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   : TG4VPhysicsConstructor(name),
  26     fSetEM(true),
  27     fSetHadron(true) {
  28 //
  29 }
  30
  31 //_____________________________________________________________________________
  32 TG4PhysicsConstructorHadron::TG4PhysicsConstructorHadron(G4int verboseLevel,
  33                                                          G4bool setEM,
  34                                                          G4bool setHadron,
  35                                                          const G4String& name)
  36   : TG4VPhysicsConstructor(name, verboseLevel),
  37     fSetEM(setEM),
  38     fSetHadron(setHadron) {
  39 //
  40 }
  41
  42 //_____________________________________________________________________________
  43 TG4PhysicsConstructorHadron::TG4PhysicsConstructorHadron(
  44                                      const TG4PhysicsConstructorHadron& right)
  45   : TG4VPhysicsConstructor(right)
  46 {
  47 //
  48   TG4Globals::Exception("TG4PhysicsConstructorHadron is protected from copying.");
  49 }
  50
  51 //_____________________________________________________________________________
  52 TG4PhysicsConstructorHadron::~TG4PhysicsConstructorHadron() {
  53 //
  54   for (G4int i=0; i<fOtherProcesses.size(); i++) delete fOtherProcesses[i];
  55 }
  56
  57 // operators
  58
  59 //_____________________________________________________________________________
  60 TG4PhysicsConstructorHadron&
  61 TG4PhysicsConstructorHadron::operator=(const TG4PhysicsConstructorHadron &right)
  62 {
  63   // check assignement to self
  64   if (this == &right) return *this;
  65
  66   TG4Globals::Exception(
  67     "TG4PhysicsConstructorHadron is protected from assigning.");
  68
  69   return *this;
  70 }
  71
  72
  73 // private methods
  74
  75 //_____________________________________________________________________________
  76 void TG4PhysicsConstructorHadron::ConstructEMProcessForPionPlus()
  77 {
  78 // Construct processes for pi+.
  79 // ---
  80
  81   // add process
  82   G4ProcessManager* pManager = G4PionPlus::PionPlus()->GetProcessManager();
  83
  84   pManager->AddProcess(&fPionPlusIonisation, ordInActive, 2, 2);
  85   pManager->AddProcess(&fPionPlusMult);
  86
  87   // set ordering
  88   pManager->SetProcessOrdering(&fPionPlusMult, idxAlongStep, 1);
  89   pManager->SetProcessOrdering(&fPionPlusMult, idxPostStep, 1);
  90
  91   // map to G3 controls
  92   TG4ProcessControlMap* controlMap = TG4ProcessControlMap::Instance();
  93   controlMap->Add(&fPionPlusIonisation, kLOSS);
  94   controlMap->Add(&fPionPlusMult, kMULS);
  95
  96   // map to G3 ALIMCProcess codes
  97   TG4ProcessMCMap* mcMap = TG4ProcessMCMap::Instance();
  98   mcMap->Add(&fPionPlusIonisation, kPEnergyLoss);
  99   mcMap->Add(&fPionPlusMult, kPMultipleScattering);
 100 }
 101
 102 //_____________________________________________________________________________
 103 void TG4PhysicsConstructorHadron::ConstructEMProcessForPionMinus()
 104 {
 105 // Construct processes for pi-.
 106 // ---
 107
 108   // add process & set ordering
 109   G4ProcessManager* pManager = G4PionMinus::PionMinus()->GetProcessManager();
 110
 111   pManager->AddProcess(&fPionMinusIonisation, ordInActive, 2, 2);
 112
 113   pManager->AddProcess(&fPionMinusMult);
 114   pManager->SetProcessOrdering(&fPionMinusMult, idxAlongStep, 1);
 115   pManager->SetProcessOrdering(&fPionMinusMult, idxPostStep, 1);
 116
 117   // map to G3 controls
 118   TG4ProcessControlMap* controlMap = TG4ProcessControlMap::Instance();
 119   controlMap->Add(&fPionMinusIonisation, kLOSS);
 120   controlMap->Add(&fPionMinusMult, kMULS);
 121
 122   // map to G3 ALIMCProcess codes
 123   TG4ProcessMCMap* mcMap = TG4ProcessMCMap::Instance();
 124   mcMap->Add(&fPionMinusIonisation, kPEnergyLoss);
 125   mcMap->Add(&fPionMinusMult, kPMultipleScattering);
 126 }
 127
 128 //_____________________________________________________________________________
 129 void TG4PhysicsConstructorHadron::ConstructEMProcessForKaonPlus()
 130 {
 131 // Construct processes for K+.
 132 // ---
 133
 134   // add process
 135   G4ProcessManager* pManager = G4KaonPlus::KaonPlus()->GetProcessManager();
 136
 137   pManager->AddProcess(&fKaonPlusIonisation, ordInActive, 2, 2);
 138   pManager->AddProcess(&fKaonPlusMult);
 139
 140   // set ordering
 141   pManager->SetProcessOrdering(&fKaonPlusMult, idxAlongStep, 1);
 142   pManager->SetProcessOrdering(&fKaonPlusMult, idxPostStep, 1);
 143
 144   // map to G3 controls
 145   TG4ProcessControlMap* controlMap = TG4ProcessControlMap::Instance();
 146   controlMap->Add(&fKaonPlusIonisation, kLOSS);
 147   controlMap->Add(&fKaonPlusMult, kMULS);
 148
 149   // map to G3 ALIMCProcess codes
 150   TG4ProcessMCMap* mcMap = TG4ProcessMCMap::Instance();
 151   mcMap->Add(&fKaonPlusIonisation, kPEnergyLoss);
 152   mcMap->Add(&fKaonPlusMult, kPMultipleScattering);
 153 }
 154
 155 //_____________________________________________________________________________
 156 void TG4PhysicsConstructorHadron::ConstructEMProcessForKaonMinus()
 157 {
 158 // Construct processes for K-.
 159 // ---
 160
 161   // add process & set ordering
 162   G4ProcessManager* pManager = G4KaonMinus::KaonMinus()->GetProcessManager();
 163
 164   pManager->AddProcess(&fKaonMinusIonisation, ordInActive, 2, 2);
 165
 166   pManager->AddProcess(&fKaonMinusMult);
 167   pManager->SetProcessOrdering(&fKaonMinusMult, idxAlongStep, 1);
 168   pManager->SetProcessOrdering(&fKaonMinusMult, idxPostStep, 1);
 169
 170   // map to G3 controls
 171   TG4ProcessControlMap* controlMap = TG4ProcessControlMap::Instance();
 172   controlMap->Add(&fKaonMinusIonisation, kLOSS);
 173   controlMap->Add(&fKaonMinusMult, kMULS);
 174
 175   // map to G3 ALIMCProcess codes
 176   TG4ProcessMCMap* mcMap = TG4ProcessMCMap::Instance();
 177   mcMap->Add(&fKaonMinusIonisation, kPEnergyLoss);
 178   mcMap->Add(&fKaonMinusMult, kPMultipleScattering);
 179 }
 180
 181 //_____________________________________________________________________________
 182 void TG4PhysicsConstructorHadron::ConstructEMProcessForProton()
 183 {
 184 // Construct processes for proton.
 185 // ---
 186
 187   // add process
 188   G4ProcessManager* pManager = G4Proton::Proton()->GetProcessManager();
 189
 190   pManager->AddProcess(&fProtonIonisation, ordInActive, 2, 2);
 191   pManager->AddProcess(&fProtonMult);
 192
 193   // set ordering
 194   pManager->SetProcessOrdering(&fProtonMult, idxAlongStep, 1);
 195   pManager->SetProcessOrdering(&fProtonMult, idxPostStep, 1);
 196
 197   // map to G3 controls
 198   TG4ProcessControlMap* controlMap = TG4ProcessControlMap::Instance();
 199   controlMap->Add(&fProtonIonisation, kLOSS);
 200   controlMap->Add(&fProtonMult, kMULS);
 201
 202   // map to G3 ALIMCProcess codes
 203   TG4ProcessMCMap* mcMap = TG4ProcessMCMap::Instance();
 204   mcMap->Add(&fProtonIonisation, kPEnergyLoss);
 205   mcMap->Add(&fProtonMult, kPMultipleScattering);
 206 }
 207
 208 //_____________________________________________________________________________
 209 void TG4PhysicsConstructorHadron::ConstructEMProcessForAntiProton()
 210 {
 211 // Construct processes for anti-proton.
 212 // ---
 213
 214   // add process & set ordering
 215   G4ProcessManager* pManager = G4AntiProton::AntiProton()->GetProcessManager();
 216
 217   pManager->AddProcess(&fAntiProtonIonisation, ordInActive, 2, 2);
 218
 219   pManager->AddProcess(&fAntiProtonMult);
 220   pManager->SetProcessOrdering(&fAntiProtonMult, idxAlongStep, 1);
 221   pManager->SetProcessOrdering(&fAntiProtonMult, idxPostStep, 1);
 222
 223   pManager->AddRestProcess(&fAntiProtonAnnihilation);
 224
 225   // map to G3 controls
 226   TG4ProcessControlMap* controlMap = TG4ProcessControlMap::Instance();
 227   controlMap->Add(&fAntiProtonIonisation, kLOSS);
 228   controlMap->Add(&fAntiProtonMult, kMULS);
 229
 230   // map to G3 ALIMCProcess codes
 231   TG4ProcessMCMap* mcMap = TG4ProcessMCMap::Instance();
 232   mcMap->Add(&fAntiProtonIonisation, kPEnergyLoss);
 233   mcMap->Add(&fAntiProtonMult, kPMultipleScattering);
 234 }
 235
 236 //_____________________________________________________________________________
 237 void TG4PhysicsConstructorHadron::ConstructEMProcessForSigmaMinus()
 238 {
 239 // Construct processes for Sigma-.
 240 // ---
 241
 242   // add process & set ordering
 243   G4ProcessManager* pManager = G4SigmaMinus::SigmaMinus()->GetProcessManager();
 244
 245   pManager->AddProcess(&fSigmaMinusIonisation, ordInActive, 2, 2);
 246
 247   pManager->AddProcess(&fSigmaMinusMult);
 248   pManager->SetProcessOrdering(&fSigmaMinusMult, idxAlongStep, 1);
 249   pManager->SetProcessOrdering(&fSigmaMinusMult, idxPostStep, 1);
 250
 251   // map to G3 controls
 252   TG4ProcessControlMap* controlMap = TG4ProcessControlMap::Instance();
 253   controlMap->Add(&fSigmaMinusIonisation, kLOSS);
 254   controlMap->Add(&fSigmaMinusMult, kMULS);
 255
 256   // map to G3 ALIMCProcess codes
 257   TG4ProcessMCMap* mcMap = TG4ProcessMCMap::Instance();
 258   mcMap->Add(&fSigmaMinusIonisation, kPEnergyLoss);
 259   mcMap->Add(&fSigmaMinusMult, kPMultipleScattering);
 260 }
 261
 262 //_____________________________________________________________________________
 263 void TG4PhysicsConstructorHadron::ConstructEMProcessForAntiSigmaMinus()
 264 {
 265 // Construct processes for anti-Sigma-.
 266 // ---
 267
 268   // add process & set ordering
 269   G4ProcessManager* pManager
 270     = G4AntiSigmaMinus::AntiSigmaMinus()->GetProcessManager();
 271
 272   pManager->AddProcess(&fAntiSigmaMinusIonisation, ordInActive, 2, 2);
 273
 274   pManager->AddProcess(&fAntiSigmaMinusMult);
 275   pManager->SetProcessOrdering(&fAntiSigmaMinusMult, idxAlongStep, 1);
 276   pManager->SetProcessOrdering(&fAntiSigmaMinusMult, idxPostStep, 1);
 277
 278   // map to G3 controls
 279   TG4ProcessControlMap* controlMap = TG4ProcessControlMap::Instance();
 280   controlMap->Add(&fAntiSigmaMinusIonisation, kLOSS);
 281   controlMap->Add(&fAntiSigmaMinusMult, kMULS);
 282
 283   // map to G3 ALIMCProcess codes
 284   TG4ProcessMCMap* mcMap = TG4ProcessMCMap::Instance();
 285   mcMap->Add(&fAntiSigmaMinusIonisation, kPEnergyLoss);
 286   mcMap->Add(&fAntiSigmaMinusMult, kPMultipleScattering);
 287 }
 288
 289 //_____________________________________________________________________________
 290 void TG4PhysicsConstructorHadron::ConstructEMProcessForSigmaPlus()
 291 {
 292 // Construct processes for Sigma+.
 293 // ---
 294
 295   // add process & set ordering
 296   G4ProcessManager* pManager = G4SigmaPlus::SigmaPlus()->GetProcessManager();
 297
 298   pManager->AddProcess(&fSigmaPlusIonisation, ordInActive, 2, 2);
 299
 300   pManager->AddProcess(&fSigmaPlusMult);
 301   pManager->SetProcessOrdering(&fSigmaPlusMult, idxAlongStep, 1);
 302   pManager->SetProcessOrdering(&fSigmaPlusMult, idxPostStep, 1);
 303
 304   // map to G3 controls
 305   TG4ProcessControlMap* controlMap = TG4ProcessControlMap::Instance();
 306   controlMap->Add(&fSigmaPlusIonisation, kLOSS);
 307   controlMap->Add(&fSigmaPlusMult, kMULS);
 308
 309   // map to G3 ALIMCProcess codes
 310   TG4ProcessMCMap* mcMap = TG4ProcessMCMap::Instance();
 311   mcMap->Add(&fSigmaPlusIonisation, kPEnergyLoss);
 312   mcMap->Add(&fSigmaPlusMult, kPMultipleScattering);
 313 }
 314
 315 //_____________________________________________________________________________
 316 void TG4PhysicsConstructorHadron::ConstructEMProcessForAntiSigmaPlus()
 317 {
 318 // Construct processes for anti-Sigma+.
 319 // ---
 320
 321   // add process & set ordering
 322   G4ProcessManager* pManager
 323     = G4AntiSigmaPlus::AntiSigmaPlus()->GetProcessManager();
 324
 325   pManager->AddProcess(&fAntiSigmaPlusIonisation, ordInActive, 2, 2);
 326
 327   pManager->AddProcess(&fAntiSigmaPlusMult);
 328   pManager->SetProcessOrdering(&fAntiSigmaPlusMult, idxAlongStep, 1);
 329   pManager->SetProcessOrdering(&fAntiSigmaPlusMult, idxPostStep, 1);
 330
 331   // map to G3 controls
 332   TG4ProcessControlMap* controlMap = TG4ProcessControlMap::Instance();
 333   controlMap->Add(&fAntiSigmaPlusIonisation, kLOSS);
 334   controlMap->Add(&fAntiSigmaPlusMult, kMULS);
 335
 336   // map to G3 ALIMCProcess codes
 337   TG4ProcessMCMap* mcMap = TG4ProcessMCMap::Instance();
 338   mcMap->Add(&fAntiSigmaPlusIonisation, kPEnergyLoss);
 339   mcMap->Add(&fAntiSigmaPlusMult, kPMultipleScattering);
 340 }
 341
 342 //_____________________________________________________________________________
 343 void TG4PhysicsConstructorHadron::ConstructEMProcessForXiMinus()
 344 {
 345 // Construct processes for Xi-.
 346 // ---
 347
 348   // add process & set ordering
 349   G4ProcessManager* pManager = G4XiMinus::XiMinus()->GetProcessManager();
 350
 351   pManager->AddProcess(&fXiMinusIonisation, ordInActive, 2, 2);
 352
 353   pManager->AddProcess(&fXiMinusMult);
 354   pManager->SetProcessOrdering(&fXiMinusMult, idxAlongStep, 1);
 355   pManager->SetProcessOrdering(&fXiMinusMult, idxPostStep, 1);
 356
 357   // map to G3 controls
 358   TG4ProcessControlMap* controlMap = TG4ProcessControlMap::Instance();
 359   controlMap->Add(&fXiMinusIonisation, kLOSS);
 360   controlMap->Add(&fXiMinusMult, kMULS);
 361
 362   // map to G3 ALIMCProcess codes
 363   TG4ProcessMCMap* mcMap = TG4ProcessMCMap::Instance();
 364   mcMap->Add(&fXiMinusIonisation, kPEnergyLoss);
 365   mcMap->Add(&fXiMinusMult, kPMultipleScattering);
 366 }
 367
 368 //_____________________________________________________________________________
 369 void TG4PhysicsConstructorHadron::ConstructEMProcessForAntiXiMinus()
 370 {
 371 // Construct processes for anti-Xi-.
 372 // ---
 373
 374   // add process & set ordering
 375   G4ProcessManager* pManager
 376     = G4AntiXiMinus::AntiXiMinus()->GetProcessManager();
 377
 378   pManager->AddProcess(&fAntiXiMinusIonisation, ordInActive, 2, 2);
 379
 380   pManager->AddProcess(&fAntiXiMinusMult);
 381   pManager->SetProcessOrdering(&fAntiXiMinusMult, idxAlongStep, 1);
 382   pManager->SetProcessOrdering(&fAntiXiMinusMult, idxPostStep, 1);
 383
 384   // map to G3 controls
 385   TG4ProcessControlMap* controlMap = TG4ProcessControlMap::Instance();
 386   controlMap->Add(&fAntiXiMinusIonisation, kLOSS);
 387   controlMap->Add(&fAntiXiMinusMult, kMULS);
 388
 389   // map to G3 ALIMCProcess codes
 390   TG4ProcessMCMap* mcMap = TG4ProcessMCMap::Instance();
 391   mcMap->Add(&fAntiXiMinusIonisation, kPEnergyLoss);
 392   mcMap->Add(&fAntiXiMinusMult, kPMultipleScattering);
 393 }
 394
 395 //_____________________________________________________________________________
 396 void TG4PhysicsConstructorHadron::ConstructEMProcessForOmegaMinus()
 397 {
 398 // Construct processes for Omega-.
 399 // ---
 400
 401   // add process & set ordering
 402   G4ProcessManager* pManager = G4OmegaMinus::OmegaMinus()->GetProcessManager();
 403
 404   pManager->AddProcess(&fOmegaMinusIonisation, ordInActive, 2, 2);
 405
 406   pManager->AddProcess(&fOmegaMinusMult);
 407   pManager->SetProcessOrdering(&fOmegaMinusMult, idxAlongStep, 1);
 408   pManager->SetProcessOrdering(&fOmegaMinusMult, idxPostStep, 1);
 409
 410   // map to G3 controls
 411   TG4ProcessControlMap* controlMap = TG4ProcessControlMap::Instance();
 412   controlMap->Add(&fOmegaMinusIonisation, kLOSS);
 413   controlMap->Add(&fOmegaMinusMult, kMULS);
 414
 415   // map to G3 ALIMCProcess codes
 416   TG4ProcessMCMap* mcMap = TG4ProcessMCMap::Instance();
 417   mcMap->Add(&fOmegaMinusIonisation, kPEnergyLoss);
 418   mcMap->Add(&fOmegaMinusMult, kPMultipleScattering);
 419 }
 420
 421 //_____________________________________________________________________________
 422 void TG4PhysicsConstructorHadron::ConstructEMProcessForAntiOmegaMinus()
 423 {
 424 // Construct processes for pi+.
 425 // ---
 426
 427   // add process & set ordering
 428   G4ProcessManager* pManager
 429     = G4AntiOmegaMinus::AntiOmegaMinus()->GetProcessManager();
 430
 431   pManager->AddProcess(&fAntiOmegaMinusIonisation, ordInActive, 2, 2);
 432
 433   pManager->AddProcess(&fAntiOmegaMinusMult);
 434   pManager->SetProcessOrdering(&fAntiOmegaMinusMult, idxAlongStep, 1);
 435   pManager->SetProcessOrdering(&fAntiOmegaMinusMult, idxPostStep, 1);
 436
 437   // map to G3 controls
 438   TG4ProcessControlMap* controlMap = TG4ProcessControlMap::Instance();
 439   controlMap->Add(&fAntiOmegaMinusIonisation, kLOSS);
 440   controlMap->Add(&fAntiOmegaMinusMult, kMULS);
 441
 442   // map to G3 ALIMCProcess codes
 443   TG4ProcessMCMap* mcMap = TG4ProcessMCMap::Instance();
 444   mcMap->Add(&fAntiOmegaMinusIonisation, kPEnergyLoss);
 445   mcMap->Add(&fAntiOmegaMinusMult, kPMultipleScattering);
 446 }
 447
 448 //_____________________________________________________________________________
 449 void TG4PhysicsConstructorHadron::ConstructEMProcessForOther()
 450 {
 451 // Construct processes for other hadrons.
 452 // ---
 453
 454   theParticleIterator->reset();
 455   while( (*theParticleIterator)() ){
 456     G4ParticleDefinition* particle = theParticleIterator->value();
 457     G4ProcessManager* pManager = particle->GetProcessManager();
 458     G4int nofAlongStepProcesses
 459       = pManager->GetAlongStepProcessVector()->length();
 460
 461     if ( !particle->IsShortLived()       &&
 462          particle->GetPDGCharge() != 0.0 &&
 463          nofAlongStepProcesses == 1      &&
 464          particle->GetParticleName() != "chargedgeantino") {
 465
 466       // create processes
 467       G4VProcess* aMultipleScattering = new G4MultipleScattering();
 468       G4VProcess* anIonisation = new G4hIonisation();
 469
 470       // add processes
 471       pManager->AddProcess(anIonisation, ordInActive, 2, 2);
 472       pManager->AddProcess(aMultipleScattering);
 473
 474       // set ordering
 475       pManager->SetProcessOrdering(aMultipleScattering, idxAlongStep, 1);
 476       pManager->SetProcessOrdering(aMultipleScattering, idxPostStep, 1);
 477
 478       // map to G3 controls
 479       TG4ProcessControlMap* controlMap = TG4ProcessControlMap::Instance();
 480       controlMap->Add(anIonisation, kLOSS);
 481       controlMap->Add(aMultipleScattering, kMULS);
 482
 483       // map to AliMCProcess codes
 484       TG4ProcessMCMap* mcMap = TG4ProcessMCMap::Instance();
 485       mcMap->Add(anIonisation, kPEnergyLoss);
 486       mcMap->Add(aMultipleScattering, kPMultipleScattering);
 487
 488       // keep for deleting
 489       fOtherProcesses.push_back(aMultipleScattering);
 490       fOtherProcesses.push_back(anIonisation);
 491     }
 492   }
 493 }
 494
 495 //_____________________________________________________________________________
 496 void TG4PhysicsConstructorHadron::ConstructHadProcessForPionPlus()
 497 {
 498 // Construct processes for pi+.
 499 // ---
 500
 501   // add process
 502   G4ProcessManager* pManager = G4PionPlus::PionPlus()->GetProcessManager();
 503   pManager->AddDiscreteProcess(&fElasticProcess);
 504
 505   fLEPionPlusModel = new G4LEPionPlusInelastic();
 506   fHEPionPlusModel = new G4HEPionPlusInelastic();
 507   fPionPlusInelastic.RegisterMe(fLEPionPlusModel);
 508   fPionPlusInelastic.RegisterMe(fHEPionPlusModel);
 509   pManager->AddDiscreteProcess(&fPionPlusInelastic);
 510
 511   // map to G3 controls
 512   TG4ProcessControlMap* controlMap = TG4ProcessControlMap::Instance();
 513   controlMap->Add(&fElasticProcess, kHADR);
 514   controlMap->Add(&fPionPlusInelastic, kHADR);
 515
 516   // map to G3 ALIMCProcess codes
 517   TG4ProcessMCMap* mcMap = TG4ProcessMCMap::Instance();
 518   mcMap->Add(&fElasticProcess, kPHElastic);
 519   mcMap->Add(&fPionPlusInelastic, kPHInhelastic);
 520 }
 521
 522 //_____________________________________________________________________________
 523 void TG4PhysicsConstructorHadron::ConstructHadProcessForPionMinus()
 524 {
 525 // Construct processes for pi-.
 526 // ---
 527
 528   // add process & set ordering
 529   G4ProcessManager* pManager = G4PionMinus::PionMinus()->GetProcessManager();
 530   pManager->AddDiscreteProcess(&fElasticProcess);
 531
 532   fLEPionMinusModel = new G4LEPionMinusInelastic();
 533   fHEPionMinusModel = new G4HEPionMinusInelastic();
 534   fPionMinusInelastic.RegisterMe(fLEPionMinusModel);
 535   fPionMinusInelastic.RegisterMe(fHEPionMinusModel);
 536   pManager->AddDiscreteProcess(&fPionMinusInelastic);
 537
 538   pManager->AddRestProcess(&fPionMinusAbsorption, ordDefault);
 539
 540   // map to G3 controls
 541   TG4ProcessControlMap* controlMap = TG4ProcessControlMap::Instance();
 542   controlMap->Add(&fPionMinusInelastic, kHADR);
 543   controlMap->Add(&fPionMinusAbsorption, kHADR);
 544
 545   // map to G3 ALIMCProcess codes
 546   TG4ProcessMCMap* mcMap = TG4ProcessMCMap::Instance();
 547   mcMap->Add(&fPionMinusInelastic, kPHInhelastic);
 548   mcMap->Add(&fPionMinusAbsorption, kPNuclearAbsorption);
 549 }
 550
 551 //_____________________________________________________________________________
 552 void TG4PhysicsConstructorHadron::ConstructHadProcessForKaonPlus()
 553 {
 554 // Construct processes for K+.
 555 // ---
 556
 557   // add process
 558   G4ProcessManager* pManager = G4KaonPlus::KaonPlus()->GetProcessManager();
 559   pManager->AddDiscreteProcess(&fElasticProcess);
 560
 561   fLEKaonPlusModel = new G4LEKaonPlusInelastic();
 562   fHEKaonPlusModel = new G4HEKaonPlusInelastic();
 563   fKaonPlusInelastic.RegisterMe(fLEKaonPlusModel);
 564   fKaonPlusInelastic.RegisterMe(fHEKaonPlusModel);
 565   pManager->AddDiscreteProcess(&fKaonPlusInelastic);
 566
 567   // map to G3 controls
 568   TG4ProcessControlMap* controlMap = TG4ProcessControlMap::Instance();
 569   controlMap->Add(&fKaonPlusInelastic, kHADR);
 570
 571   // map to G3 ALIMCProcess codes
 572   TG4ProcessMCMap* mcMap = TG4ProcessMCMap::Instance();
 573   mcMap->Add(&fKaonPlusInelastic, kPHInhelastic);
 574 }
 575
 576 //_____________________________________________________________________________
 577 void TG4PhysicsConstructorHadron::ConstructHadProcessForKaonMinus()
 578 {
 579 // Construct processes for K-.
 580 // ---
 581
 582   // add process & set ordering
 583   G4ProcessManager* pManager = G4KaonMinus::KaonMinus()->GetProcessManager();
 584   pManager->AddDiscreteProcess(&fElasticProcess);
 585
 586   fLEKaonMinusModel = new G4LEKaonMinusInelastic();
 587   fHEKaonMinusModel = new G4HEKaonMinusInelastic();
 588   fKaonMinusInelastic.RegisterMe(fLEKaonMinusModel);
 589   fKaonMinusInelastic.RegisterMe(fHEKaonMinusModel);
 590   pManager->AddDiscreteProcess(&fKaonMinusInelastic);
 591
 592   pManager->AddRestProcess(&fKaonMinusAbsorption, ordDefault);
 593
 594   // map to G3 controls
 595   TG4ProcessControlMap* controlMap = TG4ProcessControlMap::Instance();
 596   controlMap->Add(&fKaonMinusInelastic, kHADR);
 597   controlMap->Add(&fKaonMinusAbsorption, kHADR);
 598
 599   // map to G3 ALIMCProcess codes
 600   TG4ProcessMCMap* mcMap = TG4ProcessMCMap::Instance();
 601   mcMap->Add(&fKaonMinusInelastic, kPHInhelastic);
 602   mcMap->Add(&fKaonMinusAbsorption, kPNuclearAbsorption);
 603 }
 604
 605 //_____________________________________________________________________________
 606 void TG4PhysicsConstructorHadron::ConstructHadProcessForKaonZeroLong()
 607 {
 608 // Construct processes for K0L.
 609 // ---
 610
 611   // add process
 612   G4ProcessManager* pManager
 613     = G4KaonZeroLong::KaonZeroLong()->GetProcessManager();
 614   pManager->AddDiscreteProcess(&fElasticProcess);
 615
 616   fLEKaonZeroLModel = new G4LEKaonZeroLInelastic();
 617   fHEKaonZeroLModel = new G4HEKaonZeroInelastic();
 618   fKaonZeroLInelastic.RegisterMe(fLEKaonZeroLModel);
 619   fKaonZeroLInelastic.RegisterMe(fHEKaonZeroLModel);
 620   pManager->AddDiscreteProcess(&fKaonZeroLInelastic);
 621
 622   // map to G3 controls
 623   TG4ProcessControlMap* controlMap = TG4ProcessControlMap::Instance();
 624   controlMap->Add(&fKaonZeroLInelastic, kHADR);
 625
 626   // map to G3 ALIMCProcess codes
 627   TG4ProcessMCMap* mcMap = TG4ProcessMCMap::Instance();
 628   mcMap->Add(&fKaonZeroLInelastic, kPHInhelastic);
 629 }
 630
 631 //_____________________________________________________________________________
 632 void TG4PhysicsConstructorHadron::ConstructHadProcessForKaonZeroShort()
 633 {
 634 // Construct processes for K0S.
 635 // ---
 636
 637   // add process
 638   G4ProcessManager* pManager
 639     = G4KaonZeroShort::KaonZeroShort()->GetProcessManager();
 640   pManager->AddDiscreteProcess(&fElasticProcess);
 641
 642   fLEKaonZeroSModel = new G4LEKaonZeroSInelastic();
 643   fHEKaonZeroSModel = new G4HEKaonZeroInelastic();
 644   fKaonZeroSInelastic.RegisterMe(fLEKaonZeroSModel);
 645   fKaonZeroSInelastic.RegisterMe(fHEKaonZeroSModel);
 646   pManager->AddDiscreteProcess(&fKaonZeroSInelastic);
 647
 648   // map to G3 controls
 649   TG4ProcessControlMap* controlMap = TG4ProcessControlMap::Instance();
 650   controlMap->Add(&fKaonZeroSInelastic, kHADR);
 651
 652   // map to G3 ALIMCProcess codes
 653   TG4ProcessMCMap* mcMap = TG4ProcessMCMap::Instance();
 654   mcMap->Add(&fKaonZeroSInelastic, kPHInhelastic);
 655 }
 656
 657 //_____________________________________________________________________________
 658 void TG4PhysicsConstructorHadron::ConstructHadProcessForProton()
 659 {
 660 // Construct processes for proton.
 661 // ---
 662
 663   // add process
 664   G4ProcessManager* pManager = G4Proton::Proton()->GetProcessManager();
 665   pManager->AddDiscreteProcess(&fElasticProcess);
 666
 667   fLEProtonModel = new G4LEProtonInelastic();
 668   fHEProtonModel = new G4HEProtonInelastic();
 669   fProtonInelastic.RegisterMe(fLEProtonModel);
 670   fProtonInelastic.RegisterMe(fHEProtonModel);
 671   pManager->AddDiscreteProcess(&fProtonInelastic);
 672
 673   // map to G3 controls
 674   TG4ProcessControlMap* controlMap = TG4ProcessControlMap::Instance();
 675   controlMap->Add(&fProtonInelastic, kHADR);
 676
 677   // map to G3 ALIMCProcess codes
 678   TG4ProcessMCMap* mcMap = TG4ProcessMCMap::Instance();
 679   mcMap->Add(&fProtonInelastic, kPHInhelastic);
 680 }
 681
 682 //_____________________________________________________________________________
 683 void TG4PhysicsConstructorHadron::ConstructHadProcessForAntiProton()
 684 {
 685 // Construct processes for anti-proton.
 686 // ---
 687
 688   // add process & set ordering
 689   G4ProcessManager* pManager = G4AntiProton::AntiProton()->GetProcessManager();
 690   pManager->AddDiscreteProcess(&fElasticProcess);
 691
 692   fLEAntiProtonModel = new G4LEAntiProtonInelastic();
 693   fHEAntiProtonModel = new G4HEAntiProtonInelastic();
 694   fAntiProtonInelastic.RegisterMe(fLEAntiProtonModel);
 695   fAntiProtonInelastic.RegisterMe(fHEAntiProtonModel);
 696   pManager->AddDiscreteProcess(&fAntiProtonInelastic);
 697
 698   pManager->AddRestProcess(&fAntiProtonAnnihilation);
 699
 700   // map to G3 controls
 701   TG4ProcessControlMap* controlMap = TG4ProcessControlMap::Instance();
 702   controlMap->Add(&fAntiProtonInelastic, kHADR);
 703   controlMap->Add(&fAntiProtonAnnihilation, kHADR);
 704
 705   // map to G3 ALIMCProcess codes
 706   TG4ProcessMCMap* mcMap = TG4ProcessMCMap::Instance();
 707   mcMap->Add(&fAntiProtonInelastic, kPHInhelastic);
 708   mcMap->Add(&fAntiProtonAnnihilation, kPPbarAnnihilation);
 709 }
 710
 711 //_____________________________________________________________________________
 712 void TG4PhysicsConstructorHadron::ConstructHadProcessForNeutron()
 713 {
 714 // Construct processes for neutron.
 715 // ---
 716
 717   // add process
 718   G4ProcessManager* pManager = G4Neutron::Neutron()->GetProcessManager();
 719   pManager->AddDiscreteProcess(&fElasticProcess);
 720
 721   fLENeutronModel = new G4LENeutronInelastic();
 722   fHENeutronModel = new G4HENeutronInelastic();
 723   fNeutronInelastic.RegisterMe(fLENeutronModel);
 724   fNeutronInelastic.RegisterMe(fHENeutronModel);
 725   pManager->AddDiscreteProcess(&fNeutronInelastic);
 726
 727   //fNeutronFissionModel = new G4LFission();
 728   //fNeutronFission.RegisterMe(fNeutronFissionModel);
 729   //pManager->AddDiscreteProcess(&NeutronFission);
 730
 731   //fNeutronCaptureModel = new G4LCapture();
 732   //fNeutronCapture.RegisterMe(fNeutronCaptureModel);
 733   //pManager->AddDiscreteProcess(&fNeutronCapture);
 734
 735   // map to G3 controls
 736   TG4ProcessControlMap* controlMap = TG4ProcessControlMap::Instance();
 737   controlMap->Add(&fNeutronInelastic, kHADR);
 738
 739   // map to G3 ALIMCProcess codes
 740   TG4ProcessMCMap* mcMap = TG4ProcessMCMap::Instance();
 741   mcMap->Add(&fNeutronInelastic, kPHInhelastic);
 742 }
 743
 744 //_____________________________________________________________________________
 745 void TG4PhysicsConstructorHadron::ConstructHadProcessForAntiNeutron()
 746 {
 747 // Construct processes for anti-neutron.
 748 // ---
 749
 750   // add process
 751   G4ProcessManager* pManager = G4AntiNeutron::AntiNeutron()->GetProcessManager();
 752   pManager->AddDiscreteProcess(&fElasticProcess);
 753
 754   fLEAntiNeutronModel = new G4LEAntiNeutronInelastic();
 755   fHEAntiNeutronModel = new G4HEAntiNeutronInelastic();
 756   fAntiNeutronInelastic.RegisterMe(fLEAntiNeutronModel);
 757   fAntiNeutronInelastic.RegisterMe(fHEAntiNeutronModel);
 758   pManager->AddDiscreteProcess(&fAntiNeutronInelastic);
 759
 760   pManager->AddRestProcess(&fAntiNeutronAnnihilation);
 761
 762   // map to G3 controls
 763   TG4ProcessControlMap* controlMap = TG4ProcessControlMap::Instance();
 764   controlMap->Add(&fAntiNeutronInelastic, kHADR);
 765   controlMap->Add(&fAntiNeutronAnnihilation, kHADR);
 766
 767   // map to G3 ALIMCProcess codes
 768   TG4ProcessMCMap* mcMap = TG4ProcessMCMap::Instance();
 769   mcMap->Add(&fAntiNeutronInelastic, kPHInhelastic);
 770   mcMap->Add(&fAntiNeutronAnnihilation, kPNoProcess);
 771 }
 772
 773 //_____________________________________________________________________________
 774 void TG4PhysicsConstructorHadron::ConstructHadProcessForLambda()
 775 {
 776 // Construct processes for Lambda.
 777 // ---
 778
 779   // add process
 780   G4ProcessManager* pManager = G4Lambda::Lambda()->GetProcessManager();
 781   pManager->AddDiscreteProcess(&fElasticProcess);
 782
 783   fLELambdaModel = new G4LELambdaInelastic();
 784   fHELambdaModel = new G4HELambdaInelastic();
 785   fLambdaInelastic.RegisterMe(fLELambdaModel);
 786   fLambdaInelastic.RegisterMe(fHELambdaModel);
 787   pManager->AddDiscreteProcess(&fLambdaInelastic);
 788
 789   // map to G3 controls
 790   TG4ProcessControlMap* controlMap = TG4ProcessControlMap::Instance();
 791   controlMap->Add(&fLambdaInelastic, kHADR);
 792
 793   // map to G3 ALIMCProcess codes
 794   TG4ProcessMCMap* mcMap = TG4ProcessMCMap::Instance();
 795   mcMap->Add(&fLambdaInelastic, kPHInhelastic);
 796 }
 797
 798 //_____________________________________________________________________________
 799 void TG4PhysicsConstructorHadron::ConstructHadProcessForAntiLambda()
 800 {
 801 // Construct processes for anti-Lambda.
 802 // ---
 803
 804   // add process
 805   G4ProcessManager* pManager = G4AntiLambda::AntiLambda()->GetProcessManager();
 806   pManager->AddDiscreteProcess(&fElasticProcess);
 807
 808   fLEAntiLambdaModel = new G4LEAntiLambdaInelastic();
 809   fHEAntiLambdaModel = new G4HEAntiLambdaInelastic();
 810   fAntiLambdaInelastic.RegisterMe(fLEAntiLambdaModel);
 811   fAntiLambdaInelastic.RegisterMe(fHEAntiLambdaModel);
 812   pManager->AddDiscreteProcess(&fAntiLambdaInelastic);
 813
 814   // map to G3 controls
 815   TG4ProcessControlMap* controlMap = TG4ProcessControlMap::Instance();
 816   controlMap->Add(&fAntiLambdaInelastic, kHADR);
 817
 818   // map to G3 ALIMCProcess codes
 819   TG4ProcessMCMap* mcMap = TG4ProcessMCMap::Instance();
 820   mcMap->Add(&fAntiLambdaInelastic, kPHInhelastic);
 821 }
 822
 823 //_____________________________________________________________________________
 824 void TG4PhysicsConstructorHadron::ConstructHadProcessForSigmaMinus()
 825 {
 826 // Construct processes for Sigma-.
 827 // ---
 828
 829   // add process & set ordering
 830   G4ProcessManager* pManager = G4SigmaMinus::SigmaMinus()->GetProcessManager();
 831   pManager->AddDiscreteProcess(&fElasticProcess);
 832
 833   fLESigmaMinusModel = new G4LESigmaMinusInelastic();
 834   fHESigmaMinusModel = new G4HESigmaMinusInelastic();
 835   fSigmaMinusInelastic.RegisterMe(fLESigmaMinusModel);
 836   fSigmaMinusInelastic.RegisterMe(fHESigmaMinusModel);
 837   pManager->AddDiscreteProcess(&fSigmaMinusInelastic);
 838
 839   // map to G3 controls
 840   TG4ProcessControlMap* controlMap = TG4ProcessControlMap::Instance();
 841   controlMap->Add(&fSigmaMinusInelastic, kHADR);
 842
 843   // map to G3 ALIMCProcess codes
 844   TG4ProcessMCMap* mcMap = TG4ProcessMCMap::Instance();
 845   mcMap->Add(&fSigmaMinusInelastic, kPHInhelastic);
 846 }
 847
 848 //_____________________________________________________________________________
 849 void TG4PhysicsConstructorHadron::ConstructHadProcessForAntiSigmaMinus()
 850 {
 851 // Construct processes for anti-Sigma-.
 852 // ---
 853
 854   // add process & set ordering
 855   G4ProcessManager* pManager
 856     = G4AntiSigmaMinus::AntiSigmaMinus()->GetProcessManager();
 857   pManager->AddDiscreteProcess(&fElasticProcess);
 858
 859   fLEAntiSigmaMinusModel = new G4LEAntiSigmaMinusInelastic();
 860   fHEAntiSigmaMinusModel = new G4HEAntiSigmaMinusInelastic();
 861   fAntiSigmaMinusInelastic.RegisterMe(fLEAntiSigmaMinusModel);
 862   fAntiSigmaMinusInelastic.RegisterMe(fHEAntiSigmaMinusModel);
 863   pManager->AddDiscreteProcess(&fAntiSigmaMinusInelastic);
 864
 865   // map to G3 controls
 866   TG4ProcessControlMap* controlMap = TG4ProcessControlMap::Instance();
 867   controlMap->Add(&fAntiSigmaMinusInelastic, kHADR);
 868
 869   // map to G3 ALIMCProcess codes
 870   TG4ProcessMCMap* mcMap = TG4ProcessMCMap::Instance();
 871   mcMap->Add(&fAntiSigmaMinusInelastic, kPHInhelastic);
 872 }
 873
 874 //_____________________________________________________________________________
 875 void TG4PhysicsConstructorHadron::ConstructHadProcessForSigmaPlus()
 876 {
 877 // Construct processes for Sigma+.
 878 // ---
 879
 880   // add process & set ordering
 881   G4ProcessManager* pManager = G4SigmaPlus::SigmaPlus()->GetProcessManager();
 882   pManager->AddDiscreteProcess(&fElasticProcess);
 883
 884   fLESigmaPlusModel = new G4LESigmaPlusInelastic();
 885   fHESigmaPlusModel = new G4HESigmaPlusInelastic();
 886   fSigmaPlusInelastic.RegisterMe(fLESigmaPlusModel);
 887   fSigmaPlusInelastic.RegisterMe(fHESigmaPlusModel);
 888   pManager->AddDiscreteProcess(&fSigmaPlusInelastic);
 889
 890   // map to G3 controls
 891   TG4ProcessControlMap* controlMap = TG4ProcessControlMap::Instance();
 892   controlMap->Add(&fSigmaPlusInelastic, kHADR);
 893
 894   // map to G3 ALIMCProcess codes
 895   TG4ProcessMCMap* mcMap = TG4ProcessMCMap::Instance();
 896   mcMap->Add(&fSigmaPlusInelastic, kPHInhelastic);
 897 }
 898
 899 //_____________________________________________________________________________
 900 void TG4PhysicsConstructorHadron::ConstructHadProcessForAntiSigmaPlus()
 901 {
 902 // Construct processes for anti-Sigma+.
 903 // ---
 904
 905   // add process & set ordering
 906   G4ProcessManager* pManager
 907     = G4AntiSigmaPlus::AntiSigmaPlus()->GetProcessManager();
 908   pManager->AddDiscreteProcess(&fElasticProcess);
 909
 910   fLEAntiSigmaPlusModel = new G4LEAntiSigmaPlusInelastic();
 911   fHEAntiSigmaPlusModel = new G4HEAntiSigmaPlusInelastic();
 912   fAntiSigmaPlusInelastic.RegisterMe(fLEAntiSigmaPlusModel);
 913   fAntiSigmaPlusInelastic.RegisterMe(fHEAntiSigmaPlusModel);
 914   pManager->AddDiscreteProcess(&fAntiSigmaPlusInelastic);
 915
 916   // map to G3 controls
 917   TG4ProcessControlMap* controlMap = TG4ProcessControlMap::Instance();
 918   controlMap->Add(&fAntiSigmaPlusInelastic, kHADR);
 919
 920   // map to G3 ALIMCProcess codes
 921   TG4ProcessMCMap* mcMap = TG4ProcessMCMap::Instance();
 922   mcMap->Add(&fAntiSigmaPlusInelastic, kPHInhelastic);
 923 }
 924
 925 //_____________________________________________________________________________
 926 void TG4PhysicsConstructorHadron::ConstructHadProcessForXiMinus()
 927 {
 928 // Construct processes for Xi-.
 929 // ---
 930
 931   // add process & set ordering
 932   G4ProcessManager* pManager = G4XiMinus::XiMinus()->GetProcessManager();
 933   pManager->AddDiscreteProcess(&fElasticProcess);
 934
 935   fLEXiMinusModel = new G4LEXiMinusInelastic();
 936   fHEXiMinusModel = new G4HEXiMinusInelastic();
 937   fXiMinusInelastic.RegisterMe(fLEXiMinusModel);
 938   fXiMinusInelastic.RegisterMe(fHEXiMinusModel);
 939   pManager->AddDiscreteProcess(&fXiMinusInelastic);
 940
 941   // map to G3 controls
 942   TG4ProcessControlMap* controlMap = TG4ProcessControlMap::Instance();
 943   controlMap->Add(&fXiMinusInelastic, kHADR);
 944
 945   // map to G3 ALIMCProcess codes
 946   TG4ProcessMCMap* mcMap = TG4ProcessMCMap::Instance();
 947   mcMap->Add(&fXiMinusInelastic, kPHInhelastic);
 948 }
 949
 950 //_____________________________________________________________________________
 951 void TG4PhysicsConstructorHadron::ConstructHadProcessForAntiXiMinus()
 952 {
 953 // Construct processes for anti-Xi-.
 954 // ---
 955
 956   // add process & set ordering
 957   G4ProcessManager* pManager
 958     = G4AntiXiMinus::AntiXiMinus()->GetProcessManager();
 959   pManager->AddDiscreteProcess(&fElasticProcess);
 960
 961   fLEAntiXiMinusModel = new G4LEAntiXiMinusInelastic();
 962   fHEAntiXiMinusModel = new G4HEAntiXiMinusInelastic();
 963   fAntiXiMinusInelastic.RegisterMe(fLEAntiXiMinusModel);
 964   fAntiXiMinusInelastic.RegisterMe(fHEAntiXiMinusModel);
 965   pManager->AddDiscreteProcess(&fAntiXiMinusInelastic);
 966
 967   // map to G3 controls
 968   TG4ProcessControlMap* controlMap = TG4ProcessControlMap::Instance();
 969   controlMap->Add(&fAntiXiMinusInelastic, kHADR);
 970
 971   // map to G3 ALIMCProcess codes
 972   TG4ProcessMCMap* mcMap = TG4ProcessMCMap::Instance();
 973   mcMap->Add(&fAntiXiMinusInelastic, kPHInhelastic);
 974 }
 975
 976 //_____________________________________________________________________________
 977 void TG4PhysicsConstructorHadron::ConstructHadProcessForXiZero()
 978 {
 979 // Construct processes for Xi0.
 980 // ---
 981
 982   // add process
 983   G4ProcessManager* pManager = G4XiZero::XiZero()->GetProcessManager();
 984   pManager->AddDiscreteProcess(&fElasticProcess);
 985
 986   fLEXiZeroModel = new G4LEXiZeroInelastic();
 987   fHEXiZeroModel = new G4HEXiZeroInelastic();
 988   fXiZeroInelastic.RegisterMe(fLEXiZeroModel);
 989   fXiZeroInelastic.RegisterMe(fHEXiZeroModel);
 990   pManager->AddDiscreteProcess(&fXiZeroInelastic);
 991
 992   // map to G3 controls
 993   TG4ProcessControlMap* controlMap = TG4ProcessControlMap::Instance();
 994   controlMap->Add(&fXiZeroInelastic, kHADR);
 995
 996   // map to G3 ALIMCProcess codes
 997   TG4ProcessMCMap* mcMap = TG4ProcessMCMap::Instance();
 998   mcMap->Add(&fXiZeroInelastic, kPHInhelastic);
 999 }
1000
1001 //_____________________________________________________________________________
1002 void TG4PhysicsConstructorHadron::ConstructHadProcessForAntiXiZero()
1003 {
1004 // Construct processes for anti-Xi0.
1005 // ---
1006
1007   // add process
1008   G4ProcessManager* pManager = G4AntiXiZero::AntiXiZero()->GetProcessManager();
1009   pManager->AddDiscreteProcess(&fElasticProcess);
1010
1011   fLEAntiXiZeroModel = new G4LEAntiXiZeroInelastic();
1012   fHEAntiXiZeroModel = new G4HEAntiXiZeroInelastic();
1013   fAntiXiZeroInelastic.RegisterMe(fLEAntiXiZeroModel);
1014   fAntiXiZeroInelastic.RegisterMe(fHEAntiXiZeroModel);
1015   pManager->AddDiscreteProcess(&fAntiXiZeroInelastic);
1016
1017   // map to G3 controls
1018   TG4ProcessControlMap* controlMap = TG4ProcessControlMap::Instance();
1019   controlMap->Add(&fAntiXiZeroInelastic, kHADR);
1020
1021   // map to G3 ALIMCProcess codes
1022   TG4ProcessMCMap* mcMap = TG4ProcessMCMap::Instance();
1023   mcMap->Add(&fAntiXiZeroInelastic, kPHInhelastic);
1024 }
1025
1026 //_____________________________________________________________________________
1027 void TG4PhysicsConstructorHadron::ConstructHadProcessForOmegaMinus()
1028 {
1029 // Construct processes for Omega-.
1030 // ---
1031
1032   // add process & set ordering
1033   G4ProcessManager* pManager = G4OmegaMinus::OmegaMinus()->GetProcessManager();
1034   pManager->AddDiscreteProcess(&fElasticProcess);
1035
1036   fLEOmegaMinusModel = new G4LEOmegaMinusInelastic();
1037   fHEOmegaMinusModel = new G4HEOmegaMinusInelastic();
1038   fOmegaMinusInelastic.RegisterMe(fLEOmegaMinusModel);
1039   fOmegaMinusInelastic.RegisterMe(fHEOmegaMinusModel);
1040   pManager->AddDiscreteProcess(&fOmegaMinusInelastic);
1041
1042   // map to G3 controls
1043   TG4ProcessControlMap* controlMap = TG4ProcessControlMap::Instance();
1044   controlMap->Add(&fOmegaMinusInelastic, kHADR);
1045
1046   // map to G3 ALIMCProcess codes
1047   TG4ProcessMCMap* mcMap = TG4ProcessMCMap::Instance();
1048   mcMap->Add(&fOmegaMinusInelastic, kPHInhelastic);
1049 }
1050
1051 //_____________________________________________________________________________
1052 void TG4PhysicsConstructorHadron::ConstructHadProcessForAntiOmegaMinus()
1053 {
1054 // Construct processes for pi+.
1055 // ---
1056
1057   // add process & set ordering
1058   G4ProcessManager* pManager
1059     = G4AntiOmegaMinus::AntiOmegaMinus()->GetProcessManager();
1060   pManager->AddDiscreteProcess(&fElasticProcess);
1061
1062   fLEAntiOmegaMinusModel = new G4LEAntiOmegaMinusInelastic();
1063   fHEAntiOmegaMinusModel = new G4HEAntiOmegaMinusInelastic();
1064   fAntiOmegaMinusInelastic.RegisterMe(fLEAntiOmegaMinusModel);
1065   fAntiOmegaMinusInelastic.RegisterMe(fHEAntiOmegaMinusModel);
1066   pManager->AddDiscreteProcess(&fAntiOmegaMinusInelastic);
1067
1068   // map to G3 controls
1069   TG4ProcessControlMap* controlMap = TG4ProcessControlMap::Instance();
1070   controlMap->Add(&fAntiOmegaMinusInelastic, kHADR);
1071
1072   // map to G3 ALIMCProcess codes
1073   TG4ProcessMCMap* mcMap = TG4ProcessMCMap::Instance();
1074   mcMap->Add(&fAntiOmegaMinusInelastic, kPHInhelastic);
1075 }
1076
1077 //_____________________________________________________________________________
1078 void TG4PhysicsConstructorHadron::ConstructHadProcessForOther()
1079 {
1080 // Construct processes for other hadrons.
1081 // ---
1082
1083   theParticleIterator->reset();
1084   while( (*theParticleIterator)() ){
1085     G4ParticleDefinition* particle = theParticleIterator->value();
1086     G4ProcessManager* pManager = particle->GetProcessManager();
1087     G4int nofAlongStepProcesses
1088       = pManager->GetAlongStepProcessVector()->length();
1089
1090     if ( !particle->IsShortLived()       &&
1091          particle->GetPDGCharge() != 0.0 &&
1092          nofAlongStepProcesses == 1      &&
1093          particle->GetParticleName() != "chargedgeantino") {
1094
1095       // create processes
1096       G4VProcess* aMultipleScattering = new G4MultipleScattering();
1097       G4VProcess* anIonisation = new G4hIonisation();
1098
1099       // add processes
1100       pManager->AddProcess(anIonisation, ordInActive, 2, 2);
1101       pManager->AddProcess(aMultipleScattering);
1102
1103       // set ordering
1104       pManager->SetProcessOrdering(aMultipleScattering, idxAlongStep, 1);
1105       pManager->SetProcessOrdering(aMultipleScattering, idxPostStep, 1);
1106
1107       // map to G3 controls
1108       TG4ProcessControlMap* controlMap = TG4ProcessControlMap::Instance();
1109       controlMap->Add(anIonisation, kLOSS);
1110       controlMap->Add(aMultipleScattering, kMULS);
1111
1112       // map to AliMCProcess codes
1113       TG4ProcessMCMap* mcMap = TG4ProcessMCMap::Instance();
1114       mcMap->Add(anIonisation, kPEnergyLoss);
1115       mcMap->Add(aMultipleScattering, kPMultipleScattering);
1116
1117       // keep for deleting
1118       fOtherProcesses.push_back(aMultipleScattering);
1119       fOtherProcesses.push_back(anIonisation);
1120     }
1121   }
1122 }
1123
1124
1125 // protected methods
1126
1127 //_____________________________________________________________________________
1128 void TG4PhysicsConstructorHadron::ConstructParticle()
1129 {
1130 // Construct all hadrons.
1131 // ---
1132
1133   //  Construct all mesons
1134   G4MesonConstructor pMesonConstructor;
1135   pMesonConstructor.ConstructParticle();
1136
1137   //  Construct all barions
1138   G4BaryonConstructor pBaryonConstructor;
1139   pBaryonConstructor.ConstructParticle();
1140
1141   //  Construct  resonances and quarks
1142   G4ShortLivedConstructor pShortLivedConstructor;
1143   pShortLivedConstructor.ConstructParticle();
1144 }
1145
1146 //_____________________________________________________________________________
1147 void TG4PhysicsConstructorHadron::ConstructProcess()
1148 {
1149 // Construct all hadronic processes.
1150 // ---
1151   if (fSetHadron) {
1152     // Elastic process
1153     fElasticModel = new G4LElastic();
1154     fElasticProcess.RegisterMe(fElasticModel);
1155
1156     // Hadron processes
1157     ConstructHadProcessForPionPlus();
1158     ConstructHadProcessForPionMinus();
1159     ConstructHadProcessForKaonPlus();
1160     ConstructHadProcessForKaonMinus();
1161     ConstructHadProcessForKaonZeroLong();
1162     ConstructHadProcessForKaonZeroShort();
1163     ConstructHadProcessForProton();
1164     ConstructHadProcessForAntiProton();
1165     ConstructHadProcessForNeutron();
1166     ConstructHadProcessForAntiNeutron();
1167     ConstructHadProcessForLambda();
1168     ConstructHadProcessForAntiLambda();
1169     ConstructHadProcessForSigmaMinus();
1170     ConstructHadProcessForAntiSigmaMinus();
1171     ConstructHadProcessForSigmaPlus();
1172     ConstructHadProcessForAntiSigmaPlus();
1173     ConstructHadProcessForXiMinus();
1174     ConstructHadProcessForAntiXiMinus();
1175     ConstructHadProcessForXiZero();
1176     ConstructHadProcessForAntiXiZero();
1177     ConstructHadProcessForOmegaMinus();
1178     ConstructHadProcessForAntiOmegaMinus();
1179     ConstructHadProcessForOther();
1180   }
1181
1182   if (fSetEM) {
1183     // EM processes
1184     ConstructEMProcessForPionPlus();
1185     ConstructEMProcessForPionMinus();
1186     ConstructEMProcessForKaonPlus();
1187     ConstructEMProcessForKaonMinus();
1188     ConstructEMProcessForProton();
1189     ConstructEMProcessForAntiProton();
1190     ConstructEMProcessForSigmaMinus();
1191     ConstructEMProcessForAntiSigmaMinus();
1192     ConstructEMProcessForSigmaPlus();
1193     ConstructEMProcessForAntiSigmaPlus();
1194     ConstructEMProcessForXiMinus();
1195     ConstructEMProcessForAntiXiMinus();
1196     ConstructEMProcessForOmegaMinus();
1197     ConstructEMProcessForAntiOmegaMinus();
1198     ConstructEMProcessForOther();
1199   }
1200
1201   if (VerboseLevel() > 0) {
1202      G4cout << "### Hadron physics constructed." << G4endl;
1203   }
1204 }
1205