MCProcessType.java

Go to the documentation of this file.

package cedar.jetweb.model;

import cedar.jetweb.*;
import cedar.jetweb.db.DBManager;
import cedar.jetweb.db.JetWebDBException;
import cedar.jetweb.db.DBBlob2Array;

import java.util.Vector;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Date;
import java.lang.Comparable;
import java.sql.Blob;
import java.sql.SQLException;

public class MCProcessType implements Storeable, Comparable {

    private int processId = 0;
    private int collisionId = -1;
    private Collision collision;
    private String processName;
    private static HashMap<Integer, Vector<Integer> > 
    compatibleProcesses_ = new HashMap<Integer, Vector<Integer>>();
    private Vector<Integer> thisCompatibleProcesses_ = null;
    private boolean dirtyThisCompatibleProcesses_ = true;
    private static Vector<MCProcessType> allProcs;
    private float lumi_;

    //cache the process_types so we only look them up in the DB once.
    private static HashMap<Integer, MCProcessType> knownProcs_ = 
    new HashMap<Integer, MCProcessType>();

    //private static HashMap<Integer, Boolean> isValid_ = 
    //  new HashMap<Integer, Boolean>();
    private boolean valid_;

    public static final String HIGHET = "High ET";
    public static final String DIS = "DIS";
    public static final String MINBIAS = "Minimum Bias";
    public static final String CHARM = "Charm Only";
    public static final String CHARMDIS = "Charm Only DIS";
    public static final String BEAUTY = "Beauty Only";
    public static final String BEAUTYDIS = "Beauty Only DIS";
    public static final String ANNIHILATION = "Electron-positron annhilation";
    public static final String PHOTONPHOTON = "Photon Photon";
    public static final String PHOTONPARTON = "Photon Parton";
    public static final String PARTONPARTON = "Parton Parton";
    public static final String CHARMPHOTONPHOTON = "Charm Photon Photon";
    public static final String CHARMPHOTONPARTON = "Charm Photon Parton";
    public static final String CHARMPARTONPARTON = "Charm Parton Parton";
    public static final String BEAUTYPHOTONPHOTON = "Beauty Photon Photon";
    public static final String BEAUTYPHOTONPARTON = "Beauty Photon Parton";
    public static final String BEAUTYPARTONPARTON = "Beauty Parton Parton";
    //public static final String DIRECT = "Direct Photoproduction";
    //public static final String RESOLVED = "Resolved Photoproduction";
    
    public MCProcessType() {

    setIsValid(false);

    Vector<Integer> tmp = new Vector<Integer>(1);
    tmp.add(new Integer(-1));

    if(!compatibleProcesses_.containsKey(-1)){
        compatibleProcesses_.put(new Integer(-1), tmp);
        compatibleProcesses_.put(new Integer(0), tmp);
    }

    }
    public MCProcessType(int id) {

    if(knownProcs_.containsKey(new Integer(id))){
        
        MCProcessType proc = knownProcs_.get(new Integer(id));
        
        this.processId = proc.getId();
        this.collision = proc.getCollision(); 
        this.processName = proc.getMCProcessName();
        this.lumi_ = proc.getDefaultLumi();
        // new, JMB
        this.valid_ = proc.isValid();
        //this = knownProcs_.get(id);
    }else{
        
        this.processId = id;
        if(id>0){
        try {
            
            DBManager.selectFromDB(this);
            
            //temporary until the DB contains the isValid column
            //and the compatible processes column
            
            //setIsValid(true);//set all processes valid for now
            
        } catch (Exception e){
            System.out.println(e);
        }
        
        knownProcs_.put(this.processId, this);
        }else{
        setIsValid(false);
        }
    }
    }

    public MCProcessType(String procName, Collision col){
    processName = procName;
    collision = col;
    getId();
    }


    public MCProcessType(MCProcessType proc) {
    this.processId = proc.getId();
    this.collision = proc.getCollision(); 
    this.processName = proc.getMCProcessName();
    this.lumi_ = proc.getDefaultLumi();
    }

    public int getId(){ 

    if (processId==0) {
        // See if this MCProcessType is one we understand.
        try {
        DBManager.selectId(this);
        } catch (Exception e){
        processId=-1;
        }
    }

    return processId; 
    }

    public void setDefaultLumi(float lumi){

    lumi_ = lumi;
    }

    public float getDefaultLumi(){
    return lumi_;
    }


    public int getProcessId(){
    return(getId());
    }

    public String getMCProcessName(){ return processName; }

    public String getProcessName(){
    return(getMCProcessName());
    }

    public void setMCProcessName(String name){ processName = name; 
    }

    //Duplicate setMCProcessName to match the entry in the DB:

    public void setProcessName(String name){
    setMCProcessName(name);
    return;
    }

    public Collision getCollision(){ 
    return collision; 
    }

    public void setId(int id){ 
    processId = id; 
    return;
    }
    public void setProcessId(int id){
    setId(id);
    return;
    }

    public void setCollision(Collision c){ collision = c; }

    //Allow the collision to be set from the collision Id in the DB:

    public void setCollisionId(int cId){
    try{
        collision = new Collision(cId);
    }catch(JetWebException err){
        System.out.println(err.getMessage());
    }
    return;
    }

    public int getCollisionId(){
    return(getCollision().getId());
    }

    public void setIsValid(boolean isValid){

    valid_=isValid;

    //System.out.println("called setIsValid "+isValid_.size()+" id "+processId);
    //if(isValid_.containsKey(this.processId))return;
    
    //isValid_.put(this.processId, isValid);
    return;
    }

    public boolean isValid(){
    //System.out.println("checking validity for process "+this.processId);
    //System.out.println("isValid "+isValid_);
    //return(isValid_.get(this.processId));
    return(valid_);
    }
 
    public boolean getIsValid(){
    return(isValid());
    }
  
    public Vector<Integer> getCompatibleProcesses(){

    if(dirtyThisCompatibleProcesses_){

        thisCompatibleProcesses_ = 
        compatibleProcesses_.get(this.processId);
        dirtyThisCompatibleProcesses_ = false;
    }
    
    //stop-gap measure for now until entries are in 
    //the process_type table of the DB.  If this process is a 
    //non-zero Id then it is compatible with itself
    //(zero id means it has not been initialised properly)

    if(thisCompatibleProcesses_==null&&processId>0){
        thisCompatibleProcesses_ = new Vector<Integer>();
        thisCompatibleProcesses_.add(this.processId);
    }

    return(thisCompatibleProcesses_);
    }
    /*  public byte[] getCompatibleProcesses(){

    return()
    }*/
 
    public void setCompatibleProcesses(Blob compat){

    if(compatibleProcesses_.containsKey(this.processId)) return;
    Vector<Integer> compatPIds = null;

    try{
        compatPIds = DBBlob2Array.getInteger(compat);
    }catch(SQLException err){
        System.out.println("Error: could not convert Blob to array");
        System.out.println(err.getMessage());
    }

    compatibleProcesses_.put(this.processId, compatPIds);
    thisCompatibleProcesses_ = compatPIds;
    dirtyThisCompatibleProcesses_ = false;
    return;
    }
    
    public void setCompatibleProcesses(Vector<Integer> compat){

    compatibleProcesses_.put(this.processId, compat);
    thisCompatibleProcesses_ = compat;
    dirtyThisCompatibleProcesses_ = false;


    return;
    }

    public Vector<String> getUnspecifiedParameters(){
    Vector<String> missing = new Vector<String>();
    if (collision==null) missing.add("collision");
    if (processName==null) missing.add("process name");
    return missing;
    }


    public static Vector<MCProcessType> getAll(boolean selectable){
    try {
        allProcs = DBManager.getAllMCProcessTypes(selectable);
    } catch (JetWebException j) {
        System.out.println(j);
        return null;
    }
    return allProcs; 
    }
    public static Vector<MCProcessType> getAll(Collision collision, boolean selectable){

    if (collision==null) { return getAll(selectable); } 
    try {
        Vector<MCProcessType> procs = 
        DBManager.getAllMCProcessTypes(collision,selectable);
        return procs;
    } catch (JetWebException j) {
        System.out.println(j);
        return null;
    }
    }

    public boolean matches(MCProcessType proc){

    if (processId>0 && proc.getId()>0) {
        if (proc.getId()==processId) { 
        return true; 
        } else {
        return false;
        }
    }

    if (getCollision()!=null){
        if (!getCollision().equals(proc.getCollision())) { 
        return false;
        }
    }

    if (processName.length()!=0 && proc.getMCProcessName().length()!=0 && 
        processName.equalsIgnoreCase(proc.getMCProcessName())) {return false;}


    //System.out.println("matched");

    return true;
    }

    public boolean equals(Object obj){

    if (obj==null) { return false; }

    if ( !this.getClass().equals(obj.getClass())  ) { return false; }

    MCProcessType p = (MCProcessType)obj;
    return (processId==p.getId());

    }

    public int compareTo(Object obj){

    boolean objNull = obj==null ||
        obj.getClass()!=this.getClass();
    //  boolean obj2Null = obj2==null ||
    //  obj2.getClass()!=this.getClass();

    //if(obj1Null && obj2Null) return 0;
    //if(obj1Null) return -1;
    //if(obj2Null) return 1;

    if(objNull) return -1;

    return this.getId() - ((MCProcessType)obj).getId();
    }

    public int hashCode(){ return processId; }


    public String getBeams(){

    String beams = getCollision().getParticle1().getName()+       
        getCollision().getParticle2().getName();       

    return beams;
    }

    public static boolean checkCollision(int collId, int procId) throws JetWebException {
    return DBManager.checkCollision(collId, procId);
    }

    
    // Below follow a series of "Short cut" access methods for
    // information which can be deduced from the contents of an
    // MCProcessType.

    public boolean hasPhoton(){

    if(getCollision()==null)return true;

    Particle p1 = getCollision().getParticle1();
    Particle p2 = getCollision().getParticle2();
    if (p1==null || p2==null) return true;

    if ((p1.getName().equalsIgnoreCase(Particle.ELECTRON) || 
         p1.getName().equalsIgnoreCase(Particle.POSITRON) ||
         p2.getName().equalsIgnoreCase(Particle.ELECTRON) || 
         p2.getName().equalsIgnoreCase(Particle.POSITRON)) &&
        processName.indexOf(DIS)<=0 &&
        !processName.equals(ANNIHILATION)){
        return true;
    }else {
        return false;
    }
    }
    public boolean hasProton(){
    if(getCollision()==null)return true;
    Particle p1 = getCollision().getParticle1();
    Particle p2 = getCollision().getParticle2();
    if (p1==null || p2==null) return true;

    if (p1.getName().equalsIgnoreCase(Particle.PROTON) || 
        p1.getName().equalsIgnoreCase(Particle.ANTIPROTON) ||
        p2.getName().equalsIgnoreCase(Particle.PROTON) || 
        p2.getName().equalsIgnoreCase(Particle.ANTIPROTON)){
        return true;
    }else {
        return false;
    }
    }


    public boolean isPhotoproduction(){
    if (hasProton()&&hasPhoton()) return true;
    return false;
    }

    public boolean isDIS(){
    if (processName.indexOf(DIS)>=0) return true;
    return false;
    }

    public boolean isGammaGamma(){
    if (hasPhoton() && !hasProton() && processName.indexOf(DIS)<=0) return true;
    return false;
    }

    public boolean isPP(){
    if (!hasPhoton() && hasProton() && processName.indexOf(DIS)<=0) return true;
    return false;
    }

    public String toString(){

    String name = null;
    
    if(processName!=null){
        name = new String(processName);
    }else{
        name = "";
    }

    int ii = name.indexOf(" "); 
    while(ii>-1){
        name = name.substring(0,ii)+name.substring(ii+1);
        ii = name.indexOf(" ");
    }
    StringBuffer str = new StringBuffer(name);
    
    if(collision!=null){
        str.append(collision.toString());
    }
    
    return str.toString();
    }

    public boolean store() throws JetWebException {
    return DBManager.addToDB(this); 
    }


    public boolean retrieve() throws JetWebException{
    DBManager.selectFromDB(this);
    return true;
    }

    public boolean delete() throws JetWebException{
    DBManager.deleteFromDB(this);
    return true;
    }


}

Generated Wed Jan 17 09:14:27 GMT 2007