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: G4GlobalFastSimulationManager.hh,v 1.10 2006/06/29 21:09:22 gunter Exp $ >> 28 // GEANT4 tag $Name: geant4-08-01 $ 27 // 29 // 28 // << 30 // 29 //-------------------------------------------- 31 //--------------------------------------------------------------- 30 // 32 // 31 // G4GlobalFastSimulationManager.hh 33 // G4GlobalFastSimulationManager.hh 32 // 34 // 33 // Description: 35 // Description: 34 // A singleton class which manages the Fast << 36 // A singleton class which manages the Fast Simulation managers 35 // attached to envelopes. 37 // attached to envelopes. 36 // 38 // 37 // History: 39 // History: 38 // June 98: Verderi && MoraDeFreitas - "G4P 40 // June 98: Verderi && MoraDeFreitas - "G4ParallelWorld" becomes 39 // "G4FlavoredParallelWorld"; some 41 // "G4FlavoredParallelWorld"; some method name changes; 40 // GetFlavoredWorldForThis now ret << 42 // GetFlavoredWorldForThis now returns a 41 // G4FlavoredParallelWorld pointer 43 // G4FlavoredParallelWorld pointer. 42 // Feb 98: Verderi && MoraDeFreitas - First 44 // Feb 98: Verderi && MoraDeFreitas - First Implementation. 43 // 45 // 44 //-------------------------------------------- 46 //--------------------------------------------------------------- 45 47 46 #ifndef G4GLOBALFASTSIMULATIONMANAGER_HH << 48 #ifndef G4GlobalFastSimulationManager_hh 47 #define G4GLOBALFASTSIMULATIONMANAGER_HH << 49 #define G4GlobalFastSimulationManager_hh 48 50 49 #include "G4FastSimulationManager.hh" << 50 #include "G4FastSimulationManagerProcess.hh" << 51 #include "G4FastSimulationVector.hh" << 52 #include "G4VGlobalFastSimulationManager.hh" << 53 #include "globals.hh" 51 #include "globals.hh" >> 52 #include "G4FastSimulationVector.hh" 54 53 55 class G4FastSimulationMessenger; << 54 #include "G4VGlobalFastSimulationManager.hh" 56 template <class T> << 55 #include "G4FastSimulationManager.hh" 57 class G4ThreadLocalSingleton; << 56 #include "G4FastSimulationManagerProcess.hh" >> 57 #include "G4StateManager.hh" >> 58 #include "G4VStateDependent.hh" >> 59 #include "G4FlavoredParallelWorld.hh" 58 60 59 enum listType << 61 enum listType { 60 { << 61 NAMES_ONLY, 62 NAMES_ONLY, 62 MODELS, 63 MODELS, 63 ISAPPLICABLE 64 ISAPPLICABLE 64 }; 65 }; 65 66 >> 67 class G4FastSimulationMessenger; >> 68 66 // Class Description: 69 // Class Description: 67 // This a singleton class which provides the m 70 // This a singleton class which provides the management of the G4FastSimulationManager 68 // objects and some ghost facilities. << 71 // objects and some ghost facilities. 69 // 72 // 70 // You can get access to it by: 73 // You can get access to it by: 71 // 74 // 72 // #include "G4GlobalFastSimulationManager.hh" 75 // #include "G4GlobalFastSimulationManager.hh" 73 // ... 76 // ... 74 // ... 77 // ... 75 // G4GlobalFastSimulationManager* globalFSM; 78 // G4GlobalFastSimulationManager* globalFSM; 76 // globalFSM = G4GlobalFastSimulationManager:: 79 // globalFSM = G4GlobalFastSimulationManager::getGlobalFastSimulationManager(); 77 // ... 80 // ... 78 // ... 81 // ... 79 // << 82 // 80 // Presently, you will mainly need to use the << 83 // Presently, you will mainly need to use the GlobalFastSimulationManager if you use ghost 81 // geometries. 84 // geometries. 82 // 85 // 83 86 84 class G4GlobalFastSimulationManager << 87 class G4GlobalFastSimulationManager : public G4VStateDependent, >> 88 public G4VGlobalFastSimulationManager 85 { 89 { 86 friend class G4ThreadLocalSingleton<G4Global << 90 public: // With description 87 91 88 public: << 92 static G4GlobalFastSimulationManager* GetGlobalFastSimulationManager(); 89 // Destructor << 93 // Provides a global access to the GlobalFastSimulationManager 90 ~G4GlobalFastSimulationManager(); << 94 91 << 95 G4VFastSimulationModel* GetFastSimulationModel(const G4String& modelName, 92 // Provides a global access to the GlobalF << 96 const G4VFastSimulationModel* previousFound = 0) const; 93 static G4GlobalFastSimulationManager* GetG << 97 // Fetch G4VFastSimulationModel by name: 94 << 98 // 95 // Same as GetGlobalFastSimulationManager( << 99 // o returns the G4VFastSimulationModel* of model with name modelName; 96 static G4GlobalFastSimulationManager* GetI << 100 // o returns 0 if no model found; 97 << 101 // 98 // Iterative fetch of G4VFastSimulationMod << 102 // - usage: 99 // o returns the G4VFastSimulationModel << 103 // 100 // o returns 0 if no model found; << 104 // myModel = gblManager->GetFastSimulationModel("MyModel"); 101 // o usage: << 105 // 102 // myModel = gblManager->GetFastSim << 106 // o note for the case of several models having the same name: 103 // o note for the case of several model << 107 // - to get the first "MyModel" model: 104 // - to get the first "MyModel" mod << 108 // 105 // myModel1 = gblManager->GetF << 109 // myModel1 = gblManager->GetFastSimulationModel("MyModel", 0); 106 // - to get the next one: << 110 // 107 // myModel2 = gblManager->GetF << 111 // - to get the next one: 108 // - and so on. << 112 // 109 // - When gblManager->GetFastSimula << 113 // myModel2 = gblManager->GetFastSimulationModel("MyModel", myModel1); 110 // returns a null pointer, no ext << 114 // 111 G4VFastSimulationModel* << 115 // - and so on. 112 GetFastSimulationModel(const G4String& mod << 116 // 113 const G4VFastSimula << 117 // - When gblManager->GetFastSimulationModel("MyModel", myModel_n) 114 << 118 // returns a null pointer, no extra model with name "MyModel" exist. 115 // << 119 116 // G4FastSimulationManager(Process)'s mana << 120 117 // << 121 public: // Without description 118 // Methods for a G4FastSimulationManager t << 122 119 // << 123 // Destructor 120 void AddFastSimulationManager(G4FastSimula << 124 ~G4GlobalFastSimulationManager(); 121 void RemoveFastSimulationManager(G4FastSim << 125 122 // << 126 // G4FastSimulationManager's management : 123 // G4FastSimulationManagerProcess bookeepi << 127 // 124 // << 128 // Methods for a G4FastSimulationManager to register itself 125 void AddFSMP(G4FastSimulationManagerProces << 129 // 126 void RemoveFSMP(G4FastSimulationManagerPro << 130 void AddFastSimulationManager(G4FastSimulationManager*); 127 << 131 void RemoveFastSimulationManager(G4FastSimulationManager*); 128 // Flag that the Parameterisation must be << 132 129 void FastSimulationNeedsToBeClosed(); << 133 130 << 134 // Flag that the Parameterisation must be closed. 131 // Show the fast simulation setup : world( << 135 void FastSimulationNeedsToBeClosed(); 132 // Requires the geometry to be closed. << 136 133 void ShowSetup(); << 137 134 << 138 public: // With description 135 void ListEnvelopes(const G4String& aName = << 139 void CloseFastSimulation(); 136 void ListEnvelopes(const G4ParticleDefinit << 140 // Build the parallel worlds when you are using ghost volumes. In this case the Parameterisation 137 << 141 // MUST be closed BEFORE closing the geometry. It's enough to call this method just before 138 void ActivateFastSimulationModel(const G4S << 142 // closing the geometry. 139 void InActivateFastSimulationModel(const G << 143 // 140 << 144 141 void Flush(); << 145 public: // Without description 142 << 146 // print/control commands 143 private: << 147 void ListEnvelopes(const G4String& aName = "all", 144 // Private construtor insures singleton cl << 148 listType aListType = NAMES_ONLY); 145 G4GlobalFastSimulationManager(); << 149 void ListEnvelopes(const G4ParticleDefinition*); 146 << 150 147 // recursive display of regions, models, e << 151 void ActivateFastSimulationModel(const G4String&); 148 void DisplayRegion(G4Region* motherRegion, << 152 void InActivateFastSimulationModel(const G4String&); 149 std::vector<G4ParticleD << 153 150 << 154 // G4FastSimulationProcess interface 151 G4FastSimulationMessenger* fTheFastSimulat << 155 G4VFlavoredParallelWorld* GetFlavoredWorldForThis(G4ParticleDefinition *); 152 G4FastSimulationVector<G4FastSimulationMan << 156 153 G4FastSimulationVector<G4FastSimulationMan << 157 // G4StateManager interface >> 158 G4bool Notify(G4ApplicationState requestedState); >> 159 >> 160 private: >> 161 // Private construtor insures singleton class >> 162 G4GlobalFastSimulationManager(); >> 163 >> 164 // The single instance. >> 165 static G4GlobalFastSimulationManager* fGlobalFastSimulationManager; >> 166 >> 167 // The G4FastSimulationMessenger >> 168 G4FastSimulationMessenger* fTheFastSimulationMessenger; >> 169 >> 170 // List of G4FastSimulationManagers >> 171 G4FastSimulationVector <G4FastSimulationManager> ManagedManagers; >> 172 >> 173 // fClosed flags if the NeededFlavoredWorlds List was Build. >> 174 G4bool fClosed; >> 175 >> 176 // List of needed ParallelWorlds after close >> 177 G4FastSimulationVector <G4FlavoredParallelWorld> NeededFlavoredWorlds; >> 178 >> 179 // Internal fonction to Build world volume clones. >> 180 G4VPhysicalVolume* GiveMeAWorldVolumeClone(); 154 }; 181 }; 155 182 156 #endif << 183 #endif >> 184 // end of #ifndef G4GlobalFastSimulationManager_hh 157 185