29 use,
intrinsic :: iso_fortran_env
59 integer,
public,
parameter :: &
94 type(namespace_t),
intent(in) :: namespace
95 type(propagator_factory_t) :: factory
103 if (factory%final_time <=
m_zero)
then
124 class(propagator_factory_t),
intent(in) :: this
125 class(interaction_partner_t),
intent(in),
target :: system
126 class(algorithm_t),
pointer :: algorithm
130 class(propagator_t),
pointer :: propagator
165 call parse_variable(system%namespace,
'TDSystemPropagator', prop_static, prop_type)
174 select case (prop_type)
203 propagator%final_time = this%final_time
207 propagator%system => system
212 algorithm => propagator
229 float :: largest_dt, smallest_dt
231 class(
system_t),
pointer :: subsystem
244 call iter%start(system%list)
245 do while (iter%has_next())
246 subsystem => iter%get_next()
247 select type (subalgorithm => subsystem%algo)
249 largest_dt = max(largest_dt, subalgorithm%dt)
250 smallest_dt = min(smallest_dt, subalgorithm%dt/subalgorithm%algo_steps)
259 propagator%final_time = this%final_time
263 propagator%system => system
268 algorithm => propagator
292 if (dt_adjusted /= dt)
then
293 message(1) =
"The time-step was adjusted to make it commensurable with the minimum time-step:"
294 write(
message(2),
'(a,es21.15)')
" requested time-step = ", dt
295 write(
message(3),
'(a,es21.15)')
" adjusted time-step = ", dt_adjusted
Prints out to iunit a message in the form: ["InputVariable" = value] where "InputVariable" is given b...
This module defines the abstract interfact for algorithm factories.
This module implements the basic elements defining algorithms.
real(8), parameter, public clock_minimum_dt
This CLOCK_MINIMUM_DT parameter defines what is the time-step in the common reference frame of all cl...
real(8), parameter, public m_huge
real(8), parameter, public m_zero
This module defines classes and functions for interaction partners.
subroutine, public messages_print_with_emphasis(msg, iunit, namespace)
character(len=512), private msg
subroutine, public messages_warning(no_lines, all_nodes, namespace)
character(len=256), dimension(max_lines), public message
to be output by fatal, warning
subroutine, public messages_input_error(namespace, var, details, row, column)
This module implements the basic mulsisystem class, a container system for other systems.
This module implements the factory for propagators.
real(8) function propagator_factory_read_dt(this, namespace)
auxilliary function to read the time step from the input file
type(propagator_factory_t) function propagator_factory_constructor(namespace)
Constructor for the propagator factory.
integer, parameter, public prop_verlet
integer, parameter, public prop_aetrs_ms
integer, parameter, public prop_beeman_scf
integer, parameter, public prop_bomd
class(algorithm_t) function, pointer propagator_factory_create_static(this, system)
Create a static propagator.
integer, parameter, public prop_expmid
integer, parameter, public prop_expmid_2step
integer, parameter, public prop_expmid_2step_scf
integer, parameter, public prop_rk4
class(algorithm_t) function, pointer propagator_factory_create(this, system)
Create a general propagator.
integer, parameter, public prop_beeman
integer, parameter, public prop_leapfrog
This module implements the basic propagator framework.
This module implements the abstract system type.
This module defines the unit system, used for input and output.
type(unit_system_t), public units_inp
the units systems for reading and writing
Abstract class for the algorithm factories.
An algorithm is a list of algorithmic operations executed sequentially.
abstract class for general interaction partners
Container class for lists of system_oct_m::system_t.
Implements a propagator for Approximate ETRS.
Implements the Beeman propagator (with or without SCF)
Implements a propagator for Born-Oppenheimer molecular dynamics.
Implements the implicit exponential midpoint propagator with predictor-corrector.
Implements the explicit exponential midpoint propagator (without predictor-corrector)
This class defines the factory for propagators.
Implements a propagator for the leap frog algorithm.
Abstract class implementing propagators.
Implements a the 4th order Runge Kutta propagator.
Implements a propagator that keeps the state of the system constant. Note that a time-step is still r...
Implements a propagator for the velocity Verlet algorithm.
Abstract class for systems.