SiSpacePointsSeedMakerEventData.h

Go to the documentation of this file.

// -*- C++ -*-
 
/*
  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
*/

//  Header file for struct SiSpacePointsSeedMakerEventData
 
#ifndef SiSpacePointsSeedMakerEventData_h
#define SiSpacePointsSeedMakerEventData_h
 
#include "SiSpacePointsSeed/SiSpacePointsSeed.h"
#include "SiSPSeededTrackFinderData/SiSpacePointForSeed.h"
#include "SiSPSeededTrackFinderData/ITkSiSpacePointForSeed.h"
#include "SiSPSeededTrackFinderData/SiSpacePointsProSeed.h"
#include "SiSPSeededTrackFinderData/ITkSiSpacePointsProSeed.h"
#include "SiSpacePoint/SCT_SpacePoint.h"
#include "SiSpacePoint/PixelSpacePoint.h"
 
//custom allocator
#include "AthAllocators/ArenaPoolSTLAllocator.h"
 
#include "xAODInDetMeasurement/SpacePointContainer.h"
 
#include <list>
#include <map>
#include <vector>
 
namespace InDet {
 
  class FloatInt {
  public:
    float Fl;
    int   In;
  };

 
  class SiSpacePointsSeedMakerEventData {
  public:
    enum class ToolType {
      ATLxk, 
      BeamGas, 
      Cosmic, 
      HeavyIon, 
      ITk, 
      LowMomentum, 
      Trigger 
    };
 
    bool initialized{false};    
    bool trigger{false};        
    bool izvertex{false};
    bool endlist{true};
    bool isvertex{false};   
    bool checketa{false};   
 
    int maxSeedsPerSP{0};   
    bool keepAllConfirmedSeeds{false};   
    int iteration{0};   
    int iteration0{0};
    int r_first{0}; 
    int ns{0};      
    int nsaz{0};      
    int nsazv{0};
    int nr{0};        
    int nrf{0};
    int nrfz{0};     
    int nrfzv{0};
    int state{0};     
    int nspoint{2};   
    int mode{0};      
    int nlist{0};
    int fNmin{0};     
    int fvNmin{0};
    int zMin{0};
    int nOneSeeds{0};
    int nOneSeedsQ{0};
    int fillOneSeeds{0};
    int nprint{0};
    int nseeds{0};
    int seedPerSpCapacity{0}; 
 
    float K{0.};      
    float dzdrmin{0.};    //<! store eta cuts interpreted as dz/dr
    float dzdrmax{0.};    //<! store eta cuts interpreted as dz/dr
    float ipt2C{0.};  
    float ipt2K{0.};  
    float COFK{0.};   
    float zminU{0.};
    float zmaxU{0.};
    float zminB{0.};
    float zmaxB{0.};
    float ftrig{0.};
    float ftrigW{0.};
    float maxScore{0.};
    float RTmin{0.};
    float RTmax{0.};

    float xbeam[4]{0., 1., 0., 0.}; 
    float ybeam[4]{0., 0., 1., 0.}; 
    float zbeam[4]{0., 0., 0., 1.}; 
    float bField[3]{0., 0., 0.};
 
    std::vector<int> r_index;
    std::vector<int> r_map;
    std::vector<int> rf_index;
    std::vector<int> rf_map;
    std::vector<int> rfz_index;  
    std::vector<int> rfz_map;    
    std::vector<int> rfzv_index;
    std::vector<int> rfzv_map;
 
    std::set<float> l_vertex;

    std::vector<InDet::SiSpacePointForSeed*> SP;    
    std::vector<ITk::SiSpacePointForSeed*> ITkSP;

    std::vector<float> Zo;    
    std::vector<float> Tz;    
    std::vector<float> R;     
    std::vector<float> U;     
    std::vector<float> V;     
    std::vector<float> X;
    std::vector<float> Y;
    std::vector<float> Er;    
    std::vector<FloatInt> Tn;
 
    InDet::SiSpacePointsSeed seedOutput;
 
    std::vector<InDet::SiSpacePointsSeed> OneSeeds;
    std::vector<InDet::SiSpacePointsProSeed> OneSeeds_Pro;
    std::vector<ITk::SiSpacePointsProSeed> ITkOneSeeds;
    std::vector<ITk::SiSpacePointsProSeed> ITkOneSeedsQ;
 
    std::vector<std::pair<float,InDet::SiSpacePointForSeed*>> CmSp;
    std::vector<std::pair<float,ITk::SiSpacePointForSeed*>> ITkCmSp;
 
    std::vector<std::vector<InDet::SiSpacePointForSeed*>> r_Sorted;     
    std::vector<std::vector<InDet::SiSpacePointForSeed*>> rf_Sorted;
    std::vector<std::vector<InDet::SiSpacePointForSeed*>> rfz_Sorted;   
    std::vector<std::vector<InDet::SiSpacePointForSeed*>> rfzv_Sorted;
    std::vector<std::vector<ITk::SiSpacePointForSeed*>> r_ITkSorted;
    std::vector<std::vector<ITk::SiSpacePointForSeed*>> rfz_ITkSorted;
    std::vector<std::vector<ITk::SiSpacePointForSeed*>> rfzv_ITkSorted;
 
    std::vector<InDet::SiSpacePointsSeed> seeds;

    using SiSpacePointForSeedPoolList =
        std::list<InDet::SiSpacePointForSeed,
                  SG::ArenaPoolSTLAllocator<InDet::SiSpacePointForSeed>>;
 
    using ITkSiSpacePointForSeedPoolList =
        std::list<ITk::SiSpacePointForSeed,
                  SG::ArenaPoolSTLAllocator<ITk::SiSpacePointForSeed>>;
 
    using SiSpacePointsSeedPoolList =
        std::list<InDet::SiSpacePointsSeed,
                  SG::ArenaPoolSTLAllocator<InDet::SiSpacePointsSeed>>;
 
    using SiSpacePointsProSeedPoolList =
        std::list<InDet::SiSpacePointsProSeed,
                  SG::ArenaPoolSTLAllocator<InDet::SiSpacePointsProSeed>>;
 
    using ITkSiSpacePointsProSeedPoolList =
        std::list<ITk::SiSpacePointsProSeed,
                  SG::ArenaPoolSTLAllocator<ITk::SiSpacePointsProSeed>>;
 
    // special treatment for cleaning
    // given PoolStl allocator
    template <typename T>
    static void clearPoolList(std::list<T, SG::ArenaPoolSTLAllocator<T>>& poolList){
      // Can't just use clear() because we want to erase the
      // pool as well.
      poolList = std::list<T, SG::ArenaPoolSTLAllocator<T>>();
    }

    SiSpacePointForSeedPoolList l_spforseed;
    //<! keep track of an iterator over the seed list. Frequently used to keep track of where to add the next SP
    SiSpacePointForSeedPoolList::iterator i_spforseed;
 
    ITkSiSpacePointForSeedPoolList l_ITkSpacePointForSeed;
    ITkSiSpacePointForSeedPoolList::iterator i_ITkSpacePointForSeed;
 
    std::vector<const xAOD::SpacePoint*> v_ActsSpacePointForSeed;  //<! list of acts space points considered for seed building.
    std::vector<std::unique_ptr<InDet::PixelSpacePoint>> v_PixelSpacePointForSeed;
    std::vector<ITk::SiSpacePointForSeed> v_PixelSiSpacePointForSeed;
    std::map<std::pair<std::size_t, std::size_t>, std::unique_ptr<InDet::SCT_SpacePoint>> v_StripSpacePointForSeed;
 
    SiSpacePointsSeedPoolList l_seeds;
    SiSpacePointsSeedPoolList::iterator i_seed;
    SiSpacePointsSeedPoolList::iterator i_seede;
    SiSpacePointsProSeedPoolList l_seeds_Pro;       //<! lists of output seeds
    SiSpacePointsProSeedPoolList::iterator i_seed_Pro; //<! iterators over the said list
    SiSpacePointsProSeedPoolList::iterator i_seede_Pro;
 
    ITkSiSpacePointsProSeedPoolList i_ITkSeeds;
    ITkSiSpacePointsProSeedPoolList::iterator i_ITkSeed;
    ITkSiSpacePointsProSeedPoolList::iterator i_ITkSeedEnd;
 
    std::vector<InDet::SiSpacePointForSeed*>::iterator rMin;
    std::vector<ITk::SiSpacePointForSeed*>::iterator ITk_rMin;
 
    std::multimap<float,InDet::SiSpacePointsSeed*> mapOneSeeds;
    std::multimap<float,InDet::SiSpacePointsSeed*> mapSeeds;
    std::multimap<float,InDet::SiSpacePointsSeed*> l_seeds_map;
    std::multimap<float,InDet::SiSpacePointsSeed*>::iterator seed;
    std::multimap<float,InDet::SiSpacePointsSeed*>::iterator seede;
    std::multimap<float,InDet::SiSpacePointsSeed*>::iterator i_seed_map;
    std::multimap<float,InDet::SiSpacePointsSeed*>::iterator i_seede_map;
    std::multimap<float,InDet::SiSpacePointsProSeed*> mapOneSeeds_Pro;
    std::multimap<float,InDet::SiSpacePointsProSeed*> seeds_Pro;
    std::multimap<float,InDet::SiSpacePointsProSeed*>::iterator seed_Pro;
    std::multimap<float,ITk::SiSpacePointsProSeed*> ITkMapOneSeeds;
    std::multimap<float,ITk::SiSpacePointsProSeed*> ITkMapOneSeedsQ;
    std::multimap<float,ITk::SiSpacePointsProSeed*> ITkSeeds;
    std::multimap<float,ITk::SiSpacePointsProSeed*>::iterator ITkSeedIterator;
 

    void resizeSPCont(size_t increment=50, ToolType type = ToolType::ATLxk){
      size_t currSizeSP = SP.size();
      size_t newSizeSP = currSizeSP + increment;
      if (type == ToolType::ITk) {
        size_t currSizeITkSP = ITkSP.size();
        size_t newSizeITkSP = currSizeITkSP + increment;
        ITkSP.resize(newSizeITkSP, nullptr);
        X.resize(newSizeITkSP, 0.);
        Y.resize(newSizeITkSP, 0.);
        Tn.resize(newSizeITkSP);
        SP.resize(newSizeSP, nullptr);
      } else {
        SP.resize(newSizeSP, nullptr);
      }
      R.resize(newSizeSP, 0.);
      Tz.resize(newSizeSP, 0.);
      Er.resize(newSizeSP, 0.);
      U.resize(newSizeSP, 0.);
      V.resize(newSizeSP, 0.);
      if (type != ToolType::Cosmic) {
        Zo.resize(newSizeSP, 0.);
      }
    }

    void initialize(ToolType type,
                    int maxsizeSP,
                    int maxOneSize,
                    int maxsize,
                    int sizeR,
                    int sizeRF,
                    int sizeRFZ,
                    int sizeRFZV,
                    bool checkEta) {
      if (type==ToolType::ATLxk) {
        CmSp.reserve(500);
      } else if (type==ToolType::ITk) {
        ITkCmSp.reserve(500);
      }
      resizeSPCont(maxsizeSP,type);
      seedPerSpCapacity = maxOneSize;
      if (type==ToolType::ATLxk) {
        OneSeeds_Pro.resize(maxOneSize);
      } else if (type==ToolType::BeamGas or type==ToolType::HeavyIon or type==ToolType::LowMomentum or type==ToolType::Trigger) {
        OneSeeds.resize(maxOneSize);
      } else if (type==ToolType::ITk) {
        ITkOneSeeds.resize(maxOneSize);
        ITkOneSeedsQ.resize(maxOneSize);
      }
 
      // Build radius sorted containers
      r_index.resize(sizeR, 0);
      r_map.resize(sizeR, 0);
      if (type==ToolType::ITk) {
        r_ITkSorted.resize(sizeR);
      } else {
        r_Sorted.resize(sizeR);
      }
 
      if (type==ToolType::BeamGas or type==ToolType::Cosmic) {
        // Build radius-azimuthal sorted containers
        rf_index.resize(sizeRF, 0);
        rf_map.resize(sizeRF, 0);
        rf_Sorted.resize(sizeRF, {});
      }
 
      // Build radius-azimuthal-Z sorted containers
      rfz_index.resize(sizeRFZ, 0);
      rfz_map.resize(sizeRFZ, 0);
      if (type==ToolType::ITk) {
        rfz_ITkSorted.resize(sizeRFZ, {});
      } else {
        rfz_Sorted.resize(sizeRFZ, {});
      }
 
      if (type==ToolType::ATLxk or type==ToolType::HeavyIon or type==ToolType::ITk or type==ToolType::Trigger) {
        // Build radius-azimuthal-Z sorted containers for Z-vertices
        rfzv_index.resize(sizeRFZV, 0);
        rfzv_map.resize(sizeRFZV, 0);
        if (type==ToolType::ITk) {
          rfzv_ITkSorted.resize(sizeRFZV, {});
        } else {
          rfzv_Sorted.resize(sizeRFZV, {});
        }
      }
 
      if (type==ToolType::Cosmic) {
        seeds.resize(maxsize+5);
      }
 
      if (type==ToolType::ATLxk) {
        i_seed_Pro  = l_seeds_Pro.begin();
        i_seede_Pro = l_seeds_Pro.end();
      } else if (type==ToolType::BeamGas or type==ToolType::HeavyIon or type==ToolType::LowMomentum or type==ToolType::Trigger) {
        i_seed  = l_seeds.begin();
        i_seede = l_seeds.end();
      } else if (type==ToolType::ITk) {
        i_ITkSeed  = i_ITkSeeds.begin();
        i_ITkSeedEnd = i_ITkSeeds.end();
      }
 
      if (type==ToolType::Trigger) {
        seed  = mapSeeds.begin();
        seede = mapSeeds.end();
      }
 
      if (type==ToolType::ATLxk or type==ToolType::ITk) {
        checketa = checkEta;
      }
 
      initialized = true;
    }
  };
 
} // end of name space
 
#endif // SiSpacePointsSeedMakerEventData_h