JetWebLogReader.java

Go to the documentation of this file.

package cedar.jetweb.xml;

import org.jdom.input.*;
import org.jdom.Element;
import org.jdom.Document;
import org.jdom.Namespace;
import org.jdom.JDOMException;

import java.util.List;
import java.util.Iterator;
import java.util.StringTokenizer;
import java.util.HashMap;
import java.util.Vector;

import cedar.jetweb.*;
import cedar.jetweb.model.*;
import cedar.jetweb.job.LogFile;
import cedar.jetweb.generator.Generator;



public class JetWebLogReader extends JetWebXMLReader {

    private LogFile logfile  = null;
    private Element hepml = null;
    //    private Element reaction = null;
    private Namespace ns = null;
    protected RunSeries runSeries_ = null;

    private static boolean zipped = true;
    private static String HEPDATA = "hepdata";
    private static String HEPML = "hepml";
    private static String SETTINGS = "generatorSettings";
    private static String GENERATOR = "generator";
    private static String RUN = "run";
    private static String RUNSERIES = "runSeries";
    private static String DARRAY = "doubleArray";
    private static String IARRAY = "intArray";
    private static String IMATRIX = "intMatrix";
    private static String DPARAM = "doubleParameter";
    private static String IPARAM = "intParameter";
    private static String PDF = "pdf";
    private static String ARRAYE = "arrayElement";
    private static String MATRIXE= "matrixElement";
    private static String NORM = "normalisation";
    private static String LUMI = "luminosity";
    private static String NEVENTS = "numberOfEvents";
    private static String CX = "crossSection";
    private static String PARTICLE = "particle";
    private static String REACTION = "reaction";
    private static String COLLISION = "collision";
    private static String MOMENTUM = "momentum";
    private static String COMMENT = "comment";
    private static String ID = "id";

    private  static String DEFAULT_NS = "hep";
    //private  static String DEFAULT_NS_URI = "http://www.cedar.ac.uk/xml/hepdata";
    
    private  static String DEFAULT_NS_URI = 
    "http://www.cedar.ac.uk/xml/hepml";
    private  static String PHOTON="gamma";
    private  static String PROTON="p";
    private  static String ANTIPROTON="pbar";
    private  static String GAMMALEPTON = "gamma/e";
    private  static String GAMMAANTILEPTON = "gamma/e+";

    private static boolean particleNameMapInit_ = true;
    private static HashMap<String, String> particleNameMap_ = 
    new HashMap<String, String>();

    //    private HashMap<String,HashMap<Integer,Integer>> procParameters = 
    //new HashMap<String,HashMap<Integer,Integer>>();

    public static void main(String args[]){
    if (args[0]==null){
        System.out.println("Please give xml doc URI");
        return;
    }

    
    try {
        System.out.println("Converting to JDOM..");
        JetWebLogReader reader = new JetWebLogReader(args[0]);
        LogFile log = new LogFile(args[0]);
        reader.fillLog(log);
        System.out.println(log.toString());


    } catch (Throwable t) {
        System.err.println("Error reading XML");
        System.err.println(t.toString());
    } 
    }

    public JetWebLogReader(String filename) throws JetWebXMLException {
    //be careful, this should be zipped
    super(filename,zipped);
    buildNamespace();
   }

    private void buildNamespace(){
    String nsPrefix = System.getProperty("hepdataNS");
    String nsUri = System.getProperty("hepdataNsURI");
    if (nsPrefix==null){
        nsPrefix=DEFAULT_NS;
    }
    if (nsUri==null){
        nsUri=DEFAULT_NS_URI;
    }
    ns = Namespace.getNamespace(nsPrefix,nsUri);

    }
    public void fillLog(LogFile log) throws JetWebException {
    
    try { 
        logfile = log;  
        logfile.setValid(false);
        runSeries_ = logfile.getRunSeries();
        if (runSeries_==null) {
        System.out.println
           ("JetWebLogReader.fillLog: LogFile contains null runSeries");
        runSeries_ = new RunSeries();
        logfile.setRunSeries(runSeries_);
        }else{
        System.out.println
          ("JetWebLogReader.fillLog: LogFile already contains a runSeries");
        }
        
        Element root = getDocument().getRootElement();

        if(root.getName().equals(HEPML)){
        hepml = root;
        } else {
        //hepdata = root.getChild(HEPDATA,ns);
        hepml = root.getChild(HEPML, ns);
        if (hepml==null){
            throw new JetWebXMLException
            ("XML LogReader cannot find "
             +HEPML+" in "+root.getName(),getFileName());
            // +HEPDATA+" in "+root.getName(),getFileName());
        }
        }
        
        List<Element> runs = null;//new List<Element>();
        Element runSeries = null;
        Element reaction = null;
        
        try{
        reaction = hepml.getChild(REACTION, ns);
        //reaction  = (Element)hepml.getChildren().get(0);
        }catch (Exception e){
        throw new JetWebXMLException
            ("XML LogReader cannot find "+REACTION
             +" in "+root.getName(),getFileName());
        }

        try{
        runSeries = hepml.getChild(RUNSERIES, ns);
        }catch (Exception e){
        throw new JetWebXMLException
            ("XML LogReader cannot find "+RUNSERIES
             +" in "+root.getName(),getFileName());
        }

        try{
        runs = runSeries.getChildren(RUN, ns);
        System.out.println
            ("JetWebLogReader: found " + runs.size() +" runs");
        }catch (Exception e){

        throw new JetWebXMLException
            ("XML LogReader cannot find "+RUN
             +" in "+root.getName(),getFileName());
        }

        for(int ii=0; ii!= runs.size(); ++ii){
        runSeries_.addRun(fillRun(reaction, runs.get(ii)));
        }
        runSeries_.setSoftDefaults();
        // at this stage only the current log lumi is here.
        logfile.setLumi(runSeries_.getLumi());
        logfile.setCrossSection(runSeries_.getCrossSection());

        logfile.doChecks();

        //make sure LogReader xml file and Logfile xml file are same
        if (!this.getFileName().equals(logfile.getXmlFileName())){
        System.out.println
            ("LogReader Warning: xmlfile "+this.getFileName()
             + " different from logfile xmlfile " + 
             logfile.getXmlFileName() +
             " changing logfile version");
        logfile.setXmlFile(this.getFileName());
        }

    } catch (JetWebException jwe) {
        System.out.println
        ("JetWebLogReader: Problem reading "+log.getFile());
        System.out.println(jwe.getMessage());
        jwe.printStackTrace(System.out);
        logfile.setValid(false);
        logfile.setStatus(LogFile.ERROR);
    }   
    }

    private Run fillRun(Element reaction, Element run)
    throws JetWebException{

    Run runObj = new Run();

    Element settings = run.getChild(SETTINGS, ns);
    
    if(settings==null){
        throw new JetWebXMLException
        ("JetWebLogReader: No Generator settings", this.getFileName());
    }

    Generator generator = makeGenerator(settings);
    
    runObj.setGenerator(generator);
    Iterator<Element> pdfIt = settings.getChildren(PDF, ns).iterator();

    if(pdfIt==null){
        throw new JetWebXMLException
        ("JetWebLogReader: No PDFs", this.getFileName());
    }

    while(pdfIt.hasNext()){
        Element pdf = (Element)pdfIt.next();
        String particleName = 
        getParticleName(pdf.getChild(PARTICLE,ns).
                getAttributeValue("name"));
        String pdfSet = pdf.getAttributeValue("set");
        String pdfM = pdf.getAttributeValue("member");
        String pdfScheme = pdf.getAttributeValue("scheme");
        if(particleName==null||
           pdfSet==null||
           pdfM==null||
           pdfScheme==null){
        throw new JetWebXMLException
            ("JetWebLogReader: Badly defined PDFs", 
             this.getFileName());
        }

        Integer pdfMember = null;
        if (pdfM!=null){
        pdfMember= new Integer(pdfM);
        }
        
        PDF pdfObj = new PDF(pdfMember);

        if(particleName.equals(PHOTON)){
        pdfObj.setIsPhoton();
        }else if(particleName.equals(PROTON) ||
             particleName.equals(ANTIPROTON)){

        pdfObj.setIsProton();
        }

        runObj.setPDF(pdfObj);
    }

    Element norm = run.getChild(NORM, ns);

    //runObj.setLumi(lumi(run));
    runObj.setLumi(lumi(norm));
    runObj.setCrossSection(crossSection(norm));
    runObj.setProcParams(procParams(generator, settings));
    try{

        runObj.setMCProcessType(fillCollision(reaction));

    }catch(JetWebException err){
        System.out.println(err.getMessage());
    }

    return(runObj);
    
    }

    private double crossSection(Element norm){

    double cs = -1.0;
    boolean gotCS = false;

    if(norm!=null){
        String cross = norm.getChildTextTrim(CX, ns);
        if(cross!=null && !cross.equals("")){
        cs = Double.parseDouble(cross);
        gotCS = true;
        }else{
        String nevents = norm.getChildTextTrim(NEVENTS,ns);
        String lum = norm.getChildTextTrim(LUMI,ns);

        if(nevents!=null &&
           !nevents.equals("") &&
           lum!=null &&
           !lum.equals("")){
            Double l = (Double)Double.parseDouble(lum);
            double n = Double.parseDouble(nevents);
            
            if(!l.equals(0)){
            cs = n/l;
            gotCS = true;
            }
        }
        }
    }

    if(!gotCS){
        System.out.println
        ("Warning: cross section not specified for run!");
    }
    
    return cs;
    }


    private double lumi(Element norm){
    double luminosity = 0.0;
    boolean gotLumi = false;

    //Element norm = settings.getChild(NORM,ns);
    
    if(norm!=null){
        
        String lumi = norm.getChildTextTrim(LUMI,ns);
        if (lumi!=null && !lumi.equals("")){
        
        luminosity += Double.parseDouble(lumi);
        gotLumi = true;

        }else{
        String nevents = norm.getChildTextTrim(NEVENTS,ns);
        String cx = norm.getChildTextTrim(CX,ns);
        
        if(nevents != null &&
           !nevents.equals("") &&
           !cx.equals("")){
            Double crossSection = (Double)Double.parseDouble(cx);
            int n = Integer.parseInt(nevents);

            if(!crossSection.equals(0)){
            luminosity+= n / crossSection;
            gotLumi = true;
            }
        }
        }
    }

    if(!gotLumi){
        System.out.println("Warning: zero luminosity for run!");
    }
    return(luminosity);
    }

    private Generator makeGenerator(Element settings)
    throws JetWebException{

    Generator generator = null;

        String genName = 
        settings.getChild(GENERATOR, ns).getAttributeValue("name");
        
        String genVersion = 
        settings.getChild(GENERATOR,ns).getAttributeValue("version");
        
        if(genName==null||
           genVersion==null){
        throw new JetWebXMLException
            ("JetWebLogReader: Badly defined generator settings", 
             this.getFileName());
        }

        int ii = genVersion.indexOf(".");
        
        while(ii>-1){
        genVersion = 
            genVersion.substring(0,ii)+genVersion.substring(ii+1);
        ii = genVersion.indexOf(".");
        }
        try{
        generator = Generator.Maker(genName, genVersion);
        }catch(JetWebException err){
        System.out.println(err.getMessage());
        throw new JetWebXMLException
            ("JetWebLogReader: Badly defined generator settings", 
             this.getFileName());
        }
        List<Element> arg = settings.getChildren(DARRAY,ns);
        if(arg!=null){
        fillDoubleArrays(arg, generator);
        }else{
        throw new JetWebXMLException
            ("JetWebLogReader: Badly defined generator settings", 
             this.getFileName());
        }

        arg = settings.getChildren(IARRAY,ns);

        if(arg!=null){
        fillIntArrays(arg, generator);
        }else{
        throw new JetWebXMLException
            ("JetWebLogReader: Badly defined generator settings", 
             this.getFileName());
        }

        arg = settings.getChildren(DPARAM,ns);

        if(arg!=null){
        fillDoubleParams(arg, generator);
        }else{
        throw new JetWebXMLException
            ("JetWebLogReader: Badly defined generator settings", 
             this.getFileName());
        }

        arg = settings.getChildren(IPARAM,ns);

        if(arg!=null){
        fillIntParams(arg, generator);
        }else{
        throw new JetWebXMLException
            ("JetWebLogReader: Badly defined generator settings", 
             this.getFileName());
        }

    return(generator);
    }

    private Collision fillCollision(Element collE) throws JetWebXMLException {

        Collision coll = new Collision();

    List<Element> pList = collE.getChild(COLLISION, ns).getChildren(PARTICLE,ns);

    if (pList==null||pList.size()==0) {
        throw new JetWebXMLException
        ("XMLLogReader; Collision has no particles",
         logfile.toString());
    }

    Iterator<Element> it = pList.iterator();

    while (it.hasNext()){
        Element eParticle = (Element)it.next();
        String name = getParticleName(eParticle.getAttributeValue("name"));

        Double energy = null;
        Particle particle = null;
        Integer pNumber = null;
        try {
        pNumber = new Integer(eParticle.getAttributeValue(ID));
        energy = new Double(eParticle.getChildTextTrim(MOMENTUM,ns));
            particle = new Particle(name,energy.doubleValue());

        } catch (NumberFormatException e){

        throw new JetWebXMLException
            (e+" LogFileReader: getParticle ",
             name+" energy <"+
             eParticle.getChildTextTrim(MOMENTUM,ns)+">");
        } catch (NullPointerException e){
        throw new JetWebXMLException
            (e+" LogFileReader: getParticle ",
             name+" energy <"+
             eParticle.getChildTextTrim(MOMENTUM,ns)+">");
        }
        try{
        coll.addParticle(particle, pNumber);
        }catch(JetWebException err){
        System.out.println(err.getMessage());
        throw new JetWebXMLException
            ("XMLLogReader: Badly defined particle in collision", 
             this.getFileName());
        }
    }

    if(coll.getNumberOfParticles()!=2){
        throw new JetWebXMLException
            ("XMLLogReader: Collision does not contain two particles", 
             this.getFileName());
    }

    if(coll.getId()==-1){
        throw new JetWebXMLException
            ("XMLLogReader: Collision is not present in Database", 
             this.getFileName());
    };

    return coll;

    }//fillCollision


    private void fillDoubleArrays(List<Element> aList, Generator generator)
    throws JetWebException{

    if (aList==null) return;
    Iterator<Element> it = aList.iterator();
    while (it.hasNext()){
        Element eArray = it.next();
        String aName = eArray.getAttributeValue("name");
        Iterator<Element> eleIt = 
        eArray.getChildren(ARRAYE,ns).iterator();       
        if (generator.inModel(aName)||
        generator.inCuts(aName)){
        if (!generator.getRealParameterArrays().containsKey(aName)){
            generator.getRealParameterArrays().put
            (aName,new HashMap<Integer,Double>());
        }
        HashMap<Integer,Double> array = 
            generator.getRealParameterArrays().get(aName);
        while (eleIt.hasNext()){
            Element e = (Element)eleIt.next();
            Integer index = new Integer(e.getAttributeValue("index"));
            Double eVal = new Double(e.getTextTrim());
            if(generator.inModel(aName, index)||generator.inCuts(aName)){
            array.put(index,eVal);
            }
        }
        }
    }

    };
    
    private void fillIntArrays(List<Element> aList, Generator generator)
    throws JetWebException{
    if (aList==null) return;
    Iterator<Element> it = aList.iterator();
    while (it.hasNext()){
        Element eArray = it.next();
        String aName = eArray.getAttributeValue("name");        
        Iterator<Element> eleIt = eArray.getChildren(ARRAYE,ns).iterator();     
        if (generator.inModel(aName)){
        if (!generator.getIntParameterArrays().containsKey(aName)){
            generator.getIntParameterArrays().put(aName,new HashMap<Integer,Integer>());
        }
        HashMap<Integer,Integer> array = generator.getIntParameterArrays().get(aName);
        while (eleIt.hasNext()){
            Element e = eleIt.next();
            Integer index = new Integer(e.getAttributeValue("index"));
            Integer eVal = new Integer(e.getTextTrim());
            array.put(index,eVal);         
        }
        }       
    }
    }

    private void fillIntParams
    (List<Element> ipList, Generator generator) 
    throws JetWebException{

    if (ipList==null) return;
    Iterator<Element> it = ipList.iterator();
    while (it.hasNext()){
        Element iParam = (Element)it.next();
        String pName = iParam.getAttributeValue("name");
        Integer pValue = new Integer(iParam.getTextTrim());

        HashMap<String,Integer> iParams = generator.getIntParameters();
        if (iParams.containsKey(pName)){
        // maybe be more severe about this?
        System.out.println("Warning. Multiply defined "+pName);
        iParams.remove(pName);
        }

        // Read in process params for now because some model params 
        // are only relevant to some processes

        //if (generator.inModel(pName)){
        iParams.put(pName,pValue);
        //}
    }
    }
    private void fillDoubleParams(List<Element> dpList, Generator generator) 
    throws JetWebException{

    if (dpList==null) return;
    Iterator<Element> it = dpList.iterator();
    while (it.hasNext()){
        Element dParam = it.next();
        String pName = dParam.getAttributeValue("name");
        Double pValue = new Double(dParam.getTextTrim());
        HashMap<String,Double> rParams = generator.getRealParameters();

        if (rParams.containsKey(pName)){
        // maybe be more severe about this?
        System.out.println("Warning. Multiply defined "+pName);
        rParams.remove(pName);
        }

        if (generator.inModel(pName)||generator.inCuts(pName)){
        rParams.put(pName,pValue);      
        }
    }
    }
    private HashMap<String, Object> procParams
    //    private HashMap<String, HashMap<Integer, Integer> > procParams
    (Generator generator, Element settings)
    throws JetWebXMLException{

    Iterator<Element> aIt = settings.getChildren(IARRAY, ns).iterator();
    Iterator<Element> iIt = settings.getChildren(IPARAM, ns).iterator();
    Iterator<Element> mIt = settings.getChildren(IMATRIX, ns).iterator();

    HashMap<String, Object > Params = 
        new HashMap<String, Object >();

    while(aIt.hasNext()){
        Element eArray = aIt.next();
        String aName = eArray.getAttributeValue("name");        
        Iterator<Element> eleIt = eArray.getChildren(ARRAYE,ns).iterator();
        
        if(generator.inProcessType(aName)){
        HashMap<Integer,Integer> array = new HashMap<Integer,Integer>();
        while(eleIt.hasNext()){
            Element e = eleIt.next();
            Integer index = new Integer(e.getAttributeValue("index"));
            Integer eVal = new Integer(e.getTextTrim());
            array.put(index, eVal);
        }
        Params.put(aName, array);
        }
    }
    
    while(iIt.hasNext()){
        Element iParam = (Element)iIt.next();
        String pName = iParam.getAttributeValue("name");
        Integer pValue = new Integer(iParam.getTextTrim());
        
        if (generator.inProcessType(pName)){
        //HashMap<Integer,Integer> map = new HashMap<Integer,Integer>();
        //map.put(new Integer(1),pValue);
        //Params.put(pName, map);
        Params.put(pName, pValue);
        }
    }

    while(mIt.hasNext()){
        Element eMatrix = (Element)mIt.next();
        String mName = eMatrix.getAttributeValue("name");
        Iterator<Element> matIt = 
        eMatrix.getChildren(MATRIXE,ns).iterator();
        if(generator.inProcessType(mName)){
        HashMap<Integer, HashMap<Integer, Integer>> matrix = 
            new HashMap<Integer, HashMap<Integer, Integer>>();
        while(matIt.hasNext()){
            Element e = matIt.next();
            Integer iindex = new Integer(e.getAttributeValue("iindex"));
            Integer jindex = new Integer(e.getAttributeValue("jindex"));
            Integer mValue = new Integer(e.getTextTrim());
            HashMap<Integer, Integer> row = matrix.get(iindex);
            if(row==null){
            row = new HashMap<Integer, Integer>();
            matrix.put(iindex, row);
            }
            row.put(jindex, mValue);
        }
        Params.put(mName, matrix);
        }
    }

    return(Params);
    };

    private String getParticleName(String pName){
    
    if(particleNameMapInit_) initParticleNames();

    String name = 
        particleNameMap_.get(pName);

    if(name==null) return pName;

    return name;
    }

    private void initParticleNames(){
    particleNameMapInit_ = false;
    particleNameMap_.put("p+", PROTON);
    particleNameMap_.put("pbar-", ANTIPROTON);
    particleNameMap_.put(GAMMALEPTON, "e-");
    particleNameMap_.put(GAMMAANTILEPTON, "e+");
    
    return;
    }

}

Generated Wed Jan 17 09:14:27 GMT 2007