Allows to cut on the number of TRD tracklets, the momentum in the TRD chambers and...
authorcblume <cblume@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 22 Dec 2011 13:43:36 +0000 (13:43 +0000)
committercblume <cblume@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 22 Dec 2011 13:43:36 +0000 (13:43 +0000)
TRD/AliTRDCalibTask.cxx
TRD/AliTRDCalibTask.h
TRD/AliTRDCalibraFillHisto.cxx
TRD/AliTRDCalibraFillHisto.h

index 4e10a69..3718d84 100644 (file)
@@ -125,7 +125,10 @@ ClassImp(AliTRDCalibTask)
       fVector2d(kFALSE),
       fVdriftLinear(kTRUE),
       fExbAlt(kFALSE),
+      fDebugLevelTRDCalibraFillHisto(0),
       fNbTimeBins(0),
+      fNumberBinCharge(50),
+      fSelectTrigger(kTRUE),
       fSelectedTrigger(new TObjArray()),
       fRejected(kTRUE),
       fEsdTrackCuts(0),
@@ -135,7 +138,10 @@ ClassImp(AliTRDCalibTask)
       fMinNbContributors(0),
       fRangePrimaryVertexZ(9999999.0),
       fMinNbTracks(9),
-      fMaxNbTracks(500),
+      fMaxNbTracks(999999999),
+      fCutWithVdriftCalib(kFALSE),
+      fMinNbTRDtracklets(0),
+      fMinTRDMomentum(0),
       fLow(0),
       fHigh(30),
       fFillZero(kFALSE),
@@ -259,6 +265,10 @@ void AliTRDCalibTask::UserCreateOutputObjects()
   // instance calibration 
   fTRDCalibraFillHisto = AliTRDCalibraFillHisto::Instance();
   if(fOnInstance) {
+    fTRDCalibraFillHisto->SetNumberBinCharge(fNumberBinCharge); // set number of bin of the charge distribution
+    fTRDCalibraFillHisto->SetCutWithVdriftCalib(fCutWithVdriftCalib); // cut vdrift
+    fTRDCalibraFillHisto->SetMinNbTRDtracklets(fMinNbTRDtracklets); // min number of TRD tracklets
+    fTRDCalibraFillHisto->SetMinTRDMomentum(fMinTRDMomentum); // min TRD momentum
     fTRDCalibraFillHisto->SetHisto2d(fHisto2d); // choose to use histograms
     fTRDCalibraFillHisto->SetVector2d(fVector2d); // choose to use vectors
     fTRDCalibraFillHisto->SetCH2dOn();  // choose to calibrate the gain
@@ -295,7 +305,7 @@ void AliTRDCalibTask::UserCreateOutputObjects()
     fTRDCalibraFillHisto->SetNumberClustersf(fHigh); // At least 11 clusters
     
     // For testing only
-    if(fDebug > 2) fTRDCalibraFillHisto->SetDebugLevel(1); //debug stuff
+    fTRDCalibraFillHisto->SetDebugLevel(fDebugLevelTRDCalibraFillHisto); //debug stuff
     
     if(fHisto2d) {  
       fListHist->Add(fTRDCalibraFillHisto->GetCH2d());
@@ -558,7 +568,7 @@ void AliTRDCalibTask::UserExec(Option_t *)
   ///////////////////
   Bool_t pass = kTRUE;
 
-  if (strstr(type,"p-p")) {
+  if (fSelectTrigger) {
    
     //printf("Will check the triggers\n");
 
@@ -772,7 +782,7 @@ void AliTRDCalibTask::UserExec(Option_t *)
 
     if(good && fOnInstance) {
       //cout << "good" << endl;
-      fTRDCalibraFillHisto->UpdateHistogramsV1(fTrdTrack);
+      fTRDCalibraFillHisto->UpdateHistogramsV1(fTrdTrack,fkEsdTrack);
       //printf("Fill fTRDCalibraFillHisto\n");
     }
       
index ed82a49..7bc07dc 100644 (file)
@@ -56,10 +56,14 @@ class AliTRDCalibTask : public AliAnalysisTaskSE {
   void SetVdriftLinear(Bool_t vdriftLinear)                         {fVdriftLinear = vdriftLinear;};
   void SetExbAlt(Bool_t exbalt)                                     {fExbAlt = exbalt;};
   void SetNbTimeBins(Int_t nbTimeBins)                              {fNbTimeBins=nbTimeBins;};  
+  void SetNumberBinCharge(Short_t nbBinCharge)                      {fNumberBinCharge=nbBinCharge;};  
+  void SetDebugLevelTRDCalibraFillHisto(Short_t debugLevelTRDCalibraFillHisto) {fDebugLevelTRDCalibraFillHisto = debugLevelTRDCalibraFillHisto;};
+
   
   void SetNz(Short_t nz, Int_t i)                                      {fNz[i]=nz;};
   void SetNrphi(Short_t nrphi, Int_t i)                                {fNrphi[i]=nrphi;};
   
+  void SetSelectTrigger(Bool_t selectTrigger)                          {fSelectTrigger = selectTrigger;};
   void AddSelectedTriggerClass(const char*name)                        {fSelectedTrigger->Add(new TObjString(name));};
   void SetReject(Bool_t rejected)                                      {fRejected = rejected;};
   
@@ -71,6 +75,9 @@ class AliTRDCalibTask : public AliAnalysisTaskSE {
   void SetRangePrimaryVertexZ(Double_t rangePrimaryVertexZ)            {fRangePrimaryVertexZ = TMath::Abs(rangePrimaryVertexZ);}; 
   void SetMinNbTracks(Int_t minNbTracks)                               {fMinNbTracks = minNbTracks;};
   void SetMaxNbTracks(Int_t maxNbTracks)                               {fMaxNbTracks = maxNbTracks;};
+  void SetCutWithVdriftCalib(Bool_t cutWithVdriftCalib)                {fCutWithVdriftCalib = cutWithVdriftCalib;};
+  void SetMinNbTRDtracklets(Int_t minNbTRDtracklets)                   {fMinNbTRDtracklets = minNbTRDtracklets;};
+  void SetMinTRDMometum(Double_t minTRDMomentum)                       {fMinTRDMomentum = minTRDMomentum;};
  
   void SetVersionGainUsed(Int_t versionGainUsed)                       { fVersionGainUsed = versionGainUsed;   }
   void SetSubVersionGainUsed(Int_t subVersionGainUsed)                 { fSubVersionGainUsed = subVersionGainUsed;   }
@@ -144,11 +151,14 @@ class AliTRDCalibTask : public AliAnalysisTaskSE {
   Bool_t      fVdriftLinear;                     // vdrift Linear
   Bool_t      fExbAlt;                           // alternative exb calculation
 
+  Short_t     fDebugLevelTRDCalibraFillHisto;    // Debug Level Fill Histo
   Int_t       fNbTimeBins;                       // number of timebins 
+  Short_t     fNumberBinCharge;                  // Number of bins for the gain factor
 
   Short_t     fNz[3];                            // Nz mode 
   Short_t     fNrphi[3];                         // Nrphi mode
    
+  Bool_t      fSelectTrigger;                    // Select trigger
   TObjArray   *fSelectedTrigger;                 // Trigger class names accepted/rejected
   Bool_t      fRejected;                         // Reject the selected trigger class
   
@@ -160,7 +170,10 @@ class AliTRDCalibTask : public AliAnalysisTaskSE {
   Double_t    fRangePrimaryVertexZ;              // Were the primary vertex is
   Int_t       fMinNbTracks;                      // Min Nb Tracks
   Int_t       fMaxNbTracks;                      // Max Nb Tracks
-  
+  Bool_t      fCutWithVdriftCalib;               // CutWithVdriftCalib for the gain and PH
+  Int_t       fMinNbTRDtracklets;                // Min number of TRD tracklets
+  Float_t     fMinTRDMomentum;                   // Min TRD momentum  
+
   Int_t       fLow;                              // lower limit of nb of TRD clusters per tracklet
   Int_t       fHigh;                             // higher limit of nb of TRD clusters per tracklet
   Bool_t      fFillZero;                         // fill zero
@@ -193,7 +206,7 @@ class AliTRDCalibTask : public AliAnalysisTaskSE {
   AliTRDCalibTask(const AliTRDCalibTask&); 
   AliTRDCalibTask& operator=(const AliTRDCalibTask&); 
 
-  ClassDef(AliTRDCalibTask, 1); 
+  ClassDef(AliTRDCalibTask, 2); 
 };
 
 #endif
index 71ed15e..558e0b0 100644 (file)
@@ -53,6 +53,7 @@
 
 #include "AliLog.h"
 
+#include "AliESDtrack.h"
 #include "AliTRDCalibraFillHisto.h"
 #include "AliTRDCalibraMode.h"
 #include "AliTRDCalibraVector.h"
@@ -148,6 +149,9 @@ AliTRDCalibraFillHisto::AliTRDCalibraFillHisto()
   ,fNormalizeNbOfCluster(kFALSE)
   ,fMaxCluster(0)
   ,fNbMaxCluster(0)
+  ,fCutWithVdriftCalib(kFALSE)
+  ,fMinNbTRDtracklets(0)
+  ,fMinTRDMomentum(0.0)
   ,fFirstRunGain(0)
   ,fVersionGainUsed(0)
   ,fSubVersionGainUsed(0)
@@ -235,6 +239,9 @@ AliTRDCalibraFillHisto::AliTRDCalibraFillHisto(const AliTRDCalibraFillHisto &c)
   ,fNormalizeNbOfCluster(c.fNormalizeNbOfCluster)
   ,fMaxCluster(c.fMaxCluster)
   ,fNbMaxCluster(c.fNbMaxCluster)
+  ,fCutWithVdriftCalib(c.fCutWithVdriftCalib)
+  ,fMinNbTRDtracklets(c.fMinNbTRDtracklets)
+  ,fMinTRDMomentum(c.fMinTRDMomentum)
   ,fFirstRunGain(c.fFirstRunGain)
   ,fVersionGainUsed(c.fVersionGainUsed)
   ,fSubVersionGainUsed(c.fSubVersionGainUsed)
@@ -659,7 +666,7 @@ Bool_t AliTRDCalibraFillHisto::InitCalPad(Int_t detector)
 
 }
 //____________Offline tracking in the AliTRDtracker____________________________
-Bool_t AliTRDCalibraFillHisto::UpdateHistogramsV1(const AliTRDtrackV1 *t)
+Bool_t AliTRDCalibraFillHisto::UpdateHistogramsV1(const AliTRDtrackV1 *t,const AliESDtrack *esdtrack)
 {
   //
   // Use AliTRDtrackV1 for the calibration
@@ -670,15 +677,15 @@ Bool_t AliTRDCalibraFillHisto::UpdateHistogramsV1(const AliTRDtrackV1 *t)
   AliTRDcluster *cl      = 0x0;                // cluster attached now to the tracklet
   AliTRDcluster *cls     = 0x0;                // shared cluster attached now to the tracklet
   Bool_t         newtr   = kTRUE;              // new track
-  
-  // Get cal
-  //  AliTRDcalibDB *cal = AliTRDcalibDB::Instance();
-  /*
-  if (!cal) {
-    AliInfo("Could not get calibDB");
-    return kFALSE;
-  }
-*/
+
+
+  //
+  // Cut on the number of TRD tracklets
+  //
+  Int_t numberoftrdtracklets = t->GetNumberOfTracklets();
+  if(numberoftrdtracklets < fMinNbTRDtracklets) return kFALSE;
+
+  //
   if (!fCalibDB) {
     AliInfo("Could not get calibDB");
     return kFALSE;
@@ -694,6 +701,9 @@ Bool_t AliTRDCalibraFillHisto::UpdateHistogramsV1(const AliTRDtrackV1 *t)
     if(!tracklet->IsOK()) continue;
     fNumberTrack++; 
     ResetfVariablestracklet();
+    Float_t momentum = t->GetMomentum(itr);
+    if(TMath::Abs(momentum) < fMinTRDMomentum)  continue;
+
 
     //////////////////////////////////////////
     // localisation of the tracklet and dqdl
@@ -724,6 +734,7 @@ Bool_t AliTRDCalibraFillHisto::UpdateHistogramsV1(const AliTRDtrackV1 *t)
     ////////////////////////////
     // loop over the clusters
     ////////////////////////////
+    Double_t chargeQ = 0.0;
     Int_t nbclusters = 0;
     for(int jc=0; jc<AliTRDseedV1::kNtb; jc++){
       if(!(cl = tracklet->GetClusters(jc))) continue;
@@ -739,7 +750,7 @@ Bool_t AliTRDCalibraFillHisto::UpdateHistogramsV1(const AliTRDtrackV1 *t)
       // Add the charge if shared cluster
       cls = tracklet->GetClusters(jc+AliTRDseedV1::kNtb);
       //
-      StoreInfoCHPHtrack(cl, tracklet->GetQperTB(jc),group,row,col,cls); //tracklet->GetdQdl(jc)
+      chargeQ += StoreInfoCHPHtrack(cl, tracklet->GetQperTB(jc),group,row,col,cls); //tracklet->GetdQdl(jc)
     }
     
     ////////////////////////////////////////
@@ -754,16 +765,74 @@ Bool_t AliTRDCalibraFillHisto::UpdateHistogramsV1(const AliTRDtrackV1 *t)
 
       // Gain calibration
       if (fCH2dOn) {
-       FillTheInfoOfTheTrackCH(nbclusters);
+       if(fCutWithVdriftCalib) {
+         if(pass) FillTheInfoOfTheTrackCH(nbclusters);
+       } else {
+         FillTheInfoOfTheTrackCH(nbclusters);
+       }
       }
        
       // PH calibration
       if (fPH2dOn) {
-       FillTheInfoOfTheTrackPH();    
+       if(fCutWithVdriftCalib) {
+         if(pass) FillTheInfoOfTheTrackPH();
+       }
+       else {
+         FillTheInfoOfTheTrackPH();
+       }    
       }
        
       if(pass && fPRF2dOn) HandlePRFtrackletV1(tracklet,nbclusters);
-               
+       
+
+      /////////////////////////////////////////////////////////
+      // Debug
+      ////////////////////////////////////////////////////////
+      if(fDebugLevel > 0){
+               //printf("test\n");
+       if ( !fDebugStreamer ) {
+         //debug stream
+         TDirectory *backup = gDirectory;
+         fDebugStreamer = new TTreeSRedirector("TRDdebugCalibraFill.root");
+         if ( backup ) backup->cd();  //we don't want to be cd'd to the debug streamer
+       }     
+       
+       Int_t    stacke = AliTRDgeometry::GetStack(detector);
+       Int_t    sme    = AliTRDgeometry::GetSector(detector);
+       Int_t    layere  = AliTRDgeometry::GetLayer(detector);
+       // Some variables
+       Float_t b[2] = {0.0,0.0};
+       Float_t bCov[3] = {0.0,0.0,0.0};
+       if(esdtrack) esdtrack->GetImpactParameters(b,bCov);
+       if (bCov[0]<=0 || bCov[2]<=0) {
+         bCov[0]=0; bCov[2]=0;
+       }
+       Float_t dcaxy = b[0];
+       Float_t dcaz = b[1];
+       Int_t tpcnbclusters = 0;
+       if(esdtrack) tpcnbclusters = esdtrack->GetTPCclusters(0);
+       Double_t tpcsignal = 0.0;
+       if(esdtrack) tpcsignal = esdtrack->GetTPCsignal();
+        Int_t    cutvdriftlinear = 0;
+       if(!pass) cutvdriftlinear = 1;
+       
+       (* fDebugStreamer) << "FillCharge"<<
+         "detector="<<detector<<
+         "stack="<<stacke<<
+         "sm="<<sme<<
+         "layere="<<layere<<
+         "dcaxy="<<dcaxy<<
+         "dcaz="<<dcaz<<
+         "nbtpccls="<<tpcnbclusters<<
+         "tpcsignal="<<tpcsignal<<
+         "cutvdriftlinear="<<cutvdriftlinear<<
+         "ptrd="<<momentum<<
+         "nbtrdtracklet="<<numberoftrdtracklets<<
+         "charge="<<chargeQ<<
+         "\n"; 
+      }
+      
+      
     } // if a good tracklet
   }
   
@@ -915,7 +984,7 @@ Bool_t AliTRDCalibraFillHisto::FindP1TrackPHtrackletV1(const AliTRDseedV1 *track
   /////////////////////////////// 
 
 
-  if(fDebugLevel > 0){
+  if(fDebugLevel > 1){
     if ( !fDebugStreamer ) {
       //debug stream
       TDirectory *backup = gDirectory;
@@ -1174,7 +1243,7 @@ Bool_t AliTRDCalibraFillHisto::HandlePRFtrackletV1(const AliTRDseedV1 *tracklet,
     // Debug stuff
     ////////////////////
 
-    if(fDebugLevel > 0){
+    if(fDebugLevel > 1){
       if ( !fDebugStreamer ) {
        //debug stream
        TDirectory *backup = gDirectory;
@@ -1560,12 +1629,14 @@ void AliTRDCalibraFillHisto::SetNumberGroupsPRF(Short_t numberGroupsPRF)
 // Per tracklet: store or reset the info, fill the histos with the info
 //////////////////////////////////////////////////////////////////////////////////////////
 //_____________________________________________________________________________
-void AliTRDCalibraFillHisto::StoreInfoCHPHtrack(const AliTRDcluster *cl,const Double_t dqdl,const Int_t *group,const Int_t row,const Int_t col,const AliTRDcluster *cls)
+Float_t AliTRDCalibraFillHisto::StoreInfoCHPHtrack(const AliTRDcluster *cl,const Double_t dqdl,const Int_t *group,const Int_t row,const Int_t col,const AliTRDcluster *cls)
 {
   //
   // Store the infos in fAmpTotal, fPHPlace and fPHValue
   // Correct from the gain correction before
   // cls is shared cluster if any
+  // Return the charge
+  // 
   //
   
   //printf("StoreInfoCHPHtrack\n");
@@ -1607,6 +1678,8 @@ void AliTRDCalibraFillHisto::StoreInfoCHPHtrack(const AliTRDcluster *cl,const Do
     fPHPlace[time] = group[1];
     fPHValue[time] = charge;
   }
+
+  return correction;
   
 }
 //____________Offine tracking in the AliTRDtracker_____________________________
@@ -2202,7 +2275,7 @@ Int_t AliTRDCalibraFillHisto::FillDAQ(Double_t phvalue[16][144][36]){
   /////////////////////////////////////////////////////////
   // Debug
   ////////////////////////////////////////////////////////
-  if(fDebugLevel > 0){
+  if(fDebugLevel > 1){
     if ( !fDebugStreamer ) {
       //debug stream
       TDirectory *backup = gDirectory;
index a6b2d72..c462886 100644 (file)
@@ -31,6 +31,8 @@ class TTreeSRedirector;
 class AliLog;
 class AliRawReader;
 
+class AliESDtrack;
+
 class AliTRDCalibraMode;
 class AliTRDCalibraVector;
 class AliTRDCalibraVdriftLinearFit;
@@ -65,7 +67,7 @@ class AliTRDCalibraFillHisto : public TObject {
   // Functions for initialising and filling with AliTRDtrackV1
           Bool_t  Init2Dhistos(Int_t nboftimebin = -1);
          Bool_t  InitCalDet();
-         Bool_t  UpdateHistogramsV1(const AliTRDtrackV1 *t);
+         Bool_t  UpdateHistogramsV1(const AliTRDtrackV1 *t,const AliESDtrack *esdtrack = NULL);
  
   // Process events DAQ
          Int_t   ProcessEventDAQ(AliRawReader *rawReader);
@@ -145,6 +147,9 @@ class AliTRDCalibraFillHisto : public TObject {
          void     SetNormalizeNbOfCluster(Bool_t normalizeNbOfCluster)      { fNormalizeNbOfCluster = normalizeNbOfCluster; }
          void     SetMaxCluster(Float_t maxCluster)                         { fMaxCluster = maxCluster; }
          void     SetNbMaxCluster(Short_t nbMaxCluster)                     { fNbMaxCluster = nbMaxCluster; }
+         void     SetCutWithVdriftCalib(Bool_t cutWithVdriftCalib)          { fCutWithVdriftCalib = cutWithVdriftCalib; }
+         void     SetMinNbTRDtracklets(Int_t minNbTRDtracklets)             { fMinNbTRDtracklets = minNbTRDtracklets; }
+         void     SetMinTRDMomentum(Float_t minTRDMomentum)                 { fMinTRDMomentum = minTRDMomentum; }
          void     SetNz(Int_t i, Short_t nz);
           void     SetNrphi(Int_t i, Short_t nrphi);
           void     SetAllTogether(Int_t i);
@@ -168,6 +173,7 @@ class AliTRDCalibraFillHisto : public TObject {
          Bool_t   GetNormalizeNbOfCluster() const                           { return fNormalizeNbOfCluster;   }
          Float_t  GetMaxCluster() const                                     { return fMaxCluster;             }
          Short_t  GetNbMaxCluster() const                                   { return fNbMaxCluster;           }
+         Bool_t   GetCutWithVdriftCalib() const                             { return fCutWithVdriftCalib;     }
          Float_t  GetProcent() const                                        { return fProcent;                }
           Short_t  GetDifference() const                                     { return fDifference;             }
           Short_t  GetNumberClusters() const                                 { return fNumberClusters;         }
@@ -211,6 +217,9 @@ AliTRDCalibraVector *GetCalibraVector() const                                { r
          Bool_t   fNormalizeNbOfCluster;   // Normalize with the number of cluster for the gain
          Float_t  fMaxCluster;             // Max amplitude of one cluster
          Short_t  fNbMaxCluster;           // Number of tb at the end
+         Bool_t   fCutWithVdriftCalib;     // CutWithVdriftCalib for the gain and PH
+         Int_t    fMinNbTRDtracklets;      // Min number of TRD tracklets
+         Float_t  fMinTRDMomentum;         // Min TRD momentum
   // Back correction
          Int_t    fFirstRunGain;           // FirstRunGain 
          Int_t    fVersionGainUsed;        // VersionGainUsed 
@@ -301,7 +310,7 @@ AliTRDCalibraVector *GetCalibraVector() const                                { r
          Bool_t   FindP1TrackPHtrackletV1(const AliTRDseedV1 *tracklet, Int_t nbclusters);
          Bool_t   HandlePRFtrackletV1(const AliTRDseedV1 *tracklet, Int_t nbclusters);
          void     ResetfVariablestracklet();
-         void     StoreInfoCHPHtrack(const AliTRDcluster *cl,const Double_t dqdl,const Int_t *group,const Int_t row,const Int_t col,const AliTRDcluster *cls=0x0);
+         Float_t  StoreInfoCHPHtrack(const AliTRDcluster *cl,const Double_t dqdl,const Int_t *group,const Int_t row,const Int_t col,const AliTRDcluster *cls=0x0);
          void     FillCH2d(Int_t x, Float_t y);
 
   // Calibration on DAQ
@@ -335,7 +344,7 @@ AliTRDCalibraVector *GetCalibraVector() const                                { r
   AliTRDCalibraFillHisto();
   virtual ~AliTRDCalibraFillHisto(); 
     
-  ClassDef(AliTRDCalibraFillHisto,4)                         // TRD Calibration class
+  ClassDef(AliTRDCalibraFillHisto,5)                         // TRD Calibration class
 
 };