diff --git a/src/logger.c b/src/logger.c
index 2f4b0593dac039db96375afcee258a25dd871549..8be521b27f949ea0d496a5207335f1ec68208489 100644
--- a/src/logger.c
+++ b/src/logger.c
@@ -25,6 +25,7 @@
/* Some standard headers. */
#include <hdf5.h>
+#include <math.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
@@ -40,28 +41,49 @@
#include "part.h"
#include "units.h"
-/* header constants
+/*
* Thoses are definitions from the format and therefore should not be changed!
- * Size in bytes
*/
-/* size of a mask */
+/* number of bytes for a mask */
+// TODO change this to number of bits
#define logger_mask_size 1
-/* size of an offset */
-#define logger_offset_size 7
+/* number of bits for chunk header */
+#define logger_header_bytes 8
-/* size of the version information */
+/* number bytes for an offset */
+#define logger_offset_size logger_header_bytes - logger_mask_size
+
+/* number of bytes for the version information */
#define logger_version_size 20
-/* size of the size information */
-#define logger_header_number_size 2
+/* number of bytes for the labels in the header */
+#define logger_label_size 20
+
+/* number of bytes for the number in the header */
+#define logger_number_size 4
char logger_version[logger_version_size] = "0.1";
-const unsigned int logger_datatype_size[logger_data_count] = {
- sizeof(int), sizeof(float), sizeof(double),
- sizeof(char), sizeof(long long), 1,
-};
+const struct mask_data logger_mask_data[logger_count_mask] = {
+ /* Particle's position */
+ {3 * sizeof(double), 1 << logger_x, "positions"},
+ /* Particle's velocity */
+ {3 * sizeof(float), 1 << logger_v, "velocities"},
+ /* Particle's acceleration */
+ {3 * sizeof(float), 1 << logger_a, "accelerations"},
+ /* Particle's entropy */
+ {sizeof(float), 1 << logger_u, "entropy"},
+ /* Particle's smoothing length */
+ {sizeof(float), 1 << logger_h, "smoothing length"},
+ /* Particle's density */
+ {sizeof(float), 1 << logger_rho, "density"},
+ /* Particle's constants: mass (float) and ID (long long) */
+ {sizeof(float) + sizeof(long long), 1 << logger_consts, "consts"},
+ /* Simulation time stamp: integertime and double time (e.g. scale
+ factor or time) */
+ {sizeof(integertime_t) + sizeof(double), 1 << logger_timestamp,
+ "timestamp"}};
/**
* @brief Write the header of a chunk (offset + mask).
@@ -104,39 +126,8 @@ void logger_write_data(struct dump *d, size_t *offset, size_t size,
/* write data to the buffer */
memcpy(buff, p, size);
-}
-
-/**
- * @brief Write a parameter to the file
- *
- * TODO Make it thread safe or remove it.
- *
- * write data in the following order: name, data type, data.
- * It should be used only for the file header.
- *
- * @param d #dump file
- * @param params #logger_parameters file format informations
- * @param offset (return) offset of the next chunk
- * @param p pointer to the data
- * @param name Label of the parameter (should be smaller than log->name)
- * @param data_type #logger_datatype to write
- */
-void logger_write_general_data(struct dump *d,
- const struct logger_parameters *params,
- size_t *offset, const void *p, char *name,
- size_t data_type) {
- /* write name */
- logger_write_data(d, offset, params->label_size, name);
-
- /* write data type */
- logger_write_data(d, offset, params->data_type_size, &data_type);
-
- /* write value */
- if (data_type >= logger_data_count) error("Not implemented");
- size_t size = logger_datatype_size[data_type];
-
- logger_write_data(d, offset, size, p);
+ /* Update offset to end of chunk */
*offset += size;
}
@@ -153,40 +144,21 @@ int logger_compute_chunk_size(unsigned int mask) {
int size = logger_mask_size + logger_offset_size;
/* Is this a particle or a timestep? */
- if (mask & logger_mask_timestamp) {
+ if (mask & logger_mask_data[logger_timestamp].mask) {
/* The timestamp should not contain any other bits. */
- if (mask != logger_mask_timestamp)
+ if (mask != logger_mask_data[logger_timestamp].mask)
error("Timestamps should not include any other data.");
/* A timestamp consists of an unsigned long long int. */
- size += sizeof(unsigned long long int);
- size += sizeof(double);
+ size += logger_mask_data[logger_timestamp].size;
} else {
- /* Particle position as three doubles. */
- if (mask & logger_mask_x) size += 3 * sizeof(double);
-
- /* Particle velocity as three floats. */
- if (mask & logger_mask_v) size += 3 * sizeof(float);
-
- /* Particle accelleration as three floats. */
- if (mask & logger_mask_a) size += 3 * sizeof(float);
-
- /* Particle internal energy as a single float. */
- if (mask & logger_mask_u) size += sizeof(float);
-
- /* Particle smoothing length as a single float. */
- if (mask & logger_mask_h) size += sizeof(float);
-
- /* Particle density as a single float. */
- if (mask & logger_mask_rho) size += sizeof(float);
-
- /* Particle constants, which is a bit more complicated. */
- if (mask & logger_mask_rho) {
- size += sizeof(float) + // mass
- sizeof(long long); // id
+ for (int i = 0; i < logger_count_mask; i++) {
+ if (mask & logger_mask_data[i].mask) {
+ size += logger_mask_data[i].size;
+ }
}
}
@@ -209,9 +181,11 @@ void logger_log_all(struct logger *log, const struct engine *e) {
/* some constants */
const struct space *s = e->s;
- const unsigned int mask = logger_mask_x | logger_mask_v | logger_mask_a |
- logger_mask_u | logger_mask_h | logger_mask_rho |
- logger_mask_consts;
+ const unsigned int mask =
+ logger_mask_data[logger_x].mask | logger_mask_data[logger_v].mask |
+ logger_mask_data[logger_a].mask | logger_mask_data[logger_u].mask |
+ logger_mask_data[logger_h].mask | logger_mask_data[logger_rho].mask |
+ logger_mask_data[logger_consts].mask;
/* loop over all parts */
for (long long i = 0; i < e->total_nr_parts; i++) {
@@ -240,7 +214,7 @@ void logger_log_part(struct logger *log, const struct part *p,
unsigned int mask, size_t *offset) {
/* Make sure we're not writing a timestamp. */
- if (mask & logger_mask_timestamp)
+ if (mask & logger_mask_data[logger_timestamp].mask)
error("You should not log particles as timestamps.");
/* Start by computing the size of the message. */
@@ -248,51 +222,52 @@ void logger_log_part(struct logger *log, const struct part *p,
/* Allocate a chunk of memory in the dump of the right size. */
size_t offset_new;
- char *buff = (char *)dump_get(log->dump, size, &offset_new);
+ char *buff = (char *)dump_get(&log->dump, size, &offset_new);
/* Write the header. */
buff = logger_write_chunk_header(buff, &mask, offset, offset_new);
/* Particle position as three doubles. */
- if (mask & logger_mask_x) {
- memcpy(buff, p->x, 3 * sizeof(double));
- buff += 3 * sizeof(double);
+ if (mask & logger_mask_data[logger_x].mask) {
+ memcpy(buff, p->x, logger_mask_data[logger_x].size);
+ buff += logger_mask_data[logger_x].size;
}
/* Particle velocity as three floats. */
- if (mask & logger_mask_v) {
- memcpy(buff, p->v, 3 * sizeof(float));
- buff += 3 * sizeof(float);
+ if (mask & logger_mask_data[logger_v].mask) {
+ memcpy(buff, p->v, logger_mask_data[logger_v].size);
+ buff += logger_mask_data[logger_v].size;
}
/* Particle accelleration as three floats. */
- if (mask & logger_mask_a) {
- memcpy(buff, p->a_hydro, 3 * sizeof(float));
- buff += 3 * sizeof(float);
+ if (mask & logger_mask_data[logger_a].mask) {
+ memcpy(buff, p->a_hydro, logger_mask_data[logger_a].size);
+ buff += logger_mask_data[logger_a].size;
}
#if defined(GADGET2_SPH)
/* Particle internal energy as a single float. */
- if (mask & logger_mask_u) {
- memcpy(buff, &p->entropy, sizeof(float));
- buff += sizeof(float);
+ if (mask & logger_mask_data[logger_u].mask) {
+ memcpy(buff, &p->entropy, logger_mask_data[logger_u].size);
+ buff += logger_mask_data[logger_u].size;
}
/* Particle smoothing length as a single float. */
- if (mask & logger_mask_h) {
- memcpy(buff, &p->h, sizeof(float));
- buff += sizeof(float);
+ if (mask & logger_mask_data[logger_h].mask) {
+ memcpy(buff, &p->h, logger_mask_data[logger_h].size);
+ buff += logger_mask_data[logger_h].size;
}
/* Particle density as a single float. */
- if (mask & logger_mask_rho) {
- memcpy(buff, &p->rho, sizeof(float));
- buff += sizeof(float);
+ if (mask & logger_mask_data[logger_rho].mask) {
+ memcpy(buff, &p->rho, logger_mask_data[logger_rho].size);
+ buff += logger_mask_data[logger_rho].size;
}
/* Particle constants, which is a bit more complicated. */
- if (mask & logger_mask_consts) {
+ if (mask & logger_mask_data[logger_consts].mask) {
+ // TODO make it dependent of logger_mask_data
memcpy(buff, &p->mass, sizeof(float));
buff += sizeof(float);
memcpy(buff, &p->id, sizeof(long long));
@@ -318,11 +293,12 @@ void logger_log_gpart(struct logger *log, const struct gpart *p,
unsigned int mask, size_t *offset) {
/* Make sure we're not writing a timestamp. */
- if (mask & logger_mask_timestamp)
+ if (mask & logger_mask_data[logger_timestamp].mask)
error("You should not log particles as timestamps.");
/* Make sure we're not looging fields not supported by gparts. */
- if (mask & (logger_mask_u | logger_mask_rho))
+ if (mask &
+ (logger_mask_data[logger_u].mask | logger_mask_data[logger_rho].mask))
error("Can't log SPH quantities for gparts.");
/* Start by computing the size of the message. */
@@ -330,31 +306,32 @@ void logger_log_gpart(struct logger *log, const struct gpart *p,
/* Allocate a chunk of memory in the dump of the right size. */
size_t offset_new;
- char *buff = (char *)dump_get(log->dump, size, &offset_new);
+ char *buff = (char *)dump_get(&log->dump, size, &offset_new);
/* Write the header. */
buff = logger_write_chunk_header(buff, &mask, offset, offset_new);
/* Particle position as three doubles. */
- if (mask & logger_mask_x) {
- memcpy(buff, p->x, 3 * sizeof(double));
- buff += 3 * sizeof(double);
+ if (mask & logger_mask_data[logger_x].mask) {
+ memcpy(buff, p->x, logger_mask_data[logger_x].size);
+ buff += logger_mask_data[logger_x].size;
}
/* Particle velocity as three floats. */
- if (mask & logger_mask_v) {
- memcpy(buff, p->v_full, 3 * sizeof(float));
- buff += 3 * sizeof(float);
+ if (mask & logger_mask_data[logger_v].mask) {
+ memcpy(buff, p->v_full, logger_mask_data[logger_v].size);
+ buff += logger_mask_data[logger_v].size;
}
/* Particle accelleration as three floats. */
- if (mask & logger_mask_a) {
- memcpy(buff, p->a_grav, 3 * sizeof(float));
- buff += 3 * sizeof(float);
+ if (mask & logger_mask_data[logger_a].mask) {
+ memcpy(buff, p->a_grav, logger_mask_data[logger_a].size);
+ buff += logger_mask_data[logger_a].size;
}
/* Particle constants, which is a bit more complicated. */
- if (mask & logger_mask_consts) {
+ if (mask & logger_mask_data[logger_consts].mask) {
+ // TODO make it dependent of logger_mask_data
memcpy(buff, &p->mass, sizeof(float));
buff += sizeof(float);
memcpy(buff, &p->id_or_neg_offset, sizeof(long long));
@@ -376,20 +353,22 @@ void logger_log_gpart(struct logger *log, const struct gpart *p,
*/
void logger_log_timestamp(struct logger *log, integertime_t timestamp,
double time, size_t *offset) {
- struct dump *dump = log->dump;
+ struct dump *dump = &log->dump;
/* Start by computing the size of the message. */
- const int size = logger_compute_chunk_size(logger_mask_timestamp);
+ const int size =
+ logger_compute_chunk_size(logger_mask_data[logger_timestamp].mask);
/* Allocate a chunk of memory in the dump of the right size. */
size_t offset_new;
char *buff = (char *)dump_get(dump, size, &offset_new);
/* Write the header. */
- unsigned int mask = logger_mask_timestamp;
+ unsigned int mask = logger_mask_data[logger_timestamp].mask;
buff = logger_write_chunk_header(buff, &mask, offset, offset_new);
/* Store the timestamp. */
+ // TODO make it dependent of logger_mask_data
memcpy(buff, ×tamp, sizeof(integertime_t));
buff += sizeof(integertime_t);
@@ -414,10 +393,8 @@ void logger_log_timestamp(struct logger *log, integertime_t timestamp,
void logger_ensure_size(struct logger *log, size_t total_nr_parts,
size_t total_nr_gparts, size_t total_nr_sparts) {
- struct logger_parameters *log_params = log->params;
-
/* count part memory */
- size_t limit = log_params->total_size;
+ size_t limit = log->max_chunk_size;
limit *= total_nr_parts;
@@ -428,7 +405,7 @@ void logger_ensure_size(struct logger *log, size_t total_nr_parts,
if (total_nr_sparts > 0) error("Not implemented");
/* ensure enough space in dump */
- dump_ensure(log->dump, limit, log->buffer_scale * limit);
+ dump_ensure(&log->dump, limit, log->buffer_scale * limit);
}
/**
@@ -455,16 +432,17 @@ void logger_init(struct logger *log, struct swift_params *params) {
strcpy(logger_name_file, log->base_name);
strcat(logger_name_file, ".dump");
- /* init parameters */
- log->params =
- (struct logger_parameters *)malloc(sizeof(struct logger_parameters));
- logger_parameters_init(log->params);
+ /* Compute max size for a particle chunk */
+ int max_size = logger_offset_size + logger_mask_size;
- /* init dump */
- log->dump = malloc(sizeof(struct dump));
- struct dump *dump_file = log->dump;
+ /* Loop over all fields except timestamp */
+ for (int i = 0; i < logger_count_mask - 1; i++) {
+ max_size += logger_mask_data[i].size;
+ }
+ log->max_chunk_size = max_size;
- dump_init(dump_file, logger_name_file, buffer_size);
+ /* init dump */
+ dump_init(&log->dump, logger_name_file, buffer_size);
}
/**
@@ -472,11 +450,7 @@ void logger_init(struct logger *log, struct swift_params *params) {
*
* @param log The #logger
*/
-void logger_clean(struct logger *log) {
- dump_close(log->dump);
- logger_parameters_clean(log->params);
- free(log->params);
-}
+void logger_clean(struct logger *log) { dump_close(&log->dump); }
/**
* @brief Write a file header to a logger file
@@ -488,8 +462,7 @@ void logger_clean(struct logger *log) {
void logger_write_file_header(struct logger *log, const struct engine *e) {
/* get required variables */
- const struct logger_parameters log_params = *log->params;
- struct dump *dump = log->dump;
+ struct dump *dump = &log->dump;
size_t file_offset = dump->file_offset;
@@ -501,167 +474,35 @@ void logger_write_file_header(struct logger *log, const struct engine *e) {
/* Write version information */
logger_write_data(dump, &file_offset, logger_version_size, &logger_version);
- /* write number of bytes used for the offsets */
- logger_write_data(dump, &file_offset, logger_header_number_size,
- &log_params.offset_size);
-
/* write offset direction */
- int reversed = 0;
- logger_write_data(dump, &file_offset, logger_datatype_size[logger_data_bool],
- &reversed);
+ const int reversed = 0;
+ logger_write_data(dump, &file_offset, logger_number_size, &reversed);
/* placeholder to write the offset of the first log here */
- char *skip_header = dump_get(dump, log_params.offset_size, &file_offset);
+ char *skip_header = dump_get(dump, logger_offset_size, &file_offset);
/* write number of bytes used for names */
- logger_write_data(dump, &file_offset, logger_header_number_size,
- &log_params.label_size);
-
- /* write number of bytes used for numbers */
- logger_write_data(dump, &file_offset, logger_header_number_size,
- &log_params.number_size);
-
- /* write number of bytes used for masks */
- logger_write_data(dump, &file_offset, logger_header_number_size,
- &log_params.mask_size);
+ const int label_size = logger_label_size;
+ logger_write_data(dump, &file_offset, logger_number_size, &label_size);
/* write number of masks */
- logger_write_data(dump, &file_offset, log_params.number_size,
- &log_params.number_mask);
+ int count_mask = logger_count_mask;
+ logger_write_data(dump, &file_offset, logger_number_size, &count_mask);
/* write masks */
// loop over all mask type
- for (size_t i = 0; i < log_params.number_mask; i++) {
+ for (int i = 0; i < logger_count_mask; i++) {
// mask name
- size_t j = i * log_params.label_size;
- logger_write_data(dump, &file_offset, log_params.label_size,
- &log_params.masks_name[j]);
-
- // mask
- logger_write_data(dump, &file_offset, log_params.mask_size,
- &log_params.masks[i]);
+ logger_write_data(dump, &file_offset, logger_label_size,
+ &logger_mask_data[i].name);
// mask size
- logger_write_data(dump, &file_offset, log_params.number_size,
- &log_params.masks_data_size[i]);
+ logger_write_data(dump, &file_offset, logger_number_size,
+ &logger_mask_data[i].size);
}
- /* write mask data */
- // TODO
- /* loop over each mask and each data in this mask */
- /* write number of bytes for each field */
- /* write data type (float, double, ...) */
- /* write data name (mass, id, ...) */
-
- /* Write data */
- char *name = malloc(sizeof(char) * log_params.label_size);
- strcpy(name, "time_base");
- logger_write_general_data(dump, &log_params, &file_offset, &e->time_base,
- name, logger_data_double);
-
/* last step: write first offset */
- memcpy(skip_header, &file_offset, log_params.offset_size);
-
- /* free memory */
- free(name);
-}
-
-/**
- * @brief initialize the #logger_parameters with the format informations
- *
- * @param log_params #logger_parameters to initialize
- */
-void logger_parameters_init(struct logger_parameters *log_params) {
- /* set parameters */
- log_params->label_size = 20;
- log_params->offset_size = 7;
- log_params->mask_size = 1;
- log_params->number_size = 1;
- log_params->data_type_size = 1;
-
- log_params->number_mask = 8;
-
- /* set masks array */
- log_params->masks = malloc(sizeof(size_t) * log_params->number_mask);
- log_params->masks[0] = logger_mask_x;
- log_params->masks[1] = logger_mask_v;
- log_params->masks[2] = logger_mask_a;
- log_params->masks[3] = logger_mask_u;
- log_params->masks[4] = logger_mask_h;
- log_params->masks[5] = logger_mask_rho;
- log_params->masks[6] = logger_mask_consts;
- log_params->masks[7] = logger_mask_timestamp;
-
- /* set the mask names */
- size_t block_size = log_params->label_size * log_params->number_mask;
- log_params->masks_name = malloc(block_size);
- char *cur_name = log_params->masks_name;
-
- char tmp[log_params->label_size];
- strcpy(tmp, "position");
- memcpy(cur_name, &tmp, log_params->label_size);
- cur_name += log_params->label_size;
-
- strcpy(tmp, "velocity");
- memcpy(cur_name, &tmp, log_params->label_size);
- cur_name += log_params->label_size;
-
- strcpy(tmp, "acceleration");
- memcpy(cur_name, &tmp, log_params->label_size);
- cur_name += log_params->label_size;
-
- strcpy(tmp, "entropy");
- memcpy(cur_name, &tmp, log_params->label_size);
- cur_name += log_params->label_size;
-
- strcpy(tmp, "cutoff radius");
- memcpy(cur_name, &tmp, log_params->label_size);
- cur_name += log_params->label_size;
-
- strcpy(tmp, "density");
- memcpy(cur_name, &tmp, log_params->label_size);
- cur_name += log_params->label_size;
-
- strcpy(tmp, "consts");
- memcpy(cur_name, &tmp, log_params->label_size);
- cur_name += log_params->label_size;
-
- strcpy(tmp, "timestamp");
- memcpy(cur_name, &tmp, log_params->label_size);
- cur_name += log_params->label_size;
-
- /* set the data size */
- log_params->masks_data_size =
- malloc(sizeof(size_t) * log_params->number_mask);
- log_params->masks_data_size[0] = 3 * sizeof(double);
- log_params->masks_data_size[1] = 3 * sizeof(float);
- log_params->masks_data_size[2] = 3 * sizeof(float);
- log_params->masks_data_size[3] = sizeof(float);
- log_params->masks_data_size[4] = sizeof(float);
- log_params->masks_data_size[5] = sizeof(float);
- log_params->masks_data_size[6] = sizeof(float) + sizeof(long long);
- log_params->masks_data_size[7] = sizeof(integertime_t) + sizeof(double);
-
- /* Compute the size of a chunk if all the mask are activated */
- log_params->total_size = logger_offset_size + logger_mask_size;
-
- for (size_t i = 0; i < log_params->number_mask; i++) {
- if (log_params->masks[i] != logger_mask_timestamp)
- log_params->total_size += log_params->masks_data_size[i];
- }
-
- // todo masks_type
-}
-
-/**
- * @brief Clean the #logger_parameters
- *
- * @param log_params The #logger_parameters
- */
-void logger_parameters_clean(struct logger_parameters *log_params) {
- free(log_params->masks);
- free(log_params->masks_name);
- free(log_params->masks_data_size);
+ memcpy(skip_header, &file_offset, logger_offset_size);
}
/**
@@ -707,49 +548,50 @@ int logger_read_part(struct part *p, size_t *offset, const char *buff) {
buff += logger_read_chunk_header(buff, &mask, offset, cur_offset);
/* We are only interested in particle data. */
- if (mask & logger_mask_timestamp)
+ if (mask & logger_mask_data[logger_timestamp].mask)
error("Trying to read timestamp as particle.");
/* Particle position as three doubles. */
- if (mask & logger_mask_x) {
- memcpy(p->x, buff, 3 * sizeof(double));
- buff += 3 * sizeof(double);
+ if (mask & logger_mask_data[logger_x].mask) {
+ memcpy(p->x, buff, logger_mask_data[logger_x].size);
+ buff += logger_mask_data[logger_x].size;
}
/* Particle velocity as three floats. */
- if (mask & logger_mask_v) {
- memcpy(p->v, buff, 3 * sizeof(float));
- buff += 3 * sizeof(float);
+ if (mask & logger_mask_data[logger_v].mask) {
+ memcpy(p->v, buff, logger_mask_data[logger_v].size);
+ buff += logger_mask_data[logger_v].size;
}
/* Particle accelleration as three floats. */
- if (mask & logger_mask_a) {
- memcpy(p->a_hydro, buff, 3 * sizeof(float));
- buff += 3 * sizeof(float);
+ if (mask & logger_mask_data[logger_a].mask) {
+ memcpy(p->a_hydro, buff, logger_mask_data[logger_a].size);
+ buff += logger_mask_data[logger_a].size;
}
#if defined(GADGET2_SPH)
/* Particle internal energy as a single float. */
- if (mask & logger_mask_u) {
- memcpy(&p->entropy, buff, sizeof(float));
- buff += sizeof(float);
+ if (mask & logger_mask_data[logger_u].mask) {
+ memcpy(&p->entropy, buff, logger_mask_data[logger_u].size);
+ buff += logger_mask_data[logger_u].size;
}
/* Particle smoothing length as a single float. */
- if (mask & logger_mask_h) {
- memcpy(&p->h, buff, sizeof(float));
- buff += sizeof(float);
+ if (mask & logger_mask_data[logger_h].mask) {
+ memcpy(&p->h, buff, logger_mask_data[logger_h].size);
+ buff += logger_mask_data[logger_h].size;
}
/* Particle density as a single float. */
- if (mask & logger_mask_rho) {
- memcpy(&p->rho, buff, sizeof(float));
- buff += sizeof(float);
+ if (mask & logger_mask_data[logger_rho].mask) {
+ memcpy(&p->rho, buff, logger_mask_data[logger_rho].size);
+ buff += logger_mask_data[logger_rho].size;
}
/* Particle constants, which is a bit more complicated. */
- if (mask & logger_mask_rho) {
+ if (mask & logger_mask_data[logger_rho].mask) {
+ // TODO make it dependent of logger_mask_data
memcpy(&p->mass, buff, sizeof(float));
buff += sizeof(float);
memcpy(&p->id, buff, sizeof(long long));
@@ -783,33 +625,35 @@ int logger_read_gpart(struct gpart *p, size_t *offset, const char *buff) {
buff += logger_read_chunk_header(buff, &mask, offset, cur_offset);
/* We are only interested in particle data. */
- if (mask & logger_mask_timestamp)
+ if (mask & logger_mask_data[logger_timestamp].mask)
error("Trying to read timestamp as particle.");
/* We can't store all part fields in a gpart. */
- if (mask & (logger_mask_u | logger_mask_rho))
+ if (mask &
+ (logger_mask_data[logger_u].mask | logger_mask_data[logger_rho].mask))
error("Trying to read SPH quantities into a gpart.");
/* Particle position as three doubles. */
- if (mask & logger_mask_x) {
- memcpy(p->x, buff, 3 * sizeof(double));
- buff += 3 * sizeof(double);
+ if (mask & logger_mask_data[logger_x].mask) {
+ memcpy(p->x, buff, logger_mask_data[logger_x].size);
+ buff += logger_mask_data[logger_x].size;
}
/* Particle velocity as three floats. */
- if (mask & logger_mask_v) {
- memcpy(p->v_full, buff, 3 * sizeof(float));
- buff += 3 * sizeof(float);
+ if (mask & logger_mask_data[logger_v].mask) {
+ memcpy(p->v_full, buff, logger_mask_data[logger_v].size);
+ buff += logger_mask_data[logger_v].size;
}
/* Particle accelleration as three floats. */
- if (mask & logger_mask_a) {
- memcpy(p->a_grav, buff, 3 * sizeof(float));
- buff += 3 * sizeof(float);
+ if (mask & logger_mask_data[logger_a].mask) {
+ memcpy(p->a_grav, buff, logger_mask_data[logger_a].size);
+ buff += logger_mask_data[logger_a].size;
}
/* Particle constants, which is a bit more complicated. */
- if (mask & logger_mask_rho) {
+ if (mask & logger_mask_data[logger_rho].mask) {
+ // TODO make it dependent of logger_mask_data
memcpy(&p->mass, buff, sizeof(float));
buff += sizeof(float);
memcpy(&p->id_or_neg_offset, buff, sizeof(long long));
@@ -842,14 +686,15 @@ int logger_read_timestamp(unsigned long long int *t, double *time,
buff += logger_read_chunk_header(buff, &mask, offset, cur_offset);
/* We are only interested in timestamps. */
- if (!(mask & logger_mask_timestamp))
+ if (!(mask & logger_mask_data[logger_timestamp].mask))
error("Trying to read timestamp from a particle.");
/* Make sure we don't have extra fields. */
- if (mask != logger_mask_timestamp)
+ if (mask != logger_mask_data[logger_timestamp].mask)
error("Timestamp message contains extra fields.");
/* Copy the timestamp value from the buffer. */
+ // TODO make it dependent of logger_mask_data
memcpy(t, buff, sizeof(unsigned long long int));
buff += sizeof(unsigned long long int);
diff --git a/src/logger.h b/src/logger.h
index 3ac5291eaab1f0e4fc05640cc23e1705a7178c9a..56e2c8ab94c66b24df1800877bb9cfb129c3e645 100644
--- a/src/logger.h
+++ b/src/logger.h
@@ -23,6 +23,7 @@
/* Includes. */
#include "common_io.h"
+#include "dump.h"
#include "inline.h"
#include "timeline.h"
#include "units.h"
@@ -73,53 +74,32 @@ struct engine;
*/
/* Some constants. */
-enum logger_masks {
- logger_mask_x = (1 << 0),
- logger_mask_v = (1 << 1),
- logger_mask_a = (1 << 2),
- logger_mask_u = (1 << 3),
- logger_mask_h = (1 << 4),
- logger_mask_rho = (1 << 5),
- logger_mask_consts = (1 << 6),
- logger_mask_timestamp = (1 << 7),
+enum logger_masks_number {
+ logger_x = 0,
+ logger_v = 1,
+ logger_a = 2,
+ logger_u = 3,
+ logger_h = 4,
+ logger_rho = 5,
+ logger_consts = 6,
+ logger_timestamp = 7, /* expect it to be before count */
+ logger_count_mask = 8, /* Need to be the last */
+} __attribute__((packed));
+
+struct mask_data {
+ /* Number of bytes for a mask */
+ int size;
+ /* Mask value */
+ unsigned int mask;
+ /* name of the mask */
+ char name[100];
};
+extern const struct mask_data logger_mask_data[logger_count_mask];
+
/* Size of the strings. */
#define logger_string_length 200
-/* parameters of the logger */
-struct logger_parameters {
- /* size of a label in bytes */
- size_t label_size;
-
- /* size of an offset in bytes */
- size_t offset_size;
-
- /* size of a mask in bytes */
- size_t mask_size;
-
- /* size of a number in bytes */
- size_t number_size;
-
- /* size of a data type in bytes */
- size_t data_type_size;
-
- /* number of different mask */
- size_t number_mask;
-
- /* value of each masks */
- size_t *masks;
-
- /* data size of each mask */
- size_t *masks_data_size;
-
- /* label of each mask */
- char *masks_name;
-
- /* Size of a chunk if every mask are activated */
- size_t total_size;
-};
-
/* structure containing global data */
struct logger {
/* Number of particle steps between dumping a chunk of data */
@@ -128,8 +108,8 @@ struct logger {
/* Logger basename */
char base_name[logger_string_length];
- /* File name of the dump file */
- struct dump *dump;
+ /* Dump file */
+ struct dump dump;
/* timestamp offset for logger*/
size_t timestamp_offset;
@@ -137,8 +117,8 @@ struct logger {
/* scaling factor when buffer is too small */
float buffer_scale;
- /* logger parameters */
- struct logger_parameters *params;
+ /* Size of a chunk if every mask are activated */
+ int max_chunk_size;
} SWIFT_STRUCT_ALIGN;
@@ -151,18 +131,6 @@ struct logger_part_data {
size_t last_offset;
};
-enum logger_datatype {
- logger_data_int,
- logger_data_float,
- logger_data_double,
- logger_data_char,
- logger_data_longlong,
- logger_data_bool,
- logger_data_count /* should be last */
-};
-
-extern const unsigned int logger_datatype_size[];
-
/* Function prototypes. */
int logger_compute_chunk_size(unsigned int mask);
void logger_log_all(struct logger *log, const struct engine *e);
@@ -183,9 +151,6 @@ int logger_read_gpart(struct gpart *p, size_t *offset, const char *buff);
int logger_read_timestamp(unsigned long long int *t, double *time,
size_t *offset, const char *buff);
-void logger_parameters_init(struct logger_parameters *log_params);
-void logger_parameters_clean(struct logger_parameters *log_params);
-
/**
* @brief Initialize the logger data for a particle.
*
@@ -193,7 +158,7 @@ void logger_parameters_clean(struct logger_parameters *log_params);
*/
INLINE static void logger_part_data_init(struct logger_part_data *logger) {
logger->last_offset = 0;
- logger->steps_since_last_output = SHRT_MAX;
+ logger->steps_since_last_output = INT_MAX;
}
/**
diff --git a/src/runner.c b/src/runner.c
index f84b8b7ff346e033f07f31e0bf740254d654d902..f14f8d8bc2721d0edfaca542b68af645bd5ac1a0 100644
--- a/src/runner.c
+++ b/src/runner.c
@@ -2985,9 +2985,13 @@ void runner_do_logger(struct runner *r, struct cell *c, int timer) {
/* Write particle */
/* Currently writing everything, should adapt it through time */
logger_log_part(e->logger, p,
- logger_mask_x | logger_mask_v | logger_mask_a |
- logger_mask_u | logger_mask_h | logger_mask_rho |
- logger_mask_consts,
+ logger_mask_data[logger_x].mask |
+ logger_mask_data[logger_v].mask |
+ logger_mask_data[logger_a].mask |
+ logger_mask_data[logger_u].mask |
+ logger_mask_data[logger_h].mask |
+ logger_mask_data[logger_rho].mask |
+ logger_mask_data[logger_consts].mask,
&xp->logger_data.last_offset);
/* Set counter back to zero */