Import Geant4 9.0.0 source tree

examples/advanced/hadrontherapy/src/Decay.cc

@@ -37,36 +37,40 @@
 // 
 // * cirrone@lns.infn.it
 // ----------------------------------------------------------------------------
-#include "HadrontherapyDecay.hh"
-#include "G4ProcessManager.hh"
-#include "globals.hh"
-#include "G4ios.hh"
+#include "Decay.hh"
 #include "G4ParticleDefinition.hh"
 #include "G4ProcessManager.hh"
+#include "G4Decay.hh"
 
-HadrontherapyDecay::HadrontherapyDecay(const G4String& name): G4VPhysicsConstructor(name)
-{ }
 
-HadrontherapyDecay::~HadrontherapyDecay()
-{ }
+Decay::Decay(const G4String& name): 
+  G4VPhysicsConstructor(name)
+{ 
+  G4cout<< "DECAY PROCESS: G4Decay (unstable particles)" 
+        << G4endl;
+}
 
-void HadrontherapyDecay::ConstructProcess()
+Decay::~Decay()
+{}
+
+void Decay::ConstructProcess()
 {
-  // Add Decay Process
-  G4Decay* theDecayProcess = new G4Decay();
+  G4Decay* decayProcess = new G4Decay();
   theParticleIterator -> reset();
 
   while( (*theParticleIterator)() )
     {
       G4ParticleDefinition* particle = theParticleIterator -> value();
-      G4ProcessManager* pmanager = particle -> GetProcessManager();
-      if (theDecayProcess -> IsApplicable(*particle) && !particle->IsShortLived()) 
+      G4ProcessManager* processManager = particle -> GetProcessManager();
+
+      if ( decayProcess -> IsApplicable(*particle) && 
+           !particle -> IsShortLived() ) 
 	{ 
 	  G4String name =  particle -> GetParticleName();
-	  pmanager -> AddProcess(theDecayProcess);
-	  // set ordering for PostStepDoIt and AtRestDoIt
-	  pmanager -> SetProcessOrdering(theDecayProcess, idxPostStep);
-	  pmanager -> SetProcessOrdering(theDecayProcess, idxAtRest);
+	  processManager -> AddProcess(decayProcess);
+	 
+	  processManager -> SetProcessOrdering(decayProcess, idxPostStep);
+	  processManager -> SetProcessOrdering(decayProcess, idxAtRest);
 	}
     }
 }

examples/advanced/hadrontherapy/src/EMElectronEEDL.cc

@@ -38,7 +38,7 @@
 // * cirrone@lns.infn.it
 // --------------------------------------------------------------
 
-#include "HadrontherapyElectronEEDL.hh"
+#include "EMElectronEEDL.hh"
 #include "G4ProcessManager.hh"
 #include "G4ParticleDefinition.hh"
 #include "G4MultipleScattering.hh"
@@ -46,31 +46,41 @@
 #include "G4LowEnergyBremsstrahlung.hh"
 #include "G4StepLimiter.hh"
 
-HadrontherapyElectronEEDL::HadrontherapyElectronEEDL(const G4String& name): G4VPhysicsConstructor(name)
-{ }
 
-HadrontherapyElectronEEDL::~HadrontherapyElectronEEDL()
-{ }
-
-void HadrontherapyElectronEEDL::ConstructProcess()
-{
-  // Add electromagnetic processes for electrons - Low Energy Package, EEDL libraries
-  
-  theParticleIterator->reset();
-
-  while( (*theParticleIterator)() )
-    {
-      G4ParticleDefinition* particle = theParticleIterator -> value();
-      G4ProcessManager* manager = particle -> GetProcessManager();
-      G4String particleName = particle -> GetParticleName();
-     
-      if (particleName == "e-") 
-	{
-	  manager -> AddProcess(new G4MultipleScattering,     -1, 1,1);
-	  manager -> AddProcess(new G4LowEnergyIonisation,    -1, 2,2);
-	  G4LowEnergyBremsstrahlung* brem = new G4LowEnergyBremsstrahlung();
-          manager -> AddProcess(brem,-1,-1,3);
-          manager -> AddProcess(new G4StepLimiter(),          -1,-1, 3);
-	}   
-    }
+EMElectronEEDL::EMElectronEEDL(const G4String& name): 
+   G4VPhysicsConstructor(name)
+{ 
+  G4cout<< "ELECTROMAGNETIC PROCESS(ES): G4MultipleScattering (electron)" 
+        << G4endl
+        << "                             G4LowEnergyIonisation (electron)" 
+        << G4endl
+        << "                             G4LowEnergyBremsstrahlung (electron)" 
+        << G4endl
+        << "APPLIED MODEL(S): -" 
+        << G4endl;
+}
+
+EMElectronEEDL::~EMElectronEEDL()
+{ }
+
+void EMElectronEEDL::ConstructProcess()
+{
+
+  // ****************
+  // *** Electron ***
+  // ****************
+
+  G4MultipleScattering* electronMultipScatProcess = new G4MultipleScattering();
+  G4LowEnergyIonisation* electronIonisationProcess = new G4LowEnergyIonisation();
+  G4LowEnergyBremsstrahlung* electronBremsstrProcess = new G4LowEnergyBremsstrahlung();
+
+  G4StepLimiter* electronStepLimiter = new G4StepLimiter();
+
+  G4ParticleDefinition* particle = G4Electron::Electron(); 
+  G4ProcessManager* processManager = particle -> GetProcessManager();
+  processManager -> AddProcess(electronMultipScatProcess, -1, 1, 1);
+  processManager -> AddProcess(electronIonisationProcess, -1, 2, 2);
+  processManager -> AddProcess(electronBremsstrProcess, -1, -1, 3);
+  processManager -> AddProcess(electronStepLimiter, -1, -1,  3);
+
 }

examples/advanced/hadrontherapy/src/EMElectronPenelope.cc

@@ -38,43 +38,49 @@
 // * cirrone@lns.infn.it
 // --------------------------------------------------------------
 
-#include "HadrontherapyElectronPenelope.hh"
+#include "EMElectronPenelope.hh"
 #include "G4ProcessManager.hh"
 #include "G4ParticleDefinition.hh"
 #include "G4MultipleScattering.hh"
 #include "G4PenelopeIonisation.hh"
 #include "G4PenelopeBremsstrahlung.hh"
-#include "G4PenelopeAnnihilation.hh"
 #include "G4StepLimiter.hh"
 
-HadrontherapyElectronPenelope::HadrontherapyElectronPenelope(const G4String& name): 
-G4VPhysicsConstructor(name)
-{ }
 
-HadrontherapyElectronPenelope::~HadrontherapyElectronPenelope()
-{ }
-
-void HadrontherapyElectronPenelope::ConstructProcess()
-{
-  
-  
-  theParticleIterator->reset();
-
-  while( (*theParticleIterator)() )
-    {
-      G4ParticleDefinition* particle = theParticleIterator -> value();
-      G4ProcessManager* manager = particle -> GetProcessManager();
-      G4String particleName = particle -> GetParticleName();
-     
-      if (particleName == "e-") 
-	{
-	  manager -> AddProcess(new G4MultipleScattering, -1, 1,1);
-	  G4PenelopeIonisation* ioni = new G4PenelopeIonisation();
-   	  G4PenelopeBremsstrahlung* brem = new G4PenelopeBremsstrahlung();
-          manager -> AddProcess(ioni, -1, 2,2);
-	  manager -> AddProcess(brem, -1,-1,3); 
-          manager->AddProcess(new G4MultipleScattering, -1, 1,1);
-          manager->AddProcess(new G4StepLimiter(),      -1,-1,3); 
-	}   
-    }
+EMElectronPenelope::EMElectronPenelope(const G4String& name): 
+   G4VPhysicsConstructor(name)
+{ 
+  G4cout<< "ELECTROMAGNETIC PROCESS(ES): G4MultipleScattering (electron)" 
+        << G4endl
+        << "                             G4PenelopeIonisation (electron)" 
+        << G4endl
+        << "                             G4PenelopeBremsstrahlung (electron)" 
+        << G4endl
+        << "APPLIED MODEL(S): -" 
+        << G4endl;
+}
+
+EMElectronPenelope::~EMElectronPenelope()
+{ }
+
+void EMElectronPenelope::ConstructProcess()
+{
+
+  // ****************
+  // *** Electron ***
+  // ****************
+  
+  G4MultipleScattering* electronMultipScatProcess = new G4MultipleScattering();
+  G4PenelopeIonisation* electronIonisationProcess = new G4PenelopeIonisation();
+  G4PenelopeBremsstrahlung* electronBremsstrProcess = new G4PenelopeBremsstrahlung();
+
+  G4StepLimiter* electronStepLimiter = new G4StepLimiter();
+
+  G4ParticleDefinition* particle = G4Electron::Electron(); 
+  G4ProcessManager* processManager = particle -> GetProcessManager();
+  processManager -> AddProcess(electronMultipScatProcess, -1, 1, 1);
+  processManager -> AddProcess(electronIonisationProcess, -1, 2, 2);
+  processManager -> AddProcess(electronBremsstrProcess, -1, -1, 3);
+  processManager -> AddProcess(electronStepLimiter, -1, -1,  3);
+  
 }

examples/advanced/hadrontherapy/src/EMElectronStandard.cc

@@ -37,38 +37,53 @@
 // * cirrone@lns.infn.it
 // --------------------------------------------------------------
 
-#include "HadrontherapyElectronStandard.hh"
+#include "EMElectronStandard.hh"
 #include "G4ProcessManager.hh"
 #include "G4ParticleDefinition.hh"
 #include "G4MultipleScattering.hh"
 #include "G4eIonisation.hh"
 #include "G4eBremsstrahlung.hh"
 #include "G4StepLimiter.hh"
+#include "G4EmProcessOptions.hh"
 
-HadrontherapyElectronStandard::HadrontherapyElectronStandard(const G4String& name): G4VPhysicsConstructor(name)
-{ }
 
-HadrontherapyElectronStandard::~HadrontherapyElectronStandard()
-{ }
-
-void HadrontherapyElectronStandard::ConstructProcess()
-{
-  // Add standard processes for electrons
-  
-  theParticleIterator -> reset();
-
-  while( (*theParticleIterator)() )
-    {
-      G4ParticleDefinition* particle = theParticleIterator->value();
-      G4ProcessManager* manager = particle->GetProcessManager();
-      G4String particleName = particle->GetParticleName();
-     
-      if (particleName == "e-") 
-	{
-	  manager->AddProcess(new G4MultipleScattering, -1, 1,1);
-	  manager->AddProcess(new G4eIonisation,        -1, 2,2);
-	  manager->AddProcess(new G4eBremsstrahlung,    -1,-1,3); 
-          manager->AddProcess(new G4StepLimiter(),      -1,-1, 3);
-	}   
-    }
+EMElectronStandard::EMElectronStandard(const G4String& name): 
+   G4VPhysicsConstructor(name)
+{ 
+  G4cout<< "ELECTROMAGNETIC PROCESS(ES): G4MultipleScattering (electron)" 
+        << G4endl
+        << "                             G4eIonisation (electron)" 
+        << G4endl
+        << "                             G4eBremsstrahlung (electron)" 
+        << G4endl
+        << "APPLIED MODEL(S): -" 
+        << G4endl;
+}
+
+EMElectronStandard::~EMElectronStandard()
+{ }
+
+void EMElectronStandard::ConstructProcess()
+{
+  
+  // ****************
+  // *** Electron ***
+  // ****************
+
+  G4EmProcessOptions* electronEmProcessOptions = new G4EmProcessOptions();
+  electronEmProcessOptions -> SetDEDXBinning(480);
+
+  G4MultipleScattering* electronMultipScatProcess = new G4MultipleScattering();
+  G4eIonisation* electronIonisationProcess = new G4eIonisation();
+  G4eBremsstrahlung* electronBremsstrProcess = new G4eBremsstrahlung();
+
+  G4StepLimiter* electronStepLimiter = new G4StepLimiter();
+
+  G4ParticleDefinition* particle = G4Electron::Electron(); 
+  G4ProcessManager* processManager = particle -> GetProcessManager();
+  processManager -> AddProcess(electronMultipScatProcess, -1, 1, 1);
+  processManager -> AddProcess(electronIonisationProcess, -1, 2, 2);
+  processManager -> AddProcess(electronBremsstrProcess, -1, -1, 3);
+  processManager -> AddProcess(electronStepLimiter, -1, -1,  3);
+
 }

examples/advanced/hadrontherapy/src/EMHadronIonLowEICRU49.cc

@@ -38,56 +38,67 @@
 // * cirrone@lns.infn.it
 // --------------------------------------------------------------
 
-#include "HadrontherapyIonLowE.hh"
+#include "EMHadronIonLowEICRU49.hh"
 #include "G4ProcessManager.hh"
 #include "G4ParticleDefinition.hh"
 #include "G4MultipleScattering.hh"
 #include "G4hLowEnergyIonisation.hh"
-#include "G4hIonisation.hh"
-#include "G4hLowEnergyLoss.hh"
 #include "G4StepLimiter.hh"
 
-HadrontherapyIonLowE::HadrontherapyIonLowE(const G4String& name): G4VPhysicsConstructor(name)
+
+EMHadronIonLowEICRU49::EMHadronIonLowEICRU49(const G4String& name): 
+   G4VPhysicsConstructor(name)
+{ 
+  G4cout<< "ELECTROMAGNETIC PROCESS(ES): G4MultipleScattering (ions and charged hadrons)" 
+        << G4endl
+        << "                             G4hLowEnergyIonisation (ions and charged hadrons)" 
+        << G4endl
+        << "                             (applying ICRU49 stopping power parametrisations)" 
+        << G4endl
+        << "APPLIED MODEL(S): -" 
+        << G4endl;
+}
+
+EMHadronIonLowEICRU49::~EMHadronIonLowEICRU49()
 { }
 
-HadrontherapyIonLowE::~HadrontherapyIonLowE()
-{ }
-
-void HadrontherapyIonLowE::ConstructProcess()
+void EMHadronIonLowEICRU49::ConstructProcess()
 {
+  G4ParticleDefinition* particle = 0;
+  G4ProcessManager* processManager = 0;
+
+
+  // ********************************
+  // *** Charged Hadrons and Ions ***
+  // ********************************
+
+  G4VProcess* hadronIonMultipleScatProcess = new G4MultipleScattering(); 
+  G4hLowEnergyIonisation* hadronIonIonisationProcess = new G4hLowEnergyIonisation();
+  hadronIonIonisationProcess -> SetNuclearStoppingOn();
+	  
+  G4StepLimiter* hadronIonStepLimiter = new G4StepLimiter();
+
   theParticleIterator -> reset();
 
   while( (*theParticleIterator)() )
     {
-      G4ParticleDefinition* particle = theParticleIterator -> value();
-
-      G4ProcessManager* manager = particle -> GetProcessManager();
-
+      particle = theParticleIterator -> value();
+      processManager = particle -> GetProcessManager();
       G4String particleName = particle -> GetParticleName();
       G4double charge = particle -> GetPDGCharge();
-  
-      // Electromagnetic interactions for protons, pions, generic hadrons
-      // deuteron, triton, alpha particles, He3, ions.
-    
-      if (( charge != 0. ) && particleName != "e+" && particleName != "mu+" &&
-	  particleName != "e-" && particleName != "mu-") 
+      
+      if (charge != 0.0         && 
+          particleName != "e+"  && 
+          particleName != "mu+" &&
+	  particleName != "e-"  && 
+          particleName != "mu-") 
 	{
 	  if((!particle -> IsShortLived()) &&
 	     (particle -> GetParticleName() != "chargedgeantino"))
-	    {
-	      // ***** Ionisation ***** //
-	      // ICRU49 parameterisation is the default option
-              G4hLowEnergyIonisation* ionisation = new G4hLowEnergyIonisation();		
-	      // Set the nuclear stopping power
-	      ionisation -> SetNuclearStoppingOn() ;
-	  
-              // ***** Multiple scattering ***** //
-	      G4VProcess*  multipleScattering = new G4MultipleScattering(); 
-	  
-              // Activate the processes
-	      manager -> AddProcess(multipleScattering, -1,1,1);   
-	      manager -> AddProcess(ionisation, -1,2,2);
-	      manager -> AddProcess(new G4StepLimiter(),-1,-1, 3);
+	    {	  
+              processManager -> AddProcess(hadronIonMultipleScatProcess, -1, 1, 1);   
+	      processManager -> AddProcess(hadronIonIonisationProcess, -1, 2, 2);
+              processManager -> AddProcess(hadronIonStepLimiter, -1, -1, 3);
 	    }
 	}
     }

examples/advanced/hadrontherapy/src/EMHadronIonLowEZiegler1977.cc

@@ -38,63 +38,71 @@
 // * cirrone@lns.infn.it
 // --------------------------------------------------------------
 
-#include "HadrontherapyIonLowEZiegler1977.hh"
+#include "EMHadronIonLowEZiegler1977.hh"
 #include "G4ProcessManager.hh"
 #include "G4ParticleDefinition.hh"
 #include "G4MultipleScattering.hh"
 #include "G4hLowEnergyIonisation.hh"
-#include "G4hIonisation.hh"
-#include "G4hLowEnergyLoss.hh"
 #include "G4StepLimiter.hh"
 #include "G4hZiegler1977p.hh"
 
-HadrontherapyIonLowEZiegler1977::HadrontherapyIonLowEZiegler1977(const G4String& name): G4VPhysicsConstructor(name)
+
+EMHadronIonLowEZiegler1977::EMHadronIonLowEZiegler1977(const G4String& name): 
+   G4VPhysicsConstructor(name)
+{ 
+  G4cout<< "ELECTROMAGNETIC PROCESS(ES): G4MultipleScattering (ions and charged hadrons)" 
+        << G4endl
+        << "                             G4hLowEnergyIonisation (ions and charged hadrons)" 
+        << G4endl
+        << "                             (applying Ziegler77 stopping power parametrisations)" 
+        << G4endl
+        << "APPLIED MODEL(S): -" 
+        << G4endl;
+}
+
+EMHadronIonLowEZiegler1977::~EMHadronIonLowEZiegler1977()
 { }
 
-HadrontherapyIonLowEZiegler1977::~HadrontherapyIonLowEZiegler1977()
-{ }
-
-void HadrontherapyIonLowEZiegler1977::ConstructProcess()
+void EMHadronIonLowEZiegler1977::ConstructProcess()
 {
+  G4ParticleDefinition* particle = 0;
+  G4ProcessManager* processManager = 0;
+
+
+  // ********************************
+  // *** Charged Hadrons and Ions ***
+  // ********************************
+
+  G4VProcess* hadronIonMultipleScatProcess = new G4MultipleScattering(); 
+	  
+  G4StepLimiter* hadronIonStepLimiter = new G4StepLimiter();
+
   theParticleIterator -> reset();
 
   while( (*theParticleIterator)() )
     {
-      G4ParticleDefinition* particle = theParticleIterator -> value();
-      G4ProcessManager* manager = particle -> GetProcessManager();
+      particle = theParticleIterator -> value();
+      processManager = particle -> GetProcessManager();
       G4String particleName = particle -> GetParticleName();
       G4double charge = particle -> GetPDGCharge();
-
-      // protons
-      if (particleName == "proton")
-	{
-         G4hLowEnergyIonisation* ionisation = new G4hLowEnergyIonisation();   
-          // Electronic Stopping Power: Ziegler 1977 parameterisation
-         // Nuclear stopping power: Ziegler 1977   
-         ionisation -> SetElectronicStoppingPowerModel(particle, "Ziegler1977p");
-         ionisation -> SetNuclearStoppingPowerModel("Ziegler1977");
-	 ionisation -> SetNuclearStoppingOn();
-
-         G4VProcess*  multipleScattering = new G4MultipleScattering(); 
-         manager -> AddProcess(multipleScattering, -1,1,1);   
-         manager -> AddProcess(ionisation, -1,2,2);
-	 manager -> AddProcess(new G4StepLimiter(),-1,-1, 3);
-	}
-
-      // ions, alpha, pions, kaons, generic ion.....
-    if (( charge != 0. ) && particleName != "e+" && particleName != "mu+" &&
-	  particleName != "e-" && particleName != "mu-" && particleName != "proton") 
+      
+      if (charge != 0.0         && 
+          particleName != "e+"  && 
+          particleName != "mu+" &&
+	  particleName != "e-"  && 
+          particleName != "mu-") 
 	{
 	  if((!particle -> IsShortLived()) &&
 	     (particle -> GetParticleName() != "chargedgeantino"))
-	    {
-	      G4hLowEnergyIonisation* ionisation = new G4hLowEnergyIonisation();	
-	      ionisation -> SetNuclearStoppingOn() ;
-		 
-	      G4VProcess*  multipleScattering = new G4MultipleScattering(); 
-	      manager -> AddProcess(multipleScattering, -1,1,1);   
-	      manager -> AddProcess(ionisation, -1,2,2);
-	      manager -> AddProcess(new G4StepLimiter(),-1,-1, 3);
+	    {	  
+              G4hLowEnergyIonisation* hadronIonIonisationProcess = new G4hLowEnergyIonisation();
+              hadronIonIonisationProcess -> SetElectronicStoppingPowerModel(particle, "Ziegler1977p");
+              hadronIonIonisationProcess -> SetNuclearStoppingPowerModel("Ziegler1977");
+              hadronIonIonisationProcess -> SetNuclearStoppingOn();
+
+              processManager -> AddProcess(hadronIonMultipleScatProcess, -1, 1, 1);   
+	      processManager -> AddProcess(hadronIonIonisationProcess, -1, 2, 2);
+              processManager -> AddProcess(hadronIonStepLimiter, -1, -1, 3);
 	    }
 	}
     }

examples/advanced/hadrontherapy/src/EMHadronIonLowEZiegler1985.cc

@@ -38,64 +38,72 @@
 // * cirrone@lns.infn.it
 // --------------------------------------------------------------
 
-#include "HadrontherapyIonLowEZiegler1985.hh"
+#include "EMHadronIonLowEZiegler1985.hh"
 #include "G4ProcessManager.hh"
 #include "G4ParticleDefinition.hh"
 #include "G4MultipleScattering.hh"
 #include "G4hLowEnergyIonisation.hh"
 #include "G4hIonisation.hh"
-#include "G4hLowEnergyLoss.hh"
 #include "G4StepLimiter.hh"
 #include "G4hZiegler1985p.hh"
 
-HadrontherapyIonLowEZiegler1985::HadrontherapyIonLowEZiegler1985(const G4String& name): G4VPhysicsConstructor(name)
+
+EMHadronIonLowEZiegler1985::EMHadronIonLowEZiegler1985(const G4String& name): 
+   G4VPhysicsConstructor(name)
+{ 
+  G4cout<< "ELECTROMAGNETIC PROCESS(ES): G4MultipleScattering (ions and charged hadrons)" 
+        << G4endl
+        << "                             G4hLowEnergyIonisation (ions and charged hadrons)" 
+        << G4endl
+        << "                             (applying Ziegler85 stopping power parametrisations)" 
+        << G4endl
+        << "APPLIED MODEL(S): -" 
+        << G4endl;
+}
+
+EMHadronIonLowEZiegler1985::~EMHadronIonLowEZiegler1985()
 { }
 
-HadrontherapyIonLowEZiegler1985::~HadrontherapyIonLowEZiegler1985()
-{ }
-
-void HadrontherapyIonLowEZiegler1985::ConstructProcess()
+void EMHadronIonLowEZiegler1985::ConstructProcess()
 {
+  G4ParticleDefinition* particle = 0;
+  G4ProcessManager* processManager = 0;
+
+
+  // ********************************
+  // *** Charged Hadrons and Ions ***
+  // ********************************
+
+  G4VProcess* hadronIonMultipleScatProcess = new G4MultipleScattering(); 
+	  
+  G4StepLimiter* hadronIonStepLimiter = new G4StepLimiter();
+
   theParticleIterator -> reset();
 
   while( (*theParticleIterator)() )
     {
-      G4ParticleDefinition* particle = theParticleIterator -> value();
-      G4ProcessManager* manager = particle -> GetProcessManager();
+      particle = theParticleIterator -> value();
+      processManager = particle -> GetProcessManager();
       G4String particleName = particle -> GetParticleName();
       G4double charge = particle -> GetPDGCharge();
-
-      // protons
-      if (particleName == "proton")
-	{
-         G4hLowEnergyIonisation* ionisation = new G4hLowEnergyIonisation();   
-         // Electronic Stopping Power: Ziegler 1985 parameterisation
-         // Nuclear stopping power: Ziegler 1985 parameterisation   
-         ionisation -> SetElectronicStoppingPowerModel(particle, "Ziegler1985p");
-         ionisation -> SetNuclearStoppingPowerModel("Ziegler1985");
-	 ionisation -> SetNuclearStoppingOn() ; 
-
-         G4VProcess*  multipleScattering = new G4MultipleScattering(); 
-         manager -> AddProcess(multipleScattering, -1,1,1);   
-         manager -> AddProcess(ionisation, -1,2,2);
-	 manager -> AddProcess(new G4StepLimiter(),-1,-1, 3);
-	}
-
-      // ions, alpha, pions, kaons, generic ions.....
-    if (( charge != 0. ) && (particleName != "e+") && (particleName != "mu+") &&
-	  (particleName != "e-") && (particleName != "mu-") && (particleName != "proton")) 
+      
+      if (charge != 0.0         && 
+          particleName != "e+"  && 
+          particleName != "mu+" &&
+	  particleName != "e-"  && 
+          particleName != "mu-") 
 	{
 	  if((!particle -> IsShortLived()) &&
 	     (particle -> GetParticleName() != "chargedgeantino"))
-	    {
-	      G4hLowEnergyIonisation* ionisation = new G4hLowEnergyIonisation();
-		
-	      ionisation -> SetNuclearStoppingOn() ;
-		 
-	      G4VProcess*  multipleScattering = new G4MultipleScattering(); 
-	      manager -> AddProcess(multipleScattering, -1,1,1);   
-	      manager -> AddProcess(ionisation, -1,2,2);
-	      manager -> AddProcess(new G4StepLimiter(),-1,-1, 3);
+	    {	  
+              G4hLowEnergyIonisation* hadronIonIonisationProcess = new G4hLowEnergyIonisation();
+              hadronIonIonisationProcess -> SetElectronicStoppingPowerModel(particle, "Ziegler1985p");
+              hadronIonIonisationProcess -> SetNuclearStoppingPowerModel("Ziegler1985");
+              hadronIonIonisationProcess -> SetNuclearStoppingOn();
+
+              processManager -> AddProcess(hadronIonMultipleScatProcess, -1, 1, 1);   
+	      processManager -> AddProcess(hadronIonIonisationProcess, -1, 2, 2);
+              processManager -> AddProcess(hadronIonStepLimiter, -1, -1, 3);
 	    }
 	}
     }

examples/advanced/hadrontherapy/src/EMHadronIonStandard.cc

@@ -38,7 +38,7 @@
 // * cirrone@lns.infn.it
 // ----------------------------------------------------------------------------
 
-#include "HadrontherapyIonStandard.hh"
+#include "EMHadronIonStandard.hh"
 #include "G4ProcessManager.hh"
 #include "G4ParticleDefinition.hh"
 #include "G4MultipleScattering.hh"
@@ -46,21 +46,42 @@
 #include "G4ionIonisation.hh"
 #include "G4MultipleScattering.hh"
 #include "G4StepLimiter.hh"
+#include "G4EmProcessOptions.hh"
 
-HadrontherapyIonStandard::HadrontherapyIonStandard(const G4String& name): G4VPhysicsConstructor(name)
+
+EMHadronIonStandard::EMHadronIonStandard(const G4String& name): 
+   G4VPhysicsConstructor(name)
 { }
 
-HadrontherapyIonStandard::~HadrontherapyIonStandard()
+EMHadronIonStandard::~EMHadronIonStandard()
 { }
 
-void HadrontherapyIonStandard::ConstructProcess()
+void EMHadronIonStandard::ConstructProcess()
 {
+  G4ParticleDefinition* particle = 0;
+  G4ProcessManager* processManager = 0;
+
+
+  // ********************************
+  // *** Charged Hadrons and Ions ***
+  // ********************************
+
+  G4EmProcessOptions* hadronIonEmProcessOptions = new G4EmProcessOptions();
+  hadronIonEmProcessOptions -> SetDEDXBinning(480);
+
+  G4VProcess* hadronIonMultipleScatProcess = new G4MultipleScattering(); 
+  G4ionIonisation* ionIonisationProcess = new G4ionIonisation();	  
+  G4hIonisation* hadronIonisationProcess = new G4hIonisation();
+
+  G4StepLimiter* hadronIonStepLimiter = new G4StepLimiter();
+
+
   theParticleIterator -> reset();
 
   while( (*theParticleIterator)() )
     {
-      G4ParticleDefinition* particle = theParticleIterator -> value();
-      G4ProcessManager* manager = particle -> GetProcessManager();
+      particle = theParticleIterator -> value();
+      processManager = particle -> GetProcessManager();
       G4String particleName = particle -> GetParticleName();
       G4double charge = particle -> GetPDGCharge();
   
@@ -68,26 +89,24 @@ void HadrontherapyIonStandard::ConstructProcess()
 	  particleName == "alpha" ||
 	  particleName == "He3")
 	{
-	  G4ionIonisation* ionisation = new G4ionIonisation();
-	  G4VProcess*  multipleScattering = new G4MultipleScattering(); 
-	  manager -> AddProcess(multipleScattering, -1,1,1);   
-	  manager -> AddProcess(ionisation, -1,2,2);
-	  manager -> AddProcess(new G4StepLimiter(),-1,-1, 3);
+	  processManager -> AddProcess(hadronIonMultipleScatProcess, -1, 1, 1);   
+	  processManager -> AddProcess(ionIonisationProcess, -1, 2, 2);
+	  processManager -> AddProcess(hadronIonStepLimiter, -1, -1, 3);
 	}
       else
 	{
-	  //protons, triton, deuteron, pions and other hadrons
-	  if (( charge != 0. ) && particleName != "e+" && particleName != "mu+" &&
-	      particleName != "e-" && particleName != "mu-") 
+	  if (charge != 0.0         && 
+              particleName != "e+"  && 
+              particleName != "mu+" &&
+	      particleName != "e-"  && 
+              particleName != "mu-") 
 	    {
 	      if((!particle -> IsShortLived()) &&
 		 (particle -> GetParticleName() != "chargedgeantino"))
 		{
-		  G4hIonisation* ionisation = new G4hIonisation();
-		  G4VProcess*  multipleScattering = new G4MultipleScattering(); 
-		  manager -> AddProcess(multipleScattering, -1,1,1);   
-		  manager -> AddProcess(ionisation, -1,2,2);
-		  manager -> AddProcess(new G4StepLimiter(),-1,-1, 3);
+		  processManager -> AddProcess(hadronIonMultipleScatProcess, -1, 1, 1);   
+		  processManager -> AddProcess(hadronIonisationProcess, -1, 2, 2);
+		  processManager -> AddProcess(hadronIonStepLimiter, -1, -1, 3);
 		}
 	    }
 	}

examples/advanced/hadrontherapy/src/EMMuonStandard.cc

@@ -0,0 +1,138 @@
+//
+// ********************************************************************
+// * License and Disclaimer                                           *
+// *                                                                  *
+// * The  Geant4 software  is  copyright of the Copyright Holders  of *
+// * the Geant4 Collaboration.  It is provided  under  the terms  and *
+// * conditions of the Geant4 Software License,  included in the file *
+// * LICENSE and available at  http://cern.ch/geant4/license .  These *
+// * include a list of copyright holders.                             *
+// *                                                                  *
+// * Neither the authors of this software system, nor their employing *
+// * institutes,nor the agencies providing financial support for this *
+// * work  make  any representation or  warranty, express or implied, *
+// * regarding  this  software system or assume any liability for its *
+// * use.  Please see the license in the file  LICENSE  and URL above *
+// * for the full disclaimer and the limitation of liability.         *
+// *                                                                  *
+// * This  code  implementation is the result of  the  scientific and *
+// * technical work of the GEANT4 collaboration.                      *
+// * By using,  copying,  modifying or  distributing the software (or *
+// * any work based  on the software)  you  agree  to acknowledge its *
+// * use  in  resulting  scientific  publications,  and indicate your *
+// * acceptance of all terms of the Geant4 Software license.          *
+// ********************************************************************
+//
+// $Id: HadrontherapyMuonStandard.cc; May 2005
+// ----------------------------------------------------------------------------
+//                 GEANT 4 - Hadrontherapy example
+// ----------------------------------------------------------------------------
+// Code developed by:
+//
+// G.A.P. Cirrone(a)*, F. Di Rosa(a), S. Guatelli(b), G. Russo(a)
+// 
+// (a) Laboratori Nazionali del Sud 
+//     of the National Institute for Nuclear Physics, Catania, Italy
+// (b) National Institute for Nuclear Physics Section of Genova, genova, Italy
+// 
+// * cirrone@lns.infn.it
+// ----------------------------------------------------------------------------
+
+#include "EMMuonStandard.hh"
+#include "G4ParticleDefinition.hh"
+#include "G4MuonPlus.hh"
+#include "G4MuonMinus.hh"
+#include "G4ProcessManager.hh"
+#include "G4MultipleScattering.hh"
+#include "G4MuIonisation.hh"
+#include "G4MuBremsstrahlung.hh"
+#include "G4MuPairProduction.hh"
+#include "G4StepLimiter.hh"
+#include "G4EmProcessOptions.hh"
+
+
+EMMuonStandard::EMMuonStandard(const G4String& name): 
+   G4VPhysicsConstructor(name)
+{ 
+  G4cout<< "ELECTROMAGNETIC PROCESS(ES): G4MultipleScattering (muon+/-)" 
+        << G4endl
+        << "                             G4MuIonisation (muon+/-)" 
+        << G4endl
+        << "                             G4MuBremsstrahlung (muon+/-)" 
+        << G4endl
+        << "                             G4MuPairProduction (muon+/-)" 
+        << G4endl
+        << "APPLIED MODEL(S): -" 
+        << G4endl;
+}
+
+EMMuonStandard::~EMMuonStandard()
+{ }
+
+void EMMuonStandard::ConstructProcess()
+{
+  G4ParticleDefinition* particle = 0;
+  G4ProcessManager* processManager = 0;
+
+
+  // ***********************************
+  // *** Muon+/-: Common Definitions ***
+  // ***********************************
+
+  G4EmProcessOptions* muonEmProcessOptions = new G4EmProcessOptions;
+  muonEmProcessOptions -> SetDEDXBinning(480);
+
+  G4MultipleScattering* muonMultipleScatteringProcess = new G4MultipleScattering();
+  G4MuIonisation* muonIonisationProcess = new G4MuIonisation();
+  G4MuBremsstrahlung* muonBremsstrahlungProcess = new G4MuBremsstrahlung();
+  G4MuPairProduction* muonPairProductionProcess = new G4MuPairProduction();
+
+  G4StepLimiter* muonStepLimiter = new G4StepLimiter();
+
+
+  // *************
+  // *** Muon+ ***
+  // *************
+
+  particle = G4MuonPlus::MuonPlus(); 
+  processManager = particle -> GetProcessManager();
+  processManager -> AddProcess(muonMultipleScatteringProcess);
+  processManager -> AddProcess(muonIonisationProcess);
+  processManager -> AddProcess(muonBremsstrahlungProcess);
+  processManager -> AddProcess(muonPairProductionProcess);
+  processManager -> AddProcess(muonStepLimiter, -1, -1, 3);
+ 
+  processManager -> SetProcessOrdering(muonMultipleScatteringProcess, idxAlongStep,1);
+  processManager -> SetProcessOrdering(muonIonisationProcess,         idxAlongStep,2);
+  processManager -> SetProcessOrdering(muonBremsstrahlungProcess,     idxAlongStep,3);
+  processManager -> SetProcessOrdering(muonPairProductionProcess,     idxAlongStep,4);      
+	  
+  processManager -> SetProcessOrdering(muonMultipleScatteringProcess, idxPostStep,1);
+  processManager -> SetProcessOrdering(muonIonisationProcess,         idxPostStep,2);
+  processManager -> SetProcessOrdering(muonBremsstrahlungProcess,     idxPostStep,3);
+  processManager -> SetProcessOrdering(muonPairProductionProcess,     idxPostStep,4);
+
+
+  // *************
+  // *** Muon- ***
+  // *************
+
+  particle = G4MuonMinus::MuonMinus(); 
+  processManager = particle -> GetProcessManager();
+  processManager -> AddProcess(muonMultipleScatteringProcess);
+  processManager -> AddProcess(muonIonisationProcess);
+  processManager -> AddProcess(muonBremsstrahlungProcess);
+  processManager -> AddProcess(muonPairProductionProcess);
+  processManager -> AddProcess(muonStepLimiter, -1, -1, 3);
+ 
+  processManager -> SetProcessOrdering(muonMultipleScatteringProcess, idxAlongStep,1);
+  processManager -> SetProcessOrdering(muonIonisationProcess,         idxAlongStep,2);
+  processManager -> SetProcessOrdering(muonBremsstrahlungProcess,     idxAlongStep,3);
+  processManager -> SetProcessOrdering(muonPairProductionProcess,     idxAlongStep,4);      
+	  
+  processManager -> SetProcessOrdering(muonMultipleScatteringProcess, idxPostStep,1);
+  processManager -> SetProcessOrdering(muonIonisationProcess,         idxPostStep,2);
+  processManager -> SetProcessOrdering(muonBremsstrahlungProcess,     idxPostStep,3);
+  processManager -> SetProcessOrdering(muonPairProductionProcess,     idxPostStep,4);
+ 
+}

examples/advanced/hadrontherapy/src/EMPhotonEPDL.cc

@@ -37,41 +37,56 @@
 // 
 // * cirrone@lns.infn.it
 // ----------------------------------------------------------------------------
-#include "HadrontherapyPhotonEPDL.hh"
+
+#include "EMPhotonEPDL.hh"
 #include "G4ProcessManager.hh"
 #include "G4ParticleDefinition.hh"
+#include "G4Gamma.hh"
 #include "G4LowEnergyCompton.hh"
 #include "G4LowEnergyGammaConversion.hh"
 #include "G4LowEnergyPhotoElectric.hh"
 #include "G4LowEnergyRayleigh.hh"
 #include "G4StepLimiter.hh"
 
-HadrontherapyPhotonEPDL::HadrontherapyPhotonEPDL(const G4String& name): G4VPhysicsConstructor(name)
-{ }
 
-HadrontherapyPhotonEPDL::~HadrontherapyPhotonEPDL()
-{ }
-
-void HadrontherapyPhotonEPDL::ConstructProcess()
-{
-  // Add electromagnetic processes for photons, Low Energy Package,
-  // model based on EPDL Libraries
-  
-  theParticleIterator -> reset();
-
-  while( (*theParticleIterator)() )
-    {
-      G4ParticleDefinition* particle = theParticleIterator -> value();
-      G4ProcessManager* manager = particle -> GetProcessManager();
-      G4String particleName = particle -> GetParticleName();
-     
-      if (particleName == "gamma") 
-	{
-	  manager -> AddDiscreteProcess(new G4LowEnergyPhotoElectric);
-	  manager -> AddDiscreteProcess(new G4LowEnergyCompton);
-	  manager -> AddDiscreteProcess(new G4LowEnergyGammaConversion);
-	  manager -> AddDiscreteProcess(new G4LowEnergyRayleigh);
-          manager -> AddProcess(new G4StepLimiter(),-1,-1, 3);
-	}   
-    }
+EMPhotonEPDL::EMPhotonEPDL(const G4String& name): 
+   G4VPhysicsConstructor(name)
+{ 
+  G4cout<< "ELECTROMAGNETIC PROCESS(ES): G4LowEnergyPhotoElectric (photon)" 
+        << G4endl
+        << "                             G4LowEnergyCompton (photon)" 
+        << G4endl
+        << "                             G4LowEnergyGammaConversion (photon)" 
+        << G4endl
+        << "                             G4LowEnergyRayleigh (photon)" 
+        << G4endl
+        << "APPLIED MODEL(S): -" 
+        << G4endl;
+}
+
+EMPhotonEPDL::~EMPhotonEPDL()
+{ }
+
+void EMPhotonEPDL::ConstructProcess()
+{
+
+  // **************
+  // *** Photon ***
+  // **************
+  
+  G4LowEnergyPhotoElectric* photonPhotoElectricProcess = new G4LowEnergyPhotoElectric();
+  G4LowEnergyCompton* photonComptonProcess = new G4LowEnergyCompton;
+  G4LowEnergyGammaConversion* photonGammaConvProcess = new G4LowEnergyGammaConversion;
+  G4LowEnergyRayleigh* photonRayleighProcess = new G4LowEnergyRayleigh;
+
+  G4StepLimiter* photonStepLimiter = new G4StepLimiter();
+
+  G4ParticleDefinition* particle = G4Gamma::Gamma(); 
+  G4ProcessManager* processManager = particle -> GetProcessManager();
+  processManager -> AddDiscreteProcess(photonPhotoElectricProcess);
+  processManager -> AddDiscreteProcess(photonComptonProcess);
+  processManager -> AddDiscreteProcess(photonGammaConvProcess);
+  processManager -> AddDiscreteProcess(photonRayleighProcess);
+  processManager -> AddProcess(photonStepLimiter, -1, -1,  3);
+
 }

examples/advanced/hadrontherapy/src/EMPhotonPenelope.cc

@@ -38,40 +38,57 @@
 // * cirrone@lns.infn.it
 // ----------------------------------------------------------------------------
 
-#include "HadrontherapyPhotonPenelope.hh"
+#include "EMPhotonPenelope.hh"
 #include "G4ProcessManager.hh"
 #include "G4ParticleDefinition.hh"
+#include "G4Gamma.hh"
 #include "G4PenelopeCompton.hh"
 #include "G4PenelopeGammaConversion.hh"
 #include "G4PenelopePhotoElectric.hh"
 #include "G4PenelopeRayleigh.hh"
 #include "G4StepLimiter.hh"
 
-HadrontherapyPhotonPenelope::HadrontherapyPhotonPenelope(const G4String& name): G4VPhysicsConstructor(name)
+
+EMPhotonPenelope::EMPhotonPenelope(const G4String& name): 
+   G4VPhysicsConstructor(name)
+{ 
+  G4cout<< "ELECTROMAGNETIC PROCESS(ES): G4PenelopePhotoElectric (photon)" 
+        << G4endl
+        << "                             G4PenelopeCompton (photon)" 
+        << G4endl
+        << "                             G4PenelopeGammaConversion (photon)" 
+        << G4endl
+        << "                             G4PenelopeRayleigh (photon)" 
+        << G4endl
+        << "APPLIED MODEL(S): -" 
+        << G4endl;
+}
+
+EMPhotonPenelope::~EMPhotonPenelope()
 { }
 
-HadrontherapyPhotonPenelope::~HadrontherapyPhotonPenelope()
-{ }
-
-void HadrontherapyPhotonPenelope::ConstructProcess()
+void EMPhotonPenelope::ConstructProcess()
 {
-  theParticleIterator -> reset();
 
-  while( (*theParticleIterator)() )
-    {
-      G4ParticleDefinition* particle = theParticleIterator -> value();
-      G4ProcessManager* manager = particle -> GetProcessManager();
-      G4String particleName = particle -> GetParticleName();
-     
-      if (particleName == "gamma") 
-	{
-	  manager -> AddDiscreteProcess(new G4PenelopePhotoElectric);
-	  manager -> AddDiscreteProcess(new G4PenelopeCompton);
-	  manager -> AddDiscreteProcess(new G4PenelopeGammaConversion);
-	  manager -> AddDiscreteProcess(new G4PenelopeRayleigh);
-          manager -> AddProcess(new G4StepLimiter(),-1,-1, 3);
-	}   
-    }
+  // **************
+  // *** Photon ***
+  // **************
+  
+  G4PenelopePhotoElectric* photonPhotoElectricProcess = new G4PenelopePhotoElectric();
+  G4PenelopeCompton* photonComptonProcess = new G4PenelopeCompton;
+  G4PenelopeGammaConversion* photonGammaConvProcess = new G4PenelopeGammaConversion;
+  G4PenelopeRayleigh* photonRayleighProcess = new G4PenelopeRayleigh;
+
+  G4StepLimiter* photonStepLimiter = new G4StepLimiter();
+
+  G4ParticleDefinition* particle = G4Gamma::Gamma(); 
+  G4ProcessManager* processManager = particle -> GetProcessManager();
+  processManager -> AddDiscreteProcess(photonPhotoElectricProcess);
+  processManager -> AddDiscreteProcess(photonComptonProcess);
+  processManager -> AddDiscreteProcess(photonGammaConvProcess);
+  processManager -> AddDiscreteProcess(photonRayleighProcess);
+  processManager -> AddProcess(photonStepLimiter, -1, -1,  3);
+
 }
 
 

examples/advanced/hadrontherapy/src/EMPhotonStandard.cc

@@ -0,0 +1,91 @@
+//
+// ********************************************************************
+// * License and Disclaimer                                           *
+// *                                                                  *
+// * The  Geant4 software  is  copyright of the Copyright Holders  of *
+// * the Geant4 Collaboration.  It is provided  under  the terms  and *
+// * conditions of the Geant4 Software License,  included in the file *
+// * LICENSE and available at  http://cern.ch/geant4/license .  These *
+// * include a list of copyright holders.                             *
+// *                                                                  *
+// * Neither the authors of this software system, nor their employing *
+// * institutes,nor the agencies providing financial support for this *
+// * work  make  any representation or  warranty, express or implied, *
+// * regarding  this  software system or assume any liability for its *
+// * use.  Please see the license in the file  LICENSE  and URL above *
+// * for the full disclaimer and the limitation of liability.         *
+// *                                                                  *
+// * This  code  implementation is the result of  the  scientific and *
+// * technical work of the GEANT4 collaboration.                      *
+// * By using,  copying,  modifying or  distributing the software (or *
+// * any work based  on the software)  you  agree  to acknowledge its *
+// * use  in  resulting  scientific  publications,  and indicate your *
+// * acceptance of all terms of the Geant4 Software license.          *
+// ********************************************************************
+//
+// $Id: HadrontherapyPhotonStandard.cc; May 2005
+// ----------------------------------------------------------------------------
+//                 GEANT 4 - Hadrontherapy example
+// ----------------------------------------------------------------------------
+// Code developed by:
+//
+// G.A.P. Cirrone(a)*, F. Di Rosa(a), S. Guatelli(b), G. Russo(a)
+// 
+// (a) Laboratori Nazionali del Sud 
+//     of the National Institute for Nuclear Physics, Catania, Italy
+// (b) National Institute for Nuclear Physics Section of Genova, genova, Italy
+// 
+// * cirrone@lns.infn.it
+// ----------------------------------------------------------------------------
+
+#include "EMPhotonStandard.hh"
+#include "G4ProcessManager.hh"
+#include "G4ParticleDefinition.hh"
+#include "G4Gamma.hh"
+#include "G4ComptonScattering.hh"
+#include "G4GammaConversion.hh"
+#include "G4PhotoElectricEffect.hh"
+#include "G4StepLimiter.hh"
+#include "G4EmProcessOptions.hh"
+
+
+EMPhotonStandard::EMPhotonStandard(const G4String& name): 
+   G4VPhysicsConstructor(name)
+{ 
+  G4cout<< "ELECTROMAGNETIC PROCESS(ES): G4PhotoElectricEffect (photon)" 
+        << G4endl
+        << "                             G4ComptonScattering (photon)" 
+        << G4endl
+        << "                             G4GammaConversion (photon)" 
+        << G4endl
+        << "APPLIED MODEL(S): -" 
+        << G4endl;
+}
+
+EMPhotonStandard::~EMPhotonStandard()
+{ }
+
+void EMPhotonStandard::ConstructProcess()
+{
+
+  // **************
+  // *** Photon ***
+  // **************
+
+  G4EmProcessOptions* photonEmProcessOptions = new G4EmProcessOptions();
+  photonEmProcessOptions -> SetDEDXBinning(480);
+   
+  G4PhotoElectricEffect* photonPhotoElectricProcess = new G4PhotoElectricEffect();
+  G4ComptonScattering* photonComptonProcess = new G4ComptonScattering;
+  G4GammaConversion* photonGammaConvProcess = new G4GammaConversion;
+
+  G4StepLimiter* photonStepLimiter = new G4StepLimiter();
+
+  G4ParticleDefinition* particle = G4Gamma::Gamma(); 
+  G4ProcessManager* processManager = particle -> GetProcessManager();
+  processManager -> AddDiscreteProcess(photonPhotoElectricProcess);
+  processManager -> AddDiscreteProcess(photonComptonProcess);
+  processManager -> AddDiscreteProcess(photonGammaConvProcess);
+  processManager -> AddProcess(photonStepLimiter, -1, -1,  3);
+
+}

examples/advanced/hadrontherapy/src/EMPositronPenelope.cc

@@ -38,7 +38,7 @@
 // * cirrone@lns.infn.it
 // ----------------------------------------------------------------------------
 
-#include "HadrontherapyPositronPenelope.hh"
+#include "EMPositronPenelope.hh"
 #include "G4ProcessManager.hh"
 #include "G4ParticleDefinition.hh"
 #include "G4MultipleScattering.hh"
@@ -47,30 +47,45 @@
 #include "G4PenelopeAnnihilation.hh"
 #include "G4StepLimiter.hh"
 
-HadrontherapyPositronPenelope::HadrontherapyPositronPenelope(const G4String& name): 
+
+EMPositronPenelope::EMPositronPenelope(const G4String& name): 
   G4VPhysicsConstructor(name)
-{ }
-
-HadrontherapyPositronPenelope::~HadrontherapyPositronPenelope()
-{ }
-
-void HadrontherapyPositronPenelope::ConstructProcess()
-{
-  theParticleIterator->reset();
-
-  while( (*theParticleIterator)() )
-    {
-      G4ParticleDefinition* particle = theParticleIterator->value();
-      G4ProcessManager* manager = particle->GetProcessManager();
-      G4String particleName = particle->GetParticleName();
-     
-      if (particleName == "e+") 
-	{
-	  manager -> AddProcess(new G4MultipleScattering,    -1, 1,1);
-          manager -> AddProcess(new G4PenelopeIonisation,    -1, 2,2);
-	  manager -> AddProcess(new G4PenelopeBremsstrahlung,-1,-1,3);  
-          manager -> AddProcess(new G4PenelopeAnnihilation,   0,-1,4); 
-          manager -> AddProcess(new G4StepLimiter(),         -1,-1,3);
-	}   
-    }
+{ 
+  G4cout<< "ELECTROMAGNETIC PROCESS(ES): G4MultipleScattering (positron)" 
+        << G4endl
+        << "                             G4PenelopeIonisation (positron)" 
+        << G4endl
+        << "                             G4PenelopeBremsstrahlung (positron)" 
+        << G4endl
+        << "                             G4PenelopeAnnihilation (positron)" 
+        << G4endl
+        << "APPLIED MODEL(S): -" 
+        << G4endl;
+}
+
+EMPositronPenelope::~EMPositronPenelope()
+{ }
+
+void EMPositronPenelope::ConstructProcess()
+{
+
+  // ****************
+  // *** Positron ***
+  // ****************
+
+  G4MultipleScattering* positronMultipScatProcess = new G4MultipleScattering();
+  G4PenelopeIonisation* positronIonisationProcess = new G4PenelopeIonisation();
+  G4PenelopeBremsstrahlung* positronBremsstrProcess = new G4PenelopeBremsstrahlung();
+  G4PenelopeAnnihilation* positronAnnihilationProcess = new G4PenelopeAnnihilation();
+
+  G4StepLimiter* positronStepLimiter = new G4StepLimiter();
+
+  G4ParticleDefinition* particle = G4Positron::Positron(); 
+  G4ProcessManager* processManager = particle -> GetProcessManager();
+  processManager -> AddProcess(positronMultipScatProcess, -1, 1, 1);
+  processManager -> AddProcess(positronIonisationProcess, -1, 2, 2);
+  processManager -> AddProcess(positronBremsstrProcess, -1, -1, 3);
+  processManager -> AddProcess(positronAnnihilationProcess, 0, -1, 4);
+  processManager -> AddProcess(positronStepLimiter, -1, -1,  3);
+
 }

examples/advanced/hadrontherapy/src/EMPositronStandard.cc

@@ -37,7 +37,8 @@
 // 
 // * cirrone@lns.infn.it
 // ----------------------------------------------------------------------------
-#include "HadrontherapyPositronStandard.hh"
+
+#include "EMPositronStandard.hh"
 #include "G4ProcessManager.hh"
 #include "G4ParticleDefinition.hh"
 #include "G4MultipleScattering.hh"
@@ -45,32 +46,50 @@
 #include "G4eBremsstrahlung.hh"
 #include "G4eplusAnnihilation.hh"
 #include "G4StepLimiter.hh"
+#include "G4EmProcessOptions.hh"
 
-HadrontherapyPositronStandard::HadrontherapyPositronStandard(const G4String& name): G4VPhysicsConstructor(name)
-{ }
 
-HadrontherapyPositronStandard::~HadrontherapyPositronStandard()
-{ }
-
-void HadrontherapyPositronStandard::ConstructProcess()
-{
-  // Add standard processes for positrons
-  
-  theParticleIterator -> reset();
-
-  while( (*theParticleIterator)() )
-    {
-      G4ParticleDefinition* particle = theParticleIterator -> value();
-      G4ProcessManager* manager = particle -> GetProcessManager();
-      G4String particleName = particle -> GetParticleName();
-     
-      if (particleName == "e+") 
-	{
-	  manager -> AddProcess(new G4MultipleScattering, -1, 1,1);
-	  manager -> AddProcess(new G4eIonisation,        -1, 2,2);
-	  manager -> AddProcess(new G4eBremsstrahlung,    -1,-1,3);
-	  manager -> AddProcess(new G4eplusAnnihilation,   0,-1,4); 
-          manager -> AddProcess(new G4StepLimiter(),      -1,-1,3);
-	}   
-    }
+EMPositronStandard::EMPositronStandard(const G4String& name): 
+   G4VPhysicsConstructor(name)
+{ 
+  G4cout<< "ELECTROMAGNETIC PROCESS(ES): G4MultipleScattering (positron)" 
+        << G4endl
+        << "                             G4eIonisation (positron)" 
+        << G4endl
+        << "                             G4eBremsstrahlung (positron)" 
+        << G4endl
+        << "                             G4eplusAnnihilation (positron)" 
+        << G4endl
+        << "APPLIED MODEL(S): -" 
+        << G4endl;
+}
+
+EMPositronStandard::~EMPositronStandard()
+{ }
+
+void EMPositronStandard::ConstructProcess()
+{
+
+  // ****************
+  // *** Positron ***
+  // ****************
+
+  G4EmProcessOptions* positronEmProcessOptions = new G4EmProcessOptions();
+  positronEmProcessOptions -> SetDEDXBinning(480);
+
+  G4MultipleScattering* positronMultipScatProcess = new G4MultipleScattering();
+  G4eIonisation* positronIonisationProcess = new G4eIonisation();
+  G4eBremsstrahlung* positronBremsstrProcess = new G4eBremsstrahlung();
+  G4eplusAnnihilation* positronAnnihilationProcess = new G4eplusAnnihilation();
+
+  G4StepLimiter* positronStepLimiter = new G4StepLimiter();
+
+  G4ParticleDefinition* particle = G4Positron::Positron(); 
+  G4ProcessManager* processManager = particle -> GetProcessManager();
+  processManager -> AddProcess(positronMultipScatProcess, -1, 1, 1);
+  processManager -> AddProcess(positronIonisationProcess, -1, 2, 2);
+  processManager -> AddProcess(positronBremsstrProcess, -1, -1, 3);
+  processManager -> AddProcess(positronAnnihilationProcess, 0, -1, 4);
+  processManager -> AddProcess(positronStepLimiter, -1, -1,  3);
+
 }

examples/advanced/hadrontherapy/src/HEHadronIonBertiniElastic.cc

@@ -0,0 +1,121 @@
+//
+// ********************************************************************
+// * License and Disclaimer                                           *
+// *                                                                  *
+// * The  Geant4 software  is  copyright of the Copyright Holders  of *
+// * the Geant4 Collaboration.  It is provided  under  the terms  and *
+// * conditions of the Geant4 Software License,  included in the file *
+// * LICENSE and available at  http://cern.ch/geant4/license .  These *
+// * include a list of copyright holders.                             *
+// *                                                                  *
+// * Neither the authors of this software system, nor their employing *
+// * institutes,nor the agencies providing financial support for this *
+// * work  make  any representation or  warranty, express or implied, *
+// * regarding  this  software system or assume any liability for its *
+// * use.  Please see the license in the file  LICENSE  and URL above *
+// * for the full disclaimer and the limitation of liability.         *
+// *                                                                  *
+// * This  code  implementation is the result of  the  scientific and *
+// * technical work of the GEANT4 collaboration.                      *
+// * By using,  copying,  modifying or  distributing the software (or *
+// * any work based  on the software)  you  agree  to acknowledge its *
+// * use  in  resulting  scientific  publications,  and indicate your *
+// * acceptance of all terms of the Geant4 Software license.          *
+// ********************************************************************
+//
+// $Id: HadrontherapyHadronBertiniElastic.cc; May 2005
+// ----------------------------------------------------------------------------
+//                 GEANT 4 - Hadrontherapy example
+// ----------------------------------------------------------------------------
+// Code developed by:
+//
+// G.A.P. Cirrone(a)*, F. Di Rosa(a), S. Guatelli(b), G. Russo(a)
+// 
+// (a) Laboratori Nazionali del Sud 
+//     of the INFN, Catania, Italy
+// (b) INFN Section of Genova, Genova, Italy
+// 
+// * cirrone@lns.infn.it
+// ----------------------------------------------------------------------------
+
+#include "HEHadronIonBertiniElastic.hh"
+#include "G4ParticleDefinition.hh"
+#include "G4ProcessManager.hh"
+#include "G4LElastic.hh"
+#include "G4HadronElasticProcess.hh"
+#include "G4CascadeElasticInterface.hh"
+
+
+HEHadronIonBertiniElastic::HEHadronIonBertiniElastic(const G4String& name): 
+  G4VPhysicsConstructor(name)
+{
+  G4cout<< "HADRONIC ELASTIC PROCESS(ES): G4HadronElasticProcess (all considere hadrons and ions)" 
+        << G4endl
+        << "APPLIED MODEL(S): G4CascadeElasticInterface (hadrons)" 
+        << G4endl
+        << "                  G4LElastic (ions)" 
+        << G4endl;
+}
+
+HEHadronIonBertiniElastic::~HEHadronIonBertiniElastic()
+{}
+
+void HEHadronIonBertiniElastic::ConstructProcess()
+{
+  G4ParticleDefinition* particle = 0;
+  G4ProcessManager* processManager = 0;
+
+
+  // **********************************************
+  // *** Proton, Neutron, Pion plus, Pion minus ***
+  // **********************************************
+
+  G4HadronElasticProcess* hadronElasticProcess = new G4HadronElasticProcess();
+  G4CascadeElasticInterface* hadronBertiniElasticModel = new G4CascadeElasticInterface;
+  hadronElasticProcess -> RegisterMe(hadronBertiniElasticModel);
+
+  particle = G4Proton::Proton();
+  processManager = particle -> GetProcessManager();
+  processManager -> AddDiscreteProcess(hadronElasticProcess); 
+
+  particle = G4Neutron::Neutron();
+  processManager = particle -> GetProcessManager();
+  processManager -> AddDiscreteProcess(hadronElasticProcess); 
+  
+  particle = G4PionPlus::PionPlus(); 
+  processManager = particle -> GetProcessManager();
+  processManager -> AddDiscreteProcess(hadronElasticProcess);
+ 
+  particle = G4PionMinus::PionMinus();
+  processManager = particle -> GetProcessManager();
+  processManager -> AddDiscreteProcess(hadronElasticProcess); 
+
+ 
+  // *******************************
+  // *** Deuteron, Triton, Alpha ***
+  // *******************************
+
+  G4HadronElasticProcess* ionElasticProcess = new G4HadronElasticProcess();
+  G4LElastic* ionLElasticModel = new G4LElastic();
+  ionElasticProcess -> RegisterMe(ionLElasticModel);
+
+  particle = G4Deuteron::Deuteron();
+  processManager = particle -> GetProcessManager();
+  processManager -> AddDiscreteProcess(ionElasticProcess); 
+ 
+  particle = G4Triton::Triton();
+  processManager = particle -> GetProcessManager();
+  processManager -> AddDiscreteProcess(ionElasticProcess);
+
+  particle = G4Alpha::Alpha();
+  processManager = particle -> GetProcessManager();
+  processManager -> AddDiscreteProcess(ionElasticProcess); 
+
+  // particle = G4He3::He3();
+  // processManager = particle -> GetProcessManager();
+  // processManager -> AddDiscreteProcess(ionElasticProcess); 
+
+}
+
+
+

examples/advanced/hadrontherapy/src/HEHadronIonLElastic.cc

@@ -0,0 +1,110 @@
+//
+// ********************************************************************
+// * License and Disclaimer                                           *
+// *                                                                  *
+// * The  Geant4 software  is  copyright of the Copyright Holders  of *
+// * the Geant4 Collaboration.  It is provided  under  the terms  and *
+// * conditions of the Geant4 Software License,  included in the file *
+// * LICENSE and available at  http://cern.ch/geant4/license .  These *
+// * include a list of copyright holders.                             *
+// *                                                                  *
+// * Neither the authors of this software system, nor their employing *
+// * institutes,nor the agencies providing financial support for this *
+// * work  make  any representation or  warranty, express or implied, *
+// * regarding  this  software system or assume any liability for its *
+// * use.  Please see the license in the file  LICENSE  and URL above *
+// * for the full disclaimer and the limitation of liability.         *
+// *                                                                  *
+// * This  code  implementation is the result of  the  scientific and *
+// * technical work of the GEANT4 collaboration.                      *
+// * By using,  copying,  modifying or  distributing the software (or *
+// * any work based  on the software)  you  agree  to acknowledge its *
+// * use  in  resulting  scientific  publications,  and indicate your *
+// * acceptance of all terms of the Geant4 Software license.          *
+// ********************************************************************
+//
+// $Id: HadrontherapyHadronElastic.cc; May 2005
+// ----------------------------------------------------------------------------
+//                 GEANT 4 - Hadrontherapy example
+// ----------------------------------------------------------------------------
+// Code developed by:
+//
+// G.A.P. Cirrone(a)*, F. Di Rosa(a), S. Guatelli(b), G. Russo(a)
+// 
+// (a) Laboratori Nazionali del Sud 
+//     of the INFN, Catania, Italy
+// (b) INFN Section of Genova, Genova, Italy
+// 
+// * cirrone@lns.infn.it
+// ----------------------------------------------------------------------------
+
+#include "HEHadronIonLElastic.hh"
+#include "G4ParticleDefinition.hh"
+#include "G4ProcessManager.hh"
+#include "G4LElastic.hh"
+#include "G4HadronElasticProcess.hh"
+
+
+HEHadronIonLElastic::HEHadronIonLElastic(const G4String& name): 
+  G4VPhysicsConstructor(name)
+{
+  G4cout<< "HADRONIC ELASTIC PROCESS(ES): G4HadronElasticProcess (all considered hadrons and ions)" 
+        << G4endl
+        << "APPLIED MODEL(S): G4LElastic" 
+        << G4endl;
+}
+
+HEHadronIonLElastic::~HEHadronIonLElastic()
+{}
+
+void HEHadronIonLElastic::ConstructProcess()
+{
+  G4ParticleDefinition* particle = 0;
+  G4ProcessManager* processManager = 0;
+
+
+  // **********************************************
+  // *** Proton, Neutron, Pion plus, Pion minus ***
+  // *** Deuteron, Triton, Alpha                ***
+  // **********************************************
+ 
+  G4HadronElasticProcess* hadronIonElasticProcess = new G4HadronElasticProcess();
+  G4LElastic* hadronIonLElasticModel = new G4LElastic();
+  hadronIonElasticProcess -> RegisterMe(hadronIonLElasticModel); 
+
+  particle = G4Proton::Proton();
+  processManager = particle -> GetProcessManager();
+  processManager -> AddDiscreteProcess(hadronIonElasticProcess); 
+
+  particle = G4Neutron::Neutron();
+  processManager = particle -> GetProcessManager();
+  processManager -> AddDiscreteProcess(hadronIonElasticProcess); 
+
+  particle = G4PionPlus::PionPlus(); 
+  processManager = particle -> GetProcessManager();
+  processManager -> AddDiscreteProcess(hadronIonElasticProcess);
+
+  particle = G4PionMinus::PionMinus();
+  processManager = particle -> GetProcessManager();
+  processManager -> AddDiscreteProcess(hadronIonElasticProcess); 
+
+  particle = G4Deuteron::Deuteron();
+  processManager = particle -> GetProcessManager();
+  processManager -> AddDiscreteProcess(hadronIonElasticProcess); 
+
+  particle = G4Triton::Triton();
+  processManager = particle -> GetProcessManager();
+  processManager -> AddDiscreteProcess(hadronIonElasticProcess);
+
+  particle = G4Alpha::Alpha();
+  processManager = particle -> GetProcessManager();
+  processManager -> AddDiscreteProcess(hadronIonElasticProcess); 
+
+  // particle = G4He3::He3();
+  // processManager = particle -> GetProcessManager();
+  // processManager -> AddDiscreteProcess(hadronIonElasticProcess); 
+
+}
+
+
+

examples/advanced/hadrontherapy/src/HEHadronIonQElastic.cc

@@ -0,0 +1,118 @@
+//
+// ********************************************************************
+// * License and Disclaimer                                           *
+// *                                                                  *
+// * The  Geant4 software  is  copyright of the Copyright Holders  of *
+// * the Geant4 Collaboration.  It is provided  under  the terms  and *
+// * conditions of the Geant4 Software License,  included in the file *
+// * LICENSE and available at  http://cern.ch/geant4/license .  These *
+// * include a list of copyright holders.                             *
+// *                                                                  *
+// * Neither the authors of this software system, nor their employing *
+// * institutes,nor the agencies providing financial support for this *
+// * work  make  any representation or  warranty, express or implied, *
+// * regarding  this  software system or assume any liability for its *
+// * use.  Please see the license in the file  LICENSE  and URL above *
+// * for the full disclaimer and the limitation of liability.         *
+// *                                                                  *
+// * This  code  implementation is the result of  the  scientific and *
+// * technical work of the GEANT4 collaboration.                      *
+// * By using,  copying,  modifying or  distributing the software (or *
+// * any work based  on the software)  you  agree  to acknowledge its *
+// * use  in  resulting  scientific  publications,  and indicate your *
+// * acceptance of all terms of the Geant4 Software license.          *
+// ********************************************************************
+//
+// $Id: HadrontherapyHadronCHIPSElastic.cc; May 2005
+// ----------------------------------------------------------------------------
+//                 GEANT 4 - Hadrontherapy example
+// ----------------------------------------------------------------------------
+// Code developed by:
+//
+// G.A.P. Cirrone(a)*, F. Di Rosa(a), S. Guatelli(b), G. Russo(a)
+// 
+// (a) Laboratori Nazionali del Sud 
+//     of the INFN, Catania, Italy
+// (b) INFN Section of Genova, Genova, Italy
+// 
+// * cirrone@lns.infn.it
+// ----------------------------------------------------------------------------
+
+#include "HEHadronIonQElastic.hh"
+#include "G4ParticleDefinition.hh"
+#include "G4ProcessManager.hh"
+#include "G4LElastic.hh"
+#include "G4HadronElasticProcess.hh"
+#include "G4QElastic.hh"
+
+
+HEHadronIonQElastic::HEHadronIonQElastic(const G4String& name): 
+  G4VPhysicsConstructor(name)
+{
+  G4cout<< "HADRONIC ELASTIC PROCESS(ES): G4QElastic (protons, neutrons)" 
+        << G4endl
+        << "                              G4HadronElasticProcess (pions, considered ions)" 
+        << "APPLIED MODEL(S): G4LElastic (pions, considered ions)" 
+        << G4endl;
+}
+
+HEHadronIonQElastic::~HEHadronIonQElastic()
+{}
+
+void HEHadronIonQElastic::ConstructProcess()
+{
+  G4ParticleDefinition* particle = 0;
+  G4ProcessManager* processManager = 0;
+
+
+  // ***********************
+  // *** Proton, Neutron ***
+  // ***********************
+ 
+  G4QElastic* protonNeutronElasticProcess = new G4QElastic();
+
+  particle = G4Proton::Proton();
+  processManager = particle -> GetProcessManager();
+  processManager -> AddDiscreteProcess(protonNeutronElasticProcess); 
+
+  particle = G4Neutron::Neutron();
+  processManager = particle -> GetProcessManager();
+  processManager -> AddDiscreteProcess(protonNeutronElasticProcess); 
+ 
+
+  // ***************************************
+  // *** Pion plus, Pion minus, Deuteron ***
+  // *** Triton, Alpha                   ***
+  // ***************************************
+
+  G4HadronElasticProcess* pionIonElasticProcess = new G4HadronElasticProcess();
+  G4LElastic* pionIonLElasticModel = new G4LElastic();
+  pionIonElasticProcess -> RegisterMe(pionIonLElasticModel);
+ 
+  particle = G4PionPlus::PionPlus(); 
+  processManager = particle -> GetProcessManager();
+  processManager -> AddDiscreteProcess(pionIonElasticProcess);
+
+  particle = G4PionMinus::PionMinus();
+  processManager = particle -> GetProcessManager();
+  processManager -> AddDiscreteProcess(pionIonElasticProcess); 
+
+  particle = G4Deuteron::Deuteron();
+  processManager = particle -> GetProcessManager();
+  processManager -> AddDiscreteProcess(pionIonElasticProcess); 
+
+  particle = G4Triton::Triton();
+  processManager = particle -> GetProcessManager();
+  processManager -> AddDiscreteProcess(pionIonElasticProcess);
+
+  particle = G4Alpha::Alpha();
+  processManager = particle -> GetProcessManager();
+  processManager -> AddDiscreteProcess(pionIonElasticProcess); 
+
+  // particle = G4He3::He3();
+  // processManager = particle -> GetProcessManager();
+  // processManager -> AddDiscreteProcess(pionIonElasticProcess); 
+}
+
+
+

examples/advanced/hadrontherapy/src/HEHadronIonUElastic.cc

@@ -0,0 +1,113 @@
+//
+// ********************************************************************
+// * License and Disclaimer                                           *
+// *                                                                  *
+// * The  Geant4 software  is  copyright of the Copyright Holders  of *
+// * the Geant4 Collaboration.  It is provided  under  the terms  and *
+// * conditions of the Geant4 Software License,  included in the file *
+// * LICENSE and available at  http://cern.ch/geant4/license .  These *
+// * include a list of copyright holders.                             *
+// *                                                                  *
+// * Neither the authors of this software system, nor their employing *
+// * institutes,nor the agencies providing financial support for this *
+// * work  make  any representation or  warranty, express or implied, *
+// * regarding  this  software system or assume any liability for its *
+// * use.  Please see the license in the file  LICENSE  and URL above *
+// * for the full disclaimer and the limitation of liability.         *
+// *                                                                  *
+// * This  code  implementation is the result of  the  scientific and *
+// * technical work of the GEANT4 collaboration.                      *
+// * By using,  copying,  modifying or  distributing the software (or *
+// * any work based  on the software)  you  agree  to acknowledge its *
+// * use  in  resulting  scientific  publications,  and indicate your *
+// * acceptance of all terms of the Geant4 Software license.          *
+// ********************************************************************
+//
+// $Id: HadrontherapyHadronUElastic.cc; May 2005
+// ----------------------------------------------------------------------------
+//                 GEANT 4 - Hadrontherapy example
+// ----------------------------------------------------------------------------
+// Code developed by:
+//
+// G.A.P. Cirrone(a)*, F. Di Rosa(a), S. Guatelli(b), G. Russo(a)
+// 
+// (a) Laboratori Nazionali del Sud 
+//     of the INFN, Catania, Italy
+// (b) INFN Section of Genova, Genova, Italy
+// 
+// * cirrone@lns.infn.it
+// ----------------------------------------------------------------------------
+
+#include "HEHadronIonUElastic.hh"
+#include "G4ParticleDefinition.hh"
+#include "G4ProcessManager.hh"
+#include "G4UHadronElasticProcess.hh"
+#include "G4HadronElastic.hh"
+#include "G4VQCrossSection.hh"
+
+
+HEHadronIonUElastic::HEHadronIonUElastic(const G4String& name): 
+   G4VPhysicsConstructor(name)
+{
+  G4cout<< "HADRONIC ELASTIC PROCESS(ES): G4UHadronElasticProcess (all considered hadrons and ions)" 
+        << G4endl
+        << "APPLIED MODEL(S): G4HadronElastic" 
+        << G4endl;
+ 
+  model = 0;
+}
+
+HEHadronIonUElastic::~HEHadronIonUElastic()
+{
+  delete model;
+}
+
+void HEHadronIonUElastic::ConstructProcess()
+{
+  G4ParticleDefinition* particle = 0;
+  G4ProcessManager* processManager = 0;
+
+  // **********************************************
+  // *** Proton, Neutron, Pion plus, Pion minus ***
+  // *** Deuteron, Triton, Alpha                ***
+  // **********************************************
+
+  G4UHadronElasticProcess* hadronIonElasticProcess = new G4UHadronElasticProcess("elasticProcess", false);     
+  
+  G4double hadronIonElasticMinEnergy = 0. * keV;
+  G4double hadronIonElasticMaxEnergy = 100. * TeV;
+
+  G4HadronElastic* hadronIonElasticModel = new G4HadronElastic();
+  hadronIonElasticModel -> SetMinEnergy(hadronIonElasticMinEnergy);
+  hadronIonElasticModel -> SetMaxEnergy(hadronIonElasticMaxEnergy);
+
+  G4VQCrossSection* hadronIonElasticCrossSection = hadronIonElasticModel->GetCS();
+
+  hadronIonElasticProcess -> SetQElasticCrossSection(hadronIonElasticCrossSection);
+  hadronIonElasticProcess -> RegisterMe(hadronIonElasticModel);
+
+  theParticleIterator -> reset();
+
+  while( (*theParticleIterator)() )
+  {
+    particle = theParticleIterator -> value();
+    G4String particleName = particle -> GetParticleName();
+
+    if(particleName == "neutron"   || 
+       particleName == "pi-"       || 
+       particleName == "pi+"       || 
+       particleName == "proton"    || 
+       particleName == "alpha"     ||
+       particleName == "deuteron"  ||
+       particleName == "triton") 
+      
+      {
+	processManager = particle -> GetProcessManager();
+	processManager -> AddDiscreteProcess(hadronIonElasticProcess);
+      } 
+  }
+
+}
+
+
+

examples/advanced/hadrontherapy/src/HIIonLEP.cc

@@ -0,0 +1,138 @@
+//
+// ********************************************************************
+// * License and Disclaimer                                           *
+// *                                                                  *
+// * The  Geant4 software  is  copyright of the Copyright Holders  of *
+// * the Geant4 Collaboration.  It is provided  under  the terms  and *
+// * conditions of the Geant4 Software License,  included in the file *
+// * LICENSE and available at  http://cern.ch/geant4/license .  These *
+// * include a list of copyright holders.                             *
+// *                                                                  *
+// * Neither the authors of this software system, nor their employing *
+// * institutes,nor the agencies providing financial support for this *
+// * work  make  any representation or  warranty, express or implied, *
+// * regarding  this  software system or assume any liability for its *
+// * use.  Please see the license in the file  LICENSE  and URL above *
+// * for the full disclaimer and the limitation of liability.         *
+// *                                                                  *
+// * This  code  implementation is the result of  the  scientific and *
+// * technical work of the GEANT4 collaboration.                      *
+// * By using,  copying,  modifying or  distributing the software (or *
+// * any work based  on the software)  you  agree  to acknowledge its *
+// * use  in  resulting  scientific  publications,  and indicate your *
+// * acceptance of all terms of the Geant4 Software license.          *
+// ********************************************************************
+//
+// $Id: HadrontherapyProtonPrecompound.cc; May 2005
+// ----------------------------------------------------------------------------
+//                 GEANT 4 - Hadrontherapy example
+// ----------------------------------------------------------------------------
+// Code developed by:
+//
+// G.A.P. Cirrone(a)*, F. Di Rosa(a), S. Guatelli(b), G. Russo(a)
+// 
+// (a) Laboratori Nazionali del Sud 
+//     of the INFN, Catania, Italy
+// (b) INFN Section of Genova, Genova, Italy
+// 
+// * cirrone@lns.infn.it
+// ----------------------------------------------------------------------------
+
+#include "HIIonLEP.hh"
+#include "G4ParticleDefinition.hh"
+#include "G4ProcessManager.hh"
+#include "G4TripathiCrossSection.hh"
+#include "G4IonsShenCrossSection.hh"
+#include "G4DeuteronInelasticProcess.hh"
+#include "G4TritonInelasticProcess.hh"
+#include "G4AlphaInelasticProcess.hh"
+#include "G4LEDeuteronInelastic.hh"
+#include "G4LETritonInelastic.hh"
+#include "G4LEAlphaInelastic.hh"
+
+
+HIIonLEP::HIIonLEP(const G4String& name): 
+  G4VPhysicsConstructor(name)
+{
+  G4cout<< "HADRONIC INELASTIC PROCESS(ES): G4XXXInelasticProcess (all ions)" 
+        << G4endl
+        << "APPLIED MODEL(S): G4LEXXXInelastic" 
+        << G4endl;
+}
+
+HIIonLEP::~HIIonLEP()
+{}
+
+void HIIonLEP::ConstructProcess()
+{
+  G4ParticleDefinition* particle = 0;
+  G4ProcessManager* processManager = 0;
+
+   
+  // ***************************************************
+  // *** Deuteron, Triton, Alpha: Common Definitions ***
+  // ***************************************************
+
+  G4TripathiCrossSection* ionTripathiCrossSection = new G4TripathiCrossSection;
+  G4IonsShenCrossSection* ionShenCrossSection = new G4IonsShenCrossSection;
+
+  G4double ionLEPMaxEnergy = 100. * MeV;
+
+
+  // ****************
+  // *** Deuteron ***
+  // ****************
+
+  G4DeuteronInelasticProcess* deuteronInelasticProcess = new G4DeuteronInelasticProcess;
+
+  G4LEDeuteronInelastic* deuteronLEPModel = new G4LEDeuteronInelastic;
+  deuteronLEPModel -> SetMaxEnergy(ionLEPMaxEnergy);
+
+  deuteronInelasticProcess -> AddDataSet(ionTripathiCrossSection);
+  deuteronInelasticProcess -> AddDataSet(ionShenCrossSection);
+  deuteronInelasticProcess -> RegisterMe(deuteronLEPModel);
+
+  particle = G4Deuteron::Deuteron();
+  processManager = particle -> GetProcessManager();
+  processManager -> AddDiscreteProcess(deuteronInelasticProcess);
+
+
+  // **************
+  // *** Triton ***
+  // **************
+
+  G4TritonInelasticProcess* tritonInelasticProcess = new G4TritonInelasticProcess;
+  
+  G4LETritonInelastic* tritonLEPModel = new G4LETritonInelastic;
+  tritonLEPModel -> SetMaxEnergy(ionLEPMaxEnergy);
+
+  tritonInelasticProcess -> AddDataSet(ionTripathiCrossSection);
+  tritonInelasticProcess -> AddDataSet(ionShenCrossSection);
+  tritonInelasticProcess -> RegisterMe(tritonLEPModel);
+
+  particle = G4Triton::Triton();
+  processManager = particle -> GetProcessManager();
+  processManager -> AddDiscreteProcess(tritonInelasticProcess);
+ 
+
+  // *************
+  // *** Alpha ***
+  // *************
+
+  G4AlphaInelasticProcess* alphaInelasticProcess = new G4AlphaInelasticProcess;
+
+  G4LEAlphaInelastic* alphaLEPModel = new G4LEAlphaInelastic;
+  alphaLEPModel -> SetMaxEnergy(ionLEPMaxEnergy);
+ 
+  alphaInelasticProcess -> AddDataSet(ionTripathiCrossSection);
+  alphaInelasticProcess -> AddDataSet(ionShenCrossSection);
+  alphaInelasticProcess -> RegisterMe(alphaLEPModel);
+ 
+  particle = G4Alpha::Alpha();
+  processManager = particle -> GetProcessManager();
+  processManager -> AddDiscreteProcess(alphaInelasticProcess);
+  
+}
+
+
+

examples/advanced/hadrontherapy/src/HIPionBertini.cc

@@ -0,0 +1,112 @@
+//
+// ********************************************************************
+// * License and Disclaimer                                           *
+// *                                                                  *
+// * The  Geant4 software  is  copyright of the Copyright Holders  of *
+// * the Geant4 Collaboration.  It is provided  under  the terms  and *
+// * conditions of the Geant4 Software License,  included in the file *
+// * LICENSE and available at  http://cern.ch/geant4/license .  These *
+// * include a list of copyright holders.                             *
+// *                                                                  *
+// * Neither the authors of this software system, nor their employing *
+// * institutes,nor the agencies providing financial support for this *
+// * work  make  any representation or  warranty, express or implied, *
+// * regarding  this  software system or assume any liability for its *
+// * use.  Please see the license in the file  LICENSE  and URL above *
+// * for the full disclaimer and the limitation of liability.         *
+// *                                                                  *
+// * This  code  implementation is the result of  the  scientific and *
+// * technical work of the GEANT4 collaboration.                      *
+// * By using,  copying,  modifying or  distributing the software (or *
+// * any work based  on the software)  you  agree  to acknowledge its *
+// * use  in  resulting  scientific  publications,  and indicate your *
+// * acceptance of all terms of the Geant4 Software license.          *
+// ********************************************************************
+//
+// $Id: HadrontherapyProtonLEP.cc; May 2005
+// ----------------------------------------------------------------------------
+//                 GEANT 4 - Hadrontherapy example
+// ----------------------------------------------------------------------------
+// Code developed by:
+//
+// G.A.P. Cirrone(a)*, F. Di Rosa(a), S. Guatelli(b), G. Russo(a)
+// 
+// (a) Laboratori Nazionali del Sud 
+//     of the INFN, Catania, Italy
+// (b) INFN Section of Genova, Genova, Italy
+// 
+// * cirrone@lns.infn.it
+// ----------------------------------------------------------------------------
+
+#include "HIPionBertini.hh"
+#include "G4ParticleDefinition.hh"
+#include "G4ProcessManager.hh"
+#include "G4PionPlusInelasticProcess.hh"
+#include "G4PionMinusInelasticProcess.hh"
+#include "G4CascadeInterface.hh"
+#include "G4PiNuclearCrossSection.hh" 
+
+
+HIPionBertini::HIPionBertini(const G4String& name): 
+  G4VPhysicsConstructor(name)
+{
+  G4cout<< "HADRONIC INELASTIC PROCESS(ES): G4PionXXXInelasticProcess (pions+/-)" 
+        << G4endl
+        << "APPLIED MODEL(S): G4CascadeInterface" 
+        << G4endl;
+}
+
+HIPionBertini::~HIPionBertini()
+{}
+
+void HIPionBertini::ConstructProcess()
+{
+  G4ParticleDefinition* particle = 0;
+  G4ProcessManager* processManager = 0;
+
+
+  // ***********************************
+  // *** Pion+/-: Common Definitions ***
+  // ***********************************
+
+  G4PiNuclearCrossSection* pionNuclearCrossSection = new G4PiNuclearCrossSection();
+
+  G4double pionBertiniMinEnergy = 0. * MeV;
+  G4double pionBertiniMaxEnergy = 100. * MeV;
+
+  G4CascadeInterface* pionBertiniElasticModel = new G4CascadeInterface; 
+  pionBertiniElasticModel -> SetMinEnergy(pionBertiniMinEnergy);
+  pionBertiniElasticModel -> SetMaxEnergy(pionBertiniMaxEnergy);
+
+
+  // *************
+  // *** Pion+ ***
+  // *************
+
+  G4PionPlusInelasticProcess* pionPlusInelasticProcess = new G4PionPlusInelasticProcess("inelastic");
+
+  pionPlusInelasticProcess -> AddDataSet(pionNuclearCrossSection);
+  pionPlusInelasticProcess -> RegisterMe(pionBertiniElasticModel);
+ 
+  particle = G4PionPlus::PionPlus(); 
+  processManager = particle -> GetProcessManager();
+  processManager -> AddDiscreteProcess(pionPlusInelasticProcess);
+ 
+ 
+  // **************
+  // *** Pion-  ***
+  // **************
+
+  G4PionMinusInelasticProcess* pionMinusInelasticProcess = new G4PionMinusInelasticProcess("inelastic");
+
+  pionMinusInelasticProcess -> AddDataSet(pionNuclearCrossSection);
+  pionMinusInelasticProcess -> RegisterMe(pionBertiniElasticModel);
+
+  particle = G4PionMinus::PionMinus();
+  processManager = particle -> GetProcessManager();
+  processManager -> AddDiscreteProcess(pionMinusInelasticProcess);
+
+}
+
+
+

examples/advanced/hadrontherapy/src/HIPionLEP.cc

@@ -0,0 +1,119 @@
+//
+// ********************************************************************
+// * License and Disclaimer                                           *
+// *                                                                  *
+// * The  Geant4 software  is  copyright of the Copyright Holders  of *
+// * the Geant4 Collaboration.  It is provided  under  the terms  and *
+// * conditions of the Geant4 Software License,  included in the file *
+// * LICENSE and available at  http://cern.ch/geant4/license .  These *
+// * include a list of copyright holders.                             *
+// *                                                                  *
+// * Neither the authors of this software system, nor their employing *
+// * institutes,nor the agencies providing financial support for this *
+// * work  make  any representation or  warranty, express or implied, *
+// * regarding  this  software system or assume any liability for its *
+// * use.  Please see the license in the file  LICENSE  and URL above *
+// * for the full disclaimer and the limitation of liability.         *
+// *                                                                  *
+// * This  code  implementation is the result of  the  scientific and *
+// * technical work of the GEANT4 collaboration.                      *
+// * By using,  copying,  modifying or  distributing the software (or *
+// * any work based  on the software)  you  agree  to acknowledge its *
+// * use  in  resulting  scientific  publications,  and indicate your *
+// * acceptance of all terms of the Geant4 Software license.          *
+// ********************************************************************
+//
+// $Id: HadrontherapyProtonLEP.cc; May 2005
+// ----------------------------------------------------------------------------
+//                 GEANT 4 - Hadrontherapy example
+// ----------------------------------------------------------------------------
+// Code developed by:
+//
+// G.A.P. Cirrone(a)*, F. Di Rosa(a), S. Guatelli(b), G. Russo(a)
+// 
+// (a) Laboratori Nazionali del Sud 
+//     of the INFN, Catania, Italy
+// (b) INFN Section of Genova, Genova, Italy
+// 
+// * cirrone@lns.infn.it
+// ----------------------------------------------------------------------------
+
+#include "HIPionLEP.hh"
+#include "G4ParticleDefinition.hh"
+#include "G4ProcessManager.hh"
+#include "G4PionPlusInelasticProcess.hh"
+#include "G4PionMinusInelasticProcess.hh"
+#include "G4LEPionPlusInelastic.hh"
+#include "G4LEPionMinusInelastic.hh"
+#include "G4PiMinusAbsorptionAtRest.hh"
+#include "G4PiNuclearCrossSection.hh" 
+
+
+HIPionLEP::HIPionLEP(const G4String& name): 
+  G4VPhysicsConstructor(name)
+{
+  G4cout<< "HADRONIC INELASTIC PROCESS(ES): G4PionXXXInelasticProcess (pions+/-)" 
+        << G4endl
+        << "APPLIED MODEL(S): G4LEPionXXXInelastic" 
+        << G4endl;
+}
+
+HIPionLEP::~HIPionLEP()
+{}
+
+void HIPionLEP::ConstructProcess()
+{
+  G4ParticleDefinition* particle = 0;
+  G4ProcessManager* processManager = 0;
+
+
+  // ***********************************
+  // *** Pion+/-: Common Definitions ***
+  // ***********************************
+
+  G4double pionLEPMinEnergy = 0. * MeV;
+  G4double pionLEPMaxEnergy = 100. * MeV;
+
+  G4PiNuclearCrossSection* pionNuclearCrossSection = new G4PiNuclearCrossSection();
+
+  // *************
+  // *** Pion+ ***
+  // *************
+
+  G4PionPlusInelasticProcess* pionPlusInelasticProcess = new G4PionPlusInelasticProcess("inelastic");
+
+  G4LEPionPlusInelastic* pionPlusLEPModel = new G4LEPionPlusInelastic();
+  pionPlusLEPModel -> SetMinEnergy(pionLEPMinEnergy);
+  pionPlusLEPModel -> SetMaxEnergy(pionLEPMaxEnergy);
+
+  pionPlusInelasticProcess -> AddDataSet(pionNuclearCrossSection);
+  pionPlusInelasticProcess -> RegisterMe(pionPlusLEPModel);
+ 
+  particle = G4PionPlus::PionPlus(); 
+  processManager = particle -> GetProcessManager();
+  processManager -> AddDiscreteProcess(pionPlusInelasticProcess);
+ 
+ 
+  // **************
+  // *** Pion-  ***
+  // **************
+
+  G4PionMinusInelasticProcess* pionMinusInelasticProcess = new G4PionMinusInelasticProcess("inelastic");
+  G4PiMinusAbsorptionAtRest* pionMinusAbsAtRestProcess = new G4PiMinusAbsorptionAtRest();
+
+  G4LEPionMinusInelastic* pionMinusLEPModel = new G4LEPionMinusInelastic();
+  pionMinusLEPModel -> SetMinEnergy(pionLEPMinEnergy);
+  pionMinusLEPModel -> SetMaxEnergy(pionLEPMaxEnergy);
+
+  pionMinusInelasticProcess -> AddDataSet(pionNuclearCrossSection);
+  pionMinusInelasticProcess -> RegisterMe(pionMinusLEPModel);
+
+  particle = G4PionMinus::PionMinus();
+  processManager = particle -> GetProcessManager();
+  processManager -> AddDiscreteProcess(pionMinusInelasticProcess);
+  processManager -> AddRestProcess(pionMinusAbsAtRestProcess);
+
+}
+
+
+

examples/advanced/hadrontherapy/src/HIProtonNeutronBertini.cc

@@ -0,0 +1,134 @@
+//
+// ********************************************************************
+// * License and Disclaimer                                           *
+// *                                                                  *
+// * The  Geant4 software  is  copyright of the Copyright Holders  of *
+// * the Geant4 Collaboration.  It is provided  under  the terms  and *
+// * conditions of the Geant4 Software License,  included in the file *
+// * LICENSE and available at  http://cern.ch/geant4/license .  These *
+// * include a list of copyright holders.                             *
+// *                                                                  *
+// * Neither the authors of this software system, nor their employing *
+// * institutes,nor the agencies providing financial support for this *
+// * work  make  any representation or  warranty, express or implied, *
+// * regarding  this  software system or assume any liability for its *
+// * use.  Please see the license in the file  LICENSE  and URL above *
+// * for the full disclaimer and the limitation of liability.         *
+// *                                                                  *
+// * This  code  implementation is the result of  the  scientific and *
+// * technical work of the GEANT4 collaboration.                      *
+// * By using,  copying,  modifying or  distributing the software (or *
+// * any work based  on the software)  you  agree  to acknowledge its *
+// * use  in  resulting  scientific  publications,  and indicate your *
+// * acceptance of all terms of the Geant4 Software license.          *
+// ********************************************************************
+//
+// $Id: HadrontherapyProtonBertini.cc; May 2005
+// ----------------------------------------------------------------------------
+//                 GEANT 4 - Hadrontherapy example
+// ----------------------------------------------------------------------------
+// Code developed by:
+//
+// G.A.P. Cirrone(a)*, F. Di Rosa(a), S. Guatelli(b), G. Russo(a)
+// 
+// (a) Laboratori Nazionali del Sud 
+//     of the National Institute for Nuclear Physics, Catania, Italy
+// (b) National Institute for Nuclear Physics Section of Genova, genova, Italy
+// 
+// * cirrone@lns.infn.it
+
+// Code review by M.G. Pia, 2 November 2006
+// Further code review is needed
+// ----------------------------------------------------------------------------
+
+#include "HIProtonNeutronBertini.hh"
+#include "G4ParticleDefinition.hh"
+#include "G4ProcessManager.hh"
+#include "G4ProtonInelasticProcess.hh"
+#include "G4NeutronInelasticProcess.hh"
+#include "G4HadronFissionProcess.hh"
+#include "G4HadronCaptureProcess.hh"
+#include "G4ProtonInelasticCrossSection.hh"
+#include "G4NeutronInelasticCrossSection.hh"
+#include "G4CascadeInterface.hh"
+#include "G4LFission.hh"
+#include "G4LCapture.hh"
+
+
+HIProtonNeutronBertini::HIProtonNeutronBertini(const G4String& name): 
+  G4VPhysicsConstructor(name)
+{
+  G4cout<< "HADRONIC INELASTIC PROCESS(ES): G4XXXInelasticProcess (protons, neutrons)" 
+        << G4endl
+        << "APPLIED MODEL(S): G4CascadeInterface"  
+        << G4endl;
+}
+
+HIProtonNeutronBertini::~HIProtonNeutronBertini()
+{}
+
+void HIProtonNeutronBertini::ConstructProcess()
+{
+  G4ParticleDefinition* particle = 0;
+  G4ProcessManager* processManager = 0;
+
+
+  // *******************************************
+  // *** Proton, Neutron: Common Definitions ***
+  // *******************************************
+
+  G4double protonNeutronBertiniMinEnergy = 0. * MeV;
+  G4double protonNeutronBertiniMaxEnergy = 100. * MeV;
+
+  G4CascadeInterface* protonNeutronBertiniCascadeModel = new G4CascadeInterface;
+  protonNeutronBertiniCascadeModel -> SetMinEnergy(protonNeutronBertiniMinEnergy);
+  protonNeutronBertiniCascadeModel -> SetMaxEnergy(protonNeutronBertiniMaxEnergy);
+
+
+  // **************
+  // *** Proton ***
+  // **************
+
+  G4ProtonInelasticProcess* protonInelasticProcess = new G4ProtonInelasticProcess(); 
+  G4ProtonInelasticCrossSection* protonInelasticCrossSection =  new G4ProtonInelasticCrossSection(); 
+
+  protonInelasticProcess -> RegisterMe(protonNeutronBertiniCascadeModel);
+  protonInelasticProcess -> AddDataSet(protonInelasticCrossSection);
+   
+  particle = G4Proton::Proton();
+  processManager = particle -> GetProcessManager();
+  processManager -> AddDiscreteProcess(protonInelasticProcess);
+
+
+  // ***************
+  // *** Neutron ***
+  // ***************
+
+  G4NeutronInelasticProcess* neutronInelasticProcess = new G4NeutronInelasticProcess; 		  
+  G4NeutronInelasticCrossSection* neutronInelasticCrossSection = new G4NeutronInelasticCrossSection; 
+  G4HadronCaptureProcess* neutronCaptureProcess = new G4HadronCaptureProcess();
+  G4HadronFissionProcess* neutronFissionProcess = new G4HadronFissionProcess();
+
+  G4double neutronCaptureFissionMinEnergy = 0. * TeV;
+  G4double neutronCaptureFissionMaxEnergy = 100. * TeV;
+
+  G4LCapture* neutronCaptureModel = new G4LCapture();
+  neutronCaptureModel -> SetMinEnergy(neutronCaptureFissionMinEnergy);
+  neutronCaptureModel -> SetMaxEnergy(neutronCaptureFissionMaxEnergy);
+
+  G4LFission* neutronFissionModel = new G4LFission();
+  neutronFissionModel -> SetMinEnergy(neutronCaptureFissionMinEnergy);
+  neutronFissionModel -> SetMaxEnergy(neutronCaptureFissionMaxEnergy);
+
+  neutronInelasticProcess -> RegisterMe(protonNeutronBertiniCascadeModel);
+  neutronInelasticProcess -> AddDataSet(neutronInelasticCrossSection);
+  neutronCaptureProcess -> RegisterMe(neutronCaptureModel);
+  neutronFissionProcess -> RegisterMe(neutronFissionModel); 
+
+  particle = G4Neutron::Neutron();
+  processManager = particle -> GetProcessManager();
+  processManager -> AddDiscreteProcess(neutronInelasticProcess);
+  processManager -> AddDiscreteProcess(neutronCaptureProcess); 
+  processManager -> AddDiscreteProcess(neutronFissionProcess); 
+
+}

examples/advanced/hadrontherapy/src/HIProtonNeutronBinary.cc

@@ -0,0 +1,134 @@
+//
+// ********************************************************************
+// * License and Disclaimer                                           *
+// *                                                                  *
+// * The  Geant4 software  is  copyright of the Copyright Holders  of *
+// * the Geant4 Collaboration.  It is provided  under  the terms  and *
+// * conditions of the Geant4 Software License,  included in the file *
+// * LICENSE and available at  http://cern.ch/geant4/license .  These *
+// * include a list of copyright holders.                             *
+// *                                                                  *
+// * Neither the authors of this software system, nor their employing *
+// * institutes,nor the agencies providing financial support for this *
+// * work  make  any representation or  warranty, express or implied, *
+// * regarding  this  software system or assume any liability for its *
+// * use.  Please see the license in the file  LICENSE  and URL above *
+// * for the full disclaimer and the limitation of liability.         *
+// *                                                                  *
+// * This  code  implementation is the result of  the  scientific and *
+// * technical work of the GEANT4 collaboration.                      *
+// * By using,  copying,  modifying or  distributing the software (or *
+// * any work based  on the software)  you  agree  to acknowledge its *
+// * use  in  resulting  scientific  publications,  and indicate your *
+// * acceptance of all terms of the Geant4 Software license.          *
+// ********************************************************************
+//
+// $Id: HadrontherapyProtonPrecompound.cc; May 2005
+// ----------------------------------------------------------------------------
+//                 GEANT 4 - Hadrontherapy example
+// ----------------------------------------------------------------------------
+// Code developed by:
+//
+// G.A.P. Cirrone(a)*, F. Di Rosa(a), S. Guatelli(b), G. Russo(a)
+// 
+// (a) Laboratori Nazionali del Sud 
+//     of the INFN, Catania, Italy
+// (b) INFN Section of Genova, Genova, Italy
+// 
+// * cirrone@lns.infn.it
+// ----------------------------------------------------------------------------
+
+#include "HIProtonNeutronBinary.hh"
+#include "G4ParticleDefinition.hh"
+#include "G4ProcessManager.hh"
+#include "G4ProtonInelasticProcess.hh"
+#include "G4NeutronInelasticProcess.hh"
+#include "G4HadronCaptureProcess.hh"
+#include "G4HadronFissionProcess.hh"
+#include "G4ProtonInelasticCrossSection.hh"
+#include "G4NeutronInelasticCrossSection.hh"
+#include "G4BinaryCascade.hh"
+#include "G4LFission.hh"
+#include "G4LCapture.hh"
+
+
+HIProtonNeutronBinary::HIProtonNeutronBinary(const G4String& name): 
+  G4VPhysicsConstructor(name)
+{
+  G4cout<< "HADRONIC INELASTIC PROCESS(ES): G4XXXInelasticProcess (protons, neutrons)" 
+        << G4endl
+        << "APPLIED MODEL(S): G4BinaryCascade" 
+        << G4endl;
+}
+
+HIProtonNeutronBinary::~HIProtonNeutronBinary()
+{}
+
+void HIProtonNeutronBinary::ConstructProcess()
+{
+  G4ParticleDefinition* particle = 0;
+  G4ProcessManager* processManager = 0;
+
+
+  // *********************************************
+  // *** Protons, Neutrons: Common Definitions ***
+  // *********************************************
+
+  G4double protonNeutronBinaryMinEnergy = 0. * MeV;
+  G4double protonNeutronBinaryMaxEnergy = 100. * MeV;
+
+  G4BinaryCascade* protonNeutronBinaryCascadeModel = new G4BinaryCascade();
+  protonNeutronBinaryCascadeModel -> SetMinEnergy(protonNeutronBinaryMinEnergy);
+  protonNeutronBinaryCascadeModel -> SetMaxEnergy(protonNeutronBinaryMaxEnergy);
+
+
+  // **************
+  // *** Proton ***
+  // **************
+  
+  G4ProtonInelasticProcess* protonInelasticProcess = new G4ProtonInelasticProcess(); 
+  G4ProtonInelasticCrossSection* protonInelasticCrossSection =  new G4ProtonInelasticCrossSection(); 
+
+  protonInelasticProcess -> RegisterMe(protonNeutronBinaryCascadeModel);
+  protonInelasticProcess -> AddDataSet(protonInelasticCrossSection);
+   
+  particle = G4Proton::Proton();
+  processManager = particle -> GetProcessManager();
+  processManager -> AddDiscreteProcess(protonInelasticProcess);
+
+
+  // ***************
+  // *** Neutron ***
+  // ***************
+
+  G4NeutronInelasticProcess* neutronInelasticProcess = new G4NeutronInelasticProcess; 		  
+  G4NeutronInelasticCrossSection* neutronInelasticCrossSection = new G4NeutronInelasticCrossSection; 
+  G4HadronCaptureProcess* neutronCaptureProcess = new G4HadronCaptureProcess();
+  G4HadronFissionProcess* neutronFissionProcess = new G4HadronFissionProcess();
+
+  G4double neutronCaptureFissionMinEnergy = 0. * TeV;
+  G4double neutronCaptureFissionMaxEnergy = 100. * TeV;
+
+  G4LCapture* neutronCaptureModel = new G4LCapture();
+  neutronCaptureModel -> SetMinEnergy(neutronCaptureFissionMinEnergy);
+  neutronCaptureModel -> SetMaxEnergy(neutronCaptureFissionMaxEnergy);
+
+  G4LFission* neutronFissionModel = new G4LFission();
+  neutronFissionModel -> SetMinEnergy(neutronCaptureFissionMinEnergy);
+  neutronFissionModel -> SetMaxEnergy(neutronCaptureFissionMaxEnergy);
+
+  neutronInelasticProcess -> RegisterMe(protonNeutronBinaryCascadeModel);
+  neutronInelasticProcess -> AddDataSet(neutronInelasticCrossSection);
+  neutronCaptureProcess -> RegisterMe(neutronCaptureModel);
+  neutronFissionProcess -> RegisterMe(neutronFissionModel); 
+
+  particle = G4Neutron::Neutron();
+  processManager = particle -> GetProcessManager();
+  processManager -> AddDiscreteProcess(neutronInelasticProcess);
+  processManager -> AddDiscreteProcess(neutronCaptureProcess); 
+  processManager -> AddDiscreteProcess(neutronFissionProcess);   
+
+}
+
+
+

examples/advanced/hadrontherapy/src/HIProtonNeutronLEP.cc

@@ -0,0 +1,138 @@
+//
+// ********************************************************************
+// * License and Disclaimer                                           *
+// *                                                                  *
+// * The  Geant4 software  is  copyright of the Copyright Holders  of *
+// * the Geant4 Collaboration.  It is provided  under  the terms  and *
+// * conditions of the Geant4 Software License,  included in the file *
+// * LICENSE and available at  http://cern.ch/geant4/license .  These *
+// * include a list of copyright holders.                             *
+// *                                                                  *
+// * Neither the authors of this software system, nor their employing *
+// * institutes,nor the agencies providing financial support for this *
+// * work  make  any representation or  warranty, express or implied, *
+// * regarding  this  software system or assume any liability for its *
+// * use.  Please see the license in the file  LICENSE  and URL above *
+// * for the full disclaimer and the limitation of liability.         *
+// *                                                                  *
+// * This  code  implementation is the result of  the  scientific and *
+// * technical work of the GEANT4 collaboration.                      *
+// * By using,  copying,  modifying or  distributing the software (or *
+// * any work based  on the software)  you  agree  to acknowledge its *
+// * use  in  resulting  scientific  publications,  and indicate your *
+// * acceptance of all terms of the Geant4 Software license.          *
+// ********************************************************************
+//
+// $Id: HadrontherapyProtonLEP.cc; May 2005
+// ----------------------------------------------------------------------------
+//                 GEANT 4 - Hadrontherapy example
+// ----------------------------------------------------------------------------
+// Code developed by:
+//
+// G.A.P. Cirrone(a)*, F. Di Rosa(a), S. Guatelli(b), G. Russo(a)
+// 
+// (a) Laboratori Nazionali del Sud 
+//     of the INFN, Catania, Italy
+// (b) INFN Section of Genova, Genova, Italy
+// 
+// * cirrone@lns.infn.it
+// ----------------------------------------------------------------------------
+
+#include "HIProtonNeutronLEP.hh"
+#include "G4ParticleDefinition.hh"
+#include "G4ProcessManager.hh"
+#include "G4ProtonInelasticProcess.hh"
+#include "G4NeutronInelasticProcess.hh"
+#include "G4HadronCaptureProcess.hh"
+#include "G4HadronFissionProcess.hh"
+#include "G4ProtonInelasticCrossSection.hh"
+#include "G4NeutronInelasticCrossSection.hh"
+#include "G4LEProtonInelastic.hh"
+#include "G4LENeutronInelastic.hh"
+#include "G4LFission.hh"
+#include "G4LCapture.hh"
+
+
+HIProtonNeutronLEP::HIProtonNeutronLEP(const G4String& name): 
+  G4VPhysicsConstructor(name)
+{
+  G4cout<< "HADRONIC INELASTIC PROCESS(ES): G4XXXInelasticProcess (protons, neutrons)" 
+        << G4endl
+        << "APPLIED MODEL(S): G4LEXXXInelastic" 
+        << G4endl;
+}
+
+HIProtonNeutronLEP::~HIProtonNeutronLEP()
+{}
+
+void HIProtonNeutronLEP::ConstructProcess()
+{
+  G4ParticleDefinition* particle = 0;
+  G4ProcessManager* processManager = 0;
+
+  // ******************************************
+  // *** Proton,Neutron: Common Definitions ***
+  // ******************************************
+
+  G4double protonNeutronLEPMinEnergy = 0. * MeV;
+  G4double protonNeutronLEPMaxEnergy = 100. * MeV;
+
+
+  // **************
+  // *** Proton ***
+  // **************
+
+  G4ProtonInelasticProcess* protonInelasticProcess = new G4ProtonInelasticProcess(); 
+  G4ProtonInelasticCrossSection* protonInelasticCrossSection =  new G4ProtonInelasticCrossSection(); 
+
+  G4LEProtonInelastic* protonLEPModel = new G4LEProtonInelastic();
+  protonLEPModel -> SetMinEnergy(protonNeutronLEPMinEnergy);
+  protonLEPModel -> SetMaxEnergy(protonNeutronLEPMaxEnergy);
+
+  protonInelasticProcess -> RegisterMe(protonLEPModel);
+  protonInelasticProcess -> AddDataSet(protonInelasticCrossSection);
+   
+  particle = G4Proton::Proton();
+  processManager = particle -> GetProcessManager();
+  processManager -> AddDiscreteProcess(protonInelasticProcess);
+
+
+  // ***************
+  // *** Neutron ***
+  // ***************
+
+  G4NeutronInelasticProcess* neutronInelasticProcess = new G4NeutronInelasticProcess; 		  
+  G4NeutronInelasticCrossSection* neutronInelasticCrossSection = new G4NeutronInelasticCrossSection; 
+  G4HadronCaptureProcess* neutronCaptureProcess = new G4HadronCaptureProcess();
+  G4HadronFissionProcess* neutronFissionProcess = new G4HadronFissionProcess();
+
+  G4LENeutronInelastic* neutronLEPModel = new G4LENeutronInelastic();
+  neutronLEPModel -> SetMinEnergy(protonNeutronLEPMinEnergy);
+  neutronLEPModel -> SetMaxEnergy(protonNeutronLEPMaxEnergy);
+
+  G4double neutronCaptureFissionMinEnergy = 0. * TeV;
+  G4double neutronCaptureFissionMaxEnergy = 100. * TeV;
+
+  G4LCapture* neutronCaptureModel = new G4LCapture();
+  neutronCaptureModel -> SetMinEnergy(neutronCaptureFissionMinEnergy);
+  neutronCaptureModel -> SetMaxEnergy(neutronCaptureFissionMaxEnergy);
+
+  G4LFission* neutronFissionModel = new G4LFission();
+  neutronFissionModel -> SetMinEnergy(neutronCaptureFissionMinEnergy);
+  neutronFissionModel -> SetMaxEnergy(neutronCaptureFissionMaxEnergy);
+
+  neutronInelasticProcess -> RegisterMe(neutronLEPModel);
+  neutronInelasticProcess -> AddDataSet(neutronInelasticCrossSection);
+  neutronCaptureProcess -> RegisterMe(neutronCaptureModel);
+  neutronFissionProcess -> RegisterMe(neutronFissionModel); 
+
+  particle = G4Neutron::Neutron();
+  processManager = particle -> GetProcessManager();
+  processManager -> AddDiscreteProcess(neutronInelasticProcess);
+  processManager -> AddDiscreteProcess(neutronCaptureProcess); 
+  processManager -> AddDiscreteProcess(neutronFissionProcess);  
+
+}
+
+
+

examples/advanced/hadrontherapy/src/HIProtonNeutronPrecompound.cc

@@ -0,0 +1,140 @@
+//
+// ********************************************************************
+// * License and Disclaimer                                           *
+// *                                                                  *
+// * The  Geant4 software  is  copyright of the Copyright Holders  of *
+// * the Geant4 Collaboration.  It is provided  under  the terms  and *
+// * conditions of the Geant4 Software License,  included in the file *
+// * LICENSE and available at  http://cern.ch/geant4/license .  These *
+// * include a list of copyright holders.                             *
+// *                                                                  *
+// * Neither the authors of this software system, nor their employing *
+// * institutes,nor the agencies providing financial support for this *
+// * work  make  any representation or  warranty, express or implied, *
+// * regarding  this  software system or assume any liability for its *
+// * use.  Please see the license in the file  LICENSE  and URL above *
+// * for the full disclaimer and the limitation of liability.         *
+// *                                                                  *
+// * This  code  implementation is the result of  the  scientific and *
+// * technical work of the GEANT4 collaboration.                      *
+// * By using,  copying,  modifying or  distributing the software (or *
+// * any work based  on the software)  you  agree  to acknowledge its *
+// * use  in  resulting  scientific  publications,  and indicate your *
+// * acceptance of all terms of the Geant4 Software license.          *
+// ********************************************************************
+//
+// $Id: HadrontherapyProtonPrecompound.cc; May 2005
+// ----------------------------------------------------------------------------
+//                 GEANT 4 - Hadrontherapy example
+// ----------------------------------------------------------------------------
+// Code developed by:
+//
+// G.A.P. Cirrone(a)*, F. Di Rosa(a), S. Guatelli(b), G. Russo(a)
+// 
+// (a) Laboratori Nazionali del Sud 
+//     of the INFN, Catania, Italy
+// (b) INFN Section of Genova, Genova, Italy
+// 
+// * cirrone@lns.infn.it
+// ----------------------------------------------------------------------------
+
+#include "HIProtonNeutronPrecompound.hh"
+#include "G4ParticleDefinition.hh"
+#include "G4ProcessManager.hh"
+#include "G4ProtonInelasticProcess.hh"
+#include "G4NeutronInelasticProcess.hh"
+#include "G4HadronCaptureProcess.hh"
+#include "G4HadronFissionProcess.hh"
+#include "G4ProtonInelasticCrossSection.hh"
+#include "G4NeutronInelasticCrossSection.hh"
+#include "G4PreCompoundModel.hh"
+#include "G4LFission.hh"
+#include "G4LCapture.hh"
+#include "G4ExcitationHandler.hh"
+
+
+HIProtonNeutronPrecompound::HIProtonNeutronPrecompound(const G4String& name): 
+  G4VPhysicsConstructor(name)
+{
+  G4cout<< "HADRONIC INELASTIC PROCESS(ES): G4XXXInelasticProcess (protons, neutrons)" 
+        << G4endl
+        << "APPLIED MODEL(S): G4PreCompound" 
+        << G4endl
+        << "                  combined with Default Evaporation" 
+        << G4endl;
+}
+
+HIProtonNeutronPrecompound::~HIProtonNeutronPrecompound()
+{}
+
+void HIProtonNeutronPrecompound::ConstructProcess()
+{
+  G4ParticleDefinition* particle = 0;
+  G4ProcessManager* processManager = 0;
+
+
+  // *********************************************
+  // *** Protons, Neutrons: Common Definitions ***
+  // *********************************************
+
+  G4ExcitationHandler* excitationHandler  = new G4ExcitationHandler();
+
+  G4double protonNeutronPrecompoundMinEnergy = 0. * MeV;
+  G4double protonNeutronPrecompoundMaxEnergy = 100. * MeV;
+
+  G4PreCompoundModel*  protonNeutronPreCompoundModel = new G4PreCompoundModel(excitationHandler);
+  protonNeutronPreCompoundModel -> SetMinEnergy(protonNeutronPrecompoundMinEnergy);
+  protonNeutronPreCompoundModel -> SetMaxEnergy(protonNeutronPrecompoundMaxEnergy);
+
+
+  // **************
+  // *** Proton ***
+  // **************
+  
+  G4ProtonInelasticProcess* protonInelasticProcess = new G4ProtonInelasticProcess(); 
+  G4ProtonInelasticCrossSection* protonInelasticCrossSection =  new G4ProtonInelasticCrossSection(); 
+
+  protonInelasticProcess -> RegisterMe(protonNeutronPreCompoundModel);
+  protonInelasticProcess -> AddDataSet(protonInelasticCrossSection);
+   
+  particle = G4Proton::Proton();
+  processManager = particle -> GetProcessManager();
+  processManager -> AddDiscreteProcess(protonInelasticProcess);
+
+
+  // ***************
+  // *** Neutron ***
+  // ***************
+
+  G4NeutronInelasticProcess* neutronInelasticProcess = new G4NeutronInelasticProcess; 		  
+  G4NeutronInelasticCrossSection* neutronInelasticCrossSection = new G4NeutronInelasticCrossSection; 
+  G4HadronCaptureProcess* neutronCaptureProcess = new G4HadronCaptureProcess();
+  G4HadronFissionProcess* neutronFissionProcess = new G4HadronFissionProcess();
+
+  G4double neutronCaptureFissionMinEnergy = 0. * TeV;
+  G4double neutronCaptureFissionMaxEnergy = 100. * TeV;
+
+  G4LCapture* neutronCaptureModel = new G4LCapture();
+  neutronCaptureModel -> SetMinEnergy(neutronCaptureFissionMinEnergy);
+  neutronCaptureModel -> SetMaxEnergy(neutronCaptureFissionMaxEnergy);
+
+  G4LFission* neutronFissionModel = new G4LFission();
+  neutronFissionModel -> SetMinEnergy(neutronCaptureFissionMinEnergy);
+  neutronFissionModel -> SetMaxEnergy(neutronCaptureFissionMaxEnergy);
+
+  neutronInelasticProcess -> RegisterMe(protonNeutronPreCompoundModel);
+  neutronInelasticProcess -> AddDataSet(neutronInelasticCrossSection);
+  neutronCaptureProcess -> RegisterMe(neutronCaptureModel);
+  neutronFissionProcess -> RegisterMe(neutronFissionModel); 
+
+  particle = G4Neutron::Neutron();
+  processManager = particle -> GetProcessManager();
+  processManager -> AddDiscreteProcess(neutronInelasticProcess);
+  processManager -> AddDiscreteProcess(neutronCaptureProcess); 
+  processManager -> AddDiscreteProcess(neutronFissionProcess);   
+
+
+}
+
+
+

examples/advanced/hadrontherapy/src/HIProtonNeutronPrecompoundFermi.cc

@@ -0,0 +1,150 @@
+//
+// ********************************************************************
+// * License and Disclaimer                                           *
+// *                                                                  *
+// * The  Geant4 software  is  copyright of the Copyright Holders  of *
+// * the Geant4 Collaboration.  It is provided  under  the terms  and *
+// * conditions of the Geant4 Software License,  included in the file *
+// * LICENSE and available at  http://cern.ch/geant4/license .  These *
+// * include a list of copyright holders.                             *
+// *                                                                  *
+// * Neither the authors of this software system, nor their employing *
+// * institutes,nor the agencies providing financial support for this *
+// * work  make  any representation or  warranty, express or implied, *
+// * regarding  this  software system or assume any liability for its *
+// * use.  Please see the license in the file  LICENSE  and URL above *
+// * for the full disclaimer and the limitation of liability.         *
+// *                                                                  *
+// * This  code  implementation is the result of  the  scientific and *
+// * technical work of the GEANT4 collaboration.                      *
+// * By using,  copying,  modifying or  distributing the software (or *
+// * any work based  on the software)  you  agree  to acknowledge its *
+// * use  in  resulting  scientific  publications,  and indicate your *
+// * acceptance of all terms of the Geant4 Software license.          *
+// ********************************************************************
+//
+// $Id: HadrontherapyProtonPrecompoundFermi.cc; May 2005
+// ----------------------------------------------------------------------------
+//                 GEANT 4 - Hadrontherapy example
+// ----------------------------------------------------------------------------
+// Code developed by:
+//
+// G.A.P. Cirrone(a)*, F. Di Rosa(a), S. Guatelli(b), G. Russo(a)
+// 
+// (a) Laboratori Nazionali del Sud 
+//     of the INFN, Catania, Italy
+// (b) INFN Section of Genova, Genova, Italy
+// 
+// * cirrone@lns.infn.it
+// ----------------------------------------------------------------------------
+
+#include "HIProtonNeutronPrecompoundFermi.hh"
+#include "G4ParticleDefinition.hh"
+#include "G4ProcessManager.hh"
+#include "G4ProtonInelasticProcess.hh"
+#include "G4NeutronInelasticProcess.hh"
+#include "G4HadronCaptureProcess.hh"
+#include "G4HadronFissionProcess.hh"
+#include "G4ProtonInelasticCrossSection.hh"
+#include "G4NeutronInelasticCrossSection.hh"
+#include "G4PreCompoundModel.hh"
+#include "G4LFission.hh"
+#include "G4LCapture.hh"
+#include "G4Evaporation.hh"
+#include "G4FermiBreakUp.hh"
+#include "G4ExcitationHandler.hh"
+
+
+HIProtonNeutronPrecompoundFermi::HIProtonNeutronPrecompoundFermi(const G4String& name): 
+  G4VPhysicsConstructor(name)
+{
+  G4cout<< "HADRONIC INELASTIC PROCESS(ES): G4XXXInelasticProcess (protons, neutrons)" 
+        << G4endl
+        << "APPLIED MODEL(S): G4PreCompound" 
+        << G4endl
+        << "                  combined with GEM Evaporation model" 
+        << G4endl 
+        << "                  and Fermi Break-up model" 
+        << G4endl;
+}
+
+HIProtonNeutronPrecompoundFermi::~HIProtonNeutronPrecompoundFermi()
+{}
+
+void HIProtonNeutronPrecompoundFermi::ConstructProcess()
+{
+  G4ParticleDefinition* particle = 0;
+  G4ProcessManager* processManager = 0;
+
+
+  // ********************************
+  // *** Hadrons: Inelastic Model ***
+  // ********************************
+
+  G4ExcitationHandler* excitationHandler  = new G4ExcitationHandler();
+
+  G4int targetZ = 1;
+  G4int targetA = 2 * targetZ;
+
+  G4FermiBreakUp* hadronFermiBreakUpModel = new G4FermiBreakUp(); 
+  excitationHandler -> SetFermiModel(hadronFermiBreakUpModel);
+  excitationHandler -> SetMaxAandZForFermiBreakUp(targetA,targetZ);
+
+  G4double protonNeutronPrecompoundMinEnergy = 0. * MeV;
+  G4double protonNeutronPrecompoundMaxEnergy = 100. * MeV;
+
+  G4PreCompoundModel*  hadronPreCompoundModel = new G4PreCompoundModel(excitationHandler);
+  hadronPreCompoundModel -> SetMinEnergy(protonNeutronPrecompoundMinEnergy);
+  hadronPreCompoundModel -> SetMaxEnergy(protonNeutronPrecompoundMaxEnergy);
+
+
+  // **************
+  // *** Proton ***
+  // **************
+  
+  G4ProtonInelasticProcess* protonInelasticProcess = new G4ProtonInelasticProcess(); 
+  G4ProtonInelasticCrossSection* protonInelasticCrossSection =  new G4ProtonInelasticCrossSection(); 
+
+  protonInelasticProcess -> RegisterMe(hadronPreCompoundModel);
+  protonInelasticProcess -> AddDataSet(protonInelasticCrossSection);
+   
+  particle = G4Proton::Proton();
+  processManager = particle -> GetProcessManager();
+  processManager -> AddDiscreteProcess(protonInelasticProcess);
+
+
+  // ***************
+  // *** Neutron ***
+  // ***************
+
+  G4NeutronInelasticProcess* neutronInelasticProcess = new G4NeutronInelasticProcess; 		  
+  G4NeutronInelasticCrossSection* neutronInelasticCrossSection = new G4NeutronInelasticCrossSection; 
+  G4HadronCaptureProcess* neutronCaptureProcess = new G4HadronCaptureProcess();
+  G4HadronFissionProcess* neutronFissionProcess = new G4HadronFissionProcess();
+
+  G4double neutronCaptureFissionMinEnergy = 0. * TeV;
+  G4double neutronCaptureFissionMaxEnergy = 100. * TeV;
+
+  G4LCapture* neutronCaptureModel = new G4LCapture();
+  neutronCaptureModel -> SetMinEnergy(neutronCaptureFissionMinEnergy);
+  neutronCaptureModel -> SetMaxEnergy(neutronCaptureFissionMaxEnergy);
+
+  G4LFission* neutronFissionModel = new G4LFission();
+  neutronFissionModel -> SetMinEnergy(neutronCaptureFissionMinEnergy);
+  neutronFissionModel -> SetMaxEnergy(neutronCaptureFissionMaxEnergy);
+
+  neutronInelasticProcess -> RegisterMe(hadronPreCompoundModel);
+  neutronInelasticProcess -> AddDataSet(neutronInelasticCrossSection);
+  neutronCaptureProcess -> RegisterMe(neutronCaptureModel);
+  neutronFissionProcess -> RegisterMe(neutronFissionModel); 
+
+  particle = G4Neutron::Neutron();
+  processManager = particle -> GetProcessManager();
+  processManager -> AddDiscreteProcess(neutronInelasticProcess);
+  processManager -> AddDiscreteProcess(neutronCaptureProcess); 
+  processManager -> AddDiscreteProcess(neutronFissionProcess);   
+
+}
+
+
+

examples/advanced/hadrontherapy/src/HIProtonNeutronPrecompoundGEM.cc

@@ -0,0 +1,144 @@
+//
+// ********************************************************************
+// * License and Disclaimer                                           *
+// *                                                                  *
+// * The  Geant4 software  is  copyright of the Copyright Holders  of *
+// * the Geant4 Collaboration.  It is provided  under  the terms  and *
+// * conditions of the Geant4 Software License,  included in the file *
+// * LICENSE and available at  http://cern.ch/geant4/license .  These *
+// * include a list of copyright holders.                             *
+// *                                                                  *
+// * Neither the authors of this software system, nor their employing *
+// * institutes,nor the agencies providing financial support for this *
+// * work  make  any representation or  warranty, express or implied, *
+// * regarding  this  software system or assume any liability for its *
+// * use.  Please see the license in the file  LICENSE  and URL above *
+// * for the full disclaimer and the limitation of liability.         *
+// *                                                                  *
+// * This  code  implementation is the result of  the  scientific and *
+// * technical work of the GEANT4 collaboration.                      *
+// * By using,  copying,  modifying or  distributing the software (or *
+// * any work based  on the software)  you  agree  to acknowledge its *
+// * use  in  resulting  scientific  publications,  and indicate your *
+// * acceptance of all terms of the Geant4 Software license.          *
+// ********************************************************************
+//
+// $Id: HadrontherapyProtonPrecompound.cc; May 2005
+// ----------------------------------------------------------------------------
+//                 GEANT 4 - Hadrontherapy example
+// ----------------------------------------------------------------------------
+// Code developed by:
+//
+// G.A.P. Cirrone(a)*, F. Di Rosa(a), S. Guatelli(b), G. Russo(a)
+// 
+// (a) Laboratori Nazionali del Sud 
+//     of the INFN, Catania, Italy
+// (b) INFN Section of Genova, Genova, Italy
+// 
+// * cirrone@lns.infn.it
+// ----------------------------------------------------------------------------
+
+#include "HIProtonNeutronPrecompoundGEM.hh"
+#include "G4ParticleDefinition.hh"
+#include "G4ProcessManager.hh"
+#include "G4ProtonInelasticProcess.hh"
+#include "G4NeutronInelasticProcess.hh"
+#include "G4HadronCaptureProcess.hh"
+#include "G4HadronFissionProcess.hh"
+#include "G4ProtonInelasticCrossSection.hh"
+#include "G4NeutronInelasticCrossSection.hh"
+#include "G4PreCompoundModel.hh"
+#include "G4LFission.hh"
+#include "G4LCapture.hh"
+#include "G4Evaporation.hh"
+#include "G4ExcitationHandler.hh"
+
+
+HIProtonNeutronPrecompoundGEM::HIProtonNeutronPrecompoundGEM(const G4String& name): 
+  G4VPhysicsConstructor(name)
+{
+  G4cout<< "HADRONIC INELASTIC PROCESS(ES): G4XXXInelasticProcess (protons, neutrons)" 
+        << G4endl
+        << "APPLIED MODEL(S): G4PreCompound" 
+        << G4endl
+        << "                  combined with GEM Evaporation model" 
+        << G4endl;
+}
+
+HIProtonNeutronPrecompoundGEM::~HIProtonNeutronPrecompoundGEM()
+{}
+
+void HIProtonNeutronPrecompoundGEM::ConstructProcess()
+{
+  G4ParticleDefinition* particle = 0;
+  G4ProcessManager* processManager = 0;
+
+
+  // ********************************
+  // *** Hadrons: Inelastic Model ***
+  // ********************************
+
+  G4ExcitationHandler* excitationHandler  = new G4ExcitationHandler();
+
+  G4Evaporation* evaporation =  new G4Evaporation();
+  evaporation -> SetGEMChannel();
+  excitationHandler -> SetEvaporation(evaporation);
+
+  G4double protonNeutronPrecompoundMinEnergy = 0. * MeV;
+  G4double protonNeutronPrecompoundMaxEnergy = 100. * MeV;
+
+  G4PreCompoundModel*  hadronPreCompoundModel = new G4PreCompoundModel(excitationHandler);
+  hadronPreCompoundModel -> SetMinEnergy(protonNeutronPrecompoundMinEnergy);
+  hadronPreCompoundModel -> SetMaxEnergy(protonNeutronPrecompoundMaxEnergy);
+
+
+  // **************
+  // *** Proton ***
+  // **************
+  
+  G4ProtonInelasticProcess* protonInelasticProcess = new G4ProtonInelasticProcess(); 
+  G4ProtonInelasticCrossSection* protonInelasticCrossSection =  new G4ProtonInelasticCrossSection(); 
+
+  protonInelasticProcess -> RegisterMe(hadronPreCompoundModel);
+  protonInelasticProcess -> AddDataSet(protonInelasticCrossSection);
+   
+  particle = G4Proton::Proton();
+  processManager = particle -> GetProcessManager();
+  processManager -> AddDiscreteProcess(protonInelasticProcess);
+
+
+  // ***************
+  // *** Neutron ***
+  // ***************
+
+  G4NeutronInelasticProcess* neutronInelasticProcess = new G4NeutronInelasticProcess; 		  
+  G4NeutronInelasticCrossSection* neutronInelasticCrossSection = new G4NeutronInelasticCrossSection; 
+  G4HadronCaptureProcess* neutronCaptureProcess = new G4HadronCaptureProcess();
+  G4HadronFissionProcess* neutronFissionProcess = new G4HadronFissionProcess();
+
+  G4double neutronCaptureFissionMinEnergy = 0. * TeV;
+  G4double neutronCaptureFissionMaxEnergy = 100. * TeV;
+
+  G4LCapture* neutronCaptureModel = new G4LCapture();
+  neutronCaptureModel -> SetMinEnergy(neutronCaptureFissionMinEnergy);
+  neutronCaptureModel -> SetMaxEnergy(neutronCaptureFissionMaxEnergy);
+
+  G4LFission* neutronFissionModel = new G4LFission();
+  neutronFissionModel -> SetMinEnergy(neutronCaptureFissionMinEnergy);
+  neutronFissionModel -> SetMaxEnergy(neutronCaptureFissionMaxEnergy);
+
+  neutronInelasticProcess -> RegisterMe(hadronPreCompoundModel);
+  neutronInelasticProcess -> AddDataSet(neutronInelasticCrossSection);
+  neutronCaptureProcess -> RegisterMe(neutronCaptureModel);
+  neutronFissionProcess -> RegisterMe(neutronFissionModel); 
+
+  particle = G4Neutron::Neutron();
+  processManager = particle -> GetProcessManager();
+  processManager -> AddDiscreteProcess(neutronInelasticProcess);
+  processManager -> AddDiscreteProcess(neutronCaptureProcess); 
+  processManager -> AddDiscreteProcess(neutronFissionProcess);   
+
+}
+
+
+

examples/advanced/hadrontherapy/src/HIProtonNeutronPrecompoundGEMFermi.cc

@@ -0,0 +1,152 @@
+//
+// ********************************************************************
+// * License and Disclaimer                                           *
+// *                                                                  *
+// * The  Geant4 software  is  copyright of the Copyright Holders  of *
+// * the Geant4 Collaboration.  It is provided  under  the terms  and *
+// * conditions of the Geant4 Software License,  included in the file *
+// * LICENSE and available at  http://cern.ch/geant4/license .  These *
+// * include a list of copyright holders.                             *
+// *                                                                  *
+// * Neither the authors of this software system, nor their employing *
+// * institutes,nor the agencies providing financial support for this *
+// * work  make  any representation or  warranty, express or implied, *
+// * regarding  this  software system or assume any liability for its *
+// * use.  Please see the license in the file  LICENSE  and URL above *
+// * for the full disclaimer and the limitation of liability.         *
+// *                                                                  *
+// * This  code  implementation is the result of  the  scientific and *
+// * technical work of the GEANT4 collaboration.                      *
+// * By using,  copying,  modifying or  distributing the software (or *
+// * any work based  on the software)  you  agree  to acknowledge its *
+// * use  in  resulting  scientific  publications,  and indicate your *
+// * acceptance of all terms of the Geant4 Software license.          *
+// ********************************************************************
+//
+// $Id: HadrontherapyProtonPrecompoundGEMFermi.cc; May 2005
+// ----------------------------------------------------------------------------
+//                 GEANT 4 - Hadrontherapy example
+// ----------------------------------------------------------------------------
+// Code developed by:
+//
+// G.A.P. Cirrone(a)*, F. Di Rosa(a), S. Guatelli(b), G. Russo(a)
+// 
+// (a) Laboratori Nazionali del Sud 
+//     of the INFN, Catania, Italy
+// (b) INFN Section of Genova, Genova, Italy
+// 
+// * cirrone@lns.infn.it
+// ----------------------------------------------------------------------------
+
+#include "HIProtonNeutronPrecompoundGEMFermi.hh"
+#include "G4ParticleDefinition.hh"
+#include "G4ProcessManager.hh"
+#include "G4ProtonInelasticProcess.hh"
+#include "G4NeutronInelasticProcess.hh"
+#include "G4HadronCaptureProcess.hh"
+#include "G4HadronFissionProcess.hh"
+#include "G4ProtonInelasticCrossSection.hh"
+#include "G4NeutronInelasticCrossSection.hh"
+#include "G4PreCompoundModel.hh"
+#include "G4LFission.hh"
+#include "G4LCapture.hh"
+#include "G4Evaporation.hh"
+#include "G4ExcitationHandler.hh"
+#include "G4FermiBreakUp.hh"
+
+
+HIProtonNeutronPrecompoundGEMFermi::HIProtonNeutronPrecompoundGEMFermi(const G4String& name): 
+  G4VPhysicsConstructor(name)
+{
+  G4cout<< "HADRONIC INELASTIC PROCESS(ES): G4XXXInelasticProcess (protons, neutrons)" 
+        << G4endl
+        << "APPLIED MODEL(S): G4PreCompound" 
+        << G4endl
+        << "                  combined with GEM Evaporation model and Fermi Break-up model" 
+        << G4endl;
+}
+
+HIProtonNeutronPrecompoundGEMFermi::~HIProtonNeutronPrecompoundGEMFermi()
+{}
+
+void HIProtonNeutronPrecompoundGEMFermi::ConstructProcess()
+{
+  G4ParticleDefinition* particle = 0;
+  G4ProcessManager* processManager = 0;
+
+
+  // ********************************
+  // *** Hadrons: Inelastic Model ***
+  // ********************************
+
+  G4ExcitationHandler* excitationHandler  = new G4ExcitationHandler();
+
+  G4Evaporation* evaporation =  new G4Evaporation();
+  evaporation -> SetGEMChannel();
+  excitationHandler -> SetEvaporation(evaporation);
+
+  G4int targetZ = 1;
+  G4int targetA = 2 * targetZ;
+
+  G4FermiBreakUp* hadronFermiBreakUpModel = new G4FermiBreakUp(); 
+  excitationHandler -> SetFermiModel(hadronFermiBreakUpModel);
+  excitationHandler -> SetMaxAandZForFermiBreakUp(targetA,targetZ);
+
+  G4double protonNeutronPrecompoundMinEnergy = 0. * MeV;
+  G4double protonNeutronPrecompoundMaxEnergy = 100. * MeV;
+
+  G4PreCompoundModel*  hadronPreCompoundModel = new G4PreCompoundModel(excitationHandler);
+  hadronPreCompoundModel -> SetMinEnergy(protonNeutronPrecompoundMinEnergy);
+  hadronPreCompoundModel -> SetMaxEnergy(protonNeutronPrecompoundMaxEnergy);
+
+
+  // **************
+  // *** Proton ***
+  // **************
+  
+  G4ProtonInelasticProcess* protonInelasticProcess = new G4ProtonInelasticProcess(); 
+  G4ProtonInelasticCrossSection* protonInelasticCrossSection =  new G4ProtonInelasticCrossSection(); 
+
+  protonInelasticProcess -> RegisterMe(hadronPreCompoundModel);
+  protonInelasticProcess -> AddDataSet(protonInelasticCrossSection);
+   
+  particle = G4Proton::Proton();
+  processManager = particle -> GetProcessManager();
+  processManager -> AddDiscreteProcess(protonInelasticProcess);
+
+
+  // ***************
+  // *** Neutron ***
+  // ***************
+
+  G4NeutronInelasticProcess* neutronInelasticProcess = new G4NeutronInelasticProcess; 		  
+  G4NeutronInelasticCrossSection* neutronInelasticCrossSection = new G4NeutronInelasticCrossSection; 
+  G4HadronCaptureProcess* neutronCaptureProcess = new G4HadronCaptureProcess();
+  G4HadronFissionProcess* neutronFissionProcess = new G4HadronFissionProcess();
+
+  G4double neutronCaptureFissionMinEnergy = 0. * TeV;
+  G4double neutronCaptureFissionMaxEnergy = 100. * TeV;
+
+  G4LCapture* neutronCaptureModel = new G4LCapture();
+  neutronCaptureModel -> SetMinEnergy(neutronCaptureFissionMinEnergy);
+  neutronCaptureModel -> SetMaxEnergy(neutronCaptureFissionMaxEnergy);
+
+  G4LFission* neutronFissionModel = new G4LFission();
+  neutronFissionModel -> SetMinEnergy(neutronCaptureFissionMinEnergy);
+  neutronFissionModel -> SetMaxEnergy(neutronCaptureFissionMaxEnergy);
+
+  neutronInelasticProcess -> RegisterMe(hadronPreCompoundModel);
+  neutronInelasticProcess -> AddDataSet(neutronInelasticCrossSection);
+  neutronCaptureProcess -> RegisterMe(neutronCaptureModel);
+  neutronFissionProcess -> RegisterMe(neutronFissionModel); 
+
+  particle = G4Neutron::Neutron();
+  processManager = particle -> GetProcessManager();
+  processManager -> AddDiscreteProcess(neutronInelasticProcess);
+  processManager -> AddDiscreteProcess(neutronCaptureProcess); 
+  processManager -> AddDiscreteProcess(neutronFissionProcess); 
+
+}
+
+
+

examples/advanced/hadrontherapy/src/HRMuonMinusCapture.cc

@@ -23,7 +23,7 @@
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
 //
-// $Id: HadrontherapyPhotonStandard.cc; May 2005
+// $Id: HadrontherapyMuonStandard.cc; May 2005
 // ----------------------------------------------------------------------------
 //                 GEANT 4 - Hadrontherapy example
 // ----------------------------------------------------------------------------
@@ -37,38 +37,36 @@
 // 
 // * cirrone@lns.infn.it
 // ----------------------------------------------------------------------------
-#include "HadrontherapyPhotonStandard.hh"
-#include "G4ProcessManager.hh"
+
+#include "HRMuonMinusCapture.hh"
 #include "G4ParticleDefinition.hh"
-#include "G4ComptonScattering.hh"
-#include "G4GammaConversion.hh"
-#include "G4PhotoElectricEffect.hh"
-#include "G4StepLimiter.hh"
+#include "G4ProcessManager.hh"
+#include "G4MuonMinusCaptureAtRest.hh" 
 
-HadrontherapyPhotonStandard::HadrontherapyPhotonStandard(const G4String& name): G4VPhysicsConstructor(name)
-{ }
 
-HadrontherapyPhotonStandard::~HadrontherapyPhotonStandard()
-{ }
-
-void HadrontherapyPhotonStandard::ConstructProcess()
-{
-  // Add standard processes for photons
-  
-  theParticleIterator -> reset();
-
-  while( (*theParticleIterator)() )
-    {
-      G4ParticleDefinition* particle = theParticleIterator -> value();
-      G4ProcessManager* manager = particle -> GetProcessManager();
-      G4String particleName = particle -> GetParticleName();
-
-      if (particleName == "gamma") 
-	{
-	  manager -> AddDiscreteProcess(new G4PhotoElectricEffect);
-	  manager -> AddDiscreteProcess(new G4ComptonScattering);
-	  manager -> AddDiscreteProcess(new G4GammaConversion); 
-          manager -> AddProcess(new G4StepLimiter(),-1,-1, 3);
-	}   
-    }
+HRMuonMinusCapture::HRMuonMinusCapture(const G4String& name): 
+   G4VPhysicsConstructor(name)
+{ 
+  G4cout<< "HADRONIC PROCESS(ES): G4MuonMinusCaptureAtRest (muon-)" 
+        << G4endl
+        << "APPLIED MODEL(S): -" 
+        << G4endl;
+}
+
+HRMuonMinusCapture::~HRMuonMinusCapture()
+{ }
+
+void HRMuonMinusCapture::ConstructProcess()
+{
+
+  // *************
+  // *** Muon- ***
+  // *************
+
+  G4MuonMinusCaptureAtRest* muonMinusCaptureProcess= new G4MuonMinusCaptureAtRest();
+
+  G4ParticleDefinition* particle = G4MuonMinus::MuonMinus(); 
+  G4ProcessManager* processManager = particle -> GetProcessManager();
+  processManager -> AddProcess(muonMinusCaptureProcess, 0, -1, -1);
+
 }

examples/advanced/hadrontherapy/src/HadrontherapyBeamLine.cc

@@ -52,7 +52,7 @@
 #include "G4SubtractionSolid.hh"
 
 HadrontherapyBeamLine::HadrontherapyBeamLine(G4VPhysicalVolume* motherVolume):
-  physiBeamLineSupport(0),/* physiBeamLineCover(0), physiBeamLineCover2(0)*/ 
+  physiBeamLineSupport(0),
   firstScatteringFoil(0), physiFirstScatteringFoil(0), physiKaptonWindow(0), 
   solidStopper(0), physiStopper(0), 
   secondScatteringFoil(0), physiSecondScatteringFoil(0),
@@ -69,7 +69,6 @@ HadrontherapyBeamLine::HadrontherapyBeamLine(G4VPhysicalVolume* motherVolume):
   physiThirdMonitorLayer1(0), physiThirdMonitorLayer2(0),
   physiThirdMonitorLayer3(0), physiThirdMonitorLayer4(0),
   physiNozzleSupport(0), physiHoleNozzle(0),
-    /*physiSecondHoleNozzleSupport(0),*/
   solidFinalCollimator(0),
   physiFinalCollimator(0)
 {

examples/advanced/hadrontherapy/src/HadrontherapyDetectorConstruction.cc

@@ -56,10 +56,10 @@
 #include "HadrontherapyDetectorConstruction.hh"
 #include "HadrontherapyMaterial.hh"
 #include "HadrontherapyBeamLine.hh"
-//#include "HadrontherapyModulator.hh"
+#include "HadrontherapyModulator.hh"
 
 HadrontherapyDetectorConstruction::HadrontherapyDetectorConstruction()
-  : phantomSD(0), phantomROGeometry(0), beamLine(0), /*modulator(0),*/
+  : phantomSD(0), phantomROGeometry(0), beamLine(0), modulator(0),
     physicalTreatmentRoom(0),
     patientPhysicalVolume(0), 
     phantomLogicalVolume(0), 
@@ -146,8 +146,8 @@ void HadrontherapyDetectorConstruction::ConstructBeamLine()
   beamLine -> HadrontherapyBeamNozzle();
   beamLine -> HadrontherapyBeamFinalCollimator();
 
-  //modulator = new HadrontherapyModulator();
-  //modulator -> BuildModulator(physicalTreatmentRoom);
+  modulator = new HadrontherapyModulator();
+  modulator -> BuildModulator(physicalTreatmentRoom);
 
   // Patient - Mother volume of the phantom
   G4Box* patient = new G4Box("patient",20 *cm, 20 *cm, 20 *cm);
@@ -243,13 +243,13 @@ void  HadrontherapyDetectorConstruction::ConstructSensitiveDetector()
       phantomLogicalVolume -> SetSensitiveDetector(phantomSD);
     }
 }
-/*
+
 void HadrontherapyDetectorConstruction::SetModulatorAngle(G4double value)
 {  
   modulator -> SetModulatorAngle(value);
   G4RunManager::GetRunManager() -> GeometryHasBeenModified();
 }
-*/
+
 void HadrontherapyDetectorConstruction::SetRangeShifterXPosition(G4double value)
 {
   beamLine -> SetRangeShifterXPosition(value);

examples/advanced/hadrontherapy/src/HadrontherapyDetectorMessenger.cc

@@ -47,8 +47,8 @@ HadrontherapyDetectorMessenger::HadrontherapyDetectorMessenger(
 							       HadrontherapyDetectorConstruction* detector)
   :hadrontherapyDetector(detector)
 { 
-  //modulatorDir = new G4UIdirectory("/modulator/");
-  //modulatorDir -> SetGuidance("Command to rotate the modulator wheel");
+  modulatorDir = new G4UIdirectory("/modulator/");
+  modulatorDir -> SetGuidance("Command to rotate the modulator wheel");
   
   beamLineDir = new G4UIdirectory("/beamLine/");
   beamLineDir -> SetGuidance("set specification of range shifter");  
@@ -68,12 +68,12 @@ HadrontherapyDetectorMessenger::HadrontherapyDetectorMessenger(
   finalCollimatorDir = new G4UIdirectory("/beamLine/FinalCollimator/");
   finalCollimatorDir -> SetGuidance("set specification of final collimator");  
 
-  //  modulatorAngleCmd = new G4UIcmdWithADoubleAndUnit("/modulator/angle",this);
-  //modulatorAngleCmd -> SetGuidance("Set Modulator Angle");
-  //modulatorAngleCmd -> SetParameterName("Size",false);
-  //modulatorAngleCmd -> SetRange("Size>=0.");
-  //modulatorAngleCmd -> SetUnitCategory("Angle");  
-  //modulatorAngleCmd -> AvailableForStates(G4State_Idle);
+  modulatorAngleCmd = new G4UIcmdWithADoubleAndUnit("/modulator/angle",this);
+  modulatorAngleCmd -> SetGuidance("Set Modulator Angle");
+  modulatorAngleCmd -> SetParameterName("Size",false);
+  modulatorAngleCmd -> SetRange("Size>=0.");
+  modulatorAngleCmd -> SetUnitCategory("Angle");  
+  modulatorAngleCmd -> AvailableForStates(G4State_Idle);
   
   rangeShifterMatCmd = new G4UIcmdWithAString("/beamLine/RangeShifter/RSMat",this);
   rangeShifterMatCmd -> SetGuidance("Set material of range shifter");
@@ -132,21 +132,21 @@ HadrontherapyDetectorMessenger::~HadrontherapyDetectorMessenger()
   delete rangeShifterXPositionCmd;
   delete rangeShifterXSizeCmd;
   delete rangeShifterMatCmd;
-  //delete modulatorAngleCmd;
+  delete modulatorAngleCmd;
   delete finalCollimatorDir; 
   delete rangeStopperDir;
   delete secondScatteringFoilDir;
   delete firstScatteringFoilDir; 
   delete rangeShifterDir;  
   delete beamLineDir; 
-  //delete modulatorDir;   
+  delete modulatorDir;   
 }
 
 void HadrontherapyDetectorMessenger::SetNewValue(G4UIcommand* command,G4String newValue)
 { 
-  //if( command == modulatorAngleCmd )
-  //  { hadrontherapyDetector -> SetModulatorAngle
-  //         (modulatorAngleCmd -> GetNewDoubleValue(newValue));}
+  if( command == modulatorAngleCmd )
+    { hadrontherapyDetector -> SetModulatorAngle
+           (modulatorAngleCmd -> GetNewDoubleValue(newValue));}
 
   if( command == rangeShifterMatCmd )
     { hadrontherapyDetector -> SetRSMaterial(newValue);}

examples/advanced/hadrontherapy/src/HadrontherapyIonLowEZiegler2000.cc

@@ -1,100 +0,0 @@
-//
-// ********************************************************************
-// * License and Disclaimer                                           *
-// *                                                                  *
-// * The  Geant4 software  is  copyright of the Copyright Holders  of *
-// * the Geant4 Collaboration.  It is provided  under  the terms  and *
-// * conditions of the Geant4 Software License,  included in the file *
-// * LICENSE and available at  http://cern.ch/geant4/license .  These *
-// * include a list of copyright holders.                             *
-// *                                                                  *
-// * Neither the authors of this software system, nor their employing *
-// * institutes,nor the agencies providing financial support for this *
-// * work  make  any representation or  warranty, express or implied, *
-// * regarding  this  software system or assume any liability for its *
-// * use.  Please see the license in the file  LICENSE  and URL above *
-// * for the full disclaimer and the limitation of liability.         *
-// *                                                                  *
-// * This  code  implementation is the result of  the  scientific and *
-// * technical work of the GEANT4 collaboration.                      *
-// * By using,  copying,  modifying or  distributing the software (or *
-// * any work based  on the software)  you  agree  to acknowledge its *
-// * use  in  resulting  scientific  publications,  and indicate your *
-// * acceptance of all terms of the Geant4 Software license.          *
-// ********************************************************************
-//
-// $Id: HadrontherapyIonLowE.cc; May 2005
-// ----------------------------------------------------------------------------
-//                 GEANT 4 - Hadrontherapy example
-// ----------------------------------------------------------------------------
-// Code developed by:
-//
-// G.A.P. Cirrone(a)*, G. Candiano, F. Di Rosa(a), S. Guatelli(b), G. Russo(a)
-// 
-// (a) Laboratori Nazionali del Sud 
-//     of the National Institute for Nuclear Physics, Catania, Italy
-// (b) National Institute for Nuclear Physics Section of Genova, genova, Italy
-// 
-// * cirrone@lns.infn.it
-// --------------------------------------------------------------
-
-#include "HadrontherapyIonLowEZiegler2000.hh"
-#include "G4ProcessManager.hh"
-#include "G4ParticleDefinition.hh"
-#include "G4MultipleScattering.hh"
-#include "G4hLowEnergyIonisation.hh"
-#include "G4hIonisation.hh"
-#include "G4hLowEnergyLoss.hh"
-#include "G4StepLimiter.hh"
-#include "G4hSRIM2000p.hh" 
-
-HadrontherapyIonLowEZiegler2000::HadrontherapyIonLowEZiegler2000(const G4String& name): G4VPhysicsConstructor(name)
-{ }
-
-HadrontherapyIonLowEZiegler2000::~HadrontherapyIonLowEZiegler2000()
-{ }
-
-void HadrontherapyIonLowEZiegler2000::ConstructProcess()
-{
-  theParticleIterator -> reset();
-
-  while( (*theParticleIterator)() )
-    {
-      G4ParticleDefinition* particle = theParticleIterator -> value();
-      G4ProcessManager* manager = particle -> GetProcessManager();
-      G4String particleName = particle -> GetParticleName();
-      G4double charge = particle -> GetPDGCharge();
-
-      // protons
-      if (particleName == "proton")
-	{
-         G4hLowEnergyIonisation* ionisation = new G4hLowEnergyIonisation();
-         // Electronic Stopping Power: SRIM 2000 parameterisation
-         // Nuclear stopping power: ICRU 49
-         ionisation -> SetElectronicStoppingPowerModel(particle, "SRIM2000p");
-	 ionisation -> SetNuclearStoppingOn() ; 
-
-         G4VProcess*  multipleScattering = new G4MultipleScattering(); 
-         manager -> AddProcess(multipleScattering, -1,1,1);   
-         manager -> AddProcess(ionisation, -1,2,2);
-	 manager -> AddProcess(new G4StepLimiter(),-1,-1, 3);
-	}
-      // ions, alpha, pions, kaons, generic ion.....
-    if (( charge != 0. ) && particleName != "e+" && particleName != "mu+" &&
-	  particleName != "e-" && particleName != "mu-" && particleName != "proton") 
-	{
-	  if((!particle -> IsShortLived()) &&
-	     (particle -> GetParticleName() != "chargedgeantino"))
-	    {
-	      G4hLowEnergyIonisation* ionisation = new G4hLowEnergyIonisation();
-	      ionisation -> SetNuclearStoppingOn() ;
-	      G4VProcess*  multipleScattering = new G4MultipleScattering(); 
-	      manager -> AddProcess(multipleScattering, -1,1,1);   
-	      manager -> AddProcess(ionisation, -1,2,2);
-	      manager -> AddProcess(new G4StepLimiter(),-1,-1, 3);
-	    }
-	}
-    }
-}
-
-   

examples/advanced/hadrontherapy/src/HadrontherapyMaterial.cc

@@ -218,6 +218,8 @@ void HadrontherapyMaterial::DefineMaterials()
   matH2O -> AddElement(elH,2);
   matH2O -> AddElement(elO,1);
   matH2O -> GetIonisation()->SetMeanExcitationEnergy(75.0*eV);
+  matH2O -> SetChemicalFormula("H_2O");
+  G4cout << "-----------> CHEMICAL FORMULA FOR WATER FIXED <----------"<< G4endl;
 
   //soft tissue(http://www.nist.gov)
   d = 1.0*g/cm3;

examples/advanced/hadrontherapy/src/HadrontherapyMuonStandard.cc

@@ -1,103 +0,0 @@
-//
-// ********************************************************************
-// * License and Disclaimer                                           *
-// *                                                                  *
-// * The  Geant4 software  is  copyright of the Copyright Holders  of *
-// * the Geant4 Collaboration.  It is provided  under  the terms  and *
-// * conditions of the Geant4 Software License,  included in the file *
-// * LICENSE and available at  http://cern.ch/geant4/license .  These *
-// * include a list of copyright holders.                             *
-// *                                                                  *
-// * Neither the authors of this software system, nor their employing *
-// * institutes,nor the agencies providing financial support for this *
-// * work  make  any representation or  warranty, express or implied, *
-// * regarding  this  software system or assume any liability for its *
-// * use.  Please see the license in the file  LICENSE  and URL above *
-// * for the full disclaimer and the limitation of liability.         *
-// *                                                                  *
-// * This  code  implementation is the result of  the  scientific and *
-// * technical work of the GEANT4 collaboration.                      *
-// * By using,  copying,  modifying or  distributing the software (or *
-// * any work based  on the software)  you  agree  to acknowledge its *
-// * use  in  resulting  scientific  publications,  and indicate your *
-// * acceptance of all terms of the Geant4 Software license.          *
-// ********************************************************************
-//
-// $Id: HadrontherapyMuonStandard.cc; May 2005
-// ----------------------------------------------------------------------------
-//                 GEANT 4 - Hadrontherapy example
-// ----------------------------------------------------------------------------
-// Code developed by:
-//
-// G.A.P. Cirrone(a)*, F. Di Rosa(a), S. Guatelli(b), G. Russo(a)
-// 
-// (a) Laboratori Nazionali del Sud 
-//     of the National Institute for Nuclear Physics, Catania, Italy
-// (b) National Institute for Nuclear Physics Section of Genova, genova, Italy
-// 
-// * cirrone@lns.infn.it
-// ----------------------------------------------------------------------------
-
-#include "HadrontherapyMuonStandard.hh"
-#include "G4ProcessManager.hh"
-
-//muon:
-#include "G4hIonisation.hh"
-#include "G4MultipleScattering.hh"
-#include "G4MuIonisation.hh"
-#include "G4MuBremsstrahlung.hh"
-#include "G4MuPairProduction.hh"
-#include "G4MuonMinusCaptureAtRest.hh" 
-#include "G4StepLimiter.hh"
-
-HadrontherapyMuonStandard::HadrontherapyMuonStandard(const G4String& name): G4VPhysicsConstructor(name)
-{ }
-
-HadrontherapyMuonStandard::~HadrontherapyMuonStandard()
-{ }
-
-void HadrontherapyMuonStandard::ConstructProcess()
-{
-  // Add standard processes for muons
-  
-  theParticleIterator -> reset();
-
-  while( (*theParticleIterator)() )
-    {
-      G4ParticleDefinition* particle = theParticleIterator->value();
-      G4ProcessManager* pmanager = particle -> GetProcessManager();
-      G4String particleName = particle -> GetParticleName();
-     
-      if(( particleName == "mu+")|| (particleName == "mu-" ))
-	{
-           //muon
-	  G4VProcess* aMultipleScattering = new G4MultipleScattering();
-	  G4VProcess* aBremsstrahlung     = new G4MuBremsstrahlung();
-	  G4VProcess* aPairProduction     = new G4MuPairProduction();
-	  G4VProcess* anIonisation        = new G4MuIonisation();
-	  //
-	  // add processes
-	  pmanager -> AddProcess(anIonisation);
-	  pmanager -> AddProcess(aMultipleScattering);
-	  pmanager -> AddProcess(aBremsstrahlung);
-	  pmanager -> AddProcess(aPairProduction);
-	  //
-	  // set ordering for AlongStepDoIt
-	  pmanager -> SetProcessOrdering(aMultipleScattering, idxAlongStep,1);
-	  pmanager -> SetProcessOrdering(anIonisation,        idxAlongStep,2);
-	  pmanager -> SetProcessOrdering(aBremsstrahlung,     idxAlongStep,3);
-	  pmanager -> SetProcessOrdering(aPairProduction,     idxAlongStep,4);      
-	  //
-	  // set ordering for PostStepDoIt
-	  pmanager -> SetProcessOrdering(aMultipleScattering, idxPostStep,1);
-	  pmanager -> SetProcessOrdering(anIonisation,        idxPostStep,2);
-	  pmanager -> SetProcessOrdering(aBremsstrahlung,     idxPostStep,3);
-	  pmanager -> SetProcessOrdering(aPairProduction,     idxPostStep,4);
-          pmanager -> AddProcess(new G4StepLimiter(),      -1,-1, 3);
-
-	  if( particleName == "mu-" )
-	    pmanager -> AddProcess(new G4MuonMinusCaptureAtRest(), 0,-1,-1);
-	}
-    }
-  // G4cout << "Muon processes are active!"<<G4endl;
-}

examples/advanced/hadrontherapy/src/HadrontherapyProtonBertini.cc

@@ -1,313 +0,0 @@
-//
-// ********************************************************************
-// * License and Disclaimer                                           *
-// *                                                                  *
-// * The  Geant4 software  is  copyright of the Copyright Holders  of *
-// * the Geant4 Collaboration.  It is provided  under  the terms  and *
-// * conditions of the Geant4 Software License,  included in the file *
-// * LICENSE and available at  http://cern.ch/geant4/license .  These *
-// * include a list of copyright holders.                             *
-// *                                                                  *
-// * Neither the authors of this software system, nor their employing *
-// * institutes,nor the agencies providing financial support for this *
-// * work  make  any representation or  warranty, express or implied, *
-// * regarding  this  software system or assume any liability for its *
-// * use.  Please see the license in the file  LICENSE  and URL above *
-// * for the full disclaimer and the limitation of liability.         *
-// *                                                                  *
-// * This  code  implementation is the result of  the  scientific and *
-// * technical work of the GEANT4 collaboration.                      *
-// * By using,  copying,  modifying or  distributing the software (or *
-// * any work based  on the software)  you  agree  to acknowledge its *
-// * use  in  resulting  scientific  publications,  and indicate your *
-// * acceptance of all terms of the Geant4 Software license.          *
-// ********************************************************************
-//
-// $Id: HadrontherapyProtonBertini.cc; May 2005
-// ----------------------------------------------------------------------------
-//                 GEANT 4 - Hadrontherapy example
-// ----------------------------------------------------------------------------
-// Code developed by:
-//
-// G.A.P. Cirrone(a)*, F. Di Rosa(a), S. Guatelli(b), G. Russo(a)
-// 
-// (a) Laboratori Nazionali del Sud 
-//     of the National Institute for Nuclear Physics, Catania, Italy
-// (b) National Institute for Nuclear Physics Section of Genova, genova, Italy
-// 
-// * cirrone@lns.infn.it
-
-// Code review by M.G. Pia, 2 November 2006
-// Further code review is needed
-// ----------------------------------------------------------------------------
-
-#include "HadrontherapyProtonBertini.hh"
-#include "G4ParticleDefinition.hh"
-#include "G4ProcessManager.hh"
-#include "G4ParticleTypes.hh"
-#include "G4HadronElasticProcess.hh"
-#include "G4ProtonInelasticProcess.hh"
-#include "G4ExcitationHandler.hh" 
-#include "G4NeutronInelasticProcess.hh"
-#include "G4HadronInelasticProcess.hh"
-#include "G4DeuteronInelasticProcess.hh"
-#include "G4TritonInelasticProcess.hh"
-#include "G4AlphaInelasticProcess.hh"
-#include "G4LElastic.hh"
-#include "G4CascadeInterface.hh"
-#include "G4PionPlusInelasticProcess.hh"
-#include "G4LEPionPlusInelastic.hh"
-#include "G4LEPionMinusInelastic.hh"
-#include "G4PionMinusInelasticProcess.hh"
-#include "G4CascadeElasticInterface.hh"
-#include "G4HadronFissionProcess.hh"
-#include "G4HadronCaptureProcess.hh"
-#include "G4LFission.hh"
-#include "G4LCapture.hh"
-#include "G4TripathiCrossSection.hh"
-#include "G4IonsShenCrossSection.hh"
-#include "G4BinaryLightIonReaction.hh"
-#include "G4LEDeuteronInelastic.hh"
-#include "G4LETritonInelastic.hh"
-#include "G4LEAlphaInelastic.hh"
-
-// BERTINI PHYSICS LIST
-//
-// BERTINI FOR PROTONS, NEUTRONS AND PIONS
-// 
-// LEP MODEL UP TO 100 MEV AND BINARY ION MODEL BETWEEN 80 MEV AND 40. GEV 
-// FOR  DEUTERON, TRITON, ALPHA
-// 
-// FISSION AND HADRON CAPTURE FOR NEUTRONS BETWEEN 0. MEV AND 100. TEV
-//
-HadrontherapyProtonBertini::HadrontherapyProtonBertini(const G4String& name): 
-  G4VPhysicsConstructor(name)
-{
-  G4cout << "The Bertini model (for inelastic scattering) is set for protons, neutrons and pions" << G4endl;
-
-  // The Bertini model is set for protons, neutrons and pions
-  // This model contains a pre-equilibrium model and a de-excitation model
- 
-  // Ions:
-  // The inelastic scattering is modelled with  LEP model up to 100 MeV,
-  // then Binary Ion Model 
-}
-
-HadrontherapyProtonBertini::~HadrontherapyProtonBertini()
-{}
-
-void HadrontherapyProtonBertini::ConstructProcess()
-{
-  G4ParticleDefinition* particle = 0;
-  G4ProcessManager* processManager = 0;
-
-  // Physics for proton, neutron, pion+ and pion-
-
-  // Elastic scattering: Low Energy Parameterised model 
-  G4LElastic* elasticModel = new G4LElastic();
-  G4HadronElasticProcess* elasticScattering = new G4HadronElasticProcess();
-  elasticScattering->RegisterMe(elasticModel);
-
-  // Inelastic scattering: Bertini Inelastic model
-  G4CascadeInterface* theBertiniModel = new G4CascadeInterface;
-  
-  // Energy limit of the Bertini model
-  G4double bertiniLowEnergyLimit = 0.* MeV;
-  G4double bertiniHighEnergyLimit = 300.*MeV;
- 
-  theBertiniModel->SetMinEnergy(bertiniLowEnergyLimit);
-  theBertiniModel->SetMaxEnergy(bertiniHighEnergyLimit);
-
-  //--------------------------------------------------------------------------------------
-  // Proton processes
-  particle = G4Proton::Proton();
-  processManager = particle->GetProcessManager();
-  
-  // Model Registration 
-  G4ProtonInelasticProcess* theProtonInelasticProcess = new G4ProtonInelasticProcess();
-  theProtonInelasticProcess->RegisterMe(theBertiniModel);
-
-  // Activate the cross-sections for proton nuclear scattering up to 20 GeV
-  theProtonInelasticProcess->AddDataSet(&theProtonCrossSection);
- 
-  // Activate the proton inelastic scattering 
-  processManager->AddDiscreteProcess(theProtonInelasticProcess);
-  // Activate the elastic scattering 
-  processManager->AddDiscreteProcess(elasticScattering); 
-
-  //--------------------------------------------------------------------------------------
-  // Pions plus processes
-  particle = G4PionPlus::PionPlus(); 
-  processManager = particle->GetProcessManager();
-
-  // Define the inelastic process for pions plus
-  G4PionPlusInelasticProcess* thePionPlusInelasticProcess = new G4PionPlusInelasticProcess("inelastic");
-  // Register the Low Energy Inelastic Model for pions plus
-  thePionPlusInelasticProcess->RegisterMe(theBertiniModel);
-  // Activate the inelastic process for pions plus
-  processManager->AddDiscreteProcess(thePionPlusInelasticProcess);
-  // Activate the elastic process for pions plus
-  processManager->AddDiscreteProcess(elasticScattering);
-
-  //--------------------------------------------------------------------------------------
-  // Pion Minus processes
-  particle = G4PionMinus::PionMinus();
-  processManager = particle->GetProcessManager();
-
-  // Define the inelastic process for pions minus
-  G4PionMinusInelasticProcess* thePionMinusInelasticProcess = new G4PionMinusInelasticProcess("inelastic");
-  // Register the inelastic model for pion minus  
-  thePionMinusInelasticProcess->RegisterMe(theBertiniModel);
-  // Activate the inelastic process for pion minus
-  processManager->AddDiscreteProcess(thePionMinusInelasticProcess); 
-  // Activate the elastic process for pion minus
-  processManager->AddDiscreteProcess(elasticScattering);   
-
-  //--------------------------------------------------------------------------------------
-  // Neutron processes
-  particle = G4Neutron::Neutron();
-  processManager = particle->GetProcessManager();
-
-  // Register the Bertini model
-  G4NeutronInelasticProcess* theNeutronInelasticProcess = new G4NeutronInelasticProcess();
-  theNeutronInelasticProcess->RegisterMe(theBertiniModel);
-
-  // Activate the Cross-sections for neutron nuclear scattering from 14 MeV up to 20 GeV
-  theNeutronInelasticProcess->AddDataSet(&theNeutronCrossSection);
-  // Activate the neutron inelastic process
-  processManager->AddDiscreteProcess(theNeutronInelasticProcess);
-  // Activate the Hadron Elastic Process
-  processManager->AddDiscreteProcess(elasticScattering);
-
-  // Neutron capture process
- 
-  // Energy limits 
-  G4double neutronLowEnergyLimit = 0. * MeV;
-  G4double neutronHighEnergyLimit = 100. * TeV;
-
-  G4HadronCaptureProcess* neutronCapture = new G4HadronCaptureProcess();
-  // Final state production model for capture of neutral hadrons in nuclei
-  G4LCapture* captureModel = new G4LCapture();
-  // Set the energy range for the capture model
-  captureModel->SetMinEnergy(neutronLowEnergyLimit);
-  captureModel->SetMaxEnergy(neutronHighEnergyLimit);
-  // Register the neutron capture model
-  neutronCapture->RegisterMe(captureModel);
-  // Activate the neutron capture process
-  processManager->AddDiscreteProcess(neutronCapture);
-
-  // Process for induced fission
-  G4HadronFissionProcess* fission = new G4HadronFissionProcess();
-  //Final state production model for induced fission
-  G4LFission* fissionModel = new G4LFission();
-  // Set the energy range for the fission model
-  fissionModel->SetMinEnergy(neutronLowEnergyLimit);
-  fissionModel->SetMaxEnergy(neutronHighEnergyLimit);
-  // Register the fission model
-  fission->RegisterMe(fissionModel); 
-  // Activate the fission process
-  processManager->AddDiscreteProcess(fission); 
-
-  //--------------------------------------------------------------------------------------
-  // Physics for ions
-
-  // Energy limit of the LEP model for ions
-  G4double LEPHighEnergyLimit = 100.* MeV;
-
-  // Energy limit of the binary ion model
-  G4double binaryLightIonLowEnergyLimit = 80.* MeV;
-  G4double binaryLightIonHighEnergyLimit = 40.* GeV;
-
-  // Cross section data sets
-
-  // TRIPATHI CROSS SECTION
-  // Implementation of formulas taken from NASA technical paper 3621 by 
-  // Tripathi, et al. Cross-sections for ion ion scattering
-  G4TripathiCrossSection* tripathiCrossSection = new G4TripathiCrossSection;
-  
-  // IONS SHEN CROSS SECTION
-  // Implementation of formulas 
-  // Shen et al. Nuc. Phys. A 491 130 (1989) 
-  // Total Reaction Cross Section for Heavy-Ion Collisions
-  G4IonsShenCrossSection* aShen = new G4IonsShenCrossSection;
-
-  // Intra-nuclear transport: Binary Cascade Model
-  // Binary Cascade for deuteron, triton, alpha particle
-  G4BinaryLightIonReaction* theBinaryCascade = new G4BinaryLightIonReaction();
-  // Set the min and max energy for the Binary Cascade
-  theBinaryCascade->SetMinEnergy(binaryLightIonLowEnergyLimit);
-  theBinaryCascade->SetMaxEnergy(binaryLightIonHighEnergyLimit);
-
-  //--------------------------------------------------------------------------------------
-  // Deuteron 
-  particle = G4Deuteron::Deuteron();
-  processManager = particle->GetProcessManager();
-
-  // Final state production model for deuteron inelastic scattering below 100 MeV: Low Energy Parameterised model
-  G4LEDeuteronInelastic* theDeuteronLEInelasticModel = new G4LEDeuteronInelastic;
-  // Set the maximum energy for LEP model
-  theDeuteronLEInelasticModel->SetMaxEnergy(LEPHighEnergyLimit);
- // G4DeuteronInelasticProcess theDeuteronInelasticProcess;
- 
-  // Activate the Tripathi and Shen Cross Section
-  theDeuteronInelasticProcess.AddDataSet(tripathiCrossSection);
-  theDeuteronInelasticProcess.AddDataSet(aShen);
-
-  // Register the Parameterised Deuteron Inelastic Model and the Ion Binary Cascade Model
-  theDeuteronInelasticProcess.RegisterMe(theDeuteronLEInelasticModel);
-  theDeuteronInelasticProcess.RegisterMe(theBinaryCascade);
-
-  // Activate the deuteron elastic and inelastic scattering 
-  processManager->AddDiscreteProcess(&theDeuteronInelasticProcess);
-  // Activate the Hadron Elastic Process
-  processManager->AddDiscreteProcess(elasticScattering); 
-
-  //--------------------------------------------------------------------------------------
-  // Triton
-  particle = G4Triton::Triton();
-  processManager = particle->GetProcessManager();
-  
-  // Final state production model for Triton inelastic scattering below 100 MeV: Low Energy Parameterised model
-  G4LETritonInelastic* theTritonLEInelasticModel = new G4LETritonInelastic;  
-  // Set the maximum energy for LEP model
-  theTritonLEInelasticModel->SetMaxEnergy(LEPHighEnergyLimit);
-
-  // Activate the Tripathi and Shen Cross Section
-  //G4TritonInelasticProcess theTritonInelasticProcess;
-  theTritonInelasticProcess.AddDataSet(tripathiCrossSection);
-  theTritonInelasticProcess.AddDataSet(aShen);
-
-  // Register the Triton Inelastic and Binary Cascade Models
-  theTritonInelasticProcess.RegisterMe(theTritonLEInelasticModel);
-  theTritonInelasticProcess.RegisterMe(theBinaryCascade);
-
-  // Activate the triton inelastic scattering using the parameterised Triton Inelastic and Binary Cascade models
-  processManager->AddDiscreteProcess(&theTritonInelasticProcess);
-  // Activate the Hadron Elastic Process
-  processManager->AddDiscreteProcess(elasticScattering);
-
-  //--------------------------------------------------------------------------------------
-  // Alpha
-  particle = G4Alpha::Alpha();
-  processManager = particle->GetProcessManager();
-
-  // Final state production model for Alpha inelastic scattering below 20 GeV: Low Energy Parameterised model
-  G4LEAlphaInelastic* theAlphaLEInelasticModel = new G4LEAlphaInelastic;
-  // Set the maximum energy for LEP model
-  theAlphaLEInelasticModel->SetMaxEnergy(LEPHighEnergyLimit);
-
-  //G4AlphaInelasticProcess theAlphaInelasticProcess;
-
-  //  Activate the Tripathi and Shen Cross Section
-  theAlphaInelasticProcess.AddDataSet(tripathiCrossSection);
-  theAlphaInelasticProcess.AddDataSet(aShen);
-
-  // Register the Alpha Inelastic and Binary Cascade Models
-  theAlphaInelasticProcess.RegisterMe(theAlphaLEInelasticModel);
-  theAlphaInelasticProcess.RegisterMe(theBinaryCascade);
-
-  // Activate the alpha inelastic scattering using the parameterised Alpha Inelastic and Binary Cascade models
-  processManager->AddDiscreteProcess(&theAlphaInelasticProcess);
-  // Activate the Hadron Elastic Process
-  processManager->AddDiscreteProcess(elasticScattering); 
-}

examples/advanced/hadrontherapy/src/HadrontherapyProtonPrecompound.cc

@@ -1,287 +0,0 @@
-//
-// ********************************************************************
-// * License and Disclaimer                                           *
-// *                                                                  *
-// * The  Geant4 software  is  copyright of the Copyright Holders  of *
-// * the Geant4 Collaboration.  It is provided  under  the terms  and *
-// * conditions of the Geant4 Software License,  included in the file *
-// * LICENSE and available at  http://cern.ch/geant4/license .  These *
-// * include a list of copyright holders.                             *
-// *                                                                  *
-// * Neither the authors of this software system, nor their employing *
-// * institutes,nor the agencies providing financial support for this *
-// * work  make  any representation or  warranty, express or implied, *
-// * regarding  this  software system or assume any liability for its *
-// * use.  Please see the license in the file  LICENSE  and URL above *
-// * for the full disclaimer and the limitation of liability.         *
-// *                                                                  *
-// * This  code  implementation is the result of  the  scientific and *
-// * technical work of the GEANT4 collaboration.                      *
-// * By using,  copying,  modifying or  distributing the software (or *
-// * any work based  on the software)  you  agree  to acknowledge its *
-// * use  in  resulting  scientific  publications,  and indicate your *
-// * acceptance of all terms of the Geant4 Software license.          *
-// ********************************************************************
-//
-// $Id: HadrontherapyProtonPrecompound.cc; May 2005
-// ----------------------------------------------------------------------------
-//                 GEANT 4 - Hadrontherapy example
-// ----------------------------------------------------------------------------
-// Code developed by:
-//
-// G.A.P. Cirrone(a)*, F. Di Rosa(a), S. Guatelli(b), G. Russo(a)
-// 
-// (a) Laboratori Nazionali del Sud 
-//     of the INFN, Catania, Italy
-// (b) INFN Section of Genova, Genova, Italy
-// 
-// * cirrone@lns.infn.it
-// ----------------------------------------------------------------------------
-
-#include "HadrontherapyProtonPrecompound.hh"
-#include "G4ParticleDefinition.hh"
-#include "G4ProcessManager.hh"
-#include "G4LElastic.hh"
-#include "G4PionPlusInelasticProcess.hh"
-#include "G4LEPionPlusInelastic.hh"
-#include "G4LEPionMinusInelastic.hh"
-#include "G4PionMinusInelasticProcess.hh"
-#include "G4PiMinusAbsorptionAtRest.hh"
-#include "G4PiNuclearCrossSection.hh" 
-#include "G4LFission.hh"
-#include "G4LCapture.hh"
-#include "G4TripathiCrossSection.hh"
-#include "G4IonsShenCrossSection.hh"
-#include "G4HadronInelasticProcess.hh"
-#include "G4LEDeuteronInelastic.hh"
-#include "G4LETritonInelastic.hh"
-#include "G4LEAlphaInelastic.hh"
-#include "G4HadronElasticProcess.hh"
-#include "G4HadronCaptureProcess.hh"
-#include "G4BinaryLightIonReaction.hh" 
-#include "G4HadronInelasticProcess.hh"
-//
-// PRECOMPOUND PHYSICS LIST
-//
-// PRECOMPOUND + EVAPORATION(DEFAULT EVAPORATION) FOR PROTONS, NEUTRONS AND PIONS
-
-HadrontherapyProtonPrecompound::HadrontherapyProtonPrecompound(const G4String& name): 
-  G4VPhysicsConstructor(name)
-{
-  G4cout<<"****** Proton Precompound Physics List is active !!!!!! ******"
-	<<G4endl;
-}
-
-HadrontherapyProtonPrecompound::~HadrontherapyProtonPrecompound()
-{}
-
-void HadrontherapyProtonPrecompound::ConstructProcess()
-{
- G4ParticleDefinition* particle = 0;
- G4ProcessManager* pmanager = 0;
-
- // Physics for proton, neutron, pion+ and pion-
- // Elastic scattering: Low Energy Parameterised model 
- 
-  G4LElastic* elasticScatteringModel = new G4LElastic();
-  G4HadronElasticProcess* elasticScattering = new G4HadronElasticProcess();
-  elasticScattering -> RegisterMe(elasticScatteringModel);
-  
-  // Inelastic scattering: Inelastic PreCompound model
-  G4PreCompoundModel* preequilibriumModel = new G4PreCompoundModel(&theHandler);
-  // Set the minimum and maximum energy value of the pre-equilibrium model
-  G4double precompoundLowLimit = 0. * MeV;
-  G4double precompoundHighLimit = 300. * MeV;
-  preequilibriumModel -> SetMinEnergy(precompoundLowLimit);
-  preequilibriumModel -> SetMaxEnergy(precompoundHighLimit);
-
-  //--------------------------------------------------------------------------------------
-  // Proton processes
-  particle = G4Proton::Proton();
-  pmanager = particle -> GetProcessManager();
-  
-  // Model Registration 
-  protonInelasticProcess.RegisterMe(preequilibriumModel);
-  // Activate the cross-sections for proton nuclear scattering 
-  protonInelasticProcess.AddDataSet(&protonInelasticCrossSection);
-   
-  // Activate the proton inelastic scattering using the precompound model
-  pmanager -> AddDiscreteProcess(&protonInelasticProcess);
-  // Activate the proton elastic scattering 
-  pmanager -> AddDiscreteProcess(elasticScattering); 
-
-  //--------------------------------------------------------------------------------------
-  // Neutron processes
-
-  particle = G4Neutron::Neutron();
-  pmanager = particle -> GetProcessManager();
-		  
-  // Register the Precompound model
-  neutronInelasticProcess.RegisterMe(preequilibriumModel);
-  // Activate the Cross-sections for neutron nuclear scattering
-  neutronInelasticProcess.AddDataSet(&neutronInelasticCrossSection);
-
-  // Activate the neutron inelastic process
-  pmanager -> AddDiscreteProcess(&neutronInelasticProcess);
-  // Activate the neutron elastic scattering
-  pmanager -> AddDiscreteProcess(elasticScattering); 
-  
- // Neutron capture process
- 
-  // Energy limits 
-  G4HadronCaptureProcess* neutronCapture = new G4HadronCaptureProcess();
-
-  G4LCapture* captureModel = new G4LCapture();
-
-  // Energy limit of the neutron fission and capture
-  G4double neutronLowLimit = 0.*TeV;
-  G4double neutronHighLimit = 100.*TeV;
-  // Set the energy range for the capture model
-  captureModel -> SetMinEnergy(neutronLowLimit);
-  captureModel -> SetMaxEnergy(neutronHighLimit);
-
-  // Register the capture model
-  neutronCapture -> RegisterMe(captureModel);
-  // Active the capture process
-  pmanager -> AddDiscreteProcess(neutronCapture);
-
-  // Process for induced fission
-  G4HadronFissionProcess* fission = new G4HadronFissionProcess();
-  //Final state production model for induced fission
-  G4LFission* fissionModel = new G4LFission();
-  // Set the energy range for the fission model
-  fissionModel -> SetMinEnergy(neutronLowLimit);
-  fissionModel -> SetMaxEnergy(neutronHighLimit);
-  // Register the fission model
-  fission -> RegisterMe(fissionModel); 
-  // Active the fission process
-  pmanager -> AddDiscreteProcess(fission);  
-
-  //--------------------------
-  // Pion Plus
-
-  particle = G4PionPlus::PionPlus(); 
-  pmanager = particle -> GetProcessManager();
- 
-  // Define the inelastic process for pions plus
-  G4PionPlusInelasticProcess* pionPlusInelasticProcess = new G4PionPlusInelasticProcess("inelastic");
-  pionPlusInelasticProcess -> RegisterMe(preequilibriumModel);
- 
-  // Active the inelastic process for pions plus
-  pmanager -> AddDiscreteProcess(pionPlusInelasticProcess);
-  pmanager -> AddDiscreteProcess(elasticScattering);
- 
-  //-----------------------------
-  // Pion Minus
-
-  particle = G4PionMinus::PionMinus();
-  pmanager = particle -> GetProcessManager();
-
-  // Define the inelastic process for pions minus
-  G4PionMinusInelasticProcess* pionMinusInelasticProcess = new G4PionMinusInelasticProcess("inelastic");
-  // Register the inelastic model for pion minus  
-  pionMinusInelasticProcess -> RegisterMe(preequilibriumModel);
-
-  // Active the inelastic process for pion minus
-  pmanager -> AddDiscreteProcess(pionMinusInelasticProcess); 
-  pmanager -> AddDiscreteProcess(elasticScattering); 
-   
-  //--------------------------------------------------------------------------------------
-  // Physics for ions
- 
-  // Energy limit of the LEP model for ions
-  G4double LEPHighLimit = 200.*MeV;
- 
-  // TRIPATHI CROSS SECTION
-  // Implementation of formulas in analogy to NASA technical paper 3621 by 
-  // Tripathi, et al. Cross-sections for ion ion scattering
-  G4TripathiCrossSection* TripathiCrossSection = new G4TripathiCrossSection;
-  
-  // IONS SHEN CROSS SECTION
-  // Implementation of formulas 
-  // Shen et al. Nuc. Phys. A 491 130 (1989) 
-  // Total Reaction Cross Section for Heavy-Ion Collisions
-  G4IonsShenCrossSection* aShen = new G4IonsShenCrossSection;
-
-  particle = G4Deuteron::Deuteron();
-  pmanager = particle -> GetProcessManager();
-
-  // Final state production model for Deuteron inelastic scattering below 100 MeV
-  G4LEDeuteronInelastic* deuteronLEModel = new G4LEDeuteronInelastic;
-  // Set the maximum energy for LEP model
-  deuteronLEModel -> SetMaxEnergy(LEPHighLimit);
-
-  // Active the Tripathi and aShen Cross Section
-  deuteronInelasticProcess.AddDataSet(TripathiCrossSection);
-  deuteronInelasticProcess.AddDataSet(aShen);
-
-  // Register the deuteron inelastic scattering models
-  deuteronInelasticProcess.RegisterMe(deuteronLEModel);
-  
-  // Active the deuteron inelastic scattering using the deuteron inelastic and binary cascade model
-  pmanager -> AddDiscreteProcess(&deuteronInelasticProcess);
-  // Active the Hadron Elastic Process
-  pmanager -> AddDiscreteProcess(elasticScattering); 
-
-  // Triton
-  particle = G4Triton::Triton();
-  pmanager = particle -> GetProcessManager();
-  
-  // Final state production model for Triton inelastic scattering below 100 MeV
-  G4LETritonInelastic* tritonLEModel = new G4LETritonInelastic;
-  // Set the maximum energy for LEP model
-  tritonLEModel -> SetMaxEnergy(LEPHighLimit);
-
-  // Active the Tripathi and aShen Cross Section
-  tritonInelasticProcess.AddDataSet(TripathiCrossSection);
-  tritonInelasticProcess.AddDataSet(aShen);
-
-  // Register the triton inelastic scattering models
-  tritonInelasticProcess.RegisterMe(tritonLEModel);
-
-  // Active the triton inelastic scattering process
-  pmanager -> AddDiscreteProcess(&tritonInelasticProcess);
-  // Active the triton elastic scattering process
-  pmanager -> AddDiscreteProcess(elasticScattering);
-
-  // Alpha particles
-  particle = G4Alpha::Alpha();
-  pmanager = particle -> GetProcessManager();
-		  
-  // Final state production model for Alpha inelastic scattering below 20 GeV
-  G4LEAlphaInelastic* alphaLEModel = new G4LEAlphaInelastic;
-  // Set the maximum energy for LEP model
-  alphaLEModel -> SetMaxEnergy(LEPHighLimit);
- 
- // Register the alpha inelastic scattering models
-  alphaInelasticProcess.AddDataSet(TripathiCrossSection);
-  alphaInelasticProcess.AddDataSet(aShen);
- 
-  // Register the alpha inelastic scattering models
-  alphaInelasticProcess.RegisterMe(alphaLEModel);
- 
-  // Active the alpha inelastic scattering
-  pmanager -> AddDiscreteProcess(&alphaInelasticProcess);
-  // Active the alpha elastic scattering
-  pmanager -> AddDiscreteProcess(elasticScattering); 
-
-  // He3
-  // particle = G4He3::He3();
-
-  // G4HadronInelasticProcess* He3inelasticProcess = 
-  //   new G4HadronInelasticProcess("He3Inelastic",particle);
-  
-  //   G4BinaryLightIonReaction * ionBinaryCascade= new G4BinaryLightIonReaction;
- 
-  // He3inelasticProcess -> AddDataSet(TripathiCrossSection);
-  //He3inelasticProcess -> AddDataSet(aShen);
-  //He3inelasticProcess -> RegisterMe(ionBinaryCascade);
- 
-  //pmanager = particle -> GetProcessManager();
-  //pmanager -> AddDiscreteProcess(He3inelasticProcess);
-  //pmanager -> AddDiscreteProcess(elasticScattering); 
-
-}
-
-
-