PlotSelection.java

Go to the documentation of this file.

package cedar.jetweb.model.plots;

import java.util.Enumeration;
import java.util.Collection;
import java.util.List;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.Vector;

import cedar.jetweb.model.Model;
import cedar.jetweb.model.MCProcessType;
import cedar.jetweb.model.paper.PaperBank;
import cedar.jetweb.model.paper.Paper;
import cedar.jetweb.JetWebConfig;
import cedar.jetweb.job.CutCollection;

import cedar.jetweb.db.DBPlotManager;
import cedar.jetweb.JetWebException;

public class PlotSelection implements Cloneable {

    private ArrayList<DataPlot> chi2SumPlots = new ArrayList<DataPlot>();
    private ArrayList<DataPlot> chi2FitPlots = new ArrayList<DataPlot>();
    private ArrayList<DataPlot> requiredPlots = new ArrayList<DataPlot>();
    protected int cssId=-1;
    private boolean initialized = false;
    
    public PlotSelection (){    }
    
    public PlotSelection (int newCssId) throws JetWebException {
    cssId=newCssId;
    }

    private void initialize() throws JetWebException {

    // Pick up the default sumplots but not the default fit plots.
    setSumDefault();
    try {
        DBPlotManager.populateSelection(this);
        
    } catch (JetWebException e){
        throw e;
    }

    // find the runseries with largest phase space (i.e. lowest PTMIN)
    // that has data for this fit and set the CutCollection of this 


    initialized = true;
    }

    public PlotSelection restrictCutCollection(CutCollection phaseSpace)
    throws JetWebException{
    restrictCutCollection(null, phaseSpace);
    //checkCuts(chi2SumPlots, null, phaseSpace);
    //checkCuts(chi2FitPlots, null, phaseSpace);

    // don't check required plots
    // because those are the plots that are necessary for a fit
    return this;
    }

    public PlotSelection restrictCutCollection
    (MCProcessType proc, CutCollection phaseSpace)
    throws JetWebException{
    if (!initialized && cssId>=0) initialize();
    checkCuts(chi2SumPlots, proc, phaseSpace);
    checkCuts(chi2FitPlots, proc, phaseSpace);
    
    return this;
    }

    private static void checkCuts(ArrayList<DataPlot> plots, 
                  MCProcessType proc, 
                  CutCollection phaseSpace){
    int ii=0;
    while(ii<plots.size()){

        boolean incr = true;
        try{
        if(plots.get(ii).getMCProcessType().equals(proc) || 
           proc==null){
            
            if(!plots.get(ii).getCutCollection().isWithin
               (phaseSpace)){

            plots.remove(ii);
            incr = false;
            }
        }
        }catch(JetWebException err){
        System.out.println
            ("PlotSelection: unable to get process type for plot " +
             plots.get(ii).getId());
        System.out.println(err.getStackTrace());
        System.out.println(err.getMessage());
        }
        if(incr) ++ii;
    }

    return;
    }

    private static void checkCuts(ArrayList<DataPlot> plots, 
                  CutCollection phaseSpace){

    int ii=0;
    while(ii<plots.size()){
        
        //if(phaseSpace.isWithin(plots.get(ii).getCutCollection())){
        if(!plots.get(ii).getCutCollection().isWithin(phaseSpace)){

        plots.remove(ii);
        }else{
        ++ii;
        }

    }
    return;
    }

    public Vector<Integer> getPlotIds() throws JetWebException{

    ArrayList<DataPlot> list = getRequiredPlots();

    Vector<Integer> ids = new Vector<Integer>();

    for(DataPlot plot: list){
        Integer id = plot.getId();
        if(!ids.contains(id)) ids.add(id);
    }

    list = getSumPlots();

    for(DataPlot plot: list){
        Integer id = plot.getId();
        if(!ids.contains(id)) ids.add(id);
    }

    list = getFitPlots();

    for(DataPlot plot: list){
        Integer id = plot.getId();
        if(!ids.contains(id)) ids.add(id);
    }

    return ids;
    }


    public ArrayList<DataPlot> getRequiredPlots()  throws JetWebException {

    if (!initialized && cssId>=0) initialize();

    if (requiredPlots.size()==0){
        // Build the required plots.
        for (DataPlot plot : chi2SumPlots){
        requiredPlots.add(plot);
        }
        for (DataPlot plot : chi2FitPlots){
        if (!requiredPlots.contains(plot)){
            requiredPlots.add(plot);
        }
        }

    }
    return requiredPlots;
    }
    public void setRequiredPlots(ArrayList<DataPlot> rp)  throws JetWebException {
    if (!initialized && cssId>=0) initialize();
    requiredPlots = rp;
    }

    public ArrayList<DataPlot> getSumPlots()  throws JetWebException {
    if (!initialized && cssId>=0) initialize();
    return chi2SumPlots;
    }
    public void setSumPlots(ArrayList<DataPlot> sp)  throws JetWebException {
    if (!initialized && cssId>=0) initialize();
        chi2SumPlots = sp;
    }
    public ArrayList<DataPlot> getFitPlots()  throws JetWebException {
    if (!initialized && cssId>=0) initialize();
    return chi2FitPlots;
    }
    public void setFitPlots(ArrayList<DataPlot> fp)  throws JetWebException {
    if (!initialized && cssId>=0) initialize();
        chi2FitPlots = fp;
    }

    public boolean isDefaultSum()  throws JetWebException { 
    if (!initialized && cssId>=0) initialize();
    boolean isDefault = false;
    PlotSelection selection = new PlotSelection();
    selection.setSumDefault();
    if (sumEquals(selection))
        isDefault = true; 
    return isDefault;
    }

    public boolean isDefaultFit()  throws JetWebException { 
    if (!initialized && cssId>=0) initialize();
    PlotSelection selection = new PlotSelection();
    selection.setFitDefault();
    return (fitEquals(selection));
    }

    public boolean isDefault()  throws JetWebException { 
    if (!initialized && cssId>=0) initialize();
    boolean isDefault = false;
    PlotSelection selection = new PlotSelection();
    selection.setSumDefault();
    selection.setFitDefault();
    if (sumEquals(selection) && fitEquals(selection))
        isDefault = true; 
    return isDefault;
    }
    

    public void setFitDefault()  throws JetWebException { 
    if (!initialized && cssId>=0) initialize();
    chi2FitPlots.clear();

    // now add the default papers to this selection.
    Collection<? extends DataPlot> list = PaperBank.getAllPlots();
    for (DataPlot plot : list){
        if (plot.isDefaultFit()) {chi2FitPlots.add(plot);}
    }
    }
    public void setSumDefault()  throws JetWebException { 

    chi2SumPlots.clear();

    // now add the default papers to this selection.
    Collection<? extends DataPlot> list = PaperBank.getAllPlots();
    for (DataPlot plot : list){
        if (plot.isDefaultSum()) {chi2SumPlots.add(plot);}
    }
    }
    

    public boolean fitEquals(PlotSelection selection)  throws JetWebException {
    if (!initialized && cssId>=0) initialize();

    //System.out.println(chi2FitPlots.size()+" , "+selection.chi2FitPlots.size());
    //System.out.println(chi2FitPlots);
    //System.out.println(selection.getFitPlots());

    return (((chi2FitPlots.size()==selection.getFitPlots().size()))
        && (chi2FitPlots.containsAll(selection.getFitPlots())));

    }
    public boolean sumEquals(PlotSelection selection)  throws JetWebException {
    if (!initialized && cssId>=0) initialize();

    boolean equals = false;

    if (((chi2SumPlots.size()==selection.getSumPlots().size()))
        && (chi2SumPlots.containsAll(selection.getSumPlots())))
        equals = true;

    return equals;
    }

    private List<Integer> makeFitPlotList(){

    List<Integer> plotList= new ArrayList<Integer>();
    for (DataPlot plot : chi2FitPlots){
        plotList.add(plot.getId());
    }

    return plotList;
    }
    private List<Integer> makeSumPlotList(){
    List<Integer> plotList= new ArrayList<Integer>();
    for (DataPlot plot : chi2SumPlots){
        plotList.add(plot.getId());
    }
    return plotList;
    }

    public int getId() throws JetWebException {

    if (cssId<0) {

        // get list of all csnIds for this plotSelection
        List<Integer> fitPlotList = makeFitPlotList();
        Iterator<Integer> cssIds = null;
        try {
        cssIds = DBPlotManager.getCSSIds((fitPlotList.get(0)).intValue(),false).iterator();
        } catch (JetWebException e){
        throw e;
        } catch (Exception e){
        throw new JetWebException(e,"Attempt to read from Empty Plot Selection");
        }
        
        boolean found = false;                          
        while (cssIds.hasNext() && !found){
        
        int localCssId = ((Integer)cssIds.next()).intValue();
        List<Integer> csnIdList = DBPlotManager.getCsnIds(localCssId,false);
        
        //test whether set of csnIds for this Plot Selection 
        // is same as set of csnIds for localCssId
        
        if ((fitPlotList.size() == csnIdList.size()) && 
            (csnIdList.containsAll(fitPlotList))){
            
            cssId = localCssId;
            found = true;
        }
        }
        
        if (!found){
        System.out.println("No matching css found");
        // No matching set found. Make a new one.
        cssId = DBPlotManager.getMaxCssId();
        //System.out.println("Max cssId is "+cssId);
        DBPlotManager.insertCrossSectionSet(fitPlotList.iterator(),++cssId);
        System.out.println("PlotSelection: Allocated cssId is "+cssId);
        }
    } 

    return cssId;
   }

    public void setSumToBest(Model model) throws JetWebException {
    if (!initialized && cssId>=0) initialize();

    chi2SumPlots.clear();

    for (Paper dataPaper : PaperBank.getPapers()){
        for (DataPlot plot : dataPaper.getPlots()){
        if (plot.isDefaultSum() && model.predicts(plot)){
            chi2SumPlots.add(plot);
        }
        }       
    }

    }


    public void setFitToBest(Model model) throws JetWebException {
    if (!initialized && cssId>=0) initialize();

    chi2FitPlots.clear();
    
    for (Paper dataPaper : PaperBank.getPapers()){
        for (DataPlot plot : dataPaper.getPlots()){
        try {
            if (plot.isDefaultFit() && model.predicts((RealPlot)plot)){
            chi2FitPlots.add(plot);
            }
        } catch (ClassCastException e){
            System.out.println("Attempt to cast RealPlot, for paper id " 
                       + dataPaper.getId() );
        }
        }
    }

    }

    public boolean isAvailable(Model model) throws JetWebException {
    if (!initialized && cssId>=0) initialize();

    for (DataPlot plot : getRequiredPlots()){
        if ( !model.predicts((RealPlot)plot) ){ return false; }
    }
    return true;
    }

    public Object clone() {

    PlotSelection ps = new PlotSelection();

    try {
        if (!initialized && cssId>=0) initialize();


        ArrayList<DataPlot> rp = (ArrayList<DataPlot>)chi2FitPlots.clone();
        ps.setFitPlots(rp);
        ArrayList<DataPlot> sp = (ArrayList<DataPlot>)chi2SumPlots.clone();
        ps.setSumPlots(sp);
        ArrayList<DataPlot> qp = (ArrayList<DataPlot>)requiredPlots.clone();
        ps.setRequiredPlots(qp);
        
        ps.cssId=cssId;
    } catch (JetWebException jwe) {
        jwe.printStackTrace(System.out);
    }

    return ps;
    }


    public void requireLatest() throws JetWebException {
    if (!initialized && cssId>=0) initialize();
    // now add the default papers to this selection.
    for (DataPlot plot: PaperBank.getAllPlots()){
        chi2FitPlots.add(plot);
    }
    }

    public void requireLatest(MCProcessType proc)  throws JetWebException {
    if (!initialized && cssId>=0) initialize();
    System.out.println("PlotSelection.requireLatest(proc) not yet implemented.");
    }

    public void requirePaper(String identifier)  throws JetWebException {
    if (!initialized && cssId>=0) initialize();

    // now add the default papers to this selection.
    for (Paper paper : PaperBank.getPapers()){
        if (paper.getDirName().equals(identifier)){
        chi2FitPlots.addAll( paper.getPlots() );
        }
    }
    }

    public boolean fitIsEmpty()  throws JetWebException {
    if (!initialized && cssId>=0) initialize();
    return (chi2FitPlots.size()==0);

    }
    public boolean sumIsEmpty()  throws JetWebException {
    if (!initialized && cssId>=0) initialize();
    return (chi2SumPlots.size()==0);

    }

    public String toString() {
    StringBuffer strbuff = new StringBuffer();
    try {
        if (!initialized && cssId>=0) initialize();
        for (DataPlot plot : getRequiredPlots()){
        strbuff.append("Plot "+plot.getId()+": "+plot.getTitle());
        strbuff.append("\n");
        }
    } catch (JetWebException jwe){
        jwe.printStackTrace(System.out);
    }
    return strbuff.toString();
    }


    public void addFitPlot(DataPlot plot){
    chi2FitPlots.add(plot);
    }

    public void clearFitPlots(){
    chi2FitPlots.clear();
    }


}// PlotSelection

Generated Wed Jan 17 09:14:27 GMT 2007