SCT_FastDigitizationTool Class Reference

#include <SCT_FastDigitizationTool.h>

Inheritance diagram for SCT_FastDigitizationTool:

Public Member Functions
	SCT_FastDigitizationTool (const std::string &type, const std::string &name, const IInterface *parent)
virtual StatusCode	initialize ()
	Called before processing physics events.
StatusCode	prepareEvent (const EventContext &ctx, unsigned int)
StatusCode	processBunchXing (int bunchXing, SubEventIterator bSubEvents, SubEventIterator eSubEvents)
StatusCode	mergeEvent (const EventContext &ctx)
StatusCode	processAllSubEvents (const EventContext &ctx)
StatusCode	createAndStoreRIOs (const EventContext &ctx)

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

Private Member Functions
StatusCode	digitize (const EventContext &ctx, TimedHitCollection< SiHit > &thpcsi)
bool	NeighbouringClusters (const std::vector< Identifier > &potentialClusterRDOList, const InDet::SCT_Cluster *existingCluster) const

Static Private Member Functions
static void	Diffuse (HepGeom::Point3D< double > &localEntry, HepGeom::Point3D< double > &localExit, double shiftX, double shiftY)
static Amg::Vector3D	stepToStripBorder (const InDetDD::SiDetectorElement &sidetel, double localStartX, double localStartY, double localEndX, double localEndY, double slopeYX, double slopeZX, const Amg::Vector2D &stripCenter, int direction)

Private Attributes
StringProperty	m_inputObjectName {this, "InputObjectName", "SCT_Hits", "Input Object name"}
std::vector< SiHitCollection * >	m_siHitCollList
	name of the sub event hit collections.
const SCT_ID *	m_sct_ID {}
	Handle to the ID helper.
ServiceHandle< PileUpMergeSvc >	m_mergeSvc {this, "MergeSvc", "PileUpMergeSvc", "Merge service"}
	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}
ServiceHandle< IAthRNGSvc >	m_rndmSvc {this, "RndmSvc", "AthRNGSvc", ""}
	Random number service.
StringProperty	m_randomEngineName {this, "RndmEngine", "FastSCT_Digitization"}
	Name of the random number stream.
TimedHitCollection< SiHit > *	m_thpcsi {}
PublicToolHandle< InDet::ClusterMakerTool >	m_clusterMaker {this, "ClusterMaker", "InDet::ClusterMakerTool"}
ToolHandle< ISiLorentzAngleTool >	m_lorentzAngleTool {this, "LorentzAngleTool", "SiLorentzAngleTool/SCTLorentzAngleTool", "Tool to retreive Lorentz angle"}
SCT_detElement_RIO_map *	m_sctClusterMap {}
SG::WriteHandleKey< InDet::SCT_ClusterContainer >	m_sctClusterContainerKey {this, "SCT_ClusterContainerName", "SCT_Clusters"}
	the SCT_ClusterContainer
SG::WriteHandleKey< PRD_MultiTruthCollection >	m_sctPrdTruthKey {this, "TruthNameSCT", "PRD_MultiTruthSCT"}
	the PRD truth map for SCT measurements
SG::ReadCondHandleKey< InDetDD::SiDetectorElementCollection >	m_SCTDetEleCollKey {this, "SCTDetEleCollKey", "SCT_DetectorElementCollection", "Key of SiDetectorElementCollection for SCT"}
DoubleProperty	m_sctSmearPathLength {this, "SCT_SmearPathSigma", 0.01}
	the 2.
BooleanProperty	m_sctSmearLandau {this, "SCT_SmearLandau", true}
	if true : landau else: gauss
BooleanProperty	m_sctEmulateSurfaceCharge {this, "EmulateSurfaceCharge", true}
	emulate the surface charge
DoubleProperty	m_sctTanLorentzAngleScalor {this, "SCT_ScaleTanLorentzAngle", 1.}
	scale the lorentz angle effect
BooleanProperty	m_sctAnalogStripClustering {this, "SCT_AnalogClustering", false}
	not being done in ATLAS: analog strip clustering
IntegerProperty	m_sctErrorStrategy {this, "SCT_ErrorStrategy", 2}
	error strategy for the ClusterMaker
BooleanProperty	m_sctRotateEC {this, "SCT_RotateEndcapClusters", true}
bool	m_mergeCluster {true}
	enable the merging of neighbour SCT clusters >
DoubleProperty	m_DiffusionShiftX_barrel {this, "DiffusionShiftX_barrel",4 }
DoubleProperty	m_DiffusionShiftY_barrel {this, "DiffusionShiftY_barrel", 4}
DoubleProperty	m_DiffusionShiftX_endcap {this, "DiffusionShiftX_endcap", 15}
DoubleProperty	m_DiffusionShiftY_endcap {this, "DiffusionShiftY_endcap", 15}
DoubleProperty	m_sctMinimalPathCut {this, "SCT_MinimalPathLength", 90.}
	the 1.

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 82 of file SCT_FastDigitizationTool.h.

Member Typedef Documentation

SCT_detElement_RIO_map

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

private

Definition at line 126 of file SCT_FastDigitizationTool.h.

Constructor & Destructor Documentation

SCT_FastDigitizationTool()

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

Definition at line 54 of file SCT_FastDigitizationTool.cxx.

                                                                             :
 
  PileUpToolBase(type, name, parent)
{
}

Member Function Documentation

createAndStoreRIOs()

StatusCode SCT_FastDigitizationTool::createAndStoreRIOs

(

const EventContext &

ctx

)

Definition at line 891 of file SCT_FastDigitizationTool.cxx.

{
  SG::WriteHandle<InDet::SCT_ClusterContainer> sctClusterContainer(m_sctClusterContainerKey, ctx);
  sctClusterContainer = std::make_unique<InDet::SCT_ClusterContainer>(m_sct_ID->wafer_hash_max());
  if(!sctClusterContainer.isValid()) {
    ATH_MSG_FATAL( "[ --- ] Could not create SCT_ClusterContainer");
    return StatusCode::FAILURE;
  }
  sctClusterContainer->cleanup();
 
  // --------------------------------------
  // symlink the SCT Container
  InDet::SiClusterContainer* symSiContainer=nullptr;
  CHECK(evtStore()->symLink(sctClusterContainer.ptr(),symSiContainer));
  ATH_MSG_DEBUG( "[ hitproc ] SCT_ClusterContainer symlinked to SiClusterContainer in StoreGate" );
  // --------------------------------------
 
  // Get SCT_DetectorElementCollection
  SG::ReadCondHandle<InDetDD::SiDetectorElementCollection> sctDetEle(m_SCTDetEleCollKey, ctx);
  const InDetDD::SiDetectorElementCollection* elements(sctDetEle.retrieve());
  if (elements==nullptr) {
    ATH_MSG_FATAL(m_SCTDetEleCollKey.fullKey() << " could not be retrieved");
    return StatusCode::FAILURE;
  }
 
  SCT_detElement_RIO_map::iterator clusterMapGlobalIter = m_sctClusterMap->begin();
  SCT_detElement_RIO_map::iterator endOfClusterMap = m_sctClusterMap->end();
  for (; clusterMapGlobalIter != endOfClusterMap; clusterMapGlobalIter = m_sctClusterMap->upper_bound(clusterMapGlobalIter->first))
    {
      std::pair <SCT_detElement_RIO_map::iterator, SCT_detElement_RIO_map::iterator> range;
      range = m_sctClusterMap->equal_range(clusterMapGlobalIter->first);
      SCT_detElement_RIO_map::iterator firstDetElem = range.first;
      const IdentifierHash waferID = firstDetElem->first;
      const InDetDD::SiDetectorElement *detElement = elements->getDetectorElement(waferID);
      InDet::SCT_ClusterCollection *clusterCollection = new InDet::SCT_ClusterCollection(waferID);
      if (clusterCollection)
        {
          clusterCollection->setIdentifier(detElement->identify());
          for ( SCT_detElement_RIO_map::iterator localClusterIter = range.first; localClusterIter != range.second; ++localClusterIter)
            {
              InDet::SCT_Cluster *sctCluster = localClusterIter->second;
              sctCluster->setHashAndIndex(clusterCollection->identifyHash(),clusterCollection->size());
              clusterCollection->push_back(sctCluster);
            }
          if (sctClusterContainer->addCollection(clusterCollection, clusterCollection->identifyHash()).isFailure())
            {
              ATH_MSG_WARNING( "Could not add collection to Identifiable container !" );
            }
        }
    } // end for
  m_sctClusterMap->clear();
 
  return StatusCode::SUCCESS;
}

Diffuse()

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

staticprivate

Definition at line 1026 of file SCT_FastDigitizationTool.cxx.

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

digitize()

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

private

!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

< @TODO CHECK

Definition at line 226 of file SCT_FastDigitizationTool.cxx.

{
  // truth info
  SG::WriteHandle< PRD_MultiTruthCollection > sctPrdTruth(m_sctPrdTruthKey, ctx);
  sctPrdTruth = std::make_unique< PRD_MultiTruthCollection >();
  if ( !sctPrdTruth.isValid() ) {
    ATH_MSG_FATAL( "Could not record collection " << sctPrdTruth.name() );
    return StatusCode::FAILURE;
  }
  ATH_MSG_DEBUG( "PRD_MultiTruthCollection " << sctPrdTruth.name() << " registered in StoreGate" );
 
  // 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);
 
  // Get SCT_DetectorElementCollection
  SG::ReadCondHandle<InDetDD::SiDetectorElementCollection> sctDetEle(m_SCTDetEleCollKey, ctx);
  const InDetDD::SiDetectorElementCollection* elements(sctDetEle.retrieve());
  if (elements==nullptr) {
    ATH_MSG_FATAL(m_SCTDetEleCollKey.fullKey() << " could not be retrieved");
    return StatusCode::FAILURE;
  }
 
  TimedHitCollection<SiHit>::const_iterator i, e;
  if(!m_sctClusterMap) { m_sctClusterMap = new SCT_detElement_RIO_map; }
  else { m_sctClusterMap->clear(); }
  while (thpcsi.nextDetectorElement(i, e))
    {
      SCT_detElement_RIO_map SCT_DetElClusterMap;
      std::vector<int> truthIdList;
      std::vector<Identifier> detEl;
      while (i != e)
        {
          const TimedHitPtr<SiHit>& currentSiHit(*i++);
          // check the status of truth information for this SiHit
          // some Truth information is cut for pile up events
          const HepMcParticleLink currentLink = HepMcParticleLink::getRedirectedLink(currentSiHit->particleLink(), currentSiHit.eventId(), ctx); // This link should now correctly resolve to the TruthEvent McEventCollection in the main StoreGateSvc.
 
          const Identifier waferId = m_sct_ID->wafer_id(currentSiHit->getBarrelEndcap(), currentSiHit->getLayerDisk(), currentSiHit->getPhiModule(), currentSiHit->getEtaModule(), currentSiHit->getSide());
          const IdentifierHash waferHash = m_sct_ID->wafer_hash(waferId);
          const InDetDD::SiDetectorElement *hitSiDetElement = elements->getDetectorElement(waferHash);
          if (!hitSiDetElement)
            {
              ATH_MSG_ERROR( "Could not get detector element.");
              continue;
            }
 
          // the module design
          const InDetDD::SCT_ModuleSideDesign* design = dynamic_cast<const InDetDD::SCT_ModuleSideDesign*>(&hitSiDetElement->design());
          if (!design)
            {
              ATH_MSG_WARNING ( "SCT_DetailedSurfaceChargesGenerator::process can not get "<< design) ;
              continue;
            }
 
          std::vector<HepMcParticleLink> hit_vector; //Store the hits in merged cluster
 
          // Process only one hit by the same particle in the same detector element
          bool isRep = false;
          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 detElId = hitSiDetElement->identify();
          for (int j : truthIdList)
            {
              for (auto & k : detEl)
                {
                  if ((truthID > 0) && (truthID == j) && (detElId == k)) {isRep = true; break;}
                }
              if (isRep) { break; }
            }
          if (isRep) { continue; }
          truthIdList.push_back(truthID);
          detEl.push_back(detElId);
 
          const double hitDepth  = hitSiDetElement->hitDepthDirection();
 
          double shiftX,shiftY;
          if (hitSiDetElement->isBarrel()){
            shiftX=m_DiffusionShiftX_barrel;
            shiftY=m_DiffusionShiftY_barrel;
          }
          else{
            shiftX=m_DiffusionShiftX_endcap;
            shiftY=m_DiffusionShiftY_endcap;
          }
 
          HepGeom::Point3D<double> localStartPosition = hitSiDetElement->hitLocalToLocal3D(currentSiHit->localStartPosition());
          HepGeom::Point3D<double> localEndPosition = hitSiDetElement->hitLocalToLocal3D(currentSiHit->localEndPosition());
 
          Diffuse(localStartPosition,localEndPosition, shiftX * Gaudi::Units::micrometer, shiftY * Gaudi::Units::micrometer);
 
          const double localEntryX = localStartPosition.x();
          const double localEntryY = localStartPosition.y();
          const double localEntryZ = localStartPosition.z();
          const double localExitX = localEndPosition.x();
          const double localExitY = localEndPosition.y();
          const double localExitZ = localEndPosition.z();
 
 
 
          const Amg::Vector2D localEntry(localEntryX,localEntryY);
          const Amg::Vector2D localExit(localExitX,localExitY);
          const Amg::Vector3D localExit3D(localExitX,localExitY,localExitZ);
 
          const double thickness = hitSiDetElement->thickness();
 
          const Trk::Surface *hitSurface = &hitSiDetElement->surface();
 
          const double distX = localExitX-localEntryX;
          const double distY = localExitY-localEntryY;
          const double distZ = localExitZ-localEntryZ;
 
          const Amg::Vector3D localDirection(distX, distY, distZ);
          // path length statistics
          double potentialClusterPath_Geom  = localDirection.mag();    // geometrical path length
          double potentialClusterPath_Step  = 0.;                      // path calculated through stepping
          double potentialClusterPath_Used  = 0.;                      // path used (contains smearing & cut if applied)
 
          // relational slope
          const double slopeYX = distY/distX;
          const double slopeXZ = distX/distZ;
          const double slopeZX = distZ/distX;
          // signs of stepping
          const int signX = distX > 0. ? 1 : -1 ;
          const int signY = distY > 0. ? 1 : -1 ;
          const int signZ = distZ > 0. ? 1 : -1 ;
 
          // get the identifier of the entry and the exit
          const Identifier entryId = hitSiDetElement->identifierOfPosition(localEntry);
          const Identifier exitId  = hitSiDetElement->identifierOfPosition(localExit);
          // now get the cellIds and check whether they're valid
          const InDetDD::SiCellId entryCellId = hitSiDetElement->cellIdFromIdentifier(entryId);
          const InDetDD::SiCellId exitCellId = hitSiDetElement->cellIdFromIdentifier(exitId);
          // entry / exit validity
          const bool entryValid = entryCellId.isValid();
          const bool exitValid  = exitCellId.isValid();
 
          // the intersecetion id and cellId of it
          const double par = -localEntryZ/(localExitZ-localEntryZ);
          const double interX = localEntryX + par*(localExitX-localEntryX);
          const double interY = localEntryY + par*(localExitY-localEntryY);
 
          const Amg::Vector2D intersection(interX,interY);
          const Identifier intersectionId            =  hitSiDetElement->identifierOfPosition(intersection);
 
          // apply the lorentz correction
          const IdentifierHash detElHash = hitSiDetElement->identifyHash();
          const double tanLorAng     = m_sctTanLorentzAngleScalor*m_lorentzAngleTool->getTanLorentzAngle(detElHash, ctx);
          const int lorentzDirection = tanLorAng > 0. ? 1 : -1;
          const bool useLorentzDrift = std::abs(tanLorAng) > 0.01;
          // shift parameters
          const double shift = m_lorentzAngleTool->getLorentzShift(detElHash, ctx);
          // lorenz angle effects : offset goes against the lorentzAngle
          const double xLoffset  = -lorentzDirection*thickness*tanLorAng;
 
          // --------------------------------------------------------------------------------------
          // fast exit: skip non-valid entry && exit
          if (!entryValid && !exitValid)
            {
              continue;
            }
 
          std::vector<Identifier>          potentialClusterRDOList;
          std::map<Identifier, double>     surfaceChargeWeights;
          // min/max indices
          int phiIndexMinRaw = 1000;
          int phiIndexMaxRaw = -1000;
 
          // is it a single strip w/o drift effect ? - also check the numerical stability
          const bool singleStrip = (entryCellId == exitCellId && entryValid);
          if (singleStrip && !useLorentzDrift)
            {
              // ----------------------- single strip lucky case  ----------------------------------------
              // 1 strip cluster without drift effect
              surfaceChargeWeights[intersectionId] = potentialClusterPath_Geom;
            }
          else
            {
              // the start parameters
              int strips = 0;
              // needed for both approaches with and w/o drift
              Identifier          currentId             = entryId;
              InDetDD::SiCellId   currentCellId         = entryCellId;
              Amg::Vector2D  currentCenterPosition = hitSiDetElement->rawLocalPositionOfCell(currentCellId);
              Amg::Vector3D  currentPosition3D(localEntryX,localEntryY,localEntryZ);
              Amg::Vector3D  currentStep3D(0.,0.,0.);
 
              // ============================== the clusteristiaon core =====================================================
              // ----------------------- barrel geometrical clustering with drift -------------------------------------------
              // there are two independent loops
              // (a) the geometrical steps through the strips : labelled current
              Amg::Vector2D  currentCenterStep(0.,0.);
              // check for non-valid entry diode ... this needs to be reset then
              // ---------------------------------------------------
              // start position needs to be reset : --------
              if (!entryValid)
                {
                  // the number of strips in Phi
                  const int numberOfDiodesPhi = design->cells();
                  // the simple case is if the exit is outside locY
                  if (!hitSurface->bounds().insideLoc2(localEntry))
                    {
                      // step towards the border
                      const double stepInY = signY*(std::abs(localEntryY)-0.5*hitSiDetElement->length());
                      const double stepInX = stepInY*distX/distY;
                      const double stepInZ = stepInY*distZ/distY;
                      currentStep3D = Amg::Vector3D(stepInX,stepInY,stepInZ);
                    }
                  else
                    {
                      //get the last valid phi border
                      const int phiExitIndex   = exitCellId.phiIndex() <= 2 ? 0 : numberOfDiodesPhi-1;
 
                      const InDetDD::SiCellId  phiExitId(phiExitIndex);
                      const Amg::Vector2D phiExitCenter = hitSiDetElement->rawLocalPositionOfCell(phiExitId);
                      // fill the step parameters
                      // this may need to be changed to Rectangular/Trapezoid check
                      currentStep3D = stepToStripBorder(*hitSiDetElement,
                                                        //*hitSurface,
                                                        localEntryX, localEntryY,
                                                        localExitX, localExitY,
                                                        slopeYX,
                                                        slopeZX,
                                                        phiExitCenter,
                                                        signX);
                    } // ENDIF !hitSurface->bounds().insideLoc2(localEntry)
 
                  // get to the first valid strip ---------------------------------------------------
                  currentPosition3D += currentStep3D;
                  // for the record
                  potentialClusterPath_Step += currentStep3D.mag();
                  ATH_MSG_VERBOSE("[ cluster - sct ] Strip entry shifted by " << currentStep3D << " ( " <<  potentialClusterPath_Step << " )");
                  // for step epsilon into the first valid
                  const Amg::Vector2D positionInFirstValid(currentPosition3D.x()+0.01*signX,currentPosition3D.y()+0.01*signY);
                  // reset the entry parameters to the first valid pixel
                  currentId             = hitSiDetElement->identifierOfPosition(positionInFirstValid);
                  currentCellId         = hitSiDetElement->cellIdFromIdentifier(currentId);
                  currentCenterPosition = hitSiDetElement->rawLocalPositionOfCell(currentId);
 
                } // ----- start position has been reset -------- ( // endif (!entryValid) )
 
              // (b) the collection of strips due to surface charge
              // the lorentz plane setp
              double        lplaneStepX = 0.;
              double        lplaneStepY = 0.;
              Amg::Vector3D lplaneIntersection(0.,0.,0.);
              Amg::Vector3D driftPrePosition3D(currentPosition3D);
              Amg::Vector3D driftPostPosition3D(currentPosition3D);
              // (c) simple cache for the purely geometrical clustering
              Identifier    lastId = currentId;
              bool          lastStrip = false;
              ATH_MSG_VERBOSE("[ cluster - sct ] CurrentPosition " << currentPosition3D );
 
              // the steps between the strips -------------------------------------------
              for ( ; ; ++strips)
                {
                  // -------------------------------------------------------------------------------------------------
                  // current phi/eta indices
                  const int currentPhiIndex = currentCellId.phiIndex();
                  // record for the full validation
                  // (a) steps through the strips
                  // sct break for last strip or if you step out of the game
                  if (lastStrip || currentPosition3D.z() > 0.5*thickness || strips > 4)
                    {
                      break;
                    }
                  // no single valid strip
                  if (!exitValid && !currentCellId.isValid())
                    {
                      break;
                    }
                  // cache it
                  phiIndexMinRaw = currentPhiIndex < phiIndexMinRaw ?  currentPhiIndex : phiIndexMinRaw;
                  phiIndexMaxRaw = currentPhiIndex > phiIndexMaxRaw ?  currentPhiIndex : phiIndexMaxRaw;
                  // find out if this is the last step
                  lastStrip = (currentPhiIndex == exitCellId.phiIndex());
                  // get the current Pitch
                  const double currentPitchX = hitSiDetElement->phiPitch(currentCenterPosition);
                  // the next & previous sct borders are needed (next is w.r.t to the track direction)
                  std::vector<double> lorentzLinePositions;
                  const int trackDir = slopeXZ > 0 ? 1 : -1; //FIXME will be multiplying doubles by this int!
                  lorentzLinePositions.reserve(2);
                  // the both pixel borders left/right
                  lorentzLinePositions.push_back(currentCenterPosition.x() + trackDir*0.5*currentPitchX);
                  lorentzLinePositions.push_back(currentCenterPosition.x() - trackDir*0.5*currentPitchX);
                  // the third line is possible -> it is due to xOffset > pitchX
                  if (xLoffset*xLoffset > currentPitchX*currentPitchX)
                    {
                      lorentzLinePositions.push_back(currentCenterPosition.x() + lorentzDirection*1.5*currentPitchX);
                    }
                  // intersect the effective lorentz plane if the intersection is not valid anymore
                  bool          lplaneInterInCurrent(false);
                  double        lorentzPlaneHalfX(0.);
                  Amg::Vector3D lplaneCandidate(0.,0.,0.);
                  std::vector<double>::iterator lorentzLinePosIter = lorentzLinePositions.begin();
                  // find the intersection solutions for the three cases
                  int lplaneDirection = 100; // solve the intersection case first
                  // test left and right lorentz planes of this pixel
                  for ( ; lorentzLinePosIter != lorentzLinePositions.end(); ++lorentzLinePosIter)
                    {
                      // first - do the intersection : the readout side is respected by the hit depth direction
                      Trk::LineIntersection2D intersectLorentzPlane(localEntryX,-0.5*signZ*thickness,localExitX,0.5*signZ*thickness,
                                                                    (*lorentzLinePosIter)+xLoffset,-0.5*hitDepth*thickness,
                                                                    (*lorentzLinePosIter),0.5*hitDepth*thickness);
                      // avoid repeating intersections
                      const double formerPlaneStepZ = intersectLorentzPlane.interY-lplaneIntersection.z();
                      if (formerPlaneStepZ*formerPlaneStepZ < 10e-5)
                        {
                          lplaneInterInCurrent = false;
                          continue;
                        }
                      // is the intersection within the z thickness ?
                      lplaneInterInCurrent = intersectLorentzPlane.interY > -0.5*thickness
                        && intersectLorentzPlane.interY < 0.5*thickness;
                      // the step in z from the former plane intersection
                      // only go on if it is worth it
                      // (a) it has to be within z boundaries
                      if (lplaneInterInCurrent)
                        {
                          // record: the half position of the loretnz plane - for estimation to be under/over
                          lorentzPlaneHalfX = (*lorentzLinePosIter)+0.5*xLoffset;
                          // plane step parameters
                          lplaneStepX = intersectLorentzPlane.interX-localEntryX;
                          lplaneStepY = lplaneStepX*slopeYX;
                          // todo -> break condition if you are hitting the same intersection
                          lplaneCandidate = Amg::Vector3D(intersectLorentzPlane.interX,
                                                          localEntryY+lplaneStepY,
                                                          intersectLorentzPlane.interY);
                          // check in y, the x direction is only needed to find out the drift direction
                          const double distToNextLineY = 0.5*hitSiDetElement->length()-lplaneCandidate.y();
                          const double distToPrevLineY = -0.5*hitSiDetElement->length()-lplaneCandidate.y();
                          lplaneInterInCurrent = (distToNextLineY*distToPrevLineY) < 0.;
                          // we have an intersection candidate - needs to be resolved for +1/-1
                          lplaneDirection = lplaneInterInCurrent ? 0 : lplaneDirection;
                          if (lplaneInterInCurrent) {break;}
                        }
                    }
                  // now assign it (if valid)
                  if (lplaneInterInCurrent) {lplaneIntersection = lplaneCandidate;}
                  ATH_MSG_VERBOSE( "[ cluster - pix ] Lorentz plane intersection x/y/z = "
                                   << lplaneCandidate.x() << ", "
                                   << lplaneCandidate.y() << ", "
                                   << lplaneCandidate.z() );
 
                  // now solve for 1 / -1 if needed
                  if (lplaneDirection)
                    {
                      // check the z position of the track at this stage
                      const double trackZatlplaneHalfX = (lorentzPlaneHalfX-localEntryX)*slopeXZ - 0.5*thickness;
                      lplaneDirection = trackZatlplaneHalfX < 0. ? -1 : 1;
                    }
 
                  // record the lorentz plane intersections
                  // calculate the potential step in X and Y
                  currentStep3D = lastStrip ? localExit3D-currentPosition3D :  
                    stepToStripBorder(*hitSiDetElement,
                                      //*hitSurface,
                                      currentPosition3D.x(), currentPosition3D.y(),
                                      localExitX, localExitY,
                                      slopeYX,
                                      slopeZX,
                                      currentCenterPosition,
                                      signX);
 
                  // add the current Step to the current position
                  currentPosition3D     += currentStep3D;
                  // check whether the step has led outside
                  if (!hitSurface->bounds().insideLoc2(Amg::Vector2D(currentPosition3D.x(),
                                                                     currentPosition3D.y())))
                    { // stepping outside in y calls for last step
                      lastStrip = true;
                      // correct to the new position
                      currentPosition3D -= currentStep3D;
                      const double stepInY = signY*0.5*hitSiDetElement->length()-currentPosition3D.y();
                      const double stepInX = distX/distY*stepInY;
                      const double stepInZ = slopeZX*stepInX;
                      // update to the new currentStep
                      currentStep3D = Amg::Vector3D(stepInX,stepInY,stepInZ);
                      currentPosition3D += currentStep3D;
                    }
                  //           if (currentPosition3D.z() > 0.501*signZ*thickness){
                  if (std::abs(currentPosition3D.z()) > 0.501*thickness)
                    {
                      // step has led out of the silicon, correct for it
                      lastStrip = true;
                      // correct to the new position (has been seen only three times ... probably numerical problem)
                      currentPosition3D -= currentStep3D;
                      currentStep3D      = localExit3D-currentPosition3D;
                      currentPosition3D  = localExit3D;
                      //
                      ATH_MSG_VERBOSE("[ cluster - sct ] - current position set to local Exit position !");
                    }
 
                  // update the current values for the next step
                  const Amg::Vector2D currentInsidePosition(currentPosition3D.x()+0.01*signX,currentPosition3D.y()+0.01*signY);
                  currentId              = hitSiDetElement->identifierOfPosition(currentInsidePosition);
                  currentCellId          = hitSiDetElement->cellIdFromIdentifier(currentId);
                  // just to be sure also for fan structure cases
                  currentCenterPosition = hitSiDetElement->rawLocalPositionOfCell(currentCellId);
                  // The new current Position && the path length for monitoring
                  potentialClusterPath_Step              += currentStep3D.mag();
                  ATH_MSG_VERBOSE("[ cluster - sct ] CurrentPosition " << currentPosition3D
                                  << " ( yielded by :" << currentStep3D  << ")");
                  // setting the drift Post position
                  driftPostPosition3D = lplaneInterInCurrent ? lplaneIntersection : currentPosition3D;
                  // ---------- the surface charge is emulated -------------------------------------------------------
                  if (m_sctEmulateSurfaceCharge && useLorentzDrift)
                    {
                      // loop to catch lpintersection in last step
                      const int currentDrifts = (lastStrip && lplaneInterInCurrent) ? 2 : 1;
                      for (int idrift = 0; idrift < currentDrifts; ++idrift)
                        {
                          // const assignment for fast access, take intersection solution first, then cell exit
                          const Amg::Vector3D& currentDriftPrePosition  = idrift ? driftPostPosition3D : driftPrePosition3D;
                          const Amg::Vector3D& currentDriftPostPosition = idrift ? localExit3D : driftPostPosition3D;
                          // get the center of the step and drift it to the surface
                          const Amg::Vector3D driftStepCenter = 0.5*(currentDriftPrePosition+currentDriftPostPosition);
                          // respect the reaout side through the hit dept direction
                          const double driftZtoSurface    = 0.5*hitDepth*thickness-driftStepCenter.z();
                          // record the drift position on the surface
                          const double driftPositionAtSurfaceX = driftStepCenter.x() + tanLorAng*driftZtoSurface;
                          const Amg::Vector2D driftAtSurface(driftPositionAtSurfaceX,
                                                             driftStepCenter.y());
                          const Identifier surfaceChargeId = hitSiDetElement->identifierOfPosition(driftAtSurface);
                          if (surfaceChargeId.is_valid())
                            {
                              // check if the pixel has already got some charge
                              if (surfaceChargeWeights.find(surfaceChargeId) == surfaceChargeWeights.end())
                                {
                                  surfaceChargeWeights[surfaceChargeId] = (currentDriftPostPosition-currentDriftPrePosition).mag();
                                }
                              else
                                {
                                  surfaceChargeWeights[surfaceChargeId] += (currentDriftPostPosition-currentDriftPrePosition).mag();
                                }
                            }
                          // record the drift step for validation
                        } // end of last step intersection check
                    }
                  else // ---------- purely geometrical clustering w/o surface charge ---------------------------
                    {
                      surfaceChargeWeights[lastId] = currentStep3D.mag();
                    }
                  // next pre is current post && lastId is currentId
                  driftPrePosition3D = driftPostPosition3D;
                  lastId = currentId;
 
                } // end of steps between strips ----------------------------------------------------------------------
            }
 
          // the calculated local position
          double totalWeight = 0.;
          Amg::Vector2D potentialClusterPosition(0.,0.);
          std::map<Identifier,double>::iterator weightIter =  surfaceChargeWeights.begin();
          for ( ; weightIter != surfaceChargeWeights.end(); ++weightIter)
            {
              // get the (effective) path length in the strip
              double chargeWeight = (weightIter)->second;
              const Identifier chargeId = (weightIter)->first;
              // charge smearing if set : 2 possibilities landau/gauss
              // two options fro charge smearing: landau / gauss
              if ( m_sctSmearPathLength > 0. )
                {
                  // create the smdar parameter
                  const double sPar = m_sctSmearLandau ?
                    m_sctSmearPathLength*CLHEP::RandLandau::shoot(rndmEngine) :
                    m_sctSmearPathLength*CLHEP::RandGaussZiggurat::shoot(rndmEngine);
                  chargeWeight *=  (1.+sPar);
                }
 
              // the threshold cut
              if (!(chargeWeight > m_sctMinimalPathCut)) { continue; }
 
              // get the position according to the identifier
              const Amg::Vector2D chargeCenterPosition = hitSiDetElement->rawLocalPositionOfCell(chargeId);
              potentialClusterPath_Used += chargeWeight;
              // taken Weight (Fatras can do analog SCT clustering)
              const double takenWeight =  m_sctAnalogStripClustering ? chargeWeight : 1.;
              totalWeight += takenWeight;
              potentialClusterPosition += takenWeight * chargeCenterPosition;
              // and record the rdo
              potentialClusterRDOList.push_back(chargeId);
            }
          // bail out - no left overs after cut
 
          if (potentialClusterRDOList.empty() || potentialClusterPath_Used < m_sctMinimalPathCut)
            {
              continue;
            }
 
 
 
          // ---------------------------------------------------------------------------------------------
          //  PART 2: Cluster && ROT creation
          //
          // the Cluster Parameters -----------------------------
          // normalize cluster position && get identifier
          potentialClusterPosition *= 1./totalWeight;
          /*const */Identifier potentialClusterId = hitSiDetElement->identifierOfPosition(potentialClusterPosition);
          if (!potentialClusterId.is_valid()) {continue;}
 
          const IdentifierHash waferID = m_sct_ID->wafer_hash(hitSiDetElement->identify());
 
          // merging clusters
          if(m_mergeCluster){
            unsigned int countC(0);
            ATH_MSG_INFO("Before cluster merging there were " << SCT_DetElClusterMap.size() << " clusters in the SCT_DetElClusterMap.");
            for(SCT_detElement_RIO_map::iterator existingClusterIter = SCT_DetElClusterMap.begin(); existingClusterIter != SCT_DetElClusterMap.end();)
              {
                ++countC;
                if (countC>100)
                  {
                    ATH_MSG_WARNING("Over 100 clusters checked for merging - bailing out!!");
                    break;
                  }
                if (m_sct_ID->wafer_hash(((existingClusterIter->second)->detectorElement())->identify()) != waferID) {continue;}
                //make a temporary to use within the loop and possibly erase - increment the main interator at the same time.
                SCT_detElement_RIO_map::iterator currentExistingClusterIter = existingClusterIter++;
 
                const InDet::SCT_Cluster *existingCluster = (currentExistingClusterIter->second);
                bool isNeighbour = this->NeighbouringClusters(potentialClusterRDOList, existingCluster);
                if(isNeighbour)
                  {
                    //Merge the clusters
                    const std::vector<Identifier> &existingClusterRDOList = existingCluster->rdoList();
                    potentialClusterRDOList.insert(potentialClusterRDOList.end(), existingClusterRDOList.begin(), existingClusterRDOList.end() );
                    Amg::Vector2D existingClusterPosition(existingCluster->localPosition());
                    potentialClusterPosition = (potentialClusterPosition + existingClusterPosition)/2;
                    potentialClusterId = hitSiDetElement->identifierOfPosition(potentialClusterPosition);
                    //FIXME - also need to tidy up any associations to the deleted cluster in the truth container too.
                    SCT_DetElClusterMap.erase(currentExistingClusterIter);
 
 
                    //Store HepMcParticleLink connected to the cluster removed from the collection
                    std::pair<PRD_MultiTruthCollection::iterator,PRD_MultiTruthCollection::iterator> saved_hit = sctPrdTruth->equal_range(existingCluster->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) sctPrdTruth->erase(existingCluster->identify());
 
                    delete existingCluster;
                    ATH_MSG_VERBOSE("Merged two clusters.");
                    //break; // Should look for more than one possible merge.
                  }
              }
            ATH_MSG_INFO("After cluster merging there were " << SCT_DetElClusterMap.size() << " clusters in the SCT_DetElClusterMap.");
          }
          // check whether this is a trapezoid
          const bool isTrapezoid(design->shape()==InDetDD::Trapezoid);
          // prepare & create the siWidth
          std::unique_ptr<InDet::SCT_Cluster> potentialClusterUniq = nullptr;
          // Find length of strip at centre
          const double clusterWidth(potentialClusterRDOList.size()*hitSiDetElement->phiPitch(potentialClusterPosition)); 
          const std::pair<InDetDD::SiLocalPosition, InDetDD::SiLocalPosition> ends(design->endsOfStrip(potentialClusterPosition));
          const double stripLength = std::abs(ends.first.xEta()-ends.second.xEta());
          const InDet::SiWidth siWidth( Amg::Vector2D(int(potentialClusterRDOList.size()),1), Amg::Vector2D(clusterWidth,stripLength) );
          // 2a) Cluster creation ------------------------------------
          if (!m_clusterMaker.empty())
            {
              ATH_MSG_INFO("Using ClusterMakerTool to make cluster.");
              // correct for the shift that will be applied in the cluster maker
              // (only if surface charge emulation was switched off )
              if (!m_sctEmulateSurfaceCharge && shift*shift > 0.)
                {
                  potentialClusterPosition -=  Amg::Vector2D(shift,0.);
                }
              // safe to compare m_sctTanLorentzAngleScalor with 1. since it is set not calculated
              else if (m_sctTanLorentzAngleScalor != 1. && shift*shift > 0.)
                {
                  // correct shift implied by the scaling of the Lorentz angle
                  const double newshift = 0.5*thickness*tanLorAng;
                  const double corr = ( shift - newshift );
                  potentialClusterPosition +=  Amg::Vector2D(corr,0.);
                }
              bool not_valid = false;
              for (auto & i : potentialClusterRDOList)
                {
                  if (!(i.is_valid()))
                    {
                      not_valid = true;
                      break;
                    }
                }
              if (not_valid)
                {
                  continue;
                }
                potentialClusterUniq = std::make_unique<InDet::SCT_Cluster>(
                    m_clusterMaker->sctCluster(
                        potentialClusterId, potentialClusterPosition,
                        std::vector<Identifier>(potentialClusterRDOList), siWidth, hitSiDetElement,
                        m_sctErrorStrategy));
            }
          else
            {
              ATH_MSG_INFO("Making cluster locally.");
              // you need to correct for the lorentz drift -- only if surface charge emulation was switched on
              const double appliedShift = m_sctEmulateSurfaceCharge ? m_sctTanLorentzAngleScalor*shift : (1.-m_sctTanLorentzAngleScalor)*shift;
              const Amg::Vector2D lcorrectedPosition = Amg::Vector2D(potentialClusterPosition.x()+appliedShift,potentialClusterPosition.y());
              AmgSymMatrix(2) mat;
              mat.setIdentity();
              mat(Trk::locX,Trk::locX) = (clusterWidth*clusterWidth)/12.;
              mat(Trk::locY,Trk::locY) = (stripLength*stripLength)/12.;
              // rotation for endcap SCT
              if(isTrapezoid  && m_sctRotateEC)
                {
                  const double Sn      = hitSiDetElement->sinStereoLocal(intersection);
                  const double Sn2     = Sn*Sn;
                  const double Cs2     = 1.-Sn2;
                  //double W       = detElement->phiPitch(*clusterLocalPosition)/detElement->phiPitch();
                  //double V0      = mat(Trk::locX,Trk::locX)*W*W;
                  const double V0      = mat(Trk::locX,Trk::locX);
                  const 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);
                }
 
              // create a custom cluster
                potentialClusterUniq = std::make_unique<InDet::SCT_Cluster>(
                    potentialClusterId, lcorrectedPosition,
                    std::vector<Identifier>(potentialClusterRDOList), siWidth, hitSiDetElement,
                    Amg::MatrixX(mat));
            }
 
            //SCT_DetElClusterMap takes ownership of the ptr
            const auto it =
                SCT_DetElClusterMap.insert(SCT_detElement_RIO_map::value_type(
                    waferID, potentialClusterUniq.release()));
 
            //since we use this later
            const InDet::SCT_Cluster*  potentialCluster = it->second;
 
            // Build Truth info for current cluster
            if (currentLink.isValid()) {
              if (!HepMC::ignoreTruthLink(currentLink, m_vetoPileUpTruthLinks)) {
                sctPrdTruth->insert(std::make_pair(potentialCluster->identify(), currentLink));
                ATH_MSG_DEBUG("Truth map filled with cluster" << potentialCluster << " and link = " << currentLink);
              }
            }
          else
            {
              ATH_MSG_DEBUG("Particle link NOT valid!! Truth map NOT filled with cluster" << potentialCluster << " and link = " << currentLink);
            }
 
 
          for(const HepMcParticleLink& p: hit_vector){
            sctPrdTruth->insert(std::make_pair(potentialCluster->identify(), p ));
          }
 
          hit_vector.clear();
 
 
        } // end hit while
 
      (void) m_sctClusterMap->insert(SCT_DetElClusterMap.begin(), SCT_DetElClusterMap.end());
    }
  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 SCT_FastDigitizationTool::initialize ( )

virtual

Called before processing physics events.

Reimplemented from PileUpToolBase.

Definition at line 65 of file SCT_FastDigitizationTool.cxx.

{
 
  //locate the AtRndmGenSvc and initialize our local ptr
  CHECK(m_rndmSvc.retrieve());
 
  CHECK(detStore()->retrieve(m_sct_ID, "SCT_ID"));
 
  if (m_inputObjectName=="")
    {
      ATH_MSG_FATAL ( "Property InputObjectName not set !" );
      return StatusCode::FAILURE;
    }
  else
    {
      ATH_MSG_DEBUG ( "Input objects: '" << m_inputObjectName << "'" );
    }
  ATH_CHECK(m_sctClusterContainerKey.initialize());
  ATH_CHECK(m_sctPrdTruthKey.initialize());
 
  // retrieve the offline cluster maker : for pixel and/or sct
  if (!m_clusterMaker.empty())
    {
      CHECK(m_clusterMaker.retrieve());
    }
 
  //locate the PileUpMergeSvc and initialize our local ptr
  CHECK(m_mergeSvc.retrieve());
 
  CHECK(m_lorentzAngleTool.retrieve());
  //Initialize threshold
  m_sctMinimalPathCut = m_sctMinimalPathCut * Gaudi::Units::micrometer;
 
  // Initialize ReadCondHandleKey
  ATH_CHECK(m_SCTDetEleCollKey.initialize());
 
  return StatusCode::SUCCESS ;
}

mergeEvent()

StatusCode SCT_FastDigitizationTool::mergeEvent

(

const EventContext &

ctx

)

Definition at line 205 of file SCT_FastDigitizationTool.cxx.

{
  if (m_thpcsi != nullptr)
    {
      CHECK(this->digitize(ctx, *m_thpcsi));
    }
 
  //-----------------------------------------------------------------------
  // Clean up temporary containers
  delete m_thpcsi;
  for(SiHitCollection* ptr : m_siHitCollList) delete ptr;
  m_siHitCollList.clear();
  //-----------------------------------------------------------------------
 
  CHECK(this->createAndStoreRIOs(ctx));
  ATH_MSG_DEBUG ( "createAndStoreRIOs() succeeded" );
 
  return StatusCode::SUCCESS;
}

NeighbouringClusters()

bool SCT_FastDigitizationTool::NeighbouringClusters ( const std::vector< Identifier > & potentialClusterRDOList, const InDet::SCT_Cluster * existingCluster ) const

private

Definition at line 991 of file SCT_FastDigitizationTool.cxx.

{
  //---------------------------------------------------------------------------------
  bool isNeighbour = false;
  unsigned int countR(0);
  const std::vector<Identifier> &existingClusterRDOList = existingCluster->rdoList();
  std::vector<Identifier>::const_iterator potentialClusterRDOIter = potentialClusterRDOList.begin();
  for ( ; potentialClusterRDOIter != potentialClusterRDOList.end(); ++potentialClusterRDOIter)
    {
      ++countR;
      if (countR>100)
        {
          ATH_MSG_WARNING("Over 100 RDOs checked for the given cluster - bailing out!!");
          break;
        }
      std::vector<Identifier>::const_iterator existingClusterRDOIter = existingClusterRDOList.begin();
      for( ; existingClusterRDOIter != existingClusterRDOList.end(); ++existingClusterRDOIter)
        {
          if(std::abs(m_sct_ID->strip(*existingClusterRDOIter) - m_sct_ID->strip(*potentialClusterRDOIter)) < 2)
            {
              isNeighbour = true;
              break;
            }
        } // end of loop over RDOs in the current existing Cluster
      if (isNeighbour)
        {
          ATH_MSG_VERBOSE("The clusters are neighbours and can be merged.");
          break;
        }
    } // end of loop over RDOs in the potential cluster
  //---------------------------------------------------------------------------------
  return isNeighbour;
}

prepareEvent()

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

Definition at line 104 of file SCT_FastDigitizationTool.cxx.

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

processAllSubEvents()

StatusCode SCT_FastDigitizationTool::processAllSubEvents ( const EventContext & ctx )

virtual

Reimplemented from PileUpToolBase.

Definition at line 155 of file SCT_FastDigitizationTool.cxx.

                                                                                {
 
  //  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
  CHECK(this->digitize(ctx, thpcsi));
 
  CHECK(this->createAndStoreRIOs(ctx));
  ATH_MSG_DEBUG ( "createAndStoreRIOs() succeeded" );
 
  return StatusCode::SUCCESS;
}

processBunchXing()

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

virtual

Reimplemented from PileUpToolBase.

Definition at line 114 of file SCT_FastDigitizationTool.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; }

stepToStripBorder()

Amg::Vector3D SCT_FastDigitizationTool::stepToStripBorder ( const InDetDD::SiDetectorElement & sidetel, double localStartX, double localStartY, double localEndX, double localEndY, double slopeYX, double slopeZX, const Amg::Vector2D & stripCenter, int direction )

staticprivate

Definition at line 946 of file SCT_FastDigitizationTool.cxx.

{
  double stepExitX = 0.;
  double stepExitY = 0.;
  double stepExitZ = 0.;
  const double coef(1.);
 
  // probably needs to be changed to rect/trapezoid
  if (sidetel.isBarrel())
    {
      // the exit position of the new strip
      double xExitPosition = stripCenter.x()+direction*0.5*sidetel.phiPitch(stripCenter);
      stepExitX = xExitPosition-localStartX;
      stepExitY = stepExitX*slopeYX;
      stepExitZ = stepExitX*slopeZX;
    }
  else
    {
      // the end position of this particular strip
      std::pair<Amg::Vector3D,Amg::Vector3D> stripEndGlobal = sidetel.endsOfStrip(stripCenter);
      Amg::Vector3D oneStripEndLocal = coef*stripEndGlobal.first;
      Amg::Vector3D twoStripEndLocal = coef*stripEndGlobal.second;
 
      double oneStripPitch = sidetel.phiPitch(Amg::Vector2D(oneStripEndLocal.x(), oneStripEndLocal.y()));
      double twoStripPitch = sidetel.phiPitch(Amg::Vector2D(twoStripEndLocal.x(), twoStripEndLocal.y()));
      // now intersect track with border
      Trk::LineIntersection2D intersectStripBorder(localStartX,localStartY,localEndX,localEndY,
                                                   oneStripEndLocal.x()+direction*0.5*oneStripPitch,oneStripEndLocal.y(),
                                                   twoStripEndLocal.x()+direction*0.5*twoStripPitch,twoStripEndLocal.y());
      // the step in x
      stepExitX = intersectStripBorder.interX - localStartX;
      stepExitY = slopeYX*stepExitX;
      stepExitZ = slopeZX*stepExitX;
    }
  return Amg::Vector3D(stepExitX,stepExitY,stepExitZ);
}

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_clusterMaker

PublicToolHandle<InDet::ClusterMakerTool> SCT_FastDigitizationTool::m_clusterMaker {this, "ClusterMaker", "InDet::ClusterMakerTool"}

private

Definition at line 123 of file SCT_FastDigitizationTool.h.

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

m_DiffusionShiftX_barrel

DoubleProperty SCT_FastDigitizationTool::m_DiffusionShiftX_barrel {this, "DiffusionShiftX_barrel",4 }

private

Definition at line 142 of file SCT_FastDigitizationTool.h.

{this, "DiffusionShiftX_barrel",4 };

m_DiffusionShiftX_endcap

DoubleProperty SCT_FastDigitizationTool::m_DiffusionShiftX_endcap {this, "DiffusionShiftX_endcap", 15}

private

Definition at line 144 of file SCT_FastDigitizationTool.h.

{this, "DiffusionShiftX_endcap", 15};

m_DiffusionShiftY_barrel

DoubleProperty SCT_FastDigitizationTool::m_DiffusionShiftY_barrel {this, "DiffusionShiftY_barrel", 4}

private

Definition at line 143 of file SCT_FastDigitizationTool.h.

{this, "DiffusionShiftY_barrel", 4};

m_DiffusionShiftY_endcap

DoubleProperty SCT_FastDigitizationTool::m_DiffusionShiftY_endcap {this, "DiffusionShiftY_endcap", 15}

private

Definition at line 145 of file SCT_FastDigitizationTool.h.

{this, "DiffusionShiftY_endcap", 15};

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

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

private

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

Definition at line 115 of file SCT_FastDigitizationTool.h.

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

m_HardScatterSplittingSkipper

bool SCT_FastDigitizationTool::m_HardScatterSplittingSkipper {false}

private

Definition at line 116 of file SCT_FastDigitizationTool.h.

{false};

m_inputObjectName

StringProperty SCT_FastDigitizationTool::m_inputObjectName {this, "InputObjectName", "SCT_Hits", "Input Object name"}

private

Definition at line 109 of file SCT_FastDigitizationTool.h.

{this, "InputObjectName", "SCT_Hits", "Input Object name"};     

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> SCT_FastDigitizationTool::m_lorentzAngleTool {this, "LorentzAngleTool", "SiLorentzAngleTool/SCTLorentzAngleTool", "Tool to retreive Lorentz angle"}

private

Definition at line 124 of file SCT_FastDigitizationTool.h.

{this, "LorentzAngleTool", "SiLorentzAngleTool/SCTLorentzAngleTool", "Tool to retreive Lorentz angle"};

m_mergeCluster

bool SCT_FastDigitizationTool::m_mergeCluster {true}

private

enable the merging of neighbour SCT clusters >

Definition at line 141 of file SCT_FastDigitizationTool.h.

{true}; 

m_mergeSvc

ServiceHandle<PileUpMergeSvc> SCT_FastDigitizationTool::m_mergeSvc {this, "MergeSvc", "PileUpMergeSvc", "Merge service"}

private

PileUp Merge service.

Definition at line 114 of file SCT_FastDigitizationTool.h.

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

m_randomEngineName

StringProperty SCT_FastDigitizationTool::m_randomEngineName {this, "RndmEngine", "FastSCT_Digitization"}

private

Name of the random number stream.

Definition at line 119 of file SCT_FastDigitizationTool.h.

{this, "RndmEngine", "FastSCT_Digitization"};    

m_rndmSvc

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

private

Random number service.

Definition at line 118 of file SCT_FastDigitizationTool.h.

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

m_sct_ID

const SCT_ID* SCT_FastDigitizationTool::m_sct_ID {}

private

Handle to the ID helper.

Definition at line 113 of file SCT_FastDigitizationTool.h.

{};                              

m_sctAnalogStripClustering

BooleanProperty SCT_FastDigitizationTool::m_sctAnalogStripClustering {this, "SCT_AnalogClustering", false}

private

not being done in ATLAS: analog strip clustering

Definition at line 137 of file SCT_FastDigitizationTool.h.

{this, "SCT_AnalogClustering", false}; 

m_sctClusterContainerKey

SG::WriteHandleKey<InDet::SCT_ClusterContainer> SCT_FastDigitizationTool::m_sctClusterContainerKey {this, "SCT_ClusterContainerName", "SCT_Clusters"}

private

the SCT_ClusterContainer

Definition at line 129 of file SCT_FastDigitizationTool.h.

{this, "SCT_ClusterContainerName", "SCT_Clusters"}; 

m_sctClusterMap

SCT_detElement_RIO_map* SCT_FastDigitizationTool::m_sctClusterMap {}

private

Definition at line 127 of file SCT_FastDigitizationTool.h.

{};

m_SCTDetEleCollKey

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

private

Definition at line 131 of file SCT_FastDigitizationTool.h.

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

m_sctEmulateSurfaceCharge

BooleanProperty SCT_FastDigitizationTool::m_sctEmulateSurfaceCharge {this, "EmulateSurfaceCharge", true}

private

emulate the surface charge

Definition at line 135 of file SCT_FastDigitizationTool.h.

{this, "EmulateSurfaceCharge", true};  

m_sctErrorStrategy

IntegerProperty SCT_FastDigitizationTool::m_sctErrorStrategy {this, "SCT_ErrorStrategy", 2}

private

error strategy for the ClusterMaker

Definition at line 138 of file SCT_FastDigitizationTool.h.

{this, "SCT_ErrorStrategy", 2};         

m_sctMinimalPathCut

DoubleProperty SCT_FastDigitizationTool::m_sctMinimalPathCut {this, "SCT_MinimalPathLength", 90.}

private

the 1.

model parameter: minimal 3D path in strip

Definition at line 146 of file SCT_FastDigitizationTool.h.

{this, "SCT_MinimalPathLength", 90.};        

m_sctPrdTruthKey

SG::WriteHandleKey<PRD_MultiTruthCollection> SCT_FastDigitizationTool::m_sctPrdTruthKey {this, "TruthNameSCT", "PRD_MultiTruthSCT"}

private

the PRD truth map for SCT measurements

Definition at line 130 of file SCT_FastDigitizationTool.h.

{this, "TruthNameSCT", "PRD_MultiTruthSCT"};         

m_sctRotateEC

BooleanProperty SCT_FastDigitizationTool::m_sctRotateEC {this, "SCT_RotateEndcapClusters", true}

private

Definition at line 139 of file SCT_FastDigitizationTool.h.

{this, "SCT_RotateEndcapClusters", true};

m_sctSmearLandau

BooleanProperty SCT_FastDigitizationTool::m_sctSmearLandau {this, "SCT_SmearLandau", true}

private

if true : landau else: gauss

Definition at line 134 of file SCT_FastDigitizationTool.h.

{this, "SCT_SmearLandau", true};           

m_sctSmearPathLength

DoubleProperty SCT_FastDigitizationTool::m_sctSmearPathLength {this, "SCT_SmearPathSigma", 0.01}

private

the 2.

model parameter: smear the path

Definition at line 133 of file SCT_FastDigitizationTool.h.

{this, "SCT_SmearPathSigma", 0.01};       

m_sctTanLorentzAngleScalor

DoubleProperty SCT_FastDigitizationTool::m_sctTanLorentzAngleScalor {this, "SCT_ScaleTanLorentzAngle", 1.}

private

scale the lorentz angle effect

Definition at line 136 of file SCT_FastDigitizationTool.h.

{this, "SCT_ScaleTanLorentzAngle", 1.}; 

m_siHitCollList

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

private

name of the sub event hit collections.

Definition at line 111 of file SCT_FastDigitizationTool.h.

m_thpcsi

TimedHitCollection<SiHit>* SCT_FastDigitizationTool::m_thpcsi {}

private

Definition at line 121 of file SCT_FastDigitizationTool.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"};

---

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

• SCT_FastDigitizationTool.h
• SCT_FastDigitizationTool.cxx