Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/processes/electromagnetic/lowenergy/src/G4empCrossSection.cc

Version: [ ReleaseNotes ] [ 1.0 ] [ 1.1 ] [ 2.0 ] [ 3.0 ] [ 3.1 ] [ 3.2 ] [ 4.0 ] [ 4.0.p1 ] [ 4.0.p2 ] [ 4.1 ] [ 4.1.p1 ] [ 5.0 ] [ 5.0.p1 ] [ 5.1 ] [ 5.1.p1 ] [ 5.2 ] [ 5.2.p1 ] [ 5.2.p2 ] [ 6.0 ] [ 6.0.p1 ] [ 6.1 ] [ 6.2 ] [ 6.2.p1 ] [ 6.2.p2 ] [ 7.0 ] [ 7.0.p1 ] [ 7.1 ] [ 7.1.p1 ] [ 8.0 ] [ 8.0.p1 ] [ 8.1 ] [ 8.1.p1 ] [ 8.1.p2 ] [ 8.2 ] [ 8.2.p1 ] [ 8.3 ] [ 8.3.p1 ] [ 8.3.p2 ] [ 9.0 ] [ 9.0.p1 ] [ 9.0.p2 ] [ 9.1 ] [ 9.1.p1 ] [ 9.1.p2 ] [ 9.1.p3 ] [ 9.2 ] [ 9.2.p1 ] [ 9.2.p2 ] [ 9.2.p3 ] [ 9.2.p4 ] [ 9.3 ] [ 9.3.p1 ] [ 9.3.p2 ] [ 9.4 ] [ 9.4.p1 ] [ 9.4.p2 ] [ 9.4.p3 ] [ 9.4.p4 ] [ 9.5 ] [ 9.5.p1 ] [ 9.5.p2 ] [ 9.6 ] [ 9.6.p1 ] [ 9.6.p2 ] [ 9.6.p3 ] [ 9.6.p4 ] [ 10.0 ] [ 10.0.p1 ] [ 10.0.p2 ] [ 10.0.p3 ] [ 10.0.p4 ] [ 10.1 ] [ 10.1.p1 ] [ 10.1.p2 ] [ 10.1.p3 ] [ 10.2 ] [ 10.2.p1 ] [ 10.2.p2 ] [ 10.2.p3 ] [ 10.3 ] [ 10.3.p1 ] [ 10.3.p2 ] [ 10.3.p3 ] [ 10.4 ] [ 10.4.p1 ] [ 10.4.p2 ] [ 10.4.p3 ] [ 10.5 ] [ 10.5.p1 ] [ 10.6 ] [ 10.6.p1 ] [ 10.6.p2 ] [ 10.6.p3 ] [ 10.7 ] [ 10.7.p1 ] [ 10.7.p2 ] [ 10.7.p3 ] [ 10.7.p4 ] [ 11.0 ] [ 11.0.p1 ] [ 11.0.p2 ] [ 11.0.p3, ] [ 11.0.p4 ] [ 11.1 ] [ 11.1.1 ] [ 11.1.2 ] [ 11.1.3 ] [ 11.2 ] [ 11.2.1 ] [ 11.2.2 ] [ 11.3.0 ]

Diff markup

Differences between /processes/electromagnetic/lowenergy/src/G4empCrossSection.cc (Version 11.3.0) and /processes/electromagnetic/lowenergy/src/G4empCrossSection.cc (Version 9.5)


  1 //                                                  1 //
  2 // *******************************************      2 // ********************************************************************
  3 // * License and Disclaimer                         3 // * License and Disclaimer                                           *
  4 // *                                                4 // *                                                                  *
  5 // * The  Geant4 software  is  copyright of th      5 // * The  Geant4 software  is  copyright of the Copyright Holders  of *
  6 // * the Geant4 Collaboration.  It is provided      6 // * the Geant4 Collaboration.  It is provided  under  the terms  and *
  7 // * conditions of the Geant4 Software License      7 // * conditions of the Geant4 Software License,  included in the file *
  8 // * LICENSE and available at  http://cern.ch/      8 // * LICENSE and available at  http://cern.ch/geant4/license .  These *
  9 // * include a list of copyright holders.           9 // * include a list of copyright holders.                             *
 10 // *                                               10 // *                                                                  *
 11 // * Neither the authors of this software syst     11 // * Neither the authors of this software system, nor their employing *
 12 // * institutes,nor the agencies providing fin     12 // * institutes,nor the agencies providing financial support for this *
 13 // * work  make  any representation or  warran     13 // * work  make  any representation or  warranty, express or implied, *
 14 // * regarding  this  software system or assum     14 // * regarding  this  software system or assume any liability for its *
 15 // * use.  Please see the license in the file      15 // * use.  Please see the license in the file  LICENSE  and URL above *
 16 // * for the full disclaimer and the limitatio     16 // * for the full disclaimer and the limitation of liability.         *
 17 // *                                               17 // *                                                                  *
 18 // * This  code  implementation is the result      18 // * This  code  implementation is the result of  the  scientific and *
 19 // * technical work of the GEANT4 collaboratio     19 // * technical work of the GEANT4 collaboration.                      *
 20 // * By using,  copying,  modifying or  distri     20 // * By using,  copying,  modifying or  distributing the software (or *
 21 // * any work based  on the software)  you  ag     21 // * any work based  on the software)  you  agree  to acknowledge its *
 22 // * use  in  resulting  scientific  publicati     22 // * use  in  resulting  scientific  publications,  and indicate your *
 23 // * acceptance of all terms of the Geant4 Sof     23 // * acceptance of all terms of the Geant4 Software license.          *
 24 // *******************************************     24 // ********************************************************************
 25 //                                                 25 //
                                                   >>  26 // $Id: G4empCrossSection.cc,v 1.4 2011-01-03 19:35:11 vnivanch Exp $
                                                   >>  27 // GEANT4 tag $Name: not supported by cvs2svn $
 26 //                                                 28 //
 27 //                                                 29 //         
 28 //                                                 30 //
 29 // History:                                        31 // History:
 30 // -----------                                     32 // -----------
 31 //  29 Apr 2009   ALF   1st implementation         33 //  29 Apr 2009   ALF   1st implementation
 32 //  15 Mar 2011   ALF introduced the usage of      34 //  15 Mar 2011   ALF introduced the usage of G4AtomicShellEnumerator
 33 //  09 Mar 2012   LP  updated methods          << 
 34 //                                                 35 //
                                                   >>  36 
                                                   >>  37 
 35 #include "globals.hh"                              38 #include "globals.hh"
 36 #include "G4empCrossSection.hh"                    39 #include "G4empCrossSection.hh"
 37 #include "G4Proton.hh"                             40 #include "G4Proton.hh"
 38                                                    41 
 39 //....oooOO0OOooo........oooOO0OOooo........oo <<  42 
 40 G4empCrossSection::G4empCrossSection(const G4S     43 G4empCrossSection::G4empCrossSection(const G4String& nam)
 41   :G4VhShellCrossSection(nam),totalCS(0.0)         44   :G4VhShellCrossSection(nam),totalCS(0.0)
 42 {                                                  45 { 
 43  if (nam == "Empirical")                       << 
 44   {                                            << 
 45     paulShellK = new G4PaulKxsModel();         << 
 46     orlicShellLi = new G4OrlicLiXsModel();     << 
 47     flag=0;                                    << 
 48   }                                            << 
 49   else                                         << 
 50   {                                            << 
 51     G4cout << "G4empCrossSection::G4empCrossSe << 
 52      << "ERROR in G4empCrossSection name; Paul << 
 53      << G4endl;                                << 
 54     paulShellK = new G4PaulKxsModel();         << 
 55     orlicShellLi = new G4OrlicLiXsModel();     << 
 56     flag=0;                                    << 
 57   }                                            << 
 58 }                                              << 
 59                                                    46 
 60 //....oooOO0OOooo........oooOO0OOooo........oo <<  47   paulShellK = new G4PaulKxsModel();
                                                   >>  48   orlicShellLi = new G4OrlicLiXsModel();
                                                   >>  49 
                                                   >>  50 }
 61                                                    51 
 62 G4empCrossSection::~G4empCrossSection()            52 G4empCrossSection::~G4empCrossSection()
 63 {                                                  53 { 
                                                   >>  54 
 64   delete paulShellK;                               55   delete paulShellK;
 65   delete orlicShellLi;                             56   delete orlicShellLi;
 66 }                                              << 
 67                                                    57 
 68 //....oooOO0OOooo........oooOO0OOooo........oo <<  58 }
 69                                                    59 
 70 std::vector<G4double> G4empCrossSection::GetCr     60 std::vector<G4double> G4empCrossSection::GetCrossSection(G4int Z,
 71                G4double incidentEnergy,            61                G4double incidentEnergy,
 72                G4double mass,                      62                G4double mass,
 73                G4double,                       <<  63                G4double,G4bool) const
 74                const G4Material*)              << 
 75 {                                                  64 {
 76   std::vector<G4double> crossSections;             65   std::vector<G4double> crossSections;
 77   G4ParticleDefinition* aProton = G4Proton::Pr     66   G4ParticleDefinition* aProton = G4Proton::Proton();
 78                                                    67 
 79   crossSections.push_back( paulShellK->Calcula     68   crossSections.push_back( paulShellK->CalculateKCrossSection(Z, mass, incidentEnergy) );
 80                                                    69 
 81   // this check should be done in the Orlic cl     70   // this check should be done in the Orlic class, that can handle only protons;
 82   // however this would lead up tp three check     71   // however this would lead up tp three checks of the mass, while here we have only one
 83   // moreover, at the present time,this class      72   // moreover, at the present time,this class handles explicitly Paul and Orlic models,
 84   // so it can hadle the responsibility of thi     73   // so it can hadle the responsibility of this check too
 85                                                    74 
 86   if (mass == aProton->GetPDGMass()) {             75   if (mass == aProton->GetPDGMass()) {
 87                                                <<  76     crossSections.push_back( orlicShellLi->CalculateL1CrossSection(Z, incidentEnergy) );
 88     if (flag==0)                               <<  77     crossSections.push_back( orlicShellLi->CalculateL2CrossSection(Z, incidentEnergy) );
 89     {                                          <<  78     crossSections.push_back( orlicShellLi->CalculateL3CrossSection(Z, incidentEnergy) );
 90       crossSections.push_back( orlicShellLi->C << 
 91       crossSections.push_back( orlicShellLi->C << 
 92       crossSections.push_back( orlicShellLi->C << 
 93     }                                          << 
 94                                                << 
 95   }                                                79   }
                                                   >>  80 
 96   else {                                           81   else {
 97     crossSections.push_back( 0. );                 82     crossSections.push_back( 0. );
 98     crossSections.push_back( 0. );                 83     crossSections.push_back( 0. );
 99     crossSections.push_back( 0. );                 84     crossSections.push_back( 0. );
100   }                                                85   }  
101   return crossSections;                            86   return crossSections;
102                                                    87 
103 }                                                  88 }
104                                                    89 
105 //....oooOO0OOooo........oooOO0OOooo........oo << 
106                                                << 
107 G4double G4empCrossSection::CrossSection(G4int     90 G4double G4empCrossSection::CrossSection(G4int Z, G4AtomicShellEnumerator shell,
108            G4double incidentEnergy,                91            G4double incidentEnergy,
109            G4double mass,                      <<  92            G4double mass) const
110            const G4Material*)                  << 
111 {                                                  93 {
                                                   >>  94 
                                                   >>  95   //let's reproduce  
                                                   >>  96 
112   G4double res = 0.0;                              97   G4double res = 0.0;
113   G4ParticleDefinition* aProton = G4Proton::Pr     98   G4ParticleDefinition* aProton = G4Proton::Proton();
114                                                << 
115   if(fKShell == shell) {                           99   if(fKShell == shell) { 
116     res = paulShellK->CalculateKCrossSection(Z    100     res = paulShellK->CalculateKCrossSection(Z, mass, incidentEnergy);
117   }                                               101   } 
118   // this check should be done in the Orlic cl    102   // this check should be done in the Orlic class, that can handle only protons;
119   // however this would lead up tp three check    103   // however this would lead up tp three checks of the mass, while here we have only one
120   // moreover, at the present time,this class     104   // moreover, at the present time,this class handles explicitly Paul and Orlic models,
121   // so it can hadle the responsibility of thi    105   // so it can hadle the responsibility of this check too
122                                                   106 
                                                   >> 107 
123   else if (mass == aProton->GetPDGMass()) {       108   else if (mass == aProton->GetPDGMass()) {
124                                                   109     
125     if(fL1Shell == shell) {                       110     if(fL1Shell == shell) { 
126       if (flag==0) res =   orlicShellLi->Calcu << 111       res = orlicShellLi->CalculateL1CrossSection(Z, incidentEnergy);
127     }                                             112     } 
128     else if(fL2Shell == shell) {                  113     else if(fL2Shell == shell) { 
129       if (flag==0) res =   orlicShellLi->Calcu << 114       res = orlicShellLi->CalculateL2CrossSection(Z, incidentEnergy);
130     }                                             115     } 
131     else if(fL3Shell == shell) {                  116     else if(fL3Shell == shell) { 
132       if (flag==0) res =   orlicShellLi->Calcu << 117       res = orlicShellLi->CalculateL3CrossSection(Z, incidentEnergy);
133     }                                             118     } 
134   }                                               119   }
135   return res;                                     120   return res;
136 }                                                 121 }
137                                                   122 
138 //....oooOO0OOooo........oooOO0OOooo........oo << 
139                                                << 
140 std::vector<G4double> G4empCrossSection::Proba    123 std::vector<G4double> G4empCrossSection::Probabilities(G4int Z,
141                    G4double incidentEnergy,    << 124                  G4double incidentEnergy,
142                    G4double mass,              << 125                  G4double mass,
143                    G4double deltaEnergy,       << 126                  G4double deltaEnergy) const
144                    const G4Material* mat)      << 127 {
145 {                                              << 128   
146   std::vector<G4double> crossSections = GetCro << 129 std::vector<G4double> crossSections = GetCrossSection(Z, incidentEnergy, mass, deltaEnergy);
147                                                   130 
148   for (size_t i=0; i<crossSections.size(); i++    131   for (size_t i=0; i<crossSections.size(); i++ ) {
149                                                   132     
150     if (totalCS) {                                133     if (totalCS) {
151       crossSections[i] = crossSections[i]/tota    134       crossSections[i] = crossSections[i]/totalCS;
152     }                                             135     }
153                                                   136     
154   }                                               137   }
                                                   >> 138 
155   return crossSections;                           139   return crossSections;
                                                   >> 140 
156 }                                                 141 }
157                                                   142 
158 //....oooOO0OOooo........oooOO0OOooo........oo << 
159                                                   143 
160 void G4empCrossSection::SetTotalCS(G4double va    144 void G4empCrossSection::SetTotalCS(G4double val){
161                                                   145 
162   totalCS = val;                                  146   totalCS = val;
163                                                   147 
164 }                                                 148 }
165                                                   149 
166                                                   150 
167                                                   151 
168                                                   152