G4ScreenedNuclearRecoil.cc File Reference

Implementation of the G4ScreenedNuclearRecoil class. More...

#include <stdio.h>
#include "globals.hh"
#include "G4ScreenedNuclearRecoil.hh"
#include "G4ParticleTypes.hh"
#include "G4ParticleTable.hh"
#include "G4VParticleChange.hh"
#include "G4ParticleChangeForLoss.hh"
#include "G4DataVector.hh"
#include "G4Track.hh"
#include "G4Step.hh"
#include "G4Material.hh"
#include "G4Element.hh"
#include "G4Isotope.hh"
#include "G4MaterialCutsCouple.hh"
#include "G4ElementVector.hh"
#include "G4IsotopeVector.hh"
#include "G4EmProcessSubType.hh"
#include "G4ParticleDefinition.hh"
#include "G4DynamicParticle.hh"
#include "G4ProcessManager.hh"
#include "G4StableIsotopes.hh"
#include "G4LindhardPartition.hh"
#include "G4PhysicalConstants.hh"
#include "G4SystemOfUnits.hh"
#include "Randomize.hh"
#include <iostream>
#include <iomanip>
#include "c2_factory.hh"
#include <vector>

Go to the source code of this file.

Typedefs
typedef c2_ptr< G4double >	c2p

Functions
G4_c2_function &	ZBLScreening (G4int z1, G4int z2, size_t npoints, G4double rMax, G4double *auval)
G4_c2_function &	MoliereScreening (G4int z1, G4int z2, size_t npoints, G4double rMax, G4double *auval)
G4_c2_function &	LJScreening (G4int z1, G4int z2, size_t npoints, G4double rMax, G4double *auval)
G4_c2_function &	LJZBLScreening (G4int z1, G4int z2, size_t npoints, G4double rMax, G4double *auval)

Detailed Description

Implementation of the G4ScreenedNuclearRecoil class.

Definition in file G4ScreenedNuclearRecoil.cc.

Typedef Documentation

typedef c2_ptr<G4double> c2p

Definition at line 123 of file G4ScreenedNuclearRecoil.cc.

Function Documentation

G4_c2_function& LJScreening	(	G4int	z1,
		G4int	z2,
		size_t	npoints,
		G4double	rMax,
		G4double *	auval
	)

Definition at line 787 of file G4ScreenedNuclearRecoil.cc.

References python.hepunit::angstrom, and c2_factory< float_type >::lin_log_interpolating_function().

Referenced by G4NativeScreenedCoulombCrossSection::G4NativeScreenedCoulombCrossSection(), and LJZBLScreening().

{        
//from Loftager, Besenbacher, Jensen & Sorensen
//PhysRev A20, 1443++, 1979
        G4double au=0.8853*0.529*angstrom/std::sqrt(std::pow(z1, 0.6667)+std::pow(z2,0.6667));
        std::vector<G4double> r(npoints), phi(npoints);
        
        for(size_t i=0; i<npoints; i++) {
                G4double rr=(float)i/(float)(npoints-1);
                r[i]=rr*rr*rMax; // use quadratic r scale to make sampling fine near the center

                G4double y=std::sqrt(9.67*r[i]/au);
                G4double ysq=y*y;
                G4double phipoly=1+y+0.3344*ysq+0.0485*y*ysq+0.002647*ysq*ysq;
                phi[i]=phipoly*std::exp(-y);
                // G4cout << r[i] << " " << phi[i] << G4endl;
        }

        // compute the derivative at the origin for the spline
        G4double logphiprime0=(9.67/2.0)*(2*0.3344-1.0); // #avoid 0/0 on first element
        logphiprime0 *= (1.0/au); // #put back in natural units
        
        *auval=au;
        return c2.lin_log_interpolating_function().load(r, phi, false, logphiprime0*phi[0],true,0);
}

G4_c2_function& LJZBLScreening	(	G4int	z1,
		G4int	z2,
		size_t	npoints,
		G4double	rMax,
		G4double *	auval
	)

connector in between. These numbers are selected so the switchover

Definition at line 813 of file G4ScreenedNuclearRecoil.cc.

References c2_piecewise_function_p< float_type >::append_function(), c2_factory< float_type >::connector_function(), LJScreening(), c2_factory< float_type >::piecewise_function(), c2_const_ptr< float_type >::release_for_return(), c2_function< float_type >::set_domain(), c2_function< float_type >::xmax(), c2_function< float_type >::xmin(), and ZBLScreening().

Referenced by G4NativeScreenedCoulombCrossSection::G4NativeScreenedCoulombCrossSection().

{        
// hybrid of LJ and ZBL, uses LJ if x < 0.25*auniv, ZBL if x > 1.5*auniv, and 
/// connector in between.  These numbers are selected so the switchover
// is very near the point where the functions naturally cross.
        G4double auzbl, aulj;
        
        c2p zbl=ZBLScreening(z1, z2, npoints, rMax, &auzbl);
        c2p lj=LJScreening(z1, z2, npoints, rMax, &aulj);

        G4double au=(auzbl+aulj)*0.5;
        lj->set_domain(lj->xmin(), 0.25*au);
        zbl->set_domain(1.5*au,zbl->xmax());
        
        c2p conn=c2.connector_function(lj->xmax(), lj, zbl->xmin(), zbl, true,0);
        c2_piecewise_function_p<G4double> &pw=c2.piecewise_function();
        c2p keepit(pw);
        pw.append_function(lj);
        pw.append_function(conn);
        pw.append_function(zbl);
        
        *auval=au;
        keepit.release_for_return();
        return pw;
}

G4_c2_function& MoliereScreening	(	G4int	z1,
		G4int	z2,
		size_t	npoints,
		G4double	rMax,
		G4double *	auval
	)

Definition at line 761 of file G4ScreenedNuclearRecoil.cc.

References python.hepunit::angstrom, and c2_factory< float_type >::lin_log_interpolating_function().

Referenced by G4NativeScreenedCoulombCrossSection::G4NativeScreenedCoulombCrossSection().

{        
        static const size_t ncoef=3;
        static G4double scales[ncoef]={-6.0, -1.2, -0.3};
        static G4double coefs[ncoef]={0.10, 0.55, 0.35};
        
        G4double au=0.8853*0.529*angstrom/std::sqrt(std::pow(z1, 0.6667)+std::pow(z2,0.6667));
        std::vector<G4double> r(npoints), phi(npoints);
        
        for(size_t i=0; i<npoints; i++) {
                G4double rr=(float)i/(float)(npoints-1);
                r[i]=rr*rr*rMax; // use quadratic r scale to make sampling fine near the center
                G4double sum=0.0;
                for(size_t j=0; j<ncoef; j++) sum+=coefs[j]*std::exp(scales[j]*r[i]/au);
                phi[i]=sum;
        }
        
        // compute the derivative at the origin for the spline
        G4double phiprime0=0.0;
        for(size_t j=0; j<ncoef; j++) phiprime0+=scales[j]*coefs[j]*std::exp(scales[j]*r[0]/au);
        phiprime0*=(1.0/au); // put back in natural units;
        
        *auval=au;
        return c2.lin_log_interpolating_function().load(r, phi, false, phiprime0,true,0);
}

G4_c2_function& ZBLScreening	(	G4int	z1,
		G4int	z2,
		size_t	npoints,
		G4double	rMax,
		G4double *	auval
	)

Definition at line 735 of file G4ScreenedNuclearRecoil.cc.

References python.hepunit::angstrom, and c2_factory< float_type >::lin_log_interpolating_function().

Referenced by G4NativeScreenedCoulombCrossSection::G4NativeScreenedCoulombCrossSection(), and LJZBLScreening().

{
        static const size_t ncoef=4;
        static G4double scales[ncoef]={-3.2, -0.9432, -0.4028, -0.2016};
        static G4double coefs[ncoef]={0.1818,0.5099,0.2802,0.0281};
        
        G4double au=0.8854*angstrom*0.529/(std::pow(z1, 0.23)+std::pow(z2,0.23));
        std::vector<G4double> r(npoints), phi(npoints);
        
        for(size_t i=0; i<npoints; i++) {
                G4double rr=(float)i/(float)(npoints-1);
                r[i]=rr*rr*rMax; // use quadratic r scale to make sampling fine near the center
                G4double sum=0.0;
                for(size_t j=0; j<ncoef; j++) sum+=coefs[j]*std::exp(scales[j]*r[i]/au);
                phi[i]=sum;
        }

        // compute the derivative at the origin for the spline
        G4double phiprime0=0.0;
        for(size_t j=0; j<ncoef; j++) phiprime0+=scales[j]*coefs[j]*std::exp(scales[j]*r[0]/au);
        phiprime0*=(1.0/au); // put back in natural units;
        
        *auval=au;
        return c2.lin_log_interpolating_function().load(r, phi, false, phiprime0,true,0);
}