96 integer,
parameter,
public :: &
97 MULTIGRID_MX_TO_MA_EQUAL = 1, &
103 type(space_t) :: space
104 type(states_mxll_t) :: st
105 type(hamiltonian_mxll_t) :: hm
107 type(output_t) :: outp
108 type(multicomm_t) :: mc
110 type(mesh_interpolation_t) :: mesh_interpolate
112 type(propagator_mxll_t) :: tr_mxll
113 type(td_write_t) :: write_handler
114 type(c_ptr) :: output_handle
116 complex(real64),
allocatable :: ff_rs_inhom_t1(:,:), ff_rs_inhom_t2(:,:)
117 complex(real64),
allocatable :: rs_state_init(:,:)
118 type(time_interpolation_t),
pointer :: current_interpolation
119 real(real64) :: bc_bounds(2, 3), dt_bounds(2, 3)
120 integer :: energy_update_iter
121 type(restart_t) :: restart_dump
122 type(restart_t) :: restart
124 type(lattice_vectors_t) :: latt
126 type(helmholtz_decomposition_t) :: helmholtz
128 logical :: write_previous_state = .false.
151 procedure maxwell_constructor
158 class(maxwell_t),
pointer :: sys
159 type(namespace_t),
intent(in) :: namespace
173 class(maxwell_t),
intent(inout) :: this
174 type(namespace_t),
intent(in) :: namespace
181 this%namespace = namespace
185 this%space =
space_t(this%namespace)
186 if (this%space%is_periodic())
then
194 call this%quantities%add(
quantity_t(
"E field", updated_on_demand = .false.))
195 call this%quantities%add(
quantity_t(
"B field", updated_on_demand = .false.))
196 call this%quantities%add(
quantity_t(
"vector potential", updated_on_demand = .false.))
217 select type (interaction)
219 call interaction%init(this%gr)
221 call interaction%init(this%gr, this%st%dim)
222 call interaction%init_space_latt(this%space, this%latt)
226 select type (prop => this%algo)
236 message(1) =
"The chosen propagator does not yet support interaction interpolation"
239 call interaction%init_interpolation(depth, interaction%label, cmplx=.
true.)
241 this%hm%current_density_from_medium = .
true.
243 message(1) =
"Trying to initialize an unsupported interaction by Maxwell."
255 integer(int64) :: index_range(4)
256 integer :: ierr, ip, pos_index, rankmin
265 index_range(1) = this%gr%np_global
266 index_range(2) = this%st%nst
268 index_range(4) = 100000
272 index_range, (/ 5000, 1, 1, 1 /))
278 this%st%energy_rate =
m_zero
279 this%st%delta_energy =
m_zero
280 this%st%energy_via_flux_calc =
m_zero
281 this%st%trans_energy_rate =
m_zero
282 this%st%trans_delta_energy =
m_zero
283 this%st%trans_energy_via_flux_calc =
m_zero
284 this%st%plane_waves_energy_rate =
m_zero
285 this%st%plane_waves_delta_energy =
m_zero
286 this%st%plane_waves_energy_via_flux_calc =
m_zero
288 safe_allocate(this%rs_state_init(1:this%gr%np_part, 1:this%st%dim))
289 this%rs_state_init(:,:) =
m_z0
291 this%energy_update_iter = 1
293 call poisson_init(this%st%poisson, this%namespace, this%space, this%gr%der, this%mc, this%gr%stencil)
298 this%hm%propagation_apply = .
true.
300 if (
parse_is_defined(this%namespace,
'MaxwellIncidentWaves') .and. (this%tr_mxll%bc_plane_waves))
then
301 this%st%rs_state_plane_waves(:,:) =
m_z0
305 do ip = 1, this%st%selected_points_number
306 pos_index =
mesh_nearest_point(this%gr, this%st%selected_points_coordinate(:,ip), dmin, rankmin)
307 if (this%gr%mpi_grp%rank == rankmin)
then
308 this%st%selected_points_map(ip) = pos_index
310 this%st%selected_points_map(ip) = -1
315 this%st%selected_points_number)
316 call accel_write_buffer(this%st%buff_selected_points_map, this%st%selected_points_number, &
317 this%st%selected_points_map)
320 this%hm%plane_waves_apply = .
true.
321 this%hm%spatial_constant_apply = .
true.
323 call bc_mxll_init(this%hm%bc, this%namespace, this%space, this%gr, this%st)
324 this%bc_bounds(:,1:3) = this%hm%bc%bc_bounds(:,1:3)
326 this%dt_bounds(2, 1:3) = this%bc_bounds(1, 1:3)
327 this%dt_bounds(1, 1:3) = this%bc_bounds(1, 1:3) - this%gr%der%order * this%gr%spacing(1:3)
334 call zbatch_init(this%st%rs_stateb, 1, 1, this%st%dim, this%gr%np_part)
335 if (this%st%pack_states)
call this%st%rs_stateb%do_pack()
336 call this%st%rs_stateb%copy_to(this%st%rs_state_prevb)
337 call this%st%rs_stateb%copy_to(this%st%inhomogeneousb)
338 if (this%tr_mxll%bc_plane_waves)
then
339 call this%st%rs_stateb%copy_to(this%st%rs_state_plane_wavesb)
345 call this%helmholtz%init(this%namespace, this%gr, this%mc, this%space)
354 real(real64) :: courant
361 select type (algo => this%algo)
370 m_one/this%gr%spacing(3)**2))
373 write(
message(1),
'(a)')
'The timestep is too large compared to the Courant-Friedrichs-Lewy'
374 write(
message(2),
'(a)')
'stability condition. Time propagation might not be stable.'
378 if (
parse_is_defined(this%namespace,
'UserDefinedInitialMaxwellStates'))
then
383 this%st%rs_state(:,:) = this%st%rs_state + this%rs_state_init
384 if (this%tr_mxll%bc_plane_waves)
then
385 this%st%rs_state_plane_waves(:,:) = this%rs_state_init
391 if (this%tr_mxll%bc_constant)
then
393 algo%dt,
m_zero, this%st%rs_state, set_initial_state = .
true.)
398 if (
parse_is_defined(this%namespace,
'UserDefinedInitialMaxwellStates'))
then
399 safe_deallocate_a(this%rs_state_init)
405 call energy_mxll_calc(this%gr, this%st, this%hm, this%hm%energy, this%st%rs_state, &
406 this%st%rs_state_plane_waves)
410 this%st%selected_points_coordinate(:,:), this%st, this%gr)
412 call mxll_set_batch(this%st%rs_stateb, this%st%rs_state, this%gr%np, this%st%dim)
414 if (this%tr_mxll%bc_plane_waves)
then
415 call mxll_set_batch(this%st%rs_state_plane_wavesb, this%st%rs_state_plane_waves, this%gr%np, this%st%dim)
428 character(len=:),
allocatable,
intent(out) :: updated_quantities(:)
430 complex(real64),
allocatable :: charge_density_ext(:)
431 real(real64) :: current_time
434 call profiling_in(trim(this%namespace%get())//
":"//trim(operation%id))
436 current_time = this%iteration%value()
438 select type (algo => this%algo)
442 select case (operation%id)
447 safe_allocate(this%ff_rs_inhom_t1(1:this%gr%np_part, 1:this%hm%dim))
448 safe_allocate(this%ff_rs_inhom_t2(1:this%gr%np_part, 1:this%hm%dim))
451 safe_deallocate_a(this%ff_rs_inhom_t1)
452 safe_deallocate_a(this%ff_rs_inhom_t2)
455 if (this%hm%current_density_ext_flag .or. this%hm%current_density_from_medium)
then
456 call this%get_current(current_time, this%st%rs_current_density_t1)
457 call this%get_current(current_time+algo%dt, this%st%rs_current_density_t2)
464 safe_allocate(charge_density_ext(1:this%gr%np))
467 charge_density_ext =
m_z0
474 safe_deallocate_a(charge_density_ext)
478 this%st%rs_stateb, this%ff_rs_inhom_t1, this%ff_rs_inhom_t2, current_time, algo%dt)
480 updated_quantities = [
character(16) ::
"E field",
"B field",
"vector potential"]
483 if (any(this%hm%bc%bc_ab_type == option__maxwellabsorbingboundaries__cpml))
then
490 if (this%hm%current_density_ext_flag .or. this%hm%current_density_from_medium)
then
491 call this%get_current(current_time, this%st%rs_current_density_t1)
492 call mxll_set_batch(this%st%inhomogeneousb, this%st%rs_current_density_t1, this%gr%np, this%st%dim)
497 current_time, algo%dt, this%iteration%counter())
499 updated_quantities = [
character(16) ::
"E field",
"B field",
"vector potential"]
502 safe_allocate(this%ff_rs_inhom_t1(1:this%gr%np_part, 1:this%hm%dim))
503 if (any(this%hm%bc%bc_ab_type == option__maxwellabsorbingboundaries__cpml))
then
508 safe_deallocate_a(this%ff_rs_inhom_t1)
511 if (this%hm%current_density_ext_flag .or. this%hm%current_density_from_medium)
then
512 call this%get_current(current_time+algo%dt*
m_half, this%st%rs_current_density_t1)
520 current_time, algo%dt)
522 updated_quantities = [
character(16) ::
"E field",
"B field",
"vector potential"]
525 safe_allocate(this%ff_rs_inhom_t1(1:this%gr%np_part, 1:this%hm%dim))
526 safe_allocate(this%ff_rs_inhom_t2(1:this%gr%np_part, 1:this%hm%dim))
527 if (any(this%hm%bc%bc_ab_type == option__maxwellabsorbingboundaries__cpml))
then
532 safe_deallocate_a(this%ff_rs_inhom_t1)
533 safe_deallocate_a(this%ff_rs_inhom_t2)
536 if (this%hm%current_density_ext_flag .or. this%hm%current_density_from_medium)
then
537 call this%get_current(current_time+algo%dt*(
m_half-
sqrt(
m_three)/6.0_real64), this%st%rs_current_density_t1)
538 call this%get_current(current_time+algo%dt*(
m_half+
sqrt(
m_three)/6.0_real64), this%st%rs_current_density_t2)
552 current_time, algo%dt)
554 updated_quantities = [
character(16) ::
"E field",
"B field",
"vector potential"]
566 call profiling_out(trim(this%namespace%get())//
":"//trim(operation%id))
573 real(real64),
intent(in) :: tol
589 select type (interaction)
593 call interaction%init_from_partner(partner%gr, partner%space, partner%namespace)
595 call interaction%init_from_partner(partner%gr, partner%space, partner%namespace)
597 call interaction%init_from_partner(partner%gr, partner%space, partner%namespace)
599 message(1) =
"Unsupported interaction."
608 class(
maxwell_t),
intent(inout) :: partner
612 complex(real64) :: interpolated_value(3)
613 real(real64),
allocatable :: b_field(:,:), vec_pot(:,:)
616 call profiling_in(trim(partner%namespace%get())//
":"//
"COPY_QUANTITY_INTER")
618 select type (interaction)
620 call mxll_get_batch(partner%st%rs_stateb, partner%st%rs_state, partner%gr%np, partner%st%dim)
622 do ip = 1, interaction%system_np
624 interaction%system_pos(:, ip), interpolated_value(1))
626 interaction%system_pos(:, ip), interpolated_value(2))
628 interaction%system_pos(:, ip), interpolated_value(3))
634 call mxll_get_batch(partner%st%rs_stateb, partner%st%rs_state, partner%gr%np, partner%st%dim)
635 select case (interaction%type)
645 call partner%helmholtz%get_long_field(partner%namespace, partner%st%rs_state_long, total_field=partner%st%rs_state)
649 message(1) =
"Unknown type of field requested by interaction."
652 call interaction%do_mapping()
655 call mxll_get_batch(partner%st%rs_stateb, partner%st%rs_state, partner%gr%np, partner%st%dim)
656 safe_allocate(b_field(1:partner%gr%np_part, 1:partner%gr%box%dim))
657 safe_allocate(vec_pot(1:partner%gr%np_part, 1:partner%gr%box%dim))
660 partner%st%mu(1:partner%gr%np), partner%gr%np)
662 call partner%helmholtz%get_vector_potential(partner%namespace, vec_pot, trans_field=b_field)
666 interaction%partner_field(1:partner%gr%np,1:partner%gr%box%dim) = &
667 vec_pot(1:partner%gr%np,1:partner%gr%box%dim)
668 safe_deallocate_a(b_field)
669 safe_deallocate_a(vec_pot)
670 call interaction%do_mapping()
673 call mxll_get_batch(partner%st%rs_stateb, partner%st%rs_state, partner%gr%np, partner%st%dim)
675 interaction%partner_field, partner%st%mu(1:partner%gr%np), partner%gr%np)
676 call interaction%do_mapping()
679 message(1) =
"Unsupported interaction."
683 call profiling_out(trim(partner%namespace%get())//
":"//
"COPY_QUANTITY_INTER")
691 real(real64) :: itr_value
694 call profiling_in(trim(this%namespace%get())//
":"//
"OUTPUT_START")
696 select type (algo => this%algo)
698 call mxll_get_batch(this%st%rs_stateb, this%st%rs_state, this%gr%np, this%st%dim)
701 if (this%st%fromScratch)
then
702 call td_write_mxll_iter(this%write_handler, this%space, this%gr, this%st, this%hm, this%helmholtz, algo%dt, &
703 this%iteration%counter(), this%namespace)
704 itr_value = this%iteration%value()
705 call td_write_mxll_free_data(this%write_handler, this%namespace, this%space, this%gr, this%st, this%hm, this%helmholtz, &
706 this%outp, this%iteration%counter(), itr_value)
711 call profiling_out(trim(this%namespace%get())//
":"//
"OUTPUT_START")
719 logical :: stopping, reached_output_interval
720 real(real64) :: itr_value
724 call profiling_in(trim(this%namespace%get())//
":"//
"OUTPUT_WRITE")
726 select type (algo => this%algo)
730 call td_write_mxll_iter(this%write_handler, this%space, this%gr, this%st, this%hm, this%helmholtz, algo%dt, &
731 this%iteration%counter(), this%namespace)
733 reached_output_interval = .false.
735 if (this%outp%output_interval(iout) > 0)
then
736 if (mod(this%iteration%counter(), this%outp%output_interval(iout)) == 0)
then
737 reached_output_interval = .
true.
743 if (reached_output_interval .or. stopping)
then
744 call mxll_get_batch(this%st%rs_stateb, this%st%rs_state, this%gr%np, this%st%dim)
746 itr_value = this%iteration%value()
747 call td_write_mxll_free_data(this%write_handler, this%namespace, this%space, this%gr, this%st, this%hm, this%helmholtz, &
748 this%outp, this%iteration%counter(), itr_value)
753 call profiling_out(trim(this%namespace%get())//
":"//
"OUTPUT_WRITE")
766 select type (algo => this%algo)
781 integer :: int_counter
786 call iter%start(this%interactions)
787 do while (iter%has_next())
788 select type (interaction => iter%get_next())
790 int_counter = int_counter + 1
794 if (int_counter /= 0 .and. .not.
allocated(this%hm%medium_boxes))
then
795 safe_allocate(this%hm%medium_boxes(1:int_counter))
796 this%hm%calc_medium_box = .
true.
813 call iter%start(this%interactions)
814 do while (iter%has_next())
815 select type (interaction => iter%get_next())
817 if (
allocated(this%hm%medium_boxes) .and. .not. this%hm%medium_boxes_initialized)
then
819 this%hm%medium_boxes(iint) = interaction%medium_box
824 if (
allocated(this%hm%medium_boxes) .and. .not. this%hm%medium_boxes_initialized)
then
826 this%hm%medium_boxes_initialized = .
true.
829 if (this%hm%medium_boxes_initialized .and. this%hm%operator ==
faraday_ampere)
then
830 message(1) =
"A linear medium has been defined in the input file but the Hamiltonian"
831 message(2) =
"type you specified is not capable of dealing with the medium."
832 message(3) =
"Please use MaxwellHamiltonianOperator = faraday_ampere_medium or simple to enable"
833 message(4) =
"the medium propagation."
838 message(1) =
"The variable MaxwellHamiltonianOperator has been defined as faraday_ampere_medium"
839 message(2) =
"in the input file but no linear medium has been defined in the system block."
840 message(3) =
"Please either use a different option for MaxwellHamiltonianOperator or add"
841 message(4) =
"a linear medium to the system block."
852 integer :: ierr, err, zff_dim, id, id1, id2, ip_in, offset, iout
853 logical :: pml_check, write_previous_state
854 complex(real64),
allocatable :: zff(:,:)
859 call profiling_in(trim(this%namespace%get())//
":"//
"RESTART_WRITE")
865 if (this%write_handler%out(iout)%write)
then
866 call write_iter_flush(this%write_handler%out(iout)%handle)
872 pml_check = any(this%hm%bc%bc_ab_type(1:3) == option__maxwellabsorbingboundaries__cpml)
874 message(1) =
"Debug: Writing td_maxwell restart."
877 if (this%tr_mxll%bc_plane_waves)
then
878 zff_dim = 2 * this%st%dim
880 zff_dim = 1 * this%st%dim
883 zff_dim = zff_dim + 18
885 select type (prop => this%algo)
887 write_previous_state = .
true.
888 zff_dim = zff_dim + this%st%dim
890 write_previous_state = .false.
894 int(this%hm%bc%pml%points_number, int64)*3*3, this%hm%bc%pml%conv_plus)
896 int(this%hm%bc%pml%points_number, int64)*3*3, this%hm%bc%pml%conv_minus)
899 call mxll_get_batch(this%st%rs_stateb, this%st%rs_state, this%gr%np, this%st%dim)
900 if (write_previous_state)
then
901 call mxll_get_batch(this%st%rs_state_prevb, this%st%rs_state_prev, this%gr%np, this%st%dim)
904 safe_allocate(zff(1:this%gr%np,1:zff_dim))
907 zff(1:this%gr%np, 1:this%st%dim) = this%st%rs_state(1:this%gr%np, 1:this%st%dim)
908 if (this%tr_mxll%bc_plane_waves)
then
909 call mxll_get_batch(this%st%rs_state_plane_wavesb, this%st%rs_state_plane_waves, &
910 this%gr%np, this%st%dim)
911 zff(1:this%gr%np, this%st%dim+1:this%st%dim+this%st%dim) = &
912 this%st%rs_state_plane_waves(1:this%gr%np, 1:this%st%dim)
913 offset = 2*this%st%dim
922 do ip_in = 1, this%hm%bc%pml%points_number
923 zff(ip_in, offset+id) = this%hm%bc%pml%conv_plus(ip_in, id1, id2)
924 zff(ip_in, offset+9+id) = this%hm%bc%pml%conv_minus(ip_in, id1, id2)
930 if (write_previous_state)
then
931 zff(1:this%gr%np, offset+1:offset+this%st%dim) = &
932 this%st%rs_state_prev(1:this%gr%np, 1:this%st%dim)
935 call states_mxll_dump(this%restart_dump, this%st, this%space, this%gr, zff, zff_dim, err, this%iteration%counter())
936 if (err /= 0) ierr = ierr + 1
938 if (this%hm%current_density_from_medium)
then
940 call iter%start(this%interactions)
941 do while (iter%has_next())
942 interaction => iter%get_next()
943 select type (interaction)
945 call interaction%write_restart(this%gr, this%space, this%restart_dump, err)
948 if (err /= 0) ierr = ierr + 1
951 message(1) =
"Debug: Writing td_maxwell restart done."
954 safe_deallocate_a(zff)
957 message(1) =
"Unable to write time-dependent Maxwell restart information."
962 call profiling_out(trim(this%namespace%get())//
":"//
"RESTART_WRITE")
971 integer :: ierr, err, zff_dim, id, id1, id2, ip_in, offset
972 logical :: pml_check, read_previous_state
973 complex(real64),
allocatable :: zff(:,:)
978 call profiling_in(trim(this%namespace%get())//
":"//
"RESTART_READ")
982 pml_check = any(this%hm%bc%bc_ab_type(1:3) == option__maxwellabsorbingboundaries__cpml)
986 call profiling_out(trim(this%namespace%get())//
":"//
"RESTART_READ")
991 message(1) =
"Debug: Reading td_maxwell restart."
994 if (this%tr_mxll%bc_plane_waves)
then
995 zff_dim = 2 * this%st%dim
997 zff_dim = 1 * this%st%dim
1000 zff_dim = zff_dim + 18
1002 select type (prop => this%algo)
1004 read_previous_state = .
true.
1005 zff_dim = zff_dim + this%st%dim
1007 read_previous_state = .false.
1010 safe_allocate(zff(1:this%gr%np,1:zff_dim))
1012 call states_mxll_load(this%restart, this%st, this%gr, this%namespace, this%space, zff, &
1013 zff_dim, err, label =
": td_maxwell")
1014 this%st%rs_current_density_restart = .
true.
1016 this%st%rs_state(1:this%gr%np,1:this%st%dim) = zff(1:this%gr%np, 1:this%st%dim)
1017 if (this%tr_mxll%bc_plane_waves)
then
1018 this%st%rs_state_plane_waves(1:this%gr%np,1:this%st%dim) = &
1019 zff(1:this%gr%np,this%st%dim+1:this%st%dim+3)
1020 offset = 2*this%st%dim
1022 offset = this%st%dim
1029 do ip_in = 1, this%hm%bc%pml%points_number
1030 this%hm%bc%pml%conv_plus(ip_in,id1,id2) = zff(ip_in, offset+ id)
1031 this%hm%bc%pml%conv_minus(ip_in,id1,id2) = zff(ip_in, offset+9+id)
1035 this%hm%bc%pml%conv_plus_old = this%hm%bc%pml%conv_plus
1036 this%hm%bc%pml%conv_minus_old = this%hm%bc%pml%conv_minus
1037 offset = offset + 18
1039 if (read_previous_state)
then
1040 this%st%rs_state_prev(1:this%gr%np, 1:this%st%dim) = &
1041 zff(1:this%gr%np, offset+1:offset+this%st%dim)
1048 message(1) =
"Debug: Reading td restart done."
1051 safe_deallocate_a(zff)
1055 int(this%hm%bc%pml%points_number, int64)*3*3, this%hm%bc%pml%conv_plus)
1057 int(this%hm%bc%pml%points_number, int64)*3*3, this%hm%bc%pml%conv_minus)
1059 int(this%hm%bc%pml%points_number, int64)*3*3, this%hm%bc%pml%conv_plus_old)
1062 if (this%hm%current_density_from_medium)
then
1064 call iter%start(this%interactions)
1065 do while (iter%has_next())
1066 interaction => iter%get_next()
1067 select type (interaction)
1069 call interaction%read_restart(this%gr, this%space, this%restart, err)
1078 call mxll_set_batch(this%st%rs_stateb, this%st%rs_state, this%gr%np, this%st%dim)
1079 if (read_previous_state)
then
1080 call mxll_set_batch(this%st%rs_state_prevb, this%st%rs_state_prev, this%gr%np, this%st%dim)
1083 if (this%tr_mxll%bc_plane_waves)
then
1084 call mxll_set_batch(this%st%rs_state_plane_wavesb, this%st%rs_state_plane_waves, this%gr%np, this%st%dim)
1087 this%st%fromScratch = .false.
1090 message(1) =
"Unable to read time-dependent Maxwell restart information: Starting from scratch"
1095 call profiling_out(trim(this%namespace%get())//
":"//
"RESTART_READ")
1109 this%kinetic_energy = this%hm%energy%energy
1119 call profiling_in(trim(this%namespace%get())//
":"//
"END_TIMESTEP")
1122 call energy_mxll_calc_batch(this%gr, this%st, this%hm, this%hm%energy, this%st%rs_stateb, this%st%rs_state_plane_wavesb)
1128 call profiling_out(trim(this%namespace%get())//
":"//
"END_TIMESTEP")
1135 real(real64),
intent(in) :: time
1136 complex(real64),
contiguous,
intent(inout) :: current(:, :)
1139 complex(real64),
allocatable :: current_density_ext(:, :)
1143 safe_allocate(current_density_ext(1:this%gr%np, 1:this%st%dim))
1145 if (this%hm%current_density_from_medium)
then
1147 call iter%start(this%interactions)
1148 do while (iter%has_next())
1149 select type (interaction => iter%get_next())
1151 call interaction%interpolate(time, current_density_ext)
1152 call lalg_axpy(this%gr%np, 3,
m_one, current_density_ext * this%hm%current_factor, current)
1157 if (this%hm%current_density_ext_flag)
then
1159 call lalg_axpy(this%gr%np, 3,
m_one, current_density_ext, current)
1161 safe_deallocate_a(current_density_ext)
1178 safe_deallocate_a(this%rs_state_init)
1183 call this%st%rs_stateb%end()
1184 call this%st%rs_state_prevb%end()
1185 call this%st%inhomogeneousb%end()
1186 if (this%tr_mxll%bc_plane_waves)
then
1187 call this%st%rs_state_plane_wavesb%end()
scale a batch by a constant or vector
constant times a vector plus a vector
pure logical function, public accel_is_enabled()
integer, parameter, public accel_mem_read_only
This module defines the abstract interfact for algorithm factories.
This module implements the basic elements defining algorithms.
character(len=algo_label_len), parameter, public iteration_done
This module implements batches of mesh functions.
subroutine, public zbatch_init(this, dim, st_start, st_end, np, special, packed)
initialize a TYPE_CMPLX valued batch to given size without providing external memory
This module implements common operations on batches of mesh functions.
subroutine, public batch_set_zero(this, np, async)
fill all mesh functions of the batch with zero
This module handles the calculation mode.
type(calc_mode_par_t), public calc_mode_par
Singleton instance of parallel calculation mode.
This module calculates the derivatives (gradients, Laplacians, etc.) of a function.
subroutine, public get_rs_density_ext(st, space, mesh, time, rs_current_density_ext)
subroutine, public external_current_init(st, space, namespace, mesh)
This module implements the field transfer.
real(real64), parameter, public m_zero
real(real64), parameter, public m_fourth
complex(real64), parameter, public m_z0
real(real64), parameter, public m_half
real(real64), parameter, public p_c
Electron gyromagnetic ratio, see Phys. Rev. Lett. 130, 071801 (2023)
real(real64), parameter, public m_one
real(real64), parameter, public m_three
This module implements the underlying real-space grid.
subroutine, public grid_init_stage_1(gr, namespace, space, symm, latt, n_sites, site_position)
First stage of the grid initialization.
subroutine, public grid_init_stage_2(gr, namespace, space, mc, qvector)
Second stage of the grid initialization.
subroutine, public grid_end(gr)
finalize a grid object
subroutine, public hamiltonian_mxll_init(hm, namespace, gr, st)
Initializing the Maxwell Hamiltonian.
integer, parameter, public faraday_ampere
subroutine, public hamiltonian_mxll_end(hm)
integer, parameter, public faraday_ampere_medium
subroutine, public hamiltonian_mxll_update(this, time)
Maxwell Hamiltonian update (here only the time is updated, can maybe be added to another routine)
The Helmholtz decomposition is intended to contain "only mathematical" functions and procedures to co...
This module implements the index, used for the mesh points.
integer, parameter, public mxll_vec_pot_to_matter
integer, parameter, public linear_medium_to_em_field
integer, parameter, public lorentz_force
integer, parameter, public mxll_b_field_to_matter
integer, parameter, public mxll_e_field_to_matter
integer, parameter, public current_to_mxll_field
This module defines the abstract interaction_t class, and some auxiliary classes for interactions.
This module is intended to contain "only mathematical" functions and procedures.
subroutine, public bc_mxll_init(bc, namespace, space, gr, st)
subroutine, public surface_grid_points_mapping(mesh, st, bounds)
subroutine, public bc_mxll_initialize_pml_simple(bc, space, gr, c_factor, dt)
subroutine, public inner_and_outer_points_mapping(mesh, st, bounds)
subroutine maxwell_update_interactions_start(this)
subroutine maxwell_exec_end_of_timestep_tasks(this)
subroutine maxwell_init_interaction(this, interaction)
subroutine maxwell_output_start(this)
subroutine maxwell_update_interactions_finish(this)
subroutine maxwell_init_interaction_as_partner(partner, interaction)
subroutine maxwell_output_finish(this)
subroutine maxwell_restart_write_data(this)
logical function maxwell_do_algorithmic_operation(this, operation, updated_quantities)
integer, parameter, public multigrid_mx_to_ma_large
subroutine maxwell_init_parallelization(this, grp)
subroutine maxwell_get_current(this, time, current)
subroutine, public maxwell_init(this, namespace)
subroutine maxwell_initialize(this)
subroutine maxwell_output_write(this)
logical function maxwell_is_tolerance_reached(this, tol)
class(maxwell_t) function, pointer maxwell_constructor(namespace)
subroutine maxwell_update_kinetic_energy(this)
logical function maxwell_restart_read_data(this)
subroutine maxwell_finalize(this)
subroutine maxwell_copy_quantities_to_interaction(partner, interaction)
subroutine, public mesh_interpolation_init(this, mesh)
This module defines the meshes, which are used in Octopus.
integer(int64) function, public mesh_global_index_from_coords(mesh, ix)
This function returns the true global index of the point for a given vector of integer coordinates.
integer function, public mesh_nearest_point(mesh, pos, dmin, rankmin)
Returns the index of the point which is nearest to a given vector position pos.
subroutine, public messages_print_with_emphasis(msg, iunit, namespace)
subroutine, public messages_not_implemented(feature, namespace)
character(len=512), private msg
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_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.
subroutine, public multicomm_end(mc)
subroutine, public multicomm_init(mc, namespace, base_grp, mode_para, n_node, index_range, min_range)
create index and domain communicators
integer, parameter, public mxll_field_total
integer, parameter, public mxll_field_trans
integer, parameter, public mxll_field_long
this module contains the low-level part of the output system
subroutine, public output_mxll_init(outp, namespace, space)
this module contains the output system
logical function, public parse_is_defined(namespace, name)
subroutine, public poisson_init(this, namespace, space, der, mc, stencil, qtot, label, solver, verbose, force_serial, force_cmplx)
subroutine, public poisson_end(this)
subroutine, public profiling_out(label)
Increment out counter and sum up difference between entry and exit time.
subroutine, public profiling_in(label, exclude)
Increment in counter and save entry time.
character(len=algo_label_len), parameter, public exp_gauss1_start
character(len=algo_label_len), parameter, public exp_gauss1_finish
character(len=algo_label_len), parameter, public exp_gauss1_extrapolate
character(len=algo_label_len), parameter, public exp_gauss1_propagate
character(len=algo_label_len), parameter, public exp_gauss2_finish
character(len=algo_label_len), parameter, public exp_gauss2_propagate
character(len=algo_label_len), parameter, public exp_gauss2_extrapolate
character(len=algo_label_len), parameter, public exp_gauss2_start
character(len=algo_label_len), parameter, public expmid_extrapolate
character(len=algo_label_len), parameter, public expmid_finish
character(len=algo_label_len), parameter, public expmid_start
character(len=algo_label_len), parameter, public expmid_propagate
character(len=algo_label_len), parameter, public leapfrog_propagate
character(len=algo_label_len), parameter, public leapfrog_finish
character(len=algo_label_len), parameter, public leapfrog_start
subroutine, public mxll_propagate_expgauss2(hm, namespace, gr, space, st, tr, time, dt)
Exponential propagation scheme with Gauss collocation points, s=2.
subroutine, public energy_mxll_calc_batch(gr, st, hm, energy_mxll, rs_fieldb, rs_field_plane_wavesb)
integer, parameter, public rs_trans_forward
subroutine, public mxll_propagate_leapfrog(hm, namespace, gr, space, st, tr, time, dt, counter)
subroutine, public mxll_propagate_expgauss1(hm, namespace, gr, space, st, tr, time, dt)
Exponential propagation scheme with Gauss collocation points, s=1.
subroutine, public mxll_propagation_step(hm, namespace, gr, space, st, tr, rs_stateb, ff_rs_inhom_t1, ff_rs_inhom_t2, time, dt)
subroutine, public spatial_constant_calculation(constant_calc, st, gr, hm, time, dt, delay, rs_state, set_initial_state)
subroutine, public set_medium_rs_state(st, gr, hm)
subroutine, public transform_rs_densities(hm, mesh, rs_charge_density, rs_current_density, ff_density, sign)
subroutine, public energy_mxll_calc(gr, st, hm, energy_mxll, rs_field, rs_field_plane_waves)
subroutine, public propagator_mxll_init(gr, namespace, st, hm, tr)
This module implements the basic propagator framework.
character(len=algo_label_len), parameter, public store_current_status
This module defines the quantity_t class and the IDs for quantities, which can be exposed by a system...
Implementation details for regridding.
logical function, public clean_stop(comm)
returns true if a file named stop exists
subroutine, public restart_init(restart, namespace, data_type, type, mc, ierr, mesh, dir, exact)
Initializes a restart object.
integer, parameter, public restart_type_dump
logical pure function, public restart_skip(restart)
Returns true if the restart information should neither be read nor written. This might happen because...
integer, parameter, public restart_td
integer, parameter, public restart_type_load
subroutine, public restart_end(restart)
This module is intended to contain "only mathematical" functions and procedures.
subroutine, public mxll_set_batch(rs_stateb, rs_state, np, dim, offset)
subroutine, public get_rs_state_at_point(rs_state_point, rs_state, pos, st, mesh)
subroutine, public get_electric_field_vector(rs_state_vector, electric_field_vector, ep_element)
subroutine, public get_transverse_rs_state(helmholtz, st, namespace)
subroutine, public mxll_get_batch(rs_stateb, rs_state, np, dim, offset)
subroutine, public get_rs_state_batch_selected_points(rs_state_point, rs_stateb, st, mesh)
subroutine, public states_mxll_end(st)
subroutine, public states_mxll_allocate(st, mesh)
Allocates the Maxwell states defined within a states_mxll_t structure.
subroutine, public states_mxll_init(st, namespace, space)
subroutine, public get_electric_field_state(rs_state, mesh, electric_field, ep_field, np)
subroutine, public get_magnetic_field_state(rs_state, mesh, rs_sign, magnetic_field, mu_field, np)
subroutine, public get_magnetic_field_vector(rs_state_vector, rs_sign, magnetic_field_vector, mu_element)
subroutine, public states_mxll_load(restart, st, mesh, namespace, space, zff, zff_dim, ierr, iter, lowest_missing, label, verbose)
subroutine, public states_mxll_dump(restart, st, space, mesh, zff, zff_dim, ierr, iter, st_start_writing, verbose)
subroutine, public states_mxll_read_user_def(namespace, space, mesh, der, st, bc, user_def_rs_state)
This module implements the abstract system type.
subroutine, public system_init_parallelization(this, grp)
Basic functionality: copy the MPI group. This function needs to be implemented by extended types that...
subroutine, public system_end(this)
integer, parameter, public out_maxwell_max
subroutine, public td_write_mxll_init(writ, namespace, iter, dt)
subroutine, public td_write_mxll_end(writ)
subroutine, public td_write_mxll_free_data(writ, namespace, space, gr, st, hm, helmholtz, outp, iter, time)
subroutine, public td_write_mxll_iter(writ, space, gr, st, hm, helmholtz, dt, iter, namespace)
type(type_t), public type_integer
brief This module defines the class unit_t which is used by the unit_systems_oct_m module.
This module defines the unit system, used for input and output.
Descriptor of one algorithmic operation.
Class to transfer a current to a Maxwell field.
These class extend the list and list iterator to make an interaction list.
abstract interaction class
surrogate interaction class to avoid circular dependencies between modules.
Lorenz force between a systems of particles and an electromagnetic field.
Class describing Maxwell systems.
This is defined even when running serial.
class to transfer a Maxwell B field to a matter system
class to transfer a Maxwell field to a medium
class to transfer a Maxwell vector potential to a medium
Implements the an exponential RK scheme with Gauss collocation points, s=1 see also Hochbruck,...
Implements the an exponential RK scheme with Gauss collocation points, s=2 see also Hochbruck,...
Implements the explicit exponential midpoint propagator (without predictor-corrector)
Implements a propagator for the leap frog algorithm.
Abstract class implementing propagators.
Systems (system_t) can expose quantities that can be used to calculate interactions with other system...
Abstract class for systems.