lars/geant4
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Import Geant4 9.3.0 source tree

Browse Source
This commit is contained in:
Gabriele Cosmo
2016-06-09 16:15:05 +02:00
parent b79225fb37
commit 74cad5e589
3877 changed files with 234205 additions and 167127 deletions
Download Patch File Download Diff File Expand all files Collapse all files
source/physics_lists/builders/src/G4BertiniNeutronBuilder.cc
+14 -2
View File
@@ -23,6 +23,20 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4BertiniNeutronBuilder.cc,v 1.4 2009/04/02 08:11:32 vnivanch Exp $
// GEANT4 tag $Name: geant4-09-03 $
//
//---------------------------------------------------------------------------
//
// ClassName: G4BertiniNeutronBuilder
//
// Author: 2002 H.P. Wellisch
//
// Modified:
// 02.04.2009 V.Ivanchenko remove add cross section, string builderis reponsible
//
//----------------------------------------------------------------------------
//
#include "G4BertiniNeutronBuilder.hh"
#include "G4ParticleDefinition.hh"
#include "G4ParticleTable.hh"
@@ -42,13 +56,11 @@ Build(G4NeutronInelasticProcess * aP)
theModel->SetMinEnergy(theMin);
theModel->SetMaxEnergy(theMax);
aP->RegisterMe(theModel);
aP->AddDataSet(&theXSec);
}
G4BertiniNeutronBuilder::
~G4BertiniNeutronBuilder()
{
delete theModel;
}
void G4BertiniNeutronBuilder::
source/physics_lists/builders/src/G4BertiniPiKBuilder.cc
+43 -31
View File
@@ -23,14 +23,29 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
#include "G4BertiniPiKBuilder.hh"
#include "G4ParticleDefinition.hh"
#include "G4ParticleTable.hh"
#include "G4ProcessManager.hh"
// $Id: G4BertiniPiKBuilder.cc,v 1.3 2009/04/02 08:11:32 vnivanch Exp $
// GEANT4 tag $Name: geant4-09-03 $
//
//---------------------------------------------------------------------------
//
// ClassName: G4BertiniPiKBuilder
//
// Author: 2002 H.P. Wellisch
//
// Modified:
// 02.04.2009 V.Ivanchenko remove add cross section, string builderis reponsible
//
//----------------------------------------------------------------------------
//
#include "G4BertiniPiKBuilder.hh"
#include "G4ParticleDefinition.hh"
#include "G4ParticleTable.hh"
#include "G4ProcessManager.hh"
G4BertiniPiKBuilder::
G4BertiniPiKBuilder()
G4BertiniPiKBuilder::
G4BertiniPiKBuilder()
{
thePiData = new G4PiNuclearCrossSection;
theMin = 0*GeV;
theMax = 9.9*GeV;
theModel = new G4CascadeInterface;
@@ -38,58 +53,55 @@
theModel->SetMaxEnergy(theMax);
}
G4BertiniPiKBuilder::
~G4BertiniPiKBuilder()
G4BertiniPiKBuilder::~G4BertiniPiKBuilder()
{
delete theModel;
}
void G4BertiniPiKBuilder::
Build(G4PionPlusInelasticProcess * aP)
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 * aP)
void G4BertiniPiKBuilder::
Build(G4PionMinusInelasticProcess * aP)
{
aP->RegisterMe(theModel);
theModel->SetMinEnergy(theMin);
theModel->SetMaxEnergy(theMax);
}
void G4BertiniPiKBuilder::
Build(G4KaonMinusInelasticProcess * aP)
void G4BertiniPiKBuilder::
Build(G4HadronElasticProcess * ) {}
void G4BertiniPiKBuilder::
Build(G4KaonPlusInelasticProcess * aP)
{
aP->RegisterMe(theModel);
theModel->SetMinEnergy(theMin);
theModel->SetMaxEnergy(theMax);
}
void G4BertiniPiKBuilder::
Build(G4KaonZeroLInelasticProcess * aP)
void G4BertiniPiKBuilder::
Build(G4KaonMinusInelasticProcess * aP)
{
aP->RegisterMe(theModel);
theModel->SetMinEnergy(theMin);
theModel->SetMaxEnergy(theMax);
}
void G4BertiniPiKBuilder::
Build(G4KaonZeroSInelasticProcess * aP)
void G4BertiniPiKBuilder::
Build(G4KaonZeroLInelasticProcess * aP)
{
aP->RegisterMe(theModel);
theModel->SetMinEnergy(theMin);
theModel->SetMaxEnergy(theMax);
}
void G4BertiniPiKBuilder::
Build(G4KaonZeroSInelasticProcess * aP)
{
aP->RegisterMe(theModel);
theModel->SetMinEnergy(theMin);
source/physics_lists/builders/src/G4BertiniProtonBuilder.cc
+14 -2
View File
@@ -23,6 +23,20 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4BertiniProtonBuilder.cc,v 1.3 2009/04/02 08:11:32 vnivanch Exp $
// GEANT4 tag $Name: geant4-09-03 $
//
//---------------------------------------------------------------------------
//
// ClassName: G4BertiniProtonBuilder
//
// Author: 2002 H.P. Wellisch
//
// Modified:
// 02.04.2009 V.Ivanchenko remove add cross section, string builderis reponsible
//
//----------------------------------------------------------------------------
//
#include "G4BertiniProtonBuilder.hh"
#include "G4ParticleDefinition.hh"
#include "G4ParticleTable.hh"
@@ -39,7 +53,6 @@ G4BertiniProtonBuilder()
G4BertiniProtonBuilder::
~G4BertiniProtonBuilder()
{
delete theModel;
}
void G4BertiniProtonBuilder::
@@ -53,7 +66,6 @@ Build(G4ProtonInelasticProcess * aP)
theModel->SetMinEnergy(theMin);
theModel->SetMaxEnergy(theMax);
aP->RegisterMe(theModel);
aP->AddDataSet(&theXSec);
}
// 2002 by J.P. Wellisch
source/physics_lists/builders/src/G4BinaryNeutronBuilder.cc
+27 -16
View File
@@ -23,13 +23,27 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
#include "G4BinaryNeutronBuilder.hh"
#include "G4ParticleDefinition.hh"
#include "G4ParticleTable.hh"
#include "G4ProcessManager.hh"
// $Id: G4BinaryNeutronBuilder.cc,v 1.3 2009/04/02 08:11:32 vnivanch Exp $
// GEANT4 tag $Name: geant4-09-03 $
//
//---------------------------------------------------------------------------
//
// ClassName: G4BinaryNeutronBuilder
//
// Author: 2002 H.P. Wellisch
//
// Modified:
// 02.04.2009 V.Ivanchenko remove add cross section, string builderis reponsible
//
//----------------------------------------------------------------------------
//
#include "G4BinaryNeutronBuilder.hh"
#include "G4ParticleDefinition.hh"
#include "G4ParticleTable.hh"
#include "G4ProcessManager.hh"
G4BinaryNeutronBuilder::
G4BinaryNeutronBuilder()
G4BinaryNeutronBuilder::
G4BinaryNeutronBuilder()
{
theMin = 0;
theMax = 9.9*GeV;
@@ -42,27 +56,24 @@
theModel->SetMinEnergy(theMin);
theModel->SetMaxEnergy(theMax);
aP->RegisterMe(theModel);
aP->AddDataSet(&theXSec);
}
G4BinaryNeutronBuilder::
~G4BinaryNeutronBuilder()
G4BinaryNeutronBuilder::~G4BinaryNeutronBuilder()
{
delete theModel;
}
void G4BinaryNeutronBuilder::
Build(G4HadronElasticProcess * )
void G4BinaryNeutronBuilder::
Build(G4HadronElasticProcess * )
{
}
void G4BinaryNeutronBuilder::
Build(G4HadronFissionProcess * )
void G4BinaryNeutronBuilder::
Build(G4HadronFissionProcess * )
{
}
void G4BinaryNeutronBuilder::
Build(G4HadronCaptureProcess * )
void G4BinaryNeutronBuilder::
Build(G4HadronCaptureProcess * )
{
}
source/physics_lists/builders/src/G4BinaryPiKBuilder.cc
+15 -3
View File
@@ -23,6 +23,20 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4BinaryPiKBuilder.cc,v 1.3 2009/04/02 08:11:32 vnivanch Exp $
// GEANT4 tag $Name: geant4-09-03 $
//
//---------------------------------------------------------------------------
//
// ClassName: G4BinaryPiKBuilder
//
// Author: 2002 H.P. Wellisch
//
// Modified:
// 02.04.2009 V.Ivanchenko remove add cross section, string builderis reponsible
//
//----------------------------------------------------------------------------
//
#include "G4BinaryPiKBuilder.hh"
#include "G4ParticleDefinition.hh"
#include "G4ParticleTable.hh"
@@ -31,6 +45,7 @@
G4BinaryPiKBuilder::
G4BinaryPiKBuilder()
{
thePiData = new G4PiNuclearCrossSection;
theMin = 0*GeV;
theMax = 1.3*GeV;
theModel = new G4BinaryCascade;
@@ -41,7 +56,6 @@ G4BinaryPiKBuilder()
G4BinaryPiKBuilder::
~G4BinaryPiKBuilder()
{
delete theModel;
}
void G4BinaryPiKBuilder::
@@ -53,7 +67,6 @@ Build(G4PionPlusInelasticProcess * aP)
theModel->SetMinEnergy(theMin);
theModel->SetMaxEnergy(theMax);
aP->RegisterMe(theModel);
aP->AddDataSet(&thePiData);
}
void G4BinaryPiKBuilder::
@@ -62,7 +75,6 @@ Build(G4PionMinusInelasticProcess * aP)
theModel->SetMinEnergy(theMin);
theModel->SetMaxEnergy(theMax);
aP->RegisterMe(theModel);
aP->AddDataSet(&thePiData);
}
void G4BinaryPiKBuilder::
source/physics_lists/builders/src/G4BinaryProtonBuilder.cc
+17 -2
View File
@@ -23,6 +23,20 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4BinaryProtonBuilder.cc,v 1.3 2009/04/02 08:11:32 vnivanch Exp $
// GEANT4 tag $Name: geant4-09-03 $
//
//---------------------------------------------------------------------------
//
// ClassName: G4BinaryProtonBuilder
//
// Author: 2002 H.P. Wellisch
//
// Modified:
// 02.04.2009 V.Ivanchenko remove add cross section, string builderis reponsible
//
//----------------------------------------------------------------------------
//
#include "G4BinaryProtonBuilder.hh"
#include "G4ParticleDefinition.hh"
#include "G4ParticleTable.hh"
@@ -39,14 +53,15 @@ G4BinaryProtonBuilder()
void G4BinaryProtonBuilder::
Build(G4ProtonInelasticProcess * aP)
{
aP->AddDataSet(&theXSec);
theModel->SetMinEnergy(theMin);
theModel->SetMaxEnergy(theMax);
aP->RegisterMe(theModel);
}
G4BinaryProtonBuilder::
~G4BinaryProtonBuilder() {}
~G4BinaryProtonBuilder()
{
}
void G4BinaryProtonBuilder::
Build(G4HadronElasticProcess * )
source/physics_lists/builders/src/G4EmDNAPhysics.cc
+233
View File
@@ -0,0 +1,233 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4EmDNAPhysics.cc,v 1.2 2009/11/01 13:21:13 vnivanch Exp $
// GEANT4 tag $Name: geant4-09-03 $
#include "G4EmDNAPhysics.hh"
#include "G4ProcessManager.hh"
#include "G4DNAGenericIonsManager.hh"
// *** Processes and models for Geant4-DNA
#include "G4DNAElastic.hh"
#include "G4DNAChampionElasticModel.hh"
#include "G4DNAScreenedRutherfordElasticModel.hh"
#include "G4DNAExcitation.hh"
#include "G4DNAEmfietzoglouExcitationModel.hh"
#include "G4DNAMillerGreenExcitationModel.hh"
#include "G4DNABornExcitationModel.hh"
#include "G4DNAIonisation.hh"
#include "G4DNABornIonisationModel.hh"
#include "G4DNARuddIonisationModel.hh"
#include "G4DNAChargeDecrease.hh"
#include "G4DNADingfelderChargeDecreaseModel.hh"
#include "G4DNAChargeIncrease.hh"
#include "G4DNADingfelderChargeIncreaseModel.hh"
// particles
#include "G4Electron.hh"
#include "G4Proton.hh"
// Warning : the following is needed in order to use EM Physics builders
// e+
#include "G4Positron.hh"
#include "G4eMultipleScattering.hh"
#include "G4eIonisation.hh"
#include "G4eBremsstrahlung.hh"
#include "G4eplusAnnihilation.hh"
// gamma
#include "G4Gamma.hh"
#include "G4PhotoElectricEffect.hh"
#include "G4LivermorePhotoElectricModel.hh"
#include "G4ComptonScattering.hh"
#include "G4LivermoreComptonModel.hh"
#include "G4GammaConversion.hh"
#include "G4LivermoreGammaConversionModel.hh"
#include "G4RayleighScattering.hh"
#include "G4LivermoreRayleighModel.hh"
// end of warning
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
G4EmDNAPhysics::G4EmDNAPhysics(
G4int ver, const G4String& name)
: G4VPhysicsConstructor(name), verbose(ver)
{}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
G4EmDNAPhysics::~G4EmDNAPhysics()
{}
#include "G4GenericIon.hh"
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void G4EmDNAPhysics::ConstructParticle()
{
// bosons
G4Gamma::Gamma();
// leptons
G4Electron::Electron();
G4Positron::Positron();
// baryons
G4Proton::Proton();
G4GenericIon::GenericIonDefinition();
G4DNAGenericIonsManager * genericIonsManager;
genericIonsManager=G4DNAGenericIonsManager::Instance();
genericIonsManager->GetIon("alpha++");
genericIonsManager->GetIon("alpha+");
genericIonsManager->GetIon("helium");
genericIonsManager->GetIon("hydrogen");
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void G4EmDNAPhysics::ConstructProcess()
{
theParticleIterator->reset();
while( (*theParticleIterator)() )
{
G4ParticleDefinition* particle = theParticleIterator->value();
G4ProcessManager* pmanager = particle->GetProcessManager();
G4String particleName = particle->GetParticleName();
if (particleName == "e-") {
// *** Elastic scattering (two alternative models available) ***
G4DNAElastic* theDNAElasticProcess = new G4DNAElastic();
theDNAElasticProcess->SetModel(new G4DNAScreenedRutherfordElasticModel());
// or alternative model
// theDNAElasticProcess->SetModel(new G4DNAChampionElasticModel());
pmanager->AddDiscreteProcess(theDNAElasticProcess);
// *** Excitation ***
pmanager->AddDiscreteProcess(new G4DNAExcitation());
// *** Ionisation ***
pmanager->AddDiscreteProcess(new G4DNAIonisation());
} else if ( particleName == "proton" ) {
pmanager->AddDiscreteProcess(new G4DNAExcitation());
pmanager->AddDiscreteProcess(new G4DNAIonisation());
pmanager->AddDiscreteProcess(new G4DNAChargeDecrease());
} else if ( particleName == "hydrogen" ) {
pmanager->AddDiscreteProcess(new G4DNAIonisation());
pmanager->AddDiscreteProcess(new G4DNAChargeIncrease());
} else if ( particleName == "alpha" ) {
pmanager->AddDiscreteProcess(new G4DNAExcitation());
pmanager->AddDiscreteProcess(new G4DNAIonisation());
pmanager->AddDiscreteProcess(new G4DNAChargeDecrease());
} else if ( particleName == "alpha+" ) {
pmanager->AddDiscreteProcess(new G4DNAExcitation());
pmanager->AddDiscreteProcess(new G4DNAIonisation());
pmanager->AddDiscreteProcess(new G4DNAChargeDecrease());
pmanager->AddDiscreteProcess(new G4DNAChargeIncrease());
} else if ( particleName == "helium" ) {
pmanager->AddDiscreteProcess(new G4DNAExcitation());
pmanager->AddDiscreteProcess(new G4DNAIonisation());
pmanager->AddDiscreteProcess(new G4DNAChargeIncrease());
}
// Warning : the following particles and processes are needed by EM Physics builders
// They are taken from the default Livermore Physics list
// These particles are currently not handled by Geant4-DNA
// e+
else if (particleName == "e+") {
// Identical to G4EmStandardPhysics_option3
G4eMultipleScattering* msc = new G4eMultipleScattering();
msc->SetStepLimitType(fUseDistanceToBoundary);
pmanager->AddProcess(msc, -1, 1, 1);
G4eIonisation* eIoni = new G4eIonisation();
eIoni->SetStepFunction(0.2, 100*um);
pmanager->AddProcess(eIoni, -1, 2, 2);
pmanager->AddProcess(new G4eBremsstrahlung, -1,-3, 3);
pmanager->AddProcess(new G4eplusAnnihilation,0,-1, 4);
} else if (particleName == "gamma") {
G4double LivermoreHighEnergyLimit = GeV;
G4PhotoElectricEffect* thePhotoElectricEffect = new G4PhotoElectricEffect();
G4LivermorePhotoElectricModel* theLivermorePhotoElectricModel =
new G4LivermorePhotoElectricModel();
theLivermorePhotoElectricModel->SetHighEnergyLimit(LivermoreHighEnergyLimit);
thePhotoElectricEffect->AddEmModel(0, theLivermorePhotoElectricModel);
pmanager->AddDiscreteProcess(thePhotoElectricEffect);
G4ComptonScattering* theComptonScattering = new G4ComptonScattering();
G4LivermoreComptonModel* theLivermoreComptonModel =
new G4LivermoreComptonModel();
theLivermoreComptonModel->SetHighEnergyLimit(LivermoreHighEnergyLimit);
theComptonScattering->AddEmModel(0, theLivermoreComptonModel);
pmanager->AddDiscreteProcess(theComptonScattering);
G4GammaConversion* theGammaConversion = new G4GammaConversion();
G4LivermoreGammaConversionModel* theLivermoreGammaConversionModel =
new G4LivermoreGammaConversionModel();
theLivermoreGammaConversionModel->SetHighEnergyLimit(LivermoreHighEnergyLimit);
theGammaConversion->AddEmModel(0, theLivermoreGammaConversionModel);
pmanager->AddDiscreteProcess(theGammaConversion);
G4RayleighScattering* theRayleigh = new G4RayleighScattering();
G4LivermoreRayleighModel* theRayleighModel = new G4LivermoreRayleighModel();
theRayleighModel->SetHighEnergyLimit(LivermoreHighEnergyLimit);
theRayleigh->AddEmModel(0, theRayleighModel);
pmanager->AddDiscreteProcess(theRayleigh);
}
// Warning : end of particles and processes are needed by EM Physics builders
}
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
source/physics_lists/builders/src/G4EmLivermorePhysics.cc
+368
View File
@@ -0,0 +1,368 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4EmLivermorePhysics.cc,v 1.7 2009/11/24 12:53:22 vnivanch Exp $
// GEANT4 tag $Name: geant4-09-03 $
#include "G4EmLivermorePhysics.hh"
#include "G4ParticleDefinition.hh"
#include "G4ProcessManager.hh"
// *** Processes and models
// gamma
#include "G4PhotoElectricEffect.hh"
#include "G4LivermorePhotoElectricModel.hh"
#include "G4ComptonScattering.hh"
#include "G4LivermoreComptonModel.hh"
#include "G4GammaConversion.hh"
#include "G4LivermoreGammaConversionModel.hh"
#include "G4RayleighScattering.hh"
#include "G4LivermoreRayleighModel.hh"
// e-
#include "G4eMultipleScattering.hh"
#include "G4UniversalFluctuation.hh"
#include "G4eIonisation.hh"
#include "G4LivermoreIonisationModel.hh"
#include "G4eBremsstrahlung.hh"
#include "G4LivermoreBremsstrahlungModel.hh"
// e+
#include "G4eplusAnnihilation.hh"
// mu
#include "G4MuMultipleScattering.hh"
#include "G4MuIonisation.hh"
#include "G4MuBremsstrahlung.hh"
#include "G4MuPairProduction.hh"
// hadrons
#include "G4hMultipleScattering.hh"
#include "G4MscStepLimitType.hh"
#include "G4hBremsstrahlung.hh"
#include "G4hPairProduction.hh"
#include "G4hIonisation.hh"
#include "G4ionIonisation.hh"
#include "G4IonParametrisedLossModel.hh"
#include "G4NuclearStopping.hh"
// msc models
#include "G4UrbanMscModel93.hh"
#include "G4WentzelVIModel.hh"
#include "G4CoulombScattering.hh"
//
#include "G4LossTableManager.hh"
#include "G4EmProcessOptions.hh"
// particles
#include "G4Gamma.hh"
#include "G4Electron.hh"
#include "G4Positron.hh"
#include "G4MuonPlus.hh"
#include "G4MuonMinus.hh"
#include "G4PionPlus.hh"
#include "G4PionMinus.hh"
#include "G4KaonPlus.hh"
#include "G4KaonMinus.hh"
#include "G4Proton.hh"
#include "G4AntiProton.hh"
#include "G4Deuteron.hh"
#include "G4Triton.hh"
#include "G4He3.hh"
#include "G4Alpha.hh"
#include "G4GenericIon.hh"
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
G4EmLivermorePhysics::G4EmLivermorePhysics(
G4int ver, const G4String& name)
: G4VPhysicsConstructor(name), verbose(ver)
{
G4LossTableManager::Instance();
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
G4EmLivermorePhysics::~G4EmLivermorePhysics()
{}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void G4EmLivermorePhysics::ConstructParticle()
{
// gamma
G4Gamma::Gamma();
// leptons
G4Electron::Electron();
G4Positron::Positron();
G4MuonPlus::MuonPlus();
G4MuonMinus::MuonMinus();
// mesons
G4PionPlus::PionPlusDefinition();
G4PionMinus::PionMinusDefinition();
G4KaonPlus::KaonPlusDefinition();
G4KaonMinus::KaonMinusDefinition();
// baryons
G4Proton::Proton();
G4AntiProton::AntiProton();
// ions
G4Deuteron::Deuteron();
G4Triton::Triton();
G4He3::He3();
G4Alpha::Alpha();
G4GenericIon::GenericIonDefinition();
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void G4EmLivermorePhysics::ConstructProcess()
{
// Add Livermore EM Processes
theParticleIterator->reset();
while( (*theParticleIterator)() ){
G4ParticleDefinition* particle = theParticleIterator->value();
G4ProcessManager* pmanager = particle->GetProcessManager();
G4String particleName = particle->GetParticleName();
if(verbose > 1)
G4cout << "### " << GetPhysicsName() << " instantiates for "
<< particleName << G4endl;
//Applicability range for Livermore models
//for higher energies, the Standard models are used
G4double LivermoreHighEnergyLimit = GeV;
if (particleName == "gamma") {
G4PhotoElectricEffect* thePhotoElectricEffect = new G4PhotoElectricEffect();
G4LivermorePhotoElectricModel* theLivermorePhotoElectricModel =
new G4LivermorePhotoElectricModel();
theLivermorePhotoElectricModel->SetHighEnergyLimit(LivermoreHighEnergyLimit);
thePhotoElectricEffect->AddEmModel(0, theLivermorePhotoElectricModel);
pmanager->AddDiscreteProcess(thePhotoElectricEffect);
G4ComptonScattering* theComptonScattering = new G4ComptonScattering();
G4LivermoreComptonModel* theLivermoreComptonModel =
new G4LivermoreComptonModel();
theLivermoreComptonModel->SetHighEnergyLimit(LivermoreHighEnergyLimit);
theComptonScattering->AddEmModel(0, theLivermoreComptonModel);
pmanager->AddDiscreteProcess(theComptonScattering);
G4GammaConversion* theGammaConversion = new G4GammaConversion();
G4LivermoreGammaConversionModel* theLivermoreGammaConversionModel =
new G4LivermoreGammaConversionModel();
theLivermoreGammaConversionModel->SetHighEnergyLimit(LivermoreHighEnergyLimit);
theGammaConversion->AddEmModel(0, theLivermoreGammaConversionModel);
pmanager->AddDiscreteProcess(theGammaConversion);
G4RayleighScattering* theRayleigh = new G4RayleighScattering();
G4LivermoreRayleighModel* theRayleighModel = new G4LivermoreRayleighModel();
theRayleighModel->SetHighEnergyLimit(LivermoreHighEnergyLimit);
theRayleigh->AddEmModel(0, theRayleighModel);
pmanager->AddDiscreteProcess(theRayleigh);
} else if (particleName == "e-") {
G4eMultipleScattering* msc = new G4eMultipleScattering();
msc->AddEmModel(0, new G4UrbanMscModel93());
msc->SetStepLimitType(fUseDistanceToBoundary);
pmanager->AddProcess(msc, -1, 1, 1);
// Ionisation
G4eIonisation* eIoni = new G4eIonisation();
G4LivermoreIonisationModel* theIoniLivermore = new
G4LivermoreIonisationModel();
theIoniLivermore->SetHighEnergyLimit(LivermoreHighEnergyLimit);
eIoni->AddEmModel(0, theIoniLivermore, new G4UniversalFluctuation() );
eIoni->SetStepFunction(0.2, 100*um); //
pmanager->AddProcess(eIoni, -1, 2, 2);
// Bremsstrahlung
G4eBremsstrahlung* eBrem = new G4eBremsstrahlung();
G4LivermoreBremsstrahlungModel* theBremLivermore = new
G4LivermoreBremsstrahlungModel();
theBremLivermore->SetHighEnergyLimit(LivermoreHighEnergyLimit);
eBrem->AddEmModel(0, theBremLivermore);
pmanager->AddProcess(eBrem, -1,-3, 3);
} else if (particleName == "e+") {
// Identical to G4EmStandardPhysics_option3
G4eMultipleScattering* msc = new G4eMultipleScattering();
msc->AddEmModel(0, new G4UrbanMscModel93());
msc->SetStepLimitType(fUseDistanceToBoundary);
pmanager->AddProcess(msc, -1, 1, 1);
G4eIonisation* eIoni = new G4eIonisation();
eIoni->SetStepFunction(0.2, 100*um);
pmanager->AddProcess(eIoni, -1, 2, 2);
pmanager->AddProcess(new G4eBremsstrahlung, -1,-3, 3);
pmanager->AddProcess(new G4eplusAnnihilation,0,-1, 4);
} else if (particleName == "mu+" ||
particleName == "mu-" ) {
// Identical to G4EmStandardPhysics_option3
G4MuMultipleScattering* msc = new G4MuMultipleScattering();
msc->AddEmModel(0, new G4WentzelVIModel());
pmanager->AddProcess(msc, -1, 1, 1);
G4MuIonisation* muIoni = new G4MuIonisation();
muIoni->SetStepFunction(0.2, 50*um);
pmanager->AddProcess(muIoni, -1, 2, 2);
pmanager->AddProcess(new G4MuBremsstrahlung, -1,-3, 3);
pmanager->AddProcess(new G4MuPairProduction, -1,-4, 4);
pmanager->AddDiscreteProcess(new G4CoulombScattering());
} else if (particleName == "GenericIon") {
pmanager->AddProcess(new G4hMultipleScattering, -1, 1, 1);
G4ionIonisation* ionIoni = new G4ionIonisation();
ionIoni->SetEmModel(new G4IonParametrisedLossModel());
ionIoni->SetStepFunction(0.1, 10*um);
pmanager->AddProcess(ionIoni, -1, 2, 2);
pmanager->AddProcess(new G4NuclearStopping(), -1, 3,-1);
} else if (particleName == "alpha" ||
particleName == "He3" ) {
// Identical to G4EmStandardPhysics_option3
pmanager->AddProcess(new G4hMultipleScattering, -1, 1, 1);
G4ionIonisation* ionIoni = new G4ionIonisation();
ionIoni->SetStepFunction(0.1, 20*um);
pmanager->AddProcess(ionIoni, -1, 2, 2);
pmanager->AddProcess(new G4NuclearStopping(), -1, 3,-1);
} else if (particleName == "pi+" ||
particleName == "pi-" ||
particleName == "kaon+" ||
particleName == "kaon-" ||
particleName == "proton" ) {
// Identical to G4EmStandardPhysics_option3
pmanager->AddProcess(new G4hMultipleScattering, -1, 1, 1);
G4hIonisation* hIoni = new G4hIonisation();
hIoni->SetStepFunction(0.2, 50*um);
pmanager->AddProcess(hIoni, -1, 2, 2);
pmanager->AddProcess(new G4hBremsstrahlung, -1,-3, 3);
pmanager->AddProcess(new G4hPairProduction, -1,-4, 4);
} else if (particleName == "B+" ||
particleName == "B-" ||
particleName == "D+" ||
particleName == "D-" ||
particleName == "Ds+" ||
particleName == "Ds-" ||
particleName == "anti_lambda_c+" ||
particleName == "anti_omega-" ||
particleName == "anti_proton" ||
particleName == "anti_sigma_c+" ||
particleName == "anti_sigma_c++" ||
particleName == "anti_sigma+" ||
particleName == "anti_sigma-" ||
particleName == "anti_xi_c+" ||
particleName == "anti_xi-" ||
particleName == "deuteron" ||
particleName == "lambda_c+" ||
particleName == "omega-" ||
particleName == "sigma_c+" ||
particleName == "sigma_c++" ||
particleName == "sigma+" ||
particleName == "sigma-" ||
particleName == "tau+" ||
particleName == "tau-" ||
particleName == "triton" ||
particleName == "xi_c+" ||
particleName == "xi-" ) {
// Identical to G4EmStandardPhysics_option3
pmanager->AddProcess(new G4hMultipleScattering, -1, 1, 1);
pmanager->AddProcess(new G4hIonisation, -1, 2, 2);
}
}
// Em options
//
G4EmProcessOptions opt;
opt.SetVerbose(verbose);
// Multiple Coulomb scattering
//
//opt.SetMscStepLimitation(fUseDistanceToBoundary);
//opt.SetMscRangeFactor(0.02);
// Physics tables
//
opt.SetMinEnergy(100*eV);
opt.SetMaxEnergy(10*TeV);
opt.SetDEDXBinning(220);
opt.SetLambdaBinning(220);
//opt.SetSplineFlag(true);
opt.SetPolarAngleLimit(0.2);
// Ionization
//
//opt.SetSubCutoff(true);
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
source/physics_lists/builders/src/G4EmLivermorePolarizedPhysics.cc
+368
View File
@@ -0,0 +1,368 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4EmLivermorePolarizedPhysics.cc,v 1.6 2009/11/24 12:53:22 vnivanch Exp $
// GEANT4 tag $Name: geant4-09-03 $
#include "G4EmLivermorePolarizedPhysics.hh"
#include "G4ParticleDefinition.hh"
#include "G4ProcessManager.hh"
// *** Processes and models
// gamma
#include "G4PhotoElectricEffect.hh"
#include "G4LivermorePhotoElectricModel.hh"
#include "G4ComptonScattering.hh"
#include "G4LivermorePolarizedComptonModel.hh"
#include "G4GammaConversion.hh"
#include "G4LivermoreGammaConversionModel.hh"
#include "G4RayleighScattering.hh"
#include "G4LivermorePolarizedRayleighModel.hh"
// e-
#include "G4eMultipleScattering.hh"
#include "G4UniversalFluctuation.hh"
#include "G4eIonisation.hh"
#include "G4LivermoreIonisationModel.hh"
#include "G4eBremsstrahlung.hh"
#include "G4LivermoreBremsstrahlungModel.hh"
// e+
#include "G4eplusAnnihilation.hh"
// mu
#include "G4MuMultipleScattering.hh"
#include "G4MuIonisation.hh"
#include "G4MuBremsstrahlung.hh"
#include "G4MuPairProduction.hh"
// hadrons
#include "G4hMultipleScattering.hh"
#include "G4MscStepLimitType.hh"
#include "G4hBremsstrahlung.hh"
#include "G4hPairProduction.hh"
#include "G4hIonisation.hh"
#include "G4ionIonisation.hh"
#include "G4IonParametrisedLossModel.hh"
#include "G4NuclearStopping.hh"
// msc models
#include "G4UrbanMscModel93.hh"
#include "G4WentzelVIModel.hh"
#include "G4CoulombScattering.hh"
//
#include "G4LossTableManager.hh"
#include "G4EmProcessOptions.hh"
// particles
#include "G4Gamma.hh"
#include "G4Electron.hh"
#include "G4Positron.hh"
#include "G4MuonPlus.hh"
#include "G4MuonMinus.hh"
#include "G4PionPlus.hh"
#include "G4PionMinus.hh"
#include "G4KaonPlus.hh"
#include "G4KaonMinus.hh"
#include "G4Proton.hh"
#include "G4AntiProton.hh"
#include "G4Deuteron.hh"
#include "G4Triton.hh"
#include "G4He3.hh"
#include "G4Alpha.hh"
#include "G4GenericIon.hh"
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
G4EmLivermorePolarizedPhysics::G4EmLivermorePolarizedPhysics(
G4int ver, const G4String& name)
: G4VPhysicsConstructor(name), verbose(ver)
{
G4LossTableManager::Instance();
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
G4EmLivermorePolarizedPhysics::~G4EmLivermorePolarizedPhysics()
{}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void G4EmLivermorePolarizedPhysics::ConstructParticle()
{
// gamma
G4Gamma::Gamma();
// leptons
G4Electron::Electron();
G4Positron::Positron();
G4MuonPlus::MuonPlus();
G4MuonMinus::MuonMinus();
// mesons
G4PionPlus::PionPlusDefinition();
G4PionMinus::PionMinusDefinition();
G4KaonPlus::KaonPlusDefinition();
G4KaonMinus::KaonMinusDefinition();
// baryons
G4Proton::Proton();
G4AntiProton::AntiProton();
// ions
G4Deuteron::Deuteron();
G4Triton::Triton();
G4He3::He3();
G4Alpha::Alpha();
G4GenericIon::GenericIonDefinition();
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void G4EmLivermorePolarizedPhysics::ConstructProcess()
{
// Add Livermore EM Processes
theParticleIterator->reset();
while( (*theParticleIterator)() ){
G4ParticleDefinition* particle = theParticleIterator->value();
G4ProcessManager* pmanager = particle->GetProcessManager();
G4String particleName = particle->GetParticleName();
if(verbose > 1)
G4cout << "### " << GetPhysicsName() << " instantiates for "
<< particleName << G4endl;
//Applicability range for Livermore models
//for higher energies, the Standard models are used
G4double LivermoreHighEnergyLimit = GeV;
if (particleName == "gamma") {
G4PhotoElectricEffect* thePhotoElectricEffect = new G4PhotoElectricEffect();
G4LivermorePhotoElectricModel* theLivermorePhotoElectricModel = new G4LivermorePhotoElectricModel();
theLivermorePhotoElectricModel->SetHighEnergyLimit(LivermoreHighEnergyLimit);
thePhotoElectricEffect->AddEmModel(0, theLivermorePhotoElectricModel);
pmanager->AddDiscreteProcess(thePhotoElectricEffect);
G4ComptonScattering* theComptonScattering = new G4ComptonScattering();
G4LivermorePolarizedComptonModel* theLivermoreComptonModel = new G4LivermorePolarizedComptonModel();
theLivermoreComptonModel->SetHighEnergyLimit(LivermoreHighEnergyLimit);
theComptonScattering->AddEmModel(0, theLivermoreComptonModel);
pmanager->AddDiscreteProcess(theComptonScattering);
G4GammaConversion* theGammaConversion = new G4GammaConversion();
G4LivermoreGammaConversionModel* theLivermoreGammaConversionModel = new G4LivermoreGammaConversionModel();
theLivermoreGammaConversionModel->SetHighEnergyLimit(LivermoreHighEnergyLimit);
theGammaConversion->AddEmModel(0, theLivermoreGammaConversionModel);
pmanager->AddDiscreteProcess(theGammaConversion);
G4RayleighScattering* theRayleigh = new G4RayleighScattering();
G4LivermorePolarizedRayleighModel* theRayleighModel = new G4LivermorePolarizedRayleighModel();
theRayleighModel->SetHighEnergyLimit(LivermoreHighEnergyLimit);
theRayleigh->AddEmModel(0, theRayleighModel);
pmanager->AddDiscreteProcess(theRayleigh);
} else if (particleName == "e-") {
G4eMultipleScattering* msc = new G4eMultipleScattering();
msc->AddEmModel(0, new G4UrbanMscModel93());
msc->SetStepLimitType(fUseDistanceToBoundary);
pmanager->AddProcess(msc, -1, 1, 1);
// Ionisation
G4eIonisation* eIoni = new G4eIonisation();
G4LivermoreIonisationModel* theIoniLivermore = new
G4LivermoreIonisationModel();
theIoniLivermore->SetHighEnergyLimit(LivermoreHighEnergyLimit);
eIoni->AddEmModel(0, theIoniLivermore, new G4UniversalFluctuation() );
eIoni->SetStepFunction(0.2, 100*um); //
pmanager->AddProcess(eIoni, -1, 2, 2);
// Bremsstrahlung
G4eBremsstrahlung* eBrem = new G4eBremsstrahlung();
G4LivermoreBremsstrahlungModel* theBremLivermore = new
G4LivermoreBremsstrahlungModel();
theBremLivermore->SetHighEnergyLimit(LivermoreHighEnergyLimit);
eBrem->AddEmModel(0, theBremLivermore);
pmanager->AddProcess(eBrem, -1,-3, 3);
} else if (particleName == "e+") {
// Identical to G4EmStandardPhysics_option3
G4eMultipleScattering* msc = new G4eMultipleScattering();
msc->AddEmModel(0, new G4UrbanMscModel93());
msc->SetStepLimitType(fUseDistanceToBoundary);
pmanager->AddProcess(msc, -1, 1, 1);
G4eIonisation* eIoni = new G4eIonisation();
eIoni->SetStepFunction(0.2, 100*um);
pmanager->AddProcess(eIoni, -1, 2, 2);
pmanager->AddProcess(new G4eBremsstrahlung, -1,-3, 3);
pmanager->AddProcess(new G4eplusAnnihilation,0,-1, 4);
} else if (particleName == "mu+" ||
particleName == "mu-" ) {
// Identical to G4EmStandardPhysics_option3
G4MuMultipleScattering* msc = new G4MuMultipleScattering();
msc->AddEmModel(0, new G4WentzelVIModel());
pmanager->AddProcess(msc, -1, 1, 1);
G4MuIonisation* muIoni = new G4MuIonisation();
muIoni->SetStepFunction(0.2, 50*um);
pmanager->AddProcess(muIoni, -1, 2, 2);
pmanager->AddProcess(new G4MuBremsstrahlung, -1,-3, 3);
pmanager->AddProcess(new G4MuPairProduction, -1,-4, 4);
pmanager->AddDiscreteProcess(new G4CoulombScattering());
} else if (particleName == "GenericIon") {
pmanager->AddProcess(new G4hMultipleScattering, -1, 1, 1);
G4ionIonisation* ionIoni = new G4ionIonisation();
ionIoni->SetEmModel(new G4IonParametrisedLossModel());
ionIoni->SetStepFunction(0.1, 10*um);
pmanager->AddProcess(ionIoni, -1, 2, 2);
pmanager->AddProcess(new G4NuclearStopping(), -1, 3,-1);
} else if (particleName == "alpha" ||
particleName == "He3" ) {
// Identical to G4EmStandardPhysics_option3
pmanager->AddProcess(new G4hMultipleScattering, -1, 1, 1);
G4ionIonisation* ionIoni = new G4ionIonisation();
ionIoni->SetStepFunction(0.1, 20*um);
pmanager->AddProcess(ionIoni, -1, 2, 2);
pmanager->AddProcess(new G4NuclearStopping(), -1, 3,-1);
} else if (particleName == "pi+" ||
particleName == "pi-" ||
particleName == "proton" ) {
// Identical to G4EmStandardPhysics_option3
pmanager->AddProcess(new G4hMultipleScattering, -1, 1, 1);
G4hIonisation* hIoni = new G4hIonisation();
hIoni->SetStepFunction(0.2, 50*um);
pmanager->AddProcess(hIoni, -1, 2, 2);
pmanager->AddProcess(new G4hBremsstrahlung, -1,-3, 3);
pmanager->AddProcess(new G4hPairProduction, -1,-4, 4);
} else if (particleName == "B+" ||
particleName == "B-" ||
particleName == "D+" ||
particleName == "D-" ||
particleName == "Ds+" ||
particleName == "Ds-" ||
particleName == "anti_lambda_c+" ||
particleName == "anti_omega-" ||
particleName == "anti_proton" ||
particleName == "anti_sigma_c+" ||
particleName == "anti_sigma_c++" ||
particleName == "anti_sigma+" ||
particleName == "anti_sigma-" ||
particleName == "anti_xi_c+" ||
particleName == "anti_xi-" ||
particleName == "deuteron" ||
particleName == "kaon+" ||
particleName == "kaon-" ||
particleName == "lambda_c+" ||
particleName == "omega-" ||
particleName == "sigma_c+" ||
particleName == "sigma_c++" ||
particleName == "sigma+" ||
particleName == "sigma-" ||
particleName == "tau+" ||
particleName == "tau-" ||
particleName == "triton" ||
particleName == "xi_c+" ||
particleName == "xi-" ) {
// Identical to G4EmStandardPhysics_option3
pmanager->AddProcess(new G4hMultipleScattering, -1, 1, 1);
pmanager->AddProcess(new G4hIonisation, -1, 2, 2);
}
}
// Em options
//
G4EmProcessOptions opt;
opt.SetVerbose(verbose);
// Multiple Coulomb scattering
//
//opt.SetMscStepLimitation(fUseDistanceToBoundary);
//opt.SetMscRangeFactor(0.02);
// Physics tables
//
opt.SetMinEnergy(100*eV);
opt.SetMaxEnergy(10*TeV);
opt.SetDEDXBinning(220);
opt.SetLambdaBinning(220);
//opt.SetSplineFlag(true);
opt.SetPolarAngleLimit(0.2);
// Ionization
//
//opt.SetSubCutoff(true);
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
source/physics_lists/builders/src/G4EmPenelopePhysics.cc
+389
View File
@@ -0,0 +1,389 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4EmPenelopePhysics.cc,v 1.7 2009/11/24 12:53:22 vnivanch Exp $
// GEANT4 tag $Name: geant4-09-03 $
#include "G4EmPenelopePhysics.hh"
#include "G4ParticleDefinition.hh"
#include "G4ProcessManager.hh"
// *** Processes and models
// gamma
#include "G4PhotoElectricEffect.hh"
#include "G4PenelopePhotoElectricModel.hh"
#include "G4ComptonScattering.hh"
#include "G4PenelopeComptonModel.hh"
#include "G4GammaConversion.hh"
#include "G4PenelopeGammaConversionModel.hh"
#include "G4RayleighScattering.hh"
#include "G4PenelopeRayleighModel.hh"
// e- and e+
#include "G4eMultipleScattering.hh"
#include "G4UniversalFluctuation.hh"
#include "G4eIonisation.hh"
#include "G4PenelopeIonisationModel.hh"
#include "G4eBremsstrahlung.hh"
#include "G4PenelopeBremsstrahlungModel.hh"
// e+ only
#include "G4eplusAnnihilation.hh"
#include "G4PenelopeAnnihilationModel.hh"
// mu
#include "G4MuMultipleScattering.hh"
#include "G4MuIonisation.hh"
#include "G4MuBremsstrahlung.hh"
#include "G4MuPairProduction.hh"
// hadrons
#include "G4hMultipleScattering.hh"
#include "G4MscStepLimitType.hh"
#include "G4hBremsstrahlung.hh"
#include "G4hPairProduction.hh"
#include "G4hIonisation.hh"
#include "G4ionIonisation.hh"
#include "G4IonParametrisedLossModel.hh"
#include "G4NuclearStopping.hh"
// msc models
#include "G4UrbanMscModel93.hh"
#include "G4WentzelVIModel.hh"
#include "G4CoulombScattering.hh"
//
#include "G4LossTableManager.hh"
#include "G4EmProcessOptions.hh"
// particles
#include "G4Gamma.hh"
#include "G4Electron.hh"
#include "G4Positron.hh"
#include "G4MuonPlus.hh"
#include "G4MuonMinus.hh"
#include "G4PionPlus.hh"
#include "G4PionMinus.hh"
#include "G4KaonPlus.hh"
#include "G4KaonMinus.hh"
#include "G4Proton.hh"
#include "G4AntiProton.hh"
#include "G4Deuteron.hh"
#include "G4Triton.hh"
#include "G4He3.hh"
#include "G4Alpha.hh"
#include "G4GenericIon.hh"
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
G4EmPenelopePhysics::G4EmPenelopePhysics(
G4int ver, const G4String& name)
: G4VPhysicsConstructor(name), verbose(ver)
{
G4LossTableManager::Instance();
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
G4EmPenelopePhysics::~G4EmPenelopePhysics()
{}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void G4EmPenelopePhysics::ConstructParticle()
{
// gamma
G4Gamma::Gamma();
// leptons
G4Electron::Electron();
G4Positron::Positron();
G4MuonPlus::MuonPlus();
G4MuonMinus::MuonMinus();
// mesons
G4PionPlus::PionPlusDefinition();
G4PionMinus::PionMinusDefinition();
G4KaonPlus::KaonPlusDefinition();
G4KaonMinus::KaonMinusDefinition();
// baryons
G4Proton::Proton();
G4AntiProton::AntiProton();
// ions
G4Deuteron::Deuteron();
G4Triton::Triton();
G4He3::He3();
G4Alpha::Alpha();
G4GenericIon::GenericIonDefinition();
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void G4EmPenelopePhysics::ConstructProcess()
{
// Add Penelope EM Processes
theParticleIterator->reset();
while( (*theParticleIterator)() ){
G4ParticleDefinition* particle = theParticleIterator->value();
G4ProcessManager* pmanager = particle->GetProcessManager();
G4String particleName = particle->GetParticleName();
if(verbose > 1)
G4cout << "### " << GetPhysicsName() << " instantiates for "
<< particleName << G4endl;
//Applicability range for Penelope models
//for higher energies, the Standard models are used
G4double PenelopeHighEnergyLimit = 1.0*GeV;
if (particleName == "gamma") {
//Photo-electric effect
G4PhotoElectricEffect* thePhotoElectricEffect = new G4PhotoElectricEffect();
G4PenelopePhotoElectricModel* thePEPenelopeModel = new
G4PenelopePhotoElectricModel();
thePEPenelopeModel->SetHighEnergyLimit(PenelopeHighEnergyLimit);
thePhotoElectricEffect->AddEmModel(0,thePEPenelopeModel);
pmanager->AddDiscreteProcess(thePhotoElectricEffect);
//Compton scattering
G4ComptonScattering* theComptonScattering = new G4ComptonScattering();
G4PenelopeComptonModel* theComptonPenelopeModel =
new G4PenelopeComptonModel();
theComptonPenelopeModel->SetHighEnergyLimit(PenelopeHighEnergyLimit);
theComptonScattering->AddEmModel(0,theComptonPenelopeModel);
pmanager->AddDiscreteProcess(theComptonScattering);
//Gamma conversion
G4GammaConversion* theGammaConversion = new G4GammaConversion();
G4PenelopeGammaConversionModel* theGCPenelopeModel =
new G4PenelopeGammaConversionModel();
theGammaConversion->AddEmModel(0,theGCPenelopeModel);
pmanager->AddDiscreteProcess(theGammaConversion);
//Rayleigh scattering
G4RayleighScattering* theRayleigh = new G4RayleighScattering();
G4PenelopeRayleighModel* theRayleighPenelopeModel =
new G4PenelopeRayleighModel();
theRayleighPenelopeModel->SetHighEnergyLimit(PenelopeHighEnergyLimit);
theRayleigh->AddEmModel(0,theRayleighPenelopeModel);
pmanager->AddDiscreteProcess(theRayleigh);
} else if (particleName == "e-") {
G4eMultipleScattering* msc = new G4eMultipleScattering();
msc->AddEmModel(0, new G4UrbanMscModel93());
msc->SetStepLimitType(fUseDistanceToBoundary);
pmanager->AddProcess(msc, -1, 1, 1);
//Ionisation
G4eIonisation* eIoni = new G4eIonisation();
G4PenelopeIonisationModel* theIoniPenelope =
new G4PenelopeIonisationModel();
theIoniPenelope->SetHighEnergyLimit(PenelopeHighEnergyLimit);
eIoni->AddEmModel(0,theIoniPenelope,new G4UniversalFluctuation());
eIoni->SetStepFunction(0.2, 100*um); //
pmanager->AddProcess(eIoni, -1, 2, 2);
//Bremsstrahlung
G4eBremsstrahlung* eBrem = new G4eBremsstrahlung();
G4PenelopeBremsstrahlungModel* theBremPenelope = new
G4PenelopeBremsstrahlungModel();
theBremPenelope->SetHighEnergyLimit(PenelopeHighEnergyLimit);
eBrem->AddEmModel(0,theBremPenelope);
pmanager->AddProcess(eBrem, -1,-3, 3);
} else if (particleName == "e+") {
G4eMultipleScattering* msc = new G4eMultipleScattering();
msc->AddEmModel(0, new G4UrbanMscModel93());
msc->SetStepLimitType(fUseDistanceToBoundary);
pmanager->AddProcess(msc, -1, 1, 1);
//Ionisation
G4eIonisation* eIoni = new G4eIonisation();
G4PenelopeIonisationModel* theIoniPenelope =
new G4PenelopeIonisationModel();
theIoniPenelope->SetHighEnergyLimit(PenelopeHighEnergyLimit);
eIoni->AddEmModel(0,theIoniPenelope,new G4UniversalFluctuation());
eIoni->SetStepFunction(0.2, 100*um); //
pmanager->AddProcess(eIoni, -1, 2, 2);
//Bremsstrahlung
G4eBremsstrahlung* eBrem = new G4eBremsstrahlung();
G4PenelopeBremsstrahlungModel* theBremPenelope = new
G4PenelopeBremsstrahlungModel();
theBremPenelope->SetHighEnergyLimit(PenelopeHighEnergyLimit);
eBrem->AddEmModel(0,theBremPenelope);
pmanager->AddProcess(eBrem, -1,-3, 3);
//Annihilation
G4eplusAnnihilation* eAnni = new G4eplusAnnihilation();
G4PenelopeAnnihilationModel* theAnnPenelope = new
G4PenelopeAnnihilationModel();
theAnnPenelope->SetHighEnergyLimit(PenelopeHighEnergyLimit);
eAnni->AddEmModel(0,theAnnPenelope);
pmanager->AddProcess(eAnni,0,-1, 4);
} else if (particleName == "mu+" ||
particleName == "mu-" ) {
// Identical to G4EmStandardPhysics_option3
G4MuMultipleScattering* msc = new G4MuMultipleScattering();
msc->AddEmModel(0, new G4WentzelVIModel());
pmanager->AddProcess(msc, -1, 1, 1);
G4MuIonisation* muIoni = new G4MuIonisation();
muIoni->SetStepFunction(0.2, 50*um);
pmanager->AddProcess(muIoni, -1, 2, 2);
pmanager->AddProcess(new G4MuBremsstrahlung, -1,-3, 3);
pmanager->AddProcess(new G4MuPairProduction, -1,-4, 4);
pmanager->AddDiscreteProcess(new G4CoulombScattering());
} else if (particleName == "GenericIon") {
pmanager->AddProcess(new G4hMultipleScattering, -1, 1, 1);
G4ionIonisation* ionIoni = new G4ionIonisation();
ionIoni->SetEmModel(new G4IonParametrisedLossModel());
ionIoni->SetStepFunction(0.1, 10*um);
pmanager->AddProcess(ionIoni, -1, 2, 2);
pmanager->AddProcess(new G4NuclearStopping(), -1, 3,-1);
} else if (particleName == "alpha" ||
particleName == "He3" ) {
// Identical to G4EmStandardPhysics_option3
pmanager->AddProcess(new G4hMultipleScattering, -1, 1, 1);
G4ionIonisation* ionIoni = new G4ionIonisation();
ionIoni->SetStepFunction(0.1, 20*um);
pmanager->AddProcess(ionIoni, -1, 2, 2);
pmanager->AddProcess(new G4NuclearStopping(), -1, 3,-1);
} else if (particleName == "pi+" ||
particleName == "pi-" ||
particleName == "kaon+" ||
particleName == "kaon-" ||
particleName == "proton" ) {
// Identical to G4EmStandardPhysics_option3
pmanager->AddProcess(new G4hMultipleScattering, -1, 1, 1);
G4hIonisation* hIoni = new G4hIonisation();
hIoni->SetStepFunction(0.2, 50*um);
pmanager->AddProcess(hIoni, -1, 2, 2);
pmanager->AddProcess(new G4hBremsstrahlung, -1,-3, 3);
pmanager->AddProcess(new G4hPairProduction, -1,-4, 4);
} else if (particleName == "B+" ||
particleName == "B-" ||
particleName == "D+" ||
particleName == "D-" ||
particleName == "Ds+" ||
particleName == "Ds-" ||
particleName == "anti_lambda_c+" ||
particleName == "anti_omega-" ||
particleName == "anti_proton" ||
particleName == "anti_sigma_c+" ||
particleName == "anti_sigma_c++" ||
particleName == "anti_sigma+" ||
particleName == "anti_sigma-" ||
particleName == "anti_xi_c+" ||
particleName == "anti_xi-" ||
particleName == "deuteron" ||
particleName == "lambda_c+" ||
particleName == "omega-" ||
particleName == "sigma_c+" ||
particleName == "sigma_c++" ||
particleName == "sigma+" ||
particleName == "sigma-" ||
particleName == "tau+" ||
particleName == "tau-" ||
particleName == "triton" ||
particleName == "xi_c+" ||
particleName == "xi-" ) {
// Identical to G4EmStandardPhysics_option3
pmanager->AddProcess(new G4hMultipleScattering, -1, 1, 1);
pmanager->AddProcess(new G4hIonisation, -1, 2, 2);
}
}
// Em options
//
G4EmProcessOptions opt;
opt.SetVerbose(verbose);
// Multiple Coulomb scattering
//
//opt.SetMscStepLimitation(fUseDistanceToBoundary);
//opt.SetMscRangeFactor(0.02);
// Physics tables
//
opt.SetMinEnergy(100*eV);
opt.SetMaxEnergy(10*TeV);
opt.SetDEDXBinning(220);
opt.SetLambdaBinning(220);
//opt.SetSplineFlag(true);
opt.SetPolarAngleLimit(0.2);
// Ionization
//
//opt.SetSubCutoff(true);
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
source/physics_lists/builders/src/G4EmStandardPhysics.cc
+23 -19
View File
@@ -23,8 +23,8 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4EmStandardPhysics.cc,v 1.16 2008/11/21 16:50:30 vnivanch Exp $
// GEANT4 tag $Name: geant4-09-02 $
// $Id: G4EmStandardPhysics.cc,v 1.20 2009/10/30 18:36:15 vnivanch Exp $
// GEANT4 tag $Name: geant4-09-03 $
//
//---------------------------------------------------------------------------
//
@@ -53,9 +53,9 @@
#include "G4GammaConversion.hh"
#include "G4PhotoElectricEffect.hh"
#include "G4MultipleScattering.hh"
#include "G4hMultipleScattering.hh"
#include "G4eMultipleScattering.hh"
#include "G4MuMultipleScattering.hh"
#include "G4hMultipleScattering.hh"
#include "G4eIonisation.hh"
#include "G4eBremsstrahlung.hh"
@@ -154,34 +154,40 @@ void G4EmStandardPhysics::ConstructProcess()
} else if (particleName == "e-") {
pmanager->AddProcess(new G4eMultipleScattering,-1, 1, 1);
pmanager->AddProcess(new G4eIonisation, -1, 2, 2);
pmanager->AddProcess(new G4eBremsstrahlung(), -1,-3, 3);
pmanager->AddProcess(new G4eMultipleScattering(), -1, 1, 1);
pmanager->AddProcess(new G4eIonisation, -1, 2, 2);
pmanager->AddProcess(new G4eBremsstrahlung(), -1,-3, 3);
} else if (particleName == "e+") {
pmanager->AddProcess(new G4eMultipleScattering,-1, 1, 1);
pmanager->AddProcess(new G4eIonisation, -1, 2, 2);
pmanager->AddProcess(new G4eBremsstrahlung, -1,-3, 3);
pmanager->AddProcess(new G4eplusAnnihilation, 0,-1, 4);
pmanager->AddProcess(new G4eMultipleScattering(), -1, 1, 1);
pmanager->AddProcess(new G4eIonisation, -1, 2, 2);
pmanager->AddProcess(new G4eBremsstrahlung, -1,-3, 3);
pmanager->AddProcess(new G4eplusAnnihilation, 0,-1, 4);
} else if (particleName == "mu+" ||
particleName == "mu-" ) {
pmanager->AddProcess(new G4hMultipleScattering,-1, 1, 1);
pmanager->AddProcess(new G4MuIonisation, -1, 2, 2);
pmanager->AddProcess(new G4MuBremsstrahlung, -1,-3, 3);
pmanager->AddProcess(new G4MuPairProduction, -1,-4, 4);
pmanager->AddProcess(new G4MuMultipleScattering,-1, 1, 1);
pmanager->AddProcess(new G4MuIonisation, -1, 2, 2);
pmanager->AddProcess(new G4MuBremsstrahlung, -1,-3, 3);
pmanager->AddProcess(new G4MuPairProduction, -1,-4, 4);
} else if (particleName == "alpha" ||
particleName == "He3" ||
particleName == "GenericIon") {
particleName == "He3") {
pmanager->AddProcess(new G4hMultipleScattering, -1, 1, 1);
pmanager->AddProcess(new G4ionIonisation, -1, 2, 2);
} else if (particleName == "GenericIon") {
pmanager->AddProcess(new G4hMultipleScattering, -1, 1, 1);
pmanager->AddProcess(new G4ionIonisation, -1, 2, 2);
} else if (particleName == "pi+" ||
particleName == "pi-" ||
particleName == "kaon+" ||
particleName == "kaon-" ||
particleName == "proton" ) {
pmanager->AddProcess(new G4hMultipleScattering, -1, 1, 1);
@@ -205,8 +211,6 @@ void G4EmStandardPhysics::ConstructProcess()
particleName == "anti_xi_c+" ||
particleName == "anti_xi-" ||
particleName == "deuteron" ||
particleName == "kaon+" ||
particleName == "kaon-" ||
particleName == "lambda_c+" ||
particleName == "omega-" ||
particleName == "sigma_c+" ||
source/physics_lists/builders/src/G4EmStandardPhysics_option1.cc
+13 -9
View File
@@ -23,8 +23,8 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4EmStandardPhysics_option1.cc,v 1.11 2008/11/21 16:50:30 vnivanch Exp $
// GEANT4 tag $Name: geant4-09-02 $
// $Id: G4EmStandardPhysics_option1.cc,v 1.15 2009/10/30 18:36:15 vnivanch Exp $
// GEANT4 tag $Name: geant4-09-03 $
//
//---------------------------------------------------------------------------
//
@@ -56,8 +56,8 @@
#include "G4PhotoElectricEffect.hh"
#include "G4eMultipleScattering.hh"
#include "G4MuMultipleScattering.hh"
#include "G4hMultipleScattering.hh"
#include "G4MultipleScattering.hh"
#include "G4MscStepLimitType.hh"
#include "G4eIonisation.hh"
@@ -180,20 +180,26 @@ void G4EmStandardPhysics_option1::ConstructProcess()
} else if (particleName == "mu+" ||
particleName == "mu-" ) {
pmanager->AddProcess(new G4hMultipleScattering, -1, 1, 1);
pmanager->AddProcess(new G4MuMultipleScattering,-1, 1, 1);
pmanager->AddProcess(new G4MuIonisation, -1, 2, 2);
pmanager->AddProcess(new G4MuBremsstrahlung, -1,-3, 3);
pmanager->AddProcess(new G4MuPairProduction, -1,-4, 4);
} else if (particleName == "alpha" ||
particleName == "He3" ||
particleName == "GenericIon") {
particleName == "He3") {
pmanager->AddProcess(new G4hMultipleScattering, -1, 1, 1);
pmanager->AddProcess(new G4ionIonisation, -1, 2, 2);
} else if (particleName == "GenericIon") {
pmanager->AddProcess(new G4hMultipleScattering, -1, 1, 1);
pmanager->AddProcess(new G4ionIonisation, -1, 2, 2);
} else if (particleName == "pi+" ||
particleName == "pi-" ||
particleName == "kaon+" ||
particleName == "kaon-" ||
particleName == "proton" ) {
pmanager->AddProcess(new G4hMultipleScattering, -1, 1, 1);
@@ -217,8 +223,6 @@ void G4EmStandardPhysics_option1::ConstructProcess()
particleName == "anti_xi_c+" ||
particleName == "anti_xi-" ||
particleName == "deuteron" ||
particleName == "kaon+" ||
particleName == "kaon-" ||
particleName == "lambda_c+" ||
particleName == "omega-" ||
particleName == "sigma_c+" ||
@@ -237,7 +241,7 @@ void G4EmStandardPhysics_option1::ConstructProcess()
}
G4EmProcessOptions opt;
opt.SetVerbose(verbose);
//opt.SetApplyCuts(true);
opt.SetApplyCuts(true);
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
source/physics_lists/builders/src/G4EmStandardPhysics_option2.cc
+38 -22
View File
@@ -23,8 +23,8 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4EmStandardPhysics_option2.cc,v 1.15 2008/11/21 17:59:23 vnivanch Exp $
// GEANT4 tag $Name: geant4-09-02 $
// $Id: G4EmStandardPhysics_option2.cc,v 1.20 2009/11/24 12:53:22 vnivanch Exp $
// GEANT4 tag $Name: geant4-09-03 $
//
//---------------------------------------------------------------------------
//
@@ -61,6 +61,9 @@
#include "G4hMultipleScattering.hh"
#include "G4MuMultipleScattering.hh"
#include "G4CoulombScattering.hh"
#include "G4UrbanMscModel93.hh"
#include "G4WentzelVIModel.hh"
//#include "G4GoudsmitSaundersonMscModel.hh"
#include "G4eIonisation.hh"
#include "G4eBremsstrahlung.hh"
@@ -74,6 +77,7 @@
#include "G4hIonisation.hh"
#include "G4ionIonisation.hh"
//#include "G4IonParametrisedLossModel.hh"
#include "G4Gamma.hh"
#include "G4Electron.hh"
@@ -160,13 +164,19 @@ void G4EmStandardPhysics_option2::ConstructProcess()
} else if (particleName == "e-") {
pmanager->AddProcess(new G4eMultipleScattering, -1, 1, 1);
G4eMultipleScattering* msc = new G4eMultipleScattering();
msc->AddEmModel(0, new G4UrbanMscModel93());
// msc->AddEmModel(0, new G4GoudsmitSaundersonMscModel());
pmanager->AddProcess(msc, -1, 1, 1);
pmanager->AddProcess(new G4eIonisation, -1, 2, 2);
pmanager->AddProcess(new G4eBremsstrahlung, -1,-3, 3);
} else if (particleName == "e+") {
pmanager->AddProcess(new G4eMultipleScattering, -1, 1, 1);
G4eMultipleScattering* msc = new G4eMultipleScattering();
msc->AddEmModel(0, new G4UrbanMscModel93());
// msc->AddEmModel(0, new G4GoudsmitSaundersonMscModel());
pmanager->AddProcess(msc, -1, 1, 1);
pmanager->AddProcess(new G4eIonisation, -1, 2, 2);
pmanager->AddProcess(new G4eBremsstrahlung, -1,-3, 3);
pmanager->AddProcess(new G4eplusAnnihilation, 0,-1, 4);
@@ -174,24 +184,36 @@ void G4EmStandardPhysics_option2::ConstructProcess()
} else if (particleName == "mu+" ||
particleName == "mu-" ) {
pmanager->AddProcess(new G4MuMultipleScattering,-1, 1, 1);
pmanager->AddProcess(new G4MuIonisation, -1, 2, 2);
pmanager->AddProcess(new G4MuBremsstrahlung, -1,-3, 3);
pmanager->AddProcess(new G4MuPairProduction, -1,-4, 4);
G4MuMultipleScattering* msc = new G4MuMultipleScattering();
msc->AddEmModel(0, new G4WentzelVIModel());
pmanager->AddProcess(msc, -1, 1, 1);
pmanager->AddProcess(new G4MuIonisation, -1, 2, 2);
pmanager->AddProcess(new G4MuBremsstrahlung, -1,-3, 3);
pmanager->AddProcess(new G4MuPairProduction, -1,-4, 4);
pmanager->AddDiscreteProcess(new G4CoulombScattering());
} else if (particleName == "GenericIon") {
pmanager->AddProcess(new G4hMultipleScattering, -1, 1, 1);
G4ionIonisation* ionIoni = new G4ionIonisation();
//ionIoni->SetEmModel(new G4IonParametrisedLossModel());
//ionIoni->SetStepFunction(0.1, 20*um);
pmanager->AddProcess(ionIoni, -1, 2, 2);
} else if (particleName == "alpha" ||
particleName == "He3" ||
particleName == "GenericIon") {
particleName == "He3") {
pmanager->AddProcess(new G4hMultipleScattering, -1, 1, 1);
pmanager->AddProcess(new G4ionIonisation, -1, 2, 2);
} else if (particleName == "pi+" ||
particleName == "pi-" ||
particleName == "kaon+" ||
particleName == "kaon-" ||
particleName == "proton" ) {
pmanager->AddProcess(new G4MuMultipleScattering,-1, 1, 1);
pmanager->AddProcess(new G4hMultipleScattering, -1, 1, 1);
pmanager->AddProcess(new G4hIonisation, -1, 2, 2);
pmanager->AddProcess(new G4hBremsstrahlung, -1,-3, 3);
pmanager->AddProcess(new G4hPairProduction, -1,-4, 4);
@@ -212,8 +234,6 @@ void G4EmStandardPhysics_option2::ConstructProcess()
particleName == "anti_xi_c+" ||
particleName == "anti_xi-" ||
particleName == "deuteron" ||
particleName == "kaon+" ||
particleName == "kaon-" ||
particleName == "lambda_c+" ||
particleName == "omega-" ||
particleName == "sigma_c+" ||
@@ -239,17 +259,13 @@ void G4EmStandardPhysics_option2::ConstructProcess()
// Physics tables
//
//opt.SetMinEnergy(100*eV);
//opt.SetMaxEnergy(100*TeV);
//opt.SetDEDXBinning(84);
//opt.SetLambdaBinning(84);
//opt.SetMinEnergy(0.1*keV);
// opt.SetMaxEnergy(10*TeV);
//opt.SetDEDXBinning(77);
//opt.SetLambdaBinning(77);
//opt.SetSplineFlag(true);
opt.SetPolarAngleLimit(0.2);
// Energy loss
//
//opt.SetLinearLossLimit(0.01);
// Ionization
//
//opt.SetSubCutoff(true);
source/physics_lists/builders/src/G4EmStandardPhysics_option3.cc
+30 -9
View File
@@ -23,8 +23,8 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4EmStandardPhysics_option3.cc,v 1.14 2008/11/21 16:50:30 vnivanch Exp $
// GEANT4 tag $Name: geant4-09-02 $
// $Id: G4EmStandardPhysics_option3.cc,v 1.18 2009/11/24 12:53:22 vnivanch Exp $
// GEANT4 tag $Name: geant4-09-03 $
//
//---------------------------------------------------------------------------
//
@@ -49,11 +49,15 @@
#include "G4ComptonScattering.hh"
#include "G4GammaConversion.hh"
#include "G4PhotoElectricEffect.hh"
#include "G4LowEnergyRayleigh.hh"
#include "G4RayleighScattering.hh"
#include "G4eMultipleScattering.hh"
#include "G4MuMultipleScattering.hh"
#include "G4hMultipleScattering.hh"
#include "G4MscStepLimitType.hh"
#include "G4UrbanMscModel93.hh"
#include "G4WentzelVIModel.hh"
#include "G4CoulombScattering.hh"
#include "G4eIonisation.hh"
#include "G4eBremsstrahlung.hh"
@@ -67,6 +71,8 @@
#include "G4hIonisation.hh"
#include "G4ionIonisation.hh"
#include "G4IonParametrisedLossModel.hh"
#include "G4NuclearStopping.hh"
#include "G4Gamma.hh"
#include "G4Electron.hh"
@@ -147,14 +153,15 @@ void G4EmStandardPhysics_option3::ConstructProcess()
if (particleName == "gamma") {
pmanager->AddDiscreteProcess(new G4LowEnergyRayleigh);
pmanager->AddDiscreteProcess(new G4PhotoElectricEffect);
pmanager->AddDiscreteProcess(new G4ComptonScattering);
pmanager->AddDiscreteProcess(new G4GammaConversion);
pmanager->AddDiscreteProcess(new G4RayleighScattering);
} else if (particleName == "e-") {
G4eMultipleScattering* msc = new G4eMultipleScattering();
msc->AddEmModel(0, new G4UrbanMscModel93());
msc->SetStepLimitType(fUseDistanceToBoundary);
pmanager->AddProcess(msc, -1, 1, 1);
G4eIonisation* eIoni = new G4eIonisation();
@@ -165,6 +172,7 @@ void G4EmStandardPhysics_option3::ConstructProcess()
} else if (particleName == "e+") {
G4eMultipleScattering* msc = new G4eMultipleScattering();
msc->AddEmModel(0, new G4UrbanMscModel93());
msc->SetStepLimitType(fUseDistanceToBoundary);
pmanager->AddProcess(msc, -1, 1, 1);
G4eIonisation* eIoni = new G4eIonisation();
@@ -176,24 +184,38 @@ void G4EmStandardPhysics_option3::ConstructProcess()
} else if (particleName == "mu+" ||
particleName == "mu-" ) {
pmanager->AddProcess(new G4eMultipleScattering, -1, 1, 1);
G4MuMultipleScattering* msc = new G4MuMultipleScattering();
msc->AddEmModel(0, new G4WentzelVIModel());
pmanager->AddProcess(msc, -1, 1, 1);
G4MuIonisation* muIoni = new G4MuIonisation();
muIoni->SetStepFunction(0.2, 50*um);
pmanager->AddProcess(muIoni, -1, 2, 2);
pmanager->AddProcess(new G4MuBremsstrahlung, -1,-3, 3);
pmanager->AddProcess(new G4MuPairProduction, -1,-4, 4);
pmanager->AddDiscreteProcess(new G4CoulombScattering());
} else if (particleName == "alpha" ||
particleName == "He3" ||
particleName == "GenericIon") {
particleName == "He3") {
pmanager->AddProcess(new G4hMultipleScattering, -1, 1, 1);
G4ionIonisation* ionIoni = new G4ionIonisation();
ionIoni->SetStepFunction(0.1, 20*um);
pmanager->AddProcess(ionIoni, -1, 2, 2);
pmanager->AddProcess(new G4NuclearStopping(), -1, 3,-1);
} else if (particleName == "GenericIon") {
pmanager->AddProcess(new G4hMultipleScattering, -1, 1, 1);
G4ionIonisation* ionIoni = new G4ionIonisation();
ionIoni->SetEmModel(new G4IonParametrisedLossModel());
ionIoni->SetStepFunction(0.1, 10*um);
pmanager->AddProcess(ionIoni, -1, 2, 2);
pmanager->AddProcess(new G4NuclearStopping(), -1, 3,-1);
} else if (particleName == "pi+" ||
particleName == "pi-" ||
particleName == "kaon+" ||
particleName == "kaon-" ||
particleName == "proton" ) {
pmanager->AddProcess(new G4hMultipleScattering, -1, 1, 1);
@@ -219,8 +241,6 @@ void G4EmStandardPhysics_option3::ConstructProcess()
particleName == "anti_xi_c+" ||
particleName == "anti_xi-" ||
particleName == "deuteron" ||
particleName == "kaon+" ||
particleName == "kaon-" ||
particleName == "lambda_c+" ||
particleName == "omega-" ||
particleName == "sigma_c+" ||
@@ -255,6 +275,7 @@ void G4EmStandardPhysics_option3::ConstructProcess()
opt.SetDEDXBinning(220);
opt.SetLambdaBinning(220);
//opt.SetSplineFlag(true);
opt.SetPolarAngleLimit(0.2);
// Ionization
//
source/physics_lists/builders/src/G4FTFBinaryNeutronBuilder.cc
+17 -1
View File
@@ -23,10 +23,25 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4FTFBinaryNeutronBuilder.cc,v 1.4 2009/03/31 18:38:33 vnivanch Exp $
// GEANT4 tag $Name: geant4-09-03 $
//
//---------------------------------------------------------------------------
//
// ClassName: G4FTFBinaryNeutronBuilder
//
// Author: 2008 G.Folger
//
// Modified:
// 30.03.2009 V.Ivanchenko create cross section by new
//
//----------------------------------------------------------------------------
//
#include "G4FTFBinaryNeutronBuilder.hh"
#include "G4ParticleDefinition.hh"
#include "G4ParticleTable.hh"
#include "G4ProcessManager.hh"
#include "G4NeutronInelasticCrossSection.hh"
G4FTFBinaryNeutronBuilder::
G4FTFBinaryNeutronBuilder(G4bool quasiElastic)
@@ -79,6 +94,7 @@ Build(G4HadronCaptureProcess * )
void G4FTFBinaryNeutronBuilder::
Build(G4NeutronInelasticProcess * aP)
{
theModel->SetMinEnergy(theMin);
aP->RegisterMe(theModel);
aP->AddDataSet(&theXSec);
aP->AddDataSet(new G4NeutronInelasticCrossSection);
}
source/physics_lists/builders/src/G4FTFBinaryPiKBuilder.cc
+31 -21
View File
@@ -23,14 +23,29 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
#include "G4FTFBinaryPiKBuilder.hh"
#include "G4ParticleDefinition.hh"
#include "G4ParticleTable.hh"
#include "G4ProcessManager.hh"
// $Id: G4FTFBinaryPiKBuilder.cc,v 1.3 2009/03/31 18:38:33 vnivanch Exp $
// GEANT4 tag $Name: geant4-09-03 $
//
//---------------------------------------------------------------------------
//
// ClassName: G4FTFBinaryPiKBuilder
//
// Author: 2008 G.Folger
//
// Modified:
// 30.03.2009 V.Ivanchenko create cross section by new
//
//----------------------------------------------------------------------------
//
#include "G4FTFBinaryPiKBuilder.hh"
#include "G4ParticleDefinition.hh"
#include "G4ParticleTable.hh"
#include "G4ProcessManager.hh"
G4FTFBinaryPiKBuilder::
G4FTFBinaryPiKBuilder(G4bool quasiElastic)
G4FTFBinaryPiKBuilder::
G4FTFBinaryPiKBuilder(G4bool quasiElastic)
{
thePiData = new G4PiNuclearCrossSection;
theMin = 4*GeV;
theModel = new G4TheoFSGenerator("FTFB");
@@ -55,8 +70,7 @@
theModel->SetMaxEnergy(100*TeV);
}
G4FTFBinaryPiKBuilder::
~G4FTFBinaryPiKBuilder()
G4FTFBinaryPiKBuilder:: ~G4FTFBinaryPiKBuilder()
{
delete theCascade;
delete theStringDecay;
@@ -65,22 +79,22 @@
if ( theQuasiElastic ) delete theQuasiElastic;
}
void G4FTFBinaryPiKBuilder::
Build(G4HadronElasticProcess * ) {}
void G4FTFBinaryPiKBuilder::
Build(G4HadronElasticProcess * ) {}
void G4FTFBinaryPiKBuilder::
Build(G4PionPlusInelasticProcess * aP)
void G4FTFBinaryPiKBuilder::
Build(G4PionPlusInelasticProcess * aP)
{
aP->AddDataSet(&thePiData);
theModel->SetMinEnergy(theMin);
aP->AddDataSet(thePiData);
aP->RegisterMe(theModel);
}
void G4FTFBinaryPiKBuilder::
Build(G4PionMinusInelasticProcess * aP)
void G4FTFBinaryPiKBuilder::
Build(G4PionMinusInelasticProcess * aP)
{
theModel->SetMinEnergy(theMin);
theModel->SetMaxEnergy(100*TeV);
aP->AddDataSet(&thePiData);
aP->AddDataSet(thePiData);
aP->RegisterMe(theModel);
}
@@ -88,7 +102,6 @@
Build(G4KaonPlusInelasticProcess * aP)
{
theModel->SetMinEnergy(theMin);
theModel->SetMaxEnergy(100*TeV);
aP->RegisterMe(theModel);
}
@@ -96,7 +109,6 @@
Build(G4KaonMinusInelasticProcess * aP)
{
theModel->SetMinEnergy(theMin);
theModel->SetMaxEnergy(100*TeV);
aP->RegisterMe(theModel);
}
@@ -104,7 +116,6 @@
Build(G4KaonZeroLInelasticProcess * aP)
{
theModel->SetMinEnergy(theMin);
theModel->SetMaxEnergy(100*TeV);
aP->RegisterMe(theModel);
}
@@ -112,6 +123,5 @@
Build(G4KaonZeroSInelasticProcess * aP)
{
theModel->SetMinEnergy(theMin);
theModel->SetMaxEnergy(100*TeV);
aP->RegisterMe(theModel);
}
source/physics_lists/builders/src/G4FTFBinaryProtonBuilder.cc
+16 -2
View File
@@ -23,10 +23,25 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4FTFBinaryProtonBuilder.cc,v 1.3 2009/03/31 18:38:33 vnivanch Exp $
// GEANT4 tag $Name: geant4-09-03 $
//
//---------------------------------------------------------------------------
//
// ClassName: G4FTFBinaryProtonBuilder
//
// Author: 2008 G.Folger
//
// Modified:
// 30.03.2009 V.Ivanchenko create cross section by new
//
//----------------------------------------------------------------------------
//
#include "G4FTFBinaryProtonBuilder.hh"
#include "G4ParticleDefinition.hh"
#include "G4ParticleTable.hh"
#include "G4ProcessManager.hh"
#include "G4ProtonInelasticCrossSection.hh"
G4FTFBinaryProtonBuilder::
G4FTFBinaryProtonBuilder(G4bool quasiElastic)
@@ -60,9 +75,8 @@ void G4FTFBinaryProtonBuilder::
Build(G4ProtonInelasticProcess * aP)
{
theModel->SetMinEnergy(theMin);
theModel->SetMaxEnergy(100*TeV);
aP->RegisterMe(theModel);
aP->AddDataSet(&theXSec);
aP->AddDataSet(new G4ProtonInelasticCrossSection);
}
G4FTFBinaryProtonBuilder::
source/physics_lists/builders/src/G4FTFBuilder.cc
+78
View File
@@ -0,0 +1,78 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4FTFBuilder.cc,v 1.2 2009/11/25 19:33:18 vnivanch Exp $
// GEANT4 tag $Name: geant4-09-03 $
//
//---------------------------------------------------------------------------
//
// ClassName: G4FTFBuilder
//
// Author: 28 June 2009 V.Ivanchenko
//
// Modified:
//
//----------------------------------------------------------------------------
//
#include "G4FTFBuilder.hh"
#include "G4FTFModel.hh"
#include "G4ExcitedStringDecay.hh"
#include "G4TheoFSGenerator.hh"
#include "G4QStringChipsParticleLevelInterface.hh"
#include "G4GeneratorPrecompoundInterface.hh"
#include "G4LundStringFragmentation.hh"
#include "G4BinaryCascade.hh"
G4FTFBuilder::G4FTFBuilder(const G4String& aName) : G4VHadronModelBuilder(aName)
{}
G4FTFBuilder::~G4FTFBuilder()
{
delete theStringDecay;
//delete theStringModel; // is deleted by the model
}
G4HadronicInteraction* G4FTFBuilder::BuildModel()
{
G4TheoFSGenerator* theFTFModel = new G4TheoFSGenerator(GetName());
theStringModel = new G4FTFModel();
theStringDecay = new G4ExcitedStringDecay(new G4LundStringFragmentation());
theStringModel->SetFragmentationModel(theStringDecay);
theFTFModel->SetHighEnergyGenerator(theStringModel);
if(GetName() == "FTFP") {
theFTFModel->SetTransport(new G4GeneratorPrecompoundInterface());
} else if(GetName() == "FTFC") {
theFTFModel->SetTransport(new G4QStringChipsParticleLevelInterface());
} else if(GetName() == "FTFB") {
theFTFModel->SetTransport(new G4BinaryCascade());
} else {
theFTFModel->SetTransport(new G4GeneratorPrecompoundInterface());
}
return theFTFModel;
}
source/physics_lists/builders/src/G4FTFCNeutronBuilder.cc
+19 -5
View File
@@ -23,10 +23,25 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4FTFCNeutronBuilder.cc,v 1.3 2009/03/31 18:38:34 vnivanch Exp $
// GEANT4 tag $Name: geant4-09-03 $
//
//---------------------------------------------------------------------------
//
// ClassName: G4FTFCNeutronBuilder
//
// Author: 2002 J.P. Wellisch
//
// Modified:
// 30.03.2009 V.Ivanchenko create cross section by new
//
//----------------------------------------------------------------------------
//
#include "G4FTFCNeutronBuilder.hh"
#include "G4ParticleDefinition.hh"
#include "G4ParticleTable.hh"
#include "G4ProcessManager.hh"
#include "G4NeutronInelasticCrossSection.hh"
G4FTFCNeutronBuilder::
G4FTFCNeutronBuilder(G4bool quasiElastic)
@@ -49,10 +64,11 @@ G4FTFCNeutronBuilder(G4bool quasiElastic)
{ theQuasiElastic=0;}
theModel->SetTransport(theCascade);
theModel->SetMinEnergy(theMin);
theModel->SetMaxEnergy(100*TeV);
}
G4FTFCNeutronBuilder::
~G4FTFCNeutronBuilder()
G4FTFCNeutronBuilder::~G4FTFCNeutronBuilder()
{
delete theCascade;
delete theStringDecay;
@@ -79,10 +95,8 @@ Build(G4HadronCaptureProcess * )
void G4FTFCNeutronBuilder::
Build(G4NeutronInelasticProcess * aP)
{
aP->AddDataSet(&theXSec);
theModel->SetMinEnergy(theMin);
theModel->SetMaxEnergy(100*TeV);
aP->AddDataSet(new G4NeutronInelasticCrossSection);
aP->RegisterMe(theModel);
}
source/physics_lists/builders/src/G4FTFCPiKBuilder.cc
+20 -8
View File
@@ -23,6 +23,20 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4FTFCPiKBuilder.cc,v 1.3 2009/03/31 18:38:34 vnivanch Exp $
// GEANT4 tag $Name: geant4-09-03 $
//
//---------------------------------------------------------------------------
//
// ClassName: G4FTFCPiKBuilder
//
// Author: 2002 J.P. Wellisch
//
// Modified:
// 30.03.2009 V.Ivanchenko create cross section by new
//
//----------------------------------------------------------------------------
//
#include "G4FTFCPiKBuilder.hh"
#include "G4ParticleDefinition.hh"
#include "G4ParticleTable.hh"
@@ -31,6 +45,7 @@
G4FTFCPiKBuilder::
G4FTFCPiKBuilder(G4bool quasiElastic)
{
thePiData = new G4PiNuclearCrossSection;
theMin = 4*GeV;
theModel = new G4TheoFSGenerator;
@@ -48,6 +63,9 @@ G4FTFCPiKBuilder(G4bool quasiElastic)
theModel->SetQuasiElasticChannel(theQuasiElastic);
} else
{ theQuasiElastic=0;}
theModel->SetMinEnergy(theMin);
theModel->SetMaxEnergy(100*TeV);
}
G4FTFCPiKBuilder::
@@ -65,18 +83,16 @@ Build(G4HadronElasticProcess * ) {}
void G4FTFCPiKBuilder::
Build(G4PionPlusInelasticProcess * aP)
{
aP->AddDataSet(&thePiData);
aP->AddDataSet(thePiData);
theModel->SetMinEnergy(theMin);
theModel->SetMaxEnergy(100*TeV);
aP->RegisterMe(theModel);
}
void G4FTFCPiKBuilder::
Build(G4PionMinusInelasticProcess * aP)
{
aP->AddDataSet(&thePiData);
aP->AddDataSet(thePiData);
theModel->SetMinEnergy(theMin);
theModel->SetMaxEnergy(100*TeV);
aP->RegisterMe(theModel);
}
@@ -84,7 +100,6 @@ void G4FTFCPiKBuilder::
Build(G4KaonPlusInelasticProcess * aP)
{
theModel->SetMinEnergy(theMin);
theModel->SetMaxEnergy(100*TeV);
aP->RegisterMe(theModel);
}
@@ -92,7 +107,6 @@ void G4FTFCPiKBuilder::
Build(G4KaonMinusInelasticProcess * aP)
{
theModel->SetMinEnergy(theMin);
theModel->SetMaxEnergy(100*TeV);
aP->RegisterMe(theModel);
}
@@ -100,7 +114,6 @@ void G4FTFCPiKBuilder::
Build(G4KaonZeroLInelasticProcess * aP)
{
theModel->SetMinEnergy(theMin);
theModel->SetMaxEnergy(100*TeV);
aP->RegisterMe(theModel);
}
@@ -108,7 +121,6 @@ void G4FTFCPiKBuilder::
Build(G4KaonZeroSInelasticProcess * aP)
{
theModel->SetMinEnergy(theMin);
theModel->SetMaxEnergy(100*TeV);
aP->RegisterMe(theModel);
}
source/physics_lists/builders/src/G4FTFCProtonBuilder.cc
+43 -6
View File
@@ -23,35 +23,72 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4FTFCProtonBuilder.cc,v 1.4 2009/03/31 18:38:34 vnivanch Exp $
// GEANT4 tag $Name: geant4-09-03 $
//
//---------------------------------------------------------------------------
//
// ClassName: G4FTFCProtonBuilder
//
// Author: 2002 J.P. Wellisch
//
// Modified:
// 30.03.2009 V.Ivanchenko create cross section by new
//
//----------------------------------------------------------------------------
//
#include "G4FTFCProtonBuilder.hh"
#include "G4ParticleDefinition.hh"
#include "G4ParticleTable.hh"
#include "G4ProcessManager.hh"
#include "TheoModelFactory.hh"
#include "G4ProtonInelasticCrossSection.hh"
G4FTFCProtonBuilder::
G4FTFCProtonBuilder(G4bool quasiElastic)
{
theMin = 4*GeV;
theModel = TheoModelFactory<G4StringChipsParticleLevelInterface,
G4FTFModel, G4LundStringFragmentation>::New();
theModel = new G4TheoFSGenerator;
theStringModel = new G4FTFModel;
theStringDecay = new G4ExcitedStringDecay(new G4LundStringFragmentation);
theStringModel->SetFragmentationModel(theStringDecay);
theCascade = new G4StringChipsParticleLevelInterface;
theModel->SetHighEnergyGenerator(theStringModel);
if (quasiElastic)
if (quasiElastic)
{
theQuasiElastic=new G4QuasiElasticChannel;
theModel->SetQuasiElasticChannel(theQuasiElastic);
} else
{ theQuasiElastic=0;}
theModel->SetTransport(theCascade);
theModel->SetMinEnergy(theMin);
theModel->SetMaxEnergy(100*TeV);
}
G4FTFCProtonBuilder::~G4FTFCProtonBuilder()
{
delete theCascade;
delete theStringDecay;
if ( theQuasiElastic ) delete theQuasiElastic;
delete theStringModel;
delete theModel;
}
void G4FTFCProtonBuilder::
Build(G4ProtonInelasticProcess * aP)
{
theModel->SetMinEnergy(theMin);
theModel->SetMaxEnergy(100*TeV);
aP->RegisterMe(theModel);
aP->AddDataSet(&theXSec);
aP->AddDataSet(new G4ProtonInelasticCrossSection);
}
void G4FTFCProtonBuilder::
Build(G4HadronElasticProcess * )
{
}
// 2002 by J.P. Wellisch
source/physics_lists/builders/src/G4FTFPNeutronBuilder.cc
+22 -3
View File
@@ -23,15 +23,31 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4FTFPNeutronBuilder.cc,v 1.5 2009/04/23 18:54:57 japost Exp $
// GEANT4 tag $Name: geant4-09-03 $
//
//---------------------------------------------------------------------------
//
// ClassName: G4FTFPNeutronBuilder
//
// Author: 2002 J.P. Wellisch
//
// Modified:
// 30.03.2009 V.Ivanchenko create cross section by new
//
//----------------------------------------------------------------------------
//
#include "G4FTFPNeutronBuilder.hh"
#include "G4ParticleDefinition.hh"
#include "G4ParticleTable.hh"
#include "G4ProcessManager.hh"
#include "G4NeutronInelasticCrossSection.hh"
G4FTFPNeutronBuilder::
G4FTFPNeutronBuilder(G4bool quasiElastic)
{
theMin = 4*GeV;
theMin = 4*GeV;
theMax = 100*TeV;
theModel = new G4TheoFSGenerator("FTFP");
theStringModel = new G4FTFModel;
@@ -51,6 +67,9 @@ G4FTFPNeutronBuilder(G4bool quasiElastic)
theModel->SetQuasiElasticChannel(theQuasiElastic);
} else
{ theQuasiElastic=0;}
theModel->SetMinEnergy(theMin);
theModel->SetMaxEnergy(100*TeV);
}
G4FTFPNeutronBuilder::
@@ -82,9 +101,9 @@ void G4FTFPNeutronBuilder::
Build(G4NeutronInelasticProcess * aP)
{
theModel->SetMinEnergy(theMin);
theModel->SetMaxEnergy(100*TeV);
theModel->SetMaxEnergy(theMax);
aP->RegisterMe(theModel);
aP->AddDataSet(&theXSec);
aP->AddDataSet(new G4NeutronInelasticCrossSection);
}
// 2002 by J.P. Wellisch
source/physics_lists/builders/src/G4FTFPPiKBuilder.cc
+47 -30
View File
@@ -23,15 +23,31 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
#include "G4FTFPPiKBuilder.hh"
#include "G4ParticleDefinition.hh"
#include "G4ParticleTable.hh"
#include "G4ProcessManager.hh"
// $Id: G4FTFPPiKBuilder.cc,v 1.5 2009/04/23 18:54:57 japost Exp $
// GEANT4 tag $Name: geant4-09-03 $
//
//---------------------------------------------------------------------------
//
// ClassName: G4FTFPPiKBuilder
//
// Author: 2002 J.P. Wellisch
//
// Modified:
// 30.03.2009 V.Ivanchenko create cross section by new
//
//----------------------------------------------------------------------------
//
#include "G4FTFPPiKBuilder.hh"
#include "G4ParticleDefinition.hh"
#include "G4ParticleTable.hh"
#include "G4ProcessManager.hh"
G4FTFPPiKBuilder::
G4FTFPPiKBuilder(G4bool quasiElastic)
G4FTFPPiKBuilder::
G4FTFPPiKBuilder(G4bool quasiElastic)
{
thePiData = new G4PiNuclearCrossSection;
theMin = 4*GeV;
theMax = 100*TeV;
theModel = new G4TheoFSGenerator("FTFP");
theStringModel = new G4FTFModel;
@@ -51,10 +67,11 @@
{ theQuasiElastic=0;}
theModel->SetTransport(theCascade);
theModel->SetMinEnergy(theMin);
theModel->SetMaxEnergy(100*TeV);
}
G4FTFPPiKBuilder::
~G4FTFPPiKBuilder()
G4FTFPPiKBuilder:: ~G4FTFPPiKBuilder()
{
delete theCascade;
delete theStringDecay;
@@ -63,56 +80,56 @@
if ( theQuasiElastic ) delete theQuasiElastic;
}
void G4FTFPPiKBuilder::
Build(G4HadronElasticProcess * ) {}
void G4FTFPPiKBuilder::
Build(G4HadronElasticProcess * ) {}
void G4FTFPPiKBuilder::
Build(G4PionPlusInelasticProcess * aP)
void G4FTFPPiKBuilder::
Build(G4PionPlusInelasticProcess * aP)
{
theModel->SetMinEnergy(theMin);
theModel->SetMaxEnergy(100*TeV);
aP->AddDataSet(&thePiData);
theModel->SetMaxEnergy(theMax);
aP->AddDataSet(thePiData);
aP->RegisterMe(theModel);
}
void G4FTFPPiKBuilder::
Build(G4PionMinusInelasticProcess * aP)
void G4FTFPPiKBuilder::
Build(G4PionMinusInelasticProcess * aP)
{
theModel->SetMinEnergy(theMin);
theModel->SetMaxEnergy(100*TeV);
aP->AddDataSet(&thePiData);
theModel->SetMaxEnergy(theMax);
aP->AddDataSet(thePiData);
aP->RegisterMe(theModel);
}
void G4FTFPPiKBuilder::
Build(G4KaonPlusInelasticProcess * aP)
void G4FTFPPiKBuilder::
Build(G4KaonPlusInelasticProcess * aP)
{
theModel->SetMinEnergy(theMin);
theModel->SetMaxEnergy(100*TeV);
theModel->SetMaxEnergy(theMax);
aP->RegisterMe(theModel);
}
void G4FTFPPiKBuilder::
Build(G4KaonMinusInelasticProcess * aP)
void G4FTFPPiKBuilder::
Build(G4KaonMinusInelasticProcess * aP)
{
theModel->SetMinEnergy(theMin);
theModel->SetMaxEnergy(100*TeV);
theModel->SetMaxEnergy(theMax);
aP->RegisterMe(theModel);
}
void G4FTFPPiKBuilder::
Build(G4KaonZeroLInelasticProcess * aP)
void G4FTFPPiKBuilder::
Build(G4KaonZeroLInelasticProcess * aP)
{
theModel->SetMinEnergy(theMin);
theModel->SetMaxEnergy(100*TeV);
theModel->SetMaxEnergy(theMax);
aP->RegisterMe(theModel);
}
void G4FTFPPiKBuilder::
Build(G4KaonZeroSInelasticProcess * aP)
void G4FTFPPiKBuilder::
Build(G4KaonZeroSInelasticProcess * aP)
{
theModel->SetMinEnergy(theMin);
theModel->SetMaxEnergy(100*TeV);
theModel->SetMaxEnergy(theMax);
aP->RegisterMe(theModel);
}
source/physics_lists/builders/src/G4FTFPProtonBuilder.cc
+20 -2
View File
@@ -23,15 +23,31 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4FTFPProtonBuilder.cc,v 1.6 2009/04/23 18:54:57 japost Exp $
// GEANT4 tag $Name: geant4-09-03 $
//
//---------------------------------------------------------------------------
//
// ClassName: G4FTFPProtonBuilder
//
// Author: 2002 J.P. Wellisch
//
// Modified:
// 30.03.2009 V.Ivanchenko create cross section by new
//
//----------------------------------------------------------------------------
//
#include "G4FTFPProtonBuilder.hh"
#include "G4ParticleDefinition.hh"
#include "G4ParticleTable.hh"
#include "G4ProcessManager.hh"
#include "G4ProtonInelasticCrossSection.hh"
G4FTFPProtonBuilder::
G4FTFPProtonBuilder(G4bool quasiElastic)
{
theMin = 4*GeV;
theMax = 100.*TeV;
theModel = new G4TheoFSGenerator("FTFP");
theStringModel = new G4FTFModel;
@@ -51,15 +67,17 @@ G4FTFPProtonBuilder(G4bool quasiElastic)
{ theQuasiElastic=0;}
theModel->SetTransport(theCascade);
theModel->SetMinEnergy(theMin);
theModel->SetMaxEnergy(100*TeV);
}
void G4FTFPProtonBuilder::
Build(G4ProtonInelasticProcess * aP)
{
theModel->SetMinEnergy(theMin);
theModel->SetMaxEnergy(100*TeV);
theModel->SetMaxEnergy(theMax);
aP->RegisterMe(theModel);
aP->AddDataSet(&theXSec);
aP->AddDataSet(new G4ProtonInelasticCrossSection);
}
G4FTFPProtonBuilder::
source/physics_lists/builders/src/G4HadronHElasticPhysics.cc
+49 -52
View File
@@ -23,8 +23,8 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4HadronHElasticPhysics.cc,v 1.5 2008/05/19 10:21:34 vnivanch Exp $
// GEANT4 tag $Name: geant4-09-02 $
// $Id: G4HadronHElasticPhysics.cc,v 1.7 2009/11/28 17:35:01 vnivanch Exp $
// GEANT4 tag $Name: geant4-09-03 $
//
//---------------------------------------------------------------------------
//
@@ -41,11 +41,6 @@
#include "G4HadronHElasticPhysics.hh"
#include "G4HadronicProcess.hh"
#include "G4HadronElasticProcess.hh"
#include "G4HadronicInteraction.hh"
#include "G4LElastic.hh"
#include "G4ParticleDefinition.hh"
#include "G4ProcessManager.hh"
@@ -54,31 +49,30 @@
#include "G4IonConstructor.hh"
#include "G4Neutron.hh"
#include "G4VQCrossSection.hh"
#include "G4WHadronElasticProcess.hh"
#include "G4VHadronElastic.hh"
#include "G4CHIPSElastic.hh"
#include "G4ElasticHadrNucleusHE.hh"
#include "G4NeutronHPElastic.hh"
#include "G4UElasticCrossSection.hh"
#include "G4BGGNucleonElasticXS.hh"
#include "G4BGGPionElasticXS.hh"
#include "G4NeutronElasticXS.hh"
G4HadronHElasticPhysics::G4HadronHElasticPhysics(G4int ver, G4bool hp)
: G4VPhysicsConstructor("HElastic"), mname("HElastic"), verbose(ver),
hpFlag(hp), wasActivated(false)
G4HadronHElasticPhysics::G4HadronHElasticPhysics(G4int ver, G4bool hp,
const G4String& type)
: G4VPhysicsConstructor("HElastic"), verbose(ver),
hpFlag(hp), wasActivated(false), subtype(type)
{
if(verbose > 1) G4cout << "### HadronHElasticPhysics" << G4endl;
model = 0;
neutronModel = 0;
neutronHPModel = 0;
}
G4HadronHElasticPhysics::~G4HadronHElasticPhysics()
{
delete model;
delete neutronModel;
delete neutronHPModel;
}
{}
void G4HadronHElasticPhysics::ConstructParticle()
{
// G4cout << "G4HadronElasticPhysics::ConstructParticle" << G4endl;
// G4cout << "G4HadronElasticPhysics::ConstructParticle" << G4endl;
G4MesonConstructor pMesonConstructor;
pMesonConstructor.ConstructParticle();
@@ -95,22 +89,21 @@ void G4HadronHElasticPhysics::ConstructProcess()
if(wasActivated) return;
wasActivated = true;
G4double elimit = 0.4*GeV;
//G4double elimit = 0.0;
if(verbose > 1)
G4double elimit = 1.0*GeV;
if(verbose > 1) {
G4cout << "### HadronElasticPhysics Construct Processes with HE limit "
<< elimit << " MeV" << G4endl;
}
G4HadronicProcess* hel = 0;
G4VQCrossSection* man = 0;
G4VHadronElastic* plep0 = new G4VHadronElastic();
G4VHadronElastic* plep1 = new G4VHadronElastic();
plep1->SetMaxEnergy(elimit);
G4HadronElastic* he = new G4HadronElastic();
he->SetHEModelLowLimit(elimit);
he->SetQModelLowLimit(0.0);
he->SetLowestEnergyLimit(0.0);
model = he;
man = he->GetCS();
G4CHIPSElastic* chipsp = new G4CHIPSElastic();
G4CHIPSElastic* chipsn = new G4CHIPSElastic();
G4ElasticHadrNucleusHE* he = new G4ElasticHadrNucleusHE();
he->SetMinEnergy(elimit);
theParticleIterator->reset();
while( (*theParticleIterator)() )
@@ -142,44 +135,48 @@ void G4HadronHElasticPhysics::ConstructProcess()
pname == "triton") {
G4ProcessManager* pmanager = particle->GetProcessManager();
G4UHadronElasticProcess* h = new G4UHadronElasticProcess("hElastic");
h->SetQElasticCrossSection(man);
hel = h;
G4WHadronElasticProcess* hel = new G4WHadronElasticProcess();
if(pname == "proton") {
hel->AddDataSet(new G4BGGNucleonElasticXS(particle));
hel->RegisterMe(chipsp);
} else if (pname == "pi+" || pname == "pi-") {
hel->AddDataSet(new G4BGGPionElasticXS(particle));
hel->RegisterMe(plep1);
hel->RegisterMe(he);
} else {
hel->AddDataSet(new G4UElasticCrossSection(particle));
//hel->AddDataSet(new G4UElasticCrossSection(particle));
hel->RegisterMe(plep0);
}
hel->RegisterMe(model);
pmanager->AddDiscreteProcess(hel);
if(verbose > 1) {
G4cout << "### HadronHElasticPhysics: " << hel->GetProcessName()
<< " added for " << particle->GetParticleName() << G4endl;
}
// neutron case
} else if(pname == "neutron") {
G4ProcessManager* pmanager = particle->GetProcessManager();
G4UHadronElasticProcess* h = new G4UHadronElasticProcess("hElastic");
G4HadronElastic* nhe = new G4HadronElastic();
nhe->SetHEModelLowLimit(elimit);
neutronModel = nhe;
h->SetQElasticCrossSection(nhe->GetCS());
hel = h;
hel->AddDataSet(new G4BGGNucleonElasticXS(particle));
G4WHadronElasticProcess* hel = new G4WHadronElasticProcess();
if(subtype == "QBBC_XGGSN") {
hel->AddDataSet(new G4NeutronElasticXS());
} else {
hel->AddDataSet(new G4BGGNucleonElasticXS(particle));
}
hel->RegisterMe(chipsn);
if(hpFlag) {
neutronModel->SetMinEnergy(19.5*MeV);
neutronHPModel = new G4NeutronHPElastic();
hel->RegisterMe(neutronHPModel);
chipsn->SetMinEnergy(19.5*MeV);
G4NeutronHPElastic* hp = new G4NeutronHPElastic();
hel->RegisterMe(hp);
hel->AddDataSet(new G4NeutronHPElasticData());
}
hel->RegisterMe(neutronModel);
pmanager->AddDiscreteProcess(hel);
if(verbose > 1)
G4cout << "### HadronHElasticPhysics added for "
<< particle->GetParticleName() << G4endl;
if(verbose > 1) {
G4cout << "### HadronHElasticPhysics: " << hel->GetProcessName()
<< " added for " << particle->GetParticleName() << G4endl;
}
}
}
}
source/physics_lists/builders/src/G4InclAblaNeutronBuilder.cc
+69
View File
@@ -0,0 +1,69 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
#include "G4InclAblaNeutronBuilder.hh"
#include "G4ParticleDefinition.hh"
#include "G4ParticleTable.hh"
#include "G4ProcessManager.hh"
G4InclAblaNeutronBuilder::
G4InclAblaNeutronBuilder()
{
theMin = 0;
theMax = 3.0*GeV;
theModel = new G4InclAblaCascadeInterface;
}
void G4InclAblaNeutronBuilder::
Build(G4NeutronInelasticProcess * aP)
{
theModel->SetMinEnergy(theMin);
theModel->SetMaxEnergy(theMax);
aP->RegisterMe(theModel);
aP->AddDataSet(&theXSec);
}
G4InclAblaNeutronBuilder::
~G4InclAblaNeutronBuilder()
{
delete theModel;
}
void G4InclAblaNeutronBuilder::
Build(G4HadronElasticProcess * )
{
}
void G4InclAblaNeutronBuilder::
Build(G4HadronFissionProcess * )
{
}
void G4InclAblaNeutronBuilder::
Build(G4HadronCaptureProcess * )
{
}
// 2002 by J.P. Wellisch
source/physics_lists/builders/src/G4InclAblaPiKBuilder.cc
+102
View File
@@ -0,0 +1,102 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
#include "G4InclAblaPiKBuilder.hh"
#include "G4ParticleDefinition.hh"
#include "G4ParticleTable.hh"
#include "G4ProcessManager.hh"
G4InclAblaPiKBuilder::
G4InclAblaPiKBuilder()
{
theMin = 0*GeV;
theMax = 3.0*GeV;
theModel = new G4InclAblaCascadeInterface;
theModel->SetMinEnergy(theMin);
theModel->SetMaxEnergy(theMax);
theBertiniModel = new G4CascadeInterface;
theBertiniModel->SetMinEnergy(theMin);
theBertiniModel->SetMaxEnergy(theMax);
}
G4InclAblaPiKBuilder::
~G4InclAblaPiKBuilder()
{
delete theModel;
}
void G4InclAblaPiKBuilder::
Build(G4PionPlusInelasticProcess * aP)
{
aP->RegisterMe(theModel);
theModel->SetMinEnergy(theMin);
theModel->SetMaxEnergy(theMax);
}
void G4InclAblaPiKBuilder::
Build(G4PionMinusInelasticProcess * aP)
{
aP->RegisterMe(theModel);
aP->AddDataSet(&thePiData);
theModel->SetMinEnergy(theMin);
theModel->SetMaxEnergy(theMax);
}
void G4InclAblaPiKBuilder::
Build(G4HadronElasticProcess * ) {}
void G4InclAblaPiKBuilder::
Build(G4KaonPlusInelasticProcess *aP)
{
aP->RegisterMe(theBertiniModel);
theBertiniModel->SetMinEnergy(theMin);
theBertiniModel->SetMaxEnergy(theMax);
}
void G4InclAblaPiKBuilder::
Build(G4KaonMinusInelasticProcess *aP)
{
aP->RegisterMe(theBertiniModel);
theBertiniModel->SetMinEnergy(theMin);
theBertiniModel->SetMaxEnergy(theMax);
}
void G4InclAblaPiKBuilder::
Build(G4KaonZeroLInelasticProcess *aP)
{
aP->RegisterMe(theBertiniModel);
theBertiniModel->SetMinEnergy(theMin);
theBertiniModel->SetMaxEnergy(theMax);
}
void G4InclAblaPiKBuilder::
Build(G4KaonZeroSInelasticProcess *aP)
{
aP->RegisterMe(theBertiniModel);
theBertiniModel->SetMinEnergy(theMin);
theBertiniModel->SetMaxEnergy(theMax);
}
// 2002 by J.P. Wellisch
source/physics_lists/builders/src/G4InclAblaProtonBuilder.cc
+59
View File
@@ -0,0 +1,59 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
#include "G4InclAblaProtonBuilder.hh"
#include "G4ParticleDefinition.hh"
#include "G4ParticleTable.hh"
#include "G4ProcessManager.hh"
G4InclAblaProtonBuilder::
G4InclAblaProtonBuilder()
{
theMin = 0;
theMax=3.0*GeV;
theModel = new G4InclAblaCascadeInterface;
}
G4InclAblaProtonBuilder::
~G4InclAblaProtonBuilder()
{
delete theModel;
}
void G4InclAblaProtonBuilder::
Build(G4HadronElasticProcess * )
{
}
void G4InclAblaProtonBuilder::
Build(G4ProtonInelasticProcess * aP)
{
theModel->SetMinEnergy(theMin);
theModel->SetMaxEnergy(theMax);
aP->RegisterMe(theModel);
aP->AddDataSet(&theXSec);
}
// 2002 by J.P. Wellisch
source/physics_lists/builders/src/G4IonBinaryCascadePhysics.cc
+6 -4
View File
@@ -23,8 +23,8 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4IonBinaryCascadePhysics.cc,v 1.1 2006/10/31 11:35:02 gunter Exp $
// GEANT4 tag $Name: geant4-09-02 $
// $Id: G4IonBinaryCascadePhysics.cc,v 1.2 2009/02/16 10:15:35 vnivanch Exp $
// GEANT4 tag $Name: geant4-09-03 $
//
//---------------------------------------------------------------------------
//
@@ -117,9 +117,9 @@ void G4IonBinaryCascadePhysics::AddProcess(const G4String& name,
p_list.push_back(hadi);
G4ProcessManager* pManager = p->GetProcessManager();
pManager->AddDiscreteProcess(hadi);
hadi->AddDataSet(fShen);
hadi->AddDataSet(fTripathi);
hadi->AddDataSet(fTripathiLight);
hadi->AddDataSet(fShen);
hmodel->SetMinEnergy(eminBIC);
hmodel->SetMaxEnergy(emax);
hadi->RegisterMe(hmodel);
@@ -132,7 +132,9 @@ void G4IonBinaryCascadePhysics::AddProcess(const G4String& name,
G4cout << "Register " << hadi->GetProcessName()
<< " for " << p->GetParticleName()
<< " Binary Cascade for E(MeV)= " << eminBIC << " - " << emax;
if(lmodel) G4cout << " LHEP for E(MeV)= " << emax-MeV << " - " << emaxLHEP;
if(lmodel) {
G4cout << " LHEP for E(MeV)= " << emax-MeV << " - " << emaxLHEP;
}
G4cout << G4endl;
}
}
source/physics_lists/builders/src/G4IonInclAblaPhysics.cc
+152
View File
@@ -0,0 +1,152 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4IonInclAblaPhysics.cc,v 1.1 2009/07/19 18:24:03 kaitanie Exp $
// GEANT4 tag $Name: geant4-09-03 $
//
//---------------------------------------------------------------------------
//
// ClassName: G4IonInclAblaPhysics
//
// Author: P. Kaitaniemi
//
// Modified:
// 23.06.06 V.Ivanchenko set emaxLHEP=1 TeV
// 24.06.06 V.Ivanchenko fix typo
//
//----------------------------------------------------------------------------
//
#include "G4IonInclAblaPhysics.hh"
#include "G4DeuteronInelasticProcess.hh"
#include "G4TritonInelasticProcess.hh"
#include "G4AlphaInelasticProcess.hh"
#include "G4HadronInelasticProcess.hh"
#include "G4InclAblaLightIonInterface.hh"
#include "G4TripathiCrossSection.hh"
#include "G4TripathiLightCrossSection.hh"
#include "G4IonsShenCrossSection.hh"
#include "G4ParticleDefinition.hh"
#include "G4ParticleTable.hh"
#include "G4ProcessManager.hh"
// Nuclei
#include "G4IonConstructor.hh"
G4IonInclAblaPhysics::G4IonInclAblaPhysics(const G4String& name,
G4int verb)
: G4VPhysicsConstructor(name), verbose(verb), wasActivated(false)
{
// INCL/ABLA light ion maximum energy is 3.0 GeV/nucleon
emax_d = 2 * 3.0 * GeV;
emax_t = 3 * 3.0 * GeV;
emax_he3 = 3 * 3.0 * GeV;
emax_alpha = 4 * 3.0 * GeV;
emaxLHEP = 1.*TeV;
emin = 0.*MeV;
if(verbose > 1) G4cout << "### G4IonInclAblaPhysics" << G4endl;
}
G4IonInclAblaPhysics::~G4IonInclAblaPhysics()
{
if(wasActivated) {
delete fTripathi;
delete fTripathiLight;
delete fShen;
delete fLEDModel;
delete fLETModel;
delete fLEAModel;
G4int i;
G4int n = p_list.size();
for(i=0; i<n; i++) {delete p_list[i];}
n = model_list.size();
for(i=0; i<n; i++) {delete model_list[i];}
}
}
void G4IonInclAblaPhysics::ConstructProcess()
{
if(wasActivated) return;
wasActivated = true;
G4InclAblaLightIonInterface* fInclAblaIons= new G4InclAblaLightIonInterface();
model_list.push_back(fInclAblaIons);
fShen = new G4IonsShenCrossSection;
fTripathi = new G4TripathiCrossSection;
fTripathiLight = new G4TripathiLightCrossSection;
fLEDModel = new G4LEDeuteronInelastic();
fLETModel = new G4LETritonInelastic();
fLEAModel = new G4LEAlphaInelastic();
AddProcess("dInelastic", G4Deuteron::Deuteron(), fInclAblaIons, fLEDModel, emax_d);
AddProcess("tInelastic",G4Triton::Triton(), fInclAblaIons, fLETModel, emax_t);
AddProcess("He3Inelastic",G4He3::He3(), fInclAblaIons, 0, emax_he3);
AddProcess("alphaInelastic", G4Alpha::Alpha(), fInclAblaIons, fLEAModel, emax_alpha);
// Support for light ions heavier than Alpha will be included in a future release of INCL/ABLA
// AddProcess("ionInelastic",G4GenericIon::GenericIon(), fInclAblaIons, 0);
}
void G4IonInclAblaPhysics::AddProcess(const G4String& name,
G4ParticleDefinition* p,
G4HadronicInteraction* hmodel,
G4HadronicInteraction* lmodel,
const G4double inclEnergyUpperLimit = 3.0 * GeV)
{
G4HadronInelasticProcess* hadi = new G4HadronInelasticProcess(name, p);
p_list.push_back(hadi);
G4ProcessManager* pManager = p->GetProcessManager();
pManager->AddDiscreteProcess(hadi);
hadi->AddDataSet(fShen);
hadi->AddDataSet(fTripathi);
hadi->AddDataSet(fTripathiLight);
hmodel->SetMinEnergy(emin);
hmodel->SetMaxEnergy(inclEnergyUpperLimit);
hadi->RegisterMe(hmodel);
if(lmodel) {
lmodel->SetMinEnergy(inclEnergyUpperLimit - MeV);
lmodel->SetMaxEnergy(emaxLHEP);
hadi->RegisterMe(lmodel);
}
if(verbose > 1) {
G4cout << "Register " << hadi->GetProcessName()
<< " for " << p->GetParticleName()
<< " INCL/ABLA for E(MeV)= " << emin << " - " << inclEnergyUpperLimit;
if(lmodel) {
G4cout << " LHEP for E(MeV)= " << inclEnergyUpperLimit-MeV << " - " << emaxLHEP;
}
G4cout << G4endl;
}
}
void G4IonInclAblaPhysics::ConstructParticle()
{
// Construct light ions
G4IonConstructor pConstructor;
pConstructor.ConstructParticle();
}
source/physics_lists/builders/src/G4IonQMDPhysics.cc
+168
View File
@@ -0,0 +1,168 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4IonQMDPhysics.cc,v 1.1 2009/11/27 17:25:15 gunter Exp $
// GEANT4 tag $Name: geant4-09-03 $
//
//---------------------------------------------------------------------------
//
// ClassName: G4IonQMDPhysics
// Created from G4IonBinaryCascadePhysics
//
// Author: G.Folger
//
// Modified:
//
//----------------------------------------------------------------------------
//
#include "G4IonQMDPhysics.hh"
#include "G4DeuteronInelasticProcess.hh"
#include "G4TritonInelasticProcess.hh"
#include "G4AlphaInelasticProcess.hh"
#include "G4HadronInelasticProcess.hh"
#include "G4BinaryLightIonReaction.hh"
#include "G4QMDReaction.hh"
#include "G4TripathiCrossSection.hh"
#include "G4TripathiLightCrossSection.hh"
#include "G4IonsShenCrossSection.hh"
#include "G4ParticleDefinition.hh"
#include "G4ParticleTable.hh"
#include "G4ProcessManager.hh"
// Nuclei
#include "G4IonConstructor.hh"
G4IonQMDPhysics::G4IonQMDPhysics(const G4String& name,
G4int verb)
: G4VPhysicsConstructor(name), verbose(verb), wasActivated(false)
{
eminBIC = 0.*MeV;
eminQMD = 100.*MeV;
emaxQMD = 10.*GeV;
emaxLHEP = 1.*TeV;
overlap = 10*MeV;
if(verbose > 1) G4cout << "### G4IonQMDPhysics" << G4endl;
}
G4IonQMDPhysics::~G4IonQMDPhysics()
{
if(wasActivated) {
delete fTripathi;
delete fTripathiLight;
delete fShen;
delete fLEDModel;
delete fLETModel;
delete fLEAModel;
G4int i;
G4int n = p_list.size();
for(i=0; i<n; i++) {delete p_list[i];}
n = model_list.size();
for(i=0; i<n; i++) {delete model_list[i];}
}
}
void G4IonQMDPhysics::ConstructProcess()
{
if(wasActivated) return;
wasActivated = true;
G4BinaryLightIonReaction* fBC= new G4BinaryLightIonReaction();
model_list.push_back(fBC);
G4QMDReaction* fQMD= new G4QMDReaction();
model_list.push_back(fQMD);
fShen = new G4IonsShenCrossSection;
fTripathi = new G4TripathiCrossSection;
fTripathiLight = new G4TripathiLightCrossSection;
fLEDModel = new G4LEDeuteronInelastic();
fLETModel = new G4LETritonInelastic();
fLEAModel = new G4LEAlphaInelastic();
AddProcess("dInelastic", G4Deuteron::Deuteron(), fBC,0, fLEDModel);
AddProcess("tInelastic",G4Triton::Triton(), fBC,0, fLETModel);
AddProcess("He3Inelastic",G4He3::He3(), fBC,0, 0);
AddProcess("alphaInelastic", G4Alpha::Alpha(), fBC,0, fLEAModel);
AddProcess("ionInelastic",G4GenericIon::GenericIon(), fBC, fQMD, 0);
}
void G4IonQMDPhysics::AddProcess(const G4String& name,
G4ParticleDefinition* p,
G4BinaryLightIonReaction* BIC,
G4QMDReaction* QMD,
G4HadronicInteraction* LHEP)
{
G4HadronInelasticProcess* hadi = new G4HadronInelasticProcess(name, p);
p_list.push_back(hadi);
G4ProcessManager* pManager = p->GetProcessManager();
pManager->AddDiscreteProcess(hadi);
hadi->AddDataSet(fShen);
hadi->AddDataSet(fTripathi);
hadi->AddDataSet(fTripathiLight);
BIC->SetMinEnergy(eminBIC);
BIC->SetMaxEnergy(emaxQMD); //reset when QMD is present
hadi->RegisterMe(BIC);
if(QMD) {
QMD->SetMinEnergy(eminQMD);
BIC->SetMaxEnergy(eminQMD-overlap);
QMD->SetMaxEnergy(emaxQMD);
hadi->RegisterMe(QMD);
}
if(LHEP) {
LHEP->SetMinEnergy(emaxQMD - overlap);
LHEP->SetMaxEnergy(emaxLHEP);
hadi->RegisterMe(LHEP);
}
if(verbose > 1) {
G4cout << "Register " << hadi->GetProcessName()
<< " for " << p->GetParticleName() << G4endl
<< " Binary Cascade for E(MeV)= " << eminBIC << " - "
<< (QMD==0 ? emaxQMD : (eminQMD-overlap)) ;
if(QMD) {
G4cout << G4endl <<" QMD for E(MeV)= " << eminQMD << " - " << emaxQMD;
}
if(LHEP) {
G4cout << G4endl<< " LHEP for E(MeV)= " << emaxQMD-overlap << " - " << emaxLHEP;
}
G4cout << G4endl;
}
}
void G4IonQMDPhysics::ConstructParticle()
{
// Construct light ions
G4IonConstructor pConstructor;
pConstructor.ConstructParticle();
}
source/physics_lists/builders/src/G4MiscLHEPBuilder.cc
+57 -43
View File
@@ -23,7 +23,7 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// GEANT4 tag $Name: geant4-09-02 $
// GEANT4 tag $Name: geant4-09-03 $
//
//---------------------------------------------------------------------------
//
@@ -54,130 +54,144 @@ void G4MiscLHEPBuilder::Build()
wasActivated = true;
// anti-Proton
theAntiProtonInelastic = new G4AntiProtonInelasticProcess();
aProcMan = G4AntiProton::AntiProton()->GetProcessManager();
theLEAntiProtonModel = new G4LEAntiProtonInelastic();
theHEAntiProtonModel = new G4HEAntiProtonInelastic();
theHEAntiProtonModel->SetMaxEnergy(100*TeV);
theAntiProtonInelastic.RegisterMe(theLEAntiProtonModel);
theAntiProtonInelastic.RegisterMe(theHEAntiProtonModel);
aProcMan->AddDiscreteProcess(&theAntiProtonInelastic);
theAntiProtonInelastic->RegisterMe(theLEAntiProtonModel);
theAntiProtonInelastic->RegisterMe(theHEAntiProtonModel);
aProcMan->AddDiscreteProcess(theAntiProtonInelastic);
// AntiNeutron
theAntiNeutronInelastic = new G4AntiNeutronInelasticProcess();
aProcMan = G4AntiNeutron::AntiNeutron()->GetProcessManager();
theLEAntiNeutronModel = new G4LEAntiNeutronInelastic();
theHEAntiNeutronModel = new G4HEAntiNeutronInelastic();
theHEAntiNeutronModel->SetMaxEnergy(100*TeV);
theAntiNeutronInelastic.RegisterMe(theLEAntiNeutronModel);
theAntiNeutronInelastic.RegisterMe(theHEAntiNeutronModel);
aProcMan->AddDiscreteProcess(&theAntiNeutronInelastic);
theAntiNeutronInelastic->RegisterMe(theLEAntiNeutronModel);
theAntiNeutronInelastic->RegisterMe(theHEAntiNeutronModel);
aProcMan->AddDiscreteProcess(theAntiNeutronInelastic);
// Lambda
theLambdaInelastic = new G4LambdaInelasticProcess();
aProcMan = G4Lambda::Lambda()->GetProcessManager();
theLELambdaModel = new G4LELambdaInelastic();
theHELambdaModel = new G4HELambdaInelastic();
theHELambdaModel->SetMaxEnergy(100*TeV);
theLambdaInelastic.RegisterMe(theLELambdaModel);
theLambdaInelastic.RegisterMe(theHELambdaModel);
aProcMan->AddDiscreteProcess(&theLambdaInelastic);
theLambdaInelastic->RegisterMe(theLELambdaModel);
theLambdaInelastic->RegisterMe(theHELambdaModel);
aProcMan->AddDiscreteProcess(theLambdaInelastic);
// AntiLambda
theAntiLambdaInelastic = new G4AntiLambdaInelasticProcess();
aProcMan = G4AntiLambda::AntiLambda()->GetProcessManager();
theLEAntiLambdaModel = new G4LEAntiLambdaInelastic();
theHEAntiLambdaModel = new G4HEAntiLambdaInelastic();
theHEAntiLambdaModel->SetMaxEnergy(100*TeV);
theAntiLambdaInelastic.RegisterMe(theLEAntiLambdaModel);
theAntiLambdaInelastic.RegisterMe(theHEAntiLambdaModel);
aProcMan->AddDiscreteProcess(&theAntiLambdaInelastic);
theAntiLambdaInelastic->RegisterMe(theLEAntiLambdaModel);
theAntiLambdaInelastic->RegisterMe(theHEAntiLambdaModel);
aProcMan->AddDiscreteProcess(theAntiLambdaInelastic);
// SigmaMinus
theSigmaMinusInelastic = new G4SigmaMinusInelasticProcess();
aProcMan = G4SigmaMinus::SigmaMinus()->GetProcessManager();
theLESigmaMinusModel = new G4LESigmaMinusInelastic();
theHESigmaMinusModel = new G4HESigmaMinusInelastic();
theHESigmaMinusModel->SetMaxEnergy(100*TeV);
theSigmaMinusInelastic.RegisterMe(theLESigmaMinusModel);
theSigmaMinusInelastic.RegisterMe(theHESigmaMinusModel);
aProcMan->AddDiscreteProcess(&theSigmaMinusInelastic);
theSigmaMinusInelastic->RegisterMe(theLESigmaMinusModel);
theSigmaMinusInelastic->RegisterMe(theHESigmaMinusModel);
aProcMan->AddDiscreteProcess(theSigmaMinusInelastic);
// anti-SigmaMinus
theAntiSigmaMinusInelastic = new G4AntiSigmaMinusInelasticProcess();
aProcMan = G4AntiSigmaMinus::AntiSigmaMinus()->GetProcessManager();
theLEAntiSigmaMinusModel = new G4LEAntiSigmaMinusInelastic();
theHEAntiSigmaMinusModel = new G4HEAntiSigmaMinusInelastic();
theHEAntiSigmaMinusModel->SetMaxEnergy(100*TeV);
theAntiSigmaMinusInelastic.RegisterMe(theLEAntiSigmaMinusModel);
theAntiSigmaMinusInelastic.RegisterMe(theHEAntiSigmaMinusModel);
aProcMan->AddDiscreteProcess(&theAntiSigmaMinusInelastic);
theAntiSigmaMinusInelastic->RegisterMe(theLEAntiSigmaMinusModel);
theAntiSigmaMinusInelastic->RegisterMe(theHEAntiSigmaMinusModel);
aProcMan->AddDiscreteProcess(theAntiSigmaMinusInelastic);
// SigmaPlus
theSigmaPlusInelastic = new G4SigmaPlusInelasticProcess();
aProcMan = G4SigmaPlus::SigmaPlus()->GetProcessManager();
theLESigmaPlusModel = new G4LESigmaPlusInelastic();
theHESigmaPlusModel = new G4HESigmaPlusInelastic();
theHESigmaPlusModel->SetMaxEnergy(100*TeV);
theSigmaPlusInelastic.RegisterMe(theLESigmaPlusModel);
theSigmaPlusInelastic.RegisterMe(theHESigmaPlusModel);
aProcMan->AddDiscreteProcess(&theSigmaPlusInelastic);
theSigmaPlusInelastic->RegisterMe(theLESigmaPlusModel);
theSigmaPlusInelastic->RegisterMe(theHESigmaPlusModel);
aProcMan->AddDiscreteProcess(theSigmaPlusInelastic);
// anti-SigmaPlus
theAntiSigmaPlusInelastic = new G4AntiSigmaPlusInelasticProcess();
aProcMan = G4AntiSigmaPlus::AntiSigmaPlus()->GetProcessManager();
theLEAntiSigmaPlusModel = new G4LEAntiSigmaPlusInelastic();
theHEAntiSigmaPlusModel = new G4HEAntiSigmaPlusInelastic();
theHEAntiSigmaPlusModel->SetMaxEnergy(100*TeV);
theAntiSigmaPlusInelastic.RegisterMe(theLEAntiSigmaPlusModel);
theAntiSigmaPlusInelastic.RegisterMe(theHEAntiSigmaPlusModel);
aProcMan->AddDiscreteProcess(&theAntiSigmaPlusInelastic);
theAntiSigmaPlusInelastic->RegisterMe(theLEAntiSigmaPlusModel);
theAntiSigmaPlusInelastic->RegisterMe(theHEAntiSigmaPlusModel);
aProcMan->AddDiscreteProcess(theAntiSigmaPlusInelastic);
// XiMinus
theXiMinusInelastic = new G4XiMinusInelasticProcess();
aProcMan = G4XiMinus::XiMinus()->GetProcessManager();
theLEXiMinusModel = new G4LEXiMinusInelastic();
theHEXiMinusModel = new G4HEXiMinusInelastic();
theHEXiMinusModel->SetMaxEnergy(100*TeV);
theXiMinusInelastic.RegisterMe(theLEXiMinusModel);
theXiMinusInelastic.RegisterMe(theHEXiMinusModel);
aProcMan->AddDiscreteProcess(&theXiMinusInelastic);
theXiMinusInelastic->RegisterMe(theLEXiMinusModel);
theXiMinusInelastic->RegisterMe(theHEXiMinusModel);
aProcMan->AddDiscreteProcess(theXiMinusInelastic);
// anti-XiMinus
theAntiXiMinusInelastic = new G4AntiXiMinusInelasticProcess();
aProcMan = G4AntiXiMinus::AntiXiMinus()->GetProcessManager();
theLEAntiXiMinusModel = new G4LEAntiXiMinusInelastic();
theHEAntiXiMinusModel = new G4HEAntiXiMinusInelastic();
theHEAntiXiMinusModel->SetMaxEnergy(100*TeV);
theAntiXiMinusInelastic.RegisterMe(theLEAntiXiMinusModel);
theAntiXiMinusInelastic.RegisterMe(theHEAntiXiMinusModel);
aProcMan->AddDiscreteProcess(&theAntiXiMinusInelastic);
theAntiXiMinusInelastic->RegisterMe(theLEAntiXiMinusModel);
theAntiXiMinusInelastic->RegisterMe(theHEAntiXiMinusModel);
aProcMan->AddDiscreteProcess(theAntiXiMinusInelastic);
// XiZero
theXiZeroInelastic = new G4XiZeroInelasticProcess();
aProcMan = G4XiZero::XiZero()->GetProcessManager();
theLEXiZeroModel = new G4LEXiZeroInelastic();
theHEXiZeroModel = new G4HEXiZeroInelastic();
theHEXiZeroModel->SetMaxEnergy(100*TeV);
theXiZeroInelastic.RegisterMe(theLEXiZeroModel);
theXiZeroInelastic.RegisterMe(theHEXiZeroModel);
aProcMan->AddDiscreteProcess(&theXiZeroInelastic);
theXiZeroInelastic->RegisterMe(theLEXiZeroModel);
theXiZeroInelastic->RegisterMe(theHEXiZeroModel);
aProcMan->AddDiscreteProcess(theXiZeroInelastic);
// anti-XiZero
theAntiXiZeroInelastic = new G4AntiXiZeroInelasticProcess();
aProcMan = G4AntiXiZero::AntiXiZero()->GetProcessManager();
theLEAntiXiZeroModel = new G4LEAntiXiZeroInelastic();
theHEAntiXiZeroModel = new G4HEAntiXiZeroInelastic();
theHEAntiXiZeroModel->SetMaxEnergy(100*TeV);
theAntiXiZeroInelastic.RegisterMe(theLEAntiXiZeroModel);
theAntiXiZeroInelastic.RegisterMe(theHEAntiXiZeroModel);
aProcMan->AddDiscreteProcess(&theAntiXiZeroInelastic);
theAntiXiZeroInelastic->RegisterMe(theLEAntiXiZeroModel);
theAntiXiZeroInelastic->RegisterMe(theHEAntiXiZeroModel);
aProcMan->AddDiscreteProcess(theAntiXiZeroInelastic);
// OmegaMinus
theOmegaMinusInelastic = new G4OmegaMinusInelasticProcess();
aProcMan = G4OmegaMinus::OmegaMinus()->GetProcessManager();
theLEOmegaMinusModel = new G4LEOmegaMinusInelastic();
theHEOmegaMinusModel = new G4HEOmegaMinusInelastic();
theHEOmegaMinusModel->SetMaxEnergy(100*TeV);
theOmegaMinusInelastic.RegisterMe(theLEOmegaMinusModel);
theOmegaMinusInelastic.RegisterMe(theHEOmegaMinusModel);
aProcMan->AddDiscreteProcess(&theOmegaMinusInelastic);
theOmegaMinusInelastic->RegisterMe(theLEOmegaMinusModel);
theOmegaMinusInelastic->RegisterMe(theHEOmegaMinusModel);
aProcMan->AddDiscreteProcess(theOmegaMinusInelastic);
// anti-OmegaMinus
theAntiOmegaMinusInelastic = new G4AntiOmegaMinusInelasticProcess();
aProcMan = G4AntiOmegaMinus::AntiOmegaMinus()->GetProcessManager();
theLEAntiOmegaMinusModel = new G4LEAntiOmegaMinusInelastic();
theHEAntiOmegaMinusModel = new G4HEAntiOmegaMinusInelastic();
theHEAntiOmegaMinusModel->SetMaxEnergy(100*TeV);
theAntiOmegaMinusInelastic.RegisterMe(theLEAntiOmegaMinusModel);
theAntiOmegaMinusInelastic.RegisterMe(theHEAntiOmegaMinusModel);
aProcMan->AddDiscreteProcess(&theAntiOmegaMinusInelastic);
theAntiOmegaMinusInelastic->RegisterMe(theLEAntiOmegaMinusModel);
theAntiOmegaMinusInelastic->RegisterMe(theHEAntiOmegaMinusModel);
aProcMan->AddDiscreteProcess(theAntiOmegaMinusInelastic);
}
// 2002 by J.P. Wellisch
source/physics_lists/builders/src/G4MiscQGSCBuilder.cc
+101
View File
@@ -0,0 +1,101 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// GEANT4 tag $Name: geant4-09-03 $
//
//---------------------------------------------------------------------------
//
// ClassName: G4MiscQGSCBuilder
//
// Author: 2009 M. Kosov (on the basis of the G4MiscLHEPBuilder)
//
//----------------------------------------------------------------------------
//
#include "G4MiscQGSCBuilder.hh"
#include "G4ParticleDefinition.hh"
#include "G4ParticleTable.hh"
#include "G4ProcessManager.hh"
G4MiscQGSCBuilder::G4MiscQGSCBuilder(G4int ver): verbose(ver), wasActivated(false)
{
// pointer to the particle table
theParticleTable = G4ParticleTable::GetParticleTable();
theParticleIterator = theParticleTable->GetIterator();
}
G4MiscQGSCBuilder::~G4MiscQGSCBuilder() {}
void G4MiscQGSCBuilder::Build()
{
wasActivated = true;
//QGSC model definition
theModel = new G4TheoFSGenerator("QGSC");
theQGSCModel = new G4QGSModel< G4QGSParticipants >;
theQGSCDecay = new G4ExcitedStringDecay(new G4QGSMFragmentation);
theQGSCModel->SetFragmentationModel(theQGSCDecay);
theModel->SetHighEnergyGenerator(theQGSCModel);
theCascade = new G4StringChipsParticleLevelInterface;
theModel->SetTransport(theCascade);
theQuasiElastic = new G4QuasiElasticChannel;
theModel->SetQuasiElasticChannel(theQuasiElastic);
theModel->SetMinEnergy(0.);
theModel->SetMaxEnergy(100*TeV);
theParticleIterator->reset();
while( (*theParticleIterator)() )
{
G4ParticleDefinition* particle = theParticleIterator->value();
G4String pname = particle->GetParticleName();
if(pname == "kaon-" || pname == "kaon+" || pname == "kaon0S" || pname == "kaon0L" ||
pname == "pi-" || pname == "pi+" || pname == "neutron" || pname == "proton" )
{
if(verbose>1)G4cout<<"** G4MiscQGSCBuilder: "<<pname<<" already defined"<<G4endl;
}
else if(
pname == "anti_proton" || pname == "anti_neutron" || pname == "anti_lambda" ||
pname == "anti_sigma+" || pname == "anti_sigma0" || pname == "anti_sigma-" ||
pname == "anti_xi0" || pname == "anti_xi-" || pname == "anti_omega-" ||
pname == "lambda" || pname == "sigma+" || pname == "sigma0" ||
pname == "sigma-" || pname == "xi0" || pname == "xi-" || pname == "omega-")
{
if(verbose>1)G4cout<< "__ G4MiscQGSCBuilder: "<< pname <<" is defined here"<<G4endl;
G4ProcessManager* pmanager = particle->GetProcessManager();
G4HadronInelasticProcess* hp = new G4HadronInelasticProcess("hInelastic", particle);
pmanager->AddDiscreteProcess(hp);
hp->RegisterMe(theModel);
if(verbose>1)
G4cout<<"^^ G4MiscQGSCBuilder: "<<hp->GetProcessName()<<" added for "<<pname<<G4endl;
}
}
}
// 2009 by M. Kosov
source/physics_lists/builders/src/G4OpticalPhysics.cc
+264
View File
@@ -0,0 +1,264 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
//
//---------------------------------------------------------------------------
//
// ClassName: G4OpticalPhysics
//
// Author: P.Gumplinger 30.09.2009
//
// Modified:
//
//----------------------------------------------------------------------------
//
#include "G4OpticalPhysics.hh"
#include "G4LossTableManager.hh"
#include "G4EmSaturation.hh"
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
G4OpticalPhysics::G4OpticalPhysics(G4int verbose, const G4String& name)
: G4VPhysicsConstructor(name),
wasActivated(false),
fScintillationProcess(0),
fCerenkovProcess(0),
fOpWLSProcess(0),
fOpAbsorptionProcess(0),
fOpRayleighScatteringProcess(0),
fOpBoundaryProcess(0),
fMaxNumPhotons(100),
fMaxBetaChange(10.0),
fYieldFactor(1.),
fExcitationRatio(0.0),
fSurfaceModel(unified),
fProfile("delta"),
fTrackSecondariesFirst(true)
{
verboseLevel = verbose;
fMessenger = new G4OpticalPhysicsMessenger(this);
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
G4OpticalPhysics::~G4OpticalPhysics()
{
delete fMessenger;
if (wasActivated) {
delete fScintillationProcess;
delete fCerenkovProcess;
delete fOpWLSProcess;
delete fOpAbsorptionProcess;
delete fOpRayleighScatteringProcess;
delete fOpBoundaryProcess;
}
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
#include "G4OpticalPhoton.hh"
void G4OpticalPhysics::ConstructParticle()
{
/// Instantiate particles.
// optical photon
G4OpticalPhoton::OpticalPhotonDefinition();
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
#include "G4ParticleDefinition.hh"
#include "G4ProcessManager.hh"
void G4OpticalPhysics::ConstructProcess()
{
// Construct optical processes.
if (wasActivated) return;
if(verboseLevel>0)
G4cout <<"G4OpticalPhysics:: Add Optical Physics Processes"<< G4endl;
// Add Optical Processes
fOpAbsorptionProcess = new G4OpAbsorption();
fOpRayleighScatteringProcess = new G4OpRayleigh();
fOpBoundaryProcess = new G4OpBoundaryProcess();
fOpBoundaryProcess->SetModel(fSurfaceModel);
fOpWLSProcess = new G4OpWLS();
fOpWLSProcess->UseTimeProfile(fProfile);
G4ProcessManager * pManager = 0;
pManager = G4OpticalPhoton::OpticalPhoton()->GetProcessManager();
if (!pManager) {
std::ostringstream o;
o << "Optical Photon without a Process Manager";
G4Exception("G4OpticalPhysics::ConstructProcess()","",
FatalException,o.str().c_str());
}
pManager->AddDiscreteProcess(fOpAbsorptionProcess);
pManager->AddDiscreteProcess(fOpRayleighScatteringProcess);
pManager->AddDiscreteProcess(fOpBoundaryProcess);
pManager->AddDiscreteProcess(fOpWLSProcess);
fScintillationProcess = new G4Scintillation();
fScintillationProcess->SetScintillationYieldFactor(fYieldFactor);
fScintillationProcess->SetScintillationExcitationRatio(fExcitationRatio);
fScintillationProcess->SetTrackSecondariesFirst(fTrackSecondariesFirst);
// Use Birks Correction in the Scintillation process
G4EmSaturation* emSaturation = G4LossTableManager::Instance()->EmSaturation();
fScintillationProcess->AddSaturation(emSaturation);
fCerenkovProcess = new G4Cerenkov();
fCerenkovProcess->SetMaxNumPhotonsPerStep(fMaxNumPhotons);
fCerenkovProcess->SetMaxBetaChangePerStep(fMaxBetaChange);
fCerenkovProcess->SetTrackSecondariesFirst(fTrackSecondariesFirst);
theParticleIterator->reset();
while( (*theParticleIterator)() ){
G4ParticleDefinition* particle = theParticleIterator->value();
G4String particleName = particle->GetParticleName();
pManager = particle->GetProcessManager();
if (!pManager) {
std::ostringstream o;
o << "Particle " << particleName << "without a Process Manager";
G4Exception("G4OpticalPhysics::ConstructProcess()","",
FatalException,o.str().c_str());
}
if(fCerenkovProcess->IsApplicable(*particle)){
pManager->AddProcess(fCerenkovProcess);
pManager->SetProcessOrdering(fCerenkovProcess,idxPostStep);
}
if(fScintillationProcess->IsApplicable(*particle)){
pManager->AddProcess(fScintillationProcess);
pManager->SetProcessOrderingToLast(fScintillationProcess,idxAtRest);
pManager->SetProcessOrderingToLast(fScintillationProcess,idxPostStep);
}
}
wasActivated = true;
}
void G4OpticalPhysics::SetScintillationYieldFactor(G4double yieldFactor)
{
/// Set the scintillation yield factor
fYieldFactor = yieldFactor;
if(fScintillationProcess)
fScintillationProcess->SetScintillationYieldFactor(yieldFactor);
}
void G4OpticalPhysics::SetScintillationExcitationRatio(G4double excitationRatio)
{
/// Set the scintillation excitation ratio
fExcitationRatio = excitationRatio;
if(fScintillationProcess)
fScintillationProcess->SetScintillationExcitationRatio(excitationRatio);
}
void G4OpticalPhysics::SetMaxNumPhotonsPerStep(G4int maxNumPhotons)
{
/// Limit step to the specified maximum number of Cherenkov photons
fMaxNumPhotons = maxNumPhotons;
if(fCerenkovProcess)
fCerenkovProcess->SetMaxNumPhotonsPerStep(maxNumPhotons);
}
void G4OpticalPhysics::SetMaxBetaChangePerStep(G4double maxBetaChange)
{
/// Limit step to the specified maximum change of beta of the parent particle
fMaxBetaChange = maxBetaChange;
if(fCerenkovProcess)
fCerenkovProcess->SetMaxBetaChangePerStep(maxBetaChange);
}
void G4OpticalPhysics::SetOpticalSurfaceModel(G4OpticalSurfaceModel model)
{
/// Set optical surface model (glisur or unified)
fSurfaceModel = model;
if(fOpBoundaryProcess)
fOpBoundaryProcess->SetModel(model);
}
void G4OpticalPhysics::SetWLSTimeProfile(G4String profile)
{
/// Set the WLS time profile (delta or exponential)
fProfile = profile;
if(fOpWLSProcess)
fOpWLSProcess->UseTimeProfile(fProfile);
}
void G4OpticalPhysics::AddScintillationSaturation(G4EmSaturation* saturation)
{
/// Adds Birks Saturation to the G4Scintillation Process
if(fScintillationProcess)
fScintillationProcess->AddSaturation(saturation);
}
void G4OpticalPhysics::SetTrackSecondariesFirst(G4bool trackSecondariesFirst)
{
fTrackSecondariesFirst = trackSecondariesFirst;
if ( fCerenkovProcess )
fCerenkovProcess->SetTrackSecondariesFirst(trackSecondariesFirst);
if ( fScintillationProcess )
fScintillationProcess->SetTrackSecondariesFirst(trackSecondariesFirst);
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
source/physics_lists/builders/src/G4OpticalPhysicsMessenger.cc
+244
View File
@@ -0,0 +1,244 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
#include "G4OpticalPhysicsMessenger.hh"
#include "G4OpticalPhysics.hh"
#include "G4UIcommand.hh"
#include "G4UIdirectory.hh"
#include "G4UIcommand.hh"
#include "G4UIdirectory.hh"
#include "G4UIcmdWithABool.hh"
#include "G4UIcmdWithAString.hh"
#include "G4UIcmdWithADouble.hh"
#include "G4UIcmdWithAnInteger.hh"
#include "G4UIcmdWithADoubleAndUnit.hh"
#include "G4ParticleTable.hh"
#include "G4ProcessVector.hh"
#include "G4ProcessManager.hh"
#include "G4ParticleDefinition.hh"
//_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_
G4OpticalPhysicsMessenger::G4OpticalPhysicsMessenger(
G4OpticalPhysics* opticalPhysics)
: G4UImessenger(),
fOpticalPhysics(opticalPhysics),
fSelectedProcess(0),
fSelectOpProcessCmd(0),
fSetOpProcessActivationCmd(0),
fSetOpProcessVerboseCmd(0),
fSetCerenkovMaxPhotonsCmd(0),
fSetCerenkovMaxBetaChangeCmd(0),
fSetScintillationYieldFactorCmd(0),
fSetOpticalSurfaceModelCmd(0),
fSetWLSTimeProfileCmd(0),
fSetTrackSecondariesFirstCmd(0)
{
/// Standard constructor
fDir = new G4UIdirectory("/optics_engine/");
fDir->SetGuidance("Commands related to the optical physics simulation engine.");
fSelectOpProcessCmd
= new G4UIcmdWithAString("/optics_engine/selectOpProcess", this);
fSelectOpProcessCmd
->SetGuidance("Select optical process for applying verbose/activation/trackfirst commands");
fSelectOpProcessCmd->SetParameterName("OpProcess", false);
fSelectOpProcessCmd->AvailableForStates(G4State_Idle,G4State_GeomClosed,G4State_EventProc);
fSetOpProcessActivationCmd
= new G4UIcmdWithABool("/optics_engine/setOpProcessActivation", this);
fSetOpProcessActivationCmd->SetGuidance("Activate/Inactivate selected optical process");
fSetOpProcessActivationCmd->SetParameterName("OpProcessActivation", false);
fSetOpProcessActivationCmd->AvailableForStates(G4State_Idle,G4State_GeomClosed,G4State_EventProc);
fSetOpProcessVerboseCmd
= new G4UIcmdWithAnInteger("/optics_engine/setOpProcessVerbose", this);
fSetOpProcessVerboseCmd->SetGuidance("Set verbosity level for selected optical process");
fSetOpProcessVerboseCmd->SetParameterName("OpProcessVerbose", false);
fSetOpProcessVerboseCmd->SetRange("OpProcessVerbose>=0");
fSetOpProcessVerboseCmd->AvailableForStates(G4State_Idle,G4State_GeomClosed,G4State_EventProc);
fSetCerenkovMaxPhotonsCmd
= new G4UIcmdWithAnInteger("/optics_engine/setCerenkovMaxPhotons", this);
fSetCerenkovMaxPhotonsCmd->SetGuidance("Set maximum number of photons per step");
fSetCerenkovMaxPhotonsCmd->SetParameterName("CerenkovMaxPhotons", false);
fSetCerenkovMaxPhotonsCmd->SetRange("CerenkovMaxPhotons>=0");
fSetCerenkovMaxPhotonsCmd->AvailableForStates(G4State_Idle,G4State_GeomClosed,G4State_EventProc);
fSetCerenkovMaxBetaChangeCmd
= new G4UIcmdWithADouble("/optics_engine/setCerenkovMaxBetaChange", this);
fSetCerenkovMaxBetaChangeCmd
->SetGuidance("Set maximum change of beta of parent particle per step");
fSetCerenkovMaxBetaChangeCmd->SetParameterName("CerenkovMaxBetaChange", false);
fSetCerenkovMaxBetaChangeCmd->SetRange("CerenkovMaxBetaChange>=0");
fSetCerenkovMaxBetaChangeCmd->AvailableForStates(G4State_Idle,G4State_GeomClosed,G4State_EventProc);
fSetScintillationYieldFactorCmd
= new G4UIcmdWithADouble("/optics_engine/setScintillationYieldFactor", this);
fSetScintillationYieldFactorCmd->SetGuidance("Set scintillation yield factor");
fSetScintillationYieldFactorCmd->SetParameterName("ScintillationYieldFactor", false);
fSetScintillationYieldFactorCmd->SetRange("ScintillationYieldFactor>=0");
fSetScintillationYieldFactorCmd->AvailableForStates(G4State_Idle,G4State_GeomClosed,G4State_EventProc);
fSetOpticalSurfaceModelCmd
= new G4UIcmdWithAString("/optics_engine/setOpticalSurfaceModel", this);
fSetOpticalSurfaceModelCmd
->SetGuidance("Set optical surface model (glisur or unified)");
fSetOpticalSurfaceModelCmd->SetParameterName("OpticalSurfaceModel", false);
fSetOpticalSurfaceModelCmd->SetCandidates("glisur unified");
fSetOpticalSurfaceModelCmd->AvailableForStates(G4State_Idle,G4State_GeomClosed,G4State_EventProc);
fSetWLSTimeProfileCmd
= new G4UIcmdWithAString("/optics_engine/setWLSTimeProfile", this);
fSetWLSTimeProfileCmd
->SetGuidance("Set the WLS time profile (delta or exponential)");
fSetWLSTimeProfileCmd->SetParameterName("WLSTimeProfile", false);
fSetWLSTimeProfileCmd->SetCandidates("delta exponential");
fSetWLSTimeProfileCmd->AvailableForStates(G4State_Idle,G4State_GeomClosed,G4State_EventProc);
fSetTrackSecondariesFirstCmd
= new G4UIcmdWithABool("/optics_engine/setTrackSecondariesFirst", this);
fSetTrackSecondariesFirstCmd
->SetGuidance("Set option to track secondaries before finishing their parent track");
fSetTrackSecondariesFirstCmd->SetParameterName("TrackSecondariesFirst", false);
fSetTrackSecondariesFirstCmd->AvailableForStates(G4State_Idle,G4State_GeomClosed,G4State_EventProc);
}
//_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_
G4OpticalPhysicsMessenger::~G4OpticalPhysicsMessenger()
{
/// Destructor
delete fDir;
delete fSelectOpProcessCmd;
delete fSetOpProcessActivationCmd;
delete fSetOpProcessVerboseCmd;
delete fSetCerenkovMaxPhotonsCmd;
delete fSetCerenkovMaxBetaChangeCmd;
delete fSetScintillationYieldFactorCmd;
delete fSetOpticalSurfaceModelCmd;
delete fSetWLSTimeProfileCmd;
delete fSetTrackSecondariesFirstCmd;
}
//_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_
void G4OpticalPhysicsMessenger::SetNewValue(G4UIcommand* command, G4String newValue)
{
/// Apply command to the associated object.
if (command == fSelectOpProcessCmd) {
if ( newValue == "Cerenkov" ) fSelectedProcess = fOpticalPhysics->
GetCerenkovProcess();
else if ( newValue == "Scintillation" ) fSelectedProcess = fOpticalPhysics->
GetScintillationProcess();
else if ( newValue == "OpAbsorption" ) fSelectedProcess = fOpticalPhysics->
GetOpAbsorptionProcess();
else if ( newValue == "OpRayleigh" ) fSelectedProcess = fOpticalPhysics->
GetOpRayleighProcess();
else if ( newValue == "OpBoundary" ) fSelectedProcess = fOpticalPhysics->
GetOpBoundaryProcess();
else if ( newValue == "OpWLS" ) fSelectedProcess = fOpticalPhysics->
GetOpWLSProcess();
}
else if (command == fSetOpProcessActivationCmd) {
G4ParticleTable* theParticleTable = G4ParticleTable::GetParticleTable();
G4ParticleTable::G4PTblDicIterator* theParticleIterator =
theParticleTable->GetIterator();
if ( fSelectedProcess ) {
theParticleIterator->reset();
while( (*theParticleIterator)() ) {
G4ParticleDefinition* particle = theParticleIterator->value();
G4ProcessManager* processManager = particle->GetProcessManager();
G4ProcessVector* processVector = processManager->GetProcessList();
// activate or inactivate processes according to
for (G4int i=0; i<processVector->length(); i++) {
if ( (*processVector)[i] != fSelectedProcess ) continue;
G4cout << "Setting process activation: "
<< fSelectedProcess->GetProcessName() << " "
<< fSetOpProcessActivationCmd->GetNewBoolValue(newValue)
<< G4endl;
processManager->SetProcessActivation(fSelectedProcess,
fSetOpProcessActivationCmd->GetNewBoolValue(newValue));
}
}
}
}
else if (command == fSetOpProcessVerboseCmd) {
if ( fSelectedProcess )
fSelectedProcess->SetVerboseLevel
(fSetOpProcessVerboseCmd->GetNewIntValue(newValue));
}
else if (command == fSetCerenkovMaxPhotonsCmd) {
fOpticalPhysics
->SetMaxNumPhotonsPerStep(
fSetCerenkovMaxPhotonsCmd->GetNewIntValue(newValue));
}
else if (command == fSetCerenkovMaxBetaChangeCmd) {
fOpticalPhysics
->SetMaxBetaChangePerStep(
fSetCerenkovMaxBetaChangeCmd->GetNewDoubleValue(newValue));
}
else if (command == fSetScintillationYieldFactorCmd) {
fOpticalPhysics
->SetScintillationYieldFactor(
fSetScintillationYieldFactorCmd->GetNewDoubleValue(newValue));
}
else if (command == fSetOpticalSurfaceModelCmd) {
if ( newValue == "glisur" ) {
fOpticalPhysics
->SetOpticalSurfaceModel(glisur);
}
if ( newValue == "unified" ) {
fOpticalPhysics
->SetOpticalSurfaceModel(unified);
}
}
else if (command == fSetWLSTimeProfileCmd) {
if ( newValue == "delta" ) {
fOpticalPhysics
->SetWLSTimeProfile("delta"); }
if ( newValue == "exponential" ) {
fOpticalPhysics
->SetWLSTimeProfile("exponential");
}
}
else if (command == fSetTrackSecondariesFirstCmd) {
if ( fSelectedProcess ) {
G4Scintillation* scintillation =
static_cast<G4Scintillation*>(fSelectedProcess);
if (scintillation) scintillation ->
SetTrackSecondariesFirst(
fSetTrackSecondariesFirstCmd->GetNewBoolValue(newValue));
G4Cerenkov* cerenkov =
static_cast<G4Cerenkov*>(fSelectedProcess);
if (cerenkov) cerenkov ->
SetTrackSecondariesFirst(
fSetTrackSecondariesFirstCmd->GetNewBoolValue(newValue));
}
}
}
source/physics_lists/builders/src/G4PrecoNeutronBuilder.cc
+16 -1
View File
@@ -23,10 +23,25 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4PrecoNeutronBuilder.cc,v 1.2 2009/03/31 11:03:50 vnivanch Exp $
// GEANT4 tag $Name: geant4-09-03 $
//
//---------------------------------------------------------------------------
//
// ClassName: G4PrecoNeutronBuilder
//
// Author: 2002 J.P. Wellisch
//
// Modified:
// 30.03.2009 V.Ivanchenko create cross section by new
//
//----------------------------------------------------------------------------
//
#include "G4PrecoNeutronBuilder.hh"
#include "G4ParticleDefinition.hh"
#include "G4ParticleTable.hh"
#include "G4ProcessManager.hh"
#include "G4NeutronInelasticCrossSection.hh"
G4PrecoNeutronBuilder::
G4PrecoNeutronBuilder()
@@ -63,7 +78,7 @@ Build(G4NeutronInelasticProcess * aP)
theModel->SetMinEnergy(theMin);
theModel->SetMaxEnergy(theMax);
aP->RegisterMe(theModel);
aP->AddDataSet(&theXSec);
aP->AddDataSet(new G4NeutronInelasticCrossSection);
}
// 2002 by J.P. Wellisch
source/physics_lists/builders/src/G4PrecoProtonBuilder.cc
+16 -1
View File
@@ -23,10 +23,25 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4PrecoProtonBuilder.cc,v 1.2 2009/03/31 11:03:50 vnivanch Exp $
// GEANT4 tag $Name: geant4-09-03 $
//
//---------------------------------------------------------------------------
//
// ClassName: G4PrecoProtonBuilder
//
// Author: 2002 J.P. Wellisch
//
// Modified:
// 30.03.2009 V.Ivanchenko create cross section by new
//
//----------------------------------------------------------------------------
//
#include "G4PrecoProtonBuilder.hh"
#include "G4ParticleDefinition.hh"
#include "G4ParticleTable.hh"
#include "G4ProcessManager.hh"
#include "G4ProtonInelasticCrossSection.hh"
#include "G4ExcitationHandler.hh"
@@ -52,7 +67,7 @@ Build(G4ProtonInelasticProcess * aP)
theModel->SetMinEnergy(theMin);
theModel->SetMaxEnergy(theMax);
aP->RegisterMe(theModel);
aP->AddDataSet(&theXSec);
aP->AddDataSet(new G4ProtonInelasticCrossSection);
}
// 2002 by J.P. Wellisch
source/physics_lists/builders/src/G4QAtomicPhysics.cc
+209
View File
@@ -0,0 +1,209 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4QAtomicPhysics.cc,v 1.1 2009/11/20 10:24:28 mkossov Exp $
// GEANT4 tag $Name: geant4-09-03 $
//
//---------------------------------------------------------------------------
//
// ClassName: G4QAtomicPhysics
//
// Author: M. Kosov 20.11.2009 (similar to G4QAtomicPhysics)
//
// Modified:
//
//----------------------------------------------------------------------------
//
#include "G4QAtomicPhysics.hh"
#include "G4ParticleDefinition.hh"
#include "G4ProcessManager.hh"
#include "G4LossTableManager.hh"
#include "G4EmProcessOptions.hh"
#include "G4ComptonScattering.hh"
#include "G4GammaConversion.hh"
#include "G4PhotoElectricEffect.hh"
#include "G4eMultipleScattering.hh"
#include "G4MuMultipleScattering.hh"
#include "G4hMultipleScattering.hh"
#include "G4eIonisation.hh"
#include "G4eBremsstrahlung.hh"
#include "G4eplusAnnihilation.hh"
#include "G4MuIonisation.hh"
#include "G4MuBremsstrahlung.hh"
#include "G4MuPairProduction.hh"
#include "G4hBremsstrahlung.hh"
#include "G4hPairProduction.hh"
#include "G4hIonisation.hh"
#include "G4ionIonisation.hh"
#include "G4Gamma.hh"
#include "G4Electron.hh"
#include "G4Positron.hh"
#include "G4MuonPlus.hh"
#include "G4MuonMinus.hh"
#include "G4PionPlus.hh"
#include "G4PionMinus.hh"
#include "G4KaonPlus.hh"
#include "G4KaonMinus.hh"
#include "G4Proton.hh"
#include "G4AntiProton.hh"
#include "G4SigmaPlus.hh"
#include "G4SigmaMinus.hh"
#include "G4XiMinus.hh"
#include "G4OmegaMinus.hh"
#include "G4AntiSigmaPlus.hh"
#include "G4AntiSigmaMinus.hh"
#include "G4AntiXiMinus.hh"
#include "G4AntiOmegaMinus.hh"
#include "G4Deuteron.hh"
#include "G4Triton.hh"
#include "G4He3.hh"
#include "G4Alpha.hh"
#include "G4GenericIon.hh"
G4QAtomicPhysics::G4QAtomicPhysics(G4int ver, const G4String& name)
: G4VPhysicsConstructor(name), verbose(ver)
{
G4LossTableManager::Instance();
}
G4QAtomicPhysics::~G4QAtomicPhysics()
{}
void G4QAtomicPhysics::ConstructParticle()
{
// gamma
G4Gamma::Gamma();
// leptons
G4Electron::Electron();
G4Positron::Positron();
G4MuonPlus::MuonPlus();
G4MuonMinus::MuonMinus();
// mesons
G4PionPlus::PionPlusDefinition();
G4PionMinus::PionMinusDefinition();
G4KaonPlus::KaonPlusDefinition();
G4KaonMinus::KaonMinusDefinition();
// barions
G4Proton::Proton();
G4AntiProton::AntiProton();
G4SigmaPlus::SigmaPlus();
G4SigmaMinus::SigmaMinus();
G4XiMinus::XiMinus();
G4OmegaMinus::OmegaMinus();
G4AntiSigmaPlus::AntiSigmaPlus();
G4AntiSigmaMinus::AntiSigmaMinus();
G4AntiXiMinus::AntiXiMinus();
G4AntiOmegaMinus::AntiOmegaMinus();
// ions
G4Deuteron::Deuteron();
G4Triton::Triton();
G4He3::He3();
G4Alpha::Alpha();
G4GenericIon::GenericIonDefinition();
}
void G4QAtomicPhysics::ConstructProcess()
{
theParticleIterator->reset();
while( (*theParticleIterator)() )
{
G4ParticleDefinition* particlePointer = theParticleIterator->value();
G4ProcessManager* pmanager = particlePointer->GetProcessManager();
G4String particle = particlePointer->GetParticleName();
if(verbose > 1) G4cout<<"###G4QAtomicPhysics::ConstructProcesses: try "
<<GetPhysicsName()<<" builder for "<<particle<<G4endl;
if ( particle == "gamma")
{
pmanager->AddDiscreteProcess(new G4PhotoElectricEffect);
pmanager->AddDiscreteProcess(new G4ComptonScattering);
pmanager->AddDiscreteProcess(new G4GammaConversion);
}
else if( particle == "e-")
{
pmanager->AddProcess(new G4eMultipleScattering(), -1, 1, 1);
pmanager->AddProcess(new G4eIonisation, -1, 2, 2);
pmanager->AddProcess(new G4eBremsstrahlung(), -1,-3, 3);
}
else if( particle == "e+")
{
pmanager->AddProcess(new G4eMultipleScattering(), -1, 1, 1);
pmanager->AddProcess(new G4eIonisation, -1, 2, 2);
pmanager->AddProcess(new G4eBremsstrahlung, -1,-3, 3);
pmanager->AddProcess(new G4eplusAnnihilation, 0,-1, 4);
}
else if( particle == "mu+" || particle == "mu-" )
{
pmanager->AddProcess(new G4MuMultipleScattering, -1, 1, 1);
pmanager->AddProcess(new G4MuIonisation, -1, 2, 2);
pmanager->AddProcess(new G4MuBremsstrahlung, -1,-3, 3);
pmanager->AddProcess(new G4MuPairProduction, -1,-4, 4);
}
else if( particle == "pi-" || particle == "pi+" ||
particle == "kaon-" || particle == "kaon+" ||
particle == "proton" || particle == "anti_proton" ||
particle == "tau-" || particle == "tau+" ||
particle == "deuteron" || particle == "triton" ||
particle == "xi-" || particle == "anti_xi-" ||
particle == "sigma+" || particle == "anti_sigma+" ||
particle == "sigma-" || particle == "anti_sigma-" ||
particle == "omega-" || particle == "anti_omega-" )
{
pmanager->AddProcess(new G4hMultipleScattering, -1, 1, 1);
pmanager->AddProcess(new G4hIonisation, -1, 2, 2);
pmanager->AddProcess(new G4hBremsstrahlung, -1,-3, 3);
pmanager->AddProcess(new G4hPairProduction, -1,-4, 4);
}
else if(particle == "alpha" || particle == "He3" ||particle == "GenericIon")
{
pmanager->AddProcess(new G4hMultipleScattering, -1, 1, 1);
pmanager->AddProcess(new G4ionIonisation, -1, 2, 2);
}
else if (particle == "B+" || particle == "B-" ||
particle == "D+" || particle == "D-" ||
particle == "Ds+" || particle == "Ds-" ||
particle == "lambda_c+" || particle == "anti_lambda_c+" ||
particle == "sigma_c+" || particle == "anti_sigma_c+" ||
particle == "sigma_c++" || particle == "anti_sigma_c++" ||
particle == "xi_c+" || particle == "anti_xi_c+" )
{
pmanager->AddProcess(new G4hMultipleScattering, -1, 1, 1);
pmanager->AddProcess(new G4hIonisation, -1, 2, 2);
}
}
G4EmProcessOptions opt;
opt.SetVerbose(verbose);
}
source/physics_lists/builders/src/G4QCaptureAtRestPhysics.cc
+94
View File
@@ -0,0 +1,94 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4QCaptureAtRestPhysics.cc,v 1.1 2009/11/16 19:12:10 mkossov Exp $
// GEANT4 tag $Name: geant4-09-03 $
//
//---------------------------------------------------------------------------
//
// ClassName: G4QCaptureAtRestPhysics
//
// Author: 16 Nov 2009 M. Kosov
//
// Modified:
//
//----------------------------------------------------------------------------
//
#include "G4QCaptureAtRestPhysics.hh"
G4QCaptureAtRestPhysics::G4QCaptureAtRestPhysics(const G4String& name, G4int ver)
: G4VPhysicsConstructor(name), verbose(ver), wasActivated(false)
{
if(verbose > 1) G4cout << "###> G4QCaptureAtRestPhysics is initialized" << G4endl;
}
G4QCaptureAtRestPhysics::~G4QCaptureAtRestPhysics()
{
if(wasActivated) delete captureProcess;
}
void G4QCaptureAtRestPhysics::ConstructParticle()
{
// G4cout << "G4QCaptureAtRestPhysics::ConstructParticle" << G4endl;
G4LeptonConstructor pLeptonConstructor;
pLeptonConstructor.ConstructParticle();
G4MesonConstructor pMesonConstructor;
pMesonConstructor.ConstructParticle();
G4BaryonConstructor pBaryonConstructor;
pBaryonConstructor.ConstructParticle();
}
void G4QCaptureAtRestPhysics::ConstructProcess()
{
if(verbose>1) G4cout<<"###> G4QCaptureAtRestPhysics::ConstructProcess: "<<wasActivated
<<G4endl;
if(wasActivated) return;
wasActivated = true;
captureProcess = new G4QCaptureAtRest();
// Add Stopping Process
G4ParticleDefinition* particle=0;
G4ProcessManager* pmanager=0;
theParticleIterator->reset();
while( (*theParticleIterator)() )
{
particle = theParticleIterator->value();
pmanager = particle->GetProcessManager();
if(particle->GetPDGCharge() < 0. && particle != G4Electron::Electron() &&
!(particle->IsShortLived()) && captureProcess->IsApplicable(*particle) )
{
pmanager->AddRestProcess(captureProcess);
if(verbose > 1) G4cout << "###> G4QCaptureAtRestPhysics is added for "
<<particle->GetParticleName() << G4endl;
}
}
}
source/physics_lists/builders/src/G4QEmExtraPhysics.cc
+5 -5
View File
@@ -23,8 +23,8 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4QEmExtraPhysics.cc,v 1.1 2007/05/23 17:38:35 vnivanch Exp $
// GEANT4 tag $Name: geant4-09-02 $
// $Id: G4QEmExtraPhysics.cc,v 1.2 2009/11/16 19:12:10 mkossov Exp $
// GEANT4 tag $Name: geant4-09-03 $
//
//---------------------------------------------------------------------------
//
@@ -32,13 +32,13 @@
//
// Author: 23 May 2007 V. Ivanchenko
//
// Modified:
// Modified: 19 Nov 2009 M.Kosov: G4QInelastic instead of G4QCollision
//
//----------------------------------------------------------------------------
//
#include "G4QEmExtraPhysics.hh"
#include "G4QCollision.hh"
#include "G4QInelastic.hh"
#include "G4ParticleDefinition.hh"
#include "G4ProcessManager.hh"
@@ -75,7 +75,7 @@ void G4QEmExtraPhysics::ConstructProcess()
if(wasActivated) return;
wasActivated = true;
hProcess = new G4QCollision();
hProcess = new G4QInelastic();
G4ParticleDefinition* particle = G4Gamma::Gamma();
G4ProcessManager* pmanager = particle->GetProcessManager();
source/physics_lists/builders/src/G4QGSBinaryNeutronBuilder.cc
+16 -1
View File
@@ -23,10 +23,25 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4QGSBinaryNeutronBuilder.cc,v 1.3 2009/03/31 11:03:50 vnivanch Exp $
// GEANT4 tag $Name: geant4-09-03 $
//
//---------------------------------------------------------------------------
//
// ClassName: G4QGSBinaryNeutronBuilder
//
// Author: 2006 G.Folger
//
// Modified:
// 30.03.2009 V.Ivanchenko create cross section by new
//
//----------------------------------------------------------------------------
//
#include "G4QGSBinaryNeutronBuilder.hh"
#include "G4ParticleDefinition.hh"
#include "G4ParticleTable.hh"
#include "G4ProcessManager.hh"
#include "G4NeutronInelasticCrossSection.hh"
G4QGSBinaryNeutronBuilder::
G4QGSBinaryNeutronBuilder(G4bool quasiElastic)
@@ -84,6 +99,6 @@ Build(G4NeutronInelasticProcess * aP)
theModel->SetMinEnergy(theMin);
theModel->SetMaxEnergy(100*TeV);
aP->RegisterMe(theModel);
aP->AddDataSet(&theXSec);
aP->AddDataSet(new G4NeutronInelasticCrossSection);
}
source/physics_lists/builders/src/G4QGSBinaryPiKBuilder.cc
+18 -2
View File
@@ -23,6 +23,20 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4QGSBinaryPiKBuilder.cc,v 1.3 2009/03/31 11:03:50 vnivanch Exp $
// GEANT4 tag $Name: geant4-09-03 $
//
//---------------------------------------------------------------------------
//
// ClassName: G4QGSBinaryPiKBuilder
//
// Author: 2006 G.Folger
//
// Modified:
// 30.03.2009 V.Ivanchenko create cross section by new
//
//----------------------------------------------------------------------------
//
#include "G4QGSBinaryPiKBuilder.hh"
#include "G4ParticleDefinition.hh"
#include "G4ParticleTable.hh"
@@ -31,6 +45,8 @@
G4QGSBinaryPiKBuilder::
G4QGSBinaryPiKBuilder(G4bool quasiElastic)
{
thePiData = new G4PiNuclearCrossSection;
theMin = 12*GeV;
theModel = new G4TheoFSGenerator("QGSB");
@@ -72,7 +88,7 @@ Build(G4PionPlusInelasticProcess * aP)
{
theModel->SetMinEnergy(theMin);
theModel->SetMaxEnergy(100*TeV);
aP->AddDataSet(&thePiData);
aP->AddDataSet(thePiData);
aP->RegisterMe(theModel);
}
@@ -81,7 +97,7 @@ Build(G4PionMinusInelasticProcess * aP)
{
theModel->SetMinEnergy(theMin);
theModel->SetMaxEnergy(100*TeV);
aP->AddDataSet(&thePiData);
aP->AddDataSet(thePiData);
aP->RegisterMe(theModel);
}
source/physics_lists/builders/src/G4QGSBinaryProtonBuilder.cc
+27 -13
View File
@@ -23,13 +23,28 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
#include "G4QGSBinaryProtonBuilder.hh"
#include "G4ParticleDefinition.hh"
#include "G4ParticleTable.hh"
#include "G4ProcessManager.hh"
// $Id: G4QGSBinaryProtonBuilder.cc,v 1.3 2009/03/31 11:03:50 vnivanch Exp $
// GEANT4 tag $Name: geant4-09-03 $
//
//---------------------------------------------------------------------------
//
// ClassName: G4QGSBinaryProtonBuilder
//
// Author: 2006 G.Folger
//
// Modified:
// 30.03.2009 V.Ivanchenko create cross section by new
//
//----------------------------------------------------------------------------
//
#include "G4QGSBinaryProtonBuilder.hh"
#include "G4ParticleDefinition.hh"
#include "G4ParticleTable.hh"
#include "G4ProcessManager.hh"
#include "G4ProtonInelasticCrossSection.hh"
G4QGSBinaryProtonBuilder::
G4QGSBinaryProtonBuilder(G4bool quasiElastic)
G4QGSBinaryProtonBuilder::
G4QGSBinaryProtonBuilder(G4bool quasiElastic)
{
theMin = 12*GeV;
theModel = new G4TheoFSGenerator("QGSB");
@@ -52,23 +67,22 @@
{ theQuasiElastic=0;}
}
void G4QGSBinaryProtonBuilder::
Build(G4ProtonInelasticProcess * aP)
void G4QGSBinaryProtonBuilder::
Build(G4ProtonInelasticProcess * aP)
{
// G4cout << "adding inelastic Proton in QGSBinary" << G4endl;
aP->AddDataSet(&theXSec);
aP->AddDataSet(new G4ProtonInelasticCrossSection);
theModel->SetMinEnergy(theMin);
theModel->SetMaxEnergy(100*TeV);
aP->RegisterMe(theModel);
}
void G4QGSBinaryProtonBuilder::
Build(G4HadronElasticProcess * )
void G4QGSBinaryProtonBuilder::
Build(G4HadronElasticProcess * )
{
}
G4QGSBinaryProtonBuilder::
~G4QGSBinaryProtonBuilder()
G4QGSBinaryProtonBuilder::~G4QGSBinaryProtonBuilder()
{
delete thePreEquilib;
delete theCascade;
source/physics_lists/builders/src/G4QGSBuilder.cc
+95
View File
@@ -0,0 +1,95 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4QGSBuilder.cc,v 1.1 2009/10/04 16:29:54 vnivanch Exp $
// GEANT4 tag $Name: geant4-09-03 $
//
//---------------------------------------------------------------------------
//
// ClassName: G4QGSBuilder
//
// Author: 28 June 2009 V.Ivanchenko
//
// Modified:
//
//----------------------------------------------------------------------------
//
#include "G4QGSBuilder.hh"
#include "G4ExcitedStringDecay.hh"
#include "G4QuasiElasticChannel.hh"
#include "G4ProjectileDiffractiveChannel.hh"
#include "G4TheoFSGenerator.hh"
#include "G4QStringChipsParticleLevelInterface.hh"
#include "G4GeneratorPrecompoundInterface.hh"
#include "G4QGSMFragmentation.hh"
#include "G4ExcitedStringDecay.hh"
#include "G4BinaryCascade.hh"
G4QGSBuilder::G4QGSBuilder(const G4String& aName, G4bool quasiel, G4bool diff)
: G4VHadronModelBuilder(aName), quasielFlag(quasiel), diffFlag(diff)
{
theProjectileDiffraction = 0;
theQuasiElastic = 0;
}
G4QGSBuilder::~G4QGSBuilder()
{
delete theProjectileDiffraction;
delete theQuasiElastic;
delete theQGStringDecay;
delete theQGStringModel;
}
G4HadronicInteraction* G4QGSBuilder::BuildModel()
{
G4TheoFSGenerator* theQGSModel = new G4TheoFSGenerator(GetName());
theQGStringModel = new G4QGSModel< G4QGSParticipants >;
theQGStringDecay = new G4ExcitedStringDecay(new G4QGSMFragmentation());
theQGStringModel->SetFragmentationModel(theQGStringDecay);
theQGSModel->SetHighEnergyGenerator(theQGStringModel);
if(quasielFlag) {
theQuasiElastic = new G4QuasiElasticChannel();
theQGSModel->SetQuasiElasticChannel(theQuasiElastic);
}
if ( diffFlag ) {
theProjectileDiffraction = new G4ProjectileDiffractiveChannel();
theQGSModel->SetProjectileDiffraction(theProjectileDiffraction);
}
if(GetName() == "QGSP") {
theQGSModel->SetTransport(new G4GeneratorPrecompoundInterface());
} else if(GetName() == "QGSC") {
theQGSModel->SetTransport(new G4QStringChipsParticleLevelInterface());
} else if(GetName() == "QGSB") {
theQGSModel->SetTransport(new G4BinaryCascade());
} else {
theQGSModel->SetTransport(new G4GeneratorPrecompoundInterface());
}
return theQGSModel;
}
source/physics_lists/builders/src/G4QGSCEflowNeutronBuilder.cc
+16 -1
View File
@@ -23,10 +23,25 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4QGSCEflowNeutronBuilder.cc,v 1.4 2009/03/31 11:03:50 vnivanch Exp $
// GEANT4 tag $Name: geant4-09-03 $
//
//---------------------------------------------------------------------------
//
// ClassName: G4QGSCEflowNeutronBuilder
//
// Author: 2006 G.Folger
//
// Modified:
// 30.03.2009 V.Ivanchenko create cross section by new
//
//----------------------------------------------------------------------------
//
#include "G4QGSCEflowNeutronBuilder.hh"
#include "G4ParticleDefinition.hh"
#include "G4ParticleTable.hh"
#include "G4ProcessManager.hh"
#include "G4NeutronInelasticCrossSection.hh"
G4QGSCEflowNeutronBuilder::
G4QGSCEflowNeutronBuilder(G4bool quasiElastic)
@@ -66,7 +81,7 @@ Build(G4NeutronInelasticProcess * aP)
theModel->SetMinEnergy(theMin);
theModel->SetMaxEnergy(100*TeV);
aP->RegisterMe(theModel);
aP->AddDataSet(&theXSec);
aP->AddDataSet(new G4NeutronInelasticCrossSection);
}
// 2006 G.Folger
source/physics_lists/builders/src/G4QGSCEflowPiKBuilder.cc
+17 -2
View File
@@ -23,6 +23,20 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4QGSCEflowPiKBuilder.cc,v 1.4 2009/03/31 11:03:50 vnivanch Exp $
// GEANT4 tag $Name: geant4-09-03 $
//
//---------------------------------------------------------------------------
//
// ClassName: G4QGSCEflowPiKBuilder
//
// Author: 2006 G.Folger
//
// Modified:
// 30.03.2009 V.Ivanchenko create cross section by new
//
//----------------------------------------------------------------------------
//
#include "G4QGSCEflowPiKBuilder.hh"
#include "G4ParticleDefinition.hh"
#include "G4ParticleTable.hh"
@@ -31,6 +45,7 @@
G4QGSCEflowPiKBuilder::
G4QGSCEflowPiKBuilder(G4bool quasiElastic)
{
thePiCross = new G4PiNuclearCrossSection;
theMin = 8*GeV;
theModel = new G4TheoFSGenerator("QGSCEflow");
@@ -68,7 +83,7 @@ Build(G4PionPlusInelasticProcess * aP)
{
theModel->SetMinEnergy(theMin);
theModel->SetMaxEnergy(100*TeV);
aP->AddDataSet(&thePiCross);
aP->AddDataSet(thePiCross);
aP->RegisterMe(theModel);
}
@@ -77,7 +92,7 @@ Build(G4PionMinusInelasticProcess * aP)
{
theModel->SetMinEnergy(theMin);
theModel->SetMaxEnergy(100*TeV);
aP->AddDataSet(&thePiCross);
aP->AddDataSet(thePiCross);
aP->RegisterMe(theModel);
}
source/physics_lists/builders/src/G4QGSCEflowProtonBuilder.cc
+16 -1
View File
@@ -23,10 +23,25 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4QGSCEflowProtonBuilder.cc,v 1.4 2009/03/31 11:03:50 vnivanch Exp $
// GEANT4 tag $Name: geant4-09-03 $
//
//---------------------------------------------------------------------------
//
// ClassName: G4QGSCEflowProtonBuilder
//
// Author: 2006 G.Folger
//
// Modified:
// 30.03.2009 V.Ivanchenko create cross section by new
//
//----------------------------------------------------------------------------
//
#include "G4QGSCEflowProtonBuilder.hh"
#include "G4ParticleDefinition.hh"
#include "G4ParticleTable.hh"
#include "G4ProcessManager.hh"
#include "G4ProtonInelasticCrossSection.hh"
G4QGSCEflowProtonBuilder::
G4QGSCEflowProtonBuilder(G4bool quasiElastic)
@@ -71,7 +86,7 @@ Build(G4ProtonInelasticProcess * aP)
theModel->SetMinEnergy(theMin);
theModel->SetMaxEnergy(100*TeV);
aP->RegisterMe(theModel);
aP->AddDataSet(&theXSec);
aP->AddDataSet(new G4ProtonInelasticCrossSection);
}
// 2006 G.Folger
source/physics_lists/builders/src/G4QGSCNeutronBuilder.cc
+25 -11
View File
@@ -23,13 +23,28 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
#include "G4QGSCNeutronBuilder.hh"
#include "G4ParticleDefinition.hh"
#include "G4ParticleTable.hh"
#include "G4ProcessManager.hh"
// $Id: G4QGSCNeutronBuilder.cc,v 1.5 2009/03/31 11:03:50 vnivanch Exp $
// GEANT4 tag $Name: geant4-09-03 $
//
//---------------------------------------------------------------------------
//
// ClassName: G4QGSCNeutronBuilder
//
// Author: 2002 J.P. Wellisch
//
// Modified:
// 30.03.2009 V.Ivanchenko create cross section by new
//
//----------------------------------------------------------------------------
//
#include "G4QGSCNeutronBuilder.hh"
#include "G4ParticleDefinition.hh"
#include "G4ParticleTable.hh"
#include "G4ProcessManager.hh"
#include "G4NeutronInelasticCrossSection.hh"
G4QGSCNeutronBuilder::
G4QGSCNeutronBuilder(G4bool quasiElastic)
G4QGSCNeutronBuilder::
G4QGSCNeutronBuilder(G4bool quasiElastic)
{
theMin = 8*GeV;
theModel = new G4TheoFSGenerator("QGSC");
@@ -50,8 +65,7 @@
{ theQuasiElastic=0;}
}
G4QGSCNeutronBuilder::
~G4QGSCNeutronBuilder()
G4QGSCNeutronBuilder::~G4QGSCNeutronBuilder()
{
delete theStringDecay;
delete theStringModel;
@@ -60,13 +74,13 @@
delete theModel;
}
void G4QGSCNeutronBuilder::
Build(G4NeutronInelasticProcess * aP)
void G4QGSCNeutronBuilder::
Build(G4NeutronInelasticProcess * aP)
{
theModel->SetMinEnergy(theMin);
theModel->SetMaxEnergy(100*TeV);
aP->RegisterMe(theModel);
aP->AddDataSet(&theXSec);
aP->AddDataSet(new G4NeutronInelasticCrossSection);
}
// 2002 by J.P. Wellisch
source/physics_lists/builders/src/G4QGSCPiKBuilder.cc
+17 -2
View File
@@ -23,6 +23,20 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4QGSCPiKBuilder.cc,v 1.5 2009/03/31 11:03:50 vnivanch Exp $
// GEANT4 tag $Name: geant4-09-03 $
//
//---------------------------------------------------------------------------
//
// ClassName: G4QGSCPiKBuilder
//
// Author: 2002 J.P. Wellisch
//
// Modified:
// 30.03.2009 V.Ivanchenko create cross section by new
//
//----------------------------------------------------------------------------
//
#include "G4QGSCPiKBuilder.hh"
#include "G4ParticleDefinition.hh"
#include "G4ParticleTable.hh"
@@ -31,6 +45,7 @@
G4QGSCPiKBuilder::
G4QGSCPiKBuilder(G4bool quasiElastic)
{
thePiCross = new G4PiNuclearCrossSection;
theMin = 8*GeV;
theModel = new G4TheoFSGenerator("QGSC");
@@ -68,7 +83,7 @@ Build(G4PionPlusInelasticProcess * aP)
{
theModel->SetMinEnergy(theMin);
theModel->SetMaxEnergy(100*TeV);
aP->AddDataSet(&thePiCross);
aP->AddDataSet(thePiCross);
aP->RegisterMe(theModel);
}
@@ -77,7 +92,7 @@ Build(G4PionMinusInelasticProcess * aP)
{
theModel->SetMinEnergy(theMin);
theModel->SetMaxEnergy(100*TeV);
aP->AddDataSet(&thePiCross);
aP->AddDataSet(thePiCross);
aP->RegisterMe(theModel);
}
source/physics_lists/builders/src/G4QGSCProtonBuilder.cc
+15 -1
View File
@@ -23,10 +23,24 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4QGSCProtonBuilder.cc,v 1.5 2009/03/31 11:03:50 vnivanch Exp $
// GEANT4 tag $Name: geant4-09-03 $
//
//---------------------------------------------------------------------------
//
// ClassName: G4QGSCProtonBuilder
//
// Author: 2002 J.P. Wellisch
//
// Modified:
// 30.03.2009 V.Ivanchenko create cross section by new
//
//----------------------------------------------------------------------------//
#include "G4QGSCProtonBuilder.hh"
#include "G4ParticleDefinition.hh"
#include "G4ParticleTable.hh"
#include "G4ProcessManager.hh"
#include "G4ProtonInelasticCrossSection.hh"
G4QGSCProtonBuilder::
G4QGSCProtonBuilder(G4bool quasiElastic)
@@ -71,7 +85,7 @@ Build(G4ProtonInelasticProcess * aP)
theModel->SetMinEnergy(theMin);
theModel->SetMaxEnergy(100*TeV);
aP->RegisterMe(theModel);
aP->AddDataSet(&theXSec);
aP->AddDataSet(new G4ProtonInelasticCrossSection);
}
// 2002 by J.P. Wellisch
source/physics_lists/builders/src/G4QGSC_CHIPSNeutronBuilder.cc
+72
View File
@@ -0,0 +1,72 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
#include "G4QGSC_CHIPSNeutronBuilder.hh"
#include "G4ParticleDefinition.hh"
#include "G4ParticleTable.hh"
#include "G4ProcessManager.hh"
G4QGSC_CHIPSNeutronBuilder::
G4QGSC_CHIPSNeutronBuilder(G4bool quasiElastic)
{
theMin = 0*GeV;
theModel = new G4TheoFSGenerator("QGSC_CHIPS");
theStringModel= new G4QGSModel< G4QGSParticipants >;
theStringDecay = new G4ExcitedStringDecay(new G4QGSMFragmentation);
theStringModel->SetFragmentationModel(theStringDecay);
theCascade = new G4StringChipsParticleLevelInterface;
theModel->SetTransport(theCascade);
theModel->SetHighEnergyGenerator(theStringModel);
if (quasiElastic)
{
theQuasiElastic=new G4QuasiElasticChannel;
theModel->SetQuasiElasticChannel(theQuasiElastic);
} else
{ theQuasiElastic=0;}
}
G4QGSC_CHIPSNeutronBuilder::
~G4QGSC_CHIPSNeutronBuilder()
{
delete theStringDecay;
delete theStringModel;
delete theCascade;
if ( theQuasiElastic ) delete theQuasiElastic;
delete theModel;
}
void G4QGSC_CHIPSNeutronBuilder::
Build(G4NeutronInelasticProcess * aP)
{
theModel->SetMinEnergy(theMin);
theModel->SetMaxEnergy(100*TeV);
aP->RegisterMe(theModel);
aP->AddDataSet(&theXSec);
}
// 2009 by M. Kosov
source/physics_lists/builders/src/G4QGSC_CHIPSPiKBuilder.cc
+116
View File
@@ -0,0 +1,116 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
#include "G4QGSC_CHIPSPiKBuilder.hh"
#include "G4ParticleDefinition.hh"
#include "G4ParticleTable.hh"
#include "G4ProcessManager.hh"
G4QGSC_CHIPSPiKBuilder::
G4QGSC_CHIPSPiKBuilder(G4bool quasiElastic)
{
theMin = 0*GeV;
theModel = new G4TheoFSGenerator("QGSC_CHIPS");
theStringModel = new G4QGSModel< G4QGSParticipants >;
theStringDecay = new G4ExcitedStringDecay(new G4QGSMFragmentation);
theStringModel->SetFragmentationModel(theStringDecay);
theCascade = new G4StringChipsParticleLevelInterface;
theModel->SetTransport(theCascade);
theModel->SetHighEnergyGenerator(theStringModel);
if (quasiElastic)
{
theQuasiElastic=new G4QuasiElasticChannel;
theModel->SetQuasiElasticChannel(theQuasiElastic);
} else
{ theQuasiElastic=0;}
}
G4QGSC_CHIPSPiKBuilder::
~G4QGSC_CHIPSPiKBuilder()
{
delete theCascade;
delete theStringDecay;
delete theStringModel;
if ( theQuasiElastic ) delete theQuasiElastic;
delete theModel;
}
void G4QGSC_CHIPSPiKBuilder::
Build(G4HadronElasticProcess * ) {}
void G4QGSC_CHIPSPiKBuilder::
Build(G4PionPlusInelasticProcess * aP)
{
theModel->SetMinEnergy(theMin);
theModel->SetMaxEnergy(100*TeV);
aP->AddDataSet(&thePiCross);
aP->RegisterMe(theModel);
}
void G4QGSC_CHIPSPiKBuilder::
Build(G4PionMinusInelasticProcess * aP)
{
theModel->SetMinEnergy(theMin);
theModel->SetMaxEnergy(100*TeV);
aP->AddDataSet(&thePiCross);
aP->RegisterMe(theModel);
}
void G4QGSC_CHIPSPiKBuilder::
Build(G4KaonPlusInelasticProcess * aP)
{
theModel->SetMinEnergy(theMin);
theModel->SetMaxEnergy(100*TeV);
aP->RegisterMe(theModel);
}
void G4QGSC_CHIPSPiKBuilder::
Build(G4KaonMinusInelasticProcess * aP)
{
theModel->SetMinEnergy(theMin);
theModel->SetMaxEnergy(100*TeV);
aP->RegisterMe(theModel);
}
void G4QGSC_CHIPSPiKBuilder::
Build(G4KaonZeroLInelasticProcess * aP)
{
theModel->SetMinEnergy(theMin);
theModel->SetMaxEnergy(100*TeV);
aP->RegisterMe(theModel);
}
void G4QGSC_CHIPSPiKBuilder::
Build(G4KaonZeroSInelasticProcess * aP)
{
theModel->SetMinEnergy(theMin);
theModel->SetMaxEnergy(100*TeV);
aP->RegisterMe(theModel);
}
// 2009 by M. Kosov
source/physics_lists/builders/src/G4QGSC_CHIPSProtonBuilder.cc
+77
View File
@@ -0,0 +1,77 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
#include "G4QGSC_CHIPSProtonBuilder.hh"
#include "G4ParticleDefinition.hh"
#include "G4ParticleTable.hh"
#include "G4ProcessManager.hh"
G4QGSC_CHIPSProtonBuilder::
G4QGSC_CHIPSProtonBuilder(G4bool quasiElastic)
{
theMin = 0*GeV;
theModel = new G4TheoFSGenerator("QGSC_CHIPS");
theStringModel = new G4QGSModel< G4QGSParticipants >;
theStringDecay = new G4ExcitedStringDecay(new G4QGSMFragmentation);
theStringModel->SetFragmentationModel(theStringDecay);
theCascade = new G4StringChipsParticleLevelInterface;
theModel->SetHighEnergyGenerator(theStringModel);
theModel->SetTransport(theCascade);
if (quasiElastic)
{
theQuasiElastic=new G4QuasiElasticChannel;
theModel->SetQuasiElasticChannel(theQuasiElastic);
} else
{ theQuasiElastic=0;}
}
G4QGSC_CHIPSProtonBuilder::
~G4QGSC_CHIPSProtonBuilder()
{
delete theCascade;
delete theStringDecay;
delete theStringModel;
if ( theQuasiElastic ) delete theQuasiElastic;
delete theModel;
}
void G4QGSC_CHIPSProtonBuilder::
Build(G4HadronElasticProcess * )
{
}
void G4QGSC_CHIPSProtonBuilder::
Build(G4ProtonInelasticProcess * aP)
{
theModel->SetMinEnergy(theMin);
theModel->SetMaxEnergy(100*TeV);
aP->RegisterMe(theModel);
aP->AddDataSet(&theXSec);
}
// 2009 by M. Kosov
source/physics_lists/builders/src/G4QGSC_QGSCNeutronBuilder.cc
+72
View File
@@ -0,0 +1,72 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
#include "G4QGSC_QGSCNeutronBuilder.hh"
#include "G4ParticleDefinition.hh"
#include "G4ParticleTable.hh"
#include "G4ProcessManager.hh"
G4QGSC_QGSCNeutronBuilder::
G4QGSC_QGSCNeutronBuilder(G4bool quasiElastic)
{
theMin = 0*GeV;
theModel = new G4TheoFSGenerator("QGSC");
theStringModel= new G4QGSModel< G4QGSParticipants >;
theStringDecay = new G4ExcitedStringDecay(new G4QGSMFragmentation);
theStringModel->SetFragmentationModel(theStringDecay);
theCascade = new G4QStringChipsParticleLevelInterface;
theModel->SetTransport(theCascade);
theModel->SetHighEnergyGenerator(theStringModel);
if (quasiElastic)
{
theQuasiElastic=new G4QuasiElasticChannel;
theModel->SetQuasiElasticChannel(theQuasiElastic);
} else
{ theQuasiElastic=0;}
}
G4QGSC_QGSCNeutronBuilder::
~G4QGSC_QGSCNeutronBuilder()
{
delete theStringDecay;
delete theStringModel;
delete theCascade;
if ( theQuasiElastic ) delete theQuasiElastic;
delete theModel;
}
void G4QGSC_QGSCNeutronBuilder::
Build(G4NeutronInelasticProcess * aP)
{
theModel->SetMinEnergy(theMin);
theModel->SetMaxEnergy(100*TeV);
aP->RegisterMe(theModel);
aP->AddDataSet(&theXSec);
}
// 2009 by M. Kosov
source/physics_lists/builders/src/G4QGSC_QGSCPiKBuilder.cc
+116
View File
@@ -0,0 +1,116 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
#include "G4QGSC_QGSCPiKBuilder.hh"
#include "G4ParticleDefinition.hh"
#include "G4ParticleTable.hh"
#include "G4ProcessManager.hh"
G4QGSC_QGSCPiKBuilder::
G4QGSC_QGSCPiKBuilder(G4bool quasiElastic)
{
theMin = 0*GeV;
theModel = new G4TheoFSGenerator("QGSC");
theStringModel = new G4QGSModel< G4QGSParticipants >;
theStringDecay = new G4ExcitedStringDecay(new G4QGSMFragmentation);
theStringModel->SetFragmentationModel(theStringDecay);
theCascade = new G4QStringChipsParticleLevelInterface;
theModel->SetTransport(theCascade);
theModel->SetHighEnergyGenerator(theStringModel);
if (quasiElastic)
{
theQuasiElastic=new G4QuasiElasticChannel;
theModel->SetQuasiElasticChannel(theQuasiElastic);
} else
{ theQuasiElastic=0;}
}
G4QGSC_QGSCPiKBuilder::
~G4QGSC_QGSCPiKBuilder()
{
delete theCascade;
delete theStringDecay;
delete theStringModel;
if ( theQuasiElastic ) delete theQuasiElastic;
delete theModel;
}
void G4QGSC_QGSCPiKBuilder::
Build(G4HadronElasticProcess * ) {}
void G4QGSC_QGSCPiKBuilder::
Build(G4PionPlusInelasticProcess * aP)
{
theModel->SetMinEnergy(theMin);
theModel->SetMaxEnergy(100*TeV);
aP->AddDataSet(&thePiCross);
aP->RegisterMe(theModel);
}
void G4QGSC_QGSCPiKBuilder::
Build(G4PionMinusInelasticProcess * aP)
{
theModel->SetMinEnergy(theMin);
theModel->SetMaxEnergy(100*TeV);
aP->AddDataSet(&thePiCross);
aP->RegisterMe(theModel);
}
void G4QGSC_QGSCPiKBuilder::
Build(G4KaonPlusInelasticProcess * aP)
{
theModel->SetMinEnergy(theMin);
theModel->SetMaxEnergy(100*TeV);
aP->RegisterMe(theModel);
}
void G4QGSC_QGSCPiKBuilder::
Build(G4KaonMinusInelasticProcess * aP)
{
theModel->SetMinEnergy(theMin);
theModel->SetMaxEnergy(100*TeV);
aP->RegisterMe(theModel);
}
void G4QGSC_QGSCPiKBuilder::
Build(G4KaonZeroLInelasticProcess * aP)
{
theModel->SetMinEnergy(theMin);
theModel->SetMaxEnergy(100*TeV);
aP->RegisterMe(theModel);
}
void G4QGSC_QGSCPiKBuilder::
Build(G4KaonZeroSInelasticProcess * aP)
{
theModel->SetMinEnergy(theMin);
theModel->SetMaxEnergy(100*TeV);
aP->RegisterMe(theModel);
}
// 2009 by M. Kosov
source/physics_lists/builders/src/G4QGSC_QGSCProtonBuilder.cc
+77
View File
@@ -0,0 +1,77 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
#include "G4QGSC_QGSCProtonBuilder.hh"
#include "G4ParticleDefinition.hh"
#include "G4ParticleTable.hh"
#include "G4ProcessManager.hh"
G4QGSC_QGSCProtonBuilder::
G4QGSC_QGSCProtonBuilder(G4bool quasiElastic)
{
theMin = 0*GeV;
theModel = new G4TheoFSGenerator("QGSC");
theStringModel = new G4QGSModel< G4QGSParticipants >;
theStringDecay = new G4ExcitedStringDecay(new G4QGSMFragmentation);
theStringModel->SetFragmentationModel(theStringDecay);
theCascade = new G4QStringChipsParticleLevelInterface;
theModel->SetHighEnergyGenerator(theStringModel);
theModel->SetTransport(theCascade);
if (quasiElastic)
{
theQuasiElastic=new G4QuasiElasticChannel;
theModel->SetQuasiElasticChannel(theQuasiElastic);
} else
{ theQuasiElastic=0;}
}
G4QGSC_QGSCProtonBuilder::
~G4QGSC_QGSCProtonBuilder()
{
delete theCascade;
delete theStringDecay;
delete theStringModel;
if ( theQuasiElastic ) delete theQuasiElastic;
delete theModel;
}
void G4QGSC_QGSCProtonBuilder::
Build(G4HadronElasticProcess * )
{
}
void G4QGSC_QGSCProtonBuilder::
Build(G4ProtonInelasticProcess * aP)
{
theModel->SetMinEnergy(theMin);
theModel->SetMaxEnergy(100*TeV);
aP->RegisterMe(theModel);
aP->AddDataSet(&theXSec);
}
// 2009 by M. Kosov
source/physics_lists/builders/src/G4QGSPNeutronBuilder.cc
+16 -1
View File
@@ -23,10 +23,25 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4QGSPNeutronBuilder.cc,v 1.5 2009/03/31 11:03:50 vnivanch Exp $
// GEANT4 tag $Name: geant4-09-03 $
//
//---------------------------------------------------------------------------
//
// ClassName: G4QGSPNeutronBuilder
//
// Author: 2002 J.P. Wellisch
//
// Modified:
// 30.03.2009 V.Ivanchenko create cross section by new
//
//----------------------------------------------------------------------------
//
#include "G4QGSPNeutronBuilder.hh"
#include "G4ParticleDefinition.hh"
#include "G4ParticleTable.hh"
#include "G4ProcessManager.hh"
#include "G4NeutronInelasticCrossSection.hh"
G4QGSPNeutronBuilder::
G4QGSPNeutronBuilder(G4bool quasiElastic, G4bool projectileDiffraction)
@@ -91,7 +106,7 @@ Build(G4NeutronInelasticProcess * aP)
theModel->SetMinEnergy(theMin);
theModel->SetMaxEnergy(100*TeV);
aP->RegisterMe(theModel);
aP->AddDataSet(&theXSec);
aP->AddDataSet(new G4NeutronInelasticCrossSection);
}
// 2002 by J.P. Wellisch
source/physics_lists/builders/src/G4QGSPPiKBuilder.cc
+18 -2
View File
@@ -23,14 +23,30 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4QGSPPiKBuilder.cc,v 1.5 2009/03/31 11:03:50 vnivanch Exp $
// GEANT4 tag $Name: geant4-09-03 $
//
//---------------------------------------------------------------------------
//
// ClassName: G4QGSPPiKBuilder
//
// Author: 2002 J.P. Wellisch
//
// Modified:
// 30.03.2009 V.Ivanchenko create cross section by new
//
//----------------------------------------------------------------------------
//
#include "G4QGSPPiKBuilder.hh"
#include "G4ParticleDefinition.hh"
#include "G4ParticleTable.hh"
#include "G4ProcessManager.hh"
#include "G4PiNuclearCrossSection.hh"
G4QGSPPiKBuilder::
G4QGSPPiKBuilder(G4bool quasiElastic, G4bool projectileDiffraction)
{
thePiData = new G4PiNuclearCrossSection();
theMin = 12*GeV;
theModel = new G4TheoFSGenerator("QGSP");
@@ -80,7 +96,7 @@ Build(G4PionPlusInelasticProcess * aP)
{
theModel->SetMinEnergy(theMin);
theModel->SetMaxEnergy(100*TeV);
aP->AddDataSet(&thePiData);
aP->AddDataSet(thePiData);
aP->RegisterMe(theModel);
}
@@ -89,7 +105,7 @@ Build(G4PionMinusInelasticProcess * aP)
{
theModel->SetMinEnergy(theMin);
theModel->SetMaxEnergy(100*TeV);
aP->AddDataSet(&thePiData);
aP->AddDataSet(thePiData);
aP->RegisterMe(theModel);
}
source/physics_lists/builders/src/G4QGSPProtonBuilder.cc
+28 -14
View File
@@ -23,13 +23,28 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
#include "G4QGSPProtonBuilder.hh"
#include "G4ParticleDefinition.hh"
#include "G4ParticleTable.hh"
#include "G4ProcessManager.hh"
// $Id: G4QGSPProtonBuilder.cc,v 1.5 2009/03/31 11:03:50 vnivanch Exp $
// GEANT4 tag $Name: geant4-09-03 $
//
//---------------------------------------------------------------------------
//
// ClassName: G4QGSPProtonBuilder
//
// Author: 2002 J.P. Wellisch
//
// Modified:
// 30.03.2009 V.Ivanchenko create cross section by new
//
//----------------------------------------------------------------------------
//
#include "G4QGSPProtonBuilder.hh"
#include "G4ParticleDefinition.hh"
#include "G4ParticleTable.hh"
#include "G4ProcessManager.hh"
#include "G4ProtonInelasticCrossSection.hh"
G4QGSPProtonBuilder::
G4QGSPProtonBuilder(G4bool quasiElastic, G4bool projectileDiffraction)
G4QGSPProtonBuilder::
G4QGSPProtonBuilder(G4bool quasiElastic, G4bool projectileDiffraction)
{
theMin = 12*GeV;
theModel = new G4TheoFSGenerator("QGSP");
@@ -58,23 +73,22 @@
{ theProjectileDiffraction=0;}
}
void G4QGSPProtonBuilder::
Build(G4ProtonInelasticProcess * aP)
void G4QGSPProtonBuilder::
Build(G4ProtonInelasticProcess * aP)
{
// G4cout << "adding inelastic Proton in QGSP" << G4endl;
aP->AddDataSet(&theXSec);
// G4cout << "adding inelastic Proton in QGSP" << G4endl;
aP->AddDataSet(new G4ProtonInelasticCrossSection());
theModel->SetMinEnergy(theMin);
theModel->SetMaxEnergy(100*TeV);
aP->RegisterMe(theModel);
}
void G4QGSPProtonBuilder::
Build(G4HadronElasticProcess * )
void G4QGSPProtonBuilder::
Build(G4HadronElasticProcess * )
{
}
G4QGSPProtonBuilder::
~G4QGSPProtonBuilder()
G4QGSPProtonBuilder::~G4QGSPProtonBuilder()
{
delete thePreEquilib;
delete theCascade;
source/physics_lists/builders/src/G4QInelasticCHIPSBuilder.cc
+91
View File
@@ -0,0 +1,91 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// GEANT4 tag $Name: geant4-09-03 $
//
//---------------------------------------------------------------------------
//
// ClassName: G4QInelasticCHIPSBuilder
//
// Author: 2009 M. Kosov
//
//----------------------------------------------------------------------------
//
// Short comment: This is a physics list of only one model G4QInelastic for
// all hadron-nuclear interactions at all energies. There is no model- or
// process-mixing, while it is possible to merge (G4QProcessMixer) the G4_HP
// processes at low energies if the G4QInelastic, which includes all necessary
// nA inelastic processes, is found to be not saficient for some applications.
// In this particular builder the G4QInelastic process is attached to all
// hadrons other than nucleons or pi and K-mesons. Previously it could be done
// only using the LHEP parameterized package or in a temporary form by the
// QGSC model conditionally extended (just not crashing) to low energies.
// *** Important *** As the CHIPS treatment of all hadrons is the same, and
// very simple, this builder with time can be not used in the CHIPS physics list
//
// -----------------------------------------------------------------------------
#include "G4QInelasticCHIPSBuilder.hh"
G4QInelasticCHIPSBuilder::G4QInelasticCHIPSBuilder(G4int ver):
verbose(ver), wasActivated(false)
{
// pointer to the particle table
theParticleTable = G4ParticleTable::GetParticleTable();
theParticleIterator = theParticleTable->GetIterator();
}
G4QInelasticCHIPSBuilder::~G4QInelasticCHIPSBuilder()
{
if(wasActivated) delete inelastic;
}
void G4QInelasticCHIPSBuilder::Build()
{
if(wasActivated) return;
wasActivated = true;
theParticleIterator->reset();
inelastic = new G4QInelastic();
while( (*theParticleIterator)() )
{
G4ParticleDefinition* particle = theParticleIterator->value();
G4String pname = particle->GetParticleName();
if(pname == "kaon-" || pname == "kaon+" || pname == "kaon0S" || pname == "kaon0L" ||
pname == "pi-" || pname == "pi+" || pname == "neutron" || pname == "proton" ||
pname == "lambda" || pname == "sigma+" || pname == "sigma0" ||
pname == "sigma-" || pname == "xi0" || pname == "xi-" || pname == "omega-" ||
pname == "anti_proton" || pname == "anti_neutron" || pname == "anti_lambda" ||
pname == "anti_sigma+" || pname == "anti_sigma0" || pname == "anti_sigma-" ||
pname == "anti_xi0" || pname == "anti_xi-" || pname == "anti_omega-" )
{
if(verbose>1)G4cout<< "__G4QInelCHIPSBuilder: "<< pname <<" is defined here"<<G4endl;
G4ProcessManager* pmanager = particle->GetProcessManager();
pmanager->AddDiscreteProcess(inelastic);
if(verbose>1) G4cout<<"###> G4QInelasticCHIPSBuilder: "<<inelastic->GetProcessName()
<<" is added for "<<pname<<G4endl;
}
}
}
// 2009 by M. Kosov
source/physics_lists/builders/src/G4QMessenger.cc
+226
View File
@@ -0,0 +1,226 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4QMessenger.cc,v 1.1 2009/11/13 18:50:14 mkossov Exp $
// GEANT4 tag $Name: geant4-09-03 $
//
//---------------------------------------------------------------------------
//
// ClassName: G4QMessenger
//
// Author: 2009 M. V. Kossov
//
// Modified:
//
//----------------------------------------------------------------------------
//
#include "G4QMessenger.hh"
#include "G4QNeutrinoPhysics.hh"
#include "G4QPhotoNuclearPhysics.hh"
G4QMessenger::G4QMessenger()
{
rootDir = new G4UIdirectory("/CHIPS_physics/");
rootDir->SetGuidance("messenger of the CHIPS processes");
weakDir=0;
photoDir=0;
}
G4QMessenger::~G4QMessenger()
{
delete rootDir;
if(photoDir)
{
delete photoDir;
delete theSynchR;
delete minGamSR;
delete theGamN;
delete theEleN;
delete theMuoN;
delete theTauN;
delete biasPhotoN;
}
else if(weakDir)
{
delete weakDir;
delete theNuElN;
delete theNuMuN;
delete theNuTaN;
delete biasNuNuc;
}
}
// Returns Pointer to the G4QMessenger class
G4QMessenger* G4QMessenger::GetPointer()
{
static G4QMessenger theMessenger; //**Static body of CHIPS Messenger**
return &theMessenger;
}
void G4QMessenger::Add(G4QNeutrinoPhysics* weak)
{
theWeak = weak;
weakDir = new G4UIdirectory("/CHIPS_physics/neutrino/");
weakDir->SetGuidance("weak (neutrino) processes");
// commands for neutrino_el-nuclear physics.
theNuElN = new G4UIcmdWithAString("/CHIPS_physics/neutrino/NuElNuclear",this);
theNuElN->SetGuidance("Switching of nu_el-nuclear physics.");
theNuElN->SetParameterName("status","off");
theNuElN->SetCandidates("on off");
theNuElN->SetDefaultValue("off");
theNuElN->AvailableForStates(G4State_PreInit, G4State_Idle);
// commands for neutrino_mu-nuclear physics.
theNuMuN = new G4UIcmdWithAString("/CHIPS_physics/neutrino/NuMuNuclear",this);
theNuMuN->SetGuidance("Switching of nu_mu-nuclear physics.");
theNuMuN->SetParameterName("status","off");
theNuMuN->SetCandidates("on off");
theNuMuN->SetDefaultValue("off");
theNuMuN->AvailableForStates(G4State_PreInit, G4State_Idle);
// commands for neutrino_tau-nuclear physics.
theNuTaN = new G4UIcmdWithAString("/CHIPS_physics/neutrino/NuTauNuclear",this);
theNuTaN->SetGuidance("Switching of nu_tau-nuclear physics.");
theNuTaN->SetParameterName("status","off");
theNuTaN->SetCandidates("on off");
theNuTaN->SetDefaultValue("off");
theNuTaN->AvailableForStates(G4State_PreInit, G4State_Idle);
// command for biasing of neutrino-nuclear reactions
biasNuNuc = new G4UIcmdWithADouble("/CHIPS_physics/neutrino/NuNuc_Biasing", this);
biasNuNuc->SetGuidance("Set a biasing coefficient for neutrino-nuclear ractions");
biasNuNuc->SetParameterName("NuNuc_Biasing", false);
biasNuNuc->SetRange("NuNuc_Biasing > 0.");
biasNuNuc->SetDefaultValue(1.);
biasNuNuc->AvailableForStates(G4State_PreInit, G4State_Idle);
}
void G4QMessenger::Add(G4QPhotoNuclearPhysics* photo)
{
thePhoto = photo;
weakDir = new G4UIdirectory("/CHIPS_physics/photoNuclear/");
weakDir->SetGuidance("weak (neutrino) processes");
// use G4UIcmdWithADouble for weighting of processes
// command for synchrotron radiation.
theSynchR = new G4UIcmdWithAString("/CHIPS_physics/photoNuclear/SynchRadiation",this);
theSynchR->SetGuidance("Switching on/off synchrotron radiation.");
theSynchR->SetParameterName("status","off");
theSynchR->SetCandidates("on off");
theSynchR->SetDefaultValue("off");
theSynchR->AvailableForStates(G4State_PreInit, G4State_Idle);
minGamSR = new G4UIcmdWithADouble("/CHIPS_physics/photoNuclear/MinGamma_SynchRad", this);
minGamSR->SetGuidance("Set a minimum gamma for Synchratron Radiation");
minGamSR->SetParameterName("MinGamma_SynchRad", false);
minGamSR->SetRange("MinGamma_SynchRad >> 1.");
minGamSR->SetDefaultValue(227.);
minGamSR->AvailableForStates(G4State_PreInit, G4State_Idle);
// command for gamma-nuclear physics.
theGamN = new G4UIcmdWithAString("/CHIPS_physics/photoNuclear/GammaNuclear",this);
theGamN->SetGuidance("Switching of gamma-nuclear physics.");
theGamN->SetParameterName("status","off");
theGamN->SetCandidates("on off");
theGamN->SetDefaultValue("on");
theGamN->AvailableForStates(G4State_PreInit, G4State_Idle);
// command for electro-nuclear physics.
theEleN = new G4UIcmdWithAString("/CHIPS_physics/photoNuclear/ElectroNuclear",this);
theEleN->SetGuidance("Switching of electron-nuclear physics.");
theEleN->SetParameterName("status","off");
theEleN->SetCandidates("on off");
theEleN->SetDefaultValue("off");
theEleN->AvailableForStates(G4State_PreInit, G4State_Idle);
// command for muon-nuclear physics.
theMuoN = new G4UIcmdWithAString("/CHIPS_physics/photoNuclear/MuonNuclear",this);
theMuoN->SetGuidance("Switching of muon nuclear physics.");
theMuoN->SetParameterName("status","off");
theMuoN->SetCandidates("on off");
theMuoN->SetDefaultValue("off");
theMuoN->AvailableForStates(G4State_PreInit, G4State_Idle);
// command for tau-nuclear physics.
theTauN = new G4UIcmdWithAString("/CHIPS_physics/photoNuclear/TauNuclear",this);
theTauN->SetGuidance("Switching of tau nuclear physics.");
theTauN->SetParameterName("status","off");
theTauN->SetCandidates("on off");
theTauN->SetDefaultValue("off");
theTauN->AvailableForStates(G4State_PreInit, G4State_Idle);
biasPhotoN = new G4UIcmdWithADouble("/CHIPS_physics/photoNuclear/PhotoN_Biasing", this);
biasPhotoN->SetGuidance("Set a biasing coefficient for photo-nuclear ractions");
biasPhotoN->SetParameterName("PhotoN_Biasing", false);
biasPhotoN->SetRange("PhotoN_Biasing > 0.");
biasPhotoN->SetDefaultValue(1.);
biasPhotoN->AvailableForStates(G4State_PreInit, G4State_Idle);
}
void G4QMessenger::SetNewValue(G4UIcommand* aComm, G4String aS)
{
if(photoDir)
{
if (aComm==theSynchR) thePhoto->SetSynchRadOnOff(aS);
else if(aComm==minGamSR) thePhoto->SetMinGammaSR(minGamSR->GetNewDoubleValue(aS));
else if(aComm==theGamN) thePhoto->SetGammaNuclearOnOff(aS);
else if(aComm==theMuoN) thePhoto->SetElPosNuclearOnOff(aS);
else if(aComm==theMuoN) thePhoto->SetMuonNuclearOnOff(aS);
else if(aComm==theMuoN) thePhoto->SetTauNuclearOnOff(aS);
else if(aComm==biasPhotoN)thePhoto->SetPhotoNucBias(biasPhotoN->GetNewDoubleValue(aS));
}
else if(weakDir)
{
if (aComm==theNuElN) theWeak->SetNuElNuclearOnOff(aS);
else if(aComm==theNuMuN) theWeak->SetNuMuNuclearOnOff(aS);
else if(aComm==theNuTaN) theWeak->SetNuTauNuclearOnOff(aS);
else if(aComm==biasNuNuc) theWeak->SetNuNuclearBias(biasNuNuc->GetNewDoubleValue(aS));
}
}
G4String G4QMessenger::GetCurrentValue(G4UIcommand* aComm)
{
if(photoDir)
{
if (aComm==theSynchR) return thePhoto->GetSynchRadOnOff();
else if(aComm==theGamN) return thePhoto->GetGammaNuclearOnOff();
else if(aComm==theEleN) return thePhoto->GetElPosNuclearOnOff();
else if(aComm==theMuoN) return thePhoto->GetMuonNuclearOnOff();
else if(aComm==theTauN) return thePhoto->GetTauNuclearOnOff();
}
else if(weakDir)
{
if (aComm==theNuElN) return theWeak->GetNuElNuclearOnOff();
else if(aComm==theNuMuN) return theWeak->GetNuMuNuclearOnOff();
else if(aComm==theNuTaN) return theWeak->GetNuTauNuclearOnOff();
}
return "not_defined";
}
source/physics_lists/builders/src/G4QNeutrinoPhysics.cc
+145
View File
@@ -0,0 +1,145 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4QNeutrinoPhysics.cc,v 1.3 2009/11/30 18:44:49 mkossov Exp $
// GEANT4 tag $Name: geant4-09-03 $
//
//---------------------------------------------------------------------------
//
// ClassName: G4QNeutrinoPhysics
//
// Author: 2009 M. V. Kosov
//
// Modified:
//
//----------------------------------------------------------------------------
//
#include "G4QNeutrinoPhysics.hh"
G4QNeutrinoPhysics::G4QNeutrinoPhysics(const G4String& name):
G4VPhysicsConstructor(name), wasBuilt(false), nuEleActivated(false),
nuMuoActivated(false), nuTauActivated(false), nuEleOn(false),
nuMuoOn(false), nuTauOn(false), nuNucBias(1.), inelastic(0)
{
theMessenger = G4QMessenger::GetPointer();
theMessenger->Add(this);
}
G4QNeutrinoPhysics::~G4QNeutrinoPhysics()
{
if(wasBuilt && inelastic) delete inelastic;
}
void G4QNeutrinoPhysics::ConstructParticle()
{
G4NeutrinoE::NeutrinoE();
G4AntiNeutrinoE::AntiNeutrinoE();
G4NeutrinoMu::NeutrinoMu();
G4AntiNeutrinoMu::AntiNeutrinoMu();
G4NeutrinoTau::NeutrinoTau();
G4AntiNeutrinoTau::AntiNeutrinoTau();
}
void G4QNeutrinoPhysics::SetNuElNuclearOnOff(G4String& newSwitch)
{
if(wasBuilt) G4cout<<"G4QNeutrinoPhysics:No, processes are already builded!"<<G4endl;
else if(newSwitch == "on" || newSwitch == "ON" || newSwitch == "On") nuEleOn = true;
else nuEleOn = false;
}
void G4QNeutrinoPhysics::SetNuMuNuclearOnOff(G4String& newSwitch)
{
if(wasBuilt) G4cout<<"G4QNeutrinoPhysics:No, processes are already builded!"<<G4endl;
else if(newSwitch == "on" || newSwitch == "ON" || newSwitch == "On") nuMuoOn = true;
else nuMuoOn = false;
}
void G4QNeutrinoPhysics::SetNuTauNuclearOnOff(G4String& newSwitch)
{
if(wasBuilt) G4cout<<"G4QNeutrinoPhysics:No, processes are already builded!"<<G4endl;
else if(newSwitch == "on" || newSwitch == "ON" || newSwitch == "On") nuTauOn = true;
else nuTauOn = false;
}
void G4QNeutrinoPhysics::SetNuNuclearBias(G4double newValue)
{
if(wasBuilt) G4cout<<"G4QNeutrinoPhysics:No, processes are already builded!"<<G4endl;
else nuNucBias = newValue;
}
void G4QNeutrinoPhysics::ConstructProcess()
{
if(wasBuilt) return;
if(nuEleOn || nuMuoOn || nuTauOn)
{
wasBuilt = true;
G4cout<<"Builded=>G4QNeutrinoPhysics: "<<nuEleOn<<", "<<nuMuoOn<<", "<<nuTauOn<<G4endl;
inelastic = new G4QInelastic("neutrinoNuclear");
inelastic->SetWeakNucBias(nuNucBias); // enough only once (static)
if (nuEleOn) BuildNuEleNuclear();
if (nuMuoOn) BuildNuMuoNuclear();
if (nuTauOn) BuildNuTauNuclear();
}
}
void G4QNeutrinoPhysics::BuildNuEleNuclear()
{
if(nuEleActivated) return;
nuEleActivated = true;
G4ProcessManager * pManager = 0;
pManager = G4NeutrinoE::NeutrinoE()->GetProcessManager();
pManager->AddDiscreteProcess(inelastic);
pManager = G4AntiNeutrinoE::AntiNeutrinoE()->GetProcessManager();
pManager->AddDiscreteProcess(inelastic);
}
void G4QNeutrinoPhysics::BuildNuMuoNuclear()
{
if(nuMuoActivated) return;
nuMuoActivated = true;
G4ProcessManager * pManager = 0;
pManager = G4NeutrinoMu::NeutrinoMu()->GetProcessManager();
pManager->AddDiscreteProcess(inelastic);
pManager = G4AntiNeutrinoMu::AntiNeutrinoMu()->GetProcessManager();
pManager->AddDiscreteProcess(inelastic);
}
void G4QNeutrinoPhysics::BuildNuTauNuclear()
{
if(nuTauActivated) return;
nuTauActivated = true;
G4ProcessManager * pManager = 0;
pManager = G4NeutrinoTau::NeutrinoTau()->GetProcessManager();
pManager->AddDiscreteProcess(inelastic);
pManager = G4AntiNeutrinoTau::AntiNeutrinoTau()->GetProcessManager();
pManager->AddDiscreteProcess(inelastic);
}
source/physics_lists/builders/src/G4QNeutronBuilder.cc
+72
View File
@@ -0,0 +1,72 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4QNeutronBuilder.cc,v 1.4 2009/11/16 19:12:10 mkossov Exp $
// GEANT4 tag $Name: geant4-09-03 $
//
//---------------------------------------------------------------------------
//
// ClassName: G4QNeutronBuilder
//
// Author: 2009 M. Kosov
//
// Modified:
//
//----------------------------------------------------------------------------
// Short description: for possible use in QGSC_QGSC (not needed for QGSC_CHIPS)
//-----------------------------------------------------------------------------
//
#include "G4QNeutronBuilder.hh"
G4QNeutronBuilder::G4QNeutronBuilder(): wasActivated(false)
{
theNeutronInelastic = new G4NeutronInelasticProcess;
theCHIPSInelastic = new G4QInelastic;
const G4String& processName = "MixedNeutronInelasticProcess";
const G4ParticleDefinition* proj = G4Neutron::Neutron();
theProcessMixer= new G4QDiscProcessMixer(processName, proj);
}
G4QNeutronBuilder::~G4QNeutronBuilder()
{
delete theProcessMixer;
delete theCHIPSInelastic;
delete theNeutronInelastic;
}
void G4QNeutronBuilder::Build()
{
wasActivated = true;
std::vector<G4VNeutronBuilder *>::iterator i;
for(i=theModelCollections.begin(); i!=theModelCollections.end(); i++)
{
(*i)->Build(theNeutronInelastic);
}
G4ProcessManager * theProcMan = G4Neutron::Neutron()->GetProcessManager();
theProcessMixer->AddDiscreteProcess(theNeutronInelastic, 1.E8);// the second part is fake
theProcessMixer->AddDiscreteProcess(theCHIPSInelastic, 290*megaelectronvolt);
theProcMan->AddDiscreteProcess(theNeutronInelastic);
}
// 2009 by M. Kosov
source/physics_lists/builders/src/G4QPhotoNuclearPhysics.cc
+206
View File
@@ -0,0 +1,206 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4QPhotoNuclearPhysics.cc,v 1.2 2009/11/16 19:12:10 mkossov Exp $
// GEANT4 tag $Name: geant4-09-03 $
//
//---------------------------------------------------------------------------
//
// ClassName: G4QPhotoNuclearPhysics
//
// Author: 2009 M. V. Kosov
//
// Modified:
//
//----------------------------------------------------------------------------
//
#include "G4QPhotoNuclearPhysics.hh"
G4QPhotoNuclearPhysics::G4QPhotoNuclearPhysics(const G4String& name):
G4VPhysicsConstructor(name), wasBuilt(false), SynchRActivated(false),
GamNucActivated(false), EleNucActivated(false), MuoNucActivated(false),
TauNucActivated(false), synchrOn(true), synchrMinGam(227.), gamNucOn(true),
eleNucOn(true), muoNucOn(true), tauNucOn(true), photoNucBias(1.)
{
theMessenger = G4QMessenger::GetPointer();
theMessenger->Add(this);
}
G4QPhotoNuclearPhysics::~G4QPhotoNuclearPhysics()
{
if(wasBuilt)
{
delete inelastic;
if(synchrOn) delete synchrad;
}
}
void G4QPhotoNuclearPhysics::SetSynchRadOnOff(G4String& newSwitch)
{
if(wasBuilt) G4cout<<"G4QPhotoNuclearPhysics:No, processes are already builded!"<<G4endl;
else if(newSwitch == "on" || newSwitch == "ON" || newSwitch == "On") synchrOn = true;
else synchrOn = false;
}
void G4QPhotoNuclearPhysics::SetGammaNuclearOnOff(G4String& newSwitch)
{
if(wasBuilt) G4cout<<"G4QPhotoNuclearPhysics:No, processes are already builded!"<<G4endl;
else if(newSwitch == "on" || newSwitch == "ON" || newSwitch == "On") gamNucOn = true;
else gamNucOn = false;
}
void G4QPhotoNuclearPhysics::SetElPosNuclearOnOff(G4String& newSwitch)
{
if(wasBuilt) G4cout<<"G4QPhotoNuclearPhysics:No, processes are already builded!"<<G4endl;
else if(newSwitch == "on" || newSwitch == "ON" || newSwitch == "On") eleNucOn = true;
else eleNucOn = false;
}
void G4QPhotoNuclearPhysics::SetMuonNuclearOnOff(G4String& newSwitch)
{
if(wasBuilt) G4cout<<"G4QPhotoNuclearPhysics:No, processes are already builded!"<<G4endl;
else if(newSwitch == "on" || newSwitch == "ON" || newSwitch == "On") muoNucOn = true;
else muoNucOn = false;
}
void G4QPhotoNuclearPhysics::SetTauNuclearOnOff(G4String& newSwitch)
{
if(wasBuilt) G4cout<<"G4QPhotoNuclearPhysics:No, processes are already builded!"<<G4endl;
else if(newSwitch == "on" || newSwitch == "ON" || newSwitch == "On") tauNucOn = true;
else tauNucOn = false;
}
void G4QPhotoNuclearPhysics::SetMinGammaSR(G4double newValue)
{
if(wasBuilt) G4cout<<"G4QPhotoNuclearPhysics:No, processes are already builded!"<<G4endl;
else synchrMinGam = newValue;
}
void G4QPhotoNuclearPhysics::SetPhotoNucBias(G4double newValue)
{
if(wasBuilt) G4cout<<"G4QPhotoNuclearPhysics:No, processes are already builded!"<<G4endl;
else photoNucBias = newValue;
}
void G4QPhotoNuclearPhysics::ConstructParticle()
{
G4Gamma::Gamma();
G4Electron::Electron();
G4Positron::Positron();
G4MuonPlus::MuonPlus();
G4MuonMinus::MuonMinus();
G4TauPlus::TauPlus();
G4TauMinus::TauMinus();
if (synchrOn)
{
G4MesonConstructor pMesonConstructor;
pMesonConstructor.ConstructParticle();
G4BaryonConstructor pBaryonConstructor;
pBaryonConstructor.ConstructParticle();
}
}
void G4QPhotoNuclearPhysics::ConstructProcess()
{
if(wasBuilt) return;
wasBuilt = true;
inelastic = new G4QInelastic("photoNuclear");
inelastic->SetPhotNucBias(photoNucBias);
if (synchrOn) BuildSynchRad();
if (gamNucOn) BuildGammaNuclear();
if (eleNucOn) BuildElectroNuclear();
if (muoNucOn) BuildMuonNuclear();
if (tauNucOn) BuildTauNuclear();
}
void G4QPhotoNuclearPhysics::BuildGammaNuclear()
{
if(GamNucActivated) return;
GamNucActivated = true;
G4ProcessManager* pManager = G4Gamma::Gamma()->GetProcessManager();
pManager->AddDiscreteProcess(inelastic);
}
void G4QPhotoNuclearPhysics::BuildElectroNuclear()
{
if(EleNucActivated) return;
EleNucActivated = true;
G4ProcessManager * pManager = 0;
pManager = G4Electron::Electron()->GetProcessManager();
pManager->AddDiscreteProcess(inelastic);
pManager = G4Positron::Positron()->GetProcessManager();
pManager->AddDiscreteProcess(inelastic);
}
void G4QPhotoNuclearPhysics::BuildMuonNuclear()
{
if(MuoNucActivated) return;
MuoNucActivated = true;
G4ProcessManager * pManager = 0;
pManager = G4MuonPlus::MuonPlus()->GetProcessManager();
pManager->AddDiscreteProcess(inelastic);
pManager = G4MuonMinus::MuonMinus()->GetProcessManager();
pManager->AddDiscreteProcess(inelastic);
}
void G4QPhotoNuclearPhysics::BuildTauNuclear()
{
if(TauNucActivated) return;
TauNucActivated = true;
G4ProcessManager * pManager = 0;
pManager = G4TauPlus::TauPlus()->GetProcessManager();
pManager->AddDiscreteProcess(inelastic);
pManager = G4TauMinus::TauMinus()->GetProcessManager();
pManager->AddDiscreteProcess(inelastic);
}
// The CHIPS Synchrotron radiation process is working for all charged particles
void G4QPhotoNuclearPhysics::BuildSynchRad()
{
if(SynchRActivated) return;
SynchRActivated = true;
synchrad = new G4QSynchRad();
while( (*theParticleIterator)() )
{
G4ParticleDefinition* particle = theParticleIterator->value();
G4double charge = particle->GetPDGCharge();
if(charge != 0.0)
{
G4ProcessManager* pmanager = particle->GetProcessManager();
pmanager->AddDiscreteProcess(synchrad);
}
}
}
source/physics_lists/builders/src/G4QProtonBuilder.cc
+73
View File
@@ -0,0 +1,73 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4QProtonBuilder.cc,v 1.4 2009/11/16 19:12:10 mkossov Exp $
// GEANT4 tag $Name: geant4-09-03 $
//
//---------------------------------------------------------------------------
//
// ClassName: G4QProtonBuilder
//
// Author: 2009 M. Kosov
//
// Modified:
//
//----------------------------------------------------------------------------
// Short description: for G4QDiscProcessMixer use in the QGSC_CHIPS physics list
//-----------------------------------------------------------------------------
//
#include "G4QProtonBuilder.hh"
G4QProtonBuilder::G4QProtonBuilder(): wasActivated(false)
{
theProtonInelastic = new G4ProtonInelasticProcess;
theCHIPSInelastic = new G4QInelastic;
const G4String& processName = "MixedProtonInelasticProcess";
const G4ParticleDefinition* proj = G4Proton::Proton();
theProcessMixer= new G4QDiscProcessMixer(processName, proj);
}
G4QProtonBuilder::~G4QProtonBuilder()
{
delete theProcessMixer;
delete theCHIPSInelastic;
delete theProtonInelastic;
}
void G4QProtonBuilder::Build()
{
wasActivated = true;
std::vector<G4VProtonBuilder *>::iterator i;
for(i=theModelCollections.begin(); i!=theModelCollections.end(); i++)
{
(*i)->Build(theProtonInelastic);
}
G4ProcessManager * theProcMan = G4Proton::Proton()->GetProcessManager();
theProcessMixer->AddDiscreteProcess(theProtonInelastic, 1.E8); // the second part is fake
theProcessMixer->AddDiscreteProcess(theCHIPSInelastic, 290*megaelectronvolt);
theProcMan->AddDiscreteProcess(theProcessMixer);
}
// 2009 by M. Kosov
source/physics_lists/builders/src/G4VHadronModelBuilder.cc
+53
View File
@@ -0,0 +1,53 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4VHadronModelBuilder.cc,v 1.1 2009/10/04 16:29:54 vnivanch Exp $
// GEANT4 tag $Name: geant4-09-03 $
//
//---------------------------------------------------------------------------
//
// ClassName: G4VHadronModelBuilder
//
// Author: 28 June 2009 V.Ivanchenko
//
// Modified:
//
//----------------------------------------------------------------------------
//
#include "G4VHadronModelBuilder.hh"
G4VHadronModelBuilder::G4VHadronModelBuilder(const G4String& aName)
: model(0),name(aName)
{}
G4VHadronModelBuilder::~G4VHadronModelBuilder()
{}
G4HadronicInteraction* G4VHadronModelBuilder::GetModel()
{
if(!model) model = BuildModel();
return model;
}
source/physics_lists/builders/src/G4VNeutronBuilder.cc
+46
View File
@@ -0,0 +1,46 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4VNeutronBuilder.cc,v 1.1 2009/03/31 18:39:53 vnivanch Exp $
// GEANT4 tag $Name: geant4-09-03 $
//
//---------------------------------------------------------------------------
//
// ClassName: G4VNeutronBuilder
//
// Author: 2002 J.P. Wellisch
//
// Modified:
// 30.03.2009 V.Ivanchenko move constructor and destructor to source
//
//----------------------------------------------------------------------------
//
#include "G4VNeutronBuilder.hh"
G4VNeutronBuilder::G4VNeutronBuilder()
{}
G4VNeutronBuilder::~G4VNeutronBuilder()
{}
source/physics_lists/builders/src/G4VPiKBuilder.cc
+46
View File
@@ -0,0 +1,46 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4VPiKBuilder.cc,v 1.1 2009/03/31 18:39:53 vnivanch Exp $
// GEANT4 tag $Name: geant4-09-03 $
//
//---------------------------------------------------------------------------
//
// ClassName: G4VPiKBuilder
//
// Author: 2002 J.P. Wellisch
//
// Modified:
// 30.03.2009 V.Ivanchenko move constructor and destructor to source
//
//----------------------------------------------------------------------------
//
#include "G4VPiKBuilder.hh"
G4VPiKBuilder::G4VPiKBuilder()
{}
G4VPiKBuilder::~G4VPiKBuilder()
{}
source/physics_lists/builders/src/G4VProtonBuilder.cc
+46
View File
@@ -0,0 +1,46 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4VProtonBuilder.cc,v 1.1 2009/03/31 18:39:53 vnivanch Exp $
// GEANT4 tag $Name: geant4-09-03 $
//
//---------------------------------------------------------------------------
//
// ClassName: G4VProtonBuilder
//
// Author: 2002 J.P. Wellisch
//
// Modified:
// 30.03.2009 V.Ivanchenko move constructor and destructor to source
//
//----------------------------------------------------------------------------
//
#include "G4VProtonBuilder.hh"
G4VProtonBuilder::G4VProtonBuilder()
{}
G4VProtonBuilder::~G4VProtonBuilder()
{}
source/physics_lists/builders/src/G4WarnPLStatus.cc
+94
View File
@@ -0,0 +1,94 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
#include "G4WarnPLStatus.hh"
G4WarnPLStatus::G4WarnPLStatus()
{}
G4WarnPLStatus::~G4WarnPLStatus()
{}
void G4WarnPLStatus::Replaced(const G4String aPL, const G4String Replacement) const
{
G4cout <<
"*=====================================================================" <<G4endl <<
"* " <<G4endl <<
"* The Physics list "<<aPL<<" no longer exists " <<G4endl <<
"* We recommend you use the physics lists "<<Replacement<< "," <<G4endl <<
"* this offers similar functionality for most use cases " <<G4endl <<
"* " <<G4endl <<
"* " <<G4endl <<
"* We invite you to report your use case for, and your experience with" <<G4endl <<
"* this physics list on the Geant4 User Forum dedicated to physics " <<G4endl <<
"* lists: " <<G4endl <<
"* http://hypernews.slac.stanford.edu/HyperNews/geant4/get/phys-list.html"<<G4endl <<
"* " <<G4endl <<
"*=====================================================================*" <<G4endl<<
G4endl;
}
void G4WarnPLStatus::Unsupported(const G4String aPL, const G4String Replacement) const
{
G4cout <<
"*=====================================================================" <<G4endl <<
"* " <<G4endl <<
"* The Physics list "<<aPL<<" is NO LONGER SUPPORTED ! " <<G4endl <<
"* and is likely to be deleted in a future release of Geant4 " <<G4endl <<
"* " <<G4endl;
if (Replacement.size() > 0)
{
G4cout <<
"* We recommend you try the physics lists "<<Replacement<< "," <<G4endl <<
"* this offers similar functionality for most use cases " <<G4endl <<
"* " <<G4endl;
}
G4cout <<
"* " <<G4endl <<
"* We invite you to report your use case for, and your experience with" <<G4endl <<
"* this physics list on the Geant4 User Forum dedicated to physics " <<G4endl <<
"* lists: " <<G4endl <<
"* http://hypernews.slac.stanford.edu/HyperNews/geant4/get/phys-list.html"<<G4endl <<
"* " <<G4endl <<
"*=====================================================================*" <<G4endl<<
G4endl;
}
void G4WarnPLStatus::Experimental(const G4String aPL) const
{
G4cout <<
"*=====================================================================" <<G4endl <<
"* " <<G4endl <<
"* The Physics list "<<aPL<<" is an experimental physics list ! " <<G4endl <<
"* " <<G4endl <<
"* Please report your use case for, and your experience with this " <<G4endl <<
"* physics list on the Geant4 User Forum dedicated to physics lists: " <<G4endl <<
"* http://hypernews.slac.stanford.edu/HyperNews/geant4/get/phys-list.html"<<G4endl <<
"* " <<G4endl <<
"*=====================================================================*" <<G4endl<<
G4endl;
}