Back to home page

Project CMSSW displayed by LXR
 
 

    

File indexing completed on 2023-01-21 00:19:45 

0001 #include "RecoLocalTracker/SiPixelRecHits/interface/PixelCPEGeneric.h"
0002 
0003 #include "Geometry/CommonDetUnit/interface/PixelGeomDetUnit.h"
0004 #include "Geometry/TrackerGeometryBuilder/interface/RectangularPixelTopology.h"
0005 #include "DataFormats/DetId/interface/DetId.h"
0006 
0007 // Pixel templates contain the rec hit error parameterizaiton
0008 #include "CondFormats/SiPixelTransient/interface/SiPixelTemplate.h"
0009 
0010 // The generic formula
0011 #include "CondFormats/SiPixelTransient/interface/SiPixelUtils.h"
0012 
0013 // Services
0014 #include "FWCore/MessageLogger/interface/MessageLogger.h"
0015 #include "MagneticField/Engine/interface/MagneticField.h"
0016 
0017 #include "boost/multi_array.hpp"
0018 
0019 #include <iostream>
0020 using namespace std;
0021 
0022 namespace {
0023   constexpr float micronsToCm = 1.0e-4;
0024 }  // namespace
0025 
0026 //-----------------------------------------------------------------------------
0027 //!  The constructor.
0028 //-----------------------------------------------------------------------------
0029 PixelCPEGeneric::PixelCPEGeneric(edm::ParameterSet const& conf,
0030                                  const MagneticField* mag,
0031                                  const TrackerGeometry& geom,
0032                                  const TrackerTopology& ttopo,
0033                                  const SiPixelLorentzAngle* lorentzAngle,
0034                                  const SiPixelGenErrorDBObject* genErrorDBObject,
0035                                  const SiPixelLorentzAngle* lorentzAngleWidth = nullptr)
0036     : PixelCPEGenericBase(conf, mag, geom, ttopo, lorentzAngle, genErrorDBObject, lorentzAngleWidth) {
0037   if (theVerboseLevel > 0)
0038     LogDebug("PixelCPEGeneric") << " constructing a generic algorithm for ideal pixel detector.\n"
0039                                 << " CPEGeneric:: VerboseLevel = " << theVerboseLevel;
0040 
0041   // Externally settable cuts
0042   the_eff_charge_cut_lowX = conf.getParameter<double>("eff_charge_cut_lowX");
0043   the_eff_charge_cut_lowY = conf.getParameter<double>("eff_charge_cut_lowY");
0044   the_eff_charge_cut_highX = conf.getParameter<double>("eff_charge_cut_highX");
0045   the_eff_charge_cut_highY = conf.getParameter<double>("eff_charge_cut_highY");
0046   the_size_cutX = conf.getParameter<double>("size_cutX");
0047   the_size_cutY = conf.getParameter<double>("size_cutY");
0048 
0049   // Externally settable flags to inflate errors
0050   inflate_errors = conf.getParameter<bool>("inflate_errors");
0051   inflate_all_errors_no_trk_angle = conf.getParameter<bool>("inflate_all_errors_no_trk_angle");
0052 
0053   NoTemplateErrorsWhenNoTrkAngles_ = conf.getParameter<bool>("NoTemplateErrorsWhenNoTrkAngles");
0054   IrradiationBiasCorrection_ = conf.getParameter<bool>("IrradiationBiasCorrection");
0055   DoCosmics_ = conf.getParameter<bool>("DoCosmics");
0056 
0057   isPhase2_ = conf.getParameter<bool>("isPhase2");
0058 
0059   // For cosmics force the use of simple errors
0060   if ((DoCosmics_))
0061     useErrorsFromTemplates_ = false;
0062 
0063   if (!useErrorsFromTemplates_ && (truncatePixelCharge_ || IrradiationBiasCorrection_ || LoadTemplatesFromDB_)) {
0064     throw cms::Exception("PixelCPEGeneric::PixelCPEGeneric: ")
0065         << "\nERROR: useErrorsFromTemplates_ is set to False in PixelCPEGeneric_cfi.py. "
0066         << " In this case it does not make sense to set any of the following to True: "
0067         << " truncatePixelCharge_, IrradiationBiasCorrection_, DoCosmics_, LoadTemplatesFromDB_ !!!"
0068         << "\n\n";
0069   }
0070 
0071   // Use errors from templates or from GenError
0072   if (useErrorsFromTemplates_) {
0073     if (LoadTemplatesFromDB_) {  // From DB
0074       if (!SiPixelGenError::pushfile(*genErrorDBObject_, thePixelGenError_))
0075         throw cms::Exception("InvalidCalibrationLoaded")
0076             << "ERROR: GenErrors not filled correctly. Check the sqlite file. Using SiPixelTemplateDBObject version "
0077             << (*genErrorDBObject_).version();
0078       LogDebug("PixelCPEGeneric") << "Loaded genErrorDBObject v" << (*genErrorDBObject_).version();
0079     } else {  // From file
0080       if (!SiPixelGenError::pushfile(-999, thePixelGenError_))
0081         throw cms::Exception("InvalidCalibrationLoaded")
0082             << "ERROR: GenErrors not loaded correctly from text file. Reconstruction will fail.";
0083     }  // if load from DB
0084 
0085   } else {
0086 #ifdef EDM_ML_DEBUG
0087     cout << " Use simple parametrised errors " << endl;
0088 #endif
0089   }  // if ( useErrorsFromTemplates_ )
0090 
0091 #ifdef EDM_ML_DEBUG
0092   cout << "From PixelCPEGeneric::PixelCPEGeneric(...)" << endl;
0093   cout << "(int)useErrorsFromTemplates_ = " << (int)useErrorsFromTemplates_ << endl;
0094   cout << "truncatePixelCharge_         = " << (int)truncatePixelCharge_ << endl;
0095   cout << "IrradiationBiasCorrection_   = " << (int)IrradiationBiasCorrection_ << endl;
0096   cout << "(int)DoCosmics_              = " << (int)DoCosmics_ << endl;
0097   cout << "(int)LoadTemplatesFromDB_    = " << (int)LoadTemplatesFromDB_ << endl;
0098 #endif
0099 }
0100 
0101 //-----------------------------------------------------------------------------
0102 //! Hit position in the local frame (in cm).  Unlike other CPE's, this
0103 //! one converts everything from the measurement frame (in channel numbers)
0104 //! into the local frame (in centimeters).
0105 //-----------------------------------------------------------------------------
0106 LocalPoint PixelCPEGeneric::localPosition(DetParam const& theDetParam, ClusterParam& theClusterParamBase) const {
0107   ClusterParamGeneric& theClusterParam = static_cast<ClusterParamGeneric&>(theClusterParamBase);
0108 
0109   //cout<<" in PixelCPEGeneric:localPosition - "<<endl; //dk
0110 
0111   float chargeWidthX = (theDetParam.lorentzShiftInCmX * theDetParam.widthLAFractionX);
0112   float chargeWidthY = (theDetParam.lorentzShiftInCmY * theDetParam.widthLAFractionY);
0113   float shiftX = 0.5f * theDetParam.lorentzShiftInCmX;
0114   float shiftY = 0.5f * theDetParam.lorentzShiftInCmY;
0115 
0116   //cout<<" main la width "<<chargeWidthX<<" "<<chargeWidthY<<endl;
0117 
0118   if (useErrorsFromTemplates_) {
0119     float qclus = theClusterParam.theCluster->charge();
0120     float locBz = theDetParam.bz;
0121     float locBx = theDetParam.bx;
0122     //cout << "PixelCPEGeneric::localPosition(...) : locBz = " << locBz << endl;
0123 
0124     theClusterParam.pixmx = -999;     // max pixel charge for truncation of 2-D cluster
0125     theClusterParam.sigmay = -999.9;  // CPE Generic y-error for multi-pixel cluster
0126     theClusterParam.deltay = -999.9;  // CPE Generic y-bias for multi-pixel cluster
0127     theClusterParam.sigmax = -999.9;  // CPE Generic x-error for multi-pixel cluster
0128     theClusterParam.deltax = -999.9;  // CPE Generic x-bias for multi-pixel cluster
0129     theClusterParam.sy1 = -999.9;     // CPE Generic y-error for single single-pixel
0130     theClusterParam.dy1 = -999.9;     // CPE Generic y-bias for single single-pixel cluster
0131     theClusterParam.sy2 = -999.9;     // CPE Generic y-error for single double-pixel cluster
0132     theClusterParam.dy2 = -999.9;     // CPE Generic y-bias for single double-pixel cluster
0133     theClusterParam.sx1 = -999.9;     // CPE Generic x-error for single single-pixel cluster
0134     theClusterParam.dx1 = -999.9;     // CPE Generic x-bias for single single-pixel cluster
0135     theClusterParam.sx2 = -999.9;     // CPE Generic x-error for single double-pixel cluster
0136     theClusterParam.dx2 = -999.9;     // CPE Generic x-bias for single double-pixel cluster
0137 
0138     SiPixelGenError gtempl(thePixelGenError_);
0139     int gtemplID_ = theDetParam.detTemplateId;
0140 
0141     //int gtemplID0 = genErrorDBObject_->getGenErrorID(theDetParam.theDet->geographicalId().rawId());
0142     //if(gtemplID0!=gtemplID_) cout<<" different id "<< gtemplID_<<" "<<gtemplID0<<endl;
0143 
0144     theClusterParam.qBin_ = gtempl.qbin(gtemplID_,
0145                                         theClusterParam.cotalpha,
0146                                         theClusterParam.cotbeta,
0147                                         locBz,
0148                                         locBx,
0149                                         qclus,
0150                                         IrradiationBiasCorrection_,
0151                                         theClusterParam.pixmx,
0152                                         theClusterParam.sigmay,
0153                                         theClusterParam.deltay,
0154                                         theClusterParam.sigmax,
0155                                         theClusterParam.deltax,
0156                                         theClusterParam.sy1,
0157                                         theClusterParam.dy1,
0158                                         theClusterParam.sy2,
0159                                         theClusterParam.dy2,
0160                                         theClusterParam.sx1,
0161                                         theClusterParam.dx1,
0162                                         theClusterParam.sx2,
0163                                         theClusterParam.dx2);
0164 
0165     // now use the charge widths stored in the new generic template headers (change to the
0166     // incorrect sign convention of the base class)
0167     bool useLAWidthFromGenError = false;
0168     if (useLAWidthFromGenError) {
0169       chargeWidthX = (-micronsToCm * gtempl.lorxwidth());
0170       chargeWidthY = (-micronsToCm * gtempl.lorywidth());
0171       LogDebug("PixelCPE localPosition():") << "redefine la width (gen-error)" << chargeWidthX << chargeWidthY;
0172     }
0173     LogDebug("PixelCPE localPosition():") << "GenError:" << gtemplID_;
0174 
0175     // These numbers come in microns from the qbin(...) call. Transform them to cm.
0176     theClusterParam.deltax = theClusterParam.deltax * micronsToCm;
0177     theClusterParam.dx1 = theClusterParam.dx1 * micronsToCm;
0178     theClusterParam.dx2 = theClusterParam.dx2 * micronsToCm;
0179 
0180     theClusterParam.deltay = theClusterParam.deltay * micronsToCm;
0181     theClusterParam.dy1 = theClusterParam.dy1 * micronsToCm;
0182     theClusterParam.dy2 = theClusterParam.dy2 * micronsToCm;
0183 
0184     theClusterParam.sigmax = theClusterParam.sigmax * micronsToCm;
0185     theClusterParam.sx1 = theClusterParam.sx1 * micronsToCm;
0186     theClusterParam.sx2 = theClusterParam.sx2 * micronsToCm;
0187 
0188     theClusterParam.sigmay = theClusterParam.sigmay * micronsToCm;
0189     theClusterParam.sy1 = theClusterParam.sy1 * micronsToCm;
0190     theClusterParam.sy2 = theClusterParam.sy2 * micronsToCm;
0191 
0192   }  // if ( useErrorsFromTemplates_ )
0193   else {
0194     theClusterParam.qBin_ = 0;
0195   }
0196 
0197   int q_f_X;  //!< Q of the first  pixel  in X
0198   int q_l_X;  //!< Q of the last   pixel  in X
0199   int q_f_Y;  //!< Q of the first  pixel  in Y
0200   int q_l_Y;  //!< Q of the last   pixel  in Y
0201   collect_edge_charges(theClusterParam, q_f_X, q_l_X, q_f_Y, q_l_Y, useErrorsFromTemplates_ && truncatePixelCharge_);
0202 
0203   //--- Find the inner widths along X and Y in one shot.  We
0204   //--- compute the upper right corner of the inner pixels
0205   //--- (== lower left corner of upper right pixel) and
0206   //--- the lower left corner of the inner pixels
0207   //--- (== upper right corner of lower left pixel), and then
0208   //--- subtract these two points in the formula.
0209 
0210   //--- Upper Right corner of Lower Left pixel -- in measurement frame
0211   MeasurementPoint meas_URcorn_LLpix(theClusterParam.theCluster->minPixelRow() + 1.0,
0212                                      theClusterParam.theCluster->minPixelCol() + 1.0);
0213 
0214   //--- Lower Left corner of Upper Right pixel -- in measurement frame
0215   MeasurementPoint meas_LLcorn_URpix(theClusterParam.theCluster->maxPixelRow(),
0216                                      theClusterParam.theCluster->maxPixelCol());
0217 
0218   //--- These two now converted into the local
0219   LocalPoint local_URcorn_LLpix;
0220   LocalPoint local_LLcorn_URpix;
0221 
0222   // PixelCPEGeneric can be used with or without track angles
0223   // If PixelCPEGeneric is called with track angles, use them to correct for bows/kinks:
0224   if (theClusterParam.with_track_angle) {
0225     local_URcorn_LLpix = theDetParam.theTopol->localPosition(meas_URcorn_LLpix, theClusterParam.loc_trk_pred);
0226     local_LLcorn_URpix = theDetParam.theTopol->localPosition(meas_LLcorn_URpix, theClusterParam.loc_trk_pred);
0227   } else {
0228     local_URcorn_LLpix = theDetParam.theTopol->localPosition(meas_URcorn_LLpix);
0229     local_LLcorn_URpix = theDetParam.theTopol->localPosition(meas_LLcorn_URpix);
0230   }
0231 
0232 #ifdef EDM_ML_DEBUG
0233   if (theVerboseLevel > 20) {
0234     cout << "\n\t >>> theClusterParam.theCluster->x = " << theClusterParam.theCluster->x()
0235          << "\n\t >>> theClusterParam.theCluster->y = " << theClusterParam.theCluster->y()
0236          << "\n\t >>> cluster: minRow = " << theClusterParam.theCluster->minPixelRow()
0237          << "  minCol = " << theClusterParam.theCluster->minPixelCol()
0238          << "\n\t >>> cluster: maxRow = " << theClusterParam.theCluster->maxPixelRow()
0239          << "  maxCol = " << theClusterParam.theCluster->maxPixelCol()
0240          << "\n\t >>> meas: inner lower left  = " << meas_URcorn_LLpix.x() << "," << meas_URcorn_LLpix.y()
0241          << "\n\t >>> meas: inner upper right = " << meas_LLcorn_URpix.x() << "," << meas_LLcorn_URpix.y() << endl;
0242   }
0243 #endif
0244 
0245   //--- &&& Note that the cuts below should not be hardcoded (like in Orca and
0246   //--- &&& CPEFromDetPosition/PixelCPEInitial), but rather be
0247   //--- &&& externally settable (but tracked) parameters.
0248 
0249   //--- Position, including the half lorentz shift
0250 
0251 #ifdef EDM_ML_DEBUG
0252   if (theVerboseLevel > 20)
0253     cout << "\t >>> Generic:: processing X" << endl;
0254 #endif
0255 
0256   float xPos = siPixelUtils::generic_position_formula(
0257       theClusterParam.theCluster->sizeX(),
0258       q_f_X,
0259       q_l_X,
0260       local_URcorn_LLpix.x(),
0261       local_LLcorn_URpix.x(),
0262       chargeWidthX,  // lorentz shift in cm
0263       theDetParam.theThickness,
0264       theClusterParam.cotalpha,
0265       theDetParam.thePitchX,
0266       theDetParam.theRecTopol->isItBigPixelInX(theClusterParam.theCluster->minPixelRow()),
0267       theDetParam.theRecTopol->isItBigPixelInX(theClusterParam.theCluster->maxPixelRow()),
0268       the_eff_charge_cut_lowX,
0269       the_eff_charge_cut_highX,
0270       the_size_cutX);  // cut for eff charge width &&&
0271 
0272   // apply the lorentz offset correction
0273   xPos = xPos + shiftX;
0274 
0275 #ifdef EDM_ML_DEBUG
0276   if (theVerboseLevel > 20)
0277     cout << "\t >>> Generic:: processing Y" << endl;
0278 #endif
0279 
0280   float yPos = siPixelUtils::generic_position_formula(
0281       theClusterParam.theCluster->sizeY(),
0282       q_f_Y,
0283       q_l_Y,
0284       local_URcorn_LLpix.y(),
0285       local_LLcorn_URpix.y(),
0286       chargeWidthY,  // lorentz shift in cm
0287       theDetParam.theThickness,
0288       theClusterParam.cotbeta,
0289       theDetParam.thePitchY,
0290       theDetParam.theRecTopol->isItBigPixelInY(theClusterParam.theCluster->minPixelCol()),
0291       theDetParam.theRecTopol->isItBigPixelInY(theClusterParam.theCluster->maxPixelCol()),
0292       the_eff_charge_cut_lowY,
0293       the_eff_charge_cut_highY,
0294       the_size_cutY);  // cut for eff charge width &&&
0295 
0296   // apply the lorentz offset correction
0297   yPos = yPos + shiftY;
0298 
0299   // Apply irradiation corrections
0300   if (IrradiationBiasCorrection_) {
0301     if (theClusterParam.theCluster->sizeX() == 1) {  // size=1
0302       // ggiurgiu@jhu.edu, 02/03/09 : for size = 1, the Lorentz shift is already accounted by the irradiation correction
0303       //float tmp1 =  (0.5 * theDetParam.lorentzShiftInCmX);
0304       //cout << "Apply correction correction_dx1 = " << theClusterParam.dx1 << " to xPos = " << xPos;
0305       xPos = xPos - (0.5f * theDetParam.lorentzShiftInCmX);
0306       // Find if pixel is double (big).
0307       bool bigInX = theDetParam.theRecTopol->isItBigPixelInX(theClusterParam.theCluster->maxPixelRow());
0308       if (!bigInX)
0309         xPos -= theClusterParam.dx1;
0310       else
0311         xPos -= theClusterParam.dx2;
0312       //cout<<" to "<<xPos<<" "<<(tmp1+theClusterParam.dx1)<<endl;
0313     } else {  // size>1
0314       //cout << "Apply correction correction_deltax = " << theClusterParam.deltax << " to xPos = " << xPos;
0315       xPos -= theClusterParam.deltax;
0316       //cout<<" to "<<xPos<<endl;
0317     }
0318 
0319     if (theClusterParam.theCluster->sizeY() == 1) {
0320       // ggiurgiu@jhu.edu, 02/03/09 : for size = 1, the Lorentz shift is already accounted by the irradiation correction
0321       yPos = yPos - (0.5f * theDetParam.lorentzShiftInCmY);
0322 
0323       // Find if pixel is double (big).
0324       bool bigInY = theDetParam.theRecTopol->isItBigPixelInY(theClusterParam.theCluster->maxPixelCol());
0325       if (!bigInY)
0326         yPos -= theClusterParam.dy1;
0327       else
0328         yPos -= theClusterParam.dy2;
0329 
0330     } else {
0331       //cout << "Apply correction correction_deltay = " << theClusterParam.deltay << " to yPos = " << yPos << endl;
0332       yPos -= theClusterParam.deltay;
0333     }
0334 
0335   }  // if ( IrradiationBiasCorrection_ )
0336 
0337   //cout<<" in PixelCPEGeneric:localPosition - pos = "<<xPos<<" "<<yPos<<endl; //dk
0338 
0339   //--- Now put the two together
0340   LocalPoint pos_in_local(xPos, yPos);
0341   return pos_in_local;
0342 }
0343 
0344 //==============  INFLATED ERROR AND ERRORS FROM DB BELOW  ================
0345 
0346 //-------------------------------------------------------------------------
0347 //  Hit error in the local frame
0348 //-------------------------------------------------------------------------
0349 LocalError PixelCPEGeneric::localError(DetParam const& theDetParam, ClusterParam& theClusterParamBase) const {
0350   ClusterParamGeneric& theClusterParam = static_cast<ClusterParamGeneric&>(theClusterParamBase);
0351 
0352   // local variables
0353   float xerr, yerr;
0354   bool edgex, edgey, bigInX, bigInY;
0355   int maxPixelCol, maxPixelRow, minPixelCol, minPixelRow;
0356   uint sizex, sizey;
0357 
0358   initializeLocalErrorVariables(xerr,
0359                                 yerr,
0360                                 edgex,
0361                                 edgey,
0362                                 bigInX,
0363                                 bigInY,
0364                                 maxPixelCol,
0365                                 maxPixelRow,
0366                                 minPixelCol,
0367                                 minPixelRow,
0368                                 sizex,
0369                                 sizey,
0370                                 theDetParam,
0371                                 theClusterParam);
0372 
0373   bool useTempErrors =
0374       useErrorsFromTemplates_ && (!NoTemplateErrorsWhenNoTrkAngles_ || theClusterParam.with_track_angle);
0375 
0376   if (int(sizex) != (maxPixelRow - minPixelRow + 1))
0377     LogDebug("PixelCPEGeneric") << " wrong x";
0378   if (int(sizey) != (maxPixelCol - minPixelCol + 1))
0379     LogDebug("PixelCPEGeneric") << " wrong y";
0380 
0381   LogDebug("PixelCPEGeneric") << " edge clus " << xerr << " " << yerr;  //dk
0382   if (bigInX || bigInY)
0383     LogDebug("PixelCPEGeneric") << " big " << bigInX << " " << bigInY;
0384   if (edgex || edgey)
0385     LogDebug("PixelCPEGeneric") << " edge " << edgex << " " << edgey;
0386   LogDebug("PixelCPEGeneric") << " before if " << useErrorsFromTemplates_ << " " << theClusterParam.qBin_;
0387   if (theClusterParam.qBin_ == 0)
0388     LogDebug("PixelCPEGeneric") << " qbin 0! " << edgex << " " << edgey << " " << bigInX << " " << bigInY << " "
0389                                 << sizex << " " << sizey;
0390 
0391   // from PixelCPEGenericBase
0392   setXYErrors(xerr, yerr, edgex, edgey, sizex, sizey, bigInX, bigInY, useTempErrors, theDetParam, theClusterParam);
0393 
0394   if (!useTempErrors) {
0395     LogDebug("PixelCPEGeneric") << "Track angles are not known.\n"
0396                                 << "Default angle estimation which assumes track from PV (0,0,0) does not work.";
0397   }
0398 
0399   if (!useTempErrors && inflate_errors) {
0400     int n_bigx = 0;
0401     int n_bigy = 0;
0402 
0403     for (int irow = 0; irow < 7; ++irow) {
0404       if (theDetParam.theRecTopol->isItBigPixelInX(irow + minPixelRow))
0405         ++n_bigx;
0406     }
0407 
0408     for (int icol = 0; icol < 21; ++icol) {
0409       if (theDetParam.theRecTopol->isItBigPixelInY(icol + minPixelCol))
0410         ++n_bigy;
0411     }
0412 
0413     xerr = (float)(sizex + n_bigx) * theDetParam.thePitchX / std::sqrt(12.0f);
0414     yerr = (float)(sizey + n_bigy) * theDetParam.thePitchY / std::sqrt(12.0f);
0415   }
0416 
0417 #ifdef EDM_ML_DEBUG
0418   if (!(xerr > 0.0))
0419     throw cms::Exception("PixelCPEGeneric::localError") << "\nERROR: Negative pixel error xerr = " << xerr << "\n\n";
0420 
0421   if (!(yerr > 0.0))
0422     throw cms::Exception("PixelCPEGeneric::localError") << "\nERROR: Negative pixel error yerr = " << yerr << "\n\n";
0423 #endif
0424 
0425   LogDebug("PixelCPEGeneric") << " errors  " << xerr << " " << yerr;  //dk
0426   if (theClusterParam.qBin_ == 0)
0427     LogDebug("PixelCPEGeneric") << " qbin 0 " << xerr << " " << yerr;
0428 
0429   auto xerr_sq = xerr * xerr;
0430   auto yerr_sq = yerr * yerr;
0431 
0432   return LocalError(xerr_sq, 0, yerr_sq);
0433 }
0434 
0435 void PixelCPEGeneric::fillPSetDescription(edm::ParameterSetDescription& desc) {
0436   PixelCPEGenericBase::fillPSetDescription(desc);
0437   desc.add<double>("eff_charge_cut_highX", 1.0);
0438   desc.add<double>("eff_charge_cut_highY", 1.0);
0439   desc.add<double>("eff_charge_cut_lowX", 0.0);
0440   desc.add<double>("eff_charge_cut_lowY", 0.0);
0441   desc.add<double>("size_cutX", 3.0);
0442   desc.add<double>("size_cutY", 3.0);
0443   desc.add<double>("EdgeClusterErrorX", 50.0);
0444   desc.add<double>("EdgeClusterErrorY", 85.0);
0445   desc.add<bool>("inflate_errors", false);
0446   desc.add<bool>("inflate_all_errors_no_trk_angle", false);
0447   desc.add<bool>("NoTemplateErrorsWhenNoTrkAngles", false);
0448   desc.add<bool>("UseErrorsFromTemplates", true);
0449   desc.add<bool>("TruncatePixelCharge", true);
0450   desc.add<bool>("IrradiationBiasCorrection", false);
0451   desc.add<bool>("DoCosmics", false);
0452   desc.add<bool>("isPhase2", false);
0453   desc.add<bool>("SmallPitch", false);
0454 }
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.2.1 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!