CMS 3D CMS Logo

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Pages
PixelCPEBase.cc
Go to the documentation of this file.
1 // Move geomCorrection to the concrete class. d.k. 06/06.
2 // Change drift direction. d.k. 06/06
3 
4 // G. Giurgiu (ggiurgiu@pha.jhu.edu), 12/01/06, implemented the function:
5 // computeAnglesFromDetPosition(const SiPixelCluster & cl,
6 // const GeomDetUnit & det ) const
7 // 09/09/07, replaced assert statements with throw cms::Exception
8 // and fix an invalid pointer check in setTheDet function
9 // 09/21/07, implement caching of Lorentz drift direction
10 // 01/24/09, use atan2 to get the alpha and beta angles
11 // change to use Lorentz angle from DB Lotte Wilke, Jan. 31st, 2008
12 // Change to use Generic error & Template calibration from DB - D.Fehling 11/08
13 
14 
18 
20 
21 //#define TPDEBUG
22 #define CORRECT_FOR_BIG_PIXELS
23 
24 // MessageLogger
26 
27 // Magnetic field
29 
33 
34 #include <iostream>
35 
36 using namespace std;
37 
38 const float PI = 3.141593;
39 const float degsPerRad = 57.29578;
40 
41 //-----------------------------------------------------------------------------
42 // A fairly boring constructor. All quantities are DetUnit-dependent, and
43 // will be initialized in setTheDet().
44 //-----------------------------------------------------------------------------
46  const SiPixelCPEGenericErrorParm * genErrorParm, const SiPixelTemplateDBObject * templateDBobject)
47  : theDet(nullptr), theTopol(nullptr), theRecTopol(nullptr), theParam(nullptr), nRecHitsTotal_(0), nRecHitsUsedEdge_(0),
48  probabilityX_(0.0), probabilityY_(0.0),
49  probabilityQ_(0.0), qBin_(0),
50  isOnEdge_(false), hasBadPixels_(false),
51  spansTwoROCs_(false), hasFilledProb_(false),
52  loc_trk_pred_(0.0, 0.0, 0.0, 0.0)
53 {
54  //--- Lorentz angle tangent per Tesla
55 
56  lorentzAngle_ = lorentzAngle;
57 
58  //--- Algorithm's verbosity
60  conf.getUntrackedParameter<int>("VerboseLevel",0);
61 
62  //-- Magnetic Field
63  magfield_ = mag;
64 
65  //-- Error Parametriaztion from DB for CPE Generic
66  genErrorParm_ = genErrorParm;
67 
68  //-- Template Calibration Object from DB
69  templateDBobject_ = templateDBobject;
70 
71  //-- Switch on/off E.B
72  alpha2Order = conf.getParameter<bool>("Alpha2Order");
73 
74  //--- A flag that could be used to change the behavior of
75  //--- clusterProbability() in TSiPixelRecHit (the *transient* one).
76  //--- The problem is that the transient hits are made after the CPE runs
77  //--- and they don't get the access to the PSet, so we pass it via the
78  //--- CPE itself...
79  //
81  = (unsigned int) conf.getParameter<int>("ClusterProbComputationFlag");
82 
83 }
84 
85 //-----------------------------------------------------------------------------
86 // One function to cache the variables common for one DetUnit.
87 //-----------------------------------------------------------------------------
88 void
89 PixelCPEBase::setTheDet( const GeomDetUnit & det, const SiPixelCluster & cluster ) const
90 {
91  if ( theDet == &det )
92  return; // we have already seen this det unit
93 
94  //--- This is a new det unit, so cache it
95  theDet = dynamic_cast<const PixelGeomDetUnit*>( &det );
96 
97  if ( !theDet )
98  {
99  throw cms::Exception(" PixelCPEBase::setTheDet : ")
100  << " Wrong pointer to PixelGeomDetUnit object !!!";
101  }
102 
103  //--- theDet->type() returns a GeomDetType, which implements subDetector()
105  switch ( thePart )
106  {
108  // A barrel! A barrel!
109  break;
111  // A forward! A forward!
112  break;
113  default:
114  throw cms::Exception("PixelCPEBase::setTheDet :")
115  << "PixelCPEBase: A non-pixel detector type in here?" ;
116  }
117 
118  //--- The location in of this DetUnit in a cyllindrical coord system (R,Z)
119  //--- The call goes via BoundSurface, returned by theDet->surface(), but
120  //--- position() is implemented in GloballyPositioned<> template
121  //--- ( BoundSurface : Surface : GloballyPositioned<float> )
123  theDetZ = theDet->surface().position().z();
124  //--- Define parameters for chargewidth calculation
125 
126  //--- bounds() is implemented in BoundSurface itself.
128 
129  //--- Cache the topology.
130  // ggiurgiu@jhu.edu 12/09/2010 : no longer need to dynamyc cast to RectangularPixelTopology
131  //theTopol
132  //= dynamic_cast<const RectangularPixelTopology*>( & (theDet->specificTopology()) );
133 
134  auto topol = &(theDet->specificTopology());
135  if unlikely(topol!=theTopol) { // there is ONE topology!)
136  theTopol=topol;
137  auto const proxyT = dynamic_cast<const ProxyPixelTopology*>(theTopol);
138  if (proxyT) theRecTopol = dynamic_cast<const RectangularPixelTopology*>(&(proxyT->specificTopology()));
139  else theRecTopol = dynamic_cast<const RectangularPixelTopology*>(theTopol);
140  assert(theRecTopol);
141 
142  //---- The geometrical description of one module/plaquette
143  theNumOfRow = theRecTopol->nrows(); // rows in x
144  theNumOfCol = theRecTopol->ncolumns(); // cols in y
145  std::pair<float,float> pitchxy = theRecTopol->pitch();
146  thePitchX = pitchxy.first; // pitch along x
147  thePitchY = pitchxy.second; // pitch along y
148  }
149 
150  theSign = isFlipped() ? -1 : 1;
151 
152 
153  // will cache if not yest there (need some of the above)
154  theParam = &param();
155 
156  // this "has wrong sign..."
157  driftDirection_ = (*theParam).drift;
158 
159 
160  //--- The Lorentz shift.
162 
164 
165  // testing
167  //cout<<" lorentz shift "<<theLShiftX<<" "<<theLShiftY<<endl;
168  theLShiftY=0.;
169  }
170 
171  //--- Geometric Quality Information
172  int minInX,minInY,maxInX,maxInY=0;
173  minInX = cluster.minPixelRow();
174  minInY = cluster.minPixelCol();
175  maxInX = cluster.maxPixelRow();
176  maxInY = cluster.maxPixelCol();
177 
178  if(theRecTopol->isItEdgePixelInX(minInX) || theRecTopol->isItEdgePixelInX(maxInX) ||
179  theRecTopol->isItEdgePixelInY(minInY) || theRecTopol->isItEdgePixelInY(maxInY) ) {
180  isOnEdge_ = true;
181  }
182  else isOnEdge_ = false;
183 
184  // Bad Pixels have their charge set to 0 in the clusterizer
185  hasBadPixels_ = false;
186  for(unsigned int i=0; i<cluster.pixelADC().size(); ++i) {
187  if(cluster.pixelADC()[i] == 0) hasBadPixels_ = true;
188  }
189 
190  if(theRecTopol->containsBigPixelInX(minInX,maxInX) ||
191  theRecTopol->containsBigPixelInY(minInY,maxInY) ) {
192  spansTwoROCs_ = true;
193  }
194  else spansTwoROCs_ = false;
195 
196 
197  if (theVerboseLevel > 1)
198  {
199  LogDebug("PixelCPEBase") << "***** PIXEL LAYOUT *****"
200  << " thePart = " << thePart
201  << " theThickness = " << theThickness
202  << " thePitchX = " << thePitchX
203  << " thePitchY = " << thePitchY
204  // << " theOffsetX = " << theOffsetX
205  // << " theOffsetY = " << theOffsetY
206  << " theLShiftX = " << theLShiftX;
207  }
208 
209 }
210 
211 
212 //-----------------------------------------------------------------------------
213 // Compute alpha_ and beta_ from the LocalTrajectoryParameters.
214 // Note: should become const after both localParameters() become const.
215 //-----------------------------------------------------------------------------
216 void PixelCPEBase::
218  const GeomDetUnit & det,
219  const LocalTrajectoryParameters & ltp) const
220 {
221  loc_traj_param_ = ltp;
222 
223  LocalVector localDir = ltp.momentum()/ltp.momentum().mag();
224 
225  // &&& Or, maybe we need to move to the local frame ???
226  // LocalVector localDir( theDet->toLocal(theState.globalDirection()));
227  //thePart = theDet->type().part();
228 
229  float locx = localDir.x();
230  float locy = localDir.y();
231  float locz = localDir.z();
232 
233  /*
234  // Danek's definition
235  alpha_ = acos(locx/sqrt(locx*locx+locz*locz));
236  if ( isFlipped() ) // &&& check for FPIX !!!
237  alpha_ = PI - alpha_ ;
238  beta_ = acos(locy/sqrt(locy*locy+locz*locz));
239  */
240 
241  // &&& In the above, why not use atan2() ?
242  // ggiurgiu@fnal.gov, 01/24/09 : Use it now.
243  alpha_ = atan2( locz, locx );
244  beta_ = atan2( locz, locy );
245 
246  cotalpha_ = locx/locz;
247  cotbeta_ = locy/locz;
248 
249  LocalPoint trk_lp = ltp.position();
250  trk_lp_x = trk_lp.x();
251  trk_lp_y = trk_lp.y();
252 
253  with_track_angle = true;
254 
255 
256  // ggiurgiu@jhu.edu 12/09/2010 : needed to correct for bows/kinks
257  AlgebraicVector5 vec_trk_parameters = ltp.mixedFormatVector();
258  //loc_trk_pred = &Topology::LocalTrackPred( vec_trk_parameters );
259  loc_trk_pred_ = Topology::LocalTrackPred( vec_trk_parameters );
260 
261 }
262 
263 //-----------------------------------------------------------------------------
264 // Estimate theAlpha for barrel, based on the det position.
265 // &&& Needs to be consolidated from the above.
266 //-----------------------------------------------------------------------------
267 //float
268 //PixelCPEBase::estimatedAlphaForBarrel(float centerx) const
269 //{
270 // float tanalpha = theSign * (centerx-theOffsetX) * thePitchX / theDetR;
271 // return PI/2.0 - atan(tanalpha);
272 //}
273 
274 
275 //-----------------------------------------------------------------------------
276 // The local position.
277 // Should do correctly the big pixels.
278 // who is using this version????
279 //-----------------------------------------------------------------------------
282  const GeomDetUnit & det) const {
283  setTheDet( det, cluster );
284 
285  float lpx = xpos(cluster);
286  float lpy = ypos(cluster);
287  float lxshift = theLShiftX * thePitchX; // shift in cm
288  float lyshift = theLShiftY * thePitchY;
289  LocalPoint cdfsfs(lpx-lxshift, lpy-lyshift);
290  return cdfsfs;
291 }
292 
293 //-----------------------------------------------------------------------------
294 // Seems never used?
295 //-----------------------------------------------------------------------------
298  const GeomDetUnit & det) const {
299 
300  LocalPoint lp = localPosition(cluster,det);
301 
302  // ggiurgiu@jhu.edu 12/09/2010 : trk angles needed for bow/kink correction
303 
304  if ( with_track_angle )
306  else
307  return theTopol->measurementPosition( lp );
308 
309 }
310 
311 
312 //-----------------------------------------------------------------------------
313 // Once we have the position, feed it to the topology to give us
314 // the error.
315 // &&& APPARENTLY THIS METHOD IS NOT BEING USED ??? (Delete it?)
316 //-----------------------------------------------------------------------------
318 PixelCPEBase::measurementError( const SiPixelCluster& cluster, const GeomDetUnit & det) const
319 {
320  LocalPoint lp( localPosition(cluster, det) );
321  LocalError le( localError( cluster, det) );
322 
323  // ggiurgiu@jhu.edu 12/09/2010 : trk angles needed for bow/kink correction
324  if ( with_track_angle )
326  else
327  return theTopol->measurementError( lp, le );
328 }
329 
330 //-----------------------------------------------------------------------------
331 // Compute alpha_ and beta_ from the position of this DetUnit.
332 // &&& DOES NOT WORK FOR NOW. d.k. 6/06
333 // The angles from dets are calculated internaly in the PixelCPEInitial class
334 //-----------------------------------------------------------------------------
335 // G. Giurgiu, 12/01/06 : implement the function
336 void PixelCPEBase::
338  const GeomDetUnit & det ) const
339 {
340  //--- This is a new det unit, so cache it
341  theDet = dynamic_cast<const PixelGeomDetUnit*>( &det );
342  if ( ! theDet )
343  {
344  throw cms::Exception("PixelCPEBase::computeAngleFromDetPosition")
345  << " Wrong pointer to pixel detector !!!" << endl;
346 
347  }
348 
349  // get cluster center of gravity (of charge)
350  float xcenter = cl.x();
351  float ycenter = cl.y();
352 
353  // get the cluster position in local coordinates (cm)
354 
355  // ggiurgiu@jhu.edu 12/09/2010 : This function is called without track info, therefore there are no track
356  // angles to provide here. Call the default localPosition (without track info)
357  LocalPoint lp = theTopol->localPosition( MeasurementPoint(xcenter, ycenter) );
358 
359 
360  // get the cluster position in global coordinates (cm)
361  GlobalPoint gp = theDet->surface().toGlobal( lp );
362  float gp_mod = sqrt( gp.x()*gp.x() + gp.y()*gp.y() + gp.z()*gp.z() );
363 
364  // normalize
365  float gpx = gp.x()/gp_mod;
366  float gpy = gp.y()/gp_mod;
367  float gpz = gp.z()/gp_mod;
368 
369  // make a global vector out of the global point; this vector will point from the
370  // origin of the detector to the cluster
371  GlobalVector gv(gpx, gpy, gpz);
372 
373  // make local unit vector along local X axis
374  const Local3DVector lvx(1.0, 0.0, 0.0);
375 
376  // get the unit X vector in global coordinates/
377  GlobalVector gvx = theDet->surface().toGlobal( lvx );
378 
379  // make local unit vector along local Y axis
380  const Local3DVector lvy(0.0, 1.0, 0.0);
381 
382  // get the unit Y vector in global coordinates
383  GlobalVector gvy = theDet->surface().toGlobal( lvy );
384 
385  // make local unit vector along local Z axis
386  const Local3DVector lvz(0.0, 0.0, 1.0);
387 
388  // get the unit Z vector in global coordinates
389  GlobalVector gvz = theDet->surface().toGlobal( lvz );
390 
391  // calculate the components of gv (the unit vector pointing to the cluster)
392  // in the local coordinate system given by the basis {gvx, gvy, gvz}
393  // note that both gv and the basis {gvx, gvy, gvz} are given in global coordinates
394  float gv_dot_gvx = gv.x()*gvx.x() + gv.y()*gvx.y() + gv.z()*gvx.z();
395  float gv_dot_gvy = gv.x()*gvy.x() + gv.y()*gvy.y() + gv.z()*gvy.z();
396  float gv_dot_gvz = gv.x()*gvz.x() + gv.y()*gvz.y() + gv.z()*gvz.z();
397 
398 
399  /* all the above is equivalent to
400  const Local3DPoint origin = theDet->surface().toLocal(GlobalPoint(0,0,0)); // can be computed once...
401  auto gvx = lp.x()-origin.x();
402  auto gvy = lp.y()-origin.y();
403  auto gvz = -origin.z();
404  * normalization not required as only ratio used...
405  */
406 
407 
408  // calculate angles
409  alpha_ = atan2( gv_dot_gvz, gv_dot_gvx );
410  beta_ = atan2( gv_dot_gvz, gv_dot_gvy );
411 
412  cotalpha_ = gv_dot_gvx / gv_dot_gvz;
413  cotbeta_ = gv_dot_gvy / gv_dot_gvz;
414 
415  with_track_angle = false;
416 }
417 
418 
419 
420 //-----------------------------------------------------------------------------
421 // The isFlipped() is a silly way to determine which detectors are inverted.
422 // In the barrel for every 2nd ladder the E field direction is in the
423 // global r direction (points outside from the z axis), every other
424 // ladder has the E field inside. Something similar is in the
425 // forward disks (2 sides of the blade). This has to be recognised
426 // because the charge sharing effect is different.
427 //
428 // The isFliped does it by looking and the relation of the local (z always
429 // in the E direction) to global coordinates. There is probably a much
430 // better way.
431 //-----------------------------------------------------------------------------
433 {
434  // Check the relative position of the local +/- z in global coordinates.
435  float tmp1 = theDet->surface().toGlobal(Local3DPoint(0.,0.,0.)).perp2();
436  float tmp2 = theDet->surface().toGlobal(Local3DPoint(0.,0.,1.)).perp2();
437  //cout << " 1: " << tmp1 << " 2: " << tmp2 << endl;
438  if ( tmp2<tmp1 ) return true;
439  else return false;
440 }
441 
444  if unlikely ( p.bz<-1.e10f ) {
446  p.drift = driftDirection(Bfield );
447  p.bz = Bfield.z();
448  }
449  return p;
450 }
451 
452 
453 //-----------------------------------------------------------------------------
454 // HALF OF the Lorentz shift (so for the full shift multiply by 2), and
455 // in the units of pitch. (So note these are neither local nor measurement
456 // units!)
457 //-----------------------------------------------------------------------------
459 {
461 
462  // max shift in cm
463  float xdrift = dir.x()/dir.z() * theThickness;
464  // express the shift in units of pitch,
465  // divide by 2 to get the average correction
466  float lshift = xdrift / (thePitchX*2.);
467 
468  return lshift;
469 
470 
471 }
472 
474 {
475 
477 
478  float ydrift = dir.y()/dir.z() * theThickness;
479  float lshift = ydrift / (thePitchY * 2.f);
480  return lshift;
481 
482 
483 }
484 
485 
486 //-----------------------------------------------------------------------------
487 // Drift direction.
488 // Works OK for barrel and forward.
489 // The formulas used for dir_x,y,z have to be exactly the same as the ones
490 // used in the digitizer (SiPixelDigitizerAlgorithm.cc).
491 // Assumption: setTheDet() has been called already.
492 //
493 // Petar (2/23/07): uhm, actually, there is a bug in the sign for both X and Y!
494 // (The signs have been fixed in SiPixelDigitizer, but not in here.)
495 //-----------------------------------------------------------------------------
498 
499  Frame detFrame(theDet->surface().position(), theDet->surface().rotation());
500  LocalVector Bfield = detFrame.toLocal(bfield);
501  return driftDirection(Bfield);
502 
503 }
504 
507 
508  if(lorentzAngle_ == 0){
509  throw cms::Exception("invalidPointer") << "[PixelCPEBase::driftDirection] zero pointer to lorentz angle record ";
510  }
512  float alpha2;
513  if (alpha2Order) {
514  alpha2 = langle*langle;
515  } else {
516  alpha2 = 0.0;
517  }
518  // &&& dir_x should have a "-" and dir_y a "+"
519  // **********************************************************************
520  // Our convention is the following:
521  // +x is defined by the direction of the Lorentz drift!
522  // +z is defined by the direction of E field (so electrons always go into -z!)
523  // +y is defined by +x and +z, and it turns out to be always opposite to the +B field.
524  // **********************************************************************
525 
526  float dir_x = ( langle * Bfield.y() + alpha2* Bfield.z()* Bfield.x() );
527  float dir_y = -( langle * Bfield.x() - alpha2* Bfield.z()* Bfield.y() );
528  float dir_z = -( 1.f + alpha2* Bfield.z()*Bfield.z() );
529  double scale = 1.f/std::abs( dir_z ); // same as 1 + alpha2*Bfield.z()*Bfield.z()
530  LocalVector dd(dir_x*scale, dir_y*scale, -1.f ); // last is -1 !
531  if ( theVerboseLevel > 9 )
532  LogDebug("PixelCPEBase") << " The drift direction in local coordinate is "
533  << dd ;
534 
535  return dd;
536 }
537 
538 //-----------------------------------------------------------------------------
539 // One-shot computation of the driftDirection and both lorentz shifts
540 //-----------------------------------------------------------------------------
541 void
543 {
544  // this "has wrong sign..." so "corrected below
546 
547  // Max shift (at the other side of the sensor) in cm
549  // Express the shift in units of pitch,
551 
552  // Max shift (at the other side of the sensor) in cm
554  // Express the shift in units of pitch,
556 
557 
558  if ( theVerboseLevel > 9 ) {
559  LogDebug("PixelCPEBase") << " The drift direction in local coordinate is "
560  << driftDirection_ ;
561 
562  }
563 }
564 
565 //-----------------------------------------------------------------------------
570 //-----------------------------------------------------------------------------
573 {
575 
577  qualWord );
578 
580  qualWord );
581 
583  qualWord );
584 
586  qualWord );
587 
589  qualWord );
590 
592  qualWord );
593 
595  qualWord );
596 
597  return qualWord;
598 }
#define LogDebug(id)
double lorentzShiftX_
Definition: PixelCPEBase.h:253
GlobalPoint toGlobal(const Point2DBase< Scalar, LocalTag > lp) const
Definition: Surface.h:114
T getParameter(std::string const &) const
T getUntrackedParameter(std::string const &, T const &) const
int i
Definition: DBlmapReader.cc:9
Topology::LocalTrackPred loc_trk_pred_
Definition: PixelCPEBase.h:276
PixelCPEBase(edm::ParameterSet const &conf, const MagneticField *mag=0, const SiPixelLorentzAngle *lorentzAngle=0, const SiPixelCPEGenericErrorParm *genErrorParm=0, const SiPixelTemplateDBObject *templateDBobject=0)
Definition: PixelCPEBase.cc:45
int minPixelCol() const
float theNumOfRow
Definition: PixelCPEBase.h:201
bool with_track_angle
Definition: PixelCPEBase.h:226
T perp() const
Definition: PV3DBase.h:72
void setIsOnEdge(bool flag, QualWordType &qualWord)
virtual LocalPoint localPosition(const MeasurementPoint &) const =0
#define PI
void setProbabilityXY(float prob, QualWordType &qualWord)
void setSpansTwoROCs(bool flag, QualWordType &qualWord)
LocalPoint position() const
Local x and y position coordinates.
virtual GlobalVector inTesla(const GlobalPoint &gp) const =0
Field value ad specified global point, in Tesla.
void setHasBadPixels(bool flag, QualWordType &qualWord)
T mag() const
The vector magnitude. Equivalent to sqrt(vec.mag2())
void computeAnglesFromDetPosition(const SiPixelCluster &cl, const GeomDetUnit &det) const
float theLShiftY
Definition: PixelCPEBase.h:206
float theThickness
Definition: PixelCPEBase.h:196
#define nullptr
unsigned int clusterProbComputationFlag_
Definition: PixelCPEBase.h:244
T y() const
Definition: PV3DBase.h:63
#define abs(x)
Definition: mlp_lapack.h:159
SiPixelRecHitQuality::QualWordType rawQualityWord() const
const Bounds & bounds() const
Definition: Surface.h:128
MeasurementError measurementError(const SiPixelCluster &, const GeomDetUnit &det) const
float probabilityQ_
Definition: PixelCPEBase.h:231
T perp2() const
Definition: PV3DBase.h:71
bool spansTwoROCs_
Definition: PixelCPEBase.h:235
GeomDetType::SubDetector thePart
Definition: PixelCPEBase.h:194
const Plane & surface() const
The nominal surface of the GeomDet.
Definition: GeomDet.h:35
virtual float ypos(const SiPixelCluster &) const =0
float theNumOfCol
Definition: PixelCPEBase.h:202
double lorentzShiftInCmY_
Definition: PixelCPEBase.h:256
int maxPixelRow() const
uint32_t rawId() const
get the raw id
Definition: DetId.h:45
virtual float thickness() const =0
#define unlikely(x)
Definition: Likely.h:21
void setProbabilityQ(float prob, QualWordType &qualWord)
LocalVector drift
Definition: PixelCPEBase.h:54
Measurement2DPoint MeasurementPoint
Measurement points are two-dimensional by default.
T mag() const
Definition: PV3DBase.h:67
int minPixelRow() const
virtual MeasurementError measurementError(const LocalPoint &, const LocalError &) const =0
bool hasBadPixels_
Definition: PixelCPEBase.h:234
LocalVector driftDirection_
Definition: PixelCPEBase.h:252
void computeLorentzShifts() const
bool isFlipped() const
void computeAnglesFromTrajectory(const SiPixelCluster &cl, const GeomDetUnit &det, const LocalTrajectoryParameters &ltp) const
Param const & param() const
T sqrt(T t)
Definition: SSEVec.h:48
LocalPoint toLocal(const GlobalPoint &gp) const
bool hasFilledProb_
Definition: PixelCPEBase.h:236
T z() const
Definition: PV3DBase.h:64
LocalVector driftDirection(GlobalVector bfield) const
double lorentzShiftInCmX_
Definition: PixelCPEBase.h:255
const SiPixelTemplateDBObject * templateDBobject_
Definition: PixelCPEBase.h:269
MeasurementPoint measurementPosition(const SiPixelCluster &cluster, const GeomDetUnit &det) const
DetId geographicalId() const
The label of this GeomDet.
Definition: GeomDet.h:72
double f[11][100]
const MagneticField * magfield_
Definition: PixelCPEBase.h:263
virtual MeasurementPoint measurementPosition(const LocalPoint &) const =0
LocalVector momentum() const
Momentum vector in the local frame.
const std::vector< uint16_t > & pixelADC() const
tuple conf
Definition: dbtoconf.py:185
virtual LocalError localError(const SiPixelCluster &cl, const GeomDetUnit &det) const =0
Point3DBase< float, LocalTag > Local3DPoint
Definition: LocalPoint.h:9
void setHasFilledProb(bool flag, QualWordType &qualWord)
const RectangularPixelTopology * theRecTopol
Definition: PixelCPEBase.h:190
ROOT::Math::SVector< double, 5 > AlgebraicVector5
LocalTrajectoryParameters loc_traj_param_
Definition: PixelCPEBase.h:278
const SiPixelLorentzAngle * lorentzAngle_
Definition: PixelCPEBase.h:265
virtual const PixelTopology & specificTopology() const
Returns a reference to the pixel proxy topology.
const PixelTopology * theTopol
Definition: PixelCPEBase.h:189
int maxPixelCol() const
AlgebraicVector5 mixedFormatVector() const
void setTheDet(const GeomDetUnit &det, const SiPixelCluster &cluster) const
Definition: PixelCPEBase.cc:89
float lorentzShiftX() const
Pixel cluster – collection of neighboring pixels above threshold.
LocalVector const & getDrift() const
Definition: PixelCPEBase.h:319
float probabilityXY() const
Definition: PixelCPEBase.h:141
float getLorentzAngle(const uint32_t &) const
float y() const
const RotationType & rotation() const
Params m_Params
Definition: PixelCPEBase.h:328
virtual const GeomDetType & type() const
void setQBin(int qbin, QualWordType &qualWord)
dbl *** dir
Definition: mlp_gen.cc:35
const PixelGeomDetUnit * theDet
Definition: PixelCPEBase.h:185
Param const * theParam
Definition: PixelCPEBase.h:192
float theLShiftX
Definition: PixelCPEBase.h:205
double lorentzShiftY_
Definition: PixelCPEBase.h:254
float lorentzShiftY() const
T x() const
Definition: PV3DBase.h:62
const float degsPerRad
Definition: PixelCPEBase.cc:39
const PositionType & position() const
virtual LocalPoint localPosition(const SiPixelCluster &cl, const GeomDetUnit &det) const
float x() const
SubDetector subDetector() const
Definition: GeomDetType.h:22
const SiPixelCPEGenericErrorParm * genErrorParm_
Definition: PixelCPEBase.h:267
virtual float xpos(const SiPixelCluster &) const =0