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: G4SDStructure.cc 74576 2013-10-15 07:20:11Z gcosmo $ 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 size_t nTree = structure.size(); 50 delete st; << 51 for(size_t iTree=0;iTree<nTree;iTree++) 51 structure.clear(); << 52 { delete structure[iTree]; } 52 for (auto dt : detector) << 53 size_t nDet = detector.size(); 53 delete dt; << 54 for(size_t iDet=0;iDet<nDet;iDet++) 54 detector.clear(); << 55 { delete detector[iDet]; } 55 } 56 } 56 57 57 G4bool G4SDStructure::operator==(const G4SDStr << 58 G4int G4SDStructure::operator==(const G4SDStructure &right) const >> 59 { >> 60 return (this==&right); >> 61 } 58 62 59 void G4SDStructure::AddNewDetector(G4VSensitiv << 63 void G4SDStructure::AddNewDetector(G4VSensitiveDetector*aSD, >> 64 G4String treeStructure) 60 { 65 { 61 G4String remainingPath = treeStructure; 66 G4String remainingPath = treeStructure; 62 remainingPath.erase(0, pathName.length()); << 67 remainingPath.remove(0,pathName.length()); 63 if (! remainingPath.empty()) { // The detec << 68 if( ! remainingPath.isNull() ) 64 // First, ch << 69 { // The detector should be kept in subdirectory. 65 G4String subD = ExtractDirName(remainingPa << 70 // First, check if the subdirectoy exists. >> 71 G4String subD = ExtractDirName( remainingPath ); 66 G4SDStructure* tgtSDS = FindSubDirectory(s 72 G4SDStructure* tgtSDS = FindSubDirectory(subD); 67 if (tgtSDS == nullptr) { // Subdirectory << 73 if( tgtSDS == 0 ) 68 subD.insert(0, pathName); << 74 { // Subdirectory not found. Create a new directory. >> 75 subD.prepend(pathName); 69 tgtSDS = new G4SDStructure(subD); 76 tgtSDS = new G4SDStructure(subD); 70 structure.push_back(tgtSDS); << 77 structure.push_back( tgtSDS ); 71 } 78 } 72 tgtSDS->AddNewDetector(aSD, treeStructure) << 79 tgtSDS->AddNewDetector(aSD,treeStructure); 73 } 80 } 74 else { // The sensitive detector should be << 81 else 75 G4VSensitiveDetector* tgtSD = GetSD(aSD->G << 82 { // The sensitive detector should be kept in this directory. 76 if (tgtSD == nullptr) { << 83 G4VSensitiveDetector* tgtSD = GetSD( aSD->GetName() ); 77 detector.push_back(aSD); << 84 if(!tgtSD) 78 } << 85 { detector.push_back( aSD ); } 79 else if (tgtSD != aSD) { << 86 else if( tgtSD != aSD ) >> 87 { 80 #ifdef G4VERBOSE 88 #ifdef G4VERBOSE 81 G4ExceptionDescription ed; 89 G4ExceptionDescription ed; 82 ed << aSD->GetName() << " had already be << 90 ed << aSD->GetName() << " had already been stored in " 83 << ". Object pointer is overwritten.\ << 91 << pathName << ". Object pointer is overwitten.\n"; 84 ed << "It's users' responsibility to del << 92 ed << "It's users' responsibility to delete the old sensitive detector object."; 85 "object."; << 93 G4Exception("G4SDStructure::AddNewDetector()","DET1010",JustWarning,ed); 86 G4Exception("G4SDStructure::AddNewDetect << 87 #endif 94 #endif 88 RemoveSD(tgtSD); << 95 RemoveSD( tgtSD ); 89 detector.push_back(aSD); << 96 detector.push_back( aSD ); 90 } 97 } 91 } 98 } 92 } 99 } 93 100 94 G4SDStructure* G4SDStructure::FindSubDirectory << 101 G4SDStructure* G4SDStructure::FindSubDirectory(G4String subD) 95 { 102 { 96 for (auto st : structure) { << 103 for( size_t i=0; i<structure.size(); i++ ) 97 if (subD == st->dirName) return st; << 104 { 98 } << 105 if( subD == structure[i]->dirName ) return structure[i]; 99 return nullptr; << 106 } >> 107 return 0; 100 } 108 } 101 109 102 G4VSensitiveDetector* G4SDStructure::GetSD(con << 110 G4VSensitiveDetector* G4SDStructure::GetSD(G4String aSDName) 103 { 111 { 104 for (auto det : detector) { << 112 for( size_t i=0; i<detector.size(); i++ ) 105 if (aSDName == det->GetName()) return det; << 113 { >> 114 G4VSensitiveDetector* tgtSD = detector[i]; >> 115 if( aSDName == tgtSD->GetName() ) return tgtSD; 106 } 116 } 107 return nullptr; << 117 return 0; 108 } 118 } 109 119 110 void G4SDStructure::RemoveSD(G4VSensitiveDetec 120 void G4SDStructure::RemoveSD(G4VSensitiveDetector* sd) 111 { 121 { 112 auto det = std::find(detector.begin(), detec << 122 std::vector<G4VSensitiveDetector*>::iterator itr = detector.begin(); 113 if (det != detector.end()) detector.erase(de << 123 for(;itr!=detector.end();itr++) >> 124 { >> 125 if((*itr)==sd) { >> 126 detector.erase(itr); >> 127 break; >> 128 } >> 129 } 114 } 130 } 115 131 116 G4String G4SDStructure::ExtractDirName(const G << 132 G4String G4SDStructure::ExtractDirName(G4String aName) 117 { 133 { 118 G4String subD = aName; 134 G4String subD = aName; 119 auto i = aName.find('/'); << 135 G4int i = aName.first('/'); 120 if (i != G4String::npos) subD.erase(i + 1); << 136 if( i != G4int(std::string::npos) ) subD.remove(i+1); 121 return subD; 137 return subD; 122 } 138 } 123 139 124 void G4SDStructure::Activate(const G4String& a << 140 void G4SDStructure::Activate(G4String aName, G4bool sensitiveFlag) 125 { 141 { 126 G4String aPath = aName; 142 G4String aPath = aName; 127 aPath.erase(0, pathName.length()); << 143 aPath.remove(0,pathName.length()); 128 if (aPath.find('/') != std::string::npos) { << 144 if( aPath.first('/') != G4int(std::string::npos) ) >> 145 { // Command is ordered for a subdirectory. 129 G4String subD = ExtractDirName(aPath); 146 G4String subD = ExtractDirName(aPath); 130 G4SDStructure* tgtSDS = FindSubDirectory(s 147 G4SDStructure* tgtSDS = FindSubDirectory(subD); 131 if (tgtSDS == nullptr) { // The subdirect << 148 if( tgtSDS == 0 ) >> 149 { // The subdirectory is not found 132 G4cout << subD << " is not found in " << 150 G4cout << subD << " is not found in " << pathName << G4endl; 133 } 151 } 134 else { << 152 else 135 tgtSDS->Activate(aName, sensitiveFlag); << 153 { >> 154 tgtSDS->Activate(aName,sensitiveFlag); 136 } 155 } 137 } 156 } 138 else if (aPath.empty()) { // Command is ord << 157 else if( aPath.isNull() ) 139 for (auto det : detector) << 158 { // Command is ordered for all detectors in this directory. 140 det->Activate(sensitiveFlag); << 159 for( size_t i=0; i<detector.size(); i++) 141 for (auto st : structure) << 160 { 142 st->Activate(G4String("/"), sensitiveFla << 161 detector[i]->Activate(sensitiveFlag); >> 162 } >> 163 for( size_t j=0;j<structure.size(); j++) >> 164 { >> 165 structure[j]->Activate(G4String("/"),sensitiveFlag); >> 166 } 143 } 167 } 144 else { // Command is ordered to a particula << 168 else >> 169 { // Command is ordered to a particular detector. 145 G4VSensitiveDetector* tgtSD = GetSD(aPath) 170 G4VSensitiveDetector* tgtSD = GetSD(aPath); 146 if (tgtSD == nullptr) { // The detector i << 171 if( tgtSD == 0 ) >> 172 { // The detector is not found. 147 G4cout << aPath << " is not found in " < 173 G4cout << aPath << " is not found in " << pathName << G4endl; 148 } 174 } 149 else { << 175 else >> 176 { 150 tgtSD->Activate(sensitiveFlag); 177 tgtSD->Activate(sensitiveFlag); 151 } 178 } 152 } 179 } 153 } 180 } 154 181 155 G4VSensitiveDetector* G4SDStructure::FindSensi << 182 G4VSensitiveDetector* G4SDStructure::FindSensitiveDetector(G4String aName, G4bool warning) 156 { 183 { 157 G4String aPath = aName; 184 G4String aPath = aName; 158 aPath.erase(0, pathName.length()); << 185 aPath.remove(0,pathName.length()); 159 if (aPath.find('/') != std::string::npos) { << 186 if( aPath.first('/') != G4int(std::string::npos) ) >> 187 { // SD exists in sub-directory 160 G4String subD = ExtractDirName(aPath); 188 G4String subD = ExtractDirName(aPath); 161 G4SDStructure* tgtSDS = FindSubDirectory(s 189 G4SDStructure* tgtSDS = FindSubDirectory(subD); 162 if (tgtSDS == nullptr) { // The subdirect << 190 if( tgtSDS == 0 ) 163 if (warning) G4cout << subD << " is not << 191 { // The subdirectory is not found 164 return nullptr; << 192 if (warning) >> 193 G4cout << subD << " is not found in " << pathName << G4endl; >> 194 return 0; >> 195 } >> 196 else >> 197 { >> 198 return tgtSDS->FindSensitiveDetector(aName); 165 } 199 } 166 << 167 return tgtSDS->FindSensitiveDetector(aName << 168 } 200 } 169 << 201 else 170 // SD must exist in this directory << 202 { // SD must exist in this directory 171 G4VSensitiveDetector* tgtSD = GetSD(aPath); << 203 G4VSensitiveDetector* tgtSD = GetSD(aPath); 172 if (tgtSD == nullptr) { // The detector is << 204 if( tgtSD == 0 ) 173 if (warning) G4cout << aPath << " is not f << 205 { // The detector is not found. >> 206 if (warning) >> 207 G4cout << aPath << " is not found in " << pathName << G4endl; >> 208 } >> 209 return tgtSD; 174 } 210 } 175 return tgtSD; << 176 } 211 } 177 212 178 void G4SDStructure::Initialize(G4HCofThisEvent << 213 void G4SDStructure::Initialize(G4HCofThisEvent*HCE) 179 { 214 { >> 215 size_t i; 180 // Broadcast to subdirectories. 216 // Broadcast to subdirectories. 181 for (auto st : structure) { << 217 for( i=0; i<structure.size(); i++ ) 182 st->Initialize(HCE); << 218 { >> 219 structure[i]->Initialize(HCE); 183 } 220 } 184 // Initialize all detectors in this director 221 // Initialize all detectors in this directory. 185 for (auto dt : detector) { << 222 for( i=0; i<detector.size(); i++ ) 186 if (dt->isActive()) dt->Initialize(HCE); << 223 { >> 224 if(detector[i]->isActive()) detector[i]->Initialize(HCE); 187 } 225 } 188 } 226 } 189 227 190 void G4SDStructure::Terminate(G4HCofThisEvent* << 228 void G4SDStructure::Terminate(G4HCofThisEvent*HCE) 191 { 229 { >> 230 size_t i; 192 // Broadcast to subdirectories. 231 // Broadcast to subdirectories. 193 for (auto st : structure) { << 232 for( i=0; i<structure.size(); i++ ) 194 st->Terminate(HCE); << 233 { >> 234 structure[i]->Terminate(HCE); 195 } 235 } 196 // Terminate all detectors in this directory << 236 // Initialize all detectors in this directory. 197 for (auto dt : detector) { << 237 for( i=0; i<detector.size(); i++ ) 198 if (dt->isActive()) dt->EndOfEvent(HCE); << 238 { >> 239 if(detector[i]->isActive()) detector[i]->EndOfEvent(HCE); 199 } 240 } 200 } 241 } 201 242 202 void G4SDStructure::ListTree() 243 void G4SDStructure::ListTree() 203 { 244 { 204 G4cout << pathName << G4endl; 245 G4cout << pathName << G4endl; 205 for (auto sd : detector) { << 246 for(size_t i=0; i<detector.size(); i++) >> 247 { >> 248 G4VSensitiveDetector* sd = detector[i]; 206 G4cout << pathName << sd->GetName(); 249 G4cout << pathName << sd->GetName(); 207 if (sd->isActive()) { << 250 if( sd->isActive() ) 208 G4cout << " *** Active "; << 251 { G4cout << " *** Active "; } 209 } << 252 else 210 else { << 253 { G4cout << " XXX Inactive "; } 211 G4cout << " XXX Inactive "; << 212 } << 213 G4cout << G4endl; 254 G4cout << G4endl; 214 } 255 } 215 for (auto st : structure) << 256 for(size_t j=0; j<structure.size(); j++) 216 st->ListTree(); << 257 { structure[j]->ListTree(); } 217 } 258 } >> 259 >> 260 218 261