SiLorentzAngleTool Class Reference

#include <SiLorentzAngleTool.h>

Inheritance diagram for SiLorentzAngleTool:

Collaboration diagram for SiLorentzAngleTool:

Public Member Functions
	SiLorentzAngleTool (const std::string &type, const std::string &name, const IInterface *parent)
virtual	~SiLorentzAngleTool ()=default
virtual StatusCode	initialize () override
	Service init. More...
virtual StatusCode	finalize () override
	Service finalize. More...
virtual double	getLorentzShift (const IdentifierHash &elementHash, const EventContext &ctx) const override
	Get the Lorentz shift correction in the local x (phiDist) direction Assumes the center of the detector and is generally cached. More...
virtual double	getLorentzShift (const IdentifierHash &elementHash, const Amg::Vector2D &locPos) const override
	As above, but provide the local position. More...
virtual double	getLorentzShiftEta (const IdentifierHash &elementHash) const override
	Get the Lorentz shift correction in the local y (etaDist) direction Assumes the center of the detector and is generally cached. More...
virtual double	getLorentzShiftEta (const IdentifierHash &elementHash, const Amg::Vector2D &locPos) const override
	As above, but provide the local position. More...
virtual double	getTanLorentzAngle (const IdentifierHash &elementHash, const EventContext &ctx) const override
	Get tan af the Lorentz angle in the local x (phiDist) direction Assumes the center of the detector and is generally cached. More...
virtual double	getTanLorentzAngle (const IdentifierHash &elementHash, const Amg::Vector2D &locPos) const override
	As above, but provide the local position. More...
virtual double	getTanLorentzAngleEta (const IdentifierHash &elementHash) const override
	Get tan af the Lorentz angle in the local y (etaDist) direction Assumes the center of the detector and is generally cached. More...
virtual double	getTanLorentzAngleEta (const IdentifierHash &elementHash, const Amg::Vector2D &locPos) const override
	As above, but provide the local position. More...
virtual double	getBiasVoltage (const IdentifierHash &elementHash) const override
	Get bias voltage. More...
virtual double	getTemperature (const IdentifierHash &elementHash) const override
	Get temperature. More...
virtual double	getDepletionVoltage (const IdentifierHash &elementHash) const override
	Get depletion voltage. More...

Private Types
enum	Variable { LorentzShift, LorentzShiftEta, TanLorentzAngle, TanLorentzAngleEta }

Private Member Functions
double	getValue (const IdentifierHash &elementHash, const Amg::Vector2D &locPos, Variable variable) const
double	getCorrectionFactor () const
Amg::Vector3D	getMagneticField (const Amg::Vector3D &pointvec) const
const SiLorentzAngleCondData *	getCondData (const EventContext &ctx) const
const InDetDD::SiDetectorElement *	getDetectorElement (const IdentifierHash &waferHash) const

Private Attributes
std::string	m_detectorName
double	m_nominalField
bool	m_useMagFieldCache
bool	m_ignoreLocalPos
SG::ReadCondHandleKey< SiLorentzAngleCondData >	m_condData
SG::ReadCondHandleKey< InDetDD::SiDetectorElementCollection >	m_detEleCollKey {this, "DetEleCollKey", "SCT_DetectorElementCollection", "Key of SiDetectorElementCollection for SCT or Pixel"}
SG::ReadCondHandleKey< AtlasFieldCacheCondObj >	m_fieldCondObjInputKey {this, "AtlasFieldCacheCondObj", "fieldCondObj", "Name of the Magnetic Field conditions object key"}

Static Private Attributes
static const double	s_invalidValue {std::numeric_limits<double>::quiet_NaN()}

Detailed Description

Concrete class for tool providing Lorentz angle (and the corresponding correction for the shift of the measurement) for each detector element.

Definition at line 36 of file SiLorentzAngleTool.h.

Member Enumeration Documentation

Variable

enum SiLorentzAngleTool::Variable

private

Enumerator
LorentzShift
LorentzShiftEta
TanLorentzAngle
TanLorentzAngleEta

Definition at line 88 of file SiLorentzAngleTool.h.

{LorentzShift, LorentzShiftEta, TanLorentzAngle, TanLorentzAngleEta};

Constructor & Destructor Documentation

SiLorentzAngleTool()

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

Definition at line 18 of file SiLorentzAngleTool.cxx.

                                                                                                            :
  base_class(type, name, parent),
  m_condData{"SCTSiLorentzAngleCondData"}
{
  declareProperty("IgnoreLocalPos", m_ignoreLocalPos = false, 
                  "Treat methods that take a local position as if one called the methods without a local position");
  // YOU NEED TO USE THE SAME PROPERTIES AS USED IN Pixel/SCTSiLorentzAngleCondAlg!!!
  declareProperty("DetectorName", m_detectorName="Pixel", "Detector name (Pixel, SCT or PLR)");
  declareProperty("NominalField", m_nominalField = 2.0834*Gaudi::Units::tesla);
  declareProperty("UseMagFieldCache", m_useMagFieldCache = true);
  declareProperty("SiLorentzAngleCondData", m_condData, "Key of input SiLorentzAngleCondData");
}

~SiLorentzAngleTool()

virtual SiLorentzAngleTool::~SiLorentzAngleTool ( )

virtualdefault

Member Function Documentation

finalize()

StatusCode SiLorentzAngleTool::finalize ( )

overridevirtual

Service finalize.

Definition at line 53 of file SiLorentzAngleTool.cxx.

                                        {
  return StatusCode::SUCCESS;
}

getBiasVoltage()

double SiLorentzAngleTool::getBiasVoltage ( const IdentifierHash &  elementHash ) const

overridevirtual

Get bias voltage.

Definition at line 113 of file SiLorentzAngleTool.cxx.

                                                                                 {
  const SiLorentzAngleCondData* condData{getCondData(Gaudi::Hive::currentContext())};
  if (condData) {
    return condData->getBiasVoltage(elementHash);
  }
  return s_invalidValue;
}

getCondData()

const SiLorentzAngleCondData * SiLorentzAngleTool::getCondData ( const EventContext &  ctx ) const

private

Definition at line 239 of file SiLorentzAngleTool.cxx.

                                                                                           {
  SG::ReadCondHandle<SiLorentzAngleCondData> handle{m_condData, ctx};
  if (handle.isValid()) {
    const SiLorentzAngleCondData* data{*handle};
    return data;
  }
  ATH_MSG_WARNING(m_condData.key() << " cannot be retrieved.");
  return nullptr;
}

getCorrectionFactor()

double SiLorentzAngleTool::getCorrectionFactor ( ) const

private

Definition at line 201 of file SiLorentzAngleTool.cxx.

{
  const SiLorentzAngleCondData* condData{getCondData(Gaudi::Hive::currentContext())};
  if (condData) {
    return condData->getCorrectionFactor();
  }
  return s_invalidValue;
}

getDepletionVoltage()

double SiLorentzAngleTool::getDepletionVoltage ( const IdentifierHash &  elementHash ) const

overridevirtual

Get depletion voltage.

Definition at line 129 of file SiLorentzAngleTool.cxx.

                                                                                      {
  const SiLorentzAngleCondData* condData{getCondData(Gaudi::Hive::currentContext())};
  if (condData) {
    return condData->getDepletionVoltage(elementHash);
  }
  return s_invalidValue;
}

getDetectorElement()

const InDetDD::SiDetectorElement * SiLorentzAngleTool::getDetectorElement ( const IdentifierHash &  waferHash ) const

private

Definition at line 249 of file SiLorentzAngleTool.cxx.

                                                                                                            {
  SG::ReadCondHandle<InDetDD::SiDetectorElementCollection> handle{m_detEleCollKey};
  const InDetDD::SiDetectorElementCollection* elements{nullptr};
  if (handle.isValid()) elements = *handle;
  if (elements!=nullptr) return elements->getDetectorElement(waferHash);
 
  ATH_MSG_WARNING(m_detEleCollKey.key() << " cannot be retrieved.");
  return nullptr;
}

getLorentzShift() [1/2]

double SiLorentzAngleTool::getLorentzShift ( const IdentifierHash &  elementHash, const Amg::Vector2D &  locPos  ) const

overridevirtual

As above, but provide the local position.

More accurate but slower.

Definition at line 65 of file SiLorentzAngleTool.cxx.

                                                                                                             {
  if (m_ignoreLocalPos) return getLorentzShift(elementHash, Gaudi::Hive::currentContext());
  // The cache is used to store the results. The cache is therefore invalidated if we specify a position.
  return getValue(elementHash, locPos, LorentzShift);
}

getLorentzShift() [2/2]

double SiLorentzAngleTool::getLorentzShift ( const IdentifierHash &  elementHash, const EventContext &  ctx  ) const

overridevirtual

Get the Lorentz shift correction in the local x (phiDist) direction Assumes the center of the detector and is generally cached.

Definition at line 57 of file SiLorentzAngleTool.cxx.

                                                                                                           {
  const SiLorentzAngleCondData* condData{getCondData(ctx)};
  if (condData) {
    return condData->getLorentzShift(elementHash);
  }
  return s_invalidValue;
}

getLorentzShiftEta() [1/2]

double SiLorentzAngleTool::getLorentzShiftEta ( const IdentifierHash &  elementHash ) const

overridevirtual

Get the Lorentz shift correction in the local y (etaDist) direction Assumes the center of the detector and is generally cached.

Definition at line 71 of file SiLorentzAngleTool.cxx.

                                                                                     {
  const SiLorentzAngleCondData* condData{getCondData(Gaudi::Hive::currentContext())};
  if (condData) {
    return condData->getLorentzShiftEta(elementHash);
  }
  return s_invalidValue;
}

getLorentzShiftEta() [2/2]

double SiLorentzAngleTool::getLorentzShiftEta ( const IdentifierHash &  elementHash, const Amg::Vector2D &  locPos  ) const

overridevirtual

As above, but provide the local position.

More accurate but slower.

Definition at line 79 of file SiLorentzAngleTool.cxx.

                                                                                                                {
  if (m_ignoreLocalPos) return getLorentzShiftEta(elementHash);
  // The cache is used to store the results. The cache is therefore invalidated if we specify a position.
  return getValue(elementHash, locPos, LorentzShiftEta);
}

getMagneticField()

Amg::Vector3D SiLorentzAngleTool::getMagneticField ( const Amg::Vector3D &  pointvec ) const

private

Definition at line 210 of file SiLorentzAngleTool.cxx.

                                                                                  {
  // Get the magnetic field.
  bool useMagFieldCache{m_useMagFieldCache};
  MagField::AtlasFieldCache fieldCache;
  if (useMagFieldCache) {
    SG::ReadCondHandle<AtlasFieldCacheCondObj> readHandle{m_fieldCondObjInputKey, Gaudi::Hive::currentContext()};
    const AtlasFieldCacheCondObj* fieldCondObj{*readHandle};
    if (fieldCondObj == nullptr) {
      ATH_MSG_ERROR("SCTSiLorentzAngleCondAlg : Failed to retrieve AtlasFieldCacheCondObj with key " << m_fieldCondObjInputKey.key());
      useMagFieldCache = false;
    } else {
      fieldCondObj->getInitializedCache(fieldCache);
    }
  }
  if (useMagFieldCache) {
    ATH_MSG_VERBOSE("Getting magnetic field from magnetic field service.");
    double field[3];
    double point[3];
    point[0] = pointvec[0];
    point[1] = pointvec[1];
    point[2] = pointvec[2];
    fieldCache.getField(point, field);
    return Amg::Vector3D(field[0], field[1], field[2]);
  } else {
    ATH_MSG_VERBOSE("Using Nominal Field");
    return Amg::Vector3D(0., 0., m_nominalField);
  }
}

getTanLorentzAngle() [1/2]

double SiLorentzAngleTool::getTanLorentzAngle ( const IdentifierHash &  elementHash, const Amg::Vector2D &  locPos  ) const

overridevirtual

As above, but provide the local position.

More accurate but slower.

Definition at line 93 of file SiLorentzAngleTool.cxx.

                                                                                                                {
  if (m_ignoreLocalPos) return getTanLorentzAngle(elementHash, Gaudi::Hive::currentContext());
  // The cache is used to store the results. The cache is therefore invalidated if we specify a position.
  return getValue(elementHash, locPos, TanLorentzAngle);
}

getTanLorentzAngle() [2/2]

double SiLorentzAngleTool::getTanLorentzAngle ( const IdentifierHash &  elementHash, const EventContext &  ctx  ) const

overridevirtual

Get tan af the Lorentz angle in the local x (phiDist) direction Assumes the center of the detector and is generally cached.

Definition at line 85 of file SiLorentzAngleTool.cxx.

                                                                                                              {
  const SiLorentzAngleCondData* condData{getCondData(ctx)};
  if (condData) {
    return condData->getTanLorentzAngle(elementHash);
  }
  return s_invalidValue;
}

getTanLorentzAngleEta() [1/2]

double SiLorentzAngleTool::getTanLorentzAngleEta ( const IdentifierHash &  elementHash ) const

overridevirtual

Get tan af the Lorentz angle in the local y (etaDist) direction Assumes the center of the detector and is generally cached.

Definition at line 99 of file SiLorentzAngleTool.cxx.

                                                                                        {
  const SiLorentzAngleCondData* condData{getCondData(Gaudi::Hive::currentContext())};
  if (condData) {
    return condData->getTanLorentzAngleEta(elementHash);
  }
  return s_invalidValue;
}

getTanLorentzAngleEta() [2/2]

double SiLorentzAngleTool::getTanLorentzAngleEta ( const IdentifierHash &  elementHash, const Amg::Vector2D &  locPos  ) const

overridevirtual

As above, but provide the local position.

More accurate but slower.

Definition at line 107 of file SiLorentzAngleTool.cxx.

                                                                                                                   {
  if (m_ignoreLocalPos) return getTanLorentzAngleEta(elementHash);
  // The cache is used to store the results. The cache is therefore invalidated if we specify a position.
  return getValue(elementHash, locPos, TanLorentzAngleEta);
}

getTemperature()

double SiLorentzAngleTool::getTemperature ( const IdentifierHash &  elementHash ) const

overridevirtual

Get temperature.

Definition at line 121 of file SiLorentzAngleTool.cxx.

                                                                                 {
  const SiLorentzAngleCondData* condData{getCondData(Gaudi::Hive::currentContext())};
  if (condData) {
    return condData->getTemperature(elementHash);
  }
  return s_invalidValue;
}

getValue()

double SiLorentzAngleTool::getValue ( const IdentifierHash &  elementHash, const Amg::Vector2D &  locPos, Variable  variable  ) const

private

Definition at line 137 of file SiLorentzAngleTool.cxx.

                                                                                                                         {
  if (not (variable==TanLorentzAngle or variable==LorentzShift or variable==TanLorentzAngleEta or variable==LorentzShiftEta)) {
    ATH_MSG_WARNING("getValue with Variable=" << variable << " is not available");
    return s_invalidValue;
  }
 
  double temperature{getTemperature(elementHash)};
  double deplVoltage{getDepletionVoltage(elementHash)};
  double biasVoltage{getBiasVoltage(elementHash)};
 
  // Calculate depletion depth. If biasVoltage is less than depletionVoltage
  // the detector is not fully depleted and we need to take this into account.
  // We take absolute values just in case voltages are signed.
  const InDetDD::SiDetectorElement* element{getDetectorElement(elementHash)};
  double depletionDepth{element->thickness()};
  if (deplVoltage==0.0) ATH_MSG_WARNING("Depletion voltage in "<<__FILE__<<" is zero, which might be a bug.");
  if (std::abs(biasVoltage) < std::abs(deplVoltage)) {
    depletionDepth *= sqrt(std::abs(biasVoltage / deplVoltage));
  }
  double meanElectricField{0.};
  if (depletionDepth) { 
    meanElectricField = biasVoltage / depletionDepth;
  }
  double mobility{0.};
  InDet::SiliconProperties siProperties;
  siProperties.setConditions(temperature, meanElectricField);
  mobility = siProperties.signedHallMobility(element->carrierType());
  // Get magnetic field.
  Amg::Vector3D pointvec{element->globalPosition(locPos)};
  Amg::Vector3D magneticField{getMagneticField(pointvec)};
 
  double correctionFactor{getCorrectionFactor()};
 
  // The angles are in the hit frame. This is because that is what is needed by the digization and also
  // gives a more physical sign of the angle (ie dosen't flip sign when the detector is flipped).
  // The hit depth axis is pointing from the readout side to the backside if  m_design->readoutSide() < 0
  // The hit depth axis is pointing from the backside to the readout side if  m_design->readoutSide() > 0
  if (variable==TanLorentzAngle or variable==LorentzShift) {
    double tanLorentzAnglePhi{element->design().readoutSide()*mobility*element->hitDepthDirection()*element->hitPhiDirection()*(element->normal().cross(magneticField)).dot(element->phiAxis())};
    if (variable==TanLorentzAngle) {
      return correctionFactor*tanLorentzAnglePhi;
    }
    // This gives the effective correction in the reconstruction frame hence the extra hitPhiDirection()
    // as the angle above is in the hit frame.
    double lorentzCorrectionPhi{-0.5*element->hitPhiDirection()*tanLorentzAnglePhi*depletionDepth};
    return correctionFactor*lorentzCorrectionPhi;
  }
 
  // The Lorentz eta shift very small and so can be ignored, but we include it for completeness.
  // It is < ~0.1 um in the pixel.
  // In the SCT its largest in the stereo side of the barrel modules where it is about 0.3 micron along the strip. 
  if (variable==TanLorentzAngleEta or variable==LorentzShiftEta) {
    double tanLorentzAngleEta{element->design().readoutSide()*mobility*element->hitDepthDirection()*element->hitEtaDirection()*(element->normal().cross(magneticField)).dot(element->etaAxis())};
    if (variable==TanLorentzAngleEta) {
      return correctionFactor*tanLorentzAngleEta;
    }
    double lorentzCorrectionEta{-0.5*element->hitPhiDirection()*tanLorentzAngleEta*depletionDepth};
    return correctionFactor*lorentzCorrectionEta;
  }
 
  ATH_MSG_WARNING("You should not see this message. Something is wrong in getValue");
  return s_invalidValue;
}

initialize()

StatusCode SiLorentzAngleTool::initialize ( )

overridevirtual

Service init.

Definition at line 31 of file SiLorentzAngleTool.cxx.

                                          { 
 
  ATH_MSG_DEBUG("SiLorentzAngleTool Initialized");
 
  if ((m_detectorName not_eq "Pixel") and (m_detectorName not_eq "SCT") and (m_detectorName not_eq "PLR")) {
    ATH_MSG_FATAL("Invalid detector name: " << m_detectorName << ". Must be Pixel, SCT or PLR.");
    return StatusCode::FAILURE;
  }
 
  // Read Cond Handle
  ATH_CHECK(m_condData.initialize());
  ATH_CHECK(m_detEleCollKey.initialize());
 
  // MagneticFieldCache
  if (not m_useMagFieldCache) {
    ATH_MSG_DEBUG("Not using Magnetic Field cache - Will be using Nominal Field!");
  }
  ATH_CHECK(m_fieldCondObjInputKey.initialize(m_useMagFieldCache));
  
  return StatusCode::SUCCESS;
}

Member Data Documentation

m_condData

SG::ReadCondHandleKey<SiLorentzAngleCondData> SiLorentzAngleTool::m_condData

private

Definition at line 101 of file SiLorentzAngleTool.h.

m_detectorName

std::string SiLorentzAngleTool::m_detectorName

private

Definition at line 97 of file SiLorentzAngleTool.h.

m_detEleCollKey

SG::ReadCondHandleKey<InDetDD::SiDetectorElementCollection> SiLorentzAngleTool::m_detEleCollKey {this, "DetEleCollKey", "SCT_DetectorElementCollection", "Key of SiDetectorElementCollection for SCT or Pixel"}

private

Definition at line 102 of file SiLorentzAngleTool.h.

m_fieldCondObjInputKey

SG::ReadCondHandleKey<AtlasFieldCacheCondObj> SiLorentzAngleTool::m_fieldCondObjInputKey {this, "AtlasFieldCacheCondObj", "fieldCondObj", "Name of the Magnetic Field conditions object key"}

private

Definition at line 103 of file SiLorentzAngleTool.h.

m_ignoreLocalPos

bool SiLorentzAngleTool::m_ignoreLocalPos

private

Definition at line 100 of file SiLorentzAngleTool.h.

m_nominalField

double SiLorentzAngleTool::m_nominalField

private

Definition at line 98 of file SiLorentzAngleTool.h.

m_useMagFieldCache

bool SiLorentzAngleTool::m_useMagFieldCache

private

Definition at line 99 of file SiLorentzAngleTool.h.

s_invalidValue

const double SiLorentzAngleTool::s_invalidValue {std::numeric_limits<double>::quiet_NaN()}

staticprivate

Definition at line 105 of file SiLorentzAngleTool.h.

---

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

• SiLorentzAngleTool.h
• SiLorentzAngleTool.cxx