This is the current working version of kosmatau3d. It uses a series of sub-modules to perform most of the calculations. The reason for doing this is to reduce the memory footprint of the code to increase the overall efficiency. This also increases the maximum number of voxels that can be evaluated, since each voxel no longer owns as much memory.

Directly install from git using,

pip install git+https://github.com/CraigYanitski/kosmatau3d.git

Download the repository.

git clone https://github.com/CraigYanitski/kosmatau3d
cd kosmatau3d

Now that you are in the root directory of this repository, install it as an editable package in bash with,

pip install -e .

You can now keep it up-to-date using git pull in this directory.

A Voxel instance can be initialised using,

>>> from kosmatau3d import models
>>> vox = models.Voxel()

There are many parameters that must be specified in order to initialise and simulate the clumpy ensemble. For a detailed explanation of the properties that can be defined/accessed with a voxel instance, see the jupyter notebook in ./notebooks/voxel.ipynb. If you wish to use the pre-defined properties, you can simply run,

>>> vox.set_properties()
>>> vox.calculate_emission()

One can then easily plot different views of the voxel emission using built-in plotting methods.

>>> vox.plot_spectrum()

This is the basic component of kosmatau3d. It is made available as a self-sufficient object for use in other subgridding models. Given a volume-filling factor, mass, and FUV field, the single voxel object calculates the wavelength-dependant intensity, optical depth, absorption, and emissivity (assuming no background intensity) for a clumpy PDR ensemble. The explanation of this model is thoroughly-explained in ./notebooks/voxel.ipynb.

The objects that will modelled with this method are:

• IC 1396
  • (Okada, Yanitski, et al. in prep) first application of directly comparing single voxels with an observational map

The full subgrid model to simulate entire 3-dimensional structures. Voxel data can be streamed into fits files and the radiative transfer portion is a self-contained module to save on computational time.

It is currently setup for the Milky Way model initially developed by Christoph Bruckmann as that will be its first application. This galactic model can also be used in a more generalised application for distant galaxies.

The objects that will modelled with this method are:

• Milky Way
  • (Yanitski et al. in prep) an approximate description of the Milky Way emission compared to COBE-DIRBE, Planck, COBE-FIRAS, GOT C+, CfA, Mopra, ThrUMMS, and SEDIGISM data

The major changes to the functionality of the kosmatau3d model over the KOSMA-tau-3D model of Silke et al. (2017) are described in the document ./docs/treatise.pdf, and the major changes to the Milky Way model will also appear in the upcoming Yanitski et al. (2024) paper. Most of the functionality is explained in Ch. III and IV in Yanitski (2023). There will be other documents to state the other various corrections and developments made.

• 3D model
  • Correct voxel-averaged intensity calculation
  • Ensure 3D model saves relevant data
    • implement multiprocessing
  • Modify single-voxel instance to calculate a column when $f_V > 1$
    • allow for arbitrary $f_V$ $(<1)$
• Radiative transfer
  • Ensure correct calculation of sythetic datacube
    • implement multiprocessing
    • optimise
  • Implement opacity map in radiative transfer calculation
  • Implement FUV absorption calculation in full 3D model
  • Modify the radiativeTransfer module to work for arbitrary geometry
• Miscellaneous
  • Include submodule to explore KOSMA-$\tau$ and kosmatau3d properties
  • Include submodule to compare observational data with synthetic datacubes
    • fix regridding of observational error maps
  • Implement function to mimic two-layer model (aka two-voxel model)
  • Implement function to create voxel grid (functions by Yoko Okada)
    • have function fit observational data
  • Include submodule covering the Mathematica routines developed by Markus Röllig
  • Develop the code testing suite
  • Fully document the code using sphinx
  • Implement CI/CD

• Allow pickling of interpolation functions for faster debugging of the single-voxel model
• Utilise cython to improve code efficiency
• Implement numba more fully to optimise the computation time
  • use this to parallelise the code
• Create a GUI to make it easier to setup/alter the model
• Implement recursion in radiative transfer calculation