Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/processes/electromagnetic/xrays/src/G4TransitionRadiation.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/xrays/src/G4TransitionRadiation.cc (Version 11.3.0) and /processes/electromagnetic/xrays/src/G4TransitionRadiation.cc (Version 8.0.p1)


  1 //                                                  1 //
  2 // *******************************************      2 // ********************************************************************
  3 // * License and Disclaimer                    <<   3 // * DISCLAIMER                                                       *
  4 // *                                                4 // *                                                                  *
  5 // * The  Geant4 software  is  copyright of th <<   5 // * The following disclaimer summarizes all the specific disclaimers *
  6 // * the Geant4 Collaboration.  It is provided <<   6 // * of contributors to this software. The specific disclaimers,which *
  7 // * conditions of the Geant4 Software License <<   7 // * govern, are listed with their locations in:                      *
  8 // * LICENSE and available at  http://cern.ch/ <<   8 // *   http://cern.ch/geant4/license                                  *
  9 // * include a list of copyright holders.      << 
 10 // *                                                9 // *                                                                  *
 11 // * Neither the authors of this software syst     10 // * Neither the authors of this software system, nor their employing *
 12 // * institutes,nor the agencies providing fin     11 // * institutes,nor the agencies providing financial support for this *
 13 // * work  make  any representation or  warran     12 // * work  make  any representation or  warranty, express or implied, *
 14 // * regarding  this  software system or assum     13 // * regarding  this  software system or assume any liability for its *
 15 // * use.  Please see the license in the file  <<  14 // * use.                                                             *
 16 // * for the full disclaimer and the limitatio << 
 17 // *                                               15 // *                                                                  *
 18 // * This  code  implementation is the result  <<  16 // * This  code  implementation is the  intellectual property  of the *
 19 // * technical work of the GEANT4 collaboratio <<  17 // * GEANT4 collaboration.                                            *
 20 // * By using,  copying,  modifying or  distri <<  18 // * By copying,  distributing  or modifying the Program (or any work *
 21 // * any work based  on the software)  you  ag <<  19 // * based  on  the Program)  you indicate  your  acceptance of  this *
 22 // * use  in  resulting  scientific  publicati <<  20 // * statement, and all its terms.                                    *
 23 // * acceptance of all terms of the Geant4 Sof << 
 24 // *******************************************     21 // ********************************************************************
 25 //                                                 22 //
                                                   >>  23 //
                                                   >>  24 // $Id: G4TransitionRadiation.cc,v 1.6 2005/07/28 23:58:01 gum Exp $
                                                   >>  25 // GEANT4 tag $Name: geant4-08-00-patch-01 $
                                                   >>  26 //
 26 // G4TransitionRadiation class -- implementati     27 // G4TransitionRadiation class -- implementation file
 27                                                    28 
 28 // GEANT 4 class implementation file --- Copyr     29 // GEANT 4 class implementation file --- Copyright CERN 1995
                                                   >>  30 // CERN Geneva Switzerland
 29                                                    31 
 30 // For information related to this code, pleas     32 // For information related to this code, please, contact
 31 // CERN, CN Division, ASD Group                    33 // CERN, CN Division, ASD Group
 32 // History:                                        34 // History:
 33 // 1st version 11.09.97 V. Grichine (Vladimir.     35 // 1st version 11.09.97 V. Grichine (Vladimir.Grichine@cern.ch )
 34 // 2nd version 16.12.97 V. Grichine                36 // 2nd version 16.12.97 V. Grichine
 35 // 3rd version 28.07.05, P.Gumplinger add G4Pr     37 // 3rd version 28.07.05, P.Gumplinger add G4ProcessType to constructor
 36                                                    38 
 37 //#include <cmath>                             <<  39 
                                                   >>  40 #include <cmath>
                                                   >>  41 // #include "G4ios.hh"
                                                   >>  42 // #include <fstream.h>
                                                   >>  43 // #include <stdlib.h>
 38                                                    44 
 39 #include "G4TransitionRadiation.hh"                45 #include "G4TransitionRadiation.hh"
                                                   >>  46 #include "G4Material.hh"
                                                   >>  47 
                                                   >>  48 // Init gamma array
                                                   >>  49 
 40                                                    50 
 41 #include "G4EmProcessSubType.hh"               <<  51 // Local constants
                                                   >>  52 
                                                   >>  53 const G4int   G4TransitionRadiation::fSympsonNumber = 100 ;
                                                   >>  54 const G4int   G4TransitionRadiation::fGammaNumber = 15 ;
                                                   >>  55 const G4int   G4TransitionRadiation::fPointNumber = 100 ;
                                                   >>  56 
                                                   >>  57 using namespace std;
 42                                                    58 
 43 //////////////////////////////////////////////     59 ///////////////////////////////////////////////////////////////////////
                                                   >>  60 //
 44 // Constructor for selected couple of material     61 // Constructor for selected couple of materials
 45 G4TransitionRadiation::G4TransitionRadiation(c <<  62 //
 46                                              G <<  63 
                                                   >>  64 G4TransitionRadiation::
                                                   >>  65 G4TransitionRadiation( const G4String& processName, G4ProcessType type )
 47   : G4VDiscreteProcess(processName, type)          66   : G4VDiscreteProcess(processName, type)
 48 {                                                  67 {
 49   SetProcessSubType(fTransitionRadiation);     <<  68   //  fMatIndex1 = pMat1->GetIndex() ;
 50   fMatIndex1 = fMatIndex2 = 0;                 <<  69   //  fMatIndex2 = pMat2->GetIndex() ;
 51                                                << 
 52   fGamma = fEnergy = fVarAngle = fMinEnergy =  << 
 53   fSigma1 = fSigma2 = 0.0;                     << 
 54 }                                                  70 }
 55                                                    71 
 56 //////////////////////////////////////////////     72 //////////////////////////////////////////////////////////////////////
                                                   >>  73 //
 57 // Destructor                                      74 // Destructor
 58 G4TransitionRadiation::~G4TransitionRadiation( <<  75 //
 59                                                << 
 60 void G4TransitionRadiation::ProcessDescription << 
 61 {                                              << 
 62   out << "Base class for simulation of x-ray t << 
 63 }                                              << 
 64                                                << 
 65 G4bool G4TransitionRadiation::IsApplicable(    << 
 66   const G4ParticleDefinition& aParticleType)   << 
 67 {                                              << 
 68   return (aParticleType.GetPDGCharge() != 0.0) << 
 69 }                                              << 
 70                                                    76 
 71 G4double G4TransitionRadiation::GetMeanFreePat <<  77 G4TransitionRadiation::~G4TransitionRadiation()
 72                                                << 
 73 {                                                  78 {
 74   *condition = Forced;                         <<  79   ;
 75   return DBL_MAX;  // so TR doesn't limit mean << 
 76 }                                                  80 }
 77                                                    81 
 78 G4VParticleChange* G4TransitionRadiation::Post << 
 79                                                << 
 80 {                                              << 
 81   ClearNumberOfInteractionLengthLeft();        << 
 82   return &aParticleChange;                     << 
 83 }                                              << 
 84                                                    82 
 85 //////////////////////////////////////////////     83 ///////////////////////////////////////////////////////////////////
                                                   >>  84 //
 86 // Sympson integral of TR spectral-angle densi     85 // Sympson integral of TR spectral-angle density over energy between
 87 // the limits energy 1 and energy2 at fixed va <<  86 // the limits energy 1 and energy2 at fixed varAngle = 1 - cos(Theta)
 88 G4double G4TransitionRadiation::IntegralOverEn <<  87 
 89                                                <<  88 G4double
 90                                                <<  89 G4TransitionRadiation::IntegralOverEnergy( G4double energy1,
 91 {                                              <<  90                                            G4double energy2,
 92   G4int i;                                     <<  91                                            G4double varAngle     )  const
 93   G4double h, sumEven = 0.0, sumOdd = 0.0;     <<  92 {
 94   h = 0.5 * (energy2 - energy1) / fSympsonNumb <<  93   G4int i ;
 95   for(i = 1; i < fSympsonNumber; i++)          <<  94   G4double h , sumEven = 0.0 , sumOdd = 0.0 ;
                                                   >>  95   h = 0.5*(energy2 - energy1)/fSympsonNumber ;
                                                   >>  96   for(i=1;i<fSympsonNumber;i++)
 96   {                                                97   {
 97     sumEven += SpectralAngleTRdensity(energy1  <<  98     sumEven += SpectralAngleTRdensity(energy1 + 2*i*h,varAngle)  ;
 98     sumOdd += SpectralAngleTRdensity(energy1 + <<  99     sumOdd  += SpectralAngleTRdensity(energy1 + (2*i - 1)*h,varAngle) ;
 99   }                                               100   }
100   sumOdd +=                                    << 101   sumOdd += SpectralAngleTRdensity(energy1 + (2*fSympsonNumber - 1)*h,varAngle) ;
101     SpectralAngleTRdensity(energy1 + (2 * fSym << 102   return h*(  SpectralAngleTRdensity(energy1,varAngle)
102   return h *                                   << 103             + SpectralAngleTRdensity(energy2,varAngle)
103          (SpectralAngleTRdensity(energy1, varA << 104             + 4.0*sumOdd + 2.0*sumEven    )/3.0 ;
104           SpectralAngleTRdensity(energy2, varA << 
105           2.0 * sumEven) /                     << 
106          3.0;                                  << 
107 }                                                 105 }
108                                                   106 
                                                   >> 107 
                                                   >> 108 
109 //////////////////////////////////////////////    109 ///////////////////////////////////////////////////////////////////
                                                   >> 110 //
110 // Sympson integral of TR spectral-angle densi    111 // Sympson integral of TR spectral-angle density over energy between
111 // the limits varAngle1 and varAngle2 at fixed    112 // the limits varAngle1 and varAngle2 at fixed energy
112 G4double G4TransitionRadiation::IntegralOverAn << 113 
113                                                << 114 G4double
114                                                << 115 G4TransitionRadiation::IntegralOverAngle( G4double energy,
115 {                                              << 116                                           G4double varAngle1,
116   G4int i;                                     << 117                                           G4double varAngle2     ) const
117   G4double h, sumEven = 0.0, sumOdd = 0.0;     << 118 {
118   h = 0.5 * (varAngle2 - varAngle1) / fSympson << 119   G4int i ;
119   for(i = 1; i < fSympsonNumber; ++i)          << 120   G4double h , sumEven = 0.0 , sumOdd = 0.0 ;
                                                   >> 121   h = 0.5*(varAngle2 - varAngle1)/fSympsonNumber ;
                                                   >> 122   for(i=1;i<fSympsonNumber;i++)
120   {                                               123   {
121     sumEven += SpectralAngleTRdensity(energy,  << 124     sumEven += SpectralAngleTRdensity(energy,varAngle1 + 2*i*h)  ;
122     sumOdd += SpectralAngleTRdensity(energy, v << 125     sumOdd  += SpectralAngleTRdensity(energy,varAngle1 + (2*i - 1)*h) ;
123   }                                               126   }
124   sumOdd +=                                    << 127   sumOdd += SpectralAngleTRdensity(energy,varAngle1 + (2*fSympsonNumber - 1)*h) ;
125     SpectralAngleTRdensity(energy, varAngle1 + << 
126                                                   128 
127   return h *                                   << 129   return h*(  SpectralAngleTRdensity(energy,varAngle1)
128          (SpectralAngleTRdensity(energy, varAn << 130             + SpectralAngleTRdensity(energy,varAngle2)
129           SpectralAngleTRdensity(energy, varAn << 131             + 4.0*sumOdd + 2.0*sumEven    )/3.0 ;
130           2.0 * sumEven) /                     << 
131          3.0;                                  << 
132 }                                                 132 }
133                                                   133 
134 //////////////////////////////////////////////    134 ///////////////////////////////////////////////////////////////////
                                                   >> 135 //
135 // The number of transition radiation photons     136 // The number of transition radiation photons generated in the
136 // angle interval between varAngle1 and varAng    137 // angle interval between varAngle1 and varAngle2
137 G4double G4TransitionRadiation::AngleIntegralD << 138 //
138   G4double varAngle1, G4double varAngle2) cons << 139 
139 {                                              << 140 G4double G4TransitionRadiation::
140   G4int i;                                     << 141 AngleIntegralDistribution( G4double varAngle1,
141   G4double h, sumEven = 0.0, sumOdd = 0.0;     << 142                            G4double varAngle2     )   const
142   h = 0.5 * (varAngle2 - varAngle1) / fSympson << 143 {
143   for(i = 1; i < fSympsonNumber; ++i)          << 144   G4int i ;
                                                   >> 145   G4double h , sumEven = 0.0 , sumOdd = 0.0 ;
                                                   >> 146   h = 0.5*(varAngle2 - varAngle1)/fSympsonNumber ;
                                                   >> 147   for(i=1;i<fSympsonNumber;i++)
144   {                                               148   {
145     sumEven += IntegralOverEnergy(fMinEnergy,  << 149    sumEven += IntegralOverEnergy(fMinEnergy,
146                                   fMinEnergy + << 150                                  fMinEnergy +0.3*(fMaxEnergy-fMinEnergy),
147                                   varAngle1 +  << 151                                  varAngle1 + 2*i*h)
148                IntegralOverEnergy(fMinEnergy + << 152             + IntegralOverEnergy(fMinEnergy + 0.3*(fMaxEnergy - fMinEnergy),
149                                   fMaxEnergy,  << 153                                  fMaxEnergy,
150     sumOdd += IntegralOverEnergy(fMinEnergy,   << 154                                  varAngle1 + 2*i*h);
151                                  fMinEnergy +  << 155    sumOdd  += IntegralOverEnergy(fMinEnergy,
152                                  varAngle1 + ( << 156                                  fMinEnergy + 0.3*(fMaxEnergy - fMinEnergy),
153               IntegralOverEnergy(fMinEnergy +  << 157                                  varAngle1 + (2*i - 1)*h)
154                                  fMaxEnergy, v << 158             + IntegralOverEnergy(fMinEnergy + 0.3*(fMaxEnergy - fMinEnergy),
                                                   >> 159                                  fMaxEnergy,
                                                   >> 160                                  varAngle1 + (2*i - 1)*h) ;
155   }                                               161   }
156   sumOdd +=                                    << 162   sumOdd += IntegralOverEnergy(fMinEnergy,
157     IntegralOverEnergy(fMinEnergy, fMinEnergy  << 163                                fMinEnergy + 0.3*(fMaxEnergy - fMinEnergy),
158                        varAngle1 + (2 * fSymps << 164                                varAngle1 + (2*fSympsonNumber - 1)*h)
159     IntegralOverEnergy(fMinEnergy + 0.3 * (fMa << 165           + IntegralOverEnergy(fMinEnergy + 0.3*(fMaxEnergy - fMinEnergy),
160                        varAngle1 + (2 * fSymps << 166                                fMaxEnergy,
161                                                << 167                                varAngle1 + (2*fSympsonNumber - 1)*h) ;
162   return h *                                   << 168 
163          (IntegralOverEnergy(fMinEnergy,       << 169   return h*(IntegralOverEnergy(fMinEnergy,
164                              fMinEnergy + 0.3  << 170                                fMinEnergy + 0.3*(fMaxEnergy - fMinEnergy),
165                              varAngle1) +      << 171                                varAngle1)
166           IntegralOverEnergy(fMinEnergy + 0.3  << 172           + IntegralOverEnergy(fMinEnergy + 0.3*(fMaxEnergy - fMinEnergy),
167                              fMaxEnergy, varAn << 173                                fMaxEnergy,
168           IntegralOverEnergy(fMinEnergy,       << 174                                varAngle1)
169                              fMinEnergy + 0.3  << 175           + IntegralOverEnergy(fMinEnergy,
170                              varAngle2) +      << 176                                fMinEnergy + 0.3*(fMaxEnergy - fMinEnergy),
171           IntegralOverEnergy(fMinEnergy + 0.3  << 177                                varAngle2)
172                              fMaxEnergy, varAn << 178           + IntegralOverEnergy(fMinEnergy + 0.3*(fMaxEnergy - fMinEnergy),
173           4.0 * sumOdd + 2.0 * sumEven) /      << 179                                fMaxEnergy,
174          3.0;                                  << 180                                varAngle2)
                                                   >> 181             + 4.0*sumOdd + 2.0*sumEven    )/3.0 ;
175 }                                                 182 }
176                                                   183 
177 //////////////////////////////////////////////    184 ///////////////////////////////////////////////////////////////////
                                                   >> 185 //
178 // The number of transition radiation photons,    186 // The number of transition radiation photons, generated in the
179 // energy interval between energy1 and energy2    187 // energy interval between energy1 and energy2
180 G4double G4TransitionRadiation::EnergyIntegral << 188 //
181   G4double energy1, G4double energy2) const    << 189 
182 {                                              << 190 G4double G4TransitionRadiation::
183   G4int i;                                     << 191 EnergyIntegralDistribution( G4double energy1,
184   G4double h, sumEven = 0.0, sumOdd = 0.0;     << 192                             G4double energy2     )  const
185   h = 0.5 * (energy2 - energy1) / fSympsonNumb << 193 {
186   for(i = 1; i < fSympsonNumber; ++i)          << 194   G4int i ;
                                                   >> 195   G4double h , sumEven = 0.0 , sumOdd = 0.0 ;
                                                   >> 196   h = 0.5*(energy2 - energy1)/fSympsonNumber ;
                                                   >> 197   for(i=1;i<fSympsonNumber;i++)
187   {                                               198   {
188     sumEven +=                                 << 199    sumEven += IntegralOverAngle(energy1 + 2*i*h,0.0,0.01*fMaxTheta )
189       IntegralOverAngle(energy1 + 2 * i * h, 0 << 200             + IntegralOverAngle(energy1 + 2*i*h,0.01*fMaxTheta,fMaxTheta);
190       IntegralOverAngle(energy1 + 2 * i * h, 0 << 201    sumOdd  += IntegralOverAngle(energy1 + (2*i - 1)*h,0.0,0.01*fMaxTheta)
191     sumOdd +=                                  << 202             + IntegralOverAngle(energy1 + (2*i - 1)*h,0.01*fMaxTheta,fMaxTheta) ;
192       IntegralOverAngle(energy1 + (2 * i - 1)  << 
193       IntegralOverAngle(energy1 + (2 * i - 1)  << 
194   }                                               203   }
195   sumOdd += IntegralOverAngle(energy1 + (2 * f << 204   sumOdd += IntegralOverAngle(energy1 + (2*fSympsonNumber - 1)*h,
196                               0.01 * fMaxTheta << 205                               0.0,0.01*fMaxTheta)
197             IntegralOverAngle(energy1 + (2 * f << 206           + IntegralOverAngle(energy1 + (2*fSympsonNumber - 1)*h,
198                               0.01 * fMaxTheta << 207                               0.01*fMaxTheta,fMaxTheta) ;
199                                                << 208 
200   return h *                                   << 209   return h*(IntegralOverAngle(energy1,0.0,0.01*fMaxTheta)
201          (IntegralOverAngle(energy1, 0.0, 0.01 << 210           + IntegralOverAngle(energy1,0.01*fMaxTheta,fMaxTheta)
202           IntegralOverAngle(energy1, 0.01 * fM << 211           + IntegralOverAngle(energy2,0.0,0.01*fMaxTheta)
203           IntegralOverAngle(energy2, 0.0, 0.01 << 212           + IntegralOverAngle(energy2,0.01*fMaxTheta,fMaxTheta)
204           IntegralOverAngle(energy2, 0.01 * fM << 213             + 4.0*sumOdd + 2.0*sumEven    )/3.0 ;
205           4.0 * sumOdd + 2.0 * sumEven) /      << 
206          3.0;                                  << 
207 }                                                 214 }
                                                   >> 215 
                                                   >> 216 
                                                   >> 217 
                                                   >> 218 
                                                   >> 219 // end of G4TransitionRadiation implementation file --------------------------
208                                                   220