TGeant4/TG4PhysicsConstructorHadron.cxx

   1 // $Id$
   2 // Category: physics
   3 //
   4 // Author: I. Hrivnacova
   5 //
   6 // Class TG4PhysicsConstructorHadron
   7 // ---------------------------------
   8 // See the class description in the header file.
   9 // According to ExN04HadronPhysics.cc,v 1.1.2.1 2001/06/28 19:07:37 gunter Exp
  10 // GEANT4 tag Name: geant4-03-02
  11
  12 #include "TG4PhysicsConstructorHadron.h"
  13 #include "TG4ProcessControlMap.h"
  14 #include "TG4ProcessMCMap.h"
  15 #include "TG4Globals.h"
  16
  17 #include <G4ParticleDefinition.hh>
  18 #include <G4ProcessManager.hh>
  19 #include <G4MesonConstructor.hh>
  20 #include <G4BaryonConstructor.hh>
  21 #include <G4ShortLivedConstructor.hh>
  22
  23 //_____________________________________________________________________________
  24 TG4PhysicsConstructorHadron::TG4PhysicsConstructorHadron(const G4String& name)
  25   : G4VPhysicsConstructor(name)
  26 {
  27 //
  28   SetVerboseLevel(1);
  29 }
  30
  31 //_____________________________________________________________________________
  32 TG4PhysicsConstructorHadron::TG4PhysicsConstructorHadron(
  33                                      const TG4PhysicsConstructorHadron& right)
  34 {
  35 //
  36   TG4Globals::Exception("TG4PhysicsConstructorHadron is protected from copying.");
  37 }
  38
  39 //_____________________________________________________________________________
  40 TG4PhysicsConstructorHadron::~TG4PhysicsConstructorHadron() {
  41 //
  42   for (G4int i=0; i<fOtherProcesses.size(); i++) delete fOtherProcesses[i];
  43 }
  44
  45 // operators
  46
  47 //_____________________________________________________________________________
  48 TG4PhysicsConstructorHadron&
  49 TG4PhysicsConstructorHadron::operator=(const TG4PhysicsConstructorHadron &right)
  50 {
  51   // check assignement to self
  52   if (this == &right) return *this;
  53
  54   TG4Globals::Exception(
  55     "TG4PhysicsConstructorHadron is protected from assigning.");
  56
  57   return *this;
  58 }
  59
  60
  61 // private methods
  62
  63 //_____________________________________________________________________________
  64 void TG4PhysicsConstructorHadron::ConstructProcessForPionPlus()
  65 {
  66 // Construct processes for pi+.
  67 // ---
  68
  69   // add process
  70   G4ProcessManager* pManager = G4PionPlus::PionPlus()->GetProcessManager();
  71   pManager->AddDiscreteProcess(&fElasticProcess);
  72
  73   fLEPionPlusModel = new G4LEPionPlusInelastic();
  74   fHEPionPlusModel = new G4HEPionPlusInelastic();
  75   fPionPlusInelastic.RegisterMe(fLEPionPlusModel);
  76   fPionPlusInelastic.RegisterMe(fHEPionPlusModel);
  77   pManager->AddDiscreteProcess(&fPionPlusInelastic);
  78
  79   pManager->AddProcess(&fPionPlusIonisation, ordInActive, 2, 2);
  80   pManager->AddProcess(&fPionPlusMult);
  81
  82   // set ordering
  83   pManager->SetProcessOrdering(&fPionPlusMult, idxAlongStep, 1);
  84   pManager->SetProcessOrdering(&fPionPlusMult, idxPostStep, 1);
  85
  86   // map to G3 controls
  87   TG4ProcessControlMap* controlMap = TG4ProcessControlMap::Instance();
  88   controlMap->Add(&fElasticProcess, kHADR);
  89   controlMap->Add(&fPionPlusInelastic, kHADR);
  90   controlMap->Add(&fPionPlusIonisation, kLOSS);
  91   controlMap->Add(&fPionPlusMult, kMULS);
  92
  93   // map to G3 ALIMCProcess codes
  94   TG4ProcessMCMap* mcMap = TG4ProcessMCMap::Instance();
  95   mcMap->Add(&fElasticProcess, kPHElastic);
  96   mcMap->Add(&fPionPlusInelastic, kPHInhelastic);
  97   mcMap->Add(&fPionPlusIonisation, kPEnergyLoss);
  98   mcMap->Add(&fPionPlusMult, kPMultipleScattering);
  99 }
 100
 101 //_____________________________________________________________________________
 102 void TG4PhysicsConstructorHadron::ConstructProcessForPionMinus()
 103 {
 104 // Construct processes for pi-.
 105 // ---
 106
 107   // add process & set ordering
 108   G4ProcessManager* pManager = G4PionMinus::PionMinus()->GetProcessManager();
 109   pManager->AddDiscreteProcess(&fElasticProcess);
 110
 111   fLEPionMinusModel = new G4LEPionMinusInelastic();
 112   fHEPionMinusModel = new G4HEPionMinusInelastic();
 113   fPionMinusInelastic.RegisterMe(fLEPionMinusModel);
 114   fPionMinusInelastic.RegisterMe(fHEPionMinusModel);
 115   pManager->AddDiscreteProcess(&fPionMinusInelastic);
 116
 117   pManager->AddProcess(&fPionMinusIonisation, ordInActive, 2, 2);
 118
 119   pManager->AddProcess(&fPionMinusMult);
 120   pManager->SetProcessOrdering(&fPionMinusMult, idxAlongStep, 1);
 121   pManager->SetProcessOrdering(&fPionMinusMult, idxPostStep, 1);
 122
 123   pManager->AddRestProcess(&fPionMinusAbsorption, ordDefault);
 124
 125   // map to G3 controls
 126   TG4ProcessControlMap* controlMap = TG4ProcessControlMap::Instance();
 127   controlMap->Add(&fPionMinusInelastic, kHADR);
 128   controlMap->Add(&fPionMinusIonisation, kLOSS);
 129   controlMap->Add(&fPionMinusMult, kMULS);
 130   controlMap->Add(&fPionMinusAbsorption, kHADR);
 131
 132   // map to G3 ALIMCProcess codes
 133   TG4ProcessMCMap* mcMap = TG4ProcessMCMap::Instance();
 134   mcMap->Add(&fPionMinusInelastic, kPHInhelastic);
 135   mcMap->Add(&fPionMinusIonisation, kPEnergyLoss);
 136   mcMap->Add(&fPionMinusMult, kPMultipleScattering);
 137   mcMap->Add(&fPionMinusAbsorption, kPNuclearAbsorption);
 138 }
 139
 140 //_____________________________________________________________________________
 141 void TG4PhysicsConstructorHadron::ConstructProcessForKaonPlus()
 142 {
 143 // Construct processes for K+.
 144 // ---
 145
 146   // add process
 147   G4ProcessManager* pManager = G4KaonPlus::KaonPlus()->GetProcessManager();
 148   pManager->AddDiscreteProcess(&fElasticProcess);
 149
 150   fLEKaonPlusModel = new G4LEKaonPlusInelastic();
 151   fHEKaonPlusModel = new G4HEKaonPlusInelastic();
 152   fKaonPlusInelastic.RegisterMe(fLEKaonPlusModel);
 153   fKaonPlusInelastic.RegisterMe(fHEKaonPlusModel);
 154   pManager->AddDiscreteProcess(&fKaonPlusInelastic);
 155
 156   pManager->AddProcess(&fKaonPlusIonisation, ordInActive, 2, 2);
 157   pManager->AddProcess(&fKaonPlusMult);
 158
 159   // set ordering
 160   pManager->SetProcessOrdering(&fKaonPlusMult, idxAlongStep, 1);
 161   pManager->SetProcessOrdering(&fKaonPlusMult, idxPostStep, 1);
 162
 163   // map to G3 controls
 164   TG4ProcessControlMap* controlMap = TG4ProcessControlMap::Instance();
 165   controlMap->Add(&fKaonPlusInelastic, kHADR);
 166   controlMap->Add(&fKaonPlusIonisation, kLOSS);
 167   controlMap->Add(&fKaonPlusMult, kMULS);
 168
 169   // map to G3 ALIMCProcess codes
 170   TG4ProcessMCMap* mcMap = TG4ProcessMCMap::Instance();
 171   mcMap->Add(&fKaonPlusInelastic, kPHInhelastic);
 172   mcMap->Add(&fKaonPlusIonisation, kPEnergyLoss);
 173   mcMap->Add(&fKaonPlusMult, kPMultipleScattering);
 174 }
 175
 176 //_____________________________________________________________________________
 177 void TG4PhysicsConstructorHadron::ConstructProcessForKaonMinus()
 178 {
 179 // Construct processes for K-.
 180 // ---
 181
 182   // add process & set ordering
 183   G4ProcessManager* pManager = G4KaonMinus::KaonMinus()->GetProcessManager();
 184   pManager->AddDiscreteProcess(&fElasticProcess);
 185
 186   fLEKaonMinusModel = new G4LEKaonMinusInelastic();
 187   fHEKaonMinusModel = new G4HEKaonMinusInelastic();
 188   fKaonMinusInelastic.RegisterMe(fLEKaonMinusModel);
 189   fKaonMinusInelastic.RegisterMe(fHEKaonMinusModel);
 190   pManager->AddDiscreteProcess(&fKaonMinusInelastic);
 191
 192   pManager->AddProcess(&fKaonMinusIonisation, ordInActive, 2, 2);
 193
 194   pManager->AddProcess(&fKaonMinusMult);
 195   pManager->SetProcessOrdering(&fKaonMinusMult, idxAlongStep, 1);
 196   pManager->SetProcessOrdering(&fKaonMinusMult, idxPostStep, 1);
 197
 198   pManager->AddRestProcess(&fKaonMinusAbsorption, ordDefault);
 199
 200   // map to G3 controls
 201   TG4ProcessControlMap* controlMap = TG4ProcessControlMap::Instance();
 202   controlMap->Add(&fKaonMinusInelastic, kHADR);
 203   controlMap->Add(&fKaonMinusIonisation, kLOSS);
 204   controlMap->Add(&fKaonMinusMult, kMULS);
 205   controlMap->Add(&fKaonMinusAbsorption, kHADR);
 206
 207   // map to G3 ALIMCProcess codes
 208   TG4ProcessMCMap* mcMap = TG4ProcessMCMap::Instance();
 209   mcMap->Add(&fKaonMinusInelastic, kPHInhelastic);
 210   mcMap->Add(&fKaonMinusIonisation, kPEnergyLoss);
 211   mcMap->Add(&fKaonMinusMult, kPMultipleScattering);
 212   mcMap->Add(&fKaonMinusAbsorption, kPNuclearAbsorption);
 213 }
 214
 215 //_____________________________________________________________________________
 216 void TG4PhysicsConstructorHadron::ConstructProcessForKaonZeroLong()
 217 {
 218 // Construct processes for K0L.
 219 // ---
 220
 221   // add process
 222   G4ProcessManager* pManager
 223     = G4KaonZeroLong::KaonZeroLong()->GetProcessManager();
 224   pManager->AddDiscreteProcess(&fElasticProcess);
 225
 226   fLEKaonZeroLModel = new G4LEKaonZeroLInelastic();
 227   fHEKaonZeroLModel = new G4HEKaonZeroInelastic();
 228   fKaonZeroLInelastic.RegisterMe(fLEKaonZeroLModel);
 229   fKaonZeroLInelastic.RegisterMe(fHEKaonZeroLModel);
 230   pManager->AddDiscreteProcess(&fKaonZeroLInelastic);
 231
 232   // map to G3 controls
 233   TG4ProcessControlMap* controlMap = TG4ProcessControlMap::Instance();
 234   controlMap->Add(&fKaonZeroLInelastic, kHADR);
 235
 236   // map to G3 ALIMCProcess codes
 237   TG4ProcessMCMap* mcMap = TG4ProcessMCMap::Instance();
 238   mcMap->Add(&fKaonZeroLInelastic, kPHInhelastic);
 239 }
 240
 241 //_____________________________________________________________________________
 242 void TG4PhysicsConstructorHadron::ConstructProcessForKaonZeroShort()
 243 {
 244 // Construct processes for K0S.
 245 // ---
 246
 247   // add process
 248   G4ProcessManager* pManager
 249     = G4KaonZeroShort::KaonZeroShort()->GetProcessManager();
 250   pManager->AddDiscreteProcess(&fElasticProcess);
 251
 252   fLEKaonZeroSModel = new G4LEKaonZeroSInelastic();
 253   fHEKaonZeroSModel = new G4HEKaonZeroInelastic();
 254   fKaonZeroSInelastic.RegisterMe(fLEKaonZeroSModel);
 255   fKaonZeroSInelastic.RegisterMe(fHEKaonZeroSModel);
 256   pManager->AddDiscreteProcess(&fKaonZeroSInelastic);
 257
 258   // map to G3 controls
 259   TG4ProcessControlMap* controlMap = TG4ProcessControlMap::Instance();
 260   controlMap->Add(&fKaonZeroSInelastic, kHADR);
 261
 262   // map to G3 ALIMCProcess codes
 263   TG4ProcessMCMap* mcMap = TG4ProcessMCMap::Instance();
 264   mcMap->Add(&fKaonZeroSInelastic, kPHInhelastic);
 265 }
 266
 267 //_____________________________________________________________________________
 268 void TG4PhysicsConstructorHadron::ConstructProcessForProton()
 269 {
 270 // Construct processes for proton.
 271 // ---
 272
 273   // add process
 274   G4ProcessManager* pManager = G4Proton::Proton()->GetProcessManager();
 275   pManager->AddDiscreteProcess(&fElasticProcess);
 276
 277   fLEProtonModel = new G4LEProtonInelastic();
 278   fHEProtonModel = new G4HEProtonInelastic();
 279   fProtonInelastic.RegisterMe(fLEProtonModel);
 280   fProtonInelastic.RegisterMe(fHEProtonModel);
 281   pManager->AddDiscreteProcess(&fProtonInelastic);
 282
 283   pManager->AddProcess(&fProtonIonisation, ordInActive, 2, 2);
 284   pManager->AddProcess(&fProtonMult);
 285
 286   // set ordering
 287   pManager->SetProcessOrdering(&fProtonMult, idxAlongStep, 1);
 288   pManager->SetProcessOrdering(&fProtonMult, idxPostStep, 1);
 289
 290   // map to G3 controls
 291   TG4ProcessControlMap* controlMap = TG4ProcessControlMap::Instance();
 292   controlMap->Add(&fProtonInelastic, kHADR);
 293   controlMap->Add(&fProtonIonisation, kLOSS);
 294   controlMap->Add(&fProtonMult, kMULS);
 295
 296   // map to G3 ALIMCProcess codes
 297   TG4ProcessMCMap* mcMap = TG4ProcessMCMap::Instance();
 298   mcMap->Add(&fProtonInelastic, kPHInhelastic);
 299   mcMap->Add(&fProtonIonisation, kPEnergyLoss);
 300   mcMap->Add(&fProtonMult, kPMultipleScattering);
 301 }
 302
 303 //_____________________________________________________________________________
 304 void TG4PhysicsConstructorHadron::ConstructProcessForAntiProton()
 305 {
 306 // Construct processes for anti-proton.
 307 // ---
 308
 309   // add process & set ordering
 310   G4ProcessManager* pManager = G4AntiProton::AntiProton()->GetProcessManager();
 311   pManager->AddDiscreteProcess(&fElasticProcess);
 312
 313   fLEAntiProtonModel = new G4LEAntiProtonInelastic();
 314   fHEAntiProtonModel = new G4HEAntiProtonInelastic();
 315   fAntiProtonInelastic.RegisterMe(fLEAntiProtonModel);
 316   fAntiProtonInelastic.RegisterMe(fHEAntiProtonModel);
 317   pManager->AddDiscreteProcess(&fAntiProtonInelastic);
 318
 319   pManager->AddProcess(&fAntiProtonIonisation, ordInActive, 2, 2);
 320
 321   pManager->AddProcess(&fAntiProtonMult);
 322   pManager->SetProcessOrdering(&fAntiProtonMult, idxAlongStep, 1);
 323   pManager->SetProcessOrdering(&fAntiProtonMult, idxPostStep, 1);
 324
 325   pManager->AddRestProcess(&fAntiProtonAnnihilation);
 326
 327   // map to G3 controls
 328   TG4ProcessControlMap* controlMap = TG4ProcessControlMap::Instance();
 329   controlMap->Add(&fAntiProtonInelastic, kHADR);
 330   controlMap->Add(&fAntiProtonIonisation, kLOSS);
 331   controlMap->Add(&fAntiProtonMult, kMULS);
 332   controlMap->Add(&fAntiProtonAnnihilation, kHADR);
 333
 334   // map to G3 ALIMCProcess codes
 335   TG4ProcessMCMap* mcMap = TG4ProcessMCMap::Instance();
 336   mcMap->Add(&fAntiProtonInelastic, kPHInhelastic);
 337   mcMap->Add(&fAntiProtonIonisation, kPEnergyLoss);
 338   mcMap->Add(&fAntiProtonMult, kPMultipleScattering);
 339   mcMap->Add(&fAntiProtonAnnihilation, kPPbarAnnihilation);
 340 }
 341
 342 //_____________________________________________________________________________
 343 void TG4PhysicsConstructorHadron::ConstructProcessForNeutron()
 344 {
 345 // Construct processes for neutron.
 346 // ---
 347
 348   // add process
 349   G4ProcessManager* pManager = G4Neutron::Neutron()->GetProcessManager();
 350   pManager->AddDiscreteProcess(&fElasticProcess);
 351
 352   fLENeutronModel = new G4LENeutronInelastic();
 353   fHENeutronModel = new G4HENeutronInelastic();
 354   fNeutronInelastic.RegisterMe(fLENeutronModel);
 355   fNeutronInelastic.RegisterMe(fHENeutronModel);
 356   pManager->AddDiscreteProcess(&fNeutronInelastic);
 357
 358   //fNeutronFissionModel = new G4LFission();
 359   //fNeutronFission.RegisterMe(fNeutronFissionModel);
 360   //pManager->AddDiscreteProcess(&NeutronFission);
 361
 362   //fNeutronCaptureModel = new G4LCapture();
 363   //fNeutronCapture.RegisterMe(fNeutronCaptureModel);
 364   //pManager->AddDiscreteProcess(&fNeutronCapture);
 365
 366   // map to G3 controls
 367   TG4ProcessControlMap* controlMap = TG4ProcessControlMap::Instance();
 368   controlMap->Add(&fNeutronInelastic, kHADR);
 369
 370   // map to G3 ALIMCProcess codes
 371   TG4ProcessMCMap* mcMap = TG4ProcessMCMap::Instance();
 372   mcMap->Add(&fNeutronInelastic, kPHInhelastic);
 373 }
 374
 375 //_____________________________________________________________________________
 376 void TG4PhysicsConstructorHadron::ConstructProcessForAntiNeutron()
 377 {
 378 // Construct processes for anti-neutron.
 379 // ---
 380
 381   // add process
 382   G4ProcessManager* pManager = G4AntiNeutron::AntiNeutron()->GetProcessManager();
 383   pManager->AddDiscreteProcess(&fElasticProcess);
 384
 385   fLEAntiNeutronModel = new G4LEAntiNeutronInelastic();
 386   fHEAntiNeutronModel = new G4HEAntiNeutronInelastic();
 387   fAntiNeutronInelastic.RegisterMe(fLEAntiNeutronModel);
 388   fAntiNeutronInelastic.RegisterMe(fHEAntiNeutronModel);
 389   pManager->AddDiscreteProcess(&fAntiNeutronInelastic);
 390
 391   pManager->AddRestProcess(&fAntiNeutronAnnihilation);
 392
 393   // map to G3 controls
 394   TG4ProcessControlMap* controlMap = TG4ProcessControlMap::Instance();
 395   controlMap->Add(&fAntiNeutronInelastic, kHADR);
 396   controlMap->Add(&fAntiNeutronAnnihilation, kHADR);
 397
 398   // map to G3 ALIMCProcess codes
 399   TG4ProcessMCMap* mcMap = TG4ProcessMCMap::Instance();
 400   mcMap->Add(&fAntiNeutronInelastic, kPHInhelastic);
 401   mcMap->Add(&fAntiNeutronAnnihilation, kPNoProcess);
 402 }
 403
 404 //_____________________________________________________________________________
 405 void TG4PhysicsConstructorHadron::ConstructProcessForLambda()
 406 {
 407 // Construct processes for Lambda.
 408 // ---
 409
 410   // add process
 411   G4ProcessManager* pManager = G4Lambda::Lambda()->GetProcessManager();
 412   pManager->AddDiscreteProcess(&fElasticProcess);
 413
 414   fLELambdaModel = new G4LELambdaInelastic();
 415   fHELambdaModel = new G4HELambdaInelastic();
 416   fLambdaInelastic.RegisterMe(fLELambdaModel);
 417   fLambdaInelastic.RegisterMe(fHELambdaModel);
 418   pManager->AddDiscreteProcess(&fLambdaInelastic);
 419
 420   // map to G3 controls
 421   TG4ProcessControlMap* controlMap = TG4ProcessControlMap::Instance();
 422   controlMap->Add(&fLambdaInelastic, kHADR);
 423
 424   // map to G3 ALIMCProcess codes
 425   TG4ProcessMCMap* mcMap = TG4ProcessMCMap::Instance();
 426   mcMap->Add(&fLambdaInelastic, kPHInhelastic);
 427 }
 428
 429 //_____________________________________________________________________________
 430 void TG4PhysicsConstructorHadron::ConstructProcessForAntiLambda()
 431 {
 432 // Construct processes for anti-Lambda.
 433 // ---
 434
 435   // add process
 436   G4ProcessManager* pManager = G4AntiLambda::AntiLambda()->GetProcessManager();
 437   pManager->AddDiscreteProcess(&fElasticProcess);
 438
 439   fLEAntiLambdaModel = new G4LEAntiLambdaInelastic();
 440   fHEAntiLambdaModel = new G4HEAntiLambdaInelastic();
 441   fAntiLambdaInelastic.RegisterMe(fLEAntiLambdaModel);
 442   fAntiLambdaInelastic.RegisterMe(fHEAntiLambdaModel);
 443   pManager->AddDiscreteProcess(&fAntiLambdaInelastic);
 444
 445   // map to G3 controls
 446   TG4ProcessControlMap* controlMap = TG4ProcessControlMap::Instance();
 447   controlMap->Add(&fAntiLambdaInelastic, kHADR);
 448
 449   // map to G3 ALIMCProcess codes
 450   TG4ProcessMCMap* mcMap = TG4ProcessMCMap::Instance();
 451   mcMap->Add(&fAntiLambdaInelastic, kPHInhelastic);
 452 }
 453
 454 //_____________________________________________________________________________
 455 void TG4PhysicsConstructorHadron::ConstructProcessForSigmaMinus()
 456 {
 457 // Construct processes for Sigma-.
 458 // ---
 459
 460   // add process & set ordering
 461   G4ProcessManager* pManager = G4SigmaMinus::SigmaMinus()->GetProcessManager();
 462   pManager->AddDiscreteProcess(&fElasticProcess);
 463
 464   fLESigmaMinusModel = new G4LESigmaMinusInelastic();
 465   fHESigmaMinusModel = new G4HESigmaMinusInelastic();
 466   fSigmaMinusInelastic.RegisterMe(fLESigmaMinusModel);
 467   fSigmaMinusInelastic.RegisterMe(fHESigmaMinusModel);
 468   pManager->AddDiscreteProcess(&fSigmaMinusInelastic);
 469
 470   pManager->AddProcess(&fSigmaMinusIonisation, ordInActive, 2, 2);
 471
 472   pManager->AddProcess(&fSigmaMinusMult);
 473   pManager->SetProcessOrdering(&fSigmaMinusMult, idxAlongStep, 1);
 474   pManager->SetProcessOrdering(&fSigmaMinusMult, idxPostStep, 1);
 475
 476   // map to G3 controls
 477   TG4ProcessControlMap* controlMap = TG4ProcessControlMap::Instance();
 478   controlMap->Add(&fSigmaMinusInelastic, kHADR);
 479   controlMap->Add(&fSigmaMinusIonisation, kLOSS);
 480   controlMap->Add(&fSigmaMinusMult, kMULS);
 481
 482   // map to G3 ALIMCProcess codes
 483   TG4ProcessMCMap* mcMap = TG4ProcessMCMap::Instance();
 484   mcMap->Add(&fSigmaMinusInelastic, kPHInhelastic);
 485   mcMap->Add(&fSigmaMinusIonisation, kPEnergyLoss);
 486   mcMap->Add(&fSigmaMinusMult, kPMultipleScattering);
 487 }
 488
 489 //_____________________________________________________________________________
 490 void TG4PhysicsConstructorHadron::ConstructProcessForAntiSigmaMinus()
 491 {
 492 // Construct processes for anti-Sigma-.
 493 // ---
 494
 495   // add process & set ordering
 496   G4ProcessManager* pManager
 497     = G4AntiSigmaMinus::AntiSigmaMinus()->GetProcessManager();
 498   pManager->AddDiscreteProcess(&fElasticProcess);
 499
 500   fLEAntiSigmaMinusModel = new G4LEAntiSigmaMinusInelastic();
 501   fHEAntiSigmaMinusModel = new G4HEAntiSigmaMinusInelastic();
 502   fAntiSigmaMinusInelastic.RegisterMe(fLEAntiSigmaMinusModel);
 503   fAntiSigmaMinusInelastic.RegisterMe(fHEAntiSigmaMinusModel);
 504   pManager->AddDiscreteProcess(&fAntiSigmaMinusInelastic);
 505
 506   pManager->AddProcess(&fAntiSigmaMinusIonisation, ordInActive, 2, 2);
 507
 508   pManager->AddProcess(&fAntiSigmaMinusMult);
 509   pManager->SetProcessOrdering(&fAntiSigmaMinusMult, idxAlongStep, 1);
 510   pManager->SetProcessOrdering(&fAntiSigmaMinusMult, idxPostStep, 1);
 511
 512   // map to G3 controls
 513   TG4ProcessControlMap* controlMap = TG4ProcessControlMap::Instance();
 514   controlMap->Add(&fAntiSigmaMinusInelastic, kHADR);
 515   controlMap->Add(&fAntiSigmaMinusIonisation, kLOSS);
 516   controlMap->Add(&fAntiSigmaMinusMult, kMULS);
 517
 518   // map to G3 ALIMCProcess codes
 519   TG4ProcessMCMap* mcMap = TG4ProcessMCMap::Instance();
 520   mcMap->Add(&fAntiSigmaMinusInelastic, kPHInhelastic);
 521   mcMap->Add(&fAntiSigmaMinusIonisation, kPEnergyLoss);
 522   mcMap->Add(&fAntiSigmaMinusMult, kPMultipleScattering);
 523 }
 524
 525 //_____________________________________________________________________________
 526 void TG4PhysicsConstructorHadron::ConstructProcessForSigmaPlus()
 527 {
 528 // Construct processes for Sigma+.
 529 // ---
 530
 531   // add process & set ordering
 532   G4ProcessManager* pManager = G4SigmaPlus::SigmaPlus()->GetProcessManager();
 533   pManager->AddDiscreteProcess(&fElasticProcess);
 534
 535   fLESigmaPlusModel = new G4LESigmaPlusInelastic();
 536   fHESigmaPlusModel = new G4HESigmaPlusInelastic();
 537   fSigmaPlusInelastic.RegisterMe(fLESigmaPlusModel);
 538   fSigmaPlusInelastic.RegisterMe(fHESigmaPlusModel);
 539   pManager->AddDiscreteProcess(&fSigmaPlusInelastic);
 540
 541   pManager->AddProcess(&fSigmaPlusIonisation, ordInActive, 2, 2);
 542
 543   pManager->AddProcess(&fSigmaPlusMult);
 544   pManager->SetProcessOrdering(&fSigmaPlusMult, idxAlongStep, 1);
 545   pManager->SetProcessOrdering(&fSigmaPlusMult, idxPostStep, 1);
 546
 547   // map to G3 controls
 548   TG4ProcessControlMap* controlMap = TG4ProcessControlMap::Instance();
 549   controlMap->Add(&fSigmaPlusInelastic, kHADR);
 550   controlMap->Add(&fSigmaPlusIonisation, kLOSS);
 551   controlMap->Add(&fSigmaPlusMult, kMULS);
 552
 553   // map to G3 ALIMCProcess codes
 554   TG4ProcessMCMap* mcMap = TG4ProcessMCMap::Instance();
 555   mcMap->Add(&fSigmaPlusInelastic, kPHInhelastic);
 556   mcMap->Add(&fSigmaPlusIonisation, kPEnergyLoss);
 557   mcMap->Add(&fSigmaPlusMult, kPMultipleScattering);
 558 }
 559
 560 //_____________________________________________________________________________
 561 void TG4PhysicsConstructorHadron::ConstructProcessForAntiSigmaPlus()
 562 {
 563 // Construct processes for anti-Sigma+.
 564 // ---
 565
 566   // add process & set ordering
 567   G4ProcessManager* pManager
 568     = G4AntiSigmaPlus::AntiSigmaPlus()->GetProcessManager();
 569   pManager->AddDiscreteProcess(&fElasticProcess);
 570
 571   fLEAntiSigmaPlusModel = new G4LEAntiSigmaPlusInelastic();
 572   fHEAntiSigmaPlusModel = new G4HEAntiSigmaPlusInelastic();
 573   fAntiSigmaPlusInelastic.RegisterMe(fLEAntiSigmaPlusModel);
 574   fAntiSigmaPlusInelastic.RegisterMe(fHEAntiSigmaPlusModel);
 575   pManager->AddDiscreteProcess(&fAntiSigmaPlusInelastic);
 576
 577   pManager->AddProcess(&fAntiSigmaPlusIonisation, ordInActive, 2, 2);
 578
 579   pManager->AddProcess(&fAntiSigmaPlusMult);
 580   pManager->SetProcessOrdering(&fAntiSigmaPlusMult, idxAlongStep, 1);
 581   pManager->SetProcessOrdering(&fAntiSigmaPlusMult, idxPostStep, 1);
 582
 583   // map to G3 controls
 584   TG4ProcessControlMap* controlMap = TG4ProcessControlMap::Instance();
 585   controlMap->Add(&fAntiSigmaPlusInelastic, kHADR);
 586   controlMap->Add(&fAntiSigmaPlusIonisation, kLOSS);
 587   controlMap->Add(&fAntiSigmaPlusMult, kMULS);
 588
 589   // map to G3 ALIMCProcess codes
 590   TG4ProcessMCMap* mcMap = TG4ProcessMCMap::Instance();
 591   mcMap->Add(&fAntiSigmaPlusInelastic, kPHInhelastic);
 592   mcMap->Add(&fAntiSigmaPlusIonisation, kPEnergyLoss);
 593   mcMap->Add(&fAntiSigmaPlusMult, kPMultipleScattering);
 594 }
 595
 596 //_____________________________________________________________________________
 597 void TG4PhysicsConstructorHadron::ConstructProcessForXiMinus()
 598 {
 599 // Construct processes for Xi-.
 600 // ---
 601
 602   // add process & set ordering
 603   G4ProcessManager* pManager = G4XiMinus::XiMinus()->GetProcessManager();
 604   pManager->AddDiscreteProcess(&fElasticProcess);
 605
 606   fLEXiMinusModel = new G4LEXiMinusInelastic();
 607   fHEXiMinusModel = new G4HEXiMinusInelastic();
 608   fXiMinusInelastic.RegisterMe(fLEXiMinusModel);
 609   fXiMinusInelastic.RegisterMe(fHEXiMinusModel);
 610   pManager->AddDiscreteProcess(&fXiMinusInelastic);
 611
 612   pManager->AddProcess(&fXiMinusIonisation, ordInActive, 2, 2);
 613
 614   pManager->AddProcess(&fXiMinusMult);
 615   pManager->SetProcessOrdering(&fXiMinusMult, idxAlongStep, 1);
 616   pManager->SetProcessOrdering(&fXiMinusMult, idxPostStep, 1);
 617
 618   // map to G3 controls
 619   TG4ProcessControlMap* controlMap = TG4ProcessControlMap::Instance();
 620   controlMap->Add(&fXiMinusInelastic, kHADR);
 621   controlMap->Add(&fXiMinusIonisation, kLOSS);
 622   controlMap->Add(&fXiMinusMult, kMULS);
 623
 624   // map to G3 ALIMCProcess codes
 625   TG4ProcessMCMap* mcMap = TG4ProcessMCMap::Instance();
 626   mcMap->Add(&fXiMinusInelastic, kPHInhelastic);
 627   mcMap->Add(&fXiMinusIonisation, kPEnergyLoss);
 628   mcMap->Add(&fXiMinusMult, kPMultipleScattering);
 629 }
 630
 631 //_____________________________________________________________________________
 632 void TG4PhysicsConstructorHadron::ConstructProcessForAntiXiMinus()
 633 {
 634 // Construct processes for anti-Xi-.
 635 // ---
 636
 637   // add process & set ordering
 638   G4ProcessManager* pManager
 639     = G4AntiXiMinus::AntiXiMinus()->GetProcessManager();
 640   pManager->AddDiscreteProcess(&fElasticProcess);
 641
 642   fLEAntiXiMinusModel = new G4LEAntiXiMinusInelastic();
 643   fHEAntiXiMinusModel = new G4HEAntiXiMinusInelastic();
 644   fAntiXiMinusInelastic.RegisterMe(fLEAntiXiMinusModel);
 645   fAntiXiMinusInelastic.RegisterMe(fHEAntiXiMinusModel);
 646   pManager->AddDiscreteProcess(&fAntiXiMinusInelastic);
 647
 648   pManager->AddProcess(&fAntiXiMinusIonisation, ordInActive, 2, 2);
 649
 650   pManager->AddProcess(&fAntiXiMinusMult);
 651   pManager->SetProcessOrdering(&fAntiXiMinusMult, idxAlongStep, 1);
 652   pManager->SetProcessOrdering(&fAntiXiMinusMult, idxPostStep, 1);
 653
 654   // map to G3 controls
 655   TG4ProcessControlMap* controlMap = TG4ProcessControlMap::Instance();
 656   controlMap->Add(&fAntiXiMinusInelastic, kHADR);
 657   controlMap->Add(&fAntiXiMinusIonisation, kLOSS);
 658   controlMap->Add(&fAntiXiMinusMult, kMULS);
 659
 660   // map to G3 ALIMCProcess codes
 661   TG4ProcessMCMap* mcMap = TG4ProcessMCMap::Instance();
 662   mcMap->Add(&fAntiXiMinusInelastic, kPHInhelastic);
 663   mcMap->Add(&fAntiXiMinusIonisation, kPEnergyLoss);
 664   mcMap->Add(&fAntiXiMinusMult, kPMultipleScattering);
 665 }
 666
 667 //_____________________________________________________________________________
 668 void TG4PhysicsConstructorHadron::ConstructProcessForXiZero()
 669 {
 670 // Construct processes for Xi0.
 671 // ---
 672
 673   // add process
 674   G4ProcessManager* pManager = G4XiZero::XiZero()->GetProcessManager();
 675   pManager->AddDiscreteProcess(&fElasticProcess);
 676
 677   fLEXiZeroModel = new G4LEXiZeroInelastic();
 678   fHEXiZeroModel = new G4HEXiZeroInelastic();
 679   fXiZeroInelastic.RegisterMe(fLEXiZeroModel);
 680   fXiZeroInelastic.RegisterMe(fHEXiZeroModel);
 681   pManager->AddDiscreteProcess(&fXiZeroInelastic);
 682
 683   // map to G3 controls
 684   TG4ProcessControlMap* controlMap = TG4ProcessControlMap::Instance();
 685   controlMap->Add(&fXiZeroInelastic, kHADR);
 686
 687   // map to G3 ALIMCProcess codes
 688   TG4ProcessMCMap* mcMap = TG4ProcessMCMap::Instance();
 689   mcMap->Add(&fXiZeroInelastic, kPHInhelastic);
 690 }
 691
 692 //_____________________________________________________________________________
 693 void TG4PhysicsConstructorHadron::ConstructProcessForAntiXiZero()
 694 {
 695 // Construct processes for anti-Xi0.
 696 // ---
 697
 698   // add process
 699   G4ProcessManager* pManager = G4AntiXiZero::AntiXiZero()->GetProcessManager();
 700   pManager->AddDiscreteProcess(&fElasticProcess);
 701
 702   fLEAntiXiZeroModel = new G4LEAntiXiZeroInelastic();
 703   fHEAntiXiZeroModel = new G4HEAntiXiZeroInelastic();
 704   fAntiXiZeroInelastic.RegisterMe(fLEAntiXiZeroModel);
 705   fAntiXiZeroInelastic.RegisterMe(fHEAntiXiZeroModel);
 706   pManager->AddDiscreteProcess(&fAntiXiZeroInelastic);
 707
 708   // map to G3 controls
 709   TG4ProcessControlMap* controlMap = TG4ProcessControlMap::Instance();
 710   controlMap->Add(&fAntiXiZeroInelastic, kHADR);
 711
 712   // map to G3 ALIMCProcess codes
 713   TG4ProcessMCMap* mcMap = TG4ProcessMCMap::Instance();
 714   mcMap->Add(&fAntiXiZeroInelastic, kPHInhelastic);
 715 }
 716
 717 //_____________________________________________________________________________
 718 void TG4PhysicsConstructorHadron::ConstructProcessForOmegaMinus()
 719 {
 720 // Construct processes for Omega-.
 721 // ---
 722
 723   // add process & set ordering
 724   G4ProcessManager* pManager = G4OmegaMinus::OmegaMinus()->GetProcessManager();
 725   pManager->AddDiscreteProcess(&fElasticProcess);
 726
 727   fLEOmegaMinusModel = new G4LEOmegaMinusInelastic();
 728   fHEOmegaMinusModel = new G4HEOmegaMinusInelastic();
 729   fOmegaMinusInelastic.RegisterMe(fLEOmegaMinusModel);
 730   fOmegaMinusInelastic.RegisterMe(fHEOmegaMinusModel);
 731   pManager->AddDiscreteProcess(&fOmegaMinusInelastic);
 732
 733   pManager->AddProcess(&fOmegaMinusIonisation, ordInActive, 2, 2);
 734
 735   pManager->AddProcess(&fOmegaMinusMult);
 736   pManager->SetProcessOrdering(&fOmegaMinusMult, idxAlongStep, 1);
 737   pManager->SetProcessOrdering(&fOmegaMinusMult, idxPostStep, 1);
 738
 739   // map to G3 controls
 740   TG4ProcessControlMap* controlMap = TG4ProcessControlMap::Instance();
 741   controlMap->Add(&fOmegaMinusInelastic, kHADR);
 742   controlMap->Add(&fOmegaMinusIonisation, kLOSS);
 743   controlMap->Add(&fOmegaMinusMult, kMULS);
 744
 745   // map to G3 ALIMCProcess codes
 746   TG4ProcessMCMap* mcMap = TG4ProcessMCMap::Instance();
 747   mcMap->Add(&fOmegaMinusInelastic, kPHInhelastic);
 748   mcMap->Add(&fOmegaMinusIonisation, kPEnergyLoss);
 749   mcMap->Add(&fOmegaMinusMult, kPMultipleScattering);
 750 }
 751
 752 //_____________________________________________________________________________
 753 void TG4PhysicsConstructorHadron::ConstructProcessForAntiOmegaMinus()
 754 {
 755 // Construct processes for pi+.
 756 // ---
 757
 758   // add process & set ordering
 759   G4ProcessManager* pManager
 760     = G4AntiOmegaMinus::AntiOmegaMinus()->GetProcessManager();
 761   pManager->AddDiscreteProcess(&fElasticProcess);
 762
 763   fLEAntiOmegaMinusModel = new G4LEAntiOmegaMinusInelastic();
 764   fHEAntiOmegaMinusModel = new G4HEAntiOmegaMinusInelastic();
 765   fAntiOmegaMinusInelastic.RegisterMe(fLEAntiOmegaMinusModel);
 766   fAntiOmegaMinusInelastic.RegisterMe(fHEAntiOmegaMinusModel);
 767   pManager->AddDiscreteProcess(&fAntiOmegaMinusInelastic);
 768
 769   pManager->AddProcess(&fAntiOmegaMinusIonisation, ordInActive, 2, 2);
 770
 771   pManager->AddProcess(&fAntiOmegaMinusMult);
 772   pManager->SetProcessOrdering(&fAntiOmegaMinusMult, idxAlongStep, 1);
 773   pManager->SetProcessOrdering(&fAntiOmegaMinusMult, idxPostStep, 1);
 774
 775   // map to G3 controls
 776   TG4ProcessControlMap* controlMap = TG4ProcessControlMap::Instance();
 777   controlMap->Add(&fAntiOmegaMinusInelastic, kHADR);
 778   controlMap->Add(&fAntiOmegaMinusIonisation, kLOSS);
 779   controlMap->Add(&fAntiOmegaMinusMult, kMULS);
 780
 781   // map to G3 ALIMCProcess codes
 782   TG4ProcessMCMap* mcMap = TG4ProcessMCMap::Instance();
 783   mcMap->Add(&fAntiOmegaMinusInelastic, kPHInhelastic);
 784   mcMap->Add(&fAntiOmegaMinusIonisation, kPEnergyLoss);
 785   mcMap->Add(&fAntiOmegaMinusMult, kPMultipleScattering);
 786 }
 787
 788 //_____________________________________________________________________________
 789 void TG4PhysicsConstructorHadron::ConstructProcessForOther()
 790 {
 791 // Construct processes for other hadrons.
 792 // ---
 793
 794   theParticleIterator->reset();
 795   while( (*theParticleIterator)() ){
 796     G4ParticleDefinition* particle = theParticleIterator->value();
 797     G4ProcessManager* pManager = particle->GetProcessManager();
 798     G4int nofAlongStepProcesses
 799       = pManager->GetAlongStepProcessVector()->length();
 800
 801     if ( !particle->IsShortLived()       &&
 802          particle->GetPDGCharge() != 0.0 &&
 803          nofAlongStepProcesses == 1      &&
 804          particle->GetParticleName() != "chargedgeantino") {
 805
 806       // create processes
 807       G4VProcess* aMultipleScattering = new G4MultipleScattering();
 808       G4VProcess* anIonisation = new G4hIonisation();
 809
 810       // add processes
 811       pManager->AddProcess(anIonisation, ordInActive, 2, 2);
 812       pManager->AddProcess(aMultipleScattering);
 813
 814       // set ordering
 815       pManager->SetProcessOrdering(aMultipleScattering, idxAlongStep, 1);
 816       pManager->SetProcessOrdering(aMultipleScattering, idxPostStep, 1);
 817
 818       // map to G3 controls
 819       TG4ProcessControlMap* controlMap = TG4ProcessControlMap::Instance();
 820       controlMap->Add(anIonisation, kLOSS);
 821       controlMap->Add(aMultipleScattering, kMULS);
 822
 823       // map to AliMCProcess codes
 824       TG4ProcessMCMap* mcMap = TG4ProcessMCMap::Instance();
 825       mcMap->Add(anIonisation, kPEnergyLoss);
 826       mcMap->Add(aMultipleScattering, kPMultipleScattering);
 827
 828       // keep for deleting
 829       fOtherProcesses.push_back(aMultipleScattering);
 830       fOtherProcesses.push_back(anIonisation);
 831     }
 832   }
 833 }
 834
 835 // protected methods
 836
 837 //_____________________________________________________________________________
 838 void TG4PhysicsConstructorHadron::ConstructParticle()
 839 {
 840 // Construct all hadrons.
 841 // ---
 842
 843   //  Construct all mesons
 844   G4MesonConstructor pMesonConstructor;
 845   pMesonConstructor.ConstructParticle();
 846
 847   //  Construct all barions
 848   G4BaryonConstructor pBaryonConstructor;
 849   pBaryonConstructor.ConstructParticle();
 850
 851   //  Construct  resonances and quarks
 852   G4ShortLivedConstructor pShortLivedConstructor;
 853   pShortLivedConstructor.ConstructParticle();
 854 }
 855
 856 //_____________________________________________________________________________
 857 void TG4PhysicsConstructorHadron::ConstructProcess()
 858 {
 859 // Construct all hadronic processes.
 860 // ---
 861
 862   // Elastic Process
 863   fElasticModel = new G4LElastic();
 864   fElasticProcess.RegisterMe(fElasticModel);
 865
 866   ConstructProcessForPionPlus();
 867   ConstructProcessForPionMinus();
 868   ConstructProcessForKaonPlus();
 869   ConstructProcessForKaonMinus();
 870   ConstructProcessForKaonZeroLong();
 871   ConstructProcessForKaonZeroShort();
 872   ConstructProcessForProton();
 873   ConstructProcessForAntiProton();
 874   ConstructProcessForNeutron();
 875   ConstructProcessForAntiNeutron();
 876   ConstructProcessForLambda();
 877   ConstructProcessForAntiLambda();
 878   ConstructProcessForSigmaMinus();
 879   ConstructProcessForAntiSigmaMinus();
 880   ConstructProcessForSigmaPlus();
 881   ConstructProcessForAntiSigmaPlus();
 882   ConstructProcessForXiMinus();
 883   ConstructProcessForAntiXiMinus();
 884   ConstructProcessForXiZero();
 885   ConstructProcessForAntiXiZero();
 886   ConstructProcessForOmegaMinus();
 887   ConstructProcessForAntiOmegaMinus();
 888   ConstructProcessForOther();
 889
 890   if (verboseLevel>0)
 891      G4cout << "### Hadron physics constructed." << G4endl;
 892 }
 893