Lightcone outputs

configure.ac

@@ -52,7 +52,7 @@ AC_DEFINE([_GLIBCXX_INCLUDE_NEXT_C_HEADERS],1,[Hack for min() and max() using g+
 # Enable POSIX and platform extension preprocessor macros.
 AC_USE_SYSTEM_EXTENSIONS
 
-# Check for compiler version and vendor.
+# Check for C compiler version and vendor.
 AX_COMPILER_VENDOR
 AX_COMPILER_VERSION
 
@@ -1397,6 +1397,34 @@ if test "$enable_velociraptor_orphans" = "yes"; then
    AC_DEFINE([HAVE_VELOCIRAPTOR_ORPHANS], 1, [Orphan particles should be written out])
 fi
 
+# Check if lightcone output is on.
+AC_ARG_ENABLE([lightcone],
+   [AS_HELP_STRING([--enable-lightcone],
+     [Activate lightcone outputs.],
+   )],
+   [enable_lightcone="$enableval"],
+   [enable_lightcone="no"]
+)
+if test "$enable_lightcone" = "yes"; then
+   # Check for healpix for lightcone maps. May require cfitsio
+   # This sets CHEALPIX_LIBS and CHEALPIX_CFLAGS and #defines HAVE_CHEALPIX.
+   # It also adds a --with-cfitsio flag in case cfitsio is installed in a
+   # different location from healpix.
+   GV_FIND_LIBRARY([cfitsio], [CFITSIO], [cfitsio], [cfitsio], [ffclos])
+   TMP_LIBS=${LIBS}
+   LIBS="${CFITSIO_LIBS} ${LIBS}"
+   GV_FIND_LIBRARY([chealpix], [CHEALPIX], [chealpix], [chealpix], [ang2vec])
+   LIBS=${TMP_LIBS}
+   have_chealpix=${USE_CHEALPIX}
+   CHEALPIX_LIBS="${CHEALPIX_LIBS} ${CFITSIO_LIBS}"
+   AC_DEFINE([WITH_LIGHTCONE], 1, [Enable lightcone outputs])
+   if test "$have_chealpix" != "yes"; then
+      AC_MSG_ERROR([Lightcone output requires the HEALPix C API. Please configure with --with-chealpix.])
+   fi
+else
+   have_chealpix="no"
+fi
+
 # Check for floating-point execeptions
 AC_CHECK_FUNC(feenableexcept, AC_DEFINE([HAVE_FE_ENABLE_EXCEPT],[1],
     [Defined if the floating-point exception can be enabled using non-standard GNU functions.]))
@@ -1614,6 +1642,7 @@ with_subgrid_stars=none
 with_subgrid_star_formation=none
 with_subgrid_feedback=none
 with_subgrid_sink=none
+with_subgrid_extra_io=none
 
 case "$with_subgrid" in
    yes)
@@ -1630,6 +1659,7 @@ case "$with_subgrid" in
 	with_subgrid_feedback=GEAR
 	with_subgrid_black_holes=none
 	with_subgrid_sink=none
+	with_subgrid_extra_io=none
 	enable_fof=no
    ;;
    QLA)
@@ -1642,6 +1672,7 @@ case "$with_subgrid" in
 	with_subgrid_feedback=none
 	with_subgrid_black_holes=none
 	with_subgrid_sink=none
+	with_subgrid_extra_io=none
 	enable_fof=no
    ;;
    QLA-EAGLE)
@@ -1666,6 +1697,7 @@ case "$with_subgrid" in
 	with_subgrid_feedback=EAGLE
 	with_subgrid_black_holes=EAGLE
 	with_subgrid_sink=none
+	with_subgrid_extra_io=none
 	enable_fof=yes
    ;;
    EAGLE-XL)
@@ -1678,6 +1710,7 @@ case "$with_subgrid" in
 	with_subgrid_feedback=EAGLE
 	with_subgrid_black_holes=EAGLE
 	with_subgrid_sink=none
+	with_subgrid_extra_io=EAGLE
 	enable_fof=yes
    ;;
    *)
@@ -2169,6 +2202,35 @@ case "$with_tracers" in
    ;;
 esac
 
+#  Extra fields added to snapshots at i/o time
+AC_ARG_WITH([extra_io],
+   [AS_HELP_STRING([--with-extra-io=<function>],
+      [chemistry function @<:@none, EAGLE default: none@:>@]
+   )],
+   [with_extra_io="$withval"],
+   [with_extra_io="none"]
+)
+
+if test "$with_subgrid" != "none"; then
+   if test "$with_extra_io" != "none"; then
+      AC_MSG_ERROR([Cannot provide with-subgrid and with-extra_io together])
+   else
+      with_extra_io="$with_subgrid_extra_io"
+   fi
+fi
+
+case "$with_extra_io" in
+   none)
+      AC_DEFINE([EXTRA_IO_NONE], [1], [No extra_io function])
+   ;;
+   EAGLE)
+      AC_DEFINE([EXTRA_IO_EAGLE], [1], [Extra i/o fields taken from the EAGLE model])
+   ;;
+   *)
+      AC_MSG_ERROR([Unknown extra-io choice: $with_extra_io])
+   ;;
+esac
+
 # Stellar model.
 AC_ARG_WITH([stars],
    [AS_HELP_STRING([--with-stars=<model>],
@@ -2592,6 +2654,9 @@ DX_DOXYGEN_FEATURE(OFF)
 DX_INIT_DOXYGEN(SWIFT, doc/Doxyfile, doc/)
 AM_CONDITIONAL([HAVE_DOXYGEN], [test "$ac_cv_path_ac_pt_DX_DOXYGEN" != ""])
 
+# Check if using EAGLE extra I/O
+AM_CONDITIONAL([HAVEEAGLEEXTRAIO], [test "${with_extra_io}" = "EAGLE"])
+
 # Check if using QLA cooling
 AM_CONDITIONAL([HAVEQLACOOLING], [test "$with_cooling" = "QLA"])
 AM_CONDITIONAL([HAVEQLAEAGLECOOLING], [test "$with_cooling" = "QLA-EAGLE"])
@@ -2693,6 +2758,7 @@ AC_MSG_RESULT([
     - MPI               : $have_mpi_fftw
     - ARM               : $have_arm_fftw
    GSL enabled          : $have_gsl
+   HEALPix C enabled    : $have_chealpix
    libNUMA enabled      : $have_numa
    GRACKLE enabled      : $have_grackle
    Special allocators   : $have_special_allocator
@@ -2700,6 +2766,7 @@ AC_MSG_RESULT([
    Pthread barriers     : $have_pthread_barrier
    VELOCIraptor enabled : $have_velociraptor
    FoF activated:       : $enable_fof
+   Lightcones enabled   : $enable_lightcone
 
    Hydro scheme       : $with_hydro
    Dimensionality     : $with_dimension
@@ -2725,8 +2792,9 @@ AC_MSG_RESULT([
    Star feedback model  : $with_feedback_name
    Sink particle model  : $with_sink
    Black holes model    : $with_black_holes
-   Radiative transfer   : $with_rt
-
+   Radiative transfer   : $with_rt$rt_extra_msg
+   Extra i/o            : $with_extra_io
+   
    Atomic operations in tasks  : $enable_atomics_within_tasks
    Individual timers           : $enable_timers
    Task debugging              : $enable_task_debugging

doc/RTD/source/GettingStarted/compiling_code.rst

@@ -93,6 +93,16 @@ GRACKLE
 ~~~~~~~
 GRACKLE cooling is implemented in SWIFT. If you wish to take advantage of it, you will need it installed.
 
+HEALPix C library
+~~~~~~~~~~~~~~~~~~~
+
+This is required for making light cone HEALPix maps. Note that by default HEALPix builds a static library which cannot be used to build the SWIFT shared library. Either HEALPix must be built as a shared library or -fPIC must be added to the C compiler flags when HEALPix is being configured.
+
+CFITSIO
+~~~~~~~
+
+This may be required as a dependency of HEALPix.
+
 
 Initial Setup
 -------------

doc/RTD/source/LightCones/adding_outputs.rst

+.. Light Cones
+   John Helly 29th April 2021
+
+.. _lightcone_adding_outputs_label:
+
+Adding New Types of Output
+~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+New particle properties can be added to the particle light cones as follows:
+
+* Add a field to the ``lightcone_<type>_data`` struct in ``lightcone_particle_io.h`` to store the new quantity
+* Modify the ``lightcone_store_<type>`` function in ``lightcone_particle_io.c`` to set the new struct field from the particle data
+* in ``lightcone_io_make_output_fields()``, add a call to ``lightcone_io_make_output_field()`` to define the new output
+
+Here, <type> is the particle type: gas, dark_matter, stars, black_hole or neutrino.
+
+To add a new type of HEALPIX map:
+
+* Add a function to compute the quantity in ``lightcone_map_types.c``. See ``lightcone_map_total_mass()`` for an example.
+* Add a new entry to the ``lightcone_map_types`` array in lightcone_map_types.h. This should specify the name of the new map type, a pointer to the function to compute the quantity, and the units of the quantity. The last entry in the array is not used and must have a NULL function pointer to act as an end marker.

doc/RTD/source/LightCones/algorithm_description.rst

+.. Light Cones
+   John Helly 29th April 2021
+
+.. _lightcone_algorithm_description_label:
+
+Light Cone Output Algorithm
+~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+In cosmological simulations it is possible to specify the location of
+an observer in the simulation box and have SWIFT output information
+about particles in the simulation as they cross the observer's past
+light cone.
+
+Whenever a particle is drifted the code checks if any periodic copy of
+the particle crosses the lightcone during the drift, and if so that
+copy of the particle is buffered for output. As an optimization, at the
+start of each time step the code computes which periodic copies of the
+simulation box could contribute to the light cone and only those copies
+are searched. When drifting the particles in a particular cell the list of
+replications is further narrowed down using the spatial extent of the
+cell.
+
+Particles can be output directly to HDF5 files or accumulated to healpix
+maps corresponding to spherical shells centred on the observer.
+
+
+

doc/RTD/source/LightCones/index.rst

+.. Light Cones
+   John Helly 29th April 2021
+
+.. _Light_Cones_label:
+
+Light Cone Outputs
+==================
+
+This section describes the light cone outputs
+and related parameters
+
+.. toctree::
+   :maxdepth: 2
+   :caption: Contents:
+
+   algorithm_description
+   lightcone_particle_output
+   lightcone_healpix_maps
+   running_with_lightcones
+   adding_outputs

doc/RTD/source/LightCones/lightcone_healpix_maps.rst

+.. Light Cones
+   John Helly 29th April 2021
+
+.. _lightcone_healpix_maps_label:
+
+Light Cone HEALPix Maps
+~~~~~~~~~~~~~~~~~~~~~~~
+
+SWIFT can accumulate particle properties to HEALPix maps as they
+cross the observer's past light cone. Each map corresponds to a
+spherical shell centred on the observer. When a particle crosses
+the lightcone its distance from the observer is calculated and the
+particle's contribution is added to a buffer so that at the end of
+the time step it can be added to the corresponding HEALPix map.
+
+Maps can be generated for multiple concentric shells and multiple
+quantities can be accumulated for each shell. The HEALPix map for a
+shell is allocated and zeroed out when the simulation first reaches
+a redshift where particles could contribute to that map. The map is
+written out and deallocated when the simulation advances to a point
+where there can be no further contributions. In MPI runs the pixel
+data for the maps are distributed across all MPI ranks.
+
+Updates to the maps are buffered in order to avoid the need for
+communication during the time step. At the end of the step if any
+MPI rank has a large amount of updates buffered then all pending
+updates will be applied to the pixel data.
+
+For gas particles, the HEALPix maps are smoothed using a projected
+version of the same kernel used for the hydro calculations. Other
+particle types are not smoothed.
+
+The code writes one output file for each spherical shell. In MPI mode
+all ranks write to the same file using parallel HDF5. If maps of
+multiple quantities are being made they will be written to a single
+file as separate 1D datasets with one element per pixel.

doc/RTD/source/LightCones/lightcone_particle_output.rst

+.. Light Cones
+   John Helly 29th June 2021
+
+.. _lightcone_particle_output_label:
+
+Light Cone Particle Output
+~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+SWIFT can output particles to HDF5 output files (similar to the
+snapshots) as they cross the observer's light cone. During each time
+step, any particles which cross the light cone are added to a buffer.
+If this buffer is large at the end of the step then its contents
+are written to an output file. In MPI runs each MPI rank writes its
+own output file and decides independently when to flush its particle
+buffer.
+
+A new output file is started whenever restart files are written. This
+allows the code to automatically continue from the point of the restart
+dump if the run is interrupted. Any files written after the restart
+dump will be overwritten when the simulation is resumed, preventing
+duplication of particles in the light cone output.
+
+The output files have names of the form ``basename_XXXX.Y.hdf5``, where
+XXXX numbers the files written by a single MPI rank and Y is the index
+of the MPI rank.
+
+The output files contain one HDF5 group for each particle type. Within
+each group there are datasets corresponding to particle properties in
+a similar format to the snapshots.
+

doc/RTD/source/LightCones/running_with_lightcones.rst

+.. Light Cones
+   John Helly 29th April 2021
+
+.. _lightcone_running_label:
+
+Running SWIFT with Light Cone Output
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+To produce light cone particle output swift must be configured
+with ``--enable-lightcone``. Additionally, making HEALPix maps
+requires the HEALPix C library. If using MPI then parallel HDF5
+is also required.
+
+One lightcone is produced for each ``LightconeX`` section in the
+parameter file, where X=0-7. This allows generation of up to 8 
+light cones. See :ref:`Parameters_light_cone` for details.
+
+SWIFT must be run with the ``--lightcone`` flag to activate light
+cone outputs, otherwise the Lightcone sections in the parameter file
+are ignored.

doc/RTD/source/ParameterFiles/parameter_description.rst

@@ -975,6 +975,182 @@ be processed by the ``SpecWizard`` tool
      range_when_shooting_down_y: 100. # Range along the y-axis of LoS along y
      range_when_shooting_down_z: 100. # Range along the z-axis of LoS along z
 
+
+.. _Parameters_light_cone:
+
+Light Cone Outputs
+---------------------
+
+One or more light cone outputs can be configured by including ``LightconeX`` sections
+in the parameter file, where X is in the range 0-7. It is also possible to include a
+``LightconeCommon`` section for parameters which are the same for all lightcones. The
+parameters for each light cone are:
+
+* Switch to enable or disable a lightcone: ``enabled``
+
+This should be set to 1 to enable the corresponding lightcone or 0 to disable it.
+Has no effect if specified in the LightconeCommon section.
+
+* Directory in which to write light cone output: ``subdir``
+
+All light cone output files will be written in the specified directory.
+
+* Base name for particle and HEALPix map outputs: ``basename``.
+
+Particles will be written to files ``<basename>_XXXX.Y.hdf5``, where XXXX numbers the files
+written by a single MPI rank and Y is the MPI rank index. HEALPix maps are written to files
+with names ``<basename>.shell_X.hdf5``, where X is the index of the shell. The basename must
+be unique for each light cone so it cannot be specified in the LightconeCommon section.
+
+See :ref:`lightcone_adding_outputs_label` for information on adding new output quantities.
+
+* Location of the observer in the simulation box, in internal units: ``observer_position``
+
+* Size of in memory chunks used to store particles and map updates: ``buffer_chunk_size``
+
+During each time step buffered particles and HEALPix map updates are stored in a linked
+list of chunks of ``buffer_chunk_size`` elements. Additional chunks are allocated as needed.
+The map update process is parallelized over chunks so the chunks should be small enough that
+each MPI rank typically has more chunks than threads.
+
+* Maximum amount of map updates (in MB) to send on each iteration: ``max_map_update_send_size_mb``
+
+Flushing the map update buffer involves sending the updates to the MPI ranks with the affected
+pixel data. Sending all updates at once can consume a large amount of memory so this parameter
+allows updates to be applied over multiple iterations to reduce peak memory usage.
+
+* Redshift range to output each particle type: ``z_range_for_<type>``
+
+A two element array with the minimum and maximum redshift at which particles of type ``<type>``
+will be output as they cross the lightcone. ``<type>`` can be Gas, DM, DMBackground, Stars, BH
+or Neutrino. If this parameter is not present for a particular type then that type will not
+be output.
+
+* The number of buffered particles which triggers a write to disk: ``max_particles_buffered``
+
+If an MPI rank has at least max_particles_buffered particles which have crossed the lightcone,
+it will write them to disk at the end of the current time step.
+
+* Size of chunks in the particle output file
+
+This sets the HDF5 chunk size. Particle outputs must be chunked because the number of particles
+which will be written out is not known when the file is created.
+
+* Whether to use lossy compression in the particle outputs: ``particles_lossy_compression``
+
+If this is 1 then the HDF5 lossy compression filter named in the definition of each particle
+output field will be enabled. If this is 0 lossy compression is not applied.
+
+* Whether to use lossless compression in the particle outputs: ``particles_gzip_level``
+
+If this is non-zero the HDF5 deflate filter will be applied to lightcone particle output with
+the compression level set to the specified value. 
+
+* HEALPix map resolution: ``nside``
+
+* Name of the file with shell radii: ``radius_file.txt``
+
+This specifies the name of a file with the inner and outer radii of the shells used to make
+HEALPix maps. It should be a text file with a one line header and then two comma separated columns
+of numbers with the inner and outer radii. The units are determined by the header. The header must
+be one of the following:
+
+``# Minimum comoving distance, Maximum comoving distance``,
+``# Minimum redshift, Maximum redshift``, or
+``# Maximum expansion factor, Minimum expansion factor``. Comoving distances are in internal units.
+The shells must be in ascending order of radius and must not overlap.
+
+* Number of pending HEALPix map updates before the buffers are flushed: ``max_updates_buffered``
+
+In MPI mode applying updates to the HEALPix maps requires communication and forces synchronisation
+of all MPI ranks, so it is not done every time step. If any MPI rank has at least
+``max_updates_buffered`` pending updates at the end of a time step, then all ranks will apply
+their updates to the HEALPix maps.
+
+* Which types of HEALPix maps to create: ``map_names_file``
+
+This is the name of a file which specifies what quantities should be accumulated to HEALPix maps.
+The possible map types are defined in the lightcone_map_types array in ``lightcone_map_types.h``.
+See :ref:`lightcone_adding_outputs_label` if you'd like to add a new map type.
+
+* Whether to distribute HEALPix maps over multiple files: ``distributed_maps``
+
+If this is 0 then the code uses HDF5 collective writes to write each map to a single file. If this
+is 1 then each MPI rank writes its part of the HEALPix map to a separate file.
+
+The file contains two columns: the first column is the name of the map type and the second is the
+name of the compression filter to apply to it. See io_compression.c for the list of compression
+filter names. Set the filter name to ``on`` to disable compression.
+
+* Whether to use lossless compression in the HEALPix map outputs: ``maps_gzip_level``
+
+If this is non-zero the HDF5 deflate filter will be applied to the lightcone map output with
+the compression level set to the specified value. 
+
+The following shows a full set of light cone parameters for the case where we're making two
+light cones which only differ in the location of the observer:
+
+.. code:: YAML
+
+  LightconeCommon:
+
+    # Common parameters
+    subdir:            lightcones
+    buffer_chunk_size:      100000
+    max_particles_buffered: 1000000
+    hdf5_chunk_size:        10000
+ 
+    # Redshift ranges for particle types
+    z_range_for_Gas:           [0.0, 0.05]
+    z_range_for_DM:            [0.0, 0.05]
+    z_range_for_DMBackground:  [0.0, 0.05]
+    z_range_for_Stars:         [0.0, 0.05]
+    z_range_for_BH:            [0.0, 0.05]
+    z_range_for_Neutrino:      [0.0, 0.05]
+    
+    # Healpix map parameters
+    nside:                512
+    radius_file:          ./shell_radii.txt
+    max_updates_buffered: 100000
+    map_names_file:       map_names.txt
+    max_map_update_send_size_mb: 1.0
+    distributed_maps:     0
+
+    # Compression options
+    particles_lossy_compression: 0
+    particles_gzip_level:        6
+    maps_gzip_level:             6
+
+  Lightcone0:
+
+    enabled:  1
+    basename: lightcone0
+    observer_position: [35.5, 78.12, 12.45]
+
+  Lightcone0:
+
+    enabled:  1
+    basename: lightcone1
+    observer_position: [74.2, 10.80, 53.59]
+  
+
+An example of the radius file::
+
+  # Minimum comoving distance, Maximum comoving distance
+  0.0,   50.0
+  50.0,  100.0
+  150.0, 200.0
+  200.0, 400.0
+  400.0, 1000.0
+
+An example of the map names file::
+
+  TotalMass         on
+  SmoothedGasMass   on
+  UnsmoothedGasMass on
+  DarkMatterMass    on
+
+
 .. _Parameters_eos:
 
 Equation of State (EoS)

doc/RTD/source/index.rst

@@ -27,6 +27,7 @@ difference is the parameter file that will need to be adapted for SWIFT.
    FriendsOfFriends/index
    VELOCIraptorInterface/index
    LineOfSights/index
+   LightCones/index
    EquationOfState/index
    ExternalPotentials/index
    Neutrinos/index

examples/Cooling/CoolingRates/Makefile.am

@@ -15,12 +15,12 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 # Add the source directory and the non-standard paths to the included library headers to CFLAGS
-AM_CFLAGS = -I$(top_srcdir)/src -I$(top_builddir)/examples $(HDF5_CPPFLAGS) $(GSL_INCS) $(FFTW_INCS) $(NUMA_INCS) $(OPENMP_CFLAGS)
+AM_CFLAGS = -I$(top_srcdir)/src -I$(top_builddir)/examples $(HDF5_CPPFLAGS) $(GSL_INCS) $(FFTW_INCS) $(NUMA_INCS) $(OPENMP_CFLAGS) $(CHEALPIX_CFLAGS)
 
 AM_LDFLAGS = $(HDF5_LDFLAGS) $(HDF5_LIBS) $(FFTW_LIBS) $(NUMA_LIBS) $(TCMALLOC_LIBS) $(JEMALLOC_LIBS) $(TBBMALLOC_LIBS) $(GRACKLE_LIBS) $(GSL_LIBS) $(PROFILER_LIBS)
 
 # Extra libraries.
-EXTRA_LIBS = $(HDF5_LIBS) $(FFTW_LIBS) $(NUMA_LIBS) $(PROFILER_LIBS) $(TCMALLOC_LIBS) $(JEMALLOC_LIBS) $(TBBMALLOC_LIBS) $(GRACKLE_LIBS) $(VELOCIRAPTOR_LIBS) $(GSL_LIBS)
+EXTRA_LIBS = $(HDF5_LIBS) $(FFTW_LIBS) $(NUMA_LIBS) $(PROFILER_LIBS) $(TCMALLOC_LIBS) $(JEMALLOC_LIBS) $(TBBMALLOC_LIBS) $(GRACKLE_LIBS) $(VELOCIRAPTOR_LIBS) $(GSL_LIBS) $(CHEALPIX_LIBS)
 
 # Programs.
 bin_PROGRAMS = cooling_rates

examples/Makefile.am

@@ -20,13 +20,15 @@ MYFLAGS =
 
 # Add the source directory and the non-standard paths to the included library headers to CFLAGS
 AM_CFLAGS = -I$(top_srcdir)/src -I$(top_srcdir)/argparse $(HDF5_CPPFLAGS) \
-	$(GSL_INCS) $(FFTW_INCS) $(NUMA_INCS) $(GRACKLE_INCS) $(OPENMP_CFLAGS)
+	$(GSL_INCS) $(FFTW_INCS) $(NUMA_INCS) $(GRACKLE_INCS) $(OPENMP_CFLAGS) \
+	$(CHEALPIX_CFLAGS)
 
 AM_LDFLAGS = $(HDF5_LDFLAGS)
 
 # Extra libraries.
 EXTRA_LIBS = $(GSL_LIBS) $(HDF5_LIBS) $(FFTW_LIBS) $(NUMA_LIBS) $(PROFILER_LIBS) \
-	$(TCMALLOC_LIBS) $(JEMALLOC_LIBS) $(TBBMALLOC_LIBS) $(GRACKLE_LIBS)
+	$(TCMALLOC_LIBS) $(JEMALLOC_LIBS) $(TBBMALLOC_LIBS) $(GRACKLE_LIBS) \
+	$(CHEALPIX_LIBS)
 
 # MPI libraries.
 MPI_LIBS = $(PARMETIS_LIBS) $(METIS_LIBS) $(MPI_THREAD_LIBS) $(FFTW_MPI_LIBS)

examples/SmallCosmoVolume/SmallCosmoVolume_cooling/small_cosmo_volume.yml

@@ -41,6 +41,7 @@ SPH:
 
 # Parameters governing the snapshots
 Snapshots:
+  subdir:              snapshots
   basename:            snap
   delta_time:          1.02
   scale_factor_first:  0.02

examples/SmallCosmoVolume/SmallCosmoVolume_lightcone/README

+Small LCDM cosmological simulation generated by C. Power. Cosmology
+is WMAP9 and the box is 100Mpc/h in size with 64^3 particles.
+We use a softening length of 1/25th of the mean inter-particle separation.
+
+The ICs have been generated to run with Gadget-2 so we need to switch
+on the options to cancel the h-factors and a-factors at reading time.
+We generate gas from the ICs using SWIFT's internal mechanism and set the
+temperature to the expected gas temperature at this redshift.
+
+This example is intended to be run with the EAGLE-XL model in order to
+produce lightcone outputs including gas, stars and black holes. Note 
+that the resulting output will not be at all realistic due to the extremely
+poor mass resolution and the minimum overdensity for star formation has
+to be be reduced to allow any star formation.
+
+To configure the code appropriately, the following flags should be included:
+
+./configure \
+    --with-hydro=sphenix \
+    --with-subgrid=EAGLE-XL \
+    --with-kernel=wendland-C2 \
+    --with-chealpix \
+    --enable-lightcone
+
+MD5 checksum of the ICs:
+08736c3101fd738e22f5159f78e6022b  small_cosmo_volume.hdf5

examples/SmallCosmoVolume/SmallCosmoVolume_lightcone/getColibreCoolingTables.sh

+#!/bin/bash
+wget http://virgodb.cosma.dur.ac.uk/swift-webstorage/CoolingTables/COLIBRE/UV_dust1_CR1_G1_shield1.hdf5
+

examples/SmallCosmoVolume/SmallCosmoVolume_lightcone/getCoolingTables.sh

+#!/bin/bash
+wget http://virgodb.cosma.dur.ac.uk/swift-webstorage/CoolingTables/EAGLE/coolingtables.tar.gz
+tar -xvzf coolingtables.tar.gz

examples/SmallCosmoVolume/SmallCosmoVolume_lightcone/getEaglePhotometryTable.sh

+#!/bin/bash
+wget http://virgodb.cosma.dur.ac.uk/swift-webstorage/YieldTables/EAGLE/photometry.tar.gz
+tar -xf photometry.tar.gz

examples/SmallCosmoVolume/SmallCosmoVolume_lightcone/getEagleYieldTable.sh

+#!/bin/bash
+wget http://virgodb.cosma.dur.ac.uk/swift-webstorage/YieldTables/EAGLE/yieldtables.tar.gz
+tar -xf yieldtables.tar.gz

examples/SmallCosmoVolume/SmallCosmoVolume_lightcone/getIC.sh

+#!/bin/bash
+wget http://virgodb.cosma.dur.ac.uk/swift-webstorage/ICs/small_cosmo_volume.hdf5
+

examples/SmallCosmoVolume/SmallCosmoVolume_lightcone/getXrayTables.sh

+#!/bin/bash
+wget http://virgodb.cosma.dur.ac.uk/swift-webstorage/CoolingTables/COLIBRE/X_Ray_tables.13072021.hdf5