#include <PixelCPEClusterRepair.h>

Inheritance diagram for PixelCPEClusterRepair:

Classes
struct	ClusterParamTemplate

class	Rule

Public Member Functions
	PixelCPEClusterRepair (edm::ParameterSet const &conf, const MagneticField , const TrackerGeometry &, const TrackerTopology &, const SiPixelLorentzAngle , const std::vector< SiPixelTemplateStore > , const SiPixelTemplateDBObject , const SiPixel2DTemplateDBObject *)

	~PixelCPEClusterRepair () override

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 PixelCPEBase
static void	fillPSetDescription (edm::ParameterSetDescription &desc)

Private Member Functions
void	callTempReco1D (DetParam const &theDetParam, ClusterParamTemplate &theClusterParam, SiPixelTemplateReco::ClusMatrix &clusterPayload, int ID, LocalPoint &lp) const

void	callTempReco2D (DetParam const &theDetParam, ClusterParamTemplate &theClusterParam, SiPixelTemplateReco2D::ClusMatrix &clusterPayload, int ID, LocalPoint &lp) const

void	checkRecommend2D (DetParam const &theDetParam, ClusterParamTemplate &theClusterParam, SiPixelTemplateReco::ClusMatrix &clusterPayload, int ID) const

std::unique_ptr< ClusterParam >	createClusterParam (const SiPixelCluster &cl) const override

void	fill2DTemplIDs ()

LocalError	localError (DetParam const &theDetParam, ClusterParam &theClusterParam) const override

LocalPoint	localPosition (DetParam const &theDetParam, ClusterParam &theClusterParam) const override

Private Attributes
int	barrelTemplateID_

int	forwardTemplateID_

float	maxSizeMismatchInY_

float	minChargeRatio_

std::vector< Rule >	recommend2D_

bool	runDamagedClusters_

int	speed_

const SiPixel2DTemplateDBObject *	templateDBobject2D_

std::string	templateDir_

std::vector< SiPixelTemplateStore2D >	thePixelTemp2D_

std::vector< SiPixelTemplateStore > const *	thePixelTemp_

std::vector< SiPixelTemplateStore >	thePixelTempCache_

bool	UseClusterSplitter_

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 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

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 34 of file PixelCPEClusterRepair.h.

Constructor & Destructor Documentation

◆ PixelCPEClusterRepair()

PixelCPEClusterRepair::PixelCPEClusterRepair	(	edm::ParameterSet const &	conf,
		const MagneticField *	mag,
		const TrackerGeometry &	geom,
		const TrackerTopology &	ttopo,
		const SiPixelLorentzAngle *	lorentzAngle,
		const std::vector< SiPixelTemplateStore > *	templateStore,
		const SiPixelTemplateDBObject *	templateDBobject,
		const SiPixel2DTemplateDBObject *	templateDBobject2D
	)

Definition at line 38 of file PixelCPEClusterRepair.cc.

References barrelTemplateID_, Exception, fill2DTemplIDs(), forwardTemplateID_, edm::ParameterSet::getParameter(), PixelCPEBase::LoadTemplatesFromDB_, LogDebug, mag(), maxSizeMismatchInY_, minChargeRatio_, SiPixelTemplate2D::pushfile(), SiPixelTemplate::pushfile(), recommend2D_, runDamagedClusters_, speed_, str, templateDBobject2D_, templateDir_, thePixelTemp2D_, thePixelTemp_, thePixelTempCache_, and UseClusterSplitter_.

     : PixelCPEBase(conf, mag, geom, ttopo, lorentzAngle, nullptr, templateDBobject, nullptr, 1) {
   LogDebug("PixelCPEClusterRepair::(constructor)") << endl;
 
   //--- Parameter to decide between DB or text file template access
   if (LoadTemplatesFromDB_) {
     thePixelTemp_ = templateStore;
     // Initialize template store to the selected ID [Morris, 6/25/08]
     if (!SiPixelTemplate2D::pushfile(*templateDBobject2D, thePixelTemp2D_))
       throw cms::Exception("PixelCPEClusterRepair")
           << "\nERROR: Templates not filled correctly. Check the sqlite file. Using SiPixelTemplateDBObject2D version "
           << (*templateDBobject2D).version() << "\n\n";
   } else {
     LogDebug("PixelCPEClusterRepair") << "Loading templates for barrel and forward from ASCII files." << endl;
     //--- (Archaic) Get configurable template IDs.  This code executes only if we loading pixels from ASCII
     //    files, and then they are mandatory.
     barrelTemplateID_ = conf.getParameter<int>("barrelTemplateID");
     forwardTemplateID_ = conf.getParameter<int>("forwardTemplateID");
     templateDir_ = conf.getParameter<int>("directoryWithTemplates");
     thePixelTemp_ = &thePixelTempCache_;
 
     if (!SiPixelTemplate::pushfile(barrelTemplateID_, thePixelTempCache_, templateDir_))
       throw cms::Exception("PixelCPEClusterRepair")
           << "\nERROR: Template ID " << barrelTemplateID_
           << " not loaded correctly from text file. Reconstruction will fail.\n\n";
 
     if (!SiPixelTemplate::pushfile(forwardTemplateID_, thePixelTempCache_, templateDir_))
       throw cms::Exception("PixelCPEClusterRepair")
           << "\nERROR: Template ID " << forwardTemplateID_
           << " not loaded correctly from text file. Reconstruction will fail.\n\n";
   }
 
   speed_ = conf.getParameter<int>("speed");
   LogDebug("PixelCPEClusterRepair::PixelCPEClusterRepair:") << "Template speed = " << speed_ << "\n";
 
   // this returns the magnetic field value in kgauss (1T = 10 kgauss)
   int theMagField = mag->nominalValue();
 
   if (theMagField >= 36 && theMagField < 39) {
     LogDebug("PixelCPEClusterRepair::PixelCPEClusterRepair:")
         << "Magnetic field value is: " << theMagField << " kgauss. Algorithm is being run \n";
 
     templateDBobject2D_ = templateDBobject2D;
     fill2DTemplIDs();
   }
 
   UseClusterSplitter_ = conf.getParameter<bool>("UseClusterSplitter");
 
   maxSizeMismatchInY_ = conf.getParameter<double>("MaxSizeMismatchInY");
   minChargeRatio_ = conf.getParameter<double>("MinChargeRatio");
 
   // read sub-detectors and apply rule to recommend 2D
   // can be:
   //     XYX (XYZ = PXB, PXE)
   //     XYZ n (XYZ as above, n = layer, wheel or disk = 1 .. 6 ;)
   std::vector<std::string> str_recommend2D = conf.getParameter<std::vector<std::string>>("Recommend2D");
   recommend2D_.reserve(str_recommend2D.size());
   for (auto& str : str_recommend2D) {
     recommend2D_.push_back(str);
   }
 
   // do not recommend 2D if theMagField!=3.8T
   if (theMagField < 36 || theMagField > 39) {
     recommend2D_.clear();
   }
 
   // run CR on damaged clusters (and not only on edge hits)
   runDamagedClusters_ = conf.getParameter<bool>("RunDamagedClusters");
 }

◆ ~PixelCPEClusterRepair()

PixelCPEClusterRepair::~PixelCPEClusterRepair ( )

override

Definition at line 155 of file PixelCPEClusterRepair.cc.

155 {}

Member Function Documentation

◆ callTempReco1D()

void PixelCPEClusterRepair::callTempReco1D	(	DetParam const &	theDetParam,
		ClusterParamTemplate &	theClusterParam,
		SiPixelTemplateReco::ClusMatrix &	clusterPayload,
		int	ID,
		LocalPoint &	lp
	)		const

private

Definition at line 307 of file PixelCPEClusterRepair.cc.

Referenced by localPosition().

                                                                  {
   SiPixelTemplate templ(*thePixelTemp_);
 
   // Output:
   float nonsense = -99999.9f;  // nonsense init value
   theClusterParam.templXrec_ = theClusterParam.templYrec_ = theClusterParam.templSigmaX_ =
       theClusterParam.templSigmaY_ = nonsense;
   // If the template recontruction fails, we want to return 1.0 for now
   theClusterParam.probabilityX_ = theClusterParam.probabilityY_ = theClusterParam.probabilityQ_ = 1.f;
   theClusterParam.qBin_ = 0;
   // We have a boolean denoting whether the reco failed or not
   theClusterParam.hasFilledProb_ = false;
 
   // In case of template reco failure, these are the lorentz drift corrections
   // to be applied
   float lorentzshiftX = 0.5f * theDetParam.lorentzShiftInCmX;
   float lorentzshiftY = 0.5f * theDetParam.lorentzShiftInCmY;
 
   // ******************************************************************
   //--- Call normal TemplateReco
   //
   float locBz = theDetParam.bz;
   float locBx = theDetParam.bx;
   //
   const bool deadpix = false;
   std::vector<std::pair<int, int>> zeropix;
   int nypix = 0, nxpix = 0;
   //
   theClusterParam.ierr = PixelTempReco1D(ID,
                                          theClusterParam.cotalpha,
                                          theClusterParam.cotbeta,
                                          locBz,
                                          locBx,
                                          clusterPayload,
                                          templ,
                                          theClusterParam.templYrec_,
                                          theClusterParam.templSigmaY_,
                                          theClusterParam.probabilityY_,
                                          theClusterParam.templXrec_,
                                          theClusterParam.templSigmaX_,
                                          theClusterParam.probabilityX_,
                                          theClusterParam.qBin_,
                                          speed_,
                                          deadpix,
                                          zeropix,
                                          theClusterParam.probabilityQ_,
                                          nypix,
                                          nxpix);
   // ******************************************************************
 
   //--- Check exit status
   if UNLIKELY (theClusterParam.ierr != 0) {
     LogDebug("PixelCPEClusterRepair::localPosition")
         << "reconstruction failed with error " << theClusterParam.ierr << "\n";
 
     theClusterParam.probabilityX_ = theClusterParam.probabilityY_ = theClusterParam.probabilityQ_ = 0.f;
     theClusterParam.qBin_ = 0;
     //
     // Template reco has failed, compute position estimates based on cluster center of gravity + Lorentz drift
     // Future improvement would be to call generic reco instead
 
     if (theClusterParam.with_track_angle) {
       theClusterParam.templXrec_ =
           theDetParam.theTopol->localX(theClusterParam.theCluster->x(), theClusterParam.loc_trk_pred) + lorentzshiftX;
       theClusterParam.templYrec_ =
           theDetParam.theTopol->localY(theClusterParam.theCluster->y(), theClusterParam.loc_trk_pred) + lorentzshiftY;
     } else {
       edm::LogError("PixelCPEClusterRepair") << "@SUB = PixelCPEClusterRepair::localPosition"
                                              << "Should never be here. PixelCPEClusterRepair should always be called "
                                                 "with track angles. This is a bad error !!! ";
 
       theClusterParam.templXrec_ = theDetParam.theTopol->localX(theClusterParam.theCluster->x()) + lorentzshiftX;
       theClusterParam.templYrec_ = theDetParam.theTopol->localY(theClusterParam.theCluster->y()) + lorentzshiftY;
     }
   } else {
     //--- Template Reco succeeded.  The probabilities are filled.
     theClusterParam.hasFilledProb_ = true;
 
     //--- Go from microns to centimeters
     theClusterParam.templXrec_ *= micronsToCm;
     theClusterParam.templYrec_ *= micronsToCm;
 
     //--- Go back to the module coordinate system
     theClusterParam.templXrec_ += lp.x();
     theClusterParam.templYrec_ += lp.y();
   }
   return;
 }

◆ callTempReco2D()

void PixelCPEClusterRepair::callTempReco2D	(	DetParam const &	theDetParam,
		ClusterParamTemplate &	theClusterParam,
		SiPixelTemplateReco2D::ClusMatrix &	clusterPayload,
		int	ID,
		LocalPoint &	lp
	)		const

private

Definition at line 403 of file PixelCPEClusterRepair.cc.

Referenced by localPosition().

                                                                  {
   SiPixelTemplate2D templ2d(thePixelTemp2D_);
 
   // Output:
   float nonsense = -99999.9f;  // nonsense init value
   theClusterParam.templXrec_ = theClusterParam.templYrec_ = theClusterParam.templSigmaX_ =
       theClusterParam.templSigmaY_ = nonsense;
   // If the template recontruction fails, we want to return 1.0 for now
   theClusterParam.probabilityX_ = theClusterParam.probabilityY_ = theClusterParam.probabilityQ_ = 1.f;
   theClusterParam.qBin_ = 0;
   // We have a boolean denoting whether the reco failed or not
   theClusterParam.hasFilledProb_ = false;
 
   // In case of template reco failure, these are the lorentz drift corrections
   // to be applied
   float lorentzshiftX = 0.5f * theDetParam.lorentzShiftInCmX;
   float lorentzshiftY = 0.5f * theDetParam.lorentzShiftInCmY;
 
   // ******************************************************************
   //--- Call 2D TemplateReco
   //
   float locBz = theDetParam.bz;
   float locBx = theDetParam.bx;
 
   //--- Input:
   //   edgeflagy - (input) flag to indicate the present of edges in y:
   //           0=none (or interior gap),1=edge at small y, 2=edge at large y, 3=edge at either end
   //
   //   edgeflagx - (input) flag to indicate the present of edges in x:
   //           0=none, 1=edge at small x, 2=edge at large x
   //
   //   These two variables are calculated in setTheClu() and stored in edgeTypeX_ and edgeTypeY_
   //
   //--- Output:
   //   deltay - (output) template y-length - cluster length [when > 0, possibly missing end]
   //   npixels - ???     &&& Ask Morris
 
   float deltay = 0;  // return param
   int npixels = 0;   // return param
 
   //For now, turn off edgeX_ flags
   theClusterParam.edgeTypeX_ = 0;
 
   if (clusterPayload.mrow > 4) {
     // The cluster is too big, the 2D reco will perform horribly.
     // Better to return immediately in error
     theClusterParam.ierr2 = 8;
 
   } else {
     theClusterParam.ierr2 = PixelTempReco2D(ID,
                                             theClusterParam.cotalpha,
                                             theClusterParam.cotbeta,
                                             locBz,
                                             locBx,
                                             theClusterParam.edgeTypeY_,
                                             theClusterParam.edgeTypeX_,
                                             clusterPayload,
                                             templ2d,
                                             theClusterParam.templYrec_,
                                             theClusterParam.templSigmaY_,
                                             theClusterParam.templXrec_,
                                             theClusterParam.templSigmaX_,
                                             theClusterParam.templProbXY_,
                                             theClusterParam.probabilityQ_,
                                             theClusterParam.qBin_,
                                             deltay,
                                             npixels);
   }
   // ******************************************************************
 
   //--- Check exit status
   if UNLIKELY (theClusterParam.ierr2 != 0) {
     LogDebug("PixelCPEClusterRepair::localPosition")
         << "2D reconstruction failed with error " << theClusterParam.ierr2 << "\n";
 
     theClusterParam.probabilityX_ = theClusterParam.probabilityY_ = theClusterParam.probabilityQ_ = 0.f;
     theClusterParam.qBin_ = 0;
 
     // 2D Template reco has failed, compute position estimates based on cluster center of gravity + Lorentz drift
     // Future improvement would be to call generic reco instead
 
     if (theClusterParam.with_track_angle) {
       theClusterParam.templXrec_ =
           theDetParam.theTopol->localX(theClusterParam.theCluster->x(), theClusterParam.loc_trk_pred) + lorentzshiftX;
       theClusterParam.templYrec_ =
           theDetParam.theTopol->localY(theClusterParam.theCluster->y(), theClusterParam.loc_trk_pred) + lorentzshiftY;
     } else {
       edm::LogError("PixelCPEClusterRepair") << "@SUB = PixelCPEClusterRepair::localPosition"
                                              << "Should never be here. PixelCPEClusterRepair should always be called "
                                                 "with track angles. This is a bad error !!! ";
 
       theClusterParam.templXrec_ = theDetParam.theTopol->localX(theClusterParam.theCluster->x()) + lorentzshiftX;
       theClusterParam.templYrec_ = theDetParam.theTopol->localY(theClusterParam.theCluster->y()) + lorentzshiftY;
     }
 
   } else {
     //--- Template Reco succeeded.
     theClusterParam.hasFilledProb_ = true;
 
     //--- Go from microns to centimeters
     theClusterParam.templXrec_ *= micronsToCm;
     theClusterParam.templYrec_ *= micronsToCm;
 
     //--- Go back to the module coordinate system
     theClusterParam.templXrec_ += lp.x();
     theClusterParam.templYrec_ += lp.y();
   }
   return;
 }

◆ checkRecommend2D()

void PixelCPEClusterRepair::checkRecommend2D	(	DetParam const &	theDetParam,
		ClusterParamTemplate &	theClusterParam,
		SiPixelTemplateReco::ClusMatrix &	clusterPayload,
		int	ID
	)		const

private

Definition at line 520 of file PixelCPEClusterRepair.cc.

References PixelCPEBase::DetParam::bx, PixelCPEBase::DetParam::bz, SiPixelCluster::charge(), SiPixelTemplate::clsleny(), PixelCPEBase::ClusterParam::cotalpha, PixelCPEBase::ClusterParam::cotbeta, PixelCPEBase::ClusterParam::edgeTypeY_, GeomDet::geographicalId(), PixelCPEBase::ClusterParam::hasBadPixels_, mps_fire::i, SiPixelTemplate::interpolate(), maxSizeMismatchInY_, SiPixelTemplateReco::ClusMatrix::mcol, minChargeRatio_, SiPixelCluster::minPixelCol(), SiPixelTemplate::qavg(), recommend2D_, PixelCPEClusterRepair::ClusterParamTemplate::recommended2D_, runDamagedClusters_, SiPixelCluster::sizeY(), PixelCPEBase::ClusterParam::theCluster, PixelCPEBase::DetParam::theDet, thePixelTemp_, PixelCPEBase::ttopo_, and SiPixelTemplateReco::ClusMatrix::ydouble.

Referenced by localPosition().

 {
   // recommend2D is false by default
   theClusterParam.recommended2D_ = false;
 
   DetId id = (theDetParam.theDet->geographicalId());
 
   bool recommend = false;
   for (auto& rec : recommend2D_) {
     recommend = rec.recommend(id, ttopo_);
     if (recommend)
       break;
   }
 
   // only run on those layers recommended by configuration
   if (!recommend) {
     theClusterParam.recommended2D_ = false;
     return;
   }
 
   if (theClusterParam.edgeTypeY_) {
     // For clusters that have edges in Y, run 2d reco.
     // Flags already set by CPEBase
     theClusterParam.recommended2D_ = true;
     return;
   }
   // The 1d pixel template
   SiPixelTemplate templ(*thePixelTemp_);
   if (!templ.interpolate(ID, theClusterParam.cotalpha, theClusterParam.cotbeta, theDetParam.bz, theDetParam.bx)) {
     //error setting up template, return false
     theClusterParam.recommended2D_ = false;
     return;
   }
 
   //length of the cluster taking into account double sized pixels
   float nypix = clusterPayload.mcol;
   for (int i = 0; i < clusterPayload.mcol; i++) {
     if (clusterPayload.ydouble[i])
       nypix += 1.;
   }
 
   // templ.clsleny() is the expected length of the cluster along y axis.
   // templ.qavg() is the expected total charge of the cluster
   // theClusterParam.theCluster->charge() is the total charge of this cluster
   float nydiff = templ.clsleny() - nypix;
   float qratio = theClusterParam.theCluster->charge() / templ.qavg();
 
   if (nydiff > maxSizeMismatchInY_ && qratio < minChargeRatio_) {
     // If the cluster is shorter than expected and has less charge, likely
     // due to truncated cluster, try 2D reco
 
     theClusterParam.recommended2D_ = true;
     theClusterParam.hasBadPixels_ = true;
 
     // if not RunDamagedClusters flag, don't try to fix any clusters
     if (!runDamagedClusters_) {
       theClusterParam.recommended2D_ = false;
     }
 
     // Figure out what edge flags to set for truncated cluster
     // Truncated clusters usually come from dead double columns
     //
     // If cluster is of even length,  either both of or neither of beginning and ending
     // edge are on a double column, so we cannot figure out the likely edge of
     // truncation, let the 2D algorithm try extending on both sides (option 3)
     if (theClusterParam.theCluster->sizeY() % 2 == 0)
       theClusterParam.edgeTypeY_ = 3;
     else {
       //If the cluster is of odd length, only one of the edges can end on
       //a double column, this is the likely edge of truncation
       //Double columns always start on even indexes
       int min_col = theClusterParam.theCluster->minPixelCol();
       if (min_col % 2 == 0) {
         //begining edge is at a double column (end edge cannot be,
         //because odd length) so likely truncated at small y (option 1)
         theClusterParam.edgeTypeY_ = 1;
       } else {
         //end edge is at a double column (beginning edge cannot be,
         //because odd length) so likely truncated at large y (option 2)
         theClusterParam.edgeTypeY_ = 2;
       }
     }
   }
 }

◆ createClusterParam()

std::unique_ptr< PixelCPEBase::ClusterParam > PixelCPEClusterRepair::createClusterParam ( const SiPixelCluster & cl ) const

overrideprivatevirtual

Implements PixelCPEBase.

Definition at line 157 of file PixelCPEClusterRepair.cc.

References haddnano::cl.

                                                                                                                 {
   return std::make_unique<ClusterParamTemplate>(cl);
 }

◆ fill2DTemplIDs()

void PixelCPEClusterRepair::fill2DTemplIDs ( )

private

Definition at line 118 of file PixelCPEClusterRepair.cc.

References TrackerGeometry::detUnits(), PixelCPEBase::geom_, SiPixel2DTemplateDBObject::getTemplateID(), mps_fire::i, LogDebug, PixelCPEBase::m_DetParams, TrackerGeometry::offsetDU(), AlCaHLTBitMon_ParallelJobs::p, templateDBobject2D_, and GeomDetEnumerators::tkDetEnum.

Referenced by PixelCPEClusterRepair().

                                            {
   auto const& dus = geom_.detUnits();
   unsigned m_detectors = dus.size();
   for (unsigned int i = 1; i < 7; ++i) {
     LogDebug("PixelCPEClusterRepair:: LookingForFirstStrip")
         << "Subdetector " << i << " GeomDetEnumerator " << GeomDetEnumerators::tkDetEnum[i] << " offset "
         << geom_.offsetDU(GeomDetEnumerators::tkDetEnum[i]) << " is it strip? "
         << (geom_.offsetDU(GeomDetEnumerators::tkDetEnum[i]) != dus.size()
                 ? dus[geom_.offsetDU(GeomDetEnumerators::tkDetEnum[i])]->type().isOuterTracker()
                 : false);
     if (geom_.offsetDU(GeomDetEnumerators::tkDetEnum[i]) != dus.size() &&
         dus[geom_.offsetDU(GeomDetEnumerators::tkDetEnum[i])]->type().isOuterTracker()) {
       if (geom_.offsetDU(GeomDetEnumerators::tkDetEnum[i]) < m_detectors)
         m_detectors = geom_.offsetDU(GeomDetEnumerators::tkDetEnum[i]);
     }
   }
   LogDebug("LookingForFirstStrip") << " Chosen offset: " << m_detectors;
 
   m_DetParams.resize(m_detectors);
   LogDebug("PixelCPEClusterRepair::fillDetParams():") << "caching " << m_detectors << " pixel detectors" << endl;
   //Loop through detectors and store 2D template ID
   bool printed_info = false;
   for (unsigned i = 0; i != m_detectors; ++i) {
     auto& p = m_DetParams[i];
 
     p.detTemplateId2D = templateDBobject2D_->getTemplateID(p.theDet->geographicalId());
     if (p.detTemplateId != p.detTemplateId2D && !printed_info) {
       edm::LogWarning("PixelCPEClusterRepair")
           << "different template ID between 1D and 2D " << p.detTemplateId << " " << p.detTemplateId2D << endl;
       printed_info = true;
     }
   }
 }

◆ fillPSetDescription()

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

static

Definition at line 716 of file PixelCPEClusterRepair.cc.

References submitPVResolutionJobs::desc.

Referenced by PixelCPEClusterRepairESProducer::fillDescriptions().

                                                                                 {
   desc.add<int>("barrelTemplateID", 0);
   desc.add<int>("forwardTemplateID", 0);
   desc.add<int>("directoryWithTemplates", 0);
   desc.add<int>("speed", -2);
   desc.add<bool>("UseClusterSplitter", false);
   desc.add<double>("MaxSizeMismatchInY", 0.3);
   desc.add<double>("MinChargeRatio", 0.8);
   desc.add<std::vector<std::string>>("Recommend2D", {"PXB 2", "PXB 3", "PXB 4"});
   desc.add<bool>("RunDamagedClusters", false);
 }

◆ localError()

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

overrideprivatevirtual

Implements PixelCPEBase.

Definition at line 612 of file PixelCPEClusterRepair.cc.

References PixelCPEBase::bothEdgeXError_, PixelCPEBase::bothEdgeYError_, PixelCPEBase::clusterSplitMaxError_, PixelCPEBase::ClusterParam::edgeTypeX_, PixelCPEBase::ClusterParam::edgeTypeY_, Exception, f, PixelCPEBase::ClusterParam::filled_from_2d, SiPixelCluster::getSplitClusterErrorX(), SiPixelCluster::getSplitClusterErrorY(), PixelCPEClusterRepair::ClusterParamTemplate::ierr, PixelCPEClusterRepair::ClusterParamTemplate::ierr2, GeomDetEnumerators::isBarrel(), GeomDetEnumerators::isTrackerPixel(), LogDebug, pixelCPEforDevice::micronsToCm, SiPixelCluster::sizeX(), SiPixelCluster::sizeY(), PixelCPEClusterRepair::ClusterParamTemplate::templSigmaX_, PixelCPEClusterRepair::ClusterParamTemplate::templSigmaY_, PixelCPEBase::ClusterParam::theCluster, PixelCPEBase::DetParam::thePart, PixelCPEBase::theVerboseLevel, UNLIKELY, PixelCPEBase::xEdgeXError_, PixelCPEBase::xEdgeYError_, PixelCPEBase::yEdgeXError_, and PixelCPEBase::yEdgeYError_.

                                                                                                                  {
   ClusterParamTemplate& theClusterParam = static_cast<ClusterParamTemplate&>(theClusterParamBase);
 
   //--- Default is the maximum error used for edge clusters.
   //--- (never used, in fact: let comment it out, shut up the complains of the static analyzer, and save a few CPU cycles)
   float xerr = 0.0f, yerr = 0.0f;
 
   // Check if the errors were already set at the clusters splitting level
   if (theClusterParam.theCluster->getSplitClusterErrorX() > 0.0f &&
       theClusterParam.theCluster->getSplitClusterErrorX() < clusterSplitMaxError_ &&
       theClusterParam.theCluster->getSplitClusterErrorY() > 0.0f &&
       theClusterParam.theCluster->getSplitClusterErrorY() < clusterSplitMaxError_) {
     xerr = theClusterParam.theCluster->getSplitClusterErrorX() * micronsToCm;
     yerr = theClusterParam.theCluster->getSplitClusterErrorY() * micronsToCm;
 
     //cout << "Errors set at cluster splitting level : " << endl;
     //cout << "xerr = " << xerr << endl;
     //cout << "yerr = " << yerr << endl;
   } else {
     // If errors are not split at the cluster splitting level, set the errors here
 
     //--- Check status of both template calls.
     if UNLIKELY ((theClusterParam.ierr != 0) || (theClusterParam.ierr2 != 0)) {
       // If reconstruction fails the hit position is calculated from cluster center of gravity
       // corrected in x by average Lorentz drift. Assign huge errors.
       //
       if UNLIKELY (!GeomDetEnumerators::isTrackerPixel(theDetParam.thePart))
         throw cms::Exception("PixelCPEClusterRepair::localPosition :") << "A non-pixel detector type in here?";
 
       // Assign better errors based on the residuals for failed template cases
       if (GeomDetEnumerators::isBarrel(theDetParam.thePart)) {
         xerr = 55.0f * micronsToCm;  // &&& get errors from elsewhere?
         yerr = 36.0f * micronsToCm;
       } else {
         xerr = 42.0f * micronsToCm;
         yerr = 39.0f * micronsToCm;
       }
     }
     // Use special edge hit errors (derived from observed RMS's) for edge hits that we did not run the 2D reco on
     //
     else if (!theClusterParamBase.filled_from_2d && (theClusterParam.edgeTypeX_ || theClusterParam.edgeTypeY_)) {
       // for edge pixels assign errors according to observed residual RMS
       if (theClusterParam.edgeTypeX_ && !theClusterParam.edgeTypeY_) {
         xerr = xEdgeXError_ * micronsToCm;
         yerr = xEdgeYError_ * micronsToCm;
       } else if (!theClusterParam.edgeTypeX_ && theClusterParam.edgeTypeY_) {
         xerr = yEdgeXError_ * micronsToCm;
         yerr = yEdgeYError_ * micronsToCm;
       } else if (theClusterParam.edgeTypeX_ && theClusterParam.edgeTypeY_) {
         xerr = bothEdgeXError_ * micronsToCm;
         yerr = bothEdgeYError_ * micronsToCm;
       }
     } else {
       xerr = theClusterParam.templSigmaX_ * micronsToCm;
       yerr = theClusterParam.templSigmaY_ * micronsToCm;
       // &&& should also check ierr (saved as class variable) and return
       // &&& nonsense (another class static) if the template fit failed.
     }
   }
 
   if (theVerboseLevel > 9) {
     LogDebug("PixelCPEClusterRepair") << " Sizex = " << theClusterParam.theCluster->sizeX()
                                       << " Sizey = " << theClusterParam.theCluster->sizeY()
                                       << " Edgex = " << theClusterParam.edgeTypeX_
                                       << " Edgey = " << theClusterParam.edgeTypeY_ << " ErrX  = " << xerr
                                       << " ErrY  = " << yerr;
   }
 
   if (!(xerr > 0.0f))
     throw cms::Exception("PixelCPEClusterRepair::localError")
         << "\nERROR: Negative pixel error xerr = " << xerr << "\n\n";
 
   if (!(yerr > 0.0f))
     throw cms::Exception("PixelCPEClusterRepair::localError")
         << "\nERROR: Negative pixel error yerr = " << yerr << "\n\n";
 
   return LocalError(xerr * xerr, 0, yerr * yerr);
 }

◆ localPosition()

LocalPoint PixelCPEClusterRepair::localPosition	(	DetParam const &	theDetParam,
		ClusterParam &	theClusterParam
	)		const

overrideprivatevirtual

Implements PixelCPEBase.

Definition at line 168 of file PixelCPEClusterRepair.cc.

                                                                                                                     {
   ClusterParamTemplate& theClusterParam = static_cast<ClusterParamTemplate&>(theClusterParamBase);
   bool filled_from_2d = false;
 
   if (!GeomDetEnumerators::isTrackerPixel(theDetParam.thePart))
     throw cms::Exception("PixelCPEClusterRepair::localPosition :") << "A non-pixel detector type in here?";
 
   int ID1 = -9999;
   int ID2 = -9999;
   if (LoadTemplatesFromDB_) {
     ID1 = theDetParam.detTemplateId;
     ID2 = theDetParam.detTemplateId2D;
   } else {  // from asci file
     if (!GeomDetEnumerators::isEndcap(theDetParam.thePart))
       ID1 = ID2 = barrelTemplateID_;  // barrel
     else
       ID1 = ID2 = forwardTemplateID_;  // forward
   }
 
   // &&& PM, note for later: PixelCPEBase calculates minInX,Y, and maxInX,Y
   //     Why can't we simply use that and save time with row_offset, col_offset
   //     and mrow = maxInX-minInX, mcol = maxInY-minInY ... Except that we
   //     also need to take into account cluster_matrix_size_x,y.
 
   //--- Preparing to retrieve ADC counts from the SiPixeltheClusterParam.theCluster
   //    The pixels from minPixelRow() will go into clust_array_2d[0][*],
   //    and the pixels from minPixelCol() will go into clust_array_2d[*][0].
   int row_offset = theClusterParam.theCluster->minPixelRow();
   int col_offset = theClusterParam.theCluster->minPixelCol();
 
   //--- Store the coordinates of the center of the (0,0) pixel of the array that
   //    gets passed to PixelTempReco2D.  Will add these values to the output of TemplReco2D
   float tmp_x = float(row_offset) + 0.5f;
   float tmp_y = float(col_offset) + 0.5f;
 
   //--- Store these offsets (to be added later) in a LocalPoint after tranforming
   //    them from measurement units (pixel units) to local coordinates (cm)
   LocalPoint lp;
   if (theClusterParam.with_track_angle)
     //--- Update call with trk angles needed for bow/kink corrections  // Gavril
     lp = theDetParam.theTopol->localPosition(MeasurementPoint(tmp_x, tmp_y), theClusterParam.loc_trk_pred);
   else {
     edm::LogError("PixelCPEClusterRepair") << "@SUB = PixelCPEClusterRepair::localPosition"
                                            << "Should never be here. PixelCPEClusterRepair should always be called "
                                               "with track angles. This is a bad error !!! ";
     lp = theDetParam.theTopol->localPosition(MeasurementPoint(tmp_x, tmp_y));
   }
 
   //--- Compute the size of the matrix which will be passed to TemplateReco.
   //    We'll later make  clustMatrix[ mrow ][ mcol ]
   int mrow = 0, mcol = 0;
   for (int i = 0; i != theClusterParam.theCluster->size(); ++i) {
     auto pix = theClusterParam.theCluster->pixel(i);
     int irow = int(pix.x);
     int icol = int(pix.y);
     mrow = std::max(mrow, irow);
     mcol = std::max(mcol, icol);
   }
   mrow -= row_offset;
   mrow += 1;
   mrow = std::min(mrow, cluster_matrix_size_x);
   mcol -= col_offset;
   mcol += 1;
   mcol = std::min(mcol, cluster_matrix_size_y);
   assert(mrow > 0);
   assert(mcol > 0);
 
   //--- Make and fill the bool arrays flagging double pixels
   bool xdouble[mrow], ydouble[mcol];
   // x directions (shorter), rows
   for (int irow = 0; irow < mrow; ++irow)
     xdouble[irow] = theDetParam.theRecTopol->isItBigPixelInX(irow + row_offset);
   //
   // y directions (longer), columns
   for (int icol = 0; icol < mcol; ++icol)
     ydouble[icol] = theDetParam.theRecTopol->isItBigPixelInY(icol + col_offset);
 
   //--- C-style matrix.  We'll need it in either case.
   float clustMatrix[mrow][mcol];
   float clustMatrix2[mrow][mcol];
 
   //--- Prepare struct that passes pointers to TemplateReco.  It doesn't own anything.
   SiPixelTemplateReco::ClusMatrix clusterPayload{&clustMatrix[0][0], xdouble, ydouble, mrow, mcol};
   SiPixelTemplateReco2D::ClusMatrix clusterPayload2d{&clustMatrix2[0][0], xdouble, ydouble, mrow, mcol};
 
   //--- Copy clust's pixels (calibrated in electrons) into clustMatrix;
   memset(clustMatrix, 0, sizeof(float) * mrow * mcol);  // Wipe it clean.
   for (int i = 0; i != theClusterParam.theCluster->size(); ++i) {
     auto pix = theClusterParam.theCluster->pixel(i);
     int irow = int(pix.x) - row_offset;
     int icol = int(pix.y) - col_offset;
     // &&& Do we ever get pixels that are out of bounds ???  Need to check.
     if ((irow < mrow) & (icol < mcol))
       clustMatrix[irow][icol] = float(pix.adc);
   }
   // &&& Save for later: fillClustMatrix( float * clustMatrix );
 
   //--- Save a copy of clustMatrix into clustMatrix2
   memcpy(clustMatrix2, clustMatrix, sizeof(float) * mrow * mcol);
 
   //--- Set both return statuses, since we may call only one.
   theClusterParam.ierr = 0;
   theClusterParam.ierr2 = 0;
 
   //--- Should we run the 2D reco?
   checkRecommend2D(theDetParam, theClusterParam, clusterPayload, ID1);
   if (theClusterParam.recommended2D_) {
     //--- Call the Template Reco 2d with cluster repair
     filled_from_2d = true;
     callTempReco2D(theDetParam, theClusterParam, clusterPayload2d, ID2, lp);
   } else {
     //--- Call the vanilla Template Reco
     callTempReco1D(theDetParam, theClusterParam, clusterPayload, ID1, lp);
     filled_from_2d = false;
   }
 
   //--- Make sure cluster repair returns all info about the hit back up to caller
   //--- Necessary because it copied the base class so it does not modify it
   theClusterParamBase.isOnEdge_ = theClusterParam.isOnEdge_;
   theClusterParamBase.hasBadPixels_ = theClusterParam.hasBadPixels_;
   theClusterParamBase.spansTwoROCs_ = theClusterParam.spansTwoROCs_;
   theClusterParamBase.hasFilledProb_ = theClusterParam.hasFilledProb_;
   theClusterParamBase.qBin_ = theClusterParam.qBin_;
   theClusterParamBase.probabilityQ_ = theClusterParam.probabilityQ_;
   theClusterParamBase.filled_from_2d = filled_from_2d;
   if (filled_from_2d) {
     theClusterParamBase.probabilityX_ = theClusterParam.templProbXY_;
     theClusterParamBase.probabilityY_ = 0.;
   } else {
     theClusterParamBase.probabilityX_ = theClusterParam.probabilityX_;
     theClusterParamBase.probabilityY_ = theClusterParam.probabilityY_;
   }
 
   return LocalPoint(theClusterParam.templXrec_, theClusterParam.templYrec_);
 }

Member Data Documentation

◆ barrelTemplateID_

int PixelCPEClusterRepair::barrelTemplateID_

private

Definition at line 110 of file PixelCPEClusterRepair.h.

Referenced by localPosition(), and PixelCPEClusterRepair().

◆ forwardTemplateID_

int PixelCPEClusterRepair::forwardTemplateID_

private

Definition at line 111 of file PixelCPEClusterRepair.h.

Referenced by localPosition(), and PixelCPEClusterRepair().

◆ maxSizeMismatchInY_

float PixelCPEClusterRepair::maxSizeMismatchInY_

private

Definition at line 118 of file PixelCPEClusterRepair.h.

Referenced by checkRecommend2D(), and PixelCPEClusterRepair().

◆ minChargeRatio_

float PixelCPEClusterRepair::minChargeRatio_

private

Definition at line 117 of file PixelCPEClusterRepair.h.

Referenced by checkRecommend2D(), and PixelCPEClusterRepair().

◆ recommend2D_

std::vector<Rule> PixelCPEClusterRepair::recommend2D_

private

Definition at line 145 of file PixelCPEClusterRepair.h.

Referenced by checkRecommend2D(), and PixelCPEClusterRepair().

◆ runDamagedClusters_

bool PixelCPEClusterRepair::runDamagedClusters_

private

Definition at line 148 of file PixelCPEClusterRepair.h.

Referenced by checkRecommend2D(), and PixelCPEClusterRepair().

◆ speed_

int PixelCPEClusterRepair::speed_

private

Definition at line 105 of file PixelCPEClusterRepair.h.

Referenced by callTempReco1D(), and PixelCPEClusterRepair().

◆ templateDBobject2D_

const SiPixel2DTemplateDBObject* PixelCPEClusterRepair::templateDBobject2D_

private

Definition at line 114 of file PixelCPEClusterRepair.h.

Referenced by fill2DTemplIDs(), and PixelCPEClusterRepair().

◆ templateDir_

std::string PixelCPEClusterRepair::templateDir_

private

Definition at line 112 of file PixelCPEClusterRepair.h.

Referenced by PixelCPEClusterRepair().

◆ thePixelTemp2D_

std::vector<SiPixelTemplateStore2D> PixelCPEClusterRepair::thePixelTemp2D_

private

Definition at line 103 of file PixelCPEClusterRepair.h.

Referenced by callTempReco2D(), and PixelCPEClusterRepair().

◆ thePixelTemp_

std::vector<SiPixelTemplateStore> const* PixelCPEClusterRepair::thePixelTemp_

private

Definition at line 101 of file PixelCPEClusterRepair.h.

Referenced by callTempReco1D(), checkRecommend2D(), and PixelCPEClusterRepair().

◆ thePixelTempCache_

std::vector<SiPixelTemplateStore> PixelCPEClusterRepair::thePixelTempCache_

private

Definition at line 102 of file PixelCPEClusterRepair.h.

Referenced by PixelCPEClusterRepair().

◆ UseClusterSplitter_

bool PixelCPEClusterRepair::UseClusterSplitter_

private

Definition at line 107 of file PixelCPEClusterRepair.h.

Referenced by PixelCPEClusterRepair().

Classes

Public Member Functions

Static Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ PixelCPEClusterRepair()

◆ ~PixelCPEClusterRepair()

Member Function Documentation

◆ callTempReco1D()

◆ callTempReco2D()

◆ checkRecommend2D()

◆ createClusterParam()

◆ fill2DTemplIDs()

◆ fillPSetDescription()

◆ localError()

◆ localPosition()

Member Data Documentation

◆ barrelTemplateID_

◆ forwardTemplateID_

◆ maxSizeMismatchInY_

◆ minChargeRatio_

◆ recommend2D_

◆ runDamagedClusters_

◆ speed_

◆ templateDBobject2D_

◆ templateDir_

◆ thePixelTemp2D_

◆ thePixelTemp_

◆ thePixelTempCache_

◆ UseClusterSplitter_