diff --git a/analysis/PWGC2F/femtoscopy/hal/CMakeLists.txt b/analysis/PWGC2F/femtoscopy/hal/CMakeLists.txt
index abfabf4c395fced91229672b6979b381e75ee8a0..570c11d80601985d2d08783e3cfe1b272b6e4c52 100644
--- a/analysis/PWGC2F/femtoscopy/hal/CMakeLists.txt
+++ b/analysis/PWGC2F/femtoscopy/hal/CMakeLists.txt
@@ -33,6 +33,14 @@ set(HAL_CBM_FORMAT
${HAL_CBM}/format/anatree/mc
${HAL_CBM}/format/anatree/femto
${HAL_CBM}/format/unigen
+ ${HAL_CBM}/format/v0
+)
+set(HAL_CBM_HELPERS
+ ${HAL_CBM}/helpers
+ ${HAL_CBM}/helpers/anatree
+ ${HAL_CBM}/helpers/fair
+ ${HAL_CBM}/helpers/faircbm
+ ${HAL_CBM}/helpers/hal
)
set(HAL_CBM_CUTS
@@ -43,4 +51,4 @@ set(HAL_CBM_CUTS
add_subdirectory(format)
add_subdirectory(cuts)
add_subdirectory(helpers)
-add_subdirectory(qa)
+#add_subdirectory(qa)
diff --git a/analysis/PWGC2F/femtoscopy/hal/format/CMakeLists.txt b/analysis/PWGC2F/femtoscopy/hal/format/CMakeLists.txt
index 28e89c3e7ab19207af7e9f33103f9a4cc5067200..1ea0995fc71210144d672f3f880688e4181bcd76 100644
--- a/analysis/PWGC2F/femtoscopy/hal/format/CMakeLists.txt
+++ b/analysis/PWGC2F/femtoscopy/hal/format/CMakeLists.txt
@@ -27,6 +27,7 @@ set(SRCS
HalCbmFormatTypes.cxx
+HalCbmReader.cxx
combined/HalCbmFullEvent.cxx
combined/HalCbmHbtFullEvent.cxx
@@ -48,6 +49,11 @@ anatree/reco/HalCbmTrackInterface.cxx
anatree/femto/HalCbmHbtTrack.cxx
anatree/femto/HalCbmHbtEvent.cxx
+v0/HalCbmV0Builder.cxx
+v0/HalCbmV0TempTrack.cxx
+v0/HalCbmV0Track.cxx
+v0/HalCbmV0TrackTrigger.cxx
+
)
Set(HEADERS )
diff --git a/analysis/PWGC2F/femtoscopy/hal/format/HalCbmFormatLinkDef.h b/analysis/PWGC2F/femtoscopy/hal/format/HalCbmFormatLinkDef.h
index 012a9623b96c32780c29d9e2b15a88047584c195..9bce7a24baf05f1d0a505cf910bcf255256728c1 100644
--- a/analysis/PWGC2F/femtoscopy/hal/format/HalCbmFormatLinkDef.h
+++ b/analysis/PWGC2F/femtoscopy/hal/format/HalCbmFormatLinkDef.h
@@ -27,3 +27,11 @@
#pragma link C++ class HalCbmEventInterface + ;
#pragma link C++ class HalCbmTrack + ;
#pragma link C++ class HalCbmTrackInterface + ;
+
+
+#pragma link C++ class HalCbmReader + ;
+#pragma link C++ class HalCbmV0TrackTrigger + ;
+#pragma link C++ class HalCbmV0Track + ;
+#pragma link C++ class HalCbmV0TempTrack + ;
+#pragma link C++ class HalCbmV0Track + ;
+#pragma link C++ class HalCbmV0Builder + ;
diff --git a/analysis/PWGC2F/femtoscopy/hal/format/HalCbmReader.cxx b/analysis/PWGC2F/femtoscopy/hal/format/HalCbmReader.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..de9b901e3c5e5f949f5e0d362340b3b80982e5d5
--- /dev/null
+++ b/analysis/PWGC2F/femtoscopy/hal/format/HalCbmReader.cxx
@@ -0,0 +1,33 @@
+/* Copyright (C) 2025-2025 Warsaw University of Technology, Warsaw
+ SPDX-License-Identifier: GPL-3.0-only
+ Authors: Daniel Wielanek [committer] */
+#include "HalCbmReader.h"
+
+#include "HalCbmEvent.h"
+#include "HalCbmFullEvent.h"
+#include "HalCbmMCEvent.h"
+
+#include <RtypesCore.h>
+#include <TString.h>
+
+#include <Hal/StdString.h>
+
+namespace Hal
+{
+
+} /* namespace Hal */
+
+HalCbmReader::HalCbmReader(TString opt)
+{
+ if (Hal::Std::FindParam(opt, "reco", false) && Hal::Std::FindParam(opt, "mc", false)) {
+ SetFormat(new HalCbmFullEvent());
+ }
+ else if (Hal::Std::FindParam(opt, "mc", false)) {
+ SetFormat(new HalCbmMCEvent());
+ }
+ else {
+ SetFormat(new HalCbmEvent());
+ }
+}
+
+HalCbmReader::~HalCbmReader() {}
diff --git a/analysis/PWGC2F/femtoscopy/hal/format/HalCbmReader.h b/analysis/PWGC2F/femtoscopy/hal/format/HalCbmReader.h
new file mode 100644
index 0000000000000000000000000000000000000000..3f1d42d337127abdeb3efb83f0fbe54e65a63bdd
--- /dev/null
+++ b/analysis/PWGC2F/femtoscopy/hal/format/HalCbmReader.h
@@ -0,0 +1,21 @@
+/* Copyright (C) 2025-2025 Warsaw University of Technology, Warsaw
+ SPDX-License-Identifier: GPL-3.0-only
+ Authors: Daniel Wielanek [committer] */
+
+#ifndef CBMROOT_V0_ANALYSIS_PWGC2F_FEMTOSCOPY_HAL_FORMAT_HALCBMREADER_H_
+#define CBMROOT_V0_ANALYSIS_PWGC2F_FEMTOSCOPY_HAL_FORMAT_HALCBMREADER_H_
+
+#include <Hal/Reader.h>
+namespace Hal
+{
+ class EventInterface;
+}
+class HalCbmReader : public Hal::Reader {
+
+ public:
+ HalCbmReader(TString opt = "mc+reco");
+ virtual ~HalCbmReader();
+ ClassDef(HalCbmReader, 1)
+};
+
+#endif /* CBMROOT_V0_ANALYSIS_PWGC2F_FEMTOSCOPY_HAL_FORMAT_HALCBMREADER_H_ */
diff --git a/analysis/PWGC2F/femtoscopy/hal/format/anatree/mc/HalCbmMCEvent.cxx b/analysis/PWGC2F/femtoscopy/hal/format/anatree/mc/HalCbmMCEvent.cxx
index bb86515bcc80ba91d9518d065c2a81e58a30a439..dd9b7bc182a11ac3d1401f59ef64d54a1cada928 100644
--- a/analysis/PWGC2F/femtoscopy/hal/format/anatree/mc/HalCbmMCEvent.cxx
+++ b/analysis/PWGC2F/femtoscopy/hal/format/anatree/mc/HalCbmMCEvent.cxx
@@ -60,10 +60,10 @@ void HalCbmMCEvent::ShallowCopyTracks(Hal::Event* event)
void HalCbmMCEvent::UpdateAnalysisTree(Hal::EventInterface* source)
{
- HalCbmMCEventInterface* s = static_cast<HalCbmMCEventInterface*>(source);
- CbmAnaTreeMcSourceContainer* data = (CbmAnaTreeMcSourceContainer*) s->GetRawEventPointer();
- AnaTreeMcIds conf = data->GetFieldIds();
- Bool_t UseFreez = kTRUE;
+ HalCbmMCEventInterface* s = static_cast<HalCbmMCEventInterface*>(source);
+ CbmAnaTreeMcContainer* data = (CbmAnaTreeMcContainer*) s->GetRawEventPointer();
+ AnaTreeMcIds conf = data->GetFieldIds();
+ Bool_t UseFreez = kTRUE;
if (conf.freezX == AnalysisTree::UndefValueShort) {
UseFreez = kFALSE;
}
@@ -89,7 +89,7 @@ void HalCbmMCEvent::UpdateAnalysisTree(Hal::EventInterface* source)
Double_t y = particle.GetField<float>(conf.freezY);
Double_t z = particle.GetField<float>(conf.freezZ);
Double_t t = particle.GetField<float>(conf.freezT);
- track->SetFreezoutPosition(x, y, z, t);
+ track->SetFreezeoutPosition(x, y, z, t);
}
if (mother_id == -1) {
diff --git a/analysis/PWGC2F/femtoscopy/hal/format/anatree/mc/HalCbmMCEventInterface.cxx b/analysis/PWGC2F/femtoscopy/hal/format/anatree/mc/HalCbmMCEventInterface.cxx
index 2b0242885dd46d941ba9d7f7c37eec623ee91195..3e200491e0c5747e0c4b90e8a0743a31312ba9d1 100644
--- a/analysis/PWGC2F/femtoscopy/hal/format/anatree/mc/HalCbmMCEventInterface.cxx
+++ b/analysis/PWGC2F/femtoscopy/hal/format/anatree/mc/HalCbmMCEventInterface.cxx
@@ -20,7 +20,7 @@ void HalCbmMCEventInterface::Register(Bool_t write)
Hal::DataManager* manager = Hal::DataManager::Instance();
switch (fFormatType) {
case HalCbm::DataFormat::kAnalysisTree: {
- manager->Register("CbmAnaTreeMcSourceContainer.", "CbmAnaTreeMcSourceContainer.", fDataContainer, write);
+ manager->Register(HalCbm::GetContainerName("mc"), "CbmAnaTreeMcSourceContainer.", fDataContainer, write);
} break;
case HalCbm::DataFormat::kDST: {
manager->Register("CbmMCTrack", "Tracks", fCbmMCtracks, write);
@@ -81,7 +81,7 @@ HalCbmMCEventInterface::~HalCbmMCEventInterface() {}
void HalCbmMCEventInterface::ConnectToTreeInternal(eMode /*mode*/)
{
Hal::DataManager* manager = Hal::DataManager::Instance();
- fDataContainer = (CbmAnaTreeMcSourceContainer*) manager->GetObject("CbmAnaTreeMcSourceContainer.");
+ fDataContainer = (CbmAnaTreeMcContainer*) manager->GetObject(HalCbm::GetContainerName("mc"));
if (fDataContainer) {
fFormatType = HalCbm::DataFormat::kAnalysisTree;
}
diff --git a/analysis/PWGC2F/femtoscopy/hal/format/anatree/mc/HalCbmMCEventInterface.h b/analysis/PWGC2F/femtoscopy/hal/format/anatree/mc/HalCbmMCEventInterface.h
index 04ecbd8512ef00aafde24d59d4d19c0a0c1d28c1..1ac520a3466d7a6553b60bb4f791ecb8a2426be4 100644
--- a/analysis/PWGC2F/femtoscopy/hal/format/anatree/mc/HalCbmMCEventInterface.h
+++ b/analysis/PWGC2F/femtoscopy/hal/format/anatree/mc/HalCbmMCEventInterface.h
@@ -14,7 +14,7 @@
class TClonesArray;
class FairMCEventHeader;
-class CbmAnaTreeMcSourceContainer;
+class CbmAnaTreeMcContainer;
class HalCbmFullEvent;
class HalCbmMCEventInterface : public Hal::EventInterface {
@@ -22,15 +22,15 @@ class HalCbmMCEventInterface : public Hal::EventInterface {
friend class HalCbmFullEvent;
protected:
- HalCbm::DataFormat fFormatType = {HalCbm::DataFormat::kUnknown};
- CbmAnaTreeMcSourceContainer* fDataContainer = {nullptr};
- FairMCEventHeader* fEventHeader = {nullptr};
- TClonesArray* fCbmMCtracks = {nullptr};
- TClonesArray* fStsMatches = {nullptr};
- TClonesArray* fTofMatches = {nullptr};
- TClonesArray* fTrdMatches = {nullptr};
- TClonesArray* fRichMatches = {nullptr};
- TClonesArray* fMuchMatches = {nullptr};
+ HalCbm::DataFormat fFormatType = {HalCbm::DataFormat::kUnknown};
+ CbmAnaTreeMcContainer* fDataContainer = {nullptr};
+ FairMCEventHeader* fEventHeader = {nullptr};
+ TClonesArray* fCbmMCtracks = {nullptr};
+ TClonesArray* fStsMatches = {nullptr};
+ TClonesArray* fTofMatches = {nullptr};
+ TClonesArray* fTrdMatches = {nullptr};
+ TClonesArray* fRichMatches = {nullptr};
+ TClonesArray* fMuchMatches = {nullptr};
virtual void ConnectToTreeInternal(eMode mode);
void Register(Bool_t write);
diff --git a/analysis/PWGC2F/femtoscopy/hal/format/anatree/reco/HalCbmEvent.cxx b/analysis/PWGC2F/femtoscopy/hal/format/anatree/reco/HalCbmEvent.cxx
index bc0cd90608521721bd3ba06b47a5f668e8e60528..51efb74c4348ddfdf113810925b2c2a33af2016c 100644
--- a/analysis/PWGC2F/femtoscopy/hal/format/anatree/reco/HalCbmEvent.cxx
+++ b/analysis/PWGC2F/femtoscopy/hal/format/anatree/reco/HalCbmEvent.cxx
@@ -1,36 +1,52 @@
/* Copyright (C) 2023-2023 Warsaw University of Technology, Warsaw
SPDX-License-Identifier: GPL-3.0-only
Authors: Daniel Wielanek [committer] */
+
#include "HalCbmEvent.h"
#include "CbmAnaTreeContainer.h"
#include "CbmGlobalTrack.h"
+#include "CbmHit.h"
+#include "CbmStsTrack.h"
#include "CbmTofHit.h"
+#include "CbmTrackParam.h"
+#include "HalCbmDetectorID.h"
#include "HalCbmEventInterface.h"
-#include "HalCbmTrack.h"
+#include "HalCbmV0TempTrack.h"
+
+#include <FairTrackParam.h>
+#include <TClonesArray.h>
#include <TLorentzVector.h>
#include <TMath.h>
+#include <TObjArray.h>
#include <AnalysisTree/Constants.hpp>
+#include <AnalysisTree/Detector.hpp>
+#include <AnalysisTree/Hit.hpp>
#include <AnalysisTree/Matching.hpp>
+#include <AnalysisTree/Track.hpp>
#include <Hal/DataFormat.h>
-#include <Hal/Event.h>
-#include <Hal/ExpEvent.h>
+#include <Hal/DetectorTrack.h>
+#include <Hal/ExpTrack.h>
+#include <Hal/ToFTrack.h>
+#include <Hal/Track.h>
-HalCbmEvent::HalCbmEvent() : Hal::ExpEvent("HalCbmTrack") {}
+HalCbmEvent::HalCbmEvent() : Hal::ExpEvent("HalCbmTrack", "HalCbmV0Track") {}
HalCbmEvent::HalCbmEvent(const HalCbmEvent& other) : Hal::ExpEvent(other) {}
void HalCbmEvent::Update(Hal::EventInterface* interface)
{
- fTracks->Clear();
+ Clear();
+ fVertexTracks = 0;
HalCbmEventInterface* source = (HalCbmEventInterface*) interface;
switch (source->fFormatType) {
case HalCbm::DataFormat::kAnalysisTree: {
UpdateAnaTree(source);
+ UpdateV0(source);
} break;
case HalCbm::DataFormat::kDST: {
UpdateDST(source);
@@ -41,6 +57,63 @@ void HalCbmEvent::Update(Hal::EventInterface* interface)
HalCbmEvent::HalCbmEvent(TString classname) : Hal::ExpEvent(classname) {}
+void HalCbmEvent::UpdateV0(HalCbmEventInterface* ei)
+{
+ if (!ei->fTempV0) return;
+ auto clones = ei->fTempV0;
+ int nv = clones->GetEntriesFast();
+ fTotalTracksNo += nv;
+ fTracks->ExpandCreateFast(fTotalTracksNo);
+ for (int i = 0; i < nv; i++) {
+ auto temp = (HalCbmV0TempTrack*) clones->UncheckedAt(i);
+ HalCbmTrack* track = (HalCbmTrack*) fTracks->UncheckedAt(i + fVertexTracks);
+ track->ResetTrack(i + fVertexTracks, this);
+ track->Hal::ExpTrack::CopyData(&temp->GetTrack());
+ track->BuildHelix();
+ track->EnableV0(kTRUE, kTRUE);
+#ifdef DEBUG_EXTR
+ auto vecpos = temp->GetV0().GetMomPos(); //copy at-data
+ auto vecneg = temp->GetV0().GetMomNeg();
+#endif
+ temp->ComputeStuff(this, track);
+ //new track momenta calculated !
+ auto recalcmom1 = temp->GetV0().GetMomPos();
+ auto recalcmom2 = temp->GetV0().GetMomNeg();
+ track->GetV0Info()->SetMomPos(recalcmom1.X(), recalcmom1.Y(), recalcmom1.Z());
+ track->GetV0Info()->SetMomNeg(recalcmom2.X(), recalcmom2.Y(), recalcmom2.Z());
+
+
+#ifdef DEBUG_EXTR
+ //recomputed data present print them
+ auto vecpos1 = temp->GetV0().GetMomPos();
+ auto vecpos2 = temp->GetV0().GetMomNeg();
+ std::cout << __FILE__ << "____" << std::endl;
+ auto print = [](TString t, TVector3 x) {
+ std::cout << Form("%4.4f %4.4f %4.4f %s", x.X(), x.Y(), x.Z(), t.Data()) << std::endl;
+ };
+ auto raw1 = GetTrack(temp->GetV0().GetPosId())->GetMomentum().Vect();
+ auto raw2 = GetTrack(temp->GetV0().GetNegId())->GetMomentum().Vect();
+ /*print("pos ori", vecpos);
+ print("pos com", vecpos1);
+ print("neg ori", vecneg);
+ print("neg com", vecpos2);*/
+ print("p1", raw1);
+ print("p2", raw2);
+ print("p1c", vecpos1);
+ print("p1x", vecpos);
+ print("p2c", vecpos2);
+ print("p2x", vecneg);
+ print("sum com", (vecpos1 + vecpos2));
+ print("sum raw", (raw1 + raw2));
+ print("tot v0m", track->GetMomentum().Vect());
+
+#else
+
+#endif
+ track->GetV0Info()->CopyData(&temp->GetV0());
+ }
+}
+
HalCbmEvent::~HalCbmEvent() {}
Bool_t HalCbmEvent::ExistInTree() const
@@ -57,6 +130,7 @@ void HalCbmEvent::UpdateDST(HalCbmEventInterface* ei)
TLorentzVector start = ei->GetVertex();
fVertex->SetXYZT(start.X(), start.Y(), start.Z(), start.T());
fTracks->ExpandCreateFast(fTotalTracksNo);
+ fVertexTracks = ei->GetTotalTrackNo();
for (int i = 0; i < fTotalTracksNo; i++) {
HalCbmTrack* track = (HalCbmTrack*) fTracks->UncheckedAt(i);
track->ResetTrack(i, this);
@@ -109,9 +183,9 @@ void HalCbmEvent::UpdateDST(HalCbmEventInterface* ei)
void HalCbmEvent::UpdateAnaTree(HalCbmEventInterface* ei)
{
- CbmAnaTreeRecoSourceContainer* container = ei->GetContainer();
- fTotalTracksNo = ei->GetTotalTrackNo();
- TLorentzVector start = ei->GetVertex();
+ CbmAnaTreeRecoContainer* container = ei->GetContainer();
+ fTotalTracksNo = fVertexTracks = ei->GetTotalTrackNo(); //number of vtx tracks
+ TLorentzVector start = ei->GetVertex();
fVertex->SetXYZT(start.X(), start.Y(), start.Z(), start.T());
fTracks->ExpandCreateFast(fTotalTracksNo);
AnaTreeRecoIds ids = container->GetFieldIds();
@@ -151,3 +225,10 @@ void HalCbmEvent::UpdateAnaTree(HalCbmEventInterface* ei)
}
Hal::EventInterface* HalCbmEvent::CreateInterface() const { return new HalCbmEventInterface(); }
+
+void HalCbmEvent::ShallowCopyEvent(Hal::Event* event)
+{
+ Hal::ExpEvent::ShallowCopyEvent(event);
+ auto ev = (HalCbmEvent*) event;
+ fVertexTracks = ev->fVertexTracks;
+}
diff --git a/analysis/PWGC2F/femtoscopy/hal/format/anatree/reco/HalCbmEvent.h b/analysis/PWGC2F/femtoscopy/hal/format/anatree/reco/HalCbmEvent.h
index 36409f07ab77f41713ab6353797b3da676d3be24..e4ad55bf1c19fb82c8e13b5ebfb67fc8cabc8b4c 100644
--- a/analysis/PWGC2F/femtoscopy/hal/format/anatree/reco/HalCbmEvent.h
+++ b/analysis/PWGC2F/femtoscopy/hal/format/anatree/reco/HalCbmEvent.h
@@ -22,12 +22,17 @@ class HalCbmEvent : public Hal::ExpEvent {
HalCbmEvent(TString classname);
void UpdateDST(HalCbmEventInterface* ei);
void UpdateAnaTree(HalCbmEventInterface* ei);
+ void UpdateV0(HalCbmEventInterface* ei);
+ Int_t fVertexTracks = {0};
+
+ virtual void ShallowCopyEvent(Hal::Event* event);
public:
HalCbmEvent();
HalCbmEvent(const HalCbmEvent& other);
virtual void Update(Hal::EventInterface* interface);
virtual Bool_t ExistInTree() const;
+ Int_t GetVertexTracksNo() const { return fVertexTracks; }
virtual Hal::EventInterface* CreateInterface() const;
virtual Hal::Track* GetNewTrack() const { return new HalCbmTrack(); };
virtual Hal::Event* GetNewEvent() const { return new HalCbmEvent(); };
diff --git a/analysis/PWGC2F/femtoscopy/hal/format/anatree/reco/HalCbmEventInterface.cxx b/analysis/PWGC2F/femtoscopy/hal/format/anatree/reco/HalCbmEventInterface.cxx
index 9157b9b6302da747e5be35b6b82e395c2a47c550..e0fdf5a3e12171d3333e4b98b4b4a429cd23d04f 100644
--- a/analysis/PWGC2F/femtoscopy/hal/format/anatree/reco/HalCbmEventInterface.cxx
+++ b/analysis/PWGC2F/femtoscopy/hal/format/anatree/reco/HalCbmEventInterface.cxx
@@ -9,6 +9,7 @@
#include "CbmTofTrack.h"
#include "CbmVertex.h"
#include "FairRootManager.h"
+#include "HalCbmDetectorID.h"
#include <RtypesCore.h>
#include <TObjArray.h>
@@ -23,8 +24,9 @@ HalCbmEventInterface::HalCbmEventInterface() {}
void HalCbmEventInterface::ConnectToTreeInternal(eMode /*mode*/)
{
Hal::DataManager* manager = Hal::DataManager::Instance();
- fDataContainer = (CbmAnaTreeRecoSourceContainer*) manager->GetObject("CbmAnaTreeSourceContainer.");
- auto branchList = manager->GetBranchNameList();
+ fDataContainer = (CbmAnaTreeRecoContainer*) manager->GetObject(HalCbm::GetContainerName("reco"));
+
+ auto branchList = manager->GetBranchNameList();
for (auto name : branchList) {
std::cout << name << std::endl;
}
@@ -44,6 +46,7 @@ void HalCbmEventInterface::ConnectToTreeInternal(eMode /*mode*/)
}
else {
fFormatType = HalCbm::DataFormat::kAnalysisTree;
+ fTempV0 = (TClonesArray*) manager->GetObject("TempV0.");
}
}
@@ -52,7 +55,7 @@ void HalCbmEventInterface::Register(Bool_t write)
Hal::DataManager* manager = Hal::DataManager::Instance();
switch (fFormatType) {
case HalCbm::DataFormat::kAnalysisTree: {
- manager->Register("CbmAnaTreeSourceContainer.", "CbmAnaTreeSourceContainer.", fDataContainer, write);
+ manager->Register(HalCbm::GetContainerName("reco"), "CbmAnaTreeSourceContainer.", fDataContainer, write);
} break;
case HalCbm::DataFormat::kDST: {
manager->Register("PrimaryVertex.", "PrimaryVertex", fCbmVertex, write);
diff --git a/analysis/PWGC2F/femtoscopy/hal/format/anatree/reco/HalCbmEventInterface.h b/analysis/PWGC2F/femtoscopy/hal/format/anatree/reco/HalCbmEventInterface.h
index 3ae2e5e8d250b8eedf261338544c09a1636a6b83..5e2c9f9ba0b9743b6d5f4bcfafff9daa37b676f2 100644
--- a/analysis/PWGC2F/femtoscopy/hal/format/anatree/reco/HalCbmEventInterface.h
+++ b/analysis/PWGC2F/femtoscopy/hal/format/anatree/reco/HalCbmEventInterface.h
@@ -29,15 +29,16 @@ class HalCbmEventInterface : public Hal::EventInterface {
friend class HalCbmFullEvent;
protected:
- HalCbm::DataFormat fFormatType = {HalCbm::DataFormat::kUnknown};
- CbmAnaTreeRecoSourceContainer* fDataContainer = {nullptr};
- TClonesArray* fGlobalTracks = {nullptr};
- TClonesArray* fStsTracks = {nullptr};
- TClonesArray* fTrdTracks = {nullptr};
- TClonesArray* fTofHits = {nullptr};
- TClonesArray* fRichRings = {nullptr};
- TClonesArray* fMuchTracks = {nullptr};
- CbmVertex* fCbmVertex = {nullptr};
+ HalCbm::DataFormat fFormatType = {HalCbm::DataFormat::kUnknown};
+ CbmAnaTreeRecoContainer* fDataContainer = {nullptr};
+ TClonesArray* fGlobalTracks = {nullptr};
+ TClonesArray* fStsTracks = {nullptr};
+ TClonesArray* fTrdTracks = {nullptr};
+ TClonesArray* fTofHits = {nullptr};
+ TClonesArray* fRichRings = {nullptr};
+ TClonesArray* fMuchTracks = {nullptr};
+ TClonesArray* fTempV0 = {nullptr};
+ CbmVertex* fCbmVertex = {nullptr};
void UpdateDst(HalCbmMCEventInterface* ie);
void UpdateAnaTree(HalCbmMCEventInterface* ie);
virtual void ConnectToTreeInternal(eMode mode);
@@ -48,12 +49,13 @@ class HalCbmEventInterface : public Hal::EventInterface {
HalCbm::DataFormat GetFormatType() const { return fFormatType; };
virtual Int_t GetTotalTrackNo() const;
virtual Hal::TrackInterface* GetTrackInterface() const { return new HalCbmTrackInterface(); }
- CbmAnaTreeRecoSourceContainer* GetContainer() const { return fDataContainer; }
+ CbmAnaTreeRecoContainer* GetContainer() const { return fDataContainer; }
virtual TObject* GetRawTrackPointer(Int_t index) const;
/** GETTERS AND SETTERS **/
virtual void SetRunInfoId(Int_t /*i*/){};
virtual Int_t GetRunInfoId() const { return 0; };
virtual TLorentzVector GetVertex() const;
+ TClonesArray* GetV0Temp() const { return fTempV0; }
virtual ~HalCbmEventInterface();
ClassDef(HalCbmEventInterface, 1)
};
diff --git a/analysis/PWGC2F/femtoscopy/hal/format/combined/HalCbmFullEvent.cxx b/analysis/PWGC2F/femtoscopy/hal/format/combined/HalCbmFullEvent.cxx
index 13ece70b227314c14bf33312fe048368a30f52bd..ad80f2918aa69bd6ab6a175f3376873183247068 100644
--- a/analysis/PWGC2F/femtoscopy/hal/format/combined/HalCbmFullEvent.cxx
+++ b/analysis/PWGC2F/femtoscopy/hal/format/combined/HalCbmFullEvent.cxx
@@ -9,6 +9,7 @@
#include "HalCbmEventInterface.h"
#include "HalCbmMCEvent.h"
#include "HalCbmMCEventInterface.h"
+#include "HalCbmV0TempTrack.h"
#include <AnalysisTree/Constants.hpp>
@@ -51,10 +52,11 @@ HalCbmFullEvent::HalCbmFullEvent(Hal::Event* re, Hal::Event* im) : Hal::ComplexE
void HalCbmFullEvent::UpdateAnalysisTree(Hal::ComplexEventInterface* interface)
{
- HalCbmEventInterface* s = (HalCbmEventInterface*) interface->GetReal();
- CbmAnaTreeRecoSourceContainer* reco = (CbmAnaTreeRecoSourceContainer*) s->GetContainer();
- auto vecToSim = reco->GetVtx2Sim();
- for (Int_t i = 0; i < fTotalTracksNo; i++) {
+ HalCbmEventInterface* s = (HalCbmEventInterface*) interface->GetReal();
+ CbmAnaTreeRecoContainer* reco = (CbmAnaTreeRecoContainer*) s->GetContainer();
+ auto vecToSim = reco->GetVtx2Sim();
+ Int_t charged = ((HalCbmEvent*) fRealEvent)->GetVertexTracksNo();
+ for (Int_t i = 0; i < charged; i++) {
Hal::ComplexTrack* track = (Hal::ComplexTrack*) fTracks->UncheckedAt(i);
track->ResetTrack(i, this);
track->SetRealTrack(fRealEvent->GetTrack(i));
@@ -69,6 +71,25 @@ void HalCbmFullEvent::UpdateAnalysisTree(Hal::ComplexEventInterface* interface)
track->SetMatchID(match);
}
}
+ //v0 stuff
+ auto v0Tracks = s->GetV0Temp();
+ if (!v0Tracks) return;
+ for (int i = charged; i < charged + fRealEvent->GetTotalV0No(); i++) {
+ Hal::ComplexTrack* track = (Hal::ComplexTrack*) fTracks->UncheckedAt(i);
+ track->ResetTrack(i, this);
+ track->SetRealTrack(fRealEvent->GetTrack(i));
+ track->Hal::Track::CopyData(fRealEvent->GetTrack(i));
+ auto v0Temp = (HalCbmV0TempTrack*) v0Tracks->UncheckedAt(i - charged);
+ Int_t match = v0Temp->GetMcId();
+ if (match < 0 || match == AnalysisTree::UndefValueInt) {
+ track->SetImgTrack(nullptr);
+ track->SetMatchID(-1);
+ }
+ else {
+ track->SetImgTrack(fImgEvent->GetTrack(match));
+ track->SetMatchID(match);
+ }
+ }
}
void HalCbmFullEvent::UpdateDst(Hal::ComplexEventInterface* interface)
@@ -85,7 +106,7 @@ void HalCbmFullEvent::UpdateDst(Hal::ComplexEventInterface* interface)
if (sts_index >= 0) {
CbmTrackMatchNew* match = (CbmTrackMatchNew*) ims->fStsMatches->UncheckedAt(sts_index);
Int_t mcId = match->GetMatchedLink().GetIndex();
- if (mcId > 0) {
+ if (mcId >= 0) {
track->SetImgTrack(fImgEvent->GetTrack(mcId));
track->SetMatchID(mcId);
}
diff --git a/analysis/PWGC2F/femtoscopy/hal/format/unigen/HalCbmUnigenEvent.cxx b/analysis/PWGC2F/femtoscopy/hal/format/unigen/HalCbmUnigenEvent.cxx
index c365be1b00aec2dbf958e1c59fe114e5597f2ce3..5ca305862e6dc563a51074bda72164f7dfc4b59b 100644
--- a/analysis/PWGC2F/femtoscopy/hal/format/unigen/HalCbmUnigenEvent.cxx
+++ b/analysis/PWGC2F/femtoscopy/hal/format/unigen/HalCbmUnigenEvent.cxx
@@ -42,7 +42,7 @@ void HalCbmUnigenEvent::Update(Hal::EventInterface* interface)
target_track->SetMotherIndex(particle->GetParent());
}
target_track->SetMomentum(particle->Px(), particle->Py(), particle->Pz(), particle->E());
- target_track->SetFreezoutPosition(particle->X(), particle->Y(), particle->Z(), particle->T());
+ target_track->SetFreezeoutPosition(particle->X(), particle->Y(), particle->Z(), particle->T());
target_track->SetStatus(particle->GetStatus());
}
}
diff --git a/analysis/PWGC2F/femtoscopy/hal/format/v0/HalCbmV0Builder.cxx b/analysis/PWGC2F/femtoscopy/hal/format/v0/HalCbmV0Builder.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..ef7002bd8758ef0d04f6ff9748688595832a8a35
--- /dev/null
+++ b/analysis/PWGC2F/femtoscopy/hal/format/v0/HalCbmV0Builder.cxx
@@ -0,0 +1,195 @@
+/* Copyright (C) 2025-2025 Warsaw University of Technology, Warsaw
+ SPDX-License-Identifier: GPL-3.0-only
+ Authors: Daniel Wielanek [committer] */
+#include "HalCbmV0Builder.h"
+
+#include "HalCbmAnalysisManager.h"
+#include "HalCbmDetectorID.h"
+#include "HalCbmTrack.h"
+#include "HalCbmV0TempTrack.h"
+#include "HalCbmV0Track.h"
+
+#include <TClonesArray.h>
+#include <TDatabasePDG.h>
+#include <TParticlePDG.h>
+
+#include <Hal/Cout.h>
+#include <Hal/DataManager.h>
+
+namespace Hal
+{
+
+} /* namespace Hal */
+
+HalCbmV0Builder::v0rawInfo HalCbmV0Builder::Convert(const AnalysisTree::Particle& p)
+{
+ HalCbmV0Builder::v0rawInfo v0Info;
+ v0Info.chi2geo = p.GetField<float>(fV0Container->GetFieldIds().chi2geo);
+ v0Info.chi2_prim_first = p.GetField<float>(fV0Container->GetFieldIds().chi2_prim_first);
+ v0Info.chi2_prim_second = p.GetField<float>(fV0Container->GetFieldIds().chi2_prim_second);
+ v0Info.chi2_topo = p.GetField<float>(fV0Container->GetFieldIds().chi2_topo);
+ v0Info.cosine_first = p.GetField<float>(fV0Container->GetFieldIds().cosine_first);
+ v0Info.cosine_second = p.GetField<float>(fV0Container->GetFieldIds().cosine_second);
+ v0Info.cosine_topo = p.GetField<float>(fV0Container->GetFieldIds().cosine_topo);
+ v0Info.distance = p.GetField<float>(fV0Container->GetFieldIds().distance);
+ v0Info.l = p.GetField<float>(fV0Container->GetFieldIds().l);
+ v0Info.l_dl = p.GetField<float>(fV0Container->GetFieldIds().l_over_dl);
+ v0Info.mass = p.GetField<float>(fV0Container->GetFieldIds().mass);
+ v0Info.px = p.GetField<float>(fV0Container->GetFieldIds().px);
+ v0Info.py = p.GetField<float>(fV0Container->GetFieldIds().py);
+ v0Info.pz = p.GetField<float>(fV0Container->GetFieldIds().pz);
+ v0Info.x = p.GetField<float>(fV0Container->GetFieldIds().x);
+ v0Info.y = p.GetField<float>(fV0Container->GetFieldIds().y);
+ v0Info.z = p.GetField<float>(fV0Container->GetFieldIds().z);
+ v0Info.pid = p.GetField<int>(fV0Container->GetFieldIds().pdg);
+ v0Info.dau1id = p.GetField<int>(fV0Container->GetFieldIds().dau1id);
+ v0Info.dau2id = p.GetField<int>(fV0Container->GetFieldIds().dau2id);
+
+#ifdef DEBUG_EXTR
+ v0Info.dau1px = p.GetField<float>(fV0Container->GetFieldIds().dau1px);
+ v0Info.dau1py = p.GetField<float>(fV0Container->GetFieldIds().dau1py);
+ v0Info.dau1pz = p.GetField<float>(fV0Container->GetFieldIds().dau1pz);
+ v0Info.dau1x = p.GetField<float>(fV0Container->GetFieldIds().dau1x);
+ v0Info.dau1y = p.GetField<float>(fV0Container->GetFieldIds().dau1y);
+ v0Info.dau1z = p.GetField<float>(fV0Container->GetFieldIds().dau1z);
+
+ v0Info.dau2px = p.GetField<float>(fV0Container->GetFieldIds().dau2px);
+ v0Info.dau2py = p.GetField<float>(fV0Container->GetFieldIds().dau2py);
+ v0Info.dau2pz = p.GetField<float>(fV0Container->GetFieldIds().dau2pz);
+ v0Info.dau2x = p.GetField<float>(fV0Container->GetFieldIds().dau2x);
+ v0Info.dau2y = p.GetField<float>(fV0Container->GetFieldIds().dau2y);
+ v0Info.dau2z = p.GetField<float>(fV0Container->GetFieldIds().dau2z);
+#endif
+ return v0Info;
+}
+
+HalCbmV0Builder::HalCbmV0Builder(Int_t motherPid, Int_t posdau, Int_t negdau)
+ : fPidMom(motherPid)
+ , fPidPosDau(posdau)
+ , fPidNegDau(negdau)
+{
+}
+
+HalCbmV0Builder::EInitFlag HalCbmV0Builder::Init()
+{
+ fSimContainer = (CbmAnaTreeMcContainer*) Hal::DataManager::Instance()->GetObject(HalCbm::GetContainerName("mc"));
+ fRecoContainer = (CbmAnaTreeRecoContainer*) Hal::DataManager::Instance()->GetObject(HalCbm::GetContainerName("reco"));
+ fV0Container = (CbmAnaTreeV0Container*) Hal::DataManager::Instance()->GetObject(HalCbm::GetContainerName("v0"));
+ auto trk = TDatabasePDG::Instance()->GetParticle(fPidMom);
+ if (!trk) {
+ Hal::Cout::PrintInfo(Form("HalCbmV0Builder::Init cannot find selected mother PID=%i", fPidMom), Hal::EInfo::kError);
+ return EInitFlag::kERROR;
+ }
+ fMass = trk->Mass();
+ if (!fV0Container) {
+ Hal::Cout::PrintInfo("HalCbmV0Builder::Init cannot find V0 data", Hal::EInfo::kError);
+ return EInitFlag::kERROR;
+ }
+ if (!fRecoContainer) {
+ Hal::Cout::PrintInfo("HalCbmV0Builder::Init cannot find reco data", Hal::EInfo::kError);
+ return EInitFlag::kERROR;
+ }
+ fV0Temp = (TClonesArray*) Hal::DataManager::Instance()->GetObject("TempV0.");
+ if (!fV0Temp) {
+ fV0Temp = new TClonesArray("HalCbmV0TempTrack");
+ Hal::DataManager::Instance()->Register("TempV0.", "TempV0", fV0Temp, kFALSE);
+ fOwner = kTRUE;
+ }
+ return EInitFlag::kSUCCESS;
+}
+
+void HalCbmV0Builder::Exec(Option_t* /*option*/)
+{
+ auto recoCont = fRecoContainer->GetVtxTracks();
+ auto recoMatch = fRecoContainer->GetVtx2Sim();
+ auto sim = fSimContainer->GetParticles();
+ int charge_field = fRecoContainer->GetFieldIds().vtx_q;
+ int nv0s = fV0Container->GetParticles()->GetNumberOfChannels();
+ int mother_field = fSimContainer->GetFieldIds().motherId;
+ int ent = 0;
+ if (fOwner) {
+ fV0Temp->Clear("");
+ fV0Temp->ExpandCreateFast(nv0s);
+ }
+ else {
+ ent = fV0Temp->GetEntriesFast();
+ fV0Temp->ExpandCreateFast(ent + nv0s);
+ }
+ for (int i = 0; i < nv0s; i++) {
+ auto particleV0 = fV0Container->GetParticles()->GetChannel(i);
+ auto v0struct = Convert(particleV0);
+ auto dau1 = recoCont->GetChannel(v0struct.dau1id);
+ auto dau2 = recoCont->GetChannel(v0struct.dau2id);
+ int ch1 = dau1.GetField<int>(charge_field);
+ int ch2 = dau2.GetField<int>(charge_field);
+ AnalysisTree::Track daupos = dau1, dauneg = dau2;
+ if (ch1 < 0 && ch2 > 0) { // daughters swap
+ daupos = dau2;
+ dauneg = dau1;
+ int temp = v0struct.dau1id;
+ v0struct.dau1id = v0struct.dau2id;
+ v0struct.dau2id = temp;
+ }
+ auto v0Track = (HalCbmV0TempTrack*) fV0Temp->ConstructedAt(ent + i);
+ v0Track->GetTrack().SetVertexChi2(v0struct.chi2_topo);
+ double e = TMath::Sqrt(v0struct.px * v0struct.px + v0struct.py * v0struct.py + v0struct.pz * v0struct.pz
+ + v0struct.mass * v0struct.mass);
+ v0Track->GetTrack().SetMomentum(v0struct.px, v0struct.py, v0struct.pz, e);
+ v0Track->GetTrack().SetDCA(v0struct.x, v0struct.y, v0struct.z);
+ int field_hit = fRecoContainer->GetFieldIds().vtx_mvdhits;
+ int field_sts = fRecoContainer->GetFieldIds().vtx_nhits;
+ v0Track->GetTrack().SetNMvdHits(daupos.GetField<int>(field_hit) + dauneg.GetField<int>(field_hit));
+ v0Track->GetTrack().SetNStsHits(daupos.GetField<int>(field_sts) + dauneg.GetField<int>(field_sts)
+ - daupos.GetField<int>(field_hit) - dauneg.GetField<int>(field_hit));
+ v0Track->GetV0().SetPdgDaughters(fPidPosDau, fPidNegDau);
+ v0Track->GetV0().SetPosId(v0struct.dau1id);
+ v0Track->GetV0().SetNegId(v0struct.dau2id);
+ v0Track->GetV0().SetDecLenght(v0struct.l);
+ v0Track->GetV0().SetDecDl(v0struct.l_dl);
+ v0Track->GetV0().SetDauDist(v0struct.distance);
+
+#ifdef DEBUG_EXTR
+ v0Track->GetV0().SetMomentumPos(TVector3(v0struct.dau1px, v0struct.dau1py, v0struct.dau1pz));
+ v0Track->GetV0().SetMomentumNeg(TVector3(v0struct.dau2px, v0struct.dau2py, v0struct.dau2pz));
+#else
+ v0Track->GetV0().SetMomentumPos(TVector3(daupos.GetPx(), daupos.GetPy(), daupos.GetPz()));
+ v0Track->GetV0().SetMomentumNeg(TVector3(dauneg.GetPx(), dauneg.GetPy(), dauneg.GetPz()));
+#endif
+ v0Track->GetV0().SetMcId(v0struct.pid);
+ v0Track->SetMcId(-1);
+ //mc matching
+ if (!recoMatch) continue;
+ int mc1 = recoMatch->GetMatchDirect(v0struct.dau1id);
+ int mc2 = recoMatch->GetMatchDirect(v0struct.dau2id);
+ if (fBeFriendly) {
+ if (mc1 >= 0 && mc2 >= 0) {
+ auto mctrack1 = sim->GetChannel(mc1);
+ auto mctrack2 = sim->GetChannel(mc2);
+ int mom1 = mctrack1.GetField<int>(mother_field);
+ int mom2 = mctrack2.GetField<int>(mother_field);
+ v0Track->SetMcId(mom1);
+ }
+ else if (mc1 >= 0) {
+ auto mctrack = sim->GetChannel(mc1);
+ v0Track->SetMcId(mctrack.GetField<int>(mother_field));
+ }
+ else if (mc2 >= 0) {
+ auto mctrack = sim->GetChannel(mc2);
+ v0Track->SetMcId(mctrack.GetField<int>(mother_field));
+ }
+ }
+ else {
+ if (mc1 < 0) continue;
+ if (mc2 < 0) continue;
+ auto mctrack1 = sim->GetChannel(mc1);
+ auto mctrack2 = sim->GetChannel(mc2);
+ int mom1 = mctrack1.GetField<int>(mother_field);
+ int mom2 = mctrack2.GetField<int>(mother_field);
+ if (mom1 == mom2) {
+ v0Track->SetMcId(mom1);
+ }
+ }
+ }
+}
+
+HalCbmV0Builder::~HalCbmV0Builder() {}
diff --git a/analysis/PWGC2F/femtoscopy/hal/format/v0/HalCbmV0Builder.h b/analysis/PWGC2F/femtoscopy/hal/format/v0/HalCbmV0Builder.h
new file mode 100644
index 0000000000000000000000000000000000000000..bda002d0a5d9e496dd395dd8b28894a06a63a32b
--- /dev/null
+++ b/analysis/PWGC2F/femtoscopy/hal/format/v0/HalCbmV0Builder.h
@@ -0,0 +1,57 @@
+/* Copyright (C) 2025-2025 Warsaw University of Technology, Warsaw
+ SPDX-License-Identifier: GPL-3.0-only
+ Authors: Daniel Wielanek [committer] */
+#ifndef CBMROOT_V0_ANALYSIS_PWGC2F_FEMTOSCOPY_HAL_HELPERS_HALCBMV0BUILDER_H_
+#define CBMROOT_V0_ANALYSIS_PWGC2F_FEMTOSCOPY_HAL_HELPERS_HALCBMV0BUILDER_H_
+
+#include "CbmAnaTreeContainer.h"
+
+#include <Hal/Task.h>
+
+class CbmAnaTreeV0Container;
+class TClonesArray;
+
+namespace AnalysisTree
+{
+ class Particle;
+}
+
+
+class HalCbmV0Builder : public Hal::Task {
+ struct v0rawInfo {
+ float chi2geo, chi2_prim_first;
+ float chi2_prim_second, chi2_topo;
+ float cosine_first, cosine_second, cosine_topo;
+ float distance, l, l_dl;
+ float mass, px, py, pz;
+ float x, y, z;
+ int dau1id, dau2id, pid, id;
+ int mcid;
+#ifdef DEBUG_EXTR
+ int dau1px, dau1py, dau1pz, dau1x, dau1y, dau1z;
+ int dau2px, dau2py, dau2pz, dau2x, dau2y, dau2z;
+#endif
+ };
+ Int_t fPidMom;
+ Int_t fPidPosDau;
+ Int_t fPidNegDau;
+ Bool_t fBeFriendly = {kFALSE};
+ Double_t fMass = {0};
+ AnaTreeV0Ids fFields;
+ CbmAnaTreeV0Container* fV0Container = {nullptr};
+ CbmAnaTreeRecoContainer* fRecoContainer = {nullptr};
+ CbmAnaTreeMcContainer* fSimContainer = {nullptr};
+ TClonesArray* fV0Temp = {nullptr};
+ Bool_t fOwner = {kFALSE};
+ v0rawInfo Convert(const AnalysisTree::Particle& p);
+
+ public:
+ HalCbmV0Builder(Int_t motherPid = 3321, Int_t posdau = 2212, Int_t negdau = -211);
+ virtual EInitFlag Init();
+ void BeFriendly() { fBeFriendly = kTRUE; }
+ virtual void Exec(Option_t* option = "");
+ virtual ~HalCbmV0Builder();
+ ClassDef(HalCbmV0Builder, 1)
+};
+
+#endif /* CBMROOT_V0_ANALYSIS_PWGC2F_FEMTOSCOPY_HAL_HELPERS_HALCBMV0BUILDER_H_ */
diff --git a/analysis/PWGC2F/femtoscopy/hal/format/v0/HalCbmV0TempTrack.cxx b/analysis/PWGC2F/femtoscopy/hal/format/v0/HalCbmV0TempTrack.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..d66b537a3252465e2d9481138ba6b21652001b5c
--- /dev/null
+++ b/analysis/PWGC2F/femtoscopy/hal/format/v0/HalCbmV0TempTrack.cxx
@@ -0,0 +1,97 @@
+/* Copyright (C) 2025-2025 Warsaw University of Technology, Warsaw
+ SPDX-License-Identifier: GPL-3.0-only
+ Authors: Daniel Wielanek [committer] */
+#include "HalCbmV0TempTrack.h"
+
+#include <TLorentzVector.h>
+#include <TVector3.h>
+
+#include <Hal/Event.h>
+#include <Hal/ExpTrack.h>
+#include <Hal/Track.h>
+#include <Hal/V0Track.h>
+
+Double_t HalCbmV0TempTrack::GetValue(kTriggerCut val)
+{
+ switch (val) {
+ case kTriggerCut::kChi2Geo: {
+ return fV0Hidden.GetChi2geo();
+ } break;
+ case kTriggerCut::kChi2PrimFirst: {
+ return fV0Hidden.GetChi2Pos();
+ } break;
+ case kTriggerCut::kChi2PrimSecond: {
+ return fV0Hidden.GetChi2Neg();
+ } break;
+ case kTriggerCut::kChi2Topo: {
+ //return fV0Hidden.GetChi2topo();
+ } break;
+ case kTriggerCut::kCosineFirst: {
+ return fCosinePos;
+ } break;
+ case kTriggerCut::kCosineSecond: {
+ return fCosineNeg;
+ } break;
+ case kTriggerCut::kDistance: {
+ return fV0Hidden.GetChi2Pos();
+ } break;
+ case kTriggerCut::kL: {
+ return fV0Hidden.GetDecLength();
+ } break;
+ case kTriggerCut::kDl: {
+ return fV0Hidden.GetDecDl();
+ } break;
+ case kTriggerCut::kMass: {
+ return 0;
+ } break;
+ case kTriggerCut::kPt: {
+ return fRecoTrack.GetMomentum().Pt();
+ } break;
+ case kTriggerCut::kEta: {
+ return fRecoTrack.GetMomentum().Eta();
+ } break;
+ case kTriggerCut::kRxy: {
+ return fRecoTrack.GetDCA().Pt();
+ } break;
+ case kTriggerCut::kRz: {
+ return fRecoTrack.GetDCA().Z();
+ } break;
+ case kTriggerCut::kCosineTopo: {
+ return fCosineTopo;
+ } break;
+ case kTriggerCut::kPid: {
+ return fV0Hidden.GetPdg();
+ } break;
+ }
+ return 0;
+}
+
+void HalCbmV0TempTrack::ComputeStuff(Hal::Event* event, Hal::Track* assignedTrack)
+{
+ auto dau1 = (HalCbmTrack*) event->GetTrack(fV0Hidden.GetPosId());
+ auto dau2 = (HalCbmTrack*) event->GetTrack(fV0Hidden.GetNegId());
+ TVector3 vtx = event->GetVertex()->Vect();
+ auto expTrack = (Hal::ExpTrack*) assignedTrack;
+ TVector3 pos(expTrack->GetDCA()); //or + event pos?
+ TVector3 mom(expTrack->GetPx(), expTrack->GetPy(), expTrack->GetPz());
+ auto shift = mom.Unit() * fV0Hidden.GetDecLength() + vtx; //new position + pos gorsze wyniki
+ fV0Hidden.SetDecayPos(shift.X(), shift.Y(), shift.Z());
+ TVector3 dau1mom, dau2mom, dau1pos, dau2pos;
+ dau1pos = dau1->GetHelix().Eval(shift.Z(), dau1mom);
+ dau2pos = dau2->GetHelix().Eval(shift.Z(), dau2mom);
+#ifdef DEBUG_EXTR
+ std::cout << "DECPOS " << std::endl;
+ std::cout << __FILE__ << "____" << std::endl;
+ auto print = [](TString t, TVector3 x) {
+ std::cout << Form("%4.4f %4.4f %4.4f %s", x.X(), x.Y(), x.Z(), t.Data()) << std::endl;
+ };
+ print("Dau1dec", dau1pos);
+ print("Dau2dec", dau2pos);
+
+ print("Dau1vec", dau1mom);
+ print("Dau2vec", dau2mom);
+#endif
+ fV0Hidden.SetMomPos(dau1mom.X(), dau1mom.Y(), dau1mom.Z());
+ fV0Hidden.SetMomNeg(dau2mom.X(), dau2mom.Y(), dau2mom.Z());
+ fV0Hidden.Recalc(*assignedTrack);
+}
diff --git a/analysis/PWGC2F/femtoscopy/hal/format/v0/HalCbmV0TempTrack.h b/analysis/PWGC2F/femtoscopy/hal/format/v0/HalCbmV0TempTrack.h
new file mode 100644
index 0000000000000000000000000000000000000000..908a7cf1ff766148e659ab2708e4f3414a8b219d
--- /dev/null
+++ b/analysis/PWGC2F/femtoscopy/hal/format/v0/HalCbmV0TempTrack.h
@@ -0,0 +1,58 @@
+/* Copyright (C) 2025-2025 Warsaw University of Technology, Warsaw
+ SPDX-License-Identifier: GPL-3.0-only
+ Authors: Daniel Wielanek [committer] */
+#ifndef CBMROOT_V0_ANALYSIS_PWGC2F_FEMTOSCOPY_HAL_HELPERS_V0_HALCBMV0TEMPTRACK_H_
+#define CBMROOT_V0_ANALYSIS_PWGC2F_FEMTOSCOPY_HAL_HELPERS_V0_HALCBMV0TEMPTRACK_H_
+
+#include "HalCbmTrack.h"
+#include "HalCbmV0Track.h"
+
+#include <Rtypes.h>
+#include <RtypesCore.h>
+
+class HalCbmV0TempTrack : public TObject {
+ HalCbmV0Track fV0Hidden;
+ HalCbmTrack fRecoTrack;
+ Int_t fMcId = {-1}; //match id
+ Double_t fCosinePos = {0};
+ Double_t fCosineNeg = {0};
+ Double_t fCosineTopo = {0};
+ Double_t fDl = {0};
+
+ public:
+ enum class kTriggerCut
+ {
+ kChi2Geo = 0,
+ kChi2PrimFirst = 1,
+ kChi2PrimSecond = 2,
+ kChi2Topo = 3,
+ kCosineFirst = 4,
+ kCosineSecond = 5,
+ kDistance = 6,
+ kL = 7,
+ kDl = 8,
+ kMass = 9,
+ kPt = 10,
+ kEta = 11,
+ kRxy = 12,
+ kRz = 13,
+ kCosineTopo = 14,
+ kPid = 15,
+ };
+ HalCbmV0TempTrack(){};
+ Double_t GetValue(kTriggerCut val);
+ void SetCosPos(Double_t val) { fCosinePos = val; }
+ void SetCosNeg(Double_t val) { fCosineNeg = val; }
+ void SetCosTopo(Double_t val) { fCosineTopo = val; }
+ void SetDL(Double_t val) { fDl = val; }
+ HalCbmV0Track& GetV0() { return fV0Hidden; }
+ HalCbmTrack& GetTrack() { return fRecoTrack; }
+ void ComputeStuff(Hal::Event* event,
+ Hal::Track* assignedTrack); //compute missing fields (not available in root trees)
+ void SetMcId(Int_t mc) { fMcId = mc; };
+ Int_t GetMcId() const { return fMcId; }
+ virtual ~HalCbmV0TempTrack(){};
+ ClassDef(HalCbmV0TempTrack, 1);
+};
+
+#endif /* CBMROOT_V0_ANALYSIS_PWGC2F_FEMTOSCOPY_HAL_HELPERS_V0_HALCBMV0TEMPTRACK_H_ */
diff --git a/analysis/PWGC2F/femtoscopy/hal/format/v0/HalCbmV0Track.cxx b/analysis/PWGC2F/femtoscopy/hal/format/v0/HalCbmV0Track.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..0f8c9a0ceb8c8d9bbc30cbc5c1cec4b54b497cee
--- /dev/null
+++ b/analysis/PWGC2F/femtoscopy/hal/format/v0/HalCbmV0Track.cxx
@@ -0,0 +1,15 @@
+/* Copyright (C) 2025-2025 Warsaw University of Technology, Warsaw
+ SPDX-License-Identifier: GPL-3.0-only
+ Authors: Daniel Wielanek [committer] */
+#include "HalCbmV0Track.h"
+
+void HalCbmV0Track::CopyData(V0Track* v)
+{
+ Hal::V0Track::CopyData(v);
+ HalCbmV0Track* v0 = (HalCbmV0Track*) (v);
+ fMcId = v0->fMcId;
+ fDecDl = v0->fDecDl;
+ fChi2geo = v0->fChi2geo;
+ fChi2First = v0->fChi2First;
+ fChi2Second = v0->fChi2Second;
+}
diff --git a/analysis/PWGC2F/femtoscopy/hal/format/v0/HalCbmV0Track.h b/analysis/PWGC2F/femtoscopy/hal/format/v0/HalCbmV0Track.h
new file mode 100644
index 0000000000000000000000000000000000000000..53b45709a0c096a5bdcf17f56cc247b945fbe6c8
--- /dev/null
+++ b/analysis/PWGC2F/femtoscopy/hal/format/v0/HalCbmV0Track.h
@@ -0,0 +1,36 @@
+/* Copyright (C) 2025-2025 Warsaw University of Technology, Warsaw
+ SPDX-License-Identifier: GPL-3.0-only
+ Authors: Daniel Wielanek [committer] */
+#ifndef CBMROOT_V0_ANALYSIS_PWGC2F_FEMTOSCOPY_HAL_FORMAT_V0_HALCBMV0TRACK_H_
+#define CBMROOT_V0_ANALYSIS_PWGC2F_FEMTOSCOPY_HAL_FORMAT_V0_HALCBMV0TRACK_H_
+
+#include <Hal/V0Track.h>
+
+class HalCbmV0Track : public Hal::V0Track {
+ Int_t fMcId = {-1};
+ Float_t fDecDl = {0};
+ Float_t fChi2geo = {0};
+ Float_t fChi2First = {0};
+ Float_t fChi2Second = {0};
+
+ public:
+ HalCbmV0Track(){};
+ virtual ~HalCbmV0Track() {}
+ virtual void CopyData(V0Track* v);
+ void SetChi2geo(Float_t Chi2geo) { fChi2geo = Chi2geo; }
+ void SetDecDl(Float_t DecDl) { fDecDl = DecDl; }
+ void SetMcId(Int_t McId) { fMcId = McId; }
+ void SetChi2Dau(Double_t pos, Double_t neg)
+ {
+ fChi2First = pos;
+ fChi2Second = neg;
+ }
+ Float_t GetChi2geo() const { return fChi2geo; }
+ Float_t GetDecDl() const { return fDecDl; }
+ Float_t GetChi2Pos() const { return fChi2First; }
+ Float_t GetChi2Neg() const { return fChi2Second; }
+ Int_t GetMcId() const { return fMcId; };
+ ClassDef(HalCbmV0Track, 1)
+};
+
+#endif /* CBMROOT_V0_ANALYSIS_PWGC2F_FEMTOSCOPY_HAL_FORMAT_V0_HALCBMV0TRACK_H_ */
diff --git a/analysis/PWGC2F/femtoscopy/hal/format/v0/HalCbmV0TrackTrigger.cxx b/analysis/PWGC2F/femtoscopy/hal/format/v0/HalCbmV0TrackTrigger.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..4f0d1ce15f966ead2708608868257090f229884d
--- /dev/null
+++ b/analysis/PWGC2F/femtoscopy/hal/format/v0/HalCbmV0TrackTrigger.cxx
@@ -0,0 +1,8 @@
+/* Copyright (C) 2025-2025 Warsaw University of Technology, Warsaw
+ SPDX-License-Identifier: GPL-3.0-only
+ Authors: Daniel Wielanek [committer] */
+#include "HalCbmV0TrackTrigger.h"
+
+HalCbmV0TrackTrigger::HalCbmV0TrackTrigger() {}
+
+Bool_t HalCbmV0TrackTrigger::Pass(HalCbmV0TempTrack& /*tr*/) { return kTRUE; }
diff --git a/analysis/PWGC2F/femtoscopy/hal/format/v0/HalCbmV0TrackTrigger.h b/analysis/PWGC2F/femtoscopy/hal/format/v0/HalCbmV0TrackTrigger.h
new file mode 100644
index 0000000000000000000000000000000000000000..6ee3cb22662a8993a412f641e3689a4b336d5464
--- /dev/null
+++ b/analysis/PWGC2F/femtoscopy/hal/format/v0/HalCbmV0TrackTrigger.h
@@ -0,0 +1,48 @@
+/* Copyright (C) 2025-2025 Warsaw University of Technology, Warsaw
+ SPDX-License-Identifier: GPL-3.0-only
+ Authors: Daniel Wielanek [committer] */
+//TODO complete this class
+
+#ifndef CBMROOT_V0_ANALYSIS_PWGC2F_FEMTOSCOPY_HAL_FORMAT_V0_HALCBMV0TRACKTRIGGER_H_
+#define CBMROOT_V0_ANALYSIS_PWGC2F_FEMTOSCOPY_HAL_FORMAT_V0_HALCBMV0TRACKTRIGGER_H_
+
+#include "HalCbmV0TempTrack.h"
+
+#include <TObject.h>
+class HalCbmV0TrackTrigger : public TObject {
+ Double_t fMin[16];
+ Double_t fMax[16];
+
+ void SetCut(Double_t lo, Double_t hi, HalCbmV0TempTrack::kTriggerCut pos)
+ {
+ int poz = static_cast<int>(pos);
+ fMin[poz] = lo;
+ fMax[poz] = hi;
+ }
+
+ public:
+ HalCbmV0TrackTrigger();
+ void SetChi2GeoCut(Double_t lo, Double_t hi) { SetCut(lo, hi, HalCbmV0TempTrack::kTriggerCut::kChi2Geo); }
+ void SetChi2PosDauCut(Double_t lo, Double_t hi) { SetCut(lo, hi, HalCbmV0TempTrack::kTriggerCut::kChi2PrimFirst); }
+ void SetChi2NegDauCut(Double_t lo, Double_t hi) { SetCut(lo, hi, HalCbmV0TempTrack::kTriggerCut::kChi2PrimSecond); }
+ void SetChi2TopoCut(Double_t lo, Double_t hi) { SetCut(lo, hi, HalCbmV0TempTrack::kTriggerCut::kChi2Topo); }
+ void SetCosTopoCut(Double_t lo, Double_t hi) { SetCut(lo, hi, HalCbmV0TempTrack::kTriggerCut::kCosineTopo); }
+
+ void SetCosPosDauCut(Double_t lo, Double_t hi) { SetCut(lo, hi, HalCbmV0TempTrack::kTriggerCut::kCosineFirst); }
+ void SetCosNegDauCut(Double_t lo, Double_t hi) { SetCut(lo, hi, HalCbmV0TempTrack::kTriggerCut::kCosineSecond); }
+ void SetDauDistCut(Double_t lo, Double_t hi) { SetCut(lo, hi, HalCbmV0TempTrack::kTriggerCut::kDistance); }
+ void SetDecLenCut(Double_t lo, Double_t hi) { SetCut(lo, hi, HalCbmV0TempTrack::kTriggerCut::kL); }
+ void SetDeltaDecLenCut(Double_t lo, Double_t hi) { SetCut(lo, hi, HalCbmV0TempTrack::kTriggerCut::kDl); }
+
+ void SetMassCut(Double_t lo, Double_t hi) { SetCut(lo, hi, HalCbmV0TempTrack::kTriggerCut::kMass); }
+ void SetPtCut(Double_t lo, Double_t hi) { SetCut(lo, hi, HalCbmV0TempTrack::kTriggerCut::kPt); }
+ void SetEtaCut(Double_t lo, Double_t hi) { SetCut(lo, hi, HalCbmV0TempTrack::kTriggerCut::kEta); }
+ void SetDCAxyCut(Double_t lo, Double_t hi) { SetCut(lo, hi, HalCbmV0TempTrack::kTriggerCut::kRxy); }
+ void SetDCAz(Double_t lo, Double_t hi) { SetCut(lo, hi, HalCbmV0TempTrack::kTriggerCut::kRz); }
+
+ Bool_t Pass(HalCbmV0TempTrack& tr);
+ virtual ~HalCbmV0TrackTrigger(){};
+ ClassDef(HalCbmV0TrackTrigger, 1)
+};
+
+#endif /* CBMROOT_V0_ANALYSIS_PWGC2F_FEMTOSCOPY_HAL_FORMAT_V0_HALCBMV0TRACKTRIGGER_H_ */
diff --git a/analysis/PWGC2F/femtoscopy/hal/helpers/CMakeLists.txt b/analysis/PWGC2F/femtoscopy/hal/helpers/CMakeLists.txt
index 8adf62e130be4fdc1fd0c12365d185147652cfe0..fba9b22338c5e0a1d8efd1cc8554bf3d227d2648 100644
--- a/analysis/PWGC2F/femtoscopy/hal/helpers/CMakeLists.txt
+++ b/analysis/PWGC2F/femtoscopy/hal/helpers/CMakeLists.txt
@@ -11,8 +11,7 @@ Set(INCLUDE_DIRECTORIES
${CBMDATA_DIR}/global
${CBMDATA_DIR}/sts
${CMAKE_SOURCE_DIR}/core/field
- ${HAL_CBM}/helpers
- ${HAL_CBM}/helpers/anatree
+ ${HAL_CBM_HELPERS}
${AnalysisTree_INCLUDE_DIR}
)
Set(SYSTEM_INCLUDE_DIRECTORIES
@@ -30,15 +29,25 @@ Link_Directories(${LINK_DIRECTORIES})
# List of source files
set(SRCS
- HalCbmDetectorID.cxx
- HalCbmTaskManager.cxx
- HalCbmCompressionTask.cxx
- HalCbmAnalysisManager.cxx
CbmHelix.cxx
- HalCbmField.cxx
- anatree/CbmAnaTreeContainer.cxx
- anatree/CbmAnaTreeSource.cxx
- anatree/HalCbmSource.cxx
+ HalCbmDetectorID.cxx
+ HalCbmField.cxx
+
+ hal/HalCbmAnalysisManager.cxx
+ hal/HalCbmSource.cxx
+
+ faircbm/HalCbmCompressionTask.cxx
+ faircbm/HalCbmTaskManager.cxx
+
+ fair/Field.cxx
+ fair/QAManagerBasic.cxx
+ fair/RootManager.cxx
+ fair/TaskManager.cxx
+
+ anatree/CbmAnaTreeContainer.cxx
+ anatree/CbmAnaTreeObjectTrack.cxx
+ anatree/CbmAnaTreeSource.cxx
+
)
Set(LINKDEF HalCbmHelpersLinkDef.h)
@@ -48,9 +57,10 @@ set(PUBLIC_DEPENDENCIES
CbmField
FairRoot::Base
HalCut
- HalFair
HalFeatures
HalData
+ HalAna
+ HalQA
KF
KFParticle
AnalysisTreeBase
diff --git a/analysis/PWGC2F/femtoscopy/hal/helpers/CbmHelix.cxx b/analysis/PWGC2F/femtoscopy/hal/helpers/CbmHelix.cxx
index 9f80d9b776acdef4396068f524d5b85dad4f3cda..c9c7ff71bf733588ef43f3db1612b725ea1200af 100644
--- a/analysis/PWGC2F/femtoscopy/hal/helpers/CbmHelix.cxx
+++ b/analysis/PWGC2F/femtoscopy/hal/helpers/CbmHelix.cxx
@@ -7,7 +7,7 @@
#include <vector>
-#include <Hal/Field.h>
+#include <Hal/MagField.h>
// matrix x, y, tx,ty, qp, z
Hal::MagField* CbmHelix::fgField = NULL;
CbmHelix::CbmHelix() {}
diff --git a/analysis/PWGC2F/femtoscopy/hal/helpers/CbmHelix.h b/analysis/PWGC2F/femtoscopy/hal/helpers/CbmHelix.h
index a925f525c46e946724c47aab72e7aa5a234af3ad..34f5fed2dfe8427f1378ef5d06e0a46dbd80c98f 100644
--- a/analysis/PWGC2F/femtoscopy/hal/helpers/CbmHelix.h
+++ b/analysis/PWGC2F/femtoscopy/hal/helpers/CbmHelix.h
@@ -53,7 +53,18 @@ class CbmHelix : public TObject {
<< std::endl;
}
Double_t* GetTrack() { return fT; }
+ /**
+ * eval coordinates at Z
+ * @param z
+ * @return
+ */
TVector3 Eval(Double_t z);
+ /**
+ * eval coordinates and momentum at Z
+ * @param z
+ * @param mom
+ * @return
+ */
TVector3 Eval(Double_t z, TVector3& mom);
virtual ~CbmHelix();
ClassDef(CbmHelix, 1)
diff --git a/analysis/PWGC2F/femtoscopy/hal/helpers/HalCbmDetectorID.cxx b/analysis/PWGC2F/femtoscopy/hal/helpers/HalCbmDetectorID.cxx
index 06dcc2cde71cd22cad0e7a7ea1c4d40827e049d8..22688b80fbf2a9ac83cd8c04033e16d2ca72d44f 100644
--- a/analysis/PWGC2F/femtoscopy/hal/helpers/HalCbmDetectorID.cxx
+++ b/analysis/PWGC2F/femtoscopy/hal/helpers/HalCbmDetectorID.cxx
@@ -2,3 +2,20 @@
SPDX-License-Identifier: GPL-3.0-only
Authors: Daniel Wielanek [committer] */
#include "HalCbmDetectorID.h"
+
+#include <Hal/Cout.h>
+
+TString HalCbm::GetContainerName(TString name)
+{
+ if (name == "reco") {
+ return "CbmAnaTreeSourceContainer.";
+ }
+ if (name == "mc") {
+ return "CbmAnaTreeMcSourceContainer.";
+ }
+ if (name == "v0") {
+ return "CbmAnaTreeV0SourceContainer.";
+ }
+ Hal::Cout::PrintInfo(Form("HalCbm::GetContainerName wrong flag '%s'", name.Data()), Hal::EInfo::kError);
+ return "";
+}
diff --git a/analysis/PWGC2F/femtoscopy/hal/helpers/HalCbmDetectorID.h b/analysis/PWGC2F/femtoscopy/hal/helpers/HalCbmDetectorID.h
index a9557842be1be20048515da5cf8e140142b237e5..d80ac3715fdeb134d142b919140d47c5140bea7c 100644
--- a/analysis/PWGC2F/femtoscopy/hal/helpers/HalCbmDetectorID.h
+++ b/analysis/PWGC2F/femtoscopy/hal/helpers/HalCbmDetectorID.h
@@ -4,6 +4,7 @@
#ifndef CBMROOT_NICA_CBM_HELPERS_CBMDETECTORID_H_
#define CBMROOT_NICA_CBM_HELPERS_CBMDETECTORID_H_
+
#include <Hal/DataFormat.h>
namespace HalCbm
{
@@ -31,6 +32,13 @@ namespace HalCbm
kAnalysisTree = 1,
kUnknown = 2
};
+ /**
+ * returns container name in tree
+ * @param name "reco" "mc" or "v0" available
+ * @return
+ */
+ TString GetContainerName(TString name);
+
} // namespace HalCbm
diff --git a/analysis/PWGC2F/femtoscopy/hal/helpers/HalCbmHelpersLinkDef.h b/analysis/PWGC2F/femtoscopy/hal/helpers/HalCbmHelpersLinkDef.h
index 5f4b2c89824ab84fbb3d1e2044de85c77e29a20b..c722238c54fe1b044bec8aad23372ff891c26ade 100644
--- a/analysis/PWGC2F/femtoscopy/hal/helpers/HalCbmHelpersLinkDef.h
+++ b/analysis/PWGC2F/femtoscopy/hal/helpers/HalCbmHelpersLinkDef.h
@@ -9,17 +9,30 @@
#pragma link C++ namespace HalCbm::DetectorID;
#pragma link C++ enum HalCbm::GeoSetup;
#pragma link C++ enum HalCbm::DataFormat;
-#pragma link C++ class HalCbmTaskManager + ;
-#pragma link C++ class HalCbmCompressionTask + ;
+
#pragma link C++ class CbmHelix + ;
#pragma link C++ class HalCbmField + ;
-#pragma link C++ class HalCbmAnalysisManager + ;
-#pragma link C++ class CbmAnaTreeRecoSourceContainer + ;
-#pragma link C++ class CbmAnaTreeMcSourceContainer + ;
-#pragma link C++ class CbmAnaTreeSource + ;
-#pragma link C++ class CbmAnaTreeObjectTrack + ;
+
#pragma link C++ class HalCbmATIOManager + ;
#pragma link C++ class HalCbmSource + ;
+#pragma link C++ class HalCbmAnalysisManager + ;
+
+#pragma link C++ class HalCbmTaskManager + ;
+#pragma link C++ class HalCbmCompressionTask + ;
+#pragma link C++ class Hal::Fair::TaskManager + ;
+#pragma link C++ class Hal::Fair::RootManager + ;
+#pragma link C++ class Hal::Fair::QAManagerBasic + ;
+#pragma link C++ class Hal::Fair::Field + ;
+
+#pragma link C++ class CbmAnaTreeSource + ;
+#pragma link C++ class CbmAnaTreeObjectTrack + ;
+#pragma link C++ class CbmAnaTreeContainer + ;
+#pragma link C++ class CbmAnaTreeRecoContainer + ;
+#pragma link C++ class CbmAnaTreeMcContainer + ;
+#pragma link C++ class CbmAnaTreeV0Container + ;
+#pragma link C++ class CbmAnaTreeContainers + ;
+//#pragma link C++ class HalCbmQACoreManager + ;
+#pragma link C++ namespace Hal::Fair;
//#pragma link C++ class CbmNicaCompression + ;
diff --git a/analysis/PWGC2F/femtoscopy/hal/helpers/anatree/CbmAnaTreeContainer.cxx b/analysis/PWGC2F/femtoscopy/hal/helpers/anatree/CbmAnaTreeContainer.cxx
index f56b6300082bbe2bc7242bea617168f7ed68598b..31ec9e41fe82e9ee634747484ab0986a6be24bb1 100644
--- a/analysis/PWGC2F/femtoscopy/hal/helpers/anatree/CbmAnaTreeContainer.cxx
+++ b/analysis/PWGC2F/femtoscopy/hal/helpers/anatree/CbmAnaTreeContainer.cxx
@@ -4,21 +4,104 @@
#include "CbmAnaTreeContainer.h"
#include "AnalysisTree/Matching.hpp"
+#include "HalCbmSource.h"
#include <TChain.h>
#include <TFile.h>
#include <AnalysisTree/Configuration.hpp>
+#include <vector>
#include <Hal/Cout.h>
+#include <Hal/InputDataInfo.h>
+#include <Hal/RootIOManager.h>
-Bool_t CbmAnaTreeRecoSourceContainer::ConnectToTree(TChain* tree)
+void CbmAnaTreeRecoContainer::LoadFields(std::vector<TString> files)
{
+ Bool_t found;
+ AnalysisTree::BranchConfig conf = GetBranchConf(files, "VtxTracks", found);
+ if (!found) return;
+ GetFieldIds().vtx_px = conf.GetFieldId("px");
+ GetFieldIds().vtx_py = conf.GetFieldId("py");
+ GetFieldIds().vtx_pz = conf.GetFieldId("pz");
+ GetFieldIds().vtx_dcax = conf.GetFieldId("dcax");
+ GetFieldIds().vtx_dcay = conf.GetFieldId("dcay");
+ GetFieldIds().vtx_dcaz = conf.GetFieldId("dcaz");
+
+ GetFieldIds().vtx_chi2 = conf.GetFieldId("chi2");
+ GetFieldIds().vtx_vtxchi2 = conf.GetFieldId("vtx_chi2");
+ GetFieldIds().vtx_q = conf.GetFieldId("q");
+ GetFieldIds().vtx_nhits = conf.GetFieldId("nhits");
+ GetFieldIds().vtx_mvdhits = conf.GetFieldId("nhits_mvd");
+
+ GetFieldIds().vtx_x = conf.GetFieldId("x");
+ GetFieldIds().vtx_cx0 = conf.GetFieldId("cx0");
+ GetFieldIds().vtx_cov1 = conf.GetFieldId("cov1");
+ conf = GetBranchConf(files, "TofHits", found);
+ if (!found) return;
+ GetFieldIds().tof_mass2 = conf.GetFieldId("mass2");
+}
+
+void CbmAnaTreeMcContainer::LoadFields(std::vector<TString> files)
+{
+
+ Bool_t found;
+ AnalysisTree::BranchConfig conf = GetBranchConf(files, "SimParticles", found);
+ if (!found) return;
+
+ GetFieldIds().px = conf.GetFieldId("px");
+ GetFieldIds().py = conf.GetFieldId("py");
+ GetFieldIds().pz = conf.GetFieldId("pz");
+ GetFieldIds().mass = conf.GetFieldId("mass");
+ GetFieldIds().pdg = conf.GetFieldId("pid");
+ GetFieldIds().motherId = conf.GetFieldId("mother_id");
+
+ GetFieldIds().freezX = conf.GetFieldId("xfreez");
+ GetFieldIds().freezY = conf.GetFieldId("yfreez");
+ GetFieldIds().freezZ = conf.GetFieldId("zfreez");
+ GetFieldIds().freezT = conf.GetFieldId("tfreez");
+
+ conf = GetBranchConf(files, "SimEventHeader", found);
+ if (!found) return;
+
+ GetFieldIds().event_b = conf.GetFieldId("b");
+ GetFieldIds().event_psi = conf.GetFieldId("psi_RP");
+}
+
+AnalysisTree::BranchConfig CbmAnaTreeContainer::GetBranchConf(std::vector<TString> files, TString patternToFind,
+ Bool_t& found) const
+{
+ TFile* oldFile = gFile;
+ TDirectory* oldDir = gDirectory;
+ for (auto file : files) {
+ TFile* f = new TFile(file);
+ AnalysisTree::Configuration* conf = (AnalysisTree::Configuration*) f->Get("Configuration");
+ auto branches = conf->GetListOfBranches();
+ for (auto branch : branches) {
+ if (patternToFind.EqualTo(branch)) {
+ found = kTRUE;
+ f->Close();
+ gFile = oldFile;
+ gDirectory = oldDir;
+ return conf->GetBranchConfig(patternToFind.Data());
+ }
+ }
+ f->Close();
+ }
+ gFile = oldFile;
+ gDirectory = oldDir;
+ found = kFALSE;
+ return AnalysisTree::BranchConfig();
+}
+
+Bool_t CbmAnaTreeRecoContainer::ConnectToTree(TChain* tree)
+{
+
fEvent = new AnalysisTree::EventHeader();
fVtxTracks = new AnalysisTree::TrackDetector();
fTofHits = new AnalysisTree::HitDetector();
fVtx2Tof = new AnalysisTree::Matching();
- fVtx2Mc = new AnalysisTree::Matching();
+ fVtx2Mc = nullptr;
if (tree->GetBranch("VtxTracks.") == nullptr) {
Hal::Cout::PrintInfo("Lack of VtxTracks in AT", Hal::EInfo::kError);
return kFALSE;
@@ -51,7 +134,7 @@ Bool_t CbmAnaTreeRecoSourceContainer::ConnectToTree(TChain* tree)
return kTRUE;
}
-Bool_t CbmAnaTreeMcSourceContainer::ConnectToTree(TChain* tree)
+Bool_t CbmAnaTreeMcContainer::ConnectToTree(TChain* tree)
{
fEvent = new AnalysisTree::EventHeader();
fParticles = new AnalysisTree::Particles();
@@ -64,63 +147,120 @@ Bool_t CbmAnaTreeMcSourceContainer::ConnectToTree(TChain* tree)
return kTRUE;
}
-void CbmAnaTreeRecoSourceContainer::LoadFields(TString file)
+void CbmAnaTreeV0Container::LoadFields(std::vector<TString> list)
{
- TFile* oldFile = gFile;
- TDirectory* oldDir = gDirectory;
+ Bool_t found;
+ AnalysisTree::BranchConfig conf = GetBranchConf(list, "Candidates", found);
+ if (!found) return;
+ GetFieldIds().chi2geo = conf.GetFieldId("chi2_geo");
+ GetFieldIds().chi2_prim_first = conf.GetFieldId("chi2_prim_first");
+ GetFieldIds().chi2_prim_second = conf.GetFieldId("chi2_prim_second");
+ GetFieldIds().chi2_topo = conf.GetFieldId("chi2_topo");
+ GetFieldIds().cosine_first = conf.GetFieldId("cosine_first");
+ GetFieldIds().cosine_second = conf.GetFieldId("cosine_second");
- TFile* f = new TFile(file);
- AnalysisTree::Configuration* conf = (AnalysisTree::Configuration*) f->Get("Configuration");
- GetFieldIds().vtx_px = conf->GetBranchConfig("VtxTracks").GetFieldId("px");
- GetFieldIds().vtx_py = conf->GetBranchConfig("VtxTracks").GetFieldId("py");
- GetFieldIds().vtx_pz = conf->GetBranchConfig("VtxTracks").GetFieldId("pz");
- GetFieldIds().vtx_dcax = conf->GetBranchConfig("VtxTracks").GetFieldId("dcax");
- GetFieldIds().vtx_dcay = conf->GetBranchConfig("VtxTracks").GetFieldId("dcay");
- GetFieldIds().vtx_dcaz = conf->GetBranchConfig("VtxTracks").GetFieldId("dcaz");
- GetFieldIds().vtx_chi2 = conf->GetBranchConfig("VtxTracks").GetFieldId("chi2");
- GetFieldIds().vtx_vtxchi2 = conf->GetBranchConfig("VtxTracks").GetFieldId("vtx_chi2");
- GetFieldIds().vtx_q = conf->GetBranchConfig("VtxTracks").GetFieldId("q");
- GetFieldIds().vtx_nhits = conf->GetBranchConfig("VtxTracks").GetFieldId("nhits");
- GetFieldIds().vtx_mvdhits = conf->GetBranchConfig("VtxTracks").GetFieldId("nhits_mvd");
+ GetFieldIds().cosine_topo = conf.GetFieldId("cosine_topo");
+ GetFieldIds().distance = conf.GetFieldId("distance");
+ GetFieldIds().l = conf.GetFieldId("l");
+ GetFieldIds().l_over_dl = conf.GetFieldId("l_over_dl");
+ GetFieldIds().px = conf.GetFieldId("px");
+ GetFieldIds().py = conf.GetFieldId("py");
+ GetFieldIds().pz = conf.GetFieldId("pz");
+ GetFieldIds().x = conf.GetFieldId("x");
+ GetFieldIds().y = conf.GetFieldId("y");
+ GetFieldIds().z = conf.GetFieldId("z");
+ GetFieldIds().dau1id = conf.GetFieldId("daughter1_id");
+ GetFieldIds().dau2id = conf.GetFieldId("daughter2_id");
+ GetFieldIds().mass = conf.GetFieldId("mass");
- GetFieldIds().tof_mass2 = conf->GetBranchConfig("TofHits").GetFieldId("mass2");
+#ifdef DEBUG_EXTR
+ GetFieldIds().dau1px = conf.GetFieldId("dau1px");
+ GetFieldIds().dau1py = conf.GetFieldId("dau1py");
+ GetFieldIds().dau1pz = conf.GetFieldId("dau1pz");
+ GetFieldIds().dau1x = conf.GetFieldId("dau1x");
+ GetFieldIds().dau1y = conf.GetFieldId("dau1y");
+ GetFieldIds().dau1z = conf.GetFieldId("dau1z");
- GetFieldIds().vtx_x = conf->GetBranchConfig("VtxTracks").GetFieldId("x");
- GetFieldIds().vtx_cx0 = conf->GetBranchConfig("VtxTracks").GetFieldId("cx0");
- GetFieldIds().vtx_cov1 = conf->GetBranchConfig("VtxTracks").GetFieldId("cov1");
- gFile = oldFile;
- gDirectory = oldDir;
+ GetFieldIds().dau2px = conf.GetFieldId("dau2px");
+ GetFieldIds().dau2py = conf.GetFieldId("dau2py");
+ GetFieldIds().dau2pz = conf.GetFieldId("dau2pz");
+ GetFieldIds().dau2x = conf.GetFieldId("dau2x");
+ GetFieldIds().dau2y = conf.GetFieldId("dau2y");
+ GetFieldIds().dau2z = conf.GetFieldId("dau2z");
- f->Close();
- delete f;
+#endif
+
+
+ GetFieldIds().id = conf.GetFieldId("id");
+ GetFieldIds().pdg = conf.GetFieldId("pid");
+ // if (!found) return;
+ // GetFieldIds().mass = conf.GetFieldId("dcaz");
}
-void CbmAnaTreeMcSourceContainer::LoadFields(TString inFile)
+Bool_t CbmAnaTreeV0Container::ConnectToTree(TChain* tree)
{
- TFile* oldFile = gFile;
- TDirectory* oldDir = gDirectory;
+ fParticles = new AnalysisTree::Particles();
+ fParticlesMc = new AnalysisTree::Particles();
+
+ auto vec = Hal::RootIOManager::GetListOfBranches(tree, true);
+ bool found = false;
+ for (auto brName : vec) {
+ brName.EqualTo("Candidates.");
+ found = true;
+ }
+ if (!found) return kFALSE;
+ tree->SetBranchAddress("Candidates.", &fParticles);
+ tree->SetBranchAddress("Simulated.", &fParticlesMc);
+ tree->SetBranchAddress("Candidates2Simulated.", &fV02Mc);
+
+ tree->SetBranchStatus("Candidates.", 1);
+ tree->SetBranchStatus("Simulated.", 1);
+ tree->SetBranchStatus("Candidates2Simulated.", 1);
+ return kTRUE;
+}
+
+void CbmAnaTreeContainers::LoadConf(Hal::InputDataInfo* info)
+{
+ auto listRow = info->GetListOfFiles();
+ std::vector<TString> rec1;
+ for (auto lev : listRow) {
+ rec1.push_back(lev[0]);
+ }
+ for (int i = 0; i < GetSize(); i++) {
+ fContainers[i]->LoadFields(rec1);
+ }
+}
+
+CbmAnaTreeContainers::CbmAnaTreeContainers()
+{
+ fContainers[0] = new CbmAnaTreeMcContainer();
+ fContainers[1] = new CbmAnaTreeRecoContainer();
+ fContainers[2] = new CbmAnaTreeV0Container();
+}
- TFile* f = new TFile(inFile);
-
- AnalysisTree::Configuration* conf = (AnalysisTree::Configuration*) f->Get("Configuration");
-
- GetFieldIds().px = conf->GetBranchConfig("SimParticles").GetFieldId("px");
- GetFieldIds().py = conf->GetBranchConfig("SimParticles").GetFieldId("py");
- GetFieldIds().pz = conf->GetBranchConfig("SimParticles").GetFieldId("pz");
- GetFieldIds().mass = conf->GetBranchConfig("SimParticles").GetFieldId("mass");
- GetFieldIds().pdg = conf->GetBranchConfig("SimParticles").GetFieldId("pid");
- GetFieldIds().motherId = conf->GetBranchConfig("SimParticles").GetFieldId("mother_id");
- GetFieldIds().event_b = conf->GetBranchConfig("SimEventHeader").GetFieldId("b");
- GetFieldIds().event_psi = conf->GetBranchConfig("SimEventHeader").GetFieldId("psi_RP");
- GetFieldIds().freezX = conf->GetBranchConfig("SimParticles").GetFieldId("xfreez");
- GetFieldIds().freezY = conf->GetBranchConfig("SimParticles").GetFieldId("yfreez");
- GetFieldIds().freezZ = conf->GetBranchConfig("SimParticles").GetFieldId("zfreez");
- GetFieldIds().freezT = conf->GetBranchConfig("SimParticles").GetFieldId("tfreez");
- gFile = oldFile;
- gDirectory = oldDir;
-
- f->Close();
- delete f;
+CbmAnaTreeContainer* CbmAnaTreeContainers::GetContainer(EContainerType type)
+{
+ switch (type) {
+ case EContainerType::kMc: {
+ return fContainers[0];
+ } break;
+ case EContainerType::kReco: {
+ return fContainers[1];
+ } break;
+ case EContainerType::kV0: {
+ return fContainers[2];
+ } break;
+ }
+ return nullptr;
+}
+
+std::vector<TString> CbmAnaTreeContainers::GetNames()
+{
+ std::vector<TString> res;
+ res.push_back("mc");
+ res.push_back("reco");
+ res.push_back("v0");
+ return res;
}
diff --git a/analysis/PWGC2F/femtoscopy/hal/helpers/anatree/CbmAnaTreeContainer.h b/analysis/PWGC2F/femtoscopy/hal/helpers/anatree/CbmAnaTreeContainer.h
index 4c6d77cc108bd32928f7d28abadf9a4894cc49b3..849e1f32d9a0b84c4fff1cc860ebd8686f32fcd8 100644
--- a/analysis/PWGC2F/femtoscopy/hal/helpers/anatree/CbmAnaTreeContainer.h
+++ b/analysis/PWGC2F/femtoscopy/hal/helpers/anatree/CbmAnaTreeContainer.h
@@ -4,6 +4,7 @@
#ifndef NICACBMATCONTAINER_H_
#define NICACBMATCONTAINER_H_
+
#include <TNamed.h>
#include <AnalysisTree/Detector.hpp>
@@ -11,7 +12,19 @@
#include <AnalysisTree/Matching.hpp>
class TChain;
+class TFile;
+//#define DEBUG_EXTR
+
+namespace AnalysisTree
+{
+ class Configuration;
+}
+namespace Hal
+{
+ class InputDataInfo;
+}
+class HalCbmATIOManager;
struct AnaTreeRecoIds {
Int_t vtx_px, vtx_py, vtx_pz;
Int_t vtx_dcax, vtx_dcay, vtx_dcaz;
@@ -21,7 +34,19 @@ struct AnaTreeRecoIds {
Int_t tof_mass2;
};
-class CbmAnaTreeRecoSourceContainer : public TNamed {
+class CbmAnaTreeContainer : public TNamed {
+
+ public:
+ CbmAnaTreeContainer() : TNamed(){};
+ virtual void LoadFields(std::vector<TString> list) = 0;
+ virtual Bool_t ConnectToTree(TChain* chains) = 0;
+ AnalysisTree::BranchConfig GetBranchConf(std::vector<TString> files, TString patternToFind, Bool_t& found) const;
+ virtual ~CbmAnaTreeContainer(){};
+ ClassDef(CbmAnaTreeContainer, 1)
+};
+
+
+class CbmAnaTreeRecoContainer : public CbmAnaTreeContainer {
AnalysisTree::EventHeader* fEvent = {nullptr};
AnalysisTree::TrackDetector* fVtxTracks = {nullptr};
AnalysisTree::Matching* fVtx2Tof = {nullptr};
@@ -30,16 +55,16 @@ class CbmAnaTreeRecoSourceContainer : public TNamed {
AnaTreeRecoIds fVtxIds;
public:
- CbmAnaTreeRecoSourceContainer(){};
- void LoadFields(TString file);
- Bool_t ConnectToTree(TChain* tree);
+ CbmAnaTreeRecoContainer(){};
+ void LoadFields(std::vector<TString> list);
+ Bool_t ConnectToTree(TChain* chains);
inline AnalysisTree::EventHeader* GetEventHeader() const { return fEvent; };
inline AnalysisTree::TrackDetector* GetVtxTracks() const { return fVtxTracks; };
inline AnalysisTree::HitDetector* GetTofHits() const { return fTofHits; };
inline AnalysisTree::Matching* GetVtx2ToFMatch() const { return fVtx2Tof; };
inline AnalysisTree::Matching* GetVtx2Sim() const { return fVtx2Mc; };
inline AnaTreeRecoIds& GetFieldIds() { return fVtxIds; }
- virtual ~CbmAnaTreeRecoSourceContainer()
+ virtual ~CbmAnaTreeRecoContainer()
{
if (fEvent) {
delete fEvent;
@@ -49,7 +74,7 @@ class CbmAnaTreeRecoSourceContainer : public TNamed {
delete fVtx2Mc;
}
}
- ClassDef(CbmAnaTreeRecoSourceContainer, 1)
+ ClassDef(CbmAnaTreeRecoContainer, 1)
};
struct AnaTreeMcIds {
@@ -60,26 +85,88 @@ struct AnaTreeMcIds {
Int_t freezX, freezY, freezZ, freezT;
};
-class CbmAnaTreeMcSourceContainer : public TNamed {
+class CbmAnaTreeMcContainer : public CbmAnaTreeContainer {
AnalysisTree::EventHeader* fEvent = {nullptr};
AnalysisTree::Particles* fParticles = {nullptr};
AnaTreeMcIds fIds;
public:
- CbmAnaTreeMcSourceContainer(){};
- void LoadFields(TString inFile);
- Bool_t ConnectToTree(TChain* tree);
+ CbmAnaTreeMcContainer(){};
+ void LoadFields(std::vector<TString> list);
+ Bool_t ConnectToTree(TChain* chains);
inline AnaTreeMcIds& GetFieldIds() { return fIds; };
inline AnalysisTree::EventHeader* GetEventHeader() const { return fEvent; };
inline AnalysisTree::Particles* GetParticles() const { return fParticles; };
- virtual ~CbmAnaTreeMcSourceContainer()
+ virtual ~CbmAnaTreeMcContainer()
{
if (fEvent) {
delete fEvent;
delete fParticles;
}
};
- ClassDef(CbmAnaTreeMcSourceContainer, 1)
+ ClassDef(CbmAnaTreeMcContainer, 1)
+};
+
+struct AnaTreeV0Ids {
+ Int_t chi2geo, chi2_prim_first;
+ Int_t chi2_prim_second, chi2_topo;
+ Int_t cosine_first, cosine_second, cosine_topo;
+ Int_t distance, l, l_over_dl;
+ Int_t px, py, pz;
+ Int_t x, y, z;
+ Int_t dau1id, dau2id, id;
+ Int_t pdg, mass;
+#ifdef DEBUG_EXTR
+ int dau1px, dau1py, dau1pz, dau1x, dau1y, dau1z;
+ int dau2px, dau2py, dau2pz, dau2x, dau2y, dau2z;
+#endif
+};
+
+class CbmAnaTreeV0Container : public CbmAnaTreeContainer {
+ AnalysisTree::Particles* fParticles = {nullptr};
+ AnalysisTree::Particles* fParticlesMc = {nullptr};
+ AnalysisTree::Matching* fV02Mc = {nullptr};
+ AnaTreeV0Ids fIds;
+
+ public:
+ CbmAnaTreeV0Container(){};
+ void LoadFields(std::vector<TString> list);
+ Bool_t ConnectToTree(TChain* chains);
+ inline AnaTreeV0Ids& GetFieldIds() { return fIds; };
+ inline AnalysisTree::Particles* GetParticles() const { return fParticles; };
+ AnalysisTree::Matching* GetMaching() const { return fV02Mc; };
+ virtual ~CbmAnaTreeV0Container()
+ {
+ if (fParticles) delete fParticles;
+ if (fParticlesMc) delete fParticlesMc;
+ if (fV02Mc) delete fV02Mc;
+ };
+ ClassDef(CbmAnaTreeV0Container, 1)
};
+
+class CbmAnaTreeContainers : public TObject {
+
+
+ public:
+ enum class EContainerType
+ {
+ kMc = 0,
+ kReco = 1,
+ kV0 = 2
+ };
+ CbmAnaTreeContainer* fContainers[3] = {nullptr, nullptr, nullptr};
+ CbmAnaTreeContainers();
+ void LoadConf(Hal::InputDataInfo* info);
+ static std::vector<TString> GetNames();
+ CbmAnaTreeContainer* GetContainer(EContainerType type);
+ CbmAnaTreeV0Container* GetV0Data() const { return (CbmAnaTreeV0Container*) fContainers[2]; }
+ CbmAnaTreeRecoContainer* GetRecoData() const { return (CbmAnaTreeRecoContainer*) fContainers[2]; }
+ CbmAnaTreeMcContainer* GetSimData() const { return (CbmAnaTreeMcContainer*) fContainers[2]; }
+ Int_t GetSize() const { return 3; }
+ virtual ~CbmAnaTreeContainers(){};
+ ClassDef(CbmAnaTreeContainers, 1)
+};
+
+
#endif /* NICACBMATCONTAINER_H_ */
diff --git a/analysis/PWGC2F/femtoscopy/hal/helpers/anatree/CbmAnaTreeSource.cxx b/analysis/PWGC2F/femtoscopy/hal/helpers/anatree/CbmAnaTreeSource.cxx
index 2122087bbd73f340ad72d64e70c0e2d9fd17d6aa..d78fcda8ff347212c0ebaecead5fe0aca8850c77 100644
--- a/analysis/PWGC2F/femtoscopy/hal/helpers/anatree/CbmAnaTreeSource.cxx
+++ b/analysis/PWGC2F/femtoscopy/hal/helpers/anatree/CbmAnaTreeSource.cxx
@@ -4,6 +4,7 @@
#include "CbmAnaTreeSource.h"
#include "CbmAnaTreeContainer.h"
+#include "HalCbmDetectorID.h"
#include <FairLogger.h>
#include <FairRootManager.h>
@@ -14,6 +15,9 @@
#include <AnalysisTree/Configuration.hpp>
#include <fstream>
+#include <vector>
+
+#include <Hal/InputDataInfo.h>
CbmAnaTreeSource::CbmAnaTreeSource() : CbmAnaTreeSource("", "aTree") {}
@@ -23,8 +27,7 @@ CbmAnaTreeSource::CbmAnaTreeSource(TString inFile, TString treeName)
, fTreeName(treeName)
, fChain(nullptr)
, fFileName(nullptr)
- , fContainerReco(nullptr)
- , fContainerSim(nullptr)
+ , fATSource(nullptr)
{
fFileName = new TString[1];
fFileName[0] = inFile;
@@ -40,13 +43,14 @@ Bool_t CbmAnaTreeSource::Init()
LOG(debug) << "Init source ";
FairRootManager* mngr = FairRootManager::Instance();
fChain = new TChain(fTreeName); //new name of tree?
- TString first_file_name;
+
+ Hal::InputDataInfo info;
if (fFileName[0].EndsWith(".root")) {
for (int i = 0; i < fNFiles; i++) {
LOG(debug) << "CbmAnaTree: opening single file" << fFileName[i];
fChain->Add(fFileName[i]);
+ info.AddFile(fFileName[i]);
}
- first_file_name = fFileName[0];
}
else { // this is long list
std::ifstream list;
@@ -57,9 +61,9 @@ Bool_t CbmAnaTreeSource::Init()
list >> temp;
if (temp.Length() > 1) {
fChain->Add(temp);
+ info.AddFile(temp);
if (first) {
- first_file_name = temp;
- first = false;
+ first = false;
}
}
else {
@@ -69,29 +73,22 @@ Bool_t CbmAnaTreeSource::Init()
} while (!list.eof());
list.close();
}
+
+
+ info.AddFile(mngr->GetInFile()->GetName());
+ fATSource = new CbmAnaTreeContainers();
LOG(debug) << "load container ";
- fContainerReco = new CbmAnaTreeRecoSourceContainer();
- fContainerSim = new CbmAnaTreeMcSourceContainer();
- Bool_t recoAvail = fContainerReco->ConnectToTree(fChain);
- Bool_t simAvail = fContainerSim->ConnectToTree(fChain);
- if (recoAvail == kFALSE) {
- delete fContainerReco;
- fContainerReco = nullptr;
- }
- if (simAvail == kFALSE) {
- delete fContainerSim;
- fContainerSim = nullptr;
- }
- LOG(debug) << "load conf ";
- LoadConf(first_file_name);
+ fATSource->LoadConf(&info);
+
mngr->SetInChain(fChain, -1);
- if (fContainerReco) {
- LOG(debug) << "Loading reco data";
- mngr->Register("CbmAnaTreeSourceContainer.", "CbmAnaTreeSourceContainer", fContainerReco, kFALSE);
- }
- if (fContainerSim) {
- LOG(debug) << "Loading sim ana";
- mngr->Register("CbmAnaTreeMcSourceContainer.", "CbmAnaTreeMcSourceContainer", fContainerSim, kFALSE);
+
+ auto contNames = CbmAnaTreeContainers::GetNames();
+ for (int i = 0; i < fATSource->GetSize(); i++) {
+ bool con = fATSource->fContainers[i]->ConnectToTree(fChain);
+ if (con) {
+ TString name = HalCbm::GetContainerName(contNames[i]);
+ mngr->Register(name, "AT", fATSource->fContainers[i], kFALSE);
+ }
}
return kTRUE;
}
@@ -104,24 +101,6 @@ Int_t CbmAnaTreeSource::ReadEvent(UInt_t unsignedInt)
void CbmAnaTreeSource::Close() {}
-void CbmAnaTreeSource::LoadConf(TString name)
-{
- /// Save old global file and folder pointer to avoid messing with FairRoot
- TFile* oldFile = gFile;
- TDirectory* oldDir = gDirectory;
-
- if (fContainerReco) {
- fContainerReco->LoadFields(name);
- }
- if (fContainerSim) {
- fContainerSim->LoadFields(name);
- }
-
- /// Restore old global file and folder pointer to avoid messing with FairRoot
- gFile = oldFile;
- gDirectory = oldDir;
-}
-
void CbmAnaTreeSource::AddFile(TString file)
{
TString* temp = fFileName;
diff --git a/analysis/PWGC2F/femtoscopy/hal/helpers/anatree/CbmAnaTreeSource.h b/analysis/PWGC2F/femtoscopy/hal/helpers/anatree/CbmAnaTreeSource.h
index 2460c4674a161a43c54dd0dd494d7f06c0c3b6e5..7c3dc14cccb2019d71e0eba1fadb080c27658d57 100644
--- a/analysis/PWGC2F/femtoscopy/hal/helpers/anatree/CbmAnaTreeSource.h
+++ b/analysis/PWGC2F/femtoscopy/hal/helpers/anatree/CbmAnaTreeSource.h
@@ -12,8 +12,7 @@
#include <TString.h>
-class CbmAnaTreeMcSourceContainer;
-class CbmAnaTreeRecoSourceContainer;
+class CbmAnaTreeContainers;
class TChain;
class CbmAnaTreeSource : public FairSource {
@@ -21,11 +20,7 @@ class CbmAnaTreeSource : public FairSource {
TString fTreeName;
TChain* fChain;
TString* fFileName; //[fNFiles]
- CbmAnaTreeRecoSourceContainer* fContainerReco;
- CbmAnaTreeMcSourceContainer* fContainerSim;
-
- protected:
- void LoadConf(TString name);
+ CbmAnaTreeContainers* fATSource;
public:
/**
@@ -60,8 +55,6 @@ class CbmAnaTreeSource : public FairSource {
virtual void ReadBranchEvent(const char* /*BrName*/){};
virtual void ReadBranchEvent(const char* /*BrName*/, Int_t /*Event*/){};
virtual void FillEventHeader(FairEventHeader* /*feh*/){};
- CbmAnaTreeRecoSourceContainer* GetRecoContainer() const { return fContainerReco; };
- CbmAnaTreeMcSourceContainer* GetSimContainer() const { return fContainerSim; }
void SetRunId(Int_t runId) { fRunId = runId; }
ClassDef(CbmAnaTreeSource, 1)
};
diff --git a/analysis/PWGC2F/femtoscopy/hal/helpers/anatree/HalCbmSource.cxx b/analysis/PWGC2F/femtoscopy/hal/helpers/anatree/HalCbmSource.cxx
deleted file mode 100644
index dd8dae3baf3f6c7ef3c9ebe0fd3a7c413d83ad0b..0000000000000000000000000000000000000000
--- a/analysis/PWGC2F/femtoscopy/hal/helpers/anatree/HalCbmSource.cxx
+++ /dev/null
@@ -1,59 +0,0 @@
-/* Copyright (C) 2023-2023 Warsaw University of Technology, Warsaw
- SPDX-License-Identifier: GPL-3.0-only
- Authors: Daniel Wielanek [committer] */
-#include "HalCbmSource.h"
-
-#include "CbmAnaTreeContainer.h"
-
-#include <TBranch.h>
-#include <TNamed.h>
-#include <TObjArray.h>
-
-#include <Hal/RootIOManager.h>
-
-HalCbmSource::HalCbmSource(TString filename) : Source(filename) { fManager = new HalCbmATIOManager(filename); }
-
-void HalCbmSource::AddFile(TString fileName) { fManager->AddFile(fileName); }
-
-void HalCbmSource::AddFriend(TString friendName, Int_t level) { fManager->AddFriend(friendName, level); }
-
-HalCbmSource::~HalCbmSource() { delete fManager; }
-
-void HalCbmATIOManager::FillBranches()
-{
- auto inchain = GetInChain();
- fRecoContainer = new CbmAnaTreeRecoSourceContainer();
- fSimContainer = new CbmAnaTreeMcSourceContainer();
- Bool_t recoAvail = fRecoContainer->ConnectToTree(inchain[0]);
- Bool_t simAvail = fSimContainer->ConnectToTree(inchain[0]);
- fRecoContainer->LoadFields(GetInputFileName());
- fSimContainer->LoadFields(GetInputFileName());
- int count = -1;
- for (auto chain : inchain) {
- count++;
- if (count == 0) {
- if (recoAvail) {
- AddBranch("CbmAnaTreeSourceContainer.", fRecoContainer, Hal::BranchInfo::EFlag::kInActive);
- }
- if (simAvail) {
- AddBranch("CbmAnaTreeMcSourceContainer.", fSimContainer, Hal::BranchInfo::EFlag::kInActive);
- }
- continue; //skip first chain - we are looking for AT data
- }
- TObjArray* list_branch = chain->GetListOfBranches();
- for (int i = 0; i < list_branch->GetEntries(); i++) {
- TBranch* branch = (TBranch*) list_branch->At(i);
- TString name = branch->GetName();
- TObject** obj = new TObject*();
- PushTObject(obj);
- chain->SetBranchAddress(name, obj);
- AddBranch(branch->GetName(), obj[0], Hal::BranchInfo::EFlag::kInActive);
- }
- }
-}
-
-HalCbmATIOManager::~HalCbmATIOManager()
-{
- if (fRecoContainer) delete fRecoContainer;
- if (fSimContainer) delete fSimContainer;
-}
diff --git a/analysis/PWGC2F/femtoscopy/hal/helpers/fair/Field.cxx b/analysis/PWGC2F/femtoscopy/hal/helpers/fair/Field.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..eb8c8511034e84bebca5dc3ec4b201b27f8fb5db
--- /dev/null
+++ b/analysis/PWGC2F/femtoscopy/hal/helpers/fair/Field.cxx
@@ -0,0 +1,21 @@
+/* Copyright (C) 2025-2025 Warsaw University of Technology, Warsaw
+ SPDX-License-Identifier: GPL-3.0-only
+ Authors: Daniel Wielanek [committer] */
+#include "Field.h"
+
+#include <FairField.h>
+
+namespace Hal
+{
+ namespace Fair
+ {
+
+ Field::Field() : fField(nullptr) {}
+
+ TVector3 Field::GetField(Double_t x, Double_t y, Double_t z) const
+ {
+ return TVector3(fField->GetBx(x, y, z), fField->GetBy(x, y, z), fField->GetBz(x, y, z));
+ }
+ Field::~Field() { fField = nullptr; }
+ } // namespace Fair
+} /* namespace Hal */
diff --git a/analysis/PWGC2F/femtoscopy/hal/helpers/fair/Field.h b/analysis/PWGC2F/femtoscopy/hal/helpers/fair/Field.h
new file mode 100644
index 0000000000000000000000000000000000000000..39fc5d712e42bafd2912e2a6d62ddf81cf538beb
--- /dev/null
+++ b/analysis/PWGC2F/femtoscopy/hal/helpers/fair/Field.h
@@ -0,0 +1,33 @@
+/* Copyright (C) 2025-2025 Warsaw University of Technology, Warsaw
+ SPDX-License-Identifier: GPL-3.0-only
+ Authors: Daniel Wielanek [committer] */
+#ifndef HAL_FAIR_FIELD_H_
+#define HAL_FAIR_FIELD_H_
+
+#include <TVector3.h>
+
+#include <Hal/MagField.h>
+
+/**
+ * interface to Fair magnetic field
+ */
+class FairField;
+namespace Hal
+{
+ namespace Fair
+ {
+ class Field : public ::Hal::MagField {
+ FairField* fField;
+
+ public:
+ Field();
+ void SetField(FairField* field) { fField = field; };
+ FairField* GetFairField() const { return fField; }
+ TVector3 GetField(Double_t x, Double_t y, Double_t z) const;
+ virtual ~Field();
+ ClassDef(Field, 1)
+ };
+ } // namespace Fair
+} /* namespace Hal */
+
+#endif /* HAL_FAIR_FIELD_H_ */
diff --git a/analysis/PWGC2F/femtoscopy/hal/helpers/fair/QAManagerBasic.cxx b/analysis/PWGC2F/femtoscopy/hal/helpers/fair/QAManagerBasic.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..f8ffaaeccc443385f6a434ccc354af7013560e23
--- /dev/null
+++ b/analysis/PWGC2F/femtoscopy/hal/helpers/fair/QAManagerBasic.cxx
@@ -0,0 +1,42 @@
+/* Copyright (C) 2025-2025 Warsaw University of Technology, Warsaw
+ SPDX-License-Identifier: GPL-3.0-only
+ Authors: Daniel Wielanek [committer] */
+#include "QAManagerBasic.h"
+
+#include <FairFileSource.h>
+#include <FairParRootFileIo.h>
+#include <FairRun.h>
+#include <FairRunAna.h>
+#include <FairRuntimeDb.h>
+
+namespace Hal
+{
+ namespace Fair
+ {
+ QAManagerBasic::QAManagerBasic() {}
+
+ QAManagerBasic::~QAManagerBasic() {}
+
+ FairRunAna* QAManagerBasic::GetRunAna(TString outFile, TString simFile, TString recoFile, TString parFile)
+ {
+ if (simFile.Length() == 0) {
+ simFile = recoFile;
+ recoFile = "";
+ }
+ FairRunAna* run = new FairRunAna();
+ FairFileSource* file = new FairFileSource(simFile);
+ if (recoFile != "") {
+ file->AddFriend(recoFile);
+ }
+ if (parFile != "") {
+ FairRuntimeDb* rtdb = run->GetRuntimeDb();
+ FairParRootFileIo* parIo1 = new FairParRootFileIo();
+ parIo1->open(parFile.Data());
+ rtdb->setFirstInput(parIo1);
+ }
+ run->SetSource(file);
+ run->SetOutputFile(outFile);
+ return run;
+ }
+ } // namespace Fair
+} /* namespace Hal */
diff --git a/analysis/PWGC2F/femtoscopy/hal/helpers/fair/QAManagerBasic.h b/analysis/PWGC2F/femtoscopy/hal/helpers/fair/QAManagerBasic.h
new file mode 100644
index 0000000000000000000000000000000000000000..47155a0d76818754123ce051ebe71cc4d546b2ca
--- /dev/null
+++ b/analysis/PWGC2F/femtoscopy/hal/helpers/fair/QAManagerBasic.h
@@ -0,0 +1,29 @@
+/* Copyright (C) 2025-2025 Warsaw University of Technology, Warsaw
+ SPDX-License-Identifier: GPL-3.0-only
+ Authors: Daniel Wielanek [committer] */
+#ifndef HAL_FAIR_QAMANAGERBASIC_H_
+#define HAL_FAIR_QAMANAGERBASIC_H_
+
+#include <TString.h>
+
+#include <Hal/QAManager.h>
+
+/**
+ * abstract class for QA in FairRoot-based frameworks
+ */
+class FairRunAna;
+namespace Hal
+{
+ namespace Fair
+ {
+ class QAManagerBasic : public ::Hal::QAManager {
+ public:
+ QAManagerBasic();
+ virtual FairRunAna* GetRunAna(TString outFile, TString simFile, TString recoFile = "", TString parFile = "");
+ virtual ~QAManagerBasic();
+ ClassDef(QAManagerBasic, 1)
+ };
+ } // namespace Fair
+} /* namespace Hal */
+
+#endif /* HAL_FAIR_QAMANAGERBASIC_H_ */
diff --git a/analysis/PWGC2F/femtoscopy/hal/helpers/fair/RootManager.cxx b/analysis/PWGC2F/femtoscopy/hal/helpers/fair/RootManager.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..5c9f9271ab828ca3d00a5d58c2bb9726ec5eac9a
--- /dev/null
+++ b/analysis/PWGC2F/femtoscopy/hal/helpers/fair/RootManager.cxx
@@ -0,0 +1,88 @@
+/* Copyright (C) 2025-2025 Warsaw University of Technology, Warsaw
+ SPDX-License-Identifier: GPL-3.0-only
+ Authors: Daniel Wielanek [committer] */
+#include "RootManager.h"
+
+#include <FairRootManager.h>
+
+#include <RtypesCore.h>
+#include <TCollection.h>
+#include <TFile.h>
+#include <TList.h>
+#include <TObjString.h>
+
+#include <Hal/InputDataInfo.h>
+
+namespace Hal
+{
+ namespace Fair
+ {
+ RootManager::RootManager()
+ : Hal::IOManager(new Hal::InputDataInfo(FairRootManager::Instance()->GetInFile()->GetName()))
+ {
+ fFairManager = FairRootManager::Instance();
+ if (fFairManager->GetInFile()) {
+ fDataInfo->OverwriteSourceName(fFairManager->GetInFile()->GetName());
+ }
+ }
+
+ TObject* RootManager::GetObject(const char* BrName) { return fFairManager->GetObject(BrName); }
+
+ TFile* RootManager::GetInFile() { return fFairManager->GetInFile(); }
+
+ void RootManager::UpdateBranches() { fFairManager->UpdateBranches(); }
+
+ void RootManager::SetInChain(TChain* tempChain, Int_t ident) { fFairManager->SetInChain(tempChain, ident); }
+
+ void RootManager::RegisterInternal(const char* name, const char* folderName, TNamed* obj, Bool_t toFile)
+ {
+ fFairManager->Register(name, folderName, obj, toFile);
+ }
+
+ void RootManager::RegisterInternal(const char* name, const char* Foldername, TCollection* obj, Bool_t toFile)
+ {
+ fFairManager->Register(name, Foldername, obj, toFile);
+ }
+
+ void RootManager::RefreshBranchList()
+ {
+ fFairManager = FairRootManager::Instance();
+ TList* l = fFairManager->GetBranchNameList();
+ for (int i = 0; i < l->GetEntries(); i++) {
+ TString name = ((TObjString*) l->At(i))->GetString();
+ Int_t stat = fFairManager->CheckBranch(name);
+ TObject* obj = fFairManager->GetObject(name);
+ switch (stat) {
+ case 0: // not exist
+ break;
+ case 1: // in file
+ AddBranch(name, obj, BranchInfo::EFlag::kInActive);
+ break;
+ case 2: // memory
+ AddBranch(name, obj, BranchInfo::EFlag::kVirtual);
+ break;
+ }
+ }
+ }
+
+ Bool_t RootManager::InitInternal()
+ {
+ if (fFairManager == nullptr) {
+ fFairManager = FairRootManager::Instance();
+ if (fFairManager->GetInFile()) {
+ fDataInfo->OverwriteSourceName(fFairManager->GetInFile()->GetName());
+ }
+ }
+ RefreshBranchList();
+ return kTRUE;
+ }
+
+ void RootManager::CdToOutput()
+ {
+ if (!fFairManager) return;
+ auto file = fFairManager->GetOutFile();
+ if (file) file->cd();
+ }
+
+ } // namespace Fair
+} // namespace Hal
diff --git a/analysis/PWGC2F/femtoscopy/hal/helpers/fair/RootManager.h b/analysis/PWGC2F/femtoscopy/hal/helpers/fair/RootManager.h
new file mode 100644
index 0000000000000000000000000000000000000000..836d4d3ba7cd8add6c245e271341d0858adf6425
--- /dev/null
+++ b/analysis/PWGC2F/femtoscopy/hal/helpers/fair/RootManager.h
@@ -0,0 +1,48 @@
+/* Copyright (C) 2025-2025 Warsaw University of Technology, Warsaw
+ SPDX-License-Identifier: GPL-3.0-only
+ Authors: Daniel Wielanek [committer] */
+#ifndef HAL_FAIR_ROOTMANAGER_H_
+#define HAL_FAIR_ROOTMANAGER_H_
+
+#include <Hal/DataManager.h>
+#include <Hal/IOManager.h>
+
+
+/**
+ * IO manager for FairRoot
+ */
+class TObject;
+class TFile;
+class TChain;
+class TList;
+class FairRootManager;
+namespace Hal
+{
+ namespace Fair
+ {
+ class RootManager : public IOManager {
+ FairRootManager* fFairManager;
+
+ protected:
+ virtual void RegisterInternal(const char* name, const char* folderName, TNamed* obj, Bool_t toFile);
+ virtual void RegisterInternal(const char* name, const char* Foldername, TCollection* obj, Bool_t toFile);
+ virtual void RefreshBranchList();
+ virtual Bool_t InitInternal();
+
+ public:
+ RootManager();
+ TObject* GetObject(const char* BrName);
+ TFile* GetInFile();
+ void UpdateBranches();
+ void FillTree(){};
+ void SetInChain(TChain* tempChain, Int_t ident = -1);
+ Int_t CheckBranch(const char* BrName);
+ Int_t GetEntries() const { return -1; }
+ Int_t GetEntry(Int_t /*i*/, Int_t /*flag*/) { return -1; };
+ void CdToOutput();
+ virtual ~RootManager(){};
+ ClassDef(RootManager, 1)
+ };
+ } // namespace Fair
+} // namespace Hal
+#endif /* HAL_FAIR_ROOTMANAGER_H_ */
diff --git a/analysis/PWGC2F/femtoscopy/hal/helpers/fair/TaskManager.cxx b/analysis/PWGC2F/femtoscopy/hal/helpers/fair/TaskManager.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..e451ddc1e4c8e3d36c1297e18686fa898a7f6ed8
--- /dev/null
+++ b/analysis/PWGC2F/femtoscopy/hal/helpers/fair/TaskManager.cxx
@@ -0,0 +1,128 @@
+/* Copyright (C) 2025-2025 Warsaw University of Technology, Warsaw
+ SPDX-License-Identifier: GPL-3.0-only
+ Authors: Daniel Wielanek [committer] */
+#include "TaskManager.h"
+
+#include "RootManager.h"
+
+#include <RtypesCore.h>
+#include <TFile.h>
+
+#include <cstdlib>
+
+#include <Hal/DataManager.h>
+#include <Hal/IOManager.h>
+#include <Hal/Package.h>
+#include <Hal/Parameter.h>
+#include <Hal/Source.h>
+#include <Hal/Std.h>
+#include <Hal/Task.h>
+#include <Hal/TriggerTask.h>
+namespace Hal
+{
+ namespace Fair
+ {
+ TaskManager::TaskManager() : fManager(nullptr), fProcessedEvents(0) { fManager = new RootManager(); }
+
+ InitStatus TaskManager::Init()
+ {
+ fManager->Init();
+ DataManager* mng = DataManager::Instance();
+ mng->SetManager(fManager);
+ for (auto task : fTriggers) {
+ Task::EInitFlag stat = task->Init();
+ switch (stat) {
+ case Task::EInitFlag::kERROR: {
+ fPassiveTriggers.push_back(task);
+ } break;
+ case Task::EInitFlag::kSUCCESS: {
+ fActiveTriggers.push_back(task);
+ } break;
+ case Task::EInitFlag::kFATAL: {
+ exit(0);
+ return kFATAL;
+ } break;
+ }
+ }
+ for (auto task : fTasks) {
+ Task::EInitFlag stat = task->Init();
+ switch (stat) {
+ case Task::EInitFlag::kERROR: {
+ fPassiveTasks.push_back(task);
+ } break;
+ case Task::EInitFlag::kSUCCESS: {
+ fActiveTasks.push_back(task);
+ } break;
+ case Task::EInitFlag::kFATAL: {
+ exit(0);
+ return kFATAL;
+ } break;
+ }
+ }
+ return kSUCCESS;
+ }
+
+ void TaskManager::Exec(Option_t* option)
+ {
+ ++fProcessedEvents;
+ for (auto trigger : fActiveTriggers) {
+ trigger->Exec(option);
+ if (!trigger->IsEventGood()) {
+ return;
+ }
+ }
+ for (auto task : fActiveTasks) {
+ task->Exec(option);
+ }
+ }
+
+ void TaskManager::Finish()
+ {
+ auto GoToDir = [](TString name) {
+ TDirectory* dir = (TDirectory*) gFile;
+ std::vector<TString> array = Hal::Std::ExplodeString(name, '/');
+ for (int i = 0; i < (int) array.size(); i++) {
+ TDirectory* newdir = (TDirectory*) dir->FindObject(array[i]);
+ if (!newdir) {
+ dir->mkdir(array[i]);
+ }
+ dir->cd(array[i]);
+ }
+ };
+ Package* metadata_new = new Package();
+ metadata_new->SetName("RunInfo");
+ metadata_new->AddObject(new ParameterString("Software ver", HAL_PHYSICALANALYSYS_VER));
+ metadata_new->AddObject(new ParameterString("Date", Hal::Std::GetDate(), 'f'));
+ metadata_new->AddObject(new ParameterString("Time", Hal::Std::GetTime(), 'f'));
+ metadata_new->AddObject(new ParameterUInt("Processed_events", fProcessedEvents, '+'));
+ metadata_new->AddObject(new ParameterString("Input file", DataManager::Instance()->GetSourceName(), 'f'));
+ TList* list = new TList();
+ list->SetName("Tasks");
+ for (auto task : fTasks) {
+ TString name = task->ClassName();
+ TString label = "Active";
+ for (auto probeTask : fPassiveTasks) {
+ if (probeTask == task) label = "Passive";
+ }
+ list->AddLast(new ParameterString(name, label));
+ }
+ metadata_new->AddObject(list);
+
+ GoToDir("HalInfo");
+ TDirectory* dir = (TDirectory*) gFile;
+ TDirectory* metadatata = (TDirectory*) dir->Get("HalInfo");
+ if (metadatata->Get("RunInfo")) {
+ delete metadata_new;
+ }
+ else {
+ metadata_new->Write("RunInfo");
+ }
+ gFile->cd();
+ for (auto task : fTasks) {
+ task->FinishTask();
+ }
+ }
+
+ TaskManager::~TaskManager() {}
+ } // namespace Fair
+} /* namespace Hal */
diff --git a/analysis/PWGC2F/femtoscopy/hal/helpers/fair/TaskManager.h b/analysis/PWGC2F/femtoscopy/hal/helpers/fair/TaskManager.h
new file mode 100644
index 0000000000000000000000000000000000000000..84243909019e20d64e54d6ff5f6ddebceb42693b
--- /dev/null
+++ b/analysis/PWGC2F/femtoscopy/hal/helpers/fair/TaskManager.h
@@ -0,0 +1,56 @@
+/* Copyright (C) 2025-2025 Warsaw University of Technology, Warsaw
+ SPDX-License-Identifier: GPL-3.0-only
+ Authors: Daniel Wielanek [committer] */
+#ifndef HAL_FAIR_HALFAIRANALYSISMANAGER_H_
+#define HAL_FAIR_HALFAIRANALYSISMANAGER_H_
+
+#include <FairTask.h>
+
+#include <RtypesCore.h>
+#include <TString.h>
+
+#include <vector>
+
+#include <Hal/Task.h>
+
+/**
+ * wrapper of task for FairRoot
+ * You should add all task for analysis here, and later add this task as to the FairRunAna
+ */
+namespace Hal
+{
+ class IOManager;
+ class Source;
+ class TriggerTask;
+} /* namespace Hal */
+
+namespace Hal
+{
+ namespace Fair
+ {
+ class TaskManager : public FairTask {
+ protected:
+ IOManager* fManager;
+ std::vector<::Hal::TriggerTask*> fTriggers;
+ std::vector<::Hal::TriggerTask*> fActiveTriggers;
+ std::vector<::Hal::TriggerTask*> fPassiveTriggers;
+ std::vector<::Hal::Task*> fTasks;
+ std::vector<::Hal::Task*> fActiveTasks;
+ std::vector<::Hal::Task*> fPassiveTasks;
+ UInt_t fProcessedEvents;
+
+ virtual InitStatus Init();
+
+ public:
+ TaskManager();
+ virtual void AddTrigger(::Hal::TriggerTask* trigger) { fTriggers.push_back(trigger); }
+ virtual void AddTask(::Hal::Task* task) { fTasks.push_back(task); };
+ virtual void Exec(Option_t* option);
+ virtual void Finish();
+ virtual ~TaskManager();
+ ClassDef(TaskManager, 1)
+ };
+ } // namespace Fair
+} /* namespace Hal */
+
+#endif /* HAL_FAIR_HALFAIRANALYSISMANAGER_H_ */
diff --git a/analysis/PWGC2F/femtoscopy/hal/helpers/HalCbmCompressionTask.cxx b/analysis/PWGC2F/femtoscopy/hal/helpers/faircbm/HalCbmCompressionTask.cxx
similarity index 100%
rename from analysis/PWGC2F/femtoscopy/hal/helpers/HalCbmCompressionTask.cxx
rename to analysis/PWGC2F/femtoscopy/hal/helpers/faircbm/HalCbmCompressionTask.cxx
diff --git a/analysis/PWGC2F/femtoscopy/hal/helpers/HalCbmCompressionTask.h b/analysis/PWGC2F/femtoscopy/hal/helpers/faircbm/HalCbmCompressionTask.h
similarity index 100%
rename from analysis/PWGC2F/femtoscopy/hal/helpers/HalCbmCompressionTask.h
rename to analysis/PWGC2F/femtoscopy/hal/helpers/faircbm/HalCbmCompressionTask.h
diff --git a/analysis/PWGC2F/femtoscopy/hal/qa/CbmQACoreManager.cxx b/analysis/PWGC2F/femtoscopy/hal/helpers/faircbm/HalCbmQACoreManager.cxx
similarity index 87%
rename from analysis/PWGC2F/femtoscopy/hal/qa/CbmQACoreManager.cxx
rename to analysis/PWGC2F/femtoscopy/hal/helpers/faircbm/HalCbmQACoreManager.cxx
index 07465fa5edf80419680d0cce350546400c283c94..982ece5ad4fa6068aa5f00c0690981fc44736257 100644
--- a/analysis/PWGC2F/femtoscopy/hal/qa/CbmQACoreManager.cxx
+++ b/analysis/PWGC2F/femtoscopy/hal/helpers/faircbm/HalCbmQACoreManager.cxx
@@ -1,7 +1,7 @@
/* Copyright (C) 2023-2023 Warsaw University of Technology, Warsaw
SPDX-License-Identifier: GPL-3.0-only
Authors: Daniel Wielanek [committer] */
-#include "CbmQACoreManager.h"
+#include "HalCbmQACoreManager.h"
#include "CbmAnaTreeSource.h"
#include "HalCbmBasicTrackCuts.h"
@@ -19,7 +19,7 @@
#include <Hal/TrackAna.h>
-CbmQACoreManager::CbmQACoreManager()
+HalCbmQACoreManager::HalCbmQACoreManager()
{
fEta[0] = -2;
fEta[1] = 4;
@@ -27,7 +27,7 @@ CbmQACoreManager::CbmQACoreManager()
fDCAz[1] = 10;
}
-Hal::Event* CbmQACoreManager::GetFormat(eFormatType type, eAnaType ana)
+Hal::Event* HalCbmQACoreManager::GetFormat(eFormatType type, eAnaType ana)
{
switch (ana) {
case eAnaType::kDefault:
@@ -48,7 +48,7 @@ Hal::Event* CbmQACoreManager::GetFormat(eFormatType type, eAnaType ana)
return nullptr;
}
-void CbmQACoreManager::SetRecoTrackCut(Hal::TrackAna* ana, ePidCut cut, eParticleType primary, TString flag)
+void HalCbmQACoreManager::SetRecoTrackCut(Hal::TrackAna* ana, ePidCut cut, eParticleType primary, TString flag)
{
HalCbmBasicTrackCuts cuts;
switch (cut) {
@@ -122,7 +122,7 @@ void CbmQACoreManager::SetRecoTrackCut(Hal::TrackAna* ana, ePidCut cut, eParticl
ana->AddCutsAndMonitors(cuts);
}
-FairRunAna* CbmQACoreManager::GetRunAna(TString outFile, TString simFile, TString /*recoFile*/, TString /*parFile*/)
+FairRunAna* HalCbmQACoreManager::GetRunAna(TString outFile, TString simFile, TString /*recoFile*/, TString /*parFile*/)
{
FairRunAna* run = new FairRunAna();
CbmAnaTreeSource* file = new CbmAnaTreeSource(simFile);
@@ -131,4 +131,4 @@ FairRunAna* CbmQACoreManager::GetRunAna(TString outFile, TString simFile, TStrin
return run;
}
-CbmQACoreManager::~CbmQACoreManager() {}
+HalCbmQACoreManager::~HalCbmQACoreManager() {}
diff --git a/analysis/PWGC2F/femtoscopy/hal/qa/CbmQACoreManager.h b/analysis/PWGC2F/femtoscopy/hal/helpers/faircbm/HalCbmQACoreManager.h
similarity index 86%
rename from analysis/PWGC2F/femtoscopy/hal/qa/CbmQACoreManager.h
rename to analysis/PWGC2F/femtoscopy/hal/helpers/faircbm/HalCbmQACoreManager.h
index 801837e805cae5277dc2b8d9901739934a01f3ab..0953413d9200f86e36c75efbc54cf6b569c0cf91 100644
--- a/analysis/PWGC2F/femtoscopy/hal/qa/CbmQACoreManager.h
+++ b/analysis/PWGC2F/femtoscopy/hal/helpers/faircbm/HalCbmQACoreManager.h
@@ -4,8 +4,9 @@
#ifndef CBMROOT_ANALYSIS_PWGC2F_FEMTOSCOPY_NICAFEMTO_HELPERS_CBMQACOREMANAGER_H_
#define CBMROOT_ANALYSIS_PWGC2F_FEMTOSCOPY_NICAFEMTO_HELPERS_CBMQACOREMANAGER_H_
+#include "QAManagerBasic.h"
+
#include <Hal/QAManager.h>
-#include <Hal/QAManagerBasic.h>
namespace Hal
{
@@ -13,9 +14,9 @@ namespace Hal
class TrackAna;
class TwoTrackAna;
} // namespace Hal
-class CbmQACoreManager : public Hal::Fair::QAManagerBasic {
+class HalCbmQACoreManager : public Hal::Fair::QAManagerBasic {
public:
- CbmQACoreManager();
+ HalCbmQACoreManager();
virtual FairRunAna* GetRunAna(TString outFile, TString simFile, TString recoFile, TString parFile = "");
virtual Hal::Event* GetFormat(Hal::QAManager::eFormatType type,
Hal::QAManager::eAnaType ana = Hal::QAManager::eAnaType::kDefault);
@@ -24,8 +25,8 @@ class CbmQACoreManager : public Hal::Fair::QAManagerBasic {
virtual void SetEventCut(Hal::TrackAna* /*ana*/, Int_t /*col*/, TString /*flag = ""*/){};
virtual void SetPairCut(Hal::TwoTrackAna* /*ana*/, Hal::QAManager::ePidCut /*pid1*/,
Hal::QAManager::ePidCut /*pid2*/){};
- virtual ~CbmQACoreManager();
- ClassDef(CbmQACoreManager, 1)
+ virtual ~HalCbmQACoreManager();
+ ClassDef(HalCbmQACoreManager, 1)
};
diff --git a/analysis/PWGC2F/femtoscopy/hal/helpers/HalCbmTaskManager.cxx b/analysis/PWGC2F/femtoscopy/hal/helpers/faircbm/HalCbmTaskManager.cxx
similarity index 96%
rename from analysis/PWGC2F/femtoscopy/hal/helpers/HalCbmTaskManager.cxx
rename to analysis/PWGC2F/femtoscopy/hal/helpers/faircbm/HalCbmTaskManager.cxx
index fd662951d318a504ac98eaa147339cfcab27f74a..4db8632de496476a299cb218484213d1737e334e 100644
--- a/analysis/PWGC2F/femtoscopy/hal/helpers/HalCbmTaskManager.cxx
+++ b/analysis/PWGC2F/femtoscopy/hal/helpers/faircbm/HalCbmTaskManager.cxx
@@ -6,6 +6,7 @@
#include "CbmFieldMap.h"
#include "CbmFieldMapSym3.h"
#include "HalCbmField.h"
+#include "RootManager.h"
#include <FairRunAna.h>
@@ -13,7 +14,6 @@
#include <vector>
#include <Hal/IOManager.h>
-#include <Hal/RootManager.h>
HalCbmTaskManager::HalCbmTaskManager() : fMagField(nullptr) {}
diff --git a/analysis/PWGC2F/femtoscopy/hal/helpers/HalCbmTaskManager.h b/analysis/PWGC2F/femtoscopy/hal/helpers/faircbm/HalCbmTaskManager.h
similarity index 95%
rename from analysis/PWGC2F/femtoscopy/hal/helpers/HalCbmTaskManager.h
rename to analysis/PWGC2F/femtoscopy/hal/helpers/faircbm/HalCbmTaskManager.h
index d68ba0752868ce6e9a059775af9c20f3d22c2307..73116cc268ed0503399e8742729e1490dcbe8ae2 100644
--- a/analysis/PWGC2F/femtoscopy/hal/helpers/HalCbmTaskManager.h
+++ b/analysis/PWGC2F/femtoscopy/hal/helpers/faircbm/HalCbmTaskManager.h
@@ -6,8 +6,7 @@
#include "CbmHelix.h"
#include "FairField.h"
#include "FairTask.h"
-
-#include <Hal/TaskManager.h>
+#include "TaskManager.h"
namespace Hal
{
diff --git a/analysis/PWGC2F/femtoscopy/hal/helpers/HalCbmAnalysisManager.cxx b/analysis/PWGC2F/femtoscopy/hal/helpers/hal/HalCbmAnalysisManager.cxx
similarity index 100%
rename from analysis/PWGC2F/femtoscopy/hal/helpers/HalCbmAnalysisManager.cxx
rename to analysis/PWGC2F/femtoscopy/hal/helpers/hal/HalCbmAnalysisManager.cxx
diff --git a/analysis/PWGC2F/femtoscopy/hal/helpers/HalCbmAnalysisManager.h b/analysis/PWGC2F/femtoscopy/hal/helpers/hal/HalCbmAnalysisManager.h
similarity index 100%
rename from analysis/PWGC2F/femtoscopy/hal/helpers/HalCbmAnalysisManager.h
rename to analysis/PWGC2F/femtoscopy/hal/helpers/hal/HalCbmAnalysisManager.h
diff --git a/analysis/PWGC2F/femtoscopy/hal/helpers/hal/HalCbmSource.cxx b/analysis/PWGC2F/femtoscopy/hal/helpers/hal/HalCbmSource.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..f6dcaa0d6afa34e7a685f8f23ed7e7b547e46022
--- /dev/null
+++ b/analysis/PWGC2F/femtoscopy/hal/helpers/hal/HalCbmSource.cxx
@@ -0,0 +1,62 @@
+/* Copyright (C) 2023-2023 Warsaw University of Technology, Warsaw
+ SPDX-License-Identifier: GPL-3.0-only
+ Authors: Daniel Wielanek [committer] */
+#include "HalCbmSource.h"
+
+#include "CbmAnaTreeContainer.h"
+#include "HalCbmDetectorID.h"
+
+#include <TBranch.h>
+#include <TNamed.h>
+#include <TObjArray.h>
+
+#include <vector>
+
+#include <Hal/Cout.h>
+#include <Hal/InputDataInfo.h>
+#include <Hal/RootIOManager.h>
+
+HalCbmSource::HalCbmSource(TString filename) : Source(filename) { fManager = new HalCbmATIOManager(filename); }
+
+void HalCbmSource::AddFile(TString fileName) { fManager->AddFile(fileName); }
+
+void HalCbmSource::AddFriend(TString friendName, Int_t level) { fManager->AddFriend(friendName, level); }
+
+HalCbmSource::~HalCbmSource() { delete fManager; }
+
+void HalCbmATIOManager::UpdateBranches()
+{
+ if (!fAtBranchesSet) {
+ auto inchain = GetInChain();
+ fContainer = new CbmAnaTreeContainers();
+ fContainer->LoadConf(fDataInfo);
+
+ auto names = CbmAnaTreeContainers::GetNames();
+ for (int i = 0; i < fContainer->GetSize(); i++) {
+ bool con = fContainer->fContainers[i]->ConnectToTree(GetInChain());
+ if (con) {
+ TString name = HalCbm::GetContainerName(names[i]);
+ AddBranch(name, fContainer->fContainers[i], Hal::BranchInfo::EFlag::kInActive);
+ TObject** obj = new TObject*();
+ obj[0] = fContainer->fContainers[i];
+ PushTObject(obj);
+ }
+ }
+ fAtBranchesSet = kTRUE;
+ }
+ Hal::RootIOManager::UpdateBranches();
+}
+
+HalCbmATIOManager::HalCbmATIOManager(std::initializer_list<TString> lists)
+ : Hal::RootIOManager(new Hal::InputRootDataInfo(lists))
+{
+}
+
+HalCbmATIOManager::~HalCbmATIOManager()
+{
+ if (fContainer) delete fContainer;
+}
+
+Bool_t HalCbmSource::Init() { return kTRUE; }
+
+HalCbmSource::HalCbmSource(std::initializer_list<TString> lists) { fManager = new HalCbmATIOManager(lists); }
diff --git a/analysis/PWGC2F/femtoscopy/hal/helpers/anatree/HalCbmSource.h b/analysis/PWGC2F/femtoscopy/hal/helpers/hal/HalCbmSource.h
similarity index 81%
rename from analysis/PWGC2F/femtoscopy/hal/helpers/anatree/HalCbmSource.h
rename to analysis/PWGC2F/femtoscopy/hal/helpers/hal/HalCbmSource.h
index 2746315511b25ada74fc726da02987722ad01cad..df6e83e375e41c1ee67528e93fd003bac4b38278 100644
--- a/analysis/PWGC2F/femtoscopy/hal/helpers/anatree/HalCbmSource.h
+++ b/analysis/PWGC2F/femtoscopy/hal/helpers/hal/HalCbmSource.h
@@ -18,17 +18,17 @@
/**
* ugly work-around for AT that doesn't contain TObject based object
*/
-class CbmAnaTreeRecoSourceContainer;
-class CbmAnaTreeMcSourceContainer;
+class CbmAnaTreeContainers;
class HalCbmATIOManager : public Hal::RootIOManager {
protected:
- virtual void FillBranches();
- CbmAnaTreeRecoSourceContainer* fRecoContainer = {nullptr};
- CbmAnaTreeMcSourceContainer* fSimContainer = {nullptr};
+ CbmAnaTreeContainers* fContainer = {nullptr};
+ Bool_t fAtBranchesSet = {kFALSE};
public:
HalCbmATIOManager(TString name = "") : Hal::RootIOManager(name){};
+ HalCbmATIOManager(std::initializer_list<TString> lists);
+ virtual void UpdateBranches();
virtual ~HalCbmATIOManager();
ClassDef(HalCbmATIOManager, 1)
};
@@ -39,6 +39,8 @@ class HalCbmSource : public Hal::Source {
public:
HalCbmSource(TString filename = "");
+ HalCbmSource(std::initializer_list<TString> lists);
+ Bool_t Init();
virtual void AddFile(TString fileName = "");
virtual void AddFriend(TString friendName = "", Int_t level = 0);
Hal::IOManager* GetIOManager() const { return fManager; };
diff --git a/analysis/PWGC2F/femtoscopy/hal/qa/CMakeLists.txt b/analysis/PWGC2F/femtoscopy/hal/qa/CMakeLists.txt
deleted file mode 100644
index 19c6e6436d097c07dcf307cf9f331ae34a4b6b7e..0000000000000000000000000000000000000000
--- a/analysis/PWGC2F/femtoscopy/hal/qa/CMakeLists.txt
+++ /dev/null
@@ -1,59 +0,0 @@
-# Create a library called "" which includes the source files given in
-# the array .
-# The extension is already found. Any number of sources could be listed here.
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -g")
-Set(INCLUDE_DIRECTORIES
- ${CMAKE_SOURCE_FAIRMCSTACK}
- ${KF_HEADERS}
- ${CBMDATA_DIR}
- ${CBMDATA_DIR}/global
- ${CBMDATA_DIR}/sts
- ${HAL_CBM}/helpers
- ${HAL_CBM}/qa
- ${HAL_CBM_FORMAT}
- ${HAL_CBM_CUTS}
- ${Hal_INCLUDE_DIR}
-)
-Set(SYSTEM_INCLUDE_DIRECTORIES
- ${ROOT_INCLUDE_DIR}
- ${BASE_INCLUDE_DIRECTORIES}
- ${CLHEP_INCLUDE_DIR}
- ${Boost_INCLUDE_DIRS}
-)
-
-Set(LINK_DIRECTORIES
- ${ROOT_LIBRARY_DIR}
- ${FAIRROOT_LIBRARY_DIR}
- ${Boost_LIBRARY_DIRS}
- ${Vc_LIB_DIR}
- ${KFParticle_LIB_DIR}
-)
-
-Include_Directories(${INCLUDE_DIRECTORIES})
-Include_Directories(SYSTEM ${SYSTEM_INCLUDE_DIRECTORIES})
-
-Link_Directories(${LINK_DIRECTORIES})
-
-# List of source files
-set(SRCS
-CbmQACoreManager.cxx
-)
-
-Set(HEADERS )
-Set(LINKDEF HalCbmQALinkDef.h)
-Set(LIBRARY_NAME HalCbmQa)
-Set(PUBLIC_DEPENDENCIES
- HalFeatures
- HalCbmFormat
- HalData
- HalCbmCuts
- FairRoot::Base
- HalCut
- HalAna
- HalQA
- KF
- KFParticle)
-generate_cbm_library()
-
-add_dependencies(G__HalCbmQa ANALYSISTREE HAL)
-
diff --git a/analysis/PWGC2F/femtoscopy/hal/qa/HalCbmQALinkDef.h b/analysis/PWGC2F/femtoscopy/hal/qa/HalCbmQALinkDef.h
deleted file mode 100644
index ae4bfa1e12e15e142d9fb42f12f3212a8b81772b..0000000000000000000000000000000000000000
--- a/analysis/PWGC2F/femtoscopy/hal/qa/HalCbmQALinkDef.h
+++ /dev/null
@@ -1,9 +0,0 @@
-/* Copyright (C) 2023-2023 Warsaw University of Technology, Warsaw
- SPDX-License-Identifier: GPL-3.0-only
- Authors: Daniel Wielanek [committer] */
-#pragma link off all globals;
-#pragma link off all classes;
-#pragma link off all functions;
-
-#pragma link C++ class CbmQACoreManager + ;
-//#pragma link C++ class CbmNicaCompression + ;
diff --git a/cmake/modules/CbmGenerateConfig.cmake b/cmake/modules/CbmGenerateConfig.cmake
index 92716aaacb044eb7b7e5118bb177b853c5239fb6..24a7e6882d134316db077e6f5580eab27860e836 100644
--- a/cmake/modules/CbmGenerateConfig.cmake
+++ b/cmake/modules/CbmGenerateConfig.cmake
@@ -11,6 +11,7 @@ macro(generate_config_files)
"${CMAKE_INSTALL_PREFIX}/include/mvd"
"${CMAKE_INSTALL_PREFIX}/include/littrack"
"${CMAKE_INSTALL_PREFIX}/include/KF"
+ "${CMAKE_INSTALL_PREFIX}/include/Hal"
"${CMAKE_INSTALL_PREFIX}/include/AnalysisTree"
"${CMAKE_INSTALL_PREFIX}/include/AnalysisTreeQA"
)
diff --git a/external/Hal.patch b/external/Hal.patch
deleted file mode 100644
index 09dcb8a2221391e8bd9101ff658ab347ff6dc786..0000000000000000000000000000000000000000
--- a/external/Hal.patch
+++ /dev/null
@@ -1,108 +0,0 @@
-diff --git a/CMakeLists.txt b/CMakeLists.txt
-index 9376018..c87ecb1 100644
---- a/CMakeLists.txt
-+++ b/CMakeLists.txt
-@@ -15,7 +15,18 @@ endif()
- Set(USE_FAIRROOT FALSE)
- Set(USE_EXAMPLES FALSE)
- #check if simpath detected
--if(DEFINED ENV{SIMPATH})
-+
-+if(NOT DEFINED ENV{SIMPATH} AND NOT DEFINED SIMPATH)
-+message (FATAL_ERROR "\
-+You did not define the environment variable SIMPATH or define SIMPATH when calling cmake. \
-+Either of the two is needed to properly find the external packages. \
-+Please either set this environment variable or pass -DSIMPATH=<path> and execute cmake again. \
-+")
-+endif()
-+if (NOT DEFINED SIMPATH)
-+ set(SIMPATH $ENV{SIMPATH})
-+endif()
-+if(DEFINED SIMPATH)
- Set(USE_FAIRROOT TRUE)
- endif()
- #check if fairroot disabled
-diff --git a/cmake/fair/CheckCompiler.cmake b/cmake/fair/CheckCompiler.cmake
-index 2bc05b2..91a6fa2 100644
---- a/cmake/fair/CheckCompiler.cmake
-+++ b/cmake/fair/CheckCompiler.cmake
-@@ -19,7 +19,7 @@ endif (NOT CMAKE_CONFIGURATION_TYPES AND NOT CMAKE_BUILD_TYPE)
- # the compiler and compiler flags used to install fairsoft.
- # Compare compiler and compiler flags used to compile fairsoft with the compiler and flags used now
- # In case of differences print a warning
--Find_Program(FAIRSOFT_CONFIG fairsoft-config PATHS $ENV{SIMPATH}/bin $ENV{FAIRSOFT_ROOT}/bin NO_DEFAULT_PATH)
-+Find_Program(FAIRSOFT_CONFIG fairsoft-config PATHS ${SIMPATH}/bin $ENV{SIMPATH}/bin $ENV{FAIRSOFT_ROOT}/bin NO_DEFAULT_PATH)
-
- If(FAIRSOFT_CONFIG)
- Message(STATUS "fairsoft-config found")
-diff --git a/cmake/modules/CMakeFairRoot.cmake b/cmake/modules/CMakeFairRoot.cmake
-index 1fad98c..19a3290 100644
---- a/cmake/modules/CMakeFairRoot.cmake
-+++ b/cmake/modules/CMakeFairRoot.cmake
-@@ -22,9 +22,12 @@ IF(NOT UNIX)
- ENDIF(NOT UNIX)
-
-
--IF(NOT DEFINED ENV{SIMPATH})
-+if(NOT DEFINED ENV{SIMPATH} AND NOT DEFINED SIMPATH)
- MESSAGE(FATAL_ERROR "You did not define the environment variable SIMPATH which is nedded to find the external packages. Please set this variable and execute cmake again.")
- ENDIF(NOT DEFINED ENV{SIMPATH})
-+if(NOT SIMPATH)
-+ Set(SIMPATH $ENV{SIMPATH})
-+endif()
-
- find_package(ROOT 6.00.00 REQUIRED)
- if("${ROOT_VERSION_MAJOR}.${ROOT_VERSION_MINOR}" VERSION_GREATER 6.16)
-@@ -36,7 +39,6 @@ find_package(ROOT 6.00.00 REQUIRED)
- set(VMCLIB VMCLibrary)
- endif()
- endif()
--Set(SIMPATH $ENV{SIMPATH})
- Set(Boost_NO_SYSTEM_PATHS TRUE)
- Set(Boost_NO_BOOST_CMAKE TRUE)
- Set(BOOST_ROOT ${SIMPATH})
-diff --git a/cmake/modules/HalMacros.cmake b/cmake/modules/HalMacros.cmake
-index c48a4ca..19e60d0 100644
---- a/cmake/modules/HalMacros.cmake
-+++ b/cmake/modules/HalMacros.cmake
-@@ -8,15 +8,20 @@ Macro(SetFairBase)
- SET(FAIRBASE ${FAIRBASE})
- Else (FAIRBASE)
- Message(STATUS "NOT Found FAIRBASE")
-- IF(NOT DEFINED ENV{FAIRROOTPATH})
-+ if(NOT DEFINED ENV{FAIRROOTPATH} AND NOT DEFINED FAIRROOTPATH)
- MESSAGE(FATAL_ERROR "You did not define the environment variable FAIRROOTPATH which is needed to find FairRoot. Please set this variable and execute cmake again.")
- SET(CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/fair" ${CMAKE_MODULE_PATH})
- MESSAGE(WARNING "CMP ${CMAKE_MODULE_PATH}")
-- ENDIF(NOT DEFINED ENV{FAIRROOTPATH})
-- SET(FAIRROOTPATH $ENV{FAIRROOTPATH})
-+ endif()
-+ if(NOT FAIRROOTPATH)
-+ SET(FAIRROOTPATH $ENV{FAIRROOTPATH})
-+ endif()
-+ if(NOT ENV{FAIRROOTPATH})
-+ SET(ENV{FAIRROOTPATH} ${FAIRROOTPATH})
-+ endif()
- EndIf (FAIRBASE)
-- set(CMAKE_MODULE_PATH "$ENV{FAIRROOTPATH}/share/fairbase/cmake/modules_old" ${CMAKE_MODULE_PATH})
-- set(CMAKE_MODULE_PATH "$ENV{FAIRROOTPATH}/share/fairbase/cmake/modules" ${CMAKE_MODULE_PATH})
-+ set(CMAKE_MODULE_PATH "${FAIRROOTPATH}/share/fairbase/cmake/modules_old" ${CMAKE_MODULE_PATH})
-+ set(CMAKE_MODULE_PATH "${FAIRROOTPATH}/share/fairbase/cmake/modules" ${CMAKE_MODULE_PATH})
- IF(FAIRROOTPATH)
- Set(CheckSrcDir "${FAIRROOTPATH}/share/fairbase/cmake/checks")
- ELSE(FAIRROOTPATH)
-diff --git a/fair/CMakeLists.txt b/fair/CMakeLists.txt
-index 266e82e..46246e6 100644
---- a/fair/CMakeLists.txt
-+++ b/fair/CMakeLists.txt
-@@ -8,8 +8,8 @@ ${HAL_CORE}/fair
- Set(SYSTEM_INCLUDE_DIRECTORIES
- ${ROOT_INCLUDE_DIR}
- ${BASE_INCLUDE_DIRECTORIES}
-- $ENV{SIMPATH}/include
-- $ENV{SIMPATH}/include/vmc
-+ ${SIMPATH}/include
-+ ${SIMPATH}/include/vmc
- )
-
- Set(LINK_DIRECTORIES
diff --git a/external/InstallHal.cmake b/external/InstallHal.cmake
index e4cf62ada2b1c6a316ceedd256e3425938a271aa..6ca1a268a31974a50ff6167f616f4ee960e96e9e 100644
--- a/external/InstallHal.cmake
+++ b/external/InstallHal.cmake
@@ -1,17 +1,16 @@
-set(HAL_VERSION 9da3fa0b6511765b83409a1804753e4b46ab81a7)
+set(HAL_VERSION 9fb2e4528db4a8ffa9205a496b1003c388bb6de8)
set(HAL_SRC_URL "https://github.com/DanielWielanek/HAL.git")
set(HAL_DESTDIR "${CMAKE_BINARY_DIR}/external/HAL-prefix")
list(APPEND HAL_LIB_LIST "HalAna" "HalCut" "HalData" "HalFeatures" "HalFemto")
-list(APPEND HAL_LIB_LIST "HalFlow" "HalFluct" "HalSpectra" "HalFair" "HalQA")
+list(APPEND HAL_LIB_LIST "HalFlow" "HalFluct" "HalSpectra" "HalQA")
download_project_if_needed(PROJECT Hal_source
GIT_REPOSITORY ${HAL_SRC_URL}
GIT_TAG ${HAL_VERSION}
SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/Hal
- PATCH_COMMAND "patch -p1 < ${CMAKE_CURRENT_SOURCE_DIR}/Hal.patch"
)
If(ProjectUpdated)
@@ -41,6 +40,7 @@ ExternalProject_Add(HAL
-DCMAKE_INSTALL_PREFIX=${CMAKE_BINARY_DIR}
-DCMAKE_CXX_STANDARD=${CMAKE_CXX_STANDARD}
-DCMAKE_PREFIX_PATH=${CMAKE_PREFIX_PATH}
+ -DINCLUDE_HAL_SUBIDIR=TRUE
-DROOTSYS=${SIMPATH}
-DSIMPATH=${SIMPATH}
-DFAIRROOTPATH=${FAIRROOTPATH}
diff --git a/macro/analysis/cbmfemto/hbt_common.C b/macro/analysis/cbmfemto/hbt_common.C
index 8b1dfd39727790e8ffb5daa421ee7cf4d71f3950..5bd556bfd06e7d0e0a2ef4aec8c71c9ccd7b5c62 100644
--- a/macro/analysis/cbmfemto/hbt_common.C
+++ b/macro/analysis/cbmfemto/hbt_common.C
@@ -94,12 +94,12 @@ Hal::FemtoBasicAna* MakeAna(Bool_t speedUp)
* speed up analysis by using compression and special HBT format
* the sts exit distance and phi* are calculated once per track
*/
- task->SetFormat(new HalCbmFullEvent(), Hal::EFormatDepth::kNonBuffered);
+ // task->SetFormat(new HalCbmFullEvent(), Hal::EFormatDepth::kNonBuffered);
task->SetFormat(new HalCbmHbtFullEvent(), Hal::EFormatDepth::kBuffered);
task->SetFormatOption(Hal::EventAna::EFormatOption::kCompress);
}
else {
- task->SetFormat(new HalCbmFullEvent());
+ //task->SetFormat(new HalCbmFullEvent());
}
SetEventCut(task);
SetTrackCuts(task);
diff --git a/macro/analysis/cbmfemto/hbt_v0.C b/macro/analysis/cbmfemto/hbt_v0.C
new file mode 100644
index 0000000000000000000000000000000000000000..cc9d2e742f138200ebc05bb9e59b3cca3b64bb17
--- /dev/null
+++ b/macro/analysis/cbmfemto/hbt_v0.C
@@ -0,0 +1,83 @@
+/* Copyright (C) 2023-2023 Warsaw University of Technology, Warsaw
+ SPDX-License-Identifier: GPL-3.0-only
+ Authors: Daniel Wielanek [committer] */
+
+#ifndef __CLING__
+#include "CbmAnaTreeSource.h"
+#include "CbmFieldMap.h"
+#include "FairFileSource.h"
+#include "FairParRootFileIo.h"
+#include "FemtoBasicAna.h"
+#include "HalCbmAnalysisManager.h"
+#include "HalCbmReader.h"
+#include "HalCbmSource.h"
+#include "HalCbmV0Builder.h"
+#include "TFile.h"
+#include "data/CbmDefs.h"
+
+#include <FairLogger.h>
+#include <FairRun.h>
+#include <FairRunAna.h>
+
+#include <RtypesCore.h>
+#include <TStopwatch.h>
+#include <TString.h>
+#include <TTimer.h>
+
+#include <cstdio>
+#include <iostream>
+
+#include <Hal/AnalysisManager.h>
+#include <Hal/DataFormat.h>
+#include <Hal/PropertyMonitorX.h>
+#include <Hal/PropertyMonitorXY.h>
+#include <Hal/Source.h>
+
+
+using namespace std;
+#endif
+#include "hbt_common.C"
+
+#define KRONOS
+
+/**
+ * analysis macro done via FairRoot
+ * @param task
+ */
+
+void hbt_v0(TString inFile = "3000.analysistree.root", TString outFile = "test2.root")
+{
+ HalCbmAnalysisManager* manager = new HalCbmAnalysisManager();
+ auto source = new HalCbmSource(inFile);
+ source->AddFriend("v0.root");
+ manager->SetSource(source);
+ manager->SetOutput(outFile);
+
+ HalCbmV0Builder* v0 =
+ new HalCbmV0Builder(Hal::Const::LambdaPID(), Hal::Const::ProtonPID(), -Hal::Const::PionPlusPID());
+
+ manager->AddTask(v0);
+
+ auto reader = new HalCbmReader();
+ manager->AddTask(reader);
+
+ Hal::FemtoBasicAna* task = MakeAna(kTRUE);
+ task->SetPdg(Hal::Const::LambdaPID()); //switch to lambda PID
+
+
+ Hal::TrackFieldMonitorXY armenteros(Hal::DataFieldID::Track::EV0::kAlphaArm, Hal::DataFieldID::Track::EV0::kPtArm);
+ armenteros.SetXaxis(200, -1, 1);
+ armenteros.SetYaxis(200, 0, 1);
+ task->AddCutMonitor(armenteros);
+
+
+ manager->AddTask(task);
+
+ TStopwatch timer;
+ timer.Start();
+
+ manager->Init();
+ manager->Run(0, 1000);
+ Double_t rtime = timer.RealTime(), ctime = timer.CpuTime();
+ printf("RealTime=%f seconds, CpuTime=%f seconds\n", rtime, ctime);
+}
diff --git a/scripts/checklibs.sh b/scripts/checklibs.sh
index 9c95ff650f8aba53ad1c416f58e7273a9a0ddd35..3212e736ef10580ed7ce789884e9d6891f27e5ca 100755
--- a/scripts/checklibs.sh
+++ b/scripts/checklibs.sh
@@ -29,12 +29,15 @@ for lib in $all_libs; do
# So \\\\ becomes \\ which becomes \
# => Seems to still work with mawk (Mike's awk, debian 10) on run2, so ok like this?
rootmap_defs_token="\\\\[ lib"
- # if [[ ${rootmap_file} == *"libHal"* ]]; then
- # # Commented out for now as lead to missing headers detection in 60% of HAL libraries (9/14)
- # rootmap_defs_token="\\\\[ Hal"
- # fi
first_class=$(awk -v token="${rootmap_defs_token}" '$0 ~ token ,0' ${rootmap_file} | grep -m1 "${start_token_class}" | tr -d ';')
+ if [[ "" == ${first_class} && ${rootmap_file} == *"libHal"* ]]; then
+ rootmap_defs_token="\\\\[ Hal"
+ first_class=$(awk -v token="${rootmap_defs_token}" '$0 ~ token ,0' ${rootmap_file} | grep -m1 "${start_token_class}" | tr -d ';')
+ fi
first_class="${first_class##"${start_token_class}"}"
+ if [[ "" == ${first_class} ]]; then
+ echo "WARNING: No 1st class found in rootmap for ${lib} (prob. need tuning of checklibs.sh)"
+ fi
# Printouts commented out to limit spam in test logs
# FIXME: make it a "-v" option
@@ -43,7 +46,6 @@ for lib in $all_libs; do
# echo "Loading the library ${lib}"
fi
-
root -l -q -b "${SCRIPTDIR}/loadlib.C(\"${lib}\", \"${first_class}\")" &> ${tmpfile}
retval=$?
if [[ retval -ne 0 ]]; then