petaio.h File Reference

#include <mpi.h>
#include "bigfile.h"
#include "utils/paramset.h"
#include "partmanager.h"
#include "slotsmanager.h"
#include "cosmology.h"
#include "physconst.h"

Include dependency graph for petaio.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	header_data
struct	conversions
struct	IOTableEntry
struct	IOTable

Macros
#define	PTYPE_FOF_GROUP   1024
#define	IO_REG(name, dtype, items, ptype, IOTable)    io_register_io_block(# name, dtype, items, ptype, (property_getter) GT ## name , (property_setter) ST ## name, 1, IOTable)
#define	IO_REG_TYPE(name, dtype, items, ptype, IOTable)    io_register_io_block(# name, dtype, items, ptype, (property_getter) GT ## ptype ## name , (property_setter) ST ## ptype ## name, 0, IOTable)
#define	IO_REG_WRONLY(name, dtype, items, ptype, IOTable)    io_register_io_block(# name, dtype, items, ptype, (property_getter) GT ## name , NULL, 1, IOTable)
#define	IO_REG_NONFATAL(name, dtype, items, ptype, IOTable)    io_register_io_block(# name, dtype, items, ptype, (property_getter) GT ## name , (property_setter) ST ## name, 0, IOTable)
#define	SIMPLE_GETTER(name, field, type, items, stype)
#define	SIMPLE_SETTER(name, field, type, items, stype)

Typedefs
typedef void(*	property_getter) (int i, void *result, void *baseptr, void *slotptr, const struct conversions *params)
typedef void(*	property_setter) (int i, void *target, void *baseptr, void *slotptr, const struct conversions *params)
typedef int(*	petaio_selection) (int i)
typedef struct IOTableEntry	IOTableEntry

Functions
char *	petaio_get_snapshot_fname (int num, const char *OutputDir)
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)
void	set_petaio_params (ParameterSet *ps)
int	GetUsePeculiarVelocity (void)
void	petaio_init ()
void	petaio_alloc_buffer (BigArray *array, IOTableEntry *ent, int64_t npartLocal)
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_readout_buffer (BigArray *array, IOTableEntry *ent, struct conversions *conv, struct part_manager_type *PartManager, struct slots_manager_type *SlotsManager)
void	petaio_destroy_buffer (BigArray *array)
void	petaio_save_block (BigFile *bf, const char *blockname, BigArray *array, int verbose)
int	petaio_read_block (BigFile *bf, const char *blockname, BigArray *array, int required)
void	petaio_save_snapshot (const char *fname, struct IOTable *IOTable, int verbose, const double atime, const 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)
struct header_data	petaio_read_header (int num, const char *OutputDir, Cosmology *CP)
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	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)

Macro Definition Documentation

IO_REG

#define IO_REG	(		name,
			dtype,
			items,
			ptype,
			IOTable
	)		io_register_io_block(# name, dtype, items, ptype, (property_getter) GT ## name , (property_setter) ST ## name, 1, IOTable)

Definition at line 113 of file petaio.h.

IO_REG_NONFATAL

#define IO_REG_NONFATAL	(		name,
			dtype,
			items,
			ptype,
			IOTable
	)		io_register_io_block(# name, dtype, items, ptype, (property_getter) GT ## name , (property_setter) ST ## name, 0, IOTable)

Definition at line 119 of file petaio.h.

IO_REG_TYPE

#define IO_REG_TYPE	(		name,
			dtype,
			items,
			ptype,
			IOTable
	)		io_register_io_block(# name, dtype, items, ptype, (property_getter) GT ## ptype ## name , (property_setter) ST ## ptype ## name, 0, IOTable)

Definition at line 115 of file petaio.h.

IO_REG_WRONLY

#define IO_REG_WRONLY	(		name,
			dtype,
			items,
			ptype,
			IOTable
	)		io_register_io_block(# name, dtype, items, ptype, (property_getter) GT ## name , NULL, 1, IOTable)

Definition at line 117 of file petaio.h.

PTYPE_FOF_GROUP

#define PTYPE_FOF_GROUP   1024

Definition at line 66 of file petaio.h.

SIMPLE_GETTER

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

Value:

static void name(int i, type * out, void * baseptr, void * slotptr, const struct conversions * params) { \
    int k; \
    for(k = 0; k < items; k ++) { \
        out[k] = *(&(((stype *)baseptr)[i].field) + k); \
    } \
}

Definition at line 145 of file petaio.h.

SIMPLE_SETTER

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

Value:

static void name(int i, type * out, void * baseptr, void * slotptr, const struct conversions * params) { \
    int k; \
    for(k = 0; k < items; k ++) { \
        *(&(((stype *)baseptr)[i].field) + k) = out[k]; \
    } \
}

Definition at line 152 of file petaio.h.

Typedef Documentation

IOTableEntry

typedef struct IOTableEntry IOTableEntry

petaio_selection

typedef int(* petaio_selection) (int i)

Definition at line 47 of file petaio.h.

property_getter

typedef void(* property_getter) (int i, void *result, void *baseptr, void *slotptr, const struct conversions *params)

Definition at line 45 of file petaio.h.

property_setter

typedef void(* property_setter) (int i, void *target, void *baseptr, void *slotptr, const struct conversions *params)

Definition at line 46 of file petaio.h.

Function Documentation

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:

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.

petaio_alloc_buffer()

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

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

(

)

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_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:

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: