Trk::ReFitTrackWithTruth Class Reference

Algorithm using an instance of a ITrackFitter to refit the tracks of a given pseudotrack collection after changing the cluster position to the truth particle position. More...

#include <ReFitTrackWithTruth.h>

Inheritance diagram for Trk::ReFitTrackWithTruth:

Collaboration diagram for Trk::ReFitTrackWithTruth:

Public Types
typedef Trk::Track	Track

Public Member Functions
	ReFitTrackWithTruth (const std::string &name, ISvcLocator *pSvcLocator)
	standard Algorithm constructor
virtual StatusCode	initialize () override
virtual StatusCode	execute () override
virtual StatusCode	sysInitialize () override
	Override sysInitialize.
virtual const DataObjIDColl &	extraOutputDeps () const override
	Return the list of extra output dependencies.
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
virtual StatusCode	sysStart () override
	Handle START transition.
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles.
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T, V, H > &t)
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
bool	msgLvl (const MSG::Level lvl) const

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void >	renounce (T &h)
void	extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
	Add StoreName to extra input/output deps as needed.

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
std::vector< SiHit >	matchSiHitsToCluster (const int uniqueIdToMatch, const InDet::PixelCluster *pixClus, SG::ReadHandle< AtlasHitsVector< SiHit > > &siHitCollection) const
HepGeom::Point3D< double >	smearTruthPosition (const HepGeom::Point3D< double > &orig, const int bec, const int layer_disk, const InDetDD::SiDetectorDesign *design) const
double	getPhiPosResolution (int layer) const
double	getEtaPosResolution (int layer) const
double	getPhiPosErrorFactor (int layer) const
double	getEtaPosErrorFactor (int layer) const
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Static Private Member Functions
static bool	IsClusterFromTruth (const InDet::PixelCluster *pixClus, const int uniqueIdToMatch, const InDetSimDataCollection &sdoCollection)

Private Attributes
SG::ReadHandleKey< TrackCollection >	m_inputTrackColName {this,"InputTrackColName","","collection name for tracks to be refitted"}
SG::WriteHandleKey< TrackCollection >	m_outputTrackCollectionName {this,"OutputTrackColName","ReFitted_TracksWithTruth","collection name for output tracks"}
boost::thread_specific_ptr< TRandom3 >	m_random
	smear away!
Trk::RunOutlierRemoval	m_runOutlier = false
int	m_matEffects = 3
Gaudi::Property< bool >	m_saveWrongHits {this, "SaveWrongHits", false}
Gaudi::Property< bool >	m_fixWrongHits {this, "FixWrongHits", false}
Gaudi::Property< bool >	m_rejNoiseHits {this, "RejectNoiseHits", false}
Trk::ParticleHypothesis	m_ParticleHypothesis = Trk::pion
SG::ReadHandleKey< SiHitCollection >	m_siHitCollectionName {this,"SiHitCollectionName","PixelHits",""}
SG::ReadHandleKey< InDetSimDataCollection >	m_SDOContainerName {this,"MC_SDOs","PixelSDO_Map"}
SG::ReadHandleKey< TrackTruthCollection >	m_truthMapName {this,"TruthMap","InDetTracksTruthCollection"}
Gaudi::Property< std::vector< float > >	m_resolutionRPhi {this, "ResolutionRPhi", {}}
Gaudi::Property< std::vector< float > >	m_resolutionZ {this, "ResolutionZ", {}}
Gaudi::Property< std::vector< float > >	m_errorRPhi {this, "ErrorFactorRPhi", {}}
Gaudi::Property< std::vector< float > >	m_errorZ {this, "ErrorFactorZ", {}}
ToolHandle< Trk::ITrackFitter >	m_ITrackFitter {this, "FitterTool", "Trk::GlobalChi2Fitter/InDetTrackFitter" }
	the refit tool
ToolHandle< Trk::IExtendedTrackSummaryTool >	m_trkSummaryTool {this, "SummaryTool", "Trk::TrackSummaryTool/InDetTrackSummaryTool" }
	the track summary tool
ToolHandle< Trk::IPRDtoTrackMapTool >	m_assoTool {this, "AssociationTool", "Trk::PRDtoTrackMapTool" }
	Tool to create and populate PRD to track.
const AtlasDetectorID *	m_idHelper = nullptr
	Detector ID helper.
const PixelID *	m_pixelID = nullptr
	Pixel ID.
DataObjIDColl	m_extendedExtraObjects
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default)
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default)
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared

Detailed Description

Algorithm using an instance of a ITrackFitter to refit the tracks of a given pseudotrack collection after changing the cluster position to the truth particle position.

Author

Gabri.nosp@m.el.F.nosp@m.acini.nosp@m.@cer.nosp@m.n.ch, Andre.nosp@m.a.Sc.nosp@m.iandr.nosp@m.a@ce.nosp@m.rn.ch

Definition at line 54 of file ReFitTrackWithTruth.h.

Member Typedef Documentation

StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< Algorithm > >::StoreGateSvc_t

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Track

typedef Trk::Track Trk::ReFitTrackWithTruth::Track

Definition at line 58 of file ReFitTrackWithTruth.h.

Constructor & Destructor Documentation

ReFitTrackWithTruth()

Trk::ReFitTrackWithTruth::ReFitTrackWithTruth	(	const std::string &	name,
		ISvcLocator *	pSvcLocator )

standard Algorithm constructor

Definition at line 35 of file ReFitTrackWithTruth.cxx.

                                                                                           :
  AthAlgorithm(name,pSvcLocator)
{
 
}

Member Function Documentation

declareGaudiProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty ( Gaudi::Property< T, V, H > & hndl, const SG::VarHandleKeyType &  )

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKey>

Definition at line 156 of file AthCommonDataStore.h.

  {
    return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                       hndl.value(), 
                                                       hndl.documentation());
 
  }

declareProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( Gaudi::Property< T, V, H > & t )

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

                                                                     {
    typedef typename SG::HandleClassifier<T>::type htype;
    return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
  }

detStore()

const ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< Algorithm > >::detStore ( ) const

inlineinherited

The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 95 of file AthCommonDataStore.h.

{ return m_detStore; }

evtStore()

ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< Algorithm > >::evtStore ( )

inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 85 of file AthCommonDataStore.h.

{ return m_evtStore; }

execute()

StatusCode Trk::ReFitTrackWithTruth::execute ( )

overridevirtual

Definition at line 112 of file ReFitTrackWithTruth.cxx.

{
  ATH_MSG_DEBUG ("ReFitTrackWithTruth::execute()");
  std::unique_ptr<Trk::PRDtoTrackMap> prd_to_track_map(m_assoTool->createPRDtoTrackMap());
  const EventContext& ctx = Gaudi::Hive::currentContext();
 
  SG::ReadHandle<TrackCollection> tracks(m_inputTrackColName, ctx);
  if (!tracks.isValid()) {
    ATH_MSG_ERROR(m_inputTrackColName.key() << " not found");
    return StatusCode::FAILURE;
  }
 
  //retrieve truth information needed (SiHitCollection)
  SG::ReadHandle<SiHitCollection> siHits(m_siHitCollectionName, ctx);
  if (!siHits.isValid()) {
    ATH_MSG_WARNING( "Error retrieving SiHitCollection " << m_siHitCollectionName);
    return StatusCode::FAILURE;
  }
 
  //retrieve truth information needed (SDOCollection)
  SG::ReadHandle<InDetSimDataCollection> sdoCollection(m_SDOContainerName, ctx);
  if (!sdoCollection.isValid()) {
    ATH_MSG_WARNING( "Error retrieving SDOCollection " << m_SDOContainerName );
    return StatusCode::FAILURE;
  }
 
  //retrieve truth map
  SG::ReadHandle<TrackTruthCollection> truthMap(m_truthMapName, ctx);
  if (!truthMap.isValid()) {
    ATH_MSG_WARNING( "Error retrieving truth map " << m_truthMapName );
    return StatusCode::FAILURE;
  }
 
  // create new collection of tracks to write in storegate
  std::vector<std::unique_ptr<Trk::Track> > newtracks;
 
  // loop over tracks
  for (TrackCollection::const_iterator itr  = tracks->begin(); itr != tracks->end(); ++itr) {
    ATH_MSG_DEBUG("input track");
 
    // Get original parameters
    const TrackParameters* origPerigee = (*itr)->perigeeParameters();
    double od0(0);
    double oz0(0);
    double ophi0(0);
    double otheta(0);
    double oqOverP(0);
    if (!origPerigee){
      ATH_MSG_WARNING("Cannot get original parameters");
    }
    else if (msgLvl(MSG::DEBUG)) {
      od0 = origPerigee->parameters()[Trk::d0];
      oz0 = origPerigee->parameters()[Trk::z0];
      ophi0 = origPerigee->parameters()[Trk::phi0];
      otheta = origPerigee->parameters()[Trk::theta];
      oqOverP = origPerigee->parameters()[Trk::qOverP];
      ATH_MSG_DEBUG ("Original parameters " << od0  << " " << oz0  << " " << ophi0 << " " << otheta << " " << oqOverP);
    }
 
    // get the unique ID of truth particle matched to the track
    float minProb(0);
 
    // copy from DenseEnvironmentsAmbiguityProcessorTool.cxx
    ElementLink<TrackCollection> tracklink;
    tracklink.setElement(const_cast<Trk::Track*>(*itr));
    tracklink.setStorableObject(*tracks);
    const ElementLink<TrackCollection> tracklink2=tracklink;
 
    TrackTruthCollection::const_iterator found = truthMap->find(tracklink2);
    if ( found == truthMap->end() )                { continue; }
    if ( !found->second.particleLink().isValid() ) { continue; }
    if ( found->second.probability() < minProb )   { continue; }
    int uniqueIdToMatch = HepMC::uniqueID(&(found->second.particleLink()));
    ATH_MSG_DEBUG ("Unique ID to match " << uniqueIdToMatch);
 
    // now that have the track, loop through and build a new set of measurements for a track fit
    std::vector<const Trk::MeasurementBase*> measurementSet;
    std::vector<const Trk::MeasurementBase*> trash;
 
    ATH_MSG_DEBUG ("Loop over measurementsOnTrack " << (*itr)->measurementsOnTrack()->size() );
    for (const auto *measurement : *((*itr)->measurementsOnTrack())) {
      ATH_MSG_DEBUG ("Next Measurement: " << *measurement);
 
      // Get measurement as RIO_OnTrack
      const Trk::RIO_OnTrack* rio = dynamic_cast <const Trk::RIO_OnTrack*>( measurement );
      if (rio == nullptr) {
        ATH_MSG_WARNING("Cannot get RIO_OnTrack from measurement. Hit will NOT be included in track fit.");
        continue;
      }
 
      // if not a pixel cluster, keep the measurement as is and press on
      const Identifier& surfaceID = (rio->identify()) ;
      if( !m_idHelper->is_pixel(surfaceID) ) {
        measurementSet.push_back( measurement );
        continue;
      }
 
      // only PIXEL CLUSTERS from here on
      const InDet::PixelCluster* pix = dynamic_cast<const InDet::PixelCluster*>(rio->prepRawData());
      if (pix == nullptr) {
        ATH_MSG_WARNING("Cannot get PixelCluster from RIO_OnTrack");
        continue;
      }
 
      const InDetDD::SiDetectorElement* element = pix->detectorElement();
      const InDetDD::SiDetectorDesign* design = static_cast<const InDetDD::SiDetectorDesign*>(&element->design());
      // To locate cluster module
      Identifier clusterId = pix->identify();
      int bec              = m_pixelID->barrel_ec(clusterId);
      int layer_disk       = m_pixelID->layer_disk(clusterId);
 
      // Do any SDOs in reconstructed cluster match uniqueIdToMatch
      // Should always return true for pseudotracks. For reco tracks could differ
      bool hasSDOMatch = IsClusterFromTruth( pix, uniqueIdToMatch, *sdoCollection );
 
      // --- hit flags' logic
      // m_saveWrongHits - only has impact on reco track, where hit might be from wrong particle
      // m_fixWrongHits - fix will only work on hits that are not noise, noise hits behavior unchanged by this flag
      // m_rejNoiseHits - if saving but don't want to save these
 
      // could be used already here to correct wrong hits
      double maxEnergyDeposit(-1);
      SiHit maxEDepSiHit;
 
      if ( !hasSDOMatch ) {
        ATH_MSG_DEBUG ("No SDO matching cluster");
        // save wrong hits
        if (not m_saveWrongHits) continue;
        const std::vector<SiHit> matchedSiHits = matchSiHitsToCluster( -999 , pix, siHits );
        if( matchedSiHits.empty() ) {  // then noise, and go to next hit
          if( !m_rejNoiseHits ) { measurementSet.push_back( measurement ); }
          continue;
        } // is a real hit, just not from the particle in question -- will NOT go to next hit just yet
        if( m_fixWrongHits ) { // if fix, use highest energy truth hit
          for( const auto& siHit : matchedSiHits ) {
            if (siHit.energyLoss() > maxEnergyDeposit) {
              maxEnergyDeposit = siHit.energyLoss();
              maxEDepSiHit = siHit;
            }
          }
        } else { // save the wrong hit as is and go to next cluster
          measurementSet.push_back( measurement );
          continue;
        }
      } else { // hasSDOMatch
        // Get All SiHits truth matched to the reconstruction cluster for the particle associated with the track
        const std::vector<SiHit> matchedSiHits = matchSiHitsToCluster( uniqueIdToMatch, pix, siHits );
        if( matchedSiHits.empty() ) {
          ATH_MSG_WARNING ("No SiHit matching cluster");
          continue;  // should NOT HAPPEN for pseudotracks
        }
        ATH_MSG_DEBUG ("N SiHit matching cluster: " << matchedSiHits.size());
 
        // If multiple SiHits / cluster FOR THE SAME TRUTH PARTICLE,
        // Take position of SiHit giving the most energy
        for( const auto& siHit : matchedSiHits ) {
          if (siHit.energyLoss() > maxEnergyDeposit) {
            maxEnergyDeposit = siHit.energyLoss();
            maxEDepSiHit = siHit;
          }
        }
      } // if else hasSDOMatch
 
      // - Retrieve true position of cluster from entry/exit point of truth particle
      //get average position of entry/exit point
      HepGeom::Point3D<double> averagePosition = (maxEDepSiHit.localStartPosition() + maxEDepSiHit.localEndPosition()) * 0.5;
      ATH_MSG_DEBUG (" Average position : " << averagePosition);
 
      // SiHit coordinate system i.e. localStartPosition
      // z = eta -> this is y in ATLAS sensor local frame
      // y = phi -> this is x in ATLAS sensor local frame
      // USE hitLocalToLocal from SiDetectorElement
 
      HepGeom::Point3D<double> smearedPosition = smearTruthPosition( averagePosition, bec, layer_disk, design );
      ATH_MSG_DEBUG (" Smeared position : " << smearedPosition );
 
      auto locparOrig = rio->localParameters();
      ATH_MSG_DEBUG(" Original locpar " << locparOrig);
 
      Trk::LocalParameters locpar = element->hitLocalToLocal(smearedPosition.z(), smearedPosition.y()); // eta, phi
      ATH_MSG_DEBUG(" locpar " << locpar);
 
      InDetDD::SiLocalPosition centroid(locpar.get(Trk::loc2), locpar.get(Trk::loc1), 0); // eta, phi, depth
      const Amg::Vector3D& globPos = element->globalPosition(centroid);
 
      InDet::SiWidth pixWidth = pix->width();
      Amg::MatrixX   cov      = pix->localCovariance();
      // Original code took width / nrows (or columns)* 1/sqrt(12) to check if > 0...
      // only need to check width to test against 0...
      // disk one is layer 0
      if(bec!=0) layer_disk++;
      if(pixWidth.phiR()>0) {
        float error(1.0);
        error = getPhiPosResolution(layer_disk)*getPhiPosErrorFactor(layer_disk);
        cov(0,0) = error*error;
      } else {
        ATH_MSG_WARNING("pixWidth.phiR not > 0");
      }
 
      if(pixWidth.z()>0) {
        float error(1.0);
        error = getEtaPosResolution(layer_disk)*getEtaPosErrorFactor(layer_disk);
        cov(1,1) = error*error;
      } else {
        ATH_MSG_WARNING("pixWidth.z not > 0");
      }
 
      auto iH = element->identifyHash();
 
      InDet::PixelClusterOnTrack* pcot = new InDet::PixelClusterOnTrack(pix,std::move(locpar),std::move(cov),iH,globPos,
          pix->gangedPixel(),
          false);
 
      if(pcot) {
        measurementSet.push_back( pcot);
        trash.push_back(pcot);
      } else {
        ATH_MSG_WARNING("Could not make new PixelClusterOnTrack");
      }
 
    } // loop over measurements on track
 
 
 
    ATH_MSG_DEBUG ("Fit new tracks with measurementSet : " << measurementSet.size());
    std::unique_ptr<Trk::Track> newtrack;
    try {
      newtrack = m_ITrackFitter->fit(ctx,
          measurementSet,
          *origPerigee,
          m_runOutlier,
          m_ParticleHypothesis);
    }
    catch(const std::exception& e) {
      ATH_MSG_ERROR ("Refit Logic Error. No new track. Message: " << e.what());
      newtrack = nullptr;
    }
 
    ATH_MSG_DEBUG ("Track fit is done!");
 
    if (msgLvl(MSG::DEBUG)) {
      if (!newtrack) { ATH_MSG_DEBUG ("Refit Failed"); }
      else {
 
        ATH_MSG_VERBOSE ("re-fitted track:" << *newtrack);
        const Trk::Perigee* aMeasPer = newtrack->perigeeParameters();
        if (aMeasPer==nullptr){
          ATH_MSG_ERROR ("Could not get Trk::MeasuredPerigee");
        } else {
          double d0 = aMeasPer->parameters()[Trk::d0];
          double z0 = aMeasPer->parameters()[Trk::z0];
          double phi0 = aMeasPer->parameters()[Trk::phi0];
          double theta = aMeasPer->parameters()[Trk::theta];
          double qOverP = aMeasPer->parameters()[Trk::qOverP];
          ATH_MSG_DEBUG ("Refitted parameters differences "
              << (od0-d0)/od0  << " "
              << (oz0-z0)/oz0  << " "
              << (ophi0-phi0)/ophi0 << " "
              << (otheta-theta)/otheta << " "
              << (oqOverP-qOverP)/oqOverP );
        } // aMeasPer exists
      } // newtrack exists
    } // if debug
 
    if (newtrack) { newtracks.push_back(std::move(newtrack)); }
    else          { ATH_MSG_WARNING ("Refit Failed"); }
 
  } // loop over tracks
 
  ATH_MSG_VERBOSE ("Add PRDs to assoc tool.");
 
  // recreate the summaries on the final track collection with correct PRD tool
  for(const std::unique_ptr<Trk::Track> &new_track : newtracks ) {
    if((m_assoTool->addPRDs(*prd_to_track_map, *new_track)).isFailure()) {ATH_MSG_WARNING("Failed to add PRDs to map");}
  }
 
  ATH_MSG_VERBOSE ("Recalculate the summary");
  // and copy tracks from vector of non-const tracks to collection of const tracks
  std::unique_ptr<TrackCollection> new_track_collection = std::make_unique<TrackCollection>();
  new_track_collection->reserve(newtracks.size());
  for(std::unique_ptr<Trk::Track> &new_track : newtracks ) {
    m_trkSummaryTool->computeAndReplaceTrackSummary(ctx, *new_track, false /* DO NOT suppress hole search*/);
    new_track_collection->push_back(std::move(new_track));
  }
 
  ATH_MSG_VERBOSE ("Save tracks");
  ATH_CHECK(SG::WriteHandle<TrackCollection>(m_outputTrackCollectionName).record(std::move(new_track_collection)));
 
  ATH_MSG_INFO ("ReFitTrackWithTruth::execute() completed");
  return StatusCode::SUCCESS;
}

extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< Algorithm > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase & ExtraDeps )

protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

extraOutputDeps()

const DataObjIDColl & AthAlgorithm::extraOutputDeps ( ) const

overridevirtualinherited

Return the list of extra output dependencies.

This list is extended to include symlinks implied by inheritance relations.

Definition at line 50 of file AthAlgorithm.cxx.

{
  // If we didn't find any symlinks to add, just return the collection
  // from the base class.  Otherwise, return the extended collection.
  if (!m_extendedExtraObjects.empty()) {
    return m_extendedExtraObjects;
  }
  return Algorithm::extraOutputDeps();
}

getEtaPosErrorFactor()

double Trk::ReFitTrackWithTruth::getEtaPosErrorFactor ( int layer ) const

private

Definition at line 607 of file ReFitTrackWithTruth.cxx.

{ return m_errorZ[layer];    }

getEtaPosResolution()

double Trk::ReFitTrackWithTruth::getEtaPosResolution ( int layer ) const

private

Definition at line 604 of file ReFitTrackWithTruth.cxx.

{ return m_resolutionZ[layer];    }

getPhiPosErrorFactor()

double Trk::ReFitTrackWithTruth::getPhiPosErrorFactor ( int layer ) const

private

Definition at line 606 of file ReFitTrackWithTruth.cxx.

{ return m_errorRPhi[layer]; }

getPhiPosResolution()

double Trk::ReFitTrackWithTruth::getPhiPosResolution ( int layer ) const

private

Definition at line 603 of file ReFitTrackWithTruth.cxx.

{ return m_resolutionRPhi[layer]; }

initialize()

StatusCode Trk::ReFitTrackWithTruth::initialize ( )

overridevirtual

Definition at line 42 of file ReFitTrackWithTruth.cxx.

{
  ATH_MSG_INFO ("ReFitTrackWithTruth::initialize()");
 
  ATH_CHECK (m_siHitCollectionName.initialize());
  ATH_CHECK (m_SDOContainerName.initialize());
  ATH_CHECK (m_truthMapName.initialize());
 
  // get tracks
  ATH_CHECK( m_inputTrackColName.initialize() );
 
  if (m_ITrackFitter.retrieve().isFailure()) {
    ATH_MSG_FATAL ("Failed to retrieve tool "<<m_ITrackFitter.typeAndName());
    return StatusCode::FAILURE;
  } else {
    ATH_MSG_INFO ("Retrieved general fitter " << m_ITrackFitter.typeAndName());
  }
 
  if (m_trkSummaryTool.retrieve().isFailure()) {
    ATH_MSG_FATAL ("Failed to retrieve tool " << m_trkSummaryTool);
    return StatusCode::FAILURE;
  } else {
    ATH_MSG_INFO ("Retrieved tool " << m_trkSummaryTool.typeAndName());
  }
 
  // needed if want to check on shared clusters
  if ( m_assoTool.retrieve().isFailure() ) {
    ATH_MSG_FATAL ("Failed to retrieve tool " << m_assoTool);
    return StatusCode::FAILURE;
  } else ATH_MSG_INFO("Retrieved tool " << m_assoTool);
 
 
  // Configuration of the material effects
  m_ParticleHypothesis = Trk::ParticleSwitcher::particle[m_matEffects];
 
  // Get ID Helper
  ATH_CHECK(detStore()->retrieve(m_idHelper, "AtlasID"));
 
  // Get Pixel Helper
  if (detStore()->retrieve(m_pixelID, "PixelID").isFailure()) {
    ATH_MSG_FATAL ("Could not get Pixel ID helper");
    return StatusCode::FAILURE;
  }
 
  //set seed for random-number generator
  m_random->SetSeed();
 
  // ensure the vector is the correct size in case the user does not want to smear
  if( m_resolutionRPhi.size() < 4 ) { m_resolutionRPhi={0.,0.,0.,0.}; }
  if( m_resolutionZ.size() < 4 ) { m_resolutionZ={0.,0.,0.,0.}; }
 
  if( m_errorRPhi.size() < 4 ) { m_errorRPhi={1.,1.,1.,1.}; }
  if( m_errorZ.size() < 4 ) { m_errorZ={1.,1.,1.,1.}; }
 
  ATH_MSG_INFO (" Resolutions " << m_resolutionRPhi.size() << " " << m_resolutionZ.size());
  for( unsigned int i=0; i<m_resolutionRPhi.size(); i++) {
    ATH_MSG_INFO (" " << i << " " << m_resolutionRPhi[i] << "\t" << m_resolutionZ[i]);
  }
  ATH_MSG_INFO (" Error SR " << m_errorRPhi.size() << " " << m_errorZ.size());
  for( unsigned int i=0; i<m_errorRPhi.size(); i++) {
    ATH_MSG_INFO (" " << i << " " << m_errorRPhi[i] << "\t" << m_errorZ[i]);
  }
 
  ATH_CHECK(m_outputTrackCollectionName.initialize());
  ATH_MSG_DEBUG("m_outputTrackCollectionName: " << m_outputTrackCollectionName);
 
  return StatusCode::SUCCESS;
}

inputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< Algorithm > >::inputHandles ( ) const

overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

IsClusterFromTruth()

bool Trk::ReFitTrackWithTruth::IsClusterFromTruth ( const InDet::PixelCluster * pixClus, const int uniqueIdToMatch, const InDetSimDataCollection & sdoCollection )

staticprivate

Definition at line 537 of file ReFitTrackWithTruth.cxx.

                                                 {
 
  // Should be true for all pseudotracks
  // Can be false for reco tracks - misassigned hits
 
  bool match(false);
 
  // loop over reconstructed energy depoists in the cluster
  for( const auto &hitIdentifier : pixClus->rdoList() ) {
 
    // find the rdo in the sdo collection
    auto pos = sdoCollection.find(hitIdentifier);
    if( pos == sdoCollection.end() ) { continue; }
 
    // get the unique ID from each deposit
    for( const auto& deposit : pos->second.getdeposits() ){
      if( !deposit.first ){ continue; } // if truthparticle(?) link doesn't exists? Energy deposit is still known
      if( HepMC::uniqueID(&(deposit.first)) != uniqueIdToMatch ) { continue; }
      match = true;
      break;
    }
    if(match) { break; }
  }
 
  return match;
}

matchSiHitsToCluster()

std::vector< SiHit > Trk::ReFitTrackWithTruth::matchSiHitsToCluster ( const int uniqueIdToMatch, const InDet::PixelCluster * pixClus, SG::ReadHandle< AtlasHitsVector< SiHit > > & siHitCollection ) const

private

Definition at line 404 of file ReFitTrackWithTruth.cxx.

                                                                 {
 
  // passing a negative unique ID value skip this requirement - can get multiple SiHits upon return from different particles
 
  ATH_MSG_VERBOSE( " Have " << (*siHitCollection).size() << " SiHits to look through" );
  std::vector<SiHit>  matchingHits;
 
  // Check if we have detector element  --  needed to find the local position of the SiHits
  const InDetDD::SiDetectorElement* de = pixClus->detectorElement();
  if(!de) {
    ATH_MSG_WARNING("Do not have detector element to find the local position of SiHits!");
    return matchingHits;
  }
 
  // To locate cluster module
  Identifier clusterId = pixClus->identify();
 
  std::vector<const SiHit* >  multiMatchingHits;
 
  // match SiHits to unique ID and make sure in same module as reco hit
  for ( const auto&  siHit : *siHitCollection) {
 
    if ( uniqueIdToMatch > 0 ) { // negative uniqueIdToMatch will keep all
      if ( HepMC::uniqueID(&(siHit.particleLink())) != uniqueIdToMatch ) { continue; }
    }
 
    // Check if it is a Pixel hit
    if( !siHit.isPixel() ) { continue; }
 
    // Match to the cluster module
    if( m_pixelID->barrel_ec(clusterId) != siHit.getBarrelEndcap() ) { continue; }
    if( m_pixelID->layer_disk(clusterId)!= siHit.getLayerDisk() )    { continue; }
    if( m_pixelID->phi_module(clusterId)!= siHit.getPhiModule() )    { continue; }
    if( m_pixelID->eta_module(clusterId)!= siHit.getEtaModule() )    { continue; }
 
    // Have SiHits in the same module as the cluster at this point
    ATH_MSG_DEBUG("Hit is on the same module");
    multiMatchingHits.push_back(&siHit);
 
  } // loop over SiHitCollection
 
 
  //Now we will now make 1 SiHit for each true particle if the SiHits "touch" other
  std::vector<const SiHit* >::iterator siHitIter  = multiMatchingHits.begin();
  std::vector<const SiHit* >::iterator siHitIter2 = multiMatchingHits.begin();
  ATH_MSG_DEBUG( "Found " << multiMatchingHits.size() << " SiHit " );
 
  // double loop - for each matching SiHit, consider all the SiHits _next_ in the collection
  // to see if they overlap.
  // if overlapping, combine and only consider new merged hits
  for ( ; siHitIter != multiMatchingHits.end(); ++siHitIter) {
    const SiHit* lowestXPos  = *siHitIter;
    const SiHit* highestXPos = *siHitIter;
 
 
    // We will merge these hits
    std::vector<const SiHit* > ajoiningHits;
    ajoiningHits.push_back( *siHitIter );
 
    siHitIter2 = siHitIter+1;
    while ( siHitIter2 != multiMatchingHits.end() ) {
      // Need to come from the same truth particle
 
      // wasn't the unique ID match already done!?
      if ( HepMC::uniqueID(&((*siHitIter)->particleLink())) != HepMC::uniqueID(&((*siHitIter2)->particleLink()))) {
        ++siHitIter2;
        continue;
      }
 
      // Check to see if the SiHits are compatible with each other.
      if (std::abs((highestXPos->localEndPosition().x()-(*siHitIter2)->localStartPosition().x()))<0.00005 &&
          std::abs((highestXPos->localEndPosition().y()-(*siHitIter2)->localStartPosition().y()))<0.00005 &&
          std::abs((highestXPos->localEndPosition().z()-(*siHitIter2)->localStartPosition().z()))<0.00005 )
      {
        highestXPos = *siHitIter2;
        ajoiningHits.push_back( *siHitIter2 );
        // Dont use hit  more than once
        siHitIter2 = multiMatchingHits.erase( siHitIter2 );
        //--siHitIter2; // maybe
      }else if (std::abs((lowestXPos->localStartPosition().x()-(*siHitIter2)->localEndPosition().x()))<0.00005 &&
          std::abs((lowestXPos->localStartPosition().y()-(*siHitIter2)->localEndPosition().y()))<0.00005 &&
          std::abs((lowestXPos->localStartPosition().z()-(*siHitIter2)->localEndPosition().z()))<0.00005)
      {
        lowestXPos = *siHitIter2;
        ajoiningHits.push_back( *siHitIter2 );
        // Dont use hit  more than once
        siHitIter2 = multiMatchingHits.erase( siHitIter2 );
       // --siHitIter2; // maybe
      } else {
        ++siHitIter2;
      }
    } // loop over matching SiHits to see if any overlap
 
    if( ajoiningHits.empty()){
      ATH_MSG_WARNING("This should really never happen");
      continue;
    }
    if(ajoiningHits.size() == 1){
      // Copy Si Hit ready to return
      matchingHits.push_back( *ajoiningHits[0] );
      continue;
    }
    //  Build new SiHit and merge information together.
    ATH_MSG_DEBUG("Merging " << ajoiningHits.size() << " SiHits together." );
 
 
    float energyDep(0);
    float time(0);
    for( auto& siHit :  ajoiningHits){
      energyDep += siHit->energyLoss();
      time += siHit->meanTime();
    }
    time /= (float)ajoiningHits.size();
 
    matchingHits.emplace_back(lowestXPos->localStartPosition(),
                              highestXPos->localEndPosition(),
                              energyDep,
                              time,
                              HepMC::uniqueID(&((*siHitIter)->particleLink())),
                              0, // 0 for pixel 1 for Pixel
                              (*siHitIter)->getBarrelEndcap(),
                              (*siHitIter)->getLayerDisk(),
                              (*siHitIter)->getEtaModule(),
                              (*siHitIter)->getPhiModule(),
                              (*siHitIter)->getSide() );
    ATH_MSG_DEBUG("Finished Merging " << ajoiningHits.size() << " SiHits together." );
  } // loop over all matching SiHits
 
  return matchingHits;
}

msg()

MsgStream & AthCommonMsg< Algorithm >::msg ( ) const

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msgLvl()

bool AthCommonMsg< Algorithm >::msgLvl ( const MSG::Level lvl ) const

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

outputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< Algorithm > >::outputHandles ( ) const

overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

renounce()

std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > AthCommonDataStore< AthCommonMsg< Algorithm > >::renounce ( T & h )

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

  {
    h.renounce();
    PBASE::renounce (h);
  }

renounceArray()

void AthCommonDataStore< AthCommonMsg< Algorithm > >::renounceArray ( SG::VarHandleKeyArray & handlesArray )

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

smearTruthPosition()

HepGeom::Point3D< double > Trk::ReFitTrackWithTruth::smearTruthPosition ( const HepGeom::Point3D< double > & orig, const int bec, const int layer_disk, const InDetDD::SiDetectorDesign * design ) const

private

Definition at line 566 of file ReFitTrackWithTruth.cxx.

                                                 {
 
  HepGeom::Point3D<double> smeared(0,0,0);
 
  smeared.setX(orig.x());
 
  if (bec == 0) {
    double smearLocY = m_random->Gaus(0, getPhiPosResolution(layer_disk));
    double smearLocZ = m_random->Gaus(0, getEtaPosResolution(layer_disk));
    smeared.setY(orig.y() + smearLocY);
    smeared.setZ(orig.z() + smearLocZ);
 
  } else {
 
    smeared.setY(orig.y());
    smeared.setZ(orig.z());
  }
 
  //check for module boundaries
  if (smeared.y()>design->width()/2) {
    smeared.setY(design->width()/2-1e-6);
  } else if (smeared.y()<-design->width()/2) {
    smeared.setY(-design->width()/2+1e-6);
  }
  if (smeared.z()>design->length()/2) {
    smeared.setZ(design->length()/2-1e-6);
  } else if (smeared.z()<-design->length()/2) {
    smeared.setZ(-design->width()/2+1e-6);
  }
 
 
  return smeared;
}

sysInitialize()

StatusCode AthAlgorithm::sysInitialize ( )

overridevirtualinherited

Override sysInitialize.

Override sysInitialize from the base class.

Loop through all output handles, and if they're WriteCondHandles, automatically register them and this Algorithm with the CondSvc

Scan through all outputHandles, and if they're WriteCondHandles, register them with the CondSvc

Reimplemented from AthCommonDataStore< AthCommonMsg< Algorithm > >.

Reimplemented in AthAnalysisAlgorithm, AthFilterAlgorithm, AthHistogramAlgorithm, and PyAthena::Alg.

Definition at line 66 of file AthAlgorithm.cxx.

                                       {
  StatusCode sc=AthCommonDataStore<AthCommonMsg<Algorithm>>::sysInitialize();
 
  if (sc.isFailure()) {
    return sc;
  }
  ServiceHandle<ICondSvc> cs("CondSvc",name());
  for (auto h : outputHandles()) {
    if (h->isCondition() && h->mode() == Gaudi::DataHandle::Writer) {
      // do this inside the loop so we don't create the CondSvc until needed
      if ( cs.retrieve().isFailure() ) {
        ATH_MSG_WARNING("no CondSvc found: won't autoreg WriteCondHandles");
        return StatusCode::SUCCESS;
      }
      if (cs->regHandle(this,*h).isFailure()) {
        sc = StatusCode::FAILURE;
        ATH_MSG_ERROR("unable to register WriteCondHandle " << h->fullKey()
                      << " with CondSvc");
      }
    }
  }
  return sc;
}

sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< Algorithm > >::sysStart ( )

overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

updateVHKA()

void AthCommonDataStore< AthCommonMsg< Algorithm > >::updateVHKA ( Gaudi::Details::PropertyBase & )

inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

                                               {
    // debug() << "updateVHKA for property " << p.name() << " " << p.toString() 
    //         << "  size: " << m_vhka.size() << endmsg;
    for (auto &a : m_vhka) {
      std::vector<SG::VarHandleKey*> keys = a->keys();
      for (auto k : keys) {
        k->setOwner(this);
      }
    }
  }

Member Data Documentation

m_assoTool

ToolHandle<Trk::IPRDtoTrackMapTool> Trk::ReFitTrackWithTruth::m_assoTool {this, "AssociationTool", "Trk::PRDtoTrackMapTool" }

private

Tool to create and populate PRD to track.

Definition at line 119 of file ReFitTrackWithTruth.h.

{this, "AssociationTool", "Trk::PRDtoTrackMapTool" };              

m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Algorithm > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

m_errorRPhi

Gaudi::Property<std::vector<float> > Trk::ReFitTrackWithTruth::m_errorRPhi {this, "ErrorFactorRPhi", {}}

private

Definition at line 111 of file ReFitTrackWithTruth.h.

{this, "ErrorFactorRPhi", {}};              // per-layer error - multiplicative factor * res.

m_errorZ

Gaudi::Property<std::vector<float> > Trk::ReFitTrackWithTruth::m_errorZ {this, "ErrorFactorZ", {}}

private

Definition at line 112 of file ReFitTrackWithTruth.h.

{this, "ErrorFactorZ", {}};                     // per-layer error - multiplicative factor * res.

m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Algorithm > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

m_extendedExtraObjects

DataObjIDColl AthAlgorithm::m_extendedExtraObjects

privateinherited

Definition at line 79 of file AthAlgorithm.h.

m_fixWrongHits

Gaudi::Property<bool> Trk::ReFitTrackWithTruth::m_fixWrongHits {this, "FixWrongHits", false}

private

Definition at line 98 of file ReFitTrackWithTruth.h.

{this, "FixWrongHits", false};                                  // If running on Reco Tracks, fix wrong hits

m_idHelper

const AtlasDetectorID* Trk::ReFitTrackWithTruth::m_idHelper = nullptr

private

Detector ID helper.

Definition at line 121 of file ReFitTrackWithTruth.h.

m_inputTrackColName

SG::ReadHandleKey<TrackCollection> Trk::ReFitTrackWithTruth::m_inputTrackColName {this,"InputTrackColName","","collection name for tracks to be refitted"}

private

Definition at line 87 of file ReFitTrackWithTruth.h.

{this,"InputTrackColName","","collection name for tracks to be refitted"};      // Name of the input Trackcollection

m_ITrackFitter

ToolHandle<Trk::ITrackFitter> Trk::ReFitTrackWithTruth::m_ITrackFitter {this, "FitterTool", "Trk::GlobalChi2Fitter/InDetTrackFitter" }

private

the refit tool

Definition at line 115 of file ReFitTrackWithTruth.h.

{this, "FitterTool", "Trk::GlobalChi2Fitter/InDetTrackFitter" };            

m_matEffects

int Trk::ReFitTrackWithTruth::m_matEffects = 3

private

Definition at line 95 of file ReFitTrackWithTruth.h.

m_outputTrackCollectionName

SG::WriteHandleKey<TrackCollection> Trk::ReFitTrackWithTruth::m_outputTrackCollectionName {this,"OutputTrackColName","ReFitted_TracksWithTruth","collection name for output tracks"}

private

Definition at line 88 of file ReFitTrackWithTruth.h.

{this,"OutputTrackColName","ReFitted_TracksWithTruth","collection name for output tracks"};

m_ParticleHypothesis

Trk::ParticleHypothesis Trk::ReFitTrackWithTruth::m_ParticleHypothesis = Trk::pion

private

Definition at line 101 of file ReFitTrackWithTruth.h.

m_pixelID

const PixelID* Trk::ReFitTrackWithTruth::m_pixelID = nullptr

private

Pixel ID.

Definition at line 122 of file ReFitTrackWithTruth.h.

m_random

boost::thread_specific_ptr<TRandom3> Trk::ReFitTrackWithTruth::m_random

private

smear away!

Definition at line 91 of file ReFitTrackWithTruth.h.

m_rejNoiseHits

Gaudi::Property<bool> Trk::ReFitTrackWithTruth::m_rejNoiseHits {this, "RejectNoiseHits", false}

private

Definition at line 99 of file ReFitTrackWithTruth.h.

{this, "RejectNoiseHits", false};                                   // If running on Reco Tracks, can have noise hits

m_resolutionRPhi

Gaudi::Property<std::vector<float> > Trk::ReFitTrackWithTruth::m_resolutionRPhi {this, "ResolutionRPhi", {}}

private

Definition at line 109 of file ReFitTrackWithTruth.h.

{this, "ResolutionRPhi", {}};               // per-layer resolution

m_resolutionZ

Gaudi::Property<std::vector<float> > Trk::ReFitTrackWithTruth::m_resolutionZ {this, "ResolutionZ", {}}

private

Definition at line 110 of file ReFitTrackWithTruth.h.

{this, "ResolutionZ", {}};                  // per-layer resolution

m_runOutlier

Trk::RunOutlierRemoval Trk::ReFitTrackWithTruth::m_runOutlier = false

private

Definition at line 94 of file ReFitTrackWithTruth.h.

m_saveWrongHits

Gaudi::Property<bool> Trk::ReFitTrackWithTruth::m_saveWrongHits {this, "SaveWrongHits", false}

private

Definition at line 97 of file ReFitTrackWithTruth.h.

{this, "SaveWrongHits", false};                                     // If running on Reco Tracks, can have wrong hits

m_SDOContainerName

SG::ReadHandleKey<InDetSimDataCollection> Trk::ReFitTrackWithTruth::m_SDOContainerName {this,"MC_SDOs","PixelSDO_Map"}

private

Definition at line 105 of file ReFitTrackWithTruth.h.

{this,"MC_SDOs","PixelSDO_Map"};                        // SDO Container storegate key  

m_siHitCollectionName

SG::ReadHandleKey<SiHitCollection> Trk::ReFitTrackWithTruth::m_siHitCollectionName {this,"SiHitCollectionName","PixelHits",""}

private

Definition at line 104 of file ReFitTrackWithTruth.h.

{this,"SiHitCollectionName","PixelHits",""};            // SiHitCollection storegate key  

m_trkSummaryTool

ToolHandle<Trk::IExtendedTrackSummaryTool> Trk::ReFitTrackWithTruth::m_trkSummaryTool {this, "SummaryTool", "Trk::TrackSummaryTool/InDetTrackSummaryTool" }

private

the track summary tool

Definition at line 117 of file ReFitTrackWithTruth.h.

{this, "SummaryTool", "Trk::TrackSummaryTool/InDetTrackSummaryTool" };      

m_truthMapName

SG::ReadHandleKey<TrackTruthCollection> Trk::ReFitTrackWithTruth::m_truthMapName {this,"TruthMap","InDetTracksTruthCollection"}

private

Definition at line 106 of file ReFitTrackWithTruth.h.

{this,"TruthMap","InDetTracksTruthCollection"};             // TruthMap name storegate key

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< Algorithm > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< Algorithm > >::m_vhka

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

---

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

• ReFitTrackWithTruth.h
• ReFitTrackWithTruth.cxx