Changed the interface of AtFitter, changed the name of namespace from AtFITTER to EventFit.

Author: RealAurio

AtReconstruction/AtFitter/AtFitter.cxx

@@ -1,11 +1,22 @@
 #include "AtFitter.h"
 
-ClassImp(AtFITTER::AtFitter);
+#include "AtPatternEvent.h"
+#include "AtTrackingEvent.h"
 
-void AtFITTER::AtFitter::Reset()
+ClassImp(EventFit::AtFitter);
+
+void EventFit::AtFitter::FitEvent(AtTrackingEvent *trackingEvent, AtPatternEvent *patternEvent,
+                                  AtFitMetadata *fitMetadata, AtRawEvent *rawEvent, AtEvent *event)
 {
-   fPatternEvent = nullptr;
-   fFitMetadata = nullptr;
-   fRawEvent = nullptr;
-   fEvent = nullptr;
+   // Extract the candidate AtTracks.
+   std::vector<AtTrack> tracks = patternEvent->GetTrackCand();
+
+   // Save the original AtTracks to the AtTrackingEvent.
+   trackingEvent->SetTrackArray(&tracks);
+
+   // Iterate over the AtTracks and store the AtFittedTracks in the AtTrackingEvent.
+   for (auto track : tracks) {
+      std::unique_ptr<AtFittedTrack> fittedTrack(GetFittedTrack(&track, fitMetadata, rawEvent, event));
+      trackingEvent->AddFittedTrack(std::move(fittedTrack));
+   }
 }

AtReconstruction/AtFitter/AtFitter.h

@@ -20,9 +20,12 @@ class TClass;
 class TMemberInspector;
 class AtRawEvent;
 class AtEvent;
+class AtFitMetadata;
 class AtPatternEvent;
+class AtRawEvent;
+class AtTrackingEvent;
 
-namespace AtFITTER {
+namespace EventFit {
 
 class AtFitter : public TObject {
 public:
@@ -31,44 +34,26 @@ class AtFitter : public TObject {
    using TrackMetadatasSet =
       std::set<TrackMetadataPtr, std::function<bool(const TrackMetadataPtr &, const TrackMetadataPtr &)>>;
 
-protected:
-   // Pointer to the AtPatternEvent to be fitted.
-   AtPatternEvent *fPatternEvent{nullptr};
-
-   // Pointer to the AtFitResult object in which store the fit metadata.
-   AtFitMetadata *fFitMetadata{nullptr};
-
-   // Pointers to AtRawEvent and AtEvent. In case some specific fitter needs to access information
-   // in any of those branches.
-   AtRawEvent *fRawEvent{nullptr};
-   AtEvent *fEvent{nullptr};
-
-   // Compare function that will be used to sort the fit results for a given track.
-   virtual bool
-   CompareTrackFitsFunction(const TrackMetadataPtr &trackMetadataA, const TrackMetadataPtr &trackMetadataB) = 0;
-
 public:
    AtFitter() = default;
    ~AtFitter() = default;
 
-   virtual std::vector<std::unique_ptr<AtFittedTrack>> ProcessEvent() = 0;
+   virtual void FitEvent(AtTrackingEvent *trackingEvent, AtPatternEvent *patternEvent,
+                         AtFitMetadata *fitMetadata = nullptr, AtRawEvent *rawEvent = nullptr,
+                         AtEvent *event = nullptr);
    virtual void Init() = 0;
 
-   // Mandatory to set.
-   void SetPatternEvent(AtPatternEvent *patternEvent) { fPatternEvent = patternEvent; }
-   void SetFitMetadata(AtFitMetadata *fitMetadata) { fFitMetadata = fitMetadata; }
-
-   // Optional to set.
-   void SetRawEvent(AtRawEvent *rawEvent) { fRawEvent = rawEvent; }
-   void SetEvent(AtEvent *event) { fEvent = event; }
+protected:
+   virtual AtFittedTrack *GetFittedTrack(AtTrack *track, AtFitMetadata *fitMetadata = nullptr,
+                                         AtRawEvent *rawEvent = nullptr, AtEvent *event = nullptr) = 0;
 
-   // Reset pointers to AtPatternEvent, AtRawEvent and AtEvent.
-   void Reset();
+   // Compare function that will be used to sort the fit results for a given track.
+   virtual bool
+   CompareTrackFitsFunction(const TrackMetadataPtr &trackMetadataA, const TrackMetadataPtr &trackMetadataB) = 0;
 
-protected:
    ClassDef(AtFitter, 2);
 };
 
-} // namespace AtFITTER
+} // namespace EventFit
 
 #endif

AtReconstruction/AtFitter/AtGenfit.h

@@ -1,7 +1,7 @@
 #ifndef ATGENFIT_H
 #define ATGENFIT_H
 
-#include "AtFitter.h"
+#include "AtFitterOld.h"
 #include "AtFormat.h"
 #include "AtKinematics.h"
 #include "AtParsers.h"
@@ -55,7 +55,9 @@ class MeasurementFactory;
 
 namespace AtFITTER {
 
-class AtGenfit : public AtFitter {
+class [[deprecated(
+   "This still derives from the old AtFitter. Please consider updating it to the new AtFitter at some point")]] AtGenfit
+   : public AtFitterOld {
 private:
    std::shared_ptr<genfit::AbsKalmanFitter> fKalmanFitter;
    TClonesArray *fGenfitTrackArray;

AtReconstruction/AtFitterTask.cxx

@@ -26,7 +26,7 @@ class AtFittedTrack;
 
 ClassImp(AtFitterTask);
 
-AtFitterTask::AtFitterTask(std::unique_ptr<AtFITTER::AtFitter> fitter)
+AtFitterTask::AtFitterTask(std::unique_ptr<EventFit::AtFitter> fitter)
    : fInputBranchName("AtPatternEvent"), fOutputBranchName("AtTrackingEvent"), fIsPersistence(kFALSE),
      fTrackingEventArray(TClonesArray("AtTrackingEvent", 1)), fFitter(std::move(fitter)), fRawEventBranchName(""),
      fEventBranchName(""), fFitMetadataBranchName("")
@@ -113,42 +113,35 @@ void AtFitterTask::SetParContainers()
 
 void AtFitterTask::Exec(Option_t *option)
 {
-   fFitter->Reset();
-
    if (fPatternEventArray->GetEntriesFast() == 0)
       return;
 
-   // If there is AtRawEvent available, pass it to the fitter.
-   if (fRawEventArray) {
-      AtRawEvent *rawEvent = dynamic_cast<AtRawEvent *>(fRawEventArray->At(0));
-      fFitter->SetRawEvent(rawEvent);
-   }
+   // If there is AtRawEvent available, get it so it can be passed to the fitter.
+   AtRawEvent *rawEvent = nullptr;
+   if (fRawEventArray)
+      rawEvent = dynamic_cast<AtRawEvent *>(fRawEventArray->At(0));
 
-   // If there is AtEvent available, pass it to the fitter.
-   if (fEventArray) {
-      AtEvent *event = dynamic_cast<AtEvent *>(fEventArray->At(0));
-      fFitter->SetEvent(event);
-   }
+   // If there is AtEvent available, get it so it can be passed to the fitter.
+   AtEvent *event = nullptr;
+   if (fEventArray)
+      event = dynamic_cast<AtEvent *>(fEventArray->At(0));
 
    fTrackingEventArray.Delete();
 
    auto trackingEvent = dynamic_cast<AtTrackingEvent *>(fTrackingEventArray.ConstructedAt(0));
    auto fitMetadata = dynamic_cast<AtFitMetadata *>(fFitMetadataArray.ConstructedAt(0));
 
-   LOG(info) << " AtFitterTask::Exec() : Fitting event " << fEventCnt;
+   LOG(info) << " Fitting event " << fEventCnt;
 
    AtPatternEvent *patternEvent = dynamic_cast<AtPatternEvent *>(fPatternEventArray->At(0));
    std::vector<AtTrack> &tracks = patternEvent->GetTrackCand();
-   LOG(info) << " AtFitterTask::Exec() : Number of candidate tracks : " << tracks.size();
+   LOG(info) << " Number of candidate tracks : " << tracks.size();
 
-   fFitter->SetPatternEvent(patternEvent);
-   fFitter->SetFitMetadata(fitMetadata);
-   auto fittedTracks = fFitter->ProcessEvent();
+   fFitter->FitEvent(trackingEvent, patternEvent, fitMetadata, rawEvent, event);
 
-   LOG(info) << " AtFitterTask::Exec() : Number of fitted tracks : " << fittedTracks.size();
+   auto &fittedTracks = trackingEvent->GetFittedTracks();
 
-   for (auto &fittedTrack : fittedTracks)
-      trackingEvent->AddFittedTrack(std::move(fittedTrack));
+   LOG(info) << " Number of fitted tracks : " << fittedTracks.size();
 
    ++fEventCnt;
 }

AtReconstruction/AtFitterTask.h

@@ -37,14 +37,14 @@ class AtTrack;
 namespace AtTools {
 class AtTrackTransformer;
 } // namespace AtTools
-namespace AtFITTER {
+namespace EventFit {
 class AtFitter;
-} // namespace AtFITTER
+} // namespace EventFit
 
 class AtFitterTask : public FairTask {
 
 public:
-   AtFitterTask(std::unique_ptr<AtFITTER::AtFitter> fitter);
+   AtFitterTask(std::unique_ptr<EventFit::AtFitter> fitter);
    ~AtFitterTask() = default;
 
    void SetInputBranch(TString branchName);
@@ -66,7 +66,7 @@ class AtFitterTask : public FairTask {
 
    Bool_t fIsPersistence; //!< Persistence check variable
 
-   std::unique_ptr<AtFITTER::AtFitter> fFitter;
+   std::unique_ptr<EventFit::AtFitter> fFitter;
    AtDigiPar *fPar{nullptr};
    TClonesArray *fPatternEventArray;
    TClonesArray fTrackingEventArray;

AtReconstruction/AtReconstructionLinkDef.h

@@ -42,14 +42,15 @@
 #pragma link C++ namespace kf;
 #pragma link C++ namespace kf::util;
 
-#pragma link C++ namespace AtFITTER;
+#pragma link C++ namespace EventFit;
 #pragma link C++ class AtFitterTask + ;
-#pragma link C++ class AtFITTER::AtFitter - ;
+#pragma link C++ class EventFit::AtFitter - ;
 
 /* Classes that depend on Genfit2 */
+#pragma link C++ namespace AtFITTER;
 #pragma link C++ class genfit::AtSpacepointMeasurement + ;
 #pragma link C++ class AtFITTER::AtFitterOld + ;
-#pragma link C++ class AtFITTER::AtFitterTaskOld + ;
+#pragma link C++ class AtFitterTaskOld + ;
 #pragma link C++ class AtFITTER::AtGenfit + ;
 
 #pragma link C++ namespace MCFitter;