Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/geometry/biasing/src/G4IStore.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 ]

Diff markup

Differences between /geometry/biasing/src/G4IStore.cc (Version 11.3.0) and /geometry/biasing/src/G4IStore.cc (Version 9.6.p1)


  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 // G4IStore implementation                     << 
 27 //                                                 26 //
 28 // Author: Michael Dressel (CERN), 2002        <<  27 // $Id$
 29 // Modified: Alex Howard (CERN), 2013 - Change <<  28 //
                                                   >>  29 // ----------------------------------------------------------------------
                                                   >>  30 // GEANT 4 class source file
                                                   >>  31 //
                                                   >>  32 // G4IStore.cc
                                                   >>  33 //
 30 // -------------------------------------------     34 // ----------------------------------------------------------------------
 31                                                    35 
 32 #include "G4IStore.hh"                             36 #include "G4IStore.hh"
 33 #include "G4VPhysicalVolume.hh"                    37 #include "G4VPhysicalVolume.hh"
 34 #include "G4GeometryCell.hh"                       38 #include "G4GeometryCell.hh"
 35 #include "G4GeometryCellStepStream.hh"             39 #include "G4GeometryCellStepStream.hh"
 36 #include "G4LogicalVolume.hh"                      40 #include "G4LogicalVolume.hh"
 37 #include "G4TransportationManager.hh"          << 
 38                                                << 
 39 #include "G4AutoLock.hh"                       << 
 40                                                << 
 41 namespace                                      << 
 42 {                                              << 
 43   G4Mutex IStoreMutex = G4MUTEX_INITIALIZER;   << 
 44 }                                              << 
 45                                                << 
 46 // ******************************************* << 
 47 // Static class variable: ptr to single instan << 
 48 // ******************************************* << 
 49 G4ThreadLocal G4IStore* G4IStore::fInstance =  << 
 50                                                << 
 51 G4IStore::G4IStore()                           << 
 52   : fWorldVolume(G4TransportationManager::GetT << 
 53                  ->GetNavigatorForTracking()-> << 
 54 {                                              << 
 55 }                                              << 
 56                                                << 
 57 G4IStore::G4IStore(const G4String& ParallelWor << 
 58   : fWorldVolume(G4TransportationManager::GetT << 
 59                  ->GetParallelWorld(ParallelWo << 
 60 {                                              << 
 61 #ifdef G4VERBOSE                               << 
 62   G4cout << " G4IStore:: ParallelWorldName = " << 
 63          << ParallelWorldName << G4endl;       << 
 64   G4cout << " G4IStore:: fParallelWorldVolume  << 
 65          << fWorldVolume->GetName() << G4endl; << 
 66 #endif                                         << 
 67 }                                              << 
 68                                                    41 
 69 G4IStore::~G4IStore() = default;               <<  42 G4IStore::G4IStore(const G4VPhysicalVolume &worldvolume) :
                                                   >>  43   fWorldVolume(worldvolume)
                                                   >>  44 {}
 70                                                    45 
 71 void G4IStore::Clear()                         <<  46 G4IStore::~G4IStore()
 72 {                                              <<  47 {}
 73   fGeometryCelli.clear();                      << 
 74 }                                              << 
 75                                                    48 
 76 void G4IStore::SetWorldVolume()                <<  49 const G4VPhysicalVolume &G4IStore::GetWorldVolume() const 
 77 {                                              << 
 78   G4cout << " G4IStore:: SetWorldVolume " << G << 
 79   fWorldVolume = G4TransportationManager::GetT << 
 80                  ->GetNavigatorForTracking()-> << 
 81   G4cout << " World volume is: " << fWorldVolu << 
 82   // fGeometryCelli = new G4GeometryCellImport << 
 83 }                                              << 
 84                                                << 
 85 void G4IStore::SetParallelWorldVolume(const G4 << 
 86 {                                              << 
 87   G4cout << " G4IStore:: SetParallelWorldVolum << 
 88   fWorldVolume = G4TransportationManager::GetT << 
 89                  ->GetParallelWorld(paraName); << 
 90   G4cout << " ParallelWorld volume is: " << fW << 
 91   // fGeometryCelli = new G4GeometryCellImport << 
 92 }                                              << 
 93                                                << 
 94 const G4VPhysicalVolume& G4IStore::GetWorldVol << 
 95 {                                              << 
 96   return *fWorldVolume;                        << 
 97 }                                              << 
 98                                                << 
 99 const G4VPhysicalVolume* G4IStore::GetParallel << 
100 {                                                  50 {
101   return fWorldVolume;                             51   return fWorldVolume;
102 }                                                  52 }
103                                                    53 
104 void G4IStore::SetInternalIterator(const G4Geo <<  54 void G4IStore::SetInternalIterator(const G4GeometryCell &gCell) const
105 {                                                  55 {
106   fCurrentIterator = fGeometryCelli.find(gCell     56   fCurrentIterator = fGeometryCelli.find(gCell);
107 }                                                  57 }
108                                                    58 
109 void G4IStore::AddImportanceGeometryCell(G4dou     59 void G4IStore::AddImportanceGeometryCell(G4double importance,
110                                          const <<  60        const G4GeometryCell &gCell){
111 {                                              <<  61   if (importance < 0 ) {
112   if (importance < 0 )                         << 
113   {                                            << 
114     Error("AddImportanceGeometryCell() - Inval     62     Error("AddImportanceGeometryCell() - Invalid importance value given.");
115   }                                                63   }  
116   if (!IsInWorld(gCell.GetPhysicalVolume()) )  <<  64   if (!IsInWorld(gCell.GetPhysicalVolume()) ) {
117   {                                            << 
118     Error("AddImportanceGeometryCell() - Physi     65     Error("AddImportanceGeometryCell() - Physical volume not found!");
119   }                                                66   }
120   SetInternalIterator(gCell);                      67   SetInternalIterator(gCell);
121   if (fCurrentIterator != fGeometryCelli.cend( <<  68   if (fCurrentIterator!=fGeometryCelli.end()) {
122   {                                            << 
123     Error("AddImportanceGeometryCell() - Regio     69     Error("AddImportanceGeometryCell() - Region already existing!");
124   }                                                70   }
125   fGeometryCelli[gCell] = importance;              71   fGeometryCelli[gCell] = importance;
126 }                                                  72 }
127                                                    73 
128 void G4IStore::AddImportanceGeometryCell(G4dou     74 void G4IStore::AddImportanceGeometryCell(G4double importance,
129                                          const <<  75            const G4VPhysicalVolume &aVolume,
130                                          G4int <<  76            G4int aRepNum)
131 {                                                  77 {
132   AddImportanceGeometryCell(importance, G4Geom <<  78   AddImportanceGeometryCell(importance,
                                                   >>  79           G4GeometryCell(aVolume, aRepNum));
133 }                                                  80 }
134                                                    81 
135 void G4IStore::ChangeImportance(G4double impor     82 void G4IStore::ChangeImportance(G4double importance,
136                                 const G4Geomet <<  83         const G4GeometryCell &gCell){
137 {                                              <<  84   if (importance < 0 ) {
138   if (importance < 0 )                         << 
139   {                                            << 
140     Error("ChangeImportance() - Invalid import     85     Error("ChangeImportance() - Invalid importance value given.");
141   }                                                86   }
142   if (!IsInWorld(gCell.GetPhysicalVolume()))   <<  87   if (!IsInWorld(gCell.GetPhysicalVolume()) ) {
143   {                                            << 
144     Error("ChangeImportance() - Physical volum     88     Error("ChangeImportance() - Physical volume not found!");
145   }                                                89   }
146   SetInternalIterator(gCell);                      90   SetInternalIterator(gCell);
147   if (fCurrentIterator == fGeometryCelli.cend( <<  91   if (fCurrentIterator==fGeometryCelli.end()) {
148   {                                            << 
149     Error("ChangeImportance() - Region does no     92     Error("ChangeImportance() - Region does not exist!");
150   }                                                93   }
151   fGeometryCelli[gCell] = importance;              94   fGeometryCelli[gCell] = importance;
152                                                    95 
153 }                                                  96 }
154                                                << 
155 void G4IStore::ChangeImportance(G4double impor     97 void G4IStore::ChangeImportance(G4double importance,
156                                 const G4VPhysi <<  98         const G4VPhysicalVolume &aVolume,
157                                 G4int aRepNum) <<  99         G4int aRepNum)
158 {                                                 100 {
159   ChangeImportance(importance, G4GeometryCell(    101   ChangeImportance(importance, G4GeometryCell(aVolume, aRepNum));
160 }                                                 102 }
161                                                   103 
162 G4double G4IStore::GetImportance(const G4VPhys << 104 G4double G4IStore::GetImportance(const G4VPhysicalVolume &aVolume,
163                                  G4int aRepNum << 105          G4int aRepNum) const
164 {                                                 106 {  
165   G4AutoLock l(&IStoreMutex);                  << 
166   SetInternalIterator(G4GeometryCell(aVolume,     107   SetInternalIterator(G4GeometryCell(aVolume, aRepNum));
167   auto gCellIterator = fCurrentIterator;       << 108   G4GeometryCellImportance::const_iterator gCellIterator = fCurrentIterator;
168   if (gCellIterator == fGeometryCelli.cend())  << 109   if (gCellIterator==fGeometryCelli.end()) {
169   {                                            << 
170     Error("GetImportance() - Region does not e    110     Error("GetImportance() - Region does not exist!");
171     return 0.;                                    111     return 0.;
172   }                                               112   }
173   G4double importance_value = (*fCurrentIterat << 113   return (*fCurrentIterator).second;
174   l.unlock();                                  << 
175                                                << 
176   return importance_value;                     << 
177 }                                                 114 }
178                                                   115 
179 G4double G4IStore::GetImportance(const G4Geome << 116 
                                                   >> 117 G4double G4IStore::GetImportance(const G4GeometryCell &gCell) const
180 {                                                 118 {
181   G4AutoLock l(&IStoreMutex);                  << 
182   SetInternalIterator(gCell);                     119   SetInternalIterator(gCell);
183   auto gCellIterator = fCurrentIterator;       << 120   G4GeometryCellImportance::const_iterator gCellIterator = fCurrentIterator;
184   if (gCellIterator == fGeometryCelli.cend())  << 121   if (gCellIterator==fGeometryCelli.end()) {
185   {                                            << 
186     std::ostringstream err_mess;                  122     std::ostringstream err_mess;
187     err_mess << "GetImportance() - Region does    123     err_mess << "GetImportance() - Region does not exist!" << G4endl
188              << "Geometry cell, " << gCell        124              << "Geometry cell, " << gCell
189              << ", not found in: " << fGeometr    125              << ", not found in: " << fGeometryCelli << ".";
190     Error(err_mess.str());                        126     Error(err_mess.str());
191     return 0.;                                    127     return 0.;
192   }                                               128   }
193   G4double importance_value = (*fCurrentIterat << 129   return (*fCurrentIterator).second;
194   l.unlock();                                  << 
195                                                << 
196   return importance_value;                     << 
197 }                                                 130 }
198                                                   131 
199 G4bool G4IStore::IsKnown(const G4GeometryCell& << 132 G4bool G4IStore::IsKnown(const G4GeometryCell &gCell) const {
200 {                                              << 
201   G4AutoLock l(&IStoreMutex);                  << 
202   G4bool inWorldKnown(IsInWorld(gCell.GetPhysi    133   G4bool inWorldKnown(IsInWorld(gCell.GetPhysicalVolume()));
203                                                << 134           
204   if ( inWorldKnown )                          << 135   if ( inWorldKnown ) {
205   {                                            << 
206     SetInternalIterator(gCell);                   136     SetInternalIterator(gCell);
207     inWorldKnown = (fCurrentIterator != fGeome << 137     inWorldKnown = (fCurrentIterator!=fGeometryCelli.end());
208   }                                               138   }
209   l.unlock();                                  << 
210                                                << 
211   return inWorldKnown;                            139   return inWorldKnown;
212 }                                                 140 }
213                                                   141 
214 G4bool G4IStore::IsInWorld(const G4VPhysicalVo << 142 G4bool G4IStore::IsInWorld(const G4VPhysicalVolume &aVolume) const
215 {                                                 143 {
216   G4bool isIn(true);                              144   G4bool isIn(true);
217   if (!(aVolume == *fWorldVolume))             << 145   if (!(aVolume == fWorldVolume)) {
218   {                                            << 146     isIn = fWorldVolume.GetLogicalVolume()->IsAncestor(&aVolume);
219     isIn = fWorldVolume->GetLogicalVolume()->I << 
220   }                                               147   }
221   return isIn;                                    148   return isIn;
222 }                                                 149 }
223                                                   150 
224 void G4IStore::Error(const G4String& msg) cons << 
225 {                                              << 
226   G4Exception("G4IStore::Error()", "GeomBias00 << 
227 }                                              << 
228                                                   151 
229 // ******************************************* << 152 
230 // Returns the instance of the singleton.      << 153 void G4IStore::Error(const G4String &msg) const
231 // Creates it in case it's called for the firs << 
232 // ******************************************* << 
233 //                                             << 
234 G4IStore* G4IStore::GetInstance()              << 
235 {                                              << 
236   if (fInstance == nullptr)                    << 
237   {                                            << 
238 #ifdef G4VERBOSE                               << 
239     G4cout << "G4IStore:: Creating new MASS IS << 
240 #endif                                         << 
241     fInstance = new G4IStore();                << 
242   }                                            << 
243   return fInstance;                            << 
244 }                                              << 
245                                                << 
246 // ******************************************* << 
247 // Returns the instance of the singleton.      << 
248 // Creates it in case it's called for the firs << 
249 // ******************************************* << 
250 //                                             << 
251 G4IStore* G4IStore::GetInstance(const G4String << 
252 {                                                 154 {
253   if (fInstance == nullptr)                    << 155   G4Exception("G4IStore::Error()", "GeomBias0002", FatalException, msg);
254   {                                            << 
255 #ifdef G4VERBOSE                               << 
256     G4cout << "G4IStore:: Creating new Paralle << 
257            << ParallelWorldName << G4endl;     << 
258 #endif                                         << 
259     fInstance = new G4IStore(ParallelWorldName << 
260   }                                            << 
261   return fInstance;                            << 
262 }                                                 156 }
263                                                   157