DataPlot.java

Go to the documentation of this file.

package cedar.jetweb.model.plots;


import java.io.Serializable;
import java.io.File;

import java.util.Vector;
import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.Iterator;

import java.text.DecimalFormat;

import cedar.jetweb.*;
import cedar.jetweb.model.paper.PaperBank;
import cedar.jetweb.model.MCProcessType;
import cedar.jetweb.model.RunSeries;
import cedar.jetweb.model.Collision;
import cedar.jetweb.generator.Generator;
import cedar.jetweb.db.DBPlotManager;

import cedar.jetweb.job.CutCollection;

public abstract class DataPlot implements Serializable {
    public static final String REAL = DBPlotManager.REAL;
    public static final String PREDICTED = DBPlotManager.PREDICTED;
    public static final String FITTED = DBPlotManager.FITTED;

    // Declarations.
    protected double sysScale=1.0;
    protected int number;
    protected String title = "No title";

    protected int collisionId;
    protected int procIdWanted;

    protected CutCollection cuts_;

    protected Vector<DataPoint> dataPoints;
    //private HashSet unSynch = new HashSet(); 
    //protected HashSet switches = (HashSet)Collections.synchronizedSet(unSynch);
    HashSet<PlotSwitch> switches = 
    new HashSet<PlotSwitch>(Collections.synchronizedSet(new HashSet<PlotSwitch>()));

    protected int paperId;

    protected double[] chi2 = new double[]{0,0};


    protected double ecms;

    protected int csnId=-1;
    protected boolean hasdata = false;
    protected boolean shape;
    protected MCProcessType proc;
    
    private DecimalFormat form = new DecimalFormat("0.00");
    private boolean defFit;
    private boolean defSum;
    private int nDataSources=1;
    private boolean logarithmic;
    private String ylabel = " ";
    private String xlabel = " ";

    //accessors
    public int getId(){ return csnId; }

    public void setId(int newId){ csnId = newId; }

    public int getNumber(){ return number; }

    public void setNumber(int newnum){ number = newnum; }

    public CutCollection getCutCollection(){
    return cuts_;
    }

    public DataPlot setCutCollection(CutCollection cuts){
    cuts_ = cuts;
    return this;
    }

    public double getSysScale(){ return sysScale; }
    public void setSysScale(double scale){ sysScale=scale; }

    public boolean isDefaultFit(){ return defFit; }
    public void setDefaultFit(boolean isit){ defFit = isit; }

    public boolean isDefaultSum(){ return defSum; }
    public void setDefaultSum(boolean isit){ defSum = isit; }

    public boolean isLogarithmic(){ return logarithmic; }
    public void setLogarithmic(boolean b){ logarithmic = b; }

    public boolean isShape(){ return shape; }
    public void setShape(boolean isit){ shape = isit; }


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


    public String getYLabel(){
    return ylabel;
    }
    public void setYLabel(String newlabel){
    ylabel = newlabel;
    }
    public String getXLabel(){
    return xlabel;
    }
    public void setXLabel(String newlabel){
    xlabel = newlabel;
    }

    public boolean hasData() throws JetWebException { return hasdata; }
    public void setHasData(boolean b){ hasdata = b; }

    public Vector<DataPoint> getDataPoints() throws JetWebException {
    if (dataPoints==null){
        dataPoints = DBPlotManager.getDataPoints(this);
    }
    return dataPoints;
    }
    public void setDataPoints(Collection<DataPoint> newDataPoints){
    
    dataPoints = new Vector<DataPoint>();
    
    for (DataPoint point : newDataPoints) {

        try{
        dataPoints.add((DataPoint)point.clone() );
        } catch (ClassCastException e){
        System.out.println("Invalid Point Data sent to DataPlot.setDataPoints");
        }
    }

    if (dataPoints.isEmpty()){
        System.out.println("No data for plot " + number + ":" + title);
        hasdata=false;
    } else {
        hasdata=true;
    }
    
    }
    //public methods
    public double getYMin(){
    
    double min = 1000000;
        for (DataPoint point : dataPoints) {
        if (point.getY()<min){min=point.getY();} 
    }
    return min*getSysScale();
    }

    public double getYMinNonZero(){
    
    double min = 1000000;
    for (DataPoint point : dataPoints) {
        if (point.getY()<min && point.getY()>0){min=point.getY();} 
    }
    return min*getSysScale();
    }

    public double getYMax(){
    
    double max = -1000000;
    for (DataPoint point :  dataPoints){
        if (point.getY()>max) {max=point.getY();} 
    }
    return max*getSysScale();
    }



    public void setFrom(DataPlot plot){

    setDefaultFit(plot.isDefaultFit());
    setDefaultSum(plot.isDefaultSum());
    setLogarithmic(plot.isLogarithmic());
    setTitle(plot.getTitle());
    setYLabel(plot.getYLabel());
    setXLabel(plot.getXLabel());
    setId(plot.getId());
    setNumber(plot.getNumber());
    setSysScale(plot.getSysScale());
        setChi2(plot.getChi2());
        setShape(plot.isShape());
        setCollisionId(plot.getCollisionId());
        setPaperId(plot.getPaperId());
    /*
    try {
        proc=plot.getMCProcessType();
    } catch (JetWebException jwe) {
        System.out.println("ALARM!");
        jwe.printStackTrace(System.out);
    }
    */
    }


    public boolean populateDBData() throws JetWebException {
    dataPoints = DBPlotManager.getDataPoints(this);
    if (dataPoints.isEmpty()){
        hasdata = false;
        System.out.println("No data for plot " + number + ":" + title);
    } else {
        hasdata = true;
    }
    return hasdata;
    }

    public void zero(){

    System.out.println("Called zero on plot "+getId());

    // loop over the dataPoints.
    for (DataPoint point : dataPoints){
        point.setYUp(0);
        point.setYDown(0);
        point.setY(0);
    }
    }


    public boolean isPredictedBy(RunSeries rs){
    try {
        return (DBPlotManager.plotExists(this,rs));
    } catch (JetWebException j) {
        System.out.println(j);
        return false;
    }
    }

    public Iterator<PlotSwitch> getSwitches() throws JetWebException {

    HashSet<PlotSwitch> tmp = DBPlotManager.getSwitches(csnId);

    if (switches==null) {
        switches = tmp;
    } else {
        Iterator<PlotSwitch> en = tmp.iterator();
        while (en.hasNext()){
        addSwitch(en.next());
        }
    }
    return switches.iterator();

    }
    public void addSwitch(PlotSwitch ps) {

    /*
    Iterator psl = switches.iterator();
    while (psl.hasNext()){
        if (ps.equals((PlotSwitch)psl.next())){
        return;
        }
    }
    */
    switches.add(ps);
    }

    public void deleteSwitch(PlotSwitch ps) throws JetWebException {

    if (switches.contains(ps)) {
        switches.remove(ps);
    }
    DBPlotManager.delete(ps);

    }

    public double getCMEnergy() { return ecms; }
    public void setCMEnergy(double e) { ecms = e; }

    public void setPaperId(int newPaperId){
    paperId = newPaperId;
    }

    public int getPaperId(){ return paperId; }

    public void storeSwitches() throws JetWebException {

    // Get all the switches for the plot in memory. 
    Iterator<PlotSwitch> psws = getSwitches();
    while (psws.hasNext()){
        PlotSwitch ps = (PlotSwitch)psws.next();
        ps.store();
    }
    }

     public double[] getChi2(){
     return chi2;
     }


    public void setChi2(double[] newchi2){ 
    if (newchi2.length==2){
        chi2[0]=newchi2[0]; 
        chi2[1]=newchi2[1]; 
    } else {
        System.out.println("invalid Chi2 array - DataPlot.setChi2()");
    }
    }


    public int getCollisionId(){ return collisionId; }

    public void setCollisionId(int id){ collisionId = id; }


    public abstract int getProcIdWanted() throws JetWebException;

    public abstract MCProcessType getMCProcessType() throws JetWebException ;

    public static double[] getChi2(int plotId, int fitId){
    return DBPlotManager.getChi2(plotId,fitId);
    }

     public double[] getChi2(int fitId){
    return DBPlotManager.getChi2(getId(),fitId);
     }


    public int getProcIdWanted(Generator gen) throws JetWebException {

    if (procIdWanted==0){

        Vector<PlotSwitch> bestMatches = 
        DBPlotManager.getMatchedSwitches(this.getId(),gen);

        int procIdDefault = (PlotSwitch.defaultProc(new Collision(collisionId))).getId(); 
        
        if (bestMatches.size()!=0) { 
        
        // Apply the switches.
        for (PlotSwitch pSwitch : bestMatches) { 

            if ( (pSwitch.getParameterName()==null)){
            // This is the default for this plot.
            procIdDefault = pSwitch.getMCProcessTypeId();
            } else {
            if (pSwitch.getParameterName().equals("pthat")){
                try {

                Double genPthat = gen.getPthat();

                if ((pSwitch.getParameterValueLow()==null||
                     genPthat>pSwitch.getParameterValueLow()) &&
                    (pSwitch.getParameterValueHigh()==null ||
                     genPthat<pSwitch.getParameterValueHigh())
                    ){
                    procIdWanted = pSwitch.getMCProcessTypeId();
                }
                //System.out.println("DataPlot: pthat="+genPthat+" "+pSwitch.getParameterValueLow()+" "+pSwitch.getParameterValueHigh());

                } catch (NumberFormatException nfe) {
                nfe.printStackTrace();
                }
            }
            }
        }
        }
        
        if (procIdWanted==0) {procIdWanted=procIdDefault;}

    }
    return procIdWanted;
    }

}

Generated Wed Jan 17 09:14:27 GMT 2007