From b44c933ee73d84f3a9026d6a6dd3b95935840d45 Mon Sep 17 00:00:00 2001 From: cvetan Date: Thu, 29 Apr 2010 13:44:34 +0000 Subject: [PATCH] Major update of the reconstruction. All the code from the ANALYSIS/AliTriggerAnalysis is now put in the reconstruction chain. The ESD object is updated by adding the mean time per side and the final decision (beam-beam,beam-gas,empty or fake) per side. The flags which control if this new information was filled are stored within the TObject::fBits. Now we should correct a couple of OCDB entries (affected first by unavailable DP from DCS and then by wrong mapping FEE<->offline and modify AliTriggerAnalysis so that it uses directly the newly added ESD information. A request to port this commit will be made soon. --- STEER/AliESDVZERO.cxx | 33 +++++- STEER/AliESDVZERO.h | 35 +++++- VZERO/AliVZEROConst.h | 2 +- VZERO/AliVZEROReconstructor.cxx | 89 +++++++++----- VZERO/AliVZEROReconstructor.h | 8 +- VZERO/AliVZEROTriggerMask.cxx | 199 +++++++++++++++++++++----------- VZERO/AliVZEROTriggerMask.h | 61 +++++----- 7 files changed, 292 insertions(+), 135 deletions(-) diff --git a/STEER/AliESDVZERO.cxx b/STEER/AliESDVZERO.cxx index 5a77f3350fb..e625361e165 100644 --- a/STEER/AliESDVZERO.cxx +++ b/STEER/AliESDVZERO.cxx @@ -9,7 +9,13 @@ AliESDVZERO::AliESDVZERO() fBBtriggerV0A(0), fBGtriggerV0A(0), fBBtriggerV0C(0), - fBGtriggerV0C(0) + fBGtriggerV0C(0), + fV0ATime(-1024), + fV0CTime(-1024), + fV0ATimeError(0), + fV0CTimeError(0), + fV0ADecision(kV0Invalid), + fV0CDecision(kV0Invalid) { // Default constructor for(Int_t j=0; j<64; j++){ @@ -28,7 +34,13 @@ AliESDVZERO::AliESDVZERO(const AliESDVZERO &o) fBBtriggerV0A(o.fBBtriggerV0A), fBGtriggerV0A(o.fBGtriggerV0A), fBBtriggerV0C(o.fBBtriggerV0C), - fBGtriggerV0C(o.fBGtriggerV0C) + fBGtriggerV0C(o.fBGtriggerV0C), + fV0ATime(o.fV0ATime), + fV0CTime(o.fV0CTime), + fV0ATimeError(o.fV0ATimeError), + fV0CTimeError(o.fV0CTimeError), + fV0ADecision(o.fV0ADecision), + fV0CDecision(o.fV0CDecision) { // Default constructor for(Int_t j=0; j<64; j++) { @@ -50,8 +62,13 @@ AliESDVZERO::AliESDVZERO(UInt_t BBtriggerV0A, UInt_t BGtriggerV0A, fBBtriggerV0A(BBtriggerV0A), fBGtriggerV0A(BGtriggerV0A), fBBtriggerV0C(BBtriggerV0C), - fBGtriggerV0C(BGtriggerV0C) - + fBGtriggerV0C(BGtriggerV0C), + fV0ATime(-1024), + fV0CTime(-1024), + fV0ATimeError(0), + fV0CTimeError(0), + fV0ADecision(kV0Invalid), + fV0CDecision(kV0Invalid) { // Constructor for(Int_t j=0; j<64; j++) { @@ -75,6 +92,14 @@ AliESDVZERO& AliESDVZERO::operator=(const AliESDVZERO& o) fBGtriggerV0A=o.fBGtriggerV0A; fBBtriggerV0C=o.fBBtriggerV0C; fBGtriggerV0C=o.fBGtriggerV0C; + + fV0ATime = o.fV0ATime; + fV0CTime = o.fV0CTime; + fV0ATimeError = o.fV0ATimeError; + fV0CTimeError = o.fV0CTimeError; + fV0ADecision = o.fV0ADecision; + fV0CDecision = o.fV0CDecision; + for(Int_t j=0; j<64; j++) { fMultiplicity[j] = o.fMultiplicity[j]; fAdc[j] = o.fAdc[j]; diff --git a/STEER/AliESDVZERO.h b/STEER/AliESDVZERO.h index 43e69276ce7..26251c91fd9 100644 --- a/STEER/AliESDVZERO.h +++ b/STEER/AliESDVZERO.h @@ -14,6 +14,13 @@ public: Float_t *Time, Float_t *Width, Bool_t *BBFlag, Bool_t *BGFlag); virtual ~AliESDVZERO() {}; + + enum { + kCorrectedLeadingTime = BIT(14), + kTriggerBitsFilled = BIT(15), + kDecisionFilled = BIT(16) + }; + enum Decision { kV0Invalid = -1, kV0Empty = 0, kV0BB, kV0BG, kV0Fake }; // Setters virtual void SetBBtriggerV0A(UInt_t BBtrigger) {fBBtriggerV0A=BBtrigger;} @@ -32,6 +39,14 @@ public: {for(Int_t i=0;i<64;i++) fBBFlag[i]=BBFlag[i];} virtual void SetBGFlag(Bool_t BGFlag[64]) {for(Int_t i=0;i<64;i++) fBGFlag[i]=BGFlag[i];} + + void SetV0ATime(Float_t time) {fV0ATime = time;} + void SetV0CTime(Float_t time) {fV0CTime = time;} + void SetV0ATimeError(Float_t err) {fV0ATimeError = err;} + void SetV0CTimeError(Float_t err) {fV0CTimeError = err;} + + void SetV0ADecision(Decision des) {fV0ADecision = des;} + void SetV0CDecision(Decision des) {fV0CDecision = des;} // Getters Short_t GetNbPMV0A(); @@ -61,6 +76,14 @@ public: Bool_t BGTriggerV0C(Int_t i); Bool_t GetBBFlag(Int_t i); Bool_t GetBGFlag(Int_t i); + + Float_t GetV0ATime() const { return fV0ATime; } + Float_t GetV0CTime() const { return fV0CTime; } + Float_t GetV0ATimeError() const { return fV0ATimeError; } + Float_t GetV0CTimeError() const { return fV0CTimeError; } + + Decision GetV0ADecision() const { return fV0ADecision; } + Decision GetV0CDecision() const { return fV0CDecision; } Bool_t OutOfRange(Int_t i, const char *s, Int_t upper) const; AliESDVZERO &operator=(const AliESDVZERO& source); @@ -78,8 +101,16 @@ protected: Float_t fWidth[64]; // time width for each channel Bool_t fBBFlag[64]; // BB Flags from Online V0 Electronics Bool_t fBGFlag[64]; // BG Flags from Online V0 Electronics - - ClassDef(AliESDVZERO,7) + + Float_t fV0ATime; // Average time in V0A + Float_t fV0CTime; // Average time in V0C + Float_t fV0ATimeError; // Error in the average time in V0A + Float_t fV0CTimeError; // Error in the average time in V0C + + Decision fV0ADecision; // V0A final decision based on average time of channels + Decision fV0CDecision; // V0C final decision based on average time of channels + + ClassDef(AliESDVZERO,8) }; #endif diff --git a/VZERO/AliVZEROConst.h b/VZERO/AliVZEROConst.h index 60f088141c9..f706ffc722f 100644 --- a/VZERO/AliVZEROConst.h +++ b/VZERO/AliVZEROConst.h @@ -3,7 +3,7 @@ /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. */ -const Float_t kIntTimeRes = 0.5; // intrinsic time resolution of the scintillator +const Float_t kIntTimeRes = 0.39; // intrinsic time resolution of the scintillator const Float_t kV0CDelayCables = 8.1; // delay cables on the C side (in ns) const Float_t kV0Offset = 1461.4; // general V0 offset between the TDCs and the trigger const Float_t kADCTimeOffset = -189.0; // ADC sampling clock offset (in ns) diff --git a/VZERO/AliVZEROReconstructor.cxx b/VZERO/AliVZEROReconstructor.cxx index 214779c72e1..ff0806dda87 100644 --- a/VZERO/AliVZEROReconstructor.cxx +++ b/VZERO/AliVZEROReconstructor.cxx @@ -21,6 +21,9 @@ /// // /////////////////////////////////////////////////////////////////////////////// +#include +#include + #include "AliRunLoader.h" #include "AliRawReader.h" #include "AliGRPObject.h" @@ -29,6 +32,7 @@ #include "AliCDBEntry.h" #include "AliVZEROReconstructor.h" #include "AliVZERORawStream.h" +#include "AliVZEROConst.h" #include "AliESDEvent.h" #include "AliVZEROTriggerMask.h" #include "AliESDfriend.h" @@ -36,6 +40,7 @@ #include "AliVZEROdigit.h" #include "AliVZEROCalibData.h" #include "AliRunInfo.h" +#include "AliCTPTimeParams.h" ClassImp(AliVZEROReconstructor) @@ -44,7 +49,8 @@ AliVZEROReconstructor:: AliVZEROReconstructor(): AliReconstructor(), fESDVZERO(0x0), fESD(0x0), fESDVZEROfriend(0x0), - fCalibData(GetCalibData()), + fCalibData(NULL), + fTimeSlewing(NULL), fCollisionMode(0), fBeamEnergy(0.), fDigitsArray(0) @@ -52,8 +58,30 @@ AliVZEROReconstructor:: AliVZEROReconstructor(): AliReconstructor(), // Default constructor // Get calibration data - // fCalibData = GetCalibData(); - + fCalibData = GetCalibData(); + + AliCDBEntry *entry = AliCDBManager::Instance()->Get("GRP/CTP/CTPtiming"); + if (!entry) AliFatal("CTP timing parameters are not found in OCDB !"); + AliCTPTimeParams *ctpParams = (AliCTPTimeParams*)entry->GetObject(); + Float_t l1Delay = (Float_t)ctpParams->GetDelayL1L0()*25.0; + + AliCDBEntry *entry2 = AliCDBManager::Instance()->Get("VZERO/Calib/TimeDelays"); + if (!entry2) AliFatal("VZERO time delays are not found in OCDB !"); + TH1F *delays = (TH1F*)entry2->GetObject(); + + AliCDBEntry *entry3 = AliCDBManager::Instance()->Get("VZERO/Calib/TimeSlewing"); + if (!entry3) AliFatal("VZERO time slewing function is not found in OCDB !"); + fTimeSlewing = (TF1*)entry3->GetObject(); + + for(Int_t i = 0 ; i < 64; ++i) { + Int_t board = AliVZEROCalibData::GetBoardNumber(i); + fTimeOffset[i] = (((Float_t)fCalibData->GetTriggerCountOffset(board)- + (Float_t)fCalibData->GetRollOver(board))*25.0+ + fCalibData->GetTimeOffset(i)+ + l1Delay+ + delays->GetBinContent(i+1)+ + kV0Offset); + } } @@ -237,7 +265,7 @@ void AliVZEROReconstructor::FillESD(TTree* digitsTree, TTree* /*clustersTree*/, for (Int_t i=0; i<64; i++){ adc[i] = 0.0; mult[i] = 0.0; - time[i] = 0.0; + time[i] = kInvalidTime; width[i] = 0.0; BBFlag[i] = kFALSE; BGFlag[i] = kFALSE; @@ -258,7 +286,7 @@ void AliVZEROReconstructor::FillESD(TTree* digitsTree, TTree* /*clustersTree*/, Int_t k = pmNumber+64*integrator; Float_t pedestal = fCalibData->GetPedestal(k); adc[pmNumber] = digit->ADC() - pedestal; - time[pmNumber] = digit->Time(); + time[pmNumber] = CorrectLeadingTime(pmNumber,digit->Time(),adc[pmNumber]); width[pmNumber] = digit->Width(); BBFlag[pmNumber]= digit->BBFlag(); BGFlag[pmNumber]= digit->BGFlag(); @@ -271,6 +299,7 @@ void AliVZEROReconstructor::FillESD(TTree* digitsTree, TTree* /*clustersTree*/, } // end of loop over digits } // end of loop over events in digits tree + fESDVZERO->SetBit(AliESDVZERO::kCorrectedLeadingTime,kTRUE); fESDVZERO->SetMultiplicity(mult); fESDVZERO->SetADC(adc); fESDVZERO->SetTime(time); @@ -278,21 +307,12 @@ void AliVZEROReconstructor::FillESD(TTree* digitsTree, TTree* /*clustersTree*/, fESDVZERO->SetBBFlag(BBFlag); fESDVZERO->SetBGFlag(BGFlag); - // now get the trigger mask - - AliVZEROTriggerMask *TriggerMask = new AliVZEROTriggerMask(); - TriggerMask->SetAdcThreshold(10.0/2.0); - TriggerMask->SetTimeWindowWidthBBA(50); - TriggerMask->SetTimeWindowWidthBGA(20); - TriggerMask->SetTimeWindowWidthBBC(50); - TriggerMask->SetTimeWindowWidthBGC(20); - TriggerMask->FillMasks(digitsTree, fDigitsArray); + // now fill the V0 decision and channel flags + { + AliVZEROTriggerMask triggerMask; + triggerMask.FillMasks(fESDVZERO, fCalibData, fTimeSlewing); + } - fESDVZERO->SetBBtriggerV0A(TriggerMask->GetBBtriggerV0A()); - fESDVZERO->SetBGtriggerV0A(TriggerMask->GetBGtriggerV0A()); - fESDVZERO->SetBBtriggerV0C(TriggerMask->GetBBtriggerV0C()); - fESDVZERO->SetBGtriggerV0C(TriggerMask->GetBGtriggerV0C()); - if (esd) { AliDebug(1, Form("Writing VZERO data to ESD tree")); esd->SetVZEROData(fESDVZERO); @@ -374,17 +394,6 @@ AliVZEROCalibData* AliVZEROReconstructor::GetCalibData() const entry = man->Get("VZERO/Calib/Data"); -// if(!entry){ -// AliWarning("Load of calibration data from default storage failed!"); -// AliWarning("Calibration data will be loaded from local storage ($ALICE_ROOT)"); -// Int_t runNumber = man->GetRun(); -// entry = man->GetStorage("local://$ALICE_ROOT/OCDB") -// ->Get("VZERO/Calib/Data",runNumber); -// -// } - - // Retrieval of data in directory VZERO/Calib/Data: - AliVZEROCalibData *calibdata = 0; if (entry) calibdata = (AliVZEROCalibData*) entry->GetObject(); @@ -393,3 +402,23 @@ AliVZEROCalibData* AliVZEROReconstructor::GetCalibData() const return calibdata; } +Float_t AliVZEROReconstructor::CorrectLeadingTime(Int_t i, Float_t time, Float_t adc) const +{ + // Correct the leading time + // for slewing effect and + // misalignment of the channels + if (time < 1e-6) return kInvalidTime; + + // Channel alignment and general offset subtraction + if (i < 32) time -= kV0CDelayCables; + time -= fTimeOffset[i]; + + // In case of pathological signals + if (adc < 1e-6) return time; + + // Slewing correction + Float_t thr = fCalibData->GetDiscriThr(i); + time -= fTimeSlewing->Eval(adc/thr); + + return time; +} diff --git a/VZERO/AliVZEROReconstructor.h b/VZERO/AliVZEROReconstructor.h index 607003384fd..41f81c90a09 100644 --- a/VZERO/AliVZEROReconstructor.h +++ b/VZERO/AliVZEROReconstructor.h @@ -19,6 +19,7 @@ #include "AliESDVZERO.h" #include "AliVZERORecoParam.h" +class TF1; class AliVZEROCalibData; class AliESDEvent; class AliESDVZEROfriend; @@ -51,9 +52,10 @@ public: void GetCollisionMode(); AliVZEROCalibData *GetCalibData() const; + Float_t CorrectLeadingTime(Int_t i, Float_t time, Float_t adc) const; enum {kInvalidADC = -1024, - kInvalidTime = -1}; + kInvalidTime = -1024}; protected: AliESDVZERO* fESDVZERO; // ESD output object @@ -65,13 +67,15 @@ private: AliVZEROReconstructor& operator = (const AliVZEROReconstructor& reconstructor); AliVZEROCalibData* fCalibData; //! calibration data + Float_t fTimeOffset[64]; //! HPTDC time offsets channel by channel + TF1* fTimeSlewing; //! Function for time slewing correction Int_t fCollisionMode; // =0->p-p, =1->A-A Float_t fBeamEnergy; // beam energy mutable TClonesArray *fDigitsArray; // clones-array for ConvertDigits() and FillESD() - ClassDef(AliVZEROReconstructor, 1) // class for the VZERO reconstruction + ClassDef(AliVZEROReconstructor, 2) // class for the VZERO reconstruction }; #endif diff --git a/VZERO/AliVZEROTriggerMask.cxx b/VZERO/AliVZEROTriggerMask.cxx index c4c9d49a100..a8f7e97943e 100644 --- a/VZERO/AliVZEROTriggerMask.cxx +++ b/VZERO/AliVZEROTriggerMask.cxx @@ -24,16 +24,16 @@ #include #include #include -#include -#include +#include +#include #include -#include "AliCDBManager.h" -#include "AliCDBStorage.h" -#include "AliCDBEntry.h" #include "AliLog.h" #include "AliVZEROTriggerMask.h" -#include "AliVZEROdigit.h" +#include "AliVZEROConst.h" +#include "AliVZEROCalibData.h" +#include "AliESDVZERO.h" +#include "AliVZEROReconstructor.h" //______________________________________________________________________ ClassImp(AliVZEROTriggerMask) @@ -43,17 +43,29 @@ ClassImp(AliVZEROTriggerMask) AliVZEROTriggerMask::AliVZEROTriggerMask() :TObject(), fAdcThresHold(0.0), - fTimeWindowWidthBBA(50.0), - fTimeWindowWidthBGA(20.0), - fTimeWindowWidthBBC(50.0), - fTimeWindowWidthBGC(20.0), - fBBtriggerV0A(0), - fBGtriggerV0A(0), - fBBtriggerV0C(0), - fBGtriggerV0C(0) - + fTimeWindowBBALow(-9.5), + fTimeWindowBBAUp(22.5), + fTimeWindowBGALow(-2.5), + fTimeWindowBGAUp(5.0), + fTimeWindowFakeALow(-17.5), + fTimeWindowFakeAUp(-9.5), + fTimeWindowBBCLow(-2.5), + fTimeWindowBBCUp(22.5), + fTimeWindowBGCLow(-2.5), + fTimeWindowBGCUp(2.5), + fTimeWindowFakeCLow(-22.5), + fTimeWindowFakeCUp(-8.5), + fV0ADist(0), + fV0CDist(0) { - SetAdcThreshold(); + // Default constructor + // + Float_t zV0A = TMath::Abs(GetZPosition("VZERO/V0A")); + Float_t zV0C = TMath::Abs(GetZPosition("VZERO/V0C")); + + // distance in time units from nominal vertex to V0 + fV0ADist = zV0A/TMath::Ccgs()*1e9; + fV0CDist = zV0C/TMath::Ccgs()*1e9; } //________________________________________________________________________________ @@ -62,8 +74,10 @@ Double_t AliVZEROTriggerMask::GetZPosition(const char* symname){ // Double_t *tr; TGeoPNEntry *pne = gGeoManager->GetAlignableEntry(symname); - if (!pne) return 0; - + if (!pne) { + AliFatalClass(Form("TGeoPNEntry with symbolic name %s does not exist!",symname)); + return 0; + } TGeoPhysicalNode *pnode = pne->GetPhysicalNode(); if(pnode){ @@ -72,7 +86,7 @@ Double_t AliVZEROTriggerMask::GetZPosition(const char* symname){ }else{ const char* path = pne->GetTitle(); if(!gGeoManager->cd(path)){ - AliErrorClass(Form("Volume path %s not valid!",path)); + AliFatalClass(Form("Volume path %s not valid!",path)); return 0; } tr = gGeoManager->GetCurrentMatrix()->GetTranslation(); @@ -84,57 +98,106 @@ Double_t AliVZEROTriggerMask::GetZPosition(const char* symname){ //________________________________________________________________________________ -void AliVZEROTriggerMask::FillMasks(TTree* vzeroDigitsTree, - TClonesArray* const vzeroDigits) +void AliVZEROTriggerMask::FillMasks(AliESDVZERO *esdV0, + AliVZEROCalibData *cal, + TF1 *slewing) { -// Fill up the trigger mask word using the TDC - - const Double_t lightSpeed = 2.9979245800; // cm/100 ps - Float_t zV0A = TMath::Abs(GetZPosition("VZERO/V0A")); - Float_t zV0C = TMath::Abs(GetZPosition("VZERO/V0C")); - - // distance in time units from nominal vertex to V0 - Float_t v0aDist = zV0A/lightSpeed; // 100 of picoseconds - Float_t v0cDist = zV0C/lightSpeed; // 100 of picoseconds - Float_t bunchSeparation = 1000.0; // 100 of picoseconds - - // mask - UInt_t one=1; - - // loop over vzero entries - Int_t nEntries = (Int_t)vzeroDigitsTree->GetEntries(); - for (Int_t e=0; eGetEvent(e); - - Int_t nDigits = vzeroDigits->GetEntriesFast(); - - for (Int_t d=0; dGetEvent(d); - AliVZEROdigit* digit = (AliVZEROdigit*)vzeroDigits->At(d); - - Int_t pmNumber = digit->PMNumber(); - Float_t adc = digit->ADC(); - Float_t tdc = digit->Time()*10.0; // in 100 of picoseconds - - if (adc>fAdcThresHold) { - if (pmNumber<32) { // in V0C - if (tdc>(v0cDist-fTimeWindowWidthBBC/2.0) && - tdc<(v0cDist+fTimeWindowWidthBBC/2.0)) - fBBtriggerV0C+=(one<(bunchSeparation-v0cDist-fTimeWindowWidthBGC/2.0) && - tdc<(bunchSeparation-v0cDist+fTimeWindowWidthBGC/2.0)) - fBGtriggerV0C+=(one<SetBit(AliESDVZERO::kTriggerBitsFilled,kTRUE); + esdV0->SetBit(AliESDVZERO::kDecisionFilled,kTRUE); + + UInt_t aBBtriggerV0A = 0; // bit mask for Beam-Beam trigger in V0A + UInt_t aBGtriggerV0A = 0; // bit mask for Beam-Gas trigger in V0A + UInt_t aBBtriggerV0C = 0; // bit mask for Beam-Beam trigger in V0C + UInt_t aBGtriggerV0C = 0; // bit mask for Beam-Gas trigger in V0C + + const Float_t p1 = 2.19; // photostatistics term in the time resolution + const Float_t p2 = 1.31; // slewing related term in the time resolution + + // loop over vzero channels + Float_t timeAW = 0,timeCW = 0; + Float_t weightA = 0,weightC = 0; + Int_t ntimeA = 0, ntimeC = 0; + for (Int_t i = 0; i < 64; ++i) { + Float_t adc = esdV0->GetAdc(i); + if (adc > fAdcThresHold) { + Float_t tdc = esdV0->GetTime(i); + if (tdc > (AliVZEROReconstructor::kInvalidTime + 1e-6)) { + Float_t nphe = adc*kChargePerADC/(cal->GetGain(i)*TMath::Qe()); + Float_t timeErr = TMath::Sqrt(kIntTimeRes*kIntTimeRes+ + p1*p1/nphe+ + p2*p2*(slewing->GetParameter(0)*slewing->GetParameter(1))*(slewing->GetParameter(0)*slewing->GetParameter(1))* + TMath::Power(adc/cal->GetDiscriThr(i),2.*(slewing->GetParameter(1)-1.))); + + if (i < 32) { // in V0C + ntimeC++; + timeCW += tdc/(timeErr*timeErr); + weightC += 1.0/(timeErr*timeErr); + + if (tdc > (fV0CDist + fTimeWindowBBCLow) && + tdc < (fV0CDist + fTimeWindowBBCUp)) + aBBtriggerV0C |= (1 << i); + if (tdc > (-fV0CDist + fTimeWindowBGCLow) && + tdc < (-fV0CDist + fTimeWindowBGCUp)) + aBGtriggerV0C |= (1 << i); } - if (pmNumber>31) { // in V0A - Int_t shift = pmNumber-32; - if (tdc>(v0aDist-fTimeWindowWidthBBA/2.0) && - tdc<(v0aDist+fTimeWindowWidthBBA/2.0)) - fBBtriggerV0A+=(one<(bunchSeparation-v0aDist-fTimeWindowWidthBGA/2.0) && - tdc<(bunchSeparation-v0aDist+fTimeWindowWidthBGA/2.0)) - fBGtriggerV0A+=(one< (fV0ADist + fTimeWindowBBALow) && + tdc < (fV0ADist + fTimeWindowBBAUp)) + aBBtriggerV0A |= (1 << shift); + if (tdc > (-fV0ADist + fTimeWindowBGALow) && + tdc < (-fV0ADist + fTimeWindowBGAUp)) + aBGtriggerV0A |= (1 << shift); } } - } // end of loop over digits - } // end of loop over events in digits tree + } + } // end of loop over channels + + esdV0->SetBBtriggerV0A(aBBtriggerV0A); + esdV0->SetBGtriggerV0A(aBGtriggerV0A); + esdV0->SetBBtriggerV0C(aBBtriggerV0C); + esdV0->SetBGtriggerV0C(aBGtriggerV0C); + + if (weightA > 0) timeAW = timeAW/weightA; + else timeAW = AliVZEROReconstructor::kInvalidTime; + + if (weightC > 0) timeCW = timeCW/weightC; + else timeCW = AliVZEROReconstructor::kInvalidTime; + + esdV0->SetV0ATime(timeAW); + esdV0->SetV0CTime(timeCW); + esdV0->SetV0ATimeError((weightA > 0) ? (1./TMath::Sqrt(weightA)) : 0); + esdV0->SetV0ATimeError((weightC > 0) ? (1./TMath::Sqrt(weightC)) : 0); + + esdV0->SetV0ADecision(AliESDVZERO::kV0Empty); + esdV0->SetV0CDecision(AliESDVZERO::kV0Empty); + + if (timeAW > (fV0ADist + fTimeWindowBBALow) && + timeAW < (fV0ADist + fTimeWindowBBAUp)) + esdV0->SetV0ADecision(AliESDVZERO::kV0BB); + else if (timeAW > (-fV0ADist + fTimeWindowBGALow) && + timeAW < (-fV0ADist + fTimeWindowBGAUp)) + esdV0->SetV0ADecision(AliESDVZERO::kV0BG); + else if (timeAW > (fV0ADist + fTimeWindowFakeALow) && + timeAW < (fV0ADist + fTimeWindowFakeAUp)) + esdV0->SetV0ADecision(AliESDVZERO::kV0Fake); + + if (timeCW > (fV0CDist + fTimeWindowBBCLow) && + timeCW < (fV0CDist + fTimeWindowBBCUp)) + esdV0->SetV0CDecision(AliESDVZERO::kV0BB); + else if (timeCW > (-fV0CDist + fTimeWindowBGCLow) && + timeCW < (-fV0CDist + fTimeWindowBGCUp)) + esdV0->SetV0CDecision(AliESDVZERO::kV0BG); + else if (timeCW > (fV0CDist + fTimeWindowFakeCLow) && + timeCW < (fV0CDist + fTimeWindowFakeCUp)) + esdV0->SetV0CDecision(AliESDVZERO::kV0Fake); + } diff --git a/VZERO/AliVZEROTriggerMask.h b/VZERO/AliVZEROTriggerMask.h index 8e506d33b86..5088458dc88 100644 --- a/VZERO/AliVZEROTriggerMask.h +++ b/VZERO/AliVZEROTriggerMask.h @@ -9,6 +9,8 @@ #include class TTree; class TClonesArray; +class AliESDVZERO; +class AliVZEROCalibData; class AliVZEROTriggerMask : public TObject { @@ -16,40 +18,43 @@ class AliVZEROTriggerMask : public TObject AliVZEROTriggerMask(); // constructor virtual ~AliVZEROTriggerMask(){} // destructor - void FillMasks(TTree* vzeroDigitsTree, - TClonesArray* const vzeroDigits); + void FillMasks(AliESDVZERO *esdV0, + AliVZEROCalibData *cal, + TF1 *slewing); Double_t GetZPosition(const char* symname); - void SetAdcThreshold(Float_t t=55.0) - {fAdcThresHold=t;} - void SetTimeWindowWidthBBA(Float_t w=50.0) - {fTimeWindowWidthBBA=w;} - void SetTimeWindowWidthBBC(Float_t w=50.0) - {fTimeWindowWidthBBC=w;} - void SetTimeWindowWidthBGA(Float_t w=20.0) - {fTimeWindowWidthBGA=w;} - void SetTimeWindowWidthBGC(Float_t w=20.0) - {fTimeWindowWidthBGC=w;} - - UInt_t GetBBtriggerV0A() const { return fBBtriggerV0A;} - UInt_t GetBGtriggerV0A() const { return fBGtriggerV0A;} - UInt_t GetBBtriggerV0C() const { return fBBtriggerV0C;} - UInt_t GetBGtriggerV0C() const { return fBGtriggerV0C;} + void SetAdcThreshold(Float_t thr) + {fAdcThresHold=thr;} + void SetTimeWindowBBA(Float_t wlow,Float_t wup) + {fTimeWindowBBALow=wlow; fTimeWindowBBAUp=wup;} + void SetTimeWindowBBC(Float_t wlow,Float_t wup) + {fTimeWindowBBCLow=wlow; fTimeWindowBBCUp=wup;} + void SetTimeWindowBGA(Float_t wlow,Float_t wup) + {fTimeWindowBGALow=wlow; fTimeWindowBGAUp=wup;} + void SetTimeWindowBGC(Float_t wlow,Float_t wup) + {fTimeWindowBGCLow=wlow; fTimeWindowBGCUp=wup;} private: Float_t fAdcThresHold; // Threshold on the ADC - Float_t fTimeWindowWidthBBA; // size of the BBA window - Float_t fTimeWindowWidthBGA; // size of the BGA window - Float_t fTimeWindowWidthBBC; // size of the BBC window - Float_t fTimeWindowWidthBGC; // size of the BGC window - UInt_t fBBtriggerV0A; // bit mask for Beam-Beam trigger in V0A - UInt_t fBGtriggerV0A; // bit mask for Beam-Gas trigger in V0A - UInt_t fBBtriggerV0C; // bit mask for Beam-Beam trigger in V0C - UInt_t fBGtriggerV0C; // bit mask for Beam-Gas trigger in V0C - - - ClassDef( AliVZEROTriggerMask, 1 ) // VZERO Trigger Detector class + Float_t fTimeWindowBBALow; // BBA window (lower cut) + Float_t fTimeWindowBBAUp; // BBA window (upper cut) + Float_t fTimeWindowBGALow; // BGA window (lower cut) + Float_t fTimeWindowBGAUp; // BGA window (upper cut) + Float_t fTimeWindowFakeALow;// Fake V0A window (lower cut) + Float_t fTimeWindowFakeAUp; // Fake V0A window (upper cut) + Float_t fTimeWindowBBCLow; // BBC window (lower cut) + Float_t fTimeWindowBBCUp; // BBC window (upper cut) + Float_t fTimeWindowBGCLow; // BGC window (lower cut) + Float_t fTimeWindowBGCUp; // BGC window (upper cut) + Float_t fTimeWindowFakeCLow;// Fake V0C window (lower cut) + Float_t fTimeWindowFakeCUp; // Fake V0C window (upper cut) + + Float_t fV0ADist; // Z position of V0A + Float_t fV0CDist; // Z position of V0C + + + ClassDef( AliVZEROTriggerMask, 2 ) // VZERO Trigger Detector class }; #endif // ALIVZEROTRIGGERMASK_H -- 2.43.0