Tentative changes for new base class AtFittedTrack.

AtData/AtDataLinkDef.h

@@ -43,5 +43,12 @@
 #pragma link C++ enum AtPatterns::PatternType;
 #pragma link C++ function AtPatterns::CreatePattern;
 
+#pragma link C++ class AtFitMetadata + ;
+#pragma link C++ class AtFitTrackMetadata + ;
 #pragma link C++ class MCFitter::AtMCResult + ;
+
+#pragma link C++ class AtTrackingEventOld + ;
+#pragma link C++ class AtFittedTrackOld + ;
+#pragma link C++ class MCFitter::AtMCResultOld + ;
+
 #endif

AtData/AtFitMetadata.cxx

@@ -0,0 +1,3 @@
+#include "AtFitMetadata.h"
+
+ClassImp(AtFitMetadata);

AtData/AtFitMetadata.h

@@ -0,0 +1,58 @@
+#ifndef ATFITMETADATA_H
+#define ATFITMETADATA_H
+
+#include "AtFitTrackMetadata.h"
+
+#include <FairLogger.h>
+
+#include <Rtypes.h> // for Double_t, THashConsistencyHolder, ClassDefOverride
+#include <TObject.h>
+
+#include <functional>
+#include <map>
+#include <memory>
+#include <utility>
+
+class TBuffer;
+class TClass;
+class TMemberInspector;
+
+/**
+ * Class for storing the result of the fit for the entire AtTrackingEvent from an AtFitter class.
+ */
+class AtFitMetadata : public TObject {
+public:
+   using TrackMetadataPtr = std::unique_ptr<AtFitTrackMetadata>;
+   using TrackMetadatasVector = std::vector<TrackMetadataPtr>;
+   using MetadatasMap = std::map<Int_t, TrackMetadatasVector>;
+
+protected:
+   /**
+    * Map to store the metadatas for all different fits done to all tracks in the event.
+    * The Int_t corresponds to the trackID for which the metadatas correspond to.
+    * The vector of AtFitTrackMetadata contains the different metadatas for all fits
+    * that have been done for the track (for example, different assumptions for the
+    * particles of the track, different initial conditions, etc...).
+    */
+   MetadatasMap fMetadatas;
+
+   // Event ID for which this fit was done.
+   ULong_t fEventID;
+
+public:
+   AtFitMetadata() = default;
+   ~AtFitMetadata() = default;
+
+   void SetTrackMetadatasVector(Int_t trackID, TrackMetadatasVector metadatas)
+   {
+      fMetadatas.insert({trackID, std::move(metadatas)});
+   }
+
+   void SetEventID(ULong_t id) { fEventID = id; }
+
+   TrackMetadatasVector &GetTrackMetadatasVector(Int_t trackID) { return fMetadatas.at(trackID); }
+
+   ClassDefOverride(AtFitMetadata, 1);
+};
+
+#endif

AtData/AtFitTrackMetadata.cxx

@@ -0,0 +1,16 @@
+#include "AtFitTrackMetadata.h"
+
+#include <iostream>
+ClassImp(AtFitTrackMetadata);
+
+void AtFitTrackMetadata::Print() const
+
+{
+   std::cout << " Fit metadata for track with ID " << fTrackID << ":" << std::endl;
+
+   std::cout << " Statistics: " << std::endl;
+   std::cout << "   PValue    = " << fPValue << std::endl;
+   std::cout << "   Chi2      = " << fChi2 << std::endl;
+   std::cout << "   NDF       = " << fNdf << std::endl;
+   std::cout << "   Converged = " << fFitConverged << std::endl;
+}

AtData/AtFitTrackMetadata.h

@@ -0,0 +1,46 @@
+#ifndef ATFITTRACKMETADATA_H
+#define ATFITTRACKMETADATA_H
+
+#include <Rtypes.h> // for Double_t, THashConsistencyHolder, ClassDefOverride
+#include <TObject.h>
+
+class TBuffer;
+class TClass;
+class TMemberInspector;
+
+/**
+ * Class for storing the result of the fit of an AtTrack from an AtFitter class.
+ */
+class AtFitTrackMetadata : public TObject {
+protected:
+   // Statistics parameters of the fit.
+   Double_t fPValue{0};
+   Double_t fChi2{0};
+   Int_t fNdf{0};
+   Bool_t fFitConverged{false};
+
+   // The track ID for which this fit was done for.
+   Int_t fTrackID{-1};
+
+public:
+   AtFitTrackMetadata() = default;
+   ~AtFitTrackMetadata() = default;
+
+   void SetPValue(Double_t value) { fPValue = value; }
+   void SetChi2(Double_t value) { fChi2 = value; }
+   void SetNdf(Int_t value) { fNdf = value; }
+   void SetFitConverged(Bool_t value) { fFitConverged = value; }
+   void SetTrackID(Int_t value) { fTrackID = value; }
+
+   Double_t GetPValue() const { return fPValue; }
+   Double_t GetChi2() const { return fChi2; }
+   Int_t GetNdf() const { return fNdf; }
+   Bool_t GetFitConverged() const { return fFitConverged; }
+   Int_t GetTrackID() const { return fTrackID; }
+
+   virtual void Print() const;
+
+   ClassDefOverride(AtFitTrackMetadata, 1);
+};
+
+#endif

AtData/AtFittedTrack.cxx

@@ -1,45 +1,49 @@
 #include "AtFittedTrack.h"
 
-#include <Rtypes.h>
-
-#include <iterator>
-#include <numeric>
-
 ClassImp(AtFittedTrack);
 
-using XYZVector = ROOT::Math::XYZVector;
-
-const std::tuple<Float_t, Float_t, Float_t, Float_t, Float_t, Float_t, Float_t> AtFittedTrack::GetEnergyAngles()
-{
-   return std::forward_as_tuple(fEnergy, fEnergyXtr, fTheta, fPhi, fEnergyPRA, fThetaPRA, fPhiPRA);
-}
-
-const std::tuple<XYZVector, XYZVector, XYZVector> AtFittedTrack::GetVertices()
+void AtFittedTrack::SetKinematics(int particleIdx, Double_t energy, Double_t theta, Double_t phi)
 {
-   return std::forward_as_tuple(fInitialPos, fInitialPosPRA, fInitialPosXtr);
+   while (particleIdx >= fKinematics.size()) {
+      Kinematics newKinematics;
+      fKinematics.push_back(newKinematics);
+   }
+
+   fKinematics[particleIdx].kineticEnergy = energy;
+   fKinematics[particleIdx].theta = theta;
+   fKinematics[particleIdx].phi = phi;
 }
 
-const std::tuple<Float_t, Float_t, Float_t, Float_t, Float_t, Bool_t> AtFittedTrack::GetStats()
+void AtFittedTrack::SetKinematicsXtr(int particleIdx, Double_t energyxtr, Double_t thetaxtr, Double_t phixtr)
 {
-   return std::forward_as_tuple(fPValue, fChi2, fBChi2, fNdf, fBNdf, fFitConverged);
+   while (particleIdx >= fKinematicsXtr.size()) {
+      Kinematics newKinematics;
+      fKinematicsXtr.push_back(newKinematics);
+   }
+
+   fKinematicsXtr[particleIdx].kineticEnergy = energyxtr;
+   fKinematicsXtr[particleIdx].theta = thetaxtr;
+   fKinematicsXtr[particleIdx].phi = phixtr;
 }
 
-const std::tuple<Int_t, Float_t, Float_t, Float_t, std::string, Int_t> AtFittedTrack::GetTrackProperties()
+void AtFittedTrack::SetParticleInfo(int particleIdx, std::string pdg, Int_t charge, Double_t mass)
 {
-   return std::forward_as_tuple(fCharge, fBrho, fELossADC, fDEdxADC, fPDG, fTrackPoints);
+   while (particleIdx >= fParticleInfo.size()) {
+      ParticleInfo newParticleInfo;
+      fParticleInfo.push_back(newParticleInfo);
+   }
+
+   fParticleInfo[particleIdx].idPDG = TString(pdg);
+   fParticleInfo[particleIdx].charge = charge;
+   fParticleInfo[particleIdx].mass = mass;
 }
 
-const std::tuple<Float_t, Float_t> AtFittedTrack::GetIonChamber()
+void AtFittedTrack::SetVertex(int particleIdx, XYZVector point)
 {
-   return std::forward_as_tuple(fIonChamberEnergy, fIonChamberTime);
-}
+   while (particleIdx >= fVertex.size()) {
+      XYZVector newVertex;
+      fVertex.push_back(newVertex);
+   }
 
-const std::tuple<Float_t, Float_t> AtFittedTrack::GetExcitationEnergy()
-{
-   return std::forward_as_tuple(fExcitationEnergy, fExcitationEnergyXtr);
+   fVertex[particleIdx] = point;
 }
-
-const std::tuple<Float_t, Float_t, Float_t> AtFittedTrack::GetDistances()
-{
-   return std::forward_as_tuple(fDistanceXtr, fTrackLength, fPOCAXtr);
-}