ATLAS Offline Software
Public Member Functions | Protected Member Functions | Protected Attributes | Private Member Functions | Static Private Member Functions | Private Attributes | List of all members
AFP_SensitiveDetectorTool Class Reference

#include <AFP_SensitiveDetectorTool.h>

Inheritance diagram for AFP_SensitiveDetectorTool:
Collaboration diagram for AFP_SensitiveDetectorTool:

Public Member Functions

 AFP_SensitiveDetectorTool (const std::string &type, const std::string &name, const IInterface *parent)
 
 ~AFP_SensitiveDetectorTool ()
 
StatusCode SetupEvent () override final
 Beginning of an athena event. More...
 
StatusCode Gather () override final
 End of an athena event. More...
 
StatusCode initializeSD () override
 Setup an SD in the current thread. More...
 

Protected Member Functions

G4VSensitiveDetector * makeSD () const override final
 
StatusCode assignSD (G4VSensitiveDetector *sd, const std::vector< std::string > &volumes) const
 Assign SD to a list of volumes. More...
 
G4VSensitiveDetector * getSD ()
 Retrieve the current SD. More...
 
void SetSensitiveDetector (G4LogicalVolume *, G4VSensitiveDetector *) const
 Method stolen from G4VUserDetectorConstruction in G4 10.2. More...
 

Protected Attributes

Gaudi::Property< std::vector< std::string > > m_volumeNames {this, "LogicalVolumeNames", {}}
 All the volumes to which this SD is assigned. More...
 
Gaudi::Property< std::vector< std::string > > m_outputCollectionNames {this, "OutputCollectionNames", {}}
 Names of all output collections written out by this SD. More...
 
Gaudi::Property< bool > m_noVolumes {this, "NoVolumes", false}
 This SensitiveDetector has no volumes associated with it. More...
 

Private Member Functions

void setSD (G4VSensitiveDetector *)
 Set the current SD. More...
 

Static Private Member Functions

static bool matchStrings (const char *first, const char *second)
 Match two strings with wildcard support. More...
 

Private Attributes

G4VSensitiveDetector * m_SD {}
 The sensitive detector to which this thing corresponds. More...
 

Detailed Description

Definition at line 16 of file AFP_SensitiveDetectorTool.h.

Constructor & Destructor Documentation

◆ AFP_SensitiveDetectorTool()

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

Definition at line 14 of file AFP_SensitiveDetectorTool.cxx.

16 {
17 }

◆ ~AFP_SensitiveDetectorTool()

AFP_SensitiveDetectorTool::~AFP_SensitiveDetectorTool ( )
inline

Definition at line 23 of file AFP_SensitiveDetectorTool.h.

23 {}

Member Function Documentation

◆ assignSD()

StatusCode SensitiveDetectorBase::assignSD ( G4VSensitiveDetector *  sd,
const std::vector< std::string > &  volumes 
) const
protectedinherited

Assign SD to a list of volumes.

This method supports wild card matching

Definition at line 69 of file SensitiveDetectorBase.cxx.

71 {
72  // Propagate verbosity setting to the SD
73  if(msgLvl(MSG::VERBOSE)) sd->SetVerboseLevel(10);
74  else if(msgLvl(MSG::DEBUG)) sd->SetVerboseLevel(5);
75 
76  // Add the sensitive detector to the SD manager in G4 for SDs,
77  // even if it has no volumes associated to it.
78  auto sdMgr = G4SDManager::GetSDMpointer();
79  sdMgr->AddNewDetector(sd);
80 
81  if(!volumes.empty()) {
82  bool gotOne = false;
83  auto logicalVolumeStore = G4LogicalVolumeStore::GetInstance();
84  for(const auto& volumeName : volumes) {
85  // Keep track of how many volumes we find with this name string.
86  // We allow for multiple matches.
87  int numFound = 0;
88 
89  // Find volumes with this name
90  for(auto* logVol : *logicalVolumeStore) {
91 
92  ATH_MSG_VERBOSE("Check whether "<<logVol->GetName()<<" belongs to the set of sensitive detectors "<<volumeName);
93  if( matchStrings( volumeName.data(), logVol->GetName() ) ){
94  ++numFound;
95  SetSensitiveDetector(logVol, sd);
96  }
97 
98  }
99  // Warn if no volumes were found
100  if(numFound == 0) {
101  ATH_MSG_WARNING("Volume " << volumeName <<
102  " not found in G4LogicalVolumeStore.");
103  }
104  else {
105  ATH_MSG_VERBOSE("Found " << numFound << " copies of LV " << volumeName <<
106  "; SD " << sd->GetName() << " assigned.");
107  gotOne = true;
108  }
109 
110  }
111 
112  // Abort if we have failed to assign any volume
113  if(!gotOne) {
114  ATH_MSG_ERROR( "Failed to assign *any* volume to SD " << name() <<
115  " and expected at least one. Size of the volume store "<<G4LogicalVolumeStore::GetInstance()->size() );
116  return StatusCode::FAILURE;
117  }
118  }
119 
120  return StatusCode::SUCCESS;
121 }

◆ Gather()

StatusCode AFP_SensitiveDetectorTool::Gather ( )
finaloverridevirtual

End of an athena event.

Reimplemented from SensitiveDetectorBase.

Definition at line 44 of file AFP_SensitiveDetectorTool.cxx.

45 {
46  ATH_MSG_VERBOSE( "AFP_SensitiveDetectorTool::Gather()" );
47  if(!getSD())
48  {
49  ATH_MSG_ERROR ("Gather: AFP_SensitiveDetector never created!");
50  return StatusCode::FAILURE;
51  }
52  else
53  {
54  AFP_SensitiveDetector *localSD = dynamic_cast<AFP_SensitiveDetector*>(getSD());
55  if(!localSD)
56  {
57  ATH_MSG_ERROR ("Gather: Failed to cast m_SD into AFP_SensitiveDetector.");
58  return StatusCode::FAILURE;
59  }
60  localSD->EndOfAthenaEvent();
61  }
62  return StatusCode::SUCCESS;
63 }

◆ getSD()

G4VSensitiveDetector * SensitiveDetectorBase::getSD ( )
protectedinherited

Retrieve the current SD.

In AthenaMT, this means the thread-local SD. Otherwise, it is simply the single SD.

Definition at line 123 of file SensitiveDetectorBase.cxx.

124 {
125 #ifdef G4MULTITHREADED
126  // Get current thread-ID
127  const auto tid = std::this_thread::get_id();
128  // Retrieve it from the SD map
129  auto sdPair = m_sdThreadMap.find(tid);
130  if(sdPair == m_sdThreadMap.end()) return nullptr;
131  return sdPair->second;
132 #else
133  return m_SD;
134 #endif
135 }

◆ initializeSD()

StatusCode SensitiveDetectorBase::initializeSD ( )
overrideinherited

Setup an SD in the current thread.

Separate from the AthAlgTool initialize() method because it needs to be called once per worker thread in AthenaMT. Don't confuse this with the G4 SD method Initialize which is called at the beginning of every G4 event.

Definition at line 30 of file SensitiveDetectorBase.cxx.

31 {
32  ATH_MSG_VERBOSE( name() << "::initializeSD()" );
33 
34  // Sanity check for volume configuration problems.
35  // It would be better to have a more robust solution for this.
36  if(m_volumeNames.empty() != m_noVolumes) {
37  ATH_MSG_ERROR("Initializing SD from " << name() << ", NoVolumes = "
38  << (m_noVolumes? "true" : "false") << ", but LogicalVolumeNames = "
39  << m_volumeNames.value());
40  return StatusCode::FAILURE;
41  }
42 
43  // Make sure SD isn't already registered
44  if(getSD())
45  {
46  ATH_MSG_ERROR("Trying to create a SD which already exists!");
47  return StatusCode::FAILURE;
48  }
49 
50  // Make the SD stored by this tool
51  auto* sd = makeSD();
52  if(!sd)
53  {
54  ATH_MSG_ERROR("Failed to create SD!");
55  return StatusCode::FAILURE;
56  }
57  setSD(sd);
58 
59  // Assign the SD to our list of volumes
60  ATH_CHECK( assignSD( getSD(), m_volumeNames.value() ) );
61 
62  ATH_MSG_DEBUG( "Initialized and added SD " << name() );
63  return StatusCode::SUCCESS;
64 }

◆ makeSD()

G4VSensitiveDetector * AFP_SensitiveDetectorTool::makeSD ( ) const
finaloverrideprotected

Definition at line 67 of file AFP_SensitiveDetectorTool.cxx.

68 {
69  ATH_MSG_DEBUG( "Initializing SD" );
70  // Create a fresh SD
72 }

◆ matchStrings()

bool SensitiveDetectorBase::matchStrings ( const char *  first,
const char *  second 
)
staticprivateinherited

Match two strings with wildcard support.

Compares two strings character by character with optional * wildcard in the first argument

Definition at line 150 of file SensitiveDetectorBase.cxx.

151 {
152  // If we reach at the end of both strings, we are done
153  if (*first == '\0' && *second == '\0')
154  return true;
155 
156  // If there are consecutive '*' present in the first string
157  // advance to the next character
158  if(*first == '*' && *(first + 1) == '*')
159  return matchStrings(first + 1, second);
160 
161  // Make sure that the characters after '*' are present in second string.
162  if (*first == '*' && *(first + 1) != '\0' && *second == '\0')
163  return false;
164 
165  // If the current characters of both strings match
166  if (*first == *second)
167  return matchStrings(first + 1, second + 1);
168 
169  // If there is *, then there are two possibilities
170  // a) We consider current character of second string
171  // b) We ignore current character of second string.
172  if (*first == '*')
173  return matchStrings(first + 1, second) || matchStrings(first, second + 1);
174  return false;
175 }

◆ setSD()

void SensitiveDetectorBase::setSD ( G4VSensitiveDetector *  sd)
privateinherited

Set the current SD.

In hive, this gets assigned as the thread-local SD.

Definition at line 137 of file SensitiveDetectorBase.cxx.

138 {
139 #ifdef G4MULTITHREADED
140  const auto tid = std::this_thread::get_id();
141  ATH_MSG_DEBUG("Creating and registering SD " << sd << " in thread " << tid);
142  m_sdThreadMap.insert( std::make_pair(tid, sd) );
143 #else
144  m_SD = sd;
145 #endif
146 }

◆ SetSensitiveDetector()

void SensitiveDetectorBase::SetSensitiveDetector ( G4LogicalVolume *  logVol,
G4VSensitiveDetector *  aSD 
) const
protectedinherited

Method stolen from G4VUserDetectorConstruction in G4 10.2.

Definition at line 177 of file SensitiveDetectorBase.cxx.

179 {
180  // New Logic: allow for "multiple" SDs being attached to a single LV.
181  // To do that we use a special proxy SD called G4MultiSensitiveDetector
182 
183  // Get existing SD if already set and check if it is of the special type
184  G4VSensitiveDetector* originalSD = logVol->GetSensitiveDetector();
185  if ( originalSD == nullptr )
186  {
187  logVol->SetSensitiveDetector(aSD);
188  }
189  else
190  {
191  G4MultiSensitiveDetector* msd = dynamic_cast<G4MultiSensitiveDetector*>(originalSD);
192  if ( msd != nullptr )
193  {
194  msd->AddSD(aSD);
195  }
196  else
197  {
198  // Construct a unique name using the volume address
199  std::stringstream ss;
200  ss << static_cast<const void*>(logVol);
201  const G4String msdname = "/MultiSD_" + logVol->GetName() + ss.str();
202  //ATH_MSG_INFO("MultiSD name: " << msdname);
203  msd = new G4MultiSensitiveDetector(msdname);
204  // We need to register the proxy to have correct handling of IDs
205  G4SDManager::GetSDMpointer()->AddNewDetector(msd);
206  msd->AddSD(originalSD);
207  msd->AddSD(aSD);
208  logVol->SetSensitiveDetector(msd);
209  }
210  }
211 }

◆ SetupEvent()

StatusCode AFP_SensitiveDetectorTool::SetupEvent ( )
finaloverridevirtual

Beginning of an athena event.

This is where collection initialization should happen.

Reimplemented from SensitiveDetectorBase.

Definition at line 21 of file AFP_SensitiveDetectorTool.cxx.

22 {
23  ATH_MSG_VERBOSE( "AFP_SensitiveDetectorTool::SetupEvent()" );
24  if(!getSD())
25  {
26  ATH_MSG_ERROR ("SetupEvent: AFP_SensitiveDetector never created!");
27  return StatusCode::FAILURE;
28  }
29  else
30  {
31  AFP_SensitiveDetector *localSD = dynamic_cast<AFP_SensitiveDetector*>(getSD());
32  if(!localSD)
33  {
34  ATH_MSG_ERROR ("SetupEvent: Failed to cast m_SD into AFP_SensitiveDetector.");
35  return StatusCode::FAILURE;
36  }
37  localSD->StartOfAthenaEvent();
38  }
39  return StatusCode::SUCCESS;
40 }

Member Data Documentation

◆ m_noVolumes

Gaudi::Property<bool> SensitiveDetectorBase::m_noVolumes {this, "NoVolumes", false}
protectedinherited

This SensitiveDetector has no volumes associated with it.

Definition at line 87 of file SensitiveDetectorBase.h.

◆ m_outputCollectionNames

Gaudi::Property<std::vector<std::string> > SensitiveDetectorBase::m_outputCollectionNames {this, "OutputCollectionNames", {}}
protectedinherited

Names of all output collections written out by this SD.

Definition at line 84 of file SensitiveDetectorBase.h.

◆ m_SD

G4VSensitiveDetector* SensitiveDetectorBase::m_SD {}
privateinherited

The sensitive detector to which this thing corresponds.

Definition at line 111 of file SensitiveDetectorBase.h.

◆ m_volumeNames

Gaudi::Property<std::vector<std::string> > SensitiveDetectorBase::m_volumeNames {this, "LogicalVolumeNames", {}}
protectedinherited

All the volumes to which this SD is assigned.

Definition at line 82 of file SensitiveDetectorBase.h.


The documentation for this class was generated from the following files:
python.SystemOfUnits.second
int second
Definition: SystemOfUnits.py:120
AFP_SensitiveDetector::EndOfAthenaEvent
void EndOfAthenaEvent()
Definition: AFP_SensitiveDetector.cxx:774
SensitiveDetectorBase::m_SD
G4VSensitiveDetector * m_SD
The sensitive detector to which this thing corresponds.
Definition: SensitiveDetectorBase.h:111
PowhegControl_ttHplus_NLO.ss
ss
Definition: PowhegControl_ttHplus_NLO.py:83
SensitiveDetectorBase::SensitiveDetectorBase
SensitiveDetectorBase(const std::string &type, const std::string &name, const IInterface *parent)
Standard constructor.
Definition: SensitiveDetectorBase.cxx:22
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition: AthMsgStreamMacros.h:28
SensitiveDetectorBase::getSD
G4VSensitiveDetector * getSD()
Retrieve the current SD.
Definition: SensitiveDetectorBase.cxx:123
python.selector.AtlRunQuerySelectorLhcOlc.sd
sd
Definition: AtlRunQuerySelectorLhcOlc.py:612
python.setupRTTAlg.size
int size
Definition: setupRTTAlg.py:39
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
test_pyathena.parent
parent
Definition: test_pyathena.py:15
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
SensitiveDetectorBase::m_outputCollectionNames
Gaudi::Property< std::vector< std::string > > m_outputCollectionNames
Names of all output collections written out by this SD.
Definition: SensitiveDetectorBase.h:84
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:228
SensitiveDetectorBase::SetSensitiveDetector
void SetSensitiveDetector(G4LogicalVolume *, G4VSensitiveDetector *) const
Method stolen from G4VUserDetectorConstruction in G4 10.2.
Definition: SensitiveDetectorBase.cxx:178
AFP_SensitiveDetector
Definition: AFP_SensitiveDetector.h:25
SensitiveDetectorBase::matchStrings
static bool matchStrings(const char *first, const char *second)
Match two strings with wildcard support.
Definition: SensitiveDetectorBase.cxx:150
SensitiveDetectorBase::m_volumeNames
Gaudi::Property< std::vector< std::string > > m_volumeNames
All the volumes to which this SD is assigned.
Definition: SensitiveDetectorBase.h:82
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
SensitiveDetectorBase::m_noVolumes
Gaudi::Property< bool > m_noVolumes
This SensitiveDetector has no volumes associated with it.
Definition: SensitiveDetectorBase.h:87
python.CaloScaleNoiseConfig.type
type
Definition: CaloScaleNoiseConfig.py:78
DeMoScan.first
bool first
Definition: DeMoScan.py:536
AFP_SensitiveDetector::StartOfAthenaEvent
void StartOfAthenaEvent()
Definition: AFP_SensitiveDetector.cxx:57
DEBUG
#define DEBUG
Definition: page_access.h:11
SensitiveDetectorBase::setSD
void setSD(G4VSensitiveDetector *)
Set the current SD.
Definition: SensitiveDetectorBase.cxx:137
python.Constants.VERBOSE
int VERBOSE
Definition: Control/AthenaCommon/python/Constants.py:14
SensitiveDetectorBase::assignSD
StatusCode assignSD(G4VSensitiveDetector *sd, const std::vector< std::string > &volumes) const
Assign SD to a list of volumes.
Definition: SensitiveDetectorBase.cxx:70