Changes for pilup:

- 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)

diff --git a/MUON/AliMUON.cxx b/MUON/AliMUON.cxx
index eaaa167a704c00c9acac5cf3acbaa16ab1db6609..9db2fc3930be60a60fe7ec429151298024a85f33 100644 (file)
--- a/MUON/AliMUON.cxx
+++ b/MUON/AliMUON.cxx
@@ -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  
   

diff --git a/MUON/AliMUON.h b/MUON/AliMUON.h
index dc3847cd56d668aa809afbfa584ad219132f127a..186ec1089d1bcb7f2e983396f05c541c55d697e9 100644 (file)
--- a/MUON/AliMUON.h
+++ b/MUON/AliMUON.h
@@ -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
 

diff --git a/MUON/AliMUONConstants.cxx b/MUON/AliMUONConstants.cxx
index 01fec147f3aec2896cf972b192304276d17393d0..a4c08606a47ec9837ba2eaf0592d5143f58c22a2 100644 (file)
--- a/MUON/AliMUONConstants.cxx
+++ b/MUON/AliMUONConstants.cxx
@@ -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;
+}

diff --git a/MUON/AliMUONConstants.h b/MUON/AliMUONConstants.h
index aa563159e61fb79050449aec3d3fea11912eca17..ddfa73ec64aef0bbf9c8198d7fc7ad0d8ab27143 100644 (file)
--- a/MUON/AliMUONConstants.h
+++ b/MUON/AliMUONConstants.h
@@ -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 
 };

diff --git a/MUON/AliMUONDigitizerV3.cxx b/MUON/AliMUONDigitizerV3.cxx
index 0d4d29271606d0d7b0ca145f75035c12ea166751..4c86d9657e21428d9b557643c4836f0d7c0ff8f4 100644 (file)
--- a/MUON/AliMUONDigitizerV3.cxx
+++ b/MUON/AliMUONDigitizerV3.cxx
@@ -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...

diff --git a/MUON/AliMUONResponse.cxx b/MUON/AliMUONResponse.cxx
index ba7400cd41efc786d0341dbbea05d65b3a878b47..b61ed837d0b6e50d3c42f6cd655de1a07976a6ad 100644 (file)
--- a/MUON/AliMUONResponse.cxx
+++ b/MUON/AliMUONResponse.cxx
@@ -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
 

diff --git a/MUON/AliMUONResponse.h b/MUON/AliMUONResponse.h
index 76d52f5b6bf7db2326c86443b1432dd95484028e..3f125820a2aabff4b814a4cae98f2a7d1756e35b 100644 (file)
--- a/MUON/AliMUONResponse.h
+++ b/MUON/AliMUONResponse.h
@@ -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 
 };

diff --git a/MUON/AliMUONResponseTrigger.cxx b/MUON/AliMUONResponseTrigger.cxx
index c834bd173c595c01c683335dc19f1c2627f20649..aa4215c3967ddb85d82ce5d9eed6e37260779866 100644 (file)
--- a/MUON/AliMUONResponseTrigger.cxx
+++ b/MUON/AliMUONResponseTrigger.cxx
@@ -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).

diff --git a/MUON/AliMUONResponseTrigger.h b/MUON/AliMUONResponseTrigger.h
index 0ed0e40117c9fa6fc5982336879ab029d675ae0c..030078708853fc75b26fd6c5fc131e2a502daede 100644 (file)
--- a/MUON/AliMUONResponseTrigger.h
+++ b/MUON/AliMUONResponseTrigger.h
@@ -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:

diff --git a/MUON/AliMUONResponseTriggerV1.cxx b/MUON/AliMUONResponseTriggerV1.cxx
index 9a7cbb16c055c1ad9aa88d6c15fa52a1b5aee94d..11c1df4f6cc405dce9228e4a4ebba4c509062164 100644 (file)
--- a/MUON/AliMUONResponseTriggerV1.cxx
+++ b/MUON/AliMUONResponseTriggerV1.cxx
@@ -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.

diff --git a/MUON/AliMUONResponseTriggerV1.h b/MUON/AliMUONResponseTriggerV1.h
index c7200f1fd5d4b717a440781e63259279eeb03254..772721fb87f3033a53d4c6e83cee58f52bc2bc6e 100644 (file)
--- a/MUON/AliMUONResponseTriggerV1.h
+++ b/MUON/AliMUONResponseTriggerV1.h
@@ -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

diff --git a/MUON/AliMUONResponseV0.cxx b/MUON/AliMUONResponseV0.cxx
index 8522676bcd9926ea29c5fa6dffa95bae610405b2..fdfa74ff2c82a4df53d6e82e4a672deb45cbc361 100644 (file)
--- a/MUON/AliMUONResponseV0.cxx
+++ b/MUON/AliMUONResponseV0.cxx
@@ -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));
 

diff --git a/MUON/AliMUONResponseV0.h b/MUON/AliMUONResponseV0.h
index 6575f7f97971b6276bdd3b9f4c41362ee214132c..5651f4a7f2ed62ae5c0e6aa8eca668fc88e3adc5 100644 (file)
--- a/MUON/AliMUONResponseV0.h
+++ b/MUON/AliMUONResponseV0.h
@@ -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;
   

diff --git a/MUON/AliMUONSDigitizerV2.cxx b/MUON/AliMUONSDigitizerV2.cxx
index 3eca563e4e7e8139cca90bca4b69b71ccdfa0556..801a5053e08456618febd2aa8458d7fe25d4ef94 100644 (file)
--- a/MUON/AliMUONSDigitizerV2.cxx
+++ b/MUON/AliMUONSDigitizerV2.cxx
@@ -28,6 +28,7 @@
 #include "AliMUONVHitStore.h"
 #include "AliMUONCalibrationData.h"
 #include "AliMUONResponseTrigger.h"
+#include "AliMUONConstants.h"
 
 #include "AliMpCDB.h"
 #include "AliMpDEManager.h"
@@ -59,6 +60,11 @@
 
 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;

diff --git a/MUON/AliMUONSDigitizerV2.h b/MUON/AliMUONSDigitizerV2.h
index e6e2f2ad692797ad3f96eca756dc038ba3d47004..4a88675966bd6501a52db8bd4f32f87f2239b690 100644 (file)
--- a/MUON/AliMUONSDigitizerV2.h
+++ b/MUON/AliMUONSDigitizerV2.h
@@ -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
 };