Import Geant4 7.0.0 source tree

This commit is contained in:
Gabriele Cosmo
2016-06-09 11:11:55 +02:00
parent e083ffb441
commit 516dbf1a58
5914 changed files with 202605 additions and 71141 deletions
@@ -0,0 +1,2 @@
name := Packaging
include ../common.gmk
@@ -0,0 +1,37 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
#ifndef CompileTimeConstraints_hh
#define CompileTimeConstraints_hh
namespace CompileTimeConstraints
{
template <class Base> char InheritsFrom(Base *);
template <class Derived> Derived* DerivedPointer();
template < class A, class B > struct IsA
{
public:
enum { ok=(sizeof(InheritsFrom<B>(DerivedPointer<A>())) ) };
};
}
#endif
@@ -0,0 +1,53 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
#ifndef EMPhysics_h
#define EMPhysics_h 1
#include "globals.hh"
#include "G4ios.hh"
#include "G4VPhysicsConstructor.hh"
#include "G4EMBuilder.hh"
class EMPhysics : public G4VPhysicsConstructor
{
public:
EMPhysics(const G4String& name ="EM");
virtual ~EMPhysics();
public:
virtual void ConstructParticle();
virtual void ConstructProcess();
private:
G4EMBuilder theEMPhysics;
};
// 2002 by J.P. Wellisch
#endif
@@ -0,0 +1,55 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
#ifndef EM_GNPhysics_h
#define EM_GNPhysics_h 1
#include "globals.hh"
#include "G4ios.hh"
#include "G4VPhysicsConstructor.hh"
#include "G4EMBuilder.hh"
#include "G4ElectroNuclearBuilder.hh"
class EM_GNPhysics : public G4VPhysicsConstructor
{
public:
EM_GNPhysics(const G4String& name ="EM");
virtual ~EM_GNPhysics();
public:
virtual void ConstructParticle();
virtual void ConstructProcess();
private:
G4EMBuilder theEMPhysics;
G4ElectroNuclearBuilder theGNPhysics;
};
// 2002 by J.P. Wellisch
#endif
@@ -0,0 +1,63 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
#ifndef G4BertiniNeutronBuilder_h
#define G4BertiniNeutronBuilder_h 1
#include "globals.hh"
#include "G4HadronElasticProcess.hh"
#include "G4HadronFissionProcess.hh"
#include "G4HadronCaptureProcess.hh"
#include "G4NeutronInelasticProcess.hh"
#include "G4VNeutronBuilder.hh"
#include "G4CascadeInterface.hh"
#include "G4NeutronInelasticCrossSection.hh"
class G4BertiniNeutronBuilder : public G4VNeutronBuilder
{
public:
G4BertiniNeutronBuilder();
virtual ~G4BertiniNeutronBuilder();
public:
virtual void Build(G4HadronElasticProcess & aP);
virtual void Build(G4HadronFissionProcess & aP);
virtual void Build(G4HadronCaptureProcess & aP);
virtual void Build(G4NeutronInelasticProcess & aP);
void SetMinEnergy(G4double aM) {theMin = aM;}
void SetMaxEnergy(G4double aM) {theMax = aM;}
private:
G4CascadeInterface * theModel;
G4NeutronInelasticCrossSection theXSec;
G4double theMin;
G4double theMax;
};
// 2002 by J.P. Wellisch
#endif
@@ -0,0 +1,66 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
#ifndef G4BertiniPiKBuilder_h
#define G4BertiniPiKBuilder_h 1
#include "globals.hh"
#include "G4HadronElasticProcess.hh"
#include "G4HadronFissionProcess.hh"
#include "G4HadronCaptureProcess.hh"
#include "G4NeutronInelasticProcess.hh"
#include "G4VPiKBuilder.hh"
#include "G4PiNuclearCrossSection.hh"
#include "G4CascadeInterface.hh"
class G4BertiniPiKBuilder : public G4VPiKBuilder
{
public:
G4BertiniPiKBuilder();
virtual ~G4BertiniPiKBuilder();
public:
virtual void Build(G4HadronElasticProcess & aP);
virtual void Build(G4PionPlusInelasticProcess & aP);
virtual void Build(G4PionMinusInelasticProcess & aP);
virtual void Build(G4KaonPlusInelasticProcess & aP);
virtual void Build(G4KaonMinusInelasticProcess & aP);
virtual void Build(G4KaonZeroLInelasticProcess & aP);
virtual void Build(G4KaonZeroSInelasticProcess & aP);
void SetMinEnergy(G4double aM) {theMin = aM;}
void SetMaxEnergy(G4double aM) {theMax = aM;}
private:
G4PiNuclearCrossSection thePiData;
G4CascadeInterface * theModel;
G4double theMin;
G4double theMax;
};
// 2002 by J.P. Wellisch
#endif
@@ -0,0 +1,61 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
#ifndef G4BertiniProtonBuilder_h
#define G4BertiniProtonBuilder_h
#include "globals.hh"
#include "G4HadronElasticProcess.hh"
#include "G4HadronFissionProcess.hh"
#include "G4HadronCaptureProcess.hh"
#include "G4ProtonInelasticProcess.hh"
#include "G4VProtonBuilder.hh"
#include "G4CascadeInterface.hh"
#include "G4ProtonInelasticCrossSection.hh"
class G4BertiniProtonBuilder : public G4VProtonBuilder
{
public:
G4BertiniProtonBuilder();
virtual ~G4BertiniProtonBuilder();
public:
virtual void Build(G4HadronElasticProcess & aP);
virtual void Build(G4ProtonInelasticProcess & aP);
void SetMinEnergy(G4double aM) {theMin = aM;}
void SetMaxEnergy(G4double aM) {theMax = aM;}
private:
G4ProtonInelasticCrossSection theXSec;
G4CascadeInterface * theModel;
G4double theMin;
G4double theMax;
};
// 2002 by J.P. Wellisch
#endif
@@ -0,0 +1,63 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
#ifndef G4BinaryNeutronBuilder_h
#define G4BinaryNeutronBuilder_h 1
#include "globals.hh"
#include "G4HadronElasticProcess.hh"
#include "G4HadronFissionProcess.hh"
#include "G4HadronCaptureProcess.hh"
#include "G4NeutronInelasticProcess.hh"
#include "G4VNeutronBuilder.hh"
#include "G4BinaryCascade.hh"
#include "G4NeutronInelasticCrossSection.hh"
class G4BinaryNeutronBuilder : public G4VNeutronBuilder
{
public:
G4BinaryNeutronBuilder();
virtual ~G4BinaryNeutronBuilder();
public:
virtual void Build(G4HadronElasticProcess & aP);
virtual void Build(G4HadronFissionProcess & aP);
virtual void Build(G4HadronCaptureProcess & aP);
virtual void Build(G4NeutronInelasticProcess & aP);
void SetMinEnergy(G4double aM) {theMin = aM;}
void SetMaxEnergy(G4double aM) {theMax = aM;}
private:
G4BinaryCascade * theModel;
G4NeutronInelasticCrossSection theXSec;
G4double theMin;
G4double theMax;
};
// 2002 by J.P. Wellisch
#endif
@@ -0,0 +1,66 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
#ifndef G4BinaryPiKBuilder_h
#define G4BinaryPiKBuilder_h 1
#include "globals.hh"
#include "G4HadronElasticProcess.hh"
#include "G4HadronFissionProcess.hh"
#include "G4HadronCaptureProcess.hh"
#include "G4NeutronInelasticProcess.hh"
#include "G4VPiKBuilder.hh"
#include "G4PiNuclearCrossSection.hh"
#include "G4BinaryCascade.hh"
class G4BinaryPiKBuilder : public G4VPiKBuilder
{
public:
G4BinaryPiKBuilder();
virtual ~G4BinaryPiKBuilder();
public:
virtual void Build(G4HadronElasticProcess & aP);
virtual void Build(G4PionPlusInelasticProcess & aP);
virtual void Build(G4PionMinusInelasticProcess & aP);
virtual void Build(G4KaonPlusInelasticProcess & aP);
virtual void Build(G4KaonMinusInelasticProcess & aP);
virtual void Build(G4KaonZeroLInelasticProcess & aP);
virtual void Build(G4KaonZeroSInelasticProcess & aP);
void SetMinEnergy(G4double aM) {theMin = aM;}
void SetMaxEnergy(G4double aM) {theMax = aM;}
private:
G4PiNuclearCrossSection thePiData;
G4BinaryCascade * theModel;
G4double theMin;
G4double theMax;
};
// 2002 by J.P. Wellisch
#endif
@@ -0,0 +1,60 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
#ifndef G4BinaryProtonBuilder_h
#define G4BinaryProtonBuilder_h
#include "globals.hh"
#include "G4HadronElasticProcess.hh"
#include "G4HadronFissionProcess.hh"
#include "G4HadronCaptureProcess.hh"
#include "G4ProtonInelasticProcess.hh"
#include "G4VProtonBuilder.hh"
#include "G4BinaryCascade.hh"
#include "G4ProtonInelasticCrossSection.hh"
class G4BinaryProtonBuilder : public G4VProtonBuilder
{
public:
G4BinaryProtonBuilder();
virtual ~G4BinaryProtonBuilder();
public:
virtual void Build(G4HadronElasticProcess & aP);
virtual void Build(G4ProtonInelasticProcess & aP);
void SetMinEnergy(G4double aM) {theMin = aM;}
void SetMaxEnergy(G4double aM) {theMax = aM;}
private:
G4ProtonInelasticCrossSection theXSec;
G4BinaryCascade * theModel;
G4double theMin;
G4double theMax;
};
// 2002 by J.P. Wellisch
#endif
@@ -0,0 +1,114 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
#ifndef G4DataQuestionaire_h
#define G4DataQuestionaire_h 1
#include "globals.hh"
#include "G4HadronElasticProcess.hh"
#include "G4ProtonInelasticProcess.hh"
#include "G4VPiKBuilder.hh"
enum G4DataType {no, photon, neutron, radioactive, lowenergy};
class G4DataQuestionaire
{
public:
G4DataQuestionaire(G4DataType t1=no, G4DataType t2=no, G4DataType t3=no, G4DataType t4=no)
{
G4cout <<G4endl<<G4endl;
G4cout << "You are using the simulation engine reuse library: PACK 2.4"<<G4endl;
G4cout <<G4endl<<G4endl;
// G4cout << "##### the input "<<t1<<" "<<t2<<" "<<t3<<" "<<t4<<G4endl;
for(G4int i=0; i<4; i++)
{
G4DataType t(no);
if(i==0) t=t1;
if(i==1) t=t2;
if(i==2) t=t3;
if(i==3) t=t4;
switch(t)
{
case photon:
if(!getenv("G4LEVELGAMMADATA") )
{
G4cout << "Photon-evaporation data are needed."<<G4endl;
G4cout << "Please set the environmental variable G4LEVELGAMMADATA"<<G4endl;
G4cout << "to point to your PhotonEvaporation directory."<<G4endl;
G4cout << "Data are available from the geant4 download page."<<G4endl;
G4Exception("G4DataQuestionaire", "007", FatalException,
"Fatal error: Missing mandatory data for this simulation engine");
}
break;
case neutron:
if(!getenv("NeutronHPCrossSections") )
{
G4cout << "G4NDL are needed."<<G4endl;
G4cout << "Please set the environmental variable NeutronHPCrossSections"<<G4endl;
G4cout << "to point to your G4NDL directory."<<G4endl;
G4cout << "Data are available from http://cmsdoc.cern.ch/~hpw/G4NDL3.7.tar.gz "<<G4endl;
G4cout << "of the geant4 download page."<<G4endl;
G4Exception("G4DataQuestionaire", "007", FatalException,
"Fatal error: Missing mandatory data for this simulation engine");
}
break;
case radioactive:
if(!getenv("G4RADIOACTIVEDATA") )
{
G4cout << "Radioactive decay data are needed."<<G4endl;
G4cout << "Please set the environmental variable G4RADIOACTIVEDATA"<<G4endl;
G4cout << "to point to your RadiativeDecay directory."<<G4endl;
G4cout << "Data are available from the geant4 download page."<<G4endl;
G4Exception("G4DataQuestionaire", "007", FatalException,
"Fatal error: Missing mandatory data for this simulation engine");
}
break;
case lowenergy:
if(!getenv("G4LEDATA") )
{
G4cout << "Low energy electromagnetic data are needed."<<G4endl;
G4cout << "Please set the environmental variable G4LEDATA"<<G4endl;
G4cout << "to point to your G4EMLOW directory."<<G4endl;
G4cout << "Data are available from the geant4 download page."<<G4endl;
G4Exception("G4DataQuestionaire", "007", FatalException,
"Fatal error: Missing mandatory data for this simulation engine");
}
break;
case no:
// all ok
break;
default:
if(t!=no)
{
G4Exception("G4DataQuestionaire", "007", FatalException,
"data type requested is not known to the system");
}
}
}
}
~G4DataQuestionaire() {}
};
// 2002 by J.P. Wellisch
#endif
@@ -0,0 +1,81 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
#ifndef G4EMBuilder_h
#define G4EMBuilder_h 1
#include "globals.hh"
#include "G4ios.hh"
#include "G4PhotoElectricEffect.hh"
#include "G4ComptonScattering.hh"
#include "G4GammaConversion.hh"
#include "G4MultipleScattering.hh"
#include "G4eIonisation.hh"
#include "G4eBremsstrahlung.hh"
#include "G4eplusAnnihilation.hh"
#include "G4EMTailorer.hh"
#include "G4SynchrotronRadiation.hh"
#include "G4ElectroNuclearBuilder.hh"
class G4EMBuilder
{
public:
G4EMBuilder();
virtual ~G4EMBuilder();
public:
void Build();
void Synch(G4String & aState);
void GammaNuclear(G4String & aState);
protected:
G4PhotoElectricEffect thePhotoEffect;
G4ComptonScattering theComptonEffect;
G4GammaConversion thePairProduction;
G4MultipleScattering theElectronMultipleScattering;
G4eIonisation theElectronIonisation;
G4eBremsstrahlung theElectronBremsStrahlung;
G4MultipleScattering thePositronMultipleScattering;
G4eIonisation thePositronIonisation;
G4eBremsstrahlung thePositronBremsStrahlung;
G4eplusAnnihilation theAnnihilation;
G4bool wasActivated;
G4EMTailorer * theT;
G4SynchrotronRadiation theElectronSynch;
G4SynchrotronRadiation thePositronSynch;
G4bool synchOn;
G4ElectroNuclearBuilder theGNPhysics;
G4bool gammNucOn;
};
// 2002 by J.P. Wellisch
#endif
@@ -0,0 +1,52 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
#ifndef G4EMTailorer_h
#define G4EMTailorer_h
class G4EMBuilder;
#include "G4UImessenger.hh"
#include "G4UIdirectory.hh"
#include "G4UIcmdWithAString.hh"
class G4EMTailorer: public G4UImessenger
{
public:
G4EMTailorer(G4EMBuilder * af);
virtual ~G4EMTailorer()
{
delete theSynch;
delete theGN;
}
void SetNewValue(G4UIcommand* aComm, G4String aS);
private:
G4EMBuilder * theB;
G4UIcmdWithAString * theSynch;
G4UIcmdWithAString * theGN;
G4UIdirectory *aDir1;
G4UIdirectory *aDir2;
};
#endif
@@ -0,0 +1,69 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
#ifndef G4ElectroNuclearBuilder_h
#define G4ElectroNuclearBuilder_h 1
#include "globals.hh"
#include "G4ios.hh"
#include "G4TheoFSGenerator.hh"
#include "G4GeneratorPrecompoundInterface.hh"
#include "G4QGSModel.hh"
#include "G4GammaParticipants.hh"
#include "G4QGSMFragmentation.hh"
#include "G4ExcitedStringDecay.hh"
#include "G4GammaNuclearReaction.hh"
#include "G4ElectroNuclearReaction.hh"
#include "G4PhotoNuclearProcess.hh"
#include "G4ElectronNuclearProcess.hh"
#include "G4PositronNuclearProcess.hh"
class G4ElectroNuclearBuilder
{
public:
G4ElectroNuclearBuilder();
virtual ~G4ElectroNuclearBuilder();
public:
virtual void Build();
protected:
G4PhotoNuclearProcess thePhotoNuclearProcess;
G4ElectronNuclearProcess theElectronNuclearProcess;
G4PositronNuclearProcess thePositronNuclearProcess;
G4ElectroNuclearReaction * theElectroReaction;
G4GammaNuclearReaction * theGammaReaction;
G4TheoFSGenerator * theModel;
G4GeneratorPrecompoundInterface * theCascade;
G4QGSModel< G4GammaParticipants > theStringModel;
G4QGSMFragmentation theFragmentation;
G4ExcitedStringDecay * theStringDecay;
G4bool wasActivated;
};
// 2002 by J.P. Wellisch
#endif
@@ -0,0 +1,70 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
#ifndef G4FTFCNeutronBuilder_h
#define G4FTFCNeutronBuilder_h 1
#include "globals.hh"
#include "G4HadronElasticProcess.hh"
#include "G4HadronFissionProcess.hh"
#include "G4HadronCaptureProcess.hh"
#include "G4NeutronInelasticProcess.hh"
#include "G4VNeutronBuilder.hh"
#include "G4NeutronInelasticCrossSection.hh"
#include "G4TheoFSGenerator.hh"
#include "G4StringChipsParticleLevelInterface.hh"
#include "G4FTFModel.hh"
#include "G4LundStringFragmentation.hh"
#include "G4ExcitedStringDecay.hh"
class G4FTFCNeutronBuilder : public G4VNeutronBuilder
{
public:
G4FTFCNeutronBuilder();
virtual ~G4FTFCNeutronBuilder();
public:
virtual void Build(G4HadronElasticProcess & aP);
virtual void Build(G4HadronFissionProcess & aP);
virtual void Build(G4HadronCaptureProcess & aP);
virtual void Build(G4NeutronInelasticProcess & aP);
void SetMinEnergy(G4double aM) {theMin = aM;}
private:
G4TheoFSGenerator * theModel;
G4StringChipsParticleLevelInterface * theCascade;
G4FTFModel theStringModel;
G4LundStringFragmentation theFragmentation;
G4ExcitedStringDecay * theStringDecay;
G4NeutronInelasticCrossSection theXSec;
G4double theMin;
};
// 2002 by J.P. Wellisch
#endif
@@ -0,0 +1,73 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
#ifndef G4FTFCPiKBuilder_h
#define G4FTFCPiKBuilder_h 1
#include "globals.hh"
#include "G4HadronElasticProcess.hh"
#include "G4HadronFissionProcess.hh"
#include "G4HadronCaptureProcess.hh"
#include "G4NeutronInelasticProcess.hh"
#include "G4VPiKBuilder.hh"
#include "G4TheoFSGenerator.hh"
#include "G4StringChipsParticleLevelInterface.hh"
#include "G4FTFModel.hh"
#include "G4LundStringFragmentation.hh"
#include "G4ExcitedStringDecay.hh"
#include "G4PiNuclearCrossSection.hh"
class G4FTFCPiKBuilder : public G4VPiKBuilder
{
public:
G4FTFCPiKBuilder();
virtual ~G4FTFCPiKBuilder();
public:
virtual void Build(G4HadronElasticProcess & aP);
virtual void Build(G4PionPlusInelasticProcess & aP);
virtual void Build(G4PionMinusInelasticProcess & aP);
virtual void Build(G4KaonPlusInelasticProcess & aP);
virtual void Build(G4KaonMinusInelasticProcess & aP);
virtual void Build(G4KaonZeroLInelasticProcess & aP);
virtual void Build(G4KaonZeroSInelasticProcess & aP);
void SetMinEnergy(G4double aM) {theMin = aM;}
private:
G4PiNuclearCrossSection thePiData;
G4TheoFSGenerator * theModel;
G4StringChipsParticleLevelInterface * theCascade;
G4FTFModel theStringModel;
G4LundStringFragmentation theFragmentation;
G4ExcitedStringDecay * theStringDecay;
G4double theMin;
};
// 2002 by J.P. Wellisch
#endif
@@ -0,0 +1,65 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
#ifndef G4FTFCProtonBuilder_h
#define G4FTFCProtonBuilder_h
#include "globals.hh"
#include "G4HadronElasticProcess.hh"
#include "G4HadronFissionProcess.hh"
#include "G4HadronCaptureProcess.hh"
#include "G4ProtonInelasticProcess.hh"
#include "G4VProtonBuilder.hh"
#include "G4NeutronInelasticCrossSection.hh"
#include "G4TheoFSGenerator.hh"
#include "G4StringChipsParticleLevelInterface.hh"
#include "G4FTFModel.hh"
#include "G4LundStringFragmentation.hh"
#include "G4ExcitedStringDecay.hh"
#include "G4ProtonInelasticCrossSection.hh"
class G4FTFCProtonBuilder : public G4VProtonBuilder
{
public:
G4FTFCProtonBuilder();
virtual ~G4FTFCProtonBuilder(){};
public:
virtual void Build(G4HadronElasticProcess & ){};
virtual void Build(G4ProtonInelasticProcess & aP);
void SetMinEnergy(G4double aM) {theMin = aM;}
private:
G4ProtonInelasticCrossSection theXSec;
G4TheoFSGenerator * theModel;
G4double theMin;
};
// 2002 by J.P. Wellisch
#endif
@@ -0,0 +1,74 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
#ifndef G4FTFPNeutronBuilder_h
#define G4FTFPNeutronBuilder_h 1
#include "globals.hh"
#include "G4HadronElasticProcess.hh"
#include "G4HadronFissionProcess.hh"
#include "G4HadronCaptureProcess.hh"
#include "G4NeutronInelasticProcess.hh"
#include "G4VNeutronBuilder.hh"
#include "G4NeutronInelasticCrossSection.hh"
#include "G4TheoFSGenerator.hh"
#include "G4ExcitationHandler.hh"
#include "G4PreCompoundModel.hh"
#include "G4GeneratorPrecompoundInterface.hh"
#include "G4FTFModel.hh"
#include "G4LundStringFragmentation.hh"
#include "G4ExcitedStringDecay.hh"
class G4FTFPNeutronBuilder : public G4VNeutronBuilder
{
public:
G4FTFPNeutronBuilder();
virtual ~G4FTFPNeutronBuilder();
public:
virtual void Build(G4HadronElasticProcess & aP);
virtual void Build(G4HadronFissionProcess & aP);
virtual void Build(G4HadronCaptureProcess & aP);
virtual void Build(G4NeutronInelasticProcess & aP);
void SetMinEnergy(G4double aM) {theMin = aM;}
private:
G4TheoFSGenerator * theModel;
G4ExcitationHandler theHandler;
G4PreCompoundModel * thePreEquilib;
G4GeneratorPrecompoundInterface * theCascade;
G4FTFModel theStringModel;
G4LundStringFragmentation theFragmentation;
G4ExcitedStringDecay * theStringDecay;
G4NeutronInelasticCrossSection theXSec;
G4double theMin;
};
// 2002 by J.P. Wellisch
#endif
@@ -0,0 +1,77 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
#ifndef G4FTFPPiKBuilder_h
#define G4FTFPPiKBuilder_h 1
#include "globals.hh"
#include "G4HadronElasticProcess.hh"
#include "G4HadronFissionProcess.hh"
#include "G4HadronCaptureProcess.hh"
#include "G4NeutronInelasticProcess.hh"
#include "G4VPiKBuilder.hh"
#include "G4TheoFSGenerator.hh"
#include "G4ExcitationHandler.hh"
#include "G4PreCompoundModel.hh"
#include "G4GeneratorPrecompoundInterface.hh"
#include "G4FTFModel.hh"
#include "G4LundStringFragmentation.hh"
#include "G4ExcitedStringDecay.hh"
#include "G4PiNuclearCrossSection.hh"
class G4FTFPPiKBuilder : public G4VPiKBuilder
{
public:
G4FTFPPiKBuilder();
virtual ~G4FTFPPiKBuilder();
public:
virtual void Build(G4HadronElasticProcess & aP);
virtual void Build(G4PionPlusInelasticProcess & aP);
virtual void Build(G4PionMinusInelasticProcess & aP);
virtual void Build(G4KaonPlusInelasticProcess & aP);
virtual void Build(G4KaonMinusInelasticProcess & aP);
virtual void Build(G4KaonZeroLInelasticProcess & aP);
virtual void Build(G4KaonZeroSInelasticProcess & aP);
void SetMinEnergy(G4double aM) {theMin = aM;}
private:
G4PiNuclearCrossSection thePiData;
G4TheoFSGenerator * theModel;
G4ExcitationHandler theHandler;
G4PreCompoundModel * thePreEquilib;
G4GeneratorPrecompoundInterface * theCascade;
G4FTFModel theStringModel;
G4LundStringFragmentation theFragmentation;
G4ExcitedStringDecay * theStringDecay;
G4double theMin;
};
// 2002 by J.P. Wellisch
#endif
@@ -0,0 +1,73 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
#ifndef G4FTFPProtonBuilder_h
#define G4FTFPProtonBuilder_h
#include "globals.hh"
#include "G4HadronElasticProcess.hh"
#include "G4HadronFissionProcess.hh"
#include "G4HadronCaptureProcess.hh"
#include "G4ProtonInelasticProcess.hh"
#include "G4VProtonBuilder.hh"
#include "G4NeutronInelasticCrossSection.hh"
#include "G4TheoFSGenerator.hh"
#include "G4ExcitationHandler.hh"
#include "G4PreCompoundModel.hh"
#include "G4GeneratorPrecompoundInterface.hh"
#include "G4FTFModel.hh"
#include "G4LundStringFragmentation.hh"
#include "G4ExcitedStringDecay.hh"
#include "G4ProtonInelasticCrossSection.hh"
class G4FTFPProtonBuilder : public G4VProtonBuilder
{
public:
G4FTFPProtonBuilder();
virtual ~G4FTFPProtonBuilder();
public:
virtual void Build(G4HadronElasticProcess & aP);
virtual void Build(G4ProtonInelasticProcess & aP);
void SetMinEnergy(G4double aM) {theMin = aM;}
private:
G4ProtonInelasticCrossSection theXSec;
G4TheoFSGenerator * theModel;
G4ExcitationHandler theHandler;
G4PreCompoundModel * thePreEquilib;
G4GeneratorPrecompoundInterface * theCascade;
G4FTFModel theStringModel;
G4LundStringFragmentation theFragmentation;
G4ExcitedStringDecay * theStringDecay;
G4double theMin;
};
// 2002 by J.P. Wellisch
#endif
@@ -0,0 +1,114 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
#ifndef G4HadronQEDBuilder_h
#define G4HadronQEDBuilder_h 1
#include "globals.hh"
#include "G4ios.hh"
#include "G4MultipleScattering.hh"
#include "G4hIonisation.hh"
#include "G4ProcessManager.hh"
#include "G4Proton.hh"
#include "G4AntiProton.hh"
#include "G4PionPlus.hh"
#include "G4PionMinus.hh"
#include "G4KaonPlus.hh"
#include "G4KaonMinus.hh"
#include "G4SigmaMinus.hh"
#include "G4AntiSigmaMinus.hh"
#include "G4SigmaPlus.hh"
#include "G4AntiSigmaPlus.hh"
#include "G4XiMinus.hh"
#include "G4AntiXiMinus.hh"
#include "G4OmegaMinus.hh"
#include "G4AntiOmegaMinus.hh"
#include "plist.tmp"
#include "ParticleCodeMap.hh"
class G4HadronQEDBuilder
{
public:
G4HadronQEDBuilder();
virtual ~G4HadronQEDBuilder();
public:
virtual void Build();
private:
void RegisterOne(G4ProcessManager* aP, G4MultipleScattering * aM, G4hIonisation* aI);
public: // to get gcc 2.95 satisfied...
typedef Plist<G4PionPlus, G4PionMinus, G4KaonPlus, G4KaonMinus, G4Proton, G4AntiProton, G4SigmaMinus,
G4AntiSigmaMinus, G4SigmaPlus, G4AntiSigmaPlus, G4XiMinus, G4AntiXiMinus, G4OmegaMinus,
G4AntiOmegaMinus> theParticles;
typedef std::pair<G4ParticleDefinition *, std::pair<G4MultipleScattering *, G4hIonisation *> > entryType;
static std::vector< entryType > & theCache()
{
static std::vector< entryType > cache;
return cache;
}
private:
G4bool wasActivated;
struct Clear
{ void operator () (entryType & aE)
{
G4ProcessManager * aP = aE.first->GetProcessManager();
if(aP) aP->RemoveProcess(aE.second.first);
if(aP) aP->RemoveProcess(aE.second.second);
}
};
struct Register
{
template <class T>
struct Fun // to get gcc 2.95 satisfied...
{
void operator()()
{
G4ParticleDefinition * aPart =
G4ParticleTable::GetParticleTable()->FindParticle(ParticleCodeMap<T>::PDG_CODE);
// G4cout << aPart<<G4endl;
// G4cout << "===== > Calling for "<<aPart->GetParticleName()<<G4endl;
G4ProcessManager * aP = aPart->GetProcessManager();
G4hIonisation * aI = new G4hIonisation;
G4MultipleScattering * aM = new G4MultipleScattering;
aP->AddProcess(aI, ordInActive,2, 2);
aP->AddProcess(aM);
aP->SetProcessOrdering(aM, idxAlongStep, 1);
aP->SetProcessOrdering(aM, idxPostStep, 1);
G4HadronQEDBuilder::theCache().push_back(std::make_pair(aPart, std::pair<G4MultipleScattering *, G4hIonisation *>(aM, aI) ) );
}
};
};
};
// 2002 by J.P. Wellisch
#endif
@@ -0,0 +1,61 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
#ifndef G4LEADNeutronBuilder_h
#define G4LEADNeutronBuilder_h 1
#include "globals.hh"
#include "G4HadronElasticProcess.hh"
#include "G4HadronFissionProcess.hh"
#include "G4HadronCaptureProcess.hh"
#include "G4NeutronInelasticProcess.hh"
#include "G4VNeutronBuilder.hh"
#include "G4Mars5GeV.hh"
#include "G4NeutronInelasticCrossSection.hh"
class G4LEADNeutronBuilder : public G4VNeutronBuilder
{
public:
G4LEADNeutronBuilder();
virtual ~G4LEADNeutronBuilder();
public:
virtual void Build(G4HadronElasticProcess & aP);
virtual void Build(G4HadronFissionProcess & aP);
virtual void Build(G4HadronCaptureProcess & aP);
virtual void Build(G4NeutronInelasticProcess & aP);
void SetMinEnergy(G4double aM) {theMin = aM;}
private:
G4NeutronInelasticCrossSection theXSec;
G4Mars5GeV * theModel;
G4double theMin;
};
// 2002 by J.P. Wellisch
#endif
@@ -0,0 +1,64 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
#ifndef G4LEADPiKBuilder_h
#define G4LEADPiKBuilder_h 1
#include "globals.hh"
#include "G4HadronElasticProcess.hh"
#include "G4HadronFissionProcess.hh"
#include "G4HadronCaptureProcess.hh"
#include "G4NeutronInelasticProcess.hh"
#include "G4VPiKBuilder.hh"
#include "G4PiNuclearCrossSection.hh"
#include "G4Mars5GeV.hh"
class G4LEADPiKBuilder : public G4VPiKBuilder
{
public:
G4LEADPiKBuilder();
virtual ~G4LEADPiKBuilder();
public:
virtual void Build(G4HadronElasticProcess & aP);
virtual void Build(G4PionPlusInelasticProcess & aP);
virtual void Build(G4PionMinusInelasticProcess & aP);
virtual void Build(G4KaonPlusInelasticProcess & aP);
virtual void Build(G4KaonMinusInelasticProcess & aP);
virtual void Build(G4KaonZeroLInelasticProcess & aP);
virtual void Build(G4KaonZeroSInelasticProcess & aP);
void SetMinEnergy(G4double aM) {theMin = aM;}
private:
G4PiNuclearCrossSection thePiData;
G4Mars5GeV * theModel;
G4double theMin;
};
// 2002 by J.P. Wellisch
#endif
@@ -0,0 +1,59 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
#ifndef G4LEADProtonBuilder_h
#define G4LEADProtonBuilder_h
#include "globals.hh"
#include "G4HadronElasticProcess.hh"
#include "G4HadronFissionProcess.hh"
#include "G4HadronCaptureProcess.hh"
#include "G4ProtonInelasticProcess.hh"
#include "G4VProtonBuilder.hh"
#include "G4Mars5GeV.hh"
#include "G4ProtonInelasticCrossSection.hh"
class G4LEADProtonBuilder : public G4VProtonBuilder
{
public:
G4LEADProtonBuilder();
virtual ~G4LEADProtonBuilder();
public:
virtual void Build(G4HadronElasticProcess & aP);
virtual void Build(G4ProtonInelasticProcess & aP);
void SetMinEnergy(G4double aM) {theMin = aM;}
private:
G4ProtonInelasticCrossSection theXSec;
G4Mars5GeV * theModel;
G4double theMin;
};
// 2002 by J.P. Wellisch
#endif
@@ -0,0 +1,86 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
#ifndef G4LEPNeutronBuilder_h
#define G4LEPNeutronBuilder_h 1
#include "globals.hh"
#include "G4HadronElasticProcess.hh"
#include "G4HadronFissionProcess.hh"
#include "G4HadronCaptureProcess.hh"
#include "G4NeutronInelasticProcess.hh"
#include "G4VNeutronBuilder.hh"
#include "G4LElastic.hh"
#include "G4LFission.hh"
#include "G4LCapture.hh"
#include "G4LENeutronInelastic.hh"
class G4LEPNeutronBuilder : public G4VNeutronBuilder
{
public:
G4LEPNeutronBuilder();
virtual ~G4LEPNeutronBuilder();
public:
virtual void Build(G4HadronElasticProcess & aP);
virtual void Build(G4HadronFissionProcess & aP);
virtual void Build(G4HadronCaptureProcess & aP);
virtual void Build(G4NeutronInelasticProcess & aP);
void SetMinEnergy(G4double aM)
{
theMin=aM;
theIMin = theMin;
}
void SetMinInelasticEnergy(G4double aM)
{
theIMin=aM;
}
void SetMaxEnergy(G4double aM)
{
theIMax = aM;
theMax=aM;
}
void SetMaxInelasticEnergy(G4double aM)
{
theIMax = aM;
}
private:
G4double theMin;
G4double theIMin;
G4double theMax;
G4double theIMax;
G4LElastic * theElasticModel;
G4LENeutronInelastic * theLENeutronModel;
G4LFission * theNeutronFissionModel;
G4LCapture * theNeutronCaptureModel;
};
// 2002 by J.P. Wellisch
#endif
@@ -0,0 +1,86 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
#ifndef G4LEPPiKBuilder_h
#define G4LEPPiKBuilder_h
#include "globals.hh"
#include "G4ios.hh"
#include "G4VPiKBuilder.hh"
#include "G4LElastic.hh"
#include "G4LEPionPlusInelastic.hh"
#include "G4LEPionMinusInelastic.hh"
#include "G4LEKaonPlusInelastic.hh"
#include "G4LEKaonZeroSInelastic.hh"
#include "G4LEKaonZeroLInelastic.hh"
#include "G4LEKaonMinusInelastic.hh"
class G4LEPPiKBuilder : public G4VPiKBuilder
{
public:
G4LEPPiKBuilder();
virtual ~G4LEPPiKBuilder();
public:
virtual void Build(G4HadronElasticProcess & aP);
virtual void Build(G4PionPlusInelasticProcess & aP);
virtual void Build(G4PionMinusInelasticProcess & aP);
virtual void Build(G4KaonPlusInelasticProcess & aP);
virtual void Build(G4KaonMinusInelasticProcess & aP);
virtual void Build(G4KaonZeroLInelasticProcess & aP);
virtual void Build(G4KaonZeroSInelasticProcess & aP);
void SetMinEnergy(G4double aM)
{
theMin=aM;
theMinPion=theMin;
}
void SetMinPionEnergy(G4double aM)
{
theMinPion=aM;
}
void SetMaxEnergy(G4double aM)
{
theMax=aM;
}
private:
G4double theMin;
G4double theMinPion;
G4double theMax;
G4LElastic * theElasticModel;
G4LEPionPlusInelastic* theLEPionPlusModel;
G4LEPionMinusInelastic* theLEPionMinusModel;
G4LEKaonPlusInelastic* theLEKaonPlusModel;
G4LEKaonMinusInelastic* theLEKaonMinusModel;
G4LEKaonZeroLInelastic* theLEKaonZeroLModel;
G4LEKaonZeroSInelastic* theLEKaonZeroSModel;
};
// 2002 by J.P. Wellisch
#endif
@@ -0,0 +1,65 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
#ifndef G4LEPProtonBuilder_h
#define G4LEPProtonBuilder_h 1
#include "globals.hh"
#include "G4HadronElasticProcess.hh"
#include "G4ProtonInelasticProcess.hh"
#include "G4VProtonBuilder.hh"
#include "G4LElastic.hh"
#include "G4LEProtonInelastic.hh"
class G4LEPProtonBuilder : public G4VProtonBuilder
{
public:
G4LEPProtonBuilder();
virtual ~G4LEPProtonBuilder();
public:
virtual void Build(G4ProtonInelasticProcess & aP);
virtual void Build(G4HadronElasticProcess & aP);
void SetMinEnergy(G4double aM)
{
theMin=aM;
}
void SetMaxEnergy(G4double aM)
{
theMax=aM;
}
private:
G4double theMin;
G4double theMax;
G4LElastic * theElasticModel;
G4LEProtonInelastic * theLEProtonModel;
};
// 2002 by J.P. Wellisch
#endif
@@ -0,0 +1,77 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
#ifndef G4LHEPNeutronBuilder_h
#define G4LHEPNeutronBuilder_h 1
#include "globals.hh"
#include "G4HadronElasticProcess.hh"
#include "G4HadronFissionProcess.hh"
#include "G4HadronCaptureProcess.hh"
#include "G4NeutronInelasticProcess.hh"
#include "G4VNeutronBuilder.hh"
#include "G4LElastic.hh"
#include "G4LFission.hh"
#include "G4LCapture.hh"
#include "G4LENeutronInelastic.hh"
#include "G4HENeutronInelastic.hh"
class G4LHEPNeutronBuilder : public G4VNeutronBuilder
{
public:
G4LHEPNeutronBuilder();
virtual ~G4LHEPNeutronBuilder();
public:
virtual void Build(G4HadronElasticProcess & aP);
virtual void Build(G4HadronFissionProcess & aP);
virtual void Build(G4HadronCaptureProcess & aP);
virtual void Build(G4NeutronInelasticProcess & aP);
void SetMinEnergy(G4double aM)
{
theMin = aM;
theIMin = aM;
}
void SetMinInelasticEnergy(G4double aM)
{
theIMin = aM;
}
private:
G4LElastic * theElasticModel;
G4LENeutronInelastic * theLENeutronModel;
G4HENeutronInelastic * theHENeutronModel;
G4LFission * theNeutronFissionModel;
G4LCapture * theNeutronCaptureModel;
G4double theMin;
G4double theIMin;
};
// 2002 by J.P. Wellisch
#endif
@@ -0,0 +1,104 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
#ifndef G4LHEPPiKBuilder_h
#define G4LHEPPiKBuilder_h 1
#include "globals.hh"
#include "G4ios.hh"
#include "G4LElastic.hh"
#include "G4VPiKBuilder.hh"
#include "G4LEPionPlusInelastic.hh"
#include "G4LEPionMinusInelastic.hh"
#include "G4LEKaonPlusInelastic.hh"
#include "G4LEKaonZeroSInelastic.hh"
#include "G4LEKaonZeroLInelastic.hh"
#include "G4LEKaonMinusInelastic.hh"
#include "G4HEPionPlusInelastic.hh"
#include "G4HEPionMinusInelastic.hh"
#include "G4HEKaonPlusInelastic.hh"
#include "G4HEKaonZeroInelastic.hh"
#include "G4HEKaonZeroInelastic.hh"
#include "G4HEKaonMinusInelastic.hh"
class G4LHEPPiKBuilder : public G4VPiKBuilder
{
public:
G4LHEPPiKBuilder();
virtual ~G4LHEPPiKBuilder();
public:
virtual void Build(G4HadronElasticProcess & aP);
virtual void Build(G4PionPlusInelasticProcess & aP);
virtual void Build(G4PionMinusInelasticProcess & aP);
virtual void Build(G4KaonPlusInelasticProcess & aP);
virtual void Build(G4KaonMinusInelasticProcess & aP);
virtual void Build(G4KaonZeroLInelasticProcess & aP);
virtual void Build(G4KaonZeroSInelasticProcess & aP);
void SetMinEnergy(G4double aM)
{
theM=aM;
theMinPion=theM;
}
void SetMinPionEnergy(G4double aM)
{
theMinPion = aM;
}
private:
G4double theM;
G4double theMinPion;
G4LElastic * theElasticModel;
// Pi +
G4LEPionPlusInelastic* theLEPionPlusModel;
G4HEPionPlusInelastic* theHEPionPlusModel;
// Pi -
G4LEPionMinusInelastic* theLEPionMinusModel;
G4HEPionMinusInelastic* theHEPionMinusModel;
// K +
G4LEKaonPlusInelastic* theLEKaonPlusModel;
G4HEKaonPlusInelastic* theHEKaonPlusModel;
// K -
G4LEKaonMinusInelastic* theLEKaonMinusModel;
G4HEKaonMinusInelastic* theHEKaonMinusModel;
// K0L
G4LEKaonZeroLInelastic* theLEKaonZeroLModel;
G4HEKaonZeroInelastic* theHEKaonZeroLModel;
// K0S
G4LEKaonZeroSInelastic* theLEKaonZeroSModel;
G4HEKaonZeroInelastic* theHEKaonZeroSModel;
};
// 2002 by J.P. Wellisch
#endif
@@ -0,0 +1,63 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
#ifndef G4LHEPProtonBuilder_h
#define G4LHEPProtonBuilder_h 1
#include "globals.hh"
#include "G4HadronElasticProcess.hh"
#include "G4ProtonInelasticProcess.hh"
#include "G4VProtonBuilder.hh"
#include "G4LElastic.hh"
#include "G4LEProtonInelastic.hh"
#include "G4HEProtonInelastic.hh"
class G4LHEPProtonBuilder : public G4VProtonBuilder
{
public:
G4LHEPProtonBuilder();
virtual ~G4LHEPProtonBuilder();
public:
virtual void Build(G4ProtonInelasticProcess & aP);
virtual void Build(G4HadronElasticProcess & aP);
void SetMinEnergy(G4double aM)
{
theMin = aM;
}
private:
G4LElastic * theElasticModel;
G4LEProtonInelastic * theLEProtonModel;
G4HEProtonInelastic * theHEProtonModel;
G4double theMin;
};
// 2002 by J.P. Wellisch
#endif
@@ -0,0 +1,178 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
#ifndef G4MiscLHEPBuilder_h
#define G4MiscLHEPBuilder_h 1
#include "globals.hh"
#include "G4LElastic.hh"
#include "G4HadronElasticProcess.hh"
#include "G4AntiProtonInelasticProcess.hh"
#include "G4AntiNeutronInelasticProcess.hh"
#include "G4LambdaInelasticProcess.hh"
#include "G4AntiLambdaInelasticProcess.hh"
#include "G4SigmaPlusInelasticProcess.hh"
#include "G4SigmaMinusInelasticProcess.hh"
#include "G4AntiSigmaPlusInelasticProcess.hh"
#include "G4AntiSigmaMinusInelasticProcess.hh"
#include "G4XiZeroInelasticProcess.hh"
#include "G4XiMinusInelasticProcess.hh"
#include "G4AntiXiZeroInelasticProcess.hh"
#include "G4AntiXiMinusInelasticProcess.hh"
#include "G4OmegaMinusInelasticProcess.hh"
#include "G4AntiOmegaMinusInelasticProcess.hh"
#include "G4LEAntiProtonInelastic.hh"
#include "G4LEAntiNeutronInelastic.hh"
#include "G4LELambdaInelastic.hh"
#include "G4LEAntiLambdaInelastic.hh"
#include "G4LESigmaPlusInelastic.hh"
#include "G4LESigmaMinusInelastic.hh"
#include "G4LEAntiSigmaPlusInelastic.hh"
#include "G4LEAntiSigmaMinusInelastic.hh"
#include "G4LEXiZeroInelastic.hh"
#include "G4LEXiMinusInelastic.hh"
#include "G4LEAntiXiZeroInelastic.hh"
#include "G4LEAntiXiMinusInelastic.hh"
#include "G4LEOmegaMinusInelastic.hh"
#include "G4LEAntiOmegaMinusInelastic.hh"
// High-energy Models
#include "G4HEAntiProtonInelastic.hh"
#include "G4HEAntiNeutronInelastic.hh"
#include "G4HELambdaInelastic.hh"
#include "G4HEAntiLambdaInelastic.hh"
#include "G4HESigmaPlusInelastic.hh"
#include "G4HESigmaMinusInelastic.hh"
#include "G4HEAntiSigmaPlusInelastic.hh"
#include "G4HEAntiSigmaMinusInelastic.hh"
#include "G4HEXiZeroInelastic.hh"
#include "G4HEXiMinusInelastic.hh"
#include "G4HEAntiXiZeroInelastic.hh"
#include "G4HEAntiXiMinusInelastic.hh"
#include "G4HEOmegaMinusInelastic.hh"
#include "G4HEAntiOmegaMinusInelastic.hh"
class G4MiscLHEPBuilder
{
public:
G4MiscLHEPBuilder();
virtual ~G4MiscLHEPBuilder();
public:
void Build();
private:
G4LElastic* theElasticModel;
// anti-proton
G4HadronElasticProcess theAntiProtonElasticProcess;
G4AntiProtonInelasticProcess theAntiProtonInelastic;
G4LEAntiProtonInelastic* theLEAntiProtonModel;
G4HEAntiProtonInelastic* theHEAntiProtonModel;
// anti-neutron
G4HadronElasticProcess theAntiNeutronElasticProcess;
G4AntiNeutronInelasticProcess theAntiNeutronInelastic;
G4LEAntiNeutronInelastic* theLEAntiNeutronModel;
G4HEAntiNeutronInelastic* theHEAntiNeutronModel;
// Lambda
G4HadronElasticProcess theLambdaElasticProcess;
G4LambdaInelasticProcess theLambdaInelastic;
G4LELambdaInelastic* theLELambdaModel;
G4HELambdaInelastic* theHELambdaModel;
// AntiLambda
G4HadronElasticProcess theAntiLambdaElasticProcess;
G4AntiLambdaInelasticProcess theAntiLambdaInelastic;
G4LEAntiLambdaInelastic* theLEAntiLambdaModel;
G4HEAntiLambdaInelastic* theHEAntiLambdaModel;
// SigmaMinus
G4HadronElasticProcess theSigmaMinusElasticProcess;
G4SigmaMinusInelasticProcess theSigmaMinusInelastic;
G4LESigmaMinusInelastic* theLESigmaMinusModel;
G4HESigmaMinusInelastic* theHESigmaMinusModel;
// AntiSigmaMinus
G4HadronElasticProcess theAntiSigmaMinusElasticProcess;
G4AntiSigmaMinusInelasticProcess theAntiSigmaMinusInelastic;
G4LEAntiSigmaMinusInelastic* theLEAntiSigmaMinusModel;
G4HEAntiSigmaMinusInelastic* theHEAntiSigmaMinusModel;
// SigmaPlus
G4HadronElasticProcess theSigmaPlusElasticProcess;
G4SigmaPlusInelasticProcess theSigmaPlusInelastic;
G4LESigmaPlusInelastic* theLESigmaPlusModel;
G4HESigmaPlusInelastic* theHESigmaPlusModel;
// AntiSigmaPlus
G4HadronElasticProcess theAntiSigmaPlusElasticProcess;
G4AntiSigmaPlusInelasticProcess theAntiSigmaPlusInelastic;
G4LEAntiSigmaPlusInelastic* theLEAntiSigmaPlusModel;
G4HEAntiSigmaPlusInelastic* theHEAntiSigmaPlusModel;
// XiZero
G4HadronElasticProcess theXiZeroElasticProcess;
G4XiZeroInelasticProcess theXiZeroInelastic;
G4LEXiZeroInelastic* theLEXiZeroModel;
G4HEXiZeroInelastic* theHEXiZeroModel;
// AntiXiZero
G4HadronElasticProcess theAntiXiZeroElasticProcess;
G4AntiXiZeroInelasticProcess theAntiXiZeroInelastic;
G4LEAntiXiZeroInelastic* theLEAntiXiZeroModel;
G4HEAntiXiZeroInelastic* theHEAntiXiZeroModel;
// XiMinus
G4HadronElasticProcess theXiMinusElasticProcess;
G4XiMinusInelasticProcess theXiMinusInelastic;
G4LEXiMinusInelastic* theLEXiMinusModel;
G4HEXiMinusInelastic* theHEXiMinusModel;
// AntiXiMinus
G4HadronElasticProcess theAntiXiMinusElasticProcess;
G4AntiXiMinusInelasticProcess theAntiXiMinusInelastic;
G4LEAntiXiMinusInelastic* theLEAntiXiMinusModel;
G4HEAntiXiMinusInelastic* theHEAntiXiMinusModel;
// OmegaMinus
G4HadronElasticProcess theOmegaMinusElasticProcess;
G4OmegaMinusInelasticProcess theOmegaMinusInelastic;
G4LEOmegaMinusInelastic* theLEOmegaMinusModel;
G4HEOmegaMinusInelastic* theHEOmegaMinusModel;
// AntiOmegaMinus
G4HadronElasticProcess theAntiOmegaMinusElasticProcess;
G4AntiOmegaMinusInelasticProcess theAntiOmegaMinusInelastic;
G4LEAntiOmegaMinusInelastic* theLEAntiOmegaMinusModel;
G4HEAntiOmegaMinusInelastic* theHEAntiOmegaMinusModel;
G4bool wasActivated;
};
// 2002 by J.P. Wellisch
#endif
@@ -0,0 +1,61 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
#ifndef G4NeutronBuilder_h
#define G4NeutronBuilder_h 1
#include "globals.hh"
#include "G4HadronElasticProcess.hh"
#include "G4HadronFissionProcess.hh"
#include "G4HadronCaptureProcess.hh"
#include "G4NeutronInelasticProcess.hh"
#include "G4VNeutronBuilder.hh"
#include <vector>
class G4NeutronBuilder
{
public:
G4NeutronBuilder();
virtual ~G4NeutronBuilder();
public:
void Build();
void RegisterMe(G4VNeutronBuilder * aB) {theModelCollections.push_back(aB);}
private:
G4HadronElasticProcess theNeutronElasticProcess;
G4NeutronInelasticProcess theNeutronInelastic;
G4HadronFissionProcess theNeutronFission;
G4HadronCaptureProcess theNeutronCapture;
std::vector<G4VNeutronBuilder *> theModelCollections;
G4bool wasActivated;
};
// 2002 by J.P. Wellisch
#endif
@@ -0,0 +1,70 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
#ifndef G4NeutronHPBuilder_h
#define G4NeutronHPBuilder_h 1
#include "globals.hh"
#include "G4HadronElasticProcess.hh"
#include "G4HadronFissionProcess.hh"
#include "G4HadronCaptureProcess.hh"
#include "G4NeutronInelasticProcess.hh"
#include "G4VNeutronBuilder.hh"
#include "G4NeutronHPElasticData.hh"
#include "G4NeutronHPElastic.hh"
#include "G4NeutronHPInelastic.hh"
#include "G4NeutronHPInelasticData.hh"
#include "G4NeutronHPFission.hh"
#include "G4NeutronHPFissionData.hh"
#include "G4NeutronHPCapture.hh"
#include "G4NeutronHPCaptureData.hh"
class G4NeutronHPBuilder : public G4VNeutronBuilder
{
public:
G4NeutronHPBuilder();
virtual ~G4NeutronHPBuilder();
public:
virtual void Build(G4HadronElasticProcess & aP);
virtual void Build(G4HadronFissionProcess & aP);
virtual void Build(G4HadronCaptureProcess & aP);
virtual void Build(G4NeutronInelasticProcess & aP);
private:
G4NeutronHPElastic * theHPElastic;
G4NeutronHPElasticData * theHPElasticData;
G4NeutronHPInelastic * theHPInelastic;
G4NeutronHPInelasticData * theHPInelasticData;
G4NeutronHPFission * theHPFission;
G4NeutronHPFissionData * theHPFissionData;
G4NeutronHPCapture * theHPCapture;
G4NeutronHPCaptureData * theHPCaptureData;
};
// 2002 by J.P. Wellisch
#endif
@@ -0,0 +1,67 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
#ifndef G4PiKBuilder_h
#define G4PiKBuilder_h 1
#include "globals.hh"
#include "G4HadronElasticProcess.hh"
#include "G4ProtonInelasticProcess.hh"
#include "G4VPiKBuilder.hh"
#include <vector>
class G4PiKBuilder
{
public:
G4PiKBuilder();
virtual ~G4PiKBuilder();
public:
void Build();
void RegisterMe(G4VPiKBuilder * aB) {theModelCollections.push_back(aB);}
private:
G4HadronElasticProcess thePionPlusElasticProcess;
G4HadronElasticProcess thePionMinusElasticProcess;
G4HadronElasticProcess theKaonPlusElasticProcess;
G4HadronElasticProcess theKaonMinusElasticProcess;
G4HadronElasticProcess theKaonZeroLElasticProcess;
G4HadronElasticProcess theKaonZeroSElasticProcess;
G4PionPlusInelasticProcess thePionPlusInelastic;
G4PionMinusInelasticProcess thePionMinusInelastic;
G4KaonPlusInelasticProcess theKaonPlusInelastic;
G4KaonMinusInelasticProcess theKaonMinusInelastic;
G4KaonZeroLInelasticProcess theKaonZeroLInelastic;
G4KaonZeroSInelasticProcess theKaonZeroSInelastic;
std::vector<G4VPiKBuilder *> theModelCollections;
G4bool wasActivated;
};
// 2002 by J.P. Wellisch
#endif
@@ -0,0 +1,64 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
#ifndef G4PrecoNeutronBuilder_h
#define G4PrecoNeutronBuilder_h 1
#include "globals.hh"
#include "G4HadronElasticProcess.hh"
#include "G4HadronFissionProcess.hh"
#include "G4HadronCaptureProcess.hh"
#include "G4NeutronInelasticProcess.hh"
#include "G4VNeutronBuilder.hh"
#include "G4PreCompoundModel.hh"
#include "G4ExcitationHandler.hh"
#include "G4NeutronInelasticCrossSection.hh"
class G4PrecoNeutronBuilder : public G4VNeutronBuilder
{
public:
G4PrecoNeutronBuilder();
virtual ~G4PrecoNeutronBuilder();
public:
virtual void Build(G4HadronElasticProcess & aP);
virtual void Build(G4HadronFissionProcess & aP);
virtual void Build(G4HadronCaptureProcess & aP);
virtual void Build(G4NeutronInelasticProcess & aP);
void SetMinEnergy(G4double aM) {theMin = aM;}
private:
G4PreCompoundModel * theModel;
G4ExcitationHandler theHandler;
G4NeutronInelasticCrossSection theXSec;
G4double theMin;
G4double theMax;
};
// 2002 by J.P. Wellisch
#endif
@@ -0,0 +1,62 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
#ifndef G4PrecoProtonBuilder_h
#define G4PrecoProtonBuilder_h
#include "globals.hh"
#include "G4HadronElasticProcess.hh"
#include "G4HadronFissionProcess.hh"
#include "G4HadronCaptureProcess.hh"
#include "G4ProtonInelasticProcess.hh"
#include "G4VProtonBuilder.hh"
#include "G4ExcitationHandler.hh"
#include "G4PreCompoundModel.hh"
#include "G4ProtonInelasticCrossSection.hh"
class G4PrecoProtonBuilder : public G4VProtonBuilder
{
public:
G4PrecoProtonBuilder();
virtual ~G4PrecoProtonBuilder();
public:
virtual void Build(G4HadronElasticProcess & aP);
virtual void Build(G4ProtonInelasticProcess & aP);
void SetMinEnergy(G4double aM) {theMin = aM;}
private:
G4ProtonInelasticCrossSection theXSec;
G4ExcitationHandler theHandler;
G4PreCompoundModel * theModel;
G4double theMin;
G4double theMax;
};
// 2002 by J.P. Wellisch
#endif
@@ -0,0 +1,56 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
#ifndef G4ProtonBuilder_h
#define G4ProtonBuilder_h 1
#include "globals.hh"
#include "G4HadronElasticProcess.hh"
#include "G4ProtonInelasticProcess.hh"
#include "G4VProtonBuilder.hh"
#include <vector>
class G4ProtonBuilder
{
public:
G4ProtonBuilder();
virtual ~G4ProtonBuilder();
public:
void Build();
void RegisterMe(G4VProtonBuilder * aB) {theModelCollections.push_back(aB);}
private:
G4HadronElasticProcess theProtonElasticProcess;
G4ProtonInelasticProcess theProtonInelastic;
std::vector<G4VProtonBuilder *> theModelCollections;
G4bool wasActivated;
};
// 2002 by J.P. Wellisch
#endif
@@ -0,0 +1,71 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
#ifndef G4QGSCNeutronBuilder_h
#define G4QGSCNeutronBuilder_h 1
#include "globals.hh"
#include "G4HadronElasticProcess.hh"
#include "G4HadronFissionProcess.hh"
#include "G4HadronCaptureProcess.hh"
#include "G4NeutronInelasticProcess.hh"
#include "G4VNeutronBuilder.hh"
#include "G4NeutronInelasticCrossSection.hh"
#include "G4TheoFSGenerator.hh"
#include "G4StringChipsParticleLevelInterface.hh"
#include "G4QGSModel.hh"
#include "G4QGSParticipants.hh"
#include "G4QGSMFragmentation.hh"
#include "G4ExcitedStringDecay.hh"
class G4QGSCNeutronBuilder : public G4VNeutronBuilder
{
public:
G4QGSCNeutronBuilder();
virtual ~G4QGSCNeutronBuilder();
public:
virtual void Build(G4HadronElasticProcess & ){}
virtual void Build(G4HadronFissionProcess & ){}
virtual void Build(G4HadronCaptureProcess & ){}
virtual void Build(G4NeutronInelasticProcess & aP);
void SetMinEnergy(G4double aM) {theMin = aM;}
private:
G4QGSModel< G4QGSParticipants > theStringModel;
G4StringChipsParticleLevelInterface * theCascade;
G4TheoFSGenerator * theModel;
G4QGSMFragmentation theFragmentation;
G4ExcitedStringDecay * theStringDecay;
G4NeutronInelasticCrossSection theXSec;
G4double theMin;
};
// 2002 by J.P. Wellisch
#endif
@@ -0,0 +1,75 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
#ifndef G4QGSCPiKBuilder_h
#define G4QGSCPiKBuilder_h 1
#include "globals.hh"
#include "G4HadronElasticProcess.hh"
#include "G4HadronFissionProcess.hh"
#include "G4HadronCaptureProcess.hh"
#include "G4NeutronInelasticProcess.hh"
#include "G4VPiKBuilder.hh"
#include "G4PiNuclearCrossSection.hh"
#include "G4TheoFSGenerator.hh"
#include "G4StringChipsParticleLevelInterface.hh"
#include "G4QGSModel.hh"
#include "G4QGSParticipants.hh"
#include "G4QGSMFragmentation.hh"
#include "G4ExcitedStringDecay.hh"
class G4QGSCPiKBuilder : public G4VPiKBuilder
{
public:
G4QGSCPiKBuilder();
virtual ~G4QGSCPiKBuilder();
public:
virtual void Build(G4HadronElasticProcess & aP);
virtual void Build(G4PionPlusInelasticProcess & aP);
virtual void Build(G4PionMinusInelasticProcess & aP);
virtual void Build(G4KaonPlusInelasticProcess & aP);
virtual void Build(G4KaonMinusInelasticProcess & aP);
virtual void Build(G4KaonZeroLInelasticProcess & aP);
virtual void Build(G4KaonZeroSInelasticProcess & aP);
void SetMinEnergy(G4double aM) {theMin = aM;}
private:
G4PiNuclearCrossSection thePiCross;
G4TheoFSGenerator * theModel;
G4StringChipsParticleLevelInterface * theCascade;
G4QGSModel< G4QGSParticipants > theStringModel;
G4QGSMFragmentation theFragmentation;
G4ExcitedStringDecay * theStringDecay;
G4double theMin;
};
// 2002 by J.P. Wellisch
#endif
@@ -0,0 +1,70 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
#ifndef G4QGSCProtonBuilder_h
#define G4QGSCProtonBuilder_h
#include "globals.hh"
#include "G4HadronElasticProcess.hh"
#include "G4HadronFissionProcess.hh"
#include "G4HadronCaptureProcess.hh"
#include "G4ProtonInelasticProcess.hh"
#include "G4VProtonBuilder.hh"
#include "G4NeutronInelasticCrossSection.hh"
#include "G4TheoFSGenerator.hh"
#include "G4StringChipsParticleLevelInterface.hh"
#include "G4QGSModel.hh"
#include "G4QGSParticipants.hh"
#include "G4QGSMFragmentation.hh"
#include "G4ExcitedStringDecay.hh"
#include "G4ProtonInelasticCrossSection.hh"
class G4QGSCProtonBuilder : public G4VProtonBuilder
{
public:
G4QGSCProtonBuilder();
virtual ~G4QGSCProtonBuilder();
public:
virtual void Build(G4HadronElasticProcess & aP);
virtual void Build(G4ProtonInelasticProcess & aP);
void SetMinEnergy(G4double aM) {theMin = aM;}
private:
G4ProtonInelasticCrossSection theXSec;
G4TheoFSGenerator * theModel;
G4StringChipsParticleLevelInterface * theCascade;
G4QGSModel< G4QGSParticipants > theStringModel;
G4QGSMFragmentation theFragmentation;
G4ExcitedStringDecay * theStringDecay;
G4double theMin;
};
// 2002 by J.P. Wellisch
#endif
@@ -0,0 +1,75 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
#ifndef G4QGSPNeutronBuilder_h
#define G4QGSPNeutronBuilder_h 1
#include "globals.hh"
#include "G4HadronElasticProcess.hh"
#include "G4HadronFissionProcess.hh"
#include "G4HadronCaptureProcess.hh"
#include "G4NeutronInelasticProcess.hh"
#include "G4VNeutronBuilder.hh"
#include "G4NeutronInelasticCrossSection.hh"
#include "G4TheoFSGenerator.hh"
#include "G4ExcitationHandler.hh"
#include "G4PreCompoundModel.hh"
#include "G4GeneratorPrecompoundInterface.hh"
#include "G4QGSModel.hh"
#include "G4QGSParticipants.hh"
#include "G4QGSMFragmentation.hh"
#include "G4ExcitedStringDecay.hh"
class G4QGSPNeutronBuilder : public G4VNeutronBuilder
{
public:
G4QGSPNeutronBuilder();
virtual ~G4QGSPNeutronBuilder();
public:
virtual void Build(G4HadronElasticProcess & aP);
virtual void Build(G4HadronFissionProcess & aP);
virtual void Build(G4HadronCaptureProcess & aP);
virtual void Build(G4NeutronInelasticProcess & aP);
void SetMinEnergy(G4double aM) {theMin = aM;}
private:
G4TheoFSGenerator * theModel;
G4ExcitationHandler theHandler;
G4PreCompoundModel * thePreEquilib;
G4GeneratorPrecompoundInterface * theCascade;
G4QGSModel< G4QGSParticipants > theStringModel;
G4QGSMFragmentation theFragmentation;
G4ExcitedStringDecay * theStringDecay;
G4NeutronInelasticCrossSection theXSec;
G4double theMin;
};
// 2002 by J.P. Wellisch
#endif
@@ -0,0 +1,78 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
#ifndef G4QGSPPiKBuilder_h
#define G4QGSPPiKBuilder_h 1
#include "globals.hh"
#include "G4HadronElasticProcess.hh"
#include "G4HadronFissionProcess.hh"
#include "G4HadronCaptureProcess.hh"
#include "G4NeutronInelasticProcess.hh"
#include "G4VPiKBuilder.hh"
#include "G4TheoFSGenerator.hh"
#include "G4ExcitationHandler.hh"
#include "G4PreCompoundModel.hh"
#include "G4GeneratorPrecompoundInterface.hh"
#include "G4QGSModel.hh"
#include "G4QGSParticipants.hh"
#include "G4QGSMFragmentation.hh"
#include "G4ExcitedStringDecay.hh"
#include "G4PiNuclearCrossSection.hh"
class G4QGSPPiKBuilder : public G4VPiKBuilder
{
public:
G4QGSPPiKBuilder();
virtual ~G4QGSPPiKBuilder();
public:
virtual void Build(G4HadronElasticProcess & aP);
virtual void Build(G4PionPlusInelasticProcess & aP);
virtual void Build(G4PionMinusInelasticProcess & aP);
virtual void Build(G4KaonPlusInelasticProcess & aP);
virtual void Build(G4KaonMinusInelasticProcess & aP);
virtual void Build(G4KaonZeroLInelasticProcess & aP);
virtual void Build(G4KaonZeroSInelasticProcess & aP);
void SetMinEnergy(G4double aM) {theMin = aM;}
private:
G4PiNuclearCrossSection thePiData;
G4TheoFSGenerator * theModel;
G4ExcitationHandler theHandler;
G4PreCompoundModel * thePreEquilib;
G4GeneratorPrecompoundInterface * theCascade;
G4QGSModel< G4QGSParticipants > theStringModel;
G4QGSMFragmentation theFragmentation;
G4ExcitedStringDecay * theStringDecay;
G4double theMin;
};
// 2002 by J.P. Wellisch
#endif
@@ -0,0 +1,74 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
#ifndef G4QGSPProtonBuilder_h
#define G4QGSPProtonBuilder_h
#include "globals.hh"
#include "G4HadronElasticProcess.hh"
#include "G4HadronFissionProcess.hh"
#include "G4HadronCaptureProcess.hh"
#include "G4ProtonInelasticProcess.hh"
#include "G4VProtonBuilder.hh"
#include "G4NeutronInelasticCrossSection.hh"
#include "G4TheoFSGenerator.hh"
#include "G4ExcitationHandler.hh"
#include "G4PreCompoundModel.hh"
#include "G4GeneratorPrecompoundInterface.hh"
#include "G4QGSModel.hh"
#include "G4QGSParticipants.hh"
#include "G4QGSMFragmentation.hh"
#include "G4ExcitedStringDecay.hh"
#include "G4ProtonInelasticCrossSection.hh"
class G4QGSPProtonBuilder : public G4VProtonBuilder
{
public:
G4QGSPProtonBuilder();
virtual ~G4QGSPProtonBuilder();
public:
virtual void Build(G4HadronElasticProcess & aP);
virtual void Build(G4ProtonInelasticProcess & aP);
void SetMinEnergy(G4double aM) {theMin = aM;}
private:
G4ProtonInelasticCrossSection theXSec;
G4TheoFSGenerator * theModel;
G4ExcitationHandler theHandler;
G4PreCompoundModel * thePreEquilib;
G4GeneratorPrecompoundInterface * theCascade;
G4QGSModel< G4QGSParticipants > theStringModel;
G4QGSMFragmentation theFragmentation;
G4ExcitedStringDecay * theStringDecay;
G4double theMin;
};
// 2002 by J.P. Wellisch
#endif
@@ -0,0 +1,57 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
#ifndef G4StoppingHadronBuilder_h
#define G4StoppingHadronBuilder_h 1
#include "globals.hh"
#include "G4ios.hh"
// At rest processes
#include "G4AntiProtonAnnihilationAtRest.hh"
#include "G4AntiNeutronAnnihilationAtRest.hh"
#include "G4PionMinusAbsorptionAtRest.hh"
#include "G4KaonMinusAbsorption.hh"
class G4StoppingHadronBuilder
{
public:
G4StoppingHadronBuilder();
virtual ~G4StoppingHadronBuilder();
public:
virtual void Build();
private:
G4PionMinusAbsorptionAtRest thePionMinusAbsorption;
G4KaonMinusAbsorption theKaonMinusAbsorption;
G4AntiProtonAnnihilationAtRest theAntiProtonAnnihilation;
G4AntiNeutronAnnihilationAtRest theAntiNeutronAnnihilation;
G4bool wasActivated;
};
// 2002 by J.P. Wellisch
#endif
@@ -0,0 +1,43 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
#ifndef G4VNeutronBuilder_h
#define G4VNeutronBuilder_h
class G4HadronElasticProcess;
class G4HadronFissionProcess;
class G4HadronCaptureProcess;
class G4NeutronInelasticProcess;
class G4VNeutronBuilder
{
public:
G4VNeutronBuilder() {}
virtual ~G4VNeutronBuilder() {}
virtual void Build(G4HadronElasticProcess & aP) = 0;
virtual void Build(G4HadronFissionProcess & aP) = 0;
virtual void Build(G4HadronCaptureProcess & aP) = 0;
virtual void Build(G4NeutronInelasticProcess & aP) = 0;
};
// 2002 by J.P. Wellisch
#endif
@@ -0,0 +1,49 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
#ifndef G4VPiKBuilder_h
#define G4VPiKBuilder_h
#include "G4HadronElasticProcess.hh"
#include "G4PionPlusInelasticProcess.hh"
#include "G4PionMinusInelasticProcess.hh"
#include "G4KaonPlusInelasticProcess.hh"
#include "G4KaonMinusInelasticProcess.hh"
#include "G4KaonZeroLInelasticProcess.hh"
#include "G4KaonZeroSInelasticProcess.hh"
class G4VPiKBuilder
{
public:
G4VPiKBuilder() {}
virtual ~G4VPiKBuilder() {}
virtual void Build(G4HadronElasticProcess & aP) = 0;
virtual void Build(G4PionPlusInelasticProcess & aP) = 0;
virtual void Build(G4PionMinusInelasticProcess & aP) = 0;
virtual void Build(G4KaonPlusInelasticProcess & aP) = 0;
virtual void Build(G4KaonMinusInelasticProcess & aP) = 0;
virtual void Build(G4KaonZeroLInelasticProcess & aP) = 0;
virtual void Build(G4KaonZeroSInelasticProcess & aP) = 0;
};
// 2002 by J.P. Wellisch
#endif
@@ -0,0 +1,39 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
#ifndef G4VProtonBuilder_h
#define G4VProtonBuilder_h
class G4ProtonInelasticProcess;
class G4HadronElasticProcess;
class G4VProtonBuilder
{
public:
G4VProtonBuilder() {}
virtual ~G4VProtonBuilder() {}
virtual void Build(G4HadronElasticProcess & aP) = 0;
virtual void Build(G4ProtonInelasticProcess & aP) = 0;
};
// 2002 by J.P. Wellisch
#endif
@@ -0,0 +1,68 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
#ifndef GeneralPhysics_h
#define GeneralPhysics_h 1
#include "globals.hh"
#include "G4ios.hh"
#include "G4VPhysicsConstructor.hh"
#include "G4Decay.hh"
class GeneralPhysics : public G4VPhysicsConstructor
{
public:
GeneralPhysics(const G4String& name = "general");
virtual ~GeneralPhysics();
public:
// This method will be invoked in the Construct() method.
// each particle type will be instantiated
virtual void ConstructParticle();
// This method will be invoked in the Construct() method.
// each physics process will be instantiated and
// registered to the process manager of each particle type
virtual void ConstructProcess();
protected:
G4bool wasActivated;
private:
G4Decay fDecayProcess;
};
// 2002 by J.P. Wellisch
#endif
@@ -0,0 +1,107 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
//========================
// taken from example N04 of G4 distribution
//========================
#ifndef IonPhysics_h
#define IonPhysics_h 1
#include "globals.hh"
#include "G4ios.hh"
#include "G4VPhysicsConstructor.hh"
#include "G4HadronElasticProcess.hh"
#include "G4LElastic.hh"
#include "G4DeuteronInelasticProcess.hh"
#include "G4LEDeuteronInelastic.hh"
#include "G4TritonInelasticProcess.hh"
#include "G4LETritonInelastic.hh"
#include "G4AlphaInelasticProcess.hh"
#include "G4LEAlphaInelastic.hh"
#include "G4hIonisation.hh"
#include "G4ionIonisation.hh"
#include "G4MultipleScattering.hh"
class IonPhysics : public G4VPhysicsConstructor
{
public:
IonPhysics(const G4String& name="ion");
virtual ~IonPhysics();
public:
// This method will be invoked in the Construct() method.
// each particle type will be instantiated
virtual void ConstructParticle();
// This method will be invoked in the Construct() method.
// each physics process will be instantiated and
// registered to the process manager of each particle type
virtual void ConstructProcess();
protected:
// Elastic Process
G4LElastic* theElasticModel;
// Generic Ion physics
G4HadronElasticProcess theIonElasticProcess;
G4MultipleScattering fIonMultipleScattering;
G4ionIonisation fIonIonisation;
// Deuteron physics
G4HadronElasticProcess theDElasticProcess;
G4MultipleScattering fDeuteronMultipleScattering;
G4hIonisation fDeuteronIonisation;
G4DeuteronInelasticProcess fDeuteronProcess;
G4LEDeuteronInelastic* fDeuteronModel;
// Triton physics
G4HadronElasticProcess theTElasticProcess;
G4MultipleScattering fTritonMultipleScattering;
G4hIonisation fTritonIonisation;
G4TritonInelasticProcess fTritonProcess;
G4LETritonInelastic* fTritonModel;
// Alpha physics
G4HadronElasticProcess theAElasticProcess;
G4MultipleScattering fAlphaMultipleScattering;
G4hIonisation fAlphaIonisation;
G4AlphaInelasticProcess fAlphaProcess;
G4LEAlphaInelastic* fAlphaModel;
// He3 physics
G4HadronElasticProcess theHe3ElasticProcess;
G4MultipleScattering fHe3MultipleScattering;
G4hIonisation fHe3Ionisation;
G4bool wasActivated;
};
// 2002 by J.P. Wellisch
#endif
@@ -0,0 +1,76 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
#ifndef MuonPhysics_h
#define MuonPhysics_h 1
#include "globals.hh"
#include "G4ios.hh"
#include "G4VPhysicsConstructor.hh"
#include "G4MultipleScattering.hh"
#include "G4MuBremsstrahlung.hh"
#include "G4MuPairProduction.hh"
#include "G4MuIonisation.hh"
#include "G4hIonisation.hh"
#include "G4MuonMinusCaptureAtRest.hh"
class MuonPhysics : public G4VPhysicsConstructor
{
public:
MuonPhysics(const G4String& name="muon");
virtual ~MuonPhysics();
public:
virtual void ConstructParticle();
virtual void ConstructProcess();
protected:
// Muon physics
G4MultipleScattering fMuPlusMultipleScattering;
G4MuBremsstrahlung fMuPlusBremsstrahlung ;
G4MuPairProduction fMuPlusPairProduction;
G4MuIonisation fMuPlusIonisation;
G4MultipleScattering fMuMinusMultipleScattering;
G4MuBremsstrahlung fMuMinusBremsstrahlung ;
G4MuPairProduction fMuMinusPairProduction;
G4MuIonisation fMuMinusIonisation;
G4MuonMinusCaptureAtRest fMuMinusCaptureAtRest;
// Tau physics
G4MultipleScattering fTauPlusMultipleScattering;
G4hIonisation fTauPlusIonisation;
G4MultipleScattering fTauMinusMultipleScattering;
G4hIonisation fTauMinusIonisation;
G4bool wasActivated;
};
// 2002 by J.P. Wellisch
#endif
@@ -0,0 +1,60 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
#ifndef ParticleCodeMap_hh
#define ParticleCodeMap_hh
#include "G4Proton.hh"
#include "G4AntiProton.hh"
#include "G4PionPlus.hh"
#include "G4PionMinus.hh"
#include "G4KaonPlus.hh"
#include "G4KaonMinus.hh"
#include "G4SigmaMinus.hh"
#include "G4AntiSigmaMinus.hh"
#include "G4SigmaPlus.hh"
#include "G4AntiSigmaPlus.hh"
#include "G4XiMinus.hh"
#include "G4AntiXiMinus.hh"
#include "G4OmegaMinus.hh"
#include "G4AntiOmegaMinus.hh"
template <class T> struct ParticleCodeMap;
template<> struct ParticleCodeMap<G4PionPlus> { enum {PDG_CODE = 211}; };
template<> struct ParticleCodeMap<G4PionMinus> { enum {PDG_CODE = -211}; };
template<> struct ParticleCodeMap<G4KaonPlus> { enum {PDG_CODE = 321}; };
template<> struct ParticleCodeMap<G4KaonMinus> { enum {PDG_CODE = -321}; };
template<> struct ParticleCodeMap<G4Proton> { enum {PDG_CODE = 2212}; };
template<> struct ParticleCodeMap<G4AntiProton> { enum {PDG_CODE = -2212}; };
template<> struct ParticleCodeMap<G4SigmaMinus> { enum {PDG_CODE = 3112}; };
template<> struct ParticleCodeMap<G4AntiSigmaMinus>{ enum {PDG_CODE = -3112}; };
template<> struct ParticleCodeMap<G4SigmaPlus> { enum {PDG_CODE = 3222}; };
template<> struct ParticleCodeMap<G4AntiSigmaPlus> { enum {PDG_CODE = -3222}; };
template<> struct ParticleCodeMap<G4XiMinus> { enum {PDG_CODE = 3312}; };
template<> struct ParticleCodeMap<G4AntiXiMinus> { enum {PDG_CODE = -3312}; };
template<> struct ParticleCodeMap<G4OmegaMinus> { enum {PDG_CODE = 3334}; };
template<> struct ParticleCodeMap<G4AntiOmegaMinus>{ enum {PDG_CODE = -3334}; };
#endif
@@ -0,0 +1,69 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
#ifndef PortingDisclaimer_h
#define PortingDisclaimer_h
class PortingDisclaimer
{
protected:
PortingDisclaimer()
{
G4Exception("PortingDisclaimer", "007", FatalException,
"The disclaimer is not to be instanciated" );
}
private:
struct LocalDisclaimer
{
LocalDisclaimer()
{
G4cout << G4endl;
G4cout << "========================== porting disclaimer =================================="<<G4endl;
G4cout << "You are using a technical port of the physics lists provided"<<G4endl
<< "for hadronic use-cases, as validated for geant4 5.2, with a "<<G4endl
<< "later version of geant4."<<G4endl
<< "These physics lists are made available with that geant4 districution, so users"<<G4endl
<< "wishing to use the latest-greatest geant4 code keep having a starting point"<<G4endl
<< "for their work with hadronics."<<G4endl<<G4endl
<< "Please note that it is a purely technical port, without physics validation performed. "<<G4endl
<< "Hence these physics lists do not yet come with the usual guarantees attached as to "<<G4endl
<< "their physics performance."<< G4endl
<< "For validated 'educated guess' physics lists for hadronic usecases, "<<G4endl
<< "as well as updates, please see the related WWW pages."<< G4endl << G4endl
<< "For information as to which physics list is optimized for your study,"<<G4endl
<< "please also consult the GHAD WWW pages."<<G4endl
<< "Geant4 hadronics is a component system, and here the physics lists main "<<G4endl
<< "task is to configure these components in a suitable way for a concrete useage."<<G4endl
<< "Not all physics lists are suitable for all usecases."<<G4endl;
G4cout << "========================== porting disclaimer =================================="<<G4endl;
G4cout << G4endl;
}
};
public:
static LocalDisclaimer * PrintLocalDisclaimer()
{
static LocalDisclaimer aD;
return &aD;
}
};
#endif
@@ -0,0 +1,50 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
#ifndef TheoModelFactory_hh
#define TheoModelFactory_hh
template<class C, class S, class F>
class TheoModelFactory
{
public:
static G4TheoFSGenerator * New()
{
G4TheoFSGenerator * result = new G4TheoFSGenerator;
G4VIntraNuclearTransportModel * theCascade = new C;
result->SetTransport(theCascade);
G4VLongitudinalStringDecay * theFragmentation = new F;
G4ExcitedStringDecay * theStringDecay = new G4ExcitedStringDecay(theFragmentation);
G4VPartonStringModel * theStringModel = new S;
theStringModel->SetFragmentationModel(theStringDecay);
result->SetHighEnergyGenerator(theStringModel);
return result;
}
private:
};
// 2002 by J.P. Wellisch
#endif
@@ -0,0 +1,54 @@
class PNullType
{
};
template <class T0,
class T1=PNullType, class T2=PNullType, class T3=PNullType, class T4=PNullType, class T5=PNullType,
class T6=PNullType, class T7=PNullType, class T8=PNullType, class T9=PNullType, class T10=PNullType,
class T11=PNullType, class T12=PNullType, class T13=PNullType, class T14=PNullType, class T15=PNullType,
class T16=PNullType, class T17=PNullType, class T18=PNullType, class T19=PNullType, class T20=PNullType,
class T21=PNullType, class T22=PNullType, class T23=PNullType, class T24=PNullType, class T25=PNullType,
class T26=PNullType, class T27=PNullType, class T28=PNullType, class T29=PNullType, class T30=PNullType,
class T31=PNullType, class T32=PNullType, class T33=PNullType, class T34=PNullType, class T35=PNullType,
class T36=PNullType, class T37=PNullType, class T38=PNullType, class T39=PNullType, class T40=PNullType,
class T41=PNullType, class T42=PNullType, class T43=PNullType, class T44=PNullType, class T45=PNullType,
class T46=PNullType, class T47=PNullType, class T48=PNullType, class T49=PNullType, class T50=PNullType,
class T51=PNullType, class T52=PNullType, class T53=PNullType, class T54=PNullType, class T55=PNullType,
class T56=PNullType, class T57=PNullType, class T58=PNullType, class T59=PNullType, class T60=PNullType,
class T61=PNullType, class T62=PNullType, class T63=PNullType
>
struct Plist
{
typedef T0 first;
typedef Plist<
T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,
T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,
T21,T22,T23,T24,T25,T26,T27,T28,T29,T30,
T31,T32,T33,T34,T35,T36,T37,T38,T39,T40,
T41,T42,T43,T44,T45,T46,T47,T48,T49,T50,
T51,T52,T53,T54,T55,T56,T57,T58,T59,T60,
T61,T62,T63
> rest;
};
template <class functor>
struct Apply
{
template <class current, class Rest> struct CallBack {
static void Call_Back() {
typedef typename functor::Fun<current> it;
it aF; aF();
typedef typename Rest::first first;
typedef typename Rest::rest second;
Apply::CallBack<first, second>::Call_Back();
}
};
template <class Rest> struct CallBack<PNullType, Rest > {
static void Call_Back(){}
};
template <class group> static void ForEachIn() {
CallBack<typename group::first, typename group::rest>::Call_Back();
}
};
@@ -0,0 +1,60 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
#include "EMPhysics.hh"
#include "globals.hh"
#include "G4ios.hh"
#include "G4ProcessManager.hh"
#include "G4ParticleDefinition.hh"
#include "G4ParticleTable.hh"
#include "G4Gamma.hh"
#include "G4Electron.hh"
#include "G4Positron.hh"
#include "G4NeutrinoE.hh"
#include "G4AntiNeutrinoE.hh"
EMPhysics::
EMPhysics(const G4String& name) : G4VPhysicsConstructor(name) {}
EMPhysics::
~EMPhysics() {}
void EMPhysics::
ConstructParticle()
{
G4Gamma::GammaDefinition();
G4Electron::ElectronDefinition();
G4Positron::PositronDefinition();
G4NeutrinoE::NeutrinoEDefinition();
G4AntiNeutrinoE::AntiNeutrinoEDefinition();
}
void EMPhysics::
ConstructProcess()
{
theEMPhysics.Build();
}
// 2002 by J.P. Wellisch
@@ -0,0 +1,63 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
#include "EM_GNPhysics.hh"
#include "globals.hh"
#include "G4ios.hh"
#include "G4ProcessManager.hh"
#include "G4ParticleDefinition.hh"
#include "G4ParticleTable.hh"
#include "G4Gamma.hh"
#include "G4Electron.hh"
#include "G4Positron.hh"
#include "G4NeutrinoE.hh"
#include "G4AntiNeutrinoE.hh"
EM_GNPhysics::
EM_GNPhysics(const G4String& name) : G4VPhysicsConstructor(name) {}
EM_GNPhysics::
~EM_GNPhysics() {}
void EM_GNPhysics::
ConstructParticle()
{
G4Gamma::GammaDefinition();
G4Electron::ElectronDefinition();
G4Positron::PositronDefinition();
G4NeutrinoE::NeutrinoEDefinition();
G4AntiNeutrinoE::AntiNeutrinoEDefinition();
}
void EM_GNPhysics::
ConstructProcess()
{
theEMPhysics.Build();
#ifndef NO_ELECTRO_AND_GAMMA_NUCLEAR
theGNPhysics.Build();
#endif
}
// 2002 by J.P. Wellisch
@@ -0,0 +1,63 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
#include "G4BertiniNeutronBuilder.hh"
#include "G4ParticleDefinition.hh"
#include "G4ParticleTable.hh"
#include "G4ProcessManager.hh"
G4BertiniNeutronBuilder::
G4BertiniNeutronBuilder()
{
theMin = 0;
theMax = 9.9*GeV;
theModel = new G4CascadeInterface;
}
void G4BertiniNeutronBuilder::
Build(G4NeutronInelasticProcess & aP)
{
theModel->SetMinEnergy(theMin);
theModel->SetMaxEnergy(theMax);
aP.RegisterMe(theModel);
aP.AddDataSet(&theXSec);
}
G4BertiniNeutronBuilder::
~G4BertiniNeutronBuilder() {}
void G4BertiniNeutronBuilder::
Build(G4HadronElasticProcess & )
{
}
void G4BertiniNeutronBuilder::
Build(G4HadronFissionProcess & )
{
}
void G4BertiniNeutronBuilder::
Build(G4HadronCaptureProcess & )
{
}
// 2002 by J.P. Wellisch
@@ -0,0 +1,81 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
#include "G4BertiniPiKBuilder.hh"
#include "G4ParticleDefinition.hh"
#include "G4ParticleTable.hh"
#include "G4ProcessManager.hh"
G4BertiniPiKBuilder::
G4BertiniPiKBuilder()
{
theMin = 0*GeV;
theMax = 9.9*GeV;
theModel = new G4CascadeInterface;
theModel->SetMinEnergy(theMin);
theModel->SetMaxEnergy(theMax);
}
G4BertiniPiKBuilder::
~G4BertiniPiKBuilder() {}
void G4BertiniPiKBuilder::
Build(G4PionPlusInelasticProcess & aP)
{
aP.RegisterMe(theModel);
theModel->SetMinEnergy(theMin);
theModel->SetMaxEnergy(theMax);
}
void G4BertiniPiKBuilder::
Build(G4PionMinusInelasticProcess & aP)
{
aP.RegisterMe(theModel);
aP.AddDataSet(&thePiData);
theModel->SetMinEnergy(theMin);
theModel->SetMaxEnergy(theMax);
}
void G4BertiniPiKBuilder::
Build(G4HadronElasticProcess & ) {}
void G4BertiniPiKBuilder::
Build(G4KaonPlusInelasticProcess & )
{
}
void G4BertiniPiKBuilder::
Build(G4KaonMinusInelasticProcess & )
{
}
void G4BertiniPiKBuilder::
Build(G4KaonZeroLInelasticProcess & )
{
}
void G4BertiniPiKBuilder::
Build(G4KaonZeroSInelasticProcess & )
{
}
// 2002 by J.P. Wellisch
@@ -0,0 +1,53 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
#include "G4BertiniProtonBuilder.hh"
#include "G4ParticleDefinition.hh"
#include "G4ParticleTable.hh"
#include "G4ProcessManager.hh"
G4BertiniProtonBuilder::
G4BertiniProtonBuilder()
{
theMin = 0;
theMax=9.9*GeV;
theModel = new G4CascadeInterface;
}
G4BertiniProtonBuilder::
~G4BertiniProtonBuilder() {}
void G4BertiniProtonBuilder::
Build(G4HadronElasticProcess & )
{
}
void G4BertiniProtonBuilder::
Build(G4ProtonInelasticProcess & aP)
{
theModel->SetMinEnergy(theMin);
theModel->SetMaxEnergy(theMax);
aP.RegisterMe(theModel);
aP.AddDataSet(&theXSec);
}
// 2002 by J.P. Wellisch
@@ -0,0 +1,63 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
#include "G4BinaryNeutronBuilder.hh"
#include "G4ParticleDefinition.hh"
#include "G4ParticleTable.hh"
#include "G4ProcessManager.hh"
G4BinaryNeutronBuilder::
G4BinaryNeutronBuilder()
{
theMin = 0;
theMax = 9.9*GeV;
theModel = new G4BinaryCascade;
}
void G4BinaryNeutronBuilder::
Build(G4NeutronInelasticProcess & aP)
{
theModel->SetMinEnergy(theMin);
theModel->SetMaxEnergy(theMax);
aP.RegisterMe(theModel);
aP.AddDataSet(&theXSec);
}
G4BinaryNeutronBuilder::
~G4BinaryNeutronBuilder() {}
void G4BinaryNeutronBuilder::
Build(G4HadronElasticProcess & )
{
}
void G4BinaryNeutronBuilder::
Build(G4HadronFissionProcess & )
{
}
void G4BinaryNeutronBuilder::
Build(G4HadronCaptureProcess & )
{
}
// 2002 by J.P. Wellisch
@@ -0,0 +1,82 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
#include "G4BinaryPiKBuilder.hh"
#include "G4ParticleDefinition.hh"
#include "G4ParticleTable.hh"
#include "G4ProcessManager.hh"
G4BinaryPiKBuilder::
G4BinaryPiKBuilder()
{
theMin = 0*GeV;
theMax = 1.3*GeV;
theModel = new G4BinaryCascade;
theModel->SetMinEnergy(theMin);
theModel->SetMaxEnergy(theMax);
}
G4BinaryPiKBuilder::
~G4BinaryPiKBuilder() {}
void G4BinaryPiKBuilder::
Build(G4HadronElasticProcess & ) {}
void G4BinaryPiKBuilder::
Build(G4PionPlusInelasticProcess & aP)
{
theModel->SetMinEnergy(theMin);
theModel->SetMaxEnergy(theMax);
aP.RegisterMe(theModel);
aP.AddDataSet(&thePiData);
}
void G4BinaryPiKBuilder::
Build(G4PionMinusInelasticProcess & aP)
{
theModel->SetMinEnergy(theMin);
theModel->SetMaxEnergy(theMax);
aP.RegisterMe(theModel);
aP.AddDataSet(&thePiData);
}
void G4BinaryPiKBuilder::
Build(G4KaonPlusInelasticProcess & )
{
}
void G4BinaryPiKBuilder::
Build(G4KaonMinusInelasticProcess & )
{
}
void G4BinaryPiKBuilder::
Build(G4KaonZeroLInelasticProcess & )
{
}
void G4BinaryPiKBuilder::
Build(G4KaonZeroSInelasticProcess & )
{
}
// 2002 by J.P. Wellisch
@@ -0,0 +1,53 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
#include "G4BinaryProtonBuilder.hh"
#include "G4ParticleDefinition.hh"
#include "G4ParticleTable.hh"
#include "G4ProcessManager.hh"
G4BinaryProtonBuilder::
G4BinaryProtonBuilder()
{
theModel = new G4BinaryCascade;
theMin = 0;
theMax = 9.9*GeV;
}
void G4BinaryProtonBuilder::
Build(G4ProtonInelasticProcess & aP)
{
aP.AddDataSet(&theXSec);
theModel->SetMinEnergy(theMin);
theModel->SetMaxEnergy(theMax);
aP.RegisterMe(theModel);
}
G4BinaryProtonBuilder::
~G4BinaryProtonBuilder() {}
void G4BinaryProtonBuilder::
Build(G4HadronElasticProcess & )
{
}
// 2002 by J.P. Wellisch
@@ -0,0 +1,157 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
#include "G4EMBuilder.hh"
#include "globals.hh"
#include "G4ios.hh"
#include "G4ParticleDefinition.hh"
#include "G4ParticleTable.hh"
#include "G4Gamma.hh"
#include "G4Electron.hh"
#include "G4Positron.hh"
#include "G4ProcessManager.hh"
G4EMBuilder::
G4EMBuilder(): wasActivated(false), synchOn(false),
gammNucOn(false)
{
theT = new G4EMTailorer(this);
}
void G4EMBuilder::
Synch (G4String & newState)
{
if(newState == "on")
{
if(synchOn)
{
}
else if(wasActivated)
{
G4ProcessManager * pManager = 0;
pManager = G4Electron::ElectronDefinition()->GetProcessManager();
pManager->AddDiscreteProcess(&theElectronSynch);
pManager = G4Positron::PositronDefinition()->GetProcessManager();
pManager->AddDiscreteProcess(&thePositronSynch);
}
synchOn = true;
}
else if(synchOn)
{
synchOn = false;
G4ProcessManager * pManager = 0;
pManager = G4Electron::ElectronDefinition()->GetProcessManager();
pManager->RemoveProcess(&theElectronSynch);
pManager = G4Positron::PositronDefinition()->GetProcessManager();
pManager->RemoveProcess(&thePositronSynch);
}
}
void G4EMBuilder::
GammaNuclear (G4String & newState)
{
if(newState == "on")
{
if(gammNucOn)
{
}
else if(wasActivated)
{
theGNPhysics.Build();
}
gammNucOn = true;
}
else if(gammNucOn)
{
G4Exception("G4EMBuilder", "007", FatalException,
"Switching off of gamma nuclear currently not supported.");
}
}
G4EMBuilder::
~G4EMBuilder()
{
if(wasActivated)
{
G4ProcessManager * pManager = 0;
pManager = G4Gamma::Gamma()->GetProcessManager();
if(pManager)
{
pManager->RemoveProcess(&thePhotoEffect);
pManager->RemoveProcess(&theComptonEffect);
pManager->RemoveProcess(&thePairProduction);
}
pManager = G4Electron::Electron()->GetProcessManager();
if(pManager)
{
pManager->RemoveProcess(&theElectronBremsStrahlung);
pManager->RemoveProcess(&theElectronIonisation);
pManager->RemoveProcess(&theElectronMultipleScattering);
if(synchOn) pManager->RemoveProcess(&theElectronSynch);
}
pManager = G4Positron::Positron()->GetProcessManager();
if(pManager)
{
pManager->RemoveProcess(&thePositronBremsStrahlung);
pManager->RemoveProcess(&theAnnihilation);
pManager->RemoveProcess(&thePositronIonisation);
pManager->RemoveProcess(&thePositronMultipleScattering);
if(synchOn) pManager->RemoveProcess(&thePositronSynch);
}
}
}
void G4EMBuilder::Build()
{
G4ProcessManager * pManager = 0;
wasActivated = true;
pManager = G4Gamma::Gamma()->GetProcessManager();
pManager->AddDiscreteProcess(&thePhotoEffect);
pManager->AddDiscreteProcess(&theComptonEffect);
pManager->AddDiscreteProcess(&thePairProduction);
pManager = G4Electron::Electron()->GetProcessManager();
pManager->AddDiscreteProcess(&theElectronBremsStrahlung);
pManager->AddProcess(&theElectronIonisation, ordInActive,2, 2);
pManager->AddProcess(&theElectronMultipleScattering);
if(synchOn) pManager->AddDiscreteProcess(&theElectronSynch);
pManager->SetProcessOrdering(&theElectronMultipleScattering, idxAlongStep, 1);
pManager->SetProcessOrdering(&theElectronMultipleScattering, idxPostStep, 1);
pManager = G4Positron::Positron()->GetProcessManager();
pManager->AddDiscreteProcess(&thePositronBremsStrahlung);
pManager->AddDiscreteProcess(&theAnnihilation);
pManager->AddRestProcess(&theAnnihilation);
pManager->AddProcess(&thePositronIonisation, ordInActive,2, 2);
pManager->AddProcess(&thePositronMultipleScattering);
if(synchOn) pManager->AddDiscreteProcess(&thePositronSynch);
pManager->SetProcessOrdering(&thePositronMultipleScattering, idxAlongStep, 1);
pManager->SetProcessOrdering(&thePositronMultipleScattering, idxPostStep, 1);
if (gammNucOn) theGNPhysics.Build();
}
// 2002 by J.P. Wellisch
@@ -0,0 +1,64 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
#include "G4EMTailorer.hh"
#include "G4EMBuilder.hh"
void G4EMTailorer::SetNewValue(G4UIcommand* aComm, G4String aS)
{
if(aComm==theSynch)
{
theB->Synch(aS);
}
if(aComm==theGN)
{
theB->GammaNuclear(aS);
}
}
G4EMTailorer::G4EMTailorer(G4EMBuilder * ab)
{
theB = ab;
aDir1 = new G4UIdirectory("/physics_engine/");
aDir1->SetGuidance("commands related to the physics simulation engine.");
// general stuff.
aDir2 = new G4UIdirectory("/physics_engine/tailor/");
aDir2->SetGuidance("tailoring the processes");
// command for synchrotron radiation.
theSynch = new G4UIcmdWithAString("/physics_engine/tailor/SyncRadiation",this);
theSynch->SetGuidance("Switching on/off synchrotron radiation.");
theSynch->SetParameterName("status","off");
theSynch->SetCandidates("on off");
theSynch->SetDefaultValue("off");
theSynch->AvailableForStates(G4State_PreInit);
// command for gamma nuclear physics.
theGN = new G4UIcmdWithAString("/physics_engine/tailor/GammaNuclear",this);
theGN->SetGuidance("Switching on gamma nuclear physics.");
theGN->SetParameterName("status","off");
theGN->SetCandidates("on off");
theGN->SetDefaultValue("off");
theGN->AvailableForStates(G4State_PreInit);
}
@@ -0,0 +1,89 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
#include "G4ElectroNuclearBuilder.hh"
#include "globals.hh"
#include "G4ios.hh"
#include "G4ParticleDefinition.hh"
#include "G4ParticleTable.hh"
#include "G4Gamma.hh"
#include "G4Electron.hh"
#include "G4Positron.hh"
#include "G4ProcessManager.hh"
G4ElectroNuclearBuilder::G4ElectroNuclearBuilder() : wasActivated(false)
{
theElectroReaction = new G4ElectroNuclearReaction;
theGammaReaction = new G4GammaNuclearReaction;
theModel = new G4TheoFSGenerator;
theCascade = new G4GeneratorPrecompoundInterface;
theModel->SetTransport(theCascade);
theModel->SetHighEnergyGenerator(&theStringModel);
theStringDecay = new G4ExcitedStringDecay(&theFragmentation);
theStringModel.SetFragmentationModel(theStringDecay);
}
G4ElectroNuclearBuilder::~G4ElectroNuclearBuilder()
{
delete theStringDecay;
delete theElectroReaction;
delete theGammaReaction;
delete theModel;
delete theCascade;
if(wasActivated)
{
G4ProcessManager * pManager = 0;
pManager = G4Gamma::Gamma()->GetProcessManager();
if(pManager) pManager->RemoveProcess(&thePhotoNuclearProcess);
pManager = G4Electron::Electron()->GetProcessManager();
if(pManager) pManager->RemoveProcess(&theElectronNuclearProcess);
pManager = G4Positron::Positron()->GetProcessManager();
if(pManager) pManager->RemoveProcess(&thePositronNuclearProcess);
}
}
void G4ElectroNuclearBuilder::Build()
{
G4ProcessManager * aProcMan = 0;
aProcMan = G4Gamma::Gamma()->GetProcessManager();
theGammaReaction->SetMaxEnergy(3.5*GeV);
thePhotoNuclearProcess.RegisterMe(theGammaReaction);
theModel->SetMinEnergy(3.*GeV);
theModel->SetMaxEnergy(100*TeV);
thePhotoNuclearProcess.RegisterMe(theModel);
aProcMan->AddDiscreteProcess(&thePhotoNuclearProcess);
aProcMan = G4Electron::Electron()->GetProcessManager();
theElectronNuclearProcess.RegisterMe(theElectroReaction);
aProcMan->AddDiscreteProcess(&theElectronNuclearProcess);
aProcMan = G4Positron::Positron()->GetProcessManager();
thePositronNuclearProcess.RegisterMe(theElectroReaction);
aProcMan->AddDiscreteProcess(&thePositronNuclearProcess);
}
// 2002 by J.P. Wellisch
@@ -0,0 +1,71 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
#include "G4FTFCNeutronBuilder.hh"
#include "G4ParticleDefinition.hh"
#include "G4ParticleTable.hh"
#include "G4ProcessManager.hh"
G4FTFCNeutronBuilder::
G4FTFCNeutronBuilder()
{
theMin = 15*GeV;
theModel = new G4TheoFSGenerator;
theCascade = new G4StringChipsParticleLevelInterface;
theModel->SetTransport(theCascade);
theModel->SetHighEnergyGenerator(&theStringModel);
theStringDecay = new G4ExcitedStringDecay(&theFragmentation);
theStringModel.SetFragmentationModel(theStringDecay);
}
G4FTFCNeutronBuilder::
~G4FTFCNeutronBuilder()
{
delete theStringDecay;
}
void G4FTFCNeutronBuilder::
Build(G4HadronElasticProcess & )
{
}
void G4FTFCNeutronBuilder::
Build(G4HadronFissionProcess & )
{
}
void G4FTFCNeutronBuilder::
Build(G4HadronCaptureProcess & )
{
}
void G4FTFCNeutronBuilder::
Build(G4NeutronInelasticProcess & aP)
{
aP.AddDataSet(&theXSec);
theModel->SetMinEnergy(theMin);
theModel->SetMaxEnergy(100*TeV);
aP.RegisterMe(theModel);
}
// 2002 by J.P. Wellisch
@@ -0,0 +1,99 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
#include "G4FTFCPiKBuilder.hh"
#include "G4ParticleDefinition.hh"
#include "G4ParticleTable.hh"
#include "G4ProcessManager.hh"
G4FTFCPiKBuilder::
G4FTFCPiKBuilder()
{
theMin = 15*GeV;
theModel = new G4TheoFSGenerator;
theCascade = new G4StringChipsParticleLevelInterface;
theStringDecay = new G4ExcitedStringDecay(&theFragmentation);
theModel->SetTransport(theCascade);
theModel->SetHighEnergyGenerator(&theStringModel);
theStringModel.SetFragmentationModel(theStringDecay);
}
G4FTFCPiKBuilder::
~G4FTFCPiKBuilder()
{
delete theStringDecay;
}
void G4FTFCPiKBuilder::
Build(G4HadronElasticProcess & ) {}
void G4FTFCPiKBuilder::
Build(G4PionPlusInelasticProcess & aP)
{
aP.AddDataSet(&thePiData);
theModel->SetMinEnergy(theMin);
theModel->SetMaxEnergy(100*TeV);
aP.RegisterMe(theModel);
}
void G4FTFCPiKBuilder::
Build(G4PionMinusInelasticProcess & aP)
{
aP.AddDataSet(&thePiData);
theModel->SetMinEnergy(theMin);
theModel->SetMaxEnergy(100*TeV);
aP.RegisterMe(theModel);
}
void G4FTFCPiKBuilder::
Build(G4KaonPlusInelasticProcess & aP)
{
theModel->SetMinEnergy(theMin);
theModel->SetMaxEnergy(100*TeV);
aP.RegisterMe(theModel);
}
void G4FTFCPiKBuilder::
Build(G4KaonMinusInelasticProcess & aP)
{
theModel->SetMinEnergy(theMin);
theModel->SetMaxEnergy(100*TeV);
aP.RegisterMe(theModel);
}
void G4FTFCPiKBuilder::
Build(G4KaonZeroLInelasticProcess & aP)
{
theModel->SetMinEnergy(theMin);
theModel->SetMaxEnergy(100*TeV);
aP.RegisterMe(theModel);
}
void G4FTFCPiKBuilder::
Build(G4KaonZeroSInelasticProcess & aP)
{
theModel->SetMinEnergy(theMin);
theModel->SetMaxEnergy(100*TeV);
aP.RegisterMe(theModel);
}
// 2002 by J.P. Wellisch
@@ -0,0 +1,46 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
#include "G4FTFCProtonBuilder.hh"
#include "G4ParticleDefinition.hh"
#include "G4ParticleTable.hh"
#include "G4ProcessManager.hh"
#include "TheoModelFactory.hh"
G4FTFCProtonBuilder::
G4FTFCProtonBuilder()
{
theMin = 15*GeV;
theModel = TheoModelFactory<G4StringChipsParticleLevelInterface,
G4FTFModel, G4LundStringFragmentation>::New();
}
void G4FTFCProtonBuilder::
Build(G4ProtonInelasticProcess & aP)
{
theModel->SetMinEnergy(theMin);
theModel->SetMaxEnergy(100*TeV);
aP.RegisterMe(theModel);
aP.AddDataSet(&theXSec);
}
// 2002 by J.P. Wellisch
@@ -0,0 +1,72 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
#include "G4FTFPNeutronBuilder.hh"
#include "G4ParticleDefinition.hh"
#include "G4ParticleTable.hh"
#include "G4ProcessManager.hh"
G4FTFPNeutronBuilder::
G4FTFPNeutronBuilder()
{
theMin = 15*GeV;
theModel = new G4TheoFSGenerator;
theCascade = new G4GeneratorPrecompoundInterface;
thePreEquilib = new G4PreCompoundModel(&theHandler);
theCascade->SetDeExcitation(thePreEquilib);
theModel->SetTransport(theCascade);
theModel->SetHighEnergyGenerator(&theStringModel);
theStringDecay = new G4ExcitedStringDecay(&theFragmentation);
theStringModel.SetFragmentationModel(theStringDecay);
}
G4FTFPNeutronBuilder::
~G4FTFPNeutronBuilder()
{
delete theStringDecay;
}
void G4FTFPNeutronBuilder::
Build(G4HadronElasticProcess & )
{
}
void G4FTFPNeutronBuilder::
Build(G4HadronFissionProcess & )
{
}
void G4FTFPNeutronBuilder::
Build(G4HadronCaptureProcess & )
{
}
void G4FTFPNeutronBuilder::
Build(G4NeutronInelasticProcess & aP)
{
theModel->SetMinEnergy(theMin);
theModel->SetMaxEnergy(100*TeV);
aP.RegisterMe(theModel);
aP.AddDataSet(&theXSec);
}
// 2002 by J.P. Wellisch
@@ -0,0 +1,101 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
#include "G4FTFPPiKBuilder.hh"
#include "G4ParticleDefinition.hh"
#include "G4ParticleTable.hh"
#include "G4ProcessManager.hh"
G4FTFPPiKBuilder::
G4FTFPPiKBuilder()
{
theMin = 15*GeV;
theModel = new G4TheoFSGenerator;
theCascade = new G4GeneratorPrecompoundInterface;
thePreEquilib = new G4PreCompoundModel(&theHandler);
theCascade->SetDeExcitation(thePreEquilib);
theModel->SetTransport(theCascade);
theModel->SetHighEnergyGenerator(&theStringModel);
theStringDecay = new G4ExcitedStringDecay(&theFragmentation);
theStringModel.SetFragmentationModel(theStringDecay);
}
G4FTFPPiKBuilder::
~G4FTFPPiKBuilder()
{
delete theStringDecay;
}
void G4FTFPPiKBuilder::
Build(G4HadronElasticProcess & ) {}
void G4FTFPPiKBuilder::
Build(G4PionPlusInelasticProcess & aP)
{
theModel->SetMinEnergy(theMin);
theModel->SetMaxEnergy(100*TeV);
aP.AddDataSet(&thePiData);
aP.RegisterMe(theModel);
}
void G4FTFPPiKBuilder::
Build(G4PionMinusInelasticProcess & aP)
{
theModel->SetMinEnergy(theMin);
theModel->SetMaxEnergy(100*TeV);
aP.AddDataSet(&thePiData);
aP.RegisterMe(theModel);
}
void G4FTFPPiKBuilder::
Build(G4KaonPlusInelasticProcess & aP)
{
theModel->SetMinEnergy(theMin);
theModel->SetMaxEnergy(100*TeV);
aP.RegisterMe(theModel);
}
void G4FTFPPiKBuilder::
Build(G4KaonMinusInelasticProcess & aP)
{
theModel->SetMinEnergy(theMin);
theModel->SetMaxEnergy(100*TeV);
aP.RegisterMe(theModel);
}
void G4FTFPPiKBuilder::
Build(G4KaonZeroLInelasticProcess & aP)
{
theModel->SetMinEnergy(theMin);
theModel->SetMaxEnergy(100*TeV);
aP.RegisterMe(theModel);
}
void G4FTFPPiKBuilder::
Build(G4KaonZeroSInelasticProcess & aP)
{
theModel->SetMinEnergy(theMin);
theModel->SetMaxEnergy(100*TeV);
aP.RegisterMe(theModel);
}
// 2002 by J.P. Wellisch
@@ -0,0 +1,62 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
#include "G4FTFPProtonBuilder.hh"
#include "G4ParticleDefinition.hh"
#include "G4ParticleTable.hh"
#include "G4ProcessManager.hh"
G4FTFPProtonBuilder::
G4FTFPProtonBuilder()
{
theMin = 15*GeV;
theModel = new G4TheoFSGenerator;
theCascade = new G4GeneratorPrecompoundInterface;
thePreEquilib = new G4PreCompoundModel(&theHandler);
theCascade->SetDeExcitation(thePreEquilib);
theModel->SetTransport(theCascade);
theModel->SetHighEnergyGenerator(&theStringModel);
theStringDecay = new G4ExcitedStringDecay(&theFragmentation);
theStringModel.SetFragmentationModel(theStringDecay);
}
void G4FTFPProtonBuilder::
Build(G4ProtonInelasticProcess & aP)
{
theModel->SetMinEnergy(theMin);
theModel->SetMaxEnergy(100*TeV);
aP.RegisterMe(theModel);
aP.AddDataSet(&theXSec);
}
G4FTFPProtonBuilder::
~G4FTFPProtonBuilder()
{
delete theStringDecay;
}
void G4FTFPProtonBuilder::
Build(G4HadronElasticProcess & )
{
}
// 2002 by J.P. Wellisch
@@ -0,0 +1,33 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
#include "G4HadronQEDBuilder.hh"
#include "G4ParticleTable.hh"
G4HadronQEDBuilder::G4HadronQEDBuilder(): wasActivated(false) {}
G4HadronQEDBuilder::~G4HadronQEDBuilder()
{ if(wasActivated) std::for_each(theCache().begin(), theCache().end(), Clear()); }
void G4HadronQEDBuilder::Build() { wasActivated = true; Apply<Register>::ForEachIn<theParticles>(); }
// 2002 by J.P. Wellisch
@@ -0,0 +1,55 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
#include "G4LEADNeutronBuilder.hh"
#include "G4ParticleDefinition.hh"
#include "G4ParticleTable.hh"
#include "G4ProcessManager.hh"
G4LEADNeutronBuilder::
G4LEADNeutronBuilder()
{
theMin = 0;
theModel = new G4Mars5GeV;
}
G4LEADNeutronBuilder::
~G4LEADNeutronBuilder() {}
void G4LEADNeutronBuilder::
Build(G4NeutronInelasticProcess & aP)
{
aP.AddDataSet(&theXSec);
theModel->SetMinEnergy(theMin);
aP.RegisterMe(theModel);
}
void G4LEADNeutronBuilder::
Build(G4HadronElasticProcess & ){}
void G4LEADNeutronBuilder::
Build(G4HadronFissionProcess & ){}
void G4LEADNeutronBuilder::
Build(G4HadronCaptureProcess & ){}
// 2002 by J.P. Wellisch
@@ -0,0 +1,85 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
#include "G4LEADPiKBuilder.hh"
#include "G4ParticleDefinition.hh"
#include "G4ParticleTable.hh"
#include "G4ProcessManager.hh"
G4LEADPiKBuilder::
G4LEADPiKBuilder()
{
theMin = 0;
theModel = new G4Mars5GeV;
}
G4LEADPiKBuilder::
~G4LEADPiKBuilder() {}
void G4LEADPiKBuilder::
Build(G4HadronElasticProcess & ) {}
void G4LEADPiKBuilder::
Build(G4PionPlusInelasticProcess & aP)
{
aP.RegisterMe(theModel);
aP.AddDataSet(&thePiData);
theModel->SetMinEnergy(theMin);
}
void G4LEADPiKBuilder::
Build(G4PionMinusInelasticProcess & aP)
{
aP.RegisterMe(theModel);
aP.AddDataSet(&thePiData);
theModel->SetMinEnergy(theMin);
}
void G4LEADPiKBuilder::
Build(G4KaonPlusInelasticProcess & aP)
{
aP.RegisterMe(theModel);
theModel->SetMinEnergy(theMin);
}
void G4LEADPiKBuilder::
Build(G4KaonMinusInelasticProcess & aP)
{
aP.RegisterMe(theModel);
theModel->SetMinEnergy(theMin);
}
void G4LEADPiKBuilder::
Build(G4KaonZeroLInelasticProcess & aP)
{
aP.RegisterMe(theModel);
theModel->SetMinEnergy(theMin);
}
void G4LEADPiKBuilder::
Build(G4KaonZeroSInelasticProcess & aP)
{
aP.RegisterMe(theModel);
theModel->SetMinEnergy(theMin);
}
// 2002 by J.P. Wellisch
@@ -0,0 +1,51 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
#include "G4LEADProtonBuilder.hh"
#include "G4ParticleDefinition.hh"
#include "G4ParticleTable.hh"
#include "G4ProcessManager.hh"
G4LEADProtonBuilder::
G4LEADProtonBuilder()
{
theMin = 0;
theModel = new G4Mars5GeV;
}
G4LEADProtonBuilder::
~G4LEADProtonBuilder() {}
void G4LEADProtonBuilder::
Build(G4HadronElasticProcess & )
{
}
void G4LEADProtonBuilder::
Build(G4ProtonInelasticProcess & aP)
{
theModel->SetMinEnergy(theMin);
aP.RegisterMe(theModel);
aP.AddDataSet(&theXSec);
}
// 2002 by J.P. Wellisch
@@ -0,0 +1,76 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
#include "G4LEPNeutronBuilder.hh"
#include "G4ParticleDefinition.hh"
#include "G4ParticleTable.hh"
#include "G4ProcessManager.hh"
G4LEPNeutronBuilder::
G4LEPNeutronBuilder()
{
theMin = 0;
theIMin = theMin;
theMax = 20*TeV;
theIMax = 55*GeV;
}
G4LEPNeutronBuilder::
~G4LEPNeutronBuilder() {}
void G4LEPNeutronBuilder::
Build(G4HadronElasticProcess & aP)
{
theElasticModel = new G4LElastic();
theElasticModel->SetMinEnergy(theMin);
theElasticModel->SetMaxEnergy(theMax);
aP.RegisterMe(theElasticModel);
}
void G4LEPNeutronBuilder::
Build(G4HadronFissionProcess & aP)
{
theNeutronFissionModel = new G4LFission();
theNeutronFissionModel->SetMinEnergy(theMin);
theNeutronFissionModel->SetMaxEnergy(theMax);
aP.RegisterMe(theNeutronFissionModel);
}
void G4LEPNeutronBuilder::
Build(G4HadronCaptureProcess & aP)
{
theNeutronCaptureModel = new G4LCapture();
theNeutronCaptureModel->SetMinEnergy(theMin);
theNeutronCaptureModel->SetMaxEnergy(theMax);
aP.RegisterMe(theNeutronCaptureModel);
}
void G4LEPNeutronBuilder::
Build(G4NeutronInelasticProcess & aP)
{
theLENeutronModel = new G4LENeutronInelastic();
theLENeutronModel->SetMinEnergy(theIMin);
theLENeutronModel->SetMaxEnergy(theIMax);
aP.RegisterMe(theLENeutronModel);
}
// 2002 by J.P. Wellisch
@@ -0,0 +1,105 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
#include "G4LEPPiKBuilder.hh"
#include "globals.hh"
#include "G4ios.hh"
#include "G4ParticleDefinition.hh"
#include "G4ParticleTable.hh"
#include "G4MesonConstructor.hh"
#include "G4BaryonConstructor.hh"
#include "G4ProcessManager.hh"
G4LEPPiKBuilder::
G4LEPPiKBuilder()
{
theElasticModel = new G4LElastic();
theMin = 0;
theMax = 55*GeV;
theMinPion = theMin;
}
G4LEPPiKBuilder::
~G4LEPPiKBuilder() {}
void G4LEPPiKBuilder::
Build(G4HadronElasticProcess & aP)
{
aP.RegisterMe(theElasticModel);
}
void G4LEPPiKBuilder::
Build(G4PionPlusInelasticProcess & aP)
{
theLEPionPlusModel = new G4LEPionPlusInelastic();
theLEPionPlusModel->SetMinEnergy(theMinPion);
theLEPionPlusModel->SetMaxEnergy(theMax);
aP.RegisterMe(theLEPionPlusModel);
}
void G4LEPPiKBuilder::
Build(G4PionMinusInelasticProcess & aP)
{
theLEPionMinusModel = new G4LEPionMinusInelastic();
theLEPionMinusModel->SetMinEnergy(theMinPion);
theLEPionMinusModel->SetMaxEnergy(theMax);
aP.RegisterMe(theLEPionMinusModel);
}
void G4LEPPiKBuilder::
Build(G4KaonPlusInelasticProcess & aP)
{
theLEKaonPlusModel = new G4LEKaonPlusInelastic();
theLEKaonPlusModel->SetMinEnergy(theMin);
theLEKaonPlusModel->SetMaxEnergy(theMax);
aP.RegisterMe(theLEKaonPlusModel);
}
void G4LEPPiKBuilder::
Build(G4KaonMinusInelasticProcess & aP)
{
theLEKaonMinusModel = new G4LEKaonMinusInelastic();
theLEKaonMinusModel->SetMaxEnergy(theMax);
theLEKaonMinusModel->SetMinEnergy(theMin);
aP.RegisterMe(theLEKaonMinusModel);
}
void G4LEPPiKBuilder::
Build(G4KaonZeroLInelasticProcess & aP)
{
theLEKaonZeroLModel = new G4LEKaonZeroLInelastic();
theLEKaonZeroLModel->SetMaxEnergy(theMax);
theLEKaonZeroLModel->SetMinEnergy(theMin);
aP.RegisterMe(theLEKaonZeroLModel);
}
void G4LEPPiKBuilder::
Build(G4KaonZeroSInelasticProcess & aP)
{
theLEKaonZeroSModel = new G4LEKaonZeroSInelastic();
theLEKaonZeroSModel->SetMaxEnergy(theMax);
theLEKaonZeroSModel->SetMinEnergy(theMin);
aP.RegisterMe(theLEKaonZeroSModel);
}
// 2002 by J.P. Wellisch
@@ -0,0 +1,54 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
#include "G4LEPProtonBuilder.hh"
#include "G4ParticleDefinition.hh"
#include "G4ParticleTable.hh"
#include "G4ProcessManager.hh"
G4LEPProtonBuilder::
G4LEPProtonBuilder()
{
theMin = 0;
theMax=55*GeV;
}
G4LEPProtonBuilder::
~G4LEPProtonBuilder() {}
void G4LEPProtonBuilder::
Build(G4HadronElasticProcess & aP)
{
theElasticModel = new G4LElastic();
aP.RegisterMe(theElasticModel);
}
void G4LEPProtonBuilder::
Build(G4ProtonInelasticProcess & aP)
{
theLEProtonModel = new G4LEProtonInelastic();
theLEProtonModel->SetMinEnergy(theMin);
theLEProtonModel->SetMaxEnergy(theMax);
aP.RegisterMe(theLEProtonModel);
}
// 2002 by J.P. Wellisch
@@ -0,0 +1,74 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
#include "G4LHEPNeutronBuilder.hh"
#include "G4ParticleDefinition.hh"
#include "G4ParticleTable.hh"
#include "G4ProcessManager.hh"
G4LHEPNeutronBuilder::
G4LHEPNeutronBuilder()
{
theMin = 0;
theIMin = 0;
}
G4LHEPNeutronBuilder::
~G4LHEPNeutronBuilder() {}
void G4LHEPNeutronBuilder::
Build(G4NeutronInelasticProcess & aP)
{
theLENeutronModel = new G4LENeutronInelastic();
theHENeutronModel = new G4HENeutronInelastic();
theLENeutronModel->SetMinEnergy(theIMin);
theLENeutronModel->SetMaxEnergy(55*GeV);
theHENeutronModel->SetMinEnergy(25*GeV);
aP.RegisterMe(theLENeutronModel);
aP.RegisterMe(theHENeutronModel);
}
void G4LHEPNeutronBuilder::
Build(G4HadronFissionProcess & aP)
{
theNeutronFissionModel = new G4LFission();
theNeutronFissionModel->SetMinEnergy(theMin);
aP.RegisterMe(theNeutronFissionModel);
}
void G4LHEPNeutronBuilder::
Build(G4HadronElasticProcess & aP)
{
theElasticModel = new G4LElastic();
theElasticModel->SetMinEnergy(theMin);
aP.RegisterMe(theElasticModel);
}
void G4LHEPNeutronBuilder::
Build(G4HadronCaptureProcess & aP)
{
theNeutronCaptureModel = new G4LCapture();
theNeutronCaptureModel->SetMinEnergy(theMin);
aP.RegisterMe(theNeutronCaptureModel);
}
// 2002 by J.P. Wellisch
@@ -0,0 +1,114 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
#include "G4LHEPPiKBuilder.hh"
#include "globals.hh"
#include "G4ios.hh"
#include "G4ParticleDefinition.hh"
#include "G4ParticleTable.hh"
#include "G4MesonConstructor.hh"
#include "G4BaryonConstructor.hh"
#include "G4ProcessManager.hh"
G4LHEPPiKBuilder::
G4LHEPPiKBuilder()
{
theElasticModel = new G4LElastic();
theM = 0;
theMinPion = theM;
}
G4LHEPPiKBuilder::
~G4LHEPPiKBuilder() {}
void G4LHEPPiKBuilder::
Build(G4HadronElasticProcess & aP)
{
aP.RegisterMe(theElasticModel);
}
void G4LHEPPiKBuilder::
Build(G4PionPlusInelasticProcess & aP)
{
theLEPionPlusModel = new G4LEPionPlusInelastic();
theHEPionPlusModel = new G4HEPionPlusInelastic();
theLEPionPlusModel->SetMinEnergy(theMinPion);
theLEPionPlusModel->SetMaxEnergy(55*GeV);
theHEPionPlusModel->SetMinEnergy(25*GeV);
aP.RegisterMe(theLEPionPlusModel);
aP.RegisterMe(theHEPionPlusModel);
}
void G4LHEPPiKBuilder::
Build(G4PionMinusInelasticProcess & aP)
{
theLEPionMinusModel = new G4LEPionMinusInelastic();
theHEPionMinusModel = new G4HEPionMinusInelastic();
theLEPionMinusModel->SetMinEnergy(theMinPion);
theLEPionMinusModel->SetMaxEnergy(55*GeV);
theHEPionMinusModel->SetMinEnergy(25*GeV);
aP.RegisterMe(theLEPionMinusModel);
aP.RegisterMe(theHEPionMinusModel);
}
void G4LHEPPiKBuilder::
Build(G4KaonPlusInelasticProcess & aP)
{
theLEKaonPlusModel = new G4LEKaonPlusInelastic();
theHEKaonPlusModel = new G4HEKaonPlusInelastic();
theLEKaonPlusModel->SetMinEnergy(theM);
aP.RegisterMe(theLEKaonPlusModel);
aP.RegisterMe(theHEKaonPlusModel);
}
void G4LHEPPiKBuilder::
Build(G4KaonMinusInelasticProcess & aP)
{
theLEKaonMinusModel = new G4LEKaonMinusInelastic();
theHEKaonMinusModel = new G4HEKaonMinusInelastic();
theLEKaonMinusModel->SetMinEnergy(theM);
aP.RegisterMe(theLEKaonMinusModel);
aP.RegisterMe(theHEKaonMinusModel);
}
void G4LHEPPiKBuilder::
Build(G4KaonZeroLInelasticProcess & aP)
{
theLEKaonZeroLModel = new G4LEKaonZeroLInelastic();
theHEKaonZeroLModel = new G4HEKaonZeroInelastic();
theLEKaonZeroLModel->SetMinEnergy(theM);
aP.RegisterMe(theLEKaonZeroLModel);
aP.RegisterMe(theHEKaonZeroLModel);
}
void G4LHEPPiKBuilder::
Build(G4KaonZeroSInelasticProcess & aP)
{
theLEKaonZeroSModel = new G4LEKaonZeroSInelastic();
theHEKaonZeroSModel = new G4HEKaonZeroInelastic();
theLEKaonZeroSModel->SetMinEnergy(theM);
aP.RegisterMe(theLEKaonZeroSModel);
aP.RegisterMe(theHEKaonZeroSModel);
}
// 2002 by J.P. Wellisch
@@ -0,0 +1,56 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
#include "G4LHEPProtonBuilder.hh"
#include "G4ParticleDefinition.hh"
#include "G4ParticleTable.hh"
#include "G4ProcessManager.hh"
G4LHEPProtonBuilder::
G4LHEPProtonBuilder()
{
theMin = 0;
}
G4LHEPProtonBuilder::
~G4LHEPProtonBuilder() {}
void G4LHEPProtonBuilder::
Build(G4HadronElasticProcess & aP)
{
theElasticModel = new G4LElastic();
aP.RegisterMe(theElasticModel);
}
void G4LHEPProtonBuilder::
Build(G4ProtonInelasticProcess & aP)
{
theLEProtonModel = new G4LEProtonInelastic();
theHEProtonModel = new G4HEProtonInelastic();
theLEProtonModel->SetMinEnergy(theMin);
theLEProtonModel->SetMaxEnergy(55*GeV);
theHEProtonModel->SetMinEnergy(25*GeV);
aP.RegisterMe(theLEProtonModel);
aP.RegisterMe(theHEProtonModel);
}
// 2002 by J.P. Wellisch
@@ -0,0 +1,227 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
#include "G4MiscLHEPBuilder.hh"
#include "G4ParticleDefinition.hh"
#include "G4ParticleTable.hh"
#include "G4ProcessManager.hh"
G4MiscLHEPBuilder::G4MiscLHEPBuilder(): wasActivated(false) {}
G4MiscLHEPBuilder::~G4MiscLHEPBuilder()
{
if(wasActivated)
{
G4ProcessManager * aProcMan = 0;
aProcMan = G4AntiProton::AntiProton()->GetProcessManager();
if(aProcMan) aProcMan->RemoveProcess(&theAntiProtonInelastic);
if(aProcMan) aProcMan->RemoveProcess(&theAntiProtonElasticProcess);
aProcMan = G4AntiNeutron::AntiNeutron()->GetProcessManager();
if(aProcMan) aProcMan->RemoveProcess(&theAntiNeutronInelastic);
if(aProcMan) aProcMan->RemoveProcess(&theAntiNeutronElasticProcess);
aProcMan = G4Lambda::Lambda()->GetProcessManager();
if(aProcMan) aProcMan->RemoveProcess(&theLambdaInelastic);
if(aProcMan) aProcMan->RemoveProcess(&theLambdaElasticProcess);
aProcMan = G4AntiLambda::AntiLambda()->GetProcessManager();
if(aProcMan) aProcMan->RemoveProcess(&theAntiLambdaInelastic);
if(aProcMan) aProcMan->RemoveProcess(&theAntiLambdaElasticProcess);
aProcMan = G4SigmaMinus::SigmaMinus()->GetProcessManager();
if(aProcMan) aProcMan->RemoveProcess(&theSigmaMinusInelastic);
if(aProcMan) aProcMan->RemoveProcess(&theSigmaMinusElasticProcess);
aProcMan = G4AntiSigmaMinus::AntiSigmaMinus()->GetProcessManager();
if(aProcMan) aProcMan->RemoveProcess(&theAntiSigmaMinusInelastic);
if(aProcMan) aProcMan->RemoveProcess(&theAntiSigmaMinusElasticProcess);
aProcMan = G4SigmaPlus::SigmaPlus()->GetProcessManager();
if(aProcMan) aProcMan->RemoveProcess(&theSigmaPlusInelastic);
if(aProcMan) aProcMan->RemoveProcess(&theSigmaPlusElasticProcess);
aProcMan = G4AntiSigmaPlus::AntiSigmaPlus()->GetProcessManager();
if(aProcMan) aProcMan->RemoveProcess(&theAntiSigmaPlusInelastic);
if(aProcMan) aProcMan->RemoveProcess(&theAntiSigmaPlusElasticProcess);
aProcMan = G4XiMinus::XiMinus()->GetProcessManager();
if(aProcMan) aProcMan->RemoveProcess(&theXiMinusInelastic);
if(aProcMan) aProcMan->RemoveProcess(&theXiMinusElasticProcess);
aProcMan = G4AntiXiMinus::AntiXiMinus()->GetProcessManager();
if(aProcMan) aProcMan->RemoveProcess(&theAntiXiMinusInelastic);
if(aProcMan) aProcMan->RemoveProcess(&theAntiXiMinusElasticProcess);
aProcMan = G4XiZero::XiZero()->GetProcessManager();
if(aProcMan) aProcMan->RemoveProcess(&theXiZeroInelastic);
if(aProcMan) aProcMan->RemoveProcess(&theXiZeroElasticProcess);
aProcMan = G4AntiXiZero::AntiXiZero()->GetProcessManager();
if(aProcMan) aProcMan->RemoveProcess(&theAntiXiZeroInelastic);
if(aProcMan) aProcMan->RemoveProcess(&theAntiXiZeroElasticProcess);
aProcMan = G4OmegaMinus::OmegaMinus()->GetProcessManager();
if(aProcMan) aProcMan->RemoveProcess(&theOmegaMinusInelastic);
if(aProcMan) aProcMan->RemoveProcess(&theOmegaMinusElasticProcess);
aProcMan = G4AntiOmegaMinus::AntiOmegaMinus()->GetProcessManager();
if(aProcMan) aProcMan->RemoveProcess(&theAntiOmegaMinusInelastic);
if(aProcMan) aProcMan->RemoveProcess(&theAntiOmegaMinusElasticProcess);
}
}
void G4MiscLHEPBuilder::Build()
{
G4ProcessManager * aProcMan = 0;
theElasticModel = new G4LElastic;
wasActivated = true;
// anti-Proton
aProcMan = G4AntiProton::AntiProton()->GetProcessManager();
theLEAntiProtonModel = new G4LEAntiProtonInelastic();
theHEAntiProtonModel = new G4HEAntiProtonInelastic();
theAntiProtonInelastic.RegisterMe(theLEAntiProtonModel);
theAntiProtonInelastic.RegisterMe(theHEAntiProtonModel);
aProcMan->AddDiscreteProcess(&theAntiProtonInelastic);
theAntiProtonElasticProcess.RegisterMe(theElasticModel);
aProcMan->AddDiscreteProcess(&theAntiProtonElasticProcess);
// AntiNeutron
aProcMan = G4AntiNeutron::AntiNeutron()->GetProcessManager();
theLEAntiNeutronModel = new G4LEAntiNeutronInelastic();
theHEAntiNeutronModel = new G4HEAntiNeutronInelastic();
theAntiNeutronInelastic.RegisterMe(theLEAntiNeutronModel);
theAntiNeutronInelastic.RegisterMe(theHEAntiNeutronModel);
aProcMan->AddDiscreteProcess(&theAntiNeutronInelastic);
theAntiNeutronElasticProcess.RegisterMe(theElasticModel);
aProcMan->AddDiscreteProcess(&theAntiNeutronElasticProcess);
// Lambda
aProcMan = G4Lambda::Lambda()->GetProcessManager();
theLELambdaModel = new G4LELambdaInelastic();
theHELambdaModel = new G4HELambdaInelastic();
theLambdaInelastic.RegisterMe(theLELambdaModel);
theLambdaInelastic.RegisterMe(theHELambdaModel);
aProcMan->AddDiscreteProcess(&theLambdaInelastic);
theLambdaElasticProcess.RegisterMe(theElasticModel);
aProcMan->AddDiscreteProcess(&theLambdaElasticProcess);
// AntiLambda
aProcMan = G4AntiLambda::AntiLambda()->GetProcessManager();
theLEAntiLambdaModel = new G4LEAntiLambdaInelastic();
theHEAntiLambdaModel = new G4HEAntiLambdaInelastic();
theAntiLambdaInelastic.RegisterMe(theLEAntiLambdaModel);
theAntiLambdaInelastic.RegisterMe(theHEAntiLambdaModel);
aProcMan->AddDiscreteProcess(&theAntiLambdaInelastic);
theAntiLambdaElasticProcess.RegisterMe(theElasticModel);
aProcMan->AddDiscreteProcess(&theAntiLambdaElasticProcess);
// SigmaMinus
aProcMan = G4SigmaMinus::SigmaMinus()->GetProcessManager();
theLESigmaMinusModel = new G4LESigmaMinusInelastic();
theHESigmaMinusModel = new G4HESigmaMinusInelastic();
theSigmaMinusInelastic.RegisterMe(theLESigmaMinusModel);
theSigmaMinusInelastic.RegisterMe(theHESigmaMinusModel);
aProcMan->AddDiscreteProcess(&theSigmaMinusInelastic);
theSigmaMinusElasticProcess.RegisterMe(theElasticModel);
aProcMan->AddDiscreteProcess(&theSigmaMinusElasticProcess);
// anti-SigmaMinus
aProcMan = G4AntiSigmaMinus::AntiSigmaMinus()->GetProcessManager();
theLEAntiSigmaMinusModel = new G4LEAntiSigmaMinusInelastic();
theHEAntiSigmaMinusModel = new G4HEAntiSigmaMinusInelastic();
theAntiSigmaMinusInelastic.RegisterMe(theLEAntiSigmaMinusModel);
theAntiSigmaMinusInelastic.RegisterMe(theHEAntiSigmaMinusModel);
aProcMan->AddDiscreteProcess(&theAntiSigmaMinusInelastic);
theAntiSigmaMinusElasticProcess.RegisterMe(theElasticModel);
aProcMan->AddDiscreteProcess(&theAntiSigmaMinusElasticProcess);
// SigmaPlus
aProcMan = G4SigmaPlus::SigmaPlus()->GetProcessManager();
theLESigmaPlusModel = new G4LESigmaPlusInelastic();
theHESigmaPlusModel = new G4HESigmaPlusInelastic();
theSigmaPlusInelastic.RegisterMe(theLESigmaPlusModel);
theSigmaPlusInelastic.RegisterMe(theHESigmaPlusModel);
aProcMan->AddDiscreteProcess(&theSigmaPlusInelastic);
theSigmaPlusElasticProcess.RegisterMe(theElasticModel);
aProcMan->AddDiscreteProcess(&theSigmaPlusElasticProcess);
// anti-SigmaPlus
aProcMan = G4AntiSigmaPlus::AntiSigmaPlus()->GetProcessManager();
theLEAntiSigmaPlusModel = new G4LEAntiSigmaPlusInelastic();
theHEAntiSigmaPlusModel = new G4HEAntiSigmaPlusInelastic();
theAntiSigmaPlusInelastic.RegisterMe(theLEAntiSigmaPlusModel);
theAntiSigmaPlusInelastic.RegisterMe(theHEAntiSigmaPlusModel);
aProcMan->AddDiscreteProcess(&theAntiSigmaPlusInelastic);
theAntiSigmaPlusElasticProcess.RegisterMe(theElasticModel);
aProcMan->AddDiscreteProcess(&theAntiSigmaPlusElasticProcess);
// XiMinus
aProcMan = G4XiMinus::XiMinus()->GetProcessManager();
theLEXiMinusModel = new G4LEXiMinusInelastic();
theHEXiMinusModel = new G4HEXiMinusInelastic();
theXiMinusInelastic.RegisterMe(theLEXiMinusModel);
theXiMinusInelastic.RegisterMe(theHEXiMinusModel);
aProcMan->AddDiscreteProcess(&theXiMinusInelastic);
theXiMinusElasticProcess.RegisterMe(theElasticModel);
aProcMan->AddDiscreteProcess(&theXiMinusElasticProcess);
// anti-XiMinus
aProcMan = G4AntiXiMinus::AntiXiMinus()->GetProcessManager();
theLEAntiXiMinusModel = new G4LEAntiXiMinusInelastic();
theHEAntiXiMinusModel = new G4HEAntiXiMinusInelastic();
theAntiXiMinusInelastic.RegisterMe(theLEAntiXiMinusModel);
theAntiXiMinusInelastic.RegisterMe(theHEAntiXiMinusModel);
aProcMan->AddDiscreteProcess(&theAntiXiMinusInelastic);
theAntiXiMinusElasticProcess.RegisterMe(theElasticModel);
aProcMan->AddDiscreteProcess(&theAntiXiMinusElasticProcess);
// XiZero
aProcMan = G4XiZero::XiZero()->GetProcessManager();
theLEXiZeroModel = new G4LEXiZeroInelastic();
theHEXiZeroModel = new G4HEXiZeroInelastic();
theXiZeroInelastic.RegisterMe(theLEXiZeroModel);
theXiZeroInelastic.RegisterMe(theHEXiZeroModel);
aProcMan->AddDiscreteProcess(&theXiZeroInelastic);
theXiZeroElasticProcess.RegisterMe(theElasticModel);
aProcMan->AddDiscreteProcess(&theXiZeroElasticProcess);
// anti-XiZero
aProcMan = G4AntiXiZero::AntiXiZero()->GetProcessManager();
theLEAntiXiZeroModel = new G4LEAntiXiZeroInelastic();
theHEAntiXiZeroModel = new G4HEAntiXiZeroInelastic();
theAntiXiZeroInelastic.RegisterMe(theLEAntiXiZeroModel);
theAntiXiZeroInelastic.RegisterMe(theHEAntiXiZeroModel);
aProcMan->AddDiscreteProcess(&theAntiXiZeroInelastic);
theAntiXiZeroElasticProcess.RegisterMe(theElasticModel);
aProcMan->AddDiscreteProcess(&theAntiXiZeroElasticProcess);
// OmegaMinus
aProcMan = G4OmegaMinus::OmegaMinus()->GetProcessManager();
theLEOmegaMinusModel = new G4LEOmegaMinusInelastic();
theHEOmegaMinusModel = new G4HEOmegaMinusInelastic();
theOmegaMinusInelastic.RegisterMe(theLEOmegaMinusModel);
theOmegaMinusInelastic.RegisterMe(theHEOmegaMinusModel);
aProcMan->AddDiscreteProcess(&theOmegaMinusInelastic);
theOmegaMinusElasticProcess.RegisterMe(theElasticModel);
aProcMan->AddDiscreteProcess(&theOmegaMinusElasticProcess);
// anti-OmegaMinus
aProcMan = G4AntiOmegaMinus::AntiOmegaMinus()->GetProcessManager();
theLEAntiOmegaMinusModel = new G4LEAntiOmegaMinusInelastic();
theHEAntiOmegaMinusModel = new G4HEAntiOmegaMinusInelastic();
theAntiOmegaMinusInelastic.RegisterMe(theLEAntiOmegaMinusModel);
theAntiOmegaMinusInelastic.RegisterMe(theHEAntiOmegaMinusModel);
aProcMan->AddDiscreteProcess(&theAntiOmegaMinusInelastic);
theAntiOmegaMinusElasticProcess.RegisterMe(theElasticModel);
aProcMan->AddDiscreteProcess(&theAntiOmegaMinusElasticProcess);
}
// 2002 by J.P. Wellisch
@@ -0,0 +1,62 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
#include "G4NeutronBuilder.hh"
#include "G4ParticleDefinition.hh"
#include "G4ParticleTable.hh"
#include "G4ProcessManager.hh"
G4NeutronBuilder::
G4NeutronBuilder(): wasActivated(false) {}
G4NeutronBuilder::
~G4NeutronBuilder()
{
if(wasActivated)
{
G4ProcessManager * theProcMan = G4Neutron::Neutron()->GetProcessManager();
if(theProcMan) theProcMan->RemoveProcess(&theNeutronElasticProcess);
if(theProcMan) theProcMan->RemoveProcess(&theNeutronInelastic);
if(theProcMan) theProcMan->RemoveProcess(&theNeutronCapture);
if(theProcMan) theProcMan->RemoveProcess(&theNeutronFission);
}
}
void G4NeutronBuilder::
Build()
{
wasActivated = true;
std::vector<G4VNeutronBuilder *>::iterator i;
for(i=theModelCollections.begin(); i!=theModelCollections.end(); i++)
{
(*i)->Build(theNeutronElasticProcess);
(*i)->Build(theNeutronInelastic);
(*i)->Build(theNeutronCapture);
(*i)->Build(theNeutronFission);
}
G4ProcessManager * theProcMan = G4Neutron::Neutron()->GetProcessManager();
theProcMan->AddDiscreteProcess(&theNeutronElasticProcess);
theProcMan->AddDiscreteProcess(&theNeutronInelastic);
theProcMan->AddDiscreteProcess(&theNeutronCapture);
theProcMan->AddDiscreteProcess(&theNeutronFission);
}
// 2002 by J.P. Wellisch
@@ -0,0 +1,88 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
#include "G4NeutronHPBuilder.hh"
#include "G4ParticleDefinition.hh"
#include "G4ParticleTable.hh"
#include "G4ProcessManager.hh"
G4NeutronHPBuilder::
G4NeutronHPBuilder()
{
theHPElastic = NULL;
theHPElasticData = NULL;
theHPFission = NULL;
theHPFissionData = NULL;
theHPCapture = NULL;
theHPCaptureData = NULL;
theHPInelastic = NULL;
theHPInelasticData = NULL;
}
G4NeutronHPBuilder::
~G4NeutronHPBuilder()
{
delete theHPElasticData;
delete theHPFissionData;
delete theHPCaptureData;
delete theHPInelasticData;
}
void G4NeutronHPBuilder::
Build(G4HadronElasticProcess & aP)
{
if(theHPElastic==NULL) theHPElastic = new G4NeutronHPElastic;
if(theHPElasticData == NULL) theHPElasticData = new G4NeutronHPElasticData;
aP.AddDataSet(theHPElasticData);
aP.RegisterMe(theHPElastic);
}
void G4NeutronHPBuilder::
Build(G4HadronFissionProcess & aP)
{
if(theHPFission == NULL) theHPFission = new G4NeutronHPFission;
if(theHPFissionData==NULL) theHPFissionData=new G4NeutronHPFissionData;
aP.AddDataSet(theHPFissionData);
aP.RegisterMe(theHPFission);
}
void G4NeutronHPBuilder::
Build(G4HadronCaptureProcess & aP)
{
if(theHPCapture==NULL) theHPCapture = new G4NeutronHPCapture;
if(theHPCaptureData==NULL) theHPCaptureData = new G4NeutronHPCaptureData;
aP.AddDataSet(theHPCaptureData);
aP.RegisterMe(theHPCapture);
}
void G4NeutronHPBuilder::
Build(G4NeutronInelasticProcess & aP)
{
if(theHPInelastic==NULL) theHPInelastic = new G4NeutronHPInelastic;
if(theHPInelasticData==NULL) theHPInelasticData = new G4NeutronHPInelasticData;
aP.AddDataSet(theHPInelasticData);
aP.RegisterMe(theHPInelastic);
}
// 2002 by J.P. Wellisch
@@ -0,0 +1,98 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
#include "G4PiKBuilder.hh"
#include "G4ParticleDefinition.hh"
#include "G4ParticleTable.hh"
#include "G4ProcessManager.hh"
G4PiKBuilder::
G4PiKBuilder(): wasActivated(false) {}
G4PiKBuilder::
~G4PiKBuilder(){
if(wasActivated)
{
G4ProcessManager * theProcMan;
theProcMan = G4PionPlus::PionPlus()->GetProcessManager();
if(theProcMan) theProcMan->RemoveProcess(&thePionPlusElasticProcess);
if(theProcMan) theProcMan->RemoveProcess(&thePionPlusInelastic);
theProcMan = G4PionMinus::PionMinus()->GetProcessManager();
if(theProcMan) theProcMan->RemoveProcess(&thePionMinusElasticProcess);
if(theProcMan) theProcMan->RemoveProcess(&thePionMinusInelastic);
theProcMan = G4KaonPlus::KaonPlus()->GetProcessManager();
if(theProcMan) theProcMan->RemoveProcess(&theKaonPlusElasticProcess);
if(theProcMan) theProcMan->RemoveProcess(&theKaonPlusInelastic);
theProcMan = G4KaonMinus::KaonMinus()->GetProcessManager();
if(theProcMan) theProcMan->RemoveProcess(&theKaonMinusElasticProcess);
if(theProcMan) theProcMan->RemoveProcess(&theKaonMinusInelastic);
theProcMan = G4KaonZeroLong::KaonZeroLong()->GetProcessManager();
if(theProcMan) theProcMan->RemoveProcess(&theKaonZeroLElasticProcess);
if(theProcMan) theProcMan->RemoveProcess(&theKaonZeroLInelastic);
theProcMan = G4KaonZeroShort::KaonZeroShort()->GetProcessManager();
if(theProcMan) theProcMan->RemoveProcess(&theKaonZeroSElasticProcess);
if(theProcMan) theProcMan->RemoveProcess(&theKaonZeroSInelastic);
}
}
void G4PiKBuilder::
Build()
{
wasActivated = true;
std::vector<G4VPiKBuilder *>::iterator i;
for(i=theModelCollections.begin(); i!=theModelCollections.end(); i++)
{
(*i)->Build(thePionPlusElasticProcess);
(*i)->Build(thePionMinusElasticProcess);
(*i)->Build(theKaonPlusElasticProcess);
(*i)->Build(theKaonMinusElasticProcess);
(*i)->Build(theKaonZeroLElasticProcess);
(*i)->Build(theKaonZeroSElasticProcess);
(*i)->Build(thePionPlusInelastic);
(*i)->Build(thePionMinusInelastic);
(*i)->Build(theKaonPlusInelastic);
(*i)->Build(theKaonMinusInelastic);
(*i)->Build(theKaonZeroLInelastic);
(*i)->Build(theKaonZeroSInelastic);
}
G4ProcessManager * theProcMan;
theProcMan = G4PionPlus::PionPlus()->GetProcessManager();
theProcMan->AddDiscreteProcess(&thePionPlusElasticProcess);
theProcMan->AddDiscreteProcess(&thePionPlusInelastic);
theProcMan = G4PionMinus::PionMinus()->GetProcessManager();
theProcMan->AddDiscreteProcess(&thePionMinusElasticProcess);
theProcMan->AddDiscreteProcess(&thePionMinusInelastic);
theProcMan = G4KaonPlus::KaonPlus()->GetProcessManager();
theProcMan->AddDiscreteProcess(&theKaonPlusElasticProcess);
theProcMan->AddDiscreteProcess(&theKaonPlusInelastic);
theProcMan = G4KaonMinus::KaonMinus()->GetProcessManager();
theProcMan->AddDiscreteProcess(&theKaonMinusElasticProcess);
theProcMan->AddDiscreteProcess(&theKaonMinusInelastic);
theProcMan = G4KaonZeroLong::KaonZeroLong()->GetProcessManager();
theProcMan->AddDiscreteProcess(&theKaonZeroLElasticProcess);
theProcMan->AddDiscreteProcess(&theKaonZeroLInelastic);
theProcMan = G4KaonZeroShort::KaonZeroShort()->GetProcessManager();
theProcMan->AddDiscreteProcess(&theKaonZeroSElasticProcess);
theProcMan->AddDiscreteProcess(&theKaonZeroSInelastic);
}
// 2002 by J.P. Wellisch
@@ -0,0 +1,63 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
#include "G4PrecoNeutronBuilder.hh"
#include "G4ParticleDefinition.hh"
#include "G4ParticleTable.hh"
#include "G4ProcessManager.hh"
G4PrecoNeutronBuilder::
G4PrecoNeutronBuilder()
{
theMin = 0;
theMax = 170.*MeV;
theModel = new G4PreCompoundModel(&theHandler);
}
G4PrecoNeutronBuilder::
~G4PrecoNeutronBuilder() {}
void G4PrecoNeutronBuilder::
Build(G4HadronElasticProcess & )
{
}
void G4PrecoNeutronBuilder::
Build(G4HadronFissionProcess & )
{
}
void G4PrecoNeutronBuilder::
Build(G4HadronCaptureProcess & )
{
}
void G4PrecoNeutronBuilder::
Build(G4NeutronInelasticProcess & aP)
{
theModel->SetMinEnergy(theMin);
theModel->SetMaxEnergy(theMax);
aP.RegisterMe(theModel);
aP.AddDataSet(&theXSec);
}
// 2002 by J.P. Wellisch
@@ -0,0 +1,53 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
#include "G4PrecoProtonBuilder.hh"
#include "G4ParticleDefinition.hh"
#include "G4ParticleTable.hh"
#include "G4ProcessManager.hh"
G4PrecoProtonBuilder::
G4PrecoProtonBuilder()
{
theMin = 0;
theMax = 170.*MeV;
theModel = new G4PreCompoundModel(&theHandler);
}
G4PrecoProtonBuilder::
~G4PrecoProtonBuilder() {}
void G4PrecoProtonBuilder::
Build(G4HadronElasticProcess & )
{
}
void G4PrecoProtonBuilder::
Build(G4ProtonInelasticProcess & aP)
{
theModel->SetMinEnergy(theMin);
theModel->SetMaxEnergy(theMax);
aP.RegisterMe(theModel);
aP.AddDataSet(&theXSec);
}
// 2002 by J.P. Wellisch
@@ -0,0 +1,57 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
#include "G4ProtonBuilder.hh"
#include "G4ParticleDefinition.hh"
#include "G4ParticleTable.hh"
#include "G4ProcessManager.hh"
void G4ProtonBuilder::
Build()
{
wasActivated = true;
std::vector<G4VProtonBuilder *>::iterator i;
for(i=theModelCollections.begin(); i!=theModelCollections.end(); i++)
{
(*i)->Build(theProtonElasticProcess);
(*i)->Build(theProtonInelastic);
}
G4ProcessManager * theProcMan = G4Proton::Proton()->GetProcessManager();
theProcMan->AddDiscreteProcess(&theProtonElasticProcess);
theProcMan->AddDiscreteProcess(&theProtonInelastic);
}
G4ProtonBuilder::
G4ProtonBuilder(): wasActivated(false) {}
G4ProtonBuilder::
~G4ProtonBuilder()
{
if(wasActivated)
{
G4ProcessManager * theProcMan = G4Proton::Proton()->GetProcessManager();
if(theProcMan) theProcMan->RemoveProcess(&theProtonElasticProcess);
if(theProcMan) theProcMan->RemoveProcess(&theProtonInelastic);
}
}
// 2002 by J.P. Wellisch
@@ -0,0 +1,55 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
#include "G4QGSCNeutronBuilder.hh"
#include "G4ParticleDefinition.hh"
#include "G4ParticleTable.hh"
#include "G4ProcessManager.hh"
G4QGSCNeutronBuilder::
G4QGSCNeutronBuilder()
{
theMin = 8*GeV;
theModel = new G4TheoFSGenerator;
theCascade = new G4StringChipsParticleLevelInterface;
theModel->SetTransport(theCascade);
theModel->SetHighEnergyGenerator(&theStringModel);
theStringDecay = new G4ExcitedStringDecay(&theFragmentation);
theStringModel.SetFragmentationModel(theStringDecay);
}
G4QGSCNeutronBuilder::
~G4QGSCNeutronBuilder()
{
delete theStringDecay;
}
void G4QGSCNeutronBuilder::
Build(G4NeutronInelasticProcess & aP)
{
theModel->SetMinEnergy(theMin);
theModel->SetMaxEnergy(100*TeV);
aP.RegisterMe(theModel);
aP.AddDataSet(&theXSec);
}
// 2002 by J.P. Wellisch
@@ -0,0 +1,99 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
#include "G4QGSCPiKBuilder.hh"
#include "G4ParticleDefinition.hh"
#include "G4ParticleTable.hh"
#include "G4ProcessManager.hh"
G4QGSCPiKBuilder::
G4QGSCPiKBuilder()
{
theMin = 8*GeV;
theModel = new G4TheoFSGenerator;
theCascade = new G4StringChipsParticleLevelInterface;
theModel->SetTransport(theCascade);
theModel->SetHighEnergyGenerator(&theStringModel);
theStringDecay = new G4ExcitedStringDecay(&theFragmentation);
theStringModel.SetFragmentationModel(theStringDecay);
}
G4QGSCPiKBuilder::
~G4QGSCPiKBuilder()
{
delete theStringDecay;
}
void G4QGSCPiKBuilder::
Build(G4HadronElasticProcess & ) {}
void G4QGSCPiKBuilder::
Build(G4PionPlusInelasticProcess & aP)
{
theModel->SetMinEnergy(theMin);
theModel->SetMaxEnergy(100*TeV);
aP.AddDataSet(&thePiCross);
aP.RegisterMe(theModel);
}
void G4QGSCPiKBuilder::
Build(G4PionMinusInelasticProcess & aP)
{
theModel->SetMinEnergy(theMin);
theModel->SetMaxEnergy(100*TeV);
aP.AddDataSet(&thePiCross);
aP.RegisterMe(theModel);
}
void G4QGSCPiKBuilder::
Build(G4KaonPlusInelasticProcess & aP)
{
theModel->SetMinEnergy(theMin);
theModel->SetMaxEnergy(100*TeV);
aP.RegisterMe(theModel);
}
void G4QGSCPiKBuilder::
Build(G4KaonMinusInelasticProcess & aP)
{
theModel->SetMinEnergy(theMin);
theModel->SetMaxEnergy(100*TeV);
aP.RegisterMe(theModel);
}
void G4QGSCPiKBuilder::
Build(G4KaonZeroLInelasticProcess & aP)
{
theModel->SetMinEnergy(theMin);
theModel->SetMaxEnergy(100*TeV);
aP.RegisterMe(theModel);
}
void G4QGSCPiKBuilder::
Build(G4KaonZeroSInelasticProcess & aP)
{
theModel->SetMinEnergy(theMin);
theModel->SetMaxEnergy(100*TeV);
aP.RegisterMe(theModel);
}
// 2002 by J.P. Wellisch
@@ -0,0 +1,60 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
#include "G4QGSCProtonBuilder.hh"
#include "G4ParticleDefinition.hh"
#include "G4ParticleTable.hh"
#include "G4ProcessManager.hh"
G4QGSCProtonBuilder::
G4QGSCProtonBuilder()
{
theMin = 8*GeV;
theModel = new G4TheoFSGenerator;
theCascade = new G4StringChipsParticleLevelInterface;
theModel->SetTransport(theCascade);
theModel->SetHighEnergyGenerator(&theStringModel);
theStringDecay = new G4ExcitedStringDecay(&theFragmentation);
theStringModel.SetFragmentationModel(theStringDecay);
}
G4QGSCProtonBuilder::
~G4QGSCProtonBuilder()
{
delete theStringDecay;
}
void G4QGSCProtonBuilder::
Build(G4HadronElasticProcess & )
{
}
void G4QGSCProtonBuilder::
Build(G4ProtonInelasticProcess & aP)
{
theModel->SetMinEnergy(theMin);
theModel->SetMaxEnergy(100*TeV);
aP.RegisterMe(theModel);
aP.AddDataSet(&theXSec);
}
// 2002 by J.P. Wellisch
@@ -0,0 +1,72 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
#include "G4QGSPNeutronBuilder.hh"
#include "G4ParticleDefinition.hh"
#include "G4ParticleTable.hh"
#include "G4ProcessManager.hh"
G4QGSPNeutronBuilder::
G4QGSPNeutronBuilder()
{
theMin = 12*GeV;
theModel = new G4TheoFSGenerator;
theCascade = new G4GeneratorPrecompoundInterface;
thePreEquilib = new G4PreCompoundModel(&theHandler);
theCascade->SetDeExcitation(thePreEquilib);
theModel->SetTransport(theCascade);
theModel->SetHighEnergyGenerator(&theStringModel);
theStringDecay = new G4ExcitedStringDecay(&theFragmentation);
theStringModel.SetFragmentationModel(theStringDecay);
}
G4QGSPNeutronBuilder::
~G4QGSPNeutronBuilder()
{
delete theStringDecay;
}
void G4QGSPNeutronBuilder::
Build(G4HadronElasticProcess & )
{
}
void G4QGSPNeutronBuilder::
Build(G4HadronFissionProcess & )
{
}
void G4QGSPNeutronBuilder::
Build(G4HadronCaptureProcess & )
{
}
void G4QGSPNeutronBuilder::
Build(G4NeutronInelasticProcess & aP)
{
theModel->SetMinEnergy(theMin);
theModel->SetMaxEnergy(100*TeV);
aP.RegisterMe(theModel);
aP.AddDataSet(&theXSec);
}
// 2002 by J.P. Wellisch
@@ -0,0 +1,101 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
#include "G4QGSPPiKBuilder.hh"
#include "G4ParticleDefinition.hh"
#include "G4ParticleTable.hh"
#include "G4ProcessManager.hh"
G4QGSPPiKBuilder::
G4QGSPPiKBuilder()
{
theMin = 12*GeV;
theModel = new G4TheoFSGenerator;
theCascade = new G4GeneratorPrecompoundInterface;
thePreEquilib = new G4PreCompoundModel(&theHandler);
theCascade->SetDeExcitation(thePreEquilib);
theModel->SetTransport(theCascade);
theModel->SetHighEnergyGenerator(&theStringModel);
theStringDecay = new G4ExcitedStringDecay(&theFragmentation);
theStringModel.SetFragmentationModel(theStringDecay);
}
G4QGSPPiKBuilder::
~G4QGSPPiKBuilder()
{
delete theStringDecay;
}
void G4QGSPPiKBuilder::
Build(G4HadronElasticProcess & ) {}
void G4QGSPPiKBuilder::
Build(G4PionPlusInelasticProcess & aP)
{
theModel->SetMinEnergy(theMin);
theModel->SetMaxEnergy(100*TeV);
aP.AddDataSet(&thePiData);
aP.RegisterMe(theModel);
}
void G4QGSPPiKBuilder::
Build(G4PionMinusInelasticProcess & aP)
{
theModel->SetMinEnergy(theMin);
theModel->SetMaxEnergy(100*TeV);
aP.AddDataSet(&thePiData);
aP.RegisterMe(theModel);
}
void G4QGSPPiKBuilder::
Build(G4KaonPlusInelasticProcess & aP)
{
theModel->SetMinEnergy(theMin);
theModel->SetMaxEnergy(100*TeV);
aP.RegisterMe(theModel);
}
void G4QGSPPiKBuilder::
Build(G4KaonMinusInelasticProcess & aP)
{
theModel->SetMinEnergy(theMin);
theModel->SetMaxEnergy(100*TeV);
aP.RegisterMe(theModel);
}
void G4QGSPPiKBuilder::
Build(G4KaonZeroLInelasticProcess & aP)
{
theModel->SetMinEnergy(theMin);
theModel->SetMaxEnergy(100*TeV);
aP.RegisterMe(theModel);
}
void G4QGSPPiKBuilder::
Build(G4KaonZeroSInelasticProcess & aP)
{
theModel->SetMinEnergy(theMin);
theModel->SetMaxEnergy(100*TeV);
aP.RegisterMe(theModel);
}
// 2002 by J.P. Wellisch
@@ -0,0 +1,62 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
#include "G4QGSPProtonBuilder.hh"
#include "G4ParticleDefinition.hh"
#include "G4ParticleTable.hh"
#include "G4ProcessManager.hh"
G4QGSPProtonBuilder::
G4QGSPProtonBuilder()
{
theMin = 12*GeV;
theModel = new G4TheoFSGenerator;
theCascade = new G4GeneratorPrecompoundInterface;
thePreEquilib = new G4PreCompoundModel(&theHandler);
theCascade->SetDeExcitation(thePreEquilib);
theModel->SetTransport(theCascade);
theModel->SetHighEnergyGenerator(&theStringModel);
theStringDecay = new G4ExcitedStringDecay(&theFragmentation);
theStringModel.SetFragmentationModel(theStringDecay);
}
void G4QGSPProtonBuilder::
Build(G4ProtonInelasticProcess & aP)
{
aP.AddDataSet(&theXSec);
theModel->SetMinEnergy(theMin);
theModel->SetMaxEnergy(100*TeV);
aP.RegisterMe(theModel);
}
void G4QGSPProtonBuilder::
Build(G4HadronElasticProcess & )
{
}
G4QGSPProtonBuilder::
~G4QGSPProtonBuilder()
{
delete theStringDecay;
}
// 2002 by J.P. Wellisch
@@ -0,0 +1,81 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
#include "G4StoppingHadronBuilder.hh"
#include "globals.hh"
#include "G4ios.hh"
#include "G4ParticleTable.hh"
#include "G4ProcessManager.hh"
#include "G4PionMinus.hh"
#include "G4KaonMinus.hh"
#include "G4AntiProton.hh"
#include "G4AntiNeutron.hh"
G4StoppingHadronBuilder::
G4StoppingHadronBuilder(): wasActivated(false) {}
G4StoppingHadronBuilder::
~G4StoppingHadronBuilder()
{
if(wasActivated)
{
G4ProcessManager * aProcMan = 0;
aProcMan = G4PionMinus::PionMinusDefinition()->GetProcessManager();
if(aProcMan) aProcMan->RemoveProcess(&thePionMinusAbsorption);
aProcMan = G4KaonMinus::KaonMinusDefinition()->GetProcessManager();
if(aProcMan) aProcMan->RemoveProcess(&theKaonMinusAbsorption);
aProcMan = G4AntiProton::AntiProtonDefinition()->GetProcessManager();
if(aProcMan) aProcMan->RemoveProcess(&theAntiProtonAnnihilation);
aProcMan = G4AntiNeutron::AntiNeutronDefinition()->GetProcessManager();
if(aProcMan) aProcMan->RemoveProcess(&theAntiNeutronAnnihilation);
}
}
void G4StoppingHadronBuilder::Build()
{
G4ProcessManager * aProcMan = 0;
wasActivated=true;
// PionMinus
aProcMan = G4PionMinus::PionMinusDefinition()->GetProcessManager();
aProcMan->AddRestProcess(&thePionMinusAbsorption, ordDefault);
// KaonMinus
aProcMan = G4KaonMinus::KaonMinusDefinition()->GetProcessManager();
aProcMan->AddRestProcess(&theKaonMinusAbsorption, ordDefault);
// anti-Proton
aProcMan = G4AntiProton::AntiProtonDefinition()->GetProcessManager();
aProcMan->AddRestProcess(&theAntiProtonAnnihilation);
// AntiNeutron
aProcMan = G4AntiNeutron::AntiNeutronDefinition()->GetProcessManager();
aProcMan->AddRestProcess(&theAntiNeutronAnnihilation);
}
// 2002 by J.P. Wellisch
@@ -0,0 +1,81 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
#include "GeneralPhysics.hh"
#include "globals.hh"
#include "G4ios.hh"
#include "G4ParticleDefinition.hh"
#include "G4ProcessManager.hh"
// Bosons
#include "G4ChargedGeantino.hh"
#include "G4Geantino.hh"
GeneralPhysics::GeneralPhysics(const G4String& name)
: G4VPhysicsConstructor(name), wasActivated(false)
{
}
GeneralPhysics::~GeneralPhysics()
{
if(wasActivated)
{
theParticleIterator->reset();
while( (*theParticleIterator)() )
{
G4ParticleDefinition* particle = theParticleIterator->value();
G4ProcessManager* pmanager = particle->GetProcessManager();
if (fDecayProcess.IsApplicable(*particle) && pmanager) pmanager ->RemoveProcess(&fDecayProcess);
}
}
}
void GeneralPhysics::ConstructParticle()
{
// pseudo-particles
G4Geantino::GeantinoDefinition();
G4ChargedGeantino::ChargedGeantinoDefinition();
}
void GeneralPhysics::ConstructProcess()
{
// Add Decay Process
theParticleIterator->reset();
G4ParticleDefinition* particle=0;
G4ProcessManager* pmanager=0;
while( (*theParticleIterator)() )
{
particle = theParticleIterator->value();
pmanager = particle->GetProcessManager();
if( fDecayProcess.IsApplicable(*particle) )
{
pmanager -> AddProcess(&fDecayProcess);
pmanager -> SetProcessOrdering(&fDecayProcess, idxPostStep);
pmanager -> SetProcessOrdering(&fDecayProcess, idxAtRest);
}
}
}
// 2002 by J.P. Wellisch
@@ -0,0 +1,163 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
#include "IonPhysics.hh"
#include "G4ParticleDefinition.hh"
#include "G4ParticleTable.hh"
#include "G4ProcessManager.hh"
// Nuclei
#include "G4IonConstructor.hh"
#include "globals.hh"
#include "G4ios.hh"
IonPhysics::IonPhysics(const G4String& name)
: G4VPhysicsConstructor(name), wasActivated(false)
{
}
IonPhysics::~IonPhysics()
{
if(wasActivated)
{
G4ProcessManager * pManager = 0;
pManager = G4GenericIon::GenericIon()->GetProcessManager();
//if(pManager) pManager->RemoveProcess(&theIonElasticProcess);
//if(pManager) pManager->RemoveProcess(&fIonIonisation);
// if(pManager) pManager->RemoveProcess(&fIonMultipleScattering);
pManager = G4Deuteron::Deuteron()->GetProcessManager();
if(pManager) pManager->RemoveProcess(&theDElasticProcess);
if(pManager) pManager->RemoveProcess(&fDeuteronProcess);
if(pManager) pManager->RemoveProcess(&fDeuteronIonisation);
if(pManager) pManager->RemoveProcess(&fDeuteronMultipleScattering);
pManager = G4Triton::Triton()->GetProcessManager();
if(pManager) pManager->RemoveProcess(&theTElasticProcess);
if(pManager) pManager->RemoveProcess(&fTritonProcess);
if(pManager) pManager->RemoveProcess(&fTritonIonisation);
if(pManager) pManager->RemoveProcess(&fTritonMultipleScattering);
pManager = G4Alpha::Alpha()->GetProcessManager();
if(pManager) pManager->RemoveProcess(&theAElasticProcess);
if(pManager) pManager->RemoveProcess(&fAlphaProcess);
if(pManager) pManager->RemoveProcess(&fAlphaIonisation);
if(pManager) pManager->RemoveProcess(&fAlphaMultipleScattering);
pManager = G4He3::He3()->GetProcessManager();
//if(pManager) pManager->RemoveProcess(&theHe3ElasticProcess);
//if(pManager) pManager->RemoveProcess(&fHe3Ionisation);
//if(pManager) pManager->RemoveProcess(&fHe3MultipleScattering);
}
}
void IonPhysics::ConstructProcess()
{
G4ProcessManager * pManager = 0;
// Elastic Process
theElasticModel = new G4LElastic();
theIonElasticProcess.RegisterMe(theElasticModel);
theDElasticProcess.RegisterMe(theElasticModel);
theTElasticProcess.RegisterMe(theElasticModel);
theAElasticProcess.RegisterMe(theElasticModel);
theHe3ElasticProcess.RegisterMe(theElasticModel);
// Generic Ion
pManager = G4GenericIon::GenericIon()->GetProcessManager();
// add process
pManager->AddDiscreteProcess(&theIonElasticProcess);
pManager->AddProcess(&fIonIonisation, ordInActive, 2, 2);
pManager->AddProcess(&fIonMultipleScattering);
pManager->SetProcessOrdering(&fIonMultipleScattering, idxAlongStep, 1);
pManager->SetProcessOrdering(&fIonMultipleScattering, idxPostStep, 1);
// Deuteron
pManager = G4Deuteron::Deuteron()->GetProcessManager();
// add process
pManager->AddDiscreteProcess(&theDElasticProcess);
fDeuteronModel = new G4LEDeuteronInelastic();
fDeuteronProcess.RegisterMe(fDeuteronModel);
pManager->AddDiscreteProcess(&fDeuteronProcess);
pManager->AddProcess(&fDeuteronIonisation, ordInActive, 2, 2);
pManager->AddProcess(&fDeuteronMultipleScattering);
pManager->SetProcessOrdering(&fDeuteronMultipleScattering, idxAlongStep, 1);
pManager->SetProcessOrdering(&fDeuteronMultipleScattering, idxPostStep, 1);
// Triton
pManager = G4Triton::Triton()->GetProcessManager();
// add process
pManager->AddDiscreteProcess(&theTElasticProcess);
fTritonModel = new G4LETritonInelastic();
fTritonProcess.RegisterMe(fTritonModel);
pManager->AddDiscreteProcess(&fTritonProcess);
pManager->AddProcess(&fTritonIonisation, ordInActive, 2, 2);
pManager->AddProcess(&fTritonMultipleScattering);
pManager->SetProcessOrdering(&fTritonMultipleScattering, idxAlongStep, 1);
pManager->SetProcessOrdering(&fTritonMultipleScattering, idxPostStep, 1);
// Alpha
pManager = G4Alpha::Alpha()->GetProcessManager();
// add process
pManager->AddDiscreteProcess(&theAElasticProcess);
fAlphaModel = new G4LEAlphaInelastic();
fAlphaProcess.RegisterMe(fAlphaModel);
pManager->AddDiscreteProcess(&fAlphaProcess);
pManager->AddProcess(&fAlphaIonisation, ordInActive, 2, 2);
pManager->AddProcess(&fAlphaMultipleScattering);
pManager->SetProcessOrdering(&fAlphaMultipleScattering, idxAlongStep, 1);
pManager->SetProcessOrdering(&fAlphaMultipleScattering, idxPostStep, 1);
// He3
pManager = G4He3::He3()->GetProcessManager();
// add process
pManager->AddDiscreteProcess(&theHe3ElasticProcess);
pManager->AddProcess(&fHe3Ionisation, ordInActive, 2, 2);
pManager->AddProcess(&fHe3MultipleScattering);
pManager->SetProcessOrdering(&fHe3MultipleScattering, idxAlongStep, 1);
pManager->SetProcessOrdering(&fHe3MultipleScattering, idxPostStep, 1);
wasActivated = true;
}
void IonPhysics::ConstructParticle()
{
// Construct light ions
G4IonConstructor pConstructor;
pConstructor.ConstructParticle();
}
// 2002 by J.P. Wellisch
@@ -0,0 +1,133 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
#include "MuonPhysics.hh"
#include "G4ParticleDefinition.hh"
#include "G4ParticleTable.hh"
#include "G4MuonPlus.hh"
#include "G4MuonMinus.hh"
#include "G4TauMinus.hh"
#include "G4TauPlus.hh"
#include "G4NeutrinoTau.hh"
#include "G4AntiNeutrinoTau.hh"
#include "G4NeutrinoMu.hh"
#include "G4AntiNeutrinoMu.hh"
#include "G4ProcessManager.hh"
#include "globals.hh"
#include "G4ios.hh"
MuonPhysics::MuonPhysics(const G4String& name)
: G4VPhysicsConstructor(name)
{
}
MuonPhysics::~MuonPhysics()
{
if(wasActivated)
{
G4ProcessManager * pManager = 0;
pManager = G4MuonPlus::MuonPlus()->GetProcessManager();
if(pManager) pManager->RemoveProcess(&fMuPlusIonisation);
if(pManager) pManager->RemoveProcess(&fMuPlusBremsstrahlung);
if(pManager) pManager->RemoveProcess(&fMuPlusPairProduction);
if(pManager) pManager->RemoveProcess(&fMuPlusMultipleScattering);
pManager = G4MuonMinus::MuonMinus()->GetProcessManager();
if(pManager) pManager->RemoveProcess(&fMuMinusIonisation);
if(pManager) pManager->RemoveProcess(&fMuMinusBremsstrahlung);
if(pManager) pManager->RemoveProcess(&fMuMinusPairProduction);
if(pManager) pManager->RemoveProcess(&fMuMinusMultipleScattering);
if(pManager) pManager->RemoveProcess(&fMuMinusCaptureAtRest);
pManager = G4TauPlus::TauPlus()->GetProcessManager();
if(pManager) pManager->RemoveProcess(&fTauPlusIonisation);
if(pManager) pManager->RemoveProcess(&fTauPlusMultipleScattering);
pManager = G4TauMinus::TauMinus()->GetProcessManager();
if(pManager) pManager->RemoveProcess(&fTauMinusIonisation);
if(pManager) pManager->RemoveProcess(&fTauMinusMultipleScattering);
}
}
void MuonPhysics::ConstructProcess()
{
G4ProcessManager * pManager = 0;
wasActivated = true;
// Muon Plus Physics
pManager = G4MuonPlus::MuonPlus()->GetProcessManager();
// add processes
pManager->AddProcess(&fMuPlusIonisation, ordInActive,2, 2);
pManager->AddDiscreteProcess(&fMuPlusBremsstrahlung);
pManager->AddDiscreteProcess(&fMuPlusPairProduction);
pManager->AddProcess(&fMuPlusMultipleScattering);
pManager->SetProcessOrdering(&fMuPlusMultipleScattering, idxAlongStep, 1);
pManager->SetProcessOrdering(&fMuPlusMultipleScattering, idxPostStep, 1);
// Muon Minus Physics
pManager = G4MuonMinus::MuonMinus()->GetProcessManager();
// add processes
pManager->AddProcess(&fMuMinusIonisation, ordInActive,2, 2);
pManager->AddDiscreteProcess(&fMuMinusBremsstrahlung);
pManager->AddDiscreteProcess(&fMuMinusPairProduction);
pManager->AddProcess(&fMuMinusMultipleScattering);
pManager->SetProcessOrdering(&fMuMinusMultipleScattering, idxAlongStep, 1);
pManager->SetProcessOrdering(&fMuMinusMultipleScattering, idxPostStep, 1);
pManager->AddRestProcess(&fMuMinusCaptureAtRest);
// Tau Plus Physics
pManager = G4TauPlus::TauPlus()->GetProcessManager();
// add processes
pManager->AddProcess(&fTauPlusIonisation, ordInActive,2, 2);
pManager->AddProcess(&fTauPlusMultipleScattering);
pManager->SetProcessOrdering(&fTauPlusMultipleScattering, idxAlongStep, 1);
pManager->SetProcessOrdering(&fTauPlusMultipleScattering, idxPostStep, 1);
// Tau Minus Physics
pManager = G4TauMinus::TauMinus()->GetProcessManager();
// add processes
pManager->AddProcess(&fTauMinusIonisation, ordInActive,2, 2);
pManager->AddProcess(&fTauMinusMultipleScattering);
pManager->SetProcessOrdering(&fTauMinusMultipleScattering, idxAlongStep, 1);
pManager->SetProcessOrdering(&fTauMinusMultipleScattering, idxPostStep, 1);
}
void MuonPhysics::ConstructParticle()
{
G4TauMinus::TauMinusDefinition();
G4TauPlus::TauPlusDefinition();
G4MuonPlus::MuonPlusDefinition();
G4MuonMinus::MuonMinusDefinition();
G4NeutrinoMu::NeutrinoMuDefinition();
G4AntiNeutrinoMu::AntiNeutrinoMuDefinition();
G4NeutrinoTau::NeutrinoTauDefinition();
G4AntiNeutrinoTau::AntiNeutrinoTauDefinition();
}
// 2002 by J.P. Wellisch