FPGATrackSimMappingSvc Class Reference

#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.

{return m_pmap_vector_1st.size();}

GetPlaneMap_2ndSliceSize()

virtual size_t FPGATrackSimMappingSvc::GetPlaneMap_2ndSliceSize ( ) const

inlineoverrideprivatevirtual

Definition at line 71 of file FPGATrackSimMappingSvc.h.

{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.

{ 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.

{ 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.

{ return m_rmap_1st.get(); }

RegionMap_2nd()

virtual const FPGATrackSimRegionMap * FPGATrackSimMappingSvc::RegionMap_2nd ( ) const

inlineoverridevirtual

Definition at line 32 of file FPGATrackSimMappingSvc.h.

{ return m_rmap_2nd.get(); }

SubRegionMap()

virtual const FPGATrackSimRegionMap * FPGATrackSimMappingSvc::SubRegionMap ( ) const

inlineoverridevirtual

Definition at line 33 of file FPGATrackSimMappingSvc.h.

{ return m_subrmap.get();  }

SubRegionMap_2nd()

virtual const FPGATrackSimRegionMap * FPGATrackSimMappingSvc::SubRegionMap_2nd ( ) const

inlineoverridevirtual

Definition at line 34 of file FPGATrackSimMappingSvc.h.

{ 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.

{this, "DoGNNTrack", false, "flag to do NN tracking models for GNN tracking" };

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.

{this, "GNNModuleMap", "", "path of the GNN Module Map file"};

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.

{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 }"};

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.

{this, "loadRadii", true, "Whether or not to attempt to read in the idealized radii files" };

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.

{this, "loadRegionMap", true, "Whether or not to attempt to loda the region maps; if false, isInRegion will always return true" };

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.

{this, "mappingType", "FILE", "for now should be FILE only, DB for the future"};

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.

{this, "modulemap", "", "path of the ModuleLUT file"};

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.

{this, "FakeNNonnx2nd", "", "path of the NN weighting file for 2nd stage"};

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.

{this, "ParamNNonnx2nd", "", "path of the NN weighting file for 2nd stage"};

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.

{this, "ExtensionNNHitonnx", "", "path of the NN weighting file"};

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.

{this, "ExtensionNNVolonnx", "", "path of the NN weighting file"};

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.

{this, "FakeNNonnx1st", "", "path of the NN weighting file for 1st stage"};

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.

{this, "ParamNNonnx1st", "", "path of the NN weighting file for 1st stage"};

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.

{this, "pmap", "", "path of the PMAP file"};

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.

{this, "radiiFile2nd", "", "path of the average radius file for 2nd stage" };

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.

{this, "radiiFile", "", "path of the average radius file" };

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.

{ this, "regionID", 0, "current region under processing"};  // Current region of interest

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.

{this, "rmap", "", "path of the region-map file"};

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.

{this, "subrmap", "", "path of the region-map file for subregions"};

---

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

• FPGATrackSimMappingSvc.h
• FPGATrackSimMappingSvc.cxx