| 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 // G4VBiasingOperation << 26 //
>> 27 // $Id: $
>> 28 //
>> 29 // --------------------------------------------------------------------
>> 30 // GEANT 4 class header file
27 // 31 //
28 // Class Description: 32 // Class Description:
29 // 33 //
30 // An abstract class to model the behavior of 34 // An abstract class to model the behavior of any type of biasing :
31 // physics-based biasing (change of physics pr 35 // physics-based biasing (change of physics process behavior) or non-
32 // physics-based one, like splitting, killing. 36 // physics-based one, like splitting, killing.
33 // 37 //
34 // o The change of behavior of a physics proce 38 // o The change of behavior of a physics process can be:
35 // - a change of the PostStep interaction 39 // - a change of the PostStep interaction probabilty, so-called
36 // occurrence biasing << 40 // occurence biasing
37 // - a change in final state production 41 // - a change in final state production
38 // - both, provided above two are uncorrel 42 // - both, provided above two are uncorrelated.
39 // o The change of occurrence is driven by pro << 43 // o The change of occurence is driven by providing a biasing interaction
40 // law (G4VBiasingInteractionLaw) that is us 44 // law (G4VBiasingInteractionLaw) that is used in place of the analog
41 // exponential law. 45 // exponential law.
42 // This change of occurrence is controlled t << 46 // This change of occurence is controlled through many handles.
43 // o The change in final state production is m 47 // o The change in final state production is made through one single
44 // method the user is fully responsible of. 48 // method the user is fully responsible of.
45 // 49 //
46 // o Non-physics-based biasing is controlled b 50 // o Non-physics-based biasing is controlled by two methods : one to
47 // specify where this biasing should happen, 51 // specify where this biasing should happen, and one for generating
48 // the related final-state. 52 // the related final-state.
49 // 53 //
50 // Author: Marc Verderi (LLR), November 2013 << 54 // ----------------G4VBiasingOperation ----------------
51 // ------------------------------------------- << 55 //
>> 56 // Author: M.Verderi (LLR), November 2013
>> 57 // - 05/11/13 : first implementation
>> 58 // ---------------------------------------------------------------------
>> 59
>> 60
>> 61
52 #ifndef G4VBiasingOperation_hh 62 #ifndef G4VBiasingOperation_hh
53 #define G4VBiasingOperation_hh 1 63 #define G4VBiasingOperation_hh 1
54 64
55 #include "globals.hh" 65 #include "globals.hh"
56 #include "G4ForceCondition.hh" <<
57 #include "G4GPILSelection.hh" <<
58 <<
59 class G4VParticleChange; 66 class G4VParticleChange;
60 class G4Track; 67 class G4Track;
61 class G4Step; 68 class G4Step;
62 class G4VBiasingInteractionLaw; 69 class G4VBiasingInteractionLaw;
63 class G4VProcess; 70 class G4VProcess;
64 class G4BiasingProcessInterface; 71 class G4BiasingProcessInterface;
>> 72 #include "G4ForceCondition.hh"
>> 73 #include "G4GPILSelection.hh"
>> 74
>> 75 class G4VBiasingOperation {
>> 76 public:
>> 77 // ---------------
>> 78 // -- Constructor:
>> 79 // ---------------
>> 80 //
>> 81 // -- Constructor for biasing operations:
>> 82 // -----------------------------------
>> 83 // -- Operation is given a name.
>> 84 G4VBiasingOperation(G4String name);
>> 85
>> 86 // -- destructor:
>> 87 virtual ~G4VBiasingOperation();
>> 88
>> 89 public:
>> 90 // -----------------------------
>> 91 // -- Interface to sub-classes :
>> 92 // -----------------------------
>> 93 // --
>> 94 // *************************************
>> 95 // ** Methods for physics-based biasing:
>> 96 // *************************************
>> 97 // --
>> 98 // ---- I. Biasing of the process occurence:
>> 99 // -----------------------------------------
>> 100 // ---- The biasing of the process occurence regards the occurence of the PostStepDoIt
>> 101 // ---- behavior. But the weight is manipulated by both AlongStep methods (weight for
>> 102 // ---- non-interaction) and PostStep methods (weight for interaction). For this
>> 103 // ---- reason, occurence biasing is handled by both AlongStep and PostStep methods.
>> 104 // ----
>> 105 // ---- If the operation is returned to the G4BiasingProcessInterface process by the
>> 106 // ---- ProposeOccurenceBiasingOperation(...)/GetProposedOccurenceBiasingOperation(...) method
>> 107 // ---- of the biasing operator, all methods below will be called for this operation.
>> 108 // ----
>> 109 // ---- I.1) Methods called in at the PostStepGetPhysicalInteractionLength(...) level :
>> 110 // ----
>> 111 // ------ o Main and mandatory method for biasing of the PostStep process biasing occurence :
>> 112 // ------ - propose an interaction law to be substituted to the process that is biased
>> 113 // ------ - the operation is told which is the G4BiasingProcessInterface calling it with
>> 114 // ------ callingProcess argument.
>> 115 // ------ - the returned law will have to have been sampled prior to be returned as it will be
>> 116 // ------ asked for its GetSampledInteractionLength() by the callingProcess.
>> 117 virtual const G4VBiasingInteractionLaw* ProvideOccurenceBiasingInteractionLaw( const G4BiasingProcessInterface* /* callingProcess */ ) = 0;
>> 118 // ------ o Additionnal method for PostStep occurence:
>> 119 // ------ - operation can propose a force condition in the PostStepGPIL
>> 120 // ------ - this condition superseedes the wrapped process condition (taken as default condition)
>> 121 // ------ - it is called after above ProvideOccurenceBiasingInteractionLaw(...) by the same calling process.
>> 122 virtual G4ForceCondition ProposeForceCondition( const G4ForceCondition wrappedProcessCondition )
>> 123 {
>> 124 return wrappedProcessCondition;
>> 125 }
>> 126 // ----
>> 127 // ---- I.2) Methods called in at the AlongStepGetPhysicalInteractionLength(...) level :
>> 128 // ----
>> 129 // ------ o Operation can optionnally limit GPIL Along Step:
>> 130 virtual G4double ProposeAlongStepLimit( const G4BiasingProcessInterface* /* callingProcess */ ) { return DBL_MAX; }
>> 131 // ------ o Operation can propose a GPILSelection in the AlongStepGPIL
>> 132 // ------ this selection superseeded the wrapped process selection
>> 133 // ------ if the wrapped process exists, and if has along methods:
>> 134 virtual G4GPILSelection ProposeGPILSelection( const G4GPILSelection wrappedProcessSelection )
>> 135 {return wrappedProcessSelection;}
>> 136
>> 137 // ----
>> 138 // ---- I.3) Methods called in at the AlongStepDoIt(...) level :
>> 139 // ----
>> 140 // ------ o Helper method to inform the operation of the move made in the along, and related non-interaction weight
>> 141 // ------ applied to the primary track for this move:
>> 142 virtual void AlongMoveBy( const G4BiasingProcessInterface* /* callingProcess */,
>> 143 const G4Step* /* step */,
>> 144 G4double /* weightForNonInteraction */ ) {}
>> 145
>> 146 // ----
>> 147 // ---- I.4) Methods called in at the PostStepDoIt(...) level :
>> 148 // ----
>> 149 // ------ o Method allowing the operation to prevent wrapped process interaction to happen:
>> 150 // ------ - has to return true if interaction is denied by the operation
>> 151 // ------ - the primary is left unchanged in this case
>> 152 // ------ - but its weight becomes the one given by proposedTrackWeight.
>> 153 virtual G4bool DenyProcessPostStepDoIt( const G4BiasingProcessInterface* /* callingProcess */,
>> 154 const G4Track* /* track */,
>> 155 const G4Step* /* step */,
>> 156 G4double& /* proposedTrackWeight */ )
>> 157 {return false;}
>> 158
>> 159
>> 160 // ---- II. Biasing of the process post step final state:
>> 161 // ------------------------------------------------------
>> 162 // ------ Mandatory method for biasing of the PostStepDoIt of the wrapped process
>> 163 // ------ holds by the G4BiasingProcessInterface callingProcess.
>> 164 // ------ User has full freedom for the particle change returned, and is reponsible for
>> 165 // ------ the correctness of weights set to tracks.
>> 166 // ------ The wrappedProcess can be accessed through the G4BiasingProcessInterface if needed.
>> 167 // ------ This can be used in conjonction with an occurence biasing, provided this final
>> 168 // ------ state biasing is uncorrelated with the occurence biasing (as single multiplication
>> 169 // ------ of weights occur between these two biasings).
>> 170 virtual G4VParticleChange* ApplyFinalStateBiasing( const G4BiasingProcessInterface* /* callingProcess */,
>> 171 const G4Track* /* track */,
>> 172 const G4Step* /* step */) = 0;
>> 173
>> 174
>> 175 // ---- III. Biasing of the process along step final state:
>> 176 // --------------------------------------------------------
>> 177 // ---- Unprovided for now : requires significant developments.
>> 178
>> 179
>> 180
>> 181 // ***************************************************
>> 182 // -- Methods for non-physics-based biasing operation:
>> 183 // ***************************************************
>> 184 // ----
>> 185 // ---- If the operation is returned to the G4BiasingProcessInterface process by the
>> 186 // ---- ProposeNonPhysicsBiasingOperation(...)/GetProposedNonPhysicsBiasingOperation(...) method
>> 187 // ---- of the biasing operator, all methods below will be called for this operation.
>> 188 // -----
>> 189 // ---- 1) Method called in at the PostStepGetPhysicalInteractionLength(...) level :
>> 190 // ----
>> 191 // ---- o Return to the distance at which the operation should be applied, or may
>> 192 // ---- play with the force condition flags.
>> 193 virtual G4double DistanceToApplyOperation( const G4Track* /* track */,
>> 194 G4double /* previousStepSize */,
>> 195 G4ForceCondition* /* condition */) = 0;
>> 196 // ----
>> 197 // ---- 2) Method called in at the PostStepDoIt(...) level :
>> 198 // ----
>> 199 // ---- o Generate the final state for biasing (eg: splitting, killing, etc.)
>> 200 virtual G4VParticleChange* GenerateBiasingFinalState( const G4Track* /* track */,
>> 201 const G4Step* /* step */) = 0;
>> 202
>> 203
>> 204 // ----------------------------------------
>> 205 // -- public interface and utility methods:
>> 206 // ----------------------------------------
>> 207 public:
>> 208 const G4String& GetName() const {return fName;}
>> 209 std::size_t GetUniqueID() const {return fUniqueID;}
65 210
66 class G4VBiasingOperation <<
67 { <<
68 public: <<
69 <<
70 // -- Constructor: <<
71 G4VBiasingOperation(const G4String& name); <<
72 <<
73 // -- destructor: <<
74 virtual ~G4VBiasingOperation() = default; <<
75 <<
76 // ----------------------------- <<
77 // -- Interface to sub-classes : <<
78 // ----------------------------- <<
79 // -- <<
80 // ************************************* <<
81 // ** Methods for physics-based biasing: <<
82 // ************************************* <<
83 // -- <<
84 // ---- I. Biasing of the process occurren <<
85 // --------------------------------------- <<
86 // ---- The biasing of the process occurre <<
87 // ---- behavior. But the weight is manipu <<
88 // ---- non-interaction) and PostStep meth <<
89 // ---- reason, occurrence biasing is hand <<
90 // ---- <<
91 // ---- If the operation is returned to th <<
92 // ---- ProposeOccurenceBiasingOperation(. <<
93 // ---- of the biasing operator, all metho <<
94 // ---- <<
95 // ---- I.1) Methods called in at the Post <<
96 // ---- <<
97 // ------ o Main and mandatory method for <<
98 // ------ - propose an interaction law t <<
99 // ------ - the operation is told which <<
100 // ------ callingProcess argument. <<
101 // ------ - the returned law will have t <<
102 // ------ asked for its GetSampledInte <<
103 // ------ - the operation can propose a <<
104 // ------ to the operation is the one <<
105 // ------ unchanged, this same value w <<
106 virtual const G4VBiasingInteractionLaw* <<
107 ProvideOccurenceBiasingInteractionLaw( con <<
108 G4F <<
109 // ---- <<
110 // ---- I.2) Methods called in at the Alon <<
111 // ---- <<
112 // ------ o Operation can optionnally limi <<
113 virtual G4double ProposeAlongStepLimit( co <<
114 { return DBL_MAX; } <<
115 <<
116 // ------ o Operation can propose a GPILSe <<
117 // ------ this selection superseeded the <<
118 // ------ if the wrapped process exists, <<
119 virtual G4GPILSelection ProposeGPILSelecti <<
120 { return wrappedProcessSelection; } <<
121 211
122 // ---- << 212 private:
123 // ---- I.3) Methods called in at the Alon << 213 const G4String fName;
124 // ---- << 214 // -- better would be to have fUniqueID const, but pb on windows with constructor.
125 // ------ o Helper method to inform the op << 215 std::size_t fUniqueID;
126 // ------ applied to the primary track f <<
127 virtual void AlongMoveBy( const G4BiasingP <<
128 const G4Step* /* <<
129 G4double / <<
130 <<
131 // ---- II. Biasing of the process post st <<
132 // --------------------------------------- <<
133 // ------ Mandatory method for biasing of <<
134 // ------ holds by the G4BiasingProcessInt <<
135 // ------ User has full freedom for the pa <<
136 // ------ the correctness of weights set t <<
137 // ------ The forcedBiasedFinalState shoul <<
138 // ------ way, if an occurrence biasing is <<
139 // ------ for it will be applied. If retur <<
140 // ------ the returned particle change wil <<
141 // ------ responsibility of the weight cor <<
142 // ------ The wrappedProcess can be access <<
143 // ------ This can be used in conjunction <<
144 // ------ state biasing is uncorrelated wi <<
145 // ------ of weights occur between these t <<
146 virtual G4VParticleChange* ApplyFinalState <<
147 <<
148 <<
149 <<
150 <<
151 // ---- III. Biasing of the process along <<
152 // --------------------------------------- <<
153 // ---- Unprovided for now : requires sign <<
154 <<
155 // *************************************** <<
156 // -- Methods for non-physics-based biasin <<
157 // *************************************** <<
158 // ---- <<
159 // ---- If the operation is returned to th <<
160 // ---- ProposeNonPhysicsBiasingOperation( <<
161 // ---- of the biasing operator, all metho <<
162 // ----- <<
163 // ---- 1) Method called in at the PostSte <<
164 // ---- <<
165 // ---- o Return to the distance at which <<
166 // ---- play with the force condition fl <<
167 virtual G4double DistanceToApplyOperation( <<
168 <<
169 <<
170 // ---- <<
171 // ---- 2) Method called in at the PostSte <<
172 // ---- <<
173 // ---- o Generate the final state for bia <<
174 virtual G4VParticleChange* GenerateBiasing <<
175 <<
176 <<
177 // --------------------------------------- <<
178 // -- public interface and utility methods <<
179 // --------------------------------------- <<
180 <<
181 const G4String& GetName() const { return f <<
182 std::size_t GetUniqueID() const { return f <<
183 <<
184 private: <<
185 <<
186 const G4String fName; <<
187 // -- better would be to have fUniqueID co <<
188 std::size_t fUniqueID; <<
189 }; 216 };
190 217
191 #endif 218 #endif
192 219