ENCourseMerger

AtData/AtDataLinkDef.h

@@ -31,6 +31,8 @@
 #pragma link C++ class AtFittedTrack + ;
 #pragma link C++ class AtFissionEvent + ;
 #pragma link C++ class AtGenericTrace + ;
+#pragma link C++ class AtENCourseEvent + ;
+#pragma link C++ class AtPPACPair + ;
 
 #pragma link C++ class AtPatterns::AtPattern + ;
 #pragma link C++ class AtPatterns::AtPatternLine + ;

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/AtPPACPair.cxx

@@ -0,0 +1,22 @@
+#include "AtPPACPair.h"
+
+ClassImp(AtPPACPair);
+
+void AtPPACPair::CalculateDirection()
+{
+   // Entrance and exit positions relative to the center of the upstream PPAC.
+   XYZPoint initialPoint(fEntrancePosition.X(), fEntrancePosition.Y(), 0);
+   XYZPoint finalPoint(fExitPosition.X(), fExitPosition.Y(), fSeparationDistance);
+
+   // Direction vector.
+   fTrackDirection = finalPoint - initialPoint;
+
+   // Set angles based off the direction vector.
+   fTrackPolarAngle = fTrackDirection.Theta();
+   fTrackAzimutalAngle = fTrackDirection.Phi();
+}
+
+std::unique_ptr<AtPPACPair> AtPPACPair::Clone()
+{
+   return std::make_unique<AtPPACPair>(*this);
+}

AtData/AtPPACPair.h

@@ -0,0 +1,78 @@
+#ifndef ATPPACPAIR_H
+#define ATPPACPAIR_H
+
+#include <Math/Point2D.h>
+#include <Math/Point2Dfwd.h>
+#include <Math/Point3D.h>
+#include <Math/Point3Dfwd.h>
+#include <Math/Vector3D.h>
+#include <Math/Vector3Dfwd.h>
+#include <Rtypes.h>
+#include <TObject.h>
+
+#include <memory>
+
+class AtPPACPair : public TObject {
+public:
+   using XYPoint = ROOT::Math::XYPoint;
+   using XYZPoint = ROOT::Math::XYZPoint;
+   using XYZVector = ROOT::Math::XYZVector;
+
+protected:
+   // Positions, direction and angles.
+   XYPoint fEntrancePosition;
+   XYPoint fExitPosition;
+   XYZVector fTrackDirection;
+   Double_t fTrackPolarAngle;
+   Double_t fTrackAzimutalAngle;
+
+   // Geometrical parameters.
+   Double_t fSeparationDistance{500}; // [mm]. Distance between the 2 PPACs.
+
+public:
+   AtPPACPair() {}
+   AtPPACPair(XYPoint entrancePosition, XYPoint exitPosition, Double_t separationDistance = 500)
+   {
+      fEntrancePosition = entrancePosition;
+      fExitPosition = exitPosition;
+      fSeparationDistance = separationDistance;
+      CalculateDirection();
+   }
+   AtPPACPair(const AtPPACPair &) = default;
+   AtPPACPair(AtPPACPair &&) = default;
+   AtPPACPair &operator=(const AtPPACPair &) = default;
+   AtPPACPair &operator=(AtPPACPair &&) = default;
+   virtual ~AtPPACPair() = default;
+   virtual std::unique_ptr<AtPPACPair> Clone();
+
+   void SetEntrancePosition(XYPoint position)
+   {
+      fEntrancePosition = position;
+      CalculateDirection();
+   }
+   void SetExitPosition(XYPoint position)
+   {
+      fExitPosition = position;
+      CalculateDirection();
+   }
+   void SetSeparationDistance(Double_t separationDistance)
+   {
+      fSeparationDistance = separationDistance;
+      CalculateDirection();
+   }
+
+   const XYPoint GetEntrancePosition() const { return fEntrancePosition; }
+   const XYPoint GetExitPosition() const { return fExitPosition; }
+   const XYZVector GetTrackDirection() const { return fTrackDirection; }
+   const Double_t GetTrackPolarAngle() const { return fTrackPolarAngle; }
+   const Double_t GetTrackAzimutalAngle() const { return fTrackAzimutalAngle; }
+   const Double_t GetSeparationDistance() const { return fSeparationDistance; }
+
+private:
+   void CalculateDirection();
+
+public:
+   ClassDef(AtPPACPair, 1);
+};
+
+#endif

AtData/CMakeLists.txt

@@ -37,6 +37,8 @@ set(SRCS
   AtTrackingEvent.cxx
   AtPatternEvent.cxx
   AtGenericTrace.cxx
+  AtENCourseEvent.cxx
+  AtPPACPair.cxx
 
   AtProtoQuadrant.cxx
   AtTrack.cxx

AtUnpack/AtMergeENCourseTask.cxx

@@ -0,0 +1,101 @@
+#include "AtMergeENCourseTask.h"
+
+#include "AtRawEvent.h"
+
+#include <FairLogger.h>
+#include <FairRootManager.h>
+#include <FairTask.h>
+
+#include <Math/Point2D.h>
+#include <Math/Point2Dfwd.h>
+
+#include <utility>
+
+using XYPoint = ROOT::Math::XYPoint;
+
+ClassImp(AtMergeENCourseTask);
+
+AtMergeENCourseTask::AtMergeENCourseTask() : fOutputENCourseEventArray(TClonesArray("AtENCourseEvent", 1)) {}
+
+InitStatus AtMergeENCourseTask::Init()
+{
+   FairRootManager *ioMan = FairRootManager::Instance();
+   if (ioMan == nullptr) {
+      LOG(fatal) << "Cannot find RootManager!";
+      return kERROR;
+   }
+
+   fRawEventArray = dynamic_cast<TClonesArray *>(ioMan->GetObject(fRawEventBranchName));
+   if (fRawEventArray == nullptr) {
+      LOG(error) << "AtRawEvent branch was not found. The merger can not check the time stamp synchronization!";
+      return kERROR;
+   }
+
+   fENCourseFile = std::make_unique<TFile>(fInputFileName, "READ");
+   if (fENCourseFile->IsZombie()) {
+      LOG(error) << "Could not open ROOT file " << fInputFileName << "!";
+      return kERROR;
+   }
+   LOG(info) << "ROOT file " << fInputFileName << " opened successfully.";
+
+   fENCourseTree = std::unique_ptr<TTree>((TTree *)fENCourseFile->Get("tree"));
+   fENCourseTree->SetBranchAddress("eve", &eve);
+   fENCourseTree->SetBranchAddress("ppac_pos_cal", ppac_pos_cal);
+   fENCourseTree->SetBranchAddress("rf", rf);
+   fENCourseTree->SetBranchAddress("ref_tdc", &ref_tdc);
+   fENCourseTree->SetBranchAddress("madc", &madc);
+
+   ioMan->Register(fOuputBranchName, "ENCourse", &fOutputENCourseEventArray, fIsPersistent);
+
+   return kSUCCESS;
+}
+
+void AtMergeENCourseTask::Exec(Option_t *opt)
+{
+   AtENCourseEvent *ENCourseEvent = dynamic_cast<AtENCourseEvent *>(fOutputENCourseEventArray.ConstructedAt(0));
+   AtRawEvent *rawEvent = dynamic_cast<AtRawEvent *>(fRawEventArray->At(0));
+
+   if (fLastTreeEntryNum >= fENCourseTree->GetEntries()) {
+      ENCourseEvent->SetIsGood(false);
+      return;
+   }
+
+   fENCourseTree->GetEntry(fLastTreeEntryNum++);
+   LOG(info) << "Merging ENCourse event " << eve << " with timestamp " << madc.counter[0]
+             << ". The corresponding AtRawEvent has timestamp " << rawEvent->GetTimestamp(1) << " with the 1MHz clock.";
+   ENCourseEvent->SetEventID(eve);
+   ENCourseEvent->SetTimestamp(madc.counter[0]);
+
+   auto deltaTEN = madc.counter[0] - fLastENTS;
+   auto deltaTATTPC = rawEvent->GetTimestamp(1) - fLastATTPCTS;
+   fLastENTS = madc.counter[0];
+   fLastATTPCTS = rawEvent->GetTimestamp(1);
+
+   if (std::abs(Long64_t(deltaTEN - deltaTATTPC)) > fMaxDeltaTimeDifference) {
+      LOG(warning)
+         << " This ENCourse event is not time correlated with its respective AtRawEvent. Marking it as not good!";
+      ENCourseEvent->SetIsGood(false);
+      return;
+   }
+
+   XYPoint F2EntrancePoint(ppac_pos_cal[0][0], ppac_pos_cal[0][1]);
+   XYPoint F2ExitPoint(ppac_pos_cal[1][0], ppac_pos_cal[1][1]);
+   std::unique_ptr<AtPPACPair> F2PPACs = std::make_unique<AtPPACPair>(F2EntrancePoint, F2ExitPoint, fF2PPACsDistance);
+
+   XYPoint F3EntrancePoint(ppac_pos_cal[2][0], ppac_pos_cal[2][1]);
+   XYPoint F3ExitPoint(ppac_pos_cal[3][0], ppac_pos_cal[3][1]);
+   std::unique_ptr<AtPPACPair> F3PPACs = std::make_unique<AtPPACPair>(F3EntrancePoint, F3ExitPoint, fF3PPACsDistance);
+
+   ENCourseEvent->SetF2PPACs(std::move(F2PPACs));
+   ENCourseEvent->SetF3PPACs(std::move(F3PPACs));
+   for (int i = 0; i < 4; i++)
+      ENCourseEvent->SetRFToF(rf[i], i);
+   ENCourseEvent->SetTDCRef(ref_tdc);
+   ENCourseEvent->SetIsGood(true);
+}
+
+void AtMergeENCourseTask::CloseENRootFile()
+{
+   if (fENCourseFile)
+      fENCourseFile->Close();
+}

AtUnpack/AtMergeENCourseTask.h

@@ -0,0 +1,68 @@
+#ifndef ATMERGEENCOURSETASK_H
+#define ATMERGEENCOURSETASK_H
+
+#include "AtENCourseEvent.h"
+#include "AtPPACPair.h"
+
+#include <FairTask.h>
+
+#include <Rtypes.h>
+#include <TClonesArray.h>
+#include <TFile.h>
+#include <TTree.h>
+
+#include <memory>
+#include <string>
+
+class AtMergeENCourseTask : public FairTask {
+private:
+   typedef struct madc32_data {
+      unsigned int adc[32];
+      unsigned long int counter[1];
+   } madc32_data;
+
+   TString fInputFileName;
+   TString fOuputBranchName{"AtENCourseEvent"};
+   TString fRawEventBranchName{"AtRawEvent"};
+   Bool_t fIsPersistent = true;
+
+   TClonesArray fOutputENCourseEventArray;
+   TClonesArray *fRawEventArray;
+
+   std::unique_ptr<TFile> fENCourseFile{nullptr};
+   std::unique_ptr<TTree> fENCourseTree{nullptr};
+   Int_t eve;
+   Float_t ppac_pos_cal[4][2];
+   Int_t rf[4];
+   Int_t ref_tdc;
+   madc32_data madc;
+   ULong64_t fLastTreeEntryNum{};
+
+   ULong64_t fLastENTS{};
+   ULong64_t fLastATTPCTS{};
+   Int_t fMaxDeltaTimeDifference{5}; // [us]
+
+   Double_t fF2PPACsDistance{500}; // [mm]
+   Double_t fF3PPACsDistance{500}; // [mm]
+
+public:
+   AtMergeENCourseTask();
+   ~AtMergeENCourseTask() = default;
+
+   void SetInputFileName(TString filename) { fInputFileName = filename; }
+   void SetOuputBranchName(TString branchName) { fOuputBranchName = branchName; }
+   void SetPersistence(Bool_t value) { fIsPersistent = value; }
+
+   void SetMaxDeltaTimeDifference(Int_t value) { fMaxDeltaTimeDifference = value; }
+   void SetF2PPACsDistance(Double_t value) { fF2PPACsDistance = value; }
+   void SetF3PPACsDistance(Double_t value) { fF3PPACsDistance = value; }
+
+   virtual InitStatus Init() override;
+   virtual void Exec(Option_t *opt) override;
+
+   void CloseENRootFile();
+
+   ClassDefOverride(AtMergeENCourseTask, 1);
+};
+
+#endif

AtUnpack/AtUnpackLinkDef.h

@@ -25,5 +25,6 @@
 #pragma link C++ class AtROOTUnpacker + ;
 #pragma link C++ class AtGRAWUnpacker + ;
 #pragma link C++ class AtUnpackTask + ;
+#pragma link C++ class AtMergeENCourseTask + ;
 
 #endif

AtUnpack/CMakeLists.txt

@@ -34,6 +34,7 @@ set(SRCS
   AtFRIBSiUnpacker.cxx
   AtROOTUnpacker.cxx
   AtGRAWUnpacker.cxx
+  AtMergeENCourseTask.cxx
 
   GETDecoder2/GETDecoder2.cxx
   GETDecoder2/GETFrameInfo.cxx