| Geant4 Cross Reference |
1 // 1 //
2 // ******************************************* 2 // ********************************************************************
3 // * License and Disclaimer 3 // * License and Disclaimer *
4 // * 4 // * *
5 // * The Geant4 software is copyright of th 5 // * The Geant4 software is copyright of the Copyright Holders of *
6 // * the Geant4 Collaboration. It is provided 6 // * the Geant4 Collaboration. It is provided under the terms and *
7 // * conditions of the Geant4 Software License 7 // * conditions of the Geant4 Software License, included in the file *
8 // * LICENSE and available at http://cern.ch/ 8 // * LICENSE and available at http://cern.ch/geant4/license . These *
9 // * include a list of copyright holders. 9 // * include a list of copyright holders. *
10 // * 10 // * *
11 // * Neither the authors of this software syst 11 // * Neither the authors of this software system, nor their employing *
12 // * institutes,nor the agencies providing fin 12 // * institutes,nor the agencies providing financial support for this *
13 // * work make any representation or warran 13 // * work make any representation or warranty, express or implied, *
14 // * regarding this software system or assum 14 // * regarding this software system or assume any liability for its *
15 // * use. Please see the license in the file 15 // * use. Please see the license in the file LICENSE and URL above *
16 // * for the full disclaimer and the limitatio 16 // * for the full disclaimer and the limitation of liability. *
17 // * 17 // * *
18 // * This code implementation is the result 18 // * This code implementation is the result of the scientific and *
19 // * technical work of the GEANT4 collaboratio 19 // * technical work of the GEANT4 collaboration. *
20 // * By using, copying, modifying or distri 20 // * By using, copying, modifying or distributing the software (or *
21 // * any work based on the software) you ag 21 // * any work based on the software) you agree to acknowledge its *
22 // * use in resulting scientific publicati 22 // * use in resulting scientific publications, and indicate your *
23 // * acceptance of all terms of the Geant4 Sof 23 // * acceptance of all terms of the Geant4 Software license. *
24 // ******************************************* 24 // ********************************************************************
25 // 25 //
26 // 26 //
>> 27 // $Id$
27 // 28 //
28 29
29 // G4SDStructure 30 // G4SDStructure
30 #include "G4SDStructure.hh" 31 #include "G4SDStructure.hh"
31 <<
32 #include "G4ios.hh" 32 #include "G4ios.hh"
33 33
34 G4SDStructure::G4SDStructure(const G4String& a << 34 G4SDStructure::G4SDStructure(G4String aPath):verboseLevel(0)
35 { 35 {
36 pathName = aPath; 36 pathName = aPath;
37 dirName = aPath; 37 dirName = aPath;
38 auto i = dirName.length(); << 38 G4int i = dirName.length();
39 if (i > 1) { << 39 if( i > 1 )
40 dirName.erase(i - 1); << 40 {
41 auto isl = dirName.rfind('/'); << 41 dirName.remove(i-1);
42 dirName.erase(0, isl + 1); << 42 G4int isl = dirName.last('/');
>> 43 dirName.remove(0,isl+1);
43 dirName += "/"; 44 dirName += "/";
44 } 45 }
45 } 46 }
46 47
47 G4SDStructure::~G4SDStructure() 48 G4SDStructure::~G4SDStructure()
48 { 49 {
49 for (auto st : structure) << 50 for(auto st : structure) delete st;
50 delete st; <<
51 structure.clear(); 51 structure.clear();
52 for (auto dt : detector) << 52 for(auto dt : detector) delete dt;
53 delete dt; <<
54 detector.clear(); 53 detector.clear();
55 } 54 }
56 55
57 G4bool G4SDStructure::operator==(const G4SDStr << 56 G4int G4SDStructure::operator==(const G4SDStructure &right) const
>> 57 {
>> 58 return (this==&right);
>> 59 }
58 60
59 void G4SDStructure::AddNewDetector(G4VSensitiv << 61 void G4SDStructure::AddNewDetector(G4VSensitiveDetector*aSD,
>> 62 G4String treeStructure)
60 { 63 {
61 G4String remainingPath = treeStructure; 64 G4String remainingPath = treeStructure;
62 remainingPath.erase(0, pathName.length()); << 65 remainingPath.remove(0,pathName.length());
63 if (! remainingPath.empty()) { // The detec << 66 if( ! remainingPath.isNull() )
64 // First, ch << 67 { // The detector should be kept in subdirectory.
65 G4String subD = ExtractDirName(remainingPa << 68 // First, check if the subdirectoy exists.
>> 69 G4String subD = ExtractDirName( remainingPath );
66 G4SDStructure* tgtSDS = FindSubDirectory(s 70 G4SDStructure* tgtSDS = FindSubDirectory(subD);
67 if (tgtSDS == nullptr) { // Subdirectory << 71 if( tgtSDS == nullptr )
68 subD.insert(0, pathName); << 72 { // Subdirectory not found. Create a new directory.
>> 73 subD.prepend(pathName);
69 tgtSDS = new G4SDStructure(subD); 74 tgtSDS = new G4SDStructure(subD);
70 structure.push_back(tgtSDS); << 75 structure.push_back( tgtSDS );
71 } 76 }
72 tgtSDS->AddNewDetector(aSD, treeStructure) << 77 tgtSDS->AddNewDetector(aSD,treeStructure);
73 } 78 }
74 else { // The sensitive detector should be << 79 else
75 G4VSensitiveDetector* tgtSD = GetSD(aSD->G << 80 { // The sensitive detector should be kept in this directory.
76 if (tgtSD == nullptr) { << 81 G4VSensitiveDetector* tgtSD = GetSD( aSD->GetName() );
77 detector.push_back(aSD); << 82 if(!tgtSD)
78 } << 83 { detector.push_back( aSD ); }
79 else if (tgtSD != aSD) { << 84 else if( tgtSD != aSD )
>> 85 {
80 #ifdef G4VERBOSE 86 #ifdef G4VERBOSE
81 G4ExceptionDescription ed; 87 G4ExceptionDescription ed;
82 ed << aSD->GetName() << " had already be << 88 ed << aSD->GetName() << " had already been stored in "
83 << ". Object pointer is overwritten.\ << 89 << pathName << ". Object pointer is overwitten.\n";
84 ed << "It's users' responsibility to del << 90 ed << "It's users' responsibility to delete the old sensitive detector object.";
85 "object."; << 91 G4Exception("G4SDStructure::AddNewDetector()","DET1010",JustWarning,ed);
86 G4Exception("G4SDStructure::AddNewDetect <<
87 #endif 92 #endif
88 RemoveSD(tgtSD); << 93 RemoveSD( tgtSD );
89 detector.push_back(aSD); << 94 detector.push_back( aSD );
90 } 95 }
91 } 96 }
92 } 97 }
93 98
94 G4SDStructure* G4SDStructure::FindSubDirectory << 99 G4SDStructure* G4SDStructure::FindSubDirectory(G4String subD)
95 { 100 {
96 for (auto st : structure) { << 101 for(auto st : structure)
97 if (subD == st->dirName) return st; << 102 { if( subD == st->dirName ) return st; }
98 } <<
99 return nullptr; 103 return nullptr;
100 } 104 }
101 105
102 G4VSensitiveDetector* G4SDStructure::GetSD(con << 106 G4VSensitiveDetector* G4SDStructure::GetSD(G4String aSDName)
103 { 107 {
104 for (auto det : detector) { << 108 for(auto det : detector)
105 if (aSDName == det->GetName()) return det; << 109 { if(aSDName == det->GetName()) return det; }
106 } <<
107 return nullptr; 110 return nullptr;
108 } 111 }
109 112
110 void G4SDStructure::RemoveSD(G4VSensitiveDetec 113 void G4SDStructure::RemoveSD(G4VSensitiveDetector* sd)
111 { 114 {
112 auto det = std::find(detector.begin(), detec 115 auto det = std::find(detector.begin(), detector.end(), sd);
113 if (det != detector.end()) detector.erase(de << 116 if(det!=detector.end()) detector.erase(det);
114 } 117 }
115 118
116 G4String G4SDStructure::ExtractDirName(const G << 119 G4String G4SDStructure::ExtractDirName(G4String aName)
117 { 120 {
118 G4String subD = aName; 121 G4String subD = aName;
119 auto i = aName.find('/'); << 122 G4int i = aName.first('/');
120 if (i != G4String::npos) subD.erase(i + 1); << 123 if( i != G4int(std::string::npos) ) subD.remove(i+1);
121 return subD; 124 return subD;
122 } 125 }
123 126
124 void G4SDStructure::Activate(const G4String& a << 127 void G4SDStructure::Activate(G4String aName, G4bool sensitiveFlag)
125 { 128 {
126 G4String aPath = aName; 129 G4String aPath = aName;
127 aPath.erase(0, pathName.length()); << 130 aPath.remove(0,pathName.length());
128 if (aPath.find('/') != std::string::npos) { << 131 if( aPath.first('/') != G4int(std::string::npos) )
>> 132 { // Command is ordered for a subdirectory.
129 G4String subD = ExtractDirName(aPath); 133 G4String subD = ExtractDirName(aPath);
130 G4SDStructure* tgtSDS = FindSubDirectory(s 134 G4SDStructure* tgtSDS = FindSubDirectory(subD);
131 if (tgtSDS == nullptr) { // The subdirect << 135 if( tgtSDS == nullptr )
>> 136 { // The subdirectory is not found
132 G4cout << subD << " is not found in " << 137 G4cout << subD << " is not found in " << pathName << G4endl;
133 } 138 }
134 else { << 139 else
135 tgtSDS->Activate(aName, sensitiveFlag); << 140 {
>> 141 tgtSDS->Activate(aName,sensitiveFlag);
136 } 142 }
137 } 143 }
138 else if (aPath.empty()) { // Command is ord << 144 else if( aPath.isNull() )
139 for (auto det : detector) << 145 { // Command is ordered for all detectors in this directory.
140 det->Activate(sensitiveFlag); << 146 for(auto det : detector) det->Activate(sensitiveFlag);
141 for (auto st : structure) << 147 for(auto st : structure) st->Activate(G4String("/"),sensitiveFlag);
142 st->Activate(G4String("/"), sensitiveFla <<
143 } 148 }
144 else { // Command is ordered to a particula << 149 else
>> 150 { // Command is ordered to a particular detector.
145 G4VSensitiveDetector* tgtSD = GetSD(aPath) 151 G4VSensitiveDetector* tgtSD = GetSD(aPath);
146 if (tgtSD == nullptr) { // The detector i << 152 if( tgtSD == nullptr )
>> 153 { // The detector is not found.
147 G4cout << aPath << " is not found in " < 154 G4cout << aPath << " is not found in " << pathName << G4endl;
148 } 155 }
149 else { << 156 else
>> 157 {
150 tgtSD->Activate(sensitiveFlag); 158 tgtSD->Activate(sensitiveFlag);
151 } 159 }
152 } 160 }
153 } 161 }
154 162
155 G4VSensitiveDetector* G4SDStructure::FindSensi << 163 G4VSensitiveDetector* G4SDStructure::FindSensitiveDetector(G4String aName, G4bool warning)
156 { 164 {
157 G4String aPath = aName; 165 G4String aPath = aName;
158 aPath.erase(0, pathName.length()); << 166 aPath.remove(0,pathName.length());
159 if (aPath.find('/') != std::string::npos) { << 167 if( aPath.first('/') != G4int(std::string::npos) )
>> 168 { // SD exists in sub-directory
160 G4String subD = ExtractDirName(aPath); 169 G4String subD = ExtractDirName(aPath);
161 G4SDStructure* tgtSDS = FindSubDirectory(s 170 G4SDStructure* tgtSDS = FindSubDirectory(subD);
162 if (tgtSDS == nullptr) { // The subdirect << 171 if( tgtSDS == nullptr )
163 if (warning) G4cout << subD << " is not << 172 { // The subdirectory is not found
>> 173 if (warning)
>> 174 G4cout << subD << " is not found in " << pathName << G4endl;
164 return nullptr; 175 return nullptr;
165 } 176 }
166 << 177 else
167 return tgtSDS->FindSensitiveDetector(aName << 178 {
>> 179 return tgtSDS->FindSensitiveDetector(aName,warning);
>> 180 }
168 } 181 }
169 << 182 else
170 // SD must exist in this directory << 183 { // SD must exist in this directory
171 G4VSensitiveDetector* tgtSD = GetSD(aPath); << 184 G4VSensitiveDetector* tgtSD = GetSD(aPath);
172 if (tgtSD == nullptr) { // The detector is << 185 if( tgtSD == nullptr )
173 if (warning) G4cout << aPath << " is not f << 186 { // The detector is not found.
>> 187 if (warning)
>> 188 G4cout << aPath << " is not found in " << pathName << G4endl;
>> 189 }
>> 190 return tgtSD;
174 } 191 }
175 return tgtSD; <<
176 } 192 }
177 193
178 void G4SDStructure::Initialize(G4HCofThisEvent << 194 void G4SDStructure::Initialize(G4HCofThisEvent*HCE)
179 { 195 {
180 // Broadcast to subdirectories. 196 // Broadcast to subdirectories.
181 for (auto st : structure) { << 197 for(auto st : structure)
182 st->Initialize(HCE); << 198 { st->Initialize(HCE); }
183 } <<
184 // Initialize all detectors in this director 199 // Initialize all detectors in this directory.
185 for (auto dt : detector) { << 200 for(auto dt : detector)
186 if (dt->isActive()) dt->Initialize(HCE); << 201 { if(dt->isActive()) dt->Initialize(HCE); }
187 } <<
188 } 202 }
189 203
190 void G4SDStructure::Terminate(G4HCofThisEvent* << 204 void G4SDStructure::Terminate(G4HCofThisEvent*HCE)
191 { 205 {
192 // Broadcast to subdirectories. 206 // Broadcast to subdirectories.
193 for (auto st : structure) { << 207 for(auto st : structure)
194 st->Terminate(HCE); << 208 { st->Terminate(HCE); }
195 } <<
196 // Terminate all detectors in this directory 209 // Terminate all detectors in this directory.
197 for (auto dt : detector) { << 210 for(auto dt : detector)
198 if (dt->isActive()) dt->EndOfEvent(HCE); << 211 { if(dt->isActive()) dt->EndOfEvent(HCE); }
199 } <<
200 } 212 }
201 213
202 void G4SDStructure::ListTree() 214 void G4SDStructure::ListTree()
203 { 215 {
204 G4cout << pathName << G4endl; 216 G4cout << pathName << G4endl;
205 for (auto sd : detector) { << 217 for(auto sd : detector)
>> 218 {
206 G4cout << pathName << sd->GetName(); 219 G4cout << pathName << sd->GetName();
207 if (sd->isActive()) { << 220 if( sd->isActive() )
208 G4cout << " *** Active "; << 221 { G4cout << " *** Active "; }
209 } << 222 else
210 else { << 223 { G4cout << " XXX Inactive "; }
211 G4cout << " XXX Inactive "; <<
212 } <<
213 G4cout << G4endl; 224 G4cout << G4endl;
214 } 225 }
215 for (auto st : structure) << 226 for(auto st : structure) st->ListTree();
216 st->ListTree(); <<
217 } 227 }
>> 228
>> 229
218 230