PixelCPEFast Class Reference

#include <PixelCPEFast.h>

Inheritance diagram for PixelCPEFast:

Classes
struct	GPUData

Public Member Functions
pixelCPEforGPU::ParamsOnGPU const &	getCPUProduct () const
const pixelCPEforGPU::ParamsOnGPU *	getGPUProductAsync (cudaStream_t cudaStream) const
	PixelCPEFast (edm::ParameterSet const &conf, const MagneticField *, const TrackerGeometry &, const TrackerTopology &, const SiPixelLorentzAngle *, const SiPixelGenErrorDBObject *, const SiPixelLorentzAngle *)
	The constructor. More...
	~PixelCPEFast () 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	fillParamsForGpu ()
LocalError	localError (DetParam const &theDetParam, ClusterParam &theClusterParam) const override
LocalPoint	localPosition (DetParam const &theDetParam, ClusterParam &theClusterParam) const override

Private Attributes
pixelCPEforGPU::AverageGeometry	averageGeometry_
pixelCPEforGPU::CommonParams	commonParamsGPU_
pixelCPEforGPU::ParamsOnGPU	cpuData_
std::vector < pixelCPEforGPU::DetParams >	detParamsGPU_
cms::cuda::ESProduct< GPUData >	gpuData_
pixelCPEforGPU::LayerGeometry	layerGeometry_
std::vector< SiPixelGenErrorStore >	thePixelGenError_

Additional Inherited Members
Public Types inherited from PixelClusterParameterEstimator
typedef std::pair< LocalPoint, LocalError >	LocalValues
using	ReturnType = std::tuple< LocalPoint, LocalError, SiPixelRecHitQuality::QualWordType >
typedef std::vector< LocalValues >	VLocalValues
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

Definition at line 14 of file PixelCPEFast.h.

Constructor & Destructor Documentation

PixelCPEFast::PixelCPEFast	(	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 23 of file PixelCPEFast.cc.

References averageGeometry_, commonParamsGPU_, cpuData_, detParamsGPU_, Exception, fillParamsForGpu(), PixelCPEBase::genErrorDBObject_, layerGeometry_, SiPixelGenError::pushfile(), thePixelGenError_, and PixelCPEGenericBase::useErrorsFromTemplates_.

    : PixelCPEGenericBase(conf, mag, geom, ttopo, lorentzAngle, genErrorDBObject, lorentzAngleWidth) {
  // Use errors from templates or from GenError
  if (useErrorsFromTemplates_) {
    if (!SiPixelGenError::pushfile(*genErrorDBObject_, thePixelGenError_))
      throw cms::Exception("InvalidCalibrationLoaded")
          << "ERROR: GenErrors not filled correctly. Check the sqlite file. Using SiPixelTemplateDBObject version "
          << (*genErrorDBObject_).version();
  }

  fillParamsForGpu();

  cpuData_ = {
      &commonParamsGPU_,
      detParamsGPU_.data(),
      &layerGeometry_,
      &averageGeometry_,
  };
}

PixelCPEFast::~PixelCPEFast ( )

overridedefault

Member Function Documentation

void PixelCPEFast::errorFromTemplates ( DetParam const &  theDetParam, ClusterParamGeneric &  theClusterParam, float  qclus  ) const

private

Definition at line 356 of file PixelCPEFast.cc.

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

Referenced by fillParamsForGpu(), and localPosition().

                                                         {
  float locBz = theDetParam.bz;
  float locBx = theDetParam.bx;
  LogDebug("PixelCPEFast") << "PixelCPEFast::localPosition(...) : locBz = " << locBz;

  theClusterParam.pixmx = std::numeric_limits<int>::max();  // max pixel charge for truncation of 2-D cluster

  theClusterParam.sigmay = -999.9;  // CPE Generic y-error for multi-pixel cluster
  theClusterParam.sigmax = -999.9;  // CPE Generic x-error for multi-pixel cluster
  theClusterParam.sy1 = -999.9;     // CPE Generic y-error for single single-pixel
  theClusterParam.sy2 = -999.9;     // CPE Generic y-error for single double-pixel cluster
  theClusterParam.sx1 = -999.9;     // CPE Generic x-error for single single-pixel cluster
  theClusterParam.sx2 = -999.9;     // CPE Generic x-error for single double-pixel cluster

  float dummy;

  SiPixelGenError gtempl(thePixelGenError_);
  int gtemplID = theDetParam.detTemplateId;

  theClusterParam.qBin_ = gtempl.qbin(gtemplID,
                                      theClusterParam.cotalpha,
                                      theClusterParam.cotbeta,
                                      locBz,
                                      locBx,
                                      qclus,
                                      false,
                                      theClusterParam.pixmx,
                                      theClusterParam.sigmay,
                                      dummy,
                                      theClusterParam.sigmax,
                                      dummy,
                                      theClusterParam.sy1,
                                      dummy,
                                      theClusterParam.sy2,
                                      dummy,
                                      theClusterParam.sx1,
                                      dummy,
                                      theClusterParam.sx2,
                                      dummy);

  theClusterParam.sigmax = theClusterParam.sigmax * micronsToCm;
  theClusterParam.sx1 = theClusterParam.sx1 * micronsToCm;
  theClusterParam.sx2 = theClusterParam.sx2 * micronsToCm;

  theClusterParam.sigmay = theClusterParam.sigmay * micronsToCm;
  theClusterParam.sy1 = theClusterParam.sy1 * micronsToCm;
  theClusterParam.sy2 = theClusterParam.sy2 * micronsToCm;
}

void PixelCPEFast::fillParamsForGpu ( )

private

Definition at line 85 of file PixelCPEFast.cc.

References funct::abs(), cms::cuda::assert(), averageGeometry_, commonParamsGPU_, PixelCPEBase::ClusterParam::cotalpha, PixelCPEBase::ClusterParam::cotbeta, CommonMethods::cp(), detParamsGPU_, errorFromTemplates(), validate-o2o-wbm::f, g, mps_fire::i, GeomDetEnumerators::isBarrel(), isotrackApplyRegressor::k, CPEFastParametrisation::kGenErrorQBins, GetRecoTauVFromDQM_MC_cff::kk, CPEFastParametrisation::kNumErrorBins, PVValHelper::ladder, pixelCPEforGPU::LayerGeometry::layer, phase1PixelTopology::layer, TrackerTopology::layer(), layerGeometry_, phase1PixelTopology::layerStart, pixelCPEforGPU::LayerGeometry::layerStart, LogDebug, visualization-live-secondInstance_cfg::m, PixelCPEBase::m_DetParams, SiStripPI::max, min(), phase1PixelTopology::numberOfLaddersInBarrel, phase1PixelTopology::numberOfModulesInBarrel, AlCaHLTBitMon_ParallelJobs::p, PixelCPEGenericBase::ClusterParamGeneric::pixmx, TrackerTopology::pxbLadder(), PixelCPEBase::ClusterParam::qBin_, findQualityFiles::rr, PixelCPEGenericBase::ClusterParamGeneric::sigmax, PixelCPEGenericBase::ClusterParamGeneric::sigmay, mathSSE::sqrt(), PixelCPEGenericBase::ClusterParamGeneric::sx1, PixelCPEGenericBase::ClusterParamGeneric::sx2, PixelCPEGenericBase::ClusterParamGeneric::sy1, PixelCPEGenericBase::ClusterParamGeneric::sy2, pixelCPEforGPU::CommonParams::thePitchX, pixelCPEforGPU::CommonParams::thePitchY, pixelCPEforGPU::CommonParams::theThicknessB, pixelCPEforGPU::CommonParams::theThicknessE, TrackerMaterial_cfi::thickness, PixelCPEBase::ttopo_, PixelCPEBase::ClusterParam::with_track_angle, x, phase1PixelTopology::xOffset, y, phase1PixelTopology::yOffset, z, and SOAFrame< T >::z().

Referenced by PixelCPEFast().

                                    {
  //
  // this code executes only once per job, computation inefficiency is not an issue
  // many code blocks are repeated: better keep the computation local and self oconsistent as blocks may in future move around, be deleted ...
  // It is valid only for Phase1 and the version of GenError in DB used in late 2018 and in 2021

  commonParamsGPU_.theThicknessB = m_DetParams.front().theThickness;
  commonParamsGPU_.theThicknessE = m_DetParams.back().theThickness;
  commonParamsGPU_.thePitchX = m_DetParams[0].thePitchX;
  commonParamsGPU_.thePitchY = m_DetParams[0].thePitchY;

  LogDebug("PixelCPEFast") << "pitch & thickness " << commonParamsGPU_.thePitchX << ' ' << commonParamsGPU_.thePitchY
                           << "  " << commonParamsGPU_.theThicknessB << ' ' << commonParamsGPU_.theThicknessE;

  // zero average geometry
  memset(&averageGeometry_, 0, sizeof(pixelCPEforGPU::AverageGeometry));

  uint32_t oldLayer = 0;
  uint32_t oldLadder = 0;
  float rl = 0;
  float zl = 0;
  float miz = 90, mxz = 0;
  float pl = 0;
  int nl = 0;
  detParamsGPU_.resize(m_DetParams.size());
  for (auto i = 0U; i < m_DetParams.size(); ++i) {
    auto& p = m_DetParams[i];
    auto& g = detParamsGPU_[i];

    assert(p.theDet->index() == int(i));
    assert(commonParamsGPU_.thePitchY == p.thePitchY);
    assert(commonParamsGPU_.thePitchX == p.thePitchX);

    g.isBarrel = GeomDetEnumerators::isBarrel(p.thePart);
    g.isPosZ = p.theDet->surface().position().z() > 0;
    g.layer = ttopo_.layer(p.theDet->geographicalId());
    g.index = i;  // better be!
    g.rawId = p.theDet->geographicalId();
    auto thickness = g.isBarrel ? commonParamsGPU_.theThicknessB : commonParamsGPU_.theThicknessE;
    assert(thickness == p.theThickness);

    auto ladder = ttopo_.pxbLadder(p.theDet->geographicalId());
    if (oldLayer != g.layer) {
      oldLayer = g.layer;
      LogDebug("PixelCPEFast") << "new layer at " << i << (g.isBarrel ? " B  " : (g.isPosZ ? " E+ " : " E- "))
                               << g.layer << " starting at " << g.rawId << '\n'
                               << "old layer had " << nl << " ladders";
      nl = 0;
    }
    if (oldLadder != ladder) {
      oldLadder = ladder;
      LogDebug("PixelCPEFast") << "new ladder at " << i << (g.isBarrel ? " B  " : (g.isPosZ ? " E+ " : " E- "))
                               << ladder << " starting at " << g.rawId << '\n'
                               << "old ladder ave z,r,p mz " << zl / 8.f << " " << rl / 8.f << " " << pl / 8.f << ' '
                               << miz << ' ' << mxz;
      rl = 0;
      zl = 0;
      pl = 0;
      miz = 90;
      mxz = 0;
      nl++;
    }

    g.shiftX = 0.5f * p.lorentzShiftInCmX;
    g.shiftY = 0.5f * p.lorentzShiftInCmY;
    g.chargeWidthX = p.lorentzShiftInCmX * p.widthLAFractionX;
    g.chargeWidthY = p.lorentzShiftInCmY * p.widthLAFractionY;

    g.x0 = p.theOrigin.x();
    g.y0 = p.theOrigin.y();
    g.z0 = p.theOrigin.z();

    auto vv = p.theDet->surface().position();
    auto rr = pixelCPEforGPU::Rotation(p.theDet->surface().rotation());
    g.frame = pixelCPEforGPU::Frame(vv.x(), vv.y(), vv.z(), rr);

    zl += vv.z();
    miz = std::min(miz, std::abs(vv.z()));
    mxz = std::max(mxz, std::abs(vv.z()));
    rl += vv.perp();
    pl += vv.phi();  // (not obvious)

    // errors .....
    ClusterParamGeneric cp;

    cp.with_track_angle = false;

    auto lape = p.theDet->localAlignmentError();
    if (lape.invalid())
      lape = LocalError();  // zero....

    g.apeXX = lape.xx();
    g.apeYY = lape.yy();

    auto toMicron = [&](float x) { return std::min(511, int(x * 1.e4f + 0.5f)); };

    // average angle
    auto gvx = p.theOrigin.x() + 40.f * commonParamsGPU_.thePitchX;
    auto gvy = p.theOrigin.y();
    auto gvz = 1.f / p.theOrigin.z();
    //--- Note that the normalization is not required as only the ratio used

    {
      // calculate angles (fed into errorFromTemplates)
      cp.cotalpha = gvx * gvz;
      cp.cotbeta = gvy * gvz;
      errorFromTemplates(p, cp, 20000.);
    }

#ifdef EDM_ML_DEBUG
    auto m = 10000.f;
    for (float qclus = 15000; qclus < 35000; qclus += 15000) {
      errorFromTemplates(p, cp, qclus);
      LogDebug("PixelCPEFast") << i << ' ' << qclus << ' ' << cp.pixmx << ' ' << m * cp.sigmax << ' ' << m * cp.sx1
                               << ' ' << m * cp.sx2 << ' ' << m * cp.sigmay << ' ' << m * cp.sy1 << ' ' << m * cp.sy2;
    }
    LogDebug("PixelCPEFast") << i << ' ' << m * std::sqrt(lape.xx()) << ' ' << m * std::sqrt(lape.yy());
#endif  // EDM_ML_DEBUG

    g.pixmx = std::max(0, cp.pixmx);
    g.sx2 = toMicron(cp.sx2);
    g.sy1 = std::max(21, toMicron(cp.sy1));  // for some angles sy1 is very small
    g.sy2 = std::max(55, toMicron(cp.sy2));  // sometimes sy2 is smaller than others (due to angle?)

    // sample xerr as function of position
    auto const xoff = float(phase1PixelTopology::xOffset) * commonParamsGPU_.thePitchX;

    for (int ix = 0; ix < CPEFastParametrisation::kNumErrorBins; ++ix) {
      auto x = xoff * (1.f - (0.5f + float(ix)) / 8.f);
      auto gvx = p.theOrigin.x() - x;
      auto gvy = p.theOrigin.y();
      auto gvz = 1.f / p.theOrigin.z();
      cp.cotbeta = gvy * gvz;
      cp.cotalpha = gvx * gvz;
      errorFromTemplates(p, cp, 20000.f);
      g.sigmax[ix] = toMicron(cp.sigmax);
      g.sigmax1[ix] = toMicron(cp.sx1);
      LogDebug("PixelCPEFast") << "sigmax vs x " << i << ' ' << x << ' ' << cp.cotalpha << ' ' << int(g.sigmax[ix])
                               << ' ' << int(g.sigmax1[ix]) << ' ' << 10000.f * cp.sigmay << std::endl;
    }
#ifdef EDM_ML_DEBUG
    // sample yerr as function of position
    auto const yoff = float(phase1PixelTopology::yOffset) * commonParamsGPU_.thePitchY;
    for (int ix = 0; ix < CPEFastParametrisation::kNumErrorBins; ++ix) {
      auto y = yoff * (1.f - (0.5f + float(ix)) / 8.f);
      auto gvx = p.theOrigin.x() + 40.f * commonParamsGPU_.thePitchY;
      auto gvy = p.theOrigin.y() - y;
      auto gvz = 1.f / p.theOrigin.z();
      cp.cotbeta = gvy * gvz;
      cp.cotalpha = gvx * gvz;
      errorFromTemplates(p, cp, 20000.f);
      LogDebug("PixelCPEFast") << "sigmay vs y " << i << ' ' << y << ' ' << cp.cotbeta << ' ' << 10000.f * cp.sigmay
                               << std::endl;
    }
#endif  // EDM_ML_DEBUG

    // calculate angles (repeated)
    cp.cotalpha = gvx * gvz;
    cp.cotbeta = gvy * gvz;
    auto aveCB = cp.cotbeta;

    // sample x by charge
    int qbin = CPEFastParametrisation::kGenErrorQBins;  // low charge
    int k = 0;
    for (int qclus = 1000; qclus < 200000; qclus += 1000) {
      errorFromTemplates(p, cp, qclus);
      if (cp.qBin_ == qbin)
        continue;
      qbin = cp.qBin_;
      g.xfact[k] = cp.sigmax;
      g.yfact[k] = cp.sigmay;
      g.minCh[k++] = qclus;
#ifdef EDM_ML_DEBUG
      LogDebug("PixelCPEFast") << i << ' ' << g.rawId << ' ' << cp.cotalpha << ' ' << qclus << ' ' << cp.qBin_ << ' '
                               << cp.pixmx << ' ' << m * cp.sigmax << ' ' << m * cp.sx1 << ' ' << m * cp.sx2 << ' '
                               << m * cp.sigmay << ' ' << m * cp.sy1 << ' ' << m * cp.sy2 << std::endl;
#endif  // EDM_ML_DEBUG
    }
    assert(k <= CPEFastParametrisation::kGenErrorQBins);
    // fill the rest  (sometimes bin 4 is missing)
    for (int kk = k; kk < CPEFastParametrisation::kGenErrorQBins; ++kk) {
      g.xfact[kk] = g.xfact[k - 1];
      g.yfact[kk] = g.yfact[k - 1];
      g.minCh[kk] = g.minCh[k - 1];
    }
    auto detx = 1.f / g.xfact[0];
    auto dety = 1.f / g.yfact[0];
    for (int kk = 0; kk < CPEFastParametrisation::kGenErrorQBins; ++kk) {
      g.xfact[kk] *= detx;
      g.yfact[kk] *= dety;
    }
    // sample y in "angle"  (estimated from cluster size)
    float ys = 8.f - 4.f;  // apperent bias of half pixel (see plot)
    // plot: https://indico.cern.ch/event/934821/contributions/3974619/attachments/2091853/3515041/DigilessReco.pdf page 25
    // sample yerr as function of "size"
    for (int iy = 0; iy < CPEFastParametrisation::kNumErrorBins; ++iy) {
      ys += 1.f;  // first bin 0 is for size 9  (and size is in fixed point 2^3)
      if (CPEFastParametrisation::kNumErrorBins - 1 == iy)
        ys += 8.f;  // last bin for "overflow"
      // cp.cotalpha = ys*(commonParamsGPU_.thePitchX/(8.f*thickness));  //  use this to print sampling in "x"  (and comment the line below)
      cp.cotbeta = std::copysign(ys * (commonParamsGPU_.thePitchY / (8.f * thickness)), aveCB);
      errorFromTemplates(p, cp, 20000.f);
      g.sigmay[iy] = toMicron(cp.sigmay);
      LogDebug("PixelCPEFast") << "sigmax/sigmay " << i << ' ' << (ys + 4.f) / 8.f << ' ' << cp.cotalpha << '/'
                               << cp.cotbeta << ' ' << 10000.f * cp.sigmax << '/' << int(g.sigmay[iy]) << std::endl;
    }
  }  // loop over det

  //
  // compute ladder baricenter (only in global z) for the barrel
  //
  auto& aveGeom = averageGeometry_;
  int il = 0;
  for (int im = 0, nm = phase1PixelTopology::numberOfModulesInBarrel; im < nm; ++im) {
    auto const& g = detParamsGPU_[im];
    il = im / 8;
    assert(il < int(phase1PixelTopology::numberOfLaddersInBarrel));
    auto z = g.frame.z();
    aveGeom.ladderZ[il] += 0.125f * z;
    aveGeom.ladderMinZ[il] = std::min(aveGeom.ladderMinZ[il], z);
    aveGeom.ladderMaxZ[il] = std::max(aveGeom.ladderMaxZ[il], z);
    aveGeom.ladderX[il] += 0.125f * g.frame.x();
    aveGeom.ladderY[il] += 0.125f * g.frame.y();
    aveGeom.ladderR[il] += 0.125f * sqrt(g.frame.x() * g.frame.x() + g.frame.y() * g.frame.y());
  }
  assert(il + 1 == int(phase1PixelTopology::numberOfLaddersInBarrel));
  // add half_module and tollerance
  constexpr float module_length = 6.7f;
  constexpr float module_tolerance = 0.2f;
  for (int il = 0, nl = phase1PixelTopology::numberOfLaddersInBarrel; il < nl; ++il) {
    aveGeom.ladderMinZ[il] -= (0.5f * module_length - module_tolerance);
    aveGeom.ladderMaxZ[il] += (0.5f * module_length - module_tolerance);
  }

  // compute "max z" for first layer in endcap (should we restrict to the outermost ring?)
  for (auto im = phase1PixelTopology::layerStart[4]; im < phase1PixelTopology::layerStart[5]; ++im) {
    auto const& g = detParamsGPU_[im];
    aveGeom.endCapZ[0] = std::max(aveGeom.endCapZ[0], g.frame.z());
  }
  for (auto im = phase1PixelTopology::layerStart[7]; im < phase1PixelTopology::layerStart[8]; ++im) {
    auto const& g = detParamsGPU_[im];
    aveGeom.endCapZ[1] = std::min(aveGeom.endCapZ[1], g.frame.z());
  }
  // correct for outer ring being closer
  aveGeom.endCapZ[0] -= 1.5f;
  aveGeom.endCapZ[1] += 1.5f;

  for (int jl = 0, nl = phase1PixelTopology::numberOfLaddersInBarrel; jl < nl; ++jl) {
    LogDebug("PixelCPEFast") << jl << ':' << aveGeom.ladderR[jl] << '/'
                             << std::sqrt(aveGeom.ladderX[jl] * aveGeom.ladderX[jl] +
                                          aveGeom.ladderY[jl] * aveGeom.ladderY[jl])
                             << ',' << aveGeom.ladderZ[jl] << ',' << aveGeom.ladderMinZ[jl] << ','
                             << aveGeom.ladderMaxZ[jl] << '\n';
  }
  LogDebug("PixelCPEFast") << aveGeom.endCapZ[0] << ' ' << aveGeom.endCapZ[1];

  // fill Layer and ladders geometry
  memcpy(layerGeometry_.layerStart, phase1PixelTopology::layerStart, sizeof(phase1PixelTopology::layerStart));
  memcpy(layerGeometry_.layer, phase1PixelTopology::layer.data(), phase1PixelTopology::layer.size());
}

void PixelCPEFast::fillPSetDescription ( edm::ParameterSetDescription &  desc )

static

Definition at line 481 of file PixelCPEFast.cc.

References PixelCPEGenericBase::fillPSetDescription().

Referenced by PixelCPEFastESProducer::fillDescriptions().

                                                                       {
  // call PixelCPEGenericBase fillPSetDescription to add common rechit errors
  PixelCPEGenericBase::fillPSetDescription(desc);
}

pixelCPEforGPU::ParamsOnGPU const& PixelCPEFast::getCPUProduct ( ) const

inline

Definition at line 32 of file PixelCPEFast.h.

References cpuData_.

{ return cpuData_; }

const pixelCPEforGPU::ParamsOnGPU * PixelCPEFast::getGPUProductAsync

(

cudaStream_t

cudaStream

)

const

Definition at line 49 of file PixelCPEFast.cc.

References cudaCheck, data, detParamsGPU_, gpuData_, pixelCPEforGPU::ParamsOnGPU::m_averageGeometry, pixelCPEforGPU::ParamsOnGPU::m_commonParams, pixelCPEforGPU::ParamsOnGPU::m_detParams, pixelCPEforGPU::ParamsOnGPU::m_layerGeometry, PixelCPEFast::GPUData::paramsOnGPU_d, PixelCPEFast::GPUData::paramsOnGPU_h, and cms::cuda::stream.

                                                                                               {
  const auto& data = gpuData_.dataForCurrentDeviceAsync(cudaStream, [this](GPUData& data, cudaStream_t stream) {
    // and now copy to device...
    cudaCheck(cudaMalloc((void**)&data.paramsOnGPU_h.m_commonParams, sizeof(pixelCPEforGPU::CommonParams)));
    cudaCheck(cudaMalloc((void**)&data.paramsOnGPU_h.m_detParams,
                         this->detParamsGPU_.size() * sizeof(pixelCPEforGPU::DetParams)));
    cudaCheck(cudaMalloc((void**)&data.paramsOnGPU_h.m_averageGeometry, sizeof(pixelCPEforGPU::AverageGeometry)));
    cudaCheck(cudaMalloc((void**)&data.paramsOnGPU_h.m_layerGeometry, sizeof(pixelCPEforGPU::LayerGeometry)));
    cudaCheck(cudaMalloc((void**)&data.paramsOnGPU_d, sizeof(pixelCPEforGPU::ParamsOnGPU)));

    cudaCheck(cudaMemcpyAsync(
        data.paramsOnGPU_d, &data.paramsOnGPU_h, sizeof(pixelCPEforGPU::ParamsOnGPU), cudaMemcpyDefault, stream));
    cudaCheck(cudaMemcpyAsync((void*)data.paramsOnGPU_h.m_commonParams,
                              &this->commonParamsGPU_,
                              sizeof(pixelCPEforGPU::CommonParams),
                              cudaMemcpyDefault,
                              stream));
    cudaCheck(cudaMemcpyAsync((void*)data.paramsOnGPU_h.m_averageGeometry,
                              &this->averageGeometry_,
                              sizeof(pixelCPEforGPU::AverageGeometry),
                              cudaMemcpyDefault,
                              stream));
    cudaCheck(cudaMemcpyAsync((void*)data.paramsOnGPU_h.m_layerGeometry,
                              &this->layerGeometry_,
                              sizeof(pixelCPEforGPU::LayerGeometry),
                              cudaMemcpyDefault,
                              stream));
    cudaCheck(cudaMemcpyAsync((void*)data.paramsOnGPU_h.m_detParams,
                              this->detParamsGPU_.data(),
                              this->detParamsGPU_.size() * sizeof(pixelCPEforGPU::DetParams),
                              cudaMemcpyDefault,
                              stream));
  });
  return data.paramsOnGPU_d;
}

LocalError PixelCPEFast::localError ( DetParam const &  theDetParam, ClusterParam &  theClusterParam  ) const

overrideprivatevirtual

Implements PixelCPEBase.

Definition at line 467 of file PixelCPEFast.cc.

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

                                                                                                        {
  ClusterParamGeneric& theClusterParam = static_cast<ClusterParamGeneric&>(theClusterParamBase);

  auto xerr = theClusterParam.sigmax;
  auto yerr = theClusterParam.sigmay;

  LogDebug("PixelCPEFast") << " errors  " << xerr << " " << yerr;

  auto xerr_sq = xerr * xerr;
  auto yerr_sq = yerr * yerr;

  return LocalError(xerr_sq, 0, yerr_sq);
}

LocalPoint PixelCPEFast::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 412 of file PixelCPEFast.cc.

References cms::cuda::assert(), pixelCPEforGPU::ClusParamsT< N >::charge, SiPixelCluster::charge(), PixelCPEGenericBase::collect_edge_charges(), commonParamsGPU_, CommonMethods::cp(), detParamsGPU_, pixelCPEforGPU::errorFromDB(), errorFromTemplates(), GeomDet::index(), LogDebug, pixelCPEforGPU::ClusParamsT< N >::maxCol, SiPixelCluster::maxPixelCol(), SiPixelCluster::maxPixelRow(), pixelCPEforGPU::ClusParamsT< N >::maxRow, pixelCPEforGPU::ClusParamsT< N >::minCol, SiPixelCluster::minPixelCol(), SiPixelCluster::minPixelRow(), pixelCPEforGPU::ClusParamsT< N >::minRow, pixelCPEforGPU::position(), pixelCPEforGPU::ClusParamsT< N >::q_f_X, pixelCPEforGPU::ClusParamsT< N >::q_f_Y, pixelCPEforGPU::ClusParamsT< N >::q_l_X, pixelCPEforGPU::ClusParamsT< N >::q_l_Y, PixelCPEBase::ClusterParam::qBin_, PixelCPEGenericBase::ClusterParamGeneric::sigmax, PixelCPEGenericBase::ClusterParamGeneric::sigmay, PixelCPEBase::ClusterParam::theCluster, PixelCPEBase::DetParam::theDet, PixelCPEGenericBase::truncatePixelCharge_, PixelCPEGenericBase::useErrorsFromTemplates_, PixelCPEBase::ClusterParam::with_track_angle, pixelCPEforGPU::ClusParamsT< N >::xerr, pixelCPEforGPU::ClusParamsT< N >::xpos, pixelCPEforGPU::ClusParamsT< N >::yerr, and pixelCPEforGPU::ClusParamsT< N >::ypos.

                                                                                                           {
  ClusterParamGeneric& theClusterParam = static_cast<ClusterParamGeneric&>(theClusterParamBase);

  assert(!theClusterParam.with_track_angle);

  if (useErrorsFromTemplates_) {
    errorFromTemplates(theDetParam, theClusterParam, theClusterParam.theCluster->charge());
  } else {
    theClusterParam.qBin_ = 0;
  }

  int q_f_X;  
  int q_l_X;  
  int q_f_Y;  
  int q_l_Y;  
  collect_edge_charges(theClusterParam, q_f_X, q_l_X, q_f_Y, q_l_Y, useErrorsFromTemplates_ && truncatePixelCharge_);

  // do GPU like ...
  pixelCPEforGPU::ClusParams cp;

  cp.minRow[0] = theClusterParam.theCluster->minPixelRow();
  cp.maxRow[0] = theClusterParam.theCluster->maxPixelRow();
  cp.minCol[0] = theClusterParam.theCluster->minPixelCol();
  cp.maxCol[0] = theClusterParam.theCluster->maxPixelCol();

  cp.q_f_X[0] = q_f_X;
  cp.q_l_X[0] = q_l_X;
  cp.q_f_Y[0] = q_f_Y;
  cp.q_l_Y[0] = q_l_Y;

  cp.charge[0] = theClusterParam.theCluster->charge();

  auto ind = theDetParam.theDet->index();
  pixelCPEforGPU::position(commonParamsGPU_, detParamsGPU_[ind], cp, 0);
  auto xPos = cp.xpos[0];
  auto yPos = cp.ypos[0];

  // set the error  (mind ape....)
  pixelCPEforGPU::errorFromDB(commonParamsGPU_, detParamsGPU_[ind], cp, 0);
  theClusterParam.sigmax = cp.xerr[0];
  theClusterParam.sigmay = cp.yerr[0];

  LogDebug("PixelCPEFast") << " in PixelCPEFast:localPosition - pos = " << xPos << " " << yPos << " size "
                           << cp.maxRow[0] - cp.minRow[0] << ' ' << cp.maxCol[0] - cp.minCol[0];

  //--- Now put the two together
  LocalPoint pos_in_local(xPos, yPos);
  return pos_in_local;
}

Member Data Documentation

pixelCPEforGPU::AverageGeometry PixelCPEFast::averageGeometry_

private

Definition at line 47 of file PixelCPEFast.h.

Referenced by fillParamsForGpu(), and PixelCPEFast().

pixelCPEforGPU::CommonParams PixelCPEFast::commonParamsGPU_

private

Definition at line 45 of file PixelCPEFast.h.

Referenced by fillParamsForGpu(), localPosition(), and PixelCPEFast().

pixelCPEforGPU::ParamsOnGPU PixelCPEFast::cpuData_

private

Definition at line 48 of file PixelCPEFast.h.

Referenced by getCPUProduct(), and PixelCPEFast().

std::vector<pixelCPEforGPU::DetParams> PixelCPEFast::detParamsGPU_

private

Definition at line 44 of file PixelCPEFast.h.

Referenced by fillParamsForGpu(), getGPUProductAsync(), localPosition(), and PixelCPEFast().

cms::cuda::ESProduct<GPUData> PixelCPEFast::gpuData_

private

Definition at line 56 of file PixelCPEFast.h.

Referenced by getGPUProductAsync().

pixelCPEforGPU::LayerGeometry PixelCPEFast::layerGeometry_

private

Definition at line 46 of file PixelCPEFast.h.

Referenced by fillParamsForGpu(), and PixelCPEFast().

std::vector<SiPixelGenErrorStore> PixelCPEFast::thePixelGenError_

private

Definition at line 41 of file PixelCPEFast.h.

Referenced by errorFromTemplates(), and PixelCPEFast().