AliCodeTimerAuto("");
- Bool_t forExpert(kTRUE);
+ const Bool_t expert = kTRUE ;
+ const Bool_t saveCorr = kTRUE ;
+ const Bool_t image = kTRUE ;
if ( ! AliCDBManager::Instance()->GetDefaultStorage() )
{
h3->GetXaxis()->SetTitle("Chamber");
h3->GetYaxis()->SetTitle("Board");
h3->GetZaxis()->SetTitle("Strip");
- Add2RawsList(h3, kTriggerScalersBP,forExpert);
+ Add2RawsList(h3, kTriggerScalersBP, expert, !image, !saveCorr);
TH3F* h4 = new TH3F("hTriggerScalersNonBendPlane", "Trigger scalers in non-bending plane",
4, 10.5, 14.5,
h4->GetXaxis()->SetTitle("Chamber");
h4->GetYaxis()->SetTitle("Board");
h4->GetZaxis()->SetTitle("Strip");
- Add2RawsList(h4, kTriggerScalersNBP,forExpert);
+ Add2RawsList(h4, kTriggerScalersNBP, expert, !image, !saveCorr);
AliMUONTriggerDisplay triggerDisplay;
TString histoName, histoTitle;
histoTitle = Form("Chamber %i: Scalers %s", 11+iChamber, cathName.Data());
TH2F* h5 = (TH2F*)triggerDisplay.GetEmptyDisplayHisto(histoName, AliMUONTriggerDisplay::kDisplayStrips,
iCath, iChamber, histoTitle);
- Add2RawsList(h5, kTriggerScalersDisplay + AliMpConstants::NofTriggerChambers()*iCath + iChamber,!forExpert);
+ Add2RawsList(h5, kTriggerScalersDisplay + AliMpConstants::NofTriggerChambers()*iCath + iChamber, !expert, image, !saveCorr);
}
}
18, -0.5, 17.5);
h6->GetXaxis()->SetTitle("Chamber");
h6->GetYaxis()->SetTitle("RPC");
- Add2RawsList(h6, kTriggerRPCi, forExpert);
+ Add2RawsList(h6, kTriggerRPCi, expert, !image, !saveCorr);
TH2F* h7 = new TH2F("hTriggerRPCHV", "Trigger RPC HV",
4, 10.5, 14.5,
18, -0.5, 17.5);
h7->GetXaxis()->SetTitle("Chamber");
h7->GetYaxis()->SetTitle("RPC");
- Add2RawsList(h7, kTriggerRPChv, forExpert);
+ Add2RawsList(h7, kTriggerRPChv, expert, !image, !saveCorr);
for(Int_t iChamber=0; iChamber<AliMpConstants::NofTriggerChambers(); iChamber++){
histoName = Form("hRPCIChamber%i", 11+iChamber);
histoTitle = Form("Chamber %i: RPC Currents (#muA)", 11+iChamber);
TH2F* h8 = (TH2F*)triggerDisplay.GetEmptyDisplayHisto(histoName, AliMUONTriggerDisplay::kDisplaySlats,
0, iChamber, histoTitle);
- Add2RawsList(h8, kTriggerIDisplay + iChamber, !forExpert);
+ Add2RawsList(h8, kTriggerIDisplay + iChamber, !expert, image, !saveCorr);
}
for(Int_t iChamber=0; iChamber<AliMpConstants::NofTriggerChambers(); iChamber++){
histoTitle = Form("Chamber %i: RPC HV (V)", 11+iChamber);
TH2F* h9 = (TH2F*)triggerDisplay.GetEmptyDisplayHisto(histoName, AliMUONTriggerDisplay::kDisplaySlats,
0, iChamber, histoTitle);
- Add2RawsList(h9, kTriggerHVDisplay + iChamber, !forExpert);
+ Add2RawsList(h9, kTriggerHVDisplay + iChamber, !expert, image, !saveCorr);
}
TH1F* h10 = new TH1F("hTriggerScalersTime", "Trigger scalers acquisition time", 1, 0.5, 1.5);
h10->GetXaxis()->SetBinLabel(1, "One-bin histogram: bin is filled at each scaler event.");
h10->GetYaxis()->SetTitle("Cumulated scaler time (s)");
- Add2RawsList(h10, kTriggerScalersTime, !forExpert);
+ Add2RawsList(h10, kTriggerScalersTime, !expert, image, !saveCorr);
Int_t nbp(0);
TIter next(AliMpDDLStore::Instance()->CreateBusPatchIterator());
TH1* hbp = new TH1F("hTrackerBusPatchOccupancy","Occupancy of bus patches",
nbp,-0.5,nbp-0.5);
- Add2RawsList(hbp,kTrackerBusPatchOccupancy,!forExpert);
+ Add2RawsList(hbp,kTrackerBusPatchOccupancy, !expert, image, !saveCorr);
const Bool_t histogram(kFALSE);
{
/// create Reconstructed Points histograms in RecPoints subdir for the
/// MUON tracker subsystem.
+ const Bool_t expert = kTRUE ;
+ const Bool_t image = kTRUE ;
AliCodeTimerAuto("");
- Bool_t forExpert(kTRUE);
TH1I *h1I;
TH1F *h1F;
TH2F *h2F;
for ( Int_t i = 0; i < nCh; ++i )
{
h1I = new TH1I(Form("hTrackerClusterMultiplicityForChamber%d",i+1), Form("cluster size distribution in chamber %d;size (n_{pads})",i+1), 100,0,100);
- Add2RecPointsList(h1I,kTrackerClusterMultiplicityPerChamber+i,forExpert);
+ Add2RecPointsList(h1I,kTrackerClusterMultiplicityPerChamber+i, expert, !image);
h1I = new TH1I(Form("hTrackerClusterChargeForChamber%d",i+1), Form("cluster charge distribution in chamber %d;charge (ADC counts)",i+1), 500,0,5000);
- Add2RecPointsList(h1I,kTrackerClusterChargePerChamber+i,forExpert);
+ Add2RecPointsList(h1I,kTrackerClusterChargePerChamber+i, expert, !image);
Float_t rMax = AliMUONConstants::Rmax(i/2);
h2F = new TH2F(Form("hTrackerClusterHitMapForChamber%d",i+1), Form("cluster position distribution in chamber %d;X (cm);Y (cm)",i+1), 100, -rMax, rMax, 100, -rMax, rMax);
- Add2RecPointsList(h2F, kTrackerClusterHitMapPerChamber+i,forExpert);
+ Add2RecPointsList(h2F, kTrackerClusterHitMapPerChamber+i, expert, !image);
}
// summary histograms per chamber
h1I = new TH1I("hTrackerNumberOfClustersPerChamber", "Number of clusters per chamber;chamber ID;n_{clusters}", nCh,-0.5,nCh-0.5);
- Add2RecPointsList(h1I,kTrackerNumberOfClustersPerChamber,forExpert);
+ Add2RecPointsList(h1I,kTrackerNumberOfClustersPerChamber, expert, !image);
h1F = new TH1F("hTrackerClusterMultiplicityPerChMean", "cluster mean size per chamber;chamber ID;<size> (n_{pads})", nCh,-0.5,nCh-0.5);
h1F->SetOption("P");
h1F->SetMarkerStyle(kFullDotMedium);
h1F->SetMarkerColor(kRed);
- Add2RecPointsList(h1F, kTrackerClusterMultiplicityPerChMean,forExpert);
+ Add2RecPointsList(h1F, kTrackerClusterMultiplicityPerChMean, expert, !image);
h1F = new TH1F("hTrackerClusterMultiplicityPerChSigma", "cluster size dispersion per chamber;chamber ID;#sigma_{size} (n_{pads})", nCh,-0.5,nCh-0.5);
h1F->SetOption("P");
h1F->SetMarkerStyle(kFullDotMedium);
h1F->SetMarkerColor(kRed);
- Add2RecPointsList(h1F, kTrackerClusterMultiplicityPerChSigma,forExpert);
+ Add2RecPointsList(h1F, kTrackerClusterMultiplicityPerChSigma, expert, !image);
h1F = new TH1F("hTrackerClusterChargePerChMean", "cluster mean charge per chamber;chamber ID;<charge> (ADC counts)", nCh,-0.5,nCh-0.5);
h1F->SetOption("P");
h1F->SetMarkerStyle(kFullDotMedium);
h1F->SetMarkerColor(kRed);
- Add2RecPointsList(h1F, kTrackerClusterChargePerChMean,forExpert);
+ Add2RecPointsList(h1F, kTrackerClusterChargePerChMean, expert, !image);
h1F = new TH1F("hTrackerClusterChargePerChSigma", "cluster charge dispersion per chamber;chamber ID;#sigma_{charge} (ADC counts)", nCh,-0.5,nCh-0.5);
h1F->SetOption("P");
h1F->SetMarkerStyle(kFullDotMedium);
h1F->SetMarkerColor(kRed);
- Add2RecPointsList(h1F, kTrackerClusterChargePerChSigma,forExpert);
+ Add2RecPointsList(h1F, kTrackerClusterChargePerChSigma, expert, !image);
// histograms per DE
Int_t ndes(0);
ndes = TMath::Max(ndes,detElemId);
h1I = new TH1I(Form("hTrackerClusterMultiplicityForDE%04d",detElemId), Form("cluster size distribution in detection element %d;size (n_{pads})",detElemId), 100,0,100);
- Add2RecPointsList(h1I,kTrackerClusterMultiplicityPerDE+detElemId,forExpert);
+ Add2RecPointsList(h1I,kTrackerClusterMultiplicityPerDE+detElemId, expert, !image);
h1I = new TH1I(Form("hTrackerClusterChargeForDE%04d",detElemId), Form("cluster charge distribution in detection element %d;charge (ADC counts)",detElemId), 500,0,5000);
- Add2RecPointsList(h1I,kTrackerClusterChargePerDE+detElemId,forExpert);
+ Add2RecPointsList(h1I,kTrackerClusterChargePerDE+detElemId, expert, !image);
}
it.Next();
// summary histograms per DE
h1I = new TH1I("hTrackerNumberOfClustersPerDE", "Number of clusters per detection element;DetElem ID;n_{clusters}", ndes+1,-0.5,ndes+0.5);
- Add2RecPointsList(h1I, kTrackerNumberOfClustersPerDE,!forExpert);
+ Add2RecPointsList(h1I, kTrackerNumberOfClustersPerDE, !expert, image);
h1F = new TH1F("hTrackerClusterMultiplicityPerDEMean", "cluster mean size per DE;DetElem ID;<size> (n_{pads})", ndes+1,-0.5,ndes+0.5);
h1F->SetOption("P");
h1F->SetMarkerStyle(kFullDotMedium);
h1F->SetMarkerColor(kRed);
- Add2RecPointsList(h1F, kTrackerClusterMultiplicityPerDEMean,forExpert);
+ Add2RecPointsList(h1F, kTrackerClusterMultiplicityPerDEMean, expert, !image);
h1F = new TH1F("hTrackerClusterChargePerDEMean", "cluster mean charge per DE;DetElem ID;<charge> (ADC counts)", ndes+1,-0.5,ndes+0.5);
h1F->SetOption("P");
h1F->SetMarkerStyle(kFullDotMedium);
h1F->SetMarkerColor(kRed);
- Add2RecPointsList(h1F, kTrackerClusterChargePerDEMean,forExpert);
+ Add2RecPointsList(h1F, kTrackerClusterChargePerDEMean, expert, !image);
fIsInitRecPointsTracker=kTRUE;
}
/// create Reconstructed Points histograms in RecPoints subdir for the
/// MUON Trigger subsystem.
- Bool_t forExpert(kTRUE);
+ const Bool_t expert = kTRUE ;
+ const Bool_t image = kTRUE ;
TH3F* h0 = new TH3F("hTriggerDigitsBendPlane", "Trigger digits in bending plane",
4, 10.5, 14.5,
h0->GetXaxis()->SetTitle("Chamber");
h0->GetYaxis()->SetTitle("Board");
h0->GetZaxis()->SetTitle("Strip");
- Add2RecPointsList(h0, kTriggerDigitsBendPlane,forExpert);
+ Add2RecPointsList(h0, kTriggerDigitsBendPlane, expert, !image);
TH3F* h1 = new TH3F("hTriggerDigitsNonBendPlane", "Trigger digits in non-bending plane",
4, 10.5, 14.5,
h1->GetXaxis()->SetTitle("Chamber");
h1->GetYaxis()->SetTitle("Board");
h1->GetZaxis()->SetTitle("Strip");
- Add2RecPointsList(h1, kTriggerDigitsNonBendPlane,forExpert);
+ Add2RecPointsList(h1, kTriggerDigitsNonBendPlane, expert, !image);
TH1F* h2 = new TH1F("hTriggeredBoards", "Triggered boards", 234, 0.5, 234.5);
- Add2RecPointsList(h2, kTriggeredBoards,forExpert);
+ Add2RecPointsList(h2, kTriggeredBoards, expert, !image);
AliMUONTriggerDisplay triggerDisplay;
TString histoName, histoTitle;
histoTitle = Form("Chamber %i: Fired pads %s", 11+iChamber, cathName.Data());
TH2F* h3 = (TH2F*)triggerDisplay.GetEmptyDisplayHisto(histoName, AliMUONTriggerDisplay::kDisplayStrips,
iCath, iChamber, histoTitle);
- Add2RecPointsList(h3, kTriggerDigitsDisplay + AliMpConstants::NofTriggerChambers()*iCath + iChamber,!forExpert);
+ Add2RecPointsList(h3, kTriggerDigitsDisplay + AliMpConstants::NofTriggerChambers()*iCath + iChamber, !expert, image);
}
}
TH2F* h4 = (TH2F*)triggerDisplay.GetEmptyDisplayHisto("hFiredBoardsDisplay", AliMUONTriggerDisplay::kDisplayBoards,
0, 0, "Fired boards");
- Add2RecPointsList(h4, kTriggerBoardsDisplay,!forExpert);
+ Add2RecPointsList(h4, kTriggerBoardsDisplay, !expert, image);
fIsInitRecPointsTrigger = kTRUE;
}
{
///create ESDs histograms in ESDs subdir
- Bool_t forExpert(kTRUE);
+ const Bool_t expert = kTRUE ;
+ const Bool_t image = kTRUE ;
Int_t nCh = AliMUONConstants::NTrackingCh();
Int_t nDE = 1100;
// track info
TH1F* hESDnTracks = new TH1F("hESDnTracks", "number of tracks;n_{tracks}", 20, 0., 20.);
- Add2ESDsList(hESDnTracks, kESDnTracks,!forExpert);
+ Add2ESDsList(hESDnTracks, kESDnTracks, !expert, image);
TH1F* hESDMatchTrig = new TH1F("hESDMatchTrig", "number of tracks matched with trigger;n_{tracks}", 20, 0., 20.);
- Add2ESDsList(hESDMatchTrig, kESDMatchTrig,!forExpert);
+ Add2ESDsList(hESDMatchTrig, kESDMatchTrig, !expert, image);
TH1F* hESDMomentum = new TH1F("hESDMomentum", "momentum distribution;p (GeV/c)", 300, 0., 300);
- Add2ESDsList(hESDMomentum, kESDMomentum,forExpert);
+ Add2ESDsList(hESDMomentum, kESDMomentum, expert, !image);
TH1F* hESDPt = new TH1F("hESDPt", "transverse momentum distribution;p_{t} (GeV/c)", 200, 0., 50);
- Add2ESDsList(hESDPt, kESDPt,forExpert);
+ Add2ESDsList(hESDPt, kESDPt, expert, !image);
TH1F* hESDRapidity = new TH1F("hESDRapidity", "rapidity distribution;rapidity", 200, -4.5, -2.);
- Add2ESDsList(hESDRapidity, kESDRapidity,forExpert);
+ Add2ESDsList(hESDRapidity, kESDRapidity, expert, !image);
TH1F* hESDChi2 = new TH1F("hESDChi2", "normalized #chi^{2} distribution;#chi^{2} / ndf", 500, 0., 50.);
- Add2ESDsList(hESDChi2, kESDChi2,forExpert);
+ Add2ESDsList(hESDChi2, kESDChi2, expert, !image);
TH1F* hESDProbChi2 = new TH1F("hESDProbChi2", "distribution of probability of #chi^{2};prob(#chi^{2})", 100, 0., 1.);
- Add2ESDsList(hESDProbChi2, kESDProbChi2,forExpert);
+ Add2ESDsList(hESDProbChi2, kESDProbChi2, expert, !image);
// cluster info
for (Int_t i = 0; i < nCh; i++) {
Float_t rMax = AliMUONConstants::Rmax(i/2);
TH2F* hESDClusterHitMap = new TH2F(Form("hESDClusterHitMap%d",i+1), Form("cluster position distribution in chamber %d;X (cm);Y (cm)",i+1),
100, -rMax, rMax, 100, -rMax, rMax);
- Add2ESDsList(hESDClusterHitMap, kESDClusterHitMap+i,forExpert);
+ Add2ESDsList(hESDClusterHitMap, kESDClusterHitMap+i, expert, !image);
}
TH1F* hESDnClustersPerTrack = new TH1F("hESDnClustersPerTrack", "number of associated clusters per track;n_{clusters}", 20, 0., 20.);
- Add2ESDsList(hESDnClustersPerTrack, kESDnClustersPerTrack,!forExpert);
+ Add2ESDsList(hESDnClustersPerTrack, kESDnClustersPerTrack, !expert, image);
TH1F* hESDnClustersPerCh = new TH1F("hESDnClustersPerCh", "averaged number of clusters per chamber per track;chamber ID;<n_{clusters}>", nCh, -0.5, nCh-0.5);
hESDnClustersPerCh->SetFillColor(kRed);
- Add2ESDsList(hESDnClustersPerCh, kESDnClustersPerCh,forExpert);
+ Add2ESDsList(hESDnClustersPerCh, kESDnClustersPerCh, expert, !image);
TH1F* hESDnClustersPerDE = new TH1F("hESDnClustersPerDE", "averaged number of clusters per DE per track;DetElem ID;<n_{clusters}>", nDE+1, -0.5, nDE+0.5);
hESDnClustersPerDE->SetFillColor(kRed);
- Add2ESDsList(hESDnClustersPerDE, kESDnClustersPerDE,forExpert);
+ Add2ESDsList(hESDnClustersPerDE, kESDnClustersPerDE, expert, !image);
for (Int_t i = 0; i < nCh; i++) {
TH1F* hESDClusterChargeInCh = new TH1F(Form("hESDClusterChargeInCh%d",i+1), Form("cluster charge distribution in chamber %d;charge (ADC counts)",i+1), 500, 0., 5000.);
- Add2ESDsList(hESDClusterChargeInCh, kESDClusterChargeInCh+i,forExpert);
+ Add2ESDsList(hESDClusterChargeInCh, kESDClusterChargeInCh+i, expert, !image);
}
TH1F* hESDClusterChargePerChMean = new TH1F("hESDClusterChargePerChMean", "cluster mean charge per chamber;chamber ID;<charge> (ADC counts)", nCh, -0.5, nCh-0.5);
hESDClusterChargePerChMean->SetOption("P");
hESDClusterChargePerChMean->SetMarkerStyle(kFullDotMedium);
hESDClusterChargePerChMean->SetMarkerColor(kRed);
- Add2ESDsList(hESDClusterChargePerChMean, kESDClusterChargePerChMean,forExpert);
+ Add2ESDsList(hESDClusterChargePerChMean, kESDClusterChargePerChMean, expert, !image);
TH1F* hESDClusterChargePerChSigma = new TH1F("hESDClusterChargePerChSigma", "cluster charge dispersion per chamber;chamber ID;#sigma_{charge} (ADC counts)", nCh, -0.5, nCh-0.5);
hESDClusterChargePerChSigma->SetOption("P");
hESDClusterChargePerChSigma->SetMarkerStyle(kFullDotMedium);
hESDClusterChargePerChSigma->SetMarkerColor(kRed);
- Add2ESDsList(hESDClusterChargePerChSigma, kESDClusterChargePerChSigma,forExpert);
+ Add2ESDsList(hESDClusterChargePerChSigma, kESDClusterChargePerChSigma, expert, !image);
TH1F* hESDClusterChargePerDE = new TH1F("hESDClusterChargePerDE", "cluster mean charge per DE;DetElem ID;<charge> (ADC counts)", nDE+1, -0.5, nDE+0.5);
hESDClusterChargePerDE->SetOption("P");
hESDClusterChargePerDE->SetMarkerStyle(kFullDotMedium);
hESDClusterChargePerDE->SetMarkerColor(kRed);
- Add2ESDsList(hESDClusterChargePerDE, kESDClusterChargePerDE,forExpert);
+ Add2ESDsList(hESDClusterChargePerDE, kESDClusterChargePerDE, expert, !image);
for (Int_t i = 0; i < nCh; i++) {
TH1F* hESDClusterSizeInCh = new TH1F(Form("hESDClusterSizeInCh%d",i+1), Form("cluster size distribution in chamber %d;size (n_{pads})",i+1), 200, 0., 200.);
- Add2ESDsList(hESDClusterSizeInCh, kESDClusterSizeInCh+i,forExpert);
+ Add2ESDsList(hESDClusterSizeInCh, kESDClusterSizeInCh+i, expert, !image);
}
TH1F* hESDClusterSizePerChMean = new TH1F("hESDClusterSizePerChMean", "cluster mean size per chamber;chamber ID;<size> (n_{pads})", nCh, -0.5, nCh-0.5);
hESDClusterSizePerChMean->SetOption("P");
hESDClusterSizePerChMean->SetMarkerStyle(kFullDotMedium);
hESDClusterSizePerChMean->SetMarkerColor(kRed);
- Add2ESDsList(hESDClusterSizePerChMean, kESDClusterSizePerChMean,forExpert);
+ Add2ESDsList(hESDClusterSizePerChMean, kESDClusterSizePerChMean, expert, !image);
TH1F* hESDClusterSizePerChSigma = new TH1F("hESDClusterSizePerChSigma", "cluster size dispersion per chamber;chamber ID;#sigma_{size} (n_{pads})", nCh, -0.5, nCh-0.5);
hESDClusterSizePerChSigma->SetOption("P");
hESDClusterSizePerChSigma->SetMarkerStyle(kFullDotMedium);
hESDClusterSizePerChSigma->SetMarkerColor(kRed);
- Add2ESDsList(hESDClusterSizePerChSigma, kESDClusterSizePerChSigma,forExpert);
+ Add2ESDsList(hESDClusterSizePerChSigma, kESDClusterSizePerChSigma, expert, !image);
TH1F* hESDClusterSizePerDE = new TH1F("hESDClusterSizePerDE", "cluster mean size per DE;DetElem ID;<size> (n_{pads})", nDE+1, -0.5, nDE+0.5);
hESDClusterSizePerDE->SetOption("P");
hESDClusterSizePerDE->SetMarkerStyle(kFullDotMedium);
hESDClusterSizePerDE->SetMarkerColor(kRed);
- Add2ESDsList(hESDClusterSizePerDE, kESDClusterSizePerDE,forExpert);
+ Add2ESDsList(hESDClusterSizePerDE, kESDClusterSizePerDE, expert, !image);
// cluster - track info
for (Int_t i = 0; i < nCh; i++) {
TH1F* hESDResidualXInCh = new TH1F(Form("hESDResidualXInCh%d",i+1), Form("cluster-track residual-X distribution in chamber %d;#Delta_{X} (cm)",i+1), 1000, -5., 5.);
- Add2ESDsList(hESDResidualXInCh, kESDResidualXInCh+i,forExpert);
+ Add2ESDsList(hESDResidualXInCh, kESDResidualXInCh+i, expert, !image);
TH1F* hESDResidualYInCh = new TH1F(Form("hESDResidualYInCh%d",i+1), Form("cluster-track residual-Y distribution in chamber %d;#Delta_{Y} (cm)",i+1), 1000, -1., 1.);
- Add2ESDsList(hESDResidualYInCh, kESDResidualYInCh+i,forExpert);
+ Add2ESDsList(hESDResidualYInCh, kESDResidualYInCh+i, expert, !image);
TH1F* hESDLocalChi2XInCh = new TH1F(Form("hESDLocalChi2XInCh%d",i+1), Form("local chi2-X distribution in chamber %d;local #chi^{2}_{X}",i+1), 1000, 0., 25);
- Add2ESDsList(hESDLocalChi2XInCh, kESDLocalChi2XInCh+i,forExpert);
+ Add2ESDsList(hESDLocalChi2XInCh, kESDLocalChi2XInCh+i, expert, !image);
TH1F* hESDLocalChi2YInCh = new TH1F(Form("hESDLocalChi2YInCh%d",i+1), Form("local chi2-Y distribution in chamber %d;local #chi^{2}_{Y}",i+1), 1000, 0., 25);
- Add2ESDsList(hESDLocalChi2YInCh, kESDLocalChi2YInCh+i,forExpert);
+ Add2ESDsList(hESDLocalChi2YInCh, kESDLocalChi2YInCh+i, expert, !image);
}
TH1F* hESDResidualXPerChMean = new TH1F("hESDResidualXPerChMean", "cluster-track residual-X per Ch: mean;chamber ID;<#Delta_{X}> (cm)", nCh, -0.5, nCh-0.5);
hESDResidualXPerChMean->SetOption("P");
hESDResidualXPerChMean->SetMarkerStyle(kFullDotMedium);
hESDResidualXPerChMean->SetMarkerColor(kRed);
- Add2ESDsList(hESDResidualXPerChMean, kESDResidualXPerChMean,forExpert);
+ Add2ESDsList(hESDResidualXPerChMean, kESDResidualXPerChMean, expert, !image);
TH1F* hESDResidualYPerChMean = new TH1F("hESDResidualYPerChMean", "cluster-track residual-Y per Ch: mean;chamber ID;<#Delta_{Y}> (cm)", nCh, -0.5, nCh-0.5);
hESDResidualYPerChMean->SetOption("P");
hESDResidualYPerChMean->SetMarkerStyle(kFullDotMedium);
hESDResidualYPerChMean->SetMarkerColor(kRed);
- Add2ESDsList(hESDResidualYPerChMean, kESDResidualYPerChMean,forExpert);
+ Add2ESDsList(hESDResidualYPerChMean, kESDResidualYPerChMean, expert, !image);
TH1F* hESDResidualXPerChSigma = new TH1F("hESDResidualXPerChSigma", "cluster-track residual-X per Ch: sigma;chamber ID;#sigma_{X} (cm)", nCh, -0.5, nCh-0.5);
hESDResidualXPerChSigma->SetOption("P");
hESDResidualXPerChSigma->SetMarkerStyle(kFullDotMedium);
hESDResidualXPerChSigma->SetMarkerColor(kRed);
- Add2ESDsList(hESDResidualXPerChSigma, kESDResidualXPerChSigma,forExpert);
+ Add2ESDsList(hESDResidualXPerChSigma, kESDResidualXPerChSigma, expert, !image);
TH1F* hESDResidualYPerChSigma = new TH1F("hESDResidualYPerChSigma", "cluster-track residual-Y per Ch: sigma;chamber ID;#sigma_{Y} (cm)", nCh, -0.5, nCh-0.5);
hESDResidualYPerChSigma->SetOption("P");
hESDResidualYPerChSigma->SetMarkerStyle(kFullDotMedium);
hESDResidualYPerChSigma->SetMarkerColor(kRed);
- Add2ESDsList(hESDResidualYPerChSigma, kESDResidualYPerChSigma,forExpert);
+ Add2ESDsList(hESDResidualYPerChSigma, kESDResidualYPerChSigma, expert, !image);
TH1F* hESDLocalChi2XPerChMean = new TH1F("hESDLocalChi2XPerChMean", "local chi2-X per Ch: mean;chamber ID;<local #chi^{2}_{X}>", nCh, -0.5, nCh-0.5);
hESDLocalChi2XPerChMean->SetOption("P");
hESDLocalChi2XPerChMean->SetMarkerStyle(kFullDotMedium);
hESDLocalChi2XPerChMean->SetMarkerColor(kRed);
- Add2ESDsList(hESDLocalChi2XPerChMean, kESDLocalChi2XPerChMean,forExpert);
+ Add2ESDsList(hESDLocalChi2XPerChMean, kESDLocalChi2XPerChMean, expert, !image);
TH1F* hESDLocalChi2YPerChMean = new TH1F("hESDLocalChi2YPerChMean", "local chi2-Y per Ch: mean;chamber ID;<local #chi^{2}_{Y}>", nCh, -0.5, nCh-0.5);
hESDLocalChi2YPerChMean->SetOption("P");
hESDLocalChi2YPerChMean->SetMarkerStyle(kFullDotMedium);
hESDLocalChi2YPerChMean->SetMarkerColor(kRed);
- Add2ESDsList(hESDLocalChi2YPerChMean, kESDLocalChi2YPerChMean,forExpert);
+ Add2ESDsList(hESDLocalChi2YPerChMean, kESDLocalChi2YPerChMean, expert, !image);
TH1F* hESDResidualXPerDEMean = new TH1F("hESDResidualXPerDEMean", "cluster-track residual-X per DE: mean;DetElem ID;<#Delta_{X}> (cm)", nDE+1, -0.5, nDE+0.5);
hESDResidualXPerDEMean->SetOption("P");
hESDResidualXPerDEMean->SetMarkerStyle(kFullDotMedium);
hESDResidualXPerDEMean->SetMarkerColor(kRed);
- Add2ESDsList(hESDResidualXPerDEMean, kESDResidualXPerDEMean,forExpert);
+ Add2ESDsList(hESDResidualXPerDEMean, kESDResidualXPerDEMean, expert, !image);
TH1F* hESDResidualYPerDEMean = new TH1F("hESDResidualYPerDEMean", "cluster-track residual-Y per DE: mean;DetElem ID;<#Delta_{Y}> (cm)", nDE+1, -0.5, nDE+0.5);
hESDResidualYPerDEMean->SetOption("P");
hESDResidualYPerDEMean->SetMarkerStyle(kFullDotMedium);
hESDResidualYPerDEMean->SetMarkerColor(kRed);
- Add2ESDsList(hESDResidualYPerDEMean, kESDResidualYPerDEMean,forExpert);
+ Add2ESDsList(hESDResidualYPerDEMean, kESDResidualYPerDEMean, expert, !image);
TH1F* hESDResidualXPerDESigma = new TH1F("hESDResidualXPerDESigma", "cluster-track residual-X per DE: sigma;DetElem ID;#sigma_{X} (cm)", nDE+1, -0.5, nDE+0.5);
hESDResidualXPerDESigma->SetOption("P");
hESDResidualXPerDESigma->SetMarkerStyle(kFullDotMedium);
hESDResidualXPerDESigma->SetMarkerColor(kRed);
- Add2ESDsList(hESDResidualXPerDESigma, kESDResidualXPerDESigma,forExpert);
+ Add2ESDsList(hESDResidualXPerDESigma, kESDResidualXPerDESigma, expert, !image);
TH1F* hESDResidualYPerDESigma = new TH1F("hESDResidualYPerDESigma", "cluster-track residual-Y per DE: sigma;DetElem ID;#sigma_{Y} (cm)", nDE+1, -0.5, nDE+0.5);
hESDResidualYPerDESigma->SetOption("P");
hESDResidualYPerDESigma->SetMarkerStyle(kFullDotMedium);
hESDResidualYPerDESigma->SetMarkerColor(kRed);
- Add2ESDsList(hESDResidualYPerDESigma, kESDResidualYPerDESigma,forExpert);
+ Add2ESDsList(hESDResidualYPerDESigma, kESDResidualYPerDESigma, expert, !image);
TH1F* hESDLocalChi2XPerDEMean = new TH1F("hESDLocalChi2XPerDEMean", "local chi2-X per DE: mean;DetElem ID;<local #chi^{2}_{X}>", nDE+1, -0.5, nDE+0.5);
hESDLocalChi2XPerDEMean->SetOption("P");
hESDLocalChi2XPerDEMean->SetMarkerStyle(kFullDotMedium);
hESDLocalChi2XPerDEMean->SetMarkerColor(kRed);
- Add2ESDsList(hESDLocalChi2XPerDEMean, kESDLocalChi2XPerDEMean,forExpert);
+ Add2ESDsList(hESDLocalChi2XPerDEMean, kESDLocalChi2XPerDEMean, expert, !image);
TH1F* hESDLocalChi2YPerDEMean = new TH1F("hESDLocalChi2YPerDEMean", "local chi2-Y per DE: mean;DetElem ID;<local #chi^{2}_{Y}>", nDE+1, -0.5, nDE+0.5);
hESDLocalChi2YPerDEMean->SetOption("P");
hESDLocalChi2YPerDEMean->SetMarkerStyle(kFullDotMedium);
hESDLocalChi2YPerDEMean->SetMarkerColor(kRed);
- Add2ESDsList(hESDLocalChi2YPerDEMean, kESDLocalChi2YPerDEMean,forExpert);
+ Add2ESDsList(hESDLocalChi2YPerDEMean, kESDLocalChi2YPerDEMean, expert, !image);
// intermediate histograms
TH1F* hESDnTotClustersPerCh = new TH1F("hESDnTotClustersPerCh", "total number of associated clusters per chamber;chamber ID;#Sigma(n_{clusters})", nCh, -0.5, nCh-0.5);
- Add2ESDsList(hESDnTotClustersPerCh, kESDnTotClustersPerCh, forExpert);
+ Add2ESDsList(hESDnTotClustersPerCh, kESDnTotClustersPerCh, expert, !image);
TH1F* hESDnTotClustersPerDE = new TH1F("hESDnTotClustersPerDE", "total number of associated clusters per DE;DetElem ID;#Sigma(n_{clusters})", nDE+1, -0.5, nDE+0.5);
- Add2ESDsList(hESDnTotClustersPerDE, kESDnTotClustersPerDE, forExpert);
+ Add2ESDsList(hESDnTotClustersPerDE, kESDnTotClustersPerDE, expert, !image);
TH1F* hESDnTotFullClustersPerDE = new TH1F("hESDnTotFullClustersPerDE", "total number of associated clusters containing pad info per DE;DetElem ID;#Sigma(n_{full clusters})", nDE+1, -0.5, nDE+0.5);
- Add2ESDsList(hESDnTotFullClustersPerDE, kESDnTotFullClustersPerDE, forExpert);
+ Add2ESDsList(hESDnTotFullClustersPerDE, kESDnTotFullClustersPerDE, expert, !image);
TH1F* hESDSumClusterChargePerDE = new TH1F("hESDSumClusterChargePerDE", "sum of cluster charge per DE;DetElem ID;#Sigma(charge) (ADC counts)", nDE+1, -0.5, nDE+0.5);
- Add2ESDsList(hESDSumClusterChargePerDE, kESDSumClusterChargePerDE, forExpert);
+ Add2ESDsList(hESDSumClusterChargePerDE, kESDSumClusterChargePerDE, expert, !image);
TH1F* hESDSumClusterSizePerDE = new TH1F("hESDSumClusterSizePerDE", "sum of cluster size per DE;DetElem ID;#Sigma(size) (n_{pads})", nDE+1, -0.5, nDE+0.5);
- Add2ESDsList(hESDSumClusterSizePerDE, kESDSumClusterSizePerDE, forExpert);
+ Add2ESDsList(hESDSumClusterSizePerDE, kESDSumClusterSizePerDE, expert, !image);
TH1F* hESDSumResidualXPerDE = new TH1F("hESDSumResidualXPerDE", "sum of cluster-track residual-X per DE;DetElem ID;#Sigma(#Delta_{X}) (cm)", nDE+1, -0.5, nDE+0.5);
- Add2ESDsList(hESDSumResidualXPerDE, kESDSumResidualXPerDE, forExpert);
+ Add2ESDsList(hESDSumResidualXPerDE, kESDSumResidualXPerDE, expert, !image);
TH1F* hESDSumResidualYPerDE = new TH1F("hESDSumResidualYPerDE", "sum of cluster-track residual-Y per DE;DetElem ID;#Sigma(#Delta_{Y}) (cm)", nDE+1, -0.5, nDE+0.5);
- Add2ESDsList(hESDSumResidualYPerDE, kESDSumResidualYPerDE, forExpert);
+ Add2ESDsList(hESDSumResidualYPerDE, kESDSumResidualYPerDE, expert, !image);
TH1F* hESDSumResidualX2PerDE = new TH1F("hESDSumResidualX2PerDE", "sum of cluster-track residual-X**2 per DE;DetElem ID;#Sigma(#Delta_{X}^{2}) (cm^{2})", nDE+1, -0.5, nDE+0.5);
- Add2ESDsList(hESDSumResidualX2PerDE, kESDSumResidualX2PerDE, forExpert);
+ Add2ESDsList(hESDSumResidualX2PerDE, kESDSumResidualX2PerDE, expert, !image);
TH1F* hESDSumResidualY2PerDE = new TH1F("hESDSumResidualY2PerDE", "sum of cluster-track residual-Y**2 per DE;DetElem ID;#Sigma(#Delta_{Y}^{2}) (cm^{2})", nDE+1, -0.5, nDE+0.5);
- Add2ESDsList(hESDSumResidualY2PerDE, kESDSumResidualY2PerDE, forExpert);
+ Add2ESDsList(hESDSumResidualY2PerDE, kESDSumResidualY2PerDE, expert, !image);
TH1F* hESDSumLocalChi2XPerDE = new TH1F("hESDSumLocalChi2XPerDE", "sum of local chi2-X per DE;DetElem ID;#Sigma(local #chi^{2}_{X})", nDE+1, -0.5, nDE+0.5);
- Add2ESDsList(hESDSumLocalChi2XPerDE, kESDSumLocalChi2XPerDE, forExpert);
+ Add2ESDsList(hESDSumLocalChi2XPerDE, kESDSumLocalChi2XPerDE, expert, !image);
TH1F* hESDSumLocalChi2YPerDE = new TH1F("hESDSumLocalChi2YPerDE", "sum of local chi2-Y per DE;DetElem ID;#Sigma(local #chi^{2}_{Y})", nDE+1, -0.5, nDE+0.5);
- Add2ESDsList(hESDSumLocalChi2YPerDE, kESDSumLocalChi2YPerDE, forExpert);
+ Add2ESDsList(hESDSumLocalChi2YPerDE, kESDSumLocalChi2YPerDE, expert, !image);
fIsInitESDs = kTRUE;
}
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff