From 2a5f75aef7242ac54f8f58866bbd0b8914bd9492 Mon Sep 17 00:00:00 2001 From: ivana Date: Wed, 19 May 2010 09:13:39 +0000 Subject: [PATCH] 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) --- MUON/AliMUON.cxx | 9 ++------- MUON/AliMUON.h | 14 +------------- MUON/AliMUONConstants.cxx | 12 ++++++++++++ MUON/AliMUONConstants.h | 10 ++++++++-- MUON/AliMUONDigitizerV3.cxx | 6 ------ MUON/AliMUONResponse.cxx | 2 +- MUON/AliMUONResponse.h | 4 ++-- MUON/AliMUONResponseTrigger.cxx | 2 +- MUON/AliMUONResponseTrigger.h | 4 ++-- MUON/AliMUONResponseTriggerV1.cxx | 2 +- MUON/AliMUONResponseTriggerV1.h | 4 ++-- MUON/AliMUONResponseV0.cxx | 8 +++++++- MUON/AliMUONResponseV0.h | 2 +- MUON/AliMUONSDigitizerV2.cxx | 31 ++++++++++++++++++++++++++++--- MUON/AliMUONSDigitizerV2.h | 6 ++++++ 15 files changed, 74 insertions(+), 42 deletions(-) diff --git a/MUON/AliMUON.cxx b/MUON/AliMUON.cxx index eaaa167a704..9db2fc3930b 100644 --- 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 dc3847cd56d..186ec1089d1 100644 --- 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 01fec147f3a..a4c08606a47 100644 --- 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 aa563159e61..ddfa73ec64a 100644 --- 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]; ///GetTimeMin(); - const float kTime2 = muon()->GetTimeMax(); - while ( ( sdigit = static_cast(next()) ) ) { - float time = sdigit->Time()*1E9; - if (timekTime2) 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 ba7400cd41e..b61ed837d0b 100644 --- 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 76d52f5b6bf..3f125820a2a 100644 --- 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 c834bd173c5..aa4215c3967 100644 --- 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 0ed0e40117c..03007870885 100644 --- 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 9a7cbb16c05..11c1df4f6cc 100644 --- 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 c7200f1fd5d..772721fb87f 100644 --- 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 8522676bcd9..fdfa74ff2c8 100644 --- 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 6575f7f9797..5651f4a7f2e 100644 --- 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 3eca563e4e7..801a5053e08 100644 --- 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(header->GenEventHeader()); @@ -148,12 +156,14 @@ AliMUONSDigitizerV2::Exec(Option_t*) while((entry = (AliGenEventHeader*)nextH())) { float t = entry->InteractionTime(); if (TMath::Abs(t)GenEventHeader()); float t = evtHeader->InteractionTime(); if (TMath::Abs(t)MakeSDigitsContainer(); @@ -185,7 +195,7 @@ AliMUONSDigitizerV2::Exec(Option_t*) while ( ( hit = static_cast(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 || timeDiffgkMinTimeDif){ + 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 e6e2f2ad692..4a88675966b 100644 --- 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 }; -- 2.43.0