BmnGemStripModule.h

Go to the documentation of this file.

#ifndef BMNGEMSTRIPMODULE_H
#define BMNGEMSTRIPMODULE_H
 
#include "BmnGemStripLayer.h"
#include "BmnGemStripMedium.h"
#include "BmnMatch.h"
#include "BmnStripData.h"
#include "TMath.h"
#include "TString.h"
 
#include <iostream>
#include <memory>
#include <vector>
 
using namespace TMath;
using namespace std;
 
enum ElectronDriftDirectionInModule
{
    ForwardZAxisEDrift,
    BackwardZAxisEDrift
};
 
struct CollPoint;
 
class BmnGemStripModule
{
 
  public:
    // Constructors -------------------------------------------------------------
    BmnGemStripModule();
 
    BmnGemStripModule(Double_t z_start_pos,
                      ElectronDriftDirectionInModule edrift_direction,
                      Double_t DriftGap,
                      Double_t FTransferGap,
                      Double_t STransferGap,
                      Double_t InductionGap);
    //--------------------------------------------------------------------------
 
    // Destructor
    virtual ~BmnGemStripModule();
 
    // Verbosity is kept for compatibility only (default kFALSE): the output of the module goes through FairLogger LOG()
    void SetVerbosity(Bool_t verb) { Verbosity = verb; }
    Bool_t GetVerbosity() { return Verbosity; }
 
    // Module parameters --------------------------------------------------------
    Double_t GetXMinModule() { return XMinModule; }
    Double_t GetXMaxModule() { return XMaxModule; }
    Double_t GetYMinModule() { return YMinModule; }
    Double_t GetYMaxModule() { return YMaxModule; }
 
    Double_t GetXSize() { return XMaxModule - XMinModule; }
    Double_t GetYSize() { return YMaxModule - YMinModule; }
 
    void SetZStartModulePosition(Double_t zpos_module) { ZStartModulePosition = zpos_module; }
    Double_t GetZStartModulePosition() { return ZStartModulePosition; }
 
    void SetElectronDriftDirection(ElectronDriftDirectionInModule direction) { ElectronDriftDirection = direction; }
    ElectronDriftDirectionInModule GetElectronDriftDirection() { return ElectronDriftDirection; }
 
    Double_t GetModuleThickness() { return ModuleThickness; }
    Double_t GetZPositionRegistered();   // position for all registered point (hits)
    //--------------------------------------------------------------------------
 
    // Strip layers controls ----------------------------------------------------
    void AddStripLayer(BmnGemStripLayer strip_layer);
 
    Bool_t SetStripSignalInLayer(Int_t layer_num, Int_t strip_num, Double_t signal);
    Bool_t AddStripSignalInLayer(Int_t layer_num, Int_t strip_num, Double_t signal);
    Bool_t SetStripMatchInLayer(Int_t layer_num,
                                Int_t strip_num,
                                BmnMatch mc_match);   // set a MC-match for a strip in some layer
    Bool_t SetStripDigitNumberMatchInLayer(
        Int_t layer_num,
        Int_t strip_num,
        BmnMatch digit_num_match);   // set a digit number match for a strip in some layer
 
    Double_t GetStripSignalInLayer(Int_t layer_num, Int_t strip_num);
    BmnMatch GetStripMatchInLayer(Int_t layer_num, Int_t strip_num);   // get a MC-match for a strip in some layer
    BmnMatch GetStripDigitNumberMatchInLayer(Int_t layer_num,
                                             Int_t strip_num);   // get a digit number match for a strip in some layer
 
    Int_t GetNStripLayers() { return StripLayers.size(); }
    BmnGemStripLayer& GetStripLayer(Int_t num) { return StripLayers.at(num); }
    vector<BmnGemStripLayer>& GetStripLayers() { return StripLayers; }
 
    void ResetModuleData();   // clear all data in the module and all layers (not delete layers!)
    //--------------------------------------------------------------------------
 
    // Point ownership of the module --------------------------------------------
    Bool_t IsPointInsideModule(Double_t x, Double_t y);               // plane ownership
    Bool_t IsPointInsideModule(Double_t x, Double_t y, Double_t z);   // volume ownership
    Bool_t IsPointInsideZThickness(
        Double_t z);   // point with z-coord is between z_start and z_end of the module (inside module thickness)?
    //--------------------------------------------------------------------------
 
    // Methods to add a point to the module -------------------------------------
 
    // Universal method
    Bool_t AddRealPoint(Double_t x,
                        Double_t y,
                        Double_t z,
                        Double_t px,
                        Double_t py,
                        Double_t pz,
                        Double_t signal,
                        Int_t refID);
 
    // ANN generation of the strip clusters for all modules (static: can be set in a macro before the run)
    static void SetUseANNGeneration(Bool_t use) { fUseANNGeneration = use; }
    static Bool_t GetUseANNGeneration() { return fUseANNGeneration; }
 
    // path to the ANN (MLP, .bmnmlp) model for all modules; "" - the default path
    static void SetANNModelPath(TString path);
    static TString GetANNModelPath();
 
    // Strip ANN methods: max |theta| (deg) of the track for the ANN, above it - the standard method
    static constexpr Double_t kANNMaxThetaAngle = 79.0;
 
    // Center point of the ANN strip window: the track segment at the depth of the middle of the drift gap
    void GetANNWindowCenterPoint(Double_t x,
                                 Double_t y,
                                 Double_t z,
                                 Double_t x_out,
                                 Double_t y_out,
                                 Double_t z_out,
                                 Double_t& x_c,
                                 Double_t& y_c) const;
 
    Bool_t AddRealPointFull(Double_t x,
                            Double_t y,
                            Double_t z,
                            Double_t px,
                            Double_t py,
                            Double_t pz,
                            Double_t signal,
                            Int_t refID);
 
    // ANN-based 2D cluster generation
    Bool_t AddRealPointFull_ANNGenerator(Double_t x,
                                         Double_t y,
                                         Double_t z,
                                         Double_t px,
                                         Double_t py,
                                         Double_t pz,
                                         Double_t signal,
                                         Int_t refID,
                                         Int_t pdg_code,
                                         Double_t bfield,
                                         Bool_t onlyStandard = false,
                                         vector<Int_t> segs = {});
 
    // Strip generation with the fdeep model
    Bool_t AddRealPointFull_ANNStripGenerator_Fdeep(Double_t x,
                                                    Double_t y,
                                                    Double_t z,
                                                    Double_t px,
                                                    Double_t py,
                                                    Double_t pz,
                                                    Double_t signal,
                                                    Int_t refID,
                                                    Int_t pdg_code = 0,
                                                    Double_t bfield = -1,
                                                    Bool_t onlyStandard = kFALSE,
                                                    vector<Int_t> segs = {});
 
    // Strip generation with the fdeep model + the standard method is parallel (std::thread)
    Bool_t AddRealPointFull_ANNStripGenerator_Fdeep_Parallel(Double_t x,
                                                             Double_t y,
                                                             Double_t z,
                                                             Double_t px,
                                                             Double_t py,
                                                             Double_t pz,
                                                             Double_t signal,
                                                             Int_t refID,
                                                             Int_t pdg_code = 0,
                                                             Double_t bfield = -1,
                                                             Bool_t onlyStandard = kFALSE,
                                                             vector<Int_t> segs = {});
 
    // Strip generation with the own MLP inference
    Bool_t AddRealPointFull_ANNStripGenerator_MLP(Double_t x,
                                                  Double_t y,
                                                  Double_t z,
                                                  Double_t px,
                                                  Double_t py,
                                                  Double_t pz,
                                                  Double_t signal,
                                                  Int_t refID,
                                                  Int_t pdg_code = 0,
                                                  Double_t bfield = -1,
                                                  Bool_t onlyStandard = kFALSE,
                                                  vector<Int_t> segs = {});
 
    // Strip generation with the own MLP inference + the standard method is parallel (std::thread)
    Bool_t AddRealPointFull_ANNStripGenerator_MLP_Parallel(Double_t x,
                                                           Double_t y,
                                                           Double_t z,
                                                           Double_t px,
                                                           Double_t py,
                                                           Double_t pz,
                                                           Double_t signal,
                                                           Int_t refID,
                                                           Int_t pdg_code = 0,
                                                           Double_t bfield = -1,
                                                           Bool_t onlyStandard = kFALSE,
                                                           vector<Int_t> segs = {});
 
    // Strip generation with the own MLP inference + the fast standard method without the per-electron loop
    Bool_t AddRealPointFull_ANNStripGenerator_MLP_FastStand(Double_t x,
                                                            Double_t y,
                                                            Double_t z,
                                                            Double_t px,
                                                            Double_t py,
                                                            Double_t pz,
                                                            Double_t signal,
                                                            Int_t refID,
                                                            Int_t pdg_code = 0,
                                                            Double_t bfield = -1,
                                                            Bool_t onlyStandard = kFALSE,
                                                            vector<Int_t> segs = {});
 
    Bool_t AddRealPointFullOne(Double_t x,
                               Double_t y,
                               Double_t z,
                               Double_t px,
                               Double_t py,
                               Double_t pz,
                               Double_t signal,
                               Int_t refID);
 
    Bool_t AddRealPointSimple(Double_t x,
                              Double_t y,
                              Double_t z,
                              Double_t px,
                              Double_t py,
                              Double_t pz,
                              Double_t signal,
                              Int_t refID);   // old
 
    // make a strip cluster from a single point (with gauss smearing)
    StripCluster MakeCluster(Int_t layer_num, Double_t xcoord, Double_t ycoord, Double_t signal, Double_t radius);
 
    // seed for the random generator in the full simulation (AddRealPointFull)
    void SetAvalancheGenerationSeed(UInt_t seed) { AvalancheGenerationSeed = seed; }
    UInt_t GetAvalancheGenerationSeed() { return AvalancheGenerationSeed; }
 
    // limit for the mean number of ionizing clusters per cm: 0 - no limit
    void SetMaxClustersPerCm(Double_t max_clusters) { MaxClustersPerCm = max_clusters; }
    Double_t GetMaxClustersPerCm() const { return MaxClustersPerCm; }
 
    // fill the data for the training sample generation (default: kFALSE):
    void SetFillGenerationData(Bool_t fill) { FillGenerationData = fill; }
    Bool_t GetFillGenerationData() const { return FillGenerationData; }
 
    // controls to set up the avalanche radius in the non-full simulation (AddRealPointFullOne)
    void SetAvalancheRadius(Double_t aval_radius);
    Double_t GetAvalancheRadius();
    //--------------------------------------------------------------------------
 
    // Methods to calculate intersection points in the module -------------------
    void CalculateStripHitIntersectionPoints();
 
    // need for a separated test (find x,y intersection coords from strip positions)
    Bool_t SearchIntersectionPoint(Double_t& x,
                                   Double_t& y,
                                   Double_t strip_pos_layerA,
                                   Double_t strip_pos_layerB,
                                   Int_t layerA_index,
                                   Int_t layerB_index);
    //--------------------------------------------------------------------------
 
    // Added (real) points ------------------------------------------------------
    Int_t GetNRealPoints() { return RealPointsX.size(); }                       // quantity of added points
    Double_t GetRealPointX(Int_t indx) { return RealPointsX.at(indx); }         // X-coord of i-added point
    Double_t GetRealPointY(Int_t indx) { return RealPointsY.at(indx); }         // Y-coord of i-added point
    Double_t GetRealPointXout(Int_t indx) { return RealPointsXout.at(indx); }   // Xout-coord of i-added point
    Double_t GetRealPointYout(Int_t indx) { return RealPointsYout.at(indx); }   // Yout-coord of i-added point
    Double_t GetRealPointMC(Int_t indx) { return RealPointsMC.at(indx); }       // MC-index of i-added point
    // ANN strip window center point of i-added point (only the strip ANN methods
    // AddRealPointFull_ANNStripGenerator_* fill it, also with onlyStandard)
    Int_t GetNRealPointCenters() { return RealPointsXcenter.size(); }
    Double_t GetRealPointXcenter(Int_t indx) { return RealPointsXcenter.at(indx); }
    Double_t GetRealPointYcenter(Int_t indx) { return RealPointsYcenter.at(indx); }
 
    void ResetRealPoints()
    {
        RealPointsX.clear();
        RealPointsY.clear();
        RealPointsXout.clear();
        RealPointsYout.clear();
        RealPointsMC.clear();
        RealPointsXcenter.clear();
        RealPointsYcenter.clear();
    }
    //--------------------------------------------------------------------------
 
    // Intersection points ------------------------------------------------------
    Int_t GetNIntersectionPoints() { return IntersectionPointsX.size(); }   // quantity of intersections
    Double_t GetIntersectionPointX(Int_t indx)
    {
        return IntersectionPointsX.at(indx);
    }   // X-coord of indx-intersection point
    Double_t GetIntersectionPointY(Int_t indx)
    {
        return IntersectionPointsY.at(indx);
    }   // Y-coord of indx-intersection point
    Double_t GetIntersectionPointXError(Int_t indx)
    {
        return IntersectionPointsXErrors.at(indx);
    }   // X-coord error of indx-intersection point
    Double_t GetIntersectionPointYError(Int_t indx)
    {
        return IntersectionPointsYErrors.at(indx);
    }   // Y-coord error of indx-intersection point
    Int_t GetIntersectionPoint_LowerLayerClusterSize(Int_t indx)
    {
        return IntersectionPoints_LowerLayerClusterSize.at(indx);
    }   // cluster size in the lower layer
    Int_t GetIntersectionPoint_UpperLayerClusterSize(Int_t indx)
    {
        return IntersectionPoints_UpperLayerClusterSize.at(indx);
    }   // cluster size in the upper layer
    Double_t GetIntersectionPoint_LowerLayerSripPosition(Int_t indx)
    {
        return IntersectionPoints_LowerLayerStripPosition.at(indx);
    }   // strip position in the lower layer
    Double_t GetIntersectionPoint_UpperLayerSripPosition(Int_t indx)
    {
        return IntersectionPoints_UpperLayerStripPosition.at(indx);
    }   // strip position in the upper layer
    Double_t GetIntersectionPoint_LowerLayerSripTotalSignal(Int_t indx)
    {
        return IntersectionPoints_LowerLayerStripTotalSignal.at(indx);
    }   // total signal  in the lower layer
    Double_t GetIntersectionPoint_UpperLayerSripTotalSignal(Int_t indx)
    {
        return IntersectionPoints_UpperLayerStripTotalSignal.at(indx);
    }   // total signal  in the upper layer
    BmnMatch GetIntersectionPointMatch(Int_t indx)
    {
        return IntersectionPointMatches.at(indx);
    }   // Intersection point MC-match
    BmnMatch GetIntersectionPointDigitNumberMatch(Int_t indx)
    {
        return IntersectionPointDigitNumberMatches.at(indx);
    }   // Intersection point digit number match
 
    StripCluster GetUpperCluster(Int_t indx) { return UpperClusters.at(indx); }
    StripCluster GetLowerCluster(Int_t indx) { return LowerClusters.at(indx); }
 
    void ResetIntersectionPoints();
    //--------------------------------------------------------------------------
 
    // Pseudo intersections -----------------------------------------------------
    Int_t GetNPseudoIntersections() { return PseudoIntersectionsX.size(); }
    Double_t GetPseudoIntersectionX(Int_t indx) { return PseudoIntersectionsX.at(indx); }
    Double_t GetPseudoIntersectionY(Int_t indx) { return PseudoIntersectionsY.at(indx); }
    Double_t GetPseudoIntersectionXError(Int_t indx) { return PseudoIntersectionsXErrors.at(indx); }
    Double_t GetPseudoIntersectionYError(Int_t indx) { return PseudoIntersectionsYErrors.at(indx); }
    Int_t GetPseudoIntersection_LowerLayerClusterSize(Int_t indx)
    {
        return PseudoIntersections_LowerLayerClusterSize.at(indx);
    }
    Int_t GetPseudoIntersection_UpperLayerClusterSize(Int_t indx)
    {
        return PseudoIntersections_UpperLayerClusterSize.at(indx);
    }
    Double_t GetPseudoIntersection_LowerLayerSripPosition(Int_t indx)
    {
        return PseudoIntersections_LowerLayerStripPosition.at(indx);
    }
    Double_t GetPseudoIntersection_UpperLayerSripPosition(Int_t indx)
    {
        return PseudoIntersections_UpperLayerStripPosition.at(indx);
    }
    Double_t GetPseudoIntersection_LowerLayerSripTotalSignal(Int_t indx)
    {
        return PseudoIntersections_LowerLayerStripTotalSignal.at(indx);
    }
    Double_t GetPseudoIntersection_UpperLayerSripTotalSignal(Int_t indx)
    {
        return PseudoIntersections_UpperLayerStripTotalSignal.at(indx);
    }
    BmnMatch GetPseudoIntersectionMatch(Int_t indx)
    {
        return PseudoIntersectionMatches.at(indx);
    }   // Pseudo intersection MC-match
    BmnMatch GetPseudoIntersectionDigitNumberMatch(Int_t indx)
    {
        return PseudoIntersectionDigitNumberMatches.at(indx);
    }   // Pseudo intersection point digit number match
 
    StripCluster GetUpperCluster_PseudoIntersections(Int_t indx) { return UpperClusters_PseudoIntersections.at(indx); }
    StripCluster GetLowerCluster_PseudoIntersections(Int_t indx) { return LowerClusters_PseudoIntersections.at(indx); }
 
    void ResetPseudoIntersections();
    //--------------------------------------------------------------------------
 
  private:
    void DefineModuleBorders();   // calculate min-max coordinates of the module from layers` parameters
    Double_t GetNumberOfClusters(Double_t beta,
                                 Double_t gamma,
                                 Double_t charge,
                                 Double_t p0,
                                 Double_t p1);   // AZ-110124
 
  private:
    BmnGemStripModule(const BmnGemStripModule&) = delete;
    BmnGemStripModule& operator=(const BmnGemStripModule&) = delete;
 
  private:
    Bool_t Verbosity;
 
    Double_t XMinModule;
    Double_t XMaxModule;
    Double_t YMinModule;
    Double_t YMaxModule;
 
    Double_t ZStartModulePosition;
 
    Double_t DriftGapThickness;
    Double_t FirstTransferGapThickness;
    Double_t SecondTransferGapThickness;
    Double_t InductionGapThickness;
    Double_t ModuleThickness;
 
    ElectronDriftDirectionInModule ElectronDriftDirection;
 
    vector<BmnGemStripLayer> StripLayers;
 
    static Bool_t fUseANNGeneration;   // see SetUseANNGeneration()
 
    UInt_t AvalancheGenerationSeed;
    Double_t MaxClustersPerCm;   // 0 - no limit
    Bool_t FillGenerationData;   // see SetFillGenerationData()
    Double_t AvalancheRadius;
    Double_t MCD;   // Mean collision distance
    Double_t Gain;
 
    vector<Double_t> RealPointsX;
    vector<Double_t> RealPointsY;
    vector<Double_t> RealPointsXout;
    vector<Double_t> RealPointsYout;
    vector<Double_t> RealPointsMC;        // index of MC point
    vector<Double_t> RealPointsXcenter;   // ANN strip window center point (strip ANN methods only)
    vector<Double_t> RealPointsYcenter;
 
    vector<Double_t> IntersectionPointsX;
    vector<Double_t> IntersectionPointsY;
    vector<Double_t> IntersectionPointsXErrors;
    vector<Double_t> IntersectionPointsYErrors;
 
    vector<Int_t> IntersectionPoints_LowerLayerClusterSize;   // cluster size (number of strips) in the lower layer for
                                                              // each intersection point
    vector<Int_t> IntersectionPoints_UpperLayerClusterSize;   // cluster size (number of strips) in the upper layer for
                                                              // each intersection point
 
    vector<Double_t>
        IntersectionPoints_LowerLayerStripPosition;   // strip position in the lower layer for each intersection point
    vector<Double_t>
        IntersectionPoints_UpperLayerStripPosition;   // strip position in the upper layer for each intersection point
 
    vector<Double_t>
        IntersectionPoints_LowerLayerStripTotalSignal;   // total signal in the lower layer for each intersection point
    vector<Double_t>
        IntersectionPoints_UpperLayerStripTotalSignal;   // total signal in the upper layer for each intersection point
 
    vector<BmnMatch> IntersectionPointMatches;              // MC-matches
    vector<BmnMatch> IntersectionPointDigitNumberMatches;   // Digit number matches
 
    vector<StripCluster> UpperClusters;
    vector<StripCluster> LowerClusters;
 
    // Pseudo intersections -----------------------------------------------------
    vector<Double_t> PseudoIntersectionsX;
    vector<Double_t> PseudoIntersectionsY;
    vector<Double_t> PseudoIntersectionsXErrors;
    vector<Double_t> PseudoIntersectionsYErrors;
 
    vector<Int_t> PseudoIntersections_LowerLayerClusterSize;
    vector<Int_t> PseudoIntersections_UpperLayerClusterSize;
 
    vector<Double_t> PseudoIntersections_LowerLayerStripPosition;
    vector<Double_t> PseudoIntersections_UpperLayerStripPosition;
 
    vector<Double_t> PseudoIntersections_LowerLayerStripTotalSignal;
    vector<Double_t> PseudoIntersections_UpperLayerStripTotalSignal;
 
    vector<BmnMatch> PseudoIntersectionMatches;              // MC-matches
    vector<BmnMatch> PseudoIntersectionDigitNumberMatches;   // Digit number matches
 
    vector<StripCluster> UpperClusters_PseudoIntersections;
    vector<StripCluster> LowerClusters_PseudoIntersections;
 
    // testing part -----------------------------------------------------------------
  public:
    vector<Double_t> XElectronPos;
    vector<Double_t> YElectronPos;
    vector<Double_t> ElectronSignal;
    vector<Int_t> SegmentedChargeDistribution;   // ioniz. cluster distribution along a segmented track
 
    vector<vector<StripCluster>> AddedClusters;   // test
 
    void ResetElectronPointsAndClusters()
    {
        std::vector<Double_t>().swap(XElectronPos);   // clear + empty capacity
        std::vector<Double_t>().swap(YElectronPos);
        std::vector<Double_t>().swap(ElectronSignal);
        SegmentedChargeDistribution.clear();   // small- only clear is enough
 
        std::vector<std::vector<StripCluster>>().swap(AddedClusters);   // test
    }
    //------------------------------------------------------------------------------
 
  private:
    // Struct: a collision point position (an ionizing cluster position) --------
    struct CollPoint
    {
        CollPoint(Double_t _x, Double_t _y, Double_t _z)
            : x(_x)
            , y(_y)
            , z(_z)
        {}
        Double_t x;
        Double_t y;
        Double_t z;
    };
};
//------------------------------------------------------------------------------
 
#endif /* BMNGEMSTRIPMODULE_H */