Paper.java

Go to the documentation of this file.

package cedar.jetweb.model.paper;

import java.util.Vector;
import java.util.Date;
import java.util.Map;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Collection;

import java.text.DateFormat;
import java.text.SimpleDateFormat;

import java.io.BufferedReader;
import java.io.File;
import java.io.IOException;
import java.io.Serializable;
import java.io.BufferedWriter;

import java.text.NumberFormat;
import java.text.ParseException;
import java.text.DecimalFormat;

import cedar.jetweb.Storeable;
import cedar.jetweb.JetWebException;
import cedar.jetweb.JetWebConfig;
import cedar.jetweb.model.*;
import cedar.jetweb.model.plots.*;
import cedar.jetweb.model.fit.*;
import cedar.jetweb.db.DBPlotManager;
import cedar.jetweb.xml.JetWebPlotReader;
import cedar.jetweb.xml.JetWebPlotReaderFactory;


public class Paper implements Storeable {
    // Declarations
    private boolean isRealData;
    private boolean available=true;

    private double[] sumChi2;
    private double[] fitChi2;

    private int id=0;
    private String directory=null;
    private String title;
    private String reference;
    private String codeAuthor;
    private String contact;
    private int nplots=0;
    private Map<Integer,DataPlot> plots = new HashMap<Integer,DataPlot>();
    //private String htmldir=null;
    private String collaboration;
    private String accelerator;

    //Paper shouldn't need a runseries!
    //private RunSeries runSeries;

    private int irn;

    private double chi2;
    private double dof;

    // Constructors.

    public Paper(int paperId) throws JetWebException {
    this(true);
    id = paperId;
    retrieve();
    }


    public Paper(boolean realData)  {

    this.isRealData = realData;

    }

    public Paper(Paper dataPaper, Model model) throws JetWebException {

    id=dataPaper.getId();
        this.isRealData = false;

    irn = dataPaper.getIRN();
    reference = dataPaper.getReference();
    collaboration = dataPaper.getCollaboration();
    title     = dataPaper.getTitle();
    accelerator = dataPaper.getAccelerator();
    contact   = dataPaper.getContact();
    codeAuthor= dataPaper.getCodeAuthor();
    directory = dataPaper.getDirName();

    for (DataPlot compPlot : dataPaper.getPlots()){
        
        //System.out.println("instantiating predicted plot");
        try { 

        RunSeries runSeries = 
            model.getRunSeriesCollection().getRunSeries(compPlot);

        PredictedPlot plot = new PredictedPlot(compPlot,runSeries);
        //System.out.println("instantiated predicted plot");
        if (plot.hasData()){
            //System.out.println("Paper: found a plot with data "+plot.getId());
            plot.setCompPlot(compPlot);
            addPlot(plot);
        }
        } catch (JetWebException jwe) {
        // No need to do anything here. This DataPlot simply 
        // doesn't have a prediction
        // yet with this Model.     
        }
    }
    }

    // Public methods.

    public boolean retrieve() throws JetWebException {
    DBPlotManager.fillPaper(this);
    return true;
    }

    //    public RunSeries getRunSeries(){
    //return runSeries;
    //}

    public int getIRN(){
    return irn;
    }

    public void setIRN(int newirn){
    irn = newirn;
    }


    public boolean isReal(){ return isRealData; }

    public boolean isAvailable(){ return available; }

    public int getId(){ return id; }
    public void setID(int newid){ id=newid; }

    public int getSpiresId(){
    return(getIRN());
    }

    public Paper setSpiresId(int id){
    setIRN(id);
    return this;
    }

    public String getDirName(){ return directory; }
    public void setDirName(String s){ directory = s; }

    //public String getHTMLDir(){ 
    //  return htmldir; 
    //}

    public String getTitle(){return title;}
    public void setTitle(String newtitle){title = newtitle;}

    public String getCollaboration(){return collaboration;}
    public void setCollaboration(String newcollab){collaboration = newcollab;}

    public String getReference(){return reference;}
    public void setReference(String newreference){reference = newreference;}

    public String getCodeAuthor(){return codeAuthor;}
    public void setCodeAuthor(String newcodeAuthor)
    {codeAuthor = newcodeAuthor;}

    public String getContact(){return contact;}

    public String getCodeContact(){return(getContact());}

    public void setContact(String newcontact){contact = newcontact;}

    public void setCodeContact(String newcontact){
    setContact(newcontact);
    return;
    };

    public int getNPlots(){return nplots;}
    public void setNPlots(int newnplots){nplots = newnplots;}

    public Collection<? extends DataPlot> getPlots(){
    return plots.values();
    }

    public Map<Integer,? extends DataPlot> getIndexedPlots(){
    Map<Integer,DataPlot> retn = new HashMap<Integer,DataPlot>();
    retn.putAll(plots);
    return retn;
    }

    public String getAccelerator(){ return accelerator; }
    public void setAccelerator(String newaccelerator){ 
    accelerator = newaccelerator; 
    }
    public void setDirectory(String newDir){ 
    directory = newDir;
    createFileStructure();
    }

    //call this from set directory
    private void createFileStructure(){

    File dirFile = new File(JetWebConfig.rootDirectory+directory);
    if (!dirFile.exists()){
        dirFile.mkdir();
    }

    File afile = new File(directory+"/UNAVAILABLE");
    if (afile.exists()){
        available = false;
    }
    }


    public void addPlot(DataPlot plot){
    try {            
        this.plots.put(plot.getId(),plot);
    } catch (Exception e){
        System.out.println("Paper.addPlot - can't add plot id:"+plot.getId());
    }
    nplots=plots.size();
        //System.out.println("no of plots= " + plots.size());
    }

    public void setFrom(Paper paper,boolean comp) throws JetWebException {

    //System.out.println("Called Paper.setFrom");
    //Exception e = new Exception();
    //e.printStackTrace();
    //this.runSeries = paper.getRunSeries();
    this.reference = paper.getReference();
    this.collaboration = paper.getCollaboration();
    this.title = paper.getTitle();
    this.accelerator = paper.getAccelerator();
    this.id=paper.getId();
    this.contact = paper.getContact();
    this.codeAuthor = paper.getCodeAuthor();
    this.irn = paper.getIRN();
    this.directory = paper.getDirName();
        //System.out.println("im here");
        
    for (DataPlot oldplot : paper.getPlots() ){
        DataPlot plot;

        //is this paper a real data paper?
        if (isRealData){
        // looks very wasteful.
        plot = new RealPlot(oldplot.getNumber(),id);
        } else {
        // not real data
        DataPlot compPlot;
        RunSeries runSeries;
        if(oldplot instanceof PredictedPlot){
            runSeries = ((PredictedPlot)oldplot).getRunSeries();
        }else if(oldplot instanceof FittedPlot){
            Integer rsId = ((FittedPlot)oldplot).getRunSeriesId();
            runSeries = RunSeries.Maker(rsId);
        }else{
            throw new JetWebException
            ("Paper.setFrom() ERROR:"+
             "Real data plot in predicted paper", 
             "Paper id:" + id + "  plot id:" + oldplot.getId());
        }
            if (comp) { 
                compPlot = oldplot;
        } else {
            if (oldplot instanceof PredictedPlot){
            compPlot = ((PredictedPlot)oldplot).getCompPlot();
            } else if (oldplot instanceof FittedPlot){
            compPlot = ((FittedPlot)oldplot).getCompPlot();
            } else {
            throw new JetWebPlotException("Attempt to get comparison plots from real data paper","Old PaperId:"+paper.getId()+" New PaperId:"+this.getId());
            }
        }
        plot = new PredictedPlot(compPlot,runSeries);
        }
        plot.setDataPoints(oldplot.getDataPoints());
        this.addPlot(plot);
    }
    }
   
    public void add(Paper paper2) throws JetWebException {
    
    for (DataPlot one : getPlots() ){

        PredictedPlot onep = (PredictedPlot)one;
        PredictedPlot two = (PredictedPlot)paper2.getPlot(one.getId());
        onep.add(two);
    }
    }
    public DataPlot getPlot(int csnId){
    DataPlot ret = null;
    try {
        Integer i = new Integer(csnId);
        ret = (DataPlot)plots.get(i);
    } catch (Exception e){
        System.out.println("Paper.getPlot(): Attempt to retreive plot failed, plot id:"+csnId);
    }

    return ret;
    }

    public Paper fit(final Paper dataPaper, double scale, PlotSelection selection, 
              boolean scaleall) throws JetWebException {
    if (isReal()){
        throw new JetWebPlotException("Attempt to run a fit on Real Data: only valid for Predicted Data",
                      "PaperId:"+this.getId());
    }
    Paper scaled = new Paper(false);    
    boolean useOldPlots = false;
    scaled.setFrom(this,useOldPlots);

    //need to add all matching data points to the fit at this point


    scaled.sumChi2 = new double[2];
    scaled.fitChi2 = new double[2];

    Collection<? extends DataPlot> scaledPlots = scaled.getPlots();

    for (DataPlot mcPlot1 : scaledPlots){
        double chi2=0;
        PredictedPlot mcPlot = (PredictedPlot)mcPlot1;
        Vector<DataPoint> mcPoints = new Vector<DataPoint>();
        RealPlot dataPlot = (RealPlot)dataPaper.getPlot(mcPlot.getId());
        if (mcPlot.validMCProcessType()){

        if (selection.getSumPlots().contains(dataPlot) || scaleall){
            
            if (mcPlot.hasData()){
            mcPoints   = mcPlot.getDataPoints();
            
            double local_scale;
            // Shape plots never get scaled (they are ratios).
            if (mcPlot.isShape()){
                local_scale = 1;
            } else {
                local_scale = scale;
            }
            double sysScale = dataPlot.getSysScale();
            Vector<DataPoint> dataPoints = dataPlot.getDataPoints();
            
            if (mcPoints.size()!=dataPoints.size()){
                System.out.println("Error: attempt to fit unlike histograms: plot"
                           +mcPlot.getNumber()+": "+dataPoints.size()
                           +" "+mcPoints.size());
                
            } else {
                
                int missing=0;
                for (int pointnum=0; pointnum<mcPoints.size(); pointnum++){
                DataPoint mcp = (DataPoint)mcPoints.elementAt(pointnum);
                DataPoint dp = (DataPoint)dataPoints.elementAt(pointnum);
                
                // Skip points with no errors.
                if ( (mcp.getYUp()!=0.0) && 
                     (dp.getYUp()!=0.0) ){

                    // Scale the x value.
                    double error2 = Math.pow(local_scale*(mcp.getYUp()+mcp.getYDown())/2.0,2)
                    +Math.pow(sysScale*(dp.getYUp()+dp.getYDown())/2.0,2);
                    // Calculate the chi2
                    double cont = Math.pow(mcp.getY()*local_scale-sysScale*dp.getY(),2)/error2;   
                    Double testing = new Double(cont);
                    if (testing.isNaN() || testing.isInfinite()){
                    System.out.println("Error: plot"+mcPlot.getNumber());
                    System.out.println(error2+" , "+ mcp.toString()+":"+dp.toString());
                    } else {
                    chi2 = chi2+cont;
                    }
                    mcp.setY(mcp.getY()*local_scale);
                    mcp.setYUp(mcp.getYUp()*local_scale);
                    mcp.setYDown(mcp.getYDown()*local_scale);
                    mcp.setChi2(cont);
                    
                } else {
                    missing++;
                }
                }
                double[] tmp = new double[] {chi2, mcPoints.size()-missing};
                mcPlot.setChi2(tmp);
                mcPlot.setSysScale(local_scale);
            }
            } else {
            System.out.println("No data for plot");
            }
        }
        

        if (selection.getSumPlots().contains(dataPlot)){
            scaled.sumChi2[0] = scaled.sumChi2[0]+mcPlot.getChi2()[0];
            scaled.sumChi2[1] = scaled.sumChi2[1]+mcPlot.getChi2()[1];
        }
        if (selection.getFitPlots().contains(dataPlot)){
            scaled.fitChi2[0] = scaled.fitChi2[0]+mcPlot.getChi2()[0];
            scaled.fitChi2[1] = scaled.fitChi2[1]+mcPlot.getChi2()[1];
        }
        }
    }
    return scaled;
     
    }

    public boolean store() throws JetWebException {
    
    if (!this.isRealData) {
        System.out.println("Error: Attempt to write MC paper to DB");
        throw new JetWebException("Error: Attempt to write MC paper to DB",
                      "Paper ID "+id);
    }
    
    boolean paperExisted = DBPlotManager.addPaper(this);
    return !paperExisted;
    }


    public void fixFit(Fit fit) throws JetWebException{

    Map<Integer,DataPlot> fittedPlots = new HashMap<Integer,DataPlot>();
    //Iterator<DataPlot> plotList = getPlots().iterator();

    Collection<? extends DataPlot> plotList = getPlots();

    for (DataPlot plot : getPlots()){    

        try {
        FittedPlot fittedPlot = new FittedPlot((PredictedPlot)plot, fit );
        fittedPlots.put(new Integer(fittedPlot.getId()),fittedPlot);
        } catch (Exception e){
        System.out.println("Paper.fixFit() cannot add plotId:"+plot.getId());
        throw new JetWebException(e);
        }

    }
    plots = fittedPlots;
    }


    public double[] getSumChi2(){return sumChi2;}

    public double[] getFitChi2(){return fitChi2;}


    public double getChi2(int fitId){

    if (chi2>0) return chi2;
    setChi2DOF(fitId);
    return chi2;
    }
    public double getDOF(int fitId){

    if (dof>0) return dof;
    setChi2DOF(fitId);
    return dof;
    }


    private void setChi2DOF(int fitId){

    if (!isRealData) { 
        for (DataPlot plot : getPlots()){
        double[] chi2d = plot.getChi2(fitId); 
        chi2+=chi2d[0];
        dof+=chi2d[1];
        }
    }
    }

    public void delete() throws JetWebException {

    try {
        if (getPlots()!=null){
        for (DataPlot plot : getPlots() ){
            
            RealPlot rplot = (RealPlot)plot;
            rplot.delete();
            
        }
        getPlots().clear();
        }
        
        DBPlotManager.delete(this);
    } catch (Exception e) {
        throw new JetWebException(e);
    }

    }

    public boolean containsDataFor(MCProcessType proc) throws JetWebException {

    for (DataPlot plot : getPlots()) {

        if (plot.getMCProcessType().equals(proc)){
        return true;
        }
        
    }
    return false;
    }

    public boolean containsDataFor(Collision coll) throws JetWebException {

    for (DataPlot plot : getPlots()) {

        if (plot.getMCProcessType().getCollision().equals(coll)){
        return true;
        }
        
    }
    return false;
    }

}

Generated Wed Jan 17 09:14:27 GMT 2007