AliCDBEntry *entry=0;
- entry = man->Get("AD/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("AD/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("AD/Calib/Data",fRun);
- }
+ //}
// Retrieval of data in directory AD/Calib/Data:
AliADCalibData *calibdata = 0;
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("AD/Calib/TimeDelays");
if (!entry2) AliFatal("AD time delays are not found in OCDB !");
TH1F *delays = (TH1F*)entry2->GetObject();
AliCDBEntry *entry3 = AliCDBManager::Instance()->Get("AD/Calib/TimeSlewing");
if (!entry3) AliFatal("AD time slewing function is not found in OCDB !");
fTimeSlewing = (TF1*)entry3->GetObject();
-
+ /*/
for(Int_t i = 0 ; i < 16; ++i) {
//Int_t board = AliADCalibData::GetBoardNumber(i);
// (Float_t)fCalibData->GetRollOver(board))*25.0 +
// fCalibData->GetTimeOffset(i) -
// l1Delay+
- delays->GetBinContent(i+1)//+
+ //delays->GetBinContent(i+1)//+
// kV0Offset
+ 0
);
// AliInfo(Form(" fTimeOffset[%d] = %f kV0offset %f",i,fTimeOffset[i],kV0Offset));
}
}
//____________________________________________________________________________
-void AliADQADataMakerRec::MakeDigits(TTree *digitTree)
+void AliADQADataMakerRec::MakeDigits(TTree* /*digitTree*/)
{
}
//____________________________________________________________________________
-void AliADQADataMakerRec::MakeESDs(AliESDEvent * esd)
+void AliADQADataMakerRec::MakeESDs(AliESDEvent* /*esd*/)
{
}
const Float_t kChannelMax = 16;
const Int_t kNPedestalBins = 200;
const Float_t kPedestalMin = 0;
- const Float_t kPedestalMax = 200;
+ const Float_t kPedestalMax = 200;
+ const Int_t kNPairBins = 8;
+ const Float_t kPairMin = 0;
+ const Float_t kPairMax = 8;
TH2I * h2i;
TH2F * h2d;
int iHisto =0;
// Creation of Cell Multiplicity Histograms
- h1i = new TH1I("H1I_Multiplicity_ADA", "Cell Multiplicity in ADA;# of Cells;Entries", 35, 0, 35) ;
+ h1i = new TH1I("H1I_Multiplicity_ADA", "Number of fired cells in ADA;# of Cells;Entries", 10, 0, 10) ;
Add2RawsList(h1i,kMultiADA, !expert, image, saveCorr); iHisto++;
- h1i = new TH1I("H1I_Multiplicity_ADC", "Cell Multiplicity in ADC;# of Cells;Entries", 35, 0, 35) ;
+ h1i = new TH1I("H1I_Multiplicity_ADC", "Number of fired cells in ADC;# of Cells;Entries", 10, 0, 10) ;
Add2RawsList(h1i,kMultiADC, !expert, image, saveCorr); iHisto++;
// Creation of Total Charge Histograms
h2d = new TH2F("H2D_TimeADA_ADC", "Mean Time in ADC versus ADA;Time ADA [ns];Time ADC [ns]", kNTdcTimeBins/8, kTdcTimeMin,kTdcTimeMax,kNTdcTimeBins/8, kTdcTimeMin,kTdcTimeMax) ;
Add2RawsList(h2d,kTimeADAADC, !expert, image, saveCorr); iHisto++;
+ //Creation of pair coincidence histograms
+ h1i = new TH1I("H1I_MultiCoincidence_ADA", "Number of coincidences in ADA;# of Coincidences;Entries", 5, 0, 5) ;
+ Add2RawsList(h1i,kNCoincADA, !expert, image, saveCorr); iHisto++;
+ h1i = new TH1I("H1I_MultiCoincidence_ADC", "Number of coincidences in ADC;# of Coincidences;Entries", 5, 0, 5) ;
+ Add2RawsList(h1i,kNCoincADC, !expert, image, saveCorr); iHisto++;
+
+ h2d = new TH2F("H2D_Pair_Diff_Time","Diff Pair Time;Pair number;Time [ns]",kNPairBins, kPairMin, kPairMax,kNTdcTimeBins, -50., 50.);
+ Add2RawsList(h2d,kPairDiffTime, !expert, image, saveCorr); iHisto++;
+
+ h2d = new TH2F("H2D_Pair_Diff_Charge","Diff Pair Charge;Pair number;Charge [ADC counts]",kNPairBins, kPairMin, kPairMax, 2*kNChargeBins, -kChargeMax, kChargeMax);
+ Add2RawsList(h2d,kPairDiffCharge, !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
Double_t chargeADA=0., chargeADC=0.;
Double_t diffTime=-100000.;
+
+ Int_t pmulADA = 0;
+ Int_t pmulADC = 0;
+ Double_t pDiffTime =-100000.;
switch (eventType){
Int_t iFlag=0;
Int_t pedestal;
- Int_t integrator;
+ Int_t integrator[16];
Bool_t flagBB[16];
Bool_t flagBG[16];
Float_t charge;
Int_t offlineCh;
Float_t adc[16], time[16], width[16], timeCorr[16];
+ Int_t iPair=0;
for(Int_t iChannel=0; iChannel<16; iChannel++) { // BEGIN : Loop over channels
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);
+ integrator[offlineCh] = rawStream->GetIntegratorFlag(iChannel, j);
- FillRawsData((integrator == 0 ? kPedestalInt0 : kPedestalInt1),offlineCh,pedestal);
+ FillRawsData((integrator[offlineCh] == 0 ? kPedestalInt0 : kPedestalInt1),offlineCh,pedestal);
}
}
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;
+ Int_t k = offlineCh+16*iIntegrator;
//printf(Form("clock = %d adc = %f ped %f\n",iClock,rawStream->GetPedestal(iChannel,iClock),fPedestal[k]));
Int_t iClock = imax;
charge = rawStream->GetPedestal(iChannel,iClock); // Charge at the maximum
- integrator = rawStream->GetIntegratorFlag(iChannel,iClock);
+ integrator[offlineCh] = rawStream->GetIntegratorFlag(iChannel,iClock);
flagBB[offlineCh] = rawStream->GetBBFlag(iChannel, iClock);
flagBG[offlineCh] = rawStream->GetBGFlag(iChannel,iClock );
Int_t board = AliADCalibData::GetBoardNumber(offlineCh);
if (time[offlineCh] >= 1e-6) FillRawsData(kChargeEoI,offlineCh,adc[offlineCh]);
- FillRawsData((integrator == 0 ? kChargeEoIInt0 : kChargeEoIInt1),offlineCh,charge);
+ FillRawsData((integrator[offlineCh] == 0 ? kChargeEoIInt0 : kChargeEoIInt1),offlineCh,charge);
- Float_t sigma = fCalibData->GetSigma(offlineCh+16*integrator);
+ Float_t sigma = fCalibData->GetSigma(offlineCh+16*integrator[offlineCh]);
if((adc[offlineCh] > 2.*sigma) && !(time[offlineCh] <1.e-6)){
if(offlineCh<8) {
// 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; // sleewing related term in the time resolution
+ //const Float_t p1 = 2.50; // photostatistics term in the time resolution
+ //const Float_t p2 = 3.00; // sleewing 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;
+ //Float_t nphe = adc[offlineCh]*kChargePerADC/(fCalibData->GetGain(offlineCh)*TMath::Qe());
+ Float_t timeErr = 1;
+ /*/
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)));
+ (fCalibData->GetCalibDiscriThr(offlineCh,kTRUE)*fCalibData->GetCalibDiscriThr(offlineCh,kTRUE)));/*/
if (timeErr>1.e-6) {
if (offlineCh<8) {
FillRawsData(kWidth,offlineCh,width[offlineCh]);
}// END of Loop over channels
-
+
+ for(Int_t iChannel=0; iChannel<4; iChannel++) {//Loop over pairs ADC
+ offlineCh = rawStream->GetOfflineChannel(iChannel);
+ Float_t sigma = fCalibData->GetSigma(offlineCh+16*integrator[offlineCh]);
+ Float_t sigma4 = fCalibData->GetSigma(offlineCh+4+16*integrator[offlineCh]);
+ if( ((adc[offlineCh] > 2.*sigma) && !(time[offlineCh] <1.e-6)) && ((adc[offlineCh+4] > 2.*sigma4) && !(time[offlineCh+4] <1.e-6)) ){
+ pmulADC++;
+ if(timeCorr[offlineCh]<-1024.+1.e-6 || timeCorr[offlineCh+4]<-1024.+1.e-6) pDiffTime = -1024.;
+ else pDiffTime = timeCorr[offlineCh+4] - timeCorr[offlineCh];
+ FillRawsData(kPairDiffTime,iPair,pDiffTime);
+ }
+ FillRawsData(kPairDiffCharge,iPair,TMath::Abs(adc[offlineCh]-adc[offlineCh+4]));
+ iPair++;
+ }
+ for(Int_t iChannel=8; iChannel<12; iChannel++) {//Loop over pairs ADA
+ offlineCh = rawStream->GetOfflineChannel(iChannel);
+ Float_t sigma = fCalibData->GetSigma(offlineCh+16*integrator[offlineCh]);
+ Float_t sigma4 = fCalibData->GetSigma(offlineCh+4+16*integrator[offlineCh]);
+ if( ((adc[offlineCh] > 2.*sigma) && !(time[offlineCh] <1.e-6)) && ((adc[offlineCh+4] > 2.*sigma4) && !(time[offlineCh+4] <1.e-6)) ){
+ pmulADA++;
+ if(timeCorr[offlineCh]<-1024.+1.e-6 || timeCorr[offlineCh+4]<-1024.+1.e-6) pDiffTime = -1024.;
+ else pDiffTime = timeCorr[offlineCh+4] - timeCorr[offlineCh];
+ FillRawsData(kPairDiffTime,iPair,pDiffTime);
+ }
+ FillRawsData(kPairDiffCharge,iPair,TMath::Abs(adc[offlineCh]-adc[offlineCh+4]));
+ iPair++;
+ }
+ FillRawsData(kNCoincADA,pmulADA);
+ FillRawsData(kNCoincADC,pmulADC);
+
+
if(weightADA>1.e-6) timeADA /= weightADA;
else timeADA = -1024.;
if(weightADC>1.e-6) timeADC /= weightADC;
}
//____________________________________________________________________________
-Float_t AliADQADataMakerRec::CorrectLeadingTime(Int_t i, Float_t time, Float_t adc) const
+Float_t AliADQADataMakerRec::CorrectLeadingTime(Int_t /*i*/, Float_t time, Float_t /*adc*/) const
{
// Correct the leading time
// for slewing effect and
//AliInfo(Form("time-offset %f", time));
// In case of pathological signals
- if (adc < 1e-6) return time;
+ //if (adc < 1e-6) return time;
// Slewing correction
- Float_t thr = fCalibData->GetCalibDiscriThr(i,kTRUE);
+ //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);
+ //time -= fTimeSlewing->Eval(adc/thr);
return time;
}
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff