#include "AliVZEROTriggerMask.h"
#include "AliESDfriend.h"
#include "AliESDVZEROfriend.h"
+#include "AliVZEROdigit.h"
+#include "AliVZEROCalibData.h"
+#include "AliRunInfo.h"
ClassImp(AliVZEROReconstructor)
fESDVZEROfriend(0x0),
fCalibData(GetCalibData()),
fCollisionMode(0),
- fBeamEnergy(0.)
+ fBeamEnergy(0.),
+ fDigitsArray(0)
{
// Default constructor
// Get calibration data
delete fESDVZERO;
delete fESDVZEROfriend;
+ delete fDigitsArray;
}
//_____________________________________________________________________________
//______________________________________________________________________
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()) {
- Int_t ADC_max[64], adc[64], time[64], width[64], BBFlag[64], BGFlag[64];
+ if (rawStream.Next()) {
+ Float_t adc[64];
+ Float_t time[64], width[64];
+ Bool_t BBFlag[64], BGFlag[64], integrator[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;
- Int_t imax = 0;
- for(Int_t iClock=0; iClock<21; iClock++){
- if((Int_t)rawStream.GetPedestal(i,iClock) > ADC_max[i])
- {ADC_max[i]=(Int_t)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);
+ 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++){
+ 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));
+ 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->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));
+ fESDVZEROfriend->SetTime(j,time[j]);
+ fESDVZEROfriend->SetWidth(j,width[j]);
}
// Filling the esd friend object
fESDVZEROfriend->SetTriggerInputsMask(rawStream.GetTriggerInputsMask());
for(Int_t iScaler = 0; iScaler < AliESDVZEROfriend::kNScalers; iScaler++)
- fESDVZEROfriend->SetTriggerScalers(iScaler,rawStream.GetTriggerScalers(iScaler));
+ fESDVZEROfriend->SetTriggerScalers(iScaler,rawStream.GetTriggerScalers(iScaler));
- for (Int_t iBunch = 0; iBunch < AliESDVZEROfriend::kNBunches; iBunch++)
- fESDVZEROfriend->SetBunchNumbersMB(iBunch,rawStream.GetBunchNumbersMB(iBunch));
+ 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()])
+ 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], BBFlag[iChannel], BGFlag[iChannel]);
- }
+ width[iChannel], BBFlag[iChannel], BGFlag[iChannel],integrator[iChannel]);
+
+ }
+ 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);
- Short_t Multiplicity[64];
Float_t mult[64];
- Short_t adc[64];
- Short_t time[64];
- Short_t width[64];
+ Float_t adc[64];
+ Float_t time[64];
+ Float_t width[64];
Bool_t BBFlag[64];
Bool_t BGFlag[64];
for (Int_t i=0; i<64; i++){
- adc[i] = 0;
+ adc[i] = 0.0;
mult[i] = 0.0;
- time[i] = 0;
- width[i] = 0;
+ time[i] = 0.0;
+ width[i] = 0.0;
BBFlag[i] = kFALSE;
BGFlag[i] = kFALSE;
}
for (Int_t e=0; e<nEntries; e++) {
digitsTree->GetEvent(e);
- Int_t nDigits = digitsArray->GetEntriesFast();
+ Int_t nDigits = fDigitsArray->GetEntriesFast();
for (Int_t d=0; d<nDigits; d++) {
- AliVZEROdigit* digit = (AliVZEROdigit*)digitsArray->At(d);
+ AliVZEROdigit* digit = (AliVZEROdigit*) fDigitsArray->At(d);
Int_t pmNumber = digit->PMNumber();
// Pedestal retrieval and suppression:
- Int_t pedestal = int(fCalibData->GetPedestal(d));
- adc[pmNumber] = (Short_t) digit->ADC() - pedestal;
- time[pmNumber] = (Short_t) digit->Time();
- width[pmNumber] = (Short_t) digit->Width();
- BBFlag[pmNumber]= digit->BBFlag();
- BGFlag[pmNumber]= digit->BGFlag();
- // printf("PM = %d, MIP per ADC channel = %f \n",pmNumber, fCalibData->GetMIPperADC(pmNumber));
- // cut of ADC at 1MIP/2
- if(fCollisionMode >0) {
- Float_t MIP = 2.0;
- if (adc[pmNumber] > (int(MIP) /2) ) mult[pmNumber] += float(adc[pmNumber])*(1.0/MIP) ;
- }
- else{
- if (adc[pmNumber] > (int(1.0/fCalibData->GetMIPperADC(pmNumber)) /2) )
- mult[pmNumber] += float(adc[pmNumber])*fCalibData->GetMIPperADC(pmNumber);
+ Bool_t integrator = digit->Integrator();
+ Int_t k = pmNumber+64*integrator;
+ Float_t pedestal = fCalibData->GetPedestal(k);
+ adc[pmNumber] = digit->ADC() - pedestal;
+ time[pmNumber] = digit->Time();
+ width[pmNumber] = digit->Width();
+ BBFlag[pmNumber]= digit->BBFlag();
+ BGFlag[pmNumber]= digit->BGFlag();
+
+ AliDebug(2,Form("PM = %d ADC = %f TDC %f",pmNumber, digit->ADC(),digit->Time()));
+
+ 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
-
- for (Int_t j=0; j<64; j++) Multiplicity[j] = short(mult[j]+0.5);
-
- fESDVZERO->SetMultiplicity(Multiplicity);
+
+ fESDVZERO->SetMultiplicity(mult);
fESDVZERO->SetADC(adc);
fESDVZERO->SetTime(time);
fESDVZERO->SetWidth(width);
TriggerMask->SetTimeWindowWidthBGA(20);
TriggerMask->SetTimeWindowWidthBBC(50);
TriggerMask->SetTimeWindowWidthBGC(20);
- TriggerMask->FillMasks(digitsTree,digitsArray);
+ TriggerMask->FillMasks(digitsTree, fDigitsArray);
fESDVZERO->SetBBtriggerV0A(TriggerMask->GetBBtriggerV0A());
fESDVZERO->SetBGtriggerV0A(TriggerMask->GetBGtriggerV0A());
fr->SetVZEROfriend(fESDVZEROfriend);
}
}
+
+ fDigitsArray->Clear();
}
//_____________________________________________________________________________
//____________________________________________________________________________
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<TMap*>(entry->GetObject()); // old GRP entry
- if(m){
- m->Print();
- grpData = new AliGRPObject();
- grpData->ReadValuesFromMap(m);
- }
- else{
- grpData = dynamic_cast<AliGRPObject*>(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));
}
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff