/*******************************************************************************
*
*  McStas, neutron ray-tracing package
*  Copyright(C) 2007 Risoe National Laboratory.
*
* %I
* Written by: Mads Bertelsen
* Date: 19.06.20
* Version: $Revision: 0.1 $
* Origin: ESS DMSC
*
* Logger of absorption in 1D space stored as events
*
* %D
* Part of the Union components, a set of components that work together and thus
*  separates geometry and physics within McStas.
* The use of this component requires other components to be used.
*
* 1) One specifies a number of processes using process components
* 2) These are gathered into material definitions using Union_make_material
* 3) Geometries are placed using Union_box/cylinder/sphere, assigned a material
* 4) Logger and conditional components can be placed which will record what happens
* 5) A Union_master component placed after all of the above
*
* Only in step 5 will any simulation happen, and per default all geometries
*  defined before this master, but after the previous will be simulated here.
*
* There is a dedicated manual available for the Union_components
*
* This component is an absorption logger, and thus placed in point 4) above.
*
* A absorption logger will log something for each absorption event happening
*  in the geometry or geometries on which it is attached. These are specified
*  in the target_geometry string. By leaving it blank, all geometries are
*  logged, even the ones not defined at this point in the instrument file.
*  Multiple geometries are specified as a comma separated list.
*
* This absorption logger stores the absorbed weight as an event including a
*  pixel_id. The pixel_id is found from the y coordinate of the event position
*  in the coordinate system of the absorption logger and is binned to a
*  pixel_id which is necessary when importing the data in Mantid. The y
*  coordinate corresponds to the height and is natural when attaching this
*  absorption logger to a cylindrical geometry, as it will record position
*  along the axis of symmetry, and thus behave like a detector tube. When using
*  several of these absorption loggers, they will internally avoid reusing the
*  same pixel_id, but if any other mantid detectors are used, these need to have
*  pixel_ids larger than the maximum used by these loggers. Each of these components
*  uses three times the number of bins, as it internally is a 3xn histogram where
*  only the center line have data, as this is much easier to import in Mantid.
*  The ocmponent uses Monitor_nD functions for trace and mcdisplay, and for this
*  reason it can write the xml file required to transfer the detector geometry
*  to Mantid.
*
* This absorption logger needs to be placed in space, the position is recorded in
*  the coordinate system of the logger component.
*
* It is possible to attach one or more conditional components to this absorption
*  logger. Such a conditional component would impose a condition on the state of
*  the neutron after the Union_master component that executes the simulation,
*  and the absorption logger will only record the event if this condition is true.
*
* To use the logger_conditional_extend function, set it to some integer value n
*  and make and extend section to the master component that runs the geometry.
* In this extend function, logger_conditional_extend[n] is 1 if the conditional
*  stack evaluated to true, 0 if not. This way one can check what rays is logged
*  using regular McStas monitors. Only works if a conditional is applied to this
*  logger.
*
* %P
* INPUT PARAMETERS:
* yheight:         [m] Height of absorption logger
* n:               [1] Number of bins along y
* fake_event:      [1] Number of fake events to add, circumvents issue with empty event lists with MPI
* target_geometry: [string] Comma separated list of geometry names that will be logged, leave empty for all volumes (even not defined yet)
* filename:        [string] Filename of produced data file
* order_total:     [1] Only log rays that have scattered n times, -1 for all orders
* order_volume:    [1] Only log rays that have scattered n times in the same geometry, -1 for all orders
* logger_conditional_extend_index: [1] If a conditional is used with this logger, the result of each conditional calculation can be made available in extend as a array called "logger_conditional_extend", and one would then access logger_conditional_extend[n] if logger_conditional_extend_index is set to n
* init:              [string] name of Union_init component (typically "init", default)
*
* CALCULATED PARAMETERS:
*
* GLOBAL PARAMETERS:
*
* %L
*
* %E
******************************************************************************/

DEFINE COMPONENT Union_abs_logger_1D_space_event

SETTING PARAMETERS(string target_geometry="NULL", yheight, int n, int fake_event=0,
                   string filename="NULL", order_total=-1, order_volume=-1, logger_conditional_extend_index=-1, string init="init")


/* Neutron parameters: (x,y,z,vx,vy,vz,t,sx,sy,sz,p) */

SHARE
%{
  #ifndef Union
  #error "The Union_init component must be included before this Union_abs_logger_1D_space_event component"
  #endif

  // Internally avoids double import
  %include "monitor_nd-lib"

  struct temp_abs_1D_event_data_element_struct {
    double x_pos;
    double y_pos;
    double z_pos;

    double x_vel;
    double y_vel;
    double z_vel;

    double x_pol;
    double y_pol;
    double z_pol;

    double time;
    double weight;
  };

  struct temp_abs_1D_event_data_struct {
    int num_elements;
    int allocated_elements;
    struct temp_abs_1D_event_data_element_struct* elements;
  };

  struct a_1D_event_abs_storage_struct {
    MonitornD_Defines_type DEFS;
    MonitornD_Variables_type Vars;

    struct temp_abs_1D_event_data_struct temp_abs_1D_event_data;
    // some type
    int order;
    int order_in_this_volume;
    int order_process_in_this_volume;

    Coords position;
    Rotation rotation;
    Rotation t_rotation;
  };

  // record_to_temp
  // Would be nice if x y z, k_new and k_old were all coords
  void
  record_to_temp_abs_1D_event (Coords* position, double* k, double p, double time, int scattered_in_this_volume, int total_number_of_scattering_events,
                               struct abs_logger_struct* abs_logger, struct abs_logger_with_data_struct* abs_logger_with_data_array) {

    struct a_1D_event_abs_storage_struct* storage;
    storage = abs_logger->data_union.p_1D_event_abs_storage;

    int add_point = 1;

    if (storage->order != -1) {
      if (storage->order == total_number_of_scattering_events)
        add_point = 1;
      else
        add_point = 0;
    }

    if (storage->order_in_this_volume != -1) {
      if (storage->order_in_this_volume == scattered_in_this_volume)
        add_point = 1;
      else
        add_point = 0;
    }

    if (add_point == 1) {

      int i;
      double given_x_pos, given_y_pos, given_z_pos;
      coords_get (*position, &given_x_pos, &given_y_pos, &given_z_pos);
      given_x_pos = 0.0; // 1D monitor, always in center x bin

      double given_x_vel, given_y_vel, given_z_vel;
      given_x_vel = k[0] * K2V;
      given_y_vel = k[1] * K2V;
      given_z_vel = k[2] * K2V;

      if (storage->temp_abs_1D_event_data.num_elements < storage->temp_abs_1D_event_data.allocated_elements) {

        storage->temp_abs_1D_event_data.elements[storage->temp_abs_1D_event_data.num_elements].x_pos = given_x_pos;
        storage->temp_abs_1D_event_data.elements[storage->temp_abs_1D_event_data.num_elements].y_pos = given_y_pos;
        storage->temp_abs_1D_event_data.elements[storage->temp_abs_1D_event_data.num_elements].z_pos = given_z_pos;
        storage->temp_abs_1D_event_data.elements[storage->temp_abs_1D_event_data.num_elements].x_vel = given_x_vel;
        storage->temp_abs_1D_event_data.elements[storage->temp_abs_1D_event_data.num_elements].y_vel = given_y_vel;
        storage->temp_abs_1D_event_data.elements[storage->temp_abs_1D_event_data.num_elements].z_vel = given_z_vel;
        storage->temp_abs_1D_event_data.elements[storage->temp_abs_1D_event_data.num_elements].x_pol = 0.0;
        storage->temp_abs_1D_event_data.elements[storage->temp_abs_1D_event_data.num_elements].y_pol = 0.0;
        storage->temp_abs_1D_event_data.elements[storage->temp_abs_1D_event_data.num_elements].z_pol = 1.0;
        storage->temp_abs_1D_event_data.elements[storage->temp_abs_1D_event_data.num_elements].time = time;
        storage->temp_abs_1D_event_data.elements[storage->temp_abs_1D_event_data.num_elements++].weight = p;
      } else {
        // No more space, need to allocate a larger buffer for this logger. Wish I had generics.

        // copy current data to temp
        struct temp_abs_1D_event_data_struct temporary_storage;
        temporary_storage.num_elements = storage->temp_abs_1D_event_data.num_elements;
        temporary_storage.elements = malloc (temporary_storage.num_elements * sizeof (struct temp_abs_1D_event_data_element_struct));

        int index;
        for (index = 0; index < storage->temp_abs_1D_event_data.num_elements; index++) {
          temporary_storage.elements[index].x_pos = storage->temp_abs_1D_event_data.elements[index].x_pos;
          temporary_storage.elements[index].y_pos = storage->temp_abs_1D_event_data.elements[index].y_pos;
          temporary_storage.elements[index].z_pos = storage->temp_abs_1D_event_data.elements[index].z_pos;
          temporary_storage.elements[index].x_vel = storage->temp_abs_1D_event_data.elements[index].x_vel;
          temporary_storage.elements[index].y_vel = storage->temp_abs_1D_event_data.elements[index].y_vel;
          temporary_storage.elements[index].z_vel = storage->temp_abs_1D_event_data.elements[index].z_vel;
          temporary_storage.elements[index].x_pol = storage->temp_abs_1D_event_data.elements[index].x_pol;
          temporary_storage.elements[index].y_pol = storage->temp_abs_1D_event_data.elements[index].y_pol;
          temporary_storage.elements[index].z_pol = storage->temp_abs_1D_event_data.elements[index].z_pol;
          temporary_storage.elements[index].time = storage->temp_abs_1D_event_data.elements[index].time;
          temporary_storage.elements[index].weight = storage->temp_abs_1D_event_data.elements[index].weight;
        }

        // free current data
        free (storage->temp_abs_1D_event_data.elements);

        // allocate larger array (10 larger)
        storage->temp_abs_1D_event_data.allocated_elements = 10 + storage->temp_abs_1D_event_data.num_elements;
        storage->temp_abs_1D_event_data.elements
            = malloc (storage->temp_abs_1D_event_data.allocated_elements * sizeof (struct temp_abs_1D_event_data_element_struct));

        // copy back from temp
        for (index = 0; index < storage->temp_abs_1D_event_data.num_elements; index++) {
          storage->temp_abs_1D_event_data.elements[index].x_pos = temporary_storage.elements[index].x_pos;
          storage->temp_abs_1D_event_data.elements[index].y_pos = temporary_storage.elements[index].y_pos;
          storage->temp_abs_1D_event_data.elements[index].z_pos = temporary_storage.elements[index].z_pos;
          storage->temp_abs_1D_event_data.elements[index].x_vel = temporary_storage.elements[index].x_vel;
          storage->temp_abs_1D_event_data.elements[index].y_vel = temporary_storage.elements[index].y_vel;
          storage->temp_abs_1D_event_data.elements[index].z_vel = temporary_storage.elements[index].z_vel;
          storage->temp_abs_1D_event_data.elements[index].x_pol = temporary_storage.elements[index].x_pol;
          storage->temp_abs_1D_event_data.elements[index].y_pol = temporary_storage.elements[index].y_pol;
          storage->temp_abs_1D_event_data.elements[index].z_pol = temporary_storage.elements[index].z_pol;
          storage->temp_abs_1D_event_data.elements[index].time = temporary_storage.elements[index].time;
          storage->temp_abs_1D_event_data.elements[index].weight = temporary_storage.elements[index].weight;
        }

        // free temporary data
        free (temporary_storage.elements);

        // add new data point
        storage->temp_abs_1D_event_data.elements[storage->temp_abs_1D_event_data.num_elements].x_pos = given_x_pos;
        storage->temp_abs_1D_event_data.elements[storage->temp_abs_1D_event_data.num_elements].y_pos = given_y_pos;
        storage->temp_abs_1D_event_data.elements[storage->temp_abs_1D_event_data.num_elements].z_pos = given_z_pos;
        storage->temp_abs_1D_event_data.elements[storage->temp_abs_1D_event_data.num_elements].x_vel = given_x_vel;
        storage->temp_abs_1D_event_data.elements[storage->temp_abs_1D_event_data.num_elements].y_vel = given_y_vel;
        storage->temp_abs_1D_event_data.elements[storage->temp_abs_1D_event_data.num_elements].z_vel = given_z_vel;
        storage->temp_abs_1D_event_data.elements[storage->temp_abs_1D_event_data.num_elements].x_pol = 0.0;
        storage->temp_abs_1D_event_data.elements[storage->temp_abs_1D_event_data.num_elements].y_pol = 0.0;
        storage->temp_abs_1D_event_data.elements[storage->temp_abs_1D_event_data.num_elements].z_pol = 1.0;
        storage->temp_abs_1D_event_data.elements[storage->temp_abs_1D_event_data.num_elements].time = time;
        storage->temp_abs_1D_event_data.elements[storage->temp_abs_1D_event_data.num_elements++].weight = p;
      }

      // If this is the first time this ray is being recorded in this logger, add it to the list of loggers that write to temp and may get it moved to perm
      if (storage->temp_abs_1D_event_data.num_elements == 1)
        add_to_abs_logger_with_data (abs_logger_with_data_array, abs_logger);
    }
  }

  // clear_temp
  void
  clear_temp_abs_1D_event (union abs_logger_data_union* data_union) {
    data_union->p_1D_event_abs_storage->temp_abs_1D_event_data.num_elements = 0;
  }

  // record_to_perm
  void
  record_to_perm_abs_1D_event (Coords* position, double* k, double p, double time, int scattered_in_this_volume, int total_number_of_scattering_events,
                               struct abs_logger_struct* abs_logger, struct abs_logger_with_data_struct* abs_logger_with_data_array) {

    // printf("In record to permanent \n");
    struct a_1D_event_abs_storage_struct* storage;
    storage = abs_logger->data_union.p_1D_event_abs_storage;

    int add_point = 1;

    if (storage->order != -1) {
      if (storage->order == total_number_of_scattering_events)
        add_point = 1;
      else
        add_point = 0;
    }

    if (storage->order_in_this_volume != -1) {
      if (storage->order_in_this_volume == scattered_in_this_volume)
        add_point = 1;
      else
        add_point = 0;
    }

    if (add_point == 1) {
      // printf("storage was set \n");

      double given_x_pos, given_y_pos, given_z_pos;
      coords_get (*position, &given_x_pos, &given_y_pos, &given_z_pos);
      given_x_pos = 0.0; // 1D monitor, always in center x bin

      double given_x_vel, given_y_vel, given_z_vel;
      given_x_vel = k[0] * K2V;
      given_y_vel = k[1] * K2V;
      given_z_vel = k[2] * K2V;

      _class_particle _localparticle;
      _localparticle.x = given_x_pos;
      _localparticle.y = given_y_pos;
      _localparticle.z = given_z_pos;

      _localparticle.vx = given_x_vel;
      _localparticle.vy = given_y_vel;
      _localparticle.vz = given_z_vel;

      _localparticle.sx = 0.0;
      _localparticle.sy = 0.0;
      _localparticle.sz = 1.0;

      _localparticle.p = p;
      _localparticle.t = time;

      int pp;
      pp = Monitor_nD_Trace (&(storage->DEFS), &(storage->Vars), &_localparticle);
    }
  }

  // write_temp_to_perm
  void
  write_temp_to_perm_abs_1D_event (union abs_logger_data_union* data_union) {

    struct a_1D_event_abs_storage_struct* storage;
    storage = data_union->p_1D_event_abs_storage;

    int index;
    // Add all data points to the histogram, they are saved as index / weight combinations
    for (index = 0; index < storage->temp_abs_1D_event_data.num_elements; index++) {

      _class_particle _localparticle;

      _localparticle.x = storage->temp_abs_1D_event_data.elements[index].x_pos;
      _localparticle.y = storage->temp_abs_1D_event_data.elements[index].y_pos;
      _localparticle.z = storage->temp_abs_1D_event_data.elements[index].z_pos;

      _localparticle.vx = storage->temp_abs_1D_event_data.elements[index].x_vel;
      _localparticle.vy = storage->temp_abs_1D_event_data.elements[index].y_vel;
      _localparticle.vz = storage->temp_abs_1D_event_data.elements[index].z_vel;

      _localparticle.sx = 0.0;
      _localparticle.sy = 0.0;
      _localparticle.sz = 1.0;

      _localparticle.p = storage->temp_abs_1D_event_data.elements[index].weight;
      _localparticle.t = storage->temp_abs_1D_event_data.elements[index].time;

      int pp;
      pp = Monitor_nD_Trace (&(storage->DEFS), &(storage->Vars), &_localparticle);
    }
    clear_temp_abs_1D_event (data_union);
  }

  void
  write_temp_to_perm_final_p_abs_1D_event (union abs_logger_data_union* data_union, double final_weight) {

    struct a_1D_event_abs_storage_struct* storage;
    storage = data_union->p_1D_event_abs_storage;

    int index;
    // Add all data points to the histogram, they are saved as index / weight combinations
    for (index = 0; index < storage->temp_abs_1D_event_data.num_elements; index++) {

      _class_particle _localparticle;

      _localparticle.x = storage->temp_abs_1D_event_data.elements[index].x_pos;
      _localparticle.y = storage->temp_abs_1D_event_data.elements[index].y_pos;
      _localparticle.z = storage->temp_abs_1D_event_data.elements[index].z_pos;

      _localparticle.vx = storage->temp_abs_1D_event_data.elements[index].x_vel;
      _localparticle.vy = storage->temp_abs_1D_event_data.elements[index].y_vel;
      _localparticle.vz = storage->temp_abs_1D_event_data.elements[index].z_vel;

      _localparticle.sx = 0.0;
      _localparticle.sy = 0.0;
      _localparticle.sz = 1.0;

      _localparticle.p = final_weight;
      _localparticle.t = storage->temp_abs_1D_event_data.elements[index].time;

      int pp;
      pp = Monitor_nD_Trace (&(storage->DEFS), &(storage->Vars), &_localparticle);
    }
    clear_temp_abs_1D_event (data_union);
  }

  // Only need to define linking function for loggers once.
  #ifndef UNION_ABS_LOGGER
  #define UNION_ABS_LOGGER Dummy
  // Linking function for loggers, finds the indices of the specified geometries on the global_geometry_list
  void
  manual_linking_function_abs_logger_volumes (char* input_string, struct pointer_to_global_geometry_list* global_geometry_list,
                                              struct pointer_to_1d_int_list* accepted_volumes, char* component_name) {
    // Need to check a input_string of text for an occurrence of name. If it is in the inputstring, yes return 1, otherwise 0.
    char* token;
    int loop_index;
    char local_string[512];

    strcpy (local_string, input_string);
    // get the first token
    token = strtok (local_string, ",");

    // walk through other tokens
    while (token != NULL) {
      // printf( " %s\n", token );
      for (loop_index = 0; loop_index < global_geometry_list->num_elements; loop_index++) {
        if (strcmp (token, global_geometry_list->elements[loop_index].name) == 0) {
          add_element_to_int_list (accepted_volumes, loop_index);
          break;
        }

        if (loop_index == global_geometry_list->num_elements - 1) {
          // All possible geometry names have been looked through, and the break was not executed.
          // Alert the user to this problem by showing the geometry name that was not found and the currently available geometires
          printf ("\n");
          printf ("ERROR: The target_geometry string \"%s\" in Union logger component \"%s\" had an entry that did not match a specified geometry. \n",
                  input_string, component_name);
          printf ("       The unrecoignized geometry name was: \"%s\" \n", token);
          printf ("       The geometries available at this point (need to be defined before the logger): \n");
          for (loop_index = 0; loop_index < global_geometry_list->num_elements; loop_index++)
            printf ("         %s\n", global_geometry_list->elements[loop_index].name);
          exit (1);
        }
      }

      // Updates the token
      token = strtok (NULL, ",");
    }
  }

  #endif
%}

DECLARE
%{
  int loop_index;
  int found_process;
  int specified_processes;
  // char local_string[256];

  // Reused for logger
  struct pointer_to_1d_int_list accepted_processes;

  struct global_abs_logger_element_struct abs_logger_list_element;

  struct pointer_to_1d_int_list accepted_volumes;

  struct abs_logger_struct this_abs_logger;
  struct a_1D_event_abs_storage_struct this_abs_storage;

  struct abs_loggers_struct* abs_loggers_on_target_volume;
  struct Volume_struct* target_volume;

  double bufsize;
%}

INITIALIZE
%{

  bufsize = 0;

  accepted_processes.elements = NULL;
  accepted_processes.num_elements = 0;

  accepted_volumes.elements = NULL;
  accepted_volumes.num_elements = 0;

  // Input sanitation for filename apparently done in 1D_detector_out

  long element_size = 85; /* mean size per neutron for ascii storing */

  strcpy (this_abs_storage.Vars.compcurname, NAME_CURRENT_COMP);

  char option_string_part[256];

  sprintf (this_abs_storage.Vars.option, "mantid square x limits=[-0.0005,0.0005] bins=3 y limits=[%f %f] bins=%i", -0.5 * yheight, 0.5 * yheight, n);

  if (_getcomp_index (init) < 0) {
    fprintf (stderr, "Union_abs_logger_1D_space_event:%s: Error identifying Union_init component, %s is not a known component name.\n", NAME_CURRENT_COMP, init);
    exit (-1);
  }

  // Need to tell the monitor from what integer its pixel id range starts, and it necessary to avoid overlaps.
  // global_mantid_min_pixel_id is initialized as 0, and each monitor adds its number of pixels to avoid overlap.
  int global_mantid_min_pixel_id = (int)COMP_GETPAR3 (Union_init, init, global_mantid_min_pixel_id);
  sprintf (option_string_part, ", neutron pixel min=%i t, list all neutrons", global_mantid_min_pixel_id);
  global_mantid_min_pixel_id += 3 * n;

  strcat (this_abs_storage.Vars.option, option_string_part); // hardcoded min=0 for now
  printf ("Monitor_nD option string: %s\n", this_abs_storage.Vars.option);

  Monitor_nD_Init (&this_abs_storage.DEFS, &this_abs_storage.Vars, 0.001, yheight, 0, 0, 0, 0, 0, 0, 0, 0, 0); /* dims for mcdisplay */
  this_abs_storage.Vars.compcurpos = POS_A_CURRENT_COMP;

  if (filename && strlen (filename) && strcmp (filename, "NULL") && strcmp (filename, "0"))
    strncpy (this_abs_storage.Vars.Mon_File, filename, 128);

  if (bufsize > 0)
    printf ("Warning: Virtual_output: %s: buffer size=%g not recommended\n", NAME_CURRENT_COMP, bufsize);
  if (bufsize > 0)
    printf ("Virtual_output: %s: Beware virtual output generated file size (max %g Mo)\n"
            "WARNING         Memory required is %g Mo\n",
            NAME_CURRENT_COMP, bufsize* element_size / 1e6, bufsize * sizeof (double) / 1e6);

  this_abs_storage.order = order_total;
  this_abs_storage.order_in_this_volume = order_volume;

  this_abs_storage.temp_abs_1D_event_data.num_elements = 0;

  this_abs_storage.temp_abs_1D_event_data.allocated_elements = 10;
  this_abs_storage.temp_abs_1D_event_data.elements
      = malloc (this_abs_storage.temp_abs_1D_event_data.allocated_elements * sizeof (struct temp_abs_1D_event_data_element_struct));

  struct global_positions_to_transform_list_struct* global_positions_to_transform_list = COMP_GETPAR3 (Union_init, init, global_positions_to_transform_list);
  struct global_rotations_to_transform_list_struct* global_rotations_to_transform_list = COMP_GETPAR3 (Union_init, init, global_rotations_to_transform_list);
  // Test position and rotation stored in a data storage, and pointers assigned to transform lists
  this_abs_logger.position = POS_A_CURRENT_COMP;
  add_position_pointer_to_list (global_positions_to_transform_list, &this_abs_logger.position);

  rot_copy (this_abs_logger.rotation, ROT_A_CURRENT_COMP);
  add_rotation_pointer_to_list (global_rotations_to_transform_list, &this_abs_logger.rotation);

  rot_transpose (ROT_A_CURRENT_COMP, this_abs_logger.t_rotation);
  add_rotation_pointer_to_list (global_rotations_to_transform_list, &this_abs_logger.t_rotation);

  // Adding fake event to combat MPI writing bug
  if (fake_event) {
    _class_particle _localparticle;

    _localparticle.x = 0.0;
    _localparticle.y = 0.0;
    _localparticle.z = -1.0;

    _localparticle.vx = 0.0;
    _localparticle.vy = 0.0;
    _localparticle.vz = 1000.0;

    _localparticle.sx = 0.0;
    _localparticle.sy = 0.0;
    _localparticle.sz = 1.0;

    _localparticle.p = 0.0;
    _localparticle.t = 0.0;

    int pp;
    pp = Monitor_nD_Trace (&(this_abs_storage.DEFS), &(this_abs_storage.Vars), &_localparticle);
  }

  // Book keeping
  this_abs_logger.abs_logger_extend_index = logger_conditional_extend_index;
  this_abs_logger.function_pointers.active_record_function = &record_to_perm_abs_1D_event;   // Assume no conditional
  this_abs_logger.function_pointers.inactive_record_function = &record_to_temp_abs_1D_event; // If an assume is present, these two pointers are switched
  // Temp to perm functions, and standard identifier
  // this_abs_logger.function_pointers.select_t_to_p = 1; // 1: temp_to_perm, 2: temp_to_perm_final_p // Not relevant for abs
  this_abs_logger.function_pointers.temp_to_perm = &write_temp_to_perm_abs_1D_event;
  this_abs_logger.function_pointers.temp_to_perm_final_p = &write_temp_to_perm_final_p_abs_1D_event;
  this_abs_logger.function_pointers.clear_temp = &clear_temp_abs_1D_event;

  // Initializing for conditional
  this_abs_logger.conditional_list.num_elements = 0;

  this_abs_logger.data_union.p_1D_event_abs_storage = &this_abs_storage;
  sprintf (this_abs_logger.name, "%s", NAME_CURRENT_COMP);
  sprintf (abs_logger_list_element.name, "%s", NAME_CURRENT_COMP);
  abs_logger_list_element.component_index = INDEX_CURRENT_COMP;
  abs_logger_list_element.abs_logger = &this_abs_logger;

  struct pointer_to_global_geometry_list* global_geometry_list = COMP_GETPAR3 (Union_init, init, global_geometry_list);
  struct pointer_to_global_abs_logger_list* global_specific_volumes_abs_logger_list = COMP_GETPAR3 (Union_init, init, global_specific_volumes_abs_logger_list);
  // In order to run the logger at the right times, pointers to this logger is stored in each volume it logs,
  //  and additionally for each available process. If a process is not logged, the pointer is simply not stored.
  int process_index;
  // Need to find the volumes for which the processes should have a reference to this logger
  if (target_geometry && strlen (target_geometry) && strcmp (target_geometry, "NULL") && strcmp (target_geometry, "0")) {
    // Certain volumes were selected, find the indices in the global_geometry_list
    manual_linking_function_abs_logger_volumes (target_geometry, global_geometry_list, &accepted_volumes, NAME_CURRENT_COMP);
    // Add this logger to the global_specific_volumes_logger_list (so that conditionals can affect it)
    add_element_to_abs_logger_list (global_specific_volumes_abs_logger_list, abs_logger_list_element);

    for (loop_index = 0; loop_index < accepted_volumes.num_elements; loop_index++) {
      target_volume = global_geometry_list->elements[accepted_volumes.elements[loop_index]].Volume;
      // Add an element to its abs_logger list

      add_initialized_abs_logger_in_volume (&target_volume->abs_loggers);
      target_volume->abs_loggers.p_abs_logger[target_volume->abs_loggers.num_elements - 1] = &this_abs_logger;
    }
  } else {
    // Send to global_all_volumes_logger_list
    // Here there is no system for selecting processes as well
    struct pointer_to_global_abs_logger_list* global_all_volume_abs_logger_list = COMP_GETPAR3 (Union_init, init, global_all_volume_abs_logger_list);
    add_element_to_abs_logger_list (global_all_volume_abs_logger_list, abs_logger_list_element);
  }
 %}

TRACE
%{
%}

SAVE
%{
  Monitor_nD_Save (&(this_abs_storage.DEFS), &(this_abs_storage.Vars));
%}

FINALLY
%{
  /* free pointers */
  Monitor_nD_Finally (&this_abs_storage.DEFS, &this_abs_storage.Vars);
  if (bufsize) {
    printf ("Virtual_output: %s: Saved %llu events (from buffer) in file %s\n", NAME_CURRENT_COMP, this_abs_storage.Vars.Nsum, this_abs_storage.Vars.Mon_File);
    if (bufsize < this_abs_storage.Vars.Nsum)
      printf ("WARNING         When using this source, intensities must be multiplied\n"
              "                by a factor %g\n",
              (double)this_abs_storage.Vars.Nsum / (double)bufsize);
  } else
    printf ("Virtual_output: %s: Saved %llu events (all) in file %s\n", NAME_CURRENT_COMP, this_abs_storage.Vars.Nsum, this_abs_storage.Vars.Mon_File);

  // Remember to clean up allocated lists
  if (this_abs_storage.temp_abs_1D_event_data.allocated_elements > 0)
    free (this_abs_storage.temp_abs_1D_event_data.elements);

  if (accepted_processes.num_elements > 0)
    free (accepted_processes.elements);
  if (accepted_volumes.num_elements > 0)
    free (accepted_volumes.elements);
%}

MCDISPLAY
%{
  Monitor_nD_McDisplay (&(this_abs_storage.DEFS), &(this_abs_storage.Vars));
%}

END