Hepreac.java

Go to the documentation of this file.

package cedar.hepdata.webapp.pages;

import cedar.hepdata.model.*;
import cedar.hepdata.xml.*;
import cedar.hepdata.db.*;

import org.apache.tapestry5.annotations.*;
import org.apache.tapestry5.ioc.annotations.*;
import org.apache.tapestry5.services.*;

import org.hibernate.*;
import org.hibernate.criterion.*;
import java.util.*;

import java.awt.image.BufferedImage;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.List;

import org.apache.tapestry5.ComponentResources;
import org.apache.tapestry5.Link;
import org.apache.tapestry5.MarkupWriter;
import org.apache.tapestry5.StreamResponse;
import org.apache.tapestry5.annotations.*;
import org.apache.tapestry5.ioc.annotations.*;
import org.apache.tapestry5.annotations.*;
import org.apache.tapestry5.ioc.annotations.*;
import org.apache.tapestry5.ioc.services.TypeCoercer;
import org.apache.tapestry5.dom.Element;
import org.apache.tapestry5.services.Response;
import org.jfree.chart.ChartUtilities;
import org.jfree.chart.JFreeChart;
import org.jfree.chart.title.TextTitle;
import org.jfree.data.xy.*;

import org.jfree.chart.JFreeChart;
import org.jfree.chart.axis.NumberAxis;
import org.jfree.chart.axis.ValueAxis;
import org.jfree.chart.axis.LogarithmicAxis;
import org.jfree.chart.plot.XYPlot;
import org.jfree.chart.renderer.xy.XYErrorRenderer;
import org.jfree.chart.renderer.xy.XYItemRenderer;
import org.jfree.data.xy.XYIntervalSeries;
import org.jfree.data.xy.XYIntervalSeriesCollection;
import org.jfree.data.Range;


public class Hepreac{

    @Inject
    private RequestGlobals _reqGlobals;

    @Inject
    private org.hibernate.Session _session;

   
    public String getPath(){
       return _reqGlobals.getRequest().getPath();
    }
    public String getContextPath(){
       return _reqGlobals.getRequest().getContextPath();
    }

    public String getTestPath(){
        return getPath().substring(getPath().lastIndexOf("/")+1); 
    }    

    public String getQueryParam(String param){
       return _reqGlobals.getRequest().getParameter(param);
    }

    
//Papers
    private Paper _paper;
    public Paper getPaper() { return _paper; }
    public void setPaper(Paper p) { _paper = p; }
   
    public List <Paper> getPapers(){
        Query q = constructQuery();
        // execute the query and return the list of results
        return q.list();   
    }

//Datasets
    private Dataset _dataset;
    public Dataset getDataset() { return _dataset; }
    public void setDataset(Dataset d) { _dataset = d; }
    public SortedSet <Dataset> getDatasets(){
        return _paper.getDatasets();
    }

//YAxes
    static private YAxis _yaxis;
    public YAxis getYAxis() { return _yaxis; }
    public void setYAxis(YAxis y) { _yaxis = y; }
    public SortedSet <YAxis> getYAxes(){
        return _dataset.getYAxes();
    }




//-----------------------------------------ConstrucQuery()
    private Query constructQuery(){
        System.out.println("path is: " + getPath());
        
        String s0 = getPath().substring(getPath().indexOf("/")+1);
        String s1 = s0.substring(s0.indexOf("/")+1);
        String theIrn="";
        if(s1.indexOf("/") < 0 ){theIrn = s1;}
        else                    {theIrn = s1.substring(0,s1.indexOf("/"));}
        
  //      String theIrn=getPath().substring(getPath().lastIndexOf("/")+1); 
 
        Query q = null;

        // the string buffer way!!
        StringBuffer b = new StringBuffer();

        // assuming a spiresid search first 
        b.append("select distinct p from Paper p where p._spiresId = :irn"); 
        q = _session.createQuery(b.toString());
        q.setString( "irn",theIrn);
        // return the list of results
        return q;

    }
        
//-----------------------------------------getFirstAuthorName
   public String getFirstAuthorName(){
       ckbxs.put(0,false);
       int n = 0;
       String _firstauthor = "";
       for (String author : _paper.getAuthors()){
         n += 1;
         if(n == 1) {_firstauthor = author;}
       }
       String _refdate = "xx";
       for (Reference reference : _paper.getReferences()){
          _refdate = reference.getDate();
       }
        int _lref = _refdate.length();
       _firstauthor = _firstauthor + " " + _refdate.substring(_lref-2,_lref);
       return _firstauthor;
   }
//-----------------------------------------getFirstExperimentName
   public String getFirstExperimentName(){
       int n = 0;
       String _firstexperiment = "";
       for (Experiment experiment : _paper.getExperiments()){
           n += 1;
           if(n == 1) { _firstexperiment = experiment.getName();}
       }
       return _firstexperiment;
   }
//-----------------------------------------getFirstInformalName
  public String getFirstInformalName(){
       int n = 0;
       String _firstinformal = "";
       for (Experiment experiment : _paper.getExperiments()){
           n += 1;
           if(n == 1) { _firstinformal = experiment.getInformalName();}
       }
       return _firstinformal;
   }
//-----------------------------------------geFirsttPublished
   public String getFirstPublished(){
       int n = 0;
       String _firstpublished = "Not Published";
       for (Reference ref : _paper.getReferences()){
           String refdesc = ref.getDescription();
           if(ref.getType().equals("JOUR")){
                 n += 1;
                 if(n == 1) { _firstpublished = refdesc;}
           }
       }
       return _firstpublished;
   }
//-----------------------------------------getFirstPreprint
   public String getFirstPreprint(){
       int n = 0;
       String _firstpreprint= "Not Known";
       System.out.println("number of references:" + _paper.getReferences().size());
       for (Reference ref : _paper.getReferences()){
           String refdesc = ref.getDescription();
           if(!ref.getType().equals("JOUR")){
                 n += 1;
                 if(n == 1) { _firstpreprint = refdesc;}
             
           }
       }
       return _firstpreprint;
   }
   
 //-----------------------------------------getTitle
  public String getTitle(){
       return _paper.getTitle();
   }    
   
   private Map <Integer,Boolean> ckbxs = new HashMap();
   static private int _maxmap = 0; 
   @Persist
   private boolean ckbx;       
   private int _nloop = -1;
   public boolean isCkbx(){ 
       _nloop += 1;
       if(_nloop > _maxmap){ _nloop=0;} 
       System.out.println("calling isCkbx" + _nloop); 
       return ckbxs.get(_nloop); 
    }
    public void setCkbx(boolean ckbx){
       _nloop += 1;
       if(_nloop > _maxmap){ _nloop=0;} 
       ckbxs.put(_nloop,ckbx); 
       System.out.println("calling setCkbx" + _nloop); 
    }   
// now for the plotting stuff    
    @Inject 
    private ComponentResources _resources;
    
    
    static private int numberRun = 0;
    static private HashMap seriesMap = new HashMap();
    static private HashMap xLabelMap = new HashMap();
    static private HashMap yLabelMap = new HashMap();
    static private HashMap commentMap = new HashMap();
    static private String titlestring = "Title:";

 //-----------------------------------------getChart3()
    public Link getChart3(){          
        if (numberRun > 10000) {
            numberRun=0;
        }
        numberRun +=1;
        XYIntervalSeries series1 = getDataSeries(_yaxis);
        seriesMap.put(numberRun,series1);
        xLabelMap.put(numberRun,_yaxis.getDataset().getXAxis(1).getHeader());
        yLabelMap.put(numberRun,_yaxis.getHeader());
       return _resources.createActionLink("chart", false, new Object[]{"400","400",numberRun,"1"});
    }

//-----------------------------------------getDataSeries(YAxis yaxis)
    public XYIntervalSeries getDataSeries(YAxis yaxis){
        XAxis _xaxis =  yaxis.getDataset().getXAxis(1);
//      System.out.println(_xaxis.toString());
        for (String comment : yaxis.getDataset().getComments()){
            System.out.println(comment);
            titlestring = comment;
        }
        XYIntervalSeries series = new  XYIntervalSeries("data1");
        for (int ip=1; ip<=yaxis.getPoints().size(); ip++){
            try{
            double y = yaxis.getPoint(ip).getValue();
            double eplus = 0.0;
            double eminus = 0.0;
            for (Uncertainty e : yaxis.getPoint(ip).getErrors()){
               if(e.getNormType() == ErrorNorm.PCT){
                 eplus = eplus + (y*e.getPlus()/100.0)*(y*e.getPlus()/100.0);
                 eminus = eminus + (y*e.getMinus()/100.0)*(y*e.getMinus()/100.0);
               } 
               else{
                 eplus = eplus + e.getPlus()*e.getPlus(); 
                 eminus = eminus - e.getMinus()*e.getMinus();
               }
            }
            eplus = Math.sqrt(eplus);
            eminus = Math.sqrt(eminus);
            double yhigh = y + eplus;
            double ylow = y - eplus;
            double x;
            double xhigh;
            double xlow;
            if(_xaxis.getBin(ip).getLowValue() != null  && _xaxis.getBin(ip).getHighValue() != null){
                x = (_xaxis.getBin(ip).getLowValue()+_xaxis.getBin(ip).getHighValue())/2;
                xlow =  _xaxis.getBin(ip).getLowValue();
                xhigh =  _xaxis.getBin(ip).getHighValue();
            }
            else{
                x = _xaxis.getBin(ip).getFocus();
                xhigh = _xaxis.getBin(ip).getFocus();
                xlow = _xaxis.getBin(ip).getFocus();
            }
            series.add(x,xlow,xhigh,y,ylow,yhigh);
            } catch(Exception e){}
        }
        return series;
    }
        
//-----------------------------------------onChart(..................)
    public StreamResponse onChart(final int width, final int height, final int numberRun, int number){
 
        final XYIntervalSeriesCollection collection = new XYIntervalSeriesCollection();
        double xlow = 1000000.0;
        double xhigh = -1000000.0;
        double ylow = 1000000.0;
        double yhigh = -1000000.0;
        for (int n=0; n<number; n++){
            
            XYIntervalSeries series = (XYIntervalSeries) seriesMap.get(numberRun+n);
            int nitems = series.getItemCount();
            for (int nn=0; nn<nitems; nn++){
              if(series.getXLowValue(nn) < xlow){ xlow = series.getXLowValue(nn);};     
              if(series.getXHighValue(nn) > xhigh){ xhigh = series.getXHighValue(nn);};     
              if(series.getYLowValue(nn) < ylow){ ylow = series.getYLowValue(nn);};     
              if(series.getYHighValue(nn) > yhigh){ yhigh = series.getYHighValue(nn);};     
            }
            seriesMap.remove(numberRun+n);
            collection.addSeries(series);
        }
        xlow = xlow - 0.05*(xhigh-xlow);
        xhigh = xhigh + 0.05*(xhigh-xlow);
        ylow = ylow - 0.05*(yhigh-ylow);
        yhigh = yhigh + 0.05*(yhigh-ylow);
        if(xlow == xhigh){
              xlow = 0.90*xlow;
              xhigh= 1.10*xhigh;
        }
        IntervalXYDataset data1 = collection;
 
        final XYItemRenderer renderer1 = new XYErrorRenderer();
        final Range rangex = new Range(xlow,xhigh);
        final Range rangey = new Range(ylow,yhigh);
        final NumberAxis rangeAxisX = new NumberAxis();
        try {
              String xlabel = (String) xLabelMap.get(numberRun);
              rangeAxisX.setLabel(xlabel);
        } 
        catch(Exception e){          
           rangeAxisX.setLabel("xaxis label ?");
        }
        rangeAxisX.setRange(rangex);
//        rangeAxisX.setAutoRangeIncludesZero(false);
        final NumberAxis rangeAxisY = new NumberAxis();
        try{
            String ylabel = (String) yLabelMap.get(numberRun);
            rangeAxisY.setLabel(ylabel);
        }
        catch (Exception e){
             rangeAxisY.setLabel("yaxis label ?");
       }
        rangeAxisY.setRange(rangey);
//        final LogarithmicAxis rangeAxisY = new LogarithmicAxis(_yaxis.getHeader());
//        rangeAxisY.setAllowNegativesFlag(true);
//        rangeAxisY.setStrictValuesFlag(false);
//        rangeAxisY.setAutoRangeNextLogFlag(true);
        final XYPlot subplot1 = new XYPlot(data1, rangeAxisX, rangeAxisY, renderer1);
        final TextTitle title = new TextTitle(titlestring);
        final JFreeChart chart = new JFreeChart(subplot1);
        chart.addSubtitle(title);
        return new StreamResponse(){
            public String getContentType(){
                return "image/jpeg";
            }
            public InputStream getStream() throws IOException {
                BufferedImage image  = chart.createBufferedImage(width, height);
                ByteArrayOutputStream byteArray = new ByteArrayOutputStream() ;
                ChartUtilities.writeBufferedImageAsJPEG(byteArray, image) ;
                return new ByteArrayInputStream(byteArray.toByteArray());
            }
            public void prepareResponse(Response response){}
        };
    }
//---------------------------------------end of onChart(..................)
}

---