Remove obselete method Hit2Digit for digitalization
authormartinez <martinez@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 9 Mar 2005 13:14:47 +0000 (13:14 +0000)
committermartinez <martinez@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 9 Mar 2005 13:14:47 +0000 (13:14 +0000)
MUON/AliMUONDigitizer.cxx
MUON/AliMUONDigitizerv2.cxx
MUON/AliMUONDigitizerv2.h
MUON/AliMUONSDigitizerv1.cxx
MUON/AliMUONSDigitizerv1.h
MUON/MUONsimLinkDef.h
MUON/libMUONsim.pkg

index e830220..1bd07a1 100644 (file)
 #include "AliMUONHitMapA1.h"
 #include "AliMUON.h"
 #include "AliMUONLoader.h"
-#include "AliMUONChamber.h"
 #include "AliMUONConstants.h"
-#include "AliMUONDigitizer.h"
 #include "AliMUONTransientDigit.h"
-#include "AliMUONHitMapA1.h"
 #include "AliMUONTriggerDecision.h"
 #include "AliLog.h"
 
index c549286..64bb4f4 100644 (file)
 //
 /////////////////////////////////////////////////////////////////////////////////
 
+#include "AliMUON.h"
 #include "AliMUONData.h"
 #include "AliMUONLoader.h"
 #include "AliMUONConstants.h"
+#include "AliMUONChamber.h"
 #include "AliMUONDigit.h"
 #include "AliMUONDigitizerv2.h"
 #include "AliMUONTransientDigit.h"
+#include "AliMUONTriggerDecision.h"
 #include "AliLog.h"
 
 ClassImp(AliMUONDigitizerv2)
 
 //___________________________________________
-AliMUONDigitizerv2::AliMUONDigitizerv2() : AliMUONDigitizerv1()
+AliMUONDigitizerv2::AliMUONDigitizerv2() : AliMUONDigitizer()
 {
        // Default ctor - don't use it
 }
 
 //___________________________________________
-AliMUONDigitizerv2::AliMUONDigitizerv2(AliRunDigitizer* manager) : AliMUONDigitizerv1(manager)
+AliMUONDigitizerv2::AliMUONDigitizerv2(AliRunDigitizer* manager) : AliMUONDigitizer(manager)
 {
        // ctor which should be used
 }
@@ -141,6 +144,22 @@ void AliMUONDigitizerv2::AddDigit(Int_t chamber, Int_t tracks[kMAXTRACKS], Int_t
 }
 
 //------------------------------------------------------------------------
+Int_t AliMUONDigitizerv2::GetSignalFrom(AliMUONTransientDigit* td)
+{
+// Derived to apply the chamber response model to the digit. 
+// Using AliMUONChamber::ResponseModel() for this.
+
+       AliDebug(4, "Applying response of chamber to TransientDigit signal.");
+       //
+       //  Digit Response (noise, threshold, saturation, ...)
+       Int_t q = td->Signal(); 
+       AliMUONChamber& chamber = fMUON->Chamber(td->Chamber());
+       AliMUONResponse* response = chamber.ResponseModel();
+       q = response->DigitResponse(q, td);
+       return q;
+}
+
+//------------------------------------------------------------------------
 Bool_t AliMUONDigitizerv2::InitInputData(AliMUONLoader* muonloader)
 {
 // Overridden to initialize fMUONData to read from the s-digits tree TreeS. 
@@ -173,3 +192,84 @@ void AliMUONDigitizerv2::CleanupInputData(AliMUONLoader* muonloader)
        fMUONData->ResetSDigits();
        muonloader->UnloadSDigits();
 }
+
+//------------------------------------------------------------------------
+Bool_t AliMUONDigitizerv2::InitOutputData(AliMUONLoader* muonloader)
+{
+// Derived to initialize the output digits tree TreeD, create it if necessary
+// and sets the fMUONData tree address to treeD.
+
+       AliDebug(3, "Creating digits branch and setting the tree address.");
+
+       fMUONData->SetLoader(muonloader);
+
+       // New branch per chamber for MUON digit in the tree of digits
+       if (muonloader->TreeD() == NULL)
+       {
+               muonloader->MakeDigitsContainer();
+               if (muonloader->TreeD() == NULL)
+               {
+                       AliError("Could not create TreeD.");
+                       return kFALSE;
+               }
+       }
+
+       fMUONData->MakeBranch("D");
+       fMUONData->SetTreeAddress("D");
+       
+       return kTRUE;
+}
+
+//------------------------------------------------------------------------
+void AliMUONDigitizerv2::FillOutputData()
+{
+// Derived to fill TreeD and resets the digit array in fMUONData.
+
+       AliDebug(3, "Filling trees with digits.");
+       fMUONData->Fill("D");
+       fMUONData->ResetDigits();
+}
+
+//------------------------------------------------------------------------
+void AliMUONDigitizerv2::CleanupOutputData(AliMUONLoader* muonloader)
+{
+// Derived to write the digits tree and then unload the digits tree once written.
+
+       AliDebug(3, "Writing digits and releasing pointers.");
+       muonloader->WriteDigits("OVERWRITE");
+       muonloader->UnloadDigits();
+}
+
+//-----------------------------------------------------------------------
+
+void AliMUONDigitizerv2::CleanupTriggerArrays()
+{
+  fTrigDec->ClearDigits();
+}
+
+//------------------------------------------------------------------------
+void AliMUONDigitizerv2::AddDigitTrigger(Int_t chamber, Int_t tracks[kMAXTRACKS], Int_t charges[kMAXTRACKS], Int_t digits[7])
+{
+// Derived to add digits to TreeD for trigger.
+  fTrigDec->AddDigit(chamber, tracks, charges, digits); 
+}
+
+//------------------------------------------------------------------------
+void AliMUONDigitizerv2::FillTriggerOutput()
+{
+// Derived to fill TreeD and resets the trigger array in fMUONData.
+
+       AliDebug(3,"Filling trees with trigger.");
+       fMUONData->Fill("GLT");
+       fMUONData->ResetTrigger();
+}
+
+//------------------------------------------------------------------------
+void AliMUONDigitizerv2::CreateTrigger()
+{
+  fMUONData->MakeBranch("GLT");
+  fMUONData->SetTreeAddress("GLT");
+  fTrigDec->Digits2Trigger(); 
+  FillTriggerOutput(); 
+
+}
index 4222df7..ddfcda6 100644 (file)
@@ -6,12 +6,12 @@
 /* $Id$ */
 // Revision of includes 07/05/2004
 
-#include "AliMUONDigitizerv1.h"
+#include "AliMUONDigitizer.h"
 #include "AliMUONDigit.h"
 
 class AliMUONLoader;
 
-class AliMUONDigitizerv2 : public AliMUONDigitizerv1
+class AliMUONDigitizerv2 : public AliMUONDigitizer
 {
   public:    
        AliMUONDigitizerv2();
@@ -24,10 +24,22 @@ class AliMUONDigitizerv2 : public AliMUONDigitizerv1
        void MakeTransientDigitFromSDigit(Int_t iChamber, AliMUONDigit* sDigit);
 
        // The following methods are inherited from AliMUONDigitizerv1 and overridden.
-       virtual void GenerateTransientDigits();
-       virtual void AddDigit(Int_t chamber, Int_t tracks[kMAXTRACKS], Int_t charges[kMAXTRACKS], Int_t digits[7]);
-       virtual Bool_t InitInputData(AliMUONLoader* muonloader);
-       virtual void CleanupInputData(AliMUONLoader* muonloader);
+       void GenerateTransientDigits();
+       void AddDigit(Int_t chamber, Int_t tracks[kMAXTRACKS], Int_t charges[kMAXTRACKS], Int_t digits[7]);
+       Bool_t InitInputData(AliMUONLoader* muonloader);
+       void CleanupInputData(AliMUONLoader* muonloader);
+
+       // methods from old AliMUONDigitizerv1
+       Int_t GetSignalFrom(AliMUONTransientDigit* td);
+       Bool_t InitOutputData(AliMUONLoader* muonloader);
+       void CleanupOutputData(AliMUONLoader* muonloader);
+       void FillOutputData();
+
+       // for trigger purpose
+       virtual void CreateTrigger();
+       virtual void CleanupTriggerArrays();
+       virtual void AddDigitTrigger(Int_t chamber, Int_t tracks[kMAXTRACKS], Int_t charges[kMAXTRACKS], Int_t digits[7]);
+       virtual void FillTriggerOutput();
 
        ClassDef(AliMUONDigitizerv2, 0) 
 };    
index 598e41c..ab5b63f 100644 (file)
 /////////////////////////////////////////////////////////////////////////////////
 
 #include "AliMUONSDigitizerv1.h"
+#include "AliMUON.h"
 #include "AliMUONLoader.h"
+#include "AliMUONConstants.h"
+#include "AliMUONChamber.h"
 #include "AliMUONData.h"
 #include "AliMUONDigit.h"
+#include "AliMUONHit.h"
 #include "AliMUONTransientDigit.h"
 #include "AliLog.h"
 
@@ -36,14 +40,14 @@ ClassImp(AliMUONSDigitizerv1)
 
 //___________________________________________
 AliMUONSDigitizerv1::AliMUONSDigitizerv1() 
-  : AliMUONDigitizerv1()
+  : AliMUONDigitizer()
 {
        // Default ctor - don't use it
 }
 
 //___________________________________________
 AliMUONSDigitizerv1::AliMUONSDigitizerv1(AliRunDigitizer* manager) 
-  : AliMUONDigitizerv1(manager)
+  : AliMUONDigitizer(manager)
 {
        // ctor which should be used
 }
@@ -54,6 +58,123 @@ AliMUONSDigitizerv1::~AliMUONSDigitizerv1()
        // Destructor
 }
 
+//-----------------------------------------------------------------------
+void AliMUONSDigitizerv1::GenerateTransientDigits()
+{
+// Loops over all tracks and hits in the current selected event and calls 
+// MakeTransientDigitsFromHit for each hit. 
+// Note: Charge correlation is applied to the tracking chambers. 
+
+       TTree* treeH = fGime->TreeH();
+       AliDebug(2, Form("Generating transient digits using treeH = 0x%X"
+                       , (void*)treeH));
+       //
+       // Loop over tracks
+       Int_t ntracks = (Int_t) treeH->GetEntries();
+       for (Int_t itrack = 0; itrack < ntracks; itrack++) 
+       {
+               AliDebug(3, Form("Processing track %d...", itrack));
+               fMUONData->ResetHits();
+               treeH->GetEvent(itrack);
+               //
+               //  Loop over hits
+               TClonesArray* hits = fMUONData->Hits();
+               for (Int_t ihit = 0; ihit < hits->GetEntriesFast(); ihit++) 
+               {
+                       AliMUONHit* mHit = static_cast<AliMUONHit*>( hits->At(ihit) );
+                       Int_t ichamber = mHit->Chamber()-1;  // chamber number
+                       if (ichamber > AliMUONConstants::NCh()-1) 
+                       {
+                               AliError(Form("Hit 0x%X has a invalid chamber number: %d", ichamber));
+                               continue;
+                       }
+                       //
+                       //Dumping Hit content:
+                       AliDebug(3,Form("Hit %d: chamber = %d\tX = %f\tY = %f\tZ = %f\teloss = %f",
+                                       ihit, mHit->Chamber(), mHit->X(), mHit->Y(), mHit->Z(), mHit->Eloss()
+                                   ));
+                       // 
+                       // Inititializing Correlation
+                       AliMUONChamber& chamber = fMUON->Chamber(ichamber);
+                       chamber.ChargeCorrelationInit();
+                       if (ichamber < AliMUONConstants::NTrackingCh()) 
+                       {
+                               // Tracking Chamber
+                               // Initialize hit position (cursor) in the segmentation model 
+                         if (GetSegmentation() == 1) // old segmentation
+                           chamber.SigGenInit(mHit->X(), mHit->Y(), mHit->Z());
+                         else 
+                           chamber.SigGenInit(mHit);
+
+                       } // else do nothing for Trigger Chambers
+                       
+                       MakeTransientDigitsFromHit(itrack, ihit, mHit);
+               } // hit loop
+       } // track loop      
+}
+
+//--------------------------------------------------------------------------
+void AliMUONSDigitizerv1::MakeTransientDigitsFromHit(Int_t track, Int_t iHit, AliMUONHit * mHit)
+{  
+// This method is called for every hit in an event to generate AliMUONTransientDigits 
+// from the hit and add these to fTDList.
+// The AliMUONChamber::DisIntegration method us used to figure out which pads are 
+// fired for a given hit. We then loop over the fired pads and add an AliMUONTransientDigit
+// for each pad.
+
+       AliDebug(4,Form("Making transient digit for hit number %d.", iHit));
+               
+       //
+       // Calls the charge disintegration method of the current chamber 
+       AliDebug(5,"Calling AliMUONChamber::DisIngtegration...");
+
+       Float_t newdigit[6][500];  // Pad information
+       Int_t nnew=0;              // Number of touched Pads per hit
+       Int_t ichamber = mHit->Chamber()-1;
+       AliMUONChamber& chamber = fMUON->Chamber(ichamber);
+       if (GetSegmentation() == 1)
+         chamber.DisIntegration(mHit->Eloss(), mHit->Age(), mHit->X(), mHit->Y(), mHit->Z(), nnew, newdigit);
+       else
+         chamber.DisIntegration(mHit, nnew, newdigit);
+
+       // Creating new TransientDigits from hit
+       for(Int_t iTD = 0; iTD < nnew; iTD++) 
+       {
+               Int_t charge;   
+               Int_t digits[7];
+               
+               digits[0] = Int_t(newdigit[1][iTD]);  // Padx of the Digit
+               digits[1] = Int_t(newdigit[2][iTD]);  // Pady of the Digit
+               digits[2] = Int_t(newdigit[5][iTD]);  // Cathode plane
+               digits[3] = Int_t(newdigit[3][iTD]);  // Induced charge in the Pad
+               if (fSignal)
+               { 
+                       charge = digits[3];
+                       digits[4] = Int_t(newdigit[3][iTD]);  // Signal due to physics
+               }
+               else
+               {
+                       charge = digits[3] + fMask;
+                       digits[4] = 0;    // No signal due to physics since this is now background.
+               }
+               digits[5] = iHit+fMask;    // Hit number in the list
+               if (GetSegmentation() == 1)
+                 digits[6] = 0;
+               else
+                 digits[6] =  mHit->DetElemId();
+
+               AliDebug(5,Form("MakeTransientDigitsFromHit", 
+                               "DisIntegration result %d: PadX %d\tPadY %d\tPlane %d\tCharge %d\tHit %d\tidDE %d",
+                               iTD, digits[0], digits[1], digits[2], digits[3], digits[5], digits[6]));
+
+               AliMUONTransientDigit* mTD = new AliMUONTransientDigit(ichamber, digits);
+               mTD->AddToTrackList(track + fMask, charge);
+
+               OnCreateTransientDigit(mTD, mHit);
+               AddOrUpdateTransientDigit(mTD);
+       }
+}
+
 //------------------------------------------------------------------------
 void AliMUONSDigitizerv1::AddDigit(Int_t chamber, Int_t tracks[kMAXTRACKS], Int_t charges[kMAXTRACKS], Int_t digits[7])
 {
@@ -114,3 +235,38 @@ void AliMUONSDigitizerv1::CleanupOutputData(AliMUONLoader* muonloader)
        fMUONData->ResetSDigits();
        muonloader->UnloadSDigits();
 }
+
+//------------------------------------------------------------------------
+Bool_t AliMUONSDigitizerv1::InitInputData(AliMUONLoader* muonloader)
+{
+// Derived to initialise the input to read from TreeH the hits tree. 
+// If the hits are not loaded then we load the hits using the muon loader.
+
+       AliDebug(3, "Loading hits in READ mode and setting the tree address.");
+
+       fMUONData->SetLoader(muonloader);
+
+       if (muonloader->TreeH() == NULL)
+       {
+               muonloader->LoadHits("READ");
+               if (muonloader->TreeH() == NULL)
+               {
+                       AliError("Can not load the hits tree.");
+                       return kFALSE;
+               }
+       }
+
+       fMUONData->SetTreeAddress("H");
+       return kTRUE;
+}
+
+//------------------------------------------------------------------------
+void AliMUONSDigitizerv1::CleanupInputData(AliMUONLoader* muonloader)
+{
+// Derived to release the loaded hits and unload them.
+
+       AliDebug(3, "Releasing loaded hits.");
+       fMUONData->ResetHits();
+       muonloader->UnloadHits();
+}
+
index 9fec5a9..be69b2e 100644 (file)
 // SDigits from Hits 
 // J.P Cussonneau Subatech Feb 2004
 
-#include "AliMUONDigitizerv1.h"
+#include "AliMUONDigitizer.h"
 
-class AliMUONSDigitizerv1 : public AliMUONDigitizerv1
+class AliMUONHit;
+
+class AliMUONSDigitizerv1 : public AliMUONDigitizer
 {
   public:    
        AliMUONSDigitizerv1();
@@ -21,12 +23,19 @@ class AliMUONSDigitizerv1 : public AliMUONDigitizerv1
        // Preferred constructor to call which sets the manager.
        AliMUONSDigitizerv1(AliRunDigitizer * manager);
 
-       // The following methods are inherited from AliMUONDigitizerv1
-       virtual void AddDigit(Int_t chamber, Int_t tracks[kMAXTRACKS], Int_t charges[kMAXTRACKS], Int_t digits[7]);
-       virtual Int_t GetSignalFrom(AliMUONTransientDigit* td);
-       virtual Bool_t InitOutputData(AliMUONLoader* muonloader);
-       virtual void FillOutputData();
-       virtual void CleanupOutputData(AliMUONLoader* muonloader);
+       // methods from old AliMUONDigitizerv1
+       void MakeTransientDigitsFromHit(Int_t itrack, Int_t ihit, AliMUONHit * mHit);
+       void GenerateTransientDigits();
+
+       void AddDigit(Int_t chamber, Int_t tracks[kMAXTRACKS], Int_t charges[kMAXTRACKS], Int_t digits[7]);
+       Int_t GetSignalFrom(AliMUONTransientDigit* td);
+       Bool_t InitOutputData(AliMUONLoader* muonloader);
+       void FillOutputData();
+       void CleanupOutputData(AliMUONLoader* muonloader);
+
+       // methods from old AliMUONDigitizerv1
+       virtual Bool_t InitInputData(AliMUONLoader* muonloader);
+       virtual void CleanupInputData(AliMUONLoader* muonloader);
 
        // to disable trigger in SDigitizer
        void CreateTrigger(){return;}
index eeb1931..785f4b3 100644 (file)
@@ -21,7 +21,6 @@
 #pragma link C++ class AliMUONPadHit+; 
 
 #pragma link C++ class AliMUONDigitizer+; 
-#pragma link C++ class AliMUONDigitizerv1+; 
 #pragma link C++ class AliMUONDigitizerv2+; 
 #pragma link C++ class AliMUONSDigitizerv1+; 
 #pragma link C++ class AliMUONMerger+; 
index ae821cb..f4d1b57 100644 (file)
@@ -14,7 +14,6 @@ SRCS:= AliMUONv0.cxx \
        AliMUONPadHit.cxx \
        AliMUONSt1Decoder.cxx \
        AliMUONDigitizer.cxx \
-       AliMUONDigitizerv1.cxx \
        AliMUONDigitizerv2.cxx \
        AliMUONSDigitizerv1.cxx \
        AliMUONMerger.cxx \