| 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 // Geant4 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 // - 07/11/14 : suppress DenyProcessPostStepDoIt(...) as redondant
>> 59 // and special case of ApplyFinalStateBiasing(...)
>> 60 // ---------------------------------------------------------------------
>> 61
>> 62
>> 63
52 #ifndef G4VBiasingOperation_hh 64 #ifndef G4VBiasingOperation_hh
53 #define G4VBiasingOperation_hh 1 65 #define G4VBiasingOperation_hh 1
54 66
55 #include "globals.hh" 67 #include "globals.hh"
56 #include "G4ForceCondition.hh" <<
57 #include "G4GPILSelection.hh" <<
58 <<
59 class G4VParticleChange; 68 class G4VParticleChange;
60 class G4Track; 69 class G4Track;
61 class G4Step; 70 class G4Step;
62 class G4VBiasingInteractionLaw; 71 class G4VBiasingInteractionLaw;
63 class G4VProcess; 72 class G4VProcess;
64 class G4BiasingProcessInterface; 73 class G4BiasingProcessInterface;
>> 74 #include "G4ForceCondition.hh"
>> 75 #include "G4GPILSelection.hh"
>> 76
>> 77 class G4VBiasingOperation {
>> 78 public:
>> 79 // ---------------
>> 80 // -- Constructor:
>> 81 // ---------------
>> 82 //
>> 83 // -- Constructor for biasing operations:
>> 84 // -----------------------------------
>> 85 // -- Operation is given a name.
>> 86 G4VBiasingOperation(G4String name);
>> 87
>> 88 // -- destructor:
>> 89 virtual ~G4VBiasingOperation();
>> 90
>> 91 public:
>> 92 // -----------------------------
>> 93 // -- Interface to sub-classes :
>> 94 // -----------------------------
>> 95 // --
>> 96 // *************************************
>> 97 // ** Methods for physics-based biasing:
>> 98 // *************************************
>> 99 // --
>> 100 // ---- I. Biasing of the process occurence:
>> 101 // -----------------------------------------
>> 102 // ---- The biasing of the process occurence regards the occurence of the PostStepDoIt
>> 103 // ---- behavior. But the weight is manipulated by both AlongStep methods (weight for
>> 104 // ---- non-interaction) and PostStep methods (weight for interaction). For this
>> 105 // ---- reason, occurence biasing is handled by both AlongStep and PostStep methods.
>> 106 // ----
>> 107 // ---- If the operation is returned to the G4BiasingProcessInterface process by the
>> 108 // ---- ProposeOccurenceBiasingOperation(...)/GetProposedOccurenceBiasingOperation(...) method
>> 109 // ---- of the biasing operator, all methods below will be called for this operation.
>> 110 // ----
>> 111 // ---- I.1) Methods called in at the PostStepGetPhysicalInteractionLength(...) level :
>> 112 // ----
>> 113 // ------ o Main and mandatory method for biasing of the PostStep process biasing occurence :
>> 114 // ------ - propose an interaction law to be substituted to the process that is biased
>> 115 // ------ - the operation is told which is the G4BiasingProcessInterface calling it with
>> 116 // ------ callingProcess argument.
>> 117 // ------ - the returned law will have to have been sampled prior to be returned as it will be
>> 118 // ------ asked for its GetSampledInteractionLength() by the callingProcess.
>> 119 // ------ - the operation can propose a force condition in the PostStepGPIL (the passed value
>> 120 // ------ to the operation is the one of the wrapped process, if proposeForceCondition is
>> 121 // ------ unchanged, this same value will be used as the biasing foroce condition)
>> 122 virtual const G4VBiasingInteractionLaw* ProvideOccurenceBiasingInteractionLaw( const G4BiasingProcessInterface* /* callingProcess */ ,
>> 123 G4ForceCondition& /* proposeForceCondition */ ) = 0;
>> 124 // ----
>> 125 // ---- I.2) Methods called in at the AlongStepGetPhysicalInteractionLength(...) level :
>> 126 // ----
>> 127 // ------ o Operation can optionnally limit GPIL Along Step:
>> 128 virtual G4double ProposeAlongStepLimit( const G4BiasingProcessInterface* /* callingProcess */ ) { return DBL_MAX; }
>> 129 // ------ o Operation can propose a GPILSelection in the AlongStepGPIL
>> 130 // ------ this selection superseeded the wrapped process selection
>> 131 // ------ if the wrapped process exists, and if has along methods:
>> 132 virtual G4GPILSelection ProposeGPILSelection( const G4GPILSelection wrappedProcessSelection )
>> 133 {return wrappedProcessSelection;}
>> 134
>> 135 // ----
>> 136 // ---- I.3) Methods called in at the AlongStepDoIt(...) level :
>> 137 // ----
>> 138 // ------ o Helper method to inform the operation of the move made in the along, and related non-interaction weight
>> 139 // ------ applied to the primary track for this move:
>> 140 virtual void AlongMoveBy( const G4BiasingProcessInterface* /* callingProcess */,
>> 141 const G4Step* /* step */,
>> 142 G4double /* weightForNonInteraction */ ) {}
>> 143
>> 144
>> 145 // ---- II. Biasing of the process post step final state:
>> 146 // ------------------------------------------------------
>> 147 // ------ Mandatory method for biasing of the PostStepDoIt of the wrapped process
>> 148 // ------ holds by the G4BiasingProcessInterface callingProcess.
>> 149 // ------ User has full freedom for the particle change returned, and is reponsible for
>> 150 // ------ the correctness of weights set to tracks.
>> 151 // ------ The forcedBiasedFinalState should be left as is (ie false) in general. In this
>> 152 // ------ way, if an occurence biasing is also applied in the step, the weight correction
>> 153 // ------ for it will be applied. If returned forceBiasedFinalState is returned true, then
>> 154 // ------ the returned particle change will be returned as is to the stepping. Full
>> 155 // ------ responsibility of the weight correctness is taken by the biasing operation.
>> 156 // ------ The wrappedProcess can be accessed through the G4BiasingProcessInterface if needed.
>> 157 // ------ This can be used in conjonction with an occurence biasing, provided this final
>> 158 // ------ state biasing is uncorrelated with the occurence biasing (as single multiplication
>> 159 // ------ of weights occur between these two biasings).
>> 160 virtual G4VParticleChange* ApplyFinalStateBiasing( const G4BiasingProcessInterface* /* callingProcess */,
>> 161 const G4Track* /* track */,
>> 162 const G4Step* /* step */,
>> 163 G4bool& /* forceBiasedFinalState */) = 0;
>> 164
>> 165
>> 166 // ---- III. Biasing of the process along step final state:
>> 167 // --------------------------------------------------------
>> 168 // ---- Unprovided for now : requires significant developments.
>> 169
>> 170
>> 171
>> 172 // ***************************************************
>> 173 // -- Methods for non-physics-based biasing operation:
>> 174 // ***************************************************
>> 175 // ----
>> 176 // ---- If the operation is returned to the G4BiasingProcessInterface process by the
>> 177 // ---- ProposeNonPhysicsBiasingOperation(...)/GetProposedNonPhysicsBiasingOperation(...) method
>> 178 // ---- of the biasing operator, all methods below will be called for this operation.
>> 179 // -----
>> 180 // ---- 1) Method called in at the PostStepGetPhysicalInteractionLength(...) level :
>> 181 // ----
>> 182 // ---- o Return to the distance at which the operation should be applied, or may
>> 183 // ---- play with the force condition flags.
>> 184 virtual G4double DistanceToApplyOperation( const G4Track* /* track */,
>> 185 G4double /* previousStepSize */,
>> 186 G4ForceCondition* /* condition */) = 0;
>> 187 // ----
>> 188 // ---- 2) Method called in at the PostStepDoIt(...) level :
>> 189 // ----
>> 190 // ---- o Generate the final state for biasing (eg: splitting, killing, etc.)
>> 191 virtual G4VParticleChange* GenerateBiasingFinalState( const G4Track* /* track */,
>> 192 const G4Step* /* step */) = 0;
>> 193
>> 194
>> 195 // ----------------------------------------
>> 196 // -- public interface and utility methods:
>> 197 // ----------------------------------------
>> 198 public:
>> 199 const G4String& GetName() const {return fName;}
>> 200 std::size_t GetUniqueID() const {return fUniqueID;}
65 201
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 202
122 // ---- << 203 private:
123 // ---- I.3) Methods called in at the Alon << 204 const G4String fName;
124 // ---- << 205 // -- better would be to have fUniqueID const, but pb on windows with constructor.
125 // ------ o Helper method to inform the op << 206 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 }; 207 };
190 208
191 #endif 209 #endif
192 210