Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/processes/parameterisation/src/G4GlobalFastSimulationManager.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 /processes/parameterisation/src/G4GlobalFastSimulationManager.cc (Version 11.3.0) and /processes/parameterisation/src/G4GlobalFastSimulationManager.cc (Version 6.2.p1)


  1 //                                                  1 //
  2 // *******************************************      2 // ********************************************************************
  3 // * License and Disclaimer                    <<   3 // * DISCLAIMER                                                       *
  4 // *                                                4 // *                                                                  *
  5 // * The  Geant4 software  is  copyright of th <<   5 // * The following disclaimer summarizes all the specific disclaimers *
  6 // * the Geant4 Collaboration.  It is provided <<   6 // * of contributors to this software. The specific disclaimers,which *
  7 // * conditions of the Geant4 Software License <<   7 // * govern, are listed with their locations in:                      *
  8 // * LICENSE and available at  http://cern.ch/ <<   8 // *   http://cern.ch/geant4/license                                  *
  9 // * include a list of copyright holders.      << 
 10 // *                                                9 // *                                                                  *
 11 // * Neither the authors of this software syst     10 // * Neither the authors of this software system, nor their employing *
 12 // * institutes,nor the agencies providing fin     11 // * institutes,nor the agencies providing financial support for this *
 13 // * work  make  any representation or  warran     12 // * work  make  any representation or  warranty, express or implied, *
 14 // * regarding  this  software system or assum     13 // * regarding  this  software system or assume any liability for its *
 15 // * use.  Please see the license in the file  <<  14 // * use.                                                             *
 16 // * for the full disclaimer and the limitatio << 
 17 // *                                               15 // *                                                                  *
 18 // * This  code  implementation is the result  <<  16 // * This  code  implementation is the  intellectual property  of the *
 19 // * technical work of the GEANT4 collaboratio <<  17 // * GEANT4 collaboration.                                            *
 20 // * By using,  copying,  modifying or  distri <<  18 // * By copying,  distributing  or modifying the Program (or any work *
 21 // * any work based  on the software)  you  ag <<  19 // * based  on  the Program)  you indicate  your  acceptance of  this *
 22 // * use  in  resulting  scientific  publicati <<  20 // * statement, and all its terms.                                    *
 23 // * acceptance of all terms of the Geant4 Sof << 
 24 // *******************************************     21 // ********************************************************************
 25 //                                                 22 //
 26 //                                                 23 //
                                                   >>  24 // $Id: G4GlobalFastSimulationManager.cc,v 1.12 2002/12/04 21:29:50 asaim Exp $
                                                   >>  25 // GEANT4 tag $Name: geant4-05-02-patch-01 $
 27 //                                                 26 //
 28 //                                             <<  27 //  
 29 //--------------------------------------------     28 //---------------------------------------------------------------
 30 //                                                 29 //
 31 //  G4GlobalFastSimulationManager.cc               30 //  G4GlobalFastSimulationManager.cc
 32 //                                                 31 //
 33 //  Description:                                   32 //  Description:
 34 //    A singleton class which manages the Fast <<  33 //    A singleton class which manages the Fast Simulation managers 
 35 //    attached to envelopes. Implementation.       34 //    attached to envelopes. Implementation.
 36 //                                                 35 //
 37 //  History:                                       36 //  History:
 38 //    June 98: Verderi && MoraDeFreitas - "G4P     37 //    June 98: Verderi && MoraDeFreitas - "G4ParallelWorld" becomes
 39 //             "G4FlavoredParallelWorld"; some     38 //             "G4FlavoredParallelWorld"; some method name changes;
 40 //             GetFlavoredWorldForThis now ret <<  39 //             GetFlavoredWorldForThis now returns a 
 41 //             G4FlavoredParallelWorld pointer     40 //             G4FlavoredParallelWorld pointer.
 42 //    Feb 98: Verderi && MoraDeFreitas - First     41 //    Feb 98: Verderi && MoraDeFreitas - First Implementation.
 43 //    March 98: correction to instanciate dyna     42 //    March 98: correction to instanciate dynamically the manager
 44 //    May 07: Move to parallel world scheme    << 
 45 //                                                 43 //
 46 //--------------------------------------------     44 //---------------------------------------------------------------
 47                                                    45 
 48 #include "G4GlobalFastSimulationManager.hh"        46 #include "G4GlobalFastSimulationManager.hh"
 49                                                << 
 50 #include "G4FastSimulationMessenger.hh"        << 
 51 #include "G4Material.hh"                       << 
 52 #include "G4PVPlacement.hh"                    << 
 53 #include "G4ParticleDefinition.hh"             << 
 54 #include "G4ParticleTable.hh"                      47 #include "G4ParticleTable.hh"
 55 #include "G4PhysicalVolumeStore.hh"            <<  48 #include "G4ParticleDefinition.hh"
 56 #include "G4ProcessManager.hh"                 <<  49 #include "G4Material.hh"
 57 #include "G4ProcessVector.hh"                  << 
 58 #include "G4RegionStore.hh"                    << 
 59 #include "G4ThreadLocalSingleton.hh"           << 
 60 #include "G4ThreeVector.hh"                        50 #include "G4ThreeVector.hh"
                                                   >>  51 #include "G4PVPlacement.hh"
 61 #include "G4TransportationManager.hh"              52 #include "G4TransportationManager.hh"
                                                   >>  53 #include "G4FastSimulationMessenger.hh"
 62                                                    54 
 63 // ------------------------------------------- <<  55 G4GlobalFastSimulationManager* 
 64 // -- static methods to retrieve the manager p <<  56 G4GlobalFastSimulationManager::fGlobalFastSimulationManager = 0;
 65 // ------------------------------------------- << 
 66 G4GlobalFastSimulationManager* G4GlobalFastSim << 
 67 {                                              << 
 68   static G4ThreadLocalSingleton<G4GlobalFastSi << 
 69   return instance.Instance();                  << 
 70 }                                              << 
 71                                                    57 
 72 G4GlobalFastSimulationManager* G4GlobalFastSim <<  58 
                                                   >>  59 G4GlobalFastSimulationManager* 
                                                   >>  60 G4GlobalFastSimulationManager::GetGlobalFastSimulationManager()
 73 {                                                  61 {
 74   return G4GlobalFastSimulationManager::GetGlo <<  62   if(!fGlobalFastSimulationManager)
                                                   >>  63   {
                                                   >>  64     fGlobalFastSimulationManager = new G4GlobalFastSimulationManager;
                                                   >>  65     SetConcreteInstance(fGlobalFastSimulationManager);
                                                   >>  66   }
                                                   >>  67   return fGlobalFastSimulationManager;
 75 }                                                  68 }
 76                                                    69 
 77 // ---------------                             <<  70 
 78 // -- constructor                              << 
 79 // ---------------                             << 
 80 G4GlobalFastSimulationManager::G4GlobalFastSim     71 G4GlobalFastSimulationManager::G4GlobalFastSimulationManager()
 81 {                                                  72 {
 82   fTheFastSimulationMessenger = new G4FastSimu <<  73   // It starts closed.
                                                   >>  74   fClosed=true;
                                                   >>  75   // Initialises the G4FastSimulationMessenger
                                                   >>  76   fTheFastSimulationMessenger=new G4FastSimulationMessenger(this);
 83 }                                                  77 }
 84                                                    78 
 85 // -------------                               << 
 86 // -- destructor                               << 
 87 // -------------                               << 
 88 G4GlobalFastSimulationManager::~G4GlobalFastSi     79 G4GlobalFastSimulationManager::~G4GlobalFastSimulationManager()
 89 {                                                  80 {
 90   delete fTheFastSimulationMessenger;              81   delete fTheFastSimulationMessenger;
                                                   >>  82   fTheFastSimulationMessenger = 0;
 91 }                                                  83 }
 92                                                    84 
 93 // ----------------------                      <<  85 void G4GlobalFastSimulationManager::FastSimulationNeedsToBeClosed()
 94 // -- management methods:                      << 
 95 // ----------------------                      << 
 96 void G4GlobalFastSimulationManager::AddFastSim << 
 97 {                                                  86 {
 98   ManagedManagers.push_back(fsmanager);        <<  87   fClosed=false;
 99 }                                                  88 }
100                                                    89 
101 void G4GlobalFastSimulationManager::RemoveFast <<  90 void G4GlobalFastSimulationManager::
                                                   >>  91 AddFastSimulationManager(G4FastSimulationManager* fsmanager)
102 {                                                  92 {
103   ManagedManagers.remove(fsmanager);           <<  93   ManagedManagers.push_back(fsmanager);
104 }                                                  94 }
105                                                    95 
106 void G4GlobalFastSimulationManager::AddFSMP(G4 <<  96 void G4GlobalFastSimulationManager::
                                                   >>  97 RemoveFastSimulationManager(G4FastSimulationManager* fsmanager)
107 {                                                  98 {
108   fFSMPVector.push_back(fp);                   <<  99   ManagedManagers.remove(fsmanager);
109 }                                                 100 }
110                                                   101 
111 void G4GlobalFastSimulationManager::RemoveFSMP << 
112 {                                              << 
113   fFSMPVector.remove(fp);                      << 
114 }                                              << 
115                                                   102 
116 void G4GlobalFastSimulationManager::ActivateFa << 103 void G4GlobalFastSimulationManager::CloseFastSimulation()
117 {                                                 104 {
118   G4bool result = false;                       << 105   if(fClosed) return;
119   for (auto& ManagedManager : ManagedManagers) << 
120     result = result || ManagedManager->Activat << 
121                                                   106 
122   G4cout << "Model " << aName << (result ? " a << 107   G4ParticleTable* theParticleTable;
                                                   >> 108   
                                                   >> 109   // Reset the NeededFlavoredWorlds List
                                                   >> 110   NeededFlavoredWorlds.clearAndDestroy();
                                                   >> 111   
                                                   >> 112   // We'll look for models for all particle types
                                                   >> 113   theParticleTable=G4ParticleTable::GetParticleTable();
                                                   >> 114   
                                                   >> 115   // Creates the first world volume clone.
                                                   >> 116   G4VPhysicalVolume* aClone=GiveMeAWorldVolumeClone();
                                                   >> 117   
                                                   >> 118   G4cout << "Closing FastSimulation\n";
                                                   >> 119   for (G4int iParticle=0; iParticle<theParticleTable->entries(); iParticle++) {
                                                   >> 120     G4bool Needed = false;
                                                   >> 121     for (size_t ifsm=0; ifsm<ManagedManagers.size(); ifsm++)
                                                   >> 122       Needed = Needed || ManagedManagers[ifsm]->
                                                   >> 123   InsertGhostHereIfNecessary(aClone,
                                                   >> 124            *(theParticleTable->
                                                   >> 125              GetParticle(iParticle)));
                                                   >> 126     // if some FSM inserted a ghost, keep this clone.
                                                   >> 127     if(Needed) {
                                                   >> 128       NeededFlavoredWorlds.push_back(new 
                                                   >> 129           G4FlavoredParallelWorld(theParticleTable->
                                                   >> 130             GetParticle(iParticle),
                                                   >> 131                 aClone));
                                                   >> 132       // and prepare a new one.
                                                   >> 133       aClone=GiveMeAWorldVolumeClone();
                                                   >> 134     }
                                                   >> 135   }
                                                   >> 136   fClosed=true;
123 }                                                 137 }
124                                                   138 
125 void G4GlobalFastSimulationManager::InActivate << 139 G4VFlavoredParallelWorld* 
                                                   >> 140 G4GlobalFastSimulationManager::
                                                   >> 141 GetFlavoredWorldForThis(G4ParticleDefinition* particle)
126 {                                                 142 {
127   G4bool result = false;                       << 143   for (size_t ipw=0; ipw<NeededFlavoredWorlds.size(); ipw++)
128   for (auto& ManagedManager : ManagedManagers) << 144     if(NeededFlavoredWorlds[ipw]->GetTheParticleType()==particle)
129     result = result || ManagedManager->InActiv << 145       return NeededFlavoredWorlds[ipw];
130                                                << 146   return 0;
131   G4cout << "Model " << aName << (result ? " i << 
132 }                                                 147 }
133                                                   148 
134 void G4GlobalFastSimulationManager::Flush()    << 149 void 
                                                   >> 150 G4GlobalFastSimulationManager::ActivateFastSimulationModel(const G4String& aName)
135 {                                                 151 {
136   // loop over all models (that need flushing? << 152   G4bool result = false;
137   for (auto& ManagedManager : ManagedManagers) << 153   for (size_t ifsm=0; ifsm<ManagedManagers.size(); ifsm++)
138     ManagedManager->FlushModels();             << 154     result = result || ManagedManagers[ifsm]->ActivateFastSimulationModel(aName);
139 }                                              << 155   if(result) 
140                                                << 156     G4cout << "Model " << aName << " activated.";
141 // ---------------------------------           << 157   else
142 // -- display fast simulation setup:           << 158     G4cout << "Model " << aName << " not found.";
143 // ---------------------------------           << 159   G4cout << G4endl;
144 void G4GlobalFastSimulationManager::ShowSetup( << 
145 {                                              << 
146   std::vector<G4VPhysicalVolume*> worldDone;   << 
147   G4VPhysicalVolume* world;                    << 
148   G4RegionStore* regions = G4RegionStore::GetI << 
149   // ----------------------------------------- << 
150   // -- loop on regions to get the list of wor << 
151   // ----------------------------------------- << 
152   G4cout << "\nFast simulation setup:" << G4en << 
153   for (auto& region : *regions) {              << 
154     world = region->GetWorldPhysical();        << 
155     if (world == nullptr)  // region does not  << 
156     {                                          << 
157       continue;                                << 
158     }                                          << 
159     G4bool newWorld = true;                    << 
160     for (auto& ii : worldDone)                 << 
161       if (ii == world) {                       << 
162         newWorld = false;                      << 
163         break;                                 << 
164       }                                        << 
165     if (newWorld) {                            << 
166       worldDone.push_back(world);              << 
167       G4Region* worldRegion = world->GetLogica << 
168       // -- preambule: print physical volume a << 
169       if (world                                << 
170           == G4TransportationManager::GetTrans << 
171                ->GetNavigatorForTracking()     << 
172                ->GetWorldVolume())             << 
173         G4cout << "\n    * Mass Geometry with  << 
174       else                                     << 
175         G4cout << "\n    * Parallel Geometry w << 
176       G4cout << "world volume: `" << world->Ge << 
177              << "']" << G4endl;                << 
178       // -- ... and print G4FSMP(s) attached t << 
179       G4bool findG4FSMP(false);                << 
180       // -- show to what particles this G4FSMP << 
181       std::vector<G4ParticleDefinition*> parti << 
182       for (auto& ip : fFSMPVector)             << 
183         if (ip->GetWorldVolume() == world) {   << 
184           G4cout << "        o G4FastSimulatio << 
185           G4cout << "                      Att << 
186           G4ParticleTable* particles = G4Parti << 
187           for (G4int iParticle = 0; iParticle  << 
188             G4ParticleDefinition* particle = p << 
189             G4ProcessVector* processes = parti << 
190             if (processes->contains(ip)) {     << 
191               G4cout << " " << particle->GetPa << 
192               findG4FSMP = true;               << 
193               particlesKnown.push_back(particl << 
194             }                                  << 
195           }                                    << 
196           G4cout << G4endl;                    << 
197         }                                      << 
198       if (!findG4FSMP) G4cout << "        o G4 << 
199       // -- now display the regions in this wo << 
200       // indentation:                          << 
201       G4cout << "        o Region(s) and model << 
202       DisplayRegion(worldRegion, 1, particlesK << 
203     }                                          << 
204   }                                            << 
205 }                                                 160 }
206                                                   161 
207 void G4GlobalFastSimulationManager::DisplayReg << 162 void 
208   G4Region* region, G4int depth, std::vector<G << 163 G4GlobalFastSimulationManager::InActivateFastSimulationModel(const G4String& aName)
209 {                                                 164 {
210   G4String indent = "        ";                << 165   G4bool result = false;
211   for (G4int I = 0; I < depth; I++)            << 166   for (size_t ifsm=0; ifsm<ManagedManagers.size(); ifsm++)
212     indent += "    ";                          << 167     result = result || ManagedManagers[ifsm]->InActivateFastSimulationModel(aName);
213   G4cout << indent << "Region: `" << region->G << 168   if(result) 
214   G4FastSimulationManager* fastSimManager = re << 169     G4cout << "Model " << aName << " inactivated.";
215   if (fastSimManager != nullptr) {             << 170   else
216     indent += "    ";                          << 171     G4cout << "Model " << aName << " not found.";
217     G4cout << indent << "Model(s):" << G4endl; << 172   G4cout << G4endl;
218     indent += "    ";                          << 173 }
219     for (auto im : fastSimManager->GetFastSimu << 174 
220       G4cout << indent << "`" << im->GetName() << 175 void 
221       G4cout << " ; applicable to:";           << 176 G4GlobalFastSimulationManager::ListEnvelopes(const G4String& aName,
222       G4ParticleTable* particles = G4ParticleT << 177                listType theType)
223       for (G4int iParticle = 0; iParticle < pa << 178 {
224         if (im->IsApplicable(*(particles->GetP << 179   if(theType == ISAPPLICABLE) {
225           G4cout << " " << particles->GetParti << 180     for (size_t ifsm=0; ifsm<ManagedManagers.size(); ifsm++)
226           G4bool known(false);                 << 181       ManagedManagers[ifsm]->ListModels(aName);
227           for (auto& l : particlesKnown)       << 
228             if (l == particles->GetParticle(iP << 
229               known = true;                    << 
230               break;                           << 
231             }                                  << 
232           if (!known) G4cout << "[!!]";        << 
233         }                                      << 
234       }                                        << 
235       G4cout << G4endl;                        << 
236     }                                          << 
237   }                                            << 
238                                                << 
239   // -- all that to check mothership of "regio << 
240   G4PhysicalVolumeStore* physVolStore = G4Phys << 
241   for (auto physVol : *physVolStore) {         << 
242     if (physVol->GetLogicalVolume()->IsRootReg << 
243       if (physVol->GetMotherLogical() != nullp << 
244         G4Region* thisVolMotherRegion = physVo << 
245         if (thisVolMotherRegion == region)     << 
246           DisplayRegion(physVol->GetLogicalVol << 
247       }                                        << 
248   }                                            << 
249 }                                              << 
250                                                << 
251 // ----------------------------                << 
252 // -- management methods : list                << 
253 // ----------------------------                << 
254                                                << 
255 void G4GlobalFastSimulationManager::ListEnvelo << 
256 {                                              << 
257   if (theType == ISAPPLICABLE) {               << 
258     for (auto& ManagedManager : ManagedManager << 
259       ManagedManager->ListModels(aName);       << 
260     return;                                       182     return;
261   }                                               183   }
262                                                << 184   
263   if (aName == "all") {                        << 185   if(aName == "all") {
264     G4int titled = 0;                             186     G4int titled = 0;
265     for (auto& ManagedManager : ManagedManager << 187     for (size_t ifsm=0; ifsm<ManagedManagers.size(); ifsm++) {
266       if (theType == NAMES_ONLY) {             << 188       if(theType == NAMES_ONLY) {
267         if ((titled++) == 0) G4cout << "Curren << 189   if(!(titled++))
268         G4cout << "   ";                       << 190     G4cout << "Current Envelopes for Fast Simulation:\n";
269         ManagedManager->ListTitle();           << 191   G4cout << "   "; 
270         G4cout << G4endl;                      << 192   ManagedManagers[ifsm]->ListTitle();
                                                   >> 193   G4cout << G4endl;
271       }                                           194       }
272       else                                     << 195       else ManagedManagers[ifsm]->ListModels();
273         ManagedManager->ListModels();          << 
274     }                                             196     }
275   }                                               197   }
276   else {                                          198   else {
277     for (auto& ManagedManager : ManagedManager << 199     for (size_t ifsm=0; ifsm<ManagedManagers.size(); ifsm++)
278       if (aName == ManagedManager->GetEnvelope << 200       if(aName == ManagedManagers[ifsm]->
279         ManagedManager->ListModels();          << 201    GetEnvelope()->GetName()){
280         break;                                 << 202   ManagedManagers[ifsm]->ListModels();
                                                   >> 203   break;
281       }                                           204       }
282   }                                               205   }
283 }                                                 206 }
284                                                   207 
285 void G4GlobalFastSimulationManager::ListEnvelo << 208 void 
                                                   >> 209 G4GlobalFastSimulationManager::ListEnvelopes(const G4ParticleDefinition* aPD)
286 {                                                 210 {
287   for (auto& ManagedManager : ManagedManagers) << 211   for (size_t ifsm=0; ifsm<ManagedManagers.size(); ifsm++)
288     ManagedManager->ListModels(aPD);           << 212     ManagedManagers[ifsm]->ListModels(aPD);
289 }                                                 213 }
290                                                   214 
291 G4VFastSimulationModel* G4GlobalFastSimulation << 215 G4VPhysicalVolume* 
292   const G4String& modelName, const G4VFastSimu << 216 G4GlobalFastSimulationManager::GiveMeAWorldVolumeClone()
                                                   >> 217 {
                                                   >> 218   G4VPhysicalVolume* theParallelWorldPhysical;
                                                   >> 219   
                                                   >> 220   G4TransportationManager *transportationManager= 
                                                   >> 221     G4TransportationManager::GetTransportationManager();
                                                   >> 222   
                                                   >> 223   G4VSolid *parallelWorldSolid=transportationManager->
                                                   >> 224     GetNavigatorForTracking()->GetWorldVolume()->
                                                   >> 225     GetLogicalVolume()->GetSolid();
                                                   >> 226   
                                                   >> 227   G4Material *parallelWorldMaterial=transportationManager->
                                                   >> 228     GetNavigatorForTracking()->GetWorldVolume()->
                                                   >> 229     GetLogicalVolume()->GetMaterial();
                                                   >> 230   
                                                   >> 231   G4LogicalVolume *parallelWorldLog = 
                                                   >> 232     new G4LogicalVolume(parallelWorldSolid,
                                                   >> 233       parallelWorldMaterial,
                                                   >> 234       "ParallelWorldLogical",
                                                   >> 235       0, 0, 0);
                                                   >> 236   
                                                   >> 237   theParallelWorldPhysical= new G4PVPlacement(0,G4ThreeVector(),
                                                   >> 238                 "ParallelWorldPhysical",
                                                   >> 239                 parallelWorldLog,
                                                   >> 240                 0,false,0);
                                                   >> 241   
                                                   >> 242   return theParallelWorldPhysical;
                                                   >> 243 }
                                                   >> 244 
                                                   >> 245 G4bool 
                                                   >> 246 G4GlobalFastSimulationManager::Notify(G4ApplicationState requestedState)
                                                   >> 247 { 
                                                   >> 248   G4StateManager * stateManager = G4StateManager::GetStateManager();
                                                   >> 249   if((stateManager->GetPreviousState()==G4State_Idle) &&
                                                   >> 250      (requestedState==G4State_GeomClosed) &&
                                                   >> 251      (!fClosed))
                                                   >> 252     G4Exception("G4GlobalFastSimulationManager fatal error : \n1) you are using ghost volumes;\n2) In this case the G4GlobalFastSimulationManager MUST be closed BEFORE\n  closing the geometry;\n3) To do this put in your code the call \n  G4GlobalFastSimulationManager::GetGlobalFastSimulationManager()->\n    CloseFastSimulation();\n  just before closing the geometry.");
                                                   >> 253   return true;
                                                   >> 254 }
                                                   >> 255 
                                                   >> 256 G4VFastSimulationModel* 
                                                   >> 257 G4GlobalFastSimulationManager::GetFastSimulationModel(const G4String& modelName,
                                                   >> 258                   const G4VFastSimulationModel* previousFound) const
293 {                                                 259 {
294   G4VFastSimulationModel* model = nullptr;     << 260   G4VFastSimulationModel* model = 0;
295   // -- flag used to navigate accross the vari    261   // -- flag used to navigate accross the various managers;
296   bool foundPrevious(false);                      262   bool foundPrevious(false);
297   for (auto ManagedManager : ManagedManagers)  << 263   for (size_t ifsm=0; ifsm<ManagedManagers.size(); ifsm++)
298     model = ManagedManager->GetFastSimulationM << 264     {
299     if (model != nullptr) break;               << 265       model = ManagedManagers[ifsm]->GetFastSimulationModel(modelName, previousFound, foundPrevious);
300   }                                            << 266       if (model) break;
                                                   >> 267     }
301   return model;                                   268   return model;
302 }                                                 269 }
303                                                   270