diff --git a/src/gravity/MultiSoftening/gravity_logger.h b/src/gravity/MultiSoftening/gravity_logger.h
index 65035aceac081cdb6c84282e34eca16142b43db0..e39d01cd942ef7c926ebfb778fbb41caabc04550 100644
--- a/src/gravity/MultiSoftening/gravity_logger.h
+++ b/src/gravity/MultiSoftening/gravity_logger.h
@@ -44,8 +44,7 @@ static const char *gravity_logger_field_names[gravity_logger_field_count] = {
 /**
  * @brief Initialize the logger.
  *
- * WARNING: this should be done in the same order than
- * #gravity_logger_write_particle.
+ * WARNING: The order should be the same in all the functions!
  *
  * @param mask_data Data for each type of mask.
  *
@@ -78,6 +77,8 @@ INLINE static int gravity_logger_populate_mask_data(
 /**
  * @brief Generates the mask and compute the size of the record.
  *
+ * WARNING: The order should be the same in all the functions!
+ *
  * @param masks The list of masks (same order than in #gravity_logger_init).
  * @param part The #gpart that will be written.
  * @param write_all Are we forcing to write all the fields?
@@ -92,37 +93,31 @@ INLINE static void gravity_logger_compute_size_and_mask(
   /* Here you can decide your own writing logic */
 
   /* Add the coordinates. */
-  *mask |= logger_add_field_to_mask(
-      masks[gravity_logger_field_coordinates],
-      gravity_logger_field_names[gravity_logger_field_coordinates],
-      buffer_size);
+  *mask |= logger_add_field_to_mask(masks[gravity_logger_field_coordinates],
+                                    buffer_size);
 
   /* Add the velocities. */
-  *mask |= logger_add_field_to_mask(
-      masks[gravity_logger_field_velocities],
-      gravity_logger_field_names[gravity_logger_field_velocities], buffer_size);
+  *mask |= logger_add_field_to_mask(masks[gravity_logger_field_velocities],
+                                    buffer_size);
 
   /* Add the accelerations. */
-  *mask |= logger_add_field_to_mask(
-      masks[gravity_logger_field_accelerations],
-      gravity_logger_field_names[gravity_logger_field_accelerations],
-      buffer_size);
+  *mask |= logger_add_field_to_mask(masks[gravity_logger_field_accelerations],
+                                    buffer_size);
 
   /* Add the masses. */
-  *mask |= logger_add_field_to_mask(
-      masks[gravity_logger_field_masses],
-      gravity_logger_field_names[gravity_logger_field_masses], buffer_size);
+  *mask |=
+      logger_add_field_to_mask(masks[gravity_logger_field_masses], buffer_size);
 
   /* Add the ID. */
-  *mask |= logger_add_field_to_mask(
-      masks[gravity_logger_field_particle_ids],
-      gravity_logger_field_names[gravity_logger_field_particle_ids],
-      buffer_size);
+  *mask |= logger_add_field_to_mask(masks[gravity_logger_field_particle_ids],
+                                    buffer_size);
 }
 
 /**
  * @brief Write a particle to the logger.
  *
+ * WARNING: The order should be the same in all the functions!
+ *
  * @param masks The list of masks (same order than in #gravity_logger_init).
  * @param p The #gpart to write.
  * @param mask The mask to use for this record.
@@ -135,41 +130,35 @@ INLINE static char *gravity_logger_write_particle(
     unsigned int *mask, char *buff) {
 
   /* Write the coordinate. */
-  if (logger_should_write_field(
-          mask_data[gravity_logger_field_coordinates], mask,
-          gravity_logger_field_names[gravity_logger_field_coordinates])) {
+  if (logger_should_write_field(mask_data[gravity_logger_field_coordinates],
+                                mask)) {
     memcpy(buff, p->x, 3 * sizeof(double));
     buff += 3 * sizeof(double);
   }
 
   /* Write the velocity. */
-  if (logger_should_write_field(
-          mask_data[gravity_logger_field_velocities], mask,
-          gravity_logger_field_names[gravity_logger_field_velocities])) {
+  if (logger_should_write_field(mask_data[gravity_logger_field_velocities],
+                                mask)) {
     memcpy(buff, p->v_full, 3 * sizeof(float));
     buff += 3 * sizeof(float);
   }
 
   /* Write the acceleration. */
-  if (logger_should_write_field(
-          mask_data[gravity_logger_field_accelerations], mask,
-          gravity_logger_field_names[gravity_logger_field_accelerations])) {
+  if (logger_should_write_field(mask_data[gravity_logger_field_accelerations],
+                                mask)) {
     memcpy(buff, p->a_grav, 3 * sizeof(float));
     buff += 3 * sizeof(float);
   }
 
   /* Write the mass. */
-  if (logger_should_write_field(
-          mask_data[gravity_logger_field_masses], mask,
-          gravity_logger_field_names[gravity_logger_field_masses])) {
+  if (logger_should_write_field(mask_data[gravity_logger_field_masses], mask)) {
     memcpy(buff, &p->mass, sizeof(float));
     buff += sizeof(float);
   }
 
   /* Write the Id. */
-  if (logger_should_write_field(
-          mask_data[gravity_logger_field_particle_ids], mask,
-          gravity_logger_field_names[gravity_logger_field_particle_ids])) {
+  if (logger_should_write_field(mask_data[gravity_logger_field_particle_ids],
+                                mask)) {
     memcpy(buff, &p->id_or_neg_offset, sizeof(long long));
     buff += sizeof(long long);
   }
diff --git a/src/hydro/Gadget2/hydro_logger.h b/src/hydro/Gadget2/hydro_logger.h
index 17f1a702e6095c16e189fe93daf1a83e9d3b3490..c1d98f214af17834b0ce8ecebfa14d3c54676698 100644
--- a/src/hydro/Gadget2/hydro_logger.h
+++ b/src/hydro/Gadget2/hydro_logger.h
@@ -47,8 +47,7 @@ static const char *hydro_logger_field_names[hydro_logger_field_count] = {
 /**
  * @brief Initialize the logger.
  *
- * WARNING: this should be done in the same order than
- * #hydro_logger_write_particle.
+ * WARNING: The order should be the same in all the functions!
  *
  * @param mask_data Data for each type of mask.
  *
@@ -90,6 +89,8 @@ INLINE static int hydro_logger_populate_mask_data(struct mask_data *mask_data) {
 /**
  * @brief Generates the mask and compute the size of the record.
  *
+ * WARNING: The order should be the same in all the functions!
+ *
  * @param masks The list of masks (same order than in #hydro_logger_init).
  * @param part The #part that will be written.
  * @param xpart The #xpart that will be written.
@@ -106,50 +107,43 @@ INLINE static void hydro_logger_compute_size_and_mask(
   /* Here you can decide your own writing logic */
 
   /* Add the coordinates. */
-  *mask |= logger_add_field_to_mask(
-      masks[hydro_logger_field_coordinates],
-      hydro_logger_field_names[hydro_logger_field_coordinates], buffer_size);
+  *mask |= logger_add_field_to_mask(masks[hydro_logger_field_coordinates],
+                                    buffer_size);
 
   /* Add the velocities. */
-  *mask |= logger_add_field_to_mask(
-      masks[hydro_logger_field_velocities],
-      hydro_logger_field_names[hydro_logger_field_velocities], buffer_size);
+  *mask |= logger_add_field_to_mask(masks[hydro_logger_field_velocities],
+                                    buffer_size);
 
   /* Add the accelerations. */
-  *mask |= logger_add_field_to_mask(
-      masks[hydro_logger_field_accelerations],
-      hydro_logger_field_names[hydro_logger_field_accelerations], buffer_size);
+  *mask |= logger_add_field_to_mask(masks[hydro_logger_field_accelerations],
+                                    buffer_size);
 
   /* Add the masses. */
-  *mask |= logger_add_field_to_mask(
-      masks[hydro_logger_field_masses],
-      hydro_logger_field_names[hydro_logger_field_masses], buffer_size);
+  *mask |=
+      logger_add_field_to_mask(masks[hydro_logger_field_masses], buffer_size);
 
   /* Add the smoothing lengths. */
-  *mask |= logger_add_field_to_mask(
-      masks[hydro_logger_field_smoothing_lengths],
-      hydro_logger_field_names[hydro_logger_field_smoothing_lengths],
-      buffer_size);
+  *mask |= logger_add_field_to_mask(masks[hydro_logger_field_smoothing_lengths],
+                                    buffer_size);
 
   /* Add the entropies. */
-  *mask |= logger_add_field_to_mask(
-      masks[hydro_logger_field_entropies],
-      hydro_logger_field_names[hydro_logger_field_entropies], buffer_size);
+  *mask |= logger_add_field_to_mask(masks[hydro_logger_field_entropies],
+                                    buffer_size);
 
   /* Add the ID. */
-  *mask |= logger_add_field_to_mask(
-      masks[hydro_logger_field_particle_ids],
-      hydro_logger_field_names[hydro_logger_field_particle_ids], buffer_size);
+  *mask |= logger_add_field_to_mask(masks[hydro_logger_field_particle_ids],
+                                    buffer_size);
 
   /* Add the density. */
-  *mask |= logger_add_field_to_mask(
-      masks[hydro_logger_field_densities],
-      hydro_logger_field_names[hydro_logger_field_densities], buffer_size);
+  *mask |= logger_add_field_to_mask(masks[hydro_logger_field_densities],
+                                    buffer_size);
 }
 
 /**
  * @brief Write a particle to the logger.
  *
+ * WARNING: The order should be the same in all the functions!
+ *
  * @param masks The list of masks (same order than in #hydro_logger_init).
  * @param p The #part to write.
  * @param xp The #xpart to write.
@@ -163,25 +157,22 @@ INLINE static char *hydro_logger_write_particle(
     const struct xpart *xp, unsigned int *mask, char *buff) {
 
   /* Write the coordinate. */
-  if (logger_should_write_field(
-          mask_data[hydro_logger_field_coordinates], mask,
-          hydro_logger_field_names[hydro_logger_field_coordinates])) {
+  if (logger_should_write_field(mask_data[hydro_logger_field_coordinates],
+                                mask)) {
     memcpy(buff, p->x, 3 * sizeof(double));
     buff += 3 * sizeof(double);
   }
 
   /* Write the velocity. */
-  if (logger_should_write_field(
-          mask_data[hydro_logger_field_velocities], mask,
-          hydro_logger_field_names[hydro_logger_field_velocities])) {
+  if (logger_should_write_field(mask_data[hydro_logger_field_velocities],
+                                mask)) {
     memcpy(buff, p->v, 3 * sizeof(float));
     buff += 3 * sizeof(float);
   }
 
   /* Write the acceleration. */
-  if (logger_should_write_field(
-          mask_data[hydro_logger_field_accelerations], mask,
-          hydro_logger_field_names[hydro_logger_field_accelerations])) {
+  if (logger_should_write_field(mask_data[hydro_logger_field_accelerations],
+                                mask)) {
 
     /* Compute the acceleration due to hydro and gravity */
     float *acc = (float *)buff;
@@ -194,41 +185,35 @@ INLINE static char *hydro_logger_write_particle(
   }
 
   /* Write the mass. */
-  if (logger_should_write_field(
-          mask_data[hydro_logger_field_masses], mask,
-          hydro_logger_field_names[hydro_logger_field_masses])) {
+  if (logger_should_write_field(mask_data[hydro_logger_field_masses], mask)) {
     memcpy(buff, &p->mass, sizeof(float));
     buff += sizeof(float);
   }
 
   /* Write the smoothing length. */
-  if (logger_should_write_field(
-          mask_data[hydro_logger_field_smoothing_lengths], mask,
-          hydro_logger_field_names[hydro_logger_field_smoothing_lengths])) {
+  if (logger_should_write_field(mask_data[hydro_logger_field_smoothing_lengths],
+                                mask)) {
     memcpy(buff, &p->h, sizeof(float));
     buff += sizeof(float);
   }
 
   /* Write the entropy. */
-  if (logger_should_write_field(
-          mask_data[hydro_logger_field_entropies], mask,
-          hydro_logger_field_names[hydro_logger_field_entropies])) {
+  if (logger_should_write_field(mask_data[hydro_logger_field_entropies],
+                                mask)) {
     memcpy(buff, &p->entropy, sizeof(float));
     buff += sizeof(float);
   }
 
   /* Write the Id. */
-  if (logger_should_write_field(
-          mask_data[hydro_logger_field_particle_ids], mask,
-          hydro_logger_field_names[hydro_logger_field_particle_ids])) {
+  if (logger_should_write_field(mask_data[hydro_logger_field_particle_ids],
+                                mask)) {
     memcpy(buff, &p->id, sizeof(long long));
     buff += sizeof(long long);
   }
 
   /* Write the density. */
-  if (logger_should_write_field(
-          mask_data[hydro_logger_field_densities], mask,
-          hydro_logger_field_names[hydro_logger_field_densities])) {
+  if (logger_should_write_field(mask_data[hydro_logger_field_densities],
+                                mask)) {
     memcpy(buff, &p->rho, sizeof(float));
     buff += sizeof(float);
   }
diff --git a/src/logger_io.h b/src/logger_io.h
index 495e4754202ac9969a46e6697b1a8a421740c5c4..5e5657ba204889e01afd9925d1c993d7532d72f4 100644
--- a/src/logger_io.h
+++ b/src/logger_io.h
@@ -80,22 +80,13 @@ INLINE static struct mask_data logger_create_mask_entry(const char* name,
  *
  * @param mask_data The mask_data corresponding to the field that we wish to
  * write.
- * @param name The name of the field.
  * @param buffer_size (in) The current size of the future buffer. (out) The
  * updated size.
  *
  * @return The mask of the current field.
  */
 INLINE static size_t logger_add_field_to_mask(struct mask_data mask_data,
-                                              const char* name,
                                               size_t* buffer_size) {
-#ifdef SWIFT_DEBUG_CHECKS
-  /* Check that we are writing the requested field. */
-  if (strcmp(name, mask_data.name) != 0) {
-    error("Mismatch between the requested field (%s) and the mask (%s)", name,
-          mask_data.name);
-  }
-#endif
 
   *buffer_size += mask_data.size;
   return mask_data.mask;
@@ -106,19 +97,10 @@ INLINE static size_t logger_add_field_to_mask(struct mask_data mask_data,
  * #logger_add_field_to_mask.
  *
  * @param mask_data The mask_data corresponding to the current field.
- * @param name The name of the field that we are checking.
  * @param mask The mask used for the current record.
  */
 INLINE static int logger_should_write_field(struct mask_data mask_data,
-                                            unsigned int* mask,
-                                            const char* name) {
-#ifdef SWIFT_DEBUG_CHECKS
-  /* Check that we are writing the requested field. */
-  if (strcmp(name, mask_data.name) != 0) {
-    error("Mismatch between the requested field (%s) and the mask (%s)", name,
-          mask_data.name);
-  }
-#endif
+                                            unsigned int* mask) {
 
   const int test = mask_data.mask & *mask;
   if (test) {
diff --git a/src/stars/Default/stars_logger.h b/src/stars/Default/stars_logger.h
index 4f6e07060f10095cdbd86ae7ecf87b4930853e26..b4b0712c77af816056f1fa3a00a0b23634b1267a 100644
--- a/src/stars/Default/stars_logger.h
+++ b/src/stars/Default/stars_logger.h
@@ -44,8 +44,7 @@ static const char *stars_logger_field_names[stars_logger_field_count] = {
 /**
  * @brief Initialize the logger.
  *
- * WARNING: this should be done in the same order than
- * #stars_logger_write_particle.
+ * WARNING: The order should be the same in all the functions!
  *
  * @param mask_data Data for each type of mask.
  *
@@ -81,6 +80,8 @@ INLINE static int stars_logger_populate_mask_data(struct mask_data *mask_data) {
 /**
  * @brief Generates the mask and compute the size of the record.
  *
+ * WARNING: The order should be the same in all the functions!
+ *
  * @param masks The list of masks (same order than in #stars_logger_init).
  * @param part The #spart that will be written.
  * @param write_all Are we forcing to write all the fields?
@@ -95,40 +96,35 @@ INLINE static void stars_logger_compute_size_and_mask(
   /* Here you can decide your own writing logic */
 
   /* Add the coordinates. */
-  *mask |= logger_add_field_to_mask(
-      masks[stars_logger_field_coordinates],
-      stars_logger_field_names[stars_logger_field_coordinates], buffer_size);
+  *mask |= logger_add_field_to_mask(masks[stars_logger_field_coordinates],
+                                    buffer_size);
 
   /* Add the velocities. */
-  *mask |= logger_add_field_to_mask(
-      masks[stars_logger_field_velocities],
-      stars_logger_field_names[stars_logger_field_velocities], buffer_size);
+  *mask |= logger_add_field_to_mask(masks[stars_logger_field_velocities],
+                                    buffer_size);
 
   /* Add the accelerations. */
-  *mask |= logger_add_field_to_mask(
-      masks[stars_logger_field_accelerations],
-      stars_logger_field_names[stars_logger_field_accelerations], buffer_size);
+  *mask |= logger_add_field_to_mask(masks[stars_logger_field_accelerations],
+                                    buffer_size);
 
   /* Add the masses. */
-  *mask |= logger_add_field_to_mask(
-      masks[stars_logger_field_masses],
-      stars_logger_field_names[stars_logger_field_masses], buffer_size);
+  *mask |=
+      logger_add_field_to_mask(masks[stars_logger_field_masses], buffer_size);
 
   /* Add the smoothing lengths. */
-  *mask |= logger_add_field_to_mask(
-      masks[stars_logger_field_smoothing_lengths],
-      stars_logger_field_names[stars_logger_field_smoothing_lengths],
-      buffer_size);
+  *mask |= logger_add_field_to_mask(masks[stars_logger_field_smoothing_lengths],
+                                    buffer_size);
 
   /* Add the ID. */
-  *mask |= logger_add_field_to_mask(
-      masks[stars_logger_field_particle_ids],
-      stars_logger_field_names[stars_logger_field_particle_ids], buffer_size);
+  *mask |= logger_add_field_to_mask(masks[stars_logger_field_particle_ids],
+                                    buffer_size);
 }
 
 /**
  * @brief Write a particle to the logger.
  *
+ * WARNING: The order should be the same in all the functions!
+ *
  * @param masks The list of masks (same order than in #stars_logger_init).
  * @param p The #spart to write.
  * @param mask The mask to use for this record.
@@ -141,49 +137,42 @@ INLINE static char *stars_logger_write_particle(
     unsigned int *mask, char *buff) {
 
   /* Write the coordinate. */
-  if (logger_should_write_field(
-          mask_data[stars_logger_field_coordinates], mask,
-          stars_logger_field_names[stars_logger_field_coordinates])) {
+  if (logger_should_write_field(mask_data[stars_logger_field_coordinates],
+                                mask)) {
     memcpy(buff, p->x, 3 * sizeof(double));
     buff += 3 * sizeof(double);
   }
 
   /* Write the velocity. */
-  if (logger_should_write_field(
-          mask_data[stars_logger_field_velocities], mask,
-          stars_logger_field_names[stars_logger_field_velocities])) {
+  if (logger_should_write_field(mask_data[stars_logger_field_velocities],
+                                mask)) {
     memcpy(buff, p->v, 3 * sizeof(float));
     buff += 3 * sizeof(float);
   }
 
   /* Write the acceleration. */
-  if (logger_should_write_field(
-          mask_data[stars_logger_field_accelerations], mask,
-          stars_logger_field_names[stars_logger_field_accelerations])) {
+  if (logger_should_write_field(mask_data[stars_logger_field_accelerations],
+                                mask)) {
     memcpy(buff, p->gpart->a_grav, 3 * sizeof(float));
     buff += 3 * sizeof(float);
   }
 
   /* Write the mass. */
-  if (logger_should_write_field(
-          mask_data[stars_logger_field_masses], mask,
-          stars_logger_field_names[stars_logger_field_masses])) {
+  if (logger_should_write_field(mask_data[stars_logger_field_masses], mask)) {
     memcpy(buff, &p->mass, sizeof(float));
     buff += sizeof(float);
   }
 
   /* Write the smoothing length. */
-  if (logger_should_write_field(
-          mask_data[stars_logger_field_smoothing_lengths], mask,
-          stars_logger_field_names[stars_logger_field_smoothing_lengths])) {
+  if (logger_should_write_field(mask_data[stars_logger_field_smoothing_lengths],
+                                mask)) {
     memcpy(buff, &p->h, sizeof(float));
     buff += sizeof(float);
   }
 
   /* Write the Id. */
-  if (logger_should_write_field(
-          mask_data[stars_logger_field_particle_ids], mask,
-          stars_logger_field_names[stars_logger_field_particle_ids])) {
+  if (logger_should_write_field(mask_data[stars_logger_field_particle_ids],
+                                mask)) {
     memcpy(buff, &p->id, sizeof(long long));
     buff += sizeof(long long);
   }