Navigation :

Interactions

Work in progress!

Introduction

In physics, interactions are in general symmetric. However, the magnitude with which it affects the interaction partners can be very different. Also, the way the interactions have to be implemented can differ depending on the ‘‘direction’’ of the interaction.

A detailled description is given in the doxygen documentation of the interaction_oct_m module.

Abstract classes

`interaction_t`

Definition of interaction_t

  type, extends(interaction_surrogate_t), abstract :: interaction_t
    ! General information about the interaction
    type(iteration_counter_t)     :: iteration         !< Iteration counter storing the iteration at which the interaction was last updated.
    character(len=:), allocatable :: label             !< label of an interaction, used for debug and restart
    logical                       :: intra_interaction !< Is this an interaction of a system with itself?
    integer                       :: timing            !< parameter to determine if the interaction should use the couplings
    !!                                                    at the exact requested iteration or if retardation is allowed
    real(real64)                  :: energy !< Energy associated with the interaction.

    ! The interaction requires access to some quantities from a system to be evaluated.
    integer, allocatable :: system_quantities(:) !< Identifiers of the quantities needed from the system

    ! Information regarding the partner
    class(interaction_partner_t), pointer     :: partner => NULL()
    integer,                      allocatable :: couplings_from_partner(:) !< Identifiers of the quantities needed from the partner
    logical                                   :: partner_couplings_up_to_date = .false. !< Have the partner couplings been updated yet?

  contains
    procedure(interaction_calculate), deferred :: calculate
    procedure(interaction_calculate_energy), deferred :: calculate_energy
    procedure :: update => interaction_update !< @copydoc interaction_oct_m::interaction_update
    procedure :: update_partner_couplings => interaction_update_partner_couplings !< @copydoc interaction_oct_m::interaction_update_partner_couplings
    procedure :: restart_read => interaction_restart_read   !< @copydoc interaction_oct_m::interaction_restart_read
    procedure :: restart_write => interaction_restart_write !< @copydoc interaction_oct_m::interaction_restart_write
  end type interaction_t

This is the minimal data structure for interactions, which only contains information relating to partner A, who owns the interacion. In particular, the interaction has a list of quantities, which partner A needs to expose, so that the interaction can be calculated. The IDs for the exposed quantities are defined in the section Exposed Quantities.

Furthermore, this abstract type already contains the clock for the interaction, and defines the interfaces for the deferred update() and calculate() routines.

Abstract children

`force_interaction_t`

The next level of specialization of interaction, are all interactions which create a force on the partner. Here we only add the actual force vector, acting on the partner system.

Definition of force_interaction_t

`potential_interaction_t`

The next level of specialization of interaction, are all interactions which create a potential for the partner.

Definition of potential_interaction_t

`density_interaction_t`

The next level of specialization of interaction, are all interactions which create a potential for the partner.

Definition of density_interaction_t

Specific classes:

Specific interaction classes extend the abstract ones. The most important element they add to the abstract classes is the information about the quantities, required to calculate the interaction. In case of the system. owning the interaction (system A), it is sufficient to keep pointers to the data, stored in the system itself. Thr reason is that the interaction is always updated by the propagator of the system A. For the partner system (system B), however, the interaction keeps a copy of the exposed quantities. This allows the partner system to continue the propagation beyond the time for which the quantities are requested, which might happen if the two systems are using different time steps.

Ghost interaction

Definition of ghost_interaction_t

Gravity

Definition of gravity_t

Coulomb force

Definition of coulomb_force_t

Lorentz force

Definition of lorentz_force_t

Interaction factory

Instances of interaction_t or derived types are, like systems, generated using a factory.

Currently, the following interaction types are defined:


  integer, parameter, public :: &
    GRAVITY          = 1,       &
    LORENTZ_FORCE    = 2,       &
    COULOMB_FORCE    = 3,       &
    LINEAR_MEDIUM_TO_EM_FIELD = 4, &
    CURRENT_TO_MXLL_FIELD  = 5, &
    MXLL_E_FIELD_TO_MATTER   = 6,  &
    MXLL_B_FIELD_TO_MATTER   = 7,  &
    MXLL_VEC_POT_TO_MATTER   = 8,  &
    LENNARD_JONES            = 9

When using these system types, always use the parameters, and not their numerical values, as they might change over time.