| Geant4 Cross Reference |
>> 1 // This code implementation is the intellectual property of
>> 2 // the GEANT4 collaboration.
1 // 3 //
2 // ******************************************* << 4 // By copying, distributing or modifying the Program (or any work
3 // * License and Disclaimer << 5 // based on the Program) you indicate your acceptance of this statement,
4 // * << 6 // and all its terms.
5 // * The Geant4 software is copyright of th <<
6 // * the Geant4 Collaboration. It is provided <<
7 // * conditions of the Geant4 Software License <<
8 // * LICENSE and available at http://cern.ch/ <<
9 // * include a list of copyright holders. <<
10 // * <<
11 // * Neither the authors of this software syst <<
12 // * institutes,nor the agencies providing fin <<
13 // * work make any representation or warran <<
14 // * regarding this software system or assum <<
15 // * use. Please see the license in the file <<
16 // * for the full disclaimer and the limitatio <<
17 // * <<
18 // * This code implementation is the result <<
19 // * technical work of the GEANT4 collaboratio <<
20 // * By using, copying, modifying or distri <<
21 // * any work based on the software) you ag <<
22 // * use in resulting scientific publicati <<
23 // * acceptance of all terms of the Geant4 Sof <<
24 // ******************************************* <<
25 // <<
26 // <<
27 // 7 //
>> 8 // $Id: G4GlobalFastSimulationManager.hh,v 1.4.2.1.2.1 1999/12/07 20:52:52 gunter Exp $
>> 9 // GEANT4 tag $Name: geant4-01-01 $
28 // 10 //
>> 11 //
29 //-------------------------------------------- 12 //---------------------------------------------------------------
30 // 13 //
31 // G4GlobalFastSimulationManager.hh 14 // G4GlobalFastSimulationManager.hh
32 // 15 //
33 // Description: 16 // Description:
34 // A singleton class which manages the Fast << 17 // A singleton class which manages the Fast Simulation managers
35 // attached to envelopes. 18 // attached to envelopes.
36 // 19 //
37 // History: 20 // History:
38 // June 98: Verderi && MoraDeFreitas - "G4P 21 // June 98: Verderi && MoraDeFreitas - "G4ParallelWorld" becomes
39 // "G4FlavoredParallelWorld"; some 22 // "G4FlavoredParallelWorld"; some method name changes;
40 // GetFlavoredWorldForThis now ret << 23 // GetFlavoredWorldForThis now returns a
41 // G4FlavoredParallelWorld pointer 24 // G4FlavoredParallelWorld pointer.
42 // Feb 98: Verderi && MoraDeFreitas - First 25 // Feb 98: Verderi && MoraDeFreitas - First Implementation.
43 // 26 //
44 //-------------------------------------------- 27 //---------------------------------------------------------------
45 28
46 #ifndef G4GLOBALFASTSIMULATIONMANAGER_HH << 29 #ifndef G4GlobalFastSimulationManager_hh
47 #define G4GLOBALFASTSIMULATIONMANAGER_HH << 30 #define G4GlobalFastSimulationManager_hh
48 31
>> 32 #include "g4rw/tpordvec.h"
>> 33
>> 34 #include "G4VGlobalFastSimulationManager.hh"
49 #include "G4FastSimulationManager.hh" 35 #include "G4FastSimulationManager.hh"
50 #include "G4FastSimulationManagerProcess.hh" 36 #include "G4FastSimulationManagerProcess.hh"
51 #include "G4FastSimulationVector.hh" << 37 #include "G4StateManager.hh"
52 #include "G4VGlobalFastSimulationManager.hh" << 38 #include "G4VStateDependent.hh"
53 #include "globals.hh" << 39 #include "G4FlavoredParallelWorld.hh"
54 <<
55 class G4FastSimulationMessenger; <<
56 template <class T> <<
57 class G4ThreadLocalSingleton; <<
58 40
59 enum listType << 41 enum listType {
60 { <<
61 NAMES_ONLY, 42 NAMES_ONLY,
62 MODELS, 43 MODELS,
63 ISAPPLICABLE 44 ISAPPLICABLE
64 }; 45 };
65 46
>> 47 class G4FastSimulationMessenger;
>> 48
66 // Class Description: 49 // Class Description:
67 // This a singleton class which provides the m 50 // This a singleton class which provides the management of the G4FastSimulationManager
68 // objects and some ghost facilities. << 51 // objects and some ghost facilities.
69 // 52 //
70 // You can get access to it by: 53 // You can get access to it by:
71 // 54 //
72 // #include "G4GlobalFastSimulationManager.hh" 55 // #include "G4GlobalFastSimulationManager.hh"
73 // ... 56 // ...
74 // ... 57 // ...
75 // G4GlobalFastSimulationManager* globalFSM; 58 // G4GlobalFastSimulationManager* globalFSM;
76 // globalFSM = G4GlobalFastSimulationManager:: 59 // globalFSM = G4GlobalFastSimulationManager::getGlobalFastSimulationManager();
77 // ... 60 // ...
78 // ... 61 // ...
79 // << 62 //
80 // Presently, you will mainly need to use the << 63 // Presently, you will mainly need to use the GlobalFastSimulationManager if you use ghost
81 // geometries. 64 // geometries.
82 // 65 //
83 66
84 class G4GlobalFastSimulationManager << 67 class G4GlobalFastSimulationManager : public G4VStateDependent,
>> 68 public G4VGlobalFastSimulationManager
85 { 69 {
86 friend class G4ThreadLocalSingleton<G4Global << 70 public: // With description
>> 71
>> 72 static G4GlobalFastSimulationManager* GetGlobalFastSimulationManager();
>> 73 // Provides a global access to the GlobalFastSimulationManager
>> 74
>> 75 public: // Without description
>> 76
>> 77 // Destructor
>> 78 ~G4GlobalFastSimulationManager();
>> 79
>> 80 // G4FastSimulationManager's management :
>> 81 //
>> 82 // Methods for a G4FastSimulationManager to register itself
>> 83 //
>> 84 void AddFastSimulationManager(G4FastSimulationManager*);
>> 85 void RemoveFastSimulationManager(G4FastSimulationManager*);
>> 86
>> 87 // Flag that the Parameterisation must be closed.
>> 88 void FastSimulationNeedsToBeClosed();
>> 89
>> 90
>> 91 public: // With description
>> 92 void CloseFastSimulation();
>> 93 // Build the parallel worlds when you are using ghost volumes. In this case the Parameterisation
>> 94 // MUST be closed BEFORE closing the geometry. It's enough to call this method just before
>> 95 // closing the geometry.
>> 96 //
>> 97
>> 98 public: // Without description
>> 99 // print/control commands
>> 100 void ListEnvelopes(const G4String& aName = "all",
>> 101 listType aListType = NAMES_ONLY);
>> 102 void ListEnvelopes(const G4ParticleDefinition*);
>> 103
>> 104 void ActivateFastSimulationModel(const G4String&);
>> 105 void InActivateFastSimulationModel(const G4String&);
>> 106
>> 107 // G4FastSimulationProcess interface
>> 108 G4VFlavoredParallelWorld* GetFlavoredWorldForThis(G4ParticleDefinition *);
>> 109
>> 110 // G4StateManager interface
>> 111 G4bool Notify(G4ApplicationState requestedState);
>> 112
>> 113 private:
>> 114 // Private construtor insures singleton class
>> 115 G4GlobalFastSimulationManager();
>> 116
>> 117 // The single instance.
>> 118 static G4GlobalFastSimulationManager* fGlobalFastSimulationManager;
>> 119
>> 120 // The G4FastSimulationMessenger
>> 121 G4FastSimulationMessenger* fTheFastSimulationMessenger;
>> 122
>> 123 // List of G4FastSimulationManagers
>> 124 G4RWTPtrOrderedVector<G4FastSimulationManager> ManagedManagers;
>> 125
>> 126 // fClosed flags if the NeededFlavoredWorlds List was Build.
>> 127 G4bool fClosed;
>> 128
>> 129 // List of needed ParallelWorlds after close
>> 130 G4RWTPtrOrderedVector<G4FlavoredParallelWorld> NeededFlavoredWorlds;
87 131
88 public: << 132 // Internal fonction to Build world volume clones.
89 // Destructor << 133 G4VPhysicalVolume* GiveMeAWorldVolumeClone();
90 ~G4GlobalFastSimulationManager(); <<
91 <<
92 // Provides a global access to the GlobalF <<
93 static G4GlobalFastSimulationManager* GetG <<
94 <<
95 // Same as GetGlobalFastSimulationManager( <<
96 static G4GlobalFastSimulationManager* GetI <<
97 <<
98 // Iterative fetch of G4VFastSimulationMod <<
99 // o returns the G4VFastSimulationModel <<
100 // o returns 0 if no model found; <<
101 // o usage: <<
102 // myModel = gblManager->GetFastSim <<
103 // o note for the case of several model <<
104 // - to get the first "MyModel" mod <<
105 // myModel1 = gblManager->GetF <<
106 // - to get the next one: <<
107 // myModel2 = gblManager->GetF <<
108 // - and so on. <<
109 // - When gblManager->GetFastSimula <<
110 // returns a null pointer, no ext <<
111 G4VFastSimulationModel* <<
112 GetFastSimulationModel(const G4String& mod <<
113 const G4VFastSimula <<
114 <<
115 // <<
116 // G4FastSimulationManager(Process)'s mana <<
117 // <<
118 // Methods for a G4FastSimulationManager t <<
119 // <<
120 void AddFastSimulationManager(G4FastSimula <<
121 void RemoveFastSimulationManager(G4FastSim <<
122 // <<
123 // G4FastSimulationManagerProcess bookeepi <<
124 // <<
125 void AddFSMP(G4FastSimulationManagerProces <<
126 void RemoveFSMP(G4FastSimulationManagerPro <<
127 <<
128 // Flag that the Parameterisation must be <<
129 void FastSimulationNeedsToBeClosed(); <<
130 <<
131 // Show the fast simulation setup : world( <<
132 // Requires the geometry to be closed. <<
133 void ShowSetup(); <<
134 <<
135 void ListEnvelopes(const G4String& aName = <<
136 void ListEnvelopes(const G4ParticleDefinit <<
137 <<
138 void ActivateFastSimulationModel(const G4S <<
139 void InActivateFastSimulationModel(const G <<
140 <<
141 void Flush(); <<
142 <<
143 private: <<
144 // Private construtor insures singleton cl <<
145 G4GlobalFastSimulationManager(); <<
146 <<
147 // recursive display of regions, models, e <<
148 void DisplayRegion(G4Region* motherRegion, <<
149 std::vector<G4ParticleD <<
150 <<
151 G4FastSimulationMessenger* fTheFastSimulat <<
152 G4FastSimulationVector<G4FastSimulationMan <<
153 G4FastSimulationVector<G4FastSimulationMan <<
154 }; 134 };
155 135
156 #endif << 136 #endif
>> 137 // end of #ifndef G4GlobalFastSimulationManager_hh
157 138