#include <FPGATrackSimMapMakerAlg.h>

Inheritance diagram for FPGATrackSimMapMakerAlg:

Collaboration diagram for FPGATrackSimMapMakerAlg:

Classes
struct	Module

Public Types
typedef std::tuple< SiliconTech, DetectorZone, int, int, int >	FPGATrackSimModuleId

Public Member Functions
	FPGATrackSimMapMakerAlg (const std::string &name, ISvcLocator *pSvcLocator)

virtual	~FPGATrackSimMapMakerAlg ()=default

StatusCode	initialize () override

StatusCode	execute () override

StatusCode	finalize () override

virtual StatusCode	sysInitialize () override
	Override sysInitialize. More...

virtual const DataObjIDColl &	extraOutputDeps () const override
	Return the list of extra output dependencies. More...

ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard `StoreGateSvc` (event store) Returns (kind of) a pointer to the `StoreGateSvc`. More...

const ServiceHandle< StoreGateSvc > &	evtStore () const
	The standard `StoreGateSvc` (event store) Returns (kind of) a pointer to the `StoreGateSvc`. More...

const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard `StoreGateSvc/DetectorStore` Returns (kind of) a pointer to the `StoreGateSvc`. More...

virtual StatusCode	sysStart () override
	Handle START transition. More...

virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles. More...

virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles. More...

Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T > &t)

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
	Declare a new Gaudi property. More...

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
	Declare a new Gaudi property. More...

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
	Declare a new Gaudi property. More...

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc="none")
	Declare a new Gaudi property. More...

void	updateVHKA (Gaudi::Details::PropertyBase &)

MsgStream &	msg () const

MsgStream &	msg (const MSG::Level lvl) const

bool	msgLvl (const MSG::Level lvl) const

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution More...

std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void >	renounce (T &h)

void	extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
	Add StoreName to extra input/output deps as needed. More...

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
StatusCode	readInputs (bool &done)

StatusCode	writePmapAndRmap (std::vector< FPGATrackSimHit > const &pbHits, std::vector< FPGATrackSimHit > const &peHits, std::vector< FPGATrackSimHit > const &sbHits, std::vector< FPGATrackSimHit > const &seHits, int region)

StatusCode	writeSubrmap (std::vector< FPGATrackSimHit > const &allHits)

StatusCode	writeEtaPatterns ()

StatusCode	writeRadiiFile (std::vector< FPGATrackSimHit > const &allHits)

StatusCode	writeMedianZFile (std::vector< FPGATrackSimHit > const &allHits)

void	drawSlices (std::vector< FPGATrackSimHit > const &allHits)

bool	isOnKeyLayer (int keynum, SiliconTech det, DetectorZone bec, int lyr)

int	findPlane (const std::vector< std::vector< std::string >> &planes, const std::string &test)

std::string	makeRmapLines (std::vector< FPGATrackSimHit > const &hits, SiliconTech det, DetectorZone bec, int max)

std::string	makeSubrmapLines (std::vector< Module * > const &allmods, SiliconTech det, DetectorZone bec, int max)

void	parseKeyString ()

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey> More...

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyArrayType &)
	specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleType &)
	specialization for handling Gaudi::Property<SG::VarHandleBase> More...

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &t, const SG::NotHandleType &)
	specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...

Private Attributes
ToolHandle< IFPGATrackSimEventInputHeaderTool >	m_hitInputTool { this, "InputTool", "FPGATrackSimSGToRawHitsTool/FPGATrackSimInputTool", "HitInput Tool" }

FPGATrackSimEventInputHeader	m_eventHeader

Gaudi::Property< int >	m_maxEvents {this, "maxEvents", 10000, "Max Events"}

Gaudi::Property< int >	m_region {this, "region", 0, "Region"}

Gaudi::Property< float >	m_trim {this, "trim", 0.1, "trim modules with less than given percent of tracks"}

Gaudi::Property< std::string >	m_outFileName {this, "OutFileName", "", "naming convention for maps"}

Gaudi::Property< std::string >	m_keystring {this, "KeyString", "strip,barrel,2", "key layer to use for subrmap"}

Gaudi::Property< std::string >	m_keystring2 {this, "KeyString2", "", "second key layer for 2D slicing"}

Gaudi::Property< int >	m_nSlices {this, "nSlices", -1, "default is full granularity/maximum number of slices possible"}

Gaudi::Property< bool >	m_doSpacePoints {this, "doSpacePoints", false, "Use 9L instead of 8L configuration for first stage (for example)"}

Gaudi::Property< float >	m_globalTrim {this, "globalTrim", 0.1, "Trimming applied globally to the key layer before determining slice boundaries"}

Gaudi::Property< std::string >	m_description {this, "description", "", "tag description"}

Gaudi::Property< std::string >	m_geoTag {this, "GeometryVersion", "ATLAS-P2-ITK-22-02-00", "Geometry tag that this set of maps is for. TODO can we store/read from wrappers?"}

Gaudi::Property< bool >	m_remapModules {this, "remapModules", false, "Allow maps to be drawn that slice modules more finely, by remapping module indices"}

Gaudi::Property< bool >	m_drawSlices {this, "drawSlices", false, "Draw the huge 2D slice histograms"}

Gaudi::Property< bool >	m_insideout {this, "doInsideOut", false, "5 layers pixel-only configuration"}

FPGATrackSimModuleRelabel *	m_moduleRelabel = nullptr

std::map< FPGATrackSimModuleId, Module >	m_modules

std::map< int, std::vector< Module * > >	m_track2modules

std::map< int, std::vector< Module * > >	m_slice2modules

std::map< int, int >	m_track2slice

std::vector< FPGATrackSimHit >	m_pbHits

std::vector< FPGATrackSimHit >	m_peHits

std::vector< FPGATrackSimHit >	m_sbHits

std::vector< FPGATrackSimHit >	m_seHits

std::vector< FPGATrackSimHit >	m_allHits

int	m_pbmax = -1

int	m_sbmax = -1

std::vector< int >	m_pemax = {-1,-1}

std::vector< int >	m_semax = {-1,-1}

const std::vector< std::vector< std::vector< std::string > > > *	m_planes {}

const std::vector< std::vector< std::vector< std::string > > >	m_planes_default

const std::vector< std::vector< std::vector< std::string > > >	m_planes_sp

const std::vector< std::vector< std::vector< std::string > > >	m_planes2

const std::vector< std::vector< std::vector< std::string > > >	m_planes_insideout

std::map< std::string, std::set< int > >	m_keylayer

std::map< std::string, std::set< int > >	m_keylayer2

bool	m_key2 = false

std::map< int, int >	m_key_etamods

std::set< int >	m_key_etamods2

std::set< int >	m_usedTracks

std::vector< std::vector< std::vector< float > > >	m_radii

std::vector< std::vector< std::vector< float > > >	m_z

std::ofstream	m_pmap

std::ofstream	m_rmap

std::ofstream	m_subrmap

std::ofstream	m_etapat

std::ofstream	m_radfile

std::ofstream	m_zedfile

std::unique_ptr< TFile >	m_monitorFile {}

const std::vector< uint32_t >	m_diskIndex = {0,17,47,58,66}

std::map< std::string, SiliconTech >	m_det2tech = { {"pixel",SiliconTech::pixel}, {"strip",SiliconTech::strip} }

std::map< std::string, DetectorZone >	m_bec2zone = { {"barrel",DetectorZone::barrel}, {"posEndcap",DetectorZone::posEndcap}, {"negEndcap",DetectorZone::negEndcap} }

DataObjIDColl	m_extendedExtraObjects

StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default) More...

StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default) More...

std::vector< SG::VarHandleKeyArray * >	m_vhka

bool	m_varHandleArraysDeclared

Detailed Description

Definition at line 31 of file FPGATrackSimMapMakerAlg.h.

Member Typedef Documentation

◆ FPGATrackSimModuleId

typedef std::tuple<SiliconTech, DetectorZone, int, int, int> FPGATrackSimMapMakerAlg::FPGATrackSimModuleId

Definition at line 34 of file FPGATrackSimMapMakerAlg.h.

◆ StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< Algorithm > >::StoreGateSvc_t

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

◆ FPGATrackSimMapMakerAlg()

FPGATrackSimMapMakerAlg::FPGATrackSimMapMakerAlg	(	const std::string &	name,
		ISvcLocator *	pSvcLocator
	)

Definition at line 17 of file FPGATrackSimMapMakerAlg.cxx.

                                                                                                  :
     AthAlgorithm(name, pSvcLocator)
 {
 }

◆ ~FPGATrackSimMapMakerAlg()

virtual FPGATrackSimMapMakerAlg::~FPGATrackSimMapMakerAlg ( )

virtualdefault

Member Function Documentation

◆ declareGaudiProperty() [1/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty	(	Gaudi::Property< T > &	hndl,
		const SG::VarHandleKeyArrayType &
	)

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKeyArray>

Definition at line 170 of file AthCommonDataStore.h.

   {
     return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                        hndl.value(), 
                                                        hndl.documentation());
  
   }

◆ declareGaudiProperty() [2/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty	(	Gaudi::Property< T > &	hndl,
		const SG::VarHandleKeyType &
	)

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKey>

Definition at line 156 of file AthCommonDataStore.h.

   {
     return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                        hndl.value(), 
                                                        hndl.documentation());
  
   }

◆ declareGaudiProperty() [3/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty	(	Gaudi::Property< T > &	hndl,
		const SG::VarHandleType &
	)

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleBase>

Definition at line 184 of file AthCommonDataStore.h.

   {
     return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                        hndl.value(), 
                                                        hndl.documentation());
   }

◆ declareGaudiProperty() [4/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty	(	Gaudi::Property< T > &	t,
		const SG::NotHandleType &
	)

inlineprivateinherited

specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray>

Definition at line 199 of file AthCommonDataStore.h.

   {
     return PBASE::declareProperty(t);
   }

◆ declareProperty() [1/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty	(	const std::string &	name,
		SG::VarHandleBase &	hndl,
		const std::string &	doc,
		const SG::VarHandleType &
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

This is the version for types that derive from SG::VarHandleBase. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 245 of file AthCommonDataStore.h.

   {
     this->declare(hndl.vhKey());
     hndl.vhKey().setOwner(this);
  
     return PBASE::declareProperty(name,hndl,doc);
   }

◆ declareProperty() [2/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty	(	const std::string &	name,
		SG::VarHandleKey &	hndl,
		const std::string &	doc,
		const SG::VarHandleKeyType &
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

This is the version for types that derive from SG::VarHandleKey. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 221 of file AthCommonDataStore.h.

   {
     this->declare(hndl);
     hndl.setOwner(this);
  
     return PBASE::declareProperty(name,hndl,doc);
   }

◆ declareProperty() [3/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty	(	const std::string &	name,
		SG::VarHandleKeyArray &	hndArr,
		const std::string &	doc,
		const SG::VarHandleKeyArrayType &
	)

inlineinherited

Definition at line 259 of file AthCommonDataStore.h.

   {
  
     // std::ostringstream ost;
     // ost << Algorithm::name() << " VHKA declareProp: " << name 
     //     << " size: " << hndArr.keys().size() 
     //     << " mode: " << hndArr.mode() 
     //     << "  vhka size: " << m_vhka.size()
     //     << "\n";
     // debug() << ost.str() << endmsg;
  
     hndArr.setOwner(this);
     m_vhka.push_back(&hndArr);
  
     Gaudi::Details::PropertyBase* p =  PBASE::declareProperty(name, hndArr, doc);
     if (p != 0) {
       p->declareUpdateHandler(&AthCommonDataStore<PBASE>::updateVHKA, this);
     } else {
       ATH_MSG_ERROR("unable to call declareProperty on VarHandleKeyArray " 
                     << name);
     }
  
     return p;
  
   }

◆ declareProperty() [4/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty	(	const std::string &	name,
		T &	property,
		const std::string &	doc,
		const SG::NotHandleType &
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

This is the generic version, for types that do not derive from SG::VarHandleKey. It just forwards to the base class version of declareProperty.

Definition at line 333 of file AthCommonDataStore.h.

   {
     return PBASE::declareProperty(name, property, doc);
   }

◆ declareProperty() [5/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty	(	const std::string &	name,
		T &	property,
		const std::string &	doc = `"none"`
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

This dispatches to either the generic declareProperty or the one for VarHandle/Key/KeyArray.

Definition at line 352 of file AthCommonDataStore.h.

   {
     typedef typename SG::HandleClassifier<T>::type htype;
     return declareProperty (name, property, doc, htype());
   }

◆ declareProperty() [6/6]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( Gaudi::Property< T > & t )

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

                                                                  {
     typedef typename SG::HandleClassifier<T>::type htype;
     return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
   }

◆ detStore()

const ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< Algorithm > >::detStore ( ) const

inlineinherited

The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 95 of file AthCommonDataStore.h.

95 { return m_detStore; }

◆ drawSlices()

void FPGATrackSimMapMakerAlg::drawSlices ( std::vector< FPGATrackSimHit > const & allHits )

private

Definition at line 727 of file FPGATrackSimMapMakerAlg.cxx.

 {
     m_monitorFile->cd();
  
     std::vector<TH2F*> h_slicemap;
     char *hname = new char[20];
  
     for (unsigned i = 0; i < (unsigned)m_nSlices.value(); i++)
     {
         sprintf(hname,"rz_slice%u",i);
         // This should just default to the entire range, I think.
         // The user can reduce the binning.
         TH2F *h = new TH2F(hname,hname,7000,-3500,3500,1200,0,1200);
         h_slicemap.push_back(h);
     }
  
     for (const auto& hit: allHits)
     {
         if (m_usedTracks.find(hit.getEventIndex()) == m_usedTracks.end()) continue; // skip if we don't use this track
         int s = m_track2slice[hit.getEventIndex()];
         h_slicemap[s]->Fill(hit.getZ(),hit.getR());
     }
  
     for (int i = 0; i < m_nSlices.value(); i++)
         h_slicemap[i]->Write();
  
     delete [] hname;
 }

◆ evtStore() [1/2]

ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< Algorithm > >::evtStore ( )

inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 85 of file AthCommonDataStore.h.

85 { return m_evtStore; }

◆ evtStore() [2/2]

const ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< Algorithm > >::evtStore ( ) const

inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 90 of file AthCommonDataStore.h.

90 { return m_evtStore; }

◆ execute()

StatusCode FPGATrackSimMapMakerAlg::execute ( )

override

Definition at line 71 of file FPGATrackSimMapMakerAlg.cxx.

 {
     // Read inputs
     bool done = false;
     ATH_CHECK(readInputs(done));
  
     if (done) {
       SmartIF<IEventProcessor> appMgr{service("ApplicationMgr")};
       if (!appMgr) {
           ATH_MSG_ERROR("Failed to retrieve ApplicationMgr as IEventProcessor");
           return StatusCode::FAILURE;
       }
       return appMgr->stopRun();
     }
  
     // Reset data pointers
     m_eventHeader.reset();
  
     return StatusCode::SUCCESS;
 }

◆ extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< Algorithm > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase & ExtraDeps )

protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

◆ extraOutputDeps()

const DataObjIDColl & AthAlgorithm::extraOutputDeps ( ) const

overridevirtualinherited

Return the list of extra output dependencies.

This list is extended to include symlinks implied by inheritance relations.

Definition at line 50 of file AthAlgorithm.cxx.

 {
   // If we didn't find any symlinks to add, just return the collection
   // from the base class.  Otherwise, return the extended collection.
   if (!m_extendedExtraObjects.empty()) {
     return m_extendedExtraObjects;
   }
   return Algorithm::extraOutputDeps();
 }

◆ finalize()

StatusCode FPGATrackSimMapMakerAlg::finalize ( )

override

Definition at line 709 of file FPGATrackSimMapMakerAlg.cxx.

 {
     // Write the output
     ATH_CHECK(writePmapAndRmap(m_pbHits, m_peHits, m_sbHits, m_seHits, m_region));
     ATH_CHECK(writeSubrmap(m_allHits));
     ATH_CHECK(writeEtaPatterns());
     ATH_CHECK(writeRadiiFile(m_allHits));
     ATH_CHECK(writeMedianZFile(m_allHits));
     m_monitorFile.reset();
     delete m_moduleRelabel;
     m_moduleRelabel = nullptr;
     return StatusCode::SUCCESS;
 }

◆ findPlane()

int FPGATrackSimMapMakerAlg::findPlane	(	const std::vector< std::vector< std::string >> &	planes,
		const std::string &	test
	)

private

Definition at line 771 of file FPGATrackSimMapMakerAlg.cxx.

 {
     int pcounter = 0;
     for (auto& plane : planes) {
         for (auto& layer : plane) {
             if (test == layer) return pcounter;
         }
         pcounter ++;
     }
     return -1;
 }

◆ initialize()

StatusCode FPGATrackSimMapMakerAlg::initialize ( )

override

Definition at line 23 of file FPGATrackSimMapMakerAlg.cxx.

 {
  
   m_monitorFile.reset (new TFile((m_outFileName.value() + ".root").c_str(), "RECREATE"));
     std::stringstream ss(m_description);
     std::string line;
     ATH_MSG_INFO("Tag config:");
     if (m_description.value() != "")
       while (std::getline(ss, line, '\n'))
     ATH_MSG_INFO('\t' << line);
  
     // reset Hit and Module vectors
     m_pbHits.clear(); m_peHits.clear(); m_sbHits.clear(); m_seHits.clear(); m_allHits.clear();
     m_track2modules.clear(); m_track2slice.clear(); m_slice2modules.clear();
     m_key_etamods.clear(); m_key_etamods2.clear(); m_usedTracks.clear();
     m_radii.clear(); m_keylayer.clear(); m_keylayer2.clear();
     m_modules.clear();
  
     // Set up the module relabel tool.
     m_moduleRelabel = new FPGATrackSimModuleRelabel(m_geoTag.value(), m_remapModules);
  
     // We need to select this before calling parseKeyString() in case the user
     // has specified a plane (logical layer) as the keystring.
     if (m_doSpacePoints) {
         ATH_MSG_INFO("Using Space Point Configuration");
         m_planes = &m_planes_sp;
     } else if (m_insideout) {
         ATH_MSG_INFO("Using Inside-Out Configuration");
         m_planes = &m_planes_insideout;
     } else {
         ATH_MSG_INFO("Using Default Configuration");
         m_planes = &m_planes_default;
     }
  
     parseKeyString();
     ATH_CHECK(m_hitInputTool.retrieve());
  
     ATH_MSG_DEBUG("initialize() Instantiating root objects");
     ATH_MSG_DEBUG("initialize() Finished");
  
  
     return StatusCode::SUCCESS;
 }

◆ inputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< Algorithm > >::inputHandles ( ) const

overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

◆ isOnKeyLayer()

bool FPGATrackSimMapMakerAlg::isOnKeyLayer	(	int	keynum,
		SiliconTech	det,
		DetectorZone	bec,
		int	lyr
	)

private

Definition at line 756 of file FPGATrackSimMapMakerAlg.cxx.

 {
     int det = static_cast<int>(t_det);
     int bec = static_cast<int>(t_bec);
     if (keynum == 1)
         if (m_keylayer["det"].find(det) != m_keylayer["det"].end() && m_keylayer["bec"].find(bec) != m_keylayer["bec"].end() && m_keylayer["lyr"].find(lyr) != m_keylayer["lyr"].end())
             return true;
  
     if (keynum == 2)
         if (m_keylayer2["det"].find(det) != m_keylayer2["det"].end() && m_keylayer2["bec"].find(bec) != m_keylayer2["bec"].end() && m_keylayer2["lyr"].find(lyr) != m_keylayer2["lyr"].end())
             return true;
  
     return false;
 }

◆ makeRmapLines()

std::string FPGATrackSimMapMakerAlg::makeRmapLines	(	std::vector< FPGATrackSimHit > const &	hits,
		SiliconTech	det,
		DetectorZone	bec,
		int	max
	)

private

Definition at line 783 of file FPGATrackSimMapMakerAlg.cxx.

 {
     std::stringstream rmap_line;
     std::set<int> etas, phis;
  
     for(int lyr = 0; lyr <= max; lyr++)
     {
         etas.clear();
         phis.clear();
         for (const auto& hit: hits)
         {
             if(static_cast<int>(hit.getPhysLayer()) == lyr && hit.getDetectorZone() == bec)  // cast from uint to int just to remove Wsign-compare warnings
             {
                 etas.insert(hit.getEtaModule());
                 phis.insert(hit.getPhiModule());
             }
         }
         if (etas.size() != 0) rmap_line << static_cast<int>(det) << " " << static_cast<int>(bec) << " " << lyr << " " << *phis.begin() << " " << *phis.rbegin() << " " << phis.size() << " " << *etas.begin() << " " << *etas.rbegin() << " " << etas.size() << "\n";
         else rmap_line << static_cast<int>(det) << " " << static_cast<int>(bec) << " " << lyr << " 0 0 0 0 0 0\n";
  
     }
  
     return rmap_line.str();
 }

◆ makeSubrmapLines()

std::string FPGATrackSimMapMakerAlg::makeSubrmapLines	(	std::vector< Module * > const &	allmods,
		SiliconTech	det,
		DetectorZone	bec,
		int	max
	)

private

Definition at line 902 of file FPGATrackSimMapMakerAlg.cxx.

 {
     std::stringstream subrmap_line;
     std::set<int> etas, phis;
  
     std::vector<Module*> mods;
     for (auto* mod: allmods) // just want modules in pb/pe/sb/se etc, not all at once
         if (mod->det == det && mod->bec == bec) mods.push_back(mod);
  
     for(int lyr = 0; lyr <= max; lyr++)
     {
         etas.clear();
         phis.clear();
         for (auto mod: mods)
         {
             if(mod->lyr == lyr)
             {
                 etas.insert(mod->eta);
                 phis.insert(mod->phi);
             }
         }
         if (etas.size() != 0) subrmap_line << static_cast<int>(det) << " " << static_cast<int>(bec) << " " << lyr << " " << *phis.begin() << " " << *phis.rbegin() << " " << phis.size() << " " << *etas.begin() << " " << *etas.rbegin() << " " << etas.size() << "\n";
         else subrmap_line << static_cast<int>(det) << " " << static_cast<int>(bec) << " " << lyr << " 0 0 0 0 0 0\n";
  
     }
  
     return subrmap_line.str();
 }

◆ msg() [1/2]

MsgStream& AthCommonMsg< Algorithm >::msg ( ) const

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                 {
     return this->msgStream();
   }

◆ msg() [2/2]

MsgStream& AthCommonMsg< Algorithm >::msg ( const MSG::Level lvl ) const

inlineinherited

Definition at line 27 of file AthCommonMsg.h.

                                                   {
     return this->msgStream(lvl);
   }

◆ msgLvl()

bool AthCommonMsg< Algorithm >::msgLvl ( const MSG::Level lvl ) const

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                                {
     return this->msgLevel(lvl);
   }

◆ outputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< Algorithm > >::outputHandles ( ) const

overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

◆ parseKeyString()

void FPGATrackSimMapMakerAlg::parseKeyString ( )

private

Definition at line 808 of file FPGATrackSimMapMakerAlg.cxx.

 {
     // Parse keystring and define the Key Layer
     std::string delimiter = ",";
     std::string s = m_keystring.value();
     std::string det, bec, lyr;
     std::map <std::string, std::vector<std::string>> abrevs = { {"pb",{"pixel","barrel"}}, {"pe",{"pixel","endcap"}}, {"sb",{"strip","barrel"}}, {"se",{"strip","endcap"}} };
     if( s.find(delimiter) != std::string::npos) // keylayer format is 'strip,barrel,4'
     {
         try {
             std::string det = s.substr(0, s.find(delimiter));
             s.erase(0, s.find(delimiter) + delimiter.length());
             std::string bec = s.substr(0, s.find(delimiter));
             s.erase(0, s.find(delimiter) + delimiter.length());
             std::string lyr = s.substr(0, s.find(delimiter));
             s.erase(0, s.find(delimiter) + delimiter.length());
             m_keylayer["det"].insert(static_cast<int>(m_det2tech[det]));
             m_keylayer["bec"].insert(static_cast<int>(m_bec2zone[bec]));
             m_keylayer["lyr"].insert(std::stoi(lyr));
         } catch (...){
             ATH_MSG_ERROR("Invalid KeyString: '" << m_keystring << "'." << "Accepted formats are 'strip,posEndcap,2', 'pixel,barrel,3', or 'plane 0'");
         }
     }
     else // keylayer format is 'plane 0'
     {
         std::string delimiter = " ";
         try {
             s.erase(0, s.find(delimiter) + delimiter.length());
             std::string plane = s.substr(0, s.find(delimiter));
             std::vector<std::string> s = (m_planes->at(m_region))[std::stoi(plane)];
             for (unsigned i = 0; i < s.size(); i++){
                 std::string reg = s[i].substr(0, 2);
                 std::vector<std::string> zone = abrevs[reg];
                 if (s[i].back() == '+') zone[1] = "posEndcap";
                 if (s[i].back() == '-') zone[1] = "negEndcap";
                 s[i].erase(std::remove(s[i].begin(), s[i].end(), '+'), s[i].end());
                 s[i].erase(std::remove(s[i].begin(), s[i].end(), '-'), s[i].end());
                 std::string lyr = s[i].substr(2);
                 m_keylayer["det"].insert(static_cast<int>(m_det2tech[zone[0]]));
                 m_keylayer["bec"].insert(static_cast<int>(m_bec2zone[zone[1]]));
                 m_keylayer["lyr"].insert(std::stoi(lyr));
             }
         } catch (...){
             ATH_MSG_ERROR("Invalid KeyString: '" << m_keystring << "'." << "Accepted formats are 'strip,posEndcap,2', 'pixel,barrel,3', or 'plane 0'");
         }
     }
  
     // if 2D slicing
     if (m_keystring2.value() != "")
     {
         m_key2 = true;
         std::string s = m_keystring2.value();
         if( s.find(delimiter) != std::string::npos) // keylayer format is 'strip,barrel,8'
         {
             try {
                 std::string det = s.substr(0, s.find(delimiter));
                 s.erase(0, s.find(delimiter) + delimiter.length());
                 std::string bec = s.substr(0, s.find(delimiter));
                 s.erase(0, s.find(delimiter) + delimiter.length());
                 std::string lyr = s.substr(0, s.find(delimiter));
                 s.erase(0, s.find(delimiter) + delimiter.length());
                 m_keylayer2["det"].insert(static_cast<int>(m_det2tech[det]));
                 m_keylayer2["bec"].insert(static_cast<int>(m_bec2zone[bec]));
                 m_keylayer2["lyr"].insert(std::stoi(lyr));
             } catch (...){
                 ATH_MSG_ERROR("Invalid KeyString2: '" << m_keystring2 << "'." << "Accepted formats are 'strip,posEndcap,2', 'pixel,barrel,3', or 'plane 0'");
             }
         }
         else // keylayer format is 'plane 0'
         {
             std::string delimiter = " ";
             try {
                 s.erase(0, s.find(delimiter) + delimiter.length());
                 std::string plane = s.substr(0, s.find(delimiter));
                 std::vector<std::string> s = (m_planes->at(m_region))[std::stoi(plane)];
                 for (unsigned i = 0; i < s.size(); i++){
                     std::string reg = s[i].substr(0, 2);
                     std::vector<std::string> zone = abrevs[reg];
                     if (s[i].back() == '+') zone[1] = "posEndcap";
                     if (s[i].back() == '-') zone[1] = "negEndcap";
                     s[i].erase(std::remove(s[i].begin(), s[i].end(), '+'), s[i].end());
                     s[i].erase(std::remove(s[i].begin(), s[i].end(), '-'), s[i].end());
                     std::string lyr = s[i].substr(2);
                     m_keylayer2["det"].insert(static_cast<int>(m_det2tech[zone[0]]));
                     m_keylayer2["bec"].insert(static_cast<int>(m_bec2zone[zone[1]]));
                     m_keylayer2["lyr"].insert(std::stoi(lyr));
                 }
             } catch (...){
                 ATH_MSG_ERROR("Invalid KeyString2: '" << m_keystring2 << "'." << "Accepted formats are 'strip,posEndcap,2', 'pixel,barrel,3', or 'plane 0'");
             }
         }
     }
 }

◆ readInputs()

StatusCode FPGATrackSimMapMakerAlg::readInputs ( bool & done )

private

Definition at line 98 of file FPGATrackSimMapMakerAlg.cxx.

 {
     // Read primary input
     ATH_CHECK(m_hitInputTool->readData(&m_eventHeader, done));
     if (done)
     {
         ATH_MSG_INFO("Cannot read more events from file, returning");
         return StatusCode::SUCCESS; // end of loop over events
     }
  
     FPGATrackSimEventInfo eventinfo = m_eventHeader.event();
     ATH_MSG_DEBUG ("Getting Event " << eventinfo);
  
     for (auto hit: m_eventHeader.hits()) // fill track to modules map and hit vectors
     {
         // barcode cut: these hits are not associated with our single muon tracks
         if (hit.getBarcodePt() == 0) continue;
  
         SiliconTech det = hit.getDetType();
         DetectorZone bec = hit.getDetectorZone();
         int lyr = hit.getPhysLayer(); 
         int eta = hit.getEtaModule();
         int phi = hit.getPhiModule();
  
         if (hit.isPixel() && hit.isBarrel()) {
             m_pbHits.push_back(hit);
             if (lyr > m_pbmax) m_pbmax = lyr;
         }
         else if (hit.isPixel() && !hit.isBarrel()) {
             // Perform the layer + module number remapping using our tool.
             m_moduleRelabel->remap(hit);
             eta = hit.getEtaModule();
             lyr = hit.getPhysLayer();
  
             m_peHits.push_back(hit);
             if (bec == DetectorZone::posEndcap && lyr > m_pemax[0]) m_pemax[0] = lyr;
             if (bec == DetectorZone::negEndcap && lyr > m_pemax[1]) m_pemax[1] = lyr;
         }
         else if (!hit.isPixel() && hit.isBarrel()) {
             m_sbHits.push_back(hit);
             if (lyr > m_sbmax) m_sbmax = lyr;
         }
         else if (!hit.isPixel() && !hit.isBarrel()) {
             m_seHits.push_back(hit);
             if (bec == DetectorZone::posEndcap && lyr > m_semax[0]) m_semax[0] = lyr;
             if (bec == DetectorZone::negEndcap && lyr > m_semax[1]) m_semax[1] = lyr;
         }
         else ATH_MSG_ERROR("Invalid Region");
  
          // keep track of all etamods on the key layer for slicing
         if (isOnKeyLayer(1,det,bec,lyr)) {
             if (m_key_etamods.count(eta) == 0) {
                 m_key_etamods.insert(std::pair<int, int>(eta, 1));
             } else {
                 m_key_etamods[eta] += 1;
             }
         }
  
         if (m_key2) // if doing 2D slicing
             if (isOnKeyLayer(2,det,bec,lyr)) m_key_etamods2.insert(eta);
  
         // Keep a global record of all modules as we see them, indexed by the ID tuple.
         Module mod = Module(det, bec, lyr, eta, phi);
         if (m_modules.count(mod.moduleId()) == 0) {
             m_modules.insert(std::pair<FPGATrackSimModuleId, Module>(mod.moduleId(), mod));
         }
         Module* modref = &(m_modules[mod.moduleId()]);
  
         if (std::find(m_track2modules[hit.getEventIndex()].begin(), m_track2modules[hit.getEventIndex()].end(), modref) == m_track2modules[hit.getEventIndex()].end())
             m_track2modules[hit.getEventIndex()].push_back(modref);
         m_allHits.push_back(hit);
     }
  
     return StatusCode::SUCCESS;
 }

◆ renounce()

std::enable_if_t<std::is_void_v<std::result_of_t<decltype(&T::renounce)(T)> > && !std::is_base_of_v<SG::VarHandleKeyArray, T> && std::is_base_of_v<Gaudi::DataHandle, T>, void> AthCommonDataStore< AthCommonMsg< Algorithm > >::renounce ( T & h )

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

   {
     h.renounce();
     PBASE::renounce (h);
   }

◆ renounceArray()

void AthCommonDataStore< AthCommonMsg< Algorithm > >::renounceArray ( SG::VarHandleKeyArray & handlesArray )

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                           {
     handlesArray.renounce();
   }

◆ sysInitialize()

StatusCode AthAlgorithm::sysInitialize ( )

overridevirtualinherited

Override sysInitialize.

Override sysInitialize from the base class.

Loop through all output handles, and if they're WriteCondHandles, automatically register them and this Algorithm with the CondSvc

Scan through all outputHandles, and if they're WriteCondHandles, register them with the CondSvc

Reimplemented from AthCommonDataStore< AthCommonMsg< Algorithm > >.

Reimplemented in AthAnalysisAlgorithm, AthFilterAlgorithm, PyAthena::Alg, and AthHistogramAlgorithm.

Definition at line 66 of file AthAlgorithm.cxx.

                                        {
   StatusCode sc=AthCommonDataStore<AthCommonMsg<Algorithm>>::sysInitialize();
  
   if (sc.isFailure()) {
     return sc;
   }
   ServiceHandle<ICondSvc> cs("CondSvc",name());
   for (auto h : outputHandles()) {
     if (h->isCondition() && h->mode() == Gaudi::DataHandle::Writer) {
       // do this inside the loop so we don't create the CondSvc until needed
       if ( cs.retrieve().isFailure() ) {
         ATH_MSG_WARNING("no CondSvc found: won't autoreg WriteCondHandles");
         return StatusCode::SUCCESS;
       }
       if (cs->regHandle(this,*h).isFailure()) {
         sc = StatusCode::FAILURE;
         ATH_MSG_ERROR("unable to register WriteCondHandle " << h->fullKey()
                       << " with CondSvc");
       }
     }
   }
   return sc;
 }

◆ sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< Algorithm > >::sysStart ( )

overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

◆ updateVHKA()

void AthCommonDataStore< AthCommonMsg< Algorithm > >::updateVHKA ( Gaudi::Details::PropertyBase & )

inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

                                                {
     // debug() << "updateVHKA for property " << p.name() << " " << p.toString() 
     //         << "  size: " << m_vhka.size() << endmsg;
     for (auto &a : m_vhka) {
       std::vector<SG::VarHandleKey*> keys = a->keys();
       for (auto k : keys) {
         k->setOwner(this);
       }
     }
   }

◆ writeEtaPatterns()

StatusCode FPGATrackSimMapMakerAlg::writeEtaPatterns ( )

private

Definition at line 504 of file FPGATrackSimMapMakerAlg.cxx.

 {
     std::stringstream trim;
     std::stringstream gtrim;
     trim << std::fixed << std::setprecision(3) << m_trim;
     gtrim << std::fixed << std::setprecision(3) << m_globalTrim;
     std::string str_trim = trim.str();
     std::string str_gtrim = gtrim.str();
     int dot = str_trim.find_last_of(".");
     str_trim.replace(dot,1,"p");
     str_gtrim.replace(str_gtrim.find_last_of("."), 1, "p");
  
     std::string slicingType = "";
     if (m_key2) slicingType = "2D";
     std::string etapat_path = m_outFileName.value() + "region" + std::to_string(m_region) + "_trim" + str_trim + + "_gtrim" + str_gtrim + "_NSlices-" + std::to_string(m_nSlices.value()) + slicingType + "_etapatterns.patt";
  
     ATH_MSG_INFO("Creating eta patterns file: " << etapat_path);
     m_etapat.open(etapat_path, std::ofstream::out);
  
     // assign logical layer to each module
     for (auto& pair: m_track2modules) {
         for (auto& m: pair.second)
         {
             if (m->det == SiliconTech::pixel && m->bec == DetectorZone::barrel) m->plane = findPlane(m_planes->at(m_region), "pb" + std::to_string(m->lyr));
             if (m->det == SiliconTech::pixel && m->bec == DetectorZone::posEndcap) m->plane = findPlane(m_planes->at(m_region), "pe" + std::to_string(m->lyr) + "+");
             if (m->det == SiliconTech::pixel && m->bec == DetectorZone::negEndcap) m->plane = findPlane(m_planes->at(m_region), "pe" + std::to_string(m->lyr) + "-");
  
             if (m->det == SiliconTech::strip && m->bec == DetectorZone::barrel) m->plane = findPlane(m_planes->at(m_region), "sb" + std::to_string(m->lyr));
             if (m->det == SiliconTech::strip && m->bec == DetectorZone::posEndcap) m->plane = findPlane(m_planes->at(m_region), "se" + std::to_string(m->lyr) + "+");
             if (m->det == SiliconTech::strip && m->bec == DetectorZone::negEndcap) m->plane = findPlane(m_planes->at(m_region), "se" + std::to_string(m->lyr) + "-");
         }
     }
  
     for(auto trk: m_usedTracks)
     {
         std::stringstream track_etapatts;
         unsigned planesDone = 0;
         for (unsigned p = 0; p < (m_planes->at(m_region)).size(); p++)
         {
             for (const Module* m : m_track2modules[trk]) {
                 if (m->plane == static_cast<int>(p))
                 {
                     track_etapatts << std::to_string(static_cast<int>(m->det)) << "\t" << std::to_string(static_cast<int>(m->bec)) << "\t" << std::to_string(m->eta) << "\t\t";
                     planesDone++;
                     break;
                 }
             }
         }
         if (planesDone == (m_planes->at(m_region)).size())
             m_etapat << track_etapatts.str() << "\n";
  
     }
     m_etapat.close();
     return StatusCode::SUCCESS;
 }

◆ writeMedianZFile()

StatusCode FPGATrackSimMapMakerAlg::writeMedianZFile ( std::vector< FPGATrackSimHit > const & allHits )

private

Definition at line 629 of file FPGATrackSimMapMakerAlg.cxx.

 {
     // calculate median z. We do this globally and slice-by-slice.
   m_z.resize(m_nSlices.value(), std::vector<std::vector<float>>((m_planes2.at(m_region)).size(),std::vector<float>(0)));
     for (const auto& hit: allHits)
     {
         SiliconTech det = hit.getDetType();
         DetectorZone bec = hit.getDetectorZone();
         int lyr = hit.getPhysLayer();
         int slice = m_track2slice[hit.getEventIndex()];
         int plane = -1;
         if (det == SiliconTech::pixel && bec == DetectorZone::barrel) plane = findPlane(m_planes2.at(m_region), "pb" + std::to_string(lyr));
         if (det == SiliconTech::pixel && bec == DetectorZone::posEndcap) plane = findPlane(m_planes2.at(m_region), "pe" + std::to_string(lyr) + "+");
         if (det == SiliconTech::pixel && bec == DetectorZone::negEndcap) plane = findPlane(m_planes2.at(m_region), "pe" + std::to_string(lyr) + "-");
         if (det == SiliconTech::strip && bec == DetectorZone::barrel) plane = findPlane(m_planes2.at(m_region), "sb" + std::to_string(lyr));
         if (det == SiliconTech::strip && bec == DetectorZone::posEndcap) plane = findPlane(m_planes2.at(m_region), "se" + std::to_string(lyr) + "+");
         if (det == SiliconTech::strip && bec == DetectorZone::negEndcap) plane = findPlane(m_planes2.at(m_region), "se" + std::to_string(lyr) + "-");
  
         if (plane != -1) {
             m_z[slice][plane].push_back(hit.getZ());
         }
     }
  
     // print file
     std::string zed_path = m_outFileName.value() + "region" + std::to_string(m_region) + "_NSlices-" + std::to_string(m_nSlices.value()) + "_MedianZ.txt";
     ATH_MSG_INFO("Creating median z file: " << zed_path);
     m_zedfile.open(zed_path, std::ofstream::out);
     for (int s = 0; s < m_nSlices.value(); s++){
         m_zedfile << std::to_string(s) << " ";
         for (unsigned p = 0; p < (m_planes2.at(m_region)).size(); p++){
             if (m_z[s][p].size() != 0){
                 float minZ = *std::min_element(m_z[s][p].begin(), m_z[s][p].end());
                 float maxZ = *std::max_element(m_z[s][p].begin(), m_z[s][p].end());
                 float median = (minZ + maxZ)/2;
                 m_zedfile << std::setprecision(3) << std::fixed << median << " ";
             } else {
                 int median = -1;
                 m_zedfile << median << " ";
             }
         }
         m_zedfile << std::endl;
     }
  
     // Now do this globally. Note: should this be meanZ instead of medianZ in the forward region?
     m_zedfile << -1 << " ";
     for (unsigned p = 0; p < (m_planes2.at(m_region)).size(); p++) {
         float minZ = 0;
         float maxZ = 0;
         bool doneInitial = false;
         for (int s = 0; s < m_nSlices.value(); s++) {
             if (m_z[s][p].size() != 0) {
                 float newMinZ = *std::min_element(m_z[s][p].begin(), m_z[s][p].end());
                 float newMaxZ = *std::max_element(m_z[s][p].begin(), m_z[s][p].end());
                 // slightly clunky, but z can be positive and negative so there's not a sane initial/placeholder value.
                 if (doneInitial) {
                     minZ = std::min(minZ, newMinZ);
                     maxZ = std::max(maxZ, newMaxZ);
                 } else {
                     minZ = newMinZ;
                     maxZ = newMaxZ;
                     doneInitial = true;
                 }
             }
         }
         if (doneInitial) {
             float median = (minZ + maxZ)/2;
             m_zedfile << std::setprecision(3) << std::fixed << median << " ";
         } else {
             int median = -1;
             m_zedfile << median << " ";
         }
     }
     m_zedfile << std::endl;
  
     m_zedfile.close();
  
     return StatusCode::SUCCESS;
 }

◆ writePmapAndRmap()

StatusCode FPGATrackSimMapMakerAlg::writePmapAndRmap	(	std::vector< FPGATrackSimHit > const &	pbHits,
		std::vector< FPGATrackSimHit > const &	peHits,
		std::vector< FPGATrackSimHit > const &	sbHits,
		std::vector< FPGATrackSimHit > const &	seHits,
		int	region
	)

private

Definition at line 180 of file FPGATrackSimMapMakerAlg.cxx.

 {
     // Plane Map
  
     // to avoid vector _M_range_check errors, print at least one line for each DetectorZone
     if (m_pbmax == -1) m_pbmax = 0;
     if (m_sbmax == -1) m_sbmax = 0;
     if (m_pemax[0] == -1) m_pemax[0] = 0;
     if (m_pemax[1] == -1) m_pemax[1] = 0;
     if (m_semax[0] == -1) m_semax[0] = 0;
     if (m_semax[1] == -1) m_semax[1] = 0;
  
     std::string pmap_path = m_outFileName.value() + "region" + std::to_string(m_region) + ".pmap";
     ATH_MSG_INFO("Creating pmap: " << pmap_path);
     m_pmap.open(pmap_path, std::ofstream::out);
  
     m_pmap << m_geoTag.value() << "\n" << m_planes->at(reg).size() << " logical_s1\n" << m_planes2[reg].size() << " logical_s2\n";
     m_pmap << m_pbmax+1 << " pixel barrel \n" << m_pemax[0]+1 << " pixel endcap+ \n" << m_pemax[1]+1 << " pixel endcap- \n";
     m_pmap << m_sbmax+1 << " SCT barrel \n" << m_semax[0]+1 << " SCT endcap+\n" << m_semax[1]+1 << " SCT endcap-\n";
     m_pmap << "! silicon endCap physDisk physLayer ['stereo' stripSide <strip only>] 'plane1' logiLayer1 'plane2' logiLayer2\n";
     m_pmap << "\nregion " << reg << "\n";
  
     int p1,p2;
     for (int lyr = 0; lyr <= m_pbmax; lyr++) { // Pixel Barrel
         p1 = findPlane(m_planes->at(reg), "pb" + std::to_string(lyr));
         p2 = findPlane(m_planes2[reg], "pb" + std::to_string(lyr));
         m_pmap << "pixel 0    -1    " << lyr << " plane1 " << p1 << "    plane2 " << p2 << "\n";
     }
     for (int lyr = 0; lyr <= m_pemax[0]; lyr++) { // Pixel Postive Endap
         p1 = findPlane(m_planes->at(reg), "pe" + std::to_string(lyr) + "+");
         p2 = findPlane(m_planes2[reg], "pe" + std::to_string(lyr) + "+");
         m_pmap << "pixel 1    " << lyr << "    " << lyr << " plane1 " << p1 << "    plane2 " << p2 << "\n";
     }
     for (int lyr = 0; lyr <= m_pemax[1]; lyr++) { // Pixel Negative Endcap
         p1 = findPlane(m_planes->at(reg), "pe" + std::to_string(lyr) + "-");
         p2 = findPlane(m_planes2[reg], "pe" + std::to_string(lyr) + "-");
         m_pmap << "pixel 2    " << lyr << "    " << lyr << " plane1 " << p1 << "    plane2 " << p2 << "\n";
     }
     for (int lyr = 0; lyr <= m_sbmax; lyr++) { // Strip Barrel
         p1 = findPlane(m_planes->at(reg), "sb" + std::to_string(lyr));
         p2 = findPlane(m_planes2[reg], "sb" + std::to_string(lyr));
         m_pmap << "SCT 0    -1    " << lyr << " stereo " <<  lyr % 2 << " plane1 "  << p1 << "    plane2 " << p2 << "\n";
     }
     for (int lyr = 0; lyr <= m_semax[0]; lyr++) { // Strip Positive Endcap
         p1 = findPlane(m_planes->at(reg), "se" + std::to_string(lyr) + "+");
         p2 = findPlane(m_planes2[reg], "se" + std::to_string(lyr) + "+");
         m_pmap << "SCT 1    "  << lyr/2 << "    " << lyr << " stereo " <<  lyr % 2 << " plane1 " << p1 << "    plane2 " << p2 << "\n";
     }
     for (int lyr = 0; lyr <= m_semax[1]; lyr++) { // Strip Negative Endcap
         p1 = findPlane(m_planes->at(reg), "se" + std::to_string(lyr) + "-");
         p2 = findPlane(m_planes2[reg], "se" + std::to_string(lyr) + "-");
         m_pmap << "SCT 2    "  << lyr/2 << "    " << lyr << " stereo " <<  lyr % 2 << " plane1 " << p1 << "    plane2 " << p2 << "\n";
     }
  
     // Region Map
     std::string rmap_path = m_outFileName.value() + "region" + std::to_string(m_region) + ".rmap";
     ATH_MSG_INFO("Creating rmap: " << rmap_path);
     m_rmap.open(rmap_path, std::ofstream::out);
     m_rmap << "towers 1 phi 16\n\n0\n";
  
     m_rmap << makeRmapLines(pbHits, SiliconTech::pixel, DetectorZone::barrel, m_pbmax);
     m_rmap << makeRmapLines(peHits, SiliconTech::pixel, DetectorZone::posEndcap, m_pemax[0]);
     m_rmap << makeRmapLines(peHits, SiliconTech::pixel, DetectorZone::negEndcap, m_pemax[1]);
  
     m_rmap << makeRmapLines(sbHits, SiliconTech::strip, DetectorZone::barrel, m_sbmax);
     m_rmap << makeRmapLines(seHits, SiliconTech::strip, DetectorZone::posEndcap, m_semax[0]);
     m_rmap << makeRmapLines(seHits, SiliconTech::strip, DetectorZone::negEndcap, m_semax[1]);
  
     m_pmap.close();
     m_rmap.close();
  
     // Step 1: Read the entire contents of the file
     std::ifstream inputFile(pmap_path);
     if (!inputFile) {
         ATH_MSG_ERROR("Error: Unable to open file for reading: " << pmap_path);
         return StatusCode::FAILURE;
     }
  
     std::ostringstream buffer;
     buffer << inputFile.rdbuf();  // Reading the entire file into the stringstream
     std::string fileContent = buffer.str();
     inputFile.close();
  
     // Step 2: Concatenate the content n times
     std::string newContent;
     for (int i = 0; i < m_nSlices; ++i) {
         newContent += fileContent;
         newContent += '\n';
     }
  
     // Step 3: Write the new content back to the same file
     std::ofstream outputFile(pmap_path);
     if (!outputFile) {
         ATH_MSG_ERROR("Error: Unable to open file for writing: " << pmap_path);
         return StatusCode::FAILURE;
     }
  
     outputFile << newContent;
     outputFile.close();
  
     return StatusCode::SUCCESS;
 }

◆ writeRadiiFile()

StatusCode FPGATrackSimMapMakerAlg::writeRadiiFile ( std::vector< FPGATrackSimHit > const & allHits )

private

Definition at line 560 of file FPGATrackSimMapMakerAlg.cxx.

 {
     // calculate mean radii.
   m_radii.resize(m_nSlices.value(), std::vector<std::vector<float>>(m_planes2.at(m_region).size(),std::vector<float>(0)));
     for (const auto& hit: allHits)
     {
         SiliconTech det = hit.getDetType();
         DetectorZone bec = hit.getDetectorZone();
         int lyr = hit.getPhysLayer();
         int slice = m_track2slice[hit.getEventIndex()];
         int plane = -1;
         if (det == SiliconTech::pixel && bec == DetectorZone::barrel) plane = findPlane(m_planes2.at(m_region), "pb" + std::to_string(lyr));
         if (det == SiliconTech::pixel && bec == DetectorZone::posEndcap) plane = findPlane(m_planes2.at(m_region), "pe" + std::to_string(lyr) + "+");
         if (det == SiliconTech::pixel && bec == DetectorZone::negEndcap) plane = findPlane(m_planes2.at(m_region), "pe" + std::to_string(lyr) + "-");
         if (det == SiliconTech::strip && bec == DetectorZone::barrel) plane = findPlane(m_planes2.at(m_region), "sb" + std::to_string(lyr));
         if (det == SiliconTech::strip && bec == DetectorZone::posEndcap) plane = findPlane(m_planes2.at(m_region), "se" + std::to_string(lyr) + "+");
         if (det == SiliconTech::strip && bec == DetectorZone::negEndcap) plane = findPlane(m_planes2.at(m_region), "se" + std::to_string(lyr) + "-");
  
         if (plane != -1) {
             m_radii[slice][plane].push_back(hit.getR());
         }
     }
  
     // print file
     std::string radii_path = m_outFileName.value() + "region" + std::to_string(m_region) + "_NSlices-" + std::to_string(m_nSlices.value()) + "_MeanRadii.txt";
     ATH_MSG_INFO("Creating radii file: " << radii_path);
     m_radfile.open(radii_path, std::ofstream::out);
     for (int s = 0; s < m_nSlices.value(); s++){
         m_radfile << std::to_string(s) << " ";
         for (unsigned p = 0; p < (m_planes2.at(m_region)).size(); p++){
             if (m_radii[s][p].size() != 0){
                 // "If left to type inference, op operates on values of the same type as
                 // init which can result in unwanted casting of the iterator elements."
                 // https://en.cppreference.com/w/cpp/algorithm/accumulate
                 float avg = std::accumulate(m_radii[s][p].begin(), m_radii[s][p].end(), 0.0f) / float(m_radii[s][p].size());
                 m_radfile << std::setprecision(3) << std::fixed << avg << " ";
             } else {
                 int avg = -1;
                 m_radfile << avg << " ";
             }
         }
         m_radfile << "\n";
     }
  
     // Calculate global mean radii by reversing the order of the above two loops.
     m_radfile << -1 << " ";
     for (unsigned p = 0; p < (m_planes2.at(m_region)).size(); p++) {
         float avg = 0;
         int count = 0;
         for (int s = 0; s < m_nSlices.value(); s++) {
             if (m_radii[s][p].size() != 0) {
                 avg = std::accumulate(m_radii[s][p].begin(), m_radii[s][p].end(), avg);
                 count += m_radii[s][p].size();
             }
         }
         if (count > 0) {
             avg /= float(count);
             m_radfile << std::setprecision(3) << std::fixed << avg << " ";
         } else {
             m_radfile << -1 << " ";
         }
     }
     m_radfile << std::endl;
  
     m_radfile.close();
  
     return StatusCode::SUCCESS;
 }

◆ writeSubrmap()

StatusCode FPGATrackSimMapMakerAlg::writeSubrmap ( std::vector< FPGATrackSimHit > const & allHits )

private

Definition at line 283 of file FPGATrackSimMapMakerAlg.cxx.

 {
     /*   ----------  Create z-slices ---------- */
  
     // BEFORE DOING ANYTHING ELSE, apply global trimming to m_key_etamods.
     std::set<int> key_etamods;
     // First, sum up the total number of hits in the key layer. There should be a one-liner for this...
     float total_hits = 0;
     for (auto const &etamod : m_key_etamods) {
         total_hits += etamod.second;
     }
     ATH_MSG_INFO("Found " << total_hits << " hits in the key layer, applying global trim factor of " << m_globalTrim << "%");
  
     // Then, do the trim.
     for (auto const &etamod : m_key_etamods) {
         if (m_globalTrim == 0 || ((etamod.second / total_hits) >= m_globalTrim*0.01)) {
             key_etamods.insert(etamod.first);
         } else {
             ATH_MSG_INFO("Eta module " << etamod.first << " only contains " << etamod.second << " out of " << total_hits << " hits, excluding from slices.");
         }
     }
  
     if (m_nSlices.value() == -1) m_nSlices.value() = key_etamods.size(); //default is full granularity slicing
     float etasPerSlice = float(key_etamods.size())/m_nSlices.value();
     std::vector<std::vector<int>> key_modules_for_slices; // indexed by slice, holds module eta values
  
    // easier to use vector than set, convert m_key_etamods into key_etas
     std::vector<int> key_etas;
     std::vector<int> key_etas2; // used if 2D slicing
     key_etas.insert(key_etas.end(), key_etamods.begin(), key_etamods.end());
  
     for (unsigned i = 0; i < key_etas.size(); i++)
     {
         if (i >= (key_modules_for_slices.size() * etasPerSlice)) key_modules_for_slices.push_back(std::vector<int>());
         key_modules_for_slices.back().push_back(key_etas[i]);
     }
  
     std::map<int, int> keymod2slice;
     for (unsigned s = 0; s < key_modules_for_slices.size(); s++)
         for (unsigned e = 0; e < key_modules_for_slices[s].size(); e++)
             keymod2slice[key_modules_for_slices[s][e]] = s;
  
     std::string key = m_keystring.value();
     key.erase(std::remove(key.begin(), key.end(), ','), key.end());
     key.erase(std::remove(key.begin(), key.end(), ' '), key.end());
     std::string key2 = m_keystring2.value();
     key2.erase(std::remove(key2.begin(), key2.end(), ','), key2.end());
     key2.erase(std::remove(key2.begin(), key2.end(), ' '), key2.end());
  
     ATH_MSG_INFO("Doing z-slicing");
     if (key_etamods.size() == 0) ATH_MSG_ERROR("Found 0 slices using the keystring: '" << m_keystring << "'");
     ATH_MSG_INFO("Nslices = " << std::to_string(m_nSlices.value()) << ":");
  
     std::stringstream eta_slices;
     for (unsigned s = 0; s < key_modules_for_slices.size(); s++){
         for (unsigned e = 0; e < key_modules_for_slices[s].size(); e++){
             eta_slices << key_modules_for_slices[s][e] << " ";
         }
         eta_slices << ", ";
     }
     ATH_MSG_INFO(eta_slices.str());
  
     // 2D key layer slicing
     if (m_key2)
     { // make new slices from combinations of keylayer1 slices and keylayer2 slices
  
         /*------------- setup keylayer2 keymodule to slice map  -------------- */
         std::vector<std::vector<int>> key_modules_for_slices2;
         float etasPerSlice2 = float(m_key_etamods2.size())/m_nSlices.value();
         key_etas2.insert(key_etas2.end(), m_key_etamods2.begin(), m_key_etamods2.end());
         for (unsigned i = 0; i < key_etas2.size(); i++)
         {
         if (i >= (key_modules_for_slices2.size() * etasPerSlice2)) key_modules_for_slices2.push_back(std::vector<int>());
         key_modules_for_slices2.back().push_back(key_etas2[i]);
         }
  
         std::map<int, int> keymod2slice2;
         for (unsigned s = 0; s < key_modules_for_slices2.size(); s++)
             for (unsigned e = 0; e < key_modules_for_slices2[s].size(); e++)
                 keymod2slice2[key_modules_for_slices2[s][e]] = s;
         /*----------------------------------------------------------------- */
  
         int new_nSlice = m_nSlices.value();
         for (int s1 = 0; s1 < m_nSlices.value(); s1++){ // loop over keylayer1's slices
       for (int s2 = 0; s2 < m_nSlices.value(); s2++){ // loop over keylayer2's slices
  
                 for (auto& pair: m_track2modules) // track loop
                 {
                     if (m_usedTracks.find(pair.first) != m_usedTracks.end()) continue; // skip if already assigned a slice to this track
                     bool key1 = false;
                     bool key2 = false;
                     for (auto& m: pair.second) // module loop
                     {
                         if (isOnKeyLayer(1,m->det,m->bec,m->lyr))
                             if (keymod2slice[m->eta] == s1) key1 = true;
  
                         if (isOnKeyLayer(2,m->det,m->bec,m->lyr))
                             if (keymod2slice2[m->eta] == s2) key2 = true;
                     }
  
                     if (key1 && key2)
                     {
               int newSlice = m_nSlices.value()*s1 + s2;
                         m_track2slice[pair.first] = newSlice;
                         m_usedTracks.insert(pair.first);
                         if (newSlice + 1 > new_nSlice) new_nSlice = newSlice + 1; // find max slice, to set new total number of slices
                     }
                 }
             }
         }
         m_nSlices.value() = new_nSlice;
         ATH_MSG_INFO("These slices were further divided based on the key layer 2: '" << key2 << "'. Now nSlices = " << m_nSlices.value());
         ATH_MSG_INFO("Using " << m_usedTracks.size() << " tracks out of " << m_maxEvents << ". The rest were missing a hit in one or both of the key layers");
     }
  
  
     // 1D key layer slicing
     else
     {
         for (const FPGATrackSimHit& hit: allHits) // Fill the track to slice map
         {
             if (m_usedTracks.find(hit.getEventIndex()) != m_usedTracks.end()) continue; // skip if already done a hit from this track
             if (isOnKeyLayer(1,hit.getDetType(),hit.getDetectorZone(), hit.getPhysLayer()))
             { // if hit is in key layer, add it's barcode to the map
                 if (keymod2slice.count(hit.getEtaModule()) > 0) {
                     int s = keymod2slice[hit.getEtaModule()];
                     m_track2slice[hit.getEventIndex()] = s;
                     m_usedTracks.insert(hit.getEventIndex());
                 }
             }
         }
         ATH_MSG_INFO("Using " << m_usedTracks.size() << " tracks out of " << m_maxEvents << ". The rest missed the key layer");
     }
  
     std::stringstream trim;
     std::stringstream gtrim;
     trim << std::fixed << std::setprecision(3) << m_trim;
     gtrim << std::fixed << std::setprecision(3) << m_globalTrim;
     std::string str_trim = trim.str();
     std::string str_gtrim = gtrim.str();
     int dot = str_trim.find_last_of(".");
     str_trim.replace(dot,1,"p");
     str_gtrim.replace(str_gtrim.find_last_of("."), 1, "p");
  
     std::string subrmap_path = m_outFileName.value() + "region" + std::to_string(m_region) + "_" + key + "_" + key2 + "_trim" + str_trim + "_gtrim" + str_gtrim + "_NSlices-" + std::to_string(m_nSlices.value()) + ".rmap";
  
     ATH_MSG_INFO("Creating subrmap: " << subrmap_path);
     m_subrmap.open(subrmap_path, std::ofstream::out);
     m_subrmap << "towers " << m_nSlices.value() << " phi 16\n\n";
  
     // Resize numTracks vector to be equal to the number of slices
     // Now that this just stores module pointers we could loop over m_modules instead.
     for (auto& pair: m_track2modules) {
         for (Module* m: pair.second) {
       if (m->numTracks.empty()) {
         m->numTracks.resize(m_nSlices.value(), 0);
       }
         }
     }
  
  
     // Count tracks per slice
     ATH_MSG_INFO("Counting number of tracks per slice.");
     std::vector<std::vector<int>> slicedTracks (m_nSlices.value()); // vector of tracks, indexed by slice
     for (auto trk: m_usedTracks) {
         int s = m_track2slice[trk];
         slicedTracks[s].push_back(trk);
         std::vector<Module*> mods = m_track2modules[trk];
         for (Module* mod: mods) {
             mod->numTracks[s]++;
         }
     }
  
     if (m_drawSlices)
       drawSlices(allHits);
  
     // Now do trimming and Fill slice2module map
     int trimmed = 0;
     for (int s = 0; s < m_nSlices.value(); s++) {
         ATH_MSG_INFO("Applying local trimming in slice " << s);
         for (auto trk : slicedTracks[s]) {
             auto it = std::remove_if (m_track2modules[trk].begin(),
                                       m_track2modules[trk].end(),
                                       [&] (const Module* m) {
                                         return 100 * ( float(m->numTracks[s]) / float(slicedTracks[s].size()) ) < m_trim;
                                       });
             trimmed += m_track2modules[trk].end() - it;
             m_track2modules[trk].erase (it, m_track2modules[trk].end());
  
             ATH_MSG_DEBUG("About to query trk2slice");
             int s = m_track2slice[trk];
             ATH_MSG_DEBUG("Queried trk2slice.");
             // add all modules from track to slices
             if (m_track2modules[trk].size() > 0) {
                 ATH_MSG_DEBUG("About to insert trk2modules");
                 m_slice2modules[s].insert( m_slice2modules[s].end(), m_track2modules[trk].begin(), m_track2modules[trk].end() );
                 ATH_MSG_DEBUG("Inserted trk2modules.");
             }
         }
     }
     ATH_MSG_INFO("Trimmed off " << trimmed << " modules that were hit by less than " << m_trim << "% of tracks");
  
     /*   ----------  Print z-slice map ---------- */
  
     for (int s = 0; s < m_nSlices.value(); s++)
     {
         m_subrmap << s << "\n";
         m_subrmap << makeSubrmapLines(m_slice2modules[s], SiliconTech::pixel, DetectorZone::barrel, m_pbmax);
         m_subrmap << makeSubrmapLines(m_slice2modules[s], SiliconTech::pixel, DetectorZone::posEndcap, m_pemax[0]);
         m_subrmap << makeSubrmapLines(m_slice2modules[s], SiliconTech::pixel, DetectorZone::negEndcap, m_pemax[1]);
  
         m_subrmap << makeSubrmapLines(m_slice2modules[s], SiliconTech::strip, DetectorZone::barrel, m_sbmax);
         m_subrmap << makeSubrmapLines(m_slice2modules[s], SiliconTech::strip, DetectorZone::posEndcap, m_semax[0]);
         m_subrmap << makeSubrmapLines(m_slice2modules[s], SiliconTech::strip, DetectorZone::negEndcap, m_semax[1]);
         m_subrmap << "\n\n";
     }
  
     m_subrmap.close();
     return StatusCode::SUCCESS;
 }

Member Data Documentation

◆ m_allHits

std::vector<FPGATrackSimHit> FPGATrackSimMapMakerAlg::m_allHits

private

Definition at line 101 of file FPGATrackSimMapMakerAlg.h.

◆ m_bec2zone

std::map<std::string, DetectorZone> FPGATrackSimMapMakerAlg::m_bec2zone = { {"barrel",DetectorZone::barrel}, {"posEndcap",DetectorZone::posEndcap}, {"negEndcap",DetectorZone::negEndcap} }

private

Definition at line 278 of file FPGATrackSimMapMakerAlg.h.

◆ m_description

Gaudi::Property<std::string> FPGATrackSimMapMakerAlg::m_description {this, "description", "", "tag description"}

private

Definition at line 86 of file FPGATrackSimMapMakerAlg.h.

◆ m_det2tech

std::map<std::string, SiliconTech> FPGATrackSimMapMakerAlg::m_det2tech = { {"pixel",SiliconTech::pixel}, {"strip",SiliconTech::strip} }

private

Definition at line 277 of file FPGATrackSimMapMakerAlg.h.

◆ m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Algorithm > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

◆ m_diskIndex

const std::vector<uint32_t> FPGATrackSimMapMakerAlg::m_diskIndex = {0,17,47,58,66}

private

Definition at line 266 of file FPGATrackSimMapMakerAlg.h.

◆ m_doSpacePoints

Gaudi::Property<bool> FPGATrackSimMapMakerAlg::m_doSpacePoints {this, "doSpacePoints", false, "Use 9L instead of 8L configuration for first stage (for example)"}

private

Definition at line 84 of file FPGATrackSimMapMakerAlg.h.

◆ m_drawSlices

Gaudi::Property<bool> FPGATrackSimMapMakerAlg::m_drawSlices {this, "drawSlices", false, "Draw the huge 2D slice histograms"}

private

Definition at line 89 of file FPGATrackSimMapMakerAlg.h.

◆ m_etapat

std::ofstream FPGATrackSimMapMakerAlg::m_etapat

private

Definition at line 261 of file FPGATrackSimMapMakerAlg.h.

◆ m_eventHeader

FPGATrackSimEventInputHeader FPGATrackSimMapMakerAlg::m_eventHeader

private

Definition at line 47 of file FPGATrackSimMapMakerAlg.h.

◆ m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Algorithm > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

◆ m_extendedExtraObjects

DataObjIDColl AthAlgorithm::m_extendedExtraObjects

privateinherited

Definition at line 79 of file AthAlgorithm.h.

◆ m_geoTag

Gaudi::Property<std::string> FPGATrackSimMapMakerAlg::m_geoTag {this, "GeometryVersion", "ATLAS-P2-ITK-22-02-00", "Geometry tag that this set of maps is for. TODO can we store/read from wrappers?"}

private

Definition at line 87 of file FPGATrackSimMapMakerAlg.h.

◆ m_globalTrim

Gaudi::Property<float> FPGATrackSimMapMakerAlg::m_globalTrim {this, "globalTrim", 0.1, "Trimming applied globally to the key layer before determining slice boundaries"}

private

Definition at line 85 of file FPGATrackSimMapMakerAlg.h.

◆ m_hitInputTool

ToolHandle<IFPGATrackSimEventInputHeaderTool> FPGATrackSimMapMakerAlg::m_hitInputTool { this, "InputTool", "FPGATrackSimSGToRawHitsTool/FPGATrackSimInputTool", "HitInput Tool" }

private

Definition at line 45 of file FPGATrackSimMapMakerAlg.h.

◆ m_insideout

Gaudi::Property<bool> FPGATrackSimMapMakerAlg::m_insideout {this, "doInsideOut", false, "5 layers pixel-only configuration"}

private

Definition at line 90 of file FPGATrackSimMapMakerAlg.h.

◆ m_key2

bool FPGATrackSimMapMakerAlg::m_key2 = false

private

Definition at line 254 of file FPGATrackSimMapMakerAlg.h.

◆ m_key_etamods

std::map<int, int> FPGATrackSimMapMakerAlg::m_key_etamods

private

Definition at line 255 of file FPGATrackSimMapMakerAlg.h.

◆ m_key_etamods2

std::set<int> FPGATrackSimMapMakerAlg::m_key_etamods2

private

Definition at line 256 of file FPGATrackSimMapMakerAlg.h.

◆ m_keylayer

std::map<std::string, std::set<int> > FPGATrackSimMapMakerAlg::m_keylayer

private

Definition at line 251 of file FPGATrackSimMapMakerAlg.h.

◆ m_keylayer2

std::map<std::string, std::set<int> > FPGATrackSimMapMakerAlg::m_keylayer2

private

Definition at line 252 of file FPGATrackSimMapMakerAlg.h.

◆ m_keystring

Gaudi::Property<std::string> FPGATrackSimMapMakerAlg::m_keystring {this, "KeyString", "strip,barrel,2", "key layer to use for subrmap"}

private

Definition at line 81 of file FPGATrackSimMapMakerAlg.h.

◆ m_keystring2

Gaudi::Property<std::string> FPGATrackSimMapMakerAlg::m_keystring2 {this, "KeyString2", "", "second key layer for 2D slicing"}

private

Definition at line 82 of file FPGATrackSimMapMakerAlg.h.

◆ m_maxEvents

Gaudi::Property<int> FPGATrackSimMapMakerAlg::m_maxEvents {this, "maxEvents", 10000, "Max Events"}

private

Definition at line 77 of file FPGATrackSimMapMakerAlg.h.

◆ m_moduleRelabel

FPGATrackSimModuleRelabel* FPGATrackSimMapMakerAlg::m_moduleRelabel = nullptr

private

Definition at line 93 of file FPGATrackSimMapMakerAlg.h.

◆ m_modules

std::map<FPGATrackSimModuleId, Module> FPGATrackSimMapMakerAlg::m_modules

private

Definition at line 96 of file FPGATrackSimMapMakerAlg.h.

◆ m_monitorFile

std::unique_ptr<TFile> FPGATrackSimMapMakerAlg::m_monitorFile {}

private

Definition at line 262 of file FPGATrackSimMapMakerAlg.h.

◆ m_nSlices

Gaudi::Property<int> FPGATrackSimMapMakerAlg::m_nSlices {this, "nSlices", -1, "default is full granularity/maximum number of slices possible"}

private

Definition at line 83 of file FPGATrackSimMapMakerAlg.h.

◆ m_outFileName

Gaudi::Property<std::string> FPGATrackSimMapMakerAlg::m_outFileName {this, "OutFileName", "", "naming convention for maps"}

private

Definition at line 80 of file FPGATrackSimMapMakerAlg.h.

◆ m_pbHits

std::vector<FPGATrackSimHit> FPGATrackSimMapMakerAlg::m_pbHits

private

Definition at line 101 of file FPGATrackSimMapMakerAlg.h.

◆ m_pbmax

int FPGATrackSimMapMakerAlg::m_pbmax = -1

private

Definition at line 103 of file FPGATrackSimMapMakerAlg.h.

◆ m_peHits

std::vector<FPGATrackSimHit> FPGATrackSimMapMakerAlg::m_peHits

private

Definition at line 101 of file FPGATrackSimMapMakerAlg.h.

◆ m_pemax

std::vector<int> FPGATrackSimMapMakerAlg::m_pemax = {-1,-1}

private

Definition at line 105 of file FPGATrackSimMapMakerAlg.h.

◆ m_planes

const std::vector<std::vector<std::vector<std::string> > >* FPGATrackSimMapMakerAlg::m_planes {}

private

Definition at line 115 of file FPGATrackSimMapMakerAlg.h.

◆ m_planes2

const std::vector<std::vector <std::vector <std::string> > > FPGATrackSimMapMakerAlg::m_planes2

private

Initial value:

= 
        {
            { 
                {"pb4"},{"sb0"},{"sb1"},{"sb2"},{"sb3"},{"sb4"},{"sb5"},{"sb6"},{"sb7"},{"pb0"},{"pb1"},{"pb2"},{"pb3"}
            },
            { 
                {"pb4"},{"sb0"},{"sb1"},{"sb2"},{"sb3"},{"sb4"},{"sb5"},{"sb6"},{"sb7"},{"pb0"},{"pb1"},{"pb2"},{"pb3"}
            },
            { 
                {"-1"},{"-1"},{"-1"},{"-1"},{"-1"},{"-1"},{"-1"},{"-1"},{"-1"},{"-1"},{"-1"},{"-1"},{"-1"}
            },
            { 
                {"pb4","pe83+","pe84+","pe85+","pe86+","pe87+","pe88+","pe89+"},{"se4+"},{"se5+"},{"se6+"},{"se7+"},{"se8+"},{"se9+"},{"se10+"},{"se11+"},{"pb2"},{"pb3","pe58+"},{"se2+"},{"se3+"},
            },
            { 
                {"pe0+"},{"pe1+"},{"pe2+"},{"pe3+"},{"pe4+"},{"pe5+"},{"pe6+"},{"pe7+"},{"pe8+"},{"pe9+"},{"pe10+"},{"pe11+"},{"pe12+"} 
            },
            { 
                {"pb4"},{"sb0"},{"sb1"},{"sb2"},{"sb3"},{"sb4"},{"sb5"},{"sb6"},{"sb7"},{"pb0"},{"pb1"},{"pb2"},{"pb3"}
            },
            { 
                {"pb4"},{"sb0"},{"sb1"},{"sb2"},{"sb3"},{"sb4"},{"sb5"},{"sb6"},{"sb7"},{"pb0"},{"pb1"},{"pb2"},{"pb3"}
            },
            { 
                {"pb4"},{"sb0"},{"sb1"},{"sb2"},{"sb3"},{"sb4"},{"sb5"},{"sb6"},{"sb7"},{"pb0"},{"pb1"},{"pb2"},{"pb3"}
            },
        }

Definition at line 186 of file FPGATrackSimMapMakerAlg.h.

◆ m_planes_default

const std::vector< std::vector< std::vector<std::string> > > FPGATrackSimMapMakerAlg::m_planes_default

private

Initial value:

= 
        {
            { 
                {"pb4"},{"sb0"},{"sb2"},{"sb3"},{"sb4"},{"sb5"},{"sb6"},{"sb7"} 
                
            },
            { 
                {"pb4"},{"sb0"},{"sb2"},{"sb3"},{"sb4"},{"sb5"},{"sb6"},{"sb7"}
            },
            { 
                {"-1"},{"-1"},{"-1"},{"-1"},{"-1"},{"-1"},{"-1"},{"-1"}
            },
            { 
                {"pb4","pe83+","pe84+","pe85+","pe86+","pe87+","pe88+","pe89+"},{"se5+"},{"se6+"},{"se7+"},{"se8+"},{"se9+"},{"se10+"},{"se11+"}
            },
            { 
                {"pe34+","pe12+"},{"pe36+","pe29+"},{"pe8+","pe40+","pe30+"},{"pe56+","pe65+"},{"pe10+","pe6+"},{"pe11+","pe7+"},{"pe31+","pe32+"},{"pe9+","pe53+"}
            },
            { 
                {"pb4"},{"sb0"},{"sb2"},{"sb3"},{"sb4"},{"sb5"},{"sb6"},{"sb7"}
            },
            { 
                {"pb4"},{"sb0"},{"sb2"},{"sb3"},{"sb4"},{"sb5"},{"sb6"},{"sb7"}
            },
            { 
                {"pb4"},{"sb0"},{"sb2"},{"sb3"},{"sb4"},{"sb5"},{"sb6"},{"sb7"}
            },
        }

Definition at line 116 of file FPGATrackSimMapMakerAlg.h.

◆ m_planes_insideout

const std::vector<std::vector <std::vector <std::string> > > FPGATrackSimMapMakerAlg::m_planes_insideout

private

Definition at line 214 of file FPGATrackSimMapMakerAlg.h.

◆ m_planes_sp

const std::vector< std::vector< std::vector<std::string> > > FPGATrackSimMapMakerAlg::m_planes_sp

private

Definition at line 148 of file FPGATrackSimMapMakerAlg.h.

◆ m_pmap

std::ofstream FPGATrackSimMapMakerAlg::m_pmap

private

Definition at line 261 of file FPGATrackSimMapMakerAlg.h.

◆ m_radfile

std::ofstream FPGATrackSimMapMakerAlg::m_radfile

private

Definition at line 261 of file FPGATrackSimMapMakerAlg.h.

◆ m_radii

std::vector<std::vector < std::vector<float> > > FPGATrackSimMapMakerAlg::m_radii

private

Definition at line 258 of file FPGATrackSimMapMakerAlg.h.

◆ m_region

Gaudi::Property<int> FPGATrackSimMapMakerAlg::m_region {this, "region", 0, "Region"}

private

Definition at line 78 of file FPGATrackSimMapMakerAlg.h.

◆ m_remapModules

Gaudi::Property<bool> FPGATrackSimMapMakerAlg::m_remapModules {this, "remapModules", false, "Allow maps to be drawn that slice modules more finely, by remapping module indices"}

private

Definition at line 88 of file FPGATrackSimMapMakerAlg.h.

◆ m_rmap

std::ofstream FPGATrackSimMapMakerAlg::m_rmap

private

Definition at line 261 of file FPGATrackSimMapMakerAlg.h.

◆ m_sbHits

std::vector<FPGATrackSimHit> FPGATrackSimMapMakerAlg::m_sbHits

private

Definition at line 101 of file FPGATrackSimMapMakerAlg.h.

◆ m_sbmax

int FPGATrackSimMapMakerAlg::m_sbmax = -1

private

Definition at line 104 of file FPGATrackSimMapMakerAlg.h.

◆ m_seHits

std::vector<FPGATrackSimHit> FPGATrackSimMapMakerAlg::m_seHits

private

Definition at line 101 of file FPGATrackSimMapMakerAlg.h.

◆ m_semax

std::vector<int> FPGATrackSimMapMakerAlg::m_semax = {-1,-1}

private

Definition at line 106 of file FPGATrackSimMapMakerAlg.h.

◆ m_slice2modules

std::map<int, std::vector<Module*> > FPGATrackSimMapMakerAlg::m_slice2modules

private

Definition at line 97 of file FPGATrackSimMapMakerAlg.h.

◆ m_subrmap

std::ofstream FPGATrackSimMapMakerAlg::m_subrmap

private

Definition at line 261 of file FPGATrackSimMapMakerAlg.h.

◆ m_track2modules

std::map<int, std::vector<Module*> > FPGATrackSimMapMakerAlg::m_track2modules

private

Definition at line 97 of file FPGATrackSimMapMakerAlg.h.

◆ m_track2slice

std::map<int, int> FPGATrackSimMapMakerAlg::m_track2slice

private

Definition at line 98 of file FPGATrackSimMapMakerAlg.h.

◆ m_trim

Gaudi::Property<float> FPGATrackSimMapMakerAlg::m_trim {this, "trim", 0.1, "trim modules with less than given percent of tracks"}

private

Definition at line 79 of file FPGATrackSimMapMakerAlg.h.

◆ m_usedTracks

std::set<int> FPGATrackSimMapMakerAlg::m_usedTracks

private

Definition at line 257 of file FPGATrackSimMapMakerAlg.h.

◆ m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< Algorithm > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< Algorithm > >::m_vhka

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

◆ m_z

std::vector<std::vector < std::vector<float> > > FPGATrackSimMapMakerAlg::m_z

private

Definition at line 259 of file FPGATrackSimMapMakerAlg.h.

◆ m_zedfile

std::ofstream FPGATrackSimMapMakerAlg::m_zedfile

private

Definition at line 261 of file FPGATrackSimMapMakerAlg.h.

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

Classes

Public Types

Public Member Functions

Protected Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ FPGATrackSimModuleId

◆ StoreGateSvc_t

Constructor & Destructor Documentation

◆ FPGATrackSimMapMakerAlg()

◆ ~FPGATrackSimMapMakerAlg()

Member Function Documentation

◆ declareGaudiProperty() [1/4]

◆ declareGaudiProperty() [2/4]

◆ declareGaudiProperty() [3/4]

◆ declareGaudiProperty() [4/4]

◆ declareProperty() [1/6]

◆ declareProperty() [2/6]

◆ declareProperty() [3/6]

◆ declareProperty() [4/6]

◆ declareProperty() [5/6]

◆ declareProperty() [6/6]

◆ detStore()

◆ drawSlices()

◆ evtStore() [1/2]

◆ evtStore() [2/2]

◆ execute()

◆ extraDeps_update_handler()

◆ extraOutputDeps()

◆ finalize()

◆ findPlane()

◆ initialize()

◆ inputHandles()

◆ isOnKeyLayer()

◆ makeRmapLines()

◆ makeSubrmapLines()

◆ msg() [1/2]

◆ msg() [2/2]

◆ msgLvl()

◆ outputHandles()

◆ parseKeyString()

◆ readInputs()

◆ renounce()

◆ renounceArray()

◆ sysInitialize()

◆ sysStart()

◆ updateVHKA()

◆ writeEtaPatterns()

◆ writeMedianZFile()

◆ writePmapAndRmap()

◆ writeRadiiFile()

◆ writeSubrmap()

Member Data Documentation

◆ m_allHits

◆ m_bec2zone

◆ m_description

◆ m_det2tech

◆ m_detStore

◆ m_diskIndex

◆ m_doSpacePoints

◆ m_drawSlices

◆ m_etapat

◆ m_eventHeader

◆ m_evtStore

◆ m_extendedExtraObjects

◆ m_geoTag

◆ m_globalTrim

◆ m_hitInputTool

◆ m_insideout

◆ m_key2

◆ m_key_etamods

◆ m_key_etamods2

◆ m_keylayer

◆ m_keylayer2

◆ m_keystring

◆ m_keystring2

◆ m_maxEvents