Initialization

Constructing the systems

In the multisystem framework, it is important to detail how the various components are initialized. The top level system is created in main/run.F90 by calling the multisystem_basic_t constructor

  recursive function multisystem_basic_constructor(namespace, names, types, factory) result(system)
    type(namespace_t),            intent(in) :: namespace
    class(system_factory_abst_t), intent(in) :: factory
    character(len=128),           intent(in) :: names(:)
    integer,                      intent(in) :: types(:)
    class(multisystem_basic_t),   pointer    :: system

    integer :: is
    class(system_t), pointer :: sys

    PUSH_SUB(multisystem_basic_constructor)

    allocate(system)
    system%namespace = namespace

    ! No interaction directly supported by this system (but classes that extend
    ! it can add their own)
    allocate(system%supported_interactions(0))
    allocate(system%supported_interactions_as_partner(0))

    do is = 1, size(names)
      ! Create folder to store system files.
      ! Needs to be done before creating the system as this in turn might create subfolders.
      call io_mkdir(names(is), namespace=namespace)

      ! Create system
      sys => factory%create(namespace_t(names(is), parent=system%namespace), types(is))

      ! Add system to list of systems
      call system%list%add(sys)
    end do

    POP_SUB(multisystem_basic_constructor)
  end function multisystem_basic_constructor

which itself calls multisystem_basic_init() and multisystem_init().

Finally, multisystem_create_system() loops over the subsystems and calls the system factory to create each of them.

Initializing the propagators

The propagators for the system(s) are initialized in time_dependent_run_multisystem() by a call to systems%init_propagators(). As time_dependent_run_multisystem() is called with systems being of type multisystem_basic_t, this translates to a call to multisystem_init_propagator().

This routine parses the input for the propagator type, and then creates a propagator of the given type using the respective constructor.

Then, multisystem_init_propagator() loops over the subsystems, and calls system%propagator_init() for each.

In general (i.e. if the function is not overloaded by a derived class), systems use the function system_propagator_init():

system_propagator_init() parses the input file, looking for the variable TDSystemPropagator. Here it is important to remember the order in which the parser treats namespaces.

If the system is specified in the input file as:

%Systems
"System_A" | <type_A>
"System_B" | <type B>
%

the top-level multisystem will internally be called . and we have in total three namespaces:

.
./System_A
./System_B

The system%propagator_init() routines for System_A and System_B will first look whether TDSystemPropagator is defined in their respective namespace. If this is not the case, they will look for the variable in the parent namespace, which here is the global namespace ..