Merge pull request #37 from rest-for-physics/lobis-working-on-veto-readout

Update TRestDetectorSignalToRawSignalProcess

Author: lobis

inc/TRestDetectorSignalToRawSignalProcess.h

@@ -23,6 +23,7 @@
 #ifndef RestCore_TRestDetectorSignalToRawSignalProcess
 #define RestCore_TRestDetectorSignalToRawSignalProcess
 
+#include <TRestDetectorReadout.h>
 #include <TRestDetectorSignalEvent.h>
 #include <TRestEventProcess.h>
 #include <TRestRawSignalEvent.h>
@@ -36,8 +37,12 @@ class TRestDetectorSignalToRawSignalProcess : public TRestEventProcess {
     /// A pointer to the specific TRestRawSignalEvent input
     TRestRawSignalEvent* fOutputRawSignalEvent;  //!
 
+    TRestDetectorReadout* fReadout = nullptr;  //!
+
     void Initialize() override;
 
+    void InitFromConfigFile() override;
+
    protected:
     /// The sampling time from the binned raw output signal
     Double_t fSampling = 1.0;  // ns
@@ -46,14 +51,17 @@ class TRestDetectorSignalToRawSignalProcess : public TRestEventProcess {
     Int_t fNPoints = 512;
 
     /// It is used to define the way the time start will be fixed
-    TString fTriggerMode = "firstDeposit";
+    std::string fTriggerMode = "firstDeposit";
 
     /// The number of time bins the time start is delayed in the resulting output signal.
     Int_t fTriggerDelay = 100;
 
     /// The starting time for the "fixed" trigger mode (can be offset by the trigger delay)
     Int_t fTriggerFixedStartTime = 0;
 
+    /// The name of the observable used to define the trigger mode (i.e. g4Ana_sensitiveVolumeFirstHitTime)
+    std::string fTriggerModeObservableName;
+
     /// fCalibrationGain and fCalibrationOffset define the linear calibration.
     /// output = input * fCalibrationGain + calibrationOffset
     Double_t fCalibrationGain = 100.0;
@@ -74,80 +82,53 @@ class TRestDetectorSignalToRawSignalProcess : public TRestEventProcess {
     /// avoid artifacts in the signal (e.g. signals not getting cut when they should)
     Double_t fShapingTime = 0.0;  // us
 
-    Double_t fTimeStart;  //!
-    Double_t fTimeEnd;    //!
-
    public:
     inline Double_t GetSampling() const { return fSampling; }
-    inline void SetSampling(Double_t sampling) { fSampling = sampling; }
 
     inline Int_t GetNPoints() const { return fNPoints; }
-    inline void SetNPoints(Int_t nPoints) { fNPoints = nPoints; }
 
-    inline TString GetTriggerMode() const { return fTriggerMode; }
-    inline void SetTriggerMode(const TString& triggerMode) { fTriggerMode = triggerMode; }
+    inline std::string GetTriggerMode() const { return fTriggerMode; }
 
     inline Int_t GetTriggerDelay() const { return fTriggerDelay; }
-    inline void SetTriggerDelay(Int_t triggerDelay) { fTriggerDelay = triggerDelay; }
 
     inline Double_t GetGain() const { return fCalibrationGain; }
-    inline void SetGain(Double_t gain) { fCalibrationGain = gain; }
-
-    inline Double_t GetCalibrationOffset() const { return fCalibrationOffset; }
-    inline void SetCalibrationOffset(Double_t offset) { fCalibrationOffset = offset; }
 
     inline Double_t GetIntegralThreshold() const { return fIntegralThreshold; }
-    inline void SetIntegralThreshold(Double_t integralThreshold) { fIntegralThreshold = integralThreshold; }
-
-    inline Double_t GetShapingTime() const { return fShapingTime; }
-    inline void SetShapingTime(Double_t shapingTime) { fShapingTime = shapingTime; }
-
-    inline bool IsShapingEnabled() const { return fShapingTime > 0; }
 
     inline bool IsLinearCalibration() const {
         // Will return true if two points have been given for calibration
         return (fCalibrationEnergy.Mod() != 0 && fCalibrationRange.Mod() != 0);
     }
 
-    inline TVector2 GetCalibrationEnergy() const { return fCalibrationEnergy; }
-    inline void SetCalibrationEnergy(TVector2 calibrationEnergy) { fCalibrationEnergy = calibrationEnergy; }
-
-    inline TVector2 GetCalibrationRange() const { return fCalibrationRange; }
-    inline void SetCalibrationRange(TVector2 calibrationRange) { fCalibrationRange = calibrationRange; }
-
     RESTValue GetInputEvent() const override { return fInputSignalEvent; }
+
     RESTValue GetOutputEvent() const override { return fOutputRawSignalEvent; }
 
+    Double_t GetEnergyFromADC(Double_t adc, const std::string& type = "") const;
+
+    Double_t GetADCFromEnergy(Double_t energy, const std::string& type = "") const;
+
+    Double_t GetTimeFromBin(Double_t bin, const std::string& type = "") const;
+
+    Double_t GetBinFromTime(Double_t time, const std::string& type = "") const;
+
+    struct Parameters {
+        Double_t sampling = 1.0;
+        Double_t shapingTime = 0.0;
+        Double_t calibrationGain = 100;
+        Double_t calibrationOffset = 0;
+        TVector2 calibrationEnergy = {0, 0};
+        TVector2 calibrationRange = {0, 0};
+    };
+
     void InitProcess() override;
 
     TRestEvent* ProcessEvent(TRestEvent* inputEvent) override;
 
     void LoadConfig(const std::string& configFilename, const std::string& name = "");
 
     /// It prints out the process parameters stored in the metadata structure
-    void PrintMetadata() override {
-        BeginPrintProcess();
-
-        RESTMetadata << "Sampling time : " << fSampling << " us" << RESTendl;
-        RESTMetadata << "Points per channel : " << fNPoints << RESTendl;
-        RESTMetadata << "Trigger mode : " << fTriggerMode << RESTendl;
-        RESTMetadata << "Trigger delay : " << fTriggerDelay << " time units" << RESTendl;
-
-        if (IsLinearCalibration()) {
-            RESTMetadata << "Calibration energy : (" << fCalibrationEnergy.X() << ", "
-                         << fCalibrationEnergy.Y() << ") keV" << RESTendl;
-            RESTMetadata << "Calibration range : (" << fCalibrationRange.X() << ", " << fCalibrationRange.Y()
-                         << ")" << RESTendl;
-        }
-        RESTMetadata << "ADC Gain : " << fCalibrationGain << RESTendl;
-        RESTMetadata << "ADC Offset : " << fCalibrationOffset << RESTendl;
-
-        if (IsShapingEnabled()) {
-            RESTMetadata << "Shaping time : " << fShapingTime << " us" << RESTendl;
-        }
-
-        EndPrintProcess();
-    }
+    void PrintMetadata() override;
 
     /// Returns a new instance of this class
     TRestEventProcess* Maker() { return new TRestDetectorSignalToRawSignalProcess; }
@@ -157,11 +138,17 @@ class TRestDetectorSignalToRawSignalProcess : public TRestEventProcess {
 
     // Constructor
     TRestDetectorSignalToRawSignalProcess();
+
     TRestDetectorSignalToRawSignalProcess(const char* configFilename);
 
     // Destructor
     ~TRestDetectorSignalToRawSignalProcess();
 
-    ClassDefOverride(TRestDetectorSignalToRawSignalProcess, 3);
+   private:
+    std::map<std::string, Parameters> fParametersMap;
+    std::set<std::string> fReadoutTypes;
+
+    ClassDefOverride(TRestDetectorSignalToRawSignalProcess, 6);
 };
+
 #endif

inc/TRestGeant4ToDetectorHitsProcess.h

@@ -24,10 +24,12 @@
 #define RestCore_TRestGeant4ToDetectorHitsProcess
 
 #include <TRestDetectorHitsEvent.h>
+#include <TRestEventProcess.h>
 #include <TRestGeant4Event.h>
 #include <TRestGeant4Metadata.h>
 
-#include "TRestEventProcess.h"
+#include <string>
+#include <vector>
 
 /// A process to transform a *TRestGeant4Event* into a *TRestDetectorHitsEvent*.
 class TRestGeant4ToDetectorHitsProcess : public TRestEventProcess {
@@ -47,6 +49,8 @@ class TRestGeant4ToDetectorHitsProcess : public TRestEventProcess {
     /// The geometry volume names to be transferred to TRestDetectorHitsEvent
     std::vector<TString> fVolumeSelection;
 
+    std::map<std::string, REST_HitType> fHitTypes;  //!
+
     void InitFromConfigFile() override;
 
     void Initialize() override;

inc/TRestRawReadoutAnalysisProcess.h

@@ -13,9 +13,6 @@
 #define RestCore_TRestRawReadoutAnalysisProcess
 
 #include <TH1D.h>
-
-// #include <TCanvas.h>
-
 #include <TRestDetectorGas.h>
 #include <TRestDetectorHitsEvent.h>
 #include <TRestDetectorReadout.h>
@@ -44,7 +41,6 @@ class TRestRawReadoutAnalysisProcess : public TRestEventProcess {
     std::map<int, TH1D*> fModuleActivityY;  //! [MM id, channel activity]
     std::map<int, TH2D*> fModuleBSLSigmaX;  //! [MM id, channel activity]
     std::map<int, TH2D*> fModuleBSLSigmaY;  //! [MM id, channel activity]
-                                            //
 
    public:
     RESTValue GetInputEvent() const override { return fSignalEvent; }

inc/TRestRawReadoutMetadataProcess.h

@@ -0,0 +1,43 @@
+//
+// Created by lobis on 24-Aug-23.
+//
+
+#ifndef REST_TRESTRAWREADOUTMETADATAPROCESS_H
+#define REST_TRESTRAWREADOUTMETADATAPROCESS_H
+
+#include <TRestDetectorReadout.h>
+#include <TRestEventProcess.h>
+#include <TRestRawReadoutMetadata.h>
+#include <TRestRawSignalEvent.h>
+
+#include <atomic>
+
+class TRestRawReadoutMetadataProcess : public TRestEventProcess {
+   private:
+    TRestRawSignalEvent* fSignalEvent = nullptr;  //!
+    TRestDetectorReadout* fReadout;               //!
+   private:
+    static std::mutex fMetadataMutex;  //!
+
+   public:
+    RESTValue GetInputEvent() const override { return fSignalEvent; }
+    RESTValue GetOutputEvent() const override { return fSignalEvent; }
+
+    void InitProcess() override;
+    TRestEvent* ProcessEvent(TRestEvent* inputEvent) override;
+    void EndProcess() override {}
+
+    const char* GetProcessName() const override { return "readoutMetadata"; }
+
+    explicit TRestRawReadoutMetadataProcess(const char* configFilename){};
+
+    TRestRawReadoutMetadataProcess() = default;
+    ~TRestRawReadoutMetadataProcess() = default;
+
+    // this is a workaround
+    static TRestRawReadoutMetadata* fReadoutMetadata;  //! // made static to avoid problems with MT
+
+    ClassDefOverride(TRestRawReadoutMetadataProcess, 1);
+};
+
+#endif  // REST_TRESTRAWREADOUTMETADATAPROCESS_H

inc/TRestRawToDetectorSignalProcess.h

@@ -79,7 +79,7 @@ class TRestRawToDetectorSignalProcess : public TRestEventProcess {
 
     TRestEvent* ProcessEvent(TRestEvent* inputEvent) override;
 
-    void ZeroSuppresion(TRestRawSignal* rawSignal, TRestDetectorSignal& sgnl);
+    void ZeroSuppresion(TRestRawSignal* rawSignal, TRestDetectorSignal& signal);
 
     /// It prints out the process parameters stored in the metadata structure
     void PrintMetadata() override {