PixelFastDigitizationTool Class Reference

#include <PixelFastDigitizationTool.h>

Inheritance diagram for PixelFastDigitizationTool:

Public Member Functions
	PixelFastDigitizationTool (const std::string &type, const std::string &name, const IInterface *parent)
	Constructor with parameters.
	~PixelFastDigitizationTool ()
	Destructor.
StatusCode	initialize ()
StatusCode	prepareEvent (const EventContext &ctx, unsigned int)
StatusCode	processBunchXing (int bunchXing, SubEventIterator bSubEvents, SubEventIterator eSubEvents)
StatusCode	processAllSubEvents (const EventContext &ctx)
StatusCode	mergeEvent (const EventContext &ctx)
StatusCode	digitize (const EventContext &ctx, TimedHitCollection< SiHit > &thpcsi)
StatusCode	createAndStoreRIOs (const EventContext &ctx)

Private Types
typedef std::multimap< IdentifierHash, InDet::PixelCluster * >	Pixel_detElement_RIO_map

Private Member Functions
	PixelFastDigitizationTool ()
	PixelFastDigitizationTool (const PixelFastDigitizationTool &)
PixelFastDigitizationTool &	operator= (const PixelFastDigitizationTool &)
Trk::DigitizationModule *	buildDetectorModule (const InDetDD::SiDetectorElement *) const

Static Private Member Functions
static bool	areNeighbours (const std::vector< Identifier > &group, const Identifier &rdoID, const InDetDD::SiDetectorElement *, const PixelID &pixelID)
static Amg::Vector3D	CalculateIntersection (const Amg::Vector3D &Point, const Amg::Vector3D &Direction, Amg::Vector2D PlaneBorder, double halfthickness)
static void	Diffuse (HepGeom::Point3D< double > &localEntry, HepGeom::Point3D< double > &localExit, double shiftX, double shiftY)

Private Attributes
TimedHitCollection< SiHit > *	m_thpcsi {}
ServiceHandle< IAthRNGSvc >	m_rndmSvc {this, "RndmSvc", "AthRNGSvc", ""}
	Random number service.
StringProperty	m_randomEngineName {this, "RndmEngine", "FastPixelDigitization"}
	Name of the random number stream.
const PixelID *	m_pixel_ID {}
	Handle to the ID helper.
PublicToolHandle< InDet::ClusterMakerTool >	m_clusterMaker {this, "ClusterMaker", "InDet::ClusterMakerTool/FatrasClusterMaker"}
	ToolHandle to ClusterMaker.
ToolHandle< ISiLorentzAngleTool >	m_lorentzAngleTool {this, "LorentzAngleTool", "PixelLorentzAngleTool", "Tool to retreive Lorentz angle"}
BooleanProperty	m_pixUseClusterMaker {this, "PixelUseClusterMaker", true}
	use the pixel cluster maker or not
InDet::PixelClusterContainer *	m_pixelClusterContainer {}
	the PixelClusterContainer
StringProperty	m_pixel_SiClustersName {this, "PixelClusterContainerName", "PixelClusters"}
ServiceHandle< PileUpMergeSvc >	m_mergeSvc {this, "MergeSvc", "PileUpMergeSvc"}
	PileUp Merge service.
IntegerProperty	m_HardScatterSplittingMode {this, "HardScatterSplittingMode", 0, "Control pileup & signal splitting"}
	Process all SiHit or just those from signal or background events.
bool	m_HardScatterSplittingSkipper {false}
Pixel_detElement_RIO_map *	m_pixelClusterMap {}
StringProperty	m_prdTruthNamePixel {this, "TruthNamePixel", "PRD_MultiTruthPixel"}
PRD_MultiTruthCollection *	m_pixPrdTruth {}
	the PRD truth map for Pixel measurements
PublicToolHandle< InDet::PixelGangedAmbiguitiesFinder >	m_gangedAmbiguitiesFinder {this, "gangedAmbiguitiesFinder", "InDet::PixelGangedAmbiguitiesFinder"}
StringProperty	m_inputObjectName {this, "InputObjectName", "PixelHits"}
std::vector< SiHitCollection * >	m_siHitCollList {}
	name of the sub event hit collections.
double	m_pixTanLorentzAngleScalor {1.}
	scale the lorentz angle effect
BooleanProperty	m_pixEmulateSurfaceCharge {this, "PixelEmulateSurfaceCharge", true}
	emulate the surface charge
DoubleProperty	m_pixSmearPathLength {this, "PixelSmearPathSigma", 0.01}
	the 2.
BooleanProperty	m_pixSmearLandau {this, "PixelSmearLandau", true}
	if true : landau else: gauss
DoubleProperty	m_pixMinimalPathCut {this, "PixelMinimalPathLength", 0.06}
	the 1.
DoubleProperty	m_pixPathLengthTotConv {this, "PixelPathLengthTotConversion", 125.}
	from path length to tot
BooleanProperty	m_pixModuleDistortion {this, "PixelEmulateModuleDistortion", true}
	simulationn of module bowing
DoubleArrayProperty	m_pixPhiError {this, "PixelErrorPhi", {} }
	phi error when not using the ClusterMaker
DoubleArrayProperty	m_pixEtaError {this, "PixelErrorEta", {} }
	eta error when not using the ClusterMaker
IntegerProperty	m_pixErrorStrategy {this, "PixelErrorStrategy", 2}
	error strategy for the ClusterMaker
DoubleProperty	m_pixDiffShiftBarrX {this, "PixDiffShiftBarrX", 0.005}
DoubleProperty	m_pixDiffShiftBarrY {this, "PixDiffShiftBarrY", 0.005}
DoubleProperty	m_pixDiffShiftEndCX {this, "PixDiffShiftEndCX", 0.008}
DoubleProperty	m_pixDiffShiftEndCY {this, "PixDiffShiftEndCY", 0.008}
DoubleProperty	m_ThrConverted {this, "ThrConverted", 50000}
bool	m_mergeCluster {true}
	enable the merging of neighbour Pixel clusters >
short	m_splitClusters {0}
	merging parameter used to define two clusters as neighbour >
bool	m_acceptDiagonalClusters {true}
	merging parameter used to define two clusters as neighbour >
StringProperty	m_pixelClusterAmbiguitiesMapName {this, "PixelClusterAmbiguitiesMapName", "PixelClusterAmbiguitiesMap"}
InDet::PixelGangedClusterAmbiguities *	m_ambiguitiesMap {}
ServiceHandle< InDetDD::IPixelReadoutManager >	m_pixelReadout {this, "PixelReadoutManager", "PixelReadoutManager", "Pixel readout manager" }
SG::ReadCondHandleKey< PixelChargeCalibCondData >	m_chargeDataKey {this, "PixelChargeCalibCondData", "PixelChargeCalibCondData", "Pixel charge calibration data"}
SG::ReadCondHandleKey< PixelCalib::PixelOfflineCalibData >	m_offlineCalibDataKey {this, "PixelOfflineCalibData", "PixelOfflineCalibData", "Pixel offline calibration data"}
SG::ReadCondHandleKey< PixelDistortionData >	m_distortionKey {this, "PixelDistortionData", "PixelDistortionData", "Output readout distortion data"}
SG::ReadCondHandleKey< InDetDD::SiDetectorElementCollection >	m_pixelDetEleCollKey {this, "PixelDetEleCollKey", "PixelDetectorElementCollection", "Key of SiDetectorElementCollection for Pixel"}
PublicToolHandle< Trk::IModuleStepper >	m_digitizationStepper {this, "DigitizationStepper", "Trk::PlanarModuleStepper"}

structors and AlgTool implementation
virtual bool	toProcess (int bunchXing) const override
	the method this base class helps implementing
virtual bool	filterPassed () const override
	dummy implementation of passing filter
virtual void	resetFilter () override
	dummy implementation of filter reset
Gaudi::Property< int >	m_firstXing
Gaudi::Property< int >	m_lastXing
Gaudi::Property< int >	m_vetoPileUpTruthLinks
bool	m_filterPassed {true}

Detailed Description

Definition at line 59 of file PixelFastDigitizationTool.h.

Member Typedef Documentation

Pixel_detElement_RIO_map

typedef std::multimap<IdentifierHash, InDet::PixelCluster*> PixelFastDigitizationTool::Pixel_detElement_RIO_map

private

Definition at line 110 of file PixelFastDigitizationTool.h.

Constructor & Destructor Documentation

PixelFastDigitizationTool() [1/3]

PixelFastDigitizationTool::PixelFastDigitizationTool	(	const std::string &	type,
		const std::string &	name,
		const IInterface *	parent )

Constructor with parameters.

Definition at line 66 of file PixelFastDigitizationTool.cxx.

                                                                              :
 
  PileUpToolBase(type, name, parent)
{
}

~PixelFastDigitizationTool()

PixelFastDigitizationTool::~PixelFastDigitizationTool

(

)

Destructor.

Definition at line 73 of file PixelFastDigitizationTool.cxx.

                                                      {
  if(m_pixelClusterMap) {
    delete m_pixelClusterMap;
  }
}

PixelFastDigitizationTool() [2/3]

PixelFastDigitizationTool::PixelFastDigitizationTool ( )

private

PixelFastDigitizationTool() [3/3]

PixelFastDigitizationTool::PixelFastDigitizationTool ( const PixelFastDigitizationTool & )

private

Member Function Documentation

areNeighbours()

bool PixelFastDigitizationTool::areNeighbours ( const std::vector< Identifier > & group, const Identifier & rdoID, const InDetDD::SiDetectorElement * , const PixelID & pixelID )

staticprivate

Definition at line 838 of file PixelFastDigitizationTool.cxx.

{
  // note: in the PixelClusteringToolBase, m_splitClusters is a variable; here
  // splitClusters was explicitly set to zero, acceptDiagonalClusters = 1
  // so much of the original code is redundant and only one path through the code
  // is possible.
 
  std::vector<Identifier>::const_iterator groupBegin = group.begin();
  std::vector<Identifier>::const_iterator groupEnd = group.end();
 
  int row2 = pixelID.phi_index(rdoID);
  int col2 = pixelID.eta_index(rdoID);
 
  int rowmax = row2;
  bool match=false;
  while (groupBegin!=groupEnd)
    {
      Identifier id = *groupBegin;
      int row1 = pixelID.phi_index(id);
      int col1 = pixelID.eta_index(id);
      if(row1 > rowmax) rowmax = row1;
      int deltarow = abs(row2-row1);
      int deltacol = abs(col2-col1);
 
      // a side in common
      if(deltacol+deltarow < 2) match = true;
      //condition "if (acceptDiagonalClusters !=0") is redundant
      if(deltacol == 1 && deltarow == 1) match = true;
 
      ++groupBegin;
    }
 
 
  return match;
}

buildDetectorModule()

Trk::DigitizationModule * PixelFastDigitizationTool::buildDetectorModule ( const InDetDD::SiDetectorElement * hitSiDetElement ) const

private

Definition at line 878 of file PixelFastDigitizationTool.cxx.

                                                                                                                            {
 
  const InDetDD::PixelModuleDesign* design(dynamic_cast<const InDetDD::PixelModuleDesign*>(&hitSiDetElement->design()));
 
  if (!design) {
    ATH_MSG_DEBUG ( "Could not get design"<< design) ;
    return nullptr;
  }
 
  //Read from the SiDetectorElement information to build the digitization module
  const double halfThickness = hitSiDetElement->thickness() * 0.5;
  const double halfWidth     = design->width() * 0.5;
  const double halfLength    = design->length() * 0.5;
 
  int binsX = design->rows();
  int binsY = design->columns();
  double numberOfChip = design->numberOfCircuits();
 
  InDetDD::SiCellId cell(0,binsY/2);
  float LongPitch  =design->parameters(cell).width().xEta();
  //std::cout<<"numberOfChip "<<numberOfChip<<" LongPitch "<<LongPitch<<std::endl;
 
  ATH_MSG_VERBOSE("Retrieving infos: halfThickness = " << halfThickness << " --- halfWidth = " << halfWidth << " --- halfLength = " << halfLength );
  ATH_MSG_VERBOSE("Retrieving infos: binsX = " << binsX << " --- binsY = " << binsY << " --- numberOfChip = " << numberOfChip);
 
  int readoutDirection = design->readoutSide();
 
  const bool useLorentzAngle{true};
  const IdentifierHash detElHash = hitSiDetElement->identifyHash();
  float lorentzAngle   = useLorentzAngle ? hitSiDetElement->hitDepthDirection()*hitSiDetElement->hitPhiDirection()*std::atan(m_lorentzAngleTool->getTanLorentzAngle(detElHash, Gaudi::Hive::currentContext())) : 0.;
 
  // added for degugging
 
  // std::cout << "barrel_ec  = " << m_detID->barrel_ec(hitSiDetElement->identify())
  //           << " --  layer_disk = " << m_detID->layer_disk(hitSiDetElement->identify())
  //           << " --  eta_module = " << m_detID->eta_module(hitSiDetElement->identify())
  //           << " --  lorentzAngle = " << lorentzAngle
  //        << " --  lorentzCorrection = " << shift
  //        << " --  readoutDirection = " << readoutDirection << std::endl;
  // std::cout << "element->hitDepthDirection() = " << hitSiDetElement->hitDepthDirection()
  //        << " --  element->hitPhiDirection() = " << hitSiDetElement->hitPhiDirection() << std::endl;
 
  // rectangle bounds
  auto rectangleBounds = std::make_shared<const Trk::RectangleBounds>(halfWidth,halfLength);
  ATH_MSG_VERBOSE("Initialized rectangle Bounds");
  // create the segmentation
  std::shared_ptr<const Trk::Segmentation> rectangleSegmentation(new Trk::RectangularSegmentation(std::move(rectangleBounds),(size_t)binsX,LongPitch,(size_t)binsY, numberOfChip));
  // build the module
  ATH_MSG_VERBOSE("Initialized rectangleSegmentation");
  Trk::DigitizationModule * digitizationModule = new Trk::DigitizationModule(std::move(rectangleSegmentation),
                                                                               halfThickness,
                                                                               readoutDirection,
                                                                               lorentzAngle);
  ATH_MSG_VERBOSE("Building Rectangle Segmentation with dimensions (halfX, halfY) = (" << halfWidth << ", " << halfLength << ")");
 
  // success return
  return digitizationModule;
}

CalculateIntersection()

Amg::Vector3D PixelFastDigitizationTool::CalculateIntersection ( const Amg::Vector3D & Point, const Amg::Vector3D & Direction, Amg::Vector2D PlaneBorder, double halfthickness )

staticprivate

Definition at line 938 of file PixelFastDigitizationTool.cxx.

{
  Amg::Vector3D Intersection(0.,0.,0.);
 
  //Using parameter definition of a line in 3d z=z_point + direction_z t
  std::vector<double> parameters;
  parameters.push_back((PlaneBorder.x() - Point.x())/Direction.x());
  parameters.push_back((-PlaneBorder.x() - Point.x())/Direction.x());
  parameters.push_back((PlaneBorder.y() - Point.y())/Direction.y());
  parameters.push_back((-PlaneBorder.y() - Point.y())/Direction.y());
 
  for(double parameter: parameters)
    {
      double z =  Point.z() + Direction.z() * parameter;
      if( std::abs(z) > halfthickness )
        continue;
 
 
      double x = Point.x() + Direction.x() * parameter;
      double y = Point.y() + Direction.y() * parameter;
 
      if(std::abs(x) > PlaneBorder.x() || std::abs(y) > PlaneBorder.y())
        continue;
 
 
      Intersection = Amg::Vector3D(x,y,z);
      break;
 
    }
 
  return Intersection;
}

createAndStoreRIOs()

StatusCode PixelFastDigitizationTool::createAndStoreRIOs

(

const EventContext &

ctx

)

Definition at line 794 of file PixelFastDigitizationTool.cxx.

{
  SG::ReadCondHandle<InDetDD::SiDetectorElementCollection> pixelDetEleHandle(m_pixelDetEleCollKey, ctx);
  const InDetDD::SiDetectorElementCollection* elements(*pixelDetEleHandle);
  if (not pixelDetEleHandle.isValid() or elements==nullptr) {
    ATH_MSG_FATAL(m_pixelDetEleCollKey.fullKey() << " is not available.");
    return StatusCode::FAILURE;
  }
 
  Pixel_detElement_RIO_map::iterator i = m_pixelClusterMap->begin();
  Pixel_detElement_RIO_map::iterator e = m_pixelClusterMap->end();
 
  //InDet::PixelClusterCollection* clusterCollection = nullptr;
  IdentifierHash waferHash;
 
  for (; i != e; i = m_pixelClusterMap->upper_bound(i->first)){
    std::pair <Pixel_detElement_RIO_map::iterator, Pixel_detElement_RIO_map::iterator> range;
    range = m_pixelClusterMap->equal_range(i->first);
    Pixel_detElement_RIO_map::iterator firstDetElem;
    firstDetElem = range.first;
    waferHash = firstDetElem->first;
    const InDetDD::SiDetectorElement* detElement = elements->getDetectorElement(waferHash);
    auto clusterCollection = std::make_unique<InDet::PixelClusterCollection>(waferHash);
    clusterCollection->setIdentifier(detElement->identify());
    for ( Pixel_detElement_RIO_map::iterator iter = range.first; iter != range.second; ++iter){
      InDet::PixelCluster* pixelCluster = (*iter).second;
      pixelCluster->setHashAndIndex(clusterCollection->identifyHash(),clusterCollection->size());
      clusterCollection->push_back(pixelCluster);
    }
    if (!clusterCollection->empty()) {
      ATH_MSG_DEBUG ( "Filling ambiguities map" );
      m_gangedAmbiguitiesFinder->execute(clusterCollection.get(),*m_ambiguitiesMap);
      ATH_MSG_DEBUG ( "Ambiguities map: " << m_ambiguitiesMap->size() << " elements" );
      if ((m_pixelClusterContainer->addCollection(clusterCollection.release(), waferHash)).isFailure()){
        ATH_MSG_WARNING( "Could not add collection to Identifyable container !" );
      }
    }
  } // end for
 
  m_pixelClusterMap->clear();
 
  return StatusCode::SUCCESS;
}

Diffuse()

void PixelFastDigitizationTool::Diffuse ( HepGeom::Point3D< double > & localEntry, HepGeom::Point3D< double > & localExit, double shiftX, double shiftY )

staticprivate

Definition at line 971 of file PixelFastDigitizationTool.cxx.

                                                                                                                                           {
 
  double localEntryX = localEntry.x();
  double localEntryY = localEntry.y();
  double localExitX = localExit.x();
  double localExitY = localExit.y();
 
  double signX = localExitX>localEntryX ? 1:-1 ;
  double signY = localExitY>localEntryY ? 1:-1 ;
 
  localEntryX += shiftX*signX*(-1);
  localExitX += shiftX*signX;
  localEntryY += shiftY*signY*(-1);
  localExitY += shiftY*signY;
 
  localEntry.setX(localEntryX);
  localEntry.setY(localEntryY);
  localExit.setX(localExitX);
  localExit.setY(localExitY);
 
}

digitize()

StatusCode PixelFastDigitizationTool::digitize	(	const EventContext &	ctx,
		TimedHitCollection< SiHit > &	thpcsi )

Definition at line 374 of file PixelFastDigitizationTool.cxx.

{
  // Set the RNG to use for this event.
  ATHRNG::RNGWrapper* rngWrapper = m_rndmSvc->getEngine(this, m_randomEngineName);
  const std::string rngName = name()+m_randomEngineName;
  rngWrapper->setSeed( rngName, ctx );
  CLHEP::HepRandomEngine *rndmEngine = rngWrapper->getEngine(ctx);
 
  SG::ReadCondHandle<InDetDD::SiDetectorElementCollection> pixelDetEleHandle(m_pixelDetEleCollKey, ctx);
  const InDetDD::SiDetectorElementCollection* elements(*pixelDetEleHandle);
  if (not pixelDetEleHandle.isValid() or elements==nullptr) {
    ATH_MSG_FATAL(m_pixelDetEleCollKey.fullKey() << " is not available.");
    return StatusCode::FAILURE;
  }
 
  TimedHitCollection<SiHit>::const_iterator i, e;
 
  if(!m_pixelClusterMap) { m_pixelClusterMap = new Pixel_detElement_RIO_map; }
  else { m_pixelClusterMap->clear(); }
 
  SG::ReadCondHandle<PixelChargeCalibCondData> calibDataHandle(m_chargeDataKey, ctx);
  const PixelChargeCalibCondData *calibData = *calibDataHandle;
  SG::ReadCondHandle<PixelCalib::PixelOfflineCalibData> offlineCalibData(m_offlineCalibDataKey, ctx);
  std::vector<int> truthIdList;
  std::vector<Identifier> detEl;
 
  while (thpcsi.nextDetectorElement(i, e)) {
 
    Pixel_detElement_RIO_map PixelDetElClusterMap;
 
    truthIdList.clear();
    detEl.clear();
 
    while (i != e) {
 
      const TimedHitPtr<SiHit>& hit(*i++);
      // check the status of truth information for this SiHit
      // some Truth information is cut for pile up events
      const HepMcParticleLink currentLink = HepMcParticleLink::getRedirectedLink(hit->particleLink(), hit.eventId(), ctx); // This link should now correctly resolve to the TruthEvent McEventCollection in the main StoreGateSvc.
      const int barrelEC = hit->getBarrelEndcap();
      const int layerDisk = hit->getLayerDisk();
      const int phiModule = hit->getPhiModule();
      const int etaModule = hit->getEtaModule();
 
      const Identifier moduleID = m_pixel_ID->wafer_id(barrelEC, layerDisk, phiModule, etaModule);
      const IdentifierHash waferHash = m_pixel_ID->wafer_hash(moduleID);
      const InDetDD::SiDetectorElement* hitSiDetElement = elements->getDetectorElement(waferHash);
      if (!hitSiDetElement) {ATH_MSG_ERROR( " could not get detector element "); continue;}
 
      if (!(hitSiDetElement->isPixel())) {continue;}
 
 
 
      std::vector<HepMcParticleLink> hit_vector; //Store the hits in merged cluster
 
      const int truthID = (currentLink.barcode() !=0 && currentLink.id() == 0) ? 3 : currentLink.id(); // FIXME barcode-based Patch for reading in legacy barcode-based EDM - if the barcode is non-zero, but the id is zero then we must be looking at a particle linked to suppressed pile-up truth - such SiHits would be linked to the third GenParticle in their GenEvents (if they were present)
 
      const Identifier hitId = hitSiDetElement->identify(); // Isn't this is identical to moduleID?
      //const IdentifierHash hitIdHash = hitSiDetElement->identifyHash();
 
 
      bool isRep = false;
 
      for (int j : truthIdList) {
        for (auto & k : detEl) {
          if ((truthID > 0) && (truthID == j) && (hitId == k)) {isRep = true; break;}
        }
        if (isRep) break;
      }
 
      if (isRep) continue;
 
      truthIdList.push_back(truthID);
      detEl.push_back(hitId);
 
      HepGeom::Point3D<double> localStartPosition = hit->localStartPosition();
      HepGeom::Point3D<double> localEndPosition = hit->localEndPosition();
 
      localStartPosition = hitSiDetElement->hitLocalToLocal3D(localStartPosition);
      localEndPosition = hitSiDetElement->hitLocalToLocal3D(localEndPosition);
 
      int isEndcap = (barrelEC==0) ? 0:1;
 
      double shiftX = isEndcap ? m_pixDiffShiftEndCX : m_pixDiffShiftBarrX;
      double shiftY = isEndcap ? m_pixDiffShiftEndCY : m_pixDiffShiftBarrY;
 
      //       std::cout<<"Thr "<<m_ThrConverted<<std::endl;
 
      //New function to tune the cluster size
      Diffuse(localStartPosition, localEndPosition, shiftX, shiftY);
 
      const Amg::Vector3D localDirection(localEndPosition.x()-localStartPosition.x(), localEndPosition.y()-localStartPosition.y(), localEndPosition.z()-localStartPosition.z());
 
      Amg::Vector3D entryPoint(localStartPosition.x(),localStartPosition.y(),localStartPosition.z());
      Amg::Vector3D exitPoint(localEndPosition.x(),localEndPosition.y(),localEndPosition.z());
 
      const InDetDD::PixelModuleDesign* design(dynamic_cast<const InDetDD::PixelModuleDesign*>(&hitSiDetElement->design()));
      if (not design){
        ATH_MSG_FATAL("Failed to cast the hitSiDetElement::design pointer to a PixelModuleDesign*; aborting due to null pointer");
        return StatusCode::FAILURE;
      }
      const Amg::Vector2D localEntry(localStartPosition.x(),localStartPosition.y());
      const Amg::Vector2D localExit(localEndPosition.x(),localEndPosition.y());
 
      Identifier entryId = hitSiDetElement->identifierOfPosition(localEntry);
      Identifier exitId  = hitSiDetElement->identifierOfPosition(localExit);
 
      InDetDD::SiCellId entryCellId = hitSiDetElement->cellIdFromIdentifier(entryId);
      InDetDD::SiCellId exitCellId = hitSiDetElement->cellIdFromIdentifier(exitId);
 
      double halfthickness = hitSiDetElement->thickness()*0.5;
 
      bool EntryValid(entryCellId.isValid());
      bool ExitValid(exitCellId.isValid());
 
      double pixMinimalPathCut= 1. / m_pixPathLengthTotConv;
 
      Identifier diodeID = hitId;
      unsigned int FE = m_pixelReadout->getFE(diodeID, moduleID);
      InDetDD::PixelDiodeType type = m_pixelReadout->getDiodeType(diodeID);
 
      double th0 = calibData->getThresholds(type, waferHash, FE).value/ m_ThrConverted;
 
      //        if (old_th != th0) std::cout<<"converted threshold "<<th0<<std::endl, old_th= th0;
 
      //Avoid to store pixels with 0 ToT
      //if (m_pixMinimalPathCut > pixMinimalPathCut) pixMinimalPathCut=m_pixMinimalPathCut;
      //if (th0 > pixMinimalPathCut) ;
      pixMinimalPathCut=th0;
 
      if (!EntryValid || !ExitValid)
        {
          //If entry or exit aren't valid search for the valid entry/exit of the hit as Intersection with the module
 
          if ( !EntryValid && !ExitValid) continue;
 
          Amg::Vector3D Point = EntryValid ? entryPoint : exitPoint ;
 
          Amg::Vector3D Intersection =  CalculateIntersection(Point, localDirection, Amg::Vector2D(design->width() * 0.5,design->length() * 0.5),halfthickness);
 
          if( Intersection == Amg::Vector3D(0.,0.,0.))
            {
              ATH_MSG_WARNING("ATTENTION THE INTERSECTION COORDINATE IS OUT OF THE MODULE");
              continue;
            }
 
          const Amg::Vector2D Intersection_2d(Intersection.x(),Intersection.y());
          Identifier Intersection_2dId = hitSiDetElement->identifierOfPosition(Intersection_2d);
 
          InDetDD::SiCellId Intersection_2dCellId = hitSiDetElement->cellIdFromIdentifier(Intersection_2dId);
 
 
          if(!Intersection_2dCellId.isValid()) continue;
 
          if(EntryValid)
            exitPoint = Intersection;
          else
            entryPoint = Intersection;
 
 
        }
 
 
 
      Trk::DigitizationModule * digitizationModule = buildDetectorModule(hitSiDetElement);
      if(!digitizationModule){
        ATH_MSG_FATAL( " could not get build detector module ");
        return StatusCode::FAILURE;
      }
 
      // Getting the steps in the sensor
      std::vector<Trk::DigitizationStep> digitizationSteps = m_digitizationStepper->cellSteps(*digitizationModule,entryPoint,exitPoint);
 
 
 
      // the pixel positions and other needed stuff for the geometrical clustering
      std::unique_ptr<InDet::PixelCluster> pixelCluster = nullptr;
      Amg::Vector2D       clusterPosition(0.,0.);
 
      std::vector<Identifier>           rdoList;
      std::vector<int>                  totList;
 
      const bool   isGanged = false;
      int lvl1a = 0;
 
      double accumulatedPathLength=0.;
 
      //ATTENTION index max e min da rdo + manager
      int phiIndexMax = -999999;
      int phiIndexMin = 1000000;
      int etaIndexMax = -999999;
      int etaIndexMin = 1000000;
 
 
      for (auto& dStep : digitizationSteps){
 
        double pathlength = dStep.stepLength;
        // two options fro charge smearing: landau / gauss
        if ( m_pixSmearPathLength > 0. ) {
          // create the smdar parameter
          double sPar = m_pixSmearLandau ?
            m_pixSmearPathLength*CLHEP::RandLandau::shoot(rndmEngine) :
            m_pixSmearPathLength*CLHEP::RandGaussZiggurat::shoot(rndmEngine);
          pathlength *=  (1.+sPar);
        }
 
 
        if (pathlength < pixMinimalPathCut) continue;
 
        // position on the diode map
        Trk::DigitizationCell cell(dStep.stepCell.first,dStep.stepCell.second);
        Amg::Vector2D PositionOnModule = digitizationModule->segmentation().cellPosition(cell);
        InDetDD::SiCellId diode = hitSiDetElement->cellIdOfPosition(PositionOnModule);
 
 
        if (!diode.isValid())
          continue;
 
        Amg::Vector2D chargeCenterPosition = hitSiDetElement->rawLocalPositionOfCell(diode);
 
        const Identifier rdoId            =  hitSiDetElement->identifierOfPosition(chargeCenterPosition);
        clusterPosition += pathlength * chargeCenterPosition;
 
        int currentEtaIndex = diode.etaIndex();
        int currentPhiIndex = diode.phiIndex();
        if(currentEtaIndex > etaIndexMax) etaIndexMax = currentEtaIndex;
        if(currentEtaIndex < etaIndexMin) etaIndexMin = currentEtaIndex;
        if(currentPhiIndex > phiIndexMax) phiIndexMax = currentPhiIndex;
        if(currentPhiIndex < phiIndexMin) phiIndexMin = currentPhiIndex;
 
 
        // record - positions, rdoList and totList
        accumulatedPathLength += pathlength;
        //Fail
        rdoList.push_back(rdoId);
        totList.push_back(int(pathlength*m_pixPathLengthTotConv));
 
      }
 
      delete digitizationModule;
 
      // the col/row
      int siDeltaPhiCut = phiIndexMax-phiIndexMin+1;
      int siDeltaEtaCut = etaIndexMax-etaIndexMin+1;
 
      int totalToT=std::accumulate(totList.begin(), totList.end(), 0);;
 
      // bail out if 0 pixel or path length problem
      if (rdoList.empty() || accumulatedPathLength < pixMinimalPathCut || totalToT == 0) {
        if (totalToT == 0 && !rdoList.empty() ) ATH_MSG_WARNING("The total ToT of the cluster is 0, this should never happen");
        continue;
      }
 
      // weight the cluster position
      //accumulatedPathLength was checked in previous lines
      //coverity[DIVIDE_BY_ZERO:FALSE]
      clusterPosition *= 1./accumulatedPathLength;
      Identifier clusterId = hitSiDetElement->identifierOfPosition(clusterPosition);
 
 
      // merging clusters
 
      bool merged = false;
      if(m_mergeCluster){ // merge to the current cluster "near" cluster in the cluster map, in the current detector element
 
        for(Pixel_detElement_RIO_map::iterator currentClusIter = PixelDetElClusterMap.begin(); currentClusIter != PixelDetElClusterMap.end();) {
          //make a temporary to use within the loop and possibly erase - increment the main interator at the same time.
          Pixel_detElement_RIO_map::iterator clusIter = currentClusIter++;
          InDet::PixelCluster* currentCluster = clusIter->second;
          const std::vector<Identifier> &currentRdoList = currentCluster->rdoList();
          bool areNb = false;
          for (auto rdoIter : rdoList) {
            areNb = PixelFastDigitizationTool::areNeighbours(currentRdoList, rdoIter, hitSiDetElement,*m_pixel_ID);
            if (areNb) { break; }
          }
          if (areNb) {
            const std::vector<int> &currentTotList = currentCluster->totList();
            rdoList.insert(rdoList.end(), currentRdoList.begin(), currentRdoList.end() );
            totList.insert(totList.end(), currentTotList.begin(), currentTotList.end() );
            Amg::Vector2D       currentClusterPosition(currentCluster->localPosition());
            float c1 = (float)currentRdoList.size();
            float c2 = (float)rdoList.size();
            clusterPosition = (clusterPosition*c2 + currentClusterPosition*c1)/((c1 + c2));
            clusterId = hitSiDetElement->identifierOfPosition(clusterPosition);
            merged = true;
            PixelDetElClusterMap.erase(clusIter);
 
            //Store HepMcParticleLink connected to the cluster removed from the collection
            std::pair<PRD_MultiTruthCollection::iterator,PRD_MultiTruthCollection::iterator> saved_hit = m_pixPrdTruth->equal_range(currentCluster->identify());
            for (PRD_MultiTruthCollection::iterator this_hit = saved_hit.first; this_hit != saved_hit.second; ++this_hit)
              {
                hit_vector.push_back(this_hit->second);
              }
            //Delete all the occurency of the currentCluster from the multi map
            if (saved_hit.first != saved_hit.second) m_pixPrdTruth->erase(currentCluster->identify());
            delete currentCluster;
            //break; //commenting out this break statement allows for multiple existing clusters to be merged.
          }
        }
      }
 
      bool not_valid = false;
      for (auto & entry : rdoList) {
        if (!(entry.is_valid())) { not_valid = true; break;}
      }
 
      if (not_valid) continue;
 
      if(merged) {
        //Hacks for merged clusters
        for (auto rdoIter : rdoList) {
          const InDetDD::SiCellId& chargeCellId =  hitSiDetElement->cellIdFromIdentifier(rdoIter);
          // phi/ eta index
          int chargePhiIndex = chargeCellId.phiIndex();
          int chargeEtaIndex = chargeCellId.etaIndex();
          // set max min
          phiIndexMin = chargePhiIndex < phiIndexMin ?  chargePhiIndex : phiIndexMin;
          phiIndexMax = chargePhiIndex > phiIndexMax ?  chargePhiIndex : phiIndexMax;
          etaIndexMin = chargeEtaIndex < etaIndexMin ?  chargeEtaIndex : etaIndexMin;
          etaIndexMax = chargeEtaIndex > etaIndexMax ?  chargeEtaIndex : etaIndexMax;
        }
        siDeltaPhiCut = (phiIndexMax-phiIndexMin)+1;
        siDeltaEtaCut = (etaIndexMax-etaIndexMin)+1;
      }
 
      // ---------------------------------------------------------------------------------------------
      //  PART 2: Cluster && ROT creation
 
 
      //ATTENTION
      //       // correct shift implied by the scaling of the Lorentz angle
      //       double newshift = 0.5*thickness*tanLorAng;
      //       double corr = ( shift - newshift );
      // 2a) Cluster creation ------------------------------------
      if (m_pixUseClusterMaker) {
 
        // from InDetReadoutGeometry: width from eta
        const auto* pixModDesign =
            dynamic_cast<const InDetDD::PixelModuleDesign*>(
                &hitSiDetElement->design());
        if (!pixModDesign) {
          return StatusCode::FAILURE;
        }
        double etaWidth =
            pixModDesign->widthFromColumnRange(etaIndexMin, etaIndexMax);
        // from InDetReadoutGeometry : width from phi
        double phiWidth =
            pixModDesign->widthFromRowRange(phiIndexMin, phiIndexMax);
 
        InDet::SiWidth siWidth(Amg::Vector2D(siDeltaPhiCut, siDeltaEtaCut),
                               Amg::Vector2D(phiWidth, etaWidth));
 
        // use the cluster maker from the offline software
        pixelCluster =
            std::make_unique<PixelCluster>(m_clusterMaker->pixelCluster(
                clusterId, clusterPosition, std::move(rdoList),
                lvl1a, std::move(totList), siWidth,
                hitSiDetElement, isGanged, m_pixErrorStrategy, *m_pixel_ID,
                false, 0.0, 0.0, calibData, *offlineCalibData, ctx));
        if (isGanged) {
          pixelCluster->setGangedPixel(isGanged);
        }
      } else {
        ATH_MSG_WARNING(
            "[ cluster - pix ] No pixels errors provided, but configured to "
            "use them.");
        ATH_MSG_WARNING(
            "                  -> No pixels cluster will be created.");
        continue;
      }
 
      if (!(pixelCluster->identify().is_valid())) {
        pixelCluster.reset();
        continue;
      }
 
      if (!(m_pixel_ID->is_pixel(pixelCluster->identify()))) {
        pixelCluster.reset();
        continue;
      }
 
      const auto it =
          PixelDetElClusterMap.insert(Pixel_detElement_RIO_map::value_type(
              waferHash, pixelCluster.release()));
      const PixelCluster* insertedCluster = it->second;
 
      if (currentLink.isValid()) {
        if (!HepMC::ignoreTruthLink(currentLink, m_vetoPileUpTruthLinks)) {
          m_pixPrdTruth->insert(
              std::make_pair(insertedCluster->identify(), currentLink));
          ATH_MSG_DEBUG("Truth map filled with cluster"
                        << insertedCluster
                        << " and link = " << currentLink);
        }
      } else {
        ATH_MSG_DEBUG(
            "Particle link NOT valid!! Truth map NOT filled with cluster"
            << insertedCluster << " and link = " << currentLink);
      }
 
      // Add all hit that was connected to the cluster
      for (const HepMcParticleLink& p : hit_vector) {
 
        m_pixPrdTruth->insert(std::make_pair(insertedCluster->identify(), p ));
      }
 
      hit_vector.clear();
    } // end hit while
 
 
    (void) m_pixelClusterMap->insert(PixelDetElClusterMap.begin(), PixelDetElClusterMap.end());
 
 
  } // end nextDetectorElement while
 
 
  return StatusCode::SUCCESS;
}

filterPassed()

virtual bool PileUpToolBase::filterPassed ( ) const

inlineoverridevirtualinherited

dummy implementation of passing filter

Definition at line 49 of file PileUpToolBase.h.

{ return m_filterPassed; }

initialize()

StatusCode PixelFastDigitizationTool::initialize ( )

virtual

Reimplemented from PileUpToolBase.

Definition at line 80 of file PixelFastDigitizationTool.cxx.

{
 
  ATH_MSG_DEBUG ( "PixelDigitizationTool::initialize()" );
 
  ATH_CHECK(m_pixelReadout.retrieve());
  ATH_CHECK(m_chargeDataKey.initialize());
  ATH_CHECK(m_offlineCalibDataKey.initialize());
  ATH_CHECK(m_pixelDetEleCollKey.initialize());
 
  //locate the AtRndmGenSvc and initialize our local ptr
  if (!m_rndmSvc.retrieve().isSuccess())
    {
      ATH_MSG_ERROR ( "Could not find given RndmSvc" );
      return StatusCode::FAILURE;
    }
 
  if (detStore()->retrieve(m_pixel_ID, "PixelID").isFailure()) {
    ATH_MSG_ERROR ( "Could not get Pixel ID helper" );
    return StatusCode::FAILURE;
  }
 
  if (m_inputObjectName.empty())
    {
      ATH_MSG_FATAL ( "Property InputObjectName not set !" );
      return StatusCode::FAILURE;
    }
  else
    {
      ATH_MSG_DEBUG ( "Input objects: '" << m_inputObjectName << "'" );
    }
 
  // retrieve the offline cluster maker : for pixel and/or sct
  if ( m_pixUseClusterMaker) {
    if (m_clusterMaker.retrieve().isFailure()){
      ATH_MSG_WARNING( "Could not retrieve " << m_clusterMaker );
      ATH_MSG_WARNING( "-> Switching to simplified cluster creation!" );
      m_pixUseClusterMaker = false;
      m_clusterMaker.disable();
    }
  } else {
    m_clusterMaker.disable();
  }
 
  if (m_pixModuleDistortion) {
    ATH_CHECK(m_distortionKey.initialize());
  }
 
  //locate the PileUpMergeSvc and initialize our local ptr
  if (!m_mergeSvc.retrieve().isSuccess()) {
    ATH_MSG_ERROR ( "Could not find PileUpMergeSvc" );
    return StatusCode::FAILURE;
  }
 
 
  // get the InDet::PixelGangedAmbiguitiesFinder
  if ( m_gangedAmbiguitiesFinder.retrieve().isFailure() ) {
    ATH_MSG_FATAL( m_gangedAmbiguitiesFinder.propertyName() << ": Failed to retrieve tool " << m_gangedAmbiguitiesFinder.type() );
    return StatusCode::FAILURE;
  } else {
    ATH_MSG_DEBUG ( m_gangedAmbiguitiesFinder.propertyName() << ": Retrieved tool " << m_gangedAmbiguitiesFinder.type() );
  }
 
  ATH_CHECK(m_lorentzAngleTool.retrieve());
 
  return StatusCode::SUCCESS;
}

mergeEvent()

StatusCode PixelFastDigitizationTool::mergeEvent

(

const EventContext &

ctx

)

Definition at line 304 of file PixelFastDigitizationTool.cxx.

{
 
  // --------------------------------------
  // Pixel_Cluster container registration
  unsigned int nwafer = m_pixel_ID->wafer_hash_max();
  SG::WriteHandle<InDet::PixelClusterContainer> wh ("PixelClusters");
  ATH_CHECK( wh.record (std::make_unique<InDet::PixelClusterContainer>(nwafer)) );
  m_pixelClusterContainer = wh.ptr();
  m_pixelClusterContainer->cleanup();
 
  // symlink the Pixel Cluster Container
  // FIXME: This results in a hard cast, which is undefined behavior as per C++.
  ATH_CHECK( wh.symLink (SG::WriteHandleKey<InDet::SiClusterContainer>(wh.key())) );
 
  // truth info
  m_pixPrdTruth = new PRD_MultiTruthCollection;
 
  if ((evtStore()->contains<PRD_MultiTruthCollection>(m_prdTruthNamePixel))){
    if((evtStore()->retrieve(m_pixPrdTruth, m_prdTruthNamePixel)).isFailure()){
      ATH_MSG_FATAL("Could not retrieve collection " << m_prdTruthNamePixel);
      return StatusCode::FAILURE;
    }
  }else{
    if((evtStore()->record(m_pixPrdTruth, m_prdTruthNamePixel)).isFailure()){
      ATH_MSG_FATAL("Could not record collection " << m_prdTruthNamePixel);
      return StatusCode::FAILURE;
    }
  }
 
  m_ambiguitiesMap =new PixelGangedClusterAmbiguities();
 
  if (m_thpcsi != nullptr) {
    if(digitize(ctx, *m_thpcsi).isFailure()) {
      ATH_MSG_FATAL ( "Pixel digitize method failed!" );
      return StatusCode::FAILURE;
    }
  }
 
  delete m_thpcsi;
  for(SiHitCollection* ptr : m_siHitCollList) delete ptr;
  m_siHitCollList.clear();
 
 
  if (createAndStoreRIOs(ctx).isFailure()) {
    ATH_MSG_FATAL ( "createAndStoreRIOs() failed!" );
    return StatusCode::FAILURE;
  }
  else {
    ATH_MSG_DEBUG ( "createAndStoreRIOs() succeeded" );
  }
 
  if ((evtStore()->setConst(m_pixelClusterContainer)).isFailure()) {
    ATH_MSG_ERROR("[ ---- ] Could not set Pixel ROT container ");
  }
  ATH_MSG_DEBUG ("Ambiguities map has " << m_ambiguitiesMap->size() << " elements" );
  StatusCode sc = evtStore()->record(m_ambiguitiesMap,m_pixelClusterAmbiguitiesMapName,false);
  if (sc.isFailure()){
    ATH_MSG_FATAL ( "PixelClusterAmbiguitiesMap could not be recorded in StoreGate !" );
    return StatusCode::FAILURE;
  }else{
    ATH_MSG_DEBUG ( "PixelClusterAmbiguitiesMap recorded in StoreGate" );
  }
 
 
 
  return StatusCode::SUCCESS;
}

operator=()

PixelFastDigitizationTool & PixelFastDigitizationTool::operator= ( const PixelFastDigitizationTool & )

private

prepareEvent()

StatusCode PixelFastDigitizationTool::prepareEvent	(	const EventContext &	ctx,
		unsigned int	)

Definition at line 150 of file PixelFastDigitizationTool.cxx.

{
 
  m_siHitCollList.clear();
  m_thpcsi = new TimedHitCollection<SiHit>();
  m_HardScatterSplittingSkipper = false;
  return StatusCode::SUCCESS;
}

processAllSubEvents()

StatusCode PixelFastDigitizationTool::processAllSubEvents ( const EventContext & ctx )

virtual

Reimplemented from PileUpToolBase.

Definition at line 201 of file PixelFastDigitizationTool.cxx.

                                                                                 {
 
  // --------------------------------------
  // Pixel Cluster container registration
  unsigned int nwafer = m_pixel_ID->wafer_hash_max();
  SG::WriteHandle<InDet::PixelClusterContainer> wh (m_pixel_SiClustersName);
  ATH_CHECK( wh.record (std::make_unique<InDet::PixelClusterContainer>(nwafer)) );
  m_pixelClusterContainer = wh.ptr();
  m_pixelClusterContainer->cleanup();
 
  // symlink the Pixel Cluster Container
  // FIXME: This results in a hard cast, which is undefined behavior as per C++.
  ATH_CHECK( wh.symLink (SG::WriteHandleKey<InDet::SiClusterContainer>(wh.key())) );
 
  // truth info
 
  m_pixPrdTruth = new PRD_MultiTruthCollection;
 
  if ((evtStore()->contains<PRD_MultiTruthCollection>(m_prdTruthNamePixel))){
    if((evtStore()->retrieve(m_pixPrdTruth, m_prdTruthNamePixel)).isFailure()){
      ATH_MSG_FATAL("Could not retrieve collection " << m_prdTruthNamePixel);
      return StatusCode::FAILURE;
    }
  }else{
    if((evtStore()->record(m_pixPrdTruth, m_prdTruthNamePixel)).isFailure()){
      ATH_MSG_FATAL("Could not record collection " << m_prdTruthNamePixel);
      return StatusCode::FAILURE;
    }
  }
 
 
  m_ambiguitiesMap =new PixelGangedClusterAmbiguities();
 
 
  //  get the container(s)
  using TimedHitCollList = PileUpMergeSvc::TimedList<SiHitCollection>::type;
 
  //this is a list<pair<time_t, DataLink<SCTUncompressedHitCollection> > >
  TimedHitCollList hitCollList;
  unsigned int numberOfSimHits(0);
  if ( !(m_mergeSvc->retrieveSubEvtsData(m_inputObjectName.value(), hitCollList, numberOfSimHits).isSuccess()) && hitCollList.empty() ) {
    ATH_MSG_ERROR ( "Could not fill TimedHitCollList" );
    return StatusCode::FAILURE;
  } else {
    ATH_MSG_DEBUG ( hitCollList.size() << " SiHitCollections with key " << m_inputObjectName << " found" );
  }
 
  // Define Hit Collection
  TimedHitCollection<SiHit> thpcsi(numberOfSimHits);
 
  //now merge all collections into one
  TimedHitCollList::iterator   iColl(hitCollList.begin());
  TimedHitCollList::iterator endColl(hitCollList.end()  );
 
  m_HardScatterSplittingSkipper = false;
  // loop on the hit collections
  while ( iColl != endColl ) {
    //decide if this event will be processed depending on HardScatterSplittingMode & bunchXing
    if (m_HardScatterSplittingMode == 2 && !m_HardScatterSplittingSkipper ) { m_HardScatterSplittingSkipper = true; ++iColl; continue; }
    if (m_HardScatterSplittingMode == 1 && m_HardScatterSplittingSkipper )  { ++iColl; continue; }
    if (m_HardScatterSplittingMode == 1 && !m_HardScatterSplittingSkipper ) { m_HardScatterSplittingSkipper = true; }
    const SiHitCollection* p_collection(iColl->second);
    thpcsi.insert(iColl->first, p_collection);
    ATH_MSG_DEBUG ( "SiHitCollection found with " << p_collection->size() << " hits" );
    ++iColl;
  }
 
  // Process the Hits straw by straw: get the iterator pairs for given straw
  if(this->digitize(ctx, thpcsi).isFailure()) {
    ATH_MSG_FATAL ( "digitize method failed!" );
    return StatusCode::FAILURE;
  }
 
  if (createAndStoreRIOs(ctx).isFailure()) {
    ATH_MSG_FATAL ( "createAndStoreRIOs() failed!" );
    return StatusCode::FAILURE;
  }
  else {
    ATH_MSG_DEBUG ( "createAndStoreRIOs() succeeded" );
  }
 
 
  if ((evtStore()->setConst(m_pixelClusterContainer)).isFailure()) {
    ATH_MSG_ERROR("[ ---- ] Could not set Pixel ROT container ");
  }
  ATH_MSG_DEBUG ("Ambiguities map has " << m_ambiguitiesMap->size() << " elements" );
  StatusCode sc = evtStore()->record(m_ambiguitiesMap,m_pixelClusterAmbiguitiesMapName,false);
  if (sc.isFailure()){
    ATH_MSG_FATAL ( "PixelClusterAmbiguitiesMap could not be recorded in StoreGate !" );
    return StatusCode::FAILURE;
  }else{
    ATH_MSG_DEBUG ( "PixelClusterAmbiguitiesMap recorded in StoreGate" );
  }
 
 
 
 
  return StatusCode::SUCCESS;
 
}

processBunchXing()

StatusCode PixelFastDigitizationTool::processBunchXing ( int bunchXing, SubEventIterator bSubEvents, SubEventIterator eSubEvents )

virtual

Reimplemented from PileUpToolBase.

Definition at line 160 of file PixelFastDigitizationTool.cxx.

{
  //decide if this event will be processed depending on HardScatterSplittingMode & bunchXing
  if (m_HardScatterSplittingMode == 2 && !m_HardScatterSplittingSkipper ) { m_HardScatterSplittingSkipper = true; return StatusCode::SUCCESS; }
  if (m_HardScatterSplittingMode == 1 && m_HardScatterSplittingSkipper )  { return StatusCode::SUCCESS; }
  if (m_HardScatterSplittingMode == 1 && !m_HardScatterSplittingSkipper ) { m_HardScatterSplittingSkipper = true; }
 
  using TimedHitCollList = PileUpMergeSvc::TimedList<SiHitCollection>::type;
  TimedHitCollList hitCollList;
 
  if (!(m_mergeSvc->retrieveSubSetEvtData(m_inputObjectName.value(), hitCollList, bunchXing,
                                          bSubEvents, eSubEvents).isSuccess()) &&
      hitCollList.empty()) {
    ATH_MSG_ERROR("Could not fill TimedHitCollList");
    return StatusCode::FAILURE;
  } else {
    ATH_MSG_VERBOSE(hitCollList.size() << " SiHitCollections with key " <<
                    m_inputObjectName << " found");
  }
 
  TimedHitCollList::iterator iColl(hitCollList.begin());
  TimedHitCollList::iterator endColl(hitCollList.end());
 
  for( ; iColl != endColl; ++iColl) {
    SiHitCollection *siHitColl = new SiHitCollection(*iColl->second);
    PileUpTimeEventIndex timeIndex(iColl->first);
    ATH_MSG_DEBUG("SiHitCollection found with " << siHitColl->size() <<
                  " hits");
    ATH_MSG_VERBOSE("time index info. time: " << timeIndex.time()
                    << " index: " << timeIndex.index()
                    << " type: " << timeIndex.type());
    m_thpcsi->insert(timeIndex, siHitColl);
    m_siHitCollList.push_back(siHitColl);
  }
 
  return StatusCode::SUCCESS;
}

resetFilter()

virtual void PileUpToolBase::resetFilter ( )

inlineoverridevirtualinherited

dummy implementation of filter reset

Reimplemented in MergeTruthJetsTool.

Definition at line 51 of file PileUpToolBase.h.

{ m_filterPassed=true; }

toProcess()

virtual bool PileUpToolBase::toProcess ( int bunchXing ) const

inlineoverridevirtualinherited

the method this base class helps implementing

Reimplemented in MergeHijingParsTool, and MergeTrackRecordCollTool.

Definition at line 32 of file PileUpToolBase.h.

                                                       {
    //closed interval [m_firstXing,m_lastXing]
    return !((m_firstXing > bunchXing) || (bunchXing > m_lastXing));
  }

Member Data Documentation

m_acceptDiagonalClusters

bool PixelFastDigitizationTool::m_acceptDiagonalClusters {true}

private

merging parameter used to define two clusters as neighbour >

Definition at line 140 of file PixelFastDigitizationTool.h.

{true}; 

m_ambiguitiesMap

InDet::PixelGangedClusterAmbiguities* PixelFastDigitizationTool::m_ambiguitiesMap {}

private

Definition at line 142 of file PixelFastDigitizationTool.h.

{};

m_chargeDataKey

SG::ReadCondHandleKey<PixelChargeCalibCondData> PixelFastDigitizationTool::m_chargeDataKey {this, "PixelChargeCalibCondData", "PixelChargeCalibCondData", "Pixel charge calibration data"}

private

Definition at line 146 of file PixelFastDigitizationTool.h.

{this, "PixelChargeCalibCondData", "PixelChargeCalibCondData", "Pixel charge calibration data"};

m_clusterMaker

PublicToolHandle<InDet::ClusterMakerTool> PixelFastDigitizationTool::m_clusterMaker {this, "ClusterMaker", "InDet::ClusterMakerTool/FatrasClusterMaker"}

private

ToolHandle to ClusterMaker.

Definition at line 99 of file PixelFastDigitizationTool.h.

{this, "ClusterMaker", "InDet::ClusterMakerTool/FatrasClusterMaker"};   

m_digitizationStepper

PublicToolHandle<Trk::IModuleStepper> PixelFastDigitizationTool::m_digitizationStepper {this, "DigitizationStepper", "Trk::PlanarModuleStepper"}

private

Definition at line 164 of file PixelFastDigitizationTool.h.

{this, "DigitizationStepper", "Trk::PlanarModuleStepper"};

m_distortionKey

SG::ReadCondHandleKey<PixelDistortionData> PixelFastDigitizationTool::m_distortionKey {this, "PixelDistortionData", "PixelDistortionData", "Output readout distortion data"}

private

Definition at line 151 of file PixelFastDigitizationTool.h.

{this, "PixelDistortionData", "PixelDistortionData", "Output readout distortion data"};

m_filterPassed

bool PileUpToolBase::m_filterPassed {true}

protectedinherited

Definition at line 60 of file PileUpToolBase.h.

{true}; 

m_firstXing

Gaudi::Property<int> PileUpToolBase::m_firstXing

protectedinherited

Initial value:

{this, "FirstXing", -999,
      "First bunch-crossing in which det is live"}

Definition at line 54 of file PileUpToolBase.h.

                                {this, "FirstXing", -999,
      "First bunch-crossing in which det is live"};

m_gangedAmbiguitiesFinder

PublicToolHandle< InDet::PixelGangedAmbiguitiesFinder > PixelFastDigitizationTool::m_gangedAmbiguitiesFinder {this, "gangedAmbiguitiesFinder", "InDet::PixelGangedAmbiguitiesFinder"}

private

Definition at line 116 of file PixelFastDigitizationTool.h.

{this, "gangedAmbiguitiesFinder", "InDet::PixelGangedAmbiguitiesFinder"};

m_HardScatterSplittingMode

IntegerProperty PixelFastDigitizationTool::m_HardScatterSplittingMode {this, "HardScatterSplittingMode", 0, "Control pileup & signal splitting"}

private

Process all SiHit or just those from signal or background events.

Definition at line 107 of file PixelFastDigitizationTool.h.

{this, "HardScatterSplittingMode", 0, "Control pileup & signal splitting"}; 

m_HardScatterSplittingSkipper

bool PixelFastDigitizationTool::m_HardScatterSplittingSkipper {false}

private

Definition at line 108 of file PixelFastDigitizationTool.h.

{false};

m_inputObjectName

StringProperty PixelFastDigitizationTool::m_inputObjectName {this, "InputObjectName", "PixelHits"}

private

Definition at line 118 of file PixelFastDigitizationTool.h.

{this, "InputObjectName", "PixelHits"};     

m_lastXing

Gaudi::Property<int> PileUpToolBase::m_lastXing

protectedinherited

Initial value:

{this, "LastXing", 999,
      "Last bunch-crossing in which det is live"}

Definition at line 56 of file PileUpToolBase.h.

                                {this, "LastXing", 999,
      "Last bunch-crossing in which det is live"};

m_lorentzAngleTool

ToolHandle<ISiLorentzAngleTool> PixelFastDigitizationTool::m_lorentzAngleTool {this, "LorentzAngleTool", "PixelLorentzAngleTool", "Tool to retreive Lorentz angle"}

private

Definition at line 100 of file PixelFastDigitizationTool.h.

{this, "LorentzAngleTool", "PixelLorentzAngleTool", "Tool to retreive Lorentz angle"};

m_mergeCluster

bool PixelFastDigitizationTool::m_mergeCluster {true}

private

enable the merging of neighbour Pixel clusters >

Definition at line 138 of file PixelFastDigitizationTool.h.

{true}; 

m_mergeSvc

ServiceHandle<PileUpMergeSvc> PixelFastDigitizationTool::m_mergeSvc {this, "MergeSvc", "PileUpMergeSvc"}

private

PileUp Merge service.

Definition at line 106 of file PixelFastDigitizationTool.h.

{this, "MergeSvc", "PileUpMergeSvc"};      

m_offlineCalibDataKey

SG::ReadCondHandleKey<PixelCalib::PixelOfflineCalibData> PixelFastDigitizationTool::m_offlineCalibDataKey {this, "PixelOfflineCalibData", "PixelOfflineCalibData", "Pixel offline calibration data"}

private

Definition at line 149 of file PixelFastDigitizationTool.h.

{this, "PixelOfflineCalibData", "PixelOfflineCalibData", "Pixel offline calibration data"};

m_pixDiffShiftBarrX

DoubleProperty PixelFastDigitizationTool::m_pixDiffShiftBarrX {this, "PixDiffShiftBarrX", 0.005}

private

Definition at line 132 of file PixelFastDigitizationTool.h.

{this, "PixDiffShiftBarrX", 0.005}; //Shift of the track to improve cluster size description

m_pixDiffShiftBarrY

DoubleProperty PixelFastDigitizationTool::m_pixDiffShiftBarrY {this, "PixDiffShiftBarrY", 0.005}

private

Definition at line 133 of file PixelFastDigitizationTool.h.

{this, "PixDiffShiftBarrY", 0.005}; //Shift of the track to improve cluster size description

m_pixDiffShiftEndCX

DoubleProperty PixelFastDigitizationTool::m_pixDiffShiftEndCX {this, "PixDiffShiftEndCX", 0.008}

private

Definition at line 134 of file PixelFastDigitizationTool.h.

{this, "PixDiffShiftEndCX", 0.008}; //Shift of the track to improve cluster size description

m_pixDiffShiftEndCY

DoubleProperty PixelFastDigitizationTool::m_pixDiffShiftEndCY {this, "PixDiffShiftEndCY", 0.008}

private

Definition at line 135 of file PixelFastDigitizationTool.h.

{this, "PixDiffShiftEndCY", 0.008}; //Shift of the track to improve cluster size description

m_pixel_ID

const PixelID* PixelFastDigitizationTool::m_pixel_ID {}

private

Handle to the ID helper.

Definition at line 97 of file PixelFastDigitizationTool.h.

{};                             

m_pixel_SiClustersName

StringProperty PixelFastDigitizationTool::m_pixel_SiClustersName {this, "PixelClusterContainerName", "PixelClusters"}

private

Definition at line 104 of file PixelFastDigitizationTool.h.

{this, "PixelClusterContainerName", "PixelClusters"};

m_pixelClusterAmbiguitiesMapName

StringProperty PixelFastDigitizationTool::m_pixelClusterAmbiguitiesMapName {this, "PixelClusterAmbiguitiesMapName", "PixelClusterAmbiguitiesMap"}

private

Definition at line 141 of file PixelFastDigitizationTool.h.

{this, "PixelClusterAmbiguitiesMapName", "PixelClusterAmbiguitiesMap"};

m_pixelClusterContainer

InDet::PixelClusterContainer* PixelFastDigitizationTool::m_pixelClusterContainer {}

private

the PixelClusterContainer

Definition at line 103 of file PixelFastDigitizationTool.h.

{};               

m_pixelClusterMap

Pixel_detElement_RIO_map* PixelFastDigitizationTool::m_pixelClusterMap {}

private

Definition at line 111 of file PixelFastDigitizationTool.h.

{};

m_pixelDetEleCollKey

SG::ReadCondHandleKey<InDetDD::SiDetectorElementCollection> PixelFastDigitizationTool::m_pixelDetEleCollKey {this, "PixelDetEleCollKey", "PixelDetectorElementCollection", "Key of SiDetectorElementCollection for Pixel"}

private

Definition at line 154 of file PixelFastDigitizationTool.h.

{this, "PixelDetEleCollKey", "PixelDetectorElementCollection", "Key of SiDetectorElementCollection for Pixel"};

m_pixelReadout

ServiceHandle<InDetDD::IPixelReadoutManager> PixelFastDigitizationTool::m_pixelReadout {this, "PixelReadoutManager", "PixelReadoutManager", "Pixel readout manager" }

private

Definition at line 143 of file PixelFastDigitizationTool.h.

{this, "PixelReadoutManager", "PixelReadoutManager", "Pixel readout manager" };

m_pixEmulateSurfaceCharge

BooleanProperty PixelFastDigitizationTool::m_pixEmulateSurfaceCharge {this, "PixelEmulateSurfaceCharge", true}

private

emulate the surface charge

Definition at line 123 of file PixelFastDigitizationTool.h.

{this, "PixelEmulateSurfaceCharge", true};  

m_pixErrorStrategy

IntegerProperty PixelFastDigitizationTool::m_pixErrorStrategy {this, "PixelErrorStrategy", 2}

private

error strategy for the ClusterMaker

Definition at line 131 of file PixelFastDigitizationTool.h.

{this, "PixelErrorStrategy", 2};         

m_pixEtaError

DoubleArrayProperty PixelFastDigitizationTool::m_pixEtaError {this, "PixelErrorEta", {} }

private

eta error when not using the ClusterMaker

Definition at line 130 of file PixelFastDigitizationTool.h.

{this, "PixelErrorEta", {} };              

m_pixMinimalPathCut

DoubleProperty PixelFastDigitizationTool::m_pixMinimalPathCut {this, "PixelMinimalPathLength", 0.06}

private

the 1.

model parameter: minimal 3D path in pixel

Definition at line 126 of file PixelFastDigitizationTool.h.

{this, "PixelMinimalPathLength", 0.06};        

m_pixModuleDistortion

BooleanProperty PixelFastDigitizationTool::m_pixModuleDistortion {this, "PixelEmulateModuleDistortion", true}

private

simulationn of module bowing

Definition at line 128 of file PixelFastDigitizationTool.h.

{this, "PixelEmulateModuleDistortion", true};       

m_pixPathLengthTotConv

DoubleProperty PixelFastDigitizationTool::m_pixPathLengthTotConv {this, "PixelPathLengthTotConversion", 125.}

private

from path length to tot

Definition at line 127 of file PixelFastDigitizationTool.h.

{this, "PixelPathLengthTotConversion", 125.};     

m_pixPhiError

DoubleArrayProperty PixelFastDigitizationTool::m_pixPhiError {this, "PixelErrorPhi", {} }

private

phi error when not using the ClusterMaker

Definition at line 129 of file PixelFastDigitizationTool.h.

{this, "PixelErrorPhi", {} };              

m_pixPrdTruth

PRD_MultiTruthCollection* PixelFastDigitizationTool::m_pixPrdTruth {}

private

the PRD truth map for Pixel measurements

Definition at line 114 of file PixelFastDigitizationTool.h.

{};              

m_pixSmearLandau

BooleanProperty PixelFastDigitizationTool::m_pixSmearLandau {this, "PixelSmearLandau", true}

private

if true : landau else: gauss

Definition at line 125 of file PixelFastDigitizationTool.h.

{this, "PixelSmearLandau", true};           

m_pixSmearPathLength

DoubleProperty PixelFastDigitizationTool::m_pixSmearPathLength {this, "PixelSmearPathSigma", 0.01}

private

the 2.

model parameter: smear the path

Definition at line 124 of file PixelFastDigitizationTool.h.

{this, "PixelSmearPathSigma", 0.01};       

m_pixTanLorentzAngleScalor

double PixelFastDigitizationTool::m_pixTanLorentzAngleScalor {1.}

private

scale the lorentz angle effect

Definition at line 122 of file PixelFastDigitizationTool.h.

{1.}; 

m_pixUseClusterMaker

BooleanProperty PixelFastDigitizationTool::m_pixUseClusterMaker {this, "PixelUseClusterMaker", true}

private

use the pixel cluster maker or not

Definition at line 101 of file PixelFastDigitizationTool.h.

{this, "PixelUseClusterMaker", true}; 

m_prdTruthNamePixel

StringProperty PixelFastDigitizationTool::m_prdTruthNamePixel {this, "TruthNamePixel", "PRD_MultiTruthPixel"}

private

Definition at line 113 of file PixelFastDigitizationTool.h.

{this, "TruthNamePixel", "PRD_MultiTruthPixel"};

m_randomEngineName

StringProperty PixelFastDigitizationTool::m_randomEngineName {this, "RndmEngine", "FastPixelDigitization"}

private

Name of the random number stream.

Definition at line 95 of file PixelFastDigitizationTool.h.

{this, "RndmEngine", "FastPixelDigitization"};         

m_rndmSvc

ServiceHandle<IAthRNGSvc> PixelFastDigitizationTool::m_rndmSvc {this, "RndmSvc", "AthRNGSvc", ""}

private

Random number service.

Definition at line 93 of file PixelFastDigitizationTool.h.

{this, "RndmSvc", "AthRNGSvc", ""};  

m_siHitCollList

std::vector<SiHitCollection*> PixelFastDigitizationTool::m_siHitCollList {}

private

name of the sub event hit collections.

Definition at line 120 of file PixelFastDigitizationTool.h.

{};

m_splitClusters

short PixelFastDigitizationTool::m_splitClusters {0}

private

merging parameter used to define two clusters as neighbour >

Definition at line 139 of file PixelFastDigitizationTool.h.

{0}; 

m_thpcsi

TimedHitCollection<SiHit>* PixelFastDigitizationTool::m_thpcsi {}

private

Definition at line 91 of file PixelFastDigitizationTool.h.

{};

m_ThrConverted

DoubleProperty PixelFastDigitizationTool::m_ThrConverted {this, "ThrConverted", 50000}

private

Definition at line 136 of file PixelFastDigitizationTool.h.

{this, "ThrConverted", 50000};

m_vetoPileUpTruthLinks

Gaudi::Property<int> PileUpToolBase::m_vetoPileUpTruthLinks

protectedinherited

Initial value:

{this, "VetoPileUpTruthLinks", true,
      "Ignore links to suppressed pile-up truth"}

Definition at line 58 of file PileUpToolBase.h.

                                           {this, "VetoPileUpTruthLinks", true,
      "Ignore links to suppressed pile-up truth"};

---

The documentation for this class was generated from the following files:

• PixelFastDigitizationTool.h
• PixelFastDigitizationTool.cxx