HGTD_GmxInterface Class Reference

#include <HGTD_GmxInterface.h>

Inheritance diagram for HGTD_GmxInterface:

Collaboration diagram for HGTD_GmxInterface:

Public Member Functions
	HGTD_GmxInterface (HGTD_DetectorManager *detectorManager, InDetDD::SiCommonItems *commonItems)
virtual int	sensorId (std::map< std::string, int > &index) const override final
virtual void	addSensorType (const std::string &clas, const std::string &typeName, const std::map< std::string, std::string > &parameters) override final
void	addSensor (const std::string &typeName, std::map< std::string, int > &index, int sequentialId, GeoVFullPhysVol *fpv) override final
void	buildReadoutGeometryFromSqlite (IRDBAccessSvc *rdbAccessSvc, GeoModelIO::ReadGeoModel *sqlreader)
virtual void	addAlignable (int level, std::map< std::string, int > &index, GeoVFullPhysVol *fpv, GeoAlignableTransform *transform) override final
bool	msgLvl (const MSG::Level lvl) const
	Test the output level.
MsgStream &	msg () const
	The standard message stream.
MsgStream &	msg (const MSG::Level lvl) const
	The standard message stream.
void	setLevel (MSG::Level lvl)
	Change the current logging level.

Private Member Functions
void	makeLgadModule (const std::string &typeName, const std::map< std::string, std::string > &parameters)
void	initMessaging () const
	Initialize our message level and MessageSvc.

Private Attributes
std::map< std::string, const InDetDD::HGTD_ModuleDesign * >	m_geometryMap
HGTD_DetectorManager *	m_detectorManager {}
InDetDD::SiCommonItems *	m_commonItems {}
std::string	m_nm
	Message source name.
boost::thread_specific_ptr< MsgStream >	m_msg_tls
	MsgStream instance (a std::cout like with print-out levels).
std::atomic< IMessageSvc * >	m_imsg { nullptr }
	MessageSvc pointer.
std::atomic< MSG::Level >	m_lvl { MSG::NIL }
	Current logging level.
std::atomic_flag m_initialized	ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT
	Messaging initialized (initMessaging).

Detailed Description

Definition at line 27 of file HGTD_GmxInterface.h.

Constructor & Destructor Documentation

HGTD_GmxInterface()

HGTD_GmxInterface::HGTD_GmxInterface	(	HGTD_DetectorManager *	detectorManager,
		InDetDD::SiCommonItems *	commonItems )

Definition at line 25 of file HGTD_GmxInterface.cxx.

    : AthMessaging("HGTD_GmxInterface"),
      m_detectorManager(detectorManager),
      m_commonItems(commonItems)
{
}

Member Function Documentation

addAlignable()

void HGTD_GmxInterface::addAlignable ( int level, std::map< std::string, int > & index, GeoVFullPhysVol * fpv, GeoAlignableTransform * transform )

finaloverridevirtual

Definition at line 264 of file HGTD_GmxInterface.cxx.

{
    ATH_MSG_DEBUG("HGTD addAlignable called");
 
    const HGTD_ID* hgtdIdHelper =
        dynamic_cast<const HGTD_ID*>(m_commonItems->getIdHelper());
 
    if (!hgtdIdHelper) {
        ATH_MSG_ERROR("Failed to get HGTD_ID");
        return;
    }
 
    Identifier id;
 
    //HGTD has only one meaningful level for now (module level)
    if (level == 1) {
        bool newScheme = hgtdIdHelper->get_useNewIdentifierScheme();
 
        if (newScheme) {
 
            id = hgtdIdHelper->wafer_id(
                index["endcap"],
                index["layer"],
                index["moduleInLayer"],
                0
            );
 
        } else {
            id = hgtdIdHelper->wafer_id(
                index["endcap"],
                index["layer"],
                index["rowNumber"],
                index["moduleNumberInRow"]
            );
        }
    }
    else {
        ATH_MSG_WARNING("Unsupported alignment level " << level);
        return;
    }
 
    IdentifierHash hash = hgtdIdHelper->wafer_hash(id);
 
    if (!hash.is_valid()) {
        ATH_MSG_ERROR("Invalid ID in addAlignable");
        return;
    }
 
    ATH_MSG_DEBUG("HGTD ALIGNABLE (GMX): "
        << " endcap=" << index["endcap"]
        << " layer=" << index["layer"]
        << " moduleInLayer=" << index["moduleInLayer"]
        << " idHash=" << hash);
 
    ATH_MSG_DEBUG("REGISTER ALIGNABLE:"
                << " hash=" << hash
                << " transform ptr=" << transform
                << " fpv ptr=" << fpv);
    
    ATH_MSG_DEBUG("ADD ALIGNABLE FPV = " << fpv);
 
    m_detectorManager->addAlignableTransform(level, id, transform, fpv);
}

addSensor()

void HGTD_GmxInterface::addSensor ( const std::string & typeName, std::map< std::string, int > & index, int sequentialId, GeoVFullPhysVol * fpv )

finaloverride

Definition at line 138 of file HGTD_GmxInterface.cxx.

{
    //
    // Get the ATLAS "Offline" wafer identifier
    //
    const HGTD_ID* hgtdIdHelper = static_cast<const HGTD_ID *> (m_commonItems->getIdHelper());
 
    Identifier id;
 
    bool useNewIdentifierScheme = hgtdIdHelper->get_useNewIdentifierScheme(); // to find which identification scheme is configured
    if(useNewIdentifierScheme){
        id = hgtdIdHelper->wafer_id(index["endcap"],
                                    index["layer"],
                                    index["moduleInLayer"],
                                    0);
 
        ATH_MSG_DEBUG("SENSOR CHECK: moduleInLayer = " << index["moduleInLayer"]);
        
        ATH_MSG_DEBUG("HGTD New ID scheme");
    } else {
        id = hgtdIdHelper->wafer_id(index["endcap"],
                                    index["layer"],
                                    index["rowNumber"],
                                    index["moduleNumberInRow"]);
        ATH_MSG_DEBUG("HGTD Old ID scheme");
    }               
    IdentifierHash hashId = hgtdIdHelper->wafer_hash(id);
 
    //
    // Now do our best to check if this is a valid id. If either the gmx file is wrong, or the xml file
    // defining the allowed id's is wrong, you can get disallowed id's. These cause a crash later
    // if allowed through. To do the check, we ask for the hash-id of this id. Invalid ids give a
    // special invalid hash-id (0xFFFFFFFF). But we don't exit the run, to help debug things quicker.
    // //
    if (hashId.is_valid()) {
        ATH_MSG_DEBUG("valid id");
        for (const auto& [key, value] : index) {
            ATH_MSG_DEBUG(key << " = " << value << "; ");
        }
    } else {
        ATH_MSG_ERROR("Invalid id for sensitive module " << typeName << " volume with indices");
        for (const auto& [key, value] : index) {
            ATH_MSG_ERROR(key << " = " << value << "; ");
        }
        ATH_MSG_ERROR("Refusing to make it into a sensitive element. Incompatible gmx and identifier-xml files.");
        return;
    }
 
    //
    // Create the detector element and add to the DetectorManager
    //
    const InDetDD::HGTD_ModuleDesign* design = m_geometryMap[typeName];
    if (design == nullptr) {
        ATH_MSG_ERROR("addSensor: Error: Readout sensor type " << typeName << " not found.");
        throw std::runtime_error("readout sensor type " + typeName + " not found.");
    }
    m_detectorManager->addDetectorElement(new InDetDD::HGTD_DetectorElement(id, design, fpv, m_commonItems));
 
    return;
}

addSensorType()

void HGTD_GmxInterface::addSensorType ( const std::string & clas, const std::string & typeName, const std::map< std::string, std::string > & parameters )

finaloverridevirtual

Definition at line 80 of file HGTD_GmxInterface.cxx.

{
    ATH_MSG_DEBUG("addSensorType called for class " << clas << ", typeName " << typeName);
 
    if (clas == "LGAD_module") {
        // TODO: implement method to actually add the sensor type (also to the detector manager)
        makeLgadModule(typeName, parameters);
    } else {
        ATH_MSG_ERROR("addSensorType: unrecognised sensor class: " << clas);
        ATH_MSG_ERROR("No sensor design created");
    }
}

buildReadoutGeometryFromSqlite()

void HGTD_GmxInterface::buildReadoutGeometryFromSqlite	(	IRDBAccessSvc *	rdbAccessSvc,
		GeoModelIO::ReadGeoModel *	sqlreader )

Definition at line 202 of file HGTD_GmxInterface.cxx.

{
    IRDBRecordset_ptr LGAD_module = rdbAccessSvc->getRecordsetPtr("LGAD_module","");
    const std::array<std::string,7> LGAD_moduleParamNames({"thickness","xPitch","yPitch","circuitsPerColumn","circuitsPerRow","padColumns","padRows"});
 
    if(LGAD_module->size() !=0){
       for (const IRDBRecord_ptr& typeParams:*LGAD_module){
            std::map<std::string,std::string> LGAD_moduleMap;
            for(const std::string& paramName:LGAD_moduleParamNames){
                LGAD_moduleMap[paramName] = typeParams->getString(paramName);
            }
            std::string LGAD_moduleName = typeParams->getString("SensorType");
            makeLgadModule(LGAD_moduleName,LGAD_moduleMap);
        }
    }
    else ATH_MSG_WARNING("Could not retrieve LGAD_module table");
 
    //Now, loop over the FullPhysVols and create the HGTD_DetectorElements (including splitting where needed)
    //lots of string parsing...
    std::vector<std::string> fields({"endcap","layer","moduleInLayer"});
    //The map below is a map of string keys which contains all the Identifier/DetElement relevant info, and the associated FullPhysVol
    
    std::map<std::string, GeoFullPhysVol*> mapFPV;
    
    //First, find which name the tables are in the file under (depends upon the plugin used to create the input file)
    //sort these in order of precedence - HGTDPlugin, then GeoModelXMLPlugin
    const std::array<std::string,2> publishers({"HGTD","GeoModelXML"});
 
    for (auto & iPub : publishers){
        //setting the "checkTable" option to true, so that an empty map will be returned if not found and we can try the next one
         mapFPV = sqlreader->getPublishedNodes<std::string, GeoFullPhysVol*>(iPub,true);
         if (!mapFPV.empty()) {
            ATH_MSG_DEBUG("Using FPV tables from publisher "<<iPub);
            break;
         }
    }
    if (mapFPV.empty()) ATH_MSG_ERROR("Could not find any FPV tables under the expected names: "<<publishers);
 
    for (const auto&[fullPhysVolInfoString, fullPhysVolPointer] : mapFPV){
        //find the name of the corresponding detector design type
        size_t startLGAD = fullPhysVolInfoString.find("lgad");
        if(startLGAD==std::string::npos){
            ATH_MSG_DEBUG("GeoFullPhysVol "<<fullPhysVolInfoString<<" does not have the expected format. Skipping");
            continue;
        }
        std::string typeName = fullPhysVolInfoString.substr(startLGAD);
        std::map<std::string, int> index;
        for (const std::string& field:fields){
            size_t first = fullPhysVolInfoString.find(field+"_");
            size_t last = fullPhysVolInfoString.find('_',first+field.size()+1);//start looking only after end of first delimiter (plus 1 for the "_" appended) ends
            if(first==std::string::npos || last==std::string::npos){
                ATH_MSG_DEBUG("Could not extract "<<field<<" from "<<fullPhysVolInfoString<<". Skipping");
                continue;
            }
            std::string strNew = fullPhysVolInfoString.substr(first+field.size()+1,last-(first+field.size()+1));
            index[field] = std::stoi(strNew);
        }
 
        addSensor(typeName,index,0,fullPhysVolPointer);
    }
}

initMessaging()

void AthMessaging::initMessaging ( ) const

privateinherited

Initialize our message level and MessageSvc.

This method should only be called once.

Definition at line 39 of file AthMessaging.cxx.

{
  m_imsg = Athena::getMessageSvc();
  // If user did not set an explicit level, set a default
  if (m_lvl == MSG::NIL) {
    m_lvl = m_imsg ?
      static_cast<MSG::Level>( m_imsg.load()->outputLevel(m_nm) ) :
      MSG::INFO;
  }
}

makeLgadModule()

void HGTD_GmxInterface::makeLgadModule ( const std::string & typeName, const std::map< std::string, std::string > & parameters )

private

Definition at line 96 of file HGTD_GmxInterface.cxx.

{
    double thickness{};
    double xPitch{};
    double yPitch{};
    int circuitsPerColumn{};
    int circuitsPerRow{};
    int padColumns{};
    int padRows{};
 
    // read parameters
    // TO DO : checking for unlogical values
    getParameter(typeName, parameters, "thickness", thickness);
    getParameter(typeName, parameters, "xPitch", xPitch);
    getParameter(typeName, parameters, "yPitch", yPitch);
    getParameter(typeName, parameters, "circuitsPerColumn", circuitsPerColumn);
    getParameter(typeName, parameters, "circuitsPerRow", circuitsPerRow);
    getParameter(typeName, parameters, "padColumns", padColumns);
    getParameter(typeName, parameters, "padRows", padRows);
 
    std::shared_ptr<const InDetDD::PixelDiodeMatrix> normalCell = InDetDD::PixelDiodeMatrix::construct(xPitch, yPitch);
    std::shared_ptr<const InDetDD::PixelDiodeMatrix> singleRow  = InDetDD::PixelDiodeMatrix::construct(InDetDD::PixelDiodeMatrix::phiDir, 0,
                                                                          std::move(normalCell), padColumns, 0);
    std::shared_ptr<const InDetDD::PixelDiodeMatrix> fullMatrix = InDetDD::PixelDiodeMatrix::construct(InDetDD::PixelDiodeMatrix::etaDir, 0,
                                                                          std::move(singleRow), padRows, 0);
 
 
    InDetDD::DetectorDesign::Axis yDirection = InDetDD::DetectorDesign::yAxis;
 
    InDetDD::HGTD_ModuleDesign* design = new InDetDD::HGTD_ModuleDesign(thickness,
                                                                        circuitsPerColumn, circuitsPerRow,
                                                                        padColumns, padRows/2,
                                                                        padColumns, padRows/2,
                                                                        std::move(fullMatrix),
                                                                        InDetDD::CarrierType::electrons, 1, yDirection );
 
 
   m_geometryMap[typeName] = design;
}

msg() [1/2]

MsgStream & AthMessaging::msg ( ) const

inlineinherited

The standard message stream.

Returns a reference to the default message stream May not be invoked before sysInitialize() has been invoked.

Definition at line 167 of file AthMessaging.h.

{
  MsgStream* ms = m_msg_tls.get();
  if (!ms) {
    if (!m_initialized.test_and_set()) initMessaging();
    ms = new MsgStream(m_imsg,m_nm);
    m_msg_tls.reset( ms );
  }
 
  ms->setLevel (m_lvl);
  return *ms;
}

msg() [2/2]

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

inlineinherited

The standard message stream.

Returns a reference to the default message stream May not be invoked before sysInitialize() has been invoked.

Definition at line 182 of file AthMessaging.h.

{ return msg() << lvl; }

msgLvl()

bool AthMessaging::msgLvl ( const MSG::Level lvl ) const

inlineinherited

Test the output level.

Parameters

lvl	The message level to test against

Returns

boolean Indicating if messages at given level will be printed

Return values

true	Messages at level "lvl" will be printed

Definition at line 151 of file AthMessaging.h.

{
  // If user did not set explicit message level we have to initialize
  // the messaging and retrieve the default via the MessageSvc.
  if (m_lvl==MSG::NIL && !m_initialized.test_and_set()) initMessaging();
 
  if (m_lvl <= lvl) {
    msg() << lvl;
    return true;
  } else {
    return false;
  }
}

sensorId()

int HGTD_GmxInterface::sensorId ( std::map< std::string, int > & index ) const

finaloverridevirtual

Definition at line 34 of file HGTD_GmxInterface.cxx.

{
    const HGTD_ID* hgtdIdHelper = dynamic_cast<const HGTD_ID *> (m_commonItems->getIdHelper());
    // Return the Simulation HitID (nothing to do with "ATLAS Identifiers" aka "Offline Identifiers"
    int hitIdOfWafer{-1};
    if (not hgtdIdHelper) {
      ATH_MSG_ERROR("HGTD_GmxInterface::sensorId: Dynamic cast of helper failed.");
      return hitIdOfWafer;
    }
    bool newIdenSche = hgtdIdHelper->get_useNewIdentifierScheme(); // to choise which identification scheme will be used
    if(newIdenSche){
        hitIdOfWafer = SiHitIdHelper::GetHelper()->buildHitId(HGTD_HitIndex,
                                                                  index["endcap"],
                                                                  index["layer"],
                                                                  0,
                                                                  index["moduleInLayer"],
                                                                  0); // side is just 0 for HGTD
 
    ATH_MSG_DEBUG("Index list: " << index["endcap"] << " " << index["layer"] << " "
                                 << index["moduleInLayer"] );
    ATH_MSG_DEBUG("hitIdOfWafer = " << std::hex << hitIdOfWafer << std::dec);
    ATH_MSG_DEBUG(" endcap = " << SiHitIdHelper::GetHelper()->getBarrelEndcap(hitIdOfWafer)
                  << " layer = " << SiHitIdHelper::GetHelper()->getLayerDisk(hitIdOfWafer)
                  << " moduleInLayer = " << SiHitIdHelper::GetHelper()->getPhiModule(hitIdOfWafer));
    } else {
        hitIdOfWafer = SiHitIdHelper::GetHelper()->buildHitId(HGTD_HitIndex,
                                                                  index["endcap"],
                                                                  index["layer"],
                                                                  index["moduleNumberInRow"],
                                                                  index["rowNumber"],
                                                                  0); // side is just 0 for HGTD
 
    ATH_MSG_DEBUG("Index list: " << index["endcap"] << " " << index["layer"] << " "
                                 << index["moduleNumberInRow"] << " " << index["rowNumber"]);
    ATH_MSG_DEBUG("hitIdOfWafer = " << std::hex << hitIdOfWafer << std::dec);
    ATH_MSG_DEBUG(" endcap = " << SiHitIdHelper::GetHelper()->getBarrelEndcap(hitIdOfWafer)
                  << " layer = " << SiHitIdHelper::GetHelper()->getLayerDisk(hitIdOfWafer)
                  << " moduleNumberInRow = " << SiHitIdHelper::GetHelper()->getEtaModule(hitIdOfWafer)
                  << " rowNumber = " << SiHitIdHelper::GetHelper()->getPhiModule(hitIdOfWafer));
 
    }
    return hitIdOfWafer;
 
}

setLevel()

void AthMessaging::setLevel ( MSG::Level lvl )

inherited

Change the current logging level.

Use this rather than msg().setLevel() for proper operation with MT.

Definition at line 28 of file AthMessaging.cxx.

{
  m_lvl = lvl;
}

Member Data Documentation

ATLAS_THREAD_SAFE

std::atomic_flag m_initialized AthMessaging::ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT

mutableprivateinherited

Messaging initialized (initMessaging).

Definition at line 141 of file AthMessaging.h.

m_commonItems

InDetDD::SiCommonItems* HGTD_GmxInterface::m_commonItems {}

private

Definition at line 55 of file HGTD_GmxInterface.h.

{};

m_detectorManager

HGTD_DetectorManager* HGTD_GmxInterface::m_detectorManager {}

private

Definition at line 54 of file HGTD_GmxInterface.h.

{};

m_geometryMap

std::map<std::string, const InDetDD::HGTD_ModuleDesign *> HGTD_GmxInterface::m_geometryMap

private

Definition at line 53 of file HGTD_GmxInterface.h.

m_imsg

std::atomic<IMessageSvc*> AthMessaging::m_imsg { nullptr }

mutableprivateinherited

MessageSvc pointer.

Definition at line 135 of file AthMessaging.h.

{ nullptr };

m_lvl

std::atomic<MSG::Level> AthMessaging::m_lvl { MSG::NIL }

mutableprivateinherited

Current logging level.

Definition at line 138 of file AthMessaging.h.

{ MSG::NIL };

m_msg_tls

boost::thread_specific_ptr<MsgStream> AthMessaging::m_msg_tls

mutableprivateinherited

MsgStream instance (a std::cout like with print-out levels).

Definition at line 132 of file AthMessaging.h.

m_nm

std::string AthMessaging::m_nm

privateinherited

Message source name.

Definition at line 129 of file AthMessaging.h.

---

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

• HGTD_GmxInterface.h
• HGTD_GmxInterface.cxx