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/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/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);
+}