Generator.java

Go to the documentation of this file.

package cedar.jetweb.generator;

import java.util.HashMap;
import java.util.Vector;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Random;
import java.util.Date;
import java.lang.Math;

import java.io.BufferedWriter;
import java.io.IOException;

import java.text.NumberFormat;
import java.text.SimpleDateFormat;

import cedar.jetweb.model.MCProcessType;
import cedar.jetweb.model.Model;
import cedar.jetweb.model.PDF;
import cedar.jetweb.model.Collision;
import cedar.jetweb.model.plots.DataPlot;
import cedar.jetweb.model.paper.*;
import cedar.jetweb.db.DBGeneratorManager;
import cedar.jetweb.JetWebException;
import cedar.jetweb.JetWebConfig;
import cedar.jetweb.util.Match;
import cedar.jetweb.job.CutCollection;
import cedar.jetweb.job.Cut;

public abstract class Generator {

    private static Set<String> nameList;

    protected HashMap<String,Integer> intParameters = 
    new HashMap<String,Integer>();
    protected HashMap<String,Double> realParameters = 
    new HashMap<String,Double>();
    protected HashMap<String,HashMap<Integer,Integer>> intParameterArrays = 
    new HashMap<String,HashMap<Integer,Integer>>();
    protected HashMap<String,HashMap<Integer,Double>> realParameterArrays = 
    new HashMap<String,HashMap<Integer,Double>>();

    protected Set<String> realArrayNames;
    protected Set<String> realNames;
    protected Set<String> intArrayNames;
    protected Set<String> intNames;

    protected String generatorVersion;
    protected String generatorName;
    protected int generatorId;

    private static HashMap<String, Boolean> relevantPhoton_ =
    new HashMap<String, Boolean>();

    private static HashMap<String, Boolean> relevantProton_ =
    new HashMap<String, Boolean>();
    
    private static HashMap<String, HashMap<Integer, Boolean>> 
    relevantPhotonArrays_ = 
    new HashMap<String, HashMap<Integer, Boolean>>();

    private static HashMap<String, HashMap<Integer, Boolean>> 
    relevantProtonArrays_ =
    new HashMap<String, HashMap<Integer, Boolean>>();

    //Collection of cuts on phase space
    protected CutCollection cuts_;
    protected boolean dirtyCuts_ = true;

    public static Generator Maker(int id) 
    throws JetWebException {

    String[] nameAndVersion = DBGeneratorManager.getNameAndVersion(id);
    Generator gen = Maker(nameAndVersion[0],nameAndVersion[1]);
    gen.setGeneratorId(id);
    return gen;

    }
    public static Generator Maker(String name,String version) 
    throws JetWebException {

    if (name==null) {
        name = defaultName();
    }
    if (version==null){
        version = defaultVersion(name);
    }

    Generator gen = null;
    if (name.equalsIgnoreCase("herwig")){
        return new Herwig(version);     
    } else if (name.equalsIgnoreCase("pythia")){
        return new Pythia(version);
    } else {
        throw new JetWebException("Unknown generator",name);
    }

    }
    public static Generator Maker() 
    throws JetWebException {
    String name = defaultName();
    String version = defaultVersion(name);
    return Maker(name,version);
    }
    public HashMap<String,Integer> getIntParameters(){
    return intParameters;
    }
    public HashMap<String,Double> getRealParameters(){
    dirtyCuts_ = true;
    return realParameters;
    }  
    public HashMap<String,HashMap<Integer,Integer>> getIntParameterArrays(){
    return intParameterArrays;
    }  
    public HashMap<String,HashMap<Integer,Double>> getRealParameterArrays(){
    dirtyCuts_ = true;
    return realParameterArrays;
    }  

    /*
    public Generator setCollision(Collision collision){
    dirtyProcessType_ = true;
    collision_ = collision;
    return(this);
    }
    */


    public Generator setIntParameters(HashMap<String, Integer> parm){
    
    intParameters = parm;

    return this;
    }


    public Generator setRealParameters(HashMap<String, Double> parm){
    
    realParameters = parm;
    dirtyCuts_ = true;
    return this;
    }


    public Generator setIntParameterArrays
    (HashMap<String, HashMap<Integer, Integer>> parm){
    intParameterArrays = parm;
    return this;
    }

    public Generator setRealParameterArrays
    (HashMap<String, HashMap<Integer, Double>> parm){
    realParameterArrays = parm;
    dirtyCuts_ = true;
    return this;
    }

    public void setParameter(String name, int value) throws JetWebException {
    if (getIntNames().contains(name)){
        if (intParameters.containsKey(name)){
        intParameters.remove(name);
        }
        intParameters.put(name,value);

        //in principle, changing a parameter could change the process type
        //dirtyProcessType_ = true;

    } else {
        throw new JetWebException("Attempt to set illegal parameter"+name,
                      generatorName+generatorVersion);

    }
    }

    public void setParameter(String name, double value) throws JetWebException {
    dirtyCuts_ = true;
    if (getRealNames().contains(name)){
        if (realParameters.containsKey(name)){
        realParameters.remove(name);
        }
        realParameters.put(name,value);

        //in principle, changing a parameter could change the process type
        //dirtyProcessType_ = true;     

    } else {
        throw new JetWebException("Attempt to set illegal parameter"+name,
                      generatorName+generatorVersion);
    }
    }


    public void setRealElement(final String name, final int index, final Double value) 
    throws JetWebException {
    dirtyCuts_ = true;
    HashMap<Integer,Double> array = realParameterArrays.get(name);
        if (array==null) {
        if (getRealArrayNames().contains(name)){
        array = new HashMap<Integer,Double>();
        realParameterArrays.put(name,array);

        } else {
        throw new ParameterNotFoundException("Could not find array",
                         generatorName+generatorVersion,name);
        }
    }
    if (index>getMaxIndex(name) || index<getMinIndex(name)) {
        throw new ParameterNotFoundException("Index out of range",
                         generatorName+generatorVersion,name,index);
    }
    if (array.containsKey(index)) { 
        array.remove(index);
    }
    array.put(index,value);
    //dirtyProcessType_ = true;
    }
    public void setIntElement(final String name, final int index, final int value) 
    throws JetWebException {
    
    HashMap<Integer,Integer> array = intParameterArrays.get(name);
        if (array==null) {
        if (getIntArrayNames().contains(name)){
        array = new HashMap<Integer,Integer>();
        intParameterArrays.put(name,array);
        } else {
        throw new ParameterNotFoundException("Could not find array",
                         generatorName+generatorVersion,name);
        }
    }
    if (index>getMaxIndex(name) || index<getMinIndex(name)) {
        throw new ParameterNotFoundException("Index out of range",
                         generatorName+generatorVersion,name);
    }
    if (array.containsKey(index)) { 
        array.remove(index);
    }
    array.put(index,value);
    //dirtyProcessType_ = true;
    }

    //    public abstract String getMCProcessName(HashMap<String,HashMap<Integer,Integer>> parameters)
    public abstract String getMCProcessName(HashMap<String, Object> parameters)
    throws JetWebException;
    public abstract String getProcessSelector(MCProcessType proc);

    public boolean processTrumps(Generator gen){
    return false;
    }

    public int getMaxIndex(String name) throws JetWebException {
    return DBGeneratorManager.getMaxIndex(generatorName,generatorVersion,name);
    }
    public int getMinIndex(String name) throws JetWebException {
    return DBGeneratorManager.getMinIndex(generatorName,generatorVersion,name);
    }

    public String toString(){
    return getName()+"-"+getVersion();
    }

    public String getName(){
    return generatorName;
    }
    public String getVersion(){
    return generatorVersion;
    }
    public void setSoftDefaults() throws JetWebException {
    DBGeneratorManager.selectDefaultParameters(this,false);
    //dirtyProcessType_ = true;
    }
    public void setDefaults() throws JetWebException {
    DBGeneratorManager.selectDefaultParameters(this,true);
    //dirtyProcessType_ = true;
    }

    public abstract Generator addCut(Cut cut);

    public Generator addCutCollection(CutCollection cutCollection){
    for(Cut cut: cutCollection.getCuts()){
        addCut(cut);
    }
    return this;
    }

    public Generator setCutCollection(CutCollection cutCollection){
    cuts_ = new CutCollection();
    addCutCollection(cutCollection);
    return this;
    }

    public abstract CutCollection getCutCollection();
     
    public abstract Double getPthat();

    public abstract boolean checkParameters();

    public Set<String> getRealArrayNames() throws JetWebException {
    if (realArrayNames==null){
        realArrayNames = DBGeneratorManager.selectRealArrayNames(generatorName,generatorVersion);
    }
    return realArrayNames;
    }

    public Set<String> getRealNames() throws JetWebException {
    if (realNames==null){
        realNames = DBGeneratorManager.selectRealNames(generatorName,generatorVersion);
    }
    return realNames;
    }

    public Set<String> getIntArrayNames() throws JetWebException {
    if (intArrayNames==null){
        intArrayNames = DBGeneratorManager.selectIntArrayNames(generatorName,generatorVersion);
    }
    return intArrayNames;
    }

    public Set<String> getIntNames() throws JetWebException {
    if (intNames==null){
        intNames = DBGeneratorManager.selectIntNames(generatorName,generatorVersion);
    }
    return intNames;
    }


    // Static methods.
    public static String defaultName() throws JetWebException {
    return allNames().iterator().next();
    }

    public static Set<String> allNames() throws JetWebException {
    if (nameList==null){
        nameList = DBGeneratorManager.allNames();
    }
    return nameList;
    }

    public static Set<String> allVersions(String name) throws JetWebException {
    return DBGeneratorManager.getVersions(name);
    }

    public static String defaultVersion(String name) throws JetWebException {
    return DBGeneratorManager.getDefaultVersion(name);
    }

    protected abstract String getParticleName(String pName);

    public abstract void writeSteering(BufferedWriter newCards, 
                       Model model, MCProcessType proc) 
    throws JetWebException;

    protected void writeCommonFFKey(BufferedWriter newCards, 
                       MCProcessType proc)
    throws JetWebException, IOException {

    newCards.write("C HZSteer control cards for "+this);
    newCards.newLine();
    newCards.write("C\n");

    SimpleDateFormat df = 
        new SimpleDateFormat("HH:mm:ss dd/MM/yyyy");
    Date now = new Date();      
    newCards.write("C Created by JetWeb at "+df.format(now));
    newCards.newLine();

    newCards.write("C These cards will generate "+proc.getMCProcessName());
    newCards.newLine();

    newCards.write("C\n");

    newCards.write("C Start of generator independent FFKEY style steering. ");
    newCards.newLine();
    
    newCards.write("C\n");

    newCards.write("C  Tell FFREAD to print out steering cards");
    newCards.newLine();
    newCards.write("LIST");
    newCards.newLine();

    // Turn on XML output
    newCards.write("C Turn on XML output.\n");
    newCards.write("XML 1 ");
    newCards.newLine();

    // Turn on AIDA output
    newCards.write("C Turn on AIDA output.\n");
    newCards.write("AIDA 1 ");
    newCards.newLine();

    // Specify the luminosity and maximum number of events. 
    newCards.write("C Absolute maximum number of events\n");
    newCards.write("C Enforced if the lumi is too high.\n");
    newCards.write("NEV   2000000");
    newCards.newLine();
    newCards.write("C  ");
    newCards.write("C Requested lumi in inv.pb\n");
    newCards.write("LUMI "+proc.getDefaultLumi());
    newCards.newLine();

    // Choose beams.
    newCards.write("C Specify the beams. BEAM 1 has positive momentum.");
    newCards.newLine();
    //  newCards.write("BEAM1 '"+proc.getCollision().getParticle1().getName()+"'");

    newCards.write("BEAM1 '" + 
               getParticleName
               (proc.getCollision().getParticle1().getName()) + 
               "'");

    newCards.newLine();
    
    //newCards.write("BEAM2 '"+proc.getCollision().getParticle2().getName()+"'");
    newCards.write("BEAM2 '" + 
               getParticleName
               (proc.getCollision().getParticle2().getName()) + 
               "'");

    newCards.newLine();

    newCards.write("PBEAM1 "+proc.getCollision().getParticle1().getEnergy());
    newCards.newLine();
    newCards.write("PBEAM2 "+proc.getCollision().getParticle2().getEnergy());
    newCards.newLine();

    newCards.write("C\n");

    // Random number seeds.
    newCards.write("C   Random number seeds\n");
    newCards.write("RANDNUM1  "+JetWebConfig.random.nextInt(1000000));
    newCards.newLine();
    newCards.write("RANDNUM2  "+JetWebConfig.random.nextInt(1000000));
    newCards.newLine();

    newCards.write("C\n");
    newCards.write("C End of generator independent FFKEY style steering. ");
    newCards.write("C\n");

    }

    protected void writePDFFFKey(BufferedWriter newCards, Model model, 
                  MCProcessType proc)
    throws JetWebException, IOException {

    newCards.write("C ");
    newCards.newLine();

    // Choose photon pdf
    if (proc.hasPhoton()){
        newCards.write("C Photon parton density " + 
               model.getPhotonPDF().getName());
        // JetWebConfig.photonpdfName.get
        //     (model.getPhotonPDF()));
        //newCards.write("C Photon parton density "+
        //     model.getPhotonPDF());
        newCards.newLine();
        newCards.write("PDFPH "+model.getPhotonPDF().getMember());
            //newCards.write("PDFPH " + 
            //   JetWebConfig.photonpdfName.get
            //   (model.getPhotonPDF()));
        newCards.newLine();
    }
    // Choose proton pdf

    if (proc.hasProton()){
        newCards.write("C Proton parton density " + 
               model.getProtonPDF().getName());
               //JetWebConfig.protonpdfName.get
               //(model.getProtonPDF()));
        //newCards.write("C Proton parton density " + 
        //     model.getProtonPDF());
        newCards.newLine();
        newCards.write("PDFPR " + model.getProtonPDF().getMember());
        //newCards.write("PDFPR " +JetWebConfig.protonpdfName.get
        //     (model.getProtonPDF()));
        newCards.newLine();
    }

    newCards.write("C ");
    newCards.newLine();

    }
    protected void writeGenFFKey(BufferedWriter newCards, MCProcessType proc)
    throws JetWebException, IOException {

        NumberFormat form = JetWebConfig.getFormat();

    newCards.write("C\n");
    newCards.write("C Start of generator specific parameters for "
               +getName()+"-"+getVersion());
    newCards.newLine();

    newCards.write("C\n");

    // Now choose the process type
    newCards.write("C Cards to select "+proc.getMCProcessName());
    newCards.newLine();
    //Vector<Integer> pIds = proc.getCompatibleProcesses();
    //for(Integer pId: pIds){
    //MCProcessType p = new MCProcessType(pId);
    newCards.write(getProcessSelector(proc));
    newCards.newLine();
    newCards.write("C\n");
        //}

    // First the integer parameters.
    newCards.write("C Integer parameters\n");
    for (Map.Entry<String,Integer> entry : intParameters.entrySet()){       
        newCards.write(entry.getKey()+" "+entry.getValue());
        newCards.newLine();
        newCards.write("C");
        newCards.newLine();
    }

    // Now the the real parameters.
    newCards.write("C Real parameters\n");
    for (Map.Entry<String,Double> entry : realParameters.entrySet()){       
        newCards.write(entry.getKey()+" "+form.format(entry.getValue()));
        newCards.newLine();
    }
    newCards.write("C\n");
    newCards.write("C Integer parameter arrays\n");

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

        Set<Map.Entry<Integer,Integer>> array = entry.getValue().entrySet();
        for (Map.Entry<Integer,Integer> arrayEntry : array){
        Integer value = arrayEntry.getValue();
        Integer index = arrayEntry.getKey();                    
        newCards.write(arrayName.toUpperCase()+"  "+index+" = "+value);
        newCards.newLine();
        }
    }   



    // Now the real arrays.
    newCards.write("C Real parameter arrays\n");
    for (Map.Entry<String,HashMap<Integer,Double>> entry : realParameterArrays.entrySet()){
        
        String arrayName = entry.getKey(); 

        Set<Map.Entry<Integer,Double>> array = entry.getValue().entrySet();
        for (Map.Entry<Integer,Double> arrayEntry : array){
        Double value = arrayEntry.getValue();
        Integer index = arrayEntry.getKey();                    
        newCards.write(arrayName.toUpperCase()+"  "+index+" = "+form.format(value));
        newCards.newLine();
        }
    }   
    }
    protected void writePapersFFKey(BufferedWriter newCards, MCProcessType proc)
    throws JetWebException, IOException {

    newCards.write("C\n");
    newCards.write("C Start turning on HZTool Routines\n");
    newCards.write("C\n");

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

    for(Paper paper: PaperBank.getPapers()){

        if(!writtenPapers.contains(paper.getId())){
        for(DataPlot plot: paper.getPlots()){
            int pIdWanted = plot.getProcIdWanted(this);

            // only add a plot if this generator has suitable
            // kinematic cuts.
            CutCollection cuts = plot.getCutCollection();
            if(cuts==null || // if plot does not have any cuts 
                             // always add it
               cuts.isWithin(getCutCollection())){

            if(pIdWanted==proc.getId()&&
               !writtenPapers.contains(paper.getId())){
                writtenPapers.add(paper.getId());
            }else if(!writtenPapers.contains(paper.getId())){
                
                MCProcessType tmpProc = 
                new MCProcessType(pIdWanted);
                                
                if(tmpProc.isValid()){
                Vector<Integer> compatPIds = 
                    tmpProc.getCompatibleProcesses();  
                for(Integer pId: compatPIds){
                    
                    if(pId.intValue()==proc.getId()&&
                       !writtenPapers.contains(paper.getId())){
                    writtenPapers.add(paper.getId());
                    }
                }
                }
            }
            }  
        }
        }
    }
        
    for(Integer paperId: writtenPapers){
        newCards.write("ROUTINE "+paperId+"= TRUE\n");
    }
    /*
    for (Paper paper : PaperBank.getPapers()){
        for (DataPlot plot : paper.getPlotCollection()){

        int pIdWanted = plot.getProcIdWanted(this);

        if (pIdWanted==proc.getId() &&
            !writtenProcs.contains(pIdWanted)){
            newCards.write("ROUTINE "+paper.getId()+"= TRUE\n");
            writtenProcs.add(pIdWanted);
            break;
        }

        MCProcessType tmpProc = new MCProcessType(pIdWanted);
        Vector<Integer> compatPIds = tmpProc.getCompatibleProcesses();

        for(Integer pId: compatPIds){
            if(pId.intValue()==proc.getId() && 
               !writtenProcs.contains(pId)){
            newCards.write("ROUTINE "+paper.getId()+"= TRUE\n");
            writtenProcs.add(pId);
            break;
            }
        }

        }
    }
    */
    newCards.write("C\n");
    newCards.write("C End turning on HZTool Routines\n");
    newCards.write("C\n");

    }

    public boolean inModel(String pName){
    return true;
    }

    public boolean inModel(String aName, Integer index){
    return true;
    }

    public boolean inProcessType(String pName){
    return false;
    }

    public boolean inCuts(String pName){
    return false;
    }

    public boolean hasConsistentModel(Generator gen){
    
    System.out.println("called hasConsistentModel");

    return consistentParams(gen, true);
    }

    private <T1, T2 extends Comparable> boolean consistentParams
                (HashMap<T1, T2> parms1,
                 HashMap<T1, T2> parms2, 
                 Generator gen,
                 String name, boolean checkModel){

    boolean isArray = name!=null;

    for(Map.Entry<T1, T2> entry: parms2.entrySet()){
        T2 parm = parms1.get(entry.getKey());
        if(parm!=null){
        boolean check = true;
        if(checkModel){
            if(isArray){
            check = 
                (inModel(name, (Integer)entry.getKey()) && 
                 gen.inModel(name, (Integer)entry.getKey()))||
                this.inCuts(name);
            }else{
            String tmp = (String)entry.getKey();
            check = (inModel((String)entry.getKey()) &&
                 gen.inModel((String)entry.getKey()))||
                this.inCuts(tmp);
            }
        }

        if(check){
            //if(parm.compareTo(entry.getValue())!=0){

            //compareTo doesn't seem to work as it should :(

            if(!Match.compare(entry.getValue(), parm)){
            String aName;

            if(isArray){
                aName = name + "(" + entry.getKey() + ")";
            }else{
                aName = (String)entry.getKey();
            }

            System.out.println("Generator compare: Failed on " +
                       aName + ": " + 
                       entry.getValue() + 
                       " != " + parm);
            return false;
            }
        }
        }
    }
    
    return true;
    }

    private boolean consistentParams(Generator gen, boolean checkModel){

    boolean consistent = true;
    consistent = consistentParams(intParameters, 
                      gen.getIntParameters(),
                      gen,
                      null, 
                      checkModel);
    if(!consistent) return consistent;

    consistent = consistentParams(realParameters, 
                      gen.getRealParameters(),
                      gen,
                      null, 
                      checkModel);
    if(!consistent) return consistent;

    for(Map.Entry<String, HashMap<Integer, Integer>> entry:
        gen.getIntParameterArrays().entrySet()){
        String arrayName = entry.getKey();
        HashMap<Integer, Integer> otherArray = 
        intParameterArrays.get(arrayName);
        if(otherArray != null){
        consistent = consistentParams(otherArray, 
                          entry.getValue(),
                          gen,
                          entry.getKey(),
                          checkModel);
        if(!consistent)return consistent;
        }
    }

    for(Map.Entry<String, HashMap<Integer, Double>>entry:
        gen.getRealParameterArrays().entrySet()){
        String arrayName = entry.getKey();
        HashMap<Integer, Double> otherArray = 
        realParameterArrays.get(arrayName);
        if(otherArray != null){
        consistent = consistentParams(otherArray, 
                          entry.getValue(),
                          gen,
                          entry.getKey(),
                          checkModel);
        if(!consistent) return consistent;
        }
    }

    return consistent;
    }
                 

    public boolean isConsistentWith(Generator gen){

    return consistentParams(gen, false);
    /*
    String pName;
    NumberFormat form = JetWebConfig.getFormat();

    for (Map.Entry<String,Integer> entry :
         gen.getIntParameters().entrySet()){        

        Integer iParam = intParameters.get(entry.getKey());
        if (iParam!=null && !iParam.equals(entry.getValue())){ 
        System.out.println("Generator compare: Failed on " + 
                   entry.getKey() + 
                   ": "+entry.getValue()+" != "+iParam);
        return false;
        }

    }

    for (Map.Entry<String,Double> entry : gen.getRealParameters().entrySet()){      

        Double rParam = realParameters.get(entry.getKey());


        if (rParam!=null && entry.getValue()!=null){


        /*
          Double diff = rParam - entry.getValue();
          boolean equal = 
            Math.abs(diff) <= (rParam+entry.getValue()) * 0.00000005 || 
            rParam==entry.getValue();
        */
    /*
        if(rParam!=null && !Match.compareDouble(rParam,entry.getValue())){
            
            System.out.println("Generator compare: Failed on " + 
                       entry.getKey() +
                       ": " + 
                       form.format(entry.getValue()) +
                       " != " + 
                       form.format(rParam));
            
            return false;
        }
        }
    }

    // Now the integer arrays.
    for (Map.Entry<String,HashMap<Integer,Integer>> entry : gen.getIntParameterArrays().entrySet()){
        
        String arrayName = entry.getKey(); 
        HashMap<Integer,Integer> otherArray = intParameterArrays.get(arrayName);
        if (otherArray != null) {
        
        Set<Map.Entry<Integer,Integer>> array = entry.getValue().entrySet();
        for (Map.Entry<Integer,Integer> arrayEntry : array){
            Integer index = arrayEntry.getKey();                    
            Integer iParam = otherArray.get(index);
            if (iParam!=null && !iParam.equals(arrayEntry.getValue())){
            System.out.println
                ("Generator compare: Failed on " + 
                 arrayName+index + 
                 ": " + 
                 arrayEntry.getValue() + 
                 " != "+iParam);
            return false;
            }
        }
        }
    }

    // Now the real arrays.
    for (Map.Entry<String,HashMap<Integer,Double>> entry : gen.getRealParameterArrays().entrySet()){
        
        String arrayName = entry.getKey(); 
        HashMap<Integer,Double> otherArray = realParameterArrays.get(arrayName);
        if (otherArray != null) {
        
        Set<Map.Entry<Integer,Double>> array = entry.getValue().entrySet();
        for (Map.Entry<Integer,Double> arrayEntry : array){
            Integer index = arrayEntry.getKey();                    
            Double rParam = otherArray.get(index);
            

            if(rParam!=null && arrayEntry.getValue()!=null && 
               !Match.compareDouble(rParam,arrayEntry.getValue())){

            System.out.println("failed on "+arrayName);
            System.out.println("rParam = "+rParam);
            System.out.println("entry = "+arrayEntry.getValue());

            return false;
            }
        }
        }
    }

    return true;
*/
    }

    public Generator union(Generator generator)
    throws JetWebException{
       
    Generator gen = null;
    dirtyCuts_ = true;
    //if(!this.isConsistentWith(generator)){
    if(!this.hasConsistentModel(generator)){
        return gen;
    }

    gen = Maker(this.generatorName, this.generatorVersion);

    HashMap<String, Integer> commonInts =
        new HashMap<String, Integer> (this.intParameters);
    HashMap<String, Double> commonReals = 
        new HashMap<String, Double> (this.realParameters);

    for(Map.Entry<String, Integer> entry: 
        generator.getIntParameters().entrySet()){
        String name = entry.getKey();
        Integer val = entry.getValue();
        if(generator.inModel(name)){
        commonInts.put(name, val);
        }

        if(generator.inProcessType(name) && generator.processTrumps(this)){
        commonInts.put(name, val);
        }

    }

    commonReals.putAll(generator.getRealParameters());
    
    HashMap<String, HashMap<Integer, Integer>> commonIntArrays = 
        new HashMap<String, HashMap<Integer, Integer>>
        (this.intParameterArrays);

    HashMap<String, HashMap<Integer, Double>> commonRealArrays =
        new HashMap<String, HashMap<Integer, Double>>
        (this.realParameterArrays);

    for(Map.Entry entry: generator.getIntParameterArrays().entrySet()){
        if(commonIntArrays.containsKey(entry.getKey())){
        ((HashMap<Integer, Integer>)
         commonIntArrays.get(entry.getKey())).putAll
            ((HashMap<Integer, Integer>)entry.getValue());
                    
        }else{
        commonIntArrays.put((String)entry.getKey(), 
                    (HashMap<Integer, Integer>)
                    entry.getValue());
        }
    }

    for(Map.Entry entry: generator.getRealParameterArrays().entrySet()){
        if(commonRealArrays.containsKey(entry.getKey())){
        ((HashMap<Integer, Double>)
         commonRealArrays.get(entry.getKey())).putAll
            ((HashMap<Integer, Double>)entry.getValue());
        }else{
        commonRealArrays.put((String)entry.getKey(),
                     (HashMap<Integer, Double>)
                     entry.getValue());
        }
    }

    gen.setIntParameters(commonInts).
        setRealParameters(commonReals).
        setIntParameterArrays(commonIntArrays).
        setRealParameterArrays(commonRealArrays);

    return gen;
    }


    public Boolean getIsRelevantToPhoton(String pName)
    throws JetWebException{
    
    Boolean relevant = relevantPhoton_.get(pName);

    if(relevant==null){
        relevant = 
        DBGeneratorManager.checkPhotonRelevance(this,pName,null);
        relevantPhoton_.put(pName, relevant);
    }
    return(relevant);
    }
 
    public Boolean getIsRelevantToPhoton(String aName, Integer aIndex)
    throws JetWebException{
    
    HashMap<Integer, Boolean> relevantArray = 
        relevantPhotonArrays_.get(aName);

    if(relevantArray==null){
        relevantArray = new HashMap<Integer, Boolean>();
        relevantPhotonArrays_.put(aName, relevantArray);
    }

    Boolean relevant = relevantArray.get(aIndex);

    if(relevant==null){
        relevant = 
        DBGeneratorManager.checkPhotonRelevance(this,aName,aIndex);
        relevantArray.put(aIndex, relevant);
    }

    return(relevant);
    }
    
    public Boolean getIsRelevantToProton(String pName)
    throws JetWebException{
    Boolean relevant = relevantProton_.get(pName);
    
    if(relevant==null){
        relevant = 
        DBGeneratorManager.checkProtonRelevance(this,pName,null);
        relevantProton_.put(pName, relevant);
        }
        //System.out.println(relevant);
    return(relevant);
    }
    public Boolean getIsRelevantToProton(String aName, Integer aIndex)
    throws JetWebException{
    
    HashMap<Integer, Boolean> relevantArray = 
        relevantProtonArrays_.get(aName);

    if(relevantArray==null){
        relevantArray = new HashMap<Integer, Boolean>();
        relevantProtonArrays_.put(aName, relevantArray);
    }

    Boolean relevant = relevantArray.get(aIndex);

    if(relevant==null){
        relevant = 
        DBGeneratorManager.checkProtonRelevance(this,aName,aIndex);
        relevantArray.put(aIndex, relevant);
    }

    return(relevant);
    }
    
    public Boolean isRelevant(MCProcessType proc, String pName) 
    throws JetWebException {

    if(proc==null){
        return(true);
    }
    //System.out.println(proc);

    if (proc.hasPhoton()){
        //System.out.println("checking photon relevance "+pName);
        if(getIsRelevantToPhoton(pName)) return true;
    }

    if (proc.hasProton()){
        //System.out.println("checking proton relevance "+pName);       
        if(getIsRelevantToProton(pName)) return true;
    }
    //System.out.println("returning false");
    return(false);
    }
    public Boolean isRelevant(MCProcessType proc, String pName, 
                  Integer aIndex) 
    throws JetWebException {
    
    if(proc==null){
        return(true);
    }

    if (proc.hasPhoton()){
        if(getIsRelevantToPhoton(pName, aIndex)) return true;
    }

    if (proc.hasProton()){
        if(getIsRelevantToProton(pName, aIndex)) return true;
    }

    return(false);
    }

    public int getGeneratorId() throws JetWebException {
    if (generatorId<=0) {
        generatorId = DBGeneratorManager.getGeneratorId(generatorName,generatorVersion);
    }
    return generatorId;
    }
    protected void setGeneratorId(int id){
    generatorId=id;
    }




}

Generated Wed Jan 17 09:14:27 GMT 2007