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 4.1.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.3 2001/07/11 10:03:42 gunter Exp $
                                                   >>  25 // GEANT4 tag $Name: geant4-04-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 << 
 36                                                    37 
 37 //#include <cmath>                             <<  38 
                                                   >>  39 #include <math.h>
                                                   >>  40 // #include "G4ios.hh"
                                                   >>  41 // #include <fstream.h>
                                                   >>  42 // #include <stdlib.h>
 38                                                    43 
 39 #include "G4TransitionRadiation.hh"                44 #include "G4TransitionRadiation.hh"
                                                   >>  45 #include "G4Material.hh"
                                                   >>  46 
                                                   >>  47 // Init gamma array
                                                   >>  48 
                                                   >>  49 
                                                   >>  50 // Local constants
                                                   >>  51 
                                                   >>  52 const G4int   G4TransitionRadiation::fSympsonNumber = 100 ;
                                                   >>  53 const G4int   G4TransitionRadiation::fGammaNumber = 15 ;
                                                   >>  54 const G4int   G4TransitionRadiation::fPointNumber = 100 ;
 40                                                    55 
 41 #include "G4EmProcessSubType.hh"               << 
 42                                                    56 
 43 //////////////////////////////////////////////     57 ///////////////////////////////////////////////////////////////////////
                                                   >>  58 //
 44 // Constructor for selected couple of material     59 // Constructor for selected couple of materials
 45 G4TransitionRadiation::G4TransitionRadiation(c <<  60 //
 46                                              G << 
 47   : G4VDiscreteProcess(processName, type)      << 
 48 {                                              << 
 49   SetProcessSubType(fTransitionRadiation);     << 
 50   fMatIndex1 = fMatIndex2 = 0;                 << 
 51                                                    61 
 52   fGamma = fEnergy = fVarAngle = fMinEnergy =  <<  62 G4TransitionRadiation::
 53   fSigma1 = fSigma2 = 0.0;                     <<  63 G4TransitionRadiation( const G4String& processName )
                                                   >>  64   : G4VDiscreteProcess(processName)
                                                   >>  65 {
                                                   >>  66   //  fMatIndex1 = pMat1->GetIndex() ;
                                                   >>  67   //  fMatIndex2 = pMat2->GetIndex() ;
 54 }                                                  68 }
 55                                                    69 
 56 //////////////////////////////////////////////     70 //////////////////////////////////////////////////////////////////////
                                                   >>  71 //
 57 // Destructor                                      72 // Destructor
 58 G4TransitionRadiation::~G4TransitionRadiation( <<  73 //
 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                                                    74 
 71 G4double G4TransitionRadiation::GetMeanFreePat <<  75 G4TransitionRadiation::~G4TransitionRadiation()
 72                                                << 
 73 {                                                  76 {
 74   *condition = Forced;                         <<  77   ;
 75   return DBL_MAX;  // so TR doesn't limit mean << 
 76 }                                                  78 }
 77                                                    79 
 78 G4VParticleChange* G4TransitionRadiation::Post << 
 79                                                << 
 80 {                                              << 
 81   ClearNumberOfInteractionLengthLeft();        << 
 82   return &aParticleChange;                     << 
 83 }                                              << 
 84                                                    80 
 85 //////////////////////////////////////////////     81 ///////////////////////////////////////////////////////////////////
                                                   >>  82 //
 86 // Sympson integral of TR spectral-angle densi     83 // Sympson integral of TR spectral-angle density over energy between
 87 // the limits energy 1 and energy2 at fixed va <<  84 // the limits energy 1 and energy2 at fixed varAngle = 1 - cos(Theta)
 88 G4double G4TransitionRadiation::IntegralOverEn <<  85 
 89                                                <<  86 G4double
 90                                                <<  87 G4TransitionRadiation::IntegralOverEnergy( G4double energy1,
 91 {                                              <<  88                                            G4double energy2,
 92   G4int i;                                     <<  89                                            G4double varAngle     )  const
 93   G4double h, sumEven = 0.0, sumOdd = 0.0;     <<  90 {
 94   h = 0.5 * (energy2 - energy1) / fSympsonNumb <<  91   G4int i ;
 95   for(i = 1; i < fSympsonNumber; i++)          <<  92   G4double h , sumEven = 0.0 , sumOdd = 0.0 ;
                                                   >>  93   h = 0.5*(energy2 - energy1)/fSympsonNumber ;
                                                   >>  94   for(i=1;i<fSympsonNumber;i++)
 96   {                                                95   {
 97     sumEven += SpectralAngleTRdensity(energy1  <<  96     sumEven += SpectralAngleTRdensity(energy1 + 2*i*h,varAngle)  ;
 98     sumOdd += SpectralAngleTRdensity(energy1 + <<  97     sumOdd  += SpectralAngleTRdensity(energy1 + (2*i - 1)*h,varAngle) ;
 99   }                                                98   }
100   sumOdd +=                                    <<  99   sumOdd += SpectralAngleTRdensity(energy1 + (2*fSympsonNumber - 1)*h,varAngle) ;
101     SpectralAngleTRdensity(energy1 + (2 * fSym << 100   return h*(  SpectralAngleTRdensity(energy1,varAngle)
102   return h *                                   << 101             + SpectralAngleTRdensity(energy2,varAngle)
103          (SpectralAngleTRdensity(energy1, varA << 102             + 4.0*sumOdd + 2.0*sumEven    )/3.0 ;
104           SpectralAngleTRdensity(energy2, varA << 
105           2.0 * sumEven) /                     << 
106          3.0;                                  << 
107 }                                                 103 }
108                                                   104 
                                                   >> 105 
                                                   >> 106 
109 //////////////////////////////////////////////    107 ///////////////////////////////////////////////////////////////////
                                                   >> 108 //
110 // Sympson integral of TR spectral-angle densi    109 // Sympson integral of TR spectral-angle density over energy between
111 // the limits varAngle1 and varAngle2 at fixed    110 // the limits varAngle1 and varAngle2 at fixed energy
112 G4double G4TransitionRadiation::IntegralOverAn << 111 
113                                                << 112 G4double
114                                                << 113 G4TransitionRadiation::IntegralOverAngle( G4double energy,
115 {                                              << 114                                           G4double varAngle1,
116   G4int i;                                     << 115                                           G4double varAngle2     ) const
117   G4double h, sumEven = 0.0, sumOdd = 0.0;     << 116 {
118   h = 0.5 * (varAngle2 - varAngle1) / fSympson << 117   G4int i ;
119   for(i = 1; i < fSympsonNumber; ++i)          << 118   G4double h , sumEven = 0.0 , sumOdd = 0.0 ;
                                                   >> 119   h = 0.5*(varAngle2 - varAngle1)/fSympsonNumber ;
                                                   >> 120   for(i=1;i<fSympsonNumber;i++)
120   {                                               121   {
121     sumEven += SpectralAngleTRdensity(energy,  << 122     sumEven += SpectralAngleTRdensity(energy,varAngle1 + 2*i*h)  ;
122     sumOdd += SpectralAngleTRdensity(energy, v << 123     sumOdd  += SpectralAngleTRdensity(energy,varAngle1 + (2*i - 1)*h) ;
123   }                                               124   }
124   sumOdd +=                                    << 125   sumOdd += SpectralAngleTRdensity(energy,varAngle1 + (2*fSympsonNumber - 1)*h) ;
125     SpectralAngleTRdensity(energy, varAngle1 + << 
126                                                   126 
127   return h *                                   << 127   return h*(  SpectralAngleTRdensity(energy,varAngle1)
128          (SpectralAngleTRdensity(energy, varAn << 128             + SpectralAngleTRdensity(energy,varAngle2)
129           SpectralAngleTRdensity(energy, varAn << 129             + 4.0*sumOdd + 2.0*sumEven    )/3.0 ;
130           2.0 * sumEven) /                     << 
131          3.0;                                  << 
132 }                                                 130 }
133                                                   131 
134 //////////////////////////////////////////////    132 ///////////////////////////////////////////////////////////////////
                                                   >> 133 //
135 // The number of transition radiation photons     134 // The number of transition radiation photons generated in the
136 // angle interval between varAngle1 and varAng    135 // angle interval between varAngle1 and varAngle2
137 G4double G4TransitionRadiation::AngleIntegralD << 136 //
138   G4double varAngle1, G4double varAngle2) cons << 137 
139 {                                              << 138 G4double G4TransitionRadiation::
140   G4int i;                                     << 139 AngleIntegralDistribution( G4double varAngle1,
141   G4double h, sumEven = 0.0, sumOdd = 0.0;     << 140                            G4double varAngle2     )   const
142   h = 0.5 * (varAngle2 - varAngle1) / fSympson << 141 {
143   for(i = 1; i < fSympsonNumber; ++i)          << 142   G4int i ;
                                                   >> 143   G4double h , sumEven = 0.0 , sumOdd = 0.0 ;
                                                   >> 144   h = 0.5*(varAngle2 - varAngle1)/fSympsonNumber ;
                                                   >> 145   for(i=1;i<fSympsonNumber;i++)
144   {                                               146   {
145     sumEven += IntegralOverEnergy(fMinEnergy,  << 147    sumEven += IntegralOverEnergy(fMinEnergy,
146                                   fMinEnergy + << 148                                  fMinEnergy +0.3*(fMaxEnergy-fMinEnergy),
147                                   varAngle1 +  << 149                                  varAngle1 + 2*i*h)
148                IntegralOverEnergy(fMinEnergy + << 150             + IntegralOverEnergy(fMinEnergy + 0.3*(fMaxEnergy - fMinEnergy),
149                                   fMaxEnergy,  << 151                                  fMaxEnergy,
150     sumOdd += IntegralOverEnergy(fMinEnergy,   << 152                                  varAngle1 + 2*i*h);
151                                  fMinEnergy +  << 153    sumOdd  += IntegralOverEnergy(fMinEnergy,
152                                  varAngle1 + ( << 154                                  fMinEnergy + 0.3*(fMaxEnergy - fMinEnergy),
153               IntegralOverEnergy(fMinEnergy +  << 155                                  varAngle1 + (2*i - 1)*h)
154                                  fMaxEnergy, v << 156             + IntegralOverEnergy(fMinEnergy + 0.3*(fMaxEnergy - fMinEnergy),
                                                   >> 157                                  fMaxEnergy,
                                                   >> 158                                  varAngle1 + (2*i - 1)*h) ;
155   }                                               159   }
156   sumOdd +=                                    << 160   sumOdd += IntegralOverEnergy(fMinEnergy,
157     IntegralOverEnergy(fMinEnergy, fMinEnergy  << 161                                fMinEnergy + 0.3*(fMaxEnergy - fMinEnergy),
158                        varAngle1 + (2 * fSymps << 162                                varAngle1 + (2*fSympsonNumber - 1)*h)
159     IntegralOverEnergy(fMinEnergy + 0.3 * (fMa << 163           + IntegralOverEnergy(fMinEnergy + 0.3*(fMaxEnergy - fMinEnergy),
160                        varAngle1 + (2 * fSymps << 164                                fMaxEnergy,
161                                                << 165                                varAngle1 + (2*fSympsonNumber - 1)*h) ;
162   return h *                                   << 166 
163          (IntegralOverEnergy(fMinEnergy,       << 167   return h*(IntegralOverEnergy(fMinEnergy,
164                              fMinEnergy + 0.3  << 168                                fMinEnergy + 0.3*(fMaxEnergy - fMinEnergy),
165                              varAngle1) +      << 169                                varAngle1)
166           IntegralOverEnergy(fMinEnergy + 0.3  << 170           + IntegralOverEnergy(fMinEnergy + 0.3*(fMaxEnergy - fMinEnergy),
167                              fMaxEnergy, varAn << 171                                fMaxEnergy,
168           IntegralOverEnergy(fMinEnergy,       << 172                                varAngle1)
169                              fMinEnergy + 0.3  << 173           + IntegralOverEnergy(fMinEnergy,
170                              varAngle2) +      << 174                                fMinEnergy + 0.3*(fMaxEnergy - fMinEnergy),
171           IntegralOverEnergy(fMinEnergy + 0.3  << 175                                varAngle2)
172                              fMaxEnergy, varAn << 176           + IntegralOverEnergy(fMinEnergy + 0.3*(fMaxEnergy - fMinEnergy),
173           4.0 * sumOdd + 2.0 * sumEven) /      << 177                                fMaxEnergy,
174          3.0;                                  << 178                                varAngle2)
                                                   >> 179             + 4.0*sumOdd + 2.0*sumEven    )/3.0 ;
175 }                                                 180 }
176                                                   181 
177 //////////////////////////////////////////////    182 ///////////////////////////////////////////////////////////////////
                                                   >> 183 //
178 // The number of transition radiation photons,    184 // The number of transition radiation photons, generated in the
179 // energy interval between energy1 and energy2    185 // energy interval between energy1 and energy2
180 G4double G4TransitionRadiation::EnergyIntegral << 186 //
181   G4double energy1, G4double energy2) const    << 187 
182 {                                              << 188 G4double G4TransitionRadiation::
183   G4int i;                                     << 189 EnergyIntegralDistribution( G4double energy1,
184   G4double h, sumEven = 0.0, sumOdd = 0.0;     << 190                             G4double energy2     )  const
185   h = 0.5 * (energy2 - energy1) / fSympsonNumb << 191 {
186   for(i = 1; i < fSympsonNumber; ++i)          << 192   G4int i ;
                                                   >> 193   G4double h , sumEven = 0.0 , sumOdd = 0.0 ;
                                                   >> 194   h = 0.5*(energy2 - energy1)/fSympsonNumber ;
                                                   >> 195   for(i=1;i<fSympsonNumber;i++)
187   {                                               196   {
188     sumEven +=                                 << 197    sumEven += IntegralOverAngle(energy1 + 2*i*h,0.0,0.01*fMaxTheta )
189       IntegralOverAngle(energy1 + 2 * i * h, 0 << 198             + IntegralOverAngle(energy1 + 2*i*h,0.01*fMaxTheta,fMaxTheta);
190       IntegralOverAngle(energy1 + 2 * i * h, 0 << 199    sumOdd  += IntegralOverAngle(energy1 + (2*i - 1)*h,0.0,0.01*fMaxTheta)
191     sumOdd +=                                  << 200             + IntegralOverAngle(energy1 + (2*i - 1)*h,0.01*fMaxTheta,fMaxTheta) ;
192       IntegralOverAngle(energy1 + (2 * i - 1)  << 
193       IntegralOverAngle(energy1 + (2 * i - 1)  << 
194   }                                               201   }
195   sumOdd += IntegralOverAngle(energy1 + (2 * f << 202   sumOdd += IntegralOverAngle(energy1 + (2*fSympsonNumber - 1)*h,
196                               0.01 * fMaxTheta << 203                               0.0,0.01*fMaxTheta)
197             IntegralOverAngle(energy1 + (2 * f << 204           + IntegralOverAngle(energy1 + (2*fSympsonNumber - 1)*h,
198                               0.01 * fMaxTheta << 205                               0.01*fMaxTheta,fMaxTheta) ;
199                                                << 206 
200   return h *                                   << 207   return h*(IntegralOverAngle(energy1,0.0,0.01*fMaxTheta)
201          (IntegralOverAngle(energy1, 0.0, 0.01 << 208           + IntegralOverAngle(energy1,0.01*fMaxTheta,fMaxTheta)
202           IntegralOverAngle(energy1, 0.01 * fM << 209           + IntegralOverAngle(energy2,0.0,0.01*fMaxTheta)
203           IntegralOverAngle(energy2, 0.0, 0.01 << 210           + IntegralOverAngle(energy2,0.01*fMaxTheta,fMaxTheta)
204           IntegralOverAngle(energy2, 0.01 * fM << 211             + 4.0*sumOdd + 2.0*sumEven    )/3.0 ;
205           4.0 * sumOdd + 2.0 * sumEven) /      << 
206          3.0;                                  << 
207 }                                                 212 }
                                                   >> 213 
                                                   >> 214 
                                                   >> 215 
                                                   >> 216 
                                                   >> 217 // end of G4TransitionRadiation implementation file --------------------------
208                                                   218