diff --git a/analysis/PWGDIL/dielectron/papaframework/AnalysisCuts.cxx b/analysis/PWGDIL/dielectron/papaframework/AnalysisCuts.cxx
index 9edf6d023e0ee19f6d380b500e1252e4b04b40f9..75533cabe92fe042e11ddd69b0217d942134d49b 100644
--- a/analysis/PWGDIL/dielectron/papaframework/AnalysisCuts.cxx
+++ b/analysis/PWGDIL/dielectron/papaframework/AnalysisCuts.cxx
@@ -9,25 +9,34 @@
////////////////////////////////////////////////////////////////////////
#include "AnalysisCuts.h"
+
#include <TObject.h>
ClassImp(AnalysisCuts)
AnalysisCuts::AnalysisCuts()
- : TNamed("Cuts", ""), fFilterMask(0), fSelected(kFALSE) {
+ : TNamed("Cuts", "")
+ , fFilterMask(0)
+ , fSelected(kFALSE)
+{
// Default constructor
}
-AnalysisCuts::AnalysisCuts(const char* name, const char* title)
- : TNamed(name, title), fFilterMask(0), fSelected(kFALSE) {
+AnalysisCuts::AnalysisCuts(const char* name, const char* title) : TNamed(name, title), fFilterMask(0), fSelected(kFALSE)
+{
// Constructor
}
AnalysisCuts::AnalysisCuts(const AnalysisCuts& obj)
- : TNamed(obj), fFilterMask(obj.fFilterMask), fSelected(obj.fSelected) {}
+ : TNamed(obj)
+ , fFilterMask(obj.fFilterMask)
+ , fSelected(obj.fSelected)
+{
+}
-AnalysisCuts& AnalysisCuts::operator=(const AnalysisCuts& obj) {
+AnalysisCuts& AnalysisCuts::operator=(const AnalysisCuts& obj)
+{
// Assignment operator
if (this != &obj) {
TNamed::operator=(obj);
diff --git a/analysis/PWGDIL/dielectron/papaframework/AnalysisCuts.h b/analysis/PWGDIL/dielectron/papaframework/AnalysisCuts.h
index ee5399326caf7a024be35a2fb4b36ffc79b5f7e2..076e93ad8fa01b3b85259184212958addf4cace6 100644
--- a/analysis/PWGDIL/dielectron/papaframework/AnalysisCuts.h
+++ b/analysis/PWGDIL/dielectron/papaframework/AnalysisCuts.h
@@ -30,8 +30,7 @@ public:
virtual TObject* GetStatistics(Option_t*) const { return 0; }
private:
- UInt_t
- fFilterMask; // Mask to use one of the previous decisions inside a filter
+ UInt_t fFilterMask; // Mask to use one of the previous decisions inside a filter
Bool_t fSelected; // Final decision on selction
ClassDef(AnalysisCuts, 1); // Base class for filter decisions
};
diff --git a/analysis/PWGDIL/dielectron/papaframework/AnalysisFilter.cxx b/analysis/PWGDIL/dielectron/papaframework/AnalysisFilter.cxx
index 8de58232987432561593066be5b4a90526eac3bb..65e6bd3e7732d232fb48a48dca4c54b3951af10e 100644
--- a/analysis/PWGDIL/dielectron/papaframework/AnalysisFilter.cxx
+++ b/analysis/PWGDIL/dielectron/papaframework/AnalysisFilter.cxx
@@ -14,28 +14,29 @@
////////////////////////////////////////////////////////////////////////
#include "AnalysisFilter.h"
-#include "AnalysisCuts.h"
-#include "PairAnalysisHistos.h"
+
#include <THashList.h>
#include <TList.h>
#include <TObject.h>
+#include "AnalysisCuts.h"
+#include "PairAnalysisHistos.h"
#include "PairAnalysisVarManager.h"
ClassImp(AnalysisFilter)
AnalysisFilter::AnalysisFilter()
- : TNamed(), fCuts(0), fHistos() {
+ : TNamed()
+ , fCuts(0)
+ , fHistos()
+{
// Default constructor
fHistos.SetOwner(kTRUE);
fHistos.SetName("PairAnalysis_FilterHistos");
}
-AnalysisFilter::AnalysisFilter(const char* name, const char* title)
- : TNamed(name, title)
- , fCuts(new TList())
- , fHistos()
+AnalysisFilter::AnalysisFilter(const char* name, const char* title) : TNamed(name, title), fCuts(new TList()), fHistos()
// fHistos(new TList())
{
// Constructor
@@ -43,14 +44,15 @@ AnalysisFilter::AnalysisFilter(const char* name, const char* title)
fHistos.SetName(name);
}
-AnalysisFilter::AnalysisFilter(const AnalysisFilter& obj)
- : TNamed(obj), fCuts(0), fHistos() {
+AnalysisFilter::AnalysisFilter(const AnalysisFilter& obj) : TNamed(obj), fCuts(0), fHistos()
+{
// Copy constructor
fCuts = obj.fCuts;
// fHistos = obj.fHistos;
}
-AnalysisFilter::~AnalysisFilter() {
+AnalysisFilter::~AnalysisFilter()
+{
// Destructor
if (fCuts) fCuts->Delete("slow");
//if (fHistos) fHistos->Delete("slow");
@@ -58,7 +60,8 @@ AnalysisFilter::~AnalysisFilter() {
delete fCuts;
}
-AnalysisFilter& AnalysisFilter::operator=(const AnalysisFilter& other) {
+AnalysisFilter& AnalysisFilter::operator=(const AnalysisFilter& other)
+{
// Assignment
if (&other != this) {
TNamed::operator=(other);
@@ -68,7 +71,8 @@ AnalysisFilter& AnalysisFilter::operator=(const AnalysisFilter& other) {
return *this;
}
-UInt_t AnalysisFilter::IsSelected(TObject* obj) {
+UInt_t AnalysisFilter::IsSelected(TObject* obj)
+{
//
// Loop over all set of cuts
// and store the decision
@@ -89,9 +93,7 @@ UInt_t AnalysisFilter::IsSelected(TObject* obj) {
while ((cuts = (AnalysisCuts*) next())) {
//Bool_t acc = cuts->IsSelected(values);
Bool_t acc = cuts->IsSelected(obj); /// original
- if ((filterMask = cuts->GetFilterMask()) > 0) {
- acc = (acc && (filterMask == result));
- }
+ if ((filterMask = cuts->GetFilterMask()) > 0) { acc = (acc && (filterMask == result)); }
cuts->SetSelected(acc);
if (acc) { result |= iCutB & 0x00ffffff; }
iCutB *= 2;
@@ -100,7 +102,8 @@ UInt_t AnalysisFilter::IsSelected(TObject* obj) {
return result;
}
-UInt_t AnalysisFilter::IsSelected(Double_t* const values) {
+UInt_t AnalysisFilter::IsSelected(Double_t* const values)
+{
//
// Loop over all set of cuts
// and store the decision
@@ -113,9 +116,7 @@ UInt_t AnalysisFilter::IsSelected(Double_t* const values) {
while ((cuts = (AnalysisCuts*) next())) {
Bool_t acc = cuts->IsSelected(values);
- if ((filterMask = cuts->GetFilterMask()) > 0) {
- acc = (acc && (filterMask == result));
- }
+ if ((filterMask = cuts->GetFilterMask()) > 0) { acc = (acc && (filterMask == result)); }
cuts->SetSelected(acc);
if (acc) { result |= iCutB & 0x00ffffff; }
iCutB *= 2;
@@ -124,7 +125,8 @@ UInt_t AnalysisFilter::IsSelected(Double_t* const values) {
return result;
}
-UInt_t AnalysisFilter::IsSelected(TList* list) {
+UInt_t AnalysisFilter::IsSelected(TList* list)
+{
//
// Loop over all set of cuts
// and store the decision
@@ -137,9 +139,7 @@ UInt_t AnalysisFilter::IsSelected(TList* list) {
while ((cuts = (AnalysisCuts*) next())) {
Bool_t acc = cuts->IsSelected(list);
- if ((filterMask = cuts->GetFilterMask()) > 0) {
- acc = (acc && (filterMask & result));
- }
+ if ((filterMask = cuts->GetFilterMask()) > 0) { acc = (acc && (filterMask & result)); }
cuts->SetSelected(acc);
if (acc) { result |= iCutB & 0x00ffffff; }
iCutB *= 2;
@@ -148,7 +148,8 @@ UInt_t AnalysisFilter::IsSelected(TList* list) {
return result;
}
-void AnalysisFilter::Init() {
+void AnalysisFilter::Init()
+{
//
// Loop over all set of cuts and call Init
TIter next(fCuts);
@@ -157,12 +158,14 @@ void AnalysisFilter::Init() {
cuts->Init();
}
-void AnalysisFilter::AddCuts(AnalysisCuts* cuts) {
+void AnalysisFilter::AddCuts(AnalysisCuts* cuts)
+{
// Add a set of cuts
fCuts->Add(cuts);
}
-void AnalysisFilter::AddHistos(PairAnalysisHistos* histos) {
+void AnalysisFilter::AddHistos(PairAnalysisHistos* histos)
+{
//
// add histos for each cut
//
@@ -171,20 +174,18 @@ void AnalysisFilter::AddHistos(PairAnalysisHistos* histos) {
AnalysisCuts* cuts;
Int_t iCut = 0;
while ((cuts = (AnalysisCuts*) next())) {
- fHistos.AddAt(
- (PairAnalysisHistos*) histos->GetHistogramList()->Clone(cuts->GetName()),
- iCut++);
+ fHistos.AddAt((PairAnalysisHistos*) histos->GetHistogramList()->Clone(cuts->GetName()), iCut++);
// printf("AnalysisFilter::AddHistos add histos for %s at %d \n",cuts->GetName(),iCut);
}
}
-Bool_t AnalysisFilter::IsSelected(char* name) {
+Bool_t AnalysisFilter::IsSelected(char* name)
+{
//
// Returns current result for cut with name
AnalysisCuts* cut = (AnalysisCuts*) (fCuts->FindObject(name));
- if (cut) {
- return (cut->Selected());
- } else {
+ if (cut) { return (cut->Selected()); }
+ else {
return 0;
}
}
diff --git a/analysis/PWGDIL/dielectron/papaframework/AnalysisTaskMultiPairAnalysis.cxx b/analysis/PWGDIL/dielectron/papaframework/AnalysisTaskMultiPairAnalysis.cxx
index 4258be5c72dad905836e3bf3e95f02dface033a3..fbe543cf176d9070c374d2e79be1f4f7b4734d2a 100644
--- a/analysis/PWGDIL/dielectron/papaframework/AnalysisTaskMultiPairAnalysis.cxx
+++ b/analysis/PWGDIL/dielectron/papaframework/AnalysisTaskMultiPairAnalysis.cxx
@@ -18,19 +18,20 @@
// //
///////////////////////////////////////////////////////////////////////////
-#include "TSystem.h"
-#include <TChain.h>
-#include <TFile.h>
-#include <TH1D.h>
-#include <TStopwatch.h>
+#include "AnalysisTaskMultiPairAnalysis.h"
+
+#include "CbmRichElectronIdAnn.h"
#include "FairBaseParSet.h"
#include "FairRootManager.h"
#include "FairRunAna.h"
#include "FairRuntimeDb.h"
-
-#include "CbmRichElectronIdAnn.h"
+#include "TSystem.h"
+#include <TChain.h>
+#include <TFile.h>
+#include <TH1D.h>
+#include <TStopwatch.h>
#include "PairAnalysis.h"
#include "PairAnalysisEvent.h"
@@ -38,13 +39,12 @@
#include "PairAnalysisMC.h"
#include "PairAnalysisMetaData.h"
-#include "AnalysisTaskMultiPairAnalysis.h"
-
ClassImp(AnalysisTaskMultiPairAnalysis)
//_________________________________________________________________________________
AnalysisTaskMultiPairAnalysis::AnalysisTaskMultiPairAnalysis()
- : AnalysisTaskMultiPairAnalysis("name") {
+ : AnalysisTaskMultiPairAnalysis("name")
+{
//
// Constructor
//
@@ -57,7 +57,8 @@ AnalysisTaskMultiPairAnalysis::AnalysisTaskMultiPairAnalysis(const char* name)
, fListPairAnalysis()
, fListHistos()
, fTimer()
- , fProcInfo() {
+ , fProcInfo()
+{
//
// Named Constructor
//
@@ -69,50 +70,51 @@ AnalysisTaskMultiPairAnalysis::AnalysisTaskMultiPairAnalysis(const char* name)
}
//_________________________________________________________________________________
-AnalysisTaskMultiPairAnalysis::AnalysisTaskMultiPairAnalysis(const char *name,Int_t id) :
- FairTask(name),
- fMetaData(),
- fListPairAnalysis(),
- fListHistos(),
- fTimer(),
- fProcInfo()
+AnalysisTaskMultiPairAnalysis::AnalysisTaskMultiPairAnalysis(const char* name, Int_t id)
+ : FairTask(name)
+ , fMetaData()
+ , fListPairAnalysis()
+ , fListHistos()
+ , fTimer()
+ , fProcInfo()
{
//
// Named Constructor
//
- fMetaData.SetName(Form("PairAnalysisMetaData_%s",name));
- fListHistos.SetName(Form("PairAnalysisHistos_%s",name));
+ fMetaData.SetName(Form("PairAnalysisMetaData_%s", name));
+ fListHistos.SetName(Form("PairAnalysisHistos_%s", name));
fListPairAnalysis.SetOwner();
- ((TList*)fMetaData.GetMetaData())->SetOwner();
+ ((TList*) fMetaData.GetMetaData())->SetOwner();
fListHistos.SetOwner();
fId = id;
}
//_________________________________________________________________________________
-AnalysisTaskMultiPairAnalysis::AnalysisTaskMultiPairAnalysis(const char *name,Int_t id,Int_t scale) :
- FairTask(name),
- fMetaData(),
- fListPairAnalysis(),
- fListHistos(),
- fTimer(),
- fProcInfo()
+AnalysisTaskMultiPairAnalysis::AnalysisTaskMultiPairAnalysis(const char* name, Int_t id, Int_t scale)
+ : FairTask(name)
+ , fMetaData()
+ , fListPairAnalysis()
+ , fListHistos()
+ , fTimer()
+ , fProcInfo()
{
//
// Named Constructor
//
- fMetaData.SetName(Form("PairAnalysisMetaData_%s",name));
- fListHistos.SetName(Form("PairAnalysisHistos_%s",name));
+ fMetaData.SetName(Form("PairAnalysisMetaData_%s", name));
+ fListHistos.SetName(Form("PairAnalysisHistos_%s", name));
fListPairAnalysis.SetOwner();
- ((TList*)fMetaData.GetMetaData())->SetOwner();
+ ((TList*) fMetaData.GetMetaData())->SetOwner();
fListHistos.SetOwner();
- fId = id;
+ fId = id;
fThermalScaling = scale;
}
//_________________________________________________________________________________
-AnalysisTaskMultiPairAnalysis::~AnalysisTaskMultiPairAnalysis() {
+AnalysisTaskMultiPairAnalysis::~AnalysisTaskMultiPairAnalysis()
+{
//
// Destructor
//
@@ -130,7 +132,8 @@ AnalysisTaskMultiPairAnalysis::~AnalysisTaskMultiPairAnalysis() {
}
//_________________________________________________________________________________
-InitStatus AnalysisTaskMultiPairAnalysis::Init() {
+InitStatus AnalysisTaskMultiPairAnalysis::Init()
+{
//
// Add all histogram manager histogram lists to the output TList
//
@@ -141,8 +144,7 @@ InitStatus AnalysisTaskMultiPairAnalysis::Init() {
// Double_t beamEnergy=0.; /// TODO: replace all fBeamEnergy by beamEnergy in NOV16
FairRuntimeDb* rtdb = FairRunAna::Instance()->GetRuntimeDb();
if (rtdb) {
- FairBaseParSet* par =
- dynamic_cast<FairBaseParSet*>(rtdb->getContainer("FairBaseParSet"));
+ FairBaseParSet* par = dynamic_cast<FairBaseParSet*>(rtdb->getContainer("FairBaseParSet"));
if (par) {
Double_t parBeamMom = par->GetBeamMom();
// if default values of FairBaseParSet(15.) or FairRunSim(0.) are stored take the one set by hand
@@ -164,50 +166,42 @@ InitStatus AnalysisTaskMultiPairAnalysis::Init() {
PairAnalysis* papa = 0;
while ((papa = static_cast<PairAnalysis*>(nextDie()))) {
papa->Init();
- if (papa->GetHistogramList())
- fListHistos.Add(const_cast<THashList*>(papa->GetHistogramList()));
- if (papa->GetHistogramArray())
- fListHistos.Add(const_cast<TObjArray*>(papa->GetHistogramArray()));
- if (papa->GetQAHistList())
- fListHistos.Add(const_cast<THashList*>(papa->GetQAHistList()));
- if (papa->GetCutStepHistogramList())
- fListHistos.Add(static_cast<THashList*>(papa->GetCutStepHistogramList()));
+ if (papa->GetHistogramList()) fListHistos.Add(const_cast<THashList*>(papa->GetHistogramList()));
+ if (papa->GetHistogramArray()) fListHistos.Add(const_cast<TObjArray*>(papa->GetHistogramArray()));
+ if (papa->GetQAHistList()) fListHistos.Add(const_cast<THashList*>(papa->GetQAHistList()));
+ if (papa->GetCutStepHistogramList()) fListHistos.Add(static_cast<THashList*>(papa->GetCutStepHistogramList()));
}
// Get Instance of FairRoot manager
FairRootManager* man = FairRootManager::Instance();
- if (!man) {
- Fatal("AnalysisTaskMultiPairAnalysis::Init", "No FairRootManager!");
- }
+ if (!man) { Fatal("AnalysisTaskMultiPairAnalysis::Init", "No FairRootManager!"); }
// Init the input event
fInputEvent = new PairAnalysisEvent();
fInputEvent->SetInput(man);
fInputEvent->SetANNId(fId);
-
+
// Connect the MC event
PairAnalysisMC::Instance()->ConnectMCEvent();
// set the beam energy to the varmanager
PairAnalysisVarManager::SetValue(PairAnalysisVarManager::kEbeam, fBeamEnergy);
PairAnalysisVarManager::SetValue(PairAnalysisVarManager::kThermalScaling, fThermalScaling);
-
+
// initialization time and memory
gSystem->GetProcInfo(&fProcInfo);
fprintf(stderr,
"AnalysisTaskMultiPairAnalysis::Init:"
" Real time %fs, CPU time %fs, Memory %li MB(res.) %li MB(virt.) \n",
- fTimer.RealTime(),
- fTimer.CpuTime(),
- fProcInfo.fMemResident / 1024,
- fProcInfo.fMemVirtual / 1024);
+ fTimer.RealTime(), fTimer.CpuTime(), fProcInfo.fMemResident / 1024, fProcInfo.fMemVirtual / 1024);
fTimer.Reset();
return kSUCCESS;
}
//_________________________________________________________________________________
-void AnalysisTaskMultiPairAnalysis::Exec(Option_t*) {
+void AnalysisTaskMultiPairAnalysis::Exec(Option_t*)
+{
//
// Main loop. Called for every event
//
@@ -222,22 +216,16 @@ void AnalysisTaskMultiPairAnalysis::Exec(Option_t*) {
fEventsTotal++;
if (!(fEventsTotal % 10)) {
gSystem->GetProcInfo(&fProcInfo);
- fprintf(
- stderr,
- "AnalysisTaskMultiPairAnalysis::Exec: Process %.3e events, CPU time "
- "%.1fs, (%fs per event, eff %.3f), Memory %li MB(res.) %li MB(virt.) \n",
- (Double_t) fEventsTotal,
- fTimer.CpuTime(),
- fTimer.CpuTime() / fEventsTotal,
- fTimer.CpuTime() / fTimer.RealTime(),
- fProcInfo.fMemResident / 1024,
- fProcInfo.fMemVirtual / 1024);
+ fprintf(stderr,
+ "AnalysisTaskMultiPairAnalysis::Exec: Process %.3e events, CPU time "
+ "%.1fs, (%fs per event, eff %.3f), Memory %li MB(res.) %li MB(virt.) \n",
+ (Double_t) fEventsTotal, fTimer.CpuTime(), fTimer.CpuTime() / fEventsTotal,
+ fTimer.CpuTime() / fTimer.RealTime(), fProcInfo.fMemResident / 1024, fProcInfo.fMemVirtual / 1024);
fTimer.Continue();
}
// initialize track arrays and some track based variables
- fInputEvent
- ->Init(); // NOTE: tracks are initialized with mass hypo PDG 11, and adapted later!
+ fInputEvent->Init(); // NOTE: tracks are initialized with mass hypo PDG 11, and adapted later!
PairAnalysisVarManager::SetEvent(fInputEvent);
// magnetic field
@@ -277,10 +265,9 @@ void AnalysisTaskMultiPairAnalysis::Exec(Option_t*) {
if (papa->DoEventProcess()) {
useInternal = papa->Process(fInputEvent);
// input for internal train
- if (papa->DontClearArrays()) {
- fPairArray = (*(papa->GetPairArraysPointer()));
- }
- } else {
+ if (papa->DontClearArrays()) { fPairArray = (*(papa->GetPairArraysPointer())); }
+ }
+ else {
// internal train
if (useInternal) papa->Process(fPairArray);
}
@@ -297,7 +284,8 @@ void AnalysisTaskMultiPairAnalysis::Exec(Option_t*) {
}
//_________________________________________________________________________________
-void AnalysisTaskMultiPairAnalysis::FinishTask() {
+void AnalysisTaskMultiPairAnalysis::FinishTask()
+{
//
// Write debug tree
//
@@ -306,10 +294,8 @@ void AnalysisTaskMultiPairAnalysis::FinishTask() {
fMetaData.FillMeta("events", fEventsSelected);
// write output to file
- fprintf(
- stderr,
- "AnalysisTaskMultiPairAnalysis::FinishTask - write histo list to %s \n",
- FairRootManager::Instance()->GetOutFile()->GetName());
+ fprintf(stderr, "AnalysisTaskMultiPairAnalysis::FinishTask - write histo list to %s \n",
+ FairRootManager::Instance()->GetOutFile()->GetName());
FairRootManager::Instance()->GetOutFile()->cd();
fMetaData.GetMetaData()->Write(fMetaData.GetName(), TObject::kSingleKey);
diff --git a/analysis/PWGDIL/dielectron/papaframework/AnalysisTaskMultiPairAnalysis.h b/analysis/PWGDIL/dielectron/papaframework/AnalysisTaskMultiPairAnalysis.h
index 3ab341a7141991c3a11ce9580bccce3b0795fdd9..231aed7483bef34f38a0358733262aebf115ada2 100644
--- a/analysis/PWGDIL/dielectron/papaframework/AnalysisTaskMultiPairAnalysis.h
+++ b/analysis/PWGDIL/dielectron/papaframework/AnalysisTaskMultiPairAnalysis.h
@@ -10,14 +10,14 @@
//# #
//#####################################################
+#include "CbmRichElectronIdAnn.h"
+
+#include "FairTask.h"
+
#include "TList.h"
#include "TStopwatch.h"
#include "TSystem.h"
-
-#include "CbmRichElectronIdAnn.h"
-#include "FairTask.h"
-
#include "AnalysisCuts.h"
#include "PairAnalysisEvent.h"
#include "PairAnalysisMetaData.h"
@@ -30,8 +30,8 @@ class AnalysisTaskMultiPairAnalysis : public FairTask {
public:
AnalysisTaskMultiPairAnalysis();
AnalysisTaskMultiPairAnalysis(const char* name);
- AnalysisTaskMultiPairAnalysis(const char *name,Int_t id);
- AnalysisTaskMultiPairAnalysis(const char *name,Int_t id,Int_t scale);
+ AnalysisTaskMultiPairAnalysis(const char* name, Int_t id);
+ AnalysisTaskMultiPairAnalysis(const char* name, Int_t id, Int_t scale);
virtual ~AnalysisTaskMultiPairAnalysis();
virtual InitStatus Init();
@@ -40,28 +40,26 @@ public:
void SetEventFilter(AnalysisCuts* const filter) { fEventFilter = filter; }
- void AddPairAnalysis(PairAnalysis* const papa) {
+ void AddPairAnalysis(PairAnalysis* const papa)
+ {
fListPairAnalysis.Add((TObject*) papa);
} //why cast to tobject????????
- void SetBeamEnergy(Double_t beamEbyHand = -1.) {
+ void SetBeamEnergy(Double_t beamEbyHand = -1.)
+ {
fBeamEnergy = beamEbyHand;
- Warning(
- "SetBeamEnergy",
- "This function is only kept for backward compatibility!!! Value will be "
- "overwritten, when parameter is availbale (>JUN16 release).");
+ Warning("SetBeamEnergy", "This function is only kept for backward compatibility!!! Value will be "
+ "overwritten, when parameter is availbale (>JUN16 release).");
} // TODO: this should become obsolete in NOV16
protected:
- PairAnalysisMetaData
- fMetaData; //! List of meta data in the framework classes
- TObjArray* fPairArray = NULL; //! output array
- TList fListPairAnalysis; // List of papa framework instances
- TList
- fListHistos; //! List of histogram manager lists in the framework classes
-
- Double_t fBeamEnergy = 0.; // beam energy in GeV (set by hand)
- Int_t fThermalScaling = 0;
-
+ PairAnalysisMetaData fMetaData; //! List of meta data in the framework classes
+ TObjArray* fPairArray = NULL; //! output array
+ TList fListPairAnalysis; // List of papa framework instances
+ TList fListHistos; //! List of histogram manager lists in the framework classes
+
+ Double_t fBeamEnergy = 0.; // beam energy in GeV (set by hand)
+ Int_t fThermalScaling = 0;
+
AnalysisCuts* fEventFilter = NULL; // event filter
PairAnalysisEvent* fInputEvent = NULL; //! event handler
Int_t fEventsTotal = 0; // total number of processed events
@@ -69,11 +67,10 @@ protected:
TStopwatch fTimer; //! stopwatch for cpu consumption
ProcInfo_t fProcInfo; //! memory usage
- Int_t fId=0;
-
+ Int_t fId = 0;
+
AnalysisTaskMultiPairAnalysis(const AnalysisTaskMultiPairAnalysis& c);
- AnalysisTaskMultiPairAnalysis&
- operator=(const AnalysisTaskMultiPairAnalysis& c);
+ AnalysisTaskMultiPairAnalysis& operator=(const AnalysisTaskMultiPairAnalysis& c);
ClassDef(AnalysisTaskMultiPairAnalysis,
4); //Analysis Task handling multiple instances of PairAnalysis
diff --git a/analysis/PWGDIL/dielectron/papaframework/CbmPapaLinkDef.h b/analysis/PWGDIL/dielectron/papaframework/CbmPapaLinkDef.h
index b3050583aeed4040caa88b7d417d2b59e477c878..be584fcae32632555d1c4dbd8baff49eb0cd58b0 100644
--- a/analysis/PWGDIL/dielectron/papaframework/CbmPapaLinkDef.h
+++ b/analysis/PWGDIL/dielectron/papaframework/CbmPapaLinkDef.h
@@ -36,639 +36,232 @@
#pragma link C++ class PairAnalysisHn + ;
///////1D
//w/o weights
-#pragma link C++ function PairAnalysisHistos::AddHistogram( \
- char*, TVectorD*, UInt_t);
-#pragma link C++ function PairAnalysisHistos::AddHistogram( \
- char*, TVectorD*, char*);
+#pragma link C++ function PairAnalysisHistos::AddHistogram(char*, TVectorD*, UInt_t);
+#pragma link C++ function PairAnalysisHistos::AddHistogram(char*, TVectorD*, char*);
//w/ weights
-#pragma link C++ function PairAnalysisHistos::AddHistogram( \
- char*, TVectorD*, UInt_t, UInt_t);
-#pragma link C++ function PairAnalysisHistos::AddHistogram( \
- char*, TVectorD*, UInt_t, char*);
-#pragma link C++ function PairAnalysisHistos::AddHistogram( \
- char*, TVectorD*, char*, UInt_t);
-#pragma link C++ function PairAnalysisHistos::AddHistogram( \
- char*, TVectorD*, char*, char*);
+#pragma link C++ function PairAnalysisHistos::AddHistogram(char*, TVectorD*, UInt_t, UInt_t);
+#pragma link C++ function PairAnalysisHistos::AddHistogram(char*, TVectorD*, UInt_t, char*);
+#pragma link C++ function PairAnalysisHistos::AddHistogram(char*, TVectorD*, char*, UInt_t);
+#pragma link C++ function PairAnalysisHistos::AddHistogram(char*, TVectorD*, char*, char*);
// profs w/o weights
-#pragma link C++ function PairAnalysisHistos::AddProfile( \
- char*, TVectorD*, UInt_t, UInt_t, TString);
-#pragma link C++ function PairAnalysisHistos::AddProfile( \
- char*, TVectorD*, UInt_t, char*, TString);
-#pragma link C++ function PairAnalysisHistos::AddProfile( \
- char*, TVectorD*, char*, UInt_t, TString);
-#pragma link C++ function PairAnalysisHistos::AddProfile( \
- char*, TVectorD*, char*, char*, TString);
+#pragma link C++ function PairAnalysisHistos::AddProfile(char*, TVectorD*, UInt_t, UInt_t, TString);
+#pragma link C++ function PairAnalysisHistos::AddProfile(char*, TVectorD*, UInt_t, char*, TString);
+#pragma link C++ function PairAnalysisHistos::AddProfile(char*, TVectorD*, char*, UInt_t, TString);
+#pragma link C++ function PairAnalysisHistos::AddProfile(char*, TVectorD*, char*, char*, TString);
//w/ weights
-#pragma link C++ function PairAnalysisHistos::AddProfile( \
- char*, TVectorD*, UInt_t, UInt_t, TString, UInt_t);
-#pragma link C++ function PairAnalysisHistos::AddProfile( \
- char*, TVectorD*, UInt_t, char*, TString, UInt_t);
-#pragma link C++ function PairAnalysisHistos::AddProfile( \
- char*, TVectorD*, char*, UInt_t, TString, UInt_t);
-#pragma link C++ function PairAnalysisHistos::AddProfile( \
- char*, TVectorD*, char*, char*, TString, UInt_t);
-#pragma link C++ function PairAnalysisHistos::AddProfile( \
- char*, TVectorD*, UInt_t, UInt_t, TString, char*);
-#pragma link C++ function PairAnalysisHistos::AddProfile( \
- char*, TVectorD*, UInt_t, char*, TString, char*);
-#pragma link C++ function PairAnalysisHistos::AddProfile( \
- char*, TVectorD*, char*, UInt_t, TString, char*);
-#pragma link C++ function PairAnalysisHistos::AddProfile( \
- char*, TVectorD*, char*, char*, TString, char*);
+#pragma link C++ function PairAnalysisHistos::AddProfile(char*, TVectorD*, UInt_t, UInt_t, TString, UInt_t);
+#pragma link C++ function PairAnalysisHistos::AddProfile(char*, TVectorD*, UInt_t, char*, TString, UInt_t);
+#pragma link C++ function PairAnalysisHistos::AddProfile(char*, TVectorD*, char*, UInt_t, TString, UInt_t);
+#pragma link C++ function PairAnalysisHistos::AddProfile(char*, TVectorD*, char*, char*, TString, UInt_t);
+#pragma link C++ function PairAnalysisHistos::AddProfile(char*, TVectorD*, UInt_t, UInt_t, TString, char*);
+#pragma link C++ function PairAnalysisHistos::AddProfile(char*, TVectorD*, UInt_t, char*, TString, char*);
+#pragma link C++ function PairAnalysisHistos::AddProfile(char*, TVectorD*, char*, UInt_t, TString, char*);
+#pragma link C++ function PairAnalysisHistos::AddProfile(char*, TVectorD*, char*, char*, TString, char*);
///////2D
//w/o weights
-#pragma link C++ function PairAnalysisHistos::AddHistogram( \
- char*, TVectorD*, UInt_t, TVectorD*, UInt_t);
-#pragma link C++ function PairAnalysisHistos::AddHistogram( \
- char*, TVectorD*, UInt_t, TVectorD*, char*);
-#pragma link C++ function PairAnalysisHistos::AddHistogram( \
- char*, TVectorD*, char*, TVectorD*, UInt_t);
-#pragma link C++ function PairAnalysisHistos::AddHistogram( \
- char*, TVectorD*, char*, TVectorD*, char*);
+#pragma link C++ function PairAnalysisHistos::AddHistogram(char*, TVectorD*, UInt_t, TVectorD*, UInt_t);
+#pragma link C++ function PairAnalysisHistos::AddHistogram(char*, TVectorD*, UInt_t, TVectorD*, char*);
+#pragma link C++ function PairAnalysisHistos::AddHistogram(char*, TVectorD*, char*, TVectorD*, UInt_t);
+#pragma link C++ function PairAnalysisHistos::AddHistogram(char*, TVectorD*, char*, TVectorD*, char*);
//w/ weights
-#pragma link C++ function PairAnalysisHistos::AddHistogram( \
- char*, TVectorD*, UInt_t, TVectorD*, UInt_t, UInt_t);
-#pragma link C++ function PairAnalysisHistos::AddHistogram( \
- char*, TVectorD*, UInt_t, TVectorD*, UInt_t, char*);
-#pragma link C++ function PairAnalysisHistos::AddHistogram( \
- char*, TVectorD*, UInt_t, TVectorD*, char*, UInt_t);
-#pragma link C++ function PairAnalysisHistos::AddHistogram( \
- char*, TVectorD*, UInt_t, TVectorD*, char*, char*);
-#pragma link C++ function PairAnalysisHistos::AddHistogram( \
- char*, TVectorD*, char*, TVectorD*, UInt_t, UInt_t);
-#pragma link C++ function PairAnalysisHistos::AddHistogram( \
- char*, TVectorD*, char*, TVectorD*, UInt_t, char*);
-#pragma link C++ function PairAnalysisHistos::AddHistogram( \
- char*, TVectorD*, char*, TVectorD*, char*, UInt_t);
-#pragma link C++ function PairAnalysisHistos::AddHistogram( \
- char*, TVectorD*, char*, TVectorD*, char*, char*);
+#pragma link C++ function PairAnalysisHistos::AddHistogram(char*, TVectorD*, UInt_t, TVectorD*, UInt_t, UInt_t);
+#pragma link C++ function PairAnalysisHistos::AddHistogram(char*, TVectorD*, UInt_t, TVectorD*, UInt_t, char*);
+#pragma link C++ function PairAnalysisHistos::AddHistogram(char*, TVectorD*, UInt_t, TVectorD*, char*, UInt_t);
+#pragma link C++ function PairAnalysisHistos::AddHistogram(char*, TVectorD*, UInt_t, TVectorD*, char*, char*);
+#pragma link C++ function PairAnalysisHistos::AddHistogram(char*, TVectorD*, char*, TVectorD*, UInt_t, UInt_t);
+#pragma link C++ function PairAnalysisHistos::AddHistogram(char*, TVectorD*, char*, TVectorD*, UInt_t, char*);
+#pragma link C++ function PairAnalysisHistos::AddHistogram(char*, TVectorD*, char*, TVectorD*, char*, UInt_t);
+#pragma link C++ function PairAnalysisHistos::AddHistogram(char*, TVectorD*, char*, TVectorD*, char*, char*);
//profs w/o weights
-#pragma link C++ function PairAnalysisHistos::AddProfile( \
- char*, TVectorD*, UInt_t, TVectorD*, UInt_t, UInt_t, TString);
-#pragma link C++ function PairAnalysisHistos::AddProfile( \
- char*, TVectorD*, UInt_t, TVectorD*, UInt_t, char*, TString);
-#pragma link C++ function PairAnalysisHistos::AddProfile( \
- char*, TVectorD*, UInt_t, TVectorD*, char*, UInt_t, TString);
-#pragma link C++ function PairAnalysisHistos::AddProfile( \
- char*, TVectorD*, UInt_t, TVectorD*, char*, char*, TString);
-#pragma link C++ function PairAnalysisHistos::AddProfile( \
- char*, TVectorD*, char*, TVectorD*, UInt_t, UInt_t, TString);
-#pragma link C++ function PairAnalysisHistos::AddProfile( \
- char*, TVectorD*, char*, TVectorD*, UInt_t, char*, TString);
-#pragma link C++ function PairAnalysisHistos::AddProfile( \
- char*, TVectorD*, char*, TVectorD*, char*, UInt_t, TString);
-#pragma link C++ function PairAnalysisHistos::AddProfile( \
- char*, TVectorD*, char*, TVectorD*, char*, char*, TString);
+#pragma link C++ function PairAnalysisHistos::AddProfile(char*, TVectorD*, UInt_t, TVectorD*, UInt_t, UInt_t, TString);
+#pragma link C++ function PairAnalysisHistos::AddProfile(char*, TVectorD*, UInt_t, TVectorD*, UInt_t, char*, TString);
+#pragma link C++ function PairAnalysisHistos::AddProfile(char*, TVectorD*, UInt_t, TVectorD*, char*, UInt_t, TString);
+#pragma link C++ function PairAnalysisHistos::AddProfile(char*, TVectorD*, UInt_t, TVectorD*, char*, char*, TString);
+#pragma link C++ function PairAnalysisHistos::AddProfile(char*, TVectorD*, char*, TVectorD*, UInt_t, UInt_t, TString);
+#pragma link C++ function PairAnalysisHistos::AddProfile(char*, TVectorD*, char*, TVectorD*, UInt_t, char*, TString);
+#pragma link C++ function PairAnalysisHistos::AddProfile(char*, TVectorD*, char*, TVectorD*, char*, UInt_t, TString);
+#pragma link C++ function PairAnalysisHistos::AddProfile(char*, TVectorD*, char*, TVectorD*, char*, char*, TString);
//w/ weights
-#pragma link C++ function PairAnalysisHistos::AddProfile( \
- char*, TVectorD*, UInt_t, TVectorD*, UInt_t, UInt_t, TString, UInt_t);
-#pragma link C++ function PairAnalysisHistos::AddProfile( \
- char*, TVectorD*, UInt_t, TVectorD*, UInt_t, char*, TString, UInt_t);
-#pragma link C++ function PairAnalysisHistos::AddProfile( \
- char*, TVectorD*, UInt_t, TVectorD*, char*, UInt_t, TString, UInt_t);
-#pragma link C++ function PairAnalysisHistos::AddProfile( \
- char*, TVectorD*, UInt_t, TVectorD*, char*, char*, TString, UInt_t);
-#pragma link C++ function PairAnalysisHistos::AddProfile( \
- char*, TVectorD*, char*, TVectorD*, UInt_t, UInt_t, TString, UInt_t);
-#pragma link C++ function PairAnalysisHistos::AddProfile( \
- char*, TVectorD*, char*, TVectorD*, UInt_t, char*, TString, UInt_t);
-#pragma link C++ function PairAnalysisHistos::AddProfile( \
- char*, TVectorD*, char*, TVectorD*, char*, UInt_t, TString, UInt_t);
-#pragma link C++ function PairAnalysisHistos::AddProfile( \
- char*, TVectorD*, char*, TVectorD*, char*, char*, TString, UInt_t);
-#pragma link C++ function PairAnalysisHistos::AddProfile( \
- char*, TVectorD*, UInt_t, TVectorD*, UInt_t, UInt_t, TString, char*);
-#pragma link C++ function PairAnalysisHistos::AddProfile( \
- char*, TVectorD*, UInt_t, TVectorD*, UInt_t, char*, TString, char*);
-#pragma link C++ function PairAnalysisHistos::AddProfile( \
- char*, TVectorD*, UInt_t, TVectorD*, char*, UInt_t, TString, char*);
-#pragma link C++ function PairAnalysisHistos::AddProfile( \
- char*, TVectorD*, UInt_t, TVectorD*, char*, char*, TString, char*);
-#pragma link C++ function PairAnalysisHistos::AddProfile( \
- char*, TVectorD*, char*, TVectorD*, UInt_t, UInt_t, TString, char*);
-#pragma link C++ function PairAnalysisHistos::AddProfile( \
- char*, TVectorD*, char*, TVectorD*, UInt_t, char*, TString, char*);
-#pragma link C++ function PairAnalysisHistos::AddProfile( \
- char*, TVectorD*, char*, TVectorD*, char*, UInt_t, TString, char*);
-#pragma link C++ function PairAnalysisHistos::AddProfile( \
- char*, TVectorD*, char*, TVectorD*, char*, char*, TString, char*);
-////// 3D
-//w/o weights
-#pragma link C++ function PairAnalysisHistos::AddHistogram( \
- char*, TVectorD*, UInt_t, TVectorD*, UInt_t, TVectorD*, UInt_t);
-#pragma link C++ function PairAnalysisHistos::AddHistogram( \
- char*, TVectorD*, UInt_t, TVectorD*, UInt_t, TVectorD*, char*);
-#pragma link C++ function PairAnalysisHistos::AddHistogram( \
- char*, TVectorD*, UInt_t, TVectorD*, char*, TVectorD*, UInt_t);
-#pragma link C++ function PairAnalysisHistos::AddHistogram( \
- char*, TVectorD*, UInt_t, TVectorD*, char*, TVectorD*, char*);
-#pragma link C++ function PairAnalysisHistos::AddHistogram( \
- char*, TVectorD*, char*, TVectorD*, UInt_t, TVectorD*, UInt_t);
-#pragma link C++ function PairAnalysisHistos::AddHistogram( \
- char*, TVectorD*, char*, TVectorD*, UInt_t, TVectorD*, char*);
-#pragma link C++ function PairAnalysisHistos::AddHistogram( \
- char*, TVectorD*, char*, TVectorD*, char*, TVectorD*, UInt_t);
-#pragma link C++ function PairAnalysisHistos::AddHistogram( \
- char*, TVectorD*, char*, TVectorD*, char*, TVectorD*, char*);
-//w/ weights
-#pragma link C++ function PairAnalysisHistos::AddHistogram( \
- char*, TVectorD*, UInt_t, TVectorD*, UInt_t, TVectorD*, UInt_t, UInt_t);
-#pragma link C++ function PairAnalysisHistos::AddHistogram( \
- char*, TVectorD*, UInt_t, TVectorD*, UInt_t, TVectorD*, char*, UInt_t);
-#pragma link C++ function PairAnalysisHistos::AddHistogram( \
- char*, TVectorD*, UInt_t, TVectorD*, char*, TVectorD*, UInt_t, UInt_t);
-#pragma link C++ function PairAnalysisHistos::AddHistogram( \
- char*, TVectorD*, UInt_t, TVectorD*, char*, TVectorD*, char*, UInt_t);
-#pragma link C++ function PairAnalysisHistos::AddHistogram( \
- char*, TVectorD*, char*, TVectorD*, UInt_t, TVectorD*, UInt_t, UInt_t);
-#pragma link C++ function PairAnalysisHistos::AddHistogram( \
- char*, TVectorD*, char*, TVectorD*, UInt_t, TVectorD*, char*, UInt_t);
-#pragma link C++ function PairAnalysisHistos::AddHistogram( \
- char*, TVectorD*, char*, TVectorD*, char*, TVectorD*, UInt_t, UInt_t);
-#pragma link C++ function PairAnalysisHistos::AddHistogram( \
- char*, TVectorD*, char*, TVectorD*, char*, TVectorD*, char*, UInt_t);
-#pragma link C++ function PairAnalysisHistos::AddHistogram( \
- char*, TVectorD*, UInt_t, TVectorD*, UInt_t, TVectorD*, UInt_t, char*);
-#pragma link C++ function PairAnalysisHistos::AddHistogram( \
- char*, TVectorD*, UInt_t, TVectorD*, UInt_t, TVectorD*, char*, char*);
-#pragma link C++ function PairAnalysisHistos::AddHistogram( \
- char*, TVectorD*, UInt_t, TVectorD*, char*, TVectorD*, UInt_t, char*);
-#pragma link C++ function PairAnalysisHistos::AddHistogram( \
- char*, TVectorD*, UInt_t, TVectorD*, char*, TVectorD*, char*, char*);
-#pragma link C++ function PairAnalysisHistos::AddHistogram( \
- char*, TVectorD*, char*, TVectorD*, UInt_t, TVectorD*, UInt_t, char*);
-#pragma link C++ function PairAnalysisHistos::AddHistogram( \
- char*, TVectorD*, char*, TVectorD*, UInt_t, TVectorD*, char*, char*);
-#pragma link C++ function PairAnalysisHistos::AddHistogram( \
- char*, TVectorD*, char*, TVectorD*, char*, TVectorD*, UInt_t, char*);
-#pragma link C++ function PairAnalysisHistos::AddHistogram( \
- char*, TVectorD*, char*, TVectorD*, char*, TVectorD*, char*, char*);
-//profs w/o weights
-#pragma link C++ function PairAnalysisHistos::AddProfile(char*, \
- TVectorD*, \
- UInt_t, \
- TVectorD*, \
- UInt_t, \
- TVectorD*, \
- UInt_t, \
- UInt_t, \
- TString);
-#pragma link C++ function PairAnalysisHistos::AddProfile(char*, \
- TVectorD*, \
- UInt_t, \
- TVectorD*, \
- UInt_t, \
- TVectorD*, \
- char*, \
- UInt_t, \
- TString);
-#pragma link C++ function PairAnalysisHistos::AddProfile(char*, \
- TVectorD*, \
- UInt_t, \
- TVectorD*, \
- char*, \
- TVectorD*, \
- UInt_t, \
- UInt_t, \
- TString);
-#pragma link C++ function PairAnalysisHistos::AddProfile(char*, \
- TVectorD*, \
- UInt_t, \
- TVectorD*, \
- char*, \
- TVectorD*, \
- char*, \
- UInt_t, \
- TString);
-#pragma link C++ function PairAnalysisHistos::AddProfile(char*, \
- TVectorD*, \
- char*, \
- TVectorD*, \
- UInt_t, \
- TVectorD*, \
- UInt_t, \
- UInt_t, \
- TString);
-#pragma link C++ function PairAnalysisHistos::AddProfile(char*, \
- TVectorD*, \
- char*, \
- TVectorD*, \
- UInt_t, \
- TVectorD*, \
- char*, \
- UInt_t, \
- TString);
-#pragma link C++ function PairAnalysisHistos::AddProfile(char*, \
- TVectorD*, \
- char*, \
- TVectorD*, \
- char*, \
- TVectorD*, \
- UInt_t, \
- UInt_t, \
- TString);
-#pragma link C++ function PairAnalysisHistos::AddProfile(char*, \
- TVectorD*, \
- char*, \
- TVectorD*, \
- char*, \
- TVectorD*, \
- char*, \
- UInt_t, \
- TString);
-#pragma link C++ function PairAnalysisHistos::AddProfile(char*, \
- TVectorD*, \
- UInt_t, \
- TVectorD*, \
- UInt_t, \
- TVectorD*, \
- UInt_t, \
- char*, \
- TString);
-#pragma link C++ function PairAnalysisHistos::AddProfile(char*, \
- TVectorD*, \
- UInt_t, \
- TVectorD*, \
- UInt_t, \
- TVectorD*, \
- char*, \
- char*, \
- TString);
-#pragma link C++ function PairAnalysisHistos::AddProfile(char*, \
- TVectorD*, \
- UInt_t, \
- TVectorD*, \
- char*, \
- TVectorD*, \
- UInt_t, \
- char*, \
- TString);
-#pragma link C++ function PairAnalysisHistos::AddProfile(char*, \
- TVectorD*, \
- UInt_t, \
- TVectorD*, \
- char*, \
- TVectorD*, \
- char*, \
- char*, \
- TString);
-#pragma link C++ function PairAnalysisHistos::AddProfile(char*, \
- TVectorD*, \
- char*, \
- TVectorD*, \
- UInt_t, \
- TVectorD*, \
- UInt_t, \
- char*, \
- TString);
-#pragma link C++ function PairAnalysisHistos::AddProfile(char*, \
- TVectorD*, \
- char*, \
- TVectorD*, \
- UInt_t, \
- TVectorD*, \
- char*, \
- char*, \
- TString);
-#pragma link C++ function PairAnalysisHistos::AddProfile(char*, \
- TVectorD*, \
- char*, \
- TVectorD*, \
- char*, \
- TVectorD*, \
- UInt_t, \
- char*, \
- TString);
-#pragma link C++ function PairAnalysisHistos::AddProfile(char*, \
- TVectorD*, \
- char*, \
- TVectorD*, \
- char*, \
- TVectorD*, \
- char*, \
- char*, \
- TString);
-//w/ weights
-#pragma link C++ function PairAnalysisHistos::AddProfile(char*, \
- TVectorD*, \
- UInt_t, \
- TVectorD*, \
- UInt_t, \
- TVectorD*, \
- UInt_t, \
- UInt_t, \
- TString, \
- UInt_t);
-#pragma link C++ function PairAnalysisHistos::AddProfile(char*, \
- TVectorD*, \
- UInt_t, \
- TVectorD*, \
- UInt_t, \
- TVectorD*, \
- char*, \
- UInt_t, \
- TString, \
- UInt_t);
-#pragma link C++ function PairAnalysisHistos::AddProfile(char*, \
- TVectorD*, \
- UInt_t, \
- TVectorD*, \
- char*, \
- TVectorD*, \
- UInt_t, \
- UInt_t, \
- TString, \
- UInt_t);
-#pragma link C++ function PairAnalysisHistos::AddProfile(char*, \
- TVectorD*, \
- UInt_t, \
- TVectorD*, \
- char*, \
- TVectorD*, \
- char*, \
- UInt_t, \
- TString, \
- UInt_t);
-#pragma link C++ function PairAnalysisHistos::AddProfile(char*, \
- TVectorD*, \
- char*, \
- TVectorD*, \
- UInt_t, \
- TVectorD*, \
- UInt_t, \
- UInt_t, \
- TString, \
- UInt_t);
-#pragma link C++ function PairAnalysisHistos::AddProfile(char*, \
- TVectorD*, \
- char*, \
- TVectorD*, \
- UInt_t, \
- TVectorD*, \
- char*, \
- UInt_t, \
- TString, \
- UInt_t);
-#pragma link C++ function PairAnalysisHistos::AddProfile(char*, \
- TVectorD*, \
- char*, \
- TVectorD*, \
- char*, \
- TVectorD*, \
- UInt_t, \
- UInt_t, \
- TString, \
- UInt_t);
-#pragma link C++ function PairAnalysisHistos::AddProfile(char*, \
- TVectorD*, \
- char*, \
- TVectorD*, \
- char*, \
- TVectorD*, \
- char*, \
- UInt_t, \
- TString, \
- UInt_t);
-#pragma link C++ function PairAnalysisHistos::AddProfile(char*, \
- TVectorD*, \
- UInt_t, \
- TVectorD*, \
- UInt_t, \
- TVectorD*, \
- UInt_t, \
- char*, \
- TString, \
+#pragma link C++ function PairAnalysisHistos::AddProfile(char*, TVectorD*, UInt_t, TVectorD*, UInt_t, UInt_t, TString, \
UInt_t);
-#pragma link C++ function PairAnalysisHistos::AddProfile(char*, \
- TVectorD*, \
- UInt_t, \
- TVectorD*, \
- UInt_t, \
- TVectorD*, \
- char*, \
- char*, \
- TString, \
+#pragma link C++ function PairAnalysisHistos::AddProfile(char*, TVectorD*, UInt_t, TVectorD*, UInt_t, char*, TString, \
UInt_t);
-#pragma link C++ function PairAnalysisHistos::AddProfile(char*, \
- TVectorD*, \
- UInt_t, \
- TVectorD*, \
- char*, \
- TVectorD*, \
- UInt_t, \
- char*, \
- TString, \
+#pragma link C++ function PairAnalysisHistos::AddProfile(char*, TVectorD*, UInt_t, TVectorD*, char*, UInt_t, TString, \
UInt_t);
-#pragma link C++ function PairAnalysisHistos::AddProfile(char*, \
- TVectorD*, \
- UInt_t, \
- TVectorD*, \
- char*, \
- TVectorD*, \
- char*, \
- char*, \
- TString, \
+#pragma link C++ function PairAnalysisHistos::AddProfile(char*, TVectorD*, UInt_t, TVectorD*, char*, char*, TString, \
UInt_t);
-#pragma link C++ function PairAnalysisHistos::AddProfile(char*, \
- TVectorD*, \
- char*, \
- TVectorD*, \
- UInt_t, \
- TVectorD*, \
- UInt_t, \
- char*, \
- TString, \
+#pragma link C++ function PairAnalysisHistos::AddProfile(char*, TVectorD*, char*, TVectorD*, UInt_t, UInt_t, TString, \
UInt_t);
-#pragma link C++ function PairAnalysisHistos::AddProfile(char*, \
- TVectorD*, \
- char*, \
- TVectorD*, \
- UInt_t, \
- TVectorD*, \
- char*, \
- char*, \
- TString, \
+#pragma link C++ function PairAnalysisHistos::AddProfile(char*, TVectorD*, char*, TVectorD*, UInt_t, char*, TString, \
UInt_t);
-#pragma link C++ function PairAnalysisHistos::AddProfile(char*, \
- TVectorD*, \
- char*, \
- TVectorD*, \
- char*, \
- TVectorD*, \
- UInt_t, \
- char*, \
- TString, \
+#pragma link C++ function PairAnalysisHistos::AddProfile(char*, TVectorD*, char*, TVectorD*, char*, UInt_t, TString, \
UInt_t);
-#pragma link C++ function PairAnalysisHistos::AddProfile(char*, \
- TVectorD*, \
- char*, \
- TVectorD*, \
- char*, \
- TVectorD*, \
- char*, \
- char*, \
- TString, \
+#pragma link C++ function PairAnalysisHistos::AddProfile(char*, TVectorD*, char*, TVectorD*, char*, char*, TString, \
UInt_t);
-#pragma link C++ function PairAnalysisHistos::AddProfile(char*, \
- TVectorD*, \
- UInt_t, \
- TVectorD*, \
- UInt_t, \
- TVectorD*, \
- UInt_t, \
- UInt_t, \
- TString, \
+#pragma link C++ function PairAnalysisHistos::AddProfile(char*, TVectorD*, UInt_t, TVectorD*, UInt_t, UInt_t, TString, \
char*);
-#pragma link C++ function PairAnalysisHistos::AddProfile(char*, \
- TVectorD*, \
- UInt_t, \
- TVectorD*, \
- UInt_t, \
- TVectorD*, \
- char*, \
- UInt_t, \
- TString, \
+#pragma link C++ function PairAnalysisHistos::AddProfile(char*, TVectorD*, UInt_t, TVectorD*, UInt_t, char*, TString, \
char*);
-#pragma link C++ function PairAnalysisHistos::AddProfile(char*, \
- TVectorD*, \
- UInt_t, \
- TVectorD*, \
- char*, \
- TVectorD*, \
- UInt_t, \
- UInt_t, \
- TString, \
+#pragma link C++ function PairAnalysisHistos::AddProfile(char*, TVectorD*, UInt_t, TVectorD*, char*, UInt_t, TString, \
char*);
-#pragma link C++ function PairAnalysisHistos::AddProfile(char*, \
- TVectorD*, \
- UInt_t, \
- TVectorD*, \
- char*, \
- TVectorD*, \
- char*, \
- UInt_t, \
- TString, \
+#pragma link C++ function PairAnalysisHistos::AddProfile(char*, TVectorD*, UInt_t, TVectorD*, char*, char*, TString, \
char*);
-#pragma link C++ function PairAnalysisHistos::AddProfile(char*, \
- TVectorD*, \
- char*, \
- TVectorD*, \
- UInt_t, \
- TVectorD*, \
- UInt_t, \
- UInt_t, \
- TString, \
+#pragma link C++ function PairAnalysisHistos::AddProfile(char*, TVectorD*, char*, TVectorD*, UInt_t, UInt_t, TString, \
char*);
-#pragma link C++ function PairAnalysisHistos::AddProfile(char*, \
- TVectorD*, \
- char*, \
- TVectorD*, \
- UInt_t, \
- TVectorD*, \
- char*, \
- UInt_t, \
- TString, \
+#pragma link C++ function PairAnalysisHistos::AddProfile(char*, TVectorD*, char*, TVectorD*, UInt_t, char*, TString, \
char*);
-#pragma link C++ function PairAnalysisHistos::AddProfile(char*, \
- TVectorD*, \
- char*, \
- TVectorD*, \
- char*, \
- TVectorD*, \
- UInt_t, \
- UInt_t, \
- TString, \
+#pragma link C++ function PairAnalysisHistos::AddProfile(char*, TVectorD*, char*, TVectorD*, char*, UInt_t, TString, \
char*);
-#pragma link C++ function PairAnalysisHistos::AddProfile(char*, \
- TVectorD*, \
- char*, \
- TVectorD*, \
- char*, \
- TVectorD*, \
- char*, \
- UInt_t, \
- TString, \
- char*);
-#pragma link C++ function PairAnalysisHistos::AddProfile(char*, \
- TVectorD*, \
- UInt_t, \
- TVectorD*, \
- UInt_t, \
- TVectorD*, \
- UInt_t, \
- char*, \
- TString, \
- char*);
-#pragma link C++ function PairAnalysisHistos::AddProfile(char*, \
- TVectorD*, \
- UInt_t, \
- TVectorD*, \
- UInt_t, \
- TVectorD*, \
- char*, \
- char*, \
- TString, \
- char*);
-#pragma link C++ function PairAnalysisHistos::AddProfile(char*, \
- TVectorD*, \
- UInt_t, \
- TVectorD*, \
- char*, \
- TVectorD*, \
- UInt_t, \
- char*, \
- TString, \
- char*);
-#pragma link C++ function PairAnalysisHistos::AddProfile(char*, \
- TVectorD*, \
- UInt_t, \
- TVectorD*, \
- char*, \
- TVectorD*, \
- char*, \
- char*, \
- TString, \
- char*);
-#pragma link C++ function PairAnalysisHistos::AddProfile(char*, \
- TVectorD*, \
- char*, \
- TVectorD*, \
- UInt_t, \
- TVectorD*, \
- UInt_t, \
- char*, \
- TString, \
- char*);
-#pragma link C++ function PairAnalysisHistos::AddProfile(char*, \
- TVectorD*, \
- char*, \
- TVectorD*, \
- UInt_t, \
- TVectorD*, \
- char*, \
- char*, \
- TString, \
- char*);
-#pragma link C++ function PairAnalysisHistos::AddProfile(char*, \
- TVectorD*, \
- char*, \
- TVectorD*, \
- char*, \
- TVectorD*, \
- UInt_t, \
- char*, \
- TString, \
- char*);
-#pragma link C++ function PairAnalysisHistos::AddProfile(char*, \
- TVectorD*, \
- char*, \
- TVectorD*, \
- char*, \
- TVectorD*, \
- char*, \
- char*, \
- TString, \
+#pragma link C++ function PairAnalysisHistos::AddProfile(char*, TVectorD*, char*, TVectorD*, char*, char*, TString, \
char*);
+////// 3D
+//w/o weights
+#pragma link C++ function PairAnalysisHistos::AddHistogram(char*, TVectorD*, UInt_t, TVectorD*, UInt_t, TVectorD*, \
+ UInt_t);
+#pragma link C++ function PairAnalysisHistos::AddHistogram(char*, TVectorD*, UInt_t, TVectorD*, UInt_t, TVectorD*, \
+ char*);
+#pragma link C++ function PairAnalysisHistos::AddHistogram(char*, TVectorD*, UInt_t, TVectorD*, char*, TVectorD*, \
+ UInt_t);
+#pragma link C++ function PairAnalysisHistos::AddHistogram(char*, TVectorD*, UInt_t, TVectorD*, char*, TVectorD*, \
+ char*);
+#pragma link C++ function PairAnalysisHistos::AddHistogram(char*, TVectorD*, char*, TVectorD*, UInt_t, TVectorD*, \
+ UInt_t);
+#pragma link C++ function PairAnalysisHistos::AddHistogram(char*, TVectorD*, char*, TVectorD*, UInt_t, TVectorD*, \
+ char*);
+#pragma link C++ function PairAnalysisHistos::AddHistogram(char*, TVectorD*, char*, TVectorD*, char*, TVectorD*, \
+ UInt_t);
+#pragma link C++ function PairAnalysisHistos::AddHistogram(char*, TVectorD*, char*, TVectorD*, char*, TVectorD*, char*);
+//w/ weights
+#pragma link C++ function PairAnalysisHistos::AddHistogram(char*, TVectorD*, UInt_t, TVectorD*, UInt_t, TVectorD*, \
+ UInt_t, UInt_t);
+#pragma link C++ function PairAnalysisHistos::AddHistogram(char*, TVectorD*, UInt_t, TVectorD*, UInt_t, TVectorD*, \
+ char*, UInt_t);
+#pragma link C++ function PairAnalysisHistos::AddHistogram(char*, TVectorD*, UInt_t, TVectorD*, char*, TVectorD*, \
+ UInt_t, UInt_t);
+#pragma link C++ function PairAnalysisHistos::AddHistogram(char*, TVectorD*, UInt_t, TVectorD*, char*, TVectorD*, \
+ char*, UInt_t);
+#pragma link C++ function PairAnalysisHistos::AddHistogram(char*, TVectorD*, char*, TVectorD*, UInt_t, TVectorD*, \
+ UInt_t, UInt_t);
+#pragma link C++ function PairAnalysisHistos::AddHistogram(char*, TVectorD*, char*, TVectorD*, UInt_t, TVectorD*, \
+ char*, UInt_t);
+#pragma link C++ function PairAnalysisHistos::AddHistogram(char*, TVectorD*, char*, TVectorD*, char*, TVectorD*, \
+ UInt_t, UInt_t);
+#pragma link C++ function PairAnalysisHistos::AddHistogram(char*, TVectorD*, char*, TVectorD*, char*, TVectorD*, \
+ char*, UInt_t);
+#pragma link C++ function PairAnalysisHistos::AddHistogram(char*, TVectorD*, UInt_t, TVectorD*, UInt_t, TVectorD*, \
+ UInt_t, char*);
+#pragma link C++ function PairAnalysisHistos::AddHistogram(char*, TVectorD*, UInt_t, TVectorD*, UInt_t, TVectorD*, \
+ char*, char*);
+#pragma link C++ function PairAnalysisHistos::AddHistogram(char*, TVectorD*, UInt_t, TVectorD*, char*, TVectorD*, \
+ UInt_t, char*);
+#pragma link C++ function PairAnalysisHistos::AddHistogram(char*, TVectorD*, UInt_t, TVectorD*, char*, TVectorD*, \
+ char*, char*);
+#pragma link C++ function PairAnalysisHistos::AddHistogram(char*, TVectorD*, char*, TVectorD*, UInt_t, TVectorD*, \
+ UInt_t, char*);
+#pragma link C++ function PairAnalysisHistos::AddHistogram(char*, TVectorD*, char*, TVectorD*, UInt_t, TVectorD*, \
+ char*, char*);
+#pragma link C++ function PairAnalysisHistos::AddHistogram(char*, TVectorD*, char*, TVectorD*, char*, TVectorD*, \
+ UInt_t, char*);
+#pragma link C++ function PairAnalysisHistos::AddHistogram(char*, TVectorD*, char*, TVectorD*, char*, TVectorD*, \
+ char*, char*);
+//profs w/o weights
+#pragma link C++ function PairAnalysisHistos::AddProfile(char*, TVectorD*, UInt_t, TVectorD*, UInt_t, TVectorD*, \
+ UInt_t, UInt_t, TString);
+#pragma link C++ function PairAnalysisHistos::AddProfile(char*, TVectorD*, UInt_t, TVectorD*, UInt_t, TVectorD*, \
+ char*, UInt_t, TString);
+#pragma link C++ function PairAnalysisHistos::AddProfile(char*, TVectorD*, UInt_t, TVectorD*, char*, TVectorD*, \
+ UInt_t, UInt_t, TString);
+#pragma link C++ function PairAnalysisHistos::AddProfile(char*, TVectorD*, UInt_t, TVectorD*, char*, TVectorD*, char*, \
+ UInt_t, TString);
+#pragma link C++ function PairAnalysisHistos::AddProfile(char*, TVectorD*, char*, TVectorD*, UInt_t, TVectorD*, \
+ UInt_t, UInt_t, TString);
+#pragma link C++ function PairAnalysisHistos::AddProfile(char*, TVectorD*, char*, TVectorD*, UInt_t, TVectorD*, char*, \
+ UInt_t, TString);
+#pragma link C++ function PairAnalysisHistos::AddProfile(char*, TVectorD*, char*, TVectorD*, char*, TVectorD*, UInt_t, \
+ UInt_t, TString);
+#pragma link C++ function PairAnalysisHistos::AddProfile(char*, TVectorD*, char*, TVectorD*, char*, TVectorD*, char*, \
+ UInt_t, TString);
+#pragma link C++ function PairAnalysisHistos::AddProfile(char*, TVectorD*, UInt_t, TVectorD*, UInt_t, TVectorD*, \
+ UInt_t, char*, TString);
+#pragma link C++ function PairAnalysisHistos::AddProfile(char*, TVectorD*, UInt_t, TVectorD*, UInt_t, TVectorD*, \
+ char*, char*, TString);
+#pragma link C++ function PairAnalysisHistos::AddProfile(char*, TVectorD*, UInt_t, TVectorD*, char*, TVectorD*, \
+ UInt_t, char*, TString);
+#pragma link C++ function PairAnalysisHistos::AddProfile(char*, TVectorD*, UInt_t, TVectorD*, char*, TVectorD*, char*, \
+ char*, TString);
+#pragma link C++ function PairAnalysisHistos::AddProfile(char*, TVectorD*, char*, TVectorD*, UInt_t, TVectorD*, \
+ UInt_t, char*, TString);
+#pragma link C++ function PairAnalysisHistos::AddProfile(char*, TVectorD*, char*, TVectorD*, UInt_t, TVectorD*, char*, \
+ char*, TString);
+#pragma link C++ function PairAnalysisHistos::AddProfile(char*, TVectorD*, char*, TVectorD*, char*, TVectorD*, UInt_t, \
+ char*, TString);
+#pragma link C++ function PairAnalysisHistos::AddProfile(char*, TVectorD*, char*, TVectorD*, char*, TVectorD*, char*, \
+ char*, TString);
+//w/ weights
+#pragma link C++ function PairAnalysisHistos::AddProfile(char*, TVectorD*, UInt_t, TVectorD*, UInt_t, TVectorD*, \
+ UInt_t, UInt_t, TString, UInt_t);
+#pragma link C++ function PairAnalysisHistos::AddProfile(char*, TVectorD*, UInt_t, TVectorD*, UInt_t, TVectorD*, \
+ char*, UInt_t, TString, UInt_t);
+#pragma link C++ function PairAnalysisHistos::AddProfile(char*, TVectorD*, UInt_t, TVectorD*, char*, TVectorD*, \
+ UInt_t, UInt_t, TString, UInt_t);
+#pragma link C++ function PairAnalysisHistos::AddProfile(char*, TVectorD*, UInt_t, TVectorD*, char*, TVectorD*, char*, \
+ UInt_t, TString, UInt_t);
+#pragma link C++ function PairAnalysisHistos::AddProfile(char*, TVectorD*, char*, TVectorD*, UInt_t, TVectorD*, \
+ UInt_t, UInt_t, TString, UInt_t);
+#pragma link C++ function PairAnalysisHistos::AddProfile(char*, TVectorD*, char*, TVectorD*, UInt_t, TVectorD*, char*, \
+ UInt_t, TString, UInt_t);
+#pragma link C++ function PairAnalysisHistos::AddProfile(char*, TVectorD*, char*, TVectorD*, char*, TVectorD*, UInt_t, \
+ UInt_t, TString, UInt_t);
+#pragma link C++ function PairAnalysisHistos::AddProfile(char*, TVectorD*, char*, TVectorD*, char*, TVectorD*, char*, \
+ UInt_t, TString, UInt_t);
+#pragma link C++ function PairAnalysisHistos::AddProfile(char*, TVectorD*, UInt_t, TVectorD*, UInt_t, TVectorD*, \
+ UInt_t, char*, TString, UInt_t);
+#pragma link C++ function PairAnalysisHistos::AddProfile(char*, TVectorD*, UInt_t, TVectorD*, UInt_t, TVectorD*, \
+ char*, char*, TString, UInt_t);
+#pragma link C++ function PairAnalysisHistos::AddProfile(char*, TVectorD*, UInt_t, TVectorD*, char*, TVectorD*, \
+ UInt_t, char*, TString, UInt_t);
+#pragma link C++ function PairAnalysisHistos::AddProfile(char*, TVectorD*, UInt_t, TVectorD*, char*, TVectorD*, char*, \
+ char*, TString, UInt_t);
+#pragma link C++ function PairAnalysisHistos::AddProfile(char*, TVectorD*, char*, TVectorD*, UInt_t, TVectorD*, \
+ UInt_t, char*, TString, UInt_t);
+#pragma link C++ function PairAnalysisHistos::AddProfile(char*, TVectorD*, char*, TVectorD*, UInt_t, TVectorD*, char*, \
+ char*, TString, UInt_t);
+#pragma link C++ function PairAnalysisHistos::AddProfile(char*, TVectorD*, char*, TVectorD*, char*, TVectorD*, UInt_t, \
+ char*, TString, UInt_t);
+#pragma link C++ function PairAnalysisHistos::AddProfile(char*, TVectorD*, char*, TVectorD*, char*, TVectorD*, char*, \
+ char*, TString, UInt_t);
+#pragma link C++ function PairAnalysisHistos::AddProfile(char*, TVectorD*, UInt_t, TVectorD*, UInt_t, TVectorD*, \
+ UInt_t, UInt_t, TString, char*);
+#pragma link C++ function PairAnalysisHistos::AddProfile(char*, TVectorD*, UInt_t, TVectorD*, UInt_t, TVectorD*, \
+ char*, UInt_t, TString, char*);
+#pragma link C++ function PairAnalysisHistos::AddProfile(char*, TVectorD*, UInt_t, TVectorD*, char*, TVectorD*, \
+ UInt_t, UInt_t, TString, char*);
+#pragma link C++ function PairAnalysisHistos::AddProfile(char*, TVectorD*, UInt_t, TVectorD*, char*, TVectorD*, char*, \
+ UInt_t, TString, char*);
+#pragma link C++ function PairAnalysisHistos::AddProfile(char*, TVectorD*, char*, TVectorD*, UInt_t, TVectorD*, \
+ UInt_t, UInt_t, TString, char*);
+#pragma link C++ function PairAnalysisHistos::AddProfile(char*, TVectorD*, char*, TVectorD*, UInt_t, TVectorD*, char*, \
+ UInt_t, TString, char*);
+#pragma link C++ function PairAnalysisHistos::AddProfile(char*, TVectorD*, char*, TVectorD*, char*, TVectorD*, UInt_t, \
+ UInt_t, TString, char*);
+#pragma link C++ function PairAnalysisHistos::AddProfile(char*, TVectorD*, char*, TVectorD*, char*, TVectorD*, char*, \
+ UInt_t, TString, char*);
+#pragma link C++ function PairAnalysisHistos::AddProfile(char*, TVectorD*, UInt_t, TVectorD*, UInt_t, TVectorD*, \
+ UInt_t, char*, TString, char*);
+#pragma link C++ function PairAnalysisHistos::AddProfile(char*, TVectorD*, UInt_t, TVectorD*, UInt_t, TVectorD*, \
+ char*, char*, TString, char*);
+#pragma link C++ function PairAnalysisHistos::AddProfile(char*, TVectorD*, UInt_t, TVectorD*, char*, TVectorD*, \
+ UInt_t, char*, TString, char*);
+#pragma link C++ function PairAnalysisHistos::AddProfile(char*, TVectorD*, UInt_t, TVectorD*, char*, TVectorD*, char*, \
+ char*, TString, char*);
+#pragma link C++ function PairAnalysisHistos::AddProfile(char*, TVectorD*, char*, TVectorD*, UInt_t, TVectorD*, \
+ UInt_t, char*, TString, char*);
+#pragma link C++ function PairAnalysisHistos::AddProfile(char*, TVectorD*, char*, TVectorD*, UInt_t, TVectorD*, char*, \
+ char*, TString, char*);
+#pragma link C++ function PairAnalysisHistos::AddProfile(char*, TVectorD*, char*, TVectorD*, char*, TVectorD*, UInt_t, \
+ char*, TString, char*);
+#pragma link C++ function PairAnalysisHistos::AddProfile(char*, TVectorD*, char*, TVectorD*, char*, TVectorD*, char*, \
+ char*, TString, char*);
//#pragma link C++ class PairAnalysisHistosHelper+;
diff --git a/analysis/PWGDIL/dielectron/papaframework/PairAnalysis.cxx b/analysis/PWGDIL/dielectron/papaframework/PairAnalysis.cxx
index 3098ae5deed364324eb8abaefb10e24bb08db35e..633c2b5527a343ba17d1e501bc0abb23de1bed40 100644
--- a/analysis/PWGDIL/dielectron/papaframework/PairAnalysis.cxx
+++ b/analysis/PWGDIL/dielectron/papaframework/PairAnalysis.cxx
@@ -53,32 +53,30 @@ Some options to add background estimators:
// //
///////////////////////////////////////////////////////////////////////////
-#include <TDatabasePDG.h>
-#include <TLorentzVector.h>
-#include <TRandom3.h>
+#include "CbmHit.h"
+#include "CbmMCTrack.h"
+#include "CbmMatch.h"
+#include "CbmRichRing.h"
+#include "CbmTrack.h"
+
+#include "FairMCPoint.h"
+#include <TDatabasePDG.h>
#include <TGrid.h>
#include <TList.h>
+#include <TLorentzVector.h>
#include <TMath.h>
#include <TObject.h>
+#include <TRandom3.h>
#include <TString.h>
-#include "FairMCPoint.h"
-
-#include "CbmHit.h"
-#include "CbmMCTrack.h"
-#include "CbmMatch.h"
-#include "CbmRichRing.h"
-#include "CbmTrack.h"
-
#include "PairAnalysisEvent.h"
-#include "PairAnalysisTrack.h"
-
#include "PairAnalysisHistos.h"
#include "PairAnalysisMC.h"
#include "PairAnalysisPair.h"
#include "PairAnalysisPairKF.h"
#include "PairAnalysisPairLV.h"
+#include "PairAnalysisTrack.h"
#include "PairAnalysisTrackRotator.h"
#include "PairAnalysisVarManager.h"
//#include "PairAnalysisDebugTree.h"
@@ -86,19 +84,18 @@ Some options to add background estimators:
#include "PairAnalysisPairLegCuts.h"
#include "PairAnalysisSignalMC.h"
//#include "PairAnalysisV0Cuts.h"
-#include "PairAnalysisHistos.h"
-
#include "PairAnalysis.h"
+#include "PairAnalysisHistos.h"
ClassImp(PairAnalysis)
const char* PairAnalysis::fgkTrackClassNames[2] = {"+", "-"};
-const char* PairAnalysis::fgkPairClassNames[8] =
- {"SE++", "SE+-", "SE--", "ME++", "ME-+", "ME+-", "ME--", "TR+-"};
+const char* PairAnalysis::fgkPairClassNames[8] = {"SE++", "SE+-", "SE--", "ME++", "ME-+", "ME+-", "ME--", "TR+-"};
//________________________________________________________________
-PairAnalysis::PairAnalysis() : PairAnalysis("PairAnalysis", "PairAnalysis") {
+PairAnalysis::PairAnalysis() : PairAnalysis("PairAnalysis", "PairAnalysis")
+{
//
// Default constructor
//
@@ -116,14 +113,16 @@ PairAnalysis::PairAnalysis(const char* name, const char* title)
, fTrackFilterMC("TrackFilterMC")
, fPairFilterMC("PairFilterMC")
, fUsedVars(new TBits(PairAnalysisVarManager::kNMaxValuesMC))
- , fPairCandidates(new TObjArray(8)) {
+ , fPairCandidates(new TObjArray(8))
+{
//
// Named constructor
//
}
//________________________________________________________________
-PairAnalysis::~PairAnalysis() {
+PairAnalysis::~PairAnalysis()
+{
//
// Default destructor
//
@@ -138,7 +137,8 @@ PairAnalysis::~PairAnalysis() {
}
//________________________________________________________________
-void PairAnalysis::Init() {
+void PairAnalysis::Init()
+{
//
// Initialise objects
//
@@ -158,8 +158,7 @@ void PairAnalysis::Init() {
// for internal train wagons
if (!fEventProcess) {
- PairAnalysisPairLegCuts* trk2leg =
- new PairAnalysisPairLegCuts("trk2leg", "trk2leg");
+ PairAnalysisPairLegCuts* trk2leg = new PairAnalysisPairLegCuts("trk2leg", "trk2leg");
// move all track cuts (if any) into pair leg cuts
TIter listIterator(fTrackFilter.GetCuts());
while (AnalysisCuts* thisCut = (AnalysisCuts*) listIterator()) {
@@ -190,16 +189,12 @@ void PairAnalysis::Init() {
if (fHistos) { (*fUsedVars) |= (*fHistos->GetUsedVars()); }
// initialize cut step histograms
- if (fTrackFilterMC.GetHistogramList() || fTrackFilter.GetHistogramList()
- || fFinalTrackFilter.GetHistogramList()) {
- if (fTrackFilterMC.GetHistogramList())
- fCutStepHistos = fTrackFilterMC.GetHistogramList();
- if (fCutStepHistos)
- fCutStepHistos->AddAll(fTrackFilter.GetHistogramList());
+ if (fTrackFilterMC.GetHistogramList() || fTrackFilter.GetHistogramList() || fFinalTrackFilter.GetHistogramList()) {
+ if (fTrackFilterMC.GetHistogramList()) fCutStepHistos = fTrackFilterMC.GetHistogramList();
+ if (fCutStepHistos) fCutStepHistos->AddAll(fTrackFilter.GetHistogramList());
else
fCutStepHistos = fTrackFilter.GetHistogramList();
- if (fCutStepHistos)
- fCutStepHistos->AddAll(fFinalTrackFilter.GetHistogramList());
+ if (fCutStepHistos) fCutStepHistos->AddAll(fFinalTrackFilter.GetHistogramList());
else
fCutStepHistos = fFinalTrackFilter.GetHistogramList();
fCutStepHistos->SetName(Form("CutSteps_%s", GetName()));
@@ -208,7 +203,8 @@ void PairAnalysis::Init() {
//________________________________________________________________
-void PairAnalysis::Process(TObjArray* arr) {
+void PairAnalysis::Process(TObjArray* arr)
+{
//
// Process the pair array
//
@@ -226,7 +222,8 @@ void PairAnalysis::Process(TObjArray* arr) {
}
//________________________________________________________________
-Bool_t PairAnalysis::Process(PairAnalysisEvent* ev1) {
+Bool_t PairAnalysis::Process(PairAnalysisEvent* ev1)
+{
//
// Process the events
//
@@ -239,9 +236,8 @@ Bool_t PairAnalysis::Process(PairAnalysisEvent* ev1) {
}
/// set reference mass for mt calculation
- PairAnalysisVarManager::SetValue(
- PairAnalysisVarManager::kMPair,
- TDatabasePDG::Instance()->GetParticle(fPdgMother)->Mass());
+ PairAnalysisVarManager::SetValue(PairAnalysisVarManager::kMPair,
+ TDatabasePDG::Instance()->GetParticle(fPdgMother)->Mass());
/// set event
PairAnalysisVarManager::SetFillMap(fUsedVars);
@@ -260,9 +256,8 @@ Bool_t PairAnalysis::Process(PairAnalysisEvent* ev1) {
if (PairAnalysisMC::Instance()->HasMC()) { ProcessMC(); }
/// if candidate array doesn't exist, create it
- if (!fPairCandidates->UncheckedAt(0)) {
- InitPairCandidateArrays();
- } else {
+ if (!fPairCandidates->UncheckedAt(0)) { InitPairCandidateArrays(); }
+ else {
ClearArrays();
}
@@ -279,8 +274,7 @@ Bool_t PairAnalysis::Process(PairAnalysisEvent* ev1) {
FillTrackArrays(ev1);
// prefilter track
- if ((fPreFilterAllSigns || fPreFilterUnlikeOnly)
- && (fPairPreFilter.GetCuts()->GetEntries() > 0))
+ if ((fPreFilterAllSigns || fPreFilterUnlikeOnly) && (fPairPreFilter.GetCuts()->GetEntries() > 0))
PairPreFilter(0, 1, fTracks[0], fTracks[1]);
// remove tracks from arrays that DO NOT pass 2nd cut iteration
@@ -290,10 +284,7 @@ Bool_t PairAnalysis::Process(PairAnalysisEvent* ev1) {
if (!fNoPairing) {
for (Int_t itrackArr1 = 0; itrackArr1 < 2; ++itrackArr1) {
for (Int_t itrackArr2 = itrackArr1; itrackArr2 < 2; ++itrackArr2) {
- if (!fProcessLS
- && GetPairIndex(itrackArr1, itrackArr2)
- != static_cast<Int_t>(EPairType::kSEPM))
- continue;
+ if (!fProcessLS && GetPairIndex(itrackArr1, itrackArr2) != static_cast<Int_t>(EPairType::kSEPM)) continue;
FillPairArrays(itrackArr1, itrackArr2);
}
}
@@ -309,17 +300,14 @@ Bool_t PairAnalysis::Process(PairAnalysisEvent* ev1) {
// fill candidate variables
Double_t ntracks = fTracks[0].GetEntriesFast() + fTracks[1].GetEntriesFast();
- Double_t npairs =
- PairArray(static_cast<Int_t>(EPairType::kSEPM))->GetEntriesFast();
+ Double_t npairs = PairArray(static_cast<Int_t>(EPairType::kSEPM))->GetEntriesFast();
PairAnalysisVarManager::SetValue(PairAnalysisVarManager::kTracks, ntracks);
PairAnalysisVarManager::SetValue(PairAnalysisVarManager::kPairs, npairs);
//in case there is a histogram manager, fill the QA histograms
if (fHistos) FillHistograms(ev1);
// fill histo array with event information only
- if (fHistoArray)
- fHistoArray->Fill(
- 0, const_cast<Double_t*>(PairAnalysisVarManager::GetData()), 0x0, 0x0);
+ if (fHistoArray) fHistoArray->Fill(0, const_cast<Double_t*>(PairAnalysisVarManager::GetData()), 0x0, 0x0);
// clear arrays
if (!fDontClearArrays) ClearArrays();
@@ -328,7 +316,8 @@ Bool_t PairAnalysis::Process(PairAnalysisEvent* ev1) {
}
//________________________________________________________________
-void PairAnalysis::ProcessMC() {
+void PairAnalysis::ProcessMC()
+{
//
// Process the MC data
//
@@ -350,25 +339,18 @@ void PairAnalysis::ProcessMC() {
Bool_t bFillHF = kFALSE;
Bool_t bFillHist = kFALSE;
for (Int_t isig = 0; isig < nSignals; isig++) {
- PairAnalysisSignalMC* sigMC =
- (PairAnalysisSignalMC*) fSignalsMC->UncheckedAt(isig);
+ PairAnalysisSignalMC* sigMC = (PairAnalysisSignalMC*) fSignalsMC->UncheckedAt(isig);
if (!sigMC->GetFillPureMCStep()) continue;
TString sigName = sigMC->GetName();
if (fHistos && !bFillHist) {
- bFillHist |=
- fHistos->HasHistClass(Form("Pair_%s_MCtruth", sigName.Data()));
- bFillHist |=
- fHistos->HasHistClass(Form("Track.Leg_%s_MCtruth", sigName.Data()));
- bFillHist |= fHistos->HasHistClass(
- Form("Track.%s_%s_MCtruth", fgkPairClassNames[1], sigName.Data()));
+ bFillHist |= fHistos->HasHistClass(Form("Pair_%s_MCtruth", sigName.Data()));
+ bFillHist |= fHistos->HasHistClass(Form("Track.Leg_%s_MCtruth", sigName.Data()));
+ bFillHist |= fHistos->HasHistClass(Form("Track.%s_%s_MCtruth", fgkPairClassNames[1], sigName.Data()));
}
if (fHistoArray && !bFillHF) {
- bFillHF |=
- fHistoArray->HasHistClass(Form("Pair_%s_MCtruth", sigName.Data()));
- bFillHF |=
- fHistoArray->HasHistClass(Form("Track.Leg_%s_MCtruth", sigName.Data()));
- bFillHF |= fHistoArray->HasHistClass(
- Form("Track.%s_%s_MCtruth", fgkPairClassNames[1], sigName.Data()));
+ bFillHF |= fHistoArray->HasHistClass(Form("Pair_%s_MCtruth", sigName.Data()));
+ bFillHF |= fHistoArray->HasHistClass(Form("Track.Leg_%s_MCtruth", sigName.Data()));
+ bFillHF |= fHistoArray->HasHistClass(Form("Track.%s_%s_MCtruth", fgkPairClassNames[1], sigName.Data()));
}
}
@@ -421,33 +403,30 @@ void PairAnalysis::ProcessMC() {
if (fCutQA) fQAmonitor->Fill(cutmask, mctrk);
/// fill detailed cut histograms
- if (fTrackFilterMC.GetHistogramList()->GetSize())
- FillCutStepHistogramsMC(&fTrackFilterMC, cutmask, ipart, values);
+ if (fTrackFilterMC.GetHistogramList()->GetSize()) FillCutStepHistogramsMC(&fTrackFilterMC, cutmask, ipart, values);
// rejection
if (cutmask != selectedMask) continue;
// loop over signals
for (Int_t isig = 0; isig < nSignals; ++isig) {
- PairAnalysisSignalMC* sigMC =
- (PairAnalysisSignalMC*) fSignalsMC->UncheckedAt(isig);
+ PairAnalysisSignalMC* sigMC = (PairAnalysisSignalMC*) fSignalsMC->UncheckedAt(isig);
// NOTE: Some signals can be satisfied by many particles and this leads to high
// computation times (e.g. secondary electrons from the GEANT transport). Be aware of this!!
// Proceed only if this signal is required in the pure MC step
if (!sigMC->GetFillPureMCStep()) continue;
- truth1 = papaMC->IsMCTruth(
- ipart, (PairAnalysisSignalMC*) fSignalsMC->UncheckedAt(isig), 1);
+ truth1 = papaMC->IsMCTruth(ipart, (PairAnalysisSignalMC*) fSignalsMC->UncheckedAt(isig), 1);
/// NOTE: single particle signals staisfy only the first branch, truth2=kFALSE in this case
- truth2 = papaMC->IsMCTruth(
- ipart, (PairAnalysisSignalMC*) fSignalsMC->UncheckedAt(isig), 2);
+ truth2 = papaMC->IsMCTruth(ipart, (PairAnalysisSignalMC*) fSignalsMC->UncheckedAt(isig), 2);
// particles satisfying both branches are treated separately to avoid double counting during pairing
if (truth1 && truth2) {
labels12[isig][indexes12[isig]] = ipart;
++indexes12[isig];
- } else {
+ }
+ else {
if (truth1) {
labels1[isig][indexes1[isig]] = ipart;
++indexes1[isig];
@@ -494,8 +473,7 @@ void PairAnalysis::ProcessMC() {
// selection of MCtruth pairs
UInt_t cutmask = 0;
- if (mother)
- cutmask = fPairFilterMC.IsSelected(mother);
+ if (mother) cutmask = fPairFilterMC.IsSelected(mother);
else {
/// TODO: do we really want to look at combinatorics at the genrator level?
/// this might saves a lot of cpu time and combinatorics on MCtruth level is useless
@@ -507,11 +485,9 @@ void PairAnalysis::ProcessMC() {
//apply MC truth pair cuts
if (cutmask != selectedMask) continue;
- if (bFillHF)
- fHistoArray->Fill(labels1[isig][i1], labels2[isig][i2], isig);
+ if (bFillHF) fHistoArray->Fill(labels1[isig][i1], labels2[isig][i2], isig);
if (bFillHist) {
- if (FillMCHistograms(labels1[isig][i1], labels2[isig][i2], isig))
- break;
+ if (FillMCHistograms(labels1[isig][i1], labels2[isig][i2], isig)) break;
}
}
}
@@ -531,8 +507,7 @@ void PairAnalysis::ProcessMC() {
// selection of MCtruth pairs
UInt_t cutmask = 0;
- if (mother)
- cutmask = fPairFilterMC.IsSelected(mother);
+ if (mother) cutmask = fPairFilterMC.IsSelected(mother);
else {
/// NOTE: at the moment this is avoided by the 'break' after FillMCHistograms (see above NOTE)
pair->SetMCTracks(part1, part2);
@@ -541,11 +516,9 @@ void PairAnalysis::ProcessMC() {
//apply MC truth pair cuts
if (cutmask != selectedMask) continue;
- if (bFillHF)
- fHistoArray->Fill(labels12[isig][i1], labels12[isig][i2], isig);
+ if (bFillHF) fHistoArray->Fill(labels12[isig][i1], labels12[isig][i2], isig);
if (bFillHist) {
- if (FillMCHistograms(labels12[isig][i1], labels12[isig][i2], isig))
- break;
+ if (FillMCHistograms(labels12[isig][i1], labels12[isig][i2], isig)) break;
}
}
}
@@ -567,7 +540,8 @@ void PairAnalysis::ProcessMC() {
}
//________________________________________________________________
-void PairAnalysis::FillHistogramsTracks(TObjArray** tracks) {
+void PairAnalysis::FillHistogramsTracks(TObjArray** tracks)
+{
//
// Fill Histogram information for tracks after prefilter
// ignore mixed events - for prefilter, only single tracks +/- are relevant
@@ -591,8 +565,8 @@ void PairAnalysis::FillHistogramsTracks(TObjArray** tracks) {
//________________________________________________________________
-void PairAnalysis::FillHistogramsMC(const PairAnalysisEvent* /*ev*/,
- PairAnalysisEvent* /*ev1*/) {
+void PairAnalysis::FillHistogramsMC(const PairAnalysisEvent* /*ev*/, PairAnalysisEvent* /*ev1*/)
+{
//
// Fill Histogram information for MCEvents
//
@@ -611,8 +585,8 @@ void PairAnalysis::FillHistogramsMC(const PairAnalysisEvent* /*ev*/,
//________________________________________________________________
-void PairAnalysis::FillHistograms(const PairAnalysisEvent* ev,
- Bool_t pairInfoOnly) {
+void PairAnalysis::FillHistograms(const PairAnalysisEvent* ev, Bool_t pairInfoOnly)
+{
//
// Fill Histogram information for event, pairs, tracks, hits
//
@@ -624,10 +598,8 @@ void PairAnalysis::FillHistograms(const PairAnalysisEvent* ev,
//Fill event information
if (ev) {
- if (fHistos && fHistos->HasHistClass("Event"))
- fHistos->FillClass("Event", values);
- if (fHistoArray && fHistoArray->HasHistClass("Event"))
- fHistoArray->FillClass("Event", values);
+ if (fHistos && fHistos->HasHistClass("Event")) fHistos->FillClass("Event", values);
+ if (fHistoArray && fHistoArray->HasHistClass("Event")) fHistoArray->FillClass("Event", values);
}
//Fill track information, separately for the track array candidates
@@ -639,56 +611,42 @@ void PairAnalysis::FillHistograms(const PairAnalysisEvent* ev,
PairAnalysisSignalMC* sigMC = 0x0;
if (!pairInfoOnly) {
className2.Form("Track.%s", fgkPairClassNames[1]); // unlike sign, SE only
- Bool_t mergedtrkClass = fHistos->HasHistClass(className2);
- Bool_t mergedtrkClass2 =
- (fHistoArray && fHistoArray->HasHistClass(className2));
+ Bool_t mergedtrkClass = fHistos->HasHistClass(className2);
+ Bool_t mergedtrkClass2 = (fHistoArray && fHistoArray->HasHistClass(className2));
// check mc signal filling
for (Int_t isig = 0; isig < nsig; isig++) {
sigName = className2 + "_" + fSignalsMC->At(isig)->GetName();
trkClassMC.SetBitNumber(isig, fHistos->HasHistClass(sigName));
- trkClassMChf.SetBitNumber(
- isig, fHistoArray && fHistoArray->HasHistClass(sigName));
+ trkClassMChf.SetBitNumber(isig, fHistoArray && fHistoArray->HasHistClass(sigName));
}
// loop over both track arrays
for (Int_t i = 0; i < fLegTypes; ++i) {
className.Form("Track.%s", fgkTrackClassNames[i]);
Bool_t trkClass = fHistos->HasHistClass(className);
Bool_t trkClass2 = (fHistoArray && fHistoArray->HasHistClass(className));
- Bool_t fill =
- (mergedtrkClass || mergedtrkClass2 || trkClass || trkClass2);
+ Bool_t fill = (mergedtrkClass || mergedtrkClass2 || trkClass || trkClass2);
// skip stuff not to be filled
- if (!fill && !trkClassMC.CountBits() && !trkClassMChf.CountBits())
- continue;
+ if (!fill && !trkClassMC.CountBits() && !trkClassMChf.CountBits()) continue;
Int_t ntracks = fTracks[i].GetEntriesFast();
// loop over all tracks
for (Int_t itrack = 0; itrack < ntracks; ++itrack) {
- PairAnalysisTrack* track =
- static_cast<PairAnalysisTrack*>(fTracks[i].UncheckedAt(itrack));
+ PairAnalysisTrack* track = static_cast<PairAnalysisTrack*>(fTracks[i].UncheckedAt(itrack));
PairAnalysisVarManager::Fill(track, values);
if (trkClass) fHistos->FillClass(className, values);
if (trkClass2) fHistoArray->FillClass(className, values);
if (mergedtrkClass) fHistos->FillClass(className2, values);
- if (mergedtrkClass2)
- fHistoArray->FillClass(className2, values); //TODO: check only SE?
+ if (mergedtrkClass2) fHistoArray->FillClass(className2, values); //TODO: check only SE?
// check and do mc signal filling
for (Int_t isig = 0; isig < nsig; isig++) {
- if (!trkClassMC.TestBitNumber(isig)
- && !trkClassMChf.TestBitNumber(isig))
- continue;
+ if (!trkClassMC.TestBitNumber(isig) && !trkClassMChf.TestBitNumber(isig)) continue;
// test if track does correspond to the signal
- fillMC.SetBitNumber(
- isig,
- mc->IsMCTruth(
- track, (PairAnalysisSignalMC*) fSignalsMC->At(isig), 1)
- || mc->IsMCTruth(
- track, (PairAnalysisSignalMC*) fSignalsMC->At(isig), 2));
+ fillMC.SetBitNumber(isig, mc->IsMCTruth(track, (PairAnalysisSignalMC*) fSignalsMC->At(isig), 1)
+ || mc->IsMCTruth(track, (PairAnalysisSignalMC*) fSignalsMC->At(isig), 2));
sigName = className2 + "_" + fSignalsMC->At(isig)->GetName();
// fill histos
if (fillMC.TestBitNumber(isig)) {
- if (trkClassMC.TestBitNumber(isig))
- fHistos->FillClass(sigName, values);
- if (trkClassMChf.TestBitNumber(isig))
- fHistoArray->FillClass(sigName, values);
+ if (trkClassMC.TestBitNumber(isig)) fHistos->FillClass(sigName, values);
+ if (trkClassMChf.TestBitNumber(isig)) fHistoArray->FillClass(sigName, values);
}
}
@@ -719,9 +677,7 @@ void PairAnalysis::FillHistograms(const PairAnalysisEvent* ev,
if (i == static_cast<Int_t>(EPairType::kSEPM)) {
// loop over all detectors and check for hit histos
- for (ECbmModuleId idet = ECbmModuleId::kRef;
- idet < ECbmModuleId::kNofSystems;
- ++idet) {
+ for (ECbmModuleId idet = ECbmModuleId::kRef; idet < ECbmModuleId::kNofSystems; ++idet) {
className3 + Form("Hit.Legs.") + PairAnalysisHelper::GetDetName(idet);
legClassHits = fHistos->HasHistClass(className3);
if (legClassHits) break;
@@ -731,48 +687,38 @@ void PairAnalysis::FillHistograms(const PairAnalysisEvent* ev,
for (Int_t isig = 0; isig < nsig; isig++) {
sigName = Form("Pair_%s", fSignalsMC->At(isig)->GetName());
pairClassMC.SetBitNumber(isig, fHistos->HasHistClass(sigName));
- pairClassMChf.SetBitNumber(
- isig, fHistoArray && fHistoArray->HasHistClass(sigName));
+ pairClassMChf.SetBitNumber(isig, fHistoArray && fHistoArray->HasHistClass(sigName));
// Printf("fill %s: %d histos %d",sigName.Data(),pairClassMC.TestBitNumber(isig),fHistos->HasHistClass(sigName));
sigName = Form("Track.Legs_%s", fSignalsMC->At(isig)->GetName());
legClassMC.SetBitNumber(isig, fHistos->HasHistClass(sigName));
- legClassMChf.SetBitNumber(
- isig, fHistoArray && fHistoArray->HasHistClass(sigName));
+ legClassMChf.SetBitNumber(isig, fHistoArray && fHistoArray->HasHistClass(sigName));
// check mc signal leg hits filling
if (!legClassHits) {
// loop over all detectors
- for (ECbmModuleId idet = ECbmModuleId::kRef;
- idet < ECbmModuleId::kNofSystems;
- ++idet) {
- className3 =
- Form("Hit.Legs.") + PairAnalysisHelper::GetDetName(idet);
+ for (ECbmModuleId idet = ECbmModuleId::kRef; idet < ECbmModuleId::kNofSystems; ++idet) {
+ className3 = Form("Hit.Legs.") + PairAnalysisHelper::GetDetName(idet);
sigName = className3 + "_" + fSignalsMC->At(isig)->GetName();
legClassHits = fHistos->HasHistClass(className3);
- if (legClassHits)
- break; // abort when at least something should be filled
+ if (legClassHits) break; // abort when at least something should be filled
}
}
}
}
- Bool_t fill =
- (pairClass || pairClass2 || legClass || legClass2 || legClassHits);
- if (!fill && !legClassMC.CountBits() && !legClassMChf.CountBits()
- && !pairClassMC.CountBits() && !pairClassMChf.CountBits())
+ Bool_t fill = (pairClass || pairClass2 || legClass || legClass2 || legClassHits);
+ if (!fill && !legClassMC.CountBits() && !legClassMChf.CountBits() && !pairClassMC.CountBits()
+ && !pairClassMChf.CountBits())
continue;
// loop over all pairs
- UInt_t selectedMask = (1 << fPairFilter.GetCuts()->GetEntries())
- - 1; // for internal train wagons only
- Int_t npairs = PairArray(i)->GetEntriesFast();
+ UInt_t selectedMask = (1 << fPairFilter.GetCuts()->GetEntries()) - 1; // for internal train wagons only
+ Int_t npairs = PairArray(i)->GetEntriesFast();
for (Int_t ipair = 0; ipair < npairs; ++ipair) {
- PairAnalysisPair* pair =
- static_cast<PairAnalysisPair*>(PairArray(i)->UncheckedAt(ipair));
+ PairAnalysisPair* pair = static_cast<PairAnalysisPair*>(PairArray(i)->UncheckedAt(ipair));
//fill pair information
- if (pairClass || pairClass2 || pairClassMC.CountBits()
- || pairClassMChf.CountBits()) {
+ if (pairClass || pairClass2 || pairClassMC.CountBits() || pairClassMChf.CountBits()) {
// if(i==3)
// printf("train: %d \t pair type: %s \t p:%p d1:%p d2:%p \n",!fEventProcess,fgkPairClassNames[i],pair,
@@ -794,9 +740,7 @@ void PairAnalysis::FillHistograms(const PairAnalysisEvent* ev,
if (i == static_cast<Int_t>(EPairType::kSEPM)) {
for (Int_t isig = 0; isig < nsig; isig++) {
// next if nothing needs to be filled
- if (!pairClassMC.TestBitNumber(isig)
- && !pairClassMChf.TestBitNumber(isig))
- continue;
+ if (!pairClassMC.TestBitNumber(isig) && !pairClassMChf.TestBitNumber(isig)) continue;
sigMC = (PairAnalysisSignalMC*) fSignalsMC->At(isig);
// next if single particle signal
if (sigMC->IsSingleParticle()) continue;
@@ -804,10 +748,8 @@ void PairAnalysis::FillHistograms(const PairAnalysisEvent* ev,
fillMC.SetBitNumber(isig, isMCtruth);
if (!isMCtruth) continue;
sigName = Form("Pair_%s", sigMC->GetName());
- if (pairClassMC.TestBitNumber(isig))
- fHistos->FillClass(sigName, values);
- if (pairClassMChf.TestBitNumber(isig))
- fHistoArray->FillClass(sigName, values);
+ if (pairClassMC.TestBitNumber(isig)) fHistos->FillClass(sigName, values);
+ if (pairClassMChf.TestBitNumber(isig)) fHistoArray->FillClass(sigName, values);
// Double_t wght = sigMC->GetWeight(values);
// if(wght!= values[PairAnalysisVarManager::kWeight])
// Warning("FillHistograms","pair weight from tracks (%.3e) not matching MC weight (%.3e) for signal %s",
@@ -817,8 +759,7 @@ void PairAnalysis::FillHistograms(const PairAnalysisEvent* ev,
}
//fill leg information, don't fill the information twice
- if (legClass || legClass2 || legClassMC.CountBits()
- || legClassMChf.CountBits() || legClassHits) {
+ if (legClass || legClass2 || legClassMC.CountBits() || legClassMChf.CountBits() || legClassHits) {
PairAnalysisTrack* d1 = pair->GetFirstDaughter();
PairAnalysisTrack* d2 = pair->GetSecondDaughter();
if (!arrLegs.FindObject(d1)) {
@@ -831,10 +772,8 @@ void PairAnalysis::FillHistograms(const PairAnalysisEvent* ev,
if (!fillMC.TestBitNumber(isig)) continue;
sigMC = (PairAnalysisSignalMC*) fSignalsMC->At(isig);
sigName = Form("Track.Legs_%s", sigMC->GetName());
- if (legClassMC.TestBitNumber(isig))
- fHistos->FillClass(sigName, values);
- if (legClassMChf.TestBitNumber(isig))
- fHistoArray->FillClass(sigName, values);
+ if (legClassMC.TestBitNumber(isig)) fHistos->FillClass(sigName, values);
+ if (legClassMChf.TestBitNumber(isig)) fHistoArray->FillClass(sigName, values);
}
}
@@ -853,10 +792,8 @@ void PairAnalysis::FillHistograms(const PairAnalysisEvent* ev,
if (!fillMC.TestBitNumber(isig)) continue;
sigMC = (PairAnalysisSignalMC*) fSignalsMC->At(isig);
sigName = Form("Track.Legs_%s", sigMC->GetName());
- if (legClassMC.TestBitNumber(isig))
- fHistos->FillClass(sigName, values);
- if (legClassMChf.TestBitNumber(isig))
- fHistoArray->FillClass(sigName, values);
+ if (legClassMC.TestBitNumber(isig)) fHistos->FillClass(sigName, values);
+ if (legClassMChf.TestBitNumber(isig)) fHistoArray->FillClass(sigName, values);
}
}
@@ -871,8 +808,8 @@ void PairAnalysis::FillHistograms(const PairAnalysisEvent* ev,
}
}
//________________________________________________________________
-void PairAnalysis::FillHistogramsPair(PairAnalysisPair* pair,
- Bool_t fromPreFilter /*=kFALSE*/) {
+void PairAnalysis::FillHistogramsPair(PairAnalysisPair* pair, Bool_t fromPreFilter /*=kFALSE*/)
+{
//
// Fill Histogram information for pairs and the track in the pair
// NOTE: in this funtion the leg information may be filled multiple
@@ -889,7 +826,8 @@ void PairAnalysis::FillHistogramsPair(PairAnalysisPair* pair,
if (fromPreFilter) {
className.Form("RejPair.%s", fgkPairClassNames[type]);
className2.Form("RejTrack.%s", fgkPairClassNames[type]);
- } else {
+ }
+ else {
className.Form("Pair.%s", fgkPairClassNames[type]);
className2.Form("Track.Legs.%s", fgkPairClassNames[type]);
}
@@ -920,7 +858,8 @@ void PairAnalysis::FillHistogramsPair(PairAnalysisPair* pair,
}
//________________________________________________________________
-void PairAnalysis::FillTrackArrays(PairAnalysisEvent* const ev) {
+void PairAnalysis::FillTrackArrays(PairAnalysisEvent* const ev)
+{
//
// select tracks and fill track candidate arrays
// use track arrays 0 and 1
@@ -961,8 +900,7 @@ void PairAnalysis::FillTrackArrays(PairAnalysisEvent* const ev) {
}
/// fill detailed cut histograms
- if (fTrackFilter.GetHistogramList()->GetSize())
- FillCutStepHistograms(&fTrackFilter, cutmask, particle, values);
+ if (fTrackFilter.GetHistogramList()->GetSize()) FillCutStepHistograms(&fTrackFilter, cutmask, particle, values);
// rejection
if (cutmask != selectedMask) continue;
@@ -972,14 +910,12 @@ void PairAnalysis::FillTrackArrays(PairAnalysisEvent* const ev) {
// printf("particle %p: pdg: %.0f \t mother: %.0f grand: %.0f \n", particle, values[PairAnalysisVarManager::kPdgCode],
// values[PairAnalysisVarManager::kPdgCodeMother], values[PairAnalysisVarManager::kPdgCodeGrandMother]);
for (Int_t isig = 0; isig < fSignalsMC->GetEntriesFast(); isig++) {
- PairAnalysisSignalMC* sigMC =
- (PairAnalysisSignalMC*) fSignalsMC->At(isig);
- Double_t wght = sigMC->GetWeight(values);
- Bool_t useMCweight = (TMath::Abs(wght - 1.) > 1.0e-15);
+ PairAnalysisSignalMC* sigMC = (PairAnalysisSignalMC*) fSignalsMC->At(isig);
+ Double_t wght = sigMC->GetWeight(values);
+ Bool_t useMCweight = (TMath::Abs(wght - 1.) > 1.0e-15);
if (!useMCweight) continue;
// printf("\t temp. particle weight: %f \t signal weight for %s is %f \n",particle->GetWeight(),sigMC->GetName(),sigMC->GetWeight());
- if (papaMC->IsMCTruth(particle, sigMC, 1)
- || papaMC->IsMCTruth(particle, sigMC, 2)) {
+ if (papaMC->IsMCTruth(particle, sigMC, 1) || papaMC->IsMCTruth(particle, sigMC, 2)) {
// printf("particle weight: %f \t signal weight for %s is %f \n",particle->GetWeight(),sigMC->GetName(),sigMC->GetWeight());
// if(sig->GetWeight(values) != 1.0) particle->SetWeight( sig->GetWeight(values) );
particle->SetWeight(wght);
@@ -1001,14 +937,12 @@ void PairAnalysis::FillTrackArrays(PairAnalysisEvent* const ev) {
/// loop over all added signals
for (Int_t isig = 0; isig < fSignalsMC->GetEntriesFast(); isig++) {
- PairAnalysisSignalMC* sigMC =
- (PairAnalysisSignalMC*) fSignalsMC->At(isig);
- Double_t wghtMC = sigMC->GetWeight(values);
- Bool_t useMCweight = (TMath::Abs(wghtMC - 1.) > 1.0e-15);
+ PairAnalysisSignalMC* sigMC = (PairAnalysisSignalMC*) fSignalsMC->At(isig);
+ Double_t wghtMC = sigMC->GetWeight(values);
+ Bool_t useMCweight = (TMath::Abs(wghtMC - 1.) > 1.0e-15);
if (!useMCweight) continue; // signal has no weights applied
- if (papaMC->IsMCTruth(motherLabel, sigMC, 1)
- || papaMC->IsMCTruth(motherLabel, sigMC, 2)) {
+ if (papaMC->IsMCTruth(motherLabel, sigMC, 1) || papaMC->IsMCTruth(motherLabel, sigMC, 2)) {
particle->SetWeight(wghtMC);
hasMCweight = kTRUE;
}
@@ -1022,18 +956,15 @@ void PairAnalysis::FillTrackArrays(PairAnalysisEvent* const ev) {
//fill selected particle into the corresponding track arrays
Short_t charge = particle->Charge();
- if (charge > 0)
- fTracks[0].Add(particle); // positive tracks
+ if (charge > 0) fTracks[0].Add(particle); // positive tracks
else if (charge < 0)
fTracks[1].Add(particle); // negative tracks
}
}
//________________________________________________________________
-void PairAnalysis::PairPreFilter(Int_t arr1,
- Int_t arr2,
- TObjArray& arrTracks1,
- TObjArray& arrTracks2) {
+void PairAnalysis::PairPreFilter(Int_t arr1, Int_t arr2, TObjArray& arrTracks1, TObjArray& arrTracks2)
+{
//
// Prefilter tracks from pairs
// Needed for datlitz rejections
@@ -1049,8 +980,7 @@ void PairAnalysis::PairPreFilter(Int_t arr1,
Double_t mass = TDatabasePDG::Instance()->GetParticle(fPdgLeg1)->Mass();
Double_t pt = gRandom->Exp(3.); // return t from exp(-t/3.)
if (pt < 0.075) pt = 0.075;
- Double_t eta = -TMath::Log(
- TMath::Tan((gRandom->Uniform(2.5, 25.) / 180. * TMath::Pi()) / 2));
+ Double_t eta = -TMath::Log(TMath::Tan((gRandom->Uniform(2.5, 25.) / 180. * TMath::Pi()) / 2));
Double_t phi = gRandom->Uniform(TMath::TwoPi());
PairAnalysisTrack* t1 = new PairAnalysisTrack();
t1->SetPdgCode(fPdgLeg1);
@@ -1060,8 +990,7 @@ void PairAnalysis::PairPreFilter(Int_t arr1,
mass = TDatabasePDG::Instance()->GetParticle(fPdgLeg2)->Mass();
pt = gRandom->Exp(3.); // return t from exp(-t/3.)
if (pt < 0.075) pt = 0.075;
- eta = -TMath::Log(
- TMath::Tan((gRandom->Uniform(2.5, 25.) / 180. * TMath::Pi()) / 2));
+ eta = -TMath::Log(TMath::Tan((gRandom->Uniform(2.5, 25.) / 180. * TMath::Pi()) / 2));
phi = gRandom->Uniform(TMath::TwoPi());
PairAnalysisTrack* t2 = new PairAnalysisTrack();
t2->SetPdgCode(fPdgLeg2);
@@ -1072,10 +1001,9 @@ void PairAnalysis::PairPreFilter(Int_t arr1,
/// pairprefilter leg cuts
/// TODO: cut logic exceptions for test particles
/// mask used to require that all cuts are fulfilled
- UInt_t selectedMaskLeg =
- (1 << fPairPreFilterLegs.GetCuts()->GetEntries()) - 1;
- Bool_t isLeg1selected = kTRUE;
- Bool_t isLeg2selected = kTRUE;
+ UInt_t selectedMaskLeg = (1 << fPairPreFilterLegs.GetCuts()->GetEntries()) - 1;
+ Bool_t isLeg1selected = kTRUE;
+ Bool_t isLeg2selected = kTRUE;
Int_t ntrack1 = arrTracks1.GetEntriesFast();
@@ -1095,8 +1023,7 @@ void PairAnalysis::PairPreFilter(Int_t arr1,
// candiate
PairAnalysisPair* candidate;
- if (fUseKF)
- candidate = new PairAnalysisPairKF();
+ if (fUseKF) candidate = new PairAnalysisPairKF();
else
candidate = new PairAnalysisPairLV();
candidate->SetKFUsage(fUseKF);
@@ -1155,10 +1082,8 @@ void PairAnalysis::PairPreFilter(Int_t arr1,
// kAnyLeg demands that at least one candidate fullfills the cuts
// kOneLeg demands exactly one candidate to fullfill the cuts
if (selectedMaskLeg) {
- isLeg1selected =
- (fPairPreFilterLegs.IsSelected(
- static_cast<PairAnalysisTrack*>(track1))
- == selectedMaskLeg); // check cuts for the first track candidate
+ isLeg1selected = (fPairPreFilterLegs.IsSelected(static_cast<PairAnalysisTrack*>(track1))
+ == selectedMaskLeg); // check cuts for the first track candidate
if (fCutType == ECutType::kBothLegs && !isLeg1selected) continue;
}
@@ -1169,35 +1094,26 @@ void PairAnalysis::PairPreFilter(Int_t arr1,
/// pair prefilter leg cuts
if (selectedMaskLeg) {
- if (fCutType != ECutType::kAnyLeg
- || (fCutType == ECutType::kAnyLeg && !isLeg1selected)) {
- isLeg2selected =
- (fPairPreFilterLegs.IsSelected(
- static_cast<PairAnalysisTrack*>(track2))
- == selectedMaskLeg); // check cuts for the second track candidate
- if (fCutType == ECutType::kBothLegs && !isLeg2selected)
- continue; // the second track did not fullfill cuts
+ if (fCutType != ECutType::kAnyLeg || (fCutType == ECutType::kAnyLeg && !isLeg1selected)) {
+ isLeg2selected = (fPairPreFilterLegs.IsSelected(static_cast<PairAnalysisTrack*>(track2))
+ == selectedMaskLeg); // check cuts for the second track candidate
+ if (fCutType == ECutType::kBothLegs && !isLeg2selected) continue; // the second track did not fullfill cuts
if (fCutType == ECutType::kAnyLeg && !isLeg2selected)
continue; // the first and second track did not fullfill cuts
- if (fCutType == ECutType::kOneLeg
- && isLeg1selected == isLeg2selected)
+ if (fCutType == ECutType::kOneLeg && isLeg1selected == isLeg2selected)
continue; // both tracks have the same value
}
}
/// create the pair
- candidate->SetTracks(static_cast<PairAnalysisTrack*>(track1),
- fPdgLeg1,
- static_cast<PairAnalysisTrack*>(track2),
+ candidate->SetTracks(static_cast<PairAnalysisTrack*>(track1), fPdgLeg1, static_cast<PairAnalysisTrack*>(track2),
fPdgLeg2);
candidate->SetType(pairIndex);
- candidate->SetLabel(PairAnalysisMC::Instance()->GetLabelMotherWithPdg(
- candidate, fPdgMother));
+ candidate->SetLabel(PairAnalysisMC::Instance()->GetLabelMotherWithPdg(candidate, fPdgMother));
/// check if test particles are used
- Bool_t testParticle =
- (track1 == t1 || track1 == t2 || track2 == t1 || track2 == t2);
+ Bool_t testParticle = (track1 == t1 || track1 == t2 || track2 == t1 || track2 == t2);
/// pre filter pair cuts
UInt_t cutmask = fPairPreFilter.IsSelected(candidate);
@@ -1214,14 +1130,12 @@ void PairAnalysis::PairPreFilter(Int_t arr1,
/// check for test particles
if (testParticle) {
// set variable to randomrejection probability to 1
- PairAnalysisVarManager::SetValue(PairAnalysisVarManager::kRndmRej,
- 1.);
+ PairAnalysisVarManager::SetValue(PairAnalysisVarManager::kRndmRej, 1.);
continue;
}
/// fill histos
- if (fHistos)
- FillHistogramsPair(candidate, kTRUE); // kTRUE: fromPrefilter
+ if (fHistos) FillHistogramsPair(candidate, kTRUE); // kTRUE: fromPrefilter
/// set flags for track removal
bTracks1RP[itrack1] = kTRUE;
@@ -1289,8 +1203,8 @@ void PairAnalysis::PairPreFilter(Int_t arr1,
}
//________________________________________________________________
-void PairAnalysis::FilterTrackArrays(TObjArray& arrTracks1,
- TObjArray& arrTracks2) {
+void PairAnalysis::FilterTrackArrays(TObjArray& arrTracks1, TObjArray& arrTracks2)
+{
//
// select tracks and adapt track candidate arrays
// second and final track selection
@@ -1307,8 +1221,7 @@ void PairAnalysis::FilterTrackArrays(TObjArray& arrTracks1,
for (Int_t itrack = 0; itrack < arrTracks1.GetEntriesFast(); ++itrack) {
//get particle
- PairAnalysisTrack* particle =
- static_cast<PairAnalysisTrack*>(arrTracks1.UncheckedAt(itrack));
+ PairAnalysisTrack* particle = static_cast<PairAnalysisTrack*>(arrTracks1.UncheckedAt(itrack));
// fill variables
PairAnalysisVarManager::Fill(particle, values);
@@ -1333,8 +1246,7 @@ void PairAnalysis::FilterTrackArrays(TObjArray& arrTracks1,
for (Int_t itrack = 0; itrack < arrTracks2.GetEntriesFast(); ++itrack) {
//get particle
- PairAnalysisTrack* particle =
- static_cast<PairAnalysisTrack*>(arrTracks2.UncheckedAt(itrack));
+ PairAnalysisTrack* particle = static_cast<PairAnalysisTrack*>(arrTracks2.UncheckedAt(itrack));
// fill variables
PairAnalysisVarManager::Fill(particle, values);
@@ -1358,7 +1270,8 @@ void PairAnalysis::FilterTrackArrays(TObjArray& arrTracks1,
}
//________________________________________________________________
-void PairAnalysis::FillPairArrays(Int_t arr1, Int_t arr2) {
+void PairAnalysis::FillPairArrays(Int_t arr1, Int_t arr2)
+{
//
// select pairs and fill pair candidate arrays
//
@@ -1379,8 +1292,7 @@ void PairAnalysis::FillPairArrays(Int_t arr1, Int_t arr2) {
/// otherwise this will crash in the refiting done in PairAnalysisPairKF
/// track rotation is not done here!
PairAnalysisPair* candidate;
- if (fUseKF && pairIndex <= static_cast<Int_t>(EPairType::kSEMM))
- candidate = new PairAnalysisPairKF();
+ if (fUseKF && pairIndex <= static_cast<Int_t>(EPairType::kSEMM)) candidate = new PairAnalysisPairKF();
else
candidate = new PairAnalysisPairLV();
candidate->SetKFUsage(fUseKF);
@@ -1393,17 +1305,12 @@ void PairAnalysis::FillPairArrays(Int_t arr1, Int_t arr2) {
if (arr1 == arr2) end = itrack1;
for (Int_t itrack2 = 0; itrack2 < end; ++itrack2) {
//create the pair (direct pointer to the memory by this daughter reference are kept also for ME)
- candidate->SetTracks(
- &(*static_cast<PairAnalysisTrack*>(arrTracks1.UncheckedAt(itrack1))),
- fPdgLeg1,
- &(*static_cast<PairAnalysisTrack*>(arrTracks2.UncheckedAt(itrack2))),
- fPdgLeg2);
+ candidate->SetTracks(&(*static_cast<PairAnalysisTrack*>(arrTracks1.UncheckedAt(itrack1))), fPdgLeg1,
+ &(*static_cast<PairAnalysisTrack*>(arrTracks2.UncheckedAt(itrack2))), fPdgLeg2);
// TODO: maybe set here the mother pdg code and remove fPdgMother
- Int_t label = PairAnalysisMC::Instance()->GetLabelMotherWithPdg(
- candidate, fPdgMother);
+ Int_t label = PairAnalysisMC::Instance()->GetLabelMotherWithPdg(candidate, fPdgMother);
candidate->SetLabel(label);
- if (label > -1)
- candidate->SetPdgCode(fPdgMother);
+ if (label > -1) candidate->SetPdgCode(fPdgMother);
else
candidate->SetPdgCode(0);
@@ -1428,8 +1335,7 @@ void PairAnalysis::FillPairArrays(Int_t arr1, Int_t arr2) {
//add the candidate to the candidate array
PairArray(pairIndex)->Add(candidate);
//get a new candidate
- if (fUseKF && pairIndex <= static_cast<Int_t>(EPairType::kSEMM))
- candidate = new PairAnalysisPairKF();
+ if (fUseKF && pairIndex <= static_cast<Int_t>(EPairType::kSEMM)) candidate = new PairAnalysisPairKF();
else
candidate = new PairAnalysisPairLV();
candidate->SetKFUsage(fUseKF);
@@ -1441,7 +1347,8 @@ void PairAnalysis::FillPairArrays(Int_t arr1, Int_t arr2) {
}
//________________________________________________________________
-void PairAnalysis::FillPairArrayTR() {
+void PairAnalysis::FillPairArrayTR()
+{
//
// rotate pairs and fill into pair candidate arrays
//
@@ -1450,8 +1357,7 @@ void PairAnalysis::FillPairArrayTR() {
Int_t ntrack2 = fTracks[1].GetEntriesFast();
PairAnalysisPair* candidate;
- if (fUseKF)
- candidate = new PairAnalysisPairKF();
+ if (fUseKF) candidate = new PairAnalysisPairKF();
else
candidate = new PairAnalysisPairLV();
candidate->SetKFUsage(fUseKF);
@@ -1465,11 +1371,8 @@ void PairAnalysis::FillPairArrayTR() {
// loop over iterations
for (Int_t irot = 0; irot < fTrackRotator->GetIterations(); ++irot) {
// build candidate
- candidate->SetTracks(
- &(*static_cast<PairAnalysisTrack*>(fTracks[0].UncheckedAt(itrack1))),
- fPdgLeg1,
- &(*static_cast<PairAnalysisTrack*>(fTracks[1].UncheckedAt(itrack2))),
- fPdgLeg2);
+ candidate->SetTracks(&(*static_cast<PairAnalysisTrack*>(fTracks[0].UncheckedAt(itrack1))), fPdgLeg1,
+ &(*static_cast<PairAnalysisTrack*>(fTracks[1].UncheckedAt(itrack2))), fPdgLeg2);
// rotate the candidates daughter track
candidate->RotateTrack(fTrackRotator);
@@ -1480,8 +1383,7 @@ void PairAnalysis::FillPairArrayTR() {
if (cutMask != selectedMask) continue;
//histogram array for the pair
- if (fHistoArray)
- fHistoArray->Fill(static_cast<Int_t>(EPairType::kSEPMRot), candidate);
+ if (fHistoArray) fHistoArray->Fill(static_cast<Int_t>(EPairType::kSEPMRot), candidate);
if (fHistos) FillHistogramsPair(candidate);
if (fStoreRotatedPairs) {
@@ -1504,7 +1406,8 @@ void PairAnalysis::FillPairArrayTR() {
}
//________________________________________________________________
-void PairAnalysis::AddSignalMC(PairAnalysisSignalMC* signal) {
+void PairAnalysis::AddSignalMC(PairAnalysisSignalMC* signal)
+{
//
// Add an MC signal to the signals list
//
@@ -1513,17 +1416,15 @@ void PairAnalysis::AddSignalMC(PairAnalysisSignalMC* signal) {
fSignalsMC->SetOwner();
}
// sort mc signal (first single particle, then pair signals)
- if (signal->IsSingleParticle())
- fSignalsMC->AddAtFree(signal);
+ if (signal->IsSingleParticle()) fSignalsMC->AddAtFree(signal);
else
- fSignalsMC->AddAtAndExpand(
- signal, fSignalsMC->GetLast() < 10 ? 10 : fSignalsMC->GetLast() + 1);
+ fSignalsMC->AddAtAndExpand(signal, fSignalsMC->GetLast() < 10 ? 10 : fSignalsMC->GetLast() + 1);
//fSignalsMC->Add(signal);
}
//________________________________________________________________
-Bool_t
-PairAnalysis::FillMCHistograms(Int_t label1, Int_t label2, Int_t nSignal) {
+Bool_t PairAnalysis::FillMCHistograms(Int_t label1, Int_t label2, Int_t nSignal)
+{
//
// fill QA MC TRUTH histograms for pairs and legs of all added mc signals
//
@@ -1531,11 +1432,10 @@ PairAnalysis::FillMCHistograms(Int_t label1, Int_t label2, Int_t nSignal) {
TString className = Form("Pair_%s_MCtruth", sigMC->GetName());
TString className2 = Form("Track.Legs_%s_MCtruth", sigMC->GetName());
- TString className3 =
- Form("Track.%s_%s_MCtruth", fgkPairClassNames[1], sigMC->GetName());
- Bool_t pairClass = fHistos->HasHistClass(className.Data());
- Bool_t legClass = fHistos->HasHistClass(className2.Data());
- Bool_t trkClass = fHistos->HasHistClass(className3.Data());
+ TString className3 = Form("Track.%s_%s_MCtruth", fgkPairClassNames[1], sigMC->GetName());
+ Bool_t pairClass = fHistos->HasHistClass(className.Data());
+ Bool_t legClass = fHistos->HasHistClass(className2.Data());
+ Bool_t trkClass = fHistos->HasHistClass(className3.Data());
// printf("fill signal %d: pair %d legs %d trk %d \n",nSignal,pairClass,legClass,trkClass);
if (!pairClass && !legClass && !trkClass) return kFALSE;
@@ -1553,13 +1453,8 @@ PairAnalysis::FillMCHistograms(Int_t label1, Int_t label2, Int_t nSignal) {
// printf("leg/mother labels: %d/%d %d/%d \t part %p,%p \n",label1,mLabel1,label2,mLabel2,part1,part2);
// check the same mother option
- if (sigMC->GetMothersRelation()
- == PairAnalysisSignalMC::EBranchRelation::kSame
- && mLabel1 != mLabel2)
- return kFALSE;
- if (sigMC->GetMothersRelation()
- == PairAnalysisSignalMC::EBranchRelation::kDifferent
- && mLabel1 == mLabel2)
+ if (sigMC->GetMothersRelation() == PairAnalysisSignalMC::EBranchRelation::kSame && mLabel1 != mLabel2) return kFALSE;
+ if (sigMC->GetMothersRelation() == PairAnalysisSignalMC::EBranchRelation::kDifferent && mLabel1 == mLabel2)
return kFALSE;
// fill event values
@@ -1569,13 +1464,11 @@ PairAnalysis::FillMCHistograms(Int_t label1, Int_t label2, Int_t nSignal) {
// fill the leg variables
if (legClass || trkClass) {
if (part1) PairAnalysisVarManager::Fill(part1, values);
- PairAnalysisVarManager::SetValue(PairAnalysisVarManager::kWeight,
- sigMC->GetWeight(values));
+ PairAnalysisVarManager::SetValue(PairAnalysisVarManager::kWeight, sigMC->GetWeight(values));
if (part1 && trkClass) fHistos->FillClass(className3, values);
if (part1 && part2 && legClass) fHistos->FillClass(className2, values);
if (part2) PairAnalysisVarManager::Fill(part2, values);
- PairAnalysisVarManager::SetValue(PairAnalysisVarManager::kWeight,
- sigMC->GetWeight(values));
+ PairAnalysisVarManager::SetValue(PairAnalysisVarManager::kWeight, sigMC->GetWeight(values));
if (part2 && trkClass) fHistos->FillClass(className3, values);
if (part1 && part2 && legClass) fHistos->FillClass(className2, values);
}
@@ -1595,22 +1488,17 @@ PairAnalysis::FillMCHistograms(Int_t label1, Int_t label2, Int_t nSignal) {
for (Int_t ileg = 0; ileg < 2; ileg++) {
// loop over all detectors
- for (ECbmModuleId idet = ECbmModuleId::kRef;
- idet < ECbmModuleId::kNofSystems;
- ++idet) {
+ for (ECbmModuleId idet = ECbmModuleId::kRef; idet < ECbmModuleId::kNofSystems; ++idet) {
className4 = Form("Hit.%s", (ileg ? "Legs." : ""));
- className4 += PairAnalysisHelper::GetDetName(idet) + "_"
- + sigMC->GetName() + "_MCtruth";
+ className4 += PairAnalysisHelper::GetDetName(idet) + "_" + sigMC->GetName() + "_MCtruth";
if (!fHistos->HasHistClass(className4)) continue;
Int_t npnts = part->GetNPoints(idet);
//printf("track %p(%d) \t has %d %s mc points \n",part,label1,npnts,PairAnalysisHelper::GetDetName(idet).Data());
if (!npnts) continue;
- TClonesArray* points =
- PairAnalysisVarManager::GetCurrentEvent()->GetPoints(
- idet); // get point array
- Int_t psize = points->GetSize();
+ TClonesArray* points = PairAnalysisVarManager::GetCurrentEvent()->GetPoints(idet); // get point array
+ Int_t psize = points->GetSize();
if (!points || psize < 1) continue;
Int_t nfnd = 0;
@@ -1633,8 +1521,7 @@ PairAnalysis::FillMCHistograms(Int_t label1, Int_t label2, Int_t nSignal) {
//fill pair information
if (pairClass && part1 && part2) {
PairAnalysisVarManager::FillVarMCParticle(part1, part2, values);
- PairAnalysisVarManager::SetValue(PairAnalysisVarManager::kWeight,
- sigMC->GetWeight(values));
+ PairAnalysisVarManager::SetValue(PairAnalysisVarManager::kWeight, sigMC->GetWeight(values));
fHistos->FillClass(className, values);
}
@@ -1642,8 +1529,8 @@ PairAnalysis::FillMCHistograms(Int_t label1, Int_t label2, Int_t nSignal) {
}
//________________________________________________________________
-void PairAnalysis::FillHistogramsFromPairArray(
- Bool_t pairInfoOnly /*=kFALSE*/) {
+void PairAnalysis::FillHistogramsFromPairArray(Bool_t pairInfoOnly /*=kFALSE*/)
+{
//
// Fill Histogram information for tracks and pairs
//
@@ -1674,8 +1561,7 @@ void PairAnalysis::FillHistogramsFromPairArray(
// if (!pairClass&&!legClass) continue;
for (Int_t ipair = 0; ipair < npairs; ++ipair) {
- PairAnalysisPair* pair =
- static_cast<PairAnalysisPair*>(PairArray(i)->UncheckedAt(ipair));
+ PairAnalysisPair* pair = static_cast<PairAnalysisPair*>(PairArray(i)->UncheckedAt(ipair));
// apply cuts
UInt_t cutMask = fPairFilter.IsSelected(pair);
@@ -1722,10 +1608,9 @@ void PairAnalysis::FillHistogramsFromPairArray(
}
//________________________________________________________________
-void PairAnalysis::FillCutStepHistograms(AnalysisFilter* filter,
- UInt_t cutmask,
- PairAnalysisTrack* trk,
- const Double_t* values) {
+void PairAnalysis::FillCutStepHistograms(AnalysisFilter* filter, UInt_t cutmask, PairAnalysisTrack* trk,
+ const Double_t* values)
+{
/// mc instance
PairAnalysisMC* papaMC = 0x0;
@@ -1751,9 +1636,7 @@ void PairAnalysis::FillCutStepHistograms(AnalysisFilter* filter,
// printf("fill cut details for %s \n",classNameMC.Data());
}
// check if machtes mc signal
- Bool_t isMCtruth =
- fSignalsMC
- && (papaMC->IsMCTruth(trk, sigMC, 1) || papaMC->IsMCTruth(trk, sigMC, 2));
+ Bool_t isMCtruth = fSignalsMC && (papaMC->IsMCTruth(trk, sigMC, 1) || papaMC->IsMCTruth(trk, sigMC, 2));
if (isig && !isMCtruth) continue;
/// store mc signal weights in track - ATTENTION later signals should be more specific
@@ -1774,9 +1657,7 @@ void PairAnalysis::FillCutStepHistograms(AnalysisFilter* filter,
// printf(" track %p passed cut \n",trk);
/// find histogram list of current track
- histo.SetHistogramList(
- *(THashList*) filter->GetHistogramList()->FindObject(cuts->GetName()),
- kFALSE);
+ histo.SetHistogramList(*(THashList*) filter->GetHistogramList()->FindObject(cuts->GetName()), kFALSE);
/// fill track histos only once
if (!isig) {
@@ -1795,10 +1676,8 @@ void PairAnalysis::FillCutStepHistograms(AnalysisFilter* filter,
}
//________________________________________________________________
-void PairAnalysis::FillCutStepHistogramsMC(AnalysisFilter* filter,
- UInt_t cutmask,
- Int_t label,
- const Double_t* values) {
+void PairAnalysis::FillCutStepHistogramsMC(AnalysisFilter* filter, UInt_t cutmask, Int_t label, const Double_t* values)
+{
/// mc instance
PairAnalysisMC* papaMC = 0x0;
@@ -1827,9 +1706,7 @@ void PairAnalysis::FillCutStepHistogramsMC(AnalysisFilter* filter,
if (!sigMC->GetFillPureMCStep()) continue;
// check if matches mc signal
- Bool_t isMCtruth = fSignalsMC
- && (papaMC->IsMCTruth(label, sigMC, 1)
- || papaMC->IsMCTruth(label, sigMC, 2));
+ Bool_t isMCtruth = fSignalsMC && (papaMC->IsMCTruth(label, sigMC, 1) || papaMC->IsMCTruth(label, sigMC, 2));
if (isig && !isMCtruth) continue;
/// store mc signal weights in track - ATTENTION later signals should be more specific
@@ -1848,9 +1725,7 @@ void PairAnalysis::FillCutStepHistogramsMC(AnalysisFilter* filter,
if ((cutmask & cutRef) == cutRef) {
/// find histogram list of current track
- histo.SetHistogramList(
- *(THashList*) filter->GetHistogramList()->FindObject(cuts->GetName()),
- kFALSE);
+ histo.SetHistogramList(*(THashList*) filter->GetHistogramList()->FindObject(cuts->GetName()), kFALSE);
/// fill mc truth
if (isMCtruth) histo.FillClass(classNameMC, values);
@@ -1861,11 +1736,9 @@ void PairAnalysis::FillCutStepHistogramsMC(AnalysisFilter* filter,
}
//________________________________________________________________
-void PairAnalysis::FillHistogramsHits(const PairAnalysisEvent* ev,
- TBits* fillMC,
- PairAnalysisTrack* track,
- Bool_t trackIsLeg,
- Double_t* values) {
+void PairAnalysis::FillHistogramsHits(const PairAnalysisEvent* ev, TBits* fillMC, PairAnalysisTrack* track,
+ Bool_t trackIsLeg, Double_t* values)
+{
//
// Fill Histogram information for hits and hits of legs
//
@@ -1880,8 +1753,7 @@ void PairAnalysis::FillHistogramsHits(const PairAnalysisEvent* ev,
// loop over all detectors
- for (ECbmModuleId idet = ECbmModuleId::kRef; idet < ECbmModuleId::kNofSystems;
- ++idet) {
+ for (ECbmModuleId idet = ECbmModuleId::kRef; idet < ECbmModuleId::kNofSystems; ++idet) {
// detectors implemented
switch (idet) {
@@ -1905,12 +1777,9 @@ void PairAnalysis::FillHistogramsHits(const PairAnalysisEvent* ev,
for (Int_t isig = 0; isig < nsig; isig++) {
sigName = className + "_" + fSignalsMC->At(isig)->GetName();
hitClassMC.SetBitNumber(isig, fHistos->HasHistClass(sigName));
- hitClassMChf.SetBitNumber(
- isig, fHistoArray && fHistoArray->HasHistClass(sigName));
+ hitClassMChf.SetBitNumber(isig, fHistoArray && fHistoArray->HasHistClass(sigName));
}
- if (!hitClass && !hitClass2 && !hitClassMC.CountBits()
- && !hitClassMChf.CountBits())
- continue;
+ if (!hitClass && !hitClass2 && !hitClassMC.CountBits() && !hitClassMChf.CountBits()) continue;
// get hit array
TClonesArray* hits = ev->GetHits(idet);
@@ -1963,12 +1832,8 @@ void PairAnalysis::FillHistogramsHits(const PairAnalysisEvent* ev,
for (Int_t ihit = 0; ihit < nhits; ihit++) {
Int_t idx = -1;
switch (idet) {
- case ECbmModuleId::kMvd:
- idx = static_cast<CbmStsTrack*>(trkl)->GetMvdHitIndex(ihit);
- break;
- case ECbmModuleId::kSts:
- idx = static_cast<CbmStsTrack*>(trkl)->GetStsHitIndex(ihit);
- break;
+ case ECbmModuleId::kMvd: idx = static_cast<CbmStsTrack*>(trkl)->GetMvdHitIndex(ihit); break;
+ case ECbmModuleId::kSts: idx = static_cast<CbmStsTrack*>(trkl)->GetStsHitIndex(ihit); break;
case ECbmModuleId::kMuch:
case ECbmModuleId::kTrd: idx = trkl->GetHitIndex(ihit); break;
case ECbmModuleId::kTof: hit = track->GetTofHit(); break;
@@ -1976,9 +1841,7 @@ void PairAnalysis::FillHistogramsHits(const PairAnalysisEvent* ev,
default: continue;
}
// get hit
- if (idet != ECbmModuleId::kTof && idx > -1) {
- hit = dynamic_cast<CbmHit*>(hits->At(idx));
- }
+ if (idet != ECbmModuleId::kTof && idx > -1) { hit = dynamic_cast<CbmHit*>(hits->At(idx)); }
if (!hit) continue;
// fill rec hit variables
@@ -1997,24 +1860,20 @@ void PairAnalysis::FillHistogramsHits(const PairAnalysisEvent* ev,
// NOTE: the sum of all linked mc points is stored, you have to normlize to the mean
// loop over all linked mc points
for (Int_t iLink = 0; iLink < nlinks; iLink++) {
- pnt = static_cast<FairMCPoint*>(
- ev->GetPoints(idet)->At(mtch->GetLink(iLink).GetIndex()));
+ pnt = static_cast<FairMCPoint*>(ev->GetPoints(idet)->At(mtch->GetLink(iLink).GetIndex()));
// Fill the MC hit variables
- if (!iLink)
- PairAnalysisVarManager::Fill(pnt, values);
+ if (!iLink) PairAnalysisVarManager::Fill(pnt, values);
else
PairAnalysisVarManager::FillSum(pnt, values);
// hit type defintion
- if (!pnt)
- trueHit = kFALSE;
+ if (!pnt) trueHit = kFALSE;
else if (mc) {
Int_t lbl = pnt->GetTrackID();
Int_t lblM = mc->GetMothersLabel(lbl);
Int_t lblG = mc->GetMothersLabel(lblM);
- if (lbl != mctrk && lblM != mctrk && lblG != mctrk)
- trueHit = kFALSE;
+ if (lbl != mctrk && lblM != mctrk && lblG != mctrk) trueHit = kFALSE;
else
fakeHit = kFALSE;
}
@@ -2030,10 +1889,12 @@ void PairAnalysis::FillHistogramsHits(const PairAnalysisEvent* ev,
if (trueHit) {
if (hitClass) fHistos->FillClass(className + "_true", values);
if (hitClass2) fHistoArray->FillClass(className + "_true", values);
- } else if (fakeHit) {
+ }
+ else if (fakeHit) {
if (hitClass) fHistos->FillClass(className + "_fake", values);
if (hitClass2) fHistoArray->FillClass(className + "_fake", values);
- } else {
+ }
+ else {
if (hitClass) fHistos->FillClass(className + "_dist", values);
if (hitClass2) fHistoArray->FillClass(className + "_dist", values);
}
@@ -2041,10 +1902,8 @@ void PairAnalysis::FillHistogramsHits(const PairAnalysisEvent* ev,
for (Int_t isig = 0; isig < nsig; isig++) {
sigName = className + "_" + fSignalsMC->At(isig)->GetName();
if (fillMC->TestBitNumber(isig)) { // track is MC signal truth
- if (hitClassMC.TestBitNumber(isig))
- fHistos->FillClass(sigName, values);
- if (hitClassMChf.TestBitNumber(isig))
- fHistoArray->FillClass(sigName, values);
+ if (hitClassMC.TestBitNumber(isig)) fHistos->FillClass(sigName, values);
+ if (hitClassMChf.TestBitNumber(isig)) fHistoArray->FillClass(sigName, values);
}
}
diff --git a/analysis/PWGDIL/dielectron/papaframework/PairAnalysis.h b/analysis/PWGDIL/dielectron/papaframework/PairAnalysis.h
index 2fb5e830406dcaaec35c4370f8554f80632bf541..5095c286dc4b1b047c0deebf91e1f5bbc3394fe3 100644
--- a/analysis/PWGDIL/dielectron/papaframework/PairAnalysis.h
+++ b/analysis/PWGDIL/dielectron/papaframework/PairAnalysis.h
@@ -23,7 +23,8 @@ class PairAnalysis : public TNamed {
friend class PairAnalysisMixingHandler; //mixing as friend class
public:
- enum class EPairType {
+ enum class EPairType
+ {
kSEPP = 0,
kSEPM,
kSEMM,
@@ -35,9 +36,15 @@ public:
kPairTypes
};
static constexpr Int_t fNTypes = static_cast<Int_t>(EPairType::kPairTypes);
- enum class ELegType { kSEP, kSEM, kLegTypes };
+ enum class ELegType
+ {
+ kSEP,
+ kSEM,
+ kLegTypes
+ };
static constexpr Int_t fLegTypes = static_cast<Int_t>(ELegType::kLegTypes);
- enum class ECutType {
+ enum class ECutType
+ {
kBothLegs = 0,
kAnyLeg,
kOneLeg
@@ -77,100 +84,68 @@ public:
Bool_t DoProcessLS() { return fProcessLS; }
void SetUseKF(Bool_t useKF = kTRUE) { fUseKF = useKF; }
- const TObjArray* GetTrackArray(Int_t i) const {
- return (i >= 0 && i < 4) ? &fTracks[i] : 0;
- }
- const TObjArray* GetPairArray(Int_t i) const {
- return (i >= 0 && i < fNTypes)
- ? static_cast<TObjArray*>(fPairCandidates->UncheckedAt(i))
- : 0;
+ const TObjArray* GetTrackArray(Int_t i) const { return (i >= 0 && i < 4) ? &fTracks[i] : 0; }
+ const TObjArray* GetPairArray(Int_t i) const
+ {
+ return (i >= 0 && i < fNTypes) ? static_cast<TObjArray*>(fPairCandidates->UncheckedAt(i)) : 0;
}
TObjArray** GetPairArraysPointer() { return &fPairCandidates; }
void SetPairArraysPointer(TObjArray* arr) { fPairCandidates = arr; }
// outputs - hist array
- void SetHistogramArray(PairAnalysisHF* const histoarray) {
- fHistoArray = histoarray;
- }
- const TObjArray* GetHistogramArray() const {
- return fHistoArray ? fHistoArray->GetHistArray() : 0x0;
- }
- const THashList* GetQAHistList() const {
- return fQAmonitor ? fQAmonitor->GetQAHistList() : 0x0;
- }
+ void SetHistogramArray(PairAnalysisHF* const histoarray) { fHistoArray = histoarray; }
+ const TObjArray* GetHistogramArray() const { return fHistoArray ? fHistoArray->GetHistArray() : 0x0; }
+ const THashList* GetQAHistList() const { return fQAmonitor ? fQAmonitor->GetQAHistList() : 0x0; }
// outputs - histos
- void SetHistogramManager(PairAnalysisHistos* const histos) {
- fHistos = histos;
- }
+ void SetHistogramManager(PairAnalysisHistos* const histos) { fHistos = histos; }
PairAnalysisHistos* GetHistoManager() const { return fHistos; }
- const THashList* GetHistogramList() const {
- return fHistos ? fHistos->GetHistogramList() : 0x0;
- }
+ const THashList* GetHistogramList() const { return fHistos ? fHistos->GetHistogramList() : 0x0; }
// outputs - cut detailed histos
- THashList* GetCutStepHistogramList() const {
- return fCutStepHistos->GetSize() ? fCutStepHistos : 0x0;
- }
+ THashList* GetCutStepHistogramList() const { return fCutStepHistos->GetSize() ? fCutStepHistos : 0x0; }
- Bool_t HasCandidates() const {
- return GetPairArray(1) ? GetPairArray(1)->GetEntriesFast() > 0 : 0;
- }
- Bool_t HasCandidatesTR() const {
- return GetPairArray(7) ? GetPairArray(7)->GetEntriesFast() > 0 : 0;
- }
- Bool_t HasCandidatesLikeSign() const {
+ Bool_t HasCandidates() const { return GetPairArray(1) ? GetPairArray(1)->GetEntriesFast() > 0 : 0; }
+ Bool_t HasCandidatesTR() const { return GetPairArray(7) ? GetPairArray(7)->GetEntriesFast() > 0 : 0; }
+ Bool_t HasCandidatesLikeSign() const
+ {
return (GetPairArray(0) && GetPairArray(2))
- ? (GetPairArray(0)->GetEntriesFast() > 0
- || GetPairArray(2)->GetEntriesFast() > 0)
+ ? (GetPairArray(0)->GetEntriesFast() > 0 || GetPairArray(2)->GetEntriesFast() > 0)
: 0;
}
// prefilter
- void SetPreFilterUnlikeOnly(Bool_t setValue = kTRUE) {
- fPreFilterUnlikeOnly = setValue;
- };
- void SetPreFilterAllSigns(Bool_t setValue = kTRUE) {
- fPreFilterAllSigns = setValue;
- };
+ void SetPreFilterUnlikeOnly(Bool_t setValue = kTRUE) { fPreFilterUnlikeOnly = setValue; };
+ void SetPreFilterAllSigns(Bool_t setValue = kTRUE) { fPreFilterAllSigns = setValue; };
// background estimator - track rotation
- void SetTrackRotator(PairAnalysisTrackRotator* const rot) {
- fTrackRotator = rot;
- }
+ void SetTrackRotator(PairAnalysisTrackRotator* const rot) { fTrackRotator = rot; }
PairAnalysisTrackRotator* GetTrackRotator() const { return fTrackRotator; }
void SetStoreRotatedPairs(Bool_t storeTR) { fStoreRotatedPairs = storeTR; }
// background estimator - mixed events
void SetMixingHandler(PairAnalysisMixingHandler* mix) { fMixing = mix; }
PairAnalysisMixingHandler* GetMixingHandler() const { return fMixing; }
- void SetDontClearArrays(Bool_t dontClearArrays = kTRUE) {
- fDontClearArrays = dontClearArrays;
- }
+ void SetDontClearArrays(Bool_t dontClearArrays = kTRUE) { fDontClearArrays = dontClearArrays; }
Bool_t DontClearArrays() const { return fDontClearArrays; }
// mc specific
void SetHasMC(Bool_t hasMC) { fHasMC = hasMC; }
void AddSignalMC(PairAnalysisSignalMC* signal);
void SetMotherPdg(Int_t pdgMother) { fPdgMother = pdgMother; }
- void SetLegPdg(Int_t pdgLeg1, Int_t pdgLeg2) {
+ void SetLegPdg(Int_t pdgLeg1, Int_t pdgLeg2)
+ {
fPdgLeg1 = pdgLeg1;
fPdgLeg2 = pdgLeg2;
}
- void SetRefitWithMassAssump(Bool_t setValue = kTRUE) {
- fRefitMassAssump = setValue;
- }
+ void SetRefitWithMassAssump(Bool_t setValue = kTRUE) { fRefitMassAssump = setValue; }
const TObjArray* GetMCSignals() const { return fSignalsMC; }
Bool_t GetHasMC() const { return fHasMC; }
Int_t GetMotherPdg() const { return fPdgMother; }
Int_t GetLeg1Pdg() const { return fPdgLeg1; }
Int_t GetLeg2Pdg() const { return fPdgLeg2; }
- static const char* TrackClassName(Int_t i) {
- return (i >= 0 && i < 2) ? fgkTrackClassNames[i] : "";
- }
- static const char* PairClassName(Int_t i) {
- return (i >= 0 && i < 8) ? fgkPairClassNames[i] : "";
- }
+ static const char* TrackClassName(Int_t i) { return (i >= 0 && i < 2) ? fgkTrackClassNames[i] : ""; }
+ static const char* PairClassName(Int_t i) { return (i >= 0 && i < 8) ? fgkPairClassNames[i] : ""; }
Bool_t DoEventProcess() const { return fEventProcess; }
void SetEventProcess(Bool_t setValue = kTRUE) { fEventProcess = setValue; }
@@ -184,26 +159,23 @@ private:
AnalysisFilter fTrackFilter; // leg cuts
AnalysisFilter fPairPreFilterLegs; // leg filter before pair prefilter cuts
AnalysisFilter fPairPreFilter; // pair prefilter cuts
- AnalysisFilter fFinalTrackFilter; // Leg filter after the pair prefilter cuts
- AnalysisFilter fPairFilter; // pair cuts
+ AnalysisFilter fFinalTrackFilter; // Leg filter after the pair prefilter cuts
+ AnalysisFilter fPairFilter; // pair cuts
AnalysisFilter fTrackFilterMC; // MCtruth leg cuts
AnalysisFilter fPairFilterMC; // MCtruth pair cuts
- Int_t fPdgMother = 443; // pdg code of mother tracks
- Int_t fPdgLeg1 = 11; // pdg code leg1
- Int_t fPdgLeg2 = 11; // pdg code leg2
- Bool_t fRefitMassAssump =
- kFALSE; // wether refit under pdgleg mass assumption should be done
+ Int_t fPdgMother = 443; // pdg code of mother tracks
+ Int_t fPdgLeg1 = 11; // pdg code leg1
+ Int_t fPdgLeg2 = 11; // pdg code leg2
+ Bool_t fRefitMassAssump = kFALSE; // wether refit under pdgleg mass assumption should be done
TObjArray* fSignalsMC = NULL; // array of PairAnalysisSignalMC
- ECutType fCutType =
- ECutType::kBothLegs; // type of pairprefilterleg cut logic
- Bool_t fNoPairing =
- kFALSE; // if to skip pairing, can be used for track QA only
- Bool_t fProcessLS = kTRUE; // do the like-sign pairing
- Bool_t fUseKF = kFALSE; // use KF particle for pairing
+ ECutType fCutType = ECutType::kBothLegs; // type of pairprefilterleg cut logic
+ Bool_t fNoPairing = kFALSE; // if to skip pairing, can be used for track QA only
+ Bool_t fProcessLS = kTRUE; // do the like-sign pairing
+ Bool_t fUseKF = kFALSE; // use KF particle for pairing
THashList* fCutStepHistos = NULL; // list of histogram managers
PairAnalysisHF* fHistoArray = NULL; // matrix of histograms
@@ -224,23 +196,16 @@ private:
PairAnalysisTrackRotator* fTrackRotator = NULL; //Track rotator
PairAnalysisMixingHandler* fMixing = NULL; // handler for event mixing
- Bool_t fPreFilterUnlikeOnly =
- kFALSE; // Apply PreFilter either in +- or to ++/--/+- individually
- Bool_t fPreFilterAllSigns =
- kFALSE; // Apply PreFilter find in ++/--/+- and remove from all
- Bool_t fHasMC =
- kFALSE; // If we run with MC, at the moment only needed in AOD
- Bool_t fStoreRotatedPairs =
- kFALSE; // If the rotated pairs should be stored in the pair array
+ Bool_t fPreFilterUnlikeOnly = kFALSE; // Apply PreFilter either in +- or to ++/--/+- individually
+ Bool_t fPreFilterAllSigns = kFALSE; // Apply PreFilter find in ++/--/+- and remove from all
+ Bool_t fHasMC = kFALSE; // If we run with MC, at the moment only needed in AOD
+ Bool_t fStoreRotatedPairs = kFALSE; // If the rotated pairs should be stored in the pair array
Bool_t fDontClearArrays =
kFALSE; // Don't clear the arrays at the end of the Process function, needed for external use of pair and tracks
Bool_t fEventProcess = kTRUE; // Process event (or pair array)
void FillTrackArrays(PairAnalysisEvent* const ev);
- void PairPreFilter(Int_t arr1,
- Int_t arr2,
- TObjArray& arrTracks1,
- TObjArray& arrTracks2);
+ void PairPreFilter(Int_t arr1, Int_t arr2, TObjArray& arrTracks1, TObjArray& arrTracks2);
void FilterTrackArrays(TObjArray& arrTracks1, TObjArray& arrTracks2);
void FillPairArrays(Int_t arr1, Int_t arr2);
void FillPairArrayTR();
@@ -257,26 +222,15 @@ private:
void ProcessMC();
- void FillHistograms(const PairAnalysisEvent* ev,
- Bool_t pairInfoOnly = kFALSE);
+ void FillHistograms(const PairAnalysisEvent* ev, Bool_t pairInfoOnly = kFALSE);
Bool_t FillMCHistograms(Int_t label1, Int_t label2, Int_t nSignal);
void FillHistogramsMC(const PairAnalysisEvent* ev, PairAnalysisEvent* ev1);
- void FillHistogramsPair(PairAnalysisPair* pair,
- Bool_t fromPreFilter = kFALSE);
+ void FillHistogramsPair(PairAnalysisPair* pair, Bool_t fromPreFilter = kFALSE);
void FillHistogramsTracks(TObjArray** tracks);
- void FillHistogramsHits(const PairAnalysisEvent* ev,
- TBits* fillMC,
- PairAnalysisTrack* track,
- Bool_t trackIsLeg,
+ void FillHistogramsHits(const PairAnalysisEvent* ev, TBits* fillMC, PairAnalysisTrack* track, Bool_t trackIsLeg,
Double_t* values);
- void FillCutStepHistograms(AnalysisFilter* filter,
- UInt_t cutmask,
- PairAnalysisTrack* trk,
- const Double_t* values);
- void FillCutStepHistogramsMC(AnalysisFilter* filter,
- UInt_t cutmask,
- Int_t label,
- const Double_t* values);
+ void FillCutStepHistograms(AnalysisFilter* filter, UInt_t cutmask, PairAnalysisTrack* trk, const Double_t* values);
+ void FillCutStepHistogramsMC(AnalysisFilter* filter, UInt_t cutmask, Int_t label, const Double_t* values);
PairAnalysis(const PairAnalysis& c);
PairAnalysis& operator=(const PairAnalysis& c);
@@ -284,7 +238,8 @@ private:
ClassDef(PairAnalysis, 2); //Steering class to process the data
};
-inline Int_t PairAnalysis::GetPairIndex(Int_t arr1, Int_t arr2) const {
+inline Int_t PairAnalysis::GetPairIndex(Int_t arr1, Int_t arr2) const
+{
//
// get pair index
//
@@ -299,7 +254,8 @@ inline Int_t PairAnalysis::GetPairIndex(Int_t arr1, Int_t arr2) const {
}
-inline void PairAnalysis::InitPairCandidateArrays() {
+inline void PairAnalysis::InitPairCandidateArrays()
+{
//
// initialise all pair candidate arrays
//
@@ -312,14 +268,16 @@ inline void PairAnalysis::InitPairCandidateArrays() {
}
}
-inline TObjArray* PairAnalysis::PairArray(Int_t i) {
+inline TObjArray* PairAnalysis::PairArray(Int_t i)
+{
//
// for internal use only: unchecked return of pair array for fast access
//
return static_cast<TObjArray*>(fPairCandidates->UncheckedAt(i));
}
-inline void PairAnalysis::ClearArrays() {
+inline void PairAnalysis::ClearArrays()
+{
//
// Reset the Arrays
//
diff --git a/analysis/PWGDIL/dielectron/papaframework/PairAnalysisCutCombi.cxx b/analysis/PWGDIL/dielectron/papaframework/PairAnalysisCutCombi.cxx
index a9edb341924444a7e267cbc432eaa77213ded448..7e1ae572f11d20a2703b38fd4f455a8969491ad5 100644
--- a/analysis/PWGDIL/dielectron/papaframework/PairAnalysisCutCombi.cxx
+++ b/analysis/PWGDIL/dielectron/papaframework/PairAnalysisCutCombi.cxx
@@ -28,10 +28,10 @@
// //
///////////////////////////////////////////////////////////////////////////
-#include "PairAnalysisVarManager.h"
-
#include "PairAnalysisCutCombi.h"
+#include "PairAnalysisVarManager.h"
+
ClassImp(PairAnalysisCutCombi)
PairAnalysisCutCombi::PairAnalysisCutCombi()
@@ -39,7 +39,8 @@ ClassImp(PairAnalysisCutCombi)
, fNActiveCuts(0)
, fActiveCutsMask(0)
, fSelectedCutsMask(0)
- , fCutType(ECutType::kAll) {
+ , fCutType(ECutType::kAll)
+{
//
// Default Constructor
//
@@ -55,7 +56,8 @@ PairAnalysisCutCombi::PairAnalysisCutCombi(const char* name, const char* title)
, fNActiveCuts(0)
, fActiveCutsMask(0)
, fSelectedCutsMask(0)
- , fCutType(ECutType::kAll) {
+ , fCutType(ECutType::kAll)
+{
//
// Named Constructor
//
@@ -66,7 +68,8 @@ PairAnalysisCutCombi::PairAnalysisCutCombi(const char* name, const char* title)
}
//______________________________________________
-PairAnalysisCutCombi::~PairAnalysisCutCombi() {
+PairAnalysisCutCombi::~PairAnalysisCutCombi()
+{
//
// Default Destructor
//
@@ -77,7 +80,8 @@ PairAnalysisCutCombi::~PairAnalysisCutCombi() {
}
//______________________________________________
-void PairAnalysisCutCombi::AddCut(AnalysisCuts* cuts, AnalysisCuts* range) {
+void PairAnalysisCutCombi::AddCut(AnalysisCuts* cuts, AnalysisCuts* range)
+{
//
// add CutCombi cuts
//
@@ -94,7 +98,8 @@ void PairAnalysisCutCombi::AddCut(AnalysisCuts* cuts, AnalysisCuts* range) {
//______________________________________________
-Bool_t PairAnalysisCutCombi::IsSelected(TObject* track) {
+Bool_t PairAnalysisCutCombi::IsSelected(TObject* track)
+{
//
// make cut decision
//
@@ -110,7 +115,8 @@ Bool_t PairAnalysisCutCombi::IsSelected(TObject* track) {
}
//________________________________________________________________________
-Bool_t PairAnalysisCutCombi::IsSelected(Double_t* const values) {
+Bool_t PairAnalysisCutCombi::IsSelected(Double_t* const values)
+{
//
// Make cut decision
//
@@ -132,8 +138,7 @@ Bool_t PairAnalysisCutCombi::IsSelected(Double_t* const values) {
if (!fCuts[iCut]->IsSelected(values)) CLRBIT(fSelectedCutsMask, iCut);
// cut type and intermediate decision
- if (fCutType == ECutType::kAll && !TESTBIT(fSelectedCutsMask, iCut))
- return kFALSE;
+ if (fCutType == ECutType::kAll && !TESTBIT(fSelectedCutsMask, iCut)) return kFALSE;
}
// cut type and final decision
@@ -144,15 +149,15 @@ Bool_t PairAnalysisCutCombi::IsSelected(Double_t* const values) {
}
//________________________________________________________________________
-void PairAnalysisCutCombi::Print(const Option_t* /*option*/) const {
+void PairAnalysisCutCombi::Print(const Option_t* /*option*/) const
+{
//
// Print cuts and the range
//
printf("-----------------------------------------------------------------\n");
printf("cut ranges for '%s'\n", GetTitle());
- if (fCutType == ECutType::kAll) {
- printf("All Cuts have to be fulfilled\n");
- } else {
+ if (fCutType == ECutType::kAll) { printf("All Cuts have to be fulfilled\n"); }
+ else {
printf("Any Cut has to be fulfilled\n");
}
diff --git a/analysis/PWGDIL/dielectron/papaframework/PairAnalysisCutCombi.h b/analysis/PWGDIL/dielectron/papaframework/PairAnalysisCutCombi.h
index 15552f00d76b77e0119a6a6b4932e2921765a306..d5f225c4ad6ffd40b54c368dc8487f166f704e66 100644
--- a/analysis/PWGDIL/dielectron/papaframework/PairAnalysisCutCombi.h
+++ b/analysis/PWGDIL/dielectron/papaframework/PairAnalysisCutCombi.h
@@ -20,7 +20,11 @@ class PairAnalysisVarManager;
class PairAnalysisCutCombi : public AnalysisCuts {
public:
// Whether all cut criteria have to be fulfilled of just any
- enum class ECutType { kAll = 0, kAny };
+ enum class ECutType
+ {
+ kAll = 0,
+ kAny
+ };
PairAnalysisCutCombi();
PairAnalysisCutCombi(const char* name, const char* title);
@@ -55,9 +59,8 @@ private:
UShort_t fNActiveCuts; // number of acive cuts
UInt_t fActiveCutsMask; // mask of active cuts
- UInt_t
- fSelectedCutsMask; // Maks of selected cuts, is available after calling IsSelected
- ECutType fCutType; // type of the cut: any, all
+ UInt_t fSelectedCutsMask; // Maks of selected cuts, is available after calling IsSelected
+ ECutType fCutType; // type of the cut: any, all
AnalysisCuts* fRangeCuts[kNmaxCuts]; // cuts to select a range
AnalysisCuts* fCuts[kNmaxCuts]; // where these cuts are applied
diff --git a/analysis/PWGDIL/dielectron/papaframework/PairAnalysisCutGroup.cxx b/analysis/PWGDIL/dielectron/papaframework/PairAnalysisCutGroup.cxx
index 07af6ee5580771ab3d464b9539a1b2e3819731a4..b6ebc3e15bd47f885b8bfb5edbf5431cfb4a3c8c 100644
--- a/analysis/PWGDIL/dielectron/papaframework/PairAnalysisCutGroup.cxx
+++ b/analysis/PWGDIL/dielectron/papaframework/PairAnalysisCutGroup.cxx
@@ -12,36 +12,43 @@
//////////////////////////////////////////////////////////////////////////
#include "PairAnalysisCutGroup.h"
+
#include "PairAnalysisVarManager.h"
ClassImp(PairAnalysisCutGroup)
PairAnalysisCutGroup::PairAnalysisCutGroup(Bool_t compOperator /*=kCompOR*/)
- : AnalysisCuts(), fCutGroupList(0x0), fCompOperator(compOperator) {
+ : AnalysisCuts()
+ , fCutGroupList(0x0)
+ , fCompOperator(compOperator)
+{
//
// Default constructor
//
}
//_____________________________________________________________________
-PairAnalysisCutGroup::PairAnalysisCutGroup(const char* name,
- const char* title,
- Bool_t compOperator /*=kCompOR*/)
- : AnalysisCuts(name, title), fCutGroupList(0x0), fCompOperator(compOperator) {
+PairAnalysisCutGroup::PairAnalysisCutGroup(const char* name, const char* title, Bool_t compOperator /*=kCompOR*/)
+ : AnalysisCuts(name, title)
+ , fCutGroupList(0x0)
+ , fCompOperator(compOperator)
+{
//
// Named Constructor
//
}
//_____________________________________________________________________
-PairAnalysisCutGroup::~PairAnalysisCutGroup() {
+PairAnalysisCutGroup::~PairAnalysisCutGroup()
+{
//
//Default Destructor
//
}
//_____________________________________________________________________
-void PairAnalysisCutGroup::Init() {
+void PairAnalysisCutGroup::Init()
+{
// Loop over all cuts and call Init
TIter next(&fCutGroupList);
while (AnalysisCuts* thisCut = (AnalysisCuts*) next())
@@ -49,7 +56,8 @@ void PairAnalysisCutGroup::Init() {
}
//________________________________________________________________________
-Bool_t PairAnalysisCutGroup::IsSelected(Double_t* const values) {
+Bool_t PairAnalysisCutGroup::IsSelected(Double_t* const values)
+{
//
// Make cut decision
//
@@ -61,7 +69,8 @@ Bool_t PairAnalysisCutGroup::IsSelected(Double_t* const values) {
while (AnalysisCuts* thisCut = (AnalysisCuts*) listIterator()) {
if (fCompOperator == static_cast<Bool_t>(ETruthValues::kCompOR)) {
selectionResult = (selectionResult || thisCut->IsSelected(values));
- } else { //kCompAND
+ }
+ else { //kCompAND
selectionResult = (selectionResult && thisCut->IsSelected(values));
/// if (selectionResult==kFALSE) break; //Save loops vs. additional check?
}
@@ -70,7 +79,8 @@ Bool_t PairAnalysisCutGroup::IsSelected(Double_t* const values) {
}
//_____________________________________________________________________
-Bool_t PairAnalysisCutGroup::IsSelected(TObject* track) {
+Bool_t PairAnalysisCutGroup::IsSelected(TObject* track)
+{
//
// Selection-finder handling different comparison operations
//
@@ -88,7 +98,8 @@ Bool_t PairAnalysisCutGroup::IsSelected(TObject* track) {
//_____________________________________________________________________
-void PairAnalysisCutGroup::AddCut(AnalysisCuts* fCut) {
+void PairAnalysisCutGroup::AddCut(AnalysisCuts* fCut)
+{
//
// Add a defined cut to the list
//
@@ -97,7 +108,8 @@ void PairAnalysisCutGroup::AddCut(AnalysisCuts* fCut) {
}
//_____________________________________________________________________
-void PairAnalysisCutGroup::SetCompOperator(Bool_t compOperator) {
+void PairAnalysisCutGroup::SetCompOperator(Bool_t compOperator)
+{
//
// Switch between AND/OR
//
@@ -106,16 +118,16 @@ void PairAnalysisCutGroup::SetCompOperator(Bool_t compOperator) {
}
//________________________________________________________________________
-void PairAnalysisCutGroup::Print(const Option_t* /*option*/) const {
+void PairAnalysisCutGroup::Print(const Option_t* /*option*/) const
+{
//
// Print cuts and the range
//
printf("*****************************************************************\n");
printf("cut group '%s'\n", GetTitle());
- if (fCompOperator == static_cast<Bool_t>(ETruthValues::kCompAND)) {
- printf("Cut are compared with AND \n");
- } else {
+ if (fCompOperator == static_cast<Bool_t>(ETruthValues::kCompAND)) { printf("Cut are compared with AND \n"); }
+ else {
printf("Cut are compared with OR \n");
}
TIter listIterator(&fCutGroupList);
diff --git a/analysis/PWGDIL/dielectron/papaframework/PairAnalysisCutGroup.h b/analysis/PWGDIL/dielectron/papaframework/PairAnalysisCutGroup.h
index 35c56374d661c2b74326a836ea210c500fb5b2a7..f3bdd5ba65aea50ef5d581f73b631381d2ea16a0 100644
--- a/analysis/PWGDIL/dielectron/papaframework/PairAnalysisCutGroup.h
+++ b/analysis/PWGDIL/dielectron/papaframework/PairAnalysisCutGroup.h
@@ -23,14 +23,15 @@ class TCollection;
class PairAnalysisCutGroup : public AnalysisCuts {
public:
- enum class ETruthValues { kCompAND = kTRUE, kCompOR = kFALSE };
-
- PairAnalysisCutGroup(
- Bool_t compOperator = static_cast<Bool_t>(ETruthValues::kCompOR));
- PairAnalysisCutGroup(
- const char* name,
- const char* title,
- Bool_t compOperator = static_cast<Bool_t>(ETruthValues::kCompOR));
+ enum class ETruthValues
+ {
+ kCompAND = kTRUE,
+ kCompOR = kFALSE
+ };
+
+ PairAnalysisCutGroup(Bool_t compOperator = static_cast<Bool_t>(ETruthValues::kCompOR));
+ PairAnalysisCutGroup(const char* name, const char* title,
+ Bool_t compOperator = static_cast<Bool_t>(ETruthValues::kCompOR));
virtual ~PairAnalysisCutGroup();
diff --git a/analysis/PWGDIL/dielectron/papaframework/PairAnalysisCutQA.cxx b/analysis/PWGDIL/dielectron/papaframework/PairAnalysisCutQA.cxx
index 10f37de15882e8ac7c53d42e5da7de539a717dd4..649fdc6d14e3d09ab7431f0ca24cb4ce45479ed1 100644
--- a/analysis/PWGDIL/dielectron/papaframework/PairAnalysisCutQA.cxx
+++ b/analysis/PWGDIL/dielectron/papaframework/PairAnalysisCutQA.cxx
@@ -20,36 +20,35 @@
#include "PairAnalysisCutQA.h"
+#include "CbmMCTrack.h"
+
#include <TCollection.h>
#include <TList.h>
#include <TVectorD.h>
-#include "CbmMCTrack.h"
-
#include "AnalysisCuts.h"
#include "PairAnalysisCutGroup.h"
-
#include "PairAnalysisEvent.h"
+#include "PairAnalysisHelper.h"
#include "PairAnalysisPairKF.h"
#include "PairAnalysisPairLV.h"
#include "PairAnalysisTrack.h"
-#include "PairAnalysisHelper.h"
-
ClassImp(PairAnalysisCutQA)
PairAnalysisCutQA::PairAnalysisCutQA()
- : PairAnalysisCutQA("QAcuts", "QAcuts") {
+ : PairAnalysisCutQA("QAcuts", "QAcuts")
+{
//
// Default constructor
//
}
//_____________________________________________________________________
-PairAnalysisCutQA::PairAnalysisCutQA(const char* name, const char* title)
- : TNamed(name, title), fQAHistList() {
+PairAnalysisCutQA::PairAnalysisCutQA(const char* name, const char* title) : TNamed(name, title), fQAHistList()
+{
//
// Named Constructor
//
@@ -69,7 +68,8 @@ PairAnalysisCutQA::PairAnalysisCutQA(const char* name, const char* title)
}
//_____________________________________________________________________
-PairAnalysisCutQA::~PairAnalysisCutQA() {
+PairAnalysisCutQA::~PairAnalysisCutQA()
+{
//
//Default Destructor
//
@@ -77,7 +77,8 @@ PairAnalysisCutQA::~PairAnalysisCutQA() {
}
//_____________________________________________________________________
-void PairAnalysisCutQA::Init() {
+void PairAnalysisCutQA::Init()
+{
fQAHistList.SetName(Form("%s", GetName()));
@@ -109,37 +110,22 @@ void PairAnalysisCutQA::Init() {
TString logic = "passed";
if (itype == static_cast<Int_t>(ETypes::kPrePair)) logic = "rejected";
- const TVectorD* binsX =
- PairAnalysisHelper::MakeLinBinning(fNCuts[itype], 0, fNCuts[itype]);
+ const TVectorD* binsX = PairAnalysisHelper::MakeLinBinning(fNCuts[itype], 0, fNCuts[itype]);
// create histogram based on added cuts
- fCutQA = new TH1I(
- fTypeKeys[itype],
- Form(
- "%sQA;cuts;# %s %ss", fTypeKeys[itype], logic.Data(), fTypeKeys[itype]),
- fNCuts[itype],
- binsX->GetMatrixArray());
-
- if (itype == static_cast<Int_t>(ETypes::kTrack)
- || itype == static_cast<Int_t>(ETypes::kTrack2)) {
+ fCutQA = new TH1I(fTypeKeys[itype], Form("%sQA;cuts;# %s %ss", fTypeKeys[itype], logic.Data(), fTypeKeys[itype]),
+ fNCuts[itype], binsX->GetMatrixArray());
+
+ if (itype == static_cast<Int_t>(ETypes::kTrack) || itype == static_cast<Int_t>(ETypes::kTrack2)) {
fPdgCutQA = new TH2I(Form("%sPDG", fTypeKeys[itype]),
- Form("%sPDG;cuts;PDG code;# %s %ss",
- fTypeKeys[itype],
- logic.Data(),
- fTypeKeys[itype]),
- fNCuts[itype],
- binsX->GetMatrixArray(),
- binsPdg->GetNrows() - 1,
- binsPdg->GetMatrixArray());
+ Form("%sPDG;cuts;PDG code;# %s %ss", fTypeKeys[itype], logic.Data(), fTypeKeys[itype]),
+ fNCuts[itype], binsX->GetMatrixArray(), binsPdg->GetNrows() - 1, binsPdg->GetMatrixArray());
fEffCutQA =
new TProfile2D(Form("%sMatchEff", fTypeKeys[itype]),
- Form("%sMatchEff;cuts;detector;<#epsilon_{match}^{MC}>",
- fTypeKeys[itype]),
- fNCuts[itype],
- binsX->GetMatrixArray(),
- binsDet->GetNrows() - 1,
- binsDet->GetMatrixArray());
- } else {
+ Form("%sMatchEff;cuts;detector;<#epsilon_{match}^{MC}>", fTypeKeys[itype]), fNCuts[itype],
+ binsX->GetMatrixArray(), binsDet->GetNrows() - 1, binsDet->GetMatrixArray());
+ }
+ else {
fPdgCutQA = 0x0;
fEffCutQA = 0x0;
}
@@ -156,10 +142,8 @@ void PairAnalysisCutQA::Init() {
// loop over all cuts
for (Int_t i = 0; i < fNCuts[itype]; i++) {
fCutQA->GetXaxis()->SetBinLabel(i + 1, fCutNames[i][itype]);
- if (fPdgCutQA)
- fPdgCutQA->GetXaxis()->SetBinLabel(i + 1, fCutNames[i][itype]);
- if (fEffCutQA)
- fEffCutQA->GetXaxis()->SetBinLabel(i + 1, fCutNames[i][itype]);
+ if (fPdgCutQA) fPdgCutQA->GetXaxis()->SetBinLabel(i + 1, fCutNames[i][itype]);
+ if (fEffCutQA) fEffCutQA->GetXaxis()->SetBinLabel(i + 1, fCutNames[i][itype]);
// printf(" itype:%s %d -> cut:%s \n",fTypeKeys[itype],itype,fCutNames[i][itype]);
}
@@ -183,24 +167,12 @@ void PairAnalysisCutQA::Init() {
TString detlbl = "";
for (Int_t i = 0; i < binsDet->GetNrows() - 1; i++) {
switch (i + 1) {
- case 1:
- detlbl = PairAnalysisHelper::GetDetName(ECbmModuleId::kMvd);
- break;
- case 2:
- detlbl = PairAnalysisHelper::GetDetName(ECbmModuleId::kSts);
- break;
- case 3:
- detlbl = PairAnalysisHelper::GetDetName(ECbmModuleId::kRich);
- break;
- case 4:
- detlbl = PairAnalysisHelper::GetDetName(ECbmModuleId::kTrd);
- break;
- case 5:
- detlbl = PairAnalysisHelper::GetDetName(ECbmModuleId::kTof);
- break;
- case 6:
- detlbl = PairAnalysisHelper::GetDetName(ECbmModuleId::kMuch);
- break;
+ case 1: detlbl = PairAnalysisHelper::GetDetName(ECbmModuleId::kMvd); break;
+ case 2: detlbl = PairAnalysisHelper::GetDetName(ECbmModuleId::kSts); break;
+ case 3: detlbl = PairAnalysisHelper::GetDetName(ECbmModuleId::kRich); break;
+ case 4: detlbl = PairAnalysisHelper::GetDetName(ECbmModuleId::kTrd); break;
+ case 5: detlbl = PairAnalysisHelper::GetDetName(ECbmModuleId::kTof); break;
+ case 6: detlbl = PairAnalysisHelper::GetDetName(ECbmModuleId::kMuch); break;
}
fEffCutQA->GetYaxis()->SetBinLabel(i + 1, detlbl.Data());
}
@@ -209,25 +181,18 @@ void PairAnalysisCutQA::Init() {
// add to output list
switch (itype) {
case static_cast<Int_t>(ETypes::kEvent):
- static_cast<THashList*>(fQAHistList.FindObject("Event"))
- ->AddLast(fCutQA);
+ static_cast<THashList*>(fQAHistList.FindObject("Event"))->AddLast(fCutQA);
break;
case static_cast<Int_t>(ETypes::kTrack):
case static_cast<Int_t>(ETypes::kTrack2):
case static_cast<Int_t>(ETypes::kTrackMC):
- static_cast<THashList*>(fQAHistList.FindObject("Track"))
- ->AddLast(fCutQA);
- if (fPdgCutQA)
- static_cast<THashList*>(fQAHistList.FindObject("Track"))
- ->AddLast(fPdgCutQA);
- if (fEffCutQA)
- static_cast<THashList*>(fQAHistList.FindObject("Track"))
- ->AddLast(fEffCutQA);
+ static_cast<THashList*>(fQAHistList.FindObject("Track"))->AddLast(fCutQA);
+ if (fPdgCutQA) static_cast<THashList*>(fQAHistList.FindObject("Track"))->AddLast(fPdgCutQA);
+ if (fEffCutQA) static_cast<THashList*>(fQAHistList.FindObject("Track"))->AddLast(fEffCutQA);
break;
case static_cast<Int_t>(ETypes::kPair):
case static_cast<Int_t>(ETypes::kPrePair):
- static_cast<THashList*>(fQAHistList.FindObject("Pair"))
- ->AddLast(fCutQA);
+ static_cast<THashList*>(fQAHistList.FindObject("Pair"))->AddLast(fCutQA);
break;
}
}
@@ -238,7 +203,8 @@ void PairAnalysisCutQA::Init() {
}
//_____________________________________________________________________
-void PairAnalysisCutQA::AddTrackFilter(AnalysisFilter* filter) {
+void PairAnalysisCutQA::AddTrackFilter(AnalysisFilter* filter)
+{
//
// add track filter cuts to the qa histogram
//
@@ -250,8 +216,7 @@ void PairAnalysisCutQA::AddTrackFilter(AnalysisFilter* filter) {
// add new cut class to the list
if (addCut) {
- fCutNames[fNCuts[static_cast<Int_t>(ETypes::kTrack)]]
- [static_cast<Int_t>(ETypes::kTrack)] = thisCut->GetTitle();
+ fCutNames[fNCuts[static_cast<Int_t>(ETypes::kTrack)]][static_cast<Int_t>(ETypes::kTrack)] = thisCut->GetTitle();
// printf("add cut %s to %d \n",thisCut->GetTitle(),fNCuts[kTrack]);
fNCuts[static_cast<Int_t>(ETypes::kTrack)]++;
}
@@ -260,7 +225,8 @@ void PairAnalysisCutQA::AddTrackFilter(AnalysisFilter* filter) {
}
//_____________________________________________________________________
-void PairAnalysisCutQA::AddTrackFilterMC(AnalysisFilter* filter) {
+void PairAnalysisCutQA::AddTrackFilterMC(AnalysisFilter* filter)
+{
//
// add MC track filter cuts to the qa histogram
//
@@ -272,8 +238,8 @@ void PairAnalysisCutQA::AddTrackFilterMC(AnalysisFilter* filter) {
// add new cut class to the list
if (addCut) {
- fCutNames[fNCuts[static_cast<Int_t>(ETypes::kTrackMC)]]
- [static_cast<Int_t>(ETypes::kTrackMC)] = thisCut->GetTitle();
+ fCutNames[fNCuts[static_cast<Int_t>(ETypes::kTrackMC)]][static_cast<Int_t>(ETypes::kTrackMC)] =
+ thisCut->GetTitle();
// printf("add cut %s to %d \n",thisCut->GetTitle(),fNCuts[kTrack]);
fNCuts[static_cast<Int_t>(ETypes::kTrackMC)]++;
}
@@ -282,7 +248,8 @@ void PairAnalysisCutQA::AddTrackFilterMC(AnalysisFilter* filter) {
}
//_____________________________________________________________________
-void PairAnalysisCutQA::AddTrackFilter2(AnalysisFilter* filter) {
+void PairAnalysisCutQA::AddTrackFilter2(AnalysisFilter* filter)
+{
//
// add track filter cuts to the qa histogram
//
@@ -294,8 +261,7 @@ void PairAnalysisCutQA::AddTrackFilter2(AnalysisFilter* filter) {
// add new cut class to the list
if (addCut) {
- fCutNames[fNCuts[static_cast<Int_t>(ETypes::kTrack2)]]
- [static_cast<Int_t>(ETypes::kTrack2)] = thisCut->GetTitle();
+ fCutNames[fNCuts[static_cast<Int_t>(ETypes::kTrack2)]][static_cast<Int_t>(ETypes::kTrack2)] = thisCut->GetTitle();
// printf("add cut %s to %d \n",thisCut->GetTitle(),fNCuts[kTrack]);
fNCuts[static_cast<Int_t>(ETypes::kTrack2)]++;
}
@@ -305,7 +271,8 @@ void PairAnalysisCutQA::AddTrackFilter2(AnalysisFilter* filter) {
//_____________________________________________________________________
-void PairAnalysisCutQA::AddPairFilter(AnalysisFilter* pairFilter) {
+void PairAnalysisCutQA::AddPairFilter(AnalysisFilter* pairFilter)
+{
//
// add track filter cuts to the qa histogram
//
@@ -316,8 +283,7 @@ void PairAnalysisCutQA::AddPairFilter(AnalysisFilter* pairFilter) {
// add new cut class to the list
if (addCut) {
- fCutNames[fNCuts[static_cast<Int_t>(ETypes::kPair)]]
- [static_cast<Int_t>(ETypes::kPair)] = thisCut->GetTitle();
+ fCutNames[fNCuts[static_cast<Int_t>(ETypes::kPair)]][static_cast<Int_t>(ETypes::kPair)] = thisCut->GetTitle();
// printf("add cut %s to %d \n",thisCut->GetTitle(),fNCuts[kPair]);
fNCuts[static_cast<Int_t>(ETypes::kPair)]++;
}
@@ -326,7 +292,8 @@ void PairAnalysisCutQA::AddPairFilter(AnalysisFilter* pairFilter) {
}
//_____________________________________________________________________
-void PairAnalysisCutQA::AddPrePairFilter(AnalysisFilter* pairFilter) {
+void PairAnalysisCutQA::AddPrePairFilter(AnalysisFilter* pairFilter)
+{
//
// add track filter cuts to the qa histogram
//
@@ -338,8 +305,8 @@ void PairAnalysisCutQA::AddPrePairFilter(AnalysisFilter* pairFilter) {
// add new cut class to the list
if (addCut) {
- fCutNames[fNCuts[static_cast<Int_t>(ETypes::kPrePair)]]
- [static_cast<Int_t>(ETypes::kPrePair)] = thisCut->GetTitle();
+ fCutNames[fNCuts[static_cast<Int_t>(ETypes::kPrePair)]][static_cast<Int_t>(ETypes::kPrePair)] =
+ thisCut->GetTitle();
// printf("add cut %s to %d \n",thisCut->GetTitle(),fNCuts[kPair]);
fNCuts[static_cast<Int_t>(ETypes::kPrePair)]++;
}
@@ -348,7 +315,8 @@ void PairAnalysisCutQA::AddPrePairFilter(AnalysisFilter* pairFilter) {
}
//_____________________________________________________________________
-void PairAnalysisCutQA::AddEventFilter(AnalysisFilter* eventFilter) {
+void PairAnalysisCutQA::AddEventFilter(AnalysisFilter* eventFilter)
+{
//
// add track filter cuts to the qa histogram
//
@@ -360,8 +328,7 @@ void PairAnalysisCutQA::AddEventFilter(AnalysisFilter* eventFilter) {
// add new cut class to the list
if (addCut) {
- fCutNames[fNCuts[static_cast<Int_t>(ETypes::kEvent)]]
- [static_cast<Int_t>(ETypes::kEvent)] = thisCut->GetTitle();
+ fCutNames[fNCuts[static_cast<Int_t>(ETypes::kEvent)]][static_cast<Int_t>(ETypes::kEvent)] = thisCut->GetTitle();
// printf("add cut %s to %d \n",thisCut->GetTitle(),fNCuts[kEvent]);
fNCuts[static_cast<Int_t>(ETypes::kEvent)]++;
}
@@ -370,7 +337,8 @@ void PairAnalysisCutQA::AddEventFilter(AnalysisFilter* eventFilter) {
}
//_____________________________________________________________________
-void PairAnalysisCutQA::Fill(UInt_t mask, TObject* obj, UInt_t addIdx) {
+void PairAnalysisCutQA::Fill(UInt_t mask, TObject* obj, UInt_t addIdx)
+{
//
// fill the corresponding step in the qa histogram
//
@@ -380,8 +348,7 @@ void PairAnalysisCutQA::Fill(UInt_t mask, TObject* obj, UInt_t addIdx) {
// pdg to pdg label
Int_t pdg = 0;
TString pdglbl = "";
- if (idx == static_cast<Int_t>(ETypes::kTrack)
- || idx == static_cast<Int_t>(ETypes::kTrack2)) {
+ if (idx == static_cast<Int_t>(ETypes::kTrack) || idx == static_cast<Int_t>(ETypes::kTrack2)) {
pdg = (Int_t)(static_cast<PairAnalysisTrack*>(obj)->PdgCode());
switch (TMath::Abs(pdg)) {
case 11: pdglbl = "electron"; break; // electron
@@ -395,18 +362,12 @@ void PairAnalysisCutQA::Fill(UInt_t mask, TObject* obj, UInt_t addIdx) {
// find histolist
THashList* histos = 0x0;
switch (idx) {
- case static_cast<Int_t>(ETypes::kEvent):
- histos = static_cast<THashList*>(fQAHistList.FindObject("Event"));
- break;
+ case static_cast<Int_t>(ETypes::kEvent): histos = static_cast<THashList*>(fQAHistList.FindObject("Event")); break;
case static_cast<Int_t>(ETypes::kTrack):
case static_cast<Int_t>(ETypes::kTrack2):
- case static_cast<Int_t>(ETypes::kTrackMC):
- histos = static_cast<THashList*>(fQAHistList.FindObject("Track"));
- break;
+ case static_cast<Int_t>(ETypes::kTrackMC): histos = static_cast<THashList*>(fQAHistList.FindObject("Track")); break;
case static_cast<Int_t>(ETypes::kPair):
- case static_cast<Int_t>(ETypes::kPrePair):
- histos = static_cast<THashList*>(fQAHistList.FindObject("Pair"));
- break;
+ case static_cast<Int_t>(ETypes::kPrePair): histos = static_cast<THashList*>(fQAHistList.FindObject("Pair")); break;
}
// loop over cutmask and check decision
@@ -418,33 +379,23 @@ void PairAnalysisCutQA::Fill(UInt_t mask, TObject* obj, UInt_t addIdx) {
// passed
if ((mask & cutMask) == cutMask) {
static_cast<TH1I*>(histos->FindObject(fTypeKeys[idx]))->Fill(cutstep);
- if (pdg)
- static_cast<TH2I*>(histos->FindObject(Form("%sPDG", fTypeKeys[idx])))
- ->Fill(cutstep, pdglbl.Data(), 1.);
+ if (pdg) static_cast<TH2I*>(histos->FindObject(Form("%sPDG", fTypeKeys[idx])))->Fill(cutstep, pdglbl.Data(), 1.);
// fill detector dependent
- if (idx == static_cast<Int_t>(ETypes::kTrack)
- || idx == static_cast<Int_t>(ETypes::kTrack2)) {
- TProfile2D* detQA = static_cast<TProfile2D*>(
- histos->FindObject(Form("%sMatchEff", fTypeKeys[idx])));
+ if (idx == static_cast<Int_t>(ETypes::kTrack) || idx == static_cast<Int_t>(ETypes::kTrack2)) {
+ TProfile2D* detQA = static_cast<TProfile2D*>(histos->FindObject(Form("%sMatchEff", fTypeKeys[idx])));
PairAnalysisTrack* t = static_cast<PairAnalysisTrack*>(obj);
- detQA->Fill(cutstep,
- PairAnalysisHelper::GetDetName(ECbmModuleId::kMvd),
+ detQA->Fill(cutstep, PairAnalysisHelper::GetDetName(ECbmModuleId::kMvd),
t->TestBit(BIT(14 + ToIntegralType(ECbmModuleId::kMvd))));
- detQA->Fill(cutstep,
- PairAnalysisHelper::GetDetName(ECbmModuleId::kSts),
+ detQA->Fill(cutstep, PairAnalysisHelper::GetDetName(ECbmModuleId::kSts),
t->TestBit(BIT(14 + ToIntegralType(ECbmModuleId::kSts))));
- detQA->Fill(cutstep,
- PairAnalysisHelper::GetDetName(ECbmModuleId::kRich),
+ detQA->Fill(cutstep, PairAnalysisHelper::GetDetName(ECbmModuleId::kRich),
t->TestBit(BIT(14 + ToIntegralType(ECbmModuleId::kRich))));
- detQA->Fill(cutstep,
- PairAnalysisHelper::GetDetName(ECbmModuleId::kTrd),
+ detQA->Fill(cutstep, PairAnalysisHelper::GetDetName(ECbmModuleId::kTrd),
t->TestBit(BIT(14 + ToIntegralType(ECbmModuleId::kTrd))));
- detQA->Fill(cutstep,
- PairAnalysisHelper::GetDetName(ECbmModuleId::kTof),
+ detQA->Fill(cutstep, PairAnalysisHelper::GetDetName(ECbmModuleId::kTof),
t->TestBit(BIT(14 + ToIntegralType(ECbmModuleId::kTof))));
- detQA->Fill(cutstep,
- PairAnalysisHelper::GetDetName(ECbmModuleId::kMuch),
+ detQA->Fill(cutstep, PairAnalysisHelper::GetDetName(ECbmModuleId::kMuch),
t->TestBit(BIT(14 + ToIntegralType(ECbmModuleId::kMuch))));
}
@@ -454,7 +405,8 @@ void PairAnalysisCutQA::Fill(UInt_t mask, TObject* obj, UInt_t addIdx) {
}
//_____________________________________________________________________
-void PairAnalysisCutQA::FillAll(TObject* obj, UInt_t addIdx) {
+void PairAnalysisCutQA::FillAll(TObject* obj, UInt_t addIdx)
+{
//
// fill the corresponding step in the qa histogram
//
@@ -464,8 +416,7 @@ void PairAnalysisCutQA::FillAll(TObject* obj, UInt_t addIdx) {
// pdg to pdg label
Int_t pdg = 0;
TString pdglbl = "";
- if (idx == static_cast<Int_t>(ETypes::kTrack)
- || idx == static_cast<Int_t>(ETypes::kTrack2)) {
+ if (idx == static_cast<Int_t>(ETypes::kTrack) || idx == static_cast<Int_t>(ETypes::kTrack2)) {
pdg = (Int_t)(static_cast<PairAnalysisTrack*>(obj)->PdgCode());
switch (TMath::Abs(pdg)) {
case 11: pdglbl = "electron"; break; // electron
@@ -479,61 +430,45 @@ void PairAnalysisCutQA::FillAll(TObject* obj, UInt_t addIdx) {
// find histolist
THashList* histos = 0x0;
switch (idx) {
- case static_cast<Int_t>(ETypes::kEvent):
- histos = static_cast<THashList*>(fQAHistList.FindObject("Event"));
- break;
+ case static_cast<Int_t>(ETypes::kEvent): histos = static_cast<THashList*>(fQAHistList.FindObject("Event")); break;
case static_cast<Int_t>(ETypes::kTrack):
case static_cast<Int_t>(ETypes::kTrack2):
- case static_cast<Int_t>(ETypes::kTrackMC):
- histos = static_cast<THashList*>(fQAHistList.FindObject("Track"));
- break;
+ case static_cast<Int_t>(ETypes::kTrackMC): histos = static_cast<THashList*>(fQAHistList.FindObject("Track")); break;
case static_cast<Int_t>(ETypes::kPair):
- case static_cast<Int_t>(ETypes::kPrePair):
- histos = static_cast<THashList*>(fQAHistList.FindObject("Pair"));
- break;
+ case static_cast<Int_t>(ETypes::kPrePair): histos = static_cast<THashList*>(fQAHistList.FindObject("Pair")); break;
}
// fill
static_cast<TH1I*>(histos->FindObject(fTypeKeys[idx]))->Fill(0);
- if (pdg)
- static_cast<TH2I*>(histos->FindObject(Form("%sPDG", fTypeKeys[idx])))
- ->Fill(0., pdglbl.Data(), 1.);
+ if (pdg) static_cast<TH2I*>(histos->FindObject(Form("%sPDG", fTypeKeys[idx])))->Fill(0., pdglbl.Data(), 1.);
// fill detector dependent
- if (idx == static_cast<Int_t>(ETypes::kTrack)
- || idx == static_cast<Int_t>(ETypes::kTrack2)) {
- TProfile2D* detQA = static_cast<TProfile2D*>(
- histos->FindObject(Form("%sMatchEff", fTypeKeys[idx])));
+ if (idx == static_cast<Int_t>(ETypes::kTrack) || idx == static_cast<Int_t>(ETypes::kTrack2)) {
+ TProfile2D* detQA = static_cast<TProfile2D*>(histos->FindObject(Form("%sMatchEff", fTypeKeys[idx])));
PairAnalysisTrack* t = static_cast<PairAnalysisTrack*>(obj);
- detQA->Fill(0.,
- PairAnalysisHelper::GetDetName(ECbmModuleId::kMvd),
+ detQA->Fill(0., PairAnalysisHelper::GetDetName(ECbmModuleId::kMvd),
t->TestBit(BIT(14 + ToIntegralType(ECbmModuleId::kMvd))));
- detQA->Fill(0.,
- PairAnalysisHelper::GetDetName(ECbmModuleId::kSts),
+ detQA->Fill(0., PairAnalysisHelper::GetDetName(ECbmModuleId::kSts),
t->TestBit(BIT(14 + ToIntegralType(ECbmModuleId::kSts))));
- detQA->Fill(0.,
- PairAnalysisHelper::GetDetName(ECbmModuleId::kRich),
+ detQA->Fill(0., PairAnalysisHelper::GetDetName(ECbmModuleId::kRich),
t->TestBit(BIT(14 + ToIntegralType(ECbmModuleId::kRich))));
- detQA->Fill(0.,
- PairAnalysisHelper::GetDetName(ECbmModuleId::kTrd),
+ detQA->Fill(0., PairAnalysisHelper::GetDetName(ECbmModuleId::kTrd),
t->TestBit(BIT(14 + ToIntegralType(ECbmModuleId::kTrd))));
- detQA->Fill(0.,
- PairAnalysisHelper::GetDetName(ECbmModuleId::kTof),
+ detQA->Fill(0., PairAnalysisHelper::GetDetName(ECbmModuleId::kTof),
t->TestBit(BIT(14 + ToIntegralType(ECbmModuleId::kTof))));
- detQA->Fill(0.,
- PairAnalysisHelper::GetDetName(ECbmModuleId::kMuch),
+ detQA->Fill(0., PairAnalysisHelper::GetDetName(ECbmModuleId::kMuch),
t->TestBit(BIT(14 + ToIntegralType(ECbmModuleId::kMuch))));
}
}
//______________________________________________________________________
-UInt_t PairAnalysisCutQA::GetObjIndex(TObject* obj) {
+UInt_t PairAnalysisCutQA::GetObjIndex(TObject* obj)
+{
//
// return the corresponding idex
//
// printf("INFO: object type is a %s \n", obj->IsA()->GetName());
- if (obj->IsA() == CbmMCTrack::Class())
- return static_cast<Int_t>(ETypes::kTrackMC);
+ if (obj->IsA() == CbmMCTrack::Class()) return static_cast<Int_t>(ETypes::kTrackMC);
else if (obj->IsA() == PairAnalysisTrack::Class())
return static_cast<Int_t>(ETypes::kTrack);
else if (obj->IsA() == PairAnalysisPairLV::Class())
diff --git a/analysis/PWGDIL/dielectron/papaframework/PairAnalysisCutQA.h b/analysis/PWGDIL/dielectron/papaframework/PairAnalysisCutQA.h
index ef2ad650c5456e36e48d292b05d7dc8f0b7d42ae..8e43a2243553e055277a1049b55f14170dce831c 100644
--- a/analysis/PWGDIL/dielectron/papaframework/PairAnalysisCutQA.h
+++ b/analysis/PWGDIL/dielectron/papaframework/PairAnalysisCutQA.h
@@ -24,7 +24,8 @@ class TCollection;
class PairAnalysisCutQA : public TNamed {
public:
- enum class ETypes {
+ enum class ETypes
+ {
kEvent = 0,
kTrack,
kTrack2,
diff --git a/analysis/PWGDIL/dielectron/papaframework/PairAnalysisEvent.cxx b/analysis/PWGDIL/dielectron/papaframework/PairAnalysisEvent.cxx
index 49abfcac5d67c2491b4327e96fe811b1349f1efb..9d5c87998354f6a2330b4cf239c1e033ce2cf5af 100644
--- a/analysis/PWGDIL/dielectron/papaframework/PairAnalysisEvent.cxx
+++ b/analysis/PWGDIL/dielectron/papaframework/PairAnalysisEvent.cxx
@@ -18,18 +18,7 @@
*/
// //
///////////////////////////////////////////////////////////////////////////
-#include <Rtypes.h>
-#include <TArrayS.h>
-#include <TMatrixFSym.h>
-#include <TObjArray.h>
-#include <TParticle.h>
-
-
-#include "FairMCPoint.h"
-#include "FairRootManager.h"
-#include "FairTrackParam.h"
-
-#include "FairMCEventHeader.h"
+#include "PairAnalysisEvent.h"
#include "CbmGlobalTrack.h"
#include "CbmKFVertex.h"
@@ -42,7 +31,17 @@
#include "CbmTrdTrack.h"
#include "CbmVertex.h"
-#include "PairAnalysisEvent.h"
+#include "FairMCEventHeader.h"
+#include "FairMCPoint.h"
+#include "FairRootManager.h"
+#include "FairTrackParam.h"
+
+#include <Rtypes.h>
+#include <TArrayS.h>
+#include <TMatrixFSym.h>
+#include <TObjArray.h>
+#include <TParticle.h>
+
#include "PairAnalysisTrack.h"
ClassImp(PairAnalysisEvent)
@@ -69,7 +68,8 @@ PairAnalysisEvent::PairAnalysisEvent(const char* name, const char* title)
}
//______________________________________________
-PairAnalysisEvent::~PairAnalysisEvent() {
+PairAnalysisEvent::~PairAnalysisEvent()
+{
//
// Default Destructor
//
@@ -119,7 +119,8 @@ PairAnalysisEvent::~PairAnalysisEvent() {
}
//______________________________________________
-void PairAnalysisEvent::SetInput(FairRootManager* man) {
+void PairAnalysisEvent::SetInput(FairRootManager* man)
+{
//
// setup the track/hit branches
//
@@ -133,9 +134,7 @@ void PairAnalysisEvent::SetInput(FairRootManager* man) {
// The old name for the object is "PrimaryVertex" the new one
// "PrimaryVertex." Check first for the new name
fPrimVertex = dynamic_cast<CbmVertex*>(man->GetObject("PrimaryVertex."));
- if (nullptr == fPrimVertex) {
- fPrimVertex = dynamic_cast<CbmVertex*>(man->GetObject("PrimaryVertex"));
- }
+ if (nullptr == fPrimVertex) { fPrimVertex = dynamic_cast<CbmVertex*>(man->GetObject("PrimaryVertex")); }
// MC matches and tracks
fMCHeader = (FairMCEventHeader*) man->GetObject("MCEventHeader.");
fMCTracks = (TClonesArray*) man->GetObject("MCTrack");
@@ -152,8 +151,7 @@ void PairAnalysisEvent::SetInput(FairRootManager* man) {
fRichHits = (TClonesArray*) man->GetObject("RichHit");
fTofHits = (TClonesArray*) man->GetObject("TofHit");
// hit matches (matches are accessed directly via CbmHit::GetMatch)
- fMvdHitMatches =
- (TClonesArray*) man->GetObject("MvdHitMatch"); //needed for mvd matching
+ fMvdHitMatches = (TClonesArray*) man->GetObject("MvdHitMatch"); //needed for mvd matching
fStsHitMatches = (TClonesArray*) man->GetObject("StsHitMatch");
fRichHitMatches = (TClonesArray*) man->GetObject("RichHitMatch");
fTrdHitMatches = (TClonesArray*) man->GetObject("TrdHitMatch");
@@ -178,7 +176,8 @@ void PairAnalysisEvent::SetInput(FairRootManager* man) {
}
//______________________________________________
-void PairAnalysisEvent::Init() {
+void PairAnalysisEvent::Init()
+{
//
// initialization of track arrays
//
@@ -187,82 +186,37 @@ void PairAnalysisEvent::Init() {
// DEBUG stuff
if (0) {
- fprintf(stderr,
- "check %s: has %d points in %p \n",
- "MVD",
- GetNumberOfPoints(ECbmModuleId::kMvd),
+ fprintf(stderr, "check %s: has %d points in %p \n", "MVD", GetNumberOfPoints(ECbmModuleId::kMvd),
GetPoints(ECbmModuleId::kMvd));
- fprintf(stderr,
- "check %s: has %d points in %p \n",
- "STS",
- GetNumberOfPoints(ECbmModuleId::kSts),
+ fprintf(stderr, "check %s: has %d points in %p \n", "STS", GetNumberOfPoints(ECbmModuleId::kSts),
GetPoints(ECbmModuleId::kSts));
- fprintf(stderr,
- "check %s: has %d points in %p \n",
- "RICH",
- GetNumberOfPoints(ECbmModuleId::kRich),
+ fprintf(stderr, "check %s: has %d points in %p \n", "RICH", GetNumberOfPoints(ECbmModuleId::kRich),
GetPoints(ECbmModuleId::kRich));
- fprintf(stderr,
- "check %s: has %d points in %p \n",
- "TRD",
- GetNumberOfPoints(ECbmModuleId::kTrd),
+ fprintf(stderr, "check %s: has %d points in %p \n", "TRD", GetNumberOfPoints(ECbmModuleId::kTrd),
GetPoints(ECbmModuleId::kTrd));
- fprintf(stderr,
- "check %s: has %d points in %p \n",
- "TOF",
- GetNumberOfPoints(ECbmModuleId::kTof),
+ fprintf(stderr, "check %s: has %d points in %p \n", "TOF", GetNumberOfPoints(ECbmModuleId::kTof),
GetPoints(ECbmModuleId::kTof));
- fprintf(stderr,
- "check %s: has %d hitMatches in %p \n",
- "MVD",
- GetNumberOfHitMatches(ECbmModuleId::kMvd),
+ fprintf(stderr, "check %s: has %d hitMatches in %p \n", "MVD", GetNumberOfHitMatches(ECbmModuleId::kMvd),
GetHitMatches(ECbmModuleId::kMvd));
- fprintf(stderr,
- "check %s: has %d hitMatches in %p \n",
- "STS",
- GetNumberOfHitMatches(ECbmModuleId::kSts),
+ fprintf(stderr, "check %s: has %d hitMatches in %p \n", "STS", GetNumberOfHitMatches(ECbmModuleId::kSts),
GetHitMatches(ECbmModuleId::kSts));
- fprintf(stderr,
- "check %s: has %d hitMatches in %p \n",
- "RICH",
- GetNumberOfHitMatches(ECbmModuleId::kRich),
+ fprintf(stderr, "check %s: has %d hitMatches in %p \n", "RICH", GetNumberOfHitMatches(ECbmModuleId::kRich),
GetHitMatches(ECbmModuleId::kRich));
- fprintf(stderr,
- "check %s: has %d hitMatches in %p \n",
- "TRD",
- GetNumberOfHitMatches(ECbmModuleId::kTrd),
+ fprintf(stderr, "check %s: has %d hitMatches in %p \n", "TRD", GetNumberOfHitMatches(ECbmModuleId::kTrd),
GetHitMatches(ECbmModuleId::kTrd));
- fprintf(stderr,
- "check %s: has %d hitMatches in %p \n",
- "TOF",
- GetNumberOfHitMatches(ECbmModuleId::kTof),
+ fprintf(stderr, "check %s: has %d hitMatches in %p \n", "TOF", GetNumberOfHitMatches(ECbmModuleId::kTof),
GetHitMatches(ECbmModuleId::kTof));
- fprintf(stderr,
- "check %s: has %d hits in %p \n",
- "MVD",
- GetNumberOfHits(ECbmModuleId::kMvd),
+ fprintf(stderr, "check %s: has %d hits in %p \n", "MVD", GetNumberOfHits(ECbmModuleId::kMvd),
GetHits(ECbmModuleId::kMvd));
- fprintf(stderr,
- "check %s: has %d hits in %p \n",
- "STS",
- GetNumberOfHits(ECbmModuleId::kSts),
+ fprintf(stderr, "check %s: has %d hits in %p \n", "STS", GetNumberOfHits(ECbmModuleId::kSts),
GetHits(ECbmModuleId::kSts));
- fprintf(stderr,
- "check %s: has %d hits in %p \n",
- "RICH",
- GetNumberOfHits(ECbmModuleId::kRich),
+ fprintf(stderr, "check %s: has %d hits in %p \n", "RICH", GetNumberOfHits(ECbmModuleId::kRich),
GetHits(ECbmModuleId::kRich));
- fprintf(stderr,
- "check %s: has %d hits in %p \n",
- "TRD",
- GetNumberOfHits(ECbmModuleId::kTrd),
+ fprintf(stderr, "check %s: has %d hits in %p \n", "TRD", GetNumberOfHits(ECbmModuleId::kTrd),
GetHits(ECbmModuleId::kTrd));
- fprintf(stderr,
- "check %s: has %d hits in %p \n",
- "TOF",
- GetNumberOfHits(ECbmModuleId::kTof),
+ fprintf(stderr, "check %s: has %d hits in %p \n", "TOF", GetNumberOfHits(ECbmModuleId::kTof),
GetHits(ECbmModuleId::kTof));
}
@@ -270,27 +224,13 @@ void PairAnalysisEvent::Init() {
CbmKFVertex* vtx = 0x0;
if (!fPrimVertex && fMCHeader) {
TMatrixFSym cov(3);
- fPrimVertex = new CbmVertex("mcvtx",
- "mc vtx",
- fMCHeader->GetX(),
- fMCHeader->GetY(),
- fMCHeader->GetZ(),
- 1.0,
- 1,
- fMCHeader->GetNPrim(),
- cov);
- } else if (!fPrimVertex && !fMCHeader) {
+ fPrimVertex = new CbmVertex("mcvtx", "mc vtx", fMCHeader->GetX(), fMCHeader->GetY(), fMCHeader->GetZ(), 1.0, 1,
+ fMCHeader->GetNPrim(), cov);
+ }
+ else if (!fPrimVertex && !fMCHeader) {
TMatrixFSym cov(3);
- fPrimVertex = new CbmVertex("defaultvtx",
- "default vtx",
- 0.,
- 0.,
- 0.,
- 1.0,
- 1,
- TMath::Max(fGlobalTracks->GetEntriesFast(),
- fFastTracks->GetEntriesFast()),
- cov);
+ fPrimVertex = new CbmVertex("defaultvtx", "default vtx", 0., 0., 0., 1.0, 1,
+ TMath::Max(fGlobalTracks->GetEntriesFast(), fFastTracks->GetEntriesFast()), cov);
}
if (fPrimVertex) vtx = new CbmKFVertex(*fPrimVertex);
@@ -298,11 +238,9 @@ void PairAnalysisEvent::Init() {
if (fMCTracks) matches.Set(fMCTracks->GetEntriesFast());
/// loop over all glbl tracks
- for (Int_t i = 0; i < (fGlobalTracks ? fGlobalTracks->GetEntriesFast() : 0);
- i++) {
+ for (Int_t i = 0; i < (fGlobalTracks ? fGlobalTracks->GetEntriesFast() : 0); i++) {
// global track
- CbmGlobalTrack* gtrk =
- static_cast<CbmGlobalTrack*>(fGlobalTracks->UncheckedAt(i));
+ CbmGlobalTrack* gtrk = static_cast<CbmGlobalTrack*>(fGlobalTracks->UncheckedAt(i));
if (!gtrk) continue;
Int_t itrd = gtrk->GetTrdTrackIndex();
@@ -313,89 +251,57 @@ void PairAnalysisEvent::Init() {
// reconstructed tracks
CbmTrdTrack* trdTrack = 0x0;
- if (fTrdTracks && itrd >= 0)
- trdTrack = static_cast<CbmTrdTrack*>(fTrdTracks->At(itrd));
+ if (fTrdTracks && itrd >= 0) trdTrack = static_cast<CbmTrdTrack*>(fTrdTracks->At(itrd));
CbmStsTrack* stsTrack = 0x0;
- if (fStsTracks && ists >= 0)
- stsTrack = static_cast<CbmStsTrack*>(fStsTracks->At(ists));
+ if (fStsTracks && ists >= 0) stsTrack = static_cast<CbmStsTrack*>(fStsTracks->At(ists));
CbmRichRing* richRing = 0x0;
- if (fRichRings && irich >= 0)
- richRing = static_cast<CbmRichRing*>(fRichRings->At(irich));
+ if (fRichRings && irich >= 0) richRing = static_cast<CbmRichRing*>(fRichRings->At(irich));
CbmTofHit* tofHit = 0x0;
- if (fTofHits && itof >= 0)
- tofHit = static_cast<CbmTofHit*>(fTofHits->At(itof));
+ if (fTofHits && itof >= 0) tofHit = static_cast<CbmTofHit*>(fTofHits->At(itof));
CbmMuchTrack* muchTrack = 0x0;
- if (fMuchTracks && imuch >= 0)
- muchTrack = static_cast<CbmMuchTrack*>(fMuchTracks->At(imuch));
+ if (fMuchTracks && imuch >= 0) muchTrack = static_cast<CbmMuchTrack*>(fMuchTracks->At(imuch));
// track and TOFhit matches
CbmTrackMatchNew* stsMatch = 0x0;
- if (fStsMatches && stsTrack)
- stsMatch = static_cast<CbmTrackMatchNew*>(fStsMatches->At(ists));
- Int_t istsMC = (stsMatch && stsMatch->GetNofHits() > 0
- ? stsMatch->GetMatchedLink().GetIndex()
- : -1);
+ if (fStsMatches && stsTrack) stsMatch = static_cast<CbmTrackMatchNew*>(fStsMatches->At(ists));
+ Int_t istsMC = (stsMatch && stsMatch->GetNofHits() > 0 ? stsMatch->GetMatchedLink().GetIndex() : -1);
CbmTrackMatchNew* muchMatch = 0x0;
- if (fMuchMatches && muchTrack)
- muchMatch = static_cast<CbmTrackMatchNew*>(fMuchMatches->At(imuch));
- Int_t imuchMC = (muchMatch && muchMatch->GetNofHits() > 0
- ? muchMatch->GetMatchedLink().GetIndex()
- : -1);
+ if (fMuchMatches && muchTrack) muchMatch = static_cast<CbmTrackMatchNew*>(fMuchMatches->At(imuch));
+ Int_t imuchMC = (muchMatch && muchMatch->GetNofHits() > 0 ? muchMatch->GetMatchedLink().GetIndex() : -1);
CbmTrackMatchNew* trdMatch = 0x0;
- if (fTrdMatches && trdTrack)
- trdMatch = static_cast<CbmTrackMatchNew*>(fTrdMatches->At(itrd));
- Int_t itrdMC = (trdMatch ? trdMatch->GetMatchedLink().GetIndex() : -1);
+ if (fTrdMatches && trdTrack) trdMatch = static_cast<CbmTrackMatchNew*>(fTrdMatches->At(itrd));
+ Int_t itrdMC = (trdMatch ? trdMatch->GetMatchedLink().GetIndex() : -1);
CbmTrackMatchNew* richMatch = 0x0;
- if (fRichMatches && richRing)
- richMatch = static_cast<CbmTrackMatchNew*>(fRichMatches->At(irich));
- Int_t irichMC = (richMatch && richMatch->GetNofHits() > 0
- ? richMatch->GetMatchedLink().GetIndex()
- : -1);
+ if (fRichMatches && richRing) richMatch = static_cast<CbmTrackMatchNew*>(fRichMatches->At(irich));
+ Int_t irichMC = (richMatch && richMatch->GetNofHits() > 0 ? richMatch->GetMatchedLink().GetIndex() : -1);
CbmMatch* tofMatch = 0x0;
if (fTofHitMatches && tofHit)
- tofMatch = static_cast<CbmMatch*>(
- fTofHitMatches->At(itof)); //tofMatch = tofHit->GetMatch();
+ tofMatch = static_cast<CbmMatch*>(fTofHitMatches->At(itof)); //tofMatch = tofHit->GetMatch();
FairMCPoint* tofPoint = 0x0;
if (tofMatch && tofMatch->GetNofLinks() > 0)
- tofPoint = static_cast<FairMCPoint*>(
- fTofPoints->At(tofMatch->GetMatchedLink().GetIndex()));
+ tofPoint = static_cast<FairMCPoint*>(fTofPoints->At(tofMatch->GetMatchedLink().GetIndex()));
Int_t itofMC = (tofPoint ? tofPoint->GetTrackID() : -1);
Int_t imvdMC = GetMvdMatchingIndex(stsTrack);
// rich projection
FairTrackParam* richProj = 0x0;
- if (fRichProjection)
- richProj = static_cast<FairTrackParam*>(fRichProjection->At(i));
+ if (fRichProjection) richProj = static_cast<FairTrackParam*>(fRichProjection->At(i));
// monte carlo track based on the STS match!!!
Int_t iMC = istsMC;
CbmMCTrack* mcTrack = 0x0;
- if (fMCTracks && iMC >= 0)
- mcTrack = static_cast<CbmMCTrack*>(fMCTracks->At(iMC));
+ if (fMCTracks && iMC >= 0) mcTrack = static_cast<CbmMCTrack*>(fMCTracks->At(iMC));
// increment position in matching array
if (mcTrack && fMCTracks) matches[iMC]++;
// build papa track
- fTracks->AddAtAndExpand(new PairAnalysisTrack(vtx,
- gtrk,
- stsTrack,
- muchTrack,
- trdTrack,
- richRing,
- tofHit,
- mcTrack,
- stsMatch,
- muchMatch,
- trdMatch,
- richMatch,
- richProj,
- i),
+ fTracks->AddAtAndExpand(new PairAnalysisTrack(vtx, gtrk, stsTrack, muchTrack, trdTrack, richRing, tofHit, mcTrack,
+ stsMatch, muchMatch, trdMatch, richMatch, richProj, i),
i);
// set MC label and matching bits
- PairAnalysisTrack* tr =
- static_cast<PairAnalysisTrack*>(fTracks->UncheckedAt(i));
+ PairAnalysisTrack* tr = static_cast<PairAnalysisTrack*>(fTracks->UncheckedAt(i));
if (iMC < 0) iMC = -999; // STS tracks w/o MC matching
tr->SetLabel(iMC);
// NOTE: sts track matching might include mvd points
@@ -412,8 +318,7 @@ void PairAnalysisEvent::Init() {
if (!fGlobalTracks || !fGlobalTracks->GetEntriesFast()) {
// loop over all fast tracks
- for (Int_t i = 0; i < (fFastTracks ? fFastTracks->GetEntriesFast() : 0);
- i++) {
+ for (Int_t i = 0; i < (fFastTracks ? fFastTracks->GetEntriesFast() : 0); i++) {
// fast(sim) track
TParticle* ftrk = static_cast<TParticle*>(fFastTracks->UncheckedAt(i));
if (!ftrk) continue;
@@ -421,8 +326,7 @@ void PairAnalysisEvent::Init() {
// monte carlo track
Int_t iMC = ftrk->GetFirstMother();
CbmMCTrack* mcTrack = 0x0;
- if (fMCTracks && iMC >= 0)
- mcTrack = static_cast<CbmMCTrack*>(fMCTracks->At(iMC));
+ if (fMCTracks && iMC >= 0) mcTrack = static_cast<CbmMCTrack*>(fMCTracks->At(iMC));
// increment position in matching array
if (mcTrack && fMCTracks) matches[iMC]++;
// build papa track
@@ -436,76 +340,73 @@ void PairAnalysisEvent::Init() {
//______________________________________________
-PairAnalysisTrack* PairAnalysisEvent::GetTrack(UInt_t pos) {
+PairAnalysisTrack* PairAnalysisEvent::GetTrack(UInt_t pos)
+{
//
// intialize the papa track and return it
//
// check intitialisation
- if (fTracks->GetSize() < 0 || UInt_t(fTracks->GetSize()) <= pos
- || !fTracks->UncheckedAt(pos))
- Fatal("PairAnalysisEvent::GetTrack",
- "Event initialisation failed somehow !!!");
+ if (fTracks->GetSize() < 0 || UInt_t(fTracks->GetSize()) <= pos || !fTracks->UncheckedAt(pos))
+ Fatal("PairAnalysisEvent::GetTrack", "Event initialisation failed somehow !!!");
return static_cast<PairAnalysisTrack*>(fTracks->UncheckedAt(pos));
}
//______________________________________________
-Int_t PairAnalysisEvent::GetNumberOfMatches(ECbmModuleId det) const {
+Int_t PairAnalysisEvent::GetNumberOfMatches(ECbmModuleId det) const
+{
//
// number of track matches
//
switch (det) {
- case ECbmModuleId::kSts:
- return (fStsMatches ? fStsMatches->GetEntriesFast() : 0);
- case ECbmModuleId::kMuch:
- return (fMuchMatches ? fMuchMatches->GetEntriesFast() : 0);
- case ECbmModuleId::kTrd:
- return (fTrdMatches ? fTrdMatches->GetEntriesFast() : 0);
- case ECbmModuleId::kRich:
- return (fRichMatches ? fRichMatches->GetEntriesFast() : 0);
+ case ECbmModuleId::kSts: return (fStsMatches ? fStsMatches->GetEntriesFast() : 0);
+ case ECbmModuleId::kMuch: return (fMuchMatches ? fMuchMatches->GetEntriesFast() : 0);
+ case ECbmModuleId::kTrd: return (fTrdMatches ? fTrdMatches->GetEntriesFast() : 0);
+ case ECbmModuleId::kRich: return (fRichMatches ? fRichMatches->GetEntriesFast() : 0);
default: return 0;
}
}
//______________________________________________
-Int_t PairAnalysisEvent::GetNumberOfHitMatches(ECbmModuleId det) const {
+Int_t PairAnalysisEvent::GetNumberOfHitMatches(ECbmModuleId det) const
+{
//
// number of hit matches
//
- if (!GetHitMatches(det)) {
- return 0;
- } else {
+ if (!GetHitMatches(det)) { return 0; }
+ else {
return (GetHitMatches(det)->GetEntriesFast());
}
}
//______________________________________________
-Int_t PairAnalysisEvent::GetNumberOfHits(ECbmModuleId det) const {
+Int_t PairAnalysisEvent::GetNumberOfHits(ECbmModuleId det) const
+{
//
// number of reconstructed hits
//
- if (!GetHits(det)) {
- return 0;
- } else {
+ if (!GetHits(det)) { return 0; }
+ else {
return (GetHits(det)->GetEntriesFast());
}
}
//______________________________________________
-Int_t PairAnalysisEvent::GetNumberOfPoints(ECbmModuleId det) const {
+Int_t PairAnalysisEvent::GetNumberOfPoints(ECbmModuleId det) const
+{
//
// number of reconstructed hits
//
- if (!GetPoints(det)) {
- return 0;
- } else {
+ if (!GetPoints(det)) { return 0; }
+ else {
return (GetPoints(det)->GetEntriesFast());
}
}
//______________________________________________
-TClonesArray* PairAnalysisEvent::GetHits(ECbmModuleId det) const {
+TClonesArray* PairAnalysisEvent::GetHits(ECbmModuleId det) const
+{
//
// get hits array for certain detector
//
@@ -522,7 +423,8 @@ TClonesArray* PairAnalysisEvent::GetHits(ECbmModuleId det) const {
}
//______________________________________________
-TClonesArray* PairAnalysisEvent::GetHitMatches(ECbmModuleId det) const {
+TClonesArray* PairAnalysisEvent::GetHitMatches(ECbmModuleId det) const
+{
//
// get hit matches array for certain detector
//
@@ -539,7 +441,8 @@ TClonesArray* PairAnalysisEvent::GetHitMatches(ECbmModuleId det) const {
}
//______________________________________________
-TClonesArray* PairAnalysisEvent::GetPoints(ECbmModuleId det) const {
+TClonesArray* PairAnalysisEvent::GetPoints(ECbmModuleId det) const
+{
//
// get mc points array for certain detector
//
@@ -555,7 +458,8 @@ TClonesArray* PairAnalysisEvent::GetPoints(ECbmModuleId det) const {
}
//______________________________________________
-TClonesArray* PairAnalysisEvent::GetCluster(ECbmModuleId det) const {
+TClonesArray* PairAnalysisEvent::GetCluster(ECbmModuleId det) const
+{
//
// get cluster array for certain detector
//
@@ -571,7 +475,8 @@ TClonesArray* PairAnalysisEvent::GetCluster(ECbmModuleId det) const {
}
//______________________________________________
-void PairAnalysisEvent::Clear(Option_t* /*opt*/) {
+void PairAnalysisEvent::Clear(Option_t* /*opt*/)
+{
//
// clear arrays
//
@@ -584,7 +489,8 @@ void PairAnalysisEvent::Clear(Option_t* /*opt*/) {
}
//______________________________________________
-Int_t PairAnalysisEvent::GetMvdMatchingIndex(CbmStsTrack* track) const {
+Int_t PairAnalysisEvent::GetMvdMatchingIndex(CbmStsTrack* track) const
+{
//
// calculate the standalone mvd mc matching
//
@@ -595,22 +501,17 @@ Int_t PairAnalysisEvent::GetMvdMatchingIndex(CbmStsTrack* track) const {
Int_t nofMvdHits = track->GetNofMvdHits();
for (Int_t iHit = 0; iHit < nofMvdHits; iHit++) {
- const CbmMatch* hitMatch =
- static_cast<CbmMatch*>(fMvdHitMatches->At(track->GetMvdHitIndex(iHit)));
+ const CbmMatch* hitMatch = static_cast<CbmMatch*>(fMvdHitMatches->At(track->GetMvdHitIndex(iHit)));
if (!hitMatch) continue;
Int_t nofLinks = hitMatch->GetNofLinks();
for (Int_t iLink = 0; iLink < nofLinks; iLink++) {
- const CbmLink& link = hitMatch->GetLink(iLink);
- const FairMCPoint* point =
- static_cast<const FairMCPoint*>(fMvdPoints->At(link.GetIndex()));
+ const CbmLink& link = hitMatch->GetLink(iLink);
+ const FairMCPoint* point = static_cast<const FairMCPoint*>(fMvdPoints->At(link.GetIndex()));
if (NULL == point) continue;
- trackMatch->AddLink(
- CbmLink(1., point->GetTrackID(), link.GetEntry(), link.GetFile()));
+ trackMatch->AddLink(CbmLink(1., point->GetTrackID(), link.GetEntry(), link.GetFile()));
}
}
- if (trackMatch->GetNofLinks()) {
- idx = trackMatch->GetMatchedLink().GetIndex();
- }
+ if (trackMatch->GetNofLinks()) { idx = trackMatch->GetMatchedLink().GetIndex(); }
//delete surplus stuff
delete trackMatch;
diff --git a/analysis/PWGDIL/dielectron/papaframework/PairAnalysisEvent.h b/analysis/PWGDIL/dielectron/papaframework/PairAnalysisEvent.h
index 4b609120651fd837529e4f723c2de68a3d2e5df0..4f27a508fd20bd9f7fae565509a4f93183d3dfae 100644
--- a/analysis/PWGDIL/dielectron/papaframework/PairAnalysisEvent.h
+++ b/analysis/PWGDIL/dielectron/papaframework/PairAnalysisEvent.h
@@ -10,13 +10,13 @@
//# Julian Book, Uni Ffm / Julian.Book@cern.ch #
//# #
//#############################################################
+#include "CbmDefs.h"
+#include "CbmVertex.h"
+
#include <TClonesArray.h>
#include <TNamed.h>
#include <TObjArray.h>
-#include "CbmDefs.h"
-#include "CbmVertex.h"
-
class FairRootManager;
class FairMCEventHeader;
class CbmStsTrack;
@@ -30,19 +30,15 @@ public:
virtual ~PairAnalysisEvent();
void SetInput(FairRootManager* man);
- void SetANNId(Int_t Id) { fANNId=Id; }
+ void SetANNId(Int_t Id) { fANNId = Id; }
void Init();
// getters
FairMCEventHeader* GetMCHeader() const { return fMCHeader; }
CbmVertex* GetPrimaryVertex() const { return fPrimVertex; }
- Int_t GetNumberOfTracks() const {
- return (fTracks ? fTracks->GetEntriesFast() : -1);
- }
- Int_t GetNumberOfMCTracks() const {
- return (fMCTracks ? fMCTracks->GetEntriesFast() : -1);
- }
+ Int_t GetNumberOfTracks() const { return (fTracks ? fTracks->GetEntriesFast() : -1); }
+ Int_t GetNumberOfMCTracks() const { return (fMCTracks ? fMCTracks->GetEntriesFast() : -1); }
Int_t GetNumberOfVageMatches() const { return fMultiMatch; }
Int_t GetNumberOfMatches(ECbmModuleId det) const;
Int_t GetNumberOfHits(ECbmModuleId det) const;
@@ -110,9 +106,9 @@ private:
TObjArray* fTracks; // papa tracks
Int_t fMultiMatch = 0; // number of mutiple matched tracks
- Bool_t fANN=true;
- Int_t fANNId=1;
-
+ Bool_t fANN = true;
+ Int_t fANNId = 1;
+
PairAnalysisEvent(const PairAnalysisEvent& event);
PairAnalysisEvent& operator=(const PairAnalysisEvent& c);
diff --git a/analysis/PWGDIL/dielectron/papaframework/PairAnalysisFunction.cxx b/analysis/PWGDIL/dielectron/papaframework/PairAnalysisFunction.cxx
index 90211da835a924782413e23f2f4078f3bc0f3d83..78f8e941b8c2d02814086f9e0f1f3a7c74f62ceb 100644
--- a/analysis/PWGDIL/dielectron/papaframework/PairAnalysisFunction.cxx
+++ b/analysis/PWGDIL/dielectron/papaframework/PairAnalysisFunction.cxx
@@ -57,16 +57,16 @@ ClassImp(PairAnalysisFunction)
TH1F* PairAnalysisFunction::fgHistSimPM = 0x0;
-PairAnalysisFunction::PairAnalysisFunction()
- : PairAnalysisFunction("PairAnalysisFunction", "fcttitle") {
+PairAnalysisFunction::PairAnalysisFunction() : PairAnalysisFunction("PairAnalysisFunction", "fcttitle")
+{
//
// Default Constructor
//
}
//______________________________________________
-PairAnalysisFunction::PairAnalysisFunction(const char* name, const char* title)
- : TNamed(name, title) {
+PairAnalysisFunction::PairAnalysisFunction(const char* name, const char* title) : TNamed(name, title)
+{
//
// Named Constructor
//
@@ -77,7 +77,8 @@ PairAnalysisFunction::PairAnalysisFunction(const PairAnalysisFunction& c)
: TNamed(c.GetName(), c.GetTitle())
, fFitMin(c.GetFitMin())
, fFitMax(c.GetFitMax())
- , fPOIpdg(c.GetParticleOfInterest()) {
+ , fPOIpdg(c.GetParticleOfInterest())
+{
//
// Copy Constructor
//
@@ -85,7 +86,8 @@ PairAnalysisFunction::PairAnalysisFunction(const PairAnalysisFunction& c)
//______________________________________________
-PairAnalysisFunction::~PairAnalysisFunction() {
+PairAnalysisFunction::~PairAnalysisFunction()
+{
//
// Default Destructor
//
@@ -96,8 +98,8 @@ PairAnalysisFunction::~PairAnalysisFunction() {
//______________________________________________________________________________
-Double_t PairAnalysisFunction::PeakFunMC(const Double_t* x,
- const Double_t* par) {
+Double_t PairAnalysisFunction::PeakFunMC(const Double_t* x, const Double_t* par)
+{
// Fit MC signal shape
// parameters
// [0]: scale for simpeak
@@ -106,8 +108,7 @@ Double_t PairAnalysisFunction::PeakFunMC(const Double_t* x,
TH1F* hPeak = fgHistSimPM;
if (!hPeak) {
- printf(
- "E-PairAnalysisFunction::PeakFun: No histogram for peak fit defined!\n");
+ printf("E-PairAnalysisFunction::PeakFun: No histogram for peak fit defined!\n");
return 0.0;
}
@@ -118,8 +119,8 @@ Double_t PairAnalysisFunction::PeakFunMC(const Double_t* x,
}
//______________________________________________________________________________
-Double_t PairAnalysisFunction::PeakFunCB(const Double_t* x,
- const Double_t* par) {
+Double_t PairAnalysisFunction::PeakFunCB(const Double_t* x, const Double_t* par)
+{
// Crystal Ball fit function
Double_t n = par[0];
@@ -128,8 +129,7 @@ Double_t PairAnalysisFunction::PeakFunCB(const Double_t* x,
Double_t sigma = par[3];
Double_t nn = par[4];
- Double_t a =
- TMath::Power((n / TMath::Abs(alpha)), n) * TMath::Exp(-.5 * alpha * alpha);
+ Double_t a = TMath::Power((n / TMath::Abs(alpha)), n) * TMath::Exp(-.5 * alpha * alpha);
Double_t b = n / TMath::Abs(alpha) - TMath::Abs(alpha);
Double_t arg = (x[0] - meanx) / sigma;
@@ -137,7 +137,8 @@ Double_t PairAnalysisFunction::PeakFunCB(const Double_t* x,
if (arg > -1. * alpha) {
fitval = nn * TMath::Exp(-.5 * arg * arg); //gaussian part
- } else {
+ }
+ else {
fitval = nn * a * TMath::Power((b - arg), (-1 * n));
}
@@ -145,8 +146,8 @@ Double_t PairAnalysisFunction::PeakFunCB(const Double_t* x,
}
//______________________________________________________________________________
-Double_t PairAnalysisFunction::PeakFunPowGaussPow(const Double_t* x,
- const Double_t* par) {
+Double_t PairAnalysisFunction::PeakFunPowGaussPow(const Double_t* x, const Double_t* par)
+{
// PowGaussPow function fit function (both sided Crystall Ball)
Double_t n = par[0];
@@ -155,18 +156,17 @@ Double_t PairAnalysisFunction::PeakFunPowGaussPow(const Double_t* x,
Double_t meanx = par[2];
Double_t sigma = par[3];
- Double_t a =
- TMath::Power((n / TMath::Abs(alpha)), n) * TMath::Exp(-.5 * alpha * alpha);
+ Double_t a = TMath::Power((n / TMath::Abs(alpha)), n) * TMath::Exp(-.5 * alpha * alpha);
Double_t b = n / TMath::Abs(alpha) - TMath::Abs(alpha);
Double_t arg = (x[0] - meanx) / sigma;
Double_t fitval = 0;
- if (arg > alpha) {
- fitval = nn * a * TMath::Power((b + arg), (-1 * n));
- } else if (arg < -alpha) {
+ if (arg > alpha) { fitval = nn * a * TMath::Power((b + arg), (-1 * n)); }
+ else if (arg < -alpha) {
fitval = nn * a * TMath::Power((b - arg), (-1 * n));
- } else {
+ }
+ else {
fitval = nn * TMath::Exp(-0.5 * arg * arg); //gaussian part
}
@@ -174,8 +174,8 @@ Double_t PairAnalysisFunction::PeakFunPowGaussPow(const Double_t* x,
}
//______________________________________________________________________________
-Double_t PairAnalysisFunction::PeakFunExpGaussExp(const Double_t* x,
- const Double_t* par) {
+Double_t PairAnalysisFunction::PeakFunExpGaussExp(const Double_t* x, const Double_t* par)
+{
// ExpGaussExp function fit function
Double_t n = par[0];
@@ -187,11 +187,11 @@ Double_t PairAnalysisFunction::PeakFunExpGaussExp(const Double_t* x,
Double_t arg = (x[0] - meanx) / sigma;
Double_t fitval = 0;
- if (arg > alpha) {
- fitval = n * TMath::Exp(-0.5 * alpha * alpha - alpha * arg);
- } else if (arg < -alpha) {
+ if (arg > alpha) { fitval = n * TMath::Exp(-0.5 * alpha * alpha - alpha * arg); }
+ else if (arg < -alpha) {
fitval = n * TMath::Exp(-0.5 * alpha * alpha + alpha * arg);
- } else {
+ }
+ else {
fitval = n * TMath::Exp(-0.5 * arg * arg); //gaussian part
}
@@ -199,8 +199,8 @@ Double_t PairAnalysisFunction::PeakFunExpGaussExp(const Double_t* x,
}
//______________________________________________________________________________
-Double_t PairAnalysisFunction::PeakFunGauss(const Double_t* x,
- const Double_t* par) {
+Double_t PairAnalysisFunction::PeakFunGauss(const Double_t* x, const Double_t* par)
+{
// Gaussian fit function
//printf("fNparBgrd %d \n",fNparBgnd);
@@ -213,11 +213,8 @@ Double_t PairAnalysisFunction::PeakFunGauss(const Double_t* x,
}
//______________________________________________
-void PairAnalysisFunction::SetFunctions(TF1* const combined,
- TF1* const sig,
- TF1* const back,
- Int_t parM,
- Int_t parMres) {
+void PairAnalysisFunction::SetFunctions(TF1* const combined, TF1* const sig, TF1* const back, Int_t parM, Int_t parMres)
+{
//
// Set the signal, background functions and combined fit function
// Note: The process method assumes that the first n parameters in the
@@ -225,8 +222,7 @@ void PairAnalysisFunction::SetFunctions(TF1* const combined,
// and the n+1 to n+m parameters to the m parameters of the background function!!!
if (!sig || !back || !combined) {
- Error("SetFunctions",
- "Both, signal and background function need to be set!");
+ Error("SetFunctions", "Both, signal and background function need to be set!");
return;
}
fFuncSignal = sig;
@@ -237,7 +233,8 @@ void PairAnalysisFunction::SetFunctions(TF1* const combined,
}
//______________________________________________
-void PairAnalysisFunction::SetDefault(EFunction predefinedFunc) {
+void PairAnalysisFunction::SetDefault(EFunction predefinedFunc)
+{
///
/// use a predefined function, that internally sets the "fFuncSigBack"
///
@@ -251,7 +248,8 @@ void PairAnalysisFunction::SetDefault(EFunction predefinedFunc) {
}
//______________________________________________
-void PairAnalysisFunction::SetDefaults(Int_t type) {
+void PairAnalysisFunction::SetDefaults(Int_t type)
+{
//
// Setup some default functions:
// type = 0: gaus signal + linear background in 2.5 - 4 GeV inv. mass
@@ -271,35 +269,31 @@ void PairAnalysisFunction::SetDefaults(Int_t type) {
fFuncSigBack->SetParLimits(0, 0, 10000000);
fFuncSigBack->SetParLimits(1, 3.05, 3.15);
fFuncSigBack->SetParLimits(2, .02, .1);
- } else if (type == 1) {
- fFuncSignal = new TF1("DieleSignal", "gaus", 2.5, 4);
- fFuncBackground =
- new TF1("DieleBackground", "[0]*exp(-(x-[1])/[2])", 2.5, 4);
- fFuncSigBack =
- new TF1("DieleCombined", "gaus+[3]*exp(-(x-[4])/[5])", 2.5, 4);
+ }
+ else if (type == 1) {
+ fFuncSignal = new TF1("DieleSignal", "gaus", 2.5, 4);
+ fFuncBackground = new TF1("DieleBackground", "[0]*exp(-(x-[1])/[2])", 2.5, 4);
+ fFuncSigBack = new TF1("DieleCombined", "gaus+[3]*exp(-(x-[4])/[5])", 2.5, 4);
fFuncSigBack->SetParameters(1, 3.1, .05, 1, 2.5, 1);
fFuncSigBack->SetParLimits(0, 0, 10000000);
fFuncSigBack->SetParLimits(1, 3.05, 3.15);
fFuncSigBack->SetParLimits(2, .02, .1);
- } else if (type == 2) {
+ }
+ else if (type == 2) {
// half gaussian, half exponential signal function
// exponential background
- fFuncSignal = new TF1("DieleSignal",
+ fFuncSignal = new TF1("DieleSignal",
"(x<[1])*([0]*(exp(-0.5*((x-[1])/[2])^2)+exp((x-[1])/"
"[3])*(1-exp(-0.5*((x-[1])/"
"[2])^2))))+(x>=[1])*([0]*exp(-0.5*((x-[1])/[2])^2))",
- 2.5,
- 4);
- fFuncBackground =
- new TF1("DieleBackground", "[0]*exp(-(x-[1])/[2])+[3]", 2.5, 4);
- fFuncSigBack = new TF1(
- "DieleCombined",
- "(x<[1])*([0]*(exp(-0.5*((x-[1])/[2])^2)+exp((x-[1])/"
- "[3])*(1-exp(-0.5*((x-[1])/[2])^2))))+(x>=[1])*([0]*exp(-0.5*((x-[1])/"
- "[2])^2))+[4]*exp(-(x-[5])/[6])+[7]",
- 2.5,
- 4);
+ 2.5, 4);
+ fFuncBackground = new TF1("DieleBackground", "[0]*exp(-(x-[1])/[2])+[3]", 2.5, 4);
+ fFuncSigBack = new TF1("DieleCombined",
+ "(x<[1])*([0]*(exp(-0.5*((x-[1])/[2])^2)+exp((x-[1])/"
+ "[3])*(1-exp(-0.5*((x-[1])/[2])^2))))+(x>=[1])*([0]*exp(-0.5*((x-[1])/"
+ "[2])^2))+[4]*exp(-(x-[5])/[6])+[7]",
+ 2.5, 4);
fFuncSigBack->SetParameters(1., 3.1, .05, .1, 1, 2.5, 1, 0);
fFuncSigBack->SetParLimits(0, 0, 10000000);
@@ -311,7 +305,8 @@ void PairAnalysisFunction::SetDefaults(Int_t type) {
}
//______________________________________________________________________________
-void PairAnalysisFunction::CombineFunc(TF1* const peak, TF1* const bgnd) {
+void PairAnalysisFunction::CombineFunc(TF1* const peak, TF1* const bgnd)
+{
//
// combine the bgnd and the peak function
//
@@ -326,24 +321,17 @@ void PairAnalysisFunction::CombineFunc(TF1* const peak, TF1* const bgnd) {
fNparPeak = fFuncSignal->GetNpar();
fNparBgnd = (bgnd ? fFuncBackground->GetNpar() : 0);
- fFuncSigBack = new TF1("BgndPeak",
- this,
- &PairAnalysisFunction::PeakBgndFun,
- fFitMin,
- fFitMax,
- fNparPeak + fNparBgnd);
+ fFuncSigBack = new TF1("BgndPeak", this, &PairAnalysisFunction::PeakBgndFun, fFitMin, fFitMax, fNparPeak + fNparBgnd);
return;
}
//______________________________________________________________________________
-Double_t PairAnalysisFunction::PeakBgndFun(const Double_t* x,
- const Double_t* par) {
+Double_t PairAnalysisFunction::PeakBgndFun(const Double_t* x, const Double_t* par)
+{
//
// merge peak and bgnd functions
//
- return (
- fFuncSignal->EvalPar(x, par)
- + (fFuncBackground ? fFuncBackground->EvalPar(x, par + fNparPeak) : 0.));
+ return (fFuncSignal->EvalPar(x, par) + (fFuncBackground ? fFuncBackground->EvalPar(x, par + fNparPeak) : 0.));
}
//______________________________________________
@@ -358,12 +346,10 @@ Double_t PairAnalysisFunction::PeakBgndFun(const Double_t* x,
//______________________________________________
-TF1* PairAnalysisFunction::GetBoltzmann() {
+TF1* PairAnalysisFunction::GetBoltzmann()
+{
// Boltzmann (exp in 1/mt*dNdmT times mt) as a function of dNdpt
- fFuncSigBack = new TF1("Boltzmann",
- "[1]*x*sqrt(x*x+[0]*[0])*exp(-sqrt(x*x+[0]*[0])/[2])",
- 0.,
- 10.);
+ fFuncSigBack = new TF1("Boltzmann", "[1]*x*sqrt(x*x+[0]*[0])*exp(-sqrt(x*x+[0]*[0])/[2])", 0., 10.);
// fFuncSigBack->SetParameters(fPOI->Mass(), norm, temp);
if (fPOI) fFuncSigBack->FixParameter(0, fPOI->Mass());
fFuncSigBack->SetParLimits(2, 0.01, 10);
@@ -372,7 +358,8 @@ TF1* PairAnalysisFunction::GetBoltzmann() {
}
//______________________________________________
-TF1* PairAnalysisFunction::GetPtExp() {
+TF1* PairAnalysisFunction::GetPtExp()
+{
// Simple exponential in 1/pt*dNdpT, as a function of dNdpt
fFuncSigBack = new TF1("Exponential", "[0]*x*exp(-x/[1])", 0., 10.);
// fFuncSigBack->SetParameters(norm, temp);
@@ -382,7 +369,8 @@ TF1* PairAnalysisFunction::GetPtExp() {
}
//______________________________________________
-TF1* PairAnalysisFunction::GetHagedorn() {
+TF1* PairAnalysisFunction::GetHagedorn()
+{
// PowerLaw function, dNdpt
// power law Nuclear Physics B, Vol. 335, No. 2. (7 May 1990), pp. 261-287.
// This is sometimes also called Hagedorn or modified Hagedorn
@@ -395,14 +383,13 @@ TF1* PairAnalysisFunction::GetHagedorn() {
}
//______________________________________________
-TF1* PairAnalysisFunction::GetLevi() {
+TF1* PairAnalysisFunction::GetLevi()
+{
// Levi function (aka Tsallis), dNdpt
- fFuncSigBack =
- new TF1("Levi-Tsallis",
- "( x*[0]*([1]-1)*([1]-2) )/( [1]*[2]*( [1]*[2]+[3]*([1]-2) ) ) * "
- "( 1 + (sqrt([3]*[3]+x*x) -[3])/([1]*[2]) )^(-[1])",
- 0.,
- 10.);
+ fFuncSigBack = new TF1("Levi-Tsallis",
+ "( x*[0]*([1]-1)*([1]-2) )/( [1]*[2]*( [1]*[2]+[3]*([1]-2) ) ) * "
+ "( 1 + (sqrt([3]*[3]+x*x) -[3])/([1]*[2]) )^(-[1])",
+ 0., 10.);
// fFuncSigBack->SetParameters(norm, n, temp,mass);
if (fPOI) fFuncSigBack->FixParameter(3, fPOI->Mass());
fFuncSigBack->SetParLimits(2, 0.01, 10);
diff --git a/analysis/PWGDIL/dielectron/papaframework/PairAnalysisFunction.h b/analysis/PWGDIL/dielectron/papaframework/PairAnalysisFunction.h
index 7d6e70fb0cc02ed9681a20af563edb65527578ad..d0b15995a553e0bea72e57c7d7297fcc619da04e 100644
--- a/analysis/PWGDIL/dielectron/papaframework/PairAnalysisFunction.h
+++ b/analysis/PWGDIL/dielectron/papaframework/PairAnalysisFunction.h
@@ -22,7 +22,13 @@
class PairAnalysisFunction : public TNamed {
public:
- enum class EFunction { kBoltzmann = 0, kPtExp, kHagedorn, kLevi };
+ enum class EFunction
+ {
+ kBoltzmann = 0,
+ kPtExp,
+ kHagedorn,
+ kLevi
+ };
PairAnalysisFunction();
PairAnalysisFunction(const char* name, const char* title);
@@ -34,27 +40,26 @@ public:
// virtual void Fit(Option_t *opt);
// Setter
- void SetParticleOfInterest(Int_t pdgcode) {
+ void SetParticleOfInterest(Int_t pdgcode)
+ {
fPOIpdg = pdgcode;
fPOI = TDatabasePDG::Instance()->GetParticle(fPOIpdg);
}
- void SetFitRange(Double_t min, Double_t max) {
+ void SetFitRange(Double_t min, Double_t max)
+ {
fFitMin = min;
fFitMax = max;
}
void SetUseIntegral(Bool_t flag = kTRUE) { fUseIntegral = flag; }
- void SetFitOption(const char* opt) {
+ void SetFitOption(const char* opt)
+ {
fFitOpt = opt;
fFitOpt.ToLower();
if (!fFitOpt.Contains("s")) fFitOpt += "s";
}
void SetMCSignalShape(TH1F* hist) { fgHistSimPM = hist; }
- void SetFunctions(TF1* const combined,
- TF1* const sig = 0,
- TF1* const back = 0,
- Int_t parM = 1,
- Int_t parMres = 2);
+ void SetFunctions(TF1* const combined, TF1* const sig = 0, TF1* const back = 0, Int_t parM = 1, Int_t parMres = 2);
void SetDefault(EFunction predefinedFunc);
void SetDefaults(Int_t type);
@@ -64,7 +69,7 @@ public:
Double_t PeakFunMC(const Double_t* x,
const Double_t* par); // peak function from a mc histo
Double_t PeakFunCB(const Double_t* x,
- const Double_t* par); // crystal ball function
+ const Double_t* par); // crystal ball function
Double_t PeakFunGauss(const Double_t* x, const Double_t* par); // gaussian
Double_t PeakFunPowGaussPow(const Double_t* x,
const Double_t* par); // pow gaussian pow
@@ -95,9 +100,8 @@ public:
protected:
static TH1F* fgHistSimPM; // simulated peak shape
- Double_t
- PeakBgndFun(const Double_t* x,
- const Double_t* par); // combine any bgrd and any peak function
+ Double_t PeakBgndFun(const Double_t* x,
+ const Double_t* par); // combine any bgrd and any peak function
TF1* fFuncSignal = NULL; // Function for the signal description
TF1* fFuncBackground = NULL; // Function for the background description
@@ -106,16 +110,13 @@ protected:
Double_t fFitMin = 0.; // fit range lowest inv. mass
Double_t fFitMax = 0.; // fit range highest inv. mass
- TParticlePDG* fPOI = NULL; // MC particle of interest
- Int_t fPOIpdg = 443; // pdg code particle of interest
- Int_t fParMass =
- 1; // the index of the parameter corresponding to the resonance mass
- Int_t fParMassWidth =
- 2; // the index of the parameter corresponding to the resonance mass width
+ TParticlePDG* fPOI = NULL; // MC particle of interest
+ Int_t fPOIpdg = 443; // pdg code particle of interest
+ Int_t fParMass = 1; // the index of the parameter corresponding to the resonance mass
+ Int_t fParMassWidth = 2; // the index of the parameter corresponding to the resonance mass width
- TString fFitOpt = "SMNQE"; // fit option used
- Bool_t fUseIntegral =
- kFALSE; // use the integral of the fitted functions to extract signal and background
+ TString fFitOpt = "SMNQE"; // fit option used
+ Bool_t fUseIntegral = kFALSE; // use the integral of the fitted functions to extract signal and background
Int_t fDof = 0; // degrees of freedom
Double_t fChi2Dof = 0.; // chi2/dof of the fitted inv mass spectra
diff --git a/analysis/PWGDIL/dielectron/papaframework/PairAnalysisHF.cxx b/analysis/PWGDIL/dielectron/papaframework/PairAnalysisHF.cxx
index 8af8fb923dd98ba72ce4d7824193f1262f35a644..eca6af9f329939b549489fb3026f4604e77d77cb 100644
--- a/analysis/PWGDIL/dielectron/papaframework/PairAnalysisHF.cxx
+++ b/analysis/PWGDIL/dielectron/papaframework/PairAnalysisHF.cxx
@@ -14,6 +14,10 @@ Detailed description
// //
///////////////////////////////////////////////////////////////////////////
+#include "PairAnalysisHF.h"
+
+#include "CbmMCTrack.h"
+
#include <TAxis.h>
#include <TFile.h>
#include <TH1.h>
@@ -30,18 +34,13 @@ Detailed description
#include <TString.h>
#include <TVectorD.h>
-#include "CbmMCTrack.h"
-
#include "PairAnalysis.h"
#include "PairAnalysisHelper.h"
+#include "PairAnalysisHistos.h"
#include "PairAnalysisMC.h"
#include "PairAnalysisPair.h"
#include "PairAnalysisSignalMC.h"
#include "PairAnalysisStyler.h"
-
-#include "PairAnalysisHF.h"
-#include "PairAnalysisHistos.h"
-
#include "PairAnalysisTrack.h"
ClassImp(PairAnalysisHF)
@@ -53,7 +52,8 @@ ClassImp(PairAnalysisHF)
, fArrDielHistos()
, fSignalsMC(0x0)
, fVarCutType(new TBits(fMaxCuts))
- , fAxes(fMaxCuts) {
+ , fAxes(fMaxCuts)
+{
//
// Default Constructor
//
@@ -73,7 +73,8 @@ PairAnalysisHF::PairAnalysisHF(const char* name, const char* title)
, fArrDielHistos()
, fSignalsMC(0x0)
, fVarCutType(new TBits(fMaxCuts))
- , fAxes(fMaxCuts) {
+ , fAxes(fMaxCuts)
+{
//
// Named Constructor
//
@@ -86,7 +87,8 @@ PairAnalysisHF::PairAnalysisHF(const char* name, const char* title)
}
//______________________________________________
-PairAnalysisHF::~PairAnalysisHF() {
+PairAnalysisHF::~PairAnalysisHF()
+{
//
// Default Destructor
//
@@ -97,9 +99,8 @@ PairAnalysisHF::~PairAnalysisHF() {
}
//________________________________________________________________
-void PairAnalysisHF::AddCutVariable(PairAnalysisVarManager::ValueTypes type,
- TVectorD* binLimits,
- Bool_t leg) {
+void PairAnalysisHF::AddCutVariable(PairAnalysisVarManager::ValueTypes type, TVectorD* binLimits, Bool_t leg)
+{
//
// Add a variable to the histogram array with a vector
// the TVectorD is assumed to be surplus after the creation and will be deleted!!!
@@ -119,7 +120,8 @@ void PairAnalysisHF::AddCutVariable(PairAnalysisVarManager::ValueTypes type,
}
//_____________________________________________________________________________
-void PairAnalysisHF::FillClass(const char* histClass, const Double_t* values) {
+void PairAnalysisHF::FillClass(const char* histClass, const Double_t* values)
+{
//
// Fill the histograms if cuts are passed
//
@@ -131,15 +133,13 @@ void PairAnalysisHF::FillClass(const char* histClass, const Double_t* values) {
// printf(" --> %s \n",fArrDielHistos.UncheckedAt(cell)->GetName());
// do NOT set the ownership otherwise you will delete all histos!!
- SetHistogramList(*static_cast<THashList*>(fArrDielHistos.UncheckedAt(cell)),
- kFALSE);
+ SetHistogramList(*static_cast<THashList*>(fArrDielHistos.UncheckedAt(cell)), kFALSE);
PairAnalysisHistos::FillClass(histClass, values);
}
//______________________________________________
-void PairAnalysisHF::ReadFromFile(const char* file,
- const char* task,
- const char* config) {
+void PairAnalysisHF::ReadFromFile(const char* file, const char* task, const char* config)
+{
//
// Read histos from file
//
@@ -155,8 +155,7 @@ void PairAnalysisHF::ReadFromFile(const char* file,
TList* list = dynamic_cast<TList*>(o);
if (!list) continue;
//////NEEDED? else fList=list;
- TObjArray* listCfg =
- dynamic_cast<TObjArray*>(list->FindObject(Form("%s_HF", config)));
+ TObjArray* listCfg = dynamic_cast<TObjArray*>(list->FindObject(Form("%s_HF", config)));
if (!listCfg) continue;
//// SetHistogramList(*listCfg);
break;
@@ -167,9 +166,8 @@ void PairAnalysisHF::ReadFromFile(const char* file,
}
//______________________________________________
-void PairAnalysisHF::Fill(Int_t /*label1*/,
- Int_t /*label2*/,
- Int_t /*nSignal*/) {
+void PairAnalysisHF::Fill(Int_t /*label1*/, Int_t /*label2*/, Int_t /*nSignal*/)
+{
return; //TODO: OBSOLETE?
/*
//
@@ -217,8 +215,8 @@ void PairAnalysisHF::Fill(Int_t /*label1*/,
*/
}
//______________________________________________
-void PairAnalysisHF::Fill(Int_t /*pairIndex*/,
- const PairAnalysisPair* /*particle*/) {
+void PairAnalysisHF::Fill(Int_t /*pairIndex*/, const PairAnalysisPair* /*particle*/)
+{
//
// fill histograms for event, pair and daughter cuts and pair types
//
@@ -268,10 +266,9 @@ void PairAnalysisHF::Fill(Int_t /*pairIndex*/,
}
//______________________________________________
-void PairAnalysisHF::Fill(Int_t /*index*/,
- Double_t* const /*valuesPair*/,
- Double_t* const /*valuesLeg1*/,
- Double_t* const /*valuesLeg2*/) {
+void PairAnalysisHF::Fill(Int_t /*index*/, Double_t* const /*valuesPair*/, Double_t* const /*valuesLeg1*/,
+ Double_t* const /*valuesLeg2*/)
+{
//
// main fill function using index and values as input
//
@@ -342,7 +339,8 @@ void PairAnalysisHF::Fill(Int_t /*index*/,
}
//______________________________________________
-void PairAnalysisHF::Init() {
+void PairAnalysisHF::Init()
+{
//
// initialise the HF array
//
@@ -381,16 +379,13 @@ void PairAnalysisHF::Init() {
// modify title of hashlist
TString title = fArrDielHistos.UncheckedAt(icell)->GetName();
- if (!ivar)
- title = "";
+ if (!ivar) title = "";
else
- title += ":"; // delimiter for new variable
- if (fVarCutType->TestBitNumber(ivar))
- title += "Leg"; // for leg variable Identification
+ title += ":"; // delimiter for new variable
+ if (fVarCutType->TestBitNumber(ivar)) title += "Leg"; // for leg variable Identification
title += PairAnalysisVarManager::GetValueName(fVarCuts[ivar]);
title += Form("#%.2f#%.2f", lowEdge, upEdge); // TODO: precision enough?
- static_cast<THashList*>(fArrDielHistos.UncheckedAt(icell))
- ->SetName(title.Data());
+ static_cast<THashList*>(fArrDielHistos.UncheckedAt(icell))->SetName(title.Data());
/// Debug(10,title.Data());
} // end: array of cells
@@ -407,7 +402,8 @@ void PairAnalysisHF::Init() {
}
//______________________________________________
-Int_t PairAnalysisHF::GetNumberOfBins() const {
+Int_t PairAnalysisHF::GetNumberOfBins() const
+{
//
// return the number of bins this histogram grid has
//
@@ -418,7 +414,8 @@ Int_t PairAnalysisHF::GetNumberOfBins() const {
}
//______________________________________________
-Int_t PairAnalysisHF::FindCell(const Double_t* values) {
+Int_t PairAnalysisHF::FindCell(const Double_t* values)
+{
//
// cell described by 'values'
// if the values are outside the binning range -1 is returned
diff --git a/analysis/PWGDIL/dielectron/papaframework/PairAnalysisHF.h b/analysis/PWGDIL/dielectron/papaframework/PairAnalysisHF.h
index 06a7dabfbd293d4cb5f573c011c576ec57acdced..2ac304284a1fcba68dfc4bfdf385d036b9865753 100644
--- a/analysis/PWGDIL/dielectron/papaframework/PairAnalysisHF.h
+++ b/analysis/PWGDIL/dielectron/papaframework/PairAnalysisHF.h
@@ -23,7 +23,10 @@
class PairAnalysisHF : public PairAnalysisHistos {
public:
- enum class Max { kMaxCuts = 20 };
+ enum class Max
+ {
+ kMaxCuts = 20
+ };
PairAnalysisHF();
PairAnalysisHF(const char* name, const char* title);
@@ -35,9 +38,7 @@ public:
const TObjArray* GetHistArray() const { return &fArrDielHistos; }
// functions to define the grid
- void AddCutVariable(PairAnalysisVarManager::ValueTypes type,
- TVectorD* binLimits,
- Bool_t leg = kFALSE);
+ void AddCutVariable(PairAnalysisVarManager::ValueTypes type, TVectorD* binLimits, Bool_t leg = kFALSE);
// functions to fill objects
Int_t FindCell(const Double_t* values);
@@ -45,15 +46,10 @@ public:
// TODO: check, remove, implement
void Fill(Int_t pairIndex, const PairAnalysisPair* particle);
void Fill(Int_t label1, Int_t label2, Int_t nSignal);
- void Fill(Int_t Index,
- Double_t* const valuesPair,
- Double_t* const valuesLeg1,
- Double_t* const valuesLeg2);
+ void Fill(Int_t Index, Double_t* const valuesPair, Double_t* const valuesLeg1, Double_t* const valuesLeg2);
// functions to get and draw histograms
- void ReadFromFile(const char* file = "histos.root",
- const char* task = "",
- const char* config = "");
+ void ReadFromFile(const char* file = "histos.root", const char* task = "", const char* config = "");
private:
TBits* fUsedVars; // list of used variables
diff --git a/analysis/PWGDIL/dielectron/papaframework/PairAnalysisHelper.cxx b/analysis/PWGDIL/dielectron/papaframework/PairAnalysisHelper.cxx
index 72af82bbfc80bfb5d64c793d6e1bd9ed099fd52d..b6ccd166bf1359dd5f34e591fc69674273877923 100644
--- a/analysis/PWGDIL/dielectron/papaframework/PairAnalysisHelper.cxx
+++ b/analysis/PWGDIL/dielectron/papaframework/PairAnalysisHelper.cxx
@@ -11,6 +11,10 @@
///////////////////////////////////////////////////////////////////////////
+#include "PairAnalysisHelper.h"
+
+#include "CbmModuleList.h"
+
#include <TDatabasePDG.h>
#include <TError.h>
#include <TF1.h>
@@ -29,15 +33,12 @@
#include <TRandom.h>
#include <TVectorD.h>
-
-#include "CbmModuleList.h"
-#include "PairAnalysisHelper.h"
#include "PairAnalysisStyler.h"
#include "PairAnalysisVarManager.h"
//_____________________________________________________________________________
-TVectorD*
-PairAnalysisHelper::MakeLogBinning(Int_t nbinsX, Double_t xmin, Double_t xmax) {
+TVectorD* PairAnalysisHelper::MakeLogBinning(Int_t nbinsX, Double_t xmin, Double_t xmax)
+{
//
// Make logarithmic binning
// the user has to delete the array afterwards!!!
@@ -45,9 +46,8 @@ PairAnalysisHelper::MakeLogBinning(Int_t nbinsX, Double_t xmin, Double_t xmax) {
//check limits
if (xmin < 1e-20 || xmax < 1e-20) {
- Error("PairAnalysisHelper::MakeLogBinning",
- "For Log binning xmin and xmax must be > 1e-20. Using linear binning "
- "instead!");
+ Error("PairAnalysisHelper::MakeLogBinning", "For Log binning xmin and xmax must be > 1e-20. Using linear binning "
+ "instead!");
return PairAnalysisHelper::MakeLinBinning(nbinsX, xmin, xmax);
}
if (xmax < xmin) {
@@ -66,8 +66,8 @@ PairAnalysisHelper::MakeLogBinning(Int_t nbinsX, Double_t xmin, Double_t xmax) {
}
//_____________________________________________________________________________
-TVectorD*
-PairAnalysisHelper::MakeLinBinning(Int_t nbinsX, Double_t xmin, Double_t xmax) {
+TVectorD* PairAnalysisHelper::MakeLinBinning(Int_t nbinsX, Double_t xmin, Double_t xmax)
+{
//
// Make linear binning
// the user has to delete the array afterwards!!!
@@ -88,30 +88,28 @@ PairAnalysisHelper::MakeLinBinning(Int_t nbinsX, Double_t xmin, Double_t xmax) {
}
//_____________________________________________________________________________
-TVectorD* PairAnalysisHelper::MakeArbitraryBinning(const char* bins) {
+TVectorD* PairAnalysisHelper::MakeArbitraryBinning(const char* bins)
+{
//
// Make arbitrary binning, bins separated by a ','
//
TString limits(bins);
if (limits.IsNull()) {
- Error("PairAnalysisHelper::MakeArbitraryBinning",
- "Bin Limit string is empty, cannot add the variable");
+ Error("PairAnalysisHelper::MakeArbitraryBinning", "Bin Limit string is empty, cannot add the variable");
return 0x0;
}
TObjArray* arr = limits.Tokenize(",");
Int_t nLimits = arr->GetEntries();
if (nLimits < 2) {
- Error("PairAnalysisHelper::MakeArbitraryBinning",
- "Need at leas 2 bin limits, cannot add the variable");
+ Error("PairAnalysisHelper::MakeArbitraryBinning", "Need at leas 2 bin limits, cannot add the variable");
delete arr;
return 0x0;
}
TVectorD* binLimits = new TVectorD(nLimits);
for (Int_t iLim = 0; iLim < nLimits; ++iLim) {
- (*binLimits)[iLim] =
- (static_cast<TObjString*>(arr->At(iLim)))->GetString().Atof();
+ (*binLimits)[iLim] = (static_cast<TObjString*>(arr->At(iLim)))->GetString().Atof();
}
delete arr;
@@ -119,9 +117,8 @@ TVectorD* PairAnalysisHelper::MakeArbitraryBinning(const char* bins) {
}
//_____________________________________________________________________________
-TVectorD* PairAnalysisHelper::MakeGausBinning(Int_t nbinsX,
- Double_t mean,
- Double_t sigma) {
+TVectorD* PairAnalysisHelper::MakeGausBinning(Int_t nbinsX, Double_t mean, Double_t sigma)
+{
//
// Make gaussian binning
// the user has to delete the array afterwards!!!
@@ -151,8 +148,7 @@ TVectorD* PairAnalysisHelper::MakeGausBinning(Int_t nbinsX,
// current integral
// Double_t cint = g2.Integral(mean-5*sigma,xt,params,epsilon); //fast, but NOT root 6 (Integral(min,max,epsilon)) compatible
- Double_t cint =
- g2.Integral(mean - 5 * sigma, xt); //,params,epsilon); //slow
+ Double_t cint = g2.Integral(mean - 5 * sigma, xt); //,params,epsilon); //slow
// printf(" integral to %f: %f , search limit: %f \n",xt,cint,lim);
/// condition for bin limit
@@ -177,17 +173,16 @@ TVectorD* PairAnalysisHelper::MakeGausBinning(Int_t nbinsX,
}
//_____________________________________________________________________________
-TVectorD* PairAnalysisHelper::CombineBinning(TVectorD* low, TVectorD* high) {
+TVectorD* PairAnalysisHelper::CombineBinning(TVectorD* low, TVectorD* high)
+{
//
// Make a new combined binning of "low" and "high"
// the user has to delete the returned array afterwards!!!
//
// fill final vector
- Int_t lastEqualsFirst =
- (Int_t)(TMath::Abs((*low)[low->GetNrows() - 1] - (*high)[0]) < 1.e-15);
- TVectorD* binLim =
- new TVectorD(low->GetNrows() + high->GetNrows() - lastEqualsFirst);
+ Int_t lastEqualsFirst = (Int_t)(TMath::Abs((*low)[low->GetNrows() - 1] - (*high)[0]) < 1.e-15);
+ TVectorD* binLim = new TVectorD(low->GetNrows() + high->GetNrows() - lastEqualsFirst);
for (Int_t i = 0; i < low->GetNrows(); i++)
(*binLim)[i] = (*low)[i];
for (Int_t i = 0; i < high->GetNrows() - lastEqualsFirst; i++)
@@ -200,7 +195,8 @@ TVectorD* PairAnalysisHelper::CombineBinning(TVectorD* low, TVectorD* high) {
}
//_____________________________________________________________________________
-TArrayD* PairAnalysisHelper::MakeStatBinLimits(TH1* h, Double_t stat) {
+TArrayD* PairAnalysisHelper::MakeStatBinLimits(TH1* h, Double_t stat)
+{
//
// get bin limits for stat. error less than 'stat'
//
@@ -228,10 +224,9 @@ TArrayD* PairAnalysisHelper::MakeStatBinLimits(TH1* h, Double_t stat) {
// h->GetBinContent(i),h->Integral(),h->GetBinContent(i)/h->Integral(), h->GetBinError(i), TMath::Sqrt(h->GetBinContent(i)),h->GetBinError(i)/h->GetBinContent(i)*100, TMath::Sqrt(err)/cont*100);
// check for new bin
- if (
- TMath::Sqrt(err) / cont <= stat
- // || (h->GetBinContent(i)/h->Integral()) < 0.01
- // || (h->GetBinContent(i)==0.0 && h->GetBinError(i)==0. && vEle==1)
+ if (TMath::Sqrt(err) / cont <= stat
+ // || (h->GetBinContent(i)/h->Integral()) < 0.01
+ // || (h->GetBinContent(i)==0.0 && h->GetBinError(i)==0. && vEle==1)
) {
// Printf("bin from %f to %f with err %f%%",from,to,TMath::Sqrt(err)/cont*100);
err = 0.0;
@@ -249,7 +244,8 @@ TArrayD* PairAnalysisHelper::MakeStatBinLimits(TH1* h, Double_t stat) {
}
//_____________________________________________________________________________
-TVectorD* PairAnalysisHelper::MakePdgBinning() {
+TVectorD* PairAnalysisHelper::MakePdgBinning()
+{
//
// Make arbitrary binning using defined PDG codes
//
@@ -275,8 +271,8 @@ TVectorD* PairAnalysisHelper::MakePdgBinning() {
}
//_____________________________________________________________________________
-Double_t PairAnalysisHelper::EvalFormula(TFormula* form,
- const Double_t* values) {
+Double_t PairAnalysisHelper::EvalFormula(TFormula* form, const Double_t* values)
+{
//
// evaluate return value for formula with current parameter values
//
@@ -288,7 +284,8 @@ Double_t PairAnalysisHelper::EvalFormula(TFormula* form,
}
//_____________________________________________________________________________
-TString PairAnalysisHelper::GetFormulaTitle(TFormula* form) {
+TString PairAnalysisHelper::GetFormulaTitle(TFormula* form)
+{
//
// evaluate the formula in a readable way (for axis etc)
//
@@ -305,21 +302,19 @@ TString PairAnalysisHelper::GetFormulaTitle(TFormula* form) {
tform.ToLower(); // lower cases (e.g. Cos -> cos)
// replace parameter variables with proper labels
for (Int_t j = 0; j < form->GetNpar(); j++)
- tform.ReplaceAll(
- Form("[%d]", j),
- PairAnalysisVarManager::GetValueLabel((UInt_t) form->GetParameter(j)));
+ tform.ReplaceAll(Form("[%d]", j), PairAnalysisVarManager::GetValueLabel((UInt_t) form->GetParameter(j)));
return (tform);
}
//_____________________________________________________________________________
-TString PairAnalysisHelper::GetFormulaName(TFormula* form) {
+TString PairAnalysisHelper::GetFormulaName(TFormula* form)
+{
//
// build formula key with parameter names
//
TString tform("f(");
for (Int_t j = 0; j < form->GetNpar(); j++) {
- tform +=
- PairAnalysisVarManager::GetValueName((UInt_t) form->GetParameter(j));
+ tform += PairAnalysisVarManager::GetValueName((UInt_t) form->GetParameter(j));
if (j != form->GetNpar() - 1) tform += ",";
}
tform += ")";
@@ -327,8 +322,8 @@ TString PairAnalysisHelper::GetFormulaName(TFormula* form) {
}
//_____________________________________________________________________________
-TFormula* PairAnalysisHelper::GetFormula(const char* name,
- const char* formula) {
+TFormula* PairAnalysisHelper::GetFormula(const char* name, const char* formula)
+{
//
// build a TFormula object
//
@@ -339,15 +334,15 @@ TFormula* PairAnalysisHelper::GetFormula(const char* name,
if (form->Compile()) return 0x0;
//set parameter/variable identifier
for (Int_t i = 0; i < form->GetNpar(); i++) {
- form->SetParName(
- i, PairAnalysisVarManager::GetValueName(form->GetParameter(i)));
+ form->SetParName(i, PairAnalysisVarManager::GetValueName(form->GetParameter(i)));
// fUsedVars->SetBitNumber((Int_t)form->GetParameter(i),kTRUE);
}
return form;
}
//_____________________________________________________________________________
-void PairAnalysisHelper::SetPDGBinLabels(TH1* hist, Bool_t clean) {
+void PairAnalysisHelper::SetPDGBinLabels(TH1* hist, Bool_t clean)
+{
//
// build formula key with parameter names
//
@@ -383,7 +378,8 @@ void PairAnalysisHelper::SetPDGBinLabels(TH1* hist, Bool_t clean) {
}
//_____________________________________________________________________________
-TString PairAnalysisHelper::GetPDGlabel(Int_t pdg) {
+TString PairAnalysisHelper::GetPDGlabel(Int_t pdg)
+{
//
// return the label in latex format corresponding to pdg code
//
@@ -428,7 +424,8 @@ TString PairAnalysisHelper::GetPDGlabel(Int_t pdg) {
if (name.Contains("anti")) {
name.ReplaceAll("anti", "#bar{");
name.Append("}");
- } else if (name.Contains("_bar")) {
+ }
+ else if (name.Contains("_bar")) {
name.ReplaceAll("_bar", "}");
name.Prepend("#bar{");
}
@@ -447,7 +444,8 @@ TString PairAnalysisHelper::GetPDGlabel(Int_t pdg) {
}
//_____________________________________________________________________________
-void PairAnalysisHelper::SetGEANTBinLabels(TH1* hist) {
+void PairAnalysisHelper::SetGEANTBinLabels(TH1* hist)
+{
//
// build formula key with parameter names
//
@@ -465,7 +463,8 @@ void PairAnalysisHelper::SetGEANTBinLabels(TH1* hist) {
//_____________________________________________________________________________
-TString PairAnalysisHelper::GetDetName(ECbmModuleId det) {
+TString PairAnalysisHelper::GetDetName(ECbmModuleId det)
+{
//
// get detector name
//
@@ -477,7 +476,8 @@ TString PairAnalysisHelper::GetDetName(ECbmModuleId det) {
}
//_____________________________________________________________________________
-Double_t PairAnalysisHelper::GetContentMinimum(TH1* h, Bool_t inclErr) {
+Double_t PairAnalysisHelper::GetContentMinimum(TH1* h, Bool_t inclErr)
+{
//
// get minimum bin content of histogram (having entries)
//
@@ -499,10 +499,7 @@ Double_t PairAnalysisHelper::GetContentMinimum(TH1* h, Bool_t inclErr) {
if (gPad->GetLogy() && (value - error) <= 0.) continue;
if (error > value * 0.9) continue;
if (inclErr) value -= h->GetBinError(bin);
- if (value < minimum
- && TMath::Abs(h->GetBinError(bin) - 1.e-15) > 1.e-15) {
- minimum = value;
- }
+ if (value < minimum && TMath::Abs(h->GetBinError(bin) - 1.e-15) > 1.e-15) { minimum = value; }
}
}
}
@@ -510,7 +507,8 @@ Double_t PairAnalysisHelper::GetContentMinimum(TH1* h, Bool_t inclErr) {
return minimum;
}
-Double_t PairAnalysisHelper::GetContentMaximum(TH1* h, Bool_t inclErr) {
+Double_t PairAnalysisHelper::GetContentMaximum(TH1* h, Bool_t inclErr)
+{
//
// get maximum bin content+error of histogram (having entries)
//
@@ -529,16 +527,15 @@ Double_t PairAnalysisHelper::GetContentMaximum(TH1* h, Bool_t inclErr) {
value = h->GetBinContent(bin);
error = h->GetBinError(bin);
if (inclErr) value += h->GetBinError(bin);
- if (value > maximum && TMath::Abs(error - 1.e-15) > 1.e-15) {
- maximum = value;
- }
+ if (value > maximum && TMath::Abs(error - 1.e-15) > 1.e-15) { maximum = value; }
}
}
}
return maximum;
}
-Double_t PairAnalysisHelper::GetQuantile(TH1* h1, Double_t p /*=0.5*/) {
+Double_t PairAnalysisHelper::GetQuantile(TH1* h1, Double_t p /*=0.5*/)
+{
//
// calculates the quantile of the bin contents, p=0.5 -> Median
// useful functionallity for plotting 2D distibutions with some extreme outliers
@@ -556,16 +553,13 @@ Double_t PairAnalysisHelper::GetQuantile(TH1* h1, Double_t p /*=0.5*/) {
Int_t nfilled = 0;
for (Int_t i = 1; i <= nbins; i++) {
h1->GetBinXYZ(i, xbin, ybin, zbin);
- if (xbin < h1->GetXaxis()->GetFirst() || xbin > h1->GetXaxis()->GetLast())
- continue;
- if (ybin < h1->GetYaxis()->GetFirst() || ybin > h1->GetYaxis()->GetLast())
- continue;
+ if (xbin < h1->GetXaxis()->GetFirst() || xbin > h1->GetXaxis()->GetLast()) continue;
+ if (ybin < h1->GetYaxis()->GetFirst() || ybin > h1->GetYaxis()->GetLast()) continue;
Double_t con = h1->GetBinContent(i);
Double_t err = h1->GetBinError(i);
if (err != 0.0) {
// printf("bin%d %.f+-%.f \n",i,con,err);
- val[nfilled] =
- con + (h1->GetDimension() < 2 ? err : 0.0); // w or w/o err?
+ val[nfilled] = con + (h1->GetDimension() < 2 ? err : 0.0); // w or w/o err?
nfilled++;
}
}
@@ -577,7 +571,8 @@ Double_t PairAnalysisHelper::GetQuantile(TH1* h1, Double_t p /*=0.5*/) {
return val[idx[pos]];
}
-void PairAnalysisHelper::NormalizeSlicesY(TH2* h) {
+void PairAnalysisHelper::NormalizeSlicesY(TH2* h)
+{
//
// normalize slices along Y in case of a 2D histogram
//
@@ -594,7 +589,8 @@ void PairAnalysisHelper::NormalizeSlicesY(TH2* h) {
delete hsum;
}
-void PairAnalysisHelper::CumulateSlicesX(TH2* h, Bool_t reverse, Bool_t norm) {
+void PairAnalysisHelper::CumulateSlicesX(TH2* h, Bool_t reverse, Bool_t norm)
+{
//
// caluclate cumulative sum of bins (normalized to one)
// for slices along X in case of a 2D histogram
@@ -616,7 +612,8 @@ void PairAnalysisHelper::CumulateSlicesX(TH2* h, Bool_t reverse, Bool_t norm) {
}
}
-void PairAnalysisHelper::Cumulate(TH1* h, Bool_t reverse, Bool_t norm) {
+void PairAnalysisHelper::Cumulate(TH1* h, Bool_t reverse, Bool_t norm)
+{
//
// caluclate cumulative sum of bins (normalized to one)
//
@@ -636,15 +633,13 @@ void PairAnalysisHelper::Cumulate(TH1* h, Bool_t reverse, Bool_t norm) {
}
-TObject* PairAnalysisHelper::FindObjectByTitle(TObjArray* arrhist,
- TString ref) {
+TObject* PairAnalysisHelper::FindObjectByTitle(TObjArray* arrhist, TString ref)
+{
//
// shortcut to find a certain pair type object in array
//
for (Int_t i = 0; i < arrhist->GetEntriesFast(); i++) {
- if (!ref.CompareTo(arrhist->UncheckedAt(i)->GetTitle())) {
- return arrhist->UncheckedAt(i);
- }
+ if (!ref.CompareTo(arrhist->UncheckedAt(i)->GetTitle())) { return arrhist->UncheckedAt(i); }
}
return 0x0;
@@ -654,7 +649,8 @@ TObject* PairAnalysisHelper::FindObjectByTitle(TObjArray* arrhist,
//_____________________________________________________________________________
-Int_t PairAnalysisHelper::GetPrecision(Double_t value) {
+Int_t PairAnalysisHelper::GetPrecision(Double_t value)
+{
//
// computes the precision of a double
// usefull for axis ranges etc
@@ -664,12 +660,11 @@ Int_t PairAnalysisHelper::GetPrecision(Double_t value) {
value *= 1e6;
while (!bfnd) {
// Printf(" value %f precision %d bfnd %d",TMath::Abs(value*TMath::Power(10,precision)), precision, bfnd);
- bfnd =
- ((TMath::Abs(value * TMath::Power(10, precision)) / 1e6
- - TMath::Floor(TMath::Abs(value * TMath::Power(10, precision)) / 1e6))
- != 0.0
- ? kFALSE
- : kTRUE);
+ bfnd = ((TMath::Abs(value * TMath::Power(10, precision)) / 1e6
+ - TMath::Floor(TMath::Abs(value * TMath::Power(10, precision)) / 1e6))
+ != 0.0
+ ? kFALSE
+ : kTRUE);
if (!bfnd) precision++;
}
diff --git a/analysis/PWGDIL/dielectron/papaframework/PairAnalysisHelper.h b/analysis/PWGDIL/dielectron/papaframework/PairAnalysisHelper.h
index 61746c2f218198ec26944dc87de213642dabcd39..6effb90eb6600d78b41fd88489f604af0bebab22 100644
--- a/analysis/PWGDIL/dielectron/papaframework/PairAnalysisHelper.h
+++ b/analysis/PWGDIL/dielectron/papaframework/PairAnalysisHelper.h
@@ -14,11 +14,11 @@
///////////////////////////////////////////////////////////////////////////////////////////
+#include "CbmDefs.h"
+
#include <TArrayD.h>
#include <TVectorDfwd.h>
-#include "CbmDefs.h"
-
//class AliKFParticle;
/* class AliVEvent; */
/* class AliMCEvent; */
@@ -28,7 +28,8 @@ class TH1;
class TH2;
class TObjArray;
-namespace PairAnalysisHelper {
+namespace PairAnalysisHelper
+{
TVectorD* MakeLogBinning(Int_t nbinsX, Double_t xmin, Double_t xmax);
TVectorD* MakeLinBinning(Int_t nbinsX, Double_t xmin, Double_t xmax);
diff --git a/analysis/PWGDIL/dielectron/papaframework/PairAnalysisHistos.cxx b/analysis/PWGDIL/dielectron/papaframework/PairAnalysisHistos.cxx
index d6cda82b71b2351349056eefc21e1d81ba49cea9..1bdbdc5fde77188766711a410d6d9637e8fbc4d3 100644
--- a/analysis/PWGDIL/dielectron/papaframework/PairAnalysisHistos.cxx
+++ b/analysis/PWGDIL/dielectron/papaframework/PairAnalysisHistos.cxx
@@ -57,7 +57,7 @@
// //
///////////////////////////////////////////////////////////////////////////
-#include <typeinfo>
+#include "PairAnalysisHistos.h"
#include <TAxis.h>
#include <TCanvas.h>
@@ -90,10 +90,10 @@
#include <TString.h>
#include <TVectorD.h>
#include <TVirtualPS.h>
+#include <typeinfo>
#include "PairAnalysis.h"
#include "PairAnalysisHelper.h"
-#include "PairAnalysisHistos.h"
#include "PairAnalysisMetaData.h"
#include "PairAnalysisSignalMC.h"
#include "PairAnalysisStyler.h"
@@ -110,7 +110,8 @@ ClassImp(PairAnalysisHistos)
, fList(0x0)
, fUsedVars(new TBits(PairAnalysisVarManager::kNMaxValues))
, fReservedWords(new TString("Hit;Track;Pair"))
- , fPrecision(Eprecision::kFloat) {
+ , fPrecision(Eprecision::kFloat)
+{
//
// Default constructor
//
@@ -129,7 +130,8 @@ PairAnalysisHistos::PairAnalysisHistos(const char* name, const char* title)
, fList(0x0)
, fUsedVars(new TBits(PairAnalysisVarManager::kNMaxValues))
, fReservedWords(new TString("Hit;Track;Pair"))
- , fPrecision(Eprecision::kFloat) {
+ , fPrecision(Eprecision::kFloat)
+{
//
// TNamed constructor
//
@@ -140,7 +142,8 @@ PairAnalysisHistos::PairAnalysisHistos(const char* name, const char* title)
}
//_____________________________________________________________________________
-PairAnalysisHistos::~PairAnalysisHistos() {
+PairAnalysisHistos::~PairAnalysisHistos()
+{
//
// Destructor
//
@@ -152,11 +155,9 @@ PairAnalysisHistos::~PairAnalysisHistos() {
}
//_____________________________________________________________________________
-void PairAnalysisHistos::UserHistogram(const char* histClass,
- Int_t ndim,
- TObjArray* limits,
- UInt_t* vars,
- UInt_t valTypeW) {
+void PairAnalysisHistos::UserHistogram(const char* histClass, Int_t ndim, TObjArray* limits, UInt_t* vars,
+ UInt_t valTypeW)
+{
//
// Histogram creation n>3 dimension only with non-linear binning
//
@@ -164,10 +165,7 @@ void PairAnalysisHistos::UserHistogram(const char* histClass,
Bool_t isOk = kTRUE;
isOk &= (ndim < 21 && ndim > 3);
if (!isOk) {
- Warning(
- "UserHistogram",
- "Array sizes should be between 3 and 20. Not adding Histogram to '%s'.",
- histClass);
+ Warning("UserHistogram", "Array sizes should be between 3 and 20. Not adding Histogram to '%s'.", histClass);
return;
}
isOk &= (ndim == limits->GetEntriesFast());
@@ -208,19 +206,15 @@ void PairAnalysisHistos::UserHistogram(const char* histClass,
fUsedVars->SetBitNumber(valTypeW, kTRUE);
Bool_t isReserved = fReservedWords->Contains(histClass);
- if (isReserved)
- UserHistogramReservedWords(histClass, hist);
+ if (isReserved) UserHistogramReservedWords(histClass, hist);
else
UserHistogram(histClass, hist);
}
}
//_____________________________________________________________________________
-void PairAnalysisHistos::AddSparse(const char* histClass,
- Int_t ndim,
- TObjArray* limits,
- UInt_t* vars,
- UInt_t valTypeW) {
+void PairAnalysisHistos::AddSparse(const char* histClass, Int_t ndim, TObjArray* limits, UInt_t* vars, UInt_t valTypeW)
+{
//
// THnSparse creation with non-linear binning
//
@@ -266,19 +260,16 @@ void PairAnalysisHistos::AddSparse(const char* histClass,
fUsedVars->SetBitNumber(valTypeW, kTRUE);
Bool_t isReserved = fReservedWords->Contains(histClass);
- if (isReserved)
- UserHistogramReservedWords(histClass, hist);
+ if (isReserved) UserHistogramReservedWords(histClass, hist);
else
UserHistogram(histClass, hist);
}
}
//_____________________________________________________________________________
-void PairAnalysisHistos::AddSparse(const char* histClass,
- Int_t ndim,
- TObjArray* limits,
- TFormula** vars,
- UInt_t valTypeW) {
+void PairAnalysisHistos::AddSparse(const char* histClass, Int_t ndim, TObjArray* limits, TFormula** vars,
+ UInt_t valTypeW)
+{
//
// THnSparse creation with non-linear binning
//
@@ -336,16 +327,15 @@ void PairAnalysisHistos::AddSparse(const char* histClass,
fUsedVars->SetBitNumber(valTypeW, kTRUE);
Bool_t isReserved = fReservedWords->Contains(histClass);
- if (isReserved)
- UserHistogramReservedWords(histClass, hist);
+ if (isReserved) UserHistogramReservedWords(histClass, hist);
else
UserHistogram(histClass, hist);
}
}
//_____________________________________________________________________________
-TString PairAnalysisHistos::UserHistogram(const char* histClass,
- TObject* hist) {
+TString PairAnalysisHistos::UserHistogram(const char* histClass, TObject* hist)
+{
//
// Add any type of user histogram
//
@@ -372,18 +362,14 @@ TString PairAnalysisHistos::UserHistogram(const char* histClass,
for (Int_t i = 0; i < 2; i++) {
/// protection for changes of variable enum (in the postprocessing) --> use axistname indentification
// UInt_t valTypeFromTitle = 0;
- if (!i)
- valType[i] = PairAnalysisVarManager::GetValueType(
- ((TH1*) hist)->GetXaxis()->GetName());
+ if (!i) valType[i] = PairAnalysisVarManager::GetValueType(((TH1*) hist)->GetXaxis()->GetName());
else
- valType[i] = PairAnalysisVarManager::GetValueType(
- ((TH1*) hist)->GetYaxis()->GetName());
+ valType[i] = PairAnalysisVarManager::GetValueType(((TH1*) hist)->GetYaxis()->GetName());
//Printf("SWITCH TO MC: before: %d %s, (via axis name %d) ---->",valType[i],PairAnalysisVarManager::GetValueName(valType[i]),valTypeFromTitle);
valType[i] = PairAnalysisVarManager::GetValueTypeMC(valType[i]);
// if theres no corresponding MCtruth variable, skip adding this histogram
// if(valType[i] < PairAnalysisVarManager::kNMaxValues && valType[i]>0) return hist->GetName();
- if (valType[i] < PairAnalysisVarManager::kPairMax && valType[i] > 0)
- return hist->GetName();
+ if (valType[i] < PairAnalysisVarManager::kPairMax && valType[i] > 0) return hist->GetName();
// request filling of mc variable
fUsedVars->SetBitNumber(valType[i], kTRUE);
// Printf("after: %d %s",valType[i],PairAnalysisVarManager::GetValueName(valType[i]));
@@ -396,11 +382,9 @@ TString PairAnalysisHistos::UserHistogram(const char* histClass,
TFormula* f = 0;
while ((f = dynamic_cast<TFormula*>(next()))) {
for (Int_t i = 0; i < f->GetNpar(); i++) {
- Int_t parMC =
- PairAnalysisVarManager::GetValueTypeMC(f->GetParameter(i));
+ Int_t parMC = PairAnalysisVarManager::GetValueTypeMC(f->GetParameter(i));
// if theres none corresponding MCtruth variable, skip adding this histogram
- if (parMC < PairAnalysisVarManager::kNMaxValues)
- return hist->GetName();
+ if (parMC < PairAnalysisVarManager::kNMaxValues) return hist->GetName();
f->SetParameter(i, parMC);
f->SetParName(i, PairAnalysisVarManager::GetValueName(parMC));
fUsedVars->SetBitNumber(parMC, kTRUE);
@@ -409,7 +393,8 @@ TString PairAnalysisHistos::UserHistogram(const char* histClass,
// change histogram key according to mctruth information
AdaptNameTitle((TH1*) hist, histClass);
}
- } else {
+ }
+ else {
StoreVariables(hist, valType);
hist->SetUniqueID(valType[19]); // store weighting variable
}
@@ -423,12 +408,9 @@ TString PairAnalysisHistos::UserHistogram(const char* histClass,
}
//_____________________________________________________________________________
-TH1* PairAnalysisHistos::GetTHist(const char* histClass,
- const char* name,
- const char* title,
- const TVectorD* const binsX,
- const TVectorD* const binsY,
- const TVectorD* const binsZ) {
+TH1* PairAnalysisHistos::GetTHist(const char* histClass, const char* name, const char* title,
+ const TVectorD* const binsX, const TVectorD* const binsY, const TVectorD* const binsZ)
+{
//
// retrieve n-dimensional Hist depending on arguments
//
@@ -438,59 +420,32 @@ TH1* PairAnalysisHistos::GetTHist(const char* histClass,
if (!isOk) return 0x0;
switch (fPrecision) {
case Eprecision::kFloat:
- if (!binsY)
- return (new TH1F(
- name, title, binsX->GetNrows() - 1, binsX->GetMatrixArray()));
+ if (!binsY) return (new TH1F(name, title, binsX->GetNrows() - 1, binsX->GetMatrixArray()));
else if (!binsZ)
- return (new TH2F(name,
- title,
- binsX->GetNrows() - 1,
- binsX->GetMatrixArray(),
- binsY->GetNrows() - 1,
+ return (new TH2F(name, title, binsX->GetNrows() - 1, binsX->GetMatrixArray(), binsY->GetNrows() - 1,
binsY->GetMatrixArray()));
else
- return (new TH3F(name,
- title,
- binsX->GetNrows() - 1,
- binsX->GetMatrixArray(),
- binsY->GetNrows() - 1,
- binsY->GetMatrixArray(),
- binsZ->GetNrows() - 1,
- binsZ->GetMatrixArray()));
+ return (new TH3F(name, title, binsX->GetNrows() - 1, binsX->GetMatrixArray(), binsY->GetNrows() - 1,
+ binsY->GetMatrixArray(), binsZ->GetNrows() - 1, binsZ->GetMatrixArray()));
break;
case Eprecision::kDouble:
- if (!binsY)
- return (new TH1D(
- name, title, binsX->GetNrows() - 1, binsX->GetMatrixArray()));
+ if (!binsY) return (new TH1D(name, title, binsX->GetNrows() - 1, binsX->GetMatrixArray()));
else if (!binsZ)
- return (new TH2D(name,
- title,
- binsX->GetNrows() - 1,
- binsX->GetMatrixArray(),
- binsY->GetNrows() - 1,
+ return (new TH2D(name, title, binsX->GetNrows() - 1, binsX->GetMatrixArray(), binsY->GetNrows() - 1,
binsY->GetMatrixArray()));
else
- return (new TH3D(name,
- title,
- binsX->GetNrows() - 1,
- binsX->GetMatrixArray(),
- binsY->GetNrows() - 1,
- binsY->GetMatrixArray(),
- binsZ->GetNrows() - 1,
- binsZ->GetMatrixArray()));
+ return (new TH3D(name, title, binsX->GetNrows() - 1, binsX->GetMatrixArray(), binsY->GetNrows() - 1,
+ binsY->GetMatrixArray(), binsZ->GetNrows() - 1, binsZ->GetMatrixArray()));
break;
default: return 0x0; break;
}
}
//_____________________________________________________________________________
-TH1* PairAnalysisHistos::GetTProf(const char* histClass,
- const char* name,
- const char* title,
- const TVectorD* const binsX,
- const TVectorD* const binsY,
- const TVectorD* const binsZ,
- TString option) {
+TH1* PairAnalysisHistos::GetTProf(const char* histClass, const char* name, const char* title,
+ const TVectorD* const binsX, const TVectorD* const binsY, const TVectorD* const binsZ,
+ TString option)
+{
//
// retrieve n-dimensional profile histogram with error options depending on arguments
//
@@ -505,48 +460,31 @@ TH1* PairAnalysisHistos::GetTProf(const char* histClass,
TObjArray* arr = option.Tokenize(";");
arr->SetOwner();
opt = ((TObjString*) arr->At(0))->GetString();
- if (arr->GetEntriesFast() > 1)
- pmin = (((TObjString*) arr->At(1))->GetString()).Atof();
- if (arr->GetEntriesFast() > 2)
- pmax = (((TObjString*) arr->At(2))->GetString()).Atof();
+ if (arr->GetEntriesFast() > 1) pmin = (((TObjString*) arr->At(1))->GetString()).Atof();
+ if (arr->GetEntriesFast() > 2) pmax = (((TObjString*) arr->At(2))->GetString()).Atof();
delete arr;
}
// build profile with error options and return it
TH1* prof = 0x0;
if (!binsY)
- return (new TProfile(name,
- title,
- binsX->GetNrows() - 1,
- binsX->GetMatrixArray(),
- pmin,
- pmax,
- opt.Data()));
+ return (new TProfile(name, title, binsX->GetNrows() - 1, binsX->GetMatrixArray(), pmin, pmax, opt.Data()));
else if (!binsZ) {
- prof = new TProfile2D(name,
- title,
- binsX->GetNrows() - 1,
- binsX->GetMatrixArray(),
- binsY->GetNrows() - 1,
+ prof = new TProfile2D(name, title, binsX->GetNrows() - 1, binsX->GetMatrixArray(), binsY->GetNrows() - 1,
binsY->GetMatrixArray());
((TProfile2D*) prof)->BuildOptions(pmin, pmax, opt.Data());
return prof;
- } else {
- prof = new TProfile3D(name,
- title,
- binsX->GetNrows() - 1,
- binsX->GetMatrixArray(),
- binsY->GetNrows() - 1,
- binsY->GetMatrixArray(),
- binsZ->GetNrows() - 1,
- binsZ->GetMatrixArray());
+ }
+ else {
+ prof = new TProfile3D(name, title, binsX->GetNrows() - 1, binsX->GetMatrixArray(), binsY->GetNrows() - 1,
+ binsY->GetMatrixArray(), binsZ->GetNrows() - 1, binsZ->GetMatrixArray());
((TProfile3D*) prof)->BuildOptions(pmin, pmax, opt.Data());
return prof;
}
}
//_____________________________________________________________________________
-TFormula* PairAnalysisHistos::GetFormula(const char* name,
- const char* formula) {
+TFormula* PairAnalysisHistos::GetFormula(const char* name, const char* formula)
+{
//
// build a TFormula object
//
@@ -555,15 +493,15 @@ TFormula* PairAnalysisHistos::GetFormula(const char* name,
if (form->Compile()) return 0x0;
//set parameter/variable identifier
for (Int_t i = 0; i < form->GetNpar(); i++) {
- form->SetParName(
- i, PairAnalysisVarManager::GetValueName(form->GetParameter(i)));
+ form->SetParName(i, PairAnalysisVarManager::GetValueName(form->GetParameter(i)));
fUsedVars->SetBitNumber((Int_t) form->GetParameter(i), kTRUE);
}
return form;
}
//_____________________________________________________________________________
-void PairAnalysisHistos::AddClass(const char* histClass) {
+void PairAnalysisHistos::AddClass(const char* histClass)
+{
//
// Add a class of histograms
// Several classes can be added by separating them by a ';' e.g. 'class1;class2;class3'
@@ -574,8 +512,7 @@ void PairAnalysisHistos::AddClass(const char* histClass) {
TObject* o = 0;
while ((o = next())) {
if (fHistoList.FindObject(o->GetName())) {
- Warning(
- "AddClass", "Cannot create class '%s' it already exists.", histClass);
+ Warning("AddClass", "Cannot create class '%s' it already exists.", histClass);
continue;
}
if (fReservedWords->Contains(o->GetName())) {
@@ -591,7 +528,8 @@ void PairAnalysisHistos::AddClass(const char* histClass) {
}
//_____________________________________________________________________________
-void PairAnalysisHistos::FillClass(TString histClass, const Double_t* values) {
+void PairAnalysisHistos::FillClass(TString histClass, const Double_t* values)
+{
//
// Fill class 'histClass' (by name)
//
@@ -610,8 +548,8 @@ void PairAnalysisHistos::FillClass(TString histClass, const Double_t* values) {
}
//_____________________________________________________________________________
-void PairAnalysisHistos::UserHistogramReservedWords(const char* histClass,
- const TObject* hist) {
+void PairAnalysisHistos::UserHistogramReservedWords(const char* histClass, const TObject* hist)
+{
//
// Creation of histogram for all pair or track types
//
@@ -625,8 +563,7 @@ void PairAnalysisHistos::UserHistogramReservedWords(const char* histClass,
TObject* h = hist->Clone();
// Tobject has no function SetDirectory, didn't we need this???
// h->SetDirectory(0);
- if (h->InheritsFrom(TH1::Class()))
- ((TH1*) h)->SetTitle(Form("%s %s", title.Data(), l->GetName()));
+ if (h->InheritsFrom(TH1::Class())) ((TH1*) h)->SetTitle(Form("%s %s", title.Data(), l->GetName()));
else
((THnBase*) h)->SetTitle(Form("%s %s", title.Data(), l->GetName()));
@@ -639,7 +576,8 @@ void PairAnalysisHistos::UserHistogramReservedWords(const char* histClass,
}
//_____________________________________________________________________________
-void PairAnalysisHistos::DumpToFile(const char* file) {
+void PairAnalysisHistos::DumpToFile(const char* file)
+{
//
// Dump the histogram list to a newly created root file
//
@@ -649,8 +587,8 @@ void PairAnalysisHistos::DumpToFile(const char* file) {
}
//_____________________________________________________________________________
-TObject* PairAnalysisHistos::GetHist(const char* histClass,
- const char* name) const {
+TObject* PairAnalysisHistos::GetHist(const char* histClass, const char* name) const
+{
//
// return object 'name' in 'histClass'
//
@@ -660,8 +598,8 @@ TObject* PairAnalysisHistos::GetHist(const char* histClass,
}
//_____________________________________________________________________________
-TH1* PairAnalysisHistos::GetHistogram(const char* histClass,
- const char* name) const {
+TH1* PairAnalysisHistos::GetHistogram(const char* histClass, const char* name) const
+{
//
// return histogram 'name' in 'histClass'
//
@@ -669,9 +607,8 @@ TH1* PairAnalysisHistos::GetHistogram(const char* histClass,
}
//_____________________________________________________________________________
-TObject* PairAnalysisHistos::GetHist(const char* cutClass,
- const char* histClass,
- const char* name) const {
+TObject* PairAnalysisHistos::GetHist(const char* cutClass, const char* histClass, const char* name) const
+{
//
// return object from list of list of histograms
// this function is thought for retrieving histograms if a list of PairAnalysisHistos is set
@@ -686,9 +623,8 @@ TObject* PairAnalysisHistos::GetHist(const char* cutClass,
}
//_____________________________________________________________________________
-TH1* PairAnalysisHistos::GetHistogram(const char* cutClass,
- const char* histClass,
- const char* name) const {
+TH1* PairAnalysisHistos::GetHistogram(const char* cutClass, const char* histClass, const char* name) const
+{
//
// return histogram from list of list of histograms
// this function is thought for retrieving histograms if a list of PairAnalysisHistos is set
@@ -697,7 +633,8 @@ TH1* PairAnalysisHistos::GetHistogram(const char* cutClass,
}
//_____________________________________________________________________________
-void PairAnalysisHistos::Draw(const Option_t* option) {
+void PairAnalysisHistos::Draw(const Option_t* option)
+{
//
// Draw histograms
//
@@ -718,9 +655,7 @@ void PairAnalysisHistos::Draw(const Option_t* option) {
currentOpt.Remove(TString::kBoth, ' ');
testOpt = "classes=";
- if (currentOpt.Contains(testOpt.Data())) {
- drawClasses = currentOpt(testOpt.Length(), currentOpt.Length());
- }
+ if (currentOpt.Contains(testOpt.Data())) { drawClasses = currentOpt(testOpt.Length(), currentOpt.Length()); }
}
delete arr;
@@ -731,9 +666,8 @@ void PairAnalysisHistos::Draw(const Option_t* option) {
TCanvas* c = 0x0;
if (gVirtualPS) {
if (!gPad) {
- Error("Draw",
- "When writing to a file you have to create a canvas before opening "
- "the file!!!");
+ Error("Draw", "When writing to a file you have to create a canvas before opening "
+ "the file!!!");
return;
}
c = gPad->GetCanvas();
@@ -746,8 +680,7 @@ void PairAnalysisHistos::Draw(const Option_t* option) {
// Bool_t first=kTRUE;
while ((classTable = (THashList*) nextClass())) {
//test classes option
- if (!drawClasses.IsNull() && !drawClasses.Contains(classTable->GetName()))
- continue;
+ if (!drawClasses.IsNull() && !drawClasses.Contains(classTable->GetName())) continue;
//optimised division
Int_t nPads = classTable->GetEntries();
Int_t nCols = (Int_t) TMath::Ceil(TMath::Sqrt(nPads));
@@ -758,11 +691,10 @@ void PairAnalysisHistos::Draw(const Option_t* option) {
TString canvasName;
canvasName.Form("c%s_%s", GetName(), classTable->GetName());
c = (TCanvas*) gROOT->FindObject(canvasName.Data());
- if (!c)
- c = new TCanvas(canvasName.Data(),
- Form("%s: %s", GetName(), classTable->GetName()));
+ if (!c) c = new TCanvas(canvasName.Data(), Form("%s: %s", GetName(), classTable->GetName()));
c->Clear();
- } else {
+ }
+ else {
// if (first){
// first=kFALSE;
// if (nPads>1) gVirtualPS->NewPage();
@@ -780,18 +712,9 @@ void PairAnalysisHistos::Draw(const Option_t* option) {
TString drawOpt;
if ((h->InheritsFrom(TH2::Class()))) drawOpt = "colz";
if (nCols > 1 || nRows > 1) c->cd(++iPad);
- if (TMath::Abs(h->GetXaxis()->GetBinWidth(1)
- - h->GetXaxis()->GetBinWidth(2))
- > 1e-10)
- gPad->SetLogx();
- if (TMath::Abs(h->GetYaxis()->GetBinWidth(1)
- - h->GetYaxis()->GetBinWidth(2))
- > 1e-10)
- gPad->SetLogy();
- if (TMath::Abs(h->GetZaxis()->GetBinWidth(1)
- - h->GetZaxis()->GetBinWidth(2))
- > 1e-10)
- gPad->SetLogz();
+ if (TMath::Abs(h->GetXaxis()->GetBinWidth(1) - h->GetXaxis()->GetBinWidth(2)) > 1e-10) gPad->SetLogx();
+ if (TMath::Abs(h->GetYaxis()->GetBinWidth(1) - h->GetYaxis()->GetBinWidth(2)) > 1e-10) gPad->SetLogy();
+ if (TMath::Abs(h->GetZaxis()->GetBinWidth(1) - h->GetZaxis()->GetBinWidth(2)) > 1e-10) gPad->SetLogz();
TString histOpt = h->GetOption();
histOpt.ToLower();
if (histOpt.Contains("logx")) gPad->SetLogx();
@@ -808,7 +731,8 @@ void PairAnalysisHistos::Draw(const Option_t* option) {
}
//_____________________________________________________________________________
-void PairAnalysisHistos::Print(const Option_t* option) const {
+void PairAnalysisHistos::Print(const Option_t* option) const
+{
//
// Print classes and histograms
//
@@ -818,7 +742,8 @@ void PairAnalysisHistos::Print(const Option_t* option) const {
}
//_____________________________________________________________________________
-void PairAnalysisHistos::PrintStructure() const {
+void PairAnalysisHistos::PrintStructure() const
+{
//
// Print classes and histograms in the class to stdout
//
@@ -832,7 +757,8 @@ void PairAnalysisHistos::PrintStructure() const {
while ((o = nextHist()))
Printf("| ->%s\n", o->GetName());
}
- } else {
+ }
+ else {
TIter nextCutClass(fList);
THashList* cutClass = 0x0;
while ((cutClass = (THashList*) nextCutClass())) {
@@ -853,8 +779,8 @@ void PairAnalysisHistos::PrintStructure() const {
}
//_____________________________________________________________________________
-void PairAnalysisHistos::SetHistogramList(THashList& list,
- Bool_t setOwner /*=kTRUE*/) {
+void PairAnalysisHistos::SetHistogramList(THashList& list, Bool_t setOwner /*=kTRUE*/)
+{
//
// set histogram classes and histograms to this instance. It will take onwnership!
//
@@ -871,14 +797,16 @@ void PairAnalysisHistos::SetHistogramList(THashList& list,
list.SetOwner(kFALSE);
fHistoList.SetOwner(kTRUE);
fHistoList.SetName(list.GetName());
- } else {
+ }
+ else {
fHistoList.SetOwner(kFALSE);
fHistoList.SetName(list.GetName());
}
}
//_____________________________________________________________________________
-Bool_t PairAnalysisHistos::SetCutClass(const char* cutClass) {
+Bool_t PairAnalysisHistos::SetCutClass(const char* cutClass)
+{
//
// Assign histogram list according to cutClass
//
@@ -894,8 +822,8 @@ Bool_t PairAnalysisHistos::SetCutClass(const char* cutClass) {
return kTRUE;
}
//_____________________________________________________________________________
-Bool_t PairAnalysisHistos::IsHistogramOk(const char* histClass,
- const char* name) {
+Bool_t PairAnalysisHistos::IsHistogramOk(const char* histClass, const char* name)
+{
//
// check whether the histogram class exists and the histogram itself does not exist yet
//
@@ -908,10 +836,7 @@ Bool_t PairAnalysisHistos::IsHistogramOk(const char* histClass,
return kFALSE;
}
if (GetHist(histClass, name)) {
- Warning("IsHistogramOk",
- "Cannot create histogram '%s' in class '%s': It already exists!",
- name,
- histClass);
+ Warning("IsHistogramOk", "Cannot create histogram '%s' in class '%s': It already exists!", name, histClass);
return kFALSE;
}
return kTRUE;
@@ -927,9 +852,8 @@ Bool_t PairAnalysisHistos::IsHistogramOk(const char* histClass,
// }
//_____________________________________________________________________________
-void PairAnalysisHistos::ReadFromFile(const char* file,
- const char* task,
- const char* config) {
+void PairAnalysisHistos::ReadFromFile(const char* file, const char* task, const char* config)
+{
//
// Read histos from file
//
@@ -941,16 +865,14 @@ void PairAnalysisHistos::ReadFromFile(const char* file,
// check for meta data
if (name.Contains(Form("PairAnalysisMetaData_%s", task))) {
fMetaData = new PairAnalysisMetaData();
- fMetaData->SetMetaData(*dynamic_cast<TList*>(f.Get(key->GetName())),
- kFALSE);
+ fMetaData->SetMetaData(*dynamic_cast<TList*>(f.Get(key->GetName())), kFALSE);
}
// check for histos
if (!name.Contains(Form("PairAnalysisHistos_%s", task))) continue;
if (!strlen(task) && !name.Contains(task)) continue;
TObject* o = f.Get(key->GetName());
TList* list = dynamic_cast<TList*>(o);
- if (!list)
- continue;
+ if (!list) continue;
else
fList = list;
THashList* listCfg = dynamic_cast<THashList*>(list->FindObject(config));
@@ -964,10 +886,8 @@ void PairAnalysisHistos::ReadFromFile(const char* file,
}
//_____________________________________________________________________________
-TObjArray* PairAnalysisHistos::DrawTaskSame(TString histName,
- TString opt,
- TString histClassDenom,
- TString taskDenom) {
+TObjArray* PairAnalysisHistos::DrawTaskSame(TString histName, TString opt, TString histClassDenom, TString taskDenom)
+{
///
/// Draw histograms of different tasks into the same canvas
///
@@ -1013,15 +933,13 @@ TObjArray* PairAnalysisHistos::DrawTaskSame(TString histName,
/// find cut step lists if option 'cutstep' is active
if (optCutStep) {
- TString cutstepTask = fHistoList.GetName();
- THashList* listCutStep =
- dynamic_cast<THashList*>(fList->FindObject(cutstepTask));
+ TString cutstepTask = fHistoList.GetName();
+ THashList* listCutStep = dynamic_cast<THashList*>(fList->FindObject(cutstepTask));
if (listCutStep) fList = listCutStep;
}
/// find denominator list 'taskDenom'
- THashList* listDenom =
- dynamic_cast<THashList*>(fList->FindObject(taskDenom.Data()));
+ THashList* listDenom = dynamic_cast<THashList*>(fList->FindObject(taskDenom.Data()));
if (listDenom) opt += "div";
/// iterate over all tasks and their lists in the file
@@ -1050,8 +968,7 @@ TObjArray* PairAnalysisHistos::DrawTaskSame(TString histName,
/// check if selection string contains reserved word
/// if true ignore it for config selection
for (Int_t ir = 0; ir < reservedWords->GetEntriesFast(); ir++) {
- testIgnore =
- raw.Contains(((TObjString*) reservedWords->At(ir))->GetString());
+ testIgnore = raw.Contains(((TObjString*) reservedWords->At(ir))->GetString());
if (testIgnore) break;
}
if (testIgnore) continue;
@@ -1091,8 +1008,7 @@ TObjArray* PairAnalysisHistos::DrawTaskSame(TString histName,
/// adapt name for legend
SetName(listCfg->GetName());
- arr->AddAll(
- DrawSame(histName, (opt + "task").Data(), histClassDenom, listDenom));
+ arr->AddAll(DrawSame(histName, (opt + "task").Data(), histClassDenom, listDenom));
}
/// set legend name
@@ -1111,12 +1027,10 @@ TObjArray* PairAnalysisHistos::DrawTaskSame(TString histName,
lent->SetLabel(lst.Data());
}
- if (!legendname.EqualTo("none"))
- leg->SetHeader("");
+ if (!legendname.EqualTo("none")) leg->SetHeader("");
else
leg->SetHeader(legendname.Data());
- PairAnalysisStyler::SetLegendAttributes(
- leg); // coordinates, margins, fillstyle, fontsize
+ PairAnalysisStyler::SetLegendAttributes(leg); // coordinates, margins, fillstyle, fontsize
leg->Draw();
}
@@ -1129,10 +1043,8 @@ TObjArray* PairAnalysisHistos::DrawTaskSame(TString histName,
}
//_____________________________________________________________________________
-TObjArray* PairAnalysisHistos::DrawSame(TString histName,
- TString option,
- TString histClassDenom,
- THashList* listDenom) {
+TObjArray* PairAnalysisHistos::DrawSame(TString histName, TString option, TString histClassDenom, THashList* listDenom)
+{
///
/// Draw histograms with the same histName into a canvas
///
@@ -1184,10 +1096,7 @@ TObjArray* PairAnalysisHistos::DrawSame(TString histName,
optString.ToLower();
printf("Plot hist: '%s' class-denom/sel: '%s' \t listDenom: '%s' \t options: "
"'%s' \n",
- histName.Data(),
- histClassDenom.Data(),
- (listDenom ? listDenom->GetName() : ""),
- optString.Data());
+ histName.Data(), histClassDenom.Data(), (listDenom ? listDenom->GetName() : ""), optString.Data());
Bool_t optBack = optString.Contains("back");
optString.ReplaceAll("back", "");
Bool_t optGoff = optString.Contains("goff");
@@ -1270,8 +1179,7 @@ TObjArray* PairAnalysisHistos::DrawSame(TString histName,
/// set rebinning
Int_t rbn = 2;
if (optRbn) {
- TString rebin(
- optString(optString.Index("rebin", 5, 0, TString::kExact) + 5));
+ TString rebin(optString(optString.Index("rebin", 5, 0, TString::kExact) + 5));
if (rebin.IsDigit()) {
rbn = rebin.Atoi();
optString.ReplaceAll(rebin, "");
@@ -1283,10 +1191,8 @@ TObjArray* PairAnalysisHistos::DrawSame(TString histName,
TArrayD* limits = NULL;
Double_t stat = 0.8;
if (optRbnStat) {
- TString rebin(
- optString(optString.Index("stat", 4, 0, TString::kExact) + 4, 4));
- if (!rebin.IsFloat())
- rebin = optString(optString.Index("stat", 4, 0, TString::kExact) + 4, 3);
+ TString rebin(optString(optString.Index("stat", 4, 0, TString::kExact) + 4, 4));
+ if (!rebin.IsFloat()) rebin = optString(optString.Index("stat", 4, 0, TString::kExact) + 4, 3);
if (rebin.IsFloat()) {
stat = rebin.Atof();
// printf("rebinstat string: '%s' -> %f\n",rebin.Data(),stat);
@@ -1298,8 +1204,7 @@ TObjArray* PairAnalysisHistos::DrawSame(TString histName,
/// set smoothing
Int_t smth = 1;
if (optSmooth) {
- TString smooth(
- optString(optString.Index("smooth", 6, 0, TString::kExact) + 6));
+ TString smooth(optString(optString.Index("smooth", 6, 0, TString::kExact) + 6));
if (smooth.IsDigit()) {
smth = smooth.Atoi();
optString.ReplaceAll(smooth, "");
@@ -1326,7 +1231,8 @@ TObjArray* PairAnalysisHistos::DrawSame(TString histName,
Warning("DrawSame", "Clear existing array %s", GetName());
arr->ls();
arr->Clear();
- } else
+ }
+ else
arr = new TObjArray();
// arr->SetName(Form("%s",histName.Data()));
arr->SetName(GetName());
@@ -1343,10 +1249,7 @@ TObjArray* PairAnalysisHistos::DrawSame(TString histName,
TCanvas* c = 0;
if (optCan) {
c = (TCanvas*) gROOT->FindObject(Form("c%s", histName.Data()));
- if (!c) {
- c = new TCanvas(Form("c%s", histName.Data()),
- Form("All '%s' histograms", histName.Data()));
- }
+ if (!c) { c = new TCanvas(Form("c%s", histName.Data()), Form("All '%s' histograms", histName.Data())); }
// c->Clear();
c->cd();
}
@@ -1371,11 +1274,10 @@ TObjArray* PairAnalysisHistos::DrawSame(TString histName,
leg = new TLegend(0. + gPad->GetLeftMargin() + gStyle->GetTickLength("Y"),
0. + gPad->GetBottomMargin() + gStyle->GetTickLength("X"),
1. - gPad->GetRightMargin() + gStyle->GetTickLength("Y"),
- 1. - gPad->GetTopMargin() + gStyle->GetTickLength("X"),
- GetName(),
- "nbNDC");
+ 1. - gPad->GetTopMargin() + gStyle->GetTickLength("X"), GetName(), "nbNDC");
if (optTask && !optCutStep) leg->SetHeader("");
- } else if (nobj) {
+ }
+ else if (nobj) {
leg = (TLegend*) prim->FindObject("TPave");
// leg->SetX1(0. + gPad->GetLeftMargin() + gStyle->GetTickLength("Y"));
// leg->SetY1(0. + gPad->GetBottomMargin()+ gStyle->GetTickLength("X"));
@@ -1412,15 +1314,10 @@ TObjArray* PairAnalysisHistos::DrawSame(TString histName,
Info("DrawSame",
"Search for hist: '%s' class-denom: '%s' select: '%s' \t ndel: %d \t "
"for class: '%s'",
- histName.Data(),
- histClassDenom.Data(),
- select.Data(),
- ndel,
- histClass.Data());
+ histName.Data(), histClassDenom.Data(), select.Data(), ndel, histClass.Data());
/// check selections done via MC options 'onlyMC', 'noMC', 'noMCtrue', 'eff'
- if ((optNoMC && ndel > 0) || (optEff && ndel < 1)
- || (optNoMCtrue && histClass.Contains("_MCtruth"))
+ if ((optNoMC && ndel > 0) || (optEff && ndel < 1) || (optNoMCtrue && histClass.Contains("_MCtruth"))
|| (optOnlyMC && ndel < 1) || (optOnlyMCtrue && ndel < 2))
continue;
@@ -1433,12 +1330,10 @@ TObjArray* PairAnalysisHistos::DrawSame(TString histName,
srch.ReplaceAll("!", "");
Bool_t optExclSel = !(srch.EqualTo(raw)); // exclude or not
/// decision
- if (!(!histClass.Contains(srch, TString::kIgnoreCase)) ^ (optExclSel))
- pass = kTRUE;
+ if (!(!histClass.Contains(srch, TString::kIgnoreCase)) ^ (optExclSel)) pass = kTRUE;
/// exact string found - direct decision (ignore other selections)
if (histClass.EqualTo(srch, TString::kIgnoreCase)) {
- pass =
- !(!histClass.EqualTo(srch, TString::kIgnoreCase)) ^ (optExclSel);
+ pass = !(!histClass.EqualTo(srch, TString::kIgnoreCase)) ^ (optExclSel);
break;
}
}
@@ -1458,17 +1353,12 @@ TObjArray* PairAnalysisHistos::DrawSame(TString histName,
if (h->GetEntries() < 1.) continue;
/// get histClassDenom for efficiency caluclation, e.g. the MCtruth (denominator)
- if (optEff && !histClass.Contains("_MCtruth"))
- histClassDenom = histClass + "_MCtruth";
- Info("DrawSame",
- " Hist found in histClass '%s' (search for denom '%s') ",
- histClass.Data(),
- histClassDenom.Data());
+ if (optEff && !histClass.Contains("_MCtruth")) histClassDenom = histClass + "_MCtruth";
+ Info("DrawSame", " Hist found in histClass '%s' (search for denom '%s') ", histClass.Data(), histClassDenom.Data());
/// check if 'ratio' or 'eff' should be build
if ((optEff || optRatio) /*&& !optTask*/
- && (histClass.EqualTo(histClassDenom)
- || !fHistoList.FindObject(histClassDenom.Data())))
+ && (histClass.EqualTo(histClassDenom) || !fHistoList.FindObject(histClassDenom.Data())))
continue; /// TODO: why '!optTask' was needed?
else if (!histClassDenom.IsNull())
Info("DrawSame", " Denom histClass '%s' found ", histClassDenom.Data());
@@ -1478,37 +1368,28 @@ TObjArray* PairAnalysisHistos::DrawSame(TString histName,
/// print normalisation option
if (optRbn || optRbnStat)
- Info("DrawSame",
- " Rebin by %d, to <%.1f%% stat. uncertainty per bin",
- (optRbn ? rbn : 0),
+ Info("DrawSame", " Rebin by %d, to <%.1f%% stat. uncertainty per bin", (optRbn ? rbn : 0),
(optRbnStat ? stat * 100 : 0));
if (optNormY || optNorm || optEvt)
- Info("DrawSame",
- " Normalize in y-axis,2D's only(%d), by int.(%d), by #events(%d)",
- optNormY,
- optNorm,
- optEvt);
+ Info("DrawSame", " Normalize in y-axis,2D's only(%d), by int.(%d), by #events(%d)", optNormY, optNorm, optEvt);
if (optSclMax) Info("DrawSame", " Scale to maximum(%d)", optSclMax);
if (optCum)
Info("DrawSame",
" Cumulate sum of bins along x-axis, 1D's left-to-right(%d), "
"right-to-left(%d)",
- !optCumR,
- optCumR);
+ !optCumR, optCumR);
/// rebin, normalize, cumulate and scale spectra according to options 'rebinX','rebinStat','norm','normY','cum','cumR','events','sclMax'
h->Sumw2();
- if (optRbn && h->InheritsFrom(TH2::Class()))
- h = ((TH2*) h)->RebinX(rbn, h->GetName());
+ if (optRbn && h->InheritsFrom(TH2::Class())) h = ((TH2*) h)->RebinX(rbn, h->GetName());
else if (optRbn)
h->Rebin(rbn);
- if (optNormY && h->GetDimension() == 2 && !(h->GetSumOfWeights() == 0)
- && !optCum)
+ if (optNormY && h->GetDimension() == 2 && !(h->GetSumOfWeights() == 0) && !optCum)
PairAnalysisHelper::NormalizeSlicesY((TH2*) h);
if (optRbnStat && h->GetDimension() == 1) {
/// rebin until stat. uncertainty is lower than 'stat'
limits = PairAnalysisHelper::MakeStatBinLimits(h, stat);
- h = h->Rebin(limits->GetSize() - 1, h->GetName(), limits->GetArray());
+ h = h->Rebin(limits->GetSize() - 1, h->GetName(), limits->GetArray());
h->Scale(1., "width");
// delete limits;
}
@@ -1521,8 +1402,7 @@ TObjArray* PairAnalysisHistos::DrawSame(TString histName,
if (ytitle.Contains("{evt}")) optEvt = kFALSE;
if (optNorm && !(h->GetSumOfWeights() == 0) && !optCum)
- h = h->DrawNormalized(i > 0 ? (optString + "same").Data()
- : optString.Data());
+ h = h->DrawNormalized(i > 0 ? (optString + "same").Data() : optString.Data());
if (optEvt) h->Scale(1. / events);
if (optSclMax) h->Scale(1. / h->GetBinContent(h->GetMaximumBin()));
@@ -1550,33 +1430,23 @@ TObjArray* PairAnalysisHistos::DrawSame(TString histName,
/// Calculate ratios and Draw histograms
if ((optEff || optRatio) && !optNorm && !optEvt && !optTask) {
- Info("DrawSame",
- " Calculate '%s' w/o normalisation and within the same task",
- (optEff ? "efficiency" : "ratio"));
+ Info("DrawSame", " Calculate '%s' w/o normalisation and within the same task", (optEff ? "efficiency" : "ratio"));
// TString clMC = histClass+"_MCtruth";
- THashList* clDenom =
- (THashList*) fHistoList.FindObject(histClassDenom.Data());
- TH1* hMC =
- (TH1*)
- h->Clone(); // needed to preserve the labeling of non-mc histogram
+ THashList* clDenom = (THashList*) fHistoList.FindObject(histClassDenom.Data());
+ TH1* hMC = (TH1*) h->Clone(); // needed to preserve the labeling of non-mc histogram
TString histdenomMC = UserHistogram(histClassDenom.Data(), hMC);
TH1* hdenom = (TH1*) clDenom->FindObject(histdenomMC.Data());
if (!hdenom) {
Error("DrawSame", "Denominator object not found");
continue;
}
- Info("DrawSame",
- " Divide %s(#=%.3e) by %s(#=%.3e)",
- h->GetName(),
- h->GetEntries(),
- hdenom->GetName(),
+ Info("DrawSame", " Divide %s(#=%.3e) by %s(#=%.3e)", h->GetName(), h->GetEntries(), hdenom->GetName(),
hdenom->GetEntries());
delete hMC; //delete the surplus object
// normalize and rebin only once
hdenom->Sumw2(); //why is it crashing here
if (optRbnStat && (optEff || !(i % 10))) {
- hdenom = hdenom->Rebin(
- limits->GetSize() - 1, hdenom->GetName(), limits->GetArray());
+ hdenom = hdenom->Rebin(limits->GetSize() - 1, hdenom->GetName(), limits->GetArray());
hdenom->Scale(1., "width");
}
if (optRbn && (optEff || !(i % 10))) hdenom->RebinX(rbn);
@@ -1585,39 +1455,31 @@ TObjArray* PairAnalysisHistos::DrawSame(TString histName,
Warning("DrawSame(eff/ratio)", "Division failed!!!!");
continue;
}
- } else if (optTask && (optDiv || optEff || optRatio)) {
- Info("DrawSame",
- " Calculate '%s' using different tasks",
+ }
+ else if (optTask && (optDiv || optEff || optRatio)) {
+ Info("DrawSame", " Calculate '%s' using different tasks",
(optEff ? "efficiency" : (optRatio ? "ratio" : "divison")));
// denominators
TH1* hdenom = 0x0;
TH1* htden = 0x0;
if (optEff || optRatio) {
- THashList* clDenom =
- (THashList*) fHistoList.FindObject(histClassDenom.Data());
- TH1* hMC =
- (TH1*)
- h->Clone(); // needed to preserve the labeling of non-mc histogram
+ THashList* clDenom = (THashList*) fHistoList.FindObject(histClassDenom.Data());
+ TH1* hMC = (TH1*) h->Clone(); // needed to preserve the labeling of non-mc histogram
TString histdenomMC = UserHistogram(histClassDenom.Data(), hMC);
//delete the surplus object
delete hMC;
- if (clDenom) {
- hdenom = (TH1*) clDenom->FindObject(histdenomMC.Data());
- }
+ if (clDenom) { hdenom = (TH1*) clDenom->FindObject(histdenomMC.Data()); }
if (listDenom) {
- THashList* clTaskDen =
- (THashList*) listDenom->FindObject(histClassDenom.Data());
+ THashList* clTaskDen = (THashList*) listDenom->FindObject(histClassDenom.Data());
if (clTaskDen) {
// htden=(TH1*)clTaskDen->FindObject(hdenom->GetName());
htden = (TH1*) clTaskDen->FindObject(histdenomMC.Data());
Info("DrawSame",
"calculate eff/ratio using task-denom: '%s' class-denom: '%s' "
"hist-denom: '%s'",
- listDenom->GetName(),
- histClassDenom.Data(),
- histdenomMC.Data());
+ listDenom->GetName(), histClassDenom.Data(), histdenomMC.Data());
// keep only one of them, otherwise you might divide the same objects twice
if (htden) hdenom = 0x0;
}
@@ -1629,12 +1491,8 @@ TObjArray* PairAnalysisHistos::DrawSame(TString histName,
// task ratio
TH1* htnom = 0x0;
if (optDiv && !optEff) {
- Info("DrawSame",
- " Search for '%s' in task '%s'",
- histClass.Data(),
- listDenom->GetName());
- THashList* clTaskNom =
- (THashList*) listDenom->FindObject(histClass.Data());
+ Info("DrawSame", " Search for '%s' in task '%s'", histClass.Data(), listDenom->GetName());
+ THashList* clTaskNom = (THashList*) listDenom->FindObject(histClass.Data());
if (!clTaskNom) continue;
htnom = (TH1*) clTaskNom->FindObject(histName.Data());
if (!htnom) continue;
@@ -1658,18 +1516,15 @@ TObjArray* PairAnalysisHistos::DrawSame(TString histName,
}
if (optRbnStat) {
if (hdenom && nbinsd > nbinsh) {
- hdenom = hdenom->Rebin(
- limits->GetSize() - 1, hdenom->GetName(), limits->GetArray());
+ hdenom = hdenom->Rebin(limits->GetSize() - 1, hdenom->GetName(), limits->GetArray());
hdenom->Scale(1., "width");
}
if (htden && nbinstd > nbinsh) {
- htden = htden->Rebin(
- limits->GetSize() - 1, htden->GetName(), limits->GetArray());
+ htden = htden->Rebin(limits->GetSize() - 1, htden->GetName(), limits->GetArray());
htden->Scale(1., "width");
}
if (htnom && nbinstn > nbinsh) {
- htnom = htnom->Rebin(
- limits->GetSize() - 1, htnom->GetName(), limits->GetArray());
+ htnom = htnom->Rebin(limits->GetSize() - 1, htnom->GetName(), limits->GetArray());
htnom->Scale(1., "width");
}
}
@@ -1684,14 +1539,8 @@ TObjArray* PairAnalysisHistos::DrawSame(TString histName,
" Use nominator (%p,#=%.3e) and denominator 'same task & different "
"class'(%p,#=%.3e), 'certain task & different class'(%p,#=%.3e), "
"'certain task & same class'(%p,#=%.3e)",
- h,
- h->GetEntries(),
- hdenom,
- (hdenom ? hdenom->GetEntries() : 0),
- htden,
- (htden ? htden->GetEntries() : 0),
- htnom,
- (htnom ? htnom->GetEntries() : 0));
+ h, h->GetEntries(), hdenom, (hdenom ? hdenom->GetEntries() : 0), htden, (htden ? htden->GetEntries() : 0),
+ htnom, (htnom ? htnom->GetEntries() : 0));
// Printf("h %p (bins%d) \t hdenom %p (bins%d) \t htdenom %p (bins%d) \t htnom %p (bins%d)",
// h,h->GetNbinsX(),hdenom,(hdenom?hdenom->GetNbinsX():0),
// htden,(htden?htden->GetNbinsX():0),htnom,(htnom?htnom->GetNbinsX():0));
@@ -1700,14 +1549,16 @@ TObjArray* PairAnalysisHistos::DrawSame(TString histName,
if (hdenom && !h->Divide(hdenom)) {
Warning("DrawSame(eff/ratio)", "h & denom division failed!!!!");
continue;
- } else if (htden && htnom && !i && !htnom->Divide(htden)) {
- Warning("DrawSame(eff/ratio)",
- "task-nom/task-denom division failed!!!!");
+ }
+ else if (htden && htnom && !i && !htnom->Divide(htden)) {
+ Warning("DrawSame(eff/ratio)", "task-nom/task-denom division failed!!!!");
continue;
- } else if (optDiv && htnom && !h->Divide(htnom)) {
+ }
+ else if (optDiv && htnom && !h->Divide(htnom)) {
Warning("DrawSame(eff/ratio)", "h & task-nom division failed!!!!");
continue;
- } else if (htden && !h->Divide(htden)) {
+ }
+ else if (htden && !h->Divide(htden)) {
Warning("DrawSame(eff/ratio)", "h & task-denom division failed!!!!");
continue;
}
@@ -1722,9 +1573,7 @@ TObjArray* PairAnalysisHistos::DrawSame(TString histName,
Info("DrawSame", " Scale by 1/content");
TH1* hOne = (TH1*) h->Clone("one");
hOne->Reset("ICSE");
- for (Int_t ib = 0; ib < (h->GetNbinsX() + 2) * (h->GetNbinsY() + 2)
- * (h->GetNbinsZ() + 2);
- ib++)
+ for (Int_t ib = 0; ib < (h->GetNbinsX() + 2) * (h->GetNbinsY() + 2) * (h->GetNbinsZ() + 2); ib++)
hOne->SetBinContent(ib, 1.);
if (hOne->Divide(h)) h = hOne;
}
@@ -1743,8 +1592,7 @@ TObjArray* PairAnalysisHistos::DrawSame(TString histName,
/// style histograms if not done before
/// take into account reset style option 'RstSty'
- if (h->GetLineColor() == kBlack
- && !optString.Contains("col")) { // avoid color updates
+ if (h->GetLineColor() == kBlack && !optString.Contains("col")) { // avoid color updates
h->UseCurrentStyle();
PairAnalysisStyler::Style(h, i - (optRstSty ? nobj : 0));
}
@@ -1762,23 +1610,20 @@ TObjArray* PairAnalysisHistos::DrawSame(TString histName,
if (optGoff) {
if (optTask) h->SetTitle(Form("%s %s", GetName(), h->GetTitle()));
arr->Add(h);
- } else if (optStack) {
- if (!hs)
- hs = new THStack(
- "hs",
- Form(";%s;%s", h->GetXaxis()->GetTitle(), h->GetYaxis()->GetTitle()));
+ }
+ else if (optStack) {
+ if (!hs) hs = new THStack("hs", Form(";%s;%s", h->GetXaxis()->GetTitle(), h->GetYaxis()->GetTitle()));
hs->Add(h);
- } else {
+ }
+ else {
optString.ReplaceAll(" ", "");
Info("DrawSame", " Draw object with options: '%s'", optString.Data());
// h->Draw(i>0?(optString+"same").Data():optString.Data());
- if (!optSlicesY) {
- h->Draw(h != hFirst ? (optString + "same").Data() : optString.Data());
- } else if (h->GetDimension() == 2) {
+ if (!optSlicesY) { h->Draw(h != hFirst ? (optString + "same").Data() : optString.Data()); }
+ else if (h->GetDimension() == 2) {
// loop over all projections
for (Int_t bin = 1; bin < h->GetNbinsX(); bin++) {
- TH1* hp = ((TH2*) h)->ProjectionY(
- Form("%s_%d", h->GetName(), bin), bin, bin, "e");
+ TH1* hp = ((TH2*) h)->ProjectionY(Form("%s_%d", h->GetName(), bin), bin, bin, "e");
if (!hp) continue;
Long64_t nentries = Long64_t(hp->GetEntries());
if (nentries == 0) {
@@ -1790,8 +1635,7 @@ TObjArray* PairAnalysisHistos::DrawSame(TString histName,
if (optRbnStat) {
/// rebin until stat. uncertainty is lower than 'stat'
limits = PairAnalysisHelper::MakeStatBinLimits(hp, stat);
- hp = hp->Rebin(
- limits->GetSize() - 1, hp->GetName(), limits->GetArray());
+ hp = hp->Rebin(limits->GetSize() - 1, hp->GetName(), limits->GetArray());
hp->Scale(1., "width");
}
if (optCum) PairAnalysisHelper::Cumulate(hp, optCumR, optNorm);
@@ -1813,23 +1657,16 @@ TObjArray* PairAnalysisHistos::DrawSame(TString histName,
TObjArray* reservedWords = fReservedWords->Tokenize(":;");
for (Int_t ir = 0; ir < reservedWords->GetEntriesFast(); ir++) {
// printf("histClass %s \t search for %s \n",histClass.Data(),((TObjString*)reservedWords->At(ir))->GetString().Data());
- histClass.ReplaceAll(((TObjString*) reservedWords->At(ir))->GetString(),
- "");
- ratioName.ReplaceAll(((TObjString*) reservedWords->At(ir))->GetString(),
- "");
- divName.ReplaceAll(((TObjString*) reservedWords->At(ir))->GetString(),
- "");
+ histClass.ReplaceAll(((TObjString*) reservedWords->At(ir))->GetString(), "");
+ ratioName.ReplaceAll(((TObjString*) reservedWords->At(ir))->GetString(), "");
+ divName.ReplaceAll(((TObjString*) reservedWords->At(ir))->GetString(), "");
}
// change default signal names to titles
- for (Int_t isig = 0; isig < static_cast<Int_t>(
- PairAnalysisSignalMC::EDefinedSignal::kNSignals);
- isig++) {
+ for (Int_t isig = 0; isig < static_cast<Int_t>(PairAnalysisSignalMC::EDefinedSignal::kNSignals); isig++) {
TString src = PairAnalysisSignalMC::fgkSignals[isig][0];
TString rpl = PairAnalysisSignalMC::fgkSignals[isig][1];
// avoid mc signal in header AND leg-entry
- if (leg
- && (rpl.EqualTo(leg->GetHeader()) || src.EqualTo(leg->GetHeader())))
- rpl = "";
+ if (leg && (rpl.EqualTo(leg->GetHeader()) || src.EqualTo(leg->GetHeader()))) rpl = "";
histClass.ReplaceAll(src, rpl);
ratioName.ReplaceAll(src, rpl);
divName.ReplaceAll(src, rpl);
@@ -1837,21 +1674,16 @@ TObjArray* PairAnalysisHistos::DrawSame(TString histName,
// printf("histClass %s \n",histClass.Data());
// change MCtruth to MC
- for (Int_t isig = 0; isig < static_cast<Int_t>(
- PairAnalysisSignalMC::EDefinedSignal::kNSignals);
- isig++) {
+ for (Int_t isig = 0; isig < static_cast<Int_t>(PairAnalysisSignalMC::EDefinedSignal::kNSignals); isig++) {
histClass.ReplaceAll("MCtruth", "MC");
ratioName.ReplaceAll("MCtruth", "MC");
divName.ReplaceAll("MCtruth", "MC");
}
// remove pairing name if it is a MC
for (Int_t iptype = 0; iptype < PairAnalysis::fNTypes; iptype++) {
- if (ndel > 0)
- histClass.ReplaceAll(PairAnalysis::PairClassName(iptype), "");
- if (ratioName.CountChar('_') > 0)
- ratioName.ReplaceAll(PairAnalysis::PairClassName(iptype), "");
- if (divName.CountChar('_') > 0)
- divName.ReplaceAll(PairAnalysis::PairClassName(iptype), "");
+ if (ndel > 0) histClass.ReplaceAll(PairAnalysis::PairClassName(iptype), "");
+ if (ratioName.CountChar('_') > 0) ratioName.ReplaceAll(PairAnalysis::PairClassName(iptype), "");
+ if (divName.CountChar('_') > 0) divName.ReplaceAll(PairAnalysis::PairClassName(iptype), "");
}
// save Dalitz and Short underscore
histClass.ReplaceAll("_{Dalitz}", "#{Dalitz}");
@@ -1893,18 +1725,12 @@ TObjArray* PairAnalysisHistos::DrawSame(TString histName,
legOpt.ReplaceAll("z", "");
legOpt.ReplaceAll("e", "");
if (optTask) histClass.Prepend(Form("%s ", GetName()));
- if ((optTask && optCutStep && i) || (optStack && (i - nobj)))
- histClass.Prepend("+");
- if (optDiv && !optOneOver)
- histClass.ReplaceAll(GetName(),
- Form("%s/%s", GetName(), divName.Data()));
+ if ((optTask && optCutStep && i) || (optStack && (i - nobj))) histClass.Prepend("+");
+ if (optDiv && !optOneOver) histClass.ReplaceAll(GetName(), Form("%s/%s", GetName(), divName.Data()));
if (optDiv && optOneOver) histClass.Prepend(Form("%s/", divName.Data()));
if (optDet) {
- for (ECbmModuleId idet = ECbmModuleId::kRef;
- idet < ECbmModuleId::kNofSystems;
- ++idet) {
- if (histName.Contains(PairAnalysisHelper::GetDetName(idet)))
- histClass = PairAnalysisHelper::GetDetName(idet);
+ for (ECbmModuleId idet = ECbmModuleId::kRef; idet < ECbmModuleId::kNofSystems; ++idet) {
+ if (histName.Contains(PairAnalysisHelper::GetDetName(idet))) histClass = PairAnalysisHelper::GetDetName(idet);
}
}
// else if(nobj) histClass="";
@@ -1914,12 +1740,11 @@ TObjArray* PairAnalysisHistos::DrawSame(TString histName,
if (optRmsY) histClass += Form(" RMS(y)=%.2e", h->GetRMS(2));
histClass.ReplaceAll("e+00", "");
// no entry for colored plots
- if (optLeg && leg /*&& !legOpt.Contains("col")*/)
- leg->AddEntry(h, histClass.Data(), legOpt.Data());
+ if (optLeg && leg /*&& !legOpt.Contains("col")*/) leg->AddEntry(h, histClass.Data(), legOpt.Data());
// if (leg) leg->AddEntry(h,classTable->GetName(),(optString+"L").Data());
++i;
-
- } else if (nobj && leg)
+ }
+ else if (nobj && leg)
leg->AddEntry(hFirst, "", "");
//++i;
@@ -1933,8 +1758,7 @@ TObjArray* PairAnalysisHistos::DrawSame(TString histName,
/// draw stack histogram
if (optStack) {
optString.ReplaceAll(" ", "");
- Info(
- "DrawSame", " Draw stacked object with options: '%s'", optString.Data());
+ Info("DrawSame", " Draw stacked object with options: '%s'", optString.Data());
hs->Draw(nobj > 0 ? (optString + "same").Data() : optString.Data());
}
@@ -1955,8 +1779,7 @@ TObjArray* PairAnalysisHistos::DrawSame(TString histName,
if (obj->InheritsFrom(TH1::Class())) {
TH1* h1 = static_cast<TH1*>(obj);
- max = TMath::Max(
- max, PairAnalysisHelper::GetContentMaximum(h1)); //h1->GetMaximum();
+ max = TMath::Max(max, PairAnalysisHelper::GetContentMaximum(h1)); //h1->GetMaximum();
Double_t tmpmax = max * (gPad->GetLogy() ? 5. : 1.1);
if (optEff) tmpmax = 1.1;
h1->SetMaximum(tmpmax);
@@ -1981,8 +1804,7 @@ TObjArray* PairAnalysisHistos::DrawSame(TString histName,
/// automatically set log option labels
if (gPad->GetLogy()
- && (tmpmax / (tmpmin > 0. ? tmpmin : 1.)
- > TMath::Power(10., TGaxis::GetMaxDigits())
+ && (tmpmax / (tmpmin > 0. ? tmpmin : 1.) > TMath::Power(10., TGaxis::GetMaxDigits())
|| tmpmin < TMath::Power(10., -TGaxis::GetMaxDigits())
|| tmpmin > TMath::Power(10., +TGaxis::GetMaxDigits()))) {
// if(gPad->GetLogy() && tmpmax/(tmpmin>0.?tmpmin:1.) > TMath::Power(10.,TGaxis::GetMaxDigits())) {
@@ -1991,8 +1813,7 @@ TObjArray* PairAnalysisHistos::DrawSame(TString histName,
}
Double_t tmpXmin = h1->GetXaxis()->GetXmin();
if (gPad->GetLogx()
- && h1->GetXaxis()->GetXmax()
- / (TMath::Abs(tmpXmin) < 1.e-10 ? 1. : tmpXmin)
+ && h1->GetXaxis()->GetXmax() / (TMath::Abs(tmpXmin) < 1.e-10 ? 1. : tmpXmin)
> TMath::Power(10., TGaxis::GetMaxDigits())) {
// printf("Xaxis: max%f , min%f \t ratio %.3e >? %.3e \n",h1->GetXaxis()->GetXmax(),(TMath::Abs(tmpXmin)<1.e-10?1.:tmpXmin),
// h1->GetXaxis()->GetXmax()/(TMath::Abs(tmpXmin)<1.e-10?1.:tmpXmin),TMath::Power(10.,TGaxis::GetMaxDigits()));
@@ -2002,9 +1823,7 @@ TObjArray* PairAnalysisHistos::DrawSame(TString histName,
}
}
/// draw only once the default metadata if option 'meta' is active
- if (!nobj && optMeta && fMetaData && !gPad->GetPrimitive("meta")) {
- fMetaData->DrawSame("");
- }
+ if (!nobj && optMeta && fMetaData && !gPad->GetPrimitive("meta")) { fMetaData->DrawSame(""); }
/// force legend to be drawn always on top, remove multiple versions of it
/// they show up when one uses the 'task' draw option
@@ -2035,7 +1854,8 @@ TObjArray* PairAnalysisHistos::DrawSame(TString histName,
}
//_____________________________________________________________________________
-void PairAnalysisHistos::SetReservedWords(const char* words) {
+void PairAnalysisHistos::SetReservedWords(const char* words)
+{
//
// set reserved words
//
@@ -2044,13 +1864,13 @@ void PairAnalysisHistos::SetReservedWords(const char* words) {
}
//_____________________________________________________________________________
-void PairAnalysisHistos::StoreVariables(TObject* obj, UInt_t valType[20]) {
+void PairAnalysisHistos::StoreVariables(TObject* obj, UInt_t valType[20])
+{
//
//
//
if (!obj) return;
- if (obj->InheritsFrom(TH1::Class()))
- StoreVariables(static_cast<TH1*>(obj), valType);
+ if (obj->InheritsFrom(TH1::Class())) StoreVariables(static_cast<TH1*>(obj), valType);
else if (obj->InheritsFrom(THnBase::Class()))
StoreVariables(static_cast<THnBase*>(obj), valType);
@@ -2059,7 +1879,8 @@ void PairAnalysisHistos::StoreVariables(TObject* obj, UInt_t valType[20]) {
//_____________________________________________________________________________
-void PairAnalysisHistos::StoreVariables(TH1* obj, UInt_t valType[20]) {
+void PairAnalysisHistos::StoreVariables(TH1* obj, UInt_t valType[20])
+{
//
// store variables in the axis (special for TProfile3D)
//
@@ -2067,8 +1888,7 @@ void PairAnalysisHistos::StoreVariables(TH1* obj, UInt_t valType[20]) {
Int_t dim = obj->GetDimension();
// dimension correction for profiles
- if (obj->IsA() == TProfile::Class() || obj->IsA() == TProfile2D::Class()
- || obj->IsA() == TProfile3D::Class()) {
+ if (obj->IsA() == TProfile::Class() || obj->IsA() == TProfile2D::Class() || obj->IsA() == TProfile3D::Class()) {
dim++;
}
@@ -2082,7 +1902,8 @@ void PairAnalysisHistos::StoreVariables(TH1* obj, UInt_t valType[20]) {
}
//_____________________________________________________________________________
-void PairAnalysisHistos::StoreVariables(THnBase* obj, UInt_t valType[20]) {
+void PairAnalysisHistos::StoreVariables(THnBase* obj, UInt_t valType[20])
+{
//
// store variables in the axis
//
@@ -2091,32 +1912,28 @@ void PairAnalysisHistos::StoreVariables(THnBase* obj, UInt_t valType[20]) {
// check for formulas and skip the rest if needed
TList* list = obj->GetListOfFunctions();
- if (obj->IsA() == PairAnalysisHn::Class())
- list = (static_cast<PairAnalysisHn*>(obj))->GetListOfFunctions();
+ if (obj->IsA() == PairAnalysisHn::Class()) list = (static_cast<PairAnalysisHn*>(obj))->GetListOfFunctions();
if (list && list->Last()) return;
Int_t dim = obj->GetNdimensions();
for (Int_t it = 0; it < dim; it++) {
obj->GetAxis(it)->SetUniqueID(valType[it]);
- obj->GetAxis(it)->SetName(
- Form("%s", PairAnalysisVarManager::GetValueName(valType[it])));
- obj->GetAxis(it)->SetTitle(
- Form("%s %s",
- PairAnalysisVarManager::GetValueLabel(valType[it]),
- PairAnalysisVarManager::GetValueUnit(valType[it])));
+ obj->GetAxis(it)->SetName(Form("%s", PairAnalysisVarManager::GetValueName(valType[it])));
+ obj->GetAxis(it)->SetTitle(Form("%s %s", PairAnalysisVarManager::GetValueLabel(valType[it]),
+ PairAnalysisVarManager::GetValueUnit(valType[it])));
}
return;
}
//_____________________________________________________________________________
-void PairAnalysisHistos::FillValues(TObject* obj, const Double_t* values) {
+void PairAnalysisHistos::FillValues(TObject* obj, const Double_t* values)
+{
//
//
//
if (!obj) return;
- if (obj->InheritsFrom(TH1::Class()))
- FillValues(static_cast<TH1*>(obj), values);
+ if (obj->InheritsFrom(TH1::Class())) FillValues(static_cast<TH1*>(obj), values);
else if (obj->InheritsFrom(THnBase::Class()))
FillValues(static_cast<THnBase*>(obj), values);
@@ -2124,7 +1941,8 @@ void PairAnalysisHistos::FillValues(TObject* obj, const Double_t* values) {
}
//_____________________________________________________________________________
-void PairAnalysisHistos::FillValues(TH1* obj, const Double_t* values) {
+void PairAnalysisHistos::FillValues(TH1* obj, const Double_t* values)
+{
//
// fill values for TH1 inherted classes
//
@@ -2133,14 +1951,11 @@ void PairAnalysisHistos::FillValues(TH1* obj, const Double_t* values) {
Bool_t bprf = kFALSE;
// UInt_t nValues = (UInt_t) PairAnalysisVarManager::kNMaxValues;
UInt_t valueTypes = obj->GetUniqueID();
- if (valueTypes
- == static_cast<UInt_t>(PairAnalysisHistos::Eoption::kNoAutoFill))
- return;
+ if (valueTypes == static_cast<UInt_t>(PairAnalysisHistos::Eoption::kNoAutoFill)) return;
Bool_t weight = (valueTypes != static_cast<UInt_t>(Eoption::kNoWeights));
// check if tprofile
- if (obj->IsA() == TProfile::Class() || obj->IsA() == TProfile2D::Class()
- || obj->IsA() == TProfile3D::Class())
+ if (obj->IsA() == TProfile::Class() || obj->IsA() == TProfile2D::Class() || obj->IsA() == TProfile3D::Class())
bprf = kTRUE;
// TO BEAUTIFY: switch off manually weighting of profile3Ds
@@ -2159,20 +1974,16 @@ void PairAnalysisHistos::FillValues(TH1* obj, const Double_t* values) {
UInt_t value1 = obj->GetXaxis()->GetUniqueID();
UInt_t value2 = obj->GetYaxis()->GetUniqueID();
UInt_t value3 = obj->GetZaxis()->GetUniqueID();
- UInt_t value4 =
- obj->GetUniqueID(); // get weighting/profile var stored in the unique ID
+ UInt_t value4 = obj->GetUniqueID(); // get weighting/profile var stored in the unique ID
- Double_t fvals[4] = {
- values[value1], values[value2], values[value3], values[value4]};
+ Double_t fvals[4] = {values[value1], values[value2], values[value3], values[value4]};
// use formulas to update fill values
if (xform) fvals[0] = PairAnalysisHelper::EvalFormula(xform, values);
if (yform) fvals[1] = PairAnalysisHelper::EvalFormula(yform, values);
if (zform) fvals[2] = PairAnalysisHelper::EvalFormula(zform, values);
if (wform) fvals[3] = PairAnalysisHelper::EvalFormula(wform, values);
- if (pform)
- fvals[3] = PairAnalysisHelper::EvalFormula(
- pform, values); // weighting overwriting for Profile3D
+ if (pform) fvals[3] = PairAnalysisHelper::EvalFormula(pform, values); // weighting overwriting for Profile3D
/*
// ask for inclusive trigger map variables
@@ -2184,38 +1995,29 @@ void PairAnalysisHistos::FillValues(TH1* obj, const Double_t* values) {
*/
switch (dim) {
case 1:
- if (!bprf && !weight)
- obj->Fill(fvals[0]); // histograms
+ if (!bprf && !weight) obj->Fill(fvals[0]); // histograms
else if (!bprf && weight)
obj->Fill(fvals[0], fvals[3]); // weighted histograms
else if (bprf && !weight)
((TProfile*) obj)->Fill(fvals[0], fvals[1]); // profiles
else
- ((TProfile*) obj)
- ->Fill(fvals[0], fvals[1], fvals[3]); // weighted profiles
+ ((TProfile*) obj)->Fill(fvals[0], fvals[1], fvals[3]); // weighted profiles
break;
case 2:
- if (!bprf && !weight)
- obj->Fill(fvals[0], fvals[1]); // histograms
+ if (!bprf && !weight) obj->Fill(fvals[0], fvals[1]); // histograms
else if (!bprf && weight)
- ((TH2*) obj)
- ->Fill(fvals[0], fvals[1], fvals[3]); // weighted histograms
+ ((TH2*) obj)->Fill(fvals[0], fvals[1], fvals[3]); // weighted histograms
else if (bprf && !weight)
((TProfile2D*) obj)->Fill(fvals[0], fvals[1], fvals[2]); // profiles
else
- ((TProfile2D*) obj)
- ->Fill(fvals[0], fvals[1], fvals[2], fvals[3]); // weighted profiles
+ ((TProfile2D*) obj)->Fill(fvals[0], fvals[1], fvals[2], fvals[3]); // weighted profiles
break;
case 3:
- if (!bprf && !weight)
- ((TH3*) obj)->Fill(fvals[0], fvals[1], fvals[2]); // histograms
+ if (!bprf && !weight) ((TH3*) obj)->Fill(fvals[0], fvals[1], fvals[2]); // histograms
else if (!bprf && weight)
- ((TH3*) obj)
- ->Fill(
- fvals[0], fvals[1], fvals[2], fvals[3]); // weighted histograms
+ ((TH3*) obj)->Fill(fvals[0], fvals[1], fvals[2], fvals[3]); // weighted histograms
else if (bprf && !weight)
- ((TProfile3D*) obj)
- ->Fill(fvals[0], fvals[1], fvals[2], fvals[3]); // profiles
+ ((TProfile3D*) obj)->Fill(fvals[0], fvals[1], fvals[2], fvals[3]); // profiles
else
Printf(" WARNING: weighting NOT yet possible for TProfile3Ds !");
break;
@@ -2260,20 +2062,19 @@ void PairAnalysisHistos::FillValues(TH1* obj, const Double_t* values) {
}
//_____________________________________________________________________________
-void PairAnalysisHistos::FillValues(THnBase* obj, const Double_t* values) {
+void PairAnalysisHistos::FillValues(THnBase* obj, const Double_t* values)
+{
//
// fill values for THn inherted classes
//
// skip if manual filling
UInt_t value4 = obj->GetUniqueID(); // weighting variable if any
- if (value4 == static_cast<UInt_t>(PairAnalysisHistos::Eoption::kNoAutoFill))
- return;
+ if (value4 == static_cast<UInt_t>(PairAnalysisHistos::Eoption::kNoAutoFill)) return;
// check for formulas and skip the rest if needed
TList* list = obj->GetListOfFunctions();
- if (obj->IsA() == PairAnalysisHn::Class())
- list = (static_cast<PairAnalysisHn*>(obj))->GetListOfFunctions();
+ if (obj->IsA() == PairAnalysisHn::Class()) list = (static_cast<PairAnalysisHn*>(obj))->GetListOfFunctions();
Bool_t useFormulas = (list && list->Last());
// do weighting
@@ -2289,14 +2090,14 @@ void PairAnalysisHistos::FillValues(THnBase* obj, const Double_t* values) {
TString formName = Form("axis%dFormula", it);
TFormula* form = dynamic_cast<TFormula*>(list->FindObject(formName));
fill[it] = PairAnalysisHelper::EvalFormula(form, values);
- } else {
+ }
+ else {
fill[it] = values[obj->GetAxis(it)->GetUniqueID()];
}
}
// fill object
- if (!weight)
- obj->Fill(fill);
+ if (!weight) obj->Fill(fill);
else
obj->Fill(fill, values[value4]);
@@ -2304,7 +2105,8 @@ void PairAnalysisHistos::FillValues(THnBase* obj, const Double_t* values) {
}
//_____________________________________________________________________________
-void PairAnalysisHistos::FillVarArray(TObject* obj, UInt_t* valType) {
+void PairAnalysisHistos::FillVarArray(TObject* obj, UInt_t* valType)
+{
//
// extract variables stored in the axis (special for TProfile3D)
//
@@ -2316,10 +2118,9 @@ void PairAnalysisHistos::FillVarArray(TObject* obj, UInt_t* valType) {
valType[0] = ((TH1*) obj)->GetXaxis()->GetUniqueID();
valType[1] = ((TH1*) obj)->GetYaxis()->GetUniqueID();
valType[2] = ((TH1*) obj)->GetZaxis()->GetUniqueID();
- valType[3] =
- ((TH1*) obj)
- ->GetUniqueID(); // weighting(profile) var stored in unique ID
- } else if (obj->InheritsFrom(THnBase::Class())) {
+ valType[3] = ((TH1*) obj)->GetUniqueID(); // weighting(profile) var stored in unique ID
+ }
+ else if (obj->InheritsFrom(THnBase::Class())) {
for (Int_t it = 0; it < ((THn*) obj)->GetNdimensions(); it++)
valType[it] = ((THn*) obj)->GetAxis(it)->GetUniqueID();
}
@@ -2328,7 +2129,8 @@ void PairAnalysisHistos::FillVarArray(TObject* obj, UInt_t* valType) {
}
//_____________________________________________________________________________
-void PairAnalysisHistos::AdaptNameTitle(TH1* hist, const char* histClass) {
+void PairAnalysisHistos::AdaptNameTitle(TH1* hist, const char* histClass)
+{
//
// adapt name and title of the histogram
@@ -2348,8 +2150,7 @@ void PairAnalysisHistos::AdaptNameTitle(TH1* hist, const char* histClass) {
Bool_t bname = (currentName.IsNull());
Bool_t btitle = (currentTitle.IsNull());
Bool_t bprf = kFALSE;
- if (hist->IsA() == TProfile::Class() || hist->IsA() == TProfile2D::Class()
- || hist->IsA() == TProfile3D::Class())
+ if (hist->IsA() == TProfile::Class() || hist->IsA() == TProfile2D::Class() || hist->IsA() == TProfile3D::Class())
bprf = kTRUE;
// tprofile options
@@ -2376,11 +2177,8 @@ void PairAnalysisHistos::AdaptNameTitle(TH1* hist, const char* histClass) {
}
if (option.Contains("s", TString::kIgnoreCase)) bStdOpt = kFALSE;
if (pmin != pmax)
- calcrange = Form("#cbar_{%+.*f}^{%+.*f}",
- PairAnalysisHelper::GetPrecision(pmin),
- pmin,
- PairAnalysisHelper::GetPrecision(pmax),
- pmax);
+ calcrange = Form("#cbar_{%+.*f}^{%+.*f}", PairAnalysisHelper::GetPrecision(pmin), pmin,
+ PairAnalysisHelper::GetPrecision(pmax), pmax);
}
UInt_t varx = hist->GetXaxis()->GetUniqueID();
@@ -2398,43 +2196,21 @@ void PairAnalysisHistos::AdaptNameTitle(TH1* hist, const char* histClass) {
hist->GetYaxis()->SetName(PairAnalysisVarManager::GetValueName(vary));
hist->GetZaxis()->SetName(PairAnalysisVarManager::GetValueName(varz));
// adapt according to formula
- TFormula* xform = dynamic_cast<TFormula*>(
- hist->GetListOfFunctions()->FindObject("xFormula"));
- TFormula* yform = dynamic_cast<TFormula*>(
- hist->GetListOfFunctions()->FindObject("yFormula"));
- TFormula* zform = dynamic_cast<TFormula*>(
- hist->GetListOfFunctions()->FindObject("zFormula"));
- TFormula* wform = dynamic_cast<TFormula*>(
- hist->GetListOfFunctions()->FindObject("wFormula"));
- if (xform) {
- hist->GetXaxis()->SetName(
- PairAnalysisHelper::GetFormulaName(xform).Data());
- }
- if (yform) {
- hist->GetYaxis()->SetName(
- PairAnalysisHelper::GetFormulaName(yform).Data());
- }
- if (zform) {
- hist->GetZaxis()->SetName(
- PairAnalysisHelper::GetFormulaName(zform).Data());
- }
+ TFormula* xform = dynamic_cast<TFormula*>(hist->GetListOfFunctions()->FindObject("xFormula"));
+ TFormula* yform = dynamic_cast<TFormula*>(hist->GetListOfFunctions()->FindObject("yFormula"));
+ TFormula* zform = dynamic_cast<TFormula*>(hist->GetListOfFunctions()->FindObject("zFormula"));
+ TFormula* wform = dynamic_cast<TFormula*>(hist->GetListOfFunctions()->FindObject("wFormula"));
+ if (xform) { hist->GetXaxis()->SetName(PairAnalysisHelper::GetFormulaName(xform).Data()); }
+ if (yform) { hist->GetYaxis()->SetName(PairAnalysisHelper::GetFormulaName(yform).Data()); }
+ if (zform) { hist->GetZaxis()->SetName(PairAnalysisHelper::GetFormulaName(zform).Data()); }
/////// set TITLE
hist->GetXaxis()->SetTitle(PairAnalysisVarManager::GetValueLabel(varx));
hist->GetYaxis()->SetTitle(PairAnalysisVarManager::GetValueLabel(vary));
hist->GetZaxis()->SetTitle(PairAnalysisVarManager::GetValueLabel(varz));
// adapt according to formula
- if (xform) {
- hist->GetXaxis()->SetTitle(
- PairAnalysisHelper::GetFormulaTitle(xform).Data());
- }
- if (yform) {
- hist->GetYaxis()->SetTitle(
- PairAnalysisHelper::GetFormulaTitle(yform).Data());
- }
- if (zform) {
- hist->GetZaxis()->SetTitle(
- PairAnalysisHelper::GetFormulaTitle(zform).Data());
- }
+ if (xform) { hist->GetXaxis()->SetTitle(PairAnalysisHelper::GetFormulaTitle(xform).Data()); }
+ if (yform) { hist->GetYaxis()->SetTitle(PairAnalysisHelper::GetFormulaTitle(yform).Data()); }
+ if (zform) { hist->GetZaxis()->SetTitle(PairAnalysisHelper::GetFormulaTitle(zform).Data()); }
// profile axis
if (bprf && dim < 3) {
TAxis* ax = 0x0;
@@ -2450,17 +2226,11 @@ void PairAnalysisHistos::AdaptNameTitle(TH1* hist, const char* histClass) {
ax->SetTitle(tit.Data());
}
// append the units for all axes (except formula)
- tit = Form("%s %s",
- hist->GetXaxis()->GetTitle(),
- PairAnalysisVarManager::GetValueUnit(varx));
+ tit = Form("%s %s", hist->GetXaxis()->GetTitle(), PairAnalysisVarManager::GetValueUnit(varx));
if (!xform) hist->GetXaxis()->SetTitle(tit.Data());
- tit = Form("%s %s",
- hist->GetYaxis()->GetTitle(),
- PairAnalysisVarManager::GetValueUnit(vary));
+ tit = Form("%s %s", hist->GetYaxis()->GetTitle(), PairAnalysisVarManager::GetValueUnit(vary));
if (!yform) hist->GetYaxis()->SetTitle(tit.Data());
- tit = Form("%s %s",
- hist->GetZaxis()->GetTitle(),
- PairAnalysisVarManager::GetValueUnit(varz));
+ tit = Form("%s %s", hist->GetZaxis()->GetTitle(), PairAnalysisVarManager::GetValueUnit(varz));
if (!zform) hist->GetZaxis()->SetTitle(tit.Data());
// overwrite titles with hist class if needed
if (!bprf) {
@@ -2479,50 +2249,32 @@ void PairAnalysisHistos::AdaptNameTitle(TH1* hist, const char* histClass) {
}
// create an unique name
- TFormula* pform = dynamic_cast<TFormula*>(
- hist->GetListOfFunctions()->FindObject("pFormula"));
+ TFormula* pform = dynamic_cast<TFormula*>(hist->GetListOfFunctions()->FindObject("pFormula"));
if (bname) switch (dim) {
case 3:
currentName += Form("%s_", hist->GetXaxis()->GetName());
currentName += Form("%s_", hist->GetYaxis()->GetName());
currentName += Form("%s", hist->GetZaxis()->GetName());
if (bprf && !pform)
- currentName += Form("-%s%s",
- PairAnalysisVarManager::GetValueName(varp),
- (bStdOpt ? "avg" : "rms"));
+ currentName += Form("-%s%s", PairAnalysisVarManager::GetValueName(varp), (bStdOpt ? "avg" : "rms"));
else if (bprf)
- currentName +=
- Form("-%s%s",
- PairAnalysisHelper::GetFormulaName(pform).Data(),
- (bStdOpt ? "avg" : "rms"));
- if (weight && !bprf)
- currentName +=
- Form("-wght%s", PairAnalysisVarManager::GetValueName(varp));
+ currentName += Form("-%s%s", PairAnalysisHelper::GetFormulaName(pform).Data(), (bStdOpt ? "avg" : "rms"));
+ if (weight && !bprf) currentName += Form("-wght%s", PairAnalysisVarManager::GetValueName(varp));
break;
case 2:
currentName += Form("%s_", hist->GetXaxis()->GetName());
currentName += Form("%s", hist->GetYaxis()->GetName());
- if (bprf)
- currentName += Form(
- "-%s%s", hist->GetZaxis()->GetName(), (bStdOpt ? "avg" : "rms"));
- if (weight && !wform)
- currentName +=
- Form("-wght%s", PairAnalysisVarManager::GetValueName(varp));
+ if (bprf) currentName += Form("-%s%s", hist->GetZaxis()->GetName(), (bStdOpt ? "avg" : "rms"));
+ if (weight && !wform) currentName += Form("-wght%s", PairAnalysisVarManager::GetValueName(varp));
else if (weight && wform)
- currentName +=
- Form("-wght%s", PairAnalysisHelper::GetFormulaName(wform).Data());
+ currentName += Form("-wght%s", PairAnalysisHelper::GetFormulaName(wform).Data());
break;
case 1:
currentName += Form("%s", hist->GetXaxis()->GetName());
- if (bprf)
- currentName += Form(
- "-%s%s", hist->GetYaxis()->GetName(), (bStdOpt ? "avg" : "rms"));
- if (weight && !wform)
- currentName +=
- Form("-wght%s", PairAnalysisVarManager::GetValueName(varp));
+ if (bprf) currentName += Form("-%s%s", hist->GetYaxis()->GetName(), (bStdOpt ? "avg" : "rms"));
+ if (weight && !wform) currentName += Form("-wght%s", PairAnalysisVarManager::GetValueName(varp));
else if (weight && wform)
- currentName +=
- Form("-wght%s", PairAnalysisHelper::GetFormulaName(wform).Data());
+ currentName += Form("-wght%s", PairAnalysisHelper::GetFormulaName(wform).Data());
break;
}
// to differentiate btw. leg and pair histos
@@ -2534,7 +2286,8 @@ void PairAnalysisHistos::AdaptNameTitle(TH1* hist, const char* histClass) {
//_____________________________________________________________________________
-void PairAnalysisHistos::AdaptNameTitle(THnBase* hist, const char* histClass) {
+void PairAnalysisHistos::AdaptNameTitle(THnBase* hist, const char* histClass)
+{
//
// adapt name and title of the histogram
@@ -2563,11 +2316,9 @@ void PairAnalysisHistos::AdaptNameTitle(THnBase* hist, const char* histClass) {
for (Int_t it = 0; it < dim; it++) {
TString formName = Form("axis%dFormula", it);
TFormula* form = dynamic_cast<TFormula*>(list->FindObject(formName));
- hist->GetAxis(it)->SetName(
- PairAnalysisHelper::GetFormulaName(form).Data());
+ hist->GetAxis(it)->SetName(PairAnalysisHelper::GetFormulaName(form).Data());
// adapt according to formula
- hist->GetAxis(it)->SetTitle(
- PairAnalysisHelper::GetFormulaTitle(form).Data());
+ hist->GetAxis(it)->SetTitle(PairAnalysisHelper::GetFormulaTitle(form).Data());
}
}
diff --git a/analysis/PWGDIL/dielectron/papaframework/PairAnalysisHistos.h b/analysis/PWGDIL/dielectron/papaframework/PairAnalysisHistos.h
index 0f0c5d7db7df612057560a94088ae64242ea0d26..b4ed5fc460022667bd665bc797137e35f8bcefd2 100644
--- a/analysis/PWGDIL/dielectron/papaframework/PairAnalysisHistos.h
+++ b/analysis/PWGDIL/dielectron/papaframework/PairAnalysisHistos.h
@@ -25,7 +25,6 @@
#endif
#include <Rtypes.h>
-
#include <TNamed.h>
// #include <TCollection.h>
#include <TBits.h>
@@ -51,17 +50,15 @@ class PairAnalysisHn : public THnSparseF {
public:
TList* GetListOfFunctions() const { return fFunctions; }
inline PairAnalysisHn() : THnSparseF(), fFunctions(new TList) {}
- inline PairAnalysisHn(const char* name,
- const char* title,
- Int_t dim,
- const Int_t* nbins,
- const Double_t* xmin = 0,
- const Double_t* xmax = 0,
- Int_t chunksize = 1024 * 16)
+ inline PairAnalysisHn(const char* name, const char* title, Int_t dim, const Int_t* nbins, const Double_t* xmin = 0,
+ const Double_t* xmax = 0, Int_t chunksize = 1024 * 16)
: THnSparseF(name, title, dim, nbins, xmin, xmax, chunksize)
- , fFunctions(new TList) {}
+ , fFunctions(new TList)
+ {
+ }
- inline ~PairAnalysisHn() {
+ inline ~PairAnalysisHn()
+ {
if (fFunctions) {
fFunctions->SetBit(kInvalidObject);
TObject* obj = 0;
@@ -94,13 +91,18 @@ public:
PairAnalysisHistos(const char* name, const char* title);
virtual ~PairAnalysisHistos();
- enum class Eoption {
+ enum class Eoption
+ {
kNoAutoFill = 1000000000,
kNoProfile = 999,
kNoWeights = 998,
kNo = 997
};
- enum class Eprecision { kFloat = 0, kDouble };
+ enum class Eprecision
+ {
+ kFloat = 0,
+ kDouble
+ };
// functions for object creation
void SetPrecision(Eprecision precision) { fPrecision = precision; }
@@ -114,273 +116,109 @@ public:
static void StoreVariables(TH1* obj, UInt_t valType[20]);
static void StoreVariables(THnBase* obj, UInt_t valType[20]);
- void
- UserHistogram(const char* histClass,
- Int_t ndim,
- TObjArray* limits,
- UInt_t* vars,
- UInt_t valTypeW = static_cast<UInt_t>(Eoption::kNoWeights));
- void AddSparse(const char* histClass,
- Int_t ndim,
- TObjArray* limits,
- UInt_t* vars,
+ void UserHistogram(const char* histClass, Int_t ndim, TObjArray* limits, UInt_t* vars,
+ UInt_t valTypeW = static_cast<UInt_t>(Eoption::kNoWeights));
+ void AddSparse(const char* histClass, Int_t ndim, TObjArray* limits, UInt_t* vars,
UInt_t valTypeW = static_cast<UInt_t>(Eoption::kNoWeights));
- void AddSparse(const char* histClass,
- Int_t ndim,
- TObjArray* limits,
- TFormula** vars,
+ void AddSparse(const char* histClass, Int_t ndim, TObjArray* limits, TFormula** vars,
UInt_t valTypeW = static_cast<UInt_t>(Eoption::kNoWeights));
// templates
- template<typename valX,
- typename valY,
- typename valZ,
- typename valP,
- typename valW>
- TString UserObject(const char* histClass,
- const char* name,
- const char* title,
- const TVectorD* const binsX,
- valX valTypeX,
- const TVectorD* const binsY,
- valY valTypeY,
- const TVectorD* const binsZ,
- valZ valTypeZ,
- valP valTypeP,
- valW valTypeW,
- TString option);
+ template<typename valX, typename valY, typename valZ, typename valP, typename valW>
+ TString UserObject(const char* histClass, const char* name, const char* title, const TVectorD* const binsX,
+ valX valTypeX, const TVectorD* const binsY, valY valTypeY, const TVectorD* const binsZ,
+ valZ valTypeZ, valP valTypeP, valW valTypeW, TString option);
// 1D
template<typename valX, typename valW>
- TString AddHistogram(const char* histClass,
- const TVectorD* const binsX,
- valX valTypeX,
- valW valTypeW) {
- return UserObject(histClass,
- "",
- "",
- binsX,
- valTypeX,
- 0x0,
- static_cast<UInt_t>(Eoption::kNo),
- 0x0,
- static_cast<UInt_t>(Eoption::kNo),
- static_cast<UInt_t>(Eoption::kNoProfile),
- valTypeW,
- "");
+ TString AddHistogram(const char* histClass, const TVectorD* const binsX, valX valTypeX, valW valTypeW)
+ {
+ return UserObject(histClass, "", "", binsX, valTypeX, 0x0, static_cast<UInt_t>(Eoption::kNo), 0x0,
+ static_cast<UInt_t>(Eoption::kNo), static_cast<UInt_t>(Eoption::kNoProfile), valTypeW, "");
}
template<typename valX>
- TString AddHistogram(const char* histClass,
- const TVectorD* const binsX,
- valX valTypeX) {
- return AddHistogram(
- histClass, binsX, valTypeX, static_cast<UInt_t>(Eoption::kNoWeights));
+ TString AddHistogram(const char* histClass, const TVectorD* const binsX, valX valTypeX)
+ {
+ return AddHistogram(histClass, binsX, valTypeX, static_cast<UInt_t>(Eoption::kNoWeights));
}
template<typename valX, typename valP, typename valW>
- TString AddProfile(const char* histClass,
- const TVectorD* const binsX,
- valX valTypeX,
- valP valTypeP,
- TString option,
- valW valTypeW) {
- return UserObject(histClass,
- "",
- "",
- binsX,
- valTypeX,
- 0x0,
- valTypeP,
- 0x0,
- static_cast<UInt_t>(Eoption::kNo),
- valTypeP,
- valTypeW,
- option);
+ TString AddProfile(const char* histClass, const TVectorD* const binsX, valX valTypeX, valP valTypeP, TString option,
+ valW valTypeW)
+ {
+ return UserObject(histClass, "", "", binsX, valTypeX, 0x0, valTypeP, 0x0, static_cast<UInt_t>(Eoption::kNo),
+ valTypeP, valTypeW, option);
}
template<typename valX, typename valP>
- TString AddProfile(const char* histClass,
- const TVectorD* const binsX,
- valX valTypeX,
- valP valTypeP,
- TString option) {
- return AddProfile(histClass,
- binsX,
- valTypeX,
- valTypeP,
- option,
- static_cast<UInt_t>(Eoption::kNoWeights));
+ TString AddProfile(const char* histClass, const TVectorD* const binsX, valX valTypeX, valP valTypeP, TString option)
+ {
+ return AddProfile(histClass, binsX, valTypeX, valTypeP, option, static_cast<UInt_t>(Eoption::kNoWeights));
}
// 2D
template<typename valX, typename valY, typename valW>
- TString AddHistogram(const char* histClass,
- const TVectorD* const binsX,
- valX valTypeX,
- const TVectorD* const binsY,
- valY valTypeY,
- valW valTypeW) {
- return UserObject(histClass,
- "",
- "",
- binsX,
- valTypeX,
- binsY,
- valTypeY,
- 0x0,
- static_cast<UInt_t>(Eoption::kNo),
- static_cast<UInt_t>(Eoption::kNoProfile),
- valTypeW,
- "");
+ TString AddHistogram(const char* histClass, const TVectorD* const binsX, valX valTypeX, const TVectorD* const binsY,
+ valY valTypeY, valW valTypeW)
+ {
+ return UserObject(histClass, "", "", binsX, valTypeX, binsY, valTypeY, 0x0, static_cast<UInt_t>(Eoption::kNo),
+ static_cast<UInt_t>(Eoption::kNoProfile), valTypeW, "");
}
template<typename valX, typename valY>
- TString AddHistogram(const char* histClass,
- const TVectorD* const binsX,
- valX valTypeX,
- const TVectorD* const binsY,
- valY valTypeY) {
- return AddHistogram(histClass,
- binsX,
- valTypeX,
- binsY,
- valTypeY,
- static_cast<UInt_t>(Eoption::kNoWeights));
+ TString AddHistogram(const char* histClass, const TVectorD* const binsX, valX valTypeX, const TVectorD* const binsY,
+ valY valTypeY)
+ {
+ return AddHistogram(histClass, binsX, valTypeX, binsY, valTypeY, static_cast<UInt_t>(Eoption::kNoWeights));
}
template<typename valX, typename valY, typename valP, typename valW>
- TString AddProfile(const char* histClass,
- const TVectorD* const binsX,
- valX valTypeX,
- const TVectorD* const binsY,
- valY valTypeY,
- valP valTypeP,
- TString option,
- valW valTypeW) {
- return UserObject(histClass,
- "",
- "",
- binsX,
- valTypeX,
- binsY,
- valTypeY,
- 0x0,
- valTypeP,
- valTypeP,
- valTypeW,
- option);
+ TString AddProfile(const char* histClass, const TVectorD* const binsX, valX valTypeX, const TVectorD* const binsY,
+ valY valTypeY, valP valTypeP, TString option, valW valTypeW)
+ {
+ return UserObject(histClass, "", "", binsX, valTypeX, binsY, valTypeY, 0x0, valTypeP, valTypeP, valTypeW, option);
}
template<typename valX, typename valY, typename valP>
- TString AddProfile(const char* histClass,
- const TVectorD* const binsX,
- valX valTypeX,
- const TVectorD* const binsY,
- valY valTypeY,
- valP valTypeP,
- TString option) {
- return AddProfile(histClass,
- binsX,
- valTypeX,
- binsY,
- valTypeY,
- valTypeP,
- option,
+ TString AddProfile(const char* histClass, const TVectorD* const binsX, valX valTypeX, const TVectorD* const binsY,
+ valY valTypeY, valP valTypeP, TString option)
+ {
+ return AddProfile(histClass, binsX, valTypeX, binsY, valTypeY, valTypeP, option,
static_cast<UInt_t>(Eoption::kNoWeights));
}
// 3D
template<typename valX, typename valY, typename valZ, typename valW>
- TString AddHistogram(const char* histClass,
- const TVectorD* const binsX,
- valX valTypeX,
- const TVectorD* const binsY,
- valY valTypeY,
- const TVectorD* const binsZ,
- valZ valTypeZ,
- valW valTypeW) {
- return UserObject(histClass,
- "",
- "",
- binsX,
- valTypeX,
- binsY,
- valTypeY,
- binsZ,
- valTypeZ,
- static_cast<UInt_t>(Eoption::kNoProfile),
- valTypeW,
- "");
+ TString AddHistogram(const char* histClass, const TVectorD* const binsX, valX valTypeX, const TVectorD* const binsY,
+ valY valTypeY, const TVectorD* const binsZ, valZ valTypeZ, valW valTypeW)
+ {
+ return UserObject(histClass, "", "", binsX, valTypeX, binsY, valTypeY, binsZ, valTypeZ,
+ static_cast<UInt_t>(Eoption::kNoProfile), valTypeW, "");
}
template<typename valX, typename valY, typename valZ>
- TString AddHistogram(const char* histClass,
- const TVectorD* const binsX,
- valX valTypeX,
- const TVectorD* const binsY,
- valY valTypeY,
- const TVectorD* const binsZ,
- valZ valTypeZ) {
- return AddHistogram(histClass,
- binsX,
- valTypeX,
- binsY,
- valTypeY,
- binsZ,
- valTypeZ,
+ TString AddHistogram(const char* histClass, const TVectorD* const binsX, valX valTypeX, const TVectorD* const binsY,
+ valY valTypeY, const TVectorD* const binsZ, valZ valTypeZ)
+ {
+ return AddHistogram(histClass, binsX, valTypeX, binsY, valTypeY, binsZ, valTypeZ,
static_cast<UInt_t>(Eoption::kNoWeights));
}
//profs
- template<typename valX,
- typename valY,
- typename valZ,
- typename valP,
- typename valW>
- TString AddProfile(const char* histClass,
- const TVectorD* const binsX,
- valX valTypeX,
- const TVectorD* const binsY,
- valY valTypeY,
- const TVectorD* const binsZ,
- valZ valTypeZ,
- valP valTypeP,
- TString option,
- valW valTypeW) {
- return UserObject(histClass,
- "",
- "",
- binsX,
- valTypeX,
- binsY,
- valTypeY,
- binsZ,
- valTypeZ,
- valTypeP,
- valTypeW,
- option);
+ template<typename valX, typename valY, typename valZ, typename valP, typename valW>
+ TString AddProfile(const char* histClass, const TVectorD* const binsX, valX valTypeX, const TVectorD* const binsY,
+ valY valTypeY, const TVectorD* const binsZ, valZ valTypeZ, valP valTypeP, TString option,
+ valW valTypeW)
+ {
+ return UserObject(histClass, "", "", binsX, valTypeX, binsY, valTypeY, binsZ, valTypeZ, valTypeP, valTypeW, option);
}
template<typename valX, typename valY, typename valZ, typename valP>
- TString AddProfile(const char* histClass,
- const TVectorD* const binsX,
- valX valTypeX,
- const TVectorD* const binsY,
- valY valTypeY,
- const TVectorD* const binsZ,
- valZ valTypeZ,
- valP valTypeP,
- TString option) {
- return AddProfile(histClass,
- binsX,
- valTypeX,
- binsY,
- valTypeY,
- binsZ,
- valTypeZ,
- valTypeP,
- option,
+ TString AddProfile(const char* histClass, const TVectorD* const binsX, valX valTypeX, const TVectorD* const binsY,
+ valY valTypeY, const TVectorD* const binsZ, valZ valTypeZ, valP valTypeP, TString option)
+ {
+ return AddProfile(histClass, binsX, valTypeX, binsY, valTypeY, binsZ, valTypeZ, valTypeP, option,
static_cast<UInt_t>(Eoption::kNoWeights));
}
@@ -392,41 +230,30 @@ public:
static void FillValues(THnBase* obj, const Double_t* values);
// functions to get and draw histograms
- void ReadFromFile(const char* file = "histos.root",
- const char* task = "",
- const char* config = "");
+ void ReadFromFile(const char* file = "histos.root", const char* task = "", const char* config = "");
void DumpToFile(const char* file = "histos.root");
void SetList(TList* const list) { fList = list; }
TList* GetList() const { return fList; }
Bool_t SetCutClass(const char* cutClass);
- Bool_t HasHistClass(TString histClass) const {
- return fHistoList.FindObject(histClass.Data());
- }
+ Bool_t HasHistClass(TString histClass) const { return fHistoList.FindObject(histClass.Data()); }
void SetHistogramList(THashList& list, Bool_t setOwner = kTRUE);
void ResetHistogramList() { fHistoList.Clear(); }
const THashList* GetHistogramList() const { return &fHistoList; }
TObject* GetHist(const char* histClass, const char* name) const;
TH1* GetHistogram(const char* histClass, const char* name) const;
- TObject*
- GetHist(const char* cutClass, const char* histClass, const char* name) const;
- TH1* GetHistogram(const char* cutClass,
- const char* histClass,
- const char* name) const;
+ TObject* GetHist(const char* cutClass, const char* histClass, const char* name) const;
+ TH1* GetHistogram(const char* cutClass, const char* histClass, const char* name) const;
PairAnalysisMetaData* GetMetaData() const { return fMetaData; }
virtual void Print(const Option_t* option = "") const;
virtual void Draw(const Option_t* option = "");
- virtual TObjArray* DrawSame(TString histName,
- TString option = "leg can",
- TString histClassDenom = "",
- THashList* listDenom = 0x0);
- virtual TObjArray* DrawTaskSame(TString histName,
- TString opt = "leg can",
- TString histClassDenom = "",
- TString taskDenom = "");
+ virtual TObjArray* DrawSame(TString histName, TString option = "leg can", TString histClassDenom = "",
+ THashList* listDenom = 0x0);
+ virtual TObjArray* DrawTaskSame(TString histName, TString opt = "leg can", TString histClassDenom = "",
+ TString taskDenom = "");
protected:
@@ -436,19 +263,10 @@ protected:
//private:
TFormula* GetFormula(const char* name, const char* formula);
- TH1* GetTHist(const char* histClass,
- const char* name,
- const char* title,
- const TVectorD* const binsX,
- const TVectorD* const binsY,
- const TVectorD* const binsZ);
- TH1* GetTProf(const char* histClass,
- const char* name,
- const char* title,
- const TVectorD* const binsX,
- const TVectorD* const binsY,
- const TVectorD* const binsZ,
- TString option = "i");
+ TH1* GetTHist(const char* histClass, const char* name, const char* title, const TVectorD* const binsX,
+ const TVectorD* const binsY, const TVectorD* const binsZ);
+ TH1* GetTProf(const char* histClass, const char* name, const char* title, const TVectorD* const binsX,
+ const TVectorD* const binsY, const TVectorD* const binsZ, TString option = "i");
void FillVarArray(TObject* obj, UInt_t* valType);
@@ -473,31 +291,19 @@ protected:
ClassDef(PairAnalysisHistos, 3) // Histogram management
};
-template<typename valX,
- typename valY,
- typename valZ,
- typename valP,
- typename valW>
-TString PairAnalysisHistos::UserObject(const char* histClass,
- const char* name,
- const char* title,
- const TVectorD* const binsX,
- valX valTypeX,
- const TVectorD* const binsY,
- valY valTypeY,
- const TVectorD* const binsZ,
- valZ valTypeZ,
- valP valTypeP,
- valW valTypeW,
- TString option) {
+template<typename valX, typename valY, typename valZ, typename valP, typename valW>
+TString PairAnalysisHistos::UserObject(const char* histClass, const char* name, const char* title,
+ const TVectorD* const binsX, valX valTypeX, const TVectorD* const binsY,
+ valY valTypeY, const TVectorD* const binsZ, valZ valTypeZ, valP valTypeP,
+ valW valTypeW, TString option)
+{
//
// main function to setup the histogram with given variables, binning and dimensions
//
TH1* hist = 0x0;
TString err = "err";
//profile or histogram
- if (typeid(valTypeP) == typeid(UInt_t)
- && (uintptr_t) valTypeP == static_cast<UInt_t>(Eoption::kNoProfile))
+ if (typeid(valTypeP) == typeid(UInt_t) && (uintptr_t) valTypeP == static_cast<UInt_t>(Eoption::kNoProfile))
hist = GetTHist(histClass, name, title, binsX, binsY, binsZ);
else
hist = GetTProf(histClass, name, title, binsX, binsY, binsZ, option);
@@ -511,53 +317,33 @@ TString PairAnalysisHistos::UserObject(const char* histClass,
UInt_t valType[20] = {0};
TString func = "";
func.Form("%d", valTypeX);
- if (!func.Atoi())
- std::cout
- << func
- << std::
- endl; //hist->GetListOfFunctions()->Add( GetFormula("xFormula",func) );
+ if (!func.Atoi()) std::cout << func << std::endl; //hist->GetListOfFunctions()->Add( GetFormula("xFormula",func) );
else
valType[0] = func.Atoi();
func = "";
func.Form("%d", valTypeY);
- if (!func.Atoi())
- std::cout
- << func
- << std::
- endl; //hist->GetListOfFunctions()->Add( GetFormula("yFormula",func) );
+ if (!func.Atoi()) std::cout << func << std::endl; //hist->GetListOfFunctions()->Add( GetFormula("yFormula",func) );
else
valType[1] = func.Atoi();
func = "";
func.Form("%d", valTypeZ);
- if (!func.Atoi())
- std::cout
- << func
- << std::
- endl; //hist->GetListOfFunctions()->Add( GetFormula("zFormula",func) );
+ if (!func.Atoi()) std::cout << func << std::endl; //hist->GetListOfFunctions()->Add( GetFormula("zFormula",func) );
else
valType[2] = func.Atoi();
func = "";
func.Form("%d", valTypeP);
- if (!func.Atoi())
- std::cout
- << func
- << std::
- endl; //hist->GetListOfFunctions()->Add( GetFormula("pFormula",func) );
+ if (!func.Atoi()) std::cout << func << std::endl; //hist->GetListOfFunctions()->Add( GetFormula("pFormula",func) );
else
valType[3] = func.Atoi();
TString func2 = "";
func2.Form("%d", valTypeX);
func = "";
- func.Form("%d", valTypeW); //func+=valTypeW;
- if (!func.Atoi())
- std::cout
- << func
- << std::
- endl; //hist->GetListOfFunctions()->Add( GetFormula("wFormula",func) );
+ func.Form("%d", valTypeW); //func+=valTypeW;
+ if (!func.Atoi()) std::cout << func << std::endl; //hist->GetListOfFunctions()->Add( GetFormula("wFormula",func) );
else if (func2.Atoi() != static_cast<UInt_t>(Eoption::kNoWeights)) {
hist->SetUniqueID(func.Atoi()); // store weighting variable
fUsedVars->SetBitNumber(func.Atoi(), kTRUE);
@@ -586,10 +372,8 @@ TString PairAnalysisHistos::UserObject(const char* histClass,
*/
Bool_t isReserved = fReservedWords->Contains(histClass);
- if (func2.Atoi() && func2.Atoi() == static_cast<UInt_t>(Eoption::kNoAutoFill))
- hist->SetUniqueID(func2.Atoi());
- if (isReserved)
- UserHistogramReservedWords(histClass, hist);
+ if (func2.Atoi() && func2.Atoi() == static_cast<UInt_t>(Eoption::kNoAutoFill)) hist->SetUniqueID(func2.Atoi());
+ if (isReserved) UserHistogramReservedWords(histClass, hist);
else
UserHistogram(histClass, hist);
diff --git a/analysis/PWGDIL/dielectron/papaframework/PairAnalysisMC.cxx b/analysis/PWGDIL/dielectron/papaframework/PairAnalysisMC.cxx
index 27bd5e3bbcbf0725ad42fddddd13611144d33077..27e6f435a7711f69003cf5093eca11ea022739f0 100644
--- a/analysis/PWGDIL/dielectron/papaframework/PairAnalysisMC.cxx
+++ b/analysis/PWGDIL/dielectron/papaframework/PairAnalysisMC.cxx
@@ -13,15 +13,17 @@
///////////////////////////////////////////////////////////////////////////////////////////
+#include "PairAnalysisMC.h"
+
+#include "CbmMCTrack.h"
+
+#include "FairRootManager.h"
+
#include <TClonesArray.h>
#include <TMCProcess.h>
#include <TPDGCode.h>
#include <TParticle.h>
-#include "CbmMCTrack.h"
-#include "FairRootManager.h"
-
-#include "PairAnalysisMC.h"
#include "PairAnalysisSignalMC.h"
#include "PairAnalysisTrack.h"
@@ -31,7 +33,8 @@ ClassImp(PairAnalysisMC)
PairAnalysisMC* PairAnalysisMC::fgInstance = 0x0;
//____________________________________________________________
-PairAnalysisMC* PairAnalysisMC::Instance() {
+PairAnalysisMC* PairAnalysisMC::Instance()
+{
//
// return pointer to singleton implementation
//
@@ -44,8 +47,8 @@ PairAnalysisMC* PairAnalysisMC::Instance() {
}
//____________________________________________________________
-PairAnalysisMC::PairAnalysisMC()
- : fMCEvent(0x0), fHasMC(kFALSE), fMCArray(0x0) {
+PairAnalysisMC::PairAnalysisMC() : fMCEvent(0x0), fHasMC(kFALSE), fMCArray(0x0)
+{
//
// default constructor
//
@@ -53,14 +56,16 @@ PairAnalysisMC::PairAnalysisMC()
//____________________________________________________________
-PairAnalysisMC::~PairAnalysisMC() {
+PairAnalysisMC::~PairAnalysisMC()
+{
//
// default destructor
//
}
//____________________________________________________________
-Int_t PairAnalysisMC::GetNMCTracks() {
+Int_t PairAnalysisMC::GetNMCTracks()
+{
//
// return the number of generated tracks from MC event
//
@@ -72,7 +77,8 @@ Int_t PairAnalysisMC::GetNMCTracks() {
}
//____________________________________________________________
-CbmMCTrack* PairAnalysisMC::GetMCTrackFromMCEvent(Int_t label) const {
+CbmMCTrack* PairAnalysisMC::GetMCTrackFromMCEvent(Int_t label) const
+{
//
// return MC track directly from MC event
// used not only for tracks but for mothers as well, therefore do not use abs(label)
@@ -84,21 +90,18 @@ CbmMCTrack* PairAnalysisMC::GetMCTrackFromMCEvent(Int_t label) const {
}
if (label > fMCArray->GetEntriesFast()) {
- Info("PairAnalysisMC::",
- "track %d out of array size %d",
- label,
- fMCArray->GetEntriesFast());
+ Info("PairAnalysisMC::", "track %d out of array size %d", label, fMCArray->GetEntriesFast());
return NULL;
}
- CbmMCTrack* track = static_cast<CbmMCTrack*>(
- fMCArray->UncheckedAt(label)); // tracks from MC event
+ CbmMCTrack* track = static_cast<CbmMCTrack*>(fMCArray->UncheckedAt(label)); // tracks from MC event
// CbmMCTrack *track = static_cast<CbmMCTrack*>( fMCArray->At(label) ); // tracks from MC event
return track;
}
//____________________________________________________________
-Bool_t PairAnalysisMC::ConnectMCEvent() {
+Bool_t PairAnalysisMC::ConnectMCEvent()
+{
//
// connect MC array of tracks
//
@@ -113,7 +116,8 @@ Bool_t PairAnalysisMC::ConnectMCEvent() {
if (!fMCArray) {
Error("PairAnalysisMC::Instance", "Initialization of MC object failed!");
return kFALSE;
- } else
+ }
+ else
fHasMC = kTRUE;
// printf("PairAnalysisMC::ConnectMCEvent: size of mc array: %04d \n",fMCArray->GetSize());
return kTRUE;
@@ -121,7 +125,8 @@ Bool_t PairAnalysisMC::ConnectMCEvent() {
//____________________________________________________________
-CbmMCTrack* PairAnalysisMC::GetMCTrack(const PairAnalysisTrack* _track) {
+CbmMCTrack* PairAnalysisMC::GetMCTrack(const PairAnalysisTrack* _track)
+{
//
// return MC track
//
@@ -129,7 +134,8 @@ CbmMCTrack* PairAnalysisMC::GetMCTrack(const PairAnalysisTrack* _track) {
}
//______________________________________________________________
-CbmMCTrack* PairAnalysisMC::GetMCTrackMother(const PairAnalysisTrack* _track) {
+CbmMCTrack* PairAnalysisMC::GetMCTrackMother(const PairAnalysisTrack* _track)
+{
//
// return MC track mother
//
@@ -139,19 +145,20 @@ CbmMCTrack* PairAnalysisMC::GetMCTrackMother(const PairAnalysisTrack* _track) {
}
//____________________________________________________________
-CbmMCTrack* PairAnalysisMC::GetMCTrackMother(const CbmMCTrack* _particle) {
+CbmMCTrack* PairAnalysisMC::GetMCTrackMother(const CbmMCTrack* _particle)
+{
//
// return MC track mother
//
if (_particle->GetMotherId() < 0) return NULL;
- CbmMCTrack* mcmother =
- dynamic_cast<CbmMCTrack*>(fMCArray->At(_particle->GetMotherId()));
+ CbmMCTrack* mcmother = dynamic_cast<CbmMCTrack*>(fMCArray->At(_particle->GetMotherId()));
return mcmother;
}
//________________________________________________________
-Int_t PairAnalysisMC::GetMotherPDG(const PairAnalysisTrack* _track) {
+Int_t PairAnalysisMC::GetMotherPDG(const PairAnalysisTrack* _track)
+{
//
// return PDG code of the mother track from the MC truth info
//
@@ -161,7 +168,8 @@ Int_t PairAnalysisMC::GetMotherPDG(const PairAnalysisTrack* _track) {
}
//________________________________________________________
-Int_t PairAnalysisMC::GetMotherPDG(const CbmMCTrack* _track) {
+Int_t PairAnalysisMC::GetMotherPDG(const CbmMCTrack* _track)
+{
//
// return PDG code of the mother track from the MC truth info
//
@@ -172,7 +180,8 @@ Int_t PairAnalysisMC::GetMotherPDG(const CbmMCTrack* _track) {
}
//____________________________________________________________
-Int_t PairAnalysisMC::NumberOfDaughters(const CbmMCTrack* particle) {
+Int_t PairAnalysisMC::NumberOfDaughters(const CbmMCTrack* particle)
+{
//
// returns the number of daughters
//
@@ -183,9 +192,9 @@ Int_t PairAnalysisMC::NumberOfDaughters(const CbmMCTrack* particle) {
}
//____________________________________________________________
-Int_t PairAnalysisMC::GetLabelMotherWithPdg(const PairAnalysisTrack* particle1,
- const PairAnalysisTrack* particle2,
- Int_t pdgMother) {
+Int_t PairAnalysisMC::GetLabelMotherWithPdg(const PairAnalysisTrack* particle1, const PairAnalysisTrack* particle2,
+ Int_t pdgMother)
+{
//
// test if mother of particle 1 and 2 has pdgCode pdgMother and is the same;
//
@@ -211,9 +220,8 @@ Int_t PairAnalysisMC::GetLabelMotherWithPdg(const PairAnalysisTrack* particle1,
}
//____________________________________________________________
-void PairAnalysisMC::GetDaughters(const TObject* /*mother*/,
- CbmMCTrack*& d1,
- CbmMCTrack*& d2) {
+void PairAnalysisMC::GetDaughters(const TObject* /*mother*/, CbmMCTrack*& d1, CbmMCTrack*& d2)
+{
//
// Get First two daughters of the mother
// TODO: theres NO connection from mother to daughters
@@ -234,21 +242,22 @@ void PairAnalysisMC::GetDaughters(const TObject* /*mother*/,
//________________________________________________________________________________
-Int_t PairAnalysisMC::GetMothersLabel(Int_t daughterLabel) const {
+Int_t PairAnalysisMC::GetMothersLabel(Int_t daughterLabel) const
+{
//
// Get the label of the mother for particle with label daughterLabel
// NOTE: for tracks, the absolute label should be passed
//
if (daughterLabel < 0) return -1;
if (!fMCArray) return -1;
- if (GetMCTrackFromMCEvent(daughterLabel))
- return (GetMCTrackFromMCEvent(daughterLabel))->GetMotherId();
+ if (GetMCTrackFromMCEvent(daughterLabel)) return (GetMCTrackFromMCEvent(daughterLabel))->GetMotherId();
return -1;
}
//________________________________________________________________________________
-Int_t PairAnalysisMC::GetPdgFromLabel(Int_t label) const {
+Int_t PairAnalysisMC::GetPdgFromLabel(Int_t label) const
+{
//
// Get particle code using the label from stack
// NOTE: for tracks, the absolute label should be passed
@@ -261,10 +270,9 @@ Int_t PairAnalysisMC::GetPdgFromLabel(Int_t label) const {
//________________________________________________________________________________
-Bool_t PairAnalysisMC::ComparePDG(Int_t particlePDG,
- Int_t requiredPDG,
- Bool_t pdgExclusion,
- Bool_t checkBothCharges) const {
+Bool_t PairAnalysisMC::ComparePDG(Int_t particlePDG, Int_t requiredPDG, Bool_t pdgExclusion,
+ Bool_t checkBothCharges) const
+{
//
// Test the PDG codes of particles with the required ones
//
@@ -276,237 +284,164 @@ Bool_t PairAnalysisMC::ComparePDG(Int_t particlePDG,
result = kTRUE; // PDG not required (any code will do fine)
break;
case 100: // light flavoured mesons
- if (checkBothCharges)
- result =
- TMath::Abs(particlePDG) >= 100 && TMath::Abs(particlePDG) <= 199;
+ if (checkBothCharges) result = TMath::Abs(particlePDG) >= 100 && TMath::Abs(particlePDG) <= 199;
else {
if (requiredPDG > 0) result = particlePDG >= 100 && particlePDG <= 199;
- if (requiredPDG < 0)
- result = particlePDG >= -199 && particlePDG <= -100;
+ if (requiredPDG < 0) result = particlePDG >= -199 && particlePDG <= -100;
}
break;
case 1000: // light flavoured baryons
- if (checkBothCharges)
- result =
- TMath::Abs(particlePDG) >= 1000 && TMath::Abs(particlePDG) <= 1999;
+ if (checkBothCharges) result = TMath::Abs(particlePDG) >= 1000 && TMath::Abs(particlePDG) <= 1999;
else {
- if (requiredPDG > 0)
- result = particlePDG >= 1000 && particlePDG <= 1999;
- if (requiredPDG < 0)
- result = particlePDG >= -1999 && particlePDG <= -1000;
+ if (requiredPDG > 0) result = particlePDG >= 1000 && particlePDG <= 1999;
+ if (requiredPDG < 0) result = particlePDG >= -1999 && particlePDG <= -1000;
}
break;
case 200: // light flavoured mesons
- if (checkBothCharges)
- result =
- TMath::Abs(particlePDG) >= 200 && TMath::Abs(particlePDG) <= 299;
+ if (checkBothCharges) result = TMath::Abs(particlePDG) >= 200 && TMath::Abs(particlePDG) <= 299;
else {
if (requiredPDG > 0) result = particlePDG >= 200 && particlePDG <= 299;
- if (requiredPDG < 0)
- result = particlePDG >= -299 && particlePDG <= -200;
+ if (requiredPDG < 0) result = particlePDG >= -299 && particlePDG <= -200;
}
break;
case 2000: // light flavoured baryons
- if (checkBothCharges)
- result =
- TMath::Abs(particlePDG) >= 2000 && TMath::Abs(particlePDG) <= 2999;
+ if (checkBothCharges) result = TMath::Abs(particlePDG) >= 2000 && TMath::Abs(particlePDG) <= 2999;
else {
- if (requiredPDG > 0)
- result = particlePDG >= 2000 && particlePDG <= 2999;
- if (requiredPDG < 0)
- result = particlePDG >= -2999 && particlePDG <= -2000;
+ if (requiredPDG > 0) result = particlePDG >= 2000 && particlePDG <= 2999;
+ if (requiredPDG < 0) result = particlePDG >= -2999 && particlePDG <= -2000;
}
break;
case 300: // all strange mesons
- if (checkBothCharges)
- result =
- TMath::Abs(particlePDG) >= 300 && TMath::Abs(particlePDG) <= 399;
+ if (checkBothCharges) result = TMath::Abs(particlePDG) >= 300 && TMath::Abs(particlePDG) <= 399;
else {
if (requiredPDG > 0) result = particlePDG >= 300 && particlePDG <= 399;
- if (requiredPDG < 0)
- result = particlePDG >= -399 && particlePDG <= -300;
+ if (requiredPDG < 0) result = particlePDG >= -399 && particlePDG <= -300;
}
break;
case 3000: // all strange baryons
- if (checkBothCharges)
- result =
- TMath::Abs(particlePDG) >= 3000 && TMath::Abs(particlePDG) <= 3999;
+ if (checkBothCharges) result = TMath::Abs(particlePDG) >= 3000 && TMath::Abs(particlePDG) <= 3999;
else {
- if (requiredPDG > 0)
- result = particlePDG >= 3000 && particlePDG <= 3999;
- if (requiredPDG < 0)
- result = particlePDG >= -3999 && particlePDG <= -3000;
+ if (requiredPDG > 0) result = particlePDG >= 3000 && particlePDG <= 3999;
+ if (requiredPDG < 0) result = particlePDG >= -3999 && particlePDG <= -3000;
}
break;
case 400: // all charmed mesons
- if (checkBothCharges)
- result =
- TMath::Abs(particlePDG) >= 400 && TMath::Abs(particlePDG) <= 499;
+ if (checkBothCharges) result = TMath::Abs(particlePDG) >= 400 && TMath::Abs(particlePDG) <= 499;
else {
if (requiredPDG > 0) result = particlePDG >= 400 && particlePDG <= 499;
- if (requiredPDG < 0)
- result = particlePDG >= -499 && particlePDG <= -400;
+ if (requiredPDG < 0) result = particlePDG >= -499 && particlePDG <= -400;
}
break;
case 401: // open charm mesons
- if (checkBothCharges)
- result =
- TMath::Abs(particlePDG) >= 400 && TMath::Abs(particlePDG) <= 439;
+ if (checkBothCharges) result = TMath::Abs(particlePDG) >= 400 && TMath::Abs(particlePDG) <= 439;
else {
if (requiredPDG > 0) result = particlePDG >= 400 && particlePDG <= 439;
- if (requiredPDG < 0)
- result = particlePDG >= -439 && particlePDG <= -400;
+ if (requiredPDG < 0) result = particlePDG >= -439 && particlePDG <= -400;
}
break;
case 402: // open charm mesons and baryons together
if (checkBothCharges)
- result =
- (TMath::Abs(particlePDG) >= 400 && TMath::Abs(particlePDG) <= 439)
- || (TMath::Abs(particlePDG) >= 4000
- && TMath::Abs(particlePDG) <= 4399);
+ result = (TMath::Abs(particlePDG) >= 400 && TMath::Abs(particlePDG) <= 439)
+ || (TMath::Abs(particlePDG) >= 4000 && TMath::Abs(particlePDG) <= 4399);
else {
if (requiredPDG > 0)
- result = (particlePDG >= 400 && particlePDG <= 439)
- || (particlePDG >= 4000 && particlePDG <= 4399);
+ result = (particlePDG >= 400 && particlePDG <= 439) || (particlePDG >= 4000 && particlePDG <= 4399);
if (requiredPDG < 0)
- result = (particlePDG >= -439 && particlePDG <= -400)
- || (particlePDG >= -4399 && particlePDG <= -4000);
+ result = (particlePDG >= -439 && particlePDG <= -400) || (particlePDG >= -4399 && particlePDG <= -4000);
}
break;
case 403: // all charm hadrons
if (checkBothCharges)
- result =
- (TMath::Abs(particlePDG) >= 400 && TMath::Abs(particlePDG) <= 499)
- || (TMath::Abs(particlePDG) >= 4000
- && TMath::Abs(particlePDG) <= 4999);
+ result = (TMath::Abs(particlePDG) >= 400 && TMath::Abs(particlePDG) <= 499)
+ || (TMath::Abs(particlePDG) >= 4000 && TMath::Abs(particlePDG) <= 4999);
else {
if (requiredPDG > 0)
- result = (particlePDG >= 400 && particlePDG <= 499)
- || (particlePDG >= 4000 && particlePDG <= 4999);
+ result = (particlePDG >= 400 && particlePDG <= 499) || (particlePDG >= 4000 && particlePDG <= 4999);
if (requiredPDG < 0)
- result = (particlePDG >= -499 && particlePDG <= -400)
- || (particlePDG >= -4999 && particlePDG <= -4000);
+ result = (particlePDG >= -499 && particlePDG <= -400) || (particlePDG >= -4999 && particlePDG <= -4000);
}
break;
case 4000: // all charmed baryons
- if (checkBothCharges)
- result =
- TMath::Abs(particlePDG) >= 4000 && TMath::Abs(particlePDG) <= 4999;
+ if (checkBothCharges) result = TMath::Abs(particlePDG) >= 4000 && TMath::Abs(particlePDG) <= 4999;
else {
- if (requiredPDG > 0)
- result = particlePDG >= 4000 && particlePDG <= 4999;
- if (requiredPDG < 0)
- result = particlePDG >= -4999 && particlePDG <= -4000;
+ if (requiredPDG > 0) result = particlePDG >= 4000 && particlePDG <= 4999;
+ if (requiredPDG < 0) result = particlePDG >= -4999 && particlePDG <= -4000;
}
break;
case 4001: // open charm baryons
- if (checkBothCharges)
- result =
- TMath::Abs(particlePDG) >= 4000 && TMath::Abs(particlePDG) <= 4399;
+ if (checkBothCharges) result = TMath::Abs(particlePDG) >= 4000 && TMath::Abs(particlePDG) <= 4399;
else {
- if (requiredPDG > 0)
- result = particlePDG >= 4000 && particlePDG <= 4399;
- if (requiredPDG < 0)
- result = particlePDG >= -4399 && particlePDG <= -4000;
+ if (requiredPDG > 0) result = particlePDG >= 4000 && particlePDG <= 4399;
+ if (requiredPDG < 0) result = particlePDG >= -4399 && particlePDG <= -4000;
}
break;
case 500: // all beauty mesons
- if (checkBothCharges)
- result =
- TMath::Abs(particlePDG) >= 500 && TMath::Abs(particlePDG) <= 599;
+ if (checkBothCharges) result = TMath::Abs(particlePDG) >= 500 && TMath::Abs(particlePDG) <= 599;
else {
if (requiredPDG > 0) result = particlePDG >= 500 && particlePDG <= 599;
- if (requiredPDG < 0)
- result = particlePDG >= -599 && particlePDG <= -500;
+ if (requiredPDG < 0) result = particlePDG >= -599 && particlePDG <= -500;
}
break;
case 501: // open beauty mesons
- if (checkBothCharges)
- result =
- TMath::Abs(particlePDG) >= 500 && TMath::Abs(particlePDG) <= 549;
+ if (checkBothCharges) result = TMath::Abs(particlePDG) >= 500 && TMath::Abs(particlePDG) <= 549;
else {
if (requiredPDG > 0) result = particlePDG >= 500 && particlePDG <= 549;
- if (requiredPDG < 0)
- result = particlePDG >= -549 && particlePDG <= -500;
+ if (requiredPDG < 0) result = particlePDG >= -549 && particlePDG <= -500;
}
break;
case 502: // open beauty mesons and baryons
if (checkBothCharges)
- result =
- (TMath::Abs(particlePDG) >= 500 && TMath::Abs(particlePDG) <= 549)
- || (TMath::Abs(particlePDG) >= 5000
- && TMath::Abs(particlePDG) <= 5499);
+ result = (TMath::Abs(particlePDG) >= 500 && TMath::Abs(particlePDG) <= 549)
+ || (TMath::Abs(particlePDG) >= 5000 && TMath::Abs(particlePDG) <= 5499);
else {
if (requiredPDG > 0)
- result = (particlePDG >= 500 && particlePDG <= 549)
- || (particlePDG >= 5000 && particlePDG <= 5499);
+ result = (particlePDG >= 500 && particlePDG <= 549) || (particlePDG >= 5000 && particlePDG <= 5499);
if (requiredPDG < 0)
- result = (particlePDG >= -549 && particlePDG <= -500)
- || (particlePDG >= -5499 && particlePDG <= -5000);
+ result = (particlePDG >= -549 && particlePDG <= -500) || (particlePDG >= -5499 && particlePDG <= -5000);
}
break;
case 503: // all beauty hadrons
if (checkBothCharges)
- result =
- (TMath::Abs(particlePDG) >= 500 && TMath::Abs(particlePDG) <= 599)
- || (TMath::Abs(particlePDG) >= 5000
- && TMath::Abs(particlePDG) <= 5999);
+ result = (TMath::Abs(particlePDG) >= 500 && TMath::Abs(particlePDG) <= 599)
+ || (TMath::Abs(particlePDG) >= 5000 && TMath::Abs(particlePDG) <= 5999);
else {
if (requiredPDG > 0)
- result = (particlePDG >= 500 && particlePDG <= 599)
- || (particlePDG >= 5000 && particlePDG <= 5999);
+ result = (particlePDG >= 500 && particlePDG <= 599) || (particlePDG >= 5000 && particlePDG <= 5999);
if (requiredPDG < 0)
- result = (particlePDG >= -599 && particlePDG <= -500)
- || (particlePDG >= -5999 && particlePDG <= -5000);
+ result = (particlePDG >= -599 && particlePDG <= -500) || (particlePDG >= -5999 && particlePDG <= -5000);
}
break;
case 5000: // all beauty baryons
- if (checkBothCharges)
- result =
- TMath::Abs(particlePDG) >= 5000 && TMath::Abs(particlePDG) <= 5999;
+ if (checkBothCharges) result = TMath::Abs(particlePDG) >= 5000 && TMath::Abs(particlePDG) <= 5999;
else {
- if (requiredPDG > 0)
- result = particlePDG >= 5000 && particlePDG <= 5999;
- if (requiredPDG < 0)
- result = particlePDG >= -5999 && particlePDG <= -5000;
+ if (requiredPDG > 0) result = particlePDG >= 5000 && particlePDG <= 5999;
+ if (requiredPDG < 0) result = particlePDG >= -5999 && particlePDG <= -5000;
}
break;
case 5001: // open beauty baryons
- if (checkBothCharges)
- result =
- TMath::Abs(particlePDG) >= 5000 && TMath::Abs(particlePDG) <= 5499;
+ if (checkBothCharges) result = TMath::Abs(particlePDG) >= 5000 && TMath::Abs(particlePDG) <= 5499;
else {
- if (requiredPDG > 0)
- result = particlePDG >= 5000 && particlePDG <= 5499;
- if (requiredPDG < 0)
- result = particlePDG >= -5499 && particlePDG <= -5000;
+ if (requiredPDG > 0) result = particlePDG >= 5000 && particlePDG <= 5499;
+ if (requiredPDG < 0) result = particlePDG >= -5499 && particlePDG <= -5000;
}
break;
case 902: // // open charm,beauty mesons and baryons together
if (checkBothCharges)
- result =
- (TMath::Abs(particlePDG) >= 400 && TMath::Abs(particlePDG) <= 439)
- || (TMath::Abs(particlePDG) >= 4000
- && TMath::Abs(particlePDG) <= 4399)
- || (TMath::Abs(particlePDG) >= 500 && TMath::Abs(particlePDG) <= 549)
- || (TMath::Abs(particlePDG) >= 5000
- && TMath::Abs(particlePDG) <= 5499);
+ result = (TMath::Abs(particlePDG) >= 400 && TMath::Abs(particlePDG) <= 439)
+ || (TMath::Abs(particlePDG) >= 4000 && TMath::Abs(particlePDG) <= 4399)
+ || (TMath::Abs(particlePDG) >= 500 && TMath::Abs(particlePDG) <= 549)
+ || (TMath::Abs(particlePDG) >= 5000 && TMath::Abs(particlePDG) <= 5499);
else {
if (requiredPDG > 0)
- result = (particlePDG >= 400 && particlePDG <= 439)
- || (particlePDG >= 4000 && particlePDG <= 4399)
- || (particlePDG >= 500 && particlePDG <= 549)
- || (particlePDG >= 5000 && particlePDG <= 5499);
+ result = (particlePDG >= 400 && particlePDG <= 439) || (particlePDG >= 4000 && particlePDG <= 4399)
+ || (particlePDG >= 500 && particlePDG <= 549) || (particlePDG >= 5000 && particlePDG <= 5499);
if (requiredPDG < 0)
- result = (particlePDG >= -439 && particlePDG <= -400)
- || (particlePDG >= -4399 && particlePDG <= -4000)
- || (particlePDG >= -549 && particlePDG <= -500)
- || (particlePDG >= -5499 && particlePDG <= -5000);
+ result = (particlePDG >= -439 && particlePDG <= -400) || (particlePDG >= -4399 && particlePDG <= -4000)
+ || (particlePDG >= -549 && particlePDG <= -500) || (particlePDG >= -5499 && particlePDG <= -5000);
}
break;
default: // all specific cases
- if (checkBothCharges)
- result = (absRequiredPDG == TMath::Abs(particlePDG));
+ if (checkBothCharges) result = (absRequiredPDG == TMath::Abs(particlePDG));
else
result = (requiredPDG == particlePDG);
}
@@ -516,31 +451,28 @@ Bool_t PairAnalysisMC::ComparePDG(Int_t particlePDG,
}
//________________________________________________________________________________
-Bool_t PairAnalysisMC::CheckGEANTProcess(Int_t label,
- TMCProcess process) const {
+Bool_t PairAnalysisMC::CheckGEANTProcess(Int_t label, TMCProcess process) const
+{
//
// Check the GEANT process for the particle
//
if (label < 0) return kFALSE;
if (!fMCArray) return kFALSE;
- UInt_t processID =
- static_cast<CbmMCTrack*>(GetMCTrackFromMCEvent(label))->GetGeantProcessId();
+ UInt_t processID = static_cast<CbmMCTrack*>(GetMCTrackFromMCEvent(label))->GetGeantProcessId();
// printf("process: id %d --> %s \n",processID,TMCProcessName[processID]);
return (process == processID);
}
//________________________________________________________________________________
-Bool_t PairAnalysisMC::CheckParticleSource(
- Int_t label,
- PairAnalysisSignalMC::ESource source) const {
+Bool_t PairAnalysisMC::CheckParticleSource(Int_t label, PairAnalysisSignalMC::ESource source) const
+{
//
// Check the source for the particle
// NOTE: TODO: check and clarify different sources, UPDATE!
//
- UInt_t processID =
- static_cast<CbmMCTrack*>(GetMCTrackFromMCEvent(label))->GetGeantProcessId();
+ UInt_t processID = static_cast<CbmMCTrack*>(GetMCTrackFromMCEvent(label))->GetGeantProcessId();
// printf("process: id %d --> %s \n",processID,TMCProcessName[processID]);
switch (source) {
@@ -591,19 +523,16 @@ Bool_t PairAnalysisMC::CheckParticleSource(
}
//________________________________________________________________________________
-Bool_t PairAnalysisMC::CheckIsDalitz(
- Int_t label,
- const PairAnalysisSignalMC* const signalMC) const {
+Bool_t PairAnalysisMC::CheckIsDalitz(Int_t label, const PairAnalysisSignalMC* const signalMC) const
+{
//
// Check if the particle has a three body decay, one being a dalitz pdg
// NOTE: no information on # of daugthers available in CbmMCTrack
// loop over the MC tracks
// for(Int_t ipart=0; ipart<fMCArray->GetEntriesFast(); ++ipart) { // super slow
- for (Int_t ipart = label; ipart < label + 5;
- ++ipart) { // embedded particles are sorted
- CbmMCTrack* daughter =
- static_cast<CbmMCTrack*>(GetMCTrackFromMCEvent(ipart));
+ for (Int_t ipart = label; ipart < label + 5; ++ipart) { // embedded particles are sorted
+ CbmMCTrack* daughter = static_cast<CbmMCTrack*>(GetMCTrackFromMCEvent(ipart));
if (!daughter) continue;
if (daughter->GetPdgCode() != signalMC->GetDalitzPdg()) continue;
if (daughter->GetMotherId() == label) return kTRUE;
@@ -612,33 +541,26 @@ Bool_t PairAnalysisMC::CheckIsDalitz(
}
//________________________________________________________________________________
-Bool_t PairAnalysisMC::CheckDalitzDecision(
- Int_t mLabel,
- const PairAnalysisSignalMC* const signalMC) const {
+Bool_t PairAnalysisMC::CheckDalitzDecision(Int_t mLabel, const PairAnalysisSignalMC* const signalMC) const
+{
//
// Check for the decision of the dalitz type request
//
if (!signalMC) return kFALSE;
- if (signalMC->GetDalitz() == PairAnalysisSignalMC::EDalitz::kWhoCares)
- return kTRUE;
+ if (signalMC->GetDalitz() == PairAnalysisSignalMC::EDalitz::kWhoCares) return kTRUE;
Bool_t isDalitz = CheckIsDalitz(mLabel, signalMC);
- if ((signalMC->GetDalitz() == PairAnalysisSignalMC::EDalitz::kIsDalitz)
- && !isDalitz)
- return kFALSE;
- if ((signalMC->GetDalitz() == PairAnalysisSignalMC::EDalitz::kIsNotDalitz)
- && isDalitz)
- return kFALSE;
+ if ((signalMC->GetDalitz() == PairAnalysisSignalMC::EDalitz::kIsDalitz) && !isDalitz) return kFALSE;
+ if ((signalMC->GetDalitz() == PairAnalysisSignalMC::EDalitz::kIsNotDalitz) && isDalitz) return kFALSE;
return kTRUE;
}
//________________________________________________________________________________
-Bool_t PairAnalysisMC::IsMCTruth(Int_t label,
- PairAnalysisSignalMC* signalMC,
- Int_t branch) const {
+Bool_t PairAnalysisMC::IsMCTruth(Int_t label, PairAnalysisSignalMC* signalMC, Int_t branch) const
+{
//
// Check if the particle corresponds to the MC truth in signalMC in the branch specified
//
@@ -651,47 +573,37 @@ Bool_t PairAnalysisMC::IsMCTruth(Int_t label,
CbmMCTrack* part = GetMCTrackFromMCEvent(label);
if (!part) {
- Error(
- "PairAnalysisMC::", "Could not find MC particle with label %d", label);
+ Error("PairAnalysisMC::", "Could not find MC particle with label %d", label);
return kFALSE;
}
// check geant process if set
- if (signalMC->GetCheckGEANTProcess()
- && !CheckGEANTProcess(label, signalMC->GetGEANTProcess()))
- return kFALSE;
+ if (signalMC->GetCheckGEANTProcess() && !CheckGEANTProcess(label, signalMC->GetGEANTProcess())) return kFALSE;
// check the LEG
- if (!ComparePDG(part->GetPdgCode(),
- signalMC->GetLegPDG(branch),
- signalMC->GetLegPDGexclude(branch),
+ if (!ComparePDG(part->GetPdgCode(), signalMC->GetLegPDG(branch), signalMC->GetLegPDGexclude(branch),
signalMC->GetCheckBothChargesLegs(branch)))
return kFALSE;
// Check the source (primary, secondary, embedded) for the particle
- if (!CheckParticleSource(label, signalMC->GetLegSource(branch)))
- return kFALSE;
+ if (!CheckParticleSource(label, signalMC->GetLegSource(branch))) return kFALSE;
// check the MOTHER
CbmMCTrack* mcMother = 0x0;
Int_t mLabel = -1;
if (signalMC->GetMotherPDG(branch) != 0
- || signalMC->GetMotherSource(branch)
- != PairAnalysisSignalMC::ESource::kDontCare) {
+ || signalMC->GetMotherSource(branch) != PairAnalysisSignalMC::ESource::kDontCare) {
mLabel = GetMothersLabel(label);
mcMother = GetMCTrackFromMCEvent(mLabel);
if (!mcMother && !signalMC->GetMotherPDGexclude(branch)) return kFALSE;
- if (!ComparePDG((mcMother ? mcMother->GetPdgCode() : -99999),
- signalMC->GetMotherPDG(branch),
- signalMC->GetMotherPDGexclude(branch),
- signalMC->GetCheckBothChargesMothers(branch)))
- return kFALSE;
- if (!CheckParticleSource(mLabel, signalMC->GetMotherSource(branch)))
+ if (!ComparePDG((mcMother ? mcMother->GetPdgCode() : -99999), signalMC->GetMotherPDG(branch),
+ signalMC->GetMotherPDGexclude(branch), signalMC->GetCheckBothChargesMothers(branch)))
return kFALSE;
+ if (!CheckParticleSource(mLabel, signalMC->GetMotherSource(branch))) return kFALSE;
//check for dalitz decay
if (!CheckDalitzDecision(mLabel, signalMC)) return kFALSE;
@@ -701,22 +613,17 @@ Bool_t PairAnalysisMC::IsMCTruth(Int_t label,
CbmMCTrack* mcGrandMother = 0x0;
Int_t gmLabel = -1;
if (signalMC->GetGrandMotherPDG(branch) != 0
- || signalMC->GetGrandMotherSource(branch)
- != PairAnalysisSignalMC::ESource::kDontCare) {
+ || signalMC->GetGrandMotherSource(branch) != PairAnalysisSignalMC::ESource::kDontCare) {
if (mcMother) {
gmLabel = GetMothersLabel(mLabel);
mcGrandMother = GetMCTrackFromMCEvent(gmLabel);
}
- if (!mcGrandMother && !signalMC->GetGrandMotherPDGexclude(branch))
- return kFALSE;
+ if (!mcGrandMother && !signalMC->GetGrandMotherPDGexclude(branch)) return kFALSE;
- if (!ComparePDG((mcGrandMother ? mcGrandMother->GetPdgCode() : 0),
- signalMC->GetGrandMotherPDG(branch),
- signalMC->GetGrandMotherPDGexclude(branch),
- signalMC->GetCheckBothChargesGrandMothers(branch)))
- return kFALSE;
- if (!CheckParticleSource(gmLabel, signalMC->GetGrandMotherSource(branch)))
+ if (!ComparePDG((mcGrandMother ? mcGrandMother->GetPdgCode() : 0), signalMC->GetGrandMotherPDG(branch),
+ signalMC->GetGrandMotherPDGexclude(branch), signalMC->GetCheckBothChargesGrandMothers(branch)))
return kFALSE;
+ if (!CheckParticleSource(gmLabel, signalMC->GetGrandMotherSource(branch))) return kFALSE;
}
// check the GREAT GRANDMOTHER
@@ -729,12 +636,10 @@ Bool_t PairAnalysisMC::IsMCTruth(Int_t label,
ggmLabel = GetMothersLabel(gmLabel);
mcGreatGrandMother = GetMCTrackFromMCEvent(ggmLabel);
}
- if (!mcGreatGrandMother && !signalMC->GetGreatGrandMotherPDGexclude(branch))
- return kFALSE;
+ if (!mcGreatGrandMother && !signalMC->GetGreatGrandMotherPDGexclude(branch)) return kFALSE;
if (!ComparePDG((mcGreatGrandMother ? mcGreatGrandMother->GetPdgCode() : 0),
- signalMC->GetGreatGrandMotherPDG(branch),
- signalMC->GetGreatGrandMotherPDGexclude(branch),
+ signalMC->GetGreatGrandMotherPDG(branch), signalMC->GetGreatGrandMotherPDGexclude(branch),
signalMC->GetCheckBothChargesGreatGrandMothers(branch)))
return kFALSE;
// if( !CheckParticleSource(gmLabel, signalMC->GetGreatGrandMotherSource(branch))) return kFALSE;
@@ -744,9 +649,8 @@ Bool_t PairAnalysisMC::IsMCTruth(Int_t label,
}
//________________________________________________________________________________
-Bool_t PairAnalysisMC::IsMCTruth(const PairAnalysisTrack* trk,
- PairAnalysisSignalMC* signalMC,
- Int_t branch) const {
+Bool_t PairAnalysisMC::IsMCTruth(const PairAnalysisTrack* trk, PairAnalysisSignalMC* signalMC, Int_t branch) const
+{
//
// Check if the particle corresponds to the MC truth in signalMC in the branch specified
//
@@ -754,8 +658,8 @@ Bool_t PairAnalysisMC::IsMCTruth(const PairAnalysisTrack* trk,
}
//________________________________________________________________________________
-Bool_t PairAnalysisMC::IsMCTruth(const PairAnalysisPair* pair,
- const PairAnalysisSignalMC* signalMC) const {
+Bool_t PairAnalysisMC::IsMCTruth(const PairAnalysisPair* pair, const PairAnalysisSignalMC* signalMC) const
+{
//
// Check if the pair corresponds to the MC truth in signalMC
//
@@ -791,47 +695,35 @@ Bool_t PairAnalysisMC::IsMCTruth(const PairAnalysisPair* pair,
// make direct(1-1 and 2-2) and cross(1-2 and 2-1) comparisons for the whole branch
Bool_t directTerm = kTRUE;
// daughters
- directTerm = directTerm && mcD1
- && ComparePDG(d1Pdg,
- signalMC->GetLegPDG(1),
- signalMC->GetLegPDGexclude(1),
- signalMC->GetCheckBothChargesLegs(1))
- && CheckParticleSource(labelD1, signalMC->GetLegSource(1));
-
- directTerm = directTerm && mcD2
- && ComparePDG(d2Pdg,
- signalMC->GetLegPDG(2),
- signalMC->GetLegPDGexclude(2),
- signalMC->GetCheckBothChargesLegs(2))
- && CheckParticleSource(labelD2, signalMC->GetLegSource(2));
+ directTerm =
+ directTerm && mcD1
+ && ComparePDG(d1Pdg, signalMC->GetLegPDG(1), signalMC->GetLegPDGexclude(1), signalMC->GetCheckBothChargesLegs(1))
+ && CheckParticleSource(labelD1, signalMC->GetLegSource(1));
+
+ directTerm =
+ directTerm && mcD2
+ && ComparePDG(d2Pdg, signalMC->GetLegPDG(2), signalMC->GetLegPDGexclude(2), signalMC->GetCheckBothChargesLegs(2))
+ && CheckParticleSource(labelD2, signalMC->GetLegSource(2));
// mothers
Int_t labelM1 = -1;
- if (signalMC->GetMotherPDG(1) != 0
- || signalMC->GetMotherSource(1)
- != PairAnalysisSignalMC::ESource::kDontCare) {
+ if (signalMC->GetMotherPDG(1) != 0 || signalMC->GetMotherSource(1) != PairAnalysisSignalMC::ESource::kDontCare) {
labelM1 = GetMothersLabel(labelD1);
if (labelD1 > -1 && labelM1 > -1) mcM1 = GetMCTrackFromMCEvent(labelM1);
directTerm = directTerm && (mcM1 || signalMC->GetMotherPDGexclude(1))
- && ComparePDG((mcM1 ? mcM1->GetPdgCode() : -99999),
- signalMC->GetMotherPDG(1),
- signalMC->GetMotherPDGexclude(1),
- signalMC->GetCheckBothChargesMothers(1))
+ && ComparePDG((mcM1 ? mcM1->GetPdgCode() : -99999), signalMC->GetMotherPDG(1),
+ signalMC->GetMotherPDGexclude(1), signalMC->GetCheckBothChargesMothers(1))
&& CheckParticleSource(labelM1, signalMC->GetMotherSource(1))
&& CheckDalitzDecision(labelM1, signalMC);
}
Int_t labelM2 = -1;
- if (signalMC->GetMotherPDG(2) != 0
- || signalMC->GetMotherSource(2)
- != PairAnalysisSignalMC::ESource::kDontCare) {
+ if (signalMC->GetMotherPDG(2) != 0 || signalMC->GetMotherSource(2) != PairAnalysisSignalMC::ESource::kDontCare) {
labelM2 = GetMothersLabel(labelD2);
if (labelD2 > -1 && labelM2 > -1) mcM2 = GetMCTrackFromMCEvent(labelM2);
directTerm = directTerm && (mcM2 || signalMC->GetMotherPDGexclude(2))
- && ComparePDG((mcM2 ? mcM2->GetPdgCode() : -99999),
- signalMC->GetMotherPDG(2),
- signalMC->GetMotherPDGexclude(2),
- signalMC->GetCheckBothChargesMothers(2))
+ && ComparePDG((mcM2 ? mcM2->GetPdgCode() : -99999), signalMC->GetMotherPDG(2),
+ signalMC->GetMotherPDGexclude(2), signalMC->GetCheckBothChargesMothers(2))
&& CheckParticleSource(labelM2, signalMC->GetMotherSource(2))
&& CheckDalitzDecision(labelM2, signalMC);
}
@@ -839,188 +731,144 @@ Bool_t PairAnalysisMC::IsMCTruth(const PairAnalysisPair* pair,
// grand-mothers
Int_t labelG1 = -1;
if (signalMC->GetGrandMotherPDG(1) != 0
- || signalMC->GetGrandMotherSource(1)
- != PairAnalysisSignalMC::ESource::kDontCare) {
+ || signalMC->GetGrandMotherSource(1) != PairAnalysisSignalMC::ESource::kDontCare) {
labelG1 = GetMothersLabel(labelM1);
if (mcM1 && labelG1 > -1) mcG1 = GetMCTrackFromMCEvent(labelG1);
- directTerm =
- directTerm && (mcG1 || signalMC->GetGrandMotherPDGexclude(1))
- && ComparePDG((mcG1 ? mcG1->GetPdgCode() : 0),
- signalMC->GetGrandMotherPDG(1),
- signalMC->GetGrandMotherPDGexclude(1),
- signalMC->GetCheckBothChargesGrandMothers(1))
- && CheckParticleSource(labelG1, signalMC->GetGrandMotherSource(1));
+ directTerm = directTerm && (mcG1 || signalMC->GetGrandMotherPDGexclude(1))
+ && ComparePDG((mcG1 ? mcG1->GetPdgCode() : 0), signalMC->GetGrandMotherPDG(1),
+ signalMC->GetGrandMotherPDGexclude(1), signalMC->GetCheckBothChargesGrandMothers(1))
+ && CheckParticleSource(labelG1, signalMC->GetGrandMotherSource(1));
}
Int_t labelG2 = -1;
if (signalMC->GetGrandMotherPDG(2) != 0
- || signalMC->GetGrandMotherSource(2)
- != PairAnalysisSignalMC::ESource::kDontCare) {
+ || signalMC->GetGrandMotherSource(2) != PairAnalysisSignalMC::ESource::kDontCare) {
labelG2 = GetMothersLabel(labelM2);
if (mcM2 && labelG2 > -1) mcG2 = GetMCTrackFromMCEvent(labelG2);
- directTerm =
- directTerm && (mcG2 || signalMC->GetGrandMotherPDGexclude(2))
- && ComparePDG((mcG2 ? mcG2->GetPdgCode() : 0),
- signalMC->GetGrandMotherPDG(2),
- signalMC->GetGrandMotherPDGexclude(2),
- signalMC->GetCheckBothChargesGrandMothers(2))
- && CheckParticleSource(labelG2, signalMC->GetGrandMotherSource(2));
+ directTerm = directTerm && (mcG2 || signalMC->GetGrandMotherPDGexclude(2))
+ && ComparePDG((mcG2 ? mcG2->GetPdgCode() : 0), signalMC->GetGrandMotherPDG(2),
+ signalMC->GetGrandMotherPDGexclude(2), signalMC->GetCheckBothChargesGrandMothers(2))
+ && CheckParticleSource(labelG2, signalMC->GetGrandMotherSource(2));
}
// great grand-mothers
Int_t labelGG1 = -1;
- if (
- signalMC->GetGreatGrandMotherPDG(1) != 0
- /* || signalMC->GetGreatGrandMotherSource(1)!=PairAnalysisSignalMC::ESource::kDontCare*/) {
+ if (signalMC->GetGreatGrandMotherPDG(1) != 0
+ /* || signalMC->GetGreatGrandMotherSource(1)!=PairAnalysisSignalMC::ESource::kDontCare*/) {
labelGG1 = GetMothersLabel(labelG1);
if (mcG1 && labelGG1 > -1) mcGG1 = GetMCTrackFromMCEvent(labelGG1);
directTerm =
directTerm && (mcGG1 || signalMC->GetGreatGrandMotherPDGexclude(1))
- && ComparePDG((mcGG1 ? mcGG1->GetPdgCode() : 0),
- signalMC->GetGreatGrandMotherPDG(1),
- signalMC->GetGreatGrandMotherPDGexclude(1),
- signalMC->GetCheckBothChargesGreatGrandMothers(1));
+ && ComparePDG((mcGG1 ? mcGG1->GetPdgCode() : 0), signalMC->GetGreatGrandMotherPDG(1),
+ signalMC->GetGreatGrandMotherPDGexclude(1), signalMC->GetCheckBothChargesGreatGrandMothers(1));
// && CheckParticleSource(labelGG1, signalMC->GetGreatGrandMotherSource(1));
}
Int_t labelGG2 = -1;
- if (
- signalMC->GetGreatGrandMotherPDG(2) != 0
- /* || signalMC->GetGreatGrandMotherSource(2)!=PairAnalysisSignalMC::ESource::kDontCare*/) {
+ if (signalMC->GetGreatGrandMotherPDG(2) != 0
+ /* || signalMC->GetGreatGrandMotherSource(2)!=PairAnalysisSignalMC::ESource::kDontCare*/) {
labelGG2 = GetMothersLabel(labelG2);
if (mcG2 && labelGG2 > -1) mcGG2 = GetMCTrackFromMCEvent(labelGG2);
directTerm =
directTerm && (mcGG2 || signalMC->GetGreatGrandMotherPDGexclude(2))
- && ComparePDG((mcGG2 ? mcGG2->GetPdgCode() : 0),
- signalMC->GetGreatGrandMotherPDG(2),
- signalMC->GetGreatGrandMotherPDGexclude(2),
- signalMC->GetCheckBothChargesGreatGrandMothers(2));
+ && ComparePDG((mcGG2 ? mcGG2->GetPdgCode() : 0), signalMC->GetGreatGrandMotherPDG(2),
+ signalMC->GetGreatGrandMotherPDGexclude(2), signalMC->GetCheckBothChargesGreatGrandMothers(2));
// && CheckParticleSource(labelG2, signalMC->GetGreatGrandMotherSource(2));
}
// Cross term
Bool_t crossTerm = kTRUE;
// daughters
- crossTerm = crossTerm && mcD2
- && ComparePDG(d2Pdg,
- signalMC->GetLegPDG(1),
- signalMC->GetLegPDGexclude(1),
- signalMC->GetCheckBothChargesLegs(1))
- && CheckParticleSource(labelD2, signalMC->GetLegSource(1));
-
- crossTerm = crossTerm && mcD1
- && ComparePDG(d1Pdg,
- signalMC->GetLegPDG(2),
- signalMC->GetLegPDGexclude(2),
- signalMC->GetCheckBothChargesLegs(2))
- && CheckParticleSource(labelD1, signalMC->GetLegSource(2));
+ crossTerm =
+ crossTerm && mcD2
+ && ComparePDG(d2Pdg, signalMC->GetLegPDG(1), signalMC->GetLegPDGexclude(1), signalMC->GetCheckBothChargesLegs(1))
+ && CheckParticleSource(labelD2, signalMC->GetLegSource(1));
+
+ crossTerm =
+ crossTerm && mcD1
+ && ComparePDG(d1Pdg, signalMC->GetLegPDG(2), signalMC->GetLegPDGexclude(2), signalMC->GetCheckBothChargesLegs(2))
+ && CheckParticleSource(labelD1, signalMC->GetLegSource(2));
// mothers
- if (signalMC->GetMotherPDG(1) != 0
- || signalMC->GetMotherSource(1)
- != PairAnalysisSignalMC::ESource::kDontCare) {
+ if (signalMC->GetMotherPDG(1) != 0 || signalMC->GetMotherSource(1) != PairAnalysisSignalMC::ESource::kDontCare) {
if (!mcM2 && labelD2 > -1) {
labelM2 = GetMothersLabel(labelD2);
if (labelM2 > -1) mcM2 = GetMCTrackFromMCEvent(labelM2);
}
crossTerm = crossTerm && (mcM2 || signalMC->GetMotherPDGexclude(1))
- && ComparePDG((mcM2 ? mcM2->GetPdgCode() : -99999),
- signalMC->GetMotherPDG(1),
- signalMC->GetMotherPDGexclude(1),
- signalMC->GetCheckBothChargesMothers(1))
- && CheckParticleSource(labelM2, signalMC->GetMotherSource(1))
- && CheckDalitzDecision(labelM2, signalMC);
+ && ComparePDG((mcM2 ? mcM2->GetPdgCode() : -99999), signalMC->GetMotherPDG(1),
+ signalMC->GetMotherPDGexclude(1), signalMC->GetCheckBothChargesMothers(1))
+ && CheckParticleSource(labelM2, signalMC->GetMotherSource(1)) && CheckDalitzDecision(labelM2, signalMC);
}
- if (signalMC->GetMotherPDG(2) != 0
- || signalMC->GetMotherSource(2)
- != PairAnalysisSignalMC::ESource::kDontCare) {
+ if (signalMC->GetMotherPDG(2) != 0 || signalMC->GetMotherSource(2) != PairAnalysisSignalMC::ESource::kDontCare) {
if (!mcM1 && labelD1 > -1) {
labelM1 = GetMothersLabel(labelD1);
if (labelM1 > -1) mcM1 = GetMCTrackFromMCEvent(labelM1);
}
crossTerm = crossTerm && (mcM1 || signalMC->GetMotherPDGexclude(2))
- && ComparePDG((mcM1 ? mcM1->GetPdgCode() : -99999),
- signalMC->GetMotherPDG(2),
- signalMC->GetMotherPDGexclude(2),
- signalMC->GetCheckBothChargesMothers(2))
- && CheckParticleSource(labelM1, signalMC->GetMotherSource(2))
- && CheckDalitzDecision(labelM1, signalMC);
+ && ComparePDG((mcM1 ? mcM1->GetPdgCode() : -99999), signalMC->GetMotherPDG(2),
+ signalMC->GetMotherPDGexclude(2), signalMC->GetCheckBothChargesMothers(2))
+ && CheckParticleSource(labelM1, signalMC->GetMotherSource(2)) && CheckDalitzDecision(labelM1, signalMC);
}
// grand-mothers
if (signalMC->GetGrandMotherPDG(1) != 0
- || signalMC->GetGrandMotherSource(1)
- != PairAnalysisSignalMC::ESource::kDontCare) {
+ || signalMC->GetGrandMotherSource(1) != PairAnalysisSignalMC::ESource::kDontCare) {
if (!mcG2 && mcM2) {
labelG2 = GetMothersLabel(labelM2);
if (labelG2 > -1) mcG2 = GetMCTrackFromMCEvent(labelG2);
}
- crossTerm =
- crossTerm && (mcG2 || signalMC->GetGrandMotherPDGexclude(1))
- && ComparePDG((mcG2 ? mcG2->GetPdgCode() : 0),
- signalMC->GetGrandMotherPDG(1),
- signalMC->GetGrandMotherPDGexclude(1),
- signalMC->GetCheckBothChargesGrandMothers(1))
- && CheckParticleSource(labelG2, signalMC->GetGrandMotherSource(1));
+ crossTerm = crossTerm && (mcG2 || signalMC->GetGrandMotherPDGexclude(1))
+ && ComparePDG((mcG2 ? mcG2->GetPdgCode() : 0), signalMC->GetGrandMotherPDG(1),
+ signalMC->GetGrandMotherPDGexclude(1), signalMC->GetCheckBothChargesGrandMothers(1))
+ && CheckParticleSource(labelG2, signalMC->GetGrandMotherSource(1));
}
if (signalMC->GetGrandMotherPDG(2) != 0
- || signalMC->GetGrandMotherSource(2)
- != PairAnalysisSignalMC::ESource::kDontCare) {
+ || signalMC->GetGrandMotherSource(2) != PairAnalysisSignalMC::ESource::kDontCare) {
if (!mcG1 && mcM1) {
labelG1 = GetMothersLabel(labelM1);
if (labelG1 > -1) mcG1 = GetMCTrackFromMCEvent(labelG1);
}
- crossTerm =
- crossTerm && (mcG1 || signalMC->GetGrandMotherPDGexclude(2))
- && ComparePDG((mcG1 ? mcG1->GetPdgCode() : 0),
- signalMC->GetGrandMotherPDG(2),
- signalMC->GetGrandMotherPDGexclude(2),
- signalMC->GetCheckBothChargesGrandMothers(2))
- && CheckParticleSource(labelG1, signalMC->GetGrandMotherSource(2));
+ crossTerm = crossTerm && (mcG1 || signalMC->GetGrandMotherPDGexclude(2))
+ && ComparePDG((mcG1 ? mcG1->GetPdgCode() : 0), signalMC->GetGrandMotherPDG(2),
+ signalMC->GetGrandMotherPDGexclude(2), signalMC->GetCheckBothChargesGrandMothers(2))
+ && CheckParticleSource(labelG1, signalMC->GetGrandMotherSource(2));
}
// great grand-mothers
- if (
- signalMC->GetGreatGrandMotherPDG(1) != 0
- /*|| signalMC->GetGreatGrandMotherSource(1)!=PairAnalysisSignalMC::ESource::kDontCare*/) {
+ if (signalMC->GetGreatGrandMotherPDG(1) != 0
+ /*|| signalMC->GetGreatGrandMotherSource(1)!=PairAnalysisSignalMC::ESource::kDontCare*/) {
if (!mcGG2 && mcG2) {
labelGG2 = GetMothersLabel(labelG2);
if (labelGG2 > -1) mcGG2 = GetMCTrackFromMCEvent(labelGG2);
}
crossTerm =
crossTerm && (mcGG2 || signalMC->GetGreatGrandMotherPDGexclude(1))
- && ComparePDG((mcGG2 ? mcGG2->GetPdgCode() : 0),
- signalMC->GetGreatGrandMotherPDG(1),
- signalMC->GetGreatGrandMotherPDGexclude(1),
- signalMC->GetCheckBothChargesGreatGrandMothers(1));
+ && ComparePDG((mcGG2 ? mcGG2->GetPdgCode() : 0), signalMC->GetGreatGrandMotherPDG(1),
+ signalMC->GetGreatGrandMotherPDGexclude(1), signalMC->GetCheckBothChargesGreatGrandMothers(1));
// && CheckParticleSource(labelG2, signalMC->GetGreatGrandMotherSource(1));
}
- if (
- signalMC->GetGreatGrandMotherPDG(2) != 0
- /* || signalMC->GetGreatGrandMotherSource(2)!=PairAnalysisSignalMC::ESource::kDontCare*/) {
+ if (signalMC->GetGreatGrandMotherPDG(2) != 0
+ /* || signalMC->GetGreatGrandMotherSource(2)!=PairAnalysisSignalMC::ESource::kDontCare*/) {
if (!mcGG1 && mcG1) {
labelGG1 = GetMothersLabel(labelG1);
if (labelGG1 > -1) mcGG1 = GetMCTrackFromMCEvent(labelGG1);
}
crossTerm =
crossTerm && (mcGG1 || signalMC->GetGreatGrandMotherPDGexclude(2))
- && ComparePDG((mcGG1 ? mcGG1->GetPdgCode() : 0),
- signalMC->GetGreatGrandMotherPDG(2),
- signalMC->GetGreatGrandMotherPDGexclude(2),
- signalMC->GetCheckBothChargesGreatGrandMothers(2));
+ && ComparePDG((mcGG1 ? mcGG1->GetPdgCode() : 0), signalMC->GetGreatGrandMotherPDG(2),
+ signalMC->GetGreatGrandMotherPDGexclude(2), signalMC->GetCheckBothChargesGreatGrandMothers(2));
// && CheckParticleSource(labelG1, signalMC->GetGreatGrandMotherSource(2));
}
Bool_t motherRelation = kTRUE;
- if (signalMC->GetMothersRelation()
- == PairAnalysisSignalMC::EBranchRelation::kSame) {
+ if (signalMC->GetMothersRelation() == PairAnalysisSignalMC::EBranchRelation::kSame) {
motherRelation = motherRelation && HaveSameMother(pair);
}
- if (signalMC->GetMothersRelation()
- == PairAnalysisSignalMC::EBranchRelation::kDifferent) {
+ if (signalMC->GetMothersRelation() == PairAnalysisSignalMC::EBranchRelation::kDifferent) {
motherRelation = motherRelation && !HaveSameMother(pair);
}
@@ -1029,7 +877,8 @@ Bool_t PairAnalysisMC::IsMCTruth(const PairAnalysisPair* pair,
}
//____________________________________________________________
-Bool_t PairAnalysisMC::HaveSameMother(const PairAnalysisPair* pair) const {
+Bool_t PairAnalysisMC::HaveSameMother(const PairAnalysisPair* pair) const
+{
//
// Check whether two particles have the same mother
//
@@ -1044,14 +893,14 @@ Bool_t PairAnalysisMC::HaveSameMother(const PairAnalysisPair* pair) const {
Int_t labelMother1 = mcDaughter1->GetMotherId();
Int_t labelMother2 = mcDaughter2->GetMotherId();
- Bool_t sameMother = (labelMother1 > -1) && (labelMother2 > -1)
- && (labelMother1 == labelMother2);
+ Bool_t sameMother = (labelMother1 > -1) && (labelMother2 > -1) && (labelMother1 == labelMother2);
return sameMother;
}
//____________________________________________________________
-Bool_t PairAnalysisMC::IsPhysicalPrimary(Int_t label, UInt_t processID) const {
+Bool_t PairAnalysisMC::IsPhysicalPrimary(Int_t label, UInt_t processID) const
+{
// initial state particle
if (processID != kPPrimary) return kFALSE;
@@ -1102,8 +951,7 @@ Bool_t PairAnalysisMC::IsPhysicalPrimary(Int_t label, UInt_t processID) const {
// Check if it comes from a pi0 decay
if ((pdgMother == kPi0) && (processMother == kPPrimary)) return kTRUE;
// Check if it this is a heavy flavor decay product
- Int_t mfl =
- Int_t(pdgMother / TMath::Power(10, Int_t(TMath::Log10(pdgMother))));
+ Int_t mfl = Int_t(pdgMother / TMath::Power(10, Int_t(TMath::Log10(pdgMother))));
if (mfl < 4) return kFALSE; // Light hadron
// Heavy flavor hadron produced by generator
if (processMother == kPPrimary) return kTRUE;
@@ -1113,37 +961,33 @@ Bool_t PairAnalysisMC::IsPhysicalPrimary(Int_t label, UInt_t processID) const {
mother = GetMCTrackFromMCEvent(mLabel);
}
pdgMother = TMath::Abs(mother->GetPdgCode());
- mfl = Int_t(pdgMother / TMath::Power(10, Int_t(TMath::Log10(pdgMother))));
+ mfl = Int_t(pdgMother / TMath::Power(10, Int_t(TMath::Log10(pdgMother))));
return (mfl < 4 ? kFALSE : kTRUE);
}
//____________________________________________________________
-Bool_t PairAnalysisMC::IsSecondaryFromWeakDecay(Int_t label,
- UInt_t processID) const {
+Bool_t PairAnalysisMC::IsSecondaryFromWeakDecay(Int_t label, UInt_t processID) const
+{
if (IsPhysicalPrimary(label, processID)) return kFALSE;
if (processID != kPDecay) return kFALSE;
- Float_t pdgMother =
- (Float_t) TMath::Abs(GetPdgFromLabel(GetMothersLabel(label)));
+ Float_t pdgMother = (Float_t) TMath::Abs(GetPdgFromLabel(GetMothersLabel(label)));
// mass fo the flavour
- Int_t mfl =
- Int_t(pdgMother / TMath::Power(10, Int_t(TMath::Log10(pdgMother))));
+ Int_t mfl = Int_t(pdgMother / TMath::Power(10, Int_t(TMath::Log10(pdgMother))));
// mother has strangeness, pion+- or muon decay
- if (mfl == 3 || pdgMother == 211 || pdgMother == 13)
- return kTRUE;
+ if (mfl == 3 || pdgMother == 211 || pdgMother == 13) return kTRUE;
else
return kFALSE;
}
//____________________________________________________________
-Bool_t PairAnalysisMC::IsSecondaryFromMaterial(Int_t label,
- UInt_t processID) const {
+Bool_t PairAnalysisMC::IsSecondaryFromMaterial(Int_t label, UInt_t processID) const
+{
if (IsPhysicalPrimary(label, processID)) return kFALSE;
if (IsSecondaryFromWeakDecay(label, processID)) return kFALSE;
// Check if it is a non-stable product or one of the beams
CbmMCTrack* mother = GetMCTrackFromMCEvent(GetMothersLabel(label));
- if (!mother)
- return kFALSE;
+ if (!mother) return kFALSE;
else
return kTRUE;
}
diff --git a/analysis/PWGDIL/dielectron/papaframework/PairAnalysisMC.h b/analysis/PWGDIL/dielectron/papaframework/PairAnalysisMC.h
index 3a5db0c889beb75624e6c9b2005c03d35d01e500..d32a2b8f884e5d8cc7cdb5be860b14e66343bb9f 100644
--- a/analysis/PWGDIL/dielectron/papaframework/PairAnalysisMC.h
+++ b/analysis/PWGDIL/dielectron/papaframework/PairAnalysisMC.h
@@ -12,6 +12,7 @@
//#####################################################
#ifndef ROOT_TObject
+#include <TClonesArray.h>
#include <TMCProcess.h>
#include <TObject.h>
#endif
@@ -33,26 +34,18 @@ public:
static PairAnalysisMC* Instance();
- Int_t GetNMCTracks(); // return number of generated tracks
- Int_t GetMotherPDG(
- const PairAnalysisTrack* _track); // return mother PID from the MC stack
- Int_t GetMotherPDG(
- const CbmMCTrack* _track); // return mother PID from the MC stack
+ Int_t GetNMCTracks(); // return number of generated tracks
+ Int_t GetMotherPDG(const PairAnalysisTrack* _track); // return mother PID from the MC stack
+ Int_t GetMotherPDG(const CbmMCTrack* _track); // return mother PID from the MC stack
Bool_t ConnectMCEvent();
Bool_t IsMotherPdg(const PairAnalysisPair* pair, Int_t pdgMother);
- Bool_t IsMotherPdg(const PairAnalysisTrack* particle1,
- const PairAnalysisTrack* particle2,
- Int_t pdgMother);
-
- Bool_t IsMCTruth(const PairAnalysisPair* pair,
- const PairAnalysisSignalMC* signalMC) const;
- Bool_t IsMCTruth(const PairAnalysisTrack* trk,
- PairAnalysisSignalMC* signalMC,
- Int_t branch) const;
- Bool_t
- IsMCTruth(Int_t label, PairAnalysisSignalMC* signalMC, Int_t branch) const;
+ Bool_t IsMotherPdg(const PairAnalysisTrack* particle1, const PairAnalysisTrack* particle2, Int_t pdgMother);
+
+ Bool_t IsMCTruth(const PairAnalysisPair* pair, const PairAnalysisSignalMC* signalMC) const;
+ Bool_t IsMCTruth(const PairAnalysisTrack* trk, PairAnalysisSignalMC* signalMC, Int_t branch) const;
+ Bool_t IsMCTruth(Int_t label, PairAnalysisSignalMC* signalMC, Int_t branch) const;
Int_t GetMothersLabel(Int_t daughterLabel) const;
Int_t GetPdgFromLabel(Int_t label) const;
@@ -65,27 +58,18 @@ public:
Bool_t HaveSameMother(const PairAnalysisPair* pair) const;
Int_t GetLabelMotherWithPdg(const PairAnalysisPair* pair, Int_t pdgMother);
- Int_t GetLabelMotherWithPdg(const PairAnalysisTrack* particle1,
- const PairAnalysisTrack* particle2,
- Int_t pdgMother);
+ Int_t GetLabelMotherWithPdg(const PairAnalysisTrack* particle1, const PairAnalysisTrack* particle2, Int_t pdgMother);
- CbmMCTrack* GetMCTrackFromMCEvent(
- Int_t label) const; // return MC track directly from MC event
- CbmMCTrack*
- GetMCTrack(const PairAnalysisTrack*
- _track); // return MC track associated with reco track
+ CbmMCTrack* GetMCTrackFromMCEvent(Int_t label) const; // return MC track directly from MC event
+ CbmMCTrack* GetMCTrack(const PairAnalysisTrack* _track); // return MC track associated with reco track
- CbmMCTrack* GetMCTrackMother(
- const PairAnalysisTrack* _track); // return MC mother for reco track
- CbmMCTrack*
- GetMCTrackMother(const CbmMCTrack* _track); // return MC mother for mc rtack
+ CbmMCTrack* GetMCTrackMother(const PairAnalysisTrack* _track); // return MC mother for reco track
+ CbmMCTrack* GetMCTrackMother(const CbmMCTrack* _track); // return MC mother for mc rtack
- Int_t
- NumberOfDaughters(const CbmMCTrack* particle); // return number of daughters
+ Int_t NumberOfDaughters(const CbmMCTrack* particle); // return number of daughters
void GetDaughters(const TObject* mother, CbmMCTrack*& d1, CbmMCTrack*& d2);
- Bool_t CheckParticleSource(Int_t label,
- PairAnalysisSignalMC::ESource source) const;
+ Bool_t CheckParticleSource(Int_t label, PairAnalysisSignalMC::ESource source) const;
// Bool_t GetPrimaryVertex(Double_t &primVtxX, Double_t &primVtxY, Double_t &primVtxZ);
// AliMCEvent* GetMCEvent() { return fMCEvent; } // return the AliMCEvent
@@ -99,15 +83,10 @@ private:
PairAnalysisMC(const PairAnalysisMC& c);
PairAnalysisMC& operator=(const PairAnalysisMC& c);
- Bool_t ComparePDG(Int_t particlePDG,
- Int_t requiredPDG,
- Bool_t pdgExclusion,
- Bool_t checkBothCharges) const;
+ Bool_t ComparePDG(Int_t particlePDG, Int_t requiredPDG, Bool_t pdgExclusion, Bool_t checkBothCharges) const;
- Bool_t CheckIsDalitz(Int_t label,
- const PairAnalysisSignalMC* const signalMC) const;
- Bool_t CheckDalitzDecision(Int_t mLabel,
- const PairAnalysisSignalMC* const signalMC) const;
+ Bool_t CheckIsDalitz(Int_t label, const PairAnalysisSignalMC* const signalMC) const;
+ Bool_t CheckDalitzDecision(Int_t mLabel, const PairAnalysisSignalMC* const signalMC) const;
Bool_t IsPhysicalPrimary(Int_t label, UInt_t processID) const;
Bool_t IsSecondaryFromWeakDecay(Int_t label, UInt_t processID) const;
Bool_t IsSecondaryFromMaterial(Int_t label, UInt_t processID) const;
@@ -118,22 +97,20 @@ private:
//
// inline functions
//
-inline Bool_t PairAnalysisMC::IsMotherPdg(const PairAnalysisPair* pair,
- Int_t pdgMother) {
- return IsMotherPdg(
- pair->GetFirstDaughter(), pair->GetSecondDaughter(), pdgMother);
+inline Bool_t PairAnalysisMC::IsMotherPdg(const PairAnalysisPair* pair, Int_t pdgMother)
+{
+ return IsMotherPdg(pair->GetFirstDaughter(), pair->GetSecondDaughter(), pdgMother);
}
//___________________________________________________________
-inline Bool_t PairAnalysisMC::IsMotherPdg(const PairAnalysisTrack* particle1,
- const PairAnalysisTrack* particle2,
- Int_t pdgMother) {
+inline Bool_t PairAnalysisMC::IsMotherPdg(const PairAnalysisTrack* particle1, const PairAnalysisTrack* particle2,
+ Int_t pdgMother)
+{
return GetLabelMotherWithPdg(particle1, particle2, pdgMother) >= 0;
}
//___________________________________________________________
-inline Int_t PairAnalysisMC::GetLabelMotherWithPdg(const PairAnalysisPair* pair,
- Int_t pdgMother) {
- return GetLabelMotherWithPdg(
- pair->GetFirstDaughter(), pair->GetSecondDaughter(), pdgMother);
+inline Int_t PairAnalysisMC::GetLabelMotherWithPdg(const PairAnalysisPair* pair, Int_t pdgMother)
+{
+ return GetLabelMotherWithPdg(pair->GetFirstDaughter(), pair->GetSecondDaughter(), pdgMother);
}
#endif
diff --git a/analysis/PWGDIL/dielectron/papaframework/PairAnalysisMetaData.cxx b/analysis/PWGDIL/dielectron/papaframework/PairAnalysisMetaData.cxx
index d9e2606f991c8fb57d99482a4cfd30fd833d5a49..353f2944ec91ca7758545068193c2b31b5e7dd3f 100644
--- a/analysis/PWGDIL/dielectron/papaframework/PairAnalysisMetaData.cxx
+++ b/analysis/PWGDIL/dielectron/papaframework/PairAnalysisMetaData.cxx
@@ -34,16 +34,16 @@ ClassImp(PairAnalysisMetaData)
PairAnalysisMetaData::PairAnalysisMetaData()
- : PairAnalysisMetaData("PairAnalysis_MetaData",
- "PairAnalysis MetaData Container") {
+ : PairAnalysisMetaData("PairAnalysis_MetaData", "PairAnalysis MetaData Container")
+{
//
// Default constructor
//
}
//_____________________________________________________________________________
-PairAnalysisMetaData::PairAnalysisMetaData(const char* name, const char* title)
- : TNamed(name, title), fMetaList() {
+PairAnalysisMetaData::PairAnalysisMetaData(const char* name, const char* title) : TNamed(name, title), fMetaList()
+{
//
// TNamed constructor
//
@@ -52,7 +52,8 @@ PairAnalysisMetaData::PairAnalysisMetaData(const char* name, const char* title)
}
//_____________________________________________________________________________
-PairAnalysisMetaData::~PairAnalysisMetaData() {
+PairAnalysisMetaData::~PairAnalysisMetaData()
+{
//
// Destructor
//
@@ -60,7 +61,8 @@ PairAnalysisMetaData::~PairAnalysisMetaData() {
}
//_____________________________________________________________________________
-void PairAnalysisMetaData::Init() {
+void PairAnalysisMetaData::Init()
+{
//
// Init meta data objects and add to list
//
@@ -77,8 +79,7 @@ void PairAnalysisMetaData::Init() {
// pProduction->SetTitle(gProduction->Getenv("USER"));
fMetaList.Add(pProduction);
- TParameter<Double_t>* pBeamEnergy =
- new TParameter<Double_t>("beamenergy", 4.107);
+ TParameter<Double_t>* pBeamEnergy = new TParameter<Double_t>("beamenergy", 4.107);
// pBeamEnergy->SetBit(TParameter<Double_t>::kIsConst);
pBeamEnergy->SetBit(TParameter<Double_t>::kFirst);
fMetaList.Add(pBeamEnergy);
@@ -98,13 +99,11 @@ void PairAnalysisMetaData::Init() {
// TNamed *pRootVers = new TNamed("root", "XXX");
// pRootVers->SetTitle(gROOT->GetVersion());
- TParameter<Int_t>* pRootVers =
- new TParameter<Int_t>("root", gROOT->GetVersionInt());
+ TParameter<Int_t>* pRootVers = new TParameter<Int_t>("root", gROOT->GetVersionInt());
pRootVers->SetBit(TParameter<Int_t>::kIsConst);
fMetaList.Add(pRootVers);
- gSystem->Setenv("CBMROOT_SVN_REVISION",
- gSystem->GetFromPipe("svnversion $VMCWORKDIR"));
+ gSystem->Setenv("CBMROOT_SVN_REVISION", gSystem->GetFromPipe("svnversion $VMCWORKDIR"));
TString rev = gSystem->Getenv("CBMROOT_SVN_REVISION");
TParameter<Int_t>* pCbmRev = new TParameter<Int_t>("cbmroot", 0);
pCbmRev->SetBit(TParameter<Int_t>::kIsConst);
@@ -122,8 +121,8 @@ void PairAnalysisMetaData::Init() {
}
//_____________________________________________________________________________
-void PairAnalysisMetaData::SetMetaData(TList& list,
- Bool_t setOwner /*=kTRUE*/) {
+void PairAnalysisMetaData::SetMetaData(TList& list, Bool_t setOwner /*=kTRUE*/)
+{
//
// set container classes to this instance. It will take onwnership!
//
@@ -138,30 +137,32 @@ void PairAnalysisMetaData::SetMetaData(TList& list,
if (setOwner) {
list.SetOwner(kFALSE);
fMetaList.SetOwner(kTRUE);
- } else {
+ }
+ else {
fMetaList.SetOwner(kFALSE);
}
}
-void PairAnalysisMetaData::FillMeta(const char* name, Double_t val) {
+void PairAnalysisMetaData::FillMeta(const char* name, Double_t val)
+{
//
// fill meta data of doubles
//
- TParameter<Double_t>* par =
- dynamic_cast<TParameter<Double_t>*>(fMetaList.FindObject(name));
+ TParameter<Double_t>* par = dynamic_cast<TParameter<Double_t>*>(fMetaList.FindObject(name));
par->SetVal(val);
}
-void PairAnalysisMetaData::FillMeta(const char* name, Int_t val) {
+void PairAnalysisMetaData::FillMeta(const char* name, Int_t val)
+{
//
// fill meta data of integers
//
- TParameter<Int_t>* par =
- dynamic_cast<TParameter<Int_t>*>(fMetaList.FindObject(name));
+ TParameter<Int_t>* par = dynamic_cast<TParameter<Int_t>*>(fMetaList.FindObject(name));
par->SetVal(val);
}
-void PairAnalysisMetaData::FillMeta(const char* name, const char* val) {
+void PairAnalysisMetaData::FillMeta(const char* name, const char* val)
+{
//
// fill meta data of strings
//
@@ -169,25 +170,26 @@ void PairAnalysisMetaData::FillMeta(const char* name, const char* val) {
par->SetTitle(val);
}
-void PairAnalysisMetaData::GetMeta(const char* name, Int_t* val) {
+void PairAnalysisMetaData::GetMeta(const char* name, Int_t* val)
+{
//
// get meta data value for integers
//
- TParameter<Int_t>* par =
- dynamic_cast<TParameter<Int_t>*>(fMetaList.FindObject(name));
+ TParameter<Int_t>* par = dynamic_cast<TParameter<Int_t>*>(fMetaList.FindObject(name));
if (par) *val = par->GetVal();
}
-void PairAnalysisMetaData::GetMeta(const char* name, Double_t* val) {
+void PairAnalysisMetaData::GetMeta(const char* name, Double_t* val)
+{
//
// get meta data value for doubles
//
- TParameter<Double_t>* par =
- dynamic_cast<TParameter<Double_t>*>(fMetaList.FindObject(name));
+ TParameter<Double_t>* par = dynamic_cast<TParameter<Double_t>*>(fMetaList.FindObject(name));
if (par) *val = par->GetVal();
}
-void PairAnalysisMetaData::DrawSame(TString opt /*="msb"*/) {
+void PairAnalysisMetaData::DrawSame(TString opt /*="msb"*/)
+{
//
// draw meta data into current pad
// use option string to select information displayed:
@@ -199,11 +201,8 @@ void PairAnalysisMetaData::DrawSame(TString opt /*="msb"*/) {
//
if (fMetaList.GetEntries() < 1) return;
- TPaveText* pt = new TPaveText(gPad->GetLeftMargin() + 0.05,
- 1. - gPad->GetTopMargin() + 0.01,
- 1. - gPad->GetRightMargin() - 0.05,
- 0.99,
- "NDCNB");
+ TPaveText* pt = new TPaveText(gPad->GetLeftMargin() + 0.05, 1. - gPad->GetTopMargin() + 0.01,
+ 1. - gPad->GetRightMargin() - 0.05, 0.99, "NDCNB");
pt->SetName("meta");
pt->SetTextAlign(kHAlignLeft + kVAlignCenter);
pt->SetMargin(0.01); //default 0.05
@@ -212,8 +211,7 @@ void PairAnalysisMetaData::DrawSame(TString opt /*="msb"*/) {
TString tmp = "";
// simulation (only if true)
- TParameter<Bool_t>* parB =
- dynamic_cast<TParameter<Bool_t>*>(fMetaList.FindObject("mc"));
+ TParameter<Bool_t>* parB = dynamic_cast<TParameter<Bool_t>*>(fMetaList.FindObject("mc"));
if (opt.Contains("m") && parB && parB->GetVal()) {
tmp = Form(" Simulation");
line += tmp;
@@ -225,15 +223,14 @@ void PairAnalysisMetaData::DrawSame(TString opt /*="msb"*/) {
if (!tmp.IsNull()) line += ", " + tmp;
// beamenergy
- TParameter<Double_t>* parD =
- dynamic_cast<TParameter<Double_t>*>(fMetaList.FindObject("beamenergy"));
+ TParameter<Double_t>* parD = dynamic_cast<TParameter<Double_t>*>(fMetaList.FindObject("beamenergy"));
if (opt.Contains("b") && parD) {
- if (tmp.Contains("p"))
- tmp = Form("#it{E}_{beam} = %.2f GeV", parD->GetVal());
+ if (tmp.Contains("p")) tmp = Form("#it{E}_{beam} = %.2f GeV", parD->GetVal());
else
tmp = Form("#it{E}_{beam} = %.2f #it{A}GeV", parD->GetVal());
if (!tmp.IsNull()) line += " " + tmp;
- } else if (opt.Contains("S") && parD) {
+ }
+ else if (opt.Contains("S") && parD) {
TString sys(par->GetTitle());
sys.ReplaceAll("+", "");
sys.ReplaceAll("-", "");
@@ -247,15 +244,14 @@ void PairAnalysisMetaData::DrawSame(TString opt /*="msb"*/) {
zProj = 1;
aTarg = 1;
zTarg = 1;
- } else {
+ }
+ else {
/// get charge and atomic number of elements from database
TGeoElementTable g(0);
TString targ = (sys(sys.Length() - 2, sys.Length()));
TString proj = (sys(0, sys.Length() - 2));
proj.ReplaceAll("p", "H");
- aProj =
- g.FindElement(proj.Data())->A()
- + 0.05; // add a small number to get proper rounding (e.g. Au: 196->197)
+ aProj = g.FindElement(proj.Data())->A() + 0.05; // add a small number to get proper rounding (e.g. Au: 196->197)
zProj = g.FindElement(proj.Data())->Z();
aTarg = g.FindElement(targ.Data())->A() + 0.05;
zTarg = g.FindElement(targ.Data())->Z();
@@ -268,28 +264,13 @@ void PairAnalysisMetaData::DrawSame(TString opt /*="msb"*/) {
// else if(sys.EqualTo("NiAu")) { aProj=58; zProj=28; aTarg=197; zTarg=79; }
// else if(sys.EqualTo("AgAu")) { aProj=107; zProj=47; aTarg=197; zTarg=79; }
// Get the cm energy, according to URun::GetNNSqrtS
- URun run("",
- "",
- aProj,
- zProj,
- parD->GetVal(),
- aTarg,
- zTarg,
- 0.,
- 0.,
- 0.,
- 0,
- 0.,
- 0.,
- 0.,
- 0);
+ URun run("", "", aProj, zProj, parD->GetVal(), aTarg, zTarg, 0., 0., 0., 0, 0., 0., 0., 0);
tmp = Form("#sqrt{#it{s}_{NN}} = %.2f GeV", run.GetNNSqrtS());
if (!tmp.IsNull()) line += " " + tmp;
}
// events
- TParameter<Int_t>* parI =
- dynamic_cast<TParameter<Int_t>*>(fMetaList.FindObject("events"));
+ TParameter<Int_t>* parI = dynamic_cast<TParameter<Int_t>*>(fMetaList.FindObject("events"));
if (opt.Contains("n") && parD) {
// tmp=Form("#it{N}_{evt} = %.1f#times10^{6}",parI->GetVal()/1.e+6);
tmp = Form("#it{N}_{evt} = %.1fM", parI->GetVal() / 1.e+6);
diff --git a/analysis/PWGDIL/dielectron/papaframework/PairAnalysisMetaData.h b/analysis/PWGDIL/dielectron/papaframework/PairAnalysisMetaData.h
index 65b6fc486f2c23d20e7e8f9b0e2d31e73393b5fe..b2993a77560c24b975385e709755a4e1b7633b82 100644
--- a/analysis/PWGDIL/dielectron/papaframework/PairAnalysisMetaData.h
+++ b/analysis/PWGDIL/dielectron/papaframework/PairAnalysisMetaData.h
@@ -10,7 +10,6 @@
///////////////////////////////////////////////////////////////////////////////////////////
#include <Rtypes.h>
-
#include <TNamed.h>
// #include <TCollection.h>
#include <TList.h>
@@ -44,9 +43,7 @@ public:
void ResetMetaData() { fMetaList.Clear(); }
const TList* GetMetaData() const { return &fMetaList; }
- TObject* FindObject(const char* name) const {
- return fMetaList.FindObject(name);
- }
+ TObject* FindObject(const char* name) const { return fMetaList.FindObject(name); }
void DrawSame(TString opt = "msb");
diff --git a/analysis/PWGDIL/dielectron/papaframework/PairAnalysisMixedEvent.cxx b/analysis/PWGDIL/dielectron/papaframework/PairAnalysisMixedEvent.cxx
index 1cb232e7d0ec2727dbae1abc48b160fbc5631b36..9b21c35d143b4d580d0ce6fb340903054cc65489 100644
--- a/analysis/PWGDIL/dielectron/papaframework/PairAnalysisMixedEvent.cxx
+++ b/analysis/PWGDIL/dielectron/papaframework/PairAnalysisMixedEvent.cxx
@@ -12,27 +12,30 @@
// //
///////////////////////////////////////////////////////////////////////////
+#include "PairAnalysisMixedEvent.h"
+
#include <TExMap.h>
#include <TObjArray.h>
#include <TProcessID.h>
#include "PairAnalysisTrack.h"
-#include "PairAnalysisMixedEvent.h"
-
ClassImp(PairAnalysisMixedEvent)
PairAnalysisMixedEvent::PairAnalysisMixedEvent()
- : PairAnalysisMixedEvent("mixedevent", "mixed event") {
+ : PairAnalysisMixedEvent("mixedevent", "mixed event")
+{
//
// Default Constructor
//
}
//______________________________________________
-PairAnalysisMixedEvent::PairAnalysisMixedEvent(const char* name,
- const char* title)
- : TNamed(name, title), fArrTrackP(), fArrTrackN() {
+PairAnalysisMixedEvent::PairAnalysisMixedEvent(const char* name, const char* title)
+ : TNamed(name, title)
+ , fArrTrackP()
+ , fArrTrackN()
+{
//
// Named Constructor
//
@@ -41,7 +44,8 @@ PairAnalysisMixedEvent::PairAnalysisMixedEvent(const char* name,
}
//______________________________________________
-PairAnalysisMixedEvent::~PairAnalysisMixedEvent() {
+PairAnalysisMixedEvent::~PairAnalysisMixedEvent()
+{
//
// Default Destructor
//
@@ -50,8 +54,8 @@ PairAnalysisMixedEvent::~PairAnalysisMixedEvent() {
}
//______________________________________________
-void PairAnalysisMixedEvent::SetTracks(const TObjArray& arrP,
- const TObjArray& arrN) {
+void PairAnalysisMixedEvent::SetTracks(const TObjArray& arrP, const TObjArray& arrN)
+{
//
// Setup PairAnalysisPairs
// assumes that the objects in arrP and arrN are
@@ -65,20 +69,15 @@ void PairAnalysisMixedEvent::SetTracks(const TObjArray& arrP,
fNTracksP = 0;
//check size of the arrays
- if (fArrTrackP.GetSize() < arrP.GetSize()) {
- fArrTrackP.Expand(arrP.GetSize());
- }
- if (fArrTrackN.GetSize() < arrN.GetSize()) {
- fArrTrackN.Expand(arrN.GetSize());
- }
+ if (fArrTrackP.GetSize() < arrP.GetSize()) { fArrTrackP.Expand(arrP.GetSize()); }
+ if (fArrTrackN.GetSize() < arrN.GetSize()) { fArrTrackN.Expand(arrN.GetSize()); }
TExMap mapStoredVertices;
fPIDIndex = TProcessID::GetPIDs()->IndexOf(fPID);
// fill particles
Int_t tracks = 0;
for (Int_t itrack = 0; itrack < arrP.GetEntriesFast(); ++itrack) {
- PairAnalysisTrack* track =
- dynamic_cast<PairAnalysisTrack*>(arrP.At(itrack));
+ PairAnalysisTrack* track = dynamic_cast<PairAnalysisTrack*>(arrP.At(itrack));
if (!track) continue;
// buffer track
@@ -91,8 +90,7 @@ void PairAnalysisMixedEvent::SetTracks(const TObjArray& arrP,
tracks = 0;
for (Int_t itrack = 0; itrack < arrN.GetEntriesFast(); ++itrack) {
- PairAnalysisTrack* track =
- dynamic_cast<PairAnalysisTrack*>(arrN.At(itrack));
+ PairAnalysisTrack* track = dynamic_cast<PairAnalysisTrack*>(arrN.At(itrack));
if (!track) continue;
//buffer track
@@ -105,7 +103,8 @@ void PairAnalysisMixedEvent::SetTracks(const TObjArray& arrP,
}
//______________________________________________
-void PairAnalysisMixedEvent::Clear(Option_t* opt) {
+void PairAnalysisMixedEvent::Clear(Option_t* opt)
+{
//
// clear arrays
//
@@ -114,7 +113,8 @@ void PairAnalysisMixedEvent::Clear(Option_t* opt) {
}
//______________________________________________
-void PairAnalysisMixedEvent::Set(Int_t size) {
+void PairAnalysisMixedEvent::Set(Int_t size)
+{
//
// set size of array
//
@@ -123,19 +123,18 @@ void PairAnalysisMixedEvent::Set(Int_t size) {
}
//______________________________________________
-void PairAnalysisMixedEvent::SetEventData(
- const Double_t data[PairAnalysisVarManager::kNMaxValuesMC]) {
+void PairAnalysisMixedEvent::SetEventData(const Double_t data[PairAnalysisVarManager::kNMaxValuesMC])
+{
//
// copy only evnet variables
//
- for (Int_t i = PairAnalysisVarManager::kPairMax;
- i < PairAnalysisVarManager::kNMaxValuesMC;
- ++i)
+ for (Int_t i = PairAnalysisVarManager::kPairMax; i < PairAnalysisVarManager::kNMaxValuesMC; ++i)
fEventData[i] = data[i];
}
//______________________________________________
-void PairAnalysisMixedEvent::AssignID(TObject* obj) {
+void PairAnalysisMixedEvent::AssignID(TObject* obj)
+{
//
// Custom function to assign a uid to an object with an own process id
// to avoid problems buffering the vertices
diff --git a/analysis/PWGDIL/dielectron/papaframework/PairAnalysisMixedEvent.h b/analysis/PWGDIL/dielectron/papaframework/PairAnalysisMixedEvent.h
index d1e970f44c5f8bced6446745de100747d00fa73a..64f5275a3d4644297c6e1d6c93517d8b28dba79a 100644
--- a/analysis/PWGDIL/dielectron/papaframework/PairAnalysisMixedEvent.h
+++ b/analysis/PWGDIL/dielectron/papaframework/PairAnalysisMixedEvent.h
@@ -53,9 +53,7 @@ private:
Int_t fNTracksP = 0; //number of positive tracks
Int_t fNTracksN = 0; //number of negative tracks
- Double_t
- fEventData[PairAnalysisVarManager::
- kNMaxValuesMC]; // event informaion from the var manager
+ Double_t fEventData[PairAnalysisVarManager::kNMaxValuesMC]; // event informaion from the var manager
TProcessID* fPID = NULL; //! internal PID for references to buffered objects
UInt_t fPIDIndex = 0; //! index of PID
diff --git a/analysis/PWGDIL/dielectron/papaframework/PairAnalysisMixingHandler.cxx b/analysis/PWGDIL/dielectron/papaframework/PairAnalysisMixingHandler.cxx
index bd24d15ff495882401f666396c90cb90a8077840..dd46fe4dd01cc6265c0b647393b36b6edd35ff63 100644
--- a/analysis/PWGDIL/dielectron/papaframework/PairAnalysisMixingHandler.cxx
+++ b/analysis/PWGDIL/dielectron/papaframework/PairAnalysisMixingHandler.cxx
@@ -20,30 +20,32 @@
// //
///////////////////////////////////////////////////////////////////////////
+#include "PairAnalysisMixingHandler.h"
+
#include <TAxis.h>
#include <TH1.h>
#include <TVectorD.h>
-#include "PairAnalysisTrack.h"
-
#include "PairAnalysis.h"
#include "PairAnalysisMixedEvent.h"
-
-#include "PairAnalysisMixingHandler.h"
+#include "PairAnalysisTrack.h"
ClassImp(PairAnalysisMixingHandler)
PairAnalysisMixingHandler::PairAnalysisMixingHandler()
- : PairAnalysisMixingHandler("ME", "ME") {
+ : PairAnalysisMixingHandler("ME", "ME")
+{
//
// Default Constructor
//
}
//______________________________________________
-PairAnalysisMixingHandler::PairAnalysisMixingHandler(const char* name,
- const char* title)
- : TNamed(name, title), fArrPools("TClonesArray"), fAxes(fMaxCuts) {
+PairAnalysisMixingHandler::PairAnalysisMixingHandler(const char* name, const char* title)
+ : TNamed(name, title)
+ , fArrPools("TClonesArray")
+ , fAxes(fMaxCuts)
+{
//
// Named Constructor
//
@@ -54,7 +56,8 @@ PairAnalysisMixingHandler::PairAnalysisMixingHandler(const char* name,
}
//______________________________________________
-PairAnalysisMixingHandler::~PairAnalysisMixingHandler() {
+PairAnalysisMixingHandler::~PairAnalysisMixingHandler()
+{
//
// Default Destructor
//
@@ -63,9 +66,8 @@ PairAnalysisMixingHandler::~PairAnalysisMixingHandler() {
}
//________________________________________________________________
-void PairAnalysisMixingHandler::AddVariable(
- PairAnalysisVarManager::ValueTypes type,
- TVectorD* const bins) {
+void PairAnalysisMixingHandler::AddVariable(PairAnalysisVarManager::ValueTypes type, TVectorD* const bins)
+{
//
// Add a variable to the mixing handler with arbitrary binning 'bins'
//
@@ -79,16 +81,14 @@ void PairAnalysisMixingHandler::AddVariable(
}
//______________________________________________
-void PairAnalysisMixingHandler::Fill(const PairAnalysisEvent* /*ev*/,
- PairAnalysis* papa) {
+void PairAnalysisMixingHandler::Fill(const PairAnalysisEvent* /*ev*/, PairAnalysis* papa)
+{
//
// fill event buffers and perform mixing if the pool depth is reached
//
//check if there are tracks available
- if (papa->GetTrackArray(0)->GetEntriesFast() == 0
- && papa->GetTrackArray(1)->GetEntriesFast() == 0)
- return;
+ if (papa->GetTrackArray(0)->GetEntriesFast() == 0 && papa->GetTrackArray(1)->GetEntriesFast() == 0) return;
TString dim;
Int_t bin = FindBin(PairAnalysisVarManager::GetData(), &dim);
@@ -115,22 +115,23 @@ void PairAnalysisMixingHandler::Fill(const PairAnalysisEvent* /*ev*/,
Info("Fill", "New pool at %d (%s)", bin, dim.Data());
poolp = new (fArrPools[bin]) TClonesArray("PairAnalysisMixedEvent", fDepth);
poolp->SetUniqueID(0);
- } else {
+ }
+ else {
// one count further in the ring buffer
index1 = (poolp->GetUniqueID() + 1) % fDepth;
}
TClonesArray& pool = *poolp;
- PairAnalysisMixedEvent* event =
- static_cast<PairAnalysisMixedEvent*>(pool.At(index1));
+ PairAnalysisMixedEvent* event = static_cast<PairAnalysisMixedEvent*>(pool.At(index1));
if (!event) {
// Info("Fill",Form("new event at %d: %d",bin,index1));
event = new (pool[index1]) PairAnalysisMixedEvent();
// Int_t size = TMath::Max(papa->GetTrackArray(0)->GetEntriesFast(),papa->GetTrackArray(1)->GetEntriesFast()));
event->Set();
event->SetProcessID(fPID);
- } else {
+ }
+ else {
// Info("Fill",Form("use event at %d: %d",bin,index1));
}
@@ -143,8 +144,8 @@ void PairAnalysisMixingHandler::Fill(const PairAnalysisEvent* /*ev*/,
}
//______________________________________________
-void PairAnalysisMixingHandler::DoMixing(TClonesArray& pool,
- PairAnalysis* papa) {
+void PairAnalysisMixingHandler::DoMixing(TClonesArray& pool, PairAnalysis* papa)
+{
//
// perform the mixing
//
@@ -168,8 +169,7 @@ void PairAnalysisMixingHandler::DoMixing(TClonesArray& pool,
// for (Int_t i2=i1+1; i2<pool.GetEntriesFast(); ++i2){
for (Int_t i1 = 0; i1 < pool.GetEntriesFast(); ++i1) {
- const PairAnalysisMixedEvent* ev2 =
- static_cast<PairAnalysisMixedEvent*>(pool.At(i1));
+ const PairAnalysisMixedEvent* ev2 = static_cast<PairAnalysisMixedEvent*>(pool.At(i1));
// don't mix with itself
if (!ev2) continue;
@@ -226,7 +226,8 @@ void PairAnalysisMixingHandler::DoMixing(TClonesArray& pool,
}
//______________________________________________
-void PairAnalysisMixingHandler::Init(const PairAnalysis* papa) {
+void PairAnalysisMixingHandler::Init(const PairAnalysis* papa)
+{
//
// initialise event buffers
//
@@ -251,7 +252,8 @@ void PairAnalysisMixingHandler::Init(const PairAnalysis* papa) {
}
//______________________________________________
-Int_t PairAnalysisMixingHandler::GetNumberOfBins() const {
+Int_t PairAnalysisMixingHandler::GetNumberOfBins() const
+{
//
// return the number of bins this mixing handler has
//
@@ -262,8 +264,8 @@ Int_t PairAnalysisMixingHandler::GetNumberOfBins() const {
}
//______________________________________________
-Int_t PairAnalysisMixingHandler::FindBin(const Double_t values[],
- TString* dim) {
+Int_t PairAnalysisMixingHandler::FindBin(const Double_t values[], TString* dim)
+{
//
// bin bin in mixing stack described by 'values'
// if the values are outside the binning range -1 is returned
@@ -285,11 +287,7 @@ Int_t PairAnalysisMixingHandler::FindBin(const Double_t values[],
Int_t pos = TMath::BinarySearch(nRows, bins->GetMatrixArray(), val);
bin += sizeAdd * pos;
- if (dim)
- (*dim) += Form("%s: %f (%d); ",
- PairAnalysisVarManager::GetValueName(fEventCuts[i]),
- val,
- pos);
+ if (dim) (*dim) += Form("%s: %f (%d); ", PairAnalysisVarManager::GetValueName(fEventCuts[i]), val, pos);
sizeAdd *= (nRows - 1);
}
diff --git a/analysis/PWGDIL/dielectron/papaframework/PairAnalysisMixingHandler.h b/analysis/PWGDIL/dielectron/papaframework/PairAnalysisMixingHandler.h
index 869344ece91f5a6b97025401d2f6094622b30abb..7692826d49812bd416ba481f8d772038f38ee218 100644
--- a/analysis/PWGDIL/dielectron/papaframework/PairAnalysisMixingHandler.h
+++ b/analysis/PWGDIL/dielectron/papaframework/PairAnalysisMixingHandler.h
@@ -25,14 +25,18 @@ class PairAnalysisEvent;
class PairAnalysisMixingHandler : public TNamed {
public:
- enum class EMixType { kOSonly = 0, kOSandLS, kAll };
+ enum class EMixType
+ {
+ kOSonly = 0,
+ kOSandLS,
+ kAll
+ };
PairAnalysisMixingHandler();
PairAnalysisMixingHandler(const char* name, const char* title);
virtual ~PairAnalysisMixingHandler();
- void AddVariable(PairAnalysisVarManager::ValueTypes type,
- TVectorD* const bins);
+ void AddVariable(PairAnalysisVarManager::ValueTypes type, TVectorD* const bins);
void SetDepth(UShort_t depth) { fDepth = depth; }
UShort_t GetDepth() const { return fDepth; }
@@ -47,14 +51,13 @@ public:
void Init(const PairAnalysis* papa = 0x0);
private:
- UShort_t fDepth = 10; // Number of events per bin to keep in the ring buffer
+ UShort_t fDepth = 10; // Number of events per bin to keep in the ring buffer
TClonesArray fArrPools; // Array of events in bins
static const Int_t fMaxCuts = 10;
- UShort_t fEventCuts[fMaxCuts]; // cut variables
- TObjArray fAxes; // Axis descriptions of the event binning
- EMixType fMixType =
- EMixType::kOSonly; // which combinations to include in the mixing
- TProcessID* fPID = NULL; //! internal PID for references to buffered objects
+ UShort_t fEventCuts[fMaxCuts]; // cut variables
+ TObjArray fAxes; // Axis descriptions of the event binning
+ EMixType fMixType = EMixType::kOSonly; // which combinations to include in the mixing
+ TProcessID* fPID = NULL; //! internal PID for references to buffered objects
void DoMixing(TClonesArray& pool, PairAnalysis* papa);
diff --git a/analysis/PWGDIL/dielectron/papaframework/PairAnalysisObjectCuts.cxx b/analysis/PWGDIL/dielectron/papaframework/PairAnalysisObjectCuts.cxx
index 398dc62608f24c5108cc4441efaf87e6a014e174..4bebf42444122b1679b146256a7f4e60266cd5b2 100644
--- a/analysis/PWGDIL/dielectron/papaframework/PairAnalysisObjectCuts.cxx
+++ b/analysis/PWGDIL/dielectron/papaframework/PairAnalysisObjectCuts.cxx
@@ -16,6 +16,8 @@
///////////////////////////////////////////////////////////////////////////
+#include "PairAnalysisObjectCuts.h"
+
#include <TAxis.h>
#include <TFormula.h>
#include <TGraph.h>
@@ -23,23 +25,23 @@
#include <TSpline.h>
#include "PairAnalysisHelper.h"
-#include "PairAnalysisObjectCuts.h"
ClassImp(PairAnalysisObjectCuts)
PairAnalysisObjectCuts::PairAnalysisObjectCuts()
- : PairAnalysisObjectCuts("objcuts", "objcuts") {
+ : PairAnalysisObjectCuts("objcuts", "objcuts")
+{
//
// Default costructor
//
}
//________________________________________________________________________
-PairAnalysisObjectCuts::PairAnalysisObjectCuts(const char* name,
- const char* title)
+PairAnalysisObjectCuts::PairAnalysisObjectCuts(const char* name, const char* title)
: AnalysisCuts(name, title)
- , fUsedVars(new TBits(PairAnalysisVarManager::kNMaxValuesMC)) {
+ , fUsedVars(new TBits(PairAnalysisVarManager::kNMaxValuesMC))
+{
//
// Named contructor
//
@@ -54,7 +56,8 @@ PairAnalysisObjectCuts::PairAnalysisObjectCuts(const char* name,
}
//________________________________________________________________________
-PairAnalysisObjectCuts::~PairAnalysisObjectCuts() {
+PairAnalysisObjectCuts::~PairAnalysisObjectCuts()
+{
//
// Destructor
//
@@ -68,7 +71,8 @@ PairAnalysisObjectCuts::~PairAnalysisObjectCuts() {
}
//________________________________________________________________________
-Bool_t PairAnalysisObjectCuts::IsSelected(Double_t* const values) {
+Bool_t PairAnalysisObjectCuts::IsSelected(Double_t* const values)
+{
//
// Make cut decision
//
@@ -83,8 +87,7 @@ Bool_t PairAnalysisObjectCuts::IsSelected(Double_t* const values) {
// variable you want to cut on
Double_t compValue = 0.;
- if (fVarFormula[iCut])
- compValue = PairAnalysisHelper::EvalFormula(fVarFormula[iCut], values);
+ if (fVarFormula[iCut]) compValue = PairAnalysisHelper::EvalFormula(fVarFormula[iCut], values);
else
compValue = values[cut];
@@ -103,8 +106,7 @@ Bool_t PairAnalysisObjectCuts::IsSelected(Double_t* const values) {
// get array of values for the corresponding dimensions using axis names
for (Int_t idim = 0; idim < hn->GetNdimensions(); idim++) {
vals[idim] = values[PairAnalysisVarManager::GetValueType(
- hn->GetAxis(idim)
- ->GetName())]; /// TODO: what about formulas in the axis
+ hn->GetAxis(idim)->GetName())]; /// TODO: what about formulas in the axis
}
// find bin for values (w/o creating it in case it is not filled)
Long_t bin = hn->GetBin(vals, kFALSE);
@@ -118,27 +120,25 @@ Bool_t PairAnalysisObjectCuts::IsSelected(Double_t* const values) {
// get array of values for the corresponding dimensions using axis names
for (Int_t idim = 0; idim < hx->GetNdimensions(); idim++) {
vals[idim] = values[PairAnalysisVarManager::GetValueType(
- hx->GetAxis(idim)
- ->GetName())]; /// TODO: what about formulas in the axis
+ hx->GetAxis(idim)->GetName())]; /// TODO: what about formulas in the axis
}
// find bin for values (w/o creating it in case it is not filled)
Long_t bin = hx->GetBin(vals, kFALSE);
if (bin > 0) cutMax = hx->GetBinContent(bin);
delete[] vals;
}
-
- } else if ((fCutMin[iCut] && fCutMin[iCut]->IsA() == TFormula::Class())
- || (fCutMax[iCut]
- && fCutMax[iCut]->IsA() == TFormula::Class())) {
+ }
+ else if ((fCutMin[iCut] && fCutMin[iCut]->IsA() == TFormula::Class())
+ || (fCutMax[iCut] && fCutMax[iCut]->IsA() == TFormula::Class())) {
/// use formulas for the cut //
TFormula* formN = static_cast<TFormula*>(fCutMin[iCut]);
if (formN) cutMin = PairAnalysisHelper::EvalFormula(formN, values);
TFormula* formM = static_cast<TFormula*>(fCutMax[iCut]);
if (formM) cutMax = PairAnalysisHelper::EvalFormula(formM, values);
-
- } else if ((fCutMin[iCut] && fCutMin[iCut]->IsA() == TGraph::Class())
- || (fCutMax[iCut] && fCutMax[iCut]->IsA() == TGraph::Class())) {
+ }
+ else if ((fCutMin[iCut] && fCutMin[iCut]->IsA() == TGraph::Class())
+ || (fCutMax[iCut] && fCutMax[iCut]->IsA() == TGraph::Class())) {
/// use graph for the cut //
/// NOTE: binary search or a linear interpolation is used,
/// spline creation at each eval is too cpu expensive
@@ -166,19 +166,18 @@ Bool_t PairAnalysisObjectCuts::IsSelected(Double_t* const values) {
cutMin = graphN->GetY()[idx];
idx = TMath::BinarySearch(graphM->GetN(), graphM->GetX(), xval);
cutMax = graphM->GetY()[idx];
-
- } else if ((fCutMin[iCut] && fCutMin[iCut]->IsA() == TSpline3::Class())
- || (fCutMax[iCut]
- && fCutMax[iCut]->IsA() == TSpline3::Class())) {
+ }
+ else if ((fCutMin[iCut] && fCutMin[iCut]->IsA() == TSpline3::Class())
+ || (fCutMax[iCut] && fCutMax[iCut]->IsA() == TSpline3::Class())) {
/// TODO: think about poper implementation, how to store the x-variable in the spline
/// use spline for the cut //
// TSpline3 *splineN = static_cast<TSpline3*>(fCutMin[iCut]);
// if(splineN) cutMin = splineN->Eval(xval);
// TSpline3 *splineM = static_cast<TSpline3*>(fCutMax[iCut]);
// if(splineM) cutMax = splineM->Eval(xval);
- } else {
- Error("IsSelected:",
- "Cut object not supported (this message should never appear)");
+ }
+ else {
+ Error("IsSelected:", "Cut object not supported (this message should never appear)");
return kTRUE;
}
@@ -187,8 +186,7 @@ Bool_t PairAnalysisObjectCuts::IsSelected(Double_t* const values) {
if (TMath::IsNaN(cutMax)) cutMax = compValue - 1.;
// apply cut
- if (((compValue < cutMin) || (compValue > cutMax)) ^ fCutExclude[iCut])
- CLRBIT(fSelectedCutsMask, iCut);
+ if (((compValue < cutMin) || (compValue > cutMax)) ^ fCutExclude[iCut]) CLRBIT(fSelectedCutsMask, iCut);
// cut type and decision
if (fCutType == ECutType::kAll && !TESTBIT(fSelectedCutsMask, iCut))
@@ -202,7 +200,8 @@ Bool_t PairAnalysisObjectCuts::IsSelected(Double_t* const values) {
}
//________________________________________________________________________
-Bool_t PairAnalysisObjectCuts::IsSelected(TObject* track) {
+Bool_t PairAnalysisObjectCuts::IsSelected(TObject* track)
+{
//
// Make cut decision
//
@@ -221,17 +220,14 @@ Bool_t PairAnalysisObjectCuts::IsSelected(TObject* track) {
}
//________________________________________________________________________
-void PairAnalysisObjectCuts::AddCut(PairAnalysisVarManager::ValueTypes type,
- const char* formulaMin,
- const char* formulaMax,
- Bool_t excludeRange) {
+void PairAnalysisObjectCuts::AddCut(PairAnalysisVarManager::ValueTypes type, const char* formulaMin,
+ const char* formulaMax, Bool_t excludeRange)
+{
//
// Set cut range and activate it
//
- fCutMin[fNActiveCuts] =
- PairAnalysisHelper::GetFormula(formulaMin, formulaMin);
- fCutMax[fNActiveCuts] =
- PairAnalysisHelper::GetFormula(formulaMax, formulaMax);
+ fCutMin[fNActiveCuts] = PairAnalysisHelper::GetFormula(formulaMin, formulaMin);
+ fCutMax[fNActiveCuts] = PairAnalysisHelper::GetFormula(formulaMax, formulaMax);
fCutExclude[fNActiveCuts] = excludeRange;
SETBIT(fActiveCutsMask, fNActiveCuts);
fActiveCuts[fNActiveCuts] = (UShort_t) type;
@@ -240,17 +236,14 @@ void PairAnalysisObjectCuts::AddCut(PairAnalysisVarManager::ValueTypes type,
}
//________________________________________________________________________
-void PairAnalysisObjectCuts::AddCut(const char* formula,
- const char* formulaMin,
- const char* formulaMax,
- Bool_t excludeRange) {
+void PairAnalysisObjectCuts::AddCut(const char* formula, const char* formulaMin, const char* formulaMax,
+ Bool_t excludeRange)
+{
//
// Set cut range and activate it
//
- fCutMin[fNActiveCuts] =
- PairAnalysisHelper::GetFormula(formulaMin, formulaMin);
- fCutMax[fNActiveCuts] =
- PairAnalysisHelper::GetFormula(formulaMax, formulaMax);
+ fCutMin[fNActiveCuts] = PairAnalysisHelper::GetFormula(formulaMin, formulaMin);
+ fCutMax[fNActiveCuts] = PairAnalysisHelper::GetFormula(formulaMax, formulaMax);
fCutExclude[fNActiveCuts] = excludeRange;
SETBIT(fActiveCutsMask, fNActiveCuts);
fActiveCuts[fNActiveCuts] = (UShort_t) PairAnalysisVarManager::kNMaxValuesMC;
@@ -259,10 +252,9 @@ void PairAnalysisObjectCuts::AddCut(const char* formula,
}
//________________________________________________________________________
-void PairAnalysisObjectCuts::AddCut(PairAnalysisVarManager::ValueTypes type,
- TGraph* const graphMin,
- TGraph* const graphMax,
- Bool_t excludeRange) {
+void PairAnalysisObjectCuts::AddCut(PairAnalysisVarManager::ValueTypes type, TGraph* const graphMin,
+ TGraph* const graphMax, Bool_t excludeRange)
+{
//
// Set cut range and activate it
//
@@ -284,10 +276,9 @@ void PairAnalysisObjectCuts::AddCut(PairAnalysisVarManager::ValueTypes type,
}
//________________________________________________________________________
-void PairAnalysisObjectCuts::AddCut(const char* formula,
- TGraph* const graphMin,
- TGraph* const graphMax,
- Bool_t excludeRange) {
+void PairAnalysisObjectCuts::AddCut(const char* formula, TGraph* const graphMin, TGraph* const graphMax,
+ Bool_t excludeRange)
+{
//
// Set cut range and activate it
//
@@ -309,10 +300,9 @@ void PairAnalysisObjectCuts::AddCut(const char* formula,
}
//________________________________________________________________________
-void PairAnalysisObjectCuts::AddCut(PairAnalysisVarManager::ValueTypes type,
- THnBase* const histMin,
- THnBase* const histMax,
- Bool_t excludeRange) {
+void PairAnalysisObjectCuts::AddCut(PairAnalysisVarManager::ValueTypes type, THnBase* const histMin,
+ THnBase* const histMax, Bool_t excludeRange)
+{
//
// Set cut range and activate it
//
@@ -326,10 +316,9 @@ void PairAnalysisObjectCuts::AddCut(PairAnalysisVarManager::ValueTypes type,
}
//________________________________________________________________________
-void PairAnalysisObjectCuts::AddCut(const char* formula,
- THnBase* const histMin,
- THnBase* const histMax,
- Bool_t excludeRange) {
+void PairAnalysisObjectCuts::AddCut(const char* formula, THnBase* const histMin, THnBase* const histMax,
+ Bool_t excludeRange)
+{
//
// Set cut range and activate it
//
@@ -343,14 +332,14 @@ void PairAnalysisObjectCuts::AddCut(const char* formula,
}
//________________________________________________________________________
-void PairAnalysisObjectCuts::Print(const Option_t* /*option*/) const {
+void PairAnalysisObjectCuts::Print(const Option_t* /*option*/) const
+{
//
// Print cuts and the range
//
printf("cut ranges for '%s'\n", GetTitle());
- if (fCutType == ECutType::kAll) {
- printf("All Cuts have to be fulfilled\n");
- } else {
+ if (fCutType == ECutType::kAll) { printf("All Cuts have to be fulfilled\n"); }
+ else {
printf("Any Cut has to be fulfilled\n");
}
@@ -374,11 +363,9 @@ void PairAnalysisObjectCuts::Print(const Option_t* /*option*/) const {
Bool_t inverse = fCutExclude[iCut];
// cut limits
- Bool_t bCutGraph =
- (fCutMin[iCut] && fCutMin[iCut]->IsA() == TGraph::Class());
- Bool_t bCutForm =
- (fCutMin[iCut] && fCutMin[iCut]->IsA() == TFormula::Class());
- Bool_t bCutHn = (fCutMin[iCut] && fCutMin[iCut]->IsA() == THnBase::Class());
+ Bool_t bCutGraph = (fCutMin[iCut] && fCutMin[iCut]->IsA() == TGraph::Class());
+ Bool_t bCutForm = (fCutMin[iCut] && fCutMin[iCut]->IsA() == TFormula::Class());
+ Bool_t bCutHn = (fCutMin[iCut] && fCutMin[iCut]->IsA() == THnBase::Class());
// Bool_t bCutSpline = (fCutMin[iCut] && fCutMin[iCut]->IsA() == TSpline::Class());
TString dep = "";
@@ -413,15 +400,9 @@ void PairAnalysisObjectCuts::Print(const Option_t* /*option*/) const {
}
// stdout
- if (!inverse)
- printf(
- "Cut %02d: %s < %s < %s\n", iCut, dep.Data(), tit.Data(), dep.Data());
+ if (!inverse) printf("Cut %02d: %s < %s < %s\n", iCut, dep.Data(), tit.Data(), dep.Data());
else
- printf("Cut %02d: !(%s < %s < %s)\n",
- iCut,
- dep.Data(),
- tit.Data(),
- dep.Data());
+ printf("Cut %02d: !(%s < %s < %s)\n", iCut, dep.Data(), tit.Data(), dep.Data());
} //loop over cuts
}
diff --git a/analysis/PWGDIL/dielectron/papaframework/PairAnalysisObjectCuts.h b/analysis/PWGDIL/dielectron/papaframework/PairAnalysisObjectCuts.h
index 7a0b24a1e8260ad79689f5d63bb15b5374a9753c..16fb21dbdd88302dd5b707cbfd40c24a5f06616e 100644
--- a/analysis/PWGDIL/dielectron/papaframework/PairAnalysisObjectCuts.h
+++ b/analysis/PWGDIL/dielectron/papaframework/PairAnalysisObjectCuts.h
@@ -22,39 +22,28 @@ class THnBase;
class PairAnalysisObjectCuts : public AnalysisCuts {
public:
// Whether all cut criteria have to be fulfilled of just any
- enum class ECutType { kAll = 0, kAny };
+ enum class ECutType
+ {
+ kAll = 0,
+ kAny
+ };
static const Int_t fMaxCuts = 10;
PairAnalysisObjectCuts();
PairAnalysisObjectCuts(const char* name, const char* title);
virtual ~PairAnalysisObjectCuts();
//TODO: make copy constructor and assignment operator public
- void AddCut(PairAnalysisVarManager::ValueTypes type,
- const char* formulaMin,
- const char* formulaMax,
- Bool_t excludeRange = kFALSE);
- void AddCut(const char* formula,
- const char* formulaMin,
- const char* formulaMax,
+ void AddCut(PairAnalysisVarManager::ValueTypes type, const char* formulaMin, const char* formulaMax,
Bool_t excludeRange = kFALSE);
+ void AddCut(const char* formula, const char* formulaMin, const char* formulaMax, Bool_t excludeRange = kFALSE);
- void AddCut(PairAnalysisVarManager::ValueTypes type,
- TGraph* const graphMin,
- TGraph* const graphMax,
- Bool_t excludeRange = kFALSE);
- void AddCut(const char* formula,
- TGraph* const graphMin,
- TGraph* const graphMax,
+ void AddCut(PairAnalysisVarManager::ValueTypes type, TGraph* const graphMin, TGraph* const graphMax,
Bool_t excludeRange = kFALSE);
+ void AddCut(const char* formula, TGraph* const graphMin, TGraph* const graphMax, Bool_t excludeRange = kFALSE);
- void AddCut(PairAnalysisVarManager::ValueTypes type,
- THnBase* const histMin,
- THnBase* const histMax,
- Bool_t excludeRange = kFALSE);
- void AddCut(const char* formula,
- THnBase* const histMin,
- THnBase* const histMax,
+ void AddCut(PairAnalysisVarManager::ValueTypes type, THnBase* const histMin, THnBase* const histMax,
Bool_t excludeRange = kFALSE);
+ void AddCut(const char* formula, THnBase* const histMin, THnBase* const histMax, Bool_t excludeRange = kFALSE);
// setters
void SetCutType(ECutType type) { fCutType = type; }
@@ -85,9 +74,8 @@ private:
UShort_t fNActiveCuts = 0; // number of acive cuts
UInt_t fActiveCutsMask = 0; // mask of active cuts
- UInt_t fSelectedCutsMask =
- 0; // Maks of selected cuts, is available after calling IsSelected
- ECutType fCutType = ECutType::kAll; // type of the cut: any, all
+ UInt_t fSelectedCutsMask = 0; // Maks of selected cuts, is available after calling IsSelected
+ ECutType fCutType = ECutType::kAll; // type of the cut: any, all
Bool_t fCutExclude[fMaxCuts]; // inverse cut logic?
TObject* fCutMin[fMaxCuts]; // use object as lower cut
diff --git a/analysis/PWGDIL/dielectron/papaframework/PairAnalysisPair.cxx b/analysis/PWGDIL/dielectron/papaframework/PairAnalysisPair.cxx
index f72e2f24b0bee8ccd05ab65fd6f070bbd2651fd0..b3b21fb299554a7cbf6e3c2dbcb5612d2ffc6492 100644
--- a/analysis/PWGDIL/dielectron/papaframework/PairAnalysisPair.cxx
+++ b/analysis/PWGDIL/dielectron/papaframework/PairAnalysisPair.cxx
@@ -12,18 +12,20 @@
///////////////////////////////////////////////////////////////////////////
-#include <TDatabasePDG.h>
+#include "PairAnalysisPair.h"
#include "CbmVertex.h"
-#include "PairAnalysisPair.h"
+#include <TDatabasePDG.h>
+
#include "PairAnalysisTrack.h"
ClassImp(PairAnalysisPair)
Double_t PairAnalysisPair::fBeamEnergy = -1.;
-PairAnalysisPair::PairAnalysisPair() : PairAnalysisTrack(), fRefD1(), fRefD2() {
+PairAnalysisPair::PairAnalysisPair() : PairAnalysisTrack(), fRefD1(), fRefD2()
+{
//
// Default Constructor
//
@@ -41,45 +43,39 @@ PairAnalysisPair::PairAnalysisPair(const PairAnalysisPair& pair)
, fRefD2(pair.GetSecondDaughter())
, fPid1(pair.GetFirstDaughterPid())
, fPid2(pair.GetSecondDaughterPid())
- , fKFUsage(pair.GetKFUsage()) {
+ , fKFUsage(pair.GetKFUsage())
+{
//
// Copy Constructor
//
}
//______________________________________________
-PairAnalysisPair::PairAnalysisPair(Char_t type)
- : fType(type), fRefD1(), fRefD2() {
+PairAnalysisPair::PairAnalysisPair(Char_t type) : fType(type), fRefD1(), fRefD2()
+{
//
// Constructor with type
//
}
//______________________________________________
-PairAnalysisPair::~PairAnalysisPair() {
+PairAnalysisPair::~PairAnalysisPair()
+{
//
// Default Destructor
//
}
//______________________________________________
-void PairAnalysisPair::GetThetaPhiCM(TLorentzVector& motherMom,
- TLorentzVector& p1Mom,
- TLorentzVector& p2Mom,
- Double_t& thetaHE,
- Double_t& phiHE,
- Double_t& thetaCS,
- Double_t& phiCS) const {
+void PairAnalysisPair::GetThetaPhiCM(TLorentzVector& motherMom, TLorentzVector& p1Mom, TLorentzVector& p2Mom,
+ Double_t& thetaHE, Double_t& phiHE, Double_t& thetaCS, Double_t& phiCS) const
+{
//
// Calculate theta and phi in helicity and Collins-Soper coordinate frame
//
const Double_t proMass = TDatabasePDG::Instance()->GetParticle(2212)->Mass();
- TLorentzVector projMom(
- 0.,
- 0.,
- fBeamEnergy,
- TMath::Sqrt(fBeamEnergy * fBeamEnergy + proMass * proMass));
+ TLorentzVector projMom(0., 0., fBeamEnergy, TMath::Sqrt(fBeamEnergy * fBeamEnergy + proMass * proMass));
TLorentzVector targMom(0., 0., 0., TMath::Sqrt(0. * 0 + proMass * proMass));
// boost all the 4-mom vectors to the mother rest frame
@@ -100,22 +96,20 @@ void PairAnalysisPair::GetThetaPhiCM(TLorentzVector& motherMom,
if (static_cast<PairAnalysisTrack*>(fRefD1.GetObject())->Charge() > 0) {
thetaHE = zAxisHE.Dot((p1Mom.Vect()).Unit());
thetaCS = zAxisCS.Dot((p1Mom.Vect()).Unit());
- phiHE =
- TMath::ATan2((p1Mom.Vect()).Dot(yAxis), (p1Mom.Vect()).Dot(xAxisHE));
- phiCS =
- TMath::ATan2((p1Mom.Vect()).Dot(yAxis), (p1Mom.Vect()).Dot(xAxisCS));
- } else {
+ phiHE = TMath::ATan2((p1Mom.Vect()).Dot(yAxis), (p1Mom.Vect()).Dot(xAxisHE));
+ phiCS = TMath::ATan2((p1Mom.Vect()).Dot(yAxis), (p1Mom.Vect()).Dot(xAxisCS));
+ }
+ else {
thetaHE = zAxisHE.Dot((p2Mom.Vect()).Unit());
thetaCS = zAxisCS.Dot((p2Mom.Vect()).Unit());
- phiHE =
- TMath::ATan2((p2Mom.Vect()).Dot(yAxis), (p2Mom.Vect()).Dot(xAxisHE));
- phiCS =
- TMath::ATan2((p2Mom.Vect()).Dot(yAxis), (p2Mom.Vect()).Dot(xAxisCS));
+ phiHE = TMath::ATan2((p2Mom.Vect()).Dot(yAxis), (p2Mom.Vect()).Dot(xAxisHE));
+ phiCS = TMath::ATan2((p2Mom.Vect()).Dot(yAxis), (p2Mom.Vect()).Dot(xAxisCS));
}
}
//______________________________________________
-Double_t PairAnalysisPair::GetCosPointingAngle(const CbmVertex* primVtx) const {
+Double_t PairAnalysisPair::GetCosPointingAngle(const CbmVertex* primVtx) const
+{
//
// Calculate the poiting angle of the pair to the primary vertex and take the cosine
//
@@ -132,22 +126,22 @@ Double_t PairAnalysisPair::GetCosPointingAngle(const CbmVertex* primVtx) const {
}
//______________________________________________
-void PairAnalysisPair::GetDCA(const CbmVertex* primVtx,
- Double_t d0z0[2]) const {
+void PairAnalysisPair::GetDCA(const CbmVertex* primVtx, Double_t d0z0[2]) const
+{
//
// Calculate the dca of the mother with respect to the primary vertex
//
if (!primVtx) return;
- d0z0[0] = TMath::Sqrt(TMath::Power(Xv() - primVtx->GetX(), 2)
- + TMath::Power(Yv() - primVtx->GetY(), 2));
+ d0z0[0] = TMath::Sqrt(TMath::Power(Xv() - primVtx->GetX(), 2) + TMath::Power(Yv() - primVtx->GetY(), 2));
d0z0[1] = Zv() - primVtx->GetZ();
return;
}
//______________________________________________
-void PairAnalysisPair::SetBeamEnergy(Double_t beamEbyHand) {
+void PairAnalysisPair::SetBeamEnergy(Double_t beamEbyHand)
+{
//
// set the beam energy by hand
//
diff --git a/analysis/PWGDIL/dielectron/papaframework/PairAnalysisPair.h b/analysis/PWGDIL/dielectron/papaframework/PairAnalysisPair.h
index 5df64ae13823d15a146db0417d6d30cb51d9a247..52cf3ce0f3a41861cad0ccefd6a7f2de47a4eecd 100644
--- a/analysis/PWGDIL/dielectron/papaframework/PairAnalysisPair.h
+++ b/analysis/PWGDIL/dielectron/papaframework/PairAnalysisPair.h
@@ -30,13 +30,10 @@ public:
PairAnalysisPair(Char_t type);
- virtual void SetTracks(PairAnalysisTrack* const particle1,
- Int_t pid1,
- PairAnalysisTrack* const particle2,
+ virtual void SetTracks(PairAnalysisTrack* const particle1, Int_t pid1, PairAnalysisTrack* const particle2,
Int_t pid2) = 0;
- virtual void SetMCTracks(const CbmMCTrack* const particle1,
- const CbmMCTrack* const particle2) = 0;
+ virtual void SetMCTracks(const CbmMCTrack* const particle1, const CbmMCTrack* const particle2) = 0;
// kinematics
virtual Double_t Px() const { return -999.; }
@@ -44,7 +41,8 @@ public:
virtual Double_t Pz() const { return -999.; }
virtual Double_t Pt() const { return -999.; }
virtual Double_t P() const { return -999.; }
- virtual Bool_t PxPyPz(Double_t p[3]) const {
+ virtual Bool_t PxPyPz(Double_t p[3]) const
+ {
p[0] = Px();
p[1] = Py();
p[2] = Pz();
@@ -54,20 +52,17 @@ public:
virtual Double_t Xv() const { return -999.; }
virtual Double_t Yv() const { return -999.; }
virtual Double_t Zv() const { return -999.; }
- virtual Bool_t XvYvZv(Double_t x[3]) const {
+ virtual Bool_t XvYvZv(Double_t x[3]) const
+ {
x[0] = Xv();
x[1] = Yv();
x[2] = Zv();
return kTRUE;
}
- virtual Double_t OneOverPt() const {
- return Pt() > 0. ? 1. / Pt() : 0.;
- } //TODO: check
+ virtual Double_t OneOverPt() const { return Pt() > 0. ? 1. / Pt() : 0.; } //TODO: check
virtual Double_t Phi() const { return -999.; }
- virtual Double_t Theta() const {
- return Pz() != 0 ? TMath::ATan(Pt() / Pz()) : 0.;
- } //TODO: check
+ virtual Double_t Theta() const { return Pz() != 0 ? TMath::ATan(Pt() / Pz()) : 0.; } //TODO: check
virtual Double_t E() const { return -999.; }
@@ -110,22 +105,12 @@ public:
virtual Double_t DaughtersP() const { return -999.; }
// calculate cos(theta*) and phi* in HE and CS pictures
- virtual void GetThetaPhiCM(Double_t& thetaHE,
- Double_t& phiHE,
- Double_t& thetaCS,
- Double_t& phiCS) const = 0;
- void GetThetaPhiCM(TLorentzVector& motherMom,
- TLorentzVector& p1Mom,
- TLorentzVector& p2Mom,
- Double_t& thetaHE,
- Double_t& phiHE,
- Double_t& thetaCS,
- Double_t& phiCS) const;
-
- virtual Double_t
- PsiPair(Double_t MagField) const = 0; //Angle cut w.r.t. to magnetic field
- virtual Double_t PhivPair(
- Double_t MagField) const = 0; //Angle of ee plane w.r.t. to magnetic field
+ virtual void GetThetaPhiCM(Double_t& thetaHE, Double_t& phiHE, Double_t& thetaCS, Double_t& phiCS) const = 0;
+ void GetThetaPhiCM(TLorentzVector& motherMom, TLorentzVector& p1Mom, TLorentzVector& p2Mom, Double_t& thetaHE,
+ Double_t& phiHE, Double_t& thetaCS, Double_t& phiCS) const;
+
+ virtual Double_t PsiPair(Double_t MagField) const = 0; //Angle cut w.r.t. to magnetic field
+ virtual Double_t PhivPair(Double_t MagField) const = 0; //Angle of ee plane w.r.t. to magnetic field
virtual Double_t GetCosPointingAngle(const CbmVertex* primVtx) const /*= 0*/;
@@ -137,12 +122,8 @@ public:
void SetRefFirstDaughter(PairAnalysisTrack* const track) { fRefD1 = track; }
void SetRefSecondDaughter(PairAnalysisTrack* const track) { fRefD2 = track; }
- PairAnalysisTrack* GetFirstDaughter() const {
- return dynamic_cast<PairAnalysisTrack*>(fRefD1.GetObject());
- }
- PairAnalysisTrack* GetSecondDaughter() const {
- return dynamic_cast<PairAnalysisTrack*>(fRefD2.GetObject());
- }
+ PairAnalysisTrack* GetFirstDaughter() const { return dynamic_cast<PairAnalysisTrack*>(fRefD1.GetObject()); }
+ PairAnalysisTrack* GetSecondDaughter() const { return dynamic_cast<PairAnalysisTrack*>(fRefD2.GetObject()); }
Int_t GetFirstDaughterPid() const { return fPid1; }
Int_t GetSecondDaughterPid() const { return fPid2; }
@@ -153,8 +134,7 @@ public:
Bool_t GetKFUsage() const { return fKFUsage; }
protected:
- Char_t fType =
- -1; // type of the pair e.g. like sign SE, unlike sign SE, ... see PairAnalysis
+ Char_t fType = -1; // type of the pair e.g. like sign SE, unlike sign SE, ... see PairAnalysis
Short_t fCharge = -1; // charge
Int_t fLabel = -1; // MC label
Double_t fWeight = 1.; // weighting factor
diff --git a/analysis/PWGDIL/dielectron/papaframework/PairAnalysisPairKF.cxx b/analysis/PWGDIL/dielectron/papaframework/PairAnalysisPairKF.cxx
index 15b3811ad906ec743ee94e4ad7d2ef14d79a2e07..ce99c12102631ba4cd52ed158d0705416154873a 100644
--- a/analysis/PWGDIL/dielectron/papaframework/PairAnalysisPairKF.cxx
+++ b/analysis/PWGDIL/dielectron/papaframework/PairAnalysisPairKF.cxx
@@ -8,52 +8,52 @@
// //
///////////////////////////////////////////////////////////////////////////
-#include <TDatabasePDG.h>
-
-
-#include "CbmL1.h"
-#include "CbmL1PFFitter.h"
-#include "L1Algo.h"
-#include "L1Field.h"
+#include "PairAnalysisPairKF.h"
#include "CbmKFParticleInterface.h"
#include "CbmKFTrack.h"
-#include "KFParticle.h"
-
+#include "CbmL1.h"
+#include "CbmL1PFFitter.h"
#include "CbmMCTrack.h"
#include "CbmVertex.h"
-#include "PairAnalysisTrack.h"
-#include "PairAnalysisPairKF.h"
+#include <TDatabasePDG.h>
+
+#include "KFParticle.h"
+#include "L1Algo.h"
+#include "L1Field.h"
+#include "PairAnalysisTrack.h"
ClassImp(PairAnalysisPairKF)
PairAnalysisPairKF::PairAnalysisPairKF()
- : PairAnalysisPair(), fPair(), fD1(), fD2() {
+ : PairAnalysisPair()
+ , fPair()
+ , fD1()
+ , fD2()
+{
//
// Default Constructor
//
}
//______________________________________________
-PairAnalysisPairKF::PairAnalysisPairKF(const PairAnalysisPair& pair)
- : PairAnalysisPair(pair), fPair(), fD1(), fD2() {
+PairAnalysisPairKF::PairAnalysisPairKF(const PairAnalysisPair& pair) : PairAnalysisPair(pair), fPair(), fD1(), fD2()
+{
//
// Copy Constructor
//
- SetTracks(pair.GetFirstDaughter(),
- pair.GetFirstDaughterPid(),
- pair.GetSecondDaughter(),
- pair.GetSecondDaughterPid());
+ SetTracks(pair.GetFirstDaughter(), pair.GetFirstDaughterPid(), pair.GetSecondDaughter(), pair.GetSecondDaughterPid());
}
//______________________________________________
-PairAnalysisPairKF::PairAnalysisPairKF(PairAnalysisTrack* const particle1,
- Int_t pid1,
- PairAnalysisTrack* const particle2,
- Int_t pid2,
- Char_t type)
- : PairAnalysisPair(type), fPair(), fD1(), fD2() {
+PairAnalysisPairKF::PairAnalysisPairKF(PairAnalysisTrack* const particle1, Int_t pid1,
+ PairAnalysisTrack* const particle2, Int_t pid2, Char_t type)
+ : PairAnalysisPair(type)
+ , fPair()
+ , fD1()
+ , fD2()
+{
//
// Constructor with tracks
//
@@ -61,17 +61,17 @@ PairAnalysisPairKF::PairAnalysisPairKF(PairAnalysisTrack* const particle1,
}
//______________________________________________
-PairAnalysisPairKF::~PairAnalysisPairKF() {
+PairAnalysisPairKF::~PairAnalysisPairKF()
+{
//
// Default Destructor
//
}
//______________________________________________
-void PairAnalysisPairKF::SetTracks(PairAnalysisTrack* const particle1,
- Int_t pid1,
- PairAnalysisTrack* const particle2,
- Int_t pid2) {
+void PairAnalysisPairKF::SetTracks(PairAnalysisTrack* const particle1, Int_t pid1, PairAnalysisTrack* const particle2,
+ Int_t pid2)
+{
//
// set KF daughters and pair
// refParticle1 and 2 are the original tracks. In the case of track rotation
@@ -81,10 +81,8 @@ void PairAnalysisPairKF::SetTracks(PairAnalysisTrack* const particle1,
// BUT think about mixed events or LS-pairs
// const Double_t mpid1 = TDatabasePDG::Instance()->GetParticle(pid1)->Mass(); (FU) unused
// const Double_t mpid2 = TDatabasePDG::Instance()->GetParticle(pid2)->Mass(); (FU) unused
- const Double_t cpid1 =
- TDatabasePDG::Instance()->GetParticle(pid1)->Charge() * 3;
- const Double_t cpid2 =
- TDatabasePDG::Instance()->GetParticle(pid2)->Charge() * 3;
+ const Double_t cpid1 = TDatabasePDG::Instance()->GetParticle(pid1)->Charge() * 3;
+ const Double_t cpid2 = TDatabasePDG::Instance()->GetParticle(pid2)->Charge() * 3;
// match charge of track to pid and set mass accordingly
fPid1 = pid1;
@@ -104,10 +102,8 @@ void PairAnalysisPairKF::SetTracks(PairAnalysisTrack* const particle1,
/// be carefull in Mixed events this does not work because STS hits are not there
//// TODO: - write converter w/o refit, what about field coefficients
//// - OR store the KFparticle in the PapaTrack and use it here instead
- CbmKFParticleInterface::SetKFParticleFromStsTrack(
- particle1->GetStsTrack(), &fD1, fPid1, kTRUE);
- CbmKFParticleInterface::SetKFParticleFromStsTrack(
- particle2->GetStsTrack(), &fD2, fPid2, kTRUE);
+ CbmKFParticleInterface::SetKFParticleFromStsTrack(particle1->GetStsTrack(), &fD1, fPid1, kTRUE);
+ CbmKFParticleInterface::SetKFParticleFromStsTrack(particle2->GetStsTrack(), &fD2, fPid2, kTRUE);
// references
fRefD1 = particle1;
@@ -131,8 +127,8 @@ void PairAnalysisPairKF::SetTracks(PairAnalysisTrack* const particle1,
}
//______________________________________________
-void PairAnalysisPairKF::SetMCTracks(const CbmMCTrack* const particle1,
- const CbmMCTrack* const particle2) {
+void PairAnalysisPairKF::SetMCTracks(const CbmMCTrack* const particle1, const CbmMCTrack* const particle2)
+{
//
// build MC pair from daughters
// no references are set
@@ -170,10 +166,8 @@ void PairAnalysisPairKF::SetMCTracks(const CbmMCTrack* const particle1,
}
//______________________________________________
-void PairAnalysisPairKF::GetThetaPhiCM(Double_t& thetaHE,
- Double_t& phiHE,
- Double_t& thetaCS,
- Double_t& phiCS) const {
+void PairAnalysisPairKF::GetThetaPhiCM(Double_t& thetaHE, Double_t& phiHE, Double_t& thetaCS, Double_t& phiCS) const
+{
//
// Calculate theta and phi in helicity and Collins-Soper coordinate frame
//
@@ -187,26 +181,18 @@ void PairAnalysisPairKF::GetThetaPhiCM(Double_t& thetaHE,
const Double_t d2Mass = TDatabasePDG::Instance()->GetParticle(fPid2)->Mass();
// first & second daughter 4-mom
- TLorentzVector p1Mom(
- px1,
- py1,
- pz1,
- TMath::Sqrt(px1 * px1 + py1 * py1 + pz1 * pz1 + d1Mass * d1Mass));
- TLorentzVector p2Mom(
- px2,
- py2,
- pz2,
- TMath::Sqrt(px2 * px2 + py2 * py2 + pz2 * pz2 + d2Mass * d2Mass));
+ TLorentzVector p1Mom(px1, py1, pz1, TMath::Sqrt(px1 * px1 + py1 * py1 + pz1 * pz1 + d1Mass * d1Mass));
+ TLorentzVector p2Mom(px2, py2, pz2, TMath::Sqrt(px2 * px2 + py2 * py2 + pz2 * pz2 + d2Mass * d2Mass));
// mother 4-momentum vector
TLorentzVector motherMom = p1Mom + p2Mom;
- PairAnalysisPair::GetThetaPhiCM(
- motherMom, p1Mom, p2Mom, thetaHE, phiHE, thetaCS, phiCS);
+ PairAnalysisPair::GetThetaPhiCM(motherMom, p1Mom, p2Mom, thetaHE, phiHE, thetaCS, phiCS);
}
//______________________________________________
-Double_t PairAnalysisPairKF::PsiPair(Double_t /*MagField*/) const {
+Double_t PairAnalysisPairKF::PsiPair(Double_t /*MagField*/) const
+{
return 0.; /*
//Following idea to use opening of colinear pairs in magnetic field from e.g. PHENIX
//to ID conversions. Adapted from TRDv0Info class
@@ -267,17 +253,16 @@ Double_t PairAnalysisPairKF::PsiPair(Double_t /*MagField*/) const {
}
//______________________________________________
-Double_t PairAnalysisPairKF::GetArmAlpha() const {
+Double_t PairAnalysisPairKF::GetArmAlpha() const
+{
//
// Calculate the Armenteros-Podolanski Alpha
//
Int_t qD1 = fD1.GetQ();
- TVector3 momNeg((qD1 < 0 ? fD1.GetPx() : fD2.GetPx()),
- (qD1 < 0 ? fD1.GetPy() : fD2.GetPy()),
+ TVector3 momNeg((qD1 < 0 ? fD1.GetPx() : fD2.GetPx()), (qD1 < 0 ? fD1.GetPy() : fD2.GetPy()),
(qD1 < 0 ? fD1.GetPz() : fD2.GetPz()));
- TVector3 momPos((qD1 < 0 ? fD2.GetPx() : fD1.GetPx()),
- (qD1 < 0 ? fD2.GetPy() : fD1.GetPy()),
+ TVector3 momPos((qD1 < 0 ? fD2.GetPx() : fD1.GetPx()), (qD1 < 0 ? fD2.GetPy() : fD1.GetPy()),
(qD1 < 0 ? fD2.GetPz() : fD1.GetPz()));
TVector3 momTot(Px(), Py(), Pz());
@@ -288,14 +273,14 @@ Double_t PairAnalysisPairKF::GetArmAlpha() const {
}
//______________________________________________
-Double_t PairAnalysisPairKF::GetArmPt() const {
+Double_t PairAnalysisPairKF::GetArmPt() const
+{
//
// Calculate the Armenteros-Podolanski Pt
//
Int_t qD1 = fD1.GetQ();
- TVector3 momNeg((qD1 < 0 ? fD1.GetPx() : fD2.GetPx()),
- (qD1 < 0 ? fD1.GetPy() : fD2.GetPy()),
+ TVector3 momNeg((qD1 < 0 ? fD1.GetPx() : fD2.GetPx()), (qD1 < 0 ? fD1.GetPy() : fD2.GetPy()),
(qD1 < 0 ? fD1.GetPz() : fD2.GetPz()));
TVector3 momTot(Px(), Py(), Pz());
@@ -303,7 +288,8 @@ Double_t PairAnalysisPairKF::GetArmPt() const {
}
//______________________________________________
-Double_t PairAnalysisPairKF::PhivPair(Double_t MagField) const {
+Double_t PairAnalysisPairKF::PhivPair(Double_t MagField) const
+{
//Following idea to use opening of colinear pairs in magnetic field from e.g. PHENIX
//to ID conversions. Angle between ee plane and magnetic field is calculated.
@@ -320,7 +306,8 @@ Double_t PairAnalysisPairKF::PhivPair(Double_t MagField) const {
px2 = fD2.GetPx();
py2 = fD2.GetPy();
pz2 = fD2.GetPz();
- } else {
+ }
+ else {
px1 = fD2.GetPx();
py1 = fD2.GetPy();
pz1 = fD2.GetPz();
@@ -329,7 +316,8 @@ Double_t PairAnalysisPairKF::PhivPair(Double_t MagField) const {
py2 = fD1.GetPy();
pz2 = fD1.GetPz();
}
- } else {
+ }
+ else {
if (fD1.GetQ() > 0) {
px1 = fD2.GetPx();
py1 = fD2.GetPy();
@@ -338,7 +326,8 @@ Double_t PairAnalysisPairKF::PhivPair(Double_t MagField) const {
px2 = fD1.GetPx();
py2 = fD1.GetPy();
pz2 = fD1.GetPz();
- } else {
+ }
+ else {
px1 = fD1.GetPx();
py1 = fD1.GetPy();
pz1 = fD1.GetPz();
diff --git a/analysis/PWGDIL/dielectron/papaframework/PairAnalysisPairKF.h b/analysis/PWGDIL/dielectron/papaframework/PairAnalysisPairKF.h
index d32885a590d0c4bb7f214635e811ecab4eb2ac9f..219d3136d672329857ec248494e0586169ed6c0c 100644
--- a/analysis/PWGDIL/dielectron/papaframework/PairAnalysisPairKF.h
+++ b/analysis/PWGDIL/dielectron/papaframework/PairAnalysisPairKF.h
@@ -14,10 +14,11 @@
//# #
//#############################################################
-#include <KFParticle.h>
#include <TLorentzVector.h>
#include <TMath.h>
+#include <KFParticle.h>
+
#include "PairAnalysisPair.h"
#include "PairAnalysisTrack.h"
#include "PairAnalysisTrackRotator.h"
@@ -31,19 +32,12 @@ public:
virtual ~PairAnalysisPairKF();
PairAnalysisPairKF(const PairAnalysisPair& pair);
- PairAnalysisPairKF(PairAnalysisTrack* const particle1,
- Int_t pid1,
- PairAnalysisTrack* const particle2,
- Int_t pid2,
+ PairAnalysisPairKF(PairAnalysisTrack* const particle1, Int_t pid1, PairAnalysisTrack* const particle2, Int_t pid2,
Char_t type);
- void SetTracks(PairAnalysisTrack* const particle1,
- Int_t pid1,
- PairAnalysisTrack* const particle2,
- Int_t pid2);
+ void SetTracks(PairAnalysisTrack* const particle1, Int_t pid1, PairAnalysisTrack* const particle2, Int_t pid2);
- void SetMCTracks(const CbmMCTrack* const particle1,
- const CbmMCTrack* const particle2);
+ void SetMCTracks(const CbmMCTrack* const particle1, const CbmMCTrack* const particle2);
// kinematics
virtual Double_t Px() const { return fPair.GetPx(); }
@@ -51,7 +45,8 @@ public:
virtual Double_t Pz() const { return fPair.GetPz(); }
virtual Double_t Pt() const { return fPair.GetPt(); }
virtual Double_t P() const { return fPair.GetP(); }
- virtual Bool_t PxPyPz(Double_t p[3]) const {
+ virtual Bool_t PxPyPz(Double_t p[3]) const
+ {
p[0] = Px();
p[1] = Py();
p[2] = Pz();
@@ -61,27 +56,25 @@ public:
virtual Double_t Xv() const { return fPair.GetX(); }
virtual Double_t Yv() const { return fPair.GetY(); }
virtual Double_t Zv() const { return fPair.GetZ(); }
- virtual Bool_t XvYvZv(Double_t x[3]) const {
+ virtual Bool_t XvYvZv(Double_t x[3]) const
+ {
x[0] = Xv();
x[1] = Yv();
x[2] = Zv();
return kTRUE;
}
- virtual Double_t OneOverPt() const {
- return Pt() > 0. ? 1. / Pt() : 0.;
- } //TODO: check
+ virtual Double_t OneOverPt() const { return Pt() > 0. ? 1. / Pt() : 0.; } //TODO: check
virtual Double_t Phi() const { return fPair.GetPhi(); }
- virtual Double_t Theta() const {
- return Pz() != 0 ? TMath::ATan(Pt() / Pz()) : 0.;
- } //TODO: check
+ virtual Double_t Theta() const { return Pz() != 0 ? TMath::ATan(Pt() / Pz()) : 0.; } //TODO: check
virtual Double_t E() const { return fPair.GetE(); }
virtual Double_t M() const { return fPair.GetMass(); }
virtual Double_t Eta() const { return fPair.GetEta(); }
- virtual Double_t Y() const {
+ virtual Double_t Y() const
+ {
if ((E() * E() - Px() * Px() - Py() * Py() - Pz() * Pz()) > 0.)
return TLorentzVector(Px(), Py(), Pz(), E()).Rapidity();
else
@@ -99,32 +92,19 @@ public:
Double_t OpeningAngle() const { return fD1.GetAngle(fD2); }
Double_t OpeningAngleXY() const { return fD1.GetAngleXY(fD2); }
Double_t OpeningAngleRZ() const { return fD1.GetAngleRZ(fD2); }
- Double_t DistanceDaughters() const {
- return fD1.GetDistanceFromParticle(fD2);
- }
- Double_t DistanceDaughtersXY() const {
- return fD1.GetDistanceFromParticleXY(fD2);
- }
- Double_t DeviationDaughters() const {
- return fD1.GetDeviationFromParticle(fD2);
- }
- Double_t DeviationDaughtersXY() const {
- return fD1.GetDeviationFromParticleXY(fD2);
- }
+ Double_t DistanceDaughters() const { return fD1.GetDistanceFromParticle(fD2); }
+ Double_t DistanceDaughtersXY() const { return fD1.GetDistanceFromParticleXY(fD2); }
+ Double_t DeviationDaughters() const { return fD1.GetDeviationFromParticle(fD2); }
+ Double_t DeviationDaughtersXY() const { return fD1.GetDeviationFromParticleXY(fD2); }
Double_t DeltaEta() const { return TMath::Abs(fD1.GetEta() - fD2.GetEta()); }
Double_t DeltaPhi() const { return fD1.GetAngleXY(fD2); }
Double_t DaughtersP() const { return fD1.GetP() * fD2.GetP(); }
// calculate cos(theta*) and phi* in HE and CS pictures
- void GetThetaPhiCM(Double_t& thetaHE,
- Double_t& phiHE,
- Double_t& thetaCS,
- Double_t& phiCS) const;
-
- Double_t
- PsiPair(Double_t MagField) const; //Angle cut w.r.t. to magnetic field
- Double_t PhivPair(
- Double_t MagField) const; //Angle of ee plane w.r.t. to magnetic field
+ void GetThetaPhiCM(Double_t& thetaHE, Double_t& phiHE, Double_t& thetaCS, Double_t& phiCS) const;
+
+ Double_t PsiPair(Double_t MagField) const; //Angle cut w.r.t. to magnetic field
+ Double_t PhivPair(Double_t MagField) const; //Angle of ee plane w.r.t. to magnetic field
// TODO: replace by KFParticleBase functions?
Double_t GetArmAlpha() const;
diff --git a/analysis/PWGDIL/dielectron/papaframework/PairAnalysisPairLV.cxx b/analysis/PWGDIL/dielectron/papaframework/PairAnalysisPairLV.cxx
index e43be4161b54699c899a441dbb9fab2c18a6fdf9..89fa3c186c1d51d29a7e911991ac5658a5eeb000 100644
--- a/analysis/PWGDIL/dielectron/papaframework/PairAnalysisPairLV.cxx
+++ b/analysis/PWGDIL/dielectron/papaframework/PairAnalysisPairLV.cxx
@@ -12,21 +12,26 @@
///////////////////////////////////////////////////////////////////////////
-#include <TDatabasePDG.h>
+#include "PairAnalysisPairLV.h"
#include "CbmL1.h"
+#include "CbmMCTrack.h"
+
+#include <TDatabasePDG.h>
+
#include "L1Algo.h"
#include "L1Field.h"
-
-#include "CbmMCTrack.h"
#include "PairAnalysisTrack.h"
-#include "PairAnalysisPairLV.h"
-
ClassImp(PairAnalysisPairLV)
PairAnalysisPairLV::PairAnalysisPairLV()
- : PairAnalysisPair(), fPairPos(), fPair(), fD1(), fD2() {
+ : PairAnalysisPair()
+ , fPairPos()
+ , fPair()
+ , fD1()
+ , fD2()
+{
//
// Default Constructor
//
@@ -34,23 +39,27 @@ ClassImp(PairAnalysisPairLV)
//______________________________________________
PairAnalysisPairLV::PairAnalysisPairLV(const PairAnalysisPair& pair)
- : PairAnalysisPair(pair), fPairPos(), fPair(), fD1(), fD2() {
+ : PairAnalysisPair(pair)
+ , fPairPos()
+ , fPair()
+ , fD1()
+ , fD2()
+{
//
// Copy Constructor
//
- SetTracks(pair.GetFirstDaughter(),
- pair.GetFirstDaughterPid(),
- pair.GetSecondDaughter(),
- pair.GetSecondDaughterPid());
+ SetTracks(pair.GetFirstDaughter(), pair.GetFirstDaughterPid(), pair.GetSecondDaughter(), pair.GetSecondDaughterPid());
}
//______________________________________________
-PairAnalysisPairLV::PairAnalysisPairLV(PairAnalysisTrack* const particle1,
- Int_t pid1,
- PairAnalysisTrack* const particle2,
- Int_t pid2,
- Char_t type)
- : PairAnalysisPair(type), fPairPos(), fPair(), fD1(), fD2() {
+PairAnalysisPairLV::PairAnalysisPairLV(PairAnalysisTrack* const particle1, Int_t pid1,
+ PairAnalysisTrack* const particle2, Int_t pid2, Char_t type)
+ : PairAnalysisPair(type)
+ , fPairPos()
+ , fPair()
+ , fD1()
+ , fD2()
+{
//
// Constructor with tracks
//
@@ -58,17 +67,17 @@ PairAnalysisPairLV::PairAnalysisPairLV(PairAnalysisTrack* const particle1,
}
//______________________________________________
-PairAnalysisPairLV::~PairAnalysisPairLV() {
+PairAnalysisPairLV::~PairAnalysisPairLV()
+{
//
// Default Destructor
//
}
//______________________________________________
-void PairAnalysisPairLV::SetTracks(PairAnalysisTrack* const particle1,
- Int_t pid1,
- PairAnalysisTrack* const particle2,
- Int_t pid2) {
+void PairAnalysisPairLV::SetTracks(PairAnalysisTrack* const particle1, Int_t pid1, PairAnalysisTrack* const particle2,
+ Int_t pid2)
+{
//
// set TLorentzVector daughters and pair
// refParticle1 and 2 are the original tracks. In the case of track rotation
@@ -80,10 +89,8 @@ void PairAnalysisPairLV::SetTracks(PairAnalysisTrack* const particle1,
// BUT what about mixed events or LS-pairs
const Double_t mpid1 = TDatabasePDG::Instance()->GetParticle(pid1)->Mass();
const Double_t mpid2 = TDatabasePDG::Instance()->GetParticle(pid2)->Mass();
- const Double_t cpid1 =
- TDatabasePDG::Instance()->GetParticle(pid1)->Charge() * 3;
- const Double_t cpid2 =
- TDatabasePDG::Instance()->GetParticle(pid2)->Charge() * 3;
+ const Double_t cpid1 = TDatabasePDG::Instance()->GetParticle(pid1)->Charge() * 3;
+ const Double_t cpid2 = TDatabasePDG::Instance()->GetParticle(pid2)->Charge() * 3;
// match charge of track to pid and set mass accordingly
fPid1 = pid1;
@@ -100,12 +107,10 @@ void PairAnalysisPairLV::SetTracks(PairAnalysisTrack* const particle1,
}
// Calculate Energy per particle by hand
- Double_t e1 = TMath::Sqrt(m1 * m1 + particle1->Px() * particle1->Px()
- + particle1->Py() * particle1->Py()
+ Double_t e1 = TMath::Sqrt(m1 * m1 + particle1->Px() * particle1->Px() + particle1->Py() * particle1->Py()
+ particle1->Pz() * particle1->Pz());
- Double_t e2 = TMath::Sqrt(m2 * m2 + particle2->Px() * particle2->Px()
- + particle2->Py() * particle2->Py()
+ Double_t e2 = TMath::Sqrt(m2 * m2 + particle2->Px() * particle2->Px() + particle2->Py() * particle2->Py()
+ particle2->Pz() * particle2->Pz());
fRefD1 = particle1;
@@ -123,8 +128,8 @@ void PairAnalysisPairLV::SetTracks(PairAnalysisTrack* const particle1,
}
//______________________________________________
-void PairAnalysisPairLV::SetMCTracks(const CbmMCTrack* const particle1,
- const CbmMCTrack* const particle2) {
+void PairAnalysisPairLV::SetMCTracks(const CbmMCTrack* const particle1, const CbmMCTrack* const particle2)
+{
//
// build MC pair from TLorentzVector daughters
// no references are set
@@ -132,14 +137,8 @@ void PairAnalysisPairLV::SetMCTracks(const CbmMCTrack* const particle1,
particle1->Get4Momentum(fD1);
particle2->Get4Momentum(fD2);
fPair = (fD1 + fD2);
- TLorentzVector fD1Pos(particle1->GetStartX(),
- particle1->GetStartY(),
- particle1->GetStartZ(),
- particle1->GetStartT());
- TLorentzVector fD2Pos(particle2->GetStartX(),
- particle2->GetStartY(),
- particle2->GetStartZ(),
- particle2->GetStartT());
+ TLorentzVector fD1Pos(particle1->GetStartX(), particle1->GetStartY(), particle1->GetStartZ(), particle1->GetStartT());
+ TLorentzVector fD2Pos(particle2->GetStartX(), particle2->GetStartY(), particle2->GetStartZ(), particle2->GetStartT());
fPairPos = (fD1Pos + fD2Pos);
}
@@ -151,10 +150,8 @@ void PairAnalysisPairLV::SetMCTracks(const CbmMCTrack* const particle1,
// }
//______________________________________________
-void PairAnalysisPairLV::GetThetaPhiCM(Double_t& thetaHE,
- Double_t& phiHE,
- Double_t& thetaCS,
- Double_t& phiCS) const {
+void PairAnalysisPairLV::GetThetaPhiCM(Double_t& thetaHE, Double_t& phiHE, Double_t& thetaCS, Double_t& phiCS) const
+{
//
// Calculate theta and phi in helicity and Collins-Soper coordinate frame
//
@@ -162,13 +159,13 @@ void PairAnalysisPairLV::GetThetaPhiCM(Double_t& thetaHE,
TLorentzVector motherMom(fPair);
TLorentzVector p1Mom(fD1);
TLorentzVector p2Mom(fD2);
- PairAnalysisPair::GetThetaPhiCM(
- motherMom, p1Mom, p2Mom, thetaHE, phiHE, thetaCS, phiCS);
+ PairAnalysisPair::GetThetaPhiCM(motherMom, p1Mom, p2Mom, thetaHE, phiHE, thetaCS, phiCS);
}
//______________________________________________
-Double_t PairAnalysisPairLV::PsiPair(Double_t /*MagField*/) const {
+Double_t PairAnalysisPairLV::PsiPair(Double_t /*MagField*/) const
+{
//Following idea to use opening of colinear pairs in magnetic field from e.g. PHENIX
//to ID conversions. Adapted from AliTRDv0Info class
//TODO: adapt and get magnetic field
@@ -191,10 +188,8 @@ Double_t PairAnalysisPairLV::PsiPair(Double_t /*MagField*/) const {
Double_t deltat = 1.;
//difference of angles of the two daughter tracks with z-axis
- deltat =
- TMath::ATan(m2[2] / (TMath::Sqrt(m2[0] * m2[0] + m2[1] * m2[1]) + 1.e-13))
- - TMath::ATan(m1[2]
- / (TMath::Sqrt(m1[0] * m1[0] + m1[1] * m1[1]) + 1.e-13));
+ deltat = TMath::ATan(m2[2] / (TMath::Sqrt(m2[0] * m2[0] + m2[1] * m2[1]) + 1.e-13))
+ - TMath::ATan(m1[2] / (TMath::Sqrt(m1[0] * m1[0] + m1[1] * m1[1]) + 1.e-13));
// Double_t radiussum = TMath::Sqrt(x*x + y*y) + 50;//radius to which tracks shall be propagated
@@ -217,15 +212,10 @@ Double_t PairAnalysisPairLV::PsiPair(Double_t /*MagField*/) const {
*/
// absolute momentum values
- Double_t pEle =
- TMath::Sqrt(mom2Prop[0] * mom2Prop[0] + mom2Prop[1] * mom2Prop[1]
- + mom2Prop[2] * mom2Prop[2]);
- Double_t pPos =
- TMath::Sqrt(mom1Prop[0] * mom1Prop[0] + mom1Prop[1] * mom1Prop[1]
- + mom1Prop[2] * mom1Prop[2]);
+ Double_t pEle = TMath::Sqrt(mom2Prop[0] * mom2Prop[0] + mom2Prop[1] * mom2Prop[1] + mom2Prop[2] * mom2Prop[2]);
+ Double_t pPos = TMath::Sqrt(mom1Prop[0] * mom1Prop[0] + mom1Prop[1] * mom1Prop[1] + mom1Prop[2] * mom1Prop[2]);
//scalar product of propagated posit
- Double_t scalarproduct = mom1Prop[0] * mom2Prop[0] + mom1Prop[1] * mom2Prop[1]
- + mom1Prop[2] * mom2Prop[2];
+ Double_t scalarproduct = mom1Prop[0] * mom2Prop[0] + mom1Prop[1] * mom2Prop[1] + mom1Prop[2] * mom2Prop[2];
//Angle between propagated daughter tracks
Double_t chipair = TMath::ACos(scalarproduct / (pEle * pPos));
@@ -235,12 +225,12 @@ Double_t PairAnalysisPairLV::PsiPair(Double_t /*MagField*/) const {
}
//______________________________________________
-Double_t PairAnalysisPairLV::GetArmAlpha() const {
+Double_t PairAnalysisPairLV::GetArmAlpha() const
+{
//
// Calculate the Armenteros-Podolanski Alpha
//
- Int_t qD1 =
- dynamic_cast<PairAnalysisTrack*>(fRefD1.GetObject())->Charge() > 0;
+ Int_t qD1 = dynamic_cast<PairAnalysisTrack*>(fRefD1.GetObject())->Charge() > 0;
TVector3 momNeg = (qD1 < 0 ? fD1.Vect() : fD2.Vect());
TVector3 momPos = (qD1 < 0 ? fD2.Vect() : fD1.Vect());
TVector3 momTot(Px(), Py(), Pz());
@@ -252,19 +242,20 @@ Double_t PairAnalysisPairLV::GetArmAlpha() const {
}
//______________________________________________
-Double_t PairAnalysisPairLV::GetArmPt() const {
+Double_t PairAnalysisPairLV::GetArmPt() const
+{
//
// Calculate the Armenteros-Podolanski Pt
//
- Int_t qD1 =
- dynamic_cast<PairAnalysisTrack*>(fRefD1.GetObject())->Charge() > 0;
+ Int_t qD1 = dynamic_cast<PairAnalysisTrack*>(fRefD1.GetObject())->Charge() > 0;
TVector3 momNeg = (qD1 < 0 ? fD1.Vect() : fD2.Vect());
TVector3 momTot(Px(), Py(), Pz());
return (momNeg.Perp(momTot));
}
//______________________________________________
-Double_t PairAnalysisPairLV::PhivPair(Double_t MagField) const {
+Double_t PairAnalysisPairLV::PhivPair(Double_t MagField) const
+{
/// Following the idea to use opening of collinear pairs in magnetic field from e.g. PHENIX
/// to identify conversions. Angle between ee plane and magnetic field is calculated (0 to pi).
/// Due to tracking to the primary vertex, conversions with no intrinsic opening angle
@@ -276,8 +267,7 @@ Double_t PairAnalysisPairLV::PhivPair(Double_t MagField) const {
/// To reach the same result as for ULS (~pi), the legs are flipped for LS.
/// TODO: VALIDATE OBSERVABLE
Int_t qD1 = 0;
- if (fRefD1.GetObject())
- qD1 = dynamic_cast<PairAnalysisTrack*>(fRefD1.GetObject())->Charge() > 0;
+ if (fRefD1.GetObject()) qD1 = dynamic_cast<PairAnalysisTrack*>(fRefD1.GetObject())->Charge() > 0;
// TODO add mc charge (no fRefD1.GetObject())
TVector3 p1;
TVector3 p2;
@@ -288,7 +278,8 @@ Double_t PairAnalysisPairLV::PhivPair(Double_t MagField) const {
if (MagField < 0) {
p1 = (qD1 > 0 ? fD1.Vect() : fD2.Vect());
p2 = (qD1 > 0 ? fD2.Vect() : fD1.Vect());
- } else {
+ }
+ else {
p2 = (qD1 > 0 ? fD1.Vect() : fD2.Vect());
p1 = (qD1 > 0 ? fD2.Vect() : fD1.Vect());
}
@@ -306,12 +297,9 @@ Double_t PairAnalysisPairLV::PhivPair(Double_t MagField) const {
TVector3 w = u.Cross(vpm);
// unit vector in xz-plane (perpendicular to B-field)
- Double_t ax =
- u.Pz() / TMath::Sqrt(u.Px() + u.Px() + u.Pz() + u.Pz()); // =sin(alpha_xz)
- Double_t ay = 0.; // by defintion
- Double_t az =
- u.Pz()
- / TMath::Sqrt(u.Px() + u.Px() + u.Pz() + u.Pz()); // =cos(alpha_xz+180)
+ Double_t ax = u.Pz() / TMath::Sqrt(u.Px() + u.Px() + u.Pz() + u.Pz()); // =sin(alpha_xz)
+ Double_t ay = 0.; // by defintion
+ Double_t az = u.Pz() / TMath::Sqrt(u.Px() + u.Px() + u.Pz() + u.Pz()); // =cos(alpha_xz+180)
TVector3 a(ax, ay, az);
// measure angle between (wx,wy,wz) and (ax,ay,0). The angle between them
@@ -324,7 +312,8 @@ Double_t PairAnalysisPairLV::PhivPair(Double_t MagField) const {
}
//_______________________________________________
-void PairAnalysisPairLV::RotateTrack(PairAnalysisTrackRotator* rot) {
+void PairAnalysisPairLV::RotateTrack(PairAnalysisTrackRotator* rot)
+{
//
// Rotate one of the legs according to the track rotator settings
//
@@ -339,24 +328,16 @@ void PairAnalysisPairLV::RotateTrack(PairAnalysisTrackRotator* rot) {
//fD1.Print("");
//fD2.Print("");
- if (rot->GetRotationType()
- == PairAnalysisTrackRotator::ERotationType::kRotatePositive
- || (rot->GetRotationType()
- == PairAnalysisTrackRotator::ERotationType::kRotateBothRandom
- && rotCharge == 0)) {
- if (first->Charge() > 0)
- fD1.RotateZ(rotAngle);
+ if (rot->GetRotationType() == PairAnalysisTrackRotator::ERotationType::kRotatePositive
+ || (rot->GetRotationType() == PairAnalysisTrackRotator::ERotationType::kRotateBothRandom && rotCharge == 0)) {
+ if (first->Charge() > 0) fD1.RotateZ(rotAngle);
else
fD2.RotateZ(rotAngle);
}
- if (rot->GetRotationType()
- == PairAnalysisTrackRotator::ERotationType::kRotateNegative
- || (rot->GetRotationType()
- == PairAnalysisTrackRotator::ERotationType::kRotateBothRandom
- && rotCharge == 1)) {
- if (first->Charge() > 0)
- fD1.RotateZ(rotAngle);
+ if (rot->GetRotationType() == PairAnalysisTrackRotator::ERotationType::kRotateNegative
+ || (rot->GetRotationType() == PairAnalysisTrackRotator::ERotationType::kRotateBothRandom && rotCharge == 1)) {
+ if (first->Charge() > 0) fD1.RotateZ(rotAngle);
else
fD2.RotateZ(rotAngle);
}
diff --git a/analysis/PWGDIL/dielectron/papaframework/PairAnalysisPairLV.h b/analysis/PWGDIL/dielectron/papaframework/PairAnalysisPairLV.h
index 6e1bc18228a22bee22a9ca3a30594f57fa2ce33d..c8e670ec6648e0714de04fca743ab534f5979454 100644
--- a/analysis/PWGDIL/dielectron/papaframework/PairAnalysisPairLV.h
+++ b/analysis/PWGDIL/dielectron/papaframework/PairAnalysisPairLV.h
@@ -28,19 +28,12 @@ public:
virtual ~PairAnalysisPairLV();
PairAnalysisPairLV(const PairAnalysisPair& pair);
- PairAnalysisPairLV(PairAnalysisTrack* const particle1,
- Int_t pid1,
- PairAnalysisTrack* const particle2,
- Int_t pid2,
+ PairAnalysisPairLV(PairAnalysisTrack* const particle1, Int_t pid1, PairAnalysisTrack* const particle2, Int_t pid2,
Char_t type);
- void SetTracks(PairAnalysisTrack* const particle1,
- Int_t pid1,
- PairAnalysisTrack* const particle2,
- Int_t pid2);
+ void SetTracks(PairAnalysisTrack* const particle1, Int_t pid1, PairAnalysisTrack* const particle2, Int_t pid2);
- void SetMCTracks(const CbmMCTrack* const particle1,
- const CbmMCTrack* const particle2);
+ void SetMCTracks(const CbmMCTrack* const particle1, const CbmMCTrack* const particle2);
// kinematics
@@ -49,7 +42,8 @@ public:
virtual Double_t Pz() const { return fPair.Pz(); }
virtual Double_t Pt() const { return fPair.Pt(); }
virtual Double_t P() const { return fPair.P(); }
- virtual Bool_t PxPyPz(Double_t p[3]) const {
+ virtual Bool_t PxPyPz(Double_t p[3]) const
+ {
p[0] = Px();
p[1] = Py();
p[2] = Pz();
@@ -59,20 +53,17 @@ public:
virtual Double_t Xv() const { return fPairPos.X(); }
virtual Double_t Yv() const { return fPairPos.Y(); }
virtual Double_t Zv() const { return fPairPos.Z(); }
- virtual Bool_t XvYvZv(Double_t x[3]) const {
+ virtual Bool_t XvYvZv(Double_t x[3]) const
+ {
x[0] = Xv();
x[1] = Yv();
x[2] = Zv();
return kTRUE;
}
- virtual Double_t OneOverPt() const {
- return Pt() > 0. ? 1. / Pt() : 0.;
- } //TODO: check
+ virtual Double_t OneOverPt() const { return Pt() > 0. ? 1. / Pt() : 0.; } //TODO: check
virtual Double_t Phi() const { return fPair.Phi(); }
- virtual Double_t Theta() const {
- return Pz() != 0 ? TMath::ATan(Pt() / Pz()) : 0.;
- } //TODO: check
+ virtual Double_t Theta() const { return Pz() != 0 ? TMath::ATan(Pt() / Pz()) : 0.; } //TODO: check
virtual Double_t E() const { return fPair.E(); }
@@ -91,15 +82,10 @@ public:
Double_t DaughtersP() const { return fD1.P() * fD2.P(); }
// calculate cos(theta*) and phi* in HE and CS pictures
- void GetThetaPhiCM(Double_t& thetaHE,
- Double_t& phiHE,
- Double_t& thetaCS,
- Double_t& phiCS) const;
+ void GetThetaPhiCM(Double_t& thetaHE, Double_t& phiHE, Double_t& thetaCS, Double_t& phiCS) const;
- Double_t
- PsiPair(Double_t MagField) const; //Angle cut w.r.t. to magnetic field
- Double_t PhivPair(
- Double_t MagField) const; //Angle of ee plane w.r.t. to magnetic field
+ Double_t PsiPair(Double_t MagField) const; //Angle cut w.r.t. to magnetic field
+ Double_t PhivPair(Double_t MagField) const; //Angle of ee plane w.r.t. to magnetic field
Double_t GetArmAlpha() const;
Double_t GetArmPt() const;
@@ -114,9 +100,9 @@ public:
private:
TLorentzVector fPairPos; // lorentz vector position
- TLorentzVector fPair; // lorentz vector internaly used for pair calculation
- TLorentzVector fD1; // lorentz vector first daughter
- TLorentzVector fD2; // lorentz vector second daughter
+ TLorentzVector fPair; // lorentz vector internaly used for pair calculation
+ TLorentzVector fD1; // lorentz vector first daughter
+ TLorentzVector fD2; // lorentz vector second daughter
ClassDef(PairAnalysisPairLV, 2) // Lorentz vector pairs
};
diff --git a/analysis/PWGDIL/dielectron/papaframework/PairAnalysisPairLegCuts.cxx b/analysis/PWGDIL/dielectron/papaframework/PairAnalysisPairLegCuts.cxx
index a6d38a095b8920c49666b0696c4f6f3e649e2314..f2747edbd881a4731789df1a8f3a45301836ee45 100644
--- a/analysis/PWGDIL/dielectron/papaframework/PairAnalysisPairLegCuts.cxx
+++ b/analysis/PWGDIL/dielectron/papaframework/PairAnalysisPairLegCuts.cxx
@@ -17,29 +17,30 @@
// //
///////////////////////////////////////////////////////////////////////////
+#include "PairAnalysisPairLegCuts.h"
+
#include <TList.h>
#include "PairAnalysisPairLV.h"
#include "PairAnalysisTrack.h"
-#include "PairAnalysisPairLegCuts.h"
-
ClassImp(PairAnalysisPairLegCuts)
PairAnalysisPairLegCuts::PairAnalysisPairLegCuts()
- : PairAnalysisPairLegCuts("pairlegcut", "pairlegcut") {
+ : PairAnalysisPairLegCuts("pairlegcut", "pairlegcut")
+{
//
// Default contructor
//
}
//________________________________________________________________________
-PairAnalysisPairLegCuts::PairAnalysisPairLegCuts(const char* name,
- const char* title)
+PairAnalysisPairLegCuts::PairAnalysisPairLegCuts(const char* name, const char* title)
: AnalysisCuts(name, title)
, fFilterLeg1("PairFilterLeg1", "PairFilterLeg1")
- , fFilterLeg2("PairFilterLeg2", "PairFilterLeg2") {
+ , fFilterLeg2("PairFilterLeg2", "PairFilterLeg2")
+{
//
// Named contructor
//
@@ -47,7 +48,8 @@ PairAnalysisPairLegCuts::PairAnalysisPairLegCuts(const char* name,
//________________________________________________________________________
-Bool_t PairAnalysisPairLegCuts::IsSelected(TObject* track) {
+Bool_t PairAnalysisPairLegCuts::IsSelected(TObject* track)
+{
//
// check if cuts are fulfilled
//
@@ -90,19 +92,17 @@ Bool_t PairAnalysisPairLegCuts::IsSelected(TObject* track) {
}
if (fCutType == kMixLegs) {
- Bool_t isLeg1selectedMirror =
- (fFilterLeg1.IsSelected(leg2) == selectedMaskLeg1);
- Bool_t isLeg2selectedMirror =
- (fFilterLeg2.IsSelected(leg1) == selectedMaskLeg2);
- isSelected = (isLeg1selected && isLeg2selected)
- || (isLeg1selectedMirror && isLeg2selectedMirror);
+ Bool_t isLeg1selectedMirror = (fFilterLeg1.IsSelected(leg2) == selectedMaskLeg1);
+ Bool_t isLeg2selectedMirror = (fFilterLeg2.IsSelected(leg1) == selectedMaskLeg2);
+ isSelected = (isLeg1selected && isLeg2selected) || (isLeg1selectedMirror && isLeg2selectedMirror);
SetSelected(isSelected);
}
return isSelected;
}
//________________________________________________________________________
-void PairAnalysisPairLegCuts::Print(const Option_t* /*option*/) const {
+void PairAnalysisPairLegCuts::Print(const Option_t* /*option*/) const
+{
//
// Print cuts and the range
//
@@ -111,13 +111,8 @@ void PairAnalysisPairLegCuts::Print(const Option_t* /*option*/) const {
switch (fCutType) {
case kBothLegs: printf("Both legs have to fulfill the cuts\n"); break;
case kAnyLeg: printf("Any leg have to fulfill the cuts\n"); break;
- case kMixLegs:
- printf(
- "Leg1(leg2) has to fullfill the leg1(2)- or leg2(1)-cuts (mix mode)\n");
- break;
- case kOneLeg:
- printf("Only one of legs is allowed to fulfill the cuts\n");
- break;
+ case kMixLegs: printf("Leg1(leg2) has to fullfill the leg1(2)- or leg2(1)-cuts (mix mode)\n"); break;
+ case kOneLeg: printf("Only one of legs is allowed to fulfill the cuts\n"); break;
}
printf("Leg filter1: \n");
diff --git a/analysis/PWGDIL/dielectron/papaframework/PairAnalysisPairLegCuts.h b/analysis/PWGDIL/dielectron/papaframework/PairAnalysisPairLegCuts.h
index d385b34046a36b63f8fd5ec8008a3c47c59d566a..b4cc291b2271cd96ba582e98668f451901872221 100644
--- a/analysis/PWGDIL/dielectron/papaframework/PairAnalysisPairLegCuts.h
+++ b/analysis/PWGDIL/dielectron/papaframework/PairAnalysisPairLegCuts.h
@@ -19,7 +19,13 @@
class PairAnalysisPairLegCuts : public AnalysisCuts {
public:
- enum ECutType { kBothLegs = 0, kAnyLeg, kMixLegs, kOneLeg };
+ enum ECutType
+ {
+ kBothLegs = 0,
+ kAnyLeg,
+ kMixLegs,
+ kOneLeg
+ };
PairAnalysisPairLegCuts();
PairAnalysisPairLegCuts(const char* name, const char* title);
diff --git a/analysis/PWGDIL/dielectron/papaframework/PairAnalysisSignalExt.cxx b/analysis/PWGDIL/dielectron/papaframework/PairAnalysisSignalExt.cxx
index af1ad1507b619a6f0e89d13a185bc28025c8a2e9..7131b1e1a1f03da039bfaa537b70ff7edf8b95fe 100644
--- a/analysis/PWGDIL/dielectron/papaframework/PairAnalysisSignalExt.cxx
+++ b/analysis/PWGDIL/dielectron/papaframework/PairAnalysisSignalExt.cxx
@@ -13,6 +13,7 @@ resulting from single and mixed events, as defined in PairAnalysis.cxx
///////////////////////////////////////////////////////////////////////////
+#include <TCollection.h>
#include <TDatabasePDG.h>
#include <TF1.h>
#include <TH1.h>
@@ -22,9 +23,6 @@ resulting from single and mixed events, as defined in PairAnalysis.cxx
#include <TProfile2D.h>
#include <TROOT.h>
#include <TVectorT.h>
-
-#include <TCollection.h>
-#include <TF1.h>
//#include <TH1.h>
#include <TCanvas.h>
#include <TGaxis.h>
@@ -36,43 +34,43 @@ resulting from single and mixed events, as defined in PairAnalysis.cxx
#include <TString.h>
#include "PairAnalysis.h"
+#include "PairAnalysisFunction.h"
#include "PairAnalysisHelper.h"
+#include "PairAnalysisSignalExt.h"
#include "PairAnalysisSignalMC.h"
#include "PairAnalysisStyler.h"
-#include "PairAnalysisFunction.h"
-#include "PairAnalysisSignalExt.h"
-
ClassImp(PairAnalysisSignalExt)
- TH1F* PairAnalysisSignalExt::fgHistSimPM = 0x0;
-TObject* PairAnalysisSignalExt::fgPeakShape = 0x0;
-const char* PairAnalysisSignalExt::fgkValueNames[7] =
- {"S", "B", "S/#sqrt{S+B}", "S/B", "Mass", "MassWidth", "ChiSqNDFmatch"};
-const char* PairAnalysisSignalExt::fgkBackgroundMethodNames[11] = {
- "FittedMC",
- "Fitted",
- "like-sign",
- "like-sign (arithm.)",
- "like-sign #times R(#Deltam)",
- "like-sign (arithm.) #times R(#Deltam)",
- "fitted like-sign",
- "mixed event",
- "fitted mixed event",
- "track rotation",
- "cocktail"};
-
-PairAnalysisSignalExt::PairAnalysisSignalExt()
- : PairAnalysisSignalExt("PairAnalysisSignalExt", "title") {
+ TH1F* PairAnalysisSignalExt::fgHistSimPM = 0x0;
+TObject* PairAnalysisSignalExt::fgPeakShape = 0x0;
+const char* PairAnalysisSignalExt::fgkValueNames[7] = {"S", "B", "S/#sqrt{S+B}", "S/B",
+ "Mass", "MassWidth", "ChiSqNDFmatch"};
+const char* PairAnalysisSignalExt::fgkBackgroundMethodNames[11] = {"FittedMC",
+ "Fitted",
+ "like-sign",
+ "like-sign (arithm.)",
+ "like-sign #times R(#Deltam)",
+ "like-sign (arithm.) #times R(#Deltam)",
+ "fitted like-sign",
+ "mixed event",
+ "fitted mixed event",
+ "track rotation",
+ "cocktail"};
+
+PairAnalysisSignalExt::PairAnalysisSignalExt() : PairAnalysisSignalExt("PairAnalysisSignalExt", "title")
+{
//
// Default Constructor
//
}
//______________________________________________
-PairAnalysisSignalExt::PairAnalysisSignalExt(const char* name,
- const char* title)
- : PairAnalysisFunction(name, title), fValues(7), fErrors(7) {
+PairAnalysisSignalExt::PairAnalysisSignalExt(const char* name, const char* title)
+ : PairAnalysisFunction(name, title)
+ , fValues(7)
+ , fErrors(7)
+{
//
// Named Constructor
//
@@ -114,7 +112,8 @@ PairAnalysisSignalExt::PairAnalysisSignalExt(const PairAnalysisSignalExt& c)
}
//______________________________________________
-PairAnalysisSignalExt::~PairAnalysisSignalExt() {
+PairAnalysisSignalExt::~PairAnalysisSignalExt()
+{
//
// Default Destructor
//
@@ -137,11 +136,9 @@ PairAnalysisSignalExt::~PairAnalysisSignalExt() {
}
//______________________________________________
-TPaveText* PairAnalysisSignalExt::DrawStats(Double_t x1 /*=0.*/,
- Double_t y1 /*=0.*/,
- Double_t x2 /*=0.*/,
- Double_t y2 /*=0.*/,
- TString opt /*="pRnbsSmrc"*/) {
+TPaveText* PairAnalysisSignalExt::DrawStats(Double_t x1 /*=0.*/, Double_t y1 /*=0.*/, Double_t x2 /*=0.*/,
+ Double_t y2 /*=0.*/, TString opt /*="pRnbsSmrc"*/)
+{
//
// Draw extracted values in a TPaveText
//
@@ -163,8 +160,7 @@ TPaveText* PairAnalysisSignalExt::DrawStats(Double_t x1 /*=0.*/,
y1 = .7;
y2 = .9;
}
- if (y1 < 0.5)
- y2 = y1 + 0.025 * opt.Length();
+ if (y1 < 0.5) y2 = y1 + 0.025 * opt.Length();
else
y1 = y2 - 0.025 * opt.Length();
@@ -176,95 +172,59 @@ TPaveText* PairAnalysisSignalExt::DrawStats(Double_t x1 /*=0.*/,
t->SetFillStyle(kFEmpty);
t->SetBorderSize(0);
t->SetTextAlign(12);
- if (opt.Contains("p"))
- t->AddText(
- Form("#bf{%s}", (fPOI ? fPOI->GetName() : "particle not found")));
- if (opt.Contains("R"))
- t->AddText(Form("%.2f < %s < %.2f GeV/c^{2}", fIntMin, "m_{inv}", fIntMax));
- if (opt.Contains("n"))
- t->AddText(
- Form("%s: %.4g #pm %.4g", fgkValueNames[0], fValues(0), fErrors(0)));
- if (opt.Contains("b"))
- t->AddText(
- Form("%s: %.4g #pm %.4g", fgkValueNames[1], fValues(1), fErrors(1)));
+ if (opt.Contains("p")) t->AddText(Form("#bf{%s}", (fPOI ? fPOI->GetName() : "particle not found")));
+ if (opt.Contains("R")) t->AddText(Form("%.2f < %s < %.2f GeV/c^{2}", fIntMin, "m_{inv}", fIntMax));
+ if (opt.Contains("n")) t->AddText(Form("%s: %.4g #pm %.4g", fgkValueNames[0], fValues(0), fErrors(0)));
+ if (opt.Contains("b")) t->AddText(Form("%s: %.4g #pm %.4g", fgkValueNames[1], fValues(1), fErrors(1)));
Int_t smallS2B = (fValues(3) < 0.1 ? 1 : 100);
if (opt.Contains("s"))
- t->AddText(Form("%s: %.2f #pm %.2f%s",
- fgkValueNames[3],
- fValues(3) * 100 / smallS2B,
- fErrors(3) * 100 / smallS2B,
+ t->AddText(Form("%s: %.2f #pm %.2f%s", fgkValueNames[3], fValues(3) * 100 / smallS2B, fErrors(3) * 100 / smallS2B,
smallS2B > 1 ? "" : "%"));
- if (opt.Contains("S"))
- t->AddText(
- Form("%s: %.1f #pm %.1f", fgkValueNames[2], fValues(2), fErrors(2)));
- if (opt.Contains("m") && fValues(4) > 0)
- t->AddText(Form("Mass: %.2f #pm %.2f GeV/c^{2}", fValues(4), fErrors(4)));
+ if (opt.Contains("S")) t->AddText(Form("%s: %.1f #pm %.1f", fgkValueNames[2], fValues(2), fErrors(2)));
+ if (opt.Contains("m") && fValues(4) > 0) t->AddText(Form("Mass: %.2f #pm %.2f GeV/c^{2}", fValues(4), fErrors(4)));
if (opt.Contains("r") && fValues(5) > 0)
- t->AddText(Form("Mass res.: %.1f #pm %.1f MeV/c^{2}",
- 1000 * fValues(5),
- 1000 * fErrors(5)));
- if (opt.Contains("c") && fValues(6) > 0)
- t->AddText(Form("Match chi2/ndf.: %.1f", fValues(6)));
+ t->AddText(Form("Mass res.: %.1f #pm %.1f MeV/c^{2}", 1000 * fValues(5), 1000 * fErrors(5)));
+ if (opt.Contains("c") && fValues(6) > 0) t->AddText(Form("Match chi2/ndf.: %.1f", fValues(6)));
t->Draw();
return t;
}
//______________________________________________
-void PairAnalysisSignalExt::Print(Option_t* /*option*/) const {
+void PairAnalysisSignalExt::Print(Option_t* /*option*/) const
+{
//
// Print the statistics
//
- printf("Signal : %.5g #pm %.5g (+-%.3g%%)\n",
- fValues(0),
- fErrors(0),
- 100 * fErrors(0) / fValues(0));
- printf("Backgnd: %.5g #pm %.5g (+-%.3g%%)\n",
- fValues(1),
- fErrors(1),
- 100 * fErrors(1) / fValues(1));
- printf("Signif : %.5g #pm %.5g (+-%.3g%%)\n",
- fValues(2),
- fErrors(2),
- 100 * fErrors(2) / fValues(2));
- printf("SoB : %.5g #pm %.5g (+-%.3g%%)\n",
- fValues(3),
- fErrors(3),
- 100 * fErrors(3) / fValues(3));
+ printf("Signal : %.5g #pm %.5g (+-%.3g%%)\n", fValues(0), fErrors(0), 100 * fErrors(0) / fValues(0));
+ printf("Backgnd: %.5g #pm %.5g (+-%.3g%%)\n", fValues(1), fErrors(1), 100 * fErrors(1) / fValues(1));
+ printf("Signif : %.5g #pm %.5g (+-%.3g%%)\n", fValues(2), fErrors(2), 100 * fErrors(2) / fValues(2));
+ printf("SoB : %.5g #pm %.5g (+-%.3g%%)\n", fValues(3), fErrors(3), 100 * fErrors(3) / fValues(3));
if (fValues(4) > 0) printf("Mass: %.5g #pm %.5g\n", fValues(4), fErrors(4));
- if (fValues(5) > 0)
- printf("Mass res.: %.5g #pm %.5g\n", fValues(5), fErrors(5));
+ if (fValues(5) > 0) printf("Mass res.: %.5g #pm %.5g\n", fValues(5), fErrors(5));
if (fValues(6) > 0) printf("Match chi2/ndf: %.5g \n", fValues(6));
printf("Scale : %.5g \n", fScaleFactor);
printf("Mass int.: %.5g - %.5g \n", fIntMin, fIntMax);
}
//______________________________________________
-Double_t PairAnalysisSignalExt::ScaleHistograms(TH1* histRaw,
- TH1* histBackground,
- Double_t intMin,
- Double_t intMax) {
+Double_t PairAnalysisSignalExt::ScaleHistograms(TH1* histRaw, TH1* histBackground, Double_t intMin, Double_t intMax)
+{
//
// scale histBackground to match the integral of histRaw in the interval intMin, intMax
//
//protect using over and underflow bins in normalisation calculation
- if (intMin < histRaw->GetXaxis()->GetXmin())
- intMin = histRaw->GetXaxis()->GetXmin();
- if (intMin < histBackground->GetXaxis()->GetXmin())
- intMin = histBackground->GetXaxis()->GetXmin();
+ if (intMin < histRaw->GetXaxis()->GetXmin()) intMin = histRaw->GetXaxis()->GetXmin();
+ if (intMin < histBackground->GetXaxis()->GetXmin()) intMin = histBackground->GetXaxis()->GetXmin();
if (intMax > histRaw->GetXaxis()->GetXmax())
- intMax = histRaw->GetXaxis()->GetXmax()
- - histRaw->GetBinWidth(histRaw->GetNbinsX()) / 2.;
+ intMax = histRaw->GetXaxis()->GetXmax() - histRaw->GetBinWidth(histRaw->GetNbinsX()) / 2.;
if (intMax > histBackground->GetXaxis()->GetXmax())
- intMax = histBackground->GetXaxis()->GetXmax()
- - histBackground->GetBinWidth(histBackground->GetNbinsX()) / 2.;
+ intMax = histBackground->GetXaxis()->GetXmax() - histBackground->GetBinWidth(histBackground->GetNbinsX()) / 2.;
- Double_t intRaw =
- histRaw->Integral(histRaw->FindBin(intMin), histRaw->FindBin(intMax));
- Double_t intBack = histBackground->Integral(histBackground->FindBin(intMin),
- histBackground->FindBin(intMax));
+ Double_t intRaw = histRaw->Integral(histRaw->FindBin(intMin), histRaw->FindBin(intMax));
+ Double_t intBack = histBackground->Integral(histBackground->FindBin(intMin), histBackground->FindBin(intMax));
fScaleFactor = intBack > 0 ? intRaw / intBack : 1.;
// scale
if (histBackground->GetDefaultSumw2()) histBackground->Sumw2();
@@ -274,40 +234,28 @@ Double_t PairAnalysisSignalExt::ScaleHistograms(TH1* histRaw,
}
//______________________________________________
-Double_t PairAnalysisSignalExt::ScaleHistograms(TH1* histRaw,
- TH1* histBackground,
- Double_t intMin,
- Double_t intMax,
- Double_t intMin2,
- Double_t intMax2) {
+Double_t PairAnalysisSignalExt::ScaleHistograms(TH1* histRaw, TH1* histBackground, Double_t intMin, Double_t intMax,
+ Double_t intMin2, Double_t intMax2)
+{
//
// scale histBackground to match the integral of "histRaw" in the interval "intMin", "intMax" and "intMin2", "intMax2"
//
- if (TMath::Abs(intMin2 - intMax2) < 0.00001)
- return (ScaleHistograms(histRaw, histBackground, intMin, intMax));
+ if (TMath::Abs(intMin2 - intMax2) < 0.00001) return (ScaleHistograms(histRaw, histBackground, intMin, intMax));
//protect using over and underflow bins in normalisation calculation
- if (intMin < histRaw->GetXaxis()->GetXmin())
- intMin = histRaw->GetXaxis()->GetXmin();
- if (intMin < histBackground->GetXaxis()->GetXmin())
- intMin = histBackground->GetXaxis()->GetXmin();
+ if (intMin < histRaw->GetXaxis()->GetXmin()) intMin = histRaw->GetXaxis()->GetXmin();
+ if (intMin < histBackground->GetXaxis()->GetXmin()) intMin = histBackground->GetXaxis()->GetXmin();
if (intMax2 > histRaw->GetXaxis()->GetXmax())
- intMax2 = histRaw->GetXaxis()->GetXmax()
- - histRaw->GetBinWidth(histRaw->GetNbinsX()) / 2.;
+ intMax2 = histRaw->GetXaxis()->GetXmax() - histRaw->GetBinWidth(histRaw->GetNbinsX()) / 2.;
if (intMax2 > histBackground->GetXaxis()->GetXmax())
- intMax2 = histBackground->GetXaxis()->GetXmax()
- - histBackground->GetBinWidth(histBackground->GetNbinsX()) / 2.;
-
- Double_t intRaw =
- histRaw->Integral(histRaw->FindBin(intMin), histRaw->FindBin(intMax));
- Double_t intBack = histBackground->Integral(histBackground->FindBin(intMin),
- histBackground->FindBin(intMax));
- intRaw +=
- histRaw->Integral(histRaw->FindBin(intMin2), histRaw->FindBin(intMax2));
- intBack += histBackground->Integral(histBackground->FindBin(intMin2),
- histBackground->FindBin(intMax2));
+ intMax2 = histBackground->GetXaxis()->GetXmax() - histBackground->GetBinWidth(histBackground->GetNbinsX()) / 2.;
+
+ Double_t intRaw = histRaw->Integral(histRaw->FindBin(intMin), histRaw->FindBin(intMax));
+ Double_t intBack = histBackground->Integral(histBackground->FindBin(intMin), histBackground->FindBin(intMax));
+ intRaw += histRaw->Integral(histRaw->FindBin(intMin2), histRaw->FindBin(intMax2));
+ intBack += histBackground->Integral(histBackground->FindBin(intMin2), histBackground->FindBin(intMax2));
fScaleFactor = intBack > 0 ? intRaw / intBack : 1.;
// scale
@@ -318,7 +266,8 @@ Double_t PairAnalysisSignalExt::ScaleHistograms(TH1* histRaw,
}
//______________________________________________
-TH1* PairAnalysisSignalExt::MergeObjects(TH1* obj1, TH1* obj2, Double_t val) {
+TH1* PairAnalysisSignalExt::MergeObjects(TH1* obj1, TH1* obj2, Double_t val)
+{
//
// function to merge all TH1 inherited objects
// (needed because TProfile::Add with negative 'val' does not what is needed)
@@ -328,37 +277,32 @@ TH1* PairAnalysisSignalExt::MergeObjects(TH1* obj1, TH1* obj2, Double_t val) {
if (!obj2) return obj1;
TString key = Form("%s_%s", obj1->GetName(), "Signal");
- if (obj1->IsA() == TProfile2D::Class()
- && obj2->IsA() == TProfile2D::Class()) {
+ if (obj1->IsA() == TProfile2D::Class() && obj2->IsA() == TProfile2D::Class()) {
if (val >= 0.) {
//summation
((TProfile2D*) obj1)->Add(((TProfile2D*) obj2), val);
return (TH1*) obj1->Clone(key.Data()); //TOCHECK: clone needed??
- } else
+ }
+ else
return 0x0;
- } else if (obj1->IsA() == TProfile::Class()
- && obj2->IsA() == TProfile::Class()) {
+ }
+ else if (obj1->IsA() == TProfile::Class() && obj2->IsA() == TProfile::Class()) {
if (val >= 0.) {
//summation
((TProfile*) obj1)->Add(((TProfile*) obj2), val);
return (TH1*) obj1->Clone(key.Data()); //TOCHECK: clone needed??
- } else {
+ }
+ else {
// ONLY 1D subtraction
- TH1D* histSign = new TH1D(key.Data(),
- "",
- obj1->GetXaxis()->GetNbins(),
- obj1->GetXaxis()->GetXmin(),
+ TH1D* histSign = new TH1D(key.Data(), "", obj1->GetXaxis()->GetNbins(), obj1->GetXaxis()->GetXmin(),
obj1->GetXaxis()->GetXmax());
if (histSign->GetDefaultSumw2()) histSign->Sumw2();
histSign->SetDirectory(0);
for (Int_t i = 0; i <= obj1->GetNbinsX(); i++) {
- histSign->SetBinContent(
- i, obj1->GetBinContent(i) - obj2->GetBinContent(i));
+ histSign->SetBinContent(i, obj1->GetBinContent(i) - obj2->GetBinContent(i));
histSign->SetBinError(
- i,
- TMath::Sqrt(obj1->GetBinError(i) * obj1->GetBinError(i)
- - obj2->GetBinError(i) * obj2->GetBinError(i)));
+ i, TMath::Sqrt(obj1->GetBinError(i) * obj1->GetBinError(i) - obj2->GetBinError(i) * obj2->GetBinError(i)));
}
return histSign;
}
@@ -371,12 +315,14 @@ TH1* PairAnalysisSignalExt::MergeObjects(TH1* obj1, TH1* obj2, Double_t val) {
listH.Add(obj2);
obj1->Execute("Merge", listHargs.Data(), &error);
*/
- } else { // Histograms
+ }
+ else { // Histograms
if (val < 0.) { // subtraction
TH1* histSign = (TH1*) obj1->Clone(key.Data());
histSign->Add(obj2, val);
return histSign;
- } else { // merge
+ }
+ else { // merge
obj1->Add(obj2, val);
return obj1;
}
@@ -384,10 +330,8 @@ TH1* PairAnalysisSignalExt::MergeObjects(TH1* obj1, TH1* obj2, Double_t val) {
}
//______________________________________________
-TObject*
-PairAnalysisSignalExt::DescribePeakShape(ESignalExtractionMethod method,
- Bool_t replaceValErr,
- TH1F* mcShape) {
+TObject* PairAnalysisSignalExt::DescribePeakShape(ESignalExtractionMethod method, Bool_t replaceValErr, TH1F* mcShape)
+{
//
// Describe the extracted peak by the selected "method" and overwrite signal etc if activated
//
@@ -407,8 +351,7 @@ PairAnalysisSignalExt::DescribePeakShape(ESignalExtractionMethod method,
//PairAnalysisSignalFit *fExtrFunc = new PairAnalysisSignalFit();
// PairAnalysisSignalFunc fct;// = 0;//new PairAnalysisSignalFunc();
- Info(
- "DescribePeakShape", "Signal extraction method: %d", (Int_t) fPeakMethod);
+ Info("DescribePeakShape", "Signal extraction method: %d", (Int_t) fPeakMethod);
// do the scaling/fitting
switch (method) {
@@ -430,12 +373,9 @@ PairAnalysisSignalExt::DescribePeakShape(ESignalExtractionMethod method,
return 0x0;
}
if (mcShape->GetBinWidth(1) != fHistSignal->GetBinWidth(1))
- printf(
- " WARNING: MC and signal histogram have different bin widths. \n");
- data = fHistSignal->Integral(fHistSignal->FindBin(fIntMin),
- fHistSignal->FindBin(fIntMax));
- mc =
- mcShape->Integral(mcShape->FindBin(fIntMin), mcShape->FindBin(fIntMax));
+ printf(" WARNING: MC and signal histogram have different bin widths. \n");
+ data = fHistSignal->Integral(fHistSignal->FindBin(fIntMin), fHistSignal->FindBin(fIntMax));
+ mc = mcShape->Integral(mcShape->FindBin(fIntMin), mcShape->FindBin(fIntMax));
mcShape->Scale(data / mc);
break;
@@ -445,22 +385,15 @@ PairAnalysisSignalExt::DescribePeakShape(ESignalExtractionMethod method,
return 0x0;
}
if (!fgHistSimPM) fgHistSimPM = mcShape;
- if (fgHistSimPM->GetBinWidth(1) != fHistSignal->GetBinWidth(1))
- fgHistSimPM->Rebin(fRebin);
+ if (fgHistSimPM->GetBinWidth(1) != fHistSignal->GetBinWidth(1)) fgHistSimPM->Rebin(fRebin);
// fit = new TF1("fitMC",PairAnalysisSignalFunc::PeakFunMC,fFitMin,fFitMax,1);
- fit = new TF1(
- "MC", fExtrFunc, &PairAnalysisFunction::PeakFunMC, fFitMin, fFitMax, 1);
+ fit = new TF1("MC", fExtrFunc, &PairAnalysisFunction::PeakFunMC, fFitMin, fFitMax, 1);
fit->SetParNames("N");
fitResult = fHistSignal->Fit(fit, "RNI0Q");
break;
case kCrystalBall:
- fit = new TF1("Crystal Ball",
- fExtrFunc,
- &PairAnalysisFunction::PeakFunCB,
- fFitMin,
- fFitMax,
- 5);
+ fit = new TF1("Crystal Ball", fExtrFunc, &PairAnalysisFunction::PeakFunCB, fFitMin, fFitMax, 5);
fit->SetParNames("alpha", "n", "meanx", "sigma", "N");
// fit->SetParameters(-.2,5.,gMjpsi,.06,20);
// fit->SetParameters(1.,3.6,gMjpsi,.08,700);
@@ -476,12 +409,7 @@ PairAnalysisSignalExt::DescribePeakShape(ESignalExtractionMethod method,
break;
case kGaus:
- fit = new TF1("Gaussisan",
- fExtrFunc,
- &PairAnalysisFunction::PeakFunGauss,
- fFitMin,
- fFitMax,
- 3);
+ fit = new TF1("Gaussisan", fExtrFunc, &PairAnalysisFunction::PeakFunGauss, fFitMin, fFitMax, 3);
//fit = new TF1("fitGaus","gaus",fFitMin,fFitMax);
fit->SetParNames("N", "meanx", "sigma");
fit->SetParameters(1.3 * nPOI, massPOI, sigPOI);
@@ -505,27 +433,22 @@ PairAnalysisSignalExt::DescribePeakShape(ESignalExtractionMethod method,
}
// warning in case of fit issues
- if (fitResult != 0)
- Warning("DescripePeakShape", "fit has error/issue (%d)", fitResult);
+ if (fitResult != 0) Warning("DescripePeakShape", "fit has error/issue (%d)", fitResult);
// store chi2/ndf of the fit
- if (fit)
- fValues(6) = (fit->GetNDF() ? fit->GetChisquare() / fit->GetNDF() : -1.);
+ if (fit) fValues(6) = (fit->GetNDF() ? fit->GetChisquare() / fit->GetNDF() : -1.);
// overwrite values and errors if requested
if (replaceValErr) {
switch (method) {
case kBinCounting:
fValues(0) =
- fHistSignal->IntegralAndError(fHistSignal->FindBin(fIntMin),
- fHistSignal->FindBin(fIntMax),
- fErrors(0));
+ fHistSignal->IntegralAndError(fHistSignal->FindBin(fIntMin), fHistSignal->FindBin(fIntMax), fErrors(0));
SetSignificanceAndSOB();
break;
case kMCScaledMax:
case kMCScaledInt:
- fValues(0) = mcShape->IntegralAndError(
- mcShape->FindBin(fIntMin), mcShape->FindBin(fIntMax), fErrors(0));
+ fValues(0) = mcShape->IntegralAndError(mcShape->FindBin(fIntMin), mcShape->FindBin(fIntMax), fErrors(0));
SetSignificanceAndSOB();
break;
@@ -547,7 +470,8 @@ PairAnalysisSignalExt::DescribePeakShape(ESignalExtractionMethod method,
if (parSigma >= 0) {
fValues(5) = fit->GetParameter(parSigma);
fErrors(5) = fit->GetParError(parSigma);
- } else {
+ }
+ else {
// calculate FWHM
SetFWHM();
}
@@ -569,8 +493,7 @@ PairAnalysisSignalExt::DescribePeakShape(ESignalExtractionMethod method,
case kMCFitted:
case kCrystalBall:
case kGaus:
- if (fgHistSimPM)
- fit->SetName(Form("mcShapeFunc-%s", fgHistSimPM->GetName()));
+ if (fgHistSimPM) fit->SetName(Form("mcShapeFunc-%s", fgHistSimPM->GetName()));
if (replaceValErr) fgPeakShape = fit;
// delete fExtrFunc;
fPeakIsTF1 = kTRUE;
@@ -593,7 +516,8 @@ PairAnalysisSignalExt::DescribePeakShape(ESignalExtractionMethod method,
}
//______________________________________________
-void PairAnalysisSignalExt::Process(TObjArray* const arrhist) {
+void PairAnalysisSignalExt::Process(TObjArray* const arrhist)
+{
//
// process signal subtraction
//
@@ -602,8 +526,8 @@ void PairAnalysisSignalExt::Process(TObjArray* const arrhist) {
// calculate optimal binning if configured
if (fRebinStat < 1. && fBinLimits == 0x0) {
- fBinLimits = PairAnalysisHelper::MakeStatBinLimits(
- (TH1*) FindObject(arrhist, PairAnalysis::EPairType::kSEPM), fRebinStat);
+ fBinLimits =
+ PairAnalysisHelper::MakeStatBinLimits((TH1*) FindObject(arrhist, PairAnalysis::EPairType::kSEPM), fRebinStat);
}
@@ -680,10 +604,10 @@ void PairAnalysisSignalExt::Process(TObjArray* const arrhist) {
fHistDataPP = (TH1*) FindObject(arrhist, PairAnalysis::EPairType::kSEPP);
if (fHistDataPP) {
if (fBinLimits) {
- fHistDataPP = fHistDataPP->Rebin(
- fBinLimits->GetSize() - 1, "histPP", fBinLimits->GetArray());
+ fHistDataPP = fHistDataPP->Rebin(fBinLimits->GetSize() - 1, "histPP", fBinLimits->GetArray());
fHistDataPP->Scale(1., "width");
- } else
+ }
+ else
fHistDataPP->Clone("histPP");
if (fHistDataPP->GetDefaultSumw2()) fHistDataPP->Sumw2();
fHistDataPP->SetDirectory(0);
@@ -693,10 +617,10 @@ void PairAnalysisSignalExt::Process(TObjArray* const arrhist) {
fHistDataPM = (TH1*) FindObject(arrhist, PairAnalysis::EPairType::kSEPM);
if (fHistDataPM) {
if (fBinLimits) {
- fHistDataPM = fHistDataPM->Rebin(
- fBinLimits->GetSize() - 1, "histPM", fBinLimits->GetArray());
+ fHistDataPM = fHistDataPM->Rebin(fBinLimits->GetSize() - 1, "histPM", fBinLimits->GetArray());
fHistDataPM->Scale(1., "width");
- } else
+ }
+ else
fHistDataPM->Clone("histPM");
if (fHistDataPM->GetDefaultSumw2()) fHistDataPM->Sumw2();
fHistDataPM->SetDirectory(0);
@@ -707,10 +631,10 @@ void PairAnalysisSignalExt::Process(TObjArray* const arrhist) {
fHistDataMM = (TH1*) FindObject(arrhist, PairAnalysis::EPairType::kSEMM);
if (fHistDataMM) {
if (fBinLimits) {
- fHistDataMM = fHistDataMM->Rebin(
- fBinLimits->GetSize() - 1, "histMM", fBinLimits->GetArray());
+ fHistDataMM = fHistDataMM->Rebin(fBinLimits->GetSize() - 1, "histMM", fBinLimits->GetArray());
fHistDataMM->Scale(1., "width");
- } else
+ }
+ else
fHistDataMM->Clone("histMM");
if (fHistDataMM->GetDefaultSumw2()) fHistDataMM->Sumw2();
fHistDataMM->SetDirectory(0);
@@ -720,10 +644,10 @@ void PairAnalysisSignalExt::Process(TObjArray* const arrhist) {
fHistMixPP = (TH1*) FindObject(arrhist, PairAnalysis::EPairType::kMEPP);
if (fHistMixPP) {
if (fBinLimits) {
- fHistMixPP = fHistMixPP->Rebin(
- fBinLimits->GetSize() - 1, "mixPP", fBinLimits->GetArray());
+ fHistMixPP = fHistMixPP->Rebin(fBinLimits->GetSize() - 1, "mixPP", fBinLimits->GetArray());
fHistMixPP->Scale(1., "width");
- } else
+ }
+ else
fHistMixPP->Clone("mixPP");
if (fHistMixPP->GetDefaultSumw2()) fHistMixPP->Sumw2();
fHistMixPP->SetDirectory(0);
@@ -733,10 +657,10 @@ void PairAnalysisSignalExt::Process(TObjArray* const arrhist) {
fHistMixPM = (TH1*) FindObject(arrhist, PairAnalysis::EPairType::kMEPM);
if (fHistMixPM) {
if (fBinLimits) {
- fHistMixPM = fHistMixPM->Rebin(
- fBinLimits->GetSize() - 1, "mixPM", fBinLimits->GetArray());
+ fHistMixPM = fHistMixPM->Rebin(fBinLimits->GetSize() - 1, "mixPM", fBinLimits->GetArray());
fHistMixPM->Scale(1., "width");
- } else
+ }
+ else
fHistMixPM->Clone("mixPM");
if (fHistMixPM->GetDefaultSumw2()) fHistMixPM->Sumw2();
fHistMixPM->SetDirectory(0);
@@ -746,10 +670,10 @@ void PairAnalysisSignalExt::Process(TObjArray* const arrhist) {
fHistMixMP = (TH1*) FindObject(arrhist, PairAnalysis::EPairType::kMEMP);
if (fHistMixMP) {
if (fBinLimits) {
- fHistMixMP = fHistMixMP->Rebin(
- fBinLimits->GetSize() - 1, "mixMP", fBinLimits->GetArray());
+ fHistMixMP = fHistMixMP->Rebin(fBinLimits->GetSize() - 1, "mixMP", fBinLimits->GetArray());
fHistMixMP->Scale(1., "width");
- } else
+ }
+ else
fHistMixMP->Clone("mixMP");
if (fHistMixMP->GetDefaultSumw2()) fHistMixMP->Sumw2();
fHistMixMP->SetDirectory(0);
@@ -761,10 +685,10 @@ void PairAnalysisSignalExt::Process(TObjArray* const arrhist) {
fHistMixMM = (TH1*) FindObject(arrhist, PairAnalysis::EPairType::kMEMM);
if (fHistMixMM) {
if (fBinLimits) {
- fHistMixMM = fHistMixMM->Rebin(
- fBinLimits->GetSize() - 1, "mixMM", fBinLimits->GetArray());
+ fHistMixMM = fHistMixMM->Rebin(fBinLimits->GetSize() - 1, "mixMM", fBinLimits->GetArray());
fHistMixMM->Scale(1., "width");
- } else
+ }
+ else
fHistMixMM->Clone("mixMM");
if (fHistMixMM->GetDefaultSumw2()) fHistMixMM->Sumw2();
fHistMixMM->SetDirectory(0);
@@ -774,10 +698,10 @@ void PairAnalysisSignalExt::Process(TObjArray* const arrhist) {
fHistDataTR = (TH1*) FindObject(arrhist, PairAnalysis::EPairType::kSEPMRot);
if (fHistDataTR) {
if (fBinLimits) {
- fHistDataTR = fHistDataTR->Rebin(
- fBinLimits->GetSize() - 1, "histTR", fBinLimits->GetArray());
+ fHistDataTR = fHistDataTR->Rebin(fBinLimits->GetSize() - 1, "histTR", fBinLimits->GetArray());
fHistDataTR->Scale(1., "width");
- } else
+ }
+ else
fHistDataTR->Clone("histTR");
if (fHistDataTR->GetDefaultSumw2()) fHistDataTR->Sumw2();
fHistDataTR->SetDirectory(0);
@@ -785,34 +709,25 @@ void PairAnalysisSignalExt::Process(TObjArray* const arrhist) {
}
// init histograms for R-factor, subtracted signal, background
- fHistSignal = new TH1D("HistSignal",
- "Substracted signal",
- fHistDataPM->GetXaxis()->GetNbins(),
+ fHistSignal = new TH1D("HistSignal", "Substracted signal", fHistDataPM->GetXaxis()->GetNbins(),
fHistDataPM->GetXaxis()->GetXbins()->GetArray());
fHistSignal->SetXTitle(fHistDataPM->GetXaxis()->GetTitle());
fHistSignal->SetYTitle(fHistDataPM->GetYaxis()->GetTitle());
if (fHistSignal->GetDefaultSumw2()) fHistSignal->Sumw2();
fHistSignal->SetDirectory(0);
- fHistBackground = new TH1D("HistBackground",
- "Background contribution",
- fHistDataPM->GetXaxis()->GetNbins(),
+ fHistBackground = new TH1D("HistBackground", "Background contribution", fHistDataPM->GetXaxis()->GetNbins(),
fHistDataPM->GetXaxis()->GetXbins()->GetArray());
if (fHistBackground->GetDefaultSumw2()) fHistBackground->Sumw2();
fHistBackground->SetDirectory(0);
- fHistRfactor =
- new TH1D("HistRfactor",
- "Rfactor;;N^{mix}_{+-}/2#sqrt{N^{mix}_{++} N^{mix}_{--}}",
- fHistDataPM->GetXaxis()->GetNbins(),
- fHistDataPM->GetXaxis()->GetXbins()->GetArray());
+ fHistRfactor = new TH1D("HistRfactor", "Rfactor;;N^{mix}_{+-}/2#sqrt{N^{mix}_{++} N^{mix}_{--}}",
+ fHistDataPM->GetXaxis()->GetNbins(), fHistDataPM->GetXaxis()->GetXbins()->GetArray());
if (fHistRfactor->GetDefaultSumw2()) fHistRfactor->Sumw2();
fHistRfactor->SetDirectory(0);
// cocktail
if (fArrCocktail && fArrCocktail->GetEntriesFast()) {
// printf("rebin %d cocktail histograms\n",fArrCocktail->GetEntriesFast());
- fHistCocktail = new TH1D("HistCocktail",
- "Cocktail contribution",
- fHistDataPM->GetXaxis()->GetNbins(),
+ fHistCocktail = new TH1D("HistCocktail", "Cocktail contribution", fHistDataPM->GetXaxis()->GetNbins(),
fHistDataPM->GetXaxis()->GetXbins()->GetArray());
fHistCocktail->SetXTitle(fHistDataPM->GetXaxis()->GetTitle());
fHistCocktail->SetYTitle(fHistDataPM->GetYaxis()->GetTitle());
@@ -823,8 +738,7 @@ void PairAnalysisSignalExt::Process(TObjArray* const arrhist) {
for (Int_t i = 0; i < fArrCocktail->GetEntriesFast(); i++) {
TH1* htmp = static_cast<TH1*>(fArrCocktail->UncheckedAt(i));
if (fBinLimits) {
- htmp = htmp->Rebin(
- fBinLimits->GetSize() - 1, htmp->GetTitle(), fBinLimits->GetArray());
+ htmp = htmp->Rebin(fBinLimits->GetSize() - 1, htmp->GetTitle(), fBinLimits->GetArray());
if (htmp->GetDefaultSumw2()) htmp->Sumw2();
htmp->SetDirectory(0);
htmp->Scale(1., "width");
@@ -873,16 +787,12 @@ void PairAnalysisSignalExt::Process(TObjArray* const arrhist) {
ProcessCocktail();
break;
- default:
- Warning(
- "Process",
- "Subtraction method not supported. Please check SetMethod() function.");
+ default: Warning("Process", "Subtraction method not supported. Please check SetMethod() function.");
}
// set S/B and Significance histos
- if (!fPeakIsTF1)
- fHistSB = (TH1*) fgPeakShape->Clone("histSB");
+ if (!fPeakIsTF1) fHistSB = (TH1*) fgPeakShape->Clone("histSB");
else {
fHistSB = (TH1*) fHistSignal->Clone("histSB");
fHistSB->Reset("CEIS");
@@ -898,8 +808,7 @@ void PairAnalysisSignalExt::Process(TObjArray* const arrhist) {
Double_t b = 0.;
for (Int_t i = 1; i <= fHistSgn->GetNbinsX(); i++) {
- if (!fPeakIsTF1)
- s = static_cast<TH1*>(fgPeakShape)->GetBinContent(i);
+ if (!fPeakIsTF1) s = static_cast<TH1*>(fgPeakShape)->GetBinContent(i);
else
s = static_cast<TF1*>(fgPeakShape)->Eval(fHistSgn->GetBinCenter(i));
b = fHistBackground->GetBinContent(i);
@@ -912,7 +821,8 @@ void PairAnalysisSignalExt::Process(TObjArray* const arrhist) {
}
//______________________________________________
-void PairAnalysisSignalExt::ProcessLS() {
+void PairAnalysisSignalExt::ProcessLS()
+{
//
// signal subtraction suing the like-sign method
//
@@ -933,8 +843,7 @@ void PairAnalysisSignalExt::ProcessLS() {
Float_t background = 2 * TMath::Sqrt(pp * mm);
// Float_t ebackground = TMath::Sqrt(mm+pp); // do not use it since LS could be weighted err!=sqrt(entries)
- Float_t ebackground =
- TMath::Sqrt(mm / pp * ppe * ppe + pp / mm * mme * mme);
+ Float_t ebackground = TMath::Sqrt(mm / pp * ppe * ppe + pp / mm * mme * mme);
// Arithmetic mean instead of geometric
if (fMethod == kLikeSignArithm || fMethod == kLikeSignArithmRcorr) {
background = (pp + mm);
@@ -948,8 +857,7 @@ void PairAnalysisSignalExt::ProcessLS() {
}
//correct LS spectrum bin-by-bin with R factor obtained in mixed events
- if (fMixingCorr || fMethod == kLikeSignRcorr
- || fMethod == kLikeSignArithmRcorr) {
+ if (fMixingCorr || fMethod == kLikeSignRcorr || fMethod == kLikeSignArithmRcorr) {
// protections
if (!fHistMixPM || fHistMixPP || !fHistMixMM) return;
@@ -966,8 +874,7 @@ void PairAnalysisSignalExt::ProcessLS() {
Float_t background = 2 * TMath::Sqrt(pp * mm);
// do not use it since ME could be weighted err!=sqrt(entries)
// Float_t ebackground = TMath::Sqrt(mm+pp);
- Float_t ebackground =
- TMath::Sqrt(mm / pp * ppe * ppe + pp / mm * mme * mme);
+ Float_t ebackground = TMath::Sqrt(mm / pp * ppe * ppe + pp / mm * mme * mme);
//Arithmetic mean instead of geometric
if (fMethod == kLikeSignArithm) {
background = (pp + mm);
@@ -980,8 +887,7 @@ void PairAnalysisSignalExt::ProcessLS() {
if (background > 0.0) {
rcon = pm / background;
rerr = TMath::Sqrt((1. / background) * (1. / background) * pme * pme
- + (pm / (background * background))
- * (pm / (background * background)) * ebackground
+ + (pm / (background * background)) * (pm / (background * background)) * ebackground
* ebackground);
}
fHistRfactor->SetBinContent(ibin, rcon);
@@ -1004,9 +910,7 @@ void PairAnalysisSignalExt::ProcessLS() {
// background
fValues(1) =
- fHistBackground->IntegralAndError(fHistBackground->FindBin(fIntMin),
- fHistBackground->FindBin(fIntMax),
- fErrors(1));
+ fHistBackground->IntegralAndError(fHistBackground->FindBin(fIntMin), fHistBackground->FindBin(fIntMax), fErrors(1));
// signal depending on peak description method
DescribePeakShape(fPeakMethod, kTRUE, fgHistSimPM);
@@ -1017,7 +921,8 @@ void PairAnalysisSignalExt::ProcessLS() {
}
//______________________________________________
-void PairAnalysisSignalExt::ProcessEM() {
+void PairAnalysisSignalExt::ProcessEM()
+{
//
// signal subtraction using event mixing (+-,-+) method
//
@@ -1056,9 +961,7 @@ void PairAnalysisSignalExt::ProcessEM() {
// background
fValues(1) =
- fHistBackground->IntegralAndError(fHistBackground->FindBin(fIntMin),
- fHistBackground->FindBin(fIntMax),
- fErrors(1));
+ fHistBackground->IntegralAndError(fHistBackground->FindBin(fIntMin), fHistBackground->FindBin(fIntMax), fErrors(1));
// signal depending on peak description method
DescribePeakShape(fPeakMethod, kTRUE, fgHistSimPM);
@@ -1067,7 +970,8 @@ void PairAnalysisSignalExt::ProcessEM() {
}
//______________________________________________
-void PairAnalysisSignalExt::ProcessTR() {
+void PairAnalysisSignalExt::ProcessTR()
+{
//
// signal subtraction using the track-rotation method
//
@@ -1106,9 +1010,7 @@ void PairAnalysisSignalExt::ProcessTR() {
// background
fValues(1) =
- fHistBackground->IntegralAndError(fHistBackground->FindBin(fIntMin),
- fHistBackground->FindBin(fIntMax),
- fErrors(1));
+ fHistBackground->IntegralAndError(fHistBackground->FindBin(fIntMin), fHistBackground->FindBin(fIntMax), fErrors(1));
// signal depending on peak description method
DescribePeakShape(fPeakMethod, kTRUE, fgHistSimPM);
@@ -1117,7 +1019,8 @@ void PairAnalysisSignalExt::ProcessTR() {
}
//______________________________________________
-void PairAnalysisSignalExt::ProcessCocktail() {
+void PairAnalysisSignalExt::ProcessCocktail()
+{
//
// signal subtraction using the cocktail method
//
@@ -1140,9 +1043,7 @@ void PairAnalysisSignalExt::ProcessCocktail() {
// background
fValues(1) =
- fHistBackground->IntegralAndError(fHistBackground->FindBin(fIntMin),
- fHistBackground->FindBin(fIntMax),
- fErrors(1));
+ fHistBackground->IntegralAndError(fHistBackground->FindBin(fIntMin), fHistBackground->FindBin(fIntMax), fErrors(1));
// signal depending on peak description method
DescribePeakShape(fPeakMethod, kTRUE, fgHistSimPM);
@@ -1151,7 +1052,8 @@ void PairAnalysisSignalExt::ProcessCocktail() {
}
//______________________________________________
-void PairAnalysisSignalExt::Draw(const Option_t* option) {
+void PairAnalysisSignalExt::Draw(const Option_t* option)
+{
///
/// Draw signal extraction histograms into a canvas
///
@@ -1175,13 +1077,10 @@ void PairAnalysisSignalExt::Draw(const Option_t* option) {
/// "sb": calculates and plots the signal-over-background ratio instead of counts
/// "sgn": calculates and plots the significance instead of counts
- Info("Draw",
- "Signal extraction results for '%s'",
- fgkBackgroundMethodNames[fMethod]);
+ Info("Draw", "Signal extraction results for '%s'", fgkBackgroundMethodNames[fMethod]);
TString optString(option);
optString.ToLower();
- printf("Plot extraction: bgrd. estimator: '%s' \t options: '%s' \n",
- fgkBackgroundMethodNames[fMethod],
+ printf("Plot extraction: bgrd. estimator: '%s' \t options: '%s' \n", fgkBackgroundMethodNames[fMethod],
optString.Data());
Bool_t optTask = optString.Contains("same");
optString.ReplaceAll("same", "");
@@ -1226,10 +1125,8 @@ void PairAnalysisSignalExt::Draw(const Option_t* option) {
/// add canvas
TCanvas* c = 0;
if (optCan) {
- TString key =
- Form("cSignalExtraction%s",
- (optSB ? "SB" : (optSgn ? "SGN" : (optSSB ? "SSB" : ""))));
- c = (TCanvas*) gROOT->FindObject(key.Data());
+ TString key = Form("cSignalExtraction%s", (optSB ? "SB" : (optSgn ? "SGN" : (optSSB ? "SSB" : ""))));
+ c = (TCanvas*) gROOT->FindObject(key.Data());
if (!c) c = new TCanvas(key.Data(), key.Data());
// c->Clear();
c->cd();
@@ -1247,14 +1144,11 @@ void PairAnalysisSignalExt::Draw(const Option_t* option) {
// add or get legend
TLegend* leg = 0;
if ((optLeg && optTask && !nobj) || (optLeg && !optTask)) {
- leg = new TLegend(.75,
- .3,
- 1. - gPad->GetTopMargin() - gStyle->GetTickLength("X"),
- 1. - gPad->GetRightMargin() - gStyle->GetTickLength("Y"),
- fArrHists->GetName(),
- "nbNDC");
+ leg = new TLegend(.75, .3, 1. - gPad->GetTopMargin() - gStyle->GetTickLength("X"),
+ 1. - gPad->GetRightMargin() - gStyle->GetTickLength("Y"), fArrHists->GetName(), "nbNDC");
if (optTask) leg->SetHeader("");
- } else if (optLeg && nobj) {
+ }
+ else if (optLeg && nobj) {
leg = (TLegend*) prim->FindObject("TPave");
}
@@ -1267,8 +1161,7 @@ void PairAnalysisSignalExt::Draw(const Option_t* option) {
optString.ReplaceAll("logz", "");
/// error style
- if (optString.Contains("e2") || optString.Contains("e3")
- || optString.Contains("e4")) {
+ if (optString.Contains("e2") || optString.Contains("e3") || optString.Contains("e4")) {
// printf("set x-error style \n");
gStyle->SetErrorX(0.5);
// PairAnalysisStyler::SetForceFillStyle(1);
@@ -1289,42 +1182,35 @@ void PairAnalysisSignalExt::Draw(const Option_t* option) {
// styling
fHistDataPM->SetNameTitle(Form("unlike-sign%s", GetName()), "unlike-sign");
fHistDataPM->UseCurrentStyle();
- PairAnalysisStyler::Style(fHistDataPM,
- static_cast<Int_t>(PairAnalysisStyler::Eidx::kRaw));
+ PairAnalysisStyler::Style(fHistDataPM, static_cast<Int_t>(PairAnalysisStyler::Eidx::kRaw));
if (fPlotMin != fPlotMax) fHistDataPM->SetAxisRange(fPlotMin, fPlotMax, "X");
- fHistBackground->SetNameTitle(fgkBackgroundMethodNames[fMethod],
- fgkBackgroundMethodNames[fMethod]);
+ fHistBackground->SetNameTitle(fgkBackgroundMethodNames[fMethod], fgkBackgroundMethodNames[fMethod]);
fHistBackground->UseCurrentStyle();
- PairAnalysisStyler::Style(
- fHistBackground, static_cast<Int_t>(PairAnalysisStyler::Eidx::kBgrd));
+ PairAnalysisStyler::Style(fHistBackground, static_cast<Int_t>(PairAnalysisStyler::Eidx::kBgrd));
fHistSignal->SetNameTitle(Form("signal%s", GetName()), "signal");
fHistSignal->UseCurrentStyle();
- PairAnalysisStyler::Style(fHistSignal,
- static_cast<Int_t>(PairAnalysisStyler::Eidx::kSig));
+ PairAnalysisStyler::Style(fHistSignal, static_cast<Int_t>(PairAnalysisStyler::Eidx::kSig));
if (fPlotMin != fPlotMax) fHistSignal->SetAxisRange(fPlotMin, fPlotMax, "X");
if (fHistCocktail) {
fHistCocktail->SetNameTitle(Form("cocktail%s", GetName()), "cocktail");
fHistCocktail->UseCurrentStyle();
- PairAnalysisStyler::Style(
- fHistCocktail, static_cast<Int_t>(PairAnalysisStyler::Eidx::kCocktail));
- if (fPlotMin != fPlotMax)
- fHistCocktail->SetAxisRange(fPlotMin, fPlotMax, "X");
+ PairAnalysisStyler::Style(fHistCocktail, static_cast<Int_t>(PairAnalysisStyler::Eidx::kCocktail));
+ if (fPlotMin != fPlotMax) fHistCocktail->SetAxisRange(fPlotMin, fPlotMax, "X");
}
if (optSB) {
fHistSB->SetNameTitle(Form("s2b%s", GetName()), "signal");
fHistSB->UseCurrentStyle();
- PairAnalysisStyler::Style(
- fHistSB, static_cast<Int_t>(PairAnalysisStyler::Eidx::kSig));
+ PairAnalysisStyler::Style(fHistSB, static_cast<Int_t>(PairAnalysisStyler::Eidx::kSig));
if (fPlotMin != fPlotMax) fHistSB->SetAxisRange(fPlotMin, fPlotMax, "X");
- } else if (optSgn) {
+ }
+ else if (optSgn) {
fHistSgn->SetNameTitle(Form("sgn%s", GetName()), "signal");
fHistSgn->UseCurrentStyle();
- PairAnalysisStyler::Style(
- fHistSgn, static_cast<Int_t>(PairAnalysisStyler::Eidx::kSig));
+ PairAnalysisStyler::Style(fHistSgn, static_cast<Int_t>(PairAnalysisStyler::Eidx::kSig));
if (fPlotMin != fPlotMax) fHistSgn->SetAxisRange(fPlotMin, fPlotMax, "X");
}
@@ -1334,8 +1220,7 @@ void PairAnalysisSignalExt::Draw(const Option_t* option) {
fgPeakShape->UseCurrentStyle();
// fgPeakShape->SetTitle("");
- PairAnalysisStyler::Style(fgPeakShape,
- static_cast<Int_t>(PairAnalysisStyler::Eidx::kFit));
+ PairAnalysisStyler::Style(fgPeakShape, static_cast<Int_t>(PairAnalysisStyler::Eidx::kFit));
// draw stuff
if (c) c->cd(1);
@@ -1347,10 +1232,12 @@ void PairAnalysisSignalExt::Draw(const Option_t* option) {
if (optSB && !optOnlyRaw && !optNoSig) {
fHistSB->Draw(i > 0 ? (drawOpt + "same").Data() : drawOpt.Data());
i++;
- } else if (optSgn && !optOnlyRaw && !optNoSig) {
+ }
+ else if (optSgn && !optOnlyRaw && !optNoSig) {
fHistSgn->Draw(i > 0 ? (drawOpt + "same").Data() : drawOpt.Data());
i++;
- } else if (optOnlySig) {
+ }
+ else if (optOnlySig) {
drawOpt = (optString.IsNull() ? "EP0" : optString);
fHistSignal->DrawCopy(i > 0 ? (drawOpt + "same").Data() : drawOpt.Data());
i++;
@@ -1359,21 +1246,19 @@ void PairAnalysisSignalExt::Draw(const Option_t* option) {
static_cast<TF1*>(fgPeakShape)->DrawCopy(drawOpt.Data());
i++;
}
- } else if (!optSB && !optSgn) {
+ }
+ else if (!optSB && !optSgn) {
fHistDataPM->DrawCopy(i > 0 ? (drawOpt + "same").Data() : drawOpt.Data());
i++;
- if (fMethod == kRotation || fMethod == kEventMixing
- || fMethod == kCocktail)
+ if (fMethod == kRotation || fMethod == kEventMixing || fMethod == kCocktail)
drawOpt = (optString.IsNull() ? "HIST" : optString);
if (!optNoBgrd) {
- fHistBackground->DrawCopy(i > 0 ? (drawOpt + "same").Data()
- : drawOpt.Data());
+ fHistBackground->DrawCopy(i > 0 ? (drawOpt + "same").Data() : drawOpt.Data());
i++;
}
if (!optOnlyRaw && !optNoSig) {
drawOpt = (optString.IsNull() ? "EP0" : optString);
- fHistSignal->DrawCopy(i > 0 ? (drawOpt + "same").Data()
- : drawOpt.Data());
+ fHistSignal->DrawCopy(i > 0 ? (drawOpt + "same").Data() : drawOpt.Data());
i++;
drawOpt = (optString.IsNull() ? "L same" : optString + "same");
if (fPeakIsTF1) {
@@ -1393,11 +1278,8 @@ void PairAnalysisSignalExt::Draw(const Option_t* option) {
fHistCocktail->Divide(fHistBackground);
fHistCocktail->SetYTitle(Form("%s", GetValueName(3)));
}
- if (optSgn) {
- FillSignificance(fHistCocktail, fHistCocktail, fHistBackground);
- }
- fHistCocktail->DrawCopy(i > 0 ? (drawOpt + "same").Data()
- : drawOpt.Data());
+ if (optSgn) { FillSignificance(fHistCocktail, fHistCocktail, fHistBackground); }
+ fHistCocktail->DrawCopy(i > 0 ? (drawOpt + "same").Data() : drawOpt.Data());
i++; //TODO: needed?
// fHistCocktail->DrawCopy((drawOpt+"same").Data()); i++;
}
@@ -1414,11 +1296,8 @@ void PairAnalysisSignalExt::Draw(const Option_t* option) {
TString tit = hmc->GetTitle();
if (key.CountChar('_') != 1) continue; // only reconstr. MC signals
// remove cocktail subtracted signals
- if (optOnlySig && fCocktailSubtr
- && FindObjectByTitle(fArrCocktail, key))
- continue;
- else if (optOnlySig && !fCocktailSubtr && fArrCocktail
- && !FindObjectByTitle(fArrCocktail, key))
+ if (optOnlySig && fCocktailSubtr && FindObjectByTitle(fArrCocktail, key)) continue;
+ else if (optOnlySig && !fCocktailSubtr && fArrCocktail && !FindObjectByTitle(fArrCocktail, key))
continue;
else if (optCocktail && FindObjectByTitle(fArrCocktail, key))
continue;
@@ -1426,8 +1305,7 @@ void PairAnalysisSignalExt::Draw(const Option_t* option) {
// check if rebinning is necessary
if (1 && fHistSignal->GetNbinsX() != hmc->GetNbinsX()) {
if (fBinLimits) {
- hmc = hmc->Rebin(
- fBinLimits->GetSize() - 1, key.Data(), fBinLimits->GetArray());
+ hmc = hmc->Rebin(fBinLimits->GetSize() - 1, key.Data(), fBinLimits->GetArray());
hmc->SetTitle(tit.Data());
hmc->Scale(1., "width");
}
@@ -1456,10 +1334,9 @@ void PairAnalysisSignalExt::Draw(const Option_t* option) {
// TObject *obj;
while ((obj = nextObj())) {
if (obj->InheritsFrom(TH1::Class())) {
- TH1* hobj = static_cast<TH1*>(obj);
- max = TMath::Max(
- max,
- PairAnalysisHelper::GetContentMaximum(hobj)); //hobj->GetMaximum();
+ TH1* hobj = static_cast<TH1*>(obj);
+ max = TMath::Max(max,
+ PairAnalysisHelper::GetContentMaximum(hobj)); //hobj->GetMaximum();
Double_t tmpmax = max * (gPad->GetLogy() ? 5. : 1.1);
hobj->SetMaximum(tmpmax);
@@ -1473,8 +1350,7 @@ void PairAnalysisSignalExt::Draw(const Option_t* option) {
// hobj->GetTitle(),tmpmax,tmpmin, tmpmax/(tmpmin>0.?tmpmin:1.),TMath::Power(10.,TGaxis::GetMaxDigits()));
// automatically set log option
if (gPad->GetLogy()
- && (tmpmax / (tmpmin > 0. ? tmpmin : 1.)
- > TMath::Power(10., TGaxis::GetMaxDigits())
+ && (tmpmax / (tmpmin > 0. ? tmpmin : 1.) > TMath::Power(10., TGaxis::GetMaxDigits())
|| tmpmin < TMath::Power(10., -TGaxis::GetMaxDigits()))) {
hobj->GetYaxis()->SetMoreLogLabels(kFALSE);
hobj->GetYaxis()->SetNoExponent(kFALSE);
@@ -1501,11 +1377,8 @@ void PairAnalysisSignalExt::Draw(const Option_t* option) {
histClass.ReplaceAll("Pair.", "");
histClass.ReplaceAll("Pair_", "");
// change default signal names to titles
- for (Int_t isig = 0; isig < static_cast<Int_t>(
- PairAnalysisSignalMC::EDefinedSignal::kNSignals);
- isig++) {
- histClass.ReplaceAll(PairAnalysisSignalMC::fgkSignals[isig][0],
- PairAnalysisSignalMC::fgkSignals[isig][1]);
+ for (Int_t isig = 0; isig < static_cast<Int_t>(PairAnalysisSignalMC::EDefinedSignal::kNSignals); isig++) {
+ histClass.ReplaceAll(PairAnalysisSignalMC::fgkSignals[isig][0], PairAnalysisSignalMC::fgkSignals[isig][1]);
}
// remove trailing and leading spaces
histClass.Remove(TString::kBoth, ' ');
@@ -1524,8 +1397,7 @@ void PairAnalysisSignalExt::Draw(const Option_t* option) {
legOpt.ReplaceAll("text", "");
legOpt.ReplaceAll("e", "");
// Printf("hist %s legopt %s",histClass.Data(),legOpt.Data());
- if (ileg == nobj && optTask)
- leg->AddEntry((TObject*) 0x0, fArrHists->GetName(), "");
+ if (ileg == nobj && optTask) leg->AddEntry((TObject*) 0x0, fArrHists->GetName(), "");
leg->AddEntry(obj, histClass.Data(), legOpt.Data());
ileg++;
}
@@ -1547,8 +1419,7 @@ void PairAnalysisSignalExt::Draw(const Option_t* option) {
// draw statistics box
if (optStat)
- DrawStats(0.7,
- gPad->GetBottomMargin() + gStyle->GetTickLength("Y"),
+ DrawStats(0.7, gPad->GetBottomMargin() + gStyle->GetTickLength("Y"),
1. - gPad->GetRightMargin() - gStyle->GetTickLength("X"),
gPad->GetBottomMargin() + gStyle->GetTickLength("Y") + 5 * 0.025);
@@ -1557,7 +1428,8 @@ void PairAnalysisSignalExt::Draw(const Option_t* option) {
// gPad->RedrawAxis();
}
-void PairAnalysisSignalExt::ScaleBackground() {
+void PairAnalysisSignalExt::ScaleBackground()
+{
//
// scale histograms according to method and integral limits
//
@@ -1573,15 +1445,9 @@ void PairAnalysisSignalExt::ScaleBackground() {
default: scalingRef = nullptr; break;
}
if (fScaleMax > fScaleMin && fScaleMax2 > fScaleMin2)
- fScaleFactor = ScaleHistograms(scalingRef,
- fHistBackground,
- fScaleMin,
- fScaleMax,
- fScaleMin2,
- fScaleMax2);
+ fScaleFactor = ScaleHistograms(scalingRef, fHistBackground, fScaleMin, fScaleMax, fScaleMin2, fScaleMax2);
else if (fScaleMax > fScaleMin)
- fScaleFactor =
- ScaleHistograms(scalingRef, fHistBackground, fScaleMin, fScaleMax);
+ fScaleFactor = ScaleHistograms(scalingRef, fHistBackground, fScaleMin, fScaleMax);
else if (fScaleMin > 0.) {
fScaleFactor = fScaleMin;
fHistBackground->Scale(fScaleFactor);
diff --git a/analysis/PWGDIL/dielectron/papaframework/PairAnalysisSignalExt.h b/analysis/PWGDIL/dielectron/papaframework/PairAnalysisSignalExt.h
index 7c5707eaaf7bd0a84e385c3b47f972f3b8f0d772..80213d2f93da9f994d0cf6c153cf531c06e821d8 100644
--- a/analysis/PWGDIL/dielectron/papaframework/PairAnalysisSignalExt.h
+++ b/analysis/PWGDIL/dielectron/papaframework/PairAnalysisSignalExt.h
@@ -25,7 +25,8 @@ class TPaveText;
class PairAnalysisSignalExt : public PairAnalysisFunction {
public:
- enum EBackgroundMethod {
+ enum EBackgroundMethod
+ {
kFittedMC = 0,
kFitted,
kLikeSign,
@@ -39,7 +40,8 @@ public:
kCocktail
};
- enum ESignalExtractionMethod {
+ enum ESignalExtractionMethod
+ {
kBinCounting = 0,
kMCScaledMax,
kMCScaledInt,
@@ -49,7 +51,11 @@ public:
kUserFunc
};
- enum EScalingMethod { kSclToRaw = 0, kSclToLikeSign };
+ enum EScalingMethod
+ {
+ kSclToRaw = 0,
+ kSclToLikeSign
+ };
PairAnalysisSignalExt();
PairAnalysisSignalExt(const char* name, const char* title);
@@ -59,26 +65,27 @@ public:
//// Setter ////
// signal
- void SetMCSignalShape(TH1F* hist) {
+ void SetMCSignalShape(TH1F* hist)
+ {
fgHistSimPM = hist;
fHistSignalMC = hist;
}
- void SetIntegralRange(Double_t min, Double_t max) {
+ void SetIntegralRange(Double_t min, Double_t max)
+ {
fIntMin = min;
fIntMax = max;
}
- void SetPlotRange(Double_t min, Double_t max) {
+ void SetPlotRange(Double_t min, Double_t max)
+ {
fPlotMin = min;
fPlotMax = max;
}
void SetRebin(Int_t factor) { fRebin = factor; }
void SetStatRebin(Double_t stat) { fRebinStat = stat; }
void SetRebin(TArrayD* limits) { fBinLimits = limits; }
- void SetRebin(TVectorD* limits) {
- fBinLimits = new TArrayD(limits->GetNrows() - 1, limits->GetMatrixArray());
- }
- void SetExtractionMethod(ESignalExtractionMethod method,
- PairAnalysisFunction* sigF = 0x0) {
+ void SetRebin(TVectorD* limits) { fBinLimits = new TArrayD(limits->GetNrows() - 1, limits->GetMatrixArray()); }
+ void SetExtractionMethod(ESignalExtractionMethod method, PairAnalysisFunction* sigF = 0x0)
+ {
fPeakMethod = method;
fExtrFunc = sigF;
}
@@ -88,18 +95,17 @@ public:
void SetMethod(EBackgroundMethod method) { fMethod = method; }
void SetNTrackRotations(Int_t iterations) { fNiterTR = iterations; }
- void SetScaleBackgroundTo(EScalingMethod method,
- Double_t intMin,
- Double_t intMax,
- Double_t intMin2 = 0.,
- Double_t intMax2 = 0.) {
+ void SetScaleBackgroundTo(EScalingMethod method, Double_t intMin, Double_t intMax, Double_t intMin2 = 0.,
+ Double_t intMax2 = 0.)
+ {
fSclMethod = method;
fScaleMin = intMin;
fScaleMax = intMax;
fScaleMin2 = intMin2;
fScaleMax2 = intMax2;
}
- void SetCocktailContribution(TObjArray* arr, Bool_t subtract = kTRUE) {
+ void SetCocktailContribution(TObjArray* arr, Bool_t subtract = kTRUE)
+ {
fArrCocktail = arr;
fCocktailSubtr = subtract;
}
@@ -137,9 +143,7 @@ public:
Double_t GetMassWidthError() const { return fErrors(5); }
Double_t GetMatchChi2NDF() const { return fValues(6); }
Double_t GetMatchChi2NDFError() const { return fErrors(6); }
- static const char* GetValueName(Int_t i) {
- return (i >= 0 && i < 7) ? fgkValueNames[i] : "";
- }
+ static const char* GetValueName(Int_t i) { return (i >= 0 && i < 7) ? fgkValueNames[i] : ""; }
// objects
@@ -154,23 +158,12 @@ public:
TObject* GetPeakShape() const { return fgPeakShape; }
- TObject* DescribePeakShape(ESignalExtractionMethod method = kMCFitted,
- Bool_t replaceValErr = kFALSE,
- TH1F* mcShape = 0x0);
- TPaveText* DrawStats(Double_t x1 = 0.,
- Double_t y1 = 0.,
- Double_t x2 = 0.,
- Double_t y2 = 0.,
+ TObject* DescribePeakShape(ESignalExtractionMethod method = kMCFitted, Bool_t replaceValErr = kFALSE,
+ TH1F* mcShape = 0x0);
+ TPaveText* DrawStats(Double_t x1 = 0., Double_t y1 = 0., Double_t x2 = 0., Double_t y2 = 0.,
TString opt = "pRnbsSmrc");
- Double_t ScaleHistograms(TH1* histRaw,
- TH1* histBackground,
- Double_t intMin,
- Double_t intMax);
- Double_t ScaleHistograms(TH1* histRaw,
- TH1* histBackground,
- Double_t intMin,
- Double_t intMax,
- Double_t intMin2,
+ Double_t ScaleHistograms(TH1* histRaw, TH1* histBackground, Double_t intMin, Double_t intMax);
+ Double_t ScaleHistograms(TH1* histRaw, TH1* histBackground, Double_t intMin, Double_t intMax, Double_t intMin2,
Double_t intMax2);
static TH1* MergeObjects(TH1* obj1, TH1* obj2, Double_t val = +1.);
@@ -197,11 +190,13 @@ public:
TObject* FindObjectByTitle(TObjArray* arrhist, TString ref);
// implemented to remove warnings
- TObject* FindObject(const char*) const {
+ TObject* FindObject(const char*) const
+ {
TObject* bla = new TObject();
return bla;
}
- TObject* FindObject(const TObject*) const {
+ TObject* FindObject(const TObject*) const
+ {
TObject* bla = new TObject();
return bla;
}
@@ -212,16 +207,14 @@ protected:
TH1* fHistSignal = NULL; // histogram of pure signal
TH1* fHistSB = NULL; // histogram of signal to bgrd
TH1* fHistSgn = NULL; // histogram of significance
- TH1* fHistBackground =
- NULL; // histogram of background (fitted=0, like-sign=1, event mixing=2)
- TH1* fHistCocktail = NULL; // histogram of cocktail
- TH1* fHistDataPM = NULL; // histogram of selected +- pair candidates
- TH1* fHistDataPP = NULL; // histogram of selected ++ pair candidates
- TH1* fHistDataMM = NULL; // histogram of selected -- pair candidates
- TH1* fHistDataME =
- NULL; // histogram of selected +- pair candidates from mixed event
- TH1* fHistRfactor = NULL; // histogram of R factors
- TH1* fHistSignalMC = NULL; // histogram of signal MC shape
+ TH1* fHistBackground = NULL; // histogram of background (fitted=0, like-sign=1, event mixing=2)
+ TH1* fHistCocktail = NULL; // histogram of cocktail
+ TH1* fHistDataPM = NULL; // histogram of selected +- pair candidates
+ TH1* fHistDataPP = NULL; // histogram of selected ++ pair candidates
+ TH1* fHistDataMM = NULL; // histogram of selected -- pair candidates
+ TH1* fHistDataME = NULL; // histogram of selected +- pair candidates from mixed event
+ TH1* fHistRfactor = NULL; // histogram of R factors
+ TH1* fHistSignalMC = NULL; // histogram of signal MC shape
TH1* fHistMixPM = NULL; // histogram of selected +- pair candidates
TH1* fHistMixPP = NULL; // histogram of selected ++ pair candidates
@@ -248,19 +241,15 @@ protected:
Double_t fScaleMax = 0.; // max for scaling
Double_t fScaleMin2 = 0.; // min2 for scaling
Double_t fScaleMax2 = 0.; // max2 for scaling
- Int_t fNiterTR =
- 1; // track rotation scale factor according to number of rotations
- Double_t fScaleFactor = 1.; // scale factor of histogram scaling
- Bool_t fMixingCorr =
- kFALSE; // switch for bin by bin correction with R factor
- Bool_t fCocktailSubtr = kFALSE; // switch for cocktail subtraction
-
- PairAnalysisFunction* fExtrFunc = NULL; // signal extraction function
- ESignalExtractionMethod fPeakMethod =
- kBinCounting; // method for peak description and signal extraction
- static TObject*
- fgPeakShape; // histogram or function used to describe the extracted signal
- Bool_t fPeakIsTF1 = kFALSE; // flag
+ Int_t fNiterTR = 1; // track rotation scale factor according to number of rotations
+ Double_t fScaleFactor = 1.; // scale factor of histogram scaling
+ Bool_t fMixingCorr = kFALSE; // switch for bin by bin correction with R factor
+ Bool_t fCocktailSubtr = kFALSE; // switch for cocktail subtraction
+
+ PairAnalysisFunction* fExtrFunc = NULL; // signal extraction function
+ ESignalExtractionMethod fPeakMethod = kBinCounting; // method for peak description and signal extraction
+ static TObject* fgPeakShape; // histogram or function used to describe the extracted signal
+ Bool_t fPeakIsTF1 = kFALSE; // flag
Bool_t fProcessed = kFALSE; // flag
static TH1F* fgHistSimPM; // simulated peak shape
@@ -269,9 +258,8 @@ protected:
void SetSignificanceAndSOB(); // calculate the significance and S/B
void SetFWHM(); // calculate the fwhm
- static const char* fgkValueNames[7]; //value names
- static const char*
- fgkBackgroundMethodNames[11]; // background estimator names
+ static const char* fgkValueNames[7]; //value names
+ static const char* fgkBackgroundMethodNames[11]; // background estimator names
PairAnalysisSignalExt(const PairAnalysisSignalExt& c);
PairAnalysisSignalExt& operator=(const PairAnalysisSignalExt& c);
@@ -279,25 +267,22 @@ protected:
ClassDef(PairAnalysisSignalExt, 3) // Class for signal extraction
};
-inline TObject*
-PairAnalysisSignalExt::FindObject(TObjArray* arrhist,
- PairAnalysis::EPairType type) const {
+inline TObject* PairAnalysisSignalExt::FindObject(TObjArray* arrhist, PairAnalysis::EPairType type) const
+{
//
// shortcut to find a certain pair type object in array
//
// return ( arrhist->FindObject(Form("Pair.%s",PairAnalysis::PairClassName(type))) );
- TString ref =
- Form("Pair.%s", PairAnalysis::PairClassName(static_cast<Int_t>(type)));
+ TString ref = Form("Pair.%s", PairAnalysis::PairClassName(static_cast<Int_t>(type)));
for (Int_t i = 0; i < arrhist->GetEntriesFast(); i++) {
- if (!ref.CompareTo(arrhist->UncheckedAt(i)->GetTitle()))
- return arrhist->UncheckedAt(i);
+ if (!ref.CompareTo(arrhist->UncheckedAt(i)->GetTitle())) return arrhist->UncheckedAt(i);
}
return 0x0;
}
-inline TObject* PairAnalysisSignalExt::FindObjectByTitle(TObjArray* arrhist,
- TString ref) {
+inline TObject* PairAnalysisSignalExt::FindObjectByTitle(TObjArray* arrhist, TString ref)
+{
//
// shortcut to find a certain pair type object in array
//
@@ -305,14 +290,13 @@ inline TObject* PairAnalysisSignalExt::FindObjectByTitle(TObjArray* arrhist,
// return ( arrhist->FindObject(Form("Pair.%s",PairAnalysis::PairClassName(type))) );
// TString ref=Form("Pair.%s",PairAnalysis::PairClassName(type));
for (Int_t i = 0; i < arrhist->GetEntriesFast(); i++) {
- if (!ref.CompareTo(arrhist->UncheckedAt(i)->GetTitle())) {
- return arrhist->UncheckedAt(i);
- }
+ if (!ref.CompareTo(arrhist->UncheckedAt(i)->GetTitle())) { return arrhist->UncheckedAt(i); }
}
return 0x0;
}
-inline void PairAnalysisSignalExt::SetSignificanceAndSOB() {
+inline void PairAnalysisSignalExt::SetSignificanceAndSOB()
+{
//
// Calculate S/B and significance
//
@@ -321,25 +305,20 @@ inline void PairAnalysisSignalExt::SetSignificanceAndSOB() {
fValues(3) = (fValues(1) > 0 ? fValues(0) / fValues(1) : 0);
Float_t epsSig = (fValues(0) > 0 ? fErrors(0) / fValues(0) : 0);
Float_t epsBknd = (fValues(1) > 0 ? fErrors(1) / fValues(1) : 0);
- fErrors(3) = fValues(3) * TMath::Sqrt(epsSig * epsSig + epsBknd * epsBknd);
+ fErrors(3) = fValues(3) * TMath::Sqrt(epsSig * epsSig + epsBknd * epsBknd);
// Significance
- fValues(2) = ((fValues(0) + fValues(1)) > 0
- ? fValues(0) / TMath::Sqrt(fValues(0) + fValues(1))
- : 0);
+ fValues(2) = ((fValues(0) + fValues(1)) > 0 ? fValues(0) / TMath::Sqrt(fValues(0) + fValues(1)) : 0);
Float_t s = (fValues(0) > 0 ? fValues(0) : 0);
Float_t b = fValues(1);
Float_t se = fErrors(0);
Float_t be = fErrors(1);
// fErrors(2) = ((s+b)>0 ? TMath::Sqrt((s*(s+2*b)*(s+2*b)+b*s*s)/(4*TMath::Power(s+b,3))) : 0); // old implementation
fErrors(2) =
- ((s + b) > 0
- ? fValues(2)
- * TMath::Sqrt(be * be + TMath::Power(se * (s + 2 * b) / s, 2)) / 2
- / (s + b)
- : 0);
+ ((s + b) > 0 ? fValues(2) * TMath::Sqrt(be * be + TMath::Power(se * (s + 2 * b) / s, 2)) / 2 / (s + b) : 0);
}
-inline void PairAnalysisSignalExt::SetFWHM() {
+inline void PairAnalysisSignalExt::SetFWHM()
+{
//
// calculate the full width at half maximum (fwhm)
//
@@ -373,7 +352,8 @@ inline void PairAnalysisSignalExt::SetFWHM() {
delete fit;
delete pfit;
delete mfit;
- } else if (fgPeakShape->IsA() == TH1F::Class()) {
+ }
+ else if (fgPeakShape->IsA() == TH1F::Class()) {
// th1 calculation
TH1F* hist = (TH1F*) fgPeakShape->Clone("hist");
Int_t bin1 = hist->FindFirstBinAbove(hist->GetMaximum() / 2);
@@ -384,9 +364,8 @@ inline void PairAnalysisSignalExt::SetFWHM() {
}
}
-inline void PairAnalysisSignalExt::FillSignificance(TH1* hfill,
- TObject* signal,
- TH1* hbgrd) {
+inline void PairAnalysisSignalExt::FillSignificance(TH1* hfill, TObject* signal, TH1* hbgrd)
+{
///
/// fill significance histogram
///
@@ -402,8 +381,7 @@ inline void PairAnalysisSignalExt::FillSignificance(TH1* hfill,
Double_t be = 0.;
for (Int_t i = 1; i <= hfill->GetNbinsX(); i++) {
- if (signal->IsA() == TF1::Class())
- s = static_cast<TF1*>(signal)->Eval(hfill->GetBinCenter(i));
+ if (signal->IsA() == TF1::Class()) s = static_cast<TF1*>(signal)->Eval(hfill->GetBinCenter(i));
else {
s = static_cast<TH1*>(signal)->GetBinContent(i);
se = static_cast<TH1*>(signal)->GetBinError(i);
@@ -416,11 +394,7 @@ inline void PairAnalysisSignalExt::FillSignificance(TH1* hfill,
// printf("s %.3e b %.3e \t s/b: %.3e sgn %.3e \n",s,b,s/b,sgn);
hfill->SetBinContent(i, sgn);
hfill->SetBinError(
- i,
- ((s + b) > 0.
- ? sgn * TMath::Sqrt(be * be + TMath::Power(se * (s + 2 * b) / s, 2))
- / 2 / (s + b)
- : 0));
+ i, ((s + b) > 0. ? sgn * TMath::Sqrt(be * be + TMath::Power(se * (s + 2 * b) / s, 2)) / 2 / (s + b) : 0));
}
}
diff --git a/analysis/PWGDIL/dielectron/papaframework/PairAnalysisSignalFit.cxx b/analysis/PWGDIL/dielectron/papaframework/PairAnalysisSignalFit.cxx
index fe458215b2cd605e2aa8f654781072e3b89f7390..e877a8251cd36d74a54578545797c02e283b650e 100644
--- a/analysis/PWGDIL/dielectron/papaframework/PairAnalysisSignalFit.cxx
+++ b/analysis/PWGDIL/dielectron/papaframework/PairAnalysisSignalFit.cxx
@@ -121,8 +121,7 @@ ClassImp(PairAnalysisSignalFit)
}
//______________________________________________
-PairAnalysisSignalFit::PairAnalysisSignalFit(const char* name,
- const char* title)
+PairAnalysisSignalFit::PairAnalysisSignalFit(const char* name, const char* title)
: PairAnalysisSignalExt(name, title) //,
// PairAnalysisFunction()
{
@@ -132,7 +131,8 @@ PairAnalysisSignalFit::PairAnalysisSignalFit(const char* name,
}
//______________________________________________
-PairAnalysisSignalFit::~PairAnalysisSignalFit() {
+PairAnalysisSignalFit::~PairAnalysisSignalFit()
+{
//
// Default Destructor
//
@@ -140,7 +140,8 @@ PairAnalysisSignalFit::~PairAnalysisSignalFit() {
//______________________________________________
-void PairAnalysisSignalFit::Process(TObjArray* const arrhist) {
+void PairAnalysisSignalFit::Process(TObjArray* const arrhist)
+{
//
// Fit the invariant mass histograms and retrieve the signal and background
//
@@ -163,7 +164,8 @@ void PairAnalysisSignalFit::Process(TObjArray* const arrhist) {
}
//______________________________________________
-void PairAnalysisSignalFit::ProcessFit(TObjArray* const arrhist) {
+void PairAnalysisSignalFit::ProcessFit(TObjArray* const arrhist)
+{
//
// Fit the +- invariant mass distribution only
// Here we assume that the combined fit function is a sum of the signal and background functions
@@ -174,41 +176,27 @@ void PairAnalysisSignalFit::ProcessFit(TObjArray* const arrhist) {
fHistDataPM->Sumw2();
if (fRebin > 1) fHistDataPM->Rebin(fRebin);
- fHistSignal = new TH1F("HistSignal",
- "Fit substracted signal",
- fHistDataPM->GetXaxis()->GetNbins(),
- fHistDataPM->GetXaxis()->GetXmin(),
- fHistDataPM->GetXaxis()->GetXmax());
- fHistBackground = new TH1F("HistBackground",
- "Fit contribution",
- fHistDataPM->GetXaxis()->GetNbins(),
- fHistDataPM->GetXaxis()->GetXmin(),
- fHistDataPM->GetXaxis()->GetXmax());
+ fHistSignal = new TH1F("HistSignal", "Fit substracted signal", fHistDataPM->GetXaxis()->GetNbins(),
+ fHistDataPM->GetXaxis()->GetXmin(), fHistDataPM->GetXaxis()->GetXmax());
+ fHistBackground = new TH1F("HistBackground", "Fit contribution", fHistDataPM->GetXaxis()->GetNbins(),
+ fHistDataPM->GetXaxis()->GetXmin(), fHistDataPM->GetXaxis()->GetXmax());
// the starting parameters of the fit function and their limits can be tuned
// by the user in its macro
fHistDataPM->Fit(fFuncSigBack, fFitOpt.Data(), "", fFitMin, fFitMax);
- TFitResultPtr pmFitPtr =
- fHistDataPM->Fit(fFuncSigBack, fFitOpt.Data(), "", fFitMin, fFitMax);
+ TFitResultPtr pmFitPtr = fHistDataPM->Fit(fFuncSigBack, fFitOpt.Data(), "", fFitMin, fFitMax);
//TFitResult *pmFitResult = pmFitPtr.Get(); // used only with TF1Helper
//fFuncBackground->SetParameters(fFuncSigBack->GetParameters());
fFuncSignal->SetParameters(fFuncSigBack->GetParameters());
- fFuncBackground->SetParameters(fFuncSigBack->GetParameters()
- + fFuncSignal->GetNpar());
+ fFuncBackground->SetParameters(fFuncSigBack->GetParameters() + fFuncSignal->GetNpar());
// fill the background spectrum
fHistBackground->Eval(fFuncBackground);
// set the error for the background histogram
fHistBackground->Fit(fFuncBackground, "0qR", "", fFitMin, fFitMax);
- Double_t inte = fFuncBackground->IntegralError(fIntMin, fIntMax)
- / fHistDataPM->GetBinWidth(1);
- Double_t binte =
- inte
- / TMath::Sqrt(
- (fHistDataPM->FindBin(fIntMax) - fHistDataPM->FindBin(fIntMin)) + 1);
- for (Int_t iBin = fHistDataPM->FindBin(fIntMin);
- iBin <= fHistDataPM->FindBin(fIntMax);
- iBin++) {
+ Double_t inte = fFuncBackground->IntegralError(fIntMin, fIntMax) / fHistDataPM->GetBinWidth(1);
+ Double_t binte = inte / TMath::Sqrt((fHistDataPM->FindBin(fIntMax) - fHistDataPM->FindBin(fIntMin)) + 1);
+ for (Int_t iBin = fHistDataPM->FindBin(fIntMin); iBin <= fHistDataPM->FindBin(fIntMax); iBin++) {
fHistBackground->SetBinError(iBin, binte);
}
@@ -222,8 +210,7 @@ void PairAnalysisSignalFit::ProcessFit(TObjArray* const arrhist) {
Double_t error = TMath::Sqrt(epm * epm + ebknd);
// theres no signal extraction outside the fit region
if (fHistDataPM->GetBinLowEdge(iBin) > fFitMax
- || fHistDataPM->GetBinLowEdge(iBin) + fHistDataPM->GetBinWidth(iBin)
- < fFitMin) {
+ || fHistDataPM->GetBinLowEdge(iBin) + fHistDataPM->GetBinWidth(iBin) < fFitMin) {
signal = 0.0;
error = 0.0;
}
@@ -233,25 +220,20 @@ void PairAnalysisSignalFit::ProcessFit(TObjArray* const arrhist) {
if (fUseIntegral) {
// signal
- fValues(0) =
- fFuncSignal->Integral(fIntMin, fIntMax) / fHistDataPM->GetBinWidth(1);
- fErrors(0) = fFuncSignal->IntegralError(fIntMin, fIntMax)
- / fHistDataPM->GetBinWidth(1);
+ fValues(0) = fFuncSignal->Integral(fIntMin, fIntMax) / fHistDataPM->GetBinWidth(1);
+ fErrors(0) = fFuncSignal->IntegralError(fIntMin, fIntMax) / fHistDataPM->GetBinWidth(1);
// fErrors(0) = 0;
// background
- fValues(1) =
- fFuncBackground->Integral(fIntMin, fIntMax) / fHistDataPM->GetBinWidth(1);
- fErrors(1) = fFuncBackground->IntegralError(fIntMin, fIntMax)
- / fHistDataPM->GetBinWidth(1);
- } else {
+ fValues(1) = fFuncBackground->Integral(fIntMin, fIntMax) / fHistDataPM->GetBinWidth(1);
+ fErrors(1) = fFuncBackground->IntegralError(fIntMin, fIntMax) / fHistDataPM->GetBinWidth(1);
+ }
+ else {
// signal
- fValues(0) = fHistSignal->IntegralAndError(
- fHistSignal->FindBin(fIntMin), fHistSignal->FindBin(fIntMax), fErrors(0));
+ fValues(0) =
+ fHistSignal->IntegralAndError(fHistSignal->FindBin(fIntMin), fHistSignal->FindBin(fIntMax), fErrors(0));
// background
- fValues(1) =
- fHistBackground->IntegralAndError(fHistBackground->FindBin(fIntMin),
- fHistBackground->FindBin(fIntMax),
- fErrors(1));
+ fValues(1) = fHistBackground->IntegralAndError(fHistBackground->FindBin(fIntMin), fHistBackground->FindBin(fIntMax),
+ fErrors(1));
}
// S/B and significance
SetSignificanceAndSOB();
@@ -267,7 +249,8 @@ void PairAnalysisSignalFit::ProcessFit(TObjArray* const arrhist) {
}
//______________________________________________
-void PairAnalysisSignalFit::ProcessFitLS(TObjArray* const arrhist) {
+void PairAnalysisSignalFit::ProcessFitLS(TObjArray* const arrhist)
+{
//
// Substract background using the like-sign spectrum
//
@@ -283,16 +266,10 @@ void PairAnalysisSignalFit::ProcessFitLS(TObjArray* const arrhist) {
fHistDataPM->Sumw2();
fHistDataMM->Sumw2();
- fHistSignal = new TH1F("HistSignal",
- "Like-Sign substracted signal",
- fHistDataPM->GetXaxis()->GetNbins(),
- fHistDataPM->GetXaxis()->GetXmin(),
- fHistDataPM->GetXaxis()->GetXmax());
- fHistBackground = new TH1F("HistBackground",
- "Like-sign contribution",
- fHistDataPM->GetXaxis()->GetNbins(),
- fHistDataPM->GetXaxis()->GetXmin(),
- fHistDataPM->GetXaxis()->GetXmax());
+ fHistSignal = new TH1F("HistSignal", "Like-Sign substracted signal", fHistDataPM->GetXaxis()->GetNbins(),
+ fHistDataPM->GetXaxis()->GetXmin(), fHistDataPM->GetXaxis()->GetXmax());
+ fHistBackground = new TH1F("HistBackground", "Like-sign contribution", fHistDataPM->GetXaxis()->GetNbins(),
+ fHistDataPM->GetXaxis()->GetXmin(), fHistDataPM->GetXaxis()->GetXmax());
// fit the +- mass distribution
fHistDataPM->Fit(fFuncSigBack, fFitOpt.Data(), "", fFitMin, fFitMax);
@@ -324,8 +301,7 @@ void PairAnalysisSignalFit::ProcessFitLS(TObjArray* const arrhist) {
Double_t background = 2.0 * TMath::Sqrt(pp * mm);
// error propagation on the signal calculation above
- Double_t esignal =
- TMath::Sqrt(epm * epm + (mm / pp) * epp + (pp / mm) * emm);
+ Double_t esignal = TMath::Sqrt(epm * epm + (mm / pp) * epp + (pp / mm) * emm);
Double_t ebackground = TMath::Sqrt((mm / pp) * epp + (pp / mm) * emm);
fHistSignal->SetBinContent(iBin, signal);
fHistSignal->SetBinError(iBin, esignal);
@@ -334,13 +310,10 @@ void PairAnalysisSignalFit::ProcessFitLS(TObjArray* const arrhist) {
}
// signal
- fValues(0) = fHistSignal->IntegralAndError(
- fHistSignal->FindBin(fIntMin), fHistSignal->FindBin(fIntMax), fErrors(0));
+ fValues(0) = fHistSignal->IntegralAndError(fHistSignal->FindBin(fIntMin), fHistSignal->FindBin(fIntMax), fErrors(0));
// background
fValues(1) =
- fHistBackground->IntegralAndError(fHistBackground->FindBin(fIntMin),
- fHistBackground->FindBin(fIntMax),
- fErrors(1));
+ fHistBackground->IntegralAndError(fHistBackground->FindBin(fIntMin), fHistBackground->FindBin(fIntMax), fErrors(1));
// S/B and significance
SetSignificanceAndSOB();
fValues(4) = fFuncSigBack->GetParameter(fParMass);
@@ -353,17 +326,18 @@ void PairAnalysisSignalFit::ProcessFitLS(TObjArray* const arrhist) {
}
//______________________________________________
-void PairAnalysisSignalFit::ProcessFitEM(TObjArray* const arrhist) {
+void PairAnalysisSignalFit::ProcessFitEM(TObjArray* const arrhist)
+{
//
// Substract background with the event mixing technique
//
arrhist->GetEntries(); // just to avoid the unused parameter warning
- Error("ProcessFitEM",
- "Event mixing for background substraction method not yet implemented!");
+ Error("ProcessFitEM", "Event mixing for background substraction method not yet implemented!");
}
//______________________________________________
-void PairAnalysisSignalFit::Draw(const Option_t* option) {
+void PairAnalysisSignalFit::Draw(const Option_t* option)
+{
//
// Draw the fitted function
//
@@ -387,9 +361,7 @@ void PairAnalysisSignalFit::Draw(const Option_t* option) {
grBack->SetFillStyle(3001);
grSig->SetPoint(0, grBack->GetX()[0], grBack->GetY()[0]);
- grSig->SetPoint(grSig->GetN() - 1,
- grBack->GetX()[grBack->GetN() - 1],
- grBack->GetY()[grBack->GetN() - 1]);
+ grSig->SetPoint(grSig->GetN() - 1, grBack->GetX()[grBack->GetN() - 1], grBack->GetY()[grBack->GetN() - 1]);
grBack->SetPoint(0, grBack->GetX()[0], 0.);
grBack->SetPoint(grBack->GetN() - 1, grBack->GetX()[grBack->GetN() - 1], 0.);
@@ -401,10 +373,12 @@ void PairAnalysisSignalFit::Draw(const Option_t* option) {
if (fHistDataPM) {
fHistDataPM->Draw();
grSig->Draw("f");
- } else {
+ }
+ else {
grSig->Draw("af");
}
- } else {
+ }
+ else {
grSig->Draw("f");
}
if (fMethod == kFitted || fMethod == kFittedMC) grBack->Draw("f");
@@ -425,7 +399,8 @@ void PairAnalysisSignalFit::Draw(const Option_t* option) {
}
//______________________________________________
-void PairAnalysisSignalFit::Print(Option_t* /*option*/) const {
+void PairAnalysisSignalFit::Print(Option_t* /*option*/) const
+{
//
// Print the statistics
//
diff --git a/analysis/PWGDIL/dielectron/papaframework/PairAnalysisSignalFit.h b/analysis/PWGDIL/dielectron/papaframework/PairAnalysisSignalFit.h
index 6d7f3c2ad2a7649e3488a07b1863aa4b8c165b33..26493895bab69fe6249b04835515acde03e0e44a 100644
--- a/analysis/PWGDIL/dielectron/papaframework/PairAnalysisSignalFit.h
+++ b/analysis/PWGDIL/dielectron/papaframework/PairAnalysisSignalFit.h
@@ -27,11 +27,9 @@ public:
virtual ~PairAnalysisSignalFit();
virtual void Process(TObjArray* const arrhist);
- void ProcessFit(TObjArray* const arrhist); // fit the SE +- distribution
- void ProcessFitLS(
- TObjArray* const arrhist); // substract the fitted SE like-sign background
- void ProcessFitEM(
- TObjArray* const arrhist); // substract the fitted ME like-sign background
+ void ProcessFit(TObjArray* const arrhist); // fit the SE +- distribution
+ void ProcessFitLS(TObjArray* const arrhist); // substract the fitted SE like-sign background
+ void ProcessFitEM(TObjArray* const arrhist); // substract the fitted ME like-sign background
virtual void Draw(const Option_t* option = "");
diff --git a/analysis/PWGDIL/dielectron/papaframework/PairAnalysisSignalFunc.cxx b/analysis/PWGDIL/dielectron/papaframework/PairAnalysisSignalFunc.cxx
index 2a67142eb15d33436074bff3414bff3118941b52..b74310d3a404745c08e1417dcfe7650f8d6a8c6e 100644
--- a/analysis/PWGDIL/dielectron/papaframework/PairAnalysisSignalFunc.cxx
+++ b/analysis/PWGDIL/dielectron/papaframework/PairAnalysisSignalFunc.cxx
@@ -52,22 +52,24 @@ ClassImp(PairAnalysisFunction)
PairAnalysisFunction::PairAnalysisFunction()
- : TNamed("function", "function") {
+ : TNamed("function", "function")
+{
//
// Default Constructor
//
}
//______________________________________________
-PairAnalysisFunction::PairAnalysisFunction(const char* name, const char* title)
- : TNamed(name, title) {
+PairAnalysisFunction::PairAnalysisFunction(const char* name, const char* title) : TNamed(name, title)
+{
//
// Named Constructor
//
}
//______________________________________________
-PairAnalysisFunction::~PairAnalysisFunction() {
+PairAnalysisFunction::~PairAnalysisFunction()
+{
//
// Default Destructor
//
@@ -78,8 +80,8 @@ PairAnalysisFunction::~PairAnalysisFunction() {
//______________________________________________________________________________
-Double_t PairAnalysisFunction::PeakFunMC(const Double_t* x,
- const Double_t* par) {
+Double_t PairAnalysisFunction::PeakFunMC(const Double_t* x, const Double_t* par)
+{
// Fit MC signal shape
// parameters
// [0]: scale for simpeak
@@ -88,8 +90,7 @@ Double_t PairAnalysisFunction::PeakFunMC(const Double_t* x,
TH1F* hPeak = fgHistSimPM;
if (!hPeak) {
- printf(
- "E-PairAnalysisFunction::PeakFun: No histogram for peak fit defined!\n");
+ printf("E-PairAnalysisFunction::PeakFun: No histogram for peak fit defined!\n");
return 0.0;
}
@@ -100,8 +101,8 @@ Double_t PairAnalysisFunction::PeakFunMC(const Double_t* x,
}
//______________________________________________________________________________
-Double_t PairAnalysisFunction::PeakFunCB(const Double_t* x,
- const Double_t* par) {
+Double_t PairAnalysisFunction::PeakFunCB(const Double_t* x, const Double_t* par)
+{
// Crystal Ball fit function
Double_t n = par[0];
@@ -110,16 +111,14 @@ Double_t PairAnalysisFunction::PeakFunCB(const Double_t* x,
Double_t sigma = par[3];
Double_t nn = par[4];
- Double_t a =
- TMath::Power((n / TMath::Abs(alpha)), n) * TMath::Exp(-.5 * alpha * alpha);
+ Double_t a = TMath::Power((n / TMath::Abs(alpha)), n) * TMath::Exp(-.5 * alpha * alpha);
Double_t b = n / TMath::Abs(alpha) - TMath::Abs(alpha);
Double_t arg = (x[0] - meanx) / sigma;
Double_t fitval = 0;
- if (arg > -1. * alpha) {
- fitval = nn * TMath::Exp(-.5 * arg * arg);
- } else {
+ if (arg > -1. * alpha) { fitval = nn * TMath::Exp(-.5 * arg * arg); }
+ else {
fitval = nn * a * TMath::Power((b - arg), (-1 * n));
}
@@ -127,8 +126,8 @@ Double_t PairAnalysisFunction::PeakFunCB(const Double_t* x,
}
//______________________________________________________________________________
-Double_t PairAnalysisFunction::PeakFunGaus(const Double_t* x,
- const Double_t* par) {
+Double_t PairAnalysisFunction::PeakFunGaus(const Double_t* x, const Double_t* par)
+{
// Gaussian fit function
//printf("fNparBgrd %d \n",fNparBgnd);
Double_t n = par[0];
@@ -140,11 +139,8 @@ Double_t PairAnalysisFunction::PeakFunGaus(const Double_t* x,
}
//______________________________________________
-void PairAnalysisFunction::SetFunctions(TF1* const combined,
- TF1* const sig,
- TF1* const back,
- Int_t parM,
- Int_t parMres) {
+void PairAnalysisFunction::SetFunctions(TF1* const combined, TF1* const sig, TF1* const back, Int_t parM, Int_t parMres)
+{
//
// Set the signal, background functions and combined fit function
// Note: The process method assumes that the first n parameters in the
@@ -152,8 +148,7 @@ void PairAnalysisFunction::SetFunctions(TF1* const combined,
// and the n+1 to n+m parameters to the m parameters of the background function!!!
if (!sig || !back || !combined) {
- Error("SetFunctions",
- "Both, signal and background function need to be set!");
+ Error("SetFunctions", "Both, signal and background function need to be set!");
return;
}
fFuncSignal = sig;
@@ -164,7 +159,8 @@ void PairAnalysisFunction::SetFunctions(TF1* const combined,
}
//______________________________________________
-void PairAnalysisFunction::SetDefaults(Int_t type) {
+void PairAnalysisFunction::SetDefaults(Int_t type)
+{
//
// Setup some default functions:
// type = 0: gaus signal + linear background in 2.5 - 4 GeV inv. mass
@@ -184,35 +180,31 @@ void PairAnalysisFunction::SetDefaults(Int_t type) {
fFuncSigBack->SetParLimits(0, 0, 10000000);
fFuncSigBack->SetParLimits(1, 3.05, 3.15);
fFuncSigBack->SetParLimits(2, .02, .1);
- } else if (type == 1) {
- fFuncSignal = new TF1("DieleSignal", "gaus", 2.5, 4);
- fFuncBackground =
- new TF1("DieleBackground", "[0]*exp(-(x-[1])/[2])", 2.5, 4);
- fFuncSigBack =
- new TF1("DieleCombined", "gaus+[3]*exp(-(x-[4])/[5])", 2.5, 4);
+ }
+ else if (type == 1) {
+ fFuncSignal = new TF1("DieleSignal", "gaus", 2.5, 4);
+ fFuncBackground = new TF1("DieleBackground", "[0]*exp(-(x-[1])/[2])", 2.5, 4);
+ fFuncSigBack = new TF1("DieleCombined", "gaus+[3]*exp(-(x-[4])/[5])", 2.5, 4);
fFuncSigBack->SetParameters(1, 3.1, .05, 1, 2.5, 1);
fFuncSigBack->SetParLimits(0, 0, 10000000);
fFuncSigBack->SetParLimits(1, 3.05, 3.15);
fFuncSigBack->SetParLimits(2, .02, .1);
- } else if (type == 2) {
+ }
+ else if (type == 2) {
// half gaussian, half exponential signal function
// exponential background
- fFuncSignal = new TF1("DieleSignal",
+ fFuncSignal = new TF1("DieleSignal",
"(x<[1])*([0]*(exp(-0.5*((x-[1])/[2])^2)+exp((x-[1])/"
"[3])*(1-exp(-0.5*((x-[1])/"
"[2])^2))))+(x>=[1])*([0]*exp(-0.5*((x-[1])/[2])^2))",
- 2.5,
- 4);
- fFuncBackground =
- new TF1("DieleBackground", "[0]*exp(-(x-[1])/[2])+[3]", 2.5, 4);
- fFuncSigBack = new TF1(
- "DieleCombined",
- "(x<[1])*([0]*(exp(-0.5*((x-[1])/[2])^2)+exp((x-[1])/"
- "[3])*(1-exp(-0.5*((x-[1])/[2])^2))))+(x>=[1])*([0]*exp(-0.5*((x-[1])/"
- "[2])^2))+[4]*exp(-(x-[5])/[6])+[7]",
- 2.5,
- 4);
+ 2.5, 4);
+ fFuncBackground = new TF1("DieleBackground", "[0]*exp(-(x-[1])/[2])+[3]", 2.5, 4);
+ fFuncSigBack = new TF1("DieleCombined",
+ "(x<[1])*([0]*(exp(-0.5*((x-[1])/[2])^2)+exp((x-[1])/"
+ "[3])*(1-exp(-0.5*((x-[1])/[2])^2))))+(x>=[1])*([0]*exp(-0.5*((x-[1])/"
+ "[2])^2))+[4]*exp(-(x-[5])/[6])+[7]",
+ 2.5, 4);
fFuncSigBack->SetParameters(1., 3.1, .05, .1, 1, 2.5, 1, 0);
fFuncSigBack->SetParLimits(0, 0, 10000000);
@@ -224,14 +216,14 @@ void PairAnalysisFunction::SetDefaults(Int_t type) {
}
//______________________________________________________________________________
-void PairAnalysisFunction::CombineFunc(TF1* const peak, TF1* const bgnd) {
+void PairAnalysisFunction::CombineFunc(TF1* const peak, TF1* const bgnd)
+{
//
// combine the bgnd and the peak function
//
if (!peak || !bgnd) {
- Error("CombineFunc",
- "Both, signal and background function need to be set!");
+ Error("CombineFunc", "Both, signal and background function need to be set!");
return;
}
fFuncSignal = peak;
@@ -240,28 +232,22 @@ void PairAnalysisFunction::CombineFunc(TF1* const peak, TF1* const bgnd) {
fNparPeak = fFuncSignal->GetNpar();
fNparBgnd = fFuncBackground->GetNpar();
- fFuncSigBack = new TF1("BgndPeak",
- this,
- &PairAnalysisFunction::PeakBgndFun,
- fFitMin,
- fFitMax,
- fNparPeak + fNparBgnd);
+ fFuncSigBack = new TF1("BgndPeak", this, &PairAnalysisFunction::PeakBgndFun, fFitMin, fFitMax, fNparPeak + fNparBgnd);
return;
}
//______________________________________________________________________________
-Double_t PairAnalysisFunction::PeakBgndFun(const Double_t* x,
- const Double_t* par) {
+Double_t PairAnalysisFunction::PeakBgndFun(const Double_t* x, const Double_t* par)
+{
//
// merge peak and bgnd functions
//
- return (
- fFuncSignal->EvalPar(x, par)
- + (fFuncBackground ? fFuncBackground->EvalPar(x, par + fNparPeak) : 0.));
+ return (fFuncSignal->EvalPar(x, par) + (fFuncBackground ? fFuncBackground->EvalPar(x, par + fNparPeak) : 0.));
}
//______________________________________________
-void PairAnalysisFunction::Print(Option_t* /*option*/) const {
+void PairAnalysisFunction::Print(Option_t* /*option*/) const
+{
//
// Print the statistics
//
diff --git a/analysis/PWGDIL/dielectron/papaframework/PairAnalysisSignalFunc.h b/analysis/PWGDIL/dielectron/papaframework/PairAnalysisSignalFunc.h
index cde2bf41d8c7de39f8f167cbef879194aaf69575..047c8356cbd2a394b99533f7d48a1923b92937f7 100644
--- a/analysis/PWGDIL/dielectron/papaframework/PairAnalysisSignalFunc.h
+++ b/analysis/PWGDIL/dielectron/papaframework/PairAnalysisSignalFunc.h
@@ -29,17 +29,14 @@ public:
// Setter
void SetUseIntegral(Bool_t flag = kTRUE) { fUseIntegral = flag; };
- void SetFitOption(const char* opt) {
+ void SetFitOption(const char* opt)
+ {
fFitOpt = opt;
fFitOpt.ToLower();
if (!fFitOpt.Contains("s")) fFitOpt += "s";
}
- void SetFunction(TF1* const combined,
- TF1* const sig = 0,
- TF1* const back = 0,
- Int_t parM = 1,
- Int_t parMres = 2);
+ void SetFunction(TF1* const combined, TF1* const sig = 0, TF1* const back = 0, Int_t parM = 1, Int_t parMres = 2);
void SetDefaults(Int_t type);
void CombineFunc(TF1* const peak = 0, TF1* const bgnd = 0);
@@ -48,7 +45,7 @@ public:
Double_t PeakFunMC(const Double_t* x,
const Double_t* par); // peak function from a mc histo
Double_t PeakFunCB(const Double_t* x,
- const Double_t* par); // crystal ball function
+ const Double_t* par); // crystal ball function
Double_t PeakFunGaus(const Double_t* x, const Double_t* par); // gaussian
// Getter
@@ -64,22 +61,18 @@ public:
protected:
- Double_t
- PeakBgndFun(const Double_t* x,
- const Double_t* par); // combine any bgrd and any peak function
+ Double_t PeakBgndFun(const Double_t* x,
+ const Double_t* par); // combine any bgrd and any peak function
TF1* fFuncSignal = NULL; // Function for the signal description
TF1* fFuncBackground = NULL; // Function for the background description
TF1* fFuncSigBack = NULL; // Combined function signal plus background
- Int_t fParMass =
- 1; // the index of the parameter corresponding to the resonance mass
- Int_t fParMassWidth =
- 2; // the index of the parameter corresponding to the resonance mass width
+ Int_t fParMass = 1; // the index of the parameter corresponding to the resonance mass
+ Int_t fParMassWidth = 2; // the index of the parameter corresponding to the resonance mass width
- TString fFitOpt = "SMNQE"; // fit option used
- Bool_t fUseIntegral =
- kFALSE; // use the integral of the fitted functions to extract signal and background
+ TString fFitOpt = "SMNQE"; // fit option used
+ Bool_t fUseIntegral = kFALSE; // use the integral of the fitted functions to extract signal and background
Int_t fDof = 0; // degrees of freedom
Double_t fChi2Dof = 0; // chi2/dof of the fitted inv mass spectra
diff --git a/analysis/PWGDIL/dielectron/papaframework/PairAnalysisSignalMC.cxx b/analysis/PWGDIL/dielectron/papaframework/PairAnalysisSignalMC.cxx
index 14b6cdb9ba978e526bcf664a807c985d667dd4c9..f29243e4287cda082ca29abc710c461c0aca97b6 100644
--- a/analysis/PWGDIL/dielectron/papaframework/PairAnalysisSignalMC.cxx
+++ b/analysis/PWGDIL/dielectron/papaframework/PairAnalysisSignalMC.cxx
@@ -62,43 +62,44 @@
///////////////////////////////////////////////////////////////////////////
#include "PairAnalysisSignalMC.h"
+
#include "PairAnalysisHelper.h"
ClassImp(PairAnalysisSignalMC)
- const char* PairAnalysisSignalMC::fgkSignals[static_cast<int>(
- EDefinedSignal::kNSignals)][2] = { //default signal names+titles
- {"InclJpsi", "J/#psi (incl.)"},
- {"NonRadJpsi", "J/#psi"},
- {"RadJpsi", "J/#psi (rad.)"},
- {"Psi2S", "#psi(2S)"},
- {"Conversion", "#gamma#rightarrow e^{+}e^{-}"},
- {"Rho0", "#rho^{0}"},
- {"OmegaDalitz", "#omega_{Dalitz}"},
- {"Omega", "#omega"},
- {"Phi", "#phi"},
- {"EtaDalitz", "#eta_{Dalitz}"},
- {"Eta", "#eta"},
- {"Pi0Dalitz", "#pi^{0}_{Dalitz}"},
- {"Pi0Gamma", "#pi^{0}"},
- {"Pi0", "#pi^{0}"},
- {"K0Short", "K^{0}_{S}"},
- {"Lambda", "#Lambda"},
- {"InclElePM", "e^{+}e^{-} (incl.)"},
- {"DeltaElectron", "#delta rays"},
- {"PrimElectron", "e (prim.)"},
- {"PrimMuon", "#mu (prim.)"},
- {"PrimPion", "#pi (prim.)"},
- {"PrimKaon", "K (prim.)"},
- {"PrimProton", "p (prim.)"},
- {"Deuteron", "d"},
- {"Triton", "t"},
- {"Helion", "^{3}He"},
- {"Alpha", "^{4}He"}};
+ const char* PairAnalysisSignalMC::fgkSignals[static_cast<int>(EDefinedSignal::kNSignals)][2] =
+ { //default signal names+titles
+ {"InclJpsi", "J/#psi (incl.)"},
+ {"NonRadJpsi", "J/#psi"},
+ {"RadJpsi", "J/#psi (rad.)"},
+ {"Psi2S", "#psi(2S)"},
+ {"Conversion", "#gamma#rightarrow e^{+}e^{-}"},
+ {"Rho0", "#rho^{0}"},
+ {"OmegaDalitz", "#omega_{Dalitz}"},
+ {"Omega", "#omega"},
+ {"Phi", "#phi"},
+ {"EtaDalitz", "#eta_{Dalitz}"},
+ {"Eta", "#eta"},
+ {"Pi0Dalitz", "#pi^{0}_{Dalitz}"},
+ {"Pi0Gamma", "#pi^{0}"},
+ {"Pi0", "#pi^{0}"},
+ {"K0Short", "K^{0}_{S}"},
+ {"Lambda", "#Lambda"},
+ {"InclElePM", "e^{+}e^{-} (incl.)"},
+ {"DeltaElectron", "#delta rays"},
+ {"PrimElectron", "e (prim.)"},
+ {"PrimMuon", "#mu (prim.)"},
+ {"PrimPion", "#pi (prim.)"},
+ {"PrimKaon", "K (prim.)"},
+ {"PrimProton", "p (prim.)"},
+ {"Deuteron", "d"},
+ {"Triton", "t"},
+ {"Helion", "^{3}He"},
+ {"Alpha", "^{4}He"}};
//_________________________________________________________________________
-PairAnalysisSignalMC::PairAnalysisSignalMC()
- : PairAnalysisSignalMC("PairAnalysisSignalMC", "PairAnalysisSignalMC") {
+PairAnalysisSignalMC::PairAnalysisSignalMC() : PairAnalysisSignalMC("PairAnalysisSignalMC", "PairAnalysisSignalMC")
+{
//
// Default constructor
@@ -107,9 +108,8 @@ PairAnalysisSignalMC::PairAnalysisSignalMC()
//_________________________________________________________________________
-PairAnalysisSignalMC::PairAnalysisSignalMC(const Char_t* name,
- const Char_t* title)
- : TNamed(name, title) {
+PairAnalysisSignalMC::PairAnalysisSignalMC(const Char_t* name, const Char_t* title) : TNamed(name, title)
+{
//
// Named constructor
@@ -117,8 +117,8 @@ PairAnalysisSignalMC::PairAnalysisSignalMC(const Char_t* name,
}
//_________________________________________________________________________
-PairAnalysisSignalMC::PairAnalysisSignalMC(EDefinedSignal defaultSignal)
- : PairAnalysisSignalMC() {
+PairAnalysisSignalMC::PairAnalysisSignalMC(EDefinedSignal defaultSignal) : PairAnalysisSignalMC()
+{
//
// Constructor with default signals
@@ -421,9 +421,7 @@ PairAnalysisSignalMC::PairAnalysisSignalMC(EDefinedSignal defaultSignal)
fIsSingleParticle = kTRUE;
break;
default:
- Error(
- "PairAnalysisSignalMC",
- "Signal NOT predefined! Either request it or configure on your own.");
+ Error("PairAnalysisSignalMC", "Signal NOT predefined! Either request it or configure on your own.");
return;
break;
}
@@ -431,74 +429,53 @@ PairAnalysisSignalMC::PairAnalysisSignalMC(EDefinedSignal defaultSignal)
// Print();
}
-void PairAnalysisSignalMC::Print(Option_t* /*option*/) const {
+void PairAnalysisSignalMC::Print(Option_t* /*option*/) const
+{
//
//
//
Printf("MC Signal: %s with title %s ", GetName(), GetTitle());
- printf("\tPDGs leg1: %s%s%d%s ",
- (fLeg1Exclude ? "!" : ""),
- (fCheckBothChargesLeg1 ? "|" : ""),
- fLeg1,
+ printf("\tPDGs leg1: %s%s%d%s ", (fLeg1Exclude ? "!" : ""), (fCheckBothChargesLeg1 ? "|" : ""), fLeg1,
(fCheckBothChargesLeg1 ? "|" : ""));
if (fMother1 != 0)
- printf("<--- %s%s%d%s ",
- (fMother1Exclude ? "!" : ""),
- (fCheckBothChargesMother1 ? "|" : ""),
- fMother1,
+ printf("<--- %s%s%d%s ", (fMother1Exclude ? "!" : ""), (fCheckBothChargesMother1 ? "|" : ""), fMother1,
(fCheckBothChargesMother1 ? "|" : ""));
if (fGrandMother1 != 0)
- printf("<--- %s%s%d%s ",
- (fGrandMother1Exclude ? "!" : ""),
- (fCheckBothChargesGrandMother1 ? "|" : ""),
- fGrandMother1,
- (fCheckBothChargesGrandMother1 ? "|" : ""));
+ printf("<--- %s%s%d%s ", (fGrandMother1Exclude ? "!" : ""), (fCheckBothChargesGrandMother1 ? "|" : ""),
+ fGrandMother1, (fCheckBothChargesGrandMother1 ? "|" : ""));
if (fGreatGrandMother1 != 0)
- printf("<--- %s%s%d%s",
- (fGreatGrandMother1Exclude ? "!" : ""),
- (fCheckBothChargesGreatGrandMother1 ? "|" : ""),
- fGreatGrandMother1,
- (fCheckBothChargesGreatGrandMother1 ? "|" : ""));
+ printf("<--- %s%s%d%s", (fGreatGrandMother1Exclude ? "!" : ""), (fCheckBothChargesGreatGrandMother1 ? "|" : ""),
+ fGreatGrandMother1, (fCheckBothChargesGreatGrandMother1 ? "|" : ""));
printf("\n");
if (!fIsSingleParticle) {
// Printf("\t \t %s",(fDalitz)
// Printf("\t \t %s",(fMothersRelation)
- printf("\tPDGs leg2: %s%s%d%s ",
- (fLeg2Exclude ? "!" : ""),
- (fCheckBothChargesLeg2 ? "|" : ""),
- fLeg2,
+ printf("\tPDGs leg2: %s%s%d%s ", (fLeg2Exclude ? "!" : ""), (fCheckBothChargesLeg2 ? "|" : ""), fLeg2,
(fCheckBothChargesLeg2 ? "|" : ""));
if (fMother2 != 0)
- printf("<--- %s%s%d%s ",
- (fMother2Exclude ? "!" : ""),
- (fCheckBothChargesMother2 ? "|" : ""),
- fMother2,
+ printf("<--- %s%s%d%s ", (fMother2Exclude ? "!" : ""), (fCheckBothChargesMother2 ? "|" : ""), fMother2,
(fCheckBothChargesMother2 ? "|" : ""));
if (fGrandMother2 != 0)
- printf("<--- %s%s%d%s ",
- (fGrandMother2Exclude ? "!" : ""),
- (fCheckBothChargesGrandMother2 ? "|" : ""),
- fGrandMother2,
- (fCheckBothChargesGrandMother2 ? "|" : ""));
+ printf("<--- %s%s%d%s ", (fGrandMother2Exclude ? "!" : ""), (fCheckBothChargesGrandMother2 ? "|" : ""),
+ fGrandMother2, (fCheckBothChargesGrandMother2 ? "|" : ""));
if (fGreatGrandMother2 != 0)
- printf("<--- %s%s%d%s",
- (fGreatGrandMother2Exclude ? "!" : ""),
- (fCheckBothChargesGreatGrandMother2 ? "|" : ""),
- fGreatGrandMother2,
- (fCheckBothChargesGreatGrandMother2 ? "|" : ""));
+ printf("<--- %s%s%d%s", (fGreatGrandMother2Exclude ? "!" : ""), (fCheckBothChargesGreatGrandMother2 ? "|" : ""),
+ fGreatGrandMother2, (fCheckBothChargesGreatGrandMother2 ? "|" : ""));
printf("\n");
}
}
//_________________________________________________________________________
-PairAnalysisSignalMC::~PairAnalysisSignalMC() {
+PairAnalysisSignalMC::~PairAnalysisSignalMC()
+{
//
// Destructor
//
}
-Double_t PairAnalysisSignalMC::GetWeight(Double_t* const values) const {
+Double_t PairAnalysisSignalMC::GetWeight(Double_t* const values) const
+{
// TODO: workaround to avoid zero weights
if (fType == 0) return fWeight;
diff --git a/analysis/PWGDIL/dielectron/papaframework/PairAnalysisSignalMC.h b/analysis/PWGDIL/dielectron/papaframework/PairAnalysisSignalMC.h
index 7320f20ff9e255ef52006456165505768ea719e4..b99b6b84eae1b4a60a7b199b1b8f240d604bea00 100644
--- a/analysis/PWGDIL/dielectron/papaframework/PairAnalysisSignalMC.h
+++ b/analysis/PWGDIL/dielectron/papaframework/PairAnalysisSignalMC.h
@@ -15,8 +15,14 @@
class PairAnalysisSignalMC : public TNamed {
public:
- enum class EBranchRelation { kUndefined = 0, kSame, kDifferent };
- enum class ESource {
+ enum class EBranchRelation
+ {
+ kUndefined = 0,
+ kSame,
+ kDifferent
+ };
+ enum class ESource
+ {
kDontCare = 0,
kPrimary,
kSecondary,
@@ -25,8 +31,14 @@ public:
kSecondaryFromWeakDecay,
kSecondaryFromMaterial
};
- enum class EDalitz { kWhoCares = 0, kIsDalitz, kIsNotDalitz };
- enum class EDefinedSignal {
+ enum class EDalitz
+ {
+ kWhoCares = 0,
+ kIsDalitz,
+ kIsNotDalitz
+ };
+ enum class EDefinedSignal
+ {
kInclJpsi = 0,
kNonRadJpsi,
kRadJpsi,
@@ -62,75 +74,73 @@ public:
PairAnalysisSignalMC(EDefinedSignal defaultSignal);
virtual ~PairAnalysisSignalMC();
- void SetLegPDGs(Int_t pdg1,
- Int_t pdg2,
- Bool_t exclude1 = kFALSE,
- Bool_t exclude2 = kFALSE) {
+ void SetLegPDGs(Int_t pdg1, Int_t pdg2, Bool_t exclude1 = kFALSE, Bool_t exclude2 = kFALSE)
+ {
fLeg1 = pdg1;
fLeg2 = pdg2;
fLeg1Exclude = exclude1;
fLeg2Exclude = exclude2;
}
- void SetMotherPDGs(Int_t pdg1,
- Int_t pdg2,
- Bool_t exclude1 = kFALSE,
- Bool_t exclude2 = kFALSE) {
+ void SetMotherPDGs(Int_t pdg1, Int_t pdg2, Bool_t exclude1 = kFALSE, Bool_t exclude2 = kFALSE)
+ {
fMother1 = pdg1;
fMother2 = pdg2;
fMother1Exclude = exclude1;
fMother2Exclude = exclude2;
}
- void SetGrandMotherPDGs(Int_t pdg1,
- Int_t pdg2,
- Bool_t exclude1 = kFALSE,
- Bool_t exclude2 = kFALSE) {
+ void SetGrandMotherPDGs(Int_t pdg1, Int_t pdg2, Bool_t exclude1 = kFALSE, Bool_t exclude2 = kFALSE)
+ {
fGrandMother1 = pdg1;
fGrandMother2 = pdg2;
fGrandMother1Exclude = exclude1;
fGrandMother2Exclude = exclude2;
}
- void SetGreatGrandMotherPDGs(Int_t pdg1,
- Int_t pdg2,
- Bool_t exclude1 = kFALSE,
- Bool_t exclude2 = kFALSE) {
+ void SetGreatGrandMotherPDGs(Int_t pdg1, Int_t pdg2, Bool_t exclude1 = kFALSE, Bool_t exclude2 = kFALSE)
+ {
fGreatGrandMother1 = pdg1;
fGreatGrandMother2 = pdg2;
fGreatGrandMother1Exclude = exclude1;
fGreatGrandMother2Exclude = exclude2;
}
- void SetLegSources(ESource s1, ESource s2) {
+ void SetLegSources(ESource s1, ESource s2)
+ {
fLeg1Source = s1;
fLeg2Source = s2;
}
- void SetMotherSources(ESource s1, ESource s2) {
+ void SetMotherSources(ESource s1, ESource s2)
+ {
fMother1Source = s1;
fMother2Source = s2;
}
- void SetGrandMotherSources(ESource s1, ESource s2) {
+ void SetGrandMotherSources(ESource s1, ESource s2)
+ {
fGrandMother1Source = s1;
fGrandMother2Source = s2;
}
- void SetCheckBothChargesLegs(Bool_t flag1, Bool_t flag2) {
+ void SetCheckBothChargesLegs(Bool_t flag1, Bool_t flag2)
+ {
fCheckBothChargesLeg1 = flag1;
fCheckBothChargesLeg2 = flag2;
}
- void SetCheckBothChargesMothers(Bool_t flag1, Bool_t flag2) {
+ void SetCheckBothChargesMothers(Bool_t flag1, Bool_t flag2)
+ {
fCheckBothChargesMother1 = flag1;
fCheckBothChargesMother2 = flag2;
}
- void SetCheckBothChargesGrandMothers(Bool_t flag1, Bool_t flag2) {
+ void SetCheckBothChargesGrandMothers(Bool_t flag1, Bool_t flag2)
+ {
fCheckBothChargesGrandMother1 = flag1;
fCheckBothChargesGrandMother2 = flag2;
}
- void SetMothersRelation(EBranchRelation relation) {
- fMothersRelation = relation;
- }
- void SetGEANTProcess(TMCProcess processID, Bool_t check = kTRUE) {
+ void SetMothersRelation(EBranchRelation relation) { fMothersRelation = relation; }
+ void SetGEANTProcess(TMCProcess processID, Bool_t check = kTRUE)
+ {
fGEANTProcess = processID;
fCheckGEANTProcess = check;
}
// void SetWeight(TSpline3 *wghts, UInt_t var) { if(&fWeights) delete &fWeights; fWeights = *wghts; fType=var; }
- void SetWeight(TSpline3* wghts, UInt_t var) {
+ void SetWeight(TSpline3* wghts, UInt_t var)
+ {
if (fWeights) delete fWeights;
fWeights = wghts;
fType = var;
@@ -140,50 +150,37 @@ public:
void SetIsSingleParticle(Bool_t fill = kTRUE) { fIsSingleParticle = fill; }
Int_t GetLegPDG(Int_t branch) const { return (branch == 1 ? fLeg1 : fLeg2); }
- Int_t GetMotherPDG(Int_t branch) const {
- return (branch == 1 ? fMother1 : fMother2);
- }
- Int_t GetGrandMotherPDG(Int_t branch) const {
- return (branch == 1 ? fGrandMother1 : fGrandMother2);
- }
- Int_t GetGreatGrandMotherPDG(Int_t branch) const {
- return (branch == 1 ? fGreatGrandMother1 : fGreatGrandMother2);
- }
- Bool_t GetLegPDGexclude(Int_t branch) const {
- return (branch == 1 ? fLeg1Exclude : fLeg2Exclude);
- }
- Bool_t GetMotherPDGexclude(Int_t branch) const {
- return (branch == 1 ? fMother1Exclude : fMother2Exclude);
- }
- Bool_t GetGrandMotherPDGexclude(Int_t branch) const {
+ Int_t GetMotherPDG(Int_t branch) const { return (branch == 1 ? fMother1 : fMother2); }
+ Int_t GetGrandMotherPDG(Int_t branch) const { return (branch == 1 ? fGrandMother1 : fGrandMother2); }
+ Int_t GetGreatGrandMotherPDG(Int_t branch) const { return (branch == 1 ? fGreatGrandMother1 : fGreatGrandMother2); }
+ Bool_t GetLegPDGexclude(Int_t branch) const { return (branch == 1 ? fLeg1Exclude : fLeg2Exclude); }
+ Bool_t GetMotherPDGexclude(Int_t branch) const { return (branch == 1 ? fMother1Exclude : fMother2Exclude); }
+ Bool_t GetGrandMotherPDGexclude(Int_t branch) const
+ {
return (branch == 1 ? fGrandMother1Exclude : fGrandMother2Exclude);
}
- Bool_t GetGreatGrandMotherPDGexclude(Int_t branch) const {
- return (branch == 1 ? fGreatGrandMother1Exclude
- : fGreatGrandMother2Exclude);
- }
- ESource GetLegSource(Int_t branch) const {
- return (branch == 1 ? fLeg1Source : fLeg2Source);
- }
- ESource GetMotherSource(Int_t branch) const {
- return (branch == 1 ? fMother1Source : fMother2Source);
- }
- ESource GetGrandMotherSource(Int_t branch) const {
- return (branch == 1 ? fGrandMother1Source : fGrandMother2Source);
+ Bool_t GetGreatGrandMotherPDGexclude(Int_t branch) const
+ {
+ return (branch == 1 ? fGreatGrandMother1Exclude : fGreatGrandMother2Exclude);
}
- Bool_t GetCheckBothChargesLegs(Int_t branch) const {
+ ESource GetLegSource(Int_t branch) const { return (branch == 1 ? fLeg1Source : fLeg2Source); }
+ ESource GetMotherSource(Int_t branch) const { return (branch == 1 ? fMother1Source : fMother2Source); }
+ ESource GetGrandMotherSource(Int_t branch) const { return (branch == 1 ? fGrandMother1Source : fGrandMother2Source); }
+ Bool_t GetCheckBothChargesLegs(Int_t branch) const
+ {
return (branch == 1 ? fCheckBothChargesLeg1 : fCheckBothChargesLeg2);
}
- Bool_t GetCheckBothChargesMothers(Int_t branch) const {
+ Bool_t GetCheckBothChargesMothers(Int_t branch) const
+ {
return (branch == 1 ? fCheckBothChargesMother1 : fCheckBothChargesMother2);
}
- Bool_t GetCheckBothChargesGrandMothers(Int_t branch) const {
- return (branch == 1 ? fCheckBothChargesGrandMother1
- : fCheckBothChargesGrandMother2);
+ Bool_t GetCheckBothChargesGrandMothers(Int_t branch) const
+ {
+ return (branch == 1 ? fCheckBothChargesGrandMother1 : fCheckBothChargesGrandMother2);
}
- Bool_t GetCheckBothChargesGreatGrandMothers(Int_t branch) const {
- return (branch == 1 ? fCheckBothChargesGreatGrandMother1
- : fCheckBothChargesGreatGrandMother2);
+ Bool_t GetCheckBothChargesGreatGrandMothers(Int_t branch) const
+ {
+ return (branch == 1 ? fCheckBothChargesGreatGrandMother1 : fCheckBothChargesGreatGrandMother2);
}
EBranchRelation GetMothersRelation() const { return fMothersRelation; }
TMCProcess GetGEANTProcess() const { return fGEANTProcess; }
@@ -192,20 +189,19 @@ public:
// Double_t GetWeight(Double_t *const values) const {return (&fWeights ? fWeights.Eval(values[fType]) : fWeight); }
// Double_t GetWeight(Double_t *const values) const {return (fType>0 ? fWeights->Eval(values[fType]) : fWeight); }
// TODO: workaround
- Double_t GetWeight(Double_t* const values)
- const; // {return (fType>0 ? fWeights->Eval(values[fType]) : fWeight); }
+ Double_t GetWeight(Double_t* const values) const; // {return (fType>0 ? fWeights->Eval(values[fType]) : fWeight); }
Bool_t GetFillPureMCStep() const { return fFillPureMCStep; }
Bool_t IsSingleParticle() const { return fIsSingleParticle; }
- void SetIsDalitz(EDalitz dal, Int_t pdg = 0) {
+ void SetIsDalitz(EDalitz dal, Int_t pdg = 0)
+ {
fDalitz = dal;
fDalitzPdg = pdg;
}
EDalitz GetDalitz() const { return fDalitz; }
Int_t GetDalitzPdg() const { return fDalitzPdg; }
- static const char* fgkSignals[static_cast<int>(EDefinedSignal::kNSignals)]
- [2]; //default signal names+titles
+ static const char* fgkSignals[static_cast<int>(EDefinedSignal::kNSignals)][2]; //default signal names+titles
void Print(Option_t* option = "") const;
@@ -241,33 +237,28 @@ private:
ESource fGrandMother2Source = ESource::kDontCare; // grandmother 2 source
// Flaggs whether to check both charges of a given PDG code
- Bool_t fCheckBothChargesLeg1 = kFALSE; // check both charges of the legs pdg
- Bool_t fCheckBothChargesLeg2 = kFALSE; // leg2
- Bool_t fCheckBothChargesMother1 = kFALSE; // mother 1
- Bool_t fCheckBothChargesMother2 = kFALSE; // mother 2
- Bool_t fCheckBothChargesGrandMother1 = kFALSE; // grand mother 1
- Bool_t fCheckBothChargesGrandMother2 = kFALSE; // grand mother 2
- Bool_t fCheckBothChargesGreatGrandMother1 =
- kFALSE; // great grand mother 1
- Bool_t fCheckBothChargesGreatGrandMother2 =
- kFALSE; // great grand mother 2
- Bool_t fCheckGEANTProcess = kFALSE; // GEANT process
+ Bool_t fCheckBothChargesLeg1 = kFALSE; // check both charges of the legs pdg
+ Bool_t fCheckBothChargesLeg2 = kFALSE; // leg2
+ Bool_t fCheckBothChargesMother1 = kFALSE; // mother 1
+ Bool_t fCheckBothChargesMother2 = kFALSE; // mother 2
+ Bool_t fCheckBothChargesGrandMother1 = kFALSE; // grand mother 1
+ Bool_t fCheckBothChargesGrandMother2 = kFALSE; // grand mother 2
+ Bool_t fCheckBothChargesGreatGrandMother1 = kFALSE; // great grand mother 1
+ Bool_t fCheckBothChargesGreatGrandMother2 = kFALSE; // great grand mother 2
+ Bool_t fCheckGEANTProcess = kFALSE; // GEANT process
- EBranchRelation fMothersRelation = EBranchRelation::
- kUndefined; // mother 1&2 relation (same, different or whatever)
- TMCProcess fGEANTProcess =
- kPPrimary; // GEANT process ID (see roots TMCProcess)
- Double_t fWeight = 1.; // weighting factor
- TSpline3* fWeights = NULL; //> weighting factors
- UInt_t fType = 0; // lookup variable for weighting factors
+ EBranchRelation fMothersRelation = EBranchRelation::kUndefined; // mother 1&2 relation (same, different or whatever)
+ TMCProcess fGEANTProcess = kPPrimary; // GEANT process ID (see roots TMCProcess)
+ Double_t fWeight = 1.; // weighting factor
+ TSpline3* fWeights = NULL; //> weighting factors
+ UInt_t fType = 0; // lookup variable for weighting factors
// dalitz decays
EDalitz fDalitz = EDalitz::kWhoCares; // check for dalitz decay
Int_t fDalitzPdg = 0; // dalitz PDG
- Bool_t fFillPureMCStep = kFALSE; // check and fill the pure MC step
- Bool_t fIsSingleParticle =
- kFALSE; // single particle MC signal such as e,pi,K,p
+ Bool_t fFillPureMCStep = kFALSE; // check and fill the pure MC step
+ Bool_t fIsSingleParticle = kFALSE; // single particle MC signal such as e,pi,K,p
PairAnalysisSignalMC(const PairAnalysisSignalMC& c);
PairAnalysisSignalMC& operator=(const PairAnalysisSignalMC& c);
diff --git a/analysis/PWGDIL/dielectron/papaframework/PairAnalysisSpectrum.cxx b/analysis/PWGDIL/dielectron/papaframework/PairAnalysisSpectrum.cxx
index fa25438d1afce3e88041d2a4c22b35a6bf2995a8..44d2d83b46a63347b3b0ad87a3b17720a69b6148 100644
--- a/analysis/PWGDIL/dielectron/papaframework/PairAnalysisSpectrum.cxx
+++ b/analysis/PWGDIL/dielectron/papaframework/PairAnalysisSpectrum.cxx
@@ -45,40 +45,37 @@
///////////////////////////////////////////////////////////////////////////
//#include <TObject.h>
-#include <TEventList.h>
-#include <TROOT.h>
-#include <TTree.h>
+#include "PairAnalysisSpectrum.h"
#include <TCanvas.h>
-#include <TPad.h>
-
#include <TDatabasePDG.h>
+#include <TEventList.h>
#include <TF1.h>
#include <TFile.h>
#include <TFormula.h>
#include <TGraphErrors.h>
#include <TH1.h>
#include <TList.h>
+#include <TPad.h>
#include <TPaveText.h>
#include <TProfile.h>
#include <TProfile2D.h>
+#include <TROOT.h>
+#include <TTree.h>
#include <TVectorT.h>
#include "PairAnalysisHF.h"
#include "PairAnalysisHistos.h"
+#include "PairAnalysisSignalExt.h"
#include "PairAnalysisStyler.h"
#include "PairAnalysisVarManager.h"
-
-#include "PairAnalysisSignalExt.h"
-
-#include "PairAnalysisSpectrum.h"
-
ClassImp(PairAnalysisSpectrum)
//______________________________________________
PairAnalysisSpectrum::PairAnalysisSpectrum()
- : PairAnalysisSpectrum("spectrum", "title") {
+ : PairAnalysisSpectrum("spectrum", "title")
+{
///
/// Named Constructor
///
@@ -90,7 +87,8 @@ PairAnalysisSpectrum::PairAnalysisSpectrum(const char* name, const char* title)
, fRawInput(0)
, fMCInput(0)
, fMCTruth(0)
- , fExtractor(0) {
+ , fExtractor(0)
+{
///
/// Named Constructor
///
@@ -101,7 +99,8 @@ PairAnalysisSpectrum::PairAnalysisSpectrum(const char* name, const char* title)
}
//______________________________________________
-PairAnalysisSpectrum::~PairAnalysisSpectrum() {
+PairAnalysisSpectrum::~PairAnalysisSpectrum()
+{
///
/// Default Destructor
///
@@ -110,10 +109,8 @@ PairAnalysisSpectrum::~PairAnalysisSpectrum() {
}
//______________________________________________
-void PairAnalysisSpectrum::AddInput(TObjArray* raw,
- TString identifier,
- TObjArray* mc,
- TObjArray* truth) {
+void PairAnalysisSpectrum::AddInput(TObjArray* raw, TString identifier, TObjArray* mc, TObjArray* truth)
+{
///
/// add input array of histograms for signals extraction "raw" and
/// efficiency calculation "mc" and unique "idetifier" string
@@ -126,7 +123,8 @@ void PairAnalysisSpectrum::AddInput(TObjArray* raw,
}
//______________________________________________
-void PairAnalysisSpectrum::Init() {
+void PairAnalysisSpectrum::Init()
+{
///
/// Initialize the tree
///
@@ -135,7 +133,8 @@ void PairAnalysisSpectrum::Init() {
}
//______________________________________________
-void PairAnalysisSpectrum::Process() {
+void PairAnalysisSpectrum::Process()
+{
///
/// process the signal extraction
///
@@ -158,16 +157,12 @@ void PairAnalysisSpectrum::Process() {
while ((obj = nextRaw())) {
i++;
TObject::Info("Process", "Check Extraction for %s", fInputKeys[i].Data());
- TObject::Info("Process",
- "------------------------------------------------------------"
- "-----------");
+ TObject::Info("Process", "------------------------------------------------------------"
+ "-----------");
TObject::Info("Process", "Input type: %s \n", obj->ClassName());
if (fVarBinning) {
- TObject::Info("Process",
- "Binning provided for %s from %.3f to %.3f",
- fVar.Data(),
- fVarBinning->Min(),
+ TObject::Info("Process", "Binning provided for %s from %.3f to %.3f", fVar.Data(), fVarBinning->Min(),
fVarBinning->Max());
// fVarBinning->Print();
}
@@ -183,8 +178,7 @@ void PairAnalysisSpectrum::Process() {
}
// get extractor
- PairAnalysisSignalExt* sig =
- dynamic_cast<PairAnalysisSignalExt*>(fExtractor.At(i));
+ PairAnalysisSignalExt* sig = dynamic_cast<PairAnalysisSignalExt*>(fExtractor.At(i));
if (!sig) continue;
@@ -208,8 +202,7 @@ void PairAnalysisSpectrum::Process() {
objMCtruth = fMCTruth.At(i);
TObjArray* histArrMCt = NULL;
if (objMCtruth) {
- TObject::Info(
- "Process", "Input MC truth type: %s \n", objMCtruth->ClassName());
+ TObject::Info("Process", "Input MC truth type: %s \n", objMCtruth->ClassName());
histArrMCt = dynamic_cast<TObjArray*>(objMCtruth);
}
@@ -218,15 +211,12 @@ void PairAnalysisSpectrum::Process() {
if (!fVarBinning) {
// get raw input histograms
- if (!histArr && h)
- histArr = h->DrawSame("pM-wghtWeight",
- "nomc goff"); //NOTE w/o "can" it crashes
+ if (!histArr && h) histArr = h->DrawSame("pM-wghtWeight",
+ "nomc goff"); //NOTE w/o "can" it crashes
// if(!histArr && h) histArr = h->DrawSame("pM","can nomc goff"); //NOTE w/o "can" it crashes
// histArr->Print();
// get mc input histograms TODO: think about integration
- if (!histArrMC && hMC)
- histArrMC =
- hMC->DrawSame("pM", "onlymc eff goff"); //NOTE w/o "can" it crashes
+ if (!histArrMC && hMC) histArrMC = hMC->DrawSame("pM", "onlymc eff goff"); //NOTE w/o "can" it crashes
// process raw signal extraction
@@ -237,37 +227,35 @@ void PairAnalysisSpectrum::Process() {
if (sig->GetSignal() < 0.) continue;
// fill the tree
- fExt->setup = fInputKeys[i];
- fExt->setupId = i;
- fExt->poi = sig->GetParticleOfInterest();
- fExt->var = 1.; //integrated
- fExt->varE = 0.;
- fExt->s = sig->GetSignal();
- fExt->sE = sig->GetSignalError();
- fExt->b = sig->GetBackground();
- fExt->bE = sig->GetBackgroundError();
- fExt->sb = sig->GetSB();
- fExt->sbE = sig->GetSBError();
- fExt->sgn = sig->GetSignificance();
- fExt->sgnE = sig->GetSignificanceError();
- fExt->HistSignal =
- NULL; //dynamic_cast<TH1F*>(sig->GetSignalHistogram());
- fExt->eff = 1.; //TODO: calculate this
- fExt->effE = 0.; //TODO: calculate this
- fExt->signal = sig; //NULL;
- fExt->sref = 1.; //TODO: calculate this
- fExt->srefE = 0.; //TODO: calculate this
+ fExt->setup = fInputKeys[i];
+ fExt->setupId = i;
+ fExt->poi = sig->GetParticleOfInterest();
+ fExt->var = 1.; //integrated
+ fExt->varE = 0.;
+ fExt->s = sig->GetSignal();
+ fExt->sE = sig->GetSignalError();
+ fExt->b = sig->GetBackground();
+ fExt->bE = sig->GetBackgroundError();
+ fExt->sb = sig->GetSB();
+ fExt->sbE = sig->GetSBError();
+ fExt->sgn = sig->GetSignificance();
+ fExt->sgnE = sig->GetSignificanceError();
+ fExt->HistSignal = NULL; //dynamic_cast<TH1F*>(sig->GetSignalHistogram());
+ fExt->eff = 1.; //TODO: calculate this
+ fExt->effE = 0.; //TODO: calculate this
+ fExt->signal = sig; //NULL;
+ fExt->sref = 1.; //TODO: calculate this
+ fExt->srefE = 0.; //TODO: calculate this
fTree->Fill();
- } else {
+ }
+ else {
/// get raw 2D histogram
if (h && !h->SetCutClass(fInputKeys[i].Data())) continue;
- if (!histArr && h)
- histArr = h->DrawSame(Form("pM_%s", fVar.Data()), "nomc goff");
- TH2* histPM =
- (TH2*) sig->FindObject(histArr, PairAnalysis::EPairType::kSEPM);
+ if (!histArr && h) histArr = h->DrawSame(Form("pM_%s", fVar.Data()), "nomc goff");
+ TH2* histPM = (TH2*) sig->FindObject(histArr, PairAnalysis::EPairType::kSEPM);
if (!histPM) return;
TObjArray tmpArr;
@@ -276,8 +264,7 @@ void PairAnalysisSpectrum::Process() {
/// MC
TH1* histMC = NULL;
if (!histArrMC && hMC) {
- histArrMC = hMC->DrawSame(Form("p%s", fVar.Data()),
- "goff sel",
+ histArrMC = hMC->DrawSame(Form("p%s", fVar.Data()), "goff sel",
"phi"); // TODO: add search using fPOIpdg
}
if (histArrMC) {
@@ -285,11 +272,8 @@ void PairAnalysisSpectrum::Process() {
if (histArrMC->GetEntriesFast() < 2) return;
TH1* tmpMCden = (TH1*) histArrMC->At(1);
/// rebin and calculate efficiency
- histMC = tmpMCnom->Rebin(
- fVarBinning->GetNrows() - 1, "effMC", fVarBinning->GetMatrixArray());
- TH1* histMCden = tmpMCden->Rebin(fVarBinning->GetNrows() - 1,
- "effMCden",
- fVarBinning->GetMatrixArray());
+ histMC = tmpMCnom->Rebin(fVarBinning->GetNrows() - 1, "effMC", fVarBinning->GetMatrixArray());
+ TH1* histMCden = tmpMCden->Rebin(fVarBinning->GetNrows() - 1, "effMCden", fVarBinning->GetMatrixArray());
histMC->Divide(histMCden);
delete histMCden;
}
@@ -302,14 +286,10 @@ void PairAnalysisSpectrum::Process() {
TH1* tmpMCtrue = (TH1*) histArrMCt->At(0);
if (!tmpMCtrue) return;
/// rebin and calculate efficiency
- histMCtruth = tmpMCtrue->Rebin(fVarBinning->GetNrows() - 1,
- "sMCtrue",
- fVarBinning->GetMatrixArray());
+ histMCtruth = tmpMCtrue->Rebin(fVarBinning->GetNrows() - 1, "sMCtrue", fVarBinning->GetMatrixArray());
}
/// debug
- if (histMCtruth)
- TObject::Info("Process",
- "MCtruth reference histogram found and rebinned");
+ if (histMCtruth) TObject::Info("Process", "MCtruth reference histogram found and rebinned");
// loop over all bins
for (Int_t bin = 0; bin < fVarBinning->GetNrows() - 1; bin++) {
@@ -325,12 +305,7 @@ void PairAnalysisSpectrum::Process() {
Double_t fndLo = histPM->GetYaxis()->GetBinLowEdge(binLo);
Double_t fndHi = histPM->GetYaxis()->GetBinLowEdge(binHi + 1);
//printf("binning requested, found of %s: %.3f-%.3f, %.3f-%.3f \n", fVar.Data(), xLo,xHi, fndLo,fndHi );
- TObject::Info("Process",
- "Bin %d: %.3f < %s < %.3f",
- bin,
- fndLo,
- fVar.Data(),
- fndHi);
+ TObject::Info("Process", "Bin %d: %.3f < %s < %.3f", bin, fndLo, fVar.Data(), fndHi);
// fill array for signal extraction
for (Int_t ih = 0; ih < histArr->GetEntriesFast(); ih++) {
@@ -348,26 +323,25 @@ void PairAnalysisSpectrum::Process() {
if (TMath::IsNaN(sig->GetSignalError())) continue;
// fill the tree
- fExt->setup = fInputKeys[i];
- fExt->setupId = i;
- fExt->poi = sig->GetParticleOfInterest();
- fExt->var = (fndHi - fndLo) / 2 + fndLo; // center of the found bin
- fExt->varE = (fndHi - fndLo) / 2; // found bin width
- fExt->s = sig->GetSignal();
- fExt->sE = sig->GetSignalError();
- fExt->b = sig->GetBackground();
- fExt->bE = sig->GetBackgroundError();
- fExt->sb = sig->GetSB();
- fExt->sbE = sig->GetSBError();
- fExt->sgn = sig->GetSignificance();
- fExt->sgnE = sig->GetSignificanceError();
- fExt->HistSignal =
- NULL; //dynamic_cast<TH1F*>(sig->GetSignalHistogram());
- fExt->eff = (histMC ? histMC->GetBinContent(bin + 1) : 1.);
- fExt->effE = (histMC ? histMC->GetBinError(bin + 1) : 0.);
- fExt->signal = sig;
- fExt->sref = (histMCtruth ? histMCtruth->GetBinContent(bin + 1) : 0.);
- fExt->srefE = (histMCtruth ? histMCtruth->GetBinError(bin + 1) : 0.);
+ fExt->setup = fInputKeys[i];
+ fExt->setupId = i;
+ fExt->poi = sig->GetParticleOfInterest();
+ fExt->var = (fndHi - fndLo) / 2 + fndLo; // center of the found bin
+ fExt->varE = (fndHi - fndLo) / 2; // found bin width
+ fExt->s = sig->GetSignal();
+ fExt->sE = sig->GetSignalError();
+ fExt->b = sig->GetBackground();
+ fExt->bE = sig->GetBackgroundError();
+ fExt->sb = sig->GetSB();
+ fExt->sbE = sig->GetSBError();
+ fExt->sgn = sig->GetSignificance();
+ fExt->sgnE = sig->GetSignificanceError();
+ fExt->HistSignal = NULL; //dynamic_cast<TH1F*>(sig->GetSignalHistogram());
+ fExt->eff = (histMC ? histMC->GetBinContent(bin + 1) : 1.);
+ fExt->effE = (histMC ? histMC->GetBinError(bin + 1) : 0.);
+ fExt->signal = sig;
+ fExt->sref = (histMCtruth ? histMCtruth->GetBinContent(bin + 1) : 0.);
+ fExt->srefE = (histMCtruth ? histMCtruth->GetBinError(bin + 1) : 0.);
fTree->Fill();
@@ -395,9 +369,8 @@ void PairAnalysisSpectrum::Process() {
}
//______________________________________________
-void PairAnalysisSpectrum::DrawSpectrum(const char* varexp,
- const char* selection,
- Option_t* option) {
+void PairAnalysisSpectrum::DrawSpectrum(const char* varexp, const char* selection, Option_t* option)
+{
//
// TTree draw alias
//
@@ -416,10 +389,7 @@ void PairAnalysisSpectrum::DrawSpectrum(const char* varexp,
TString optString(option);
optString.ToLower();
- printf("Plot spectrum: '%s' \t selection: '%s' \t options: '%s' \n",
- varexp,
- selection,
- optString.Data());
+ printf("Plot spectrum: '%s' \t selection: '%s' \t options: '%s' \n", varexp, selection, optString.Data());
Bool_t optLegFull = optString.Contains("legf");
optString.ReplaceAll("legf", "");
Bool_t optLeg = optString.Contains("leg");
@@ -455,8 +425,7 @@ void PairAnalysisSpectrum::DrawSpectrum(const char* varexp,
/// canvas
ckey.ReplaceAll("/", "#"); /// canvas name does not allow '/'
TCanvas* c = NULL;
- if (optSamePad)
- c = gPad->GetCanvas();
+ if (optSamePad) c = gPad->GetCanvas();
else
c = (TCanvas*) gROOT->FindObject(ckey.Data());
if (!c) {
@@ -481,10 +450,9 @@ void PairAnalysisSpectrum::DrawSpectrum(const char* varexp,
leg = new TLegend(0. + gPad->GetLeftMargin() + gStyle->GetTickLength("Y"),
0. + gPad->GetBottomMargin() + gStyle->GetTickLength("X"),
1. - gPad->GetRightMargin() + gStyle->GetTickLength("Y"),
- 1. - gPad->GetTopMargin() + gStyle->GetTickLength("X"),
- GetName(),
- "nbNDC");
- } else if (optLeg && nobj) {
+ 1. - gPad->GetTopMargin() + gStyle->GetTickLength("X"), GetName(), "nbNDC");
+ }
+ else if (optLeg && nobj) {
leg = (TLegend*) prim->FindObject("TPave");
}
@@ -498,8 +466,7 @@ void PairAnalysisSpectrum::DrawSpectrum(const char* varexp,
optString.ReplaceAll("logy", "");
optString.ReplaceAll("logz", "");
- if (ndim < 3
- && !ckey.Contains("signal->")) { // build own histogram with labels
+ if (ndim < 3 && !ckey.Contains("signal->")) { // build own histogram with labels
// printf("try to get errors for %d dimensional input \n",ndim);
TString varkey(varexp);
@@ -544,10 +511,7 @@ void PairAnalysisSpectrum::DrawSpectrum(const char* varexp,
// else
if (!fkey.Contains("E")) {
varkey.Append(errkey.Prepend(":"));
- Info("Draw",
- " Appended '%s' by '%s' for error caluclation",
- varkey.Data(),
- errkey.Data());
+ Info("Draw", " Appended '%s' by '%s' for error caluclation", varkey.Data(), errkey.Data());
}
/// TTree:Draw command with graphics off to get errors
@@ -561,15 +525,9 @@ void PairAnalysisSpectrum::DrawSpectrum(const char* varexp,
/// setup the final tgraph WITH error bars
TGraphErrors* gr = 0x0;
- if (ndim > 1)
- gr = new TGraphErrors(fTree->GetSelectedRows(),
- fTree->GetV2(),
- fTree->GetV1(),
- 0,
- fTree->GetV3());
+ if (ndim > 1) gr = new TGraphErrors(fTree->GetSelectedRows(), fTree->GetV2(), fTree->GetV1(), 0, fTree->GetV3());
else
- gr = new TGraphErrors(
- fTree->GetSelectedRows(), fTree->GetV1(), xval, fTree->GetV2(), 0);
+ gr = new TGraphErrors(fTree->GetSelectedRows(), fTree->GetV1(), xval, fTree->GetV2(), 0);
delete[] xval;
if (!gr) {
@@ -596,11 +554,10 @@ void PairAnalysisSpectrum::DrawSpectrum(const char* varexp,
// sort x-values
gr->Sort();
- TGraphErrors* grE = NULL; // statistical
- TGraphErrors* grS = NULL; // systematic
- TGraphErrors* grC = NULL; // stat + syst
- if (optSyst
- && fVarBinning) { //TODO: implement systematic calculation w/o binning
+ TGraphErrors* grE = NULL; // statistical
+ TGraphErrors* grS = NULL; // systematic
+ TGraphErrors* grC = NULL; // stat + syst
+ if (optSyst && fVarBinning) { //TODO: implement systematic calculation w/o binning
grE = new TGraphErrors(); // statistical graph
grS = new TGraphErrors(); // systematics graph
grC = new TGraphErrors(); // systematics graph
@@ -640,15 +597,12 @@ void PairAnalysisSpectrum::DrawSpectrum(const char* varexp,
switch (fSystMthd) {
case ESystMethod::kBarlow:
// I. calc uncorr. stat. error from sub/superset w.r.t. first measurement
- uce = TMath::Sqrt(
- TMath::Abs(gye[j] * gye[j] - gye[first] * gye[first]));
+ uce = TMath::Sqrt(TMath::Abs(gye[j] * gye[j] - gye[first] * gye[first]));
// II. calc max. deviation w.r.t. mean y-value incl. 1sigma* 0.9 of I.
// NOTE: 0.9 can be change to a max value of 1->1sigma, 0.9 is more consevative
esys = TMath::Max(esys, TMath::Abs(ysys - gy[j]) - 0.9 * uce);
break;
- case ESystMethod::kSystMax:
- esys = TMath::Max(esys, TMath::Abs(ysys - gy[j]));
- break;
+ case ESystMethod::kSystMax: esys = TMath::Max(esys, TMath::Abs(ysys - gy[j])); break;
case ESystMethod::kSystRMS: esys += gy[j] * gy[j]; break;
}
// printf("bin error %f \t syst %f from abs %f \n",gye[j],esys, TMath::Abs( gy[j] ));
@@ -658,41 +612,35 @@ void PairAnalysisSpectrum::DrawSpectrum(const char* varexp,
switch (fSystMthd) {
case ESystMethod::kBarlow: /* nothing to be done */ break;
case ESystMethod::kSystMax: /* nothing to be done */ break;
- case ESystMethod::kSystRMS:
- esys =
- TMath::Sqrt(TMath::Abs(esys / (nsys ? nsys : 1) - ysys * ysys));
- break;
+ case ESystMethod::kSystRMS: esys = TMath::Sqrt(TMath::Abs(esys / (nsys ? nsys : 1) - ysys * ysys)); break;
}
// fill statistical and systematic graph values and errors
grE->SetPoint(ibin, xvar, ysys); // mean
grE->SetPointError(ibin, 0.0, gye[first]); // stat.uncert. of first set
- Double_t boxW = (fVarBinning->Max() - fVarBinning->Min())
- / (fVarBinning->GetNrows() - 1);
+ Double_t boxW = (fVarBinning->Max() - fVarBinning->Min()) / (fVarBinning->GetNrows() - 1);
grS->SetPoint(ibin, xvar, ysys); // mean
grS->SetPointError(ibin, boxW * 0.35, esys); // systematic value
// calculate err = sqrt(stat.**2 + syst**2)
grC->SetPoint(ibin, xvar, ysys); // mean
- grC->SetPointError(ibin,
- boxW * 0.35,
- TMath::Sqrt(esys * esys + gye[first] * gye[first]));
+ grC->SetPointError(ibin, boxW * 0.35, TMath::Sqrt(esys * esys + gye[first] * gye[first]));
// increase index counter
first += nsys;
ibin++;
} //next bin
// grS->Print();
- } else {
+ }
+ else {
grC = new TGraphErrors(*gr);
}
if (optPrint) grC->Print();
Info("Draw", " Draw object with options: '%s'", optString.Data());
- if (!PairAnalysisStyler::GetFirstHistogram())
- gr->Draw((optString + "A").Data());
+ if (!PairAnalysisStyler::GetFirstHistogram()) gr->Draw((optString + "A").Data());
else {
gr->Draw((optString + "same").Data());
@@ -703,17 +651,14 @@ void PairAnalysisSpectrum::DrawSpectrum(const char* varexp,
Int_t idx[1000];
TMath::Sort(npnts, val, idx, kTRUE); // kFALSE=increasing numbers
- Double_t errmin =
- (TMath::IsNaN(valE[idx[npnts - 1]]) ? 0. : valE[idx[npnts - 1]]);
+ Double_t errmin = (TMath::IsNaN(valE[idx[npnts - 1]]) ? 0. : valE[idx[npnts - 1]]);
Double_t min = (val[idx[npnts - 1]] - errmin) * 0.9;
Double_t tmpmin = PairAnalysisStyler::GetFirstHistogram()->GetMinimum();
- PairAnalysisStyler::GetFirstHistogram()->SetMinimum(
- (tmpmin < min ? tmpmin : min));
+ PairAnalysisStyler::GetFirstHistogram()->SetMinimum((tmpmin < min ? tmpmin : min));
Double_t errmax = (TMath::IsNaN(valE[idx[0]]) ? 0. : valE[idx[0]]);
Double_t max = (val[idx[0]] + errmax) * 1.1;
Double_t tmpmax = PairAnalysisStyler::GetFirstHistogram()->GetMaximum();
- PairAnalysisStyler::GetFirstHistogram()->SetMaximum(
- (tmpmax > max ? tmpmax : max));
+ PairAnalysisStyler::GetFirstHistogram()->SetMaximum((tmpmax > max ? tmpmax : max));
}
// draw systemtaic graph ontop
@@ -739,8 +684,8 @@ void PairAnalysisSpectrum::DrawSpectrum(const char* varexp,
fSignal = grC;
PairAnalysisStyler::Style(fSignal, nobj);
-
- } else {
+ }
+ else {
// execute tree draw command
fTree->Draw(varexp, selection, optString.Data());
fprintf(stderr, "use plain TTree::Draw command \n");
@@ -758,8 +703,7 @@ void PairAnalysisSpectrum::DrawSpectrum(const char* varexp,
TString xt = "";
TString yt = "Entries";
xt = ((TObjString*) arr->At(0))->GetString();
- if (xt.EqualTo("sb"))
- xt = PairAnalysisSignalExt::GetValueName(3);
+ if (xt.EqualTo("sb")) xt = PairAnalysisSignalExt::GetValueName(3);
else if (xt.EqualTo("s"))
xt = PairAnalysisSignalExt::GetValueName(0);
else if (xt.EqualTo("b"))
@@ -767,23 +711,20 @@ void PairAnalysisSpectrum::DrawSpectrum(const char* varexp,
else if (xt.EqualTo("sgn"))
xt = PairAnalysisSignalExt::GetValueName(2);
else if (xt.EqualTo("var"))
- xt = Form("%s %s",
- PairAnalysisVarManager::GetValueLabel(varx),
- PairAnalysisVarManager::GetValueUnit(varx));
+ xt = Form("%s %s", PairAnalysisVarManager::GetValueLabel(varx), PairAnalysisVarManager::GetValueUnit(varx));
else if (xt.Contains("var")) {
- xt.ReplaceAll(
- "varE", Form("#Delta%s", PairAnalysisVarManager::GetValueLabel(varx)));
+ xt.ReplaceAll("varE", Form("#Delta%s", PairAnalysisVarManager::GetValueLabel(varx)));
xt.ReplaceAll("var", PairAnalysisVarManager::GetValueLabel(varx));
}
if (arr->GetEntriesFast() < 2) {
PairAnalysisStyler::GetFirstHistogram()->SetXTitle(xt.Data());
PairAnalysisStyler::GetFirstHistogram()->SetYTitle(yt.Data());
- } else {
+ }
+ else {
PairAnalysisStyler::GetFirstHistogram()->SetYTitle(xt.Data());
xt = ((TObjString*) arr->At(1))->GetString();
- if (xt.EqualTo("sb"))
- xt = PairAnalysisSignalExt::GetValueName(3);
+ if (xt.EqualTo("sb")) xt = PairAnalysisSignalExt::GetValueName(3);
else if (xt.EqualTo("s"))
xt = PairAnalysisSignalExt::GetValueName(0);
else if (xt.EqualTo("b"))
@@ -791,13 +732,9 @@ void PairAnalysisSpectrum::DrawSpectrum(const char* varexp,
else if (xt.EqualTo("sgn"))
xt = PairAnalysisSignalExt::GetValueName(2);
else if (xt.EqualTo("var"))
- xt = Form("%s %s",
- PairAnalysisVarManager::GetValueLabel(varx),
- PairAnalysisVarManager::GetValueUnit(varx));
+ xt = Form("%s %s", PairAnalysisVarManager::GetValueLabel(varx), PairAnalysisVarManager::GetValueUnit(varx));
else if (xt.Contains("var")) {
- xt.ReplaceAll(
- "varE",
- Form("#Delta%s", PairAnalysisVarManager::GetValueLabel(varx)));
+ xt.ReplaceAll("varE", Form("#Delta%s", PairAnalysisVarManager::GetValueLabel(varx)));
xt.ReplaceAll("var", PairAnalysisVarManager::GetValueLabel(varx));
}
PairAnalysisStyler::GetFirstHistogram()->SetXTitle(xt.Data());
@@ -811,17 +748,14 @@ void PairAnalysisSpectrum::DrawSpectrum(const char* varexp,
if (carr) delete carr;
/// set ndivisions
- if (fVarBinning)
- PairAnalysisStyler::GetFirstHistogram()->SetAxisRange(
- fVarBinning->Min(), fVarBinning->Max(), "X");
+ if (fVarBinning) PairAnalysisStyler::GetFirstHistogram()->SetAxisRange(fVarBinning->Min(), fVarBinning->Max(), "X");
// PairAnalysisStyler::GetFirstHistogram()->GetXaxis()->SetNdivisions(, 0, 0, kFALSE);
// legend
if (leg) {
- PairAnalysisStyler::SetLegendAttributes(
- leg, optLegFull); // coordinates, margins, fillstyle, fontsize
- if (!nobj) leg->Draw(); // only draw the legend once
+ PairAnalysisStyler::SetLegendAttributes(leg, optLegFull); // coordinates, margins, fillstyle, fontsize
+ if (!nobj) leg->Draw(); // only draw the legend once
/// gPad->GetCanvas()->Update();
}
@@ -830,7 +764,8 @@ void PairAnalysisSpectrum::DrawSpectrum(const char* varexp,
}
//______________________________________________
-void PairAnalysisSpectrum::Write() {
+void PairAnalysisSpectrum::Write()
+{
///
/// write to output file
///
@@ -842,7 +777,8 @@ void PairAnalysisSpectrum::Write() {
}
//______________________________________________
-void PairAnalysisSpectrum::Fit(TString drawoption) {
+void PairAnalysisSpectrum::Fit(TString drawoption)
+{
///
/// Fit the spectrum according to the selected method
///
@@ -866,8 +802,7 @@ void PairAnalysisSpectrum::Fit(TString drawoption) {
return;
}
- PairAnalysisStyler::Style(fFuncSigBack,
- static_cast<Int_t>(PairAnalysisStyler::Eidx::kFit));
+ PairAnalysisStyler::Style(fFuncSigBack, static_cast<Int_t>(PairAnalysisStyler::Eidx::kFit));
fFuncSigBack->SetLineColor(fSignal->GetLineColor());
// fFuncSigBack->SetLineStyle(kDashed);
diff --git a/analysis/PWGDIL/dielectron/papaframework/PairAnalysisSpectrum.h b/analysis/PWGDIL/dielectron/papaframework/PairAnalysisSpectrum.h
index b1020e4b05f9f16d46000d5b903f9894b3891464..066d632ae8b6a247ca0c25916786267a79e83513 100644
--- a/analysis/PWGDIL/dielectron/papaframework/PairAnalysisSpectrum.h
+++ b/analysis/PWGDIL/dielectron/papaframework/PairAnalysisSpectrum.h
@@ -15,14 +15,12 @@
#include <TString.h>
#include <TVectorT.h>
+#include "PairAnalysis.h"
+#include "PairAnalysisFunction.h"
#include "PairAnalysisHF.h"
#include "PairAnalysisHistos.h"
-
-#include "PairAnalysisFunction.h"
#include "PairAnalysisSignalExt.h"
-#include "PairAnalysis.h"
-
class TList;
class TObjArray;
class TFormula;
@@ -50,16 +48,20 @@ public:
PairAnalysisSignalExt* signal = NULL; // Signal extraction
Double_t sref = 0.; // mc truth signal
Double_t srefE = 0.; // mc truth signal error
- ClassDef(
- Extraction,
- 1) // mini object that holds members of the PairAnalysisSpectrum TTree
+ ClassDef(Extraction,
+ 1) // mini object that holds members of the PairAnalysisSpectrum TTree
};
ClassImp(Extraction)
class PairAnalysisSpectrum : public PairAnalysisFunction {
public:
- enum class ESystMethod { kBarlow = 0, kSystMax, kSystRMS };
+ enum class ESystMethod
+ {
+ kBarlow = 0,
+ kSystMax,
+ kSystRMS
+ };
PairAnalysisSpectrum();
PairAnalysisSpectrum(const char* name, const char* title);
@@ -68,26 +70,20 @@ public:
// General Setter
- void SetVariable(TString varType, TVectorD* const binLimits) {
+ void SetVariable(TString varType, TVectorD* const binLimits)
+ {
fVar = varType;
fVarBinning = binLimits;
}
void SetSystMethod(ESystMethod mthd) { fSystMthd = mthd; }
// Input
- void AddInput(TObjArray* raw,
- TString identifier,
- TObjArray* mc = NULL,
- TObjArray* truth = NULL);
+ void AddInput(TObjArray* raw, TString identifier, TObjArray* mc = NULL, TObjArray* truth = NULL);
void AddMCInput(PairAnalysisHistos* hf) { fMCInput.Add(hf); }
- void AddExtractor(PairAnalysisSignalExt* sig) {
- fExtractor.Add((PairAnalysisSignalExt*) sig->Clone());
- }
+ void AddExtractor(PairAnalysisSignalExt* sig) { fExtractor.Add((PairAnalysisSignalExt*) sig->Clone()); }
// Spectrum
- virtual void DrawSpectrum(const char* varexp,
- const char* selection = "",
- Option_t* option = "");
+ virtual void DrawSpectrum(const char* varexp, const char* selection = "", Option_t* option = "");
Int_t Write(const char*, Int_t, Int_t) { return -1; }
Int_t Write(const char*, Int_t, Int_t) const { return -1; }
@@ -107,16 +103,14 @@ private:
TVectorD* fVarBinning = NULL; // variable binning
// calculation
- ESystMethod fSystMthd =
- ESystMethod::kSystMax; // method for systematic uncertainty calculation
+ ESystMethod fSystMthd = ESystMethod::kSystMax; // method for systematic uncertainty calculation
// input
TString fInputKeys[100]; // keys to identify the extraction
- TList fRawInput; // list of input objects for signals (HF, Ntuple, THnSparse)
- TList fMCInput; // list of input objects for mc (HF, Ntuple, THnSparse)
- TList fMCTruth; // list of input objects for mc truth
- TList
- fExtractor; // list of input objects for signal extraction objects (Ext,Func)
+ TList fRawInput; // list of input objects for signals (HF, Ntuple, THnSparse)
+ TList fMCInput; // list of input objects for mc (HF, Ntuple, THnSparse)
+ TList fMCTruth; // list of input objects for mc truth
+ TList fExtractor; // list of input objects for signal extraction objects (Ext,Func)
// output
TTree* fTree = NULL; // tree output
diff --git a/analysis/PWGDIL/dielectron/papaframework/PairAnalysisStyleDefs.h b/analysis/PWGDIL/dielectron/papaframework/PairAnalysisStyleDefs.h
index cf5bde5ddf7909927e214f6c67a8cbbcda24d968..2573483660be578408cc02c7fe290ba45534c24e 100644
--- a/analysis/PWGDIL/dielectron/papaframework/PairAnalysisStyleDefs.h
+++ b/analysis/PWGDIL/dielectron/papaframework/PairAnalysisStyleDefs.h
@@ -10,8 +10,6 @@
// //
///////////////////////////////////////////////////////////////////////////////////////////
-#include "PairAnalysisStyler.h"
-
#include <Rtypes.h>
#include <TAttMarker.h>
#include <TColor.h>
@@ -19,7 +17,10 @@
#include <TLegendEntry.h>
#include <TStyle.h>
-namespace PairAnalysisStyler {
+#include "PairAnalysisStyler.h"
+
+namespace PairAnalysisStyler
+{
/* enum class Eidx { kRaw=100, kBgrd, kSig, kFit, kCocktail, kNidx }; */
/* enum class EfillMark { kOpenMarker=1, kFullMarker, kDontCare }; */
@@ -27,61 +28,30 @@ namespace PairAnalysisStyler {
/* enum class Epalette { kDefault=0, kGoodBad }; */
static Int_t fCol[static_cast<Int_t>(PairAnalysisStyler::Eidx::kNidx)
- - static_cast<Int_t>(PairAnalysisStyler::Eidx::kRaw)] =
- {kBlack, kTeal - 8, kBlack, kTeal - 7, kTeal - 7};
+ - static_cast<Int_t>(PairAnalysisStyler::Eidx::kRaw)] = {kBlack, kTeal - 8, kBlack, kTeal - 7,
+ kTeal - 7};
static Int_t fMrk[static_cast<Int_t>(PairAnalysisStyler::Eidx::kNidx)
- - static_cast<Int_t>(PairAnalysisStyler::Eidx::kRaw)] =
- {kFullCircle, kOpenCircle, kOpenCircle, kDot, kDot};
+ - static_cast<Int_t>(PairAnalysisStyler::Eidx::kRaw)] = {kFullCircle, kOpenCircle, kOpenCircle,
+ kDot, kDot};
static Double_t fSze[static_cast<Int_t>(PairAnalysisStyler::Eidx::kNidx)
- - static_cast<Int_t>(PairAnalysisStyler::Eidx::kRaw)] =
- {1., 1., 1., 1., 1.};
+ - static_cast<Int_t>(PairAnalysisStyler::Eidx::kRaw)] = {1., 1., 1., 1., 1.};
static Int_t fLne[static_cast<Int_t>(PairAnalysisStyler::Eidx::kNidx)
- - static_cast<Int_t>(PairAnalysisStyler::Eidx::kRaw)] =
- {kSolid, kSolid, kSolid, kSolid, kSolid};
+ - static_cast<Int_t>(PairAnalysisStyler::Eidx::kRaw)] = {kSolid, kSolid, kSolid, kSolid, kSolid};
static Double_t fWdt[static_cast<Int_t>(PairAnalysisStyler::Eidx::kNidx)
- - static_cast<Int_t>(PairAnalysisStyler::Eidx::kRaw)] =
- {2., 2., 2., 2., 2.};
+ - static_cast<Int_t>(PairAnalysisStyler::Eidx::kRaw)] = {2., 2., 2., 2., 2.};
static Int_t fFll[static_cast<Int_t>(PairAnalysisStyler::Eidx::kNidx)
- - static_cast<Int_t>(PairAnalysisStyler::Eidx::kRaw)] =
- {0, 0, 0, 0, 0}; //kFEmpty
+ - static_cast<Int_t>(PairAnalysisStyler::Eidx::kRaw)] = {0, 0, 0, 0, 0}; //kFEmpty
- static Int_t Marker[] = {kFullCircle,
- kFullDiamond,
- kFullSquare,
- kFullCross,
- kFullStar,
- kMultiply,
- kPlus,
- kStar,
- kOpenCircle,
- kOpenDiamond,
- kOpenSquare,
- kOpenCross,
- kOpenStar}; // kNMaxMarker
+ static Int_t Marker[] = {kFullCircle, kFullDiamond, kFullSquare, kFullCross, kFullStar, kMultiply, kPlus,
+ kStar, kOpenCircle, kOpenDiamond, kOpenSquare, kOpenCross, kOpenStar}; // kNMaxMarker
- static Int_t Line[] = {kSolid,
- kDashed,
- kDotted,
+ static Int_t Line[] = {kSolid, kDashed, kDotted,
// 9,
kDashDotted}; // kNMaxLine
- static Int_t Color[] = {kRed - 4,
- kBlue - 4,
- kBlack,
- kGreen + 1,
- kAzure + 1,
- kOrange + 2,
- kSpring + 4,
- kViolet + 1,
- kOrange,
- kGray + 1,
- kRed + 2,
- kCyan + 1,
- kGreen + 3,
- kBlue + 1,
- kMagenta + 1,
- kOrange - 6,
- kCyan - 2}; // kNMaxColor
+ static Int_t Color[] = {kRed - 4, kBlue - 4, kBlack, kGreen + 1, kAzure + 1, kOrange + 2,
+ kSpring + 4, kViolet + 1, kOrange, kGray + 1, kRed + 2, kCyan + 1,
+ kGreen + 3, kBlue + 1, kMagenta + 1, kOrange - 6, kCyan - 2}; // kNMaxColor
static Int_t Fill[] = {-1};
diff --git a/analysis/PWGDIL/dielectron/papaframework/PairAnalysisStyler.cxx b/analysis/PWGDIL/dielectron/papaframework/PairAnalysisStyler.cxx
index ea545b2501c7be5e453ec5c901a418216a5f27ee..46311a54913fb17b7ae2b9181cb7005d3993f44c 100644
--- a/analysis/PWGDIL/dielectron/papaframework/PairAnalysisStyler.cxx
+++ b/analysis/PWGDIL/dielectron/papaframework/PairAnalysisStyler.cxx
@@ -16,6 +16,8 @@
// //
///////////////////////////////////////////////////////////////////////////
+#include "PairAnalysisStyler.h"
+
#include <TAttFill.h>
#include <TAttLine.h>
#include <TAttMarker.h>
@@ -34,10 +36,10 @@
#include <TStyle.h>
#include "PairAnalysisStyleDefs.h"
-#include "PairAnalysisStyler.h"
//_____________________________________________________________________________
-void PairAnalysisStyler::SetStyle(TStyle* userStyle) {
+void PairAnalysisStyler::SetStyle(TStyle* userStyle)
+{
//
// set and load user defined style
//
@@ -46,7 +48,8 @@ void PairAnalysisStyler::SetStyle(TStyle* userStyle) {
}
//_____________________________________________________________________________
-void PairAnalysisStyler::LoadStyle() {
+void PairAnalysisStyler::LoadStyle()
+{
//
// load style
//
@@ -63,7 +66,8 @@ void PairAnalysisStyler::LoadStyle() {
if (fUserDielStyle) {
fUserDielStyle->cd();
gROOT->ForceStyle();
- } else {
+ }
+ else {
Int_t font = 42;
Int_t bgrdcolor = 0; // set to -1 for transparaent, will causes warnings
@@ -140,8 +144,7 @@ void PairAnalysisStyler::LoadStyle() {
// For the statistics box:
defaultSty->SetOptFile(0);
- defaultSty->SetOptStat(
- 0); // To display the mean and RMS: SetOptStat("mr");
+ defaultSty->SetOptStat(0); // To display the mean and RMS: SetOptStat("mr");
// defaultSty->SetOptStat("n"); // only name
defaultSty->SetStatColor(kWhite);
defaultSty->SetStatFont(font);
@@ -169,8 +172,7 @@ void PairAnalysisStyler::LoadStyle() {
// defaultSty->SetTitleY(0.985); // Set the position of the title box
defaultSty->SetTitleStyle(kFEmpty);
// defaultSty->SetTitleBorderSize(2);
- defaultSty->SetPaintTextFormat(
- ".3f"); // format if you plot with TEXT option
+ defaultSty->SetPaintTextFormat(".3f"); // format if you plot with TEXT option
// for Paves and boxes
// defaultSty->SetFillColor(bgrdcolor); // this makes palettes unicolored
@@ -203,10 +205,8 @@ void PairAnalysisStyler::LoadStyle() {
defaultSty->SetAxisColor(1, "XYZ");
// defaultSty->SetStripDecimals(kTRUE);
// defaultSty->SetTickLength(0.03, "XYZ");
- defaultSty->SetNdivisions(
- 810, "XYZ"); // defaultSty->SetNdivisions(505, "XYZ");
- defaultSty->SetPadTickX(
- 1); // To get tick marks on the opposite side of the frame
+ defaultSty->SetNdivisions(810, "XYZ"); // defaultSty->SetNdivisions(505, "XYZ");
+ defaultSty->SetPadTickX(1); // To get tick marks on the opposite side of the frame
defaultSty->SetPadTickY(1);
// Change for log plots:
@@ -259,7 +259,8 @@ void PairAnalysisStyler::LoadStyle() {
}
//_____________________________________________________________________________
-void PairAnalysisStyler::Style(TObject* obj, Int_t idx) {
+void PairAnalysisStyler::Style(TObject* obj, Int_t idx)
+{
//
// style object according to index
//
@@ -289,27 +290,21 @@ void PairAnalysisStyler::Style(TObject* obj, Int_t idx) {
// marker attributes
if (obj->InheritsFrom(TAttMarker::Class())) {
if (idx >= 100) { // predefined styles
- dynamic_cast<TAttMarker*>(obj)->SetMarkerSize(
- fSze[idx - static_cast<Int_t>(Eidx::kRaw)]);
- dynamic_cast<TAttMarker*>(obj)->SetMarkerStyle(
- fMrk[idx - static_cast<Int_t>(Eidx::kRaw)]);
- dynamic_cast<TAttMarker*>(obj)->SetMarkerColor(
- fCol[idx - static_cast<Int_t>(Eidx::kRaw)]);
- } else {
+ dynamic_cast<TAttMarker*>(obj)->SetMarkerSize(fSze[idx - static_cast<Int_t>(Eidx::kRaw)]);
+ dynamic_cast<TAttMarker*>(obj)->SetMarkerStyle(fMrk[idx - static_cast<Int_t>(Eidx::kRaw)]);
+ dynamic_cast<TAttMarker*>(obj)->SetMarkerColor(fCol[idx - static_cast<Int_t>(Eidx::kRaw)]);
+ }
+ else {
dynamic_cast<TAttMarker*>(obj)->SetMarkerSize(1.5);
- dynamic_cast<TAttMarker*>(obj)->SetMarkerStyle(
- Marker[idx % static_cast<Int_t>(Estyle::kNMaxMarker)]);
- dynamic_cast<TAttMarker*>(obj)->SetMarkerColor(
- Color[idx % static_cast<Int_t>(Estyle::kNMaxColor)]);
- if (idx >= static_cast<Int_t>(Estyle::kNMaxColor)
- && idx < static_cast<Int_t>(Estyle::kNMaxColor) * 2) {
+ dynamic_cast<TAttMarker*>(obj)->SetMarkerStyle(Marker[idx % static_cast<Int_t>(Estyle::kNMaxMarker)]);
+ dynamic_cast<TAttMarker*>(obj)->SetMarkerColor(Color[idx % static_cast<Int_t>(Estyle::kNMaxColor)]);
+ if (idx >= static_cast<Int_t>(Estyle::kNMaxColor) && idx < static_cast<Int_t>(Estyle::kNMaxColor) * 2) {
idx = idx % static_cast<Int_t>(Estyle::kNMaxColor);
- dynamic_cast<TAttMarker*>(obj)->SetMarkerColor(
- TColor::GetColorDark(Color[idx]));
- } else if (idx >= static_cast<Int_t>(Estyle::kNMaxColor) * 2) {
+ dynamic_cast<TAttMarker*>(obj)->SetMarkerColor(TColor::GetColorDark(Color[idx]));
+ }
+ else if (idx >= static_cast<Int_t>(Estyle::kNMaxColor) * 2) {
idx = idx % (2 * static_cast<Int_t>(Estyle::kNMaxColor));
- dynamic_cast<TAttMarker*>(obj)->SetMarkerColor(
- TColor::GetColorBright(Color[idx]));
+ dynamic_cast<TAttMarker*>(obj)->SetMarkerColor(TColor::GetColorBright(Color[idx]));
}
}
}
@@ -318,27 +313,21 @@ void PairAnalysisStyler::Style(TObject* obj, Int_t idx) {
if (obj->InheritsFrom(TAttLine::Class())) {
// printf("index %d for %s \n",idx,obj->GetName());
if (idx >= 100) { // predefined styles
- dynamic_cast<TAttLine*>(obj)->SetLineWidth(
- fWdt[idx - static_cast<Int_t>(Eidx::kRaw)]);
- dynamic_cast<TAttLine*>(obj)->SetLineStyle(
- fLne[idx - static_cast<Int_t>(Eidx::kRaw)]);
- dynamic_cast<TAttLine*>(obj)->SetLineColor(
- fCol[idx - static_cast<Int_t>(Eidx::kRaw)]);
- } else {
+ dynamic_cast<TAttLine*>(obj)->SetLineWidth(fWdt[idx - static_cast<Int_t>(Eidx::kRaw)]);
+ dynamic_cast<TAttLine*>(obj)->SetLineStyle(fLne[idx - static_cast<Int_t>(Eidx::kRaw)]);
+ dynamic_cast<TAttLine*>(obj)->SetLineColor(fCol[idx - static_cast<Int_t>(Eidx::kRaw)]);
+ }
+ else {
dynamic_cast<TAttLine*>(obj)->SetLineWidth(2);
- dynamic_cast<TAttLine*>(obj)->SetLineStyle(
- Line[idx % static_cast<Int_t>(Estyle::kNMaxLine)]);
- dynamic_cast<TAttLine*>(obj)->SetLineColor(
- Color[idx % static_cast<Int_t>(Estyle::kNMaxColor)]);
- if (idx >= static_cast<Int_t>(Estyle::kNMaxColor)
- && idx < static_cast<Int_t>(Estyle::kNMaxColor) * 2) {
+ dynamic_cast<TAttLine*>(obj)->SetLineStyle(Line[idx % static_cast<Int_t>(Estyle::kNMaxLine)]);
+ dynamic_cast<TAttLine*>(obj)->SetLineColor(Color[idx % static_cast<Int_t>(Estyle::kNMaxColor)]);
+ if (idx >= static_cast<Int_t>(Estyle::kNMaxColor) && idx < static_cast<Int_t>(Estyle::kNMaxColor) * 2) {
idx = idx % static_cast<Int_t>(Estyle::kNMaxColor);
- dynamic_cast<TAttLine*>(obj)->SetLineColor(
- TColor::GetColorDark(Color[idx]));
- } else if (idx >= static_cast<Int_t>(Estyle::kNMaxColor) * 2) {
+ dynamic_cast<TAttLine*>(obj)->SetLineColor(TColor::GetColorDark(Color[idx]));
+ }
+ else if (idx >= static_cast<Int_t>(Estyle::kNMaxColor) * 2) {
idx = idx % (2 * static_cast<Int_t>(Estyle::kNMaxColor));
- dynamic_cast<TAttLine*>(obj)->SetLineColor(
- TColor::GetColorBright(Color[idx]));
+ dynamic_cast<TAttLine*>(obj)->SetLineColor(TColor::GetColorBright(Color[idx]));
}
}
}
@@ -346,25 +335,19 @@ void PairAnalysisStyler::Style(TObject* obj, Int_t idx) {
// fill attributes, only used if fill style is set (default: not)
if (obj->InheritsFrom(TAttFill::Class())) {
// printf("fill style %d for index: %d \n",Fill[0],idx);
- if (idx >= 100
- && fFll[idx - static_cast<Int_t>(Eidx::kRaw)]
- >= 0) { // predefined styles
- dynamic_cast<TAttFill*>(obj)->SetFillColor(
- fCol[idx - static_cast<Int_t>(Eidx::kRaw)]);
- dynamic_cast<TAttFill*>(obj)->SetFillStyle(
- fFll[idx - static_cast<Int_t>(Eidx::kRaw)]);
- } else if (Fill[0] >= 0) {
- dynamic_cast<TAttFill*>(obj)->SetFillColor(
- Color[idx % static_cast<Int_t>(Estyle::kNMaxColor)]);
- if (idx >= static_cast<Int_t>(Estyle::kNMaxColor)
- && idx < static_cast<Int_t>(Estyle::kNMaxColor) * 2) {
+ if (idx >= 100 && fFll[idx - static_cast<Int_t>(Eidx::kRaw)] >= 0) { // predefined styles
+ dynamic_cast<TAttFill*>(obj)->SetFillColor(fCol[idx - static_cast<Int_t>(Eidx::kRaw)]);
+ dynamic_cast<TAttFill*>(obj)->SetFillStyle(fFll[idx - static_cast<Int_t>(Eidx::kRaw)]);
+ }
+ else if (Fill[0] >= 0) {
+ dynamic_cast<TAttFill*>(obj)->SetFillColor(Color[idx % static_cast<Int_t>(Estyle::kNMaxColor)]);
+ if (idx >= static_cast<Int_t>(Estyle::kNMaxColor) && idx < static_cast<Int_t>(Estyle::kNMaxColor) * 2) {
idx = idx % static_cast<Int_t>(Estyle::kNMaxColor);
- dynamic_cast<TAttFill*>(obj)->SetFillColor(
- TColor::GetColorDark(Color[idx]));
- } else if (idx >= static_cast<Int_t>(Estyle::kNMaxColor) * 2) {
+ dynamic_cast<TAttFill*>(obj)->SetFillColor(TColor::GetColorDark(Color[idx]));
+ }
+ else if (idx >= static_cast<Int_t>(Estyle::kNMaxColor) * 2) {
idx = idx % (2 * static_cast<Int_t>(Estyle::kNMaxColor));
- dynamic_cast<TAttFill*>(obj)->SetFillColor(
- TColor::GetColorBright(Color[idx]));
+ dynamic_cast<TAttFill*>(obj)->SetFillColor(TColor::GetColorBright(Color[idx]));
}
dynamic_cast<TAttFill*>(obj)->SetFillStyle(Fill[0]);
}
@@ -372,7 +355,8 @@ void PairAnalysisStyler::Style(TObject* obj, Int_t idx) {
}
//_____________________________________________________________________________
-void PairAnalysisStyler::SetForceLineStyle(Int_t line) {
+void PairAnalysisStyler::SetForceLineStyle(Int_t line)
+{
//
// force a certain line style
//
@@ -382,7 +366,8 @@ void PairAnalysisStyler::SetForceLineStyle(Int_t line) {
}
//_____________________________________________________________________________
-void PairAnalysisStyler::SetForceColor(Int_t color) {
+void PairAnalysisStyler::SetForceColor(Int_t color)
+{
//
// force a certain color
//
@@ -392,20 +377,20 @@ void PairAnalysisStyler::SetForceColor(Int_t color) {
}
//_____________________________________________________________________________
-void PairAnalysisStyler::SetForceFillStyle(Int_t fill) {
+void PairAnalysisStyler::SetForceFillStyle(Int_t fill)
+{
//
// force a certain color
//
- for (Int_t i = 0;
- i < (static_cast<Int_t>(Eidx::kNidx) - static_cast<Int_t>(Eidx::kRaw));
- i++) {
+ for (Int_t i = 0; i < (static_cast<Int_t>(Eidx::kNidx) - static_cast<Int_t>(Eidx::kRaw)); i++) {
fFll[i] = fill;
}
Fill[0] = fill;
}
//_____________________________________________________________________________
-void PairAnalysisStyler::SetForceMarkerFillStyle(EfillMark fill) {
+void PairAnalysisStyler::SetForceMarkerFillStyle(EfillMark fill)
+{
//
// force a certain marker fill style
//
@@ -460,13 +445,9 @@ void PairAnalysisStyler::SetForceMarkerFillStyle(EfillMark fill) {
//_____________________________________________________________________________
-void PairAnalysisStyler::SetStyle(Eidx idx,
- Int_t col,
- Int_t marker,
- Double_t size,
- Int_t line,
- Double_t width,
- Int_t fill) {
+void PairAnalysisStyler::SetStyle(Eidx idx, Int_t col, Int_t marker, Double_t size, Int_t line, Double_t width,
+ Int_t fill)
+{
//
// change predefined style "idx" according to arguments
//
@@ -483,7 +464,8 @@ void PairAnalysisStyler::SetStyle(Eidx idx,
void PairAnalysisStyler::SetLegendAlign(UInt_t align) { fLegAlign = align; }
//_____________________________________________________________________________
-void PairAnalysisStyler::SetLegendAttributes(TLegend* leg, Bool_t fill) {
+void PairAnalysisStyler::SetLegendAttributes(TLegend* leg, Bool_t fill)
+{
//
// set/update legend cooordinates according to alignement (stored in uniqueID)
// and "fill" a legend with white background color
@@ -556,15 +538,16 @@ void PairAnalysisStyler::SetLegendAttributes(TLegend* leg, Bool_t fill) {
if (fLegAlign == 12 || fLegAlign == 22) { //top
leg->SetY2(1. - gPad->GetTopMargin() - gStyle->GetTickLength("X"));
leg->SetY1(leg->GetY2() - maxhgth);
- } else { // bottom
+ }
+ else { // bottom
leg->SetY1(0. + gPad->GetBottomMargin() + gStyle->GetTickLength("X"));
leg->SetY2(leg->GetY1() + maxhgth);
}
- if (fLegAlign == 22 || fLegAlign == 21) { //right
- leg->SetX2(1. - gPad->GetRightMargin()
- - gStyle->GetTickLength("Y") * 1.0); //x2.0 ticklength
+ if (fLegAlign == 22 || fLegAlign == 21) { //right
+ leg->SetX2(1. - gPad->GetRightMargin() - gStyle->GetTickLength("Y") * 1.0); //x2.0 ticklength
leg->SetX1(leg->GetX2() - maxwdth * 1.0 - symblwdth);
- } else if (fLegAlign == 12 || fLegAlign == 11) { //left
+ }
+ else if (fLegAlign == 12 || fLegAlign == 11) { //left
leg->SetX1(0. + gPad->GetLeftMargin() + gStyle->GetTickLength("Y"));
leg->SetX2(leg->GetX1() + maxwdth * 1.0 + symblwdth);
}
@@ -574,8 +557,7 @@ void PairAnalysisStyler::SetLegendAttributes(TLegend* leg, Bool_t fill) {
leg->SetEntrySeparation(entrysep - 1.);
// styling
- if (fill)
- leg->SetFillStyle(1001); // solid
+ if (fill) leg->SetFillStyle(1001); // solid
else
leg->SetFillStyle(kFEmpty); // empty
// leg->SetFillColorAlpha(gStyle->GetLegendFillColor(), 0.8);
@@ -585,7 +567,8 @@ void PairAnalysisStyler::SetLegendAttributes(TLegend* leg, Bool_t fill) {
// printf(" y1 %f y2 %f \n",leg->GetY1(),leg->GetY2());
}
-void PairAnalysisStyler::SetPalette(Epalette colors, Bool_t reverse) {
+void PairAnalysisStyler::SetPalette(Epalette colors, Bool_t reverse)
+{
//
// use own definition of color palettes for zaxis
//
@@ -599,8 +582,7 @@ void PairAnalysisStyler::SetPalette(Epalette colors, Bool_t reverse) {
Double_t red[NRGBs] = {0.00, 0.00, 0.87, 1.00, 0.51};
Double_t green[NRGBs] = {0.00, 0.81, 1.00, 0.20, 0.00};
Double_t blue[NRGBs] = {0.51, 1.00, 0.12, 0.00, 0.00};
- if (reverse)
- TColor::CreateGradientColorTable(NRGBs, stops, blue, green, red, NCont);
+ if (reverse) TColor::CreateGradientColorTable(NRGBs, stops, blue, green, red, NCont);
else
TColor::CreateGradientColorTable(NRGBs, stops, red, green, blue, NCont);
break;
@@ -609,8 +591,7 @@ void PairAnalysisStyler::SetPalette(Epalette colors, Bool_t reverse) {
Double_t red[NRGBs] = {0.00, 0.00, 0.87, 1.00, 0.36};
Double_t green[NRGBs] = {0.20, 0.81, 1.00, 0.20, 0.00};
Double_t blue[NRGBs] = {0.00, 0.00, 0.00, 0.00, 0.00};
- if (reverse)
- TColor::CreateGradientColorTable(NRGBs, stops, green, red, blue, NCont);
+ if (reverse) TColor::CreateGradientColorTable(NRGBs, stops, green, red, blue, NCont);
else
TColor::CreateGradientColorTable(NRGBs, stops, red, green, blue, NCont);
break;
@@ -622,7 +603,8 @@ void PairAnalysisStyler::SetPalette(Epalette colors, Bool_t reverse) {
}
//_____________________________________________________________________________
-TH1* PairAnalysisStyler::GetFirstHistogram() {
+TH1* PairAnalysisStyler::GetFirstHistogram()
+{
//
// get the first histogram drawn on the pad
// this can be modified in the usual way
@@ -636,18 +618,15 @@ TH1* PairAnalysisStyler::GetFirstHistogram() {
TObject* obj;
while ((obj = nextObj())) {
if (obj->InheritsFrom(TH1::Class())) { return (static_cast<TH1*>(obj)); }
- if (obj->InheritsFrom(TGraph::Class())) {
- return (static_cast<TH1*>(static_cast<TGraph*>(obj)->GetHistogram()));
- }
- if (obj->InheritsFrom(THStack::Class())) {
- return (static_cast<TH1*>(static_cast<THStack*>(obj)->GetHistogram()));
- }
+ if (obj->InheritsFrom(TGraph::Class())) { return (static_cast<TH1*>(static_cast<TGraph*>(obj)->GetHistogram())); }
+ if (obj->InheritsFrom(THStack::Class())) { return (static_cast<TH1*>(static_cast<THStack*>(obj)->GetHistogram())); }
}
return 0x0;
}
//_____________________________________________________________________________
-TLegendEntry* PairAnalysisStyler::GetLegendEntry(Int_t idx) {
+TLegendEntry* PairAnalysisStyler::GetLegendEntry(Int_t idx)
+{
//
// TODO
//
diff --git a/analysis/PWGDIL/dielectron/papaframework/PairAnalysisStyler.h b/analysis/PWGDIL/dielectron/papaframework/PairAnalysisStyler.h
index b106e9ea36978b18854b43d083e907cb3cbccd65..7412de2b5360560c5730217a5fe0d3c009fcfcee 100644
--- a/analysis/PWGDIL/dielectron/papaframework/PairAnalysisStyler.h
+++ b/analysis/PWGDIL/dielectron/papaframework/PairAnalysisStyler.h
@@ -20,22 +20,40 @@
#include <TStyle.h>
-namespace PairAnalysisStyler {
+namespace PairAnalysisStyler
+{
- enum class Eidx { kRaw = 100, kBgrd, kSig, kFit, kCocktail, kNidx };
- enum class Epalette { kDefault = 0, kGoodBad };
- enum class EfillMark { kOpenMarker = 1, kFullMarker, kDontCare };
- enum class Estyle { kNMaxMarker = 13, kNMaxLine = 4, kNMaxColor = 17 };
+ enum class Eidx
+ {
+ kRaw = 100,
+ kBgrd,
+ kSig,
+ kFit,
+ kCocktail,
+ kNidx
+ };
+ enum class Epalette
+ {
+ kDefault = 0,
+ kGoodBad
+ };
+ enum class EfillMark
+ {
+ kOpenMarker = 1,
+ kFullMarker,
+ kDontCare
+ };
+ enum class Estyle
+ {
+ kNMaxMarker = 13,
+ kNMaxLine = 4,
+ kNMaxColor = 17
+ };
void SetStyle(TStyle* userStyle);
- void SetStyle(Eidx idx,
- Int_t col = kBlack,
- Int_t marker = kOpenCircle,
- Double_t size = 1.5,
- Int_t line = kSolid,
- Double_t width = 2.,
- Int_t fill = kFEmpty);
+ void SetStyle(Eidx idx, Int_t col = kBlack, Int_t marker = kOpenCircle, Double_t size = 1.5, Int_t line = kSolid,
+ Double_t width = 2., Int_t fill = kFEmpty);
void LoadStyle();
void Style(TObject* obj, Int_t idx = 0);
@@ -45,8 +63,7 @@ namespace PairAnalysisStyler {
void SetForceMarkerFillStyle(EfillMark fill);
- void SetPalette(Epalette colors = Epalette::kDefault,
- Bool_t reverse = kFALSE);
+ void SetPalette(Epalette colors = Epalette::kDefault, Bool_t reverse = kFALSE);
void SetLegendAlign(UInt_t align);
void SetLegendAttributes(TLegend* leg, Bool_t fill = kFALSE);
diff --git a/analysis/PWGDIL/dielectron/papaframework/PairAnalysisTrack.cxx b/analysis/PWGDIL/dielectron/papaframework/PairAnalysisTrack.cxx
index 03160b0b3bc4d91c67ac6c1cdfd6edb869ecd217..e8e6c973b38ebf5ad07deabfbf6fda7de7867e6b 100644
--- a/analysis/PWGDIL/dielectron/papaframework/PairAnalysisTrack.cxx
+++ b/analysis/PWGDIL/dielectron/papaframework/PairAnalysisTrack.cxx
@@ -21,17 +21,15 @@
///////////////////////////////////////////////////////////////////////////
//#include <TObjArray.h>
-#include <vector>
-
-#include <TDatabasePDG.h>
-#include <TLorentzVector.h>
-#include <TParticle.h>
-#include <TParticlePDG.h>
-
-#include "FairTrackParam.h"
+#include "PairAnalysisTrack.h"
#include "CbmGlobalTrack.h"
#include "CbmKFVertex.h"
+#include "CbmL1PFFitter.h"
+#include "CbmLitConverterFairTrackParam.h"
+#include "CbmLitPtrTypes.h"
+#include "CbmLitToolFactory.h"
+#include "CbmLitTrackParam.h"
#include "CbmMCTrack.h"
#include "CbmMuchTrack.h"
#include "CbmMvdDetector.h"
@@ -44,20 +42,24 @@
#include "CbmTrackParam.h"
#include "CbmTrdTrack.h"
-#include "CbmL1PFFitter.h"
-#include "L1Field.h"
+#include "FairTrackParam.h"
-#include "CbmLitConverterFairTrackParam.h"
-#include "CbmLitPtrTypes.h"
-#include "CbmLitToolFactory.h"
-#include "CbmLitTrackParam.h"
+#include <TDatabasePDG.h>
+#include <TLorentzVector.h>
+#include <TParticle.h>
+#include <TParticlePDG.h>
-#include "PairAnalysisTrack.h"
+#include <vector>
+
+#include "L1Field.h"
ClassImp(PairAnalysisTrack)
PairAnalysisTrack::PairAnalysisTrack()
- : TNamed(), fMomentum(), fPosition() {
+ : TNamed()
+ , fMomentum()
+ , fPosition()
+{
//
// Default Constructor
//
@@ -65,7 +67,10 @@ ClassImp(PairAnalysisTrack)
//______________________________________________
PairAnalysisTrack::PairAnalysisTrack(const char* name, const char* title)
- : TNamed(name, title), fMomentum(), fPosition() {
+ : TNamed(name, title)
+ , fMomentum()
+ , fPosition()
+{
//
// Named Constructor
//
@@ -79,7 +84,8 @@ PairAnalysisTrack::PairAnalysisTrack(TParticle* fastTrk, CbmMCTrack* mctrk)
, fPosition()
, fPdgCode(fastTrk->GetPdgCode())
, fLabel(fastTrk->GetFirstMother())
- , fFastTrack(kTRUE) {
+ , fFastTrack(kTRUE)
+{
//
// Constructor
//
@@ -91,19 +97,10 @@ PairAnalysisTrack::PairAnalysisTrack(TParticle* fastTrk, CbmMCTrack* mctrk)
}
//______________________________________________
-PairAnalysisTrack::PairAnalysisTrack(CbmKFVertex* vtx,
- CbmGlobalTrack* gtrk,
- CbmStsTrack* ststrk,
- CbmMuchTrack* muchtrk,
- CbmTrdTrack* trdtrk,
- CbmRichRing* richring,
- CbmTofHit* tofhit,
- CbmMCTrack* mctrk,
- CbmTrackMatchNew* stsmatch,
- CbmTrackMatchNew* muchmatch,
- CbmTrackMatchNew* trdmatch,
- CbmTrackMatchNew* richmatch,
- FairTrackParam* richproj,
+PairAnalysisTrack::PairAnalysisTrack(CbmKFVertex* vtx, CbmGlobalTrack* gtrk, CbmStsTrack* ststrk, CbmMuchTrack* muchtrk,
+ CbmTrdTrack* trdtrk, CbmRichRing* richring, CbmTofHit* tofhit, CbmMCTrack* mctrk,
+ CbmTrackMatchNew* stsmatch, CbmTrackMatchNew* muchmatch,
+ CbmTrackMatchNew* trdmatch, CbmTrackMatchNew* richmatch, FairTrackParam* richproj,
Int_t gIndex)
: TNamed()
, fPrimVertex(vtx)
@@ -122,27 +119,23 @@ PairAnalysisTrack::PairAnalysisTrack(CbmKFVertex* vtx,
, fRichProj(richproj)
, fMvdEntrance(new FairTrackParam())
, fMomentum()
- , fPosition() {
+ , fPosition()
+{
//
// Constructor
//
- Double_t m2 =
- TMath::Power(TDatabasePDG::Instance()->GetParticle(11)->Mass(), 2);
+ Double_t m2 = TMath::Power(TDatabasePDG::Instance()->GetParticle(11)->Mass(), 2);
/// check mvd entrance if mvd is in setup
CbmMvdStationPar* mvdpar = CbmMvdDetector::Instance()->GetParameterFile();
if (mvdpar && mvdpar->GetStationCount()) {
- Double_t zMvd =
- mvdpar->GetZPosition(0); // z-position of the first mvd station
- TrackExtrapolatorPtr fExtrapolator =
- CbmLitToolFactory::CreateTrackExtrapolator("rk4");
+ Double_t zMvd = mvdpar->GetZPosition(0); // z-position of the first mvd station
+ TrackExtrapolatorPtr fExtrapolator = CbmLitToolFactory::CreateTrackExtrapolator("rk4");
CbmLitTrackParam litParamIn;
- CbmLitConverterFairTrackParam::FairTrackParamToCbmLitTrackParam(
- ststrk->GetParamFirst(), &litParamIn);
+ CbmLitConverterFairTrackParam::FairTrackParamToCbmLitTrackParam(ststrk->GetParamFirst(), &litParamIn);
CbmLitTrackParam litParamOut;
fExtrapolator->Extrapolate(&litParamIn, &litParamOut, zMvd, NULL);
- CbmLitConverterFairTrackParam::CbmLitTrackParamToFairTrackParam(
- &litParamOut, fMvdEntrance);
+ CbmLitConverterFairTrackParam::CbmLitTrackParamToFairTrackParam(&litParamOut, fMvdEntrance);
}
/// get parameters at primary vertex
@@ -150,11 +143,11 @@ PairAnalysisTrack::PairAnalysisTrack(CbmKFVertex* vtx,
if (ppar) {
fMomentum.SetPxPyPzE(ppar->GetPx(), ppar->GetPy(), ppar->GetPz(), 0.);
fMomentum.SetE(TMath::Sqrt(fMomentum.Vect().Mag2() + m2));
- fPosition.SetXYZM(
- ppar->GetX(), ppar->GetY(), ppar->GetZ(), TMath::Sqrt(m2));
+ fPosition.SetXYZM(ppar->GetX(), ppar->GetY(), ppar->GetZ(), TMath::Sqrt(m2));
fCharge = (ppar->GetQp() > 0. ? +1. : -1.);
CalculateChi2Vtx();
- } else {
+ }
+ else {
Refit(211);
}
@@ -186,7 +179,8 @@ PairAnalysisTrack::PairAnalysisTrack(const PairAnalysisTrack& track)
, fPdgCode(track.PdgCode())
, fLabel(track.GetLabel())
, fWeight(track.GetWeight())
- , fFastTrack(track.fFastTrack) {
+ , fFastTrack(track.fFastTrack)
+{
//
// Copy Constructor
//
@@ -204,7 +198,8 @@ PairAnalysisTrack::PairAnalysisTrack(const PairAnalysisTrack& track)
}
//______________________________________________
-PairAnalysisTrack::~PairAnalysisTrack() {
+PairAnalysisTrack::~PairAnalysisTrack()
+{
//
// Default Destructor
//
@@ -212,13 +207,13 @@ PairAnalysisTrack::~PairAnalysisTrack() {
}
//______________________________________________
-CbmTrackMatchNew* PairAnalysisTrack::GetTrackMatch(ECbmModuleId det) const {
+CbmTrackMatchNew* PairAnalysisTrack::GetTrackMatch(ECbmModuleId det) const
+{
//
// get track match depending on detector id
//
switch (det) {
- case ECbmModuleId::kMvd:
- return fStsTrackMatch; // there is no mvd track, hit are associtaed to sts track
+ case ECbmModuleId::kMvd: return fStsTrackMatch; // there is no mvd track, hit are associtaed to sts track
case ECbmModuleId::kSts: return fStsTrackMatch;
case ECbmModuleId::kTrd: return fTrdTrackMatch;
case ECbmModuleId::kMuch: return fMuchTrackMatch;
@@ -228,13 +223,13 @@ CbmTrackMatchNew* PairAnalysisTrack::GetTrackMatch(ECbmModuleId det) const {
}
//______________________________________________
-CbmTrack* PairAnalysisTrack::GetTrack(ECbmModuleId det) const {
+CbmTrack* PairAnalysisTrack::GetTrack(ECbmModuleId det) const
+{
//
// get track depending on detector id
//
switch (det) {
- case ECbmModuleId::kMvd:
- return fStsTrack; // there is no mvd track, hit are associtaed to sts track
+ case ECbmModuleId::kMvd: return fStsTrack; // there is no mvd track, hit are associtaed to sts track
case ECbmModuleId::kSts: return fStsTrack;
case ECbmModuleId::kTrd: return fTrdTrack;
case ECbmModuleId::kMuch: return fMuchTrack;
@@ -244,19 +239,16 @@ CbmTrack* PairAnalysisTrack::GetTrack(ECbmModuleId det) const {
}
//______________________________________________
-void PairAnalysisTrack::SetMassHypo(Int_t pdg1,
- Int_t pdg2,
- Bool_t refitMassAssump) {
+void PairAnalysisTrack::SetMassHypo(Int_t pdg1, Int_t pdg2, Bool_t refitMassAssump)
+{
//
// use charge, time and track length information to assign
// the best guessed mass hypothesis
//
const Double_t mpdg1 = TDatabasePDG::Instance()->GetParticle(pdg1)->Mass();
const Double_t mpdg2 = TDatabasePDG::Instance()->GetParticle(pdg2)->Mass();
- const Double_t cpdg1 =
- TDatabasePDG::Instance()->GetParticle(pdg1)->Charge() * 3;
- const Double_t cpdg2 =
- TDatabasePDG::Instance()->GetParticle(pdg2)->Charge() * 3;
+ const Double_t cpdg1 = TDatabasePDG::Instance()->GetParticle(pdg1)->Charge() * 3;
+ const Double_t cpdg2 = TDatabasePDG::Instance()->GetParticle(pdg2)->Charge() * 3;
Double_t m2 = 0.;
Int_t ppdg = 0; // prefered pdg
@@ -264,19 +256,18 @@ void PairAnalysisTrack::SetMassHypo(Int_t pdg1,
if (fCharge * cpdg1 < 0) {
m2 = mpdg2 * mpdg2;
ppdg = pdg2;
- } else if (fCharge * cpdg2 < 0) {
+ }
+ else if (fCharge * cpdg2 < 0) {
m2 = mpdg1 * mpdg1;
ppdg = pdg1;
- } else
+ }
+ else
Error("SetMassHypo", "via STS charge went wrong!");
// use TOF time(ns) and track length(cm) if available
if (fTofHit && kFALSE) { //TODO: switched OFF!!
m2 = fMomentum.Mag2()
- * (TMath::Power((fTofHit->GetTime() * 1e-9 * TMath::C())
- / fGlblTrack->GetLength() / 100,
- 2)
- - 1);
+ * (TMath::Power((fTofHit->GetTime() * 1e-9 * TMath::C()) / fGlblTrack->GetLength() / 100, 2) - 1);
}
// refit (under pdg assumption if activated)
@@ -286,13 +277,14 @@ void PairAnalysisTrack::SetMassHypo(Int_t pdg1,
if (ppar) {
fMomentum.SetPxPyPzE(ppar->GetPx(), ppar->GetPy(), ppar->GetPz(), 0.);
fMomentum.SetE(TMath::Sqrt(fMomentum.Vect().Mag2() + m2));
- fPosition.SetXYZM(
- ppar->GetX(), ppar->GetY(), ppar->GetZ(), TMath::Sqrt(m2));
+ fPosition.SetXYZM(ppar->GetX(), ppar->GetY(), ppar->GetZ(), TMath::Sqrt(m2));
fCharge = (ppar->GetQp() > 0. ? +1. : -1.);
CalculateChi2Vtx();
- } else
+ }
+ else
Refit(211);
- } else {
+ }
+ else {
Refit(ppdg);
// fMomentum.Print();
/// set mass hypo
@@ -302,7 +294,8 @@ void PairAnalysisTrack::SetMassHypo(Int_t pdg1,
}
//______________________________________________
-void PairAnalysisTrack::Refit(Int_t pidHypo) {
+void PairAnalysisTrack::Refit(Int_t pidHypo)
+{
//
// refit the track under certain mass assumption using CbmL1PFFitter
// to the primary vertex
@@ -348,15 +341,14 @@ void PairAnalysisTrack::Refit(Int_t pidHypo) {
}
//______________________________________________
-void PairAnalysisTrack::CalculateChi2Vtx() {
+void PairAnalysisTrack::CalculateChi2Vtx()
+{
//
// calculation according to CbmL1PFFitter::GetChiToVertex
//
// primary vertex
- Double_t Cv[3] = {fPrimVertex->GetCovMatrix()[0],
- fPrimVertex->GetCovMatrix()[1],
- fPrimVertex->GetCovMatrix()[2]};
+ Double_t Cv[3] = {fPrimVertex->GetCovMatrix()[0], fPrimVertex->GetCovMatrix()[1], fPrimVertex->GetCovMatrix()[2]};
// track params at prim vertex
const CbmTrackParam* ppar = fGlblTrack->GetParamVertex();
@@ -366,20 +358,16 @@ void PairAnalysisTrack::CalculateChi2Vtx() {
Double_t dy = ppar->GetY() - fPrimVertex->GetRefY();
- Double_t c[3] = {ppar->GetCovariance(0, 0),
- ppar->GetCovariance(1, 0),
- ppar->GetCovariance(1, 1)};
+ Double_t c[3] = {ppar->GetCovariance(0, 0), ppar->GetCovariance(1, 0), ppar->GetCovariance(1, 1)};
c[0] += Cv[0];
c[1] += Cv[1];
c[2] += Cv[2];
Double_t d = c[0] * c[2] - c[1] * c[1];
- Double_t chi = TMath::Sqrt(TMath::Abs(
- 0.5 * (dx * dx * c[0] - 2 * dx * dy * c[1] + dy * dy * c[2]) / d));
+ Double_t chi = TMath::Sqrt(TMath::Abs(0.5 * (dx * dx * c[0] - 2 * dx * dy * c[1] + dy * dy * c[2]) / d));
Bool_t isNull = (TMath::Abs(d) < 1.e-20);
- if (isNull)
- fChi2Vtx = -1.;
+ if (isNull) fChi2Vtx = -1.;
else
fChi2Vtx = chi;
}
diff --git a/analysis/PWGDIL/dielectron/papaframework/PairAnalysisTrack.h b/analysis/PWGDIL/dielectron/papaframework/PairAnalysisTrack.h
index a49b77d6b9bb89bd4c8bf4c1f9e6e352513cb624..bf7dd44ffcdfed7a84a0d022f796fe72e87d9e6d 100644
--- a/analysis/PWGDIL/dielectron/papaframework/PairAnalysisTrack.h
+++ b/analysis/PWGDIL/dielectron/papaframework/PairAnalysisTrack.h
@@ -11,10 +11,10 @@
//# #
//#############################################################
+#include "CbmDefs.h"
+
#include <TLorentzVector.h>
#include <TNamed.h>
-
-#include "CbmDefs.h"
//#include "CbmTrackMatchNew.h"
class FairTrackParam;
@@ -38,20 +38,10 @@ class PairAnalysisTrack : public TNamed {
public:
PairAnalysisTrack();
PairAnalysisTrack(const char* name, const char* title);
- PairAnalysisTrack(CbmKFVertex* vtx,
- CbmGlobalTrack* gtrk,
- CbmStsTrack* ststrk,
- CbmMuchTrack* muchtrk,
- CbmTrdTrack* trdtrk,
- CbmRichRing* richring,
- CbmTofHit* tofhit,
- CbmMCTrack* mctrk,
- CbmTrackMatchNew* stsmatch,
- CbmTrackMatchNew* muchmatch,
- CbmTrackMatchNew* trdMatch,
- CbmTrackMatchNew* richMatch,
- FairTrackParam* richproj,
- Int_t gIndex);
+ PairAnalysisTrack(CbmKFVertex* vtx, CbmGlobalTrack* gtrk, CbmStsTrack* ststrk, CbmMuchTrack* muchtrk,
+ CbmTrdTrack* trdtrk, CbmRichRing* richring, CbmTofHit* tofhit, CbmMCTrack* mctrk,
+ CbmTrackMatchNew* stsmatch, CbmTrackMatchNew* muchmatch, CbmTrackMatchNew* trdMatch,
+ CbmTrackMatchNew* richMatch, FairTrackParam* richproj, Int_t gIndex);
PairAnalysisTrack(TParticle* fastTrk, CbmMCTrack* mctrk);
virtual ~PairAnalysisTrack();
diff --git a/analysis/PWGDIL/dielectron/papaframework/PairAnalysisTrackRotator.cxx b/analysis/PWGDIL/dielectron/papaframework/PairAnalysisTrackRotator.cxx
index e3238c3c11cd5a58a50f5262a09146c0edcbac14..ee4524d1acfece90e5f0419a986f1b54ba8c5cec 100644
--- a/analysis/PWGDIL/dielectron/papaframework/PairAnalysisTrackRotator.cxx
+++ b/analysis/PWGDIL/dielectron/papaframework/PairAnalysisTrackRotator.cxx
@@ -15,24 +15,24 @@
// //
///////////////////////////////////////////////////////////////////////////
+#include "PairAnalysisTrackRotator.h"
+
#include <TMath.h>
#include <TRandom3.h>
-#include "PairAnalysisTrackRotator.h"
-
ClassImp(PairAnalysisTrackRotator)
PairAnalysisTrackRotator::PairAnalysisTrackRotator()
- : PairAnalysisTrackRotator("TR", "TR") {
+ : PairAnalysisTrackRotator("TR", "TR")
+{
//
// Default Constructor
//
}
//______________________________________________
-PairAnalysisTrackRotator::PairAnalysisTrackRotator(const char* name,
- const char* title)
- : TNamed(name, title) {
+PairAnalysisTrackRotator::PairAnalysisTrackRotator(const char* name, const char* title) : TNamed(name, title)
+{
//
// Named Constructor
//
@@ -40,7 +40,8 @@ PairAnalysisTrackRotator::PairAnalysisTrackRotator(const char* name,
}
//______________________________________________
-PairAnalysisTrackRotator::~PairAnalysisTrackRotator() {
+PairAnalysisTrackRotator::~PairAnalysisTrackRotator()
+{
//
// Default Destructor
//
diff --git a/analysis/PWGDIL/dielectron/papaframework/PairAnalysisTrackRotator.h b/analysis/PWGDIL/dielectron/papaframework/PairAnalysisTrackRotator.h
index e620f2f4b57ea8478f14621e051941d672c9fb07..25770bf7dbd3cd14ffe4a83685ae9501ba10e32e 100644
--- a/analysis/PWGDIL/dielectron/papaframework/PairAnalysisTrackRotator.h
+++ b/analysis/PWGDIL/dielectron/papaframework/PairAnalysisTrackRotator.h
@@ -16,7 +16,8 @@
class PairAnalysisTrackRotator : public TNamed {
public:
- enum class ERotationType {
+ enum class ERotationType
+ {
kRotatePositive,
kRotateNegative,
kRotateBothRandom
@@ -39,18 +40,14 @@ public:
Double_t GetStartAnglePhi() const { return fStartAnglePhi; }
Double_t GetConeAnglePhi() const { return fConeAnglePhi; }
- Double_t GetAngle() const {
- return fStartAnglePhi + (2 * gRandom->Rndm() - 1) * fConeAnglePhi;
- }
+ Double_t GetAngle() const { return fStartAnglePhi + (2 * gRandom->Rndm() - 1) * fConeAnglePhi; }
Double_t GetCharge() const { return TMath::Nint(gRandom->Rndm()); }
private:
- UInt_t fIterations = 1; // number of iterations
- ERotationType fRotationType =
- ERotationType::kRotateBothRandom; // which track to rotate
- Double_t fStartAnglePhi = TMath::Pi(); // starting angle for rotation
- Double_t fConeAnglePhi =
- TMath::Pi(); // opening angle in phi for multiple rotation
+ UInt_t fIterations = 1; // number of iterations
+ ERotationType fRotationType = ERotationType::kRotateBothRandom; // which track to rotate
+ Double_t fStartAnglePhi = TMath::Pi(); // starting angle for rotation
+ Double_t fConeAnglePhi = TMath::Pi(); // opening angle in phi for multiple rotation
PairAnalysisTrackRotator(const PairAnalysisTrackRotator& c);
PairAnalysisTrackRotator& operator=(const PairAnalysisTrackRotator& c);
diff --git a/analysis/PWGDIL/dielectron/papaframework/PairAnalysisVarCuts.cxx b/analysis/PWGDIL/dielectron/papaframework/PairAnalysisVarCuts.cxx
index 866dfcf366050a744a8f03dc4748542d05f1c120..3e86db31d6183924e915329f87ee923ea560e7be 100644
--- a/analysis/PWGDIL/dielectron/papaframework/PairAnalysisVarCuts.cxx
+++ b/analysis/PWGDIL/dielectron/papaframework/PairAnalysisVarCuts.cxx
@@ -23,11 +23,12 @@
///////////////////////////////////////////////////////////////////////////
+#include "PairAnalysisVarCuts.h"
+
#include <TAxis.h>
#include <TFormula.h>
#include "PairAnalysisHelper.h"
-#include "PairAnalysisVarCuts.h"
ClassImp(PairAnalysisVarCuts)
@@ -38,7 +39,8 @@ ClassImp(PairAnalysisVarCuts)
, fNActiveCuts(0)
, fActiveCutsMask(0)
, fSelectedCutsMask(0)
- , fCutType(ECutType::kAll) {
+ , fCutType(ECutType::kAll)
+{
//
// Default costructor
//
@@ -60,7 +62,8 @@ PairAnalysisVarCuts::PairAnalysisVarCuts(const char* name, const char* title)
, fNActiveCuts(0)
, fActiveCutsMask(0)
, fSelectedCutsMask(0)
- , fCutType(ECutType::kAll) {
+ , fCutType(ECutType::kAll)
+{
//
// Named contructor
//
@@ -76,7 +79,8 @@ PairAnalysisVarCuts::PairAnalysisVarCuts(const char* name, const char* title)
}
//________________________________________________________________________
-PairAnalysisVarCuts::~PairAnalysisVarCuts() {
+PairAnalysisVarCuts::~PairAnalysisVarCuts()
+{
//
// Destructor
//
@@ -87,7 +91,8 @@ PairAnalysisVarCuts::~PairAnalysisVarCuts() {
}
//________________________________________________________________________
-Bool_t PairAnalysisVarCuts::IsSelected(Double_t* const values) {
+Bool_t PairAnalysisVarCuts::IsSelected(Double_t* const values)
+{
//
// Make cut decision
//
@@ -102,23 +107,19 @@ Bool_t PairAnalysisVarCuts::IsSelected(Double_t* const values) {
// apply 'bit cut'
if (fBitCut[iCut]) {
- if ((TESTBIT((UInt_t) values[cut], (UInt_t) fCutMin[iCut]))
- ^ (!fCutExclude[iCut]))
+ if ((TESTBIT((UInt_t) values[cut], (UInt_t) fCutMin[iCut])) ^ (!fCutExclude[iCut]))
CLRBIT(fSelectedCutsMask, iCut);
- } else {
+ }
+ else {
// standard var cuts
- if (!fCutVar[iCut]
- && ((values[cut] < fCutMin[iCut]) || (values[cut] > fCutMax[iCut]))
- ^ fCutExclude[iCut]) {
+ if (!fCutVar[iCut] && ((values[cut] < fCutMin[iCut]) || (values[cut] > fCutMax[iCut])) ^ fCutExclude[iCut]) {
CLRBIT(fSelectedCutsMask, iCut);
- } else if (fCutVar[iCut] && fCutVar[iCut]->IsA() == TFormula::Class()) {
+ }
+ else if (fCutVar[iCut] && fCutVar[iCut]->IsA() == TFormula::Class()) {
/// use a formula for the variable //
TFormula* form = static_cast<TFormula*>(fCutVar[iCut]);
Double_t val = PairAnalysisHelper::EvalFormula(form, values);
- if (((val < fCutMin[iCut]) || (val > fCutMax[iCut]))
- ^ fCutExclude[iCut]) {
- CLRBIT(fSelectedCutsMask, iCut);
- }
+ if (((val < fCutMin[iCut]) || (val > fCutMax[iCut])) ^ fCutExclude[iCut]) { CLRBIT(fSelectedCutsMask, iCut); }
}
}
// cut type and decision
@@ -133,7 +134,8 @@ Bool_t PairAnalysisVarCuts::IsSelected(Double_t* const values) {
}
//________________________________________________________________________
-Bool_t PairAnalysisVarCuts::IsSelected(TObject* track) {
+Bool_t PairAnalysisVarCuts::IsSelected(TObject* track)
+{
//
// Make cut decision
//
@@ -154,10 +156,9 @@ Bool_t PairAnalysisVarCuts::IsSelected(TObject* track) {
}
//________________________________________________________________________
-void PairAnalysisVarCuts::AddCut(PairAnalysisVarManager::ValueTypes type,
- Double_t min,
- Double_t max,
- Bool_t excludeRange) {
+void PairAnalysisVarCuts::AddCut(PairAnalysisVarManager::ValueTypes type, Double_t min, Double_t max,
+ Bool_t excludeRange)
+{
//
// Set cut range and activate it
//
@@ -176,10 +177,8 @@ void PairAnalysisVarCuts::AddCut(PairAnalysisVarManager::ValueTypes type,
}
//________________________________________________________________________
-void PairAnalysisVarCuts::AddCut(const char* formula,
- Double_t min,
- Double_t max,
- Bool_t excludeRange) {
+void PairAnalysisVarCuts::AddCut(const char* formula, Double_t min, Double_t max, Bool_t excludeRange)
+{
//
// Set cut range and activate it
//
@@ -200,8 +199,7 @@ void PairAnalysisVarCuts::AddCut(const char* formula,
if (form->Compile()) return;
//set parameter identifier and activate variables in the fill map
for (Int_t i = 0; i < form->GetNpar(); i++) {
- form->SetParName(
- i, PairAnalysisVarManager::GetValueName(form->GetParameter(i)));
+ form->SetParName(i, PairAnalysisVarManager::GetValueName(form->GetParameter(i)));
fUsedVars->SetBitNumber((Int_t) form->GetParameter(i), kTRUE);
}
@@ -210,9 +208,8 @@ void PairAnalysisVarCuts::AddCut(const char* formula,
}
//________________________________________________________________________
-void PairAnalysisVarCuts::AddBitCut(PairAnalysisVarManager::ValueTypes type,
- UInt_t bit,
- Bool_t excludeRange) {
+void PairAnalysisVarCuts::AddBitCut(PairAnalysisVarManager::ValueTypes type, UInt_t bit, Bool_t excludeRange)
+{
//
// Set cut range and activate it
//
@@ -226,71 +223,57 @@ void PairAnalysisVarCuts::AddBitCut(PairAnalysisVarManager::ValueTypes type,
}
//________________________________________________________________________
-void PairAnalysisVarCuts::Print(const Option_t* /*option*/) const {
+void PairAnalysisVarCuts::Print(const Option_t* /*option*/) const
+{
//
// Print cuts and the range
//
printf("------------------------------------------\n");
printf("cut ranges for '%s'\n", GetTitle());
- if (fCutType == ECutType::kAll) {
- printf("All Cuts have to be fulfilled\n");
- } else {
+ if (fCutType == ECutType::kAll) { printf("All Cuts have to be fulfilled\n"); }
+ else {
printf("Any Cut has to be fulfilled\n");
}
for (Int_t iCut = 0; iCut < fNActiveCuts; ++iCut) {
Int_t cut = (Int_t) fActiveCuts[iCut];
Bool_t inverse = fCutExclude[iCut];
Bool_t bitcut = fBitCut[iCut];
- Bool_t fcut = (fCutVar[iCut] && fCutVar[iCut]->IsA() == TFormula::Class());
+ Bool_t fcut = (fCutVar[iCut] && fCutVar[iCut]->IsA() == TFormula::Class());
if (!bitcut && !fcut) {
// standard cut
if (!inverse) {
- printf("Cut %02d: %f < %s < %f\n",
- iCut,
- fCutMin[iCut],
- PairAnalysisVarManager::GetValueName((Int_t) cut),
+ printf("Cut %02d: %f < %s < %f\n", iCut, fCutMin[iCut], PairAnalysisVarManager::GetValueName((Int_t) cut),
fCutMax[iCut]);
- } else {
- printf("Cut %02d: !(%f < %s < %f)\n",
- iCut,
- fCutMin[iCut],
- PairAnalysisVarManager::GetValueName((Int_t) cut),
+ }
+ else {
+ printf("Cut %02d: !(%f < %s < %f)\n", iCut, fCutMin[iCut], PairAnalysisVarManager::GetValueName((Int_t) cut),
fCutMax[iCut]);
}
- } else if (bitcut) {
+ }
+ else if (bitcut) {
// bit cut
if (!inverse) {
- printf("Cut %02d: %s & (1ULL<<%d) \n",
- iCut,
- PairAnalysisVarManager::GetValueName((Int_t) cut),
+ printf("Cut %02d: %s & (1ULL<<%d) \n", iCut, PairAnalysisVarManager::GetValueName((Int_t) cut),
(UInt_t) fCutMin[iCut]);
- } else {
- printf("Cut %02d: !(%s & (1ULL<<%d)) \n",
- iCut,
- PairAnalysisVarManager::GetValueName((Int_t) cut),
+ }
+ else {
+ printf("Cut %02d: !(%s & (1ULL<<%d)) \n", iCut, PairAnalysisVarManager::GetValueName((Int_t) cut),
(UInt_t) fCutMin[iCut]);
}
- } else if (fcut) {
+ }
+ else if (fcut) {
// variable defined by a formula
TFormula* form = static_cast<TFormula*>(fCutVar[iCut]);
TString tit(form->GetExpFormula());
// replace parameter variables with names labels
for (Int_t j = 0; j < form->GetNpar(); j++)
tit.ReplaceAll(Form("[%d]", j), form->GetParName(j));
- if (!inverse)
- printf("Cut %02d: %f < %s < %f\n",
- iCut,
- fCutMin[iCut],
- tit.Data(),
- fCutMax[iCut]);
+ if (!inverse) printf("Cut %02d: %f < %s < %f\n", iCut, fCutMin[iCut], tit.Data(), fCutMax[iCut]);
else
- printf("Cut %02d: !(%f < %s < %f)\n",
- iCut,
- fCutMin[iCut],
- tit.Data(),
- fCutMax[iCut]);
- } else
+ printf("Cut %02d: !(%f < %s < %f)\n", iCut, fCutMin[iCut], tit.Data(), fCutMax[iCut]);
+ }
+ else
printf("cut class not found\n");
} //loop over cuts
printf("------------------------------------------\n");
diff --git a/analysis/PWGDIL/dielectron/papaframework/PairAnalysisVarCuts.h b/analysis/PWGDIL/dielectron/papaframework/PairAnalysisVarCuts.h
index 1832583a6e841182ec7c7dae39dc915de122d785..aa66355ae480dcb917a99cf7003b193f458c039e 100644
--- a/analysis/PWGDIL/dielectron/papaframework/PairAnalysisVarCuts.h
+++ b/analysis/PWGDIL/dielectron/papaframework/PairAnalysisVarCuts.h
@@ -23,27 +23,21 @@
class PairAnalysisVarCuts : public AnalysisCuts {
public:
// Whether all cut criteria have to be fulfilled of just any
- enum class ECutType { kAll = 0, kAny };
+ enum class ECutType
+ {
+ kAll = 0,
+ kAny
+ };
PairAnalysisVarCuts();
PairAnalysisVarCuts(const char* name, const char* title);
virtual ~PairAnalysisVarCuts();
//TODO: make copy constructor and assignment operator public
- void AddCut(PairAnalysisVarManager::ValueTypes type,
- Double_t min,
- Double_t max,
- Bool_t excludeRange = kFALSE);
- void AddCut(const char* formula,
- Double_t min,
- Double_t max,
- Bool_t excludeRange = kFALSE);
- void AddCut(PairAnalysisVarManager::ValueTypes type,
- Double_t value,
- Bool_t excludeRange = kFALSE);
- void AddBitCut(PairAnalysisVarManager::ValueTypes type,
- UInt_t bit,
- Bool_t excludeRange = kFALSE);
+ void AddCut(PairAnalysisVarManager::ValueTypes type, Double_t min, Double_t max, Bool_t excludeRange = kFALSE);
+ void AddCut(const char* formula, Double_t min, Double_t max, Bool_t excludeRange = kFALSE);
+ void AddCut(PairAnalysisVarManager::ValueTypes type, Double_t value, Bool_t excludeRange = kFALSE);
+ void AddBitCut(PairAnalysisVarManager::ValueTypes type, UInt_t bit, Bool_t excludeRange = kFALSE);
// setters
void SetCutType(ECutType type) { fCutType = type; }
@@ -72,25 +66,19 @@ public:
private:
- TBits* fUsedVars; // list of used variables
- UShort_t fActiveCuts
- [PairAnalysisVarManager::kNMaxValuesMC]; // list of activated cuts
- UShort_t fNActiveCuts; // number of acive cuts
- UInt_t fActiveCutsMask; // mask of active cuts
-
- UInt_t
- fSelectedCutsMask; // Maks of selected cuts, is available after calling IsSelected
- ECutType fCutType; // type of the cut: any, all
-
- Double_t fCutMin
- [PairAnalysisVarManager::kNMaxValuesMC]; // minimum values for the cuts
- Double_t fCutMax
- [PairAnalysisVarManager::kNMaxValuesMC]; // maximum values for the cuts
- Bool_t
- fCutExclude[PairAnalysisVarManager::kNMaxValuesMC]; // inverse cut logic?
- Bool_t fBitCut[PairAnalysisVarManager::kNMaxValuesMC]; // bit cut
- TObject* fCutVar
- [PairAnalysisVarManager::kNMaxValuesMC]; // used formula for variable
+ TBits* fUsedVars; // list of used variables
+ UShort_t fActiveCuts[PairAnalysisVarManager::kNMaxValuesMC]; // list of activated cuts
+ UShort_t fNActiveCuts; // number of acive cuts
+ UInt_t fActiveCutsMask; // mask of active cuts
+
+ UInt_t fSelectedCutsMask; // Maks of selected cuts, is available after calling IsSelected
+ ECutType fCutType; // type of the cut: any, all
+
+ Double_t fCutMin[PairAnalysisVarManager::kNMaxValuesMC]; // minimum values for the cuts
+ Double_t fCutMax[PairAnalysisVarManager::kNMaxValuesMC]; // maximum values for the cuts
+ Bool_t fCutExclude[PairAnalysisVarManager::kNMaxValuesMC]; // inverse cut logic?
+ Bool_t fBitCut[PairAnalysisVarManager::kNMaxValuesMC]; // bit cut
+ TObject* fCutVar[PairAnalysisVarManager::kNMaxValuesMC]; // used formula for variable
PairAnalysisVarCuts(const PairAnalysisVarCuts& c);
PairAnalysisVarCuts& operator=(const PairAnalysisVarCuts& c);
@@ -103,9 +91,8 @@ private:
//
//Inline functions
//
-inline void PairAnalysisVarCuts::AddCut(PairAnalysisVarManager::ValueTypes type,
- Double_t value,
- Bool_t excludeRange) {
+inline void PairAnalysisVarCuts::AddCut(PairAnalysisVarManager::ValueTypes type, Double_t value, Bool_t excludeRange)
+{
//
// Set cut in a small delta around value
//