Geant4  10.02.p01
G4VPhysicsConstructor.hh
Go to the documentation of this file.
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 //
27 // $Id: G4VPhysicsConstructor.hh 68802 2013-04-05 13:54:41Z gcosmo $
28 //
29 //
30 // ------------------------------------------------------------
31 // GEANT 4 class header file
32 // Class Description:
33 // This class is an virtual class for constructing
34 // particles and processes. This class objects will be
35 // registered to G4VPhysicsList.
36 //
37 // User must implement following four virtual methods
38 // in his own concrete class derived from this class.
39 //
40 // all necessary particle type will be instantiated
41 // virtual void ConstructParticle();
42 //
43 // all physics processes will be instantiated and
44 // registered to the process manager of each particle type
45 // virtual void ConstructProcess();
46 //
47 // Only one physics constructor can be registered to
48 // Modular Physics List for each "physics_type".
49 // Physics constructors with same "physics_type" can be
50 // replaced by using the method of
51 // G4VModularPhysicsList::ReplacePhysics()
52 //
53 //
54 // -------------------------------------------
55 // History
56 // first version 12 Nov. 2000 by H.Kurashige
57 // Add physicsType 14 Mar. 2011 by H.Kurashige
58 // Add RegisterProcess 1 May 2011 by H.Kurashige
59 // ------------------------------------------------------------
60 #ifndef G4VPhysicsConstructor_h
61 #define G4VPhysicsConstructor_h 1
62 
63 #include "globals.hh"
64 #include "rundefs.hh"
65 #include "G4ios.hh"
66 #include "G4ParticleTable.hh"
67 #include "G4PhysicsListHelper.hh"
68 #include "G4VUPLSplitter.hh"
69 
70 
71 class G4VPCData
72 {
73  //Encapsulate the fields of class G4VPhysicsConstructor
74  //that are per-thread.
75 public:
76  void initialize();
78 };
79 
80 // The type G4VPCManager is introduced to encapsulate the methods used by
81 // both the master thread and worker threads to allocate memory space for
82 // the fields encapsulated by the class G4VPCData. When each thread
83 // changes the value for these fields, it refers to them using a macro
84 // definition defined below. For every G4VPhysicsConstructor instance,
85 // there is a corresponding G4VPCData instance. All G4VPCData instances
86 // are organized by the class G4VUPLManager as an array.
87 // The field "int g4vuplInstanceID" is added to the class G4VUserPhysicsList.
88 // The value of this field in each G4VUserPhysicsList instance is the
89 // subscript of the corresponding G44VUPLData instance.
90 // In order to use the class G44VUPLManager, we add a static member in the class
91 // G4VUserPhysicsList as follows: "static G4VUPLManager subInstanceManager".
92 // Both the master thread and worker threads change the length of the array
93 // for G44VUPLData instances mutually along with G4VUserPhysicsList
94 // instances are created. For each worker thread, it dynamically creates ions.
95 // Consider any thread A, if there is any other thread which creates an ion.
96 // This ion is shared by the thread A. So the thread A leaves an empty space
97 // in the array of G4PDefData instances for the ion.
98 //
99 // Important Note: you may wonder why we are introducing this mechanism
100 // since there is only one PL for each application.
101 // This is true, in the sense that only one PL is allowed
102 // to be associated to a G4RunManager, however user can instantiate
103 // as many PLs are needed and at run-time select one of the PLs to be used
104 // we thus need this mechanism to guarantee that the system works without
105 // problems in case of this (unusual) case. This may be reviewed in the future
108 
109 // This macros change the references to fields that are now encapsulated
110 // in the class G4VPCData.
111 //
112 // Note1: the use of this-> this is needed to avoid compilation errors
113 // when using templated class with T=G4VUserPhysicsList. Don't know why.
114 // Note2: the name of the first #define is different, because otherwise
115 // we need to change its use in all classes that inherits from
116 // this base class (all examples). However one should note comment
117 // on JIRA task: http://jira-geant4.kek.jp/browse/DEV-27
118 
119 #define aParticleIterator ((subInstanceManager.offset[g4vpcInstanceID])._aParticleIterator)
120 
122 {
123  public: // with description
124 
125  G4VPhysicsConstructor(const G4String& ="");
126  G4VPhysicsConstructor(const G4String& name, G4int physics_type);
127  virtual ~G4VPhysicsConstructor();
128 
129  virtual void ConstructParticle()=0;
130  // This method will be invoked in the Construct() method.
131  // each particle type will be instantiated
132 
133  virtual void ConstructProcess()=0;
134  // This method will be invoked in the Construct() method.
135  // each physics process will be instantiated and
136  // registered to the process manager of each particle type
137 
138  inline void SetPhysicsName(const G4String& ="");
139  inline const G4String& GetPhysicsName() const;
140 
141  inline void SetPhysicsType(G4int);
142  inline G4int GetPhysicsType() const;
143 
144  inline void SetVerboseLevel(G4int value);
145  inline G4int GetVerboseLevel() const;
146  // set/get controle flag for output message
147  // 0: Silent
148  // 1: Warning message
149  // 2: More
150  // verbose level is set equal to physics list when registered
151 
152  protected:
153 
154  inline G4bool RegisterProcess(G4VProcess* process,
155  G4ParticleDefinition* particle);
156  // Register a process to the particle type
157  // according to the ordering parameter table
158  // 'true' is returned if the process is registerd successfully
159 
160  protected:
164 
168 public:
169  inline G4int GetInstanceID() const;
170  static const G4VPCManager& GetSubInstanceManager();
171  //G4ParticleTable::G4PTblDicIterator* aParticleIterator;
172  // the particle table has the complete List of existing particle types
173 
174  //G4PhysicsListHelper* aPLHelper;
175 };
176 
177 // Inlined methods
178 
180 {
181  verboseLevel = value;
182 }
183 
185 {
186  return verboseLevel;
187 }
188 
190 {
191  namePhysics = name;
192 }
193 
195 {
196  return namePhysics;
197 }
198 
200 {
201  if (val>0) typePhysics = val;
202 }
203 
205 {
206  return typePhysics;
207 }
208 
209 inline
211  G4ParticleDefinition* particle)
212 {
214  //return aPLHelper->RegisterProcess(process, particle);
215 }
216 
217 inline
219 {
220  return subInstanceManager;
221 }
222 #endif
223 
224 
225 
226 
G4int GetInstanceID() const
G4String name
Definition: TRTMaterials.hh:40
#define G4RUN_DLL
Definition: rundefs.hh:48
int G4int
Definition: G4Types.hh:78
G4ParticleTable::G4PTblDicIterator * _aParticleIterator
G4ParticleTable * theParticleTable
G4bool RegisterProcess(G4VProcess *process, G4ParticleDefinition *particle)
virtual void ConstructParticle()=0
G4VPCManager G4VPhyscicsConstructorManager
bool G4bool
Definition: G4Types.hh:79
G4bool RegisterProcess(G4VProcess *process, G4ParticleDefinition *particle)
static G4RUN_DLL G4VPCManager subInstanceManager
const G4String & GetPhysicsName() const
void SetVerboseLevel(G4int value)
G4VUPLSplitter< G4VPCData > G4VPCManager
void SetPhysicsName(const G4String &="")
static G4PhysicsListHelper * GetPhysicsListHelper()
G4VPhysicsConstructor(const G4String &="")
virtual void ConstructProcess()=0
static const G4VPCManager & GetSubInstanceManager()