#include <G4BaierKatkov.hh>

Public Member Functions
	G4BaierKatkov ()

	~G4BaierKatkov ()=default

G4double	GetSinglePhotonRadiationProbabilityLimit ()
	get functions

G4double	GetTotalRadiationProbability ()
	total probability of radiation: needs calculation of DoRadiation first

G4double	GetParticleNewTotalEnergy ()

G4double	GetParticleNewAngleX ()

G4double	GetParticleNewAngleY ()

G4double	GetNewGlobalTime ()

const G4ThreeVector &	GetParticleNewCoordinateXYZ ()

const std::vector< G4double > &	GetPhotonEnergyInSpectrum ()
	get photon energies (x-value in spectrum)

const std::vector< G4double > &	GetTotalSpectrum ()
	get fTotalSpectrum after finishing the trajectory part with DoRadiation

void	SetSinglePhotonRadiationProbabilityLimit (G4double wmax)
	set functions

void	SetNSmallTrajectorySteps (G4int nSmallTrajectorySteps)

void	ResetRadIntegral ()

void	SetSamplingPhotonsNumber (G4int nPhotons)

void	SetRadiationAngleFactor (G4double radiationAngleFactor)

void	SetSpectrumEnergyRange (G4double emin, G4double emax, G4int numberOfBins)

void	SetMinPhotonEnergy (G4double emin)
	SetSpectrumEnergyRange also calls ResetRadIntegral()

void	SetMaxPhotonEnergy (G4double emax)

void	SetNBinsSpectrum (G4int nbin)

void	AddStatisticsInPhotonEnergyRegion (G4double emin, G4double emax, G4int timesPhotonStatistics)

void	SetVirtualCollimator (G4double virtualCollimatorAngularDiameter)

G4bool	DoRadiation (G4double etotal, G4double mass, G4double angleX, G4double angleY, G4double angleScatteringX, G4double angleScatteringY, G4double step, G4double globalTime, G4ThreeVector coordinateXYZ, G4bool flagEndTrajectory=false)

void	GeneratePhoton (G4FastStep &fastStep)

Detailed Description

Definition at line 51 of file G4BaierKatkov.hh.

Constructor & Destructor Documentation

◆ G4BaierKatkov()

G4BaierKatkov::G4BaierKatkov ( )

Definition at line 39 of file G4BaierKatkov.cc.

{
    //sets the default spectrum energy range of integration and
    //calls ResetRadIntegral()
    SetSpectrumEnergyRange(0.1*MeV,1.*GeV,110);
 
    //Do not worry if the maximal energy > particle energy
    //this elements of spectrum with non-physical energies
    //will not be processed (they will be 0)
 
    G4cout << " "<< G4endl;
    G4cout << "G4BaierKatkov model is activated."<< G4endl;
    G4cout << " "<< G4endl;
}

◆ ~G4BaierKatkov()

G4BaierKatkov::~G4BaierKatkov ( )

default

Member Function Documentation

◆ AddStatisticsInPhotonEnergyRegion()

void G4BaierKatkov::AddStatisticsInPhotonEnergyRegion	(	G4double	emin,
		G4double	emax,
		G4int	timesPhotonStatistics )

Increase the statistic of virtual photons in a certain energy region CAUTION! : don't do it before SetSpectrumEnergyRange or SetMinPhotonEnergy

Definition at line 152 of file G4BaierKatkov.cc.

{
 
    if(timesPhotonStatistics<=1)
    {
        G4cout << "G4BaierKatkov model, "
                  "function AddStatisticsInPhotonEnergyRegion("
                              << emin/CLHEP::MeV << " MeV, "
                              << emax/CLHEP::MeV << " MeV, "
                              << timesPhotonStatistics << ")" << G4endl;
        G4cout << "Warning: the statistics factor cannot be <=1." << G4endl;
        G4cout << "The statistics was not added." << G4endl;
        G4cout << " "<< G4endl;
    }
    else if(fMinPhotonEnergy>emin)
    {
        G4cout << "G4BaierKatkov model, "
                  "function AddStatisticsInPhotonEnergyRegion("
                              << emin/CLHEP::MeV << " MeV, "
                              << emax/CLHEP::MeV << " MeV, "
                              << timesPhotonStatistics << ")" << G4endl;
        G4cout << "Warning: the minimal energy inserted is less then "
                  "the minimal energy cut of the spectrum: "
               << fMinPhotonEnergy/CLHEP::MeV << " MeV." << G4endl;
        G4cout << "The statistics was not added." << G4endl;
        G4cout << " "<< G4endl;
    }
    else if(emax-emin<DBL_EPSILON)
    {
        G4cout << "G4BaierKatkov model, "
                  "function AddStatisticsInPhotonEnergyRegion("
                              << emin/CLHEP::MeV << " MeV, "
                              << emax/CLHEP::MeV << " MeV, "
                              << timesPhotonStatistics << ")" << G4endl;
        G4cout << "Warning: the maximal energy <= the minimal energy." << G4endl;
        G4cout << "The statistics was not added." << G4endl;
        G4cout << " "<< G4endl;
    }
    else
    {
        G4bool setrange = true;
        G4double logAddRangeEmindEmin = G4Log(emin/fMinPhotonEnergy);
        G4double logAddRangeEmaxdEmin = G4Log(emax/fMinPhotonEnergy);
 
        G4int nAddRange = (G4int)fTimesPhotonStatistics.size();
        for (G4int j=0;j<nAddRange;j++)
        {
            if((logAddRangeEmindEmin>=fLogAddRangeEmindEmin[j]&&
                logAddRangeEmindEmin< fLogAddRangeEmaxdEmin[j])||
               (logAddRangeEmaxdEmin> fLogAddRangeEmindEmin[j]&&
                logAddRangeEmaxdEmin<=fLogAddRangeEmaxdEmin[j])||
               (logAddRangeEmindEmin<=fLogAddRangeEmindEmin[j]&&
                logAddRangeEmaxdEmin>=fLogAddRangeEmaxdEmin[j]))
            {
                G4cout << "G4BaierKatkov model, "
                          "function AddStatisticsInPhotonEnergyRegion("
                                      << emin/CLHEP::MeV << " MeV, "
                                      << emax/CLHEP::MeV << " MeV, "
                                      << timesPhotonStatistics << ")" << G4endl;
               G4cout << "Warning: the energy range intersects another "
                         "added energy range." << G4endl;
               G4cout << "The statistics was not added." << G4endl;
               G4cout << " "<< G4endl;
               setrange = false;
               break;
            }
        }
        if (setrange)
        {
            fLogAddRangeEmindEmin.push_back(logAddRangeEmindEmin);
            fLogAddRangeEmaxdEmin.push_back(logAddRangeEmaxdEmin);
            fTimesPhotonStatistics.push_back(timesPhotonStatistics);
 
            G4cout << "G4BaierKatkov model: increasing the statistics of photon sampling "
                      "in Baier-Katkov with a factor of "
                   << timesPhotonStatistics << G4endl;
            G4cout << "in the energy spectrum range: ("
                   << emin/CLHEP::MeV << " MeV, "
                   << emax/CLHEP::MeV << " MeV)" << G4endl;
        }
    }
}

◆ DoRadiation()

G4bool G4BaierKatkov::DoRadiation	(	G4double	etotal,
		G4double	mass,
		G4double	angleX,
		G4double	angleY,
		G4double	angleScatteringX,
		G4double	angleScatteringY,
		G4double	step,
		G4double	globalTime,
		G4ThreeVector	coordinateXYZ,
		G4bool	flagEndTrajectory = false )

add the new elements of the trajectory, calculate radiation in a crystal see complete description in G4BaierKatkov::DoRadiation calls RadIntegral and all the necessary functions sets the parameters of a photon produced (if any) using SetPhotonProductionParameters() returns true in the case of photon generation, false if not

DoRadiation description

The real trajectory is divided onto parts. Every part is accumulated until the radiation cannot be considered as single photon, i.e. the radiation probability exceeds some threshold fSinglePhotonRadiationProbabilityLimit. Typically fSinglePhotonRadiationProbabilityLimit should be between 0.01 and 0.1. Then the photon generation as well as its parameters are simulated in SetPhotonProductionParameters()

Finally if radiation took place, this function sets the new particle parameters (the parameters at the point of radiation emission) fNewParticleEnergy; fNewParticleAngleX; fNewParticleAngleY; NewStep; fNewGlobalTime; fNewParticleCoordinateXYZ;

In order to control if the trajectory part reaches this limit, one needs to divide it into smaller pieces (consisting of fNSmallTrajectorySteps elements, typically several hundred) and to calculate the total radiation probability along the trajectory part after each small piece accomplished. If it exceeds the fSinglePhotonRadiationProbabilityLimit, the trajectory part is over and the radiation can be generated.

In order to calculate the radiation probability the Baier-Katkov integral is called after each small piece of the trajectory. It is summarized with the integral along the previous small pieces for this part of the trajectory.

To speed-up the simulations, the photon angles are generated only once at the start of the trajectory part.

Definition at line 652 of file G4BaierKatkov.cc.

{
    /**
    DoRadiation description
 
    The real trajectory is divided onto parts.
    Every part is accumulated until the radiation cannot be considered as single photon,
    i.e. the radiation probability exceeds some threshold
    fSinglePhotonRadiationProbabilityLimit.
    Typically fSinglePhotonRadiationProbabilityLimit should be between 0.01 and 0.1.
    Then the photon generation as well as its parameters are simulated
    in SetPhotonProductionParameters()
 
    Finally if radiation took place, this function sets the new particle parameters
    (the parameters at the point of radiation emission)
    fNewParticleEnergy; fNewParticleAngleX;
    fNewParticleAngleY; NewStep; fNewGlobalTime; fNewParticleCoordinateXYZ;
 
    In order to control if the trajectory part reaches this limit,
    one needs to divide it into smaller pieces (consisting of
    fNSmallTrajectorySteps elements, typically several hundred) and to calculate the total
    radiation probability along the trajectory part after each small piece accomplished.
    If it exceeds the fSinglePhotonRadiationProbabilityLimit,
    the trajectory part is over and the radiation can be generated.
 
    In order to calculate the radiation probability the Baier-Katkov integral is called
    after each small piece of the trajectory. It is summarized with the integral along
    the previous small pieces for this part of the trajectory.
 
    To speed-up the simulations, the photon angles are generated only once
    at the start of the trajectory part.
    */
 
    //flag if a photon was produced
    G4bool flagPhotonProduced = false;
 
    //adding the next trajectory element to the vectors
    fParticleAnglesX.push_back(angleX);
    fParticleAnglesY.push_back(angleY);
    fScatteringAnglesX.push_back(angleScatteringX);
    fScatteringAnglesY.push_back(angleScatteringY);
    fSteps.push_back(step);
    fGlobalTimes.push_back(globalTime);
    fParticleCoordinatesXYZ.push_back(coordinateXYZ);
 
    G4double imax = fSteps.size();
    if((imax==fImin0+fNSmallTrajectorySteps)||flagEndTrajectory)
    {
        //set the angular limits at the start of the trajectory part
        if(fImin0==0)
        {
            //radiation within the angle = +-fRadiationAngleFactor/gamma
            G4double radiationAngleLimit=fRadiationAngleFactor*mass/etotal;
 
            SetPhotonSamplingParameters(etotal-mass,
            *std::min_element(fParticleAnglesX.begin(),
                              fParticleAnglesX.end())-radiationAngleLimit,
            *std::max_element(fParticleAnglesX.begin(),
                              fParticleAnglesX.end())+radiationAngleLimit,
            *std::min_element(fParticleAnglesY.begin(),
                              fParticleAnglesY.end())-radiationAngleLimit,
            *std::max_element(fParticleAnglesY.begin(),
                              fParticleAnglesY.end())+radiationAngleLimit);
 
            //calculation of angles of photon emission
            //(these angles are integration variables, Monte Carlo integration)
            GeneratePhotonSampling();
        }
 
        //calculate Baier-Katkov integral after this
        //small piece of trajectory (fNSmallTrajectorySteps elements)
        fTotalRadiationProbability = RadIntegral(etotal,mass,
                                                fParticleAnglesX,fParticleAnglesY,
                                                fScatteringAnglesX,fScatteringAnglesY,
                                                fSteps, fImin0);
 
        //setting the last element of this small trajectory piece
        fImin0 = imax;
        fImax0.push_back(imax*1.);
 
        //if the radiation probability is high enough or if we are finishing
        //our trajectory => to simulate the photon emission
        if(fTotalRadiationProbability>fSinglePhotonRadiationProbabilityLimit||
                flagEndTrajectory)
        {
            fItrajectories += 1; //count this trajectory !!!correction 19.07.2023
 
            flagPhotonProduced = SetPhotonProductionParameters(etotal,mass);
 
            // correction 19.07.2023 fItrajectories += 1; //count this trajectory
 
            //reinitialize intermediate integrals fFa, fSs, fSc, fSsx, fSsy, fScx, fScy;
            //reset radiation integral internal variables to defaults;
            //reset the trajectory and radiation probability along the trajectory
            ResetRadIntegral();
        }
    }
 
    return flagPhotonProduced;
}

◆ GeneratePhoton()

void G4BaierKatkov::GeneratePhoton ( G4FastStep & fastStep )

generates secondary photon belonging to fastStep with variables photon energy, momentum direction, coordinates and global time CALCULATED IN DoRadiation => USE IT ONLY AFTER DoRadiation returns true

Definition at line 760 of file G4BaierKatkov.cc.

{
    const G4DynamicParticle theGamma = G4DynamicParticle(G4Gamma::Gamma(),
                                                         PhMomentumDirection,fEph0);
    //generation of a secondary photon
    fastStep.CreateSecondaryTrack(theGamma,fNewParticleCoordinateXYZ,fNewGlobalTime,true);
}

◆ GetNewGlobalTime()

G4double G4BaierKatkov::GetNewGlobalTime ( )

inline

Definition at line 102 of file G4BaierKatkov.hh.

102{return fNewGlobalTime;}

◆ GetParticleNewAngleX()

G4double G4BaierKatkov::GetParticleNewAngleX ( )

inline

Definition at line 100 of file G4BaierKatkov.hh.

100{return fNewParticleAngleX;}

◆ GetParticleNewAngleY()

G4double G4BaierKatkov::GetParticleNewAngleY ( )

inline

Definition at line 101 of file G4BaierKatkov.hh.

101{return fNewParticleAngleY;}

◆ GetParticleNewCoordinateXYZ()

const G4ThreeVector & G4BaierKatkov::GetParticleNewCoordinateXYZ ( )

inline

Definition at line 103 of file G4BaierKatkov.hh.

103{return fNewParticleCoordinateXYZ;}

◆ GetParticleNewTotalEnergy()

G4double G4BaierKatkov::GetParticleNewTotalEnergy ( )

inline

get new parameters of the particle (the parameters at the point of radiation emission) needs calculation of DoRadiation first

Definition at line 99 of file G4BaierKatkov.hh.

99{return fNewParticleEnergy;}

◆ GetPhotonEnergyInSpectrum()

const std::vector< G4double > & G4BaierKatkov::GetPhotonEnergyInSpectrum ( )

inline

get photon energies (x-value in spectrum)

Definition at line 106 of file G4BaierKatkov.hh.

107 {return fPhotonEnergyInSpectrum;}

◆ GetSinglePhotonRadiationProbabilityLimit()

G4double G4BaierKatkov::GetSinglePhotonRadiationProbabilityLimit ( )

inline

get functions

You may call DoRadiation at each step of your trajectory CAUTION: please ensure that your steps are physically small enough for calculation of the radiation type you are interested in CAUTION: do ResetRadIntegral() before the start of a new trajectory

1) change some model defaults if necessary (SetSinglePhotonRadiationProbabilityLimit, SetNSmallTrajectorySteps, SetSpectrumEnergyRange) 2) call DoRadiation at each step of your trajectory 3) if DoRadiation returns TRUE, this means that a photon is produced (not added as a secondary yet) and its parameters are calculated. 4) You may generate a new photon using GeneratePhoton either with the parameters calculated in DoRadiation or your own parameters. CAUTION: By now GeneratePhoton works only for a FastSim model 5) Use GetPhotonEnergyInSpectrum() and GetTotalSpectrum() to return calculated total spectrum (all the photons altogether) Caution: is not normalized on the event number 6) Get the charged particle parameters in the radiation point: GetParticleNewTotalEnergy(), GetParticleNewAngleX(), GetParticleNewAngleY(), GetNewGlobalTime(), GetParticleNewCoordinateXYZ() get maximal radiation probability to preserve single photon radiation

Definition at line 88 of file G4BaierKatkov.hh.

89 {return fSinglePhotonRadiationProbabilityLimit;}

◆ GetTotalRadiationProbability()

G4double G4BaierKatkov::GetTotalRadiationProbability ( )

inline

total probability of radiation: needs calculation of DoRadiation first

CAUTION! : use the get functions below ONLY AFTER the call of DoRadiation and ONLY IF IT RETURNS true

Definition at line 95 of file G4BaierKatkov.hh.

95{return fTotalRadiationProbability;}

◆ GetTotalSpectrum()

const std::vector< G4double > & G4BaierKatkov::GetTotalSpectrum ( )

inline

get fTotalSpectrum after finishing the trajectory part with DoRadiation

Definition at line 110 of file G4BaierKatkov.hh.

110{return fTotalSpectrum;}

◆ ResetRadIntegral()

void G4BaierKatkov::ResetRadIntegral ( )

reinitialize intermediate integrals fFa, fSs, fSc, fSsx, fSsy, fScx, fScy; reset radiation integral internal variables to defaults; reset the trajectory and radiation probability along the trajectory

Definition at line 56 of file G4BaierKatkov.cc.

{
    fAccumSpectrum.clear();
 
    //reinitialize intermediate integrals with zeros
    fFa.resize(fNMCPhotons);
    fSs.resize(fNMCPhotons);
    fSc.resize(fNMCPhotons);
    fSsx.resize(fNMCPhotons);
    fSsy.resize(fNMCPhotons);
    fScx.resize(fNMCPhotons);
    fScy.resize(fNMCPhotons);
    std::fill(fFa.begin(), fFa.end(), 0.);
    std::fill(fSs.begin(), fSs.end(), 0.);
    std::fill(fSc.begin(), fSc.end(), 0.);
    std::fill(fSsx.begin(), fSsx.end(), 0.);
    std::fill(fSsy.begin(), fSsy.end(), 0.);
    std::fill(fScx.begin(), fScx.end(), 0.);
    std::fill(fScy.begin(), fScy.end(), 0.);
 
    //Reset radiation integral internal variables to defaults
    fMeanPhotonAngleX =0.;        //average angle of
                                  //radiated photon direction in sampling, x-plane
    fParamPhotonAngleX=1.e-3*rad; //a parameter of
                                  //radiated photon sampling distribution, x-plane
    fMeanPhotonAngleY =0.;        //average angle of
                                  //radiated photon direction in sampling, y-plane
    fParamPhotonAngleY=1.e-3*rad; //a parameter of
                                  //radiated photon sampling distribution, y-plane
 
    fImin0 = 0;//set the first vector element to 0
 
    //reset the trajectory
    fParticleAnglesX.clear();
    fParticleAnglesY.clear();
    fScatteringAnglesX.clear();
    fScatteringAnglesY.clear();
    fSteps.clear();
    fGlobalTimes.clear();
    fParticleCoordinatesXYZ.clear();
 
    //resets the vector of element numbers at the trajectory start
    fImax0.clear();
    //sets 0 element of the vector of element numbers
    fImax0.push_back(0.);
 
    //resets the radiation probability
    fTotalRadiationProbabilityAlongTrajectory.clear();
    //sets the radiation probability at the trajectory start
    fTotalRadiationProbabilityAlongTrajectory.push_back(0.);
}

Referenced by DoRadiation(), and SetSpectrumEnergyRange().

◆ SetMaxPhotonEnergy()

void G4BaierKatkov::SetMaxPhotonEnergy ( G4double emax )

inline

Definition at line 149 of file G4BaierKatkov.hh.

                                          {SetSpectrumEnergyRange(fMinPhotonEnergy,
                                                                  emax,
                                                                  fNBinsSpectrum);}

◆ SetMinPhotonEnergy()

void G4BaierKatkov::SetMinPhotonEnergy ( G4double emin )

inline

SetSpectrumEnergyRange also calls ResetRadIntegral()

Definition at line 146 of file G4BaierKatkov.hh.

                                          {SetSpectrumEnergyRange(emin,
                                                                  fMaxPhotonEnergy,
                                                                  fNBinsSpectrum);}

◆ SetNBinsSpectrum()

void G4BaierKatkov::SetNBinsSpectrum ( G4int nbin )

inline

Definition at line 152 of file G4BaierKatkov.hh.

                                     {SetSpectrumEnergyRange(fMinPhotonEnergy,
                                                             fMaxPhotonEnergy,
                                                             nbin);}

◆ SetNSmallTrajectorySteps()

void G4BaierKatkov::SetNSmallTrajectorySteps ( G4int nSmallTrajectorySteps )

inline

number of steps in a trajectory small piece before the next call of the radiation integral

Definition at line 120 of file G4BaierKatkov.hh.

121 {fNSmallTrajectorySteps = nSmallTrajectorySteps;}

◆ SetRadiationAngleFactor()

void G4BaierKatkov::SetRadiationAngleFactor ( G4double radiationAngleFactor )

inline

setting the number of radiation angles 1/gamma, defining the width of the angular distribution of photon sampling in the Baier-Katkov Integral

Definition at line 134 of file G4BaierKatkov.hh.

135 {fRadiationAngleFactor = radiationAngleFactor;}

◆ SetSamplingPhotonsNumber()

void G4BaierKatkov::SetSamplingPhotonsNumber ( G4int nPhotons )

inline

setting the number of photons in sampling of Baier-Katkov Integral (MC integration by photon energy and angles <=> photon momentum)

Definition at line 130 of file G4BaierKatkov.hh.

130{fNMCPhotons = nPhotons;}

◆ SetSinglePhotonRadiationProbabilityLimit()

void G4BaierKatkov::SetSinglePhotonRadiationProbabilityLimit ( G4double wmax )

inline

set functions

set maximal radiation probability to preserve single photon radiation

Definition at line 115 of file G4BaierKatkov.hh.

116 {fSinglePhotonRadiationProbabilityLimit = wmax;}

◆ SetSpectrumEnergyRange()

void G4BaierKatkov::SetSpectrumEnergyRange	(	G4double	emin,
		G4double	emax,
		G4int	numberOfBins )

CAUTION, the bins width is logarithmic Do not worry if the maximal energy > particle energy. This elements of spectrum with non-physical energies will not be processed (they will be 0).

Definition at line 110 of file G4BaierKatkov.cc.

{
    fMinPhotonEnergy = emin;
    fMaxPhotonEnergy = emax;
    fNBinsSpectrum = numberOfBins;
 
    fLogEmaxdEmin = G4Log(fMaxPhotonEnergy/fMinPhotonEnergy);
 
    //in initializing fNPhotonsPerBin
    fNPhotonsPerBin.resize(fNBinsSpectrum);
    std::fill(fNPhotonsPerBin.begin(), fNPhotonsPerBin.end(), 0);
 
    //initializing the Spectrum
    fSpectrum.resize(fNBinsSpectrum);
    std::fill(fSpectrum.begin(), fSpectrum.end(), 0);
 
    //initializing the fAccumTotalSpectrum
    fAccumTotalSpectrum.resize(fNBinsSpectrum);
    std::fill(fAccumTotalSpectrum.begin(), fAccumTotalSpectrum.end(), 0);
 
    //initializing the fTotalSpectrum
    fTotalSpectrum.resize(fNBinsSpectrum);
    std::fill(fTotalSpectrum.begin(), fTotalSpectrum.end(), 0);
 
    fPhotonEnergyInSpectrum.clear();
    for (G4int j=0;j<fNBinsSpectrum;j++)
    {
        //bin position (mean between 2 bin limits)
        fPhotonEnergyInSpectrum.push_back(fMinPhotonEnergy*
                                       (std::exp(fLogEmaxdEmin*j/fNBinsSpectrum)+
                                        std::exp(fLogEmaxdEmin*(j+1)/fNBinsSpectrum))/2.);
    }
 
    fItrajectories = 0;
 
    ResetRadIntegral();
}

Referenced by G4BaierKatkov(), SetMaxPhotonEnergy(), SetMinPhotonEnergy(), and SetNBinsSpectrum().

◆ SetVirtualCollimator()

void G4BaierKatkov::SetVirtualCollimator ( G4double virtualCollimatorAngularDiameter )

inline

Virtual collimator masks the selection of photon angles in fTotalSpectrum Virtual collimator doesn't influence on Geant4 simulations.

Definition at line 163 of file G4BaierKatkov.hh.

164 {fVirtualCollimatorAngularDiameter=virtualCollimatorAngularDiameter;}

The documentation for this class was generated from the following files:

Public Member Functions

Detailed Description

Constructor & Destructor Documentation

◆ G4BaierKatkov()

◆ ~G4BaierKatkov()

Member Function Documentation

◆ AddStatisticsInPhotonEnergyRegion()

◆ DoRadiation()

◆ GeneratePhoton()

◆ GetNewGlobalTime()

◆ GetParticleNewAngleX()

◆ GetParticleNewAngleY()

◆ GetParticleNewCoordinateXYZ()

◆ GetParticleNewTotalEnergy()

◆ GetPhotonEnergyInSpectrum()

◆ GetSinglePhotonRadiationProbabilityLimit()

◆ GetTotalRadiationProbability()

◆ GetTotalSpectrum()

◆ ResetRadIntegral()

◆ SetMaxPhotonEnergy()

◆ SetMinPhotonEnergy()

◆ SetNBinsSpectrum()

◆ SetNSmallTrajectorySteps()

◆ SetRadiationAngleFactor()

◆ SetSamplingPhotonsNumber()

◆ SetSinglePhotonRadiationProbabilityLimit()

◆ SetSpectrumEnergyRange()

◆ SetVirtualCollimator()