diff --git a/analysis/common/analysis_tree_converter/CbmConverterManager.cxx b/analysis/common/analysis_tree_converter/CbmConverterManager.cxx
index 0a3b792cda899bbe1c10e58a9fdc143443014ace..90b8b661df2be7adfb16b210aa494f6700d75e60 100644
--- a/analysis/common/analysis_tree_converter/CbmConverterManager.cxx
+++ b/analysis/common/analysis_tree_converter/CbmConverterManager.cxx
@@ -1,35 +1,38 @@
-#include <iostream>
+#include "CbmConverterManager.h"
-#include "AnalysisTree/DataHeader.hpp"
-#include "AnalysisTree/TaskManager.hpp"
+#include "CbmConverterTask.h"
#include "TGeoBBox.h"
#include "TGeoManager.h"
-#include "CbmConverterManager.h"
-#include "CbmConverterTask.h"
+#include <iostream>
+
+#include "AnalysisTree/DataHeader.hpp"
+#include "AnalysisTree/TaskManager.hpp"
ClassImp(CbmConverterManager)
- InitStatus CbmConverterManager::Init() {
+ InitStatus CbmConverterManager::Init()
+{
task_manager_->Init();
FillDataHeader();
return kSUCCESS;
}
-void CbmConverterManager::Exec(Option_t* /*opt*/) {
+void CbmConverterManager::Exec(Option_t* /*opt*/)
+{
index_map_.clear();
for (auto* task : tasks_) {
task->SetIndexesMap(&index_map_);
task->Exec();
- index_map_.insert(
- std::make_pair(task->GetOutputBranchName(), task->GetOutIndexesMap()));
+ index_map_.insert(std::make_pair(task->GetOutputBranchName(), task->GetOutIndexesMap()));
}
task_manager_->FillOutput();
}
-void CbmConverterManager::Finish() {
+void CbmConverterManager::Finish()
+{
TDirectory* curr = gDirectory; // TODO check why this is needed
TFile* currentFile = gFile;
@@ -41,7 +44,8 @@ void CbmConverterManager::Finish() {
gDirectory = curr;
}
-void CbmConverterManager::FillDataHeader() {
+void CbmConverterManager::FillDataHeader()
+{
// Force user to write data info //TODO is there a way to read it from a file automatically?
assert(!system_.empty() && beam_mom_);
@@ -79,8 +83,7 @@ void CbmConverterManager::FillDataHeader() {
double x = translation.X();
double y = translation.Y();
- std::cout << "mod" << modID << " : " << Form("(%.3f, %3f)", x, y)
- << std::endl;
+ std::cout << "mod" << modID << " : " << Form("(%.3f, %3f)", x, y) << std::endl;
auto* module = psd_mod_pos.AddChannel();
module->SetPosition(x, y, frontFaceGlobal[2]);
diff --git a/analysis/common/analysis_tree_converter/CbmConverterManager.h b/analysis/common/analysis_tree_converter/CbmConverterManager.h
index 0ddb1c0fd7659ffbe2ea64c0ac3ac45eaaa79398..ce3b9ebdb80c65f4ad9d0f26ab6c58c90ae45bcb 100644
--- a/analysis/common/analysis_tree_converter/CbmConverterManager.h
+++ b/analysis/common/analysis_tree_converter/CbmConverterManager.h
@@ -1,13 +1,14 @@
#ifndef ANALYSIS_TREE_CONVERTERMANAGER_H_
#define ANALYSIS_TREE_CONVERTERMANAGER_H_
-#include <utility>
-
#include "FairTask.h"
+#include <utility>
+
#include "AnalysisTree/TaskManager.hpp"
-namespace AnalysisTree {
+namespace AnalysisTree
+{
class Configuration;
class DataHeader;
} // namespace AnalysisTree
@@ -24,7 +25,8 @@ public:
void Exec(Option_t* opt) override;
void Finish() override;
- void AddTask(CbmConverterTask* task) {
+ void AddTask(CbmConverterTask* task)
+ {
tasks_.emplace_back(task);
task_manager_->AddTask(reinterpret_cast<AnalysisTree::Task*>(task));
}
@@ -32,23 +34,22 @@ public:
void SetSystem(const std::string& system) { system_ = system; }
void SetBeamMomentum(float beam_mom) { beam_mom_ = beam_mom; }
- void SetOutputName(std::string file, std::string tree = "aTree") {
+ void SetOutputName(std::string file, std::string tree = "aTree")
+ {
task_manager_->SetOutputName(std::move(file), std::move(tree));
}
private:
void FillDataHeader();
- AnalysisTree::TaskManager* task_manager_ {
- AnalysisTree::TaskManager::GetInstance()};
+ AnalysisTree::TaskManager* task_manager_ {AnalysisTree::TaskManager::GetInstance()};
std::string system_;
float beam_mom_ {0.};
std::vector<CbmConverterTask*> tasks_ {};
- std::map<std::string, std::map<int, int>>
- index_map_ {}; ///< map CbmRoot to AT of indexes for a given branch
+ std::map<std::string, std::map<int, int>> index_map_ {}; ///< map CbmRoot to AT of indexes for a given branch
ClassDefOverride(CbmConverterManager, 1)
};
diff --git a/analysis/common/analysis_tree_converter/CbmConverterTask.h b/analysis/common/analysis_tree_converter/CbmConverterTask.h
index 34588f8fd5f9ed451725b84b267d00729de14329..b41925a3defd8f9e2ce94dec8871eb4ec54e9325 100644
--- a/analysis/common/analysis_tree_converter/CbmConverterTask.h
+++ b/analysis/common/analysis_tree_converter/CbmConverterTask.h
@@ -1,32 +1,28 @@
#ifndef ANALYSIS_TREE_CONVERTERTASK_H_
#define ANALYSIS_TREE_CONVERTERTASK_H_
-#include "AnalysisTree/Task.hpp"
-
#include <map>
#include <string>
+#include "AnalysisTree/Task.hpp"
+
class FairRootManager;
class CbmConverterTask : public AnalysisTree::Task {
public:
CbmConverterTask() = delete;
- explicit CbmConverterTask(std::string out_branch_name,
- std::string match_to = "") {
+ explicit CbmConverterTask(std::string out_branch_name, std::string match_to = "")
+ {
out_branch_ = std::move(out_branch_name);
match_to_ = std::move(match_to);
};
~CbmConverterTask() override = default;
- const std::map<int, int>& GetOutIndexesMap() const {
- return out_indexes_map_;
- }
+ const std::map<int, int>& GetOutIndexesMap() const { return out_indexes_map_; }
- void SetIndexesMap(std::map<std::string, std::map<int, int>>* indexes_map) {
- indexes_map_ = indexes_map;
- }
+ void SetIndexesMap(std::map<std::string, std::map<int, int>>* indexes_map) { indexes_map_ = indexes_map; }
const std::string& GetOutputBranchName() const { return out_branch_; }
@@ -34,8 +30,7 @@ protected:
std::map<int, int> out_indexes_map_ {}; ///< CbmRoot to AnalysisTree indexes
///< map for output branch
std::string out_branch_ {};
- std::map<std::string, std::map<int, int>>*
- indexes_map_ {}; ///< CbmRoot to AnalysisTree indexes map for branches
+ std::map<std::string, std::map<int, int>>* indexes_map_ {}; ///< CbmRoot to AnalysisTree indexes map for branches
///< from other tasks
std::string match_to_ {}; ///< AT branch to match
};
diff --git a/analysis/common/analysis_tree_converter/CbmPsdModulesConverter.cxx b/analysis/common/analysis_tree_converter/CbmPsdModulesConverter.cxx
index b3a1ca227bc686c1dabd7f799389e049f9ca53f6..49ce439ec8211e62e0c0c90bb993a9dd115ee730 100644
--- a/analysis/common/analysis_tree_converter/CbmPsdModulesConverter.cxx
+++ b/analysis/common/analysis_tree_converter/CbmPsdModulesConverter.cxx
@@ -1,45 +1,46 @@
-#include <AnalysisTree/TaskManager.hpp>
-#include <cassert>
-#include <vector>
+#include "CbmPsdModulesConverter.h"
-#include "TClonesArray.h"
+#include "CbmPsdHit.h"
#include "FairRootManager.h"
-#include "AnalysisTree/Detector.hpp"
+#include "TClonesArray.h"
-#include "CbmPsdHit.h"
-#include "CbmPsdModulesConverter.h"
+#include <AnalysisTree/TaskManager.hpp>
+#include <cassert>
+#include <vector>
+
+#include "AnalysisTree/Detector.hpp"
ClassImp(CbmPsdModulesConverter)
- void CbmPsdModulesConverter::Init() {
+ void CbmPsdModulesConverter::Init()
+{
assert(!out_branch_.empty());
auto* ioman = FairRootManager::Instance();
assert(ioman != nullptr);
cbm_psd_hits_ = (TClonesArray*) ioman->GetObject("PsdHit");
- AnalysisTree::BranchConfig psd_branch(out_branch_,
- AnalysisTree::DetType::kModule);
+ AnalysisTree::BranchConfig psd_branch(out_branch_, AnalysisTree::DetType::kModule);
auto* man = AnalysisTree::TaskManager::GetInstance();
man->AddBranch(out_branch_, psd_modules_, psd_branch);
}
-void CbmPsdModulesConverter::Exec() {
+void CbmPsdModulesConverter::Exec()
+{
assert(cbm_psd_hits_);
psd_modules_->ClearChannels();
CbmPsdHit* hit {nullptr};
Float_t psd_energy {0.};
- auto* data_header = AnalysisTree::TaskManager::GetInstance()->GetDataHeader();
- auto* config = AnalysisTree::TaskManager::GetInstance()->GetConfig();
+ auto* data_header = AnalysisTree::TaskManager::GetInstance()->GetDataHeader();
+ auto* config = AnalysisTree::TaskManager::GetInstance()->GetConfig();
const auto& branch = config->GetBranchConfig(out_branch_);
- const int n_psd_modules =
- data_header->GetModulePositions(0).GetNumberOfChannels();
+ const int n_psd_modules = data_header->GetModulePositions(0).GetNumberOfChannels();
psd_modules_->Reserve(n_psd_modules);
for (int i = 0; i < n_psd_modules; ++i) {
auto& module = psd_modules_->AddChannel(branch);
diff --git a/analysis/common/analysis_tree_converter/CbmPsdModulesConverter.h b/analysis/common/analysis_tree_converter/CbmPsdModulesConverter.h
index b57e72c9c593b3a0b674ade4e5d9ccb8802b8527..53bdc8bacbeb058f57b95f2e9dcfdca91e0d3f0c 100644
--- a/analysis/common/analysis_tree_converter/CbmPsdModulesConverter.h
+++ b/analysis/common/analysis_tree_converter/CbmPsdModulesConverter.h
@@ -1,16 +1,17 @@
#ifndef ANALYSIS_TREE_PSDMODULESCONVERTER_H_
#define ANALYSIS_TREE_PSDMODULESCONVERTER_H_
-#include "AnalysisTree/Detector.hpp"
#include "CbmConverterTask.h"
+#include "AnalysisTree/Detector.hpp"
+
class TClonesArray;
class CbmPsdModulesConverter final : public CbmConverterTask {
public:
- explicit CbmPsdModulesConverter(std::string out_branch_name,
- std::string match_to = "")
- : CbmConverterTask(std::move(out_branch_name), std::move(match_to)) {
+ explicit CbmPsdModulesConverter(std::string out_branch_name, std::string match_to = "")
+ : CbmConverterTask(std::move(out_branch_name), std::move(match_to))
+ {
out_branch_ = "PsdModules";
};
diff --git a/analysis/common/analysis_tree_converter/CbmRecEventHeaderConverter.cxx b/analysis/common/analysis_tree_converter/CbmRecEventHeaderConverter.cxx
index 114de6a864ab03a99f8877371e9ddba0ecd85798..5e01f623c34ad3e09f10c85033d07210a245aca1 100644
--- a/analysis/common/analysis_tree_converter/CbmRecEventHeaderConverter.cxx
+++ b/analysis/common/analysis_tree_converter/CbmRecEventHeaderConverter.cxx
@@ -1,16 +1,21 @@
+#include "CbmRecEventHeaderConverter.h"
+
#include "CbmVertex.h"
+
#include "FairMCEventHeader.h"
#include "FairRootManager.h"
+
#include "TClonesArray.h"
-#include "cassert"
-#include "iostream"
+
#include <AnalysisTree/TaskManager.hpp>
-#include "CbmRecEventHeaderConverter.h"
+#include "cassert"
+#include "iostream"
ClassImp(CbmRecEventHeaderConverter)
- void CbmRecEventHeaderConverter::Init() {
+ void CbmRecEventHeaderConverter::Init()
+{
assert(!out_branch_.empty());
auto* ioman = FairRootManager::Instance();
assert(ioman != nullptr);
@@ -18,11 +23,9 @@ ClassImp(CbmRecEventHeaderConverter)
cbm_prim_vertex_ = (CbmVertex*) ioman->GetObject("PrimaryVertex.");
// ***** RecEventHeader *******
- AnalysisTree::BranchConfig RecEventHeaderBranch(
- "RecEventHeader", AnalysisTree::DetType::kEventHeader);
+ AnalysisTree::BranchConfig RecEventHeaderBranch("RecEventHeader", AnalysisTree::DetType::kEventHeader);
RecEventHeaderBranch.AddField<float>("vtx_chi2", "primiry vertex fit chi2");
- RecEventHeaderBranch.AddField<float>("Epsd",
- "GeV, full energy deposit in PSD");
+ RecEventHeaderBranch.AddField<float>("Epsd", "GeV, full energy deposit in PSD");
RecEventHeaderBranch.AddField<int>("M", "total multiplicity in STS");
RecEventHeaderBranch.AddField<int>("evt_id", "event identifier");
@@ -31,7 +34,8 @@ ClassImp(CbmRecEventHeaderConverter)
rec_event_header_->Init(RecEventHeaderBranch);
}
-void CbmRecEventHeaderConverter::Exec() {
+void CbmRecEventHeaderConverter::Exec()
+{
auto* out_config_ = AnalysisTree::TaskManager::GetInstance()->GetConfig();
const auto& branch = out_config_->GetBranchConfig(out_branch_);
@@ -44,14 +48,10 @@ void CbmRecEventHeaderConverter::Exec() {
return;
}
- rec_event_header_->SetVertexPosition3({cbm_prim_vertex_->GetX(),
- cbm_prim_vertex_->GetY(),
- cbm_prim_vertex_->GetZ()});
+ rec_event_header_->SetVertexPosition3({cbm_prim_vertex_->GetX(), cbm_prim_vertex_->GetY(), cbm_prim_vertex_->GetZ()});
// rec_event_header_ -> SetField(int(cbm_sts_tracks_->GetEntries()),
// config_.GetBranchConfig(rec_event_header_->GetId() ).GetFieldId("M"));
- rec_event_header_->SetField(int(cbm_header_->GetEventID()),
- branch.GetFieldId("evt_id"));
- rec_event_header_->SetField(
- float(cbm_prim_vertex_->GetChi2() / cbm_prim_vertex_->GetNDF()),
- branch.GetFieldId("vtx_chi2"));
+ rec_event_header_->SetField(int(cbm_header_->GetEventID()), branch.GetFieldId("evt_id"));
+ rec_event_header_->SetField(float(cbm_prim_vertex_->GetChi2() / cbm_prim_vertex_->GetNDF()),
+ branch.GetFieldId("vtx_chi2"));
}
diff --git a/analysis/common/analysis_tree_converter/CbmRecEventHeaderConverter.h b/analysis/common/analysis_tree_converter/CbmRecEventHeaderConverter.h
index ef6c163930f4944ae68e11e6a4a2a6be4923a5df..51e56b33e72c7be8c061818ce64d603e8317d9e4 100644
--- a/analysis/common/analysis_tree_converter/CbmRecEventHeaderConverter.h
+++ b/analysis/common/analysis_tree_converter/CbmRecEventHeaderConverter.h
@@ -1,17 +1,16 @@
#ifndef ANALYSIS_TREE_RECEVENTHEADERCONVERTER_H_
#define ANALYSIS_TREE_RECEVENTHEADERCONVERTER_H_
-#include "AnalysisTree/EventHeader.hpp"
-
#include "CbmConverterTask.h"
+#include "AnalysisTree/EventHeader.hpp"
+
class FairMCEventHeader;
class CbmVertex;
class CbmRecEventHeaderConverter final : public CbmConverterTask {
public:
- explicit CbmRecEventHeaderConverter(std::string out_branch_name)
- : CbmConverterTask(std::move(out_branch_name)) {};
+ explicit CbmRecEventHeaderConverter(std::string out_branch_name) : CbmConverterTask(std::move(out_branch_name)) {};
~CbmRecEventHeaderConverter() final = default;
void Init() final;
diff --git a/analysis/common/analysis_tree_converter/CbmRichRingsConverter.cxx b/analysis/common/analysis_tree_converter/CbmRichRingsConverter.cxx
index 77e5036731ef7645bceb159f6537c2406985c925..0463d1789acb8836c54bc04fc80dc768e242b7bd 100644
--- a/analysis/common/analysis_tree_converter/CbmRichRingsConverter.cxx
+++ b/analysis/common/analysis_tree_converter/CbmRichRingsConverter.cxx
@@ -1,20 +1,22 @@
-#include <cassert>
-#include <vector>
+#include "CbmRichRingsConverter.h"
-#include "TClonesArray.h"
+#include <CbmGlobalTrack.h>
#include <FairMCPoint.h>
#include <FairRootManager.h>
-#include "AnalysisTree/Matching.hpp"
+#include "TClonesArray.h"
#include <AnalysisTree/TaskManager.hpp>
-#include <CbmGlobalTrack.h>
+#include <cassert>
+#include <vector>
+
#include <rich/CbmRichRing.h>
-#include "CbmRichRingsConverter.h"
+#include "AnalysisTree/Matching.hpp"
-void CbmRichRingsConverter::Init() {
+void CbmRichRingsConverter::Init()
+{
assert(!out_branch_.empty());
auto* ioman = FairRootManager::Instance();
@@ -22,8 +24,7 @@ void CbmRichRingsConverter::Init() {
cbm_rich_rings_ = (TClonesArray*) ioman->GetObject("RichRing");
cbm_global_tracks_ = (TClonesArray*) ioman->GetObject("GlobalTrack");
- AnalysisTree::BranchConfig rich_branch(out_branch_,
- AnalysisTree::DetType::kHit);
+ AnalysisTree::BranchConfig rich_branch(out_branch_, AnalysisTree::DetType::kHit);
rich_branch.AddField<float>("radius");
rich_branch.AddFields<int>({"n_hits", "n_hits_on_ring"});
rich_branch.AddFields<float>({"axis_a", "axis_b"});
@@ -31,15 +32,15 @@ void CbmRichRingsConverter::Init() {
rich_branch.AddField<float>("chi2_ov_ndf", "chi2/ndf ring fit");
rich_branch.AddField<float>("phi_ellipse", "phi rotation angle of ellipse");
rich_branch.AddField<float>("radial_pos", "sqrt(x**2+abs(y-110)**2)");
- rich_branch.AddField<float>("radial_angle",
- "(0||1||2)*pi +- atan( abs((+-100-y)/-x) )");
+ rich_branch.AddField<float>("radial_angle", "(0||1||2)*pi +- atan( abs((+-100-y)/-x) )");
auto* man = AnalysisTree::TaskManager::GetInstance();
man->AddBranch(out_branch_, rich_rings_, rich_branch);
man->AddMatching(match_to_, out_branch_, vtx_tracks_2_rich_);
}
-void CbmRichRingsConverter::FillRichRings() {
+void CbmRichRingsConverter::FillRichRings()
+{
assert(cbm_rich_rings_);
rich_rings_->ClearChannels();
@@ -58,17 +59,13 @@ void CbmRichRingsConverter::FillRichRings() {
const int i_phi_ellipse = branch.GetFieldId("phi_ellipse");
const auto it = indexes_map_->find(match_to_);
- if (it == indexes_map_->end()) {
- throw std::runtime_error(match_to_
- + " is not found to match with TOF hits");
- }
+ if (it == indexes_map_->end()) { throw std::runtime_error(match_to_ + " is not found to match with TOF hits"); }
auto rec_tracks_map = it->second;
rich_rings_->Reserve(cbm_global_tracks_->GetEntries());
for (Int_t igt = 0; igt < cbm_global_tracks_->GetEntries(); igt++) {
- const auto* global_track =
- static_cast<const CbmGlobalTrack*>(cbm_global_tracks_->At(igt));
+ const auto* global_track = static_cast<const CbmGlobalTrack*>(cbm_global_tracks_->At(igt));
Int_t i_rich = global_track->GetRichRingIndex();
if (i_rich < 0) continue;
@@ -88,10 +85,7 @@ void CbmRichRingsConverter::FillRichRings() {
ring.SetField(float(rich_ring->GetCenterX()), i_center);
ring.SetField(float(rich_ring->GetCenterY()), i_center + 1);
ring.SetField(float(rich_ring->GetRadius()), i_r);
- ring.SetField(float(rich_ring->GetNDF() > 0.
- ? rich_ring->GetChi2() / rich_ring->GetNDF()
- : -999.),
- i_chi2);
+ ring.SetField(float(rich_ring->GetNDF() > 0. ? rich_ring->GetChi2() / rich_ring->GetNDF() : -999.), i_chi2);
ring.SetField(float(rich_ring->GetRadialAngle()), i_radial_angle);
ring.SetField(float(rich_ring->GetRadialPosition()), i_radial_pos);
ring.SetField(float(rich_ring->GetPhi()), i_phi_ellipse);
@@ -99,15 +93,15 @@ void CbmRichRingsConverter::FillRichRings() {
if (rec_tracks_map.empty()) { continue; }
const Int_t stsTrackIndex = global_track->GetStsTrackIndex();
if (rec_tracks_map.find(stsTrackIndex) != rec_tracks_map.end()) {
- vtx_tracks_2_rich_->AddMatch(rec_tracks_map.find(stsTrackIndex)->second,
- ring.GetId());
+ vtx_tracks_2_rich_->AddMatch(rec_tracks_map.find(stsTrackIndex)->second, ring.GetId());
}
}
}
void CbmRichRingsConverter::Exec() { FillRichRings(); }
-CbmRichRingsConverter::~CbmRichRingsConverter() {
+CbmRichRingsConverter::~CbmRichRingsConverter()
+{
delete rich_rings_;
delete vtx_tracks_2_rich_;
};
diff --git a/analysis/common/analysis_tree_converter/CbmRichRingsConverter.h b/analysis/common/analysis_tree_converter/CbmRichRingsConverter.h
index 5f8a9b9e844112d241980278ee2a82b707df4220..5b12721f82b4ca350176676ff073411aff34dac8 100644
--- a/analysis/common/analysis_tree_converter/CbmRichRingsConverter.h
+++ b/analysis/common/analysis_tree_converter/CbmRichRingsConverter.h
@@ -7,14 +7,14 @@
class TClonesArray;
-namespace AnalysisTree {
+namespace AnalysisTree
+{
class Matching;
}
class CbmRichRingsConverter final : public CbmConverterTask {
public:
- explicit CbmRichRingsConverter(std::string out_branch_name,
- std::string match_to = "")
+ explicit CbmRichRingsConverter(std::string out_branch_name, std::string match_to = "")
: CbmConverterTask(std::move(out_branch_name), std::move(match_to)) {};
~CbmRichRingsConverter() final;
diff --git a/analysis/common/analysis_tree_converter/CbmSimEventHeaderConverter.cxx b/analysis/common/analysis_tree_converter/CbmSimEventHeaderConverter.cxx
index 65a2d7d318bab256cdc91c88f83b6a203232f0c6..91289b3207bfd9b734b30d6d561d9db3fea1fe3f 100644
--- a/analysis/common/analysis_tree_converter/CbmSimEventHeaderConverter.cxx
+++ b/analysis/common/analysis_tree_converter/CbmSimEventHeaderConverter.cxx
@@ -1,23 +1,26 @@
+#include "CbmSimEventHeaderConverter.h"
+
#include "FairMCEventHeader.h"
#include "FairRootManager.h"
+
#include "TClonesArray.h"
-#include "cassert"
-#include "iostream"
+
#include <AnalysisTree/TaskManager.hpp>
-#include "CbmSimEventHeaderConverter.h"
+#include "cassert"
+#include "iostream"
ClassImp(CbmSimEventHeaderConverter)
- void CbmSimEventHeaderConverter::Init() {
+ void CbmSimEventHeaderConverter::Init()
+{
assert(!out_branch_.empty());
auto* ioman = FairRootManager::Instance();
assert(ioman != nullptr);
cbm_header_ = (FairMCEventHeader*) ioman->GetObject("MCEventHeader.");
// ***** SimEventHeader *******
- AnalysisTree::BranchConfig SimEventHeaderBranch(
- "SimEventHeader", AnalysisTree::DetType::kEventHeader);
+ AnalysisTree::BranchConfig SimEventHeaderBranch("SimEventHeader", AnalysisTree::DetType::kEventHeader);
SimEventHeaderBranch.AddField<float>("psi_RP", "reaction plane orientation");
SimEventHeaderBranch.AddField<float>("b", "fm, impact parameter");
SimEventHeaderBranch.AddField<float>("time", "ns, event time");
@@ -29,25 +32,18 @@ ClassImp(CbmSimEventHeaderConverter)
sim_event_header_->Init(SimEventHeaderBranch);
}
-void CbmSimEventHeaderConverter::Exec() {
- if (!cbm_header_) {
- throw std::runtime_error(
- "CbmSimEventHeaderConverter::Exec - ERROR! No fHeader!");
- }
+void CbmSimEventHeaderConverter::Exec()
+{
+ if (!cbm_header_) { throw std::runtime_error("CbmSimEventHeaderConverter::Exec - ERROR! No fHeader!"); }
auto* out_config_ = AnalysisTree::TaskManager::GetInstance()->GetConfig();
const auto& branch = out_config_->GetBranchConfig(out_branch_);
TVector3 pos {cbm_header_->GetX(), cbm_header_->GetY(), cbm_header_->GetZ()};
sim_event_header_->SetVertexPosition3(pos);
- sim_event_header_->SetField(float(cbm_header_->GetRotZ()),
- branch.GetFieldId("psi_RP"));
- sim_event_header_->SetField(float(cbm_header_->GetB()),
- branch.GetFieldId("b"));
- sim_event_header_->SetField(int(cbm_header_->GetEventID()),
- branch.GetFieldId("event_id"));
- sim_event_header_->SetField(int(cbm_header_->GetRunID()),
- branch.GetFieldId("run_id"));
- sim_event_header_->SetField(float(cbm_header_->GetT()),
- branch.GetFieldId("time"));
+ sim_event_header_->SetField(float(cbm_header_->GetRotZ()), branch.GetFieldId("psi_RP"));
+ sim_event_header_->SetField(float(cbm_header_->GetB()), branch.GetFieldId("b"));
+ sim_event_header_->SetField(int(cbm_header_->GetEventID()), branch.GetFieldId("event_id"));
+ sim_event_header_->SetField(int(cbm_header_->GetRunID()), branch.GetFieldId("run_id"));
+ sim_event_header_->SetField(float(cbm_header_->GetT()), branch.GetFieldId("time"));
}
diff --git a/analysis/common/analysis_tree_converter/CbmSimEventHeaderConverter.h b/analysis/common/analysis_tree_converter/CbmSimEventHeaderConverter.h
index e99870f42a3257a3d2b7628dd04c5aba2503f400..c010aec3135ada7432dd52b512419bccd85b2f39 100644
--- a/analysis/common/analysis_tree_converter/CbmSimEventHeaderConverter.h
+++ b/analysis/common/analysis_tree_converter/CbmSimEventHeaderConverter.h
@@ -1,17 +1,16 @@
#ifndef ANALYSIS_TREE_SIMEVENTHEADERCONVERTER_H_
#define ANALYSIS_TREE_SIMEVENTHEADERCONVERTER_H_
-#include "AnalysisTree/EventHeader.hpp"
-
#include "CbmConverterTask.h"
+#include "AnalysisTree/EventHeader.hpp"
+
class FairMCEventHeader;
class CbmVertex;
class CbmSimEventHeaderConverter final : public CbmConverterTask {
public:
- explicit CbmSimEventHeaderConverter(std::string out_branch_name)
- : CbmConverterTask(std::move(out_branch_name)) {};
+ explicit CbmSimEventHeaderConverter(std::string out_branch_name) : CbmConverterTask(std::move(out_branch_name)) {};
~CbmSimEventHeaderConverter() final = default;
void Init() final;
diff --git a/analysis/common/analysis_tree_converter/CbmSimTracksConverter.cxx b/analysis/common/analysis_tree_converter/CbmSimTracksConverter.cxx
index 7e621882e8b7cbf474e29a4c2b7b05c323cf2bf9..6a434f5beb3684bcb3d0f2d918360c6ac6d819a0 100644
--- a/analysis/common/analysis_tree_converter/CbmSimTracksConverter.cxx
+++ b/analysis/common/analysis_tree_converter/CbmSimTracksConverter.cxx
@@ -1,39 +1,36 @@
-#include <cassert>
-#include <vector>
-
-#include <AnalysisTree/TaskManager.hpp>
+#include "CbmSimTracksConverter.h"
-#include "TClonesArray.h"
+#include "CbmMCTrack.h"
#include "FairRootManager.h"
-#include "CbmMCTrack.h"
-#include "CbmSimTracksConverter.h"
+#include "TClonesArray.h"
+
+#include <AnalysisTree/TaskManager.hpp>
+#include <cassert>
+#include <vector>
ClassImp(CbmSimTracksConverter)
- void CbmSimTracksConverter::Init() {
+ void CbmSimTracksConverter::Init()
+{
assert(!out_branch_.empty());
auto* ioman = FairRootManager::Instance();
cbm_mc_tracks_ = (TClonesArray*) ioman->GetObject("MCTrack");
- AnalysisTree::BranchConfig sim_particles_branch(
- out_branch_, AnalysisTree::DetType::kParticle);
- sim_particles_branch.AddField<int>("mother_id",
- "id of mother particle, -1 for primaries");
- sim_particles_branch.AddField<int>("cbmroot_id",
- "track id in CbmRoot transport file");
+ AnalysisTree::BranchConfig sim_particles_branch(out_branch_, AnalysisTree::DetType::kParticle);
+ sim_particles_branch.AddField<int>("mother_id", "id of mother particle, -1 for primaries");
+ sim_particles_branch.AddField<int>("cbmroot_id", "track id in CbmRoot transport file");
sim_particles_branch.AddField<int>("geant_process_id", "");
- sim_particles_branch.AddFields<int>(
- {"n_hits_mvd", "n_hits_sts", "n_hits_trd"},
- "Number of hits in the detector");
+ sim_particles_branch.AddFields<int>({"n_hits_mvd", "n_hits_sts", "n_hits_trd"}, "Number of hits in the detector");
auto* man = AnalysisTree::TaskManager::GetInstance();
man->AddBranch(out_branch_, sim_tracks_, sim_particles_branch);
}
-void CbmSimTracksConverter::Exec() {
+void CbmSimTracksConverter::Exec()
+{
assert(cbm_mc_tracks_);
out_indexes_map_.clear();
@@ -68,9 +65,8 @@ void CbmSimTracksConverter::Exec() {
track.SetField(int(mctrack->GetUniqueID()), icbm_id);
// mother id should < than track id, so we can do it here
- if (mctrack->GetMotherId() == -1) {
- track.SetField(int(-1), imother_id);
- } else {
+ if (mctrack->GetMotherId() == -1) { track.SetField(int(-1), imother_id); }
+ else {
auto p = out_indexes_map_.find(mctrack->GetMotherId());
if (p == out_indexes_map_.end()) // match is not found
track.SetField(int(-999), imother_id);
diff --git a/analysis/common/analysis_tree_converter/CbmSimTracksConverter.h b/analysis/common/analysis_tree_converter/CbmSimTracksConverter.h
index a1e0676bdf73f1daaa6b38d297d000df541515b6..e969a06b8a9b899fb89fddd9fd0ebe4dd4ccb0c2 100644
--- a/analysis/common/analysis_tree_converter/CbmSimTracksConverter.h
+++ b/analysis/common/analysis_tree_converter/CbmSimTracksConverter.h
@@ -1,16 +1,15 @@
#ifndef ANALYSIS_TREE_SIMTRACKSCONVERTER_H_
#define ANALYSIS_TREE_SIMTRACKSCONVERTER_H_
-#include "AnalysisTree/Detector.hpp"
-
#include "CbmConverterTask.h"
+#include "AnalysisTree/Detector.hpp"
+
class TClonesArray;
class CbmSimTracksConverter final : public CbmConverterTask {
public:
- explicit CbmSimTracksConverter(std::string out_branch_name,
- std::string match_to = "")
+ explicit CbmSimTracksConverter(std::string out_branch_name, std::string match_to = "")
: CbmConverterTask(std::move(out_branch_name), std::move(match_to)) {};
~CbmSimTracksConverter() final;
diff --git a/analysis/common/analysis_tree_converter/CbmStsTracksConverter.cxx b/analysis/common/analysis_tree_converter/CbmStsTracksConverter.cxx
index 6aef8251ae07e08ae53f848fa27338ddf384a245..ec2f2d6959d6b2c08bdb29c5ca4869eb38d5af45 100644
--- a/analysis/common/analysis_tree_converter/CbmStsTracksConverter.cxx
+++ b/analysis/common/analysis_tree_converter/CbmStsTracksConverter.cxx
@@ -4,24 +4,26 @@
#include "CbmStsTrack.h"
#include "CbmTrackMatchNew.h"
#include "CbmVertex.h"
-#include "Interface/CbmKFVertex.h"
-#include "L1Field.h"
-#include "ParticleFinder/CbmL1PFFitter.h"
#include "FairRootManager.h"
-#include "AnalysisTree/Matching.hpp"
-#include <AnalysisTree/TaskManager.hpp>
-
#include "TClonesArray.h"
+#include <AnalysisTree/TaskManager.hpp>
#include <cassert>
+
#include <cmath>
+#include "AnalysisTree/Matching.hpp"
+#include "Interface/CbmKFVertex.h"
+#include "L1Field.h"
+#include "ParticleFinder/CbmL1PFFitter.h"
+
ClassImp(CbmStsTracksConverter)
- void CbmStsTracksConverter::Exec() {
+ void CbmStsTracksConverter::Exec()
+{
assert(cbm_sts_tracks_ != nullptr && cbm_mc_tracks_ != nullptr);
vtx_tracks_2_sim_->Clear();
@@ -31,12 +33,14 @@ ClassImp(CbmStsTracksConverter)
MapTracks();
}
-CbmStsTracksConverter::~CbmStsTracksConverter() {
+CbmStsTracksConverter::~CbmStsTracksConverter()
+{
delete vtx_tracks_;
delete vtx_tracks_2_sim_;
};
-void CbmStsTracksConverter::InitInput() {
+void CbmStsTracksConverter::InitInput()
+{
auto* ioman = FairRootManager::Instance();
cbm_prim_vertex_ = (CbmVertex*) ioman->GetObject("PrimaryVertex.");
@@ -45,47 +49,29 @@ void CbmStsTracksConverter::InitInput() {
cbm_sts_match_ = (TClonesArray*) ioman->GetObject("StsTrackMatch");
}
-void CbmStsTracksConverter::Init() {
+void CbmStsTracksConverter::Init()
+{
InitInput();
- AnalysisTree::BranchConfig vtx_tracks_config(out_branch_,
- AnalysisTree::DetType::kTrack);
+ AnalysisTree::BranchConfig vtx_tracks_config(out_branch_, AnalysisTree::DetType::kTrack);
vtx_tracks_config.AddField<float>("chi2", "chi2 of the track fit");
- vtx_tracks_config.AddField<float>("vtx_chi2",
- "chi2 to to the primary vertex");
- vtx_tracks_config.AddFields<float>(
- {"dcax", "dcay", "dcaz"},
- "not actuall Distance of Closest Approach, but extrapolated to z=z_vtx");
+ vtx_tracks_config.AddField<float>("vtx_chi2", "chi2 to to the primary vertex");
+ vtx_tracks_config.AddFields<float>({"dcax", "dcay", "dcaz"},
+ "not actuall Distance of Closest Approach, but extrapolated to z=z_vtx");
vtx_tracks_config.AddField<int>("ndf", "number degrees of freedom");
vtx_tracks_config.AddField<int>("q", "charge");
vtx_tracks_config.AddField<int>("nhits", "number of hits (total MVD+STS)");
vtx_tracks_config.AddField<int>("nhits_mvd", "number of hits in MVD");
if (is_write_kfinfo_) {
- vtx_tracks_config.AddFields<float>({"x", "y", "z", "tx", "ty", "qp"},
- "track parameters");
- vtx_tracks_config.AddFields<float>(
- {"cx0", "cx1", "cx2", "cy0", "cy1", "cy2", "cz0", "cz1", "cz2", "z0"},
- "magnetic field approximation");
- vtx_tracks_config.AddFields<float>({"cov1",
- "cov2",
- "cov3",
- "cov4",
- "cov5",
- "cov6",
- "cov7",
- "cov8",
- "cov9",
- "cov10",
- "cov11",
- "cov12",
- "cov13",
- "cov14",
- "cov15"},
+ vtx_tracks_config.AddFields<float>({"x", "y", "z", "tx", "ty", "qp"}, "track parameters");
+ vtx_tracks_config.AddFields<float>({"cx0", "cx1", "cx2", "cy0", "cy1", "cy2", "cz0", "cz1", "cz2", "z0"},
+ "magnetic field approximation");
+ vtx_tracks_config.AddFields<float>({"cov1", "cov2", "cov3", "cov4", "cov5", "cov6", "cov7", "cov8", "cov9", "cov10",
+ "cov11", "cov12", "cov13", "cov14", "cov15"},
"covarience matrix");
- vtx_tracks_config.AddField<int>("mother_pdg",
- "PDG code of mother particle");
+ vtx_tracks_config.AddField<int>("mother_pdg", "PDG code of mother particle");
vtx_tracks_config.AddField<int>("mc_pdg", "MC-true PDG code");
vtx_tracks_config.AddField<bool>("pass_cuts", "ask Oleksii");
@@ -102,9 +88,8 @@ void CbmStsTracksConverter::Init() {
}
// TODO misleading name, move field filling somewhere else?
-float CbmStsTracksConverter::ExtrapolateToVertex(CbmStsTrack* sts_track,
- AnalysisTree::Track& track,
- int pdg) {
+float CbmStsTracksConverter::ExtrapolateToVertex(CbmStsTrack* sts_track, AnalysisTree::Track& track, int pdg)
+{
vector<CbmStsTrack> tracks = {*sts_track};
CbmL1PFFitter fitter;
@@ -134,7 +119,8 @@ float CbmStsTracksConverter::ExtrapolateToVertex(CbmStsTrack* sts_track,
return chi2_to_vtx[0];
}
-void CbmStsTracksConverter::ReadVertexTracks() {
+void CbmStsTracksConverter::ReadVertexTracks()
+{
assert(cbm_prim_vertex_ && cbm_sts_tracks_);
vtx_tracks_->ClearChannels();
@@ -158,10 +144,10 @@ void CbmStsTracksConverter::ReadVertexTracks() {
auto& track = vtx_tracks_->AddChannel(branch);
- int pdg = GetMcPid((CbmTrackMatchNew*) cbm_sts_match_->At(i_track), track);
+ int pdg = GetMcPid((CbmTrackMatchNew*) cbm_sts_match_->At(i_track), track);
bool is_good_track = IsGoodCovMatrix(sts_track);
- float chi2_vertex = ExtrapolateToVertex(sts_track, track, pdg);
+ float chi2_vertex = ExtrapolateToVertex(sts_track, track, pdg);
const FairTrackParam* trackParamFirst = sts_track->GetParamFirst();
TVector3 momRec;
trackParamFirst->Momentum(momRec);
@@ -172,12 +158,9 @@ void CbmStsTracksConverter::ReadVertexTracks() {
track.SetField(int(sts_track->GetNDF()), indf);
track.SetField(float(sts_track->GetChiSq()), ichi2);
track.SetField(int(sts_track->GetNofHits()), inhits);
- track.SetField(float(trackParamFirst->GetX() - cbm_prim_vertex_->GetX()),
- idcax);
- track.SetField(float(trackParamFirst->GetY() - cbm_prim_vertex_->GetY()),
- idcax + 1);
- track.SetField(float(trackParamFirst->GetZ() - cbm_prim_vertex_->GetZ()),
- idcax + 2);
+ track.SetField(float(trackParamFirst->GetX() - cbm_prim_vertex_->GetX()), idcax);
+ track.SetField(float(trackParamFirst->GetY() - cbm_prim_vertex_->GetY()), idcax + 1);
+ track.SetField(float(trackParamFirst->GetZ() - cbm_prim_vertex_->GetZ()), idcax + 2);
track.SetField(int(sts_track->GetNofMvdHits()), inhits_mvd);
track.SetField(float(chi2_vertex), ivtx_chi2);
@@ -187,9 +170,9 @@ void CbmStsTracksConverter::ReadVertexTracks() {
}
}
-void CbmStsTracksConverter::WriteKFInfo(AnalysisTree::Track& track,
- const CbmStsTrack* sts_track,
- bool is_good_track) const {
+void CbmStsTracksConverter::WriteKFInfo(AnalysisTree::Track& track, const CbmStsTrack* sts_track,
+ bool is_good_track) const
+{
assert(sts_track);
const FairTrackParam* trackParamFirst = sts_track->GetParamFirst();
@@ -208,8 +191,8 @@ void CbmStsTracksConverter::WriteKFInfo(AnalysisTree::Track& track,
track.SetField(is_good_track, ipasscuts_);
}
-bool CbmStsTracksConverter::IsGoodCovMatrix(
- const CbmStsTrack* sts_track) const {
+bool CbmStsTracksConverter::IsGoodCovMatrix(const CbmStsTrack* sts_track) const
+{
if (!is_reproduce_cbmkfpf_) return true;
@@ -234,10 +217,8 @@ bool CbmStsTracksConverter::IsGoodCovMatrix(
for (auto element : cov_matrix) {
ok = ok && isfinite(element);
}
- ok = ok && (cov_matrix[0] < 1. && cov_matrix[0] > 0.)
- && (cov_matrix[2] < 1. && cov_matrix[2] > 0.)
- && (cov_matrix[5] < 1. && cov_matrix[5] > 0.)
- && (cov_matrix[9] < 1. && cov_matrix[9] > 0.)
+ ok = ok && (cov_matrix[0] < 1. && cov_matrix[0] > 0.) && (cov_matrix[2] < 1. && cov_matrix[2] > 0.)
+ && (cov_matrix[5] < 1. && cov_matrix[5] > 0.) && (cov_matrix[9] < 1. && cov_matrix[9] > 0.)
&& (cov_matrix[14] < 1. && cov_matrix[14] > 0.);
ok = ok && sts_track->GetChiSq() < 10. * sts_track->GetNDF();
@@ -245,8 +226,8 @@ bool CbmStsTracksConverter::IsGoodCovMatrix(
return ok;
}
-int CbmStsTracksConverter::GetMcPid(const CbmTrackMatchNew* match,
- AnalysisTree::Track& track) const {
+int CbmStsTracksConverter::GetMcPid(const CbmTrackMatchNew* match, AnalysisTree::Track& track) const
+{
if (!is_write_kfinfo_) { return -2; }
//-----------PID as in MZ's
@@ -267,28 +248,21 @@ int CbmStsTracksConverter::GetMcPid(const CbmTrackMatchNew* match,
}
}
- if (!((bestWeight / totalWeight < 0.7)
- || (mcTrackId >= nMCTracks || mcTrackId < 0))) {
+ if (!((bestWeight / totalWeight < 0.7) || (mcTrackId >= nMCTracks || mcTrackId < 0))) {
auto* mctrack = static_cast<CbmMCTrack*>(cbm_mc_tracks_->At(mcTrackId));
- if (!(TMath::Abs(mctrack->GetPdgCode()) == 11
- || TMath::Abs(mctrack->GetPdgCode()) == 13
- || TMath::Abs(mctrack->GetPdgCode()) == 211
- || TMath::Abs(mctrack->GetPdgCode()) == 321
- || TMath::Abs(mctrack->GetPdgCode()) == 2212
- || TMath::Abs(mctrack->GetPdgCode()) == 1000010020
- || TMath::Abs(mctrack->GetPdgCode()) == 1000010030
- || TMath::Abs(mctrack->GetPdgCode()) == 1000020030
+ if (!(TMath::Abs(mctrack->GetPdgCode()) == 11 || TMath::Abs(mctrack->GetPdgCode()) == 13
+ || TMath::Abs(mctrack->GetPdgCode()) == 211 || TMath::Abs(mctrack->GetPdgCode()) == 321
+ || TMath::Abs(mctrack->GetPdgCode()) == 2212 || TMath::Abs(mctrack->GetPdgCode()) == 1000010020
+ || TMath::Abs(mctrack->GetPdgCode()) == 1000010030 || TMath::Abs(mctrack->GetPdgCode()) == 1000020030
|| TMath::Abs(mctrack->GetPdgCode()) == 1000020040)) {
pdgCode = -1;
- } else {
+ }
+ else {
pdgCode = mctrack->GetPdgCode();
}
if (mctrack->GetMotherId() > -1) {
- track.SetField(
- int(((CbmMCTrack*) cbm_mc_tracks_->At(mctrack->GetMotherId()))
- ->GetPdgCode()),
- imother_pdg_);
+ track.SetField(int(((CbmMCTrack*) cbm_mc_tracks_->At(mctrack->GetMotherId()))->GetPdgCode()), imother_pdg_);
}
}
}
@@ -297,12 +271,10 @@ int CbmStsTracksConverter::GetMcPid(const CbmTrackMatchNew* match,
return pdgCode;
}
-void CbmStsTracksConverter::MapTracks() {
+void CbmStsTracksConverter::MapTracks()
+{
const auto it = indexes_map_->find(match_to_);
- if (it == indexes_map_->end()) {
- throw std::runtime_error(match_to_
- + " is not found to match with vertex tracks");
- }
+ if (it == indexes_map_->end()) { throw std::runtime_error(match_to_ + " is not found to match with vertex tracks"); }
auto sim_tracks_map = it->second;
if (out_indexes_map_.empty() || sim_tracks_map.empty()) return;
@@ -315,8 +287,7 @@ void CbmStsTracksConverter::MapTracks() {
if (match->GetNofLinks() > 0) { // there is at least one matched MC-track
const int mc_track_id = match->GetMatchedLink().GetIndex();
- if (match->GetTrueOverAllHitsRatio()
- < 0.5) // not enough hits to be a match
+ if (match->GetTrueOverAllHitsRatio() < 0.5) // not enough hits to be a match
continue;
auto p = sim_tracks_map.find(mc_track_id);
diff --git a/analysis/common/analysis_tree_converter/CbmStsTracksConverter.h b/analysis/common/analysis_tree_converter/CbmStsTracksConverter.h
index 94d3602c216cb9c462437da83d470b7885270639..152adb5c88b27df1c552977a613d7a2f88e1bcb8 100644
--- a/analysis/common/analysis_tree_converter/CbmStsTracksConverter.h
+++ b/analysis/common/analysis_tree_converter/CbmStsTracksConverter.h
@@ -10,16 +10,18 @@ class CbmVertex;
class CbmStsTrack;
class CbmTrackMatchNew;
-namespace AnalysisTree {
+namespace AnalysisTree
+{
class Matching;
}
class CbmStsTracksConverter final : public CbmConverterTask {
public:
- explicit CbmStsTracksConverter(std::string out_branch_name,
- std::string match_to = "")
- : CbmConverterTask(std::move(out_branch_name), std::move(match_to)) {}
+ explicit CbmStsTracksConverter(std::string out_branch_name, std::string match_to = "")
+ : CbmConverterTask(std::move(out_branch_name), std::move(match_to))
+ {
+ }
~CbmStsTracksConverter() final;
@@ -34,17 +36,13 @@ private:
void ReadVertexTracks();
void MapTracks();
void InitInput();
- float ExtrapolateToVertex(CbmStsTrack* sts_track,
- AnalysisTree::Track& track,
- int pdg);
+ float ExtrapolateToVertex(CbmStsTrack* sts_track, AnalysisTree::Track& track, int pdg);
- void WriteKFInfo(AnalysisTree::Track& track,
- const CbmStsTrack* sts_track,
- bool is_good_track) const;
+ void WriteKFInfo(AnalysisTree::Track& track, const CbmStsTrack* sts_track, bool is_good_track) const;
bool IsGoodCovMatrix(const CbmStsTrack* sts_track) const;
int GetMcPid(const CbmTrackMatchNew* match, AnalysisTree::Track& track) const;
- AnalysisTree::TrackDetector* vtx_tracks_ {nullptr}; ///< raw pointers are needed for TTree::Branch
+ AnalysisTree::TrackDetector* vtx_tracks_ {nullptr}; ///< raw pointers are needed for TTree::Branch
AnalysisTree::Matching* vtx_tracks_2_sim_ {nullptr}; ///< raw pointers are needed for TTree::Branch
CbmVertex* cbm_prim_vertex_ {nullptr}; ///< non-owning pointer
diff --git a/analysis/common/analysis_tree_converter/CbmTofHitsConverter.cxx b/analysis/common/analysis_tree_converter/CbmTofHitsConverter.cxx
index 8f1b5fcc15eb17e2ea4bece14a24dc5b88f93a9c..31833c1c4bd58e1c966a9f1fac8fc69b35cfe531 100644
--- a/analysis/common/analysis_tree_converter/CbmTofHitsConverter.cxx
+++ b/analysis/common/analysis_tree_converter/CbmTofHitsConverter.cxx
@@ -1,23 +1,24 @@
-#include <cassert>
-#include <vector>
+#include "CbmTofHitsConverter.h"
-#include "TClonesArray.h"
+#include <CbmGlobalTrack.h>
+#include <CbmTofHit.h>
+#include <CbmTrackMatchNew.h>
#include <FairMCPoint.h>
#include <FairRootManager.h>
-#include "AnalysisTree/Matching.hpp"
+#include "TClonesArray.h"
#include <AnalysisTree/TaskManager.hpp>
-#include <CbmGlobalTrack.h>
-#include <CbmTofHit.h>
-#include <CbmTrackMatchNew.h>
+#include <cassert>
+#include <vector>
-#include "CbmTofHitsConverter.h"
+#include "AnalysisTree/Matching.hpp"
ClassImp(CbmTofHitsConverter)
- void CbmTofHitsConverter::Init() {
+ void CbmTofHitsConverter::Init()
+{
assert(!out_branch_.empty());
auto* ioman = FairRootManager::Instance();
@@ -29,8 +30,7 @@ ClassImp(CbmTofHitsConverter)
// cbm_mc_tracks_ = (TClonesArray*) ioman->GetObject("MCTrack");
// cbm_sts_match_ = (TClonesArray*) ioman->GetObject("StsTrackMatch");
- AnalysisTree::BranchConfig tof_branch(out_branch_,
- AnalysisTree::DetType::kHit);
+ AnalysisTree::BranchConfig tof_branch(out_branch_, AnalysisTree::DetType::kHit);
tof_branch.AddField<float>("mass2", "Mass squared");
tof_branch.AddField<float>("l", "Track lenght");
tof_branch.AddField<float>("t", "ps(?), Measured time ");
@@ -44,8 +44,8 @@ ClassImp(CbmTofHitsConverter)
man->AddMatching(match_to_, out_branch_, vtx_tracks_2_tof_);
}
-void CbmTofHitsConverter::ExtrapolateStraightLine(FairTrackParam* params,
- float z) {
+void CbmTofHitsConverter::ExtrapolateStraightLine(FairTrackParam* params, float z)
+{
const Float_t Tx = params->GetTx();
const Float_t Ty = params->GetTy();
@@ -58,7 +58,8 @@ void CbmTofHitsConverter::ExtrapolateStraightLine(FairTrackParam* params,
params->SetPosition({x, y, z});
}
-void CbmTofHitsConverter::FillTofHits() {
+void CbmTofHitsConverter::FillTofHits()
+{
assert(cbm_tof_hits_);
tof_hits_->ClearChannels();
vtx_tracks_2_tof_->Clear();
@@ -73,31 +74,25 @@ void CbmTofHitsConverter::FillTofHits() {
const int i_l = branch.GetFieldId("l");
const auto it = indexes_map_->find(match_to_);
- if (it == indexes_map_->end()) {
- throw std::runtime_error(match_to_
- + " is not found to match with TOF hits");
- }
+ if (it == indexes_map_->end()) { throw std::runtime_error(match_to_ + " is not found to match with TOF hits"); }
auto rec_tracks_map = it->second;
tof_hits_->Reserve(cbm_global_tracks_->GetEntries());
for (Int_t igt = 0; igt < cbm_global_tracks_->GetEntries(); igt++) {
- const auto* globalTrack =
- static_cast<const CbmGlobalTrack*>(cbm_global_tracks_->At(igt));
+ const auto* globalTrack = static_cast<const CbmGlobalTrack*>(cbm_global_tracks_->At(igt));
const Int_t tofHitIndex = globalTrack->GetTofHitIndex();
if (tofHitIndex < 0) continue;
- const auto* tofHit =
- static_cast<const CbmTofHit*>(cbm_tof_hits_->At(tofHitIndex));
+ const auto* tofHit = static_cast<const CbmTofHit*>(cbm_tof_hits_->At(tofHitIndex));
FairTrackParam param_last = *(globalTrack->GetParamLast());
TVector3 p_tof;
param_last.Momentum(p_tof);
- const Float_t p = p_tof.Mag();
- const Int_t q = param_last.GetQp() > 0 ? 1 : -1;
- const Float_t l =
- globalTrack->GetLength(); // l is calculated by global tracking
+ const Float_t p = p_tof.Mag();
+ const Int_t q = param_last.GetQp() > 0 ? 1 : -1;
+ const Float_t l = globalTrack->GetLength(); // l is calculated by global tracking
const Float_t time = tofHit->GetTime();
const Float_t beta = l / (time * 29.9792458);
const Float_t m2 = p * p * (1. / (beta * beta) - 1.);
@@ -122,8 +117,7 @@ void CbmTofHitsConverter::FillTofHits() {
if (rec_tracks_map.empty()) { continue; }
const Int_t stsTrackIndex = globalTrack->GetStsTrackIndex();
if (rec_tracks_map.find(stsTrackIndex) != rec_tracks_map.end()) {
- vtx_tracks_2_tof_->AddMatch(rec_tracks_map.find(stsTrackIndex)->second,
- hit.GetId());
+ vtx_tracks_2_tof_->AddMatch(rec_tracks_map.find(stsTrackIndex)->second, hit.GetId());
}
// const auto* tofMatch =
@@ -153,7 +147,8 @@ void CbmTofHitsConverter::FillTofHits() {
void CbmTofHitsConverter::Exec() { FillTofHits(); }
-CbmTofHitsConverter::~CbmTofHitsConverter() {
+CbmTofHitsConverter::~CbmTofHitsConverter()
+{
delete tof_hits_;
delete vtx_tracks_2_tof_;
};
diff --git a/analysis/common/analysis_tree_converter/CbmTofHitsConverter.h b/analysis/common/analysis_tree_converter/CbmTofHitsConverter.h
index de8eeabe7ff2cdaa3ab7ade74ee0e48cb6fcdaa2..796e679ef43fc535f6dfafbeefc8d2c2e390fed6 100644
--- a/analysis/common/analysis_tree_converter/CbmTofHitsConverter.h
+++ b/analysis/common/analysis_tree_converter/CbmTofHitsConverter.h
@@ -8,14 +8,14 @@
class TClonesArray;
class FairTrackParam;
-namespace AnalysisTree {
+namespace AnalysisTree
+{
class Matching;
}
class CbmTofHitsConverter final : public CbmConverterTask {
public:
- explicit CbmTofHitsConverter(std::string out_branch_name,
- std::string match_to = "")
+ explicit CbmTofHitsConverter(std::string out_branch_name, std::string match_to = "")
: CbmConverterTask(std::move(out_branch_name), std::move(match_to)) {};
~CbmTofHitsConverter() final;
diff --git a/analysis/common/analysis_tree_converter/CbmTrdTracksConverter.cxx b/analysis/common/analysis_tree_converter/CbmTrdTracksConverter.cxx
index e73de281357e124a329b887051868d7322668382..489bf2f1f16f6818cfa7b4b17ec0f10ca982c61c 100644
--- a/analysis/common/analysis_tree_converter/CbmTrdTracksConverter.cxx
+++ b/analysis/common/analysis_tree_converter/CbmTrdTracksConverter.cxx
@@ -1,24 +1,25 @@
#include "CbmTrdTracksConverter.h"
-#include <cassert>
-#include <vector>
-
-#include "TClonesArray.h"
+#include <CbmGlobalTrack.h>
+#include <CbmTrackMatchNew.h>
+#include <CbmTrdHit.h>
+#include <CbmTrdTrack.h>
#include <FairMCPoint.h>
#include <FairRootManager.h>
-#include "AnalysisTree/Matching.hpp"
+#include "TClonesArray.h"
+
#include <AnalysisTree/TaskManager.hpp>
+#include <cassert>
+#include <vector>
-#include <CbmGlobalTrack.h>
-#include <CbmTrackMatchNew.h>
-#include <CbmTrdHit.h>
-#include <CbmTrdTrack.h>
+#include "AnalysisTree/Matching.hpp"
ClassImp(CbmTrdTracksConverter)
- void CbmTrdTracksConverter::Init() {
+ void CbmTrdTracksConverter::Init()
+{
assert(!out_branch_.empty());
auto* ioman = FairRootManager::Instance();
@@ -27,12 +28,11 @@ ClassImp(CbmTrdTracksConverter)
cbm_global_tracks_ = (TClonesArray*) ioman->GetObject("GlobalTrack");
cbm_trd_hits_ = (TClonesArray*) ioman->GetObject("TrdHit");
- AnalysisTree::BranchConfig trd_branch(out_branch_,
- AnalysisTree::DetType::kTrack);
- trd_branch.AddFields<float>(
- {"energy_loss_0", "energy_loss_1", "energy_loss_2", "energy_loss_3"}, "keV(?), Energy loss per TRD station");
- trd_branch.AddFields<float>(
- {"pid_like_e", "pid_like_pi", "pid_like_k", "pid_like_p"}, "Probability to be a given particle specie");
+ AnalysisTree::BranchConfig trd_branch(out_branch_, AnalysisTree::DetType::kTrack);
+ trd_branch.AddFields<float>({"energy_loss_0", "energy_loss_1", "energy_loss_2", "energy_loss_3"},
+ "keV(?), Energy loss per TRD station");
+ trd_branch.AddFields<float>({"pid_like_e", "pid_like_pi", "pid_like_k", "pid_like_p"},
+ "Probability to be a given particle specie");
trd_branch.AddField<float>("chi2_ov_ndf", "chi2 divided by NDF of the track fit");
trd_branch.AddFields<float>({"pT_out", "p_out"}, "Momentum at last point (?)");
trd_branch.AddField<int>("n_hits", "Number of hits");
@@ -42,7 +42,8 @@ ClassImp(CbmTrdTracksConverter)
man->AddMatching(match_to_, out_branch_, vtx_tracks_2_trd_);
}
-void CbmTrdTracksConverter::FillTrdTracks() {
+void CbmTrdTracksConverter::FillTrdTracks()
+{
assert(cbm_trd_tracks_);
trd_tracks_->ClearChannels();
@@ -59,17 +60,13 @@ void CbmTrdTracksConverter::FillTrdTracks() {
const int i_n_hits = branch.GetFieldId("n_hits");
const auto it = indexes_map_->find(match_to_);
- if (it == indexes_map_->end()) {
- throw std::runtime_error(match_to_
- + " is not found to match with TOF hits");
- }
+ if (it == indexes_map_->end()) { throw std::runtime_error(match_to_ + " is not found to match with TOF hits"); }
auto rec_tracks_map = it->second;
trd_tracks_->Reserve(cbm_global_tracks_->GetEntries());
for (Int_t igt = 0; igt < cbm_global_tracks_->GetEntries(); igt++) {
- const auto* global_track =
- static_cast<const CbmGlobalTrack*>(cbm_global_tracks_->At(igt));
+ const auto* global_track = static_cast<const CbmGlobalTrack*>(cbm_global_tracks_->At(igt));
Int_t itrd = global_track->GetTrdTrackIndex();
if (itrd < 0) continue;
@@ -92,11 +89,9 @@ void CbmTrdTracksConverter::FillTrdTracks() {
track.SetField(float(trd_track->GetPidLikePI()), i_pid_like + 1);
track.SetField(float(trd_track->GetPidLikeKA()), i_pid_like + 2);
track.SetField(float(trd_track->GetPidLikePR()), i_pid_like + 3);
-// track.SetField(float(trd_track->GetPidLikeMU()), i_pid_like + 4);
+ // track.SetField(float(trd_track->GetPidLikeMU()), i_pid_like + 4);
- track.SetField(float(trd_track->GetNDF() > 0.
- ? trd_track->GetChiSq() / trd_track->GetNDF()
- : -999.),
+ track.SetField(float(trd_track->GetNDF() > 0. ? trd_track->GetChiSq() / trd_track->GetNDF() : -999.),
i_chi2_ov_ndf);
track.SetField(float(mom_last.Pt()), i_pT_out);
@@ -111,23 +106,22 @@ void CbmTrdTracksConverter::FillTrdTracks() {
auto* hit = (CbmTrdHit*) cbm_trd_hits_->At(idx);
if (hit) {
// std::cout << hit->GetELoss()*1e6 << " " << hit->GetPlaneId() << std::endl;
- track.SetField(float(hit->GetELoss() * 1e6),
- i_e_loss_i + hit->GetPlaneId());
+ track.SetField(float(hit->GetELoss() * 1e6), i_e_loss_i + hit->GetPlaneId());
}
}
if (rec_tracks_map.empty()) { continue; }
const Int_t stsTrackIndex = global_track->GetStsTrackIndex();
if (rec_tracks_map.find(stsTrackIndex) != rec_tracks_map.end()) {
- vtx_tracks_2_trd_->AddMatch(rec_tracks_map.find(stsTrackIndex)->second,
- track.GetId());
+ vtx_tracks_2_trd_->AddMatch(rec_tracks_map.find(stsTrackIndex)->second, track.GetId());
}
}
}
void CbmTrdTracksConverter::Exec() { FillTrdTracks(); }
-CbmTrdTracksConverter::~CbmTrdTracksConverter() {
+CbmTrdTracksConverter::~CbmTrdTracksConverter()
+{
delete trd_tracks_;
delete vtx_tracks_2_trd_;
};
diff --git a/analysis/common/analysis_tree_converter/CbmTrdTracksConverter.h b/analysis/common/analysis_tree_converter/CbmTrdTracksConverter.h
index ff194782af298b22c635c4d1506cf1e2efdecb43..8adf8d8491e62c84580a57dcda86c8c434a2559d 100644
--- a/analysis/common/analysis_tree_converter/CbmTrdTracksConverter.h
+++ b/analysis/common/analysis_tree_converter/CbmTrdTracksConverter.h
@@ -7,18 +7,25 @@
class TClonesArray;
-namespace AnalysisTree {
+namespace AnalysisTree
+{
class Matching;
}
class CbmTrdTracksConverter final : public CbmConverterTask {
- enum kInBranches { kTrdTrack = 0, kGlobalTrack, kTrdHit };
+ enum kInBranches
+ {
+ kTrdTrack = 0,
+ kGlobalTrack,
+ kTrdHit
+ };
public:
- explicit CbmTrdTracksConverter(std::string out_branch_name,
- std::string match_to = "")
- : CbmConverterTask(std::move(out_branch_name), std::move(match_to)) {}
+ explicit CbmTrdTracksConverter(std::string out_branch_name, std::string match_to = "")
+ : CbmConverterTask(std::move(out_branch_name), std::move(match_to))
+ {
+ }
~CbmTrdTracksConverter() final;
diff --git a/analysis/common/at_kfpf_interface/ATKFParticleFinder.cxx b/analysis/common/at_kfpf_interface/ATKFParticleFinder.cxx
index f5cbd021646720b640ec67ddf714de54665dde8f..7aa1292f614e4560de94bbd9a89ecf70e4e864cf 100644
--- a/analysis/common/at_kfpf_interface/ATKFParticleFinder.cxx
+++ b/analysis/common/at_kfpf_interface/ATKFParticleFinder.cxx
@@ -1,7 +1,7 @@
#include "ATKFParticleFinder.h"
-void ATKFParticleFinder::InitInput(const std::string& file_name,
- const std::string& tree_name) {
+void ATKFParticleFinder::InitInput(const std::string& file_name, const std::string& tree_name)
+{
std::cout << "ATKFParticleFinder::InitInput()\n";
// topo_reconstructor_ = new KFParticleTopoReconstructor;
@@ -29,13 +29,13 @@ void ATKFParticleFinder::InitInput(const std::string& file_name,
vtx_chi2_field_id_ = branch_conf_kftr.GetFieldId("vtx_chi2");
}
-void ATKFParticleFinder::InitOutput(const std::string& file_name) {
+void ATKFParticleFinder::InitOutput(const std::string& file_name)
+{
std::cout << "ATKFParticleFinder::InitOutput()\n";
out_file_ = TFile::Open(file_name.c_str(), "recreate");
- AnalysisTree::BranchConfig ParticlesRecoBranch(
- "ParticlesReconstructed", AnalysisTree::DetType::kParticle);
+ AnalysisTree::BranchConfig ParticlesRecoBranch("ParticlesReconstructed", AnalysisTree::DetType::kParticle);
ParticlesRecoBranch.AddField<int>("daughter1id");
ParticlesRecoBranch.AddField<int>("daughter2id");
@@ -44,34 +44,31 @@ void ATKFParticleFinder::InitOutput(const std::string& file_name) {
particles_reco_ = new AnalysisTree::Particles(out_config_.GetBranchConfig("ParticlesReconstructed").GetId());
out_tree_ = new TTree("aTree", "AnalysisTree ParticlesReco");
- out_tree_->Branch(
- "ParticlesReconstructed", "AnalysisTree::Particles", &particles_reco_);
+ out_tree_->Branch("ParticlesReconstructed", "AnalysisTree::Particles", &particles_reco_);
out_config_.Write("Configuration");
- daughter1_id_field_id_ = out_config_.GetBranchConfig(particles_reco_->GetId())
- .GetFieldId("daughter1id");
- daughter2_id_field_id_ = out_config_.GetBranchConfig(particles_reco_->GetId())
- .GetFieldId("daughter2id");
+ daughter1_id_field_id_ = out_config_.GetBranchConfig(particles_reco_->GetId()).GetFieldId("daughter1id");
+ daughter2_id_field_id_ = out_config_.GetBranchConfig(particles_reco_->GetId()).GetFieldId("daughter2id");
}
-void ATKFParticleFinder::Finish() {
+void ATKFParticleFinder::Finish()
+{
std::cout << "ATKFParticleFinder::Finish()\n";
out_tree_->Write();
out_file_->Close();
}
-void ATKFParticleFinder::Run(int n_events) {
- if (n_events < 0 || n_events > in_chain_->GetEntries())
- n_events = in_chain_->GetEntries();
+void ATKFParticleFinder::Run(int n_events)
+{
+ if (n_events < 0 || n_events > in_chain_->GetEntries()) n_events = in_chain_->GetEntries();
std::cout << "ATKFParticleFinder::Run() " << n_events << " events\n";
for (int i_event = 0; i_event < n_events; i_event++) {
std::cout << "eveNo = " << i_event << "\n";
in_chain_->GetEntry(i_event);
- KFParticleTopoReconstructor* eventTopoReconstructor =
- CreateTopoReconstructor();
+ KFParticleTopoReconstructor* eventTopoReconstructor = CreateTopoReconstructor();
// const KFPTrackVector* tv = eventTopoReconstructor->GetTracks();
// KFPTrackVector tvv = *tv;
@@ -85,7 +82,8 @@ void ATKFParticleFinder::Run(int n_events) {
Finish();
}
-KFParticleTopoReconstructor* ATKFParticleFinder::CreateTopoReconstructor() {
+KFParticleTopoReconstructor* ATKFParticleFinder::CreateTopoReconstructor()
+{
//
// Creates the pointer on the KFParticleTopoReconstructor object
// with all necessary input information in order to perform particle selection using
@@ -95,20 +93,17 @@ KFParticleTopoReconstructor* ATKFParticleFinder::CreateTopoReconstructor() {
// cuts setting
TR->GetKFParticleFinder()->SetChiPrimaryCut2D(cuts_.GetCutChi2Prim());
- TR->GetKFParticleFinder()->SetMaxDistanceBetweenParticlesCut(
- cuts_.GetCutDistance());
+ TR->GetKFParticleFinder()->SetMaxDistanceBetweenParticlesCut(cuts_.GetCutDistance());
TR->GetKFParticleFinder()->SetChi2Cut2D(cuts_.GetCutChi2Geo());
TR->GetKFParticleFinder()->SetLCut(cuts_.GetCutLDown());
TR->GetKFParticleFinder()->SetLdLCut2D(cuts_.GetCutLdL());
int n_good_tracks = 0;
- for (unsigned int i_track = 0; i_track < kf_tracks_->GetNumberOfChannels();
- i_track++) {
+ for (unsigned int i_track = 0; i_track < kf_tracks_->GetNumberOfChannels(); i_track++) {
const AnalysisTree::Track& rec_track = kf_tracks_->GetChannel(i_track);
if (rec_track.GetField<bool>(passcuts_field_id_) == 0) continue;
- if (rec_track.GetField<int>(pdg_field_id_) == -2 && pid_mode_ == 1)
- continue;
+ if (rec_track.GetField<int>(pdg_field_id_) == -2 && pid_mode_ == 1) continue;
n_good_tracks++;
}
@@ -117,17 +112,14 @@ KFParticleTopoReconstructor* ATKFParticleFinder::CreateTopoReconstructor() {
int j_track = 0;
- for (unsigned int i_track = 0; i_track < kf_tracks_->GetNumberOfChannels();
- i_track++) {
+ for (unsigned int i_track = 0; i_track < kf_tracks_->GetNumberOfChannels(); i_track++) {
const AnalysisTree::Track& rec_track = kf_tracks_->GetChannel(i_track);
if (rec_track.GetField<bool>(passcuts_field_id_) == 0) continue;
- if (rec_track.GetField<int>(pdg_field_id_) == -2 && pid_mode_ == 1)
- continue;
+ if (rec_track.GetField<int>(pdg_field_id_) == -2 && pid_mode_ == 1) continue;
for (Int_t iP = 0; iP < 3; iP++)
- track_vector1.SetParameter(
- rec_track.GetField<float>(par_field_id_ + iP), iP, j_track);
+ track_vector1.SetParameter(rec_track.GetField<float>(par_field_id_ + iP), iP, j_track);
track_vector1.SetParameter(rec_track.GetPx(), 3, j_track);
track_vector1.SetParameter(rec_track.GetPy(), 4, j_track);
track_vector1.SetParameter(rec_track.GetPz(), 5, j_track);
@@ -135,28 +127,22 @@ KFParticleTopoReconstructor* ATKFParticleFinder::CreateTopoReconstructor() {
for (Int_t iC = 0; iC < 21; iC++)
track_vector1.SetCovariance(cov_matrix.at(iC), iC, j_track);
for (Int_t iF = 0; iF < 10; iF++)
- track_vector1.SetFieldCoefficient(
- rec_track.GetField<float>(mf_field_id_ + iF), iF, j_track);
- if (pid_mode_ == 0)
- track_vector1.SetPDG(-1, j_track);
+ track_vector1.SetFieldCoefficient(rec_track.GetField<float>(mf_field_id_ + iF), iF, j_track);
+ if (pid_mode_ == 0) track_vector1.SetPDG(-1, j_track);
else if (pid_mode_ == 1)
track_vector1.SetPDG(rec_track.GetField<int>(pdg_field_id_), j_track);
track_vector1.SetQ(rec_track.GetField<int>(q_field_id_), j_track);
- if (rec_track.GetField<float>(vtx_chi2_field_id_) < 3.)
- track_vector1.SetPVIndex(0, j_track);
+ if (rec_track.GetField<float>(vtx_chi2_field_id_) < 3.) track_vector1.SetPVIndex(0, j_track);
else
track_vector1.SetPVIndex(-1, j_track);
- track_vector1.SetNPixelHits(rec_track.GetField<int>(nhits_mvd_field_id_),
- j_track);
+ track_vector1.SetNPixelHits(rec_track.GetField<int>(nhits_mvd_field_id_), j_track);
track_vector1.SetId(rec_track.GetId(), j_track);
j_track++;
}
TR->Init(track_vector1, track_vector2);
KFPVertex primVtx_tmp;
- primVtx_tmp.SetXYZ(rec_event_header_->GetVertexX(),
- rec_event_header_->GetVertexY(),
- rec_event_header_->GetVertexZ());
+ primVtx_tmp.SetXYZ(rec_event_header_->GetVertexX(), rec_event_header_->GetVertexY(), rec_event_header_->GetVertexZ());
primVtx_tmp.SetCovarianceMatrix(0, 0, 0, 0, 0, 0);
primVtx_tmp.SetNContributors(0);
primVtx_tmp.SetChi2(-100);
@@ -169,11 +155,11 @@ KFParticleTopoReconstructor* ATKFParticleFinder::CreateTopoReconstructor() {
return TR;
}
-void ATKFParticleFinder::WriteCandidates(
- const KFParticleTopoReconstructor* eventTR) {
+void ATKFParticleFinder::WriteCandidates(const KFParticleTopoReconstructor* eventTR)
+{
particles_reco_->ClearChannels();
- for (const auto & particle : eventTR->GetParticles()) {
+ for (const auto& particle : eventTR->GetParticles()) {
auto* particlerec = particles_reco_->AddChannel();
particlerec->Init(out_config_.GetBranchConfig(particles_reco_->GetId()));
@@ -182,8 +168,7 @@ void ATKFParticleFinder::WriteCandidates(
particlerec->SetMass(mass);
particlerec->SetField(particle.DaughterIds()[0], daughter1_id_field_id_);
particlerec->SetField(particle.DaughterIds()[1], daughter2_id_field_id_);
- particlerec->SetMomentum(
- particle.GetPx(), particle.GetPy(), particle.GetPz());
+ particlerec->SetMomentum(particle.GetPx(), particle.GetPy(), particle.GetPz());
particlerec->SetPid(particle.GetPDG());
// topo_reconstructor_->AddParticle(particle);
@@ -191,8 +176,8 @@ void ATKFParticleFinder::WriteCandidates(
out_tree_->Fill();
}
-std::vector<float>
-ATKFParticleFinder::GetCovMatrixCbm(const AnalysisTree::Track& track) const {
+std::vector<float> ATKFParticleFinder::GetCovMatrixCbm(const AnalysisTree::Track& track) const
+{
const double tx = track.GetField<float>(par_field_id_ + 3);
const double ty = track.GetField<float>(par_field_id_ + 4);
const double qp = track.GetField<float>(par_field_id_ + 5);
@@ -211,12 +196,9 @@ ATKFParticleFinder::GetCovMatrixCbm(const AnalysisTree::Track& track) const {
const double dpzdty = -q / qp * ty / t3;
const double dpzdqp = -q / (qp * qp * t3);
- const double F[6][5] = {{1.f, 0.f, 0.f, 0.f, 0.f},
- {0.f, 1.f, 0.f, 0.f, 0.f},
- {0.f, 0.f, 0.f, 0.f, 0.f},
- {0.f, 0.f, dpxdtx, dpxdty, dpxdqp},
- {0.f, 0.f, dpydtx, dpydty, dpydqp},
- {0.f, 0.f, dpzdtx, dpzdty, dpzdqp}};
+ const double F[6][5] = {{1.f, 0.f, 0.f, 0.f, 0.f}, {0.f, 1.f, 0.f, 0.f, 0.f},
+ {0.f, 0.f, 0.f, 0.f, 0.f}, {0.f, 0.f, dpxdtx, dpxdty, dpxdqp},
+ {0.f, 0.f, dpydtx, dpydty, dpydqp}, {0.f, 0.f, dpzdtx, dpzdty, dpzdqp}};
double VFT[5][6];
for (int i = 0; i < 5; i++)
@@ -224,13 +206,11 @@ ATKFParticleFinder::GetCovMatrixCbm(const AnalysisTree::Track& track) const {
VFT[i][j] = 0;
for (int k = 0; k < 5; k++) {
if (k <= i)
- VFT[i][j] +=
- track.GetField<float>(cov_field_id_ + k + i * (i + 1) / 2)
- * F[j][k]; //parameters->GetCovariance(i,k) * F[j][k];
+ VFT[i][j] += track.GetField<float>(cov_field_id_ + k + i * (i + 1) / 2)
+ * F[j][k]; //parameters->GetCovariance(i,k) * F[j][k];
else
- VFT[i][j] +=
- track.GetField<float>(cov_field_id_ + i + k * (k + 1) / 2)
- * F[j][k]; //parameters->GetCovariance(i,k) * F[j][k];
+ VFT[i][j] += track.GetField<float>(cov_field_id_ + i + k * (k + 1) / 2)
+ * F[j][k]; //parameters->GetCovariance(i,k) * F[j][k];
}
}
diff --git a/analysis/common/at_kfpf_interface/ATKFParticleFinder.h b/analysis/common/at_kfpf_interface/ATKFParticleFinder.h
index a2a23aa35a6ceed689ad9e17eb3269a0322051a8..5c65c661b0d8537b1f8ae450956883a6476fbcba 100644
--- a/analysis/common/at_kfpf_interface/ATKFParticleFinder.h
+++ b/analysis/common/at_kfpf_interface/ATKFParticleFinder.h
@@ -1,17 +1,16 @@
#ifndef ATKFParticleFinder_HH
#define ATKFParticleFinder_HH
-#include <string>
-#include <utility>
-
#include "TChain.h"
#include "TFile.h"
#include "TTree.h"
+#include <string>
+#include <utility>
+
#include "AnalysisTree/Configuration.hpp"
#include "AnalysisTree/Detector.hpp"
#include "AnalysisTree/EventHeader.hpp"
-
#include "CutsContainer.h"
#include "KFParticleTopoReconstructor.h"