SiPixelRecHits/src/PixelCPEBase.cc

0001 // Move geomCorrection to the concrete class. d.k. 06/06.
0002 // Change drift direction. d.k. 06/06
0003 // G. Giurgiu (ggiurgiu@pha.jhu.edu), 12/01/06, implemented the function:
0004 // computeAnglesFromDetPosition(const SiPixelCluster & cl,
0005 // change to use Lorentz angle from DB Lotte Wilke, Jan. 31st, 2008
0006 // Change to use Generic error & Template calibration from DB - D.Fehling 11/08
0007
0008 #include "Geometry/CommonDetUnit/interface/PixelGeomDetUnit.h"
0009 #include "RecoLocalTracker/SiPixelRecHits/interface/PixelCPEBase.h"
0010
0011 #define CORRECT_FOR_BIG_PIXELS
0012
0013 // MessageLogger
0014 #include "FWCore/MessageLogger/interface/MessageLogger.h"
0015
0016 // Magnetic field
0017 #include "MagneticField/Engine/interface/MagneticField.h"
0018
0019 #include <iostream>
0020
0021 using namespace std;
0022
0023 //-----------------------------------------------------------------------------
0024 //  A constructor run for generic and templates
0025 //
0026 //-----------------------------------------------------------------------------
0027 PixelCPEBase::PixelCPEBase(edm::ParameterSet const& conf,
0028                            const MagneticField* mag,
0029                            const TrackerGeometry& geom,
0030                            const TrackerTopology& ttopo,
0031                            const SiPixelLorentzAngle* lorentzAngle,
0032                            const SiPixelGenErrorDBObject* genErrorDBObject,
0033                            const SiPixelTemplateDBObject* templateDBobject,
0034                            const SiPixelLorentzAngle* lorentzAngleWidth,
0035                            int flag)
0036     //  : useLAAlignmentOffsets_(false), useLAOffsetFromConfig_(false),
0037     : useLAOffsetFromConfig_(false),
0038       useLAWidthFromConfig_(false),
0039       useLAWidthFromDB_(false),
0040       theFlag_(flag),
0041       magfield_(mag),
0042       geom_(geom),
0043       ttopo_(ttopo) {
0044 #ifdef EDM_ML_DEBUG
0045   nRecHitsTotal_ = 0;
0046   nRecHitsUsedEdge_ = 0,
0047 #endif
0048
0049   //--- Lorentz angle tangent per Tesla
0050       lorentzAngle_ = lorentzAngle;
0051   lorentzAngleWidth_ = lorentzAngleWidth;
0052
0053   //-- GenError Calibration Object from DB
0054   genErrorDBObject_ = genErrorDBObject;
0055
0056   //-- Template Calibration Object from DB
0057   if (theFlag_ != 0)
0058     templateDBobject_ = templateDBobject;  // flag to check if it is generic or templates
0059
0060   // Configurables
0061   // For both templates & generic
0062
0063   // Read templates and/or generic errors from DB
0064   LoadTemplatesFromDB_ = conf.getParameter<bool>("LoadTemplatesFromDB");
0065
0066   //--- Algorithm's verbosity
0067   theVerboseLevel = conf.getUntrackedParameter<int>("VerboseLevel", 0);
0068
0069   //-- Switch on/off E.B
0070   alpha2Order = conf.getParameter<bool>("Alpha2Order");
0071
0072   //--- A flag that could be used to change the behavior of
0073   //--- clusterProbability() in TSiPixelRecHit (the *transient* one).
0074   //--- The problem is that the transient hits are made after the CPE runs
0075   //--- and they don't get the access to the PSet, so we pass it via the
0076   //--- CPE itself...
0077   //
0078   clusterProbComputationFlag_ = (unsigned int)conf.getParameter<int>("ClusterProbComputationFlag");
0079
0080   // This LA related parameters are only relevant for the Generic algo
0081   // They still have to be used in Base since the LA computation is in Base
0082
0083   // Use LA-width from DB.
0084   // If both (this and from config) are false LA-width is calcuated from LA-offset
0085   useLAWidthFromDB_ = conf.getParameter<bool>("useLAWidthFromDB");
0086
0087   // Use Alignment LA-offset in generic
0088   // (Experimental; leave commented out)
0089   //useLAAlignmentOffsets_ = conf.existsAs<bool>("useLAAlignmentOffsets")?
0090   //conf.getParameter<bool>("useLAAlignmentOffsets"):false;
0091
0092   // Used only for testing
0093   lAOffset_ = conf.getParameter<double>("lAOffset");
0094   lAWidthBPix_ = conf.getParameter<double>("lAWidthBPix");
0095   lAWidthFPix_ = conf.getParameter<double>("lAWidthFPix");
0096
0097   // Use LA-offset from config, for testing only
0098   if (lAOffset_ > 0.0)
0099     useLAOffsetFromConfig_ = true;
0100   // Use LA-width from config, split into fpix & bpix, for testing only
0101   if (lAWidthBPix_ > 0.0 || lAWidthFPix_ > 0.0)
0102     useLAWidthFromConfig_ = true;
0103
0104   // For Templates only
0105   // Compute the Lorentz shifts for this detector element for templates (from Alignment)
0106   doLorentzFromAlignment_ = conf.getParameter<bool>("doLorentzFromAlignment");
0107   useLAFromDB_ = conf.getParameter<bool>("useLAFromDB");
0108
0109   LogDebug("PixelCPEBase") << " LA constants - " << lAOffset_ << " " << lAWidthBPix_ << " " << lAWidthFPix_
0110                            << endl;  //dk
0111
0112   fillDetParams();
0113 }
0114
0115 //-----------------------------------------------------------------------------
0116 //  Fill all variables which are constant for an event (geometry)
0117 //-----------------------------------------------------------------------------
0118 void PixelCPEBase::fillDetParams() {
0119   // MM: this code finds the last Pixel (Inner Tracker) DetUnit to loop upon when filling the det params, by looking the first detId which is from
0120   // the Outer Tracker (Strips in case of the Phase-0/1 detector).
0121
0122   auto const& dus = geom_.detUnits();
0123   unsigned m_detectors = dus.size();
0124   for (unsigned int i = 1; i < 7; ++i) {
0125     LogDebug("PixelCPEBase:: LookingForFirstStrip")
0126         << "Subdetector " << i << " GeomDetEnumerator " << GeomDetEnumerators::tkDetEnum[i] << " offset "
0127         << geom_.offsetDU(GeomDetEnumerators::tkDetEnum[i]) << " is it strip? "
0128         << (geom_.offsetDU(GeomDetEnumerators::tkDetEnum[i]) != dus.size()
0129                 ? dus[geom_.offsetDU(GeomDetEnumerators::tkDetEnum[i])]->type().isOuterTracker()
0130                 : false);
0131
0132     if (geom_.offsetDU(GeomDetEnumerators::tkDetEnum[i]) != dus.size() &&
0133         dus[geom_.offsetDU(GeomDetEnumerators::tkDetEnum[i])]->type().isOuterTracker()) {
0134       if (geom_.offsetDU(GeomDetEnumerators::tkDetEnum[i]) < m_detectors) {
0135         m_detectors = geom_.offsetDU(GeomDetEnumerators::tkDetEnum[i]);
0136       }
0137     }
0138   }
0139   LogDebug("LookingForFirstStrip") << " Chosen offset: " << m_detectors;
0140
0141   m_DetParams.resize(m_detectors);
0142   LogDebug("PixelCPEBase::fillDetParams():") << "caching " << m_detectors << " pixel detectors" << endl;
0143   for (unsigned i = 0; i != m_detectors; ++i) {
0144     auto& p = m_DetParams[i];
0145     p.theDet = dynamic_cast<const PixelGeomDetUnit*>(dus[i]);
0146     assert(p.theDet);
0147     assert(p.theDet->index() == int(i));
0148
0149     p.theOrigin = p.theDet->surface().toLocal(GlobalPoint(0, 0, 0));
0150
0151     //--- p.theDet->type() returns a GeomDetType, which implements subDetector()
0152     p.thePart = p.theDet->type().subDetector();
0153
0154     //--- The location in of this DetUnit in a cyllindrical coord system (R,Z)
0155     //--- The call goes via BoundSurface, returned by p.theDet->surface(), but
0156     //--- position() is implemented in GloballyPositioned<> template
0157     //--- ( BoundSurface : Surface : GloballyPositioned<float> )
0158     //p.theDetR = p.theDet->surface().position().perp();  //Not used, AH
0159     //p.theDetZ = p.theDet->surface().position().z();  //Not used, AH
0160     //--- Define parameters for chargewidth calculation
0161
0162     //--- bounds() is implemented in BoundSurface itself.
0163     p.theThickness = p.theDet->surface().bounds().thickness();
0164
0165     // Cache the det id for templates and generic erros
0166
0167     if (theFlag_ == 0) {         // for generic
0168       if (LoadTemplatesFromDB_)  // do only if genError requested
0169         p.detTemplateId = genErrorDBObject_->getGenErrorID(p.theDet->geographicalId().rawId());
0170     } else {  // for templates
0171       p.detTemplateId = templateDBobject_->getTemplateID(p.theDet->geographicalId());
0172     }
0173
0174     auto topol = &(p.theDet->specificTopology());
0175     p.theTopol = topol;
0176
0177     //--- The geometrical description of one module/plaquette
0178     std::pair<float, float> pitchxy = p.theTopol->pitch();
0179     p.thePitchX = pitchxy.first;   // pitch along x
0180     p.thePitchY = pitchxy.second;  // pitch along y
0181
0182     LocalVector Bfield = p.theDet->surface().toLocal(magfield_->inTesla(p.theDet->surface().position()));
0183     p.bz = Bfield.z();
0184     p.bx = Bfield.x();
0185
0186     //---  Compute the Lorentz shifts for this detector element
0187     if ((theFlag_ == 0) || useLAFromDB_ ||
0188         doLorentzFromAlignment_) {  // do always for generic and if using LA from DB or alignment for templates
0189       p.driftDirection = driftDirection(p, Bfield);
0190       computeLorentzShifts(p);
0191     }
0192
0193     LogDebug("PixelCPEBase::fillDetParams()") << "***** PIXEL LAYOUT *****"
0194                                               << " thePart = " << p.thePart << " theThickness = " << p.theThickness
0195                                               << " thePitchX  = " << p.thePitchX << " thePitchY  = " << p.thePitchY;
0196     //               << " theLShiftX  = " << p.theLShiftX;
0197   }
0198 }
0199
0200 //-----------------------------------------------------------------------------
0201 //  One function to cache the variables common for one DetUnit.
0202 //-----------------------------------------------------------------------------
0203 void PixelCPEBase::setTheClu(DetParam const& theDetParam, ClusterParam& theClusterParam) const {
0204   //--- Geometric Quality Information
0205   int minInX, minInY, maxInX, maxInY = 0;
0206   minInX = theClusterParam.theCluster->minPixelRow();
0207   minInY = theClusterParam.theCluster->minPixelCol();
0208   maxInX = theClusterParam.theCluster->maxPixelRow();
0209   maxInY = theClusterParam.theCluster->maxPixelCol();
0210
0211   int min_row(0), min_col(0);
0212   int max_row = theDetParam.theTopol->nrows() - 1;
0213   int max_col = theDetParam.theTopol->ncolumns() - 1;
0214
0215   if (minInX == min_row)
0216     theClusterParam.edgeTypeX_ = 1;
0217   else if (maxInX == max_row)
0218     theClusterParam.edgeTypeX_ = 2;
0219   else
0220     theClusterParam.edgeTypeX_ = 0;
0221
0222   if (minInY == min_col)
0223     theClusterParam.edgeTypeY_ = 1;
0224   else if (maxInY == max_col)
0225     theClusterParam.edgeTypeY_ = 2;
0226   else
0227     theClusterParam.edgeTypeY_ = 0;
0228
0229   theClusterParam.isOnEdge_ = (theClusterParam.edgeTypeX_ || theClusterParam.edgeTypeY_);
0230
0231   // &&& FOR NOW UNUSED. KEEP IT IN CASE WE WANT TO USE IT IN THE FUTURE
0232   // Bad Pixels have their charge set to 0 in the clusterizer
0233   //hasBadPixels_ = false;
0234   //for(unsigned int i=0; i<theClusterParam.theCluster->pixelADC().size(); ++i) {
0235   //if(theClusterParam.theCluster->pixelADC()[i] == 0) { hasBadPixels_ = true; break;}
0236   //}
0237
0238   theClusterParam.spansTwoROCs_ = theDetParam.theTopol->containsBigPixelInX(minInX, maxInX) ||
0239                                   theDetParam.theTopol->containsBigPixelInY(minInY, maxInY);
0240 }
0241
0242 //-----------------------------------------------------------------------------
0243 //  Compute alpha_ and beta_ from the LocalTrajectoryParameters.
0244 //  Note: should become const after both localParameters() become const.
0245 //-----------------------------------------------------------------------------
0246 void PixelCPEBase::computeAnglesFromTrajectory(DetParam const& theDetParam,
0247                                                ClusterParam& theClusterParam,
0248                                                const LocalTrajectoryParameters& ltp) const {
0249   theClusterParam.cotalpha = ltp.dxdz();
0250   theClusterParam.cotbeta = ltp.dydz();
0251
0252   LocalPoint trk_lp = ltp.position();
0253   theClusterParam.trk_lp_x = trk_lp.x();
0254   theClusterParam.trk_lp_y = trk_lp.y();
0255
0256   theClusterParam.with_track_angle = true;
0257
0258   // GG: needed to correct for bows/kinks
0259   theClusterParam.loc_trk_pred = Topology::LocalTrackPred(
0260       theClusterParam.trk_lp_x, theClusterParam.trk_lp_y, theClusterParam.cotalpha, theClusterParam.cotbeta);
0261 }
0262
0263 //-----------------------------------------------------------------------------
0264 //  Estimate theAlpha for barrel, based on the det position.
0265 //  &&& Needs to be consolidated from the above.
0266 //-----------------------------------------------------------------------------
0267 //float
0268 //PixelCPEBase::estimatedAlphaForBarrel(float centerx) const
0269 //{
0270 //  float tanalpha = theSign * (centerx-theOffsetX) * thePitchX / theDetR;
0271 //  return PI/2.0 - atan(tanalpha);
0272 //}
0273
0274 //-----------------------------------------------------------------------------
0275 //  Compute alpha_ and beta_ from the position of this DetUnit.
0276 //  &&& DOES NOT WORK FOR NOW. d.k. 6/06
0277 // The angles from dets are calculated internaly in the PixelCPEInitial class
0278 //-----------------------------------------------------------------------------
0279 // G. Giurgiu, 12/01/06 : implement the function
0280 void PixelCPEBase::computeAnglesFromDetPosition(DetParam const& theDetParam, ClusterParam& theClusterParam) const {
0281   LocalPoint lp = theDetParam.theTopol->localPosition(
0282       MeasurementPoint(theClusterParam.theCluster->x(), theClusterParam.theCluster->y()));
0283   auto gvx = lp.x() - theDetParam.theOrigin.x();
0284   auto gvy = lp.y() - theDetParam.theOrigin.y();
0285   auto gvz = -1.f / theDetParam.theOrigin.z();
0286   //--- Note that the normalization is not required as only the ratio used
0287
0288   //theClusterParam.zneg = (gvz < 0); // Not used, AH
0289
0290   // calculate angles
0291   theClusterParam.cotalpha = gvx * gvz;
0292   theClusterParam.cotbeta = gvy * gvz;
0293
0294   theClusterParam.with_track_angle = false;
0295
0296   /*
0297     // used only in dberror param...
0298     auto alpha = HALF_PI - std::atan(cotalpha_);
0299     auto beta = HALF_PI - std::atan(cotbeta_);
0300     if (zneg) { beta -=PI; alpha -=PI;}
0301
0302     auto alpha_ = atan2( gv_dot_gvz, gv_dot_gvx );
0303     auto beta_  = atan2( gv_dot_gvz, gv_dot_gvy );
0304
0305     assert(std::abs(std::round(alpha*10000.f)-std::round(alpha_*10000.f))<2);
0306     assert(std::abs(std::round(beta*10000.f)-std::round(beta_*10000.f))<2);
0307     */
0308 }
0309
0310 //------------------------------------------------------------------------
0311 PixelCPEBase::DetParam const& PixelCPEBase::detParam(const GeomDetUnit& det) const {
0312   auto i = det.index();
0313   //cout << "get parameters of detector " << i << endl;
0314   assert(i < int(m_DetParams.size()));
0315   //if (i>=int(m_DetParams.size())) m_DetParams.resize(i+1);  // should never happen!
0316   const DetParam& p = m_DetParams[i];
0317   return p;
0318 }
0319
0320 //-----------------------------------------------------------------------------
0321 //  Drift direction.
0322 //  Works OK for barrel and forward.
0323 //  The formulas used for dir_x,y,z have to be exactly the same as the ones
0324 //  used in the digitizer (SiPixelDigitizerAlgorithm.cc).
0325 //  &&& PM: needs to be consolidated, discuss with PS.
0326 //-----------------------------------------------------------------------------
0327 LocalVector PixelCPEBase::driftDirection(DetParam& theDetParam, GlobalVector bfield) const {
0328   Frame detFrame(theDetParam.theDet->surface().position(), theDetParam.theDet->surface().rotation());
0329   LocalVector Bfield = detFrame.toLocal(bfield);
0330   return driftDirection(theDetParam, Bfield);
0331 }
0332
0333 LocalVector PixelCPEBase::driftDirection(DetParam& theDetParam, LocalVector Bfield) const {
0334   // Use LA from DB or from config
0335   float langle = 0.;
0336   if (!useLAOffsetFromConfig_) {     // get it from DB
0337     if (lorentzAngle_ != nullptr) {  // a real LA object
0338       langle = lorentzAngle_->getLorentzAngle(theDetParam.theDet->geographicalId().rawId());
0339       LogDebug("PixelCPEBase::driftDirection()")
0340           << " la " << langle << " " << theDetParam.theDet->geographicalId().rawId() << endl;
0341     } else {                                                                                      // no LA, unused
0342       langle = 0;                                                                                 // set to a fake value
0343       LogDebug("PixelCPEBase::driftDirection()") << " LA object is NULL, assume LA = 0" << endl;  //dk
0344     }
0345     LogDebug("PixelCPEBase::driftDirection()") << " Will use LA Offset from DB " << langle << endl;
0346   } else {  // from config file
0347     langle = lAOffset_;
0348     LogDebug("PixelCPEBase::driftDirection()") << " Will use LA Offset from config " << langle << endl;
0349   }
0350
0351   // Now do the LA width stuff
0352   theDetParam.widthLAFractionX = 1.;  // predefine to 1 (default) if things fail
0353   theDetParam.widthLAFractionY = 1.;
0354
0355   // Compute the charge width, generic only
0356   if (theFlag_ == 0) {
0357     if (useLAWidthFromDB_ && (lorentzAngleWidth_ != nullptr)) {
0358       // take it from a separate, special LA DB object (forWidth)
0359
0360       auto langleWidth = lorentzAngleWidth_->getLorentzAngle(theDetParam.theDet->geographicalId().rawId());
0361       if (langleWidth != 0.0)
0362         theDetParam.widthLAFractionX = std::abs(langleWidth / langle);
0363       // leave the widthLAFractionY=1.
0364       //cout<<" LAWidth lorentz width "<<theDetParam.widthLAFractionX<<" "<<theDetParam.widthLAFractionY<<endl;
0365
0366     } else if (useLAWidthFromConfig_) {  // get from config
0367
0368       double lAWidth = 0;
0369       if (GeomDetEnumerators::isTrackerPixel(theDetParam.thePart) && GeomDetEnumerators::isBarrel(theDetParam.thePart))
0370         lAWidth = lAWidthBPix_;  // barrel
0371       else
0372         lAWidth = lAWidthFPix_;
0373
0374       if (langle != 0.0)
0375         theDetParam.widthLAFractionX = std::abs(lAWidth / langle);
0376       // fix the FractionY at 1
0377
0378       //cout<<" Lorentz width from config "<<theDetParam.widthLAFractionX<<" "<<theDetParam.widthLAFractionY<<endl;
0379
0380     } else {  // get if from the offset LA (old method used until 2013)
0381               // do nothing
0382       //cout<<" Old default LA width method "<<theDetParam.widthLAFractionX<<" "<<theDetParam.widthLAFractionY<<endl;
0383     }
0384
0385     //cout<<" Final LA fraction  "<<theDetParam.widthLAFractionX<<" "<<theDetParam.widthLAFractionY<<endl;
0386
0387   }  // if flag
0388
0389   float alpha2 = alpha2Order ? langle * langle : 0;  //
0390
0391   // **********************************************************************
0392   // Our convention is the following:
0393   // +x is defined by the direction of the Lorentz drift!
0394   // +z is defined by the direction of E field (so electrons always go into -z!)
0395   // +y is defined by +x and +z, and it turns out to be always opposite to the +B field.
0396   // **********************************************************************
0397
0398   float dir_x = -(langle * Bfield.y() + alpha2 * Bfield.z() * Bfield.x());
0399   float dir_y = (langle * Bfield.x() - alpha2 * Bfield.z() * Bfield.y());
0400   float dir_z = -(1.f + alpha2 * Bfield.z() * Bfield.z());
0401   auto scale = 1.f / std::abs(dir_z);                  // same as 1 + alpha2*Bfield.z()*Bfield.z()
0402   LocalVector dd(dir_x * scale, dir_y * scale, -1.f);  // last is -1 !
0403
0404   LogDebug("PixelCPEBase") << " The drift direction in local coordinate is " << dd;
0405
0406   return dd;
0407 }
0408
0409 //-----------------------------------------------------------------------------
0410 //  One-shot computation of the driftDirection and both lorentz shifts
0411 //-----------------------------------------------------------------------------
0412 void PixelCPEBase::computeLorentzShifts(DetParam& theDetParam) const {
0413   // Max shift (at the other side of the sensor) in cm
0414   theDetParam.lorentzShiftInCmX =
0415       theDetParam.driftDirection.x() / theDetParam.driftDirection.z() * theDetParam.theThickness;  //
0416   theDetParam.lorentzShiftInCmY =
0417       theDetParam.driftDirection.y() / theDetParam.driftDirection.z() * theDetParam.theThickness;  //
0418
0419   LogDebug("PixelCPEBase::computeLorentzShifts()")
0420       << " lorentzShiftsInCmX,Y = " << theDetParam.lorentzShiftInCmX << " " << theDetParam.lorentzShiftInCmY << " "
0421       << theDetParam.driftDirection;
0422 }
0423
0424 //-----------------------------------------------------------------------------
0425 //! A convenience method to fill a whole SiPixelRecHitQuality word in one shot.
0426 //! This way, we can keep the details of what is filled within the pixel
0427 //! code and not expose the Transient SiPixelRecHit to it as well.  The name
0428 //! of this function is chosen to match the one in SiPixelRecHit.
0429 //-----------------------------------------------------------------------------
0430 SiPixelRecHitQuality::QualWordType PixelCPEBase::rawQualityWord(ClusterParam& theClusterParam) const {
0431   SiPixelRecHitQuality::QualWordType qualWord(0);
0432   if (theClusterParam.hasFilledProb_) {
0433     float probabilityXY = 0;
0434     if (theClusterParam.filled_from_2d)
0435       probabilityXY = theClusterParam.probabilityX_;
0436     else if (theClusterParam.probabilityX_ != 0 && theClusterParam.probabilityY_ != 0)
0437       probabilityXY = theClusterParam.probabilityX_ * theClusterParam.probabilityY_ *
0438                       (1.f - std::log(theClusterParam.probabilityX_ * theClusterParam.probabilityY_));
0439     SiPixelRecHitQuality::thePacking.setProbabilityXY(probabilityXY, qualWord);
0440
0441     SiPixelRecHitQuality::thePacking.setProbabilityQ(theClusterParam.probabilityQ_, qualWord);
0442   }
0443   SiPixelRecHitQuality::thePacking.setQBin(theClusterParam.qBin_, qualWord);
0444
0445   SiPixelRecHitQuality::thePacking.setIsOnEdge(theClusterParam.isOnEdge_, qualWord);
0446
0447   SiPixelRecHitQuality::thePacking.setHasBadPixels(theClusterParam.hasBadPixels_, qualWord);
0448
0449   SiPixelRecHitQuality::thePacking.setSpansTwoROCs(theClusterParam.spansTwoROCs_, qualWord);
0450
0451   SiPixelRecHitQuality::thePacking.setHasFilledProb(theClusterParam.hasFilledProb_, qualWord);
0452
0453   return qualWord;
0454 }
0455
0456 void PixelCPEBase::fillPSetDescription(edm::ParameterSetDescription& desc) {
0457   desc.add<bool>("LoadTemplatesFromDB", true);
0458   desc.add<bool>("Alpha2Order", true);
0459   desc.add<int>("ClusterProbComputationFlag", 0);
0460   desc.add<bool>("useLAWidthFromDB", true);
0461   desc.add<double>("lAOffset", 0.0);
0462   desc.add<double>("lAWidthBPix", 0.0);
0463   desc.add<double>("lAWidthFPix", 0.0);
0464   desc.add<bool>("doLorentzFromAlignment", false);
0465   desc.add<bool>("useLAFromDB", true);
0466 }