X-Git-Url: http://git.uio.no/git/?a=blobdiff_plain;f=VZERO%2FAliVZEROReconstructor.cxx;h=4829a7ba9e1b68bf920340e5ec0676444b5482f3;hb=1dead9dec94d602bb167042a91e992acaef607db;hp=60b63fd6008835c2b1f7ed2a9fc5fffb07d0460a;hpb=59063a181837c693d4185e8dbb7bc4ed4de8d20b;p=u%2Fmrichter%2FAliRoot.git diff --git a/VZERO/AliVZEROReconstructor.cxx b/VZERO/AliVZEROReconstructor.cxx index 60b63fd6008..4829a7ba9e1 100644 --- a/VZERO/AliVZEROReconstructor.cxx +++ b/VZERO/AliVZEROReconstructor.cxx @@ -23,23 +23,36 @@ #include "AliRunLoader.h" #include "AliRawReader.h" +#include "AliGRPObject.h" +#include "AliCDBManager.h" +#include "AliCDBStorage.h" +#include "AliCDBEntry.h" #include "AliVZEROReconstructor.h" #include "AliVZERORawStream.h" -#include "AliESD.h" +#include "AliESDEvent.h" +#include "AliVZEROTriggerMask.h" +#include "AliESDfriend.h" +#include "AliESDVZEROfriend.h" +#include "AliVZEROdigit.h" +#include "AliVZEROCalibData.h" +#include "AliRunInfo.h" ClassImp(AliVZEROReconstructor) //_____________________________________________________________________________ AliVZEROReconstructor:: AliVZEROReconstructor(): AliReconstructor(), - fESDVZERO(0x0), - fESD(0x0), - fRunLoader(0x0), - fCalibData(GetCalibData()) + fESDVZERO(0x0), + fESD(0x0), + fESDVZEROfriend(0x0), + fCalibData(GetCalibData()), + fCollisionMode(0), + fBeamEnergy(0.) { // Default constructor // Get calibration data // fCalibData = GetCalibData(); + } @@ -57,23 +70,26 @@ AliVZEROReconstructor& AliVZEROReconstructor::operator = AliVZEROReconstructor::~AliVZEROReconstructor() { // destructor - delete fESDVZERO; - + + delete fESDVZERO; + delete fESDVZEROfriend; } //_____________________________________________________________________________ -void AliVZEROReconstructor::Init(AliRunLoader* runLoader) +void AliVZEROReconstructor::Init() { // initializer - fRunLoader = runLoader; fESDVZERO = new AliESDVZERO; + fESDVZEROfriend = new AliESDVZEROfriend; + + GetCollisionMode(); // fCollisionMode =1 for Pb-Pb simulated data } //______________________________________________________________________ void AliVZEROReconstructor::ConvertDigits(AliRawReader* rawReader, TTree* digitsTree) const { -// converts to digits +// converts RAW to digits if (!digitsTree) { AliError("No digits tree!"); @@ -83,57 +99,146 @@ void AliVZEROReconstructor::ConvertDigits(AliRawReader* rawReader, TTree* digits TClonesArray* digitsArray = new TClonesArray("AliVZEROdigit"); digitsTree->Branch("VZERODigit", &digitsArray); + fESDVZEROfriend->Reset(); + rawReader->Reset(); AliVZERORawStream rawStream(rawReader); - while (rawStream.Next()) { - Int_t pmNumber = rawStream.GetCell(); - Int_t adc = rawStream.GetADC(); - Int_t time = rawStream.GetTime(); - new ((*digitsArray)[digitsArray->GetEntriesFast()]) - AliVZEROdigit(pmNumber,adc,time); - } + 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++) { + 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) + + 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); + 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,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)); + - digitsTree->Fill(); + // Channels(aliroot numbering) will be ordered in the tree + for(Int_t iChannel = 0; iChannel < 64; iChannel++) { + if(fCalibData->IsChannelDead(iChannel)){ + adc[iChannel] = (Float_t) kInvalidADC; + time[iChannel] = (Float_t) kInvalidTime; + } + if (adc[iChannel] > 0) + new ((*digitsArray)[digitsArray->GetEntriesFast()]) + AliVZEROdigit(iChannel, adc[iChannel], time[iChannel], + width[iChannel], BBFlag[iChannel], BGFlag[iChannel],integrator[iChannel]); + + } + digitsTree->Fill(); + } } //______________________________________________________________________ void AliVZEROReconstructor::FillESD(TTree* digitsTree, TTree* /*clustersTree*/, - AliESD* esd) const + AliESDEvent* esd) const { -// fills multiplicities to the ESD - +// fills multiplicities to the ESD - pedestal is now subtracted + if (!digitsTree) { - AliError("No digits tree!"); - return; + AliError("No digits tree!"); + return; } TClonesArray* digitsArray = NULL; TBranch* digitBranch = digitsTree->GetBranch("VZERODigit"); digitBranch->SetAddress(&digitsArray); - Int_t nbPMV0A = 0; - Int_t nbPMV0C = 0; - Int_t mTotV0A = 0; - Int_t mTotV0C = 0; - Float_t adcV0A = 0.0; - Float_t adcV0C = 0.0; - Float_t multV0A[4]; - Float_t multV0C[4]; - Int_t mRingV0A[4]; - Int_t mRingV0C[4]; - - Int_t adc[64]; - Float_t mip[64]; + Float_t mult[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; - mip[i] = 110.0;} - for (Int_t j=0; j<4; j++){ - multV0A[j] = 0.0; - multV0C[j] = 0.0; - mRingV0A[j] = 0; - mRingV0C[j] = 0;} + adc[i] = 0.0; + mult[i] = 0.0; + time[i] = 0.0; + width[i] = 0.0; + BBFlag[i] = kFALSE; + BGFlag[i] = kFALSE; + } - // loop over VZERO entries + // loop over VZERO entries to get multiplicity Int_t nEntries = (Int_t)digitsTree->GetEntries(); for (Int_t e=0; eGetEvent(e); @@ -141,51 +246,59 @@ void AliVZEROReconstructor::FillESD(TTree* digitsTree, TTree* /*clustersTree*/, Int_t nDigits = digitsArray->GetEntriesFast(); for (Int_t d=0; dAt(d); - Int_t pmNumber = digit->PMNumber(); - adc[pmNumber] = digit->ADC(); - // cut of ADC at MIP/2 - if (adc[pmNumber] > (mip[pmNumber]/2)) { - if (pmNumber<=31) { - if (pmNumber<=7) multV0C[0]=multV0C[0]+ float(adc[pmNumber])/mip[pmNumber]; - if (pmNumber>=8 && pmNumber<=15) multV0C[1]=multV0C[1]+ float(adc[pmNumber])/mip[pmNumber]; - if (pmNumber>=16 && pmNumber<=23) multV0C[2]=multV0C[2]+ float(adc[pmNumber])/mip[pmNumber]; - if (pmNumber>=24 && pmNumber<=31) multV0C[3]=multV0C[3]+ float(adc[pmNumber])/mip[pmNumber]; - adcV0C = adcV0C + float(adc[pmNumber])/mip[pmNumber]; - nbPMV0C++; - } - if (pmNumber>=32 ) { - if (pmNumber>=32 && pmNumber<=39) multV0A[0]=multV0A[0]+ float(adc[pmNumber])/mip[pmNumber]; - if (pmNumber>=40 && pmNumber<=47) multV0A[1]=multV0A[1]+ float(adc[pmNumber])/mip[pmNumber]; - if (pmNumber>=48 && pmNumber<=55) multV0A[2]=multV0A[2]+ float(adc[pmNumber])/mip[pmNumber]; - if (pmNumber>=56 && pmNumber<=63) multV0A[3]=multV0A[3]+ float(adc[pmNumber])/mip[pmNumber]; - adcV0A = adcV0A + float(adc[pmNumber])/mip[pmNumber]; - nbPMV0A++; - } - } + AliVZEROdigit* digit = (AliVZEROdigit*)digitsArray->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; + 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 - - mTotV0A = int(adcV0A + 0.5); - mTotV0C = int(adcV0C + 0.5); - for (Int_t j=0; j<4; j++){ - mRingV0A[j] = int(multV0A[j] + 0.5); - mRingV0C[j] = int(multV0C[j] + 0.5);} - - AliDebug(1,Form("VZERO multiplicities : %d (V0A) %d (V0C)", mTotV0A, mTotV0C)); - AliDebug(1,Form("Number of PMs fired : %d (V0A) %d (V0C)", nbPMV0A, nbPMV0C)); - - fESDVZERO->SetNbPMV0A(nbPMV0A); - fESDVZERO->SetNbPMV0C(nbPMV0C); - fESDVZERO->SetMTotV0A(mTotV0A); - fESDVZERO->SetMTotV0C(mTotV0C); - fESDVZERO->SetMRingV0A(mRingV0A); - fESDVZERO->SetMRingV0C(mRingV0C); + + 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()); if (esd) { - AliDebug(1, Form("Writing VZERO data to ESD tree")); - esd->SetVZEROData(fESDVZERO); + AliDebug(1, Form("Writing VZERO data to ESD tree")); + esd->SetVZEROData(fESDVZERO); + } + + if (esd) { + AliESDfriend *fr = (AliESDfriend*)esd->FindListObject("AliESDfriend"); + if (fr) { + AliDebug(1, Form("Writing VZERO friend data to ESD tree")); + fr->SetVZEROfriend(fESDVZEROfriend); + } } } @@ -208,13 +321,41 @@ AliCDBStorage* AliVZEROReconstructor::SetStorage(const char *uri) AliCDBStorage *storage = manager->GetDefaultStorage(); if(deleteManager){ - AliCDBManager::Instance()->UnsetDefaultStorage(); - defstorage = 0; // the storage is killed by AliCDBManager::Instance()->Destroy() + AliCDBManager::Instance()->UnsetDefaultStorage(); + defstorage = 0; // the storage is killed by AliCDBManager::Instance()->Destroy() } return storage; } +//____________________________________________________________________________ +void AliVZEROReconstructor::GetCollisionMode() +{ + // Retrieval of collision mode + + TString beamType = GetRunInfo()->GetBeamType(); + if(beamType==AliGRPObject::GetInvalidString()){ + AliError("VZERO cannot retrieve beam type"); + return; + } + + 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; + } + + fBeamEnergy = GetRunInfo()->GetBeamEnergy(); + if(fBeamEnergy==AliGRPObject::GetInvalidFloat()) { + AliError("Missing value for the beam energy ! Using 0"); + fBeamEnergy = 0.; + } + + AliDebug(1,Form("\n ++++++ Beam type and collision mode retrieved as %s %d @ %1.3f GeV ++++++\n\n",beamType.Data(), fCollisionMode, fBeamEnergy)); + +} + //_____________________________________________________________________________ AliVZEROCalibData* AliVZEROReconstructor::GetCalibData() const { @@ -230,7 +371,7 @@ AliVZEROCalibData* AliVZEROReconstructor::GetCalibData() const // 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") +// entry = man->GetStorage("local://$ALICE_ROOT/OCDB") // ->Get("VZERO/Calib/Data",runNumber); // // } @@ -244,3 +385,4 @@ AliVZEROCalibData* AliVZEROReconstructor::GetCalibData() const return calibdata; } +