X-Git-Url: http://git.uio.no/git/?a=blobdiff_plain;f=VZERO%2FAliVZEROReconstructor.cxx;h=440db6e4ed4b72bdbc5b98a25c359833ff72495e;hb=1dc767cff5d8138ee4eb310fbe0368a724ae1b78;hp=b430753f70aa3a765e775fcf97ef0d9e15bbd394;hpb=6c115a32b357e381250506f1b73d96f4b476d97a;p=u%2Fmrichter%2FAliRoot.git diff --git a/VZERO/AliVZEROReconstructor.cxx b/VZERO/AliVZEROReconstructor.cxx index b430753f70a..440db6e4ed4 100644 --- a/VZERO/AliVZEROReconstructor.cxx +++ b/VZERO/AliVZEROReconstructor.cxx @@ -21,6 +21,10 @@ /// // /////////////////////////////////////////////////////////////////////////////// +#include +#include +#include + #include "AliRunLoader.h" #include "AliRawReader.h" #include "AliGRPObject.h" @@ -29,11 +33,16 @@ #include "AliCDBEntry.h" #include "AliVZEROReconstructor.h" #include "AliVZERORawStream.h" +#include "AliVZEROConst.h" #include "AliESDEvent.h" #include "AliVZEROTriggerMask.h" #include "AliESDfriend.h" #include "AliESDVZEROfriend.h" #include "AliVZEROdigit.h" +#include "AliVZEROCalibData.h" +#include "AliRunInfo.h" +#include "AliCTPTimeParams.h" +#include "AliLHCClockPhase.h" ClassImp(AliVZEROReconstructor) @@ -42,15 +51,64 @@ AliVZEROReconstructor:: AliVZEROReconstructor(): AliReconstructor(), fESDVZERO(0x0), fESD(0x0), fESDVZEROfriend(0x0), - fCalibData(GetCalibData()), + fCalibData(NULL), + fTriggerData(NULL), + fTimeSlewing(NULL), + fSaturationCorr(NULL), + fEqFactors(NULL), fCollisionMode(0), - fBeamEnergy(0.) + fBeamEnergy(0.), + fDigitsArray(0) { // 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 *entry1 = AliCDBManager::Instance()->Get("GRP/CTP/TimeAlign"); + if (!entry1) AliFatal("CTP time-alignment is not found in OCDB !"); + AliCTPTimeParams *ctpTimeAlign = (AliCTPTimeParams*)entry1->GetObject(); + l1Delay += ((Float_t)ctpTimeAlign->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(); + + AliCDBEntry *entry4 = AliCDBManager::Instance()->Get("GRP/Calib/LHCClockPhase"); + if (!entry4) AliFatal("LHC clock-phase shift is not found in OCDB !"); + AliLHCClockPhase *phase = (AliLHCClockPhase*)entry4->GetObject(); + + for(Int_t i = 0 ; i < 64; ++i) { + Int_t board = AliVZEROCalibData::GetBoardNumber(i); + fTimeOffset[i] = (((Float_t)fCalibData->GetRollOver(board)- + (Float_t)fCalibData->GetTriggerCountOffset(board))*25.0+ + fCalibData->GetTimeOffset(i)- + l1Delay- + phase->GetMeanPhase()+ + delays->GetBinContent(i+1)+ + kV0Offset); + } + + AliCDBEntry *entry5 = AliCDBManager::Instance()->Get("VZERO/Calib/Saturation"); + if (!entry5) AliFatal("Saturation entry is not found in OCDB !"); + fSaturationCorr = (TObjArray*)entry5->GetObject(); + + AliCDBEntry *entry6 = AliCDBManager::Instance()->Get("VZERO/Trigger/Data"); + if (!entry6) AliFatal("VZERO trigger config data is not found in OCDB !"); + fTriggerData = (AliVZEROTriggerData*)entry6->GetObject(); + AliCDBEntry *entry7 = AliCDBManager::Instance()->Get("VZERO/Calib/EqualizationFactors"); + if (!entry7) AliFatal("VZERO equalization factors are not found in OCDB !"); + fEqFactors = (TH1F*)entry7->GetObject(); } @@ -69,8 +127,12 @@ AliVZEROReconstructor::~AliVZEROReconstructor() { // destructor - delete fESDVZERO; + if(fESDVZERO) + delete fESDVZERO; + if(fESDVZEROfriend) delete fESDVZEROfriend; + if(fDigitsArray) + delete fDigitsArray; } //_____________________________________________________________________________ @@ -87,171 +149,320 @@ void AliVZEROReconstructor::Init() //______________________________________________________________________ void AliVZEROReconstructor::ConvertDigits(AliRawReader* rawReader, TTree* digitsTree) const { -// converts RAW to digits - pedestal is subtracted +// converts RAW to digits if (!digitsTree) { AliError("No digits tree!"); return; } - TClonesArray* digitsArray = new TClonesArray("AliVZEROdigit"); - digitsTree->Branch("VZERODigit", &digitsArray); + if (!fDigitsArray) + fDigitsArray = new TClonesArray("AliVZEROdigit", 64); + digitsTree->Branch("VZERODigit", &fDigitsArray); fESDVZEROfriend->Reset(); rawReader->Reset(); AliVZERORawStream rawStream(rawReader); - if (rawStream.Next()) { - Float_t ADC_max[64], adc[64]; - Bool_t BBFlag[64], BGFlag[64], integrator[64]; - Float_t time[64], width[64]; - for(Int_t i=0; i<64; i++) { - // Search for the maximum charge in the train of 21 LHC clocks - // regardless of the integrator which has been operated: - ADC_max[i] = 0.0; - Int_t imax = 0; - for(Int_t iClock=0; iClock<21; iClock++){ - if(rawStream.GetPedestal(i,iClock) > ADC_max[i]) - {ADC_max[i]= rawStream.GetPedestal(i,iClock); - imax = iClock;} - } - // Convert i (FEE channel numbering) to j (aliroot channel numbering) - Int_t j = rawStream.GetOfflineChannel(i); - adc[j] = ADC_max[i]; - time[j] = rawStream.GetTime(i); - width[j] = rawStream.GetWidth(i); - BBFlag[j] = rawStream.GetBBFlag(i,imax); - BGFlag[j] = rawStream.GetBGFlag(i,imax); - integrator[j] = rawStream.GetIntegratorFlag(i,imax); - - // Filling the esd friend object - fESDVZEROfriend->SetBBScalers(j,rawStream.GetBBScalers(i)); - fESDVZEROfriend->SetBGScalers(j,rawStream.GetBGScalers(i)); - for (Int_t iBunch = 0; iBunch < AliESDVZEROfriend::kNBunches; iBunch++) { - fESDVZEROfriend->SetChargeMB(j,iBunch,rawStream.GetChargeMB(i,iBunch)); - fESDVZEROfriend->SetIntMBFlag(j,iBunch,rawStream.GetIntMBFlag(i,iBunch)); - fESDVZEROfriend->SetBBMBFlag(j,iBunch,rawStream.GetBBMBFlag(i,iBunch)); - fESDVZEROfriend->SetBGMBFlag(j,iBunch,rawStream.GetBGMBFlag(i,iBunch)); - } - for (Int_t iEv = 0; iEv < AliESDVZEROfriend::kNEvOfInt; iEv++) { - fESDVZEROfriend->SetPedestal(j,iEv,rawStream.GetPedestal(i,iEv)); - fESDVZEROfriend->SetIntegratorFlag(j,iEv,rawStream.GetIntegratorFlag(i,iEv)); - fESDVZEROfriend->SetBBFlag(j,iEv,rawStream.GetBBFlag(i,iEv)); - fESDVZEROfriend->SetBGFlag(j,iEv,rawStream.GetBGFlag(i,iEv)); - } - fESDVZEROfriend->SetTime(j,rawStream.GetTime(i)); - fESDVZEROfriend->SetWidth(j,rawStream.GetWidth(i)); - } - - // Filling the esd friend object - fESDVZEROfriend->SetTriggerInputs(rawStream.GetTriggerInputs()); - fESDVZEROfriend->SetTriggerInputsMask(rawStream.GetTriggerInputsMask()); - - for(Int_t iScaler = 0; iScaler < AliESDVZEROfriend::kNScalers; iScaler++) - fESDVZEROfriend->SetTriggerScalers(iScaler,rawStream.GetTriggerScalers(iScaler)); - - for(Int_t iBunch = 0; iBunch < AliESDVZEROfriend::kNBunches; iBunch++) - fESDVZEROfriend->SetBunchNumbersMB(iBunch,rawStream.GetBunchNumbersMB(iBunch)); + if (rawStream.Next()) { + + Int_t aBBflagsV0A = 0; + Int_t aBBflagsV0C = 0; + Int_t aBGflagsV0A = 0; + Int_t aBGflagsV0C = 0; + + for(Int_t iChannel=0; iChannel < 64; ++iChannel) { + Int_t offlineCh = rawStream.GetOfflineChannel(iChannel); + // ADC charge samples + Short_t chargeADC[AliVZEROdigit::kNClocks]; + for(Int_t iClock=0; iClock < AliVZEROdigit::kNClocks; ++iClock) { + chargeADC[iClock] = rawStream.GetPedestal(iChannel,iClock); + } + // Integrator flag + Bool_t integrator = rawStream.GetIntegratorFlag(iChannel,AliVZEROdigit::kNClocks/2); + // Beam-beam and beam-gas flags + if(offlineCh<32) { + if (rawStream.GetBBFlag(iChannel,AliVZEROdigit::kNClocks/2)) aBBflagsV0C |= (1 << offlineCh); + if (rawStream.GetBGFlag(iChannel,AliVZEROdigit::kNClocks/2)) aBGflagsV0C |= (1 << offlineCh); + } else { + if (rawStream.GetBBFlag(iChannel,AliVZEROdigit::kNClocks/2)) aBBflagsV0A |= (1 << (offlineCh-32)); + if (rawStream.GetBGFlag(iChannel,AliVZEROdigit::kNClocks/2)) aBGflagsV0A |= (1 << (offlineCh-32)); + } + // HPTDC data (leading time and width) + Int_t board = AliVZEROCalibData::GetBoardNumber(offlineCh); + Float_t time = rawStream.GetTime(iChannel)*fCalibData->GetTimeResolution(board); + Float_t width = rawStream.GetWidth(iChannel)*fCalibData->GetWidthResolution(board); + // Add a digit + if(!fCalibData->IsChannelDead(iChannel)){ + new ((*fDigitsArray)[fDigitsArray->GetEntriesFast()]) + AliVZEROdigit(offlineCh, time, + width,integrator, + chargeADC); + } + + // Filling the part of esd friend object that is available only for raw data + fESDVZEROfriend->SetBBScalers(offlineCh,rawStream.GetBBScalers(iChannel)); + fESDVZEROfriend->SetBGScalers(offlineCh,rawStream.GetBGScalers(iChannel)); + for (Int_t iBunch = 0; iBunch < AliESDVZEROfriend::kNBunches; iBunch++) { + fESDVZEROfriend->SetChargeMB(offlineCh,iBunch,rawStream.GetChargeMB(iChannel,iBunch)); + fESDVZEROfriend->SetIntMBFlag(offlineCh,iBunch,rawStream.GetIntMBFlag(iChannel,iBunch)); + fESDVZEROfriend->SetBBMBFlag(offlineCh,iBunch,rawStream.GetBBMBFlag(iChannel,iBunch)); + fESDVZEROfriend->SetBGMBFlag(offlineCh,iBunch,rawStream.GetBGMBFlag(iChannel,iBunch)); + } + for (Int_t iEv = 0; iEv < AliESDVZEROfriend::kNEvOfInt; iEv++) { + fESDVZEROfriend->SetBBFlag(offlineCh,iEv,rawStream.GetBBFlag(iChannel,iEv)); + fESDVZEROfriend->SetBGFlag(offlineCh,iEv,rawStream.GetBGFlag(iChannel,iEv)); + } + } + + // Filling the global part of esd friend object that is available only for raw data + rawStream.FillTriggerBits(fTriggerData); + fESDVZEROfriend->SetTriggerInputs(rawStream.GetTriggerInputs()); + fESDVZEROfriend->SetTriggerInputsMask(rawStream.GetTriggerInputsMask()); + + for(Int_t iScaler = 0; iScaler < AliESDVZEROfriend::kNScalers; iScaler++) + fESDVZEROfriend->SetTriggerScalers(iScaler,rawStream.GetTriggerScalers(iScaler)); + + for(Int_t iBunch = 0; iBunch < AliESDVZEROfriend::kNBunches; iBunch++) + fESDVZEROfriend->SetBunchNumbersMB(iBunch,rawStream.GetBunchNumbersMB(iBunch)); - - // Channels(aliroot numbering) will be ordered in the tree - for(Int_t iChannel = 0; iChannel < 64; iChannel++) { - new ((*digitsArray)[digitsArray->GetEntriesFast()]) - AliVZEROdigit(iChannel, adc[iChannel], time[iChannel], - width[iChannel], BBFlag[iChannel], BGFlag[iChannel],integrator[iChannel]); - } + // Store the BB and BG flags in the digits tree (user info) + digitsTree->GetUserInfo()->Add(new TParameter("BBflagsV0A",aBBflagsV0A)); + digitsTree->GetUserInfo()->Add(new TParameter("BBflagsV0C",aBBflagsV0C)); + digitsTree->GetUserInfo()->Add(new TParameter("BGflagsV0A",aBGflagsV0A)); + digitsTree->GetUserInfo()->Add(new TParameter("BGflagsV0C",aBGflagsV0C)); + + UShort_t chargeA,chargeC; + rawStream.CalculateChargeForCentrTriggers(fTriggerData,chargeA,chargeC); + digitsTree->GetUserInfo()->Add(new TParameter("ChargeA",(Int_t)chargeA)); + digitsTree->GetUserInfo()->Add(new TParameter("ChargeC",(Int_t)chargeC)); + digitsTree->GetUserInfo()->Add(new TParameter("TriggerInputs",(Int_t)rawStream.GetTriggerInputs())); + + digitsTree->Fill(); } - digitsTree->Fill(); -} + fDigitsArray->Clear(); +} //______________________________________________________________________ void AliVZEROReconstructor::FillESD(TTree* digitsTree, TTree* /*clustersTree*/, AliESDEvent* esd) const { -// fills multiplicities to the ESD +// fills multiplicities to the ESD - pedestal is now subtracted if (!digitsTree) { AliError("No digits tree!"); return; } - TClonesArray* digitsArray = NULL; TBranch* digitBranch = digitsTree->GetBranch("VZERODigit"); - digitBranch->SetAddress(&digitsArray); + digitBranch->SetAddress(&fDigitsArray); Float_t mult[64]; Float_t adc[64]; Float_t time[64]; Float_t width[64]; - Bool_t BBFlag[64]; - Bool_t BGFlag[64]; + Bool_t aBBflag[64]; + Bool_t aBGflag[64]; 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; + aBBflag[i] = kFALSE; + aBGflag[i] = kFALSE; } - // loop over VZERO entries to get multiplicity + Int_t aBBflagsV0A = 0; + Int_t aBBflagsV0C = 0; + Int_t aBGflagsV0A = 0; + Int_t aBGflagsV0C = 0; + + if (digitsTree->GetUserInfo()->FindObject("BBflagsV0A")) { + aBBflagsV0A = ((TParameter*)digitsTree->GetUserInfo()->FindObject("BBflagsV0A"))->GetVal(); + } + else { + if (esd && (esd->GetEventType() == 7)) + AliWarning("V0A beam-beam flags not found in digits tree UserInfo!"); + } + + if (digitsTree->GetUserInfo()->FindObject("BBflagsV0C")) { + aBBflagsV0C = ((TParameter*)digitsTree->GetUserInfo()->FindObject("BBflagsV0C"))->GetVal(); + } + else { + if (esd && (esd->GetEventType() == 7)) + AliWarning("V0C beam-beam flags not found in digits tree UserInfo!"); + } + + if (digitsTree->GetUserInfo()->FindObject("BGflagsV0A")) { + aBGflagsV0A = ((TParameter*)digitsTree->GetUserInfo()->FindObject("BGflagsV0A"))->GetVal(); + } + else { + if (esd && (esd->GetEventType() == 7)) + AliWarning("V0A beam-gas flags not found in digits tree UserInfo!"); + } + + if (digitsTree->GetUserInfo()->FindObject("BGflagsV0C")) { + aBGflagsV0C = ((TParameter*)digitsTree->GetUserInfo()->FindObject("BGflagsV0C"))->GetVal(); + } + else { + if (esd && (esd->GetEventType() == 7)) + AliWarning("V0C beam-gas flags not found in digits tree UserInfo!"); + } + + // Beam-beam and beam-gas flags (hardware) + for (Int_t iChannel = 0; iChannel < 64; ++iChannel) { + if(iChannel < 32) { + aBBflag[iChannel] = (aBBflagsV0C >> iChannel) & 0x1; + aBGflag[iChannel] = (aBGflagsV0C >> iChannel) & 0x1; + } + else { + aBBflag[iChannel] = (aBBflagsV0A >> (iChannel-32)) & 0x1; + aBGflag[iChannel] = (aBGflagsV0A >> (iChannel-32)) & 0x1; + } + } + + // Fill the trigger charges and bits + UShort_t chargeA = 0; + UShort_t chargeC = 0; + UShort_t triggerInputs = 0; + if (digitsTree->GetUserInfo()->FindObject("ChargeA")) { + chargeA = (UShort_t)(((TParameter*)digitsTree->GetUserInfo()->FindObject("ChargeA"))->GetVal()); + } + else { + if (esd && (esd->GetEventType() == 7)) + AliWarning("V0A trigger charge not found in digits tree UserInfo!"); + } + + if (digitsTree->GetUserInfo()->FindObject("ChargeC")) { + chargeC = (UShort_t)(((TParameter*)digitsTree->GetUserInfo()->FindObject("ChargeC"))->GetVal()); + } + else { + if (esd && (esd->GetEventType() == 7)) + AliWarning("V0C trigger charge not found in digits tree UserInfo!"); + } + + if (digitsTree->GetUserInfo()->FindObject("TriggerInputs")) { + triggerInputs = (UShort_t)(((TParameter*)digitsTree->GetUserInfo()->FindObject("TriggerInputs"))->GetVal()); + } + else { + if (esd && (esd->GetEventType() == 7)) + AliWarning("V0C trigger charge not found in digits tree UserInfo!"); + } + + fESDVZERO->SetTriggerChargeA(chargeA); + fESDVZERO->SetTriggerChargeC(chargeC); + fESDVZERO->SetTriggerBits(triggerInputs); + fESDVZERO->SetBit(AliESDVZERO::kTriggerChargeBitsFilled,kTRUE); + Int_t nEntries = (Int_t)digitsTree->GetEntries(); for (Int_t e=0; eGetEvent(e); - Int_t nDigits = digitsArray->GetEntriesFast(); + Int_t nDigits = fDigitsArray->GetEntriesFast(); for (Int_t d=0; dAt(d); - Int_t pmNumber = digit->PMNumber(); - // Pedestal retrieval and suppression: - Float_t pedestal = fCalibData->GetPedestal(d); - adc[pmNumber] = digit->ADC() - pedestal; - time[pmNumber] = digit->Time(); + AliVZEROdigit* digit = (AliVZEROdigit*) fDigitsArray->At(d); + Int_t pmNumber = digit->PMNumber(); + + // Pedestal retrieval and suppression + Bool_t integrator = digit->Integrator(); + Float_t maxadc = 0; + Int_t imax = -1; + Float_t adcPedSub[AliVZEROdigit::kNClocks]; + for(Int_t iClock=0; iClock < AliVZEROdigit::kNClocks; ++iClock) { + Short_t charge = digit->ChargeADC(iClock); + Bool_t iIntegrator = (iClock%2 == 0) ? integrator : !integrator; + Int_t k = pmNumber + 64*iIntegrator; + adcPedSub[iClock] = (Float_t)charge - fCalibData->GetPedestal(k); + if(adcPedSub[iClock] <= GetRecoParam()->GetNSigmaPed()*fCalibData->GetSigma(k)) { + adcPedSub[iClock] = 0; + continue; + } + if(iClock < GetRecoParam()->GetStartClock() || iClock > GetRecoParam()->GetEndClock()) continue; + if(adcPedSub[iClock] > maxadc) { + maxadc = adcPedSub[iClock]; + imax = iClock; + } + } + + if (imax != -1) { + Int_t start = imax - GetRecoParam()->GetNPreClocks(); + if (start < 0) start = 0; + Int_t end = imax + GetRecoParam()->GetNPostClocks(); + if (end > 20) end = 20; + for(Int_t iClock = start; iClock <= end; iClock++) { + adc[pmNumber] += adcPedSub[iClock]; + } + } + + // HPTDC leading time and width + // Correction for slewing and various time delays + time[pmNumber] = CorrectLeadingTime(pmNumber,digit->Time(),adc[pmNumber]); width[pmNumber] = digit->Width(); - BBFlag[pmNumber]= digit->BBFlag(); - BGFlag[pmNumber]= digit->BGFlag(); - // printf("PM = %d, MIP per ADC channel = %f \n",pmNumber, fCalibData->GetMIPperADC(pmNumber)); - //AliInfo(Form("PM = %d, ADC = %f TDC %f",pmNumber, digit->ADC(),digit->Time())); - // cut of ADC at 1MIP/2 - if(fCollisionMode >0) { - Float_t MIP = 2.0; - if (adc[pmNumber] > (MIP/2.) ) mult[pmNumber] += adc[pmNumber]*(1.0/MIP) ; - } - else{ - if (adc[pmNumber] > (1.0/fCalibData->GetMIPperADC(pmNumber) /2.) ) - mult[pmNumber] += adc[pmNumber]*fCalibData->GetMIPperADC(pmNumber); - } + + if (adc[pmNumber] > 0) { + AliDebug(1,Form("PM = %d ADC = %f TDC %f (%f) Int %d (%d %d %d %d %d) %f %f %f %f %d %d",pmNumber, adc[pmNumber], + digit->Time(),time[pmNumber], + integrator, + digit->ChargeADC(8),digit->ChargeADC(9),digit->ChargeADC(10), + digit->ChargeADC(11),digit->ChargeADC(12), + fCalibData->GetPedestal(pmNumber),fCalibData->GetSigma(pmNumber), + fCalibData->GetPedestal(pmNumber+64),fCalibData->GetSigma(pmNumber+64), + aBBflag[pmNumber],aBGflag[pmNumber])); + }; + + TF1 *saturationFunc = (TF1*)fSaturationCorr->UncheckedAt(pmNumber); + if (!saturationFunc) AliFatal(Form("Saturation correction for channel %d is not found!",pmNumber)); + AliDebug(1,Form("Saturation PM=%d %f %f",pmNumber,adc[pmNumber],saturationFunc->Eval(adc[pmNumber]))); + mult[pmNumber] = saturationFunc->Eval(adc[pmNumber])*fCalibData->GetMIPperADC(pmNumber); + + // Fill ESD friend object + for (Int_t iEv = 0; iEv < AliESDVZEROfriend::kNEvOfInt; iEv++) { + fESDVZEROfriend->SetPedestal(pmNumber,iEv,(Float_t)digit->ChargeADC(iEv)); + fESDVZEROfriend->SetIntegratorFlag(pmNumber,iEv,(iEv%2 == 0) ? integrator : !integrator); + } + fESDVZEROfriend->SetTime(pmNumber,digit->Time()); + fESDVZEROfriend->SetWidth(pmNumber,digit->Width()); + } // 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); fESDVZERO->SetWidth(width); - 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,digitsArray); - - fESDVZERO->SetBBtriggerV0A(TriggerMask->GetBBtriggerV0A()); - fESDVZERO->SetBGtriggerV0A(TriggerMask->GetBGtriggerV0A()); - fESDVZERO->SetBBtriggerV0C(TriggerMask->GetBBtriggerV0C()); - fESDVZERO->SetBGtriggerV0C(TriggerMask->GetBGtriggerV0C()); - + fESDVZERO->SetBit(AliESDVZERO::kOnlineBitsFilled,kTRUE); + fESDVZERO->SetBBFlag(aBBflag); + fESDVZERO->SetBGFlag(aBGflag); + fESDVZERO->SetBit(AliESDVZERO::kCorrectedForSaturation,kTRUE); + + // now fill the V0 decision and channel flags + { + AliVZEROTriggerMask triggerMask; + triggerMask.SetRecoParam(GetRecoParam()); + triggerMask.FillMasks(fESDVZERO, fCalibData, fTimeSlewing); + } + if (esd) { AliDebug(1, Form("Writing VZERO data to ESD tree")); esd->SetVZEROData(fESDVZERO); + const AliESDRun *esdRun = esd->GetESDRun(); + if (esdRun) { + Float_t factors[64]; + Float_t factorSum = 0; + for(Int_t i = 0; i < 64; ++i) { + factors[i] = fEqFactors->GetBinContent(i+1)*fCalibData->GetMIPperADC(i); + factorSum += factors[i]; + } + for(Int_t i = 0; i < 64; ++i) factors[i] *= (64./factorSum); + + esd->SetVZEROEqFactors(factors); + } + else + AliError("AliESDRun object is not available! Cannot write the equalization factors!"); } if (esd) { @@ -261,6 +472,8 @@ void AliVZEROReconstructor::FillESD(TTree* digitsTree, TTree* /*clustersTree*/, fr->SetVZEROfriend(fESDVZEROfriend); } } + + fDigitsArray->Clear(); } //_____________________________________________________________________________ @@ -292,57 +505,28 @@ AliCDBStorage* AliVZEROReconstructor::SetStorage(const char *uri) //____________________________________________________________________________ void AliVZEROReconstructor::GetCollisionMode() { -// Retrieves the collision mode from GRP data - -// Initialization of the GRP entry - - Int_t run = AliCDBManager::Instance()->GetRun(); - -// printf("\n ++++++ Run Number retrieved as %d \n",run); - - AliCDBEntry* entry = AliCDBManager::Instance()->Get("GRP/GRP/Data",run); - AliGRPObject* grpData = 0x0; - - if(entry){ - TMap* m = dynamic_cast(entry->GetObject()); // old GRP entry - if(m){ - m->Print(); - grpData = new AliGRPObject(); - grpData->ReadValuesFromMap(m); - } - else{ - grpData = dynamic_cast(entry->GetObject()); // new GRP entry - entry->SetOwner(0); - } - AliCDBManager::Instance()->UnloadFromCache("GRP/GRP/Data"); - } + // Retrieval of collision mode - if(!grpData) { AliError("No GRP entry found in OCDB!"); - return; } - -// Retrieval of simulated collision mode - - TString beamType = grpData->GetBeamType(); + TString beamType = GetRunInfo()->GetBeamType(); if(beamType==AliGRPObject::GetInvalidString()){ - AliError("GRP/GRP/Data entry: missing value for the beam type !"); - AliError("\t VZERO cannot retrieve beam type\n"); + AliError("VZERO cannot retrieve beam type"); return; } - if( (beamType.CompareTo("P-P") ==0) || (beamType.CompareTo("p-p") ==0) ){ - fCollisionMode=0; + if( (beamType.CompareTo("P-P") ==0) || (beamType.CompareTo("p-p") ==0) ){ + fCollisionMode=0; + } + else if( (beamType.CompareTo("Pb-Pb") ==0) || (beamType.CompareTo("A-A") ==0) ){ + fCollisionMode=1; } - else if( (beamType.CompareTo("Pb-Pb") ==0) || (beamType.CompareTo("A-A") ==0) ){ - fCollisionMode=1; - } - fBeamEnergy = grpData->GetBeamEnergy(); + fBeamEnergy = GetRunInfo()->GetBeamEnergy(); if(fBeamEnergy==AliGRPObject::GetInvalidFloat()) { - AliError("GRP/GRP/Data entry: missing value for the beam energy ! Using 0"); + AliError("Missing value for the beam energy ! Using 0"); fBeamEnergy = 0.; } -// printf("\n ++++++ Beam type and collision mode retrieved as %s %d @ %1.3f GeV ++++++\n\n",beamType.Data(), fCollisionMode, fBeamEnergy); + AliDebug(1,Form("\n ++++++ Beam type and collision mode retrieved as %s %d @ %1.3f GeV ++++++\n\n",beamType.Data(), fCollisionMode, fBeamEnergy)); } @@ -357,17 +541,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(); @@ -376,3 +549,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->GetCalibDiscriThr(i,kTRUE); + time -= fTimeSlewing->Eval(adc/thr); + + return time; +}