Muon::NSWCalibTool Class Reference

#include <NSWCalibTool.h>

Inheritance diagram for Muon::NSWCalibTool:

Collaboration diagram for Muon::NSWCalibTool:

Public Types
using	TimeCalibType = NswCalibDbTimeChargeData::CalibDataType
using	TimeCalibConst = NswCalibDbTimeChargeData::CalibConstants

Public Member Functions
virtual	~NSWCalibTool ()=default
StatusCode	calibrateClus (const EventContext &ctx, const Muon::MMPrepData *prepData, const Amg::Vector3D &globalPos, std::vector< NSWCalib::CalibratedStrip > &calibClus) const override
StatusCode	distToTime (const EventContext &ctx, const Muon::MMPrepData *prepData, const Amg::Vector3D &globalPos, const std::vector< double > &driftDistances, std::vector< double > &driftTimes) const override
StatusCode	calibrateClus (const EventContext &ctx, const ActsTrk::GeometryContext &gctx, const xAOD::MMCluster &prepData, const Amg::Vector3D &globalPos, std::vector< NSWCalib::CalibratedStrip > &calibClus) const override
StatusCode	calibrateStrip (const EventContext &ctx, const Identifier &id, const double time, const double charge, const double theta, const double lorentzAngle, NSWCalib::CalibratedStrip &calibStrip) const override
StatusCode	calibrateStrip (const EventContext &ctx, const Muon::MM_RawData *mmRawData, NSWCalib::CalibratedStrip &calibStrip) const override
StatusCode	calibrateStrip (const EventContext &ctx, const Muon::STGC_RawData *sTGCRawData, NSWCalib::CalibratedStrip &calibStrip) const override
bool	tdoToTime (const EventContext &ctx, const bool inCounts, const int tdo, const Identifier &chnlId, float &time, const int relBCID) const override
bool	timeToTdo (const EventContext &ctx, const float time, const Identifier &chnlId, int &tdo, int &relBCID) const override
bool	chargeToPdo (const EventContext &ctx, const float charge, const Identifier &chnlId, int &pdo) const override
bool	pdoToCharge (const EventContext &ctx, const bool inCounts, const int pdo, const Identifier &chnlId, float &charge) const override
virtual StatusCode	initialize () override
NSWCalib::MicroMegaGas	mmGasProperties () const override
float	mmPeakTime () const override
float	stgcPeakTime () const override

Private Types
using	angleFunction = NSWCalib::MicroMegaGas::angleFunction

Private Member Functions
const NswCalibDbTimeChargeData *	getCalibData (const EventContext &ctx) const
bool	loadMagneticField (const EventContext &ctx, MagField::AtlasFieldCache &fieldCache) const
const Muon::mmCTPClusterCalibData *	getCTPClusterCalibData (const EventContext &ctx) const
bool	timeToTdoMM (const NswCalibDbTimeChargeData *tdoPdoData, const float time, const Identifier &chnlId, int &tdo, int &relBCID) const
bool	timeToTdoSTGC (const NswCalibDbTimeChargeData *tdoPdoData, const float time, const Identifier &chnlId, int &tdo, int &relBCID) const
float	applyT0Calibration (const EventContext &ctx, const Identifier &id, float time) const
StatusCode	initializeGasProperties ()
bool	localStripPosition (const Identifier &id, Amg::Vector2D &locPos) const

Private Attributes
ServiceHandle< Muon::IMuonIdHelperSvc >	m_idHelperSvc {this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"}
SG::ReadCondHandleKey< AtlasFieldCacheCondObj >	m_fieldCondObjInputKey {this, "AtlasFieldCacheCondObj", "fieldCondObj"}
SG::ReadCondHandleKey< MuonGM::MuonDetectorManager >	m_muDetMgrKey {this, "DetectorManagerKey", "MuonDetectorManager", "Key of input MuonDetectorManager condition data"}
SG::ReadCondHandleKey< NswCalibDbTimeChargeData >	m_condTdoPdoKey {this, "condTdoPdoKey", "NswCalibDbTimeChargeData", "Key of NswCalibDbTimeChargeData object containing calibration data (TDO and PDO)"}
SG::ReadCondHandleKey< NswT0Data >	m_condT0Key {this, "condT0Key", "NswT0Data", "Key of NswT0Data containing the t0 calibration data"}
Gaudi::Property< bool >	m_isData {this, "isData", false, "Processing data"}
Gaudi::Property< bool >	m_CalibDriftVelocityFromData {this, "calibrateDriftVelocityFromData", false, "calibrateDriftVelocityFromData"}
SG::ReadCondHandleKey< Muon::mmCTPClusterCalibData >	m_ctpClusterCalibKey {this, "CTPClusterCalibKey", "mmCTPClusterCalibData", "Key of the CTP cluster calibration corrections"}
Gaudi::Property< double >	m_vDrift {this, "DriftVelocity",0.047, "Drift velocity"}
Gaudi::Property< double >	m_timeRes {this, "TimeResolution", 25., "Time resolution"}
Gaudi::Property< double >	m_longDiff {this, "longDiff", 0.019}
Gaudi::Property< double >	m_transDiff {this, "transDiff", 0.036}
Gaudi::Property< double >	m_ionUncertainty {this,"ionUncertainty", 4.0}
Gaudi::Property< float >	m_mmPeakTime {this, "mmPeakTime", 200.}
Gaudi::Property< float >	m_stgcPeakTime {this, "sTgcPeakTime", 0.}
Gaudi::Property< std::string >	m_gasMixture {this, "GasMixture", "ArCo2_937"}
Gaudi::Property< float >	m_mmLatencyMC {this,"mmLatencyMC",25}
Gaudi::Property< float >	m_mmLatencyData {this,"mmLatencyData",0}
Gaudi::Property< float >	m_stgcLatencyMC {this,"stgcLatencyMC",-50}
Gaudi::Property< float >	m_stgcLatencyData {this,"stgcLatencyData",-50}
Gaudi::Property< bool >	m_applyMmT0Calib {this, "applyMmT0Calib", false, "apply the MM t0 calibration"}
Gaudi::Property< bool >	m_applysTgcT0Calib {this, "applysTgcT0Calib", false, "apply the sTGC t0 calibration"}
Gaudi::Property< bool >	m_applyMmBFieldCalib {this, "applyMmBFieldCalib", true, "apply the MM BField correction in reconstruction"}
Gaudi::Property< float >	m_mmT0TargetValue {this, "mmT0TargetValue", 50.0, "target mean value for the MM t0 calibration"}
Gaudi::Property< float >	m_stgcT0TargetValue {this,"stgcT0TargetValue", 0.0 ,"target mean value for the sTGC t0 calibration"}
double	m_interactionDensitySigma {0.0F}
double	m_interactionDensityMean {0.0F}
angleFunction	m_lorentzAngleFunction {NSWCalib::MicroMegaGas::dummy_func()}

Detailed Description

Definition at line 26 of file NSWCalibTool.h.

Member Typedef Documentation

angleFunction

using Muon::NSWCalibTool::angleFunction = NSWCalib::MicroMegaGas::angleFunction

private

Definition at line 116 of file NSWCalibTool.h.

TimeCalibConst

using Muon::NSWCalibTool::TimeCalibConst = NswCalibDbTimeChargeData::CalibConstants

Definition at line 34 of file NSWCalibTool.h.

TimeCalibType

using Muon::NSWCalibTool::TimeCalibType = NswCalibDbTimeChargeData::CalibDataType

Definition at line 33 of file NSWCalibTool.h.

Constructor & Destructor Documentation

~NSWCalibTool()

virtual Muon::NSWCalibTool::~NSWCalibTool ( )

virtualdefault

Member Function Documentation

applyT0Calibration()

float Muon::NSWCalibTool::applyT0Calibration ( const EventContext & ctx, const Identifier & id, float time ) const

private

Definition at line 462 of file NSWCalibTool.cxx.

                                                                                                          {
  SG::ReadCondHandle<NswT0Data> readT0{m_condT0Key, ctx};
  if(!readT0.isValid()){
    ATH_MSG_ERROR("Cannot find conditions data container for T0s!");
  }
  float t0 {0};
  bool isGood = readT0->getT0(id, t0);
  if(!isGood || t0==0){
    ATH_MSG_DEBUG("failed to retrieve good t0 from database, skipping t0 calibration");
    return time;
  } else {
    float targetT0 = (m_idHelperSvc->isMM(id) ? m_mmT0TargetValue  : m_stgcT0TargetValue);
    float newTime = time + (targetT0 - t0);
    ATH_MSG_DEBUG("doing T0 calibration for RDO " << m_idHelperSvc->toString(id) << " time " << time <<" t0 from  database " <<  t0  << " t0 target " << targetT0  << " new time " <<  newTime);
    return newTime;
  }
}

calibrateClus() [1/2]

StatusCode Muon::NSWCalibTool::calibrateClus ( const EventContext & ctx, const ActsTrk::GeometryContext & gctx, const xAOD::MMCluster & prepData, const Amg::Vector3D & globalPos, std::vector< NSWCalib::CalibratedStrip > & calibClus ) const

override

magnetic field

get the component parallel to to the eta strips (same used in digitization)

swap sign depending on the readout side

loop over prepData strips

Definition at line 138 of file NSWCalibTool.cxx.

                                                                                                  {
 
  double lorentzAngle {0.};
  if(m_applyMmBFieldCalib){
    MagField::AtlasFieldCache fieldCache;
    if (!loadMagneticField(ctx, fieldCache)) return StatusCode::FAILURE;
    Amg::Vector3D magneticField{Amg::Vector3D::Zero()};
    fieldCache.getField(globalPos.data(), magneticField.data());

    double phi    = globalPos.phi();
    double bfield = (magneticField.x()*std::sin(phi)-magneticField.y()*std::cos(phi))*1000.;

    int gasGap = m_idHelperSvc->mmIdHelper().gasGap(prepData.identify());
    bool changeSign = ( globalPos.z() < 0. ? (gasGap==1 || gasGap==3) : (gasGap==2 || gasGap==4) );
    if (changeSign) bfield = -bfield;

    lorentzAngle = (bfield>0. ? 1. : -1.)*m_lorentzAngleFunction(std::abs(bfield)) * toRad;
  }

  for (unsigned int i = 0; i < prepData.stripNumbers().size(); ++i){
    Identifier id =  m_idHelperSvc->mmIdHelper().channelID(prepData.identify(), m_idHelperSvc->mmIdHelper().multilayer(prepData.identify()), m_idHelperSvc->mmIdHelper().gasGap(prepData.identify()),prepData.stripNumbers().at(i));
    double time = prepData.stripTimes().at(i);
    double charge = prepData.stripCharges().at(i);
    //Retrieve pointing constraint
    const Amg::Vector3D& globPos{prepData.readoutElement()->localToGlobalTrans(gctx, prepData.layerHash()) * (prepData.localPosition<1>()[0]*Amg::Vector3D::UnitX())};
    NSWCalib::CalibratedStrip calibStrip;
    ATH_CHECK(calibrateStrip(ctx, id, time, charge, (globPos.theta() / toRad) , lorentzAngle, calibStrip));
 
    calibClus.push_back(std::move(calibStrip));
  }
  return StatusCode::SUCCESS;
}

calibrateClus() [2/2]

StatusCode Muon::NSWCalibTool::calibrateClus ( const EventContext & ctx, const Muon::MMPrepData * prepData, const Amg::Vector3D & globalPos, std::vector< NSWCalib::CalibratedStrip > & calibClus ) const

override

magnetic field

get the component parallel to to the eta strips (same used in digitization)

swap sign depending on the readout side

loop over prepData strips

Definition at line 99 of file NSWCalibTool.cxx.

                                                                                                                                                                                     {
 
  double lorentzAngle {0.};
  if(m_applyMmBFieldCalib){
    MagField::AtlasFieldCache fieldCache;
    if (!loadMagneticField(ctx, fieldCache)) return StatusCode::FAILURE;
    Amg::Vector3D magneticField{Amg::Vector3D::Zero()};
    fieldCache.getField(globalPos.data(), magneticField.data());

    double phi    = globalPos.phi();
    double bfield = (magneticField.x()*std::sin(phi)-magneticField.y()*std::cos(phi))*1000.;

    int gasGap = m_idHelperSvc->mmIdHelper().gasGap(prepData->identify());
    bool changeSign = ( globalPos.z() < 0. ? (gasGap==1 || gasGap==3) : (gasGap==2 || gasGap==4) );
    if (changeSign) bfield = -bfield;

    lorentzAngle = (bfield>0. ? 1. : -1.)*m_lorentzAngleFunction(std::abs(bfield)) * toRad;
  }

  for (unsigned int i = 0; i < prepData->stripNumbers().size(); ++i){
    Identifier id = prepData->rdoList().at(i);
    double time = prepData->stripTimes().at(i);
    double charge = prepData->stripCharges().at(i);
    //Retrieve pointing constraint
    const Amg::Vector3D& globPos{prepData->globalPosition()};
    NSWCalib::CalibratedStrip calibStrip;
    ATH_CHECK(calibrateStrip(ctx, id, time, charge, (globPos.theta() / toRad) , lorentzAngle, calibStrip));
 
    calibClus.push_back(std::move(calibStrip));
  }
  return StatusCode::SUCCESS;
}

calibrateStrip() [1/3]

StatusCode Muon::NSWCalibTool::calibrateStrip ( const EventContext & ctx, const Identifier & id, const double time, const double charge, const double theta, const double lorentzAngle, NSWCalib::CalibratedStrip & calibStrip ) const

override

transversal and longitudinal components of the resolution

Definition at line 182 of file NSWCalibTool.cxx.

                                                                                                                                                                                                                           {
 
 
  //get local positon
  Amg::Vector2D locPos{Amg::Vector2D::Zero()};
  if(!localStripPosition(id,locPos)) {
    ATH_MSG_WARNING(__FILE__<<":"<<__LINE__<<" Failed to retrieve local strip position "<<m_idHelperSvc->toString(id));
    return StatusCode::FAILURE;
  }
  
  calibStrip.identifier = id;
  calibStrip.charge = charge;
  calibStrip.time = time;
 
  //retrieve identifier for the gas gap, not necessarily for the channel
  //There is no pcb segmentation for these corrections, stored with pcb = 1 as default 
  Identifier gasGapId = m_idHelperSvc->mmIdHelper().channelID(id,                                                          m_idHelperSvc->mmIdHelper().multilayer(id),
m_idHelperSvc->mmIdHelper().gasGap(id), 1);
 
  double vDrift = m_vDrift; //nominal value from Garfield simulation  
 
  if(m_CalibDriftVelocityFromData){
     vDrift = getCTPClusterCalibData(ctx)->getCTPCorrectedDriftVelocity(gasGapId, theta);
 
     //Calculate the new half max possible time based on the new drift velocity
     float max_half_drifttime = (vDrift != 0 ) ? 2.5/vDrift : 50.;
 
     //Shift the mean of the time to account for different values of drift velocities
     calibStrip.time = time + (max_half_drifttime - m_mmT0TargetValue);
     ATH_MSG_VERBOSE( "Original drift time: " << time << " new max half drift time: " << max_half_drifttime <<  " new time: " << calibStrip.time << " targett0 " << m_mmT0TargetValue );
  }
 
 
  double vDriftCorrected = vDrift * std::cos(lorentzAngle);
 
  calibStrip.distDrift = vDriftCorrected * calibStrip.time;

  calibStrip.resTransDistDrift = pitchErr + std::pow(m_transDiff * calibStrip.distDrift, 2);
  calibStrip.resLongDistDrift = std::pow(m_ionUncertainty * vDriftCorrected, 2)
    + std::pow(m_longDiff * calibStrip.distDrift, 2);
  calibStrip.dx = std::sin(lorentzAngle) * calibStrip.time * vDrift;  
  calibStrip.locPos = Amg::Vector2D(locPos.x() + calibStrip.dx, locPos.y()); 
  return StatusCode::SUCCESS;
}

calibrateStrip() [2/3]

StatusCode Muon::NSWCalibTool::calibrateStrip ( const EventContext & ctx, const Muon::MM_RawData * mmRawData, NSWCalib::CalibratedStrip & calibStrip ) const

override

Definition at line 229 of file NSWCalibTool.cxx.

                                                                                                                                               {  
 
  const Identifier rdoId = mmRawData->identify();
  //get local postion
  Amg::Vector2D locPos{0,0};
  if(!localStripPosition(rdoId,locPos)) {
    ATH_MSG_WARNING(__FILE__<<":"<<__LINE__<<" Failed to retrieve local strip position "<<m_idHelperSvc->toString(rdoId));
    return StatusCode::FAILURE;
  }
 
  // MuonDetectorManager from the conditions store
  SG::ReadCondHandle<MuonGM::MuonDetectorManager> muDetMgrHandle{m_muDetMgrKey, ctx};
  const MuonGM::MuonDetectorManager* muDetMgr = muDetMgrHandle.cptr();
 
  //get globalPos
  Amg::Vector3D globalPos{Amg::Vector3D::Zero()};
  const MuonGM::MMReadoutElement* detEl = muDetMgr->getMMReadoutElement(rdoId);
  detEl->stripGlobalPosition(rdoId,globalPos);
 
  // RDO has values in counts for both simulation and data
  float time{-FLT_MAX}, charge{-FLT_MAX};
  tdoToTime  (ctx, mmRawData->timeAndChargeInCounts(), mmRawData->time  (), rdoId, time  , mmRawData->relBcid()); 
  pdoToCharge(ctx, mmRawData->timeAndChargeInCounts(), mmRawData->charge(), rdoId, charge                      );
 
  calibStrip.charge     = charge;
  // historically the peak time is included in the time determined by the MM digitization and therefore added back in the tdoToTime function
  // in order to not break the RDO to digit conversion needed for the trigger and the overlay
  calibStrip.time       = time - globalPos.norm() * reciprocalSpeedOfLight - mmPeakTime();
  // applying T0 calibration, cannot be done inside the the tdo to time function since the tof correction was included when deriving the calibration constants
  if(m_applyMmT0Calib){
    calibStrip.time = applyT0Calibration(ctx, rdoId, calibStrip.time);
  }
 
  calibStrip.identifier = rdoId;
 
  ATH_MSG_DEBUG("Calibrating RDO " << m_idHelperSvc->toString(rdoId) << "with pdo: " << mmRawData->charge() << " tdo: "<< mmRawData->time() << " relBCID "<< mmRawData->relBcid() << " charge and time in counts  " <<
                         mmRawData->timeAndChargeInCounts() << " isData "<< m_isData  << " to charge: " << calibStrip.charge << " electrons  time after corrections " << calibStrip.time << " ns  time before corrections "<< time << "ns");
 
 
  //get stripWidth
  detEl->getDesign(rdoId)->channelWidth(); // positon is not used for strip width 
 
  calibStrip.distDrift = m_vDrift * calibStrip.time;
  calibStrip.resTransDistDrift = pitchErr + std::pow(m_transDiff * calibStrip.distDrift, 2);
  calibStrip.resLongDistDrift = std::pow(m_ionUncertainty * m_vDrift, 2)
                              + std::pow(m_longDiff * calibStrip.distDrift, 2);
 
  calibStrip.locPos = locPos;
 
  return StatusCode::SUCCESS;
}

calibrateStrip() [3/3]

StatusCode Muon::NSWCalibTool::calibrateStrip ( const EventContext & ctx, const Muon::STGC_RawData * sTGCRawData, NSWCalib::CalibratedStrip & calibStrip ) const

override

Definition at line 281 of file NSWCalibTool.cxx.

                                                                                                                                                   {
 
  Identifier rdoId = sTGCRawData->identify();
  SG::ReadCondHandle<MuonGM::MuonDetectorManager> muDetMgrHandle{m_muDetMgrKey, ctx};
  const MuonGM::MuonDetectorManager* muDetMgr = muDetMgrHandle.cptr();
 
  //get globalPos
  Amg::Vector3D globalPos{Amg::Vector3D::Zero()};
  const MuonGM::sTgcReadoutElement* detEl = muDetMgr->getsTgcReadoutElement(rdoId);
  detEl->stripGlobalPosition(rdoId,globalPos);
  
  //get local postion
  Amg::Vector2D locPos{Amg::Vector2D::Zero()};
  if(!localStripPosition(rdoId,locPos)) {
    ATH_MSG_WARNING(__FILE__<<":"<<__LINE__<<" Failed to retrieve local strip position "<<m_idHelperSvc->toString(rdoId));
    return StatusCode::FAILURE;
  }
 
  // RDO has values in counts for both simulation and data
  float time{-FLT_MAX}, charge{-FLT_MAX};
  tdoToTime  (ctx, sTGCRawData->timeAndChargeInCounts(), sTGCRawData->time  (), rdoId, time  , sTGCRawData->bcTag()); 
  pdoToCharge(ctx, sTGCRawData->timeAndChargeInCounts(), sTGCRawData->charge(), rdoId, charge                      );
  if(sTGCRawData->timeAndChargeInCounts()){
    calibStrip.charge     = charge  * sTGC_pCPerfC;
  } else {
    calibStrip.charge     = charge;
  }
  calibStrip.time       = time - stgcPeakTime();
 
  if(m_applysTgcT0Calib){
    calibStrip.time = applyT0Calibration(ctx, rdoId, calibStrip.time);
  }
 
  calibStrip.identifier = rdoId;
  calibStrip.locPos = locPos;
  return StatusCode::SUCCESS;
  
}

chargeToPdo()

bool Muon::NSWCalibTool::chargeToPdo ( const EventContext & ctx, const float charge, const Identifier & chnlId, int & pdo ) const

override

Definition at line 354 of file NSWCalibTool.cxx.

                                                                                                                   {
  const NswCalibDbTimeChargeData* tdoPdoData = getCalibData(ctx);
  if (!tdoPdoData) {
    pdo = 0;
    return false;  
  }
  const TimeCalibConst* calib_ptr = tdoPdoData->getCalibForChannel(TimeCalibType::PDO, chnlId);
  if (!calib_ptr) {
    pdo = 0;
    return false; 
  }
  const TimeCalibConst& calib{*calib_ptr};
  float c = charge;
  if     (m_idHelperSvc->isMM  (chnlId)) c /= MM_electronsPerfC;
  else if(m_idHelperSvc->issTgc(chnlId)) c *= sTGC_pCPerfC;
  else {
    pdo = 0;
    return false;
  }
  pdo = c * calib.slope + calib.intercept;
  return true;
}

distToTime()

StatusCode Muon::NSWCalibTool::distToTime ( const EventContext & ctx, const Muon::MMPrepData * prepData, const Amg::Vector3D & globalPos, const std::vector< double > & driftDistances, std::vector< double > & driftTimes ) const

override

retrieve the magnetic field

get the component parallel to to the eta strips (same used in digitization)

swap sign depending on the readout side

loop over drift distances

Definition at line 328 of file NSWCalibTool.cxx.

                                                                                                                                                                                                           {
  MagField::AtlasFieldCache fieldCache;
  if (!loadMagneticField(ctx, fieldCache)) return StatusCode::FAILURE;  
  Amg::Vector3D magneticField{Amg::Vector3D::Zero()};
  fieldCache.getField(globalPos.data(), magneticField.data());

  const double phi    = globalPos.phi();
  double bfield = (magneticField.x()*std::sin(phi)-magneticField.y()*std::cos(phi))*1000.;

  int gasGap = m_idHelperSvc->mmIdHelper().gasGap(prepData->identify());
  bool changeSign = ( globalPos.z() < 0. ? (gasGap==1 || gasGap==3) : (gasGap==2 || gasGap==4) );
  if (changeSign) bfield = -bfield;
  double cos2_lorentzAngle = std::pow(std::cos ( (bfield>0. ? 1. : -1.)*m_lorentzAngleFunction(std::abs(bfield)) * toRad), 2);
  for (const double dist : driftDistances){
    double time = dist / (m_vDrift*cos2_lorentzAngle);
    driftTimes.push_back(time);
  }
  return StatusCode::SUCCESS;
 
}

getCalibData()

const NswCalibDbTimeChargeData * Muon::NSWCalibTool::getCalibData ( const EventContext & ctx ) const

private

Definition at line 78 of file NSWCalibTool.cxx.

                                                                                            {
  // set up pointer to conditions object
  SG::ReadCondHandle<NswCalibDbTimeChargeData> readTdoPdo{m_condTdoPdoKey, ctx};
  if(!readTdoPdo.isValid()){
    ATH_MSG_ERROR("Cannot find conditions data container for TDOs and PDOs!");
    return nullptr;
  } 
  return readTdoPdo.cptr();
}

getCTPClusterCalibData()

const Muon::mmCTPClusterCalibData * Muon::NSWCalibTool::getCTPClusterCalibData ( const EventContext & ctx ) const

private

Definition at line 88 of file NSWCalibTool.cxx.

                                                                                                       {
  //Can we not get this somewhere above? Can this not be read just once? per run?
  SG::ReadCondHandle<Muon::mmCTPClusterCalibData> ctpClusterCalibDB{m_ctpClusterCalibKey, ctx};
  if (!ctpClusterCalibDB.isValid()) {
      ATH_MSG_FATAL("Failed to retrieve the parameterized errors "<<ctpClusterCalibDB.fullKey());
      return nullptr;
  }
  return ctpClusterCalibDB.cptr();
}

initialize()

StatusCode Muon::NSWCalibTool::initialize ( )

overridevirtual

Definition at line 49 of file NSWCalibTool.cxx.

{
  ATH_MSG_DEBUG("In initialize()");
  ATH_CHECK(m_idHelperSvc.retrieve());
  ATH_CHECK(m_condTdoPdoKey.initialize());
  ATH_CHECK(m_condT0Key.initialize(m_applyMmT0Calib || m_applysTgcT0Calib));
  ATH_CHECK(m_fieldCondObjInputKey.initialize());
  ATH_CHECK(m_muDetMgrKey.initialize());
  ATH_CHECK(initializeGasProperties());
  ATH_CHECK(m_ctpClusterCalibKey.initialize(m_CalibDriftVelocityFromData));  
  ATH_CHECK(initializeGasProperties());
  return StatusCode::SUCCESS;
}

initializeGasProperties()

StatusCode Muon::NSWCalibTool::initializeGasProperties ( )

private

Definition at line 63 of file NSWCalibTool.cxx.

                                                     {
  if (!map_vDrift.count(m_gasMixture)) {
    ATH_MSG_FATAL("Configured Micromegas with unkown gas mixture: " << m_gasMixture);
    return StatusCode::FAILURE;
  }
 
  m_vDrift = map_vDrift.find(m_gasMixture)->second;
  m_transDiff = map_transDiff.find(m_gasMixture)->second;
  m_longDiff = map_longDiff.find(m_gasMixture)->second;
  m_interactionDensitySigma = map_interactionDensitySigma.find(m_gasMixture)->second;
  m_interactionDensityMean =  map_interactionDensityMean.find(m_gasMixture)->second;
  m_lorentzAngleFunction =  map_lorentzAngleFunctionPars.find(m_gasMixture)->second;
  return StatusCode::SUCCESS;
}

loadMagneticField()

bool Muon::NSWCalibTool::loadMagneticField ( const EventContext & ctx, MagField::AtlasFieldCache & fieldCache ) const

private

Definition at line 319 of file NSWCalibTool.cxx.

                                                                                                           {
  SG::ReadCondHandle<AtlasFieldCacheCondObj> readHandle{m_fieldCondObjInputKey, ctx};
  if (!readHandle.isValid()) {
      ATH_MSG_ERROR("doDigitization: Failed to retrieve AtlasFieldCacheCondObj with key " << m_fieldCondObjInputKey.key());
      return false;
  }
  readHandle.cptr()->getInitializedCache(fieldCache);
  return true;
}

localStripPosition()

bool Muon::NSWCalibTool::localStripPosition ( const Identifier & id, Amg::Vector2D & locPos ) const

private

Definition at line 522 of file NSWCalibTool.cxx.

                                                                                         {
  // MuonDetectorManager from the conditions store
  SG::ReadCondHandle<MuonGM::MuonDetectorManager> muDetMgrHandle{m_muDetMgrKey};
  const MuonGM::MuonDetectorManager* muDetMgr = muDetMgrHandle.cptr();
  if(m_idHelperSvc->isMM(id)){
    const MuonGM::MMReadoutElement* detEl = muDetMgr->getMMReadoutElement(id);
    return detEl->stripPosition(id,locPos);
 
  } else if(m_idHelperSvc->issTgc(id)){
    const MuonGM::sTgcReadoutElement* detEl = muDetMgr->getsTgcReadoutElement(id);
    return detEl->stripPosition(id,locPos);
 
  } else {
    return false;
  }
}

mmGasProperties()

NSWCalib::MicroMegaGas Muon::NSWCalibTool::mmGasProperties ( ) const

override

Definition at line 510 of file NSWCalibTool.cxx.

                                                              {
  NSWCalib::MicroMegaGas properties{};
  properties.driftVelocity  = m_vDrift;
  properties.longitudinalDiffusionSigma = m_longDiff;
  properties.transverseDiffusionSigma = m_transDiff;
  properties.interactionDensityMean = m_interactionDensityMean;
  properties.interactionDensitySigma = m_interactionDensitySigma;
  properties.lorentzAngleFunction = m_lorentzAngleFunction;
  return properties;
}

mmPeakTime()

float Muon::NSWCalibTool::mmPeakTime ( ) const

inlineoverride

Definition at line 59 of file NSWCalibTool.h.

{return m_mmPeakTime;  }

pdoToCharge()

bool Muon::NSWCalibTool::pdoToCharge ( const EventContext & ctx, const bool inCounts, const int pdo, const Identifier & chnlId, float & charge ) const

override

Definition at line 378 of file NSWCalibTool.cxx.

                                                                                                                                        {  
  if(!inCounts){
    charge = pdo;
    return true;
  }
  const NswCalibDbTimeChargeData* tdoPdoData = getCalibData(ctx);
  if (!tdoPdoData) {
    charge =0.;
    return false;  
  }
  const TimeCalibConst* calib_ptr = tdoPdoData->getCalibForChannel(TimeCalibType::PDO, chnlId);
  if (!calib_ptr) {
    charge = 0.;
    return false; 
  }
  const TimeCalibConst& calib{*calib_ptr};
  charge = (pdo-calib.intercept)/calib.slope;
  if     (m_idHelperSvc->isMM  (chnlId)) charge *= MM_electronsPerfC;
  else if(m_idHelperSvc->issTgc(chnlId)) charge /= sTGC_pCPerfC;
  else return false;
  return true;
}

stgcPeakTime()

float Muon::NSWCalibTool::stgcPeakTime ( ) const

inlineoverride

Definition at line 60 of file NSWCalibTool.h.

{return m_stgcPeakTime;}

tdoToTime()

bool Muon::NSWCalibTool::tdoToTime ( const EventContext & ctx, const bool inCounts, const int tdo, const Identifier & chnlId, float & time, const int relBCID ) const

override

Definition at line 482 of file NSWCalibTool.cxx.

                                                                                                                                                       {
  if(!inCounts){
    time = tdo;
    return true;
  }
  const NswCalibDbTimeChargeData* tdoPdoData = getCalibData(ctx);
  if (!tdoPdoData) {
    time = 0.;
    return false;  
  }
  const TimeCalibConst* calib_ptr = tdoPdoData->getCalibForChannel(TimeCalibType::TDO, chnlId);
  if (!calib_ptr){
     time = 0.;
     return false;
  } 
  const TimeCalibConst& calib {*calib_ptr};
  //this shift of 25ns is necessary to align the time of the signal with the way the VMM determines the time
  //(relBCID 0 corresponds to -37.5 ns to - 12.5 ns)
  //Eventually it should go into the conditions db since it is probably not the same for MC and Data
  //but for now it is kept like it is. pscholer 8th of June 2022
  float mmLatency   = (m_isData? m_mmLatencyData   : m_mmLatencyMC  );
  float stgcLatency = (m_isData? m_stgcLatencyData : m_stgcLatencyMC);
 
  const float peakTime  = m_idHelperSvc->isMM(chnlId) ? mmPeakTime() + mmLatency : stgcPeakTime() + stgcLatency; 
  time = relBCID*25. - (tdo-calib.intercept)/calib.slope + peakTime;
  return true;
}

timeToTdo()

bool Muon::NSWCalibTool::timeToTdo ( const EventContext & ctx, const float time, const Identifier & chnlId, int & tdo, int & relBCID ) const

override

Definition at line 402 of file NSWCalibTool.cxx.

                                                                                                                             {
  const NswCalibDbTimeChargeData* tdoPdoData = getCalibData(ctx);
  if (!tdoPdoData) return false;
  if     (m_idHelperSvc->isMM  (chnlId)) return timeToTdoMM  (tdoPdoData, time, chnlId, tdo, relBCID);
  else if(m_idHelperSvc->issTgc(chnlId)) return timeToTdoSTGC(tdoPdoData, time, chnlId, tdo, relBCID);
  return false;
}

timeToTdoMM()

bool Muon::NSWCalibTool::timeToTdoMM ( const NswCalibDbTimeChargeData * tdoPdoData, const float time, const Identifier & chnlId, int & tdo, int & relBCID ) const

private

Definition at line 411 of file NSWCalibTool.cxx.

                                                                                                                                                  {
  const float t = time - m_mmPeakTime - m_mmLatencyMC; // subtract peaking time first! This is not supossed to run on data ever only needed for the RDO->Digit step
  const TimeCalibConst* calib_ptr = tdoPdoData->getCalibForChannel(TimeCalibType::TDO, chnlId);
  if (!calib_ptr) {
    tdo = relBCID = 0;
    return false;
  }
  const TimeCalibConst& calib{*calib_ptr};
  float tdoTime = -999.9;
  constexpr float lowerBound = Muon::MM_RawData::s_lowerTimeBound;
  for(int i_relBCID=0; i_relBCID<Muon::MM_RawData::s_BCWindow; i_relBCID++){
    if(t >= lowerBound+i_relBCID*25 && t < (lowerBound+25)+i_relBCID*25){
      tdoTime = i_relBCID*25 - t;
      relBCID = i_relBCID;
      break;
    }
  }
  if(tdoTime < lowerBound) {
    tdo = relBCID = 0;
    return false;
  }
  tdo = tdoTime*calib.slope + calib.intercept;
  return true;
}

timeToTdoSTGC()

bool Muon::NSWCalibTool::timeToTdoSTGC ( const NswCalibDbTimeChargeData * tdoPdoData, const float time, const Identifier & chnlId, int & tdo, int & relBCID ) const

private

Definition at line 437 of file NSWCalibTool.cxx.

                                                                                                                                                    {
  const float t = time - m_stgcPeakTime - m_stgcLatencyMC; // subtract peaking time and latency first! This is not supossed to run on data ever only needed for the RDO->Digit step
  const TimeCalibConst* calib_ptr = tdoPdoData->getCalibForChannel(TimeCalibType::TDO, chnlId);
  if (!calib_ptr){
    tdo = relBCID = 0;
    return false;
  }
  const TimeCalibConst& calib = {*calib_ptr};
  float tdoTime = -999.9;
  const float lowerBound = Muon::STGC_RawData::s_lowerTimeBound - m_stgcLatencyMC; // this is not supossed to run on data ever, only needed for the RDO->Digit step
  for(int i_relBCID=0; i_relBCID<Muon::STGC_RawData::s_BCWindow; ++i_relBCID){
    if(t >= lowerBound+i_relBCID*25 && t < (lowerBound+25)+i_relBCID*25){
      tdoTime = i_relBCID*25 - t;
      relBCID = i_relBCID;
      break;
    }
  }
  if(tdoTime < lowerBound) {
    tdo = relBCID = 0;
    return false;
  }
  tdo = tdoTime*calib.slope + calib.intercept;
  return true;
}

Member Data Documentation

m_applyMmBFieldCalib

Gaudi::Property<bool> Muon::NSWCalibTool::m_applyMmBFieldCalib {this, "applyMmBFieldCalib", true, "apply the MM BField correction in reconstruction"}

private

Definition at line 106 of file NSWCalibTool.h.

{this, "applyMmBFieldCalib", true, "apply the MM BField correction in reconstruction"};

m_applyMmT0Calib

Gaudi::Property<bool> Muon::NSWCalibTool::m_applyMmT0Calib {this, "applyMmT0Calib", false, "apply the MM t0 calibration"}

private

Definition at line 103 of file NSWCalibTool.h.

{this, "applyMmT0Calib", false, "apply the MM t0 calibration"};

m_applysTgcT0Calib

Gaudi::Property<bool> Muon::NSWCalibTool::m_applysTgcT0Calib {this, "applysTgcT0Calib", false, "apply the sTGC t0 calibration"}

private

Definition at line 104 of file NSWCalibTool.h.

{this, "applysTgcT0Calib", false, "apply the sTGC t0 calibration"};

m_CalibDriftVelocityFromData

Gaudi::Property<bool> Muon::NSWCalibTool::m_CalibDriftVelocityFromData {this, "calibrateDriftVelocityFromData", false, "calibrateDriftVelocityFromData"}

private

Definition at line 80 of file NSWCalibTool.h.

{this, "calibrateDriftVelocityFromData", false, "calibrateDriftVelocityFromData"};

m_condT0Key

SG::ReadCondHandleKey<NswT0Data> Muon::NSWCalibTool::m_condT0Key {this, "condT0Key", "NswT0Data", "Key of NswT0Data containing the t0 calibration data"}

private

Definition at line 76 of file NSWCalibTool.h.

{this, "condT0Key", "NswT0Data", "Key of NswT0Data containing the t0 calibration data"};

m_condTdoPdoKey

SG::ReadCondHandleKey<NswCalibDbTimeChargeData> Muon::NSWCalibTool::m_condTdoPdoKey {this, "condTdoPdoKey", "NswCalibDbTimeChargeData", "Key of NswCalibDbTimeChargeData object containing calibration data (TDO and PDO)"}

private

Definition at line 75 of file NSWCalibTool.h.

{this, "condTdoPdoKey", "NswCalibDbTimeChargeData", "Key of NswCalibDbTimeChargeData object containing calibration data (TDO and PDO)"};

m_ctpClusterCalibKey

SG::ReadCondHandleKey<Muon::mmCTPClusterCalibData> Muon::NSWCalibTool::m_ctpClusterCalibKey {this, "CTPClusterCalibKey", "mmCTPClusterCalibData", "Key of the CTP cluster calibration corrections"}

private

Definition at line 81 of file NSWCalibTool.h.

{this, "CTPClusterCalibKey", "mmCTPClusterCalibData", "Key of the CTP cluster calibration corrections"};

m_fieldCondObjInputKey

SG::ReadCondHandleKey<AtlasFieldCacheCondObj> Muon::NSWCalibTool::m_fieldCondObjInputKey {this, "AtlasFieldCacheCondObj", "fieldCondObj"}

private

Definition at line 73 of file NSWCalibTool.h.

{this, "AtlasFieldCacheCondObj", "fieldCondObj"};

m_gasMixture

Gaudi::Property<std::string> Muon::NSWCalibTool::m_gasMixture {this, "GasMixture", "ArCo2_937"}

private

Definition at line 92 of file NSWCalibTool.h.

{this, "GasMixture",  "ArCo2_937"};

m_idHelperSvc

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

private

Definition at line 72 of file NSWCalibTool.h.

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

m_interactionDensityMean

double Muon::NSWCalibTool::m_interactionDensityMean {0.0F}

private

Definition at line 114 of file NSWCalibTool.h.

{0.0F};

m_interactionDensitySigma

double Muon::NSWCalibTool::m_interactionDensitySigma {0.0F}

private

Definition at line 113 of file NSWCalibTool.h.

{0.0F};

m_ionUncertainty

Gaudi::Property<double> Muon::NSWCalibTool::m_ionUncertainty {this,"ionUncertainty", 4.0}

private

Definition at line 89 of file NSWCalibTool.h.

{this,"ionUncertainty", 4.0}; //ns

m_isData

Gaudi::Property<bool> Muon::NSWCalibTool::m_isData {this, "isData", false, "Processing data"}

private

Definition at line 78 of file NSWCalibTool.h.

{this, "isData", false, "Processing data"};

m_longDiff

Gaudi::Property<double> Muon::NSWCalibTool::m_longDiff {this, "longDiff", 0.019}

private

Definition at line 87 of file NSWCalibTool.h.

{this, "longDiff", 0.019}; // mm/ mm

m_lorentzAngleFunction

angleFunction Muon::NSWCalibTool::m_lorentzAngleFunction {NSWCalib::MicroMegaGas::dummy_func()}

private

Definition at line 117 of file NSWCalibTool.h.

{NSWCalib::MicroMegaGas::dummy_func()};

m_mmLatencyData

Gaudi::Property<float> Muon::NSWCalibTool::m_mmLatencyData {this,"mmLatencyData",0}

private

Definition at line 97 of file NSWCalibTool.h.

{this,"mmLatencyData",0}; //tuned with 2023 data, should not change anymore. 

m_mmLatencyMC

Gaudi::Property<float> Muon::NSWCalibTool::m_mmLatencyMC {this,"mmLatencyMC",25}

private

Definition at line 96 of file NSWCalibTool.h.

{this,"mmLatencyMC",25};

m_mmPeakTime

Gaudi::Property<float> Muon::NSWCalibTool::m_mmPeakTime {this, "mmPeakTime", 200.}

private

Definition at line 90 of file NSWCalibTool.h.

{this, "mmPeakTime", 200.}; //ns

m_mmT0TargetValue

Gaudi::Property<float> Muon::NSWCalibTool::m_mmT0TargetValue {this, "mmT0TargetValue", 50.0, "target mean value for the MM t0 calibration"}

private

Definition at line 109 of file NSWCalibTool.h.

{this,  "mmT0TargetValue", 50.0, "target mean value for the MM t0 calibration"};

m_muDetMgrKey

SG::ReadCondHandleKey<MuonGM::MuonDetectorManager> Muon::NSWCalibTool::m_muDetMgrKey {this, "DetectorManagerKey", "MuonDetectorManager", "Key of input MuonDetectorManager condition data"}

private

Definition at line 74 of file NSWCalibTool.h.

{this, "DetectorManagerKey", "MuonDetectorManager", "Key of input MuonDetectorManager condition data"}; 

m_stgcLatencyData

Gaudi::Property<float> Muon::NSWCalibTool::m_stgcLatencyData {this,"stgcLatencyData",-50}

private

Definition at line 100 of file NSWCalibTool.h.

{this,"stgcLatencyData",-50}; //this is temporary, need to align with what we find in data

m_stgcLatencyMC

Gaudi::Property<float> Muon::NSWCalibTool::m_stgcLatencyMC {this,"stgcLatencyMC",-50}

private

Definition at line 99 of file NSWCalibTool.h.

{this,"stgcLatencyMC",-50};

m_stgcPeakTime

Gaudi::Property<float> Muon::NSWCalibTool::m_stgcPeakTime {this, "sTgcPeakTime", 0.}

private

Definition at line 91 of file NSWCalibTool.h.

{this, "sTgcPeakTime", 0.}; // ns

m_stgcT0TargetValue

Gaudi::Property<float> Muon::NSWCalibTool::m_stgcT0TargetValue {this,"stgcT0TargetValue", 0.0 ,"target mean value for the sTGC t0 calibration"}

private

Definition at line 110 of file NSWCalibTool.h.

{this,"stgcT0TargetValue", 0.0 ,"target mean value for the  sTGC t0 calibration"};

m_timeRes

Gaudi::Property<double> Muon::NSWCalibTool::m_timeRes {this, "TimeResolution", 25., "Time resolution"}

private

Definition at line 86 of file NSWCalibTool.h.

{this, "TimeResolution", 25., "Time resolution"};

m_transDiff

Gaudi::Property<double> Muon::NSWCalibTool::m_transDiff {this, "transDiff", 0.036}

private

Definition at line 88 of file NSWCalibTool.h.

{this, "transDiff", 0.036};

m_vDrift

Gaudi::Property<double> Muon::NSWCalibTool::m_vDrift {this, "DriftVelocity",0.047, "Drift velocity"}

private

Definition at line 85 of file NSWCalibTool.h.

{this, "DriftVelocity",0.047, "Drift velocity"};

---

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

• NSWCalibTool.h
• NSWCalibTool.cxx