RunSeries.java

Go to the documentation of this file.

package cedar.jetweb.model;

import java.util.Date;
import java.util.Vector;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.TreeSet;

import java.io.File;

import cedar.jetweb.db.DBManager;
import cedar.jetweb.db.DBJobManager;
import cedar.jetweb.JetWebException;
import cedar.jetweb.job.LogFile;
import cedar.jetweb.JetWebConfig;
import cedar.jetweb.util.Match;
import cedar.jetweb.generator.Generator;
import cedar.jetweb.model.plots.DataPlot;
import cedar.jetweb.model.paper.*;
import cedar.jetweb.job.CutCollection;

public class RunSeries extends ResultSearchPattern {

    private int runseriesId=-1;
    private Date date;    
    private double lumi_;
    private boolean dirtyLumi_ = true;
    private Double crossSection_;
    private boolean dirtyCrossSection_ = true;
    private int nLogs=-1;
    private Vector<LogFile> logFiles;
    private boolean dirtyProcessType_ = true;
    private MCProcessType proc_;
    private Vector<Run> runs_ = new Vector<Run>(0);
    //    private Run combinedRun_ = new Run();
    private boolean isValid_=false;
    private boolean dirtyIsValid_ = true;

    private Generator generator_;
    private boolean dirtyGenerator_ = true;
    private boolean dirtyPhotonpdfList_ = true;
    private boolean dirtyProtonpdfList_ = true;

    private CutCollection cuts_;
    private boolean dirtyCuts_ = true;
    private boolean cutSuccess_ = false;
    private static HashMap<MCProcessType, Vector<MCProcessType> > 
    ProcessCompatibility_ = 
    new HashMap<MCProcessType, Vector<MCProcessType> > ();

    // Keep a record of the last previously used RunSeries to speed up access
    // if we need it twice

    private static Integer previousId_;
    private static RunSeries previousRunSeries_;


    // Method to make a new runseries from a runseries id
    // Keeps a cache of existing runseries.
   
    public static RunSeries Maker(Integer newId)
    throws JetWebException{

    if(newId!=previousId_){
        previousRunSeries_ = new RunSeries(newId);
        previousId_ = newId;
    }

    return previousRunSeries_;

    }

    public RunSeries(){

    super();
    System.out.println("Making empty runseries");
    runseriesId=-1;

    }

    public RunSeries(int newId) throws JetWebException {

    super();
    System.out.println("Making new runseries from id");
    runseriesId=newId;
    retrieve();
    }

    public RunSeries(ResultSearchPattern pattern){

    super();
    System.out.println("Making new runseries from resultserachpattern");
    runseriesId = -1;

    this.generatorList = pattern.getGeneratorList();
    setGenerator(generatorList.get(0));
    setLumi(0.0);
    this.protonpdfList = pattern.getProtonPDFList();
    this.photonpdfList = pattern.getPhotonPDFList();

    if(pattern.getProtonPDFList().size()!=0){
        runs_.get(0).setPDF(pattern.getProtonPDFList().get(0));
    }

    if(pattern.getPhotonPDFList().size()!=0){
        runs_.get(0).setPDF(pattern.getPhotonPDFList().get(0));
    }

    }
    /*
     * Retrieve this runseries from the DB
     */

    public boolean retrieve() throws JetWebException {

    DBManager.selectFromDB(this);
    dirtyLumi_=false;
    dirtyCrossSection_ = false;
    return true;
    }


    public int getId(){
    return runseriesId;
    }

    public void setId(int newrunseriesId){
    runseriesId = newrunseriesId;
    dirtyCuts_ =true;
    }

    public Date getDate(){ return date; }

    public void setDate(Date date){
    this.date = date;
    }

    public RunSeries setLumi(double newLumi){
    
    Run run = null;

    if(runs_.size()==0){
        run = new Run();
        run.setLumi(1.0);
        if(protonpdfList!=null && protonpdfList.size()!=0){
        run.setPDF(protonpdfList.get(0));
        }
        if(photonpdfList!=null && photonpdfList.size()!=0){
        run.setPDF(photonpdfList.get(0));
        }

        addRun(run);
        dirtyProtonpdfList_ = true;
        dirtyPhotonpdfList_ = true;
    }

    double oldLumi = getLumi();

    //protect from existing lumi = 0 !
    double norm = oldLumi/newLumi;

    if(Match.compareDouble(norm, 0.0)){
        // the old lumi is 0.
        // so set all runs to have the new Lumi and return

        for(Run r: runs_){
        r.setLumi(newLumi);
        }
        lumi_ = newLumi;
        return this;
    }

    norm = newLumi / oldLumi;

    if(norm != norm){
        // since we already tested for oldLumi/newLumi  = 0, 
        // the only way we can get here is if newLumi = oldLumi = 0.
        norm = 0.0;
    }

    for(Run r: runs_){
        r.setLumi(norm * r.getLumi());
    }

    lumi_ = newLumi;
    //  combinedRun_.setLumi(newLumi);

    return(this);
    }

    public Double getCrossSection(){

    if(!dirtyCrossSection_) return crossSection_;
    dirtyCrossSection_ = false;

    crossSection_ = 0.0;

    for(Run run: runs_){
        crossSection_ += run.getCrossSection();
    }

    return crossSection_;
    }

    public RunSeries setCrossSection(Double cs){
    dirtyCrossSection_ = false;
    crossSection_ = cs;
    return this;
    }


    public double getLumi(){ 

    if(!dirtyLumi_) return lumi_;

    dirtyLumi_ = false;

    Vector<Run> triedRuns = new Vector<Run>();
    Vector<Double> foundLumis = new Vector<Double>();

    for(Run run: runs_){

        boolean found = false;

        for(int ii=0; ii!=triedRuns.size() && !found; ++ii){
        if(run.equals(triedRuns.get(ii))){

            System.out.println
            ("RunSeries: Found matching runs for process "+
             run.getMCProcessType() + 
             ": Combining luminosities");

            System.out.println("Adding lumi "+
                       run.getLumi()+
                       " to already found lumi of "+
                       foundLumis.get(ii));

            Double newLumi = foundLumis.get(ii) + run.getLumi();
            
            foundLumis.set(ii, newLumi);

            found = true;
        }
        }

        if(!found){
        triedRuns.add(run);
        foundLumis.add(run.getLumi());
        }
    }

    //now get the lowest of the lumis found

    TreeSet<Double> sortedLumis = new TreeSet(foundLumis);
    lumi_ = sortedLumis.first();
    return lumi_;
    }

    public int getNLogs(){
    if (nLogs<0) { 
        try {
        nLogs = DBJobManager.getNLogs(this.getId());
        } catch (JetWebException j){
        System.out.println(j);
        }
    }
    return nLogs; 
    }

    public Vector<LogFile> getLogFiles(){
    if (logFiles==null){
        try {
        return DBJobManager.getLogFiles(this.getId());
        } catch (JetWebException j){
        System.out.println(j);
        }
    }
    return logFiles;
    }

    public RunSeries setMCProcessType(MCProcessType proc)
    throws JetWebException{
    dirtyCuts_ = true;
    if(!proc.isValid()){
        System.out.println
        ("Warning: MCProcessType for RunSeries"+
         " is not valid - not assigning");
        return this;
    }
       
    if(proc.equals(getMCProcessType())) return this;
      
    dirtyProcessType_ = true;
    dirtyIsValid_ = true;

    Vector<Integer> compatibleProcs = proc.getCompatibleProcesses();

    boolean compatible = (runs_.size()==0)? false: true;

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

    for(Run run: runs_){

        existingProcs.add(run.getMCProcessType().getId());

        if(!compatibleProcs.contains
           (run.getMCProcessType().getId())){
        compatible = false;
        }
    }

    if(!compatible){
        lumi_ = getLumi();
        generator_ = getGenerator();
        runs_.clear();
        dirtyProtonpdfList_ = true;
        dirtyPhotonpdfList_ = true;
        Vector<Integer> compatiblePIds = proc.getCompatibleProcesses();

        for(Integer PId: compatiblePIds){
        Run run = new Run();
        if(protonpdfList!=null && protonpdfList.size()!=0){
            run.setPDF(protonpdfList.get(0));
        }
        if(photonpdfList!=null && photonpdfList.size()!=0){
            run.setPDF(photonpdfList.get(0));
        }
        run.setLumi(lumi_);
        run.setGenerator(generator_);
        run.setMCProcessType(new MCProcessType(PId));
        runs_.add(run);

        }

        proc_ = proc;
        dirtyProcessType_ = false;
    }else{

        //for(int ii=0; ii!= compatibleProcs.size();++ii){
        for(Integer compatibleProc: compatibleProcs){

        //if(!existingProcs.contains(compatibleProcs.get(ii))){
        if(!existingProcs.contains(compatibleProc)){
            Run run = new Run();
            run.setLumi(lumi_);
            run.setMCProcessType
            //(new MCProcessType(compatibleProcs.get(ii)));
            (new MCProcessType(compatibleProc));
            runs_.add(run);

        }
        }
    }

    return(this);
    }


    public MCProcessType getMCProcessType()
    throws JetWebException{ 

    if(!dirtyProcessType_) return(proc_);

    dirtyProcessType_ = false;

    if(runs_.size()==0){

        proc_ = new MCProcessType();
        return(proc_);
    }

    boolean compatible = true;

    //Vector of process ids in this runseries
    Vector<Integer> PIds = new Vector<Integer>();
    
    //Vector of process ids with which all processes are compatible
    Vector<Integer> allowedIds = 
        runs_.get(0).getMCProcessType().getCompatibleProcesses();


    for(Run run: runs_){


        //System.out.println("Adding process type "+
        //         run.getMCProcessType().getId());

        PIds.add(run.getMCProcessType().getId());
        
        //Vector of process ids with which this process is compatible
        Vector<Integer> compatIds = 
        run.getMCProcessType().getCompatibleProcesses();
        
        Vector<Integer> tmp = new Vector<Integer>();
        if(compatIds!=null){

        for(Integer Id: compatIds){
            //System.out.println("compat. with "+Id);
            if(allowedIds.contains(Id)){
            tmp.add(Id);
            }
        }
    
        }else{
        System.out.println
            ("MCProcessType does not contain a " + 
             "list of processes it is compatible with");

        throw new JetWebException
            ("MCProcessType does not contain a " + 
             "list of processes it is compatible with",
             run.getMCProcessType().toString());
        }
        allowedIds = tmp;
    }

    //
    // if(compatIds!=null){//shouldn't ever be null since 
                        //it is compatible with itself at least.

        //Check that every process is compatible
    /*
        for(int jj=0; jj!=runs_.size(); ++jj){
            if(!compatIds.contains
               (run.getMCProcessType().getId())){
            compatible = false;
            }
            }*/

    for(Run run: runs_){
        if(!allowedIds.contains(run.getMCProcessType().getId())){
        compatible = false;
        }
    }

    if(!compatible){
        
        //System.out.println("!compatible");

        return null;
    }


    //Vector of valid Processes with which every process in this
    //runseries is compatible
    Vector<MCProcessType> validProcs = new Vector<MCProcessType>();

    for(Integer allowedId: allowedIds){
        MCProcessType tmp = new MCProcessType(allowedId);

        if(tmp.isValid()){
        validProcs.add(tmp);
        }
    }


    //System.out.println(validProcs.toString());

    //Processes which are valid and compatible _only_ with those
    //processes in this runseries (there should be ony one such process)
    Vector<MCProcessType> uniqueProcess = new Vector<MCProcessType>();

    for(int ii=0; ii!= validProcs.size(); ++ii){

        if(validProcs.get(ii).getCompatibleProcesses().containsAll(PIds)
           &&
           PIds.containsAll(validProcs.get(ii).getCompatibleProcesses())){
        uniqueProcess.add(validProcs.get(ii));
        }
    }

    if(uniqueProcess.size()==0){

        //System.out.println("uniqueProcess.size()==0");

        return null;
        /*
        throw new JetWebException
        ("Runs in this RunSeries do not " + 
         "form a complete and valid physics process", 
         PIds.toString());
        */
    }else if(uniqueProcess.size()>1){
        
        throw new JetWebException
        ("Database specifies two or more physics processes "+
         "that are compatible with this set of runs",
         PIds.toString());
    }

    proc_ = uniqueProcess.get(0);
    return(proc_);
    }

    public Vector<Integer> getSubSeries(){


    return new Vector<Integer>();
    }
    /*
     * Sets the Kinematical cuts for this runseries based upon the 
     * actual cuts used by the generator and the cuts required by the plots
     * generated by this runseries.
     * For example, if the generator in this runseries has a PTMin cut of 10
     * but the plot generated by this runseries with the lowest PT requirement
     * has a PTMin of 15 then the PTMin cut for this runseries will be set
     * at 15.  This is so that a future runseries with 10 < PTMin < 15
     * may be combined with this one (because it too will have its PTMin
     * cut raised to 15).
     * @returns true if cuts are successfully set.  false otherwise
     */

    public boolean setCuts()
    throws JetWebException{

    if(!dirtyCuts_) return cutSuccess_;
    
    cuts_ = getGenerator().getCutCollection();
    cutSuccess_ = (cuts_==null)? false: true;
    dirtyCuts_ = false;
    return cutSuccess_;

    // used to set cut collection to match the cut collection of the 
    // plot with the smallest cut collection for which this runseries
    // generates data.
    // no longer used.

    /*
    if(!dirtyCuts_) return cutSuccess_;
    dirtyCuts_ = false;
    CutCollection newCuts = new CutCollection();
    
    cutSuccess_ = false;

    for(Paper paper: PaperBank.getPapers()){
        for(DataPlot plot: paper.getPlots()){
        if(plot.getProcIdWanted(getGenerator()) ==
           getMCProcessType().getId()){

            CutCollection cuts = plot.getCutCollection();

            if(cuts!=null){
            if(cuts.isWithin(getGenerator().getCutCollection())){
                newCuts = cuts.union(newCuts);
                cutSuccess_ = true;
            }
            }
        }
        }
    }

    cuts_ = newCuts;

    return cutSuccess_;
    */
    }
    public CutCollection getCutCollection(){
    try{
        setCuts();
    }catch(JetWebException err){
        System.out.println
        ("RunSeries.getCutCollection():"+ 
         " unable to determine correct set of cuts.");
        System.out.println(err.getMessage());
        err.printStackTrace();
    }
    return cuts_;
    }

    public RunSeries addRun(Run run){
    
    if(runs_.size()==0 || run.isConsistentWith(runs_.get(0))){
        dirtyProcessType_ = true;
        dirtyLumi_ = true;
        dirtyCrossSection_ = true;
        dirtyIsValid_ = true;
        dirtyProtonpdfList_ = true;
        dirtyPhotonpdfList_ = true;
        dirtyCuts_ = true;
        runs_.add(run);
    }else{
        System.out.println
       ("Failed to add run to RunSeries - not consistent with existing runs!");
    }
    return(this);
    }

    public RunSeries clearRuns(){
    
    dirtyProcessType_ = true;
    dirtyLumi_ = true;
    dirtyCrossSection_ = true;
    dirtyIsValid_ = true;
    dirtyProtonpdfList_ = true;
    dirtyPhotonpdfList_ = true;
    dirtyCuts_ = true;
    runs_.clear();
    
    return this;
    }


    public void setGenerator(Generator generator){
    
    dirtyProtonpdfList_ = true;
    dirtyPhotonpdfList_ = true;
    dirtyCuts_ = true;
    if(runs_.size()==0){
        Run run = new Run();
        //run.setGenerator(generator);
        if(protonpdfList!=null && protonpdfList.size()!=0){
        run.setPDF(protonpdfList.get(0));
        }
        if(photonpdfList!=null && photonpdfList.size()!=0){
        run.setPDF(photonpdfList.get(0));
        }
        runs_.add(run);
    }

    for(Run run: runs_){
        run.setGenerator(generator);
    }

    generator_ = generator;
    dirtyGenerator_ = false;
    return;
    }

    public Generator getGenerator()
    throws JetWebException{

    if(!dirtyGenerator_) return generator_;

    if(runs_.size()==0){
        return null;
        //throw new JetWebException
        //("Error: Unable to get Generator - has not been set.",
        // "cedar.jetweb.model.RunSeries.getGenerator()");
    }
    
    generator_ = runs_.get(0).getGenerator();
    
    for(Run run: runs_){

        generator_ = generator_.union(run.getGenerator());
        
        if(generator_== null) return generator_;

    }

    dirtyGenerator_=false;

    return(generator_);
    }
    
    public Generator getGenerator(int i) throws JetWebException {
    if (i!=0) {
        throw new JetWebException("RunSeries: getGenerator("+i+")",
                      "method not allowed");
    }
    return getGenerator();
    }

    public Vector<Generator> getGeneratorList(){
    if(generatorList!=null){
        generatorList.clear();   
    }else{
        generatorList = new Vector<Generator>(1);
    }
    try{
        generatorList.add(getGenerator());
    }catch(JetWebException err){
        System.out.println(err.getMessage());
    }
    return generatorList;
    }
    public Vector<PDF> getProtonPDFList(){
    
    if(protonpdfList==null) protonpdfList = new Vector<PDF>();

    if(!dirtyProtonpdfList_){
        return protonpdfList;
    }
    
    dirtyProtonpdfList_ = false;

    Run checkRun;

    if(runs_.size()==0){
        return(protonpdfList);//assumes ptotonpdfList must have been null
    }else{
        checkRun = runs_.get(0);
        protonpdfList.clear();
        protonpdfList.add(checkRun.getProtonPDF());
    }

    for(Run run: runs_){
        if(!run.isConsistentWith(checkRun)){
        protonpdfList.add(run.getProtonPDF());
        }
    }
    return protonpdfList;
    }
    public Vector<PDF> getPhotonPDFList(){
    if(photonpdfList==null) photonpdfList = new Vector<PDF>();

    if(!dirtyPhotonpdfList_){
        return photonpdfList;
    }

    dirtyPhotonpdfList_ = false;

    Run checkRun;

    if(runs_.size()==0){

        System.out.println("runs_.size()=0: cannot determine photon pdf");

        return(photonpdfList);
    }else{
        checkRun = runs_.get(0);
        photonpdfList.clear();
        photonpdfList.add(checkRun.getPhotonPDF());
    }

    for(Run run: runs_){
        if(!run.isConsistentWith(checkRun)){
        photonpdfList.add(run.getPhotonPDF());
        }
    }
    return photonpdfList;
    }
    public PDF getProtonPDF()
    throws JetWebException {

    if(dirtyProtonpdfList_){
        getProtonPDFList();
    }

    if(protonpdfList==null || protonpdfList.size()==0){
        throw new JetWebException("No Proton PDF defined in RunSeries",
                      "RunSeries.getProtonPDF");
    }else if(protonpdfList.size()>1){
        throw new JetWebException
        ("Multiple proton PDFs defined in RunSeries - don't know which one to use",
         "RunSeries.getProtonPDF");
    }
    return protonpdfList.get(0);
    
    }
    public PDF getPhotonPDF()
    throws JetWebException{

    if(dirtyPhotonpdfList_){
        getPhotonPDFList();
    }
    if(photonpdfList==null || photonpdfList.size()==0){
        throw new JetWebException("No Photon PDF defined in RunSeries",
                      "RunSeries.getPhotonPDF");
    }else if(photonpdfList.size()>1){
        throw new JetWebException
        ("Multiple photon PDFs defined in RunSeries - don't know which one to use",
         "RunSeries.getPhotonPDF");
    }


    return photonpdfList.get(0);

    }

    public Vector<Model> getConsistentModels() throws JetWebException {
    return DBManager.getConsistentModels(this);
    }

    public boolean isValid()
    throws JetWebException{

    if(!dirtyIsValid_) return(isValid_);
    
    dirtyIsValid_ = false;

    getMCProcessType();

    isValid_ = (proc_ == null)? false: true;

    for(int ii=0; ii!=runs_.size() && isValid_;++ii){
        for(int jj=0; jj!= runs_.size(); ++jj){
        isValid_ = runs_.get(ii).isConsistentWith(runs_.get(jj));
        }
    }

    return(isValid_);
    }


    public RunSeries removeIrrelevantParameters() throws JetWebException {

    dirtyCuts_ = true;
    Set<Map.Entry<String,Integer>> intParameters;
    Set<Map.Entry<String,Double>>  realParameters;
    Set<Map.Entry<String,HashMap<Integer,Integer>>> intArrays;
    Set<Map.Entry<String,HashMap<Integer,Double>>> realArrays;

    Vector<String> toGo = new Vector<String>();

    // First the integer parameters.
    intParameters = generator_.getIntParameters().entrySet(); 
    for (Map.Entry<String,Integer> entry : intParameters){      
        if (!generator_.isRelevant(proc_,entry.getKey())){
            toGo.add(entry.getKey());
        }
    }
    for (String key : toGo){
        generator_.getIntParameters().remove(key);
    }
    toGo.clear();

    // Now the real parameters.
    realParameters = generator_.getRealParameters().entrySet(); 
    for (Map.Entry<String,Double> entry : realParameters){      
        if (!generator_.isRelevant(proc_,entry.getKey())){
            toGo.add(entry.getKey());
        }
    }

    for (String key : toGo){
        generator_.getRealParameters().remove(key);
    }
    toGo.clear();


    // Now the int arrays.
    intArrays = generator_.getIntParameterArrays().entrySet(); 
    for (Map.Entry<String,HashMap<Integer,Integer>> entry : intArrays){
        
        String arrayName = entry.getKey(); 

        Set<Map.Entry<Integer,Integer>> array = entry.getValue().entrySet();

        for (Map.Entry<Integer,Integer> arrayEntry : array){

        Integer index = arrayEntry.getKey();            
        if (!generator_.isRelevant(proc_,arrayName,index)){
            toGo.add(entry.getKey());
        }
        }
        for (String key : toGo){
        entry.getValue().remove(key);
        }
        toGo.clear();
    }



    // Now the real arrays.
    realArrays = generator_.getRealParameterArrays().entrySet(); 
    for (Map.Entry<String,HashMap<Integer,Double>> entry : realArrays){
        
        String arrayName = entry.getKey(); 

        Set<Map.Entry<Integer,Double>> array = entry.getValue().entrySet();

        for (Map.Entry<Integer,Double> arrayEntry : array){

        Integer index = arrayEntry.getKey();            
        if (!generator_.isRelevant(proc_,arrayName,index)){
            toGo.add(entry.getKey());
        }
        }
        for (String key : toGo){
        entry.getValue().remove(key);
        }
        toGo.clear();



    }

    // now make the runs consistent.
    for (Run run : runs_){
        run.setGenerator(generator_);
    }

    return this;
    }


}

Generated Wed Jan 17 09:14:27 GMT 2007