Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/run/src/G4VModularPhysicsList.cc

Version: [ ReleaseNotes ] [ 1.0 ] [ 1.1 ] [ 2.0 ] [ 3.0 ] [ 3.1 ] [ 3.2 ] [ 4.0 ] [ 4.0.p1 ] [ 4.0.p2 ] [ 4.1 ] [ 4.1.p1 ] [ 5.0 ] [ 5.0.p1 ] [ 5.1 ] [ 5.1.p1 ] [ 5.2 ] [ 5.2.p1 ] [ 5.2.p2 ] [ 6.0 ] [ 6.0.p1 ] [ 6.1 ] [ 6.2 ] [ 6.2.p1 ] [ 6.2.p2 ] [ 7.0 ] [ 7.0.p1 ] [ 7.1 ] [ 7.1.p1 ] [ 8.0 ] [ 8.0.p1 ] [ 8.1 ] [ 8.1.p1 ] [ 8.1.p2 ] [ 8.2 ] [ 8.2.p1 ] [ 8.3 ] [ 8.3.p1 ] [ 8.3.p2 ] [ 9.0 ] [ 9.0.p1 ] [ 9.0.p2 ] [ 9.1 ] [ 9.1.p1 ] [ 9.1.p2 ] [ 9.1.p3 ] [ 9.2 ] [ 9.2.p1 ] [ 9.2.p2 ] [ 9.2.p3 ] [ 9.2.p4 ] [ 9.3 ] [ 9.3.p1 ] [ 9.3.p2 ] [ 9.4 ] [ 9.4.p1 ] [ 9.4.p2 ] [ 9.4.p3 ] [ 9.4.p4 ] [ 9.5 ] [ 9.5.p1 ] [ 9.5.p2 ] [ 9.6 ] [ 9.6.p1 ] [ 9.6.p2 ] [ 9.6.p3 ] [ 9.6.p4 ] [ 10.0 ] [ 10.0.p1 ] [ 10.0.p2 ] [ 10.0.p3 ] [ 10.0.p4 ] [ 10.1 ] [ 10.1.p1 ] [ 10.1.p2 ] [ 10.1.p3 ] [ 10.2 ] [ 10.2.p1 ] [ 10.2.p2 ] [ 10.2.p3 ] [ 10.3 ] [ 10.3.p1 ] [ 10.3.p2 ] [ 10.3.p3 ] [ 10.4 ] [ 10.4.p1 ] [ 10.4.p2 ] [ 10.4.p3 ] [ 10.5 ] [ 10.5.p1 ] [ 10.6 ] [ 10.6.p1 ] [ 10.6.p2 ] [ 10.6.p3 ] [ 10.7 ] [ 10.7.p1 ] [ 10.7.p2 ] [ 10.7.p3 ] [ 10.7.p4 ] [ 11.0 ] [ 11.0.p1 ] [ 11.0.p2 ] [ 11.0.p3, ] [ 11.0.p4 ] [ 11.1 ] [ 11.1.1 ] [ 11.1.2 ] [ 11.1.3 ] [ 11.2 ] [ 11.2.1 ] [ 11.2.2 ] [ 11.3.0 ]

  1 //
  2 // ********************************************************************
  3 // * License and Disclaimer                                           *
  4 // *                                                                  *
  5 // * The  Geant4 software  is  copyright of the Copyright Holders  of *
  6 // * the Geant4 Collaboration.  It is provided  under  the terms  and *
  7 // * conditions of the Geant4 Software License,  included in the file *
  8 // * LICENSE and available at  http://cern.ch/geant4/license .  These *
  9 // * include a list of copyright holders.                             *
 10 // *                                                                  *
 11 // * Neither the authors of this software system, nor their employing *
 12 // * institutes,nor the agencies providing financial support for this *
 13 // * work  make  any representation or  warranty, express or implied, *
 14 // * regarding  this  software system or assume any liability for its *
 15 // * use.  Please see the license in the file  LICENSE  and URL above *
 16 // * for the full disclaimer and the limitation of liability.         *
 17 // *                                                                  *
 18 // * This  code  implementation is the result of  the  scientific and *
 19 // * technical work of the GEANT4 collaboration.                      *
 20 // * By using,  copying,  modifying or  distributing the software (or *
 21 // * any work based  on the software)  you  agree  to acknowledge its *
 22 // * use  in  resulting  scientific  publications,  and indicate your *
 23 // * acceptance of all terms of the Geant4 Software license.          *
 24 // ********************************************************************
 25 //
 26 // G4VModularPhysicsList implementation
 27 //
 28 // Original author: H.Kurashige (Kobe University), 12 November 2000
 29 // --------------------------------------------------------------------
 30 
 31 #include "G4VModularPhysicsList.hh"
 32 
 33 #include "G4StateManager.hh"
 34 
 35 #include <algorithm>
 36 
 37 // This macros change the references to fields that are now encapsulated
 38 // in the class G4VMPLData.
 39 #define G4MT_physicsVector ((G4VMPLsubInstanceManager.offset[g4vmplInstanceID]).physicsVector)
 40 
 41 G4VMPLManager G4VModularPhysicsList::G4VMPLsubInstanceManager;
 42 
 43 // --------------------------------------------------------------------
 44 void G4VMPLData::initialize()
 45 {
 46   physicsVector = new G4PhysConstVectorData();
 47 }
 48 
 49 // --------------------------------------------------------------------
 50 G4VModularPhysicsList::G4VModularPhysicsList()
 51 {
 52   g4vmplInstanceID = G4VMPLsubInstanceManager.CreateSubInstance();
 53 }
 54 
 55 // --------------------------------------------------------------------
 56 G4VModularPhysicsList::~G4VModularPhysicsList()
 57 {
 58   if (G4MT_physicsVector != nullptr) {
 59     for (auto& ptr : *G4MT_physicsVector) {
 60       delete ptr;
 61     }
 62     delete G4MT_physicsVector;
 63     G4MT_physicsVector = nullptr;
 64   }
 65 }
 66 
 67 // --------------------------------------------------------------------
 68 G4VModularPhysicsList::G4VModularPhysicsList(const G4VModularPhysicsList& right)
 69   : G4VUserPhysicsList(right)
 70 {
 71   g4vmplInstanceID = G4VMPLsubInstanceManager.CreateSubInstance();
 72   G4MT_physicsVector = nullptr;
 73 }
 74 
 75 // --------------------------------------------------------------------
 76 G4VModularPhysicsList& G4VModularPhysicsList::operator=(const G4VModularPhysicsList& right)
 77 {
 78   if (this != &right) {
 79     defaultCutValue = right.defaultCutValue;
 80     isSetDefaultCutValue = right.isSetDefaultCutValue;
 81     fRetrievePhysicsTable = right.fRetrievePhysicsTable;
 82     fStoredInAscii = right.fStoredInAscii;
 83     fIsCheckedForRetrievePhysicsTable = right.fIsCheckedForRetrievePhysicsTable;
 84     fIsRestoredCutValues = right.fIsRestoredCutValues;
 85     directoryPhysicsTable = right.directoryPhysicsTable;
 86     (this->subInstanceManager.offset[this->g4vuplInstanceID])._fDisplayThreshold =
 87       static_cast<const G4VUserPhysicsList&>(right)
 88         .GetSubInstanceManager()
 89         .offset[right.GetInstanceID()]
 90         ._fDisplayThreshold;
 91     (this->subInstanceManager.offset[this->g4vuplInstanceID])._fDisplayThreshold =
 92       static_cast<G4int>(static_cast<const G4VUserPhysicsList&>(right)
 93                            .GetSubInstanceManager()
 94                            .offset[right.GetInstanceID()]
 95                            ._fIsPhysicsTableBuilt);
 96     fDisableCheckParticleList = right.fDisableCheckParticleList;
 97     verboseLevel = right.verboseLevel;
 98 
 99     if (G4MT_physicsVector != nullptr) {
100       for (auto& ptr : *G4MT_physicsVector) {
101         delete ptr;
102       }
103       delete G4MT_physicsVector;
104       G4MT_physicsVector = nullptr;
105     }
106     g4vmplInstanceID = G4VMPLsubInstanceManager.CreateSubInstance();
107   }
108   return *this;
109 }
110 
111 // --------------------------------------------------------------------
112 void G4VModularPhysicsList::ConstructParticle()
113 {
114   // create particles
115   for (auto itr = G4MT_physicsVector->cbegin(); itr != G4MT_physicsVector->cend(); ++itr) {
116     (*itr)->ConstructParticle();
117   }
118 }
119 
120 // --------------------------------------------------------------------
121 // Andrea Dotti: May 6 2013
122 // Current limitation being debugged: Construction of physics processes
123 // needs to be sequential (there is at least one HAD processes creating
124 // problems). This is not yet understood and needs to be debugged. We do not
125 // want this part to be sequential (imagine when one has 100 threads)
126 // TODO: Remove this lock
127 #include "G4AutoLock.hh"
128 namespace
129 {
130 G4Mutex constructProcessMutex = G4MUTEX_INITIALIZER;
131 }
132 
133 // --------------------------------------------------------------------
134 void G4VModularPhysicsList::ConstructProcess()
135 {
136   G4AutoLock l(&constructProcessMutex);  // Protection to be removed (A.Dotti)
137   AddTransportation();
138 
139   for (auto itr = G4MT_physicsVector->cbegin(); itr != G4MT_physicsVector->cend(); ++itr) {
140     (*itr)->ConstructProcess();
141   }
142 }
143 
144 // --------------------------------------------------------------------
145 void G4VModularPhysicsList::RegisterPhysics(G4VPhysicsConstructor* fPhysics)
146 {
147   G4StateManager* stateManager = G4StateManager::GetStateManager();
148   G4ApplicationState currentState = stateManager->GetCurrentState();
149   if (!(currentState == G4State_PreInit)) {
150     G4Exception("G4VModularPhysicsList::RegisterPhysics", "Run0201", JustWarning,
151                 "Geant4 kernel is not PreInit state : Method ignored.");
152     return;
153   }
154 
155   G4String pName = fPhysics->GetPhysicsName();
156   G4int pType = fPhysics->GetPhysicsType();
157   // If physics_type is equal to 0,
158   // following duplication check is omitted
159   // This is TEMPORAL treatment.
160   if (pType == 0) {
161     G4MT_physicsVector->push_back(fPhysics);
162 #ifdef G4VERBOSE
163     if (verboseLevel > 1) {
164       G4cout << "G4VModularPhysicsList::RegisterPhysics: " << pName << " with type : " << pType
165              << " is added" << G4endl;
166     }
167 #endif
168     return;
169   }
170 
171   // Check if physics with the physics_type same as one of given physics
172   auto itr = G4MT_physicsVector->cbegin();
173   for (; itr != G4MT_physicsVector->cend(); ++itr) {
174     if (pType == (*itr)->GetPhysicsType()) break;
175   }
176   if (itr != G4MT_physicsVector->cend()) {
177 #ifdef G4VERBOSE
178     if (verboseLevel > 0) {
179       G4cout << "G4VModularPhysicsList::RegisterPhysics: "
180              << "a physics with given type already exists " << G4endl;
181       G4cout << " Type = " << pType << " : "
182              << "  existing physics is " << (*itr)->GetPhysicsName() << G4endl;
183       G4cout << " New " << pName << " can not be registered " << G4endl;
184     }
185 #endif
186     G4String comment = "Duplicate type for ";
187     comment += pName;
188     G4Exception("G4VModularPhysicsList::RegisterPhysics", "Run0202", JustWarning, comment);
189     return;
190   }
191 
192   // register
193   G4MT_physicsVector->push_back(fPhysics);
194 }
195 
196 // --------------------------------------------------------------------
197 void G4VModularPhysicsList::ReplacePhysics(G4VPhysicsConstructor* fPhysics)
198 {
199   G4StateManager* stateManager = G4StateManager::GetStateManager();
200   G4ApplicationState currentState = stateManager->GetCurrentState();
201   if (!(currentState == G4State_PreInit)) {
202     G4Exception("G4VModularPhysicsList::ReplacePhysics", "Run0203", JustWarning,
203                 "Geant4 kernel is not PreInit state : Method ignored.");
204     return;
205   }
206 
207   G4String pName = fPhysics->GetPhysicsName();
208   G4int pType = fPhysics->GetPhysicsType();
209   // If physics_type is equal to 0,
210   // duplication check is omitted and just added.
211   // This is TEMPORAL treatment.
212   if (pType == 0) {
213     // register
214     G4MT_physicsVector->push_back(fPhysics);
215 #ifdef G4VERBOSE
216     if (verboseLevel > 0) {
217       G4cout << "G4VModularPhysicsList::ReplacePhysics: " << pName << " with type : " << pType
218              << " is added" << G4endl;
219     }
220 #endif
221     return;
222   }
223 
224   // Check if physics with the physics_type same as one of given physics
225   auto itr = G4MT_physicsVector->begin();
226   for (; itr != G4MT_physicsVector->end(); ++itr) {
227     if (pType == (*itr)->GetPhysicsType()) break;
228   }
229   if (itr == G4MT_physicsVector->end()) {
230     // register
231     G4MT_physicsVector->push_back(fPhysics);
232   }
233   else {
234 #ifdef G4VERBOSE
235     if (verboseLevel > 0) {
236       G4cout << "G4VModularPhysicsList::ReplacePhysics: " << (*itr)->GetPhysicsName()
237              << " with type : " << pType << " is replaced with " << pName << G4endl;
238     }
239 #endif
240 
241     //  delete exsiting one
242     delete (*itr);
243     // replace with given one
244     (*itr) = fPhysics;
245   }
246   return;
247 }
248 
249 // --------------------------------------------------------------------
250 void G4VModularPhysicsList::RemovePhysics(G4int pType)
251 {
252   G4StateManager* stateManager = G4StateManager::GetStateManager();
253   G4ApplicationState currentState = stateManager->GetCurrentState();
254   if (!(currentState == G4State_PreInit)) {
255     G4Exception("G4VModularPhysicsList::RemovePhysics", "Run0204", JustWarning,
256                 "Geant4 kernel is not PreInit state : Method ignored.");
257     return;
258   }
259 
260   for (auto itr = G4MT_physicsVector->cbegin(); itr != G4MT_physicsVector->cend();) {
261     if (pType == (*itr)->GetPhysicsType()) {
262       G4String pName = (*itr)->GetPhysicsName();
263 #ifdef G4VERBOSE
264       if (verboseLevel > 0) {
265         G4cout << "G4VModularPhysicsList::RemovePhysics: " << pName << " is removed" << G4endl;
266       }
267 #endif
268       G4MT_physicsVector->erase(itr);
269       break;
270     }
271 
272     ++itr;
273   }
274 }
275 
276 // --------------------------------------------------------------------
277 void G4VModularPhysicsList::RemovePhysics(G4VPhysicsConstructor* fPhysics)
278 {
279   G4StateManager* stateManager = G4StateManager::GetStateManager();
280   G4ApplicationState currentState = stateManager->GetCurrentState();
281   if (!(currentState == G4State_PreInit)) {
282     G4Exception("G4VModularPhysicsList::RemovePhysics", "Run0205", JustWarning,
283                 "Geant4 kernel is not PreInit state : Method ignored.");
284     return;
285   }
286 
287   for (auto itr = G4MT_physicsVector->cbegin(); itr != G4MT_physicsVector->cend();) {
288     if (fPhysics == (*itr)) {
289       G4String pName = (*itr)->GetPhysicsName();
290 #ifdef G4VERBOSE
291       if (verboseLevel > 0) {
292         G4cout << "G4VModularPhysicsList::RemovePhysics: " << pName << " is removed" << G4endl;
293       }
294 #endif
295       G4MT_physicsVector->erase(itr);
296       break;
297     }
298 
299     ++itr;
300   }
301 }
302 
303 // --------------------------------------------------------------------
304 void G4VModularPhysicsList::RemovePhysics(const G4String& name)
305 {
306   G4StateManager* stateManager = G4StateManager::GetStateManager();
307   G4ApplicationState currentState = stateManager->GetCurrentState();
308   if (!(currentState == G4State_PreInit)) {
309     G4Exception("G4VModularPhysicsList::RemovePhysics", "Run0206", JustWarning,
310                 "Geant4 kernel is not PreInit state : Method ignored.");
311     return;
312   }
313 
314   for (auto itr = G4MT_physicsVector->cbegin(); itr != G4MT_physicsVector->cend();) {
315     G4String pName = (*itr)->GetPhysicsName();
316     if (name == pName) {
317 #ifdef G4VERBOSE
318       if (verboseLevel > 0) {
319         G4cout << "G4VModularPhysicsList::RemovePhysics: " << pName << " is removed" << G4endl;
320       }
321 #endif
322       G4MT_physicsVector->erase(itr);
323       break;
324     }
325 
326     ++itr;
327   }
328 }
329 
330 // --------------------------------------------------------------------
331 const G4VPhysicsConstructor* G4VModularPhysicsList::GetPhysics(G4int idx) const
332 {
333   auto itr = G4MT_physicsVector->cbegin();
334   for (G4int i = 0; i < idx && itr != G4MT_physicsVector->cend(); ++i)
335     ++itr;
336   if (itr != G4MT_physicsVector->cend()) return (*itr);
337   return nullptr;
338 }
339 
340 // --------------------------------------------------------------------
341 const G4VPhysicsConstructor* G4VModularPhysicsList::GetPhysics(const G4String& name) const
342 {
343   auto itr = G4MT_physicsVector->cbegin();
344   for (; itr != G4MT_physicsVector->cend(); ++itr) {
345     if (name == (*itr)->GetPhysicsName()) break;
346   }
347   if (itr != G4MT_physicsVector->cend()) return (*itr);
348   return nullptr;
349 }
350 
351 // --------------------------------------------------------------------
352 const G4VPhysicsConstructor* G4VModularPhysicsList::GetPhysicsWithType(G4int pType) const
353 {
354   auto itr = G4MT_physicsVector->cbegin();
355   for (; itr != G4MT_physicsVector->cend(); ++itr) {
356     if (pType == (*itr)->GetPhysicsType()) break;
357   }
358   if (itr != G4MT_physicsVector->cend()) return (*itr);
359   return nullptr;
360 }
361 
362 // --------------------------------------------------------------------
363 void G4VModularPhysicsList::SetVerboseLevel(G4int value)
364 {
365   verboseLevel = value;
366   // Loop over constructors
367   for (auto itr = G4MT_physicsVector->cbegin(); itr != G4MT_physicsVector->cend(); ++itr) {
368     (*itr)->SetVerboseLevel(verboseLevel);
369   }
370 }
371 
372 // --------------------------------------------------------------------
373 void G4VModularPhysicsList::TerminateWorker()
374 {
375   // See https://jira-geant4.kek.jp/browse/DEV-284
376   std::for_each(G4MT_physicsVector->cbegin(), G4MT_physicsVector->cend(),
377                 [](G4PhysConstVector::value_type el) { el->TerminateWorker(); });
378   G4VUserPhysicsList::TerminateWorker();
379 }
380