X-Git-Url: http://git.uio.no/git/?a=blobdiff_plain;f=VZERO%2FAliVZEROQADataMakerRec.cxx;h=761cb64088a9b58e5fb9a35c1bc83b9b8336f32d;hb=934558d8d2bc39c2a79fe1cad461525bdba0515b;hp=e3d0cbc7896aae656a5268c7da20ad627bc89581;hpb=4e25ac795836afea113484651fe7e4a9d3d2c95a;p=u%2Fmrichter%2FAliRoot.git diff --git a/VZERO/AliVZEROQADataMakerRec.cxx b/VZERO/AliVZEROQADataMakerRec.cxx index e3d0cbc7896..761cb64088a 100644 --- a/VZERO/AliVZEROQADataMakerRec.cxx +++ b/VZERO/AliVZEROQADataMakerRec.cxx @@ -22,12 +22,14 @@ // --- ROOT system --- #include #include +#include #include #include #include -#include +#include #include #include +#include // --- Standard library --- @@ -41,42 +43,79 @@ #include "AliQAChecker.h" #include "AliRawReader.h" #include "AliVZERORawStream.h" +#include "AliVZEROdigit.h" +#include "AliVZEROConst.h" #include "AliVZEROReconstructor.h" +#include "AliVZEROTrending.h" +#include "AliVZEROCalibData.h" +#include "AliVZEROTriggerData.h" +#include "AliCTPTimeParams.h" #include "event.h" +const Float_t kMinBBA = 68. ; +const Float_t kMaxBBA = 100. ; +const Float_t kMinBBC = 75.5 ; +const Float_t kMaxBBC = 100. ; +const Float_t kMinBGA = 54. ; +const Float_t kMaxBGA = 58. ; +const Float_t kMinBGC = 69.5 ; +const Float_t kMaxBGC = 74. ; + + + + ClassImp(AliVZEROQADataMakerRec) //____________________________________________________________________________ - AliVZEROQADataMakerRec::AliVZEROQADataMakerRec() : - AliQADataMakerRec(AliQAv1::GetDetName(AliQAv1::kVZERO), "VZERO Quality Assurance Data Maker"), - fCalibData(0x0), - fEvent(0) +AliVZEROQADataMakerRec::AliVZEROQADataMakerRec() : +AliQADataMakerRec(AliQAv1::GetDetName(AliQAv1::kVZERO), "VZERO Quality Assurance Data Maker"), + fCalibData(0x0), + fTriggerData(0x0), +// fEvent(0), +// fNTotEvents(0), +// fNSubEvents(0), +// fTrendingUpdateEvent(0), +// fNTrendingUpdates(0), + fTrendingUpdateTime(0), + fCycleStartTime(0), + fCycleStopTime(0), + fTimeSlewing(0) { - // Constructor + // Constructor - AliInfo("Construct VZERO QA Object"); - - for(Int_t i=0; i<64; i++){ - fEven[i] = 0; - fOdd[i] = 0; } + AliDebug(AliQAv1::GetQADebugLevel(), "Construct VZERO QA Object"); + + for(Int_t i=0; i<64; i++){ + fEven[i] = 0; + fOdd[i] = 0; + } - for(Int_t i=0; i<128; i++){ - fADCmean[i] = 0.0; } + for(Int_t i=0; i<128; i++){ + fADCmean[i] = 0.0; } } //____________________________________________________________________________ - AliVZEROQADataMakerRec::AliVZEROQADataMakerRec(const AliVZEROQADataMakerRec& qadm) : +AliVZEROQADataMakerRec::AliVZEROQADataMakerRec(const AliVZEROQADataMakerRec& qadm) : AliQADataMakerRec(), - fCalibData(0x0), - fEvent(0) + fCalibData(0x0), + fTriggerData(0x0), + // fEvent(0), + // fNTotEvents(0), + // fNSubEvents(0), + // fTrendingUpdateEvent(0), + // fNTrendingUpdates(0), + fTrendingUpdateTime(0), + fCycleStartTime(0), + fCycleStopTime(0), + fTimeSlewing(0) { // Copy constructor - SetName((const char*)qadm.GetName()) ; - SetTitle((const char*)qadm.GetTitle()); + SetName((const char*)qadm.GetName()) ; + SetTitle((const char*)qadm.GetTitle()); } //__________________________________________________________________ @@ -93,63 +132,46 @@ AliVZEROQADataMakerRec& AliVZEROQADataMakerRec::operator = (const AliVZEROQAData AliVZEROCalibData* AliVZEROQADataMakerRec::GetCalibData() const { - AliCDBManager *man = AliCDBManager::Instance(); + AliCDBManager *man = AliCDBManager::Instance(); - AliCDBEntry *entry=0; + AliCDBEntry *entry=0; - entry = man->Get("VZERO/Calib/Data",fRun); - if(!entry){ - AliWarning("Load of calibration data from default storage failed!"); - AliWarning("Calibration data will be loaded from local storage ($ALICE_ROOT)"); + entry = man->Get("VZERO/Calib/Data",fRun); + if(!entry){ + AliWarning("Load of calibration data from default storage failed!"); + AliWarning("Calibration data will be loaded from local storage ($ALICE_ROOT)"); - man->SetDefaultStorage("local://$ALICE_ROOT/OCDB"); - entry = man->Get("VZERO/Calib/Data",fRun); - } - // Retrieval of data in directory VZERO/Calib/Data: + man->SetDefaultStorage("local://$ALICE_ROOT/OCDB"); + entry = man->Get("VZERO/Calib/Data",fRun); + } + // Retrieval of data in directory VZERO/Calib/Data: - AliVZEROCalibData *calibdata = 0; + AliVZEROCalibData *calibdata = 0; - if (entry) calibdata = (AliVZEROCalibData*) entry->GetObject(); - if (!calibdata) AliFatal("No calibration data from calibration database !"); + if (entry) calibdata = (AliVZEROCalibData*) entry->GetObject(); + if (!calibdata) AliFatal("No calibration data from calibration database !"); - return calibdata; + return calibdata; } - - //____________________________________________________________________________ void AliVZEROQADataMakerRec::EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray ** list) { // Detector specific actions at end of cycle // Does the QA checking - + ResetEventTrigClasses(); + // AliQAChecker::Instance()->Run(AliQAv1::kVZERO, task, list) ; + + if(task == AliQAv1::kRAWS){ + TTimeStamp currentTime; + fCycleStopTime = currentTime.GetSec(); + } for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) { - SetEventSpecie(specie) ; - if(task == AliQAv1::kRAWS){ - int nMaxBin = GetRawsData(kPedestalTimeInt0)->GetNbinsY(); - if(fCurrentCycle%nMaxBin==0) { - GetRawsData(kPedestalTimeInt0)->Reset(); - GetRawsData(kPedestalTimeInt1)->Reset(); - GetRawsData(kChargeEoITimeInt0)->Reset(); - GetRawsData(kChargeEoITimeInt1)->Reset(); - } - TH1D* hProj; - char name[50]; - for(Int_t iChannel=0; iChannel<64; iChannel++) { - for(Int_t integrator=0;integrator<2;integrator++){ - sprintf(name,"Ped_%d_%d",iChannel,integrator); - hProj = ((TH2I*)GetRawsData((integrator == 0 ? kPedestalCycleInt0 : kPedestalCycleInt1)))->ProjectionY(name,iChannel+1,iChannel+1); - ((TH2D*)GetRawsData((integrator == 0 ? kPedestalTimeInt0 : kPedestalTimeInt1)))->Fill((double)iChannel,(double)(fCurrentCycle%nMaxBin),(double)hProj->GetMean()); - delete hProj; - - sprintf(name,"Charge_%d_%d",iChannel,integrator); - hProj = ((TH2I*)GetRawsData((integrator == 0 ? kChargeEoICycleInt0 : kChargeEoICycleInt1)))->ProjectionY(name,iChannel+1,iChannel+1); - ((TH2D*)GetRawsData((integrator == 0 ? kChargeEoITimeInt0 : kChargeEoITimeInt1)))->Fill((double)iChannel,(double)(fCurrentCycle%nMaxBin),hProj->GetMean()); - delete hProj; - } - } + if (! IsValidEventSpecie(specie, list)) continue ; + SetEventSpecie(AliRecoParam::ConvertIndex(specie)); + if(task == AliQAv1::kRAWS) { } else if (task == AliQAv1::kESDS) { } } @@ -160,271 +182,322 @@ void AliVZEROQADataMakerRec::InitESDs() { // Creates histograms to control ESDs - Bool_t expert = kTRUE ; + const Bool_t expert = kTRUE ; + const Bool_t image = kTRUE ; - TH2D * h2d; + TH2F * h2d; TH1I * h1i; - TH1D * h1d; + TH1F * h1d; - h1i = new TH1I("H1I_Cell_Multiplicity_V0A", "Cell Multiplicity in V0A", 35, 0, 35) ; - h1i->GetXaxis()->SetTitle("Multiplicity (Nb of Cell)"); - Add2ESDsList(h1i, kCellMultiV0A, !expert) ; + h1i = new TH1I("H1I_Cell_Multiplicity_V0A", "Cell Multiplicity in V0A;Multiplicity (Nb of Cell);Counts", 35, 0, 35) ; + Add2ESDsList(h1i, kCellMultiV0A, !expert, image) ; - h1i = new TH1I("H1I_Cell_Multiplicity_V0C", "Cell Multiplicity in V0C", 35, 0, 35) ; - h1i->GetXaxis()->SetTitle("Multiplicity (Nb of Cell)"); - Add2ESDsList(h1i, kCellMultiV0C, !expert) ; + h1i = new TH1I("H1I_Cell_Multiplicity_V0C", "Cell Multiplicity in V0;Multiplicity (Nb of Cell);Counts", 35, 0, 35) ; + Add2ESDsList(h1i, kCellMultiV0C, !expert, image) ; - h1d = new TH1D("H1D_MIP_Multiplicity_V0A", "MIP Multiplicity in V0A", 1000, 0, 1000) ; - h1d->GetXaxis()->SetTitle("Multiplicity (Nb of MIP)"); - Add2ESDsList(h1d, kMIPMultiV0A, !expert) ; + h1d = new TH1F("H1D_MIP_Multiplicity_V0A", "MIP Multiplicity in V0A;Multiplicity (Nb of MIP);Counts", 1000, 0, 1000) ; + Add2ESDsList(h1d, kMIPMultiV0A, !expert, image) ; - h1d = new TH1D("H1D_MIP_Multiplicity_V0C", "MIP Multiplicity in V0C", 1000, 0, 1000) ; - h1d->GetXaxis()->SetTitle("Multiplicity (Nb of MIP)"); - Add2ESDsList(h1d, kMIPMultiV0C, !expert) ; - - h2d = new TH2D("H2D_MIP_Multiplicity_Channel", "MIP Multiplicity per Channel",64, 0, 64, 100, 0, 100) ; - h2d->GetXaxis()->SetTitle("Channel"); - h2d->GetYaxis()->SetTitle("Multiplicity (Nb of MIP)"); - Add2ESDsList(h2d, kMIPMultiChannel, !expert) ; + h1d = new TH1F("H1D_MIP_Multiplicity_V0C", "MIP Multiplicity in V0C;Multiplicity (Nb of MIP);Counts", 1000, 0, 1000) ; + Add2ESDsList(h1d, kMIPMultiV0C, !expert, image) ; + + h2d = new TH2F("H2D_MIP_Multiplicity_Channel", "MIP Multiplicity per Channel;Channel;Multiplicity (Nb of MIP)",64, 0, 64, 100, 0, 100) ; + Add2ESDsList(h2d, kMIPMultiChannel, !expert, image) ; - h1d = new TH1D("H1D_BBFlag_Counters", "BB Flag Counters",64, 0, 64) ; - h1d->GetXaxis()->SetTitle("Channel"); - Add2ESDsList(h1d, kBBFlag, !expert) ; + h1d = new TH1F("H1D_BBFlag_Counters", "BB Flag Counters;Channel;Counts",64, 0, 64) ; + Add2ESDsList(h1d, kBBFlag, !expert, image) ; - h1d = new TH1D("H1D_BGFlag_Counters", "BG Flag Counters",64, 0, 64) ; - h1d->GetXaxis()->SetTitle("Channel"); - Add2ESDsList(h1d, kBGFlag, !expert) ; + h1d = new TH1F("H1D_BGFlag_Counters", "BG Flag Counters;Channel;Counts",64, 0, 64) ; + Add2ESDsList(h1d, kBGFlag, !expert, image) ; - h2d = new TH2D("H2D_Charge_Channel", "ADC Charge per channel",64, 0, 64, 1024, 0, 1024) ; - h2d->GetXaxis()->SetTitle("Channel"); - h2d->GetYaxis()->SetTitle("Charge (ADC counts)"); - Add2ESDsList(h2d, kChargeChannel, !expert) ; + h2d = new TH2F("H2D_Charge_Channel", "ADC Charge per channel;Channel;Charge (ADC counts)",64, 0, 64, 1024, 0, 1024) ; + Add2ESDsList(h2d, kChargeChannel, !expert, image) ; - h2d = new TH2D("H2D_Time_Channel", "Time per channel",64, 0, 64, 820, 0, 410) ; - h2d->GetXaxis()->SetTitle("Channel"); - h2d->GetYaxis()->SetTitle("Time (ns)"); - Add2ESDsList(h2d, kTimeChannel, !expert) ; + h2d = new TH2F("H2D_Time_Channel", "Time per channel;Channel;Time (ns)",64, 0, 64, 400, -100, 100) ; + Add2ESDsList(h2d, kTimeChannel, !expert, image) ; - h1d = new TH1D("H1D_V0A_Time", "Mean V0A Time",2048, 0., 409.6); - h1d->GetXaxis()->SetTitle("Time (ns)"); - Add2ESDsList(h1d,kESDV0ATime, !expert); + h1d = new TH1F("H1D_V0A_Time", "Mean V0A Time;Time (ns);Counts",1000, -100., 100.); + Add2ESDsList(h1d,kESDV0ATime, !expert, image); - h1d = new TH1D("H1D_V0C_Time", "Mean V0C Time",2048, 0., 409.6); - h1d->GetXaxis()->SetTitle("Time (ns)"); - Add2ESDsList(h1d,kESDV0CTime, !expert); + h1d = new TH1F("H1D_V0C_Time", "Mean V0C Time;Time (ns);Counts",1000, -100., 100.); + Add2ESDsList(h1d,kESDV0CTime, !expert, image); - h1d = new TH1D("H1D_Diff_Time", "Diff Time V0A - V0C",2*2048, -409.6, 409.6); - h1d->GetXaxis()->SetTitle("Diff Time V0A - V0C (ns)"); - Add2ESDsList(h1d,kESDDiffTime, !expert); - + h1d = new TH1F("H1D_Diff_Time", "Diff Time V0A - V0C;Diff Time V0A - V0C (ns);Counts",1000, -200., 200.); + Add2ESDsList(h1d,kESDDiffTime, !expert, image); + // + ClonePerTrigClass(AliQAv1::kESDS); // this should be the last line } //____________________________________________________________________________ - void AliVZEROQADataMakerRec::InitRaws() - { - // Creates RAW histograms in Raws subdir - - Bool_t expert = kTRUE ; - Bool_t saveCorr = kTRUE ; +void AliVZEROQADataMakerRec::InitRaws() +{ + // Creates RAW histograms in Raws subdir + + const Bool_t expert = kTRUE ; + const Bool_t saveCorr = kTRUE ; + const Bool_t image = kTRUE ; - char name[50] , title[100]; const Int_t kNintegrator = 2; - const Int_t kNTdcTimeBins = 2048; - const Int_t kTdcTimeMin = 0; - const Int_t kTdcTimeMax = 4096; - const Int_t kNTdcWidthBins = 128; - const Int_t kTdcWidthMin = 0; - const Int_t kTdcWidthMax = 128; + const Int_t kNTdcTimeBins = 1280; + const Float_t kTdcTimeMin = 0.; + const Float_t kTdcTimeMax = 75.; + const Int_t kNTdcWidthBins = 256; + const Float_t kTdcWidthMin = 0; + const Float_t kTdcWidthMax = 200.; const Int_t kNChargeBins = 1024; - const Int_t kChargeMin = 0; - const Int_t kChargeMax = 1024; + const Float_t kChargeMin = 0; + const Float_t kChargeMax = 1024; const Int_t kNChannelBins = 64; - const Int_t kChannelMin = 0; - const Int_t kChannelMax = 64; + const Float_t kChannelMin = 0; + const Float_t kChannelMax = 64; const Int_t kNPedestalBins = 200; - const Int_t kPedestalMin = 0; - const Int_t kPedestalMax = 200; - const Int_t kTimeMin = 0; - const Int_t kTimeMax = 100; - const Int_t kNMIPBins = 200; - const Int_t kMIPMin = 0; - const Int_t kMIPMax = 200; + const Float_t kPedestalMin = 0; + const Float_t kPedestalMax = 200; + const Int_t kNMIPBins = 512; + const Float_t kMIPMin = 0; + const Float_t kMIPMax = 16; TH2I * h2i; - TH2D * h2d; + TH2F * h2d; TH1I * h1i; - TH1D * h1d; + TH1F * h1d; int iHisto =0; - - // Creation of Cell Multiplicity Histograms - h1i = new TH1I("H1I_Multiplicity_V0A", "Cell Multiplicity in V0A", 35, 0, 35) ; - Add2RawsList(h1i,kMultiV0A, !expert, saveCorr); iHisto++; - h1i = new TH1I("H1I_Multiplicity_V0C", "Cell Multiplicity in V0C", 35, 0, 35) ; - Add2RawsList(h1i,kMultiV0C, !expert, saveCorr); iHisto++; + // Creation of Trigger Histogram + h1d = new TH1F("H1D_Trigger_Type", "V0 Trigger Type;;Counts", 4,0 ,4) ; + Add2RawsList(h1d,kTriggers, !expert, image, saveCorr); iHisto++; + h1d->SetFillColor(29); + h1d->SetLineWidth(2); + h1d->GetXaxis()->SetLabelSize(0.06); + h1d->GetXaxis()->SetNdivisions(808,kFALSE); + h1d->GetXaxis()->SetBinLabel(1, "V0-AND"); + h1d->GetXaxis()->SetBinLabel(2, "V0-OR"); + h1d->GetXaxis()->SetBinLabel(3, "V0-BGA"); + h1d->GetXaxis()->SetBinLabel(4, "V0-BGC"); + + h2d = new TH2F("H2D_Trigger_Type", "V0 Trigger Type;V0A;V0C", 4,0 ,4,4,0,4) ; + Add2RawsList(h2d,kTriggers2, !expert, image, saveCorr); iHisto++; + h2d->SetOption("coltext"); + h2d->GetXaxis()->SetLabelSize(0.06); + h2d->GetXaxis()->SetNdivisions(808,kFALSE); + h2d->GetYaxis()->SetNdivisions(808,kFALSE); + h2d->GetXaxis()->SetBinLabel(1, "Empty"); + h2d->GetXaxis()->SetBinLabel(2, "Fake"); + h2d->GetXaxis()->SetBinLabel(3, "BB"); + h2d->GetXaxis()->SetBinLabel(4, "BG"); + h2d->GetYaxis()->SetBinLabel(1, "Empty"); + h2d->GetYaxis()->SetBinLabel(2, "Fake"); + h2d->GetYaxis()->SetBinLabel(3, "BB"); + h2d->GetYaxis()->SetBinLabel(4, "BG"); + + // Creation of Cell Multiplicity Histograms + h1i = new TH1I("H1I_Multiplicity_V0A", "Cell Multiplicity in V0A;# of Cells;Entries", 35, 0, 35) ; + Add2RawsList(h1i,kMultiV0A, expert, image, saveCorr); iHisto++; + h1i = new TH1I("H1I_Multiplicity_V0C", "Cell Multiplicity in V0C;# of Cells;Entries", 35, 0, 35) ; + Add2RawsList(h1i,kMultiV0C, expert, image, saveCorr); iHisto++; // Creation of Total Charge Histograms - h1d = new TH1D("H1D_Charge_V0A", "Total Charge in V0A", 2048, 0, 32768) ; - Add2RawsList(h1d,kChargeV0A, !expert, saveCorr); iHisto++; - h1d = new TH1D("H1D_Charge_V0C", "Total Charge in V0C", 2048, 0, 32768) ; - Add2RawsList(h1d,kChargeV0C, !expert, saveCorr); iHisto++; - h1d = new TH1D("H1D_Charge_V0", "Total Charge in V0", 2048, 0, 65536) ; - Add2RawsList(h1d,kChargeV0, !expert, saveCorr); iHisto++; + h1d = new TH1F("H1D_Charge_V0A", "Total Charge in V0A;Charge [ADC counts];Counts", 4000, 0, 30000) ; + Add2RawsList(h1d,kChargeV0A, expert, !image, saveCorr); iHisto++; + h1d = new TH1F("H1D_Charge_V0C", "Total Charge in V0C;Charge [ADC counts];Counts", 4000, 0, 50000) ; + Add2RawsList(h1d,kChargeV0C, expert, !image, saveCorr); iHisto++; + h1d = new TH1F("H1D_Charge_V0", "Total Charge in V0;Charge [ADC counts];Counts", 4000, 0, 80000) ; + Add2RawsList(h1d,kChargeV0, expert, !image, saveCorr); iHisto++; // Creation of MIP Histograms - h1d = new TH1D("H1D_MIP_V0A", "Total MIP in V0A", 2*kNMIPBins,kMIPMin ,32*kMIPMax) ; - Add2RawsList(h1d,kRawMIPV0A, !expert, saveCorr); iHisto++; - h1d = new TH1D("H1D_MIP_V0C", "Total MIP in V0C", 2*kNMIPBins,kMIPMin ,32*kMIPMax) ; - Add2RawsList(h1d,kRawMIPV0C, !expert, saveCorr); iHisto++; - h1d = new TH1D("H1D_MIP_V0", "Total MIP in V0", 2*kNMIPBins,kMIPMin ,32*kMIPMax) ; - Add2RawsList(h1d,kRawMIPV0, !expert, saveCorr); iHisto++; - h2d = new TH2D("H2D_MIP_Channel", "Nb of MIP per channel", kNChannelBins, kChannelMin, kChannelMax,kNMIPBins,kMIPMin ,kMIPMax) ; - Add2RawsList(h2d,kRawMIPChannel, expert, !saveCorr); iHisto++; + h1d = new TH1F("H1D_MIP_V0A", "Total MIP in V0A;Multiplicity [MIP];Counts", kNMIPBins,kMIPMin ,32*kMIPMax) ; + Add2RawsList(h1d,kRawMIPV0A, expert, !image, saveCorr); iHisto++; + h1d = new TH1F("H1D_MIP_V0C", "Total MIP in V0C;Multiplicity [MIP];Counts", kNMIPBins,kMIPMin ,32*kMIPMax) ; + Add2RawsList(h1d,kRawMIPV0C, expert, !image, saveCorr); iHisto++; + h1d = new TH1F("H1D_MIP_V0", "Total MIP in V0;Multiplicity [MIP];Counts", 2*kNMIPBins,kMIPMin ,64*kMIPMax) ; + Add2RawsList(h1d,kRawMIPV0, expert, !image, saveCorr); iHisto++; + h2d = new TH2F("H2D_MIP_Channel", "Nb of MIP per channel;Channel;# of Mips", kNChannelBins, kChannelMin, kChannelMax,kNMIPBins,kMIPMin ,kMIPMax) ; + Add2RawsList(h2d,kRawMIPChannel, expert, !image, !saveCorr); iHisto++; - for(Int_t iInt=0;iIntSetMinimum(0); + Add2RawsList(h1d,kBBFlagsPerChannel, !expert, image, !saveCorr); iHisto++; + + h2d = new TH2F("H2D_BBFlagVsClock", "BB-Flags Versus LHC-Clock;Channel;LHC Clocks",kNChannelBins, kChannelMin, kChannelMax,21, -10.5, 10.5 ); + Add2RawsList(h2d,kBBFlagVsClock, expert, !image, !saveCorr); iHisto++; - // Creation of Flag versus LHC Clock histograms - sprintf(name,"H2D_BBFlagVsClock"); - sprintf(title,"BB-Flags Versus LHC-Clock"); - h2d = new TH2D(name, title,kNChannelBins, kChannelMin, kChannelMax,21, -10.5, 10.5 ); - Add2RawsList(h2d,kBBFlagVsClock, expert, !saveCorr); iHisto++; + h2d = new TH2F("H2D_BGFlagVsClock", "BG-Flags Versus LHC-Clock;Channel;LHC Clocks",kNChannelBins, kChannelMin, kChannelMax,21, -10.5, 10.5 ); + Add2RawsList(h2d,kBGFlagVsClock, expert, !image, !saveCorr); iHisto++; + // + // Creation of histograms with the charge sums used inthe centrality triggers + h2d = new TH2F("H2D_CentrChargeV0A_V0C","Trigger charge sums V0C vs V0A; V0A Charge Sum [ADC counts]; V0C Charge Sum [ADC counts];", + 300,0,15000,500,0,25000); + Add2RawsList(h2d,kCentrChargeV0AV0C, !expert, image, saveCorr); iHisto++; + + AliDebug(AliQAv1::GetQADebugLevel(), Form("%d Histograms has been added to the Raws List",iHisto)); + // + ClonePerTrigClass(AliQAv1::kRAWS); // this should be the last line +} + +//____________________________________________________________________________ +void AliVZEROQADataMakerRec::InitDigits() +{ + // create Digits histograms in Digits subdir + const Bool_t expert = kTRUE ; + const Bool_t image = kTRUE ; + + TH1I *fhDigTDC[64]; + TH1I *fhDigADC[64]; + + // create Digits histograms in Digits subdir + TH1I * h0 = new TH1I("hDigitMultiplicity", "Digits multiplicity distribution in VZERO;# of Digits;Entries", 100, 0, 99) ; + h0->Sumw2() ; + Add2DigitsList(h0, 0, !expert, image) ; + + for (Int_t i=0; i<64; i++) + { + fhDigTDC[i] = new TH1I(Form("hDigitTDC%d", i),Form("Digit TDC in cell %d; TDC value;Entries",i),300,0.,149.); + + fhDigADC[i]= new TH1I(Form("hDigitADC%d",i),Form("Digit ADC in cell %d;ADC value;Entries",i),1024,0.,1023.); + + Add2DigitsList(fhDigTDC[i],i+1, !expert, image); + Add2DigitsList(fhDigADC[i],i+1+64, !expert, image); + } + // + ClonePerTrigClass(AliQAv1::kDIGITS); // this should be the last line +} + +//____________________________________________________________________________ +void AliVZEROQADataMakerRec::MakeDigits() +{ + // makes data from Digits + + FillDigitsData(0,fDigitsArray->GetEntriesFast()) ; + TIter next(fDigitsArray) ; + AliVZEROdigit *aVZERODigit ; + while ( (aVZERODigit = dynamic_cast(next())) ) { + Int_t aPMNumber = aVZERODigit->PMNumber(); + FillDigitsData(aPMNumber +1, aVZERODigit->Time()) ; // in 100 of picoseconds + FillDigitsData(aPMNumber +1+64, aVZERODigit->ADC()) ; + } +} + + +//____________________________________________________________________________ +void AliVZEROQADataMakerRec::MakeDigits(TTree *digitTree) +{ + // makes data from Digit Tree - sprintf(name,"H2D_BGFlagVsClock"); - sprintf(title,"BG-Flags Versus LHC-Clock"); - h2d = new TH2D(name, title,kNChannelBins, kChannelMin, kChannelMax,21, -10.5, 10.5 ); - Add2RawsList(h2d,kBGFlagVsClock, expert, !saveCorr); iHisto++; - - AliInfo(Form("%d Histograms has been added to the Raws List",iHisto)); - } + if ( fDigitsArray ) + fDigitsArray->Clear() ; + else + fDigitsArray = new TClonesArray("AliVZEROdigit", 1000) ; + + TBranch * branch = digitTree->GetBranch("VZERODigit") ; + if ( ! branch ) { + AliWarning("VZERO branch in Digit Tree not found") ; + } else { + branch->SetAddress(&fDigitsArray) ; + branch->GetEntry(0) ; + MakeDigits() ; + } + // + IncEvCountCycleDigits(); + IncEvCountTotalDigits(); + // +} + //____________________________________________________________________________ void AliVZEROQADataMakerRec::MakeESDs(AliESDEvent * esd) @@ -434,68 +507,70 @@ void AliVZEROQADataMakerRec::MakeESDs(AliESDEvent * esd) UInt_t eventType = esd->GetEventType(); switch (eventType){ - case PHYSICS_EVENT: - AliESDVZERO *esdVZERO=esd->GetVZEROData(); + case PHYSICS_EVENT: + AliESDVZERO *esdVZERO=esd->GetVZEROData(); - if (!esdVZERO) break; + if (!esdVZERO) break; - GetESDsData(kCellMultiV0A)->Fill(esdVZERO->GetNbPMV0A()); - GetESDsData(kCellMultiV0C)->Fill(esdVZERO->GetNbPMV0C()); - GetESDsData(kMIPMultiV0A)->Fill(esdVZERO->GetMTotV0A()); - GetESDsData(kMIPMultiV0C)->Fill(esdVZERO->GetMTotV0C()); + FillESDsData(kCellMultiV0A,esdVZERO->GetNbPMV0A()); + FillESDsData(kCellMultiV0C,esdVZERO->GetNbPMV0C()); + FillESDsData(kMIPMultiV0A,esdVZERO->GetMTotV0A()); + FillESDsData(kMIPMultiV0C,esdVZERO->GetMTotV0C()); - Float_t timeV0A = 0., timeV0C = 0., diffTime; - Int_t iTimeV0A = 0, iTimeV0C = 0; - - for(Int_t i=0;i<64;i++) { - GetESDsData(kMIPMultiChannel)->Fill((Float_t) i,(Float_t) esdVZERO->GetMultiplicity(i)); - GetESDsData(kChargeChannel)->Fill((Float_t) i,(Float_t) esdVZERO->GetAdc(i)); - if(esdVZERO->GetBBFlag(i)) GetESDsData(kBBFlag)->Fill((Float_t) i); - if(esdVZERO->GetBGFlag(i)) GetESDsData(kBGFlag)->Fill((Float_t) i); - - Float_t time = (Float_t) esdVZERO->GetTime(i)/10.; //Convert in ns: 1 TDC channel = 100ps - GetESDsData(kTimeChannel)->Fill((Float_t) i,time); - - if(time>0.){ - if (i<32) { - iTimeV0C++; - timeV0C += time; - }else{ - iTimeV0A++; - timeV0A += time; - } - } - } - if(iTimeV0A>0) timeV0A /= iTimeV0A; - else timeV0A = -1.; - if(iTimeV0C>0) timeV0C /= iTimeV0C; - else timeV0C = -1.; - if(timeV0A<0. || timeV0C<0.) diffTime = -10000.; - else diffTime = timeV0A - timeV0C; + for(Int_t i=0;i<64;i++) { + FillESDsData(kMIPMultiChannel,(Float_t) i,(Float_t) esdVZERO->GetMultiplicity(i)); + FillESDsData(kChargeChannel,(Float_t) i,(Float_t) esdVZERO->GetAdc(i)); + if (i < 32) { + if(esdVZERO->BBTriggerV0C(i)) FillESDsData(kBBFlag,(Float_t) i); + if(esdVZERO->BGTriggerV0C(i)) FillESDsData(kBGFlag,(Float_t) i); + } + else { + if(esdVZERO->BBTriggerV0A(i-32)) FillESDsData(kBBFlag,(Float_t) i); + if(esdVZERO->BGTriggerV0A(i-32)) FillESDsData(kBGFlag,(Float_t) i); + } + Float_t time = (Float_t) esdVZERO->GetTime(i); //Convert in ns: 1 TDC channel = 100ps + FillESDsData(kTimeChannel,(Float_t) i,time); + } - GetESDsData(kESDV0ATime)->Fill(timeV0A); - GetESDsData(kESDV0CTime)->Fill(timeV0C); - GetESDsData(kESDDiffTime)->Fill(diffTime); + Float_t timeV0A = esdVZERO->GetV0ATime(); + Float_t timeV0C = esdVZERO->GetV0CTime(); + Float_t diffTime; + + if(timeV0A<-1024.+1.e-6 || timeV0C<-1024.+1.e-6) diffTime = -1024.; + else diffTime = timeV0A - timeV0C; + + FillESDsData(kESDV0ATime,timeV0A); + FillESDsData(kESDV0CTime,timeV0C); + FillESDsData(kESDDiffTime,diffTime); - break; - } - + break; + } + // + IncEvCountCycleESDs(); + IncEvCountTotalESDs(); + // } //____________________________________________________________________________ - void AliVZEROQADataMakerRec::MakeRaws(AliRawReader* rawReader) - { +void AliVZEROQADataMakerRec::MakeRaws(AliRawReader* rawReader) +{ // Fills histograms with Raws, computes average ADC values dynamically (pedestal subtracted) + + // Check id histograms already created for this Event Specie + if ( ! GetRawsData(kPedestalInt0) ) + InitRaws() ; + rawReader->Reset() ; AliVZERORawStream* rawStream = new AliVZERORawStream(rawReader); - rawStream->Next(); - + if(!(rawStream->Next())) return; + eventTypeType eventType = rawReader->GetType(); Int_t mulV0A = 0 ; Int_t mulV0C = 0 ; Double_t timeV0A =0., timeV0C = 0.; + Double_t weightV0A =0., weightV0C = 0.; UInt_t itimeV0A=0, itimeV0C=0; Double_t chargeV0A=0., chargeV0C=0.; Double_t mipV0A=0., mipV0C=0.; @@ -504,218 +579,320 @@ void AliVZEROQADataMakerRec::MakeESDs(AliESDEvent * esd) switch (eventType){ - case PHYSICS_EVENT: - Int_t iFlag=0; - Int_t pedestal; - Int_t integrator; - Bool_t BBFlag; - Bool_t BGFlag; - UInt_t time, width; - Int_t MBCharge, charge; - Int_t offlineCh; - TH1D * hProj; - - for(Int_t iChannel=0; iChannel<64; iChannel++) { // BEGIN : Loop over channels + case PHYSICS_EVENT: + + // fNTotEvents++; // Use framework counters instead + + Int_t iFlag=0; + Int_t pedestal; + Int_t integrator; + Bool_t flagBB[64]; + Bool_t flagBG[64]; + Int_t mbCharge; + Float_t charge; + Int_t offlineCh; + Float_t adc[64], time[64], width[64], timeCorr[64]; + + for(Int_t iChannel=0; iChannel<64; iChannel++) { // BEGIN : Loop over channels - offlineCh = rawStream->GetOfflineChannel(iChannel); + offlineCh = rawStream->GetOfflineChannel(iChannel); - // Fill Pedestal histograms + // Fill Pedestal histograms - for(Int_t j=15; j<21; j++) { - if((rawStream->GetBGFlag(iChannel,j) || rawStream->GetBBFlag(iChannel,j))) iFlag++; - } + for(Int_t j=15; j<21; j++) { + if((rawStream->GetBGFlag(iChannel,j) || rawStream->GetBBFlag(iChannel,j))) iFlag++; + } - if(iFlag == 0){ //No Flag found - for(Int_t j=15; j<21; j++){ - pedestal=rawStream->GetPedestal(iChannel, j); - integrator = rawStream->GetIntegratorFlag(iChannel, j); + if(iFlag == 0){ //No Flag found + for(Int_t j=15; j<21; j++){ + pedestal= (Int_t) rawStream->GetPedestal(iChannel, j); + integrator = rawStream->GetIntegratorFlag(iChannel, j); - GetRawsData((integrator == 0 ? kPedestalInt0 : kPedestalInt1))->Fill(offlineCh,pedestal); - GetRawsData((integrator == 0 ? kPedestalCycleInt0 : kPedestalCycleInt1))->Fill(offlineCh,pedestal); - } - } + FillRawsData((integrator == 0 ? kPedestalInt0 : kPedestalInt1),offlineCh,pedestal); + } + } - // Fill Charge EoI histograms + // Fill Charge EoI histograms - // Look for the maximum in the LHC clock train - charge = 0; - Int_t iClock = 0; - Int_t iCharge = 0; - for(Int_t iEvent=0; iEvent<21; iEvent++){ - iCharge = rawStream->GetPedestal(iChannel,iEvent); - if(iCharge>charge) { - charge = iCharge; - iClock = iEvent; - } - } // End of maximum searching procedure - - integrator = rawStream->GetIntegratorFlag(iChannel,iClock); - BBFlag = rawStream->GetBBFlag(iChannel, iClock); - BGFlag = rawStream->GetBGFlag(iChannel,iClock ); - - GetRawsData((integrator == 0 ? kChargeEoIInt0 : kChargeEoIInt1))->Fill(offlineCh,charge); - if(BBFlag) GetRawsData((integrator == 0 ? kChargeEoIBBInt0 : kChargeEoIBBInt1))->Fill(offlineCh,charge); - if(BGFlag) GetRawsData((integrator == 0 ? kChargeEoIBGInt0 : kChargeEoIBGInt1))->Fill(offlineCh,charge); - - hProj = ((TH2I*)GetRawsData((integrator == 0 ? kPedestalInt0 : kPedestalInt1)))->ProjectionY("",offlineCh+1,offlineCh+1); - Double_t ped = hProj->GetMean(); - Double_t sigma = hProj->GetRMS(); - delete hProj; - - Double_t chargeEoI = charge - ped; - - // Calculation of the number of MIP - Double_t mipEoI = chargeEoI * fCalibData->GetMIPperADC(offlineCh); + adc[offlineCh] = 0.0; + + // 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(iChannel,iClock); + Int_t k = offlineCh+64*iIntegrator; + + //printf(Form("clock = %d adc = %f ped %f\n",iClock,rawStream->GetPedestal(iChannel,iClock),fPedestal[k])); + + adcPedSub[iClock] = rawStream->GetPedestal(iChannel,iClock) - fCalibData->GetPedestal(k); + // if(adcPedSub[iClock] <= GetRecoParam()->GetNSigmaPed()*fCalibData->GetSigma(k)) { + if(adcPedSub[iClock] <= 2.*fCalibData->GetSigma(k)) { + adcPedSub[iClock] = 0; + continue; + } + // if(iClock < GetRecoParam()->GetStartClock() || iClock > GetRecoParam()->GetEndClock()) continue; + if(iClock < 8 || iClock > 12) continue; + if(adcPedSub[iClock] > maxadc) { + maxadc = adcPedSub[iClock]; + imax = iClock; + } + } + //printf(Form("Channel %d (online), %d (offline)\n",iChannel,j)); + if (imax != -1) { + // Int_t start = imax - GetRecoParam()->GetNPreClocks(); + Int_t start = imax - 2; + if (start < 0) start = 0; + // Int_t end = imax + GetRecoParam()->GetNPostClocks(); + Int_t end = imax + 1; + if (end > 20) end = 20; + for(Int_t iClock = start; iClock <= end; iClock++) { + adc[offlineCh] += adcPedSub[iClock]; + } + } + + + Int_t iClock = imax; + charge = rawStream->GetPedestal(iChannel,iClock); // Charge at the maximum + + integrator = rawStream->GetIntegratorFlag(iChannel,iClock); + flagBB[offlineCh] = rawStream->GetBBFlag(iChannel, iClock); + flagBG[offlineCh] = rawStream->GetBGFlag(iChannel,iClock ); + Int_t board = AliVZEROCalibData::GetBoardNumber(offlineCh); + time[offlineCh] = rawStream->GetTime(iChannel)*fCalibData->GetTimeResolution(board); + width[offlineCh] = rawStream->GetWidth(iChannel)*fCalibData->GetWidthResolution(board); + + if (time[offlineCh] >= 1e-6) FillRawsData(kChargeEoI,offlineCh,adc[offlineCh]); + + FillRawsData((integrator == 0 ? kChargeEoIInt0 : kChargeEoIInt1),offlineCh,charge); + if(flagBB[offlineCh]) FillRawsData((integrator == 0 ? kChargeEoIBBInt0 : kChargeEoIBBInt1),offlineCh,charge); + if(flagBG[offlineCh]) FillRawsData((integrator == 0 ? kChargeEoIBGInt0 : kChargeEoIBGInt1),offlineCh,charge); + + Float_t sigma = fCalibData->GetSigma(offlineCh+64*integrator); - if(charge<1023 && chargeEoI > 5.*sigma){ - ((TH2I*)GetRawsData((integrator == 0 ? kChargeEoICycleInt0 : kChargeEoICycleInt1)))->Fill(offlineCh,chargeEoI); - ((TH2D*)GetRawsData(kRawMIPChannel))->Fill(offlineCh,mipEoI); - if(offlineCh<32) { - mulV0C++; - chargeV0C += chargeEoI; - mipV0C += mipEoI; - } else { - mulV0A++; - chargeV0A += chargeEoI; - mipV0A += mipEoI; - } - } - - // Fill Charge Minimum Bias Histograms + // Calculation of the number of MIP + Double_t mipEoI = adc[offlineCh] * fCalibData->GetMIPperADC(offlineCh); + + if((adc[offlineCh] > 2.*sigma) && !(time[offlineCh] <1.e-6)){ + FillRawsData(kRawMIPChannel,offlineCh,mipEoI); + if(offlineCh<32) { + mulV0C++; + chargeV0C += adc[offlineCh]; + mipV0C += mipEoI; + } else { + mulV0A++; + chargeV0A += adc[offlineCh]; + mipV0A += mipEoI; + } + } + + // Fill Charge Minimum Bias Histograms - int idx; - for(Int_t iBunch=0; iBunch<10; iBunch++){ - integrator = rawStream->GetIntMBFlag(iChannel, iBunch); - BBFlag = rawStream->GetBBMBFlag(iChannel, iBunch); - BGFlag = rawStream->GetBGMBFlag(iChannel, iBunch); - MBCharge = rawStream->GetChargeMB(iChannel, iBunch); - - if(integrator==0){ - if(BBFlag==0){ - if(BGFlag==0) idx = kChargeMBBB0BG0Int0; - else idx = kChargeMBBB0BG1Int0; - } else { - if(BGFlag==0) idx = kChargeMBBB1BG0Int0; - else idx = kChargeMBBB1BG1Int0; - } - } else { - if(BBFlag==0){ - if(BGFlag==0) idx = kChargeMBBB0BG0Int1; - else idx = kChargeMBBB0BG1Int1; - } else { - if(BGFlag==0) idx = kChargeMBBB1BG0Int1; - else idx = kChargeMBBB1BG1Int1; - } - } - GetRawsData(idx)->Fill(offlineCh,MBCharge); - } - - // Fill HPTDC Time Histograms - - BBFlag = rawStream->GetBBFlag(iChannel, 10); - BGFlag = rawStream->GetBGFlag(iChannel, 10); - time = rawStream->GetTime(iChannel); - width = rawStream->GetWidth(iChannel); - - if(time>0.){ - if (offlineCh<32) { - itimeV0C++; - timeV0C += time; - }else{ - itimeV0A++; - timeV0A += time; - } - } - GetRawsData(kHPTDCTime)->Fill(offlineCh,time); - GetRawsData(kWidth)->Fill(offlineCh,width); - if(BBFlag) { - GetRawsData(kHPTDCTimeBB)->Fill(offlineCh,time); - GetRawsData(kWidthBB)->Fill(offlineCh,width); - } - if(BGFlag) { - GetRawsData(kHPTDCTimeBG)->Fill(offlineCh,time); - GetRawsData(kWidthBG)->Fill(offlineCh,width); - } - - // Fill Flag and Charge Versus LHC-Clock histograms + int idx; + for(Int_t iBunch=0; iBunch<10; iBunch++){ + integrator = rawStream->GetIntMBFlag(iChannel, iBunch); + bool bbFlag = rawStream->GetBBMBFlag(iChannel, iBunch); + bool bgFlag = rawStream->GetBGMBFlag(iChannel, iBunch); + mbCharge = rawStream->GetChargeMB(iChannel, iBunch); + + if(integrator==0){ + if(bbFlag==0){ + if(bgFlag==0) idx = kChargeMBBB0BG0Int0; + else idx = kChargeMBBB0BG1Int0; + } else { + if(bgFlag==0) idx = kChargeMBBB1BG0Int0; + else idx = kChargeMBBB1BG1Int0; + } + } else { + if(bbFlag==0){ + if(bgFlag==0) idx = kChargeMBBB0BG0Int1; + else idx = kChargeMBBB0BG1Int1; + } else { + if(bgFlag==0) idx = kChargeMBBB1BG0Int1; + else idx = kChargeMBBB1BG1Int1; + } + } + FillRawsData(idx,offlineCh,mbCharge); + } + + // Fill HPTDC Time Histograms + timeCorr[offlineCh] = CorrectLeadingTime(offlineCh,time[offlineCh],adc[offlineCh]); + + const Float_t p1 = 2.50; // photostatistics term in the time resolution + const Float_t p2 = 3.00; // slewing related term in the time resolution + if(timeCorr[offlineCh]>-1024 + 1.e-6){ + Float_t nphe = adc[offlineCh]*kChargePerADC/(fCalibData->GetGain(offlineCh)*TMath::Qe()); + Float_t timeErr = 0; + if (nphe>1.e-6) timeErr = TMath::Sqrt(kIntTimeRes*kIntTimeRes+ + p1*p1/nphe+ + p2*p2*(fTimeSlewing->GetParameter(0)*fTimeSlewing->GetParameter(1))*(fTimeSlewing->GetParameter(0)*fTimeSlewing->GetParameter(1))* + TMath::Power(adc[offlineCh]/fCalibData->GetCalibDiscriThr(offlineCh,kTRUE),2.*(fTimeSlewing->GetParameter(1)-1.))/ + (fCalibData->GetCalibDiscriThr(offlineCh,kTRUE)*fCalibData->GetCalibDiscriThr(offlineCh,kTRUE))); + + if (timeErr>1.e-6) { + if (offlineCh<32) { + itimeV0C++; + timeV0C += timeCorr[offlineCh]/(timeErr*timeErr); + weightV0C += 1./(timeErr*timeErr); + }else{ + itimeV0A++; + timeV0A += timeCorr[offlineCh]/(timeErr*timeErr); + weightV0A += 1./(timeErr*timeErr); + } + } + } + FillRawsData(kHPTDCTime,offlineCh,timeCorr[offlineCh]); + FillRawsData(kWidth,offlineCh,width[offlineCh]); + if(flagBB[offlineCh]) { + FillRawsData(kHPTDCTimeBB,offlineCh,timeCorr[offlineCh]); + FillRawsData(kWidthBB,offlineCh,width[offlineCh]); + } + if(flagBG[offlineCh]) { + FillRawsData(kHPTDCTimeBG,offlineCh,timeCorr[offlineCh]); + FillRawsData(kWidthBG,offlineCh,width[offlineCh]); + } + + // Fill Flag and Charge Versus LHC-Clock histograms - for(Int_t iEvent=0; iEvent<21; iEvent++){ - charge = rawStream->GetPedestal(iChannel,iEvent); - integrator = rawStream->GetIntegratorFlag(iChannel,iEvent); - BBFlag = rawStream->GetBBFlag(iChannel, iEvent); - BGFlag = rawStream->GetBGFlag(iChannel,iEvent ); - - ((TH2*) GetRawsData((integrator == 0 ? kChargeVsClockInt0 : kChargeVsClockInt1 )))->Fill(offlineCh,(float)iEvent-10,(float)charge); - ((TH2*) GetRawsData(kBBFlagVsClock))->Fill(offlineCh,(float)iEvent-10,(float)BBFlag); - ((TH2*) GetRawsData(kBGFlagVsClock))->Fill(offlineCh,(float)iEvent-10,(float)BGFlag); - } - - }// END of Loop over channels - - if(itimeV0A>0) timeV0A /= (itimeV0A * 10); // itimeV0A Channels and divide by 10 to have the result in ns because 1 TDC Channel = 100 ps - else timeV0A = -1.; - if(itimeV0C>0) timeV0C /= (itimeV0C * 10); - else timeV0C = -1.; - if(timeV0A<0. || timeV0C<0.) diffTime = -10000.; - else diffTime = timeV0A - timeV0C; - - GetRawsData(kV0ATime)->Fill(timeV0A); - GetRawsData(kV0CTime)->Fill(timeV0C); - GetRawsData(kDiffTime)->Fill(diffTime); - - GetRawsData(kMultiV0A)->Fill(mulV0A); - GetRawsData(kMultiV0C)->Fill(mulV0C); + for(Int_t iEvent=0; iEvent<21; iEvent++){ + charge = rawStream->GetPedestal(iChannel,iEvent); + integrator = rawStream->GetIntegratorFlag(iChannel,iEvent); + bool bbFlag = rawStream->GetBBFlag(iChannel, iEvent); + bool bgFlag = rawStream->GetBGFlag(iChannel,iEvent ); + + FillRawsData((integrator == 0 ? kChargeVsClockInt0 : kChargeVsClockInt1 ), offlineCh,(float)iEvent-10,(float)charge); + FillRawsData(kBBFlagVsClock, offlineCh,(float)iEvent-10,(float)bbFlag); + FillRawsData(kBGFlagVsClock, offlineCh,(float)iEvent-10,(float)bgFlag); + if(iEvent==10) FillRawsData(kBBFlagsPerChannel, offlineCh,(float)bbFlag); + } + + }// END of Loop over channels - GetRawsData(kChargeV0A)->Fill(chargeV0A); - GetRawsData(kChargeV0C)->Fill(chargeV0C); - GetRawsData(kChargeV0)->Fill(chargeV0A + chargeV0C); + if(weightV0A>1.e-6) timeV0A /= weightV0A; + else timeV0A = -1024.; + if(weightV0C>1.e-6) timeV0C /= weightV0C; + else timeV0C = -1024.; + if(timeV0A<-1024.+1.e-6 || timeV0C<-1024.+1.e-6) diffTime = -1024.; + else diffTime = timeV0A - timeV0C; + + Bool_t v0ABB = kFALSE; + Bool_t v0CBB = kFALSE; + Bool_t v0ABG = kFALSE; + Bool_t v0CBG = kFALSE; + Bool_t v0AFake = kFALSE; + Bool_t v0CFake = kFALSE; + Bool_t v0AEmpty = kFALSE; + Bool_t v0CEmpty = kFALSE; + Int_t v0ATrigger=0; + Int_t v0CTrigger=0; + + // Change default BB and BG windows according to the Trigger Count Offset setting with respect to the default one which is 3247. + Float_t winOffset = (fCalibData->GetTriggerCountOffset(0) - 3247)*25.; + + if((timeV0A>kMinBBA-winOffset) && (timeV0AkMinBGA-winOffset) && (timeV0A-1024.+1.e-6) { + v0AFake = kTRUE; + v0ATrigger=1; + } else { + v0AEmpty = kTRUE; + v0ATrigger=0; + } + + if((timeV0C>kMinBBC-winOffset) && (timeV0CkMinBGC-winOffset) && (timeV0C-1024.+1.e-6) { + v0CFake = kTRUE; + v0CTrigger=1; + } else { + v0CEmpty = kTRUE; + v0CTrigger=0; + } + + // Fill Trigger output histogram + if(v0ABB && v0CBB) FillRawsData(kTriggers,0); + if((v0ABB || v0CBB) && !(v0ABG || v0CBG)) FillRawsData(kTriggers,1); + if(v0ABG && v0CBB) FillRawsData(kTriggers,2); + if(v0ABB && v0CBG) FillRawsData(kTriggers,3); - GetRawsData(kRawMIPV0A)->Fill(mipV0A); - GetRawsData(kRawMIPV0C)->Fill(mipV0C); - GetRawsData(kRawMIPV0)->Fill(mipV0A + mipV0C); - break; + FillRawsData(kTriggers2,v0ATrigger,v0CTrigger); + + FillRawsData(kV0ATime,timeV0A); + FillRawsData(kV0CTime,timeV0C); + FillRawsData(kDiffTime,diffTime); + FillRawsData(kTimeV0AV0C,timeV0A,timeV0C); + + FillRawsData(kMultiV0A,mulV0A); + FillRawsData(kMultiV0C,mulV0C); + + FillRawsData(kChargeV0A,chargeV0A); + FillRawsData(kChargeV0C,chargeV0C); + FillRawsData(kChargeV0,chargeV0A + chargeV0C); + + FillRawsData(kRawMIPV0A,mipV0A); + FillRawsData(kRawMIPV0C,mipV0C); + FillRawsData(kRawMIPV0,mipV0A + mipV0C); + + // Fill the histograms with charge sums used in the centrality triggers + UShort_t chargeA = 0; + UShort_t chargeC = 0; + rawStream->CalculateChargeForCentrTriggers(fTriggerData,chargeA,chargeC); + FillRawsData(kCentrChargeV0AV0C,(Float_t)chargeA,(Float_t)chargeC); - } // END of SWITCH : EVENT TYPE + break; + } // END of SWITCH : EVENT TYPE - fEvent++; - TParameter * p = dynamic_cast*>(GetParameterList()->FindObject(Form("%s_%s_%s", GetName(), AliQAv1::GetTaskName(AliQAv1::kRAWS).Data(), GetRawsData(kMultiV0A)->GetName()))) ; - p->SetVal((double)mulV0A) ; + // fEvent++; // RS: Use framework counters instead + TParameter * p = dynamic_cast*>(GetParameterList()->FindObject(Form("%s_%s_%s", GetName(), AliQAv1::GetTaskName(AliQAv1::kRAWS).Data(), GetRawsData(kMultiV0A)->GetName()))) ; + if (p) p->SetVal((double)mulV0A) ; - p = dynamic_cast*>(GetParameterList()->FindObject(Form("%s_%s_%s", GetName(), AliQAv1::GetTaskName(AliQAv1::kRAWS).Data(), GetRawsData(kMultiV0C)->GetName()))) ; - p->SetVal((double)mulV0C) ; + p = dynamic_cast*>(GetParameterList()->FindObject(Form("%s_%s_%s", GetName(), AliQAv1::GetTaskName(AliQAv1::kRAWS).Data(), GetRawsData(kMultiV0C)->GetName()))) ; + if (p) p->SetVal((double)mulV0C) ; - p = dynamic_cast*>(GetParameterList()->FindObject(Form("%s_%s_%s", GetName(), AliQAv1::GetTaskName(AliQAv1::kRAWS).Data(), GetRawsData(kChargeV0A)->GetName()))) ; - p->SetVal((double)chargeV0A) ; + p = dynamic_cast*>(GetParameterList()->FindObject(Form("%s_%s_%s", GetName(), AliQAv1::GetTaskName(AliQAv1::kRAWS).Data(), GetRawsData(kChargeV0A)->GetName()))) ; + if (p) p->SetVal((double)chargeV0A) ; - p = dynamic_cast*>(GetParameterList()->FindObject(Form("%s_%s_%s", GetName(), AliQAv1::GetTaskName(AliQAv1::kRAWS).Data(), GetRawsData(kChargeV0C)->GetName()))) ; - p->SetVal((double)chargeV0C) ; + p = dynamic_cast*>(GetParameterList()->FindObject(Form("%s_%s_%s", GetName(), AliQAv1::GetTaskName(AliQAv1::kRAWS).Data(), GetRawsData(kChargeV0C)->GetName()))) ; + if (p) p->SetVal((double)chargeV0C) ; - p = dynamic_cast*>(GetParameterList()->FindObject(Form("%s_%s_%s", GetName(), AliQAv1::GetTaskName(AliQAv1::kRAWS).Data(), GetRawsData(kChargeV0)->GetName()))) ; - p->SetVal((double)(chargeV0A + chargeV0C)) ; + p = dynamic_cast*>(GetParameterList()->FindObject(Form("%s_%s_%s", GetName(), AliQAv1::GetTaskName(AliQAv1::kRAWS).Data(), GetRawsData(kChargeV0)->GetName()))) ; + if (p) p->SetVal((double)(chargeV0A + chargeV0C)) ; - p = dynamic_cast*>(GetParameterList()->FindObject(Form("%s_%s_%s", GetName(), AliQAv1::GetTaskName(AliQAv1::kRAWS).Data(), GetRawsData(kRawMIPV0A)->GetName()))) ; - p->SetVal((double)mipV0A) ; + p = dynamic_cast*>(GetParameterList()->FindObject(Form("%s_%s_%s", GetName(), AliQAv1::GetTaskName(AliQAv1::kRAWS).Data(), GetRawsData(kRawMIPV0A)->GetName()))) ; + if (p) p->SetVal((double)mipV0A) ; - p = dynamic_cast*>(GetParameterList()->FindObject(Form("%s_%s_%s", GetName(), AliQAv1::GetTaskName(AliQAv1::kRAWS).Data(), GetRawsData(kRawMIPV0C)->GetName()))) ; - p->SetVal((double)mipV0C) ; + p = dynamic_cast*>(GetParameterList()->FindObject(Form("%s_%s_%s", GetName(), AliQAv1::GetTaskName(AliQAv1::kRAWS).Data(), GetRawsData(kRawMIPV0C)->GetName()))) ; + if (p) p->SetVal((double)mipV0C) ; - p = dynamic_cast*>(GetParameterList()->FindObject(Form("%s_%s_%s", GetName(), AliQAv1::GetTaskName(AliQAv1::kRAWS).Data(), GetRawsData(kRawMIPV0)->GetName()))) ; - p->SetVal((double)(mipV0A + mipV0C)) ; + p = dynamic_cast*>(GetParameterList()->FindObject(Form("%s_%s_%s", GetName(), AliQAv1::GetTaskName(AliQAv1::kRAWS).Data(), GetRawsData(kRawMIPV0)->GetName()))) ; + if (p) p->SetVal((double)(mipV0A + mipV0C)) ; - p = dynamic_cast*>(GetParameterList()->FindObject(Form("%s_%s_%s", GetName(), AliQAv1::GetTaskName(AliQAv1::kRAWS).Data(), GetRawsData(kV0ATime)->GetName()))) ; - p->SetVal((double)timeV0A) ; + p = dynamic_cast*>(GetParameterList()->FindObject(Form("%s_%s_%s", GetName(), AliQAv1::GetTaskName(AliQAv1::kRAWS).Data(), GetRawsData(kV0ATime)->GetName()))) ; + if (p) p->SetVal((double)timeV0A) ; - p = dynamic_cast*>(GetParameterList()->FindObject(Form("%s_%s_%s", GetName(), AliQAv1::GetTaskName(AliQAv1::kRAWS).Data(), GetRawsData(kV0CTime)->GetName()))) ; - p->SetVal((double)timeV0C) ; + p = dynamic_cast*>(GetParameterList()->FindObject(Form("%s_%s_%s", GetName(), AliQAv1::GetTaskName(AliQAv1::kRAWS).Data(), GetRawsData(kV0CTime)->GetName()))) ; + if (p) p->SetVal((double)timeV0C) ; - p = dynamic_cast*>(GetParameterList()->FindObject(Form("%s_%s_%s", GetName(), AliQAv1::GetTaskName(AliQAv1::kRAWS).Data(), GetRawsData(kDiffTime)->GetName()))) ; - p->SetVal((double)diffTime) ; + p = dynamic_cast*>(GetParameterList()->FindObject(Form("%s_%s_%s", GetName(), AliQAv1::GetTaskName(AliQAv1::kRAWS).Data(), GetRawsData(kDiffTime)->GetName()))) ; + if (p) p->SetVal((double)diffTime) ; - delete rawStream; rawStream = 0x0; - - - } + delete rawStream; rawStream = 0x0; + // + IncEvCountCycleRaws(); + IncEvCountTotalRaws(); + // +} //____________________________________________________________________________ void AliVZEROQADataMakerRec::StartOfDetectorCycle() @@ -725,15 +902,74 @@ void AliVZEROQADataMakerRec::StartOfDetectorCycle() // Reset of the histogram used - to have the trend versus time - 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("VZERO/Trigger/Data"); + if (!entry4) AliFatal("VZERO trigger config data is not found in OCDB !"); + fTriggerData = (AliVZEROTriggerData*)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+ + delays->GetBinContent(i+1)//+ + // kV0Offset + ); + // AliInfo(Form(" fTimeOffset[%d] = %f kV0offset %f",i,fTimeOffset[i],kV0Offset)); + } + + + - TH1* h; - h = GetRawsData(kPedestalCycleInt0); - if(h) h->Reset(); - h = GetRawsData(kPedestalCycleInt1); - if(h) h->Reset(); - h = GetRawsData(kChargeEoICycleInt0); - if(h) h->Reset(); - h = GetRawsData(kChargeEoICycleInt1); - if(h) h->Reset(); + + TTimeStamp currentTime; + fCycleStartTime = currentTime.GetSec(); + + // fNTotEvents = 0; +} + +//------------------------------------------------------------------------------------------------- +Float_t AliVZEROQADataMakerRec::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 -1024; + + // Channel alignment and general offset subtraction + // if (i < 32) time -= kV0CDelayCables; + // time -= fTimeOffset[i]; + //AliInfo(Form("time-offset %f", time)); + + // In case of pathological signals + if (adc < 1e-6) return time; + + // Slewing correction + Float_t thr = fCalibData->GetCalibDiscriThr(i,kTRUE); + //AliInfo(Form("adc %f thr %f dtime %f ", adc,thr,fTimeSlewing->Eval(adc/thr))); + time -= fTimeSlewing->Eval(adc/thr); + + return time; } +