ResultSearchPattern.java

Go to the documentation of this file.

package cedar.jetweb.model;

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

import cedar.jetweb.*;
import cedar.jetweb.util.Match;
import cedar.jetweb.job.LogFile;
import cedar.jetweb.model.fit.Fit;
import cedar.jetweb.db.DBManager;

import cedar.jetweb.generator.Generator;

public class ResultSearchPattern implements Cloneable {

    protected String description_;

    protected Vector<Generator> generatorList;
    protected Vector<PDF> protonpdfList;
    protected Vector<PDF> photonpdfList;

    protected Vector<Match> notMatching = new Vector<Match>();

    public Enumeration<Match> getNonMatchingParameters(){
    return notMatching.elements();
    }

    public Vector<PDF> getProtonPDFList(){ 
    if (protonpdfList==null) { protonpdfList = new Vector<PDF>(); }
    return protonpdfList; 
    }
    public PDF getProtonPDF(int i) throws JetWebException { 
    if (protonpdfList!=null && i < protonpdfList.size()) {
        try {
        return protonpdfList.elementAt(i); 
        } catch (ArrayIndexOutOfBoundsException a){
        throw new JetWebException(a,"Index was "+i+":");
        }
    } else {
        return null;
    }
    }
    public PDF getProtonPDF() throws JetWebException {
    return getProtonPDF(0); 
    }

    public Vector<PDF> getPhotonPDFList() { 
    if (photonpdfList==null) { photonpdfList = new Vector<PDF>(); }
    return photonpdfList; 
    }
    public PDF getPhotonPDF(int i) throws JetWebException {
 
    if (photonpdfList!=null && i<photonpdfList.size()) {
        try {
        return photonpdfList.elementAt(i); 
        } catch (ArrayIndexOutOfBoundsException a){
        throw new JetWebException(a,"Index was "+i+":");
        }
    } else {
        return null;
    }
    }
    public PDF getPhotonPDF() throws JetWebException { 
    return getPhotonPDF(0); 
    }

    public Vector<Generator> getGeneratorList(){ 
    if (generatorList==null) { generatorList = new Vector<Generator>(); }
    return generatorList; 
    }
    public Generator getGenerator(int i) throws JetWebException { 
    if (generatorList!=null) {
        try {
        return (Generator)generatorList.elementAt(i); 
        } catch (ArrayIndexOutOfBoundsException a){
        throw new JetWebException(a,"Index was "+i+":");
        }
    } else {
        return null;
    }
    }
    public void setGenerator(Generator gen){
    if (generatorList==null){
        generatorList = new Vector<Generator>();
    } else {
        generatorList.clear();
    }
    generatorList.add(gen);
    }
    
    public String getDescription(){
    return description_;
    }

    public ResultSearchPattern setDescription(String description){
    description_ = description;
    return this;
    }

    public Generator getGenerator() throws JetWebException { 
    return getGenerator(0);
    }

    public Double getPthat() throws JetWebException {   
    return getGenerator().getPthat();
    }

    public ResultSearchPattern (){
    // do nothing.
    }

    /*
     * Make copy of pattern. 
     * Does not copy the generators. 
     */
    public Object clone() {
    ResultSearchPattern newPattern = new ResultSearchPattern();
    newPattern.generatorList = 
        (this.generatorList==null) ? null : 
        new Vector<Generator>(this.generatorList);
    newPattern.protonpdfList = 
        (this.protonpdfList==null) ? null : 
        new Vector<PDF>(this.protonpdfList);
    newPattern.photonpdfList = 
        (this.photonpdfList==null) ? null : 
        new Vector<PDF>(this.photonpdfList);
    newPattern.notMatching = 
        (this.notMatching==null) ? null : 
        new Vector<Match>(this.notMatching);

    return newPattern;
    }

    private boolean compare
    (String paramName, Vector<Object> val1, Vector<Object> val2){
    boolean match = false;

    if(val1.size()==0 ||val2.size()==0){
        match = true;
    }else if(val1.contains(val2.elementAt(0))){
        match = true;
    }else{
        notMatching.add
        (new Match(paramName, val1.elementAt(0), val2.elementAt(0)));
                      
    }
    return match;
    }

    private boolean compare(String paramName, String val1, String val2){
    boolean match = false;

    if (val1.trim().length()==0 || val2.trim().length()==0) { 
        match = true; 
    } else {
        if (val1.equals(val2)){
        match = true;
        } else {
        //System.out.println("Failed"+ paramName+ ":" + val1+","+val2);
        notMatching.add(new Match(paramName,val1,val2));
        }
    }

    return match;
    }

    // compares two HashMaps of parameters, if non-matching, record in
    // notMatching collection.
    /*
    private boolean compare
    (String name,HashMap<?,?> map1,HashMap<?,?> map2, Generator gen){

    boolean match = true;

    Set<? extends Map.Entry<?,?>> list = map1.entrySet();

    for (Map.Entry<?,?> entry : list){
        Object key = entry.getKey();
        if (gen.inModel(name, (Integer)key) && map2.containsKey(key)){
        Object val1 = map2.get(key);
        Object val2 = entry.getValue();
        if (val1!=null && val2 !=null && !val1.equals(val2)){
            match = false;
            if (val1 instanceof Double) {
            match = Match.compareDouble((Double)val1,(Double)val2);
            val1 = JetWebConfig.getFormat().format(val1);
            val2 = JetWebConfig.getFormat().format(val2);
            } 
            if (!match) {
            notMatching.add
                (new Match(name+":"+key.toString(), val1, val2));
            }
        }
        }
    }
    return match;
    }
    */
    private <T1, T2> boolean compare
    (String name, HashMap<T1, T2> map1, HashMap<T1, T2> map2, 
     Generator gen){

    boolean match = true;

    for(Map.Entry<T1, T2> entry: map1.entrySet()){
        T1 key = entry.getKey();
        boolean inModel = true;
        if(key instanceof Integer){
        inModel = gen.inModel(name, (Integer)key);
        }
        if(inModel && map2.containsKey(key)){
        T2 val1 = map2.get(key);
        T2 val2 = entry.getValue();

        if(val1!=null && val2 !=null &&
           !Match.compare(val1, val2)){
            match = false;
            if(!match){
            //if(val1 instanceof Double){
            //  val1 = (T2)JetWebConfig.getFormat().format(val1);
            //  val2 = (T2)JetWebConfig.getFormat().format(val2);
            //}
            System.out.println("Failed comparison on " + 
                       name + ": " + key + "." + 
                       val1 + "!=" + val2);

            notMatching.add
                (new Match(name+":"+key.toString(), val1, val2));
            }
        }
        }
    }

    return match;
    }


    public boolean matches(RunSeries runSeries) throws JetWebException {
    return matches(runSeries,runSeries.getMCProcessType());
    }

    public boolean matches(Model model) throws JetWebException {
    return matches(model,null);
    }

    public boolean matches(ResultSearchPattern pattern) throws JetWebException {
    return matches(pattern,null);
    }

    private boolean matches(ResultSearchPattern pattern, MCProcessType proc) 
    throws JetWebException {

    boolean match = true;

    String tmp;

    // clear down the record of comparison of this pattern with any other.
    notMatching.clear();

    match = match && compare(Match.GEN,getGenerator().getName(),
                 pattern.getGenerator().getName());
    match = match && compare(Match.GEN,getGenerator().getVersion(),
                 pattern.getGenerator().getVersion());

    if(!match){ 
        System.out.println("Failed compare on generator name and version" );
        return match;
    }

    // Got to do all the generator parameters too!!
    match = match && compare("Integer: ",getGenerator().getIntParameters(),
                 pattern.getGenerator().getIntParameters(), pattern.getGenerator());

    HashMap<String, Integer> intParams1 = new HashMap<String, Integer>();
    HashMap<String, Integer> intParams2 = new HashMap<String, Integer>();
    
    for(Map.Entry<String, Integer> entry: 
        getGenerator().getIntParameters().entrySet()){
        String key = entry.getKey();

        if(getGenerator().inModel(key) || 
           getGenerator().inProcessType(key)){
        intParams1.put(key, entry.getValue());
        }

    }

    for(Map.Entry<String, Integer> entry:
        pattern.getGenerator().getIntParameters().entrySet()){
        String key = entry.getKey();
        if(pattern.getGenerator().inModel(key) ||
           pattern.getGenerator().inProcessType(key)){
        intParams2.put(key, entry.getValue());
        }
    }

    match = match && compare("Integer: ",intParams1, intParams2,
                 pattern.getGenerator());

    if(!match) return match;

    HashMap<String, Double> realParams1 = new HashMap<String, Double>();
    HashMap<String, Double> realParams2 = new HashMap<String, Double>();
    for(Map.Entry entry: getGenerator().getRealParameters().entrySet()){
        String key = (String)entry.getKey();
        if(getGenerator().inModel(key) || 
           getGenerator().inProcessType(key)){
        realParams1.put(key, (Double)entry.getValue());
        }
    }

    for(Map.Entry entry: 
        pattern.getGenerator().getRealParameters().entrySet()){
        String key = (String)entry.getKey();
        if(pattern.getGenerator().inModel(key)||
           pattern.getGenerator().inProcessType(key)){
        realParams2.put(key, (Double)entry.getValue());
        }
    }

    match = match && 
        compare("Real   : ", realParams1, realParams2, 
            pattern.getGenerator());

    //  match = match && compare("Real   : ",getGenerator().getRealParameters(),
    //       pattern.getGenerator().getRealParameters());

    if(!match) return match;

    // Now the integer arrays.
    for (Map.Entry<String,HashMap<Integer,Integer>> entry : 
         getGenerator().getIntParameterArrays().entrySet()){
        
        String arrayName = entry.getKey(); 
        if(pattern.getGenerator().inModel(arrayName)){
        HashMap<Integer,Integer> map2 = 
            pattern.getGenerator().getIntParameterArrays().
            get(arrayName);
        match = match && 
            compare(arrayName,entry.getValue(),map2, 
                pattern.getGenerator());
        }
    }   

    if(!match) return match;

    // Now the real arrays.
    for (Map.Entry<String,HashMap<Integer,Double>> entry : 
         getGenerator().getRealParameterArrays().entrySet()){
        
            String arrayName = entry.getKey(); 
        if(pattern.getGenerator().inModel(arrayName)){
        HashMap<Integer,Double> map2 = 
            pattern.getGenerator().getRealParameterArrays().
            get(arrayName);
        match = match && 
            compare(arrayName,entry.getValue(),map2, 
                pattern.getGenerator());
        }
    }
    /*
    if(photonpdfList != null &&
       pattern.getPhotonPDFList()!=null){
        match = match && compare(Match.PHPDF, 
                     PDF2Object(photonpdfList),
                     PDF2Object(pattern.getPhotonPDFList()));
    }
    */

    if(getPhotonPDF() !=null &&
       pattern.getPhotonPDF() !=null){
        match = match && getPhotonPDF().equals(pattern.getPhotonPDF());
    }

    if(!match) return match;
    /*
    if(protonpdfList != null &&
       pattern.getProtonPDFList()!=null){
        match = match && compare(Match.PRPDF,
                     PDF2Object(protonpdfList),
                     PDF2Object(pattern.getProtonPDFList()));
    }
    */
    if(getProtonPDF() != null &&
       pattern.getProtonPDF() != null){
        match = match && getProtonPDF().equals(pattern.getProtonPDF());
    }

    return match;   
    }

    private Vector<Object> PDF2Object(Vector<PDF> pdfVec){
    Vector<Object> objVec = new Vector<Object>(pdfVec.size());
    for(PDF pdf: pdfVec){
        objVec.add(pdf);
    }
    return objVec;
    }

    public void dumpParms(){

    System.out.println(getParms()); 
    
    }

    public String getParms(){
    
    StringBuffer b = new StringBuffer("----------------------------");  

    b.append("\nGenerator "+this.getGeneratorList());   
    b.append("\nPhoton "+this.getPhotonPDFList());  
    b.append("\nProton "+this.getProtonPDFList());  
    return b.toString();

    }


    public void setSoftDefaults() throws JetWebException {

    if (getProtonPDFList().size()==0) 
        getProtonPDFList().add(JetWebConfig.defaultProtonPDF);
    if (getPhotonPDFList().size()==0) 
        getPhotonPDFList().add(JetWebConfig.defaultPhotonPDF);

    // Default generator
    if (getGeneratorList().size()==0) {
        // add a default generator
        Generator gen = Generator.Maker();
        gen.setDefaults();
        getGeneratorList().add(gen);
    } else {
        for (Generator gen : generatorList)
        gen.setSoftDefaults();
    }
    }
    public void setDefaults() throws JetWebException {

    getProtonPDFList().clear(); 
    getProtonPDFList().add(JetWebConfig.defaultProtonPDF);

    getPhotonPDFList().clear(); 
        getPhotonPDFList().add(JetWebConfig.defaultPhotonPDF);

    // Default generator
    getGeneratorList().clear();
        Generator gen = Generator.Maker();
    gen.setDefaults();
    generatorList.add(gen);

    }

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

}

Generated Wed Jan 17 09:14:27 GMT 2007