Because now there is a case when we want to open in appending mode: in
program `inst_eddies`.

Than ks to commit 5ff9e1d2, we are reverting in part commits e1aa5bcc and
fda1e6cd.

Remove `shpc_create` from use list in main program `test_overlap`. It
is no longer needed since commit 50d2f596.

Write file `node_id_param.json` from programs `test_overlap` and `eddy_graph`.

Write node indices instead of dates and eddy indices in
edgelist. Compute `e_overestim` from `ishape_last`. Remove header
lines of edgelist. See commit 3370733a. Replace argument d of procedure
overlap by arguments `e_overestim` and k.

Remove component `number_eddies` of derived type snapshot. It was the
same as `number_vis_extr` since there are no interpolated eddies any longer.

This is a big change, a big simplification. Creating interpolated
eddies was the way of Alexis Chaigneau. Rémi L. thinks it is no longer
useful.

So remove procedure `init_interpolated_eddy`; do not create SHPC for
interpolated eddies in programs `eddy_graph`, `test_overlap` and
`test_write_overlap`; remove argument `hshp_interp` of procedure
overlap; remove arguments `hshp_interp`, m, cyclone, `coord_extr_1`,
`ssh_extr_1`, `coord_extr_2` and `ssh_extr_2` of procedure
`write_overlap`.

Redefine `k_test_[12]` as date indices (0-based) instead of dates.

Follow-up to commit 3b68dd5.

To ease use of call with keywords.

Because variables in `grid_nml` should be all defined in the input file.

We now impose that all eddies in an SHPC have the same
orientation. Remove field `extr_cycl` from the derived type shpc and
add field cyclone to shpc. When reading an eddy, give it the
orientation of its SHPC. Add argument cyclone to procedure
`shpc_create`. Create a file `orientation.txt` in each SHPC. When
writing an eddy, check that its orientation matches that of the SHPC.

Rename triplet to collection, `shp_tr` to shpc, shpt to shpc in
comments, identifiers and file names.

We are reverting commits 35fad1b7 and df2b397d because we want the
program `eddy_graph.sh` to read an SHPC containing a single
orientation.

Do not print arrays.

Also split the tests, Fortran source files, Python files and JSon
files. Keep at the top level the files used in both `Inst_eddies` and
Overlap.

Motivations for the split:

- The top directory contained many files.

- It may be useful to compile only one of the two sub-projects. For
example, only `Inst_eddies` on Ciclad, where MPI 3 is not available.

Group `new_unit` and open in the same procedure, that we rename from
`set_unit_edge` to `open_edge_file`. This removes the need for a
special version of `new_unit` and it is closer to the use of the
`new_unit` keyword in Fortran 2008.

This makes the program `eddy_graph` heavier but it makes sense because
there can be no connection between the two graphs, and we need to make
the graphs as small as possible for large spatio-temporal domains.

`unit_edgelist` was just transmitted by procedure overlap from main
program unit to `write_overlap`. So now overlap does not see
`unit_edgelist`. Further motivation: we are going to split the edge
list file into two files.

Replace `loop_shp_append.py` by `loop_shp_tr_append.py`. Instead of
looping on years, we assume we are working on a single year. We could
call this script inside a loop on years in the shell. The advantage is
that we need to make fewer assumptions on the arborescence of
files. Also, we can make `loop_shp_tr_append.py` more general by
starting and ending at arbitrary days. We drop the timing that was in
`loop_shp_append.py`. We add the creation of file `ishape_last.txt`.

In script `shp_tr_append.sh`, assume that the directories contain
files `ishape_last.txt` and modify `ishape_last.txt` in the
destination directory.

In program `test_overlap`, read grid description from a file
`grid_nml.txt` in SHP triplet directory, instead of from standard
input. This is the same modification we made for program
`eddy_graph`. Modify input files accordingly.

Add main program `eddy_graph`.

Change order of dummy arguments of `dispatch_snapshot` and overlap.

Rename files and identifiers: change `"shp_triplet"` to `"shp_tr"`.

Add dummy argument `shp_triplet_dir` to procedure
`shp_triplet_create`. Motivation: program `eddy_graph` needs to create
one SHP triplet per MPI process.

Rename procedure `init_shapefiles` to `shp_triplet_create`.

Use the components for field identifiers of a variable of type
`shp_triplet` instead of storing these field identifiers in variables
of modules `init_shapefiles_m` and `read_field_indices_m`. The dummy
argument hshp of procedure `read_field_indices` becomes
`intent(inout)`.

Create derived type `shp_triplet`. Motivation: we need to manipulate
two triplets of shapefiles in program `eddy_graph`. Use everywhere a
variable of type `shp_triplet` instead of the three variables
`hshp_extremum`, `hshp_outermost`, `hshp_max_speed` when all three of
them appear. Rename character variable `shp_triplet` to
`shp_triplet_dir`.

In procedure `dispatch_snapshot`, rename dummy argument m to rank,
clearer.

Rename program `test_get_snapshot` to `test_get_dispatch_snap` and
make it call `dispatch_snapshot` instead of `send_snapshot`. The only
difference in result is that the program now writes files
`isolated_nodes.txt` and `number_eddies.csv`.

Check in program `test_overlap` that it is run on a single MPI process.

Prepare for a run of `test_get_snapshot` which receives a
snapshot. Generalize main unit `test_get_snapshot`: it is now
parallelized; it reads a date index from stdin; it sends a snapshot
from process 1 to process 0 if it is run with 2 processes.

The logic of the overlap program will be that all processes access the
triplet of input shapefiles. So modify subroutine
`read_field_indices`: process 0 reads field indices and broadcasts
them. This implies that programs `test_overlap`, `test_read_snapshot`
and `test_read_eddy` use MPI.

Generalize `algorithm.py`.

In program `test_send_recv`, read input SHP triplet from command line
instead of requiring it to be present in the current directory with
the name `SHP_triplet_old`. Generalize `test_send_recv`: read
`ishape_last` from file. In `test_send_recv`, all processes must now
access the triplet of shapefiles since process 0 reads field
indices. For the sake of uniformity, read and broadcast k1 from
process 0.