(change) second phase install

MontyCarlo (alpha, developmental releases)

MontyCarlo is a python framework for setting up simulations and/or developing applications whose basis is the simulation of particle transport. It simulates the propagation and effects of ionizing radiation (photons, electrons and positrons with energies between 1keV and 1GeV) in matter of homogeneous density, filling constructive solid geometry models.

This work has a poster presentation in the 3rd European Congress of Medical Physics and has been presented in a workshop organized by the Faculty of Sciences of the University of Porto and the Ludwig Maximilian University of Munich.

Getting started

Clone this repository and run

docker compose up -d

This will start a jupyter notebook server listening on http://localhost:8888.

Have fun exploring high energy particle tracks in a 3d environment!

White tracks: Photons
Blue tracks: electrons
Red tracks: positrons

The innermost sphere contains water, the outer sphere contains air and the rest of space is filled with gold.

Be sure to zoom in on every detail!

Other cool examples

What to expect

Speed

Although it is a python module this package is written in a happy mix of Python, Cython, C++. A notable example of a package that also does this is Numpy. Most of the initialization and pretty much all the programming user interface is in Python, so while setting up your simulation or handling the results of it, you'll be dealing with Python. However, from the moment you tell MontyCarlo to start simulating, it leaves the world of Python and starts running optimized C code. Each language is therefore placed strategically so that it can play to its strenghts.

Fun

Using the power of vtk through the wonderful work of mayavi remarkable visualizations are easy in Monty Carlo.

50keV electrons in water (secondary particles off):

10MeV electrons in water (primary in red, secondary photon in green)

Bugs

This is a very early version of a fairly large code. Bugs are guaranteed! Submitting an issue is a great way to contribute to the project at this stage!

Available Features:

Construction of any material via a stochiometric formula and density water = Mat({1:2, 8:1}, 1);
Constructed materials are automatically cached in the folder your_project\mat.
Only spheres are available. This will remain as such until all this has been thoroughly tested:
- Constructive Solid Geometry (CSG) using the | & and - operators;
- linear transformations on the volumes (translation and rotation);
- bounding volume hierarchy (BVH) constructed with the aid of the user;
- a syntatic indication of the BVH using with statements;
- a new method of particle transport that greatly accelerates the simulation of electrons and positrons;
The volumes surfaces are rendered and cached in your_project/geo;
Three particles are available:
- Photons (analogue simulation);
  - Compton Scattering;
  - Rayleigh Scattering;
  - Photoelectric Effect;
  - Pair Production;
  - Triplet Production;
- Electrons (class II condensed history);
  - Elastic Scattering (atom is not affected): Angular Deflection + Bremstrahlung Production;
  - Inelastic Scattering (atom is affected): Interaction with an individual atom + with the condensed medium as a whole;
- Positrons (class II condensed history);
  - Elastic Scattering (atom is not affected): Angular Deflection + Bremstrahlung Production;
  - Inelastic Scattering (atom is affected): Interaction with an individual atom + with the condensed medium as a whole;
  - Anihilation (positron meets electron);
The simulation is coupled (e.g. supports secondary particle creation)
Supports simulation of post-ionization relaxation effects;
Two particle sources are available:
- Isotropic point source: emits particles from a point with randomized directions - IsotropicPoint
- Directional point source: emits particles from a point towards a specified direction - Beam
Automated database download on first import;
3d plotting of particle trajectories;
3d plotting of the constructed geometry;
simultaneous plotting of both geometry and trajectories;
One tally is available:
- Z_TALLY - calculates PDD's
Automatic generation of *.html output files (work in progress though)

Possible Future Work

Sources
Tallying
- Energy Deposition (1d, 2d, 3d, 4d(spatial + temporal) )
- Flux
- Others
Variance reduction
Image Detectors
Extension to E < 1keV (for laser applications)
Extension to E > 1GeV (for thermonuclear applications)
Implementation of other particles
- Protons
- Neutrons
- etc...
Dedicated graphics engine (w/sphere tracing)
An auto-cad like GUI for CSG modeling
Geant4 like API
GPU accelaration
CPU multiprocessing/multithreading
Advanced data vizualization (w/ ParaView)
Distributed Cloud Computing
Dedicated python notebook (like Jupyter)

	if self.render:
	@plt_geo.sdf3
	def this():
	def SDF(double[:,:] P):
	cdef double3 p
	cdef int N = len(P)
	cdef cnp.ndarray sd = np.zeros(N)
	cdef int i
	for i in range(N):
	p.x = P[i, 0]
	p.y = P[i, 1]
	p.z = P[i, 2]
	sd[i] = self.SDF(p)
	return sd
	return SDF

	generator = this()
	import os
	generator.save(f"geo/{self.name}.stl")

	cdef double SDF(self, double3 _pos):
	cdef double3 pos = _pos
	self.tr.inv_pos(pos)
	return sqrt(pos.xpos.x + pos.ypos.y + pos.z*pos.z) - self.r

	cdef class Primitive(CSGvol):
	cdef Transform tr


	def __init__(self):
	super(Primitive, self).__init__()
	self.tr = Identity(self)

	def translate(self, dx, dy, dz):
	self.tr = self.tr.translate(dx, dy, dz)
	#self.mesh.translate([dx, dy, dz])

	def rotate(self, axis, angle):
	self.tr = self.tr.rotate(axis, angle)

	@property
	def matrix(self):
	return self.tr.matrix

	@property
	def inv_matrix(self):
	return self.tr.inv_matrix

	cdef void inv_pos(self, double3& rpos):
	cdef double3 pos = rpos
	rpos.x = self.iT[0]pos.x + self.iT[1]pos.y + self.iT[2] *pos.z + self.iT[3]
	rpos.y = self.iT[4]pos.x + self.iT[5]pos.y + self.iT[6] *pos.z + self.iT[7]
	rpos.z = self.iT[8]pos.x + self.iT[9]pos.y + self.iT[10]*pos.z + self.iT[11]

	def rebuildsampler(this):
	cdef sampler self
	self = <sampler> sampler.__new__(sampler)

	self.Zeff = this.Zeff
	self.k = this.k # molecule.k
	self.X = this.X # np.array(XX)
	self.Xmax = this.Xmax # np.array(Xmax)
	self.E = this.E # np.array(molecule.E)*1e6
	self.kcr = this.kcr # molecule.Wcr/(molecule.E*1e6)
	self.logE = this.logE # np.log(molecule.E*1e6)
	self.En = this.En

	return self

	cdef (double, double) full_sample(self, double E, mixmax_engine *genPTR):
	"""Sample electrons fractional energy loss (k) and the emitted photons polar angular with respect to the direction of the electrons movement (theta).
	"""

	cdef double k = self._sample(E,genPTR)
	#cdef double theta = sample_theta(E, self.Zeff, k)
	return (k , sample_theta(E, self.Zeff, k, genPTR))

	cdef double _sample(self, double E, mixmax_engine *genPTR):
	"""Sample the electrons fractional energy loss (k).
	"""

	self.i = search._sortedArrayDOUBLE(self.E, E, 0, self.En)

	if self.E[self.i] == E:
	return self.sample_ds(genPTR)

	cdef double logE1, logE2, logE
	assert self.E[self.i] <= E < self.E[self.i+1]

	logE1, logE2 = self.logE[self.i], self.logE[self.i+1]
	logE = log(E)


	#cdef double pi_1, pi_2
	#pi_1 =
	#pi_2 = (logE - logE1)/log_diff




	if genPTR.get_next_float() > ( logE2 - logE ) / (logE2 - logE1):
	self.i +=1

	return self.sample_ds(genPTR)

	cdef double sample_ds(self, mixmax_engine *genPTR):
	"""Sample the electrons fractional energy loss (k) from the chosen X-Section.
	"""
	cdef double w
	cdef double kcr = self.kcr[self.i]
	cdef LLI XX = self.X[self.i]
	cdef double Xmax = self.Xmax[self.i]
	while 1:
	w = kcr**genPTR.get_next_float()
	if genPTR.get_next_float()*Xmax < XX._eval(w):
	return w

	cdef double _sample(self):
	self.R = self.N * rand()
	self.i = <int> self.R

	if self.R - self.i < self.cut_offs[self.i]:

	self.dx = rand() * self.DX[self.i]

	self.y = self.c[3, self.i]

	self.y += self.c[2, self.i]*self.dx

	self.dx *= self.dx
	self.y += self.c[1, self.i]*self.dx

	self.dx *= self.dx
	self.y += self.c[0, self.i]*self.dx

	return self.y


	self.i = self.rej_indexes[self.i]


	self.y = self.c[3, self.i]
	self.dx = rand()*self.DX[self.i]

	self.y += self.c[2, self.i]*self.dx

	self.dx *= self.dx
	self.y += self.c[1, self.i]*self.dx

	self.dx *= self.dx
	self.y += self.c[0, self.i]*self.dx

	return self.y

ruifilipecampos / montycarlo Goto Github PK

montycarlo's Introduction

MontyCarlo (alpha, developmental releases)

Getting started

Other cool examples

What to expect

Speed

Fun

Bugs

Available Features:

Possible Future Work

montycarlo's People

Contributors

Stargazers

Watchers

Forkers

montycarlo's Issues

untar step too cumberson

in def exit

the signed distance function of the sphere

Performed Tests

Working on

Recommend Projects

Recommend Topics

Recommend Org