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

Import Geant4 10.0.0 source tree

Browse Source
This commit is contained in:
Gabriele Cosmo
2016-06-10 11:51:14 +02:00
parent e2d2f9810a
commit 286caacf06
12421 changed files with 730077 additions and 502383 deletions
Download Patch File Download Diff File Expand all files Collapse all files
source/physics_lists/constructors/electromagnetic/CMakeLists.txt
+19
View File
@@ -0,0 +1,19 @@
#------------------------------------------------------------------------------
# CMakeLists.txt
# Module : G4physlist_ctor_factory
# Package: Geant4.src.G4physicslists.G4phys_ctors.G4phys_ctor_em
#
# CMakeLists.txt for building a single granular library.
#
# Generated on : 12-Jan-2013
#
# $Id: CMakeLists.txt 66704 2013-01-10 18:20:17Z gunter $
#
#------------------------------------------------------------------------------
if(GEANT4_BUILD_GRANULAR_LIBS)
include(Geant4MacroLibraryTargets)
GEANT4_GRANULAR_LIBRARY_TARGET(COMPONENT sources.cmake)
endif()
source/physics_lists/constructors/electromagnetic/GNUmakefile
+56
View File
@@ -0,0 +1,56 @@
# $Id: GNUmakefile 77567 2013-11-26 09:40:31Z gcosmo $
# ---------------------------------------------------------------------------
# GNUmakefile for physics_lists/constructors/electromagnetic library.
# Gunter Folger 10-Jan-2012.
# ---------------------------------------------------------------------------
name := G4phys_ctor_em
ifndef G4INSTALL
G4INSTALL = ../../../..
endif
include $(G4INSTALL)/config/architecture.gmk
CPPFLAGS += -I$(G4BASE)/global/management/include \
-I$(G4BASE)/global/HEPRandom/include \
-I$(G4BASE)/global/HEPNumerics/include \
-I$(G4BASE)/global/HEPGeometry/include \
-I$(G4BASE)/geometry/volumes/include \
-I$(G4BASE)/geometry/management/include \
-I$(G4BASE)/geometry/magneticfield/include \
-I$(G4BASE)/geometry/navigation/include \
-I$(G4BASE)/intercoms/include \
-I$(G4BASE)/track/include \
-I$(G4BASE)/particles/shortlived/include \
-I$(G4BASE)/particles/management/include \
-I$(G4BASE)/particles/leptons/include \
-I$(G4BASE)/particles/bosons/include \
-I$(G4BASE)/particles/hadrons/mesons/include \
-I$(G4BASE)/particles/hadrons/barions/include \
-I$(G4BASE)/particles/hadrons/ions/include \
-I$(G4BASE)/run/include \
-I$(G4BASE)/physics_lists/builders/include \
-I$(G4BASE)/physics_lists/constructors/factory/include \
-I$(G4BASE)/physics_lists/util/include \
-I$(G4BASE)/processes/management/include \
-I$(G4BASE)/processes/transportation/include \
-I$(G4BASE)/processes/decay/include \
-I$(G4BASE)/processes/cuts/include \
-I$(G4BASE)/processes/optical/include \
-I$(G4BASE)/processes/electromagnetic/highenergy/include \
-I$(G4BASE)/processes/electromagnetic/standard/include \
-I$(G4BASE)/processes/electromagnetic/muons/include \
-I$(G4BASE)/processes/electromagnetic/utils/include \
-I$(G4BASE)/processes/electromagnetic/xrays/include \
-I$(G4BASE)/processes/electromagnetic/lowenergy/include \
-I$(G4BASE)/processes/electromagnetic/dna/management/include \
-I$(G4BASE)/processes/electromagnetic/dna/molecules/management/include \
-I$(G4BASE)/processes/electromagnetic/dna/molecules/types/include \
-I$(G4BASE)/processes/electromagnetic/dna/models/include \
-I$(G4BASE)/processes/electromagnetic/dna/processes/include \
-I$(G4BASE)/processes/electromagnetic/dna/utils/include \
-I$(G4BASE)/materials/include
include $(G4INSTALL)/config/common.gmk
source/physics_lists/constructors/electromagnetic/History
+95
View File
@@ -0,0 +1,95 @@
$Id: History 75585 2013-11-04 12:24:44Z gcosmo $
-------------------------------------------------------------------
=========================================================
Geant4 - an Object-Oriented Toolkit for Simulation in HEP
=========================================================
Hadronic physics-list/constructors/factory History
--------------------------------------------------
This file should be used to briefly summarize all major modifications
introduced in the code and keeptrack of all tags.
----------------------------------------------------------
* Reverse chronological order (last date on top), please *
----------------------------------------------------------
01-Nov-2013, M.K (phys-ctor-em-V09-06-21)
- Update sources.cmake
01-Nov-2013, M.K (phys-ctor-em-V09-06-20)
- Remove temporarly G4EmDNAPhysicsChemistry to avoid conflicts with dna dev
01-Nov-2013, M.K (phys-ctor-em-V09-06-19)
- Modified G4EmDNAPhysicsChemistry
- Update sources.cmake
28-Oct-2013, V.Ivanchenko (phys-ctor-em-V09-06-18)
- G4EmStandardPhysics - disable ApplyCuts option
- G4EmStandardPhysics_option2 - removed unused header
10-Oct-2013, M.K (phys-ctor-em-V09-06-17)
- Same as before
06-Oct-2013, M.K (phys-ctor-em-V09-06-16)
- Same as before
04-Oct-2013, M.K (phys-ctor-em-V09-06-15)
- Remove unused variable
03-Oct-2013, M.K (phys-ctor-em-V09-06-14)
- DNA chemistry physics list updated
16-Sep-2013, V.Ivanchenko (phys-ctor-em-V09-06-13)
- G4EmStandardPhysics - enable ApplyCuts option
- G4EmStandardPhysics_option2 - disable ApplyCuts option
both changings are needed to check an effect of these options
to optimise EM for the release
14-Sep-2013, M.Asai (phys-ctor-em-V09-06-12)
- Further fix G4OpticalPhysics for MT.
12-Sep-2013, M.Asai (phys-ctor-em-V09-06-11)
- Fix G4OpticalPhysics for MT.
21-Aug-2013, V.Ivanchenko (phys-ctor-em-V09-06-10)
- Removed G4UrbanMscModel95 from EmDNA constructor
19-Aug-2013, V.Ivanchenko (phys-ctor-em-V09-06-09)
- in all constructors use G4UrbanMscModel instead of Urban93 or Urban95
17-Jun-2013, Alberto Ribon (phys-ctor-em-V09-06-08)
- Fixed compilation warning in G4EmDNAPhysicsChemistry.
29-Mar-2013, Andrea Dotti (phys-ctor-em-V09-06-07)
- Changes needed for MT: now G4VUserPhysicsList is a split class
21-Mar-2013, A. Dotti (phys-ctor-em-V09-06-06)
- Use Get/Set methods to access master process manager pointer for G4ParticleDefinition
in EmDNA constructor (co-working tag with particles-V09-06-08)
27-Feb-2013, V.Ivanchenko (phys-ctor-em-V09-06-05)
- in all constructors improved verbose oputput and fixed warning from
the clang compiler on MacOS
19-Feb-2013, V.Ivanchenko (phys-ctor-em-V09-06-04)
- in all constructors G4UrbanMscModel95 substituted by G4UrbanMscModel
- G4EmStandardPhysics_option4 - low limit increased from 10 eV to 100 eV
13-Feb-2013, V.Ivanchenko (phys-ctor-em-V09-06-03)
- G4EmLivermorePhysics - set low-limit 100 eV and number of bins
for tables 220 to avoid problems in Livermore ionisation for
electron stopping powers and ranges
01-Feb-2013, V.Ivanchenko (phys-ctor-em-V09-06-02)
- G4EmExtraPhysics and G4EmMessenger are moved to gamma_lepto_nuclear
subdirectory
- removed unused dependences from GNUmakefile and source.cmake
30-Jan-2013, Mathieu Karamitros, G.Folger (phys-ctor-em-V09-06-01)
- First and simple approach to solve process manager initialization after
migratioon to G4MT.
10-Jan-2013, Gunter Folger (phys-ctor-em-V09-06-00)
- new directory structure introduced.
constructors/electromagnetic classes
source/physics_lists/constructors/electromagnetic/include/G4EmDNAPhysics.hh
+63
View File
@@ -0,0 +1,63 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
//
// $Id: G4EmDNAPhysics.hh 66704 2013-01-10 18:20:17Z gunter $
#ifndef G4EmDNAPhysics_h
#define G4EmDNAPhysics_h 1
#include "G4VPhysicsConstructor.hh"
#include "globals.hh"
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
class G4EmDNAPhysics : public G4VPhysicsConstructor
{
public:
G4EmDNAPhysics(G4int ver = 1);
// obsolete
G4EmDNAPhysics(G4int ver, const G4String& name);
virtual ~G4EmDNAPhysics();
virtual void ConstructParticle();
virtual void ConstructProcess();
private:
G4int verbose;
};
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
#endif
source/physics_lists/constructors/electromagnetic/include/G4EmLivermorePhysics.hh
+62
View File
@@ -0,0 +1,62 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4EmLivermorePhysics.hh 66704 2013-01-10 18:20:17Z gunter $
#ifndef G4EmLivermorePhysics_h
#define G4EmLivermorePhysics_h 1
#include "G4VPhysicsConstructor.hh"
#include "globals.hh"
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
class G4EmLivermorePhysics : public G4VPhysicsConstructor
{
public:
G4EmLivermorePhysics(G4int ver = 1);
// obsolete
G4EmLivermorePhysics(G4int ver, const G4String& name);
virtual ~G4EmLivermorePhysics();
virtual void ConstructParticle();
virtual void ConstructProcess();
private:
G4int verbose;
};
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
#endif
source/physics_lists/constructors/electromagnetic/include/G4EmLivermorePolarizedPhysics.hh
+61
View File
@@ -0,0 +1,61 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4EmLivermorePolarizedPhysics.hh 66704 2013-01-10 18:20:17Z gunter $
#ifndef G4EmLivermorePolarizedPhysics_h
#define G4EmLivermorePolarizedPhysics_h 1
#include "G4VPhysicsConstructor.hh"
#include "globals.hh"
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
class G4EmLivermorePolarizedPhysics : public G4VPhysicsConstructor
{
public:
G4EmLivermorePolarizedPhysics(G4int ver = 1);
// obsolete
G4EmLivermorePolarizedPhysics(G4int ver, const G4String&);
virtual ~G4EmLivermorePolarizedPhysics();
virtual void ConstructParticle();
virtual void ConstructProcess();
private:
G4int verbose;
};
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
#endif
source/physics_lists/constructors/electromagnetic/include/G4EmLowEPPhysics.hh
+61
View File
@@ -0,0 +1,61 @@
//
// ********************************************************************
// * 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. *
// ********************************************************************
//
#ifndef G4EmLowEPPhysics_h
#define G4EmLowEPPhysics_h 1
#include "G4VPhysicsConstructor.hh"
#include "globals.hh"
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
class G4EmLowEPPhysics : public G4VPhysicsConstructor
{
public:
G4EmLowEPPhysics(G4int ver = 1);
// obsolete
G4EmLowEPPhysics(G4int ver, const G4String& name);
virtual ~G4EmLowEPPhysics();
virtual void ConstructParticle();
virtual void ConstructProcess();
private:
G4int verbose;
};
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
#endif
source/physics_lists/constructors/electromagnetic/include/G4EmPenelopePhysics.hh
+62
View File
@@ -0,0 +1,62 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4EmPenelopePhysics.hh 66704 2013-01-10 18:20:17Z gunter $
#ifndef G4EmPenelopePhysics_h
#define G4EmPenelopePhysics_h 1
#include "G4VPhysicsConstructor.hh"
#include "globals.hh"
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
class G4EmPenelopePhysics : public G4VPhysicsConstructor
{
public:
G4EmPenelopePhysics(G4int ver = 1);
// obsolete
G4EmPenelopePhysics(G4int ver, const G4String& name);
virtual ~G4EmPenelopePhysics();
virtual void ConstructParticle();
virtual void ConstructProcess();
private:
G4int verbose;
};
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
#endif
source/physics_lists/constructors/electromagnetic/include/G4EmStandardPhysics.hh
+77
View File
@@ -0,0 +1,77 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
//
// $Id: G4EmStandardPhysics.hh 66704 2013-01-10 18:20:17Z gunter $
//
//---------------------------------------------------------------------------
//
// ClassName: G4EmStandardPhysics
//
// Author: V.Ivanchenko 09.11.2005
//
// Modified:
// 05.12.2005 V.Ivanchenko add controlled verbosity
// 23.11.2006 V.Ivanchenko remove mscStepLimit option and improve cout
//
//----------------------------------------------------------------------------
//
// This class provides construction of default EM standard physics
//
#ifndef G4EmStandardPhysics_h
#define G4EmStandardPhysics_h 1
#include "G4VPhysicsConstructor.hh"
#include "globals.hh"
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
class G4EmStandardPhysics : public G4VPhysicsConstructor
{
public:
G4EmStandardPhysics(G4int ver = 0);
// obsolete
G4EmStandardPhysics(G4int ver, const G4String& name);
virtual ~G4EmStandardPhysics();
virtual void ConstructParticle();
virtual void ConstructProcess();
private:
G4int verbose;
};
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
#endif
source/physics_lists/constructors/electromagnetic/include/G4EmStandardPhysics_option1.hh
+80
View File
@@ -0,0 +1,80 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4EmStandardPhysics_option1.hh 66704 2013-01-10 18:20:17Z gunter $
//
//---------------------------------------------------------------------------
//
// ClassName: G4EmStandardPhysics_option1
//
// Author: V.Ivanchenko 09.11.2005
//
// Modified:
// 05.12.2005 V.Ivanchenko add controlled verbosity
// 13.11.2006 V.Ivanchenko set default msc step limit false
// 15.05.2007 V.Ivanchenko rename to _option1
//
//----------------------------------------------------------------------------
//
// This class provides construction of EM standard physics using set of options
// allowing speed up simulation. Results for simulation in thin layers of
// materials with different density may be biased.
//
#ifndef G4EmStandardPhysics_option1_h
#define G4EmStandardPhysics_option1_h 1
#include "G4VPhysicsConstructor.hh"
#include "globals.hh"
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
class G4EmStandardPhysics_option1 : public G4VPhysicsConstructor
{
public:
G4EmStandardPhysics_option1(G4int ver = 1);
// obsolete
G4EmStandardPhysics_option1(G4int ver, const G4String& name);
virtual ~G4EmStandardPhysics_option1();
virtual void ConstructParticle();
virtual void ConstructProcess();
private:
G4int verbose;
};
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
#endif
source/physics_lists/constructors/electromagnetic/include/G4EmStandardPhysics_option2.hh
+81
View File
@@ -0,0 +1,81 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
//
// $Id: G4EmStandardPhysics_option2.hh 66704 2013-01-10 18:20:17Z gunter $
//
//---------------------------------------------------------------------------
//
// ClassName: G4EmStandardPhysics_option2
//
// Author: V.Ivanchenko 09.11.2005
//
// Modified:
// 05.12.2005 V.Ivanchenko add controlled verbosity
// 19.12.2005 V.Ivanchenko rename 71 -> 72
// 15.05.2007 V.Ivanchenko rename to _option2
//
//----------------------------------------------------------------------------
//
// This class provides construction of EM standard physics using set of options
// allowing to utilize sub-cutoff option for ionisation processes and higher
// production threshold than in default EM physics.
//
#ifndef G4EmStandardPhysics_option2_h
#define G4EmStandardPhysics_option2_h 1
#include "G4VPhysicsConstructor.hh"
#include "globals.hh"
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
class G4EmStandardPhysics_option2 : public G4VPhysicsConstructor
{
public:
G4EmStandardPhysics_option2(G4int ver = 1);
// obsolete
G4EmStandardPhysics_option2(G4int ver, const G4String& name);
virtual ~G4EmStandardPhysics_option2();
virtual void ConstructParticle();
virtual void ConstructProcess();
private:
G4int verbose;
};
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
#endif
source/physics_lists/constructors/electromagnetic/include/G4EmStandardPhysics_option3.hh
+77
View File
@@ -0,0 +1,77 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
//
// $Id: G4EmStandardPhysics_option3.hh 66704 2013-01-10 18:20:17Z gunter $
//
//---------------------------------------------------------------------------
//
// ClassName: G4EmStandardPhysics_option3
//
// Author: V.Ivanchenko 13.03.2008
//
// Modified:
//
//----------------------------------------------------------------------------
//
// This class provides construction of EM standard physics using set of
// the most adavced options allowing precise simulation at low
// and intermediate energies
//
#ifndef G4EmStandardPhysics_option3_h
#define G4EmStandardPhysics_option3_h 1
#include "G4VPhysicsConstructor.hh"
#include "globals.hh"
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
class G4EmStandardPhysics_option3 : public G4VPhysicsConstructor
{
public:
G4EmStandardPhysics_option3(G4int ver = 1);
// obsolete
G4EmStandardPhysics_option3(G4int ver, const G4String& name);
virtual ~G4EmStandardPhysics_option3();
virtual void ConstructParticle();
virtual void ConstructProcess();
private:
G4int verbose;
};
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
#endif
source/physics_lists/constructors/electromagnetic/include/G4EmStandardPhysics_option4.hh
+78
View File
@@ -0,0 +1,78 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
//
// $Id: G4EmStandardPhysics_option4.hh 66704 2013-01-10 18:20:17Z gunter $
//
//---------------------------------------------------------------------------
//
// ClassName: G4EmStandardPhysics_option4
//
// Author: V.Ivanchenko 28.09.2012
//
// Modified:
//
//----------------------------------------------------------------------------
//
// This class provides construction of EM physics using the best models
// of standard and low-energy packages and set of
// the most adavced options allowing precise simulation at low
// and intermediate energies
//
#ifndef G4EmStandardPhysics_option4_h
#define G4EmStandardPhysics_option4_h 1
#include "G4VPhysicsConstructor.hh"
#include "globals.hh"
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
class G4EmStandardPhysics_option4 : public G4VPhysicsConstructor
{
public:
G4EmStandardPhysics_option4(G4int ver = 1);
// obsolete
G4EmStandardPhysics_option4(G4int ver, const G4String& name);
virtual ~G4EmStandardPhysics_option4();
virtual void ConstructParticle();
virtual void ConstructProcess();
private:
G4int verbose;
};
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
#endif
source/physics_lists/constructors/electromagnetic/include/G4OpticalPhysics.hh
+188
View File
@@ -0,0 +1,188 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
//
//
//---------------------------------------------------------------------------
//
// ClassName: G4OpticalPhysics
//
// Author: P.Gumplinger 30.09.2009
//
// Modified: P.Gumplinger 29.09.2011
// (based on code from I. Hrivnacova)
//
//----------------------------------------------------------------------------
//
// This class provides construction of default optical physics
//
#ifndef G4OpticalPhysics_h
#define G4OpticalPhysics_h 1
#include "globals.hh"
#include "G4VPhysicsConstructor.hh"
#include "G4OpticalProcessIndex.hh"
#include "G4OpticalPhysicsMessenger.hh"
#include "G4OpWLS.hh"
#include "G4Scintillation.hh"
#include "G4Cerenkov.hh"
#include "G4OpAbsorption.hh"
#include "G4OpRayleigh.hh"
#include "G4OpMieHG.hh"
#include "G4OpBoundaryProcess.hh"
#include "G4OpticalSurface.hh"
#include <vector>
class G4VProcess;
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
class G4OpticalPhysics : public G4VPhysicsConstructor
{
public:
G4OpticalPhysics(G4int verbose = 0, const G4String& name = "Optical");
virtual ~G4OpticalPhysics();
protected:
// construct particle and physics
virtual void ConstructParticle();
virtual void ConstructProcess();
private:
/// Not implemented
G4OpticalPhysics(const G4OpticalPhysics& right);
/// Not implemented
G4OpticalPhysics& operator=(const G4OpticalPhysics& right);
public:
// configure G4OpticalPhysics builder
void Configure(G4OpticalProcessIndex, G4bool );
// get methods
virtual G4Scintillation* GetScintillationProcess()
{ return fScintillationProcess; }
virtual G4Cerenkov* GetCerenkovProcess()
{ return fCerenkovProcess; }
virtual G4OpWLS* GetOpWLSProcess() { return fOpWLSProcess; }
virtual G4OpAbsorption* GetOpAbsorptionProcess()
{ return fOpAbsorptionProcess; }
virtual G4OpRayleigh* GetOpRayleighProcess()
{ return fOpRayleighScatteringProcess; }
virtual G4OpMieHG* GetOpMieHGProcess()
{ return fOpMieHGScatteringProcess; }
virtual G4OpBoundaryProcess* GetOpBoundaryProcess()
{ return fOpBoundaryProcess; }
// set methods
void SetProcessVerbose(G4int , G4int );
void SetMaxNumPhotonsPerStep(G4int );
void SetMaxBetaChangePerStep(G4double );
void SetScintillationYieldFactor(G4double );
void SetScintillationExcitationRatio(G4double );
void SetWLSTimeProfile(G4String );
void SetScintillationByParticleType(G4bool );
void AddScintillationSaturation(G4EmSaturation* );
void SetTrackSecondariesFirst(G4OpticalProcessIndex, G4bool );
void SetFiniteRiseTime(G4bool );
private:
// methods
void PrintStatistics() const;
// data members
static G4ThreadLocal G4bool wasActivated;
// messenger
G4OpticalPhysicsMessenger* fMessenger;
// The vector of optical processes
std::vector<G4VProcess*> fProcesses;
// The vector of process configuration
std::vector<G4bool> fProcessUse;
// The vector of process verbose level
std::vector<G4int> fProcessVerbose;
// The vector of track secondaries options;
// the option to track secondaries before finishing their parent track
std::vector<G4bool> fProcessTrackSecondariesFirst;
G4Scintillation* fScintillationProcess;
G4Cerenkov* fCerenkovProcess;
G4OpWLS* fOpWLSProcess;
G4OpAbsorption* fOpAbsorptionProcess;
G4OpRayleigh* fOpRayleighScatteringProcess;
G4OpMieHG* fOpMieHGScatteringProcess;
G4OpBoundaryProcess* fOpBoundaryProcess;
/// max number of Cerenkov photons per step
G4int fMaxNumPhotons;
/// max change of beta per step
G4double fMaxBetaChange;
/// scintillation yield factor
G4double fYieldFactor;
/// scintillation excitation ratio
G4double fExcitationRatio;
/// the WLS process time profile
G4String fProfile;
/// option to set a finite rise-time; Note: the G4Scintillation
/// process expects the user to have set the constant material
/// property FAST/SLOWSCINTILLATIONRISETIME
G4bool fFiniteRiseTime;
/// option to allow for the light yield to be a function of
/// particle type and deposited energy in case of non-linear
/// light emission in scintillators
G4bool fScintillationByParticleType;
};
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
#endif // G4OpticalPhysics_h
source/physics_lists/constructors/electromagnetic/include/G4OpticalPhysicsMessenger.hh
+139
View File
@@ -0,0 +1,139 @@
//
// ********************************************************************
// * 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: G4OpticalPhysicsMessenger
//
// Author: P.Gumplinger 30.09.2009
//
// Modified: P.Gumplinger 29.09.2011
// (based on code from I. Hrivnacova)
//
//----------------------------------------------------------------------------
//
// This class defines commands for the optical physics
//
#ifndef G4OpticalPhysicsMessenger_h
#define G4OpticalPhysicsMessenger_h 1
#include "globals.hh"
#include "G4UImessenger.hh"
#include "G4OpticalProcessIndex.hh"
class G4VProcess;
class G4OpticalPhysics;
class G4UIdirectory;
class G4UIcmdWithABool;
class G4UIcmdWithADouble;
class G4UIcmdWithAString;
class G4UIcmdWithAnInteger;
// Messenger class that defines commands for the optical physics
//
// Implements commands:
// - /optics_engine/selectOpProcess processName
// - /optics_engine/setOpProcessUse true|false
// - /optics_engine/setOpProcessVerbose verboseLevel
// - /optics_engine/setCerenkovMaxPhotons maxNofPhotons
// - /optics_engine/setCerenkovMaxBetaChange maxBetaChange
// - /optics_engine/setScintillationYieldFactor yieldFactor
// - /optics_engine/setScintillationByParticleType true|false
// - /optics_engine/setOpticalSurfaceModel glisur|unified
// - /optics_engine/setWLSTimeProfile delta|exponential
// - /optics_engine/setTrackSecondariesFirst true|false
// - /optics_engine/setFiniteRiseTime true|false
class G4OpticalPhysicsMessenger: public G4UImessenger
{
public:
G4OpticalPhysicsMessenger(G4OpticalPhysics*);
virtual ~G4OpticalPhysicsMessenger();
// methods
virtual void SetNewValue(G4UIcommand*, G4String);
private:
/// Not implemented
G4OpticalPhysicsMessenger();
/// Not implemented
G4OpticalPhysicsMessenger(const G4OpticalPhysicsMessenger& right);
/// Not implemented
G4OpticalPhysicsMessenger& operator=(const G4OpticalPhysicsMessenger& right);
// data members
/// associated class
G4OpticalPhysics* fOpticalPhysics;
/// command directory
G4UIdirectory* fDir;
/// selected optical process
G4OpticalProcessIndex fSelectedProcessIndex;
/// selectOpProcess command
G4UIcmdWithAString* fSelectOpProcessCmd;
/// setProcessUse command
G4UIcmdWithABool* fSetOpProcessUseCmd;
/// setProcessVerbose command
G4UIcmdWithAnInteger* fSetOpProcessVerboseCmd;
/// setCerenkovMaxPhotons command
G4UIcmdWithAnInteger* fSetCerenkovMaxPhotonsCmd;
/// setCerenkovMaxBetaChange command
G4UIcmdWithADouble* fSetCerenkovMaxBetaChangeCmd;
/// setScintillationYieldFactor command
G4UIcmdWithADouble* fSetScintillationYieldFactorCmd;
/// setScintillationByParticleType command
G4UIcmdWithABool* fSetScintillationByParticleTypeCmd;
// /// setOpticalSurfaceModel command
// G4UIcmdWithAString* fSetOpticalSurfaceModelCmd;
/// setWLSTimeProfile command
G4UIcmdWithAString* fSetWLSTimeProfileCmd;
/// setTrackSecondariesFirst command
G4UIcmdWithABool* fSetTrackSecondariesFirstCmd;
/// setFiniteRiseTime command
G4UIcmdWithABool* fSetFiniteRiseTimeCmd;
};
#endif // G4OpticalPhysicsMessenger_h
source/physics_lists/constructors/electromagnetic/include/G4OpticalProcessIndex.hh
+84
View File
@@ -0,0 +1,84 @@
//
// ********************************************************************
// * 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: G4OpticalProcessIndex
//
// Author: P.Gumplinger 29.09.2011
// (based on code from I. Hrivnacova)
//
// Modified:
//
//----------------------------------------------------------------------------
//
// Enumeration for processes defined in G4OpticalPhysics
//
// The enumeration constants are used as the indices of the instatianted
// processes in the vector of processes; needed to configure G4OpticalPhysics
// (PhysicsList) according to selected process choices.
//
#ifndef G4OpticalProcessIndex_h
#define G4OpticalProcessIndex_h 1
#include "globals.hh"
enum G4OpticalProcessIndex {
kCerenkov, ///< Cerenkov process index
kScintillation, ///< Scintillation process index
kAbsorption, ///< Absorption process index
kRayleigh, ///< Rayleigh scattering process index
kMieHG, ///< Mie scattering process index
kBoundary, ///< Boundary process index
kWLS, ///< Wave Length Shifting process index
kNoProcess ///< Number of processes, no selected process
};
/// Return the name for a given optical process index
G4String G4OpticalProcessName(G4int );
////////////////////
// Inline methods
////////////////////
inline
G4String G4OpticalProcessName(G4int processNumber)
{
switch ( processNumber ) {
case kCerenkov: return "Cerenkov";
case kScintillation: return "Scintillation";
case kAbsorption: return "OpAbsorption";
case kRayleigh: return "OpRayleigh";
case kMieHG: return "OpMieHG";
case kBoundary: return "OpBoundary";
case kWLS: return "OpWLS";
default: return "NoProcess";
}
}
#endif // G4OpticalProcessIndex_h
source/physics_lists/constructors/electromagnetic/sources.cmake
+153
View File
@@ -0,0 +1,153 @@
#------------------------------------------------------------------------------
# sources.cmake
# Module : G4phys_ctor_em
# Package: Geant4.src.G4physicslists.G4physlist_ctors.G4physlist_ctor_em
#
# Sources description for a library.
# Lists the sources and headers of the code explicitely.
# Lists include paths needed.
# Lists the internal granular and global dependencies of the library.
# Source specific properties should be added at the end.
#
# Generated on : 10/01/2013
#
# $Id: sources.cmake 75585 2013-11-04 12:24:44Z gcosmo $
#
#------------------------------------------------------------------------------
# List external includes needed.
include_directories(${CLHEP_INCLUDE_DIRS})
# List internal includes needed.
include_directories(${CMAKE_SOURCE_DIR}/source/digits_hits/digits/include)
include_directories(${CMAKE_SOURCE_DIR}/source/digits_hits/hits/include)
include_directories(${CMAKE_SOURCE_DIR}/source/event/include)
include_directories(${CMAKE_SOURCE_DIR}/source/geometry/magneticfield/include)
include_directories(${CMAKE_SOURCE_DIR}/source/geometry/management/include)
include_directories(${CMAKE_SOURCE_DIR}/source/geometry/navigation/include)
include_directories(${CMAKE_SOURCE_DIR}/source/geometry/volumes/include)
include_directories(${CMAKE_SOURCE_DIR}/source/global/HEPGeometry/include)
include_directories(${CMAKE_SOURCE_DIR}/source/global/HEPRandom/include)
include_directories(${CMAKE_SOURCE_DIR}/source/global/management/include)
include_directories(${CMAKE_SOURCE_DIR}/source/intercoms/include)
include_directories(${CMAKE_SOURCE_DIR}/source/materials/include)
include_directories(${CMAKE_SOURCE_DIR}/source/particles/bosons/include)
include_directories(${CMAKE_SOURCE_DIR}/source/particles/hadrons/barions/include)
include_directories(${CMAKE_SOURCE_DIR}/source/particles/hadrons/ions/include)
include_directories(${CMAKE_SOURCE_DIR}/source/particles/hadrons/mesons/include)
include_directories(${CMAKE_SOURCE_DIR}/source/particles/leptons/include)
include_directories(${CMAKE_SOURCE_DIR}/source/particles/management/include)
include_directories(${CMAKE_SOURCE_DIR}/source/particles/shortlived/include)
include_directories(${CMAKE_SOURCE_DIR}/source/physics_lists/builders/include)
include_directories(${CMAKE_SOURCE_DIR}/source/physics_lists/constructors/factory/include)
include_directories(${CMAKE_SOURCE_DIR}/source/physics_lists/util/include)
include_directories(${CMAKE_SOURCE_DIR}/source/processes/cuts/include)
include_directories(${CMAKE_SOURCE_DIR}/source/processes/decay/include)
include_directories(${CMAKE_SOURCE_DIR}/source/processes/electromagnetic/dna/utils/include)
include_directories(${CMAKE_SOURCE_DIR}/source/processes/electromagnetic/dna/processes/include)
include_directories(${CMAKE_SOURCE_DIR}/source/processes/electromagnetic/dna/models/include)
include_directories(${CMAKE_SOURCE_DIR}/source/processes/electromagnetic/dna/management/include)
include_directories(${CMAKE_SOURCE_DIR}/source/processes/electromagnetic/dna/molecules/management/include)
include_directories(${CMAKE_SOURCE_DIR}/source/processes/electromagnetic/dna/molecules/types/include)
include_directories(${CMAKE_SOURCE_DIR}/source/processes/electromagnetic/highenergy/include)
include_directories(${CMAKE_SOURCE_DIR}/source/processes/electromagnetic/lowenergy/include)
include_directories(${CMAKE_SOURCE_DIR}/source/processes/electromagnetic/muons/include)
include_directories(${CMAKE_SOURCE_DIR}/source/processes/electromagnetic/standard/include)
include_directories(${CMAKE_SOURCE_DIR}/source/processes/electromagnetic/utils/include)
include_directories(${CMAKE_SOURCE_DIR}/source/processes/electromagnetic/xrays/include)
include_directories(${CMAKE_SOURCE_DIR}/source/processes/management/include)
include_directories(${CMAKE_SOURCE_DIR}/source/processes/optical/include)
include_directories(${CMAKE_SOURCE_DIR}/source/processes/transportation/include)
include_directories(${CMAKE_SOURCE_DIR}/source/run/include)
include_directories(${CMAKE_SOURCE_DIR}/source/track/include)
include_directories(${CMAKE_SOURCE_DIR}/source/tracking/include)
#
# Define the Geant4 Module.
#
include(Geant4MacroDefineModule)
GEANT4_DEFINE_MODULE(NAME G4phys_ctor_em
HEADERS
G4EmDNAPhysics.hh
G4EmLivermorePhysics.hh
G4EmLivermorePolarizedPhysics.hh
G4EmLowEPPhysics.hh
G4EmPenelopePhysics.hh
G4EmStandardPhysics.hh
G4EmStandardPhysics_option1.hh
G4EmStandardPhysics_option2.hh
G4EmStandardPhysics_option3.hh
G4EmStandardPhysics_option4.hh
G4OpticalPhysics.hh
G4OpticalPhysicsMessenger.hh
G4OpticalProcessIndex.hh
SOURCES
G4EmDNAPhysics.cc
G4EmLivermorePhysics.cc
G4EmLivermorePolarizedPhysics.cc
G4EmLowEPPhysics.cc
G4EmPenelopePhysics.cc
G4EmStandardPhysics.cc
G4EmStandardPhysics_option1.cc
G4EmStandardPhysics_option2.cc
G4EmStandardPhysics_option3.cc
G4EmStandardPhysics_option4.cc
G4OpticalPhysics.cc
G4OpticalPhysicsMessenger.cc
GRANULAR_DEPENDENCIES
G4baryons
G4bosons
G4cuts
G4decay
G4digits
G4emdna-utils
G4emdna-processes
G4emdna-molman
G4emdna-moltypes
G4emdna-models
G4emhighenergy
G4emlowenergy
G4emstandard
G4emutils
G4event
G4geometrymng
G4globman
G4hits
G4intercoms
G4ions
G4leptons
G4magneticfield
G4materials
G4mesons
G4muons
G4navigation
G4optical
G4partman
G4phys_builders
G4phys_ctor_factory
G4physlist_util
G4procman
G4run
G4shortlived
G4track
G4tracking
G4transportation
G4volumes
G4xrays
GLOBAL_DEPENDENCIES
G4digits_hits
G4event
G4geometry
G4global
G4intercoms
G4materials
G4particles
G4processes
G4run
G4track
G4tracking
LINK_LIBRARIES
)
# List any source specific properties here
source/physics_lists/constructors/electromagnetic/src/G4EmDNAPhysics.cc
+277
View File
@@ -0,0 +1,277 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4EmDNAPhysics.cc 73244 2013-08-22 13:12:17Z gcosmo $
#include "G4EmDNAPhysics.hh"
#include "G4SystemOfUnits.hh"
#include "G4DNAGenericIonsManager.hh"
// *** Processes and models for Geant4-DNA
#include "G4DNAElastic.hh"
#include "G4DNAChampionElasticModel.hh"
#include "G4DNAScreenedRutherfordElasticModel.hh"
#include "G4DNAExcitation.hh"
#include "G4DNAAttachment.hh"
#include "G4DNAVibExcitation.hh"
#include "G4DNAIonisation.hh"
#include "G4DNAChargeDecrease.hh"
#include "G4DNAChargeIncrease.hh"
// particles
#include "G4Electron.hh"
#include "G4Proton.hh"
#include "G4GenericIon.hh"
// Warning : the following is needed in order to use EM Physics builders
// e+
#include "G4Positron.hh"
#include "G4eMultipleScattering.hh"
#include "G4eIonisation.hh"
#include "G4eBremsstrahlung.hh"
#include "G4eplusAnnihilation.hh"
// gamma
#include "G4Gamma.hh"
#include "G4PhotoElectricEffect.hh"
#include "G4LivermorePhotoElectricModel.hh"
#include "G4ComptonScattering.hh"
#include "G4LivermoreComptonModel.hh"
#include "G4GammaConversion.hh"
#include "G4LivermoreGammaConversionModel.hh"
#include "G4RayleighScattering.hh"
#include "G4LivermoreRayleighModel.hh"
// end of warning
#include "G4LossTableManager.hh"
#include "G4UAtomicDeexcitation.hh"
#include "G4PhysicsListHelper.hh"
#include "G4BuilderType.hh"
// factory
#include "G4PhysicsConstructorFactory.hh"
//
G4_DECLARE_PHYSCONSTR_FACTORY(G4EmDNAPhysics);
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
G4EmDNAPhysics::G4EmDNAPhysics(G4int ver)
: G4VPhysicsConstructor("G4EmDNAPhysics"), verbose(ver)
{
SetPhysicsType(bElectromagnetic);
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
G4EmDNAPhysics::G4EmDNAPhysics(G4int ver, const G4String&)
: G4VPhysicsConstructor("G4EmDNAPhysics"), verbose(ver)
{
SetPhysicsType(bElectromagnetic);
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
G4EmDNAPhysics::~G4EmDNAPhysics()
{}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void G4EmDNAPhysics::ConstructParticle()
{
// bosons
G4Gamma::Gamma();
// leptons
G4Electron::Electron();
G4Positron::Positron();
// baryons
G4Proton::Proton();
G4GenericIon::GenericIonDefinition();
G4DNAGenericIonsManager * genericIonsManager;
genericIonsManager=G4DNAGenericIonsManager::Instance();
genericIonsManager->GetIon("alpha++");
genericIonsManager->GetIon("alpha+");
genericIonsManager->GetIon("helium");
genericIonsManager->GetIon("hydrogen");
genericIonsManager->GetIon("carbon");
genericIonsManager->GetIon("nitrogen");
genericIonsManager->GetIon("oxygen");
genericIonsManager->GetIon("iron");
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void G4EmDNAPhysics::ConstructProcess()
{
if(verbose > 1) {
G4cout << "### " << GetPhysicsName() << " Construct Processes " << G4endl;
}
G4PhysicsListHelper* ph = G4PhysicsListHelper::GetPhysicsListHelper();
aParticleIterator->reset();
while( (*aParticleIterator)() )
{
G4ParticleDefinition* particle = aParticleIterator->value();
G4String particleName = particle->GetParticleName();
if (particleName == "e-") {
// *** Elastic scattering (two alternative models available) ***
G4DNAElastic* theDNAElasticProcess = new G4DNAElastic("e-_G4DNAElastic");
theDNAElasticProcess->SetEmModel(new G4DNAChampionElasticModel());
// or alternative model
//theDNAElasticProcess->SetEmModel(new G4DNAScreenedRutherfordElasticModel());
ph->RegisterProcess(theDNAElasticProcess, particle);
// *** Excitation ***
ph->RegisterProcess(new G4DNAExcitation("e-_G4DNAExcitation"), particle);
// *** Ionisation ***
ph->RegisterProcess(new G4DNAIonisation("e-_G4DNAIonisation"), particle);
// *** Vibrational excitation ***
ph->RegisterProcess(new G4DNAVibExcitation("e-_G4DNAVibExcitation"), particle);
// *** Attachment ***
ph->RegisterProcess(new G4DNAAttachment("e-_G4DNAAttachment"), particle);
} else if ( particleName == "proton" ) {
ph->RegisterProcess(new G4DNAExcitation("proton_G4DNAExcitation"), particle);
ph->RegisterProcess(new G4DNAIonisation("proton_G4DNAIonisation"), particle);
ph->RegisterProcess(new G4DNAChargeDecrease("proton_G4DNAChargeDecrease"), particle);
} else if ( particleName == "hydrogen" ) {
ph->RegisterProcess(new G4DNAExcitation("hydrogen_G4DNAExcitation"), particle);
ph->RegisterProcess(new G4DNAIonisation("hydrogen_G4DNAIonisation"), particle);
ph->RegisterProcess(new G4DNAChargeIncrease("hydrogen_G4DNAChargeIncrease"), particle);
} else if ( particleName == "alpha" ) {
ph->RegisterProcess(new G4DNAExcitation("alpha_G4DNAExcitation"), particle);
ph->RegisterProcess(new G4DNAIonisation("alpha_G4DNAIonisation"), particle);
ph->RegisterProcess(new G4DNAChargeDecrease("alpha_G4DNAChargeDecrease"), particle);
} else if ( particleName == "alpha+" ) {
ph->RegisterProcess(new G4DNAExcitation("alpha+_G4DNAExcitation"), particle);
ph->RegisterProcess(new G4DNAIonisation("alpha+_G4DNAIonisation"), particle);
ph->RegisterProcess(new G4DNAChargeDecrease("alpha+_G4DNAChargeDecrease"), particle);
ph->RegisterProcess(new G4DNAChargeIncrease("alpha+_G4DNAChargeIncrease"), particle);
} else if ( particleName == "helium" ) {
ph->RegisterProcess(new G4DNAExcitation("helium_G4DNAExcitation"), particle);
ph->RegisterProcess(new G4DNAIonisation("helium_G4DNAIonisation"), particle);
ph->RegisterProcess(new G4DNAChargeIncrease("helium_G4DNAChargeIncrease"), particle);
// Extension to HZE proposed by Z. Francis
} else if ( particleName == "carbon" ) {
ph->RegisterProcess(new G4DNAIonisation("carbon_G4DNAIonisation"), particle);
} else if ( particleName == "nitrogen" ) {
ph->RegisterProcess(new G4DNAIonisation("nitrogen_G4DNAIonisation"), particle);
} else if ( particleName == "oxygen" ) {
ph->RegisterProcess(new G4DNAIonisation("oxygen_G4DNAIonisation"), particle);
} else if ( particleName == "iron" ) {
ph->RegisterProcess(new G4DNAIonisation("iron_G4DNAIonisation"), particle);
}
// Warning : the following particles and processes are needed by EM Physics builders
// They are taken from the default Livermore Physics list
// These particles are currently not handled by Geant4-DNA
// e+
else if (particleName == "e+") {
// Identical to G4EmStandardPhysics_option3
G4eMultipleScattering* msc = new G4eMultipleScattering();
msc->SetStepLimitType(fUseDistanceToBoundary);
G4eIonisation* eIoni = new G4eIonisation();
eIoni->SetStepFunction(0.2, 100*um);
ph->RegisterProcess(msc, particle);
ph->RegisterProcess(eIoni, particle);
ph->RegisterProcess(new G4eBremsstrahlung(), particle);
ph->RegisterProcess(new G4eplusAnnihilation(), particle);
} else if (particleName == "gamma") {
G4double LivermoreHighEnergyLimit = GeV;
G4PhotoElectricEffect* thePhotoElectricEffect = new G4PhotoElectricEffect();
G4LivermorePhotoElectricModel* theLivermorePhotoElectricModel =
new G4LivermorePhotoElectricModel();
theLivermorePhotoElectricModel->SetHighEnergyLimit(LivermoreHighEnergyLimit);
thePhotoElectricEffect->AddEmModel(0, theLivermorePhotoElectricModel);
ph->RegisterProcess(thePhotoElectricEffect, particle);
G4ComptonScattering* theComptonScattering = new G4ComptonScattering();
G4LivermoreComptonModel* theLivermoreComptonModel =
new G4LivermoreComptonModel();
theLivermoreComptonModel->SetHighEnergyLimit(LivermoreHighEnergyLimit);
theComptonScattering->AddEmModel(0, theLivermoreComptonModel);
ph->RegisterProcess(theComptonScattering, particle);
G4GammaConversion* theGammaConversion = new G4GammaConversion();
G4LivermoreGammaConversionModel* theLivermoreGammaConversionModel =
new G4LivermoreGammaConversionModel();
theLivermoreGammaConversionModel->SetHighEnergyLimit(LivermoreHighEnergyLimit);
theGammaConversion->AddEmModel(0, theLivermoreGammaConversionModel);
ph->RegisterProcess(theGammaConversion, particle);
G4RayleighScattering* theRayleigh = new G4RayleighScattering();
G4LivermoreRayleighModel* theRayleighModel = new G4LivermoreRayleighModel();
theRayleighModel->SetHighEnergyLimit(LivermoreHighEnergyLimit);
theRayleigh->AddEmModel(0, theRayleighModel);
ph->RegisterProcess(theRayleigh, particle);
}
// Warning : end of particles and processes are needed by EM Physics builders
}
// Deexcitation
//
G4VAtomDeexcitation* de = new G4UAtomicDeexcitation();
G4LossTableManager::Instance()->SetAtomDeexcitation(de);
de->SetFluo(true);
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
source/physics_lists/constructors/electromagnetic/src/G4EmLivermorePhysics.cc
+470
View File
@@ -0,0 +1,470 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4EmLivermorePhysics.cc 68750 2013-04-05 10:19:04Z gcosmo $
#include "G4EmLivermorePhysics.hh"
#include "G4ParticleDefinition.hh"
#include "G4SystemOfUnits.hh"
// *** Processes and models
// gamma
#include "G4PhotoElectricEffect.hh"
#include "G4LivermorePhotoElectricModel.hh"
#include "G4ComptonScattering.hh"
#include "G4LivermoreComptonModel.hh"
#include "G4GammaConversion.hh"
#include "G4LivermoreGammaConversionModel.hh"
#include "G4RayleighScattering.hh"
#include "G4LivermoreRayleighModel.hh"
// e+-
#include "G4eMultipleScattering.hh"
#include "G4UniversalFluctuation.hh"
#include "G4eIonisation.hh"
#include "G4LivermoreIonisationModel.hh"
#include "G4eBremsstrahlung.hh"
#include "G4LivermoreBremsstrahlungModel.hh"
#include "G4Generator2BS.hh"
// e+
#include "G4eplusAnnihilation.hh"
// mu+-
#include "G4MuMultipleScattering.hh"
#include "G4MuIonisation.hh"
#include "G4MuBremsstrahlung.hh"
#include "G4MuPairProduction.hh"
#include "G4MuBremsstrahlungModel.hh"
#include "G4MuPairProductionModel.hh"
#include "G4hBremsstrahlungModel.hh"
#include "G4hPairProductionModel.hh"
// hadrons
#include "G4hMultipleScattering.hh"
#include "G4MscStepLimitType.hh"
#include "G4hBremsstrahlung.hh"
#include "G4hPairProduction.hh"
#include "G4hIonisation.hh"
#include "G4ionIonisation.hh"
#include "G4alphaIonisation.hh"
#include "G4IonParametrisedLossModel.hh"
#include "G4NuclearStopping.hh"
// msc models
#include "G4UrbanMscModel.hh"
#include "G4WentzelVIModel.hh"
#include "G4GoudsmitSaundersonMscModel.hh"
#include "G4CoulombScattering.hh"
#include "G4eCoulombScatteringModel.hh"
// interfaces
#include "G4LossTableManager.hh"
#include "G4EmProcessOptions.hh"
#include "G4UAtomicDeexcitation.hh"
// particles
#include "G4Gamma.hh"
#include "G4Electron.hh"
#include "G4Positron.hh"
#include "G4MuonPlus.hh"
#include "G4MuonMinus.hh"
#include "G4PionPlus.hh"
#include "G4PionMinus.hh"
#include "G4KaonPlus.hh"
#include "G4KaonMinus.hh"
#include "G4Proton.hh"
#include "G4AntiProton.hh"
#include "G4Deuteron.hh"
#include "G4Triton.hh"
#include "G4He3.hh"
#include "G4Alpha.hh"
#include "G4GenericIon.hh"
//
#include "G4PhysicsListHelper.hh"
#include "G4BuilderType.hh"
// factory
#include "G4PhysicsConstructorFactory.hh"
//
G4_DECLARE_PHYSCONSTR_FACTORY(G4EmLivermorePhysics);
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
G4EmLivermorePhysics::G4EmLivermorePhysics(G4int ver)
: G4VPhysicsConstructor("G4EmLivermorePhysics"), verbose(ver)
{
G4LossTableManager::Instance();
SetPhysicsType(bElectromagnetic);
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
G4EmLivermorePhysics::G4EmLivermorePhysics(G4int ver, const G4String&)
: G4VPhysicsConstructor("G4EmLivermorePhysics"), verbose(ver)
{
G4LossTableManager::Instance();
SetPhysicsType(bElectromagnetic);
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
G4EmLivermorePhysics::~G4EmLivermorePhysics()
{}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void G4EmLivermorePhysics::ConstructParticle()
{
// gamma
G4Gamma::Gamma();
// leptons
G4Electron::Electron();
G4Positron::Positron();
G4MuonPlus::MuonPlus();
G4MuonMinus::MuonMinus();
// mesons
G4PionPlus::PionPlusDefinition();
G4PionMinus::PionMinusDefinition();
G4KaonPlus::KaonPlusDefinition();
G4KaonMinus::KaonMinusDefinition();
// baryons
G4Proton::Proton();
G4AntiProton::AntiProton();
// ions
G4Deuteron::Deuteron();
G4Triton::Triton();
G4He3::He3();
G4Alpha::Alpha();
G4GenericIon::GenericIonDefinition();
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void G4EmLivermorePhysics::ConstructProcess()
{
if(verbose > 1) {
G4cout << "### " << GetPhysicsName() << " Construct Processes " << G4endl;
}
G4PhysicsListHelper* ph = G4PhysicsListHelper::GetPhysicsListHelper();
// muon & hadron bremsstrahlung and pair production
G4MuBremsstrahlung* mub = new G4MuBremsstrahlung();
G4MuPairProduction* mup = new G4MuPairProduction();
G4hBremsstrahlung* pib = new G4hBremsstrahlung();
G4hPairProduction* pip = new G4hPairProduction();
G4hBremsstrahlung* kb = new G4hBremsstrahlung();
G4hPairProduction* kp = new G4hPairProduction();
G4hBremsstrahlung* pb = new G4hBremsstrahlung();
G4hPairProduction* pp = new G4hPairProduction();
// muon & hadron multiple scattering
G4MuMultipleScattering* mumsc = new G4MuMultipleScattering();
mumsc->AddEmModel(0, new G4WentzelVIModel());
G4hMultipleScattering* pimsc = new G4hMultipleScattering();
pimsc->AddEmModel(0, new G4WentzelVIModel());
G4hMultipleScattering* kmsc = new G4hMultipleScattering();
kmsc->AddEmModel(0, new G4WentzelVIModel());
G4hMultipleScattering* pmsc = new G4hMultipleScattering();
pmsc->AddEmModel(0, new G4WentzelVIModel());
G4hMultipleScattering* hmsc = new G4hMultipleScattering("ionmsc");
// high energy limit for e+- scattering models
G4double highEnergyLimit = 100*MeV;
// nuclear stopping
G4NuclearStopping* ionnuc = new G4NuclearStopping();
G4NuclearStopping* pnuc = new G4NuclearStopping();
// Add Livermore EM Processes
aParticleIterator->reset();
while( (*aParticleIterator)() ){
G4ParticleDefinition* particle = aParticleIterator->value();
G4String particleName = particle->GetParticleName();
//Applicability range for Livermore models
//for higher energies, the Standard models are used
G4double LivermoreHighEnergyLimit = GeV;
if (particleName == "gamma") {
// Photoelectric effect - define low-energy model
G4PhotoElectricEffect* thePhotoElectricEffect = new G4PhotoElectricEffect();
G4LivermorePhotoElectricModel* theLivermorePhotoElectricModel =
new G4LivermorePhotoElectricModel();
thePhotoElectricEffect->SetEmModel(theLivermorePhotoElectricModel);
ph->RegisterProcess(thePhotoElectricEffect, particle);
// Compton scattering - define low-energy model
G4ComptonScattering* theComptonScattering = new G4ComptonScattering();
G4LivermoreComptonModel* theLivermoreComptonModel =
new G4LivermoreComptonModel();
theLivermoreComptonModel->SetHighEnergyLimit(LivermoreHighEnergyLimit);
theComptonScattering->SetEmModel(theLivermoreComptonModel, 1);
ph->RegisterProcess(theComptonScattering, particle);
// gamma conversion - define low-energy model
G4GammaConversion* theGammaConversion = new G4GammaConversion();
G4VEmModel* theLivermoreGammaConversionModel =
new G4LivermoreGammaConversionModel();
theGammaConversion->SetEmModel(theLivermoreGammaConversionModel, 1);
ph->RegisterProcess(theGammaConversion, particle);
// default Rayleigh scattering is Livermore
G4RayleighScattering* theRayleigh = new G4RayleighScattering();
ph->RegisterProcess(theRayleigh, particle);
} else if (particleName == "e-") {
// multiple scattering
G4eMultipleScattering* msc = new G4eMultipleScattering;
msc->SetStepLimitType(fUseDistanceToBoundary);
G4UrbanMscModel* msc1 = new G4UrbanMscModel();
G4WentzelVIModel* msc2 = new G4WentzelVIModel();
msc1->SetHighEnergyLimit(highEnergyLimit);
msc2->SetLowEnergyLimit(highEnergyLimit);
msc->AddEmModel(0, msc1);
msc->AddEmModel(0, msc2);
G4eCoulombScatteringModel* ssm = new G4eCoulombScatteringModel();
G4CoulombScattering* ss = new G4CoulombScattering();
ss->SetEmModel(ssm, 1);
ss->SetMinKinEnergy(highEnergyLimit);
ssm->SetLowEnergyLimit(highEnergyLimit);
ssm->SetActivationLowEnergyLimit(highEnergyLimit);
ph->RegisterProcess(msc, particle);
ph->RegisterProcess(ss, particle);
// Ionisation - Livermore should be used only for low energies
G4eIonisation* eIoni = new G4eIonisation();
G4LivermoreIonisationModel* theIoniLivermore = new
G4LivermoreIonisationModel();
theIoniLivermore->SetHighEnergyLimit(0.1*MeV);
eIoni->AddEmModel(0, theIoniLivermore, new G4UniversalFluctuation() );
eIoni->SetStepFunction(0.2, 100*um); //
ph->RegisterProcess(eIoni, particle);
// Bremsstrahlung
G4eBremsstrahlung* eBrem = new G4eBremsstrahlung();
G4VEmModel* theBremLivermore = new G4LivermoreBremsstrahlungModel();
theBremLivermore->SetHighEnergyLimit(1*GeV);
//theBremLivermore->SetAngularDistribution(new G4Generator2BS());
eBrem->SetEmModel(theBremLivermore,1);
ph->RegisterProcess(eBrem, particle);
} else if (particleName == "e+") {
// Identical to G4EmStandardPhysics_option3
// multiple scattering
G4eMultipleScattering* msc = new G4eMultipleScattering;
msc->SetStepLimitType(fUseDistanceToBoundary);
G4UrbanMscModel* msc1 = new G4UrbanMscModel();
G4WentzelVIModel* msc2 = new G4WentzelVIModel();
msc1->SetHighEnergyLimit(highEnergyLimit);
msc2->SetLowEnergyLimit(highEnergyLimit);
msc->AddEmModel(0, msc1);
msc->AddEmModel(0, msc2);
G4eCoulombScatteringModel* ssm = new G4eCoulombScatteringModel();
G4CoulombScattering* ss = new G4CoulombScattering();
ss->SetEmModel(ssm, 1);
ss->SetMinKinEnergy(highEnergyLimit);
ssm->SetLowEnergyLimit(highEnergyLimit);
ssm->SetActivationLowEnergyLimit(highEnergyLimit);
G4eIonisation* eIoni = new G4eIonisation();
eIoni->SetStepFunction(0.2, 100*um);
ph->RegisterProcess(msc, particle);
ph->RegisterProcess(eIoni, particle);
ph->RegisterProcess(new G4eBremsstrahlung(), particle);
ph->RegisterProcess(new G4eplusAnnihilation(), particle);
ph->RegisterProcess(ss, particle);
} else if (particleName == "mu+" ||
particleName == "mu-" ) {
G4MuIonisation* muIoni = new G4MuIonisation();
muIoni->SetStepFunction(0.2, 50*um);
ph->RegisterProcess(mumsc, particle);
ph->RegisterProcess(muIoni, particle);
ph->RegisterProcess(mub, particle);
ph->RegisterProcess(mup, particle);
ph->RegisterProcess(new G4CoulombScattering(), particle);
} else if (particleName == "alpha" ||
particleName == "He3" ) {
// Identical to G4EmStandardPhysics_option3
G4hMultipleScattering* msc = new G4hMultipleScattering();
G4ionIonisation* ionIoni = new G4ionIonisation();
ionIoni->SetStepFunction(0.1, 10*um);
ph->RegisterProcess(msc, particle);
ph->RegisterProcess(ionIoni, particle);
ph->RegisterProcess(ionnuc, particle);
} else if (particleName == "GenericIon") {
// Identical to G4EmStandardPhysics_option3
G4ionIonisation* ionIoni = new G4ionIonisation();
ionIoni->SetEmModel(new G4IonParametrisedLossModel());
ionIoni->SetStepFunction(0.1, 1*um);
ph->RegisterProcess(hmsc, particle);
ph->RegisterProcess(ionIoni, particle);
ph->RegisterProcess(ionnuc, particle);
} else if (particleName == "pi+" ||
particleName == "pi-" ) {
//G4hMultipleScattering* pimsc = new G4hMultipleScattering();
G4hIonisation* hIoni = new G4hIonisation();
hIoni->SetStepFunction(0.2, 50*um);
ph->RegisterProcess(pimsc, particle);
ph->RegisterProcess(hIoni, particle);
ph->RegisterProcess(pib, particle);
ph->RegisterProcess(pip, particle);
} else if (particleName == "kaon+" ||
particleName == "kaon-" ) {
//G4hMultipleScattering* kmsc = new G4hMultipleScattering();
G4hIonisation* hIoni = new G4hIonisation();
hIoni->SetStepFunction(0.2, 50*um);
ph->RegisterProcess(kmsc, particle);
ph->RegisterProcess(hIoni, particle);
ph->RegisterProcess(kb, particle);
ph->RegisterProcess(kp, particle);
} else if (particleName == "proton" ||
particleName == "anti_proton") {
//G4hMultipleScattering* pmsc = new G4hMultipleScattering();
G4hIonisation* hIoni = new G4hIonisation();
hIoni->SetStepFunction(0.2, 50*um);
ph->RegisterProcess(pmsc, particle);
ph->RegisterProcess(hIoni, particle);
ph->RegisterProcess(pb, particle);
ph->RegisterProcess(pp, particle);
ph->RegisterProcess(pnuc, particle);
} else if (particleName == "B+" ||
particleName == "B-" ||
particleName == "D+" ||
particleName == "D-" ||
particleName == "Ds+" ||
particleName == "Ds-" ||
particleName == "anti_He3" ||
particleName == "anti_alpha" ||
particleName == "anti_deuteron" ||
particleName == "anti_lambda_c+" ||
particleName == "anti_omega-" ||
particleName == "anti_sigma_c+" ||
particleName == "anti_sigma_c++" ||
particleName == "anti_sigma+" ||
particleName == "anti_sigma-" ||
particleName == "anti_triton" ||
particleName == "anti_xi_c+" ||
particleName == "anti_xi-" ||
particleName == "deuteron" ||
particleName == "lambda_c+" ||
particleName == "omega-" ||
particleName == "sigma_c+" ||
particleName == "sigma_c++" ||
particleName == "sigma+" ||
particleName == "sigma-" ||
particleName == "tau+" ||
particleName == "tau-" ||
particleName == "triton" ||
particleName == "xi_c+" ||
particleName == "xi-" ) {
// Identical to G4EmStandardPhysics_option3
ph->RegisterProcess(hmsc, particle);
ph->RegisterProcess(new G4hIonisation(), particle);
ph->RegisterProcess(pnuc, particle);
}
}
// Em options
//
G4EmProcessOptions opt;
opt.SetVerbose(verbose);
// Multiple Coulomb scattering
//
opt.SetPolarAngleLimit(CLHEP::pi);
// Physics tables
//
opt.SetMinEnergy(100*eV);
opt.SetMaxEnergy(10*TeV);
opt.SetDEDXBinning(220);
opt.SetLambdaBinning(220);
// Nuclear stopping
pnuc->SetMaxKinEnergy(MeV);
// Ionization
//
//opt.SetSubCutoff(true);
// Deexcitation
//
G4VAtomDeexcitation* de = new G4UAtomicDeexcitation();
G4LossTableManager::Instance()->SetAtomDeexcitation(de);
de->SetFluo(true);
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
source/physics_lists/constructors/electromagnetic/src/G4EmLivermorePolarizedPhysics.cc
+460
View File
@@ -0,0 +1,460 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4EmLivermorePolarizedPhysics.cc 68750 2013-04-05 10:19:04Z gcosmo $
#include "G4EmLivermorePolarizedPhysics.hh"
#include "G4ParticleDefinition.hh"
#include "G4SystemOfUnits.hh"
// *** Processes and models
// gamma
#include "G4PhotoElectricEffect.hh"
#include "G4LivermorePolarizedPhotoElectricModel.hh"
#include "G4ComptonScattering.hh"
#include "G4LivermorePolarizedComptonModel.hh"
#include "G4GammaConversion.hh"
#include "G4LivermorePolarizedGammaConversionModel.hh"
#include "G4RayleighScattering.hh"
#include "G4LivermorePolarizedRayleighModel.hh"
// e+-
#include "G4eMultipleScattering.hh"
#include "G4UniversalFluctuation.hh"
#include "G4eIonisation.hh"
#include "G4LivermoreIonisationModel.hh"
#include "G4eBremsstrahlung.hh"
#include "G4LivermoreBremsstrahlungModel.hh"
// e+
#include "G4eplusAnnihilation.hh"
// mu+-
#include "G4MuMultipleScattering.hh"
#include "G4MuIonisation.hh"
#include "G4MuBremsstrahlung.hh"
#include "G4MuPairProduction.hh"
#include "G4MuBremsstrahlungModel.hh"
#include "G4MuPairProductionModel.hh"
#include "G4hBremsstrahlungModel.hh"
#include "G4hPairProductionModel.hh"
// hadrons
#include "G4hMultipleScattering.hh"
#include "G4MscStepLimitType.hh"
#include "G4hBremsstrahlung.hh"
#include "G4hPairProduction.hh"
#include "G4hIonisation.hh"
#include "G4ionIonisation.hh"
#include "G4alphaIonisation.hh"
#include "G4IonParametrisedLossModel.hh"
#include "G4NuclearStopping.hh"
// msc models
#include "G4UrbanMscModel.hh"
#include "G4WentzelVIModel.hh"
#include "G4GoudsmitSaundersonMscModel.hh"
#include "G4CoulombScattering.hh"
#include "G4eCoulombScatteringModel.hh"
// interfaces
#include "G4LossTableManager.hh"
#include "G4EmProcessOptions.hh"
#include "G4UAtomicDeexcitation.hh"
// particles
#include "G4Gamma.hh"
#include "G4Electron.hh"
#include "G4Positron.hh"
#include "G4MuonPlus.hh"
#include "G4MuonMinus.hh"
#include "G4PionPlus.hh"
#include "G4PionMinus.hh"
#include "G4KaonPlus.hh"
#include "G4KaonMinus.hh"
#include "G4Proton.hh"
#include "G4AntiProton.hh"
#include "G4Deuteron.hh"
#include "G4Triton.hh"
#include "G4He3.hh"
#include "G4Alpha.hh"
#include "G4GenericIon.hh"
//
#include "G4PhysicsListHelper.hh"
#include "G4BuilderType.hh"
// factory
#include "G4PhysicsConstructorFactory.hh"
//
G4_DECLARE_PHYSCONSTR_FACTORY(G4EmLivermorePolarizedPhysics);
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
G4EmLivermorePolarizedPhysics::G4EmLivermorePolarizedPhysics(G4int ver)
: G4VPhysicsConstructor("G4EmLivermorePolarizedPhysics"), verbose(ver)
{
G4LossTableManager::Instance();
SetPhysicsType(bElectromagnetic);
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
G4EmLivermorePolarizedPhysics::G4EmLivermorePolarizedPhysics(G4int ver, const G4String&)
: G4VPhysicsConstructor("G4EmLivermorePolarizedPhysics"), verbose(ver)
{
G4LossTableManager::Instance();
SetPhysicsType(bElectromagnetic);
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
G4EmLivermorePolarizedPhysics::~G4EmLivermorePolarizedPhysics()
{}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void G4EmLivermorePolarizedPhysics::ConstructParticle()
{
// gamma
G4Gamma::Gamma();
// leptons
G4Electron::Electron();
G4Positron::Positron();
G4MuonPlus::MuonPlus();
G4MuonMinus::MuonMinus();
// mesons
G4PionPlus::PionPlusDefinition();
G4PionMinus::PionMinusDefinition();
G4KaonPlus::KaonPlusDefinition();
G4KaonMinus::KaonMinusDefinition();
// baryons
G4Proton::Proton();
G4AntiProton::AntiProton();
// ions
G4Deuteron::Deuteron();
G4Triton::Triton();
G4He3::He3();
G4Alpha::Alpha();
G4GenericIon::GenericIonDefinition();
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void G4EmLivermorePolarizedPhysics::ConstructProcess()
{
if(verbose > 1) {
G4cout << "### " << GetPhysicsName() << " Construct Processes " << G4endl;
}
G4PhysicsListHelper* ph = G4PhysicsListHelper::GetPhysicsListHelper();
// muon & hadron bremsstrahlung and pair production
G4MuBremsstrahlung* mub = new G4MuBremsstrahlung();
G4MuPairProduction* mup = new G4MuPairProduction();
G4hBremsstrahlung* pib = new G4hBremsstrahlung();
G4hPairProduction* pip = new G4hPairProduction();
G4hBremsstrahlung* kb = new G4hBremsstrahlung();
G4hPairProduction* kp = new G4hPairProduction();
G4hBremsstrahlung* pb = new G4hBremsstrahlung();
G4hPairProduction* pp = new G4hPairProduction();
// muon & hadron multiple scattering
G4MuMultipleScattering* mumsc = new G4MuMultipleScattering();
mumsc->AddEmModel(0, new G4WentzelVIModel());
G4MuMultipleScattering* pimsc = new G4MuMultipleScattering();
pimsc->AddEmModel(0, new G4WentzelVIModel());
G4MuMultipleScattering* kmsc = new G4MuMultipleScattering();
kmsc->AddEmModel(0, new G4WentzelVIModel());
G4MuMultipleScattering* pmsc = new G4MuMultipleScattering();
pmsc->AddEmModel(0, new G4WentzelVIModel());
G4hMultipleScattering* hmsc = new G4hMultipleScattering("ionmsc");
// high energy limit for e+- scattering models
G4double highEnergyLimit = 100*MeV;
// nuclear stopping
G4NuclearStopping* ionnuc = new G4NuclearStopping();
G4NuclearStopping* pnuc = new G4NuclearStopping();
// Add Livermore EM Processes
aParticleIterator->reset();
while( (*aParticleIterator)() ){
G4ParticleDefinition* particle = aParticleIterator->value();
G4String particleName = particle->GetParticleName();
//Applicability range for Livermore models
//for higher energies, the Standard models are used
G4double LivermoreHighEnergyLimit = GeV;
if (particleName == "gamma") {
G4PhotoElectricEffect* thePhotoElectricEffect = new G4PhotoElectricEffect();
G4LivermorePolarizedPhotoElectricModel* theLivermorePhotoElectricModel = new G4LivermorePolarizedPhotoElectricModel();
theLivermorePhotoElectricModel->SetHighEnergyLimit(LivermoreHighEnergyLimit);
thePhotoElectricEffect->AddEmModel(0, theLivermorePhotoElectricModel);
ph->RegisterProcess(thePhotoElectricEffect, particle);
G4ComptonScattering* theComptonScattering = new G4ComptonScattering();
G4LivermorePolarizedComptonModel* theLivermoreComptonModel = new G4LivermorePolarizedComptonModel();
theLivermoreComptonModel->SetHighEnergyLimit(LivermoreHighEnergyLimit);
theComptonScattering->AddEmModel(0, theLivermoreComptonModel);
ph->RegisterProcess(theComptonScattering, particle);
G4GammaConversion* theGammaConversion = new G4GammaConversion();
G4LivermorePolarizedGammaConversionModel* theLivermoreGammaConversionModel = new G4LivermorePolarizedGammaConversionModel();
theLivermoreGammaConversionModel->SetHighEnergyLimit(LivermoreHighEnergyLimit);
theGammaConversion->AddEmModel(0, theLivermoreGammaConversionModel);
ph->RegisterProcess(theGammaConversion, particle);
G4RayleighScattering* theRayleigh = new G4RayleighScattering();
G4LivermorePolarizedRayleighModel* theRayleighModel = new G4LivermorePolarizedRayleighModel();
theRayleighModel->SetHighEnergyLimit(LivermoreHighEnergyLimit);
theRayleigh->AddEmModel(0, theRayleighModel);
ph->RegisterProcess(theRayleigh, particle);
} else if (particleName == "e-") {
// multiple scattering
G4eMultipleScattering* msc = new G4eMultipleScattering;
msc->SetStepLimitType(fUseDistanceToBoundary);
G4UrbanMscModel* msc1 = new G4UrbanMscModel();
G4WentzelVIModel* msc2 = new G4WentzelVIModel();
msc1->SetHighEnergyLimit(highEnergyLimit);
msc2->SetLowEnergyLimit(highEnergyLimit);
msc->AddEmModel(0, msc1);
msc->AddEmModel(0, msc2);
G4eCoulombScatteringModel* ssm = new G4eCoulombScatteringModel();
G4CoulombScattering* ss = new G4CoulombScattering();
ss->SetEmModel(ssm, 1);
ss->SetMinKinEnergy(highEnergyLimit);
ssm->SetLowEnergyLimit(highEnergyLimit);
ssm->SetActivationLowEnergyLimit(highEnergyLimit);
ph->RegisterProcess(msc, particle);
ph->RegisterProcess(ss, particle);
// Ionisation
G4eIonisation* eIoni = new G4eIonisation();
G4LivermoreIonisationModel* theIoniLivermore = new
G4LivermoreIonisationModel();
theIoniLivermore->SetHighEnergyLimit(0.1*MeV);
eIoni->AddEmModel(0, theIoniLivermore, new G4UniversalFluctuation() );
eIoni->SetStepFunction(0.2, 100*um); //
ph->RegisterProcess(eIoni, particle);
// Bremsstrahlung from standard
G4eBremsstrahlung* eBrem = new G4eBremsstrahlung();
ph->RegisterProcess(eBrem, particle);
} else if (particleName == "e+") {
// multiple scattering
G4eMultipleScattering* msc = new G4eMultipleScattering;
msc->SetStepLimitType(fUseDistanceToBoundary);
G4UrbanMscModel* msc1 = new G4UrbanMscModel();
G4WentzelVIModel* msc2 = new G4WentzelVIModel();
msc1->SetHighEnergyLimit(highEnergyLimit);
msc2->SetLowEnergyLimit(highEnergyLimit);
msc->AddEmModel(0, msc1);
msc->AddEmModel(0, msc2);
G4eCoulombScatteringModel* ssm = new G4eCoulombScatteringModel();
G4CoulombScattering* ss = new G4CoulombScattering();
ss->SetEmModel(ssm, 1);
ss->SetMinKinEnergy(highEnergyLimit);
ssm->SetLowEnergyLimit(highEnergyLimit);
ssm->SetActivationLowEnergyLimit(highEnergyLimit);
// Ionisation
G4eIonisation* eIoni = new G4eIonisation();
eIoni->SetStepFunction(0.2, 100*um);
ph->RegisterProcess(msc, particle);
ph->RegisterProcess(eIoni, particle);
ph->RegisterProcess(new G4eBremsstrahlung(), particle);
ph->RegisterProcess(new G4eplusAnnihilation(), particle);
ph->RegisterProcess(ss, particle);
} else if (particleName == "mu+" ||
particleName == "mu-" ) {
G4MuIonisation* muIoni = new G4MuIonisation();
muIoni->SetStepFunction(0.2, 50*um);
ph->RegisterProcess(mumsc, particle);
ph->RegisterProcess(muIoni, particle);
ph->RegisterProcess(mub, particle);
ph->RegisterProcess(mup, particle);
ph->RegisterProcess(new G4CoulombScattering(), particle);
} else if (particleName == "alpha" ||
particleName == "He3" ) {
// Identical to G4EmStandardPhysics_option3
G4hMultipleScattering* msc = new G4hMultipleScattering();
G4ionIonisation* ionIoni = new G4ionIonisation();
ionIoni->SetStepFunction(0.1, 10*um);
ph->RegisterProcess(msc, particle);
ph->RegisterProcess(ionIoni, particle);
ph->RegisterProcess(ionnuc, particle);
} else if (particleName == "GenericIon") {
// Identical to G4EmStandardPhysics_option3
G4ionIonisation* ionIoni = new G4ionIonisation();
ionIoni->SetEmModel(new G4IonParametrisedLossModel());
ionIoni->SetStepFunction(0.1, 1*um);
ph->RegisterProcess(hmsc, particle);
ph->RegisterProcess(ionIoni, particle);
ph->RegisterProcess(ionnuc, particle);
} else if (particleName == "pi+" ||
particleName == "pi-" ) {
//G4hMultipleScattering* pimsc = new G4hMultipleScattering();
G4hIonisation* hIoni = new G4hIonisation();
hIoni->SetStepFunction(0.2, 50*um);
ph->RegisterProcess(pimsc, particle);
ph->RegisterProcess(hIoni, particle);
ph->RegisterProcess(pib, particle);
ph->RegisterProcess(pip, particle);
} else if (particleName == "kaon+" ||
particleName == "kaon-" ) {
//G4hMultipleScattering* kmsc = new G4hMultipleScattering();
G4hIonisation* hIoni = new G4hIonisation();
hIoni->SetStepFunction(0.2, 50*um);
ph->RegisterProcess(kmsc, particle);
ph->RegisterProcess(hIoni, particle);
ph->RegisterProcess(kb, particle);
ph->RegisterProcess(kp, particle);
} else if (particleName == "proton" ||
particleName == "anti_proton") {
//G4hMultipleScattering* pmsc = new G4hMultipleScattering();
G4hIonisation* hIoni = new G4hIonisation();
hIoni->SetStepFunction(0.2, 50*um);
ph->RegisterProcess(pmsc, particle);
ph->RegisterProcess(hIoni, particle);
ph->RegisterProcess(pb, particle);
ph->RegisterProcess(pp, particle);
ph->RegisterProcess(pnuc, particle);
} else if (particleName == "B+" ||
particleName == "B-" ||
particleName == "D+" ||
particleName == "D-" ||
particleName == "Ds+" ||
particleName == "Ds-" ||
particleName == "anti_He3" ||
particleName == "anti_alpha" ||
particleName == "anti_deuteron" ||
particleName == "anti_lambda_c+" ||
particleName == "anti_omega-" ||
particleName == "anti_sigma_c+" ||
particleName == "anti_sigma_c++" ||
particleName == "anti_sigma+" ||
particleName == "anti_sigma-" ||
particleName == "anti_triton" ||
particleName == "anti_xi_c+" ||
particleName == "anti_xi-" ||
particleName == "deuteron" ||
particleName == "lambda_c+" ||
particleName == "omega-" ||
particleName == "sigma_c+" ||
particleName == "sigma_c++" ||
particleName == "sigma+" ||
particleName == "sigma-" ||
particleName == "tau+" ||
particleName == "tau-" ||
particleName == "triton" ||
particleName == "xi_c+" ||
particleName == "xi-" ) {
// Identical to G4EmStandardPhysics_option3
ph->RegisterProcess(hmsc, particle);
ph->RegisterProcess(new G4hIonisation(), particle);
ph->RegisterProcess(pnuc, particle);
}
}
// Em options
//
G4EmProcessOptions opt;
opt.SetVerbose(verbose);
// Multiple Coulomb scattering
//
opt.SetPolarAngleLimit(CLHEP::pi);
// Physics tables
//
opt.SetMinEnergy(100*eV);
opt.SetMaxEnergy(10*TeV);
opt.SetDEDXBinning(220);
opt.SetLambdaBinning(220);
// Nuclear stopping
pnuc->SetMaxKinEnergy(MeV);
// Ionization
//
//opt.SetSubCutoff(true);
// Deexcitation
//
G4VAtomDeexcitation* de = new G4UAtomicDeexcitation();
G4LossTableManager::Instance()->SetAtomDeexcitation(de);
de->SetFluo(true);
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
source/physics_lists/constructors/electromagnetic/src/G4EmLowEPPhysics.cc
+425
View File
@@ -0,0 +1,425 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4EmLowEPPhysics.cc 73153 2013-08-20 07:17:42Z gcosmo $
#include "G4EmLowEPPhysics.hh"
#include "G4ParticleDefinition.hh"
#include "G4SystemOfUnits.hh"
// *** Processes and models
// gamma
#include "G4PhotoElectricEffect.hh"
#include "G4LivermorePhotoElectricModel.hh"
#include "G4ComptonScattering.hh"
#include "G4LowEPComptonModel.hh"
#include "G4GammaConversion.hh"
#include "G4LivermoreGammaConversionModel.hh"
#include "G4RayleighScattering.hh"
#include "G4LivermoreRayleighModel.hh"
// e+-
#include "G4eMultipleScattering.hh"
#include "G4UniversalFluctuation.hh"
#include "G4eIonisation.hh"
#include "G4LivermoreIonisationModel.hh"
#include "G4eBremsstrahlung.hh"
#include "G4LivermoreBremsstrahlungModel.hh"
#include "G4Generator2BS.hh"
// e+
#include "G4eplusAnnihilation.hh"
// mu+-
#include "G4MuMultipleScattering.hh"
#include "G4MuIonisation.hh"
#include "G4MuBremsstrahlung.hh"
#include "G4MuPairProduction.hh"
#include "G4MuBremsstrahlungModel.hh"
#include "G4MuPairProductionModel.hh"
#include "G4hBremsstrahlungModel.hh"
#include "G4hPairProductionModel.hh"
// hadrons
#include "G4hMultipleScattering.hh"
#include "G4MscStepLimitType.hh"
#include "G4hBremsstrahlung.hh"
#include "G4hPairProduction.hh"
#include "G4hIonisation.hh"
#include "G4ionIonisation.hh"
#include "G4alphaIonisation.hh"
#include "G4IonParametrisedLossModel.hh"
#include "G4NuclearStopping.hh"
// msc models
#include "G4UrbanMscModel.hh"
#include "G4WentzelVIModel.hh"
#include "G4GoudsmitSaundersonMscModel.hh"
#include "G4CoulombScattering.hh"
// interfaces
#include "G4LossTableManager.hh"
#include "G4EmProcessOptions.hh"
#include "G4UAtomicDeexcitation.hh"
// particles
#include "G4Gamma.hh"
#include "G4Electron.hh"
#include "G4Positron.hh"
#include "G4MuonPlus.hh"
#include "G4MuonMinus.hh"
#include "G4PionPlus.hh"
#include "G4PionMinus.hh"
#include "G4KaonPlus.hh"
#include "G4KaonMinus.hh"
#include "G4Proton.hh"
#include "G4AntiProton.hh"
#include "G4Deuteron.hh"
#include "G4Triton.hh"
#include "G4He3.hh"
#include "G4Alpha.hh"
#include "G4GenericIon.hh"
//
#include "G4PhysicsListHelper.hh"
#include "G4BuilderType.hh"
// factory
#include "G4PhysicsConstructorFactory.hh"
//
G4_DECLARE_PHYSCONSTR_FACTORY(G4EmLowEPPhysics);
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
G4EmLowEPPhysics::G4EmLowEPPhysics(G4int ver)
: G4VPhysicsConstructor("G4EmLowEPPhysics"), verbose(ver)
{
G4LossTableManager::Instance();
SetPhysicsType(bElectromagnetic);
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
G4EmLowEPPhysics::G4EmLowEPPhysics(G4int ver, const G4String&)
: G4VPhysicsConstructor("G4EmLowEPPhysics"), verbose(ver)
{
G4LossTableManager::Instance();
SetPhysicsType(bElectromagnetic);
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
G4EmLowEPPhysics::~G4EmLowEPPhysics()
{}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void G4EmLowEPPhysics::ConstructParticle()
{
// gamma
G4Gamma::Gamma();
// leptons
G4Electron::Electron();
G4Positron::Positron();
G4MuonPlus::MuonPlus();
G4MuonMinus::MuonMinus();
// mesons
G4PionPlus::PionPlusDefinition();
G4PionMinus::PionMinusDefinition();
G4KaonPlus::KaonPlusDefinition();
G4KaonMinus::KaonMinusDefinition();
// baryons
G4Proton::Proton();
G4AntiProton::AntiProton();
// ions
G4Deuteron::Deuteron();
G4Triton::Triton();
G4He3::He3();
G4Alpha::Alpha();
G4GenericIon::GenericIonDefinition();
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void G4EmLowEPPhysics::ConstructProcess()
{
G4PhysicsListHelper* ph = G4PhysicsListHelper::GetPhysicsListHelper();
// muon & hadron bremsstrahlung and pair production
G4MuBremsstrahlung* mub = new G4MuBremsstrahlung();
G4MuPairProduction* mup = new G4MuPairProduction();
G4hBremsstrahlung* pib = new G4hBremsstrahlung();
G4hPairProduction* pip = new G4hPairProduction();
G4hBremsstrahlung* kb = new G4hBremsstrahlung();
G4hPairProduction* kp = new G4hPairProduction();
G4hBremsstrahlung* pb = new G4hBremsstrahlung();
G4hPairProduction* pp = new G4hPairProduction();
// muon & hadron multiple scattering
G4MuMultipleScattering* mumsc = new G4MuMultipleScattering();
mumsc->AddEmModel(0, new G4WentzelVIModel());
G4hMultipleScattering* hmsc = new G4hMultipleScattering();
G4hMultipleScattering* pmsc = new G4hMultipleScattering();
G4hMultipleScattering* pimsc = new G4hMultipleScattering();
G4hMultipleScattering* kmsc = new G4hMultipleScattering();
// Add Livermore EM Processes
aParticleIterator->reset();
while( (*aParticleIterator)() ){
G4ParticleDefinition* particle = aParticleIterator->value();
G4String particleName = particle->GetParticleName();
if(verbose > 1)
G4cout << "### " << GetPhysicsName() << " instantiates for "
<< particleName << G4endl;
//Applicability range for Livermore models
//for higher energies, the Standard models are used
G4double LivermoreHighEnergyLimit = GeV;
if (particleName == "gamma") {
G4PhotoElectricEffect* thePhotoElectricEffect = new G4PhotoElectricEffect();
G4LivermorePhotoElectricModel* theLivermorePhotoElectricModel =
new G4LivermorePhotoElectricModel();
theLivermorePhotoElectricModel->SetHighEnergyLimit(LivermoreHighEnergyLimit);
thePhotoElectricEffect->AddEmModel(0, theLivermorePhotoElectricModel);
ph->RegisterProcess(thePhotoElectricEffect, particle);
G4ComptonScattering* theComptonScattering = new G4ComptonScattering();
G4LowEPComptonModel* theLowEPComptonModel =
new G4LowEPComptonModel();
theLowEPComptonModel->SetHighEnergyLimit(LivermoreHighEnergyLimit);
theComptonScattering->AddEmModel(0, theLowEPComptonModel);
ph->RegisterProcess(theComptonScattering, particle);
G4GammaConversion* theGammaConversion = new G4GammaConversion();
G4LivermoreGammaConversionModel* theLivermoreGammaConversionModel =
new G4LivermoreGammaConversionModel();
theLivermoreGammaConversionModel->SetHighEnergyLimit(LivermoreHighEnergyLimit);
theGammaConversion->AddEmModel(0, theLivermoreGammaConversionModel);
ph->RegisterProcess(theGammaConversion, particle);
G4RayleighScattering* theRayleigh = new G4RayleighScattering();
G4LivermoreRayleighModel* theRayleighModel = new G4LivermoreRayleighModel();
theRayleighModel->SetHighEnergyLimit(LivermoreHighEnergyLimit);
theRayleigh->AddEmModel(0, theRayleighModel);
ph->RegisterProcess(theRayleigh, particle);
} else if (particleName == "e-") {
G4eMultipleScattering* msc = new G4eMultipleScattering();
//msc->AddEmModel(0, new G4UrbanMscModel());
//msc->AddEmModel(0, new G4GoudsmitSaundersonMscModel());
msc->SetStepLimitType(fUseDistanceToBoundary);
ph->RegisterProcess(msc, particle);
// Ionisation
G4eIonisation* eIoni = new G4eIonisation();
G4LivermoreIonisationModel* theIoniLivermore = new
G4LivermoreIonisationModel();
theIoniLivermore->SetHighEnergyLimit(0.1*MeV);
eIoni->AddEmModel(0, theIoniLivermore, new G4UniversalFluctuation() );
eIoni->SetStepFunction(0.2, 100*um); //
ph->RegisterProcess(eIoni, particle);
// Bremsstrahlung
G4eBremsstrahlung* eBrem = new G4eBremsstrahlung();
G4LivermoreBremsstrahlungModel* theBremLivermore = new
G4LivermoreBremsstrahlungModel();
theBremLivermore->SetHighEnergyLimit(25*MeV);
theBremLivermore->SetAngularDistribution(new G4Generator2BS());
eBrem->AddEmModel(0, theBremLivermore);
ph->RegisterProcess(eBrem, particle);
} else if (particleName == "e+") {
// Identical to G4EmStandardPhysics_option3
G4eMultipleScattering* msc = new G4eMultipleScattering();
// msc->AddEmModel(0, new G4UrbanMscModel());
//msc->AddEmModel(0, new G4GoudsmitSaundersonMscModel());
msc->SetStepLimitType(fUseDistanceToBoundary);
G4eIonisation* eIoni = new G4eIonisation();
eIoni->SetStepFunction(0.2, 100*um);
ph->RegisterProcess(msc, particle);
ph->RegisterProcess(eIoni, particle);
ph->RegisterProcess(new G4eBremsstrahlung(), particle);
ph->RegisterProcess(new G4eplusAnnihilation(), particle);
} else if (particleName == "mu+" ||
particleName == "mu-" ) {
G4MuIonisation* muIoni = new G4MuIonisation();
muIoni->SetStepFunction(0.2, 50*um);
ph->RegisterProcess(mumsc, particle);
ph->RegisterProcess(muIoni, particle);
ph->RegisterProcess(mub, particle);
ph->RegisterProcess(mup, particle);
ph->RegisterProcess(new G4CoulombScattering(), particle);
} else if (particleName == "alpha" ||
particleName == "He3" ) {
// Identical to G4EmStandardPhysics_option3
G4ionIonisation* ionIoni = new G4ionIonisation();
ionIoni->SetStepFunction(0.1, 10*um);
ph->RegisterProcess(hmsc, particle);
ph->RegisterProcess(ionIoni, particle);
ph->RegisterProcess(new G4NuclearStopping(), particle);
} else if (particleName == "GenericIon") {
// Identical to G4EmStandardPhysics_option3
G4ionIonisation* ionIoni = new G4ionIonisation();
ionIoni->SetEmModel(new G4IonParametrisedLossModel());
ionIoni->SetStepFunction(0.1, 1*um);
ph->RegisterProcess(hmsc, particle);
ph->RegisterProcess(ionIoni, particle);
ph->RegisterProcess(new G4NuclearStopping(), particle);
} else if (particleName == "pi+" ||
particleName == "pi-" ) {
G4hIonisation* hIoni = new G4hIonisation();
hIoni->SetStepFunction(0.2, 50*um);
ph->RegisterProcess(pimsc, particle);
ph->RegisterProcess(hIoni, particle);
ph->RegisterProcess(pib, particle);
ph->RegisterProcess(pip, particle);
} else if (particleName == "kaon+" ||
particleName == "kaon-" ) {
G4hIonisation* hIoni = new G4hIonisation();
hIoni->SetStepFunction(0.2, 50*um);
ph->RegisterProcess(kmsc, particle);
ph->RegisterProcess(hIoni, particle);
ph->RegisterProcess(kb, particle);
ph->RegisterProcess(kp, particle);
} else if (particleName == "proton" ||
particleName == "anti_proton") {
G4hIonisation* hIoni = new G4hIonisation();
hIoni->SetStepFunction(0.2, 50*um);
ph->RegisterProcess(pmsc, particle);
ph->RegisterProcess(hIoni, particle);
ph->RegisterProcess(pb, particle);
ph->RegisterProcess(pp, particle);
} else if (particleName == "B+" ||
particleName == "B-" ||
particleName == "D+" ||
particleName == "D-" ||
particleName == "Ds+" ||
particleName == "Ds-" ||
particleName == "anti_He3" ||
particleName == "anti_alpha" ||
particleName == "anti_deuteron" ||
particleName == "anti_lambda_c+" ||
particleName == "anti_omega-" ||
particleName == "anti_sigma_c+" ||
particleName == "anti_sigma_c++" ||
particleName == "anti_sigma+" ||
particleName == "anti_sigma-" ||
particleName == "anti_triton" ||
particleName == "anti_xi_c+" ||
particleName == "anti_xi-" ||
particleName == "deuteron" ||
particleName == "lambda_c+" ||
particleName == "omega-" ||
particleName == "sigma_c+" ||
particleName == "sigma_c++" ||
particleName == "sigma+" ||
particleName == "sigma-" ||
particleName == "tau+" ||
particleName == "tau-" ||
particleName == "triton" ||
particleName == "xi_c+" ||
particleName == "xi-" ) {
// Identical to G4EmStandardPhysics_option3
ph->RegisterProcess(hmsc, particle);
ph->RegisterProcess(new G4hIonisation(), particle);
}
}
// Em options
//
G4EmProcessOptions opt;
opt.SetVerbose(verbose);
// Multiple Coulomb scattering
//
opt.SetPolarAngleLimit(CLHEP::pi);
// Physics tables
//
opt.SetMinEnergy(100*eV);
opt.SetMaxEnergy(10*TeV);
opt.SetDEDXBinning(220);
opt.SetLambdaBinning(220);
// Ionization
//
//opt.SetSubCutoff(true);
// Deexcitation
//
G4VAtomDeexcitation* de = new G4UAtomicDeexcitation();
G4LossTableManager::Instance()->SetAtomDeexcitation(de);
de->SetFluo(true);
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
source/physics_lists/constructors/electromagnetic/src/G4EmPenelopePhysics.cc
+499
View File
@@ -0,0 +1,499 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4EmPenelopePhysics.cc 68750 2013-04-05 10:19:04Z gcosmo $
#include "G4EmPenelopePhysics.hh"
#include "G4ParticleDefinition.hh"
#include "G4SystemOfUnits.hh"
// *** Processes and models
// gamma
#include "G4PhotoElectricEffect.hh"
#include "G4PenelopePhotoElectricModel.hh"
#include "G4ComptonScattering.hh"
#include "G4PenelopeComptonModel.hh"
#include "G4GammaConversion.hh"
#include "G4PenelopeGammaConversionModel.hh"
#include "G4RayleighScattering.hh"
#include "G4PenelopeRayleighModel.hh"
// e- and e+
#include "G4eMultipleScattering.hh"
#include "G4UniversalFluctuation.hh"
#include "G4eIonisation.hh"
#include "G4PenelopeIonisationModel.hh"
#include "G4eBremsstrahlung.hh"
#include "G4PenelopeBremsstrahlungModel.hh"
// e+ only
#include "G4eplusAnnihilation.hh"
#include "G4PenelopeAnnihilationModel.hh"
// mu
#include "G4MuMultipleScattering.hh"
#include "G4MuIonisation.hh"
#include "G4MuBremsstrahlung.hh"
#include "G4MuPairProduction.hh"
#include "G4MuBremsstrahlungModel.hh"
#include "G4MuPairProductionModel.hh"
#include "G4hBremsstrahlungModel.hh"
#include "G4hPairProductionModel.hh"
// hadrons
#include "G4hMultipleScattering.hh"
#include "G4MscStepLimitType.hh"
#include "G4hBremsstrahlung.hh"
#include "G4hPairProduction.hh"
#include "G4hIonisation.hh"
#include "G4ionIonisation.hh"
#include "G4alphaIonisation.hh"
#include "G4IonParametrisedLossModel.hh"
#include "G4NuclearStopping.hh"
// msc models
#include "G4UrbanMscModel.hh"
#include "G4GoudsmitSaundersonMscModel.hh"
#include "G4WentzelVIModel.hh"
#include "G4CoulombScattering.hh"
#include "G4eCoulombScatteringModel.hh"
//
#include "G4LossTableManager.hh"
#include "G4VAtomDeexcitation.hh"
#include "G4UAtomicDeexcitation.hh"
#include "G4EmProcessOptions.hh"
// particles
#include "G4Gamma.hh"
#include "G4Electron.hh"
#include "G4Positron.hh"
#include "G4MuonPlus.hh"
#include "G4MuonMinus.hh"
#include "G4PionPlus.hh"
#include "G4PionMinus.hh"
#include "G4KaonPlus.hh"
#include "G4KaonMinus.hh"
#include "G4Proton.hh"
#include "G4AntiProton.hh"
#include "G4Deuteron.hh"
#include "G4Triton.hh"
#include "G4He3.hh"
#include "G4Alpha.hh"
#include "G4GenericIon.hh"
//
#include "G4PhysicsListHelper.hh"
#include "G4BuilderType.hh"
// factory
#include "G4PhysicsConstructorFactory.hh"
//
G4_DECLARE_PHYSCONSTR_FACTORY(G4EmPenelopePhysics);
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
G4EmPenelopePhysics::G4EmPenelopePhysics(G4int ver)
: G4VPhysicsConstructor("G4EmPenelopePhysics"), verbose(ver)
{
G4LossTableManager::Instance();
SetPhysicsType(bElectromagnetic);
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
G4EmPenelopePhysics::G4EmPenelopePhysics(G4int ver, const G4String&)
: G4VPhysicsConstructor("G4EmPenelopePhysics"), verbose(ver)
{
G4LossTableManager::Instance();
SetPhysicsType(bElectromagnetic);
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
G4EmPenelopePhysics::~G4EmPenelopePhysics()
{}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void G4EmPenelopePhysics::ConstructParticle()
{
// gamma
G4Gamma::Gamma();
// leptons
G4Electron::Electron();
G4Positron::Positron();
G4MuonPlus::MuonPlus();
G4MuonMinus::MuonMinus();
// mesons
G4PionPlus::PionPlusDefinition();
G4PionMinus::PionMinusDefinition();
G4KaonPlus::KaonPlusDefinition();
G4KaonMinus::KaonMinusDefinition();
// baryons
G4Proton::Proton();
G4AntiProton::AntiProton();
// ions
G4Deuteron::Deuteron();
G4Triton::Triton();
G4He3::He3();
G4Alpha::Alpha();
G4GenericIon::GenericIonDefinition();
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void G4EmPenelopePhysics::ConstructProcess()
{
if(verbose > 1) {
G4cout << "### " << GetPhysicsName() << " Construct Processes " << G4endl;
}
G4PhysicsListHelper* ph = G4PhysicsListHelper::GetPhysicsListHelper();
// muon & hadron bremsstrahlung and pair production
G4MuBremsstrahlung* mub = new G4MuBremsstrahlung();
G4MuPairProduction* mup = new G4MuPairProduction();
G4hBremsstrahlung* pib = new G4hBremsstrahlung();
G4hPairProduction* pip = new G4hPairProduction();
G4hBremsstrahlung* kb = new G4hBremsstrahlung();
G4hPairProduction* kp = new G4hPairProduction();
G4hBremsstrahlung* pb = new G4hBremsstrahlung();
G4hPairProduction* pp = new G4hPairProduction();
// muon & hadron multiple scattering
G4MuMultipleScattering* mumsc = new G4MuMultipleScattering();
mumsc->AddEmModel(0, new G4WentzelVIModel());
G4MuMultipleScattering* pimsc = new G4MuMultipleScattering();
pimsc->AddEmModel(0, new G4WentzelVIModel());
G4MuMultipleScattering* kmsc = new G4MuMultipleScattering();
kmsc->AddEmModel(0, new G4WentzelVIModel());
G4MuMultipleScattering* pmsc = new G4MuMultipleScattering();
pmsc->AddEmModel(0, new G4WentzelVIModel());
G4hMultipleScattering* hmsc = new G4hMultipleScattering("ionmsc");
// high energy limit for e+- scattering models
G4double highEnergyLimit = 100*MeV;
// nuclear stopping
G4NuclearStopping* ionnuc = new G4NuclearStopping();
G4NuclearStopping* pnuc = new G4NuclearStopping();
// Add Penelope EM Processes
aParticleIterator->reset();
while( (*aParticleIterator)() ){
G4ParticleDefinition* particle = aParticleIterator->value();
G4String particleName = particle->GetParticleName();
//Applicability range for Penelope models
//for higher energies, the Standard models are used
G4double PenelopeHighEnergyLimit = 1.0*GeV;
if (particleName == "gamma") {
//Photo-electric effect
G4PhotoElectricEffect* thePhotoElectricEffect = new G4PhotoElectricEffect();
G4PenelopePhotoElectricModel* thePEPenelopeModel = new
G4PenelopePhotoElectricModel();
thePEPenelopeModel->SetHighEnergyLimit(PenelopeHighEnergyLimit);
thePhotoElectricEffect->SetEmModel(thePEPenelopeModel, 1);
ph->RegisterProcess(thePhotoElectricEffect, particle);
//Compton scattering
G4ComptonScattering* theComptonScattering = new G4ComptonScattering();
G4PenelopeComptonModel* theComptonPenelopeModel =
new G4PenelopeComptonModel();
theComptonPenelopeModel->SetHighEnergyLimit(PenelopeHighEnergyLimit);
theComptonScattering->SetEmModel(theComptonPenelopeModel, 1);
ph->RegisterProcess(theComptonScattering, particle);
//Gamma conversion
G4GammaConversion* theGammaConversion = new G4GammaConversion();
G4PenelopeGammaConversionModel* theGCPenelopeModel =
new G4PenelopeGammaConversionModel();
theGammaConversion->SetEmModel(theGCPenelopeModel,1);
ph->RegisterProcess(theGammaConversion, particle);
//Rayleigh scattering
G4RayleighScattering* theRayleigh = new G4RayleighScattering();
G4PenelopeRayleighModel* theRayleighPenelopeModel =
new G4PenelopeRayleighModel();
//theRayleighPenelopeModel->SetHighEnergyLimit(PenelopeHighEnergyLimit);
theRayleigh->SetEmModel(theRayleighPenelopeModel, 1);
ph->RegisterProcess(theRayleigh, particle);
} else if (particleName == "e-") {
// multiple scattering
G4eMultipleScattering* msc = new G4eMultipleScattering;
msc->SetStepLimitType(fUseDistanceToBoundary);
G4UrbanMscModel* msc1 = new G4UrbanMscModel();
G4WentzelVIModel* msc2 = new G4WentzelVIModel();
msc1->SetHighEnergyLimit(highEnergyLimit);
msc2->SetLowEnergyLimit(highEnergyLimit);
msc->AddEmModel(0, msc1);
msc->AddEmModel(0, msc2);
G4eCoulombScatteringModel* ssm = new G4eCoulombScatteringModel();
G4CoulombScattering* ss = new G4CoulombScattering();
ss->SetEmModel(ssm, 1);
ss->SetMinKinEnergy(highEnergyLimit);
ssm->SetLowEnergyLimit(highEnergyLimit);
ssm->SetActivationLowEnergyLimit(highEnergyLimit);
ph->RegisterProcess(msc, particle);
ph->RegisterProcess(ss, particle);
//Ionisation
G4eIonisation* eIoni = new G4eIonisation();
G4PenelopeIonisationModel* theIoniPenelope =
new G4PenelopeIonisationModel();
theIoniPenelope->SetHighEnergyLimit(PenelopeHighEnergyLimit);
eIoni->AddEmModel(0,theIoniPenelope,new G4UniversalFluctuation());
eIoni->SetStepFunction(0.2, 100*um); //
ph->RegisterProcess(eIoni, particle);
//Bremsstrahlung
G4eBremsstrahlung* eBrem = new G4eBremsstrahlung();
G4PenelopeBremsstrahlungModel* theBremPenelope = new
G4PenelopeBremsstrahlungModel();
theBremPenelope->SetHighEnergyLimit(PenelopeHighEnergyLimit);
eBrem->AddEmModel(0,theBremPenelope);
ph->RegisterProcess(eBrem, particle);
} else if (particleName == "e+") {
// multiple scattering
G4eMultipleScattering* msc = new G4eMultipleScattering;
msc->SetStepLimitType(fUseDistanceToBoundary);
G4UrbanMscModel* msc1 = new G4UrbanMscModel();
G4WentzelVIModel* msc2 = new G4WentzelVIModel();
msc1->SetHighEnergyLimit(highEnergyLimit);
msc2->SetLowEnergyLimit(highEnergyLimit);
msc->AddEmModel(0, msc1);
msc->AddEmModel(0, msc2);
G4eCoulombScatteringModel* ssm = new G4eCoulombScatteringModel();
G4CoulombScattering* ss = new G4CoulombScattering();
ss->SetEmModel(ssm, 1);
ss->SetMinKinEnergy(highEnergyLimit);
ssm->SetLowEnergyLimit(highEnergyLimit);
ssm->SetActivationLowEnergyLimit(highEnergyLimit);
ph->RegisterProcess(msc, particle);
ph->RegisterProcess(ss, particle);
//Ionisation
G4eIonisation* eIoni = new G4eIonisation();
G4PenelopeIonisationModel* theIoniPenelope =
new G4PenelopeIonisationModel();
theIoniPenelope->SetHighEnergyLimit(PenelopeHighEnergyLimit);
eIoni->AddEmModel(0,theIoniPenelope,new G4UniversalFluctuation());
eIoni->SetStepFunction(0.2, 100*um); //
ph->RegisterProcess(eIoni, particle);
//Bremsstrahlung
G4eBremsstrahlung* eBrem = new G4eBremsstrahlung();
G4PenelopeBremsstrahlungModel* theBremPenelope = new
G4PenelopeBremsstrahlungModel();
theBremPenelope->SetHighEnergyLimit(PenelopeHighEnergyLimit);
eBrem->AddEmModel(0,theBremPenelope);
ph->RegisterProcess(eBrem, particle);
//Annihilation
G4eplusAnnihilation* eAnni = new G4eplusAnnihilation();
G4PenelopeAnnihilationModel* theAnnPenelope = new
G4PenelopeAnnihilationModel();
theAnnPenelope->SetHighEnergyLimit(PenelopeHighEnergyLimit);
eAnni->AddEmModel(0,theAnnPenelope);
ph->RegisterProcess(eAnni, particle);
} else if (particleName == "mu+" ||
particleName == "mu-" ) {
// Identical to G4EmStandardPhysics_option3
G4MuIonisation* muIoni = new G4MuIonisation();
muIoni->SetStepFunction(0.2, 50*um);
ph->RegisterProcess(mumsc, particle);
ph->RegisterProcess(muIoni, particle);
ph->RegisterProcess(mub, particle);
ph->RegisterProcess(mup, particle);
ph->RegisterProcess(new G4CoulombScattering(), particle);
} else if (particleName == "alpha" ||
particleName == "He3" ) {
// Identical to G4EmStandardPhysics_option3
G4hMultipleScattering* msc = new G4hMultipleScattering();
G4ionIonisation* ionIoni = new G4ionIonisation();
ionIoni->SetStepFunction(0.1, 10*um);
ph->RegisterProcess(msc, particle);
ph->RegisterProcess(ionIoni, particle);
ph->RegisterProcess(ionnuc, particle);
} else if (particleName == "GenericIon") {
// Identical to G4EmStandardPhysics_option3
G4ionIonisation* ionIoni = new G4ionIonisation();
ionIoni->SetEmModel(new G4IonParametrisedLossModel());
ionIoni->SetStepFunction(0.1, 1*um);
ph->RegisterProcess(hmsc, particle);
ph->RegisterProcess(ionIoni, particle);
ph->RegisterProcess(ionnuc, particle);
} else if (particleName == "pi+" ||
particleName == "pi-" ) {
G4hIonisation* hIoni = new G4hIonisation();
hIoni->SetStepFunction(0.2, 50*um);
ph->RegisterProcess(pimsc, particle);
ph->RegisterProcess(hIoni, particle);
ph->RegisterProcess(pib, particle);
ph->RegisterProcess(pip, particle);
} else if (particleName == "kaon+" ||
particleName == "kaon-" ) {
G4hIonisation* hIoni = new G4hIonisation();
hIoni->SetStepFunction(0.2, 50*um);
ph->RegisterProcess(kmsc, particle);
ph->RegisterProcess(hIoni, particle);
ph->RegisterProcess(kb, particle);
ph->RegisterProcess(kp, particle);
} else if (particleName == "proton" ||
particleName == "anti_proton") {
G4hIonisation* hIoni = new G4hIonisation();
hIoni->SetStepFunction(0.2, 50*um);
ph->RegisterProcess(pmsc, particle);
ph->RegisterProcess(hIoni, particle);
ph->RegisterProcess(pb, particle);
ph->RegisterProcess(pp, particle);
ph->RegisterProcess(pnuc, particle);
} else if (particleName == "B+" ||
particleName == "B-" ||
particleName == "D+" ||
particleName == "D-" ||
particleName == "Ds+" ||
particleName == "Ds-" ||
particleName == "anti_He3" ||
particleName == "anti_alpha" ||
particleName == "anti_deuteron" ||
particleName == "anti_lambda_c+" ||
particleName == "anti_omega-" ||
particleName == "anti_sigma_c+" ||
particleName == "anti_sigma_c++" ||
particleName == "anti_sigma+" ||
particleName == "anti_sigma-" ||
particleName == "anti_triton" ||
particleName == "anti_xi_c+" ||
particleName == "anti_xi-" ||
particleName == "deuteron" ||
particleName == "lambda_c+" ||
particleName == "omega-" ||
particleName == "sigma_c+" ||
particleName == "sigma_c++" ||
particleName == "sigma+" ||
particleName == "sigma-" ||
particleName == "tau+" ||
particleName == "tau-" ||
particleName == "triton" ||
particleName == "xi_c+" ||
particleName == "xi-" ) {
// Identical to G4EmStandardPhysics_option3
ph->RegisterProcess(hmsc, particle);
ph->RegisterProcess(new G4hIonisation(), particle);
ph->RegisterProcess(pnuc, particle);
}
}
// Em options
//
G4EmProcessOptions opt;
opt.SetVerbose(verbose);
// Multiple Coulomb scattering
//
//opt.SetMscStepLimitation(fUseDistanceToBoundary);
//opt.SetMscRangeFactor(0.02);
// Physics tables
//
opt.SetMinEnergy(100*eV);
opt.SetMaxEnergy(10*TeV);
opt.SetDEDXBinning(220);
opt.SetLambdaBinning(220);
// Nuclear stopping
pnuc->SetMaxKinEnergy(MeV);
//opt.SetSplineFlag(true);
opt.SetPolarAngleLimit(CLHEP::pi);
// Ionization
//
//opt.SetSubCutoff(true);
// Deexcitation
//
G4VAtomDeexcitation* deexcitation = new G4UAtomicDeexcitation();
G4LossTableManager::Instance()->SetAtomDeexcitation(deexcitation);
deexcitation->SetFluo(true);
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
source/physics_lists/constructors/electromagnetic/src/G4EmStandardPhysics.cc
+346
View File
@@ -0,0 +1,346 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4EmStandardPhysics.cc 75169 2013-10-29 09:21:54Z gcosmo $
//
//---------------------------------------------------------------------------
//
// ClassName: G4EmStandardPhysics
//
// Author: V.Ivanchenko 09.11.2005
//
// Modified:
// 05.12.2005 V.Ivanchenko add controlled verbosity
// 13.11.2006 V.Ivanchenko use G4hMultipleScattering
// 23.11.2006 V.Ivanchenko remove mscStepLimit option and improve cout
// 13.02.2007 V.Ivanchenko use G4hMultipleScattering for muons
// 13.02.2007 V.Ivanchenko set skin=0.0
// 21.04.2008 V.Ivanchenko add long-lived D and B mesons
//
//----------------------------------------------------------------------------
//
#include "G4EmStandardPhysics.hh"
#include "G4SystemOfUnits.hh"
#include "G4ParticleDefinition.hh"
#include "G4LossTableManager.hh"
#include "G4EmProcessOptions.hh"
#include "G4ComptonScattering.hh"
#include "G4GammaConversion.hh"
#include "G4PhotoElectricEffect.hh"
#include "G4eMultipleScattering.hh"
#include "G4MuMultipleScattering.hh"
#include "G4hMultipleScattering.hh"
#include "G4CoulombScattering.hh"
#include "G4eCoulombScatteringModel.hh"
#include "G4WentzelVIModel.hh"
#include "G4UrbanMscModel.hh"
#include "G4MuBremsstrahlungModel.hh"
#include "G4MuPairProductionModel.hh"
#include "G4hBremsstrahlungModel.hh"
#include "G4hPairProductionModel.hh"
#include "G4eIonisation.hh"
#include "G4eBremsstrahlung.hh"
#include "G4eplusAnnihilation.hh"
#include "G4UAtomicDeexcitation.hh"
#include "G4MuIonisation.hh"
#include "G4MuBremsstrahlung.hh"
#include "G4MuPairProduction.hh"
#include "G4hBremsstrahlung.hh"
#include "G4hPairProduction.hh"
#include "G4hIonisation.hh"
#include "G4ionIonisation.hh"
#include "G4alphaIonisation.hh"
#include "G4Gamma.hh"
#include "G4Electron.hh"
#include "G4Positron.hh"
#include "G4MuonPlus.hh"
#include "G4MuonMinus.hh"
#include "G4PionPlus.hh"
#include "G4PionMinus.hh"
#include "G4KaonPlus.hh"
#include "G4KaonMinus.hh"
#include "G4Proton.hh"
#include "G4AntiProton.hh"
#include "G4Deuteron.hh"
#include "G4Triton.hh"
#include "G4He3.hh"
#include "G4Alpha.hh"
#include "G4GenericIon.hh"
#include "G4PhysicsListHelper.hh"
#include "G4BuilderType.hh"
// factory
#include "G4PhysicsConstructorFactory.hh"
//
G4_DECLARE_PHYSCONSTR_FACTORY(G4EmStandardPhysics);
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
G4EmStandardPhysics::G4EmStandardPhysics(G4int ver)
: G4VPhysicsConstructor("G4EmStandard"), verbose(ver)
{
G4LossTableManager::Instance();
SetPhysicsType(bElectromagnetic);
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
G4EmStandardPhysics::G4EmStandardPhysics(G4int ver, const G4String&)
: G4VPhysicsConstructor("G4EmStandard"), verbose(ver)
{
G4LossTableManager::Instance();
SetPhysicsType(bElectromagnetic);
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
G4EmStandardPhysics::~G4EmStandardPhysics()
{}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void G4EmStandardPhysics::ConstructParticle()
{
// gamma
G4Gamma::Gamma();
// leptons
G4Electron::Electron();
G4Positron::Positron();
G4MuonPlus::MuonPlus();
G4MuonMinus::MuonMinus();
// mesons
G4PionPlus::PionPlusDefinition();
G4PionMinus::PionMinusDefinition();
G4KaonPlus::KaonPlusDefinition();
G4KaonMinus::KaonMinusDefinition();
// barions
G4Proton::Proton();
G4AntiProton::AntiProton();
// ions
G4Deuteron::Deuteron();
G4Triton::Triton();
G4He3::He3();
G4Alpha::Alpha();
G4GenericIon::GenericIonDefinition();
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void G4EmStandardPhysics::ConstructProcess()
{
if(verbose > 1) {
G4cout << "### " << GetPhysicsName() << " Construct Processes " << G4endl;
}
G4PhysicsListHelper* ph = G4PhysicsListHelper::GetPhysicsListHelper();
// muon & hadron bremsstrahlung and pair production
G4MuBremsstrahlung* mub = new G4MuBremsstrahlung();
G4MuPairProduction* mup = new G4MuPairProduction();
G4hBremsstrahlung* pib = new G4hBremsstrahlung();
G4hPairProduction* pip = new G4hPairProduction();
G4hBremsstrahlung* kb = new G4hBremsstrahlung();
G4hPairProduction* kp = new G4hPairProduction();
G4hBremsstrahlung* pb = new G4hBremsstrahlung();
G4hPairProduction* pp = new G4hPairProduction();
// muon & hadron multiple scattering
G4MuMultipleScattering* mumsc = new G4MuMultipleScattering();
mumsc->AddEmModel(0, new G4WentzelVIModel());
G4MuMultipleScattering* pimsc = new G4MuMultipleScattering();
pimsc->AddEmModel(0, new G4WentzelVIModel());
G4MuMultipleScattering* kmsc = new G4MuMultipleScattering();
kmsc->AddEmModel(0, new G4WentzelVIModel());
G4MuMultipleScattering* pmsc = new G4MuMultipleScattering();
pmsc->AddEmModel(0, new G4WentzelVIModel());
G4hMultipleScattering* hmsc = new G4hMultipleScattering("ionmsc");
// high energy limit for e+- scattering models
G4double highEnergyLimit = 100*MeV;
// Add standard EM Processes
aParticleIterator->reset();
while( (*aParticleIterator)() ){
G4ParticleDefinition* particle = aParticleIterator->value();
G4String particleName = particle->GetParticleName();
if (particleName == "gamma") {
ph->RegisterProcess(new G4PhotoElectricEffect(), particle);
ph->RegisterProcess(new G4ComptonScattering(), particle);
ph->RegisterProcess(new G4GammaConversion(), particle);
} else if (particleName == "e-") {
G4eMultipleScattering* msc = new G4eMultipleScattering;
G4UrbanMscModel* msc1 = new G4UrbanMscModel();
G4WentzelVIModel* msc2 = new G4WentzelVIModel();
msc1->SetHighEnergyLimit(highEnergyLimit);
msc2->SetLowEnergyLimit(highEnergyLimit);
msc->AddEmModel(0, msc1);
msc->AddEmModel(0, msc2);
G4eCoulombScatteringModel* ssm = new G4eCoulombScatteringModel();
G4CoulombScattering* ss = new G4CoulombScattering();
ss->SetEmModel(ssm, 1);
ss->SetMinKinEnergy(highEnergyLimit);
ssm->SetLowEnergyLimit(highEnergyLimit);
ssm->SetActivationLowEnergyLimit(highEnergyLimit);
ph->RegisterProcess(msc, particle);
ph->RegisterProcess(new G4eIonisation(), particle);
ph->RegisterProcess(new G4eBremsstrahlung(), particle);
ph->RegisterProcess(ss, particle);
} else if (particleName == "e+") {
G4eMultipleScattering* msc = new G4eMultipleScattering;
G4UrbanMscModel* msc1 = new G4UrbanMscModel();
G4WentzelVIModel* msc2 = new G4WentzelVIModel();
msc1->SetHighEnergyLimit(highEnergyLimit);
msc2->SetLowEnergyLimit(highEnergyLimit);
msc->AddEmModel(0, msc1);
msc->AddEmModel(0, msc2);
G4eCoulombScatteringModel* ssm = new G4eCoulombScatteringModel();
G4CoulombScattering* ss = new G4CoulombScattering();
ss->SetEmModel(ssm, 1);
ss->SetMinKinEnergy(highEnergyLimit);
ssm->SetLowEnergyLimit(highEnergyLimit);
ssm->SetActivationLowEnergyLimit(highEnergyLimit);
ph->RegisterProcess(msc, particle);
ph->RegisterProcess(new G4eIonisation(), particle);
ph->RegisterProcess(new G4eBremsstrahlung(), particle);
ph->RegisterProcess(new G4eplusAnnihilation(), particle);
ph->RegisterProcess(ss, particle);
} else if (particleName == "mu+" ||
particleName == "mu-" ) {
ph->RegisterProcess(mumsc, particle);
ph->RegisterProcess(new G4MuIonisation(), particle);
ph->RegisterProcess(mub, particle);
ph->RegisterProcess(mup, particle);
ph->RegisterProcess(new G4CoulombScattering(), particle);
} else if (particleName == "alpha" ||
particleName == "He3") {
//ph->RegisterProcess(hmsc, particle);
ph->RegisterProcess(new G4hMultipleScattering(), particle);
ph->RegisterProcess(new G4ionIonisation(), particle);
} else if (particleName == "GenericIon") {
ph->RegisterProcess(hmsc, particle);
ph->RegisterProcess(new G4ionIonisation(), particle);
} else if (particleName == "pi+" ||
particleName == "pi-" ) {
//G4hMultipleScattering* pimsc = new G4hMultipleScattering();
ph->RegisterProcess(pimsc, particle);
ph->RegisterProcess(new G4hIonisation(), particle);
ph->RegisterProcess(pib, particle);
ph->RegisterProcess(pip, particle);
} else if (particleName == "kaon+" ||
particleName == "kaon-" ) {
//G4hMultipleScattering* kmsc = new G4hMultipleScattering();
ph->RegisterProcess(kmsc, particle);
ph->RegisterProcess(new G4hIonisation(), particle);
ph->RegisterProcess(kb, particle);
ph->RegisterProcess(kp, particle);
} else if (particleName == "proton" ||
particleName == "anti_proton") {
//G4hMultipleScattering* pmsc = new G4hMultipleScattering();
ph->RegisterProcess(pmsc, particle);
ph->RegisterProcess(new G4hIonisation(), particle);
ph->RegisterProcess(pb, particle);
ph->RegisterProcess(pp, particle);
} else if (particleName == "B+" ||
particleName == "B-" ||
particleName == "D+" ||
particleName == "D-" ||
particleName == "Ds+" ||
particleName == "Ds-" ||
particleName == "anti_He3" ||
particleName == "anti_alpha" ||
particleName == "anti_deuteron" ||
particleName == "anti_lambda_c+" ||
particleName == "anti_omega-" ||
particleName == "anti_sigma_c+" ||
particleName == "anti_sigma_c++" ||
particleName == "anti_sigma+" ||
particleName == "anti_sigma-" ||
particleName == "anti_triton" ||
particleName == "anti_xi_c+" ||
particleName == "anti_xi-" ||
particleName == "deuteron" ||
particleName == "lambda_c+" ||
particleName == "omega-" ||
particleName == "sigma_c+" ||
particleName == "sigma_c++" ||
particleName == "sigma+" ||
particleName == "sigma-" ||
particleName == "tau+" ||
particleName == "tau-" ||
particleName == "triton" ||
particleName == "xi_c+" ||
particleName == "xi-" ) {
ph->RegisterProcess(hmsc, particle);
ph->RegisterProcess(new G4hIonisation(), particle);
}
}
G4EmProcessOptions opt;
opt.SetVerbose(verbose);
// opt.SetApplyCuts(true);
opt.SetPolarAngleLimit(CLHEP::pi);
// Deexcitation
//
G4VAtomDeexcitation* de = new G4UAtomicDeexcitation();
G4LossTableManager::Instance()->SetAtomDeexcitation(de);
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
source/physics_lists/constructors/electromagnetic/src/G4EmStandardPhysics_option1.cc
+359
View File
@@ -0,0 +1,359 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4EmStandardPhysics_option1.cc 73153 2013-08-20 07:17:42Z gcosmo $
//
//---------------------------------------------------------------------------
//
// ClassName: G4EmStandardPhysics_option1
//
// Author: V.Ivanchenko 09.11.2005
//
// Modified:
// 19.12.2005 V.Ivanchenko StepFunction for electrons (1.0, 1.0*mm)
// 21.06.2006 V.Ivanchenko use recent msc with step limitation off
// 23.06.2006 V.Ivanchenko set dRoverRange = 0.8 for e- and e+
// 13.11.2006 V.Ivanchenko use G4hMultipleScattering
// 23.11.2006 V.Ivanchenko remove mscStepLimit option and improve cout
// 13.02.2007 V.Ivanchenko set skin=0.0
// 15.05.2007 V.Ivanchenko rename to _option1
// 21.04.2008 V.Ivanchenko add long-lived D and B mesons
// 19.11.2010 V.Ivanchenko added WentzelVI model for muons;
// disable ApplyCut option for compatibility with 9.2
//
//----------------------------------------------------------------------------
//
#include "G4EmStandardPhysics_option1.hh"
#include "G4SystemOfUnits.hh"
#include "G4ParticleDefinition.hh"
#include "G4LossTableManager.hh"
#include "G4EmProcessOptions.hh"
#include "G4ComptonScattering.hh"
#include "G4GammaConversion.hh"
#include "G4PhotoElectricEffect.hh"
#include "G4eMultipleScattering.hh"
#include "G4MuMultipleScattering.hh"
#include "G4hMultipleScattering.hh"
#include "G4eCoulombScatteringModel.hh"
#include "G4CoulombScattering.hh"
#include "G4WentzelVIModel.hh"
#include "G4UrbanMscModel.hh"
#include "G4eIonisation.hh"
#include "G4eBremsstrahlung.hh"
#include "G4eplusAnnihilation.hh"
#include "G4UAtomicDeexcitation.hh"
#include "G4MuIonisation.hh"
#include "G4MuBremsstrahlung.hh"
#include "G4MuPairProduction.hh"
#include "G4hBremsstrahlung.hh"
#include "G4hPairProduction.hh"
#include "G4MuBremsstrahlungModel.hh"
#include "G4MuPairProductionModel.hh"
#include "G4hBremsstrahlungModel.hh"
#include "G4hPairProductionModel.hh"
#include "G4hIonisation.hh"
#include "G4ionIonisation.hh"
#include "G4alphaIonisation.hh"
#include "G4Gamma.hh"
#include "G4Electron.hh"
#include "G4Positron.hh"
#include "G4MuonPlus.hh"
#include "G4MuonMinus.hh"
#include "G4PionPlus.hh"
#include "G4PionMinus.hh"
#include "G4KaonPlus.hh"
#include "G4KaonMinus.hh"
#include "G4Proton.hh"
#include "G4AntiProton.hh"
#include "G4Deuteron.hh"
#include "G4Triton.hh"
#include "G4He3.hh"
#include "G4Alpha.hh"
#include "G4GenericIon.hh"
#include "G4PhysicsListHelper.hh"
#include "G4BuilderType.hh"
// factory
#include "G4PhysicsConstructorFactory.hh"
//
G4_DECLARE_PHYSCONSTR_FACTORY(G4EmStandardPhysics_option1);
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
G4EmStandardPhysics_option1::G4EmStandardPhysics_option1(G4int ver)
: G4VPhysicsConstructor("G4EmStandard_opt1"), verbose(ver)
{
G4LossTableManager::Instance();
SetPhysicsType(bElectromagnetic);
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
G4EmStandardPhysics_option1::G4EmStandardPhysics_option1(G4int ver, const G4String&)
: G4VPhysicsConstructor("G4EmStandard_opt1"), verbose(ver)
{
G4LossTableManager::Instance();
SetPhysicsType(bElectromagnetic);
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
G4EmStandardPhysics_option1::~G4EmStandardPhysics_option1()
{}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void G4EmStandardPhysics_option1::ConstructParticle()
{
// gamma
G4Gamma::Gamma();
// leptons
G4Electron::Electron();
G4Positron::Positron();
G4MuonPlus::MuonPlus();
G4MuonMinus::MuonMinus();
// mesons
G4PionPlus::PionPlusDefinition();
G4PionMinus::PionMinusDefinition();
G4KaonPlus::KaonPlusDefinition();
G4KaonMinus::KaonMinusDefinition();
// barions
G4Proton::Proton();
G4AntiProton::AntiProton();
// ions
G4Deuteron::Deuteron();
G4Triton::Triton();
G4He3::He3();
G4Alpha::Alpha();
G4GenericIon::GenericIonDefinition();
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void G4EmStandardPhysics_option1::ConstructProcess()
{
if(verbose > 1) {
G4cout << "### " << GetPhysicsName() << " Construct Processes " << G4endl;
}
G4PhysicsListHelper* ph = G4PhysicsListHelper::GetPhysicsListHelper();
// muon & hadron bremsstrahlung and pair production
G4MuBremsstrahlung* mub = new G4MuBremsstrahlung();
G4MuPairProduction* mup = new G4MuPairProduction();
G4hBremsstrahlung* pib = new G4hBremsstrahlung();
G4hPairProduction* pip = new G4hPairProduction();
G4hBremsstrahlung* kb = new G4hBremsstrahlung();
G4hPairProduction* kp = new G4hPairProduction();
G4hBremsstrahlung* pb = new G4hBremsstrahlung();
G4hPairProduction* pp = new G4hPairProduction();
// muon & hadron multiple scattering
G4MuMultipleScattering* mumsc = new G4MuMultipleScattering();
mumsc->AddEmModel(0, new G4WentzelVIModel());
G4MuMultipleScattering* pimsc = new G4MuMultipleScattering();
pimsc->AddEmModel(0, new G4WentzelVIModel());
G4MuMultipleScattering* kmsc = new G4MuMultipleScattering();
kmsc->AddEmModel(0, new G4WentzelVIModel());
G4MuMultipleScattering* pmsc = new G4MuMultipleScattering();
pmsc->AddEmModel(0, new G4WentzelVIModel());
G4hMultipleScattering* hmsc = new G4hMultipleScattering("ionmsc");
// high energy limit for e+- scattering models and bremsstrahlung
G4double highEnergyLimit = 100*MeV;
// Add standard EM Processes
aParticleIterator->reset();
while( (*aParticleIterator)() ){
G4ParticleDefinition* particle = aParticleIterator->value();
G4String particleName = particle->GetParticleName();
if (particleName == "gamma") {
ph->RegisterProcess(new G4PhotoElectricEffect(), particle);
ph->RegisterProcess(new G4ComptonScattering(), particle);
ph->RegisterProcess(new G4GammaConversion(), particle);
} else if (particleName == "e-") {
G4eIonisation* eioni = new G4eIonisation();
eioni->SetStepFunction(0.8, 1.0*mm);
G4eMultipleScattering* msc = new G4eMultipleScattering;
msc->SetStepLimitType(fMinimal);
G4UrbanMscModel* msc1 = new G4UrbanMscModel();
G4WentzelVIModel* msc2 = new G4WentzelVIModel();
msc1->SetHighEnergyLimit(highEnergyLimit);
msc2->SetLowEnergyLimit(highEnergyLimit);
msc->AddEmModel(0, msc1);
msc->AddEmModel(0, msc2);
G4eCoulombScatteringModel* ssm = new G4eCoulombScatteringModel();
G4CoulombScattering* ss = new G4CoulombScattering();
ss->SetEmModel(ssm, 1);
ss->SetMinKinEnergy(highEnergyLimit);
ssm->SetLowEnergyLimit(highEnergyLimit);
ssm->SetActivationLowEnergyLimit(highEnergyLimit);
ph->RegisterProcess(msc, particle);
ph->RegisterProcess(eioni, particle);
ph->RegisterProcess(new G4eBremsstrahlung(), particle);
ph->RegisterProcess(ss, particle);
} else if (particleName == "e+") {
G4eIonisation* eioni = new G4eIonisation();
eioni->SetStepFunction(0.8, 1.0*mm);
G4eMultipleScattering* msc = new G4eMultipleScattering;
msc->SetStepLimitType(fMinimal);
G4UrbanMscModel* msc1 = new G4UrbanMscModel();
G4WentzelVIModel* msc2 = new G4WentzelVIModel();
msc1->SetHighEnergyLimit(highEnergyLimit);
msc2->SetLowEnergyLimit(highEnergyLimit);
msc->AddEmModel(0, msc1);
msc->AddEmModel(0, msc2);
G4eCoulombScatteringModel* ssm = new G4eCoulombScatteringModel();
G4CoulombScattering* ss = new G4CoulombScattering();
ss->SetEmModel(ssm, 1);
ss->SetMinKinEnergy(highEnergyLimit);
ssm->SetLowEnergyLimit(highEnergyLimit);
ssm->SetActivationLowEnergyLimit(highEnergyLimit);
ph->RegisterProcess(msc, particle);
ph->RegisterProcess(eioni, particle);
ph->RegisterProcess(new G4eBremsstrahlung(), particle);
ph->RegisterProcess(new G4eplusAnnihilation(), particle);
ph->RegisterProcess(ss, particle);
} else if (particleName == "mu+" ||
particleName == "mu-" ) {
ph->RegisterProcess(mumsc, particle);
ph->RegisterProcess(new G4MuIonisation(), particle);
ph->RegisterProcess(mub, particle);
ph->RegisterProcess(mup, particle);
ph->RegisterProcess(new G4CoulombScattering(), particle);
} else if (particleName == "alpha" ||
particleName == "He3" ) {
//ph->RegisterProcess(hmsc, particle);
ph->RegisterProcess(new G4hMultipleScattering(), particle);
ph->RegisterProcess(new G4ionIonisation(), particle);
} else if (particleName == "GenericIon") {
ph->RegisterProcess(hmsc, particle);
ph->RegisterProcess(new G4ionIonisation(), particle);
} else if (particleName == "pi+" ||
particleName == "pi-" ) {
//G4hMultipleScattering* pimsc = new G4hMultipleScattering();
ph->RegisterProcess(pimsc, particle);
ph->RegisterProcess(new G4hIonisation(), particle);
ph->RegisterProcess(pib, particle);
ph->RegisterProcess(pip, particle);
} else if (particleName == "kaon+" ||
particleName == "kaon-" ) {
//G4hMultipleScattering* kmsc = new G4hMultipleScattering();
ph->RegisterProcess(kmsc, particle);
ph->RegisterProcess(new G4hIonisation(), particle);
ph->RegisterProcess(kb, particle);
ph->RegisterProcess(kp, particle);
// } else if (particleName == "proton" ) {
} else if (particleName == "proton" ||
particleName == "anti_proton") {
//G4hMultipleScattering* pmsc = new G4hMultipleScattering();
ph->RegisterProcess(pmsc, particle);
ph->RegisterProcess(new G4hIonisation(), particle);
ph->RegisterProcess(pb, particle);
ph->RegisterProcess(pp, particle);
} else if (particleName == "B+" ||
particleName == "B-" ||
particleName == "D+" ||
particleName == "D-" ||
particleName == "Ds+" ||
particleName == "Ds-" ||
particleName == "anti_He3" ||
particleName == "anti_alpha" ||
particleName == "anti_deuteron" ||
particleName == "anti_lambda_c+" ||
particleName == "anti_omega-" ||
particleName == "anti_sigma_c+" ||
particleName == "anti_sigma_c++" ||
particleName == "anti_sigma+" ||
particleName == "anti_sigma-" ||
particleName == "anti_triton" ||
particleName == "anti_xi_c+" ||
particleName == "anti_xi-" ||
particleName == "deuteron" ||
particleName == "lambda_c+" ||
particleName == "omega-" ||
particleName == "sigma_c+" ||
particleName == "sigma_c++" ||
particleName == "sigma+" ||
particleName == "sigma-" ||
particleName == "tau+" ||
particleName == "tau-" ||
particleName == "triton" ||
particleName == "xi_c+" ||
particleName == "xi-" ) {
ph->RegisterProcess(hmsc, particle);
ph->RegisterProcess(new G4hIonisation(), particle);
}
}
G4EmProcessOptions opt;
opt.SetVerbose(verbose);
opt.SetPolarAngleLimit(CLHEP::pi);
opt.SetApplyCuts(true);
// Deexcitation
//
G4VAtomDeexcitation* de = new G4UAtomicDeexcitation();
G4LossTableManager::Instance()->SetAtomDeexcitation(de);
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
source/physics_lists/constructors/electromagnetic/src/G4EmStandardPhysics_option2.cc
+385
View File
@@ -0,0 +1,385 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4EmStandardPhysics_option2.cc 75169 2013-10-29 09:21:54Z gcosmo $
//
//---------------------------------------------------------------------------
//
// ClassName: G4EmStandardPhysics_option2
//
// Author: V.Ivanchenko 09.11.2005
//
// Modified:
// 19.12.2005 V.Ivanchenko rename 71 -> 72
// 15.06.2006 V.Ivanchenko use this class as a constructor of fast EM physics
// 13.11.2006 V.Ivanchenko use G4hMultipleScattering
// 14.11.2006 V.Ivanchenko use sub-cutoff option for all particles
// 13.02.2007 V.Ivanchenko use default msc
// 15.05.2007 V.Ivanchenko rename to _option2
// 13.03.2008 V.Ivanchenko use G4eMultipleScattering
// 21.04.2008 V.Ivanchenko add long-lived D and B mesons; use spline
// 28.05.2008 V.Ivanchenko linLossLimit=0.01; added hBrem and hPairProd processes
//
//----------------------------------------------------------------------------
//
#include "G4EmStandardPhysics_option2.hh"
#include "G4SystemOfUnits.hh"
#include "G4ParticleDefinition.hh"
#include "G4LossTableManager.hh"
#include "G4EmProcessOptions.hh"
#include "G4ComptonScattering.hh"
#include "G4GammaConversion.hh"
#include "G4PhotoElectricEffect.hh"
#include "G4PEEffectFluoModel.hh"
#include "G4KleinNishinaModel.hh"
#include "G4RayleighScattering.hh"
#include "G4eMultipleScattering.hh"
#include "G4hMultipleScattering.hh"
#include "G4MuMultipleScattering.hh"
#include "G4CoulombScattering.hh"
#include "G4eCoulombScatteringModel.hh"
#include "G4UrbanMscModel.hh"
#include "G4WentzelVIModel.hh"
#include "G4eIonisation.hh"
#include "G4eBremsstrahlung.hh"
#include "G4eBremsstrahlungRelModel.hh"
#include "G4eplusAnnihilation.hh"
#include "G4Generator2BS.hh"
#include "G4SeltzerBergerModel.hh"
#include "G4UAtomicDeexcitation.hh"
#include "G4MuIonisation.hh"
#include "G4MuBremsstrahlung.hh"
#include "G4MuPairProduction.hh"
#include "G4hBremsstrahlung.hh"
#include "G4hPairProduction.hh"
#include "G4MuBremsstrahlungModel.hh"
#include "G4MuPairProductionModel.hh"
#include "G4hBremsstrahlungModel.hh"
#include "G4hPairProductionModel.hh"
#include "G4hIonisation.hh"
#include "G4ionIonisation.hh"
#include "G4alphaIonisation.hh"
#include "G4Gamma.hh"
#include "G4Electron.hh"
#include "G4Positron.hh"
#include "G4MuonPlus.hh"
#include "G4MuonMinus.hh"
#include "G4PionPlus.hh"
#include "G4PionMinus.hh"
#include "G4KaonPlus.hh"
#include "G4KaonMinus.hh"
#include "G4Proton.hh"
#include "G4AntiProton.hh"
#include "G4Deuteron.hh"
#include "G4Triton.hh"
#include "G4He3.hh"
#include "G4Alpha.hh"
#include "G4GenericIon.hh"
#include "G4PhysicsListHelper.hh"
#include "G4BuilderType.hh"
// factory
#include "G4PhysicsConstructorFactory.hh"
//
G4_DECLARE_PHYSCONSTR_FACTORY(G4EmStandardPhysics_option2);
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
G4EmStandardPhysics_option2::G4EmStandardPhysics_option2(G4int ver)
: G4VPhysicsConstructor("G4EmStandard_opt2"), verbose(ver)
{
G4LossTableManager::Instance();
SetPhysicsType(bElectromagnetic);
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
G4EmStandardPhysics_option2::G4EmStandardPhysics_option2(G4int ver, const G4String&)
: G4VPhysicsConstructor("G4EmStandard_opt2"), verbose(ver)
{
G4LossTableManager::Instance();
SetPhysicsType(bElectromagnetic);
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
G4EmStandardPhysics_option2::~G4EmStandardPhysics_option2()
{}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void G4EmStandardPhysics_option2::ConstructParticle()
{
// gamma
G4Gamma::Gamma();
// leptons
G4Electron::Electron();
G4Positron::Positron();
G4MuonPlus::MuonPlus();
G4MuonMinus::MuonMinus();
// mesons
G4PionPlus::PionPlusDefinition();
G4PionMinus::PionMinusDefinition();
G4KaonPlus::KaonPlusDefinition();
G4KaonMinus::KaonMinusDefinition();
// barions
G4Proton::Proton();
G4AntiProton::AntiProton();
// ions
G4Deuteron::Deuteron();
G4Triton::Triton();
G4He3::He3();
G4Alpha::Alpha();
G4GenericIon::GenericIonDefinition();
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void G4EmStandardPhysics_option2::ConstructProcess()
{
if(verbose > 1) {
G4cout << "### " << GetPhysicsName() << " Construct Processes " << G4endl;
}
G4PhysicsListHelper* ph = G4PhysicsListHelper::GetPhysicsListHelper();
// muon & hadron bremsstrahlung and pair production
G4MuBremsstrahlung* mub = new G4MuBremsstrahlung();
G4MuPairProduction* mup = new G4MuPairProduction();
G4hBremsstrahlung* pib = new G4hBremsstrahlung();
G4hPairProduction* pip = new G4hPairProduction();
G4hBremsstrahlung* kb = new G4hBremsstrahlung();
G4hPairProduction* kp = new G4hPairProduction();
G4hBremsstrahlung* pb = new G4hBremsstrahlung();
G4hPairProduction* pp = new G4hPairProduction();
// muon & hadron multiple scattering
G4MuMultipleScattering* mumsc = new G4MuMultipleScattering();
mumsc->AddEmModel(0, new G4WentzelVIModel());
G4hMultipleScattering* pmsc = new G4hMultipleScattering();
pmsc->AddEmModel(0, new G4WentzelVIModel());
G4hMultipleScattering* pimsc = new G4hMultipleScattering();
pimsc->AddEmModel(0, new G4WentzelVIModel());
G4hMultipleScattering* kmsc = new G4hMultipleScattering();
kmsc->AddEmModel(0, new G4WentzelVIModel());
G4hMultipleScattering* hmsc = new G4hMultipleScattering("ionmsc");
// high energy limit for e+- scattering models and bremsstrahlung
G4double highEnergyLimit = 100*MeV;
// Add standard EM Processes
aParticleIterator->reset();
while( (*aParticleIterator)() ){
G4ParticleDefinition* particle = aParticleIterator->value();
G4String particleName = particle->GetParticleName();
if (particleName == "gamma") {
ph->RegisterProcess(new G4PhotoElectricEffect(), particle);
ph->RegisterProcess(new G4ComptonScattering(), particle);
ph->RegisterProcess(new G4GammaConversion(), particle);
ph->RegisterProcess(new G4RayleighScattering(), particle);
} else if (particleName == "e-") {
G4eIonisation* eioni = new G4eIonisation();
eioni->SetStepFunction(0.8, 1.0*mm);
G4eMultipleScattering* msc = new G4eMultipleScattering;
msc->SetStepLimitType(fMinimal);
G4UrbanMscModel* msc1 = new G4UrbanMscModel();
G4WentzelVIModel* msc2 = new G4WentzelVIModel();
msc1->SetHighEnergyLimit(highEnergyLimit);
msc2->SetLowEnergyLimit(highEnergyLimit);
msc->AddEmModel(0, msc1);
msc->AddEmModel(0, msc2);
G4eCoulombScatteringModel* ssm = new G4eCoulombScatteringModel();
G4CoulombScattering* ss = new G4CoulombScattering();
ss->SetEmModel(ssm, 1);
ss->SetMinKinEnergy(highEnergyLimit);
ssm->SetLowEnergyLimit(highEnergyLimit);
ssm->SetActivationLowEnergyLimit(highEnergyLimit);
G4eBremsstrahlung* brem = new G4eBremsstrahlung();
G4SeltzerBergerModel* br1 = new G4SeltzerBergerModel();
G4eBremsstrahlungRelModel* br2 = new G4eBremsstrahlungRelModel();
br1->SetAngularDistribution(new G4Generator2BS());
br2->SetAngularDistribution(new G4Generator2BS());
brem->SetEmModel(br1,1);
brem->SetEmModel(br2,2);
br2->SetLowEnergyLimit(GeV);
ph->RegisterProcess(msc, particle);
ph->RegisterProcess(eioni, particle);
ph->RegisterProcess(brem, particle);
ph->RegisterProcess(ss, particle);
} else if (particleName == "e+") {
G4eIonisation* eioni = new G4eIonisation();
eioni->SetStepFunction(0.8, 1.0*mm);
G4eMultipleScattering* msc = new G4eMultipleScattering;
msc->SetStepLimitType(fMinimal);
G4UrbanMscModel* msc1 = new G4UrbanMscModel();
G4WentzelVIModel* msc2 = new G4WentzelVIModel();
msc1->SetHighEnergyLimit(highEnergyLimit);
msc2->SetLowEnergyLimit(highEnergyLimit);
msc->AddEmModel(0, msc1);
msc->AddEmModel(0, msc2);
G4eCoulombScatteringModel* ssm = new G4eCoulombScatteringModel();
G4CoulombScattering* ss = new G4CoulombScattering();
ss->SetEmModel(ssm, 1);
ss->SetMinKinEnergy(highEnergyLimit);
ssm->SetLowEnergyLimit(highEnergyLimit);
ssm->SetActivationLowEnergyLimit(highEnergyLimit);
ph->RegisterProcess(msc, particle);
ph->RegisterProcess(eioni, particle);
ph->RegisterProcess(new G4eBremsstrahlung(), particle);
ph->RegisterProcess(new G4eplusAnnihilation(), particle);
ph->RegisterProcess(ss, particle);
} else if (particleName == "mu+" ||
particleName == "mu-" ) {
ph->RegisterProcess(mumsc, particle);
ph->RegisterProcess(new G4MuIonisation(), particle);
ph->RegisterProcess(mub, particle);
ph->RegisterProcess(mup, particle);
ph->RegisterProcess(new G4CoulombScattering(), particle);
} else if (particleName == "alpha" ||
particleName == "He3") {
//ph->RegisterProcess(hmsc, particle);
ph->RegisterProcess(new G4hMultipleScattering(), particle);
ph->RegisterProcess(new G4ionIonisation(), particle);
} else if (particleName == "GenericIon") {
G4ionIonisation* ionIoni = new G4ionIonisation();
//ionIoni->SetEmModel(new G4IonParametrisedLossModel());
//ionIoni->SetStepFunction(0.1, 20*um);
ph->RegisterProcess(hmsc, particle);
ph->RegisterProcess(ionIoni, particle);
} else if (particleName == "pi+" ||
particleName == "pi-" ) {
ph->RegisterProcess(pimsc, particle);
ph->RegisterProcess(new G4hIonisation(), particle);
ph->RegisterProcess(pib, particle);
ph->RegisterProcess(pip, particle);
} else if (particleName == "kaon+" ||
particleName == "kaon-" ) {
ph->RegisterProcess(kmsc, particle);
ph->RegisterProcess(new G4hIonisation(), particle);
ph->RegisterProcess(kb, particle);
ph->RegisterProcess(kp, particle);
} else if (particleName == "proton" ||
particleName == "anti_proton") {
ph->RegisterProcess(pmsc, particle);
ph->RegisterProcess(new G4hIonisation(), particle);
ph->RegisterProcess(pb, particle);
ph->RegisterProcess(pp, particle);
} else if (particleName == "B+" ||
particleName == "B-" ||
particleName == "D+" ||
particleName == "D-" ||
particleName == "Ds+" ||
particleName == "Ds-" ||
particleName == "anti_He3" ||
particleName == "anti_alpha" ||
particleName == "anti_deuteron" ||
particleName == "anti_lambda_c+" ||
particleName == "anti_omega-" ||
particleName == "anti_sigma_c+" ||
particleName == "anti_sigma_c++" ||
particleName == "anti_sigma+" ||
particleName == "anti_sigma-" ||
particleName == "anti_triton" ||
particleName == "anti_xi_c+" ||
particleName == "anti_xi-" ||
particleName == "deuteron" ||
particleName == "lambda_c+" ||
particleName == "omega-" ||
particleName == "sigma_c+" ||
particleName == "sigma_c++" ||
particleName == "sigma+" ||
particleName == "sigma-" ||
particleName == "tau+" ||
particleName == "tau-" ||
particleName == "triton" ||
particleName == "xi_c+" ||
particleName == "xi-" ) {
ph->RegisterProcess(hmsc, particle);
ph->RegisterProcess(new G4hIonisation(), particle);
}
}
// Em options
//
G4EmProcessOptions opt;
opt.SetVerbose(verbose);
// Scattering options
//
opt.SetPolarAngleLimit(CLHEP::pi);
// Ionization
//
//opt.SetSubCutoff(true);
// Deexcitation
//
G4VAtomDeexcitation* de = new G4UAtomicDeexcitation();
G4LossTableManager::Instance()->SetAtomDeexcitation(de);
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
source/physics_lists/constructors/electromagnetic/src/G4EmStandardPhysics_option3.cc
+378
View File
@@ -0,0 +1,378 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4EmStandardPhysics_option3.cc 68750 2013-04-05 10:19:04Z gcosmo $
//
//---------------------------------------------------------------------------
//
// ClassName: G4EmStandardPhysics_option3
//
// Author: V.Ivanchenko 13.03.2008
//
// Modified:
// 21.04.2008 V.Ivanchenko add long-lived D and B mesons; use spline
// 28.05.2008 V.Ivanchenko linLossLimit=0.01 for ions 0.001 for others
//
//----------------------------------------------------------------------------
//
#include "G4EmStandardPhysics_option3.hh"
#include "G4SystemOfUnits.hh"
#include "G4ParticleDefinition.hh"
#include "G4LossTableManager.hh"
#include "G4EmProcessOptions.hh"
#include "G4ComptonScattering.hh"
#include "G4GammaConversion.hh"
#include "G4PhotoElectricEffect.hh"
#include "G4RayleighScattering.hh"
#include "G4PEEffectFluoModel.hh"
#include "G4KleinNishinaModel.hh"
#include "G4eMultipleScattering.hh"
#include "G4MuMultipleScattering.hh"
#include "G4hMultipleScattering.hh"
#include "G4MscStepLimitType.hh"
#include "G4UrbanMscModel.hh"
#include "G4DummyModel.hh"
#include "G4WentzelVIModel.hh"
#include "G4CoulombScattering.hh"
#include "G4eIonisation.hh"
#include "G4eBremsstrahlung.hh"
#include "G4Generator2BS.hh"
#include "G4SeltzerBergerModel.hh"
#include "G4eplusAnnihilation.hh"
#include "G4UAtomicDeexcitation.hh"
#include "G4MuIonisation.hh"
#include "G4MuBremsstrahlung.hh"
#include "G4MuPairProduction.hh"
#include "G4hBremsstrahlung.hh"
#include "G4hPairProduction.hh"
#include "G4MuBremsstrahlungModel.hh"
#include "G4MuPairProductionModel.hh"
#include "G4hBremsstrahlungModel.hh"
#include "G4hPairProductionModel.hh"
#include "G4hIonisation.hh"
#include "G4ionIonisation.hh"
#include "G4IonParametrisedLossModel.hh"
#include "G4NuclearStopping.hh"
#include "G4Gamma.hh"
#include "G4Electron.hh"
#include "G4Positron.hh"
#include "G4MuonPlus.hh"
#include "G4MuonMinus.hh"
#include "G4PionPlus.hh"
#include "G4PionMinus.hh"
#include "G4KaonPlus.hh"
#include "G4KaonMinus.hh"
#include "G4Proton.hh"
#include "G4AntiProton.hh"
#include "G4Deuteron.hh"
#include "G4Triton.hh"
#include "G4He3.hh"
#include "G4Alpha.hh"
#include "G4GenericIon.hh"
#include "G4PhysicsListHelper.hh"
#include "G4BuilderType.hh"
// factory
#include "G4PhysicsConstructorFactory.hh"
//
G4_DECLARE_PHYSCONSTR_FACTORY(G4EmStandardPhysics_option3);
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
G4EmStandardPhysics_option3::G4EmStandardPhysics_option3(G4int ver)
: G4VPhysicsConstructor("G4EmStandard_opt3"), verbose(ver)
{
G4LossTableManager::Instance();
SetPhysicsType(bElectromagnetic);
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
G4EmStandardPhysics_option3::G4EmStandardPhysics_option3(G4int ver, const G4String&)
: G4VPhysicsConstructor("G4EmStandard_opt3"), verbose(ver)
{
G4LossTableManager::Instance();
SetPhysicsType(bElectromagnetic);
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
G4EmStandardPhysics_option3::~G4EmStandardPhysics_option3()
{}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void G4EmStandardPhysics_option3::ConstructParticle()
{
// gamma
G4Gamma::Gamma();
// leptons
G4Electron::Electron();
G4Positron::Positron();
G4MuonPlus::MuonPlus();
G4MuonMinus::MuonMinus();
// mesons
G4PionPlus::PionPlusDefinition();
G4PionMinus::PionMinusDefinition();
G4KaonPlus::KaonPlusDefinition();
G4KaonMinus::KaonMinusDefinition();
// barions
G4Proton::Proton();
G4AntiProton::AntiProton();
// ions
G4Deuteron::Deuteron();
G4Triton::Triton();
G4He3::He3();
G4Alpha::Alpha();
G4GenericIon::GenericIonDefinition();
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void G4EmStandardPhysics_option3::ConstructProcess()
{
if(verbose > 1) {
G4cout << "### " << GetPhysicsName() << " Construct Processes " << G4endl;
}
G4PhysicsListHelper* ph = G4PhysicsListHelper::GetPhysicsListHelper();
// muon & hadron bremsstrahlung and pair production
G4MuBremsstrahlung* mub = new G4MuBremsstrahlung();
G4MuPairProduction* mup = new G4MuPairProduction();
G4hBremsstrahlung* pib = new G4hBremsstrahlung();
G4hPairProduction* pip = new G4hPairProduction();
G4hBremsstrahlung* kb = new G4hBremsstrahlung();
G4hPairProduction* kp = new G4hPairProduction();
G4hBremsstrahlung* pb = new G4hBremsstrahlung();
G4hPairProduction* pp = new G4hPairProduction();
// muon & hadron multiple scattering
G4MuMultipleScattering* mumsc = new G4MuMultipleScattering();
mumsc->AddEmModel(0, new G4WentzelVIModel());
//G4hMultipleScattering* pimsc = new G4hMultipleScattering();
// pimsc->AddEmModel(0, new G4WentzelVIModel());
// G4hMultipleScattering* kmsc = new G4hMultipleScattering();
// kmsc->AddEmModel(0, new G4WentzelVIModel());
//G4hMultipleScattering* pmsc = new G4hMultipleScattering();
//pmsc->AddEmModel(0, new G4WentzelVIModel());
G4hMultipleScattering* hmsc = new G4hMultipleScattering("ionmsc");
// nuclear stopping
G4NuclearStopping* ionnuc = new G4NuclearStopping();
G4NuclearStopping* pnuc = new G4NuclearStopping();
// Add standard EM Processes
aParticleIterator->reset();
while( (*aParticleIterator)() ){
G4ParticleDefinition* particle = aParticleIterator->value();
G4String particleName = particle->GetParticleName();
if (particleName == "gamma") {
G4ComptonScattering* cs = new G4ComptonScattering;
cs->SetEmModel(new G4KleinNishinaModel());
ph->RegisterProcess(new G4PhotoElectricEffect(), particle);
ph->RegisterProcess(cs, particle);
ph->RegisterProcess(new G4GammaConversion(), particle);
ph->RegisterProcess(new G4RayleighScattering(), particle);
} else if (particleName == "e-") {
G4eMultipleScattering* msc = new G4eMultipleScattering();
//msc->AddEmModel(0, new G4UrbanMscModel());
msc->SetStepLimitType(fUseDistanceToBoundary);
G4eIonisation* eIoni = new G4eIonisation();
eIoni->SetStepFunction(0.2, 100*um);
G4eBremsstrahlung* brem = new G4eBremsstrahlung();
ph->RegisterProcess(msc, particle);
ph->RegisterProcess(eIoni, particle);
ph->RegisterProcess(brem, particle);
} else if (particleName == "e+") {
G4eMultipleScattering* msc = new G4eMultipleScattering();
//msc->AddEmModel(0, new G4UrbanMscModel());
msc->SetStepLimitType(fUseDistanceToBoundary);
G4eIonisation* eIoni = new G4eIonisation();
eIoni->SetStepFunction(0.2, 100*um);
ph->RegisterProcess(msc, particle);
ph->RegisterProcess(eIoni, particle);
ph->RegisterProcess(new G4eBremsstrahlung(), particle);
ph->RegisterProcess(new G4eplusAnnihilation(), particle);
} else if (particleName == "mu+" ||
particleName == "mu-" ) {
G4MuIonisation* muIoni = new G4MuIonisation();
muIoni->SetStepFunction(0.2, 50*um);
ph->RegisterProcess(mumsc, particle);
ph->RegisterProcess(muIoni, particle);
ph->RegisterProcess(mub, particle);
ph->RegisterProcess(mup, particle);
ph->RegisterProcess(new G4CoulombScattering(), particle);
} else if (particleName == "alpha" ||
particleName == "He3") {
G4hMultipleScattering* msc = new G4hMultipleScattering();
G4ionIonisation* ionIoni = new G4ionIonisation();
ionIoni->SetStepFunction(0.1, 10*um);
ph->RegisterProcess(msc, particle);
ph->RegisterProcess(ionIoni, particle);
ph->RegisterProcess(ionnuc, particle);
} else if (particleName == "GenericIon") {
G4ionIonisation* ionIoni = new G4ionIonisation();
ionIoni->SetEmModel(new G4IonParametrisedLossModel());
ionIoni->SetStepFunction(0.1, 1*um);
ph->RegisterProcess(hmsc, particle);
ph->RegisterProcess(ionIoni, particle);
ph->RegisterProcess(ionnuc, particle);
} else if (particleName == "pi+" ||
particleName == "pi-" ) {
G4hMultipleScattering* pimsc = new G4hMultipleScattering();
G4hIonisation* hIoni = new G4hIonisation();
hIoni->SetStepFunction(0.2, 50*um);
ph->RegisterProcess(pimsc, particle);
ph->RegisterProcess(hIoni, particle);
ph->RegisterProcess(pib, particle);
ph->RegisterProcess(pip, particle);
} else if (particleName == "kaon+" ||
particleName == "kaon-" ) {
G4hMultipleScattering* kmsc = new G4hMultipleScattering();
G4hIonisation* hIoni = new G4hIonisation();
hIoni->SetStepFunction(0.2, 50*um);
ph->RegisterProcess(kmsc, particle);
ph->RegisterProcess(hIoni, particle);
ph->RegisterProcess(kb, particle);
ph->RegisterProcess(kp, particle);
} else if (particleName == "proton" ||
particleName == "anti_proton") {
G4hMultipleScattering* pmsc = new G4hMultipleScattering();
G4hIonisation* hIoni = new G4hIonisation();
hIoni->SetStepFunction(0.2, 50*um);
ph->RegisterProcess(pmsc, particle);
ph->RegisterProcess(hIoni, particle);
ph->RegisterProcess(pb, particle);
ph->RegisterProcess(pp, particle);
ph->RegisterProcess(pnuc, particle);
} else if (particleName == "B+" ||
particleName == "B-" ||
particleName == "D+" ||
particleName == "D-" ||
particleName == "Ds+" ||
particleName == "Ds-" ||
particleName == "anti_He3" ||
particleName == "anti_alpha" ||
particleName == "anti_deuteron" ||
particleName == "anti_lambda_c+" ||
particleName == "anti_omega-" ||
particleName == "anti_sigma_c+" ||
particleName == "anti_sigma_c++" ||
particleName == "anti_sigma+" ||
particleName == "anti_sigma-" ||
particleName == "anti_triton" ||
particleName == "anti_xi_c+" ||
particleName == "anti_xi-" ||
particleName == "deuteron" ||
particleName == "lambda_c+" ||
particleName == "omega-" ||
particleName == "sigma_c+" ||
particleName == "sigma_c++" ||
particleName == "sigma+" ||
particleName == "sigma-" ||
particleName == "tau+" ||
particleName == "tau-" ||
particleName == "triton" ||
particleName == "xi_c+" ||
particleName == "xi-" ) {
ph->RegisterProcess(hmsc, particle);
ph->RegisterProcess(new G4hIonisation(), particle);
}
}
// Em options
//
G4EmProcessOptions opt;
opt.SetVerbose(verbose);
// Multiple Coulomb scattering
//
opt.SetPolarAngleLimit(CLHEP::pi);
// Physics tables
//
opt.SetMinEnergy(10*eV);
opt.SetMaxEnergy(10*TeV);
opt.SetDEDXBinning(240);
opt.SetLambdaBinning(240);
// Nuclear stopping
pnuc->SetMaxKinEnergy(MeV);
// Ionization
//
//opt.SetSubCutoff(true);
// Deexcitation
G4VAtomDeexcitation* de = new G4UAtomicDeexcitation();
G4LossTableManager::Instance()->SetAtomDeexcitation(de);
de->SetFluo(true);
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
source/physics_lists/constructors/electromagnetic/src/G4EmStandardPhysics_option4.cc
+449
View File
@@ -0,0 +1,449 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4EmStandardPhysics_option4.cc 73153 2013-08-20 07:17:42Z gcosmo $
//
//---------------------------------------------------------------------------
//
// ClassName: G4EmStandardPhysics_option4
//
// Author: V.Ivanchenko 28.09.2012 from Option3 physics constructor
//
// Modified:
//
//----------------------------------------------------------------------------
//
#include "G4EmStandardPhysics_option4.hh"
#include "G4SystemOfUnits.hh"
#include "G4ParticleDefinition.hh"
#include "G4LossTableManager.hh"
#include "G4EmProcessOptions.hh"
#include "G4ComptonScattering.hh"
#include "G4GammaConversion.hh"
#include "G4PhotoElectricEffect.hh"
#include "G4RayleighScattering.hh"
#include "G4PEEffectFluoModel.hh"
#include "G4KleinNishinaModel.hh"
#include "G4LowEPComptonModel.hh"
#include "G4PenelopeGammaConversionModel.hh"
#include "G4LivermorePhotoElectricModel.hh"
#include "G4eMultipleScattering.hh"
#include "G4MuMultipleScattering.hh"
#include "G4hMultipleScattering.hh"
#include "G4MscStepLimitType.hh"
#include "G4UrbanMscModel.hh"
#include "G4DummyModel.hh"
#include "G4WentzelVIModel.hh"
#include "G4CoulombScattering.hh"
#include "G4eCoulombScatteringModel.hh"
#include "G4eIonisation.hh"
#include "G4eBremsstrahlung.hh"
#include "G4Generator2BS.hh"
#include "G4Generator2BN.hh"
#include "G4SeltzerBergerModel.hh"
#include "G4PenelopeIonisationModel.hh"
#include "G4UniversalFluctuation.hh"
#include "G4eplusAnnihilation.hh"
#include "G4UAtomicDeexcitation.hh"
#include "G4MuIonisation.hh"
#include "G4MuBremsstrahlung.hh"
#include "G4MuPairProduction.hh"
#include "G4hBremsstrahlung.hh"
#include "G4hPairProduction.hh"
#include "G4MuBremsstrahlungModel.hh"
#include "G4MuPairProductionModel.hh"
#include "G4hBremsstrahlungModel.hh"
#include "G4hPairProductionModel.hh"
#include "G4hIonisation.hh"
#include "G4ionIonisation.hh"
#include "G4IonParametrisedLossModel.hh"
#include "G4NuclearStopping.hh"
#include "G4Gamma.hh"
#include "G4Electron.hh"
#include "G4Positron.hh"
#include "G4MuonPlus.hh"
#include "G4MuonMinus.hh"
#include "G4PionPlus.hh"
#include "G4PionMinus.hh"
#include "G4KaonPlus.hh"
#include "G4KaonMinus.hh"
#include "G4Proton.hh"
#include "G4AntiProton.hh"
#include "G4Deuteron.hh"
#include "G4Triton.hh"
#include "G4He3.hh"
#include "G4Alpha.hh"
#include "G4GenericIon.hh"
#include "G4PhysicsListHelper.hh"
#include "G4BuilderType.hh"
// factory
#include "G4PhysicsConstructorFactory.hh"
//
G4_DECLARE_PHYSCONSTR_FACTORY(G4EmStandardPhysics_option4);
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
G4EmStandardPhysics_option4::G4EmStandardPhysics_option4(G4int ver)
: G4VPhysicsConstructor("G4EmStandard_opt4"), verbose(ver)
{
G4LossTableManager::Instance();
SetPhysicsType(bElectromagnetic);
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
G4EmStandardPhysics_option4::G4EmStandardPhysics_option4(G4int ver, const G4String&)
: G4VPhysicsConstructor("G4EmStandard_opt3"), verbose(ver)
{
G4LossTableManager::Instance();
SetPhysicsType(bElectromagnetic);
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
G4EmStandardPhysics_option4::~G4EmStandardPhysics_option4()
{}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void G4EmStandardPhysics_option4::ConstructParticle()
{
// gamma
G4Gamma::Gamma();
// leptons
G4Electron::Electron();
G4Positron::Positron();
G4MuonPlus::MuonPlus();
G4MuonMinus::MuonMinus();
// mesons
G4PionPlus::PionPlusDefinition();
G4PionMinus::PionMinusDefinition();
G4KaonPlus::KaonPlusDefinition();
G4KaonMinus::KaonMinusDefinition();
// barions
G4Proton::Proton();
G4AntiProton::AntiProton();
// ions
G4Deuteron::Deuteron();
G4Triton::Triton();
G4He3::He3();
G4Alpha::Alpha();
G4GenericIon::GenericIonDefinition();
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void G4EmStandardPhysics_option4::ConstructProcess()
{
if(verbose > 1) {
G4cout << "### " << GetPhysicsName() << " Construct Processes " << G4endl;
}
G4PhysicsListHelper* ph = G4PhysicsListHelper::GetPhysicsListHelper();
// muon & hadron bremsstrahlung and pair production
G4MuBremsstrahlung* mub = new G4MuBremsstrahlung();
G4MuPairProduction* mup = new G4MuPairProduction();
G4hBremsstrahlung* pib = new G4hBremsstrahlung();
G4hPairProduction* pip = new G4hPairProduction();
G4hBremsstrahlung* kb = new G4hBremsstrahlung();
G4hPairProduction* kp = new G4hPairProduction();
G4hBremsstrahlung* pb = new G4hBremsstrahlung();
G4hPairProduction* pp = new G4hPairProduction();
// muon & hadron multiple scattering
G4MuMultipleScattering* mumsc = new G4MuMultipleScattering();
mumsc->AddEmModel(0, new G4WentzelVIModel());
G4hMultipleScattering* pimsc = new G4hMultipleScattering();
pimsc->AddEmModel(0, new G4WentzelVIModel());
G4hMultipleScattering* kmsc = new G4hMultipleScattering();
kmsc->AddEmModel(0, new G4WentzelVIModel());
G4hMultipleScattering* pmsc = new G4hMultipleScattering();
pmsc->AddEmModel(0, new G4WentzelVIModel());
G4hMultipleScattering* hmsc = new G4hMultipleScattering("ionmsc");
// high energy limit for e+- scattering models
G4double highEnergyLimit = 100*MeV;
// nuclear stopping
G4NuclearStopping* ionnuc = new G4NuclearStopping();
G4NuclearStopping* pnuc = new G4NuclearStopping();
// Add standard EM Processes
aParticleIterator->reset();
while( (*aParticleIterator)() ){
G4ParticleDefinition* particle = aParticleIterator->value();
G4String particleName = particle->GetParticleName();
if (particleName == "gamma") {
// Compton scattering
G4ComptonScattering* cs = new G4ComptonScattering;
cs->SetEmModel(new G4KleinNishinaModel(),1);
G4VEmModel* theLowEPComptonModel = new G4LowEPComptonModel();
theLowEPComptonModel->SetHighEnergyLimit(20*MeV);
cs->AddEmModel(0, theLowEPComptonModel);
ph->RegisterProcess(cs, particle);
// Photoelectric
G4PhotoElectricEffect* pe = new G4PhotoElectricEffect();
G4VEmModel* theLivermorePEModel = new G4LivermorePhotoElectricModel();
theLivermorePEModel->SetHighEnergyLimit(10*GeV);
pe->SetEmModel(theLivermorePEModel,1);
ph->RegisterProcess(pe, particle);
// Gamma conversion
G4GammaConversion* gc = new G4GammaConversion();
G4VEmModel* thePenelopeGCModel = new G4PenelopeGammaConversionModel();
thePenelopeGCModel->SetHighEnergyLimit(1*GeV);
gc->SetEmModel(thePenelopeGCModel,1);
ph->RegisterProcess(gc, particle);
// Rayleigh scattering
ph->RegisterProcess(new G4RayleighScattering(), particle);
} else if (particleName == "e-") {
// multiple scattering
G4eMultipleScattering* msc = new G4eMultipleScattering;
msc->SetStepLimitType(fUseDistanceToBoundary);
G4UrbanMscModel* msc1 = new G4UrbanMscModel();
G4WentzelVIModel* msc2 = new G4WentzelVIModel();
msc1->SetHighEnergyLimit(highEnergyLimit);
msc2->SetLowEnergyLimit(highEnergyLimit);
msc->AddEmModel(0, msc1);
msc->AddEmModel(0, msc2);
G4eCoulombScatteringModel* ssm = new G4eCoulombScatteringModel();
G4CoulombScattering* ss = new G4CoulombScattering();
ss->SetEmModel(ssm, 1);
ss->SetMinKinEnergy(highEnergyLimit);
ssm->SetLowEnergyLimit(highEnergyLimit);
ssm->SetActivationLowEnergyLimit(highEnergyLimit);
// ionisation
G4eIonisation* eIoni = new G4eIonisation();
eIoni->SetStepFunction(0.2, 100*um);
G4VEmModel* theIoniPenelope = new G4PenelopeIonisationModel();
theIoniPenelope->SetHighEnergyLimit(0.1*MeV);
eIoni->AddEmModel(0, theIoniPenelope, new G4UniversalFluctuation());
// bremsstrahlung
G4eBremsstrahlung* eBrem = new G4eBremsstrahlung();
ph->RegisterProcess(msc, particle);
ph->RegisterProcess(eIoni, particle);
ph->RegisterProcess(eBrem, particle);
ph->RegisterProcess(ss, particle);
} else if (particleName == "e+") {
// multiple scattering
G4eMultipleScattering* msc = new G4eMultipleScattering;
msc->SetStepLimitType(fUseDistanceToBoundary);
G4UrbanMscModel* msc1 = new G4UrbanMscModel();
G4WentzelVIModel* msc2 = new G4WentzelVIModel();
msc1->SetHighEnergyLimit(highEnergyLimit);
msc2->SetLowEnergyLimit(highEnergyLimit);
msc->AddEmModel(0, msc1);
msc->AddEmModel(0, msc2);
G4eCoulombScatteringModel* ssm = new G4eCoulombScatteringModel();
G4CoulombScattering* ss = new G4CoulombScattering();
ss->SetEmModel(ssm, 1);
ss->SetMinKinEnergy(highEnergyLimit);
ssm->SetLowEnergyLimit(highEnergyLimit);
ssm->SetActivationLowEnergyLimit(highEnergyLimit);
// ionisation
G4eIonisation* eIoni = new G4eIonisation();
eIoni->SetStepFunction(0.2, 100*um);
G4VEmModel* theIoniPenelope = new G4PenelopeIonisationModel();
theIoniPenelope->SetHighEnergyLimit(0.1*MeV);
eIoni->AddEmModel(0, theIoniPenelope, new G4UniversalFluctuation());
// bremsstrahlung
G4eBremsstrahlung* eBrem = new G4eBremsstrahlung();
ph->RegisterProcess(msc, particle);
ph->RegisterProcess(eIoni, particle);
ph->RegisterProcess(eBrem, particle);
ph->RegisterProcess(ss, particle);
// annihilation at rest and in flight
ph->RegisterProcess(new G4eplusAnnihilation(), particle);
} else if (particleName == "mu+" ||
particleName == "mu-" ) {
G4MuIonisation* muIoni = new G4MuIonisation();
muIoni->SetStepFunction(0.2, 50*um);
ph->RegisterProcess(mumsc, particle);
ph->RegisterProcess(muIoni, particle);
ph->RegisterProcess(mub, particle);
ph->RegisterProcess(mup, particle);
ph->RegisterProcess(new G4CoulombScattering(), particle);
} else if (particleName == "alpha" ||
particleName == "He3") {
G4hMultipleScattering* msc = new G4hMultipleScattering();
G4ionIonisation* ionIoni = new G4ionIonisation();
ionIoni->SetStepFunction(0.1, 10*um);
ph->RegisterProcess(msc, particle);
ph->RegisterProcess(ionIoni, particle);
ph->RegisterProcess(ionnuc, particle);
} else if (particleName == "GenericIon") {
G4ionIonisation* ionIoni = new G4ionIonisation();
ionIoni->SetEmModel(new G4IonParametrisedLossModel());
ionIoni->SetStepFunction(0.1, 1*um);
ph->RegisterProcess(hmsc, particle);
ph->RegisterProcess(ionIoni, particle);
ph->RegisterProcess(ionnuc, particle);
} else if (particleName == "pi+" ||
particleName == "pi-" ) {
//G4hMultipleScattering* pimsc = new G4hMultipleScattering();
G4hIonisation* hIoni = new G4hIonisation();
hIoni->SetStepFunction(0.2, 50*um);
ph->RegisterProcess(pimsc, particle);
ph->RegisterProcess(hIoni, particle);
ph->RegisterProcess(pib, particle);
ph->RegisterProcess(pip, particle);
} else if (particleName == "kaon+" ||
particleName == "kaon-" ) {
//G4hMultipleScattering* kmsc = new G4hMultipleScattering();
G4hIonisation* hIoni = new G4hIonisation();
hIoni->SetStepFunction(0.2, 50*um);
ph->RegisterProcess(kmsc, particle);
ph->RegisterProcess(hIoni, particle);
ph->RegisterProcess(kb, particle);
ph->RegisterProcess(kp, particle);
} else if (particleName == "proton" ||
particleName == "anti_proton") {
//G4hMultipleScattering* pmsc = new G4hMultipleScattering();
G4hIonisation* hIoni = new G4hIonisation();
hIoni->SetStepFunction(0.2, 50*um);
ph->RegisterProcess(pmsc, particle);
ph->RegisterProcess(hIoni, particle);
ph->RegisterProcess(pb, particle);
ph->RegisterProcess(pp, particle);
ph->RegisterProcess(pnuc, particle);
} else if (particleName == "B+" ||
particleName == "B-" ||
particleName == "D+" ||
particleName == "D-" ||
particleName == "Ds+" ||
particleName == "Ds-" ||
particleName == "anti_He3" ||
particleName == "anti_alpha" ||
particleName == "anti_deuteron" ||
particleName == "anti_lambda_c+" ||
particleName == "anti_omega-" ||
particleName == "anti_sigma_c+" ||
particleName == "anti_sigma_c++" ||
particleName == "anti_sigma+" ||
particleName == "anti_sigma-" ||
particleName == "anti_triton" ||
particleName == "anti_xi_c+" ||
particleName == "anti_xi-" ||
particleName == "deuteron" ||
particleName == "lambda_c+" ||
particleName == "omega-" ||
particleName == "sigma_c+" ||
particleName == "sigma_c++" ||
particleName == "sigma+" ||
particleName == "sigma-" ||
particleName == "tau+" ||
particleName == "tau-" ||
particleName == "triton" ||
particleName == "xi_c+" ||
particleName == "xi-" ) {
ph->RegisterProcess(hmsc, particle);
ph->RegisterProcess(new G4hIonisation(), particle);
ph->RegisterProcess(pnuc, particle);
}
}
// Em options
//
G4EmProcessOptions opt;
opt.SetVerbose(verbose);
// Multiple Coulomb scattering
//
opt.SetPolarAngleLimit(CLHEP::pi);
// Physics tables
//
opt.SetMinEnergy(100*eV);
opt.SetMaxEnergy(10*TeV);
opt.SetDEDXBinning(220);
opt.SetLambdaBinning(220);
// Nuclear stopping
pnuc->SetMaxKinEnergy(MeV);
// Ionization
//
//opt.SetSubCutoff(true);
// Deexcitation
G4VAtomDeexcitation* de = new G4UAtomicDeexcitation();
G4LossTableManager::Instance()->SetAtomDeexcitation(de);
de->SetFluo(true);
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
source/physics_lists/constructors/electromagnetic/src/G4OpticalPhysics.cc
+365
View File
@@ -0,0 +1,365 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
//
//---------------------------------------------------------------------------
//
// ClassName: G4OpticalPhysics
//
// Author: P.Gumplinger 30.09.2009
//
// Modified: P.Gumplinger 29.09.2011
// (based on code from I. Hrivnacova)
//
//----------------------------------------------------------------------------
//
#include "G4OpticalPhysics.hh"
#include "G4LossTableManager.hh"
#include "G4EmSaturation.hh"
G4ThreadLocal G4bool G4OpticalPhysics::wasActivated = false;
// factory
#include "G4PhysicsConstructorFactory.hh"
//
G4_DECLARE_PHYSCONSTR_FACTORY(G4OpticalPhysics);
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
G4OpticalPhysics::G4OpticalPhysics(G4int verbose, const G4String& name)
: G4VPhysicsConstructor(name),
fScintillationProcess(NULL),
fCerenkovProcess(NULL),
fOpWLSProcess(NULL),
fOpAbsorptionProcess(NULL),
fOpRayleighScatteringProcess(NULL),
fOpMieHGScatteringProcess(NULL),
fOpBoundaryProcess(NULL),
fMaxNumPhotons(100),
fMaxBetaChange(10.0),
fYieldFactor(1.),
fExcitationRatio(0.0),
fProfile("delta"),
fFiniteRiseTime(false),
fScintillationByParticleType(false)
{
verboseLevel = verbose;
fMessenger = new G4OpticalPhysicsMessenger(this);
for ( G4int i=0; i<kNoProcess; i++ ) {
fProcesses.push_back(NULL);
fProcessUse.push_back(true);
fProcessVerbose.push_back(verbose);
fProcessTrackSecondariesFirst.push_back(true);
}
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
G4OpticalPhysics::~G4OpticalPhysics()
{
delete fMessenger;
// Process objects are deleted elsewhere.
/************* if (wasActivated) {
if (fScintillationProcess) delete fScintillationProcess;
if (fCerenkovProcess) delete fCerenkovProcess;
if (fOpWLSProcess) delete fOpWLSProcess;
if (fOpAbsorptionProcess) delete fOpAbsorptionProcess;
if (fOpRayleighScatteringProcess) delete fOpRayleighScatteringProcess;
if (fOpMieHGScatteringProcess) delete fOpMieHGScatteringProcess;
if (fOpBoundaryProcess) delete fOpBoundaryProcess;
wasActivated = false;
} ************************/
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void G4OpticalPhysics::PrintStatistics() const
{
// Print all processes activation and their parameters
for ( G4int i=0; i<kNoProcess; i++ ) {
G4cout << " " << G4OpticalProcessName(i) << " process: ";
if ( ! fProcessUse[i] ) {
G4cout << "not used" << G4endl;
}
else {
G4cout << "used" << G4endl;
if ( i == kCerenkov ) {
G4cout << " Max number of photons per step: " << fMaxNumPhotons << G4endl;
G4cout << " Max beta change per step: " << fMaxBetaChange << G4endl;
if ( fProcessTrackSecondariesFirst[kCerenkov] ) G4cout << " Track secondaries first: activated" << G4endl;
}
if ( i == kScintillation ) {
if (fScintillationByParticleType)
G4cout << " Scintillation by Particle Type: activated " << G4endl;
G4cout << " Yield factor: " << fYieldFactor << G4endl;
G4cout << " ExcitationRatio: " << fExcitationRatio << G4endl;
if ( fProcessTrackSecondariesFirst[kScintillation] ) G4cout << " Track secondaries first: activated" << G4endl;
}
if ( i == kWLS ) {
G4cout << " WLS process time profile: " << fProfile << G4endl;
}
}
}
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
#include "G4OpticalPhoton.hh"
void G4OpticalPhysics::ConstructParticle()
{
/// Instantiate particles.
// optical photon
G4OpticalPhoton::OpticalPhotonDefinition();
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
#include "G4ParticleDefinition.hh"
#include "G4ProcessManager.hh"
void G4OpticalPhysics::ConstructProcess()
{
// Construct optical processes.
if (wasActivated) return;
if(verboseLevel>0)
G4cout <<"G4OpticalPhysics:: Add Optical Physics Processes"<< G4endl;
// Add Optical Processes
fProcesses[kAbsorption] = fOpAbsorptionProcess = new G4OpAbsorption();
fProcesses[kRayleigh] = fOpRayleighScatteringProcess = new G4OpRayleigh();
fProcesses[kMieHG] = fOpMieHGScatteringProcess = new G4OpMieHG();
fProcesses[kBoundary] = fOpBoundaryProcess = new G4OpBoundaryProcess();
fProcesses[kWLS] = fOpWLSProcess = new G4OpWLS();
fOpWLSProcess->UseTimeProfile(fProfile);
G4ProcessManager * pManager = 0;
pManager = G4OpticalPhoton::OpticalPhoton()->GetProcessManager();
if (!pManager) {
std::ostringstream o;
o << "Optical Photon without a Process Manager";
G4Exception("G4OpticalPhysics::ConstructProcess()","",
FatalException,o.str().c_str());
return;
}
for ( G4int i=kAbsorption; i<=kWLS; i++ ) {
if ( fProcessUse[i] ) {
pManager->AddDiscreteProcess(fProcesses[i]);
}
}
fProcesses[kScintillation] = fScintillationProcess = new G4Scintillation();
fScintillationProcess->SetScintillationYieldFactor(fYieldFactor);
fScintillationProcess->SetScintillationExcitationRatio(fExcitationRatio);
fScintillationProcess->SetFiniteRiseTime(fFiniteRiseTime);
fScintillationProcess->SetScintillationByParticleType(fScintillationByParticleType);
fScintillationProcess->
SetTrackSecondariesFirst(fProcessTrackSecondariesFirst[kScintillation]);
// Use Birks Correction in the Scintillation process
G4EmSaturation* emSaturation = G4LossTableManager::Instance()->EmSaturation();
fScintillationProcess->AddSaturation(emSaturation);
fProcesses[kCerenkov] = fCerenkovProcess = new G4Cerenkov();
fCerenkovProcess->SetMaxNumPhotonsPerStep(fMaxNumPhotons);
fCerenkovProcess->SetMaxBetaChangePerStep(fMaxBetaChange);
fCerenkovProcess->
SetTrackSecondariesFirst(fProcessTrackSecondariesFirst[kCerenkov]);
aParticleIterator->reset();
while( (*aParticleIterator)() ){
G4ParticleDefinition* particle = aParticleIterator->value();
G4String particleName = particle->GetParticleName();
pManager = particle->GetProcessManager();
if (!pManager) {
std::ostringstream o;
o << "Particle " << particleName << "without a Process Manager";
G4Exception("G4OpticalPhysics::ConstructProcess()","",
FatalException,o.str().c_str());
return; // else coverity complains for pManager use below
}
if( fCerenkovProcess->IsApplicable(*particle) &&
fProcessUse[kCerenkov] ) {
pManager->AddProcess(fCerenkovProcess);
pManager->SetProcessOrdering(fCerenkovProcess,idxPostStep);
}
if( fScintillationProcess->IsApplicable(*particle) &&
fProcessUse[kScintillation] ){
pManager->AddProcess(fScintillationProcess);
pManager->SetProcessOrderingToLast(fScintillationProcess,idxAtRest);
pManager->SetProcessOrderingToLast(fScintillationProcess,idxPostStep);
}
}
// Add verbose
for ( G4int i=0; i<kNoProcess; i++ ) {
fProcesses[i]->SetVerboseLevel(fProcessVerbose[i]);
}
if (verboseLevel > 1) PrintStatistics();
if (verboseLevel > 0)
G4cout << "### " << namePhysics << " physics constructed." << G4endl;
wasActivated = true;
}
void G4OpticalPhysics::SetScintillationYieldFactor(G4double yieldFactor)
{
/// Set the scintillation yield factor
fYieldFactor = yieldFactor;
if(fScintillationProcess)
fScintillationProcess->SetScintillationYieldFactor(yieldFactor);
}
void G4OpticalPhysics::SetScintillationExcitationRatio(G4double excitationRatio)
{
/// Set the scintillation excitation ratio
fExcitationRatio = excitationRatio;
if(fScintillationProcess)
fScintillationProcess->SetScintillationExcitationRatio(excitationRatio);
}
void G4OpticalPhysics::SetMaxNumPhotonsPerStep(G4int maxNumPhotons)
{
/// Limit step to the specified maximum number of Cherenkov photons
fMaxNumPhotons = maxNumPhotons;
if(fCerenkovProcess)
fCerenkovProcess->SetMaxNumPhotonsPerStep(maxNumPhotons);
}
void G4OpticalPhysics::SetMaxBetaChangePerStep(G4double maxBetaChange)
{
/// Limit step to the specified maximum change of beta of the parent particle
fMaxBetaChange = maxBetaChange;
if(fCerenkovProcess)
fCerenkovProcess->SetMaxBetaChangePerStep(maxBetaChange);
}
void G4OpticalPhysics::SetWLSTimeProfile(G4String profile)
{
/// Set the WLS time profile (delta or exponential)
fProfile = profile;
if(fOpWLSProcess)
fOpWLSProcess->UseTimeProfile(fProfile);
}
void G4OpticalPhysics::AddScintillationSaturation(G4EmSaturation* saturation)
{
/// Adds Birks Saturation to the G4Scintillation Process
if(fScintillationProcess)
fScintillationProcess->AddSaturation(saturation);
}
void G4OpticalPhysics::SetScintillationByParticleType(G4bool scintillationByParticleType)
{
fScintillationByParticleType = scintillationByParticleType;
if (fScintillationProcess)
fScintillationProcess->SetScintillationByParticleType(scintillationByParticleType);
}
void G4OpticalPhysics::SetTrackSecondariesFirst(G4OpticalProcessIndex index,
G4bool trackSecondariesFirst)
{
if ( index >= kNoProcess ) return;
if ( fProcessTrackSecondariesFirst[index] == trackSecondariesFirst ) return;
fProcessTrackSecondariesFirst[index] = trackSecondariesFirst;
if(fCerenkovProcess && index == kCerenkov )
fCerenkovProcess->SetTrackSecondariesFirst(trackSecondariesFirst);
if(fScintillationProcess && index == kScintillation)
fScintillationProcess->SetTrackSecondariesFirst(trackSecondariesFirst);
}
void G4OpticalPhysics::SetFiniteRiseTime(G4bool finiteRiseTime)
{
fFiniteRiseTime = finiteRiseTime;
if(fScintillationProcess)
fScintillationProcess->SetFiniteRiseTime(finiteRiseTime);
}
void G4OpticalPhysics::Configure(G4OpticalProcessIndex index, G4bool isUse)
{
// Configure the physics constructor to use/not use a selected process.
// This method can only be called in PreInit> phase (before execution of
// ConstructProcess). The process is not added to particle's process manager
// and so it cannot be re-activated later in Idle> phase with the command
// /process/activate.
if ( index >= kNoProcess ) return;
if ( fProcessUse[index] == isUse ) return;
fProcessUse[index] = isUse;
}
void G4OpticalPhysics::SetProcessVerbose(G4int index,
G4int inputVerboseLevel)
{
// Set new verbose level to a selected process
if ( index >= kNoProcess ) return;
if ( fProcessVerbose[index] == inputVerboseLevel ) return;
fProcessVerbose[index] = inputVerboseLevel;
if ( fProcesses[index] ) fProcesses[index]->SetVerboseLevel(inputVerboseLevel);
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
source/physics_lists/constructors/electromagnetic/src/G4OpticalPhysicsMessenger.cc
+269
View File
@@ -0,0 +1,269 @@
//
// ********************************************************************
// * 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: G4OpticalPhysicsMessenger
//
// Author: P.Gumplinger 30.09.2009 //
//
// Modified: P.Gumplinger 29.09.2011
// (based on code from I. Hrivnacova)
//
//----------------------------------------------------------------------------
//
#include "G4OpticalPhysicsMessenger.hh"
#include "G4OpticalPhysics.hh"
#include "G4UIcommand.hh"
#include "G4UIdirectory.hh"
#include "G4UIcommand.hh"
#include "G4UIdirectory.hh"
#include "G4UIcmdWithABool.hh"
#include "G4UIcmdWithAString.hh"
#include "G4UIcmdWithADouble.hh"
#include "G4UIcmdWithAnInteger.hh"
#include "G4UIcmdWithADoubleAndUnit.hh"
#include "G4ParticleTable.hh"
#include "G4ProcessVector.hh"
#include "G4ProcessManager.hh"
#include "G4ParticleDefinition.hh"
//_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_
G4OpticalPhysicsMessenger::G4OpticalPhysicsMessenger(
G4OpticalPhysics* opticalPhysics)
: G4UImessenger(),
fOpticalPhysics(opticalPhysics),
fSelectedProcessIndex(kNoProcess),
fSelectOpProcessCmd(0),
fSetOpProcessUseCmd(0),
fSetOpProcessVerboseCmd(0),
fSetCerenkovMaxPhotonsCmd(0),
fSetCerenkovMaxBetaChangeCmd(0),
fSetScintillationYieldFactorCmd(0),
fSetScintillationByParticleTypeCmd(0),
// fSetOpticalSurfaceModelCmd(0),
fSetWLSTimeProfileCmd(0),
fSetTrackSecondariesFirstCmd(0),
fSetFiniteRiseTimeCmd(0)
{
fDir = new G4UIdirectory("/optics_engine/");
fDir->SetGuidance("Commands related to the optical physics simulation engine.");
fSelectOpProcessCmd
= new G4UIcmdWithAString("/optics_engine/selectOpProcess", this);
fSelectOpProcessCmd
->SetGuidance("Select optical process for applying use/verbose/trackfirst commands");
fSelectOpProcessCmd->SetParameterName("OpProcess", false);
G4String candidates;
for ( G4int i=0; i<kNoProcess; i++ ) {
candidates += G4OpticalProcessName(i);
candidates += G4String(" ");
}
fSelectOpProcessCmd->SetCandidates(candidates);
fSelectOpProcessCmd->AvailableForStates(G4State_PreInit, G4State_Idle, G4State_GeomClosed, G4State_EventProc);
fSetOpProcessUseCmd
= new G4UIcmdWithABool("/optics_engine/setOpProcessUse", this);
fSetOpProcessUseCmd->SetGuidance("Use/Not use selected optical process");
fSetOpProcessUseCmd->SetParameterName("OpProcessUse", false);
fSetOpProcessUseCmd->AvailableForStates(G4State_PreInit);
fSetOpProcessVerboseCmd
= new G4UIcmdWithAnInteger("/optics_engine/setOpProcessVerbose", this);
fSetOpProcessVerboseCmd->SetGuidance("Set verbosity level for selected optical process");
fSetOpProcessVerboseCmd->SetParameterName("OpProcessVerbose", false);
fSetOpProcessVerboseCmd->SetRange("OpProcessVerbose>=0");
fSetOpProcessVerboseCmd->AvailableForStates(G4State_PreInit, G4State_Idle, G4State_GeomClosed, G4State_EventProc);
fSetCerenkovMaxPhotonsCmd
= new G4UIcmdWithAnInteger("/optics_engine/setCerenkovMaxPhotons", this);
fSetCerenkovMaxPhotonsCmd->SetGuidance("Set maximum number of photons per step");
fSetCerenkovMaxPhotonsCmd->SetParameterName("CerenkovMaxPhotons", false);
fSetCerenkovMaxPhotonsCmd->SetRange("CerenkovMaxPhotons>=0");
fSetCerenkovMaxPhotonsCmd->AvailableForStates(G4State_PreInit, G4State_Idle, G4State_GeomClosed, G4State_EventProc);
fSetCerenkovMaxBetaChangeCmd
= new G4UIcmdWithADouble("/optics_engine/setCerenkovMaxBetaChange", this);
fSetCerenkovMaxBetaChangeCmd
->SetGuidance("Set maximum change of beta of parent particle per step");
fSetCerenkovMaxBetaChangeCmd->SetParameterName("CerenkovMaxBetaChange", false);
fSetCerenkovMaxBetaChangeCmd->SetRange("CerenkovMaxBetaChange>=0");
fSetCerenkovMaxBetaChangeCmd->AvailableForStates(G4State_PreInit, G4State_Idle, G4State_GeomClosed, G4State_EventProc);
fSetScintillationYieldFactorCmd
= new G4UIcmdWithADouble("/optics_engine/setScintillationYieldFactor", this);
fSetScintillationYieldFactorCmd->SetGuidance("Set scintillation yield factor");
fSetScintillationYieldFactorCmd->SetParameterName("ScintillationYieldFactor", false);
fSetScintillationYieldFactorCmd->SetRange("ScintillationYieldFactor>=0");
fSetScintillationYieldFactorCmd->AvailableForStates(G4State_PreInit, G4State_Idle, G4State_GeomClosed, G4State_EventProc);
fSetScintillationByParticleTypeCmd
= new G4UIcmdWithABool("/optics_engine/setScintillationByParticleType", this);
fSetScintillationByParticleTypeCmd->SetGuidance("Activate/Inactivate scintillation process by particle type");
fSetScintillationByParticleTypeCmd->SetParameterName("ScintillationByParticleTypeActivation", false);
fSetScintillationByParticleTypeCmd->AvailableForStates(G4State_PreInit, G4State_Idle, G4State_GeomClosed, G4State_EventProc);
// fSetOpticalSurfaceModelCmd
// = new G4UIcmdWithAString("/optics_engine/setOpticalSurfaceModel", this);
// fSetOpticalSurfaceModelCmd
// ->SetGuidance("Set optical surface model (glisur or unified)");
// fSetOpticalSurfaceModelCmd->SetParameterName("OpticalSurfaceModel", false);
// fSetOpticalSurfaceModelCmd->SetCandidates("glisur unified");
// fSetOpticalSurfaceModelCmd->AvailableForStates(G4State_PreInit, G4State_Idle, G4State_GeomClosed, G4State_EventProc);
fSetWLSTimeProfileCmd
= new G4UIcmdWithAString("/optics_engine/setWLSTimeProfile", this);
fSetWLSTimeProfileCmd
->SetGuidance("Set the WLS time profile (delta or exponential)");
fSetWLSTimeProfileCmd->SetParameterName("WLSTimeProfile", false);
fSetWLSTimeProfileCmd->SetCandidates("delta exponential");
fSetWLSTimeProfileCmd->AvailableForStates(G4State_PreInit, G4State_Idle, G4State_GeomClosed, G4State_EventProc);
fSetTrackSecondariesFirstCmd
= new G4UIcmdWithABool("/optics_engine/setTrackSecondariesFirst", this);
fSetTrackSecondariesFirstCmd
->SetGuidance("Set option to track secondaries before finishing their parent track");
fSetTrackSecondariesFirstCmd->SetParameterName("TrackSecondariesFirst", false);
fSetTrackSecondariesFirstCmd->AvailableForStates(G4State_PreInit, G4State_Idle, G4State_GeomClosed, G4State_EventProc);
fSetFiniteRiseTimeCmd
= new G4UIcmdWithABool("/optics_engine/setFiniteRiseTime", this);
fSetFiniteRiseTimeCmd
->SetGuidance("Set option of a finite rise-time for G4Scintillation - If set, the G4Scintillation process expects the user to have set the constant material property FAST/SLOWSCINTILLATIONRISETIME");
fSetFiniteRiseTimeCmd->SetParameterName("FiniteRiseTime", false);
fSetFiniteRiseTimeCmd->AvailableForStates(G4State_PreInit, G4State_Idle, G4State_GeomClosed, G4State_EventProc);
}
G4OpticalPhysicsMessenger::~G4OpticalPhysicsMessenger()
{
// Destructor
delete fDir;
delete fSelectOpProcessCmd;
delete fSetOpProcessUseCmd;
delete fSetOpProcessVerboseCmd;
delete fSetCerenkovMaxPhotonsCmd;
delete fSetCerenkovMaxBetaChangeCmd;
delete fSetScintillationYieldFactorCmd;
delete fSetScintillationByParticleTypeCmd;
// delete fSetOpticalSurfaceModelCmd;
delete fSetWLSTimeProfileCmd;
delete fSetTrackSecondariesFirstCmd;
delete fSetFiniteRiseTimeCmd;
}
void G4OpticalPhysicsMessenger::SetNewValue(G4UIcommand* command, G4String newValue)
{
/// Apply command to the associated object.
if (command == fSelectOpProcessCmd) {
if ( newValue == "Cerenkov" ) {
fSelectedProcessIndex = kCerenkov;
} else if ( newValue == "Scintillation" ) {
fSelectedProcessIndex = kScintillation;
} else if ( newValue == "OpAbsorption" ) {
fSelectedProcessIndex = kAbsorption;
} else if ( newValue == "OpRayleigh" ) {
fSelectedProcessIndex = kRayleigh;
} else if ( newValue == "OpMieHG" ) {
fSelectedProcessIndex = kMieHG;
} else if ( newValue == "OpBoundary" ) {
fSelectedProcessIndex = kBoundary;
} else if ( newValue == "OpWLS" ) {
fSelectedProcessIndex = kWLS;
}
}
else if (command == fSetOpProcessUseCmd) {
fOpticalPhysics->
Configure(fSelectedProcessIndex,
fSetOpProcessUseCmd->GetNewBoolValue(newValue));
}
else if (command == fSetOpProcessVerboseCmd) {
if ( fSelectedProcessIndex < kNoProcess ) {
fOpticalPhysics->
SetProcessVerbose(fSelectedProcessIndex,
fSetOpProcessVerboseCmd->GetNewIntValue(newValue));
} else {
for ( G4int i=0; i<kNoProcess; i++ ) {
fOpticalPhysics->
SetProcessVerbose(i,fSetOpProcessVerboseCmd->GetNewIntValue(newValue));
}
}
}
else if (command == fSetCerenkovMaxPhotonsCmd) {
fOpticalPhysics
->SetMaxNumPhotonsPerStep(
fSetCerenkovMaxPhotonsCmd->GetNewIntValue(newValue));
}
else if (command == fSetCerenkovMaxBetaChangeCmd) {
fOpticalPhysics
->SetMaxBetaChangePerStep(
fSetCerenkovMaxBetaChangeCmd->GetNewDoubleValue(newValue));
}
else if (command == fSetScintillationYieldFactorCmd) {
fOpticalPhysics
->SetScintillationYieldFactor(
fSetScintillationYieldFactorCmd->GetNewDoubleValue(newValue));
}
else if (command == fSetScintillationByParticleTypeCmd) {
fOpticalPhysics
->SetScintillationByParticleType(
fSetScintillationByParticleTypeCmd->GetNewBoolValue(newValue));
}
else if (command == fSetFiniteRiseTimeCmd) {
fOpticalPhysics
->SetFiniteRiseTime(
fSetFiniteRiseTimeCmd->GetNewBoolValue(newValue));
}
// else if (command == fSetOpticalSurfaceModelCmd) {
// if ( newValue == "glisur" ) {
// fOpticalPhysics
// ->SetOpticalSurfaceModel(glisur);
// }
// if ( newValue == "unified" ) {
// fOpticalPhysics
// ->SetOpticalSurfaceModel(unified);
// }
// }
else if (command == fSetWLSTimeProfileCmd) {
if ( newValue == "delta" ) {
fOpticalPhysics
->SetWLSTimeProfile("delta"); }
if ( newValue == "exponential" ) {
fOpticalPhysics
->SetWLSTimeProfile("exponential");
}
}
else if (command == fSetTrackSecondariesFirstCmd) {
fOpticalPhysics->SetTrackSecondariesFirst(fSelectedProcessIndex,
fSetTrackSecondariesFirstCmd->
GetNewBoolValue(newValue));
}
}