Assume that a slice is in a directory
"{shpc_dir}/{orientation}/Slice_{slice}" where shpc_dir can be any
name, orientation is "Anticyclones" or "Cyclones" and slice is an
integer. Do not read or create any longer a file "orientation.txt" in
the slice directory. Add procedure `get_slice_dir`. Add dummy
arguments cyclone and slice to procedure `shpc_open`. Add dummy
argument slice to procedure `shpc_create`.

Rename procedure `write_snapshot` to `save_snapshot`.

Split derived type `shpc_slice_handler` into `shpc_slice_handler` and
`shpc_slice_meta out`. Do not mix what is necessary to open, create
and close, analogous to a logical unit, with what comes from reading
the files.

Create component `unit` for `ishape_last.txt` in derived type
`shpc_slice_handler`. Open, create and close `ishape_last.txt` at the
same time we open, create and close the shapefiles. So we use
`read_opcol` instead of `read_column` when we need to read
`ishape_last.txt`.

We are more clearly separating opening files and reading from them.

Since `NR_util` has been integrated into Jumble.

But reading from them is not here yet.

Since `shpc_open` is called by all processes, reading d0 and
`ishape_last` in `shpc_open` implies that we do not broadcast d0 and
`ishape_last`.

Since processes need d0 to allocate `ishape_last`.

Store `ishape_last` and first date in components of derived type
shpc. We then remove arguments `d_init` and `ishape_last` of procedures
`read_snapshot` and `get_snapshot`.

It was confusing to mix opening an SHPC with broadcasting some part of
the resulting shpc variable.

In procedure `get_snapshot`.

Note that we then have to declare `d_init` before `ishape_last` in
procedure `get_snapshot`.

Before reading `ishape_last`, because we are going to use `d_init` as
lower bound of `ishape_last`.

We are reverting commit e48b7f7e. I think I did not really appreciate
then that the number of days since 1950-1-1 is another date index. It
is clearer to use just one date index, which is in the dbf files. So,
in effect, we replace everywhere the old 0-based date index k by `k -
d_init`. Note that we no longer need argument `d_init` for procedure
`dispatch_snapshot` and we no longer need to write `d_init` to file
`node_id_param.json`. Note also that the value of every node index
changes by the amount `d_init * e_overestim`.

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

Do not create file `number_eddies.csv` in program `eddy_graph`. Since
there are no interpolated eddies any longer, the file
`number_eddies.csv` just contained the same information that is in
`ishape_last.txt` in the input SHPC. Remove argument
`unit_number_eddies` of procedure `dispatch_snapshot`.

Follow-up to commit 3b68dd5. A default value of 0 for k in main
program unit `test_get_dispatch_snap` now makes sense.

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

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.

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"`.

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.

Change order of dummy arguments of procedure `get_snapshot` to make it
more convenient to call with keywords. Rename dummy argument m to
rank, clearer.

Bug fix in `short_tests_.json`: run `test_read_snapshot` and
`test_overlap` with `mpiexec -n 1`, else the programs may not be able
to read standard input.

On our way to a generalization of script `filter.py`: use a function
to define the filter.

In script `plot_snapshot.py`, accept a triplet of shapefiles without
`ishape_last.txt`.

Add a test for program `test_get_snapshot` where one of the processes
does a reception in procedure `get_snapshot`.

Bug fix in main unit `test_get_snapshot`: we send and receive date k.

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.

First compilation and test of procedure `get_snapshot`. Change order
of dummy arguments of procedure `get_snapshot`: make it more
convenient for call with keywords. Replace dummy arguments periodic
and `dist_lim` by dummy argument copy. Add dummy arguments
`ishape_last` and k1. Promote `hshp_extremum`, `hshp_outermost`,
`hshp_max_speed` from local variables to dummy arguments.

In program `test_read_snapshot`, read input SHP triplet from command
line instead of requiring it to be present in the current directory
with the name `SHP_triplet_old`.

Remove directory `Tests/Input/Region_1/SHP_triplet`, which was not used.

Change of idea: make date index an intent in argument of procedure
`read_snapshot`. Replace dummy arguments `ishape_first` and scalar
`ishape_last` by k1 and array `ishape_last`. It is now the task of
`read_snapshot` to find the ishapes to read. This seems clearer.

Organize better the directory `Input`: create sub-directories for regions.

Big change: use SHP triplets that can contain several snapshots. So
program `test_overlap` reads a single SHP triplet. The dates that
`test_overlap` should read are now specified in the input
namelist. SHP triplet directory must now contain a file named
`contents.csv`. `test_overlap` reads `contents.csv` into variables k1
and `ishape_last`. So there is no longer any need to read the number
of entities in one of the shapefiles.

For each region, concatenate SHP triplets for dates 2006/01/01 and
2006/01/02.

Read namelist from process 0 in program `test_send_recv`: it is
simpler since it is the default setting of mpiexec and I do not see
any drawback.

In programs `test_read_snapshot` and `test_send_recv`, just hard code
for now the ishapes we want to read in the SHP triplet.

Generalize `read_snapshot`. Add dummy argments `ishape_first` and
`ishape_last`. This allows getting a snaphot from a triplet of
shapefiles containing several snapshots. Consequence: move the call to
`shp_get_info_03` from `read_snapshot` to `test_overlap`,
`test_read_snapshot` and `test_send_recv`.

Remove opening and closing of shapefiles from procedure
`get_snapshot`. Since a triplet of shapefiles can contain several
snapshots, we do not want to open and close the same shapefiles
several times from the same MPI process.

Pass argument copy to `read_snapshot` rather than arguments periodic
and `dist_lim`. Motivation: do not recompute copy at each call of
`read_snapshot`. `read_snapshot` is going to be called many times in
overlap program, with always the same value of copy. And we do not
need the values of periodic and `dist_lim` separately in
`read_snapshot`.

Complete `send_snapshot` and `recv_snapshot` by sending and receiving
an entire snapshot. So we need nlon, nlat and copy in `recv_snapshot`
to allocate `extr_map`. It is better to pass arguments nlon, nlat and
copy than sending and receiving the shape of `extr_map` with MPI, of
course, since the shape is the same for all snapshots. In program
`test_send_recv`, write the entire received snaphot.

Bug fix in `Tests/CMakeLists.txt`: several targets missed
`${netcdff_INCLUDE_DIR}`.

Create procedure `write_snapshot` from code in main program
`test_read_snapshot`, because we need to do this also in program
`test_send_recv`. Note the dissymmetry with `read_snapshot`, which
does not include the opening and closing of the shapefiles. That is
because we anticipate calling `read_snapshot` several times with the
same shapefiles in program overlap.

Change order of dummy arguments of procedure `write_extr_map`. More
convenient for calling it with keywords from `write_snapshot`.

We need the dummy version of EZMPI for sequential programs linking
with `Shapelib_03`.

Replace `include_directories` by `target_include_directories` in
`Tests/CMakeLists.txt`. Motivation: some targets do no use ezmpi. This
implies adding directories to `target_include_directories` for
`extraction_eddies`.

In `send_snapshot` and `recv_snapshot`, send and receive a whole
eddy. Read and write a snapshot in `test_send_recv`.

Use `SHP_triplet` instead of Snapshot for the name of the directory
containing the three shapefiles extremum, `outermost_contour` and
`max_speed_contour`. This is meant as a general name, analogous to a
new file type. Generally, the shapefiles may contain eddies at
different dates, not just a snapshot.