CMS 3D CMS Logo
List of all members | Public Types | Public Member Functions | Static Public Member Functions | Private Member Functions | Private Attributes
PixelCPEFastParamsHost< TrackerTraits > Class Template Reference

#include <PixelCPEFastParamsHost.h>

Inheritance diagram for PixelCPEFastParamsHost< TrackerTraits >:
PixelCPEGenericBase PixelCPEBase PixelClusterParameterEstimator

Public Types

using Buffer = cms::alpakatools::host_buffer< pixelCPEforDevice::ParamsOnDeviceT< TrackerTraits > >
 
using ConstBuffer = cms::alpakatools::const_host_buffer< pixelCPEforDevice::ParamsOnDeviceT< TrackerTraits > >
 
- Public Types inherited from PixelClusterParameterEstimator
typedef std::pair< LocalPoint, LocalError > LocalValues
 
using ReturnType = std::tuple< LocalPoint, LocalError, SiPixelRecHitQuality::QualWordType >
 
typedef std::vector< LocalValues > VLocalValues
 

Public Member Functions

Buffer buffer ()
 
ConstBuffer buffer () const
 
ConstBuffer const_buffer () const
 
pixelCPEforDevice::ParamsOnDeviceT< TrackerTraits > const * data () const
 
PixelCPEFastParamsHost & operator= (PixelCPEFastParamsHost const &)=delete
 
PixelCPEFastParamsHost & operator= (PixelCPEFastParamsHost &&)=default
 
 PixelCPEFastParamsHost (edm::ParameterSet const &conf, const MagneticField *mag, const TrackerGeometry &geom, const TrackerTopology &ttopo, const SiPixelLorentzAngle *lorentzAngle, const SiPixelGenErrorDBObject *genErrorDBObject, const SiPixelLorentzAngle *lorentzAngleWidth)
 The constructor. More...
 
 PixelCPEFastParamsHost (PixelCPEFastParamsHost const &)=delete
 
 PixelCPEFastParamsHost (PixelCPEFastParamsHost &&)=default
 
auto size () const
 
 ~PixelCPEFastParamsHost () override=default
 
- Public Member Functions inherited from PixelCPEGenericBase
 PixelCPEGenericBase (edm::ParameterSet const &conf, const MagneticField *mag, const TrackerGeometry &geom, const TrackerTopology &ttopo, const SiPixelLorentzAngle *lorentzAngle, const SiPixelGenErrorDBObject *genErrorDBObject, const SiPixelLorentzAngle *lorentzAngleWidth)
 
 ~PixelCPEGenericBase () override=default
 
- Public Member Functions inherited from PixelCPEBase
ReturnType getParameters (const SiPixelCluster &cl, const GeomDetUnit &det) const override
 
ReturnType getParameters (const SiPixelCluster &cl, const GeomDetUnit &det, const LocalTrajectoryParameters &ltp) const override
 
 PixelCPEBase (edm::ParameterSet const &conf, const MagneticField *mag, const TrackerGeometry &geom, const TrackerTopology &ttopo, const SiPixelLorentzAngle *lorentzAngle, const SiPixelGenErrorDBObject *genErrorDBObject, const SiPixelTemplateDBObject *templateDBobject, const SiPixelLorentzAngle *lorentzAngleWidth, int flag=0)
 
- Public Member Functions inherited from PixelClusterParameterEstimator
unsigned int clusterProbComputationFlag () const
 
virtual ReturnType getParameters (const SiPixelCluster &cl, const GeomDetUnit &det, const TrajectoryStateOnSurface &tsos) const
 
virtual VLocalValues localParametersV (const SiPixelCluster &cluster, const GeomDetUnit &gd) const
 
virtual VLocalValues localParametersV (const SiPixelCluster &cluster, const GeomDetUnit &gd, TrajectoryStateOnSurface &tsos) const
 
 PixelClusterParameterEstimator ()
 
virtual ~PixelClusterParameterEstimator ()
 

Static Public Member Functions

static void fillPSetDescription (edm::ParameterSetDescription &desc)
 
- Static Public Member Functions inherited from PixelCPEGenericBase
static void fillPSetDescription (edm::ParameterSetDescription &desc)
 
- Static Public Member Functions inherited from PixelCPEBase
static void fillPSetDescription (edm::ParameterSetDescription &desc)
 

Private Member Functions

void errorFromTemplates (DetParam const &theDetParam, ClusterParamGeneric &theClusterParam, float qclus) const
 
void fillParamsForDevice ()
 
LocalError localError (DetParam const &theDetParam, ClusterParam &theClusterParam) const override
 
LocalPoint localPosition (DetParam const &theDetParam, ClusterParam &theClusterParam) const override
 

Private Attributes

Buffer buffer_
 
std::vector< SiPixelGenErrorStore > thePixelGenError_
 

Additional Inherited Members

- Protected Types inherited from PixelCPEBase
using DetParams = std::vector< DetParam >
 
typedef GloballyPositioned< double > Frame
 
- Protected Member Functions inherited from PixelCPEGenericBase
std::unique_ptr< ClusterParam > createClusterParam (const SiPixelCluster &cl) const override
 
void initializeLocalErrorVariables (float &xerr, float &yerr, bool &edgex, bool &edgey, bool &bigInX, bool &bigInY, int &maxPixelCol, int &maxPixelRow, int &minPixelCol, int &minPixelRow, uint &sizex, uint &sizey, DetParam const &theDetParam, ClusterParamGeneric const &theClusterParam) const
 
void setXYErrors (float &xerr, float &yerr, const bool edgex, const bool edgey, const unsigned int sizex, const unsigned int sizey, const bool bigInX, const bool bigInY, const bool useTemplateErrors, DetParam const &theDetParam, ClusterParamGeneric const &theClusterParam) const
 
- Protected Member Functions inherited from PixelCPEBase
void computeAnglesFromDetPosition (DetParam const &theDetParam, ClusterParam &theClusterParam) const
 
void computeAnglesFromTrajectory (DetParam const &theDetParam, ClusterParam &theClusterParam, const LocalTrajectoryParameters &ltp) const
 
void computeLorentzShifts (DetParam &) const
 
DetParam const & detParam (const GeomDetUnit &det) const
 
LocalVector driftDirection (DetParam &theDetParam, GlobalVector bfield) const
 
LocalVector driftDirection (DetParam &theDetParam, LocalVector bfield) const
 
void setTheClu (DetParam const &, ClusterParam &theClusterParam) const
 
- Static Protected Member Functions inherited from PixelCPEGenericBase
static void collect_edge_charges (ClusterParam &theClusterParam, int &q_f_X, int &q_l_X, int &q_f_Y, int &q_l_Y, bool truncate)
 
- Protected Attributes inherited from PixelCPEGenericBase
const float edgeClusterErrorX_
 
const float edgeClusterErrorY_
 
const bool truncatePixelCharge_
 
bool useErrorsFromTemplates_
 
const std::vector< float > xerr_barrel_l1_
 
const float xerr_barrel_l1_def_
 
const std::vector< float > xerr_barrel_ln_
 
const float xerr_barrel_ln_def_
 
const std::vector< float > xerr_endcap_
 
const float xerr_endcap_def_
 
const std::vector< float > yerr_barrel_l1_
 
const float yerr_barrel_l1_def_
 
const std::vector< float > yerr_barrel_ln_
 
const float yerr_barrel_ln_def_
 
const std::vector< float > yerr_endcap_
 
const float yerr_endcap_def_
 
- Protected Attributes inherited from PixelCPEBase
bool alpha2Order
 
bool doLorentzFromAlignment_
 
const SiPixelGenErrorDBObject * genErrorDBObject_
 
const TrackerGeometry & geom_
 
float lAOffset_
 
float lAWidthBPix_
 
float lAWidthFPix_
 
bool LoadTemplatesFromDB_
 
const SiPixelLorentzAngle * lorentzAngle_
 
const SiPixelLorentzAngle * lorentzAngleWidth_
 
DetParams m_DetParams = DetParams(1440)
 
const MagneticField * magfield_
 
const SiPixelTemplateDBObject * templateDBobject_
 
int theFlag_
 
int theVerboseLevel
 
const TrackerTopology & ttopo_
 
bool useLAFromDB_
 
bool useLAOffsetFromConfig_
 
bool useLAWidthFromConfig_
 
bool useLAWidthFromDB_
 
- Protected Attributes inherited from PixelClusterParameterEstimator
unsigned int clusterProbComputationFlag_
 
- Static Protected Attributes inherited from PixelCPEBase
static constexpr float bothEdgeXError_ = 31.0f
 
static constexpr float bothEdgeYError_ = 90.0f
 
static constexpr float clusterSplitMaxError_ = 7777.7f
 
static constexpr float xEdgeXError_ = 23.0f
 
static constexpr float xEdgeYError_ = 39.0f
 
static constexpr float yEdgeXError_ = 24.0f
 
static constexpr float yEdgeYError_ = 96.0f
 

Detailed Description

template<typename TrackerTraits>
class PixelCPEFastParamsHost< TrackerTraits >

Definition at line 18 of file PixelCPEFastParamsHost.h.

Member Typedef Documentation

◆ Buffer

template<typename TrackerTraits>
using PixelCPEFastParamsHost< TrackerTraits >::Buffer = cms::alpakatools::host_buffer<pixelCPEforDevice::ParamsOnDeviceT<TrackerTraits> >

Definition at line 20 of file PixelCPEFastParamsHost.h.

◆ ConstBuffer

template<typename TrackerTraits>
using PixelCPEFastParamsHost< TrackerTraits >::ConstBuffer = cms::alpakatools::const_host_buffer<pixelCPEforDevice::ParamsOnDeviceT<TrackerTraits> >

Definition at line 21 of file PixelCPEFastParamsHost.h.

Constructor & Destructor Documentation

◆ PixelCPEFastParamsHost() [1/3]

template<typename TrackerTraits >
PixelCPEFastParamsHost< TrackerTraits >::PixelCPEFastParamsHost ( edm::ParameterSet const &  conf,
const MagneticField *  mag,
const TrackerGeometry &  geom,
const TrackerTopology &  ttopo,
const SiPixelLorentzAngle *  lorentzAngle,
const SiPixelGenErrorDBObject *  genErrorDBObject,
const SiPixelLorentzAngle *  lorentzAngleWidth 
)

The constructor.

Definition at line 17 of file PixelCPEFastParamsHost.cc.

References Exception, PixelCPEFastParamsHost< TrackerTraits >::fillParamsForDevice(), PixelCPEBase::genErrorDBObject_, SiPixelGenError::pushfile(), PixelCPEFastParamsHost< TrackerTraits >::thePixelGenError_, and PixelCPEGenericBase::useErrorsFromTemplates_.

24  : PixelCPEGenericBase(conf, mag, geom, ttopo, lorentzAngle, genErrorDBObject, lorentzAngleWidth),
25  buffer_(cms::alpakatools::make_host_buffer<pixelCPEforDevice::ParamsOnDeviceT<TrackerTraits>>()) {
26  // Use errors from templates or from GenError
27  if (useErrorsFromTemplates_) {
28  if (!SiPixelGenError::pushfile(*genErrorDBObject_, this->thePixelGenError_))
29  throw cms::Exception("InvalidCalibrationLoaded")
30  << "ERROR: GenErrors not filled correctly. Check the sqlite file. Using SiPixelTemplateDBObject version "
31  << (*genErrorDBObject_).version();
32  }
33 
34  fillParamsForDevice();
35 }
SiPixelGenError::pushfile
static bool pushfile(int filenum, std::vector< SiPixelGenErrorStore > &pixelTemp, std::string dir="")
Definition: SiPixelGenError.cc:55
PixelCPEFastParamsHost::thePixelGenError_
std::vector< SiPixelGenErrorStore > thePixelGenError_
Definition: PixelCPEFastParamsHost.h:59
cms::alpakatools::make_host_buffer
std::enable_if_t< not std::is_array_v< T >, host_buffer< T > > make_host_buffer()
Definition: memory.h:65
PixelCPEGenericBase::PixelCPEGenericBase
PixelCPEGenericBase(edm::ParameterSet const &conf, const MagneticField *mag, const TrackerGeometry &geom, const TrackerTopology &ttopo, const SiPixelLorentzAngle *lorentzAngle, const SiPixelGenErrorDBObject *genErrorDBObject, const SiPixelLorentzAngle *lorentzAngleWidth)
Definition: PixelCPEGenericBase.cc:11
mag
T mag() const
The vector magnitude. Equivalent to sqrt(vec.mag2())
Definition: Basic3DVectorLD.h:130
PixelCPEBase::genErrorDBObject_
const SiPixelGenErrorDBObject * genErrorDBObject_
Definition: PixelCPEBase.h:236

◆ PixelCPEFastParamsHost() [2/3]

template<typename TrackerTraits>
PixelCPEFastParamsHost< TrackerTraits >::PixelCPEFastParamsHost ( PixelCPEFastParamsHost< TrackerTraits > const &  )
delete

◆ PixelCPEFastParamsHost() [3/3]

template<typename TrackerTraits>
PixelCPEFastParamsHost< TrackerTraits >::PixelCPEFastParamsHost ( PixelCPEFastParamsHost< TrackerTraits > &&  )
default

◆ ~PixelCPEFastParamsHost()

template<typename TrackerTraits>
PixelCPEFastParamsHost< TrackerTraits >::~PixelCPEFastParamsHost ( )
overridedefault

Member Function Documentation

◆ buffer() [1/2]

template<typename TrackerTraits>
Buffer PixelCPEFastParamsHost< TrackerTraits >::buffer ( )
inline

Definition at line 43 of file PixelCPEFastParamsHost.h.

References PixelCPEFastParamsHost< TrackerTraits >::buffer_.

Referenced by cms::alpakatools::CopyToDevice< PixelCPEFastParamsHost< TrackerTraits > >::copyAsync().

43 { return buffer_; }

◆ buffer() [2/2]

template<typename TrackerTraits>
ConstBuffer PixelCPEFastParamsHost< TrackerTraits >::buffer ( ) const
inline

Definition at line 44 of file PixelCPEFastParamsHost.h.

References PixelCPEFastParamsHost< TrackerTraits >::buffer_.

44 { return buffer_; }

◆ const_buffer()

template<typename TrackerTraits>
ConstBuffer PixelCPEFastParamsHost< TrackerTraits >::const_buffer ( ) const
inline

Definition at line 45 of file PixelCPEFastParamsHost.h.

References PixelCPEFastParamsHost< TrackerTraits >::buffer_.

45 { return buffer_; }

◆ data()

template<typename TrackerTraits>
pixelCPEforDevice::ParamsOnDeviceT<TrackerTraits> const* PixelCPEFastParamsHost< TrackerTraits >::data ( ) const
inline

Definition at line 49 of file PixelCPEFastParamsHost.h.

References PixelCPEFastParamsHost< TrackerTraits >::buffer_.

49 { return buffer_.data(); }

◆ errorFromTemplates()

template<typename TrackerTraits >
void PixelCPEFastParamsHost< TrackerTraits >::errorFromTemplates ( DetParam const &  theDetParam,
ClusterParamGeneric &  theClusterParam,
float  qclus 
) const
private

Definition at line 349 of file PixelCPEFastParamsHost.cc.

References PixelCPEBase::DetParam::bx, PixelCPEBase::DetParam::bz, PixelCPEBase::ClusterParam::cotalpha, PixelCPEBase::ClusterParam::cotbeta, PixelCPEBase::DetParam::detTemplateId, LogDebug, SiStripPI::max, pixelCPEforDevice::micronsToCm, PixelCPEGenericBase::ClusterParamGeneric::pixmx, SiPixelGenError::qbin(), PixelCPEBase::ClusterParam::qBin_, PixelCPEGenericBase::ClusterParamGeneric::sigmax, PixelCPEGenericBase::ClusterParamGeneric::sigmay, PixelCPEGenericBase::ClusterParamGeneric::sx1, PixelCPEGenericBase::ClusterParamGeneric::sx2, PixelCPEGenericBase::ClusterParamGeneric::sy1, and PixelCPEGenericBase::ClusterParamGeneric::sy2.

351  {
352  float locBz = theDetParam.bz;
353  float locBx = theDetParam.bx;
354  LogDebug("PixelCPEFastParamsHost") << "PixelCPEFastParamsHost::localPosition(...) : locBz = " << locBz;
355 
356  theClusterParam.pixmx = std::numeric_limits<int>::max(); // max pixel charge for truncation of 2-D cluster
357 
358  theClusterParam.sigmay = -999.9; // CPE Generic y-error for multi-pixel cluster
359  theClusterParam.sigmax = -999.9; // CPE Generic x-error for multi-pixel cluster
360  theClusterParam.sy1 = -999.9; // CPE Generic y-error for single single-pixel
361  theClusterParam.sy2 = -999.9; // CPE Generic y-error for single double-pixel cluster
362  theClusterParam.sx1 = -999.9; // CPE Generic x-error for single single-pixel cluster
363  theClusterParam.sx2 = -999.9; // CPE Generic x-error for single double-pixel cluster
364 
365  float dummy;
366 
367  SiPixelGenError gtempl(this->thePixelGenError_);
368  int gtemplID = theDetParam.detTemplateId;
369 
370  theClusterParam.qBin_ = gtempl.qbin(gtemplID,
371  theClusterParam.cotalpha,
372  theClusterParam.cotbeta,
373  locBz,
374  locBx,
375  qclus,
376  false,
377  theClusterParam.pixmx,
378  theClusterParam.sigmay,
379  dummy,
380  theClusterParam.sigmax,
381  dummy,
382  theClusterParam.sy1,
383  dummy,
384  theClusterParam.sy2,
385  dummy,
386  theClusterParam.sx1,
387  dummy,
388  theClusterParam.sx2,
389  dummy);
390 
391  theClusterParam.sigmax = theClusterParam.sigmax * pixelCPEforDevice::micronsToCm;
392  theClusterParam.sx1 = theClusterParam.sx1 * pixelCPEforDevice::micronsToCm;
393  theClusterParam.sx2 = theClusterParam.sx2 * pixelCPEforDevice::micronsToCm;
394 
395  theClusterParam.sigmay = theClusterParam.sigmay * pixelCPEforDevice::micronsToCm;
396  theClusterParam.sy1 = theClusterParam.sy1 * pixelCPEforDevice::micronsToCm;
397  theClusterParam.sy2 = theClusterParam.sy2 * pixelCPEforDevice::micronsToCm;
398 }
PixelCPEFastParamsHost::thePixelGenError_
std::vector< SiPixelGenErrorStore > thePixelGenError_
Definition: PixelCPEFastParamsHost.h:59
pixelCPEforDevice::micronsToCm
constexpr float micronsToCm
Definition: pixelCPEforDevice.h:26
LogDebug
#define LogDebug(id)
Definition: MessageLogger.h:241

◆ fillParamsForDevice()

template<typename TrackerTraits >
void PixelCPEFastParamsHost< TrackerTraits >::fillParamsForDevice ( )
private

Definition at line 38 of file PixelCPEFastParamsHost.cc.

References funct::abs(), cms::cuda::assert(), ALPAKA_ACCELERATOR_NAMESPACE::brokenline::constexpr(), CommonMethods::cp(), f, nano_mu_digi_cff::float, g, mps_fire::i, createfilelist::int, GeomDetEnumerators::isBarrel(), ALPAKA_ACCELERATOR_NAMESPACE::ecal::reconstruction::internal::endcap::ix(), ALPAKA_ACCELERATOR_NAMESPACE::ecal::reconstruction::internal::endcap::iy(), dqmdumpme::k, pixelCPEforDevice::kGenErrorQBins, GetRecoTauVFromDQM_MC_cff::kk, pixelCPEforDevice::kNumErrorBins, PVValHelper::ladder, phase1PixelTopology::layerStart, LogDebug, visualization-live-secondInstance_cfg::m, SiStripPI::max, SiStripPI::min, phase1PixelTopology::numberOfModules, AlCaHLTBitMon_ParallelJobs::p, findQualityFiles::rr, mathSSE::sqrt(), Calorimetry_cff::thickness, mitigatedMETSequence_cff::U, x, detailsBasic3DVector::y, detailsBasic3DVector::z, and SOAFrame< T >::z().

Referenced by PixelCPEFastParamsHost< TrackerTraits >::PixelCPEFastParamsHost().

38  {
39  // this code executes only once per job, computation inefficiency is not an issue
40  // many code blocks are repeated: better keep the computation local and self consistent as blocks may in future move around, be deleted ...
41  // It is valid only for Phase1 and the version of GenError in DB used in late 2018 and in 2021
42 
43  buffer_->commonParams().theThicknessB = m_DetParams.front().theThickness;
44  buffer_->commonParams().theThicknessE = m_DetParams.back().theThickness;
45  buffer_->commonParams().thePitchX = m_DetParams[0].thePitchX;
46  buffer_->commonParams().thePitchY = m_DetParams[0].thePitchY;
47 
48  buffer_->commonParams().numberOfLaddersInBarrel = TrackerTraits::numberOfLaddersInBarrel;
49 
50  LogDebug("PixelCPEFastParamsHost") << "pitch & thickness " << buffer_->commonParams().thePitchX << ' '
51  << buffer_->commonParams().thePitchY << " "
52  << buffer_->commonParams().theThicknessB << ' '
53  << buffer_->commonParams().theThicknessE;
54 
55  // zero average geometry
56  memset(&buffer_->averageGeometry(), 0, sizeof(pixelTopology::AverageGeometryT<TrackerTraits>));
57 
58  uint32_t oldLayer = 0;
59  uint32_t oldLadder = 0;
60  float rl = 0;
61  float zl = 0;
62  float miz = 500, mxz = 0;
63  float pl = 0;
64  int nl = 0;
65 
66  assert(m_DetParams.size() <= TrackerTraits::numberOfModules);
67  for (auto i = 0U; i < m_DetParams.size(); ++i) {
68  auto& p = m_DetParams[i];
69  auto& g = buffer_->detParams(i);
70 
71  g.nRowsRoc = p.theDet->specificTopology().rowsperroc();
72  g.nColsRoc = p.theDet->specificTopology().colsperroc();
73  g.nRows = p.theDet->specificTopology().rocsX() * g.nRowsRoc;
74  g.nCols = p.theDet->specificTopology().rocsY() * g.nColsRoc;
75 
76  g.numPixsInModule = g.nRows * g.nCols;
77 
78  assert(p.theDet->index() == int(i));
79  assert(buffer_->commonParams().thePitchY == p.thePitchY);
80  assert(buffer_->commonParams().thePitchX == p.thePitchX);
81 
82  g.isBarrel = GeomDetEnumerators::isBarrel(p.thePart);
83  g.isPosZ = p.theDet->surface().position().z() > 0;
84  g.layer = ttopo_.layer(p.theDet->geographicalId());
85  g.index = i; // better be!
86  g.rawId = p.theDet->geographicalId();
87  auto thickness = g.isBarrel ? buffer_->commonParams().theThicknessB : buffer_->commonParams().theThicknessE;
88  assert(thickness == p.theThickness);
89 
90  auto ladder = ttopo_.pxbLadder(p.theDet->geographicalId());
91  if (oldLayer != g.layer) {
92  oldLayer = g.layer;
93  LogDebug("PixelCPEFastParamsHost") << "new layer at " << i << (g.isBarrel ? " B " : (g.isPosZ ? " E+ " : " E- "))
94  << g.layer << " starting at " << g.rawId << '\n'
95  << "old layer had " << nl << " ladders";
96  nl = 0;
97  }
98  if (oldLadder != ladder) {
99  oldLadder = ladder;
100  LogDebug("PixelCPEFastParamsHost") << "new ladder at " << i
101  << (g.isBarrel ? " B " : (g.isPosZ ? " E+ " : " E- ")) << ladder
102  << " starting at " << g.rawId << '\n'
103  << "old ladder ave z,r,p mz " << zl / 8.f << " " << rl / 8.f << " " << pl / 8.f
104  << ' ' << miz << ' ' << mxz;
105  rl = 0;
106  zl = 0;
107  pl = 0;
108  miz = 500;
109  mxz = 0;
110  nl++;
111  }
112 
113  g.shiftX = 0.5f * p.lorentzShiftInCmX;
114  g.shiftY = 0.5f * p.lorentzShiftInCmY;
115  g.chargeWidthX = p.lorentzShiftInCmX * p.widthLAFractionX;
116  g.chargeWidthY = p.lorentzShiftInCmY * p.widthLAFractionY;
117 
118  g.x0 = p.theOrigin.x();
119  g.y0 = p.theOrigin.y();
120  g.z0 = p.theOrigin.z();
121 
122  auto vv = p.theDet->surface().position();
123  auto rr = pixelCPEforDevice::Rotation(p.theDet->surface().rotation());
124  g.frame = pixelCPEforDevice::Frame(vv.x(), vv.y(), vv.z(), rr);
125 
126  zl += vv.z();
127  miz = std::min(miz, std::abs(vv.z()));
128  mxz = std::max(mxz, std::abs(vv.z()));
129  rl += vv.perp();
130  pl += vv.phi(); // (not obvious)
131 
132  // errors .....
133  ClusterParamGeneric cp;
134 
135  cp.with_track_angle = false;
136 
137  auto lape = p.theDet->localAlignmentError();
138  if (lape.invalid())
139  lape = LocalError(); // zero....
140 
141  g.apeXX = lape.xx();
142  g.apeYY = lape.yy();
143 
144  auto toMicron = [&](float x) { return std::min(511, int(x * 1.e4f + 0.5f)); };
145 
146  // average angle
147  auto gvx = p.theOrigin.x() + 40.f * buffer_->commonParams().thePitchX;
148  auto gvy = p.theOrigin.y();
149  auto gvz = 1.f / p.theOrigin.z();
150  //--- Note that the normalization is not required as only the ratio used
151 
152  {
153  // calculate angles (fed into errorFromTemplates)
154  cp.cotalpha = gvx * gvz;
155  cp.cotbeta = gvy * gvz;
156 
157  errorFromTemplates(p, cp, 20000.);
158  }
159 
160 #ifdef EDM_ML_DEBUG
161  auto m = 10000.f;
162  for (float qclus = 15000; qclus < 35000; qclus += 15000) {
163  errorFromTemplates(p, cp, qclus);
164  LogDebug("PixelCPEFastParamsHost") << i << ' ' << qclus << ' ' << cp.pixmx << ' ' << m * cp.sigmax << ' '
165  << m * cp.sx1 << ' ' << m * cp.sx2 << ' ' << m * cp.sigmay << ' ' << m * cp.sy1
166  << ' ' << m * cp.sy2;
167  }
168  LogDebug("PixelCPEFastParamsHost") << i << ' ' << m * std::sqrt(lape.xx()) << ' ' << m * std::sqrt(lape.yy());
169 #endif // EDM_ML_DEBUG
170 
171  g.pixmx = std::max(0, cp.pixmx);
172  g.sx2 = toMicron(cp.sx2);
173  g.sy1 = std::max(21, toMicron(cp.sy1)); // for some angles sy1 is very small
174  g.sy2 = std::max(55, toMicron(cp.sy2)); // sometimes sy2 is smaller than others (due to angle?)
175 
176  //sample xerr as function of position
177  // moduleOffsetX is the definition of TrackerTraits::xOffset,
178  // needs to be calculated because for Phase2 the modules are not uniform
179  float moduleOffsetX = -(0.5f * float(g.nRows) + TrackerTraits::bigPixXCorrection);
180  auto const xoff = moduleOffsetX * buffer_->commonParams().thePitchX;
181 
182  for (int ix = 0; ix < pixelCPEforDevice::kNumErrorBins; ++ix) {
183  auto x = xoff * (1.f - (0.5f + float(ix)) / 8.f);
184  auto gvx = p.theOrigin.x() - x;
185  auto gvy = p.theOrigin.y();
186  auto gvz = 1.f / p.theOrigin.z();
187  cp.cotbeta = gvy * gvz;
188  cp.cotalpha = gvx * gvz;
189  errorFromTemplates(p, cp, 20000.f);
190  g.sigmax[ix] = toMicron(cp.sigmax);
191  g.sigmax1[ix] = toMicron(cp.sx1);
192  LogDebug("PixelCPEFastParamsHost") << "sigmax vs x " << i << ' ' << x << ' ' << cp.cotalpha << ' '
193  << int(g.sigmax[ix]) << ' ' << int(g.sigmax1[ix]) << ' ' << 10000.f * cp.sigmay
194  << std::endl;
195  }
196 #ifdef EDM_ML_DEBUG
197  // sample yerr as function of position
198  // moduleOffsetY is the definition of TrackerTraits::yOffset (removed)
199  float moduleOffsetY = 0.5f * float(g.nCols) + TrackerTraits::bigPixYCorrection;
200  auto const yoff = -moduleOffsetY * buffer_->commonParams().thePitchY;
201 
202  for (int ix = 0; ix < pixelCPEforDevice::kNumErrorBins; ++ix) {
203  auto y = yoff * (1.f - (0.5f + float(ix)) / 8.f);
204  auto gvx = p.theOrigin.x() + 40.f * buffer_->commonParams().thePitchY;
205  auto gvy = p.theOrigin.y() - y;
206  auto gvz = 1.f / p.theOrigin.z();
207  cp.cotbeta = gvy * gvz;
208  cp.cotalpha = gvx * gvz;
209  errorFromTemplates(p, cp, 20000.f);
210  LogDebug("PixelCPEFastParamsHost") << "sigmay vs y " << i << ' ' << y << ' ' << cp.cotbeta << ' '
211  << 10000.f * cp.sigmay << std::endl;
212  }
213 #endif // EDM_ML_DEBUG
214 
215  // calculate angles (repeated)
216  cp.cotalpha = gvx * gvz;
217  cp.cotbeta = gvy * gvz;
218  auto aveCB = cp.cotbeta;
219 
220  // sample x by charge
221  int qbin = pixelCPEforDevice::kGenErrorQBins; // low charge
222  int k = 0;
223  int qClusIncrement = 100;
224  for (int qclus = 1000; k < pixelCPEforDevice::kGenErrorQBins;
225  qclus += qClusIncrement) { //increase charge until we cover all qBin categories
226  errorFromTemplates(p, cp, qclus);
227  if (cp.qBin_ == qbin)
228  continue;
229  qbin = cp.qBin_;
230  //There are two qBin categories with low charge. Their qBins are 5 and 4 (pixelCPEforDevice::kGenErrorQBins, pixelCPEforDevice::kGenErrorQBins-1)
231  //We increment charge until qBin gets switched from 5 and then we start writing detParams as we are not interested in cases with qBin=5
232  //The problem is that with a too large qClusIncrement, we may go directly from 5 to 3, breaking the logic of the for loop
233  //Therefore, we start with lower increment (100) until we get to qBin=4
234  if (qbin < pixelCPEforDevice::kGenErrorQBins) {
235  qClusIncrement = 1000;
236  }
237  g.xfact[k] = cp.sigmax;
238  g.yfact[k] = cp.sigmay;
239  g.minCh[k++] = qclus;
240 #ifdef EDM_ML_DEBUG
241  LogDebug("PixelCPEFastParamsHost") << i << ' ' << g.rawId << ' ' << cp.cotalpha << ' ' << qclus << ' ' << cp.qBin_
242  << ' ' << cp.pixmx << ' ' << m * cp.sigmax << ' ' << m * cp.sx1 << ' '
243  << m * cp.sx2 << ' ' << m * cp.sigmay << ' ' << m * cp.sy1 << ' ' << m * cp.sy2
244  << std::endl;
245 #endif // EDM_ML_DEBUG
246  }
247 
248  assert(k <= pixelCPEforDevice::kGenErrorQBins);
249 
250  // fill the rest (sometimes bin 4 is missing)
251  for (int kk = k; kk < pixelCPEforDevice::kGenErrorQBins; ++kk) {
252  g.xfact[kk] = g.xfact[k - 1];
253  g.yfact[kk] = g.yfact[k - 1];
254  g.minCh[kk] = g.minCh[k - 1];
255  }
256  auto detx = 1.f / g.xfact[0];
257  auto dety = 1.f / g.yfact[0];
258  for (int kk = 0; kk < pixelCPEforDevice::kGenErrorQBins; ++kk) {
259  g.xfact[kk] *= detx;
260  g.yfact[kk] *= dety;
261  }
262  // sample y in "angle" (estimated from cluster size)
263  float ys = 8.f - 4.f; // apperent bias of half pixel (see plot)
264  // plot: https://indico.cern.ch/event/934821/contributions/3974619/attachments/2091853/3515041/DigilessReco.pdf page 25
265  // sample yerr as function of "size"
266  for (int iy = 0; iy < pixelCPEforDevice::kNumErrorBins; ++iy) {
267  ys += 1.f; // first bin 0 is for size 9 (and size is in fixed point 2^3)
268  if (pixelCPEforDevice::kNumErrorBins - 1 == iy)
269  ys += 8.f; // last bin for "overflow"
270  // cp.cotalpha = ys*(buffer_->commonParams().thePitchX/(8.f*thickness)); // use this to print sampling in "x" (and comment the line below)
271  cp.cotbeta = std::copysign(ys * (buffer_->commonParams().thePitchY / (8.f * thickness)), aveCB);
272  errorFromTemplates(p, cp, 20000.f);
273  g.sigmay[iy] = toMicron(cp.sigmay);
274  LogDebug("PixelCPEFastParamsHost") << "sigmax/sigmay " << i << ' ' << (ys + 4.f) / 8.f << ' ' << cp.cotalpha
275  << '/' << cp.cotbeta << ' ' << 10000.f * cp.sigmax << '/' << int(g.sigmay[iy])
276  << std::endl;
277  }
278  } // loop over det
279 
280  constexpr int numberOfModulesInLadder = TrackerTraits::numberOfModulesInLadder;
281  constexpr int numberOfLaddersInBarrel = TrackerTraits::numberOfLaddersInBarrel;
282  constexpr int numberOfModulesInBarrel = TrackerTraits::numberOfModulesInBarrel;
283 
284  constexpr float ladderFactor = 1.f / float(numberOfModulesInLadder);
285 
286  constexpr int firstEndcapPos = TrackerTraits::firstEndcapPos;
287  constexpr int firstEndcapNeg = TrackerTraits::firstEndcapNeg;
288 
289  // compute ladder baricenter (only in global z) for the barrel
290  //
291  auto& aveGeom = buffer_->averageGeometry();
292  int il = 0;
293  for (int im = 0, nm = numberOfModulesInBarrel; im < nm; ++im) {
294  auto const& g = buffer_->detParams(im);
295  il = im / numberOfModulesInLadder;
296  assert(il < int(numberOfLaddersInBarrel));
297  auto z = g.frame.z();
298  aveGeom.ladderZ[il] += ladderFactor * z;
299  aveGeom.ladderMinZ[il] = std::min(aveGeom.ladderMinZ[il], z);
300  aveGeom.ladderMaxZ[il] = std::max(aveGeom.ladderMaxZ[il], z);
301  aveGeom.ladderX[il] += ladderFactor * g.frame.x();
302  aveGeom.ladderY[il] += ladderFactor * g.frame.y();
303  aveGeom.ladderR[il] += ladderFactor * sqrt(g.frame.x() * g.frame.x() + g.frame.y() * g.frame.y());
304  }
305  assert(il + 1 == int(numberOfLaddersInBarrel));
306  // add half_module and tollerance
307  constexpr float moduleLength = TrackerTraits::moduleLength;
308  constexpr float module_tolerance = 0.2f;
309  for (int il = 0, nl = numberOfLaddersInBarrel; il < nl; ++il) {
310  aveGeom.ladderMinZ[il] -= (0.5f * moduleLength - module_tolerance);
311  aveGeom.ladderMaxZ[il] += (0.5f * moduleLength - module_tolerance);
312  }
313 
314  // compute "max z" for first layer in endcap (should we restrict to the outermost ring?)
315  for (auto im = TrackerTraits::layerStart[firstEndcapPos]; im < TrackerTraits::layerStart[firstEndcapPos + 1]; ++im) {
316  auto const& g = buffer_->detParams(im);
317  aveGeom.endCapZ[0] = std::max(aveGeom.endCapZ[0], g.frame.z());
318  }
319  for (auto im = TrackerTraits::layerStart[firstEndcapNeg]; im < TrackerTraits::layerStart[firstEndcapNeg + 1]; ++im) {
320  auto const& g = buffer_->detParams(im);
321  aveGeom.endCapZ[1] = std::min(aveGeom.endCapZ[1], g.frame.z());
322  }
323  // correct for outer ring being closer
324  aveGeom.endCapZ[0] -= TrackerTraits::endcapCorrection;
325  aveGeom.endCapZ[1] += TrackerTraits::endcapCorrection;
326 #ifdef EDM_ML_DEBUG
327  for (int jl = 0, nl = numberOfLaddersInBarrel; jl < nl; ++jl) {
328  LogDebug("PixelCPEFastParamsHost") << jl << ':' << aveGeom.ladderR[jl] << '/'
329  << std::sqrt(aveGeom.ladderX[jl] * aveGeom.ladderX[jl] +
330  aveGeom.ladderY[jl] * aveGeom.ladderY[jl])
331  << ',' << aveGeom.ladderZ[jl] << ',' << aveGeom.ladderMinZ[jl] << ','
332  << aveGeom.ladderMaxZ[jl] << '\n';
333  }
334  LogDebug("PixelCPEFastParamsHost") << aveGeom.endCapZ[0] << ' ' << aveGeom.endCapZ[1];
335 #endif // EDM_ML_DEBUG
336 
337  // fill Layer and ladders geometry
338  memset(&buffer_->layerGeometry(), 0, sizeof(pixelCPEforDevice::LayerGeometryT<TrackerTraits>));
339  memcpy(buffer_->layerGeometry().layerStart,
340  TrackerTraits::layerStart,
341  sizeof(pixelCPEforDevice::LayerGeometryT<TrackerTraits>::layerStart));
342  memcpy(buffer_->layerGeometry().layer,
343  pixelTopology::layer<TrackerTraits>.data(),
344  pixelTopology::layer<TrackerTraits>.size());
345  buffer_->layerGeometry().maxModuleStride = pixelTopology::maxModuleStride<TrackerTraits>;
346 }
Calorimetry_cff.thickness
thickness
Definition: Calorimetry_cff.py:115
mps_fire.i
i
Definition: mps_fire.py:429
GeomDetEnumerators::isBarrel
bool isBarrel(GeomDetEnumerators::SubDetector m)
Definition: GeomDetEnumerators.cc:57
PixelCPEBase::m_DetParams
DetParams m_DetParams
Definition: PixelCPEBase.h:282
TrackerTopology::pxbLadder
unsigned int pxbLadder(const DetId &id) const
Definition: TrackerTopology.h:157
hgcal_conditions::parameters
Definition: HGCConditions.h:86
ALPAKA_ACCELERATOR_NAMESPACE::brokenline::constexpr
if constexpr(n > 3)
Definition: BrokenLine.h:164
cms::cuda::assert
assert(be >=bs)
g
The Signals That Services Can Subscribe To This is based on ActivityRegistry and is current per Services can connect to the signals distributed by the ActivityRegistry in order to monitor the activity of the application Each possible callback has some defined which we here list in angle e g
Definition: Activities.doc:4
mitigatedMETSequence_cff.U
U
Definition: mitigatedMETSequence_cff.py:36
phase1PixelTopology::numberOfModules
constexpr uint16_t numberOfModules
Definition: SimplePixelTopology.h:136
TrackerTopology::layer
unsigned int layer(const DetId &id) const
Definition: TrackerTopology.cc:47
pixelCPEforDevice::kNumErrorBins
constexpr int kNumErrorBins
Definition: pixelCPEforDevice.h:24
nano_mu_digi_cff.float
float
Definition: nano_mu_digi_cff.py:13
mathSSE::sqrt
T sqrt(T t)
Definition: SSEVec.h:19
visualization-live-secondInstance_cfg.m
m
Definition: visualization-live-secondInstance_cfg.py:84
funct::abs
Abs< T >::type abs(const T &t)
Definition: Abs.h:22
SOAFrame::z
constexpr T z() const
Definition: SOARotation.h:133
f
double f[11][100]
Definition: MuScleFitUtils.cc:78
PixelCPEFastParamsHost::errorFromTemplates
void errorFromTemplates(DetParam const &theDetParam, ClusterParamGeneric &theClusterParam, float qclus) const
Definition: PixelCPEFastParamsHost.cc:349
ALPAKA_ACCELERATOR_NAMESPACE::ecal::reconstruction::internal::endcap::ix
ALPAKA_FN_ACC ALPAKA_FN_INLINE uint32_t ix(uint32_t id)
Definition: KernelHelpers.dev.cc:128
pixelCPEforDevice::kGenErrorQBins
constexpr int kGenErrorQBins
Definition: pixelCPEforDevice.h:22
PixelCPEBase::ttopo_
const TrackerTopology & ttopo_
Definition: PixelCPEBase.h:231
pixelCPEforDevice::Frame
SOAFrame< float > Frame
Definition: pixelCPEforDevice.h:29
GetRecoTauVFromDQM_MC_cff.kk
kk
Definition: GetRecoTauVFromDQM_MC_cff.py:84
phase1PixelTopology::layerStart
static constexpr uint32_t layerStart[numberOfLayers+1]
Definition: SimplePixelTopology.h:189
ALPAKA_ACCELERATOR_NAMESPACE::ecal::reconstruction::internal::endcap::iy
ALPAKA_FN_ACC ALPAKA_FN_INLINE uint32_t iy(uint32_t id)
Definition: KernelHelpers.dev.cc:130
AlCaHLTBitMon_ParallelJobs.p
def p
Definition: AlCaHLTBitMon_ParallelJobs.py:153
CommonMethods.cp
def cp(fromDir, toDir, listOfFiles, overwrite=False, smallList=False)
Definition: CommonMethods.py:191
pixelCPEforDevice::Rotation
SOARotation< float > Rotation
Definition: pixelCPEforDevice.h:30
LogDebug
#define LogDebug(id)
Definition: MessageLogger.h:241

◆ fillPSetDescription()

template<typename TrackerTraits >
void PixelCPEFastParamsHost< TrackerTraits >::fillPSetDescription ( edm::ParameterSetDescription &  desc)
static

Definition at line 477 of file PixelCPEFastParamsHost.cc.

References submitPVResolutionJobs::desc, and PixelCPEGenericBase::fillPSetDescription().

Referenced by ALPAKA_ACCELERATOR_NAMESPACE::PixelCPEFastParamsESProducerAlpaka< TrackerTraits >::fillDescriptions().

477  {
478  // call PixelCPEGenericBase fillPSetDescription to add common rechit errors
479  PixelCPEGenericBase::fillPSetDescription(desc);
480 }
PixelCPEGenericBase::fillPSetDescription
static void fillPSetDescription(edm::ParameterSetDescription &desc)
Definition: PixelCPEGenericBase.cc:217

◆ localError()

template<typename TrackerTraits >
LocalError PixelCPEFastParamsHost< TrackerTraits >::localError ( DetParam const &  theDetParam,
ClusterParam &  theClusterParam 
) const
overrideprivatevirtual

Implements PixelCPEBase.

Definition at line 461 of file PixelCPEFastParamsHost.cc.

References LogDebug, PixelCPEGenericBase::ClusterParamGeneric::sigmax, and PixelCPEGenericBase::ClusterParamGeneric::sigmay.

462  {
463  ClusterParamGeneric& theClusterParam = static_cast<ClusterParamGeneric&>(theClusterParamBase);
464 
465  auto xerr = theClusterParam.sigmax;
466  auto yerr = theClusterParam.sigmay;
467 
468  LogDebug("PixelCPEFastParamsHost") << " errors " << xerr << " " << yerr;
469 
470  auto xerr_sq = xerr * xerr;
471  auto yerr_sq = yerr * yerr;
472 
473  return LocalError(xerr_sq, 0, yerr_sq);
474 }
LogDebug
#define LogDebug(id)
Definition: MessageLogger.h:241

◆ localPosition()

template<typename TrackerTraits >
LocalPoint PixelCPEFastParamsHost< TrackerTraits >::localPosition ( DetParam const &  theDetParam,
ClusterParam &  theClusterParamBase 
) const
overrideprivatevirtual

Hit position in the local frame (in cm). Unlike other CPE's, this one converts everything from the measurement frame (in channel numbers) into the local frame (in centimeters).

< Q of the first pixel in X

< Q of the last pixel in X

< Q of the first pixel in Y

< Q of the last pixel in Y

Implements PixelCPEBase.

Definition at line 406 of file PixelCPEFastParamsHost.cc.

References SiPixelCluster::charge(), CommonMethods::cp(), GeomDet::index(), LogDebug, SiPixelCluster::maxPixelCol(), SiPixelCluster::maxPixelRow(), SiPixelCluster::minPixelCol(), SiPixelCluster::minPixelRow(), PixelCPEBase::ClusterParam::qBin_, PixelCPEGenericBase::ClusterParamGeneric::sigmax, PixelCPEGenericBase::ClusterParamGeneric::sigmay, PixelCPEBase::ClusterParam::theCluster, and PixelCPEBase::DetParam::theDet.

407  {
408  ClusterParamGeneric& theClusterParam = static_cast<ClusterParamGeneric&>(theClusterParamBase);
409 
410  if (useErrorsFromTemplates_) {
411  errorFromTemplates(theDetParam, theClusterParam, theClusterParam.theCluster->charge());
412  } else {
413  theClusterParam.qBin_ = 0;
414  }
415 
416  int q_f_X;
417  int q_l_X;
418  int q_f_Y;
419  int q_l_Y;
420  collect_edge_charges(theClusterParam, q_f_X, q_l_X, q_f_Y, q_l_Y, useErrorsFromTemplates_ && truncatePixelCharge_);
421 
422  // do GPU like ...
423  pixelCPEforDevice::ClusParams cp;
424 
425  cp.minRow[0] = theClusterParam.theCluster->minPixelRow();
426  cp.maxRow[0] = theClusterParam.theCluster->maxPixelRow();
427  cp.minCol[0] = theClusterParam.theCluster->minPixelCol();
428  cp.maxCol[0] = theClusterParam.theCluster->maxPixelCol();
429 
430  cp.q_f_X[0] = q_f_X;
431  cp.q_l_X[0] = q_l_X;
432  cp.q_f_Y[0] = q_f_Y;
433  cp.q_l_Y[0] = q_l_Y;
434 
435  cp.charge[0] = theClusterParam.theCluster->charge();
436 
437  auto ind = theDetParam.theDet->index();
438  pixelCPEforDevice::position<TrackerTraits>(buffer_->commonParams(), buffer_->detParams(ind), cp, 0);
439  auto xPos = cp.xpos[0];
440  auto yPos = cp.ypos[0];
441 
442  // set the error (mind ape....)
443  pixelCPEforDevice::errorFromDB<TrackerTraits>(buffer_->commonParams(), buffer_->detParams(ind), cp, 0);
444  theClusterParam.sigmax = cp.xerr[0];
445  theClusterParam.sigmay = cp.yerr[0];
446 
447  LogDebug("PixelCPEFastParamsHost") << " in PixelCPEFastParamsHost:localPosition - pos = " << xPos << " " << yPos
448  << " size " << cp.maxRow[0] - cp.minRow[0] << ' ' << cp.maxCol[0] - cp.minCol[0];
449 
450  //--- Now put the two together
451  LocalPoint pos_in_local(xPos, yPos);
452  return pos_in_local;
453 }
PixelCPEGenericBase::collect_edge_charges
static void collect_edge_charges(ClusterParam &theClusterParam, int &q_f_X, int &q_l_X, int &q_f_Y, int &q_l_Y, bool truncate)
Definition: PixelCPEGenericBase.cc:45
hgcal_conditions::parameters
Definition: HGCConditions.h:86
PixelCPEFastParamsHost::errorFromTemplates
void errorFromTemplates(DetParam const &theDetParam, ClusterParamGeneric &theClusterParam, float qclus) const
Definition: PixelCPEFastParamsHost.cc:349
CommonMethods.cp
def cp(fromDir, toDir, listOfFiles, overwrite=False, smallList=False)
Definition: CommonMethods.py:191
LogDebug
#define LogDebug(id)
Definition: MessageLogger.h:241

◆ operator=() [1/2]

template<typename TrackerTraits>
PixelCPEFastParamsHost& PixelCPEFastParamsHost< TrackerTraits >::operator= ( PixelCPEFastParamsHost< TrackerTraits > const &  )
delete

◆ operator=() [2/2]

template<typename TrackerTraits>
PixelCPEFastParamsHost& PixelCPEFastParamsHost< TrackerTraits >::operator= ( PixelCPEFastParamsHost< TrackerTraits > &&  )
default

◆ size()

template<typename TrackerTraits>
auto PixelCPEFastParamsHost< TrackerTraits >::size ( void  ) const
inline

Definition at line 47 of file PixelCPEFastParamsHost.h.

References PixelCPEFastParamsHost< TrackerTraits >::buffer_.

Referenced by ntupleDataFormat._Collection::__iter__(), and ntupleDataFormat._Collection::__len__().

47 { return alpaka::getExtentProduct(buffer_); }

Member Data Documentation

◆ buffer_

template<typename TrackerTraits>
Buffer PixelCPEFastParamsHost< TrackerTraits >::buffer_
private

Definition at line 63 of file PixelCPEFastParamsHost.h.

Referenced by PixelCPEFastParamsHost< TrackerTraits >::buffer(), PixelCPEFastParamsHost< TrackerTraits >::const_buffer(), PixelCPEFastParamsHost< TrackerTraits >::data(), and PixelCPEFastParamsHost< TrackerTraits >::size().

◆ thePixelGenError_

template<typename TrackerTraits>
std::vector<SiPixelGenErrorStore> PixelCPEFastParamsHost< TrackerTraits >::thePixelGenError_
private

Definition at line 59 of file PixelCPEFastParamsHost.h.

Referenced by PixelCPEFastParamsHost< TrackerTraits >::PixelCPEFastParamsHost().

Generated for CMSSW Reference Manual by doxygen 1.8.14