#include <FPGATrackSimMappingSvc.h>

Inheritance diagram for FPGATrackSimMappingSvc:

Collaboration diagram for FPGATrackSimMappingSvc:

Public Member Functions
	FPGATrackSimMappingSvc (const std::string &name, ISvcLocator *svc)

virtual	~FPGATrackSimMappingSvc ()=default

virtual StatusCode	initialize () override

virtual const FPGATrackSimPlaneMap *	PlaneMap_1st (int slice) const override

virtual const FPGATrackSimPlaneMap *	PlaneMap_2nd (int slice) const override

virtual const FPGATrackSimRegionMap *	RegionMap_1st () const override

virtual const FPGATrackSimRegionMap *	RegionMap_2nd () const override

virtual const FPGATrackSimRegionMap *	SubRegionMap () const override

virtual const FPGATrackSimRegionMap *	SubRegionMap_2nd () const override

virtual std::string	getFakeNNMapString () const override

virtual std::string	getFakeNNMap2ndString () const override

virtual std::string	getExtensionNNHitMapString () const override

virtual std::string	getExtensionNNVolMapString () const override

virtual std::string	getParamNNMapString () const override

virtual std::string	getParamNNMap2ndString () const override

virtual std::string	getGNNModuleMapString () const override

Private Member Functions
virtual size_t	GetPlaneMap_1stSliceSize () const override

virtual size_t	GetPlaneMap_2ndSliceSize () const override

int	readPmapSize (std::ifstream &fileIn)

int	countPmapSize (std::ifstream &fileIn)

StatusCode	checkInputs ()

StatusCode	checkAllocs ()

Private Attributes
Gaudi::Property< unsigned int >	m_regionID { this, "regionID", 0, "current region under processing"}

Gaudi::Property< std::string >	m_mappingType {this, "mappingType", "FILE", "for now should be FILE only, DB for the future"}

Gaudi::Property< std::string >	m_rmap_path {this, "rmap", "", "path of the region-map file"}

Gaudi::Property< std::string >	m_subrmap_path {this, "subrmap", "", "path of the region-map file for subregions"}

Gaudi::Property< std::string >	m_pmap_path {this, "pmap", "", "path of the PMAP file"}

Gaudi::Property< std::string >	m_modulelut_path {this, "modulemap", "", "path of the ModuleLUT file"}

Gaudi::Property< std::string >	m_NNmap_path_fake {this, "FakeNNonnx1st", "", "path of the NN weighting file for 1st stage"}

Gaudi::Property< std::string >	m_NNmap2nd_path_fake {this, "FakeNNonnx2nd", "", "path of the NN weighting file for 2nd stage"}

Gaudi::Property< std::string >	m_NNmap_path_extension_vol {this, "ExtensionNNVolonnx", "", "path of the NN weighting file"}

Gaudi::Property< std::string >	m_NNmap_path_extension_hit {this, "ExtensionNNHitonnx", "", "path of the NN weighting file"}

Gaudi::Property< std::string >	m_NNmap_path_param {this, "ParamNNonnx1st", "", "path of the NN weighting file for 1st stage"}

Gaudi::Property< std::string >	m_NNmap2nd_path_param {this, "ParamNNonnx2nd", "", "path of the NN weighting file for 2nd stage"}

Gaudi::Property< std::string >	m_GNNmap_path_moduleMap {this, "GNNModuleMap", "", "path of the GNN Module Map file"}

Gaudi::Property< std::string >	m_radii_path {this, "radiiFile", "", "path of the average radius file" }

Gaudi::Property< std::string >	m_radii2nd_path {this, "radiiFile2nd", "", "path of the average radius file for 2nd stage" }

Gaudi::Property< std::vector< int > >	m_layerOverrides {this, "layerOverride", {}, "Overrides the selection of the 1st stage logical layers in the plane map. Each entry declares a detector layer to use as a logical layer. Specify a detector layer with { SiliconTech * 1000 + DetectorZone * 100 + PhysicalLayer }"}

Gaudi::Property< bool >	m_loadRadii {this, "loadRadii", true, "Whether or not to attempt to read in the idealized radii files" }

Gaudi::Property< bool >	m_loadRegionMap {this, "loadRegionMap", true, "Whether or not to attempt to loda the region maps; if false, isInRegion will always return true" }

Gaudi::Property< bool >	m_doGNNTrack {this, "DoGNNTrack", false, "flag to do NN tracking models for GNN tracking" }

std::vector< std::unique_ptr< FPGATrackSimPlaneMap > >	m_pmap_vector_1st

std::vector< std::unique_ptr< FPGATrackSimPlaneMap > >	m_pmap_vector_2nd

std::unique_ptr< FPGATrackSimRegionMap >	m_rmap_1st = nullptr

std::unique_ptr< FPGATrackSimRegionMap >	m_rmap_2nd = nullptr

std::unique_ptr< FPGATrackSimRegionMap >	m_subrmap = nullptr

std::unique_ptr< FPGATrackSimRegionMap >	m_subrmap_2nd = nullptr

std::unique_ptr< FPGATrackSimNNMap >	m_NNmap_fake = nullptr

std::unique_ptr< FPGATrackSimNNMap >	m_NNmap_param = nullptr

std::unique_ptr< FPGATrackSimNNMap >	m_NNmap2nd_fake = nullptr

std::unique_ptr< FPGATrackSimNNMap >	m_NNmap2nd_param = nullptr

std::unique_ptr< FPGATrackSimNNMap >	m_NNmap_extension_vol = nullptr

std::unique_ptr< FPGATrackSimNNMap >	m_NNmap_extension_hit = nullptr

std::unique_ptr< FPGATrackSimNNMap >	m_GNNmap_moduleMap = nullptr

size_t	m_numberOfPmaps = 0

Detailed Description

Definition at line 20 of file FPGATrackSimMappingSvc.h.

Constructor & Destructor Documentation

◆ FPGATrackSimMappingSvc()

FPGATrackSimMappingSvc::FPGATrackSimMappingSvc	(	const std::string &	name,
		ISvcLocator *	svc
	)

Definition at line 7 of file FPGATrackSimMappingSvc.cxx.

                                                                                      :
     base_class(name, svc)
 {
 }

◆ ~FPGATrackSimMappingSvc()

virtual FPGATrackSimMappingSvc::~FPGATrackSimMappingSvc ( )

virtualdefault

Member Function Documentation

◆ checkAllocs()

StatusCode FPGATrackSimMappingSvc::checkAllocs ( )

private

Definition at line 28 of file FPGATrackSimMappingSvc.cxx.

 {
     if (m_pmap_vector_1st.empty())
     {
         ATH_MSG_FATAL("Error using 1st stage plane map no elements of vector made: " << m_pmap_vector_1st);
         return StatusCode::FAILURE;
     }
     if (!m_numberOfPmaps){
         ATH_MSG_FATAL("Error with declared number of plane maps: " << m_pmap_path);
         return StatusCode::FAILURE;
     }
     if (m_numberOfPmaps != (m_pmap_vector_1st.size())){
         ATH_MSG_FATAL("Error using number of declared plane maps does not equal number of loaded plane maps: " << m_pmap_path<<"=/="<<m_pmap_vector_1st.size());
         return StatusCode::FAILURE;
     }
     for (size_t a = 0 ; a < m_pmap_vector_1st.size() ;a++)
     {
         if(!m_pmap_vector_1st.at(a)){
             ATH_MSG_FATAL("Error using 1st stage plane map for slice: " << a <<" of "<< m_pmap_vector_1st.size());
             return StatusCode::FAILURE;
         }
     }
     if (m_pmap_vector_2nd.empty())
     {
         ATH_MSG_FATAL("Error using 2nd stage plane map no elements of vector made: " << m_pmap_vector_2nd);
         return StatusCode::FAILURE;
     }
     if (!m_numberOfPmaps){
         ATH_MSG_FATAL("Error with declared number of plane maps: " << m_pmap_path);
         return StatusCode::FAILURE;
     }
     if (m_numberOfPmaps != (m_pmap_vector_2nd.size())){
         ATH_MSG_FATAL("Error using number of declared plane maps does not equal number of loaded plane maps: " << m_pmap_path<<"=/="<<m_pmap_vector_2nd.size());
         return StatusCode::FAILURE;
     }
     for (size_t a = 0 ; a < m_pmap_vector_2nd.size() ;a++)
     {
         if(!m_pmap_vector_2nd.at(a)){
             ATH_MSG_FATAL("Error using 1st stage plane map for slice: " << a <<" of "<< m_pmap_vector_2nd.size());
             return StatusCode::FAILURE;
         }
     }
     if (!m_rmap_1st){
         ATH_MSG_FATAL("Error creating region map for 1st stage from: " << m_rmap_path);
         return StatusCode::FAILURE;
     }
     if (!m_rmap_2nd){
         ATH_MSG_FATAL("Error creating region map for 2nd stage from: " << m_rmap_path);
         return StatusCode::FAILURE;
     }
     if (!m_subrmap){
         ATH_MSG_FATAL("Error creating sub-region map from: " << m_subrmap_path);
         return StatusCode::FAILURE;
     }
     if (!m_subrmap_2nd){
         ATH_MSG_FATAL("Error creating second stage sub-region map from: " << m_subrmap_path);
         return StatusCode::FAILURE;
     }
     return StatusCode::SUCCESS;
 }

◆ checkInputs()

StatusCode FPGATrackSimMappingSvc::checkInputs ( )

private

Definition at line 13 of file FPGATrackSimMappingSvc.cxx.

 {
     if (m_pmap_path.value().empty())
         ATH_MSG_FATAL("Main plane map definition missing");
     else if (m_rmap_path.value().empty())
         ATH_MSG_FATAL("Missing region map path");
     else if (m_modulelut_path.value().empty())
         ATH_MSG_FATAL("Module LUT file is missing");
     else
         return StatusCode::SUCCESS;
  
     return StatusCode::FAILURE;
 }

◆ countPmapSize()

int FPGATrackSimMappingSvc::countPmapSize ( std::ifstream & fileIn )

private

Definition at line 156 of file FPGATrackSimMappingSvc.cxx.

 {
     std::string line;
  
     getline(fileIn, line);
     std::istringstream sline(line);
     std::string geoKeyCheck;
     sline >> geoKeyCheck;
     m_numberOfPmaps = 1;
     while (getline(fileIn,line)){
         std::istringstream sline(line);
         std::string geoKeyCandidate;
         sline >> geoKeyCandidate;
         if(geoKeyCheck.compare(geoKeyCandidate)==0){
             m_numberOfPmaps++;
         }
     }
     return m_numberOfPmaps;
 }

◆ getExtensionNNHitMapString()

std::string FPGATrackSimMappingSvc::getExtensionNNHitMapString ( ) const

overridevirtual

Definition at line 119 of file FPGATrackSimMappingSvc.cxx.

                                                                    {
     if (m_NNmap_extension_hit != nullptr) {
         return m_NNmap_extension_hit->getNNMap();
     }
     else{
         return "";
     }
 }

◆ getExtensionNNVolMapString()

std::string FPGATrackSimMappingSvc::getExtensionNNVolMapString ( ) const

overridevirtual

Definition at line 110 of file FPGATrackSimMappingSvc.cxx.

                                                                    {
     if (m_NNmap_extension_vol != nullptr) {
         return m_NNmap_extension_vol->getNNMap();
     }
     else{
         return "";
     }
 }

◆ getFakeNNMap2ndString()

std::string FPGATrackSimMappingSvc::getFakeNNMap2ndString ( ) const

overridevirtual

Definition at line 100 of file FPGATrackSimMappingSvc.cxx.

                                                               {
     if (m_NNmap2nd_fake != nullptr) {
         return m_NNmap2nd_fake->getNNMap();
     }
     else{
         return "";
     }
 }

◆ getFakeNNMapString()

std::string FPGATrackSimMappingSvc::getFakeNNMapString ( ) const

overridevirtual

Definition at line 90 of file FPGATrackSimMappingSvc.cxx.

                                                            {
     if (m_NNmap_fake != nullptr) {
         return m_NNmap_fake->getNNMap();
     }
     else{
         return "";
     }
 }

◆ getGNNModuleMapString()

std::string FPGATrackSimMappingSvc::getGNNModuleMapString ( ) const

overridevirtual

Definition at line 147 of file FPGATrackSimMappingSvc.cxx.

                                                               {
     if (m_GNNmap_moduleMap != nullptr) {
         return m_GNNmap_moduleMap->getNNMap();
     }
     else{
         return "";
     }
 }

◆ getParamNNMap2ndString()

std::string FPGATrackSimMappingSvc::getParamNNMap2ndString ( ) const

overridevirtual

Definition at line 138 of file FPGATrackSimMappingSvc.cxx.

                                                                {
     if (m_NNmap2nd_param != nullptr) {
         return m_NNmap2nd_param->getNNMap();
     }
     else{
         return "";
     }
 }

◆ getParamNNMapString()

std::string FPGATrackSimMappingSvc::getParamNNMapString ( ) const

overridevirtual

Definition at line 129 of file FPGATrackSimMappingSvc.cxx.

                                                             {
     if (m_NNmap_param != nullptr) {
         return m_NNmap_param->getNNMap();
     }
     else{
         return "";
     }
 }

◆ GetPlaneMap_1stSliceSize()

virtual size_t FPGATrackSimMappingSvc::GetPlaneMap_1stSliceSize ( ) const

inlineoverrideprivatevirtual

Definition at line 70 of file FPGATrackSimMappingSvc.h.

70 {return m_pmap_vector_1st.size();}

◆ GetPlaneMap_2ndSliceSize()

virtual size_t FPGATrackSimMappingSvc::GetPlaneMap_2ndSliceSize ( ) const

inlineoverrideprivatevirtual

Definition at line 71 of file FPGATrackSimMappingSvc.h.

71 {return m_pmap_vector_2nd.size();}

◆ initialize()

StatusCode FPGATrackSimMappingSvc::initialize ( )

overridevirtual

Definition at line 175 of file FPGATrackSimMappingSvc.cxx.

 {
     ATH_CHECK(checkInputs());
  
     if (m_mappingType.value() == "FILE")
     {
         const std::string & filepath = PathResolverFindCalibFile(m_pmap_path.value());
         std::ifstream fin(filepath);
         if (!fin.is_open())
         {
             ATH_MSG_DEBUG("Couldn't open " << filepath);
             throw ("FPGATrackSimPlaneMap Couldn't open " + filepath);
         }
         
         countPmapSize(fin);
         fin.close();
         fin.open(filepath);
         ATH_MSG_DEBUG("Creating the 1st stage plane map");
         for (size_t i = 0; i<m_numberOfPmaps; i++)
         {
             m_pmap_vector_1st.emplace_back(std::make_unique<FPGATrackSimPlaneMap>(fin, m_regionID, 1, m_layerOverrides));
         }
         
         fin.close();
         fin.open(filepath);
         ATH_MSG_DEBUG("Creating the 2nd stage plane map");
         for (size_t i = 0; i<m_numberOfPmaps; i++)
         {
             m_pmap_vector_2nd.emplace_back(std::make_unique<FPGATrackSimPlaneMap>(fin, m_regionID, 2, m_layerOverrides));
         }
         fin.close();
  
         ATH_MSG_DEBUG("Creating the 1st stage region map: " << PathResolverFindCalibFile(m_rmap_path.value()));
         m_rmap_1st = std::unique_ptr<FPGATrackSimRegionMap>(new FPGATrackSimRegionMap(m_pmap_vector_1st, PathResolverFindCalibFile(m_rmap_path.value()), !(m_loadRegionMap.value())));
  
         ATH_MSG_DEBUG("Creating the 2nd stage region map: " << PathResolverFindCalibFile(m_rmap_path.value()));
         m_rmap_2nd = std::unique_ptr<FPGATrackSimRegionMap>(new FPGATrackSimRegionMap(m_pmap_vector_2nd, PathResolverFindCalibFile(m_rmap_path.value()), !(m_loadRegionMap.value())));
  
         ATH_MSG_DEBUG("Creating the sub-region map: " << PathResolverFindCalibFile(m_subrmap_path.value()));
         m_subrmap = std::unique_ptr<FPGATrackSimRegionMap>(new FPGATrackSimRegionMap(m_pmap_vector_1st, PathResolverFindCalibFile(m_subrmap_path.value()), !(m_loadRegionMap.value())));
  
         ATH_MSG_DEBUG("Creating the 2nd stage sub-region map:" << PathResolverFindCalibFile(m_subrmap_path.value()));
         m_subrmap_2nd = std::unique_ptr<FPGATrackSimRegionMap>(new FPGATrackSimRegionMap(m_pmap_vector_2nd, PathResolverFindCalibFile(m_subrmap_path.value()), !(m_loadRegionMap.value())));
  
         ATH_MSG_DEBUG("Setting the Modules LUT for Region Maps");
         ATH_MSG_DEBUG("Loading the Module LUT from " << PathResolverFindCalibFile(m_modulelut_path.value()));
         m_rmap_1st->loadModuleIDLUT(PathResolverFindCalibFile(m_modulelut_path.value()));
         m_rmap_2nd->loadModuleIDLUT(PathResolverFindCalibFile(m_modulelut_path.value()));
  
         if (m_loadRadii) {
             ATH_MSG_DEBUG("Setting the average radius per logical layer for Region and Subregion Maps");
             ATH_MSG_DEBUG("Loading Radii from " << PathResolverFindCalibFile(m_radii_path.value()));
             m_rmap_1st->loadRadiiFile(PathResolverFindCalibFile(m_radii_path.value()), 0, m_pmap_vector_1st.at(0)->getNLogiLayers());
             m_rmap_2nd->loadRadiiFile(PathResolverFindCalibFile(m_radii_path.value()), 0, m_pmap_vector_1st.at(0)->getNLogiLayers());
             m_rmap_2nd->loadRadiiFile(PathResolverFindCalibFile(m_radii2nd_path.value()), m_pmap_vector_1st.at(0)->getNLogiLayers(), m_pmap_vector_2nd.at(0)->getNLogiLayers());
  
             m_subrmap->loadRadiiFile(PathResolverFindCalibFile(m_radii_path.value()), 0, m_pmap_vector_1st.at(0)->getNLogiLayers());
             m_subrmap_2nd->loadRadiiFile(PathResolverFindCalibFile(m_radii_path.value()), 0, m_pmap_vector_1st.at(0)->getNLogiLayers());
             m_subrmap_2nd->loadRadiiFile(PathResolverFindCalibFile(m_radii2nd_path.value()), m_pmap_vector_1st.at(0)->getNLogiLayers(), m_pmap_vector_2nd.at(0)->getNLogiLayers());
         }
  
         ATH_MSG_DEBUG("Creating NN weighting map");
         ATH_MSG_INFO("MappingSVc using " << m_NNmap_path_fake.value() << " for fake track estimation");
         ATH_MSG_INFO("MappingSVc using " << m_NNmap_path_param.value() << " for track parameter estimation");
         ATH_MSG_INFO("MappingSVc using " << m_NNmap2nd_path_fake.value() << " for 2nd stage fake track estimation");
         ATH_MSG_INFO("MappingSVc using " << m_NNmap2nd_path_param.value() << " for 2nd stage track parameter estimation");
         ATH_MSG_INFO("MappingSVc using " << m_NNmap_path_extension_vol.value() << " for track extension");
         ATH_MSG_INFO("MappingSVc using " << m_NNmap_path_extension_hit.value() << " for track extension");
  
         if ( ! m_NNmap_path_extension_vol.empty() ) {
         std::string model_path = m_NNmap_path_extension_vol.value() + "_" + std::to_string(m_regionID) + "_cyl_condor.onnx";
         m_NNmap_extension_vol = std::make_unique<FPGATrackSimNNMap>(PathResolverFindCalibFile(model_path));
     } else {
             m_NNmap_extension_vol = nullptr;
     }
  
     if ( ! m_NNmap_path_extension_hit.empty() ) {
       std::string model_path = m_NNmap_path_extension_hit.value() + "_" + std::to_string(m_regionID) + "_cyl_condor.onnx";
       m_NNmap_extension_hit = std::make_unique<FPGATrackSimNNMap>(PathResolverFindCalibFile(model_path));
     } else {
             m_NNmap_extension_hit = nullptr;
            
         }
  
         if ( ! m_NNmap_path_fake.empty() ) {
         std::string model_path = m_NNmap_path_fake.value() + "_" + std::to_string(m_regionID) + "_condor.onnx";
         m_NNmap_fake = std::make_unique<FPGATrackSimNNMap>(PathResolverFindCalibFile(model_path));
     } else {
             m_NNmap_fake = nullptr;
         }
  
         if ( ! m_NNmap2nd_path_fake.empty() ) {
       std::string model_path = m_NNmap2nd_path_fake.value() + "_" + std::to_string(m_regionID) + "_condor.onnx";
       m_NNmap2nd_fake = std::make_unique<FPGATrackSimNNMap>(PathResolverFindCalibFile(model_path));
     } else {
       m_NNmap2nd_fake = nullptr;
         }   
  
         if (m_doGNNTrack) { // For GNN algorithms to use second stage models in first stage
             if ( ! m_NNmap_path_param.empty() ) {
                 std::string model_path = m_NNmap_path_param.value() + "_" + std::to_string(m_regionID) + "_condor.onnx";
                 m_NNmap_param = std::make_unique<FPGATrackSimNNMap>(PathResolverFindCalibFile(model_path));
             } else {
                 m_NNmap_param = nullptr;
             }
         }
         else { // For GenScan/InsideOut algorithms to use first stage models
             if ( ! m_NNmap_path_param.empty() ) {     
                 std::string model_path;
                 if(m_regionID <= 354) model_path = m_NNmap_path_param.value() + "_34_354.onnx";
                 else if (m_regionID <= 738)  model_path = m_NNmap_path_param.value() + "_418_738.onnx";
                 else model_path = m_NNmap_path_param.value() + "_802_1250.onnx";      
                 m_NNmap_param = std::make_unique<FPGATrackSimNNMap>(PathResolverFindCalibFile(model_path));
             } else {
                 m_NNmap_param = nullptr;
             }
         }
  
         if ( ! m_NNmap2nd_path_param.empty() ) {
             std::string model_path = m_NNmap2nd_path_param.value() + "_" + std::to_string(m_regionID) + "_condor.onnx";
             m_NNmap_param = std::make_unique<FPGATrackSimNNMap>(PathResolverFindCalibFile(model_path));
         } else {
             m_NNmap_param = nullptr;
         }
  
         if ( ! m_GNNmap_path_moduleMap.empty() ) {
             std::string model_path = m_GNNmap_path_moduleMap.value()+ "_" + std::to_string(m_regionID) + ".root";
             m_GNNmap_moduleMap = std::make_unique<FPGATrackSimNNMap>(PathResolverFindCalibFile(model_path));
         } else {
             m_GNNmap_moduleMap = nullptr;
         }
     }
     ATH_CHECK(checkAllocs());
     return StatusCode::SUCCESS;
 }

◆ PlaneMap_1st()

virtual const FPGATrackSimPlaneMap* FPGATrackSimMappingSvc::PlaneMap_1st ( int slice ) const

inlineoverridevirtual

Definition at line 29 of file FPGATrackSimMappingSvc.h.

29 { return m_pmap_vector_1st.at(slice).get(); }

◆ PlaneMap_2nd()

virtual const FPGATrackSimPlaneMap* FPGATrackSimMappingSvc::PlaneMap_2nd ( int slice ) const

inlineoverridevirtual

Definition at line 30 of file FPGATrackSimMappingSvc.h.

30 { return m_pmap_vector_2nd.at(slice).get(); }

◆ readPmapSize()

int FPGATrackSimMappingSvc::readPmapSize ( std::ifstream & fileIn )

private

◆ RegionMap_1st()

virtual const FPGATrackSimRegionMap* FPGATrackSimMappingSvc::RegionMap_1st ( ) const

inlineoverridevirtual

Definition at line 31 of file FPGATrackSimMappingSvc.h.

31 { return m_rmap_1st.get(); }

◆ RegionMap_2nd()

virtual const FPGATrackSimRegionMap* FPGATrackSimMappingSvc::RegionMap_2nd ( ) const

inlineoverridevirtual

Definition at line 32 of file FPGATrackSimMappingSvc.h.

32 { return m_rmap_2nd.get(); }

◆ SubRegionMap()

virtual const FPGATrackSimRegionMap* FPGATrackSimMappingSvc::SubRegionMap ( ) const

inlineoverridevirtual

Definition at line 33 of file FPGATrackSimMappingSvc.h.

33 { return m_subrmap.get(); }

◆ SubRegionMap_2nd()

virtual const FPGATrackSimRegionMap* FPGATrackSimMappingSvc::SubRegionMap_2nd ( ) const

inlineoverridevirtual

Definition at line 34 of file FPGATrackSimMappingSvc.h.

34 { return m_subrmap_2nd.get(); }

Member Data Documentation

◆ m_doGNNTrack

Gaudi::Property<bool> FPGATrackSimMappingSvc::m_doGNNTrack {this, "DoGNNTrack", false, "flag to do NN tracking models for GNN tracking" }

private

Definition at line 64 of file FPGATrackSimMappingSvc.h.

◆ m_GNNmap_moduleMap

std::unique_ptr<FPGATrackSimNNMap> FPGATrackSimMappingSvc::m_GNNmap_moduleMap = nullptr

private

Definition at line 82 of file FPGATrackSimMappingSvc.h.

◆ m_GNNmap_path_moduleMap

Gaudi::Property<std::string> FPGATrackSimMappingSvc::m_GNNmap_path_moduleMap {this, "GNNModuleMap", "", "path of the GNN Module Map file"}

private

Definition at line 58 of file FPGATrackSimMappingSvc.h.

◆ m_layerOverrides

Gaudi::Property<std::vector <int> > FPGATrackSimMappingSvc::m_layerOverrides {this, "layerOverride", {}, "Overrides the selection of the 1st stage logical layers in the plane map. Each entry declares a detector layer to use as a logical layer. Specify a detector layer with { SiliconTech * 1000 + DetectorZone * 100 + PhysicalLayer }"}

private

Definition at line 61 of file FPGATrackSimMappingSvc.h.

◆ m_loadRadii

Gaudi::Property<bool> FPGATrackSimMappingSvc::m_loadRadii {this, "loadRadii", true, "Whether or not to attempt to read in the idealized radii files" }

private

Definition at line 62 of file FPGATrackSimMappingSvc.h.

◆ m_loadRegionMap

Gaudi::Property<bool> FPGATrackSimMappingSvc::m_loadRegionMap {this, "loadRegionMap", true, "Whether or not to attempt to loda the region maps; if false, isInRegion will always return true" }

private

Definition at line 63 of file FPGATrackSimMappingSvc.h.

◆ m_mappingType

Gaudi::Property<std::string> FPGATrackSimMappingSvc::m_mappingType {this, "mappingType", "FILE", "for now should be FILE only, DB for the future"}

private

Definition at line 47 of file FPGATrackSimMappingSvc.h.

◆ m_modulelut_path

Gaudi::Property<std::string> FPGATrackSimMappingSvc::m_modulelut_path {this, "modulemap", "", "path of the ModuleLUT file"}

private

Definition at line 51 of file FPGATrackSimMappingSvc.h.

◆ m_NNmap2nd_fake

std::unique_ptr<FPGATrackSimNNMap> FPGATrackSimMappingSvc::m_NNmap2nd_fake = nullptr

private

Definition at line 78 of file FPGATrackSimMappingSvc.h.

◆ m_NNmap2nd_param

std::unique_ptr<FPGATrackSimNNMap> FPGATrackSimMappingSvc::m_NNmap2nd_param = nullptr

private

Definition at line 79 of file FPGATrackSimMappingSvc.h.

◆ m_NNmap2nd_path_fake

Gaudi::Property<std::string> FPGATrackSimMappingSvc::m_NNmap2nd_path_fake {this, "FakeNNonnx2nd", "", "path of the NN weighting file for 2nd stage"}

private

Definition at line 53 of file FPGATrackSimMappingSvc.h.

◆ m_NNmap2nd_path_param

Gaudi::Property<std::string> FPGATrackSimMappingSvc::m_NNmap2nd_path_param {this, "ParamNNonnx2nd", "", "path of the NN weighting file for 2nd stage"}

private

Definition at line 57 of file FPGATrackSimMappingSvc.h.

◆ m_NNmap_extension_hit

std::unique_ptr<FPGATrackSimNNMap> FPGATrackSimMappingSvc::m_NNmap_extension_hit = nullptr

private

Definition at line 81 of file FPGATrackSimMappingSvc.h.

◆ m_NNmap_extension_vol

std::unique_ptr<FPGATrackSimNNMap> FPGATrackSimMappingSvc::m_NNmap_extension_vol = nullptr

private

Definition at line 80 of file FPGATrackSimMappingSvc.h.

◆ m_NNmap_fake

std::unique_ptr<FPGATrackSimNNMap> FPGATrackSimMappingSvc::m_NNmap_fake = nullptr

private

Definition at line 76 of file FPGATrackSimMappingSvc.h.

◆ m_NNmap_param

std::unique_ptr<FPGATrackSimNNMap> FPGATrackSimMappingSvc::m_NNmap_param = nullptr

private

Definition at line 77 of file FPGATrackSimMappingSvc.h.

◆ m_NNmap_path_extension_hit

Gaudi::Property<std::string> FPGATrackSimMappingSvc::m_NNmap_path_extension_hit {this, "ExtensionNNHitonnx", "", "path of the NN weighting file"}

private

Definition at line 55 of file FPGATrackSimMappingSvc.h.

◆ m_NNmap_path_extension_vol

Gaudi::Property<std::string> FPGATrackSimMappingSvc::m_NNmap_path_extension_vol {this, "ExtensionNNVolonnx", "", "path of the NN weighting file"}

private

Definition at line 54 of file FPGATrackSimMappingSvc.h.

◆ m_NNmap_path_fake

Gaudi::Property<std::string> FPGATrackSimMappingSvc::m_NNmap_path_fake {this, "FakeNNonnx1st", "", "path of the NN weighting file for 1st stage"}

private

Definition at line 52 of file FPGATrackSimMappingSvc.h.

◆ m_NNmap_path_param

Gaudi::Property<std::string> FPGATrackSimMappingSvc::m_NNmap_path_param {this, "ParamNNonnx1st", "", "path of the NN weighting file for 1st stage"}

private

Definition at line 56 of file FPGATrackSimMappingSvc.h.

◆ m_numberOfPmaps

size_t FPGATrackSimMappingSvc::m_numberOfPmaps = 0

private

Definition at line 85 of file FPGATrackSimMappingSvc.h.

◆ m_pmap_path

Gaudi::Property<std::string> FPGATrackSimMappingSvc::m_pmap_path {this, "pmap", "", "path of the PMAP file"}

private

Definition at line 50 of file FPGATrackSimMappingSvc.h.

◆ m_pmap_vector_1st

std::vector<std::unique_ptr<FPGATrackSimPlaneMap> > FPGATrackSimMappingSvc::m_pmap_vector_1st

private

Definition at line 68 of file FPGATrackSimMappingSvc.h.

◆ m_pmap_vector_2nd

std::vector<std::unique_ptr<FPGATrackSimPlaneMap> > FPGATrackSimMappingSvc::m_pmap_vector_2nd

private

Definition at line 69 of file FPGATrackSimMappingSvc.h.

◆ m_radii2nd_path

Gaudi::Property<std::string> FPGATrackSimMappingSvc::m_radii2nd_path {this, "radiiFile2nd", "", "path of the average radius file for 2nd stage" }

private

Definition at line 60 of file FPGATrackSimMappingSvc.h.

◆ m_radii_path

Gaudi::Property<std::string> FPGATrackSimMappingSvc::m_radii_path {this, "radiiFile", "", "path of the average radius file" }

private

Definition at line 59 of file FPGATrackSimMappingSvc.h.

◆ m_regionID

Gaudi::Property<unsigned int> FPGATrackSimMappingSvc::m_regionID { this, "regionID", 0, "current region under processing"}

private

Definition at line 46 of file FPGATrackSimMappingSvc.h.

◆ m_rmap_1st

std::unique_ptr<FPGATrackSimRegionMap> FPGATrackSimMappingSvc::m_rmap_1st = nullptr

private

Definition at line 72 of file FPGATrackSimMappingSvc.h.

◆ m_rmap_2nd

std::unique_ptr<FPGATrackSimRegionMap> FPGATrackSimMappingSvc::m_rmap_2nd = nullptr

private

Definition at line 73 of file FPGATrackSimMappingSvc.h.

◆ m_rmap_path

Gaudi::Property<std::string> FPGATrackSimMappingSvc::m_rmap_path {this, "rmap", "", "path of the region-map file"}

private

Definition at line 48 of file FPGATrackSimMappingSvc.h.

◆ m_subrmap

std::unique_ptr<FPGATrackSimRegionMap> FPGATrackSimMappingSvc::m_subrmap = nullptr

private

Definition at line 74 of file FPGATrackSimMappingSvc.h.

◆ m_subrmap_2nd

std::unique_ptr<FPGATrackSimRegionMap> FPGATrackSimMappingSvc::m_subrmap_2nd = nullptr

private

Definition at line 75 of file FPGATrackSimMappingSvc.h.

◆ m_subrmap_path

Gaudi::Property<std::string> FPGATrackSimMappingSvc::m_subrmap_path {this, "subrmap", "", "path of the region-map file for subregions"}

private

Definition at line 49 of file FPGATrackSimMappingSvc.h.

The documentation for this class was generated from the following files:

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ FPGATrackSimMappingSvc()

◆ ~FPGATrackSimMappingSvc()

Member Function Documentation

◆ checkAllocs()

◆ checkInputs()

◆ countPmapSize()

◆ getExtensionNNHitMapString()

◆ getExtensionNNVolMapString()

◆ getFakeNNMap2ndString()

◆ getFakeNNMapString()

◆ getGNNModuleMapString()

◆ getParamNNMap2ndString()

◆ getParamNNMapString()

◆ GetPlaneMap_1stSliceSize()

◆ GetPlaneMap_2ndSliceSize()

◆ initialize()

◆ PlaneMap_1st()

◆ PlaneMap_2nd()

◆ readPmapSize()

◆ RegionMap_1st()

◆ RegionMap_2nd()

◆ SubRegionMap()

◆ SubRegionMap_2nd()

Member Data Documentation

◆ m_doGNNTrack

◆ m_GNNmap_moduleMap

◆ m_GNNmap_path_moduleMap

◆ m_layerOverrides

◆ m_loadRadii

◆ m_loadRegionMap

◆ m_mappingType

◆ m_modulelut_path

◆ m_NNmap2nd_fake

◆ m_NNmap2nd_param

◆ m_NNmap2nd_path_fake

◆ m_NNmap2nd_path_param

◆ m_NNmap_extension_hit

◆ m_NNmap_extension_vol

◆ m_NNmap_fake

◆ m_NNmap_param

◆ m_NNmap_path_extension_hit

◆ m_NNmap_path_extension_vol

◆ m_NNmap_path_fake

◆ m_NNmap_path_param

◆ m_numberOfPmaps

◆ m_pmap_path

◆ m_pmap_vector_1st

◆ m_pmap_vector_2nd

◆ m_radii2nd_path

◆ m_radii_path

◆ m_regionID

◆ m_rmap_1st

◆ m_rmap_2nd

◆ m_rmap_path

◆ m_subrmap

◆ m_subrmap_2nd

◆ m_subrmap_path