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 MMPrepData *prepData, const Amg::Vector3D &globalPos, std::vector< NSWCalib::CalibratedStrip > &calibClus) const override
StatusCode	distToTime (const EventContext &ctx, const 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 MM_RawData *mmRawData, NSWCalib::CalibratedStrip &calibStrip) const override
StatusCode	calibrateStrip (const EventContext &ctx, const 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
StatusCode	loadMagneticField (const EventContext &ctx, MagField::AtlasFieldCache &fieldCache) 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 ()
std::optional< Amg::Vector2D >	localStripPosition (const EventContext &ctx, const Identifier &id) const

Private Attributes
ServiceHandle< IMuonIdHelperSvc >	m_idHelperSvc {this, "MuonIdHelperSvc", "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< 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 114 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 458 of file NSWCalibTool.cxx.

                                                                                                          {
  const NswT0Data* readT0{nullptr};
  if(!SG::get(readT0, m_condT0Key, ctx).isSuccess()){
    ATH_MSG_ERROR("Cannot find conditions data container for T0s!");
  }
  std::optional<float> t0 = readT0->getT0(id);
  if(!t0){
    ATH_MSG_DEBUG("failed to retrieve good t0 from database, skipping t0 calibration");
    return time;
  }  
  const auto& 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 116 of file NSWCalibTool.cxx.

                                                                                                  {
 
  double lorentzAngle {0.};
  if(m_applyMmBFieldCalib){
    MagField::AtlasFieldCache fieldCache;
    ATH_CHECK(loadMagneticField(ctx, fieldCache));
    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()->localToGlobalTransform(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 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 77 of file NSWCalibTool.cxx.

                                                                                                                                                                                     {
 
  double lorentzAngle {0.};
  if(m_applyMmBFieldCalib){
    MagField::AtlasFieldCache fieldCache;
    ATH_CHECK(loadMagneticField(ctx, fieldCache));
    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 160 of file NSWCalibTool.cxx.

                                                                                         {
  //get local positon
  auto locPos = localStripPosition(ctx, id);
  if(!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;
 
  const MmIdHelper& idHelper{m_idHelperSvc->mmIdHelper()};
 
  //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 = idHelper.channelID(id,
                                          idHelper.multilayer(id),
                                          idHelper.gasGap(id), 1);
 
  double vDrift = m_vDrift; //nominal value from Garfield simulation  
 
  if(m_CalibDriftVelocityFromData) {
     const MmCTPClusterCalibData* ctpCalibData{nullptr};
     ATH_CHECK(SG::get(ctpCalibData, m_ctpClusterCalibKey, ctx));
     vDrift = ctpCalibData->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 MM_RawData * mmRawData, NSWCalib::CalibratedStrip & calibStrip ) const

override

Hopefully this does not trigger the T0 reference test....

Definition at line 217 of file NSWCalibTool.cxx.

                                                                                         {  
 
  const Identifier& rdoId = mmRawData->identify();
 
  const MuonGM::MuonDetectorManager* muDetMgr{nullptr};
  ATH_CHECK(SG::get(muDetMgr, m_muDetMgrKey, ctx));
 
  //get globalPos
  Amg::Vector3D globalPos{Amg::Vector3D::Zero()};
  const MuonGM::MMReadoutElement* detEl = muDetMgr->getMMReadoutElement(rdoId);
  if (!detEl->stripGlobalPosition(rdoId, globalPos)) {
      ATH_MSG_WARNING(__func__<<"() "<<__LINE__<<" - Failed to fetch global position for "
                    <<m_idHelperSvc->toString(rdoId));
      return StatusCode::FAILURE;
  }
 
  // RDO has values in counts for both simulation and data
  float time{-std::numeric_limits<float>::max()}, 
        charge{-std::numeric_limits<float>::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(__func__<<"() "<<__LINE__<<" - Calibrating RDO " << m_idHelperSvc->toString(rdoId) 
             << " with pdo: " << mmRawData->charge() << ", tdo: "<< mmRawData->time() 
             << ", relBCID "<< mmRawData->relBcid() << ", charge and time in counts: "
             << mmRawData->timeAndChargeInCounts() <<", "<< 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);

  detEl->surface(rdoId).globalToLocal(globalPos, Amg::Vector3D::Zero(), calibStrip.locPos);
 
  return StatusCode::SUCCESS;
}

calibrateStrip() [3/3]

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

override

Hopefully this does not trigger the T0 reference test....

Definition at line 272 of file NSWCalibTool.cxx.

                                                                                         {
 
  const Identifier& rdoId = sTGCRawData->identify();
  const MuonGM::MuonDetectorManager* muDetMgr{nullptr};
  ATH_CHECK(SG::get(muDetMgr, m_muDetMgrKey, ctx));
 
  //get globalPos
  Amg::Vector3D globalPos{Amg::Vector3D::Zero()};
  const MuonGM::sTgcReadoutElement* detEl = muDetMgr->getsTgcReadoutElement(rdoId);
  if (!detEl->stripGlobalPosition(rdoId,globalPos)) {
      ATH_MSG_WARNING(__func__<<"() "<<__LINE__<<" - Failed to retrieve a valid global position for "
                  <<m_idHelperSvc->toString(rdoId));
      return StatusCode::FAILURE;
  }
  // RDO has values in counts for both simulation and data
  float time{-std::numeric_limits<float>::max()}, charge{-std::numeric_limits<float>::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;
  detEl->surface(rdoId).globalToLocal(globalPos, Amg::Vector3D::Zero(), calibStrip.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 346 of file NSWCalibTool.cxx.

                                                                                                                   {
  const NswCalibDbTimeChargeData* tdoPdoData{nullptr};
  if (!SG::get(tdoPdoData, m_condTdoPdoKey, ctx)) {
    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 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 316 of file NSWCalibTool.cxx.

                                                                               {
  MagField::AtlasFieldCache fieldCache;
  ATH_CHECK(loadMagneticField(ctx, fieldCache));
  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;
 
}

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

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

private

Definition at line 310 of file NSWCalibTool.cxx.

                                                                                                                 {
  const AtlasFieldCacheCondObj* condObj{};
  ATH_CHECK(SG::get(condObj, m_fieldCondObjInputKey, ctx));
  condObj->getInitializedCache(fieldCache);
  return StatusCode::SUCCESS;
}

localStripPosition()

std::optional< Amg::Vector2D > Muon::NSWCalibTool::localStripPosition ( const EventContext & ctx, const Identifier & id ) const

private

Definition at line 518 of file NSWCalibTool.cxx.

                                                                                                 {
  
  const MuonGM::MuonDetectorManager* muDetMgr{nullptr};
  if (!SG::get(muDetMgr, m_muDetMgrKey, ctx)) {
    THROW_EXCEPTION("Failed to retrieve the detector manager");
  }
  Amg::Vector2D locPos{Amg::Vector2D::Zero()};
  if(m_idHelperSvc->isMM(id)){
    if (!muDetMgr->getMMReadoutElement(id)->stripPosition(id,locPos)) {
        return std::nullopt;
    }
  } else if(m_idHelperSvc->issTgc(id)){
    if (!muDetMgr->getsTgcReadoutElement(id)->stripPosition(id,locPos)) {
        return std::nullopt;
    }
  } else {
    ATH_MSG_WARNING("Non NSW identifier "<<m_idHelperSvc->toString(id));
    return std::nullopt;
  }
  return locPos;
}

mmGasProperties()

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

override

Definition at line 506 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 370 of file NSWCalibTool.cxx.

                                                     {
  if(!inCounts){
    charge = pdo;
    return true;
  }
  const NswCalibDbTimeChargeData* tdoPdoData{nullptr};
  if (!SG::get(tdoPdoData, m_condTdoPdoKey, ctx)) {
    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 478 of file NSWCalibTool.cxx.

                                                                                                                                                       {
  if(!inCounts){
    time = tdo;
    return true;
  }
  const NswCalibDbTimeChargeData* tdoPdoData{nullptr};
  if (!SG::get(tdoPdoData, m_condTdoPdoKey, ctx)){
    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 398 of file NSWCalibTool.cxx.

                                                                                                                             {
  const NswCalibDbTimeChargeData* tdoPdoData{nullptr};
  if (!SG::get(tdoPdoData, m_condTdoPdoKey, ctx)) 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 407 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 433 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 104 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 101 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 102 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 78 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 74 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 73 of file NSWCalibTool.h.

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

m_ctpClusterCalibKey

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

private

Definition at line 79 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 71 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 90 of file NSWCalibTool.h.

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

m_idHelperSvc

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

private

Definition at line 70 of file NSWCalibTool.h.

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

m_interactionDensityMean

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

private

Definition at line 112 of file NSWCalibTool.h.

{0.0F};

m_interactionDensitySigma

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

private

Definition at line 111 of file NSWCalibTool.h.

{0.0F};

m_ionUncertainty

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

private

Definition at line 87 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 76 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 85 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 115 of file NSWCalibTool.h.

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

m_mmLatencyData

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

private

Definition at line 95 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 94 of file NSWCalibTool.h.

{this,"mmLatencyMC",25};

m_mmPeakTime

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

private

Definition at line 88 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 107 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 72 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 98 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 97 of file NSWCalibTool.h.

{this,"stgcLatencyMC",-50};

m_stgcPeakTime

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

private

Definition at line 89 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 108 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 84 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 86 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 83 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