#include <StripGmxInterface.h>

Inheritance diagram for InDetDD::ITk::StripGmxInterface:

Collaboration diagram for InDetDD::ITk::StripGmxInterface:

Public Member Functions
	StripGmxInterface (SCT_DetectorManager detectorManager, SiCommonItems commonItems, WaferTree *waferTree)
virtual int	sensorId (std::map< std::string, int > &index) const override final
virtual int	splitSensorId (std::map< std::string, int > &index, std::pair< std::string, int > &extraIndex, std::map< std::string, int > &updatedIndex) 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	addSplitSensor (const std::string &typeName, std::map< std::string, int > &index, std::pair< std::string, int > &extraIndex, int sequentialId, GeoVFullPhysVol *fpv, int splitLevel) override final
virtual void	addAlignable (int level, std::map< std::string, int > &index, GeoVFullPhysVol fpv, GeoAlignableTransform transform) override final
virtual void	addSplitAlignable (int level, std::map< std::string, int > &index, std::pair< std::string, int > &extraIndex, GeoVFullPhysVol fpv, GeoAlignableTransform transform) override final
void	buildReadoutGeometryFromSqlite (IRDBAccessSvc rdbAccessSvc, GeoModelIO::ReadGeoModel sqlreader)
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	makeSiStripBox (const std::string &typeName, const std::map< std::string, std::string > &parameters)
void	makeStereoAnnulus (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 SiDetectorDesign * >	m_geometryMap
std::map< std::string, const SCT_ModuleSideDesign * >	m_motherMap
SCT_DetectorManager *	m_detectorManager {}
SiCommonItems *	m_commonItems {}
WaferTree *	m_waferTree {}
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 29 of file StripGmxInterface.h.

Constructor & Destructor Documentation

◆ StripGmxInterface()

InDetDD::ITk::StripGmxInterface::StripGmxInterface	(	SCT_DetectorManager *	detectorManager,
		SiCommonItems *	commonItems,
		WaferTree *	waferTree )

Definition at line 57 of file StripGmxInterface.cxx.

  : AthMessaging("StripGmxInterface"),
    m_detectorManager(detectorManager),
    m_commonItems(commonItems),
    m_waferTree(waferTree)
{}

Member Function Documentation

◆ addAlignable()

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

finaloverridevirtual

Definition at line 618 of file StripGmxInterface.cxx.

{
  ATH_MSG_DEBUG("addAlignable called");
  //
  // Get the offline-id appropriate to the level (0 = wafer, 1 = module, 2 = wheel/cylinder, 3 = part, i.e barrel or an endcap)
  //
  const SCT_ID *sctIdHelper = dynamic_cast<const SCT_ID *> (m_commonItems->getIdHelper());
  if (not sctIdHelper){
    ATH_MSG_ERROR("Failed dynamic_cast to SCT_ID in StripGmxInterface::addAlignable");
    return;
  }
  Identifier id;
  switch (level) {
    case 0:
      id = sctIdHelper->wafer_id(index[becStr],
                                 index[layerStr],
                                 index[phiStr],
                                 index[etaStr],
                                 index[sideStr]);
      break;
    case 1:
      id = sctIdHelper->wafer_id(index[becStr],
                                 index[layerStr],
                                 index[phiStr],
                                 index[etaStr],
                                 0);
      break;
    case 2:
      id = sctIdHelper->wafer_id(index[becStr],
                                 index[layerStr],
                                 0,
                                 0,
                                 0);
      break;
    case 3:
      id = sctIdHelper->wafer_id(index[becStr],
                                 0,
                                 0,
                                 0,
                                 0);
      break;
    default:
      throw GaudiException("Unknown level " + std::to_string(level) + " for alignment in addAlignable",
                           "StripGmxInterface::addAlignable", StatusCode::FAILURE);
      break;
  }
  m_detectorManager->addAlignableTransform(level, id, transform, fpv);
}

◆ addSensor()

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

finaloverride

Definition at line 552 of file StripGmxInterface.cxx.

{
  //
  // Get the ATLAS "Offline" wafer identifier
  //
  const SCT_ID *sctIdHelper = dynamic_cast<const SCT_ID *> (m_commonItems->getIdHelper());
  if (not sctIdHelper){
    ATH_MSG_ERROR("StripGmxInterface::addSensor: ID helper pointer could not be cast to SCT_ID *");
    return;
  }
  Identifier id = sctIdHelper->wafer_id(index[becStr],
                                        index[layerStr],
                                        index[phiStr],
                                        index[etaStr],
                                        index[sideStr]);
  IdentifierHash hashId = sctIdHelper->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_ERROR("Invalid id for sensitive module " << typeName << " volume with indices");
    for (const auto& [key, value] : index) {
      msg() << MSG::ERROR << key << " = " << value << "; ";
    }
    msg() << MSG::ERROR << endmsg;
    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
  //
  auto it = m_geometryMap.find(typeName);
  if(it == m_geometryMap.end() || it->second == nullptr) {
    ATH_MSG_ERROR("addSensor: Error: Readout sensor type " << typeName << " not found.");
    throw std::runtime_error("readout sensor type " + typeName + " not found.");
  }
  const SiDetectorDesign *design = it->second;
 
  m_detectorManager->addDetectorElement(new SiDetectorElement(id, design, fpv, m_commonItems));
 
  //
  // Build up a map-structure for numerology
  //
  Wafer wafer((unsigned int) hashId);
  std::string errorMessage("");
  if (!m_waferTree->add(index[becStr],
                        index[layerStr],
                        index[etaStr],
                        index[phiStr],
                        index[sideStr],
                        wafer,
                        errorMessage)) {
    ATH_MSG_ERROR(errorMessage);
  }
 
  return;
}

◆ addSensorType()

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

finaloverridevirtual

Definition at line 128 of file StripGmxInterface.cxx.

{
  ATH_MSG_DEBUG("addSensorType called for class " << clas << ", typeName " << typeName);
 
  if (clas == "SiStripBox") {
    makeSiStripBox(typeName, parameters);
  } else if (clas == "StereoAnnulus") {
    makeStereoAnnulus(typeName, parameters);
  } else { // To-do: add "Annulus"
    ATH_MSG_ERROR("addSensorType: unrecognised sensor class: " << clas);
    ATH_MSG_ERROR("No sensor design created");
  }
}

◆ addSplitAlignable()

void InDetDD::ITk::StripGmxInterface::addSplitAlignable	(	int	level,
		std::map< std::string, int > &	index,
		std::pair< std::string, int > &	extraIndex,
		GeoVFullPhysVol *	fpv,
		GeoAlignableTransform *	transform )

finaloverridevirtual

Definition at line 670 of file StripGmxInterface.cxx.

{
  ATH_MSG_DEBUG("addSplitAlignable called");
  //
  // Get the offline-id appropriate to the level (0 = wafer, 1 = module, 2 = wheel/cylinder, 3 = part, i.e barrel or an endcap)
  //
  std::map<std::string, int> updatedIndex;
  splitSensorId(index,extraIndex,updatedIndex);
 
  const SCT_ID *sctIdHelper = dynamic_cast<const SCT_ID *> (m_commonItems->getIdHelper());
  if (not sctIdHelper){
    ATH_MSG_ERROR("Failed dynamic_cast to SCT_ID in StripGmxInterface::addSplitAlignable");
    return;
  }
  Identifier id;
  switch (level) {
    case 0:
      id = sctIdHelper->wafer_id(updatedIndex[becStr],
                                 updatedIndex[layerStr],
                                 updatedIndex[phiStr],
                                 updatedIndex[etaStr],
                                 updatedIndex[sideStr]);
      break;
    case 1:
      id = sctIdHelper->wafer_id(updatedIndex[becStr],
                                 updatedIndex[layerStr],
                                 updatedIndex[phiStr],
                                 updatedIndex[etaStr],
                                 0);
      break;
    case 2:
      id = sctIdHelper->wafer_id(updatedIndex[becStr],
                                 updatedIndex[layerStr],
                                 0,
                                 0,
                                 0);
      break;
    case 3:
      id = sctIdHelper->wafer_id(updatedIndex[becStr],
                                 0,
                                 0,
                                 0,
                                 0);
      break;
    default:
      throw GaudiException("Unknown level " + std::to_string(level) + " for alignment in addSplitAlignable",
                           "StripGmxInterface::addSplitAlignable", StatusCode::FAILURE);
      break;
  }
  m_detectorManager->addAlignableTransform(level, id, transform, fpv);
}

◆ addSplitSensor()

void InDetDD::ITk::StripGmxInterface::addSplitSensor	(	const std::string &	typeName,
		std::map< std::string, int > &	index,
		std::pair< std::string, int > &	extraIndex,
		int	sequentialId,
		GeoVFullPhysVol *	fpv,
		int	splitLevel )

finaloverride

Definition at line 476 of file StripGmxInterface.cxx.

{
  std::map<std::string, int> updatedIndex;
  splitSensorId(index,extraIndex,updatedIndex);
  int splitIndex = extraIndex.second;
  //
  // Get the ATLAS "Offline" wafer identifier
  //
  const SCT_ID *sctIdHelper = dynamic_cast<const SCT_ID *> (m_commonItems->getIdHelper());
  if (not sctIdHelper){
    ATH_MSG_ERROR("Failed dynamic cast to SCT_ID in StripGmxInterface::addSplitSensor");
    return;
  }
  Identifier id = sctIdHelper->wafer_id(updatedIndex[becStr],
                                        updatedIndex[layerStr],
                                        updatedIndex[phiStr],
                                        updatedIndex[etaStr],
                                        updatedIndex[sideStr]);
  IdentifierHash hashId = sctIdHelper->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_ERROR("Invalid id for sensitive wafer " << typeName << " volume with indices");
    for (const auto& [key, value] : index) {
      msg() << MSG::ERROR << key << " = " << value << "; ";
    }
    msg() << MSG::ERROR << endmsg;
    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
  //
  std::string splitTypeName = typeName + "_" + std::to_string(splitIndex);
  if (updatedIndex[becStr] == 0) { // only barrel-type have side dependence
    splitTypeName += "_" + std::to_string(updatedIndex[sideStr]);
  }
 
  auto it = m_geometryMap.find(splitTypeName);
  if(it == m_geometryMap.end() || it->second == nullptr) {
    ATH_MSG_ERROR("addSplitSensor: Error: Readout sensor type " << typeName << " not found.");
    throw std::runtime_error("readout sensor type " + typeName + " not found.");
  }
  const SiDetectorDesign *design = it->second;
 
  m_detectorManager->addDetectorElement(new SiDetectorElement(id, design, fpv, m_commonItems));
 
  //
  // Build up a map-structure for numerology
  //
  Wafer wafer((unsigned int) hashId);
  std::string errorMessage("");
  if (!m_waferTree->add(updatedIndex[becStr],
                        updatedIndex[layerStr],
                        updatedIndex[etaStr],
                        updatedIndex[phiStr],
                        updatedIndex[sideStr],
                        wafer,
                        errorMessage)) {
    ATH_MSG_ERROR(errorMessage);
  }
 
  return;
}

◆ buildReadoutGeometryFromSqlite()

void InDetDD::ITk::StripGmxInterface::buildReadoutGeometryFromSqlite	(	IRDBAccessSvc *	rdbAccessSvc,
		GeoModelIO::ReadGeoModel *	sqlreader )

Definition at line 726 of file StripGmxInterface.cxx.

                                                                                                                    {
 
    IRDBRecordset_ptr stereoAnnulus = rdbAccessSvc->getRecordsetPtr("StereoAnnulus","");
    const std::array<std::string,13> stereoAnnulusParamNames{"thickness","carrierType","readoutSide","fieldDirection","stripDirection","stereoAngle","centreR","nRows","splitLevel","nStrips","phiPitch","startR","endR"};
 
    if(stereoAnnulus->size() !=0){
       for (unsigned int iR =0;iR<stereoAnnulus->size();iR++){
            std::map<std::string,std::string> stereoAnnulusMap;
            for(const std::string& paramName:stereoAnnulusParamNames){
                stereoAnnulusMap[paramName] = (*stereoAnnulus)[iR]->getString(paramName);
            }
        std::string stereoAnnulusName = (*stereoAnnulus)[iR]->getString("SensorType");
        makeStereoAnnulus(stereoAnnulusName,stereoAnnulusMap);
        } 
    }
    else ATH_MSG_WARNING("Could not retrieve StereoAnnulus table");
    
    IRDBRecordset_ptr stripBox = rdbAccessSvc->getRecordsetPtr("SiStripBox","");
    const std::array<std::string,10> stripBoxParamNames{"thickness","carrierType","readoutSide","fieldDirection","stripDirection","nRows","stripLength","splitLevel","nStrips","pitch"};
 
    if(stripBox->size() !=0){
       for (unsigned int iR =0;iR<stripBox->size();iR++){
            std::map<std::string,std::string> stripBoxMap;
            for(const std::string& paramName:stripBoxParamNames){
                std::string paramValue = (*stripBox)[iR]->getString(paramName);
                stripBoxMap[paramName] = std::move(paramValue);
            }
        std::string stripBoxName = (*stripBox)[iR]->getString("SensorType");
        makeSiStripBox(stripBoxName,stripBoxMap);
        } 
    }
    else ATH_MSG_WARNING("Could not retrieve SiStripBox table");
 
    //Now, loop over the FullPhysVols and create the SiDetectorElements (including splitting where needed)
    //lots of string parsing...
    const std::array<std::string,5> fields{becStr,layerStr,phiStr,etaStr,sideStr}; 
    //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 - ITkPlugin, then ITkStripPlugin, then GeoModelXMLPlugin
    const std::array<std::string,3> publishers{"ITk","ITkStrip","GeoModelXML"};
    //The below is a map of string keys which will contain all the Identifier/DetElement relevant info, and the associated FullPhysVol
    // (once filled from the published table in the SQLite)
    std::map<std::string, GeoFullPhysVol*> mapFPV;
    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 then 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);
    std::pair<std::string, int> extraIndex{etaStr, 0}; // eventually specify in XML the field to split in?
    for (const auto&[fullPhysVolInfoString, fullPhysVolPointer] : mapFPV){
        //find the name of the corresponding detector design type
        size_t startRG = fullPhysVolInfoString.find("RG_");
        if(startRG==std::string::npos){
            ATH_MSG_DEBUG("GeoFullPhysVol "<<fullPhysVolInfoString<<" does not have the expected format. Skipping");
            continue;
        } 
        std::string typeName = fullPhysVolInfoString.substr(startRG);
        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);
        }
        //now check if we need to split
        size_t splitPos = fullPhysVolInfoString.find("split_");
        
        if(splitPos!=std::string::npos){
            size_t last = fullPhysVolInfoString.find('_',splitPos+6);//"split_" is 6 characters
            std::string strNew = fullPhysVolInfoString.substr(splitPos+6,last-(splitPos+6));
            int splitLevel = std::stoi(strNew);
            for(int i=0;i<splitLevel;i++){
              extraIndex.second = i;
              addSplitSensor(typeName,index,extraIndex,0,fullPhysVolPointer,splitLevel);
            }
        }
        else 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;
  }
}

◆ makeSiStripBox()

void InDetDD::ITk::StripGmxInterface::makeSiStripBox	(	const std::string &	typeName,
		const std::map< std::string, std::string > &	parameters )

private

Definition at line 145 of file StripGmxInterface.cxx.

{
  //
  // Get all parameters.
  //
  
  double thickness{0.320};
  int readoutSide{1};
  InDetDD::CarrierType carrier(InDetDD::electrons);
  int nRows{1};
  double pitch{0.080};
  int nStrips{1280}; // Per row
  double length{25.0};
 
  std::string carrierString;
  getParameter(typeName, parameters, "carrierType", carrierString);
  if (carrierString == "electrons") {
    carrier = InDetDD::electrons;
  } else if (carrierString == "holes") {
    carrier = InDetDD::holes;
  } else {
    throw GaudiException("Parameter carrierType should be electrons or holes for " + typeName,
                         "StripGmxInterface::makeSiStripBox", StatusCode::FAILURE);
  }
 
  std::string readoutSideString;
  getParameter(typeName, parameters, "readoutSide", readoutSideString);
  if (readoutSideString == "+") {
    readoutSide = 1;
  } else if (readoutSideString == "-") {
    readoutSide = -1;
  } else {
    throw GaudiException("Parameter readoutSide should be + or - for " + typeName,
                         "StripGmxInterface::makeSiStripBox", StatusCode::FAILURE);
  }
 
  std::string fieldDirectionString;
  getParameter(typeName, parameters, "fieldDirection", fieldDirectionString);
  auto fieldDirectionOptional = direction(fieldDirectionString);
  if (!fieldDirectionOptional){
    throw GaudiException("Parameter fieldDirection should be x, y, or z for " + typeName,
                         "StripGmxInterface::makeSiStripBox", StatusCode::FAILURE);
  }
 
  std::string stripDirectionString;
  getParameter(typeName, parameters, "stripDirection", stripDirectionString);
  auto stripDirectionOptional = direction(stripDirectionString);
  if (!stripDirectionOptional){
    throw GaudiException("Parameter stripDirection should be x, y, or z for " + typeName,
                         "StripGmxInterface::makeSiStripBox", StatusCode::FAILURE);
  }
  const auto stripDirection = *stripDirectionOptional;
  const auto fieldDirection = *fieldDirectionOptional;
  getParameter(typeName, parameters, "thickness", thickness);
  getParameter(typeName, parameters, "nRows", nRows);
  getParameter(typeName, parameters, "nStrips", nStrips);
  getParameter(typeName, parameters, "pitch", pitch);
  getParameter(typeName, parameters, "stripLength", length);
 
  //At the moment, we'd only ever want StripBarrel for this detector type, so throw a WARNING if it differs
  //However, in future this may be different, so implementing the functionality to set this anyway 
  InDetDD::DetectorType detectorType{InDetDD::StripBarrel};
  int detectorTypeEnum = 0;
  if (checkParameter(typeName, parameters, "detectorType", detectorTypeEnum)) {
    if (detectorTypeEnum == 4) detectorType = InDetDD::StripBarrel;
    else ATH_MSG_WARNING("Non-strip barrel type set for strip box DetectorElement - is this intended?");
  }
 
 
  //
  // Make Sensor Design and add to DetectorManager
  //
 
  int splitLevel{};
  if (checkParameter(typeName, parameters, "splitLevel", splitLevel)) {
    // start from middle of first strip row
    double initZShift = length * (-static_cast<double>(splitLevel) * 0.5 + 0.5);
 
    // now, the "Mother"...
    // This is a container for all the other designs, to allow navigation
    // between the different rows on a simulated sensor in the HITS
    auto motherDesign = std::make_unique<StripBoxDesign>(stripDirection,
                                                         fieldDirection,
                                                         thickness,
                                                         readoutSide,
                                                         carrier,
                                                         nRows,
                                                         nStrips,
                                                         pitch,
                                                         length,
                                                         detectorType);
 
    for (int i = 0; i< splitLevel; i++) {
      for (int side : {0,1}) { //need different additional shift transform per side...
        int sign = (side == 0) ? 1 : -1; //...because shift in different direction per side
        double zShift = sign * (initZShift + (i * length));
 
        auto design = std::make_unique<StripBoxDesign>(stripDirection,
                                                       fieldDirection,
                                                       thickness,
                                                       readoutSide,
                                                       carrier,
                                                       1, //single row
                                                       nStrips,
                                                       pitch,
                                                       length,
                                                       detectorType,
                                                       zShift);
 
        design->setMother(motherDesign.get());
        motherDesign->addChildDesign(i,design.get());
 
        std::string splitName = typeName + "_" + std::to_string(i) + "_" + std::to_string(side);
        m_geometryMap[splitName] = m_detectorManager->addDesign(std::move(design));
      }
    }
 
    // Add to map for addSensor routine
    m_motherMap[typeName] = motherDesign.get();
    m_detectorManager->addMotherDesign(std::move(motherDesign));
  } else { // no split level
    auto design = std::make_unique<StripBoxDesign>(stripDirection,
                                                   fieldDirection,
                                                   thickness,
                                                   readoutSide,
                                                   carrier,
                                                   nRows,
                                                   nStrips,
                                                   pitch,
                                                   length,
                                                   detectorType);
 
    // Add to map for addSensor routine
    m_geometryMap[typeName] = design.get();
    m_detectorManager->addDesign(std::move(design));
  }
}

◆ makeStereoAnnulus()

void InDetDD::ITk::StripGmxInterface::makeStereoAnnulus	(	const std::string &	typeName,
		const std::map< std::string, std::string > &	parameters )

private

Definition at line 285 of file StripGmxInterface.cxx.

{
  //
  //  Get all parameters.
  //
  int readoutSide{1};
 
  InDetDD::CarrierType carrier{InDetDD::electrons};
  double thickness{0.320};
  double stereoAngle{0.020};
  double centreR{500.};
  int nRows{1};
  std::vector <int> nStrips;
  std::vector<double> phiPitch;
  std::vector<double> startR;
  std::vector<double> endR;
  bool usePC{false}; // initialise to false
 
  std::string carrierString;
  getParameter(typeName, parameters, "carrierType", carrierString);
  if (carrierString == "electrons") {
    carrier = InDetDD::electrons;
  } else if (carrierString == "holes") {
    carrier = InDetDD::holes;
  } else {
    throw GaudiException("Parameter carrierType should be electrons or holes for " + typeName,
                         "StripGmxInterface::makeStereoAnnulus", StatusCode::FAILURE);
  }
 
  std::string readoutSideString;
  getParameter(typeName, parameters, "readoutSide", readoutSideString);
  if (readoutSideString == "+") {
    readoutSide = 1;
  } else if (readoutSideString == "-") {
    readoutSide = -1;
  } else {
    throw GaudiException("Parameter readoutSide should be + or - for " + typeName,
                         "StripGmxInterface::makeStereoAnnulus", StatusCode::FAILURE);
  }
 
  std::string fieldDirectionString;
  getParameter(typeName, parameters, "fieldDirection", fieldDirectionString);
  auto fieldDirectionOptional = direction(fieldDirectionString);
  if (!fieldDirectionOptional){
    throw GaudiException("Parameter fieldDirection should be x, y, or z for " + typeName,
                         "StripGmxInterface::makeStereoAnnulus", StatusCode::FAILURE);
  }
  const auto fieldDirection = *fieldDirectionOptional;
  //
  std::string stripDirectionString;
  getParameter(typeName, parameters, "stripDirection", stripDirectionString);
  auto stripDirectionOptional = direction(stripDirectionString);
  if (!stripDirectionOptional){
    throw GaudiException("Parameter stripDirection should be x, y, or z for " + typeName,
                         "StripGmxInterface::makeStereoAnnulus", StatusCode::FAILURE);
  }
  const auto stripDirection = *stripDirectionOptional;
  getParameter(typeName, parameters, "thickness", thickness);
  getParameter(typeName, parameters, "stereoAngle", stereoAngle);
  getParameter(typeName, parameters, "centreR", centreR);
  getParameter(typeName, parameters, "nRows", nRows);
 
  getParameters(typeName, parameters, "nStrips", nStrips);
  if (nStrips.size() != static_cast<size_t>(nRows)) {
    throw GaudiException("Wrong number of nStrips " + std::to_string(nStrips.size()) + " " + typeName,
                         "StripGmxInterface::makeStereoAnnulus", StatusCode::FAILURE);
  }
 
  getParameters(typeName, parameters, "phiPitch", phiPitch);
  if (phiPitch.size() != static_cast<size_t>(nRows)) {
    throw GaudiException("Wrong number of pitches " + std::to_string(phiPitch.size()) + " " + typeName,
                         "StripGmxInterface::makeStereoAnnulus", StatusCode::FAILURE);
  }
 
  getParameters(typeName, parameters, "startR", startR);
  if (startR.size() != static_cast<size_t>(nRows)) {
    throw GaudiException("Wrong number of startRs " + std::to_string(startR.size()) + " " + typeName,
                         "StripGmxInterface::makeStereoAnnulus", StatusCode::FAILURE);
  }
 
  getParameters(typeName, parameters, "endR", endR);
  if (endR.size() != static_cast<size_t>(nRows)) {
    throw GaudiException("Wrong number of endRs " + std::to_string(endR.size()) + " " + typeName,
                         "StripGmxInterface::makeStereoAnnulus", StatusCode::FAILURE);
  }
 
  if (checkParameter(typeName, parameters, "usePC", usePC)) ATH_MSG_INFO("Using polar co-ordinates for strip stereo annulus modules");
 
 
   //At the moment, we'd only ever want StripEndcap for this detector type, so throw a WARNING if it differs
  //However, in future this may be different, so implementing the functionality to set this anyway 
  InDetDD::DetectorType detectorType{InDetDD::StripEndcap};
  int detectorTypeEnum = 0;
  if (checkParameter(typeName, parameters, "detectorType", detectorTypeEnum)) {
    if (detectorTypeEnum == 5) detectorType = InDetDD::StripEndcap;
    else ATH_MSG_WARNING("Non-strip endcap type set for strip annulus DetectorElement - is this intended?");
  }
 
  //
  //  Make Sensor Design and add it to the DetectorManager
  //
  std::vector<int> singleRowStrips;
  std::vector<double> singleRowPitch;
  std::vector<double> singleRowMinR;
  std::vector<double> singleRowMaxR;
 
  int splitLevel{};
  if (checkParameter(typeName, parameters, "splitLevel", splitLevel)) {
    // now the mother...
    auto motherDesign = std::make_unique<StripStereoAnnulusDesign>(stripDirection,
                                                                   fieldDirection,
                                                                   thickness,
                                                                   readoutSide,
                                                                   carrier,
                                                                   nRows,
                                                                   nStrips,
                                                                   phiPitch,
                                                                   startR,
                                                                   endR,
                                                                   stereoAngle,
                                                                   centreR,
                                                                   usePC,
                                                                   detectorType);
 
    for (int i = 0; i < splitLevel; i++) {
      singleRowStrips.clear();
      singleRowPitch.clear();
      singleRowMinR.clear();
      singleRowMaxR.clear();
 
      singleRowStrips.push_back(nStrips[i]);
      singleRowPitch.push_back(phiPitch[i]);
      singleRowMinR.push_back(startR[i]);
      singleRowMaxR.push_back(endR[i]);
    //"shift" radius for correcting local<->global transforms
    //centreR remains the relevant radius for bounds/stereo calculations
    //since the strip frame is defined per wafer not per row
      double thisCentreR = (singleRowMinR[0] + singleRowMaxR[0] ) *0.5;
 
      auto design = std::make_unique<StripStereoAnnulusDesign>(stripDirection,
                                                               fieldDirection,
                                                               thickness,
                                                               readoutSide,
                                                               carrier,
                                                               1,//this design represents a single row by definition
                                                               singleRowStrips,
                                                               singleRowPitch,
                                                               singleRowMinR,
                                                               singleRowMaxR,
                                                               stereoAngle,
                                                               thisCentreR,
                                                               centreR,
                                                               usePC,
                                                               detectorType);
 
      // Add to map for addSensor routine
      std::string splitName = typeName + "_" + std::to_string(i);
      design->setMother(motherDesign.get());
      motherDesign->addChildDesign(i,design.get());
 
      m_geometryMap[splitName] = design.get();
      m_detectorManager->addDesign(std::move(design));
 
    }
 
    // finally, declare to the manager (now becomes const)
    m_motherMap[typeName] = motherDesign.get();
    m_detectorManager->addMotherDesign(std::move(motherDesign));
 
  } else {
    auto design = std::make_unique<StripStereoAnnulusDesign>(stripDirection,
                                                             fieldDirection,
                                                             thickness,
                                                             readoutSide,
                                                             carrier,
                                                             nRows,
                                                             nStrips,
                                                             phiPitch,
                                                             startR,
                                                             endR,
                                                             stereoAngle,
                                                             centreR,
                                                             usePC,
                                                             detectorType);
 
    m_geometryMap[typeName] = design.get();
    m_detectorManager->addDesign(std::move(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.

183{ 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 InDetDD::ITk::StripGmxInterface::sensorId ( std::map< std::string, int > & index ) const

finaloverridevirtual

Definition at line 67 of file StripGmxInterface.cxx.

{
  //
  // Return the Simulation HitID (nothing to do with "ATLAS Identifiers" aka "Offline Identifiers"
 
  int hitIdOfWafer = SiHitIdHelper::GetHelper()->buildHitId(SCT_HitIndex,
                                                            index[becStr],
                                                            index[layerStr],
                                                            index[etaStr],
                                                            index[phiStr],
                                                            index[sideStr]);
 
  ATH_MSG_DEBUG("Index list: " << index[becStr] << " " << index[layerStr] << " "
                               << index[etaStr] << " " << index[phiStr] << " " << index[sideStr]);
  ATH_MSG_DEBUG("hitIdOfWafer = " << std::hex << hitIdOfWafer << std::dec);
  ATH_MSG_DEBUG(" bec = " << SiHitIdHelper::GetHelper()->getBarrelEndcap(hitIdOfWafer)
                << " lay = " << SiHitIdHelper::GetHelper()->getLayerDisk(hitIdOfWafer)
                << " eta = " << SiHitIdHelper::GetHelper()->getEtaModule(hitIdOfWafer)
                << " phi = " << SiHitIdHelper::GetHelper()->getPhiModule(hitIdOfWafer)
                << " side = " << SiHitIdHelper::GetHelper()->getSide(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;
}

◆ splitSensorId()

int InDetDD::ITk::StripGmxInterface::splitSensorId	(	std::map< std::string, int > &	index,
		std::pair< std::string, int > &	extraIndex,
		std::map< std::string, int > &	updatedIndex ) const

finaloverridevirtual

Definition at line 90 of file StripGmxInterface.cxx.

{
  //
  // Return the Simulation HitID (nothing to do with "ATLAS Identifiers" aka "Offline Identifiers"
 
  if (extraIndex.first != etaStr) {
    ATH_MSG_FATAL("Base Identifier: " << index[becStr] << " " << index[layerStr] << " "
                  << index[etaStr] << " " << index[phiStr] << " " << index[sideStr]);
    ATH_MSG_FATAL("Attempting to split "<< extraIndex.second);
    ATH_MSG_FATAL("Only splitting of eta_module supported for ITk strips!!!");
    return -1;
  }
 
  //add the required amount to the requested field
  updatedIndex = index;
  updatedIndex[extraIndex.first] += extraIndex.second;
 
  int hitIdOfWafer = SiHitIdHelper::GetHelper()->buildHitId(SCT_HitIndex,
                                                            index[becStr],
                                                            index[layerStr],
                                                            index[etaStr] + extraIndex.second,
                                                            index[phiStr],
                                                            index[sideStr]);
 
  ATH_MSG_DEBUG("Index list: " << index[becStr] << " " << index[layerStr] << " "
                << index[etaStr] + extraIndex.second << " " << index[phiStr] << " " << index[sideStr]);
  ATH_MSG_DEBUG("hitIdOfWafer = " << std::hex << hitIdOfWafer << std::dec);
  ATH_MSG_DEBUG(" bec = " << SiHitIdHelper::GetHelper()->getBarrelEndcap(hitIdOfWafer)
                << " lay = " << SiHitIdHelper::GetHelper()->getLayerDisk(hitIdOfWafer)
                << " eta = " << SiHitIdHelper::GetHelper()->getEtaModule(hitIdOfWafer)
                << " phi = " << SiHitIdHelper::GetHelper()->getPhiModule(hitIdOfWafer)
                << " side = " << SiHitIdHelper::GetHelper()->getSide(hitIdOfWafer));
  return hitIdOfWafer;
}

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

SiCommonItems* InDetDD::ITk::StripGmxInterface::m_commonItems {}

private

Definition at line 73 of file StripGmxInterface.h.

73{};

◆ m_detectorManager

SCT_DetectorManager* InDetDD::ITk::StripGmxInterface::m_detectorManager {}

private

Definition at line 72 of file StripGmxInterface.h.

72{};

◆ m_geometryMap

std::map<std::string, const SiDetectorDesign *> InDetDD::ITk::StripGmxInterface::m_geometryMap

private

Definition at line 70 of file StripGmxInterface.h.

◆ m_imsg

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

mutableprivateinherited

MessageSvc pointer.

Definition at line 135 of file AthMessaging.h.

135{ nullptr };

◆ m_lvl

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

mutableprivateinherited

Current logging level.

Definition at line 138 of file AthMessaging.h.

138{ MSG::NIL };

◆ m_motherMap

std::map<std::string, const SCT_ModuleSideDesign *> InDetDD::ITk::StripGmxInterface::m_motherMap

private

Definition at line 71 of file StripGmxInterface.h.

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

◆ m_waferTree

WaferTree* InDetDD::ITk::StripGmxInterface::m_waferTree {}

private

Definition at line 74 of file StripGmxInterface.h.

74{};

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

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ StripGmxInterface()

Member Function Documentation

◆ addAlignable()

◆ addSensor()

◆ addSensorType()

◆ addSplitAlignable()

◆ addSplitSensor()

◆ buildReadoutGeometryFromSqlite()

◆ initMessaging()

◆ makeSiStripBox()

◆ makeStereoAnnulus()

◆ msg() [1/2]

◆ msg() [2/2]

◆ msgLvl()

◆ sensorId()

◆ setLevel()

◆ splitSensorId()

Member Data Documentation

◆ ATLAS_THREAD_SAFE

◆ m_commonItems

◆ m_detectorManager

◆ m_geometryMap

◆ m_imsg

◆ m_lvl

◆ m_motherMap

◆ m_msg_tls

◆ m_nm

◆ m_waferTree