diff --git a/analysis/PWGDIL/dielectron/conversion/CbmAnaConversion.cxx b/analysis/PWGDIL/dielectron/conversion/CbmAnaConversion.cxx
index ef26af2b848c5d441f25bf29db4707ae9df3fe37..d28fde2603be8bb5249fa686799079c9533ff45a 100644
--- a/analysis/PWGDIL/dielectron/conversion/CbmAnaConversion.cxx
+++ b/analysis/PWGDIL/dielectron/conversion/CbmAnaConversion.cxx
@@ -1285,10 +1285,9 @@ void CbmAnaConversion::AnalyseElectrons(CbmMCTrack* mctrack)
 }
 
 
-CbmLmvmKinematicParams CbmAnaConversion::CalculateKinematicParams(const CbmMCTrack* mctrackP,
-                                                                  const CbmMCTrack* mctrackM)
+LmvmKinePar CbmAnaConversion::CalculateKinematicParams(const CbmMCTrack* mctrackP, const CbmMCTrack* mctrackM)
 {
-  CbmLmvmKinematicParams params;
+  LmvmKinePar params;
 
   TVector3 momP;  //momentum e+
   mctrackP->GetMomentum(momP);
diff --git a/analysis/PWGDIL/dielectron/conversion/CbmAnaConversion.h b/analysis/PWGDIL/dielectron/conversion/CbmAnaConversion.h
index 5772c5faa34b94ee4eaef45ad1868d04640683ad..4708819c8c023d85c0a90f8bb949cb1d71bddc52 100644
--- a/analysis/PWGDIL/dielectron/conversion/CbmAnaConversion.h
+++ b/analysis/PWGDIL/dielectron/conversion/CbmAnaConversion.h
@@ -15,11 +15,12 @@
 #define CBM_ANA_CONVERSION
 
 #include "CbmKFVertex.h"
-#include "CbmLmvmKinematicParams.h"
 #include "CbmMCTrack.h"
 
 #include "FairTask.h"
 
+#include "LmvmKinePar.h"
+
 //#include "KFParticleTopoReconstructor.h"
 #include "CbmAnaConversionKF.h"
 #include "CbmAnaConversionPhotons.h"
@@ -82,7 +83,7 @@ public:
     */
   virtual void Exec(Option_t* option);
 
-  CbmLmvmKinematicParams CalculateKinematicParams(const CbmMCTrack* mctrackP, const CbmMCTrack* mctrackM);
+  LmvmKinePar CalculateKinematicParams(const CbmMCTrack* mctrackP, const CbmMCTrack* mctrackM);
 
   Double_t Invmass_2gammas(const CbmMCTrack* gamma1, const CbmMCTrack* gamma2);
   Double_t Invmass_2particles(const CbmMCTrack* mctrack1, const CbmMCTrack* mctrack2);
diff --git a/analysis/PWGDIL/dielectron/conversion/CbmAnaConversionPhotons.cxx b/analysis/PWGDIL/dielectron/conversion/CbmAnaConversionPhotons.cxx
index 6fd81a63970a9d31fdd428b3578a367e4c21a715..986ead09b688f4bdc92aeb8948f146fa8c18a04b 100644
--- a/analysis/PWGDIL/dielectron/conversion/CbmAnaConversionPhotons.cxx
+++ b/analysis/PWGDIL/dielectron/conversion/CbmAnaConversionPhotons.cxx
@@ -1033,10 +1033,9 @@ int CbmAnaConversionPhotons::CheckMC(CbmMCTrack* mctrack)
 }
 
 
-CbmLmvmKinematicParams CbmAnaConversionPhotons::CalculateKinematicParams(const CbmMCTrack* mctrackP,
-                                                                         const CbmMCTrack* mctrackM)
+LmvmKinePar CbmAnaConversionPhotons::CalculateKinematicParams(const CbmMCTrack* mctrackP, const CbmMCTrack* mctrackM)
 {
-  CbmLmvmKinematicParams params;
+  LmvmKinePar params;
 
   TVector3 momP;  //momentum e+
   mctrackP->GetMomentum(momP);
@@ -1067,10 +1066,9 @@ CbmLmvmKinematicParams CbmAnaConversionPhotons::CalculateKinematicParams(const C
 }
 
 
-CbmLmvmKinematicParams CbmAnaConversionPhotons::CalculateKinematicParamsReco(const TVector3 electron1,
-                                                                             const TVector3 electron2)
+LmvmKinePar CbmAnaConversionPhotons::CalculateKinematicParamsReco(const TVector3 electron1, const TVector3 electron2)
 {
-  CbmLmvmKinematicParams params;
+  LmvmKinePar params;
 
   Double_t energyP = TMath::Sqrt(electron1.Mag2() + M2E);
   TLorentzVector lorVecP(electron1, energyP);
@@ -1109,7 +1107,7 @@ void CbmAnaConversionPhotons::AnalyseElectronsFromGammaMC()
       int motherID_i = fMCTracklist_allElectronsFromGamma[i]->GetMotherId();
       int motherID_j = fMCTracklist_allElectronsFromGamma[j]->GetMotherId();
 
-      CbmLmvmKinematicParams paramSet =
+      LmvmKinePar paramSet =
         CalculateKinematicParams(fMCTracklist_allElectronsFromGamma[i], fMCTracklist_allElectronsFromGamma[j]);
 
       CbmMCTrack* mothermctrack_i = (CbmMCTrack*) fMcTracks->At(motherID_i);
@@ -1214,9 +1212,9 @@ void CbmAnaConversionPhotons::AnalyseElectronsFromGammaReco()
         continue;  // only 1 electron and 1 positron allowed
 
 
-      CbmLmvmKinematicParams paramSet = CalculateKinematicParamsReco(fRecoTracklist_allElectronsFromGammaMom[i],
-                                                                     fRecoTracklist_allElectronsFromGammaMom[j]);
-      Double_t OpeningAngleCut        = CbmAnaConversionCutSettings::CalcOpeningAngleCut(paramSet.fPt);
+      LmvmKinePar paramSet     = CalculateKinematicParamsReco(fRecoTracklist_allElectronsFromGammaMom[i],
+                                                          fRecoTracklist_allElectronsFromGammaMom[j]);
+      Double_t OpeningAngleCut = CbmAnaConversionCutSettings::CalcOpeningAngleCut(paramSet.fPt);
 
 
       fhEFG_angle_all_reco->Fill(
@@ -1345,8 +1343,8 @@ void CbmAnaConversionPhotons::AnalyseElectronsFromPi0Reco()
         continue;  // only 1 electron and 1 positron allowed
 
 
-      CbmLmvmKinematicParams paramSet = CalculateKinematicParamsReco(fRecoTracklist_allElectronsFromPi0Mom[i],
-                                                                     fRecoTracklist_allElectronsFromPi0Mom[j]);
+      LmvmKinePar paramSet = CalculateKinematicParamsReco(fRecoTracklist_allElectronsFromPi0Mom[i],
+                                                          fRecoTracklist_allElectronsFromPi0Mom[j]);
 
       int motherID_i = fRecoTracklist_allElectronsFromPi0[i]->GetMotherId();
       int motherID_j = fRecoTracklist_allElectronsFromPi0[j]->GetMotherId();
diff --git a/analysis/PWGDIL/dielectron/conversion/CbmAnaConversionPhotons.h b/analysis/PWGDIL/dielectron/conversion/CbmAnaConversionPhotons.h
index 57dcaba3ea163a5ed4e8d14491e3d4de7d42f356..a2e097b322050f467e6ff99e447a5aa4625d17d2 100644
--- a/analysis/PWGDIL/dielectron/conversion/CbmAnaConversionPhotons.h
+++ b/analysis/PWGDIL/dielectron/conversion/CbmAnaConversionPhotons.h
@@ -22,12 +22,13 @@
 
 // included from CbmRoot
 #include "CbmKFVertex.h"
-#include "CbmLmvmKinematicParams.h"
 #include "CbmMCTrack.h"
 #include "CbmVertex.h"
 
 #include <vector>
 
+#include "LmvmKinePar.h"
+
 /*
 class CbmAnaConversionKinematicParams
 {
@@ -62,8 +63,8 @@ public:
   int CheckMC(CbmMCTrack* mctrack);
 
   //CbmAnaConversionKinematicParams CalculateKinematicParams(const CbmMCTrack* mctrackP, const CbmMCTrack* mctrackM);
-  CbmLmvmKinematicParams CalculateKinematicParams(const CbmMCTrack* mctrackP, const CbmMCTrack* mctrackM);
-  CbmLmvmKinematicParams CalculateKinematicParamsReco(const TVector3 electron1, const TVector3 electron2);
+  LmvmKinePar CalculateKinematicParams(const CbmMCTrack* mctrackP, const CbmMCTrack* mctrackM);
+  LmvmKinePar CalculateKinematicParamsReco(const TVector3 electron1, const TVector3 electron2);
 
 
   void AnalyseElectronsFromGammaMC();
diff --git a/analysis/PWGDIL/dielectron/conversion/CbmAnaConversionReco.cxx b/analysis/PWGDIL/dielectron/conversion/CbmAnaConversionReco.cxx
index 75e3d99a786d4e008ef08f8af005396acf282174..b2ee059567beb711cd43e76a041c24be7d8ef8bd 100644
--- a/analysis/PWGDIL/dielectron/conversion/CbmAnaConversionReco.cxx
+++ b/analysis/PWGDIL/dielectron/conversion/CbmAnaConversionReco.cxx
@@ -1234,7 +1234,7 @@ void CbmAnaConversionReco::InvariantMassTest_4epem()
                 fhEPEM_pt_vs_p_all_refitted->Fill(fRecoRefittedMomentum[k].Perp(), fRecoRefittedMomentum[k].Mag());
                 fhEPEM_pt_vs_p_all_refitted->Fill(fRecoRefittedMomentum[l].Perp(), fRecoRefittedMomentum[l].Mag());
 
-                CbmLmvmKinematicParams params1 =
+                LmvmKinePar params1 =
                   CalculateKinematicParams_4particles(fRecoRefittedMomentum[i], fRecoRefittedMomentum[j],
                                                       fRecoRefittedMomentum[k], fRecoRefittedMomentum[l]);
                 fhPi0_pt_vs_rap_gee->Fill(params1.fPt, params1.fRapidity);
@@ -1328,7 +1328,7 @@ void CbmAnaConversionReco::InvariantMassTest_4epem()
                 fhEPEM_pt_vs_p_all_refitted->Fill(fRecoRefittedMomentum[k].Perp(), fRecoRefittedMomentum[k].Mag());
                 fhEPEM_pt_vs_p_all_refitted->Fill(fRecoRefittedMomentum[l].Perp(), fRecoRefittedMomentum[l].Mag());
 
-                CbmLmvmKinematicParams params1 =
+                LmvmKinePar params1 =
                   CalculateKinematicParams_4particles(fRecoRefittedMomentum[i], fRecoRefittedMomentum[j],
                                                       fRecoRefittedMomentum[k], fRecoRefittedMomentum[l]);
                 fhPi0_pt_vs_rap_gee->Fill(params1.fPt, params1.fRapidity);
@@ -1422,7 +1422,7 @@ void CbmAnaConversionReco::InvariantMassTest_4epem()
                 fhEPEM_pt_vs_p_all_refitted->Fill(fRecoRefittedMomentum[k].Perp(), fRecoRefittedMomentum[k].Mag());
                 fhEPEM_pt_vs_p_all_refitted->Fill(fRecoRefittedMomentum[l].Perp(), fRecoRefittedMomentum[l].Mag());
 
-                CbmLmvmKinematicParams params1 =
+                LmvmKinePar params1 =
                   CalculateKinematicParams_4particles(fRecoRefittedMomentum[i], fRecoRefittedMomentum[j],
                                                       fRecoRefittedMomentum[k], fRecoRefittedMomentum[l]);
                 fhPi0_pt_vs_rap_gee->Fill(params1.fPt, params1.fRapidity);
@@ -1744,7 +1744,7 @@ void CbmAnaConversionReco::InvariantMassTest_4epem()
               fhEPEM_openingAngle_betweenGammas_reco->Fill(openingAngleBetweenGammasReco);
 
 
-              CbmLmvmKinematicParams params1 = CalculateKinematicParams_4particles(
+              LmvmKinePar params1 = CalculateKinematicParams_4particles(
                 fRecoRefittedMomentum[i], fRecoRefittedMomentum[j], fRecoRefittedMomentum[k], fRecoRefittedMomentum[l]);
               fhPi0_pt_vs_rap_gg->Fill(params1.fPt, params1.fRapidity);
               fhPi0_pt_vs_rap_all->Fill(params1.fPt, params1.fRapidity);
@@ -1798,8 +1798,8 @@ void CbmAnaConversionReco::InvariantMassTest_4epem()
               Bool_t IsRichElectron3MC = (TMath::Abs(fRecoTracklistEPEM[k]->GetPdgCode()) == 11);
               Bool_t IsRichElectron4MC = (TMath::Abs(fRecoTracklistEPEM[l]->GetPdgCode()) == 11);
 
-              CbmLmvmKinematicParams paramsCut1;
-              CbmLmvmKinematicParams paramsCut2;
+              LmvmKinePar paramsCut1;
+              LmvmKinePar paramsCut2;
 
               if (motherId1 == motherId2) {
                 paramsCut1 = CalculateKinematicParamsReco(fRecoRefittedMomentum[i], fRecoRefittedMomentum[j]);
@@ -1941,8 +1941,8 @@ void CbmAnaConversionReco::CutEfficiencyStudies(int e1, int e2, int e3, int e4,
   Double_t ANNvalueE3 = ElectronANNvalue(fRecoTracklistEPEM_gtid[e3], fRecoRefittedMomentum[e3].Mag());
   Double_t ANNvalueE4 = ElectronANNvalue(fRecoTracklistEPEM_gtid[e4], fRecoRefittedMomentum[e4].Mag());
 
-  CbmLmvmKinematicParams paramsCut1;
-  CbmLmvmKinematicParams paramsCut2;
+  LmvmKinePar paramsCut1;
+  LmvmKinePar paramsCut2;
 
   if (motherE1 == motherE2) {
     paramsCut1 = CalculateKinematicParamsReco(fRecoRefittedMomentum[e1], fRecoRefittedMomentum[e2]);
@@ -2330,18 +2330,12 @@ void CbmAnaConversionReco::CalculateInvMassWithFullRecoCuts()
             //fhElectrons_invmass->Fill(invmass);
 
 
-            CbmLmvmKinematicParams params1 =
-              CalculateKinematicParamsReco(fRecoRefittedMomentum[a], fRecoRefittedMomentum[b]);
-            CbmLmvmKinematicParams params2 =
-              CalculateKinematicParamsReco(fRecoRefittedMomentum[a], fRecoRefittedMomentum[c]);
-            CbmLmvmKinematicParams params3 =
-              CalculateKinematicParamsReco(fRecoRefittedMomentum[a], fRecoRefittedMomentum[d]);
-            CbmLmvmKinematicParams params4 =
-              CalculateKinematicParamsReco(fRecoRefittedMomentum[b], fRecoRefittedMomentum[c]);
-            CbmLmvmKinematicParams params5 =
-              CalculateKinematicParamsReco(fRecoRefittedMomentum[b], fRecoRefittedMomentum[d]);
-            CbmLmvmKinematicParams params6 =
-              CalculateKinematicParamsReco(fRecoRefittedMomentum[c], fRecoRefittedMomentum[d]);
+            LmvmKinePar params1 = CalculateKinematicParamsReco(fRecoRefittedMomentum[a], fRecoRefittedMomentum[b]);
+            LmvmKinePar params2 = CalculateKinematicParamsReco(fRecoRefittedMomentum[a], fRecoRefittedMomentum[c]);
+            LmvmKinePar params3 = CalculateKinematicParamsReco(fRecoRefittedMomentum[a], fRecoRefittedMomentum[d]);
+            LmvmKinePar params4 = CalculateKinematicParamsReco(fRecoRefittedMomentum[b], fRecoRefittedMomentum[c]);
+            LmvmKinePar params5 = CalculateKinematicParamsReco(fRecoRefittedMomentum[b], fRecoRefittedMomentum[d]);
+            LmvmKinePar params6 = CalculateKinematicParamsReco(fRecoRefittedMomentum[c], fRecoRefittedMomentum[d]);
 
             Double_t openingAngleCut     = 1;
             Int_t IsPhoton_openingAngle1 = (params1.fAngle < openingAngleCut);
@@ -2379,10 +2373,9 @@ void CbmAnaConversionReco::CalculateInvMassWithFullRecoCuts()
 }
 
 
-CbmLmvmKinematicParams CbmAnaConversionReco::CalculateKinematicParamsReco(const TVector3 electron1,
-                                                                          const TVector3 electron2)
+LmvmKinePar CbmAnaConversionReco::CalculateKinematicParamsReco(const TVector3 electron1, const TVector3 electron2)
 {
-  CbmLmvmKinematicParams params;
+  LmvmKinePar params;
 
   Double_t energyP = TMath::Sqrt(electron1.Mag2() + M2E);
   TLorentzVector lorVecP(electron1, energyP);
@@ -2408,12 +2401,10 @@ CbmLmvmKinematicParams CbmAnaConversionReco::CalculateKinematicParamsReco(const
 }
 
 
-CbmLmvmKinematicParams CbmAnaConversionReco::CalculateKinematicParams_4particles(const TVector3 part1,
-                                                                                 const TVector3 part2,
-                                                                                 const TVector3 part3,
-                                                                                 const TVector3 part4)
+LmvmKinePar CbmAnaConversionReco::CalculateKinematicParams_4particles(const TVector3 part1, const TVector3 part2,
+                                                                      const TVector3 part3, const TVector3 part4)
 {
-  CbmLmvmKinematicParams params;
+  LmvmKinePar params;
 
   Double_t energy1 = TMath::Sqrt(part1.Mag2() + M2E);
   TLorentzVector lorVec1(part1, energy1);
diff --git a/analysis/PWGDIL/dielectron/conversion/CbmAnaConversionReco.h b/analysis/PWGDIL/dielectron/conversion/CbmAnaConversionReco.h
index c631e361b0626450ff41f25fa041d03bdc3ea62f..52d67395e8fdac9d24e9a95d914c6b04bd8627b3 100644
--- a/analysis/PWGDIL/dielectron/conversion/CbmAnaConversionReco.h
+++ b/analysis/PWGDIL/dielectron/conversion/CbmAnaConversionReco.h
@@ -22,13 +22,14 @@
 
 // included from CbmRoot
 #include "CbmLitGlobalElectronId.h"
-#include "CbmLmvmKinematicParams.h"
 #include "CbmMCTrack.h"
 #include "CbmRichElectronIdAnn.h"
 #include "CbmVertex.h"
 
 #include <vector>
 
+#include "LmvmKinePar.h"
+
 class CbmAnaConversionReco {
 
 public:
@@ -61,9 +62,9 @@ public:
                                                   TVector3 electron4);
 
   void CalculateInvMassWithFullRecoCuts();
-  CbmLmvmKinematicParams CalculateKinematicParamsReco(const TVector3 electron1, const TVector3 electron2);
-  CbmLmvmKinematicParams CalculateKinematicParams_4particles(const TVector3 part1, const TVector3 part2,
-                                                             const TVector3 part3, const TVector3 part4);
+  LmvmKinePar CalculateKinematicParamsReco(const TVector3 electron1, const TVector3 electron2);
+  LmvmKinePar CalculateKinematicParams_4particles(const TVector3 part1, const TVector3 part2, const TVector3 part3,
+                                                  const TVector3 part4);
 
   Bool_t IsRichElectronANN(Int_t globalTrackIndex, Double_t momentum);
   Double_t ElectronANNvalue(Int_t globalTrackIndex, Double_t momentum);
diff --git a/analysis/PWGDIL/dielectron/conversion/CbmAnaConversionRecoFull.cxx b/analysis/PWGDIL/dielectron/conversion/CbmAnaConversionRecoFull.cxx
index 08b3961caba3459da6986393ca52f9b7f4fac645..dd8b1691df85f8ab5c3b079ca3e34f1d75ebd669 100644
--- a/analysis/PWGDIL/dielectron/conversion/CbmAnaConversionRecoFull.cxx
+++ b/analysis/PWGDIL/dielectron/conversion/CbmAnaConversionRecoFull.cxx
@@ -1386,7 +1386,7 @@ void CbmAnaConversionRecoFull::CombineElectrons(vector<CbmGlobalTrack*> gtrack,
         if (test != 1) continue;  // need one electron and one positron
         //if(fElectrons_momentaChi[a] > 10 || fElectrons_momentaChi[b] > 10) continue;
 
-        CbmLmvmKinematicParams params1 = CalculateKinematicParamsReco(momenta[a], momenta[b]);
+        LmvmKinePar params1 = CalculateKinematicParamsReco(momenta[a], momenta[b]);
 
         CbmAnaConversionKinematicParams paramsTest =
           CbmAnaConversionKinematicParams::KinematicParams_2particles_Reco(momenta[a], momenta[b]);
@@ -1591,10 +1591,9 @@ Double_t CbmAnaConversionRecoFull::Rap_4particlesRECO(const TVector3 part1, cons
 }
 
 
-CbmLmvmKinematicParams CbmAnaConversionRecoFull::CalculateKinematicParamsReco(const TVector3 electron1,
-                                                                              const TVector3 electron2)
+LmvmKinePar CbmAnaConversionRecoFull::CalculateKinematicParamsReco(const TVector3 electron1, const TVector3 electron2)
 {
-  CbmLmvmKinematicParams params;
+  LmvmKinePar params;
 
   Double_t energyP = TMath::Sqrt(electron1.Mag2() + M2E);
   TLorentzVector lorVecP(electron1, energyP);
@@ -1620,12 +1619,10 @@ CbmLmvmKinematicParams CbmAnaConversionRecoFull::CalculateKinematicParamsReco(co
 }
 
 
-CbmLmvmKinematicParams CbmAnaConversionRecoFull::CalculateKinematicParams_4particles(const TVector3 part1,
-                                                                                     const TVector3 part2,
-                                                                                     const TVector3 part3,
-                                                                                     const TVector3 part4)
+LmvmKinePar CbmAnaConversionRecoFull::CalculateKinematicParams_4particles(const TVector3 part1, const TVector3 part2,
+                                                                          const TVector3 part3, const TVector3 part4)
 {
-  CbmLmvmKinematicParams params;
+  LmvmKinePar params;
 
   Double_t energy1 = TMath::Sqrt(part1.Mag2() + M2E);
   TLorentzVector lorVec1(part1, energy1);
@@ -1737,8 +1734,8 @@ void CbmAnaConversionRecoFull::CombinePhotons(vector<CbmGlobalTrack*> gtrack, ve
         if (index == 1) fhPhotons_angleBetween->Fill(opening_angle);
 
 
-        CbmLmvmKinematicParams params1 = CalculateKinematicParams_4particles(momenta[electron11], momenta[electron12],
-                                                                             momenta[electron21], momenta[electron22]);
+        LmvmKinePar params1 = CalculateKinematicParams_4particles(momenta[electron11], momenta[electron12],
+                                                                  momenta[electron21], momenta[electron22]);
 
         CbmAnaConversionKinematicParams paramsTest = CbmAnaConversionKinematicParams::KinematicParams_4particles_Reco(
           momenta[electron11], momenta[electron12], momenta[electron21], momenta[electron22]);
@@ -2252,7 +2249,7 @@ void CbmAnaConversionRecoFull::CombineElectronsRefit()
 				if(test != 1) continue;		// need one electron and one positron
 				//if(fElectrons_momentaChi[a] > 10 || fElectrons_momentaChi[b] > 10) continue;
 				
-				CbmLmvmKinematicParams params1 = CalculateKinematicParamsReco(fElectrons_momenta_refit[a], fElectrons_momenta_refit[b]);
+				LmvmKinePar params1 = CalculateKinematicParamsReco(fElectrons_momenta_refit[a], fElectrons_momenta_refit[b]);
 				
 				Double_t openingAngleCut = 1;
 				Double_t invMassCut = 0.03;
@@ -2387,12 +2384,12 @@ void CbmAnaConversionRecoFull::CombineElectrons()
 						fhElectrons_invmass->Fill(invmass);
 						
 						
-						CbmLmvmKinematicParams params1 = CalculateKinematicParamsReco(fElectrons_momenta[a], fElectrons_momenta[b]);
-						CbmLmvmKinematicParams params2 = CalculateKinematicParamsReco(fElectrons_momenta[a], fElectrons_momenta[c]);
-						CbmLmvmKinematicParams params3 = CalculateKinematicParamsReco(fElectrons_momenta[a], fElectrons_momenta[d]);
-						CbmLmvmKinematicParams params4 = CalculateKinematicParamsReco(fElectrons_momenta[b], fElectrons_momenta[c]);
-						CbmLmvmKinematicParams params5 = CalculateKinematicParamsReco(fElectrons_momenta[b], fElectrons_momenta[d]);
-						CbmLmvmKinematicParams params6 = CalculateKinematicParamsReco(fElectrons_momenta[c], fElectrons_momenta[d]);
+						LmvmKinePar params1 = CalculateKinematicParamsReco(fElectrons_momenta[a], fElectrons_momenta[b]);
+						LmvmKinePar params2 = CalculateKinematicParamsReco(fElectrons_momenta[a], fElectrons_momenta[c]);
+						LmvmKinePar params3 = CalculateKinematicParamsReco(fElectrons_momenta[a], fElectrons_momenta[d]);
+						LmvmKinePar params4 = CalculateKinematicParamsReco(fElectrons_momenta[b], fElectrons_momenta[c]);
+						LmvmKinePar params5 = CalculateKinematicParamsReco(fElectrons_momenta[b], fElectrons_momenta[d]);
+						LmvmKinePar params6 = CalculateKinematicParamsReco(fElectrons_momenta[c], fElectrons_momenta[d]);
 						
 						Double_t openingAngleCut = 1;
 						Int_t IsPhoton_openingAngle1 = (params1.fAngle < openingAngleCut);
@@ -2443,7 +2440,7 @@ void CbmAnaConversionRecoFull::CombineElectrons()
         if (test != 1) continue;  // need one electron and one positron
         //if(fElectrons_momentaChi[a] > 10 || fElectrons_momentaChi[b] > 10) continue;
 
-        CbmLmvmKinematicParams params1 = CalculateKinematicParamsReco(fElectrons_momenta[a], fElectrons_momenta[b]);
+        LmvmKinePar params1 = CalculateKinematicParamsReco(fElectrons_momenta[a], fElectrons_momenta[b]);
 
         // standard fixed opening angle cut
         //Double_t openingAngleCut = 1;
@@ -2551,7 +2548,7 @@ void CbmAnaConversionRecoFull::CombinePhotons()
         fhPhotons_angleBetween->Fill(opening_angle);
 
 
-        CbmLmvmKinematicParams params1 =
+        LmvmKinePar params1 =
           CalculateKinematicParams_4particles(fElectrons_momenta[electron11], fElectrons_momenta[electron12],
                                               fElectrons_momenta[electron21], fElectrons_momenta[electron22]);
 
diff --git a/analysis/PWGDIL/dielectron/conversion/CbmAnaConversionRecoFull.h b/analysis/PWGDIL/dielectron/conversion/CbmAnaConversionRecoFull.h
index 6c07f98646b3d9e5d5e8769480cfad287418e268..19a676a608a16a819beb624bfa99846464ed8a2b 100644
--- a/analysis/PWGDIL/dielectron/conversion/CbmAnaConversionRecoFull.h
+++ b/analysis/PWGDIL/dielectron/conversion/CbmAnaConversionRecoFull.h
@@ -24,12 +24,13 @@
 // included from CbmRoot
 #include "CbmKFVertex.h"
 #include "CbmLitGlobalElectronId.h"
-#include "CbmLmvmKinematicParams.h"
 #include "CbmMCTrack.h"
 #include "CbmVertex.h"
 
 #include <vector>
 
+#include "LmvmKinePar.h"
+
 class CbmAnaConversionRecoFull {
 
 public:
@@ -49,9 +50,9 @@ public:
   Double_t Pt_4particlesRECO(const TVector3 part1, const TVector3 part2, const TVector3 part3, const TVector3 part4);
   Double_t Rap_4particlesRECO(const TVector3 part1, const TVector3 part2, const TVector3 part3, const TVector3 part4);
 
-  CbmLmvmKinematicParams CalculateKinematicParamsReco(const TVector3 electron1, const TVector3 electron2);
-  CbmLmvmKinematicParams CalculateKinematicParams_4particles(const TVector3 part1, const TVector3 part2,
-                                                             const TVector3 part3, const TVector3 part4);
+  LmvmKinePar CalculateKinematicParamsReco(const TVector3 electron1, const TVector3 electron2);
+  LmvmKinePar CalculateKinematicParams_4particles(const TVector3 part1, const TVector3 part2, const TVector3 part3,
+                                                  const TVector3 part4);
 
   void CombinePhotons(std::vector<CbmGlobalTrack*> gtrack, std::vector<TVector3> momenta, std::vector<float> momentaChi,
                       std::vector<int> mctrackID, std::vector<std::vector<int>> reconstructedPhotons, Int_t index);
diff --git a/analysis/PWGDIL/dielectron/conversion/CbmAnaConversionTest.cxx b/analysis/PWGDIL/dielectron/conversion/CbmAnaConversionTest.cxx
index 582f0ba3c1ccbaeaf997204dffb2f44b738f9026..df994c5d422f9b42df9bc0f448ac64e0b394c149 100644
--- a/analysis/PWGDIL/dielectron/conversion/CbmAnaConversionTest.cxx
+++ b/analysis/PWGDIL/dielectron/conversion/CbmAnaConversionTest.cxx
@@ -638,7 +638,7 @@ void CbmAnaConversionTest::CombineElectrons_FromSTSandRICH()
         if (fVector_gtIndex[a] == fVector_electronRICH_gtIndex[b]) continue;
         if (fVector_richIndex[a] >= 0) continue;  // 4th lepton should have no signal in RICH, only in STS
 
-        //CbmLmvmKinematicParams params1 = CalculateKinematicParamsReco(fVector_momenta[a], fVector_electronRICH_momenta[b]);
+        //LmvmKinePar params1 = CalculateKinematicParamsReco(fVector_momenta[a], fVector_electronRICH_momenta[b]);
         CbmAnaConversionKinematicParams paramsTest = CbmAnaConversionKinematicParams::KinematicParams_2particles_Reco(
           fVector_momenta[a], fVector_electronRICH_momenta[b]);
 
@@ -698,7 +698,7 @@ void CbmAnaConversionTest::CombineElectrons_FromRICH()
         if (test != 1) continue;  // need one electron and one positron
         if (fVector_electronRICH_gtIndex[a] == fVector_electronRICH_gtIndex[b]) continue;
 
-        //CbmLmvmKinematicParams params1 = CalculateKinematicParamsReco(fVector_electronRICH_momenta[a], fVector_electronRICH_momenta[b]);
+        //LmvmKinePar params1 = CalculateKinematicParamsReco(fVector_electronRICH_momenta[a], fVector_electronRICH_momenta[b]);
         CbmAnaConversionKinematicParams paramsTest = CbmAnaConversionKinematicParams::KinematicParams_2particles_Reco(
           fVector_electronRICH_momenta[a], fVector_electronRICH_momenta[b]);
 
@@ -792,7 +792,7 @@ void CbmAnaConversionTest::CombinePhotons()
         //Double_t opening_angle = OpeningAngleBetweenPhotons(momenta, reconstructedPhotons[a], reconstructedPhotons[b]);
 
 
-        //CbmLmvmKinematicParams params1 = CalculateKinematicParams_4particles(momenta[electron11], momenta[electron12], momenta[electron21], momenta[electron22]);
+        //LmvmKinePar params1 = CalculateKinematicParams_4particles(momenta[electron11], momenta[electron12], momenta[electron21], momenta[electron22]);
 
 
         Double_t ANNe11 = ElectronANNvalue(gtIndex11, fVector_momenta[electron11].Mag());
@@ -972,10 +972,9 @@ void CbmAnaConversionTest::CombinePhotons()
 }
 
 
-CbmLmvmKinematicParams CbmAnaConversionTest::CalculateKinematicParamsReco(const TVector3 electron1,
-                                                                          const TVector3 electron2)
+LmvmKinePar CbmAnaConversionTest::CalculateKinematicParamsReco(const TVector3 electron1, const TVector3 electron2)
 {
-  CbmLmvmKinematicParams params;
+  LmvmKinePar params;
 
   Double_t energyP = TMath::Sqrt(electron1.Mag2() + M2E);
   TLorentzVector lorVecP(electron1, energyP);
@@ -1039,7 +1038,7 @@ void CbmAnaConversionTest::CombineElectrons_STSonly()
         if (test != 1) continue;  // need one electron and one positron
         if (fVector_gtIndex[a] == fVector_gtIndex[b]) continue;
 
-        //CbmLmvmKinematicParams params1 = CalculateKinematicParamsReco(fVector_electronRICH_momenta[a], fVector_electronRICH_momenta[b]);
+        //LmvmKinePar params1 = CalculateKinematicParamsReco(fVector_electronRICH_momenta[a], fVector_electronRICH_momenta[b]);
         CbmAnaConversionKinematicParams paramsTest =
           CbmAnaConversionKinematicParams::KinematicParams_2particles_Reco(fVector_momenta[a], fVector_momenta[b]);
 
diff --git a/analysis/PWGDIL/dielectron/conversion/CbmAnaConversionTest.h b/analysis/PWGDIL/dielectron/conversion/CbmAnaConversionTest.h
index f6793474c162ac780ddf774d5d3cde9f02187457..2054b9b464e614c8766f28ff3d80f39818f1aa8d 100644
--- a/analysis/PWGDIL/dielectron/conversion/CbmAnaConversionTest.h
+++ b/analysis/PWGDIL/dielectron/conversion/CbmAnaConversionTest.h
@@ -24,12 +24,13 @@
 #include "CbmGlobalTrack.h"
 #include "CbmKFVertex.h"
 #include "CbmLitGlobalElectronId.h"
-#include "CbmLmvmKinematicParams.h"
 #include "CbmMCTrack.h"
 #include "CbmVertex.h"
 
 #include <vector>
 
+#include "LmvmKinePar.h"
+
 class CbmAnaConversionTest {
 
 public:
@@ -49,7 +50,7 @@ public:
   void CombineElectrons_FromSTSandRICH();
   void CombinePhotons();
   void CombineElectrons_FromRICH();
-  CbmLmvmKinematicParams CalculateKinematicParamsReco(const TVector3 electron1, const TVector3 electron2);
+  LmvmKinePar CalculateKinematicParamsReco(const TVector3 electron1, const TVector3 electron2);
   Double_t Invmass_4particlesRECO(const TVector3 part1, const TVector3 part2, const TVector3 part3,
                                   const TVector3 part4);
 
diff --git a/analysis/PWGDIL/dielectron/conversion/CbmAnaConversionTest2.h b/analysis/PWGDIL/dielectron/conversion/CbmAnaConversionTest2.h
index 12e452739510f09a052caa128e4d2bbdad1b1412..d0afa241151aa0e0a22bbdf339db0cd8d1bb8c2c 100644
--- a/analysis/PWGDIL/dielectron/conversion/CbmAnaConversionTest2.h
+++ b/analysis/PWGDIL/dielectron/conversion/CbmAnaConversionTest2.h
@@ -24,12 +24,13 @@
 #include "CbmGlobalTrack.h"
 #include "CbmKFVertex.h"
 #include "CbmLitGlobalElectronId.h"
-#include "CbmLmvmKinematicParams.h"
 #include "CbmMCTrack.h"
 #include "CbmVertex.h"
 
 #include <vector>
 
+#include "LmvmKinePar.h"
+
 class CbmAnaConversionTest2 {
 
 public:
diff --git a/analysis/PWGDIL/dielectron/lmvm/CbmLmvmKinematicParams.h b/analysis/PWGDIL/dielectron/lmvm/LmvmKinePar.h
similarity index 88%
rename from analysis/PWGDIL/dielectron/lmvm/CbmLmvmKinematicParams.h
rename to analysis/PWGDIL/dielectron/lmvm/LmvmKinePar.h
index 8a4e10076f96e46efebda0b6b830d782d1b020e5..64968b1402c35a9fcc07ba8583d4c81fa88f8b2f 100644
--- a/analysis/PWGDIL/dielectron/lmvm/CbmLmvmKinematicParams.h
+++ b/analysis/PWGDIL/dielectron/lmvm/LmvmKinePar.h
@@ -2,8 +2,8 @@
    SPDX-License-Identifier: GPL-3.0-only
    Authors: Elena Lebedeva [committer], Semen Lebedev */
 
-#ifndef CBM_LMVM_KINE_PARAMS_H
-#define CBM_LMVM_KINE_PARAMS_H
+#ifndef LMVM_KINE_PAR_H
+#define LMVM_KINE_PAR_H
 
 #include "CbmMCTrack.h"
 
@@ -14,7 +14,7 @@
 
 #define M2E 2.6112004954086e-7
 
-class CbmLmvmKinematicParams {
+class LmvmKinePar {
 public:
   Double_t fMomentumMag = 0.;  // Absolute value of momentum
   Double_t fPt          = 0.;  // Transverse momentum
@@ -25,9 +25,9 @@ public:
   /*
     * Calculate kinematic parameters for MC tracks.
     */
-  static CbmLmvmKinematicParams Create(const CbmMCTrack* mctrackP, const CbmMCTrack* mctrackM)
+  static LmvmKinePar Create(const CbmMCTrack* mctrackP, const CbmMCTrack* mctrackM)
   {
-    CbmLmvmKinematicParams params;
+    LmvmKinePar params;
     if (mctrackP == nullptr || mctrackM == nullptr) return params;
 
     TVector3 momP;  //momentum e+
@@ -60,9 +60,9 @@ public:
   /*
     * Calculate kinematic parameters for LMVM candidates.
     */
-  static CbmLmvmKinematicParams Create(const LmvmCand* candP, const LmvmCand* candM)
+  static LmvmKinePar Create(const LmvmCand* candP, const LmvmCand* candM)
   {
-    CbmLmvmKinematicParams params;
+    LmvmKinePar params;
     if (candP == nullptr || candM == nullptr) return params;
 
     TLorentzVector lorVecP(candP->fMomentum, candP->fEnergy);
diff --git a/analysis/PWGDIL/dielectron/lmvm/LmvmTask.cxx b/analysis/PWGDIL/dielectron/lmvm/LmvmTask.cxx
index 5bf25f37e7e7c455520ce950a3e5c635e437a716..0e73e67a01432a94525567973160d88ab7f92dd1 100644
--- a/analysis/PWGDIL/dielectron/lmvm/LmvmTask.cxx
+++ b/analysis/PWGDIL/dielectron/lmvm/LmvmTask.cxx
@@ -311,10 +311,10 @@ void LmvmTask::DoMcPair()
 
     bool isAcc1 = IsMcTrackAccepted(iMc1);
     for (int iMc2 = iMc1 + 1; iMc2 < nMcTracks; iMc2++) {
-      CbmMCTrack* mct2            = static_cast<CbmMCTrack*>(fMCTracks->At(iMc2));
-      bool isAccPair              = isAcc1 && IsMcTrackAccepted(iMc2);
-      ELmvmSrc srcPair            = LmvmUtils::GetMcPairSrc(mct1, mct2, fMCTracks);
-      CbmLmvmKinematicParams pKin = CbmLmvmKinematicParams::Create(mct1, mct2);
+      CbmMCTrack* mct2 = static_cast<CbmMCTrack*>(fMCTracks->At(iMc2));
+      bool isAccPair   = isAcc1 && IsMcTrackAccepted(iMc2);
+      ELmvmSrc srcPair = LmvmUtils::GetMcPairSrc(mct1, mct2, fMCTracks);
+      LmvmKinePar pKin = LmvmKinePar::Create(mct1, mct2);
 
       if (srcPair == ELmvmSrc::Signal) {
         fH.FillH2("hMomVsAnglePairSignalMc", std::sqrt(mct1->GetP() * mct2->GetP()), pKin.fAngle);
@@ -574,8 +574,8 @@ void LmvmTask::CombinatorialPairs()
       if (cand2.IsMcSignal()) continue;
       //double weight = (cand1.IsMcSignal() || cand2.IsMcSignal()) ? fW : 1.;
 
-      CbmLmvmKinematicParams pRec = CbmLmvmKinematicParams::Create(&cand1, &cand2);
-      bool isSameEvent            = (cand1.fEventNumber == cand2.fEventNumber);
+      LmvmKinePar pRec = LmvmKinePar::Create(&cand1, &cand2);
+      bool isSameEvent = (cand1.fEventNumber == cand2.fEventNumber);
       for (auto step : fH.fAnaSteps) {
         if (step == ELmvmAnaStep::Mc || step == ELmvmAnaStep::Acc) continue;
         if (cand1.IsCutTill(step) && cand2.IsCutTill(step)) {
@@ -660,8 +660,7 @@ void LmvmTask::AssignMcToTopologyCands(vector<LmvmCand>& topoCands)
   }
 }
 
-void LmvmTask::PairSource(const LmvmCand& candP, const LmvmCand& candM, ELmvmAnaStep step,
-                          const CbmLmvmKinematicParams& parRec)
+void LmvmTask::PairSource(const LmvmCand& candP, const LmvmCand& candM, ELmvmAnaStep step, const LmvmKinePar& parRec)
 {
   ELmvmSrc src = LmvmUtils::GetMcPairSrc(candP, candM);
   fH.FillH1("hAnglePair", src, step, parRec.fAngle, fW);
@@ -729,8 +728,8 @@ void LmvmTask::TrackSource(const LmvmCand& cand, ELmvmAnaStep step, int pdg)
   }
 }
 
-void LmvmTask::FillPairHists(const LmvmCand& candP, const LmvmCand& candM, const CbmLmvmKinematicParams& parMc,
-                             const CbmLmvmKinematicParams& parRec, ELmvmAnaStep step)
+void LmvmTask::FillPairHists(const LmvmCand& candP, const LmvmCand& candM, const LmvmKinePar& parMc,
+                             const LmvmKinePar& parRec, ELmvmAnaStep step)
 {
   // mo need to fill histograms for MC and Acc steps
   if (step == ELmvmAnaStep::Mc || step == ELmvmAnaStep::Acc) return;
@@ -789,8 +788,8 @@ void LmvmTask::SignalAndBgReco()
       CbmMCTrack* mctrackM =
         (candM.fStsMcTrackId >= 0) ? static_cast<CbmMCTrack*>(fMCTracks->At(candM.fStsMcTrackId)) : nullptr;
 
-      CbmLmvmKinematicParams pMC  = CbmLmvmKinematicParams::Create(mctrackP, mctrackM);
-      CbmLmvmKinematicParams pRec = CbmLmvmKinematicParams::Create(&candP, &candM);
+      LmvmKinePar pMC  = LmvmKinePar::Create(mctrackP, mctrackM);
+      LmvmKinePar pRec = LmvmKinePar::Create(&candP, &candM);
 
       for (auto step : fH.fAnaSteps) {
         if (candP.IsCutTill(step) && candM.IsCutTill(step)) FillPairHists(candP, candM, pMC, pRec, step);
@@ -806,7 +805,7 @@ void LmvmTask::CheckGammaConvAndPi0()
     for (auto& candM : fCands) {
       if (candM.fCharge > 0) continue;
       if (candP.IsCutTill(ELmvmAnaStep::ElId) && candM.IsCutTill(ELmvmAnaStep::ElId)) {
-        CbmLmvmKinematicParams pRec = CbmLmvmKinematicParams::Create(&candP, &candM);
+        LmvmKinePar pRec = LmvmKinePar::Create(&candP, &candM);
         if (fCuts.IsGammaCutOk(pRec.fMinv)) {
           candM.fIsGammaCut = true;
           candP.fIsGammaCut = true;
@@ -842,7 +841,7 @@ void LmvmTask::CheckTopologyCut(ELmvmTopologyCut cut, const string& name)
       for (size_t iM = 0; iM < tpCands.size(); iM++) {
         // different charges, charge iM != charge iP
         if (tpCands[iM].fCharge != cand.fCharge) {
-          CbmLmvmKinematicParams pRec = CbmLmvmKinematicParams::Create(&cand, &tpCands[iM]);
+          LmvmKinePar pRec = LmvmKinePar::Create(&cand, &tpCands[iM]);
           dataV.emplace_back(pRec.fAngle, tpCands[iM].fMomentum.Mag(), iM);
         }
       }
diff --git a/analysis/PWGDIL/dielectron/lmvm/LmvmTask.h b/analysis/PWGDIL/dielectron/lmvm/LmvmTask.h
index dde2477b2c0e396c6bcba8e0bda8b958da960f93..688ccc3a1120fdc6222f5bee739e7a78acd85436 100644
--- a/analysis/PWGDIL/dielectron/lmvm/LmvmTask.h
+++ b/analysis/PWGDIL/dielectron/lmvm/LmvmTask.h
@@ -6,7 +6,6 @@
 #define LMVM_TASK_H
 
 #include "CbmKFVertex.h"
-#include "CbmLmvmKinematicParams.h"
 #include "CbmStsKFTrackFitter.h"
 
 #include "FairMCEventHeader.h"
@@ -22,6 +21,7 @@
 #include "LmvmCuts.h"
 #include "LmvmDef.h"
 #include "LmvmHist.h"
+#include "LmvmKinePar.h"
 
 class TClonesArray;
 class TH2D;
@@ -70,8 +70,7 @@ public:
      * \param[in] step Enumeration AnalysisSteps, specify analysis step.
      * \param[in] parRec Kinematic parameters for reconstructed pair.
      */
-  void PairSource(const LmvmCand& candP, const LmvmCand& candM, ELmvmAnaStep step,
-                  const CbmLmvmKinematicParams& parRec);
+  void PairSource(const LmvmCand& candP, const LmvmCand& candM, ELmvmAnaStep step, const LmvmKinePar& parRec);
 
   /*
      *  \brief Fills minv, pty, mom histograms for specified analysis step.
@@ -81,8 +80,8 @@ public:
      * \param[in] parRec Reconstructed kinematic parameters.
      * \param[in] step Enumeration AnalysisSteps, specify analysis step.
      */
-  void FillPairHists(const LmvmCand& candP, const LmvmCand& candM, const CbmLmvmKinematicParams& parMc,
-                     const CbmLmvmKinematicParams& parRec, ELmvmAnaStep step);
+  void FillPairHists(const LmvmCand& candP, const LmvmCand& candM, const LmvmKinePar& parMc, const LmvmKinePar& parRec,
+                     ELmvmAnaStep step);
 
   void FillMomHists(const CbmMCTrack* mct, const LmvmCand* cand, ELmvmSrc src, ELmvmAnaStep step);
 
diff --git a/analysis/PWGDIL/dielectron/pi0eta/CbmKresConversionCorrectedPhotons.cxx b/analysis/PWGDIL/dielectron/pi0eta/CbmKresConversionCorrectedPhotons.cxx
index f349fc92be8bce4fe599cb13b0cc0f05f7e34db8..0a1e77fea25c0ac7f02023aa795a48b193913c89 100644
--- a/analysis/PWGDIL/dielectron/pi0eta/CbmKresConversionCorrectedPhotons.cxx
+++ b/analysis/PWGDIL/dielectron/pi0eta/CbmKresConversionCorrectedPhotons.cxx
@@ -651,9 +651,9 @@ void CbmKresConversionCorrectedPhotons::FindGammasTarget(
       }
       int richcheck = richcheck_0 + richcheck_1;
 
-      Double_t InvmassReco          = CbmKresFunctions::Invmass_2particles_RECO(part1, part2);
-      Double_t OpeningAngle         = CbmKresFunctions::CalculateOpeningAngle_Reco(part1, part2);
-      CbmLmvmKinematicParams params = CbmKresFunctions::CalculateKinematicParamsReco(part1, part2);
+      Double_t InvmassReco  = CbmKresFunctions::Invmass_2particles_RECO(part1, part2);
+      Double_t OpeningAngle = CbmKresFunctions::CalculateOpeningAngle_Reco(part1, part2);
+      LmvmKinePar params    = CbmKresFunctions::CalculateKinematicParamsReco(part1, part2);
 
       if (params.fRapidity != params.fRapidity) continue;
       if (params.fPt != params.fPt) continue;
@@ -1031,9 +1031,9 @@ void CbmKresConversionCorrectedPhotons::FindGammasOutside(
       }
 
 
-      Double_t InvmassReco          = CbmKresFunctions::Invmass_2particles_RECO(part1, part2);
-      Double_t OpeningAngle         = CbmKresFunctions::CalculateOpeningAngle_Reco(part1, part2);
-      CbmLmvmKinematicParams params = CbmKresFunctions::CalculateKinematicParamsReco(part1, part2);
+      Double_t InvmassReco  = CbmKresFunctions::Invmass_2particles_RECO(part1, part2);
+      Double_t OpeningAngle = CbmKresFunctions::CalculateOpeningAngle_Reco(part1, part2);
+      LmvmKinePar params    = CbmKresFunctions::CalculateKinematicParamsReco(part1, part2);
 
       if (params.fRapidity != params.fRapidity) continue;
       if (params.fPt != params.fPt) continue;
@@ -1701,7 +1701,7 @@ void CbmKresConversionCorrectedPhotons::CDP_likesign_Mixing_Target(double AngleC
       if (TMath::Abs(InvmassReco) > InvMassCut) continue;
       // if (AnnValue < 0.9 || AnnValue > 1.1) continue;
 
-      CbmLmvmKinematicParams params = CbmKresFunctions::CalculateKinematicParamsReco(e1, e2);
+      LmvmKinePar params = CbmKresFunctions::CalculateKinematicParamsReco(e1, e2);
 
       if (params.fRapidity != params.fRapidity) continue;
       if (params.fPt != params.fPt) continue;
@@ -1756,7 +1756,7 @@ void CbmKresConversionCorrectedPhotons::CDP_likesign_Mixing_Target(double AngleC
       if (TMath::Abs(InvmassReco) > InvMassCut) continue;
       // if (AnnValue < 0.9 || AnnValue > 1.1) continue;
 
-      CbmLmvmKinematicParams params = CbmKresFunctions::CalculateKinematicParamsReco(e1, e2);
+      LmvmKinePar params = CbmKresFunctions::CalculateKinematicParamsReco(e1, e2);
 
       if (params.fRapidity != params.fRapidity) continue;
       if (params.fPt != params.fPt) continue;
@@ -1825,7 +1825,7 @@ void CbmKresConversionCorrectedPhotons::CDP_likesign_Mixing_Outside(double Angle
       if (TMath::Abs(InvmassReco) > InvMassCut) continue;
       // if (AnnValue < 0.9 || AnnValue > 1.1) continue;
 
-      CbmLmvmKinematicParams params = CbmKresFunctions::CalculateKinematicParamsReco(e1, e2);
+      LmvmKinePar params = CbmKresFunctions::CalculateKinematicParamsReco(e1, e2);
 
       if (params.fRapidity != params.fRapidity) continue;
       if (params.fPt != params.fPt) continue;
@@ -1891,7 +1891,7 @@ void CbmKresConversionCorrectedPhotons::CDP_likesign_Mixing_Outside(double Angle
       if (TMath::Abs(InvmassReco) > InvMassCut) continue;
       // if (AnnValue < 0.9 || AnnValue > 1.1) continue;
 
-      CbmLmvmKinematicParams params = CbmKresFunctions::CalculateKinematicParamsReco(e1, e2);
+      LmvmKinePar params = CbmKresFunctions::CalculateKinematicParamsReco(e1, e2);
 
       if (params.fRapidity != params.fRapidity) continue;
       if (params.fPt != params.fPt) continue;
@@ -1953,7 +1953,7 @@ void CbmKresConversionCorrectedPhotons::CDP_Mixing_Target(double AngleCut, doubl
       if (TMath::Abs(InvmassReco) > InvMassCut) continue;
       // if (AnnValue < 0.9 || AnnValue > 1.1) continue;
 
-      CbmLmvmKinematicParams params = CbmKresFunctions::CalculateKinematicParamsReco(e1, e2);
+      LmvmKinePar params = CbmKresFunctions::CalculateKinematicParamsReco(e1, e2);
 
       if (params.fRapidity != params.fRapidity) continue;
       if (params.fPt != params.fPt) continue;
@@ -2030,7 +2030,7 @@ void CbmKresConversionCorrectedPhotons::CDP_Mixing_Outside(double AngleCut, doub
       if (TMath::Abs(InvmassReco) > InvMassCut) continue;
       // if (AnnValue < 0.9 || AnnValue > 1.1) continue;
 
-      CbmLmvmKinematicParams params = CbmKresFunctions::CalculateKinematicParamsReco(e1, e2);
+      LmvmKinePar params = CbmKresFunctions::CalculateKinematicParamsReco(e1, e2);
 
       if (params.fRapidity != params.fRapidity) continue;
       if (params.fPt != params.fPt) continue;
diff --git a/analysis/PWGDIL/dielectron/pi0eta/CbmKresConversionCorrectedPhotons.h b/analysis/PWGDIL/dielectron/pi0eta/CbmKresConversionCorrectedPhotons.h
index 8bb955694f2533a2bbb62b536c85459b2ab0d4b1..6cae2e492f0140db53c27709525860834076b731 100644
--- a/analysis/PWGDIL/dielectron/pi0eta/CbmKresConversionCorrectedPhotons.h
+++ b/analysis/PWGDIL/dielectron/pi0eta/CbmKresConversionCorrectedPhotons.h
@@ -9,7 +9,6 @@
 #include "CbmKresGammaCorrection.h"
 #include "CbmKresSelectAnnPhotons.h"
 #include "CbmKresTrainAnnDirectPhotons.h"
-#include "CbmLmvmKinematicParams.h"
 #include "CbmMCTrack.h"
 #include "CbmRichRing.h"
 #include "CbmRichRingFitterEllipseTau.h"
@@ -20,6 +19,7 @@
 #include <TClonesArray.h>
 
 #include "KFParticle.h"
+#include "LmvmKinePar.h"
 
 class CbmRichRingFitterEllipseTau;
 
diff --git a/analysis/PWGDIL/dielectron/pi0eta/CbmKresConversionKF.cxx b/analysis/PWGDIL/dielectron/pi0eta/CbmKresConversionKF.cxx
index ccac39d2b0bb56dcf7c88aaae5174b2966dec43d..7eaccfe76f1ff0a2aad75671d7af89259f767df7 100644
--- a/analysis/PWGDIL/dielectron/pi0eta/CbmKresConversionKF.cxx
+++ b/analysis/PWGDIL/dielectron/pi0eta/CbmKresConversionKF.cxx
@@ -26,7 +26,6 @@
 #include "CbmKFParticleFinderQa.h"
 #include "CbmKresConversionBG.h"
 #include "CbmKresFunctions.h"
-#include "CbmLmvmKinematicParams.h"
 #include "CbmMCTrack.h"
 #include "CbmRichHit.h"
 #include "CbmRichRing.h"
@@ -37,6 +36,7 @@
 
 #include "KFParticle.h"
 #include "KFParticleTopoReconstructor.h"
+#include "LmvmKinePar.h"
 
 
 using namespace std;
@@ -1050,7 +1050,7 @@ void CbmKresConversionKF::FindPi0(TString /*mod*/, vector<vector<TVector3>> Gamm
       CbmMCTrack* mcTrack3 = GammasMC[gamma2][0];
       CbmMCTrack* mcTrack4 = GammasMC[gamma2][1];
 
-      CbmLmvmKinematicParams params = CbmKresFunctions::CalculateKinematicParams_4particles(e1, e2, e3, e4);
+      LmvmKinePar params = CbmKresFunctions::CalculateKinematicParams_4particles(e1, e2, e3, e4);
 
       Pi0InvMassRecoKF->Fill(params.fMinv);
 
@@ -1157,11 +1157,11 @@ void CbmKresConversionKF::MixedEvent()
   for (Int_t a = 0; a < nof - 1; a++) {
     for (Int_t b = a + 1; b < nof; b++) {
       if (EMT_Event[a] == EMT_Event[b]) continue;  // to make sure that the photons are from two different events
-      TVector3 e11                  = EMT_pair_momenta[a][0];
-      TVector3 e12                  = EMT_pair_momenta[a][1];
-      TVector3 e21                  = EMT_pair_momenta[b][0];
-      TVector3 e22                  = EMT_pair_momenta[b][1];
-      CbmLmvmKinematicParams params = CbmKresFunctions::CalculateKinematicParams_4particles(e11, e12, e21, e22);
+      TVector3 e11       = EMT_pair_momenta[a][0];
+      TVector3 e12       = EMT_pair_momenta[a][1];
+      TVector3 e21       = EMT_pair_momenta[b][0];
+      TVector3 e22       = EMT_pair_momenta[b][1];
+      LmvmKinePar params = CbmKresFunctions::CalculateKinematicParams_4particles(e11, e12, e21, e22);
 
       fEMT_InvMass_All->Fill(params.fMinv);
       if (EMT_NofRings[a] == 0 && EMT_NofRings[b] == 0) fEMT_InvMass_Zero->Fill(params.fMinv);
@@ -1203,11 +1203,11 @@ void CbmKresConversionKF::MixedEventMulti()
       if (EMT_Event_multi_all[a] == EMT_Event_multi_all[b])
         continue;  // to make sure that the photons are from two different events
       if (EMT_multi_all[a] != EMT_multi_all[b]) continue;  // check same multiplicity
-      TVector3 e11                  = EMT_pair_momenta_multi_all[a][0];
-      TVector3 e12                  = EMT_pair_momenta_multi_all[a][1];
-      TVector3 e21                  = EMT_pair_momenta_multi_all[b][0];
-      TVector3 e22                  = EMT_pair_momenta_multi_all[b][1];
-      CbmLmvmKinematicParams params = CbmKresFunctions::CalculateKinematicParams_4particles(e11, e12, e21, e22);
+      TVector3 e11       = EMT_pair_momenta_multi_all[a][0];
+      TVector3 e12       = EMT_pair_momenta_multi_all[a][1];
+      TVector3 e21       = EMT_pair_momenta_multi_all[b][0];
+      TVector3 e22       = EMT_pair_momenta_multi_all[b][1];
+      LmvmKinePar params = CbmKresFunctions::CalculateKinematicParams_4particles(e11, e12, e21, e22);
 
       if (EMT_multi_all[a] == 1) EMTMulti_InvMass_All_m1->Fill(params.fMinv);
       if (EMT_multi_all[a] == 2) EMTMulti_InvMass_All_m2->Fill(params.fMinv);
@@ -1227,11 +1227,11 @@ void CbmKresConversionKF::MixedEventMulti()
       if (EMT_Event_multi_zero[a] == EMT_Event_multi_zero[b])
         continue;  // to make sure that the photons are from two different events
       if (EMT_multi_zero[a] != EMT_multi_zero[b]) continue;  // check same multiplicity
-      TVector3 e11                  = EMT_pair_momenta_multi_zero[a][0];
-      TVector3 e12                  = EMT_pair_momenta_multi_zero[a][1];
-      TVector3 e21                  = EMT_pair_momenta_multi_zero[b][0];
-      TVector3 e22                  = EMT_pair_momenta_multi_zero[b][1];
-      CbmLmvmKinematicParams params = CbmKresFunctions::CalculateKinematicParams_4particles(e11, e12, e21, e22);
+      TVector3 e11       = EMT_pair_momenta_multi_zero[a][0];
+      TVector3 e12       = EMT_pair_momenta_multi_zero[a][1];
+      TVector3 e21       = EMT_pair_momenta_multi_zero[b][0];
+      TVector3 e22       = EMT_pair_momenta_multi_zero[b][1];
+      LmvmKinePar params = CbmKresFunctions::CalculateKinematicParams_4particles(e11, e12, e21, e22);
 
       if (EMT_multi_zero[a] == 1) EMTMulti_InvMass_Zero_m1->Fill(params.fMinv);
       if (EMT_multi_zero[a] == 2) EMTMulti_InvMass_Zero_m2->Fill(params.fMinv);
@@ -1251,11 +1251,11 @@ void CbmKresConversionKF::MixedEventMulti()
       if (EMT_Event_multi_one[a] == EMT_Event_multi_one[b])
         continue;  // to make sure that the photons are from two different events
       if (EMT_multi_one[a] != EMT_multi_one[b]) continue;  // check same multiplicity
-      TVector3 e11                  = EMT_pair_momenta_multi_one[a][0];
-      TVector3 e12                  = EMT_pair_momenta_multi_one[a][1];
-      TVector3 e21                  = EMT_pair_momenta_multi_one[b][0];
-      TVector3 e22                  = EMT_pair_momenta_multi_one[b][1];
-      CbmLmvmKinematicParams params = CbmKresFunctions::CalculateKinematicParams_4particles(e11, e12, e21, e22);
+      TVector3 e11       = EMT_pair_momenta_multi_one[a][0];
+      TVector3 e12       = EMT_pair_momenta_multi_one[a][1];
+      TVector3 e21       = EMT_pair_momenta_multi_one[b][0];
+      TVector3 e22       = EMT_pair_momenta_multi_one[b][1];
+      LmvmKinePar params = CbmKresFunctions::CalculateKinematicParams_4particles(e11, e12, e21, e22);
 
       if (EMT_multi_one[a] == 1) EMTMulti_InvMass_One_m1->Fill(params.fMinv);
       if (EMT_multi_one[a] == 2) EMTMulti_InvMass_One_m2->Fill(params.fMinv);
@@ -1275,11 +1275,11 @@ void CbmKresConversionKF::MixedEventMulti()
       if (EMT_Event_multi_two[a] == EMT_Event_multi_two[b])
         continue;  // to make sure that the photons are from two different events
       if (EMT_multi_two[a] != EMT_multi_two[b]) continue;  // check same multiplicity
-      TVector3 e11                  = EMT_pair_momenta_multi_two[a][0];
-      TVector3 e12                  = EMT_pair_momenta_multi_two[a][1];
-      TVector3 e21                  = EMT_pair_momenta_multi_two[b][0];
-      TVector3 e22                  = EMT_pair_momenta_multi_two[b][1];
-      CbmLmvmKinematicParams params = CbmKresFunctions::CalculateKinematicParams_4particles(e11, e12, e21, e22);
+      TVector3 e11       = EMT_pair_momenta_multi_two[a][0];
+      TVector3 e12       = EMT_pair_momenta_multi_two[a][1];
+      TVector3 e21       = EMT_pair_momenta_multi_two[b][0];
+      TVector3 e22       = EMT_pair_momenta_multi_two[b][1];
+      LmvmKinePar params = CbmKresFunctions::CalculateKinematicParams_4particles(e11, e12, e21, e22);
 
       if (EMT_multi_two[a] == 1) EMTMulti_InvMass_Two_m1->Fill(params.fMinv);
       if (EMT_multi_two[a] == 2) EMTMulti_InvMass_Two_m2->Fill(params.fMinv);
@@ -1299,11 +1299,11 @@ void CbmKresConversionKF::MixedEventMulti()
       if (EMT_Event_multi_onetwo[a] == EMT_Event_multi_onetwo[b])
         continue;  // to make sure that the photons are from two different events
       if (EMT_multi_onetwo[a] != EMT_multi_onetwo[b]) continue;  // check same multiplicity
-      TVector3 e11                  = EMT_pair_momenta_multi_onetwo[a][0];
-      TVector3 e12                  = EMT_pair_momenta_multi_onetwo[a][1];
-      TVector3 e21                  = EMT_pair_momenta_multi_onetwo[b][0];
-      TVector3 e22                  = EMT_pair_momenta_multi_onetwo[b][1];
-      CbmLmvmKinematicParams params = CbmKresFunctions::CalculateKinematicParams_4particles(e11, e12, e21, e22);
+      TVector3 e11       = EMT_pair_momenta_multi_onetwo[a][0];
+      TVector3 e12       = EMT_pair_momenta_multi_onetwo[a][1];
+      TVector3 e21       = EMT_pair_momenta_multi_onetwo[b][0];
+      TVector3 e22       = EMT_pair_momenta_multi_onetwo[b][1];
+      LmvmKinePar params = CbmKresFunctions::CalculateKinematicParams_4particles(e11, e12, e21, e22);
 
       if (EMT_multi_onetwo[a] == 1) EMTMulti_InvMass_OneTwo_m1->Fill(params.fMinv);
       if (EMT_multi_onetwo[a] == 2) EMTMulti_InvMass_OneTwo_m2->Fill(params.fMinv);
diff --git a/analysis/PWGDIL/dielectron/pi0eta/CbmKresConversionManual.cxx b/analysis/PWGDIL/dielectron/pi0eta/CbmKresConversionManual.cxx
index f2a6500d00e0c2bea56a64048842c65398071315..4217f26a67fa0c246aca87602bfea48a09435878 100644
--- a/analysis/PWGDIL/dielectron/pi0eta/CbmKresConversionManual.cxx
+++ b/analysis/PWGDIL/dielectron/pi0eta/CbmKresConversionManual.cxx
@@ -2198,7 +2198,7 @@ void CbmKresConversionManual::FindPi0(TString mod, TString position, vector<vect
           || StsIndex[gamma1][1] == StsIndex[gamma2][0] || StsIndex[gamma1][1] == StsIndex[gamma2][1])
         continue;  // particles are not used twice --> different
 
-      CbmLmvmKinematicParams params = CbmKresFunctions::CalculateKinematicParams_4particles(e11, e12, e21, e22);
+      LmvmKinePar params = CbmKresFunctions::CalculateKinematicParams_4particles(e11, e12, e21, e22);
 
       CbmKresFunctions::CalculateOpeningAngle_Reco(e11, e12);
       CbmKresFunctions::CalculateOpeningAngle_Reco(e21, e22);
@@ -2578,11 +2578,11 @@ void CbmKresConversionManual::Mixing_Target()
     for (Int_t b = a + 1; b < nof_Target; b++) {
       if (EMT_man_Event_Target[a] == EMT_man_Event_Target[b])
         continue;  // to make sure that the photons are from two different events
-      TVector3 e11                  = EMT_man_pair_momenta_Target[a][0];
-      TVector3 e12                  = EMT_man_pair_momenta_Target[a][1];
-      TVector3 e21                  = EMT_man_pair_momenta_Target[b][0];
-      TVector3 e22                  = EMT_man_pair_momenta_Target[b][1];
-      CbmLmvmKinematicParams params = CbmKresFunctions::CalculateKinematicParams_4particles(e11, e12, e21, e22);
+      TVector3 e11       = EMT_man_pair_momenta_Target[a][0];
+      TVector3 e12       = EMT_man_pair_momenta_Target[a][1];
+      TVector3 e21       = EMT_man_pair_momenta_Target[b][0];
+      TVector3 e22       = EMT_man_pair_momenta_Target[b][1];
+      LmvmKinePar params = CbmKresFunctions::CalculateKinematicParams_4particles(e11, e12, e21, e22);
 
       EMT_InvMass_all_Target->Fill(params.fMinv);
       if (EMT_man_NofRings_Target[a] == 0 && EMT_man_NofRings_Target[b] == 0)
@@ -2608,11 +2608,11 @@ void CbmKresConversionManual::Mixing_Outside()
     for (Int_t b = a + 1; b < nof_Outside; b++) {
       if (EMT_man_Event_Outside[a] == EMT_man_Event_Outside[b])
         continue;  // to make sure that the photons are from two different events
-      TVector3 e11                  = EMT_man_pair_momenta_Outside[a][0];
-      TVector3 e12                  = EMT_man_pair_momenta_Outside[a][1];
-      TVector3 e21                  = EMT_man_pair_momenta_Outside[b][0];
-      TVector3 e22                  = EMT_man_pair_momenta_Outside[b][1];
-      CbmLmvmKinematicParams params = CbmKresFunctions::CalculateKinematicParams_4particles(e11, e12, e21, e22);
+      TVector3 e11       = EMT_man_pair_momenta_Outside[a][0];
+      TVector3 e12       = EMT_man_pair_momenta_Outside[a][1];
+      TVector3 e21       = EMT_man_pair_momenta_Outside[b][0];
+      TVector3 e22       = EMT_man_pair_momenta_Outside[b][1];
+      LmvmKinePar params = CbmKresFunctions::CalculateKinematicParams_4particles(e11, e12, e21, e22);
 
       EMT_InvMass_all_Outside->Fill(params.fMinv);
       if (EMT_man_NofRings_Outside[a] == 0 && EMT_man_NofRings_Outside[b] == 0)
@@ -2638,11 +2638,11 @@ void CbmKresConversionManual::Mixing_Both()
     for (Int_t b = a + 1; b < nof_Both; b++) {
       if (EMT_man_Event_Both[a] == EMT_man_Event_Both[b])
         continue;  // to make sure that the photons are from two different events
-      TVector3 e11                  = EMT_man_pair_momenta_Both[a][0];
-      TVector3 e12                  = EMT_man_pair_momenta_Both[a][1];
-      TVector3 e21                  = EMT_man_pair_momenta_Both[b][0];
-      TVector3 e22                  = EMT_man_pair_momenta_Both[b][1];
-      CbmLmvmKinematicParams params = CbmKresFunctions::CalculateKinematicParams_4particles(e11, e12, e21, e22);
+      TVector3 e11       = EMT_man_pair_momenta_Both[a][0];
+      TVector3 e12       = EMT_man_pair_momenta_Both[a][1];
+      TVector3 e21       = EMT_man_pair_momenta_Both[b][0];
+      TVector3 e22       = EMT_man_pair_momenta_Both[b][1];
+      LmvmKinePar params = CbmKresFunctions::CalculateKinematicParams_4particles(e11, e12, e21, e22);
 
       EMT_InvMass_all_Both->Fill(params.fMinv);
       if (EMT_man_NofRings_Both[a] == 0 && EMT_man_NofRings_Both[b] == 0) EMT_InvMass_zero_Both->Fill(params.fMinv);
@@ -2945,11 +2945,11 @@ void CbmKresConversionManual::Mixing_WAC()
     for (Int_t b = a + 1; b < nof_WAC; b++) {
       if (EMT_man_Event_WAC[a] == EMT_man_Event_WAC[b])
         continue;  // to make sure that the photons are from two different events
-      TVector3 e11                  = EMT_man_pair_momenta_WAC[a][0];
-      TVector3 e12                  = EMT_man_pair_momenta_WAC[a][1];
-      TVector3 e21                  = EMT_man_pair_momenta_WAC[b][0];
-      TVector3 e22                  = EMT_man_pair_momenta_WAC[b][1];
-      CbmLmvmKinematicParams params = CbmKresFunctions::CalculateKinematicParams_4particles(e11, e12, e21, e22);
+      TVector3 e11       = EMT_man_pair_momenta_WAC[a][0];
+      TVector3 e12       = EMT_man_pair_momenta_WAC[a][1];
+      TVector3 e21       = EMT_man_pair_momenta_WAC[b][0];
+      TVector3 e22       = EMT_man_pair_momenta_WAC[b][1];
+      LmvmKinePar params = CbmKresFunctions::CalculateKinematicParams_4particles(e11, e12, e21, e22);
       EMT_InvMass_WAC->Fill(params.fMinv);
     }
   }
diff --git a/analysis/PWGDIL/dielectron/pi0eta/CbmKresConversionManualmbias1.cxx b/analysis/PWGDIL/dielectron/pi0eta/CbmKresConversionManualmbias1.cxx
index 811e865578224ecaa78561e2a3617b2ebdddc29d..f3905c6a8fbde2696654befc55889eca990ec218 100644
--- a/analysis/PWGDIL/dielectron/pi0eta/CbmKresConversionManualmbias1.cxx
+++ b/analysis/PWGDIL/dielectron/pi0eta/CbmKresConversionManualmbias1.cxx
@@ -1499,7 +1499,7 @@ void CbmKresConversionManualmbias1::FindPi0(TString mod, TString position, vecto
           || StsIndex[gamma1][1] == StsIndex[gamma2][0] || StsIndex[gamma1][1] == StsIndex[gamma2][1])
         continue;  // particles not used twice --> different
 
-      CbmLmvmKinematicParams params = CbmKresFunctions::CalculateKinematicParams_4particles(e11, e12, e21, e22);
+      LmvmKinePar params = CbmKresFunctions::CalculateKinematicParams_4particles(e11, e12, e21, e22);
 
       //Double_t OA1 = CbmKresFunctions::CalculateOpeningAngle_Reco(e11, e12);
       //Double_t OA2 = CbmKresFunctions::CalculateOpeningAngle_Reco(e21, e22);
@@ -1623,11 +1623,11 @@ void CbmKresConversionManualmbias1::Mixing_Target()
     for (Int_t b = a + 1; b < nof_Target; b++) {
       if (EMT_man_Event_Target_mbias1[a] == EMT_man_Event_Target_mbias1[b])
         continue;  // to make sure that the photons are from two different events
-      TVector3 e11                  = EMT_man_pair_momenta_Target_mbias1[a][0];
-      TVector3 e12                  = EMT_man_pair_momenta_Target_mbias1[a][1];
-      TVector3 e21                  = EMT_man_pair_momenta_Target_mbias1[b][0];
-      TVector3 e22                  = EMT_man_pair_momenta_Target_mbias1[b][1];
-      CbmLmvmKinematicParams params = CbmKresFunctions::CalculateKinematicParams_4particles(e11, e12, e21, e22);
+      TVector3 e11       = EMT_man_pair_momenta_Target_mbias1[a][0];
+      TVector3 e12       = EMT_man_pair_momenta_Target_mbias1[a][1];
+      TVector3 e21       = EMT_man_pair_momenta_Target_mbias1[b][0];
+      TVector3 e22       = EMT_man_pair_momenta_Target_mbias1[b][1];
+      LmvmKinePar params = CbmKresFunctions::CalculateKinematicParams_4particles(e11, e12, e21, e22);
 
       EMT_InvMass_all_Target_mbias1->Fill(params.fMinv);
       if (EMT_man_NofRings_Target_mbias1[a] == 0 && EMT_man_NofRings_Target_mbias1[b] == 0)
@@ -1653,11 +1653,11 @@ void CbmKresConversionManualmbias1::Mixing_Outside()
     for (Int_t b = a + 1; b < nof_Outside; b++) {
       if (EMT_man_Event_Outside_mbias1[a] == EMT_man_Event_Outside_mbias1[b])
         continue;  // to make sure that the photons are from two different events
-      TVector3 e11                  = EMT_man_pair_momenta_Outside_mbias1[a][0];
-      TVector3 e12                  = EMT_man_pair_momenta_Outside_mbias1[a][1];
-      TVector3 e21                  = EMT_man_pair_momenta_Outside_mbias1[b][0];
-      TVector3 e22                  = EMT_man_pair_momenta_Outside_mbias1[b][1];
-      CbmLmvmKinematicParams params = CbmKresFunctions::CalculateKinematicParams_4particles(e11, e12, e21, e22);
+      TVector3 e11       = EMT_man_pair_momenta_Outside_mbias1[a][0];
+      TVector3 e12       = EMT_man_pair_momenta_Outside_mbias1[a][1];
+      TVector3 e21       = EMT_man_pair_momenta_Outside_mbias1[b][0];
+      TVector3 e22       = EMT_man_pair_momenta_Outside_mbias1[b][1];
+      LmvmKinePar params = CbmKresFunctions::CalculateKinematicParams_4particles(e11, e12, e21, e22);
 
       EMT_InvMass_all_Outside_mbias1->Fill(params.fMinv);
       if (EMT_man_NofRings_Outside_mbias1[a] == 0 && EMT_man_NofRings_Outside_mbias1[b] == 0)
@@ -1683,11 +1683,11 @@ void CbmKresConversionManualmbias1::Mixing_Both()
     for (Int_t b = a + 1; b < nof_Both; b++) {
       if (EMT_man_Event_Both_mbias1[a] == EMT_man_Event_Both_mbias1[b])
         continue;  // to make sure that the photons are from two different events
-      TVector3 e11                  = EMT_man_pair_momenta_Both_mbias1[a][0];
-      TVector3 e12                  = EMT_man_pair_momenta_Both_mbias1[a][1];
-      TVector3 e21                  = EMT_man_pair_momenta_Both_mbias1[b][0];
-      TVector3 e22                  = EMT_man_pair_momenta_Both_mbias1[b][1];
-      CbmLmvmKinematicParams params = CbmKresFunctions::CalculateKinematicParams_4particles(e11, e12, e21, e22);
+      TVector3 e11       = EMT_man_pair_momenta_Both_mbias1[a][0];
+      TVector3 e12       = EMT_man_pair_momenta_Both_mbias1[a][1];
+      TVector3 e21       = EMT_man_pair_momenta_Both_mbias1[b][0];
+      TVector3 e22       = EMT_man_pair_momenta_Both_mbias1[b][1];
+      LmvmKinePar params = CbmKresFunctions::CalculateKinematicParams_4particles(e11, e12, e21, e22);
 
       EMT_InvMass_all_Both_mbias1->Fill(params.fMinv);
       if (EMT_man_NofRings_Both_mbias1[a] == 0 && EMT_man_NofRings_Both_mbias1[b] == 0)
diff --git a/analysis/PWGDIL/dielectron/pi0eta/CbmKresConversionManualmbias2.cxx b/analysis/PWGDIL/dielectron/pi0eta/CbmKresConversionManualmbias2.cxx
index a949f5ec93ebd745ce3c220cd79b1e95ef37f0bb..87bc8a8e475c9c9e0f5ead7527bb45ac063f7d77 100644
--- a/analysis/PWGDIL/dielectron/pi0eta/CbmKresConversionManualmbias2.cxx
+++ b/analysis/PWGDIL/dielectron/pi0eta/CbmKresConversionManualmbias2.cxx
@@ -1499,7 +1499,7 @@ void CbmKresConversionManualmbias2::FindPi0(TString mod, TString position, vecto
           || StsIndex[gamma1][1] == StsIndex[gamma2][0] || StsIndex[gamma1][1] == StsIndex[gamma2][1])
         continue;  // particles not used twice --> different
 
-      CbmLmvmKinematicParams params = CbmKresFunctions::CalculateKinematicParams_4particles(e11, e12, e21, e22);
+      LmvmKinePar params = CbmKresFunctions::CalculateKinematicParams_4particles(e11, e12, e21, e22);
 
       //Double_t OA1 = CbmKresFunctions::CalculateOpeningAngle_Reco(e11, e12);
       //Double_t OA2 = CbmKresFunctions::CalculateOpeningAngle_Reco(e21, e22);
@@ -1623,11 +1623,11 @@ void CbmKresConversionManualmbias2::Mixing_Target()
     for (Int_t b = a + 1; b < nof_Target; b++) {
       if (EMT_man_Event_Target_mbias2[a] == EMT_man_Event_Target_mbias2[b])
         continue;  // to make sure that the photons are from two different events
-      TVector3 e11                  = EMT_man_pair_momenta_Target_mbias2[a][0];
-      TVector3 e12                  = EMT_man_pair_momenta_Target_mbias2[a][1];
-      TVector3 e21                  = EMT_man_pair_momenta_Target_mbias2[b][0];
-      TVector3 e22                  = EMT_man_pair_momenta_Target_mbias2[b][1];
-      CbmLmvmKinematicParams params = CbmKresFunctions::CalculateKinematicParams_4particles(e11, e12, e21, e22);
+      TVector3 e11       = EMT_man_pair_momenta_Target_mbias2[a][0];
+      TVector3 e12       = EMT_man_pair_momenta_Target_mbias2[a][1];
+      TVector3 e21       = EMT_man_pair_momenta_Target_mbias2[b][0];
+      TVector3 e22       = EMT_man_pair_momenta_Target_mbias2[b][1];
+      LmvmKinePar params = CbmKresFunctions::CalculateKinematicParams_4particles(e11, e12, e21, e22);
 
       EMT_InvMass_all_Target_mbias2->Fill(params.fMinv);
       if (EMT_man_NofRings_Target_mbias2[a] == 0 && EMT_man_NofRings_Target_mbias2[b] == 0)
@@ -1653,11 +1653,11 @@ void CbmKresConversionManualmbias2::Mixing_Outside()
     for (Int_t b = a + 1; b < nof_Outside; b++) {
       if (EMT_man_Event_Outside_mbias2[a] == EMT_man_Event_Outside_mbias2[b])
         continue;  // to make sure that the photons are from two different events
-      TVector3 e11                  = EMT_man_pair_momenta_Outside_mbias2[a][0];
-      TVector3 e12                  = EMT_man_pair_momenta_Outside_mbias2[a][1];
-      TVector3 e21                  = EMT_man_pair_momenta_Outside_mbias2[b][0];
-      TVector3 e22                  = EMT_man_pair_momenta_Outside_mbias2[b][1];
-      CbmLmvmKinematicParams params = CbmKresFunctions::CalculateKinematicParams_4particles(e11, e12, e21, e22);
+      TVector3 e11       = EMT_man_pair_momenta_Outside_mbias2[a][0];
+      TVector3 e12       = EMT_man_pair_momenta_Outside_mbias2[a][1];
+      TVector3 e21       = EMT_man_pair_momenta_Outside_mbias2[b][0];
+      TVector3 e22       = EMT_man_pair_momenta_Outside_mbias2[b][1];
+      LmvmKinePar params = CbmKresFunctions::CalculateKinematicParams_4particles(e11, e12, e21, e22);
 
       EMT_InvMass_all_Outside_mbias2->Fill(params.fMinv);
       if (EMT_man_NofRings_Outside_mbias2[a] == 0 && EMT_man_NofRings_Outside_mbias2[b] == 0)
@@ -1683,11 +1683,11 @@ void CbmKresConversionManualmbias2::Mixing_Both()
     for (Int_t b = a + 1; b < nof_Both; b++) {
       if (EMT_man_Event_Both_mbias2[a] == EMT_man_Event_Both_mbias2[b])
         continue;  // to make sure that the photons are from two different events
-      TVector3 e11                  = EMT_man_pair_momenta_Both_mbias2[a][0];
-      TVector3 e12                  = EMT_man_pair_momenta_Both_mbias2[a][1];
-      TVector3 e21                  = EMT_man_pair_momenta_Both_mbias2[b][0];
-      TVector3 e22                  = EMT_man_pair_momenta_Both_mbias2[b][1];
-      CbmLmvmKinematicParams params = CbmKresFunctions::CalculateKinematicParams_4particles(e11, e12, e21, e22);
+      TVector3 e11       = EMT_man_pair_momenta_Both_mbias2[a][0];
+      TVector3 e12       = EMT_man_pair_momenta_Both_mbias2[a][1];
+      TVector3 e21       = EMT_man_pair_momenta_Both_mbias2[b][0];
+      TVector3 e22       = EMT_man_pair_momenta_Both_mbias2[b][1];
+      LmvmKinePar params = CbmKresFunctions::CalculateKinematicParams_4particles(e11, e12, e21, e22);
 
       EMT_InvMass_all_Both_mbias2->Fill(params.fMinv);
       if (EMT_man_NofRings_Both_mbias2[a] == 0 && EMT_man_NofRings_Both_mbias2[b] == 0)
diff --git a/analysis/PWGDIL/dielectron/pi0eta/CbmKresConversionManualmbias3.cxx b/analysis/PWGDIL/dielectron/pi0eta/CbmKresConversionManualmbias3.cxx
index 4792a9b0ddd2cd1ca972103297092d99dd7e3fc4..e563a5ea2c8066a8cd4e69614f0e14c114bf64bc 100644
--- a/analysis/PWGDIL/dielectron/pi0eta/CbmKresConversionManualmbias3.cxx
+++ b/analysis/PWGDIL/dielectron/pi0eta/CbmKresConversionManualmbias3.cxx
@@ -1499,7 +1499,7 @@ void CbmKresConversionManualmbias3::FindPi0(TString mod, TString position, vecto
           || StsIndex[gamma1][1] == StsIndex[gamma2][0] || StsIndex[gamma1][1] == StsIndex[gamma2][1])
         continue;  // particles not used twice --> different
 
-      CbmLmvmKinematicParams params = CbmKresFunctions::CalculateKinematicParams_4particles(e11, e12, e21, e22);
+      LmvmKinePar params = CbmKresFunctions::CalculateKinematicParams_4particles(e11, e12, e21, e22);
 
       //Double_t OA1 = CbmKresFunctions::CalculateOpeningAngle_Reco(e11, e12);
       //Double_t OA2 = CbmKresFunctions::CalculateOpeningAngle_Reco(e21, e22);
@@ -1623,11 +1623,11 @@ void CbmKresConversionManualmbias3::Mixing_Target()
     for (Int_t b = a + 1; b < nof_Target; b++) {
       if (EMT_man_Event_Target_mbias3[a] == EMT_man_Event_Target_mbias3[b])
         continue;  // to make sure that the photons are from two different events
-      TVector3 e11                  = EMT_man_pair_momenta_Target_mbias3[a][0];
-      TVector3 e12                  = EMT_man_pair_momenta_Target_mbias3[a][1];
-      TVector3 e21                  = EMT_man_pair_momenta_Target_mbias3[b][0];
-      TVector3 e22                  = EMT_man_pair_momenta_Target_mbias3[b][1];
-      CbmLmvmKinematicParams params = CbmKresFunctions::CalculateKinematicParams_4particles(e11, e12, e21, e22);
+      TVector3 e11       = EMT_man_pair_momenta_Target_mbias3[a][0];
+      TVector3 e12       = EMT_man_pair_momenta_Target_mbias3[a][1];
+      TVector3 e21       = EMT_man_pair_momenta_Target_mbias3[b][0];
+      TVector3 e22       = EMT_man_pair_momenta_Target_mbias3[b][1];
+      LmvmKinePar params = CbmKresFunctions::CalculateKinematicParams_4particles(e11, e12, e21, e22);
 
       EMT_InvMass_all_Target_mbias3->Fill(params.fMinv);
       if (EMT_man_NofRings_Target_mbias3[a] == 0 && EMT_man_NofRings_Target_mbias3[b] == 0)
@@ -1653,11 +1653,11 @@ void CbmKresConversionManualmbias3::Mixing_Outside()
     for (Int_t b = a + 1; b < nof_Outside; b++) {
       if (EMT_man_Event_Outside_mbias3[a] == EMT_man_Event_Outside_mbias3[b])
         continue;  // to make sure that the photons are from two different events
-      TVector3 e11                  = EMT_man_pair_momenta_Outside_mbias3[a][0];
-      TVector3 e12                  = EMT_man_pair_momenta_Outside_mbias3[a][1];
-      TVector3 e21                  = EMT_man_pair_momenta_Outside_mbias3[b][0];
-      TVector3 e22                  = EMT_man_pair_momenta_Outside_mbias3[b][1];
-      CbmLmvmKinematicParams params = CbmKresFunctions::CalculateKinematicParams_4particles(e11, e12, e21, e22);
+      TVector3 e11       = EMT_man_pair_momenta_Outside_mbias3[a][0];
+      TVector3 e12       = EMT_man_pair_momenta_Outside_mbias3[a][1];
+      TVector3 e21       = EMT_man_pair_momenta_Outside_mbias3[b][0];
+      TVector3 e22       = EMT_man_pair_momenta_Outside_mbias3[b][1];
+      LmvmKinePar params = CbmKresFunctions::CalculateKinematicParams_4particles(e11, e12, e21, e22);
 
       EMT_InvMass_all_Outside_mbias3->Fill(params.fMinv);
       if (EMT_man_NofRings_Outside_mbias3[a] == 0 && EMT_man_NofRings_Outside_mbias3[b] == 0)
@@ -1683,11 +1683,11 @@ void CbmKresConversionManualmbias3::Mixing_Both()
     for (Int_t b = a + 1; b < nof_Both; b++) {
       if (EMT_man_Event_Both_mbias3[a] == EMT_man_Event_Both_mbias3[b])
         continue;  // to make sure that the photons are from two different events
-      TVector3 e11                  = EMT_man_pair_momenta_Both_mbias3[a][0];
-      TVector3 e12                  = EMT_man_pair_momenta_Both_mbias3[a][1];
-      TVector3 e21                  = EMT_man_pair_momenta_Both_mbias3[b][0];
-      TVector3 e22                  = EMT_man_pair_momenta_Both_mbias3[b][1];
-      CbmLmvmKinematicParams params = CbmKresFunctions::CalculateKinematicParams_4particles(e11, e12, e21, e22);
+      TVector3 e11       = EMT_man_pair_momenta_Both_mbias3[a][0];
+      TVector3 e12       = EMT_man_pair_momenta_Both_mbias3[a][1];
+      TVector3 e21       = EMT_man_pair_momenta_Both_mbias3[b][0];
+      TVector3 e22       = EMT_man_pair_momenta_Both_mbias3[b][1];
+      LmvmKinePar params = CbmKresFunctions::CalculateKinematicParams_4particles(e11, e12, e21, e22);
 
       EMT_InvMass_all_Both_mbias3->Fill(params.fMinv);
       if (EMT_man_NofRings_Both_mbias3[a] == 0 && EMT_man_NofRings_Both_mbias3[b] == 0)
diff --git a/analysis/PWGDIL/dielectron/pi0eta/CbmKresConversionManualmbias4.cxx b/analysis/PWGDIL/dielectron/pi0eta/CbmKresConversionManualmbias4.cxx
index 34083c772f3c44e3fceee3fca0f128e46898e001..784ec3a309bc6e6be2f8b52ca963abdc0e499cab 100644
--- a/analysis/PWGDIL/dielectron/pi0eta/CbmKresConversionManualmbias4.cxx
+++ b/analysis/PWGDIL/dielectron/pi0eta/CbmKresConversionManualmbias4.cxx
@@ -1499,7 +1499,7 @@ void CbmKresConversionManualmbias4::FindPi0(TString mod, TString position, vecto
           || StsIndex[gamma1][1] == StsIndex[gamma2][0] || StsIndex[gamma1][1] == StsIndex[gamma2][1])
         continue;  // particles not used twice --> different
 
-      CbmLmvmKinematicParams params = CbmKresFunctions::CalculateKinematicParams_4particles(e11, e12, e21, e22);
+      LmvmKinePar params = CbmKresFunctions::CalculateKinematicParams_4particles(e11, e12, e21, e22);
 
       //Double_t OA1 = CbmKresFunctions::CalculateOpeningAngle_Reco(e11, e12);
       //Double_t OA2 = CbmKresFunctions::CalculateOpeningAngle_Reco(e21, e22);
@@ -1623,11 +1623,11 @@ void CbmKresConversionManualmbias4::Mixing_Target()
     for (Int_t b = a + 1; b < nof_Target; b++) {
       if (EMT_man_Event_Target_mbias4[a] == EMT_man_Event_Target_mbias4[b])
         continue;  // to make sure that the photons are from two different events
-      TVector3 e11                  = EMT_man_pair_momenta_Target_mbias4[a][0];
-      TVector3 e12                  = EMT_man_pair_momenta_Target_mbias4[a][1];
-      TVector3 e21                  = EMT_man_pair_momenta_Target_mbias4[b][0];
-      TVector3 e22                  = EMT_man_pair_momenta_Target_mbias4[b][1];
-      CbmLmvmKinematicParams params = CbmKresFunctions::CalculateKinematicParams_4particles(e11, e12, e21, e22);
+      TVector3 e11       = EMT_man_pair_momenta_Target_mbias4[a][0];
+      TVector3 e12       = EMT_man_pair_momenta_Target_mbias4[a][1];
+      TVector3 e21       = EMT_man_pair_momenta_Target_mbias4[b][0];
+      TVector3 e22       = EMT_man_pair_momenta_Target_mbias4[b][1];
+      LmvmKinePar params = CbmKresFunctions::CalculateKinematicParams_4particles(e11, e12, e21, e22);
 
       EMT_InvMass_all_Target_mbias4->Fill(params.fMinv);
       if (EMT_man_NofRings_Target_mbias4[a] == 0 && EMT_man_NofRings_Target_mbias4[b] == 0)
@@ -1653,11 +1653,11 @@ void CbmKresConversionManualmbias4::Mixing_Outside()
     for (Int_t b = a + 1; b < nof_Outside; b++) {
       if (EMT_man_Event_Outside_mbias4[a] == EMT_man_Event_Outside_mbias4[b])
         continue;  // to make sure that the photons are from two different events
-      TVector3 e11                  = EMT_man_pair_momenta_Outside_mbias4[a][0];
-      TVector3 e12                  = EMT_man_pair_momenta_Outside_mbias4[a][1];
-      TVector3 e21                  = EMT_man_pair_momenta_Outside_mbias4[b][0];
-      TVector3 e22                  = EMT_man_pair_momenta_Outside_mbias4[b][1];
-      CbmLmvmKinematicParams params = CbmKresFunctions::CalculateKinematicParams_4particles(e11, e12, e21, e22);
+      TVector3 e11       = EMT_man_pair_momenta_Outside_mbias4[a][0];
+      TVector3 e12       = EMT_man_pair_momenta_Outside_mbias4[a][1];
+      TVector3 e21       = EMT_man_pair_momenta_Outside_mbias4[b][0];
+      TVector3 e22       = EMT_man_pair_momenta_Outside_mbias4[b][1];
+      LmvmKinePar params = CbmKresFunctions::CalculateKinematicParams_4particles(e11, e12, e21, e22);
 
       EMT_InvMass_all_Outside_mbias4->Fill(params.fMinv);
       if (EMT_man_NofRings_Outside_mbias4[a] == 0 && EMT_man_NofRings_Outside_mbias4[b] == 0)
@@ -1683,11 +1683,11 @@ void CbmKresConversionManualmbias4::Mixing_Both()
     for (Int_t b = a + 1; b < nof_Both; b++) {
       if (EMT_man_Event_Both_mbias4[a] == EMT_man_Event_Both_mbias4[b])
         continue;  // to make sure that the photons are from two different events
-      TVector3 e11                  = EMT_man_pair_momenta_Both_mbias4[a][0];
-      TVector3 e12                  = EMT_man_pair_momenta_Both_mbias4[a][1];
-      TVector3 e21                  = EMT_man_pair_momenta_Both_mbias4[b][0];
-      TVector3 e22                  = EMT_man_pair_momenta_Both_mbias4[b][1];
-      CbmLmvmKinematicParams params = CbmKresFunctions::CalculateKinematicParams_4particles(e11, e12, e21, e22);
+      TVector3 e11       = EMT_man_pair_momenta_Both_mbias4[a][0];
+      TVector3 e12       = EMT_man_pair_momenta_Both_mbias4[a][1];
+      TVector3 e21       = EMT_man_pair_momenta_Both_mbias4[b][0];
+      TVector3 e22       = EMT_man_pair_momenta_Both_mbias4[b][1];
+      LmvmKinePar params = CbmKresFunctions::CalculateKinematicParams_4particles(e11, e12, e21, e22);
 
       EMT_InvMass_all_Both_mbias4->Fill(params.fMinv);
       if (EMT_man_NofRings_Both_mbias4[a] == 0 && EMT_man_NofRings_Both_mbias4[b] == 0)
diff --git a/analysis/PWGDIL/dielectron/pi0eta/CbmKresConversionPhotons.cxx b/analysis/PWGDIL/dielectron/pi0eta/CbmKresConversionPhotons.cxx
index e0b9d82a2ec22ad207a2caae6b444298eb6ca749..17441145315efefb74d853a2cae570c856f2f8dc 100644
--- a/analysis/PWGDIL/dielectron/pi0eta/CbmKresConversionPhotons.cxx
+++ b/analysis/PWGDIL/dielectron/pi0eta/CbmKresConversionPhotons.cxx
@@ -841,9 +841,9 @@ void CbmKresConversionPhotons::FindGammasTarget(int EventNumMan, double AngleCut
       }
       int richcheck = richcheck_0 + richcheck_1;
 
-      Double_t InvmassReco          = CbmKresFunctions::Invmass_2particles_RECO(part1, part2);
-      Double_t OpeningAngle         = CbmKresFunctions::CalculateOpeningAngle_Reco(part1, part2);
-      CbmLmvmKinematicParams params = CbmKresFunctions::CalculateKinematicParamsReco(part1, part2);
+      Double_t InvmassReco  = CbmKresFunctions::Invmass_2particles_RECO(part1, part2);
+      Double_t OpeningAngle = CbmKresFunctions::CalculateOpeningAngle_Reco(part1, part2);
+      LmvmKinePar params    = CbmKresFunctions::CalculateKinematicParamsReco(part1, part2);
 
       DP_candidates_InvMass_vs_OA_Target->Fill(InvmassReco, OpeningAngle);
       DP_candidates_InvMass_vs_OA_Both->Fill(InvmassReco, OpeningAngle);
@@ -1428,9 +1428,9 @@ void CbmKresConversionPhotons::FindGammasOutside(
       }
 
 
-      Double_t InvmassReco          = CbmKresFunctions::Invmass_2particles_RECO(part1, part2);
-      Double_t OpeningAngle         = CbmKresFunctions::CalculateOpeningAngle_Reco(part1, part2);
-      CbmLmvmKinematicParams params = CbmKresFunctions::CalculateKinematicParamsReco(part1, part2);
+      Double_t InvmassReco  = CbmKresFunctions::Invmass_2particles_RECO(part1, part2);
+      Double_t OpeningAngle = CbmKresFunctions::CalculateOpeningAngle_Reco(part1, part2);
+      LmvmKinePar params    = CbmKresFunctions::CalculateKinematicParamsReco(part1, part2);
 
       DP_candidates_InvMass_vs_OA_Outside->Fill(InvmassReco, OpeningAngle);
       DP_candidates_InvMass_vs_OA_Both->Fill(InvmassReco, OpeningAngle);
@@ -2354,7 +2354,7 @@ void CbmKresConversionPhotons::DP_likesign_Mixing_Target(double AngleCut, double
       if (TMath::Abs(InvmassReco) > InvMassCut) continue;
       // if (AnnValue < 0.9 || AnnValue > 1.1) continue;
 
-      CbmLmvmKinematicParams params = CbmKresFunctions::CalculateKinematicParamsReco(e1, e2);
+      LmvmKinePar params = CbmKresFunctions::CalculateKinematicParamsReco(e1, e2);
 
       int rings_amount = DP_LK_EMT_NofRings_minus_Target[a] + DP_LK_EMT_NofRings_minus_Target[b];
 
@@ -2393,7 +2393,7 @@ void CbmKresConversionPhotons::DP_likesign_Mixing_Target(double AngleCut, double
       if (TMath::Abs(InvmassReco) > InvMassCut) continue;
       // if (AnnValue < 0.9 || AnnValue > 1.1) continue;
 
-      CbmLmvmKinematicParams params = CbmKresFunctions::CalculateKinematicParamsReco(e1, e2);
+      LmvmKinePar params = CbmKresFunctions::CalculateKinematicParamsReco(e1, e2);
 
       int rings_amount = DP_LK_EMT_NofRings_plus_Target[a] + DP_LK_EMT_NofRings_plus_Target[b];
 
@@ -2446,7 +2446,7 @@ void CbmKresConversionPhotons::DP_likesign_Mixing_Outside(double AngleCut, doubl
       if (TMath::Abs(InvmassReco) > InvMassCut) continue;
       // if (AnnValue < 0.9 || AnnValue > 1.1) continue;
 
-      CbmLmvmKinematicParams params = CbmKresFunctions::CalculateKinematicParamsReco(e1, e2);
+      LmvmKinePar params = CbmKresFunctions::CalculateKinematicParamsReco(e1, e2);
 
       int rings_amount = DP_LK_EMT_NofRings_minus_Outside[a] + DP_LK_EMT_NofRings_minus_Outside[b];
 
@@ -2496,7 +2496,7 @@ void CbmKresConversionPhotons::DP_likesign_Mixing_Outside(double AngleCut, doubl
       if (TMath::Abs(InvmassReco) > InvMassCut) continue;
       // if (AnnValue < 0.9 || AnnValue > 1.1) continue;
 
-      CbmLmvmKinematicParams params = CbmKresFunctions::CalculateKinematicParamsReco(e1, e2);
+      LmvmKinePar params = CbmKresFunctions::CalculateKinematicParamsReco(e1, e2);
 
       int rings_amount = DP_LK_EMT_NofRings_plus_Outside[a] + DP_LK_EMT_NofRings_plus_Outside[b];
 
@@ -2542,8 +2542,8 @@ void CbmKresConversionPhotons::DP_Mixing_Target(double AngleCut, double InvMassC
       if (TMath::Abs(InvmassReco) > InvMassCut) continue;
       // if (AnnValue < 0.9 || AnnValue > 1.1) continue;
 
-      CbmLmvmKinematicParams params = CbmKresFunctions::CalculateKinematicParamsReco(e1, e2);
-      int rings_amount              = DP_EMT_NofRings_minus_Target[a] + DP_EMT_NofRings_plus_Target[b];
+      LmvmKinePar params = CbmKresFunctions::CalculateKinematicParamsReco(e1, e2);
+      int rings_amount   = DP_EMT_NofRings_minus_Target[a] + DP_EMT_NofRings_plus_Target[b];
 
       DP_EMT_Pt_all_Target->Fill(params.fPt);
       DP_EMT_Pt_all_Both->Fill(params.fPt);
@@ -2609,8 +2609,8 @@ void CbmKresConversionPhotons::DP_Mixing_Outside(double AngleCut, double InvMass
       if (TMath::Abs(InvmassReco) > InvMassCut) continue;
       // if (AnnValue < 0.9 || AnnValue > 1.1) continue;
 
-      CbmLmvmKinematicParams params = CbmKresFunctions::CalculateKinematicParamsReco(e1, e2);
-      int rings_amount              = DP_EMT_NofRings_minus_Outside[a] + DP_EMT_NofRings_plus_Outside[b];
+      LmvmKinePar params = CbmKresFunctions::CalculateKinematicParamsReco(e1, e2);
+      int rings_amount   = DP_EMT_NofRings_minus_Outside[a] + DP_EMT_NofRings_plus_Outside[b];
 
       DP_EMT_Pt_all_Outside->Fill(params.fPt);
       DP_EMT_Pt_all_Both->Fill(params.fPt);
diff --git a/analysis/PWGDIL/dielectron/pi0eta/CbmKresConversionPhotons.h b/analysis/PWGDIL/dielectron/pi0eta/CbmKresConversionPhotons.h
index 2efda1086503deb996ceee608bac696af401fe45..8b3180e5f6c3055efe16ae47a796d5ccedc9e86d 100644
--- a/analysis/PWGDIL/dielectron/pi0eta/CbmKresConversionPhotons.h
+++ b/analysis/PWGDIL/dielectron/pi0eta/CbmKresConversionPhotons.h
@@ -8,7 +8,6 @@
 #include "CbmKFVertex.h"
 #include "CbmKresSelectAnnPhotons.h"
 #include "CbmKresTrainAnnDirectPhotons.h"
-#include "CbmLmvmKinematicParams.h"
 #include "CbmMCTrack.h"
 #include "CbmRichRing.h"
 #include "CbmRichRingFitterEllipseTau.h"
@@ -19,6 +18,7 @@
 #include <TClonesArray.h>
 
 #include "KFParticle.h"
+#include "LmvmKinePar.h"
 
 class CbmRichRingFitterEllipseTau;
 
diff --git a/analysis/PWGDIL/dielectron/pi0eta/CbmKresEta.cxx b/analysis/PWGDIL/dielectron/pi0eta/CbmKresEta.cxx
index f394e907027e90b580620653a6f8c3bf89ae36f6..615816c436ac5b94a8571128838bd0138d7b7d37 100644
--- a/analysis/PWGDIL/dielectron/pi0eta/CbmKresEta.cxx
+++ b/analysis/PWGDIL/dielectron/pi0eta/CbmKresEta.cxx
@@ -1061,11 +1061,11 @@ void CbmKresEta::FindGammasTarget(int EventNumEta, double AngleCut, double InvMa
       }
       int richcheck = richcheck_0 + richcheck_1;
 
-      double InvmassReco            = CbmKresFunctions::Invmass_2particles_RECO(part1, part2);
-      double OpeningAngle           = CbmKresFunctions::CalculateOpeningAngle_Reco(part1, part2);
-      double PlaneAngle_last        = CalculatePlaneAngle_last(sts1, sts2);
-      double PlaneAngle_first       = CalculatePlaneAngle_first(sts1, sts2);
-      CbmLmvmKinematicParams params = CbmKresFunctions::CalculateKinematicParamsReco(part1, part2);
+      double InvmassReco      = CbmKresFunctions::Invmass_2particles_RECO(part1, part2);
+      double OpeningAngle     = CbmKresFunctions::CalculateOpeningAngle_Reco(part1, part2);
+      double PlaneAngle_last  = CalculatePlaneAngle_last(sts1, sts2);
+      double PlaneAngle_first = CalculatePlaneAngle_first(sts1, sts2);
+      LmvmKinePar params      = CbmKresFunctions::CalculateKinematicParamsReco(part1, part2);
 
       int TruePair =
         0;  //correctly reconstructed photon from eta meson:          0 - means wrong pair combination; 		1 - means correct pair
@@ -1299,11 +1299,11 @@ void CbmKresEta::FindGammasOutside(int EventNumEta, double AngleCut, double InvM
         richcheck = Rings_minus_Outside[i] + Rings_plus_Outside[j];
       }
 
-      double InvmassReco            = CbmKresFunctions::Invmass_2particles_RECO(part1, part2);
-      double OpeningAngle           = CbmKresFunctions::CalculateOpeningAngle_Reco(part1, part2);
-      double PlaneAngle_last        = CalculatePlaneAngle_last(sts1, sts2);
-      double PlaneAngle_first       = CalculatePlaneAngle_first(sts1, sts2);
-      CbmLmvmKinematicParams params = CbmKresFunctions::CalculateKinematicParamsReco(part1, part2);
+      double InvmassReco      = CbmKresFunctions::Invmass_2particles_RECO(part1, part2);
+      double OpeningAngle     = CbmKresFunctions::CalculateOpeningAngle_Reco(part1, part2);
+      double PlaneAngle_last  = CalculatePlaneAngle_last(sts1, sts2);
+      double PlaneAngle_first = CalculatePlaneAngle_first(sts1, sts2);
+      LmvmKinePar params      = CbmKresFunctions::CalculateKinematicParamsReco(part1, part2);
 
       int TruePair =
         0;  //correctly reconstructed photon from eta meson:          0 - means wrong pair combination; 		1 - means correct pair
@@ -1553,7 +1553,7 @@ void CbmKresEta::FindEta(TString /*mod*/, TString position, vector<vector<TVecto
           || StsIndex[gamma1][1] == StsIndex[gamma2][0] || StsIndex[gamma1][1] == StsIndex[gamma2][1])
         continue;  // particles are not used twice --> different
 
-      CbmLmvmKinematicParams params = CbmKresFunctions::CalculateKinematicParams_4particles(e11, e12, e21, e22);
+      LmvmKinePar params = CbmKresFunctions::CalculateKinematicParams_4particles(e11, e12, e21, e22);
       double openingAngleBetweenGammasReco =
         CbmKresFunctions::CalculateOpeningAngleBetweenGammas_Reco(e11, e12, e21, e22);
 
@@ -1668,11 +1668,11 @@ void CbmKresEta::Mixing_Target()
     for (Int_t b = a + 1; b < nof_Target; b++) {
       if (EMT_eta_gg_Event_Target[a] == EMT_eta_gg_Event_Target[b])
         continue;  // to make sure that the photons are from two different events
-      TVector3 e11                  = EMT_eta_gg_pair_momenta_Target[a][0];
-      TVector3 e12                  = EMT_eta_gg_pair_momenta_Target[a][1];
-      TVector3 e21                  = EMT_eta_gg_pair_momenta_Target[b][0];
-      TVector3 e22                  = EMT_eta_gg_pair_momenta_Target[b][1];
-      CbmLmvmKinematicParams params = CbmKresFunctions::CalculateKinematicParams_4particles(e11, e12, e21, e22);
+      TVector3 e11       = EMT_eta_gg_pair_momenta_Target[a][0];
+      TVector3 e12       = EMT_eta_gg_pair_momenta_Target[a][1];
+      TVector3 e21       = EMT_eta_gg_pair_momenta_Target[b][0];
+      TVector3 e22       = EMT_eta_gg_pair_momenta_Target[b][1];
+      LmvmKinePar params = CbmKresFunctions::CalculateKinematicParams_4particles(e11, e12, e21, e22);
       double openingAngleBetweenGammasReco =
         CbmKresFunctions::CalculateOpeningAngleBetweenGammas_Reco(e11, e12, e21, e22);
       if (openingAngleBetweenGammasReco < 10 || openingAngleBetweenGammasReco > 40) continue;
@@ -1697,11 +1697,11 @@ void CbmKresEta::Mixing_Outside()
     for (Int_t b = a + 1; b < nof_Outside; b++) {
       if (EMT_eta_gg_Event_Outside[a] == EMT_eta_gg_Event_Outside[b])
         continue;  // to make sure that the photons are from two different events
-      TVector3 e11                  = EMT_eta_gg_pair_momenta_Outside[a][0];
-      TVector3 e12                  = EMT_eta_gg_pair_momenta_Outside[a][1];
-      TVector3 e21                  = EMT_eta_gg_pair_momenta_Outside[b][0];
-      TVector3 e22                  = EMT_eta_gg_pair_momenta_Outside[b][1];
-      CbmLmvmKinematicParams params = CbmKresFunctions::CalculateKinematicParams_4particles(e11, e12, e21, e22);
+      TVector3 e11       = EMT_eta_gg_pair_momenta_Outside[a][0];
+      TVector3 e12       = EMT_eta_gg_pair_momenta_Outside[a][1];
+      TVector3 e21       = EMT_eta_gg_pair_momenta_Outside[b][0];
+      TVector3 e22       = EMT_eta_gg_pair_momenta_Outside[b][1];
+      LmvmKinePar params = CbmKresFunctions::CalculateKinematicParams_4particles(e11, e12, e21, e22);
       double openingAngleBetweenGammasReco =
         CbmKresFunctions::CalculateOpeningAngleBetweenGammas_Reco(e11, e12, e21, e22);
       if (openingAngleBetweenGammasReco < 10 || openingAngleBetweenGammasReco > 40) continue;
@@ -1726,11 +1726,11 @@ void CbmKresEta::Mixing_Both(vector<TH1*> rap_pt_separation_all, vector<TH1*> ra
     for (Int_t b = a + 1; b < nof_Both; b++) {
       if (EMT_eta_gg_Event_Both[a] == EMT_eta_gg_Event_Both[b])
         continue;  // to make sure that the photons are from two different events
-      TVector3 e11                  = EMT_eta_gg_pair_momenta_Both[a][0];
-      TVector3 e12                  = EMT_eta_gg_pair_momenta_Both[a][1];
-      TVector3 e21                  = EMT_eta_gg_pair_momenta_Both[b][0];
-      TVector3 e22                  = EMT_eta_gg_pair_momenta_Both[b][1];
-      CbmLmvmKinematicParams params = CbmKresFunctions::CalculateKinematicParams_4particles(e11, e12, e21, e22);
+      TVector3 e11       = EMT_eta_gg_pair_momenta_Both[a][0];
+      TVector3 e12       = EMT_eta_gg_pair_momenta_Both[a][1];
+      TVector3 e21       = EMT_eta_gg_pair_momenta_Both[b][0];
+      TVector3 e22       = EMT_eta_gg_pair_momenta_Both[b][1];
+      LmvmKinePar params = CbmKresFunctions::CalculateKinematicParams_4particles(e11, e12, e21, e22);
       double openingAngleBetweenGammasReco =
         CbmKresFunctions::CalculateOpeningAngleBetweenGammas_Reco(e11, e12, e21, e22);
       if (openingAngleBetweenGammasReco < 10 || openingAngleBetweenGammasReco > 40) continue;
diff --git a/analysis/PWGDIL/dielectron/pi0eta/CbmKresEtaMCAnalysis.cxx b/analysis/PWGDIL/dielectron/pi0eta/CbmKresEtaMCAnalysis.cxx
index a6fa367a31a9784be8e8a29aee2576646a306330..f1bdb5dee59542ae6fe3208ec32f900d41863d95 100644
--- a/analysis/PWGDIL/dielectron/pi0eta/CbmKresEtaMCAnalysis.cxx
+++ b/analysis/PWGDIL/dielectron/pi0eta/CbmKresEtaMCAnalysis.cxx
@@ -854,9 +854,9 @@ void CbmKresEtaMCAnalysis::EtaDoubleGammaAnalysis_plusBG(double OpeningAngleCut,
       double openingAngleBetweenGammasReco = CalculateOpeningAngleBetweenGammas_Reco(e11, e12, e21, e22);
       if (openingAngleBetweenGammasReco < 10 || openingAngleBetweenGammasReco > 40) continue;
 
-      double InvMass_true           = CbmKresFunctions::Invmass_4particles_MC(mcTrack1, mcTrack2, mcTrack3, mcTrack4);
-      double InvMass_reco           = CbmKresFunctions::Invmass_4particles_RECO(e11, e12, e21, e22);
-      CbmLmvmKinematicParams params = CbmKresFunctions::CalculateKinematicParams_4particles(e11, e12, e21, e22);
+      double InvMass_true = CbmKresFunctions::Invmass_4particles_MC(mcTrack1, mcTrack2, mcTrack3, mcTrack4);
+      double InvMass_reco = CbmKresFunctions::Invmass_4particles_RECO(e11, e12, e21, e22);
+      LmvmKinePar params  = CbmKresFunctions::CalculateKinematicParams_4particles(e11, e12, e21, e22);
 
       gg[8]->Fill(InvMass_true);
       gg[9]->Fill(InvMass_reco);
@@ -1023,9 +1023,9 @@ void CbmKresEtaMCAnalysis::EtaChargedPionsGammaAnalysis_plusBG(double OpeningAng
       TVector3 e21 = ECPGA_pions_RefMom[pionpair][0];
       TVector3 e22 = ECPGA_pions_RefMom[pionpair][1];
 
-      Double_t InvMass_true         = CbmKresFunctions::Invmass_4particles_MC(mcTrack1, mcTrack2, mcTrack3, mcTrack4);
-      Double_t InvMass_reco         = CbmKresFunctions::Invmass_2el_2pions_RECO(e11, e12, e21, e22);
-      CbmLmvmKinematicParams params = CbmKresFunctions::CalculateKinematicParams_2el_2pions(e11, e12, e21, e22);
+      Double_t InvMass_true = CbmKresFunctions::Invmass_4particles_MC(mcTrack1, mcTrack2, mcTrack3, mcTrack4);
+      Double_t InvMass_reco = CbmKresFunctions::Invmass_2el_2pions_RECO(e11, e12, e21, e22);
+      LmvmKinePar params    = CbmKresFunctions::CalculateKinematicParams_2el_2pions(e11, e12, e21, e22);
 
       ppg[6]->Fill(InvMass_true);
       ppg[7]->Fill(InvMass_reco);
@@ -1122,7 +1122,7 @@ void CbmKresEtaMCAnalysis::Mixing_gg()
       double openingAngleBetweenGammasReco = CalculateOpeningAngleBetweenGammas_Reco(e11, e12, e21, e22);
       if (openingAngleBetweenGammasReco < 10 || openingAngleBetweenGammasReco > 40) continue;
 
-      CbmLmvmKinematicParams params = CbmKresFunctions::CalculateKinematicParams_4particles(e11, e12, e21, e22);
+      LmvmKinePar params = CbmKresFunctions::CalculateKinematicParams_4particles(e11, e12, e21, e22);
       EMT_eta_gg->Fill(params.fMinv);
     }
   }
@@ -1143,7 +1143,7 @@ void CbmKresEtaMCAnalysis::Mixing_ppg()
       TVector3 e21 = EMT_ppg_pp_pair_momenta[b][0];
       TVector3 e22 = EMT_ppg_pp_pair_momenta[b][1];
 
-      CbmLmvmKinematicParams params = CbmKresFunctions::CalculateKinematicParams_2el_2pions(e11, e12, e21, e22);
+      LmvmKinePar params = CbmKresFunctions::CalculateKinematicParams_2el_2pions(e11, e12, e21, e22);
       EMT_eta_ppg->Fill(params.fMinv);
     }
   }
@@ -1175,7 +1175,7 @@ void CbmKresEtaMCAnalysis::Mixing_three_body()
         TVector3 e11 = EMT_ppg_ee_pair_momenta[a][0];
         TVector3 e12 = EMT_ppg_ee_pair_momenta[a][1];
 
-        CbmLmvmKinematicParams params = CbmKresFunctions::CalculateKinematicParams_2el_2pions(e11, e12, e21, e22);
+        LmvmKinePar params = CbmKresFunctions::CalculateKinematicParams_2el_2pions(e11, e12, e21, e22);
         EMT_eta_three_body->Fill(params.fMinv);
       }
     }
diff --git a/analysis/PWGDIL/dielectron/pi0eta/CbmKresFunctions.h b/analysis/PWGDIL/dielectron/pi0eta/CbmKresFunctions.h
index c16ca941134f46b51a08ed447935ce0aade9c18b..c263538cc2735239217bc31ad43e04602a61b632 100644
--- a/analysis/PWGDIL/dielectron/pi0eta/CbmKresFunctions.h
+++ b/analysis/PWGDIL/dielectron/pi0eta/CbmKresFunctions.h
@@ -14,7 +14,6 @@
 #define CBM_KRES_FUNCTIONS
 
 #include "CbmGlobalTrack.h"
-#include "CbmLmvmKinematicParams.h"
 #include "CbmMCTrack.h"
 #include "CbmStsKFTrackFitter.h"
 #include "CbmVertex.h"
@@ -24,6 +23,8 @@
 #include "TMatrixTSym.h"
 #include "TVector3.h"
 
+#include "LmvmKinePar.h"
+
 #define M2E 2.6112004954086e-7
 #define M2Pion 0.0194798351452
 
@@ -177,9 +178,9 @@ public:
 
 
   // calculation of many interesting for analysis physics parameters of 2 tracks: Invariant mass, opening angle, rapidity, pt,
-  static CbmLmvmKinematicParams CalculateKinematicParamsReco(const TVector3 electron1, const TVector3 electron2)
+  static LmvmKinePar CalculateKinematicParamsReco(const TVector3 electron1, const TVector3 electron2)
   {
-    CbmLmvmKinematicParams params;
+    LmvmKinePar params;
 
     Double_t energyP = TMath::Sqrt(electron1.Mag2() + M2E);
     TLorentzVector lorVecP(electron1, energyP);
@@ -206,10 +207,10 @@ public:
 
 
   // calculation of many interesting for analysis physics parameters of 4 tracks: Invariant mass, opening angle, rapidity, pt,
-  static CbmLmvmKinematicParams CalculateKinematicParams_4particles(const TVector3 part1, const TVector3 part2,
-                                                                    const TVector3 part3, const TVector3 part4)
+  static LmvmKinePar CalculateKinematicParams_4particles(const TVector3 part1, const TVector3 part2,
+                                                         const TVector3 part3, const TVector3 part4)
   {
-    CbmLmvmKinematicParams params;
+    LmvmKinePar params;
 
     Double_t energy1 = TMath::Sqrt(part1.Mag2() + M2E);
     TLorentzVector lorVec1(part1, energy1);
@@ -422,10 +423,10 @@ public:
 
 
   // calculation of many interesting for analysis physics parameters of 2 leptons and 2 pions: Invariant mass, opening angle, rapidity, pt,
-  static CbmLmvmKinematicParams CalculateKinematicParams_2el_2pions(const TVector3 part1, const TVector3 part2,
-                                                                    const TVector3 part3, const TVector3 part4)
+  static LmvmKinePar CalculateKinematicParams_2el_2pions(const TVector3 part1, const TVector3 part2,
+                                                         const TVector3 part3, const TVector3 part4)
   {
-    CbmLmvmKinematicParams params;
+    LmvmKinePar params;
 
     Double_t energy1 = TMath::Sqrt(part1.Mag2() + M2E);
     TLorentzVector lorVec1(part1, energy1);