Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/processes/hadronic/models/de_excitation/handler/include/G4ExcitationHandler.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/de_excitation/handler/include/G4ExcitationHandler.hh (Version 11.3.0) and /processes/hadronic/models/de_excitation/handler/include/G4ExcitationHandler.hh (Version 10.4)


  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 // $Id: G4ExcitationHandler.hh 104984 2017-07-03 15:13:37Z gcosmo $
                                                   >>  27 //
 26 // Hadronic Process: Nuclear De-excitations        28 // Hadronic Process: Nuclear De-excitations
 27 // by V. Lara (May 1998)                           29 // by V. Lara (May 1998)
 28 //                                                 30 //
 29 // Modifications:                                  31 // Modifications:
 30 // 30 June 1998 by V. Lara:                        32 // 30 June 1998 by V. Lara:
 31 //      -Using G4ParticleTable and therefore G     33 //      -Using G4ParticleTable and therefore G4IonTable
 32 //       it can return all kind of fragments p     34 //       it can return all kind of fragments produced in 
 33 //       deexcitation                              35 //       deexcitation
 34 //      -It uses default algorithms for:           36 //      -It uses default algorithms for:
 35 //              Evaporation: G4StatEvaporation     37 //              Evaporation: G4StatEvaporation
 36 //              MultiFragmentation: G4DummyMF      38 //              MultiFragmentation: G4DummyMF (a dummy one)
 37 //              Fermi Breakup model: G4StatFer     39 //              Fermi Breakup model: G4StatFermiBreakUp
 38 //                                                 40 //
 39 // 03 September 2008 by J. M. Quesada for exte     41 // 03 September 2008 by J. M. Quesada for external choice of inverse 
 40 //    cross section option                         42 //    cross section option
 41 // 06 September 2008 JMQ Also external choices     43 // 06 September 2008 JMQ Also external choices have been added for 
 42 //    superimposed Coulomb barrier (if useSICB <<  44 //    superimposed Coulomb barrier (if useSICBis set true, by default is false)  
 43 // 23 January 2012 by V.Ivanchenko remove obso     45 // 23 January 2012 by V.Ivanchenko remove obsolete data members; added access
 44 //    methods to deexcitation components           46 //    methods to deexcitation components
 45 //                                                 47 //                   
 46                                                    48 
 47 #ifndef G4ExcitationHandler_h                      49 #ifndef G4ExcitationHandler_h
 48 #define G4ExcitationHandler_h 1                    50 #define G4ExcitationHandler_h 1
 49                                                    51 
 50 #include "globals.hh"                              52 #include "globals.hh"
 51 #include "G4Fragment.hh"                           53 #include "G4Fragment.hh"
 52 #include "G4ReactionProductVector.hh"              54 #include "G4ReactionProductVector.hh"
 53 #include "G4IonTable.hh"                           55 #include "G4IonTable.hh"
 54 #include "G4DeexPrecoParameters.hh"                56 #include "G4DeexPrecoParameters.hh"
 55 #include "G4NistManager.hh"                    << 
 56                                                    57 
 57 class G4VMultiFragmentation;                       58 class G4VMultiFragmentation;
 58 class G4VFermiBreakUp;                             59 class G4VFermiBreakUp;
 59 class G4VEvaporation;                              60 class G4VEvaporation;
 60 class G4VEvaporationChannel;                       61 class G4VEvaporationChannel;
 61 class G4ParticleTable;                         <<  62 class G4NistManager;
 62                                                    63 
 63 class G4ExcitationHandler                          64 class G4ExcitationHandler 
 64 {                                                  65 {
 65 public:                                            66 public:
 66                                                    67 
 67   G4ExcitationHandler();                       <<  68   explicit G4ExcitationHandler(); 
 68   ~G4ExcitationHandler();                          69   ~G4ExcitationHandler();
 69                                                    70 
 70   G4ReactionProductVector* BreakItUp(const G4F     71   G4ReactionProductVector* BreakItUp(const G4Fragment &theInitialState);
 71                                                    72 
 72   // short model description used for automati     73   // short model description used for automatic web documentation
 73   void ModelDescription(std::ostream& outFile)     74   void ModelDescription(std::ostream& outFile) const;
 74                                                    75 
 75   void Initialise();                               76   void Initialise();
 76                                                    77 
 77   // user defined sub-models                       78   // user defined sub-models
 78   // deletion is responsibility of this handle     79   // deletion is responsibility of this handler if isLocal=true 
 79   void SetEvaporation(G4VEvaporation* ptr, G4b     80   void SetEvaporation(G4VEvaporation* ptr, G4bool isLocal=false);
 80   void SetMultiFragmentation(G4VMultiFragmenta     81   void SetMultiFragmentation(G4VMultiFragmentation* ptr);
 81   void SetFermiModel(G4VFermiBreakUp* ptr);        82   void SetFermiModel(G4VFermiBreakUp* ptr);
 82   void SetPhotonEvaporation(G4VEvaporationChan     83   void SetPhotonEvaporation(G4VEvaporationChannel* ptr);
 83   void SetDeexChannelsType(G4DeexChannelType v     84   void SetDeexChannelsType(G4DeexChannelType val);
 84                                                    85 
 85   //======== Obsolete methods to be removed ==     86   //======== Obsolete methods to be removed =====
 86                                                    87 
 87   // parameters of sub-models                      88   // parameters of sub-models
 88   inline void SetMaxZForFermiBreakUp(G4int aZ)     89   inline void SetMaxZForFermiBreakUp(G4int aZ);
 89   inline void SetMaxAForFermiBreakUp(G4int anA     90   inline void SetMaxAForFermiBreakUp(G4int anA);
 90   inline void SetMaxAandZForFermiBreakUp(G4int     91   inline void SetMaxAandZForFermiBreakUp(G4int anA,G4int aZ);
 91   inline void SetMinEForMultiFrag(G4double anE     92   inline void SetMinEForMultiFrag(G4double anE);
 92                                                    93 
 93   // access methods                                94   // access methods
 94   G4VEvaporation* GetEvaporation();            <<  95   inline G4VEvaporation* GetEvaporation();
 95   G4VMultiFragmentation* GetMultiFragmentation <<  96   inline G4VMultiFragmentation* GetMultiFragmentation();
 96   G4VFermiBreakUp* GetFermiModel();            <<  97   inline G4VFermiBreakUp* GetFermiModel();
 97   G4VEvaporationChannel* GetPhotonEvaporation( <<  98   inline G4VEvaporationChannel* GetPhotonEvaporation();
 98                                                    99 
 99   // for inverse cross section choice             100   // for inverse cross section choice
100   inline void SetOPTxs(G4int opt);                101   inline void SetOPTxs(G4int opt);
101   // for superimposed Coulomb Barrier for inve << 102   // for superimposed Coulomb Barrir for inverse cross sections
102   inline void UseSICB();                          103   inline void UseSICB();
103                                                   104 
104   //==========================================    105   //==============================================
105                                                   106 
                                                   >> 107 private:
                                                   >> 108 
                                                   >> 109   void SetParameters();
                                                   >> 110 
106   G4ExcitationHandler(const G4ExcitationHandle    111   G4ExcitationHandler(const G4ExcitationHandler &right) = delete;
107   const G4ExcitationHandler & operator            112   const G4ExcitationHandler & operator
108   =(const G4ExcitationHandler &right) = delete    113   =(const G4ExcitationHandler &right) = delete;
109   G4bool operator==(const G4ExcitationHandler     114   G4bool operator==(const G4ExcitationHandler &right) const = delete;
110   G4bool operator!=(const G4ExcitationHandler     115   G4bool operator!=(const G4ExcitationHandler &right) const = delete;
111                                                << 
112 private:                                       << 
113                                                << 
114   void SetParameters();                        << 
115                                                << 
116   inline void SortSecondaryFragment(G4Fragment << 
117                                                   116   
118   G4VEvaporation* theEvaporation{nullptr};     << 117   G4VEvaporation* theEvaporation;  
119   G4VMultiFragmentation* theMultiFragmentation    118   G4VMultiFragmentation* theMultiFragmentation;
120   G4VFermiBreakUp* theFermiModel;                 119   G4VFermiBreakUp* theFermiModel;
121   G4VEvaporationChannel* thePhotonEvaporation;    120   G4VEvaporationChannel* thePhotonEvaporation;
122   G4ParticleTable* thePartTable;               << 
123   G4IonTable* theTableOfIons;                  << 
124   G4NistManager* nist;                         << 
125                                                   121 
126   const G4ParticleDefinition* theElectron;     << 122   const G4ParticleDefinition* electron;
127   const G4ParticleDefinition* theNeutron;      << 123   G4int icID;
128   const G4ParticleDefinition* theProton;       << 
129   const G4ParticleDefinition* theDeuteron;     << 
130   const G4ParticleDefinition* theTriton;       << 
131   const G4ParticleDefinition* theHe3;          << 
132   const G4ParticleDefinition* theAlpha;        << 
133   const G4ParticleDefinition* theLambda;       << 
134                                                << 
135   G4int icID{0};                               << 
136                                                << 
137   G4int maxZForFermiBreakUp{9};                << 
138   G4int maxAForFermiBreakUp{17};               << 
139                                                << 
140   G4int  fVerbose{1};                          << 
141   G4int  fWarnings{0};                         << 
142                                                   124 
                                                   >> 125   G4int maxZForFermiBreakUp;
                                                   >> 126   G4int maxAForFermiBreakUp;
143   G4double minEForMultiFrag;                      127   G4double minEForMultiFrag;
144   G4double minExcitation;                         128   G4double minExcitation;
145   G4double maxExcitation;                      << 
146   G4double fLambdaMass;                        << 
147                                                   129 
148   G4bool isInitialised{false};                 << 130   G4IonTable* theTableOfIons;
149   G4bool isEvapLocal{true};                    << 131   G4NistManager* nist;
150   G4bool isActive{true};                       << 132 
                                                   >> 133   G4int  fVerbose;
                                                   >> 134   G4bool isInitialised;
                                                   >> 135   G4bool isEvapLocal;
                                                   >> 136   G4bool isActive;
151                                                   137 
152   // list of fragments to store final result      138   // list of fragments to store final result   
153   std::vector<G4Fragment*> theResults;            139   std::vector<G4Fragment*> theResults;
154                                                   140 
155   // list of fragments to store intermediate r    141   // list of fragments to store intermediate result   
156   std::vector<G4Fragment*> results;               142   std::vector<G4Fragment*> results;
157                                                   143 
                                                   >> 144   // list of fragments to apply PhotonEvaporation 
                                                   >> 145   std::vector<G4Fragment*> thePhotoEvapList;
                                                   >> 146 
158   // list of fragments to apply Evaporation or    147   // list of fragments to apply Evaporation or Fermi Break-Up
159   std::vector<G4Fragment*> theEvapList;           148   std::vector<G4Fragment*> theEvapList;          
160 };                                                149 };
161                                                   150 
162 inline void G4ExcitationHandler::SetMaxZForFer    151 inline void G4ExcitationHandler::SetMaxZForFermiBreakUp(G4int aZ)
163 {                                                 152 {
164   maxZForFermiBreakUp = aZ;                       153   maxZForFermiBreakUp = aZ;
165 }                                                 154 }
166                                                   155 
167 inline void G4ExcitationHandler::SetMaxAForFer    156 inline void G4ExcitationHandler::SetMaxAForFermiBreakUp(G4int anA)
168 {                                                 157 {
169   maxAForFermiBreakUp = anA;                      158   maxAForFermiBreakUp = anA;
170 }                                                 159 }
171                                                   160 
172 inline void G4ExcitationHandler::SetMaxAandZFo    161 inline void G4ExcitationHandler::SetMaxAandZForFermiBreakUp(G4int anA, G4int aZ)
173 {                                                 162 {
174   SetMaxAForFermiBreakUp(anA);                    163   SetMaxAForFermiBreakUp(anA);
175   SetMaxZForFermiBreakUp(aZ);                     164   SetMaxZForFermiBreakUp(aZ);
176 }                                                 165 }
177                                                   166 
178 inline void G4ExcitationHandler::SetMinEForMul    167 inline void G4ExcitationHandler::SetMinEForMultiFrag(G4double anE)
179 {                                                 168 {
180   minEForMultiFrag = anE;                         169   minEForMultiFrag = anE;
181 }                                                 170 }
182                                                   171 
183 inline void G4ExcitationHandler::SortSecondary << 172 inline G4VEvaporation* G4ExcitationHandler::GetEvaporation()
184 {                                              << 173 {
185   G4int A = frag->GetA_asInt();                << 174   return theEvaporation;
186                                                << 175 }
187   // gamma, e-, p, n                           << 176 
188   if(A <= 1 || frag->IsLongLived()) {          << 177 inline G4VMultiFragmentation* G4ExcitationHandler::GetMultiFragmentation()
189     theResults.push_back(frag);                << 178 {
190   } else if(frag->GetExcitationEnergy() < minE << 179   return theMultiFragmentation;
191     // cold fragments                          << 
192     G4int Z = frag->GetZ_asInt();              << 
193                                                << 
194     // is stable or d, t, He3, He4             << 
195     if(nist->GetIsotopeAbundance(Z, A) > 0.0 | << 
196       theResults.push_back(frag); // stable fr << 
197     } else {                                   << 
198       theEvapList.push_back(frag);             << 
199     }                                          << 
200     // hot fragments are unstable              << 
201   } else {                                     << 
202     theEvapList.push_back(frag);               << 
203   }                                            << 
204 }                                                 180 }
                                                   >> 181 
                                                   >> 182 inline G4VFermiBreakUp* G4ExcitationHandler::GetFermiModel()
                                                   >> 183 {
                                                   >> 184   return theFermiModel;
                                                   >> 185 }
                                                   >> 186 
                                                   >> 187 inline G4VEvaporationChannel* G4ExcitationHandler::GetPhotonEvaporation()
                                                   >> 188 {
                                                   >> 189   return thePhotonEvaporation;
                                                   >> 190 }
                                                   >> 191 
                                                   >> 192 inline void G4ExcitationHandler::SetOPTxs(G4int) 
                                                   >> 193 {}
                                                   >> 194 
                                                   >> 195 inline void G4ExcitationHandler::UseSICB()
                                                   >> 196 {}
205                                                   197 
206 #endif                                            198 #endif
207                                                   199