Starting to use new clustering interface (AliMUONVClusterFinder)
authorivana <ivana@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 16 Nov 2006 10:10:16 +0000 (10:10 +0000)
committerivana <ivana@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 16 Nov 2006 10:10:16 +0000 (10:10 +0000)
(Laurent)

MUON/AliMUONClusterReconstructor.cxx
MUON/AliMUONClusterReconstructor.h
MUON/AliMUONReconstructor.cxx
MUON/AliMUONReconstructor.h

index 48ca6a1..22b3684 100644 (file)
 #include "AliMUONClusterFinderVS.h"
 #include "AliMUONClusterInput.h"
 #include "AliMUONRawCluster.h"
-
+#include "AliMUONVClusterFinder.h"
+#include "AliMUONCluster.h"
 #include "AliMpDEManager.h"
-
+#include "AliMpSegmentation.h"
+#include "AliMUONGeometryTransformer.h"
 #include "AliLog.h"
 
 /// \cond CLASSIMP
@@ -43,17 +45,26 @@ ClassImp(AliMUONClusterReconstructor) // Class implementation in ROOT context
 /// \endcond
  
 //__________________________________________________________________________
-AliMUONClusterReconstructor::AliMUONClusterReconstructor(AliMUONData* data)
+AliMUONClusterReconstructor::AliMUONClusterReconstructor(AliMUONData* data,
+                                                         AliMUONVClusterFinder* clusterFinder,
+                                                         const AliMUONGeometryTransformer* transformer)
 : TObject(),
+  fClusterFinder(clusterFinder),
   fMUONData(data),
   fRecModel(new AliMUONClusterFinderVS()),
   fDigitsCath0(new TClonesArray("AliMUONDigit",1000)),
-  fDigitsCath1(new TClonesArray("AliMUONDigit",1000))
+  fDigitsCath1(new TClonesArray("AliMUONDigit",1000)),
+  fTransformer(transformer)
 {
 /// Standard Constructor
 
   fDigitsCath0->SetOwner(kTRUE); 
   fDigitsCath1->SetOwner(kTRUE);
+  if (!transformer && clusterFinder)
+  {
+    AliFatal("I require a geometry transformer, otherwise I cannot compute "
+             "global coordinates of the clusters !");    
+  }
 }
 
 //__________________________________________________________________________
@@ -68,6 +79,66 @@ AliMUONClusterReconstructor::~AliMUONClusterReconstructor(void)
 
 //______________________________________________________________________________
 void
+AliMUONClusterReconstructor::ClusterizeOneDEV2(Int_t detElemId)
+{
+  AliDebug(1,Form("DE %d",detElemId));
+  const AliMpVSegmentation* seg[2] = 
+  { AliMpSegmentation::Instance()->GetMpSegmentation(detElemId,0),
+    AliMpSegmentation::Instance()->GetMpSegmentation(detElemId,1)
+  };
+  
+  
+  TClonesArray* digits[2] = { fDigitsCath0, fDigitsCath1 };
+  
+  Bool_t ok = fClusterFinder->Prepare(seg,digits);
+  if ( !ok )
+  {
+    AliWarning(Form("No hit pad for DE %d ?",detElemId));
+  }
+  
+  AliMUONCluster* cluster;
+  
+  Int_t chamber = detElemId/100 - 1;
+  
+  while ( ( cluster = fClusterFinder->NextCluster() ) )
+  {
+    StdoutToAliDebug(1,cout << "From AliMUONClusterReconstructor::ClusterizeOneDEV2 : cluster->Print():" << endl;
+                     cluster->Print(););
+    
+    // Converts cluster objects into ones suitable for output
+    //
+    AliMUONRawCluster rawCluster;
+    
+    rawCluster.SetDetElemId(detElemId);
+    
+    for ( Int_t cathode = 0; cathode < 2; ++cathode )
+    {
+      rawCluster.SetMultiplicity(cathode,cluster->Multiplicity(cathode));
+      rawCluster.SetCharge(cathode,cluster->Charge()); // both cathode get the total cluster charge
+      Double_t xg, yg, zg;
+      
+      fTransformer->Local2Global(detElemId, 
+                                 cluster->Position().X(), cluster->Position().Y(), 
+                                 0, xg, yg, zg);
+      
+      if ( cathode == 0 )
+      {
+        AliDebug(1,Form("Adding RawCluster detElemId %4d mult %2d charge %e (xl,yl,zl)=(%e,%e,%e) (xg,yg,zg)=(%e,%e,%e)",
+                        detElemId,cluster->Multiplicity(),cluster->Charge(),
+                        cluster->Position().X(),cluster->Position().Y(),0.0,
+                        xg,yg,zg));
+      }
+      rawCluster.SetX(cathode,xg);
+      rawCluster.SetY(cathode,yg);
+      rawCluster.SetZ(cathode,zg);      
+    }
+    fMUONData->AddRawCluster(chamber,rawCluster);
+    delete cluster;
+  }
+}
+
+//______________________________________________________________________________
+void
 AliMUONClusterReconstructor::ClusterizeOneDE(Int_t detElemId)
 {
 /// Clusterize one detection element, and let fMUONData know about
@@ -75,24 +146,30 @@ AliMUONClusterReconstructor::ClusterizeOneDE(Int_t detElemId)
   
   if ( fDigitsCath0->GetEntriesFast() || fDigitsCath1->GetEntriesFast() )
   {
-    Int_t iChamber = AliMpDEManager::GetChamberId(detElemId);
-    AliMUONClusterInput::Instance()->SetDigits(iChamber, detElemId,
-                                               fDigitsCath0,fDigitsCath1);
-    AliDebug(3,Form("ClusterizeOneDE iChamber=%d DE=%d",iChamber,detElemId));
-    StdoutToAliDebug(3,cout << "DigitsCath0=" << endl;
-                     fDigitsCath0->Print();
-                     cout << "DigitsCath1=" << endl;
-                     fDigitsCath1->Print(););
-    fRecModel->FindRawClusters();
-    
-    // copy results into the output container
-    TClonesArray* tmp = fRecModel->GetRawClusters();
-    for (Int_t id = 0; id < tmp->GetEntriesFast(); ++id) 
+    if ( fClusterFinder )
     {
-      AliMUONRawCluster* pClus = (AliMUONRawCluster*) tmp->At(id);
-      fMUONData->AddRawCluster(iChamber, *pClus);
-    }        
-    
+      ClusterizeOneDEV2(detElemId);
+    }
+    else
+    {
+      Int_t iChamber = AliMpDEManager::GetChamberId(detElemId);
+      AliMUONClusterInput::Instance()->SetDigits(iChamber, detElemId,
+                                                 fDigitsCath0,fDigitsCath1);
+      AliDebug(3,Form("ClusterizeOneDE iChamber=%d DE=%d",iChamber,detElemId));
+      StdoutToAliDebug(3,cout << "DigitsCath0=" << endl;
+                       fDigitsCath0->Print();
+                       cout << "DigitsCath1=" << endl;
+                       fDigitsCath1->Print(););
+      fRecModel->FindRawClusters();
+      
+      // copy results into the output container
+      TClonesArray* tmp = fRecModel->GetRawClusters();
+      for (Int_t id = 0; id < tmp->GetEntriesFast(); ++id) 
+      {
+        AliMUONRawCluster* pClus = (AliMUONRawCluster*) tmp->At(id);
+        fMUONData->AddRawCluster(iChamber, *pClus);
+      }        
+    }
     // Reset the arrays
     fDigitsCath0->Clear("C");
     fDigitsCath1->Clear("C");
@@ -110,7 +187,7 @@ void AliMUONClusterReconstructor::Digits2Clusters(Int_t chBeg)
 /// of that detection element have been stored), we clusterize this DE, and
 /// move to the next one.
   
-  if (!fRecModel)
+  if (!fRecModel && !fClusterFinder)
   {
     AliWarning("No reco model defined. Nothing to do...");
     return;
index 5817345..40cc7a0 100644 (file)
 class AliMUONClusterFinderVS;
 class AliMUONData;
 class TClonesArray;
+class AliMUONVClusterFinder;
+class AliMUONGeometryTransformer;
 
 class AliMUONClusterReconstructor : public TObject 
 {
  public:
-  AliMUONClusterReconstructor(AliMUONData* data = 0x0); // Constructor
+  AliMUONClusterReconstructor(AliMUONData* data = 0x0,
+                              AliMUONVClusterFinder* finder = 0x0,
+                              const AliMUONGeometryTransformer* transformer = 0x0
+                              ); 
   virtual ~AliMUONClusterReconstructor(void); // Destructor
 
  
@@ -27,26 +32,29 @@ class AliMUONClusterReconstructor : public TObject
   virtual void   Digits2Clusters(Int_t chBeg = 0);
   virtual void   Trigger2Trigger() ;
 
-//  // pointer to data container
-//  AliMUONData*   GetMUONData() {return fMUONData;}
   // Reco Model
   AliMUONClusterFinderVS* GetRecoModel() {return fRecModel;}
 
   void SetRecoModel(AliMUONClusterFinderVS* rec);
 
  protected:
-  void ClusterizeOneDE(Int_t detElemId);
-  
- private:
+
   AliMUONClusterReconstructor (const AliMUONClusterReconstructor& rhs); // copy constructor
   AliMUONClusterReconstructor& operator=(const AliMUONClusterReconstructor& rhs); // assignment operator
 
+  void ClusterizeOneDE(Int_t detElemId);
+  void ClusterizeOneDEV2(Int_t detElemId);
+  
+private:
+  AliMUONVClusterFinder* fClusterFinder; //!< the object doing the real job (not owner)  
   AliMUONData*            fMUONData;           //!< Data container for MUON subsystem 
   AliMUONClusterFinderVS* fRecModel;           //!< cluster recontruction model
 
   TClonesArray* fDigitsCath0; //!< digits for cathode 0 of the current DE
   TClonesArray* fDigitsCath1; //!< digits for cathode 1 of the current DE
   
+  const AliMUONGeometryTransformer* fTransformer; //!< to go from local to global (not owner)
+    
   ClassDef(AliMUONClusterReconstructor,0) // MUON cluster reconstructor in ALICE
 };
        
index 9be5a6e..cb75ba3 100644 (file)
 
 #include "AliMpSegmentation.h"
 
+#include "AliMUONPreClusterFinder.h"
+#include "AliMUONClusterFinderCOG.h"
+#include "AliMUONClusterFinderSimpleFit.h"
+#include "AliMUONClusterFinderMLEM.h"
+  
 #include "AliRawReader.h"
 #include "AliRun.h"
 #include "AliRunLoader.h"
@@ -140,6 +145,46 @@ AliMUONReconstructor::Init(AliRunLoader* runLoader)
 }
 
 //_____________________________________________________________________________
+AliMUONClusterReconstructor*
+AliMUONReconstructor::CreateClusterReconstructor(AliMUONData* data) const
+{
+  AliMUONVClusterFinder* clusterFinder(0x0);
+  
+  TString opt(GetOption());
+  opt.ToUpper();
+  
+  if ( strstr(opt,"PRECLUSTER") )
+  {
+    clusterFinder = new AliMUONPreClusterFinder;
+  }  
+  else if ( strstr(opt,"COG") )
+  {
+    clusterFinder = new AliMUONClusterFinderCOG;
+  }  
+  else if ( strstr(opt,"SIMPLEFIT") )
+  {
+    clusterFinder = new AliMUONClusterFinderSimpleFit;
+  }
+  else if ( strstr(opt,"MLEM:DRAW") )
+  {
+    clusterFinder = new AliMUONClusterFinderMLEM(kTRUE);
+  }
+  else if ( strstr(opt,"MLEM") )
+  {
+    clusterFinder = new AliMUONClusterFinderMLEM(kFALSE);
+  } 
+  
+  if ( clusterFinder) 
+  {
+    AliInfo(Form("Will use %s for clusterizing",clusterFinder->ClassName()));
+  }
+  
+  AliMUONClusterReconstructor* clusterReco = 
+    new AliMUONClusterReconstructor(data,clusterFinder,fTransformer);
+  return clusterReco;
+}
+
+//_____________________________________________________________________________
 void AliMUONReconstructor::Reconstruct(AliRunLoader* runLoader) const
 {
 /// Reconstruct
@@ -158,7 +203,7 @@ void AliMUONReconstructor::Reconstruct(AliRunLoader* runLoader) const
   
   recoEvent->SetTriggerCircuit(fTriggerCircuit);
 
-  AliMUONClusterReconstructor* recoCluster = new AliMUONClusterReconstructor(data);
+  AliMUONClusterReconstructor* recoCluster = CreateClusterReconstructor(data);
   
   AliMUONClusterFinderVS *recModel = recoCluster->GetRecoModel();
 
@@ -268,7 +313,8 @@ void AliMUONReconstructor::Reconstruct(AliRunLoader* runLoader) const
 }
 
 //_____________________________________________________________________________
-void AliMUONReconstructor::Reconstruct(AliRunLoader* runLoader, AliRawReader* rawReader) const
+void AliMUONReconstructor::Reconstruct(AliRunLoader* runLoader, 
+                                       AliRawReader* rawReader) const
 {
 /// Recontruct
 /// \todo add more
@@ -280,20 +326,21 @@ void AliMUONReconstructor::Reconstruct(AliRunLoader* runLoader, AliRawReader* ra
   // passing loader as argument.
   fDigitMaker->SetMUONData(&data);
 
-  AliMUONClusterReconstructor recoCluster(&data);
+  AliMUONClusterReconstructor* recoCluster = CreateClusterReconstructor(&data);
 
   AliMUONVTrackReconstructor *recoEvent;
   if (strstr(GetOption(),"Original")) recoEvent = new AliMUONTrackReconstructor(&data);
   else if (strstr(GetOption(),"Combi")) recoEvent = new AliMUONTrackReconstructorK(&data,"Combi");
   else recoEvent = new AliMUONTrackReconstructorK(&data,"Kalman");
-  
+
   recoEvent->SetTriggerCircuit(fTriggerCircuit);
 
-  AliMUONClusterFinderVS *recModel = recoCluster.GetRecoModel();
+  AliMUONClusterFinderVS *recModel = recoCluster->GetRecoModel();
+
   if (!strstr(GetOption(),"VS")) 
   {
     recModel = (AliMUONClusterFinderVS*) new AliMUONClusterFinderAZ();
-    recoCluster.SetRecoModel(recModel);
+    recoCluster->SetRecoModel(recModel);
   }
   recModel->SetGhostChi2Cut(10);
 
@@ -352,13 +399,13 @@ void AliMUONReconstructor::Reconstruct(AliRunLoader* runLoader, AliRawReader* ra
     // tracking branch
     data.MakeBranch("RC");
     data.SetTreeAddress("RC");
-    recoCluster.Digits2Clusters(); 
+    recoCluster->Digits2Clusters(); 
     data.Fill("RC"); 
 
     // trigger branch
     data.MakeBranch("TC");
     data.SetTreeAddress("TC");
-    recoCluster.Trigger2Trigger();
+    recoCluster->Trigger2Trigger();
     data.Fill("TC");
     
     loader->WriteRecPoints("OVERWRITE");
@@ -401,6 +448,8 @@ void AliMUONReconstructor::Reconstruct(AliRunLoader* runLoader, AliRawReader* ra
   
   delete recoEvent;
 
+  delete recoCluster;
+  
   AliInfo(Form("Execution time for converting RAW data to digits in MUON : R:%.2fs C:%.2fs",
                rawTimer.RealTime(),rawTimer.CpuTime()));
   AliInfo(Form("Execution time for calibrating MUON : R:%.2fs C:%.2fs",
index 2b77cb1..afc62d1 100644 (file)
@@ -19,6 +19,7 @@ class AliMUONDigitMaker;
 class AliMUONTriggerCrateStore;
 class TClonesArray;
 class AliMUONGeometryTransformer;
+class AliMUONClusterReconstructor;
 
 class AliMUONReconstructor: public AliReconstructor 
 {
@@ -49,6 +50,8 @@ class AliMUONReconstructor: public AliReconstructor
 private:
 
     TTask* GetCalibrationTask(AliMUONData* data) const;
+    AliMUONClusterReconstructor* CreateClusterReconstructor(AliMUONData*) const;
+    
     AliMUONReconstructor(const AliMUONReconstructor& right);
     AliMUONReconstructor&  operator = (const AliMUONReconstructor& right);