Navigation :

Factories

Octopus uses the so-called factory pattern to create instances of the systems and interaction classes. The abstract factory classes are introduced to avoid the problem of circular dependencies.

The function of the factories is to create an object of a (dynamically) given type and return a pointer to it. This is done by calling the respective constructors of the classes, of which an instance is to be created.

System factories

  type, abstract :: system_factory_abst_t
  contains
    procedure(system_factory_abst_create),     deferred :: create
  end type system_factory_abst_t

  type, extends(system_factory_abst_t) :: system_factory_t
  contains
    procedure :: create => system_factory_create         !< @copydoc system_factory_oct_m::system_factory_create
  end type system_factory_t

Definition of system_factory_create()

  recursive function system_factory_create(this, namespace, type) result(system)
    class(system_factory_t), intent(in) :: this       !< the system factory
    type(namespace_t),       intent(in) :: namespace  !< namespace of the system
    integer,                 intent(in) :: type       !< type of the system to create
    class(system_t),         pointer    :: system     !< pointer to newly created system

    integer :: n_systems, is, ic, iother
    type(block_t) :: blk
    character(len=128), allocatable :: names(:)
    integer, allocatable :: types(:)

    PUSH_SUB(system_factory_create)

    !%Variable Systems
    !%Type block
    !%Section System
    !%Description
    !% List of systems that will be treated in the calculation.
    !% The first column should be a string containing the system name.
    !% The second column should be the system type. See below for a list of
    !% available system types.
    !%Option electronic 1
    !% An electronic system. (not fully implemented yet)
    !%Option maxwell 2
    !% A maxwell system.
    !%Option classical_particle 3
    !% A classical particle. Used for testing purposes only.
    !%Option charged_particle 4
    !% A charged classical particle.
    !%Option dftbplus 5
    !% A DFTB+ system
    !%Option linear_medium 6
    !% A linear medium for classical electrodynamics.
    !%Option matter 7
    !% A matter system containing electrons and classical ions.
    !%Option dispersive_medium 8
    !% (Experimental) A dispersive medium for classical electrodynamics.
    !%Option multisystem 9
    !% A system containing other systems.
    !%Option ions 10
    !% An ensemble of classical charged particles.
    !%End
    select case (type)
    case (SYSTEM_MULTISYSTEM)

      ! Parse the input file to get the list of subsystems
      if (parse_block(namespace, 'Systems', blk) == 0) then

        n_systems = parse_block_n(blk)
        SAFE_ALLOCATE(names(1:n_systems))
        SAFE_ALLOCATE(types(1:n_systems))

        do is = 1, n_systems
          ! Parse system name and type
          call parse_block_string(blk, is - 1, 0, names(is))
          if (len_trim(names(is)) == 0) then
            call messages_input_error(namespace, 'Systems', 'All systems must have a name')
          end if
          do ic = 1, len(parser_varname_excluded_characters)
            if (index(trim(names(is)), parser_varname_excluded_characters(ic:ic)) /= 0) then
              call messages_input_error(namespace, 'Systems', &
                'Illegal character "' // parser_varname_excluded_characters(ic:ic) // '" in system name', row=is-1, column=0)
            end if
          end do
          call parse_block_integer(blk, is - 1, 1, types(is))

          ! Check that the system name is unique
          do iother = 1, is-1
            if (names(is) == names(iother)) then
              call messages_input_error(namespace, 'Systems', 'Duplicated system in multi-system', &
                row=is-1, column=0)
            end if
          end do

        end do
        call parse_block_end(blk)
      else
        call messages_input_error(namespace, 'Systems', 'Missing Systems block')
      end if

      system => multisystem_basic_t(namespace, names, types, this)

      SAFE_DEALLOCATE_A(names)
      SAFE_DEALLOCATE_A(types)

    case (SYSTEM_ELECTRONIC)
      system => electrons_t(namespace)
    case (SYSTEM_MAXWELL)
      system => maxwell_t(namespace)
    case (SYSTEM_CLASSICAL_PARTICLE)
      system => classical_particle_t(namespace)
    case (SYSTEM_CHARGED_PARTICLE)
      system => charged_particle_t(namespace)
    case (SYSTEM_DFTBPLUS)
      system => dftb_t(namespace)
    case (SYSTEM_LINEAR_MEDIUM)
      system => linear_medium_t(namespace)
    case (SYSTEM_MATTER)
      system => matter_t(namespace)
    case (SYSTEM_DISPERSIVE_MEDIUM)
      system => dispersive_medium_t(namespace)
      call messages_experimental('dispersive_medium', namespace=namespace)
    case (SYSTEM_IONS)
      system => ions_t(namespace)
    case default
      call messages_input_error(namespace, 'Systems', 'Unknown system type.')
    end select

    POP_SUB(system_factory_create)
  end function system_factory_create

Interaction factories

  type, abstract :: interactions_factory_abst_t
  contains
    procedure(interactions_factory_abst_create), deferred :: create
    !< @copydoc interactions_factory_abst_create
    procedure(interactions_factory_abst_options), deferred, nopass :: options
    !< @copydoc interactions_factory_abst_options
  end type interactions_factory_abst_t

  type, extends(interactions_factory_abst_t) :: interactions_factory_t
  contains
    procedure :: create => interactions_factory_create              !< @copydoc interactions_factory_create()
    procedure, nopass :: options => interactions_factory_options    !< @copydoc interactions_factory_options()
  end type interactions_factory_t

Definition of interactions_factory_abst_create_interactions()

Definition of interactions_factory_create()