Rcnp analysis branch

AtData/AtBraggFitMetadata.cxx

@@ -0,0 +1,23 @@
+#include "AtBraggFitMetadata.h"
+
+#include <iostream>
+ClassImp(AtBraggFitMetadata);
+
+std::unique_ptr<AtFitTrackMetadata> AtBraggFitMetadata::Clone()
+{
+   return std::make_unique<AtBraggFitMetadata>(*this);
+}
+
+void AtBraggFitMetadata::Print() const
+{
+   AtFitTrackMetadata::Print();
+
+   std::cout << " Bragg fitting specifics: " << std::endl;
+   std::cout << "   Punched through? " << fIsPunchThrough << std::endl;
+   std::cout << "   Reconstructed ELoss profile? " << fIsReconstructedELoss << std::endl;
+   std::cout << "   ELoss model name: " << fELossModelName.Data() << std::endl;
+   std::cout << "   Particle: (A, Z) = (" << fA << ", " << fZ << "), mass = " << fMassAmu << " umas" << std::endl;
+   std::cout << "   KineticEnergy = (" << fKineticEnergy << " +- " << fKineticEnergyUncertainty << ") MeV" << std::endl;
+   std::cout << "   AmplitudeFactor = (" << fAmplitudeFactor << " +- " << fAmplitudeFactorUncertainty << ") ADC/MeV"
+             << std::endl;
+}

AtData/AtBraggFitMetadata.h

@@ -0,0 +1,81 @@
+#ifndef ATBRAGGFITMETADATA_H
+#define ATBRAGGFITMETADATA_H
+
+#include "AtFitTrackMetadata.h"
+
+#include <Rtypes.h> // for Double_t, THashConsistencyHolder, ClassDefOverride
+#include <TObject.h>
+#include <TString.h>
+
+class TBuffer;
+class TClass;
+class TMemberInspector;
+
+/**
+ * Class for storing the result of the fit of an AtTrack from an AtFitter class.
+ */
+class AtBraggFitMetadata : public AtFitTrackMetadata {
+protected:
+   // Parameters of the fit and name of the ELoss model used.
+   TString fELossModelName{"none"};
+   Double_t fKineticEnergy{-1};              // MeV
+   Double_t fKineticEnergyUncertainty{-1};   // MeV
+   Double_t fAmplitudeFactor{-1};            // ADC/MeV
+   Double_t fAmplitudeFactorUncertainty{-1}; // ADC/MeV
+
+   // Particle information.
+   TString fPDGCode{"none"};
+   Int_t fA{0};
+   Int_t fZ{0};
+   Double_t fMassAmu{0};
+
+   // The ELoss profile that best fits the experimental Bragg curve. Stored here for quick access on the Bragg curve tab
+   // of the viewer for example.
+   std::vector<std::pair<Double_t, Double_t>> fELossFitValues;
+
+   // Parameter to store whether or not the track punched through. Most likely, yes.
+   Bool_t fIsPunchThrough{kTRUE};
+
+   // Sometimes, the experimental Bragg curve values could not be reconstructed (vertex not found for example).
+   Bool_t fIsReconstructedELoss{kFALSE};
+
+public:
+   AtBraggFitMetadata() = default;
+   AtBraggFitMetadata(const AtBraggFitMetadata &) = default;
+   AtBraggFitMetadata(AtBraggFitMetadata &&) = default;
+   ~AtBraggFitMetadata() = default;
+
+   virtual std::unique_ptr<AtFitTrackMetadata> Clone() override;
+
+   void SetELossModelName(std::string name) { fELossModelName = TString(name); }
+   void SetKineticEnergy(Double_t value) { fKineticEnergy = value; }
+   void SetKineticEnergyUncertainty(Double_t value) { fKineticEnergyUncertainty = value; }
+   void SetAmplitudeFactor(Double_t value) { fAmplitudeFactor = value; }
+   void SetAmplitudeFactorUncertainty(Double_t value) { fAmplitudeFactorUncertainty = value; }
+   void SetPDGCode(std::string value) { fPDGCode = TString(value); }
+   void SetAtomicMassNumber(Int_t value) { fA = value; }
+   void SetChargeNumber(Int_t value) { fZ = value; }
+   void SetMassAmu(Double_t value) { fMassAmu = value; }
+   void SetELossFitValues(std::vector<std::pair<Double_t, Double_t>> values) { fELossFitValues = values; }
+   void SetIsPunchThrough(Bool_t value) { fIsPunchThrough = value; }
+   void SetIsReconstructedELoss(Bool_t value) { fIsReconstructedELoss = value; }
+
+   TString GetELossModelName() { return fELossModelName; }
+   Double_t GetKineticEnergy() { return fKineticEnergy; }
+   Double_t GetKineticEnergyUncertainty() { return fKineticEnergyUncertainty; }
+   Double_t GetAmplitudeFactor() { return fAmplitudeFactor; }
+   Double_t GetAmplitudeFactorUncertainty() { return fAmplitudeFactorUncertainty; }
+   TString GetPDGCode() { return fPDGCode; }
+   Int_t GetAtomicMassNumber() { return fA; }
+   Int_t GetChargeNumber() { return fZ; }
+   Double_t GetMassAmu() { return fMassAmu; }
+   std::vector<std::pair<Double_t, Double_t>> GetELossFitValues() { return fELossFitValues; }
+   Bool_t GetIsPunchThrough() { return fIsPunchThrough; }
+   Bool_t GetIsReconstructedELoss() { return fIsReconstructedELoss; }
+
+   virtual void Print() const override;
+
+   ClassDefOverride(AtBraggFitMetadata, 1);
+};
+
+#endif

AtData/AtDataLinkDef.h

@@ -28,9 +28,15 @@
 #pragma link C++ class AtTrackingEvent + ;
 #pragma link C++ class AtProtoQuadrant + ;
 #pragma link C++ class AtTrack + ;
+#pragma link C++ struct AtTrack::BraggCurve + ;
 #pragma link C++ class AtFittedTrack + ;
 #pragma link C++ class AtFissionEvent + ;
 #pragma link C++ class AtGenericTrace + ;
+#pragma link C++ class AtSiEvent + ;
+#pragma link C++ class AtGaggEvent + ;
+#pragma link C++ class AtENCourseEvent + ;
+#pragma link C++ class AtPPACPair + ;
+#pragma link C++ class AtICEvent + ;
 
 #pragma link C++ class AtPatterns::AtPattern + ;
 #pragma link C++ class AtPatterns::AtPatternLine + ;
@@ -43,5 +49,13 @@
 #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 AtBraggFitMetadata + ;
+
+#pragma link C++ class AtTrackingEventOld + ;
+#pragma link C++ class AtFittedTrackOld + ;
+#pragma link C++ class MCFitter::AtMCResultOld + ;
+
 #endif

AtData/AtENCourseEvent.cxx

@@ -0,0 +1,38 @@
+#include "AtENCourseEvent.h"
+
+#include <Rtypes.h>
+
+ClassImp(AtENCourseEvent);
+
+AtENCourseEvent::AtENCourseEvent() : AtBaseEvent("AtENCourseEvent")
+{
+   fF2PPACs = nullptr;
+   fF3PPACs = nullptr;
+   for (int i = 0; i < 4; i++)
+      fRFToF[i] = -999;
+   fTDCRef = 0;
+}
+
+AtENCourseEvent::AtENCourseEvent(const AtENCourseEvent &copy) : AtBaseEvent(copy), fTDCRef(copy.fTDCRef)
+{
+   fF2PPACs = copy.fF2PPACs->Clone();
+   fF3PPACs = copy.fF3PPACs->Clone();
+   for (int i = 0; i < 4; i++)
+      fRFToF[i] = copy.fRFToF[i];
+}
+
+AtENCourseEvent &AtENCourseEvent::operator=(AtENCourseEvent object)
+{
+   swap(*this, object);
+   return *this;
+}
+
+void AtENCourseEvent::Clear(Option_t *opt)
+{
+   AtBaseEvent::Clear(opt);
+   fF2PPACs.reset();
+   fF3PPACs.reset();
+   for (int i = 0; i < 4; i++)
+      fRFToF[i] = -999;
+   fTDCRef = 0;
+}

AtData/AtENCourseEvent.h

@@ -0,0 +1,53 @@
+#ifndef AtENCOURSEEVENT_H
+#define AtENCOURSEEVENT_H
+
+#include "AtBaseEvent.h"
+#include "AtPPACPair.h"
+
+#include <FairLogger.h>
+
+#include <Rtypes.h>
+
+class AtENCourseEvent : public AtBaseEvent {
+private:
+   std::unique_ptr<AtPPACPair> fF2PPACs;
+   std::unique_ptr<AtPPACPair> fF3PPACs;
+
+   Int_t fRFToF[4];
+   Int_t fTDCRef;
+
+public:
+   AtENCourseEvent();
+   AtENCourseEvent(const AtENCourseEvent &copy);
+   AtENCourseEvent(const AtBaseEvent &copy) : AtBaseEvent(copy) { SetName("AtENCourseEvent"); }
+   AtENCourseEvent &operator=(const AtENCourseEvent object);
+   virtual ~AtENCourseEvent() = default;
+
+   friend void swap(AtENCourseEvent &first, AtENCourseEvent &second)
+   {
+      using std::swap;
+      swap(dynamic_cast<AtBaseEvent &>(first), dynamic_cast<AtBaseEvent &>(second));
+
+      swap(first.fF2PPACs, second.fF2PPACs);
+      swap(first.fF3PPACs, second.fF3PPACs);
+      swap(first.fRFToF, second.fRFToF);
+      swap(first.fTDCRef, second.fTDCRef);
+   }
+
+   void Clear(Option_t *opt = nullptr) override;
+
+   void SetF2PPACs(std::unique_ptr<AtPPACPair> F2PPACs) { fF2PPACs = std::move(F2PPACs); }
+   void SetF3PPACs(std::unique_ptr<AtPPACPair> F3PPACs) { fF3PPACs = std::move(F3PPACs); }
+   void SetRFToF(Int_t RFToF, Int_t idx = 0) { fRFToF[idx] = RFToF; }
+   void SetTDCRef(Int_t TDCRef) { fTDCRef = TDCRef; }
+
+   const AtPPACPair &GetF2PPACs() const { return *fF2PPACs; }
+   const AtPPACPair &GetF3PPACs() const { return *fF3PPACs; }
+   const Int_t GetRFToF(Int_t idx = 0) const { return fRFToF[idx]; }
+   const Int_t GetTDCRef() const { return fTDCRef; }
+   const Int_t GetTDCRefRFToF(Int_t idx = 0) const { return fRFToF[idx] - fTDCRef; }
+
+   ClassDefOverride(AtENCourseEvent, 1);
+};
+
+#endif

AtData/AtFitMetadata.cxx

@@ -0,0 +1,14 @@
+#include "AtFitMetadata.h"
+
+ClassImp(AtFitMetadata);
+
+AtFitMetadata::AtFitMetadata(const AtFitMetadata &copy) : fEventID(copy.fEventID)
+{
+   for (auto const &entry : copy.fMetadatas) {
+      Int_t trackID = entry.first;
+      TrackMetadatasVector newMetadatasVector;
+      for (auto &&metadata : entry.second)
+         newMetadatasVector.push_back(metadata->Clone());
+      fMetadatas.insert({trackID, std::move(newMetadatasVector)});
+   }
+}

AtData/AtFitMetadata.h

@@ -0,0 +1,61 @@
+#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(const AtFitMetadata &copy);
+   ~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); }
+   ULong_t GetEventID() { return fEventID; }
+   Int_t GetNumEntries() { return fMetadatas.size(); }
+
+   ClassDefOverride(AtFitMetadata, 1);
+};
+
+#endif

AtData/AtFitTrackMetadata.cxx

@@ -0,0 +1,21 @@
+#include "AtFitTrackMetadata.h"
+
+#include <iostream>
+ClassImp(AtFitTrackMetadata);
+
+std::unique_ptr<AtFitTrackMetadata> AtFitTrackMetadata::Clone()
+{
+   return std::make_unique<AtFitTrackMetadata>(*this);
+}
+
+void AtFitTrackMetadata::Print() const
+
+{
+   std::cout << " Fit metadata " << fFitID << " 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,58 @@
+#ifndef ATFITTRACKMETADATA_H
+#define ATFITTRACKMETADATA_H
+
+#include <Rtypes.h> // for Double_t, THashConsistencyHolder, ClassDefOverride
+#include <TObject.h>
+
+#include <memory>
+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};
+
+   // More than 1 fit may be done for each track. Adding a fit ID.
+   Int_t fFitID{-1};
+
+public:
+   AtFitTrackMetadata() = default;
+   AtFitTrackMetadata(const AtFitTrackMetadata &) = default;
+   AtFitTrackMetadata(AtFitTrackMetadata &&) = default;
+   ~AtFitTrackMetadata() = default;
+   AtFitTrackMetadata &operator=(const AtFitTrackMetadata &) = default;
+   AtFitTrackMetadata &operator=(AtFitTrackMetadata &&) = default;
+
+   virtual std::unique_ptr<AtFitTrackMetadata> Clone();
+
+   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; }
+   void SetFitID(Int_t value) { fFitID = 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; }
+   Int_t GetFitID() const { return fFitID; }
+
+   virtual void Print() const;
+
+   ClassDefOverride(AtFitTrackMetadata, 1);
+};
+
+#endif