CaConfig.h

Go to the documentation of this file.

/* Copyright (C) 2025 GSI Helmholtzzentrum fuer Schwerionenforschung, Darmstadt
   SPDX-License-Identifier: GPL-3.0-only
   Authors: Sergei Zharko [committer] */

 
#pragma once
 
#include "CaDefs.h"
#include "CaIteration.h"
#include "CaMisalignmentTolerance.h"
#include "CbmYaml.h"
 
#include <boost/serialization/access.hpp>
#include <boost/serialization/array.hpp>
#include <boost/serialization/utility.hpp>
#include <boost/serialization/vector.hpp>
 
#include <string>
#include <vector>
 
namespace cbm::algo::ca
{
  enum class EDetectorID;

  class alignas(constants::misc::Alignment) Config {
   public:
    template<typename T>
    using DynArray_t = std::vector<T>;  
 
    using MisalignmentTolArray_t = std::array<MisalignmentTolerance, constants::size::MaxNdetectors>;
 

    struct alignas(constants::misc::Alignment) Control {
      int maxDoubletsPerSinglet{150};                
      int maxTripletsPerDoublet{15};                 
      float defaultMass{constants::phys::MuonMass};  
      bool ghostSuppression{false};                  
 
      CBM_YAML_PROPERTIES(
        yaml::Property(&Control::maxDoubletsPerSinglet, "max_doublets_per_singlet",
                       "Max number of doublets per singlet to accept branching"),
        yaml::Property(&Control::maxTripletsPerDoublet, "max_triplets_per_doublet",
                       "Max number of triplets per doublet to accept branching"),
        //yaml::Property(&Control::defaultMass, "default_mass",
        //               "Default mass of tracked particle for fitting"),
        yaml::Property(&Control::ghostSuppression, "is_ghost_suppression", "Enable ghost suppression"));
 
     private:
      friend class boost::serialization::access;

      template<class Archive>
      void serialize(Archive& ar, const unsigned int)
      {
        ar& maxDoubletsPerSinglet;
        ar& maxTripletsPerDoublet;
        ar& defaultMass;
        ar& ghostSuppression;
      }
    };
 

    struct alignas(constants::misc::Alignment) Dev {
      bool extendTracksViaMc{false};         
      bool forceUseOriginalField{false};     
      bool ignoreHitSearchAreas{false};      
      bool matchDoubletsViaMc{false};        
      bool matchTripletsViaMc{false};        
      bool suppressOverlapHitsViaMc{false};  
      bool useParSearchWindows{false};       
 
      CBM_YAML_PROPERTIES(
        yaml::Property(&Dev::extendTracksViaMc, "extend_tracks_via_mc", "Extend tracks using MC information"),
        yaml::Property(&Dev::forceUseOriginalField, "use_of_original_field", "Force using original magnetic field"),
        yaml::Property(&Dev::ignoreHitSearchAreas, "ignore_hit_search_areas", "Process all hits on the station ignoring hit search areas"),
        yaml::Property(&Dev::matchDoubletsViaMc, "match_doublets_via_mc", "Match doublets using MC information"),
        yaml::Property(&Dev::matchTripletsViaMc, "match_triplets_via_mc", "Match triplets using MC information"),
        yaml::Property(&Dev::suppressOverlapHitsViaMc, "suppress_overlap_hits_via_mc", "Suppress hits in sensor overlaps using MC information"),
        yaml::Property(&Dev::useParSearchWindows, "par_search_w_used", "Parameterized search windows are used in track finding")
      );
 
     private:
      friend class boost::serialization::access;

      template<class Archive>
      void serialize(Archive& ar, const unsigned int)
      {
        ar& extendTracksViaMc;
        ar& forceUseOriginalField;
        ar& ignoreHitSearchAreas;
        ar& matchDoubletsViaMc;
        ar& matchTripletsViaMc;
        ar& suppressOverlapHitsViaMc;
        ar& useParSearchWindows;
      }
    };
 
 
    // FIXME: remove
    Config() = default;

    Config(DynArray_t<Iteration>&& iterations, Control&& controlFlags, Dev&& devFlags,
           MisalignmentTolArray_t&& misalignment);

    bool DevExtendTracksViaMc() const { return fDev.extendTracksViaMc; }

    bool DevForceUseOriginalField() const { return fDev.forceUseOriginalField; }

    bool DevIgnoreHitSearchAreas() const { return fDev.ignoreHitSearchAreas; }

    bool DevMatchDoubletsViaMc() const { return fDev.matchDoubletsViaMc; }

    bool DevMatchTripletsViaMc() const { return fDev.matchTripletsViaMc; }

    bool DevSuppressOverlapHitsViaMc() const { return fDev.suppressOverlapHitsViaMc; }

    bool DevUseParSearchWindows() const { return fDev.useParSearchWindows; }

    int GetNofIterations() const { return fvCaIterations.size(); }

    const Iteration& GetIteration(int iIteration) const { return fvCaIterations[iIteration]; }

    const DynArray_t<Iteration>& GetIterations() const { return fvCaIterations; }

    float GetDefaultMass() const { return fControl.defaultMass; }

    int GetMaxDoubletsPerSinglet() const { return fControl.maxDoubletsPerSinglet; }

    int GetMaxTripletsPerDoublet() const { return fControl.maxTripletsPerDoublet; }

    const MisalignmentTolerance& GetMisalignmentTolerance(EDetectorID detId) const
    {
      return fvMisalignment[static_cast<int>(detId)];
    }

    bool SuppressGhost() const { return fControl.ghostSuppression; }

    std::string ToString(int indentLevel = 0) const;
 
   private:
    DynArray_t<Iteration> fvCaIterations;        
    Control fControl;                            
    Dev fDev;                                    
    MisalignmentTolArray_t fvMisalignment = {};  
 
    friend class boost::serialization::access;
    template<class Archive>
    void serialize(Archive& ar, const unsigned int)
    {
      ar& fvCaIterations;
      ar& fControl;
      ar& fDev;
      ar& fvMisalignment;
    }
  };
}  // namespace cbm::algo::ca