SiSmearedDigitizationTool Class Reference

#include <SiSmearedDigitizationTool.h>

Inheritance diagram for SiSmearedDigitizationTool:

Public Types
typedef std::multimap< IdentifierHash, InDet::PixelCluster * >	Pixel_detElement_RIO_map
typedef std::multimap< IdentifierHash, InDet::SCT_Cluster * >	SCT_detElement_RIO_map

Public Member Functions
	SiSmearedDigitizationTool (const std::string &type, const std::string &name, const IInterface *parent)
	Constructor with parameters.
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	mergeClusters (Pixel_detElement_RIO_map *cluster_map)
StatusCode	mergeClusters (SCT_detElement_RIO_map *cluster_map)
StatusCode	digitize (const EventContext &ctx, TimedHitCollection< SiHit > &thpcsi)
StatusCode	createAndStoreRIOs (const EventContext &ctx)
StatusCode	retrieveTruth ()
StatusCode	finalize ()
template<typename CLUSTER>
double	calculateDistance (CLUSTER *clusterA, CLUSTER *clusterB)
template<typename CLUSTER>
double	calculateSigma (CLUSTER *clusterA, CLUSTER *clusterB)
template<typename CLUSTER>
ClusterInfo	calculateNewCluster (CLUSTER *clusterA, CLUSTER *clusterB)
template<typename CLUSTER>
StatusCode	FillTruthMap (PRD_MultiTruthCollection *, CLUSTER *, const TimedHitPtr< SiHit > &)

Private Member Functions
	SiSmearedDigitizationTool ()
	SiSmearedDigitizationTool (const SiSmearedDigitizationTool &)
SiSmearedDigitizationTool &	operator= (const SiSmearedDigitizationTool &)

Private Attributes
ServiceHandle< IAthRNGSvc >	m_rndmSvc {this, "RndmSvc", "AthRNGSvc", ""}
	Random number service.
SG::ReadCondHandleKey< InDetDD::SiDetectorElementCollection >	m_pixelDetEleCollKey {this, "PixelDetEleCollKey", "PixelDetectorElementCollection", "Key of SiDetectorElementCollection for Pixel"}
SG::ReadCondHandleKey< InDetDD::SiDetectorElementCollection >	m_SCTDetEleCollKey {this, "SCTDetEleCollKey", "SCT_DetectorElementCollection", "Key of SiDetectorElementCollection for SCT"}
const PixelID *	m_pixel_ID
	Handle to the ID helper.
const SCT_ID *	m_sct_ID
	Handle to the ID helper.
std::string	m_randomEngineName
	Name of the random number stream.
float	m_pitch_X
float	m_pitch_Y
bool	m_merge
double	m_nSigma
bool	m_useDiscSurface
InDet::PixelClusterContainer *	m_pixelClusterContainer
	the PixelClusterContainer
InDet::SCT_ClusterContainer *	m_sctClusterContainer
	the SCT_ClusterContainer
ServiceHandle< PileUpMergeSvc >	m_mergeSvc
	PileUp Merge service.
int	m_HardScatterSplittingMode
	Process all SiHit or just those from signal or background events.
bool	m_HardScatterSplittingSkipper
PRD_MultiTruthCollection *	m_pixelPrdTruth {}
std::string	m_prdTruthNamePixel
PRD_MultiTruthCollection *	m_SCTPrdTruth {}
std::string	m_prdTruthNameSCT
SiHitCollection *	m_simHitColl {}
std::string	m_inputObjectName
std::vector< SiHitCollection * >	m_siHitCollList
	name of the sub event hit collections.
Pixel_detElement_RIO_map *	m_pixelClusterMap {}
SCT_detElement_RIO_map *	m_sctClusterMap {}
bool	m_SmearPixel
bool	m_emulateAtlas
std::string	m_pixel_SiClustersName
std::string	m_Sct_SiClustersName
bool	m_checkSmear
ServiceHandle< ITHistSvc >	m_thistSvc {this, "THistSvc", "THistSvc"}
TFile *	m_outputFile
	the root file
TTree *	m_currentTree
	the tree to store information from pixel and SCT (before and after smearing)
double	m_x_pixel
double	m_y_pixel
double	m_x_exit_pixel
double	m_y_exit_pixel
double	m_z_exit_pixel
double	m_x_entry_pixel
double	m_y_entry_pixel
double	m_z_entry_pixel
double	m_x_pixel_global
double	m_y_pixel_global
double	m_z_pixel_global
double	m_x_SCT
double	m_x_exit_SCT
double	m_y_exit_SCT
double	m_z_exit_SCT
double	m_x_entry_SCT
double	m_y_entry_SCT
double	m_z_entry_SCT
double	m_x_SCT_global
double	m_y_SCT_global
double	m_z_SCT_global
double	m_x_pixel_smeared
double	m_y_pixel_smeared
double	m_x_SCT_smeared
double	m_Err_x_pixel
double	m_Err_y_pixel
double	m_Err_x_SCT
double	m_Err_y_SCT

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 61 of file SiSmearedDigitizationTool.h.

Member Typedef Documentation

Pixel_detElement_RIO_map

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

Definition at line 82 of file SiSmearedDigitizationTool.h.

SCT_detElement_RIO_map

typedef std::multimap<IdentifierHash, InDet::SCT_Cluster*> SiSmearedDigitizationTool::SCT_detElement_RIO_map

Definition at line 83 of file SiSmearedDigitizationTool.h.

Constructor & Destructor Documentation

SiSmearedDigitizationTool() [1/3]

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

Constructor with parameters.

Definition at line 64 of file SiSmearedDigitizationTool.cxx.

                                                                              :
  PileUpToolBase(type, name, parent),
  m_pixel_ID(nullptr),
  m_sct_ID(nullptr),
  m_randomEngineName("SiSmearedDigitization"),
  m_pitch_X(0),
  m_pitch_Y(0),
  m_merge(false),
  m_nSigma(0.),
  m_useDiscSurface(false),
  m_pixelClusterContainer(nullptr),
  m_sctClusterContainer(nullptr),
  m_mergeSvc("PileUpMergeSvc",name),
  m_HardScatterSplittingMode(0),
  m_HardScatterSplittingSkipper(false),
  m_prdTruthNamePixel("PRD_MultiTruthPixel"),
  m_prdTruthNameSCT("PRD_MultiTruthSCT"),
  m_SmearPixel(true), //true: smear pixel --- false: smear SCT
  m_emulateAtlas(true), // error rotation for endcap SCT
  m_checkSmear(false),
  m_outputFile(nullptr),
  m_currentTree(nullptr),
  m_x_pixel(0),
  m_y_pixel(0),
  m_x_exit_pixel(0),
  m_y_exit_pixel(0),
  m_z_exit_pixel(0),
  m_x_entry_pixel(0),
  m_y_entry_pixel(0),
  m_z_entry_pixel(0),
  m_x_pixel_global(0),
  m_y_pixel_global(0),
  m_z_pixel_global(0),
  m_x_SCT(0),
  m_x_exit_SCT(0),
  m_y_exit_SCT(0),
  m_z_exit_SCT(0),
  m_x_entry_SCT(0),
  m_y_entry_SCT(0),
  m_z_entry_SCT(0),
  m_x_SCT_global(0),
  m_y_SCT_global(0),
  m_z_SCT_global(0),
  m_x_pixel_smeared(0),
  m_y_pixel_smeared(0),
  m_x_SCT_smeared(0),
  m_Err_x_pixel(0),
  m_Err_y_pixel(0),
  m_Err_x_SCT(0),
  m_Err_y_SCT(0)
{
  declareProperty("RndmEngine",                   m_randomEngineName, "Random engine name");
  declareProperty("InputObjectName",              m_inputObjectName="PixelHits", "Input Object name" );
  declareProperty("pitch_X",                      m_pitch_X);
  declareProperty("pitch_Y",                      m_pitch_Y);
  declareProperty("MergeClusters",                m_merge);
  declareProperty("Nsigma",                       m_nSigma);
  declareProperty("SmearPixel",                   m_SmearPixel, "Enable Pixel or SCT Smearing");
  declareProperty("PixelClusterContainerName",    m_pixel_SiClustersName="PixelClusters");
  declareProperty("SCT_ClusterContainerName",     m_Sct_SiClustersName="SCT_Clusters");
  declareProperty("CheckSmear",                   m_checkSmear);
 
  declareProperty("HardScatterSplittingMode"     , m_HardScatterSplittingMode, "Control pileup & signal splitting" );
 
}

SiSmearedDigitizationTool() [2/3]

SiSmearedDigitizationTool::SiSmearedDigitizationTool ( )

private

SiSmearedDigitizationTool() [3/3]

SiSmearedDigitizationTool::SiSmearedDigitizationTool ( const SiSmearedDigitizationTool & )

private

Member Function Documentation

calculateDistance()

template<typename CLUSTER>

double SiSmearedDigitizationTool::calculateDistance	(	CLUSTER *	clusterA,
		CLUSTER *	clusterB )

Definition at line 470 of file SiSmearedDigitizationTool.cxx.

                                                                                         {
 
  // take needed information on the first clusters
  Amg::Vector2D intersection_a = clusterA->localPosition();
 
  // take needed information on the second clusters
  Amg::Vector2D intersection_b = clusterB->localPosition();
 
  ATH_MSG_DEBUG( "--- SiSmearedDigitizationTool: intersection_a = " << intersection_a);
  ATH_MSG_DEBUG( "--- SiSmearedDigitizationTool: intersection_b = " << intersection_b);
 
  double distX = intersection_a.x() - intersection_b.x();
  double distY = intersection_a.y() - intersection_b.y();
 
  return sqrt(distX*distX + distY*distY);
}

calculateNewCluster()

template<typename CLUSTER>

ClusterInfo SiSmearedDigitizationTool::calculateNewCluster	(	CLUSTER *	clusterA,
		CLUSTER *	clusterB )

Definition at line 505 of file SiSmearedDigitizationTool.cxx.

                                                                                                 {
  // take needed information on the first clusters
  Amg::Vector2D intersection_a = clusterA->localPosition();
  const Amg::MatrixX& clusterErr_a = clusterA->localCovariance();
 
  // take needed information on the second clusters
  Amg::Vector2D intersection_b = clusterB->localPosition();
  const Amg::MatrixX& clusterErr_b = clusterB->localCovariance();
 
  double sigmaX = sqrt(Amg::error(clusterErr_a,Trk::locX) * Amg::error(clusterErr_a,Trk::locX) +
                       Amg::error(clusterErr_b,Trk::locX) * Amg::error(clusterErr_b,Trk::locX));
 
  double sigmaY = sqrt(Amg::error(clusterErr_a,Trk::locY) * Amg::error(clusterErr_a,Trk::locY) +
                       Amg::error(clusterErr_b,Trk::locY) * Amg::error(clusterErr_b,Trk::locY));
 
  double interX = 0.5*(intersection_a.x()+intersection_b.x());
  double interY = 0.5*(intersection_a.y()+intersection_b.y());
 
  Amg::Vector2D intersection(interX, interY);
 
  ATH_MSG_DEBUG( "--- SiSmearedDigitizationTool: intersection = " << intersection);
 
  const InDet::SiWidth& siWidth_a = clusterA->width();
  const InDet::SiWidth& siWidth_b = clusterB->width();
 
  ATH_MSG_DEBUG( "--- SiSmearedDigitizationTool: siWidth_a = " << siWidth_a);
  ATH_MSG_DEBUG( "--- SiSmearedDigitizationTool: siWidth_b = " << siWidth_b);
 
  Amg::Vector2D colRow = siWidth_a.colRow() + siWidth_b.colRow();
  Amg::Vector2D  phiRz = siWidth_a.widthPhiRZ() + siWidth_b.widthPhiRZ();
 
  InDet::SiWidth siWidth(colRow, phiRz);
 
  ATH_MSG_DEBUG( "--- SiSmearedDigitizationTool: siWidth = " << siWidth);
 
  AmgSymMatrix(2) covariance;
  covariance.setIdentity();
  covariance(Trk::locX,Trk::locX) = sigmaX*sigmaX;
  covariance(Trk::locY,Trk::locY) = sigmaY*sigmaY;
  Amg::MatrixX clusterErr = covariance;
 
  return ClusterInfo( intersection, siWidth, clusterErr );
 
}

calculateSigma()

template<typename CLUSTER>

double SiSmearedDigitizationTool::calculateSigma	(	CLUSTER *	clusterA,
		CLUSTER *	clusterB )

Definition at line 488 of file SiSmearedDigitizationTool.cxx.

                                                                                      {
  // take needed information on the first cluster
  const Amg::MatrixX& clusterErr_a = clusterA->localCovariance();
 
  // take needed information on the second clusters
  const Amg::MatrixX& clusterErr_b = clusterB->localCovariance();
 
  double sigmaX = sqrt(Amg::error(clusterErr_a,Trk::locX) * Amg::error(clusterErr_a,Trk::locX) +
                       Amg::error(clusterErr_b,Trk::locX) * Amg::error(clusterErr_b,Trk::locX));
 
  double sigmaY = sqrt(Amg::error(clusterErr_a,Trk::locY) * Amg::error(clusterErr_a,Trk::locY) +
                       Amg::error(clusterErr_b,Trk::locY) * Amg::error(clusterErr_b,Trk::locY));
 
  return sqrt(sigmaX*sigmaX + sigmaY*sigmaY);
}

createAndStoreRIOs()

StatusCode SiSmearedDigitizationTool::createAndStoreRIOs

(

const EventContext &

ctx

)

Definition at line 1119 of file SiSmearedDigitizationTool.cxx.

{
  // Get PixelDetectorElementCollection
  const InDetDD::SiDetectorElementCollection* elementsPixel = nullptr;
  if (m_SmearPixel) {
    SG::ReadCondHandle<InDetDD::SiDetectorElementCollection> pixelDetEle(m_pixelDetEleCollKey, ctx);
    elementsPixel = pixelDetEle.retrieve();
    if (elementsPixel==nullptr) {
      ATH_MSG_FATAL(m_pixelDetEleCollKey.fullKey() << " could not be retrieved");
      return StatusCode::FAILURE;
    }
  }
  // Get SCT_DetectorElementCollection
  const InDetDD::SiDetectorElementCollection* elementsSCT = nullptr;
  if (not m_SmearPixel) {
    SG::ReadCondHandle<InDetDD::SiDetectorElementCollection> sctDetEle(m_SCTDetEleCollKey, ctx);
    elementsSCT = sctDetEle.retrieve();
    if (elementsSCT==nullptr) {
      ATH_MSG_FATAL(m_SCTDetEleCollKey.fullKey() << " could not be retrieved");
      return StatusCode::FAILURE;
    }
  }
 
  if ( m_SmearPixel ) { // Store Pixel RIOs
 
    ATH_MSG_DEBUG( "--- SiSmearedDigitizationTool: in pixel createAndStoreRIOs() ---" );
 
    Pixel_detElement_RIO_map::iterator i = m_pixelClusterMap->begin();
    Pixel_detElement_RIO_map::iterator e = m_pixelClusterMap->end();
 
    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;
 
      IdentifierHash waferID;
      waferID = firstDetElem->first;
 
      const InDetDD::SiDetectorElement* detElement = elementsPixel->getDetectorElement(waferID);
 
      InDet::PixelClusterCollection *clusterCollection = new InDet::PixelClusterCollection(waferID);
      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 ( m_pixelClusterContainer->addCollection( clusterCollection, waferID ).isFailure() ) {
        ATH_MSG_WARNING( "Could not add collection to Identifyable container !" );
      }
    } // end for
 
    m_pixelClusterMap->clear();
 
  }
  else { // Store SCT RIOs
 
    ATH_MSG_DEBUG( "--- SiSmearedDigitizationTool: in SCT createAndStoreRIOs() ---" );
 
    SCT_detElement_RIO_map::iterator i = m_sctClusterMap->begin();
    SCT_detElement_RIO_map::iterator e = m_sctClusterMap->end();
 
    for ( ; i != e; i = m_sctClusterMap->upper_bound(i->first) ) {
      std::pair <SCT_detElement_RIO_map::iterator, SCT_detElement_RIO_map::iterator> range;
      range = m_sctClusterMap->equal_range(i->first);
 
      SCT_detElement_RIO_map::iterator firstDetElem;
      firstDetElem = range.first;
 
      IdentifierHash waferID;
      waferID = firstDetElem->first;
      const InDetDD::SiDetectorElement* detElement = elementsSCT->getDetectorElement(waferID);
 
      InDet::SCT_ClusterCollection *clusterCollection = new InDet::SCT_ClusterCollection(waferID);
      clusterCollection->setIdentifier(detElement->identify());
 
 
      for ( SCT_detElement_RIO_map::iterator iter = range.first; iter != range.second; ++iter ) {
        InDet::SCT_Cluster* sctCluster = (*iter).second;
        sctCluster->setHashAndIndex(clusterCollection->identifyHash(),clusterCollection->size());
        clusterCollection->push_back(sctCluster);
      }
 
      if ( m_sctClusterContainer->addCollection( clusterCollection, clusterCollection->identifyHash() ).isFailure() ) {
        ATH_MSG_WARNING( "Could not add collection to Identifyable container !" );
      }
 
    } // end for
 
    m_sctClusterMap->clear();
  }
 
  return StatusCode::SUCCESS;
}

digitize()

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

Definition at line 711 of file SiSmearedDigitizationTool.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);
 
  ATH_MSG_DEBUG( "--- SiSmearedDigitizationTool: in SiSmearedDigizationTool::digitize() ---" );
 
  // Get PixelDetectorElementCollection
  const InDetDD::SiDetectorElementCollection* elementsPixel = nullptr;
  if (m_SmearPixel) {
    SG::ReadCondHandle<InDetDD::SiDetectorElementCollection> pixelDetEle(m_pixelDetEleCollKey, ctx);
    elementsPixel = pixelDetEle.retrieve();
    if (elementsPixel==nullptr) {
      ATH_MSG_FATAL(m_pixelDetEleCollKey.fullKey() << " could not be retrieved");
      return StatusCode::FAILURE;
    }
  }
  // Get SCT_DetectorElementCollection
  const InDetDD::SiDetectorElementCollection* elementsSCT = nullptr;
  if (not m_SmearPixel) {
    SG::ReadCondHandle<InDetDD::SiDetectorElementCollection> sctDetEle(m_SCTDetEleCollKey, ctx);
    elementsSCT = sctDetEle.retrieve();
    if (elementsSCT==nullptr) {
      ATH_MSG_FATAL(m_SCTDetEleCollKey.fullKey() << " could not be retrieved");
      return StatusCode::FAILURE;
    }
  }
 
  TimedHitCollection<SiHit>::const_iterator i, e;
 
  if(m_SmearPixel) { // Smear Pixel
    m_pixelClusterMap = new Pixel_detElement_RIO_map;
  } else {// Smear SCT
    m_sctClusterMap = new SCT_detElement_RIO_map;
  }
 
  while (thpcsi.nextDetectorElement(i, e)) {
 
    while (i != e) {
      m_useDiscSurface = false;
 
      const TimedHitPtr<SiHit>& hit(*i++);
      int barrelEC  = hit->getBarrelEndcap();
      int layerDisk = hit->getLayerDisk();
      int phiModule = hit->getPhiModule();
      int etaModule = hit->getEtaModule();
      int side      = 0;
 
      const InDetDD::SiDetectorElement* hitSiDetElement = nullptr;
 
      if(m_SmearPixel) { // Smear Pixel
        Identifier wafer_id = m_pixel_ID->wafer_id(barrelEC,layerDisk,phiModule,etaModule);
        IdentifierHash wafer_hash = m_pixel_ID->wafer_hash(wafer_id);
        const InDetDD::SiDetectorElement* hitSiDetElement_temp = elementsPixel->getDetectorElement(wafer_hash);
        ATH_MSG_DEBUG("Pixel SiDetectorElement --> barrel_ec " << barrelEC << ", layer_disk " << layerDisk << ", phi_module " << phiModule << ", eta_module " << etaModule );
        hitSiDetElement = hitSiDetElement_temp;
      } else { // Smear SCT
        side = hit->getSide();
        Identifier idwafer = m_sct_ID->wafer_id(barrelEC,layerDisk,phiModule,etaModule,side);
        IdentifierHash idhash = m_sct_ID->wafer_hash(m_sct_ID->wafer_id(idwafer));
        const InDetDD::SiDetectorElement* hitSiDetElement_temp = elementsSCT->getDetectorElement(idhash);
        ATH_MSG_DEBUG("SCT SiDetectorElement --> barrel_ec " << barrelEC << ", layer_disk " << layerDisk << ", phi_module " << phiModule << ", eta_module " << etaModule << ", side " << side);
        hitSiDetElement = hitSiDetElement_temp;
      }
 
      // untangling the logic: if not using custom geometry, hitSiDetElement
      // gets dereferenced (and should be checked)
      //
      // if using custom geometry, hitPlanarDetElement gets dereferenced
      // (and should be checked)
      if (not hitSiDetElement) {
        ATH_MSG_FATAL("hitSiDetElement is null in SiSmearedDigitizationTool:"<<__LINE__);
        throw std::runtime_error(std::string("hitSiDetElement is null in SiSmearedDigitizationTool::digitize() "));
      }
 
      if (m_SmearPixel && !(hitSiDetElement->isPixel())) continue;
      if (!m_SmearPixel && !(hitSiDetElement->isSCT())) continue;
 
      IdentifierHash waferID;
 
      if(m_SmearPixel) { // Smear Pixel
         waferID = m_pixel_ID->wafer_hash(hitSiDetElement->identify());
      } else { // Smear SCT
         waferID = m_sct_ID->wafer_hash(hitSiDetElement->identify());
      }
 
      HepGeom::Point3D<double> pix_localStartPosition = hit->localStartPosition();
      HepGeom::Point3D<double> pix_localEndPosition   = hit->localEndPosition();
 
      pix_localStartPosition = hitSiDetElement->hitLocalToLocal3D(pix_localStartPosition);
      pix_localEndPosition = hitSiDetElement->hitLocalToLocal3D(pix_localEndPosition);
 
      double localEntryX = pix_localStartPosition.x();
      double localEntryY = pix_localStartPosition.y();
      double localEntryZ = pix_localStartPosition.z();
      double localExitX = pix_localEndPosition.x();
      double localExitY = pix_localEndPosition.y();
      double localExitZ = pix_localEndPosition.z();
 
      double thickness = 0.0;
      thickness = hitSiDetElement->thickness();
 
      // Transform to reconstruction local coordinates (different x,y,z ordering and sign conventions compared to simulation coords)
      if (!m_SmearPixel) { // Smear SCT
        HepGeom::Point3D<double> sct_localStartPosition = hit->localStartPosition();
        HepGeom::Point3D<double> sct_localEndPosition = hit->localEndPosition();
 
        sct_localStartPosition = hitSiDetElement->hitLocalToLocal3D(sct_localStartPosition);
        sct_localEndPosition = hitSiDetElement->hitLocalToLocal3D(sct_localEndPosition);
 
        localEntryX = sct_localStartPosition.x();
        localEntryY = sct_localStartPosition.y();
        localEntryZ = sct_localStartPosition.z();
        localExitX  = sct_localEndPosition.x();
        localExitY  = sct_localEndPosition.y();
        localExitZ  = sct_localEndPosition.z();
      }
 
      double distX = std::abs(std::abs(localExitX)-std::abs(localEntryX));
      double distY = std::abs(std::abs(localExitY)-std::abs(localEntryY));
 
      if(m_SmearPixel) { // Smear Pixel
        ATH_MSG_DEBUG( "--- SiSmearedDigitizationTool: pixel start position --- " << localEntryX << ",  " << localEntryY << ",  " << localEntryZ );
        ATH_MSG_DEBUG( "--- SiSmearedDigitizationTool: pixel exit position --- " << localExitX << ",  " << localExitY << ",  " << localExitZ );
        m_x_entry_pixel = localEntryX;
        m_y_entry_pixel = localEntryY;
        m_z_entry_pixel = localEntryZ;
        m_x_exit_pixel = localExitX;
        m_y_exit_pixel = localExitY;
        m_z_exit_pixel = localExitZ;
      } else { // Smear SCT
        ATH_MSG_DEBUG( "--- SiSmearedDigitizationTool: SCT start position --- " << localEntryX << ",  " << localEntryY << ",  " << localEntryZ );
        ATH_MSG_DEBUG( "--- SiSmearedDigitizationTool: SCT exit position --- " << localExitX << ",  " << localExitY << ",  " << localExitZ );
        m_x_entry_SCT = localEntryX;
        m_y_entry_SCT = localEntryY;
        m_z_entry_SCT = localEntryZ;
        m_x_exit_SCT = localExitX;
        m_y_exit_SCT = localExitY;
        m_z_exit_SCT = localExitZ;
      }
 
      Amg::Vector2D localEntry(localEntryX,localEntryY);
      Amg::Vector2D localExit(localExitX,localExitY);
 
      // the pixel positions and other needed stuff for the geometrical clustering
      std::vector<Identifier>           rdoList;
 
      Amg::Vector3D localDirection(localExitX-localEntryX, localExitY-localEntryY, localExitZ-localEntryZ);
 
      InDetDD::SiCellId entryCellId;
      InDetDD::SiCellId exitCellId;
 
      // get the identifier of the entry and the exit
      Identifier entryId = hitSiDetElement->identifierOfPosition(localEntry);
      Identifier exitId  = hitSiDetElement->identifierOfPosition(localExit);
 
      // now get the cellIds and check whether they're valid
      entryCellId = hitSiDetElement->cellIdFromIdentifier(entryId);
      exitCellId  = hitSiDetElement->cellIdFromIdentifier(exitId);
 
      ATH_MSG_DEBUG( "--- SiSmearedDigitizationTool: entryId " << entryId << " --- exitId " << exitId );
      ATH_MSG_DEBUG( "--- SiSmearedDigitizationTool: entryCellId " << entryCellId << " --- exitCellId " << exitCellId );
 
      ATH_MSG_DEBUG( "--- SiSmearedDigitizationTool: surface " << hitSiDetElement->surface());
 
      // entry / exit validity
      bool entryValid = entryCellId.isValid();
      bool exitValid  = exitCellId.isValid();
 
      ATH_MSG_DEBUG( "--- SiSmearedDigitizationTool: entryValid? " << entryValid << " --- exitValid? " << exitValid );
 
      if (!entryValid && !exitValid) continue;
 
      // the intersecetion id and cellId of it
      double interX = 0.5*(localEntryX+localExitX);
      double interY = 0.5*(localEntryY+localExitY);
 
      ATH_MSG_DEBUG( "--- SiSmearedDigitizationTool: " << (m_SmearPixel ? "pixel" : "SCT") << " inter X --- " << interX );
      ATH_MSG_DEBUG( "--- SiSmearedDigitizationTool: " << (m_SmearPixel ? "pixel" : "SCT") << " inter Y --- " << interY );
      ATH_MSG_DEBUG( "--- SiSmearedDigitizationTool: " << (m_SmearPixel ? "pixel" : "SCT") << " dist X --- "  << distX );
      ATH_MSG_DEBUG( "--- SiSmearedDigitizationTool: " << (m_SmearPixel ? "pixel" : "SCT") << " dist Y --- "  << distY );
 
      //the particle crosses at least n pixels (in x direction you have timesX, in y direction you have timesY)
      double timesX = (m_pitch_X) ? floor(distX/m_pitch_X) : 0;
      double timesY = (m_pitch_Y) ? floor(distY/m_pitch_Y) : 0;
 
      double newdistX = distX - (timesX*m_pitch_X);
      double newdistY = distY - (timesY*m_pitch_Y);
 
      ATH_MSG_DEBUG( "--- SiSmearedDigitizationTool: times X --- " << timesX );
      ATH_MSG_DEBUG( "--- SiSmearedDigitizationTool: times Y --- " << timesY );
      ATH_MSG_DEBUG( "--- SiSmearedDigitizationTool: new dist X --- " << newdistX );
      ATH_MSG_DEBUG( "--- SiSmearedDigitizationTool: new dist Y --- " << newdistY );
      ATH_MSG_DEBUG( "--- SiSmearedDigitizationTool: thickness --- " << thickness );
 
      //Probability
 
      double ProbY = 2*newdistY/(m_pitch_Y+newdistY);
      double ProbX = 2*newdistX/(m_pitch_X+newdistX);
 
      ATH_MSG_DEBUG( "--- SiSmearedDigitizationTool: ProbX --- " << ProbX );
      ATH_MSG_DEBUG( "--- SiSmearedDigitizationTool: ProbY --- " << ProbY );
 
      // create the errors
      ATH_MSG_DEBUG( "--- SiSmearedDigitizationTool: pitch X --- " << m_pitch_X );
      ATH_MSG_DEBUG( "--- SiSmearedDigitizationTool: pitch Y --- " << m_pitch_Y );
 
      double sigmaX = m_pitch_X/sqrt(12.);
      double sigmaY = m_pitch_Y/sqrt(12.);
 
      int elementX = timesX+1;
      int elementY = timesY+1;
 
      if(m_SmearPixel) {
        if (CLHEP::RandFlat::shoot(rndmEngine, 0.0, 1.0) < ProbY) { // number of crossed pixel is (timesY+1)+1
          sigmaY = (double)(timesY+2)*m_pitch_Y/sqrt(12.);
          elementY++;
        } else // number of crossed pixel is (timesY+1)
          sigmaY = (double)(timesY+1)*m_pitch_Y/sqrt(12.);
 
        if (CLHEP::RandFlat::shoot(rndmEngine, 0.0, 1.0) < ProbX) { // number of crossed pixel is (timesY+1)+1
          sigmaX = (double)(timesX+2)*m_pitch_X/sqrt(12.);
          elementX++;
        } else // number of crossed pixel is (timesY+1)
          sigmaX = (double)(timesX+1)*m_pitch_X/sqrt(12.);
      }
 
      ATH_MSG_DEBUG( "--- SiSmearedDigitizationTool " << (m_SmearPixel ? "pixel" : "SCT") << " sigma X --- " << sigmaX);
      ATH_MSG_DEBUG( "--- SiSmearedDigitizationTool " << (m_SmearPixel ? "pixel" : "SCT") << " sigma Y --- " << sigmaY);
 
 
      double temp_X = interX;
      double temp_Y = interY;
 
      Amg::Vector2D intersection(interX, interY);
 
      ATH_MSG_DEBUG( "--- SiSmearedDigitizationTool: Intersection after smearing: " << intersection);
 
      Identifier intersectionId;
      intersectionId = hitSiDetElement->identifierOfPosition(intersection);
 
      rdoList.push_back(intersectionId);
      InDetDD::SiCellId currentCellId = hitSiDetElement->cellIdFromIdentifier(intersectionId);
 
      if (!currentCellId.isValid()) continue;
 
      ATH_MSG_DEBUG( "--- SiSmearedDigitizationTool: Intersection Id = " << intersectionId << " --- currentCellId = " << currentCellId );
 
      if(m_SmearPixel) { // Smear Pixel --> Create Pixel Cluster
 
        double lengthX = (m_pitch_X) ? elementX*m_pitch_X : 1.;
        double lengthY = (m_pitch_Y) ? elementY*m_pitch_Y : 1.;
 
        if (m_pitch_X == 0. || m_pitch_Y == 0.)
          ATH_MSG_WARNING( "--- SiSmearedDigitizationTool: pitchX and/or pitchY are 0. Cluster length is forced to be 1. mm");
 
        InDet::SiWidth siWidth(Amg::Vector2D(elementX,elementY), Amg::Vector2D(lengthX, lengthY));
 
        InDet::PixelCluster* pixelCluster = nullptr;
 
        AmgSymMatrix(2) covariance;
        covariance.setIdentity();
        covariance(Trk::locX,Trk::locX) = sigmaX*sigmaX;
        covariance(Trk::locY,Trk::locY) = sigmaY*sigmaY;
 
        // create the cluster
        pixelCluster = new InDet::PixelCluster(intersectionId,
                                               intersection,
                                               std::move(rdoList),
                                               siWidth,
                                               hitSiDetElement,
                                               Amg::MatrixX(covariance));
        m_pixelClusterMap->insert(std::pair<IdentifierHash, InDet::PixelCluster* >(waferID, pixelCluster));
 
        if (FillTruthMap(m_pixelPrdTruth, pixelCluster, hit).isFailure()) {
          ATH_MSG_FATAL ( "FillTruthMap() for pixel failed!" );
          return StatusCode::FAILURE;
        }
 
        if (m_checkSmear) {
 
            ATH_MSG_DEBUG( "--- SiSmearedDigitizationTool: pixelCluster --> " << *pixelCluster);
            //Take info to store in the tree
            m_x_pixel = temp_X;
            m_y_pixel = temp_Y;
 
            m_x_pixel_smeared = (pixelCluster->localPosition()).x();
            m_y_pixel_smeared = (pixelCluster->localPosition()).y();
 
            ATH_MSG_DEBUG( "--- SiSmearedDigitizationTool: BEFORE SMEARING LocalPosition --> X = " << m_x_pixel << "  Y = " << m_y_pixel);
            ATH_MSG_DEBUG( "--- SiSmearedDigitizationTool: LocalPosition --> X = " << m_x_pixel_smeared << "  Y = " << m_y_pixel_smeared);
 
            ATH_MSG_DEBUG( "--- SiSmearedDigitizationTool: GlobalPosition --> X = " << (pixelCluster->globalPosition()).x() << "  Y = " << (pixelCluster->globalPosition()).y());
            m_x_pixel_global = (pixelCluster->globalPosition()).x();
            m_y_pixel_global = (pixelCluster->globalPosition()).y();
            m_z_pixel_global = (pixelCluster->globalPosition()).z();
 
            m_Err_x_pixel = Amg::error(pixelCluster->localCovariance(), Trk::locX);
            m_Err_y_pixel = Amg::error(pixelCluster->localCovariance(), Trk::locY);
 
            ATH_MSG_DEBUG( "--- SiSmearedDigitizationTool: Error --> X = " << m_Err_x_pixel << "  Y = " << m_Err_y_pixel);
 
            m_currentTree -> Fill();
          }  // End of Pix smear check
 
      } else { // Smear SCT --> Create SCT Cluster
 
        // prepare the clusters
        InDet::SCT_Cluster * sctCluster = nullptr;
 
        // Pixel Design needed -------------------------------------------------------------
        const InDetDD::SCT_ModuleSideDesign* design_sct;
 
        design_sct = dynamic_cast<const InDetDD::SCT_ModuleSideDesign*>(&hitSiDetElement->design());
 
        if (!design_sct) {
           ATH_MSG_INFO ( "Could not get design"<< design_sct) ;
           continue;
        }
 
        // Find length of strip at centre
        double clusterWidth = rdoList.size()*hitSiDetElement->phiPitch(intersection);
        const std::pair<InDetDD::SiLocalPosition, InDetDD::SiLocalPosition> ends(design_sct->endsOfStrip(intersection));
        double stripLength = std::abs(ends.first.xEta()-ends.second.xEta());
 
        InDet::SiWidth siWidth(Amg::Vector2D(int(rdoList.size()),1),
                               Amg::Vector2D(clusterWidth,stripLength) );
 
        const Amg::Vector2D& colRow = siWidth.colRow();
 
        AmgSymMatrix(2) mat;
        mat.setIdentity();
        mat(Trk::locX,Trk::locX) = sigmaX*sigmaX;
        mat(Trk::locY,Trk::locY) = hitSiDetElement->length()*hitSiDetElement->length()/12.;
 
        // single strip - resolution close to pitch/sqrt(12)
        // two-strip hits: better resolution, approx. 40% lower
 
        InDetDD::DetectorShape elShape = hitSiDetElement->design().shape();
        if(m_emulateAtlas && elShape == InDetDD::Trapezoid)
        { // rotation for endcap SCT
 
          if(colRow.x() == 1) {
             mat(Trk::locX,Trk::locX) = pow(siWidth.phiR(),2)/12;
          }
          else if(colRow.x() == 2) {
             mat(Trk::locX,Trk::locX) = pow(0.27*siWidth.phiR(),2)/12;
          }
          else {
             mat(Trk::locX,Trk::locX) = pow(siWidth.phiR(),2)/12;
          }
 
          mat(Trk::locY,Trk::locY) = pow(siWidth.z()/colRow.y(),2)/12;
          double sn      = hitSiDetElement->sinStereoLocal(intersection);
          double sn2     = sn*sn;
          double cs2     = 1.-sn2;
          double w       = hitSiDetElement->phiPitch(intersection)/hitSiDetElement->phiPitch();
          double v0      = mat(Trk::locX, Trk::locX)*w*w;
          double v1      = mat(Trk::locY, Trk::locY);
          mat(Trk::locX, Trk::locX) = (cs2*v0+sn2*v1);
          mat(Trk::locY, Trk::locX) = (sn*sqrt(cs2)*(v0-v1));
          mat(Trk::locY, Trk::locY) = (sn2*v0+cs2*v1);
        }  // End of rotation endcap SCT
 
 
        sctCluster = new InDet::SCT_Cluster(intersectionId,
                                             intersection,
                                             std::move(rdoList),
                                             siWidth,
                                             hitSiDetElement,
                                             Amg::MatrixX(mat));
 
        m_sctClusterMap->insert(std::pair<IdentifierHash, InDet::SCT_Cluster* >(waferID, sctCluster));
 
        if (FillTruthMap(m_SCTPrdTruth, sctCluster, hit).isFailure()) {
          ATH_MSG_FATAL ( "FillTruthMap() for SCT failed!" );
          return StatusCode::FAILURE;
        }
 
        if (m_checkSmear) {
 
            ATH_MSG_DEBUG( "--- SiSmearedDigitizationTool: SCT_Cluster --> " << *sctCluster);
 
            //Take info to store in the tree
            m_x_SCT = m_useDiscSurface ? temp_Y : temp_X;
            m_x_SCT_smeared = (sctCluster->localPosition()).x();
 
            ATH_MSG_DEBUG( "--- SiSmearedDigitizationTool: BEFORE SMEARING LocalPosition --> X = " << m_x_SCT );
            ATH_MSG_DEBUG( "--- SiSmearedDigitizationTool: LocalPosition --> X = " << m_x_SCT_smeared );
 
            ATH_MSG_DEBUG( "--- SiSmearedDigitizationTool: GlobalPosition --> X = " << (sctCluster->globalPosition()).x() << "  Y = " << (sctCluster->globalPosition()).y());
            m_x_SCT_global = (sctCluster->globalPosition()).x();
            m_y_SCT_global = (sctCluster->globalPosition()).y();
            m_z_SCT_global = (sctCluster->globalPosition()).z();
 
            m_currentTree -> Fill();
        }  // End smear checking
      }  // End SCT
    } // while
  } //while
  return StatusCode::SUCCESS;
}

FillTruthMap()

template<typename CLUSTER>

StatusCode SiSmearedDigitizationTool::FillTruthMap	(	PRD_MultiTruthCollection *	map,
		CLUSTER *	cluster,
		const TimedHitPtr< SiHit > &	hit )

Definition at line 446 of file SiSmearedDigitizationTool.cxx.

                                                                                                                                  {
 
  ATH_MSG_DEBUG("Truth map filling with cluster " << *cluster << " and link = " << hit->particleLink());
  if (hit->particleLink().isValid()){
    if (!HepMC::ignoreTruthLink(hit->particleLink(), m_vetoPileUpTruthLinks)) {
      map->insert(std::make_pair(cluster->identify(), hit->particleLink()));
      ATH_MSG_DEBUG("Truth map filled with cluster " << *cluster << " and link = " << hit->particleLink());
    }
  }else{
    ATH_MSG_DEBUG("Particle link NOT valid!! Truth map NOT filled with cluster" << cluster << " and link = " << hit->particleLink());
  }
 
  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; }

finalize()

StatusCode SiSmearedDigitizationTool::finalize

(

)

Definition at line 241 of file SiSmearedDigitizationTool.cxx.

{
 
  if (m_checkSmear){
    m_outputFile->cd();
    m_currentTree->Write();
    m_outputFile->Close();
    ATH_MSG_DEBUG ( "SiSmearedDigitizationTool : Writing Tree" );
 
  }
 
  ATH_MSG_DEBUG ( "SiSmearedDigitizationTool : finalize()" );
 
 
  return StatusCode::SUCCESS;
 
}

initialize()

StatusCode SiSmearedDigitizationTool::initialize ( )

virtual

Reimplemented from PileUpToolBase.

Definition at line 133 of file SiSmearedDigitizationTool.cxx.

{
 
  ATH_MSG_DEBUG ( "SiSmearedDigitizationTool::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 (not m_SmearPixel){ // Smear SCT
    if (detStore()->retrieve(m_sct_ID, "SCT_ID").isFailure()) {
      ATH_MSG_ERROR ( "Could not get SCT ID helper" );
      return StatusCode::FAILURE;
    }
 
    m_inputObjectName="SCT_Hits"; // Set the input object name
  }
 
  // Initialize ReadCondHandleKeys
  ATH_CHECK(m_pixelDetEleCollKey.initialize(m_SmearPixel));
  ATH_CHECK(m_SCTDetEleCollKey.initialize(not m_SmearPixel));
 
  if (m_inputObjectName.empty())
    {
      ATH_MSG_FATAL ( "Property InputObjectName not set !" );
      return StatusCode::FAILURE;
    }
  else
    {
      ATH_MSG_DEBUG ( "Input objects: '" << m_inputObjectName << "'" );
    }
 
  //locate the PileUpMergeSvc and initialize our local ptr
  if (!m_mergeSvc.retrieve().isSuccess()) {
    ATH_MSG_ERROR ( "Could not find PileUpMergeSvc" );
    return StatusCode::FAILURE;
  }
 
  if (m_checkSmear){
 
    // get THistSvc
    ATH_CHECK(m_thistSvc.retrieve());
 
    if (m_SmearPixel){
      m_outputFile = new TFile("CheckSmearing_Pixel.root","RECREATE");
      m_currentTree = new TTree("PixelTree","Check smearing Pixel");
      m_currentTree->Branch("pixel_X"            , &m_x_pixel         , "m_x_pixel/D");
      m_currentTree->Branch("pixel_Y"            , &m_y_pixel         , "m_y_pixel/D");
      m_currentTree->Branch("pixel_X_exit"       , &m_x_exit_pixel    , "m_x_exit_pixel/D");
      m_currentTree->Branch("pixel_Y_exit"       , &m_y_exit_pixel    , "m_y_exit_pixel/D");
      m_currentTree->Branch("pixel_Z_exit"       , &m_z_exit_pixel    , "m_z_exit_pixel/D");
      m_currentTree->Branch("pixel_X_entry"      , &m_x_entry_pixel   , "m_x_entry_pixel/D");
      m_currentTree->Branch("pixel_Y_entry"      , &m_y_entry_pixel   , "m_y_entry_pixel/D");
      m_currentTree->Branch("pixel_Z_entry"      , &m_z_entry_pixel   , "m_z_entry_pixel/D");
      m_currentTree->Branch("pixel_X_global"     , &m_x_pixel_global  , "m_x_pixel_global/D");
      m_currentTree->Branch("pixel_Y_global"     , &m_y_pixel_global  , "m_y_pixel_global/D");
      m_currentTree->Branch("pixel_Z_global"     , &m_z_pixel_global  , "m_z_pixel_global/D");
      m_currentTree->Branch("pixel_X_smear"      , &m_x_pixel_smeared , "m_x_pixel_smeared/D");
      m_currentTree->Branch("pixel_Y_smear"      , &m_y_pixel_smeared , "m_y_pixel_smeared/D");
      m_currentTree->Branch("pixel_Err_X"        , &m_Err_x_pixel     , "m_Err_x_pixel/D");
      m_currentTree->Branch("pixel_Err_Y"        , &m_Err_y_pixel     , "m_Err_y_pixel/D");
 
      if( m_thistSvc->regTree("PixelTree",m_currentTree).isFailure()) {
        ATH_MSG_ERROR("Cannot register Ttree");
        return StatusCode::FAILURE;
      }else{
        ATH_MSG_DEBUG ( "Ttree registered" );
      }
    }
    else{
      m_outputFile = new TFile("CheckSmearing_SCT.root","RECREATE");
      m_currentTree = new TTree("SCT_Tree","Check smearing SCT");
      m_currentTree->Branch("SCT_X"             , &m_x_SCT         , "m_x_SCT/D");
      m_currentTree->Branch("SCT_exit_X"        , &m_x_exit_SCT    , "m_x_exit_SCT/D");
      m_currentTree->Branch("SCT_exit_Y"        , &m_y_exit_SCT    , "m_y_exit_SCT/D");
      m_currentTree->Branch("SCT_exit_Z"        , &m_z_exit_SCT    , "m_z_exit_SCT/D");
      m_currentTree->Branch("SCT_entry_X"       , &m_x_entry_SCT   , "m_x_entry_SCT/D");
      m_currentTree->Branch("SCT_entry_Y"       , &m_y_entry_SCT   , "m_y_entry_SCT/D");
      m_currentTree->Branch("SCT_entry_Z"       , &m_z_entry_SCT   , "m_z_entry_SCT/D");
      m_currentTree->Branch("SCT_X_global"      , &m_x_SCT_global  , "m_x_SCT_global/D");
      m_currentTree->Branch("SCT_Y_global"      , &m_y_SCT_global  , "m_y_SCT_global/D");
      m_currentTree->Branch("SCT_Z_global"      , &m_z_SCT_global  , "m_z_SCT_global/D");
      m_currentTree->Branch("SCT_X_smear"       , &m_x_SCT_smeared , "m_x_SCT_smeared/D");
      m_currentTree->Branch("SCT_Err_X"         , &m_Err_x_SCT     , "m_Err_x_SCT/D");
 
      if( m_thistSvc->regTree("SCT_Tree",m_currentTree).isFailure()) {
        ATH_MSG_ERROR("Cannot register Ttree");
        return StatusCode::FAILURE;
      }else{
        ATH_MSG_DEBUG ( "Ttree registered" );
      }
    }
 
 
  }
 
  return StatusCode::SUCCESS;
}

mergeClusters() [1/2]

StatusCode SiSmearedDigitizationTool::mergeClusters

(

Pixel_detElement_RIO_map *

cluster_map

)

Definition at line 550 of file SiSmearedDigitizationTool.cxx.

{
  // The idea is first to check how many cluster we have to merge and then merge them.
  // The loop is done until there aren't any clusters to merge
 
  ATH_MSG_DEBUG( "--- SiSmearedDigitizationTool: in mergeClusters() using PixelClusters --- ");
 
  Pixel_detElement_RIO_map::iterator i = cluster_map->begin();
  Pixel_detElement_RIO_map::iterator e = cluster_map->end();
 
  for (; i != e; i = cluster_map->upper_bound(i->first)){
    IdentifierHash current_id = i->first;
    // Check if clusters with current_id have been already considered
 
    bool NewMerge = true;
 
    while (NewMerge) {
      NewMerge = false;
      std::pair <Pixel_detElement_RIO_map::iterator, Pixel_detElement_RIO_map::iterator> range = cluster_map->equal_range(current_id);
 
      for ( Pixel_detElement_RIO_map::iterator iter = range.first; iter != range.second;  ++iter){
        for (Pixel_detElement_RIO_map::iterator inner_iter = std::next(iter); inner_iter != range.second; ++inner_iter){
 
          double dist = calculateDistance((*iter).second,(*inner_iter).second);
          double sigma = calculateSigma((*iter).second,(*inner_iter).second);
 
          if( dist <= m_nSigma * sigma) {
 
            std::vector<Identifier> rdoList;
 
            Amg::Vector2D intersection;
            InDet::SiWidth siWidth;
            Amg::MatrixX clusterErr;
            std::tie( intersection, siWidth, clusterErr ) = calculateNewCluster( iter->second, inner_iter->second );
 
            const InDetDD::SiDetectorElement* hitSiDetElement = (((*inner_iter).second)->detectorElement());
            Identifier intersectionId = hitSiDetElement->identifierOfPosition(intersection);
 
            rdoList.push_back(intersectionId);
 
            InDetDD::SiCellId currentCellId = hitSiDetElement->cellIdFromIdentifier(intersectionId);
 
            if ( !currentCellId.isValid() ) {
              continue;
            }
 
            InDet::PixelCluster* pixelCluster = new InDet::PixelCluster(intersectionId,
                                                                        intersection,
                                                                        std::move(rdoList),
                                                                        siWidth,
                                                                        hitSiDetElement,
                                                                        std::move(clusterErr));
            ((*inner_iter).second) = pixelCluster;
 
            cluster_map->erase(iter);
            NewMerge = true;
            goto REPEAT_LOOP;
          }
        }
      }
    REPEAT_LOOP: ;
    }
  }
 
  return StatusCode::SUCCESS;
}

mergeClusters() [2/2]

StatusCode SiSmearedDigitizationTool::mergeClusters

(

SCT_detElement_RIO_map *

cluster_map

)

Definition at line 618 of file SiSmearedDigitizationTool.cxx.

{
  ATH_MSG_DEBUG(
    "--- SiSmearedDigitizationTool: in mergeClusters() using SCT_Clusters ---");
 
  if (!cluster_map) {
    ATH_MSG_FATAL("Null SCT cluster map passed to mergeClusters()");
    return StatusCode::FAILURE;
  }
 
  auto i = cluster_map->begin();
 
  while (i != cluster_map->end()) {
    const IdentifierHash current_id = i->first;
    bool mergedThisPass;
 
    do {
      mergedThisPass = false;
      const auto range = cluster_map->equal_range(current_id);
 
      auto iter = range.first;
      //coverity complains due to the erase; but there is a break immediately after
      //coverity[INVALIDATE_ITERATOR]
      while (iter != range.second && !mergedThisPass) {
        auto inner_iter = std::next(iter);
 
        while (inner_iter != range.second) {
          const double dist =
            calculateDistance(iter->second, inner_iter->second);
          const double sigma =
            calculateSigma(iter->second, inner_iter->second);
 
          if (dist > m_nSigma * sigma) {
            ++inner_iter;
            continue;
          }
 
          Amg::Vector2D intersection;
          InDet::SiWidth siWidth;
          Amg::MatrixX clusterErr;
 
          std::tie(intersection, siWidth, clusterErr) =
            calculateNewCluster(iter->second, inner_iter->second);
 
          const InDetDD::SiDetectorElement* hitSiDetElement =
            inner_iter->second->detectorElement();
 
          const Identifier intersectionId =
            hitSiDetElement->identifierOfPosition(intersection);
 
          const InDetDD::SiCellId currentCellId =
            hitSiDetElement->cellIdFromIdentifier(intersectionId);
 
          if (!currentCellId.isValid()) {
            ++inner_iter;
            continue;
          }
 
          std::vector<Identifier> rdoList{intersectionId};
 
          auto sctCluster = std::make_unique<InDet::SCT_Cluster>(
            intersectionId,
            intersection,
            std::move(rdoList),
            siWidth,
            hitSiDetElement,
            std::move(clusterErr));
 
          auto* const oldIterCluster = iter->second;
          auto* const oldInnerCluster = inner_iter->second;
 
          inner_iter->second = sctCluster.release();
 
          delete oldIterCluster;
          delete oldInnerCluster;
 
          cluster_map->erase(iter);
 
          mergedThisPass = true;
          break;
        }
 
        if (!mergedThisPass) {
          ++iter;
        }
      }
    } while (mergedThisPass);
 
    i = cluster_map->upper_bound(current_id);
  }
 
  return StatusCode::SUCCESS;
}

mergeEvent()

StatusCode SiSmearedDigitizationTool::mergeEvent

(

const EventContext &

ctx

)

Definition at line 461 of file SiSmearedDigitizationTool.cxx.

                                                                     {
 
  if (m_SmearPixel)
    return mergeClusters(m_pixelClusterMap);
  else
    return mergeClusters(m_sctClusterMap);
}

operator=()

SiSmearedDigitizationTool & SiSmearedDigitizationTool::operator= ( const SiSmearedDigitizationTool & )

private

prepareEvent()

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

Definition at line 259 of file SiSmearedDigitizationTool.cxx.

{
 
  ATH_MSG_DEBUG( "--- SiSmearedDigitizationTool: in pixel prepareEvent() ---" );
 
  m_siHitCollList.clear();
  m_HardScatterSplittingSkipper = false;
 
  return StatusCode::SUCCESS;
}

processAllSubEvents()

StatusCode SiSmearedDigitizationTool::processAllSubEvents ( const EventContext & ctx )

virtual

Reimplemented from PileUpToolBase.

Definition at line 312 of file SiSmearedDigitizationTool.cxx.

                                                                                 {
 
  ATH_MSG_DEBUG( "--- SiSmearedDigitizationTool: in pixel processAllSubEvents() ---" );
 
  if(m_SmearPixel){ // Smear Pixel
    // --------------------------------------
    // PixelCluster 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 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())) );
 
  }else{ // Smear SCT
    // --------------------------------------
    // SCT_Cluster container registration
    unsigned int nwafer = m_sct_ID->wafer_hash_max();
    SG::WriteHandle<InDet::SCT_ClusterContainer> wh (m_Sct_SiClustersName);
    ATH_CHECK( wh.record (std::make_unique<InDet::SCT_ClusterContainer>(nwafer)) );
    m_sctClusterContainer = wh.ptr();
    m_sctClusterContainer->cleanup();
 
    // symlink the SCT 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())) );
  }
 
  if (retrieveTruth().isFailure()) {
    ATH_MSG_FATAL ( "retrieveTruth() failed!" );
    return StatusCode::FAILURE;
  }
 
  //  get the container(s)
  using TimedHitCollList = PileUpMergeSvc::TimedList<SiHitCollection>::type;
 
  m_simHitColl = new SiHitCollection;
 
  //this is a list<pair<time_t, DataLink<SCTUncompressedHitCollection> > >
  TimedHitCollList hitCollList;
  unsigned int numberOfSimHits(0);
  if ( !(m_mergeSvc->retrieveSubEvtsData(m_inputObjectName, 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 ) {
    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 (m_merge)
    if(this->mergeEvent(ctx).isFailure()) {
      ATH_MSG_FATAL ( "merge method failed!" );
      return StatusCode::FAILURE;
    }
 
  if (createAndStoreRIOs(ctx).isFailure()) {
    ATH_MSG_FATAL ( "createAndStoreRIOs() failed!" );
    return StatusCode::FAILURE;
  }
  else {
    ATH_MSG_DEBUG ( "createAndStoreRIOs() succeeded" );
  }
 
  return StatusCode::SUCCESS;
 
}

processBunchXing()

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

virtual

Reimplemented from PileUpToolBase.

Definition at line 271 of file SiSmearedDigitizationTool.cxx.

{
  ATH_MSG_DEBUG( "--- SiSmearedDigitizationTool: in pixel processBunchXing() ---" );
  //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, 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_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; }

retrieveTruth()

StatusCode SiSmearedDigitizationTool::retrieveTruth

(

)

Definition at line 406 of file SiSmearedDigitizationTool.cxx.

                                                   {
 
 
  if(m_SmearPixel){ // Smear Pixel
 
    m_pixelPrdTruth = new PRD_MultiTruthCollection;
 
    if ((evtStore()->contains<PRD_MultiTruthCollection>(m_prdTruthNamePixel))){
      if((evtStore()->retrieve(m_pixelPrdTruth, m_prdTruthNamePixel)).isFailure()){
        ATH_MSG_FATAL("Could not retrieve collection " << m_prdTruthNamePixel);
        return StatusCode::FAILURE;
      }
    }else{
      if((evtStore()->record(m_pixelPrdTruth, m_prdTruthNamePixel)).isFailure()){
        ATH_MSG_FATAL("Could not record collection " << m_prdTruthNamePixel);
        return StatusCode::FAILURE;
      }
    }
  }else{ // Smear SCT
    m_SCTPrdTruth = new PRD_MultiTruthCollection;
 
    if ((evtStore()->contains<PRD_MultiTruthCollection>(m_prdTruthNameSCT))){
      if((evtStore()->retrieve(m_SCTPrdTruth, m_prdTruthNameSCT)).isFailure()){
        ATH_MSG_FATAL("Could not retrieve collection " << m_prdTruthNameSCT);
        return StatusCode::FAILURE;
      }
    }else{
      if((evtStore()->record(m_SCTPrdTruth, m_prdTruthNameSCT)).isFailure()){
        ATH_MSG_FATAL("Could not record collection " << m_prdTruthNameSCT);
        return StatusCode::FAILURE;
      }
    }
  }
 
 
  return StatusCode::SUCCESS;
 
}

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_checkSmear

bool SiSmearedDigitizationTool::m_checkSmear

private

Definition at line 155 of file SiSmearedDigitizationTool.h.

m_currentTree

TTree* SiSmearedDigitizationTool::m_currentTree

private

the tree to store information from pixel and SCT (before and after smearing)

Definition at line 159 of file SiSmearedDigitizationTool.h.

m_emulateAtlas

bool SiSmearedDigitizationTool::m_emulateAtlas

private

Definition at line 150 of file SiSmearedDigitizationTool.h.

m_Err_x_pixel

double SiSmearedDigitizationTool::m_Err_x_pixel

private

Definition at line 188 of file SiSmearedDigitizationTool.h.

m_Err_x_SCT

double SiSmearedDigitizationTool::m_Err_x_SCT

private

Definition at line 190 of file SiSmearedDigitizationTool.h.

m_Err_y_pixel

double SiSmearedDigitizationTool::m_Err_y_pixel

private

Definition at line 189 of file SiSmearedDigitizationTool.h.

m_Err_y_SCT

double SiSmearedDigitizationTool::m_Err_y_SCT

private

Definition at line 191 of file SiSmearedDigitizationTool.h.

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_HardScatterSplittingMode

int SiSmearedDigitizationTool::m_HardScatterSplittingMode

private

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

Definition at line 130 of file SiSmearedDigitizationTool.h.

m_HardScatterSplittingSkipper

bool SiSmearedDigitizationTool::m_HardScatterSplittingSkipper

private

Definition at line 131 of file SiSmearedDigitizationTool.h.

m_inputObjectName

std::string SiSmearedDigitizationTool::m_inputObjectName

private

Definition at line 140 of file SiSmearedDigitizationTool.h.

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_merge

bool SiSmearedDigitizationTool::m_merge

private

Definition at line 120 of file SiSmearedDigitizationTool.h.

m_mergeSvc

ServiceHandle<PileUpMergeSvc> SiSmearedDigitizationTool::m_mergeSvc

private

PileUp Merge service.

Definition at line 129 of file SiSmearedDigitizationTool.h.

m_nSigma

double SiSmearedDigitizationTool::m_nSigma

private

Definition at line 121 of file SiSmearedDigitizationTool.h.

m_outputFile

TFile* SiSmearedDigitizationTool::m_outputFile

private

the root file

Definition at line 158 of file SiSmearedDigitizationTool.h.

m_pitch_X

float SiSmearedDigitizationTool::m_pitch_X

private

Definition at line 117 of file SiSmearedDigitizationTool.h.

m_pitch_Y

float SiSmearedDigitizationTool::m_pitch_Y

private

Definition at line 118 of file SiSmearedDigitizationTool.h.

m_pixel_ID

const PixelID* SiSmearedDigitizationTool::m_pixel_ID

private

Handle to the ID helper.

Definition at line 112 of file SiSmearedDigitizationTool.h.

m_pixel_SiClustersName

std::string SiSmearedDigitizationTool::m_pixel_SiClustersName

private

Definition at line 152 of file SiSmearedDigitizationTool.h.

m_pixelClusterContainer

InDet::PixelClusterContainer* SiSmearedDigitizationTool::m_pixelClusterContainer

private

the PixelClusterContainer

Definition at line 125 of file SiSmearedDigitizationTool.h.

m_pixelClusterMap

Pixel_detElement_RIO_map* SiSmearedDigitizationTool::m_pixelClusterMap {}

private

Definition at line 144 of file SiSmearedDigitizationTool.h.

{};

m_pixelDetEleCollKey

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

private

Definition at line 109 of file SiSmearedDigitizationTool.h.

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

m_pixelPrdTruth

PRD_MultiTruthCollection* SiSmearedDigitizationTool::m_pixelPrdTruth {}

private

Definition at line 133 of file SiSmearedDigitizationTool.h.

{};

m_prdTruthNamePixel

std::string SiSmearedDigitizationTool::m_prdTruthNamePixel

private

Definition at line 134 of file SiSmearedDigitizationTool.h.

m_prdTruthNameSCT

std::string SiSmearedDigitizationTool::m_prdTruthNameSCT

private

Definition at line 137 of file SiSmearedDigitizationTool.h.

m_randomEngineName

std::string SiSmearedDigitizationTool::m_randomEngineName

private

Name of the random number stream.

Definition at line 115 of file SiSmearedDigitizationTool.h.

m_rndmSvc

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

private

Random number service.

Definition at line 107 of file SiSmearedDigitizationTool.h.

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

m_sct_ID

const SCT_ID* SiSmearedDigitizationTool::m_sct_ID

private

Handle to the ID helper.

Definition at line 113 of file SiSmearedDigitizationTool.h.

m_Sct_SiClustersName

std::string SiSmearedDigitizationTool::m_Sct_SiClustersName

private

Definition at line 153 of file SiSmearedDigitizationTool.h.

m_sctClusterContainer

InDet::SCT_ClusterContainer* SiSmearedDigitizationTool::m_sctClusterContainer

private

the SCT_ClusterContainer

Definition at line 127 of file SiSmearedDigitizationTool.h.

m_sctClusterMap

SCT_detElement_RIO_map* SiSmearedDigitizationTool::m_sctClusterMap {}

private

Definition at line 146 of file SiSmearedDigitizationTool.h.

{};

m_SCTDetEleCollKey

SG::ReadCondHandleKey<InDetDD::SiDetectorElementCollection> SiSmearedDigitizationTool::m_SCTDetEleCollKey {this, "SCTDetEleCollKey", "SCT_DetectorElementCollection", "Key of SiDetectorElementCollection for SCT"}

private

Definition at line 110 of file SiSmearedDigitizationTool.h.

{this, "SCTDetEleCollKey", "SCT_DetectorElementCollection", "Key of SiDetectorElementCollection for SCT"};

m_SCTPrdTruth

PRD_MultiTruthCollection* SiSmearedDigitizationTool::m_SCTPrdTruth {}

private

Definition at line 136 of file SiSmearedDigitizationTool.h.

{};

m_siHitCollList

std::vector<SiHitCollection*> SiSmearedDigitizationTool::m_siHitCollList

private

name of the sub event hit collections.

Definition at line 142 of file SiSmearedDigitizationTool.h.

m_simHitColl

SiHitCollection* SiSmearedDigitizationTool::m_simHitColl {}

private

Definition at line 139 of file SiSmearedDigitizationTool.h.

{};

m_SmearPixel

bool SiSmearedDigitizationTool::m_SmearPixel

private

Definition at line 148 of file SiSmearedDigitizationTool.h.

m_thistSvc

ServiceHandle<ITHistSvc> SiSmearedDigitizationTool::m_thistSvc {this, "THistSvc", "THistSvc"}

private

Definition at line 157 of file SiSmearedDigitizationTool.h.

{this, "THistSvc", "THistSvc"};

m_useDiscSurface

bool SiSmearedDigitizationTool::m_useDiscSurface

private

Definition at line 123 of file SiSmearedDigitizationTool.h.

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"};

m_x_entry_pixel

double SiSmearedDigitizationTool::m_x_entry_pixel

private

Definition at line 166 of file SiSmearedDigitizationTool.h.

m_x_entry_SCT

double SiSmearedDigitizationTool::m_x_entry_SCT

private

Definition at line 177 of file SiSmearedDigitizationTool.h.

m_x_exit_pixel

double SiSmearedDigitizationTool::m_x_exit_pixel

private

Definition at line 163 of file SiSmearedDigitizationTool.h.

m_x_exit_SCT

double SiSmearedDigitizationTool::m_x_exit_SCT

private

Definition at line 174 of file SiSmearedDigitizationTool.h.

m_x_pixel

double SiSmearedDigitizationTool::m_x_pixel

private

Definition at line 161 of file SiSmearedDigitizationTool.h.

m_x_pixel_global

double SiSmearedDigitizationTool::m_x_pixel_global

private

Definition at line 169 of file SiSmearedDigitizationTool.h.

m_x_pixel_smeared

double SiSmearedDigitizationTool::m_x_pixel_smeared

private

Definition at line 184 of file SiSmearedDigitizationTool.h.

m_x_SCT

double SiSmearedDigitizationTool::m_x_SCT

private

Definition at line 173 of file SiSmearedDigitizationTool.h.

m_x_SCT_global

double SiSmearedDigitizationTool::m_x_SCT_global

private

Definition at line 180 of file SiSmearedDigitizationTool.h.

m_x_SCT_smeared

double SiSmearedDigitizationTool::m_x_SCT_smeared

private

Definition at line 186 of file SiSmearedDigitizationTool.h.

m_y_entry_pixel

double SiSmearedDigitizationTool::m_y_entry_pixel

private

Definition at line 167 of file SiSmearedDigitizationTool.h.

m_y_entry_SCT

double SiSmearedDigitizationTool::m_y_entry_SCT

private

Definition at line 178 of file SiSmearedDigitizationTool.h.

m_y_exit_pixel

double SiSmearedDigitizationTool::m_y_exit_pixel

private

Definition at line 164 of file SiSmearedDigitizationTool.h.

m_y_exit_SCT

double SiSmearedDigitizationTool::m_y_exit_SCT

private

Definition at line 175 of file SiSmearedDigitizationTool.h.

m_y_pixel

double SiSmearedDigitizationTool::m_y_pixel

private

Definition at line 162 of file SiSmearedDigitizationTool.h.

m_y_pixel_global

double SiSmearedDigitizationTool::m_y_pixel_global

private

Definition at line 170 of file SiSmearedDigitizationTool.h.

m_y_pixel_smeared

double SiSmearedDigitizationTool::m_y_pixel_smeared

private

Definition at line 185 of file SiSmearedDigitizationTool.h.

m_y_SCT_global

double SiSmearedDigitizationTool::m_y_SCT_global

private

Definition at line 181 of file SiSmearedDigitizationTool.h.

m_z_entry_pixel

double SiSmearedDigitizationTool::m_z_entry_pixel

private

Definition at line 168 of file SiSmearedDigitizationTool.h.

m_z_entry_SCT

double SiSmearedDigitizationTool::m_z_entry_SCT

private

Definition at line 179 of file SiSmearedDigitizationTool.h.

m_z_exit_pixel

double SiSmearedDigitizationTool::m_z_exit_pixel

private

Definition at line 165 of file SiSmearedDigitizationTool.h.

m_z_exit_SCT

double SiSmearedDigitizationTool::m_z_exit_SCT

private

Definition at line 176 of file SiSmearedDigitizationTool.h.

m_z_pixel_global

double SiSmearedDigitizationTool::m_z_pixel_global

private

Definition at line 171 of file SiSmearedDigitizationTool.h.

m_z_SCT_global

double SiSmearedDigitizationTool::m_z_SCT_global

private

Definition at line 182 of file SiSmearedDigitizationTool.h.

---

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

• SiSmearedDigitizationTool.h
• SiSmearedDigitizationTool.cxx