Navigation :

Startup

General Startup procedure of the Octopus Code

The flow chart for most calculations has many steps in common, most of them related to setting up the basic data structures of the code.

The ‘main’ program only performs tasks which are independent of the actual calculation and the physical system:

main/main.F90:

In a strongly simplified way, we have:

program main

  [...]

  ! "constructors":           ! start code components

  call global_init()               ! initialize the mpi, clocks, etc.
  call parser_init()               ! initialize the input parser
  call messages_init()             ! initialize the message system
  call walltimer_init()            ! initialize the timer module
  call io_init()                   ! initialize the I/O subsystem
  call calc_mode_par_init()        ! initialize parallelization strategy
  call profiling_init()            ! initialize and start the profiling system

  call run(inp_calc_mode)          ! pass control to the 'actual code' running the calculation

  ! "destructors":            ! stop code components in reverse order

  call profiling_end()
  call calc_mode_par_end()
  call io_end()
  call walltimer_end()
  call messages_end()
  call parser_end()
  call global_end()

end programme

The actual calculation is started from the routine run(), which initialized the data structures representing the actual system and calculation mode, before starting the corresponding calculation:

main/run.F90 defines the module run_oct_m:

This module does not contain own data (apart from constants).

Definition of run()

  subroutine run(namespace, calc_mode_id)
    type(namespace_t), intent(in) :: namespace
    integer,           intent(in) :: calc_mode_id

    type(partner_list_t)     :: partners !< structured (hierarchical) list of partners
    class(system_t), pointer :: systems  !< top level system (either electrons or multisystem_basic container)
    type(system_factory_t) :: system_factory
    type(interactions_factory_t) :: interactions_factory
    logical :: from_scratch
    integer :: iunit_out
    type(partner_iterator_t) :: iter
    class(interaction_partner_t), pointer :: partner

    PUSH_SUB(run)

    call messages_print_with_emphasis(msg="Calculation Mode", namespace=namespace)
    call messages_print_var_option("CalculationMode", calc_mode_id, namespace=namespace)
    call messages_print_with_emphasis(namespace=namespace)

    call calc_mode_init()

    if (calc_mode_id == OPTION__CALCULATIONMODE__RECIPE) then
      call pulpo_print()
      POP_SUB(run)
      return
    end if

    call restart_module_init(namespace)

    call unit_system_init(namespace)

    call accel_init(mpi_world, namespace)

    ! initialize FFTs
    call fft_all_init(namespace)

    if (calc_mode_id == OPTION__CALCULATIONMODE__TEST) then
      call test_run(namespace)
      call fft_all_end()
      call mpi_debug_statistics()
      POP_SUB(run)
      return
    end if

    ! Create systems
    if (parse_is_defined(namespace, "Systems")) then
      ! We are running in multi-system mode
      systems => system_factory%create(namespace, SYSTEM_MULTISYSTEM)
    else
      ! Fall back to old behaviour
      systems => electrons_t(namespace, generate_epot = calc_mode_id /= OPTION__CALCULATIONMODE__DUMMY)
    end if

    ! initialize everything that needs parallelization
    call systems%init_parallelization(mpi_world)

    ! Create list of partners
    select type (systems)
    class is (multisystem_basic_t)
      ! Systems are also partners
      partners = systems%list
      ! Add external potentials to partners list
      call load_external_potentials(partners, namespace)

      call load_external_waves(partners, namespace)

      ! Add lasers to the partner list
      call load_lasers(partners, namespace)

    type is (electrons_t)
      call partners%add(systems)
    end select

    ! Initialize algorithms (currently only propagators are supported)
    select type (systems)
    class is (multisystem_basic_t)
      select case (calc_mode_id)
      case (OPTION__CALCULATIONMODE__GS)
        call systems%new_algorithm(minimizer_factory_t(systems%namespace))
      case (OPTION__CALCULATIONMODE__TD)
        call systems%new_algorithm(propagator_factory_t(systems%namespace))
      end select
    end select

    ![create_interactions] !doxygen marker. Dont delete
    ! Create and initialize interactions
    !
    ! This function is called recursively for all subsystems of systems.
    ! If systems is a multisystem_basic_t container, the partners list contains all subsystems.
    call systems%create_interactions(interactions_factory, partners)
    ![create_interactions]

    select type (systems)
    class is (multisystem_basic_t)
      ! Write the interaction graph as a DOT graph for debug
      if ((debug%interaction_graph .or. debug%interaction_graph_full) .and. mpi_grp_is_root(mpi_world)) then
        iunit_out = io_open('debug/interaction_graph.dot', systems%namespace, action='write')
        write(iunit_out, '(a)') 'digraph {'
        call systems%write_interaction_graph(iunit_out, debug%interaction_graph_full)
        write(iunit_out, '(a)') '}'
        call io_close(iunit_out)
      end if
    end select

    if (.not. systems%process_is_slave()) then
      call messages_write('Info: Octopus initialization completed.', new_line = .true.)
      call messages_write('Info: Starting calculation mode.')
      call messages_info(namespace=namespace)

      !%Variable FromScratch
      !%Type logical
      !%Default false
      !%Section Execution
      !%Description
      !% When this variable is set to true, <tt>Octopus</tt> will perform a
      !% calculation from the beginning, without looking for restart
      !% information.
      !% NOTE: If available, mesh partitioning information will be used for
      !% initializing the calculation regardless of the set value for this variable.
      !%End
      call parse_variable(namespace, 'FromScratch', .false., from_scratch)

      call profiling_in("CALC_MODE")

      select case (calc_mode_id)
      case (OPTION__CALCULATIONMODE__GS)
        select type (systems)
        class is (multisystem_basic_t)
          call multisystem_run(systems, from_scratch)
        type is (electrons_t)
          call ground_state_run(systems, from_scratch)
        end select
      case (OPTION__CALCULATIONMODE__UNOCC)
        call unocc_run(systems, from_scratch)
      case (OPTION__CALCULATIONMODE__TD)
        select type (systems)
        class is (multisystem_basic_t)
          call multisystem_run(systems, from_scratch)
        type is (electrons_t)
          call time_dependent_run(systems, from_scratch)
        end select
      case (OPTION__CALCULATIONMODE__GO)
        call geom_opt_run(systems, from_scratch)
      case (OPTION__CALCULATIONMODE__OPT_CONTROL)
        call opt_control_run(systems)
      case (OPTION__CALCULATIONMODE__EM_RESP)
        select case (get_resp_method(namespace))
        case (FD)
          call static_pol_run(systems, from_scratch)
        case (LR)
          call em_resp_run(systems, from_scratch)
        end select
      case (OPTION__CALCULATIONMODE__CASIDA)
        call casida_run(systems, from_scratch)
      case (OPTION__CALCULATIONMODE__VDW)
        call vdW_run(systems, from_scratch)
      case (OPTION__CALCULATIONMODE__VIB_MODES)
        select case (get_resp_method(namespace))
        case (FD)
          call phonons_run(systems)
        case (LR)
          call phonons_lr_run(systems, from_scratch)
        end select
      case (OPTION__CALCULATIONMODE__ONE_SHOT)
        message(1) = "CalculationMode = one_shot is obsolete. Please use gs with MaximumIter = 0."
        call messages_fatal(1, namespace=namespace)
      case (OPTION__CALCULATIONMODE__KDOTP)
        call kdotp_lr_run(systems, from_scratch)
      case (OPTION__CALCULATIONMODE__DUMMY)
      case (OPTION__CALCULATIONMODE__INVERT_KS)
        call invert_ks_run(systems)
      case (OPTION__CALCULATIONMODE__RECIPE)
        ASSERT(.false.) !this is handled before, if we get here, it is an error
      end select

      call profiling_out("CALC_MODE")
    end if

    select type (systems)
    class is (multisystem_basic_t)
      !Deallocate the external potentials
      call iter%start(partners)
      do while (iter%has_next())
        select type(ptr => iter%get_next())
        class is(external_potential_t)
          partner => ptr
          SAFE_DEALLOCATE_P(partner)
        class is(external_waves_t)
          partner => ptr
          SAFE_DEALLOCATE_P(partner)
        class is(lasers_t)
          partner => ptr
          SAFE_DEALLOCATE_P(partner)
        end select
      end do
    end select

    ! Finalize systems
    SAFE_DEALLOCATE_P(systems)

    call fft_all_end()

    call accel_end(global_namespace)

    call mpi_debug_statistics()

    POP_SUB(run)

  contains

    subroutine calc_mode_init()

      PUSH_SUB(calc_mode_init)

      select case (calc_mode_id)
      case (OPTION__CALCULATIONMODE__GS, OPTION__CALCULATIONMODE__GO, OPTION__CALCULATIONMODE__UNOCC)
        call ground_state_run_init()
      case (OPTION__CALCULATIONMODE__TD)
        call td_run_init()
      case (OPTION__CALCULATIONMODE__CASIDA)
        call casida_run_init()
      end select

      POP_SUB(calc_mode_init)
    end subroutine calc_mode_init

scf/ground_state.F90:

  subroutine ground_state_run(electrons, from_scratch)
    class(electrons_t), intent(inout) :: electrons
    logical,            intent(inout) :: from_scratch

    PUSH_SUB(ground_state_run)

    call electrons_ground_state_run(electrons%namespace, electrons%mc, electrons%gr, &
      electrons%ions, electrons%ext_partners, &
      electrons%st, electrons%ks, electrons%hm, electrons%outp, electrons%space, from_scratch)

    POP_SUB(ground_state_run)
  end subroutine ground_state_run

  subroutine electrons_ground_state_run(namespace, mc, gr, ions, ext_partners, st, ks, hm, outp, space, fromScratch)
    type(namespace_t),        intent(in)    :: namespace
    type(multicomm_t),        intent(in)    :: mc
    type(grid_t),             intent(inout) :: gr
    type(ions_t),             intent(inout) :: ions
    type(partner_list_t),     intent(in)    :: ext_partners
    type(states_elec_t),      intent(inout) :: st
    type(v_ks_t),             intent(inout) :: ks
    type(hamiltonian_elec_t), intent(inout) :: hm
    type(output_t),           intent(in)    :: outp
    type(electron_space_t),   intent(in)    :: space
    logical,                  intent(inout) :: fromScratch

    type(rdm_t)     :: rdm
    type(scf_t)     :: scf

    PUSH_SUB(ground_state_run_legacy)

    call gs_allocate_wavefunctions(namespace, gr, st, hm, scf, ks, ions, mc, space)

    if (.not. fromScratch) then
      call gs_load_from_restart(namespace, scf, gr, mc, st, hm, ks, space, ions, ext_partners, fromScratch)
    end if

    call gs_initialize(namespace, scf, rdm, gr, mc, st, hm, ions, ks, space, ext_partners, fromScratch)

    call gs_run(namespace, scf, rdm, mc, gr, ions, ext_partners, st, ks, hm, outp, space)

    call gs_cleanup(ks, scf, rdm, st, hm)

    POP_SUB(ground_state_run_legacy)
  end subroutine electrons_ground_state_run