Changes for pilup:
authorivana <ivana@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 19 May 2010 09:13:39 +0000 (09:13 +0000)
committerivana <ivana@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 19 May 2010 09:13:39 +0000 (09:13 +0000)
- In AliMUON: Setter and getter of time limits for pileup events removed. Time limit variables removed.
- In AliMUONDigitizerV3: Cut on time for digitization removed
- In AliMUONSDigitizerV2:
  - Calling the DisIntegrate function now includes the time differences between the arrival hit time of a pileup event and the average arrival time
- In AliMUONResponse, AliMUONResponseTrigger, AliMUONResponseTriggerV1: DisIntegrate function modified to include differences in arrival time
- In AliMUONResponseV0: a reduction factor applied to the charged from energy loss if the hit belongs to a track in a pileup event.
- In AliMUONConstants: average arrival times to chambers added, a reduced total charge for hits belonging to tracks from pileup events added
(Mercedes)

15 files changed:
MUON/AliMUON.cxx
MUON/AliMUON.h
MUON/AliMUONConstants.cxx
MUON/AliMUONConstants.h
MUON/AliMUONDigitizerV3.cxx
MUON/AliMUONResponse.cxx
MUON/AliMUONResponse.h
MUON/AliMUONResponseTrigger.cxx
MUON/AliMUONResponseTrigger.h
MUON/AliMUONResponseTriggerV1.cxx
MUON/AliMUONResponseTriggerV1.h
MUON/AliMUONResponseV0.cxx
MUON/AliMUONResponseV0.h
MUON/AliMUONSDigitizerV2.cxx
MUON/AliMUONSDigitizerV2.h

index eaaa167..9db2fc3 100644 (file)
@@ -103,9 +103,7 @@ AliMUON::AliMUON()
     fDigitMaker(0x0),
     fHitStore(0x0),
     fDigitStoreConcreteClassName(),
-    fCalibrationData(0x0),
-    fTimeMin(-100000),
-    fTimeMax(100000)
+    fCalibrationData(0x0)
 {
 /// Default Constructor
     
@@ -141,10 +139,7 @@ AliMUON::AliMUON(const char *name, const char* title)
     fDigitMaker(new AliMUONDigitMaker),
     fHitStore(0x0),
     fDigitStoreConcreteClassName("AliMUONDigitStoreV2S"),
-    fCalibrationData(),
-    fTimeMin(-100000),
-    fTimeMax(100000)
-
+    fCalibrationData()
 {
   /// Standard constructor  
   
index dc3847c..186ec10 100644 (file)
@@ -122,15 +122,6 @@ class AliMUON : public  AliDetector
   /// Parametrised tail effect in resolution histogram
   virtual void SetTailEffect(Bool_t isTailEffect) { fIsTailEffect=isTailEffect; }
     
-    // For pileup studies
-    //
-                 /// Set time limits for sdigits to be digitized
-    virtual void SetTimeLimits(Float_t time1, Float_t time2) {fTimeMin=time1; fTimeMax=time2;}
-                 /// Return minimum time(*10^9) for a sdigit to be digitized
-    virtual Float_t GetTimeMin() {return fTimeMin;}
-                 /// Return maximum time(*10^9) for a sdigit to be digitized
-    virtual Float_t GetTimeMax() {return fTimeMax;}
-    
     // Getters
                   /// Return reference to Chamber \a id
     virtual AliMUONChamber& Chamber(Int_t id)
@@ -192,10 +183,7 @@ class AliMUON : public  AliDetector
     
     AliMUONCalibrationData* fCalibrationData; ///< pointer of calibration data
 
-    Float_t fTimeMin;           ///< minimum time(*10^9) for an sdigit to be digitized
-    Float_t fTimeMax;           ///< maximum time(*10^9) for an sdigit to be digitized
-  
-    ClassDef(AliMUON,20)  // MUON Detector base class
+    ClassDef(AliMUON,21)  // MUON Detector base class
 };
 #endif
 
index 01fec14..a4c0860 100644 (file)
@@ -114,6 +114,10 @@ Double_t AliMUONConstants::fgChamberThicknessInX0[10] = {0.065, 0.065, 0.075, 0.
 
 const Double_t AliMUONConstants::fgkMostProbBendingMomentum = 2.0;
 
+Float_t AliMUONConstants::fgAverageChamberT[14]=
+  {17.64*1E-9, 18.28*1E-9, 22.68*1E-9, 23.33*1E-9, 32.42*1E-9, 33.48*1E-9, 42.76*1E-9,
+   43.81*1E-9, 47.13*1E-9, 48.17*1E-9, 53.75*1E-9, 54.32*1E-9, 57.12*1E-9, 57.67*1E-9};
+
 //______________________________________________________________________________
 Int_t AliMUONConstants::NCh()
 {
@@ -172,3 +176,11 @@ Int_t AliMUONConstants::ChamberNumber(Float_t z, bool warn)
   if (warn) AliWarningClass(Form("No chamber number found for z = %f",z));
   return -1;
 }
+
+//______________________________________________________________________________
+Float_t AliMUONConstants::ReducedQTot(Float_t qtot, Float_t timeDif)
+{
+  // return a reduced charge if the hit belongs to a track from a pileup event
+  Float_t q = qtot*1.19*(1.24-timeDif*1E6)*TMath::Exp(-(0.97-timeDif*1E6)*(0.97-timeDif*1E6)/2.42);
+  return q;
+}
index aa56315..ddfa73e 100644 (file)
@@ -96,7 +96,12 @@ class AliMUONConstants : public TObject {
     static Double_t MuonFilterX0() {return fgkMuonFilterX0;}
 
     /// Return the most probable bending momentum (GeV/c) (used when B = 0)
-  static Double_t GetMostProbBendingMomentum() { return fgkMostProbBendingMomentum; }
+    static Double_t GetMostProbBendingMomentum() { return fgkMostProbBendingMomentum; }
+      
+    /// Return average arrival time to chamber i
+    static Float_t  AverageChamberT(Int_t i) {return fgAverageChamberT[i];}
+    /// Return a reduced total charge
+    static Float_t  ReducedQTot(Float_t qtot, Float_t timeDif);
   
  protected:
     /// Default constructor
@@ -151,8 +156,9 @@ class AliMUONConstants : public TObject {
     static const Double_t fgkMuonFilterZEnd; ///< z-position of the end of the muon filter
     static const Double_t fgkMuonFilterX0; ///< x0 of the muon filter
     
-  static const Double_t fgkMostProbBendingMomentum; ///< most probable value (GeV/c) of muon momentum in bending plane (used when B = 0) needed to get some "reasonable" corrections for MCS and E loss even if B = 0
+    static const Double_t fgkMostProbBendingMomentum; ///< most probable value (GeV/c) of muon momentum in bending plane (used when B = 0) needed to get some "reasonable" corrections for MCS and E loss even if B = 0
 
+    static Float_t fgAverageChamberT[14]; ///<average arrival time to chamber
   
     ClassDef(AliMUONConstants, 0) // MUON global constants 
 };
index 0d4d292..4c86d96 100644 (file)
@@ -783,14 +783,8 @@ AliMUONDigitizerV3::MergeWithSDigits(AliMUONVDigitStore*& outputStore,
   TIter next(input.CreateIterator());
   AliMUONVDigit* sdigit;
   
-  const float kTime1 = muon()->GetTimeMin();
-  const float kTime2 = muon()->GetTimeMax();
-
   while ( ( sdigit = static_cast<AliMUONVDigit*>(next()) ) )
   {
-    float time = sdigit->Time()*1E9;
-    if (time<kTime1 || time>kTime2) continue;
-    
     // Update the track references using the mask.
     // FIXME: this is dirty, for backward compatibility only.
     // Should re-design all this way of keeping track of MC information...
index ba7400c..b61ed83 100644 (file)
@@ -44,7 +44,7 @@ AliMUONResponse::~AliMUONResponse()
 
 //_____________________________________________________________________________
 void
-AliMUONResponse::DisIntegrate(const AliMUONHit&, TList& digits)
+AliMUONResponse::DisIntegrate(const AliMUONHit&, TList& digits, Float_t timeDif)
 {
 /// Not implemented disintegration
 
index 76d52f5..3f12582 100644 (file)
@@ -71,8 +71,8 @@ class AliMUONResponse : public TObject
     virtual Float_t IntXY(Int_t, AliMUONGeometrySegmentation*) const {return 1.;}
     
     //// Go from one hit to several digits, applying charge spreading.
-    virtual void DisIntegrate(const AliMUONHit& hit, TList& digits);
-
+    virtual void DisIntegrate(const AliMUONHit& hit, TList& digits, Float_t timeDif);
+    
     // 
     ClassDef(AliMUONResponse,1) // Chamber response virtual base class 
 };
index c834bd1..aa4215c 100644 (file)
@@ -84,7 +84,7 @@ AliMUONResponseTrigger::~AliMUONResponseTrigger()
 
 //_____________________________________________________________________________
 void 
-AliMUONResponseTrigger::DisIntegrate(const AliMUONHit& hit, TList& digits)
+AliMUONResponseTrigger::DisIntegrate(const AliMUONHit& hit, TList& digits, Float_t timeDif)
 {
   /// Generate 2 digits (one on each cathode) from 1 hit, i.e. no cluster-size
   /// generation (simplest response case).
index 0ed0e40..0300787 100644 (file)
@@ -23,8 +23,8 @@ class AliMUONResponseTrigger : public AliMUONResponse
   /// Set the GenerCluster parameter       
   virtual Int_t SetGenerCluster(){return 0;}
 
-  virtual void DisIntegrate(const AliMUONHit& hit, TList& digits);
-
+  virtual void DisIntegrate(const AliMUONHit& hit, TList& digits, Float_t timeDif);
+  
   virtual void InitTriggerEfficiency(AliMUONTriggerEfficiencyCells* triggerEfficiency);
 
  protected:
index 9a7cbb1..11c1df4 100644 (file)
@@ -127,7 +127,7 @@ const
 }
 
 //------------------------------------------------------------------  
-void AliMUONResponseTriggerV1::DisIntegrate(const AliMUONHit& hit, TList& digits)
+void AliMUONResponseTriggerV1::DisIntegrate(const AliMUONHit& hit, TList& digits, Float_t timeDif)
 {
   /// Generate digits (on each cathode) from 1 hit, with cluster-size
   /// generation.
index c7200f1..772721f 100644 (file)
@@ -24,8 +24,8 @@ class AliMUONResponseTriggerV1 : public AliMUONResponseTrigger
     // Set the GenerCluster parameter       
     virtual Int_t SetGenerCluster();
     
-    virtual void DisIntegrate(const AliMUONHit& hit, TList& digits);
-
+    virtual void DisIntegrate(const AliMUONHit& hit, TList& digits, Float_t timeDif);
+    
   protected:
     Float_t fGenerCluster;   ///< Random number  
     Float_t fA;              ///< first parameter  of the cluster-size param
index 8522676..fdfa74f 100644 (file)
@@ -28,6 +28,7 @@
 #include "AliMUONDigit.h"
 #include "AliMUONGeometryTransformer.h"
 #include "AliMUONHit.h"
+#include "AliMUONConstants.h"
 
 #include "AliMpArea.h"
 #include "AliMpDEManager.h"
@@ -201,7 +202,7 @@ AliMUONResponseV0::GetAnod(Float_t x) const
 
 //______________________________________________________________________________
 void 
-AliMUONResponseV0::DisIntegrate(const AliMUONHit& hit, TList& digits)
+AliMUONResponseV0::DisIntegrate(const AliMUONHit& hit, TList& digits, Float_t timeDif)
 {
   /// Go from 1 hit to a list of digits.
   /// The energy deposition of that hit is first converted into charge
@@ -265,6 +266,11 @@ AliMUONResponseV0::DisIntegrate(const AliMUONHit& hit, TList& digits)
   // Get pulse height from energy loss.
   Float_t qtot = IntPH(hit.Eloss());
   
+  // If from a pileup event we apply a reduction factor to the charge
+  if (timeDif!=0){
+    qtot = AliMUONConstants::ReducedQTot(qtot,timeDif);
+  }
+  
   // Get the charge correlation between cathodes.
   Float_t currentCorrel = TMath::Exp(gRandom->Gaus(0.0,ChargeCorrel()/2.0));
 
index 6575f7f..5651f4a 100644 (file)
@@ -91,7 +91,7 @@ class AliMUONResponseV0 : public AliMUONResponse
     
     virtual Float_t GetAnod(Float_t x) const;
     
-    virtual void DisIntegrate(const AliMUONHit& hit, TList& digits);
+    virtual void DisIntegrate(const AliMUONHit& hit, TList& digits, Float_t timeDif);
     
     virtual void Print(Option_t* opt="") const;
   
index 3eca563..801a505 100644 (file)
@@ -28,6 +28,7 @@
 #include "AliMUONVHitStore.h"
 #include "AliMUONCalibrationData.h"
 #include "AliMUONResponseTrigger.h"
+#include "AliMUONConstants.h"
 
 #include "AliMpCDB.h"
 #include "AliMpDEManager.h"
 
 ClassImp(AliMUONSDigitizerV2)
 
+Float_t  AliMUONSDigitizerV2::fgkMaxIntTime = 10.0;
+Float_t  AliMUONSDigitizerV2::fgkMaxPosTimeDif = 1.22E-6;
+Float_t  AliMUONSDigitizerV2::fgkMaxNegTimeDif = -3.5E-6;
+Float_t  AliMUONSDigitizerV2::fgkMinTimeDif = 25E-9;
+
 //_____________________________________________________________________________
 AliMUONSDigitizerV2::AliMUONSDigitizerV2() 
 : TTask("AliMUONSDigitizerV2","From Hits to SDigits for MUON")
@@ -126,6 +132,8 @@ AliMUONSDigitizerV2::Exec(Option_t*)
   
   AliDebug(1,Form("Will use digitStore of type %s",sDigitStore->ClassName()));
           
+  // average arrival time to chambers, for pileup studies
+
   for ( Int_t iEvent = 0; iEvent < nofEvents; ++iEvent ) 
   {    
     // Loop over events.
@@ -136,7 +144,7 @@ AliMUONSDigitizerV2::Exec(Option_t*)
     runLoader->GetEvent(iEvent);
   
     // for pile up studies
-    float T0=10;
+    float T0=fgkMaxIntTime;  int AA=0;
     AliHeader* header = runLoader->GetHeader();   
     AliGenCocktailEventHeader* cocktailHeader =
       dynamic_cast<AliGenCocktailEventHeader*>(header->GenEventHeader());
@@ -148,12 +156,14 @@ AliMUONSDigitizerV2::Exec(Option_t*)
       while((entry = (AliGenEventHeader*)nextH())) {
        float t = entry->InteractionTime();     
        if (TMath::Abs(t)<TMath::Abs(T0)) T0 = t;      
+       AA++;
       }
     } else {
       AliGenEventHeader* evtHeader = 
        (AliGenEventHeader*)(header->GenEventHeader());
       float t = evtHeader->InteractionTime();          
       if (TMath::Abs(t)<TMath::Abs(T0)) T0 = t;           
+      AA++;
     }
 
     loader->MakeSDigitsContainer();
@@ -185,7 +195,7 @@ AliMUONSDigitizerV2::Exec(Option_t*)
       
       while ( ( hit = static_cast<AliMUONHit*>(next()) ) )       
       {
-        Int_t chamberId = hit->Chamber()-1;
+       Int_t chamberId = hit->Chamber()-1;
        Float_t age = hit->Age()-T0;
 
         AliMUONChamber& chamber = muon->Chamber(chamberId);
@@ -193,7 +203,22 @@ AliMUONSDigitizerV2::Exec(Option_t*)
         
         // This is the heart of this method : the dis-integration
         TList digits;        
-        response->DisIntegrate(*hit,digits);
+       if (AA>1){  // if there are pileup events
+         Float_t chamberTime = AliMUONConstants::AverageChamberT(chamberId);
+         Float_t timeDif=age-chamberTime;        
+         if (timeDif>fgkMaxPosTimeDif || timeDif<fgkMaxNegTimeDif) {
+           continue;
+         }
+         if(TMath::Abs(timeDif)>fgkMinTimeDif){
+           response->DisIntegrate(*hit,digits,timeDif);
+         }
+         else{
+           response->DisIntegrate(*hit,digits,0.);
+         }
+       }
+       else{
+         response->DisIntegrate(*hit,digits,0.);
+       }
         
         TIter nextd(&digits);
         AliMUONVDigit* d;
index e6e2f2a..4a88675 100644 (file)
@@ -29,6 +29,12 @@ public:
   virtual ~AliMUONSDigitizerV2();
   
   virtual void Exec(Option_t* opt="");
+  
+private:
+  static Float_t  fgkMaxIntTime; ///< maximum time of interaction
+  static Float_t  fgkMaxPosTimeDif; ///< maximum event time after the triggered event for a hit to be digitized 
+  static Float_t  fgkMaxNegTimeDif; ///< maximum event time before the triggered event for a hit to be digitized 
+  static Float_t  fgkMinTimeDif; ///< minimum time difference for the reduction factor to be applied  
     
   ClassDef(AliMUONSDigitizerV2,1) // MUON SDigitizer V2-1
 };