CaIteration.h

Go to the documentation of this file.

/* Copyright (C) 2022 GSI Helmholtzzentrum fuer Schwerionenforschung, Darmstadt
   SPDX-License-Identifier: GPL-3.0-only
   Authors: Sergey Gorbunov, Sergei Zharko [committer] */
 
/***************************************************************************************************
 * @file   L1CAIteration.h
 * @brief  Declaration of the L1CAIteration class 
 * @since  05.02.2022
 * @author S.Zharko <s.zharko@gsi.de>
 ***************************************************************************************************/
 
#pragma once  // include this header only once per compilation unit
 
#include "CaVector.h"
 
#include <boost/serialization/access.hpp>
#include <boost/serialization/string.hpp>
 
#include <bitset>
#include <iomanip>
#include <string>
 
namespace cbm::algo::ca
{
  class Iteration {
   public:
    Iteration() = default;
 
    Iteration(const Iteration& other) = default;
 
    Iteration(const Iteration& other, const std::string& name) : Iteration(other) { SetName(name); }
 
    Iteration(Iteration&& other) noexcept = default;
 
    Iteration(const std::string& name);
 
    ~Iteration() noexcept = default;
 
    Iteration& operator=(const Iteration& other) = default;
 
    Iteration& operator=(Iteration&& other) = default;
 
    bool Check() const;
 
    float GetDoubletChi2Cut() const { return fDoubletChi2Cut; }
 
    bool GetElectronFlag() const { return fIsElectron; }
 
    bool GetExtendTracksFlag() const { return fIsExtendTracks; }
 
    int GetFirstStationIndex() const { return fFirstStationIndex; }
 
    int GetMaxStationGap() const { return fMaxStationGap; }
 
    float GetMaxDZ() const { return fMaxDZ; }
 
    float GetMaxQp() const { return fMaxQp; }
 
    float GetMaxSlope() const { return fMaxSlope; }
 
    float GetMaxSlopePV() const { return fMaxSlopePV; }
 
    int GetMinNhits() const { return fMinNhits; }
 
    int GetMinNhitsStation0() const { return fMinNhitsStation0; }
 
    const std::string& GetName() const { return fName; }
 
    float GetPickGather() const { return fPickGather; }
 
    bool GetPrimaryFlag() const { return fIsPrimary; }
 
    float GetTargetPosSigmaX() const { return fTargetPosSigmaX; }
 
    float GetTargetPosSigmaY() const { return fTargetPosSigmaY; }
 
    float GetTrackChi2Cut() const { return fTrackChi2Cut; }
 
    bool GetTrackFromTripletsFlag() const { return fIsTrackFromTriplets; }
 
    float GetTripletChi2Cut() const { return fTripletChi2Cut; }
 
    float GetTripletFinalChi2Cut() const { return fTripletFinalChi2Cut; }
 
    float GetTripletLinkChi2() const { return fTripletLinkChi2; }
 
    void SetDoubletChi2Cut(float input) { fDoubletChi2Cut = input; }
 
    void SetElectronFlag(bool flag) { fIsElectron = flag; }
 
    void SetExtendTracksFlag(bool flag) { fIsExtendTracks = flag; }
 
    void SetFirstStationIndex(int index) { fFirstStationIndex = index; }
 
    void SetMaxStationGap(int nSkipped) { fMaxStationGap = nSkipped; }
 
    void SetMaxDZ(float input) { fMaxDZ = input; }
 
    void SetMaxQp(float input) { fMaxQp = input; }
 
    void SetMaxSlope(float input) { fMaxSlope = input; }
 
    void SetMaxSlopePV(float input) { fMaxSlopePV = input; }
 
    void SetMinNhits(int val) { fMinNhits = val; }
 
    void SetMinNhitsStation0(int val) { fMinNhitsStation0 = val; }
 
    void SetName(const std::string& name) { fName = name; }
 
    void SetPickGather(float input) { fPickGather = input; }
 
    void SetPrimaryFlag(bool flag) { fIsPrimary = flag; }
 
    void SetTargetPosSigmaXY(float sigmaX, float sigmaY);
 
    void SetTrackChi2Cut(float input) { fTrackChi2Cut = input; }
 
    void SetTrackFromTripletsFlag(bool flag) { fIsTrackFromTriplets = flag; }
 
    void SetTripletChi2Cut(float input) { fTripletChi2Cut = input; }
 
    void SetTripletFinalChi2Cut(float input) { fTripletFinalChi2Cut = input; }
 
    void SetTripletLinkChi2(float input) { fTripletLinkChi2 = input; }
 
    std::string ToString(int indentLevel = 0) const;
 
    static std::string ToTableFromVector(const Vector<Iteration>& vIterations);
 
   private:
    std::string fName{""};  
 
    // TODO: Iteratively change the literals to floats (S.Zharko)
    // NOTE: For each new cut one should not forget to create a setter and a getter, insert the value
    //       initialization in the copy constructor and the Swap operator as well as a string repre-
    //       sentation to the ToString method (S.Zharko)
    float fTrackChi2Cut        = 10.f;                 
    float fTripletChi2Cut      = 21.1075f;             
    float fTripletFinalChi2Cut = 21.1075f;             
    float fDoubletChi2Cut      = 11.3449 * 2.f / 3.f;  
    float fPickGather          = 3.0;                  
    float fTripletLinkChi2     = 25.0;       
    float fMaxQp               = 1.0 / 0.5;  
    float fMaxSlopePV          = 1.1;        
    float fMaxSlope            = 2.748;      
    float fMaxDZ               = 0.f;        
    float fTargetPosSigmaX     = 0;          
    float fTargetPosSigmaY     = 0;          
    int fFirstStationIndex     = 0;          
    int fMinNhits              = 3;          
    int fMinNhitsStation0      = 3;          
    bool fIsPrimary            = false;      
    bool fIsElectron           = false;      
    bool fIsExtendTracks       = false;      
    int fMaxStationGap         = 0;          
 
 
    bool fIsTrackFromTriplets = false;
 
    friend class boost::serialization::access;
    template<class Archive>
    void serialize(Archive& ar, const unsigned int /*version*/)
    {
      ar& fName;
      ar& fTrackChi2Cut;
      ar& fTripletChi2Cut;
      ar& fTripletFinalChi2Cut;
      ar& fDoubletChi2Cut;
      ar& fPickGather;
      ar& fTripletLinkChi2;
      ar& fMaxQp;
      ar& fMaxSlopePV;
      ar& fMaxSlope;
      ar& fMaxDZ;
      ar& fTargetPosSigmaX;
      ar& fTargetPosSigmaY;
      ar& fFirstStationIndex;
      ar& fMinNhits;
      ar& fMinNhitsStation0;
      ar& fIsPrimary;
      ar& fIsElectron;
      ar& fIsExtendTracks;
      ar& fMaxStationGap;
      ar& fIsTrackFromTriplets;
    }
  };
}  // namespace cbm::algo::ca