StRoot: StEvent/StTriggerId.cxx Source File

00001 /***************************************************************************
00002  *
00003  * $Id: StTriggerId.cxx,v 2.5 2011/02/02 20:20:10 ullrich Exp $
00004  *
00005  * Author: Thomas Ullrich, January 2003
00006  ***************************************************************************
00007  *
00008  * Description:
00009  *
00010  ***************************************************************************
00011  *
00012  * $Log: StTriggerId.cxx,v $
00013  * Revision 2.5  2011/02/02 20:20:10  ullrich
00014  * Extend to 64 bit (Jamie)
00015  *
00016  * Revision 2.4  2005/08/16 22:36:27  ullrich
00017  * Fixed bug in copy and assignement operator (mMask not assigned).
00018  *
00019  * Revision 2.3  2004/10/11 23:00:20  ullrich
00020  * Add copy constructor and assign. op., implement ostream op., define to enum.
00021  *
00022  * Revision 2.2  2003/02/18 21:34:46  jeromel
00023  * Changed vector to arrays
00024  *
00025  * Revision 2.1  2003/01/30 18:14:15  ullrich
00026  * Initial Revision.
00027  *
00028  **************************************************************************/
00029 #include "StTriggerId.h"
00030 #include "StMessMgr.h"
00031 
00032 
00033 ClassImp(StTriggerId)
00034 
00035 StTriggerId::StTriggerId() : mMask(0) {
00036     mIdx = 0;
00037     for(int i=0 ; i < mMaxTriggerIds ; ++i) {
00038         mId[i]                = 0;
00039         mVersion[i]           = 0;
00040         mNameVersion[i]       = 0;
00041         mThresholdVersion[i]  = 0;
00042         mPrescaleVersion[i]   = 0;
00043     }
00044 }
00045 
00046 StTriggerId::~StTriggerId()  {/* noop */}
00047 
00048 StTriggerId::StTriggerId(const StTriggerId &id) {
00049     mIdx = id.mIdx;
00050     mMask = id.mMask;
00051     for(int i=0 ; i < mMaxTriggerIds ; ++i){
00052         mId[i]                = id.mId[i];
00053         mVersion[i]           = id.mVersion[i];
00054         mNameVersion[i]       = id.mNameVersion[i];
00055         mThresholdVersion[i]  = id.mThresholdVersion[i];
00056         mPrescaleVersion[i]   = id.mPrescaleVersion[i];
00057     }  
00058 }
00059 
00060 const StTriggerId &StTriggerId::operator=(const StTriggerId &id) {
00061     if (&id==this) return id;
00062   
00063     mIdx = id.mIdx;
00064     mMask = id.mMask;
00065     
00066     for(int i=0 ; i < mMaxTriggerIds ; ++i) {
00067         mId[i]                = id.mId[i];
00068         mVersion[i]           = id.mVersion[i];
00069         mNameVersion[i]       = id.mNameVersion[i];
00070         mThresholdVersion[i]  = id.mThresholdVersion[i];
00071         mPrescaleVersion[i]   = id.mPrescaleVersion[i];
00072     }  
00073     return *this;
00074 }
00075 
00076 unsigned int
00077 StTriggerId::index(unsigned int id) const
00078 {
00079     for (unsigned int i=0; i<mMaxTriggerIds; i++)
00080         if (id == mId[i]) return i;
00081     return mMaxTriggerIds; // no index found (no such trigger id)
00082 }
00083 
00084 uint64_t
00085 StTriggerId::mask() const {return mMask;}
00086 
00087 bool
00088 StTriggerId::isTrigger(unsigned int id) const
00089 {
00090     return index(id) < mMaxTriggerIds;
00091 }
00092 
00093 unsigned int
00094 StTriggerId::version(unsigned int id) const
00095 {
00096     unsigned int i = index(id);
00097     if (i < mMaxTriggerIds)
00098         return mVersion[i];
00099     else
00100         return 0;
00101 }
00102 
00103 unsigned int
00104 StTriggerId::nameVersion(unsigned int id) const
00105 {
00106     unsigned int i = index(id);
00107     if (i < mMaxTriggerIds)
00108         return mNameVersion[i];
00109     else
00110         return 0;
00111 }
00112 
00113 unsigned int
00114 StTriggerId::thresholdVersion(unsigned int id) const
00115 {
00116     unsigned int i = index(id);
00117     if (i < mMaxTriggerIds)
00118         return mThresholdVersion[i];
00119     else
00120         return 0;
00121 }
00122 
00123 unsigned int
00124 StTriggerId::prescaleVersion(unsigned int id) const    
00125 {
00126     unsigned int i = index(id);
00127     if (i < mMaxTriggerIds)
00128         return mPrescaleVersion[i];
00129     else
00130         return 0;
00131 }
00132 
00133 vector<unsigned int>
00134 StTriggerId::triggerIds() const {
00135     vector<unsigned int> retVec;
00136     for (unsigned int i=0; i< mMaxTriggerIds; ++i) {
00137         if (mId[i]) retVec.push_back(mId[i]);
00138     }
00139     
00140     return retVec;
00141 }
00142 
00143 void
00144 StTriggerId::setMask(uint64_t val) {mMask = val;}
00145 
00146 void
00147 StTriggerId::addTrigger(unsigned int id, unsigned int v,
00148                     unsigned int nv, unsigned int tv,
00149                     unsigned int pv)
00150 {
00151     if( mIdx >= mMaxTriggerIds){
00152         gMessMgr->Warning() << "StTriggerId::addTrigger : MAX Dimension reached. Cannot add !!" << endm;
00153     }
00154     else {
00155         mId[mIdx]               = id;
00156         mVersion[mIdx]          = v;
00157         mNameVersion[mIdx]      = nv;
00158         mThresholdVersion[mIdx] = tv;
00159         mPrescaleVersion[mIdx]  = pv;
00160         ++mIdx;
00161     }
00162 }
00163 
00164 ostream& operator<<(ostream& os, const StTriggerId& id)
00165 {
00166     for (unsigned int i=0; i<id.maxTriggerIds(); i++) {
00167         os << i << '\t'
00168            << id.mId[i] << '\t'
00169            << id.mVersion[i] << '\t'
00170            << id.mNameVersion[i] << '\t'
00171            << id.mThresholdVersion[i] << '\t'
00172            << id.mPrescaleVersion[i] << endl;
00173     }
00174     return os;
00175 }