#include <mpi.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <stdarg.h>
#include <omp.h>
#include <bigfile-mpi.h>
#include "sfr_eff.h"
#include "cooling.h"
#include "timestep.h"
#include "petaio.h"
#include "slotsmanager.h"
#include "hydra.h"
#include "density.h"
#include "partmanager.h"
#include "config.h"
#include "neutrinos_lra.h"
#include "utils.h"

Include dependency graph for petaio.c:

Classes
struct	petaio_params

Macros
#define	SIMPLE_PROPERTY(name, field, type, items)

#define	SIMPLE_PROPERTY_TYPE(name, ptype, field, type, items)

#define	SIMPLE_GETTER_PI(name, field, dtype, items, slottype)

#define	SIMPLE_SETTER_PI(name, field, dtype, items, slottype)

#define	SIMPLE_PROPERTY_PI(name, field, type, items, slottype)

#define	SIMPLE_PROPERTY_TYPE_PI(name, ptype, field, type, items, slottype)

Functions
void	set_petaio_params (ParameterSet *ps)

int	GetUsePeculiarVelocity (void)

static void	petaio_write_header (BigFile bf, const double atime, const int64_t NTotal, const Cosmology CP, const struct header_data data)

static void	petaio_read_header_internal (BigFile bf, Cosmology CP, struct header_data *data)

void	petaio_init (void)

void	petaio_build_selection (int selection, int ptype_offset, int ptype_count, const struct particle_data Parts, const int NumPart, int(select_func)(int i, const struct particle_data Parts))

void	petaio_save_snapshot (const char fname, struct IOTable IOTable, int verbose, const double atime, const Cosmology *CP)

char *	petaio_get_snapshot_fname (int num, const char *OutputDir)

struct header_data	petaio_read_header (int num, const char OutputDir, Cosmology CP)

void	petaio_read_snapshot (int num, const char OutputDir, Cosmology CP, struct header_data header, struct part_manager_type PartManager, struct slots_manager_type *SlotsManager, MPI_Comm Comm)

static double	_get_attr_double (BigBlock bh, const char name, const double def)

static int	_get_attr_int (BigBlock bh, const char name, const int def)

void	petaio_alloc_buffer (BigArray array, IOTableEntry ent, int64_t localsize)

void	petaio_readout_buffer (BigArray array, IOTableEntry ent, struct conversions conv, struct part_manager_type PartManager, struct slots_manager_type *SlotsManager)

void	petaio_build_buffer (BigArray array, IOTableEntry ent, const int selection, const int NumSelection, struct particle_data Parts, struct slots_manager_type SlotsManager, struct conversions conv)

void	petaio_destroy_buffer (BigArray *array)

int	petaio_read_block (BigFile bf, const char blockname, BigArray *array, int required)

void	petaio_save_block (BigFile bf, const char blockname, BigArray *array, int verbose)

void	io_register_io_block (const char name, const char dtype, int items, int ptype, property_getter getter, property_setter setter, int required, struct IOTable *IOTable)

static void	GTPosition (int i, double out, void baseptr, void smanptr, const struct conversions params)

static void	STPosition (int i, double out, void baseptr, void smanptr, const struct conversions params)

static void	GTVelocity (int i, float out, void baseptr, void smanptr, const struct conversions params)

static void	STVelocity (int i, float out, void baseptr, void smanptr, const struct conversions params)

static void	GTBlackholeMinPotPos (int i, double out, void baseptr, void smanptr, const struct conversions params)

static void	GTNeutralHydrogenFraction (int i, float out, void baseptr, void smanptr, const struct conversions params)

static void	GTHeliumIFraction (int i, float out, void baseptr, void smanptr, const struct conversions params)

static void	GTHeliumIIFraction (int i, float out, void baseptr, void smanptr, const struct conversions params)

static void	GTHeliumIIIFraction (int i, float out, void baseptr, void smanptr, const struct conversions params)

static void	GTInternalEnergy (int i, float out, void baseptr, void smanptr, const struct conversions params)

static void	STInternalEnergy (int i, float out, void baseptr, void smanptr, const struct conversions params)

static void	GTHeIIIIonized (int i, unsigned char out, void baseptr, void smanptr, const struct conversions params)

static void	STHeIIIIonized (int i, unsigned char out, void baseptr, void smanptr, const struct conversions params)

static void	GTSwallowed (int i, unsigned char out, void baseptr, void smanptr, const struct conversions params)

static void	STSwallowed (int i, unsigned char out, void baseptr, void smanptr, const struct conversions params)

static int	order_by_type (const void a, const void b)

void	register_io_blocks (struct IOTable *IOTable, int WriteGroupID, int MetalReturnOn)

void	register_debug_io_blocks (struct IOTable *IOTable)

void	destroy_io_blocks (struct IOTable *IOTable)

Variables
static struct petaio_params	IO

static struct header_data	Header

Macro Definition Documentation

◆ SIMPLE_GETTER_PI

#define SIMPLE_GETTER_PI	(	name,
		field,
		dtype,
		items,
		slottype
	)

Value:

static void name(int i, dtype * out, void * baseptr, void * smanptr, const struct conversions * params) { \
    int PI = ((struct particle_data *) baseptr)[i].PI; \
    int ptype = ((struct particle_data *) baseptr)[i].Type; \
    struct slot_info * info = &(((struct slots_manager_type *) smanptr)->info[ptype]); \
    slottype * sl = (slottype *) info->ptr; \
    int k; \
    for(k = 0; k < items; k ++) { \
        out[k] = *(&(sl[PI].field) + k); \
    } \
}

Definition at line 713 of file petaio.c.

◆ SIMPLE_PROPERTY

#define SIMPLE_PROPERTY	(	name,
		field,
		type,
		items
	)

Value:

SIMPLE_GETTER(GT ## name , field, type, items, struct particle_data) \

SIMPLE_SETTER(ST ## name , field, type, items, struct particle_data)

SIMPLE_GETTER

#define SIMPLE_GETTER(name, field, type, items, stype)

Definition: petaio.h:145

Definition at line 704 of file petaio.c.

◆ SIMPLE_PROPERTY_PI

#define SIMPLE_PROPERTY_PI	(	name,
		field,
		type,
		items,
		slottype
	)

Value:

SIMPLE_GETTER_PI(GT ## name , field, type, items, slottype) \

SIMPLE_SETTER_PI(ST ## name , field, type, items, slottype)

SIMPLE_GETTER_PI

#define SIMPLE_GETTER_PI(name, field, dtype, items, slottype)

Definition: petaio.c:713

Definition at line 737 of file petaio.c.

◆ SIMPLE_PROPERTY_TYPE

#define SIMPLE_PROPERTY_TYPE	(	name,
		ptype,
		field,
		type,
		items
	)

Value:

SIMPLE_GETTER(GT ## ptype ## name , field, type, items, struct particle_data) \

SIMPLE_SETTER(ST ## ptype ## name , field, type, items, struct particle_data)

Definition at line 708 of file petaio.c.

◆ SIMPLE_PROPERTY_TYPE_PI

#define SIMPLE_PROPERTY_TYPE_PI	(	name,
		ptype,
		field,
		type,
		items,
		slottype
	)

Value:

SIMPLE_GETTER_PI(GT ## ptype ## name , field, type, items, slottype) \

SIMPLE_SETTER_PI(ST ## ptype ## name , field, type, items, slottype)

Definition at line 740 of file petaio.c.

◆ SIMPLE_SETTER_PI

#define SIMPLE_SETTER_PI	(	name,
		field,
		dtype,
		items,
		slottype
	)

Value:

static void name(int i, dtype * out, void * baseptr, void * smanptr, const struct conversions * params) { \
    int PI = ((struct particle_data *) baseptr)[i].PI; \
    int ptype = ((struct particle_data *) baseptr)[i].Type; \
    struct slot_info * info = &(((struct slots_manager_type *) smanptr)->info[ptype]); \
    slottype * sl = (slottype *) info->ptr; \
    int k; \
    for(k = 0; k < items; k ++) { \
        *(&(sl[PI].field) + k) = out[k]; \
    } \
}

Definition at line 725 of file petaio.c.

Function Documentation

◆ _get_attr_double()

static double _get_attr_double	(	BigBlock *	bh,
		const char *	name,
		const double	def
	)

static

Definition at line 407 of file petaio.c.

 {
     double foo;
     if(0 != big_block_get_attr(bh, name, &foo, "f8", 1)) {
         foo = def;
     }
     return foo;
 }

References name.

Referenced by petaio_read_header_internal().

Here is the caller graph for this function:

◆ _get_attr_int()

static int _get_attr_int	(	BigBlock *	bh,
		const char *	name,
		const int	def
	)

static

Definition at line 416 of file petaio.c.

 {
     int foo;
     if(0 != big_block_get_attr(bh, name, &foo, "i4", 1)) {
         foo = def;
     }
     return foo;
 }

References name.

Referenced by petaio_read_header_internal().

Here is the caller graph for this function:

◆ destroy_io_blocks()

void destroy_io_blocks ( struct IOTable * IOTable )

Definition at line 1034 of file petaio.c.

                                                  {
     myfree(IOTable->ent);
     IOTable->allocated = 0;
 }

References IOTable::allocated, IOTable::ent, and myfree.

Referenced by dump_snapshot(), fof_save_particles(), petaio_read_snapshot(), run_gravity_test(), and write_checkpoint().

Here is the caller graph for this function:

◆ GetUsePeculiarVelocity()

int GetUsePeculiarVelocity ( void )

Definition at line 79 of file petaio.c.

 {
     return IO.UsePeculiarVelocity;
 }

References IO, and petaio_params::UsePeculiarVelocity.

Referenced by fof_write_header(), and GTMassCenterVelocity().

Here is the caller graph for this function:

◆ GTBlackholeMinPotPos()

static void GTBlackholeMinPotPos	(	int	i,
		double *	out,
		void *	baseptr,
		void *	smanptr,
		const struct conversions *	params
	)

static

Definition at line 806 of file petaio.c.

                                                                                                                          {
     /* Remove the particle offset before saving*/
     struct particle_data * part = (struct particle_data *) baseptr;
     int PI = part[i].PI;
     struct slot_info * info = &(((struct slots_manager_type *) smanptr)->info[5]);
     struct bh_particle_data * sl = (struct bh_particle_data *) info->ptr;
     int d;
     for(d = 0; d < 3; d ++) {
         out[d] = sl[PI].MinPotPos[d] - PartManager->CurrentParticleOffset[d];
         while(out[d] > PartManager->BoxSize) out[d] -= PartManager->BoxSize;
         while(out[d] <= 0) out[d] += PartManager->BoxSize;
     }
 }

References part_manager_type::BoxSize, part_manager_type::CurrentParticleOffset, bh_particle_data::MinPotPos, PartManager, particle_data::PI, and slot_info::ptr.

◆ GTHeIIIIonized()

static void GTHeIIIIonized	(	int	i,
		unsigned char *	out,
		void *	baseptr,
		void *	smanptr,
		const struct conversions *	params
	)

static

Definition at line 873 of file petaio.c.

                                                                                                                           {
     struct particle_data * part = (struct particle_data *) baseptr;
     *out = part[i].HeIIIionized;
 }

References particle_data::HeIIIionized.

◆ GTHeliumIFraction()

static void GTHeliumIFraction	(	int	i,
		float *	out,
		void *	baseptr,
		void *	smanptr,
		const struct conversions *	params
	)

static

Definition at line 831 of file petaio.c.

                                                                                                                      {
     double redshift = 1./params->atime - 1;
     struct particle_data * pl = ((struct particle_data *) baseptr)+i;
     int PI = pl->PI;
     struct slot_info * info = &(((struct slots_manager_type *) smanptr)->info[0]);
     struct sph_particle_data * sl = (struct sph_particle_data *) info->ptr;
     *out = get_helium_neutral_fraction_sfreff(0, redshift, params->hubble, pl, sl+PI);
 }

References conversions::atime, get_helium_neutral_fraction_sfreff(), conversions::hubble, particle_data::PI, and slot_info::ptr.

Here is the call graph for this function:

◆ GTHeliumIIFraction()

static void GTHeliumIIFraction	(	int	i,
		float *	out,
		void *	baseptr,
		void *	smanptr,
		const struct conversions *	params
	)

static

Definition at line 839 of file petaio.c.

                                                                                                                       {
     double redshift = 1./params->atime - 1;
     struct particle_data * pl = ((struct particle_data *) baseptr)+i;
     int PI = pl->PI;
     struct slot_info * info = &(((struct slots_manager_type *) smanptr)->info[0]);
     struct sph_particle_data * sl = (struct sph_particle_data *) info->ptr;
     *out = get_helium_neutral_fraction_sfreff(1, redshift, params->hubble, pl, sl+PI);
 }

References conversions::atime, get_helium_neutral_fraction_sfreff(), conversions::hubble, particle_data::PI, and slot_info::ptr.

Here is the call graph for this function:

◆ GTHeliumIIIFraction()

static void GTHeliumIIIFraction	(	int	i,
		float *	out,
		void *	baseptr,
		void *	smanptr,
		const struct conversions *	params
	)

static

Definition at line 847 of file petaio.c.

                                                                                                                        {
     double redshift = 1./params->atime - 1;
     struct particle_data * pl = ((struct particle_data *) baseptr)+i;
     int PI = pl->PI;
     struct slot_info * info = &(((struct slots_manager_type *) smanptr)->info[0]);
     struct sph_particle_data * sl = (struct sph_particle_data *) info->ptr;
     *out = get_helium_neutral_fraction_sfreff(2, redshift, params->hubble, pl, sl+PI);
 }

References conversions::atime, get_helium_neutral_fraction_sfreff(), conversions::hubble, particle_data::PI, and slot_info::ptr.

Here is the call graph for this function:

◆ GTInternalEnergy()

static void GTInternalEnergy	(	int	i,
		float *	out,
		void *	baseptr,
		void *	smanptr,
		const struct conversions *	params
	)

static

Definition at line 855 of file petaio.c.

                                                                                                                     {
     int PI = ((struct particle_data *) baseptr)[i].PI;
     struct slot_info * info = &(((struct slots_manager_type *) smanptr)->info[0]);
     struct sph_particle_data * sl = (struct sph_particle_data *) info->ptr;
     double a3inv = 1/(params->atime * params->atime * params->atime);
     *out = sl[PI].Entropy / GAMMA_MINUS1 * pow(sl[PI].Density * a3inv, GAMMA_MINUS1);
 }

References conversions::atime, sph_particle_data::Density, sph_particle_data::Entropy, GAMMA_MINUS1, and slot_info::ptr.

◆ GTNeutralHydrogenFraction()

static void GTNeutralHydrogenFraction	(	int	i,
		float *	out,
		void *	baseptr,
		void *	smanptr,
		const struct conversions *	params
	)

static

Definition at line 822 of file petaio.c.

                                                                                                                              {
     double redshift = 1./params->atime - 1;
     struct particle_data * pl = ((struct particle_data *) baseptr)+i;
     int PI = pl->PI;
     struct slot_info * info = &(((struct slots_manager_type *) smanptr)->info[0]);
     struct sph_particle_data * sl = (struct sph_particle_data *) info->ptr;
     *out = get_neutral_fraction_sfreff(redshift, params->hubble, pl, sl+PI);
 }

References get_neutral_fraction_sfreff(), particle_data::PI, and slot_info::ptr.

Here is the call graph for this function:

◆ GTPosition()

static void GTPosition	(	int	i,
		double *	out,
		void *	baseptr,
		void *	smanptr,
		const struct conversions *	params
	)

static

Definition at line 685 of file petaio.c.

                                                                                                                {
     /* Remove the particle offset before saving*/
     struct particle_data * part = (struct particle_data *) baseptr;
     int d;
     for(d = 0; d < 3; d ++) {
         out[d] = part[i].Pos[d] - PartManager->CurrentParticleOffset[d];
         while(out[d] > PartManager->BoxSize) out[d] -= PartManager->BoxSize;
         while(out[d] <= 0) out[d] += PartManager->BoxSize;
     }
 }

References part_manager_type::BoxSize, part_manager_type::CurrentParticleOffset, PartManager, and particle_data::Pos.

◆ GTSwallowed()

static void GTSwallowed	(	int	i,
		unsigned char *	out,
		void *	baseptr,
		void *	smanptr,
		const struct conversions *	params
	)

static

Definition at line 882 of file petaio.c.

                                                                                                                        {
     struct particle_data * part = (struct particle_data *) baseptr;
     *out = part[i].Swallowed;
 }

References particle_data::Swallowed.

◆ GTVelocity()

static void GTVelocity	(	int	i,
		float *	out,
		void *	baseptr,
		void *	smanptr,
		const struct conversions *	params
	)

static

Definition at line 744 of file petaio.c.

                                                                                                               {
     /* Convert to Peculiar Velocity if UsePeculiarVelocity is set */
     double fac;
     struct particle_data * part = (struct particle_data *) baseptr;
     if (IO.UsePeculiarVelocity) {
         fac = 1.0 / params->atime;
     } else {
         fac = 1.0;
     }
  
     int d;
     for(d = 0; d < 3; d ++) {
         out[d] = fac * part[i].Vel[d];
     }
 }

References conversions::atime, IO, petaio_params::UsePeculiarVelocity, and particle_data::Vel.

◆ io_register_io_block()

void io_register_io_block	(	const char *	name,
		const char *	dtype,
		int	items,
		int	ptype,
		property_getter	getter,
		property_setter	setter,
		int	required,
		struct IOTable *	IOTable
	)

Definition at line 658 of file petaio.c.

           {
     if (IOTable->used == IOTable->allocated) {
         IOTable->ent = (IOTableEntry *) myrealloc(IOTable->ent, 2*IOTable->allocated*sizeof(IOTableEntry));
         IOTable->allocated *= 2;
     }
     IOTableEntry * ent = &IOTable->ent[IOTable->used];
     strncpy(ent->name, name, 63);
     ent->name[63] = '\0';
     ent->zorder = IOTable->used;
     ent->ptype = ptype;
     strncpy(ent->dtype, dtype, 7);
     ent->dtype[7] = '\0';
     ent->getter = getter;
     ent->setter = setter;
     ent->items = items;
     ent->required = required;
     IOTable->used ++;
 }

References IOTable::allocated, IOTableEntry::dtype, IOTable::ent, IOTableEntry::getter, IOTableEntry::items, myrealloc, name, IOTableEntry::name, IOTableEntry::ptype, ptype, IOTableEntry::required, IOTableEntry::setter, IOTable::used, and IOTableEntry::zorder.

◆ order_by_type()

static int order_by_type	(	const void *	a,
		const void *	b
	)

static

Definition at line 892 of file petaio.c.

 {
     const struct IOTableEntry * pa  = (const struct IOTableEntry *) a;
     const struct IOTableEntry * pb  = (const struct IOTableEntry *) b;
  
     if(pa->ptype < pb->ptype)
         return -1;
     if(pa->ptype > pb->ptype)
         return +1;
     if(pa->zorder < pb->zorder)
         return -1;
     if(pa->zorder > pb->zorder)
         return 1;
  
     return 0;
 }

References IOTableEntry::ptype, and IOTableEntry::zorder.

Referenced by register_debug_io_blocks(), and register_io_blocks().

Here is the caller graph for this function:

◆ petaio_alloc_buffer()

void petaio_alloc_buffer	(	BigArray *	array,
		IOTableEntry *	ent,
		int64_t	localsize
	)

Definition at line 491 of file petaio.c.

                                                                                   {
     size_t dims[2];
     ptrdiff_t strides[2];
     int elsize = dtype_itemsize(ent->dtype);
  
     dims[0] = localsize;
     dims[1] = ent->items;
     strides[1] = elsize;
     strides[0] = elsize * ent->items;
     char * buffer = (char *) mymalloc("IOBUFFER", dims[0] * dims[1] * elsize);
  
     big_array_init(array, buffer, ent->dtype, 2, dims, strides);
 }

References IOTableEntry::dtype, IOTableEntry::items, and mymalloc.

Referenced by build_buffer_fof(), petaio_build_buffer(), and petaio_read_snapshot().

Here is the caller graph for this function:

◆ petaio_build_buffer()

void petaio_build_buffer	(	BigArray *	array,
		IOTableEntry *	ent,
		const int *	selection,
		const int	NumSelection,
		struct particle_data *	Parts,
		struct slots_manager_type *	SlotsManager,
		struct conversions *	conv
	)

Definition at line 521 of file petaio.c.

 {
     if(selection == NULL) {
         endrun(-1, "NULL selection is not supported\n");
     }
  
     /* don't forget to free buffer after its done*/
     petaio_alloc_buffer(array, ent, NumSelection);
  
     /* Fast code path if there are no such particles */
     if(NumSelection == 0) {
         return;
     }
  
 #pragma omp parallel
     {
         int i;
         const int tid = omp_get_thread_num();
         const int NT = omp_get_num_threads();
         const int start = NumSelection * (size_t) tid / NT;
         const int end = NumSelection * ((size_t) tid + 1) / NT;
         /* fill the buffer */
         char * p = (char *) array->data;
         p += array->strides[0] * start;
         for(i = start; i < end; i ++) {
             const int j = selection[i];
             if(Parts[j].Type != ent->ptype) {
                 endrun(2, "Selection %d has type = %d != %d\n", j, Parts[j].Type, ent->ptype);
             }
             ent->getter(j, p, Parts, SlotsManager, conv);
             p += array->strides[0];
         }
     }
 }

References endrun(), IOTableEntry::getter, petaio_alloc_buffer(), IOTableEntry::ptype, SlotsManager, and particle_data::Type.

Referenced by fof_save_particles(), and petaio_save_snapshot().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ petaio_build_selection()

void petaio_build_selection	(	int *	selection,
		int *	ptype_offset,
		int *	ptype_count,
		const struct particle_data *	Parts,
		const int	NumPart,
		int()(int i, const struct particle_data Parts)	select_func
	)

Create a Selection array for the buffers. This array indirectly sort the particles by the type.

The offset for the starting of each type is stored in ptype_offset.

if select_func is provided, it shall return 1 for those that shall be included in the output.

Definition at line 113 of file petaio.c.

 {
     int i;
     ptype_offset[0] = 0;
     ptype_count[0] = 0;
  
     for(i = 0; i < NumPart; i ++) {
         if(P[i].IsGarbage)
             continue;
         if((select_func == NULL) || (select_func(i, Parts) != 0)) {
             int ptype = Parts[i].Type;
             ptype_count[ptype] ++;
         }
     }
     for(i = 1; i < 6; i ++) {
         ptype_offset[i] = ptype_offset[i-1] + ptype_count[i-1];
         ptype_count[i-1] = 0;
     }
  
     ptype_count[5] = 0;
     for(i = 0; i < NumPart; i ++) {
         int ptype = Parts[i].Type;
         if(P[i].IsGarbage)
             continue;
         if((select_func == NULL) || (select_func(i, Parts) != 0)) {
             selection[ptype_offset[ptype] + ptype_count[ptype]] = i;
             ptype_count[ptype]++;
         }
     }
 }

References P, ptype, and particle_data::Type.

Referenced by fof_save_particles(), and petaio_save_snapshot().

Here is the caller graph for this function:

◆ petaio_destroy_buffer()

void petaio_destroy_buffer ( BigArray * array )

Definition at line 557 of file petaio.c.

                                              {
     myfree(array->data);
 }

References myfree.

Referenced by fof_save_particles(), petaio_read_snapshot(), and petaio_save_snapshot().

Here is the caller graph for this function:

◆ petaio_get_snapshot_fname()

char* petaio_get_snapshot_fname	(	int	num,
		const char *	OutputDir
	)

Definition at line 207 of file petaio.c.

 {
     char * fname;
     if(num == -1) {
         fname = fastpm_strdup_printf("%s", IO.InitCondFile);
     } else {
         fname = fastpm_strdup_printf("%s/%s_%03d", OutputDir, IO.SnapshotFileBase, num);
     }
     return fname;
 }

References fastpm_strdup_printf(), petaio_params::InitCondFile, IO, and petaio_params::SnapshotFileBase.

Referenced by petaio_read_snapshot(), and write_checkpoint().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ petaio_init()

void petaio_init ( void )

Definition at line 88 of file petaio.c.

                        {
     /* Smaller files will do aggregated IO.*/
     if(IO.EnableAggregatedIO) {
         message(0, "Aggregated IO is enabled\n");
         big_file_mpi_set_aggregated_threshold(IO.AggregatedIOThreshold);
     } else {
         message(0, "Aggregated IO is disabled.\n");
         big_file_mpi_set_aggregated_threshold(0);
     }
     if(IO.NumWriters == 0)
         MPI_Comm_size(MPI_COMM_WORLD, &IO.NumWriters);
 }

References petaio_params::AggregatedIOThreshold, petaio_params::EnableAggregatedIO, IO, message(), and petaio_params::NumWriters.

Referenced by begrun().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ petaio_read_block()

int petaio_read_block	(	BigFile *	bf,
		const char *	blockname,
		BigArray *	array,
		int	required
	)

Definition at line 562 of file petaio.c.

                                                                                             {
     BigBlock bb;
     BigBlockPtr ptr;
  
     /* open the block */
     if(0 != big_file_mpi_open_block(bf, &bb, blockname, MPI_COMM_WORLD)) {
         if(required)
             endrun(0, "Failed to open block at %s:%s\n", blockname, big_file_get_error_message());
         else
             return 1;
     }
     if(0 != big_block_seek(&bb, &ptr, 0)) {
             endrun(1, "Failed to seek block %s: %s\n", blockname, big_file_get_error_message());
     }
     if(0 != big_block_mpi_read(&bb, &ptr, array, IO.NumWriters, MPI_COMM_WORLD)) {
         endrun(1, "Failed to read from block %s: %s\n", blockname, big_file_get_error_message());
     }
     if(0 != big_block_mpi_close(&bb, MPI_COMM_WORLD)) {
         endrun(0, "Failed to close block at %s:%s\n", blockname,
                     big_file_get_error_message());
     }
     return 0;
 }

References endrun(), IO, and petaio_params::NumWriters.

Referenced by petaio_read_icnutransfer(), petaio_read_neutrinos(), and petaio_read_snapshot().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ petaio_read_header()

struct header_data petaio_read_header	(	int	num,
		const char *	OutputDir,
		Cosmology *	CP
	)

Definition at line 207 of file petaio.c.

 {
     BigFile bf = {0};
  
     char * fname = petaio_get_snapshot_fname(num, OutputDir);
     message(0, "Probing Header of snapshot file: %s\n", fname);
  
     if(0 != big_file_mpi_open(&bf, fname, MPI_COMM_WORLD)) {
         endrun(0, "Failed to open snapshot at %s:%s\n", fname,
                     big_file_get_error_message());
     }
  
     struct header_data head;
     petaio_read_header_internal(&bf, CP, &head);
     head.neutrinonk = -1;
     /* Try to read the neutrino header data from the snapshot.
      * If this fails then neutrinonk will be zero.*/
     if(num >= 0) {
         BigBlock bn;
         if(0 == big_file_mpi_open_block(&bf, &bn, "Neutrino", MPI_COMM_WORLD)) {
             if(0 != big_block_get_attr(&bn, "Nkval", &head.neutrinonk, "u8", 1))
                 endrun(0, "Failed to read attr: %s\n", big_file_get_error_message());
             big_block_mpi_close(&bn, MPI_COMM_WORLD);
         }
     }
  
     if(0 != big_file_mpi_close(&bf, MPI_COMM_WORLD)) {
         endrun(0, "Failed to close snapshot at %s:%s\n", fname,
                     big_file_get_error_message());
     }
     myfree(fname);
     Header = head;
     return head;
 }

Referenced by begrun().

Here is the caller graph for this function:

◆ petaio_read_header_internal()

static void petaio_read_header_internal	(	BigFile *	bf,
		Cosmology *	CP,
		struct header_data *	data
	)

static

Definition at line 426 of file petaio.c.

                                                                                        {
     BigBlock bh;
     if(0 != big_file_mpi_open_block(bf, &bh, "Header", MPI_COMM_WORLD)) {
         endrun(0, "Failed to create block at %s:%s\n", "Header",
                     big_file_get_error_message());
     }
     double Time = 0.;
     if(
     (0 != big_block_get_attr(&bh, "TotNumPart", Header->NTotal, "u8", 6)) ||
     (0 != big_block_get_attr(&bh, "MassTable", Header->MassTable, "f8", 6)) ||
     (0 != big_block_get_attr(&bh, "BoxSize", &Header->BoxSize, "f8", 1)) ||
     (0 != big_block_get_attr(&bh, "Time", &Time, "f8", 1))
     ) {
         endrun(0, "Failed to read attr: %s\n",
                     big_file_get_error_message());
     }
  
     Header->TimeSnapshot = Time;
     if(0!= big_block_get_attr(&bh, "TimeIC", &Header->TimeIC, "f8", 1))
         Header->TimeIC = Time;
  
     /* Set a reasonable MassTable entry for stars and BHs*/
     if(Header->MassTable[4] == 0)
         Header->MassTable[4] = Header->MassTable[0] / get_generations();
     if(Header->MassTable[5] == 0)
         Header->MassTable[5] = Header->MassTable[4];
  
     /* fall back to traditional MP-Gadget Units if not given in the snapshot file. */
     Header->UnitVelocity_in_cm_per_s = _get_attr_double(&bh, "UnitVelocity_in_cm_per_s", 1e5); /* 1 km/sec */
     Header->UnitLength_in_cm = _get_attr_double(&bh, "UnitLength_in_cm",  3.085678e21); /* 1.0 Kpc /h */
     Header->UnitMass_in_g = _get_attr_double(&bh, "UnitMass_in_g", 1.989e43); /* 1e10 Msun/h */
  
     double OmegaBaryon = CP->OmegaBaryon;
     double HubbleParam = CP->HubbleParam;
     double OmegaLambda = CP->OmegaLambda;
  
     if(0 == big_block_get_attr(&bh, "OmegaBaryon", &CP->OmegaBaryon, "f8", 1) &&
             OmegaBaryon > 0 && fabs(CP->OmegaBaryon - OmegaBaryon) > 1e-3)
         message(0,"IC Header has Omega_b = %g but paramfile wants %g\n", CP->OmegaBaryon, OmegaBaryon);
     if(0 == big_block_get_attr(&bh, "HubbleParam", &CP->HubbleParam, "f8", 1) &&
             HubbleParam > 0 && fabs(CP->HubbleParam - HubbleParam) > 1e-3)
         message(0,"IC Header has HubbleParam = %g but paramfile wants %g\n", CP->HubbleParam, HubbleParam);
     if(0 == big_block_get_attr(&bh, "OmegaLambda", &CP->OmegaLambda, "f8", 1) &&
             OmegaLambda > 0 && fabs(CP->OmegaLambda - OmegaLambda) > 1e-3)
         message(0,"IC Header has Omega_L = %g but paramfile wants %g\n", CP->OmegaLambda, OmegaLambda);
  
     /* If UsePeculiarVelocity = 1 then snapshots save to the velocity field the physical peculiar velocity, v = a dx/dt (where x is comoving distance).
      * If UsePeculiarVelocity = 0 then the velocity field is a * v = a^2 dx/dt in snapshots
      * and v / sqrt(a) = sqrt(a) dx/dt in the ICs. Note that snapshots never match Gadget-2, which
      * saves physical peculiar velocity / sqrt(a) in both ICs and snapshots. */
     IO.UsePeculiarVelocity = _get_attr_int(&bh, "UsePeculiarVelocity", 0);
  
     if(0 != big_block_get_attr(&bh, "TotNumPartInit", Header->NTotalInit, "u8", 6)) {
         int ptype;
         for(ptype = 0; ptype < 6; ptype ++) {
             Header->NTotalInit[ptype] = Header->NTotal[ptype];
         }
     }
  
     if(0 != big_block_mpi_close(&bh, MPI_COMM_WORLD)) {
         endrun(0, "Failed to close block: %s\n",
                     big_file_get_error_message());
     }
 }

References _get_attr_double(), _get_attr_int(), header_data::BoxSize, CP, endrun(), get_generations(), Header, Cosmology::HubbleParam, IO, header_data::MassTable, message(), header_data::NTotal, header_data::NTotalInit, Cosmology::OmegaBaryon, Cosmology::OmegaLambda, ptype, header_data::TimeIC, header_data::TimeSnapshot, header_data::UnitLength_in_cm, header_data::UnitMass_in_g, header_data::UnitVelocity_in_cm_per_s, and petaio_params::UsePeculiarVelocity.

Here is the call graph for this function:

◆ petaio_read_snapshot()

void petaio_read_snapshot	(	int	num,
		const char *	OutputDir,
		Cosmology *	CP,
		struct header_data *	header,
		struct part_manager_type *	PartManager,
		struct slots_manager_type *	SlotsManager,
		MPI_Comm	Comm
	)

Definition at line 255 of file petaio.c.

 {
     char * fname = petaio_get_snapshot_fname(num, OutputDir);
     int i;
     const int ic = (num == -1);
     BigFile bf = {0};
     message(0, "Reading snapshot %s\n", fname);
  
     if(0 != big_file_mpi_open(&bf, fname, Comm)) {
         endrun(0, "Failed to open snapshot at %s:%s\n", fname,
                     big_file_get_error_message());
     }
  
     /*Read neutrinos from the snapshot if necessary*/
     if(CP->MassiveNuLinRespOn) {
         int ThisTask;
         MPI_Comm_rank(Comm, &ThisTask);
         /*Read the neutrino transfer function from the ICs: init_neutrinos_lra should have been called before this!*/
         if(ic)
             petaio_read_icnutransfer(&bf, ThisTask);
         else
             petaio_read_neutrinos(&bf, ThisTask);
     }
  
     struct conversions conv = {0};
     conv.atime = header->TimeSnapshot;
     conv.hubble = hubble_function(CP, header->TimeSnapshot);
  
     struct IOTable IOTable[1] = {0};
     /* Always try to read the metal tables.
      * This lets us turn it off for a short period and then re-enable it.
      * Note the metal fields are non-fatal so this does not break resuming without metals.*/
     register_io_blocks(IOTable, 0, 1);
  
     for(i = 0; i < IOTable->used; i ++) {
         /* only process the particle blocks */
         char blockname[128];
         int ptype = IOTable->ent[i].ptype;
         BigArray array = {0};
         if(!(ptype < 6 && ptype >= 0)) {
             continue;
         }
         if(header->NTotal[ptype] == 0) continue;
         if(ic) {
             /* for IC read in only three blocks */
             int keep = 0;
             keep |= (0 == strcmp(IOTable->ent[i].name, "Position"));
             keep |= (0 == strcmp(IOTable->ent[i].name, "Velocity"));
             keep |= (0 == strcmp(IOTable->ent[i].name, "ID"));
             if (ptype == 5) {
                 keep |= (0 == strcmp(IOTable->ent[i].name, "Mass"));
                 keep |= (0 == strcmp(IOTable->ent[i].name, "BlackholeMass"));
                 keep |= (0 == strcmp(IOTable->ent[i].name, "MinPotPos"));
             }
             if(!keep) continue;
         }
         if(IOTable->ent[i].setter == NULL) {
             /* FIXME: do not know how to read this block; assume the fucker is
              * internally intialized; */
             continue;
         }
         sprintf(blockname, "%d/%s", ptype, IOTable->ent[i].name);
         petaio_alloc_buffer(&array, &IOTable->ent[i], header->NLocal[ptype]);
         if(0 == petaio_read_block(&bf, blockname, &array, IOTable->ent[i].required))
             petaio_readout_buffer(&array, &IOTable->ent[i], &conv, PartManager, SlotsManager);
         petaio_destroy_buffer(&array);
     }
     destroy_io_blocks(IOTable);
  
     if(0 != big_file_mpi_close(&bf, Comm)) {
         endrun(0, "Failed to close snapshot at %s:%s\n", fname,
                     big_file_get_error_message());
     }
     /* now we have IDs, set up the ID consistency between slots. */
     slots_setup_id(PartManager, SlotsManager);
     myfree(fname);
  
     if(ic) {
         /*
          *  IC doesn't have entropy or energy; always use the
          *  InitTemp in paramfile, then use init.c to convert to
          *  entropy.
          * */
         struct particle_data * parts = PartManager->Base;
         int i;
         /* touch up the mass -- IC files save mass in header */
         #pragma omp parallel for
         for(i = 0; i < PartManager->NumPart; i++)
         {
             parts[i].Mass = header->MassTable[parts[i].Type];
         }
  
         if (!IO.UsePeculiarVelocity ) {
             /* fixing the unit of velocity from Legacy GenIC IC */
             #pragma omp parallel for
             for(i = 0; i < PartManager->NumPart; i++) {
                 int k;
                 /* for GenIC's Gadget-1 snapshot Unit to Gadget-2 Internal velocity unit */
                 for(k = 0; k < 3; k++)
                     parts[i].Vel[k] *= sqrt(header->TimeSnapshot) * header->TimeSnapshot;
             }
         }
     }
 }

References conversions::atime, part_manager_type::Base, CP, destroy_io_blocks(), endrun(), IOTable::ent, conversions::hubble, hubble_function(), IO, particle_data::Mass, Cosmology::MassiveNuLinRespOn, header_data::MassTable, message(), myfree, IOTableEntry::name, header_data::NLocal, header_data::NTotal, part_manager_type::NumPart, PartManager, petaio_alloc_buffer(), petaio_destroy_buffer(), petaio_get_snapshot_fname(), petaio_read_block(), petaio_read_icnutransfer(), petaio_read_neutrinos(), petaio_readout_buffer(), IOTableEntry::ptype, ptype, register_io_blocks(), IOTableEntry::required, IOTableEntry::setter, slots_setup_id(), SlotsManager, ThisTask, header_data::TimeSnapshot, particle_data::Type, IOTable::used, petaio_params::UsePeculiarVelocity, and particle_data::Vel.

Referenced by init().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ petaio_readout_buffer()

void petaio_readout_buffer	(	BigArray *	array,
		IOTableEntry *	ent,
		struct conversions *	conv,
		struct part_manager_type *	PartManager,
		struct slots_manager_type *	SlotsManager
	)

Definition at line 506 of file petaio.c.

                                                                                                                                                                               {
     int i;
     /* fill the buffer */
     char * p = (char *) array->data;
     for(i = 0; i < PartManager->NumPart; i ++) {
         if(PartManager->Base[i].Type != ent->ptype) continue;
         ent->setter(i, p, PartManager->Base, SlotsManager, conv);
         p += array->strides[0];
     }
 }

References part_manager_type::Base, PartManager, IOTableEntry::ptype, IOTableEntry::setter, SlotsManager, and particle_data::Type.

Referenced by petaio_read_snapshot().

Here is the caller graph for this function:

◆ petaio_save_block()

void petaio_save_block	(	BigFile *	bf,
		const char *	blockname,
		BigArray *	array,
		int	verbose
	)

Definition at line 587 of file petaio.c.

 {
  
     BigBlock bb;
     BigBlockPtr ptr;
  
     int elsize = big_file_dtype_itemsize(array->dtype);
  
     int NumWriters = IO.NumWriters;
  
     size_t size = count_sum(array->dims[0]);
     int NumFiles;
  
     if(IO.EnableAggregatedIO) {
         NumFiles = (size * elsize + IO.BytesPerFile - 1) / IO.BytesPerFile;
         if(NumWriters > NumFiles * IO.WritersPerFile) {
             NumWriters = NumFiles * IO.WritersPerFile;
             message(0, "Throttling NumWriters to %d.\n", NumWriters);
         }
         if(NumWriters < IO.MinNumWriters) {
             NumWriters = IO.MinNumWriters;
             NumFiles = (NumWriters + IO.WritersPerFile - 1) / IO.WritersPerFile ;
             message(0, "Throttling NumWriters to %d.\n", NumWriters);
         }
     } else {
         NumFiles = NumWriters;
     }
     /*Do not write empty files*/
     if(size == 0) {
         NumFiles = 0;
     }
  
     if(verbose && size > 0) {
         message(0, "Will write %td particles to %d Files for %s\n", size, NumFiles, blockname);
     }
     /* create the block */
     /* dims[1] is the number of members per item */
     if(0 != big_file_mpi_create_block(bf, &bb, blockname, array->dtype, array->dims[1], NumFiles, size, MPI_COMM_WORLD)) {
         endrun(0, "Failed to create block at %s:%s\n", blockname,
                     big_file_get_error_message());
     }
     if(0 != big_block_seek(&bb, &ptr, 0)) {
         endrun(0, "Failed to seek:%s\n", big_file_get_error_message());
     }
     if(0 != big_block_mpi_write(&bb, &ptr, array, NumWriters, MPI_COMM_WORLD)) {
         endrun(0, "Failed to write :%s\n", big_file_get_error_message());
     }
  
     if(verbose && size > 0)
         message(0, "Done writing %td particles to %d Files\n", size, NumFiles);
  
     if(0 != big_block_mpi_close(&bb, MPI_COMM_WORLD)) {
         endrun(0, "Failed to close block at %s:%s\n", blockname,
                 big_file_get_error_message());
     }
 }

References petaio_params::BytesPerFile, count_sum(), petaio_params::EnableAggregatedIO, endrun(), IO, message(), petaio_params::MinNumWriters, petaio_params::NumWriters, and petaio_params::WritersPerFile.

Referenced by fof_save_particles(), petaio_save_neutrinos(), and petaio_save_snapshot().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ petaio_save_snapshot()

void petaio_save_snapshot	(	const char *	fname,
		struct IOTable *	IOTable,
		int	verbose,
		const double	atime,
		const Cosmology *	CP
	)

Definition at line 151 of file petaio.c.

 {
     message(0, "saving snapshot into %s\n", fname);
  
     BigFile bf = {0};
     if(0 != big_file_mpi_create(&bf, fname, MPI_COMM_WORLD)) {
         endrun(0, "Failed to create snapshot at %s:%s\n", fname,
                     big_file_get_error_message());
     }
  
     int ptype_offset[6]={0};
     int ptype_count[6]={0};
     int64_t NTotal[6]={0};
  
     int * selection = (int *) mymalloc("Selection", sizeof(int) * PartManager->NumPart);
  
     petaio_build_selection(selection, ptype_offset, ptype_count, P, PartManager->NumPart, NULL);
  
     sumup_large_ints(6, ptype_count, NTotal);
  
     struct conversions conv = {0};
     conv.atime = atime;
     conv.hubble = hubble_function(CP, atime);
  
     petaio_write_header(&bf, atime, NTotal, CP, &Header);
  
     int i;
     for(i = 0; i < IOTable->used; i ++) {
         /* only process the particle blocks */
         char blockname[128];
         int ptype = IOTable->ent[i].ptype;
         BigArray array = {0};
         /*This exclude FOF blocks*/
         if(!(ptype < 6 && ptype >= 0)) {
             continue;
         }
         sprintf(blockname, "%d/%s", ptype, IOTable->ent[i].name);
         petaio_build_buffer(&array, &IOTable->ent[i], selection + ptype_offset[ptype], ptype_count[ptype], P, SlotsManager, &conv);
         petaio_save_block(&bf, blockname, &array, verbose);
         petaio_destroy_buffer(&array);
     }
  
     if(CP->MassiveNuLinRespOn) {
         int ThisTask;
         MPI_Comm_rank(MPI_COMM_WORLD, &ThisTask);
         petaio_save_neutrinos(&bf, ThisTask);
     }
     if(0 != big_file_mpi_close(&bf, MPI_COMM_WORLD)){
         endrun(0, "Failed to close snapshot at %s:%s\n", fname,
                     big_file_get_error_message());
     }
  
     myfree(selection);
 }

References conversions::atime, CP, endrun(), IOTable::ent, Header, conversions::hubble, hubble_function(), Cosmology::MassiveNuLinRespOn, message(), myfree, mymalloc, IOTableEntry::name, header_data::NTotal, part_manager_type::NumPart, P, PartManager, petaio_build_buffer(), petaio_build_selection(), petaio_destroy_buffer(), petaio_save_block(), petaio_save_neutrinos(), petaio_write_header(), IOTableEntry::ptype, ptype, SlotsManager, sumup_large_ints(), ThisTask, and IOTable::used.

Referenced by dump_snapshot(), run_gravity_test(), and write_checkpoint().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ petaio_write_header()

static void petaio_write_header	(	BigFile *	bf,
		const double	atime,
		const int64_t *	NTotal,
		const Cosmology *	CP,
		const struct header_data *	data
	)

static

Definition at line 361 of file petaio.c.

                                                                                                                                                  {
     BigBlock bh;
     if(0 != big_file_mpi_create_block(bf, &bh, "Header", NULL, 0, 0, 0, MPI_COMM_WORLD)) {
         endrun(0, "Failed to create block at %s:%s\n", "Header",
                 big_file_get_error_message());
     }
  
     /* conversion from peculiar velocity to RSD */
     const double hubble = hubble_function(CP, atime);
     double RSD = 1.0 / (atime * hubble);
  
     if(!IO.UsePeculiarVelocity) {
         RSD /= atime; /* Conversion from internal velocity to RSD */
     }
  
     int dk = GetDensityKernelType();
     if(
     (0 != big_block_set_attr(&bh, "TotNumPart", NTotal, "u8", 6)) ||
     (0 != big_block_set_attr(&bh, "TotNumPartInit", &data->NTotalInit, "u8", 6)) ||
     (0 != big_block_set_attr(&bh, "MassTable", &data->MassTable, "f8", 6)) ||
     (0 != big_block_set_attr(&bh, "Time", &atime, "f8", 1)) ||
     (0 != big_block_set_attr(&bh, "TimeIC", &data->TimeIC, "f8", 1)) ||
     (0 != big_block_set_attr(&bh, "BoxSize", &data->BoxSize, "f8", 1)) ||
     (0 != big_block_set_attr(&bh, "OmegaLambda", &CP->OmegaLambda, "f8", 1)) ||
     (0 != big_block_set_attr(&bh, "RSDFactor", &RSD, "f8", 1)) ||
     (0 != big_block_set_attr(&bh, "UsePeculiarVelocity", &IO.UsePeculiarVelocity, "i4", 1)) ||
     (0 != big_block_set_attr(&bh, "Omega0", &CP->Omega0, "f8", 1)) ||
     (0 != big_block_set_attr(&bh, "CMBTemperature", &CP->CMBTemperature, "f8", 1)) ||
     (0 != big_block_set_attr(&bh, "OmegaBaryon", &CP->OmegaBaryon, "f8", 1)) ||
     (0 != big_block_set_attr(&bh, "UnitLength_in_cm", &data->UnitLength_in_cm, "f8", 1)) ||
     (0 != big_block_set_attr(&bh, "UnitMass_in_g", &data->UnitMass_in_g, "f8", 1)) ||
     (0 != big_block_set_attr(&bh, "UnitVelocity_in_cm_per_s", &data->UnitVelocity_in_cm_per_s, "f8", 1)) ||
     (0 != big_block_set_attr(&bh, "CodeVersion", GADGET_VERSION, "S1", strlen(GADGET_VERSION))) ||
     (0 != big_block_set_attr(&bh, "CompilerSettings", GADGET_COMPILER_SETTINGS, "S1", strlen(GADGET_COMPILER_SETTINGS))) ||
     (0 != big_block_set_attr(&bh, "DensityKernel", &dk, "i4", 1)) ||
     (0 != big_block_set_attr(&bh, "HubbleParam", &CP->HubbleParam, "f8", 1)) ) {
         endrun(0, "Failed to write attributes %s\n",
                     big_file_get_error_message());
     }
  
     if(0 != big_block_mpi_close(&bh, MPI_COMM_WORLD)) {
         endrun(0, "Failed to close block %s\n",
                     big_file_get_error_message());
     }
 }

References header_data::BoxSize, Cosmology::CMBTemperature, CP, endrun(), GADGET_COMPILER_SETTINGS, GADGET_VERSION, GetDensityKernelType(), hubble_function(), Cosmology::HubbleParam, IO, header_data::MassTable, header_data::NTotalInit, Cosmology::Omega0, Cosmology::OmegaBaryon, Cosmology::OmegaLambda, header_data::TimeIC, header_data::UnitLength_in_cm, header_data::UnitMass_in_g, header_data::UnitVelocity_in_cm_per_s, and petaio_params::UsePeculiarVelocity.

Referenced by petaio_save_snapshot().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ register_debug_io_blocks()

void register_debug_io_blocks ( struct IOTable * IOTable )

Definition at line 1014 of file petaio.c.

 {
     int ptype;
     for(ptype = 0; ptype < 6; ptype++) {
         IO_REG_WRONLY(GravAccel,       "f4", 3, ptype, IOTable);
         IO_REG_WRONLY(GravPM,       "f4", 3, ptype, IOTable);
         if(!IO.OutputTimebins) /* Otherwise it is output in the regular blocks*/
             IO_REG_WRONLY(TimeBin,       "u4", 1, ptype, IOTable);
     }
     IO_REG_WRONLY(HydroAccel,       "f4", 3, 0, IOTable);
     IO_REG_WRONLY(MaxSignalVel,       "f4", 1, 0, IOTable);
     IO_REG_WRONLY(Entropy,       "f4", 1, 0, IOTable);
     IO_REG_WRONLY(DtEntropy,       "f4", 1, 0, IOTable);
     IO_REG_WRONLY(DhsmlEgyDensityFactor,       "f4", 1, 0, IOTable);
     IO_REG_WRONLY(DivVel,       "f4", 1, 0, IOTable);
     IO_REG_WRONLY(CurlVel,       "f4", 1, 0, IOTable);
     /*Sort IO blocks so similar types are together; then ordered by the sequence they are declared. */
     qsort_openmp(IOTable->ent, IOTable->used, sizeof(struct IOTableEntry), order_by_type);
 }

References IOTable::ent, GravPM, IO, IO_REG_WRONLY, order_by_type(), petaio_params::OutputTimebins, ptype, qsort_openmp, and IOTable::used.

Referenced by dump_snapshot(), and write_checkpoint().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ register_io_blocks()

void register_io_blocks	(	struct IOTable *	IOTable,
		int	WriteGroupID,
		int	MetalReturnOn
	)

Definition at line 909 of file petaio.c.

 {
     int i;
     IOTable->used = 0;
     IOTable->allocated = 100;
     IOTable->ent = (IOTableEntry *) mymalloc2("IOTable", IOTable->allocated * sizeof(IOTableEntry));
     /* Bare Bone Gravity*/
     for(i = 0; i < 6; i ++) {
         /* We put Mass first because sometimes there is
          * corruption in the first array and we can recover from Mass corruption*/
         IO_REG(Mass,     "f4", 1, i, IOTable);
         IO_REG(Position, "f8", 3, i, IOTable);
         IO_REG(Velocity, "f4", 3, i, IOTable);
         IO_REG(ID,       "u8", 1, i, IOTable);
         if(IO.OutputPotential)
             IO_REG_WRONLY(Potential, "f4", 1, i, IOTable);
         if(WriteGroupID)
             IO_REG_WRONLY(GroupID, "u4", 1, i, IOTable);
         if(IO.OutputTimebins)
             IO_REG_WRONLY(TimeBin,       "u4", 1, i, IOTable);
     }
  
     IO_REG(Generation,       "u1", 1, 0, IOTable);
     IO_REG(Generation,       "u1", 1, 4, IOTable);
     IO_REG(Generation,       "u1", 1, 5, IOTable);
     /* Bare Bone SPH*/
     IO_REG(SmoothingLength,  "f4", 1, 0, IOTable);
     IO_REG(Density,          "f4", 1, 0, IOTable);
  
     if(DensityIndependentSphOn())
         IO_REG(EgyWtDensity,          "f4", 1, 0, IOTable);
  
     /* On reload this sets the Entropy variable, need the densities.
      * Register this after Density and EgyWtDensity will ensure density is read
      * before this. */
     IO_REG(InternalEnergy,   "f4", 1, 0, IOTable);
  
     /* Cooling */
     IO_REG(ElectronAbundance,       "f4", 1, 0, IOTable);
     IO_REG_WRONLY(NeutralHydrogenFraction, "f4", 1, 0, IOTable);
  
     if(IO.OutputHeliumFractions) {
         IO_REG_WRONLY(HeliumIFraction, "f4", 1, 0, IOTable);
         IO_REG_WRONLY(HeliumIIFraction, "f4", 1, 0, IOTable);
         IO_REG_WRONLY(HeliumIIIFraction, "f4", 1, 0, IOTable);
     }
     /* Marks whether a particle has been HeIII ionized yet*/
     IO_REG_NONFATAL(HeIIIIonized, "u1", 1, 0, IOTable);
  
     /* SF */
     IO_REG_WRONLY(StarFormationRate, "f4", 1, 0, IOTable);
     /* Another new addition: save the DelayTime for wind particles*/
     IO_REG_NONFATAL(DelayTime,  "f4", 1, 0, IOTable);
  
     IO_REG_NONFATAL(BirthDensity, "f4", 1, 4, IOTable);
     IO_REG_TYPE(StarFormationTime, "f4", 1, 4, IOTable);
     IO_REG_TYPE(Metallicity,       "f4", 1, 0, IOTable);
     IO_REG_TYPE(Metallicity,       "f4", 1, 4, IOTable);
     if(MetalReturnOn) {
         IO_REG_TYPE(Metals,       "f4", NMETALS, 0, IOTable);
         IO_REG_TYPE(Metals,       "f4", NMETALS, 4, IOTable);
         IO_REG_TYPE(LastEnrichmentMyr, "f4", 1, 4, IOTable);
         IO_REG_TYPE(TotalMassReturned, "f4", 1, 4, IOTable);
         IO_REG_NONFATAL(SmoothingLength,  "f4", 1, 4, IOTable);
     }
     /* end SF */
  
     /* Black hole */
     IO_REG_TYPE(StarFormationTime, "f4", 1, 5, IOTable);
     IO_REG(BlackholeMass,          "f4", 1, 5, IOTable);
     IO_REG(BlackholeDensity,          "f4", 1, 5, IOTable);
     IO_REG(BlackholeAccretionRate, "f4", 1, 5, IOTable);
     IO_REG(BlackholeProgenitors,   "i4", 1, 5, IOTable);
     IO_REG(BlackholeMinPotPos, "f8", 3, 5, IOTable);
     IO_REG(BlackholeJumpToMinPot,   "i4", 1, 5, IOTable);
     IO_REG(BlackholeMtrack,         "f4", 1, 5, IOTable);
     IO_REG_NONFATAL(BlackholeMseed,         "f4", 1, 5, IOTable);
     IO_REG_NONFATAL(BlackholeKineticFdbkEnergy, "f4", 1, 5, IOTable);
  
     /* Smoothing lengths for black hole: this is a new addition*/
     IO_REG_NONFATAL(SmoothingLength,  "f4", 1, 5, IOTable);
     /* Marks whether a BH particle has been swallowed*/
     IO_REG_NONFATAL(Swallowed, "u1", 1, 5, IOTable);
     /* ID of the swallowing black hole particle. If == -1, then particle is live*/
     IO_REG_NONFATAL(BlackholeSwallowID, "u8", 1, 5, IOTable);
     /* Time the BH was swallowed*/
     IO_REG_NONFATAL(BlackholeSwallowTime, "f4", 1, 5, IOTable);
  
     /*Sort IO blocks so similar types are together; then ordered by the sequence they are declared. */
     qsort_openmp(IOTable->ent, IOTable->used, sizeof(struct IOTableEntry), order_by_type);
 }

References IOTable::allocated, DensityIndependentSphOn(), IOTable::ent, IO, IO_REG, IO_REG_NONFATAL, IO_REG_TYPE, IO_REG_WRONLY, mymalloc2, NMETALS, order_by_type(), petaio_params::OutputHeliumFractions, petaio_params::OutputPotential, petaio_params::OutputTimebins, qsort_openmp, and IOTable::used.

Referenced by dump_snapshot(), fof_save_particles(), petaio_read_snapshot(), run_gravity_test(), and write_checkpoint().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_petaio_params()

void set_petaio_params ( ParameterSet * ps )

Definition at line 57 of file petaio.c.

 {
     int ThisTask;
     MPI_Comm_rank(MPI_COMM_WORLD, &ThisTask);
     if(ThisTask == 0) {
         IO.BytesPerFile = param_get_int(ps, "BytesPerFile");
         IO.UsePeculiarVelocity = 0; /* Will be set by the Initial Condition File */
         IO.NumWriters = param_get_int(ps, "NumWriters");
         IO.MinNumWriters = param_get_int(ps, "MinNumWriters");
         IO.WritersPerFile = param_get_int(ps, "WritersPerFile");
         IO.AggregatedIOThreshold = param_get_int(ps, "AggregatedIOThreshold");
         IO.EnableAggregatedIO = param_get_int(ps, "EnableAggregatedIO");
         IO.OutputPotential = param_get_int(ps, "OutputPotential");
         IO.OutputTimebins = param_get_int(ps, "OutputTimebins");
         IO.OutputHeliumFractions = param_get_int(ps, "OutputHeliumFractions");
         param_get_string2(ps, "SnapshotFileBase", IO.SnapshotFileBase, sizeof(IO.SnapshotFileBase));
         param_get_string2(ps, "InitCondFile", IO.InitCondFile, sizeof(IO.InitCondFile));
  
     }
     MPI_Bcast(&IO, sizeof(struct petaio_params), MPI_BYTE, 0, MPI_COMM_WORLD);
 }

References petaio_params::AggregatedIOThreshold, petaio_params::BytesPerFile, petaio_params::EnableAggregatedIO, petaio_params::InitCondFile, IO, petaio_params::MinNumWriters, petaio_params::NumWriters, petaio_params::OutputHeliumFractions, petaio_params::OutputPotential, petaio_params::OutputTimebins, param_get_int(), param_get_string2(), petaio_params::SnapshotFileBase, ThisTask, petaio_params::UsePeculiarVelocity, and petaio_params::WritersPerFile.

Referenced by read_parameter_file().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ STHeIIIIonized()

static void STHeIIIIonized	(	int	i,
		unsigned char *	out,
		void *	baseptr,
		void *	smanptr,
		const struct conversions *	params
	)

static

Definition at line 878 of file petaio.c.

                                                                                                                           {
     struct particle_data * part = (struct particle_data *) baseptr;
     part[i].HeIIIionized = *out;
 }

References particle_data::HeIIIionized.

◆ STInternalEnergy()

static void STInternalEnergy	(	int	i,
		float *	out,
		void *	baseptr,
		void *	smanptr,
		const struct conversions *	params
	)

static

Definition at line 863 of file petaio.c.

                                                                                                                     {
     float u = *out;
     int PI = ((struct particle_data *) baseptr)[i].PI;
     struct slot_info * info = &(((struct slots_manager_type *) smanptr)->info[0]);
     struct sph_particle_data * sl = (struct sph_particle_data *) info->ptr;
     double a3inv = 1/(params->atime * params->atime * params->atime);
     sl[PI].Entropy  = GAMMA_MINUS1 * u / pow(sl[PI].Density * a3inv, GAMMA_MINUS1);
 }

References conversions::atime, sph_particle_data::Density, sph_particle_data::Entropy, GAMMA_MINUS1, and slot_info::ptr.

◆ STPosition()

static void STPosition	(	int	i,
		double *	out,
		void *	baseptr,
		void *	smanptr,
		const struct conversions *	params
	)

static

Definition at line 696 of file petaio.c.

                                                                                                                {
     int d;
     struct particle_data * part = (struct particle_data *) baseptr;
     for(d = 0; d < 3; d ++) {
         part[i].Pos[d] = out[d];
     }
 }

References particle_data::Pos.

◆ STSwallowed()

static void STSwallowed	(	int	i,
		unsigned char *	out,
		void *	baseptr,
		void *	smanptr,
		const struct conversions *	params
	)

static

Definition at line 887 of file petaio.c.

                                                                                                                        {
     struct particle_data * part = (struct particle_data *) baseptr;
     part[i].Swallowed = *out;
 }

References particle_data::Swallowed.

◆ STVelocity()

static void STVelocity	(	int	i,
		float *	out,
		void *	baseptr,
		void *	smanptr,
		const struct conversions *	params
	)

static

Definition at line 759 of file petaio.c.

                                                                                                               {
     double fac;
     struct particle_data * part = (struct particle_data *) baseptr;
     if (IO.UsePeculiarVelocity) {
         fac = params->atime;
     } else {
         fac = 1.0;
     }
  
     int d;
     for(d = 0; d < 3; d ++) {
         part[i].Vel[d] = out[d] * fac;
     }
 }

References conversions::atime, IO, petaio_params::UsePeculiarVelocity, and particle_data::Vel.

Variable Documentation

◆ Header

struct header_data Header

static

Definition at line 1 of file petaio.c.

Referenced by petaio_read_header_internal(), and petaio_save_snapshot().

◆ IO

struct petaio_params IO

static

Referenced by GetUsePeculiarVelocity(), GTVelocity(), petaio_get_snapshot_fname(), petaio_init(), petaio_read_block(), petaio_read_header_internal(), petaio_read_snapshot(), petaio_save_block(), petaio_write_header(), register_debug_io_blocks(), register_io_blocks(), set_petaio_params(), and STVelocity().

Classes

Macros

Functions

Variables

Macro Definition Documentation

◆ SIMPLE_GETTER_PI

◆ SIMPLE_PROPERTY

◆ SIMPLE_PROPERTY_PI

◆ SIMPLE_PROPERTY_TYPE

◆ SIMPLE_PROPERTY_TYPE_PI

◆ SIMPLE_SETTER_PI

Function Documentation

◆ _get_attr_double()

◆ _get_attr_int()

◆ destroy_io_blocks()

◆ GetUsePeculiarVelocity()

◆ GTBlackholeMinPotPos()

◆ GTHeIIIIonized()

◆ GTHeliumIFraction()

◆ GTHeliumIIFraction()

◆ GTHeliumIIIFraction()

◆ GTInternalEnergy()

◆ GTNeutralHydrogenFraction()

◆ GTPosition()

◆ GTSwallowed()

◆ GTVelocity()

◆ io_register_io_block()

◆ order_by_type()

◆ petaio_alloc_buffer()

◆ petaio_build_buffer()

◆ petaio_build_selection()

◆ petaio_destroy_buffer()

◆ petaio_get_snapshot_fname()

◆ petaio_init()

◆ petaio_read_block()

◆ petaio_read_header()

◆ petaio_read_header_internal()

◆ petaio_read_snapshot()

◆ petaio_readout_buffer()

◆ petaio_save_block()

◆ petaio_save_snapshot()

◆ petaio_write_header()

◆ register_debug_io_blocks()

◆ register_io_blocks()

◆ set_petaio_params()

◆ STHeIIIIonized()

◆ STInternalEnergy()

◆ STPosition()

◆ STSwallowed()

◆ STVelocity()

Variable Documentation

◆ Header

◆ IO