DTParametrizedDriftAlgo Class Reference

#include <DTParametrizedDriftAlgo.h>

Inheritance diagram for DTParametrizedDriftAlgo:

Public Member Functions
bool	compute (const DTLayer *layer, const DTDigi &digi, LocalPoint &leftPoint, LocalPoint &rightPoint, LocalError &error) const override
bool	compute (const DTLayer *layer, const DTRecHit1D &recHit1D, const float &angle, const GlobalPoint &globPos, DTRecHit1D &newHit1D) const override
bool	compute (const DTLayer *layer, const DTRecHit1D &recHit1D, const float &angle, DTRecHit1D &newHit1D) const override
	DTParametrizedDriftAlgo (const edm::ParameterSet &config)
	Constructor. More...
void	setES (const edm::EventSetup &setup) override
	Pass the Event Setup to the algo at each event. More...
	~DTParametrizedDriftAlgo () override
	Destructor. More...
Public Member Functions inherited from DTRecHitBaseAlgo
	DTRecHitBaseAlgo (const edm::ParameterSet &config)
	Constructor. More...
virtual edm::OwnVector< DTRecHit1DPair >	reconstruct (const DTLayer *layer, const DTLayerId &layerId, const DTDigiCollection::Range &digiRange)
	Build all hits in the range associated to the layerId, at the 1st step. More...
virtual	~DTRecHitBaseAlgo ()
	Destructor. More...

Private Member Functions
virtual bool	compute (const DTLayer *layer, const DTWireId &wireId, const float digiTime, const float &angle, const GlobalPoint &globPos, DTRecHit1D &newHit1D, int step) const
virtual bool	compute (const DTLayer *layer, const DTWireId &wireId, const float digiTime, const float &angle, const GlobalPoint &globPos, LocalPoint &leftPoint, LocalPoint &rightPoint, LocalError &error, int step) const

Private Attributes
const bool	debug
const bool	interpolate
const MagneticField *	magField
const float	maxTime
const float	minTime

Additional Inherited Members
Protected Attributes inherited from DTRecHitBaseAlgo
std::unique_ptr< DTTTrigBaseSync >	theSync

Detailed Description

Concrete implementation of DTRecHitBaseAlgo. Compute drift distance using the CIEMAT (by P.Garcia Abia and J. Puerta) parametrization of the cell behavior obtained with GARFIELD

Author

G. Cerminara - INFN Torino

Definition at line 16 of file DTParametrizedDriftAlgo.h.

Constructor & Destructor Documentation

DTParametrizedDriftAlgo()

DTParametrizedDriftAlgo::DTParametrizedDriftAlgo

(

const edm::ParameterSet &

config

)

Constructor.

Definition at line 27 of file DTParametrizedDriftAlgo.cc.

    : DTRecHitBaseAlgo(config),
      interpolate(config.getParameter<bool>("interpolate")),
      minTime(config.getParameter<double>("minTime")),  // FIXME: Default was -3 ns
      maxTime(config.getParameter<double>("maxTime")),  // FIXME: Default was 415 ns
      // Set verbose output
      debug(config.getUntrackedParameter<bool>("debug", "false")) {}

~DTParametrizedDriftAlgo()

DTParametrizedDriftAlgo::~DTParametrizedDriftAlgo ( )

override

Destructor.

Definition at line 35 of file DTParametrizedDriftAlgo.cc.

{}

Member Function Documentation

compute() [1/5]

bool DTParametrizedDriftAlgo::compute ( const DTLayer *  layer, const DTDigi &  digi, LocalPoint &  leftPoint, LocalPoint &  rightPoint, LocalError &  error  ) const

overridevirtual

First step in computation of Left/Right hits from a Digi. The results are the local position (in DTLayer frame) of the Left and Right hit, and the error (which is common). The center of the wire is assumed as hit coordinate along y. Returns false on failure.

Implements DTRecHitBaseAlgo.

compute() [2/5]

bool DTParametrizedDriftAlgo::compute ( const DTLayer *  layer, const DTRecHit1D &  recHit1D, const float &  angle, const GlobalPoint &  globPos, DTRecHit1D &  newHit1D  ) const

overridevirtual

Third (and final) step in hits position computation. In addition the the angle, also the global position of the hit is given as input. This allows to get the magnetic field at the hit position (and not only that at the center of the wire). Also the position along the wire is available and can be used to correct the drift time for particle TOF and propagation of signal along the wire. NOTE: Only position and error of the new hit are modified

Implements DTRecHitBaseAlgo.

compute() [3/5]

bool DTParametrizedDriftAlgo::compute ( const DTLayer *  layer, const DTRecHit1D &  recHit1D, const float &  angle, DTRecHit1D &  newHit1D  ) const

overridevirtual

Second step. The impact angle is given as input, and it's used to improve the hit position (and relative error). The angle is defined in radians, with respect to the perpendicular to the layer plane. Given the local direction, angle=atan(dir.x()/-dir.z()) . This can be used when a SL segment is built, so the impact angle is known but the position along wire is not. NOTE: Only position and error of the new hit are modified

Implements DTRecHitBaseAlgo.

compute() [4/5]

bool DTParametrizedDriftAlgo::compute ( const DTLayer *  layer, const DTWireId &  wireId, const float  digiTime, const float &  angle, const GlobalPoint &  globPos, DTRecHit1D &  newHit1D, int  step  ) const

privatevirtual

Definition at line 294 of file DTParametrizedDriftAlgo.cc.

                                                      {
  LocalPoint leftPoint;
  LocalPoint rightPoint;
  LocalError error;
 
  if (compute(layer, wireId, digiTime, angle, globPos, leftPoint, rightPoint, error, step)) {
    // Set the position and the error of the rechit which is being updated
    switch (newHit1D.lrSide()) {
      case DTEnums::Left: {
        // Keep the original y position of newHit1D: for step==3, it's the
        // position along the wire. Needed for rotation alignment
        LocalPoint leftPoint3D(leftPoint.x(), newHit1D.localPosition().y(), leftPoint.z());
        newHit1D.setPositionAndError(leftPoint3D, error);
        break;
      }
 
      case DTEnums::Right: {
        // as above: 3d position
        LocalPoint rightPoint3D(rightPoint.x(), newHit1D.localPosition().y(), rightPoint.z());
        newHit1D.setPositionAndError(rightPoint3D, error);
        break;
      }
 
      default:
        throw cms::Exception("InvalidDTCellSide") << "[DTParametrizedDriftAlgo] Compute at Step " << step
                                                  << ", Hit side " << newHit1D.lrSide() << " is invalid!" << endl;
        return false;
    }
 
    return true;
  } else {
    return false;
  }
}

References angle(), bookConverter::compute(), relativeConstraints::error, Exception, DTEnums::Left, DTRecHit1D::localPosition(), DTRecHit1D::lrSide(), DTEnums::Right, DTRecHit1D::setPositionAndError(), PV3DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::y(), and PV3DBase< T, PVType, FrameType >::z().

compute() [5/5]

bool DTParametrizedDriftAlgo::compute ( const DTLayer *  layer, const DTWireId &  wireId, const float  digiTime, const float &  angle, const GlobalPoint &  globPos, LocalPoint &  leftPoint, LocalPoint &  rightPoint, LocalError &  error, int  step  ) const

privatevirtual

Definition at line 100 of file DTParametrizedDriftAlgo.cc.

                                                      {
  // Subtract Offset according to DTTTrigBaseSync concrete instance
  // chosen with the 'tZeroMode' parameter
  float driftTime = digiTime - theSync->offset(layer, wireId, globPos);
 
  // check for out-of-time only at step 1
  if (step == 1 && (driftTime < minTime || driftTime > maxTime)) {
    if (debug)
      cout << "*** Drift time out of window for in-time hits " << driftTime << endl;
 
    if (step == 1) {  //FIXME: protection against failure at 2nd and 3rd steps, must be checked!!!
      // Hits are interpreted as coming from out-of-time pile-up and recHit
      // is ignored.
      return false;
    }
  }
 
  // Small negative times interpreted as hits close to the wire.
  if (driftTime < 0.)
    driftTime = 0;
 
  //----------------------------------------------------------------------
  // Magnetic Field in layer frame
  const LocalVector BLoc = layer->toLocal(magField->inTesla(globPos));
 
  float By = BLoc.y();
  float Bz = BLoc.z();
 
  //--------------------------------------------------------------------
  // Calculate the drift distance and the resolution from the parametrization
 
  DTTime2DriftParametrization::drift_distance DX;
  static const DTTime2DriftParametrization par;
 
  bool parStatus = par.computeDriftDistance_mean(driftTime, angle, By, Bz, interpolate, &DX);
 
  if (!parStatus) {
    if (debug)
      cout << "[DTParametrizedDriftAlgo]*** WARNING: call to parametrization failed" << endl;
    return false;
  }
 
  float sigma_l = DX.x_width_m;
  float sigma_r = DX.x_width_p;
  float drift = DX.x_drift;
 
  float reso = 0;
 
  bool variableSigma = false;
  // By defualt the errors are obtained from a fit of the residuals in the various
  // stations/SL.
  // The error returned by DTTime2DriftParametrization can not be used easily
  // to determine the hit error due to the way the parametrization of the error
  // is done (please contcat the authors for details).
  // Anyhow changing variableSigma==true, an attempt is done to set a variable error
  // according to the sigma calculated by DTTime2DriftParametrization.
  // Additionally, contributions from uncertaionties in TOF and signal propagation
  // corrections are added.
  // Uncertainty in the determination of incident angle and hit position
  // (ie B value) are NOT accounted.
  // This is not the default since it does not give good results...
 
  int wheel = abs(wireId.wheel());
  if (variableSigma) {
    float sTDelays = 0;
    if (step == 1) {                    // 1. step
      reso = (sigma_l + sigma_r) / 2.;  // FIXME: theta/B are not yet known...
      if (wireId.superlayer() == 2) {   // RZ
        sTDelays = 2.92;
      } else {  // RPhi
        if (wheel == 0) {
          sTDelays = 2.74;
        } else if (wheel == 1) {
          sTDelays = 1.83;
        } else if (wheel == 2) {
          sTDelays = 1.25;
        }
      }
    } else if (step == 2) {             // 2. step
      reso = (sigma_l + sigma_r) / 2.;  // FIXME: B is not yet known...
      if (wireId.superlayer() == 2) {   // RZ
        sTDelays = 0.096;
      } else {  // RPhi
        if (wheel == 0) {
          sTDelays = 0.022;
        } else if (wheel == 1) {
          sTDelays = 0.079;
        } else if (wheel == 2) {
          sTDelays = 0.124;
        }
      }
    } else if (step == 3) {  // 3. step
      reso = (sigma_l + sigma_r) / 2.;
      if (wireId.superlayer() == 2) {  // RZ
        sTDelays = 0.096;
      } else {  // RPhi
        if (wheel == 0) {
          sTDelays = 0.022;
        } else if (wheel == 1) {
          sTDelays = 0.079;
        } else if (wheel == 2) {
          sTDelays = 0.124;
        }
      }
    }
    float sXDelays = sTDelays * DX.v_drift / 10.;
    reso = sqrt(reso * reso + sXDelays * sXDelays);
  } else {            // Use a fixed sigma, from fit of residuals.
    if (step == 1) {  // 1. step
      if (wireId.superlayer() == 2) {
        if (wheel == 0) {
          reso = 0.0250;
        } else if (wheel == 1) {
          reso = 0.0271;
        } else if (wheel == 2) {
          reso = 0.0308;
        }
      } else {
        reso = 0.0237;
      }
    } else if (step == 2) {  // 2. step //FIXME
      if (wireId.superlayer() == 2) {
        if (wheel == 0) {
          reso = 0.0250;
        } else if (wheel == 1) {
          reso = 0.0271;
        } else if (wheel == 2) {
          reso = 0.0305;
        }
      } else {
        reso = 0.0231;
      }
    } else if (step == 3) {  // 3. step
      if (wireId.superlayer() == 2) {
        if (wheel == 0) {
          reso = 0.0196;
        } else if (wheel == 1) {
          reso = 0.0210;
        } else if (wheel == 2) {
          reso = 0.0228;
        }
      } else {
        reso = 0.0207;
      }
    }
  }
  //--------------------------------------------------------------------
 
  error = LocalError(reso * reso, 0., 0.);
 
  // Get Wire position
  if (!layer->specificTopology().isWireValid(wireId.wire()))
    return false;
  LocalPoint locWirePos(layer->specificTopology().wirePosition(wireId.wire()), 0, 0);
 
  //Build the two possible points and the error on the position
  leftPoint = LocalPoint(locWirePos.x() - drift, locWirePos.y(), locWirePos.z());
  rightPoint = LocalPoint(locWirePos.x() + drift, locWirePos.y(), locWirePos.z());
 
  if (debug) {
    int prevW = cout.width();
    cout << setiosflags(ios::showpoint | ios::fixed) << setw(3) << "[DTParametrizedDriftAlgo]: step " << step << endl
         << "  Global Position  " << globPos << endl
         << "  Local Position   " << layer->toLocal(globPos)
         << endl
         //          << "  y along Wire     " << wireCoord << endl
         << "  Digi time        " << digiTime
         << endl
         //          << "  dpropDelay       " << propDelay << endl
         //          << "  deltaTOF         " << deltaTOF << endl
         << " >Drif time        " << driftTime << endl
         << " >Angle            " << angle * 180. / M_PI << endl
         << " <Drift distance   " << drift << endl
         << " <sigma_l          " << sigma_l << endl
         << " <sigma_r          " << sigma_r << endl
         << "  reso             " << reso << endl
         << "  leftPoint        " << leftPoint << endl
         << "  rightPoint       " << rightPoint << endl
         << "  error            " << error << resetiosflags(ios::showpoint | ios::fixed) << setw(prevW) << endl
         << endl;
  }
 
  return true;
}

References funct::abs(), angle(), DTTime2DriftParametrization::computeDriftDistance_mean(), gather_cfg::cout, debug, shallow::drift(), relativeConstraints::error, alignBH_cfg::fixed, HiCaloJetParameters_cff::interpolate, DTTopology::isWireValid(), M_PI, HLT_2018_cff::maxTime, DTLayer::specificTopology(), mathSSE::sqrt(), DTSuperLayerId::superlayer(), GeomDet::toLocal(), DTTime2DriftParametrization::drift_distance::v_drift, DTChamberId::wheel(), makeMuonMisalignmentScenario::wheel, DTWireId::wire(), DTTopology::wirePosition(), PV3DBase< T, PVType, FrameType >::x(), DTTime2DriftParametrization::drift_distance::x_drift, DTTime2DriftParametrization::drift_distance::x_width_m, DTTime2DriftParametrization::drift_distance::x_width_p, PV3DBase< T, PVType, FrameType >::y(), and PV3DBase< T, PVType, FrameType >::z().

setES()

void DTParametrizedDriftAlgo::setES ( const edm::EventSetup &  setup )

overridevirtual

Pass the Event Setup to the algo at each event.

Implements DTRecHitBaseAlgo.

Definition at line 37 of file DTParametrizedDriftAlgo.cc.

                                                           {
  theSync->setES(setup);
  // Access the magnetic field
  ESHandle<MagneticField> magneticField;
  setup.get<IdealMagneticFieldRecord>().get(magneticField);
  magField = &*magneticField;
}

References get, HLT_2018_cff::magneticField, and singleTopDQM_cfi::setup.

Member Data Documentation

debug

const bool DTParametrizedDriftAlgo::debug

private

Definition at line 96 of file DTParametrizedDriftAlgo.h.

Referenced by runTauIdMVA.TauIDEmbedder::loadMVA_WPs_run2_2017(), and runTauIdMVA.TauIDEmbedder::runTauID().

interpolate

const bool DTParametrizedDriftAlgo::interpolate

private

Definition at line 67 of file DTParametrizedDriftAlgo.h.

magField

const MagneticField* DTParametrizedDriftAlgo::magField

private

Definition at line 99 of file DTParametrizedDriftAlgo.h.

maxTime

const float DTParametrizedDriftAlgo::maxTime

private

Definition at line 73 of file DTParametrizedDriftAlgo.h.

minTime

const float DTParametrizedDriftAlgo::minTime

private

Definition at line 70 of file DTParametrizedDriftAlgo.h.