Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/global/management/src/G4PhysicsModelCatalog.cc

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 /global/management/src/G4PhysicsModelCatalog.cc (Version 11.3.0) and /global/management/src/G4PhysicsModelCatalog.cc (Version 10.3.p3)


  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 // G4PhysicsModelCatalog class implementation  << 
 27 //                                                 26 //
 28 // Author: M.Asai (SLAC), 26 September 2013    <<  27 // $Id: G4ios.cc 70004 2013-05-21 16:28:30Z adotti $
 29 //                                                 28 //
 30 // Revised in August 2021 by A.Ribon (CERN).   << 
 31 // ------------------------------------------- << 
 32                                                    29 
 33 #include "G4PhysicsModelCatalog.hh"                30 #include "G4PhysicsModelCatalog.hh"
                                                   >>  31 
                                                   >>  32 #ifdef G4MULTITHREADED
 34 #include "G4Threading.hh"                          33 #include "G4Threading.hh"
                                                   >>  34 #endif
 35                                                    35 
 36 G4bool G4PhysicsModelCatalog::isInitialized =  <<  36 modelCatalog* G4PhysicsModelCatalog::catalog = 0;
 37 std::vector< G4int >*    G4PhysicsModelCatalog << 
 38 std::vector< G4String >* G4PhysicsModelCatalog << 
 39                                                << 
 40 // ------------------------------------------- << 
 41 void G4PhysicsModelCatalog::Initialize() {     << 
 42   if(isInitialized)                            << 
 43   {                                            << 
 44     return;                                    << 
 45   }                                            << 
 46   if ( theVectorOfModelIDs == nullptr  &&  the << 
 47     static std::vector< G4int > aVectorOfInts; << 
 48     theVectorOfModelIDs = &aVectorOfInts;      << 
 49     static std::vector< G4String > aVectorOfSt << 
 50     theVectorOfModelNames = &aVectorOfStrings; << 
 51                                                << 
 52     // NOTE:                                   << 
 53     // The goal is that, starting from Geant4  << 
 54     // identifiers (modelID, index, name) rema << 
 55     // physics list, application, and version  << 
 56     // Therefore, after Geant4 11.0, you can o << 
 57     // a new model is added, or when a pre-exi << 
 58     // in this catalogue is included - at the  << 
 59     // (rather than inserting it in the middle << 
 60     //                                         << 
 61     // For the modelID values, these are the c << 
 62     // - Values below 1000 are excluded becaus << 
 63     //   sub-process ID values.                << 
 64     // - Whenever resonable, modelID values sh << 
 65     //   them, to allow for eventual, future v << 
 66     //   tunings of the same model - to keep m << 
 67     //   original model.                       << 
 68     // - modelID values are between 10'000 and << 
 69     //   subdivision in 3 categories (identifi << 
 70     //   digit):                               << 
 71     //   *  Values between 10'000 and 19'999 a << 
 72     //   *  Values between 20'000 and 29'999 a << 
 73     //   *  Values between 30'000 and 39'999 a << 
 74     //      (i.e. included neither in EM model << 
 75     //   Note that larger values of modelID ar << 
 76     //   handle nor less computing performant  << 
 77     //   (we remind that, for plotting, the in << 
 78     //    its modelID, should be conveniently  << 
 79     //    the modelID is recommended).         << 
 80                                                << 
 81     // ======================================= << 
 82     // ================= 1st EM MODELS : from  << 
 83     // ======================================= << 
 84                                                << 
 85     InsertModel( 10000, "model_EM" );          << 
 86                                                << 
 87     // e- production                           << 
 88     InsertModel( 10010, "model_DeltaElectron"  << 
 89     InsertModel( 10011, "model_DeltaEBelowCut" << 
 90     InsertModel( 10012, "model_PhotoElectron"  << 
 91     InsertModel( 10013, "model_ComptonElectron << 
 92     InsertModel( 10014, "model_TripletElectron << 
 93                                                << 
 94     // gamma production                        << 
 95     InsertModel( 10020, "model_Bremsstrahlung" << 
 96     InsertModel( 10021, "model_SplitBremsstrah << 
 97     InsertModel( 10022, "model_ComptonGamma" ) << 
 98     InsertModel( 10023, "model_Annihilation" ) << 
 99     InsertModel( 10024, "model_TripletGamma" ) << 
100     InsertModel( 10025, "model_GammaGammaEntan << 
101                                                << 
102     // e+e- pair production                    << 
103     InsertModel( 10030, "model_EplusEminisPair << 
104                                                << 
105     // atomic de-excitation                    << 
106     InsertModel( 10040, "model_Fluorescence" ) << 
107     InsertModel( 10041, "model_gammaPIXE" );   << 
108     InsertModel( 10050, "model_AugerElectron"  << 
109     InsertModel( 10051, "model_ePIXE" );       << 
110                                                << 
111     // recoil ions                             << 
112     InsertModel( 10060, "model_IonRecoil" );   << 
113                                                << 
114     // DNA models                              << 
115     InsertModel( 11000, "model_DNA" );         << 
116     InsertModel( 11001, "model_Ritchie1994eSol << 
117     InsertModel( 11002, "model_Terrisol1990eSo << 
118     InsertModel( 11003, "model_Meesungnoen2002 << 
119     InsertModel( 11004, "model_Kreipl2009eSolv << 
120     InsertModel( 11005, "model_MeesungnoenSoli << 
121                                                << 
122     // ======================================= << 
123     // ============= 2nd HADRONIC MODELS : fro << 
124     // ======================================= << 
125                                                << 
126     // --------------------------------------- << 
127     // --- Gamma- , Lepto- , Neutrino-nuclear  << 
128     // --------------------------------------- << 
129     //    -  20'000 - 20'099 : Electromagnetic << 
130     //    -  20'100 - 20'199 : Gamma-nuclear m << 
131     //    -  20'200 - 20-299 : Electron/positr << 
132     //    -  20'300 - 20'399 : Muon-nuclear mo << 
133     //    -  20'400 - 20'499 : Tau-nuclear mod << 
134     //    -  20'500 - 20'999 : Neutrino models << 
135     //    ...                                  << 
136                                                << 
137     // --- EM dissociation models: 20'000 - 20 << 
138                                                << 
139     // Class G4EMDissociation                  << 
140     InsertModel( 20000, "model_projectileEMDis << 
141     InsertModel( 20001, "model_targetEMDissoci << 
142                                                << 
143     // --- Gamma-nuclear models: 20'100 - 20'1 << 
144                                                << 
145     // Class G4LENDorBERTModel                 << 
146     InsertModel( 20100, "model_LENDorBERTModel << 
147                                                << 
148     // Class G4LowEGammaNuclearModel           << 
149     InsertModel( 20150, "model_GammaNPreco" ); << 
150                                                << 
151     // --- Charged-lepton - nuclear models: 20 << 
152                                                << 
153     // Class G4ElectroVDNuclearModel           << 
154     InsertModel( 20200, "model_G4ElectroVDNucl << 
155                                                << 
156     // Class G4MuonVDNuclearModel              << 
157     InsertModel( 20300, "model_G4MuonVDNuclear << 
158                                                << 
159     // --- Neutrino models: 20'500 - 20'999 -- << 
160                                                << 
161     // Class G4NeutrinoElectronCcModel         << 
162     InsertModel( 20510, "model_nu-e-inelastic" << 
163                                                << 
164     // Class G4NeutrinoNucleusModel            << 
165     InsertModel( 20520, "model_neutrino-nucleu << 
166                                                << 
167     // The following classes derives from G4Ne << 
168     // Class G4ANuElNucleusCcModel             << 
169     InsertModel( 20530, "model_ANuElNuclCcMode << 
170     // Class G4ANuElNucleusNcModel             << 
171     InsertModel( 20540, "model_ANuElNuclNcMode << 
172     // Class G4ANuMuNucleusCcModel             << 
173     InsertModel( 20550, "model_ANuMuNuclCcMode << 
174     // Class G4ANuMuNucleusNcModel             << 
175     InsertModel( 20560, "model_ANuMuNuclNcMode << 
176     // Class G4NuElNucleusCcModel              << 
177     InsertModel( 20570, "model_NuElNuclCcModel << 
178     // Class G4NuElNucleusNcModel              << 
179     InsertModel( 20580, "model_NuElNuclNcModel << 
180     // Class G4NuMuNucleusCcModel              << 
181     InsertModel( 20590, "model_NuMuNuclCcModel << 
182     // Class G4NuMuNucleusNcModel              << 
183     InsertModel( 20600, "model_NuMuNuclNcModel << 
184                                                << 
185     // --------------------------------------- << 
186     // --- Elastic, Charge-Exchange, Quasi-Ela << 
187     // --------------------------------------- << 
188     //    -  21'000 - 21'199 : Elastic         << 
189     //    -  21'200 - 21'299 : Charge-Exchange << 
190     //    -  21'300 - 21'499 : Quasi-Elastic   << 
191     //    -  21'500 - 21'999 : specialized Dif << 
192     // --------------------------------------- << 
193                                                << 
194     // --- Elastic models: 21'000 - 21'199 --- << 
195                                                << 
196     // Class G4HadronElastic                   << 
197     InsertModel( 21000, "model_hElasticLHEP" ) << 
198     // Class G4AntiNuclElastic                 << 
199     InsertModel( 21010, "model_AntiAElastic" ) << 
200     // Class G4ChipsElasticModel               << 
201     InsertModel( 21020, "model_hElasticCHIPS"  << 
202     // Class G4DiffuseElastic                  << 
203     InsertModel( 21030, "model_DiffuseElastic" << 
204     // Class G4DiffuseElasticV2                << 
205     InsertModel( 21040, "model_DiffuseElasticV << 
206     // Class G4NuclNuclDiffuseElastic          << 
207     InsertModel( 21050, "model_NNDiffuseElasti << 
208     // Class G4ElasticHadrNucleusHE            << 
209     InsertModel( 21060, "model_hElasticGlauber << 
210     // Class G4hhElastic                       << 
211     InsertModel( 21070, "model_HadrHadrElastic << 
212     // Class G4LowEHadronElastic               << 
213     InsertModel( 21080, "model_hLowEElastic" ) << 
214     // Class G4LEHadronProtonElastic           << 
215     InsertModel( 21090, "model_G4LEHadronProto << 
216     // Class G4LEnp                            << 
217     InsertModel( 21100, "model_G4LEnp" );      << 
218     // Class G4LEpp                            << 
219     InsertModel( 21110, "model_G4LEpp" );      << 
220     // Class G4NeutronElectronElModel          << 
221     InsertModel( 21120, "model_n-e-elastic" ); << 
222     // Class G4NeutrinoElectronNcModel         << 
223     InsertModel( 21130, "model_nu-e-elastic" ) << 
224                                                << 
225     // --- Charge exchange : 21'200 - 21'299 - << 
226                                                << 
227     // Class: G4ChargeExchange                 << 
228     InsertModel( 21200, "model_ChargeExchange" << 
229                                                << 
230     // --- Quasi-Elastic : 21'300 - 21'499 --- << 
231                                                << 
232     // Class: G4QuasiElasticChannel (which use << 
233     InsertModel( 21300, "model_QuasiElastic" ) << 
234                                                << 
235     // --- Special diffraction generators : 21 << 
236                                                << 
237     // Class: G4LMsdGenerator                  << 
238     InsertModel( 21500, "model_LMsdGenerator"  << 
239                                                << 
240     // --------------------------------------- << 
241     // --- High energy-models (e.g. string mod << 
242     // --------------------------------------- << 
243     //    -  22'000 - 22'099 : G4TheoFSGenerat << 
244     //    -  22'100 - 22'199 : FTF             << 
245     //    -  22'200 - 22'299 : QGS             << 
246     //    -  ...                               << 
247     // For gamma         - nuclear : QGS strin << 
248     // For e-/e+/mu-/mu+ - nuclear : FTF strin << 
249     InsertModel( 22000, "model_TheoFSGenerator << 
250     // FTF string formation + Lund string frag << 
251     InsertModel( 22100, "model_FTFP" );        << 
252     // FTF string formation + Lund string frag << 
253     InsertModel( 22150, "model_FTFB" );        << 
254     // FTF string formation + QGS string fragm << 
255     InsertModel( 22175, "model_FTFQGSP" );     << 
256     // QGS string formation + QGS string fragm << 
257     InsertModel( 22200, "model_QGSP" );        << 
258     // QGS string formation + QGS string fragm << 
259     InsertModel( 22250, "model_QGSB" );        << 
260                                                << 
261     // --------------------------------------- << 
262     // --- Intermediate energy models : 23'000 << 
263     // --------------------------------------- << 
264     //    -  23'000 - 23'099 : BERT            << 
265     //    -  23'100 - 23'199 : BIC             << 
266     //    -  23'200 - 23'299 : INCL            << 
267     //    -  23'300 - 23'399 : QMD             << 
268     //    ...                                  << 
269     // Class: G4CascadeInterface               << 
270     InsertModel( 23000, "model_BertiniCascade" << 
271                                                << 
272     // The names are similar, but not identica << 
273     // Class: G4BinaryCascade                  << 
274     InsertModel( 23100, "model_G4BinaryCascade << 
275     // Class: G4BinaryLightIonReaction         << 
276     InsertModel( 23110, "model_G4BinaryLightIo << 
277                                                << 
278     // Class: G4INCLXXInterface                << 
279     InsertModel( 23200, "model_INCLXXCascade"  << 
280                                                << 
281     // Class: G4QMDReaction                    << 
282     InsertModel( 23300, "model_QMDModel" );    << 
283                                                << 
284     // --------------------------------------- << 
285     // --- Pre-equilibrium/De-excitation model << 
286     // --------------------------------------- << 
287     //    -  Pre-equilibrium : 24'000 - 24'099 << 
288     //       *  24'000 - 24'049 : precompound  << 
289     //       *  24'050 - 24'099 : internal BER << 
290     //    -  de-excitation : 24'100 - 24'999   << 
291     //       *  24'100 - 24'149 : Evaporation  << 
292     //       *  24'150 - 24'199 : Photon evapo << 
293     //       *  24'200 - 24'299 : GEM evaporat << 
294     //       *  24'300 - 24'349 : Fermi BreakU << 
295     //       *  24'350 - 24'399 : Multifragmen << 
296     //       *  24'400 - 24'449 : Ablation     << 
297     //       *  24'450 - 24'499 : Fission      << 
298     //       *  24'500 - 24'599 : ABLA         << 
299     //       *  24'600 - 24'699 : internal BER << 
300     //       ...                               << 
301                                                << 
302     // --- Pre-equilibrium: 24'000 - 24'099 -- << 
303                                                << 
304     // Class: G4PreCompoundModel               << 
305     InsertModel( 24000, "model_PRECO" );       << 
306                                                << 
307     // Class: G4LowEIonFragmentation           << 
308     InsertModel( 24010, "model_LowEIonPreco" ) << 
309                                                << 
310     // Class: G4NonEquilibriumEvaporator (i.e. << 
311     InsertModel( 24050, "model_G4NonEquilibriu << 
312                                                << 
313     // --- De-excitation: 24'100 - 24'999 ---  << 
314                                                << 
315     //     --- Evaporation: 24'100-  24'149 -- << 
316                                                << 
317     // Class: G4EvaporationChannel             << 
318     InsertModel( 24100, "model_G4EvaporationCh << 
319                                                << 
320     // Class: G4UnstableFragmentBreakUp        << 
321     InsertModel( 24120, "model_G4UnstableFragm << 
322                                                << 
323     //     --- Photon-Evaporation: 24'150 - 24 << 
324                                                << 
325     // Class: G4PhotonEvaporation              << 
326     InsertModel( 24150, "model_G4PhotonEvapora << 
327                                                << 
328     // Class: G4NeutronRadCapture              << 
329     InsertModel( 24160, "model_nRadCapture" ); << 
330                                                << 
331     //     --- GEM evaporation : 24'200 - 24'2 << 
332                                                << 
333     // Class: G4GEMChannel                     << 
334     InsertModel( 24200, "model_G4GEMChannel" ) << 
335                                                << 
336     // Class: G4GEMChannelVI                   << 
337     InsertModel( 24210, "model_G4GEMChannelVI" << 
338                                                << 
339     //     --- Fermi BreakUp : 24'300 - 24'349 << 
340                                                << 
341     // Class: G4FermiBreakUpVI                 << 
342     InsertModel( 24300, "model_G4FermiBreakUpV << 
343                                                << 
344     //     --- Multifragmentation : 24'350 - 2 << 
345                                                << 
346     // Class: G4StatMF                         << 
347     InsertModel( 24350, "model_G4StatMF" );    << 
348                                                << 
349     //     --- Ablation : 24'400 - 24'449 ---  << 
350                                                << 
351     // Class: G4WilsonAblationModel            << 
352     InsertModel( 24400, "model_G4WilsonAblatio << 
353                                                << 
354     //     --- Fission : 24'450 - 24'499 ---   << 
355                                                << 
356     // Class: G4CompetitiveFission             << 
357     InsertModel( 24450, "model_G4CompetitiveFi << 
358                                                << 
359     //     --- ABLA : 24'500 - 24'599 ---      << 
360                                                << 
361     // Class: G4AblaInterface                  << 
362     InsertModel( 24500, "model_ABLA" );        << 
363                                                << 
364     //     --- internal BERT de-excitation : 2 << 
365                                                << 
366     // Class: G4EquilibriumEvaporator          << 
367     InsertModel( 24600, "model_G4EquilibriumEv << 
368                                                << 
369     //     --- Other types of de-excitation :  << 
370                                                << 
371     //     ...                                 << 
372                                                << 
373     // --------------------------------------- << 
374     // --- Low-energy data-driven : 25'000 - 2 << 
375     // --------------------------------------- << 
376     //    -  25'000 - 25'199 : ParticleHP      << 
377     //    -  25'200 - 25'299 : LEND            << 
378     //       ...                               << 
379     //    -  25'500 - 25'999 : RadioactiveDeca << 
380                                                << 
381     // --- ParticleHP : 25'000 - 25'199 ---    << 
382                                                << 
383     // Classes: G4ParticleHPCapture , G4Partic << 
384     InsertModel( 25000, "model_NeutronHPCaptur << 
385                                                << 
386     // Classes: G4ParticleHPElastic , G4Partic << 
387     InsertModel( 25010, "model_NeutronHPElasti << 
388                                                << 
389     // Classes: G4ParticleHPFission , G4Partic << 
390     InsertModel( 25020, "model_NeutronHPFissio << 
391                                                << 
392     // Inelastic: the following classes inheri << 
393     //            G4ParticleHPInelasticCompFS, << 
394                                                << 
395     // Class G4ParticleHPNInelasticFS          << 
396     InsertModel( 25030, "model_G4ParticleHPNIn << 
397     // Class model_G4ParticleHPNXInelasticFS   << 
398     InsertModel( 25031, "model_G4ParticleHPNXI << 
399     // Class G4ParticleHP2NDInelasticFS        << 
400     InsertModel( 25032, "model_G4ParticleHP2ND << 
401     // Class G4ParticleHP2NInelasticFS         << 
402     InsertModel( 25033, "model_G4ParticleHP2NI << 
403     // Class G4ParticleHP3NInelasticFS         << 
404     InsertModel( 25034, "model_G4ParticleHP3NI << 
405     // Class G4ParticleHPNAInelasticFS         << 
406     InsertModel( 25035, "model_G4ParticleHPNAI << 
407     // Class G4ParticleHPN3AInelasticFS        << 
408     InsertModel( 25036, "model_G4ParticleHPN3A << 
409     // Class G4ParticleHP2NAInelasticFS        << 
410     InsertModel( 25037, "model_G4ParticleHP2NA << 
411     // Class G4ParticleHP3NAInelasticFS        << 
412     InsertModel( 25038, "model_G4ParticleHP3NA << 
413     // Class G4ParticleHPNPInelasticFS         << 
414     InsertModel( 25039, "model_G4ParticleHPNPI << 
415     // Class G4ParticleHPN2AInelasticFS        << 
416     InsertModel( 25040, "model_G4ParticleHPN2A << 
417     // Clas G4ParticleHP2N2AInelasticFS        << 
418     InsertModel( 25041, "model_G4ParticleHP2N2 << 
419     // Class G4ParticleHPNDInelasticFS         << 
420     InsertModel( 25042, "model_G4ParticleHPNDI << 
421     // Class G4ParticleHPNTInelasticFS         << 
422     InsertModel( 25043, "model_G4ParticleHPNTI << 
423     // Class G4ParticleHPNHe3InelasticFS       << 
424     InsertModel( 25044, "model_G4ParticleHPNHe << 
425     // Class G4ParticleHPND2AInelasticFS       << 
426     InsertModel( 25045, "model_G4ParticleHPND2 << 
427     // Class G4ParticleHPNT2AInelasticFS       << 
428     InsertModel( 25046, "model_G4ParticleHPNT2 << 
429     // Class G4ParticleHP4NInelasticFS         << 
430     InsertModel( 25047, "model_G4ParticleHP4NI << 
431     // Class G4ParticleHP2NPInelasticFS        << 
432     InsertModel( 25048, "model_G4ParticleHP2NP << 
433     // Class G4ParticleHP3NPInelasticFS        << 
434     InsertModel( 25049, "model_G4ParticleHP3NP << 
435     // Class G4ParticleHPN2PInelasticFS        << 
436     InsertModel( 25050, "model_G4ParticleHPN2P << 
437     // Class G4ParticleHPNPAInelasticFS        << 
438     InsertModel( 25051, "model_G4ParticleHPNPA << 
439     // Class G4ParticleHPPInelasticFS          << 
440     InsertModel( 25052, "model_G4ParticleHPPIn << 
441     // Class G4ParticleHPDInelasticFS          << 
442     InsertModel( 25053, "model_G4ParticleHPDIn << 
443     // Class G4ParticleHPTInelasticFS          << 
444     InsertModel( 25054, "model_G4ParticleHPTIn << 
445     // Class G4ParticleHPHe3InelasticFS        << 
446     InsertModel( 25055, "model_G4ParticleHPHe3 << 
447     // Class G4ParticleHPAInelasticFS          << 
448     InsertModel( 25056, "model_G4ParticleHPAIn << 
449     // Class G4ParticleHP2AInelasticFS         << 
450     InsertModel( 25057, "model_G4ParticleHP2AI << 
451     // Class G4ParticleHP3AInelasticFS         << 
452     InsertModel( 25058, "model_G4ParticleHP3AI << 
453     // Class G4ParticleHP2PInelasticFS         << 
454     InsertModel( 25059, "model_G4ParticleHP2PI << 
455     // Class G4ParticleHPPAInelasticFS         << 
456     InsertModel( 25060, "model_G4ParticleHPPAI << 
457     // Class G4ParticleHPD2AInelasticFS        << 
458     InsertModel( 25061, "model_G4ParticleHPD2A << 
459     // Class G4ParticleHPT2AInelasticFS        << 
460     InsertModel( 25062, "model_G4ParticleHPT2A << 
461     // Class G4ParticleHPPDInelasticFS         << 
462     InsertModel( 25063, "model_G4ParticleHPPDI << 
463     // Class G4ParticleHPPTInelasticFS         << 
464     InsertModel( 25064, "model_G4ParticleHPPTI << 
465     // Class G4ParticleHPDAInelasticFS         << 
466     InsertModel( 25065, "model_G4ParticleHPDAI << 
467                                                << 
468     // --- LEND : 25'200 - 25'299 ---          << 
469                                                << 
470     // Class: G4LENDModel                      << 
471     InsertModel( 25200, "model_LENDModel" );   << 
472                                                << 
473     // The following classes inherit from G4LE << 
474                                                << 
475     // Class: G4LENDCapture                    << 
476     InsertModel( 25210, "model_LENDCapture" ); << 
477     // Class: G4LENDElastic                    << 
478     InsertModel( 25220, "model_LENDElastic" ); << 
479     // Class: G4LENDFission                    << 
480     InsertModel( 25230, "model_LENDFission" ); << 
481     // Class: G4LENDInelastic                  << 
482     InsertModel( 25240, "model_LENDInelastic"  << 
483     // Class: G4LENDCombinedModel              << 
484     InsertModel( 25250, "model_LENDCombinedMod << 
485     // Class: G4LENDGammaModel                 << 
486     InsertModel( 25260, "model_LENDGammaModel" << 
487                                                << 
488     // --- Radioactive Decay : 25'500 - 25'999 << 
489                                                << 
490     // 25'510 +  10*G4RadioactiveDecayMode     << 
491     InsertModel( 25510, "model_RDM_IT" );      << 
492     InsertModel( 25520, "model_RDM_BetaMinus"  << 
493     InsertModel( 25530, "model_RDM_BetaPlus" ) << 
494     InsertModel( 25540, "model_RDM_KshellEC" ) << 
495     InsertModel( 25550, "model_RDM_LshellEC" ) << 
496     InsertModel( 25560, "model_RDM_MshellEC" ) << 
497     InsertModel( 25570, "model_RDM_NshellEC" ) << 
498     InsertModel( 25580, "model_RDM_Alpha" );   << 
499     InsertModel( 25590, "model_RDM_Proton" );  << 
500     InsertModel( 25600, "model_RDM_Neutron" ); << 
501     InsertModel( 25610, "model_RDM_SpFission"  << 
502     InsertModel( 25620, "model_RDM_BDProton" ) << 
503     InsertModel( 25630, "model_RDM_BDNeutron"  << 
504     InsertModel( 25640, "model_RDM_Beta2Minus" << 
505     InsertModel( 25650, "model_RDM_Beta2Plus"  << 
506     InsertModel( 25660, "model_RDM_Proton2" ); << 
507     InsertModel( 25670, "model_RDM_Neutron2" ) << 
508     InsertModel( 25680, "model_RDM_Triton" );  << 
509                                                << 
510     InsertModel( 25810, "model_RDM_AtomicRelax << 
511                                                << 
512     // --------------------------------------- << 
513     // --- Others HAD (everything not include  << 
514     // --------------------------------------- << 
515     //    -  26'000 - 26'099 : Stopping        << 
516     //    -  26'100 - 26'199 : Fission         << 
517     //    -  26'200 - 26'299 : Abration        << 
518     //    -  26'300 - 26'399 : Coalescence     << 
519     //    ...                                  << 
520                                                << 
521     // --- Stopping : 26'000 - 26'099 ---      << 
522                                                << 
523     // Below are classes that derives from G4H << 
524     // The names are the same as before Geant4 << 
525     // Classes that use it: G4HadronStoppingPr << 
526                                                << 
527     // Class: G4HadronicAbsorptionBertini      << 
528     InsertModel( 26000, "model_hBertiniCapture << 
529     InsertModel( 26001, "model_hBertiniCapture << 
530     InsertModel( 26002, "model_hBertiniCapture << 
531     // Class: G4HadronicAbsorptionFritiof      << 
532     InsertModel( 26010, "model_hFritiofCapture << 
533     InsertModel( 26011, "model_hFritiofCapture << 
534     InsertModel( 26012, "model_hFritiofCapture << 
535     // Class: G4HadronicAbsorptionFritiofWithB << 
536     InsertModel( 26020, "model_hFritiofWithBin << 
537     InsertModel( 26021, "model_hFritiofWithBin << 
538     InsertModel( 26022, "model_hFritiofWithBin << 
539     // Class: G4MuonMinusCapture               << 
540     InsertModel( 26030, "model_muMinusCaptureA << 
541     InsertModel( 26031, "model_muMinusCaptureA << 
542     InsertModel( 26032, "model_muMinusCaptureA << 
543                                                << 
544     // --- Fission : 26'100 - 26'199 ---       << 
545                                                << 
546     // Class G4LFission                        << 
547     InsertModel( 26100, "model_G4LFission" );  << 
548                                                << 
549     // LLNL fission (related classes: G4Fissio << 
550     InsertModel( 26110, "model_G4LLNLFission"  << 
551                                                << 
552     // --- Abration : 26'200 - 26'299 ---      << 
553                                                << 
554     // Class G4WilsonAbrasionModel             << 
555     InsertModel( 26200, "model_G4WilsonAbrasio << 
556                                                << 
557     // --- Coalescence : 26'300 - 26'399 ---   << 
558                                                << 
559     // Class G4CRCoalescence                   << 
560     InsertModel( 26300, "model_G4CRCoalescence << 
561                                                << 
562     // ======================================= << 
563     // === 3rd OTHER (i.e. non-EM and non-HAD) << 
564     // ======================================= << 
565                                                << 
566     // -------------------------------         << 
567     // --- Biasing : 30'000-30'999 ---         << 
568     // -------------------------------         << 
569                                                << 
570     // The name is the same as before Geant4 1 << 
571     // Classes that use it: G4BOptrForceCollis << 
572     InsertModel( 30010, "model_GenBiasForceCol << 
573                                                << 
574     // ----------------------------------      << 
575     // --- Channeling : 31'000-31'999 ---      << 
576     // ----------------------------------      << 
577                                                << 
578     // The name is the same as before Geant4 1 << 
579     // Classes that use it: G4Channeling , G4C << 
580     InsertModel( 31010, "model_channeling" );  << 
581                                                << 
582     // --- Others ... ---                      << 
583                                                << 
584     // ======================================= << 
585     // ================== 4th MODELS ADDED AFT << 
586     // ======================================= << 
587     // PLEASE ADD MODELS ONLY BELOW HERE, WITH << 
588     // IF YOU ARE NOT SURE, PLEASE CONTACT ONE << 
589     // GEANT4 PHYSICS WORKING GROUPS.          << 
590                                                << 
591     // Class: G4HadronicAbsorptionINCLXX       << 
592     InsertModel( 26040, "model_hINCLXXCaptureA << 
593     InsertModel( 26041, "model_hINCLXXCaptureA << 
594     InsertModel( 26042, "model_hINCLXXCaptureA << 
595                                                << 
596     // Class: G4LightIonQMDReaction            << 
597     InsertModel( 23310, "model_LightIonQMDMode << 
598                                                << 
599     // Class: G4NuDEXEvaporation (to be added  << 
600     // InsertModel( 24700, "model_nuDEX_evapor << 
601                                                << 
602     // Class: G4NuDEXNeutronCapture            << 
603     InsertModel( 25300, "model_nuDEX_neutronCa << 
604                                                << 
605     // ...                                     << 
606                                                << 
607     SanityCheck();                             << 
608     isInitialized = true;                      << 
609                                                << 
610     // The following call is commented out bec << 
611     // the verbosity level, but this would imp << 
612     // category to other categories which is n << 
613     // Anyhow, the call  G4PhysicsModelCatalog << 
614     // can be easily placed elsewhere (in eith << 
615     // Geant4 classes).                        << 
616     //PrintAllInformation();                   << 
617   }                                            << 
618 }                                              << 
619                                                    37 
620 // ------------------------------------------- <<  38 G4PhysicsModelCatalog::G4PhysicsModelCatalog()
621 void G4PhysicsModelCatalog::SanityCheck() {    <<  39 { if(!catalog) { 
622   if ( theVectorOfModelIDs->size() != theVecto <<  40     static modelCatalog catal;
623     G4ExceptionDescription ed;                 <<  41     catalog = &catal; 
624     ed << "theVectorOfModelIDs' size=" << theV <<  42   } 
625        << " is NOT the same as theVectorOfMode << 
626     G4Exception( "G4PhysicsModelCatalog::Sanit << 
627      FatalException, ed, "should be the same!" << 
628   } else {                                     << 
629     G4bool isModelIDOutsideRange = false;      << 
630     G4bool isModelIDRepeated = false;          << 
631     G4bool isModelNameRepeated = false;        << 
632     for ( int idx = 0; idx < Entries(); ++idx  << 
633       G4int modelID = (*theVectorOfModelIDs)[  << 
634       G4String modelName = (*theVectorOfModelN << 
635       if ( modelID < GetMinAllowedModelIDValue << 
636   isModelIDOutsideRange = true;                << 
637       }                                        << 
638       for ( int jdx = idx + 1; jdx < Entries() << 
639         if(modelID == (*theVectorOfModelIDs)[j << 
640         {                                      << 
641           isModelIDRepeated = true;            << 
642         }                                      << 
643         if(modelName == (*theVectorOfModelName << 
644         {                                      << 
645           isModelNameRepeated = true;          << 
646         }                                      << 
647       }                                        << 
648     }                                          << 
649     if ( isModelIDOutsideRange || isModelIDRep << 
650       G4ExceptionDescription ed;               << 
651       if(isModelIDOutsideRange)                << 
652       {                                        << 
653         ed << "theVectorOfModelIDs has NOT all << 
654            << GetMinAllowedModelIDValue() << " << 
655            << GetMaxAllowedModelIDValue();     << 
656       }                                        << 
657       if(isModelIDRepeated)                    << 
658       {                                        << 
659         ed << "theVectorOfModelIDs has NOT all << 
660       }                                        << 
661       if(isModelNameRepeated)                  << 
662       {                                        << 
663         ed << "theVectorOfModelNames has NOT a << 
664       }                                        << 
665       G4Exception( "G4PhysicsModelCatalog::San << 
666        FatalException, ed, "cannot continue!"  << 
667     }                                          << 
668   }                                            << 
669   return;                                      << 
670 }                                                  43 }
671                                                    44 
672 // ------------------------------------------- <<  45 G4PhysicsModelCatalog::~G4PhysicsModelCatalog()
                                                   >>  46 {}
                                                   >>  47 //{ delete catalog; catalog = 0; }
673                                                    48 
674 // ------------------------------------------- <<  49 G4int G4PhysicsModelCatalog::Register(const G4String& name)
675 const G4String G4PhysicsModelCatalog::GetModel <<  50 {
676   G4String modelName = "Undefined";            <<  51   G4PhysicsModelCatalog();
677   if ( modelID >= GetMinAllowedModelIDValue()  <<  52   G4int idx = GetIndex(name);
678     for ( int idx = 0; idx < Entries(); ++idx  <<  53   if(idx>=0) return idx;
679       if ( (*theVectorOfModelIDs)[ idx ] == mo <<  54 #ifdef G4MULTITHREADED
680   modelName = (*theVectorOfModelNames)[ idx ]; <<  55   if(G4Threading::IsWorkerThread()) return -1;
681   break;                                       <<  56 #endif
682       }                                        <<  57   catalog->push_back(name);
683     }                                          <<  58   return catalog->size()-1;
684   }                                            << 
685   return modelName;                            << 
686 }                                                  59 }
687                                                    60 
688 // ------------------------------------------- <<  61 const G4String& G4PhysicsModelCatalog::GetModelName(G4int idx) 
689 const G4String G4PhysicsModelCatalog::GetModel <<  62 {
690   return ( modelIndex >= 0  &&  modelIndex < E <<  63   static const G4String undef = "Undefined";
691        ? (*theVectorOfModelNames)[ modelIndex  <<  64   if(idx>=0 && idx<Entries()) return (*catalog)[idx];
                                                   >>  65   return undef;
692 }                                                  66 }
693                                                    67 
694 // ------------------------------------------- <<  68 G4int G4PhysicsModelCatalog::GetIndex(const G4String& name) 
695 G4int G4PhysicsModelCatalog::GetModelID( const <<  69 {
696   return ( modelIndex >= 0  &&  modelIndex < E <<  70   for(G4int idx=0;idx<Entries();++idx)
697        ? (*theVectorOfModelIDs)[ modelIndex ]  <<  71   { if((*catalog)[idx]==name) return idx; }
                                                   >>  72   return -1;
698 }                                                  73 }
699                                                    74 
700 // ------------------------------------------- <<  75 G4int G4PhysicsModelCatalog::Entries() 
701 G4int G4PhysicsModelCatalog::GetModelID( const <<  76 { return (catalog) ? G4int(catalog->size()) : -1; }
702   if(!isInitialized)                           << 
703   {                                            << 
704     Initialize();                              << 
705   }                                            << 
706   G4int modelID = -1;                          << 
707   for ( G4int idx = 0; idx < Entries(); ++idx  << 
708     if ( (*theVectorOfModelNames)[ idx ] == mo << 
709       modelID = (*theVectorOfModelIDs)[ idx ]; << 
710       break;                                   << 
711     }                                          << 
712   }                                            << 
713   return modelID;                              << 
714 }                                              << 
715                                                    77 
716 // ------------------------------------------- <<  78 void G4PhysicsModelCatalog::Destroy()
717 G4int G4PhysicsModelCatalog::GetModelIndex( co <<  79 {}
718   G4int modelIndex = -1;                       << 
719   if ( modelID >= GetMinAllowedModelIDValue()  << 
720     for ( G4int idx = 0; idx < Entries(); ++id << 
721       if ( (*theVectorOfModelIDs)[ idx ] == mo << 
722   modelIndex = idx;                            << 
723   break;                                       << 
724       }                                        << 
725     }                                          << 
726   }                                            << 
727   return modelIndex;                           << 
728 }                                              << 
729                                                    80 
730 // ------------------------------------------- << 
731 G4int G4PhysicsModelCatalog::GetModelIndex( co << 
732   G4int modelIndex = -1;                       << 
733   for ( G4int idx = 0; idx < Entries(); ++idx  << 
734     if ( (*theVectorOfModelNames)[ idx ] == mo << 
735       modelIndex = idx;                        << 
736       break;                                   << 
737     }                                          << 
738   }                                            << 
739   return modelIndex;                           << 
740 }                                              << 
741                                                << 
742 // ------------------------------------------- << 
743 G4int G4PhysicsModelCatalog::Entries() {       << 
744   // It is enough to check the size of one of  << 
745   return ( theVectorOfModelIDs != nullptr ) ?  << 
746 }                                              << 
747                                                << 
748 // ------------------------------------------- << 
749 void G4PhysicsModelCatalog::PrintAllInformatio << 
750   G4cout << G4endl                             << 
751    << " ====================================== << 
752    << " === G4PhysicsModelCatalog::PrintAllInf << 
753    << " ====================================== << 
754    << " SIZE (i.e. number of models in the cat << 
755   for ( int idx = 0; idx < Entries(); ++idx )  << 
756     G4int modelID = (*theVectorOfModelIDs)[ id << 
757     G4String modelName = (*theVectorOfModelNam << 
758     G4cout << "\t index=" << idx << "\t modelN << 
759      << "\t modelID=" << modelID << G4endl;    << 
760   }                                            << 
761   G4cout << " ================================ << 
762    << " ====================================== << 
763    << " ====================================== << 
764    << G4endl;                                  << 
765 }                                              << 
766                                                    81