Fit.java

Go to the documentation of this file.

package cedar.jetweb.model.fit;

import java.io.File;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;

import java.util.List;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.Collections;
import java.util.Date;
import java.util.Vector;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Map;
import java.util.Iterator;
import java.util.Collection;

import java.text.DateFormat;
import java.text.ParseException;
import java.text.DecimalFormat;

import org.apache.commons.io.FileUtils;

import cedar.jetweb.*;
import cedar.jetweb.model.plots.*;
import cedar.jetweb.model.paper.*;
import cedar.jetweb.model.*;

import cedar.jetweb.html.*;

import cedar.jetweb.db.DBFitManager;
import cedar.jetweb.db.DBPlotManager;


public class Fit implements Storeable {
    
    private Model model;
    private int modelId;
    private PlotSelection selection;
    private Map<Integer,Paper> mcPapers=new HashMap<Integer,Paper>();
    private HashMap<Integer, CombinedPaper> papers_ = 
    new HashMap<Integer, CombinedPaper>();
    private int fitId=-1;
    private boolean valid_=false;
    private Date date;
    private double bestScale;

    // If true, the fit will be updated next time it is queried.
    private boolean forceUpdate_=false;

    private double[] chi2 = {0.0, 0.0};

    public Fit(int newFitId) throws JetWebException { 

    fitId = newFitId;
    init();
    
    }

    public Fit(Model newmodel, PlotSelection newselection) 
    throws JetWebException {  

    model=newmodel;
    modelId=model.getId();

    selection=(PlotSelection)newselection.clone();
    
    init();
    
    // Check the required plots are available and get the chi2/dof for them.
    if (!selection.isAvailable(model)){

        System.out.println
        ("JM:  plot selection is not available in this model");

        throw new JetWebFitException
        ("Requested plots not available for model, Id:"
         +model.getId(),"");
    }
    
    // Find the cross section set matching this PlotSelection.
    try {
        int cssId = selection.getId();
        if (cssId<0) {
        System.out.println
            ("Error: could not allocate cross section set for this fit."+cssId);
        throw new JetWebException
            ("Error: could not allocate cross section set for this fit.","fit = "+getId());
        }
    } catch (JetWebException e) {
        System.out.println("Error: could not allocate cross section set for this fit."+e);
        throw e;
    }
    
    // There are two types of plots in the PlotSelection. Those to
    // be included int the reported Chi2 Sum, and those to be used
    // to determine the normalisation of the MC in the fit. Only
    // the latter really distinguishes two completely different
    // Fits, since the former can be easily recalculated on the
    // fly. Thus to determine whether or not this Fit has already
    // been done, we search using a PlotSelection which has the
    // "Sum" plots set to the default value, but the "Fit" plots
    // as given in the input PlotSelection.
    // 
    PlotSelection defaultSelection = new PlotSelection();
    //defaultSelection.setSumDefault();
    defaultSelection.setSumPlots(selection.getSumPlots());
    defaultSelection.setFitPlots(selection.getFitPlots());
    
    System.out.println("Successfully made fit for model "+newmodel);

    return;
    }

    public Date getDate() throws JetWebException { 
    fill();
    return date; 
    }
    public void setDate(Date d) { date = d;}
    
    public void setId(int id) { fitId = id;}
    
    public int getId(){ return fitId; }
    
    public double getScale()  throws JetWebException  { 
    fill();
    return bestScale;
    }
    public void setScale(double d){ bestScale = d;}
    
    public PlotSelection getSelection(){ return selection;}
    public Model getModel() throws JetWebException {
    
    if(getId() >= 0 ) fill();
    if (modelId<0) return null;
    try {
        if (model==null){
        model=new Model(modelId);
        }
    } catch (JetWebException e){
        throw e;
    }
    return model;
    }

    public PlotSelection getPlotSelection()  throws JetWebException {
    if(getId()>=0) fill();
    return selection;
    }

    public void setPlotSelection(PlotSelection sel){
    selection = sel;
    }

    public void setModelId(int newId){ modelId=newId;}
    public boolean isValid()  throws JetWebException { 
    fill();
    return valid_; }
    public Map<Integer,Paper> getMCPapers() throws JetWebException {

    fill();
    if (mcPapers.isEmpty()){
        populateMCPapers();
        populatePapers();
    }
    Map<Integer,Paper> retn = new HashMap<Integer,Paper>();
    retn.putAll(mcPapers);
    return retn;
    }
    
    public HashMap<Integer, CombinedPaper> getPapers() throws JetWebException{

    fill();
    if(papers_.isEmpty()){
        populatePapers();
    }
    
    HashMap<Integer, CombinedPaper> retn = 
        new HashMap<Integer, CombinedPaper>();
    
    retn.putAll(papers_);
    return retn;
    }

    private void doFit(PlotSelection defaultSumPlots) throws JetWebException {

    System.out.println("Fit: Starting fit "+fitId);

    double start     = JetWebConfig.lowScale;
    double stop      = JetWebConfig.highScale;
    double increment = JetWebConfig.scaleIncrement;
    Double chi2min = Double.POSITIVE_INFINITY;
    bestScale = 0;
    //doing the fit is much nicer with CombinedPapers.  Not used yet.
    

    while(start<=stop){
        double chi2 = 0.0;
        for(CombinedPaper paper: papers_.values()){
        paper.setScale(start);
        chi2 = chi2 + paper.getFitChi2(defaultSumPlots);
        }
        if(chi2<chi2min){
        chi2min = chi2;
        bestScale = start;

        }
        start = start + increment;
    }

    //Set the best scale for the papers and re-calculate the chi2
    //Could do this by keeping a copy of the papers when the best scale
    //is found.  Would need a deep copy of the paper and to copy the 
    //paper each time a better scale is found so may not even be
    //faster

    for(CombinedPaper paper: papers_.values()){
        paper.setScale(bestScale);
        paper.getFitChi2(defaultSumPlots);
        //papers_.put(paper.getRealPaper().getId(), paper);
    }

    Map<Integer,Paper> dataPapers = new HashMap<Integer,Paper>();
    Map<Integer,Paper> scaledPapers = new HashMap<Integer,Paper>();

    // Get the Vector of Data Papers which match these.
    for (Paper mcPaper : mcPapers.values()) {
        Paper dataPaper = PaperBank.getPaper(mcPaper.getId());
        dataPapers.put(new Integer(dataPaper.getId()),dataPaper);
    }

    while (start<=stop){

        double chi2=0;
        for (Paper mcPaper : mcPapers.values()){
        Paper dataPaper = dataPapers.get(new Integer(mcPaper.getId()));
        Paper tmpPaper  = mcPaper.fit
            (dataPaper,start,defaultSumPlots,false);
        chi2=chi2+tmpPaper.getFitChi2()[0];
        //System.out.println("chi2,scale"+chi2+","+start);
        }

        if (chi2<chi2min){
        chi2min=chi2;
        bestScale=start;
            }

        start = start+increment;

    }

    System.out.println("Have fit. Now adjust mcPapers to use the correct scale.");
    for (Paper mcPaper : mcPapers.values()){
        Paper dataPaper = dataPapers.get(new Integer(mcPaper.getId()));
        mcPaper = mcPaper.fit(dataPaper,bestScale,defaultSumPlots,true);
        mcPaper.fixFit(this);
            scaledPapers.put(new Integer(mcPaper.getId()),mcPaper);
    }

    // Replace the old mcPapers by the new ones.
    mcPapers = scaledPapers;
    System.out.println("Best scale = "+bestScale);

    }

    private void populatePapers() throws JetWebException{
    
    for(RealPaper realPaper: PaperBank.getRealPapers()){
        CombinedPaper newPaper = new CombinedPaper(realPaper, getModel());
        if(newPaper.getNPredictedPlots()!=0){ 
        papers_.put(newPaper.getRealPaper().getId(), newPaper);
        }
    }

    return;
    }

    private void populateMCPapers() throws JetWebException {

    System.out.println("Fit: Getting MC papers");

    /*
    for (Paper dataPaper : PaperBank.getPapers()){
        Paper mcPaper = null;
        mcPaper = new Paper(dataPaper,getModel());
        if (mcPaper.getPlots()!=null && mcPaper.getPlots().iterator().hasNext()){
        mcPapers.put(new Integer(mcPaper.getId()),mcPaper);
        }
    }
    */
    System.out.println("+++ populating mcpapers +++");
    mcPapers = DBPlotManager.getPredictedPapers(getModel());
    System.out.println("+++ done +++");
    return;
    }


    // Insert the fitted plots into the fitted_points and
    // fitted_prediction tables.
    private void insertPlots() throws JetWebException {

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

    //Insert plots using new CombinedPaper:

    for(Map.Entry<Integer, CombinedPaper> entry: papers_.entrySet()){
        CombinedPaper paper = entry.getValue();
        paper.setFit(this);
        for(FittedPlot plot: paper.getFittedPlots()){
        //Uncomment this line to enable storage of 
        // FittedPlots from new Combined Papers
        //plot.toDB();
        }
    }

    //using old method

    // Loop over papers.
    for (Paper mcPaper : mcPapers.values()){

        //Iterator<DataPlot> mcPlotList = mcPaper.getPlots().iterator(); 
        
        //while (mcPlotList.hasNext()){
        for (DataPlot plot : mcPaper.getPlots()){
        //FittedPlot mcPlot = (FittedPlot)mcPlotList.next();
        if(allPlots.contains(plot.getId())){
            System.out.println
            ("Saving plot "+ plot.getNumber() +
             " from paper " + mcPaper.getId());
            
            FittedPlot mcPlot = (FittedPlot)plot;
            mcPlot.setFit(this);
            mcPlot.toDB();
        }
        }
    }
    }

    private void init() throws JetWebException {

    mcPapers=new HashMap<Integer,Paper>();

    }




    public void setChi2(double[] chi2){
    this.chi2[0] = chi2[0];
    this.chi2[1] = chi2[1];
    }
    public double[] getChi2() throws JetWebException {

    fill();

    if (this.chi2[0]>0) { 
        return this.chi2; 
    } else {

        double[] chi2 = {0.0, 0.0};
        Iterator<DataPlot> plots = selection.getSumPlots().iterator();
        while (plots.hasNext()){
        DataPlot plot = plots.next();       
        chi2 = DataPlot.getChi2(plot.getId(),getId());
        this.chi2[0]+=chi2[0];
        this.chi2[1]+=chi2[1];
        }

        return this.chi2; 
    }   
    }

    public double[] getChi2(PlotSelection newSelection, MCProcessType proc) 
    throws JetWebException {

    fill();

    if (newSelection == null && proc == null){
        return getChi2();
    } else if (proc == null){

        double[] newChi2 = {0.0, 0.0};
        double[] tmpChi2 = {0.0, 0.0};
        Iterator<DataPlot> plots = newSelection.getSumPlots().iterator();
        while (plots.hasNext()){
        DataPlot plot = plots.next();       
        tmpChi2 = DataPlot.getChi2(plot.getId(),getId());
        newChi2[0]+=tmpChi2[0];
        newChi2[1]+=tmpChi2[1];
        }
        return newChi2;
    }
    

    Iterator<DataPlot> plots;
    if (newSelection == null) { 
        plots = selection.getSumPlots().iterator();
    } else {
        plots = newSelection.getSumPlots().iterator();
    }

    double[] newChi2 = {0.0, 0.0};
    double[] tmpChi2 = {0.0, 0.0};

    try {
        Vector<RunSeries> rsVector = model.getRunSeries(proc);

        while (plots.hasNext()){
        DataPlot plot = plots.next();
        Enumeration<RunSeries> rsList = rsVector.elements();
        boolean notFound = true;
        while (rsList.hasMoreElements() && notFound){
            RunSeries runSeries = rsList.nextElement();
            if (plot.isPredictedBy(runSeries)){
            tmpChi2 = DataPlot.getChi2(plot.getId(),getId());
            newChi2[0]+=tmpChi2[0];
            newChi2[1]+=tmpChi2[1];
            notFound = false;
            }       
        }       
        }
    } catch (JetWebException j) {
        System.out.println(j);
    }

    return newChi2;

    }

    public double[] getChi2(PlotSelection newSelection) throws JetWebException {

    fill();

    return getChi2(newSelection, null);
    }

    public double[] getChi2(MCProcessType proc) throws JetWebException {

    fill();
    return getChi2(null, proc);
    }

    public void zero(){
    DBFitManager.zeroFit(fitId);
    }

    public static void delete(int fitId){

    System.out.println("Fit: Removing Fit "+fitId);
    File dir = new File(JetWebConfig.rootDirectory
                +"/"+JetWebConfig.plotCacheDirName
                +"/"+fitId);
    try {
        FileUtils.deleteDirectory(dir);
        DBFitManager.deleteAll(fitId);
    } catch (Exception e) {
        System.out.println("Failed in attempt to delete fit"+e);
        e.printStackTrace();
    }
    
    }

    private void forceUpdate(){
    forceUpdate_ = true;
    valid_ = false;
    }



    public void update(boolean force) throws JetWebException {
    
    try {
        
        System.out.println("Fit: Deleting graphics Files ");
        File dir = new File(JetWebConfig.rootDirectory+"/"
                +"/"+JetWebConfig.plotCacheDirName
                +"/"+fitId);
        FileUtils.deleteDirectory(dir);

        //fit = new Fit(fitId);
        this.forceUpdate();
        fill();
    } catch (JetWebException e) {
        System.out.println("Failed in attempt to force update: "+e);
        e.printStackTrace();
        throw e; 
    } catch (IOException e) {
        System.out.println("Failed in attempt to force update: "+e);
        e.printStackTrace();
        throw new JetWebException(e); 
    }
    }

    public boolean retrieve() throws JetWebException {

    String result = DBFitManager.selectFromDB(this);    

    boolean uptodate = result.equals(DBFitManager.SUCCESS);
    System.out.println(result);
    return uptodate;
    }

    public synchronized boolean store() throws JetWebException {

    if (!valid_) {
        throw new JetWebException("Attempt to store invalid fit!","ID:"+getId());
    }

    System.out.println("Storing fit");

    boolean existed = (getId()>0);

    System.out.println("Fit ID = "+getId());
    System.out.println("fit already existed = "+existed);

    // If a row existed before. Delete it, and everything
    // associated with it.

    if (existed) DBFitManager.deleteAll(getId());
    // If this fails, the fitId will be set to 0

    DBFitManager.addFit(this);

    if (fitId!=0){

        System.out.println("inserting plots");

        // Insert the plots.
        insertPlots();

    } else {
        throw new JetWebException("Fit.store:Error determining fitId! "
                      ,"ModelId="+model.getId()
                      +", PlotSelection="+selection.getId());
    }

    System.out.println("returning from store method");


    return existed;
    }





    public static List<Fit> getFits( final ResultSearchPattern pattern, 
                     final PlotSelection selection, 
                     final String sort ) throws JetWebException {

    List<Fit> fitList = new ArrayList<Fit>();

    System.out.println("Fit: Looking for models for "+pattern.getGenerator());

    // Build a list of Models which are consistent with this ResultSearchPattern
    Collection<Model> modelList = pattern.getConsistentModels();
    
    // Build Fits from the models and the cross section set.
    for (Model model : modelList){
        try {
        Fit fit = new Fit(model, selection);
        if (fit.isValid()) { fitList.add(fit); }
        } catch (JetWebFitException e) { 
        // Come here if the required plots aren't available.
        System.out.println("Fit: found a model, but with insufficient data.");
        }
    }

    //sort the fitList according to the "sort" input
    Comparator listSort = new Comparator() {
        public int compare(Object o1, Object o2) {
            Fit j1 = (Fit)o1; 
            Fit j2 = (Fit)o2; 
            Model m1 =null;
            Model m2 =null;
            try {
            m1 = j1.getModel();
            } catch (JetWebException e){
            return -1;
            }
            try {
            m2 = j2.getModel();
            } catch (JetWebException e){
            return 1;
            }
            int sortResult=0;
            try {
            if (sort.equals(HTMLUtils.PTHAT)){
                sortResult = m2.getPthat().compareTo(m1.getPthat());
            } else if (sort.equals(HTMLUtils.DATE)){
                sortResult = j1.getDate().compareTo(j2.getDate());

            /*
            } else if (sort.equals(HTMLUtils.CHI2ALL)){
            CutBand band1 = (CutBand)j1.bands.get(CutBand.ALL);
            CutBand band2 = (CutBand)j2.bands.get(CutBand.ALL);
            sortResult = (new Double(band2.getChi2Total()/band2.getDOFTotal()))
                .compareTo((new Double(band1.getChi2Total()/band1.getDOFTotal())));
            } else if (sort.equals(HTMLUtils.CHI2HIGH)){
            CutBand band1 = (CutBand)j1.bands.get(CutBand.HI);
            CutBand band2 = (CutBand)j2.bands.get(CutBand.HI);
            sortResult = (new Double(band2.getChi2Total()/band2.getDOFTotal()) )
                .compareTo((new Double(band1.getChi2Total()/band1.getDOFTotal())));
            } else if (sort.equals(HTMLUtils.CHI2LOW)){
            CutBand band1 = (CutBand)j1.bands.get(CutBand.LO);
            CutBand band2 = (CutBand)j2.bands.get(CutBand.LO);
            sortResult = (new Double(band2.getChi2Total()/band2.getDOFTotal()) )
                .compareTo((new Double(band1.getChi2Total()/band1.getDOFTotal())));
            } else if (sort.equals(HTMLUtils.CHI2SHAPE)){
            CutBand band1 = (CutBand)j1.bands.get(CutBand.SHAPE);
            CutBand band2 = (CutBand)j2.bands.get(CutBand.SHAPE);
            sortResult = (new Double(band2.getChi2Total()/band2.getDOFTotal()) )
                .compareTo((new Double(band1.getChi2Total()/band1.getDOFTotal())));
            } else if (sort.equals(HTMLUtils.CHI2CHARM)){
            CutBand band1 = (CutBand)j1.bands.get(CutBand.CHARM);
            CutBand band2 = (CutBand)j2.bands.get(CutBand.CHARM);
            sortResult = (new Double(band2.getChi2Total()/band2.getDOFTotal()) )
                .compareTo((new Double(band1.getChi2Total()/band1.getDOFTotal())));

            } else if (sort.equals(HTMLUtils.CHI2ALLEP)){
            CutBand band1 = (CutBand)j1.bands.get(CutBand.ALL);
            CutBand band2 = (CutBand)j2.bands.get(CutBand.ALL);
            sortResult = (new Double(band2.getChi2Ep()/band2.getDOFEp()))
                .compareTo((new Double(band1.getChi2Ep()/band1.getDOFEp())));
            } else if (sort.equals(HTMLUtils.CHI2HIGHEP)){
            CutBand band1 = (CutBand)j1.bands.get(CutBand.HI);
            CutBand band2 = (CutBand)j2.bands.get(CutBand.HI);
            sortResult = (new Double(band2.getChi2Ep()/band2.getDOFEp()) )
                .compareTo((new Double(band1.getChi2Ep()/band1.getDOFEp())));
            } else if (sort.equals(HTMLUtils.CHI2LOWEP)){
            CutBand band1 = (CutBand)j1.bands.get(CutBand.LO);
            CutBand band2 = (CutBand)j2.bands.get(CutBand.LO);
            sortResult = (new Double(band2.getChi2Ep()/band2.getDOFEp()) )
                .compareTo((new Double(band1.getChi2Ep()/band1.getDOFEp())));
            } else if (sort.equals(HTMLUtils.CHI2SHAPEEP)){
            CutBand band1 = (CutBand)j1.bands.get(CutBand.SHAPE);
            CutBand band2 = (CutBand)j2.bands.get(CutBand.SHAPE);
            sortResult = (new Double(band2.getChi2Ep()/band2.getDOFEp()) )
                .compareTo((new Double(band1.getChi2Ep()/band1.getDOFEp())));
            } else if (sort.equals(HTMLUtils.CHI2CHARMEP)){
            CutBand band1 = (CutBand)j1.bands.get(CutBand.CHARM);
            CutBand band2 = (CutBand)j2.bands.get(CutBand.CHARM);
            sortResult = (new Double(band2.getChi2Ep()/band2.getDOFEp()) )
                .compareTo((new Double(band1.getChi2Ep()/band1.getDOFEp())));

            } else if (sort.equals(HTMLUtils.CHI2ALLEE)){
            CutBand band1 = (CutBand)j1.bands.get(CutBand.ALL);
            CutBand band2 = (CutBand)j2.bands.get(CutBand.ALL);
            sortResult = (new Double(band2.getChi2Ee()/band2.getDOFEe()))
                .compareTo((new Double(band1.getChi2Ee()/band1.getDOFEe())));
            } else if (sort.equals(HTMLUtils.CHI2HIGHEE)){
            CutBand band1 = (CutBand)j1.bands.get(CutBand.HI);
            CutBand band2 = (CutBand)j2.bands.get(CutBand.HI);
            sortResult = (new Double(band2.getChi2Ee()/band2.getDOFEe()) )
                .compareTo((new Double(band1.getChi2Ee()/band1.getDOFEe())));
            } else if (sort.equals(HTMLUtils.CHI2LOWEE)){
            CutBand band1 = (CutBand)j1.bands.get(CutBand.LO);
            CutBand band2 = (CutBand)j2.bands.get(CutBand.LO);
            sortResult = (new Double(band2.getChi2Ee()/band2.getDOFEe()) )
                .compareTo((new Double(band1.getChi2Ee()/band1.getDOFEe())));
            } else if (sort.equals(HTMLUtils.CHI2SHAPEEE)){
            CutBand band1 = (CutBand)j1.bands.get(CutBand.SHAPE);
            CutBand band2 = (CutBand)j2.bands.get(CutBand.SHAPE);
            sortResult = (new Double(band2.getChi2Ee()/band2.getDOFEe()) )
                .compareTo((new Double(band1.getChi2Ee()/band1.getDOFEe())));
            } else if (sort.equals(HTMLUtils.CHI2CHARMEE)){
            CutBand band1 = (CutBand)j1.bands.get(CutBand.CHARM);
            CutBand band2 = (CutBand)j2.bands.get(CutBand.CHARM);
            sortResult = (new Double(band2.getChi2Ee()/band2.getDOFEe()) )
                .compareTo((new Double(band1.getChi2Ee()/band1.getDOFEe())));

            } else if (sort.equals(HTMLUtils.CHI2ALLPP)){
            CutBand band1 = (CutBand)j1.bands.get(CutBand.ALL);
            CutBand band2 = (CutBand)j2.bands.get(CutBand.ALL);
            sortResult = (new Double(band2.getChi2Pp()/band2.getDOFPp()))
                .compareTo((new Double(band1.getChi2Pp()/band1.getDOFPp())));
            } else if (sort.equals(HTMLUtils.CHI2HIGHPP)){
            CutBand band1 = (CutBand)j1.bands.get(CutBand.HI);
            CutBand band2 = (CutBand)j2.bands.get(CutBand.HI);
            sortResult = (new Double(band2.getChi2Pp()/band2.getDOFPp()) )
                .compareTo((new Double(band1.getChi2Pp()/band1.getDOFPp())));
            } else if (sort.equals(HTMLUtils.CHI2LOWPP)){
            CutBand band1 = (CutBand)j1.bands.get(CutBand.LO);
            CutBand band2 = (CutBand)j2.bands.get(CutBand.LO);
            sortResult = (new Double(band2.getChi2Pp()/band2.getDOFPp()) )
                .compareTo((new Double(band1.getChi2Pp()/band1.getDOFPp())));
            } else if (sort.equals(HTMLUtils.CHI2SHAPEPP)){
            CutBand band1 = (CutBand)j1.bands.get(CutBand.SHAPE);
            CutBand band2 = (CutBand)j2.bands.get(CutBand.SHAPE);
            sortResult = (new Double(band2.getChi2Pp()/band2.getDOFPp()) )
                .compareTo((new Double(band1.getChi2Pp()/band1.getDOFPp())));
            } else if (sort.equals(HTMLUtils.CHI2CHARMPP)){
            CutBand band1 = (CutBand)j1.bands.get(CutBand.CHARM);
            CutBand band2 = (CutBand)j2.bands.get(CutBand.CHARM);
            sortResult = (new Double(band2.getChi2Pp()/band2.getDOFPp()) )
                .compareTo((new Double(band1.getChi2Pp()/band1.getDOFPp())));
            */

            }
            } catch (NumberFormatException e){
            System.out.println("Fit: number format exception in sorting of results by " 
                       + sort);
            } catch (JetWebException e1){
            System.out.println("Fit: JetWebException thrown " 
                       + sort);
            e1.printStackTrace(System.out);
            } catch (NullPointerException e2){
            System.out.println("Fit:NullPointerException in sorting of results by " 
                       + sort);
            e2.printStackTrace(System.out);
            System.out.println("Fit ID 1:"+j1.getId());
            System.out.println("Fit ID 2:"+j2.getId());
            }
            return -1*sortResult;
        }
    };
    
    Collections.sort(fitList,listSort);
    return fitList;

    }


    public static Vector<Fit> getFits(Model model) throws JetWebException {

    return DBFitManager.select(model);

    }

    //
    // This method is invoked automatically when any get method for the
    // the fit is invoked. It  
    // 
    private void fill() throws JetWebException {

    if (valid_) {return;}

    // Search DB for a fit either with this id, or associated with
    // this model and cross section set.  Regenerate the fit if
    // data has been added to the model since the fit was last
    // remade.  
    boolean uptodate = retrieve();

    valid_=true;

    System.out.println("Fit "+fitId+" up to date? "+uptodate);

    if ( !uptodate || forceUpdate_ ){

        forceUpdate_=false;

        // (Re)do the fit.
        populateMCPapers();
        populatePapers();

        doFit(selection);

        // store it
        store();

        // (Re)write the graphics files
        HTMLPaperWriter.writeGraphics(mcPapers,this);
    }
    } 
}

Generated Wed Jan 17 09:14:27 GMT 2007