Import Geant4 11.0.0.beta source tree

examples/advanced/underground_physics/src/DMXDetectorMaterial.icc

@@ -51,7 +51,6 @@
     (name="Vacuum", z=1., a=1.*g/mole, density=1.e-20*g/cm3,
      kStateGas, temperature=0.1*kelvin, pressure=1.e-20*bar);
 
-
   // xenons
   G4Element* elementXe = new G4Element( "Xenon", "Xe", 54., 131.29*g/mole );
   G4Material* LXe = new G4Material
@@ -66,39 +65,67 @@
   std::vector<G4double> LXe_SCINT = { 0.1, 1.0, 0.1 };
   std::vector<G4double> LXe_RIND  = { 1.59 , 1.57, 1.54 };
   std::vector<G4double> LXe_ABSL  = { 35.*cm, 35.*cm, 35.*cm}; //atten length
+  std::vector<G4double> LXe_scint_e = { 0.*MeV, 10.*MeV };
+  std::vector<G4double> LXe_scint_default = { 0., 120000.};
+  std::vector<G4double> LXe_scint_alpha = { 0., 132000.};
+  std::vector<G4double> LXe_scint_ion = { 0., 24000.};
   G4MaterialPropertiesTable *LXe_mt = new G4MaterialPropertiesTable();
-  LXe_mt->AddProperty("FASTCOMPONENT", LXe_PP, LXe_SCINT);
-  LXe_mt->AddProperty("SLOWCOMPONENT", LXe_PP, LXe_SCINT);
+  LXe_mt->AddProperty("SCINTILLATIONCOMPONENT1", LXe_PP, LXe_SCINT);
+  LXe_mt->AddProperty("SCINTILLATIONCOMPONENT2", LXe_PP, LXe_SCINT);
   LXe_mt->AddProperty("RINDEX",        LXe_PP, LXe_RIND);
   LXe_mt->AddProperty("ABSLENGTH",     LXe_PP, LXe_ABSL);
-  LXe_mt->AddConstProperty("SCINTILLATIONYIELD",12000./MeV); // include QE 20%
+  LXe_mt->AddProperty("ELECTRONSCINTILLATIONYIELD", LXe_scint_e, LXe_scint_default); // include QE 20%
   // and 13eV creation energy for photons - may be 15eV?
   // Fano factor assumed 1; should be much less for Xe ~ 0.13
   // but the Fano factor is already partially included in the correlated 
   // electron production - therefore not the absolute Fano factor here:
+  LXe_mt->AddConstProperty("ELECTRONSCINTILLATIONYIELD1", 0.);
+  LXe_mt->AddConstProperty("ELECTRONSCINTILLATIONYIELD2", 1.);
+
+  LXe_mt->AddProperty("ALPHASCINTILLATIONYIELD", LXe_scint_e, LXe_scint_alpha); // include QE 20%
+  LXe_mt->AddConstProperty("ALPHASCINTILLATIONYIELD1", 1.);
+  LXe_mt->AddConstProperty("ALPHASCINTILLATIONYIELD2", 0.);
+
+  LXe_mt->AddProperty("IONSCINTILLATIONYIELD", LXe_scint_e, LXe_scint_ion); // include QE 20%
+  LXe_mt->AddConstProperty("IONSCINTILLATIONYIELD1", 1.);
+  LXe_mt->AddConstProperty("IONSCINTILLATIONYIELD2", 0.);
+
   LXe_mt->AddConstProperty("RESOLUTIONSCALE",1.0);
-  LXe_mt->AddConstProperty("FASTTIMECONSTANT",20.*ns);
-  LXe_mt->AddConstProperty("SLOWTIMECONSTANT",45.*ns);
-  LXe_mt->AddConstProperty("YIELDRATIO",1.0);
+  LXe_mt->AddConstProperty("SCINTILLATIONTIMECONSTANT1",20.*ns);
+  LXe_mt->AddConstProperty("SCINTILLATIONTIMECONSTANT2",45.*ns);
   LXe->SetMaterialPropertiesTable(LXe_mt);
 
-  //  std::vector<G4double> GXe_PP    = { 7.07*eV, 7.07*eV };
   std::vector<G4double> GXe_PP = { 7.0*eV, 7.07*eV, 7.14*eV };
   std::vector<G4double> GXe_SCINT = { 0.1, 1.0, 0.1 };
   std::vector<G4double> GXe_RIND  = { 1.00, 1.00, 1.00 };
   std::vector<G4double> GXe_ABSL  = { 100*m, 100*m, 100*m}; //atten length
+  std::vector<G4double> GXe_scint_e = { 0.*MeV, 10.*MeV };
+  std::vector<G4double> GXe_scint_default = { 0., 120000.};
+  std::vector<G4double> GXe_scint_alpha = { 0., 132000.};
+  std::vector<G4double> GXe_scint_ion = { 0., 24000.};
   G4MaterialPropertiesTable *GXe_mt = new G4MaterialPropertiesTable();
-  GXe_mt->AddProperty("FASTCOMPONENT", GXe_PP, GXe_SCINT);
-  GXe_mt->AddProperty("SLOWCOMPONENT", GXe_PP, GXe_SCINT);
+  GXe_mt->AddProperty("SCINTILLATIONCOMPONENT1", GXe_PP, GXe_SCINT);
+  GXe_mt->AddProperty("SCINTILLATIONCOMPONENT2", GXe_PP, GXe_SCINT);
   GXe_mt->AddProperty("RINDEX",        GXe_PP, GXe_RIND);
   GXe_mt->AddProperty("ABSLENGTH",     GXe_PP, GXe_ABSL);
   GXe_mt->AddConstProperty("SCINTILLATIONYIELD",12000./MeV); // include QE 20%
-  GXe_mt->AddConstProperty("RESOLUTIONSCALE",1.0);
-  GXe_mt->AddConstProperty("FASTTIMECONSTANT",20.*ns);
-  GXe_mt->AddConstProperty("SLOWTIMECONSTANT",45.*ns);
-  GXe_mt->AddConstProperty("YIELDRATIO",1.0);
-  GXe->SetMaterialPropertiesTable(GXe_mt);
 
+  GXe_mt->AddProperty("ELECTRONSCINTILLATIONYIELD", GXe_scint_e, GXe_scint_default); // include QE 20%
+  GXe_mt->AddConstProperty("ELECTRONSCINTILLATIONYIELD1", 0.);
+  GXe_mt->AddConstProperty("ELECTRONSCINTILLATIONYIELD2", 1.);
+
+  GXe_mt->AddProperty("ALPHASCINTILLATIONYIELD", GXe_scint_e, GXe_scint_alpha); // include QE 20%
+  GXe_mt->AddConstProperty("ALPHASCINTILLATIONYIELD1", 1.);
+  GXe_mt->AddConstProperty("ALPHASCINTILLATIONYIELD2", 0.);
+
+  GXe_mt->AddProperty("IONSCINTILLATIONYIELD", LXe_scint_e, LXe_scint_ion); // include QE 20%
+  GXe_mt->AddConstProperty("IONSCINTILLATIONYIELD1", 1.);
+  GXe_mt->AddConstProperty("IONSCINTILLATIONYIELD2", 0.);
+
+  GXe_mt->AddConstProperty("RESOLUTIONSCALE",1.0);
+  GXe_mt->AddConstProperty("SCINTILLATIONTIMECONSTANT1",20.*ns);
+  GXe_mt->AddConstProperty("SCINTILLATIONTIMECONSTANT2",45.*ns);
+  GXe->SetMaterialPropertiesTable(GXe_mt);
 
   // making quartz
   G4Element* O  = new G4Element
@@ -112,7 +139,6 @@
 
   std::vector<G4double> quartz_PP   = { 5.0*eV, 6.69*eV, 7.50*eV }; // lambda range 4 ri
   std::vector<G4double> quartz_RIND = { 1.51, 1.57, 1.61 };     // ref index
-  //  std::vector<G4double> quartz_RIND = { 1.45, 1.51, 1.54 };     // ref index
   std::vector<G4double> quartz_ABSL = { 3.0*cm, 3.0*cm, 3.0*cm };// atten length
   G4MaterialPropertiesTable *quartz_mt = new G4MaterialPropertiesTable();
   quartz_mt->AddProperty("RINDEX", quartz_PP, quartz_RIND);
@@ -136,7 +162,6 @@
   std::vector<G4double> cathmetal_PP   = { 5.0*eV, 6.69*eV, 7.50*eV };
   std::vector<G4double> cathmetal_RIND = { 1.51, 1.57, 1.61 };     // ref index
   std::vector<G4double> cathmetal_ABSL = { 1.e-20*m,  1.e-20*m,  1.e-20*m };// atten length
-//  std::vector<G4double> cathmetal_ABSL = { 3.0*cm, 3.0*cm, 3.0*cm };// atten length
   G4MaterialPropertiesTable *cathmetal_mt = new G4MaterialPropertiesTable();
   cathmetal_mt->AddProperty("RINDEX", cathmetal_PP, cathmetal_RIND);
   cathmetal_mt->AddProperty("ABSLENGTH", cathmetal_PP, cathmetal_ABSL);

examples/advanced/underground_physics/src/DMXParticleSource.cc

@@ -68,7 +68,7 @@
 DMXParticleSource::DMXParticleSource() {
 
   NumberOfParticlesToBeGenerated = 1;
-  particle_definition = NULL;
+  particle_definition = nullptr;
   G4ThreeVector zero(0., 0., 0.);
   particle_momentum_direction = G4ParticleMomentum(1., 0., 0.);
   particle_energy = 1.0*MeV;
@@ -137,25 +137,15 @@ void DMXParticleSource::ConfineSourceToVolume(G4String Vname)
   if(verbosityLevel == 2) G4cout << VolName << G4endl;
 
   // checks if selected volume exists
-  G4VPhysicalVolume *tempPV      = NULL;
-  G4PhysicalVolumeStore *PVStore = 0;
+  G4VPhysicalVolume *tempPV      = nullptr;
+  G4PhysicalVolumeStore *PVStore = nullptr;
   G4String theRequiredVolumeName = VolName;
   PVStore = G4PhysicalVolumeStore::GetInstance();
-  G4int i = 0;
   G4bool found = false;
   if(verbosityLevel == 2) G4cout << PVStore->size() << G4endl;
 
-  // recasting required since PVStore->size() is actually a signed int...
-  while (!found && i<(G4int)PVStore->size())
-    {
-      tempPV = (*PVStore)[i];
-      found  = tempPV->GetName() == theRequiredVolumeName;
-      if(verbosityLevel == 2)
-	G4cout << i << " " << " " << tempPV->GetName() 
-	       << " " << theRequiredVolumeName << " " << found << G4endl;
-      if (!found)
-	{i++;}
-    }
+  tempPV = PVStore->GetVolume(theRequiredVolumeName, false);
+  if (tempPV != nullptr) { found = true; }
 
   // found = true then the volume exists else it doesnt.
   if(found == true) {
@@ -171,16 +161,13 @@ void DMXParticleSource::ConfineSourceToVolume(G4String Vname)
     VolName = "NULL";
     Confine = false;
   }
-
 }
 
-
 void DMXParticleSource::SetAngDistType(G4String atype)
 {
   AngDistType = atype;
 }
 
-
 void DMXParticleSource::GeneratePointSource()
 {
   // Generates Points given the point source.
@@ -191,7 +178,6 @@ void DMXParticleSource::GeneratePointSource()
       G4cout << "Error SourcePosType is not set to Point" << G4endl;
 }
 
-
 void DMXParticleSource::GeneratePointsInVolume()
 {
   G4ThreeVector RandPos;
@@ -238,16 +224,14 @@ void DMXParticleSource::GeneratePointsInVolume()
 
 }
 
-
 G4bool DMXParticleSource::IsSourceConfined()
 {
 
   // Method to check point is within the volume specified
   if(Confine == false)
     G4cout << "Error: Confine is false" << G4endl;
-  G4ThreeVector null(0.,0.,0.);
-  G4ThreeVector *ptr;
-  ptr = &null;
+  G4ThreeVector null_vec(0.,0.,0.);
+  G4ThreeVector *ptr = &null_vec;
 
   // Check particle_position is within VolName
   G4VPhysicalVolume *theVolume;
@@ -262,14 +246,12 @@ G4bool DMXParticleSource::IsSourceConfined()
     return(false);
 }
 
-
 void DMXParticleSource::SetParticleMomentumDirection
    (G4ParticleMomentum aDirection) {
 
   particle_momentum_direction =  aDirection.unit();
 }
 
-
 void DMXParticleSource::GenerateIsotropicFlux()
 {
 
@@ -278,7 +260,8 @@ void DMXParticleSource::GenerateIsotropicFlux()
 
   G4double sintheta, sinphi, costheta, cosphi;
   rndm = G4UniformRand();
-  costheta = std::cos(MinTheta) - rndm * (std::cos(MinTheta) - std::cos(MaxTheta));
+  costheta = std::cos(MinTheta) - rndm * (std::cos(MinTheta)
+                                - std::cos(MaxTheta));
   sintheta = std::sqrt(1. - costheta*costheta);
   
   rndm2 = G4UniformRand();
@@ -301,10 +284,10 @@ void DMXParticleSource::GenerateIsotropicFlux()
 
   // particle_momentum_direction now holds unit momentum vector.
   if(verbosityLevel >= 2)
-    G4cout << "Generating isotropic vector: " << particle_momentum_direction << G4endl;
+    G4cout << "Generating isotropic vector: "
+           << particle_momentum_direction << G4endl;
 }
 
-
 void DMXParticleSource::SetEnergyDisType(G4String DisType)
 {
   EnergyDisType = DisType;
@@ -320,7 +303,6 @@ void DMXParticleSource::GenerateMonoEnergetic()
   particle_energy = MonoEnergy;
 }
 
-
 void DMXParticleSource::SetVerbosity(int vL)
 {
   verbosityLevel = vL;
@@ -334,11 +316,10 @@ void DMXParticleSource::SetParticleDefinition
   particle_charge = particle_definition->GetPDGCharge();
 }
 
-
 void DMXParticleSource::GeneratePrimaryVertex(G4Event *evt)
 {
 
-  if(particle_definition==NULL) {
+  if(particle_definition==nullptr) {
     G4cout << "No particle has been defined!" << G4endl;
     return;
   }
@@ -365,7 +346,7 @@ void DMXParticleSource::GeneratePrimaryVertex(G4Event *evt)
     else if(Confine == false)
       srcconf = true; // terminate loop
     
-    LoopCount++;
+    ++LoopCount;
     if(LoopCount == 100000) {
       G4cout << "*************************************" << G4endl;
         G4cout << "LoopCount = 100000" << G4endl;
@@ -409,30 +390,25 @@ void DMXParticleSource::GeneratePrimaryVertex(G4Event *evt)
   
   if(verbosityLevel >= 1){
     G4cout << "Particle name: " 
-	   << particle_definition->GetParticleName() << G4endl; 
+           << particle_definition->GetParticleName() << G4endl; 
     G4cout << "       Energy: "<<particle_energy << G4endl;
     G4cout << "     Position: "<<particle_position<< G4endl; 
     G4cout << "    Direction: "<<particle_momentum_direction << G4endl;
     G4cout << " NumberOfParticlesToBeGenerated: "
-	   << NumberOfParticlesToBeGenerated << G4endl;
+           << NumberOfParticlesToBeGenerated << G4endl;
   }
 
-
-  for( G4int i=0; i<NumberOfParticlesToBeGenerated; i++ ) {
+  for( G4int i=0; i<NumberOfParticlesToBeGenerated; ++i ) {
     G4PrimaryParticle* particle =
       new G4PrimaryParticle(particle_definition,px,py,pz);
     particle->SetMass( mass );
     particle->SetCharge( particle_charge );
     particle->SetPolarization(particle_polarization.x(),
-			      particle_polarization.y(),
-			      particle_polarization.z());
+                              particle_polarization.y(),
+                              particle_polarization.z());
     vertex->SetPrimary( particle );
   }
   evt->AddPrimaryVertex( vertex );
   if(verbosityLevel > 1)
     G4cout << " Primary Vetex generated "<< G4endl;   
 }
-
-
-
-

examples/advanced/underground_physics/src/DMXPhysicsList.cc

@@ -128,6 +128,7 @@
 #include "G4Scintillation.hh"
 #include "G4OpAbsorption.hh"
 #include "G4OpBoundaryProcess.hh"
+#include "G4OpticalParameters.hh"
 
 // Elastic processes:
 #include "G4HadronElasticProcess.hh"
@@ -135,19 +136,7 @@
 #include "G4ElasticHadrNucleusHE.hh"
 
 // Inelastic processes:
-#include "G4PionPlusInelasticProcess.hh"
-#include "G4PionMinusInelasticProcess.hh"
-#include "G4KaonPlusInelasticProcess.hh"
-#include "G4KaonZeroSInelasticProcess.hh"
-#include "G4KaonZeroLInelasticProcess.hh"
-#include "G4KaonMinusInelasticProcess.hh"
-#include "G4ProtonInelasticProcess.hh"
-#include "G4AntiProtonInelasticProcess.hh"
-#include "G4NeutronInelasticProcess.hh"
-#include "G4AntiNeutronInelasticProcess.hh"
-#include "G4DeuteronInelasticProcess.hh"
-#include "G4TritonInelasticProcess.hh"
-#include "G4AlphaInelasticProcess.hh"
+#include "G4HadronInelasticProcess.hh"
 
 // High energy FTFP model and Bertini cascade
 #include "G4FTFModel.hh"
@@ -169,7 +158,6 @@
 #include "G4AntiNuclElastic.hh"
 
 #include "G4CrossSectionInelastic.hh"
-#include "G4CrossSectionPairGG.hh"
 #include "G4BGGNucleonInelasticXS.hh"
 #include "G4BGGNucleonElasticXS.hh"
 #include "G4NeutronInelasticXS.hh"
@@ -179,7 +167,7 @@
 #include "G4ComponentGGHadronNucleusXsc.hh"
 
 #include "G4HadronElastic.hh"
-#include "G4HadronCaptureProcess.hh"
+#include "G4NeutronCaptureProcess.hh"
 
 // Neutron high-precision models: <20 MeV
 #include "G4ParticleHPElastic.hh"
@@ -190,9 +178,10 @@
 #include "G4ParticleHPInelasticData.hh"
 
 // Stopping processes
-#include "G4PiMinusAbsorptionBertini.hh"
-#include "G4KaonMinusAbsorptionBertini.hh"
-#include "G4AntiProtonAbsorptionFritiof.hh"
+#include "G4HadronStoppingProcess.hh"
+#include "G4HadronicAbsorptionBertini.hh"
+#include "G4HadronicAbsorptionFritiof.hh"
+
 #include "G4HadronicParameters.hh"
 
 #include "G4Decay.hh"
@@ -487,39 +476,14 @@ void DMXPhysicsList::ConstructEM() {
 // Optical Processes ////////////////////////////////////////////////////////
 void DMXPhysicsList::ConstructOp() 
 {
-  // default scintillation process
+  G4OpticalParameters* opParams = G4OpticalParameters::Instance();
   G4Scintillation* theScintProcessDef = new G4Scintillation("Scintillation");
-  // theScintProcessDef->DumpPhysicsTable();
-  theScintProcessDef->SetTrackSecondariesFirst(true);
-  theScintProcessDef->SetScintillationYieldFactor(1.0); //
-  theScintProcessDef->SetScintillationExcitationRatio(0.0); //
-  theScintProcessDef->SetVerboseLevel(OpVerbLevel);
-
-  // scintillation process for alpha:
-  G4Scintillation* theScintProcessAlpha = new G4Scintillation("Scintillation");
-  // theScintProcessNuc->DumpPhysicsTable();
-  theScintProcessAlpha->SetTrackSecondariesFirst(true);
-  theScintProcessAlpha->SetScintillationYieldFactor(1.1);
-  theScintProcessAlpha->SetScintillationExcitationRatio(1.0);
-  theScintProcessAlpha->SetVerboseLevel(OpVerbLevel);
-
-  // scintillation process for heavy nuclei
-  G4Scintillation* theScintProcessNuc = new G4Scintillation("Scintillation");
-  // theScintProcessNuc->DumpPhysicsTable();
-  theScintProcessNuc->SetTrackSecondariesFirst(true);
-  theScintProcessNuc->SetScintillationYieldFactor(0.2);
-  theScintProcessNuc->SetScintillationExcitationRatio(1.0);
-  theScintProcessNuc->SetVerboseLevel(OpVerbLevel);
+  opParams->SetScintTrackSecondariesFirst(true);
+  opParams->SetScintByParticleType(true);
 
   // optical processes
   G4OpAbsorption* theAbsorptionProcess = new G4OpAbsorption();
-  //  G4OpRayleigh* theRayleighScatteringProcess = new G4OpRayleigh();
   G4OpBoundaryProcess* theBoundaryProcess = new G4OpBoundaryProcess();
-  //  theAbsorptionProcess->DumpPhysicsTable();
-  //  theRayleighScatteringProcess->DumpPhysicsTable();
-  theAbsorptionProcess->SetVerboseLevel(OpVerbLevel);
-  // theRayleighScatteringProcess->SetVerboseLevel(OpVerbLevel);
-  theBoundaryProcess->SetVerboseLevel(OpVerbLevel);
 
   auto particleIterator=GetParticleIterator();
   particleIterator->reset();
@@ -529,27 +493,13 @@ void DMXPhysicsList::ConstructOp()
       G4ProcessManager* pmanager = particle->GetProcessManager();
       G4String particleName = particle->GetParticleName();
       if (theScintProcessDef->IsApplicable(*particle)) {
-	//      if(particle->GetPDGMass() > 5.0*GeV) 
-	if(particle->GetParticleName() == "GenericIon") {
-	  pmanager->AddProcess(theScintProcessNuc); // AtRestDiscrete
-	  pmanager->SetProcessOrderingToLast(theScintProcessNuc,idxAtRest);
-	  pmanager->SetProcessOrderingToLast(theScintProcessNuc,idxPostStep);
-	}	  
-	else if(particle->GetParticleName() == "alpha") {
-	  pmanager->AddProcess(theScintProcessAlpha);
-	  pmanager->SetProcessOrderingToLast(theScintProcessAlpha,idxAtRest);
-	  pmanager->SetProcessOrderingToLast(theScintProcessAlpha,idxPostStep);
-	}
-	else {
-	  pmanager->AddProcess(theScintProcessDef);
-	  pmanager->SetProcessOrderingToLast(theScintProcessDef,idxAtRest);
-	  pmanager->SetProcessOrderingToLast(theScintProcessDef,idxPostStep);
-	}	  
+        pmanager->AddProcess(theScintProcessDef);
+        pmanager->SetProcessOrderingToLast(theScintProcessDef,idxAtRest);
+        pmanager->SetProcessOrderingToLast(theScintProcessDef,idxPostStep);
       }
       
       if (particleName == "opticalphoton") {
 	pmanager->AddDiscreteProcess(theAbsorptionProcess);
-	//	pmanager->AddDiscreteProcess(theRayleighScatteringProcess);
 	pmanager->AddDiscreteProcess(theBoundaryProcess);
       }
     }
@@ -624,8 +574,8 @@ void DMXPhysicsList::ConstructHad()
           theElasticProcess->RegisterMe( elastic_he );
 	  pmanager->AddDiscreteProcess( theElasticProcess );
 	  //Inelastic scattering
-	  G4PionPlusInelasticProcess* theInelasticProcess = 
-	    new G4PionPlusInelasticProcess("inelastic");
+	  G4HadronInelasticProcess* theInelasticProcess = 
+	    new G4HadronInelasticProcess( "inelastic", G4PionPlus::Definition() );
 	  theInelasticProcess->AddDataSet( new G4BGGPionElasticXS( particle ) );
 	  theInelasticProcess->RegisterMe( theFTFModel1 );
           theInelasticProcess->RegisterMe( theBERTModel0 );
@@ -640,14 +590,14 @@ void DMXPhysicsList::ConstructHad()
           theElasticProcess->RegisterMe( elastic_he );
 	  pmanager->AddDiscreteProcess( theElasticProcess );
 	  //Inelastic scattering
-	  G4PionMinusInelasticProcess* theInelasticProcess = 
-	    new G4PionMinusInelasticProcess("inelastic");
+	  G4HadronInelasticProcess* theInelasticProcess = 
+	    new G4HadronInelasticProcess( "inelastic", G4PionMinus::Definition() );
 	  theInelasticProcess->AddDataSet( new G4BGGPionInelasticXS( particle ) );
 	  theInelasticProcess->RegisterMe( theFTFModel1 );
           theInelasticProcess->RegisterMe( theBERTModel0 );
 	  pmanager->AddDiscreteProcess( theInelasticProcess );	  
 	  //Absorption
-	  pmanager->AddRestProcess(new G4PiMinusAbsorptionBertini, ordDefault);
+	  pmanager->AddRestProcess(new G4HadronicAbsorptionBertini(G4PionMinus::Definition()), ordDefault);
 	}
       else if (particleName == "kaon+") 
 	{
@@ -657,8 +607,8 @@ void DMXPhysicsList::ConstructHad()
           theElasticProcess->RegisterMe( elastic_lhep0 );
 	  pmanager->AddDiscreteProcess( theElasticProcess );
           // Inelastic scattering	
-	  G4KaonPlusInelasticProcess* theInelasticProcess = 
-	    new G4KaonPlusInelasticProcess("inelastic");
+	  G4HadronInelasticProcess* theInelasticProcess = 
+	    new G4HadronInelasticProcess( "inelastic", G4KaonPlus::Definition() );
 	  theInelasticProcess->AddDataSet( theGGHNInel );
 	  theInelasticProcess->RegisterMe( theFTFModel1 );
           theInelasticProcess->RegisterMe( theBERTModel0 );
@@ -672,8 +622,8 @@ void DMXPhysicsList::ConstructHad()
           theElasticProcess->RegisterMe( elastic_lhep0 );
 	  pmanager->AddDiscreteProcess( theElasticProcess );
           // Inelastic scattering	 
-	  G4KaonZeroSInelasticProcess* theInelasticProcess = 
-	    new G4KaonZeroSInelasticProcess("inelastic");
+	  G4HadronInelasticProcess* theInelasticProcess = 
+	    new G4HadronInelasticProcess( "inelastic", G4KaonZeroShort::Definition() );
 	  theInelasticProcess->AddDataSet( theGGHNInel );
 	  theInelasticProcess->RegisterMe( theFTFModel1 );
           theInelasticProcess->RegisterMe( theBERTModel0 );
@@ -688,8 +638,8 @@ void DMXPhysicsList::ConstructHad()
           theElasticProcess->RegisterMe( elastic_lhep0 );
 	  pmanager->AddDiscreteProcess( theElasticProcess );
 	  // Inelastic scattering
-	  G4KaonZeroLInelasticProcess* theInelasticProcess = 
-	    new G4KaonZeroLInelasticProcess("inelastic");
+	  G4HadronInelasticProcess* theInelasticProcess = 
+	    new G4HadronInelasticProcess( "inelastic", G4KaonZeroLong::Definition() );
 	  theInelasticProcess->AddDataSet( theGGHNInel );
 	  theInelasticProcess->RegisterMe( theFTFModel1 );
           theInelasticProcess->RegisterMe( theBERTModel0 ); 
@@ -704,13 +654,13 @@ void DMXPhysicsList::ConstructHad()
           theElasticProcess->RegisterMe( elastic_lhep0 );
 	  pmanager->AddDiscreteProcess( theElasticProcess );
           // Inelastic scattering
-	  G4KaonMinusInelasticProcess* theInelasticProcess = 
-	    new G4KaonMinusInelasticProcess("inelastic");	
+	  G4HadronInelasticProcess* theInelasticProcess = 
+	    new G4HadronInelasticProcess( "inelastic", G4KaonMinus::Definition() );	
           theInelasticProcess->AddDataSet( theGGHNInel );
 	  theInelasticProcess->RegisterMe( theFTFModel1 );
           theInelasticProcess->RegisterMe( theBERTModel0 );
 	  pmanager->AddDiscreteProcess( theInelasticProcess );
-	  pmanager->AddRestProcess(new G4KaonMinusAbsorptionBertini, ordDefault);
+	  pmanager->AddRestProcess(new G4HadronicAbsorptionBertini(G4KaonMinus::Definition()), ordDefault);
 	}
 
       else if (particleName == "proton") 
@@ -721,8 +671,8 @@ void DMXPhysicsList::ConstructHad()
           theElasticProcess->RegisterMe( elastic_chip );
 	  pmanager->AddDiscreteProcess( theElasticProcess );
 	  // Inelastic scattering
-	  G4ProtonInelasticProcess* theInelasticProcess = 
-	    new G4ProtonInelasticProcess("inelastic");
+	  G4HadronInelasticProcess* theInelasticProcess = 
+	    new G4HadronInelasticProcess( "inelastic", G4Proton::Definition() );
 	  theInelasticProcess->AddDataSet( new G4BGGNucleonInelasticXS( G4Proton::Proton() ) );
 	  theInelasticProcess->RegisterMe( theFTFModel1 );
           theInelasticProcess->RegisterMe( theBERTModel0 );
@@ -743,13 +693,13 @@ void DMXPhysicsList::ConstructHad()
           theElasticProcess->RegisterMe( elastic_anuc );
 	  pmanager->AddDiscreteProcess( theElasticProcess );
 	  // Inelastic scattering
-	  G4AntiProtonInelasticProcess* theInelasticProcess = 
-	    new G4AntiProtonInelasticProcess("inelastic");
+	  G4HadronInelasticProcess* theInelasticProcess = 
+	    new G4HadronInelasticProcess( "inelastic", G4AntiProton::Definition() );
 	  theInelasticProcess->AddDataSet( theAntiNucleonData );
 	  theInelasticProcess->RegisterMe( theFTFModel0 );
 	  pmanager->AddDiscreteProcess( theInelasticProcess );
 	  // Absorption
-	  pmanager->AddRestProcess(new G4AntiProtonAbsorptionFritiof, ordDefault);
+	  pmanager->AddRestProcess(new G4HadronicAbsorptionFritiof(G4AntiProton::Definition()), ordDefault);
 	}
       else if (particleName == "neutron") {
 	// elastic scattering
@@ -765,8 +715,8 @@ void DMXPhysicsList::ConstructHad()
 	theElasticProcess->AddDataSet( new G4ParticleHPElasticData );
 	pmanager->AddDiscreteProcess( theElasticProcess );
 	// inelastic scattering		
-	G4NeutronInelasticProcess* theInelasticProcess =
-	  new G4NeutronInelasticProcess("inelastic");
+	G4HadronInelasticProcess* theInelasticProcess =
+	  new G4HadronInelasticProcess( "inelastic", G4Neutron::Definition() );
 	theInelasticProcess->AddDataSet( new G4NeutronInelasticXS() );
 	theInelasticProcess->RegisterMe( theFTFModel1 );
         theInelasticProcess->RegisterMe( theBERTModel1 );
@@ -777,8 +727,8 @@ void DMXPhysicsList::ConstructHad()
 	theInelasticProcess->AddDataSet( new G4ParticleHPInelasticData );
 	pmanager->AddDiscreteProcess(theInelasticProcess);
 	// capture
-	G4HadronCaptureProcess* theCaptureProcess =
-	  new G4HadronCaptureProcess;
+	G4NeutronCaptureProcess* theCaptureProcess =
+	  new G4NeutronCaptureProcess;
 	G4ParticleHPCapture * theLENeutronCaptureModel = new G4ParticleHPCapture;
 	theLENeutronCaptureModel->SetMinEnergy(theHPMin);
 	theLENeutronCaptureModel->SetMaxEnergy(theHPMax);
@@ -794,8 +744,8 @@ void DMXPhysicsList::ConstructHad()
           theElasticProcess->RegisterMe( elastic_lhep0 );
 	  pmanager->AddDiscreteProcess( theElasticProcess );
           // Inelastic scattering (include annihilation on-fly)
-	  G4AntiNeutronInelasticProcess* theInelasticProcess = 
-	    new G4AntiNeutronInelasticProcess("inelastic");
+	  G4HadronInelasticProcess* theInelasticProcess = 
+	    new G4HadronInelasticProcess( "inelastic", G4AntiNeutron::Definition() );
 	  theInelasticProcess->AddDataSet( theAntiNucleonData );
 	  theInelasticProcess->RegisterMe( theFTFModel0 );
 	  pmanager->AddDiscreteProcess( theInelasticProcess );	  
@@ -808,8 +758,8 @@ void DMXPhysicsList::ConstructHad()
           theElasticProcess->RegisterMe( elastic_lhep0 );
 	  pmanager->AddDiscreteProcess( theElasticProcess );
           // Inelastic scattering
-	  G4DeuteronInelasticProcess* theInelasticProcess = 
-	    new G4DeuteronInelasticProcess("inelastic");
+	  G4HadronInelasticProcess* theInelasticProcess = 
+	    new G4HadronInelasticProcess( "inelastic", G4Deuteron::Definition() );
 	  theInelasticProcess->AddDataSet( theGGNuclNuclData );
 	  theInelasticProcess->RegisterMe( theFTFModel1 );
           theInelasticProcess->RegisterMe( theBERTModel0 );
@@ -823,8 +773,8 @@ void DMXPhysicsList::ConstructHad()
           theElasticProcess->RegisterMe( elastic_lhep0 );
 	  pmanager->AddDiscreteProcess( theElasticProcess );
           // Inelastic scattering
-	  G4TritonInelasticProcess* theInelasticProcess = 
-	    new G4TritonInelasticProcess("inelastic");
+	  G4HadronInelasticProcess* theInelasticProcess = 
+	    new G4HadronInelasticProcess( "inelastic", G4Triton::Definition() );
 	  theInelasticProcess->AddDataSet( theGGNuclNuclData );
 	  theInelasticProcess->RegisterMe( theFTFModel1 );
           theInelasticProcess->RegisterMe( theBERTModel0 );
@@ -838,8 +788,8 @@ void DMXPhysicsList::ConstructHad()
           theElasticProcess->RegisterMe( elastic_lhep0 );
 	  pmanager->AddDiscreteProcess( theElasticProcess );
           // Inelastic scattering
-	  G4AlphaInelasticProcess* theInelasticProcess = 
-	    new G4AlphaInelasticProcess("inelastic");	 
+	  G4HadronInelasticProcess* theInelasticProcess = 
+	    new G4HadronInelasticProcess( "inelastic", G4Alpha::Definition() );	 
           theInelasticProcess->AddDataSet( theGGNuclNuclData );
 	  theInelasticProcess->RegisterMe( theFTFModel1 );
           theInelasticProcess->RegisterMe( theBERTModel0 );