ITk::TrackClusterAssValidation Class Reference

#include <ITkTrackClusterAssValidation.h>

Inheritance diagram for ITk::TrackClusterAssValidation:

Classes
struct	EventData_t

Public Member Functions
	TrackClusterAssValidation (const std::string &name, ISvcLocator *pSvcLocator)
virtual	~TrackClusterAssValidation ()
StatusCode	initialize ()
StatusCode	execute (const EventContext &ctx) const
StatusCode	finalize ()
virtual StatusCode	sysInitialize () override
	Override sysInitialize.
virtual bool	isClonable () const override
	Specify if the algorithm is clonable.
virtual unsigned int	cardinality () const override
	Cardinality (Maximum number of clones that can exist) special value 0 means that algorithm is reentrant.
virtual StatusCode	sysExecute (const EventContext &ctx) override
	Execute an algorithm.
virtual const DataObjIDColl &	extraOutputDeps () const override
	Return the list of extra output dependencies.
virtual bool	filterPassed (const EventContext &ctx) const
virtual void	setFilterPassed (bool state, const EventContext &ctx) const
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	newSpacePointsEvent (const EventContext &ctx, ITk::TrackClusterAssValidation::EventData_t &event_data) const
void	newClustersEvent (const EventContext &ctx, ITk::TrackClusterAssValidation::EventData_t &event_data) const
void	tracksComparison (const EventContext &ctx, ITk::TrackClusterAssValidation::EventData_t &event_data) const
void	efficiencyReconstruction (ITk::TrackClusterAssValidation::EventData_t &event_data) const
bool	noReconstructedParticles (const ITk::TrackClusterAssValidation::EventData_t &event_data) const
int	qualityTracksSelection (ITk::TrackClusterAssValidation::EventData_t &event_data) const
int	kine (const ITk::TrackClusterAssValidation::EventData_t &event_data, const Trk::PrepRawData *, const Trk::PrepRawData *, int *, int) const
int	kine (const ITk::TrackClusterAssValidation::EventData_t &event_data, const Trk::PrepRawData *, int *, int) const
int	charge (const ITk::TrackClusterAssValidation::EventData_t &event_data, std::pair< int, const Trk::PrepRawData * >, int &, double &) const
int	charge (const ITk::TrackClusterAssValidation::EventData_t &event_data, std::pair< int, const Trk::PrepRawData * > pa, int &rap) const
float	minpT (float eta) const
unsigned int	minclusters (float eta) const
MsgStream &	dumptools (MsgStream &out, MSG::Level level) const
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.

Static Protected Member Functions
static int	kine0 (const ITk::TrackClusterAssValidation::EventData_t &event_data, const Trk::PrepRawData *, int *, int)
static bool	isTruth (const ITk::TrackClusterAssValidation::EventData_t &, const Trk::PrepRawData *)
static bool	isTheSameDetElement (const ITk::TrackClusterAssValidation::EventData_t &event_data, int, const Trk::PrepRawData *)
static bool	isTheSameDetElement (const ITk::TrackClusterAssValidation::EventData_t &event_data, int, const Trk::SpacePoint *)
static PRD_MultiTruthCollection::const_iterator	findTruth (const ITk::TrackClusterAssValidation::EventData_t &event_data, const Trk::PrepRawData *, PRD_MultiTruthCollection::const_iterator &)
static MsgStream &	dumpevent (MsgStream &out, const ITk::TrackClusterAssValidation::EventData_t &event_data)

Protected Attributes
BooleanProperty	m_usePix {this, "usePixel", true}
BooleanProperty	m_useStrip {this, "useStrip", true}
BooleanProperty	m_useOutliers {this, "useOutliers", false}
IntegerProperty	m_pdg {this, "pdgParticle", 0}
std::mutex	m_statMutex
std::vector< InDet::TrackCollectionStat_t > m_trackCollectionStat	ATLAS_THREAD_SAFE
InDet::EventStat_t m_eventStat	ATLAS_THREAD_SAFE
UnsignedIntegerProperty	m_spcut {this, "MinNumberSpacePoints", 3}
FloatProperty	m_ptcutmax {this, "MomentumMaxCut", 1.e20}
FloatProperty	m_rapcut {this, "RapidityCut", 4.0}
FloatProperty	m_ptcut {this, "MomentumCut", {}}
FloatProperty	m_rmin {this, "RadiusMin", 0.}
FloatProperty	m_rmax {this, "RadiusMax", 20.}
FloatArrayProperty	m_etabins {this, "EtaBins", {}}
FloatArrayProperty	m_ptcuts {this, "PtCuts", {}}
UnsignedIntegerArrayProperty	m_clcuts {this, "MinNumberClustersCuts", {}}
float	m_tcut = 0
SG::ReadHandleKeyArray< TrackCollection >	m_tracklocation {this, "TracksLocation", {"CombinedITkTracks"}}
SG::ReadHandleKey< SpacePointContainer >	m_spacepointsStripname {this, "SpacePointsStripName", "ITkStripSpacePoints"}
SG::ReadHandleKey< SpacePointContainer >	m_spacepointsPixelname {this, "SpacePointsPixelName", "ITkPixelSpacePoints"}
SG::ReadHandleKey< SpacePointOverlapCollection >	m_spacepointsOverlapname {this, "SpacePointsOverlapName", "ITkOverlapSpacePoints"}
SG::ReadHandleKey< InDet::SiClusterContainer >	m_clustersStripname {this, "StripClusterContainer", "ITkStripClusters"}
SG::ReadHandleKey< InDet::SiClusterContainer >	m_clustersPixelname {this, "PixelClusterContainer", "ITkPixelClusters"}
SG::ReadHandleKey< PRD_MultiTruthCollection >	m_truth_locationPixel {this, "TruthLocationPixel", "PRD_MultiTruthITkPixel"}
SG::ReadHandleKey< PRD_MultiTruthCollection >	m_truth_locationStrip {this, "TruthLocationStrip", "PRD_MultiTruthITkStrip"}
SG::ReadCondHandleKey< InDetDD::SiDetectorElementCollection >	m_pixelDetEleCollKey {this, "PixelDetEleCollKey", "ITkPixelDetectorElementCollection", "Key of SiDetectorElementCollection for Pixel"}
SG::ReadCondHandleKey< InDetDD::SiDetectorElementCollection >	m_StripDetEleCollKey {this, "StripDetEleCollKey", "ITkStripDetectorElementCollection", "Key of SiDetectorElementCollection for Strip"}

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
DataObjIDColl	m_extendedExtraObjects
	Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks.
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

Definition at line 27 of file ITkTrackClusterAssValidation.h.

Member Typedef Documentation

StoreGateSvc_t

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

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

TrackClusterAssValidation()

ITk::TrackClusterAssValidation::TrackClusterAssValidation	(	const std::string &	name,
		ISvcLocator *	pSvcLocator )

Definition at line 23 of file ITkTrackClusterAssValidation.cxx.

  : AthReentrantAlgorithm(name,pSvcLocator)
{
}

~TrackClusterAssValidation()

ITk::TrackClusterAssValidation::~TrackClusterAssValidation ( )

virtualdefault

Member Function Documentation

cardinality()

unsigned int AthCommonReentrantAlgorithm< Gaudi::Algorithm >::cardinality ( ) const

overridevirtualinherited

Cardinality (Maximum number of clones that can exist) special value 0 means that algorithm is reentrant.

Override this to return 0 for reentrant algorithms.

Definition at line 75 of file AthCommonReentrantAlgorithm.cxx.

{
  return 0;
}

charge() [1/2]

int ITk::TrackClusterAssValidation::charge ( const ITk::TrackClusterAssValidation::EventData_t & event_data, std::pair< int, const Trk::PrepRawData * > pa, int & rap ) const

inlineprotected

Definition at line 180 of file ITkTrackClusterAssValidation.h.

      { double eta; return charge(event_data, pa, rap, eta); };

charge() [2/2]

int ITk::TrackClusterAssValidation::charge ( const ITk::TrackClusterAssValidation::EventData_t & event_data, std::pair< int, const Trk::PrepRawData * > pa, int & rap, double & eta ) const

protected

Definition at line 1392 of file ITkTrackClusterAssValidation.cxx.

{
  int                     uniqueID = pa.first;
  const Trk::PrepRawData* d = pa.second;
  PRD_MultiTruthCollection::const_iterator mce;
  PRD_MultiTruthCollection::const_iterator mc = findTruth(event_data,d,mce);
 
  for(; mc!=mce; ++mc) {
    if(HepMC::uniqueID((*mc).second)==uniqueID) {
 
      const HepMC::ConstGenParticlePtr   pat  = (*mc).second.cptr();
 
      rap       = 0;
      double px =  pat->momentum().px();
      double py =  pat->momentum().py();
      double pz =  pat->momentum().pz();
      double pt = std::sqrt(px*px+py*py)   ;
      double t  = std::atan2(pt,pz)        ;
      eta = std::abs(std::log(std::tan(.5*t)));
      // Forward
      if (eta > 3.0)
    rap = 3;
      else
      // other regions
    eta > 1.6 ? rap = 2 : eta > .8 ?  rap = 1 : rap = 0;
 
      int                         pdg = pat->pdg_id();
      if (MC::isNucleus(pdg)) continue; // ignore nuclei from hadronic interactions
      double ch = MC::charge(pdg);
      if(ch >  .5) return  1;
      if(ch < -.5) return -1;
      return 0;
    }
  }
  return 0;
}

declareGaudiProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< Gaudi::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< Gaudi::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< Gaudi::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; }

dumpevent()

MsgStream & ITk::TrackClusterAssValidation::dumpevent ( MsgStream & out, const ITk::TrackClusterAssValidation::EventData_t & event_data )

staticprotected

Definition at line 647 of file ITkTrackClusterAssValidation.cxx.

{
  out << MSG::DEBUG << "\n";
  auto formatOutput = [&out](const auto val){
    out<<std::setw(12)<<val
     <<"                              |\n";
  };
  out<<"|---------------------------------------------------------------------|\n";
  out<<"| m_nspacepoints          | ";
  formatOutput(event_data.m_nspacepoints);
  out<<"| m_nclusters             | ";
  formatOutput(event_data.m_nclusters);
  out<<"| Kine-Clusters    size   | ";
  formatOutput(event_data.m_kinecluster.size());
  out<<"| Kine-SpacePoints size   | ";
  formatOutput(event_data.m_kinespacepoint.size());
  out<<"| Number good kine tracks | ";
  formatOutput(event_data.m_nqtracks);
  out<<"|---------------------------------------------------------------------|\n";
  return out;
}

dumptools()

MsgStream & ITk::TrackClusterAssValidation::dumptools ( MsgStream & out, MSG::Level level ) const

protected

Definition at line 592 of file ITkTrackClusterAssValidation.cxx.

{
  SG::ReadHandleKeyArray<TrackCollection>::const_iterator t=m_tracklocation.begin(),te=m_tracklocation.end();
 
  int n;
  out << level <<"\n";
  out<<"|--------------------------------------------------------------------------------------------------------------------|\n";
  for(; t!=te; ++t) {
    n     = 65-t->key().size();
    std::string s1; for(int i=0; i<n; ++i) s1.append(" "); s1.append("|");
    out<<"| Location of input tracks                        | "<<t->key()<<s1<<"\n";
  }
  auto padString = [](const std::string & s){
   const int n = 65 - s.size();
   return s + std::string(n, ' ');
  };
  std::string s2 = padString(m_spacepointsPixelname.key());
  std::string s3 = padString(m_spacepointsStripname.key());
  std::string s4 = padString(m_spacepointsOverlapname.key());
  std::string s5 = padString(m_clustersPixelname.key());
  std::string s6 = padString(m_clustersStripname.key());
  //
  std::string s7 = padString(m_truth_locationPixel.key());
  std::string s8 = padString(m_truth_locationStrip.key());
 
  out<<"| Pixel    space points                           | "<<s2<<"|\n";
  out<<"| Strip      space points                         | "<<s3<<"|\n";
  out<<"| Overlap  space points                           | "<<s4<<"|\n";
  out<<"| Pixel    clusters                               | "<<s5<<"|\n";
  out<<"| Strip      clusters                             | "<<s6<<"|\n";
  out<<"| Truth location  for pixels                      | "<<s7<<"|\n";
  out<<"| Truth location  for strips                      | "<<s8<<"|\n";
  out<<"|   max   pT cut                                  | "
     <<std::setw(14)<<std::setprecision(5)<<m_ptcutmax
     <<"                                                   |\n";
  out<<"|   rapidity cut                                  | "
     <<std::setw(14)<<std::setprecision(5)<<m_rapcut
     <<"                                                   |\n";
  out<<"| min Radius                                      | "
     <<std::setw(14)<<std::setprecision(5)<<m_rmin
     <<"                                                   |\n";
  out<<"| max Radius                                      | "
     <<std::setw(14)<<std::setprecision(5)<<m_rmax
     <<"                                                   |\n";
  out<<"| Min. number sp.points     for generated track   | "
     <<std::setw(14)<<std::setprecision(5)<<m_spcut
     <<"                                                   |\n";
  out<<"|--------------------------------------------------------------------------------------------------------------------|\n";
  return out;
}

efficiencyReconstruction()

void ITk::TrackClusterAssValidation::efficiencyReconstruction ( ITk::TrackClusterAssValidation::EventData_t & event_data ) const

protected

Definition at line 1070 of file ITkTrackClusterAssValidation.cxx.

{
  for(SG::ReadHandleKeyArray<TrackCollection>::size_type nc = 0; nc!=m_tracklocation.size(); ++nc) {
 
    event_data.m_difference[nc].clear();
    auto p = event_data.m_particles[nc].begin(), pe =event_data.m_particles[nc].end();
    if(p==pe) return;
    std::multimap<int,int>::const_iterator t, te = event_data.m_tracks[nc].end();
 
    while (p!=pe) {
 
      const int uniqueID = HepMC::uniqueID(*p);
      int n = event_data.m_kinecluster.count(uniqueID);
      int m = 0;
      int w = 0;
      t = event_data.m_tracks[nc].find(uniqueID);
      for(; t!=te; ++t) {
    if((*t).first!=uniqueID) break;
    int ts = (*t).second/1000;
    int ws = (*t).second%1000;
    if     (ts > m         ) {m = ts; w = ws;}
    else if(ts==m && w > ws) {        w = ws;}
      }
      int d = n-m; if(d<0) d = 0; else if(d > 5) d=5; if(w>4) w = 4;
      if(m) {
    ++event_data.m_trackCollectionStat[nc].m_efficiency [d];
    ++event_data.m_trackCollectionStat[nc].m_efficiencyN[d][w];
      }
      int ch = (*p).charge();
      if(m) {
    ++event_data.m_trackCollectionStat[nc].m_efficiencyBTE[d][w][(*p).rapidity()];
    ch > 0 ? ++event_data.m_trackCollectionStat[nc].m_efficiencyPOS[d] : ++event_data.m_trackCollectionStat[nc].m_efficiencyNEG[d];
      }
      if(nc==0) {
    ++event_data.m_eventStat.m_events; ch > 0 ? ++event_data.m_eventStat.m_eventsPOS : ++event_data.m_eventStat.m_eventsNEG;
    ++event_data.m_eventStat.m_eventsBTE[(*p).rapidity()];
      }
      if(d==0) event_data.m_particles[nc].erase(p++);
      else {event_data.m_difference[nc].push_back(n-m);  ++p;}
    }
  }
}

evtStore()

ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< Gaudi::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 ITk::TrackClusterAssValidation::execute

(

const EventContext &

ctx

)

const

Definition at line 90 of file ITkTrackClusterAssValidation.cxx.

{
 
  if(!m_usePix && !m_useStrip) return StatusCode::SUCCESS;
  EventData_t event_data(m_tracklocation.size() );
 
  std::vector<SG::ReadHandle<PRD_MultiTruthCollection> > read_handle;
  read_handle.reserve(3);
  if(m_usePix) {
    read_handle.emplace_back(m_truth_locationPixel,ctx);
    if (not read_handle.back().isValid()) {
      ATH_MSG_FATAL( "Could not find TruthPix" );
      return StatusCode::FAILURE;
    }
    event_data.m_truthPix = &(*read_handle.back());
  }
 
  if(m_useStrip) {
    read_handle.emplace_back(m_truth_locationStrip,ctx);
    if (not read_handle.back().isValid()) {
      ATH_MSG_FATAL( "Could not find TruthStrip" );
      return StatusCode::FAILURE;
    }
    event_data.m_truthStrip = &(*read_handle.back());
  }
 
  newClustersEvent      (ctx,event_data);
  newSpacePointsEvent   (ctx,event_data);
  event_data.m_nqtracks = qualityTracksSelection(event_data);
  tracksComparison      (ctx,event_data);
  if(!event_data.m_particles[0].empty()) {
 
    efficiencyReconstruction(event_data);
    if(msgLvl(MSG::DEBUG)) noReconstructedParticles(event_data);
 
  }
 
  {
    std::lock_guard<std::mutex> lock(m_statMutex);
    assert( event_data.m_trackCollectionStat.size() == m_trackCollectionStat.size());
    for (unsigned int i=0; i< m_trackCollectionStat.size(); ++i ) {
      m_trackCollectionStat[i] += event_data.m_trackCollectionStat[i];
    }
    m_eventStat += event_data.m_eventStat;
  }
 
  if (msgLvl(MSG::DEBUG)) {
    dumpevent(msg(),event_data);
    msg() << endmsg;
  }
  return StatusCode::SUCCESS;
}

extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< Gaudi::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 & AthCommonReentrantAlgorithm< Gaudi::Algorithm >::extraOutputDeps ( ) const

overridevirtualinherited

Return the list of extra output dependencies.

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

Definition at line 94 of file AthCommonReentrantAlgorithm.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 BaseAlg::extraOutputDeps();
}

filterPassed()

virtual bool AthCommonReentrantAlgorithm< Gaudi::Algorithm >::filterPassed ( const EventContext & ctx ) const

inlinevirtualinherited

Definition at line 96 of file AthCommonReentrantAlgorithm.h.

                                                           {
    return execState( ctx ).filterPassed();
  }

finalize()

StatusCode ITk::TrackClusterAssValidation::finalize

(

)

Definition at line 147 of file ITkTrackClusterAssValidation.cxx.

                                                  {
  if(m_eventStat.m_events<=0) return StatusCode::SUCCESS;
  const auto & w13 = std::setw(13);
  const auto & p5 = std::setprecision(5);
  const auto topNtail=[](const std::string & str){return "|" + str + "|";};
  const std::string lineSeparator(83,'-');
  const std::string spaceSeparator(83,' ');
  std::stringstream out;
  out<<std::fixed;
  out<<topNtail(lineSeparator)<<"\n";
  out<<"|        TrackClusterAssValidation statistic for charge truth particles with        |\n";
  out<<topNtail(spaceSeparator)<<"\n";
 
  out<<"|        eta bins for eta dependent variables = [0.0, ";
  for (unsigned int etabin = 1; etabin<(m_etabins.size()-1); etabin++)
    out << std::setw(2) << std::setprecision(1) << m_etabins.value().at(etabin) << ", ";
  out << std::setw(2) << m_etabins.value().back() << "]                |\n";
  out<<"|                    eta dependent pT [MeV]  >= [";
  for (unsigned int ptbin = 0; ptbin<(m_ptcuts.size()-1); ptbin++)
    out<<std::setw(6)<<std::setprecision(2)<<m_ptcuts.value().at(ptbin)<<", ";
  out<<std::setw(6)<<std::setprecision(2)<<m_ptcuts.value().back()<<"]            |\n";
  if(m_ptcutmax < 1000000.) {
    out<<"|                    pT                      <="<<w13<<p5<<m_ptcutmax<<" MeV"<<"                    |\n";
  }
  out<<"|                    |rapidity|              <="<<w13<<p5<<m_rapcut<<"                        |\n";
  out<<"|                    max vertex radius       <="<<w13<<p5<<m_rmax<<" mm"<<"                     |\n";
  out<<"|                    min vertex radius       >="<<w13<<p5<<m_rmin<<" mm"<<"                     |\n";
  out<<"|                    particles pdg            ="<<std::setw(8)<<m_pdg<<"                             |\n";
  
  auto yesNo=[](const bool predicate){return predicate ? "yes" : "no ";};
  out<<"|                    use Pixels information          "<<yesNo(m_usePix)<<"                            |\n";
  out<<"|                    use Strip  information          "<<yesNo(m_useStrip)<<"                            |\n";
  out<<"|                    take into account outliers      "<<yesNo(m_useOutliers)<<"                            |\n";
  out<<topNtail(spaceSeparator)<<"\n";
  if(!m_usePix && !m_useStrip) return StatusCode::SUCCESS;
  enum Regions{Barrel, Transition, Endcap, Forward, NRegions};
  auto incrementArray=[](auto & array, const int idx){for (int j{};j!=NRegions;++j) array[idx][j] += array[idx+1][j];};
  for(int i=48; i>=0; --i) {
    m_eventStat.m_particleClusters      [i]   +=m_eventStat.m_particleClusters      [i+1];
    incrementArray(m_eventStat.m_particleClustersBTE, i);
    m_eventStat.m_particleSpacePoints   [i]   +=m_eventStat.m_particleSpacePoints   [i+1];
    incrementArray(m_eventStat.m_particleSpacePointsBTE, i);
  }
  auto coerceToOne=[](const double & initialVal)->double {return (initialVal<1.) ? 1. : initialVal; };
  /* Note that in all cases below, the dimension of the target (i.e. result) array is 10
   * whereas the dimension of the source, or input, array is 50. The first index of the source
   * is used for totals, to act as a denominator(coerced to 1 if necessary). Bin 49 is used for overflows.
   * Stats for single clusters (index 1) appear to be unused in printout.
  */
  //all
  double pa   =  coerceToOne(m_eventStat.m_particleClusters[0]); 
  std::array<double, 10> pc2ff{};
  size_t clusterIdx = 2;
  for (auto & thisCluster: pc2ff){
    thisCluster = double(m_eventStat.m_particleClusters[ clusterIdx++ ])/ pa;
  }
  //barrel
  pa           = coerceToOne(m_eventStat.m_particleClustersBTE[0][Barrel]); 
  std::array<double, 10> pcBarrel2ff{};
  size_t clusterBarrelIdx = 2;
  for (auto & thisClusterB: pcBarrel2ff){
    thisClusterB = double(m_eventStat.m_particleClustersBTE[ clusterBarrelIdx++ ][Barrel])/ pa;
  }
  //transition
  pa           = coerceToOne(m_eventStat.m_particleClustersBTE[0][Transition]); 
  std::array<double, 10> pcTransition2ff{};
  size_t clusterTransitionIdx = 2;
  for (auto & thisClusterT: pcTransition2ff){
    thisClusterT = double(m_eventStat.m_particleClustersBTE[ clusterTransitionIdx++ ][Transition])/ pa;
  }
  //endcap
  pa           = coerceToOne(m_eventStat.m_particleClustersBTE[0][Endcap]); 
  std::array<double, 10> pcEndcap2ff{};
  size_t clusterEndcapIdx = 2;
  for (auto & thisClusterE: pcEndcap2ff){
    thisClusterE = double(m_eventStat.m_particleClustersBTE[ clusterEndcapIdx++ ][Endcap])/ pa;
  }
  //fwd
  pa           = coerceToOne(m_eventStat.m_particleClustersBTE[0][3]); 
  std::array<double, 10> pcFwd2ff{};
  size_t clusterFwdIdx = 2;
  for (auto & thisClusterD: pcFwd2ff){
    thisClusterD = double(m_eventStat.m_particleClustersBTE[ clusterFwdIdx++ ][Forward])/ pa;
  }
  //
  //*** SPACE POINTS ***
  //
  //all
  pa   =  coerceToOne(m_eventStat.m_particleSpacePoints[0]); 
  std::array<double, 10> sp2ff{};
  size_t spacepointIdx = 2;
  for (auto & thisSpacepoint: sp2ff){
    thisSpacepoint = double(m_eventStat.m_particleSpacePoints[ spacepointIdx++ ])/ pa;
  }
  //barrel
  pa           = coerceToOne(m_eventStat.m_particleSpacePointsBTE[0][Barrel]); 
  std::array<double, 10> spBarrel2ff{};
  size_t spacepointBarrelIdx = 2;
  for (auto & thisSpacepoint: spBarrel2ff){
    thisSpacepoint = double(m_eventStat.m_particleSpacePointsBTE[ spacepointBarrelIdx++ ][Barrel])/ pa;
  }
  //transition
  pa           = coerceToOne(m_eventStat.m_particleSpacePointsBTE[0][Transition]); 
  std::array<double, 10> spTransition2ff{};
  size_t spacepointTransitionIdx = 2;
  for (auto & thisSpacepoint: spTransition2ff){
    thisSpacepoint = double(m_eventStat.m_particleSpacePointsBTE[ spacepointTransitionIdx++ ][Transition])/ pa;
  }
  //endcap
  pa           = coerceToOne(m_eventStat.m_particleSpacePointsBTE[0][Endcap]); 
  std::array<double, 10> spEndcap2ff{};
  size_t spacepointEndcapIdx = 2;
  for (auto & thisSpacepoint: spEndcap2ff){
    thisSpacepoint = double(m_eventStat.m_particleSpacePointsBTE[ spacepointEndcapIdx++ ][Endcap])/ pa;
  }
  //Fwd
  pa           = coerceToOne(m_eventStat.m_particleSpacePointsBTE[0][Forward]); 
  std::array<double, 10> spFwd2ff{};
  size_t spacepointFwdIdx = 2;
  for (auto & thisSpacepoint: spFwd2ff){
    thisSpacepoint = double(m_eventStat.m_particleSpacePointsBTE[ spacepointFwdIdx++ ][Forward])/ pa;
  }
  auto w8=std::setw(8);
  out<<"|         Probability for such charge particles to have some number silicon                          |\n";
  out<<"|                     clusters                         |             space points                        |\n";
  out<<"|           Total   Barrel  Transi  Endcap   Forward   |  Total   Barrel  Transi  Endcap   Forward       |\n";
 
   for (size_t idx{0};idx != 10;++idx){
     out<<"|  >= "<<idx+2<< std::string((idx<8)?"  ":" ")
       <<w8<<p5<<pc2ff[idx]
       <<w8<<p5<<pcBarrel2ff[idx]
       <<w8<<p5<<pcTransition2ff[idx]
       <<w8<<p5<<pcEndcap2ff[idx]
       <<w8<<p5<<pcFwd2ff[idx]<<"  |  "
 
       <<w8<<p5<<sp2ff[idx]
       <<w8<<p5<<spBarrel2ff[idx]
       <<w8<<p5<<spTransition2ff[idx]
       <<w8<<p5<<spEndcap2ff[idx]
       <<w8<<p5<<spFwd2ff[idx]
       <<"       |\n";
   }
 
  out<<topNtail(spaceSeparator)<<"\n";
  out<<"|               Additional cuts for truth particles are                             |\n";
  out<<"|   eta dependent number of silicon clusters >= [";
  for (unsigned int clbin = 0; clbin<(m_clcuts.size()-1); clbin++)
    out<<std::setw(2)<<m_clcuts.value().at(clbin)<<", ";
  out<<std::setw(2)<<m_clcuts.value().back()<<"]                        |\n";
  out<<"|                    number  space    points >="<<w13<<m_spcut.value()<<"                        |\n";
 
  pa  = coerceToOne(m_eventStat.m_particleClusters[0]); 
  out<<"|           Probability find truth particles with this cuts is "<<w8<<p5<<double(m_eventStat.m_events)/pa<<"             |\n";
  pa  = coerceToOne(m_eventStat.m_particleClustersBTE[0][Barrel]); 
  out<<"|                                        For barrel     region "<<w8<<p5<<double(m_eventStat.m_eventsBTE[Barrel])/pa<<"             |\n";
  pa  = coerceToOne(m_eventStat.m_particleClustersBTE[0][Transition]);
  out<<"|                                        For transition region "<<w8<<p5<<double(m_eventStat.m_eventsBTE[Transition])/pa<<"             |\n";
  pa  = coerceToOne(m_eventStat.m_particleClustersBTE[0][Endcap]); 
  out<<"|                                        For endcap     region "<<w8<<p5<<double(m_eventStat.m_eventsBTE[Endcap])/pa<<"             |\n";
  pa  = coerceToOne(m_eventStat.m_particleClustersBTE[0][Forward]); 
  out<<"|                                        For forward    region "<<w8<<p5<<double(m_eventStat.m_eventsBTE[Forward])/pa<<"             |\n";
  out<<"|                                                                                   |\n";
  pa            = coerceToOne(m_eventStat.m_nclustersNegBP); 
  double ratio  = double(m_eventStat.m_nclustersPosBP)/pa;
  double eratio = std::sqrt(ratio*(1.+ratio)/pa);
  out<<"|      Ratio barrel pixels clusters for +/- particles ="<<w8<<p5<<ratio<<" +-"<<w8<<p5<<eratio<<"          |\n";
  pa            = coerceToOne(m_eventStat.m_nclustersNegEP); 
  ratio         = double(m_eventStat.m_nclustersPosEP)/pa;
  eratio        = std::sqrt(ratio*(1.+ratio)/pa);
  out<<"|      Ratio endcap pixels clusters for +/- particles ="<<w8<<p5<<ratio<<" +-"<<w8<<p5<<eratio<<"          |\n";
  pa            = coerceToOne(m_eventStat.m_nclustersNegBS);
  ratio         = double(m_eventStat.m_nclustersPosBS)/pa;
  eratio        = std::sqrt(ratio*(1.+ratio)/pa);
  out<<"|      Ratio barrel   Strip  clusters for +/- particles ="<<w8<<p5<<ratio<<" +-"<<w8<<p5<<eratio<<"          |\n";
  pa            = coerceToOne(m_eventStat.m_nclustersNegES);
  ratio         = double(m_eventStat.m_nclustersPosES)/pa;
  eratio        = std::sqrt(ratio*(1.+ratio)/pa);
  out<<"|      Ratio endcap   Strip  clusters for +/- particles ="<<w8<<p5<<ratio<<" +-"<<w8<<p5<<eratio<<"          |\n";
  pa            = double(m_eventStat.m_eventsNEG);      if(pa < 1.) pa = 1.;
  ratio         = double(m_eventStat.m_eventsPOS)/pa;
  eratio        = std::sqrt(ratio*(1.+ratio)/pa);
  out<<"|      Number truth particles and +/- ratio ="<<std::setw(10)<<m_eventStat.m_events<<w8<<p5<<ratio<<" +-"<<w8<<p5<<eratio<<"          |\n";
    ratio = 0.;
    if(m_eventStat.m_nclustersPTOT!=0) ratio = double(m_eventStat.m_nclustersPTOTt)/double(m_eventStat.m_nclustersPTOT);
 
  out<<"| Number pix clusters, truth clusters and ratio = "
       <<std::setw(10)<<m_eventStat.m_nclustersPTOT
       <<std::setw(10)<<m_eventStat.m_nclustersPTOTt
       <<std::setw(12)<<std::setprecision(5)<<ratio<<"  |\n";
  ratio = 0.;
  if(m_eventStat.m_nclustersSTOT!=0) ratio = double(m_eventStat.m_nclustersSTOTt)/double(m_eventStat.m_nclustersSTOT);
   out<<"| Number strip clusters, truth clusters and ratio = "
       <<std::setw(10)<<m_eventStat.m_nclustersSTOT
       <<std::setw(10)<<m_eventStat.m_nclustersSTOTt
       <<std::setw(12)<<std::setprecision(5)<<ratio<<"  |\n";
       
  out<<"|-----------------------------------------------------------------------------------|\n\n";
 
  SG::ReadHandleKeyArray<TrackCollection>::const_iterator t=m_tracklocation.begin(),te=m_tracklocation.end();
  int nc = 0;
  for(; t!=te; ++t) {
    int   n     = 47-(t->key().size());
    std::string s1; for(int i=0; i<n; ++i) s1.append(" "); s1.append("|");
 
 
    out<<"|-----------------------------------------------------------------------------------|\n";
    out<<"|                      Statistic for "<<(t->key())<<s1<<"\n";
 
    double ne = double(m_eventStat.m_events);  if(ne < 1.) ne = 1.;
    double ef [6]; for(int i=0; i!=6; ++i) ef [i] = double(m_trackCollectionStat[nc].m_efficiency   [i])   /ne;
    double ef0[6]; for(int i=0; i!=6; ++i) ef0[i] = double(m_trackCollectionStat[nc].m_efficiencyN  [i][0])/ne;
    double ef1[6]; for(int i=0; i!=6; ++i) ef1[i] = double(m_trackCollectionStat[nc].m_efficiencyN  [i][1])/ne;
    double ef2[6]; for(int i=0; i!=6; ++i) ef2[i] = double(m_trackCollectionStat[nc].m_efficiencyN  [i][2])/ne;
 
 
    using EffArray_t = std::array<double, 6>;
    //
    auto makeEffArray = [](const auto & threeDimArray, const size_t secondIdx, const size_t thirdIdx, const double denom){
      EffArray_t result{};
      size_t idx{0};
      auto invDenom = 1./denom;
      for (auto & entry: result){
        entry = threeDimArray[idx++][secondIdx][thirdIdx]*invDenom;
      }
      return result;
    };
    //
    const auto & efficiencyArrayInput = m_trackCollectionStat[nc].m_efficiencyBTE;
    //
    double neBTE = coerceToOne(m_eventStat.m_eventsBTE[Barrel]);
    const EffArray_t efB0 = makeEffArray(efficiencyArrayInput,0,Barrel,neBTE);
    const EffArray_t efB1 = makeEffArray(efficiencyArrayInput,1,Barrel,neBTE);
    const EffArray_t efB2 = makeEffArray(efficiencyArrayInput,2,Barrel,neBTE);
    const EffArray_t efB3 = makeEffArray(efficiencyArrayInput,3,Barrel,neBTE);
    const EffArray_t efB4 = makeEffArray(efficiencyArrayInput,4,Barrel,neBTE);
    //
    neBTE = coerceToOne(m_eventStat.m_eventsBTE[Transition]);
    const EffArray_t efT0 = makeEffArray(efficiencyArrayInput,0,Transition,neBTE);
    const EffArray_t efT1 = makeEffArray(efficiencyArrayInput,1,Transition,neBTE);
    const EffArray_t efT2 = makeEffArray(efficiencyArrayInput,2,Transition,neBTE);
    const EffArray_t efT3 = makeEffArray(efficiencyArrayInput,3,Transition,neBTE);
    const EffArray_t efT4 = makeEffArray(efficiencyArrayInput,4,Transition,neBTE);
    //
    neBTE = coerceToOne(m_eventStat.m_eventsBTE[Endcap]);
    const EffArray_t efE0 = makeEffArray(efficiencyArrayInput,0,Endcap,neBTE);
    const EffArray_t efE1 = makeEffArray(efficiencyArrayInput,1,Endcap,neBTE);
    const EffArray_t efE2 = makeEffArray(efficiencyArrayInput,2,Endcap,neBTE);
    const EffArray_t efE3 = makeEffArray(efficiencyArrayInput,3,Endcap,neBTE);
    const EffArray_t efE4 = makeEffArray(efficiencyArrayInput,4,Endcap,neBTE);
    //
    neBTE = coerceToOne(m_eventStat.m_eventsBTE[Forward]);
    const EffArray_t efD0 = makeEffArray(efficiencyArrayInput,0,Forward,neBTE);
    const EffArray_t efD1 = makeEffArray(efficiencyArrayInput,1,Forward,neBTE);
    const EffArray_t efD2 = makeEffArray(efficiencyArrayInput,2,Forward,neBTE);
    const EffArray_t efD3 = makeEffArray(efficiencyArrayInput,3,Forward,neBTE);
    const EffArray_t efD4 = makeEffArray(efficiencyArrayInput,4,Forward,neBTE);
 
 
    double efrec  = ef0[0]+ef0[1]+ef0[2]+ef1[0]+ef1[1]+ef2[0];
    double efrecB = efB0[0]+efB0[1]+efB0[2]+efB1[0]+efB1[1]+efB2[0];
    double efrecT = efT0[0]+efT0[1]+efT0[2]+efT1[0]+efT1[1]+efT2[0];
    double efrecE = efE0[0]+efE0[1]+efE0[2]+efE1[0]+efE1[1]+efE2[0];
    double efrecD = efD0[0]+efD0[1]+efD0[2]+efD1[0]+efD1[1]+efD2[0];
 
    ne        = coerceToOne(m_eventStat.m_eventsPOS); 
    double efP[6]; for(int i=0; i!=6; ++i) efP[i] = double(m_trackCollectionStat[nc].m_efficiencyPOS[i])/ne;
    ne        = coerceToOne(m_eventStat.m_eventsNEG);
    double efN[6]; for(int i=0; i!=6; ++i) efN[i] = double(m_trackCollectionStat[nc].m_efficiencyNEG[i])/ne;
 
    out<<"|-----------------------------------------------------------------------------------|\n";
    out<<"| Probability to lose       0        1        2        3        4    >=5 clusters   |\n";
    out<<"|-----------------------------------------------------------------------------------|\n";
    
    auto formattedOutput=[&out](auto & effArray){ 
      for (size_t i{};i!=6;++i){
        out<<std::setw(9)<<std::setprecision(4)<<effArray[i];
      }
      out<<"        |\n";
    };
    
    out<<"| For all particles   ";
      formattedOutput(ef);
    out<<"| For  +  particles   ";
      formattedOutput(efP);
    out<<"| For  -  particles   ";
      formattedOutput(efN);
    out<<"|-----------------------------------------------------------------------------------|\n";
    out<<"| Barrel region                                                                     |\n";
    out<<"|   0 wrong clusters  ";
      formattedOutput(efB0);
    out<<"|   1 wrong clusters  ";
      formattedOutput(efB1);
    out<<"|   2 wrong clusters  ";
      formattedOutput(efB2);
    out<<"|   3 wrong clusters  ";
      formattedOutput(efB3);
    out<<"| >=4 wrong clusters  ";
      formattedOutput(efB4);
    out<<"|-----------------------------------------------------------------------------------|\n";
    out<<"| Transition region                                                                 |\n";
    out<<"|   0 wrong clusters  ";
      formattedOutput(efT0);
    out<<"|   1 wrong clusters  ";
      formattedOutput(efT1);
    out<<"|   2 wrong clusters  ";
      formattedOutput(efT2);
    out<<"|   3 wrong clusters  ";
      formattedOutput(efT3);
    out<<"| >=4 wrong clusters  ";
      formattedOutput(efT4);
    out<<"|-----------------------------------------------------------------------------------|\n";
    out<<"| Endcap region                                                                     |\n";
    out<<"|   0 wrong clusters  ";
    formattedOutput(efE0);
    out<<"|   1 wrong clusters  ";
      formattedOutput(efE1);
    out<<"|   2 wrong clusters  ";
      formattedOutput(efE2);
    out<<"|   3 wrong clusters  ";
      formattedOutput(efE3);
    out<<"| >=4 wrong clusters  ";
      formattedOutput(efE4);
    out<<"|-----------------------------------------------------------------------------------|\n";
    out<<"| Forward region                                                                    |\n";
    out<<"|   0 wrong clusters  ";
    formattedOutput(efD0);
    out<<"|   1 wrong clusters  ";
    formattedOutput(efD1);
    out<<"|   2 wrong clusters  ";
    formattedOutput(efD2);
    out<<"|   3 wrong clusters  ";
    formattedOutput(efD3);
    out<<"| >=4 wrong clusters  ";
    formattedOutput(efD4);
 
   out<<"|-----------------------------------------------------------------------------------|\n";
   pa  = coerceToOne(m_eventStat.m_particleClusters[0]);
   out<<"| Efficiency reconstruction (number lose+wrong < 3) = "
        <<std::setw(9)<<std::setprecision(5)<<efrec
        <<" ("
        <<std::setw(9)<<std::setprecision(5)<<efrec*double(m_eventStat.m_events)/pa
        <<" ) "
        <<"       |\n";
   pa  = coerceToOne(m_eventStat.m_particleClustersBTE[0][Barrel]);
   out<<"|                             For barrel     region = "
        <<std::setw(9)<<std::setprecision(5)<<efrecB
        <<" ("
        <<std::setw(9)<<std::setprecision(5)<<efrecB*double(m_eventStat.m_eventsBTE[Barrel])/pa
        <<" ) "
        <<"       |\n";
   pa  = coerceToOne(m_eventStat.m_particleClustersBTE[0][Transition]); 
   out<<"|                             For transition region = "
        <<std::setw(9)<<std::setprecision(5)<<efrecT
        <<" ("
        <<std::setw(9)<<std::setprecision(5)<<efrecT*double(m_eventStat.m_eventsBTE[Transition])/pa
        <<" ) "
        <<"       |\n";
   pa  = coerceToOne(m_eventStat.m_particleClustersBTE[0][Endcap]); 
   out<<"|                             For endcap     region = "
        <<std::setw(9)<<std::setprecision(5)<<efrecE
        <<" ("
        <<std::setw(9)<<std::setprecision(5)<<efrecE*double(m_eventStat.m_eventsBTE[Endcap])/pa
        <<" ) "
        <<"       |\n";
   pa  = coerceToOne(m_eventStat.m_particleClustersBTE[0][Forward]); 
   out<<"|                             For forward    region = "
            <<std::setw(9)<<std::setprecision(5)<<efrecD
            <<" ("
            <<std::setw(9)<<std::setprecision(5)<<efrecD*double(m_eventStat.m_eventsBTE[Forward])/pa
            <<" ) "
            <<"       |\n";
 
    out<<"|-----------------------------------------------------------------------------------|\n";
    out<<"| Reconstructed tracks         +          -    +/-ratio     error                   |\n";
    out<<"|-----------------------------------------------------------------------------------|\n";
 
    pa     = coerceToOne(m_trackCollectionStat[nc].m_ntracksNEGB); 
    ratio  = double(m_trackCollectionStat[nc].m_ntracksPOSB)/pa;
    eratio = std::sqrt(ratio*(1.+ratio)/pa);
 
    out<<"| Barrel               "
         <<std::setw(10)<<m_trackCollectionStat[nc].m_ntracksPOSB
         <<std::setw(11)<<m_trackCollectionStat[nc].m_ntracksNEGB
         <<std::setw(11)<<std::setprecision(5)<<ratio
         <<std::setw(11)<<std::setprecision(5)<<eratio<<"                  |\n";
    pa     = coerceToOne(m_trackCollectionStat[nc].m_ntracksNEGE); 
    ratio  = double(m_trackCollectionStat[nc].m_ntracksPOSE)/pa;
    eratio = std::sqrt(ratio*(1.+ratio)/pa);
 
    out<<"| Endcap               "
         <<std::setw(10)<<m_trackCollectionStat[nc].m_ntracksPOSE
         <<std::setw(11)<<m_trackCollectionStat[nc].m_ntracksNEGE
         <<std::setw(11)<<std::setprecision(5)<<ratio
         <<std::setw(11)<<std::setprecision(5)<<eratio<<"                  |\n";
    pa     = coerceToOne(m_trackCollectionStat[nc].m_ntracksNEGFWD); 
    ratio  = double(m_trackCollectionStat[nc].m_ntracksPOSFWD)/pa;
    eratio = std::sqrt(ratio*(1.+ratio)/pa);
 
    out<<"| Forward              "
             <<std::setw(10)<<m_trackCollectionStat[nc].m_ntracksPOSFWD
             <<std::setw(11)<<m_trackCollectionStat[nc].m_ntracksNEGFWD
             <<std::setw(11)<<std::setprecision(5)<<ratio
             <<std::setw(11)<<std::setprecision(5)<<eratio<<"                  |\n";
 
 
 
    int nt=0;
    int ft=0;
    int kf=0;
    for(int k = 0; k!=50; ++k) {
      nt+=m_trackCollectionStat[nc].m_total[k];
      ft+=m_trackCollectionStat[nc].m_fake [k];
      if(!kf && nt) kf = k;
    }
 
    if(kf) {
 
      out<<"|-----------------------------------------------------------------------------------|\n";
      out<<"|             Fake tracks rate for different number of clusters on track            |\n";
      out<<"|-----------------------------------------------------------------------------------|\n";
 
      for(int k = kf; k!=kf+6; ++k) {
    out<<"|     >= "<<std::setw(2)<<k<<"   ";
      }
      out<<"|\n";
 
      for(int k = kf; k!=kf+6; ++k) {
    double eff = 0.; if(nt>0) eff = double(ft)/double(nt);
    out<<"|"<<std::setw(12)<<std::setprecision(5)<<eff<<" ";
    nt-=m_trackCollectionStat[nc].m_total[k];
    ft-=m_trackCollectionStat[nc].m_fake [k];
      }
      out<<"|\n";
      out<<"|-----------------------------------------------------------------------------------|\n";
    }
    ++nc;
  }
  ATH_MSG_INFO("\n"<<out.str());
  return StatusCode::SUCCESS;
}

findTruth()

PRD_MultiTruthCollection::const_iterator ITk::TrackClusterAssValidation::findTruth ( const ITk::TrackClusterAssValidation::EventData_t & event_data, const Trk::PrepRawData * d, PRD_MultiTruthCollection::const_iterator & mce )

staticprotected

Definition at line 1363 of file ITkTrackClusterAssValidation.cxx.

{
  const InDet::SCT_Cluster    * si = dynamic_cast<const InDet::SCT_Cluster*>    (d);
  const InDet::PixelCluster   * px = dynamic_cast<const InDet::PixelCluster*>   (d);
 
  PRD_MultiTruthCollection::const_iterator mc;
 
  if     (px && event_data.m_truthPix) {mc=event_data.m_truthPix->find(d->identify()); mce=event_data.m_truthPix->end();}
  else if(si && event_data.m_truthStrip) {mc=event_data.m_truthStrip->find(d->identify()); mce=event_data.m_truthStrip->end();}
  else {
    const PRD_MultiTruthCollection *truth[] {event_data. m_truthPix,event_data.m_truthStrip};
    for (int i=0; i<3; i++) {
        if (truth[i]) {
          mce=truth[i]->end();
          return truth[i]->end();
        }
    }
    throw std::runtime_error("Neither Pixel nor Strip truth.");
  }
  return mc;
}

initialize()

StatusCode ITk::TrackClusterAssValidation::initialize

(

)

Definition at line 36 of file ITkTrackClusterAssValidation.cxx.

{
 
  StatusCode sc;
 
  if (m_rapcut == 0) {
    m_tcut = 0;
  }
  else {
    double den = tan(2.*atan(exp(-m_rapcut)));
    if (den > 0) {
      m_tcut = 1./den;
    }
    else {
      m_tcut = std::numeric_limits<double>::max();
    }
  }
 
  // Erase statistic information
  //
  m_pdg          = std::abs(m_pdg)         ;
 
  m_trackCollectionStat.resize(m_tracklocation.size());
  m_eventStat = InDet::EventStat_t();
 
  // Read Handle Key
  ATH_CHECK(m_truth_locationStrip.initialize(m_useStrip));
  ATH_CHECK(m_clustersStripname.initialize(m_useStrip));
  ATH_CHECK(m_spacepointsStripname.initialize(m_useStrip));
 
  ATH_CHECK( m_clustersPixelname.initialize(m_usePix));
  ATH_CHECK( m_spacepointsPixelname.initialize(m_usePix));
  ATH_CHECK( m_truth_locationPixel.initialize(m_usePix));
 
  ATH_CHECK( m_spacepointsOverlapname.initialize(m_useStrip));
 
  ATH_CHECK( m_tracklocation.initialize());
 
  // Read Cond Handle Key
  ATH_CHECK(m_pixelDetEleCollKey.initialize());
  ATH_CHECK(m_StripDetEleCollKey.initialize());
 
  if (msgLvl(MSG::DEBUG)) {
    dumptools(msg(),MSG::DEBUG);
    msg() << endmsg;
  }
 
  return sc;
}

inputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< Gaudi::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.

isClonable()

bool AthCommonReentrantAlgorithm< Gaudi::Algorithm >::isClonable ( ) const

overridevirtualinherited

Specify if the algorithm is clonable.

Reentrant algorithms are clonable.

Reimplemented in InDet::GNNSeedingTrackMaker, InDet::SCT_Clusterization, InDet::SiSPGNNTrackMaker, InDet::SiSPSeededTrackFinder, InDet::SiTrackerSpacePointFinder, ITkPixelCablingAlg, ITkStripCablingAlg, RoIBResultToxAOD, SCT_ByteStreamErrorsTestAlg, SCT_CablingCondAlgFromCoraCool, SCT_CablingCondAlgFromText, SCT_ConditionsParameterTestAlg, SCT_ConditionsSummaryTestAlg, SCT_ConfigurationConditionsTestAlg, SCT_FlaggedConditionTestAlg, SCT_LinkMaskingTestAlg, SCT_MajorityConditionsTestAlg, SCT_ModuleVetoTestAlg, SCT_MonitorConditionsTestAlg, SCT_PrepDataToxAOD, SCT_RawDataToxAOD, SCT_ReadCalibChipDataTestAlg, SCT_ReadCalibDataTestAlg, SCT_RODVetoTestAlg, SCT_SensorsTestAlg, SCT_SiliconConditionsTestAlg, SCT_StripVetoTestAlg, SCT_TdaqEnabledTestAlg, SCT_TestCablingAlg, SCTEventFlagWriter, SCTRawDataProvider, SCTSiLorentzAngleTestAlg, SCTSiPropertiesTestAlg, and Simulation::BeamEffectsAlg.

Definition at line 68 of file AthCommonReentrantAlgorithm.cxx.

{
  // Reentrant algorithms are clonable.
  return true;
}

isTheSameDetElement() [1/2]

bool ITk::TrackClusterAssValidation::isTheSameDetElement ( const ITk::TrackClusterAssValidation::EventData_t & event_data, int K, const Trk::PrepRawData * d )

staticprotected

Definition at line 1225 of file ITkTrackClusterAssValidation.cxx.

{
  std::multimap<int,const Trk::PrepRawData*>::const_iterator k = event_data.m_kinecluster.find(K);
  for(; k!=event_data.m_kinecluster.end(); ++k) {
 
    if((*k).first!= K) return false;
    if(d->detectorElement()==(*k).second->detectorElement()) return true;
  }
  return false;
}

isTheSameDetElement() [2/2]

bool ITk::TrackClusterAssValidation::isTheSameDetElement ( const ITk::TrackClusterAssValidation::EventData_t & event_data, int K, const Trk::SpacePoint * sp )

staticprotected

Definition at line 1241 of file ITkTrackClusterAssValidation.cxx.

{
  const Trk::PrepRawData*  p1 = sp->clusterList().first;
  const Trk::PrepRawData*  p2 = sp->clusterList().second;
 
  std::multimap<int,const Trk::SpacePoint*>::const_iterator  k = event_data.m_kinespacepoint.find(K);
 
  if(!p2) {
 
    for(; k!=event_data.m_kinespacepoint.end(); ++k) {
      if((*k).first!= K) return false;
 
      const Trk::PrepRawData*  n1 = (*k).second->clusterList().first ;
      const Trk::PrepRawData*  n2 = (*k).second->clusterList().second;
 
      if(p1->detectorElement() == n1->detectorElement()) return true;
      if(!n2) continue;
      if(p1->detectorElement() == n2->detectorElement()) return true;
    }
    return false;
  }
 
  for(; k!=event_data.m_kinespacepoint.end(); ++k) {
    if((*k).first!= K) return false;
 
    const Trk::PrepRawData*  n1 = (*k).second->clusterList().first ;
    const Trk::PrepRawData*  n2 = (*k).second->clusterList().second;
 
    if(p1->detectorElement() == n1->detectorElement()) return true;
    if(p2->detectorElement() == n1->detectorElement()) return true;
    if(!n2) continue;
    if(p1->detectorElement() == n2->detectorElement()) return true;
    if(p2->detectorElement() == n2->detectorElement()) return true;
  }
  return false;
}

isTruth()

bool ITk::TrackClusterAssValidation::isTruth ( const ITk::TrackClusterAssValidation::EventData_t & event_data, const Trk::PrepRawData * d )

staticprotected

Definition at line 1213 of file ITkTrackClusterAssValidation.cxx.

{
  PRD_MultiTruthCollection::const_iterator mce;
  PRD_MultiTruthCollection::const_iterator mc = findTruth(event_data,d,mce);
  return mc!=mce;
}

kine() [1/2]

int ITk::TrackClusterAssValidation::kine ( const ITk::TrackClusterAssValidation::EventData_t & event_data, const Trk::PrepRawData * d1, const Trk::PrepRawData * d2, int * Kine, int nmax ) const

protected

Definition at line 1117 of file ITkTrackClusterAssValidation.cxx.

{
  int nkine = 0;
  int Kine1[1000],Kine2[1000];
  int n1 = kine(event_data,d1,Kine1,nmax); if(!n1) return nkine;
  int n2 = kine(event_data,d2,Kine2,nmax); if(!n2) return nkine;
 
  for(int i = 0; i!=n1; ++i) {
    for(int j = 0; j!=n2; ++j) {
      if(Kine1[i]==Kine2[j]) {Kine[nkine++] = Kine1[i];  break;}
    }
  }
  return nkine;
}

kine() [2/2]

int ITk::TrackClusterAssValidation::kine ( const ITk::TrackClusterAssValidation::EventData_t & event_data, const Trk::PrepRawData * d, int * Kine, int nmax ) const

protected

Definition at line 1137 of file ITkTrackClusterAssValidation.cxx.

{
 
  PRD_MultiTruthCollection::const_iterator mce;
  PRD_MultiTruthCollection::const_iterator mc = findTruth(event_data,d,mce);
 
  Identifier ID    = d->identify();
  int        nkine = 0;
 
  for(; mc!=mce; ++mc) {
 
    if( (*mc).first != ID ) return nkine;
 
    const int uniqueID = HepMC::uniqueID((*mc).second); if(uniqueID<=0) continue;
 
    const HepMC::ConstGenParticlePtr pa = (*mc).second.cptr();
    if(!pa or !pa->production_vertex()) continue;
 
    int pdg = std::abs(pa->pdg_id()); if(m_pdg && m_pdg != pdg ) continue;
    if (MC::isNucleus(pdg)) continue; // ignore nuclei from hadronic interactions
    if ( std::abs(MC::charge(pdg)) < .5 ) continue;
 
    // pT cut
    //
    double           px = pa->momentum().px();
    double           py = pa->momentum().py();
    double           pz = pa->momentum().pz();
    double           pt = std::sqrt(px*px+py*py);
    if( pt < m_ptcut || pt > m_ptcutmax) continue;
 
    // Rapidity cut
    //
    double           t  = std::abs(pz)/pt;
    if( t  > m_tcut ) continue;
 
    // Radius cut
    //
    double           vx = pa->production_vertex()->position().x();
    double           vy = pa->production_vertex()->position().y();
    double           r = std::sqrt(vx*vx+vy*vy);
    if( r < m_rmin || r > m_rmax) continue;
 
    Kine[nkine] = uniqueID; if(++nkine >= nmax) break;
  }
  return nkine;
}

kine0()

int ITk::TrackClusterAssValidation::kine0 ( const ITk::TrackClusterAssValidation::EventData_t & event_data, const Trk::PrepRawData * d, int * Kine, int nmax )

staticprotected

Definition at line 1189 of file ITkTrackClusterAssValidation.cxx.

{
 
  PRD_MultiTruthCollection::const_iterator mce;
  PRD_MultiTruthCollection::const_iterator mc = findTruth(event_data, d,mce);
 
  Identifier ID    = d->identify();
  int        nkine = 0;
 
  for(; mc!=mce; ++mc) {
 
    if( (*mc).first != ID ) return nkine;
 
    const int uniqueID = HepMC::uniqueID((*mc).second); if(uniqueID<=0) continue;
    Kine[nkine] = uniqueID; if(++nkine >= nmax) break;
  }
  return nkine;
}

minclusters()

unsigned int ITk::TrackClusterAssValidation::minclusters ( float eta ) const

inlineprotected

Definition at line 203 of file ITkTrackClusterAssValidation.h.

                                                                               {
    float aeta = std::abs(eta);
    for(int n = int(m_clcuts.size()-1); n>0; --n) {
      if(aeta > m_etabins.value().at(n)) return m_clcuts.value().at(n);
    }
    return m_clcuts.value().at(0);
  }

minpT()

float ITk::TrackClusterAssValidation::minpT ( float eta ) const

inlineprotected

Definition at line 195 of file ITkTrackClusterAssValidation.h.

                                                                  {
    float aeta = std::abs(eta);
    for(int n = int(m_ptcuts.size()-1); n>0; --n) {
      if(aeta > m_etabins.value().at(n)) return m_ptcuts.value().at(n);
    }
    return m_ptcuts.value().at(0);
  }

msg()

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msgLvl()

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

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

newClustersEvent()

void ITk::TrackClusterAssValidation::newClustersEvent ( const EventContext & ctx, ITk::TrackClusterAssValidation::EventData_t & event_data ) const

protected

Definition at line 674 of file ITkTrackClusterAssValidation.cxx.

{
  std::lock_guard<std::mutex> lock(m_statMutex);
 
  // Get pixel clusters container
  //
  std::unique_ptr<SG::ReadHandle<InDet::SiClusterContainer> >       pixelcontainer;
  std::unique_ptr<SG::ReadHandle<InDet::SiClusterContainer> >       stripcontainer;
 
  if(m_usePix) {
    pixelcontainer = std::make_unique<SG::ReadHandle<InDet::SiClusterContainer> >(m_clustersPixelname,ctx);
    if (!pixelcontainer->isValid()) ATH_MSG_DEBUG("Failed to create Pixel clusters container read handle with key " << m_clustersPixelname.key());
  }
 
  // Get strip  clusters container
  //
  if(m_useStrip) {
    stripcontainer = std::make_unique<SG::ReadHandle<InDet::SiClusterContainer> >(m_clustersStripname,ctx);
    if (!stripcontainer->isValid()) ATH_MSG_DEBUG("Failed to create Strip clusters container read handle with key " << m_clustersStripname.key());
  }
 
  int Kine[1000];
 
  event_data.m_clusterHandles.reserve(3);
  // Loop through all pixel clusters
  //
  if(pixelcontainer && pixelcontainer->isValid()) {
    InDet::SiClusterContainer::const_iterator w  =  (*pixelcontainer)->begin();
    InDet::SiClusterContainer::const_iterator we =  (*pixelcontainer)->end  ();
 
    for(; w!=we; ++w) {
 
      InDet::SiClusterCollection::const_iterator c  = (*w)->begin();
      InDet::SiClusterCollection::const_iterator ce = (*w)->end  ();
 
      for(; c!=ce; ++c) {
 
    ++event_data.m_nclusters;
    ++m_eventStat.m_nclustersPTOT;
    if(isTruth(event_data,(*c))) ++m_eventStat.m_nclustersPTOTt;  
 
 
    int nk = kine(event_data,(*c),Kine,999);
    for(int i=0; i!=nk; ++i) {
      if(!isTheSameDetElement(event_data,Kine[i],(*c))) {
        event_data.m_kinecluster.insert(std::make_pair(Kine[i],(*c)));
      }
    }
      }
    }
    event_data.m_clusterHandles.push_back(std::move(pixelcontainer));
 
  }
 
  // Loop through all strip clusters
  //
  if(stripcontainer && stripcontainer->isValid()) {
    InDet::SiClusterContainer::const_iterator w  =  (*stripcontainer)->begin();
    InDet::SiClusterContainer::const_iterator we =  (*stripcontainer)->end  ();
 
    for(; w!=we; ++w) {
 
      InDet::SiClusterCollection::const_iterator c  = (*w)->begin();
      InDet::SiClusterCollection::const_iterator ce = (*w)->end  ();
 
      for(; c!=ce; ++c) {
 
    ++event_data.m_nclusters;
    ++m_eventStat.m_nclustersSTOT;
    if(isTruth(event_data,(*c))) ++m_eventStat.m_nclustersSTOTt; 
    
    int nk = kine(event_data,(*c),Kine,999);
    for(int i=0; i!=nk; ++i) {
      if(!isTheSameDetElement(event_data,Kine[i],(*c))) event_data.m_kinecluster.insert(std::make_pair(Kine[i],(*c)));
    }
      }
    }
    event_data.m_clusterHandles.push_back(std::move(stripcontainer));
  }
 
}

newSpacePointsEvent()

void ITk::TrackClusterAssValidation::newSpacePointsEvent ( const EventContext & ctx, ITk::TrackClusterAssValidation::EventData_t & event_data ) const

protected

Definition at line 760 of file ITkTrackClusterAssValidation.cxx.

{
 
  int Kine[1000];
 
  if(m_usePix && !m_spacepointsPixelname.key().empty()) {
    event_data.m_spacePointContainer.emplace_back(m_spacepointsPixelname,ctx);
    if (!event_data.m_spacePointContainer.back().isValid()) {
      ATH_MSG_DEBUG( "Invalid Pixels space points container read handle for key " << m_spacepointsPixelname.key()  );
    }
    else  {
      SpacePointContainer::const_iterator spc  =  event_data.m_spacePointContainer.back()->begin();
      SpacePointContainer::const_iterator spce =  event_data.m_spacePointContainer.back()->end  ();
      for(; spc != spce; ++spc) {
        SpacePointCollection::const_iterator sp  = (*spc)->begin();
        SpacePointCollection::const_iterator spe = (*spc)->end  ();
 
        for(; sp != spe; ++sp) {
 
          ++event_data.m_nspacepoints;
          int nk = kine(event_data,(*sp)->clusterList().first,Kine,999);
          for(int i=0; i!=nk; ++i) {
 
            if(!isTheSameDetElement(event_data,Kine[i],(*sp))) {
              event_data.m_kinespacepoint.insert(std::make_pair(Kine[i],(*sp)));
            }
          }
        }
      }
    }
  }
 
  // Get strip space points containers from store gate
  //
  if(m_useStrip && !m_spacepointsStripname.key().empty()) {
    event_data.m_spacePointContainer.emplace_back(m_spacepointsStripname,ctx);
    if (!event_data.m_spacePointContainer.back().isValid()) {
      ATH_MSG_DEBUG( "Invalid Strip space points container read handle for key " << m_spacepointsStripname.key() );
    }
    else  {
      SpacePointContainer::const_iterator spc  =  event_data.m_spacePointContainer.back()->begin();
      SpacePointContainer::const_iterator spce =  event_data.m_spacePointContainer.back()->end  ();
 
      for(; spc != spce; ++spc) {
 
        SpacePointCollection::const_iterator sp  = (*spc)->begin();
        SpacePointCollection::const_iterator spe = (*spc)->end  ();
 
        for(; sp != spe; ++sp) {
 
 
          ++event_data.m_nspacepoints;
          int nk = kine(event_data,(*sp)->clusterList().first,(*sp)->clusterList().second,Kine,999);
          for(int i=0; i!=nk; ++i) {
            if(!isTheSameDetElement(event_data,Kine[i],(*sp))) {
              event_data.m_kinespacepoint.insert(std::make_pair(Kine[i],(*sp)));
            }
          }
        }
      }
    }
  }
 
  // Get strip overlap space points containers from store gate
  //
  if(m_useStrip && !m_spacepointsOverlapname.key().empty()) {
    event_data.m_spacepointsOverlap=std::make_unique< SG::ReadHandle<SpacePointOverlapCollection> >(m_spacepointsOverlapname,ctx);
    if (!event_data.m_spacepointsOverlap->isValid()) {
      ATH_MSG_DEBUG( "Invalid overlap space points container read handle for key " << m_spacepointsOverlapname.key() );
    }
    else  {
      SpacePointOverlapCollection::const_iterator sp  = (*(event_data.m_spacepointsOverlap))->begin();
      SpacePointOverlapCollection::const_iterator spe = (*(event_data.m_spacepointsOverlap))->end  ();
 
      for (; sp!=spe; ++sp) {
 
        ++event_data.m_nspacepoints;
        int nk = kine(event_data,(*sp)->clusterList().first,(*sp)->clusterList().second,Kine,999);
        for(int i=0; i!=nk; ++i) {
          if(!isTheSameDetElement(event_data,Kine[i],(*sp))) {
            event_data.m_kinespacepoint.insert(std::make_pair(Kine[i],(*sp)));
          }
        }
      }
    }
  }
}

noReconstructedParticles()

bool ITk::TrackClusterAssValidation::noReconstructedParticles ( const ITk::TrackClusterAssValidation::EventData_t & event_data ) const

protected

Definition at line 1283 of file ITkTrackClusterAssValidation.cxx.

{
 
  for(SG::ReadHandleKeyArray<TrackCollection>::size_type nc=0; nc!=m_tracklocation.size(); ++nc) {
 
    auto p = event_data.m_particles[nc].begin(), pe =event_data.m_particles[nc].end();
    if(p==pe) continue;
 
    std::list<int>::const_iterator dif = event_data.m_difference[nc].begin();
 
    std::multimap<int,const Trk::PrepRawData*>::const_iterator c,ce = event_data.m_kinecluster.end();
 
    int n  = 69-m_tracklocation[nc].key().size();
    std::string s1; for(int i=0; i<n; ++i) s1.append(" "); s1.append("|");
    std::stringstream out;
    out<<"|----------------------------------------------------------------------------------------|\n";
    out<<"|                   "<<m_tracklocation[nc]<<s1<<"\n";
    out<<"|----------------------------------------------------------------------------------------|\n";
    out<<"|    #   pdg     kine   Ncl Ntr Nsp Lose     pT(MeV)    rapidity    radius          z    |\n";
    out<<"|----------------------------------------------------------------------------------------|\n";
    
    n = 0;
    for(; p!=pe; ++p) {
 
      const int uniqueID = HepMC::uniqueID(*p);
 
      c = event_data.m_kinecluster.find(uniqueID); if(c==ce) continue;
      const Trk::PrepRawData* d = (*c).second;
 
      PRD_MultiTruthCollection::const_iterator mce;
      PRD_MultiTruthCollection::const_iterator mc = findTruth(event_data,d,mce);
 
      Identifier ID    = d->identify();
      bool Q = false;
      for(; mc!=mce; ++mc) {
    if((*mc).first != ID) break;
    if(HepMC::uniqueID((*mc).second)==uniqueID) {Q=true; break;}
      }
 
      if(!Q) continue;
 
      const HepMC::ConstGenParticlePtr pa = (*mc).second.cptr();
 
      double           px =  pa->momentum().px();
      double           py =  pa->momentum().py();
      double           pz =  pa->momentum().pz();
      double           vx = pa->production_vertex()->position().x();
      double           vy = pa->production_vertex()->position().y();
      double           vz = pa->production_vertex()->position().z();
      double           pt = std::sqrt(px*px+py*py);
      double           t  = std::atan2(pt,pz);
      double           ra =-std::log(std::tan(.5*t));
      double           r  = std::sqrt(vx*vx+vy*vy);
      ++n;
      out<<"| "
         <<std::setw(4)<<n
           <<std::setw(6)<<pa->pdg_id()
           <<std::setw(10)<<HepMC::barcode(pa)
           <<std::setw(4)<<event_data.m_kinecluster   .count(uniqueID)
           <<std::setw(4)<<event_data.m_kinespacepoint.count(uniqueID)
           <<std::setw(4)<<(*dif)
           <<std::setw(12)<<std::setprecision(5)<<pt
           <<std::setw(12)<<std::setprecision(5)<<ra
           <<std::setw(12)<<std::setprecision(5)<<r
           <<std::setw(12)<<std::setprecision(5)<<vz
           <<"   |\n";
      ++dif;
 
    }
    out<<"|----------------------------------------------------------------------------------------|\n";
    ATH_MSG_INFO("\n"<<out.str());
  }
  return true;
}

outputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< Gaudi::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.

qualityTracksSelection()

int ITk::TrackClusterAssValidation::qualityTracksSelection ( ITk::TrackClusterAssValidation::EventData_t & event_data ) const

protected

Definition at line 851 of file ITkTrackClusterAssValidation.cxx.

{
  std::multimap<int,const Trk::PrepRawData*>::iterator c = event_data.m_kinecluster   .begin();
  std::multimap<int,const Trk::SpacePoint*>::iterator  s = event_data.m_kinespacepoint.begin();
 
  if( c == event_data.m_kinecluster.end()) {
    return 0;
  }
 
  if( s == event_data.m_kinespacepoint.end()) {
    return 0;
  }
 
  std::list<int> worskine;
 
  int          rp = 0;
  double      eta = 0.;
  int          t  = 0;
  int          k0 = (*c).first;
  int          q0 = k0*charge(event_data,(*c),rp);
  unsigned int nc = 1         ;
  
  auto coerceTo49 = [] (const size_t idx){
   return (idx<50) ? idx : 49;
  };
  
  for(++c; c!=event_data.m_kinecluster.end(); ++c) {
 
    if((*c).first==k0) {++nc; continue;}
    q0 = charge(event_data,(*c),rp,eta)*k0;
    //
    const size_t clusterIdx =coerceTo49(nc);
    ++event_data.m_eventStat.m_particleClusters   [clusterIdx];
    ++event_data.m_eventStat.m_particleClustersBTE[clusterIdx][rp];
    //
    int ns = event_data.m_kinespacepoint.count(k0);
    const size_t spacepointIdx =coerceTo49(ns);
    ++event_data.m_eventStat.m_particleSpacePoints   [spacepointIdx];
    ++event_data.m_eventStat.m_particleSpacePointsBTE[spacepointIdx][rp];
 
    if     (nc                        < minclusters(eta)   ) worskine.push_back(k0);
    else if(event_data.m_kinespacepoint.count(k0)< m_spcut   ) worskine.push_back(k0);
    else {
      event_data.m_particles[0].push_back(InDet::PartPropCache(q0,rp)); ++t;
    }
 
    k0 = (*c).first;
    q0 =charge(event_data,(*c),rp,eta)*k0;
    nc = 1         ;
  }
 
  ++event_data.m_eventStat.m_particleClusters   [coerceTo49(nc)];
  ++event_data.m_eventStat.m_particleClustersBTE[coerceTo49(nc)][rp];
  int ns = event_data.m_kinespacepoint.count(k0);
  ++event_data.m_eventStat.m_particleSpacePoints   [coerceTo49(ns)];
  ++event_data.m_eventStat.m_particleSpacePointsBTE[coerceTo49(ns)][rp];
 
  if     (nc                        < minclusters(eta)   ) worskine.push_back(k0);
  else if(event_data.m_kinespacepoint.count(k0)< m_spcut   ) worskine.push_back(k0);
  else {
    event_data.m_particles[0].push_back(InDet::PartPropCache(q0,rp)); ++t;
  }
  for(auto & pThisCluster: worskine) {
    event_data.m_kinecluster   .erase(pThisCluster);
    event_data.m_kinespacepoint.erase(pThisCluster);
  }
 
  for(c = event_data.m_kinecluster.begin(); c!= event_data.m_kinecluster.end(); ++c) {
    const Trk::PrepRawData*
    d = (*c).second;
    const InDetDD::SiDetectorElement*
    de= dynamic_cast<const InDetDD::SiDetectorElement*>(d->detectorElement());
    if (not de) continue;
    int q  = charge(event_data,*c,rp);
 
    if     (q<0) {
      if(de->isBarrel()) {
          de->isPixel() ? ++event_data.m_eventStat.m_nclustersNegBP : ++event_data.m_eventStat.m_nclustersNegBS;
      }
      else                                     {
          de->isPixel() ? ++event_data.m_eventStat.m_nclustersNegEP : ++event_data.m_eventStat.m_nclustersNegES;
      }
 
    }
    else if(q>0) {
      if(de->isBarrel()) {
        de->isPixel() ? ++event_data.m_eventStat.m_nclustersPosBP : ++event_data.m_eventStat.m_nclustersPosBS;
      }
      else                                     {
        de->isPixel() ? ++event_data.m_eventStat.m_nclustersPosEP : ++event_data.m_eventStat.m_nclustersPosES;
      }
    }
  }
 
 
 
  for(const auto& p: event_data.m_particles[0]) {
    for(SG::ReadHandleKeyArray<TrackCollection>::size_type nc=1; nc<m_tracklocation.size(); ++nc) event_data.m_particles[nc].push_back(p);
  }
  return t;
}

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< Gaudi::Algorithm > >::renounce ( T & h )

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

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

renounceArray()

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

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

setFilterPassed()

virtual void AthCommonReentrantAlgorithm< Gaudi::Algorithm >::setFilterPassed ( bool state, const EventContext & ctx ) const

inlinevirtualinherited

Definition at line 100 of file AthCommonReentrantAlgorithm.h.

                                                                            {
    execState( ctx ).setFilterPassed( state );
  }

sysExecute()

StatusCode AthCommonReentrantAlgorithm< Gaudi::Algorithm >::sysExecute ( const EventContext & ctx )

overridevirtualinherited

Execute an algorithm.

We override this in order to work around an issue with the Algorithm base class storing the event context in a member variable that can cause crashes in MT jobs.

Definition at line 85 of file AthCommonReentrantAlgorithm.cxx.

{
  return BaseAlg::sysExecute (ctx);
}

sysInitialize()

StatusCode AthCommonReentrantAlgorithm< Gaudi::Algorithm >::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< Gaudi::Algorithm > >.

Reimplemented in HypoBase, and InputMakerBase.

Definition at line 61 of file AthCommonReentrantAlgorithm.cxx.

                                                               {
  StatusCode sc=AthCommonDataStore<AthCommonMsg<BaseAlg>>::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< Gaudi::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.

tracksComparison()

void ITk::TrackClusterAssValidation::tracksComparison ( const EventContext & ctx, ITk::TrackClusterAssValidation::EventData_t & event_data ) const

protected

Definition at line 957 of file ITkTrackClusterAssValidation.cxx.

{
  if(!event_data.m_nqtracks) return;
 
 
  int nc = -1;
  event_data.m_trackcontainer.reserve(m_tracklocation.size());
  for(const SG::ReadHandleKey<TrackCollection> &track_key : m_tracklocation ) {
    if(++nc >= 100) return;
    event_data.m_tracks[nc].clear();
 
    event_data.m_trackcontainer.emplace_back(track_key,ctx );
    if (!event_data.m_trackcontainer.back().isValid()) {
      continue;
    }
 
    // Loop through all found tracks
    //
    TrackCollection::const_iterator t,te = event_data.m_trackcontainer.back()->end();
 
    int KINE[200],NKINE[200];
 
    for (t=event_data.m_trackcontainer.back()->begin(); t!=te; ++t) {
 
      Trk::TrackStates::const_iterator s = (*t)->trackStateOnSurfaces()->begin(),
                                       se = (*t)->trackStateOnSurfaces()->end();
 
      int  NK  = 0;
      int  NC  = 0;
      int  N0  = 0;
      int  nkm = 0;
      bool qp  = false;
 
      const Trk::TrackParameters* tpf = (*s)->trackParameters();  if(!tpf) continue;
      const AmgVector(5)&         Vpf = tpf ->parameters     ();
      double                      pTf = std::abs(std::sin(Vpf[3])/Vpf[4]);
      double                     etaf = std::abs(log(tan(.5*Vpf[3])));
      bool                        qTf = pTf > minpT(etaf);
      for(; s!=se; ++s) {
 
    if(!qp) {
 
      const Trk::TrackParameters* tp = (*s)->trackParameters();
 
      if(tp) {
        qp = true;
        const AmgVector(5)& Vp = tp->parameters();
        double pT  = std::sin(Vp[3])/Vp[4]  ;
        double rap = std::abs(std::log(std::tan(.5*Vp[3])));
        double minpt = minpT(rap);
        if     (pT >  minpt && pT <  m_ptcutmax) {
          if     (rap <      1. ) ++event_data.m_trackCollectionStat[nc].m_ntracksPOSB;
          else if(rap < 3.0) ++event_data.m_trackCollectionStat[nc].m_ntracksPOSE;
          else if(rap < m_rapcut) ++event_data.m_trackCollectionStat[nc].m_ntracksPOSFWD;
        }
        else if(pT < -minpt && pT > -m_ptcutmax) {
          if     (rap <      1. ) ++event_data.m_trackCollectionStat[nc].m_ntracksNEGB;
              else if(rap < 3.0) ++event_data.m_trackCollectionStat[nc].m_ntracksNEGE;
          else if(rap < m_rapcut) ++event_data.m_trackCollectionStat[nc].m_ntracksNEGFWD;
        }
      }
    }
 
    if(!m_useOutliers && !(*s)->type(Trk::TrackStateOnSurface::Measurement)) continue;
 
    const Trk::MeasurementBase* mb = (*s)->measurementOnTrack();
    if(!mb) continue;
 
    const Trk::RIO_OnTrack*     ri = dynamic_cast<const Trk::RIO_OnTrack*>(mb);
    if(!ri) continue;
 
    const Trk::PrepRawData*     rd = ri->prepRawData();
    if(!rd) continue;
 
    const InDet::SiCluster*     si = dynamic_cast<const InDet::SiCluster*>(rd);
    if(!si) continue;
 
    if(!m_usePix && dynamic_cast<const InDet::PixelCluster*>(si)) continue;
    if(!m_useStrip && dynamic_cast<const InDet::SCT_Cluster*> (si)) continue;
 
 
    int Kine[1000], nk=kine0(event_data,rd,Kine,999); ++NC; if(!nk) ++N0;
 
    for(int k = 0; k!=nk; ++k) {
 
      int n = 0;
      for(; n!=NK; ++n) {if(Kine[k]==KINE[n]) {++NKINE[n]; break;}}
      if(n==NK) {KINE[NK] = Kine[k]; NKINE[NK] = 1; if (NK < 200) ++NK;}
    }
    for(int n=0; n!=NK; ++n) {if(NKINE[n]>nkm) nkm = NKINE[n];}
      }
 
      for(int n=0; n!=NK; ++n) {
    if(NKINE[n]==nkm) {
      int NQ = 1000*NKINE[n]+(NC-NKINE[n]);
 
      event_data.m_tracks[nc].insert(std::make_pair(KINE[n],NQ));
      if(qTf) {
        if(NC-N0 > 2) {
          ++event_data.m_trackCollectionStat[nc].m_total[NC]; if(NC-NKINE[n] > 2) {++event_data.m_trackCollectionStat[nc].m_fake[NC];}
        }
      }
    }
      }
    }
 
  }
}

updateVHKA()

void AthCommonDataStore< AthCommonMsg< Gaudi::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

ATLAS_THREAD_SAFE [1/2]

std::vector<InDet::TrackCollectionStat_t> m_trackCollectionStat ITk::TrackClusterAssValidation::ATLAS_THREAD_SAFE

mutableprotected

Definition at line 58 of file ITkTrackClusterAssValidation.h.

ATLAS_THREAD_SAFE [2/2]

InDet::EventStat_t m_eventStat ITk::TrackClusterAssValidation::ATLAS_THREAD_SAFE

mutableprotected

Definition at line 59 of file ITkTrackClusterAssValidation.h.

m_clcuts

UnsignedIntegerArrayProperty ITk::TrackClusterAssValidation::m_clcuts {this, "MinNumberClustersCuts", {}}

protected

Definition at line 70 of file ITkTrackClusterAssValidation.h.

{this, "MinNumberClustersCuts", {}};

m_clustersPixelname

SG::ReadHandleKey<InDet::SiClusterContainer> ITk::TrackClusterAssValidation::m_clustersPixelname {this, "PixelClusterContainer", "ITkPixelClusters"}

protected

Definition at line 84 of file ITkTrackClusterAssValidation.h.

{this, "PixelClusterContainer", "ITkPixelClusters"};

m_clustersStripname

SG::ReadHandleKey<InDet::SiClusterContainer> ITk::TrackClusterAssValidation::m_clustersStripname {this, "StripClusterContainer", "ITkStripClusters"}

protected

Definition at line 82 of file ITkTrackClusterAssValidation.h.

{this, "StripClusterContainer", "ITkStripClusters"};

m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

m_etabins

FloatArrayProperty ITk::TrackClusterAssValidation::m_etabins {this, "EtaBins", {}}

protected

Definition at line 68 of file ITkTrackClusterAssValidation.h.

{this, "EtaBins", {}};

m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

m_extendedExtraObjects

DataObjIDColl AthCommonReentrantAlgorithm< Gaudi::Algorithm >::m_extendedExtraObjects

privateinherited

Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks.

Empty if no symlinks were found.

Definition at line 114 of file AthCommonReentrantAlgorithm.h.

m_pdg

IntegerProperty ITk::TrackClusterAssValidation::m_pdg {this, "pdgParticle", 0}

protected

Definition at line 55 of file ITkTrackClusterAssValidation.h.

{this, "pdgParticle", 0};

m_pixelDetEleCollKey

SG::ReadCondHandleKey<InDetDD::SiDetectorElementCollection> ITk::TrackClusterAssValidation::m_pixelDetEleCollKey {this, "PixelDetEleCollKey", "ITkPixelDetectorElementCollection", "Key of SiDetectorElementCollection for Pixel"}

protected

Definition at line 92 of file ITkTrackClusterAssValidation.h.

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

m_ptcut

FloatProperty ITk::TrackClusterAssValidation::m_ptcut {this, "MomentumCut", {}}

protected

Definition at line 64 of file ITkTrackClusterAssValidation.h.

{this, "MomentumCut", {}};

m_ptcutmax

FloatProperty ITk::TrackClusterAssValidation::m_ptcutmax {this, "MomentumMaxCut", 1.e20}

protected

Definition at line 62 of file ITkTrackClusterAssValidation.h.

{this, "MomentumMaxCut", 1.e20};

m_ptcuts

FloatArrayProperty ITk::TrackClusterAssValidation::m_ptcuts {this, "PtCuts", {}}

protected

Definition at line 69 of file ITkTrackClusterAssValidation.h.

{this, "PtCuts", {}};

m_rapcut

FloatProperty ITk::TrackClusterAssValidation::m_rapcut {this, "RapidityCut", 4.0}

protected

Definition at line 63 of file ITkTrackClusterAssValidation.h.

{this, "RapidityCut", 4.0};

m_rmax

FloatProperty ITk::TrackClusterAssValidation::m_rmax {this, "RadiusMax", 20.}

protected

Definition at line 66 of file ITkTrackClusterAssValidation.h.

{this, "RadiusMax", 20.};

m_rmin

FloatProperty ITk::TrackClusterAssValidation::m_rmin {this, "RadiusMin", 0.}

protected

Definition at line 65 of file ITkTrackClusterAssValidation.h.

{this, "RadiusMin", 0.};

m_spacepointsOverlapname

SG::ReadHandleKey<SpacePointOverlapCollection> ITk::TrackClusterAssValidation::m_spacepointsOverlapname {this, "SpacePointsOverlapName", "ITkOverlapSpacePoints"}

protected

Definition at line 80 of file ITkTrackClusterAssValidation.h.

{this, "SpacePointsOverlapName", "ITkOverlapSpacePoints"};

m_spacepointsPixelname

SG::ReadHandleKey<SpacePointContainer> ITk::TrackClusterAssValidation::m_spacepointsPixelname {this, "SpacePointsPixelName", "ITkPixelSpacePoints"}

protected

Definition at line 78 of file ITkTrackClusterAssValidation.h.

{this, "SpacePointsPixelName", "ITkPixelSpacePoints"};

m_spacepointsStripname

SG::ReadHandleKey<SpacePointContainer> ITk::TrackClusterAssValidation::m_spacepointsStripname {this, "SpacePointsStripName", "ITkStripSpacePoints"}

protected

Definition at line 76 of file ITkTrackClusterAssValidation.h.

{this, "SpacePointsStripName", "ITkStripSpacePoints"};

m_spcut

UnsignedIntegerProperty ITk::TrackClusterAssValidation::m_spcut {this, "MinNumberSpacePoints", 3}

protected

Definition at line 61 of file ITkTrackClusterAssValidation.h.

{this, "MinNumberSpacePoints", 3};

m_statMutex

std::mutex ITk::TrackClusterAssValidation::m_statMutex

mutableprotected

Definition at line 57 of file ITkTrackClusterAssValidation.h.

m_StripDetEleCollKey

SG::ReadCondHandleKey<InDetDD::SiDetectorElementCollection> ITk::TrackClusterAssValidation::m_StripDetEleCollKey {this, "StripDetEleCollKey", "ITkStripDetectorElementCollection", "Key of SiDetectorElementCollection for Strip"}

protected

Definition at line 94 of file ITkTrackClusterAssValidation.h.

{this, "StripDetEleCollKey", "ITkStripDetectorElementCollection", "Key of SiDetectorElementCollection for Strip"};

m_tcut

float ITk::TrackClusterAssValidation::m_tcut = 0

protected

Definition at line 72 of file ITkTrackClusterAssValidation.h.

m_tracklocation

SG::ReadHandleKeyArray<TrackCollection> ITk::TrackClusterAssValidation::m_tracklocation {this, "TracksLocation", {"CombinedITkTracks"}}

protected

Definition at line 74 of file ITkTrackClusterAssValidation.h.

{this, "TracksLocation", {"CombinedITkTracks"}};

m_truth_locationPixel

SG::ReadHandleKey<PRD_MultiTruthCollection> ITk::TrackClusterAssValidation::m_truth_locationPixel {this, "TruthLocationPixel", "PRD_MultiTruthITkPixel"}

protected

Definition at line 86 of file ITkTrackClusterAssValidation.h.

{this, "TruthLocationPixel", "PRD_MultiTruthITkPixel"};      

m_truth_locationStrip

SG::ReadHandleKey<PRD_MultiTruthCollection> ITk::TrackClusterAssValidation::m_truth_locationStrip {this, "TruthLocationStrip", "PRD_MultiTruthITkStrip"}

protected

Definition at line 88 of file ITkTrackClusterAssValidation.h.

{this, "TruthLocationStrip", "PRD_MultiTruthITkStrip"};

m_useOutliers

BooleanProperty ITk::TrackClusterAssValidation::m_useOutliers {this, "useOutliers", false}

protected

Definition at line 54 of file ITkTrackClusterAssValidation.h.

{this, "useOutliers", false};

m_usePix

BooleanProperty ITk::TrackClusterAssValidation::m_usePix {this, "usePixel", true}

protected

Definition at line 52 of file ITkTrackClusterAssValidation.h.

{this, "usePixel", true};

m_useStrip

BooleanProperty ITk::TrackClusterAssValidation::m_useStrip {this, "useStrip", true}

protected

Definition at line 53 of file ITkTrackClusterAssValidation.h.

{this, "useStrip", true};

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_vhka

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

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

---

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

• ITkTrackClusterAssValidation.h
• ITkTrackClusterAssValidation.cxx