Added some extra scripts.

[u/mrichter/AliRoot.git] / TOF / AliTOFTrigger.cxx

diff --git a/TOF/AliTOFTrigger.cxx b/TOF/AliTOFTrigger.cxx
index a5bbbf243fe90d509e8bc70a79cde9cc28bbfba3..4e1768ca6473eb4da1de319e7fc84e77f63974f6 100644 (file)
--- a/TOF/AliTOFTrigger.cxx
+++ b/TOF/AliTOFTrigger.cxx
@@ -47,6 +47,10 @@
 #include "AliTOFTrigger.h"
 #include "AliTOFTriggerMask.h"
 
+#include "AliCDBManager.h"
+#include "AliCDBEntry.h"
+
+
 extern AliRun* gAlice;
 
 //-------------------------------------------------------------------------
@@ -74,8 +78,10 @@ ClassImp(AliTOFTrigger)
     fTOFTrigMask(0)
 {
   //main ctor
+  for (Int_t i=0;i<kNCTTM;i++) fLTMarray[i] = kFALSE;
+
   for (Int_t i=0;i<kNLTM;i++){
-  fLTMarray[i] = kFALSE;  //*******************************************************************************************************
+
     for (Int_t j=0;j<kNLTMchannels;j++){
       fLTMmatrix[i][j]=kFALSE;
     }
@@ -120,8 +126,8 @@ AliTOFTrigger::AliTOFTrigger(Int_t HighMultTh, Int_t ppMBTh, Int_t MultiMuonTh,
   fTOFTrigMask(0)
 {
   //ctor with thresholds for triggers
+  for (Int_t i=0;i<kNCTTM;i++) fLTMarray[i] = kFALSE;
   for (Int_t i=0;i<kNLTM;i++){
-  fLTMarray[i] = kFALSE;  //*******************************************************************************************************
     for (Int_t j=0;j<kNLTMchannels;j++){
       fLTMmatrix[i][j]=kFALSE;
     }
@@ -142,6 +148,8 @@ AliTOFTrigger::AliTOFTrigger(Int_t HighMultTh, Int_t ppMBTh, Int_t MultiMuonTh,
   CreateInputs();
 }
 
+
+#if 0 /*** COPY CONSTRUCTOR SUPPRESSED **/
 //____________________________________________________________________________
 
 AliTOFTrigger::AliTOFTrigger(const AliTOFTrigger & tr):
@@ -165,8 +173,8 @@ AliTOFTrigger::AliTOFTrigger(const AliTOFTrigger & tr):
   fTOFTrigMask(0)
 {
   //copy ctor
+  for (Int_t i=0;i<kNCTTM;i++) fLTMarray[i] = kFALSE;
   for (Int_t i=0;i<kNLTM;i++){
-  fLTMarray[i] = tr.fLTMarray[i]; 
     for (Int_t j=0;j<kNLTMchannels;j++){
       fLTMmatrix[i][j]=tr.fLTMmatrix[i][j];
     }
@@ -193,6 +201,7 @@ AliTOFTrigger::AliTOFTrigger(const AliTOFTrigger & tr):
   CreateInputs();
 
 }
+#endif /*** COPY CONTRUCTOR SUPPRESSED ***/
 
 //----------------------------------------------------------------------
 
@@ -435,12 +444,20 @@ void AliTOFTrigger::CreateLTMMatrixFromDigits() {
   //
 
   //initialization
+  for (Int_t i=0;i<kNCTTM;i++) fLTMarray[i]= kFALSE;
   for (Int_t i=0;i<kNLTM;i++){
-  fLTMarray[i]= kFALSE;
     for (Int_t j=0;j<kNLTMchannels;j++){
       fLTMmatrix[i][j]=kFALSE;
     }
   }
+  for (Int_t i=0;i<kNCTTM;i++){
+      for (Int_t j=0;j<kNCTTMchannels;j++){
+         fCTTMmatrixFront[i][j]=kFALSE;
+         fCTTMmatrixBack[i][j]=kFALSE;
+      }
+  }
+
+
   AliRunLoader *rl;
   rl = AliRunLoader::Instance();
 
@@ -451,10 +468,10 @@ void AliTOFTrigger::CreateLTMMatrixFromDigits() {
 
   tofLoader->LoadDigits("read");
   TTree *treeD = tofLoader->TreeD();
-  if (treeD == 0x0)
-    {
-      AliFatal("AliTOFTrigger: Can not get TreeD");
-    }
+  if (treeD == 0x0) {
+    AliFatal("AliTOFTrigger: Can not get TreeD");
+    return;
+  }
 
   TBranch *branch = treeD->GetBranch("TOF");
   if (!branch) {
@@ -483,10 +500,8 @@ void AliTOFTrigger::CreateLTMMatrixFromDigits() {
     GetLTMIndex(detind,indexLTM);
 
     fLTMmatrix[indexLTM[0]][indexLTM[1]] = kTRUE;
-    fLTMarray[indexLTM[0]%36] = kTRUE; //dimensione MAX array 36 = kNCTTM 
+//    fLTMarray[indexLTM[0]%36] = kTRUE; //dimensione MAX array 36 = kNCTTM 
     }
-  fNCrateOn = 0; 
-  for(Int_t j=0; j < kNCTTM; j++) {if(fLTMarray[j]) fNCrateOn++;}
 
 
   tofLoader->UnloadDigits();
@@ -508,6 +523,12 @@ void AliTOFTrigger::CreateLTMMatrixFromRaw(AliRawReader *fRawReader) {
       fLTMmatrix[i][j]=kFALSE;
     }
   }
+  for (Int_t i=0;i<kNCTTM;i++){
+      for (Int_t j=0;j<kNCTTMchannels;j++){
+         fCTTMmatrixFront[i][j]=kFALSE;
+         fCTTMmatrixBack[i][j]=kFALSE;
+      }
+  }
 
   if(fRawReader){
     AliTOFRawStream * tofRawStream = new AliTOFRawStream();
@@ -538,7 +559,7 @@ void AliTOFTrigger::CreateLTMMatrixFromRaw(AliRawReader *fRawReader) {
     for (indexDDL=0; indexDDL<AliDAQ::NumberOfDdls("TOF"); indexDDL++) {
       
       fRawReader->Reset();
-      tofRawStream->LoadRawData(indexDDL);
+      tofRawStream->LoadRawDataBuffersV2(indexDDL);
       
       clonesRawData = tofRawStream->GetRawData();
       if (clonesRawData->GetEntriesFast()!=0) AliInfo(Form(" TOF raw data number = %3d", clonesRawData->GetEntriesFast()));
@@ -581,6 +602,8 @@ void AliTOFTrigger::CreateLTMMatrixFromRaw(AliRawReader *fRawReader) {
     //if (fVerbose==2) ftxt.close();
 
     if (inholes) AliWarning(Form("Clusters in the TOF holes: %d",inholes));
+    delete tofRawStream;
+    tofRawStream = NULL;
 
   }
 
@@ -676,6 +699,19 @@ void AliTOFTrigger::PrintMap()
 */
 //-------------------------------------------------------------------------
 
+void AliTOFTrigger::GetMapMatrix(Bool_t map[][24]) const
+{
+  //
+  // Returns CTTM map
+  //
+
+  for(Int_t i = 0; i<kNLTM;i++)
+    for(Int_t j = 0; j<kNCTTMchannels;j++)
+      map[i][j]=(i<36)?fCTTMmatrixFront[i][j]:fCTTMmatrixBack[i-36][j];
+
+}
+//-------------------------------------------------------------------------
+
 void AliTOFTrigger::GetMap(Bool_t **map) const
 {
   //
@@ -684,31 +720,58 @@ void AliTOFTrigger::GetMap(Bool_t **map) const
 
   for(Int_t i = 0; i<kNLTM;i++)
     for(Int_t j = 0; j<kNCTTMchannels;j++)
-      map[i][j]=(i<36)?fCTTMmatrixFront[i][j]:fCTTMmatrixBack[i][j];
+      map[i][j]=(i<36)?fCTTMmatrixFront[i][j]:fCTTMmatrixBack[i-36][j];
 
 }
 
+
 //-------------------------------------------------------------------------
 void AliTOFTrigger::GetTRDmap(Bool_t **map) const
 {
   //
   // Retriev the bit map sent to the TRD detector
   //
+    
+    for(int i = 0; i<kNLTM;i++)
+       for(int j = 0; j<kNLTMtoTRDchannels;j++){
+           map[i][j]=kFALSE;
+       }
 
-  for(int i = 0; i<kNLTM;i++)
-    for(int j = 0; j<kNLTMtoTRDchannels;j++)
-      map[i][j]=kFALSE;
-
-  for(int i = 0; i<kNLTM/2;i++)
+    for(int i = 0; i<kNLTM/2;i++)
     for(int j = 0; j<AliTOFTrigger::kNCTTMchannels;j++){
-      UInt_t uTRDbit=j/3;
-      if(fCTTMmatrixFront[i][j]) map[i][uTRDbit]=kTRUE;
+       UInt_t uTRDbit=j/3;
+       if(fCTTMmatrixFront[i][j]) map[i][uTRDbit]=kTRUE;
     }
   for(int i = kNLTM/2; i<kNLTM;i++)
+      for(int j = 0; j<AliTOFTrigger::kNCTTMchannels;j++){
+         UInt_t uTRDbit=j/3;
+         if(fCTTMmatrixBack[i-kNLTM/2][j]) map[i][uTRDbit]=kTRUE;
+    }
+  
+}
+//-------------------------------------------------------------------------
+void AliTOFTrigger::GetTRDmapMatrix(Bool_t map[][8]) const
+{
+  //
+  // Retriev the bit map sent to the TRD detector
+  //
+    
+    for(int i = 0; i<kNLTM;i++)
+       for(int j = 0; j<kNLTMtoTRDchannels;j++){
+           map[i][j]=kFALSE;
+       }
+
+    for(int i = 0; i<kNLTM/2;i++)
     for(int j = 0; j<AliTOFTrigger::kNCTTMchannels;j++){
-      UInt_t uTRDbit=j/3;
-      if(fCTTMmatrixBack[i][j]) map[i][uTRDbit]=kTRUE;
+       UInt_t uTRDbit=j/3;
+       if(fCTTMmatrixFront[i][j]) map[i][uTRDbit]=kTRUE;
     }
+  for(int i = kNLTM/2; i<kNLTM;i++)
+      for(int j = 0; j<AliTOFTrigger::kNCTTMchannels;j++){
+         UInt_t uTRDbit=j/3;
+         if(fCTTMmatrixBack[i-kNLTM/2][j]) map[i][uTRDbit]=kTRUE;
+    }
+  
 }
 
 //-------------------------------------------------------------------------
@@ -723,7 +786,7 @@ void AliTOFTrigger::SetBit(Int_t *detind)
   if(index[0]<36)
     fCTTMmatrixFront[index[0]][index[1]]=kTRUE;
   else
-    fCTTMmatrixBack[index[0]][index[1]]=kTRUE;
+    fCTTMmatrixBack[index[0]-36][index[1]]=kTRUE;
 
 }
 
@@ -736,7 +799,8 @@ void AliTOFTrigger::SetBit(Int_t nDDL, Int_t nTRM, Int_t iChain,
   // labelled by number nDDL, nTRM, iChain, iTDC, iCH
   //
 
-  if(nTRM==3 && iTDC>12 && iTDC<14 && nDDL%2==1){ // DDL number to LTM number mapping
+    if(nTRM==3 && iTDC>=12 && iTDC<=14 && nDDL%2==1){ // DDL number to LTM number mapping
+//       getchar();
     Int_t iLTMindex=-1;
     Int_t iChannelIndex=-1;
     switch(nDDL%AliTOFGeometry::NDDL()){
@@ -757,13 +821,15 @@ void AliTOFTrigger::SetBit(Int_t nDDL, Int_t nTRM, Int_t iChain,
       iLTMindex++;
     iChannelIndex=iCH+iTDC*AliTOFGeometry::NCh()-12*AliTOFGeometry::NCh();
     Int_t index[2]={iLTMindex,iChannelIndex};
-    if (index[0]<36)
+    if (index[0]<36){
       fCTTMmatrixFront[index[0]][index[1]]=kTRUE;
-    else
-      fCTTMmatrixBack[index[0]][index[1]]=kTRUE;
-  }
-  else
-    AliError("Call this function only if(nTRM==3 && iTDC>12 && iTDC<14 && nDDL%2==1) ");
+      fLTMmatrix[index[0]][index[1]*2]=kTRUE;
+    }
+    else{
+       fCTTMmatrixBack[index[0]-36][index[1]]=kTRUE;
+       fLTMmatrix[index[0]][index[1]*2]=kTRUE;
+    }
+    }
 
 }
 //-------------------------------------------------------------------------
@@ -779,7 +845,7 @@ void AliTOFTrigger::ResetBit(Int_t *detind)
   if(index[0]<36)
     fCTTMmatrixFront[index[0]][index[1]]=kFALSE;
   else
-    fCTTMmatrixBack[index[0]][index[1]]=kFALSE;
+    fCTTMmatrixBack[index[0]-36][index[1]]=kFALSE;
 
 }
 
@@ -813,10 +879,12 @@ void AliTOFTrigger::ResetBit(Int_t nDDL, Int_t nTRM, Int_t iChain,
       iLTMindex++;
     iChannelIndex=iCH+iTDC*AliTOFGeometry::NCh()-12*AliTOFGeometry::NCh();
     Int_t index[2]={iLTMindex,iChannelIndex};
-    if (index[0]<36)
+    if (index[0]<36){
       fCTTMmatrixFront[index[0]][index[1]]=kFALSE;
-    else
-      fCTTMmatrixBack[index[0]][index[1]]=kFALSE;
+    }
+    else{
+      fCTTMmatrixBack[index[0]-36][index[1]]=kFALSE;
+    }
   }
   else
     AliError("Call this function only if(nTRM==3 && iTDC>12 && iTDC<14 && nDDL%2==1) ");
@@ -832,7 +900,7 @@ Bool_t AliTOFTrigger::GetBit(Int_t *detind)
 
   Int_t index[2];
   GetCTTMIndex(detind,index);
-  return (index[0]<36)?fCTTMmatrixFront[index[0]][index[1]]:fCTTMmatrixBack[index[0]][index[1]];
+  return (index[0]<36)?fCTTMmatrixFront[index[0]][index[1]]:fCTTMmatrixBack[index[0]-36][index[1]];
 
 }
 
@@ -874,7 +942,7 @@ Bool_t AliTOFTrigger::GetBit(Int_t nDDL, Int_t nTRM, Int_t iChain,
     iLTMindex++;
   iChannelindex=iCH+iTDC*AliTOFGeometry::NCh()-12*AliTOFGeometry::NCh();
   Int_t index[2]={iLTMindex,iChannelindex};
-  return (index[0]<36)?fCTTMmatrixFront[index[0]][index[1]]:fCTTMmatrixBack[index[0]][index[1]];
+  return (index[0]<36)?fCTTMmatrixFront[index[0]][index[1]]:fCTTMmatrixBack[index[0]-36][index[1]];
 
 }
 
@@ -884,18 +952,25 @@ void AliTOFTrigger::CreateCTTMMatrix() {
   //
   // Create CTTM bit map
   //
+    Int_t fromTriggertoDCS[72] = {0,1,4,5,8,9,12,13,16,17,20,21,24,25,28,29,32,33,36,37,40,41,44,45,48,49,52,53,56,57,60,61,64,65,68,69,3,
+                                 2,7,6,11,10,15,14,19,18,23,22,27,26,31,30,35,34,39,38,43,42,47,46,51,50,55,54,59,58,63,62,67,66,71,70};
+
+
     fNMaxipadOnAll=0;
     fNMaxipadOn=0;
 
     for(Int_t i = 0; i<kNLTM;i++){
        UInt_t currentMask = fPowerMask[kNCTTMchannels]-1;
-       if(fTOFTrigMask) currentMask=fTOFTrigMask->GetTriggerMask(i);
+       if(fTOFTrigMask) currentMask=fTOFTrigMask->GetTriggerMask(fromTriggertoDCS[i]);
        if(i<kNCTTM){
            for(Int_t j = 0; j<kNCTTMchannels;j++){
                fCTTMmatrixFront[i][j]=fLTMmatrix[i][2*j]||fLTMmatrix[i][2*j+1];
                if(fCTTMmatrixFront[i][j]) fNMaxipadOnAll++;
                if(!(currentMask & fPowerMask[j])) fCTTMmatrixFront[i][j]=0;
-               if(fCTTMmatrixFront[i][j]) fNMaxipadOn++;
+               if(fCTTMmatrixFront[i][j]){
+                   fNMaxipadOn++;
+                   fLTMarray[i] = kTRUE;
+               }
            }
        }
        else{
@@ -903,10 +978,17 @@ void AliTOFTrigger::CreateCTTMMatrix() {
                fCTTMmatrixBack[i-kNCTTM][j]=fLTMmatrix[i][2*j]||fLTMmatrix[i][2*j+1];;
                if(fCTTMmatrixBack[i-kNCTTM][j]) fNMaxipadOnAll++;
                if(!(currentMask & fPowerMask[j])) fCTTMmatrixBack[i-kNCTTM][j]=0;
-               if(fCTTMmatrixBack[i-kNCTTM][j]) fNMaxipadOn++;
+               if(fCTTMmatrixBack[i-kNCTTM][j]){
+                   fNMaxipadOn++;
+                   fLTMarray[i-kNCTTM] = kTRUE;
+               }
            }
        }
     }
+  
+    fNCrateOn = 0; 
+    for(Int_t j=0; j < kNCTTM; j++) {if(fLTMarray[j]) fNCrateOn++;}
+
 }     
 //-----------------------------------------------------------------------------
 
@@ -924,12 +1006,29 @@ void AliTOFTrigger::LoadActiveMask(){
 //
 // Load OCDB current mask
 //
-    UInt_t maskArray[kNLTM];
-    if(fTOFTrigMask == NULL) fTOFTrigMask = new AliTOFTriggerMask();
-    for (Int_t k = 0; k < kNLTM ; k++) maskArray[k] = fPowerMask[kNCTTMchannels]-1;
-    for (Int_t k = 0; k < kNLTM ; k+=2) maskArray[k] = 0;
+
+    AliCDBManager *cdb = AliCDBManager::Instance();
+    if(cdb->GetRun() < 0 || !(cdb->GetDefaultStorage())){
+       if(!(cdb->GetDefaultStorage())){
+           cdb->SetDefaultStorage("local://$ALICE_ROOT/OCDB");
+           printf("AliTOFTrigger (WARNING): probably CDB first instance - Default Sorage set to \"local://$ALICE_ROOT/OCDB\"\n");
+       }
+       if(cdb->GetRun() < 0){
+           cdb->SetRun(0);
+         printf("AliTOFTrigger (WARNING): probably CDB first instance - number of run set to 0\n");
+       }
+    }
+
+    AliCDBEntry *cdbe = cdb->Get("TRIGGER/TOF/TriggerMask");
+    if(!cdbe) return;
+    fTOFTrigMask= (AliTOFTriggerMask *)cdbe->GetObject();
+    
+//     UInt_t maskArray[kNLTM];
+//     if(fTOFTrigMask == NULL) fTOFTrigMask = new AliTOFTriggerMask();
+//     for (Int_t k = 0; k < kNLTM ; k++) maskArray[k] = fPowerMask[kNCTTMchannels]-1;
+//     //for (Int_t k = 0; k < kNLTM ; k+=2) maskArray[k] = 0;
     
-    fTOFTrigMask->SetTriggerMaskArray(maskArray);
+//     fTOFTrigMask->SetTriggerMaskArray(maskArray);
 }
 
 
@@ -938,8 +1037,6 @@ AliTOFTrigger::~AliTOFTrigger()
 {
   // dtor
 
-  if (fTOFTrigMask) delete fTOFTrigMask;
-
 }
 
 //-----------------------------------------------------------------------------
@@ -949,3 +1046,4 @@ AliTOFTrigger& AliTOFTrigger::operator=(const AliTOFTrigger &/*source*/)
   return *this;
 
 }
+