Octopus
gauge_field.F90
Go to the documentation of this file.
1!! Copyright (C) 2008 X. Andrade
2!! Copyright (C) 2020 N. Tancogne-Dejean
3!!
4!! This program is free software; you can redistribute it and/or modify
5!! it under the terms of the GNU General Public License as published by
6!! the Free Software Foundation; either version 2, or (at your option)
7!! any later version.
8!!
9!! This program is distributed in the hope that it will be useful,
10!! but WITHOUT ANY WARRANTY; without even the implied warranty of
11!! MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12!! GNU General Public License for more details.
13!!
14!! You should have received a copy of the GNU General Public License
15!! along with this program; if not, write to the Free Software
16!! Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
17!! 02110-1301, USA.
18!!
19
20#include "global.h"
21
24 use debug_oct_m
25 use global_oct_m
26 use grid_oct_m
29 use, intrinsic :: iso_fortran_env
31 use mesh_oct_m
34 use mpi_oct_m
36 use parser_oct_m
40 use space_oct_m
43 use unit_oct_m
46 use xc_lrc_oct_m
47
48 implicit none
49
50 private
51
52 public :: &
71
72 type, extends(interaction_partner_t) :: gauge_field_t
73 private
74 type(space_t), public :: space
75 real(real64), allocatable :: vecpot(:)
76 real(real64), allocatable :: vecpot_vel(:)
77 real(real64), allocatable :: vecpot_acc(:)
78 real(real64), allocatable :: vecpot_kick(:)
79 real(real64), allocatable :: force(:)
80 real(real64) :: wp2
81 logical :: with_gauge_field = .false.
82 integer :: dynamics
83 real(real64) :: kicktime
84
85 real(real64) :: volume
86
87 contains
88 procedure :: init_interaction_as_partner => gauge_field_init_interaction_as_partner
89 procedure :: copy_quantities_to_interaction => gauge_field_copy_quantities_to_interaction
91 end type gauge_field_t
92
93 interface gauge_field_t
94 module procedure gauge_field_init
95 end interface gauge_field_t
96
97
98contains
99
100 ! ---------------------------------------------------------
101 function gauge_field_init(namespace, volume) result(this)
102 class(gauge_field_t), pointer :: this
103 type(namespace_t), intent(in) :: namespace
104 real(real64), intent(in) :: volume
105
106 integer :: ii
107 type(block_t) :: blk
108 logical :: default_gauge_field_propagate
109
110 push_sub(gauge_field_init)
111
112 safe_allocate(this)
113
114 this%namespace = namespace_t("GaugeField", parent=namespace)
115
116 ! Temporary initialization of the space.
117 ! This will be inherited from system_t once this is turned into a system
118 this%space = space_t(namespace)
119
120 this%with_gauge_field = .false.
121
122 this%volume = volume
123
124 safe_allocate(this%vecpot(1:this%space%dim))
125 safe_allocate(this%vecpot_vel(1:this%space%dim))
126 safe_allocate(this%vecpot_acc(1:this%space%dim))
127 safe_allocate(this%vecpot_kick(1:this%space%dim))
128 safe_allocate(this%force(1:this%space%dim))
129 this%vecpot = m_zero
130 this%vecpot_vel = m_zero
131 this%vecpot_acc = m_zero
132 this%vecpot_kick = m_zero
133 this%force = m_zero
134
135 !%Variable GaugeFieldDynamics
136 !%Type integer
137 !%Default polarization
138 !%Section Hamiltonian
139 !%Description
140 !% This variable select the dynamics of the gauge field used to
141 !% apply a finite electric field to periodic systems in
142 !% time-dependent runs.
143 !%Option none 0
144 !% The gauge field does not have dynamics. The induced polarization field is zero.
145 !%Option polarization 1
146 !% The gauge field follows the dynamic described in
147 !% Bertsch et al, Phys. Rev. B 62 7998 (2000).
148 !%End
149 call parse_variable(namespace, 'GaugeFieldDynamics', option__gaugefielddynamics__polarization, this%dynamics)
150
151 !%Variable GaugeVectorField
152 !%Type block
153 !%Section Hamiltonian
154 !%Description
155 !% The gauge vector field is used to include a uniform (but time-dependent)
156 !% external electric field in a time-dependent run for
157 !% a periodic system. An optional second row specifies the initial
158 !% value for the time derivative of the gauge field (which is set
159 !% to zero by default). By default this field is not included.
160 !% If <tt>KPointsUseSymmetries = yes</tt>, then <tt>SymmetryBreakDir</tt>
161 !% must be set in the same direction.
162 !% This is used with utility <tt>oct-dielectric_function</tt>
163 !% according to GF Bertsch, J-I Iwata, A Rubio, and K Yabana,
164 !% <i>Phys. Rev. B</i> <b>62</b>, 7998-8002 (2000).
165 !%
166 !% Note that if present and non-zero, this automatically implies
167 !% <tt>GaugeFieldPropagate = yes</tt>.
168 !% However, this could be turned off by <tt>GaugeFieldPropagate</tt>.
169 !%End
171 ! Read the initial gauge vector field
172 default_gauge_field_propagate = .false.
173 if (parse_block(namespace, 'GaugeVectorField', blk) == 0) then
175 do ii = 1, this%space%dim
176 call parse_block_float(blk, 0, ii - 1, this%vecpot_kick(ii))
177 end do
179 ! By default, we activate GaugeFieldPropagate
180 if (norm2(this%vecpot_kick(1:this%space%dim)) > m_epsilon) then
181 default_gauge_field_propagate = .true.
182 end if
185 if (.not. this%space%is_periodic()) then
186 message(1) = "GaugeVectorField is intended for periodic systems."
187 call messages_warning(1, namespace=namespace)
188 end if
189
190 end if
191
192 !%Variable GaugeFieldPropagate
193 !%Type logical
194 !%Default no
195 !%Section Hamiltonian
196 !%Description
197 !% Propagate the gauge field with initial condition set by GaugeVectorField or zero if not specified
198 !%End
199 call parse_variable(namespace, 'GaugeFieldPropagate', default_gauge_field_propagate, this%with_gauge_field)
200
201
202 !%Variable GaugeFieldDelay
203 !%Type float
204 !%Default 0.
205 !%Section Hamiltonian
206 !%Description
207 !% The application of the gauge field acts as a probe of the system. For dynamical
208 !% systems one can apply this probe with a delay relative to the start of the simulation.
209 !%End
210 call parse_variable(namespace, 'GaugeFieldDelay', m_zero, this%kicktime)
211
212 if (abs(this%kicktime) <= m_epsilon) then
213 this%vecpot(1:this%space%dim) = this%vecpot_kick(1:this%space%dim)
214 end if
215
216 pop_sub(gauge_field_init)
217 end function gauge_field_init
218
219 ! ---------------------------------------------------------
220 subroutine gauge_field_check_symmetries(this, kpoints)
221 type(gauge_field_t), intent(in) :: this
222 type(kpoints_t), intent(in) :: kpoints
223
224 integer :: iop
225
227
228 if (kpoints%use_symmetries) then
229 do iop = 1, symmetries_number(kpoints%symm)
230 if (iop == symmetries_identity_index(kpoints%symm)) cycle
231 if (.not. symm_op_invariant_cart(kpoints%symm%ops(iop), this%vecpot_kick, 1e-5_real64)) then
232 message(1) = "The GaugeVectorField breaks (at least) one of the symmetries used to reduce the k-points."
233 message(2) = "Set SymmetryBreakDir equal to GaugeVectorField."
234 call messages_fatal(2, namespace=this%namespace)
235 end if
236 end do
237 end if
238
240 end subroutine gauge_field_check_symmetries
241
242
243 ! ---------------------------------------------------------
244 subroutine gauge_field_end(this)
245 type(gauge_field_t), intent(inout) :: this
246
247 push_sub(gauge_field_end)
248
249 this%with_gauge_field = .false.
250 safe_deallocate_a(this%vecpot)
251 safe_deallocate_a(this%vecpot_vel)
252 safe_deallocate_a(this%vecpot_acc)
253 safe_deallocate_a(this%vecpot_kick)
254 safe_deallocate_a(this%force)
255
256 pop_sub(gauge_field_end)
257 end subroutine gauge_field_end
258
259
260 ! ---------------------------------------------------------
261 logical pure function gauge_field_is_propagated(this) result(is_propagated)
262 type(gauge_field_t), intent(in) :: this
263
264 is_propagated = this%with_gauge_field
265 end function gauge_field_is_propagated
266
267 ! ---------------------------------------------------------
268 logical pure function gauge_field_is_used(this) result(is_used)
269 type(gauge_field_t), intent(in) :: this
270
271 is_used = this%with_gauge_field .or. (norm2(this%vecpot_kick(1:this%space%dim)) > m_epsilon)
272 end function gauge_field_is_used
273
274
275
276 ! ---------------------------------------------------------
277 subroutine gauge_field_set_vec_pot(this, vec_pot)
278 type(gauge_field_t), intent(inout) :: this
279 real(real64), intent(in) :: vec_pot(:)
280
282 this%vecpot(1:this%space%dim) = vec_pot(1:this%space%dim)
283
285 end subroutine gauge_field_set_vec_pot
286
287
288 ! ---------------------------------------------------------
289 subroutine gauge_field_set_vec_pot_vel(this, vec_pot_vel)
290 type(gauge_field_t), intent(inout) :: this
291 real(real64), intent(in) :: vec_pot_vel(:)
292
294 this%vecpot_vel(1:this%space%dim) = vec_pot_vel(1:this%space%dim)
295
297 end subroutine gauge_field_set_vec_pot_vel
298
299
300 ! ---------------------------------------------------------
301 subroutine gauge_field_get_vec_pot(this, vec_pot)
302 type(gauge_field_t), intent(in) :: this
303 real(real64), intent(out) :: vec_pot(:)
304
306 vec_pot(1:this%space%dim) = this%vecpot(1:this%space%dim)
307
309 end subroutine gauge_field_get_vec_pot
310
311
312 ! ---------------------------------------------------------
313 subroutine gauge_field_get_vec_pot_vel(this, vec_pot_vel)
314 type(gauge_field_t), intent(in) :: this
315 real(real64), intent(out) :: vec_pot_vel(:)
316
318 vec_pot_vel(1:this%space%dim) = this%vecpot_vel(1:this%space%dim)
319
321 end subroutine gauge_field_get_vec_pot_vel
322
323
324 ! ---------------------------------------------------------
325 subroutine gauge_field_get_vec_pot_acc(this, vec_pot_acc)
326 type(gauge_field_t), intent(in) :: this
327 real(real64), intent(out) :: vec_pot_acc(:)
328
330 vec_pot_acc(1:this%space%dim) = this%vecpot_acc(1:this%space%dim)
331
333 end subroutine gauge_field_get_vec_pot_acc
334
335 ! ---------------------------------------------------------
336 subroutine gauge_field_propagate(this, dt, time)
337 type(gauge_field_t), intent(inout) :: this
338 real(real64), intent(in) :: dt
339 real(real64), intent(in) :: time
340
341 logical, save :: warning_shown = .false.
342 integer :: idim
343
344 push_sub(gauge_field_propagate)
345
346 this%vecpot_acc(1:this%space%dim) = this%force(1:this%space%dim)
347
348 ! apply kick, in case kicktime=0 the kick has already been applied
349 if (this%kicktime > m_zero .and. time-dt <= this%kicktime .and. time > this%kicktime) then
350 this%vecpot(1:this%space%dim) = this%vecpot(1:this%space%dim) + this%vecpot_kick(1:this%space%dim)
351 call messages_write(' ---------------- Applying gauge kick ----------------')
352 call messages_info(namespace=this%namespace)
353 end if
354
355 this%vecpot(1:this%space%dim) = this%vecpot(1:this%space%dim) + dt * this%vecpot_vel(1:this%space%dim) + &
356 m_half * dt**2 * this%force(1:this%space%dim)
357
358 !In the case of a kick, the induced field could not be higher than the initial kick
359 do idim = 1, this%space%dim
360 if (.not. warning_shown .and. abs(this%vecpot_kick(idim)) > m_epsilon .and. &
361 abs(this%vecpot(idim))> abs(this%vecpot_kick(idim))*1.01 .and. .not. this%kicktime > m_zero) then
362
363 warning_shown = .true.
364
365 write(message(1),'(a)') 'It seems that the gauge-field might be diverging. You should probably check'
366 write(message(2),'(a)') 'the simulation parameters, in particular the number of k-points.'
367 call messages_warning(2, namespace=this%namespace)
368 end if
369 end do
370 pop_sub(gauge_field_propagate)
371 end subroutine gauge_field_propagate
373 ! ---------------------------------------------------------
374 subroutine gauge_field_init_vec_pot(this, qtot)
375 type(gauge_field_t), intent(inout) :: this
376 real(real64), intent(in) :: qtot
377
379
380 this%wp2 = m_four*m_pi*qtot/this%volume
381
382 write (message(1), '(a,f12.6,a)') "Info: Electron-gas plasmon frequency", &
383 units_from_atomic(units_out%energy, sqrt(this%wp2)), " ["//trim(units_abbrev(units_out%energy))//"]"
384 call messages_info(1, namespace=this%namespace)
385
387 end subroutine gauge_field_init_vec_pot
388
389 ! ---------------------------------------------------------
390 real(real64) function gauge_field_get_energy(this) result(energy)
391 type(gauge_field_t), intent(in) :: this
392
393 push_sub(gauge_field_get_energy)
394
395 if(allocated(this%vecpot_vel)) then
396 energy = this%volume / (8.0_real64 * m_pi * p_c**2) * sum(this%vecpot_vel(1:this%space%dim)**2)
397 else
398 energy = m_zero
399 end if
400
402 end function gauge_field_get_energy
403
404
405 ! ---------------------------------------------------------
406 subroutine gauge_field_dump(restart, gfield, ierr)
407 type(restart_t), intent(in) :: restart
408 type(gauge_field_t), intent(in) :: gfield
409 integer, intent(out) :: ierr
410
411 integer :: err
412 real(real64), allocatable :: vecpot(:,:)
413
414 push_sub(gauge_field_dump)
415
416 ierr = 0
417
418 if (restart%skip()) then
419 pop_sub(gauge_field_dump)
420 return
421 end if
422
423 message(1) = "Debug: Writing gauge field restart."
424 call messages_info(1, namespace=gfield%namespace, debug_only=.true.)
425
426 safe_allocate(vecpot(1:gfield%space%dim, 1:2))
427 vecpot = m_zero
428 call gauge_field_get_vec_pot(gfield, vecpot(:, 1))
429 call gauge_field_get_vec_pot_vel(gfield, vecpot(:, 2))
430
431 call restart%write_binary("gauge_field", 2*gfield%space%dim, vecpot, err)
432 safe_deallocate_a(vecpot)
433 if (err /= 0) ierr = ierr + 1
434
435 message(1) = "Debug: Writing gauge field restart done."
436 call messages_info(1, namespace=gfield%namespace, debug_only=.true.)
437
438 pop_sub(gauge_field_dump)
439 end subroutine gauge_field_dump
440
441
442 ! ---------------------------------------------------------
443 subroutine gauge_field_load(restart, gfield, ierr)
444 type(restart_t), intent(in) :: restart
445 type(gauge_field_t), intent(inout) :: gfield
446 integer, intent(out) :: ierr
447
448 integer :: err
449 real(real64), allocatable :: vecpot(:,:)
450
451 push_sub(gauge_field_load)
452
453 ierr = 0
454
455 if (restart%skip()) then
456 ierr = -1
457 pop_sub(gauge_field_load)
458 return
459 end if
460
461 message(1) = "Debug: Reading gauge field restart."
462 call messages_info(1, namespace=gfield%namespace, debug_only=.true.)
463
464 safe_allocate(vecpot(1:gfield%space%dim, 1:2))
465 call restart%read_binary("gauge_field", 2*gfield%space%dim, vecpot, err)
466 if (err /= 0) ierr = ierr + 1
467
468 call gauge_field_set_vec_pot(gfield, vecpot(:,1))
469 call gauge_field_set_vec_pot_vel(gfield, vecpot(:,2))
470 safe_deallocate_a(vecpot)
471
472 message(1) = "Debug: Reading gauge field restart done."
473 call messages_info(1, namespace=gfield%namespace, debug_only=.true.)
474
475 pop_sub(gauge_field_load)
476 end subroutine gauge_field_load
477
478 ! ---------------------------------------------------------
479
480 subroutine gauge_field_get_force(this, gr, spin_channels, current, lrc)
481 type(gauge_field_t), intent(inout) :: this
482 type(grid_t), intent(in) :: gr
483 integer, intent(in) :: spin_channels
484 real(real64), intent(in) :: current(:,:,:)
485 type(xc_lrc_t), intent(in) :: lrc
486
487 integer :: idir, ispin
488
489 push_sub(gauge_field_get_force)
490
491 select case (this%dynamics)
492 case (option__gaugefielddynamics__none)
493 this%force(1:this%space%dim) = m_zero
494
495 case (option__gaugefielddynamics__polarization)
496 do idir = 1, this%space%periodic_dim
497 this%force(idir) = m_zero
498 do ispin = 1, spin_channels
499 ! If the absolute value of lrc_alpha_ is finite (lrc_alpha can be negative), we apply
500 ! the Proca equation a_2*d^2A/dt^2+a_1*dA/dt+a_0*A=4*Pi*c*J(t)/V.
501 ! Here, lrc_alpha=4*Pi/a_2, proca_a_zero=a_0/(4*Pi), and a_1 can be always set to 0.
502 ! For more details, see reference J. K. Dewhurst <i>et al.</i>, <i>Phys. Rev. B</i> 111, L060302 (2025).
503 if(abs(lrc%alpha) > m_epsilon) then
504 this%force(idir) = this%force(idir) + &
505 lrc%alpha*p_c/this%volume*dmf_integrate(gr, current(:, idir, ispin)) + &
506 lrc%alpha*lrc%proca_a_zero*this%vecpot_kick(idir) - &
507 lrc%alpha*lrc%proca_a_zero*this%vecpot(idir) - lrc%alpha*lrc%proca_a_one*this%vecpot_vel(idir)
508 else
509 this%force(idir) = this%force(idir) - &
510 m_four*m_pi*p_c/this%volume*dmf_integrate(gr, current(:, idir, ispin))
511 endif
512 end do
513 end do
514
515 case default
516 assert(.false.)
517 end select
518
519 pop_sub(gauge_field_get_force)
520 end subroutine gauge_field_get_force
521
522 ! ---------------------------------------------------------
523
524 subroutine gauge_field_do_algorithmic_operation(this, operation, dt, time)
525 class(gauge_field_t), intent(inout) :: this
526 type(algorithmic_operation_t), intent(in) :: operation
527 real(real64), intent(in) :: dt
528 real(real64), intent(in) :: time
529
531
532 select case (operation%id)
533 case (verlet_start)
534 !Does nothing at the moment
535 case (verlet_finish)
536 !Does nothing at the moment
537 case (verlet_update_pos)
538 !This is inside the gauge_field_propagate routine at the moment
539 case (verlet_compute_acc)
540 call gauge_field_propagate(this, dt, time)
541
542 case (verlet_compute_vel)
543 this%vecpot_vel(1:this%space%dim) = this%vecpot_vel(1:this%space%dim) + &
544 m_half * dt * (this%vecpot_acc(1:this%space%dim) + this%force(1:this%space%dim))
545 case default
546 message(1) = "Unsupported TD operation."
547 call messages_fatal(1, namespace=this%namespace)
548 end select
549
552
553
554 ! ---------------------------------------------------------
555 subroutine gauge_field_output_write(this, out_gauge, iter)
556 type(gauge_field_t), intent(in) :: this
557 type(c_ptr), intent(inout) :: out_gauge
558 integer, intent(in) :: iter
559
560 integer :: idir
561 character(len=50) :: aux
562 real(real64) :: temp(this%space%dim)
563
564 if (.not. mpi_world%is_root()) return ! only first node outputs
565
567
568 if (iter == 0) then
569 call write_iter_clear(out_gauge)
570 call write_iter_string(out_gauge,'################################################################################')
571 call write_iter_nl(out_gauge)
572 call write_iter_string(out_gauge,'# HEADER')
573 call write_iter_nl(out_gauge)
574
575 ! first line: column names
576 call write_iter_header_start(out_gauge)
577
578 do idir = 1, this%space%dim
579 write(aux, '(a2,i1,a1)') 'A(', idir, ')'
580 call write_iter_header(out_gauge, aux)
581 end do
582 do idir = 1, this%space%dim
583 write(aux, '(a6,i1,a1)') 'dA/dt(', idir, ')'
584 call write_iter_header(out_gauge, aux)
585 end do
586 do idir = 1, this%space%dim
587 write(aux, '(a10,i1,a1)') 'd^2A/dt^2(', idir, ')'
588 call write_iter_header(out_gauge, aux)
589 end do
590 call write_iter_nl(out_gauge)
591
592 ! second line: units
593 !call write_iter_string(out_gauge, '#[Iter n.]')
594 !call write_iter_header(out_gauge, '[' // trim(units_abbrev(units_out%time)) // ']')
595 !call write_iter_string(out_gauge, &
596 ! 'A Vector potential in ' // trim(units_abbrev(units_out%length)) &
597 ! 'A dot in ' // trim(units_abbrev(units_out%length)) &
598 ! 'A dot dot in ' // trim(units_abbrev(units_out%length))
599 !call write_iter_nl(out_gauge)
600
601 call write_iter_string(out_gauge,'################################################################################')
602 call write_iter_nl(out_gauge)
603
604 end if
605
606 call write_iter_start(out_gauge)
607
608 do idir = 1, this%space%dim
609 temp(idir) = units_from_atomic(units_out%energy, this%vecpot(idir))
610 end do
611 call write_iter_double(out_gauge, temp, this%space%dim)
612
613 do idir = 1, this%space%dim
614 temp(idir) = units_from_atomic(units_out%energy / units_out%time, this%vecpot_vel(idir))
615 end do
616 call write_iter_double(out_gauge, temp, this%space%dim)
617
618 do idir = 1, this%space%dim
619 temp(idir) = units_from_atomic(units_out%energy / units_out%time**2, this%vecpot_acc(idir))
620 end do
621 call write_iter_double(out_gauge, temp, this%space%dim)
622
623 call write_iter_nl(out_gauge)
624
626 end subroutine gauge_field_output_write
627
628 ! ---------------------------------------------------------
629 subroutine gauge_field_finalize(this)
630 type(gauge_field_t), intent(inout) :: this
631
632 push_sub(gauge_field_finalize)
633
634 call gauge_field_end(this)
635
636 pop_sub(gauge_field_finalize)
637 end subroutine gauge_field_finalize
638
639 ! ---------------------------------------------------------
640 subroutine gauge_field_init_interaction_as_partner(partner, interaction)
641 class(gauge_field_t), intent(in) :: partner
642 class(interaction_surrogate_t), intent(inout) :: interaction
643
645
646 select type (interaction)
647 class default
648 message(1) = "Unsupported interaction."
649 call messages_fatal(1)
650 end select
651
654
655 ! ---------------------------------------------------------
656 subroutine gauge_field_copy_quantities_to_interaction(partner, interaction)
657 class(gauge_field_t), intent(inout) :: partner
658 class(interaction_surrogate_t), intent(inout) :: interaction
659
661
662 select type (interaction)
663 class default
664 message(1) = "Unsupported interaction."
665 call messages_fatal(1)
666 end select
667
670
671end module gauge_field_oct_m
672
673!! Local Variables:
674!! mode: f90
675!! coding: utf-8
676!! End:
double sqrt(double __x) __attribute__((__nothrow__
This module implements the basic elements defining algorithms.
Definition: algorithm.F90:143
subroutine, public gauge_field_set_vec_pot_vel(this, vec_pot_vel)
subroutine, public gauge_field_output_write(this, out_gauge, iter)
subroutine, public gauge_field_set_vec_pot(this, vec_pot)
subroutine gauge_field_finalize(this)
subroutine, public gauge_field_get_vec_pot_acc(this, vec_pot_acc)
subroutine, public gauge_field_load(restart, gfield, ierr)
subroutine gauge_field_copy_quantities_to_interaction(partner, interaction)
subroutine, public gauge_field_get_force(this, gr, spin_channels, current, lrc)
subroutine, public gauge_field_end(this)
subroutine, public gauge_field_get_vec_pot(this, vec_pot)
subroutine, public gauge_field_do_algorithmic_operation(this, operation, dt, time)
subroutine, public gauge_field_check_symmetries(this, kpoints)
subroutine, public gauge_field_get_vec_pot_vel(this, vec_pot_vel)
class(gauge_field_t) function, pointer, public gauge_field_init(namespace, volume)
subroutine, public gauge_field_dump(restart, gfield, ierr)
subroutine gauge_field_init_interaction_as_partner(partner, interaction)
logical pure function, public gauge_field_is_propagated(this)
logical pure function, public gauge_field_is_used(this)
subroutine, public gauge_field_init_vec_pot(this, qtot)
real(real64) function, public gauge_field_get_energy(this)
subroutine gauge_field_propagate(this, dt, time)
real(real64), parameter, public m_zero
Definition: global.F90:191
real(real64), parameter, public m_epsilon
Definition: global.F90:207
This module implements the underlying real-space grid.
Definition: grid.F90:119
This module defines classes and functions for interaction partners.
This module defines various routines, operating on mesh functions.
This module defines the meshes, which are used in Octopus.
Definition: mesh.F90:120
subroutine, public messages_warning(no_lines, all_nodes, namespace)
Definition: messages.F90:525
character(len=256), dimension(max_lines), public message
to be output by fatal, warning
Definition: messages.F90:162
subroutine, public messages_fatal(no_lines, only_root_writes, namespace)
Definition: messages.F90:410
integer function, public parse_block(namespace, name, blk, check_varinfo_)
Definition: parser.F90:615
integer pure function, public symmetries_identity_index(this)
Definition: symmetries.F90:599
integer pure function, public symmetries_number(this)
Definition: symmetries.F90:553
brief This module defines the class unit_t which is used by the unit_systems_oct_m module.
Definition: unit.F90:134
This module defines the unit system, used for input and output.
Explicit interfaces to C functions, defined in write_iter_low.cc.
Definition: write_iter.F90:116
abstract class for general interaction partners
int true(void)