Simplify multiphase-field test setup

[CINTROINI]

Goal

Reduce the boilerplate needed to set up a multiphase-style test case (eg. N grains sharing a
mesh, one Problem per grain, transient/steady coupling).

What's needed

• Factory to build N SpatialDiscretization instances sharing a single mesh, instead of
  declaring each one by hand.
• Factory to build N BoundaryConditions from a shared boundary list.
• tests.hpp: allow using Transient and Steady schemes together in the same file without name
  clashes (currently using namespace SlothTransientXD and SlothSteadyXD together collide on
  PB, OPE, etc.).

Scope

• kernel/include/Sloth/tests.hpp
• kernel/include/Factory/ (new package)

[CINTROINI]

@tbarani

[CINTROINI]

Every test currently repeats the same block of type aliases by hand:

const int DIM = 2;
using FECollection = Test<DIM>::FECollection;
using VARS = Test<DIM>::VARS;
using VAR = Test<DIM>::VAR;
using PST = Test<DIM>::PST;
using SPA = Test<DIM>::SPA;
using BCS = Test<DIM>::BCS;
/////////////////////////
using OPE = TransientOperator<FECollection, DIM>;
using PB = Problem<OPE, VARS, PST>;

This can be replaced with:

using namespace Sloth2D;

OPE/PB become TransientOPE/TransientPB (or SteadyOPE/SteadyPB for steady problems),
so both schemes can coexist in the same file without redeclaring anything by hand.

For 1D and 3D, using namespace Sloth1D; and using namespace Sloth3D; work the same way.

[CINTROINI]

Beyond PDE-type problems (OPE/PB), the same aliases cover the other problem kinds,
independent of Steady/Transient: MPI_Problem via PB_MPI, Calphad_Problem via
PB_CALPHAD, and Property_problem via PB_PROPERTY — all already available through the
same using namespace SlothND.

[CINTROINI]

the usual unprefixed PDE aliases are still working.

[CINTROINI]

Likewise, building N SpatialDiscretization objects sharing a mesh currently means writing out each pointer by hand. For example, for periodic mesh,

SpatialDiscretization<FECollection, DIM> spatial("InlineSquareWithQuadrangles", 1,
                                                  refinement_level, std::make_tuple(NN, NN, L, L),
                                                  translations);

std::vector<SPA*> spatials{&spatial, &spatial, &spatial, &spatial, &spatial, &spatial,
                           &spatial, &spatial, &spatial, &spatial, &spatial, &spatial,
                           &spatial, &spatial, &spatial, &spatial, &spatial, &spatial,
                           &spatial, &spatial, &spatial, &spatial, &spatial, &spatial,
                           &spatial, &spatial, &spatial, &spatial, &spatial, &spatial};

This can be replaced with:

SPAS spatials =
    setPeriodicSpatialDiscretization(30, "InlineSquareWithQuadrangles", 1, refinement_level,
                                     std::make_tuple(NN, NN, L, L), translations, true);

or

auto spatials =
    setPeriodicSpatialDiscretization(30, "InlineSquareWithQuadrangles", 1, refinement_level,
                                     std::make_tuple(NN, NN, L, L), translations, true);

For non-periodic mesh, setSpatialDiscretization can be used.

[CINTROINI]

In the same way, boundary conditions for each spatial object can be generated directly from
spatials instead of being built one by one:

auto boundaries = {Boundary("lower", 0, "Periodic"), Boundary("right", 1, "Periodic"),
                   Boundary("upper", 2, "Periodic"), Boundary("left", 3, "Periodic")};
auto bcs = setBoundaryConditions(ngrains, spatials, boundaries);

Afterwards, multiphase-field variables can be defined as

std::vector<VARS> vars_grains;
  vars_grains.reserve(ngrains);
  for (int i = 0; i < ngrains; ++i) {
    auto vv = VAR(spatials[i], bcs[i], "phi_" + std::to_string(i), Glossary::PhaseField, 2,
                  AnalyticalFunctions<DIM>(vect_user_func[i]));
    vv.set_additional_information("phi");
    vars_grains.emplace_back(vv);
  }

[CINTROINI]

Finally, coupling N identical Problems (Coupling<PB, PB, ..., PB>) currently requires knowing
N at compile time to repeat the type by hand. Given a std::vector<PB>, setCoupling<N> builds
the Coupling<PB, ..., PB> (N times) directly:

constexpr int grains = 30;
std::vector<TransientPB> ac_pbs;
ac_pbs.reserve(ngrains);

...


auto cc = setCoupling<ngrains>("Multigrains", ac_pbs);

[CINTROINI]

All of these modifications are used inside the new test Studies/multigrains/test1_amr, which is similar to Studies/multigrains/test1 but simulates polycrystalline evolution with a partitioned algorithm and AMR.

[CINTROINI]

To simplify test setup further, auxiliary variables don't need to be passed to Problem's
constructor — they can be set afterwards via set_auxvariables:

pb.set_auxvariables(aux_ptrs);

where aux_ptrs is a std::vector<VARS*> (e.g. the other grains' Variables, for the current
grain's Problem in a partitioned multiphase-field setup).