Disentangled usage of HLT and offline one pad clusters
authorjthaeder <jthaeder@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 8 Nov 2011 00:06:14 +0000 (00:06 +0000)
committerjthaeder <jthaeder@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 8 Nov 2011 00:06:14 +0000 (00:06 +0000)
 - added extra option the recoparam

Implemted options for rec.C for input switching of TPC reco

//--------------------------------------------------------------------
//          Options for the TPC Reconstruction in rec.C
//
//  4 options can be set to change the input for TPC reconstruction
//  which overwrites the usage of fUseHLTClusters of the AliTPCRecoParam
//
//  1) useRAW        - use RAW, if not present -> do nothing
//  2) useRAWorHLT   - use RAW, if not present -> use HLT clusters
//  3) useHLT        - use HLT clusters, if not present -> do nothing
//  4) useHLTorRAW   - use HLT clusters, if not present -> use RAW
//
//  -> The current default is useHLTorRAW
//--------------------------------------------------------------------

TPC/AliTPCRecoParam.cxx
TPC/AliTPCRecoParam.h
TPC/AliTPCReconstructor.cxx
TPC/AliTPCReconstructor.h
TPC/AliTPCclustererMI.cxx
TPC/AliTPCclustererMI.h
TPC/AliTPCtrackerMI.cxx
TPC/AliTPCtrackerMI.h
TPC/macros/ModifyRecoParamHLTUsage.C

index 3566071..561a9c0 100644 (file)
@@ -61,7 +61,7 @@ Bool_t AliTPCRecoParam::fgUseTimeCalibration=kTRUE; // flag usage the time depen
 //_____________________________________________________________________________
 AliTPCRecoParam::AliTPCRecoParam():
   AliDetectorRecoParam(),
-  fUseHLTClusters(1),  // use RAW data
+  fUseHLTClusters(4),  // use HLTorRAW data
   fBClusterSharing(kTRUE),
   fCtgRange(1.05),       
   fMaxSnpTracker(0.95),
@@ -76,6 +76,7 @@ AliTPCRecoParam::AliTPCRecoParam():
   fMaxNoise(2.),
   //
   fUseOnePadCluster(kTRUE),
+  fUseHLTOnePadCluster(kFALSE),
   fMinMaxCutAbs(4.),
   fMinLeftRightCutAbs(6.),
   fMinUpDownCutAbs(6.),
index 6c9e7b4..10ecb09 100644 (file)
@@ -46,7 +46,8 @@ class AliTPCRecoParam : public AliDetectorRecoParam
   Float_t  GetDumpAmplitudeMin()   const  { return fDumpAmplitudeMin;}
   Float_t  GetMaxNoise()           const  { return fMaxNoise;}  
   //
-  Int_t   GetUseOnePadCluster()   const   { return fUseOnePadCluster;}
+  Int_t    GetUseOnePadCluster()   const  { return fUseOnePadCluster;}
+  Bool_t   GetUseHLTOnePadCluster()const  { return fUseHLTOnePadCluster;}
   Float_t  GetMinMaxCutAbs()       const  { return fMinMaxCutAbs; }
   Float_t  GetMinLeftRightCutAbs() const  { return fMinLeftRightCutAbs;}  // minimal amplitude left right - PRF
   Float_t  GetMinUpDownCutAbs()    const  { return fMinUpDownCutAbs;}  // minimal amplitude up-down - TRF 
@@ -55,6 +56,7 @@ class AliTPCRecoParam : public AliDetectorRecoParam
   Float_t  GetMinUpDownCutSigma()    const  { return fMinUpDownCutSigma;}  // minimal amplitude up-down - TRF 
   //
   void SetUseOnePadCluster(Int_t use)      {   fUseOnePadCluster = use;}
+  void SetUseHLTOnePadCluster(Bool_t use)  {   fUseHLTOnePadCluster = use;}
   void SetMinMaxCutAbs(Float_t th)         {   fMinMaxCutAbs=th; }
   void SetMinLeftRightCutAbs(Float_t th)   {   fMinLeftRightCutAbs=th;}  // minimal amplitude left right - PRF
   void SetMinUpDownCutAbs(Float_t th)      {   fMinUpDownCutAbs=th;}  // minimal amplitude up-down - TRF 
@@ -149,7 +151,8 @@ class AliTPCRecoParam : public AliDetectorRecoParam
   Bool_t   fBDoUnfold;       // do unfolding of clusters
   Float_t  fDumpAmplitudeMin; // minimal amplitude of signal to be dumped 
   Float_t  fMaxNoise;        // maximal noise sigma on pad to be used in cluster finder
-  Int_t   fUseOnePadCluster; // flag - use one pad cluster -0 not use >0 use
+  Int_t    fUseOnePadCluster; // flag - use one pad cluster -0 not use >0 use
+  Bool_t   fUseHLTOnePadCluster; // flag - use one HLT pad cluster for tracking
   Float_t  fMinMaxCutAbs;    // minimal amplitude at cluster maxima
   Float_t  fMinLeftRightCutAbs;  // minimal amplitude left right - PRF
   Float_t  fMinUpDownCutAbs;  // minimal amplitude up-down - TRF 
@@ -200,7 +203,7 @@ public:
                                       // to be switched off for pass 0 reconstruction
                                       // Use static function, other option will be to use 
                                       // additional specific storage ?
-  ClassDef(AliTPCRecoParam, 15)
+  ClassDef(AliTPCRecoParam, 16)
 };
 
 
index dbe8d1c..784616b 100644 (file)
 
 /* $Id$ */
 
+//--------------------------------------------------------------------
+//          Options for the TPC Reconstruction in rec.C
+//
+//  4 options can be set to change the input for TPC reconstruction
+//  which overwrites the usage of fUseHLTClusters of the AliTPCRecoParam
+//
+//  1) useRAW        - use RAW, if not present -> do nothing
+//  2) useRAWorHLT   - use RAW, if not present -> use HLT clusters
+//  3) useHLT        - use HLT clusters, if not present -> do nothing
+//  4) useHLTorRAW   - use HLT clusters, if not present -> use RAW
+//
+//  -> The current default is useHLTorRAW
+//--------------------------------------------------------------------
+
 ///////////////////////////////////////////////////////////////////////////////
 //                                                                           //
 // class for TPC reconstruction                                              //
@@ -112,7 +126,12 @@ AliTracker* AliTPCReconstructor::CreateTracker() const
     param = new AliTPCParamSR;
   }
   param->ReadGeoMatrices();
-  return new AliTPCtrackerMI(param);
+  
+  AliTPCtrackerMI* tracker = new AliTPCtrackerMI(param);
+
+  ParseOptions(tracker);
+
+  return tracker;
 }
 
 //_____________________________________________________________________________
@@ -137,3 +156,39 @@ AliTPCParam* AliTPCReconstructor::GetTPCParam() const
 
   return param;
 }
+
+
+//_____________________________________________________________________________
+void AliTPCReconstructor::ParseOptions( AliTPCtrackerMI* tracker ) const
+{
+// parse options from rec.C and set in clusterer and tracker
+  
+  TString option = GetOption();
+  
+  Int_t useHLTClusters = 3;
+
+  if (option.Contains("use")) {
+    
+    AliInfo(Form("Overide TPC RecoParam with option %s",option.Data()));
+    
+    if (!option.CompareTo("useRAW"))
+      useHLTClusters = 1;
+    if (!option.CompareTo("useRAWorHLT"))
+      useHLTClusters = 2;
+    if (!option.CompareTo("useHLT"))
+      useHLTClusters = 3;
+    if (!option.CompareTo("useHLTorRAW"))
+      useHLTClusters = 4;
+  }
+  else {
+    const AliTPCRecoParam* param = GetRecoParam();
+    useHLTClusters = param->GetUseHLTClusters();
+  }
+
+  AliInfo(Form("Usage of HLT clusters in TPC reconstruction : %d", useHLTClusters));
+
+  fClusterer->SetUseHLTClusters(useHLTClusters);
+  tracker->SetUseHLTClusters(useHLTClusters);
+
+  return;
+}
index 2d1f631..d618b52 100644 (file)
@@ -10,6 +10,7 @@
 
 class AliTPCParam;
 class AliTPCclustererMI;
+class AliTPCtrackerMI;
 class AliTPCAltroEmulator;
 
 class AliTPCReconstructor: public AliReconstructor {
@@ -38,6 +39,7 @@ public:
   static void  SetAltroEmulator(AliTPCAltroEmulator *altro) { fAltroEmulator=altro;}
   static AliTPCAltroEmulator *  GetAltroEmulator() { return fAltroEmulator;}
 
+  void ParseOptions(AliTPCtrackerMI* tracker) const;
 
 private:
   AliTPCReconstructor(const AliTPCReconstructor&); //Not implemented
index 46ba14a..2859f24 100644 (file)
@@ -118,7 +118,7 @@ AliTPCclustererMI::AliTPCclustererMI(const AliTPCParam* par, const AliTPCRecoPar
   fRecoParam(0),
   fBDumpSignal(kFALSE),
   fBClonesArray(kFALSE),
-  fUseHLTClusters(1),
+  fUseHLTClusters(4),
   fAllBins(NULL),
   fAllSigBins(NULL),
   fAllNSigBins(NULL)
@@ -199,7 +199,7 @@ AliTPCclustererMI::AliTPCclustererMI(const AliTPCclustererMI &param)
   fRecoParam(0),
   fBDumpSignal(kFALSE),
   fBClonesArray(kFALSE),
-  fUseHLTClusters(1),
+  fUseHLTClusters(4),
   fAllBins(NULL),
   fAllSigBins(NULL),
   fAllNSigBins(NULL)
@@ -724,10 +724,6 @@ void AliTPCclustererMI::Digits2Clusters()
   //-----------------------------------------------------------------
   // Use HLT clusters
   //-----------------------------------------------------------------
-  fUseHLTClusters = fRecoParam->GetUseHLTClusters();
-
-  AliInfo(Form("Usage of HLT clusters in TPC reconstruction : %d",fUseHLTClusters));
-
   if (fUseHLTClusters == 3 || fUseHLTClusters == 4) {
     AliInfo("Using HLT clusters for TPC off-line reconstruction");
     fZWidth = fParam->GetZWidth();
@@ -744,7 +740,7 @@ void AliTPCclustererMI::Digits2Clusters()
        return;
       }
       else {
-       AliInfo("Now trying to read TPC RAW");
+       AliInfo("Now trying to read from TPC RAW");
       }
     }
     // Some other problem during cluster reading
@@ -996,10 +992,6 @@ void AliTPCclustererMI::Digits2Clusters(AliRawReader* rawReader)
   //-----------------------------------------------------------------
   // Use HLT clusters
   //-----------------------------------------------------------------
-  fUseHLTClusters = fRecoParam->GetUseHLTClusters();
-
-  AliInfo(Form("Usage of HLT clusters in TPC reconstruction : %d",fUseHLTClusters));
-
   if (fUseHLTClusters == 3 || fUseHLTClusters == 4) {
     AliInfo("Using HLT clusters for TPC off-line reconstruction");
     fZWidth = fParam->GetZWidth();
index d2ea1ab..89295bf 100644 (file)
@@ -48,6 +48,8 @@ public:
 
   void StoreInClonesArray(Bool_t bOutput = kTRUE) {fBClonesArray = bOutput;} // store output clusters in TClonesArray
 
+  void SetUseHLTClusters(Int_t useHLTClusters) {fUseHLTClusters = useHLTClusters;} // set usage from HLT clusters from rec.C options
+
 private:
   Bool_t IsMaximum(Float_t k, Int_t max, const Float_t *bins) const; 
   void MakeCluster2(Int_t k,Int_t max,Float_t *bins,UInt_t m,
index be6e197..886c129 100644 (file)
@@ -200,7 +200,8 @@ AliTPCtrackerMI::AliTPCtrackerMI()
                 fSeeds(0),
                 fIteration(0),
                 fkParam(0),
-                fDebugStreamer(0)
+                fDebugStreamer(0),
+                fUseHLTClusters(4)
 {
   //
   // default constructor
@@ -374,12 +375,13 @@ Int_t AliTPCtrackerMI::AcceptCluster(AliTPCseed * seed, AliTPCclusterMI * cluste
     return 2;    
   }
 
-  if (AliTPCReconstructor::GetRecoParam()->GetUseHLTClusters() == 3 ||
-      AliTPCReconstructor::GetRecoParam()->GetUseHLTClusters() == 4 ) {
-    if(!AliTPCReconstructor::GetRecoParam()->GetUseOnePadCluster())
+  if (fUseHLTClusters == 3 || fUseHLTClusters == 4) {
+    if(!AliTPCReconstructor::GetRecoParam()->GetUseHLTOnePadCluster()) {
       if (TMath::Abs(cluster->GetSigmaY2()) < kAlmost0)
        return 2;
+    }
   }
+
   return 0;
 }
 
@@ -407,7 +409,9 @@ AliTracker(),
                 fSeeds(0),
                 fIteration(0),
                 fkParam(0),
-                fDebugStreamer(0)
+                 fDebugStreamer(0),
+                 fUseHLTClusters(4)
+
 {
   //---------------------------------------------------------------------
   // The main TPC tracker constructor
@@ -461,7 +465,8 @@ AliTPCtrackerMI::AliTPCtrackerMI(const AliTPCtrackerMI &t):
                 fSeeds(0),
                 fIteration(0),
                 fkParam(0),
-                fDebugStreamer(0)
+                 fDebugStreamer(0),
+                 fUseHLTClusters(4)
 {
   //------------------------------------
   // dummy copy constructor
index 77c27a5..33f5437 100644 (file)
@@ -105,7 +105,7 @@ public:
    Bool_t GetProlongation(Double_t x1, Double_t x2, Double_t x[5], Double_t &y, Double_t &z) const;
 
  public:
-
+   void SetUseHLTClusters(Int_t useHLTClusters) {fUseHLTClusters = useHLTClusters;} // set usage from HLT clusters from rec.C options
 
    Float_t OverlapFactor(AliTPCseed * s1, AliTPCseed * s2, Int_t &sum1, Int_t &sum2);
    void  SignShared(AliTPCseed * s1, AliTPCseed * s2);
@@ -194,6 +194,7 @@ private:
    Double_t fPadLength[200];                // max y for given pad row
    const AliTPCParam *fkParam;          //pointer to the parameters
    TTreeSRedirector *fDebugStreamer;     //!debug streamer
+   Int_t  fUseHLTClusters;              // use HLT clusters instead of offline clusters
    ClassDef(AliTPCtrackerMI,2) 
 };
 
index bf766e2..40e0acf 100644 (file)
@@ -59,12 +59,6 @@ void ModifyRecoParamHLTUsage( const Char_t* lastOCDBEntry,
   parLowFlux->SetUseHLTClusters(iHLTusage);
   parCosmicFlux->SetUseHLTClusters(iHLTusage);
 
-  if (iHLTusage == 3 || iHLTusage == 4) {
-    parHighFlux->SetUseOnePadCluster(0);
-    parLowFlux->SetUseOnePadCluster(0);
-    parCosmicFlux->SetUseOnePadCluster(0);
-  }
-
   // -- Write out
   // -------------------------------------------------------------------
   const Char_t *comment = "Modified RecoParam with HLT clusters usage";