From 8c0b5e70eaf4af646346ce107d408237194cb59d Mon Sep 17 00:00:00 2001 From: martinez Date: Thu, 28 Jun 2007 10:20:41 +0000 Subject: [PATCH] Intrinsic chamber efficiency calculation performed during reconstruction (Diego) Output of the efficiency calculation stored in esdTree user info (Diego) Digits in non bending plane crossing many local boards are saved once in order t avoid storing twice the same digit (Diego) --- MUON/AliMUON.cxx | 6 +- MUON/AliMUON.h | 6 +- MUON/AliMUONDigitMaker.cxx | 18 +- MUON/AliMUONDigitizerV3.cxx | 124 ++- MUON/AliMUONDigitizerV3.h | 6 +- MUON/AliMUONReconstructor.cxx | 20 +- MUON/AliMUONReconstructor.h | 4 + MUON/AliMUONResponseTriggerV1.cxx | 8 +- MUON/AliMUONTracker.cxx | 11 +- MUON/AliMUONTracker.h | 5 +- MUON/AliMUONTriggerChamberEff.cxx | 953 +++++++++++----------- MUON/AliMUONTriggerChamberEff.h | 103 +-- MUON/AliMUONTriggerEfficiencyCells.cxx | 44 +- MUON/AliMUONTriggerEfficiencyCells.h | 3 +- MUON/MUONrecLinkDef.h | 1 + MUON/libMUONrec.pkg | 1 + MUON/mapping/AliMpTriggerSegmentation.cxx | 8 +- 17 files changed, 778 insertions(+), 543 deletions(-) diff --git a/MUON/AliMUON.cxx b/MUON/AliMUON.cxx index b701e620100..e7b6cdae403 100644 --- a/MUON/AliMUON.cxx +++ b/MUON/AliMUON.cxx @@ -115,7 +115,7 @@ AliMUON::AliMUON() fTriggerResponseV1(kFALSE), fTriggerCoinc44(0), fTriggerEffCells(0), - fDigitizerWithNoise(kTRUE), + fDigitizerWithNoise(1), fRawWriter(0x0), fDigitMaker(0x0), fHitStore(0x0) @@ -147,7 +147,7 @@ AliMUON::AliMUON(const char *name, const char* title) fTriggerResponseV1(kFALSE), fTriggerCoinc44(0), fTriggerEffCells(0), - fDigitizerWithNoise(kTRUE), + fDigitizerWithNoise(1), fRawWriter(0x0), fDigitMaker(new AliMUONDigitMaker), fHitStore(0x0) @@ -601,7 +601,7 @@ Bool_t AliMUON::GetTriggerEffCells() const } //____________________________________________________________________ -Bool_t AliMUON::GetDigitizerWithNoise() const +Int_t AliMUON::GetDigitizerWithNoise() const { /// /// Returns fDigitizerWithNoise diff --git a/MUON/AliMUON.h b/MUON/AliMUON.h index d030a9b1636..34f30fded5a 100644 --- a/MUON/AliMUON.h +++ b/MUON/AliMUON.h @@ -117,9 +117,9 @@ class AliMUON : public AliDetector { fTriggerEffCells = trigEffCells; } virtual Bool_t GetTriggerEffCells() const; /// Set off generation of noisy digits - virtual void SetDigitizerWithNoise(Bool_t digitizerWithNoise) + virtual void SetDigitizerWithNoise(Int_t digitizerWithNoise) { fDigitizerWithNoise = digitizerWithNoise; } - virtual Bool_t GetDigitizerWithNoise() const; + virtual Int_t GetDigitizerWithNoise() const; // Getters /// Return reference to Chamber \a id @@ -164,7 +164,7 @@ class AliMUON : public AliDetector Bool_t fTriggerResponseV1; ///< Flag to select TriggerResponseV1 Int_t fTriggerCoinc44; ///< Flag to select TriggerCoinc44 Bool_t fTriggerEffCells; ///< Flag to select TriggerEffCells - Bool_t fDigitizerWithNoise; ///< Flag to switch on/off generation of noisy digits + Int_t fDigitizerWithNoise; ///< Flag to switch on/off generation of noisy digits AliMUONRawWriter* fRawWriter; //!< Raw data writer diff --git a/MUON/AliMUONDigitMaker.cxx b/MUON/AliMUONDigitMaker.cxx index 52dc820bc70..8e3b472cae6 100644 --- a/MUON/AliMUONDigitMaker.cxx +++ b/MUON/AliMUONDigitMaker.cxx @@ -328,6 +328,8 @@ Int_t AliMUONDigitMaker::TriggerDigits(Int_t nBoard, AliMpLocalBoard* localBoard = AliMpDDLStore::Instance()->GetLocalBoard(nBoard); + Int_t n,b; + // loop over x1-4 and y1-4 for (Int_t iChamber = 0; iChamber < 4; ++iChamber) { @@ -360,14 +362,20 @@ Int_t AliMUONDigitMaker::TriggerDigits(Int_t nBoard, detElemId, nBoard, ibitxy)); continue; } - - AliMUONVDigit* digit = digitStore.Add(detElemId,nBoard,ibitxy,iCath,AliMUONVDigitStore::kDeny); + + n = pad.GetLocation(0).GetFirst(); // always take first location so that digits are not inserted several times + b = pad.GetLocation(0).GetSecond(); + + AliDebug(1,Form("Using localBoard %d ixy %d instead of %d,%d", + n,b,nBoard,ibitxy)); + + AliMUONVDigit* digit = digitStore.Add(detElemId,n,b,iCath,AliMUONVDigitStore::kDeny); if (!digit) { - AliError(Form("Could not add digit DE %04d LocalBoard %03d ibitxy %02d cath %d", - detElemId,nBoard,ibitxy,iCath)); - continue; + AliDebug(1, Form("Digit DE %04d LocalBoard %03d ibitxy %02d cath %d already in store", + detElemId,nBoard,ibitxy,iCath)); + continue; } Int_t padX = pad.GetIndices().GetFirst(); diff --git a/MUON/AliMUONDigitizerV3.cxx b/MUON/AliMUONDigitizerV3.cxx index 0f576e51209..2075c76b001 100644 --- a/MUON/AliMUONDigitizerV3.cxx +++ b/MUON/AliMUONDigitizerV3.cxx @@ -51,6 +51,7 @@ #include #include +#include "AliMUONGeometryTransformer.h" //ADDED for trigger noise /// /// \class AliMUONDigitizerV3 /// The digitizer is performing the transformation to go from SDigits (digits @@ -73,6 +74,12 @@ namespace { return static_cast(gAlice->GetModule("MUON")); } + + //ADDED for trigger noise + const AliMUONGeometryTransformer* GetTransformer() + { + return muon()->GetGeometryTransformer(); + } } const Double_t AliMUONDigitizerV3::fgkNSigmas=3; @@ -83,7 +90,7 @@ ClassImp(AliMUONDigitizerV3) //_____________________________________________________________________________ AliMUONDigitizerV3::AliMUONDigitizerV3(AliRunDigitizer* manager, - Bool_t generateNoisyDigits) + Int_t generateNoisyDigits) : AliDigitizer(manager), fIsInitialized(kFALSE), fCalibrationData(0x0), @@ -92,6 +99,7 @@ fTriggerEfficiency(0x0), fGenerateNoisyDigitsTimer(), fExecTimer(), fNoiseFunction(0x0), +fNoiseFunctionTrig(0x0), fGenerateNoisyDigits(generateNoisyDigits), fLogger(new AliMUONLogger(1000)), fTriggerStore(new AliMUONTriggerStoreV1), @@ -115,6 +123,7 @@ AliMUONDigitizerV3::~AliMUONDigitizerV3() delete fCalibrationData; delete fTriggerProcessor; delete fNoiseFunction; + delete fNoiseFunctionTrig; delete fTriggerStore; delete fDigitStore; delete fOutputDigitStore; @@ -254,7 +263,7 @@ AliMUONDigitizerV3::ApplyResponseToTriggerDigit(const AliMUONVDigitStore& digitS Bool_t isTrig[2]; - fTriggerEfficiency->IsTriggered(detElemId, nboard-1, + fTriggerEfficiency->IsTriggered(detElemId, nboard, isTrig[0], isTrig[1]); digit.EfficiencyApplied(kTRUE); correspondingDigit->EfficiencyApplied(kTRUE); @@ -383,6 +392,12 @@ AliMUONDigitizerV3::Exec(Option_t*) fOutputDigitStore = fDigitStore->Create(); } + if ( fGenerateNoisyDigits>=2 ) + { + // Generate noise-only digits for trigger. + GenerateNoisyDigitsForTrigger(*fDigitStore); + } + ApplyResponse(*fDigitStore,*fOutputDigitStore); if ( fGenerateNoisyDigits ) @@ -567,6 +582,111 @@ AliMUONDigitizerV3::GenerateNoisyDigitsForOneCathode(AliMUONVDigitStore& digitSt } } + +//_____________________________________________________________________________ +void +AliMUONDigitizerV3::GenerateNoisyDigitsForTrigger(AliMUONVDigitStore& digitStore) +{ + /// Generate noise-only digits for one cathode of one detection element. + /// Called by GenerateNoisyDigits() + + if ( !fNoiseFunctionTrig ) + { + fNoiseFunctionTrig = new TF1("AliMUONDigitizerV3::fNoiseFunctionTrig","landau", + 50.,270.); + + fNoiseFunctionTrig->SetParameters(3.91070e+02, 9.85026, 9.35881e-02); + } + + AliMpPad pad[2]; + AliMUONVDigit *d[2]={0x0}; + + for ( Int_t chamberId = AliMUONConstants::NTrackingCh(); chamberId < AliMUONConstants::NCh(); ++chamberId ) + { + + Int_t nofNoisyPads = 50; + + Float_t r=-1, fi = 0., gx, gy, x, y, z, xg01, yg01, zg, xg02, yg02; + AliMpDEIterator it; + + AliDebug(3,Form("Chamber %d nofNoisyPads %d",chamberId,nofNoisyPads)); + + for ( Int_t i = 0; i < nofNoisyPads; ++i ) + { + //printf("Generating noise %i\n",i); + Int_t ix(-1); + Int_t iy(-1); + Bool_t isOk = kFALSE; + Int_t detElemId = -1; + do { + //r = gRandom->Landau(9.85026, 9.35881e-02); + r = fNoiseFunctionTrig->GetRandom(); + fi = 2. * TMath::Pi() * gRandom->Rndm(); + //printf("r = %f\tfi = %f\n", r, fi); + gx = r * TMath::Cos(fi); + gy = r * TMath::Sin(fi); + + for ( it.First(chamberId); ! it.IsDone(); it.Next() ){ + Int_t currDetElemId = it.CurrentDEId(); + const AliMpVSegmentation* seg + = AliMpSegmentation::Instance()->GetMpSegmentation(currDetElemId,AliMp::GetCathodType(0)); + if (!seg) continue; + Float_t deltax = seg->Dimensions().X(); + Float_t deltay = seg->Dimensions().Y(); + GetTransformer()->Local2Global(currDetElemId, -deltax, -deltay, 0, xg01, yg01, zg); + GetTransformer()->Local2Global(currDetElemId, deltax, deltay, 0, xg02, yg02, zg); + Float_t xg1 = xg01, xg2 = xg02, yg1 = yg01, yg2 = yg02; + if(xg01>xg02){ + xg1 = xg02; + xg2 = xg01; + } + if(yg01>yg02){ + yg1 = yg02; + yg2 = yg01; + } + if(gx>=xg1 && gx<=xg2 && gy>=yg1 && gy<=yg2){ + detElemId = currDetElemId; + GetTransformer()->Global2Local(detElemId, gx, gy, 0, x, y, z); + pad[0] = seg->PadByPosition(TVector2(x,y),kFALSE); + if(!pad[0].IsValid()) continue; + isOk = kTRUE; + break; + } + } // loop on slats + } while ( !isOk ); + + const AliMpVSegmentation* seg1 + = AliMpSegmentation::Instance()->GetMpSegmentation(detElemId,AliMp::GetCathodType(1)); + pad[1] = seg1->PadByPosition(TVector2(x,y),kFALSE); + + for ( Int_t cathode = 0; cathode < 2; ++cathode ){ + Int_t manuId = pad[cathode].GetLocation(0).GetFirst(); + Int_t manuChannel = pad[cathode].GetLocation(0).GetSecond(); + d[cathode] = digitStore.CreateDigit(detElemId,manuId,manuChannel,cathode); + ix = pad[cathode].GetIndices().GetFirst(); + iy = pad[cathode].GetIndices().GetSecond(); + d[cathode]->SetPadXY(ix,iy); + //d[cathode].SetSignal(1); + //d[cathode].SetPhysicsSignal(0); + d[cathode]->SetCharge(1); + d[cathode]->NoiseOnly(kTRUE); + AliDebug(3,Form("Adding a pure noise digit :")); + + Bool_t ok = digitStore.Add(*d[cathode],AliMUONVDigitStore::kDeny); + if (!ok) + { + fLogger->Log("Collision while adding TriggerNoise digit"); + } + else + { + fLogger->Log("Added triggerNoise digit"); + } + } //loop on cathodes + } // loop on noisy pads + } // loop on chambers +} + + //_____________________________________________________________________________ AliLoader* AliMUONDigitizerV3::GetLoader(const TString& folderName) diff --git a/MUON/AliMUONDigitizerV3.h b/MUON/AliMUONDigitizerV3.h index 68f4de9f49f..3c60a526744 100644 --- a/MUON/AliMUONDigitizerV3.h +++ b/MUON/AliMUONDigitizerV3.h @@ -36,7 +36,7 @@ class AliMUONDigitizerV3 : public AliDigitizer { public: AliMUONDigitizerV3(AliRunDigitizer* manager=0, - Bool_t generateNoisyDigits=kTRUE); + Int_t generateNoisyDigits=1); virtual ~AliMUONDigitizerV3(); virtual void Exec(Option_t* opt=""); @@ -64,6 +64,7 @@ private: void GenerateNoisyDigits(AliMUONVDigitStore& digitStore); void GenerateNoisyDigitsForOneCathode(AliMUONVDigitStore& digitStore, Int_t detElemId, Int_t cathode); + void GenerateNoisyDigitsForTrigger(AliMUONVDigitStore& digitStore); void MergeWithSDigits(AliMUONVDigitStore*& digitStore, const AliMUONVDigitStore& input, @@ -77,7 +78,8 @@ private: TStopwatch fGenerateNoisyDigitsTimer; //!< counting time spent in GenerateNoisyDigits() TStopwatch fExecTimer; //!< couting time spent in Exec() TF1* fNoiseFunction; //!< function to randomly get signal above n*sigma_ped - Bool_t fGenerateNoisyDigits; //!< whether or not we should generate noise-only digits for tracker + TF1* fNoiseFunctionTrig; //!< function to get noise disribution on trig. chambers + Int_t fGenerateNoisyDigits; //!< whether or not we should generate noise-only digits for tracker (1) and trigger (2) static const Double_t fgkNSigmas; ///< \brief number of sigmas above ped to use /// for noise-only digit generation and zero-suppression AliMUONLogger* fLogger; //!< to keep track of messages diff --git a/MUON/AliMUONReconstructor.cxx b/MUON/AliMUONReconstructor.cxx index f840174d749..492e9a6432d 100644 --- a/MUON/AliMUONReconstructor.cxx +++ b/MUON/AliMUONReconstructor.cxx @@ -73,6 +73,7 @@ #include "AliMUONPreClusterFinder.h" #include "AliMUONTracker.h" #include "AliMUONVTrackStore.h" +#include "AliMUONTriggerChamberEff.h" #include "AliMUONTriggerCircuit.h" #include "AliMUONTriggerCrateStore.h" #include "AliMUONTriggerStoreV1.h" @@ -103,6 +104,7 @@ fClusterReconstructor(0x0), fClusterStore(0x0), fTriggerStore(0x0), fTrackStore(0x0), +fTrigChamberEff(0x0), fTimers(new AliMUONStopwatchGroup) { /// normal ctor @@ -124,6 +126,7 @@ AliMUONReconstructor::~AliMUONReconstructor() delete fClusterStore; delete fTriggerStore; delete fTrackStore; + delete fTrigChamberEff; AliInfo("Timers:"); fTimers->Print(); delete fTimers; @@ -250,6 +253,20 @@ AliMUONReconstructor::CreateTriggerCircuit() const fTriggerCircuit = new AliMUONTriggerCircuit(fTransformer); } + +//_____________________________________________________________________________ +void +AliMUONReconstructor::CreateTriggerChamberEff() const +{ + /// Create (and create if necessary) the trigger chamber efficiency class + if (fTrigChamberEff) return; + + AliMUONStopwatchGroupElement timer(fTimers,"MUON","AliMUONReconstructor::CreateTriggerChamberEff()"); + + fTrigChamberEff = new AliMUONTriggerChamberEff(fTransformer,fDigitMaker,kTRUE); + //fTrigChamberEff->SetDebugLevel(1); +} + //_____________________________________________________________________________ AliTracker* AliMUONReconstructor::CreateTracker(AliRunLoader* runLoader) const @@ -259,6 +276,7 @@ AliMUONReconstructor::CreateTracker(AliRunLoader* runLoader) const CreateTriggerCircuit(); CreateDigitMaker(); + CreateTriggerChamberEff(); AliLoader* loader = runLoader->GetDetectorLoader("MUON"); if (!loader) @@ -266,7 +284,7 @@ AliMUONReconstructor::CreateTracker(AliRunLoader* runLoader) const AliError("Cannot get MUONLoader, so cannot create MUONTracker"); return 0x0; } - AliMUONTracker* tracker = new AliMUONTracker(loader,fDigitMaker,fTransformer,fTriggerCircuit); + AliMUONTracker* tracker = new AliMUONTracker(loader,fDigitMaker,fTransformer,fTriggerCircuit,fTrigChamberEff); tracker->SetOption(GetOption()); return tracker; diff --git a/MUON/AliMUONReconstructor.h b/MUON/AliMUONReconstructor.h index 8e4536ef178..62b913c10be 100644 --- a/MUON/AliMUONReconstructor.h +++ b/MUON/AliMUONReconstructor.h @@ -36,6 +36,8 @@ class AliMUONVClusterStore; class AliMUONTracker; class AliMUONVTrackStore; +class AliMUONTriggerChamberEff; + class AliMUONStopwatchGroup; class AliMUONReconstructor : public AliReconstructor @@ -76,6 +78,7 @@ private: void CreateDigitMaker() const; void CreateTriggerCircuit() const; void CreateClusterReconstructor() const; + void CreateTriggerChamberEff() const; void FillTreeR(AliMUONVTriggerStore* triggerStore, AliMUONVClusterStore* clusterStore, TTree& clustersTree) const; @@ -96,6 +99,7 @@ private: mutable AliMUONVClusterStore* fClusterStore; //!< Cluster container mutable AliMUONVTriggerStore* fTriggerStore; //!< Trigger container mutable AliMUONVTrackStore* fTrackStore; //!< Track container + mutable AliMUONTriggerChamberEff* fTrigChamberEff; //!< pointer to trigger chamber efficiency class AliMUONStopwatchGroup* fTimers; //!< Internal timers ClassDef(AliMUONReconstructor,1) // Implementation of AliReconstructor diff --git a/MUON/AliMUONResponseTriggerV1.cxx b/MUON/AliMUONResponseTriggerV1.cxx index e8b0ffa9d65..094e9a7160c 100644 --- a/MUON/AliMUONResponseTriggerV1.cxx +++ b/MUON/AliMUONResponseTriggerV1.cxx @@ -158,8 +158,8 @@ void AliMUONResponseTriggerV1::DisIntegrate(const AliMUONHit& hit, TList& digits Int_t ix = pad.GetIndices().GetFirst(); Int_t iy = pad.GetIndices().GetSecond(); - AliMUONDigit* d = new AliMUONDigit(detElemId,pad.GetLocation().GetFirst(), - pad.GetLocation().GetSecond(), + AliMUONDigit* d = new AliMUONDigit(detElemId,pad.GetLocation(0).GetFirst(), + pad.GetLocation(0).GetSecond(), cath); d->SetPadXY(ix,iy); @@ -204,8 +204,8 @@ void AliMUONResponseTriggerV1::DisIntegrate(const AliMUONHit& hit, TList& digits else qp = 0; if (qp == 1) { // this digit is fired - AliMUONDigit* dNeigh = new AliMUONDigit(detElemId,padNeigh.GetLocation().GetFirst(), - padNeigh.GetLocation().GetSecond(), + AliMUONDigit* dNeigh = new AliMUONDigit(detElemId,padNeigh.GetLocation(0).GetFirst(), + padNeigh.GetLocation(0).GetSecond(), cath); dNeigh->SetPadXY(ixNeigh,iyNeigh); diff --git a/MUON/AliMUONTracker.cxx b/MUON/AliMUONTracker.cxx index 0ea93743c35..09dae3aa760 100644 --- a/MUON/AliMUONTracker.cxx +++ b/MUON/AliMUONTracker.cxx @@ -35,6 +35,7 @@ #include "AliMUONTrackReconstructor.h" #include "AliMUONTrackReconstructorK.h" #include "AliMUONTrackStoreV1.h" +#include "AliMUONTriggerChamberEff.h" #include "AliMUONTriggerTrackStoreV1.h" #include "AliMUONVClusterStore.h" #include "AliMUONVTriggerStore.h" @@ -46,12 +47,14 @@ AliMUONTracker::AliMUONTracker(AliLoader* loader, const AliMUONDigitMaker* digitMaker, const AliMUONGeometryTransformer* transformer, - const AliMUONTriggerCircuit* triggerCircuit) + const AliMUONTriggerCircuit* triggerCircuit, + AliMUONTriggerChamberEff* chamberEff) : AliTracker(), fLoader(loader), fDigitMaker(digitMaker), // not owner fTransformer(transformer), // not owner fTriggerCircuit(triggerCircuit), // not owner + fTrigChamberEff(chamberEff), // not owner fTrackHitPatternMaker(0x0), fTrackReco(0x0), fClusterStore(0x0), @@ -173,6 +176,12 @@ Int_t AliMUONTracker::Clusters2Tracks(TTree& tracksTree, AliESD* esd) // Fills output TreeT tracksTree.Fill(); + if( trackStore && triggerTrackStore && fTriggerStore && fTrigChamberEff){ + fTrigChamberEff->EventChamberEff(*fTriggerStore,*triggerTrackStore,*trackStore); + fTrigChamberEff->WriteEfficiencyMap("."); + fTrigChamberEff->WriteEfficiencyMapTxt("."); + } + FillESD(*trackStore,esd); // cleanup diff --git a/MUON/AliMUONTracker.h b/MUON/AliMUONTracker.h index 61ab7a3f1c9..0d9f835881e 100644 --- a/MUON/AliMUONTracker.h +++ b/MUON/AliMUONTracker.h @@ -18,6 +18,7 @@ class AliLoader; class AliMUONDigitMaker; class AliMUONGeometryTransformer; class AliMUONTrackHitPattern; +class AliMUONTriggerChamberEff; class AliMUONTriggerCircuit; class AliMUONVClusterStore; class AliMUONVTrackReconstructor; @@ -31,7 +32,8 @@ class AliMUONTracker : public AliTracker AliMUONTracker(AliLoader* loader, const AliMUONDigitMaker* digitMaker=0, const AliMUONGeometryTransformer* transformer=0, - const AliMUONTriggerCircuit* triggerCircuit=0); + const AliMUONTriggerCircuit* triggerCircuit=0, + AliMUONTriggerChamberEff* chamberEff=0); virtual ~AliMUONTracker(); /// Main entry point. @@ -67,6 +69,7 @@ private: const AliMUONDigitMaker* fDigitMaker; //!< digit maker (not owner) const AliMUONGeometryTransformer* fTransformer; //!< geometry transformer (not owner) const AliMUONTriggerCircuit* fTriggerCircuit; //!< trigger circuit (not owner) + AliMUONTriggerChamberEff* fTrigChamberEff; //!< trigger efficiency (not owner) AliMUONTrackHitPattern* fTrackHitPatternMaker; //!< trigger hit pattern maker AliMUONVTrackReconstructor* fTrackReco; //!< track reconstructor AliMUONVClusterStore* fClusterStore; //!< cluster container diff --git a/MUON/AliMUONTriggerChamberEff.cxx b/MUON/AliMUONTriggerChamberEff.cxx index 47f86161844..ed1647f0c85 100644 --- a/MUON/AliMUONTriggerChamberEff.cxx +++ b/MUON/AliMUONTriggerChamberEff.cxx @@ -25,130 +25,139 @@ #include "AliMUONTriggerChamberEff.h" #include "AliMUONVDigit.h" #include "AliMUONConstants.h" -#include "AliMUONGlobalTrigger.h" -#include "AliMUONGeometryTransformer.h" -#include "AliMUON.h" -#include "AliMUONRecData.h" #include "AliMUONTriggerTrack.h" +#include "AliMUONDigitMaker.h" +#include "AliMUONLocalTrigger.h" +#include "AliMUONGeometryTransformer.h" + +#include "AliMUONTrack.h" +#include "AliMUONTrackParam.h" +#include "AliMUONTrackExtrap.h" + +#include "AliMUONDigitStoreV1.h" +#include "AliMUONVDigitStore.h" +#include "AliMUONVTriggerStore.h" +#include "AliMUONVTriggerTrackStore.h" +#include "AliMUONVTrackStore.h" #include "AliMpVSegmentation.h" #include "AliMpSegmentation.h" #include "AliMpPad.h" #include "AliMpDEIterator.h" #include "AliMpPlaneType.h" +#include "AliMpDEManager.h" -#include "AliRunLoader.h" -#include "AliRun.h" +#include "AliLog.h" #include #include #include #include +#include +#include +#include + + /// \cond CLASSIMP ClassImp(AliMUONTriggerChamberEff) /// \endcond + //_____________________________________________________________________________ -AliMUONTriggerChamberEff::AliMUONTriggerChamberEff(const char* galiceFile, - Int_t firstEvent, Int_t lastEvent) +AliMUONTriggerChamberEff::AliMUONTriggerChamberEff() : TObject(), - fFirstEvent(firstEvent), - fLastEvent(lastEvent), - fFirstRun(-1), - fLastRun(-1), - fRunLoader(0x0), - fData(0x0), + fTransformer(0x0), + fDigitMaker(0x0), fReproduceTrigResponse(kFALSE), fPrintInfo(kFALSE), - fMUON(0x0), + fWriteOnESD(kFALSE), fDebugLevel(0), - fGaliceDir(0x0) + fkMaxDistance(99999.) { /// Standard constructor - SetGaliceFile(galiceFile); ResetArrays(); } + //_____________________________________________________________________________ -AliMUONTriggerChamberEff::AliMUONTriggerChamberEff(Int_t firstRun, Int_t lastRun, - const char* galiceRunDir, - Int_t firstEvent, Int_t lastEvent) +AliMUONTriggerChamberEff::AliMUONTriggerChamberEff(const AliMUONGeometryTransformer* transformer, + const AliMUONDigitMaker* digitMaker, + Bool_t writeOnESD) : TObject(), - fFirstEvent(firstEvent), - fLastEvent(lastEvent), - fFirstRun(firstRun), - fLastRun(lastRun), - fRunLoader(0x0), - fData(0x0), + fTransformer(transformer), + fDigitMaker(digitMaker), fReproduceTrigResponse(kFALSE), fPrintInfo(kFALSE), - fMUON(0x0), + fWriteOnESD(writeOnESD), fDebugLevel(0), - fGaliceDir(galiceRunDir) + fkMaxDistance(99999.) { /// Standard constructor ResetArrays(); } + //_____________________________________________________________________________ AliMUONTriggerChamberEff::~AliMUONTriggerChamberEff() { /// Destructor - fRunLoader->UnloadAll(); - delete fRunLoader; - delete fData; + Bool_t writeOnESD=fWriteOnESD; + fWriteOnESD=kFALSE; + if(writeOnESD) SaveInESDFile(); } + //_____________________________________________________________________________ -void AliMUONTriggerChamberEff::SetGaliceFile(const char *galiceFile) +AliMUONTriggerChamberEff::AliMUONTriggerChamberEff(const AliMUONTriggerChamberEff& other) + :TObject(other), + fTransformer(0x0), + fDigitMaker(0x0), + fReproduceTrigResponse(other.fReproduceTrigResponse), + fPrintInfo(other.fPrintInfo), + fWriteOnESD(other.fWriteOnESD), + fDebugLevel(other.fDebugLevel), + fkMaxDistance(other.fkMaxDistance) { - // - /// Opens the galice.root and loads tracks and digits. - // - - fRunLoader = AliRunLoader::Open(galiceFile,"MUONFolder","READ"); - if (!fRunLoader) - { - AliError(Form("Error opening %s file \n",galiceFile)); - } - else - { - fRunLoader->LoadgAlice(); - gAlice = fRunLoader->GetAliRun(); - fMUON = (AliMUON*)gAlice->GetModule("MUON"); - - if(fLastEvent<=0 || fLastEvent>fRunLoader->GetNumberOfEvents())fLastEvent = fRunLoader->GetNumberOfEvents()-1; - if(fFirstEvent<0)fFirstEvent=0; - - - AliLoader* loader = fRunLoader->GetLoader("MUONLoader"); - if ( loader ) - { - fData = new AliMUONRecData(loader,"MUON","MUON"); - loader->LoadTracks("READ"); - loader->LoadDigits("READ"); - } - else - { - AliError(Form("Could get MUONLoader")); + for(Int_t ch=0; chUnloadAll("all"); - delete fRunLoader; - fRunLoader = NULL; + /// Asignment operator + // check assignement to self + if (this == &other) + return *this; + + // base class assignement + TObject::operator=(other); + + fTransformer = 0x0; + fDigitMaker = 0x0; + fReproduceTrigResponse = other.fReproduceTrigResponse; + fPrintInfo = other.fPrintInfo; + fWriteOnESD = other.fWriteOnESD; + fDebugLevel = other.fDebugLevel; + //fkMaxDistance = other.fkMaxDistance; + return *this; } + //_____________________________________________________________________________ void AliMUONTriggerChamberEff::ResetArrays() { @@ -164,42 +173,65 @@ void AliMUONTriggerChamberEff::ResetArrays() fInefficientSlat[ch][cath][slat] = 0; fHitPerSlat[ch][cath][slat] = 0; } + for(Int_t board=0; board(next()) ) ) + { + if (locTrg->IsNull()) continue; + + TArrayS xyPattern[2]; + locTrg->GetXPattern(xyPattern[0]); + locTrg->GetYPattern(xyPattern[1]); + + Int_t nBoard = locTrg->LoCircuit(); + fDigitMaker->TriggerDigits(nBoard, xyPattern, digitStore); + } + return kTRUE; +} + + //_____________________________________________________________________________ -void AliMUONTriggerChamberEff::InfoDigit() +void AliMUONTriggerChamberEff::InfoDigit(AliMUONVDigitStore& digitStore) { // /// Prints information on digits (for debugging) // - - AliMUONDigit * mDigit=0x0; - Int_t firstTrigCh = AliMUONConstants::NTrackingCh(); - // Addressing - Int_t nchambers = AliMUONConstants::NCh(); - fData->SetTreeAddress("D,GLT"); + TIter next(digitStore.CreateIterator()); + AliMUONVDigit* mDigit=0x0; - fData->GetDigits(); - // Loop on chambers - for(Int_t ichamber=firstTrigCh; ichamberDigits(ichamber); - digits->Sort(); - Int_t ndigits = (Int_t)digits->GetEntriesFast(); - for(Int_t idigit=0; idigitAt(idigit); - mDigit->Print(); - } // end digit loop - } // end chamber loop - fData->ResetDigits(); - fData->ResetTrigger(); + while ( ( mDigit = static_cast(next()) ) ) + { + mDigit->Print(); + } // end digit loop + printf("\n"); } //_____________________________________________________________________________ -Int_t AliMUONTriggerChamberEff::MatchingPad(Int_t &detElemId, Float_t coor[2], const AliMUONGeometryTransformer *kGeomTransformer, Bool_t isMatch[fgkNcathodes], Int_t nboard[fgkNcathodes][4], Float_t zRealMatch[fgkNchambers], Float_t y11) +Int_t AliMUONTriggerChamberEff::MatchingPad(AliMUONVDigitStore& digitStore, Int_t &detElemId, + Float_t coor[2], Bool_t isMatch[fgkNcathodes], + Int_t nboard[fgkNcathodes][4], + Float_t zRealMatch[fgkNchambers], Float_t y11) { // /// Check slat and board number of digit matching track @@ -208,29 +240,36 @@ Int_t AliMUONTriggerChamberEff::MatchingPad(Int_t &detElemId, Float_t coor[2], c enum {kBending, kNonBending}; Float_t minMatchDist[fgkNcathodes]; + Int_t padsInCheckArea[fgkNcathodes]; for(Int_t cath=0; cathDigits(iChamber); - digits->Sort(); Int_t foundDetElemId = detElemId; Float_t foundZmatch=999.; Float_t yCoorAtPadZ=999.; - Int_t ndigits = (Int_t)digits->GetEntriesFast(); - AliMUONVDigit * mDigit = 0x0; - for(Int_t idigit=0; idigitAt(idigit); + + TIter next(digitStore.CreateIterator()); + AliMUONVDigit* mDigit; + Int_t idigit=0; + + while ( ( mDigit = static_cast(next()) ) ) + { + idigit++; Int_t currDetElemId = mDigit->DetElemId(); + Int_t currCh = AliMpDEManager::GetChamberId(currDetElemId); + if(currCh!=iChamber) continue; Int_t currSlat = currDetElemId%100; - if(TMath::Abs(currSlat%18-iSlat%18)>1)continue; // Check neighbour slats + Int_t slatDiff = TMath::Abs(currSlat-iSlat); + if(slatDiff>1 && slatDiff<17) continue; // Check neighbour slats Int_t cathode = mDigit->Cathode(); Int_t ix = mDigit->PadX(); Int_t iy = mDigit->PadY(); @@ -243,22 +282,24 @@ Int_t AliMUONTriggerChamberEff::MatchingPad(Int_t &detElemId, Float_t coor[2], c Float_t ylocal1 = pad.Position().Y(); Float_t dpx = pad.Dimensions().X(); Float_t dpy = pad.Dimensions().Y(); - kGeomTransformer->Local2Global(currDetElemId, xlocal1, ylocal1, 0, xpad, ypad, zpad); + fTransformer->Local2Global(currDetElemId, xlocal1, ylocal1, 0, xpad, ypad, zpad); if(fDebugLevel>2)printf("DetElemId = %i\tCathode = %i\t(x,y) Pad = (%i,%i) = (%.2f,%.2f)\tDim = (%.2f,%.2f)\tTrack = (%.2f,%.2f)\n",currDetElemId,cathode,ix,iy,xpad,ypad,dpx,dpy,coor[0],coor[1]); // searching track intersection with chambers (second approximation) if(ch%2==1){ + //if(iChamber%2==1){ Float_t deltaZ = zpad - zRealMatch[0]; y = (coor[1]-y11)*deltaZ/oldDeltaZ + y11; if(fDebugLevel>=3 && TMath::Abs(y-coor[1])>0.1)printf("oldDeltaZ = %7.2f newDeltaZ = %7.2f\toldY = %7.2f new y = %7.2f\n",oldDeltaZ,deltaZ,coor[1],y); } Float_t matchDist = PadMatchTrack(xpad, ypad, dpx, dpy, coor[0], y, ch); + if(matchDistminMatchDist[cathode])continue; isMatch[cathode] = kTRUE; minMatchDist[cathode] = matchDist; foundDetElemId = currDetElemId; foundZmatch=zpad; yCoorAtPadZ=y; - if(cathode==kBending)trigDigitBendPlane = idigit; + if(cathode==kBending) trigDigitBendPlane = idigit; for (Int_t loc=0; loc2) { + if(fDebugLevel>=1) printf("padsInCheckArea[%i] = %i\n",cath,padsInCheckArea[cath]); + return -500; + } + } + if(isMatch[kBending] || isMatch[kNonBending]){ detElemId = foundDetElemId; zRealMatch[ch] = foundZmatch; @@ -280,16 +329,19 @@ Int_t AliMUONTriggerChamberEff::MatchingPad(Int_t &detElemId, Float_t coor[2], c } //_____________________________________________________________________________ -Float_t AliMUONTriggerChamberEff::PadMatchTrack(Float_t xPad, Float_t yPad, Float_t dpx, Float_t dpy, - Float_t xTrackAtPad, Float_t yTrackAtPad, Int_t chamber) +Float_t AliMUONTriggerChamberEff::PadMatchTrack(Float_t xPad, Float_t yPad, + Float_t dpx, Float_t dpy, + Float_t xTrackAtPad, Float_t yTrackAtPad, + Int_t chamber) { // /// Decides if the digit belongs to the trigger track. // - Float_t maxDist = 3.;//cm + Float_t maxDist = 2.;//3. // cm + Float_t maxDistCheckArea = 6.; // cm - Float_t matchDist = 99999.; + Float_t matchDist = fkMaxDistance; Float_t deltaX = TMath::Abs(xPad-xTrackAtPad)-dpx; Float_t deltaY = TMath::Abs(yPad-yTrackAtPad)-dpy; @@ -305,14 +357,16 @@ Float_t AliMUONTriggerChamberEff::PadMatchTrack(Float_t xPad, Float_t yPad, Floa if(dpyGetGeometryTransformer(); Float_t minDist = 999.; for ( it.First(chamber-1); ! it.IsDone(); it.Next() ){ Int_t detElemId = it.CurrentDEId(); @@ -348,50 +402,52 @@ Int_t AliMUONTriggerChamberEff::DetElemIdFromPos(Float_t x, Float_t y, Int_t cha Float_t tolerance=0.2*((Float_t)ich); Float_t currDist=9999.; - const AliMpVSegmentation* seg = - AliMpSegmentation::Instance() - ->GetMpSegmentation(detElemId,AliMp::GetCathodType(cathode)); - if (seg){ - Float_t deltax = seg->Dimensions().X(); - Float_t deltay = seg->Dimensions().Y(); - Float_t xlocal1 = -deltax; - Float_t ylocal1 = -deltay; - Float_t xlocal2 = +deltax; - Float_t ylocal2 = +deltay; - Float_t xg01, yg01, zg1, xg02, yg02, zg2; - kGeomTransformer->Local2Global(detElemId, xlocal1, ylocal1, 0, xg01, yg01, zg1); - kGeomTransformer->Local2Global(detElemId, xlocal2, ylocal2, 0, xg02, yg02, zg2); - - Float_t xg1 = xg01, xg2 = xg02, yg1 = yg01, yg2 = yg02; - - if(xg01>xg02){ - xg1 = xg02; - xg2 = xg01; - } - if(yg01>yg02){ - yg1 = yg02; - yg2 = yg01; - } + const AliMpVSegmentation* seg = + AliMpSegmentation::Instance() + ->GetMpSegmentation(detElemId,AliMp::GetCathodType(cathode)); + if (!seg) continue; + + Float_t deltax = seg->Dimensions().X(); + Float_t deltay = seg->Dimensions().Y(); + Float_t xlocal1 = -deltax; + Float_t ylocal1 = -deltay; + Float_t xlocal2 = +deltax; + Float_t ylocal2 = +deltay; + Float_t xg01, yg01, zg1, xg02, yg02, zg2; + fTransformer->Local2Global(detElemId, xlocal1, ylocal1, 0, xg01, yg01, zg1); + fTransformer->Local2Global(detElemId, xlocal2, ylocal2, 0, xg02, yg02, zg2); + + Float_t xg1 = xg01, xg2 = xg02, yg1 = yg01, yg2 = yg02; + + if(xg01>xg02){ + xg1 = xg02; + xg2 = xg01; + } + if(yg01>yg02){ + yg1 = yg02; + yg2 = yg01; + } - if(x>=xg1-tolerance && x<=xg2+tolerance && y>=yg1-tolerance && y<=yg2+tolerance){ // takes into account errors in extrapolation - if(yyg2) currDist = y-yg2; - if(currDist=xg1-tolerance && x<=xg2+tolerance && y>=yg1-tolerance && y<=yg2+tolerance){ // takes into account errors in extrapolation + if(yyg2) currDist = y-yg2; + if(currDistGetGeometryTransformer(); Float_t xl, yl, zl; - kGeomTransformer->Global2Local(detElemId, x, y, 0, xl, yl, zl); + fTransformer->Global2Local(detElemId, x, y, 0, xl, yl, zl); TVector2 pos(xl,yl); const AliMpVSegmentation* seg = AliMpSegmentation::Instance() @@ -419,34 +474,9 @@ void AliMUONTriggerChamberEff::LocalBoardFromPos(Float_t x, Float_t y, Int_t det //_____________________________________________________________________________ -void AliMUONTriggerChamberEff::PrintTrigger(AliMUONGlobalTrigger *globalTrig) -{ - // - /// Print trigger response. - // - - printf("===================================================\n"); - printf(" Global Trigger output\t \tLow pt\tHigh pt\n"); - - printf(" number of Single:\t \t"); - printf("%i\t",globalTrig->SingleLpt()); - printf("%i\t",globalTrig->SingleHpt()); - printf("\n"); - - printf(" number of UnlikeSign pair:\t"); - printf("%i\t",globalTrig->PairUnlikeLpt()); - printf("%i\t",globalTrig->PairUnlikeHpt()); - printf("\n"); - - printf(" number of LikeSign pair:\t"); - printf("%i\t",globalTrig->PairLikeLpt()); - printf("%i\t",globalTrig->PairLikeHpt()); - printf("\n"); - printf("===================================================\n"); - printf("\n"); -} - -void AliMUONTriggerChamberEff::PerformTriggerChamberEff(const char* outputDir) +void AliMUONTriggerChamberEff::EventChamberEff(const AliMUONVTriggerStore& triggerStore, + const AliMUONVTriggerTrackStore& trigTrackStore, + const AliMUONVTrackStore& trackStore) { // /// Main method. @@ -456,8 +486,12 @@ void AliMUONTriggerChamberEff::PerformTriggerChamberEff(const char* outputDir) /// Files with calculated efficiency are placed in the user defined outputDir. // + if(!fTransformer || ! fDigitMaker) { + AliError(Form("AliMUONGeometryTransformer or AliMUONDigitMaker not properly initialized!!")); + return; + } + enum {kBending, kNonBending}; - Int_t evtBeforePrint = 1000; Float_t rad2deg = 180./TMath::Pi(); Int_t chOrder[fgkNchambers] = {0,2,1,3}; @@ -467,20 +501,12 @@ void AliMUONTriggerChamberEff::PerformTriggerChamberEff(const char* outputDir) Bool_t match[fgkNchambers][fgkNcathodes] = {{kFALSE}}; Bool_t matchPad[fgkNcathodes]={kFALSE}; - TClonesArray *recTrigTracksArray = 0x0; - AliMUONTriggerTrack *recTrigTrack = 0x0; Float_t zMeanChamber[fgkNchambers]; for(Int_t ch=0; ch=0){ - cout<<"\n\nRun = "<GetPathInfo(filename,fs)){ - cout<<"Warning: "<(next()) ) ) + { + for(Int_t cath=0; cathGetEvent(ievent); - if (ievent%evtBeforePrint==0) printf("\t Event = %d\n",ievent); - - fData->ResetDigits(); - fData->ResetTrigger(); - fData->ResetRecTriggerTracks(); - fData->ResetRecTracks(); + Bool_t isClearEvent = kTRUE; + Bool_t doubleCountTrack = kFALSE; - fData->SetTreeAddress("RL,RT"); - fData->GetRecTriggerTracks(); - recTrigTracksArray = fData->RecTriggerTracks(); - Int_t nRecTrigTracks = (Int_t) recTrigTracksArray->GetEntriesFast(); + if(!IsCleanTrack(recTrigTrack, trackStore)) { + if(fDebugLevel>=1) printf("\tTrack %p (%f, %f) don't match tracker track: rejected!\n",recTrigTrack,recTrigTrack->GetX11(),recTrigTrack->GetY11()); + continue; + } - fData->SetTreeAddress("D,GLT"); - fData->GetDigits(); + Float_t x11 = recTrigTrack->GetX11();// x position (info from non-bending plane) + Float_t y11 = recTrigTrack->GetY11();// y position (info from bending plane) + Float_t thetaX = recTrigTrack->GetThetax(); + Float_t thetaY = recTrigTrack->GetThetay(); - const AliMUONGeometryTransformer* kGeomTransformer = fMUON->GetGeometryTransformer(); + if(fDebugLevel>=3) printf("\tTrack = %p\npos from track: (x,y) = (%f, %f), (thetaX, thetaY) = (%f, %f)\n",recTrigTrack,x11,y11,thetaX*rad2deg,thetaY*rad2deg); - for (Int_t iRecTrigTrack=0; iRecTrigTrackAt(iRecTrigTrack); - Float_t x11 = recTrigTrack->GetX11();// x position (info from non-bending plane) - Float_t y11 = recTrigTrack->GetY11();// y position (info from bending plane) - Float_t thetaX = recTrigTrack->GetThetax(); - Float_t thetaY = recTrigTrack->GetThetay(); - - if(fDebugLevel>=3)printf("\tEvent = %i, Track = %i\npos from track: (x,y) = (%f, %f), (thetaX, thetaY) = (%f, %f)\n",ievent,iRecTrigTrack,x11,y11,thetaX*rad2deg,thetaY*rad2deg); + for(Int_t ch=0; ch=2) + printf("zMeanChamber[%i] = %.2f\tzRealMatch[0] = %.2f\n",currCh,zMeanChamber[currCh],zRealMatch[0]); - for(Int_t ch=0; ch=1)correctFactor[kNonBending] = zMeanChamber[0]/zRealMatch[0];// corrects x position + if(ch>=2)correctFactor[kBending] = (zMeanChamber[2] - zMeanChamber[0]) / (zRealMatch[2] - zRealMatch[0]);// corrects y position + + // searching track intersection with chambers (first approximation) + Float_t deltaZ = zMeanChamber[currCh] - zMeanChamber[0]; + trackIntersectCh[currCh][0] = zMeanChamber[currCh] * TMath::Tan(thetaX) * correctFactor[kNonBending];// x position (info from non-bending plane) + trackIntersectCh[currCh][1] = y11 + deltaZ * TMath::Tan(thetaY) * correctFactor[kBending];// y position (info from bending plane) + Int_t detElemIdFromTrack = DetElemIdFromPos(trackIntersectCh[currCh][0], trackIntersectCh[currCh][1], 11+currCh, 0); + if(detElemIdFromTrack<0) { + if(fDebugLevel>1) printf("Warning: trigger track outside trigger chamber\n"); + continue; } - - for(Int_t ch=0; ch=2){ - if(fDebugLevel<3)printf("\tEvent = %i, Track = %i\n", ievent, iRecTrigTrack); - printf("zMeanChamber[%i] = %.2f\tzRealMatch[0] = %.2f\n",currCh,zMeanChamber[currCh],zRealMatch[0]); - } - - for(Int_t cath=0; cath=1)correctFactor[kNonBending] = zMeanChamber[0]/zRealMatch[0];// corrects x position - if(ch>=2)correctFactor[kBending] = (zMeanChamber[2] - zMeanChamber[0]) / (zRealMatch[2] - zRealMatch[0]);// corrects y position - - // searching track intersection with chambers (first approximation) - Float_t deltaZ = zMeanChamber[currCh] - zMeanChamber[0]; - trackIntersectCh[currCh][0] = zMeanChamber[currCh] * TMath::Tan(thetaX) * correctFactor[kNonBending];// x position (info from non-bending plane) - trackIntersectCh[currCh][1] = y11 + deltaZ * TMath::Tan(thetaY) * correctFactor[kBending];// y position (info from bending plane) - Int_t detElemIdFromTrack = DetElemIdFromPos(trackIntersectCh[currCh][0], trackIntersectCh[currCh][1], 11+currCh, 0); - if(detElemIdFromTrack<0) { - if(fDebugLevel>1) printf("Warning: trigger track outside trigger chamber\n"); - continue; - } - triggeredDigits[1][currCh] = MatchingPad(detElemIdFromTrack, trackIntersectCh[currCh], kGeomTransformer, matchPad, nboard, zRealMatch, y11); - - // deciding if digit matches track - Bool_t isDiffLocBoard = kFALSE; - if(fReproduceTrigResponse && ch>2){ - for(Int_t cath=0; cath=0){ - if(boardThatTriggered[currCh][cath][0]!=boardThatTriggered[currCh-1][cath][0]) isDiffLocBoard = kTRUE; - } - } - } - - if(isDiffLocBoard && fDebugLevel>=1)printf("\tDifferent local board\n"); + triggeredDigits[1][currCh] = MatchingPad(digitStore, detElemIdFromTrack, trackIntersectCh[currCh], matchPad, nboard, zRealMatch, y11); + + // if MatchingPad = -500 => too many digits matching pad => + // => Event not clear => Reject track + if(triggeredDigits[1][currCh]<-100){ + isClearEvent = kFALSE; + if(fDebugLevel>=1) printf("Warning: track = %p (%i) matches many pads. Rejected!\n",recTrigTrack, detElemIdFromTrack); + break; + } + // deciding if digit matches track + Bool_t isDiffLocBoard = kFALSE; + if(fReproduceTrigResponse && ch>2){ for(Int_t cath=0; cath=0){ + if(boardThatTriggered[currCh][cath][0]!=boardThatTriggered[currCh-1][cath][0]) isDiffLocBoard = kTRUE; } } - } // end chamber loop + } + + if(isDiffLocBoard && fDebugLevel>=1)printf("\tDifferent local board\n"); for(Int_t cath=0; cath=1 && !isClearEvent)printf("Warning: found %i digits for trigger track cathode %i.\nRejecting event\n", digitPerTrack[cath],cath); + match[currCh][cath] = (matchPad[cath] && !isDiffLocBoard); + if(!match[currCh][cath]) continue; + digitPerTrack[cath]++; + trigScheme[currCh][cath]++; + slatThatTriggered[currCh][cath] = detElemIdFromTrack; + for(Int_t loc=0; loc<4; loc++){ + boardThatTriggered[currCh][cath][loc] = nboard[cath][loc]; + } } + } // end chamber loop - if(!isClearEvent && !fReproduceTrigResponse) continue; + for(Int_t cath=0; cath=1 && !isClearEvent)printf("Warning: found %i digits for trigger track cathode %i.\nRejecting event\n", digitPerTrack[cath],cath); + } - Int_t commonDigits = 0; - for(Int_t ch=0; ch=2){ - doubleCountTrack=kTRUE; - } + if(!isClearEvent && !fReproduceTrigResponse) continue; - if(!doubleCountTrack || fReproduceTrigResponse){ - for(Int_t cath=0; cath=2){ + doubleCountTrack=kTRUE; + } - // Trigger 4/4 - if(is44==1){ - fTrigger44[cath]++; - if(fDebugLevel>=1)printf("Trigger44[%i] = %i\n",cath,fTrigger44[cath]); - if(goodForSlatEff){ - for(Int_t ch=0; ch=1)printf("Slat that triggered = %i\n",slatThatTriggered[ch][cath]); - if(goodForBoardEff && firstBoard>0){ - fHitPerBoard[ch][cath][firstBoard-1]++; - if(fDebugLevel>=1)printf("Board that triggered = %i\n",firstBoard); - } - else if(fDebugLevel>=1)printf("Event = %i, Track = %i: Particle crossed different boards: rejected!\n",ievent,iRecTrigTrack); - } + if(!doubleCountTrack || fReproduceTrigResponse){ + for(Int_t cath=0; cath0){ - Int_t ineffCh = ineffDetElId/100-11; - fTrigger34[ineffCh][cath]++; - if(fDebugLevel>=1) printf("Trigger34[%i][%i] = %i\n",ineffCh,cath,fTrigger34[ineffCh][cath]); - if(goodForSlatEff){ - if(fDebugLevel>=1) printf("Slat non efficient = %i\n",ineffDetElId); - fInefficientSlat[ineffCh][cath][ineffSlat]++; - + if(!atLeastOneLoc)goodForBoardEff=kFALSE; + } // end chamber loop + + // Trigger 4/4 + if(is44==1){ + fTrigger44[cath]++; + if(fDebugLevel>=1)printf("Trigger44[%i] = %i\n",cath,fTrigger44[cath]); + if(goodForSlatEff){ + for(Int_t ch=0; ch=1)printf("Slat that triggered = %i\n",slatThatTriggered[ch][cath]); if(goodForBoardEff && firstBoard>0){ - if(fDebugLevel>=1) printf("Board non efficient = %i\n",firstBoard); - fInefficientBoard[ineffCh][cath][firstBoard-1]++; + fHitPerBoard[ch][cath][firstBoard-1]++; + if(fDebugLevel>=1)printf("Board that triggered = %i\n",firstBoard); } - else if(fDebugLevel>=1) printf("Event = %i, Track = %i: Particle crossed different boards: rejected!\n",ievent,iRecTrigTrack); + else if(fDebugLevel>=1) printf("Track = %p: Particle crossed different boards: rejected!\n",recTrigTrack); } - else printf("Event %i, Track = %i: Particle crossed different slats: rejected!\n",ievent,iRecTrigTrack); } - } // end loop on cathodes - } - else if(doubleCountTrack){ - if(fDebugLevel<=1)printf("\n\tEvent = %i, Track = %i: ", ievent,iRecTrigTrack); - printf("Double Count Track: %i similar to %i. Track rejected!\n",iRecTrigTrack, iRecTrigTrack-1); - } - } // end trigger tracks loop - if(nRecTrigTracks<=0) continue; + else if(fDebugLevel>=1) printf("Track = %p: Particle crossed different slats: rejected!\n",recTrigTrack); + //cout<<"fTrigger44["<=1) printf("Slat non efficient = %i\n",ineffDetElId); + fInefficientSlat[ineffCh][cath][ineffSlat]++; + + if(goodForBoardEff && firstBoard>0){ + if(fDebugLevel>=1) printf("Board non efficient = %i\n",firstBoard); + fInefficientBoard[ineffCh][cath][firstBoard-1]++; + } + else if(fDebugLevel>=1) printf("Track = %p: Particle crossed different boards: rejected!\n",recTrigTrack); + } + else if(fDebugLevel>=1) printf("Track = %p: Particle crossed different slats: rejected!\n",recTrigTrack); + //cout<<"fTrigger34["<=1) + printf("\n\tTrack = %p: \nDouble Count Track: Track rejected!\n",recTrigTrack); } - }// end event loop - if(fFirstRun>=0)CleanGalice(); - } //end loop over run - - // Write output data - WriteEfficiencyMap(outputDir); + } // end trigger tracks loop - WriteOutput(outputDir, totNumOfTrig, atLeast1MuPerEv); + if(fPrintInfo) InfoDigit(digitStore); } //_____________________________________________________________________________ -void AliMUONTriggerChamberEff::WriteOutput(const char* outputDir, Int_t totNumOfTrig[4][2], Int_t atLeast1MuPerEv[4][2]) +void AliMUONTriggerChamberEff::WriteEfficiencyMap(const char* outputDir) { // /// Writes information on calculated efficiency. /// It writes: triggerChamberEff.root file containing efficiency histograms. - /// - /// In addition a text file triggerChamberEff.out is created, - /// with further informations on efficiencies. // - char *cathodeName[fgkNcathodes]={"Bending plane", "Non-Bending plane"}; char *cathCode[fgkNcathodes] = {"bendPlane", "nonBendPlane"}; char outFileName[100]; - sprintf(outFileName, "%s/triggerChamberEff.out",outputDir); - FILE *outfile = fopen(outFileName, "w"); - for(Int_t cath=0; cathSetXTitle("boards"); histoBoard[cath][ch]->SetYTitle(yAxisTitle); histoBoard[cath][ch]->GetXaxis()->SetNdivisions(fgkNboards); + + // ADDED for check + for(Int_t hType=0; hTypeSetXTitle("slat"); + histoCheckSlat[cath][ch][hType]->SetYTitle(yAxisTitle); + histoCheckSlat[cath][ch][hType]->GetXaxis()->SetNdivisions(fgkNslats); + + sprintf(histoName, "%sBoard%s%i", cathCode[cath], histoTypeName[hType], 11+ch); + sprintf(histoTitle, "Chamber %i: board %s %s", 11+ch, histoTypeTitle[hType], cathCode[cath]); + histoCheckBoard[cath][ch][hType] = new TH1F(histoName, histoTitle, fgkNboards, 1-0.5, fgkNboards+1.-0.5); + histoCheckBoard[cath][ch][hType]->SetXTitle("boards"); + histoCheckBoard[cath][ch][hType]->SetYTitle(yAxisTitle); + histoCheckBoard[cath][ch][hType]->GetXaxis()->SetNdivisions(fgkNboards); + } + // end ADDED for check } } } Float_t efficiency, efficiencyError; + Int_t bin; for(Int_t cath=0; cathSetBinContent(slat+1, efficiency); - histo[cath][ch]->SetBinError(slat+1, efficiencyError); + bin = histo[cath][ch]->FindBin(slat); + histo[cath][ch]->SetBinContent(bin, efficiency); + histo[cath][ch]->SetBinError(bin, efficiencyError); + + // ADDED for check + histoCheckSlat[cath][ch][allChEff]->SetBinContent(bin, fHitPerSlat[ch][cath][slat]); + histoCheckSlat[cath][ch][chNonEff]->SetBinContent(bin, fInefficientSlat[ch][cath][slat]); } CalculateEfficiency(fTrigger44[cath], fTrigger34[ch][cath]+fTrigger44[cath], efficiency, efficiencyError, kFALSE); - histo[cath][kChamberEff]->SetBinContent(ch+1, efficiency); - histo[cath][kChamberEff]->SetBinError(ch+1, efficiencyError); + bin = histo[cath][ch]->FindBin(11+ch); + histo[cath][kChamberEff]->SetBinContent(bin, efficiency); + histo[cath][kChamberEff]->SetBinError(bin, efficiencyError); for(Int_t board=0; boardSetBinContent(board+1, efficiency); - histoBoard[cath][ch]->SetBinError(board+1, efficiencyError); + bin = histoBoard[cath][ch]->FindBin(board+1); + histoBoard[cath][ch]->SetBinContent(bin, efficiency); + histoBoard[cath][ch]->SetBinError(bin, efficiencyError); + + // ADDED for check + histoCheckBoard[cath][ch][allChEff]->SetBinContent(bin, fHitPerBoard[ch][cath][board]); + histoCheckBoard[cath][ch][chNonEff]->SetBinContent(bin, fInefficientBoard[ch][cath][board]); } } } @@ -887,7 +845,7 @@ void AliMUONTriggerChamberEff::WriteOutput(const char* outputDir, Int_t totNumOf //_____________________________________________________________________________ -void AliMUONTriggerChamberEff::WriteEfficiencyMap(const char* outputDir) +void AliMUONTriggerChamberEff::WriteEfficiencyMapTxt(const char* outputDir) { // /// Writes the calculated efficiency in the text file efficiencyCells.dat @@ -927,3 +885,70 @@ void AliMUONTriggerChamberEff::WriteEfficiencyMap(const char* outputDir) }// loop on chambers } + +//_____________________________________________________________________________ +Bool_t AliMUONTriggerChamberEff::IsCleanTrack(AliMUONTriggerTrack *triggerTrack, + const AliMUONVTrackStore& trackStore) +{ + // + /// Try to match track from tracking system with trigger track + // + const Double_t kDistSigma[3]={1,1,0.02}; // sigma of distributions (trigger-track) X,Y,slopeY + const Double_t kMaxChi2MatchTrigger = 16.0; + + AliMUONTrackParam trackParam; + + Double_t distTriggerTrack[3]; + Double_t xTrack, yTrack, ySlopeTrack, chi2; + + AliMUONTrack* track; + TIter next(trackStore.CreateIterator()); + + while ( ( track = static_cast(next()) ) ) + { + trackParam = *((AliMUONTrackParam*) (track->GetTrackParamAtHit()->Last())); + AliMUONTrackExtrap::ExtrapToZ(&trackParam, AliMUONConstants::DefaultChamberZ(10)); // extrap to 1st trigger chamber + + xTrack = trackParam.GetNonBendingCoor(); + yTrack = trackParam.GetBendingCoor(); + ySlopeTrack = trackParam.GetBendingSlope(); + + distTriggerTrack[0] = (triggerTrack->GetX11()-xTrack)/kDistSigma[0]; + distTriggerTrack[1] = (triggerTrack->GetY11()-yTrack)/kDistSigma[1]; + distTriggerTrack[2] = (TMath::Tan(triggerTrack->GetThetay())-ySlopeTrack)/kDistSigma[2]; + chi2 = 0.; + for (Int_t iVar = 0; iVar < 3; iVar++) chi2 += distTriggerTrack[iVar]*distTriggerTrack[iVar]; + chi2 /= 3.; // Normalized Chi2: 3 degrees of freedom (X,Y,slopeY) + if (chi2 < kMaxChi2MatchTrigger) return kTRUE; + } + + return kFALSE; +} + + +//_____________________________________________________________________________ +void AliMUONTriggerChamberEff::SaveInESDFile() +{ + // + /// Store AliMUONTriggerChamberEff in esd file + // + TDirectory *dir = gDirectory; + TFile *logFile = 0x0; + TSeqCollection *list = gROOT->GetListOfFiles(); + Int_t n = list->GetEntries(); + for(Int_t i=0; iAt(i); + if (strstr(logFile->GetName(), "AliESDs.root")) break; + } + if(logFile){ + TTree *esdTree = (TTree*)logFile->Get("esdTree"); + if(esdTree){ + if(!esdTree->GetUserInfo()->FindObject("AliMUONTriggerChamberEff")){ + AliInfo(Form("Adding AliMUONTrigChamberEff in %s",logFile->GetName())); + esdTree->GetUserInfo()->Add(this->Clone()); + esdTree->Write("",TObject::kOverwrite); + } + } + } + dir->cd(); +} diff --git a/MUON/AliMUONTriggerChamberEff.h b/MUON/AliMUONTriggerChamberEff.h index a445adb5d25..e194d84b531 100644 --- a/MUON/AliMUONTriggerChamberEff.h +++ b/MUON/AliMUONTriggerChamberEff.h @@ -10,22 +10,30 @@ // Author Diego Stocco #include -#include -#include "AliMUONGeometryTransformer.h" +#include -class AliRunLoader; -class AliMUONRecData; -class AliMUON; -class AliMUONGlobalTrigger; -class TString; +class AliMUONGeometryTransformer; +class AliMUONDigitMaker; +class AliMUONTriggerTrack; +class AliMUONVDigitStore; +class AliMUONVTriggerStore; +class AliMUONVTriggerTrackStore; +class AliMUONVTrackStore; +class TClonesArray; class AliMUONTriggerChamberEff : public TObject { public: - AliMUONTriggerChamberEff(const char* galiceFile, Int_t firstEvent=0, Int_t lastEvent=-1); - AliMUONTriggerChamberEff(Int_t firstRun, Int_t lastRun, const char* galiceRunDir, Int_t firstEvent=0, Int_t lastEvent=-1); + AliMUONTriggerChamberEff(); + AliMUONTriggerChamberEff(const AliMUONGeometryTransformer* transformer, + const AliMUONDigitMaker* digitMaker, + Bool_t writeOnESD=kFALSE); + virtual ~AliMUONTriggerChamberEff(); + AliMUONTriggerChamberEff(const AliMUONTriggerChamberEff& other); // copy constructor + AliMUONTriggerChamberEff& operator=(const AliMUONTriggerChamberEff& other); // assignment operator + /// Set Reproduce trigger response void SetReproduceTrigResponse(Bool_t reproduceTrigRes=kFALSE) {fReproduceTrigResponse=reproduceTrigRes;} @@ -36,58 +44,61 @@ public: void SetDebugLevel(Int_t debugLevel) {fDebugLevel=debugLevel;} - void PerformTriggerChamberEff(const char* outputDir); + void EventChamberEff(const AliMUONVTriggerStore& triggerStore, + const AliMUONVTriggerTrackStore& trigTrackStore, + const AliMUONVTrackStore& trackStore); + void WriteEfficiencyMap(const char* outputDir); + void WriteEfficiencyMapTxt(const char* outputDir); private: - /// Not implemented + /* + /// Not implemented AliMUONTriggerChamberEff(const AliMUONTriggerChamberEff& other); /// Not implemented AliMUONTriggerChamberEff& operator=(const AliMUONTriggerChamberEff& other); + */ - void SetGaliceFile(const char* galiceFile); - void CleanGalice(); + static const Int_t fgkNchambers=4; ///< Number of trigger chambers + static const Int_t fgkNcathodes=2; ///< Number of cathodes per chamber + static const Int_t fgkNslats=18; ///< Number of slats per chamber + static const Int_t fgkNboards=234; ///< Number of trigger boards per chamber + + Int_t fTrigger34[fgkNchambers][fgkNcathodes]; //< Array counting # of times chamber was inefficient + Int_t fTrigger44[fgkNcathodes]; //< Array counting # of times all chambers were efficient + Int_t fInefficientSlat[fgkNchambers][fgkNcathodes][fgkNslats]; //< Array counting # of times slats were inefficient + Int_t fHitPerSlat[fgkNchambers][fgkNcathodes][fgkNslats]; //< Array counting # of times slats were efficient + Int_t fInefficientBoard[fgkNchambers][fgkNcathodes][fgkNboards]; //< Array counting # of times boards were inefficient + Int_t fHitPerBoard[fgkNchambers][fgkNcathodes][fgkNboards]; //< Array counting # of times boards were efficient - Int_t fFirstEvent; //!< First event to consider - Int_t fLastEvent; //!< Last event to consider - Int_t fFirstRun; //!< First run to consider - Int_t fLastRun; //!< Last run to consider - AliRunLoader* fRunLoader; //!< AliRunLoader pointer - AliMUONRecData* fData; //!< AliMUONData pointer (to access containers) - Bool_t fReproduceTrigResponse;//!< Reproduce trigger response - Bool_t fPrintInfo;//!< Print informations on event - AliMUON *fMUON; //!< AliMUON pointer + const AliMUONGeometryTransformer* fTransformer; //!< geometry transformer + const AliMUONDigitMaker* fDigitMaker; //!< pointer to digit maker + Bool_t fReproduceTrigResponse; //!< Reproduce trigger response + Bool_t fPrintInfo; //!< Print informations on event + Int_t fWriteOnESD; //!< flag to write on ESD Int_t fDebugLevel; //!< Debug level - TString fGaliceDir; //!< base directory for many runs. - - static const Int_t fgkNchambers=4; //!< Number of trigger chambers - static const Int_t fgkNcathodes=2; //!< Number of cathodes per chamber - static const Int_t fgkNslats=18; //!< Number of slats per chamber - static const Int_t fgkNboards=234; //!< Number of trigger boards per chamber - - Int_t fTrigger34[fgkNchambers][fgkNcathodes];//!< Array counting # of times chamber was inefficient - Int_t fTrigger44[fgkNcathodes];//!< Array counting # of times all chambers were efficient - Int_t fInefficientSlat[fgkNchambers][fgkNcathodes][fgkNslats];//!< Array counting # of times slats were inefficient - Int_t fHitPerSlat[fgkNchambers][fgkNcathodes][fgkNslats];//!< Array counting # of times slats were efficient - Int_t fInefficientBoard[fgkNchambers][fgkNcathodes][fgkNboards];//!< Array counting # of times boards were inefficient - Int_t fHitPerBoard[fgkNchambers][fgkNcathodes][fgkNboards];//!< Array counting # of times boards were efficient + const Float_t fkMaxDistance; //!< Maximum distance for reference protected: - Int_t MatchingPad(Int_t &detElemId, Float_t coor[2], const AliMUONGeometryTransformer *kGeomTransformer, - Bool_t isMatch[fgkNcathodes], Int_t nboard[fgkNcathodes][4], Float_t zRealMatch[fgkNchambers], Float_t y11); + Int_t MatchingPad(AliMUONVDigitStore& digitStore, Int_t &detElemId, Float_t coor[2], + Bool_t isMatch[fgkNcathodes], Int_t nboard[fgkNcathodes][4], + Float_t zRealMatch[fgkNchambers], Float_t y11); Float_t PadMatchTrack(Float_t xPad, Float_t yPad, Float_t dpx, Float_t dpy, - Float_t xTrackAtPad, Float_t yTrackAtPad, Int_t chamber); - void PrintTrigger(AliMUONGlobalTrigger *globalTrig); - void InfoDigit(); - void CalculateEfficiency(Int_t trigger44, Int_t trigger34, Float_t &efficiency, Float_t &error, Bool_t failuresAsInput); + Float_t xTrackAtPad, Float_t yTrackAtPad, Int_t chamber); + void InfoDigit(AliMUONVDigitStore& digitStore); + void CalculateEfficiency(Int_t trigger44, Int_t trigger34, Float_t &efficiency, + Float_t &error, Bool_t failuresAsInput); Int_t DetElemIdFromPos(Float_t x, Float_t y, Int_t chamber, Int_t cathode); - void LocalBoardFromPos(Float_t x, Float_t y, Int_t detElemId, Int_t cathode, Int_t localBoard[4]); + void LocalBoardFromPos(Float_t x, Float_t y, Int_t detElemId, + Int_t cathode, Int_t localBoard[4]); void ResetArrays(); - void WriteOutput(const char* outputDir, Int_t totNumOfTrig[4][2], Int_t atLeast1MuPerEv[4][2]); - void WriteEfficiencyMap(const char* outputDir); - + Bool_t TriggerDigits(const AliMUONVTriggerStore& triggerStore, + AliMUONVDigitStore& digitStore) const; + Bool_t IsCleanTrack(AliMUONTriggerTrack *triggerTrack, + const AliMUONVTrackStore& trackStore); + void SaveInESDFile(); - ClassDef(AliMUONTriggerChamberEff,0) // Dumper of MUON related data + ClassDef(AliMUONTriggerChamberEff,1) // Trigger chamber efficiency }; #endif diff --git a/MUON/AliMUONTriggerEfficiencyCells.cxx b/MUON/AliMUONTriggerEfficiencyCells.cxx index 470cdaab04f..fcf474edbbf 100755 --- a/MUON/AliMUONTriggerEfficiencyCells.cxx +++ b/MUON/AliMUONTriggerEfficiencyCells.cxx @@ -17,6 +17,8 @@ #include #include "Riostream.h" #include "TSystem.h" +#include "TFile.h" +#include "TH1F.h" #include "AliMUONTriggerEfficiencyCells.h" #include "AliMpConstants.h" @@ -119,8 +121,8 @@ void AliMUONTriggerEfficiencyCells::GetCellEfficiency(Int_t detElemId, Int_t loc /// Get the efficiencies of the 2 cathodes at a given local board Int_t chamber = FindChamberIndex(detElemId); - eff1 = fBoardContent[chamber][0][localBoard]; - eff2 = fBoardContent[chamber][1][localBoard]; + eff1 = fBoardContent[chamber][0][localBoard-1]; + eff2 = fBoardContent[chamber][1][localBoard-1]; } @@ -179,15 +181,20 @@ void AliMUONTriggerEfficiencyCells::ReadFile(const char* filename) /// Reads a file containing the efficiency map. TString fileName = gSystem->ExpandPathName(filename); + if(fileName.EndsWith(".root")){ + ReadHistoBoards(fileName.Data()); + return; + } + ifstream file(fileName.Data()); char dat[50]; if (file.good()){ file >> dat; if(!strcmp(dat,"localBoards"))ReadFileBoards(file); else ReadFileXY(file); - file.close(); + file.close(); } else { - AliWarning(Form("Can't read file %s",fileName.Data())); + AliWarning(Form("Can't read file %s",fileName.Data())); } } @@ -251,6 +258,35 @@ void AliMUONTriggerEfficiencyCells::ReadFileBoards(ifstream &file) } } + +//__________________________________________________________________________ +void AliMUONTriggerEfficiencyCells::ReadHistoBoards(const char *filename) +{ + TFile *file = new TFile(filename, "read"); + if(!file) { + AliWarning(Form("Can't read file %s",filename)); + return; + } + char histoName[30]; + char *cathCode[2] = {"bendPlane", "nonBendPlane"}; + TH1F *histo = 0x0; + for(Int_t ch=0; ch<4; ch++){ + for(Int_t cath=0; cath<2; cath++){ + sprintf(histoName, "%sBoardEffChamber%i", cathCode[cath], 11+ch); + histo = (TH1F *)file->Get(histoName); + if(!(TH1F *)file->Get(histoName)) { + AliWarning(Form("Can't find histo %s in file %s",histoName, filename)); + continue; + } + for(Int_t board=0; boardFindBin(board+1); + fBoardContent[ch][cath][board] = histo->GetBinContent(bin); + } + } + } +} + + //__________________________________________________________________________ Int_t AliMUONTriggerEfficiencyCells::FindChamberIndex(Int_t detElemId) { diff --git a/MUON/AliMUONTriggerEfficiencyCells.h b/MUON/AliMUONTriggerEfficiencyCells.h index 72a9bcea9ee..6801cb39124 100755 --- a/MUON/AliMUONTriggerEfficiencyCells.h +++ b/MUON/AliMUONTriggerEfficiencyCells.h @@ -42,6 +42,7 @@ private: Int_t FindSlatIndex(Int_t detElemId); void ReadFileXY(ifstream &file); void ReadFileBoards(ifstream &file); + void ReadHistoBoards(const char* filename="MUON.TriggerEfficiencyMap.root"); static const Int_t fgkNofCells=80; ///< Number of cells @@ -53,7 +54,7 @@ private: static const Int_t fgkNofBoards=234; ///< Number of boards /// the boards content - Float_t fBoardContent[4][2][fgkNofBoards]; //[trig. chambers][RPCs][cathode][board] + Float_t fBoardContent[4][2][fgkNofBoards]; //[trig. chambers][cathode][board] ClassDef(AliMUONTriggerEfficiencyCells,2) // Trigger efficiency store }; diff --git a/MUON/MUONrecLinkDef.h b/MUON/MUONrecLinkDef.h index 44a7652c533..86979dcb69a 100644 --- a/MUON/MUONrecLinkDef.h +++ b/MUON/MUONrecLinkDef.h @@ -35,6 +35,7 @@ #pragma link C++ class AliMUONClusterFinderMLEM+; #pragma link C++ class AliMUONClusterSplitterMLEM+; #pragma link C++ class AliMUONTrackHitPattern+; +#pragma link C++ class AliMUONTriggerChamberEff+; #pragma link C++ class AliMUONVClusterStore+; #pragma link C++ class AliMUONClusterStoreV1+; diff --git a/MUON/libMUONrec.pkg b/MUON/libMUONrec.pkg index fd0da72214c..99fcb1c1098 100644 --- a/MUON/libMUONrec.pkg +++ b/MUON/libMUONrec.pkg @@ -31,6 +31,7 @@ SRCS:= AliMUONClusterReconstructor.cxx \ AliMUONPadStatusMaker.cxx \ AliMUONPadStatusMapMaker.cxx \ AliMUONTrackHitPattern.cxx \ + AliMUONTriggerChamberEff.cxx \ AliMUONVClusterStore.cxx \ AliMUONClusterStoreV1.cxx \ AliMUONVTrackStore.cxx \ diff --git a/MUON/mapping/AliMpTriggerSegmentation.cxx b/MUON/mapping/AliMpTriggerSegmentation.cxx index fbb5adfcc16..a4d31359a43 100644 --- a/MUON/mapping/AliMpTriggerSegmentation.cxx +++ b/MUON/mapping/AliMpTriggerSegmentation.cxx @@ -221,13 +221,9 @@ AliMpTriggerSegmentation::PadByLocation(const AliMpIntPair& location, { if ( !pad.IsValid() ) { - pad = AliMpPad(invloc,pi.GetIndices(),pi.Position(),pi.Dimensions()); - pad.AddLocation(pi.GetLocation()); + // uses PadByIndices to get the complete list of locations + return PadByIndices(pi.GetIndices(),warning); } - else - { - pad.AddLocation(pi.GetLocation()); - } } } if ( warning && !pad.IsValid() ) -- 2.43.0