AT.run.GSM.method: AT.run.GSM.method

Description Usage Arguments Value See Also Examples

View source: R/libamtrack.R

Description

Computes HCP response and relative efficiency/RBE using summation of tracks an a Cartesian grid (the GSM algorithm). Be aware that this routine can take considerable time to compute depending on the arguments, esp. for higher energy (>10 MeV/u) particles. It is therefore advantageous to test your settings with a low number of runs first.

Usage

1
2
3
4
AT.run.GSM.method(E.MeV.u, particle.no, fluence.cm2.or.dose.Gy,
 material.no, stopping.power.source.no, 
	rdd.model, rdd.parameters, er.model, gamma.model, gamma.parameters, 
	N.runs, write.output, nX, voxel.size.m, lethal.events.mode)

Arguments

E.MeV.u

particle energy for each component in the mixed particle field [MeV/u] (array of size number.of.field.components) (see also E.MeV.u).

particle.no

particle type for each component in the mixed particle field (array of size number.of.field.components) (see also particle.no).

fluence.cm2.or.dose.Gy

if positive, particle fluence for each component in the mixed particle field [1/cm2]; if negative, particle dose for each component in the mixed particle field [Gy] (array of size number.of.field.components) (see also fluence.cm2.or.dose.Gy).

material.no

index number for detector material (see also material.no).

stopping.power.source.no

TODO (see also stopping.power.source.no).

rdd.model

index number for chosen radial dose distribution (see also rdd.model).

rdd.parameters

parameters for chosen radial dose distribution (array of size 4).

er.model

index number for chosen electron-range model (see also er.model).

gamma.model

index number for chosen gamma response.

gamma.parameters

parameters for chosen gamma response (array of size 9).

N.runs

number of runs within which track positions will be resampled.

write.output

if true, a protocol is written to SuccessiveConvolutions.txt in the working directory.

nX

number of voxels of the grid in x (and y as the grid is quadratic).

voxel.size.m

side length of a voxel in m.

lethal.events.mode

if true, allows to do calculations for cell survival.

Value

relative.efficiency

particle response at dose D / gamma response at dose D

d.check

sanity check: total dose (in Gy) as returned by the algorithm

S.HCP

absolute particle response

S.gamma

absolute gamma response

n.particles

average number of particle tracks on the detector grid

sd.relative.efficiency

standard deviation for relative.efficiency

sd.d.check

standard deviation for d.check

sd.S.HCP

standard deviation for S.HCP

sd.S.gamma

standard deviation for S.gamma

sd.n.particles

standard deviation for n.particles

See Also

View the C source code here: http://sourceforge.net/apps/trac/libamtrack/browser/trunk/src/AT_Algorithms_GSM.c#L277

Examples

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
# Compute the relative efficiency of an Alanine detector
#  in a proton field
AT.run.GSM.method( # protons
                   particle.no                          = 1001,
                   # with 10 MeV/u
                   E.MeV.u                              = 10, 
                   # delivering 1 Gy
                   fluence.cm2.or.dose.Gy               = c(-1.0),
                   # i.e. Alanine
                   material.no                          = 5,
                   
# simple 'Geiss' parametrization of radial dose distribution                   
                   rdd.model                            = 3,
                   # with 50 nm core radius
                   rdd.parameter                        = 50e-9,
                   # M. Scholz' parametrization of track radius
                   er.model                             = 4,
                   # Use exponential saturation
                   gamma.model                          = 4,
                   # max. response normalized to 1, saturation dose 500 Gy
                   gamma.parameters                     = c(1,500),
                   # resample 1000 times
                   N.runs                               = 1000,
                   # write a log file
                   write.output                         = TRUE,
                   # use a 10x10 grid
                   nX                                   = 10,
                   # with 5 nm voxel size
                   voxel.size.m                         = 5e-9,
                   # use independent subtargets
                   lethal.events.mode                   = FALSE,
                   # and PSTAR stopping powers
                   stopping.power.source.no             = 2)                  
    

libamtrack documentation built on May 31, 2017, 2:37 a.m.