Geant4

 10.0  p01  

Physics  I:  Physics  Lists  

Geant4  Tutorial  at  Stanford  

4  March  2014  
Dennis  Wright  (SLAC)  
 Outline  
• IntroducGon  

• The  G4VUserPhysicsList  class  

• Modular  physics  lists  

• Packaged  physics  lists  

• Choosing  the  appropriate  physics  list  

• ValidaGng  your  physics  list    

2  
 What  is  a  Physics  List?  
• A  class  which  collects  all  the  parGcles,  physics  processes  and  
producGon  thresholds  needed  for  your  applicaGon  
• It  tells  the  run  manager  how  and  when  to  invoke  physics    

• It  is  a  very  flexible  way  to  build  a  physics  environment  

– user  can  pick  the  parGcles  he  wants  
– user  can  pick  the  physics  to  assign  to  each  parGcle  
 
• But,  user  must  have  a  good  understanding  of  the  physics  
required  
– omission  of  parGcles  or  physics  could  cause  errors  or  poor  
simulaGon  

3  
 Why  Do  We  Need  a  Physics  List?  
• Physics  is  physics  –  shouldn’t  Geant4  provide,  as  a  default,  a  
complete  set  of  physics  processes  that  everyone  can  use?  
• No:  
– there  are  many  different  physics  models  and  approximaGons  
– very  much  the  case  for  hadronic  physics  
– but  also  true  for  electromagneGc  physics  
 
– computaGon  speed  is  an  issue  
– a  user  may  want  a  less-­‐detailed,  but  faster  approximaGon  
 
– no  applicaGon  requires  all  the  physics  and  parGcles  that  Geant4  
has  to  offer  
– e.g.,  most  medical  applicaGons  do  not  want  mulG-­‐GeV  physics  

4  
 Why  Do  We  Need  a  Physics  List?  
• For  this  reason  Geant4  takes  an  atomisGc,  rather  than  an  
integral  approach  to  physics  
– provide  many  physics  components  (processes)  which  are  
decoupled  from  one  another  (for  the  most  part)  
– user  selects  these  components  in  custom-­‐designed  physics  lists  
in  much  the  same  way  as  a  detector  geometry  is  built  

• ExcepGons  
– a  few  electromagneGc  processes  must  be  used  together  
– future  processes  involving  interference  of  electromagneGc  and  
strong  interacGons  may  require  coupling  as  well  

5  
 Physics  Processes  Provided  by  Geant4  
• EM  physics  
– “standard”  processes  valid  from  ~  1  keV  to  ~PeV  
– “low  energy”  valid  from  250  eV  to  ~PeV  
– opGcal  photons  

• Weak  interacGon  physics  

– decay  of  subatomic  parGcles  
– radioacGve  decay  of  nuclei  

• Hadronic  physics  
– pure  strong  interacGon  physics  valid  from  0  to  ~TeV  
– electro-­‐  and  gamma-­‐nuclear  valid  from  10  MeV  to  ~TeV  

• Parameterized  or  “fast  simulaGon”  physics  

6  
 G4VUserPhysicsList  
• All  physics  lists  must  derive  from  this  class  
– and  then  be  registered  with  the  run  manager  

• Example:  
 class  MyPhysicsList:  public  G4VUserPhysicsList  {  
         public:  
                   MyPhysicsList();  
                   ~MyPhysicsList();  
                   void  ConstructParGcle();  
                   void  ConstructProcess();  
                   void  SetCuts();  
 }  
• User  must  implement  the  methods  ConstructParGcle,  
ConstructProcess  and  SetCuts  
7  
 G4VUserPhysicsList:  Required  Methods  
• ConstructParGcle()  –  choose  the  parGcles  you  need  in  your  
simulaGon  and  define  them  all  here  
• ConstructProcess()  –  for  each  parGcle,  assign  all  the  physics  
processes  important  in  your  simulaGon  
• What’s  a  process?  
•  à  a  class  that  defines  how  a  parGcle  should  interact  with  
majer  (it’s  where  the  physics  is!)  
• more  on  this  later  
• SetCuts()  –  set  the  range  cuts  for  secondary  producGon  
– What’s  a  range  cut?  
– à  essenGally  a  low  energy  limit  on  parGcle  producGon  
– more  on  this  later  
8  
 ConstructParGcle()  
     void  MyPhysicsList::ConstructParGcle()    {  
               G4BaryonConstructor*  baryonConstructor  =  
                                                                                                                       new  G4BaryonConstructor();  
               baryonConstructor-­‐>ConstructParGcle();  
               delete  baryonConstructor;  
               G4BosonConstructor*  bosonConstructor  =    
                                                                                                                       new  G4BosonConstructor();  
               bosonConstructor-­‐>ConstructParGcle();  
               delete  bosonConstructor;  
               …  
               …  
       }  
9  
                 
 ConstructParGcle()      (alternate)  
     void  MyPhysicsList::ConstructParGcle()    
     {  
               G4Electron::ElectronDefiniGon();  
               G4Proton::ProtonDefiniGon();  
               G4Neutron::NeutronDefiniGon();  
               G4Gamma::GammaDefiniGon();  
               …  
               …  
       }  
                 

10  
 ConstructProcess()  
     void  MyPhysicsList::ConstructProcess()    {  
               AddTransportaGon();  
                 //  method  provided  by  G4VUserPhysicsList  assigns  transportaGon  
                 //  process  to  all  parGcles  defined  in  ConstructParGcle()  
 
                 ConstructEM();  
                 //  method  may  be  defined  by  user  (for  convenience)  
                 //  put  electromagneGc  physics  here  
 
                 ConstructGeneral();  
                 //  method  may  be  defined  by  user  to  hold  all  other  processes  
       }  
                  11  
 ConstructEM()  
     void  MyPhysicsList::ConstructEM()    {  
               G4PhysicsListHelper*  ph  =  G4PhysicsListHelper::GetPhysicsListHelper();  
 
               theParGcleIterator-­‐>reset();  
               while(  (*theParGcleIterator)()  )  {  
                         G4ParGcleDefiniGon*  parGcle  =  theParGcleIterator-­‐>value();  
                         if    (parGcle  ==  G4Gamma::Gamma()  )  {  
                                 ph-­‐>RegisterProcess(new  G4GammaConversion(),    parGcle);  
                                   ….    //  add  more  processes  
                         }  
                           …    //  do  electrons,  positrons,  etc.  
               }  
12  
 
 ConstructGeneral()  
     void  MyPhysicsList::ConstructGeneral()    {  
               G4PhysicsListHelper*  ph  =  G4PhysicsListHelper::GetPhysicsListHelper();  
               //  Add  decay  process  
               G4Decay*  theDecayProcess  =  new  G4Decay();  
               theParGcleIterator-­‐>reset();  
               while(  (*theParGcleIterator)()  )  {  
                         G4ParGcleDefiniGon*  parGcle  =  theParGcleIterator-­‐>value();  
                         if    (theDecayProcess-­‐>IsApplicable(*parGcle)  )  {    
                                 ph-­‐>RegisterProcess(theDecayProcess,  parGcle);  
                         }  
                 }  
                 //  Add  other  physics  
13  
 
 SetCuts()  
     void  MyPhysicsList::SetCuts()  
     {  
               defaultCutValue  =  0.7*mm;  
               SetCutValue(defaultCutValue,  “gamma”);  
               SetCutValue(defaultCutValue,  “e-­‐”);  
               SetCutValue(defaultCutValue,  “e+”);  
               SetCutValue(defaultCutValue,  “proton”);  
               //  
               //  These  are  all  the  producGon  cuts  you  need  to  set  
               //  -­‐  not  required  for  any  other  parGcle  
     }  
 
  14  
 G4VModularPhysicsList  
• The  physics  list  in  our  example  is  quite  simple  
• A  realisGc  physics  list  is  likely  to  have  many  more  physics  
processes  
– such  a  list  can  become  quite  long,  complicated  and  hard  to  
maintain  
– try  a  modular  physics  list  instead  
• Features  of  G4VModularPhysicsList  
– derived  from  G4VUserPhysicsList  
– AddTransportaGon()  automaGcally  called  for  all  registered  parGcles  
– allows  you  to  define  “physics  modules”:  EM  physics,  hadronic  
physics,  opGcal  physics,  etc.  
 
15  
 
 A  Simple  G4VModularPhysicsList  
• Constructor:  
   MyModPhysList::MyModPhysList():  G4VModularPhysicsList()  {  
             defaultCutValue  =  0.7*mm;  
             RegisterPhysics(new  ProtonPhysics()  );    
             //  all  physics  processes  having  to  do  with  protons  
RegisterPhysics(new  ElectronPhysics()  );  
//  all  physics  processes  having  to  do  with  electrons  
RegisterPhysics(new  DecayPhysics()  );  
//  physics  of  unstable  parGcles  
   }  
• SetCuts:  
     void  MyModPhysList::SetCuts()  {  SetCutsWithDefault();  }   16  
 
 Physics  Constructors  
• Allows  you  to  group  parGcle  and  process  construcGon  
according  to  physics  domains  
• class  ProtonPhysics  :  public  G4VPhysicsConstructor  
         {    
                   public:  
                             ProtonPhysics(const  G4String&  name  =  “proton”);  
                             virtual  ~ProtonPhysics();  
                             virtual  void  ConstructParGcle()  
                             //  easy  –  only  one  parGcle  to  build  in  this  case  
                             virtual  void  ConstructProcess();  
                             //  put  here  all  the  processes  a  proton  can  have  
         }  
17  
 
 Packaged  Physics  Lists  
• Our  example  dealt  mainly  with  electromagneGc  physics  
• A  realisGc  physics  list  can  be  found  in  basic  example  B3  
– uses  “standard”  EM  physics  and  decay  physics  
– a  good  starGng  point  
– add  to  it  according  to  your  needs  
• Adding  hadronic  physics  is  more  involved  
– for  any  one  hadronic  process,  user  may  choose  from  several  
hadronic  models  
– choosing  the  right  models  for  your  applicaGon  requires  care  
– to  make  things  easier,  pre-­‐packaged  physics  lists  are  provided  
according  to  some  reference  use  cases  
 
18  
 
 Packaged  Physics  Lists  
• Each  pre-­‐packaged  physics  list  includes  different  choices  of  
EM  and  hadronic  physics  
• A  list  of  these  can  be  found  in  your  copy  of  the  toolkit  at    
geant4/source/physics_lists/lists/include  
• Caveats  
– these  lists  are  provided  as  a  “best  guess”  of  the  physics  needed  
in  a  given  use  case  
– the  user  is  responsible  for  validaGng  the  physics  for  his  own  
applicaGon  and  adding  (or  subtracGng)  the  appropriate  physics  
– they  are  intended  as  starGng  points  or  templates  
 
 
19  
 
 Reference  Physics  Lists  
• Among  the  pre-­‐packaged  physics  lists  are  the  “Reference”  
physics  lists    
– a  small  number  of  well-­‐maintained  and  tested  physics  lists  
– also  the  most  used  (ATLAS,  CMS,  etc.)  and  most  recommended  
• These  are  updated  less  frequently  
– more  stable  
• More  on  these,  and  which  ones  we  recommend,  later  
 
 
 
 
  20  
A  Short  Guide  to  Choosing  a    
Physics  List  
 Choosing  a  Physics  List  
• Which  physics  list  you  use  is  highly  dependent  on  your  use  
case  
• Before  choosing,  or  building  your  own,  familiarize  yourself  
with  the  major  physics  processes  available  
• the  process-­‐model  catalog  is  useful  for  this    
• see  Geant4  web  page  under  User  Support,  item  11b  
 
• Geant4  provides  several  “reference  physics  lists”  which  are  
rouGnely  validated  and  updated  with  each  release  
• these  should  be  considered  only  as  starGng  points  which  you  
may  need  to  validate  or  modify  for  your  applicaGon  
• There  are  also  many  physics  lists  in  the  examples  which  you  
can  copy  
• these  are  owen  very  specific  to  a  given  use  case  
22  
 Choosing  a  Physics  List  
• There  are  currently  19  packaged  physics  lists  available  
• but  you  will  likely  be  interested  in  only  a  few,  namely  the  
“reference”  physics  lists  
• many  physics  lists  are  either  developmental  or  customized  in  
some  way,  and  so  not  very  useful  to  new  users  
 
• All  but  one  of  the  packaged  physics  lists  use  templates  
• the  LBE  physics  list  is  the  old-­‐style  “flat”  list  without  templates  
or  physics  builders  
 
• 6  reference  physics  lists:  
• FTFP_BERT,  FTFP_BERT_HP  
• QGSP_BERT,  QGSP_BERT_HP,  QGSP_BIC  
• QGSP_FTFP_BERT  
23  
 Physics  List  Naming  ConvenGon  
• The  following    acronyms  refer  to  various  hadronic  opGons  
• QGS  -­‐>  Quark  Gluon  String  model  (>~20  GeV)    
• FTF  -­‐>  FriGof  string  model  (>~5  GeV)  
• BIC  -­‐>  Binary  Cascade  (<~  10  GeV)  
• BERT  -­‐>  BerGni-­‐style  cascade  (<~  10  GeV)    
• HP  -­‐>  High  Precision  neutron  model  (  <  20  MeV)  
• P  -­‐>  G4Precompund  model  used  for  de-­‐excitaGon  
 
• EM  opGons  designated  by  
• no  suffix  :  standard  EM  physics  
• EMV  suffix  :  older  but  faster  EM  processes  
• other  suffixes  for  other  EM  opGons  
24  
 Reference  Physics  Lists  
• FTFP_BERT  
– recommended  by  Geant4  for  HEP  
– contains  all  standard  EM  processes  
– uses  BerGni-­‐style  cascade  for  hadrons  <  5  GeV  
– uses  FTF  (FriGof)  model  for  high  energies  (  >  4  GeV)  

• QGSP_BERT  
– all  standard  EM  processes  
– BerGni-­‐style  cascade  up  to  9.9  GeV  
– QGS  model  for  high  energies  (>  ~18  GeV)  
– FTF  in  between  

25  
 Reference  Physics  Lists  
• QGSP_BIC  
– same  as  QGSP_BERT,  but  replaces  BerGni  cascade  with  Binary  
cascade  and  G4Precompound  model  
– recommended  for  use  at  energies  below  200  MeV  (many  
medical  applicaGons)  

• FTFP_BERT_HP  
– same  as  FTFP_BERT,  but  with  high  precision  neutron  model  
used  for  neutrons  below  20  MeV  
– significantly  slower  than  FTFP_BERT  when  full  thermal  cross  
secGons  used  
–there’s  an  opGon  to  turn  this  off  
– for  radiaGon  protecGon  and  shielding  applicaGons  

26  
 Other  Physics  Lists  
• Shielding    
– based  on  FTFP_BERT_HP  with  improved  neutron  cross  secGons  
from  JENDL  
– bejer  ion  interacGons  using  QMD  model  
– currently  used  by  SuperCDMS  dark  majer  search  
– recommended  for:  
–shielding  applicaGons  
–space  physics  
–HEP    

27  
 Other  Physics  Lists  
• FTFP_INCLXX,  FTFP_INCLXX_HP  
– like  FTFP_BERT,  but  with  BERT  replaced  by  INCL++  cascade  
model  
• QBBC  
– uses  both  BERT  and  BIC  cascade  models  
– latest  coherent  elasGc  scajering  
– neutronXS  models  (faster  CPU-­‐wise)  

• QGSP_BIC_HP  
– same  as  QGSP_BIC,  but  with  high  precision  neutron  model  used  
for  neutrons  below  20  MeV  
– recommended  for  radiaGon  protecGon,  shielding  and  medical  
applicaGons  
28  
 Other  Physics  Lists  (based  on  use  case)  
• If  primary  parGcle  energy  in  your  applicaGon  is  <  5  GeV  (for  
example,  clinical  proton  beam  of  150  MeV)  
– start  with  a  physics  list  which  includes  BIC  or  BERT  
– e.g.  QGSP_BIC,    QGSP_BERT,  FTFP_BERT,  etc.  

• If  neutron  transport  is  important  

– start  with  physics  list  containing  “HP”  
– e.g.  QGSP_BIC_HP,    FTFP_BERT_HP,  etc.  

• If  you’re  interested  in  Bragg  curve  physics  

– use  a  physics  list  ending  in  “EMV”  or  “EMX”  
– e.g.  QGSP_BERT_EMV    

29  
 Other  Physics  Lists  (based  on  use  case)  

• For  opGcal  photon  transport  

– start  with  the  LBE  physics  list  
– list  is  a  bit  old,  but  opGcal  code  can  be  extracted  for  other  
applicaGons  

• For  radioacGve  decay  

– use  LBE  list  as  an  example,  or  the  physics  list  in  example  B3  

• For    detailed  line  emissions  from  EM  processes  

– LBE  or  see  following  slide  

30  
 Alternate  EM  Physics  Lists  
• Up  to  now,  most  physics  lists  menGoned  have  used  the  
“standard”  EM  processes,  but  “low  energy”  EM  physics  is  also  
available  
• G4EmLivermorePhysics      (physics  list  suffix  =  LIV)  
• G4EmLivermorePolarizedPhysics  
• G4EmPenelopePhysics    (suffix  =  PEN)  
• G4EmDNAPhysics  
 
• Physics  lists  containing  these  are  recommended  for  micro-­‐
dosimetry  applicaGons  
• For  examples  using  a  DNA  physics  list,  go  to  
• geant4/source/examples/advanced  
31  
 Using  Alternate  EM  Physics  Lists  
• These  physics  list  classes  derive  from  the  
G4VPhysicsConstructor  abstract  base  class  
• A  good  implementaGon  example  that  uses  these  already  
available  physics  lists  can  be  found  in    
• examples/extended/electromagneGc/TestEm2  
 
• Once  you  know  the  desired  hadronic  part  of  the  physics  list  
name  (e.g.  FTFP_BERT)  an  easy  way  to  keep  straight  the  
various  EM  opGons  is  to  use  the  G4PhysListFactory  class:  
• G4PhysListFactory  factory;  
       G4VModularPhysicsList*  physList  =  
                                     factory.GetReferencePhysList(“FTFP_BERT_  XXX”);  
       //  where  XXX  =  EMV  or  EMX  or  LIV  or  PEN  
32  
 Using  Geant4  ValidaGon  to  Choose  Physics  Lists  
• UlGmately  you  must  choose  a  physics  list  based  on  how  well  
its  component  processes  and  models  perform  
• physics  performance  
• CPU  performance  
• Geant4  provides  validaGon  (comparison  to  data)  for  most  of  
its  physics  codes  
• validaGon  is  a  conGnuing  task,  performed  at  least  as  owen  as  
each  release  
• more  validaGon  tests  added  as  Gme  goes  on  
• To  access  these  comparisons,  go  to  Geant4  website  
– follow  the  chain:  click  on  “Results  and  PublicaGons”  -­‐>  
“ValidaGon  and  tesGng”  -­‐>  ValidaGon  Database:  “FNAL_DB”  
33  
New  Hadronic  ValidaGon  Framework  

34  
IAEA  ValidaGon  Tests  (Hadronic)  

35  
Specific  Hadronic  ValidaGon  Test  

36  
 Summary  
• All  the  parGcles,  physics  processes  and  producGon  cuts  
needed  for  an  applicaGon  must  go  into  a  physics  list  
• Two  kinds  of  physics  list  classes  are  available  for  users  to  
derive  from  
– G4VUserPhysicsList  –  for  relaGvely  simple  physics  lists  
– G4VModularPhysicsList  –  for  detailed  physics  lists  
• Some  physics  lists  are  provided  by  Geant4  as  a  starGng  point  
for  users  
• Care  is  required  by  user  in  choosing  the  right  physics  
– use  the  validaGon,  Luke  
 
 
37