#include <MdtCalibrationT0ShiftTool.h>

Inheritance diagram for MdtCalibrationT0ShiftTool:

Collaboration diagram for MdtCalibrationT0ShiftTool:

Public Member Functions
	MdtCalibrationT0ShiftTool (const std::string &type, const std::string &name, const IInterface *parent)
	constructor More...

	~MdtCalibrationT0ShiftTool ()=default
	destructor More...

StatusCode	initializeMap () override final

float	getValue (const Identifier &id) const override

virtual StatusCode	initialize () override

StatusCode	dumpMapAsFile ()

StatusCode	loadMapFromFile ()

Protected Attributes
Gaudi::Property< std::string >	m_mapFileName {this,"MapFile",""}

Gaudi::Property< float >	m_centralValue {this,"CentralValue",0}

Gaudi::Property< float >	m_sigma {this,"Sigma",10}

Gaudi::Property< bool >	m_forceMapRecreate {this,"ForceMapRecreate",false}

std::map< Identifier, float >	m_shiftValues

bool	m_mapIsInitialized {false}

ServiceHandle< Muon::IMuonIdHelperSvc >	m_idHelperSvc {this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"}

SG::ReadCondHandleKey< MuonMDT_CablingMap >	m_mdtCab {this, "MdtCabling", "MuonMDT_CablingMap"}

Detailed Description

Provides a per-tube smearing of the T0 value.

Author: Andreas Hoenle

Definition at line 16 of file MdtCalibrationT0ShiftTool.h.

Constructor & Destructor Documentation

◆ MdtCalibrationT0ShiftTool()

MdtCalibrationT0ShiftTool::MdtCalibrationT0ShiftTool	(	const std::string &	type,
		const std::string &	name,
		const IInterface *	parent
	)

constructor

Definition at line 11 of file MdtCalibrationT0ShiftTool.cxx.

                                                                                                                            :
   MdtCalibrationShiftMapBase(type, name, parent) {
 }

◆ ~MdtCalibrationT0ShiftTool()

MdtCalibrationT0ShiftTool::~MdtCalibrationT0ShiftTool ( )

default

destructor

Member Function Documentation

◆ dumpMapAsFile()

StatusCode MdtCalibrationShiftMapBase::dumpMapAsFile ( )

inherited

Definition at line 22 of file MdtCalibrationShiftMapBase.cxx.

                                                      {
   /* initialize map if it's not there */
   if (!m_mapIsInitialized) {
     ATH_CHECK(initializeMap());
   }
  
   /* write the map to a file */
   {
     std::ofstream file(m_mapFileName.value().c_str(), std::ios::out | std::ios::trunc);
  
     /* see if opening the file was successful */
     if (!file.is_open()) {
       ATH_MSG_FATAL(
           "Cannot open map output file for writing. Tried accessing file at \"./"
           << m_mapFileName << "\"");
       return StatusCode::FAILURE;
     }
  
     /* write header, comments can start with '#' or '//' */
     file << "# This file contains shift values for MDT tubes\n";
     file << "# Each Identifier is mapped to a float\n";
     file << "# Below are comma separated values with formatting\n";
     file << "# Identifier.get_compact(),float\n";
     file << "# ------------------------------------------------\n";
  
     /* dump map contents */
     for (auto shift : m_shiftValues) {
       Identifier::value_type identifierCompact = shift.first.get_compact();
       float shiftValue = shift.second;
       file << identifierCompact;
       file << ",";
       file << shiftValue;
       file << "\n";
     }
   }  // '}' flushes file
   return StatusCode::SUCCESS;
 }

◆ getValue()

float MdtCalibrationShiftMapBase::getValue ( const Identifier & id ) const

overrideinherited

Definition at line 130 of file MdtCalibrationShiftMapBase.cxx.

                                                                      { 
   std::map<Identifier, float>::const_iterator itr = m_shiftValues.find(id);
   if (itr == m_shiftValues.end()){
       ATH_MSG_FATAL("The identifier "<<m_idHelperSvc->toString(id)<<" is not known for a T0 smearing");
       throw std::runtime_error("MdtT0Calibration - Invalid identifier");
   }
   return itr->second; 
 }

◆ initialize()

StatusCode MdtCalibrationShiftMapBase::initialize ( )

overridevirtualinherited

Definition at line 15 of file MdtCalibrationShiftMapBase.cxx.

                                                   {
   ATH_CHECK(m_idHelperSvc.retrieve());
   ATH_CHECK(m_mdtCab.initialize());
   ATH_CHECK(initializeMap());
   return StatusCode::SUCCESS;
 }

◆ initializeMap()

StatusCode MdtCalibrationT0ShiftTool::initializeMap ( )

finaloverridevirtual

Loop over all tdc channels

Implements MdtCalibrationShiftMapBase.

Definition at line 15 of file MdtCalibrationT0ShiftTool.cxx.

 {
   if (m_mapIsInitialized) {
     ATH_MSG_WARNING("Map already initalized. Multiple calls of initalizeMap should not happen.");
     return StatusCode::SUCCESS;
   }
  
   /* First try loading the map from its default location */
   if (!m_forceMapRecreate) {
     ATH_CHECK(loadMapFromFile());
     return StatusCode::SUCCESS;
   }
  
   /* map was not found as a file or needs to be recreated */
   // TODO: What if multiple jobs started in parallel?
   //       (DataRace on MapFile because of parallel jobs)
  
   /* initialize random number generator that creates the shift values */
   TRandom3 rng(/*seed*/ 20120704);
  
   SG::ReadCondHandle<MuonMDT_CablingMap> readHandle{m_mdtCab, Gaudi::Hive::currentContext()};
   const MuonMDT_CablingMap* mdtCabling{*readHandle};
   if(!mdtCabling){
     ATH_MSG_ERROR("Null pointer to the MDT cabling conditions object");
     return StatusCode::FAILURE;
   }
   
   for (const auto& onl_cab : mdtCabling->getOnlineConvMap()) {
       MuonMDT_CablingMap::CablingData cabling_data{};
       cabling_data.MdtCablingOnData::operator=(onl_cab.first);
       for (const auto& tdc : onl_cab.second) {
           if (!tdc) continue;
           cabling_data.tdcId = tdc->moduleId();          
           for (cabling_data.channelId = 0; cabling_data.channelId < 24; ++cabling_data.channelId) {
              /* Get the offline ID, given the current detector element */
             if (!mdtCabling->getOfflineId(cabling_data, msgStream())) {
               ATH_MSG_WARNING(cabling_data);
               continue;
             }
             Identifier channelIdentifier;
             bool isValid  = mdtCabling->convert(cabling_data,channelIdentifier);
             // this debug msg can be removed eventually
             ATH_MSG_DEBUG("Trying to set from online IDs "<<
                           std::endl<<
                           cabling_data<< 
                           " .. with channelID"<<
                           std::endl << 
                           "  Identifier    " << 
                           channelIdentifier <<std::endl<<"  Identifier32  " << channelIdentifier.get_identifier32());
  
             if (!isValid) {
               ATH_MSG_FATAL(cabling_data<<" --- Conversion to Identifier is NOT valid.");
               return StatusCode::FAILURE;
             }
  
             double rn = rng.Gaus(m_centralValue, m_sigma);
             // Fatal if entry exists
             if (m_shiftValues.find(channelIdentifier) != m_shiftValues.end()) {
               ATH_MSG_FATAL("Double counting in initialization of map");
               return StatusCode::FAILURE;
             }
             m_shiftValues[channelIdentifier] = rn;
           
           }
       }
   }
   /* initalization was successful */
   m_mapIsInitialized = true;
  
   /* write map to the default location */
   ATH_CHECK( dumpMapAsFile() );
  
   return StatusCode::SUCCESS;
 }

◆ loadMapFromFile()

StatusCode MdtCalibrationShiftMapBase::loadMapFromFile ( )

inherited

Definition at line 60 of file MdtCalibrationShiftMapBase.cxx.

                                                        {
   /* check if map was already initialized */
   if (m_mapIsInitialized) {
     ATH_MSG_WARNING("Map already initialized, won't overwrite it.");
     return StatusCode::SUCCESS;
   }
  
   /* resolve path */
   std::string fileWithPath = PathResolver::find_file(m_mapFileName, "DATAPATH");
   if (fileWithPath.empty()) {
     ATH_MSG_ERROR("Cannot find file " << m_mapFileName << " in $DATAPATH");
     return StatusCode::FAILURE;
   }
  
   /* check if the file exists */
   struct stat buffer{};
   if (stat(fileWithPath.c_str(), &buffer) != 0) {
     ATH_MSG_ERROR("Cannot stat the file \""
                   << fileWithPath.c_str()
                   << "\" -> map can not be initialized from this file.");
     return StatusCode::FAILURE;
   }
  
   /* check if the map is already stored */
   std::ifstream fin(fileWithPath.c_str(), std::ios::in);
   std::string line;
   bool initializedWithWarnings = false;
   // get all lines in file
   while (std::getline(fin, line)) {
     // check if file is empty, begins with '#', or '//'
     if (line.empty() || line.compare(0, 1, "#") == 0 ||
         line.compare(0, 2, "//")) {
       continue;
     }
     // need a stringstream for readline
     std::stringstream lineStream(line);
     // get all csv tokens in line
     std::string token;
     std::vector<std::string> tokenVector;
     while (std::getline(lineStream, token, ',')) {
       tokenVector.push_back(token);
     }
     // expect exactly two tokens: identifier and value
     if (tokenVector.size() == 2) {
       // we are careful about the type here
       // watch out for compiler warnings warning about casting ull to value_type
       // they might occur of Identifier::value_type is changed at some point
       Identifier::value_type identifierCompact = std::stoull(tokenVector[0]);
       Identifier id(identifierCompact);
       float shift = std::stof(tokenVector[1]);
       m_shiftValues[id] = shift;
     } else {
       ATH_MSG_WARNING("Unexpected input format in shift map file "
                       << fileWithPath.c_str());
       ATH_MSG_WARNING("Expected 2 tokens, got " << tokenVector.size());
       ATH_MSG_WARNING("Broken line: \"" << line.c_str() << "\"");
       initializedWithWarnings = true;
     }
   }
   m_mapIsInitialized = true;
   if (initializedWithWarnings) {
     ATH_MSG_WARNING("Initialized shift map WITH WARNINGS from file \""
                     << fileWithPath.c_str() << "\"");
   } else {
     ATH_MSG_INFO("Successfully initialized shift map from file \""
                  << fileWithPath.c_str() << "\"");
   }
   return StatusCode::SUCCESS;
 }