Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/processes/hadronic/models/inclxx/incl_physics/include/G4INCLInteractionAvatar.hh

Version: [ ReleaseNotes ] [ 1.0 ] [ 1.1 ] [ 2.0 ] [ 3.0 ] [ 3.1 ] [ 3.2 ] [ 4.0 ] [ 4.0.p1 ] [ 4.0.p2 ] [ 4.1 ] [ 4.1.p1 ] [ 5.0 ] [ 5.0.p1 ] [ 5.1 ] [ 5.1.p1 ] [ 5.2 ] [ 5.2.p1 ] [ 5.2.p2 ] [ 6.0 ] [ 6.0.p1 ] [ 6.1 ] [ 6.2 ] [ 6.2.p1 ] [ 6.2.p2 ] [ 7.0 ] [ 7.0.p1 ] [ 7.1 ] [ 7.1.p1 ] [ 8.0 ] [ 8.0.p1 ] [ 8.1 ] [ 8.1.p1 ] [ 8.1.p2 ] [ 8.2 ] [ 8.2.p1 ] [ 8.3 ] [ 8.3.p1 ] [ 8.3.p2 ] [ 9.0 ] [ 9.0.p1 ] [ 9.0.p2 ] [ 9.1 ] [ 9.1.p1 ] [ 9.1.p2 ] [ 9.1.p3 ] [ 9.2 ] [ 9.2.p1 ] [ 9.2.p2 ] [ 9.2.p3 ] [ 9.2.p4 ] [ 9.3 ] [ 9.3.p1 ] [ 9.3.p2 ] [ 9.4 ] [ 9.4.p1 ] [ 9.4.p2 ] [ 9.4.p3 ] [ 9.4.p4 ] [ 9.5 ] [ 9.5.p1 ] [ 9.5.p2 ] [ 9.6 ] [ 9.6.p1 ] [ 9.6.p2 ] [ 9.6.p3 ] [ 9.6.p4 ] [ 10.0 ] [ 10.0.p1 ] [ 10.0.p2 ] [ 10.0.p3 ] [ 10.0.p4 ] [ 10.1 ] [ 10.1.p1 ] [ 10.1.p2 ] [ 10.1.p3 ] [ 10.2 ] [ 10.2.p1 ] [ 10.2.p2 ] [ 10.2.p3 ] [ 10.3 ] [ 10.3.p1 ] [ 10.3.p2 ] [ 10.3.p3 ] [ 10.4 ] [ 10.4.p1 ] [ 10.4.p2 ] [ 10.4.p3 ] [ 10.5 ] [ 10.5.p1 ] [ 10.6 ] [ 10.6.p1 ] [ 10.6.p2 ] [ 10.6.p3 ] [ 10.7 ] [ 10.7.p1 ] [ 10.7.p2 ] [ 10.7.p3 ] [ 10.7.p4 ] [ 11.0 ] [ 11.0.p1 ] [ 11.0.p2 ] [ 11.0.p3, ] [ 11.0.p4 ] [ 11.1 ] [ 11.1.1 ] [ 11.1.2 ] [ 11.1.3 ] [ 11.2 ] [ 11.2.1 ] [ 11.2.2 ] [ 11.3.0 ]

Diff markup

Differences between /processes/hadronic/models/inclxx/incl_physics/include/G4INCLInteractionAvatar.hh (Version 11.3.0) and /processes/hadronic/models/inclxx/incl_physics/include/G4INCLInteractionAvatar.hh (Version 10.7.p1)


  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 // INCL++ intra-nuclear cascade model              26 // INCL++ intra-nuclear cascade model
 27 // Alain Boudard, CEA-Saclay, France               27 // Alain Boudard, CEA-Saclay, France
 28 // Joseph Cugnon, University of Liege, Belgium     28 // Joseph Cugnon, University of Liege, Belgium
 29 // Jean-Christophe David, CEA-Saclay, France       29 // Jean-Christophe David, CEA-Saclay, France
 30 // Pekka Kaitaniemi, CEA-Saclay, France, and H     30 // Pekka Kaitaniemi, CEA-Saclay, France, and Helsinki Institute of Physics, Finland
 31 // Sylvie Leray, CEA-Saclay, France                31 // Sylvie Leray, CEA-Saclay, France
 32 // Davide Mancusi, CEA-Saclay, France              32 // Davide Mancusi, CEA-Saclay, France
 33 //                                                 33 //
 34 #define INCLXX_IN_GEANT4_MODE 1                    34 #define INCLXX_IN_GEANT4_MODE 1
 35                                                    35 
 36 #include "globals.hh"                              36 #include "globals.hh"
 37                                                    37 
 38 /* \file G4INCLInteractionAvatar.hh                38 /* \file G4INCLInteractionAvatar.hh
 39  * \brief Virtual class for interaction avatar     39  * \brief Virtual class for interaction avatars.
 40  *                                                 40  *
 41  * This class is inherited by decay and collis     41  * This class is inherited by decay and collision avatars. The goal is to
 42  * provide a uniform treatment of common physi     42  * provide a uniform treatment of common physics, such as Pauli blocking,
 43  * enforcement of energy conservation, etc.        43  * enforcement of energy conservation, etc.
 44  *                                                 44  *
 45  *  \date Mar 1st, 2011                            45  *  \date Mar 1st, 2011
 46  * \author Davide Mancusi                          46  * \author Davide Mancusi
 47  */                                                47  */
 48                                                    48 
 49 #ifndef G4INCLINTERACTIONAVATAR_HH_                49 #ifndef G4INCLINTERACTIONAVATAR_HH_
 50 #define G4INCLINTERACTIONAVATAR_HH_                50 #define G4INCLINTERACTIONAVATAR_HH_
 51                                                    51 
 52 #include "G4INCLIAvatar.hh"                        52 #include "G4INCLIAvatar.hh"
 53 #include "G4INCLNucleus.hh"                        53 #include "G4INCLNucleus.hh"
 54 #include "G4INCLFinalState.hh"                     54 #include "G4INCLFinalState.hh"
 55 #include "G4INCLRootFinder.hh"                     55 #include "G4INCLRootFinder.hh"
 56 #include "G4INCLKinematicsUtils.hh"                56 #include "G4INCLKinematicsUtils.hh"
 57 #include "G4INCLAllocationPool.hh"                 57 #include "G4INCLAllocationPool.hh"
 58                                                    58 
 59 namespace G4INCL {                                 59 namespace G4INCL {
 60                                                    60 
 61   class InteractionAvatar : public G4INCL::IAv     61   class InteractionAvatar : public G4INCL::IAvatar {
 62     public:                                        62     public:
 63       InteractionAvatar(G4double, G4INCL::Nucl     63       InteractionAvatar(G4double, G4INCL::Nucleus*, G4INCL::Particle*);
 64       InteractionAvatar(G4double, G4INCL::Nucl     64       InteractionAvatar(G4double, G4INCL::Nucleus*, G4INCL::Particle*, G4INCL::Particle*);
 65       virtual ~InteractionAvatar();                65       virtual ~InteractionAvatar();
 66                                                    66 
 67       /// \brief Target accuracy in the determ     67       /// \brief Target accuracy in the determination of the local-energy Q-value
 68       static const G4double locEAccuracy;          68       static const G4double locEAccuracy;
 69       /// \brief Max number of iterations for      69       /// \brief Max number of iterations for the determination of the local-energy Q-value
 70       static const G4int maxIterLocE;              70       static const G4int maxIterLocE;
 71                                                    71 
 72       /// \brief Release the memory allocated      72       /// \brief Release the memory allocated for the backup particles
 73       static void deleteBackupParticles();         73       static void deleteBackupParticles();
 74                                                    74 
 75     protected:                                     75     protected:
 76       virtual G4INCL::IChannel* getChannel() =     76       virtual G4INCL::IChannel* getChannel() = 0;
 77                                                    77 
 78       G4bool bringParticleInside(Particle * co     78       G4bool bringParticleInside(Particle * const p);
 79                                                    79 
 80       /** \brief Apply local-energy transforma     80       /** \brief Apply local-energy transformation, if appropriate
 81        *                                           81        *
 82        * \param p particle to apply the transf     82        * \param p particle to apply the transformation to
 83        */                                          83        */
 84       void preInteractionLocalEnergy(Particle      84       void preInteractionLocalEnergy(Particle * const p);
 85                                                    85 
 86       /** \brief Store the state of the partic     86       /** \brief Store the state of the particles before the interaction
 87        *                                           87        *
 88        * If the interaction cannot be realised     88        * If the interaction cannot be realised for any reason, we will need to
 89        * restore the particle state as it was      89        * restore the particle state as it was before. This is done by calling
 90        * the restoreParticles() method.            90        * the restoreParticles() method.
 91        */                                          91        */
 92       void preInteractionBlocking();               92       void preInteractionBlocking();
 93                                                    93 
 94       void preInteraction();                       94       void preInteraction();
 95       void postInteraction(FinalState *);          95       void postInteraction(FinalState *);
 96                                                    96 
 97       /** \brief Restore the state of both par     97       /** \brief Restore the state of both particles.
 98        *                                           98        *
 99        * The state must first be stored by cal     99        * The state must first be stored by calling preInteractionBlocking().
100        */                                         100        */
101       void restoreParticles() const;              101       void restoreParticles() const;
102                                                   102 
103       /// \brief true if the given avatar shou    103       /// \brief true if the given avatar should use local energy
104       G4bool shouldUseLocalEnergy() const;        104       G4bool shouldUseLocalEnergy() const;
105                                                   105 
106       Nucleus *theNucleus;                        106       Nucleus *theNucleus;
107       Particle *particle1, *particle2;            107       Particle *particle1, *particle2;
108       static G4ThreadLocal Particle *backupPar    108       static G4ThreadLocal Particle *backupParticle1, *backupParticle2;
109       ThreeVector boostVector;                    109       ThreeVector boostVector;
110       G4double oldTotalEnergy, oldXSec;           110       G4double oldTotalEnergy, oldXSec;
111       G4bool isPiN;                               111       G4bool isPiN;
112       G4double weight;                            112       G4double weight;
113                                                   113 
114     private:                                      114     private:
115       /// \brief RootFunctor-derived object fo    115       /// \brief RootFunctor-derived object for enforcing energy conservation in N-N.
116       class ViolationEMomentumFunctor : public    116       class ViolationEMomentumFunctor : public RootFunctor {
117         public:                                   117         public:
118           /** \brief Prepare for calling the (    118           /** \brief Prepare for calling the () operator and scaleParticleMomenta
119            *                                      119            *
120            * The constructor sets the private     120            * The constructor sets the private class members.
121            */                                     121            */
122           ViolationEMomentumFunctor(Nucleus *     122           ViolationEMomentumFunctor(Nucleus * const nucleus, ParticleList const &modAndCre, const G4double totalEnergyBeforeInteraction, ThreeVector const &boost, const G4bool localE);
123           virtual ~ViolationEMomentumFunctor()    123           virtual ~ViolationEMomentumFunctor();
124                                                   124 
125           /** \brief Compute the energy-conser    125           /** \brief Compute the energy-conservation violation.
126            *                                      126            *
127            * \param x scale factor for the par    127            * \param x scale factor for the particle momenta
128            * \return the energy-conservation v    128            * \return the energy-conservation violation
129            */                                     129            */
130           G4double operator()(const G4double x    130           G4double operator()(const G4double x) const;
131                                                   131 
132           /// \brief Clean up after root findi    132           /// \brief Clean up after root finding
133           void cleanUp(const G4bool success) c    133           void cleanUp(const G4bool success) const;
134                                                   134 
135         private:                                  135         private:
136           /// \brief List of final-state parti    136           /// \brief List of final-state particles.
137           ParticleList finalParticles;            137           ParticleList finalParticles;
138           /// \brief CM particle momenta, as d    138           /// \brief CM particle momenta, as determined by the channel.
139           std::vector<ThreeVector> particleMom    139           std::vector<ThreeVector> particleMomenta;
140           /// \brief Total energy before the i    140           /// \brief Total energy before the interaction.
141           G4double initialEnergy;                 141           G4double initialEnergy;
142           /// \brief Pointer to the nucleus       142           /// \brief Pointer to the nucleus
143           Nucleus *theNucleus;                    143           Nucleus *theNucleus;
144           /// \brief Pointer to the boost vect    144           /// \brief Pointer to the boost vector
145           ThreeVector const &boostVector;         145           ThreeVector const &boostVector;
146                                                   146 
147           /// \brief True if we should use loc    147           /// \brief True if we should use local energy
148           const G4bool shouldUseLocalEnergy;      148           const G4bool shouldUseLocalEnergy;
149                                                   149 
150           /** \brief Scale the momenta of the     150           /** \brief Scale the momenta of the modified and created particles.
151            *                                      151            *
152            * Set the momenta of the modified a    152            * Set the momenta of the modified and created particles to alpha times
153            * their original momenta (stored in    153            * their original momenta (stored in particleMomenta). You must call
154            * init() before using this method.     154            * init() before using this method.
155            *                                      155            *
156            * \param alpha scale factor            156            * \param alpha scale factor
157            */                                     157            */
158           void scaleParticleMomenta(const G4do    158           void scaleParticleMomenta(const G4double alpha) const;
159                                                   159 
160       };                                          160       };
161                                                   161 
162       /// \brief RootFunctor-derived object fo    162       /// \brief RootFunctor-derived object for enforcing energy conservation in delta production
163       class ViolationEEnergyFunctor : public R    163       class ViolationEEnergyFunctor : public RootFunctor {
164         public:                                   164         public:
165           /** \brief Prepare for calling the (    165           /** \brief Prepare for calling the () operator and setParticleEnergy
166            *                                      166            *
167            * The constructor sets the private     167            * The constructor sets the private class members.
168            */                                     168            */
169           ViolationEEnergyFunctor(Nucleus * co    169           ViolationEEnergyFunctor(Nucleus * const nucleus, Particle * const aParticle, const G4double totalEnergyBeforeInteraction, const G4bool localE);
170           virtual ~ViolationEEnergyFunctor() {    170           virtual ~ViolationEEnergyFunctor() {}
171                                                   171 
172           /** \brief Compute the energy-conser    172           /** \brief Compute the energy-conservation violation.
173            *                                      173            *
174            * \param x scale factor for the par    174            * \param x scale factor for the particle energy
175            * \return the energy-conservation v    175            * \return the energy-conservation violation
176            */                                     176            */
177           G4double operator()(const G4double x    177           G4double operator()(const G4double x) const;
178                                                   178 
179           /// \brief Clean up after root findi    179           /// \brief Clean up after root finding
180           void cleanUp(const G4bool success) c    180           void cleanUp(const G4bool success) const;
181                                                   181 
182           /** \brief Set the energy of the par    182           /** \brief Set the energy of the particle.
183            *                                      183            *
184            * \param energy                        184            * \param energy
185            */                                     185            */
186           void setParticleEnergy(const G4doubl    186           void setParticleEnergy(const G4double energy) const;
187                                                   187 
188         private:                                  188         private:
189           /// \brief Total energy before the i    189           /// \brief Total energy before the interaction.
190           G4double initialEnergy;                 190           G4double initialEnergy;
191           /// \brief Pointer to the nucleus.      191           /// \brief Pointer to the nucleus.
192           Nucleus *theNucleus;                    192           Nucleus *theNucleus;
193           /// \brief The final-state particle.    193           /// \brief The final-state particle.
194           Particle *theParticle;                  194           Particle *theParticle;
195           /// \brief The initial energy of the    195           /// \brief The initial energy of the particle.
196           G4double theEnergy;                     196           G4double theEnergy;
197           /// \brief The initial momentum of t    197           /// \brief The initial momentum of the particle.
198           ThreeVector theMomentum;                198           ThreeVector theMomentum;
199           /** \brief Threshold for the energy     199           /** \brief Threshold for the energy of the particle
200            *                                      200            *
201            * The particle (a delta) cannot hav    201            * The particle (a delta) cannot have less than this energy.
202            */                                     202            */
203           G4double energyThreshold;               203           G4double energyThreshold;
204           /// \brief Whether we should use loc    204           /// \brief Whether we should use local energy
205           const G4bool shouldUseLocalEnergy;      205           const G4bool shouldUseLocalEnergy;
206       };                                          206       };
207                                                   207 
208       RootFunctor *violationEFunctor;             208       RootFunctor *violationEFunctor;
209                                                   209 
210     protected:                                    210     protected:
211       /** \brief Enforce energy conservation.     211       /** \brief Enforce energy conservation.
212        *                                          212        *
213        * Final states generated by the channel    213        * Final states generated by the channels might violate energy conservation
214        * because of different reasons (energy-    214        * because of different reasons (energy-dependent potentials, local
215        * energy...). This conservation law mus    215        * energy...). This conservation law must therefore be enforced by hand. We
216        * do so by rescaling the momenta of the    216        * do so by rescaling the momenta of the final-state particles in the CM
217        * frame. If this turns out to be imposs    217        * frame. If this turns out to be impossible, this method returns false.
218        *                                          218        *
219        * \return true if the algorithm succeed    219        * \return true if the algorithm succeeded
220        */                                         220        */
221       G4bool enforceEnergyConservation(FinalSt    221       G4bool enforceEnergyConservation(FinalState * const fs);
222                                                   222 
223       ParticleList modified, created, modified    223       ParticleList modified, created, modifiedAndCreated, Destroyed, ModifiedAndDestroyed;
224                                                   224 
225       INCL_DECLARE_ALLOCATION_POOL(Interaction    225       INCL_DECLARE_ALLOCATION_POOL(InteractionAvatar)
226   };                                              226   };
227                                                   227 
228 }                                                 228 }
229                                                   229 
230 #endif /* G4INCLINTERACTIONAVATAR_HH_ */          230 #endif /* G4INCLINTERACTIONAVATAR_HH_ */
231                                                   231