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

Import Geant4 10.6.0 source tree

Browse Source
This commit is contained in:
Gabriele Cosmo
2019-12-06 15:12:28 +01:00
parent b2a62ae692
commit 5baee230e9
2997 changed files with 141580 additions and 98673 deletions
Download Patch File Download Diff File Expand all files Collapse all files
source/physics_lists/lists/include/FTFP_BERT.hh
+8 -15
View File
@@ -35,31 +35,24 @@
//
//----------------------------------------------------------------------------
//
#ifndef TFTFP_BERT_h
#define TFTFP_BERT_h 1
#ifndef FTFP_BERT_h
#define FTFP_BERT_h 1
#include <CLHEP/Units/SystemOfUnits.h>
#include "globals.hh"
#include "G4VModularPhysicsList.hh"
#include "CompileTimeConstraints.hh"
template<class T>
class TFTFP_BERT: public T
class FTFP_BERT: public G4VModularPhysicsList
{
public:
TFTFP_BERT(G4int ver = 1);
virtual ~TFTFP_BERT();
public:
// SetCuts()
virtual void SetCuts();
FTFP_BERT(G4int ver = 1);
virtual ~FTFP_BERT()=default;
private:
enum {ok = CompileTimeConstraints::IsA<T, G4VModularPhysicsList>::ok };
FTFP_BERT(const FTFP_BERT &) = delete;
FTFP_BERT & operator=(const FTFP_BERT &)=delete;
};
#include "FTFP_BERT.icc"
typedef TFTFP_BERT<G4VModularPhysicsList> FTFP_BERT;
#endif
source/physics_lists/lists/include/FTFP_BERT.icc
-120
View File
@@ -1,120 +0,0 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
//
//---------------------------------------------------------------------------
//
// ClassName:
//
// Author: 2007 Gunter Folger
//
// created from FTFP
//
// Modified:
// 19.06.2008 G.Folger: don't use chips quasielastic in FTF
// 27.11.2009 G.Folger: Remobe experimental status
// 04.06.2010 G.Folger: Use new ctor for builders
// 16.08.2010 H.Kurashige: Remove inclusion of G4ParticleWithCuts
// 26.06.2012 A.Ribon: Use FTF/Preco and BERT for nuclear capture at rest.
// 27.07.2012 A.Ribon: Use the new class G4BertiniAndFritiofStoppingPhysics
// 16.10.2012 A.Ribon: Renamed the physics classes used
//
//----------------------------------------------------------------------------
//
#include <iomanip>
#include "globals.hh"
#include "G4ios.hh"
#include "G4ProcessManager.hh"
#include "G4ProcessVector.hh"
#include "G4ParticleTypes.hh"
#include "G4ParticleTable.hh"
#include "G4Material.hh"
#include "G4MaterialTable.hh"
#include "G4DecayPhysics.hh"
#include "G4EmStandardPhysics.hh"
#include "G4EmExtraPhysics.hh"
#include "G4IonPhysics.hh"
#include "G4StoppingPhysics.hh"
#include "G4HadronElasticPhysics.hh"
#include "G4NeutronTrackingCut.hh"
#include "G4DataQuestionaire.hh"
#include "G4HadronPhysicsFTFP_BERT.hh"
template<class T> TFTFP_BERT<T>::TFTFP_BERT(G4int ver): T()
{
// default cut value (1.0mm)
// defaultCutValue = 1.0*CLHEP::mm;
G4DataQuestionaire it(photon);
G4cout << "<<< Geant4 Physics List simulation engine: FTFP_BERT 2.0"<<G4endl;
G4cout <<G4endl;
this->defaultCutValue = 0.7*CLHEP::mm;
this->SetVerboseLevel(ver);
// EM Physics
this->RegisterPhysics( new G4EmStandardPhysics(ver));
// Synchroton Radiation & GN Physics
this->RegisterPhysics( new G4EmExtraPhysics(ver) );
// Decays
this->RegisterPhysics( new G4DecayPhysics(ver) );
// Hadron Elastic scattering
this->RegisterPhysics( new G4HadronElasticPhysics(ver) );
// Hadron Physics
this->RegisterPhysics( new G4HadronPhysicsFTFP_BERT(ver));
// Stopping Physics
this->RegisterPhysics( new G4StoppingPhysics(ver) );
// Ion Physics
this->RegisterPhysics( new G4IonPhysics(ver));
// Neutron tracking cut
this->RegisterPhysics( new G4NeutronTrackingCut(ver));
}
template<class T> TFTFP_BERT<T>::~TFTFP_BERT()
{
}
template<class T> void TFTFP_BERT<T>::SetCuts()
{
if (this->verboseLevel >1){
G4cout << "FTFP_BERT::SetCuts:";
}
// " G4VUserPhysicsList::SetCutsWithDefault" method sets
// the default cut value for all particle types
this->SetCutsWithDefault();
// if (this->verboseLevel > 0)
// G4VUserPhysicsList::DumpCutValuesTable();
}
source/physics_lists/lists/include/FTFP_BERT_ATL.hh
+9 -15
View File
@@ -35,31 +35,25 @@
// energy region [9, 12] GeV (instead of [4, 5] GeV as in FTFP_BERT).
//----------------------------------------------------------------------------
//
#ifndef TFTFP_BERT_ATL_h
#define TFTFP_BERT_ATL_h 1
#ifndef FTFP_BERT_ATL_h
#define FTFP_BERT_ATL_h 1
#include <CLHEP/Units/SystemOfUnits.h>
#include "globals.hh"
#include "G4VModularPhysicsList.hh"
#include "CompileTimeConstraints.hh"
template<class T>
class TFTFP_BERT_ATL: public T
class FTFP_BERT_ATL: public G4VModularPhysicsList
{
public:
TFTFP_BERT_ATL(G4int ver = 1);
virtual ~TFTFP_BERT_ATL();
public:
// SetCuts()
virtual void SetCuts();
FTFP_BERT_ATL(G4int ver = 1);
virtual ~FTFP_BERT_ATL()=default;
private:
enum {ok = CompileTimeConstraints::IsA<T, G4VModularPhysicsList>::ok };
FTFP_BERT_ATL(const FTFP_BERT_ATL &) = delete;
FTFP_BERT_ATL & operator=(const FTFP_BERT_ATL &)=delete;
};
#include "FTFP_BERT_ATL.icc"
typedef TFTFP_BERT_ATL<G4VModularPhysicsList> FTFP_BERT_ATL;
#endif
source/physics_lists/lists/include/FTFP_BERT_ATL.icc
-118
View File
@@ -1,118 +0,0 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
//
//---------------------------------------------------------------------------
// Author: Alberto Ribon
// Date: April 2016
//
// New physics list FTFP_BERT_ATL.
// This is a modified version of the FTFP_BERT physics list for ATLAS.
// The physics list FTFP_BERT_ATL has the transition between Bertini (BERT)
// intra-nuclear cascade model and Fritiof (FTF) string model in the
// energy region [9, 12] GeV (instead of [4, 5] GeV as in FTFP_BERT).
//----------------------------------------------------------------------------
//
#include <iomanip>
#include "globals.hh"
#include "G4ios.hh"
#include "G4ProcessManager.hh"
#include "G4ProcessVector.hh"
#include "G4ParticleTypes.hh"
#include "G4ParticleTable.hh"
#include "G4Material.hh"
#include "G4MaterialTable.hh"
#include "G4DecayPhysics.hh"
#include "G4EmStandardPhysics.hh"
#include "G4EmExtraPhysics.hh"
#include "G4IonPhysics.hh"
#include "G4StoppingPhysics.hh"
#include "G4HadronElasticPhysics.hh"
#include "G4NeutronTrackingCut.hh"
#include "G4DataQuestionaire.hh"
#include "G4HadronPhysicsFTFP_BERT_ATL.hh"
#include "G4WarnPLStatus.hh"
template<class T> TFTFP_BERT_ATL<T>::TFTFP_BERT_ATL(G4int ver): T()
{
// default cut value (1.0mm)
// defaultCutValue = 1.0*CLHEP::mm;
G4DataQuestionaire it(photon);
G4cout << "<<< Geant4 Physics List simulation engine: FTFP_BERT_ATL 2.0"<<G4endl;
G4cout <<G4endl;
this->defaultCutValue = 0.7*CLHEP::mm;
this->SetVerboseLevel(ver);
G4WarnPLStatus exp;
exp.Experimental("FTFP_BERT_ATL");
// EM Physics
this->RegisterPhysics( new G4EmStandardPhysics(ver));
// Synchroton Radiation & GN Physics
this->RegisterPhysics( new G4EmExtraPhysics(ver) );
// Decays
this->RegisterPhysics( new G4DecayPhysics(ver) );
// Hadron Elastic scattering
this->RegisterPhysics( new G4HadronElasticPhysics(ver) );
// Hadron Physics
this->RegisterPhysics( new G4HadronPhysicsFTFP_BERT_ATL(ver) );
// Stopping Physics
this->RegisterPhysics( new G4StoppingPhysics(ver) );
// Ion Physics
this->RegisterPhysics( new G4IonPhysics(ver));
// Neutron tracking cut
this->RegisterPhysics( new G4NeutronTrackingCut(ver));
}
template<class T> TFTFP_BERT_ATL<T>::~TFTFP_BERT_ATL()
{
}
template<class T> void TFTFP_BERT_ATL<T>::SetCuts()
{
if (this->verboseLevel >1){
G4cout << "FTFP_BERT_ATL::SetCuts:";
}
// " G4VUserPhysicsList::SetCutsWithDefault" method sets
// the default cut value for all particle types
this->SetCutsWithDefault();
// if (this->verboseLevel > 0)
// G4VUserPhysicsList::DumpCutValuesTable();
}
source/physics_lists/lists/include/FTFP_BERT_HP.hh
+10 -13
View File
@@ -36,30 +36,27 @@
//
//----------------------------------------------------------------------------
//
#ifndef TFTFP_BERT_HP_h
#define TFTFP_BERT_HP_h 1
#ifndef FTFP_BERT_HP_h
#define FTFP_BERT_HP_h 1
#include <CLHEP/Units/SystemOfUnits.h>
#include "globals.hh"
#include "G4VModularPhysicsList.hh"
#include "CompileTimeConstraints.hh"
template<class T>
class TFTFP_BERT_HP: public T
class FTFP_BERT_HP: public G4VModularPhysicsList
{
public:
TFTFP_BERT_HP(G4int ver = 1);
virtual ~TFTFP_BERT_HP();
FTFP_BERT_HP(G4int ver = 1);
virtual ~FTFP_BERT_HP()=default;
public:
FTFP_BERT_HP(const FTFP_BERT_HP &) = delete;
FTFP_BERT_HP & operator=(const FTFP_BERT_HP &)=delete;
// SetCuts()
virtual void SetCuts();
private:
enum {ok = CompileTimeConstraints::IsA<T, G4VModularPhysicsList>::ok };
};
#include "FTFP_BERT_HP.icc"
typedef TFTFP_BERT_HP<G4VModularPhysicsList> FTFP_BERT_HP;
#endif
source/physics_lists/lists/include/FTFP_BERT_HP.icc
-105
View File
@@ -1,105 +0,0 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
//------------------------------------------------------------------------
//
// Modified:
//
//------------------------------------------------------------------------
//
#include <iomanip>
#include "globals.hh"
#include "G4ios.hh"
#include "G4ProcessManager.hh"
#include "G4ProcessVector.hh"
#include "G4ParticleTypes.hh"
#include "G4ParticleTable.hh"
#include "G4Material.hh"
#include "G4MaterialTable.hh"
#include "G4DecayPhysics.hh"
#include "G4EmStandardPhysics.hh"
#include "G4EmExtraPhysics.hh"
#include "G4IonPhysics.hh"
#include "G4StoppingPhysics.hh"
#include "G4HadronElasticPhysicsHP.hh"
#include "G4DataQuestionaire.hh"
#include "G4HadronPhysicsFTFP_BERT_HP.hh"
template<class T> TFTFP_BERT_HP<T>::TFTFP_BERT_HP(G4int ver): T()
{
// default cut value (1.0mm)
// defaultCutValue = 1.0*CLHEP::mm;
G4DataQuestionaire it(photon, neutron);
G4cout << "<<< Geant4 Physics List simulation engine: FTFP_BERT_HP 2.0"<<G4endl;
G4cout <<G4endl;
this->defaultCutValue = 0.7*CLHEP::mm;
this->SetVerboseLevel(ver);
// EM Physics
this->RegisterPhysics( new G4EmStandardPhysics(ver) );
// Synchroton Radiation & GN Physics
this->RegisterPhysics( new G4EmExtraPhysics(ver) );
// Decays
this->RegisterPhysics( new G4DecayPhysics(ver) );
// Hadron Elastic scattering
this->RegisterPhysics( new G4HadronElasticPhysicsHP(ver) );
// Hadron Physics
this->RegisterPhysics( new G4HadronPhysicsFTFP_BERT_HP(ver) );
// Stopping Physics
this->RegisterPhysics( new G4StoppingPhysics(ver) );
// Ion Physics
this->RegisterPhysics( new G4IonPhysics(ver) );
}
template<class T> TFTFP_BERT_HP<T>::~TFTFP_BERT_HP()
{
}
template<class T> void TFTFP_BERT_HP<T>::SetCuts()
{
if (this->verboseLevel >1){
G4cout << "FTFP_BERT_HP::SetCuts:";
}
// " G4VUserPhysicsList::SetCutsWithDefault" method sets
// the default cut value for all particle types
this->SetCutsWithDefault();
this->SetCutValue(0.0, "proton");
// if (this->verboseLevel > 0)
// G4VUserPhysicsList::DumpCutValuesTable();
}
source/physics_lists/lists/include/FTFP_BERT_TRV.hh
+8 -15
View File
@@ -35,31 +35,24 @@
//
//----------------------------------------------------------------------------
//
#ifndef TFTFP_BERT_TRV_h
#define TFTFP_BERT_TRV_h 1
#ifndef FTFP_BERT_TRV_h
#define FTFP_BERT_TRV_h 1
#include <CLHEP/Units/SystemOfUnits.h>
#include "globals.hh"
#include "G4VModularPhysicsList.hh"
#include "CompileTimeConstraints.hh"
template<class T>
class TFTFP_BERT_TRV: public T
class FTFP_BERT_TRV: public G4VModularPhysicsList
{
public:
TFTFP_BERT_TRV(G4int ver = 1);
virtual ~TFTFP_BERT_TRV();
FTFP_BERT_TRV(G4int ver = 1);
virtual ~FTFP_BERT_TRV()=default;
public:
// SetCuts()
virtual void SetCuts();
private:
enum {ok = CompileTimeConstraints::IsA<T, G4VModularPhysicsList>::ok };
FTFP_BERT_TRV(const FTFP_BERT_TRV &) = delete;
FTFP_BERT_TRV & operator=(const FTFP_BERT_TRV &)=delete;
};
#include "FTFP_BERT_TRV.icc"
typedef TFTFP_BERT_TRV<G4VModularPhysicsList> FTFP_BERT_TRV;
#endif
source/physics_lists/lists/include/FTFP_BERT_TRV.icc
-132
View File
@@ -1,132 +0,0 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
//
//---------------------------------------------------------------------------
//
// ClassName: FTFP_BERT_TRV
//
// Author: 2009 John Apostolakis
//
// created from FTFP_BERT - simple variant changing inelastic thresholds
//
// Modified:
// 16.08.2010 H.Kurashige: Remove inclusion of G4ParticleWithCuts
// 18.10.2011 A.Ribon: Replace CHIPS with FTF/Preco for nuclear capture
// at rest of anti-protons.
// 27.07.2012 A.Ribon: Use the new class G4BertiniAndFritiofStoppingPhysics
// 16.10.2012 A.Ribon: Renamed the physics classes used
// 05.06.2014 A.Ribon: Use (temporary) G4HadronHElasticPhysics
// 08.01.2015 A.Ribon: Switch on low-mass diffraction dissociation
//
//----------------------------------------------------------------------------
//
#include <iomanip>
#include "globals.hh"
#include "G4ios.hh"
#include "G4ProcessManager.hh"
#include "G4ProcessVector.hh"
#include "G4ParticleTypes.hh"
#include "G4ParticleTable.hh"
#include "G4Material.hh"
#include "G4MaterialTable.hh"
#include "G4DecayPhysics.hh"
#include "G4EmStandardPhysics.hh"
#include "G4EmStandardPhysicsGS.hh"
#include "G4EmExtraPhysics.hh"
#include "G4IonPhysics.hh"
#include "G4StoppingPhysics.hh"
#include "G4HadronHElasticPhysics.hh"
#include "G4NeutronTrackingCut.hh"
#include "G4DataQuestionaire.hh"
#include "G4HadronPhysicsFTFP_BERT_TRV.hh"
#include "G4WarnPLStatus.hh"
#include "G4EmParameters.hh"
template<class T> TFTFP_BERT_TRV<T>::TFTFP_BERT_TRV(G4int ver): T()
{
// default cut value (1.0mm)
// defaultCutValue = 1.0*CLHEP::mm;
G4DataQuestionaire it(photon);
G4cout << "<<< Geant4 Physics List simulation engine: FTFP_BERT_TRV 2.0"<<G4endl;
G4cout <<G4endl;
this->defaultCutValue = 0.7*CLHEP::mm;
this->SetVerboseLevel(ver);
G4WarnPLStatus exp;
exp.Experimental("FTFP_BERT_TRV");
// EM Physics
G4EmStandardPhysicsGS* gsPhysics = new G4EmStandardPhysicsGS( ver );
G4EmParameters::Instance()->SetMscStepLimitType( fUseSafety );
this->RegisterPhysics( gsPhysics );
// Synchroton Radiation & GN Physics
this->RegisterPhysics( new G4EmExtraPhysics(ver) );
// Decays
this->RegisterPhysics( new G4DecayPhysics(ver) );
// Hadron Elastic scattering
this->RegisterPhysics( new G4HadronHElasticPhysics(ver, true) );
// Hadron Physics
this->RegisterPhysics( new G4HadronPhysicsFTFP_BERT_TRV(ver));
// Stopping Physics
this->RegisterPhysics( new G4StoppingPhysics(ver) );
// Ion Physics
this->RegisterPhysics( new G4IonPhysics(ver));
// Neutron tracking cut
this->RegisterPhysics( new G4NeutronTrackingCut(ver));
}
template<class T> TFTFP_BERT_TRV<T>::~TFTFP_BERT_TRV()
{
}
template<class T> void TFTFP_BERT_TRV<T>::SetCuts()
{
if (this->verboseLevel >1){
G4cout << "FTFP_BERT_TRV::SetCuts:";
}
// " G4VUserPhysicsList::SetCutsWithDefault" method sets
// the default cut value for all particle types
this->SetCutsWithDefault();
// if (this->verboseLevel > 0)
// G4VUserPhysicsList::DumpCutValuesTable();
}
source/physics_lists/lists/include/FTFQGSP_BERT.hh
+9 -14
View File
@@ -36,31 +36,26 @@
//
//----------------------------------------------------------------------------
//
#ifndef TFTFQGSP_BERT_h
#define TFTFQGSP_BERT_h 1
#ifndef FTFQGSP_BERT_h
#define FTFQGSP_BERT_h 1
#include <CLHEP/Units/SystemOfUnits.h>
#include "globals.hh"
#include "G4VModularPhysicsList.hh"
#include "CompileTimeConstraints.hh"
template<class T>
class TFTFQGSP_BERT: public T
class FTFQGSP_BERT: public G4VModularPhysicsList
{
public:
TFTFQGSP_BERT(G4int ver = 1);
virtual ~TFTFQGSP_BERT();
public:
// SetCuts()
virtual void SetCuts();
FTFQGSP_BERT(G4int ver = 1);
virtual ~FTFQGSP_BERT()=default;
FTFQGSP_BERT(const FTFQGSP_BERT &) = delete;
FTFQGSP_BERT & operator=(const FTFQGSP_BERT &)=delete;
private:
enum {ok = CompileTimeConstraints::IsA<T, G4VModularPhysicsList>::ok };
};
#include "FTFQGSP_BERT.icc"
typedef TFTFQGSP_BERT<G4VModularPhysicsList> FTFQGSP_BERT;
#endif
source/physics_lists/lists/include/FTFQGSP_BERT.icc
-118
View File
@@ -1,118 +0,0 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
//
//---------------------------------------------------------------------------
//
// ClassName: FTFQGSP_BERT
//
// Author: 2017 Alberto Ribon
//
// created from FTFP_BERT
//
// Modified:
//
//----------------------------------------------------------------------------
//
#include <iomanip>
#include "globals.hh"
#include "G4ios.hh"
#include "G4ProcessManager.hh"
#include "G4ProcessVector.hh"
#include "G4ParticleTypes.hh"
#include "G4ParticleTable.hh"
#include "G4Material.hh"
#include "G4MaterialTable.hh"
#include "G4DecayPhysics.hh"
#include "G4EmStandardPhysics.hh"
#include "G4EmExtraPhysics.hh"
#include "G4IonPhysics.hh"
#include "G4StoppingPhysics.hh"
#include "G4HadronElasticPhysics.hh"
#include "G4NeutronTrackingCut.hh"
#include "G4DataQuestionaire.hh"
#include "G4HadronPhysicsFTFQGSP_BERT.hh"
#include "G4WarnPLStatus.hh"
template<class T> TFTFQGSP_BERT<T>::TFTFQGSP_BERT(G4int ver): T()
{
G4DataQuestionaire it(photon);
G4cout << "<<< Geant4 Physics List simulation engine: FTFQGSP_BERT 1.0"<<G4endl;
G4cout <<G4endl;
this->defaultCutValue = 0.7*CLHEP::mm;
this->SetVerboseLevel(ver);
G4WarnPLStatus exp;
exp.Experimental("FTFQGSP_BERT");
// EM Physics
this->RegisterPhysics( new G4EmStandardPhysics(ver) );
// Synchroton Radiation & GN Physics
this->RegisterPhysics( new G4EmExtraPhysics(ver) );
// Decays
this->RegisterPhysics( new G4DecayPhysics(ver) );
// Hadron Elastic scattering
this->RegisterPhysics( new G4HadronElasticPhysics(ver) );
// Hadron Physics
this->RegisterPhysics( new G4HadronPhysicsFTFQGSP_BERT(ver) );
// Stopping Physics
this->RegisterPhysics( new G4StoppingPhysics(ver) );
// Ion Physics
this->RegisterPhysics( new G4IonPhysics(ver) );
// Neutron tracking cut
this->RegisterPhysics( new G4NeutronTrackingCut(ver) );
}
template<class T> TFTFQGSP_BERT<T>::~TFTFQGSP_BERT()
{
}
template<class T> void TFTFQGSP_BERT<T>::SetCuts()
{
if (this->verboseLevel >1){
G4cout << "FTFQGSP_BERT::SetCuts:";
}
// " G4VUserPhysicsList::SetCutsWithDefault" method sets
// the default cut value for all particle types
this->SetCutsWithDefault();
// if (this->verboseLevel > 0)
// G4VUserPhysicsList::DumpCutValuesTable();
}
source/physics_lists/lists/include/FTF_BIC.hh
+9 -15
View File
@@ -34,31 +34,25 @@
//
//----------------------------------------------------------------------------
//
#ifndef TFTF_BIC_h
#define TFTF_BIC_h 1
#ifndef FTF_BIC_h
#define FTF_BIC_h 1
#include <CLHEP/Units/SystemOfUnits.h>
#include "globals.hh"
#include "G4VModularPhysicsList.hh"
#include "CompileTimeConstraints.hh"
template<class T>
class TFTF_BIC: public T
class FTF_BIC: public G4VModularPhysicsList
{
public:
TFTF_BIC(G4int ver = 1);
virtual ~TFTF_BIC();
FTF_BIC(G4int ver = 1);
virtual ~FTF_BIC()=default;
FTF_BIC(const FTF_BIC &) = delete;
FTF_BIC & operator=(const FTF_BIC &)=delete;
public:
// SetCuts()
virtual void SetCuts();
private:
enum {ok = CompileTimeConstraints::IsA<T, G4VModularPhysicsList>::ok };
};
#include "FTF_BIC.icc"
typedef TFTF_BIC<G4VModularPhysicsList> FTF_BIC;
#endif
source/physics_lists/lists/include/FTF_BIC.icc
-129
View File
@@ -1,129 +0,0 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
//
//---------------------------------------------------------------------------
//
// ClassName: FTF_BIC
//
// Author: 2007 Gunter Folger
//
// Modified:
// 19.06.2008 G.Folger: don't use chips quasielastic in FTF
// 04.06.2010 G.Folger: Use new ctor for builders
// 16.08.2010 H.Kurashige: Remove inclusion of G4ParticleWithCuts
// 16.10.2012 A.Ribon: Use new default stopping and ion physics
//
//----------------------------------------------------------------------------
//
#include <iomanip>
#include "globals.hh"
#include "G4ios.hh"
#include "G4ProcessManager.hh"
#include "G4ProcessVector.hh"
#include "G4ParticleTypes.hh"
#include "G4ParticleTable.hh"
#include "G4Material.hh"
#include "G4MaterialTable.hh"
#include "G4DecayPhysics.hh"
#include "G4EmStandardPhysics.hh"
#include "G4EmExtraPhysics.hh"
#include "G4IonPhysics.hh"
#include "G4StoppingPhysics.hh"
#include "G4HadronElasticPhysics.hh"
#include "G4NeutronTrackingCut.hh"
//AR-31Oct2012 #include "G4NeutronCrossSectionXS.hh"
#include "G4DataQuestionaire.hh"
#include "G4HadronPhysicsFTF_BIC.hh"
#include "G4WarnPLStatus.hh"
template<class T> TFTF_BIC<T>::TFTF_BIC(G4int ver): T()
{
// default cut value (1.0mm)
// defaultCutValue = 1.0*CLHEP::mm;
G4DataQuestionaire it(photon);
G4cout << "<<< Geant4 Physics List simulation engine: FTF_BIC 2.0"<<G4endl;
G4cout <<G4endl;
this->defaultCutValue = 0.7*CLHEP::mm;
this->SetVerboseLevel(ver);
G4WarnPLStatus exp;
exp.Experimental("FTF_BIC");
// EM Physics
this->RegisterPhysics( new G4EmStandardPhysics(ver) );
// Synchroton Radiation & GN Physics
this->RegisterPhysics( new G4EmExtraPhysics(ver) );
// Decays
this->RegisterPhysics( new G4DecayPhysics(ver) );
// Hadron Elastic scattering
this-> RegisterPhysics( new G4HadronElasticPhysics(ver) );
// Hadron Physics
this->RegisterPhysics( new G4HadronPhysicsFTF_BIC(ver));
// Stopping Physics
this->RegisterPhysics( new G4StoppingPhysics(ver) );
// Ion Physics
this->RegisterPhysics( new G4IonPhysics(ver));
// Neutron tracking cut
this->RegisterPhysics( new G4NeutronTrackingCut(ver));
// Neutron cross sections
//AR-31Oct2012 this->RegisterPhysics( new G4NeutronCrossSectionXS(ver) );
}
template<class T> TFTF_BIC<T>::~TFTF_BIC()
{
}
template<class T> void TFTF_BIC<T>::SetCuts()
{
if (this->verboseLevel >1){
G4cout << "FTF_BIC::SetCuts:";
}
// " G4VUserPhysicsList::SetCutsWithDefault" method sets
// the default cut value for all particle types
this->SetCutsWithDefault();
// if (this->verboseLevel >0)
// G4VUserPhysicsList::DumpCutValuesTable();
}
source/physics_lists/lists/include/G4GenericPhysicsList.icc
-5
View File
@@ -45,15 +45,11 @@
#include "G4ios.hh"
#include <iomanip>
#include "G4DataQuestionaire.hh"
template<class T> TG4GenericPhysicsList<T>::TG4GenericPhysicsList(G4int ver): T(), messenger(this, "/PhysicsList/")
{
DeclareProperties();
G4DataQuestionaire it(photon);
G4cout << "<<< Geant4 Physics List simulation engine: G4GenericPhysicsList"<<G4endl;
G4cout <<G4endl;
this->defaultCutValue = 0.7*CLHEP::mm;
@@ -64,7 +60,6 @@ template<class T> TG4GenericPhysicsList<T>::TG4GenericPhysicsList(std::vector<G4
{
DeclareProperties();
G4DataQuestionaire it(photon);
G4cout << "<<< Geant4 Physics List simulation engine: G4GenericPhysicsList"<<G4endl;
G4cout <<G4endl;
this->defaultCutValue = 0.7*CLHEP::mm;
source/physics_lists/lists/include/INCLXXPhysicsListHelper.icc
+3 -3
View File
@@ -47,6 +47,7 @@
#include "G4MaterialTable.hh"
#include "G4DecayPhysics.hh"
#include "G4RadioactiveDecayPhysics.hh"
#include "G4EmStandardPhysics.hh"
#include "G4EmExtraPhysics.hh"
#include "G4IonINCLXXPhysics.hh"
@@ -55,7 +56,6 @@
#include "G4HadronElasticPhysicsHP.hh"
#include "G4NeutronTrackingCut.hh"
#include "G4DataQuestionaire.hh"
#include "G4HadronPhysicsINCLXX.hh"
#include "G4WarnPLStatus.hh"
@@ -70,8 +70,7 @@ template<class T, bool withNeutronHP, bool withFTFP> TINCLXXPhysicsListHelper<T,
if(withNeutronHP)
name += "_HP";
G4DataQuestionaire it(photon);
G4cout << "<<< Geant4 Physics List simulation engine: " << name << " 1.0 (based on INCLXXPhysicsListHelper)"<<G4endl;
G4cout << "<<< Geant4 Physics List simulation engine: " << name << " (based on INCLXXPhysicsListHelper)"<<G4endl;
G4cout <<G4endl;
this->defaultCutValue = 0.7*CLHEP::mm;
@@ -88,6 +87,7 @@ template<class T, bool withNeutronHP, bool withFTFP> TINCLXXPhysicsListHelper<T,
// Decays
this->RegisterPhysics( new G4DecayPhysics(ver) );
if(withNeutronHP) this->RegisterPhysics( new G4RadioactiveDecayPhysics(ver) );
// Hadron Elastic scattering
if(withNeutronHP)
source/physics_lists/lists/include/LBE.hh
+13 -18
View File
@@ -43,36 +43,32 @@
// PhysicsList header
// --------------------------------------------------------------
#ifndef TLBE_h
#define TLBE_h 1
#include <CLHEP/Units/SystemOfUnits.h>
#ifndef LBE_h
#define LBE_h 1
#include "globals.hh"
#include "G4VUserPhysicsList.hh"
#include "CompileTimeConstraints.hh"
#include "G4VModularPhysicsList.hh"
class G4StoppingPhysics; // This builder encapsulate stopping processes
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
template<class T>
class TLBE: public T
class LBE: public G4VModularPhysicsList
{
public:
TLBE(G4int ver = 1);
~TLBE();
// virtual ~TLBE();
LBE(G4int ver = 1);
virtual ~LBE();
//delete copy constructor and assignment operator
LBE(const LBE &)=delete;
LBE& operator=(const LBE &right)=delete;
public:
virtual void SetCuts();
private:
enum {ok = CompileTimeConstraints::IsA<T, G4VModularPhysicsList>::ok };
protected:
// Construct particle and physics
virtual void ConstructParticle();
@@ -104,9 +100,10 @@ private:
G4double cutForGamma;
G4double cutForElectron;
G4double cutForPositron;
G4double cutForProton;
G4double cutForAlpha;
G4double cutForGenericIon;
// uncomment if the code if corresponding code in LBE.cc is un-commented
// G4double cutForProton;
// G4double cutForAlpha;
// G4double cutForGenericIon;
G4StoppingPhysics* stoppingPhysics;
@@ -119,7 +116,5 @@ private:
void ConstructMyShortLiveds();
};
#include "LBE.icc"
typedef TLBE<G4VModularPhysicsList> LBE;
#endif
source/physics_lists/lists/include/LBE.icc
-994
View File
@@ -1,994 +0,0 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
//
// --------------------------------------------------------------
//
// For information related to this code contact: Alex Howard
// e-mail: alexander.howard@cern.ch
// --------------------------------------------------------------
// Comments
//
// Underground Advanced
//
// This physics list is taken from the underground_physics example with small
// modifications. It is an example of a "flat" physics list with no dependence
// on builders. The physics covered would be suitable for a low background
// experiment including the neutron_hp package
//
//
//
// PhysicsList program
//
// Modified:
//
// 14-02-03 Fix bugs in msc and hIon instanciation + cut per region
// 16-08-10 Remove inclusion of obsolete class of G4ParticleWithCuts
// 20-10-10 Migrate LowEnergy process to Livermore models, LP
// 28-03-13 Replace LEP/HEP with FTFP+BERT (A.R.)
// --------------------------------------------------------------
#include <iomanip>
#include "globals.hh"
#include "G4ios.hh"
#include "G4ProcessManager.hh"
#include "G4ProcessVector.hh"
#include "G4ParticleTypes.hh"
#include "G4ParticleTable.hh"
#include "G4ProductionCutsTable.hh"
#include "G4UserLimits.hh"
#include "G4DataQuestionaire.hh"
#include "G4WarnPLStatus.hh"
// Builder for all stopping processes
#include "G4StoppingPhysics.hh"
#include "G4HadronicParameters.hh"
// Constructor /////////////////////////////////////////////////////////////
template<class T> TLBE<T>::TLBE(G4int ver) :T()
{
G4DataQuestionaire it(photon, lowenergy, neutron, radioactive);
G4cout << "You are using the simulation engine: LBE 5.3"<<G4endl;
G4cout <<G4endl<<G4endl;
this->defaultCutValue = 1.0*CLHEP::micrometer; //
cutForGamma = this->defaultCutValue;
// cutForElectron = 1.0*CLHEP::nanometer;
cutForElectron = 1.0*CLHEP::micrometer;
cutForPositron = this->defaultCutValue;
//not used:
// cutForProton = this->defaultCutValue;
// cutForAlpha = 1.0*CLHEP::nanometer;
// cutForGenericIon = 1.0*CLHEP::nanometer;
stoppingPhysics = new G4StoppingPhysics;
VerboseLevel = ver;
OpVerbLevel = 0;
this->SetVerboseLevel(VerboseLevel);
}
// Destructor //////////////////////////////////////////////////////////////
template<class T> TLBE<T>::~TLBE()
{
delete stoppingPhysics;
}
// Construct Particles /////////////////////////////////////////////////////
template<class T> void TLBE<T>::ConstructParticle()
{
// In this method, static member functions should be called
// for all particles which you want to use.
// This ensures that objects of these particle types will be
// created in the program.
ConstructMyBosons();
ConstructMyLeptons();
ConstructMyMesons();
ConstructMyBaryons();
ConstructMyIons();
ConstructMyShortLiveds();
stoppingPhysics->ConstructParticle(); // Anything not included above
}
// construct Bosons://///////////////////////////////////////////////////
template<class T> void TLBE<T>::ConstructMyBosons()
{
// pseudo-particles
G4Geantino::GeantinoDefinition();
G4ChargedGeantino::ChargedGeantinoDefinition();
// gamma
G4Gamma::GammaDefinition();
//OpticalPhotons
G4OpticalPhoton::OpticalPhotonDefinition();
}
// construct Leptons://///////////////////////////////////////////////////
template<class T> void TLBE<T>::ConstructMyLeptons()
{
// leptons
G4Electron::ElectronDefinition();
G4Positron::PositronDefinition();
G4MuonPlus::MuonPlusDefinition();
G4MuonMinus::MuonMinusDefinition();
G4NeutrinoE::NeutrinoEDefinition();
G4AntiNeutrinoE::AntiNeutrinoEDefinition();
G4NeutrinoMu::NeutrinoMuDefinition();
G4AntiNeutrinoMu::AntiNeutrinoMuDefinition();
}
#include "G4MesonConstructor.hh"
#include "G4BaryonConstructor.hh"
#include "G4IonConstructor.hh"
// construct Mesons://///////////////////////////////////////////////////
template<class T> void TLBE<T>::ConstructMyMesons()
{
// mesons
G4MesonConstructor mConstructor;
mConstructor.ConstructParticle();
}
// construct Baryons://///////////////////////////////////////////////////
template<class T> void TLBE<T>::ConstructMyBaryons()
{
// baryons
G4BaryonConstructor bConstructor;
bConstructor.ConstructParticle();
}
// construct Ions://///////////////////////////////////////////////////
template<class T> void TLBE<T>::ConstructMyIons()
{
// ions
G4IonConstructor iConstructor;
iConstructor.ConstructParticle();
}
// construct Shortliveds://///////////////////////////////////////////////////
template<class T> void TLBE<T>::ConstructMyShortLiveds()
{
// ShortLiveds
;
}
// Construct Processes //////////////////////////////////////////////////////
template<class T> void TLBE<T>::ConstructProcess()
{
AddTransportation();
ConstructEM();
ConstructOp();
ConstructHad();
ConstructGeneral();
}
// Transportation ///////////////////////////////////////////////////////////
#include "G4MaxTimeCuts.hh"
#include "G4MinEkineCuts.hh"
template<class T> void TLBE<T>::AddTransportation() {
G4VUserPhysicsList::AddTransportation();
auto myParticleIterator=G4ParticleTable::GetParticleTable()->GetIterator();
myParticleIterator->reset();
while( (*(myParticleIterator))() ){
G4ParticleDefinition* particle = myParticleIterator->value();
G4ProcessManager* pmanager = particle->GetProcessManager();
G4String particleName = particle->GetParticleName();
// time cuts for ONLY neutrons:
if(particleName == "neutron")
pmanager->AddDiscreteProcess(new G4MaxTimeCuts());
// Energy cuts to kill charged (embedded in method) particles:
pmanager->AddDiscreteProcess(new G4MinEkineCuts());
}
}
// Electromagnetic Processes ////////////////////////////////////////////////
// all charged particles
#include "G4eMultipleScattering.hh"
#include "G4MuMultipleScattering.hh"
#include "G4hMultipleScattering.hh"
// gamma. Use Livermore models
#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 "G4UrbanMscModel.hh"
#include "G4eIonisation.hh"
#include "G4LivermoreIonisationModel.hh"
#include "G4eBremsstrahlung.hh"
#include "G4LivermoreBremsstrahlungModel.hh"
// e+
#include "G4eplusAnnihilation.hh"
// alpha and GenericIon and deuterons, triton, He3:
#include "G4ionIonisation.hh"
#include "G4hIonisation.hh"
#include "G4hBremsstrahlung.hh"
//
#include "G4IonParametrisedLossModel.hh"
#include "G4NuclearStopping.hh"
#include "G4EnergyLossTables.hh"
//muon:
#include "G4MuIonisation.hh"
#include "G4MuBremsstrahlung.hh"
#include "G4MuPairProduction.hh"
#include "G4MuonMinusCapture.hh"
//OTHERS:
//#include "G4hIonisation.hh" // standard hadron ionisation
template<class T> void TLBE<T>::ConstructEM() {
// models & processes:
// Use Livermore models up to 20 MeV, and standard
// models for higher energy
G4double LivermoreHighEnergyLimit = 20*CLHEP::MeV;
//
auto myParticleIterator=G4ParticleTable::GetParticleTable()->GetIterator();
myParticleIterator->reset();
while( (*(myParticleIterator))() ){
G4ParticleDefinition* particle = myParticleIterator->value();
G4ProcessManager* pmanager = particle->GetProcessManager();
G4String particleName = particle->GetParticleName();
G4String particleType = particle->GetParticleType();
G4double charge = particle->GetPDGCharge();
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-")
{
//electron
// process ordering: AddProcess(name, at rest, along step, post step)
// -1 = not implemented, then ordering
G4eMultipleScattering* msc = new G4eMultipleScattering();
//msc->AddEmModel(0, new G4UrbanMscModel());
msc->SetStepLimitType(fUseDistanceToBoundary);
pmanager->AddProcess(msc, -1, 1, 1);
// Ionisation
G4eIonisation* eIoni = new G4eIonisation();
G4LivermoreIonisationModel* theIoniLivermore = new
G4LivermoreIonisationModel();
theIoniLivermore->SetHighEnergyLimit(1*CLHEP::MeV);
eIoni->AddEmModel(0, theIoniLivermore, new G4UniversalFluctuation() );
eIoni->SetStepFunction(0.2, 100*CLHEP::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+")
{
//positron
G4eMultipleScattering* msc = new G4eMultipleScattering();
//msc->AddEmModel(0, new G4UrbanMscModel());
msc->SetStepLimitType(fUseDistanceToBoundary);
pmanager->AddProcess(msc, -1, 1, 1);
G4eIonisation* eIoni = new G4eIonisation();
eIoni->SetStepFunction(0.2, 100*CLHEP::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-" )
{
//muon
G4MuMultipleScattering* aMultipleScattering = new G4MuMultipleScattering();
pmanager->AddProcess(aMultipleScattering, -1, 1, 1);
pmanager->AddProcess(new G4MuIonisation(), -1, 2, 2);
pmanager->AddProcess(new G4MuBremsstrahlung(), -1,-1, 3);
pmanager->AddProcess(new G4MuPairProduction(), -1,-1, 4);
if( particleName == "mu-" )
pmanager->AddProcess(new G4MuonMinusCapture(), 0,-1,-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*CLHEP::um);
pmanager->AddProcess(ionIoni, -1, 2, 2);
pmanager->AddProcess(new G4NuclearStopping(), -1, 3,-1);
}
else if (particleName == "alpha" || particleName == "He3")
{
//MSC, ion-Ionisation, Nuclear Stopping
pmanager->AddProcess(new G4hMultipleScattering, -1, 1, 1);
G4ionIonisation* ionIoni = new G4ionIonisation();
ionIoni->SetStepFunction(0.1, 20*CLHEP::um);
pmanager->AddProcess(ionIoni, -1, 2, 2);
pmanager->AddProcess(new G4NuclearStopping(), -1, 3,-1);
}
else if (particleName == "proton" ||
particleName == "deuteron" ||
particleName == "triton" ||
particleName == "pi+" ||
particleName == "pi-" ||
particleName == "kaon+" ||
particleName == "kaon-")
{
//MSC, h-ionisation, bremsstrahlung
pmanager->AddProcess(new G4hMultipleScattering, -1, 1, 1);
G4hIonisation* hIoni = new G4hIonisation();
hIoni->SetStepFunction(0.2, 50*CLHEP::um);
pmanager->AddProcess(hIoni, -1, 2, 2);
pmanager->AddProcess(new G4hBremsstrahlung, -1,-3, 3);
}
else if ((!particle->IsShortLived()) &&
(charge != 0.0) &&
(particle->GetParticleName() != "chargedgeantino"))
{
//all others charged particles except geantino
pmanager->AddProcess(new G4hMultipleScattering, -1, 1, 1);
pmanager->AddProcess(new G4hIonisation, -1, 2, 2);
}
}
}
// Optical Processes ////////////////////////////////////////////////////////
#include "G4Scintillation.hh"
#include "G4OpAbsorption.hh"
//#include "G4OpRayleigh.hh"
#include "G4OpBoundaryProcess.hh"
template<class T> void TLBE<T>::ConstructOp()
{
// default scintillation process
//Coverity report: check that the process is actually used, if not must delete
G4bool theScintProcessDefNeverUsed = true;
G4Scintillation* theScintProcessDef = new G4Scintillation("Scintillation");
// theScintProcessDef->DumpPhysicsTable();
theScintProcessDef->SetTrackSecondariesFirst(true);
theScintProcessDef->SetScintillationYieldFactor(1.0); //
theScintProcessDef->SetScintillationExcitationRatio(0.0); //
theScintProcessDef->SetVerboseLevel(OpVerbLevel);
// scintillation process for alpha:
G4bool theScintProcessAlphaNeverUsed = true;
G4Scintillation* theScintProcessAlpha = new G4Scintillation("Scintillation");
// theScintProcessNuc->DumpPhysicsTable();
theScintProcessAlpha->SetTrackSecondariesFirst(true);
theScintProcessAlpha->SetScintillationYieldFactor(1.1);
theScintProcessAlpha->SetScintillationExcitationRatio(1.0);
theScintProcessAlpha->SetVerboseLevel(OpVerbLevel);
// scintillation process for heavy nuclei
G4bool theScintProcessNucNeverUsed = true;
G4Scintillation* theScintProcessNuc = new G4Scintillation("Scintillation");
// theScintProcessNuc->DumpPhysicsTable();
theScintProcessNuc->SetTrackSecondariesFirst(true);
theScintProcessNuc->SetScintillationYieldFactor(0.2);
theScintProcessNuc->SetScintillationExcitationRatio(1.0);
theScintProcessNuc->SetVerboseLevel(OpVerbLevel);
// optical processes
G4bool theAbsorptionProcessNeverUsed = true;
G4OpAbsorption* theAbsorptionProcess = new G4OpAbsorption();
// G4OpRayleigh* theRayleighScatteringProcess = new G4OpRayleigh();
G4bool theBoundaryProcessNeverUsed = true;
G4OpBoundaryProcess* theBoundaryProcess = new G4OpBoundaryProcess();
// theAbsorptionProcess->DumpPhysicsTable();
// theRayleighScatteringProcess->DumpPhysicsTable();
theAbsorptionProcess->SetVerboseLevel(OpVerbLevel);
// theRayleighScatteringProcess->SetVerboseLevel(OpVerbLevel);
theBoundaryProcess->SetVerboseLevel(OpVerbLevel);
auto myParticleIterator=G4ParticleTable::GetParticleTable()->GetIterator();
myParticleIterator->reset();
while( (*(myParticleIterator))() )
{
G4ParticleDefinition* particle = myParticleIterator->value();
G4ProcessManager* pmanager = particle->GetProcessManager();
G4String particleName = particle->GetParticleName();
if (theScintProcessDef->IsApplicable(*particle)) {
// if(particle->GetPDGMass() > 5.0*CLHEP::GeV)
if(particle->GetParticleName() == "GenericIon") {
pmanager->AddProcess(theScintProcessNuc); // AtRestDiscrete
pmanager->SetProcessOrderingToLast(theScintProcessNuc,idxAtRest);
pmanager->SetProcessOrderingToLast(theScintProcessNuc,idxPostStep);
theScintProcessNucNeverUsed = false;
}
else if(particle->GetParticleName() == "alpha") {
pmanager->AddProcess(theScintProcessAlpha);
pmanager->SetProcessOrderingToLast(theScintProcessAlpha,idxAtRest);
pmanager->SetProcessOrderingToLast(theScintProcessAlpha,idxPostStep);
theScintProcessAlphaNeverUsed = false;
}
else {
pmanager->AddProcess(theScintProcessDef);
pmanager->SetProcessOrderingToLast(theScintProcessDef,idxAtRest);
pmanager->SetProcessOrderingToLast(theScintProcessDef,idxPostStep);
theScintProcessDefNeverUsed = false;
}
}
if (particleName == "opticalphoton") {
pmanager->AddDiscreteProcess(theAbsorptionProcess);
theAbsorptionProcessNeverUsed = false;
// pmanager->AddDiscreteProcess(theRayleighScatteringProcess);
theBoundaryProcessNeverUsed = false;
pmanager->AddDiscreteProcess(theBoundaryProcess);
}
}
if ( theScintProcessDefNeverUsed ) delete theScintProcessDef;
if ( theScintProcessAlphaNeverUsed ) delete theScintProcessAlpha;
if ( theScintProcessNucNeverUsed ) delete theScintProcessNuc;
if ( theBoundaryProcessNeverUsed ) delete theBoundaryProcess;
if ( theAbsorptionProcessNeverUsed ) delete theAbsorptionProcess;
}
// Hadronic processes ////////////////////////////////////////////////////////
// Elastic processes:
#include "G4HadronElasticProcess.hh"
#include "G4HadronCaptureProcess.hh"
#include "G4HadronElastic.hh"
#include "G4ChipsElasticModel.hh"
#include "G4ElasticHadrNucleusHE.hh"
#include "G4AntiNuclElastic.hh"
#include "G4BGGPionElasticXS.hh"
#include "G4CrossSectionDataSetRegistry.hh"
#include "G4ChipsProtonElasticXS.hh"
#include "G4ChipsNeutronElasticXS.hh"
#include "G4ComponentAntiNuclNuclearXS.hh"
#include "G4CrossSectionElastic.hh"
// Inelastic processes:
#include "G4PionPlusInelasticProcess.hh"
#include "G4PionMinusInelasticProcess.hh"
#include "G4KaonPlusInelasticProcess.hh"
#include "G4KaonZeroSInelasticProcess.hh"
#include "G4KaonZeroLInelasticProcess.hh"
#include "G4KaonMinusInelasticProcess.hh"
#include "G4ProtonInelasticProcess.hh"
#include "G4AntiProtonInelasticProcess.hh"
#include "G4NeutronInelasticProcess.hh"
#include "G4AntiNeutronInelasticProcess.hh"
#include "G4DeuteronInelasticProcess.hh"
#include "G4TritonInelasticProcess.hh"
#include "G4AlphaInelasticProcess.hh"
// FTFP + BERT model
#include "G4TheoFSGenerator.hh"
#include "G4ExcitationHandler.hh"
#include "G4PreCompoundModel.hh"
#include "G4GeneratorPrecompoundInterface.hh"
#include "G4FTFModel.hh"
#include "G4LundStringFragmentation.hh"
#include "G4ExcitedStringDecay.hh"
#include "G4CascadeInterface.hh"
#include "G4CrossSectionInelastic.hh"
#include "G4PiNuclearCrossSection.hh"
#include "G4CrossSectionPairGG.hh"
#include "G4ChipsKaonMinusInelasticXS.hh"
#include "G4ChipsKaonPlusInelasticXS.hh"
#include "G4ChipsKaonZeroInelasticXS.hh"
#include "G4CrossSectionDataSetRegistry.hh"
#include "G4BGGNucleonInelasticXS.hh"
#include "G4ComponentAntiNuclNuclearXS.hh"
#include "G4ComponentGGNuclNuclXsc.hh"
// Neutron high-precision models: <20 MeV
#include "G4ParticleHPElastic.hh"
#include "G4ParticleHPElasticData.hh"
#include "G4ParticleHPCapture.hh"
#include "G4ParticleHPCaptureData.hh"
#include "G4ParticleHPInelastic.hh"
#include "G4ParticleHPInelasticData.hh"
#include "G4NeutronCaptureXS.hh"
#include "G4NeutronRadCapture.hh"
// Binary light ion cascade for alpha, deuteron and triton
#include "G4BinaryLightIonReaction.hh"
// ConstructHad()
// Makes discrete physics processes for the hadrons, at present limited
// to those particles with GHEISHA interactions (INTRC > 0).
// The processes are: Elastic scattering and Inelastic scattering.
// F.W.Jones 09-JUL-1998
template<class T> void TLBE<T>::ConstructHad()
{
// Elastic scattering
const G4double elastic_elimitPi = 1.0*CLHEP::GeV;
G4HadronElastic* elastic_lhep0 = new G4HadronElastic();
G4HadronElastic* elastic_lhep1 = new G4HadronElastic();
elastic_lhep1->SetMaxEnergy( elastic_elimitPi );
G4ChipsElasticModel* elastic_chip = new G4ChipsElasticModel();
G4ElasticHadrNucleusHE* elastic_he = new G4ElasticHadrNucleusHE();
elastic_he->SetMinEnergy( elastic_elimitPi );
// Inelastic scattering
const G4double theFTFMin0 = 0.0*CLHEP::GeV;
const G4double theFTFMin1 = 4.0*CLHEP::GeV;
const G4double theFTFMax = G4HadronicParameters::Instance()->GetMaxEnergy();
const G4double theBERTMin0 = 0.0*CLHEP::GeV;
const G4double theBERTMin1 = 19.0*CLHEP::MeV;
const G4double theBERTMax = 5.0*CLHEP::GeV;
const G4double theHPMin = 0.0*CLHEP::GeV;
const G4double theHPMax = 20.0*CLHEP::MeV;
const G4double theIonBCMin = 0.0*CLHEP::GeV;
const G4double theIonBCMax = 5.0*CLHEP::GeV;
G4FTFModel * theStringModel = new G4FTFModel;
G4ExcitedStringDecay * theStringDecay = new G4ExcitedStringDecay( new G4LundStringFragmentation );
theStringModel->SetFragmentationModel( theStringDecay );
G4PreCompoundModel * thePreEquilib = new G4PreCompoundModel( new G4ExcitationHandler );
G4GeneratorPrecompoundInterface * theCascade = new G4GeneratorPrecompoundInterface( thePreEquilib );
G4TheoFSGenerator * theFTFModel0 = new G4TheoFSGenerator( "FTFP" );
theFTFModel0->SetHighEnergyGenerator( theStringModel );
theFTFModel0->SetTransport( theCascade );
theFTFModel0->SetMinEnergy( theFTFMin0 );
theFTFModel0->SetMaxEnergy( theFTFMax );
G4TheoFSGenerator * theFTFModel1 = new G4TheoFSGenerator( "FTFP" );
theFTFModel1->SetHighEnergyGenerator( theStringModel );
theFTFModel1->SetTransport( theCascade );
theFTFModel1->SetMinEnergy( theFTFMin1 );
theFTFModel1->SetMaxEnergy( theFTFMax );
G4CascadeInterface * theBERTModel0 = new G4CascadeInterface;
theBERTModel0->SetMinEnergy( theBERTMin0 );
theBERTModel0->SetMaxEnergy( theBERTMax );
G4CascadeInterface * theBERTModel1 = new G4CascadeInterface;
theBERTModel1->SetMinEnergy( theBERTMin1 );
theBERTModel1->SetMaxEnergy( theBERTMax );
// Binary Cascade
G4BinaryLightIonReaction * theIonBC = new G4BinaryLightIonReaction( thePreEquilib );
theIonBC->SetMinEnergy( theIonBCMin );
theIonBC->SetMaxEnergy( theIonBCMax );
G4VCrossSectionDataSet * thePiData = new G4CrossSectionPairGG(
(G4PiNuclearCrossSection*)G4CrossSectionDataSetRegistry::Instance()->GetCrossSectionDataSet(G4PiNuclearCrossSection::Default_Name()), 91*CLHEP::GeV );
G4VCrossSectionDataSet * theAntiNucleonData = new G4CrossSectionInelastic( new G4ComponentAntiNuclNuclearXS );
G4ComponentGGNuclNuclXsc * ggNuclNuclXsec = new G4ComponentGGNuclNuclXsc();
G4VCrossSectionDataSet * theGGNuclNuclData = new G4CrossSectionInelastic(ggNuclNuclXsec);
auto myParticleIterator=G4ParticleTable::GetParticleTable()->GetIterator();
myParticleIterator->reset();
while ((*(myParticleIterator))())
{
G4ParticleDefinition* particle = myParticleIterator->value();
G4ProcessManager* pmanager = particle->GetProcessManager();
G4String particleName = particle->GetParticleName();
if (particleName == "pi+")
{
// Elastic scattering
G4HadronElasticProcess* theElasticProcess = new G4HadronElasticProcess;
theElasticProcess->AddDataSet( new G4BGGPionElasticXS( particle ) );
theElasticProcess->RegisterMe( elastic_lhep1 );
theElasticProcess->RegisterMe( elastic_he );
pmanager->AddDiscreteProcess( theElasticProcess );
// Inelastic scattering
G4PionPlusInelasticProcess* theInelasticProcess = new G4PionPlusInelasticProcess("inelastic");
theInelasticProcess->AddDataSet( thePiData );
theInelasticProcess->RegisterMe( theFTFModel1 );
theInelasticProcess->RegisterMe( theBERTModel0 );
pmanager->AddDiscreteProcess( theInelasticProcess );
}
else if (particleName == "pi-")
{
// Elastic scattering
G4HadronElasticProcess* theElasticProcess = new G4HadronElasticProcess;
theElasticProcess->AddDataSet( new G4BGGPionElasticXS( particle ) );
theElasticProcess->RegisterMe( elastic_lhep1 );
theElasticProcess->RegisterMe( elastic_he );
pmanager->AddDiscreteProcess( theElasticProcess );
// Inelastic scattering
G4PionMinusInelasticProcess* theInelasticProcess = new G4PionMinusInelasticProcess("inelastic");
theInelasticProcess->AddDataSet( thePiData );
theInelasticProcess->RegisterMe( theFTFModel1 );
theInelasticProcess->RegisterMe( theBERTModel0 );
pmanager->AddDiscreteProcess( theInelasticProcess );
}
else if (particleName == "kaon+")
{
// Elastic scattering
G4HadronElasticProcess* theElasticProcess = new G4HadronElasticProcess;
theElasticProcess->RegisterMe( elastic_lhep0 );
pmanager->AddDiscreteProcess( theElasticProcess );
// Inelastic scattering
G4KaonPlusInelasticProcess* theInelasticProcess = new G4KaonPlusInelasticProcess("inelastic");
theInelasticProcess->AddDataSet( G4CrossSectionDataSetRegistry::Instance()->GetCrossSectionDataSet(G4ChipsKaonPlusInelasticXS::Default_Name()));
theInelasticProcess->RegisterMe( theFTFModel1 );
theInelasticProcess->RegisterMe( theBERTModel0 );
pmanager->AddDiscreteProcess( theInelasticProcess );
}
else if (particleName == "kaon0S")
{
// Elastic scattering
G4HadronElasticProcess* theElasticProcess = new G4HadronElasticProcess;
theElasticProcess->RegisterMe( elastic_lhep0 );
pmanager->AddDiscreteProcess( theElasticProcess );
// Inelastic scattering
G4KaonZeroSInelasticProcess* theInelasticProcess = new G4KaonZeroSInelasticProcess("inelastic");
theInelasticProcess->AddDataSet( G4CrossSectionDataSetRegistry::Instance()->GetCrossSectionDataSet(G4ChipsKaonZeroInelasticXS::Default_Name()));
theInelasticProcess->RegisterMe( theFTFModel1 );
theInelasticProcess->RegisterMe( theBERTModel0 );
pmanager->AddDiscreteProcess( theInelasticProcess );
}
else if (particleName == "kaon0L")
{
// Elastic scattering
G4HadronElasticProcess* theElasticProcess = new G4HadronElasticProcess;
theElasticProcess->RegisterMe( elastic_lhep0 );
pmanager->AddDiscreteProcess( theElasticProcess );
// Inelastic scattering
G4KaonZeroLInelasticProcess* theInelasticProcess = new G4KaonZeroLInelasticProcess("inelastic");
theInelasticProcess->AddDataSet( G4CrossSectionDataSetRegistry::Instance()->GetCrossSectionDataSet(G4ChipsKaonZeroInelasticXS::Default_Name()));
theInelasticProcess->RegisterMe( theFTFModel1 );
theInelasticProcess->RegisterMe( theBERTModel0 );
pmanager->AddDiscreteProcess( theInelasticProcess );
}
else if (particleName == "kaon-")
{
// Elastic scattering
G4HadronElasticProcess* theElasticProcess = new G4HadronElasticProcess;
theElasticProcess->RegisterMe( elastic_lhep0 );
pmanager->AddDiscreteProcess( theElasticProcess );
// Inelastic scattering
G4KaonMinusInelasticProcess* theInelasticProcess = new G4KaonMinusInelasticProcess("inelastic");
theInelasticProcess->AddDataSet( G4CrossSectionDataSetRegistry::Instance()->GetCrossSectionDataSet(G4ChipsKaonMinusInelasticXS::Default_Name()));
theInelasticProcess->RegisterMe( theFTFModel1 );
theInelasticProcess->RegisterMe( theBERTModel0 );
pmanager->AddDiscreteProcess( theInelasticProcess );
}
else if (particleName == "proton")
{
// Elastic scattering
G4HadronElasticProcess* theElasticProcess = new G4HadronElasticProcess;
theElasticProcess->AddDataSet(G4CrossSectionDataSetRegistry::Instance()->GetCrossSectionDataSet(G4ChipsProtonElasticXS::Default_Name()));
theElasticProcess->RegisterMe( elastic_chip );
pmanager->AddDiscreteProcess( theElasticProcess );
// Inelastic scattering
G4ProtonInelasticProcess* theInelasticProcess = new G4ProtonInelasticProcess("inelastic");
theInelasticProcess->AddDataSet( new G4BGGNucleonInelasticXS( G4Proton::Proton() ) );
theInelasticProcess->RegisterMe( theFTFModel1 );
theInelasticProcess->RegisterMe( theBERTModel0 );
pmanager->AddDiscreteProcess( theInelasticProcess );
}
else if (particleName == "anti_proton")
{
// Elastic scattering
const G4double elastic_elimitAntiNuc = 100.0*CLHEP::MeV;
G4AntiNuclElastic* elastic_anuc = new G4AntiNuclElastic();
elastic_anuc->SetMinEnergy( elastic_elimitAntiNuc );
G4CrossSectionElastic* elastic_anucxs = new G4CrossSectionElastic( elastic_anuc->GetComponentCrossSection() );
G4HadronElastic* elastic_lhep2 = new G4HadronElastic();
elastic_lhep2->SetMaxEnergy( elastic_elimitAntiNuc );
G4HadronElasticProcess* theElasticProcess = new G4HadronElasticProcess;
theElasticProcess->AddDataSet( elastic_anucxs );
theElasticProcess->RegisterMe( elastic_lhep2 );
theElasticProcess->RegisterMe( elastic_anuc );
pmanager->AddDiscreteProcess( theElasticProcess );
// Inelastic scattering
G4AntiProtonInelasticProcess* theInelasticProcess = new G4AntiProtonInelasticProcess("inelastic");
theInelasticProcess->AddDataSet( theAntiNucleonData );
theInelasticProcess->RegisterMe( theFTFModel0 );
pmanager->AddDiscreteProcess( theInelasticProcess );
}
else if (particleName == "neutron") {
// elastic scattering
G4HadronElasticProcess* theElasticProcess = new G4HadronElasticProcess;
theElasticProcess->AddDataSet(G4CrossSectionDataSetRegistry::Instance()->GetCrossSectionDataSet(G4ChipsNeutronElasticXS::Default_Name()));
G4HadronElastic* elastic_neutronChipsModel = new G4ChipsElasticModel();
elastic_neutronChipsModel->SetMinEnergy( 19.0*CLHEP::MeV );
theElasticProcess->RegisterMe( elastic_neutronChipsModel );
G4ParticleHPElastic * theElasticNeutronHP = new G4ParticleHPElastic;
theElasticNeutronHP->SetMinEnergy( theHPMin );
theElasticNeutronHP->SetMaxEnergy( theHPMax );
theElasticProcess->RegisterMe( theElasticNeutronHP );
theElasticProcess->AddDataSet( new G4ParticleHPElasticData );
pmanager->AddDiscreteProcess( theElasticProcess );
// inelastic scattering
G4NeutronInelasticProcess* theInelasticProcess = new G4NeutronInelasticProcess("inelastic");
theInelasticProcess->AddDataSet( new G4BGGNucleonInelasticXS( G4Neutron::Neutron() ) );
theInelasticProcess->RegisterMe( theFTFModel1 );
theInelasticProcess->RegisterMe( theBERTModel1 );
G4ParticleHPInelastic * theNeutronInelasticHPModel = new G4ParticleHPInelastic;
theNeutronInelasticHPModel->SetMinEnergy( theHPMin );
theNeutronInelasticHPModel->SetMaxEnergy( theHPMax );
theInelasticProcess->RegisterMe( theNeutronInelasticHPModel );
theInelasticProcess->AddDataSet( new G4ParticleHPInelasticData );
pmanager->AddDiscreteProcess(theInelasticProcess);
// capture
G4HadronCaptureProcess* theCaptureProcess = new G4HadronCaptureProcess;
G4ParticleHPCapture * theNeutronCaptureHPModel = new G4ParticleHPCapture;
theNeutronCaptureHPModel->SetMinEnergy( theHPMin );
theNeutronCaptureHPModel->SetMaxEnergy( theHPMax );
G4NeutronRadCapture* theNeutronRadCapture = new G4NeutronRadCapture();
theNeutronRadCapture->SetMinEnergy(theHPMax*0.99);
theCaptureProcess->RegisterMe( theNeutronCaptureHPModel );
theCaptureProcess->RegisterMe( theNeutronRadCapture);
theCaptureProcess->AddDataSet( new G4ParticleHPCaptureData );
theCaptureProcess->AddDataSet((G4NeutronCaptureXS*)G4CrossSectionDataSetRegistry::Instance()->GetCrossSectionDataSet(G4NeutronCaptureXS::Default_Name()));
pmanager->AddDiscreteProcess(theCaptureProcess);
}
else if (particleName == "anti_neutron")
{
// Elastic scattering
G4HadronElasticProcess* theElasticProcess = new G4HadronElasticProcess;
theElasticProcess->RegisterMe( elastic_lhep0 );
pmanager->AddDiscreteProcess( theElasticProcess );
// Inelastic scattering
G4AntiNeutronInelasticProcess* theInelasticProcess = new G4AntiNeutronInelasticProcess("inelastic");
theInelasticProcess->AddDataSet( theAntiNucleonData );
theInelasticProcess->RegisterMe( theFTFModel0 );
pmanager->AddDiscreteProcess( theInelasticProcess );
}
else if (particleName == "deuteron")
{
// Elastic scattering
G4HadronElasticProcess* theElasticProcess = new G4HadronElasticProcess;
theElasticProcess->RegisterMe( elastic_lhep0 );
pmanager->AddDiscreteProcess( theElasticProcess );
// Inelastic scattering
G4DeuteronInelasticProcess* theInelasticProcess = new G4DeuteronInelasticProcess("inelastic");
theInelasticProcess->AddDataSet( theGGNuclNuclData );
theInelasticProcess->RegisterMe( theFTFModel1 );
theInelasticProcess->RegisterMe( theIonBC );
pmanager->AddDiscreteProcess( theInelasticProcess );
}
else if (particleName == "triton")
{
// Elastic scattering
G4HadronElasticProcess* theElasticProcess = new G4HadronElasticProcess;
theElasticProcess->RegisterMe( elastic_lhep0 );
pmanager->AddDiscreteProcess( theElasticProcess );
// Inelastic scattering
G4TritonInelasticProcess* theInelasticProcess = new G4TritonInelasticProcess("inelastic");
theInelasticProcess->AddDataSet( theGGNuclNuclData );
theInelasticProcess->RegisterMe( theFTFModel1 );
theInelasticProcess->RegisterMe( theIonBC );
pmanager->AddDiscreteProcess( theInelasticProcess );
}
else if (particleName == "alpha")
{
// Elastic scattering
G4HadronElasticProcess* theElasticProcess = new G4HadronElasticProcess;
theElasticProcess->RegisterMe( elastic_lhep0 );
pmanager->AddDiscreteProcess( theElasticProcess );
// Inelastic scattering
G4AlphaInelasticProcess* theInelasticProcess = new G4AlphaInelasticProcess("inelastic");
theInelasticProcess->AddDataSet( theGGNuclNuclData );
theInelasticProcess->RegisterMe( theFTFModel1 );
theInelasticProcess->RegisterMe( theIonBC );
pmanager->AddDiscreteProcess( theInelasticProcess );
}
} // while ((*(myParticleIterator))())
// Add stopping processes with builder
stoppingPhysics->ConstructProcess();
}
// Decays ///////////////////////////////////////////////////////////////////
#include "G4Decay.hh"
#include "G4RadioactiveDecayBase.hh"
#include "G4IonTable.hh"
#include "G4Ions.hh"
#include "G4LossTableManager.hh"
#include "G4UAtomicDeexcitation.hh"
#include "G4NuclearLevelData.hh"
#include "G4NuclideTable.hh"
template<class T> void TLBE<T>::ConstructGeneral() {
// Add Decay Process
G4Decay* theDecayProcess = new G4Decay();
G4bool theDecayProcessNeverUsed = true; //Check if theDecayProcess will be used
auto myParticleIterator=G4ParticleTable::GetParticleTable()->GetIterator();
myParticleIterator->reset();
while( (*(myParticleIterator))() )
{
G4ParticleDefinition* particle = myParticleIterator->value();
G4ProcessManager* pmanager = particle->GetProcessManager();
if (theDecayProcess->IsApplicable(*particle) && !particle->IsShortLived())
{
theDecayProcessNeverUsed = false;
pmanager ->AddProcess(theDecayProcess);
// set ordering for PostStepDoIt and AtRestDoIt
pmanager ->SetProcessOrdering(theDecayProcess, idxPostStep);
pmanager ->SetProcessOrdering(theDecayProcess, idxAtRest);
}
}
// Declare radioactive decay to the GenericIon in the IonTable.
const G4IonTable *theIonTable =
G4ParticleTable::GetParticleTable()->GetIonTable();
G4RadioactiveDecayBase* theRadioactiveDecay = new G4RadioactiveDecayBase();
//Fix for activation of RadioactiveDecay, based on G4RadioactiveDecayPhysics
G4EmParameters* param = G4EmParameters::Instance();
param->SetAugerCascade(true);
param->AddPhysics("world","G4RadioactiveDecay");
G4DeexPrecoParameters* deex = G4NuclearLevelData::GetInstance()->GetParameters();
deex->SetStoreAllLevels(true);
deex->SetMaxLifeTime(G4NuclideTable::GetInstance()->GetThresholdOfHalfLife()
/std::log(2.));
G4LossTableManager* man = G4LossTableManager::Instance();
G4VAtomDeexcitation* ad = man->AtomDeexcitation();
if(!ad) {
ad = new G4UAtomicDeexcitation();
man->SetAtomDeexcitation(ad);
ad->InitialiseAtomicDeexcitation();
}
for (G4int i=0; i<theIonTable->Entries(); i++)
{
G4String particleName = theIonTable->GetParticle(i)->GetParticleName();
G4String particleType = theIonTable->GetParticle(i)->GetParticleType();
if (particleName == "GenericIon")
{
G4ProcessManager* pmanager =
theIonTable->GetParticle(i)->GetProcessManager();
pmanager->SetVerboseLevel(VerboseLevel);
pmanager ->AddProcess(theRadioactiveDecay);
pmanager ->SetProcessOrdering(theRadioactiveDecay, idxPostStep);
pmanager ->SetProcessOrdering(theRadioactiveDecay, idxAtRest);
}
}
//If we actually never used the process, delete it
//From Coverity report
if ( theDecayProcessNeverUsed ) delete theDecayProcess;
}
// Cuts /////////////////////////////////////////////////////////////////////
template<class T> void TLBE<T>::SetCuts()
{
if (this->verboseLevel >1)
G4cout << "LBE::SetCuts:";
if (this->verboseLevel>0){
G4cout << "LBE::SetCuts:";
G4cout << "CutLength : "
<< G4BestUnit(this->defaultCutValue,"Length") << G4endl;
}
//special for low energy physics
G4double lowlimit=250*CLHEP::eV;
G4ProductionCutsTable * aPCTable = G4ProductionCutsTable::GetProductionCutsTable();
aPCTable->SetEnergyRange(lowlimit,100*CLHEP::GeV);
// set cut values for gamma at first and for e- second and next for e+,
// because some processes for e+/e- need cut values for gamma
this->SetCutValue(cutForGamma, "gamma");
this->SetCutValue(cutForElectron, "e-");
this->SetCutValue(cutForPositron, "e+");
// this->SetCutValue(cutForProton, "proton");
// this->SetCutValue(cutForProton, "anti_proton");
// this->SetCutValue(cutForAlpha, "alpha");
// this->SetCutValue(cutForGenericIon, "GenericIon");
// this->SetCutValueForOthers(this->defaultCutValue);
if (this->verboseLevel>0) this->DumpCutValuesTable();
}
source/physics_lists/lists/include/NuBeam.hh
+8 -19
View File
@@ -32,36 +32,25 @@
//
//----------------------------------------------------------------------------
//
#ifndef TNuBeam_h
#define TNuBeam_h 1
#include <CLHEP/Units/SystemOfUnits.h>
#ifndef NuBeam_h
#define NuBeam_h 1
#include "globals.hh"
#include "G4VModularPhysicsList.hh"
#include "CompileTimeConstraints.hh"
template<class T>
class TNuBeam : public T
class NuBeam : public G4VModularPhysicsList
{
public:
TNuBeam(G4int ver = 1);
virtual ~TNuBeam();
NuBeam(G4int ver = 1);
virtual ~NuBeam()=default;
public:
// SetCuts()
virtual void SetCuts();
private:
enum { ok = CompileTimeConstraints::IsA< T, G4VModularPhysicsList >::ok };
NuBeam(const NuBeam &) = delete;
NuBeam & operator=(const NuBeam &)=delete;
};
#include "NuBeam.icc"
typedef TNuBeam<G4VModularPhysicsList> NuBeam;
#endif
source/physics_lists/lists/include/NuBeam.icc
-116
View File
@@ -1,116 +0,0 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
//
//---------------------------------------------------------------------------
//
// ClassName: NuBeam
//
// Author: Julia Yarba, FNAL/CD (2014)
//
//
// Modified:
//
//----------------------------------------------------------------------------
//
#include <iomanip>
#include "globals.hh"
#include "G4ios.hh"
#include "G4ProcessManager.hh"
#include "G4ProcessVector.hh"
#include "G4ParticleTypes.hh"
#include "G4ParticleTable.hh"
#include "G4Material.hh"
#include "G4MaterialTable.hh"
#include "G4DecayPhysics.hh"
#include "G4EmStandardPhysics.hh"
#include "G4EmExtraPhysics.hh"
#include "G4IonPhysics.hh"
#include "G4StoppingPhysics.hh"
#include "G4HadronElasticPhysics.hh"
#include "G4NeutronTrackingCut.hh"
#include "G4DataQuestionaire.hh"
#include "G4HadronPhysicsNuBeam.hh"
template<class T> TNuBeam<T>::TNuBeam(G4int ver): T()
{
G4DataQuestionaire it(photon);
G4cout << "<<< Geant4 Physics List simulation engine: NuBeam v0.0" << G4endl;
G4cout <<G4endl;
this->defaultCutValue = 0.7*CLHEP::mm;
this->SetVerboseLevel(ver);
// EM Physics
this->RegisterPhysics( new G4EmStandardPhysics(ver));
// Synchroton Radiation & GN Physics
this->RegisterPhysics( new G4EmExtraPhysics(ver) );
// Decays
this->RegisterPhysics( new G4DecayPhysics(ver) );
// Hadron Elastic scattering
this->RegisterPhysics( new G4HadronElasticPhysics(ver) );
// Hadron Physics
this->RegisterPhysics( new G4HadronPhysicsNuBeam(ver));
// Stopping Physics
this->RegisterPhysics( new G4StoppingPhysics(ver) );
// Ion Physics
this->RegisterPhysics( new G4IonPhysics(ver));
// Neutron tracking cut
this->RegisterPhysics( new G4NeutronTrackingCut(ver));
}
template<class T> TNuBeam<T>::~TNuBeam()
{
}
template<class T> void TNuBeam<T>::SetCuts()
{
if (this->verboseLevel >1){
G4cout << "TNuBeam::SetCuts:";
}
// " G4VUserPhysicsList::SetCutsWithDefault" method sets
// the default cut value for all particle types
this->SetCutsWithDefault();
// if (this->verboseLevel > 0)
// G4VUserPhysicsList::DumpCutValuesTable();
}
source/physics_lists/lists/include/QBBC.hh
+3 -5
View File
@@ -46,13 +46,11 @@ public:
explicit QBBC(G4int ver = 1, const G4String& type = "QBBC");
virtual ~QBBC();
private:
virtual ~QBBC()=default;
// copy constructor and hide assignment operator
QBBC(QBBC &);
QBBC & operator=(const QBBC &right);
QBBC(const QBBC &)=delete;
QBBC & operator=(const QBBC &right)=delete;
};
source/physics_lists/lists/include/QGSP_BERT.hh
+8 -20
View File
@@ -34,35 +34,23 @@
//
//----------------------------------------------------------------------------
//
#ifndef TQGSP_BERT_h
#define TQGSP_BERT_h 1
#include <CLHEP/Units/SystemOfUnits.h>
#ifndef QGSP_BERT_h
#define QGSP_BERT_h 1
#include "globals.hh"
#include "G4VModularPhysicsList.hh"
#include "CompileTimeConstraints.hh"
template<class T>
class TQGSP_BERT: public T
class QGSP_BERT: public G4VModularPhysicsList
{
public:
TQGSP_BERT(G4int ver = 1);
virtual ~TQGSP_BERT();
QGSP_BERT(G4int ver = 1);
virtual ~QGSP_BERT()=default;
QGSP_BERT(const QGSP_BERT &) = delete;
QGSP_BERT & operator=(const QGSP_BERT &)=delete;
public:
// SetCuts()
virtual void SetCuts();
private:
enum {ok = CompileTimeConstraints::IsA<T, G4VModularPhysicsList>::ok };
};
#include "QGSP_BERT.icc"
typedef TQGSP_BERT<G4VModularPhysicsList> QGSP_BERT;
// 2002 by J.P. Wellisch
#endif
source/physics_lists/lists/include/QGSP_BERT.icc
-128
View File
@@ -1,128 +0,0 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
//
//---------------------------------------------------------------------------
//
// ClassName: QGSP_BERT
//
// Author: 2002 J.P. Wellisch
//
// Modified:
// 25.11.2005 G.Folger: migration to non static particles
// 30.11.2005 G.Folger: Register EmStandard first, split Em Standard and Extra
// 02.12.2005 V.Ivanchenko: rename components
// 08.06.2006 V.Ivanchenko: migration to CHIPS stopping
// 15.06.2006 G.Folger: Migrate to HadronElasticPhysics using improved elastic
// 20.11.2006 G.Folger: add Tracking Cut for neutrons
// 26.04.2007 G.Folger: Enable quasielastic for QGS string model
// 16.05.2007 V.Ivanchenko: rename EM builders
// 04.06.2010 G.Folger: Use new ctor for builders
// 16.08.2010 H.Kurashige: Remove inclusion of G4ParticleWithCuts
// 16.10.2012 A.Ribon: Renamed the physics classes used
//
//----------------------------------------------------------------------------
//
#include <iomanip>
#include "globals.hh"
#include "G4ios.hh"
#include "G4ProcessManager.hh"
#include "G4ProcessVector.hh"
#include "G4ParticleTypes.hh"
#include "G4ParticleTable.hh"
#include "G4Material.hh"
#include "G4MaterialTable.hh"
#include "G4DecayPhysics.hh"
#include "G4EmStandardPhysics.hh"
#include "G4EmExtraPhysics.hh"
#include "G4IonPhysics.hh"
#include "G4StoppingPhysics.hh"
#include "G4HadronElasticPhysics.hh"
#include "G4NeutronTrackingCut.hh"
#include "G4DataQuestionaire.hh"
#include "G4HadronPhysicsQGSP_BERT.hh"
template<class T> TQGSP_BERT<T>::TQGSP_BERT(G4int ver): T()
{
G4DataQuestionaire it(photon);
G4cout << "<<< Geant4 Physics List simulation engine: QGSP_BERT 4.0"<<G4endl;
G4cout <<G4endl;
this->defaultCutValue = 0.7*CLHEP::mm;
this->SetVerboseLevel(ver);
// EM Physics
this->RegisterPhysics( new G4EmStandardPhysics(ver) );
// Synchroton Radiation & GN Physics
this->RegisterPhysics( new G4EmExtraPhysics(ver) );
// Decays
this->RegisterPhysics( new G4DecayPhysics(ver) );
// Hadron Elastic scattering
this->RegisterPhysics( new G4HadronElasticPhysics(ver) );
// Hadron Physics
this->RegisterPhysics( new G4HadronPhysicsQGSP_BERT(ver));
// Stopping Physics
this->RegisterPhysics( new G4StoppingPhysics(ver) );
// Ion Physics
this->RegisterPhysics( new G4IonPhysics(ver));
// Neutron tracking cut
this->RegisterPhysics( new G4NeutronTrackingCut(ver));
}
template<class T> TQGSP_BERT<T>::~TQGSP_BERT()
{
}
template<class T> void TQGSP_BERT<T>::SetCuts()
{
if (this->verboseLevel >1){
G4cout << "QGSP_BERT::SetCuts:";
}
// " G4VUserPhysicsList::SetCutsWithDefault" method sets
// the default cut value for all particle types
this->SetCutsWithDefault();
// if (this->verboseLevel >0)
// G4VUserPhysicsList::DumpCutValuesTable();
}
// 2002 by J.P. Wellisch
source/physics_lists/lists/include/QGSP_BERT_HP.hh
+10 -18
View File
@@ -34,33 +34,25 @@
//
//----------------------------------------------------------------------------
//
#ifndef TQGSP_BERT_HP_h
#define TQGSP_BERT_HP_h 1
#include <CLHEP/Units/SystemOfUnits.h>
#ifndef QGSP_BERT_HP_h
#define QGSP_BERT_HP_h 1
#include "globals.hh"
#include "G4VModularPhysicsList.hh"
#include "CompileTimeConstraints.hh"
template<class T>
class TQGSP_BERT_HP: public T
class QGSP_BERT_HP: public G4VModularPhysicsList
{
public:
TQGSP_BERT_HP(G4int ver=1);
virtual ~TQGSP_BERT_HP();
public:
QGSP_BERT_HP(G4int ver=1);
virtual ~QGSP_BERT_HP()=default;
QGSP_BERT_HP(const QGSP_BERT_HP &) = delete;
QGSP_BERT_HP & operator=(const QGSP_BERT_HP &)=delete;
// SetCuts()
virtual void SetCuts();
private:
enum {ok = CompileTimeConstraints::IsA<T, G4VModularPhysicsList>::ok };
};
#include "QGSP_BERT_HP.icc"
typedef TQGSP_BERT_HP<G4VModularPhysicsList> QGSP_BERT_HP;
// 2002 by J.P. Wellisch
#endif
source/physics_lists/lists/include/QGSP_BERT_HP.icc
-127
View File
@@ -1,127 +0,0 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
//
//---------------------------------------------------------------------------
//
// ClassName: QGSP_BERT
//
// Author: 2002 J.P. Wellisch
//
// Modified:
// 15.12.2005 G.Folger: migration to non static particles, rename components,
// ordering of registrations
// 08.06.2006 V.Ivanchenko: migration to CHIPS stopping
// 15.06.2006 G.Folger: Migrate to HadronElasticPhysics using improved elastic
// 26.04.2007 G.Folger: Enable quasielastic for QGS string model
// 16.05.2007 V.Ivanchenko: rename EM builders
// 04.06.2010 G.Folger: Use new ctor for builders
// 16.08.2010 H.Kurashige: Remove inclusion of G4ParticleWithCuts
// 16.10.2012 A.Ribon: Use new default stopping
//
//----------------------------------------------------------------------------
//
#include <iomanip>
#include "globals.hh"
#include "G4ios.hh"
#include "G4ProcessManager.hh"
#include "G4ProcessVector.hh"
#include "G4ParticleTypes.hh"
#include "G4ParticleTable.hh"
#include "G4Material.hh"
#include "G4MaterialTable.hh"
#include "G4DecayPhysics.hh"
#include "G4EmStandardPhysics.hh"
#include "G4EmExtraPhysics.hh"
#include "G4IonPhysics.hh"
#include "G4StoppingPhysics.hh"
#include "G4HadronElasticPhysicsHP.hh"
#include "G4DataQuestionaire.hh"
#include "G4HadronPhysicsQGSP_BERT_HP.hh"
template<class T> TQGSP_BERT_HP<T>::TQGSP_BERT_HP(G4int ver): T()
{
G4DataQuestionaire it(photon, neutron);
G4cout << "<<< Geant4 Physics List simulation engine: QGSP_BERT_HP"<<G4endl;
G4cout <<G4endl<<G4endl;
this->defaultCutValue = 0.7*CLHEP::mm;
this->SetVerboseLevel(ver);
// EM Physics
this->RegisterPhysics( new G4EmStandardPhysics(ver) );
// Synchroton Radiation & GN Physics
this->RegisterPhysics( new G4EmExtraPhysics(ver) );
// Decays
this->RegisterPhysics( new G4DecayPhysics(ver) );
// Hadron Elastic scattering
this-> RegisterPhysics( new G4HadronElasticPhysicsHP(ver) );
// Hadron Physics
this->RegisterPhysics( new G4HadronPhysicsQGSP_BERT_HP(ver));
// Stopping Physics
this->RegisterPhysics( new G4StoppingPhysics(ver));
// Ion Physics
this->RegisterPhysics( new G4IonPhysics(ver));
}
template<class T> TQGSP_BERT_HP<T>::~TQGSP_BERT_HP()
{
}
template<class T> void TQGSP_BERT_HP<T>::SetCuts()
{
if (this->verboseLevel >1){
G4cout << "QGSP_BERT_HP::SetCuts:";
}
// " G4VUserPhysicsList::SetCutsWithDefault" method sets
// the default cut value for all particle types
this->SetCutsWithDefault();
//Set proton cut value to 0 for producing low energy recoil nucleus
this->SetCutValue(0, "proton");
// if (this->verboseLevel >0)
// G4VUserPhysicsList::DumpCutValuesTable();
}
// 2002 by J.P. Wellisch
source/physics_lists/lists/include/QGSP_BIC.hh
+3 -6
View File
@@ -44,13 +44,10 @@ class QGSP_BIC : public G4VModularPhysicsList
{
public:
QGSP_BIC(G4int ver = 1);
virtual ~QGSP_BIC();
virtual ~QGSP_BIC()=default;
private:
// copy constructor and hide assignment operator
QGSP_BIC(QGSP_BIC &);
QGSP_BIC & operator=(const QGSP_BIC &right);
QGSP_BIC(const QGSP_BIC &)=delete;
QGSP_BIC & operator=(const QGSP_BIC &right)=delete;
};
source/physics_lists/lists/include/QGSP_BIC_AllHP.hh
+4 -6
View File
@@ -43,13 +43,11 @@ class QGSP_BIC_AllHP : public G4VModularPhysicsList
{
public:
QGSP_BIC_AllHP(G4int ver = 1);
virtual ~QGSP_BIC_AllHP();
virtual ~QGSP_BIC_AllHP()=default;
private:
// copy constructor and hide assignment operator
QGSP_BIC_AllHP(QGSP_BIC_AllHP &);
QGSP_BIC_AllHP& operator=(const QGSP_BIC_AllHP &right);
//delete copy constructor and assignment operator
QGSP_BIC_AllHP(const QGSP_BIC_AllHP &)=delete;
QGSP_BIC_AllHP& operator=(const QGSP_BIC_AllHP &right)=delete;
};
source/physics_lists/lists/include/QGSP_BIC_HP.hh
+4 -6
View File
@@ -45,13 +45,11 @@ class QGSP_BIC_HP : public G4VModularPhysicsList
{
public:
QGSP_BIC_HP(G4int ver = 1);
virtual ~QGSP_BIC_HP();
virtual ~QGSP_BIC_HP()=default;
private:
// copy constructor and hide assignment operator
QGSP_BIC_HP(QGSP_BIC_HP &);
QGSP_BIC_HP & operator=(const QGSP_BIC_HP &right);
// delete copy constructor and assignment operator
QGSP_BIC_HP(const QGSP_BIC_HP &)=delete;
QGSP_BIC_HP & operator=(const QGSP_BIC_HP &right)=delete;
};
source/physics_lists/lists/include/QGSP_FTFP_BERT.hh
+8 -20
View File
@@ -34,35 +34,23 @@
//
//----------------------------------------------------------------------------
//
#ifndef TQGSP_FTFP_BERT_h
#define TQGSP_FTFP_BERT_h 1
#include <CLHEP/Units/SystemOfUnits.h>
#ifndef QGSP_FTFP_BERT_h
#define QGSP_FTFP_BERT_h 1
#include "globals.hh"
#include "G4VModularPhysicsList.hh"
#include "CompileTimeConstraints.hh"
template<class T>
class TQGSP_FTFP_BERT: public T
class QGSP_FTFP_BERT: public G4VModularPhysicsList
{
public:
TQGSP_FTFP_BERT(G4int ver = 1);
virtual ~TQGSP_FTFP_BERT();
QGSP_FTFP_BERT(G4int ver = 1);
virtual ~QGSP_FTFP_BERT()=default;
QGSP_FTFP_BERT(const QGSP_FTFP_BERT &) = delete;
QGSP_FTFP_BERT & operator=(const QGSP_FTFP_BERT &)=delete;
public:
// SetCuts()
virtual void SetCuts();
private:
enum {ok = CompileTimeConstraints::IsA<T, G4VModularPhysicsList>::ok };
};
#include "QGSP_FTFP_BERT.icc"
typedef TQGSP_FTFP_BERT<G4VModularPhysicsList> QGSP_FTFP_BERT;
// 2002 by J.P. Wellisch
#endif
source/physics_lists/lists/include/QGSP_FTFP_BERT.icc
-122
View File
@@ -1,122 +0,0 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
//
//---------------------------------------------------------------------------
//
// ClassName: QGSP_FTFP_BERT
//
// Author: 2009 J. Apostolakis/V.Ivantchenko
//
// Modified:
// 27.11.2009 G.Folger: Mark as experimental
// 04.06.2010 G.Folger: Use new ctor for builders
// 04.06.2010 G.Folger: Remove experimental status
// 16.08.2010 H.Kurashige: Remove inclusion of G4ParticleWithCuts
// 16.10.2012 A.Ribon: Renamed the physics classes used
//
//----------------------------------------------------------------------------
//
#include <iomanip>
#include "globals.hh"
#include "G4ios.hh"
#include "G4ProcessManager.hh"
#include "G4ProcessVector.hh"
#include "G4ParticleTypes.hh"
#include "G4ParticleTable.hh"
#include "G4Material.hh"
#include "G4MaterialTable.hh"
#include "G4DecayPhysics.hh"
#include "G4EmStandardPhysics.hh"
#include "G4EmExtraPhysics.hh"
#include "G4IonPhysics.hh"
#include "G4StoppingPhysics.hh"
#include "G4HadronElasticPhysics.hh"
#include "G4NeutronTrackingCut.hh"
#include "G4DataQuestionaire.hh"
#include "G4HadronPhysicsQGSP_FTFP_BERT.hh"
template<class T> TQGSP_FTFP_BERT<T>::TQGSP_FTFP_BERT(G4int ver): T()
{
G4DataQuestionaire it(photon);
G4cout << "<<< Geant4 Physics List simulation engine: QGSP_FTFP_BERT 4.0"<<G4endl;
G4cout <<G4endl;
this->defaultCutValue = 0.7*CLHEP::mm;
this->SetVerboseLevel(ver);
// EM Physics
this->RegisterPhysics( new G4EmStandardPhysics(ver) );
// Synchroton Radiation & GN Physics
this->RegisterPhysics( new G4EmExtraPhysics(ver) );
// Decays
this->RegisterPhysics( new G4DecayPhysics(ver) );
// Hadron Elastic scattering
this->RegisterPhysics( new G4HadronElasticPhysics(ver) );
// Hadron Physics
this->RegisterPhysics( new G4HadronPhysicsQGSP_FTFP_BERT(ver));
// Stopping Physics
this->RegisterPhysics( new G4StoppingPhysics(ver) );
// Ion Physics
this->RegisterPhysics( new G4IonPhysics(ver));
// Neutron tracking cut
this->RegisterPhysics( new G4NeutronTrackingCut(ver));
}
template<class T> TQGSP_FTFP_BERT<T>::~TQGSP_FTFP_BERT()
{
}
template<class T> void TQGSP_FTFP_BERT<T>::SetCuts()
{
if (this->verboseLevel >1){
G4cout << "QGSP_FTFP_BERT::SetCuts:";
}
// " G4VUserPhysicsList::SetCutsWithDefault" method sets
// the default cut value for all particle types
this->SetCutsWithDefault();
// if (this->verboseLevel >0)
// G4VUserPhysicsList::DumpCutValuesTable();
}
// 2002 by J.P. Wellisch
source/physics_lists/lists/include/QGS_BIC.hh
+9 -17
View File
@@ -35,31 +35,23 @@
//
//----------------------------------------------------------------------------
//
#ifndef TQGS_BIC_h
#define TQGS_BIC_h 1
#include <CLHEP/Units/SystemOfUnits.h>
#ifndef QGS_BIC_h
#define QGS_BIC_h 1
#include "globals.hh"
#include "G4VModularPhysicsList.hh"
#include "CompileTimeConstraints.hh"
template<class T>
class TQGS_BIC: public T
class QGS_BIC: public G4VModularPhysicsList
{
public:
TQGS_BIC(G4int ver = 1);
virtual ~TQGS_BIC();
QGS_BIC(G4int ver = 1);
virtual ~QGS_BIC()=default;
QGS_BIC(const QGS_BIC &) = delete;
QGS_BIC & operator=(const QGS_BIC &)=delete;
public:
// SetCuts()
virtual void SetCuts();
private:
enum {ok = CompileTimeConstraints::IsA<T, G4VModularPhysicsList>::ok };
};
#include "QGS_BIC.icc"
typedef TQGS_BIC<G4VModularPhysicsList> QGS_BIC;
#endif
source/physics_lists/lists/include/QGS_BIC.icc
-129
View File
@@ -1,129 +0,0 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
//
//---------------------------------------------------------------------------
//
// ClassName: QGS_BIC
//
// Author: 2007 Gunter Folger
// created from QGSP_BIC by H.P.Wellisch
//
// Modified:
// 04.06.2010 G.Folger: Use new ctor for builders
// 16.08.2010 H.Kurashige: Remove inclusion of G4ParticleWithCuts
// 16.10.2012 A.Ribon: Use new default stopping and ion physics
//
//----------------------------------------------------------------------------
//
#include <iomanip>
#include "globals.hh"
#include "G4ios.hh"
#include "G4ProcessManager.hh"
#include "G4ProcessVector.hh"
#include "G4ParticleTypes.hh"
#include "G4ParticleTable.hh"
#include "G4Material.hh"
#include "G4MaterialTable.hh"
#include "G4DecayPhysics.hh"
#include "G4EmStandardPhysics.hh"
#include "G4EmExtraPhysics.hh"
#include "G4IonPhysics.hh"
#include "G4StoppingPhysics.hh"
#include "G4HadronElasticPhysics.hh"
#include "G4NeutronTrackingCut.hh"
//AR-31Oct2012 #include "G4NeutronCrossSectionXS.hh"
#include "G4DataQuestionaire.hh"
#include "G4HadronPhysicsQGS_BIC.hh"
#include "G4WarnPLStatus.hh"
template<class T> TQGS_BIC<T>::TQGS_BIC(G4int ver): T()
{
// default cut value (1.0mm)
// defaultCutValue = 1.0*CLHEP::mm;
G4DataQuestionaire it(photon);
G4cout << "<<< Geant4 Physics List simulation engine: QGS_BIC 2.0"<<G4endl;
G4cout <<G4endl;
this->defaultCutValue = 0.7*CLHEP::mm;
this->SetVerboseLevel(ver);
G4WarnPLStatus exp;
exp.Experimental("QGS_BIC");
// EM Physics
this->RegisterPhysics( new G4EmStandardPhysics(ver) );
// Synchroton Radiation & GN Physics
this->RegisterPhysics( new G4EmExtraPhysics(ver) );
// Decays
this->RegisterPhysics( new G4DecayPhysics(ver) );
// Hadron Elastic scattering
this->RegisterPhysics( new G4HadronElasticPhysics(ver) );
// Hadron Physics
this->RegisterPhysics( new G4HadronPhysicsQGS_BIC(ver) );
// Stopping Physics
this->RegisterPhysics( new G4StoppingPhysics(ver) );
// Ion Physics
this->RegisterPhysics( new G4IonPhysics(ver) );
// Neutron tracking cut
this->RegisterPhysics( new G4NeutronTrackingCut(ver) );
// Neutron cross sections
//AR-31Oct2012 this->RegisterPhysics( new G4NeutronCrossSectionXS(ver) );
}
template<class T> TQGS_BIC<T>::~TQGS_BIC()
{
}
template<class T> void TQGS_BIC<T>::SetCuts()
{
if (this->verboseLevel >1){
G4cout << "QGS_BIC::SetCuts:";
}
// " G4VUserPhysicsList::SetCutsWithDefault" method sets
// the default cut value for all particle types
this->SetCutsWithDefault();
// if (this->verboseLevel >0)
// G4VUserPhysicsList::DumpCutValuesTable();
}
source/physics_lists/lists/include/Shielding.hh
+4 -6
View File
@@ -48,13 +48,11 @@ class Shielding : public G4VModularPhysicsList
public:
explicit Shielding(G4int verb = 1 , const G4String& n_model = "HP",
const G4String& HadrPhysVariant = "");
virtual ~Shielding();
virtual ~Shielding()=default;
private:
// copy constructor and hide assignment operator
Shielding(Shielding &);
Shielding & operator=(const Shielding &right);
//delete copy constructor and assignment operator
Shielding(const Shielding &)=delete;
Shielding & operator=(const Shielding &right)=delete;
};
#endif
source/physics_lists/lists/include/ShieldingLEND.hh
+3 -5
View File
@@ -45,13 +45,11 @@ class ShieldingLEND : public Shielding
{
public:
explicit ShieldingLEND(G4int ver = 1) : Shielding(ver,"LEND","") {};
virtual ~ShieldingLEND() {};
private:
virtual ~ShieldingLEND()=default;
// copy constructor and hide assignment operator
ShieldingLEND(ShieldingLEND &);
ShieldingLEND & operator=(const ShieldingLEND &right);
ShieldingLEND(const ShieldingLEND &)=delete;
ShieldingLEND & operator=(const ShieldingLEND &right)=delete;
};
#endif