#include "AliVZEROCalibData.h"
#include "AliRunInfo.h"
#include "AliCTPTimeParams.h"
+#include "AliLHCClockPhase.h"
ClassImp(AliVZEROReconstructor)
fESD(0x0),
fESDVZEROfriend(0x0),
fCalibData(NULL),
+ fTriggerData(NULL),
fTimeSlewing(NULL),
+ fSaturationCorr(NULL),
+ fEqFactors(NULL),
fCollisionMode(0),
fBeamEnergy(0.),
fDigitsArray(0)
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();
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->GetTriggerCountOffset(board)-
- (Float_t)fCalibData->GetRollOver(board))*25.0+
- fCalibData->GetTimeOffset(i)+
- l1Delay+
+ 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();
}
{
// destructor
- delete fESDVZERO;
+ if(fESDVZERO)
+ delete fESDVZERO;
+ if(fESDVZEROfriend)
delete fESDVZEROfriend;
+ if(fDigitsArray)
delete fDigitsArray;
}
rawReader->Reset();
AliVZERORawStream rawStream(rawReader);
if (rawStream.Next()) {
- Float_t adc[64];
- Float_t time[64], width[64];
- Bool_t BBFlag[64], BGFlag[64], integrator[64];
- Short_t chargeADC[64][21];
- for(Int_t i=0; i<64; i++) {
- Int_t j = rawStream.GetOfflineChannel(i);
- adc[j] = 0.0;
- time[j] = 0.0;
- width[j] = 0.0;
- BBFlag[j] = kFALSE;
- BGFlag[j] = kFALSE;
- integrator[j] = kFALSE;
- // Search for the maximum charge in the train of 21 LHC clocks
- // regardless of the integrator which has been operated:
- Float_t maxadc = 0;
- Int_t imax = -1;
- Float_t adcPedSub[21];
- for(Int_t iClock=0; iClock<21; iClock++){
- chargeADC[j][iClock] = (Short_t)rawStream.GetPedestal(i,iClock);
- Bool_t iIntegrator = rawStream.GetIntegratorFlag(i,iClock);
- Int_t k = j+64*iIntegrator;
- adcPedSub[iClock] = rawStream.GetPedestal(i,iClock) - 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;
- }
- }
- AliDebug(2,Form("Channel %d (online), %d (offline)",i,j));
- 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++) {
- if (iClock >= imax) {
- BBFlag[j] |= rawStream.GetBBFlag(i,iClock);
- BGFlag[j] |= rawStream.GetBGFlag(i,iClock);
- }
- if (iClock == imax)
- adc[j] += rawStream.GetPedestal(i,iClock);
- else
- adc[j] += adcPedSub[iClock];
-
- AliDebug(2,Form("clock = %d adc = %f",iClock,rawStream.GetPedestal(i,iClock)));
- }
- // Convert i (FEE channel numbering) to j (aliroot channel numbering)
-
- integrator[j] = rawStream.GetIntegratorFlag(i,imax);
- }
-
- Int_t board = j / 8;
- time[j] = rawStream.GetTime(i)/ (25./256.) * fCalibData->GetTimeResolution(board);
- width[j] = rawStream.GetWidth(i) / 0.4 * fCalibData->GetWidthResolution(board);
-
- // 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,time[j]);
- fESDVZEROfriend->SetWidth(j,width[j]);
- }
-
- // 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));
+ 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));
-
- Int_t aBBflagsV0A = 0;
- Int_t aBBflagsV0C = 0;
- Int_t aBGflagsV0A = 0;
- Int_t aBGflagsV0C = 0;
-
- // Channels(aliroot numbering) will be ordered in the tree
- for(Int_t iChannel = 0; iChannel < 64; iChannel++) {
- if(iChannel<32) {
- if (BBFlag[iChannel]) aBBflagsV0C |= (1 << iChannel);
- if (BGFlag[iChannel]) aBGflagsV0C |= (1 << iChannel);
- } else {
- if (BBFlag[iChannel]) aBBflagsV0A |= (1 << (iChannel-32));
- if (BGFlag[iChannel]) aBGflagsV0A |= (1 << (iChannel-32));
- }
- if(fCalibData->IsChannelDead(iChannel)){
- adc[iChannel] = (Float_t) kInvalidADC;
- time[iChannel] = (Float_t) kInvalidTime;
- }
- if (adc[iChannel] > 0)
- new ((*fDigitsArray)[fDigitsArray->GetEntriesFast()])
- AliVZEROdigit(iChannel, adc[iChannel], time[iChannel],
- width[iChannel],integrator[iChannel],
- chargeADC[iChannel]);
-
- }
-
- // Store the BB and BG flags in the digits tree (user info)
- digitsTree->GetUserInfo()->Add(new TParameter<int>("BBflagsV0A",aBBflagsV0A));
- digitsTree->GetUserInfo()->Add(new TParameter<int>("BBflagsV0C",aBBflagsV0C));
- digitsTree->GetUserInfo()->Add(new TParameter<int>("BGflagsV0A",aBGflagsV0A));
- digitsTree->GetUserInfo()->Add(new TParameter<int>("BGflagsV0C",aBGflagsV0C));
-
- digitsTree->Fill();
+ // Store the BB and BG flags in the digits tree (user info)
+ digitsTree->GetUserInfo()->Add(new TParameter<int>("BBflagsV0A",aBBflagsV0A));
+ digitsTree->GetUserInfo()->Add(new TParameter<int>("BBflagsV0C",aBBflagsV0C));
+ digitsTree->GetUserInfo()->Add(new TParameter<int>("BGflagsV0A",aBGflagsV0A));
+ digitsTree->GetUserInfo()->Add(new TParameter<int>("BGflagsV0C",aBGflagsV0C));
+
+ UShort_t chargeA,chargeC;
+ rawStream.CalculateChargeForCentrTriggers(fTriggerData,chargeA,chargeC);
+ digitsTree->GetUserInfo()->Add(new TParameter<int>("ChargeA",(Int_t)chargeA));
+ digitsTree->GetUserInfo()->Add(new TParameter<int>("ChargeC",(Int_t)chargeC));
+ digitsTree->GetUserInfo()->Add(new TParameter<int>("TriggerInputs",(Int_t)rawStream.GetTriggerInputs()));
+
+ digitsTree->Fill();
}
fDigitsArray->Clear();
-}
+}
//______________________________________________________________________
void AliVZEROReconstructor::FillESD(TTree* digitsTree, TTree* /*clustersTree*/,
if (digitsTree->GetUserInfo()->FindObject("BBflagsV0A")) {
aBBflagsV0A = ((TParameter<int>*)digitsTree->GetUserInfo()->FindObject("BBflagsV0A"))->GetVal();
}
- else
- AliWarning("V0A beam-beam flags not found in digits tree UserInfo! The flags will not be written to the raw-data stream!");
+ else {
+ if (esd && (esd->GetEventType() == 7))
+ AliWarning("V0A beam-beam flags not found in digits tree UserInfo!");
+ }
if (digitsTree->GetUserInfo()->FindObject("BBflagsV0C")) {
aBBflagsV0C = ((TParameter<int>*)digitsTree->GetUserInfo()->FindObject("BBflagsV0C"))->GetVal();
}
- else
- AliWarning("V0C beam-beam flags not found in digits tree UserInfo! The flags will not be written to the raw-data stream!");
+ else {
+ if (esd && (esd->GetEventType() == 7))
+ AliWarning("V0C beam-beam flags not found in digits tree UserInfo!");
+ }
if (digitsTree->GetUserInfo()->FindObject("BGflagsV0A")) {
aBGflagsV0A = ((TParameter<int>*)digitsTree->GetUserInfo()->FindObject("BGflagsV0A"))->GetVal();
}
- else
- AliWarning("V0A beam-gas flags not found in digits tree UserInfo! The flags will not be written to the raw-data stream!");
+ else {
+ if (esd && (esd->GetEventType() == 7))
+ AliWarning("V0A beam-gas flags not found in digits tree UserInfo!");
+ }
if (digitsTree->GetUserInfo()->FindObject("BGflagsV0C")) {
aBGflagsV0C = ((TParameter<int>*)digitsTree->GetUserInfo()->FindObject("BGflagsV0C"))->GetVal();
}
- else
- AliWarning("V0C beam-gas flags not found in digits tree UserInfo! The flags will not be written to the raw-data stream!");
-
+ 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<int>*)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<int>*)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<int>*)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; e<nEntries; e++) {
for (Int_t d=0; d<nDigits; d++) {
AliVZEROdigit* digit = (AliVZEROdigit*) fDigitsArray->At(d);
- Int_t pmNumber = digit->PMNumber();
- // Pedestal retrieval and suppression:
- Bool_t integrator = digit->Integrator();
- Int_t k = pmNumber+64*integrator;
- Float_t pedestal = fCalibData->GetPedestal(k);
- adc[pmNumber] = digit->ADC() - pedestal;
+ 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();
- if(pmNumber < 32) {
- aBBflag[pmNumber] = (aBBflagsV0C >> pmNumber) & 0x1;
- aBGflag[pmNumber] = (aBGflagsV0C >> pmNumber) & 0x1;
- }
- else {
- aBBflag[pmNumber] = (aBBflagsV0A >> (pmNumber-32)) & 0x1;
- aBGflag[pmNumber] = (aBGflagsV0A >> (pmNumber-32)) & 0x1;
+
+ if (adc[pmNumber] > 0) {
+ AliDebug(1,Form("PM = %d ADC = %.2f (%.2f) TDC %.2f (%.2f) Int %d (%d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d) %.2f %.2f %.2f %.2f %d %d",pmNumber, adc[pmNumber],
+ digit->ChargeADC(11)+digit->ChargeADC(10)+digit->ChargeADC(9)+digit->ChargeADC(8)+
+ digit->ChargeADC(7)+digit->ChargeADC(6)+digit->ChargeADC(5)+digit->ChargeADC(4)-
+ 4.*fCalibData->GetPedestal(pmNumber)-4.*fCalibData->GetPedestal(pmNumber+64),
+ digit->Time(),time[pmNumber],
+ integrator,
+ digit->ChargeADC(0),digit->ChargeADC(1),digit->ChargeADC(2),digit->ChargeADC(3),digit->ChargeADC(4),digit->ChargeADC(5),digit->ChargeADC(6),digit->ChargeADC(7),
+ digit->ChargeADC(8),digit->ChargeADC(9),digit->ChargeADC(10),
+ digit->ChargeADC(11),digit->ChargeADC(12),
+ digit->ChargeADC(13),digit->ChargeADC(14),digit->ChargeADC(15),digit->ChargeADC(16),digit->ChargeADC(17),digit->ChargeADC(18),digit->ChargeADC(19),digit->ChargeADC(20),
+ 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());
- if (adc[pmNumber] > 0) AliDebug(1,Form("PM = %d ADC = %f TDC %f Int %d (%d %d %d %d %d) %f %f %f %f %d %d",pmNumber, adc[pmNumber],digit->Time(),
- 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]));
-
- if(adc[pmNumber] > (fCalibData->GetPedestal(k) + GetRecoParam()->GetNSigmaPed()*fCalibData->GetSigma(k))) {
- mult[pmNumber] += adc[pmNumber]*fCalibData->GetMIPperADC(pmNumber);
- }
} // end of loop over digits
} // end of loop over events in digits tree
fESDVZERO->SetADC(adc);
fESDVZERO->SetTime(time);
fESDVZERO->SetWidth(width);
+ 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) {
if (adc < 1e-6) return time;
// Slewing correction
- Float_t thr = fCalibData->GetDiscriThr(i);
+ Float_t thr = fCalibData->GetCalibDiscriThr(i,kTRUE);
time -= fTimeSlewing->Eval(adc/thr);
return time;