Content

1. Introduction
2. Files provided
3. Running a test example
4. Structure of the parameter files
5. Storing the EIRENE triangular grids in IMAS
   
   1. Structure of EIRENE files keeping the grid
   2. Presentation of EIRENE grid in GGD
   3. Module  triangular_grid_modile 
      1. Data types provided
      2. Methods provided 
   4. Module  triangular_grid_ids_io
      1. Data types provided
      2. Methods provided
6. EIRENE input wrapper
   1. Structure of EIRENE input files
   2. Module eirene_data_io
      1. Data types provided
      2. Methods provided 
   3. Module imas_data_io
   4. ???
   5. Main program files  save_input_main.f90  and  provide_input_main.f90
7. Things to be done

1. Introduction

The Fortran routines described herein are intended to become a part of interface between the code EIRENE and the IMAS data structure. In its current form, they write EIRENE input data (grid information and a restricted set of physical quantities defined on this grid) to IMAS and, vice versa, get these data back from IMAS in the native format. Thus, they are a wrapper providing (partly) an interface between IMAS and EIRENE.

In the future, the functions responsible for communication with IMAS could be incorporated to the code directly, but this will depend on the plans of the EIRENE team.

The structure of this document is as follows. Section 2 lists the files provided. Section 3 describes how to run a test example. Section 4 presents the parameter files controlling the wrapper programs. Section 5 describes the organization of the grid storage. In Section 6, the wrapper for the EIRENE input is described. Finally, the things to be done are outlined in Section 7.

2. Files provided

The files listed below can be found in the public directory ~g2yyakov/public/eirene/version0.9.

!!! To be updated

3. Running a test example

You can use the prepared data files (the files soledge3x.npco_char, soledge3x.elemente, soledge3x.neighbor, and the files with the suffix '.dat'). Admittedly, the dat-files have no physical sense and were created with the only aim to check the corectness of input/output operations. 

1. Copy the files to your directory. 
2. If you wish to test the programs with your own files, copy them to the same direcctory. Do not forget to put the correct names to the command file save_input.par.
3. Load the IMAS library by typing:
   module load imasenv/3.37.0    
4. Create the IMAS database entry:
   imasdb eirene 
5. Now you can compile the examples. Type
   make clean 
make save_input 
6. Run the program:
   ./save_input.exe 
   The program puts the grid stored in the files soledge3x.* and the content of the dat-files into the IMAS database  eirene .
7. Type
   make provide_input 
8. Run the program:
   ./provide_input.exe 
9. Compare the new files  eirene.*   with the original files  soledge3x.* and the original data files with the new files (their names end with the suffix '_input.dat').

4. Structure of the parameter files

The program save_input.exe takes parameters that control the work of the program from the file save_input.par. A template of this file is given below. 

! Parameters that control saving the EIRENE input to IMAS.
! Use '!' when inserting comment lines.
! You can add comments at the end of each line unless this line holds a text that may contain blanks (e.g., a description field).
! Do not change the order of the parameters.
!
eirene                                         <= IMAS database
10003                                         <= shot
1                                                <= run
'IDS created to test EIRENE input storage'     <= IDS comment
'Yurii Yakovenko'                          <= input provider
'once upon a time'                       <= creation date
!!! grid data
"SN"                                         <= grid name
4                                              <= grid index in dictionary (single null)
"EIRENE grid for single null configuration"  <= grid description
"primary_standard"                 <= poloidal space name
"primary poloidal triangular grid" <= poloidal space description
soledge3x.npco_char                <= grid node file
soledge3x.elemente                 <= grid triangle file
soledge3x.neighbors                <= grid neighbor file
!!! Physical quantities
bx.dat       <= bx file
by.dat       <= by file
bz.dat       <= bz file
Btotal.dat   <= Btotal file
vx.dat       <= vx file
vy.dat       <= vy file
vz.dat      <= vz file
Te.dat       <= Te file
!!! Ion physical quantities
2           <= Number of ion species
! Ion species 1
D  2  1  1  <= label, mass, Z_ion, Z_element
TD.dat      <= temperature file
nD.dat      <= density file
! Ion species 2
T  3  1  1  <= label, mass, Z_ion, Z_element
TT.dat      <= temperature file
nT.dat      <= density file

A tempalate of the file provide_input.par that controls the program provide_input.exe is as follows:

! Parameters that control saving the EIRENE input to IMAS.
! Use '!' when inserting comment lines.
! You can add comments at the end of each line.
! Do not change the order of parameters.
!
eirene                       <= IMAS database
10003                       <= shot
1                               <= run
input.dat                  <= generic suffix
!!! grid data
eirene.nodes                <= grid node file
eirene.triangles            <= grid triangle file
eirene.neighbors          <= grid neighbor file
!!! Physical quantities
bx_input.dat      <= bx file
by_input.dat      <= by file
bz_input.dat      <= bz file
BF_input.dat      <= total B file
vx_input.dat      <= vx file
vy_input.dat      <= vy file
vz_input.dat      <= vz file

5. Storing the EIRENE triangular grids in IMAS

The Fortran routines described herein take files containing the description of a triangular grid in native EIRENE format and store this grid in an IMAS IDS; on the other hand, they extract a stored grid description from IMAS and provide it in EIRENE format. At present, these routines have been tested only with the IDS's  edge_profiles and equilibrium.

The grid is stored in the IMAS subsystem called GGD (General Grid Description). This subsystem consists of two data sub-trees available in most IMAS IDS:  grid_ggd  and  ggd  .  The former contains the description of the grid itself; the latter, all quantities given with reference to this grid (for, value of electron temperature at all grid nodes, values of energy flux at all nodes at the divertor surface etc.). A more detailed description will be given in section 5. 

The files provided are intended to support storing triangular 2D grids in the  grid_ggd  structure. In the future (if required), they can be upgraded to support work with 3D grids consisting of a triangular 2D grid in the poloidal plane and a grid in the toroidal direction.

5.1. Structure of EIRENE files keeping the grid

There are three files describing the triangular grid used in EIRENE.

The file defining the grid nodes and their coordinates (soledge3x.npco_char in the provided example) starts with the number of nodes in the line 1. The rest of lines contain 3 number each: 
node index, R (or X) coordinate (cm), Z (or Y) coordinate (cm). 

The file defining the triangles in terms of its vertices (soledge3x.elemente  in the provided example) has the following structure. The line 1 contains the number of triangles. Each following line contains 4 integers:
triangle index, index of vertex 1 (in the grid node list), index of vertex 2, index of vertex 3.

The file describing the boundaries and neighbours of the triangles in terms of its vertices (soledge3x.neighbor  in the provided example) has the following structure. The line 1 contains the number of triangles. Each following line contains 12 integers:
triangle index, N₁, S₁, M₁, N₂, S₂, M₂, N₃, S₃, M₃,  ixtri  ,  iytri .

Here N_i  is the index of the neighbouring triangle on side i, S_i  is the index of this side in the triangle N_i, M_i  is the ‘material property’ of the side i,   ixtri  and  iytri  are not used now (they are zeros in this example). Note that side 1 connects vertices 1 and 2; side 2, vertices 2 and 3; side 3, vertices 3 and 1. The material property (MP) is an index referring to a surface model defined in the main EIRENE file. In particular, MP is 0 for transparent (i.e., internal) grid edges. The MP of boundary edges can have different positive values. In the provides example, there are boundary edges with MP = 1, 2, 3.

5.2. Presentation of EIRENE grid in GGD

We begin with brief overview of general principles of presentation of grids in the  grid_ggd  structure.

We will follow the terminology of the GGD manual. The IMAS data dictionary is a hierarchical tree-like structure consisting of substructures. The following terms will be used:

• A node is any element of the tree.
• A simple node is a regular single node.
• An array of structures node (AOS) is a 1D array of structures under the same node label.
• A leaf is and endpoint of the tree. It holds data in specified format.
• The parent of a node is the element one level above this node.
• A child of a node is an element one level below this node.
• A sibling of a node is a node having the same parent.

First of all,  grid_ggd  is AOS whose elements correspond to different time slices of the IDS. If the grid does not depend on time, this array can contain only one element.

Each element of  grid_ggd  has (inter alia) two children AOS’s: spaces and grid subsets.

The spaces are used to contain the description of geometric objects constituting the grid, including their location in space. Let us consider a rectangular grid in 2D space as an example. To describe it, we can introduce one 2D space, provide the coordinates of all nodes and then describe the other grid elements (edges and cells) in terms of the nodes they consist of. However, it may be easier to choose another way. We can organize two 1D spaces, put the nodes along each coordinate and (if required) describe edges connecting these nodes.

It seems that for EIRENE in 3D geometry, it will be worthwhile to introduce 2 spaces: a 2D space in the poloidal plane and a 1D space in the toroidal direction. At present, only the poloidal 2D space is implemented.

The main child of each element of the  space  AOS is the  objects_per_dimension   AOS, each element of this AOS having only one child – the  object  AOS.

The element  objects_per_dimension(1)  contains information about the 0D objects of the space – the grid nodes. In each element of the  object   AOS, only one child – the  geometry(:)  real array containing the spatial coordinates of the node – is actually filled.

The 2^nd  and 3^rd  elements of  objects_per_dimension   hold information about 1D and 2D objects, respectively. For each 1D object (edge), we store the indices of the 2 nodes that the edge connects. They are stored in the  nodes(:)  child of each object. For a 2D object (triangle), we fill its children nodes(:) (with 3 elements) and boundary.  In the AOS  boundary, we fill the  index   child leaf (the index of the bounding edge) and one element of the  neighbours  child AOS (the index of the neighbouring triangle).

Each grid subset is an arbitrary set of grid elements of the same dimensionality. For examples, all grid nodes, all grid edges, all grid cells, all boundary grid edges, all cells situated in SOL can be examples of subsets. Each subset provided in the  grid_ggd  branch can be used in the  ggd  branch of the IDS in order to save a distribution of some physical quantity on this subset. For example, if we have organized the subset of all boundary edges in 2D, we can save in  ggd  the flux of particles through these edges as a 1D array. By giving a reference to this grid subset, we establish relation between the flux values and the edges.

To describe a subset, we can refer to objects from several spaces. Let us consider again the example of a 2D rectangular grid represented via two 1D grid spaces. The subset of all grid nodes can be organized as follows. The  grid_subset  AOS has a child element, holding information about all subset elements. In our case, the elements are the grid nodes. Each node can be described as a combination of one node of the x-grid and one node of the y-grid. So, each element in the  element  AOS has the only child – the  object  AOS. Each element of the  object  AOS has three leaves:  space   (the index of the space from which it is taken),  dimension   (its dimensionality index), and  index  (its index in the list of objects of this dimensionality). In our case, the elements are grid nodes. Each node (element) can be described as a combination of one node of the x-grid (0-dimensional object of the x-space) and one node of the y-grid (0-dimensional object of the x-space).

The subsets can be distinguished by their identifiers. The  identifier  node has three leaves:

1. name  contains the name given to the subset.
2. index  contains the integer identifier given to the subset (the list of standard integer identifiers can be found in the GGD manual).
3. description  contains a verbose description.

For the triangular EIRENE grid, the following subsets are created (this list can be extended if required or shortened if some subsets are not needed):

1. Subset of all nodes in the poloidal plane (the subset name is  'pol1', the integer identifier is 1).
2. Subset of all edges in the poloidal plane (the subset name is  'pol2', the integer identifier is 2).
3. Subset of all 2D cells (triangles) in the poloidal plane (the subset name is  'pol3').
4. Several subsets of edges with a certain MP in the poloidal plane (the subset names are  'MPnnnn', where nnnn is the material property value).
5. Special subset with no objects for storing averages in  ggd_fast  (the subset name is 'average').
6. Subset of all nodes in 3D space. 
7. Subset of all 3D cells (trigonal prisms).

At present, only items 1-4 of this lists are implemented.

5.3. Module triangular_grid_module

The module contains a data type for storing the information about all elements of a triangular grid and a library of methods (subroutines and functions). The methods solve the following tasks:

1. Reading and writing files in the EIRENE format
2. Checking the grid description for sanity
3. Building the missing parts of the information from available parts

The last item is important because the information set in the EIRENE files and the information set in GGD are different. In particular, the EIRENE files do not contain information about edges.

The module depends on the IMAS module  ids_types   (uses the constant  IDS_real  – the kind of real variables in IMAS).

5.3.1. Data types provided

The following data types are provided:

type triangular_grid
    type(coordinates_2d), allocatable, dimension(:) :: vertex
    type(triangle_structure), allocatable, dimension(:) :: triangle
    type(edge_structure), allocatable, dimension(:) :: edge
end type triangular_grid

The type  triangular_grid  is intended for storing the description of a triangular grid, its components keeping information about the grid vertices, the grid cells (triangles), and the grid edges, respectively.

type coordinates_2d
    real(IDS_real) :: x, y
end type coordinates_2d

The type  coordinates_2d  is intended for storing the grid point coordinates in the poloidal plane.

type triangle_structure
    integer :: vertex(3)
    integer :: neighbor(3) = (/0,0,0/)
    integer :: neighbors_side(3) = (/0,0,0/)
    integer :: side(3)
    integer :: material_property(3)=(/0,0,0/)
    integer :: ixtri=0, iytri=0              
end type triangle_structure

The type  triangle_structure  is intended for storing information about a grid triangle, including the information about neighbouring triangles available in the EIRENE files. The integer child array vertex holds indices of the triangle vertices in  triangular_grid%vertex. The child arrays  side  and  material_property  hold indices of the sides in  triangular_grid%edges   and their MPs, respectively (side 1 connects vertices 1 and 2; side 2, vertices 2 and 3; side 3, vertices 3 and 1). The child arrays  neighbor   and  neighbors_side   hold indices of the corresponding neighbouring triangles N_i  in  triangular_grid%triangle   and the indices of the separating edge in N_i. The child leaves  ixtri   and  iytri  will be used later (maybe).

type edge_structure
    integer :: vertex(2)           
    integer :: material_property=0 
    integer :: adjacent(2)=(/0,0/) 
end type edge_structure

The type  edge_structure  is intended for information about an edge. The integer child array  vertex   holds indices of the edge vertices in  triangular_grid%vertex  . The leaf  material_property   holds the MP of the edge. The child array  adjacent   holds the indices of the neighbouring triangles in  triangular_grid%triangle .

5.3.2. Methods provided

The module member routines are as follows:

• function read_eirene_grid 
  Read information about a triangular grid from EIRENE-format files and generate a list of grid edges;
• subroutine write_eirene_grid 
  Write information about a triangular grid into EIRENE-format files;
• subroutine provide_grid_object_lists 
  Provide lists of objects (nodes, edges and cells); nodes are characterized by their coordinates; edges and cells, by indices of nodes they consist of;
• subroutine arrange_neighbors 
  Build information about neighboring cells necessary the EIRENE file format; 
• subroutine build_edges
Fill the edge(:) child of the grid structure using the triangle child content;

• function give_edges_with_mat_property 
  Return the list of indices of edges with a given MP;
• function all_material_properties
  Provide list of all MP values available in the grid;
• subroutine deallocate_grid 
  Deallocate the structure child arrays.

Service routines:

• subroutine read_vertices 
  Read the coordinates of grid vertices from an EIRENE-format file.
• subroutine read_triangles 
  Read indices of the vertices that form each grid triangle from an EIRENE-format file.
• subroutine read_neighbors 
  Read information on the neighbours of each grid triangle from an EIRENE-format file, putting it to the substructure grid % triangle.
• subroutine write_vertices 
  Write the coordinates of grid vertices into an EIRENE-format file.
• subroutine write_triangles 
  Write information on the vertices that form each grid triangle into an EIRENE-format file.
• subroutine write_neighbors 
  Write information on the neighbors of each grid triangle into an EIRENE-format file.
• subroutine find_neighboring_triangles 
  Given the index of a vertex grid % vertex, the subroutine finds the indices of all triangles containing this vertex.
• integer function find_side 
  Given two vertex indices and a triangle structure, the function returns the index of the edge consisting of these vertices in the triangle (0 when the edge does not belong to the triangle).
• subroutine write_edges 
  Write grid edges to a file.
• subroutine check_edges 
  Sanity check: The subroutine checks if all edges that have both adjacent triangles have material_property/=0 and vice versa.
• subroutine check_vertices 
  Sanity check: The subroutine checks if every grid vertex belongs to a triangle.
• subroutine grid_statistics 
  Print grid statistics.
• integer function neighboring_triangle_index 
  The function returns the index of a triangle neighoring with a reference triangle. The neighbor index must be larger than the reference triangle index. When there is no such a triangle, the function returns 0.
• integer function edge_index 
  Return the index of an edge consisting of two given vertices (0 when there is no such edge).

Detailed interface of the methods:

function read_eirene_grid (coord_file, triangles_file, neighbors_file, do_tests, io_unit) result (grid)

Read information about a triangular grid from EIRENE-format files and generate a list of grid edges (using the method  build_edges).

subroutine write_eirene_grid (grid, coord_file, triangles_file, neighbors_file, do_tests, io_unit)

Write information about a triangular grid into EIRENE-format files;

subroutine provide_grid_object_lists (grid, coordinates, edge_connect, cell_connect)

Given a grid stucture, the subroutine provides three arrays:

• coordinates , real 2D array containing  the coordinates for all grid nodes;
• edge_connect , integer 2D array containing indices of vertices for all edges;
• cell_connect , integer 2D array containing indices of vertices for all cells (triangles).

This subroutine is no longer used in the module  triangular_grid_ids_io.f90 .

subroutine arrange_neighbors (grid)

Process a grid structure taken from IMAS, filling up the missing components of  grid%triangle  (information about neighbouring edges and triangles).

subroutine build_edges (grid)

Process a grid structure, building the missing substructure  grid % edge . The order of the edges in the substructure is as follows: side 1 of triange 1, side 2 of triange 1, side 3 of triange 1, side 1 of triangle 2 (if not accounted for earlier), side 2 of triangle 2 (if not accounted for earlier), and so on.

function give_edges_with_mat_property (grid, mat_property)

Return a list of edges with a given value of MP.

subroutine deallocate_grid (grid)

Deallocate all grid components.

For the description of the service routines (some of them are no longer used), see comments in the module file.

5.4. Module  triangular_grid_ids_io

The module contains routines that support writing a grid having the  type(triangular_grid)  form to IMAS IDS's and, vice versa, reading a grid from IMAS and putting it into the type(triangular_grid)  form. It depends on the module  triangular_grid_module   and the IMAS modules  ids_schemas   and  ids_routines .

At present, it is assumed that both input and output of EIRENE represent a steady state. Therefore, only one time slice is organized for both GGD data structure and the GGD grid.

At present, only one grid space is arranged: a two-dimensional poloidal grid space holding a triangular grid. However, the routines of this modules are organized in a way that should facilitate adding additional spaces (most probably, a 1D toroidal space) if required. When the poloidal grid is recovered from an IDS, it is taken from the space having the identifier index equal to 1 (see the function get_grid_objects).

5.4.1.  Data types provided

    type grid_control_panel
        type(ids_identifier_dynamic_aos3) :: grid_identifier
        character(len=ids_string_length) :: poloidal_space_name, poloidal_space_description
        character(len=ids_string_length) :: node_file, triangle_file, neighbor_file
        integer :: grid_index = 1             ! Use grid_ggd in time slice 1
        integer :: ggd_index = 1              ! Use ggd in time slice 1
        ! The following fields are not used when getting the grid from IDS
        integer :: grid_dictionary_index
        !! Allocation of IMAS grid space for EIRENE triangular grid
        integer :: nSpaces = 1                ! Total number of GGD spaces;
                                                          ! may change if toroidal coordinate is added
        integer :: eirene_space_index = 1     ! May change if toroidal coordinate is added
        integer :: Ngrid_slices = 1                 ! Number of grid_ggd slices to be allocated
        integer :: Nggd_slices = 1                 ! Number of ggd slices to be allocated
    end type grid_control_panel

The structure type grid_control_panel is intended for holding the control parameters taken from a command file. These parameters determine how the EIRENE triangular grid is saved in / recovered from an IMAS IDS.

5.4.2.  Methods provided

The module contains the following routines:

• get_grid_controls_for_input_saving
Get from the command file the parameters that control saving the EIRENE grid to an IMAS database that is to hold an EIRENE input.

• get_grid_controls_for_input_fetching 
  Get from the command file the parameters that control extracting the EIRENE grid from an IMAS database holding an EIRENE input.
• get_triangular_grid_from_ids 
  Read a triangular grid from an IDS (not 'equilibrium'), put it into a  type(triangular_grid)-structure, and build the missing parts of the structure.
• get_triangular_grid_from_equilibrium
  Read a triangular grid from the 'equilibrium' IDS, put it into a  type(triangular_grid)-structure, and build the missing parts of the structure.
• get_grid_objects
  Get objects from the space holding a triangular grid and put them into a type(triangular_grid)-structure.
• arrange_material_properties
  Get information about the material properties of grid edges from IDS and add it to the type(triangular_grid)-structure holding the grid description.
• put_eirene_grid_to_ids 
  Save a triangular grid given as a  type(triangular_grid)-structure into a grid_ggd AoS element (not applicable to the 'equilibrium' IDS).
• put_eirene_grid_to_equilibrium
  Save a triangular grid given as a  type(triangular_grid)-structure into a grid_ggd AoS element (intended for the 'equilibrium' IDS).
• arrange_grid_space
  Create the 'space' AoS of grid_ggd.
• arrange_triangular_grid_space 
  Put a triangular grid given as a  type(triangular_grid)-structure to a desired  grid_ggd  space.
• arrange_subsets
  Create the 'subset' AoS.
• arrange_standard_2d_subset 
  Arrange a "standard" subset in the poloidal 2d space (subset of all nodes, all edges, or all triangular cells).
• arrange_mat_property_subset 
  Arrange a subset of edges with a certain value of MP.
• arrange_subset_for_averages
  Arrange a special single-element subset for storing averages.

Detailed description of the methods:

function get_grid_controls_for_input_saving (io_unit) result (grid_controls)

Prepare the control parameters for saving an EIRENE grid to an IMAS database that is to hold an EIRENE input. The control parameters are taken from a command file.

function get_grid_controls_for_input_fetching (io_unit) result (grid_controls)

Prepare the control parameters for extracting an EIRENE grid from an IMAS database holding an EIRENE input. The control parameters are taken from a command file.

function get_triangular_grid_from_ids (grid_ggd) result (eirene_grid)

Read data about a triangular grid from a given space of GGD grid, put it into a  type(triangular_grid)-structure and call the subroutines  arrange_material_properties  (from this module) and  arrange_neighbors   (from  triangular_grid_module) to build the missing parts of the structure. This function is not applicable to the grid stored in the 'equilibrium' IDS (because the type of the structure used for storing the GGD grid in this IDS is peculiar). To extract the grid from the 'equilibrium' IDS, use the function get_triangular_grid_from_equilibrium.

function get_triangular_grid_from_equilibrium (grid_ggd) result (eirene_grid)

Read data about a triangular grid from a given space of GGD grid, put it into a  type(triangular_grid)-structure and call the subroutines  arrange_material_properties  (from this module) and  arrange_neighbors   (from  triangular_grid_module) to build the missing parts of the structure. This function is applicable only to the grid stored in the 'equilibrium' IDS (because the type of the structure used for storing the GGD grid in this IDS is peculiar). To extract the grid from another IDS, use the function get_triangular_grid_from_ids.

function get_grid_objects (space) result (eirene_grid)

The function returns a type(triangular_grid)-structure, which is partly filled with information read from the GGD grid space having the identifier index equal to 1 (i.e., being the 'primary grid space'). The function takes as a parameter the AoS of all grid spaces.

subroutine arrange_material_properties (eirene_grid, subsets)

Get information about the MPs of grid edges from IDS and add it to the type(triangular_grid)-structure holding the grid description. This information is stored in GGD in the form of subsets uniting the edges with certain values of the MP.

subroutine put_eirene_grid_to_ids (eirene_grid, grid_ggd, nSpaces, eirene_space_index, grid_identifier, eirene_space_name, eirene_space_description)

Place a grid into a given  grid_ggd  structure by allocating the space AOS with a given number of grid spaces, putting a triangular grid given as a  type(triangular_grid)-structure into a desired element of the  space  AOS, and organizing the necessary grid subsets. This subroution cannot be used for putting a grid into the 'equilibrium' IDS (because the type of the structure used for storing the GGD grid in this IDS is peculiar). To put the grid into the 'equilibrium' IDS, use the function put_eirene_grid_to_equilibrium.

subroutine put_eirene_grid_to_equilibrium (eirene_grid, grid_ggd, nSpaces, eirene_space_index, grid_identifier, eirene_space_name, eirene_space_description)

Place a grid into a given  grid_ggd  structure by allocating the space AOS with a given number of grid spaces, putting a triangular grid given as a  type(triangular_grid)-structure into a desired element of the  space  AOS, and organizing the necessary grid subsets. This subroution can be used only for putting a grid into the 'equilibrium' IDS (because the type of the structure used for storing the GGD grid in this IDS is peculiar). To put the grid into another IDS, use the function put_eirene_grid_to_ids.

function arrange_grid_spaces (grid, nSpaces, eirene_space_index, eirene_space_name, eirene_space_description) result (spaces)

Place a grid into a given  grid_ggd  structure by allocating the space AOS with a given number of grid spaces, putting a triangular grid given as a  type(triangular_grid)-structure into a desired element of the  space  AOS, and organizing the necessary grid subsets. This subroution can be used only for putting a grid into the 'equilibrium' IDS (because the type of the structure used for storing the GGD grid in this IDS is peculiar). To put the grid into another IDS, use the function put_eirene_grid_to_ids.

function arrange_triangular_grid_space (grid, space_name, space_description) result (space)

Create a GGD space and put the objects (nodes, edges, and cells) of an EIRENE triangular grid there. The information about grid objects is taken from a  type(triangular_grid)-structure.

function arrange_subsets (eirene_space, eirene_space_index, grid) result (subsets)

Create a GGD space and put the objects (nodes, edges, and cells) of an EIRENE triangular grid there. The information about grid objects is taken from a  type(triangular_grid)-structure.

subroutine  arrange_standard_2d_subset(subset, space, space_index, dimensionality, subset_id)

Arrange a "standard" subset in the poloidal space – a subset of all nodes, edges, or triangular cells (depending on the dimensionality, 1, 2, or 3, respectively). The subset gets the name 'poln', where n is the dimensionality.

subroutine  arrange_mat_property_subset (subset, space, space_index, grid, mat_property, subset_id)

Arrange a subset for edges with a certain value of MP. The subset gets the name 'MPnnnn', where nnnn is the MP value.

subroutine  arrange_subset_for_averages (subset, subset_id)

Arrange a special subset for storing 2d averages.  The subset gets the name 'average'.

6. EIRENE input wrappers

Now the subroutines are united in wrapper programs, but, if desired, they can be incorporated into the code. Only a part of input quantities is now processed. ?????????

6.1. Structure of EIRENE input files

??????????

6.2.  Module eirene_data_io

This module provides tools for dealing with files containing EIRENE input data.

6.2.1.  Data types provided

type eirene_data
    real(ids_real), allocatable :: main_part(:)
    real(ids_real) :: average
    real(ids_real), allocatable :: extra_data(:) ! To be implemented yet
    logical :: extra_data_present                ! Shows if extra_data is filled
end type eirene_data

This type is intended for storage ?????????????????

6.2.2.  Methods provided

The module contains the following routines:

• deallocate_data_set
• read_quantity_from_file
• write_quantity_to_file

6.3. Module imas_data_io

The module contains???

6.4. Module edge_profiles_io

?????

6.5. Module equilibrium_io

????????????

6.6. Module global_parameters

??????????????

6.7. Module imas_controls_for_input

????????????

6.8. Main files  save_input_main.f90   and  provide_input_main.f90 

The wrapper program contained in the file save_input_main.f90  performs the following actions:

• ????????      Initializes an instance of the  edge_profiles   IDS in the code memory with writing some mandatory fields.
• Writes some labels to the IDS.
• Allocates the  grid_ggd  AOS with only one element.
• Reads information about the grid from files and establishes grid edges, using the  read_eirene_grid  function (module  triangular_grid_module).
• Puts the grid information into the IDS, using the  put_triangular_grid_to_ids  subroutine (module  triangular_grid_ids_io).
• Creates the corresponding IDS in an IMAS database.
• Writes the IDS prepared in the code memory to the IMAS database and closes the database.

The program contained in the file  recover_grid.f90  performs the following actions:

• Opens the IMAS database by calling the subroutine  imas_open_env  .
• Reads the IMAS IDS  edge_profiles, using the subroutine  ids_get .
• Extracts the information about the grid from the IDS and puts it into a  type(triangular_grid)-structure, using the subroutine  get_triangular_grid_from_ids  (module  triangular_grid_ids_io).
• Writes the grid to EIRENE-format files (subroutine  write_eirene_grid, module  triangular_grid_module).
• Closes the IMAS database.

7. Things to be done

• Code parameters
• Extend the list of input quantities
• IMASification of EIRENE output
• Try to adjust the processing of exceptions to GSL practices (if worth while)