source: trunk/examples/advanced/Tiara/source/tiara/src/TiaraPhysicsList.cc @ 1002

Last change on this file since 1002 was 807, checked in by garnier, 16 years ago

update
File size: 26.3 KB
Line 
1//
2// ********************************************************************
3// * License and Disclaimer                                           *
4// *                                                                  *
5// * The  Geant4 software  is  copyright of the Copyright Holders  of *
6// * the Geant4 Collaboration.  It is provided  under  the terms  and *
7// * conditions of the Geant4 Software License,  included in the file *
8// * LICENSE and available at  http://cern.ch/geant4/license .  These *
9// * include a list of copyright holders.                             *
10// *                                                                  *
11// * Neither the authors of this software system, nor their employing *
12// * institutes,nor the agencies providing financial support for this *
13// * work  make  any representation or  warranty, express or implied, *
14// * regarding  this  software system or assume any liability for its *
15// * use.  Please see the license in the file  LICENSE  and URL above *
16// * for the full disclaimer and the limitation of liability.         *
17// *                                                                  *
18// * This  code  implementation is the result of  the  scientific and *
19// * technical work of the GEANT4 collaboration.                      *
20// * By using,  copying,  modifying or  distributing the software (or *
21// * any work based  on the software)  you  agree  to acknowledge its *
22// * use  in  resulting  scientific  publications,  and indicate your *
23// * acceptance of all terms of the Geant4 Software license.          *
24// ********************************************************************
25//
26//
27// $Id: TiaraPhysicsList.cc,v 1.6 2006/06/29 15:45:20 gunter Exp $
28// GEANT4 tag $Name:  $
29//
30
31#include "globals.hh"
32#include <iomanip>                
33
34#include "TiaraPhysicsList.hh"
35#include "G4ParticleDefinition.hh"
36#include "G4ParticleWithCuts.hh"
37#include "G4ProcessManager.hh"
38#include "G4ProcessVector.hh"
39#include "G4ParticleTypes.hh"
40#include "G4ParticleTable.hh"
41#include "G4BosonConstructor.hh"
42#include "G4LeptonConstructor.hh"
43#include "G4MesonConstructor.hh"
44#include "G4BaryonConstructor.hh"
45#include "G4IonConstructor.hh"
46#include "G4ShortLivedConstructor.hh"
47#include "G4Material.hh"
48#include "G4MaterialTable.hh"
49
50TiaraPhysicsList::TiaraPhysicsList() : G4VUserPhysicsList()
51{
52  SetVerboseLevel(1);
53}
54
55TiaraPhysicsList::~TiaraPhysicsList()
56{}
57
58void TiaraPhysicsList::ConstructParticle()
59{
60  // In this method, static member functions should be called
61  // for all particles which you want to use.
62  // This ensures that objects of these particle types will be
63  // created in the program.
64
65  ConstructAllBosons();
66  ConstructAllLeptons();
67  ConstructAllMesons();
68  ConstructAllBaryons();
69  ConstructAllIons();
70  ConstructAllShortLiveds();
71}
72
73void TiaraPhysicsList::ConstructAllBosons()
74{
75  // Construct all bosons
76  G4BosonConstructor pConstructor;
77  pConstructor.ConstructParticle();
78}
79
80void TiaraPhysicsList::ConstructAllLeptons()
81{
82  // Construct all leptons
83  G4LeptonConstructor pConstructor;
84  pConstructor.ConstructParticle();
85}
86
87void TiaraPhysicsList::ConstructAllMesons()
88{
89  //  Construct all mesons
90  G4MesonConstructor pConstructor;
91  pConstructor.ConstructParticle();
92}
93
94void TiaraPhysicsList::ConstructAllBaryons()
95{
96  //  Construct all barions
97  G4BaryonConstructor pConstructor;
98  pConstructor.ConstructParticle();
99}
100
101void TiaraPhysicsList::ConstructAllIons()
102{
103  //  Construct light ions
104  G4IonConstructor pConstructor;
105  pConstructor.ConstructParticle(); 
106}
107
108void TiaraPhysicsList::ConstructAllShortLiveds()
109{
110  //  Construct  resonaces and quarks
111  G4ShortLivedConstructor pConstructor;
112  pConstructor.ConstructParticle(); 
113}
114
115void TiaraPhysicsList::ConstructProcess()
116{
117  AddTransportation();
118  ConstructEM();
119  ConstructLeptHad();
120  ConstructHad();
121  ConstructGeneral();
122}
123
124#include "G4ComptonScattering.hh"
125#include "G4GammaConversion.hh"
126#include "G4PhotoElectricEffect.hh"
127
128#include "G4MultipleScattering.hh"
129
130#include "G4eIonisation.hh"
131#include "G4eBremsstrahlung.hh"
132#include "G4eplusAnnihilation.hh"
133
134#include "G4MuIonisation.hh"
135#include "G4MuBremsstrahlung.hh"
136#include "G4MuPairProduction.hh"
137
138#include "G4hIonisation.hh"
139#include "G4ionIonisation.hh"
140
141void TiaraPhysicsList::ConstructEM()
142{
143  theParticleIterator->reset();
144  while( (*theParticleIterator)() ){
145    G4ParticleDefinition* particle = theParticleIterator->value();
146    G4ProcessManager* pmanager = particle->GetProcessManager();
147    G4String particleName = particle->GetParticleName();
148     
149    if (particleName == "gamma") {
150    // gamma
151      // Construct processes for gamma
152      pmanager->AddDiscreteProcess(new G4GammaConversion());
153      pmanager->AddDiscreteProcess(new G4ComptonScattering());     
154      pmanager->AddDiscreteProcess(new G4PhotoElectricEffect());
155
156    } else if (particleName == "e-") {
157    //electron
158      // Construct processes for electron
159      pmanager->AddProcess(new G4MultipleScattering(),-1,1,1);
160      pmanager->AddProcess(new G4eIonisation(),-1,2,2);
161      pmanager->AddProcess(new G4eBremsstrahlung(),-1,-1,3);
162 
163    } else if (particleName == "e+") {
164    //positron
165      // Construct processes for positron
166     pmanager->AddProcess(new G4MultipleScattering(),-1,1,1);
167     
168     pmanager->AddProcess(new G4eIonisation(),-1,2,2);
169     pmanager->AddProcess(new G4eBremsstrahlung(),-1,-1,3);     
170     pmanager->AddProcess(new G4eplusAnnihilation(),0,-1,4);
171 
172    } else if( particleName == "mu+" || 
173               particleName == "mu-"    ) {
174    //muon 
175     // Construct processes for muon+
176     pmanager->AddProcess(new G4MultipleScattering(),-1,1,1);
177     pmanager->AddProcess(new G4MuIonisation(),-1,2,2);
178     pmanager->AddProcess(new G4MuBremsstrahlung(),-1,-1,3);
179     pmanager->AddProcess(new G4MuPairProduction(),-1,-1,4);       
180     
181    } else if( particleName == "GenericIon" ) {
182      pmanager->AddProcess(new G4MultipleScattering(),-1,1,1);
183      pmanager->AddProcess(new G4ionIonisation(),-1,2,2); 
184    } else { 
185      if ((particle->GetPDGCharge() != 0.0) && 
186          (particle->GetParticleName() != "chargedgeantino")&&
187          (!particle->IsShortLived()) ) {
188     // all others charged particles except geantino
189       pmanager->AddProcess(new G4MultipleScattering(),-1,1,1);
190       pmanager->AddProcess(new G4hIonisation(),-1,2,2);       
191     }
192    }
193  }
194}
195
196// Hadron Processes
197
198#include "G4HadronElasticProcess.hh"
199#include "G4HadronFissionProcess.hh"
200#include "G4HadronCaptureProcess.hh"
201
202#include "G4PionPlusInelasticProcess.hh"
203#include "G4PionMinusInelasticProcess.hh"
204#include "G4KaonPlusInelasticProcess.hh"
205#include "G4KaonZeroSInelasticProcess.hh"
206#include "G4KaonZeroLInelasticProcess.hh"
207#include "G4KaonMinusInelasticProcess.hh"
208#include "G4ProtonInelasticProcess.hh"
209#include "G4AntiProtonInelasticProcess.hh"
210#include "G4NeutronInelasticProcess.hh"
211#include "G4AntiNeutronInelasticProcess.hh"
212#include "G4LambdaInelasticProcess.hh"
213#include "G4AntiLambdaInelasticProcess.hh"
214#include "G4SigmaPlusInelasticProcess.hh"
215#include "G4SigmaMinusInelasticProcess.hh"
216#include "G4AntiSigmaPlusInelasticProcess.hh"
217#include "G4AntiSigmaMinusInelasticProcess.hh"
218#include "G4XiZeroInelasticProcess.hh"
219#include "G4XiMinusInelasticProcess.hh"
220#include "G4AntiXiZeroInelasticProcess.hh"
221#include "G4AntiXiMinusInelasticProcess.hh"
222#include "G4DeuteronInelasticProcess.hh"
223#include "G4TritonInelasticProcess.hh"
224#include "G4AlphaInelasticProcess.hh"
225#include "G4OmegaMinusInelasticProcess.hh"
226#include "G4AntiOmegaMinusInelasticProcess.hh"
227
228// Low-energy Models
229
230#include "G4LElastic.hh"
231#include "G4LFission.hh"
232#include "G4LCapture.hh"
233
234#include "G4LEPionPlusInelastic.hh"
235#include "G4LEPionMinusInelastic.hh"
236#include "G4LEKaonPlusInelastic.hh"
237#include "G4LEKaonZeroSInelastic.hh"
238#include "G4LEKaonZeroLInelastic.hh"
239#include "G4LEKaonMinusInelastic.hh"
240#include "G4LEProtonInelastic.hh"
241#include "G4LEAntiProtonInelastic.hh"
242#include "G4LENeutronInelastic.hh"
243#include "G4LEAntiNeutronInelastic.hh"
244#include "G4LELambdaInelastic.hh"
245#include "G4LEAntiLambdaInelastic.hh"
246#include "G4LESigmaPlusInelastic.hh"
247#include "G4LESigmaMinusInelastic.hh"
248#include "G4LEAntiSigmaPlusInelastic.hh"
249#include "G4LEAntiSigmaMinusInelastic.hh"
250#include "G4LEXiZeroInelastic.hh"
251#include "G4LEXiMinusInelastic.hh"
252#include "G4LEAntiXiZeroInelastic.hh"
253#include "G4LEAntiXiMinusInelastic.hh"
254#include "G4LEDeuteronInelastic.hh"
255#include "G4LETritonInelastic.hh"
256#include "G4LEAlphaInelastic.hh"
257#include "G4LEOmegaMinusInelastic.hh"
258#include "G4LEAntiOmegaMinusInelastic.hh"
259
260// -- generator models
261#include "G4TheoFSGenerator.hh"
262#include "G4ExcitationHandler.hh"
263#include "G4Evaporation.hh"
264#include "G4CompetitiveFission.hh"
265#include "G4FermiBreakUp.hh"
266#include "G4StatMF.hh"
267#include "G4GeneratorPrecompoundInterface.hh"
268#include "G4Fancy3DNucleus.hh"
269#include "G4LEProtonInelastic.hh"
270#include "G4StringModel.hh"
271#include "G4PreCompoundModel.hh"
272#include "G4FTFModel.hh"
273#include "G4QGSMFragmentation.hh"
274#include "G4ExcitedStringDecay.hh"
275
276//
277// ConstructHad()
278//
279// Makes discrete physics processes for the hadrons, at present limited
280// to those particles with GHEISHA interactions (INTRC > 0).
281// The processes are: Elastic scattering, Inelastic scattering,
282// Fission (for neutron only), and Capture (neutron).
283//
284// F.W.Jones  06-JUL-1998
285//
286
287void TiaraPhysicsList::ConstructHad()
288{
289    // this will be the model class for high energies
290    G4TheoFSGenerator * theTheoModel = new G4TheoFSGenerator;
291       
292    // all models for treatment of thermal nucleus
293    G4Evaporation * theEvaporation = new G4Evaporation;
294    G4FermiBreakUp * theFermiBreakUp = new G4FermiBreakUp;
295    G4StatMF * theMF = new G4StatMF;
296
297    // Evaporation logic
298    G4ExcitationHandler * theHandler = new G4ExcitationHandler;
299        theHandler->SetEvaporation(theEvaporation);
300        theHandler->SetFermiModel(theFermiBreakUp);
301        theHandler->SetMultiFragmentation(theMF);
302        theHandler->SetMaxAandZForFermiBreakUp(12, 6);
303        theHandler->SetMinEForMultiFrag(3*MeV);
304       
305    // Pre equilibrium stage
306    G4PreCompoundModel * thePreEquilib = new G4PreCompoundModel(theHandler);
307
308   
309    // a no-cascade generator-precompound interaface
310    G4GeneratorPrecompoundInterface * theCascade = new G4GeneratorPrecompoundInterface;
311            theCascade->SetDeExcitation(thePreEquilib); 
312       
313    // here come the high energy parts
314    // the string model; still not quite according to design - Explicite use of the forseen interfaces
315    // will be tested and documented in this program by beta-02 at latest.
316    G4VPartonStringModel * theStringModel;
317    theStringModel = new G4FTFModel;
318    theTheoModel->SetTransport(theCascade);
319    theTheoModel->SetHighEnergyGenerator(theStringModel);
320    theTheoModel->SetMinEnergy(19*GeV);
321    theTheoModel->SetMaxEnergy(100*TeV);
322
323      G4VLongitudinalStringDecay * theFragmentation = new G4QGSMFragmentation;
324      G4ExcitedStringDecay * theStringDecay = new G4ExcitedStringDecay(theFragmentation);
325      theStringModel->SetFragmentationModel(theStringDecay);
326
327// done with the generator model (most of the above is also available as default)
328   G4HadronElasticProcess* theElasticProcess = 
329                                    new G4HadronElasticProcess;
330   G4LElastic* theElasticModel = new G4LElastic;
331   theElasticProcess->RegisterMe(theElasticModel);
332   G4HadronElasticProcess* theElasticProcess1 = 
333                                    new G4HadronElasticProcess;
334   theParticleIterator->reset();
335   while ((*theParticleIterator)()) {
336      G4ParticleDefinition* particle = theParticleIterator->value();
337      G4ProcessManager* pmanager = particle->GetProcessManager();
338      G4String particleName = particle->GetParticleName();
339     
340      if (particleName == "pi+") {
341         pmanager->AddDiscreteProcess(theElasticProcess);
342         G4PionPlusInelasticProcess* theInelasticProcess = 
343                                new G4PionPlusInelasticProcess("inelastic");
344         G4LEPionPlusInelastic* theInelasticModel = 
345                                new G4LEPionPlusInelastic;
346         theInelasticProcess->RegisterMe(theInelasticModel);
347         theInelasticProcess->RegisterMe(theTheoModel);
348         pmanager->AddDiscreteProcess(theInelasticProcess);
349      }
350      else if (particleName == "pi-") {
351         pmanager->AddDiscreteProcess(theElasticProcess);
352         G4PionMinusInelasticProcess* theInelasticProcess = 
353                                new G4PionMinusInelasticProcess("inelastic");
354         G4LEPionMinusInelastic* theInelasticModel = 
355                                new G4LEPionMinusInelastic;
356         theInelasticProcess->RegisterMe(theInelasticModel);
357         theInelasticProcess->RegisterMe(theTheoModel);
358         pmanager->AddDiscreteProcess(theInelasticProcess);
359      }
360      else if (particleName == "kaon+") {
361         pmanager->AddDiscreteProcess(theElasticProcess);
362         G4KaonPlusInelasticProcess* theInelasticProcess = 
363                                  new G4KaonPlusInelasticProcess("inelastic");
364         G4LEKaonPlusInelastic* theInelasticModel = new G4LEKaonPlusInelastic;
365         theInelasticProcess->RegisterMe(theInelasticModel);
366         theInelasticProcess->RegisterMe(theTheoModel);
367         pmanager->AddDiscreteProcess(theInelasticProcess);
368      }
369      else if (particleName == "kaon0S") {
370         pmanager->AddDiscreteProcess(theElasticProcess);
371         G4KaonZeroSInelasticProcess* theInelasticProcess = 
372                             new G4KaonZeroSInelasticProcess("inelastic");
373         G4LEKaonZeroSInelastic* theInelasticModel = 
374                             new G4LEKaonZeroSInelastic;
375         theInelasticProcess->RegisterMe(theInelasticModel);
376         theInelasticProcess->RegisterMe(theTheoModel);
377         pmanager->AddDiscreteProcess(theInelasticProcess);
378      }
379      else if (particleName == "kaon0L") {
380         pmanager->AddDiscreteProcess(theElasticProcess);
381         G4KaonZeroLInelasticProcess* theInelasticProcess = 
382                             new G4KaonZeroLInelasticProcess("inelastic");
383         G4LEKaonZeroLInelastic* theInelasticModel = 
384                             new G4LEKaonZeroLInelastic;
385         theInelasticProcess->RegisterMe(theInelasticModel);
386         theInelasticProcess->RegisterMe(theTheoModel);
387         pmanager->AddDiscreteProcess(theInelasticProcess);
388      }
389      else if (particleName == "kaon-") {
390         pmanager->AddDiscreteProcess(theElasticProcess);
391         G4KaonMinusInelasticProcess* theInelasticProcess = 
392                                 new G4KaonMinusInelasticProcess("inelastic");
393         G4LEKaonMinusInelastic* theInelasticModel = 
394                                 new G4LEKaonMinusInelastic;
395         theInelasticProcess->RegisterMe(theInelasticModel);
396         theInelasticProcess->RegisterMe(theTheoModel);
397         pmanager->AddDiscreteProcess(theInelasticProcess);
398      }
399      else if (particleName == "proton") {
400         pmanager->AddDiscreteProcess(theElasticProcess);
401         G4ProtonInelasticProcess* theInelasticProcess = 
402                                    new G4ProtonInelasticProcess("inelastic");
403         G4LEProtonInelastic* theInelasticModel = new G4LEProtonInelastic;
404         theInelasticProcess->RegisterMe(theInelasticModel);
405         theInelasticProcess->RegisterMe(theTheoModel);
406         pmanager->AddDiscreteProcess(theInelasticProcess);
407      }
408      else if (particleName == "anti_proton") {
409         pmanager->AddDiscreteProcess(theElasticProcess);
410         G4AntiProtonInelasticProcess* theInelasticProcess = 
411                                new G4AntiProtonInelasticProcess("inelastic");
412         G4LEAntiProtonInelastic* theInelasticModel = 
413                                new G4LEAntiProtonInelastic;
414         theInelasticProcess->RegisterMe(theInelasticModel);
415         theInelasticProcess->RegisterMe(theTheoModel);
416         pmanager->AddDiscreteProcess(theInelasticProcess);
417      }
418      else if (particleName == "neutron") {
419         
420          // elastic scattering
421         G4LElastic* theElasticModel1 = new G4LElastic;
422         theElasticProcess1->RegisterMe(theElasticModel1);
423         pmanager->AddDiscreteProcess(theElasticProcess1);
424          // inelastic scattering
425         G4NeutronInelasticProcess* theInelasticProcess = 
426                                    new G4NeutronInelasticProcess("inelastic");
427         G4LENeutronInelastic* theInelasticModel = new G4LENeutronInelastic;
428         theInelasticProcess->RegisterMe(theInelasticModel);
429         theInelasticProcess->RegisterMe(theTheoModel);
430         pmanager->AddDiscreteProcess(theInelasticProcess);
431          // fission
432         G4HadronFissionProcess* theFissionProcess =
433                                    new G4HadronFissionProcess;
434         G4LFission* theFissionModel = new G4LFission;
435         theFissionProcess->RegisterMe(theFissionModel);
436         pmanager->AddDiscreteProcess(theFissionProcess);
437         // capture
438         G4HadronCaptureProcess* theCaptureProcess =
439                                    new G4HadronCaptureProcess;
440         G4LCapture* theCaptureModel = new G4LCapture;
441         theCaptureProcess->RegisterMe(theCaptureModel);
442         pmanager->AddDiscreteProcess(theCaptureProcess);
443      } 
444      else if (particleName == "anti_neutron") {
445         pmanager->AddDiscreteProcess(theElasticProcess);
446         G4AntiNeutronInelasticProcess* theInelasticProcess = 
447                               new G4AntiNeutronInelasticProcess("inelastic");
448         G4LEAntiNeutronInelastic* theInelasticModel = 
449                               new G4LEAntiNeutronInelastic;
450         theInelasticProcess->RegisterMe(theInelasticModel);
451         theInelasticProcess->RegisterMe(theTheoModel);
452         pmanager->AddDiscreteProcess(theInelasticProcess);
453      }
454      else if (particleName == "lambda") {
455         pmanager->AddDiscreteProcess(theElasticProcess);
456         G4LambdaInelasticProcess* theInelasticProcess = 
457                                    new G4LambdaInelasticProcess("inelastic");
458         G4LELambdaInelastic* theInelasticModel = new G4LELambdaInelastic;
459         theInelasticProcess->RegisterMe(theInelasticModel);
460         theInelasticProcess->RegisterMe(theTheoModel);
461         pmanager->AddDiscreteProcess(theInelasticProcess);
462      }
463      else if (particleName == "anti_lambda") {
464         pmanager->AddDiscreteProcess(theElasticProcess);
465         G4AntiLambdaInelasticProcess* theInelasticProcess = 
466                                new G4AntiLambdaInelasticProcess("inelastic");
467         G4LEAntiLambdaInelastic* theInelasticModel = 
468                                new G4LEAntiLambdaInelastic;
469         theInelasticProcess->RegisterMe(theInelasticModel);
470         theInelasticProcess->RegisterMe(theTheoModel);
471         pmanager->AddDiscreteProcess(theInelasticProcess);
472      }
473      else if (particleName == "sigma+") {
474         pmanager->AddDiscreteProcess(theElasticProcess);
475         G4SigmaPlusInelasticProcess* theInelasticProcess = 
476                                 new G4SigmaPlusInelasticProcess("inelastic");
477         G4LESigmaPlusInelastic* theInelasticModel = 
478                                 new G4LESigmaPlusInelastic;
479         theInelasticProcess->RegisterMe(theInelasticModel);
480         theInelasticProcess->RegisterMe(theTheoModel);
481         pmanager->AddDiscreteProcess(theInelasticProcess);
482      }
483      else if (particleName == "sigma-") {
484         pmanager->AddDiscreteProcess(theElasticProcess);
485         G4SigmaMinusInelasticProcess* theInelasticProcess = 
486                                 new G4SigmaMinusInelasticProcess("inelastic");
487         G4LESigmaMinusInelastic* theInelasticModel = 
488                                 new G4LESigmaMinusInelastic;
489         theInelasticProcess->RegisterMe(theInelasticModel);
490         theInelasticProcess->RegisterMe(theTheoModel);
491         pmanager->AddDiscreteProcess(theInelasticProcess);
492      }
493      else if (particleName == "anti_sigma+") {
494         pmanager->AddDiscreteProcess(theElasticProcess);
495         G4AntiSigmaPlusInelasticProcess* theInelasticProcess = 
496                             new G4AntiSigmaPlusInelasticProcess("inelastic");
497         G4LEAntiSigmaPlusInelastic* theInelasticModel = 
498                                 new G4LEAntiSigmaPlusInelastic;
499         theInelasticProcess->RegisterMe(theInelasticModel);
500         theInelasticProcess->RegisterMe(theTheoModel);
501         pmanager->AddDiscreteProcess(theInelasticProcess);
502      }
503      else if (particleName == "anti_sigma-") {
504         pmanager->AddDiscreteProcess(theElasticProcess);
505         G4AntiSigmaMinusInelasticProcess* theInelasticProcess = 
506                            new G4AntiSigmaMinusInelasticProcess("inelastic");
507         G4LEAntiSigmaMinusInelastic* theInelasticModel = 
508                                 new G4LEAntiSigmaMinusInelastic;
509         theInelasticProcess->RegisterMe(theInelasticModel);
510         theInelasticProcess->RegisterMe(theTheoModel);
511         pmanager->AddDiscreteProcess(theInelasticProcess);
512      }
513      else if (particleName == "xi0") {
514         pmanager->AddDiscreteProcess(theElasticProcess);
515         G4XiZeroInelasticProcess* theInelasticProcess = 
516                            new G4XiZeroInelasticProcess("inelastic");
517         G4LEXiZeroInelastic* theInelasticModel = 
518                                 new G4LEXiZeroInelastic;
519         theInelasticProcess->RegisterMe(theInelasticModel);
520         theInelasticProcess->RegisterMe(theTheoModel);
521         pmanager->AddDiscreteProcess(theInelasticProcess);
522      }
523      else if (particleName == "xi-") {
524         pmanager->AddDiscreteProcess(theElasticProcess);
525         G4XiMinusInelasticProcess* theInelasticProcess = 
526                            new G4XiMinusInelasticProcess("inelastic");
527         G4LEXiMinusInelastic* theInelasticModel = 
528                                 new G4LEXiMinusInelastic;
529         theInelasticProcess->RegisterMe(theInelasticModel);
530         theInelasticProcess->RegisterMe(theTheoModel);
531         pmanager->AddDiscreteProcess(theInelasticProcess);
532      }
533      else if (particleName == "anti_xi0") {
534         pmanager->AddDiscreteProcess(theElasticProcess);
535         G4AntiXiZeroInelasticProcess* theInelasticProcess = 
536                            new G4AntiXiZeroInelasticProcess("inelastic");
537         G4LEAntiXiZeroInelastic* theInelasticModel = 
538                                 new G4LEAntiXiZeroInelastic;
539         theInelasticProcess->RegisterMe(theInelasticModel);
540         theInelasticProcess->RegisterMe(theTheoModel);
541         pmanager->AddDiscreteProcess(theInelasticProcess);
542      }
543      else if (particleName == "anti_xi-") {
544         pmanager->AddDiscreteProcess(theElasticProcess);
545         G4AntiXiMinusInelasticProcess* theInelasticProcess = 
546                            new G4AntiXiMinusInelasticProcess("inelastic");
547         G4LEAntiXiMinusInelastic* theInelasticModel = 
548                                 new G4LEAntiXiMinusInelastic;
549         theInelasticProcess->RegisterMe(theInelasticModel);
550         theInelasticProcess->RegisterMe(theTheoModel);
551         pmanager->AddDiscreteProcess(theInelasticProcess);
552      }
553      else if (particleName == "deuteron") {
554         pmanager->AddDiscreteProcess(theElasticProcess);
555         G4DeuteronInelasticProcess* theInelasticProcess = 
556                            new G4DeuteronInelasticProcess("inelastic");
557         G4LEDeuteronInelastic* theInelasticModel = 
558                                 new G4LEDeuteronInelastic;
559         theInelasticProcess->RegisterMe(theInelasticModel);
560         theInelasticProcess->RegisterMe(theTheoModel);
561         pmanager->AddDiscreteProcess(theInelasticProcess);
562      }
563      else if (particleName == "triton") {
564         pmanager->AddDiscreteProcess(theElasticProcess);
565         G4TritonInelasticProcess* theInelasticProcess = 
566                            new G4TritonInelasticProcess("inelastic");
567         G4LETritonInelastic* theInelasticModel = 
568                                 new G4LETritonInelastic;
569         theInelasticProcess->RegisterMe(theInelasticModel);
570         theInelasticProcess->RegisterMe(theTheoModel);
571         pmanager->AddDiscreteProcess(theInelasticProcess);
572      }
573      else if (particleName == "alpha") {
574         pmanager->AddDiscreteProcess(theElasticProcess);
575         G4AlphaInelasticProcess* theInelasticProcess = 
576                            new G4AlphaInelasticProcess("inelastic");
577         G4LEAlphaInelastic* theInelasticModel = 
578                                 new G4LEAlphaInelastic;
579         theInelasticProcess->RegisterMe(theInelasticModel);
580         theInelasticProcess->RegisterMe(theTheoModel);
581         pmanager->AddDiscreteProcess(theInelasticProcess);
582      }
583      else if (particleName == "omega-") {
584         pmanager->AddDiscreteProcess(theElasticProcess);
585         G4OmegaMinusInelasticProcess* theInelasticProcess = 
586                            new G4OmegaMinusInelasticProcess("inelastic");
587         G4LEOmegaMinusInelastic* theInelasticModel = 
588                                 new G4LEOmegaMinusInelastic;
589         theInelasticProcess->RegisterMe(theInelasticModel);
590         theInelasticProcess->RegisterMe(theTheoModel);
591         pmanager->AddDiscreteProcess(theInelasticProcess);
592      }
593      else if (particleName == "anti_omega-") {
594         pmanager->AddDiscreteProcess(theElasticProcess);
595         G4AntiOmegaMinusInelasticProcess* theInelasticProcess = 
596                            new G4AntiOmegaMinusInelasticProcess("inelastic");
597         G4LEAntiOmegaMinusInelastic* theInelasticModel = 
598                                 new G4LEAntiOmegaMinusInelastic;
599         theInelasticProcess->RegisterMe(theInelasticModel);
600         theInelasticProcess->RegisterMe(theTheoModel);
601         pmanager->AddDiscreteProcess(theInelasticProcess);
602      }
603   }
604}
605
606void TiaraPhysicsList::ConstructLeptHad()
607{;}
608
609#include "G4Decay.hh"
610void TiaraPhysicsList::ConstructGeneral()
611{
612  G4Decay* theDecayProcess = new G4Decay();
613  theParticleIterator->reset();
614  while( (*theParticleIterator)() ){
615    G4ParticleDefinition* particle = theParticleIterator->value();
616    G4ProcessManager* pmanager = particle->GetProcessManager();
617    if (theDecayProcess->IsApplicable(*particle)) { 
618      pmanager ->AddProcess(theDecayProcess);
619      pmanager ->SetProcessOrdering(theDecayProcess, idxPostStep);
620      pmanager ->SetProcessOrdering(theDecayProcess, idxAtRest);
621    }
622  }
623}
624
625void TiaraPhysicsList::SetCuts()
626{
627  if (verboseLevel >0)
628  {
629    G4cout << "TiaraPhysicsList::SetCuts:";
630    G4cout << "CutLength : " << defaultCutValue/mm << " (mm)" << G4endl;
631  } 
632  //   "G4VUserPhysicsList::SetCutsWithDefault" method sets
633  //   the default cut value for all particle types
634  SetCutsWithDefault();   
635}
Note: See TracBrowser for help on using the repository browser.