//
// Constructor
//
+ DGUARD(fDebug,0,"Named CTOR of AliCentralMCMultiplicityTask: %s", name);
}
//____________________________________________________________________
AliCentralMCMultiplicityTask::AliCentralMCMultiplicityTask()
//
// Constructor
//
+ DGUARD(fDebug,0,"Default CTOR of AliCentralMCMultiplicityTask");
}
//____________________________________________________________________
AliCentralMCMultiplicityTask::AliCentralMCMultiplicityTask(const AliCentralMCMultiplicityTask& o)
//
// Copy constructor
//
+ DGUARD(fDebug,0,"COPY CTOR of AliCentralMCMultiplicityTask");
}
//____________________________________________________________________
AliCentralMCMultiplicityTask&
//
// Assignment operator
//
+ DGUARD(fDebug,3,"Assignment of AliCentralMCMultiplicityTask");
+ if (&o == this) return *this;
AliCentralMultiplicityTask::operator=(o);
fAODMCCentral = o.fAODMCCentral;
fTrackDensity = o.fTrackDensity;
// Create output objects
//
//
+ DGUARD(fDebug,1,"Create user output in AliCentralMCMultiplicityTask");
AliCentralMultiplicityTask::UserCreateOutputObjects();
AliAnalysisManager* am = AliAnalysisManager::GetAnalysisManager();
// Parameters:
// option Not used
//
+ DGUARD(fDebug,1,"Process event in AliCentralMCMultiplicityTask");
fAODMCCentral.Clear("");
// Call base class
// Parameters:
// option Not used
//
+ DGUARD(fDebug,1,"Final analysis of merge in AliCentralMCMultiplicityTask");
AliCentralMultiplicityTask::Terminate(option);
}
//____________________________________________________________________
//
// Constructor
//
+ DGUARD(fDebug,0,"Named CTOR of AliCentralMultiplicityTask: %s", name);
DefineOutput(1, TList::Class());
fBranchNames =
"ESD:AliESDRun.,AliESDHeader.,AliMultiplicity.,"
//
// Constructor
//
+ DGUARD(fDebug,0,"Default CTOR of AliCentralMultiplicityTask");
}
//____________________________________________________________________
AliCentralMultiplicityTask::AliCentralMultiplicityTask(const AliCentralMultiplicityTask& o)
//
// Copy constructor
//
+ DGUARD(fDebug,0,"COPY CTOR of AliCentralMultiplicityTask");
+
}
//____________________________________________________________________
AliCentralMultiplicityTask&
//
// Assignment operator
//
+ DGUARD(fDebug,3,"Assignment of AliCentralMultiplicityTask");
if (&o == this) return *this;
fInspector = o.fInspector;
fData = o.fData;
// Create output objects
//
//
+ DGUARD(fDebug,1,"Create user output in AliCentralMultiplicityTask");
AliAnalysisManager* am = AliAnalysisManager::GetAnalysisManager();
AliAODHandler* ah =
//
// Get the ESD event. IF this is the first event, initialise
//
+ DGUARD(fDebug,1,"Get ESD event in AliCentralMultiplicityTask");
AliESDEvent* esd = dynamic_cast<AliESDEvent*>(InputEvent());
if (!esd) {
AliWarning("No ESD event found for input event");
AliCentralMultiplicityTask::MarkEventForStore() const
{
// Make sure the AOD tree is filled
+ DGUARD(fDebug,1,"Mark AOD event for store in AliCentralMultiplicityTask");
AliAnalysisManager* am = AliAnalysisManager::GetAnalysisManager();
AliAODHandler* ah =
dynamic_cast<AliAODHandler*>(am->GetOutputEventHandler());
//____________________________________________________________________
void AliCentralMultiplicityTask::FindEtaLimits()
{
+ // Find our pseudo-rapidity limits
+ //
+ // Uses the secondary map to do so.
+ DGUARD(fDebug,1,"Find eta limits in AliCentralMultiplicityTask");
AliCentralCorrSecondaryMap* secMap = GetManager().GetSecMap();
const TAxis& vaxis = secMap->GetVertexAxis();
secs->SetOwner();
secs->SetName("secondaryMaps");
fList->Add(secs);
+ unsigned short s = 1;
TH2D* hCoverage = new TH2D("coverage", "#eta coverage per v_{z}",
- secMap->GetCorrection(UShort_t(1))->GetXaxis()->GetNbins(),
- secMap->GetCorrection(UShort_t(1))->GetXaxis()->GetXmin(),
- secMap->GetCorrection(UShort_t(1))->GetXaxis()->GetXmax(),
+ secMap->GetCorrection(s)->GetXaxis()->GetNbins(),
+ secMap->GetCorrection(s)->GetXaxis()->GetXmin(),
+ secMap->GetCorrection(s)->GetXaxis()->GetXmax(),
vaxis.GetNbins(),vaxis.GetXmin(),vaxis.GetXmax());
hCoverage->SetDirectory(0);
hCoverage->SetXTitle("#eta");
// Parameters:
// option Not used
//
+ DGUARD(fDebug,1,"Process event in AliCentralMultiplicityTask");
fAODCentral.Clear("");
fIvz = 0;
AliCentralMultiplicityTask::ProcessESD(TH2D& aodHist,
const AliMultiplicity* spdmult) const
{
+ DGUARD(fDebug,1,"Process the ESD in AliCentralMultiplicityTask");
fNTracklet->Reset();
fNCluster->Reset();
AliCentralMultiplicityTask::CorrectData(TH2D& aodHist, UShort_t vtxbin) const
{
// Corrections
+ DGUARD(fDebug,1,"Correct data in AliCentralMultiplicityTask");
TH1D* hAcceptance = fManager.GetAcceptanceCorrection(vtxbin);
TH2D* hSecMap = fManager.GetSecMapCorrection(vtxbin);
// Parameters:
// option Not used
//
+ DGUARD(fDebug,1,"Process merged output in AliCentralMultiplicityTask");
}
//____________________________________________________________________
void
void
AliDisplacedVertexSelection::Print(Option_t*) const
{
+#if 0
char ind[gROOT->GetDirLevel()+1];
for (Int_t i = 0; i < gROOT->GetDirLevel(); i++) ind[i] = ' ';
ind[gROOT->GetDirLevel()] = '\0';
std::cout << std::boolalpha
<< std::noboolalpha << std::endl;
+#endif
}
//____________________________________________________________________
//Global Event Filter//
///////////////////////
Bool_t zdcAccSat[21];
- Bool_t zdcAccSatRunClass[21];
-for(Int_t k = -10; k <= 10; k++)
+ // Bool_t zdcAccSatRunClass[21];
+ for(Int_t k = -10; k <= 10; k++)
{
zdcAccSat[k+10] = kFALSE;
- zdcAccSatRunClass[k+10] = kFALSE;
+ // zdcAccSatRunClass[k+10] = kFALSE;
}
//Global Event Filter//
///////////////////////
Bool_t zdcAccSat[21];
- Bool_t zdcAccSatRunClass[21];
+ // Bool_t zdcAccSatRunClass[21];
for(Int_t k = -10; k <= 10; k++)
{
zdcAccSat[k+10] = kFALSE;
- zdcAccSatRunClass[k+10] = kFALSE;
+ // zdcAccSatRunClass[k+10] = kFALSE;
}
fDebug(0)
{
// Constructor
+ DGUARD(fDebug, 0, "Default CTOR of AliFMDCorrector");
}
//____________________________________________________________________
//
// Parameters:
// title Title
+ DGUARD(fDebug, 0, "Named CTOR of AliFMDCorrector: %s", title);
fRingHistos.SetName(GetName());
fRingHistos.Add(new RingHistos(1, 'I'));
fRingHistos.Add(new RingHistos(2, 'I'));
//
// Parameters:
// o Object to copy from
+ DGUARD(fDebug, 0, "Copy CTOR of AliFMDCorrector");
TIter next(&o.fRingHistos);
TObject* obj = 0;
while ((obj = next())) fRingHistos.Add(obj);
// Destructor
//
//
+ DGUARD(fDebug, 3, "DTOR of AliFMDCorrector");
fRingHistos.Delete();
}
//
// Parameters:
// o Object to assign from
+ DGUARD(fDebug, 3, "Assignment of AliFMDCorrector");
if (&o == this) return *this;
TNamed::operator=(o);
// Parameters:
// etaAxis Eta axis to use
//
+ DGUARD(fDebug, 1, "Initialization of AliFMDCorrector");
if (!fUseSecondaryMap)
AliWarning("Secondary maps not used - BE CAREFUL");
if (!fUseVertexBias)
// Return:
// true on successs
//
+ DGUARD(fDebug, 1, "Correct histograms of AliFMDCorrector");
AliForwardCorrectionManager& fcm = AliForwardCorrectionManager::Instance();
UShort_t uvb = vtxbin;
// dir Where the output is stored
// nEvents Number of events
//
+ DGUARD(fDebug, 1, "Scale histograms of AliFMDCorrector");
if (nEvents <= 0) return;
TList* d = static_cast<TList*>(dir->FindObject(GetName()));
if (!d) return;
// Parameters:
// dir List to write in
//
+ DGUARD(fDebug, 1, "Define output of AliFMDCorrector");
TList* d = new TList;
d->SetName(GetName());
dir->Add(d);
//
// Constructor
//
-
+ DGUARD(fDebug, 0, "Default CTOR of FMD density calculator");
}
//____________________________________________________________________
// Parameters:
// name Name of object
//
+ DGUARD(fDebug, 0, "Named CTOR of FMD density calculator: %s", title);
fRingHistos.SetName(GetName());
fRingHistos.SetOwner();
fRingHistos.Add(new RingHistos(1, 'I'));
// Parameters:
// o Object to copy from
//
+ DGUARD(fDebug, 0, "Copy CTOR of FMD density calculator");
TIter next(&o.fRingHistos);
TObject* obj = 0;
while ((obj = next())) fRingHistos.Add(obj);
//
// Destructor
//
+ DGUARD(fDebug, 3, "DTOR of FMD density calculator");
fRingHistos.Delete();
}
// Return:
// Reference to this object
//
+ DGUARD(fDebug, 3, "Assignment of FMD density calculator");
if (&o == this) return *this;
TNamed::operator=(o);
//
// Parameters:
// etaAxis Not used
+ DGUARD(fDebug, 1, "Initialize FMD density calculator");
CacheMaxWeights();
TIter next(&fRingHistos);
//
// Return:
// true on successs
-
-
+ DGUARD(fDebug, 1, "Calculate density in FMD density calculator");
for (UShort_t d=1; d<=3; d++) {
UShort_t nr = (d == 1 ? 1 : 2);
// r Ring
// iEta Eta bin
//
+ DGUARD(fDebug, 3, "Find maximum weight in FMD density calculator");
AliFMDCorrELossFit::ELossFit* fit = cor->GetFit(d,r,iEta);
if (!fit) {
// AliWarning(Form("No energy loss fit for FMD%d%c at eta=%f", d, r, eta));
//
// Find the max weights and cache them
//
+ DGUARD(fDebug, 2, "Cache maximum weights in FMD density calculator");
AliForwardCorrectionManager& fcm = AliForwardCorrectionManager::Instance();
AliFMDCorrELossFit* cor = fcm.GetELossFit();
const TAxis& eta = cor->GetEtaAxis();
// The number of particles
//
// if (mult <= GetMultCut()) return 0;
+ DGUARD(fDebug, 3, "Calculate Nch in FMD density calculator");
if (lowFlux) return 1;
AliForwardCorrectionManager& fcm = AliForwardCorrectionManager::Instance();
// Return:
//
//
+ DGUARD(fDebug, 3, "Apply correction in FMD density calculator");
AliForwardCorrectionManager& fcm = AliForwardCorrectionManager::Instance();
Float_t correction = 1;
// Return:
// Newly allocated histogram of acceptance corrections
//
+ DGUARD(fDebug, 3, "Make acceptance correction in FMD density calculator");
const Double_t ic1[] = { 4.9895, 15.3560 };
const Double_t ic2[] = { 1.8007, 17.2000 };
const Double_t oc1[] = { 4.2231, 26.6638 };
// dir where to put the output
// nEvents Number of events
//
+ DGUARD(fDebug, 1, "Scale histograms in FMD density calculator");
if (nEvents <= 0) return;
TList* d = static_cast<TList*>(dir->FindObject(GetName()));
if (!d) return;
// Parameters:
// dir List to write in
//
+ DGUARD(fDebug, 1, "Define output FMD density calculator");
TList* d = new TList;
d->SetOwner();
d->SetName(GetName());
//
// Default Constructor - do not use
//
+ DGUARD(fDebug, 0, "Default CTOR of AliFMDEnergyFitter");
}
//____________________________________________________________________
// Parameters:
// title Title of object - not significant
//
+ DGUARD(fDebug, 0, "Named CTOR of AliFMDEnergyFitter: %s", title);
fEtaAxis.SetName("etaAxis");
fEtaAxis.SetTitle("#eta");
fCentralityAxis.SetName("centralityAxis");
// Parameters:
// o Object to copy from
//
+ DGUARD(fDebug, 0, "Copy CTOR of AliFMDEnergyFitter");
TIter next(&o.fRingHistos);
TObject* obj = 0;
while ((obj = next())) fRingHistos.Add(obj);
// Return:
// Reference to this
//
+ DGUARD(fDebug, 3, "Assignment of AliFMDEnergyFitter");
if (&o == this) return *this;
TNamed::operator=(o);
// has already been set (using SetEtaAxis), then this parameter will be
// ignored
//
+ DGUARD(fDebug, 1, "Initialize of AliFMDEnergyFitter");
if (fEtaAxis.GetNbins() == 0 ||
TMath::Abs(fEtaAxis.GetXmax() - fEtaAxis.GetXmin()) < 1e-7)
SetEtaAxis(eAxis);
// Return:
// True on success, false otherwise
//
+ DGUARD(fDebug, 1, "Accumulate statistics in AliFMDEnergyFitter");
Int_t icent = fCentralityAxis.FindBin(cent);
if (icent < 1 || icent > fCentralityAxis.GetNbins()) icent = 0;
// Parameters:
// dir Where the histograms are
//
+ DGUARD(fDebug, 1, "Fit distributions in AliFMDEnergyFitter");
if (!fDoFits) return;
TList* d = static_cast<TList*>(dir->FindObject(GetName()));
// Parameters:
// dir List to analyse
//
+ DGUARD(fDebug, 1, "Make the correction objec in AliFMDEnergyFitter");
AliForwardCorrectionManager& mgr = AliForwardCorrectionManager::Instance();
AliFMDCorrELossFit* obj = new AliFMDCorrELossFit;
// Parameters:
// dir Directory to add to
//
+ DGUARD(fDebug, 1, "Define output in AliFMDEnergyFitter");
TList* d = new TList;
d->SetName(GetName());
dir->Add(d);
//
// Default CTOR
//
+ DGUARD(fDebug, 0, "Default CTOR AliFMDEnergyFitter::RingHistos");
}
//____________________________________________________________________
// r ring
//
fEtaEDists.SetName("EDists");
+ DGUARD(fDebug, 0, "Named CTOR AliFMDEnergyFitter::RingHistos: FMD%d%c",
+ d, r);
}
//____________________________________________________________________
AliFMDEnergyFitter::RingHistos::RingHistos(const RingHistos& o)
// Parameters:
// o Object to copy from
//
+ DGUARD(fDebug, 0, "Copy CTOR AliFMDEnergyFitter::RingHistos");
fFits.Clear();
TIter next(&o.fEtaEDists);
TObject* obj = 0;
// Return:
// Reference to this
//
+ DGUARD(fDebug, 3, "Assignment of AliFMDEnergyFitter::RingHistos");
if (&o == this) return *this;
AliForwardUtil::RingHistos::operator=(o);
//
// Destructor
//
+ DGUARD(fDebug, 3, "DTOR of AliFMDEnergyFitter::RingHistos");
if (fEDist) delete fEDist;
fEtaEDists.Delete();
}
// icent Centrality bin (1-based)
// mult Signal
//
+ DGUARD(fDebug, 2, "Filling in AliFMDEnergyFitter::RingHistos");
if (empty) {
fEmpty->Fill(mult);
return;
// nDEbins Number of bins
// useIncrBin Whether to use an increasing bin size
//
+ DGUARD(fDebug, 2, "Initialize in AliFMDEnergyFitter::RingHistos");
fEDist = new TH1D(Form("%s_edist", fName.Data()),
Form("#DeltaE/#DeltaE_{mip} for %s", fName.Data()),
200, 0, 6);
// chi2nuCut Cut on @f$ \chi^2/\nu@f$ -
// the reduced @f$\chi^2@f$
//
+ DGUARD(fDebug, 2, "Fit in AliFMDEnergyFitter::RingHistos");
// Get our ring list from the output container
TList* l = GetOutputList(dir);
// Return:
// The best fit function
//
+ DGUARD(fDebug, 3, "Fit histogram in AliFMDEnergyFitter::RingHistos: %s",
+ dist->GetName());
Double_t maxRange = 10;
// Create a fitter object
// Parameters:
// dir
//
+ DGUARD(fDebug, 2, "Define output in AliFMDEnergyFitter::RingHistos");
fList = DefineOutputList(dir);
}
//
// Constructor
//
+ DGUARD(fDebug,0,"Default CTOR of AliFMDEnergyFitterTask");
}
//____________________________________________________________________
// Parameters:
// name Name of task
//
+ DGUARD(fDebug,0,"Named CTOR of AliFMDEnergyFitterTask: %s", name);
DefineOutput(1, TList::Class());
DefineOutput(2, TList::Class());
}
// Parameters:
// o Object to copy from
//
+ DGUARD(fDebug,0,"COPY CTOR of AliFMDEnergyFitterTask");
DefineOutput(1, TList::Class());
DefineOutput(2, TList::Class());
}
// Return:
// Reference to this object
//
+ DGUARD(fDebug,3,"Assignment of AliFMDEnergyFitterTask");
if (&o == this) return *this;
AliAnalysisTaskSE::operator=(o);
// Initialize the task
//
//
+ DGUARD(fDebug,1,"Initialize of AliFMDEnergyFitterTask");
fFirstEvent = true;
}
// Initialise the sub objects and stuff. Called on first event
//
//
+ DGUARD(fDebug,1,"Initialize subs of AliFMDEnergyFitterTask");
AliForwardCorrectionManager& fcm = AliForwardCorrectionManager::Instance();
UShort_t sys = fEventInspector.GetCollisionSystem();
UShort_t sNN = fEventInspector.GetEnergy();
// Create output objects
//
//
+ DGUARD(fDebug,1,"Create output objects of AliFMDEnergyFitterTask");
fList = new TList;
fList->SetOwner();
// static Int_t cnt = 0;
// cnt++;
// Get the input data
+ DGUARD(fDebug,1,"Analyse event of AliFMDEnergyFitterTask");
AliMCEvent* mcevent = MCEvent();
if(mcevent) {
// Parameters:
// option Not used
//
- AliInfo(Form("Running terminate of %s", GetName()));
+ DGUARD(fDebug,1,"Processing merged output of AliFMDEnergyFitterTask");
+
TList* list = dynamic_cast<TList*>(GetOutputData(1));
if (!list) {
AliError(Form("No output list defined (%p)", GetOutputData(1)));
//
// Constructor
//
+ DGUARD(fDebug,0,"Default CTOR of AliFMDEventInspector");
}
//____________________________________________________________________
// Parameters:
// name Name of object
//
+ DGUARD(fDebug,0,"Named CTOR of AliFMDEventInspector: %s", name);
}
//____________________________________________________________________
// Parameters:
// o Object to copy from
//
+ DGUARD(fDebug,0,"Copy CTOR of AliFMDEventInspector");
}
//____________________________________________________________________
// Return:
// Reference to this object
//
+ DGUARD(fDebug,3,"Assignment of AliFMDEventInspector");
if (&o == this) return *this;
TNamed::operator=(o);
fHEventsTr = o.fHEventsTr;
// Return:
// true on success, false otherwise
//
+ DGUARD(fDebug,3,"Fetch histograms in AliFMDEventInspector");
hEventsTr = 0;
hEventsTrVtx = 0;
hTriggers = 0;
// Parameters:
// vtxAxis Vertex axis in use
//
- AliInfo("Initialising the event inspector");
+ DGUARD(fDebug,1,"Initialize in AliFMDEventInspector");
// -1.5 -0.5 0.5 1.5 ... 89.5 ... 100.5
// ----- 92 number --------- ---- 1 ---
{
// Write TNamed objects to output list containing information about
// the running conditions
+ DGUARD(fDebug,2,"Store information from AliFMDEventInspector");
if (!fList) return;
TNamed* sys = new TNamed("sys", "");
//
// dir Directory to add to
//
+ DGUARD(fDebug,1,"Define output from AliFMDEventInspector");
fList = new TList;
fList->SetName(GetName());
dir->Add(fList);
// Return:
// 0 (or kOk) on success, otherwise a bit mask of error codes
//
+ DGUARD(fDebug,1,"Process event in AliFMDEventInspector");
// --- Check that we have an event ---------------------------------
if (!event) {
// Return:
// False on error, true otherwise
//
+ DGUARD(fDebug,2,"Read the centrality in AliFMDEventInspector");
+
cent = -1;
qual = 0;
AliCentrality* centObj = const_cast<AliESDEvent*>(esd)->GetCentrality();
// Return:
// @c true on success, @c false otherwise
//
+ DGUARD(fDebug,2,"Read the triggers in AliFMDEventInspector");
triggers = 0;
// Get the analysis manager - should always be there
// Return:
// @c true on success, @c false otherwise
//
+ DGUARD(fDebug,2,"Read the vertex in AliFMDEventInspector");
vz = 0;
vx = 1024;
vy = 1024;
// AliInfo(Form("Parameters from 1st ESD event: cms=%s, sNN=%f, field=%f",
// esd->GetBeamType(), 2*esd->GetBeamEnergy(),
// esd->GetMagneticField()));
+ DGUARD(fDebug,2,"Read the run details in AliFMDEventInspector");
fCollisionSystem =
AliForwardUtil::ParseCollisionSystem(esd->GetBeamType());
fEnergy =
//
// Constructor
//
+ DGUARD(fDebug,0,"Default CTOR of AliFMDEventPlaneFinder");
}
// Parameters:
// name Name of object
//
+ DGUARD(fDebug,0,"Named CTOR of AliFMDEventPlaneFinder: %s", title);
}
//____________________________________________________________________
// Parameters:
// o Object to copy from
//
+ DGUARD(fDebug,0,"Copy CTOR of AliFMDEventPlaneFinder");
}
//____________________________________________________________________
// Return:
// Reference to this object
//
+ DGUARD(fDebug,3,"Assignment of AliFMDEventPlaneFinder");
if (&o == this) return *this;
TNamed::operator=(o);
// Parameters:
// etaAxis fmd eta axis binning
//
+ DGUARD(fDebug,1,"Initalization of AliFMDEventPlaneFinder");
fHistFMDEventplane = new TH1D("hFMDEventplane", "FMD eventplane",
100, 0., TMath::Pi());
fHistFMDEventplane->Sumw2();
// Parameters:
// dir List to write in
//
+ DGUARD(fDebug,1,"Define output of AliFMDEventPlaneFinder");
fList = new TList();
fList->SetOwner();
fList->SetName(GetName());
//
// Return:
// true on successs
+ DGUARD(fDebug,1,"Find the event plane in AliFMDEventPlaneFinder");
fQt.Set(0., 0.);
fQa.Set(0., 0.);
//
// Calculate the Q vectors
//
+ DGUARD(fDebug,2,"Calculate Q-vectors in AliFMDEventPlaneFinder");
Double_t phi = 0, eta = 0, weight = 0;
for (Int_t e = 1; e <= h->GetNbinsX(); e++) {
Double_t qx = 0, qy = 0;
//
// Calculate the eventplane
//
+ DGUARD(fDebug,2,"Calculate Event plane in AliFMDEventPlaneFinder");
Double_t ep = -1;
if (v.Mod() == 0.) return ep;
//
// Fill diagnostics histograms
//
+ DGUARD(fDebug,2,"Fill histograms in AliFMDEventPlaneFinder");
Double_t fmdEPt = fmdEP->GetEventplane();
Double_t fmdEPa = fmdEP->GetEventplaneA();
Double_t fmdEPc = fmdEP->GetEventplaneC();
//
// Default constructor
//
+ DGUARD(fDebug,0,"Default CTOR of AliFMDEventPlaneTask");
}
//_____________________________________________________________________
AliFMDEventPlaneTask::AliFMDEventPlaneTask(const char* name)
// Parameters:
// name: Name of task
//
+ DGUARD(fDebug,0,"Named CTOR of AliFMDEventPlaneTask: %s", name);
DefineOutput(1, TList::Class());
DefineOutput(2, TList::Class());
// Parameters:
// o Object to copy from
//
+ DGUARD(fDebug,0,"Copy CTOR of AliFMDEventPlaneTask");
}
//_____________________________________________________________________
AliFMDEventPlaneTask&
//
// Assignment operator
//
+ DGUARD(fDebug,3,"Assignment of AliFMDEventPlaneTask");
if (&o == this) return *this;
fSumList = o.fSumList;
fOutputList = o.fOutputList;
//
// Create output objects
//
+ DGUARD(fDebug,1,"Create user objects of AliFMDEventPlaneTask");
if (!fSumList)
fSumList = new TList();
fSumList->SetName("Sums");
// Parameters:
// option: Not used
//
+ DGUARD(fDebug,1,"Process an event in AliFMDEventPlaneTask");
// Reset data members
fCent = -1;
// Parameters:
// option: Not used
//
+ DGUARD(fDebug,1,"Process merged output of AliFMDEventPlaneTask");
// Reinitiate lists if Terminate is called separately!
fSumList = dynamic_cast<TList*> (GetOutputData(1));
// Parameters:
// AliAODForwardMult: forward mult object with trigger and vertex info
//
+ DGUARD(fDebug,2,"Check AOD in AliFMDEventPlaneTask");
if (!aodfm->IsTriggerBits(AliAODForwardMult::kOffline)) return kFALSE;
fFiducialMethod(kByCut),
fSkipFMDRings(0),
fBgAndHitMaps(false)
-{}
+{
+ DGUARD(fDebug, 0, "Default CTOR of AliFMDHistCollector");
+}
//____________________________________________________________________
AliFMDHistCollector::AliFMDHistCollector(const char* title)
fSkipFMDRings(0),
fBgAndHitMaps(false)
{
+ DGUARD(fDebug, 0, "Named CTOR of AliFMDHistCollector: %s", title);
}
//____________________________________________________________________
AliFMDHistCollector::AliFMDHistCollector(const AliFMDHistCollector& o)
fFiducialMethod(o.fFiducialMethod),
fSkipFMDRings(o.fSkipFMDRings),
fBgAndHitMaps(o.fBgAndHitMaps)
-{}
+{
+ DGUARD(fDebug, 0, "Copy CTOR of AliFMDHistCollector");
+}
//____________________________________________________________________
AliFMDHistCollector::~AliFMDHistCollector()
{
+ DGUARD(fDebug, 3, "DTOR of AliFMDHistCollector");
if (fList) delete fList;
}
//____________________________________________________________________
// Return:
// Reference to this object
//
+ DGUARD(fDebug, 3, "Assignment of AliFMDHistCollector");
if (&o == this) return *this;
TNamed::operator=(o);
// Parameters:
// vtxAxis Vertex axis
//
+ DGUARD(fDebug, 1, "Initialization of AliFMDHistCollector");
AliForwardCorrectionManager& fcm = AliForwardCorrectionManager::Instance();
// Parameters:
// dir List to write in
//
+ DGUARD(fDebug, 1, "Define output of AliFMDHistCollector");
fList = new TList;
fList->SetOwner();
fList->SetName(GetName());
// Return:
// true on successs
//
+ DGUARD(fDebug, 1, "Collect final histogram of AliFMDHistCollector");
AliForwardCorrectionManager& fcm = AliForwardCorrectionManager::Instance();
const TAxis* vtxAxis = fcm.GetVertexAxis();
Double_t vMin = vtxAxis->GetBinLowEdge(vtxbin);
// Remove temporary histogram
if(fBgAndHitMaps) {
TH2D* hRingSumVtx
- = static_cast<TH2D*>(vtxList->FindObject(Form("hitMapFMD%d%c", d, r)));
+ = static_cast<TH2D*>(vtxList->FindObject(Form("hitMapFMD%d%c",
+ d, r)));
hRingSumVtx->Add(t);
}
delete t;
AliFMDMCTrackDensity::State&
AliFMDMCTrackDensity::State::operator=(const State& o)
{
+ if (&o == this) return *this;
angle = o.angle;
oldDetector = o.oldDetector;
oldRing = o.oldRing;
//
// Default Constructor - do not use
//
+ DGUARD(fDebug,0, "Default CTOR for AliFMDSharingFilter");
}
//____________________________________________________________________
// Parameters:
// title Title of object - not significant
//
+ DGUARD(fDebug,0, "Named CTOR for AliFMDSharingFilter: %s", title);
fRingHistos.SetName(GetName());
fRingHistos.SetOwner();
// Parameters:
// o Object to copy from
//
+ DGUARD(fDebug,0, "Copy CTOR for AliFMDSharingFilter");
TIter next(&o.fRingHistos);
TObject* obj = 0;
while ((obj = next())) fRingHistos.Add(obj);
//
// Destructor
//
+ DGUARD(fDebug,3, "DTOR for AliFMDSharingFilter");
fRingHistos.Delete();
}
// Return:
// Reference to this
//
+ DGUARD(fDebug,3, "Assigment for AliFMDSharingFilter");
if (&o == this) return *this;
TNamed::operator=(o);
AliFMDSharingFilter::Init()
{
// Initialise
+ DGUARD(fDebug,1, "Initialize for AliFMDSharingFilter");
AliForwardCorrectionManager& fcm = AliForwardCorrectionManager::Instance();
// Get the high cut. The high cut is defined as the
// Return:
// True on success, false otherwise
//
+ DGUARD(fDebug,1, "Filter event in AliFMDSharingFilter");
output.Clear();
TIter next(&fRingHistos);
RingHistos* o = 0;
fSummed->Fill(kMergedWithOther, nMerged);
fSummed->Fill(kMergedInto, nSummed);
- DBGL(1, Form("none=%9d, candidate=%9d, merged=%9d, summed=%9d",
+ DBGL(5, Form("none=%9d, candidate=%9d, merged=%9d, summed=%9d",
nNone, nCandidate, nMerged, nSummed));
next.Reset();
while ((o = static_cast<RingHistos*>(next())))
// strip is considered a candidate.
if (thisE < lowCut || thisE > 20) {
thisStatus = kNone;
- DBGL(3,Form(" %9f<%9f || %9f>20, 0'ed", thisE, lowCut, thisE));
+ DBGL(5,Form(" %9f<%9f || %9f>20, 0'ed", thisE, lowCut, thisE));
if (prevStatus == kCandidate) prevStatus = kNone;
return 0;
}
// It this strip was merged with the previous strip, then
// make the next strip a candidate and zero the value in this strip.
if (thisStatus == kMergedWithOther) {
- DBGL(3,Form(" Merged with other, 0'ed"));
+ DBGL(5,Form(" Merged with other, 0'ed"));
return 0;
}
thisStatus = kMergedInto;
else
thisStatus = kNone;
- DBGL(3, Form(" %9f>%f9 (was %9f) -> %9f %s",
+ DBGL(5, Form(" %9f>%f9 (was %9f) -> %9f %s",
totalE, highCut, thisE, totalE,status2String(thisStatus)));
return totalE;
}
// If the total signal is smaller than low cut then zero this and kill this
if (totalE < lowCut) {
- DBGL(3, Form(" %9f<%9f (was %9f), zeroed", totalE, lowCut, thisE));
+ DBGL(5, Form(" %9f<%9f (was %9f), zeroed", totalE, lowCut, thisE));
thisStatus = kNone;
return 0;
}
// If total signal not above high cut or lower than low cut,
// mark this as a candidate for merging into the next, and zero signal
- DBGL(3, Form(" %9f<%9f<%9f (was %9f), zeroed, candidate",
+ DBGL(5, Form(" %9f<%9f<%9f (was %9f), zeroed, candidate",
lowCut, totalE, highCut, thisE));
thisStatus = kCandidate;
return (fZeroSharedHitsBelowThreshold ? 0 : totalE);
// dir Where the output is
// nEvents Number of events
//
+ DGUARD(fDebug,1, "Scale histograms in AliFMDSharingFilter");
if (nEvents <= 0) return;
TList* d = static_cast<TList*>(dir->FindObject(GetName()));
if (!d) return;
// Parameters:
// dir Directory to add to
//
+ DGUARD(fDebug,1, "Define output in AliFMDSharingFilter");
TList* d = new TList;
d->SetName(GetName());
dir->Add(d);
Int_t nBins = accMap->GetNbinsX();
Double_t eta[48] = { 0. };
Int_t n = 0;
- Double_t newOcc[48] = { 0. };
+ // Double_t newOcc[48] = { 0. };
Double_t prev = -1;
for (Int_t i = 0; i < nBins; i++) {
Double_t occ = accMap->GetBinContent(i+1);
if (prev != occ && (((occ > 0.6 || occ == 0) && i*0.25-6 < 4) || ((occ == 0) && i*0.25-6 >= 4))) {
eta[n] = i*0.25-6.;
- newOcc[n] = occ;
+ // newOcc[n] = occ;
n++;
if (fDebug > 5) AliInfo(Form("eta: %f \t occ: %f \t Vertex: %d \n", eta[n-1], occ, fVzMin));
}
}
// For flow calculations
- Double_t two = 0, qc2 = 0, vnTwo = 0, four = 0, qc4 = 0, vnFour = 0;
+ Double_t two = 0, qc2 = 0, /*vnTwo = 0,*/ four = 0, qc4 = 0/*, vnFour = 0*/;
Double_t twoPrime = 0, qc2Prime = 0, vnTwoDiff = 0, fourPrime = 0, qc4Prime = 0, vnFourDiff = 0;
Double_t w2 = 0, w4 = 0, w2p = 0, w4p = 0;
Double_t w2Two = 0, w2pTwoPrime = 0, w4Four = 0, w4pFourPrime = 0;
if (fDebug > 0) AliInfo(Form("%s: QC_%d{2} = %1.3f for eta = %1.2f and centrality %3.1f - skipping", fType.Data(), fMoment, qc2, eta, cent));
continue;
}
- vnTwo = TMath::Sqrt(qc2);
+ // vnTwo = TMath::Sqrt(qc2);
// if (!TMath::IsNaN(vnTwo*mult))
// cumu2->Fill(eta, cent, vnTwo, fCumuHist->GetBinContent(0,cBin,0));
if (fDebug > 0) AliInfo(Form("%s: QC_%d{4} = %1.3f for eta = %1.2f and centrality %3.1f - skipping", fType.Data(), fMoment, qc2, eta, cent));
continue;
}
- vnFour = TMath::Power(-qc4, 0.25);
+ // vnFour = TMath::Power(-qc4, 0.25);
// if (!TMath::IsNaN(vnFour*mult))
// cumu4->Fill(eta, cent, vnFour, fCumuHist->GetBinContent(0,cBin,0));
//
// Constructor
//
+ DGUARD(fDebug, 0, "Default CTOR of AliForwarddNdetaTask");
}
//____________________________________________________________________
// Paramters
// name Name of task
SetTitle("FMD");
+ DGUARD(fDebug, 0, "Named CTOR of AliForwarddNdetaTask");
}
//____________________________________________________________________
//
// Copy constructor
//
+ DGUARD(fDebug, 0, "Copy CTOR of AliForwarddNdetaTask");
}
//____________________________________________________________________
// Return:
// Newly allocated object (of our type)
//
+ DGUARD(fDebug, 3,"Make a centrality bin for AliForwarddNdetaTask: %s [%d,%d]",
+ name, l, h);
return new AliForwarddNdetaTask::CentralityBin(name, l, h);
}
TList* mclist,
TList* truthlist )
{
- AliInfo(Form("In End of %s with corrEmpty=%d, cutEdges=%d, rootProj=%d",
- GetName(), corrEmpty, cutEdges, rootProj));
+ DGUARD(fDebug, 1, "In End of %s with corrEmpty=%d, cutEdges=%d, rootProj=%d",
+ GetName(), corrEmpty, cutEdges, rootProj);
AliBasedNdetaTask::CentralityBin::End(sums, results, scheme,
shapeCorr, trigEff,
symmetrice, rebin,
rootProj, corrEmpty, cutEdges,
- triggerMask, marker, color, mclist, truthlist);
+ triggerMask, marker, color, mclist,
+ truthlist);
if (!IsAllBin()) return;
TFile* file = TFile::Open("forward.root", "READ");
* @param mc If true, assume simulated events
* @param usePar If true, use PARs
*/
- void Run(const char* mode, const char* oper,
- Int_t nEvents=-1, Bool_t mc=false,
- Bool_t usePar=false)
+ void Run(const char* mode,
+ const char* oper,
+ Int_t nEvents=-1,
+ Bool_t mc=false,
+ Bool_t usePar=false,
+ Int_t dbg=0)
{
Info("Run", "Running in mode=%s, oper=%s, events=%d, MC=%d, Par=%d",
mode, oper, nEvents, mc, usePar);
- Exec("ESD", mode, oper, nEvents, mc, usePar);
+ Exec("ESD", mode, oper, nEvents, mc, usePar, dbg);
}
/**
* Run this analysis
* @param mc If true, assume simulated events
* @param usePar If true, use PARs
*/
- void Run(EMode mode, EOper oper, Int_t nEvents=-1, Bool_t mc=false,
- Bool_t usePar = false)
+ void Run(EMode mode,
+ EOper oper,
+ Int_t nEvents=-1,
+ Bool_t mc=false,
+ Bool_t usePar = false,
+ Int_t dbg = 0)
{
Info("Run", "Running in mode=%d, oper=%d, events=%d, MC=%d, Par=%d",
mode, oper, nEvents, mc, usePar);
- Exec(kESD, mode, oper, nEvents, mc, usePar);
+ Exec(kESD, mode, oper, nEvents, mc, usePar, dbg);
}
protected:
/**
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff