With `target_sources` rather than referring to their path from another
directory.

Since `NR_util` has been integrated into Jumble.

Following updates of the libraries.

Following updates of the libraries.

In case we are a sub-project.

`read_eddy.f90`, `read_field_indices.f90` and `shp_tr_open.f90` will
become common to Overlap and `Inst_eddies` because they will be used
in `Inst_eddies/Tests/test_set_max_speed.f90`. So there are now enough
common files to justify a new directory.

Move Fortran source files used in tests of both parts, `Inst_eddies`
and Overlap, to directory Tests at root of repository.

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.

Motivation: we are going to split the edge list file into two files.

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

Missing libraries in `target_link_libraries`. This appears now because
some links are now declared private in the libraries.

Replace script `mkdir_nproc.sh` by script
`eddy_graph.sh`. `eddy_graph.sh` is a wrapper script for program
`eddy_graph`. It includes the creation of output directories that was
done by `mkdir_nproc.sh`. `mkdir_nproc.sh` was only used for program
`eddy_graph`. There was the need to automate the concatenation of
output files for a run with several MPI processes.

Add a test for `eddy_graph`.

Improve the handling of the NetCDF Fortran library in cmake files.
Add the configuration of `eddy_graph_in.sh`.

In main program `eddy_graph`, do not write title lines in files
`unit_number_eddies` and `unit_edgelist` because these files are
concatenated for all the MPI processes by `eddy_graph.sh`. So the
title lines are added by `eddy_graph.sh`.

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

Rename procedure `init_shapefiles` to `shp_triplet_create`.

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.

Add script for concatenation of triplets of shapefiles.

Generalize script `plot_snapshot.py` to read a single date in a
triplet of shapefiles containing several dates.

Bug fix in `Tests/CMakeLists.txt`: missing source file.

Include four dates in `Tests/Input/Region_1/SHP_triplet_noise`, in
preparation for a test with `test_get_snapshot`. Main unit
`test_nearby_extr` must then read the number of shapes for the first
date in `ishape_last.txt`.

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.

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

Simplify cmake files, taking advantage of improved packaging of
libraries. This also much simplifies the configuration process: the
user typically has only two directories to specify: `CMAKE_PREFIX_PATH` and
`fortrangis_INCLUDE_DIR`. Also `Shapelib_03` no longer depends on EZMPI,
since revision 129a0cc.

Add test for `test_send_recv`.

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

In procedures `recv_snapshot` and `send_snapshot`, use library EZMPI
instead of MPI directly.

Rename `receive_snapshot` to `recv_snapshot` for consistency with MPI
calls. In procedure `send_snapshot`, invert order of dummy arguments
tag and dest for consistency with MPI calls.

Fill in procedures `receive_snapshot` and `send_snapshot`. This is
just a beginning with part of an eddy. Add test program.

Rename `test_successive_overlap` to `test_overlap`: we will also use
it for non-successive overlap. Accordingly, add an input variable
`max_delta` and change the size of flow to `max_delta` + 1. We read
from snapshots `flow(1)` and `flow(max_delta + 1)`. For
`flow(2:max_delta)`, we only need to define the component
`number_eddies`.

Add options for the NAG compiler.

Replace `target_include_directories` by `include_directories` in
`Tests/CMakeLists.txt`. The file was becoming too long.

Remove unused items in use statements.

Bug fix in `Tests/Input/successive_overlap_region_5_nml.txt`: remove a comma.

Change order of dummy arguments of procedure
`write_overlap`. Motivation: call with keywords in
`test_write_overlap`.

Add main program `test_write_overlap` and corresponding tests in
`short_tests.json`.

New script `triplet_dump.sh`.

Add `.cmake` files. The idea is to have a build system independent of
the environment. This allows us to have a customized version of
`ConfigureCompilerFlags.cmake` without the `-ffpe-trap=invalid`
option.

Move the inner part of procedure overlap to a separate procedure
`write_overlap`. overlap was too complex with 6 nested constructs. The
downside is that the initialization of `e` is repeated for every
non-successive overlap. If necessary, we can later add an
initialization on first entry (but an initialization at declaration is
not possible). `write_overlap` has some consistency: all the arguments
are `intent(in)`, scalars or small vectors of intrinsic type, and
`write_overlap` only writes to files. All modifications to flow are
done outside of `write_overlap`.

Remove procedure `interpolate_eddy`. I realized that the longitude of
one of the overlapping eddies must be shifted. It seemed awkward to
pass variable m from overlap as an argument to
`interpolate_eddy`. Passing separately the useful components of
overlapping eddies made the procedure bulky, not worth creating for
three lines of computation.

As a consequence, inline the interpolation of eddies in procedure
overlap. An advantage is that part of the processing that was in
`interpolate_eddy` can migrate out of the interpolation loop.

As another consequence, remove program `test_interpolate_eddy` and
correponding test.

Upgrade procedure `candidate_overlap` to deal with non-successive
overlap. Add dummy argument delta.

Make the program `test_interpolate_eddy` more comfortable to use by
reading a directory on the command line.

Create main program `test_interpolate_eddy`. Add corresponding test in
`short_tests.json`. Add corresponding input files.

Changing my mind, `interpolate_eddy` only interpolates, it does not
write the interpolated eddy, this seems clearer. So it can be a
function instead of a subroutine and we call `write_eddy` from
overlap. We need to add arguments `hshp_extremum`, `hshp_outermost`
and `hshp_max_speed` to overlap. The main program
`test_successive_overlap` now has to create shapefiles.

Prepare for overlap of eddies at non-successive dates:

- add argument `delta_out` to procedure `candidate_overlap` (not yet
used);
- add procedure `interpolate_eddy` (empty for now);
- rename `successive_overlap` to overlap because the procedure will handle both
cases, successive dates and non-successive dates;
- generalize procedure overlap to handle delta between dates.

read_snapshot and successive_overlap instead of a named constant of
module successive_overlap_m.

Bug fix in main programs test_read_snapshot and
test_successive_overlap: take into account that step is in degrees.

eddies at date "j" in a new function candidate_overlap. This reduces
the number of nested constructs from 8 to 5. Incidentally, we can now
avoid defining needlessly polyline_1 if there is no candidate at date
"j". Also the function candidate_overlap should also be called by
non_successive_overlap.

Add argument periodic to procedure successive_overlap.

In main unit test_successive_overlap, pass to successive_overlap the
date subscript returned by read_snapshot instead of an arbitrary
value. Only print delta_in and delta_out if they are /= huge.

Tests/CMakeLists.txt. This is more concise since we can merge them
with target_sources.

Bug fix: missing source file successive_overlap.f90 for target
test_read_snapshot.