29 use,
intrinsic :: iso_fortran_env
76 integer,
parameter :: &
100 logical :: constant_velocity
101 integer :: thermostat
103 real(real64) :: current_temperature
105 real(real64),
allocatable :: oldforce(:, :)
108 real(real64),
allocatable :: old_pos(:, :)
111 real(real64),
allocatable :: cell_force(:)
112 real(real64),
allocatable :: old_cell_force(:)
113 real(real64),
allocatable :: cell_vel(:)
114 real(real64),
allocatable :: initial_rlattice(:,:)
115 real(real64),
allocatable :: strain(:)
117 real(real64) :: pressure
120 logical :: symmetrize = .false.
121 type(symmetrizer_t),
pointer :: symm
124 type(nose_hoover_t) :: nh(1:2)
125 type(tdf_t) :: temperature_function
128 logical :: drive_ions
129 type(ion_td_displacement_t),
allocatable :: td_displacements(:)
130 type(ions_t),
pointer :: ions_t0
132 real(real64),
public :: ionic_scale
142 real(real64),
allocatable :: pos(:, :)
143 real(real64),
allocatable :: vel(:, :)
144 real(real64),
allocatable :: old_pos(:, :)
145 type(nose_hoover_t) :: nh(1:2)
150 real(real64),
allocatable :: pos(:, :)
151 real(real64),
allocatable :: vel(:, :)
152 real(real64),
allocatable :: old_pos(:, :)
159 use iso_c_binding,
only: c_ptr
160 type(ion_dynamics_t),
intent(out) :: this
161 type(namespace_t),
intent(in) :: namespace
162 type(ions_t),
intent(inout) :: ions
163 logical,
intent(in) :: symmetrize
164 type(symmetrizer_t),
optional,
target,
intent(in) :: symm
166 integer :: i, j, iatom, ierr, periodic_dim, ncomp
167 real(real64) :: xx(ions%space%dim), temperature, sigma, kin1, kin2
168 type(c_ptr) :: random_gen_pointer
170 character(len=100) :: temp_function_name
171 logical :: have_velocities
175 character(len=200) :: expression
179 have_velocities = .false.
180 this%drive_ions = .false.
182 this%symmetrize = symmetrize
183 if (this%symmetrize)
then
184 assert(
present(symm))
222 write(
message(1),
'(a)')
'Input: TDIonicTimeScale must be positive.'
240 call parse_variable(namespace,
'IonsConstantVelocity', .false., this%constant_velocity)
243 if (this%constant_velocity)
then
246 this%drive_ions = .
true.
270 if (
parse_block(namespace,
'IonsTimeDependentDisplacements', blk) == 0)
then
273 safe_allocate(this%td_displacements(1:ions%natoms))
274 this%td_displacements(1:ions%natoms)%move = .false.
275 if (ndisp > 0) this%drive_ions =.
true.
279 this%td_displacements(iatom)%move = .
true.
282 call tdf_read(this%td_displacements(iatom)%fx, namespace, trim(expression), ierr)
284 write(
message(1),
'(3A)')
'Could not find "', trim(expression),
'" in the TDFunctions block:'
290 call tdf_read(this%td_displacements(iatom)%fy, namespace, trim(expression), ierr)
292 write(
message(1),
'(3A)')
'Could not find "', trim(expression),
'" in the TDFunctions block:'
297 call tdf_read(this%td_displacements(iatom)%fz, namespace, trim(expression), ierr)
299 write(
message(1),
'(3A)')
'Could not find "', trim(expression),
'" in the TDFunctions block:'
305 safe_allocate(this%ions_t0)
328 call parse_variable(namespace,
'Thermostat', thermo_none, this%thermostat)
332 if (this%thermostat /= thermo_none)
then
334 have_velocities = .
true.
336 if (this%drive_ions)
then
337 call messages_write(
'You cannot use a Thermostat and IonsConstantVelocity or IonsTimeDependentDisplacements')
354 call parse_variable(namespace,
'TemperatureFunction',
'temperature', temp_function_name)
356 call tdf_read(this%temperature_function, namespace, temp_function_name, ierr)
359 message(1) =
"You have enabled a thermostat but Octopus could not find"
360 message(2) =
"the '"//trim(temp_function_name)//
"' function in the TDFunctions block."
376 this%nh(2)%mass = this%nh(1)%mass
381 safe_allocate(this%old_pos(1:ions%space%dim, 1:ions%natoms))
383 this%old_pos = ions%pos
405 have_velocities = .
true.
412 do i = 1, ions%natoms
415 sigma =
sqrt(temperature / ions%mass(i))
421 call mpi_world%bcast(ions%vel(:, i), ions%space%dim, mpi_double_precision, 0)
428 call ions%update_kinetic_energy()
429 kin1 = ions%kinetic_energy
431 xx = ions%center_of_mass_vel()
432 do i = 1, ions%natoms
433 ions%vel(:, i) = ions%vel(:, i) - xx
436 call ions%update_kinetic_energy()
437 kin2 = ions%kinetic_energy
439 do i = 1, ions%natoms
440 ions%vel(:, i) =
sqrt(kin1/kin2)*ions%vel(:, i)
443 call ions%update_kinetic_energy()
445 write(
message(1),
'(a,f10.4,1x,a)')
'Info: Initial velocities randomly distributed with T =', &
447 write(
message(2),
'(2x,a,f8.4,1x,a)')
'<K> =', &
450 write(
message(3),
'(2x,a,f8.4,1x,a)')
'3/2 k_B T =', &
509 have_velocities = .
true.
511 if (ions%natoms /= xyz%n)
then
512 write(
message(1),
'(a,i4,a,i4)')
'I need exactly ', ions%natoms,
' velocities, but I found ', xyz%n
517 do i = 1, ions%natoms
528 call ions%update_kinetic_energy()
538 call parse_variable(namespace,
'MoveIons', have_velocities, this%move_ions)
541 if (this%move_ions .and. ions%space%periodic_dim == 1)
then
543 'Moving ions for a 1D periodic system is not allowed, as forces are incorrect.')
546 if (this%ions_move())
then
547 safe_allocate(this%oldforce(1:ions%space%dim, 1:ions%natoms))
550 if (ions%space%is_periodic())
then
561 call parse_variable(namespace,
'CellDynamics', .false., this%relax_cell)
564 if (this%cell_relax())
then
566 message(1) =
"Cell dynamics not supported on GPUs."
570 periodic_dim = ions%space%periodic_dim
571 ncomp = periodic_dim * periodic_dim
572 safe_allocate(this%cell_force(1:ncomp))
574 safe_allocate(this%old_cell_force(1:ncomp))
575 this%old_cell_force =
m_zero
576 safe_allocate(this%cell_vel(1:ncomp))
579 safe_allocate(this%strain(1:ncomp))
582 do i = 1, periodic_dim
583 do j = i, periodic_dim
584 if(i == j) this%strain(ncomp) =
m_one
591 safe_allocate(this%initial_rlattice(1:periodic_dim, 1:periodic_dim))
592 this%initial_rlattice(1:periodic_dim, 1:periodic_dim) = ions%latt%rlattice(1:periodic_dim, 1:periodic_dim)
606 this%relax_cell = .false.
619 safe_deallocate_a(this%oldforce)
621 if (this%thermostat /= thermo_none)
then
622 call tdf_end(this%temperature_function)
625 if (this%drive_ions .and.
allocated(this%td_displacements))
then
626 if (any(this%td_displacements(1:this%ions_t0%natoms)%move))
then
631 safe_deallocate_a(this%td_displacements)
634 safe_deallocate_a(this%cell_force)
635 safe_deallocate_a(this%old_cell_force)
636 safe_deallocate_a(this%cell_vel)
637 safe_deallocate_a(this%initial_rlattice)
647 type(
ions_t),
intent(inout) :: ions
648 real(real64),
intent(in) :: time
649 real(real64),
intent(in) :: dt
658 if (this%drive_ions)
then
668 do iatom = 1, ions%natoms
669 ions%pos(:, iatom) = ions%latt%cart_to_red(ions%pos(:, iatom))
670 ions%vel(:, iatom) = ions%latt%cart_to_red(ions%vel(:, iatom))
671 ions%tot_force(:, iatom) = ions%latt%cart_to_red(ions%tot_force(:, iatom))
675 if (this%ions_move())
then
680 if (this%cell_relax())
then
685 do iatom = 1, ions%natoms
686 ions%pos(:, iatom) = ions%latt%red_to_cart(ions%pos(:, iatom))
687 ions%vel(:, iatom) = ions%latt%red_to_cart(ions%vel(:, iatom))
688 if (
allocated(this%oldforce))
then
689 this%oldforce(:, iatom) = ions%latt%red_to_cart(this%oldforce(:, iatom))
691 ions%tot_force(:, iatom) = ions%latt%red_to_cart(ions%tot_force(:, iatom))
696 call ions%fold_atoms_into_cell()
706 real(real64),
intent(in) :: time
712 if (this%thermostat /= thermo_none)
then
715 if (this%current_temperature <
m_zero)
then
716 write(
message(1),
'(a, f10.3, 3a, f10.3, 3a)') &
717 "Negative temperature (", &
724 this%current_temperature =
m_zero
735 type(
ions_t),
intent(inout) :: ions
736 real(real64),
intent(in) :: time
737 real(real64),
intent(in) :: dt
740 real(real64) :: dr(3)
744 assert(this%drive_ions)
746 do iatom = 1, ions%natoms
747 if (ions%fixed(iatom)) cycle
749 if (this%constant_velocity)
then
750 ions%pos(:, iatom) = ions%pos(:, iatom) + dt*ions%vel(:, iatom)
752 else if (
allocated(this%td_displacements))
then
754 if (this%td_displacements(iatom)%move)
then
755 dr(1:3)=(/ real(
tdf(this%td_displacements(iatom)%fx, time), real64), &
756 real(
tdf(this%td_displacements(iatom)%fy, time), real64), &
757 real(tdf(this%td_displacements(iatom)%fz, time), real64) /)
759 ions%pos(:, iatom) = this%ions_t0%pos(:, iatom) + dr(1:ions%space%dim)
775 type(
ions_t),
intent(inout) :: ions
776 real(real64),
intent(in) :: time
777 real(real64),
intent(in) :: dt
783 assert(.not. this%drive_ions)
787 do iatom = 1, ions%natoms
788 if (ions%fixed(iatom)) cycle
790 ions%pos(:, iatom) = ions%pos(:, iatom) + dt*ions%vel(:, iatom) + &
791 m_half*dt**2 / ions%mass(iatom) * ions%tot_force(:, iatom)
793 this%oldforce(:, iatom) = ions%tot_force(:, iatom)
805 do iatom = 1, ions%natoms
806 if (ions%fixed(iatom)) cycle
808 ions%pos(:, iatom) = ions%pos(:, iatom) +
m_half*dt*ions%vel(:, iatom)
820 type(
ions_t),
intent(inout) :: ions
821 real(real64),
intent(in) :: time
822 real(real64),
intent(in) :: dt
825 integer :: idir, jdir, comp
826 real(real64) :: rlattice_change(ions%space%periodic_dim*ions%space%periodic_dim)
830 rlattice_change = dt * this%cell_vel +
m_half*dt**2 * this%cell_force
833 do idir = 1, ions%space%periodic_dim
835 this%cell_force(jdir + (idir-1)*ions%space%periodic_dim)), &
836 jdir = 1, ions%space%periodic_dim)
838 call messages_info(1+ions%space%periodic_dim, namespace=ions%namespace)
840 write(
message(1),
'(a,3a,a)')
' Cell vel [', &
842 do idir = 1, ions%space%periodic_dim
844 this%cell_vel(jdir+ (idir-1)*ions%space%periodic_dim)), &
845 jdir = 1, ions%space%periodic_dim)
847 call messages_info(1+ions%space%periodic_dim, namespace=ions%namespace)
851 do idir = 1, ions%space%periodic_dim
852 do jdir = 1, ions%space%periodic_dim
853 ions%latt%rlattice(idir, jdir) = ions%latt%rlattice(idir, jdir) + rlattice_change(comp)
858 this%old_cell_force = this%cell_force
860 if (
associated(this%symm))
then
861 call this%symm%symmetrize_lattice_vectors(ions%space%periodic_dim, &
862 this%initial_rlattice, ions%latt%rlattice, this%symmetrize)
864 call ions%update_lattice_vectors(ions%latt, this%symmetrize)
873 type(
ions_t),
intent(inout) :: ions
875 real(real64) :: g1, g2, ss, uk, dt, temp
881 call ions%update_kinetic_energy()
882 uk = ions%kinetic_energy
884 temp = this%current_temperature
886 g2 = (this%nh(1)%mass*this%nh(1)%vel**2 - temp)/this%nh(2)%mass
887 this%nh(2)%vel = this%nh(2)%vel + g2*dt/
m_four
888 this%nh(1)%vel = this%nh(1)%vel*
exp(-this%nh(2)%vel*dt/8.0_real64)
890 g1 = (
m_two*uk -
m_three*ions%natoms*temp)/this%nh(1)%mass
891 this%nh(1)%vel = this%nh(1)%vel + g1*dt/
m_four
892 this%nh(1)%vel = this%nh(1)%vel*
exp(-this%nh(2)%vel*dt/8.0_real64)
893 this%nh(1)%pos = this%nh(1)%pos + this%nh(1)%vel*dt/
m_two
894 this%nh(2)%pos = this%nh(2)%pos + this%nh(2)%vel*dt/
m_two
898 ions%vel = ss*ions%vel
902 this%nh(1)%vel = this%nh(1)%vel*
exp(-this%nh(2)%vel*dt/8.0_real64)
903 g1 = (
m_two*uk -
m_three*ions%natoms*temp)/this%nh(1)%mass
904 this%nh(1)%vel = this%nh(1)%vel + g1*dt/
m_four
905 this%nh(1)%vel = this%nh(1)%vel*
exp(-this%nh(2)%vel*dt/8.0_real64)
907 g2 = (this%nh(1)%mass*this%nh(1)%vel**2 - temp)/this%nh(2)%mass
908 this%nh(2)%vel = this%nh(2)%vel + g2*dt/
m_four
917 type(
ions_t),
intent(inout) :: ions
918 logical,
optional,
intent(out) :: atoms_moved
924 if (this%drive_ions)
return
928 if (
present(atoms_moved)) atoms_moved = this%thermostat ==
thermo_nh
933 do iatom = 1, ions%natoms
934 if (ions%fixed(iatom)) cycle
936 ions%vel(:, iatom) = ions%vel(:, iatom) &
937 + this%dt/ions%mass(iatom) *
m_half * (this%oldforce(:, iatom) + &
938 ions%tot_force(:, iatom))
944 do iatom = 1, ions%natoms
945 ions%vel(:, iatom) = ions%vel(:, iatom) + this%dt*ions%tot_force(:, iatom) / ions%mass(iatom)
946 ions%pos(:, iatom) = ions%pos(:, iatom) +
m_half*this%dt*ions%vel(:, iatom)
956 ions%vel = scal*ions%vel
959 if (this%cell_relax())
then
960 this%cell_vel = this%cell_vel + this%dt *
m_half * (this%old_cell_force + this%cell_force)
970 type(
ions_t),
intent(in) :: ions
971 real(real64),
intent(inout) :: q(:, :)
972 real(real64),
intent(inout) :: v(:, :)
973 real(real64),
intent(in) :: fold(:, :)
974 real(real64),
intent(in) :: dt
981 do iatom = 1, ions%natoms
982 v(iatom, 1:ions%space%dim) = v(iatom, 1:ions%space%dim) / ions%mass(iatom)
986 do iatom = 1, ions%natoms
987 if (ions%fixed(iatom)) cycle
988 q(iatom, 1:ions%space%dim) = q(iatom, 1:ions%space%dim) + dt * v(iatom, 1:ions%space%dim) + &
989 m_half*dt**2 / ions%mass(iatom) * fold(iatom, 1:ions%space%dim)
993 do iatom = 1, ions%natoms
994 v(iatom, 1:ions%space%dim) = ions%mass(iatom) * v(iatom, 1:ions%space%dim)
1005 type(
ions_t),
intent(in) :: ions
1006 real(real64),
intent(inout) :: v(:, :)
1007 real(real64),
intent(in) :: fold(:, :)
1008 real(real64),
intent(in) :: fnew(:, :)
1009 real(real64),
intent(in) :: dt
1016 do iatom = 1, ions%natoms
1017 v(iatom, 1:ions%space%dim) = v(iatom, 1:ions%space%dim) / ions%mass(iatom)
1021 do iatom = 1, ions%natoms
1022 if (ions%fixed(iatom)) cycle
1023 v(iatom, 1:ions%space%dim) = v(iatom, 1:ions%space%dim) &
1024 + dt / ions%mass(iatom) *
m_half * (fold(iatom, 1:ions%space%dim) + fnew(iatom, 1:ions%space%dim))
1028 do iatom = 1, ions%natoms
1029 v(iatom, 1:ions%space%dim) = ions%mass(iatom) * v(iatom, 1:ions%space%dim)
1039 type(
ions_t),
intent(in) :: ions
1042 if (.not. this%ions_move())
return
1046 safe_allocate(state%pos(1:ions%space%dim, 1:ions%natoms))
1047 safe_allocate(state%vel(1:ions%space%dim, 1:ions%natoms))
1049 state%pos = ions%pos
1050 state%vel = ions%vel
1053 safe_allocate(state%old_pos(1:ions%space%dim, 1:ions%natoms))
1054 state%old_pos(1:ions%space%dim, 1:ions%natoms) = this%old_pos(1:ions%space%dim, 1:ions%natoms)
1055 state%nh(1:2)%pos = this%nh(1:2)%pos
1056 state%nh(1:2)%vel = this%nh(1:2)%vel
1066 type(
ions_t),
intent(inout) :: ions
1069 assert(.not. this%cell_relax())
1070 if (.not. this%ions_move())
return
1074 ions%pos = state%pos
1075 ions%vel = state%vel
1078 this%old_pos(1:ions%space%dim, 1:ions%natoms) = state%old_pos(1:ions%space%dim, 1:ions%natoms)
1079 this%nh(1:2)%pos = state%nh(1:2)%pos
1080 this%nh(1:2)%vel = state%nh(1:2)%vel
1081 safe_deallocate_a(state%old_pos)
1084 safe_deallocate_a(state%pos)
1085 safe_deallocate_a(state%vel)
1095 ions_move = this%move_ions
1105 drive_ions = this%drive_ions
1114 cell_dynamics = this%relax_cell
1123 is_active = this%relax_cell .or. this%move_ions
1131 type(ions_t),
intent(in) :: ions
1134 real(real64) :: kinetic_energy
1136 kinetic_energy = m_zero
1137 do iatom = 1, ions%natoms
1138 kinetic_energy = kinetic_energy + &
1139 m_half * ions%mass(iatom) * sum(ions%vel(:, iatom)**2)
1141 temperature = m_two/m_three*kinetic_energy/ions%natoms
1150 if (this%move_ions)
then
1151 this%move_ions = .false.
1163 this%move_ions = .
true.
1169 type(restart_t),
intent(in) :: restart
1170 integer,
intent(out) :: ierr
1174 if (
allocated(this%oldforce))
then
1175 call drestart_write_binary(restart,
"ion_dynamics_oldforce",
size(this%oldforce), &
1176 this%oldforce, ierr)
1179 if(
allocated(this%old_cell_force))
then
1180 call drestart_write_binary(restart,
"ion_dynamics_old_cell_force",
size(this%old_cell_force), &
1181 this%old_cell_force, ierr)
1190 type(restart_t),
intent(in) :: restart
1191 integer,
intent(out) :: ierr
1195 if (
allocated(this%oldforce))
then
1196 call drestart_read_binary(restart,
"ion_dynamics_oldforce",
size(this%oldforce), &
1197 this%oldforce, ierr)
1200 if(
allocated(this%old_cell_force))
then
1201 call drestart_read_binary(restart,
"ion_dynamics_old_cell_force",
size(this%old_cell_force), &
1202 this%old_cell_force, ierr)
1212 class(space_t),
intent(in) :: space
1213 real(real64),
intent(in) :: stress(3,3)
1214 real(real64),
intent(in) :: rlattice(:,:)
1215 real(real64),
intent(in) :: rcell_volume
1217 integer :: idir, jdir, comp
1218 real(real64) :: inv_latt(space%periodic_dim, space%periodic_dim), tmp_stress(space%periodic_dim, space%periodic_dim)
1219 real(real64) :: cell_force(space%periodic_dim, space%periodic_dim)
1224 inv_latt = rlattice(1:space%periodic_dim, 1:space%periodic_dim)
1225 call lalg_inverse(space%periodic_dim, inv_latt,
'dir')
1227 tmp_stress = -stress(1:space%periodic_dim, 1:space%periodic_dim)
1228 do idir = 1, space%periodic_dim
1229 tmp_stress(idir, idir) = tmp_stress(idir, idir) - this%pressure/space%periodic_dim
1231 cell_force = matmul(tmp_stress, transpose(inv_latt)) * rcell_volume
1234 do idir = 1, space%periodic_dim
1235 do jdir = 1, space%periodic_dim
1236 this%cell_force(comp) = cell_force(idir, jdir)
1241 if (debug%info)
then
1242 write(message(1),
'(a,3a,a)')
' Stress tensor [', trim(units_abbrev(units_out%energy/units_out%length**space%dim)),
']'
1243 do idir = 1, space%periodic_dim
1244 write(message(1+idir),
'(9e18.10)') (units_from_atomic(units_out%energy/units_out%length**space%dim, stress(jdir, idir)), &
1245 jdir = 1, space%periodic_dim)
1247 call messages_info(1+space%periodic_dim, namespace=global_namespace)
1255 type(namespace_t),
intent(in) :: namespace
1256 type(grid_t),
intent(inout) :: gr
1257 class(space_t),
intent(in) :: space
1258 type(poisson_t),
intent(inout) :: psolver
1259 type(kpoints_t),
intent(inout) :: kpoints
1260 type(multicomm_t),
intent(in) :: mc
1261 real(real64),
intent(in) :: qtot
1262 type(lattice_vectors_t),
intent(in) :: new_latt
1265 real(real64) :: length(1:space%dim)
1270 select type(box => gr%box)
1271 type is (box_parallelepiped_t)
1272 do idir = 1, space%dim
1273 length(idir) = norm2(new_latt%rlattice(1:space%dim, idir))
1275 call box%regenerate(space%dim, new_latt%rlattice, length, namespace)
1277 call messages_not_implemented(
"Grid regeneration for non-parallelepiped boxes", namespace=namespace)
1280 call grid_lattice_vectors_update(gr, space, namespace, mc, new_latt)
1283 call poisson_end(psolver)
1284 call poisson_init(psolver, namespace, space, gr%der, mc, gr%stencil, qtot, verbose=.false.)
1286 call kpoints_lattice_vectors_update(kpoints, new_latt)
Functions to generate random numbers.
Prints out to iunit a message in the form: ["InputVariable" = value] where "InputVariable" is given b...
double exp(double __x) __attribute__((__nothrow__
pure logical function, public accel_is_enabled()
real(real64), parameter, public m_two
real(real64), parameter, public m_zero
real(real64), parameter, public m_four
real(real64), parameter, public m_half
real(real64), parameter, public m_one
real(real64), parameter, public m_three
This module implements the underlying real-space grid.
subroutine, public ion_dynamics_verlet_step2(ions, v, fold, fnew, dt)
A bare verlet integrator.
subroutine ion_dynamics_update_temperature(this, time, namespace)
Update the temperature of the ions in case of a thermostat.
subroutine, public ion_dynamics_dump(this, restart, ierr)
subroutine, public ion_dynamics_verlet_step1(ions, q, v, fold, dt)
A bare verlet integrator.
logical pure function ion_dynamics_cell_relax(this)
Is the cell dynamics activated or not.
subroutine nh_chain(this, ions)
subroutine, public ion_dynamics_restore_state(this, ions, state)
subroutine, public ion_dynamics_propagate(this, ions, time, dt, namespace)
Interface for the ion/cell dynamics.
subroutine ion_dynamics_propagate_cell(this, ions, time, dt, namespace)
Time-evolution of the lattice vectors.
subroutine, public ion_dynamics_save_state(this, ions, state)
subroutine, public ion_dynamics_unfreeze(this)
Unfreezes the ionic movement.
subroutine ion_dynamics_propagate_ions(this, ions, time, dt)
Time evolution of the ions.
subroutine ion_dynamics_update_stress(this, space, stress, rlattice, rcell_volume)
Updates the stress tensor for the ion dynamics.
subroutine, public ion_dynamics_propagate_vel(this, ions, atoms_moved)
subroutine, public ion_dynamics_load(this, restart, ierr)
subroutine, public ion_dynamics_init(this, namespace, ions, symmetrize, symm)
integer, parameter thermo_scal
subroutine, public electrons_lattice_vectors_update(namespace, gr, space, psolver, kpoints, mc, qtot, new_latt)
subroutine, public ion_dynamics_end(this)
subroutine ion_dynamics_propagate_driven_ions(this, ions, time, dt)
Move ions following a driven motion.
integer, parameter thermo_nh
logical pure function ion_dynamics_ions_move(this)
logical function, public ion_dynamics_freeze(this)
Freezes the ionic movement.
logical pure function ion_dynamics_is_active(this)
Is the cell dynamics activated or not.
logical pure function, public ion_dynamics_drive_ions(this)
Is the ion dynamics activated or not.
real(real64) function, public ion_dynamics_temperature(ions)
This function returns the ionic temperature in energy units.
This module is intended to contain "only mathematical" functions and procedures.
subroutine, public messages_warning(no_lines, all_nodes, namespace)
subroutine, public messages_obsolete_variable(namespace, name, rep)
character(len=256), dimension(max_lines), public message
to be output by fatal, warning
subroutine, public messages_fatal(no_lines, only_root_writes, namespace)
subroutine, public messages_input_error(namespace, var, details, row, column)
subroutine, public messages_experimental(name, namespace)
subroutine, public messages_info(no_lines, iunit, debug_only, stress, all_nodes, namespace)
logical function mpi_grp_is_root(grp)
Is the current MPI process of grpcomm, root.
type(mpi_grp_t), public mpi_world
This module handles the communicators for the various parallelization strategies.
logical function, public parse_is_defined(namespace, name)
integer function, public parse_block(namespace, name, blk, check_varinfo_)
integer, parameter, public read_coords_err
for read_coords_info::file_type
subroutine, public read_coords_init(gf)
subroutine, public read_coords_end(gf)
subroutine, public read_coords_read(what, gf, space, namespace)
subroutine, public tdf_end(f)
subroutine, public tdf_read(f, namespace, function_name, ierr)
This function initializes "f" from the TDFunctions block.
brief This module defines the class unit_t which is used by the unit_systems_oct_m module.
character(len=20) pure function, public units_abbrev(this)
This module defines the unit system, used for input and output.
type(unit_system_t), public units_out
type(unit_t), public unit_kelvin
For converting energies into temperatures.
type(unit_system_t), public units_inp
the units systems for reading and writing