#include <MdtCalibrationShiftMapBase.h>

Inheritance diagram for MdtCalibrationShiftMapBase:

Collaboration diagram for MdtCalibrationShiftMapBase:

Public Member Functions
	MdtCalibrationShiftMapBase (const std::string &type, const std::string &name, const IInterface *parent)

	~MdtCalibrationShiftMapBase ()=default

float	getValue (const Identifier &id) const override

virtual StatusCode	initialize () override

virtual StatusCode	initializeMap ()=0

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 the base class for the per-tube shifting tools, like MdtCalibT0ShiftTool & MdtCalibTMaxShiftTool.

Author: Andreas Hoenle

Definition at line 24 of file MdtCalibrationShiftMapBase.h.

Constructor & Destructor Documentation

◆ MdtCalibrationShiftMapBase()

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

Definition at line 12 of file MdtCalibrationShiftMapBase.cxx.

13 : base_class (type, name, parent) {}

◆ ~MdtCalibrationShiftMapBase()

MdtCalibrationShiftMapBase::~MdtCalibrationShiftMapBase ( )

default

Member Function Documentation

◆ dumpMapAsFile()

StatusCode MdtCalibrationShiftMapBase::dumpMapAsFile ( )

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

override

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 ( )

overridevirtual

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()

virtual StatusCode MdtCalibrationShiftMapBase::initializeMap ( )

pure virtual

Implemented in MdtCalibrationT0ShiftTool, and MdtCalibrationTMaxShiftTool.

◆ loadMapFromFile()

StatusCode MdtCalibrationShiftMapBase::loadMapFromFile ( )

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;
 }