MdtCalibrationT0ShiftTool Class Reference

Provides a per-tube smearing of the T0 value. More...

#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
	~MdtCalibrationT0ShiftTool ()=default
	destructor
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;
}

Member Data Documentation

m_centralValue

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

protectedinherited

Definition at line 53 of file MdtCalibrationShiftMapBase.h.

{this,"CentralValue",0};

m_forceMapRecreate

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

protectedinherited

Definition at line 55 of file MdtCalibrationShiftMapBase.h.

{this,"ForceMapRecreate",false};

m_idHelperSvc

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

protectedinherited

Definition at line 60 of file MdtCalibrationShiftMapBase.h.

{this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"};

m_mapFileName

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

protectedinherited

Definition at line 52 of file MdtCalibrationShiftMapBase.h.

{this,"MapFile",""};

m_mapIsInitialized

bool MdtCalibrationShiftMapBase::m_mapIsInitialized {false}

protectedinherited

Definition at line 58 of file MdtCalibrationShiftMapBase.h.

{false};

m_mdtCab

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

protectedinherited

Definition at line 61 of file MdtCalibrationShiftMapBase.h.

{this, "MdtCabling", "MuonMDT_CablingMap"};

m_shiftValues

std::map<Identifier, float> MdtCalibrationShiftMapBase::m_shiftValues

protectedinherited

Definition at line 57 of file MdtCalibrationShiftMapBase.h.

m_sigma

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

protectedinherited

Definition at line 54 of file MdtCalibrationShiftMapBase.h.

{this,"Sigma",10};

---

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

• MdtCalibrationT0ShiftTool.h
• MdtCalibrationT0ShiftTool.cxx