ATLAS Offline Software
Loading...
Searching...
No Matches
Public Member Functions | Private Attributes | List of all members
G4UA::TestActionShowerLib Class Reference

Class for collecting G4 hit information. More...

#include <TestActionShowerLib.h>

Inheritance diagram for G4UA::TestActionShowerLib:
Collaboration diagram for G4UA::TestActionShowerLib:

Public Member Functions

 TestActionShowerLib ()
virtual void BeginOfEventAction (const G4Event *) override
virtual void EndOfEventAction (const G4Event *) override
virtual void BeginOfRunAction (const G4Run *) override
virtual void EndOfRunAction (const G4Run *) override
virtual void UserSteppingAction (const G4Step *) override

Private Attributes

ServiceHandle< StoreGateSvc > m_evtStore
 Pointer to StoreGate (event store by default)
ServiceHandle< ILArCalculatorSvc > m_current_calculator
G4VSolid * m_current_solid
G4AffineTransform * m_current_transform
ShowerLib::StepInfoCollection * m_eventSteps
 Collection of StepInfo.
LAr calculators
ServiceHandle< ILArCalculatorSvc > m_calculator_EMECIW
 Pointer to EMEC inner wheel calculator.
ServiceHandle< ILArCalculatorSvc > m_calculator_EMECOW
 Pointer to EMEC outer wheel calculator.
ServiceHandle< ILArCalculatorSvc > m_calculator_FCAL1
ServiceHandle< ILArCalculatorSvc > m_calculator_FCAL2
ServiceHandle< ILArCalculatorSvc > m_calculator_FCAL3
ServiceHandle< ILArCalculatorSvc > m_calculator_EMB

Detailed Description

Class for collecting G4 hit information. 

   Collect and store Geant4 hit information, i.e.
   position, deposited energy and time, from hits
   for the creation of a shower library
Author
Wolfgang Ehrenfeld, University of Hamburg, Germany
Sasha Glazov, DESY Hamburg, Germany

Definition at line 47 of file TestActionShowerLib.h.

Constructor & Destructor Documentation

◆ TestActionShowerLib()

G4UA::TestActionShowerLib::TestActionShowerLib ( )

Definition at line 27 of file TestActionShowerLib.cxx.

27 :
28 m_evtStore("StoreGateSvc/StoreGateSvc","TestActionShowerLib"),
29 m_current_calculator("","TestActionShowerLib"),
30 m_current_solid(nullptr),
31 m_current_transform(nullptr),
32 m_calculator_EMECIW("EMECPosInnerWheelCalculator","TestActionShowerLib"),
33 m_calculator_EMECOW("EMECPosOuterWheelCalculator","TestActionShowerLib"),
34 m_calculator_FCAL1("FCAL1Calculator","TestActionShowerLib"),
35 m_calculator_FCAL2("FCAL2Calculator","TestActionShowerLib"),
36 m_calculator_FCAL3("FCAL3Calculator","TestActionShowerLib"),
37 m_calculator_EMB("EMBCalculator","TestActionShowerLib"),
38 m_eventSteps(nullptr)
39 {
40#ifdef _myDEBUG_
41 G4cout << "#########################################" << G4endl
42 << "## TestActionShowerLib - Constructor ##" << G4endl
43 << "#########################################" << G4endl;
44#endif
45 }
G4UA::TestActionShowerLib::m_calculator_FCAL2
ServiceHandle< ILArCalculatorSvc > m_calculator_FCAL2
Definition TestActionShowerLib.h:79
G4UA::TestActionShowerLib::m_calculator_FCAL3
ServiceHandle< ILArCalculatorSvc > m_calculator_FCAL3
Definition TestActionShowerLib.h:80
G4UA::TestActionShowerLib::m_current_transform
G4AffineTransform * m_current_transform
Definition TestActionShowerLib.h:69
G4UA::TestActionShowerLib::m_calculator_EMB
ServiceHandle< ILArCalculatorSvc > m_calculator_EMB
Definition TestActionShowerLib.h:81
G4UA::TestActionShowerLib::m_calculator_EMECOW
ServiceHandle< ILArCalculatorSvc > m_calculator_EMECOW
Pointer to EMEC outer wheel calculator.
Definition TestActionShowerLib.h:77
G4UA::TestActionShowerLib::m_calculator_FCAL1
ServiceHandle< ILArCalculatorSvc > m_calculator_FCAL1
Definition TestActionShowerLib.h:78
G4UA::TestActionShowerLib::m_evtStore
ServiceHandle< StoreGateSvc > m_evtStore
Pointer to StoreGate (event store by default)
Definition TestActionShowerLib.h:63
G4UA::TestActionShowerLib::m_calculator_EMECIW
ServiceHandle< ILArCalculatorSvc > m_calculator_EMECIW
Pointer to EMEC inner wheel calculator.
Definition TestActionShowerLib.h:75
G4UA::TestActionShowerLib::m_current_calculator
ServiceHandle< ILArCalculatorSvc > m_current_calculator
Definition TestActionShowerLib.h:67
G4UA::TestActionShowerLib::m_eventSteps
ShowerLib::StepInfoCollection * m_eventSteps
Collection of StepInfo.
Definition TestActionShowerLib.h:86

Member Function Documentation

◆ BeginOfEventAction()

void G4UA::TestActionShowerLib::BeginOfEventAction ( const G4Event * )
overridevirtual

Definition at line 47 of file TestActionShowerLib.cxx.

48 {
49 if (m_current_transform == nullptr) {
50 m_current_transform = new G4AffineTransform();
51 }
52
53 m_eventSteps = new ShowerLib::StepInfoCollection();
54
55#ifdef _myDEBUG_
56 G4cout << "#########################################" << G4endl
57 << "## TestActionShowerLib - BeginOfEvent ##" << G4endl
58 << "#########################################" << G4endl;
59#endif
60 }

◆ BeginOfRunAction()

void G4UA::TestActionShowerLib::BeginOfRunAction ( const G4Run * )
overridevirtual

Definition at line 122 of file TestActionShowerLib.cxx.

123 {
124#ifdef _myDEBUG_
125 G4cout << "#########################################" << G4endl
126 << "## TestActionShowerLib - BeginOfRun ##" << G4endl
127 << "#########################################" << G4endl;
128#endif
129 // init calculator
130 if(!m_calculator_EMECIW.retrieve().isSuccess()) {
131 G4cout<<"Could not get ILArCalculatorSvc/InnerAbsorberWheel"<<G4endl;
132 return;
133 }
134 if(!m_calculator_EMECOW.retrieve().isSuccess()) {
135 G4cout<<"Could not get ILArCalculatorSvc/OuterAbsorberWheel"<<G4endl;
136 return;
137 }
138 if(!m_calculator_FCAL1.retrieve().isSuccess()) {
139 G4cout<<"Could not get ILArCalculatorSvc/FCAL1Calculator"<<G4endl;
140 return;
141 }
142 if(!m_calculator_FCAL2.retrieve().isSuccess()) {
143 G4cout<<"Could not get ILArCalculatorSvc/FCAL2Calculator"<<G4endl;
144 return;
145 }
146 if(!m_calculator_FCAL3.retrieve().isSuccess()) {
147 G4cout<<"Could not get ILArCalculatorSvc/FCAL3Calculator"<<G4endl;
148 return;
149 }
150 if(!m_calculator_EMB.retrieve().isSuccess()) {
151 G4cout<<"Could not get ILArCalculatorSvc/BarrelCalculator"<<G4endl;
152 return;
153 }
154
155 if (m_current_transform == nullptr) {
156 m_current_transform = new G4AffineTransform ();
157 }
158 }

◆ EndOfEventAction()

void G4UA::TestActionShowerLib::EndOfEventAction ( const G4Event * )
overridevirtual

Definition at line 62 of file TestActionShowerLib.cxx.

63 {
64#ifdef _myDEBUG_
65 G4cout << "#########################################" << G4endl
66 << "## TestActionShowerLib - EndOfEvent ##" << G4endl
67 //<< "## MMM="<<m_count<<" ###" << G4endl
68 << "#########################################" << G4endl;
69#endif
70
71 //
72 // Zero order cleanup
73 // combine hits from the same spot (distance < 1 mm^2)
74 // only necessary for large number of spots (> 500)
75 //
76 const double dsame = 1.; // 1mm^2
77
78#ifdef _myDEBUG_
79 G4cout << "TestActionShowerLib::EndOfEventAction: Before initial cleanup, N="
80 << m_eventSteps->size() << G4endl;
81#endif
82
83 if (m_eventSteps->size()>500) {
84 ShowerLib::StepInfoCollection::iterator i1 = m_eventSteps->begin();
85 while (i1 != m_eventSteps->end()) {
86 ShowerLib::StepInfoCollection::iterator i2 = i1 + 1;
87 while (i2 != m_eventSteps->end()) {
88 // if distance below cut off, combined and erase
89 if ( (i1 != i2) && ((*i1)->diff2(**i2) < dsame)) {
90 **i1 += **i2;
91 i2 = m_eventSteps->erase(i2);
92 } else {
93 ++i2;
94 }
95 }
96 ++i1;
97 }
98 }
99
100#ifdef _myDEBUG_
101 G4cout << "TestActionShowerLib::EndOfEventAction: After initial cleanup, N="
102 << m_eventSteps->size() << G4endl;
103#endif
104
105 //
106 // Put eventSteps into event store
107 //
108 std::string location("EventSteps");
109 StatusCode sc = m_evtStore->record( m_eventSteps, location, true );
110 if( sc.isFailure() ) {
111 G4cout << "TestActionShowerLib::EndOfEventAction Error: Couldn't store "
112 << "EventSteps object in event store at location: " << location << G4endl;
113 } else {
114#ifdef _myDEBUG_
115 G4cout << "TestActionShowerLib::EndOfEventAction: Stored EventSteps "
116 << "object (size: " << m_eventSteps->size() << ")"
117 << " in event store at location: " << location << G4endl;
118#endif
119 }
120 }
sc
static Double_t sc
Definition LArPhysWaveHECTool.cxx:37
DataVector< StepInfo >::iterator
DataModel_detail::iterator< DataVector > iterator
Definition DataVector.h:842
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22

◆ EndOfRunAction()

void G4UA::TestActionShowerLib::EndOfRunAction ( const G4Run * )
overridevirtual

Definition at line 160 of file TestActionShowerLib.cxx.

161 {
162#ifdef _myDEBUG_
163 G4cout << "#########################################" << G4endl
164 << "## TestActionShowerLib - EndOfRun ##" << G4endl
165 << "#########################################" << G4endl;
166#endif
167 }

◆ UserSteppingAction()

void G4UA::TestActionShowerLib::UserSteppingAction ( const G4Step * aStep)
overridevirtual

Definition at line 170 of file TestActionShowerLib.cxx.

171 {
172 bool hasCalc=true;
173 bool emptydet = (m_eventSteps->detector[0] == '\0'); //empty string. man, i hate pure C!
174 if (emptydet) { //give name to the detector, set calculator, transformation and G4Solid for the whole shower
175 G4ThreeVector pos = aStep->GetPostStepPoint()->GetPosition();
176 const G4TouchableHistory* theTouchable = static_cast<const G4TouchableHistory*>(aStep->GetPostStepPoint()->GetTouchable());
177 int depth = theTouchable->GetHistoryDepth();
178 bool correct_volume = false;
179 if (depth < 2) { //this is obviously the wrong volume
180 correct_volume = true; // this may appear misleading, but actually it means: "no need to look deeper"
181 }
182 G4VPhysicalVolume* rootVol = theTouchable->GetVolume(depth - 1);
183 int curdepth = 0;
184 m_current_transform->SetNetRotation(*(theTouchable->GetRotation(curdepth)));
185 m_current_transform->SetNetTranslation(theTouchable->GetTranslation(curdepth));
186 m_current_transform->Invert();
187 G4VPhysicalVolume* cur_volume = theTouchable->GetVolume(curdepth);
188 G4LogicalVolume* cur_log_volume = cur_volume->GetLogicalVolume();
189
190 do {
191 if ((cur_log_volume->GetName() == "LArMgr::LAr::FCAL::Module1::Absorber") ||
192 (cur_log_volume->GetName() == "LArMgr::LAr::FCAL::Module2::Absorber") ||
193 (cur_log_volume->GetName() == "LArMgr::LAr::EMEC::Pos::OuterWheel") ||
194 (cur_log_volume->GetName() == "LArMgr::LAr::EMEC::Neg::OuterWheel") ||
195 (cur_log_volume->GetName() == "LArMgr::LAr::EMEC::Pos::InnerWheel") ||
196 (cur_log_volume->GetName() == "LArMgr::LAr::EMEC::Neg::InnerWheel") ||
197 (cur_log_volume->GetName() == "LArMgr::LAr::EMB::STAC")) {
198 correct_volume = true;
199 }
200 if (!correct_volume) { //go one level up
201 curdepth++;
202 m_current_transform->SetNetRotation(*(theTouchable->GetRotation(curdepth)));
203 m_current_transform->SetNetTranslation(theTouchable->GetTranslation(curdepth));
204 cur_volume = theTouchable->GetVolume(curdepth);
205 cur_log_volume = cur_volume->GetLogicalVolume();
206 }
207 } while ((!correct_volume) && (cur_volume != rootVol) && (curdepth < (depth-1)));
208
209 m_current_solid = cur_log_volume->GetSolid();
210
211 if (cur_log_volume->GetName() == "LArMgr::LAr::FCAL::Module1::Absorber") {
212 // shower is inside FCAL1
213 m_current_calculator = m_calculator_FCAL1;
214 strcpy(m_eventSteps->detector,"FCAL1");
215 } else if (cur_log_volume->GetName() == "LArMgr::LAr::FCAL::Module2::Absorber") {
216 // shower is inside FCAL2
217 m_current_calculator = m_calculator_FCAL2;
218 strcpy(m_eventSteps->detector,"FCAL2");
219 } else if ((cur_log_volume->GetName() == "LArMgr::LAr::EMEC::Pos::InnerWheel") ||
220 (cur_log_volume->GetName() == "LArMgr::LAr::EMEC::Neg::InnerWheel")) {
221 // shower is inside inner EMEC
222 m_current_calculator = m_calculator_EMECIW;
223 strcpy(m_eventSteps->detector,"EMEC");
224 } else if ((cur_log_volume->GetName() == "LArMgr::LAr::EMEC::Pos::OuterWheel") ||
225 (cur_log_volume->GetName() == "LArMgr::LAr::EMEC::Neg::OuterWheel")) {
226 // shower is inside outer EMEC positive
227 m_current_calculator = m_calculator_EMECOW;
228 strcpy(m_eventSteps->detector,"EMEC");
229 } else if (cur_log_volume->GetName() == "LArMgr::LAr::EMB::STAC") {
230 // shower is inside EMB positive
231 m_current_calculator = m_calculator_EMB;
232 strcpy(m_eventSteps->detector,"EMB");
233 } else {
234 // outside.
235 //m_current_calculator = NULL;
236 hasCalc=false;
237 }
238 }
239
240 if (aStep->GetTotalEnergyDeposit()>0) {
241 //first, let's see if the shower is valid
242 if (!hasCalc) {
243 m_eventSteps->invalid_energy += aStep->GetTotalEnergyDeposit();
244 return;
245 }
246 //then, let's see if we travel outside the detector volume
247
248 // Initial position:
249 G4ThreeVector pos1=aStep->GetPreStepPoint()->GetPosition();
250 G4ThreeVector pos2=aStep->GetPostStepPoint()->GetPosition();
251
252 // Average position:
253 G4ThreeVector pos = 0.5*(pos1+pos2);
254
255 G4ThreeVector prepos = pos1;
256 m_current_transform->ApplyPointTransform(prepos);
257 if (m_current_solid->Inside(prepos) == kOutside) {
258 m_eventSteps->invalid_energy += aStep->GetTotalEnergyDeposit();
259 return;
260 }
261
262 G4VPhysicalVolume* pCurrentVolume = aStep->GetPreStepPoint()->GetPhysicalVolume();
263 if (!pCurrentVolume->GetLogicalVolume()->GetSensitiveDetector()){
264 return;
265 }
266
267 double et = 0; // Total collected charge
268 std::vector<LArHitData> results;
269 if (m_current_calculator->Process(aStep, results))
270 {
271 for (const auto& larhit: results)
272 {
273 et += larhit.energy;
274 }
275 }
276 else
277 {
278 G4cout << "Error: Hit not processed by calculator!" << G4endl;
279 return;
280 }
281
282 // drop hits with zero deposited energy (could still happen with negative corrections from calculator)
283 if (et <= 0.) {
284 return;
285 }
286
287 ShowerLib::StepInfo* theInfo = new ShowerLib::StepInfo();
288
289 theInfo->setE(et);
290
291#ifdef _myDEBUG_
292 G4cout<<" TAGINFO: "<< et <<" "<<aStep->GetTotalEnergyDeposit()<< G4endl;
293#endif
294
295 theInfo->setTime(aStep->GetPreStepPoint()->GetGlobalTime());
296
297 theInfo->setP(pos);
298
299 m_eventSteps->push_back(theInfo);
300
301 } else {
302#ifdef _myDEBUG_
303 G4cout << "DEBUG: step " << aStep->GetTotalEnergyDeposit() << G4endl;
304#endif
305 }
306 }
et
float et(const xAOD::jFexSRJetRoI *j)
Definition L1MonitorAdaptors.h:17
ShowerLib::StepInfo::setTime
void setTime(const double t)
set time
Definition StepInfo.h:57
ShowerLib::StepInfo::setP
void setP(const CLHEP::Hep3Vector &p)
set position
Definition StepInfo.h:47
ShowerLib::StepInfo::setE
void setE(const double t)
set depoisted energy
Definition StepInfo.h:55
depth
std::string depth
tag string for intendation
Definition fastadd.cxx:46

Member Data Documentation

◆ m_calculator_EMB

ServiceHandle<ILArCalculatorSvc> G4UA::TestActionShowerLib::m_calculator_EMB
private

Definition at line 81 of file TestActionShowerLib.h.

◆ m_calculator_EMECIW

ServiceHandle<ILArCalculatorSvc> G4UA::TestActionShowerLib::m_calculator_EMECIW
private

Pointer to EMEC inner wheel calculator.

Definition at line 75 of file TestActionShowerLib.h.

◆ m_calculator_EMECOW

ServiceHandle<ILArCalculatorSvc> G4UA::TestActionShowerLib::m_calculator_EMECOW
private

Pointer to EMEC outer wheel calculator.

Definition at line 77 of file TestActionShowerLib.h.

◆ m_calculator_FCAL1

ServiceHandle<ILArCalculatorSvc> G4UA::TestActionShowerLib::m_calculator_FCAL1
private

Definition at line 78 of file TestActionShowerLib.h.

◆ m_calculator_FCAL2

ServiceHandle<ILArCalculatorSvc> G4UA::TestActionShowerLib::m_calculator_FCAL2
private

Definition at line 79 of file TestActionShowerLib.h.

◆ m_calculator_FCAL3

ServiceHandle<ILArCalculatorSvc> G4UA::TestActionShowerLib::m_calculator_FCAL3
private

Definition at line 80 of file TestActionShowerLib.h.

◆ m_current_calculator

ServiceHandle<ILArCalculatorSvc> G4UA::TestActionShowerLib::m_current_calculator
private

Definition at line 67 of file TestActionShowerLib.h.

◆ m_current_solid

G4VSolid* G4UA::TestActionShowerLib::m_current_solid
private

Definition at line 68 of file TestActionShowerLib.h.

◆ m_current_transform

G4AffineTransform* G4UA::TestActionShowerLib::m_current_transform
private

Definition at line 69 of file TestActionShowerLib.h.

◆ m_eventSteps

ShowerLib::StepInfoCollection* G4UA::TestActionShowerLib::m_eventSteps
private

Collection of StepInfo.

Definition at line 86 of file TestActionShowerLib.h.

◆ m_evtStore

ServiceHandle<StoreGateSvc> G4UA::TestActionShowerLib::m_evtStore
private

Pointer to StoreGate (event store by default)

Definition at line 63 of file TestActionShowerLib.h.

The documentation for this class was generated from the following files:
Generated on for ATLAS Offline Software by doxygen 1.14.0