CombinedPaper.java

Go to the documentation of this file.

package cedar.jetweb.model.paper;

//import cedar.jetweb.Storeable;
import cedar.jetweb.JetWebException;
import cedar.jetweb.model.plots.*;
import cedar.jetweb.model.Model;
import cedar.jetweb.model.fit.Fit;
import cedar.jetweb.model.RunSeries;

import java.util.HashMap;
import java.util.Collection;
import java.util.Collections;
import java.util.Vector;
import java.util.Map;
public class CombinedPaper {

    private RealPaper paper_;

    //The model and fit Ids for which this paper contains plots
    private Integer modelId_ = -1;
    private Fit fit_;

    private HashMap<Integer, MergedPlot> predictedPlots_ = 
    new HashMap<Integer, MergedPlot>();

    private HashMap<Integer, FittedPlot> fittedPlots_ = 
    new HashMap<Integer, FittedPlot>();

    private Double chi2_;
    private Double dof_;

    private Boolean dirtyChi2_ = true;

    private Double scale_ = 1.0;

    public CombinedPaper(){
    
    }
    
    public CombinedPaper(RealPaper paper) throws JetWebException{
    
    paper_ = paper;
    }

    public CombinedPaper(RealPaper paper, Model model)throws JetWebException{

    paper_ = paper;
    modelId_ = model.getId();

    // now fill all the predicted plots for that model
    model.addAllRunSeries();

    for(RealPlot plot: paper.getPlots()){
        MergedPlot existingPlot = null;
        boolean foundData = false;

        for(RunSeries runseries: 
            model.getRunSeriesCollection().getRunSeriesList()){

        PredictedPlot newPlot = new PredictedPlot(plot, runseries);

        if(newPlot.hasData()){
            foundData = true;
            existingPlot = 
            predictedPlots_.get(newPlot.getId());
            if(existingPlot==null){

            existingPlot = new MergedPlot();
            }

            existingPlot.addPlot(newPlot, false);
            predictedPlots_.put(newPlot.getId(), existingPlot);
        }
        }
        if(foundData){
        existingPlot.mergePoints();
        }
    }

    }

    public CombinedPaper(CombinedPaper paper) 
    throws JetWebException{

    paper_ = paper.getRealPaper();
    fit_ = paper.getFit();
    modelId_ = paper.getModelId();
    scale_ = paper.getScale();
    chi2_ = paper.getFitChi2();
    dof_ = paper.getFitDOF();
    dirtyChi2_ = false;
    predictedPlots_ = 
        new HashMap<Integer, MergedPlot>(paper.getIndexedPredictedPlots());
    fittedPlots_ = 
        new HashMap<Integer, FittedPlot>(paper.getIndexedFittedPlots());

    }

    public CombinedPaper setFit(Fit fit){
    fit_ = fit;

    for(FittedPlot plot: fittedPlots_.values()){
        plot.setFit(fit);
    }

    dirtyChi2_ = true;

    return this;
    }

    public Fit getFit(){
    return fit_;
    }

    public Integer getModelId(){
    return modelId_;
    }

    public CombinedPaper add(PredictedPlot plot)
    throws JetWebException{
    MergedPlot existingPlot = predictedPlots_.get(plot.getId());
    if(existingPlot==null){
        existingPlot = new MergedPlot();
    }

    existingPlot.addPlot(plot);
    predictedPlots_.put(plot.getId(), existingPlot);
    dirtyChi2_ = true;
    return this;
    }

    public RealPaper getRealPaper(){
    return paper_;
    }

    public Collection<FittedPlot> getFittedPlots()
    throws JetWebException{
    
    if(fit_.getId()<0){
        fittedPlots_.clear();

        dirtyChi2_ = true;
        return fittedPlots_.values();
    }

    for(MergedPlot plot: getPredictedPlots()){
        
        FittedPlot fPlot = fittedPlots_.get(plot.getId());
        
        if(fPlot==null || 
           fPlot.getFit()==null || 
           fPlot.getFit().getId()!=fit_.getId()){

        fPlot = new FittedPlot(plot, fit_);

        //set other stuff here needed for fittedplot 
        //(not sure if there is any)

        fittedPlots_.put(plot.getId(), fPlot);
        dirtyChi2_ = true;
        }
    }

    return fittedPlots_.values();
    }

    public Collection<MergedPlot> getPredictedPlots(){
    return predictedPlots_.values();
    }

    public HashMap<Integer, MergedPlot> getIndexedPredictedPlots(){
    return predictedPlots_;
    }

    public HashMap<Integer, FittedPlot> getIndexedFittedPlots(){
    return fittedPlots_;
    }

    public Integer getNPredictedPlots(){
    return predictedPlots_.size();
    }

    public CombinedPaper setScale(Double scale){
    scale_ = scale;
    dirtyChi2_ = true;
    return this;
    }

    public Double getScale(){
    return scale_;
    }


    public Double getFitChi2(){
    return chi2_;
    }

    public Double getFitChi2(PlotSelection selection)
    throws JetWebException{

    if(!dirtyChi2_) return chi2_;
    dirtyChi2_ = false;
    Double chi2 = 0.0;

    Vector<Integer> wantedIds = selection.getPlotIds();

    for(Map.Entry<Integer, MergedPlot> entry: predictedPlots_.entrySet()){
        if(wantedIds.contains(entry.getKey())&&
           entry.getValue().hasData()){

        RealPlot realPlot = paper_.getPlot(entry.getKey());
        Double localScale = 1.0;

        if(!entry.getValue().isShape()){
            localScale = scale_;
        }

        if(realPlot!=null){
            Vector<DataPoint> mcPts = entry.getValue().getDataPoints();
            Vector<DataPoint> realPts = realPlot.getDataPoints();
            Vector<DataPoint> fPts = new Vector<DataPoint>();

            //sort the data points so they are in the same order

            Collections.sort(mcPts);
            Collections.sort(realPts);

            if(mcPts.size()==realPts.size()){
            Double sysScale = realPlot.getSysScale();
            for(Integer pntNum=0; pntNum!=mcPts.size(); ++pntNum){
                DataPoint mcPt = mcPts.get(pntNum);
                DataPoint realPt = realPts.get(pntNum);
                
                if( mcPt.getYUp()!=0.0 && 
                realPt.getYUp() !=0.0){
                
                Double errorMc = 
                    0.5 * localScale*
                    (mcPt.getYUp()+mcPt.getYDown());
                    
                Double error2 = 0.5 * sysScale *
                    (realPt.getYUp() + realPt.getYDown());

                error2 = error2 * error2;
                error2 = error2 + errorMc*errorMc;

                Double incr = mcPt.getY()*localScale - 
                    realPt.getY()*sysScale;
                incr = incr * incr / error2;
                
                if(incr.isNaN() || incr.isInfinite()){
                    System.out.println
                    ("Error: plot" + 
                     entry.getValue().getNumber());
                    System.out.println
                    (error2+" , "+ mcPt.toString()+":"+
                     realPt.toString());

                }
                
                chi2 = chi2 + incr;
                mcPt.setChi2(incr);
                DataPoint fPt = (DataPoint)mcPt.clone();
                fPt.setY(mcPt.getY()*localScale);
                fPt.setYUp(mcPt.getYUp()*localScale);
                fPt.setYDown(mcPt.getYDown()*localScale);
                fPts.add(fPt);
                }
            }
            }
            
            FittedPlot fPlot = fittedPlots_.get(entry.getKey());
            if(fPlot==null){
            fPlot = new FittedPlot(entry.getValue(), fit_);
            }
            fPlot.setDataPoints(fPts);
            fittedPlots_.put(entry.getKey(), fPlot);
        }
        }
    }

    return chi2;
    }
    public Double getFitDOF(){
    return 1.0;
    }

}

Generated Wed Jan 17 09:14:27 GMT 2007