InDet::SCT_ClusterValidationNtupleWriter Class Reference

Validation Algorithm to retrieve a SCT_ClusterContainer, loop over the entries and fill the validation ntuple with RIO specific entries. More...

#include <SCT_ClusterValidationNtupleWriter.h>

Inheritance diagram for InDet::SCT_ClusterValidationNtupleWriter:

Public Member Functions
	SCT_ClusterValidationNtupleWriter (const std::string &name, ISvcLocator *pSvcLocator)
	Standard Athena-Algorithm Constructor.
	~SCT_ClusterValidationNtupleWriter ()=default
	Default Destructor.
virtual StatusCode	initialize () override
	standard Athena-Algorithm method
virtual StatusCode	execute () override
	standard Athena-Algorithm method
virtual StatusCode	finalize () override
	standard Athena-Algorithm method
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
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
const SCT_ID *	m_sctid
	SCT ID helper.
const InDet::SCT_ClusterContainer *	m_riocontainer
	container of RIOs
SG::ReadHandleKey< xAOD::EventInfo >	m_eventInfoKey {this, "EventInfoKey", "EventInfo", "key for xAOD::EventInfo"}
SG::ReadHandleKey< SCT_ClusterContainer >	m_jo_riocontainername {this, "SCT_ClusterContainer", "SCT_Clusters", "jobOption: name of container with RIOs"}
SG::ReadHandleKey< SCT_RDO_Container >	m_dataObjectName {this, "SCT_RDOContainer", "SCT_RDOs", "Data object name: for the SCT this is SCT_RDOs"}
SG::ReadHandleKey< SpacePointContainer >	m_spacePointContainerName {this, "SCT_SpacePointContainer", "SCT_SpacePoints", "SpacePoint container name: for the SCT this is SCT_SpacePoints"}
SG::ReadHandleKey< TrackCollection >	m_inputTrackCollection {this, "SCT_InputTrackCollection", "CombinedInDetTracks", "TrackCollection name, needed for hits-on-tracks, default is CombinedInDetTracks"}
SG::ReadCondHandleKey< InDetDD::SiDetectorElementCollection >	m_SCTDetEleCollKey {this, "SCTDetEleCollKey", "SCT_DetectorElementCollection", "Key of SiDetectorElementCollection for SCT"}
ToolHandle< ISCT_ByteStreamErrorsTool >	m_byteStreamErrTool {this, "ByteStreamErrTool", "SCT_ByteStreamErrorsTool", "Tool to retrieve SCT ByteStream Errors"}
ToolHandle< ISCT_CablingTool >	m_cabling {this, "SCT_CablingTool", "SCT_CablingTool", "Tool to retrieve SCT Cabling"}
StringProperty	m_ntupleFileName {this, "NtupleFileName", "/NTUPLES/FILE1"}
	jobOption: Ntuple file name
StringProperty	m_ntupleDirName {this, "NtupleDirectoryName", "FitterValidation"}
	jobOption: Ntuple directory name
StringProperty	m_ntupleTreeName {this, "NtupleTreeName", "RIOs"}
	jobOption: Ntuple tree name
BooleanProperty	m_fillCluster {this, "FillCluster", false}
	flag to book, access and fill Cluster or not
BooleanProperty	m_fillRDO {this, "FillRDO", true}
	flag to book, access and fill RDO or not
BooleanProperty	m_fillSpacePoint {this, "FillSpacePoint", false}
	flag to book, access and fill SpacePoints or not
BooleanProperty	m_fillBSErrs {this, "FillBSErrs", true}
	flag to book, access and fill ByteStream errors or not
BooleanProperty	m_doHitsOnTracks {this, "DoHitsOnTracks", false}
	flag to book, access and fill RDO isOnTrack or not
TTree *	m_nt
	pointer to the ntuple tree.
int	m_runNumber
	run number
int	m_eventNumber
	event number for current PRD vector
int	m_lumiBlock
	event lumi block information
int	m_timeStamp
	event time stamp
int	m_bunchCrossing
	event bunch crossing ID
int	m_nRIOs
	number of RIOs, i.e.
std::vector< float > *	m_rioLoc1
	local x coordinate of strip UNIT:mm
std::vector< float > *	m_rioSurfaceX
	global x coordinate of SCT wafer center UNIT:mm
std::vector< float > *	m_rioSurfaceY
	global x coordinate of SCT wafer center UNIT:mm
std::vector< float > *	m_rioSurfaceZ
	global x coordinate of SCT wafer center UNIT:mm
std::vector< int > *	m_SctBarrelEndcap
	from IdHelper: pos/neg barrel (+/-1) and pos/neg endcap (+/-2) UNIT:1:bar, 2:ec
std::vector< int > *	m_SctLayerDisk
	from IdHelper: layer/disk index
std::vector< int > *	m_SctEtaModule
	from IdHelper: module index in eta
std::vector< int > *	m_SctPhiModule
	from IdHelper: module index in phi
std::vector< int > *	m_SctSide
	from IdHelper: side index (0/1)
std::vector< float > *	m_SctDeltaPhi
	please provide description!
std::vector< float > *	m_SctHitErr
	please provide description!
int	m_nSP
std::vector< int > *	m_sp_bec
	Barrel or endcap index (barrel: 0, endcap: +/-2) for SpacePoint.
std::vector< int > *	m_sp_layer
	index of the SCT-layer in which the SCT wafer is positioned for SpacePoint
std::vector< int > *	m_sp_eta
	eta index of the SCT-layer in which the SCT wafer is positioned for SpacePoint
std::vector< int > *	m_sp_phi
	phi index of the SCT-layer in which the SCT wafer is positioned for SpacePoint
std::vector< float > *	m_sp_x
	x position of SpacePoint in ATLAS coordinate system (mm)
std::vector< float > *	m_sp_y
	y position of SpacePoint in ATLAS coordinate system (mm)
std::vector< float > *	m_sp_z
	z position of SpacePoint in ATLAS coordinate system (mm)
int	m_nRDOs
	Number of RDOs.
std::vector< int > *	m_sct_rdoGroupSize
	RDO group size.
std::vector< int > *	m_sct_rdoIsOnTrack
	RDO on track.
std::vector< int > *	m_sct_layer
	index of the SCT-layer in which the SCT wafer is positioned
std::vector< int > *	m_sct_eta
	eta of the SCT wafer
std::vector< int > *	m_sct_phi
	phi of the SCT wafer
std::vector< int > *	m_sct_side
	side of the SCT wafer (0 or 1) within the SCT module
std::vector< int > *	m_sct_barrelec
	barrel/endcap index (barrel: 0, endcap: +/-2)
std::vector< int > *	m_sct_firstStrip
	index (could be from 0 to 767) of the fired strip within the SCT wafer
std::vector< int > *	m_sct_numHitsInWafer
	number of hits in the SCT wafer
std::vector< int > *	m_sct_waferHash
	index (could be from 0 to 8175) of the fired SCT wafer
std::vector< int > *	m_sct_tbin
	timebin of the RDO
std::vector< int > *	m_sct_rodid
	ROD ID of the RDO.
std::vector< int > *	m_sct_channel
	channel within ROD of the RDO
int	m_totalNumErrors
	total number of BS errors.
std::vector< int > *	m_scterr_bec
	barrel/endcap index (barrel: 0, endcap: +/-2)
std::vector< int > *	m_scterr_layer
	layer (barrel) or disk (endcap) of wafer with the error
std::vector< int > *	m_scterr_eta
	eta of the SCT wafer
std::vector< int > *	m_scterr_phi
	phi of the SCT wafer
std::vector< int > *	m_scterr_side
	side of the SCT wafer (0 or 1) within the module
std::vector< int > *	m_scterr_rodid
	online ID of ROD containing link
std::vector< int > *	m_scterr_channel
	online channel no.
std::vector< int > *	m_scterr_type
	type of BS error (as defined in SCT_ByteStreamErrs enum in ISCT_ByteStreamErrorsSvc.h)
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

Validation Algorithm to retrieve a SCT_ClusterContainer, loop over the entries and fill the validation ntuple with RIO specific entries.

Author

Sebas.nosp@m.tian.nosp@m..Flei.nosp@m.schm.nosp@m.ann@c.nosp@m.ern..nosp@m.ch

Peter.nosp@m..Van.nosp@m.kov@c.nosp@m.ern..nosp@m.ch

Definition at line 44 of file SCT_ClusterValidationNtupleWriter.h.

Member Typedef Documentation

StoreGateSvc_t

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

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

SCT_ClusterValidationNtupleWriter()

InDet::SCT_ClusterValidationNtupleWriter::SCT_ClusterValidationNtupleWriter	(	const std::string &	name,
		ISvcLocator *	pSvcLocator )

Standard Athena-Algorithm Constructor.

Definition at line 32 of file SCT_ClusterValidationNtupleWriter.cxx.

                                                                                                                        :
  AthAlgorithm(name, pSvcLocator),
  m_sctid{nullptr},
  m_riocontainer{nullptr},
  m_nt{nullptr},
  m_runNumber{0},
  m_eventNumber{0},
  m_lumiBlock{0},
  m_timeStamp{0},
  m_bunchCrossing{0},
  m_nRIOs{0},
  m_rioLoc1{nullptr},
  m_rioSurfaceX{nullptr},
  m_rioSurfaceY{nullptr},
  m_rioSurfaceZ{nullptr},
  m_SctBarrelEndcap{nullptr},
  m_SctLayerDisk{nullptr},
  m_SctEtaModule{nullptr},
  m_SctPhiModule{nullptr},
  m_SctSide{nullptr},
  m_SctDeltaPhi{nullptr},
  m_SctHitErr{nullptr},
  m_nSP{0},
  m_sp_bec{nullptr},
  m_sp_layer{nullptr},
  m_sp_eta{nullptr},
  m_sp_phi{nullptr},
  m_sp_x{nullptr},
  m_sp_y{nullptr},
  m_sp_z{nullptr},
  m_nRDOs{0},
  m_sct_rdoGroupSize{nullptr},
  m_sct_rdoIsOnTrack{nullptr},
  m_sct_layer{nullptr},
  m_sct_eta{nullptr},
  m_sct_phi{nullptr},
  m_sct_side{nullptr},
  m_sct_barrelec{nullptr},
  m_sct_firstStrip{nullptr},
  m_sct_numHitsInWafer{nullptr},
  m_sct_waferHash{nullptr},
  m_sct_tbin{nullptr},
  m_sct_rodid{nullptr},
  m_sct_channel{nullptr},
  m_totalNumErrors{0},
  m_scterr_bec{nullptr},
  m_scterr_layer{nullptr},
  m_scterr_eta{nullptr},
  m_scterr_phi{nullptr},
  m_scterr_side{nullptr},
  m_scterr_rodid{nullptr},
  m_scterr_channel{nullptr},
  m_scterr_type{nullptr}
 
  {
  }

~SCT_ClusterValidationNtupleWriter()

InDet::SCT_ClusterValidationNtupleWriter::~SCT_ClusterValidationNtupleWriter ( )

default

Default Destructor.

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 InDet::SCT_ClusterValidationNtupleWriter::execute ( )

overridevirtual

standard Athena-Algorithm method

end of m_fillRDO

get the position in real space

get online rodid and channel no. from ID hash using cabling

Fill ByteStream errors block if requested.

types of errors are defined in the enum in ISCT_ByteStreamErrorsSvc. At the moment there are 15 different types of BS error.

get online rodid and channel no. from ID hash using cabling

Definition at line 243 of file SCT_ClusterValidationNtupleWriter.cxx.

                                                           {
 
  //-------------
  // get some event properties    
  SG::ReadHandle<xAOD::EventInfo> eventInfo(m_eventInfoKey);
  if (not eventInfo.isValid()) {
    ATH_MSG_ERROR( "Could not retrieve event info" );
  }
  m_runNumber     = eventInfo->runNumber(); 
  m_eventNumber   = eventInfo->eventNumber();
  m_lumiBlock     = eventInfo->lumiBlock();
  m_timeStamp     = eventInfo->timeStamp();
  m_bunchCrossing = eventInfo->bcid();
 
  // reset variables
  m_nRIOs = 0;
  m_rioLoc1->clear();
  m_rioSurfaceX->clear();
  m_rioSurfaceY->clear();
  m_rioSurfaceZ->clear();
  m_SctBarrelEndcap->clear();
  m_SctLayerDisk->clear();
  m_SctEtaModule->clear();
  m_SctPhiModule->clear();
  m_SctSide->clear();
  m_SctDeltaPhi->clear();
  m_SctHitErr->clear();
    
  m_nRDOs = 0;
  m_sct_rdoGroupSize->clear();
  m_sct_rdoIsOnTrack->clear();
  m_sct_layer->clear();
  m_sct_eta->clear();
  m_sct_phi->clear();
  m_sct_side->clear();
  m_sct_barrelec->clear();
  m_sct_firstStrip->clear();
  m_sct_numHitsInWafer->clear();
  m_sct_waferHash->clear();
  m_sct_tbin->clear();
  m_sct_rodid->clear();
  m_sct_channel->clear();
    
  m_nSP = 0;
  m_sp_bec->clear();
  m_sp_layer->clear();
  m_sp_eta->clear();
  m_sp_phi->clear();
  m_sp_x->clear();
  m_sp_y->clear();
  m_sp_z->clear();
 
  m_totalNumErrors = 0;
  m_scterr_bec->clear();
  m_scterr_layer->clear();
  m_scterr_eta->clear();
  m_scterr_phi->clear();
  m_scterr_side->clear();
  m_scterr_rodid->clear();
  m_scterr_channel->clear();
  m_scterr_type->clear();
 
  // Retrieve containers which are required
 
  // Container with SCT RIOs
  m_riocontainer = nullptr;
  if ( m_fillCluster.value()) {
    SG::ReadHandle<SCT_ClusterContainer> h_riocontainer(m_jo_riocontainername);
    if (not h_riocontainer.isValid()) {
      ATH_MSG_DEBUG("Could not get PrepRawDataContainer");
    } else {
      m_riocontainer = &*h_riocontainer;
    }
  }
 
  // SpacePoint container
  const SpacePointContainer* p_spContainer = nullptr;
  if (m_fillSpacePoint.value()) {
    SG::ReadHandle<SpacePointContainer> h_spContainer(m_spacePointContainerName);
    if (not h_spContainer.isValid()) {
      ATH_MSG_DEBUG("Could not get SpacePointContainer");
    } else {
      p_spContainer = &*h_spContainer;
    }
  }
 
  // RDO container
  using SCTRawDataType = SCT_RDORawData;
  const SCT_RDO_Container* p_rdocontainer = nullptr;
  std::vector<Identifier> RDOsOnTracks;
  if (m_fillRDO.value()) {
    SG::ReadHandle<SCT_RDO_Container> h_rdocontainer(m_dataObjectName);
    if (not h_rdocontainer.isValid()) {
      ATH_MSG_DEBUG( "Failed to retrieve SCT RDO container" );
    } else {
      p_rdocontainer = &*h_rdocontainer;
    }
    if (m_doHitsOnTracks.value()) {
      //Track container
      SG::ReadHandle<TrackCollection> tracks(m_inputTrackCollection);
      if (not tracks.isValid()) {
        ATH_MSG_ERROR("Track container not found");
      } else {
        // assemble list of RDOs on Tracks   
        for (int i=0; i<(int)tracks->size(); i++) {
          const Trk::Track *track=(*tracks)[i];
          if (track == nullptr) {
            ATH_MSG_ERROR("no pointer to track!");
            break;
          }
          // Get pointer to track state on surfaces
          const Trk::TrackStates* trackStates=track->trackStateOnSurfaces();
          if (trackStates == nullptr) {
            ATH_MSG_WARNING("for current track is TrackStateOnSurfaces == Null, no data will be written for this track");
          } else {
            // Loop over all track states on surfaces
            for (Trk::TrackStates::const_iterator it=trackStates->begin(); it!=trackStates->end(); ++it) {
              // Get pointer to RIO of right type
              const InDet::SiClusterOnTrack *clus =
                dynamic_cast<const InDet::SiClusterOnTrack*>((*it)->measurementOnTrack());
              if (clus) {
                // Get Pointer to prepRawDataObject
                const InDet::SiCluster *RawDataClus
                  = dynamic_cast<const InDet::SiCluster*>(clus->prepRawData());
                if (RawDataClus==nullptr) {
                  ATH_MSG_WARNING("SiCluster WITHOUT prepRawData!!!!");
                  break;
                }
                // if Cluster is in SCT ...
                if (RawDataClus->detectorElement()->isSCT()) {
      
                  const std::vector<Identifier>& rdoList = RawDataClus->rdoList();
                  RDOsOnTracks.insert(RDOsOnTracks.end(),rdoList.begin(),rdoList.end());
                }
              }
            }
          }
        }
      } 
    } // end of m_doHitsOnTracks
  } 
 
    
    // Fill clusters
  if (m_fillCluster.value() && m_riocontainer !=nullptr) {
 
    int RIOindex = 0;
 
    // -----------------------
    // get all the RIO_Collections in the container
    InDet::SCT_ClusterContainer::const_iterator containerIterator = m_riocontainer->begin();
    for( ; containerIterator != m_riocontainer->end(); ++containerIterator) {
      ATH_MSG_DEBUG( "There are "  << (*containerIterator)->size() << " entries in the PrepRawDataCollection" );
 
      // ---------------------------------
      //get all the RIOs in the collection
 
      InDet::SCT_ClusterCollection::const_iterator rioIterator = (*containerIterator)->begin();
      for (; rioIterator != (*containerIterator)->end(); ++rioIterator) {
        // get the surface center of the RIO
        if (!(*rioIterator)) {
          ATH_MSG_WARNING( "nullptr to RIO" );
          continue;
        }
        if (!((*rioIterator)->detectorElement())) {
          ATH_MSG_WARNING( "in RIO: nullptr to detElement" );
          continue;
        }
   
        if (m_nRIOs >=500000) {
          ATH_MSG_WARNING( "reached max. number of RIO entries in the ntuple" );
          m_nt->Fill();
          return StatusCode::SUCCESS;
     
        }
        const Amg::Vector3D surfaceGlobPos = (*rioIterator)->detectorElement()->center( (*rioIterator)->identify() ) ;
        // fill surface global position
        m_rioSurfaceX->push_back(float(surfaceGlobPos.x()));
        m_rioSurfaceY->push_back(float(surfaceGlobPos.y()));
        m_rioSurfaceZ->push_back(float(surfaceGlobPos.z()));
        // get the local position of the RIO
        const Amg::Vector2D locPos = (*rioIterator)->localPosition();
        // fill local position
        m_rioLoc1->push_back(float(locPos[Trk::locX]));
   
        Identifier clId = (*rioIterator)->identify();  
        const SCT_Cluster& cluster = **rioIterator;
        const InDet::SiWidth&  width = cluster.width();
        m_SctDeltaPhi->push_back(float(width.phiR()));
        m_SctLayerDisk->push_back(int(m_sctid->layer_disk(clId)));
        m_SctEtaModule->push_back(int(m_sctid->eta_module(clId)));
        m_SctPhiModule->push_back(int(m_sctid->phi_module(clId)));
        m_SctSide->push_back(int(m_sctid->side(clId)));
        m_SctBarrelEndcap->push_back(int(m_sctid->barrel_ec(clId))) ; //endcap or barrel
        //determine hit error 
        //             bool SctCluster_is_1dim = (cluster.localParameters().parameterKey() == 1);
        /*if (SctCluster_is_1dim)*/ 
        m_SctHitErr->push_back( Amg::error(cluster.localCovariance(),1));
        //             else {
        //               HepSymMatrix CovMat;
        //               CovMat = cluster.localErrorMatrix();covariance();
        //               if (CovMat.num_col() == 2) {
        //               //ATH_MSG_DEBUG( "hit CovMat:" << CovMat[0,0]  << " " << CovMat[0,1] << " " );
        //               //ATH_MSG_DEBUG( "           " << CovMat[1,0]  << " " << CovMat[1,1] << " " );
        //                 const double hitErr = sqrt(CovMat[0][0]);
        //               }
        //               m_SctHitErr->push_back(hitErr);
        //  
        //             }
        // 
        // count the RIO
        RIOindex++;
      }
    }
    m_nRIOs = RIOindex;
  }

 
  if (m_fillSpacePoint.value() && p_spContainer != nullptr) {
    DataVector<Trk::SpacePoint>::const_iterator p_sp;
    std::pair<IdentifierHash, IdentifierHash> sp_clusInfo;
    //loop over SCT space points collections
    for(SpacePointContainer::const_iterator it=p_spContainer->begin(); it!=p_spContainer->end(); ++it) {
      const SpacePointCollection *colNext=&(**it);
      if (!colNext) continue;
 
      //loop over SpacePoints
      for(p_sp=colNext->begin(); p_sp!=colNext->end(); ++p_sp) {
        m_nSP++;
        const Trk::SpacePoint& sp = **p_sp;
        // Getting [layer/phi] from the one of the two clusters
        sp_clusInfo = sp.elementIdList();
        IdentifierHash first_clus = sp_clusInfo.first;
        Identifier waferId = m_sctid->wafer_id(first_clus);
        m_sp_bec->push_back(m_sctid->barrel_ec(waferId));
        m_sp_layer->push_back(m_sctid->layer_disk(waferId));
        m_sp_phi->push_back(m_sctid->phi_module(waferId));
        m_sp_eta->push_back(m_sctid->eta_module(waferId));
        // HepPoint3D point = sp.globalPosition();
        Amg::Vector3D point = sp.globalPosition();
        m_sp_x->push_back(point.x());
        m_sp_y->push_back(point.y());
        m_sp_z->push_back(point.z());
      }
    }
  }
  if (m_fillRDO.value() && p_rdocontainer !=nullptr) {
 
    SCT_RDO_Container::const_iterator col_it  = p_rdocontainer->begin();
    SCT_RDO_Container::const_iterator lastCol = p_rdocontainer->end();
    for( ; col_it!= lastCol ; ++col_it) {
      const InDetRawDataCollection<SCTRawDataType>* SCT_Collection(*col_it);
        
      if (!SCT_Collection) continue;  // select only SCT RDOs
      Identifier theWaferIdOfTheRDOCollection =  SCT_Collection->identify();
      unsigned int theHashOfTheRDOCollection= m_sctid->wafer_hash(theWaferIdOfTheRDOCollection);
      uint32_t onlineID = m_cabling->getOnlineIdFromHash(theHashOfTheRDOCollection);
      SCT_OnlineId online(onlineID);
      uint32_t rod = online.rod();
      uint32_t fibre = online.fibre();
 
      DataVector<SCTRawDataType>::const_iterator p_rdo=SCT_Collection->begin() ;
      DataVector<SCTRawDataType>::const_iterator end_rdo = SCT_Collection->end();
      int totalNumberOfStrips=0;
      int thisBec = m_sctid->barrel_ec(theWaferIdOfTheRDOCollection);
      int thisLayerDisk = m_sctid->layer_disk(theWaferIdOfTheRDOCollection);
      int thisPhi = m_sctid->phi_module(theWaferIdOfTheRDOCollection);
      int thisEta = m_sctid->eta_module(theWaferIdOfTheRDOCollection);
      int thisSide = m_sctid->side(theWaferIdOfTheRDOCollection);
 
      m_nRDOs += SCT_Collection->size();
      for(; p_rdo!=end_rdo; ++p_rdo) {
 
        //  SCT RDO Group Size;
        m_sct_rdoGroupSize->push_back((*p_rdo)->getGroupSize());
        totalNumberOfStrips=totalNumberOfStrips+((*p_rdo)->getGroupSize());
 
        Identifier SCT_Identifier = (*p_rdo)->identify();
 
        //  SCT_ClusterStruct cluster;
        m_sct_firstStrip->push_back(m_sctid->strip(SCT_Identifier));
 
        //Identifier wafer_id =  m_sctid->wafer_id(SCT_Identifier); 
 
        m_sct_layer->push_back(thisLayerDisk);
        m_sct_eta->push_back(thisEta);
        m_sct_phi->push_back(thisPhi);
        m_sct_side->push_back(thisSide);
        m_sct_barrelec->push_back(thisBec);
        m_sct_numHitsInWafer->push_back(totalNumberOfStrips);
        m_sct_waferHash->push_back(theHashOfTheRDOCollection);
        const SCT3_RawData* rdo3 = dynamic_cast<const SCT3_RawData*>(*p_rdo);
        if (rdo3!=nullptr) {
          m_sct_tbin->push_back(rdo3->getTimeBin());
        } else {
          m_sct_tbin->push_back(-1);
        }
        m_sct_rodid->push_back(rod);
        m_sct_channel->push_back(fibre);
 
        if (m_doHitsOnTracks.value()) {
          int isOnTrack = 0;
          if (find(RDOsOnTracks.begin(),RDOsOnTracks.end(),SCT_Identifier) != RDOsOnTracks.end())
            isOnTrack = 1;
          m_sct_rdoIsOnTrack->push_back(isOnTrack);
        }
      }
    }
  }

  if (m_fillBSErrs.value()) {
    m_totalNumErrors = 0;
    for (int type=0; type < SCT_ByteStreamErrors::NUM_ERROR_TYPES; ++type) { 
      const std::set<IdentifierHash> errorSet = m_byteStreamErrTool->getErrorSet(type);
 
      int eta=0,phi=0,bec=0,layer=0,side=0;
      m_totalNumErrors += errorSet.size();
      for(const auto& idHash : errorSet) { 
        Identifier itId = m_sctid->wafer_id(idHash);
        layer = m_sctid->layer_disk(itId);
        side = m_sctid->side(itId);
        eta = m_sctid->eta_module(itId);
        phi = m_sctid->phi_module(itId);
        bec = m_sctid->barrel_ec(itId);
        m_scterr_type->push_back(type);
        m_scterr_bec->push_back(bec);
        m_scterr_layer->push_back(layer);
        m_scterr_eta->push_back(eta);
        m_scterr_phi->push_back(phi);
        m_scterr_side->push_back(side);

        uint32_t onlineID = m_cabling->getOnlineIdFromHash(idHash);
        SCT_OnlineId online(onlineID);
        uint32_t rod = online.rod();
        uint32_t fibre = online.fibre();
        m_scterr_rodid->push_back((int)rod);
        m_scterr_channel->push_back((int)fibre);
      }
      
    }
  }
  m_nt->Fill();
  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();
}

finalize()

StatusCode InDet::SCT_ClusterValidationNtupleWriter::finalize ( )

overridevirtual

standard Athena-Algorithm method

Definition at line 598 of file SCT_ClusterValidationNtupleWriter.cxx.

                                                            {
  ATH_MSG_INFO( "SCT_ClusterValidationNtupleWriter finalize()" );
  delete m_rioLoc1;
  delete m_rioSurfaceX;
  delete m_rioSurfaceY;
  delete m_rioSurfaceZ;
  delete m_SctBarrelEndcap;
  delete m_SctLayerDisk;
  delete m_SctEtaModule;
  delete m_SctPhiModule;
  delete m_SctSide;
  delete m_SctDeltaPhi;
  delete m_SctHitErr;
  delete m_sp_bec;
  delete m_sp_layer;
  delete m_sp_eta;
  delete m_sp_phi;
  delete m_sp_x;
  delete m_sp_y;
  delete m_sp_z;
  delete m_sct_rdoGroupSize;
  delete m_sct_rdoIsOnTrack;
  delete m_sct_layer;
  delete m_sct_eta;
  delete m_sct_phi;
  delete m_sct_side;
  delete m_sct_barrelec;
  delete m_sct_firstStrip;
  delete m_sct_numHitsInWafer;
  delete m_sct_waferHash;
  delete m_sct_tbin;
  delete m_sct_rodid;
  delete m_sct_channel;
  delete m_scterr_bec;
  delete m_scterr_layer;
  delete m_scterr_eta;
  delete m_scterr_phi;
  delete m_scterr_side;
  delete m_scterr_rodid;
  delete m_scterr_channel;
  delete m_scterr_type;
 
  m_rioLoc1=nullptr;
  m_rioSurfaceX=nullptr;
  m_rioSurfaceY=nullptr;
  m_rioSurfaceZ=nullptr;
  m_SctBarrelEndcap=nullptr;
  m_SctLayerDisk=nullptr;
  m_SctEtaModule=nullptr;
  m_SctPhiModule=nullptr;
  m_SctSide=nullptr;
  m_SctDeltaPhi=nullptr;
  m_SctHitErr=nullptr;
  m_sp_bec=nullptr;
  m_sp_layer=nullptr;
  m_sp_eta=nullptr;
  m_sp_phi=nullptr;
  m_sp_x=nullptr;
  m_sp_y=nullptr;
  m_sp_z=nullptr;
  m_sct_rdoGroupSize=nullptr;
  m_sct_rdoIsOnTrack=nullptr;
  m_sct_layer=nullptr;
  m_sct_eta=nullptr;
  m_sct_phi=nullptr;
  m_sct_side=nullptr;
  m_sct_barrelec=nullptr;
  m_sct_firstStrip=nullptr;
  m_sct_numHitsInWafer=nullptr;
  m_sct_waferHash=nullptr;
  m_sct_tbin=nullptr;
  m_sct_rodid=nullptr;
  m_sct_channel=nullptr;
  m_scterr_bec=nullptr;
  m_scterr_layer=nullptr;
  m_scterr_eta=nullptr;
  m_scterr_phi=nullptr;
  m_scterr_side=nullptr;
  m_scterr_rodid=nullptr;
  m_scterr_channel=nullptr;
  m_scterr_type=nullptr;
 
  return StatusCode::SUCCESS;
}

initialize()

StatusCode InDet::SCT_ClusterValidationNtupleWriter::initialize ( )

overridevirtual

standard Athena-Algorithm method

Definition at line 89 of file SCT_ClusterValidationNtupleWriter.cxx.

                                                              {
  
  ATH_CHECK(detStore()->retrieve(m_sctid, "SCT_ID"));
 
  if (m_fillBSErrs.value()) {
    ATH_CHECK(m_byteStreamErrTool.retrieve());
    ATH_MSG_INFO("Retrieved tool " << m_byteStreamErrTool);
 
    ATH_CHECK(m_cabling.retrieve());
    ATH_MSG_INFO("Retrieved tool " << m_cabling);
  } else {
    m_byteStreamErrTool.disable();
    m_cabling.disable();
  }
 
 
  // ---------------------------
  // retrieve pointer to THistSvc
  SmartIF<ITHistSvc> tHistSvc{Gaudi::svcLocator()->service("THistSvc")};
  ATH_CHECK(tHistSvc.isValid());
 
  // ---------------------------
  // create tree and register it to THistSvc
  m_nt = new TTree(TString(m_ntupleTreeName.value()), "SCT_Clusters");
  // NB: we must not delete the tree, this is done by THistSvc
  std::string fullNtupleName =  "/"+m_ntupleFileName.value()+"/"+m_ntupleDirName.value()+"/"+m_ntupleTreeName.value();
  StatusCode sc = tHistSvc->regTree(fullNtupleName, m_nt);
  if (sc.isFailure()) {
    ATH_MSG_ERROR( "Unable to register TTree : " << fullNtupleName );
    return sc;
  }
  //-----------------
  // add items
  // event info:
 
  m_nt->Branch("SCT_RunNumber",          &m_runNumber,     "run_number/I");      
  m_nt->Branch("SCT_EventNumber",        &m_eventNumber,   "event_number/I");      
  m_nt->Branch("SCT_LumiBlock",          &m_lumiBlock,     "lumi_block/I");      
  m_nt->Branch("SCT_TimeStamp",          &m_timeStamp,     "time_stamp/I");      
  m_nt->Branch("SCT_BunchCrossing",      &m_bunchCrossing, "bunch_crossing/I");      
  m_nt->Branch("SCT_nRIOs",              &m_nRIOs,         "Number_of_RIOs/I");
    
  // RIO info:
  m_rioLoc1       = new std::vector<float>();
  m_rioSurfaceX   = new std::vector<float>();
  m_rioSurfaceY   = new std::vector<float>();
  m_rioSurfaceZ   = new std::vector<float>();
  // SCT module info
  m_SctBarrelEndcap= new  std::vector<int>();
  m_SctLayerDisk   = new  std::vector<int>();
  m_SctEtaModule   = new  std::vector<int>();
  m_SctPhiModule   = new  std::vector<int>();
  m_SctSide        = new  std::vector<int>();
  m_SctDeltaPhi    = new  std::vector<float>();
  m_SctHitErr      = new  std::vector<float>();
  // SCT RDO info
  m_sct_rdoGroupSize            = new  std::vector<int>();
  m_sct_rdoIsOnTrack            = new  std::vector<int>();
  m_sct_layer                   = new  std::vector<int>();
  m_sct_eta                     = new  std::vector<int>();
  m_sct_phi                     = new  std::vector<int>();
  m_sct_side                    = new  std::vector<int>();
  m_sct_barrelec                = new  std::vector<int>();
  m_sct_firstStrip              = new  std::vector<int>();
  m_sct_numHitsInWafer          = new  std::vector<int>();
  m_sct_waferHash               = new  std::vector<int>();
  m_sct_tbin                    = new  std::vector<int>();
  m_sct_rodid                   = new  std::vector<int>();
  m_sct_channel                 = new  std::vector<int>();
  // SCT SpacePoint info
  m_sp_bec                      = new  std::vector<int>();
  m_sp_layer                    = new  std::vector<int>();
  m_sp_eta                      = new  std::vector<int>();
  m_sp_phi                      = new  std::vector<int>();
  m_sp_x                        = new  std::vector<float>();
  m_sp_y                        = new  std::vector<float>();
  m_sp_z                        = new  std::vector<float>();
  // SCT BS error info
  m_scterr_bec                  = new  std::vector<int>();
  m_scterr_layer                = new  std::vector<int>();
  m_scterr_eta                  = new  std::vector<int>();
  m_scterr_phi                  = new  std::vector<int>();
  m_scterr_side                 = new  std::vector<int>();
  m_scterr_rodid                = new  std::vector<int>();
  m_scterr_channel              = new  std::vector<int>();
  m_scterr_type                 = new  std::vector<int>();
 
  if (m_fillCluster.value()) {
    m_nt->Branch("SCT_DriftRadius", &m_rioLoc1); 
    m_nt->Branch("SCT_SurfaceX",    &m_rioSurfaceX); 
    m_nt->Branch("SCT_SurfaceY",    &m_rioSurfaceY); 
    m_nt->Branch("SCT_SurfaceZ",    &m_rioSurfaceZ); 
      
    m_nt->Branch("SCT_BarrelEndcap", &m_SctBarrelEndcap);
    m_nt->Branch("SCT_LayerDisk",    &m_SctLayerDisk);
    m_nt->Branch("SCT_EtaModule",    &m_SctEtaModule);
    m_nt->Branch("SCT_PhiModule",    &m_SctPhiModule);
    m_nt->Branch("SCT_Side",         &m_SctSide);
    m_nt->Branch("SCT_DeltaPhi",     &m_SctDeltaPhi);
    m_nt->Branch("SCT_HitErr",       &m_SctHitErr);
  }
  if (m_fillSpacePoint.value()) {
    m_nt->Branch("SP_SCT_nSpacePoints", &m_nSP);
    m_nt->Branch("SP_SCT_BarrelEndcap", &m_sp_bec);
    m_nt->Branch("SP_SCT_EtaModule",    &m_sp_eta);
    m_nt->Branch("SP_SCT_PhiModule",    &m_sp_phi);
    m_nt->Branch("SP_SCT_Layer",        &m_sp_layer);
    m_nt->Branch("SP_SCT_X",            &m_sp_x);
    m_nt->Branch("SP_SCT_Y",            &m_sp_y);
    m_nt->Branch("SP_SCT_Z",            &m_sp_z);
  }
  if (m_fillRDO.value()) {
    m_nt->Branch("RDO_SCT_nRDOs",                  &m_nRDOs);
    m_nt->Branch("RDO_SCT_RDO_Group_Size",         &m_sct_rdoGroupSize);
    m_nt->Branch("RDO_SCT_Layer",                  &m_sct_layer);
    m_nt->Branch("RDO_SCT_Eta",                    &m_sct_eta);
    m_nt->Branch("RDO_SCT_Phi",                    &m_sct_phi);
    m_nt->Branch("RDO_SCT_Side",                   &m_sct_side);
    m_nt->Branch("RDO_SCT_Barrelec",               &m_sct_barrelec);
    m_nt->Branch("RDO_SCT_FirstStrip",             &m_sct_firstStrip);
    m_nt->Branch("RDO_SCT_NumHitsInWafer",         &m_sct_numHitsInWafer);
    m_nt->Branch("RDO_SCT_WaferHash",              &m_sct_waferHash);
    m_nt->Branch("RDO_SCT_TimeBin",                &m_sct_tbin);
    m_nt->Branch("RDO_SCT_RODId",                  &m_sct_rodid);
    m_nt->Branch("RDO_SCT_Channel",                &m_sct_channel);
    if (m_doHitsOnTracks.value()) {
      m_nt->Branch("RDO_SCT_isOnTrack",              &m_sct_rdoIsOnTrack);
    }
  }
  if (m_fillBSErrs.value()) {
    m_nt->Branch("SCTErr_TotalNumBSErrs",         &m_totalNumErrors,"numBSerrs/I");
    m_nt->Branch("SCTErr_BEC",                    &m_scterr_bec);
    m_nt->Branch("SCTErr_Layer",                  &m_scterr_layer);
    m_nt->Branch("SCTErr_Eta",                    &m_scterr_eta);
    m_nt->Branch("SCTErr_Phi",                    &m_scterr_phi);
    m_nt->Branch("SCTErr_Side",                   &m_scterr_side);
    m_nt->Branch("SCTErr_RODId",                  &m_scterr_rodid);
    m_nt->Branch("SCTErr_Channel",                &m_scterr_channel);
    m_nt->Branch("SCTErr_Type",                   &m_scterr_type);
  }
 
  // Read Handle Key
  ATH_CHECK( m_eventInfoKey.initialize() );
  ATH_CHECK( m_jo_riocontainername.initialize(m_fillCluster.value()) );
  ATH_CHECK( m_dataObjectName.initialize(m_fillRDO.value()) );
  ATH_CHECK( m_spacePointContainerName.initialize(m_fillSpacePoint.value()) );
  ATH_CHECK( m_inputTrackCollection.initialize(m_fillRDO.value() and m_doHitsOnTracks.value()) );
 
  // Read Cond Handle Key
  ATH_CHECK( m_SCTDetEleCollKey.initialize( m_fillCluster.value() ) );
 
  return sc;
}

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.

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();
  }

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_bunchCrossing

int InDet::SCT_ClusterValidationNtupleWriter::m_bunchCrossing

private

event bunch crossing ID

Definition at line 90 of file SCT_ClusterValidationNtupleWriter.h.

m_byteStreamErrTool

ToolHandle<ISCT_ByteStreamErrorsTool> InDet::SCT_ClusterValidationNtupleWriter::m_byteStreamErrTool {this, "ByteStreamErrTool", "SCT_ByteStreamErrorsTool", "Tool to retrieve SCT ByteStream Errors"}

private

Definition at line 71 of file SCT_ClusterValidationNtupleWriter.h.

{this, "ByteStreamErrTool", "SCT_ByteStreamErrorsTool", "Tool to retrieve SCT ByteStream Errors"};

m_cabling

ToolHandle<ISCT_CablingTool> InDet::SCT_ClusterValidationNtupleWriter::m_cabling {this, "SCT_CablingTool", "SCT_CablingTool", "Tool to retrieve SCT Cabling"}

private

Definition at line 72 of file SCT_ClusterValidationNtupleWriter.h.

{this, "SCT_CablingTool", "SCT_CablingTool", "Tool to retrieve SCT Cabling"};

m_dataObjectName

SG::ReadHandleKey<SCT_RDO_Container> InDet::SCT_ClusterValidationNtupleWriter::m_dataObjectName {this, "SCT_RDOContainer", "SCT_RDOs", "Data object name: for the SCT this is SCT_RDOs"}

private

Definition at line 64 of file SCT_ClusterValidationNtupleWriter.h.

{this, "SCT_RDOContainer", "SCT_RDOs", "Data object name: for the SCT this is SCT_RDOs"};

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_doHitsOnTracks

BooleanProperty InDet::SCT_ClusterValidationNtupleWriter::m_doHitsOnTracks {this, "DoHitsOnTracks", false}

private

flag to book, access and fill RDO isOnTrack or not

Definition at line 80 of file SCT_ClusterValidationNtupleWriter.h.

{this, "DoHitsOnTracks", false};     

m_eventInfoKey

SG::ReadHandleKey<xAOD::EventInfo> InDet::SCT_ClusterValidationNtupleWriter::m_eventInfoKey {this, "EventInfoKey", "EventInfo", "key for xAOD::EventInfo"}

private

Definition at line 62 of file SCT_ClusterValidationNtupleWriter.h.

{this, "EventInfoKey", "EventInfo", "key for xAOD::EventInfo"};

m_eventNumber

int InDet::SCT_ClusterValidationNtupleWriter::m_eventNumber

private

event number for current PRD vector

Definition at line 87 of file SCT_ClusterValidationNtupleWriter.h.

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_fillBSErrs

BooleanProperty InDet::SCT_ClusterValidationNtupleWriter::m_fillBSErrs {this, "FillBSErrs", true}

private

flag to book, access and fill ByteStream errors or not

Definition at line 79 of file SCT_ClusterValidationNtupleWriter.h.

{this, "FillBSErrs", true};         

m_fillCluster

BooleanProperty InDet::SCT_ClusterValidationNtupleWriter::m_fillCluster {this, "FillCluster", false}

private

flag to book, access and fill Cluster or not

Definition at line 76 of file SCT_ClusterValidationNtupleWriter.h.

{this, "FillCluster", false};        

m_fillRDO

BooleanProperty InDet::SCT_ClusterValidationNtupleWriter::m_fillRDO {this, "FillRDO", true}

private

flag to book, access and fill RDO or not

Definition at line 77 of file SCT_ClusterValidationNtupleWriter.h.

{this, "FillRDO", true};            

m_fillSpacePoint

BooleanProperty InDet::SCT_ClusterValidationNtupleWriter::m_fillSpacePoint {this, "FillSpacePoint", false}

private

flag to book, access and fill SpacePoints or not

Definition at line 78 of file SCT_ClusterValidationNtupleWriter.h.

{this, "FillSpacePoint", false};     

m_inputTrackCollection

SG::ReadHandleKey<TrackCollection> InDet::SCT_ClusterValidationNtupleWriter::m_inputTrackCollection {this, "SCT_InputTrackCollection", "CombinedInDetTracks", "TrackCollection name, needed for hits-on-tracks, default is CombinedInDetTracks"}

private

Definition at line 66 of file SCT_ClusterValidationNtupleWriter.h.

{this, "SCT_InputTrackCollection", "CombinedInDetTracks", "TrackCollection name, needed for hits-on-tracks, default is CombinedInDetTracks"};

m_jo_riocontainername

SG::ReadHandleKey<SCT_ClusterContainer> InDet::SCT_ClusterValidationNtupleWriter::m_jo_riocontainername {this, "SCT_ClusterContainer", "SCT_Clusters", "jobOption: name of container with RIOs"}

private

Definition at line 63 of file SCT_ClusterValidationNtupleWriter.h.

{this, "SCT_ClusterContainer", "SCT_Clusters", "jobOption: name of container with RIOs"};

m_lumiBlock

int InDet::SCT_ClusterValidationNtupleWriter::m_lumiBlock

private

event lumi block information

Definition at line 88 of file SCT_ClusterValidationNtupleWriter.h.

m_nRDOs

int InDet::SCT_ClusterValidationNtupleWriter::m_nRDOs

private

Number of RDOs.

Definition at line 117 of file SCT_ClusterValidationNtupleWriter.h.

m_nRIOs

int InDet::SCT_ClusterValidationNtupleWriter::m_nRIOs

private

number of RIOs, i.e.

SCT clusters, in the event. This variable set the size of the vectors with cluster information.

Definition at line 93 of file SCT_ClusterValidationNtupleWriter.h.

m_nSP

int InDet::SCT_ClusterValidationNtupleWriter::m_nSP

private

Definition at line 107 of file SCT_ClusterValidationNtupleWriter.h.

m_nt

TTree* InDet::SCT_ClusterValidationNtupleWriter::m_nt

private

pointer to the ntuple tree.

Definition at line 83 of file SCT_ClusterValidationNtupleWriter.h.

m_ntupleDirName

StringProperty InDet::SCT_ClusterValidationNtupleWriter::m_ntupleDirName {this, "NtupleDirectoryName", "FitterValidation"}

private

jobOption: Ntuple directory name

Definition at line 74 of file SCT_ClusterValidationNtupleWriter.h.

{this, "NtupleDirectoryName", "FitterValidation"};      

m_ntupleFileName

StringProperty InDet::SCT_ClusterValidationNtupleWriter::m_ntupleFileName {this, "NtupleFileName", "/NTUPLES/FILE1"}

private

jobOption: Ntuple file name

Definition at line 73 of file SCT_ClusterValidationNtupleWriter.h.

{this, "NtupleFileName", "/NTUPLES/FILE1"};     

m_ntupleTreeName

StringProperty InDet::SCT_ClusterValidationNtupleWriter::m_ntupleTreeName {this, "NtupleTreeName", "RIOs"}

private

jobOption: Ntuple tree name

Definition at line 75 of file SCT_ClusterValidationNtupleWriter.h.

{this, "NtupleTreeName", "RIOs"};     

m_riocontainer

const InDet::SCT_ClusterContainer* InDet::SCT_ClusterValidationNtupleWriter::m_riocontainer

private

container of RIOs

Definition at line 61 of file SCT_ClusterValidationNtupleWriter.h.

m_rioLoc1

std::vector<float>* InDet::SCT_ClusterValidationNtupleWriter::m_rioLoc1

private

local x coordinate of strip UNIT:mm

Definition at line 94 of file SCT_ClusterValidationNtupleWriter.h.

m_rioSurfaceX

std::vector<float>* InDet::SCT_ClusterValidationNtupleWriter::m_rioSurfaceX

private

global x coordinate of SCT wafer center UNIT:mm

Definition at line 95 of file SCT_ClusterValidationNtupleWriter.h.

m_rioSurfaceY

std::vector<float>* InDet::SCT_ClusterValidationNtupleWriter::m_rioSurfaceY

private

global x coordinate of SCT wafer center UNIT:mm

Definition at line 96 of file SCT_ClusterValidationNtupleWriter.h.

m_rioSurfaceZ

std::vector<float>* InDet::SCT_ClusterValidationNtupleWriter::m_rioSurfaceZ

private

global x coordinate of SCT wafer center UNIT:mm

Definition at line 97 of file SCT_ClusterValidationNtupleWriter.h.

m_runNumber

int InDet::SCT_ClusterValidationNtupleWriter::m_runNumber

private

run number

Definition at line 86 of file SCT_ClusterValidationNtupleWriter.h.

m_sct_barrelec

std::vector<int>* InDet::SCT_ClusterValidationNtupleWriter::m_sct_barrelec

private

barrel/endcap index (barrel: 0, endcap: +/-2)

Definition at line 124 of file SCT_ClusterValidationNtupleWriter.h.

m_sct_channel

std::vector<int>* InDet::SCT_ClusterValidationNtupleWriter::m_sct_channel

private

channel within ROD of the RDO

Definition at line 130 of file SCT_ClusterValidationNtupleWriter.h.

m_sct_eta

std::vector<int>* InDet::SCT_ClusterValidationNtupleWriter::m_sct_eta

private

eta of the SCT wafer

Definition at line 121 of file SCT_ClusterValidationNtupleWriter.h.

m_sct_firstStrip

std::vector<int>* InDet::SCT_ClusterValidationNtupleWriter::m_sct_firstStrip

private

index (could be from 0 to 767) of the fired strip within the SCT wafer

Definition at line 125 of file SCT_ClusterValidationNtupleWriter.h.

m_sct_layer

std::vector<int>* InDet::SCT_ClusterValidationNtupleWriter::m_sct_layer

private

index of the SCT-layer in which the SCT wafer is positioned

Definition at line 120 of file SCT_ClusterValidationNtupleWriter.h.

m_sct_numHitsInWafer

std::vector<int>* InDet::SCT_ClusterValidationNtupleWriter::m_sct_numHitsInWafer

private

number of hits in the SCT wafer

Definition at line 126 of file SCT_ClusterValidationNtupleWriter.h.

m_sct_phi

std::vector<int>* InDet::SCT_ClusterValidationNtupleWriter::m_sct_phi

private

phi of the SCT wafer

Definition at line 122 of file SCT_ClusterValidationNtupleWriter.h.

m_sct_rdoGroupSize

std::vector<int>* InDet::SCT_ClusterValidationNtupleWriter::m_sct_rdoGroupSize

private

RDO group size.

Definition at line 118 of file SCT_ClusterValidationNtupleWriter.h.

m_sct_rdoIsOnTrack

std::vector<int>* InDet::SCT_ClusterValidationNtupleWriter::m_sct_rdoIsOnTrack

private

RDO on track.

Definition at line 119 of file SCT_ClusterValidationNtupleWriter.h.

m_sct_rodid

std::vector<int>* InDet::SCT_ClusterValidationNtupleWriter::m_sct_rodid

private

ROD ID of the RDO.

Definition at line 129 of file SCT_ClusterValidationNtupleWriter.h.

m_sct_side

std::vector<int>* InDet::SCT_ClusterValidationNtupleWriter::m_sct_side

private

side of the SCT wafer (0 or 1) within the SCT module

Definition at line 123 of file SCT_ClusterValidationNtupleWriter.h.

m_sct_tbin

std::vector<int>* InDet::SCT_ClusterValidationNtupleWriter::m_sct_tbin

private

timebin of the RDO

Definition at line 128 of file SCT_ClusterValidationNtupleWriter.h.

m_sct_waferHash

std::vector<int>* InDet::SCT_ClusterValidationNtupleWriter::m_sct_waferHash

private

index (could be from 0 to 8175) of the fired SCT wafer

Definition at line 127 of file SCT_ClusterValidationNtupleWriter.h.

m_SctBarrelEndcap

std::vector<int>* InDet::SCT_ClusterValidationNtupleWriter::m_SctBarrelEndcap

private

from IdHelper: pos/neg barrel (+/-1) and pos/neg endcap (+/-2) UNIT:1:bar, 2:ec

Definition at line 98 of file SCT_ClusterValidationNtupleWriter.h.

m_SctDeltaPhi

std::vector<float>* InDet::SCT_ClusterValidationNtupleWriter::m_SctDeltaPhi

private

please provide description!

Definition at line 103 of file SCT_ClusterValidationNtupleWriter.h.

m_SCTDetEleCollKey

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

private

Definition at line 69 of file SCT_ClusterValidationNtupleWriter.h.

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

m_scterr_bec

std::vector<int>* InDet::SCT_ClusterValidationNtupleWriter::m_scterr_bec

private

barrel/endcap index (barrel: 0, endcap: +/-2)

Definition at line 139 of file SCT_ClusterValidationNtupleWriter.h.

m_scterr_channel

std::vector<int>* InDet::SCT_ClusterValidationNtupleWriter::m_scterr_channel

private

online channel no.

of link.

Definition at line 145 of file SCT_ClusterValidationNtupleWriter.h.

m_scterr_eta

std::vector<int>* InDet::SCT_ClusterValidationNtupleWriter::m_scterr_eta

private

eta of the SCT wafer

Definition at line 141 of file SCT_ClusterValidationNtupleWriter.h.

m_scterr_layer

std::vector<int>* InDet::SCT_ClusterValidationNtupleWriter::m_scterr_layer

private

layer (barrel) or disk (endcap) of wafer with the error

Definition at line 140 of file SCT_ClusterValidationNtupleWriter.h.

m_scterr_phi

std::vector<int>* InDet::SCT_ClusterValidationNtupleWriter::m_scterr_phi

private

phi of the SCT wafer

Definition at line 142 of file SCT_ClusterValidationNtupleWriter.h.

m_scterr_rodid

std::vector<int>* InDet::SCT_ClusterValidationNtupleWriter::m_scterr_rodid

private

online ID of ROD containing link

Definition at line 144 of file SCT_ClusterValidationNtupleWriter.h.

m_scterr_side

std::vector<int>* InDet::SCT_ClusterValidationNtupleWriter::m_scterr_side

private

side of the SCT wafer (0 or 1) within the module

Definition at line 143 of file SCT_ClusterValidationNtupleWriter.h.

m_scterr_type

std::vector<int>* InDet::SCT_ClusterValidationNtupleWriter::m_scterr_type

private

type of BS error (as defined in SCT_ByteStreamErrs enum in ISCT_ByteStreamErrorsSvc.h)

Definition at line 146 of file SCT_ClusterValidationNtupleWriter.h.

m_SctEtaModule

std::vector<int>* InDet::SCT_ClusterValidationNtupleWriter::m_SctEtaModule

private

from IdHelper: module index in eta

Definition at line 100 of file SCT_ClusterValidationNtupleWriter.h.

m_SctHitErr

std::vector<float>* InDet::SCT_ClusterValidationNtupleWriter::m_SctHitErr

private

please provide description!

Definition at line 104 of file SCT_ClusterValidationNtupleWriter.h.

m_sctid

const SCT_ID* InDet::SCT_ClusterValidationNtupleWriter::m_sctid

private

SCT ID helper.

Definition at line 60 of file SCT_ClusterValidationNtupleWriter.h.

m_SctLayerDisk

std::vector<int>* InDet::SCT_ClusterValidationNtupleWriter::m_SctLayerDisk

private

from IdHelper: layer/disk index

Definition at line 99 of file SCT_ClusterValidationNtupleWriter.h.

m_SctPhiModule

std::vector<int>* InDet::SCT_ClusterValidationNtupleWriter::m_SctPhiModule

private

from IdHelper: module index in phi

Definition at line 101 of file SCT_ClusterValidationNtupleWriter.h.

m_SctSide

std::vector<int>* InDet::SCT_ClusterValidationNtupleWriter::m_SctSide

private

from IdHelper: side index (0/1)

Definition at line 102 of file SCT_ClusterValidationNtupleWriter.h.

m_sp_bec

std::vector<int>* InDet::SCT_ClusterValidationNtupleWriter::m_sp_bec

private

Barrel or endcap index (barrel: 0, endcap: +/-2) for SpacePoint.

Definition at line 108 of file SCT_ClusterValidationNtupleWriter.h.

m_sp_eta

std::vector<int>* InDet::SCT_ClusterValidationNtupleWriter::m_sp_eta

private

eta index of the SCT-layer in which the SCT wafer is positioned for SpacePoint

Definition at line 110 of file SCT_ClusterValidationNtupleWriter.h.

m_sp_layer

std::vector<int>* InDet::SCT_ClusterValidationNtupleWriter::m_sp_layer

private

index of the SCT-layer in which the SCT wafer is positioned for SpacePoint

Definition at line 109 of file SCT_ClusterValidationNtupleWriter.h.

m_sp_phi

std::vector<int>* InDet::SCT_ClusterValidationNtupleWriter::m_sp_phi

private

phi index of the SCT-layer in which the SCT wafer is positioned for SpacePoint

Definition at line 111 of file SCT_ClusterValidationNtupleWriter.h.

m_sp_x

std::vector<float>* InDet::SCT_ClusterValidationNtupleWriter::m_sp_x

private

x position of SpacePoint in ATLAS coordinate system (mm)

Definition at line 112 of file SCT_ClusterValidationNtupleWriter.h.

m_sp_y

std::vector<float>* InDet::SCT_ClusterValidationNtupleWriter::m_sp_y

private

y position of SpacePoint in ATLAS coordinate system (mm)

Definition at line 113 of file SCT_ClusterValidationNtupleWriter.h.

m_sp_z

std::vector<float>* InDet::SCT_ClusterValidationNtupleWriter::m_sp_z

private

z position of SpacePoint in ATLAS coordinate system (mm)

Definition at line 114 of file SCT_ClusterValidationNtupleWriter.h.

m_spacePointContainerName

SG::ReadHandleKey<SpacePointContainer> InDet::SCT_ClusterValidationNtupleWriter::m_spacePointContainerName {this, "SCT_SpacePointContainer", "SCT_SpacePoints", "SpacePoint container name: for the SCT this is SCT_SpacePoints"}

private

Definition at line 65 of file SCT_ClusterValidationNtupleWriter.h.

{this, "SCT_SpacePointContainer", "SCT_SpacePoints", "SpacePoint container name: for the SCT this is SCT_SpacePoints"};

m_timeStamp

int InDet::SCT_ClusterValidationNtupleWriter::m_timeStamp

private

event time stamp

Definition at line 89 of file SCT_ClusterValidationNtupleWriter.h.

m_totalNumErrors

int InDet::SCT_ClusterValidationNtupleWriter::m_totalNumErrors

private

total number of BS errors.

Definition at line 138 of file SCT_ClusterValidationNtupleWriter.h.

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:

• SCT_ClusterValidationNtupleWriter.h
• SCT_ClusterValidationNtupleWriter.cxx