HGTD_GmxInterface.cxx

Go to the documentation of this file.

/*
  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
*/
 
#include "HGTD_GmxInterface.h"
#include <HGTD_ReadoutGeometry/HGTD_DetectorManager.h>
#include <HGTD_Identifier/HGTD_ID.h>
#include <HGTD_ReadoutGeometry/HGTD_DetectorElement.h>
#include <HGTD_ReadoutGeometry/HGTD_ModuleDesign.h>
 
#include <InDetSimEvent/SiHitIdHelper.h>
#include <ReadoutGeometryBase/SiCommonItems.h>
 
#include <RDBAccessSvc/IRDBAccessSvc.h>
#include <RDBAccessSvc/IRDBRecord.h>
#include <RDBAccessSvc/IRDBRecordset.h>
#include <GeoModelRead/ReadGeoModel.h>
#include <GeoModelKernel/GeoFullPhysVol.h>
 
namespace
{
constexpr int HGTD_HitIndex{2};
}
 
HGTD_GmxInterface::HGTD_GmxInterface(HGTD_DetectorManager *detectorManager,
                                     InDetDD::SiCommonItems *commonItems)
    : AthMessaging("HGTD_GmxInterface"),
      m_detectorManager(detectorManager),
      m_commonItems(commonItems)
{
}
 
 
int HGTD_GmxInterface::sensorId(std::map<std::string, int> &index) const
{
    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;
 
}
 
 
void HGTD_GmxInterface::addSensorType(const std::string &clas,
                                      const std::string &typeName,
                                      const std::map<std::string, std::string> &parameters)
{
    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");
    }
}
 
 
void HGTD_GmxInterface::makeLgadModule(const std::string &typeName,
                                       const std::map<std::string, std::string> &parameters)
{
    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;
}
 
 
void HGTD_GmxInterface::addSensor(const std::string &typeName,
                                  std::map<std::string, int> &index,
                                  int /* sensitiveId */,
                                  GeoVFullPhysVol *fpv)
{
    //
    // 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;
}
 
void HGTD_GmxInterface::buildReadoutGeometryFromSqlite(IRDBAccessSvc * rdbAccessSvc,GeoModelIO::ReadGeoModel* sqlreader)
{
    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);
    }
}
 
void HGTD_GmxInterface::addAlignable(int level,
                                     std::map<std::string, int> &index,
                                     GeoVFullPhysVol *fpv,
                                     GeoAlignableTransform *transform)
{
    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);
}