Clock jump defaults

StRoot/StETofCalibMaker/StETofCalibMaker.cxx

@@ -127,7 +127,9 @@ StETofCalibMaker::StETofCalibMaker( const char* name )
   mStateMapStop(0),
   mDbEntryStart(0),
   mDbEntryStop(0),
-  mGlobalCounter(1)
+  mGlobalCounter(1),
+  mCalState(false)
+
 
 {
     /// default constructor
@@ -201,7 +203,12 @@ StETofCalibMaker::InitRun( Int_t runnumber )
     // --------------------------------------------------------------------------------------------
 
     //Get4 status map
-
+    for(int i=0; i < eTofConst::nGet4sInSystem; i++){
+      mGet4StateMap[i] = 0;
+      if(i < (eTofConst::nGet4sInSystem/2)){
+	mGet4DefaultStateMap[i] = 0;
+      }
+    }
     readGet4State(mGlobalCounter , 0);
 
     // electronics-to-hardware map
@@ -1459,7 +1466,7 @@ StETofCalibMaker::processMuDst()
 		if (hasPulsersVec.size() == 108){
 		  etofHeader->setHasPulsersVec(hasPulsersVec);
 	  	} 
-		
+
 		//fill good event flag into header
 		for( unsigned int iGet4 = 0; iGet4 < 1728; iGet4++){
 		  goodEventFlagVec.push_back(!etofHeader->missMatchFlagVec().at(iGet4));
@@ -2168,7 +2175,10 @@ StETofCalibMaker::applyCalibration( StETofDigi* aDigi, StETofHeader* etofHeader
 	double stateCorr =0;
 	if(mGet4StateMap[get4Id] == 1) stateCorr =  6.25;
 	else if(mGet4StateMap[get4Id] == 2) stateCorr =  -6.25;
-	// else if(mGet4StateMap[get4Id] == 3) stateCorr =  0.0;
+
+	// only calibrate here if flag is set
+	if(!mCalState) stateCorr = 0;
+
 
         double calibTime = aDigi->rawTime() - mResetTime
                                             - resetTimeCorr()
@@ -2689,12 +2699,12 @@ void StETofCalibMaker::readGet4State(int fileNr, short forward){
    std::vector< unsigned long int > intVec;
 
    //first read
-    if(forward == 0) mGlobalCounter = 1;
+    if(forward == 0) mGlobalCounter = 0;
     //jump forward
-    else if(forward > 0) mGlobalCounter++;
+    else if(forward > 0){ mGlobalCounter++;
     //jump backward
-    else mGlobalCounter--; // forward < 0
-    
+    }else {mGlobalCounter--;} // forward < 0
+
     if(mGlobalCounter == 0){
       mGlobalCounter++;
       fileZero = true;
@@ -2743,7 +2753,7 @@ void StETofCalibMaker::readGet4State(int fileNr, short forward){
     std::map<unsigned long int,vector<int>> stateVec;
     std::map<unsigned long int ,vector<int>> get4IdVec;
 
-    decodeInt(intVec , mGet4StateMap , mGet4ZeroStateMap , startVec , mMasterStartVec , stateVec , get4IdVec); 	
+    decodeInt(intVec , mGet4StateMap , mGet4ZeroStateMap , startVec , mMasterStartVec , stateVec , get4IdVec, mGet4DefaultStateMap); 	
 
    // fill stateMap & steering vecs with EvtZero entries: read in first 1728 states & times
    for(int i = 0; i< eTofConst::nGet4sInSystem;i++){
@@ -2858,9 +2868,11 @@ void StETofCalibMaker::checkGet4State(unsigned long int eventNr){
 
 }
 //-----------------------------------------------------
-void StETofCalibMaker::decodeInt( std::vector<unsigned long int> intVec ,std::map<int , short>& mGet4StateMap ,std::map<int , short>& mGet4ZeroStateMap ,std::vector<unsigned long int>& startVec ,std::vector<unsigned long int>& mMasterStartVec ,std::map<unsigned long int,vector<int>>& stateVec ,std::map<unsigned long int,vector<int>>& get4IdVec){
+void StETofCalibMaker::decodeInt( std::vector<unsigned long int> intVec ,std::map<int , short>& mGet4StateMap ,std::map<int , short>& mGet4ZeroStateMap ,std::vector<unsigned long int>& startVec ,std::vector<unsigned long int>& mMasterStartVec ,std::map<unsigned long int,vector<int>>& stateVec ,std::map<unsigned long int,vector<int>>& get4IdVec, std::map<int , short>& mGet4DefaultStateMap){
 
   unsigned long int lastEvtId =0;
+  std::map<int, std::vector< stateStruct > > stateMap;
+
 
     for(unsigned int i = 0; i < intVec.size(); i++){
 
@@ -2873,9 +2885,40 @@ void StETofCalibMaker::decodeInt( std::vector<unsigned long int> intVec ,std::ma
 	int Get4Id2;
 	int get4state2;
 
-      // decode nonZero/stateChange ints ( int = 42.xxx.xxx.xxx = 2 states only)
+	stateStruct struct1;
+	stateStruct struct2;
+
 	switch (intVec.at(i) / 100000000) {
-
+
+	//decode default jump states
+        case 39 :
+
+	tmp       = intVec.at(i) % 3900000000;
+	stateInt1 = tmp / 10000;
+        stateInt2 = tmp % 10000;
+
+        Get4Id1 = -1;
+	get4state1 = -1;
+	Get4Id2 = -1;
+	get4state2 = -1;
+
+	if(stateInt1 < 6912){
+	  Get4Id1 = stateInt1 % (eTofConst::nGet4sInSystem/2);  
+	  get4state1 = stateInt1 / (eTofConst::nGet4sInSystem/2);
+	}
+	if(stateInt2 < 6912){
+	  Get4Id2 = stateInt2 % (eTofConst::nGet4sInSystem/2);
+	  get4state2 = stateInt2 / (eTofConst::nGet4sInSystem/2);
+	}
+
+	if(i < (eTofConst::nGet4sInSystem/4) ){  
+	  mGet4DefaultStateMap[Get4Id1] = get4state1;
+	  mGet4DefaultStateMap[Get4Id2] = get4state2;
+	} 
+
+	break;  
+
+	// decode nonZero/stateChange ints ( int = 42.xxx.xxx.xxx = 2 states only)
 	case 42	:	
 	tmp       = intVec.at(i) % 4200000000;
 	stateInt1 = tmp / 10000;
@@ -2895,7 +2938,8 @@ void StETofCalibMaker::decodeInt( std::vector<unsigned long int> intVec ,std::ma
 	  get4state2 = stateInt2 / eTofConst::nGet4sInSystem;
 	}
 
-	if(i < 864){	  
+	if(i >= (eTofConst::nGet4sInSystem/4) && i < ((eTofConst::nGet4sInSystem/4) + (eTofConst::nGet4sInSystem/2))){	  
+
 	  mGet4StateMap[Get4Id1] = get4state1;
 	  mGet4StateMap[Get4Id2] = get4state2;
 	  mGet4ZeroStateMap[Get4Id1] = get4state1;
@@ -2906,6 +2950,18 @@ void StETofCalibMaker::decodeInt( std::vector<unsigned long int> intVec ,std::ma
 	stateVec[lastEvtId].push_back(get4state2);
 	get4IdVec[lastEvtId].push_back(Get4Id2);
 
+	//stateStruct struct1;
+	struct1.get4Id = Get4Id1;
+	struct1.state  = get4state1;
+	struct1.evtId  = lastEvtId;
+	//stateStruct struct2;
+	struct2.get4Id = Get4Id2;
+	struct2.state  = get4state2;
+	struct2.evtId  = lastEvtId;
+
+	stateMap[Get4Id1].push_back(struct1);
+	stateMap[Get4Id2].push_back(struct2);
+
 	break;
 
         //decode eventnumber ( int = 40.xxx.xxx.xxx = event number ) 
@@ -2936,10 +2992,37 @@ void StETofCalibMaker::decodeInt( std::vector<unsigned long int> intVec ,std::ma
 	stateVec[lastEvtId].push_back(get4state1);
 	get4IdVec[lastEvtId].push_back(Get4Id1);
 
+	//stateStruct struct1;
+	struct1.get4Id = Get4Id1;
+	struct1.state  = get4state1;
+	struct1.evtId  = lastEvtId;
+
+	stateMap[Get4Id1].push_back(struct1);
+
 	break;
 
 	default:
 	LOG_ERROR << "Get4 state not well defined -> Check db / state file !" << endm;	
      }
    }
+
+    //sort vecs (necessary due to get4 splitting)   
+    std::sort(startVec.begin(), startVec.end());
+    std::sort(mMasterStartVec.begin(), mMasterStartVec.end());
+
+    for(unsigned int i=0; i< 1728;i++){
+
+     std::vector<stateStruct> tmpVec = stateMap.at(i);
+
+     for(unsigned int j=0; j < stateMap.at(i).size();j++){
+       tmpVec.push_back(stateMap.at(i).at(j));
+     }
+     std::sort(tmpVec.begin(), tmpVec.end(), [] (stateStruct x, stateStruct  y) { return x.evtId < y.evtId; } );
+
+     for(unsigned int j=0; j< tmpVec.size();j++){
+
+       stateVec[tmpVec.at(j).evtId].push_back(tmpVec.at(j).state);
+       get4IdVec[tmpVec.at(j).evtId].push_back(tmpVec.at(j).get4Id);
+     }     
+   }
 }

StRoot/StETofCalibMaker/StETofCalibMaker.h

@@ -84,13 +84,17 @@ class StETofCalibMaker: public StMaker {
     void setFileNameResetTimeCorr(      const char* fileName );
     void setFileNamePulserTotPeak(      const char* fileName );
     void setFileNamePulserTimeDiffGbtx( const char* fileName );
+    void setCalState(         const bool calTrue );
+    bool calState();
 
     void setDoQA(  const bool doQA  );
     void setDebug( const bool debug );
     void setStrictPulserHandling( const bool debug );
     void setReferencePulserIndex( const int index );
 
     short GetState(int);
+    short GetDefaultState(int);
+
 
     //moved to public to avoid problem with root6
     struct StructStuckFwDigi{
@@ -103,6 +107,12 @@ class StETofCalibMaker: public StMaker {
 		  }
     };
 
+   struct stateStruct{
+      int     get4Id;
+      unsigned long int  evtId;
+      Double_t  state;
+    };
+
 
 private:
     bool isFileExisting( const std::string fileName );
@@ -206,19 +216,28 @@ class StETofCalibMaker: public StMaker {
     std::vector<unsigned long int> mMasterStartVec;
     std::map<int , short>          mGet4StateMap;
     std::map<int , short>          mGet4ZeroStateMap;
+    std::map<int , short>          mGet4DefaultStateMap;
+
     unsigned long int              mStateMapStart;
     unsigned long int              mStateMapStop;
     unsigned long int              mDbEntryStart;
     unsigned long int              mDbEntryStop;
     int                            mGlobalCounter;
+    bool                           mCalState;
+
+    void decodeInt( std::vector<unsigned long int> intVec ,std::map<int , short>& mGet4StateMap ,std::map<int , short>& mGet4ZeroStateMap ,std::vector<unsigned long int>& startVec ,std::vector<unsigned long int>& mMasterStartVec ,std::map<unsigned long int,vector<int>>& stateVec ,std::map<unsigned long int,vector<int>>& get4IdVec, std::map<int , short>&  mGet4DefaultStateMap);
 
-    void decodeInt( std::vector<unsigned long int> intVec ,std::map<int , short>& mGet4StateMap ,std::map<int , short>& mGet4ZeroStateMap ,std::vector<unsigned long int>& startVec ,std::vector<unsigned long int>& mMasterStartVec ,std::map<unsigned long int,vector<int>>& stateVec ,std::map<unsigned long int,vector<int>>& get4IdVec);
 
     virtual const Char_t *GetCVS() const { static const char cvs[]="Tag $Name:  $Id: built " __DATE__ " " __TIME__ ; return cvs; }
 
     ClassDef( StETofCalibMaker, 0 )
 };
-inline short StETofCalibMaker::GetState(         int get4 )     { return mGet4StateMap.at(get4); }
+
+inline bool  StETofCalibMaker::calState(                                          )     { return mCalState; }
+inline short StETofCalibMaker::GetDefaultState(                          int get4 )     { return mGet4DefaultStateMap.at(get4); }
+inline short StETofCalibMaker::GetState(                                 int get4 )     { return mGet4StateMap.at(get4); }
+inline void StETofCalibMaker::setCalState(                   const bool calTrue   )     { mCalState         = calTrue; }
+
 inline void StETofCalibMaker::setFileNameCalibParam(         const char* fileName )     { mFileNameCalibParam         = fileName; }
 inline void StETofCalibMaker::setFileNameElectronicsMap(     const char* fileName )     { mFileNameElectronicsMap     = fileName; }
 inline void StETofCalibMaker::setFileNameStatusMap(          const char* fileName )     { mFileNameStatusMap          = fileName; }