37 use,
intrinsic :: iso_fortran_env
75 integer,
allocatable :: helicity(:)
76 integer,
allocatable :: m_order(:)
77 real(real64),
allocatable :: amp(:)
78 real(real64),
allocatable :: theta_k(:)
79 real(real64),
allocatable :: omega(:)
80 real(real64),
allocatable :: shift(:,:)
81 logical,
allocatable :: envelope(:)
82 integer,
allocatable :: lin_dir(:)
90 integer :: points_number
91 integer,
allocatable :: points_map(:)
93 integer,
allocatable :: modus(:)
94 integer,
allocatable :: field_type(:)
95 character(len=1024),
allocatable :: e_field_string(:,:)
96 real(real64),
allocatable :: k_vector(:,:)
97 real(real64),
allocatable :: v_vector(:,:)
98 complex(real64),
allocatable :: e_field(:,:)
99 real(real64),
allocatable :: pw_phase(:)
100 type(mxf_t),
allocatable :: mx_function(:)
102 logical :: output_from_point = .false.
103 real(real64),
allocatable :: selected_point_coordinate(:)
104 real(real64),
allocatable :: selected_point_field(:)
105 real(real64) :: c_factor
106 type(accel_mem_t) :: buff_map
107 type(bessel_beam_t) :: bessel
122 class(external_waves_t),
pointer :: this
123 type(namespace_t),
intent(in) :: namespace
126 character(len=:),
allocatable :: quantities(:)
132 this%namespace = namespace_t(
"ExternalSource", parent=namespace)
134 message(1) =
'Plane-wave is currently always 3D and non-periodic.'
138 quantities = [
character(16) ::
"E field",
"vector potential",
"B field"]
139 do iq = 1,
size(quantities)
140 call this%quantities%add(
quantity_t(quantities(iq), always_available = .
true., &
141 updated_on_demand = .
true., iteration =
clock_t()))
152 class(external_waves_t),
intent(in) :: partner
153 class(interaction_surrogate_t),
intent(inout) :: interaction
157 select type (interaction)
176 character(len=*),
intent(in) :: label
181 case (
"E field",
"B field",
"vector potential")
202 select type(interaction)
204 quantity => partner%quantities%get(
"E field")
206 call external_waves_eval(partner, quantity%iteration%value(), interaction%system_gr,
"E field", &
207 interaction%system_field)
208 call interaction%do_mapping()
211 quantity => partner%quantities%get(
"vector potential")
212 interaction%system_field =
m_zero
214 "vector potential", interaction%system_field)
215 call interaction%do_mapping()
218 quantity => partner%quantities%get(
"B field")
219 interaction%system_field =
m_zero
220 call external_waves_eval(partner, quantity%iteration%value(), interaction%system_gr,
"B field", &
221 interaction%system_field, der=interaction%system_gr%der)
222 call interaction%do_mapping()
225 message(1) =
"Incompatible interaction."
236 type(namespace_t),
intent(in) :: namespace
238 logical :: has_source
249 call parse_variable(namespace,
'AnalyticalExternalSource', .false., has_source)
263 type(namespace_t),
intent(in) :: namespace
265 integer :: il, nlines, ncols, iex_norm, idim
266 integer,
parameter :: sys_dim = 3
267 real(real64) :: k_vector(sys_dim), velocity(sys_dim), x_pos(sys_dim)
268 real(real64) :: x_norm, dummy(sys_dim), k_dot_e , test_limit, k_norm, output_pos(3)
269 complex(real64) :: e_field(sys_dim)
270 character(len=1024) :: k_string(sys_dim)
271 character(len=1),
dimension(sys_dim),
parameter :: dims = [
"x",
"y",
"z"]
272 character(len=1024) :: mxf_expression
278 test_limit = 10.0e-9_real64
296 if (
parse_block(namespace,
'ExternalSourceBesselOutput', blk) == 0)
then
298 if (nlines > 1 )
then
299 message(2) =
'ExternalSource output is limited to one point.'
303 if (ncols /= 3 )
then
304 message(1) =
'ExternalSourceBesselOutput must have 3 columns.'
307 external_waves%output_from_point= .
true.
308 safe_allocate(external_waves%selected_point_coordinate(1:3))
309 safe_allocate(external_waves%selected_point_field(1:3))
314 external_waves%selected_point_coordinate(1:3) = output_pos(1:3)
315 external_waves%selected_point_field(1:3) =
m_zero
319 external_waves%out_file =
io_open(
'bessel_source_at_point', namespace=namespace, action=
'write')
320 write(external_waves%out_file,
'(12a) ')
'# Time (a.u.) ' ,
' Field-x ' ,
' Field-y ' ,
' Field-z '
323 external_waves%output_from_point= .false.
367 if (
parse_block(namespace,
'MaxwellIncidentWaves', blk) == 0)
then
374 external_waves%number = nlines
375 safe_allocate(external_waves%modus(1:nlines))
376 safe_allocate(external_waves%e_field_string(1:3, 1:nlines))
377 safe_allocate(external_waves%e_field(1:3, 1:nlines))
378 safe_allocate(external_waves%k_vector(1:3, 1:nlines))
379 safe_allocate(external_waves%v_vector(1:3, 1:nlines))
380 safe_allocate(external_waves%mx_function(1:nlines))
381 safe_allocate(external_waves%field_type(1:nlines))
382 safe_allocate(external_waves%pw_phase(1:nlines))
383 external_waves%pw_phase =
m_zero
385 call external_waves%bessel%init(nlines, 3)
389 if ((ncols < 5) .or. (ncols > 9))
then
390 message(1) =
'Each line in the MaxwellIncidentWaves block must have five to nine columns.'
399 if (external_waves%modus(il) == option__maxwellincidentwaves__plane_wave_parser)
then
402 call parse_block_string( blk, il - 1, 3 + idim + 1, external_waves%e_field_string(idim, il))
404 write(
message(1),
'(a,i2,a) ')
'Substituting electromagnetic incident wave ', il,
' with the expressions: '
407 write(
message(idim),
'(6a)')
' Wave vector k('//dims(idim)//
') = ', trim(k_string(idim))
408 write(
message(idim+1),
'(2a)')
' E-field('//dims(idim)//
') for t_0 = ', trim(external_waves%e_field_string(idim, il))
424 k_norm = norm2(k_vector)
426 velocity(:) = k_vector(:) / k_norm *
p_c * external_waves%c_factor
427 external_waves%k_vector(:,il) = k_vector(:)
428 external_waves%v_vector(:,il) = velocity(:)
430 else if (external_waves%modus(il) == option__maxwellincidentwaves__plane_wave_mx_function)
then
436 write(
message(1),
'(a,i2) ')
'Substituting electromagnetic incident wave ', il
437 write(
message(2),
'(a)' )
'with the expression: '
441 write(
message(idim),
'(a,f9.4,sp,f9.4,"i")')
' E-field('//trim(dims(idim))//
') complex amplitude = ', &
442 real(e_field(idim)), aimag(e_field(idim))
444 write(
message(4),
'(2a)' )
' Maxwell wave function name = ', trim(mxf_expression)
447 call mxf_read(external_waves%mx_function(il), namespace, trim(mxf_expression), iex_norm)
448 if (iex_norm /= 0)
then
449 write(
message(1),
'(3A)')
'Ex_norm in the ""', trim(mxf_expression), &
450 '"" field defined in the MaxwellIncidentWaves block'
457 k_vector(1:3) = external_waves%mx_function(il)%k_vector(1:3)
458 k_norm = norm2(k_vector)
460 k_dot_e = real(dot_product(k_vector, e_field), real64)
461 if (abs(k_dot_e) > test_limit)
then
462 write(
message(1),
'(a) ')
'The wave vector k or its electric field are not perpendicular. '
463 write(
message(2),
'(a,f8.3,a)' )
'Their dot product yields the magnitude', abs(k_dot_e) ,
' while'
464 write(
message(3),
'(a,f8.3,a)' )
'tolerance is ', test_limit ,
'.'
467 if (k_norm < 1e-10)
then
468 message(1) =
'The k vector is not set correctly: |k|~0 .'
472 external_waves%e_field(:,il) = e_field(:)
473 external_waves%k_vector(:,il) = k_vector(:)
474 external_waves%v_vector(:,il) = k_vector(:) / k_norm *
p_c * external_waves%c_factor
476 else if (external_waves%modus(il) == option__maxwellincidentwaves__bessel_function)
then
484 external_waves%bessel%envelope(il) = .
true.
485 call mxf_read(external_waves%mx_function(il), namespace, trim(mxf_expression), iex_norm)
491 write(
message(1),
'(a,i2) ')
'Incident Bessel Beam', il
494 if (abs(external_waves%bessel%helicity(il)) /= 1)
then
495 write(
message(1),
'(A)')
'Helicity has to be either +1 or -1 !'
499 write(
message(1),
'(a,f5.3)' )
' Bessel Amplitude ', external_waves%bessel%amp(il)
500 write(
message(2),
'(a,i2)' )
' Bessel Order m', external_waves%bessel%m_order(il)
501 write(
message(3),
'(a,f5.3)' )
' Bessel Frequency ', external_waves%bessel%omega(il)
502 write(
message(4),
'(a,i2)' )
' Bessel Helicity ', external_waves%bessel%helicity(il)
503 write(
message(5),
'(a,f5.3)' )
' Bessel Opening Angle ', external_waves%bessel%theta_k(il)
506 if (external_waves%bessel%lin_dir(il)/= 0)
then
507 write(
message(5),
'(a,i2)' )
' Bessel is Linearly Polarized in Direction : ', external_waves%bessel%lin_dir(il)
518 external_waves%number = 0
536 if (
parse_block(namespace,
'BesselBeamAxisShift', blk) == 0)
then
539 if (ncols /= 3 )
then
540 message(1) =
'BesselBeamAxisShift must have 3 columns.'
564 if (external_waves%output_from_point)
then
565 call io_close(external_waves%out_file)
566 safe_deallocate_a(external_waves%selected_point_coordinate)
567 safe_deallocate_a(external_waves%selected_point_field)
570 safe_deallocate_a(external_waves%bessel%shift)
571 safe_deallocate_a(external_waves%points_map)
572 safe_deallocate_a(external_waves%modus)
573 safe_deallocate_a(external_waves%e_field_string)
574 safe_deallocate_a(external_waves%k_vector)
575 safe_deallocate_a(external_waves%v_vector)
576 safe_deallocate_a(external_waves%e_field)
577 safe_deallocate_a(external_waves%mx_function)
578 safe_deallocate_a(external_waves%pw_phase)
589 subroutine external_waves_eval(external_waves, time, mesh, type_of_field, out_field_total, der)
591 real(real64),
intent(in) :: time
592 class(
mesh_t),
intent(in) :: mesh
593 character(len=*),
intent(in) :: type_of_field
594 real(real64),
intent(out) :: out_field_total(:, :)
604 call plane_waves_eval(external_waves, time, mesh, type_of_field, out_field_total, der=der)
605 call bessel_source_eval(external_waves, time, mesh, type_of_field, out_field_total, der=der)
614 subroutine plane_waves_eval(external_waves, time, mesh, type_of_field, out_field_total, der)
616 real(real64),
intent(in) :: time
617 class(
mesh_t),
intent(in) :: mesh
618 character(len=*),
intent(in) :: type_of_field
619 real(real64),
intent(out) :: out_field_total(:, :)
623 real(real64),
allocatable :: pw_field(:,:), ztmp(:,:), b_field_aux(:,:)
625 integer,
allocatable :: indices_pw_parser(:)
626 integer,
allocatable :: indices_mx_ftc(:)
627 integer :: n_plane_waves, n_points
633 indices_pw_parser = pack([(wn, wn = 1,external_waves%number)], &
634 external_waves%modus == option__maxwellincidentwaves__plane_wave_parser)
636 indices_mx_ftc = pack([(wn, wn = 1,external_waves%number)], &
637 external_waves%modus == option__maxwellincidentwaves__plane_wave_mx_function)
639 n_plane_waves =
size(indices_pw_parser) +
size(indices_mx_ftc)
641 p_c_ =
p_c * external_waves%c_factor
643 if (n_plane_waves == 0)
then
651 safe_allocate(ztmp(mesh%np,
size(out_field_total, dim=2)))
652 n_points = mesh%np_part
656 safe_allocate(pw_field(n_points,
size(out_field_total, dim=2)))
660 do wn = 1, external_waves%number
662 select case(external_waves%modus(wn))
663 case (option__maxwellincidentwaves__plane_wave_parser)
666 case (option__maxwellincidentwaves__plane_wave_mx_function)
670 select case (external_waves%field_type(wn))
674 select case (type_of_field)
676 out_field_total(1:mesh%np,:) = out_field_total(1:mesh%np,:) + pw_field(1:mesh%np,:)
677 case (
"vector potential")
680 safe_allocate(b_field_aux(1:mesh%np, 1:mesh%box%dim))
681 call get_pw_b_field(external_waves, mesh, wn, pw_field, b_field_aux)
682 out_field_total(:,:) = out_field_total(:,:) + b_field_aux(:,:)
683 safe_deallocate_a(b_field_aux)
688 select case (type_of_field)
691 case (
"vector potential")
692 out_field_total(1:mesh%np,:) = out_field_total(1:mesh%np,:) -
m_one/p_c_ * pw_field(1:mesh%np,1:3)
694 call dderivatives_curl(der, pw_field(1:mesh%np_part,1:3), ztmp(1:mesh%np,1:3), set_bc = .false.)
695 out_field_total(1:mesh%np,1:3) = out_field_total(1:mesh%np,1:3) -
m_one/p_c_ * ztmp(1:mesh%np, 1:3)
701 safe_deallocate_a(pw_field)
702 safe_deallocate_a(ztmp)
713 integer,
intent(in) :: wn
714 real(real64),
intent(in) :: time
715 class(
mesh_t),
intent(in) :: mesh
716 integer,
intent(in) :: n_points
717 real(real64),
intent(out) :: pw_field(:,:)
719 real(real64) :: x_prop(3), x_norm
720 real(real64) :: velocity_time(3)
721 real(real64) :: parsed_field(3)
722 real(real64) :: dummy(3)
725 velocity_time(:) = external_waves%v_vector(1:3, wn) * time
728 external_waves%e_field_string(idim, wn))
730 x_prop = mesh%x(ip, :) - velocity_time
731 x_norm = norm2(x_prop(1:3))
742 integer,
intent(in) :: wn
743 real(real64),
intent(in) :: time
744 class(
mesh_t),
intent(in) :: mesh
745 integer,
intent(in) :: n_points
746 real(real64),
intent(out) :: pw_field(:,:)
748 real(real64) :: x_prop(3), x_norm
749 real(real64) :: velocity_time(3)
750 complex(real64) :: efield_ip(3)
751 complex(real64) :: e0(3)
754 velocity_time(:) = external_waves%v_vector(1:3, wn) * time
755 e0(:) = external_waves%e_field(1:3, wn)
757 x_prop = mesh%x(ip, :) - velocity_time
758 x_norm = norm2(x_prop(1:3))
759 efield_ip =
mxf(external_waves%mx_function(wn), x_prop, external_waves%pw_phase(wn))
760 pw_field(ip, :) = real(e0(1:3) * efield_ip, real64)
767 subroutine get_pw_b_field(external_waves, mesh, pwidx, e_field, b_field)
769 class(
mesh_t),
intent(in) :: mesh
770 real(real64),
intent(in) :: e_field(:,:)
771 real(real64),
intent(out) :: b_field(:,:)
772 integer,
intent(in) :: pwidx
774 real(real64) :: k_vector(3), k_vector_abs
775 real(real64) :: velocity(3)
777 complex(real64) :: e0(3)
780 velocity = external_waves%v_vector(1:3, pwidx)
781 k_vector = external_waves%k_vector(1:3, pwidx)
782 k_vector_abs = norm2(k_vector(1:3))
783 e0 = external_waves%e_field(1:3, pwidx)
784 p_c_ =
p_c * external_waves%c_factor
788 b_field(ip, :) =
m_one/(p_c_ * k_vector_abs) * dcross_product(k_vector, e_field(ip, :))
795 subroutine bessel_source_eval(external_waves, time, mesh, type_of_field, out_field_total, der)
797 real(real64),
intent(in) :: time
798 class(
mesh_t),
intent(in) :: mesh
799 character(len=*),
intent(in) :: type_of_field
800 real(real64),
intent(out) :: out_field_total(:, :)
803 real(real64) :: dmin, omega, k_vector(3), c_factor
804 integer :: iline, wn, pos_index, n_points, rankmin
805 real(real64),
allocatable :: shift(:,:)
806 complex(real64),
allocatable :: bessel_field_total(:,:), ztmp(:,:), vec_pot(:,:)
807 integer,
allocatable :: indices_bessel_ftc(:)
808 type(
mxf_t) :: envelope_mxf
814 indices_bessel_ftc = pack([(wn, wn = 1,external_waves%number)], &
815 external_waves%modus == option__maxwellincidentwaves__bessel_function)
817 if (
size(indices_bessel_ftc) == 0)
then
824 if (
allocated(external_waves%bessel%shift) .and. &
825 size(external_waves%bessel%shift(:,1)) /=
size(indices_bessel_ftc))
then
826 message(1) =
'Number of BesselBeamAxisShift defined in input file'
827 message(2) =
'does not match the number of Bessel beams.'
831 safe_allocate(shift(
size(indices_bessel_ftc), 3))
832 if (
allocated(external_waves%bessel%shift))
then
833 shift = external_waves%bessel%shift
838 if (type_of_field ==
"B field")
then
840 safe_allocate(vec_pot(mesh%np_part,
size(out_field_total, dim=2)))
841 safe_allocate(ztmp(
size(out_field_total, dim=1),
size(out_field_total, dim=2)))
842 n_points = mesh%np_part
848 safe_allocate(bessel_field_total(1:n_points, 1:3))
849 bessel_field_total =
m_zero
851 do iline = 1,
size(indices_bessel_ftc)
852 wn = indices_bessel_ftc(iline)
853 omega = external_waves%bessel%omega(wn)
854 k_vector = external_waves%mx_function(wn)%k_vector
855 c_factor = external_waves%c_factor
856 envelope_mxf = external_waves%mx_function(wn)
858 call external_waves%bessel%function(wn, shift, mesh, n_points, time, k_vector, c_factor, envelope_mxf, bessel_field_total)
860 select case (external_waves%field_type(wn))
864 select case (type_of_field)
866 out_field_total(1:mesh%np,1:3) = out_field_total(1:mesh%np,1:3) + real(
m_zi*omega*bessel_field_total(1:mesh%np,1:3))
867 case (
"vector potential")
870 out_field_total(1:mesh%np,1:3) = out_field_total(1:mesh%np,1:3) -
m_one/
p_c * real(bessel_field_total(1:mesh%np,1:3))
872 call zderivatives_curl(der, bessel_field_total(1:mesh%np_part,1:3), ztmp(1:mesh%np,1:3), set_bc = .false.)
873 out_field_total(1:mesh%np,1:3) = out_field_total(1:mesh%np,1:3) -
m_one/
p_c * real(ztmp(1:mesh%np, 1:3))
878 select case (type_of_field)
880 out_field_total(1:mesh%np,1:3) = out_field_total(1:mesh%np,1:3) + real(bessel_field_total(1:mesh%np,1:3))
881 case (
"vector potential")
884 out_field_total(1:mesh%np,1:3) = out_field_total(1:mesh%np,1:3) -
m_one/
p_c * &
885 real(bessel_field_total(1:mesh%np,1:3)/M_zI/omega)
887 vec_pot(1:mesh%np_part,1:3) = -
m_one/
p_c * real(bessel_field_total(1:mesh%np_part,1:3)/m_zi/omega)
889 out_field_total(1:mesh%np,1:3) = out_field_total(1:mesh%np,1:3) - real(ztmp(1:mesh%np, 1:3))
895 if (external_waves%output_from_point)
then
896 pos_index =
mesh_nearest_point(mesh, external_waves%selected_point_coordinate(1:3), dmin, rankmin)
897 if (mesh%mpi_grp%rank == rankmin)
then
898 external_waves%selected_point_field(:) = out_field_total(pos_index,:)
899 write(external_waves%out_file,
"(4F14.8, 4x)") time, external_waves%selected_point_field(:)
903 safe_deallocate_a(shift)
904 safe_deallocate_a(ztmp)
905 safe_deallocate_a(vec_pot)
906 safe_deallocate_a(bessel_field_total)
915 subroutine bessel_beam_function(this, iline, shift, mesh, n_points, time, k_vector, c_factor, envelope_mxf, bessel_field)
917 integer,
intent(in) :: iline
918 real(real64),
intent(in) :: shift(:,:), time, k_vector(3), c_factor
919 class(
mesh_t),
intent(in) :: mesh
920 integer,
intent(in) :: n_points
921 type(
mxf_t),
intent(in) :: envelope_mxf
922 complex(real64),
intent(out) :: bessel_field(:,:)
924 real(real64) :: pos(3), temp, temp2, temp3, rho, phi_rho, wigner(3)
925 real(real64) :: hel, theta, omega, amp, kappa, proj, k_norm, velocity_time(3), x_prop(3)
926 complex(real64) :: efield_ip(3)
927 real(real64) :: bessel_plus, bessel_minus
928 integer :: ip, mm, pol
930 assert(iline <=
size(this%omega))
931 hel = real(this%helicity(iline), real64)
932 theta = this%theta_k(iline)
933 mm = this%m_order(iline)
935 omega = this%omega(iline)
936 proj = omega *
cos(theta) /
p_c
937 kappa =
sqrt(omega**2 - (proj*
p_c)**2)
940 wigner(2) = 0.5 * (1 + hel *
cos(theta))
941 wigner(3) = 0.5 * (1 - hel *
cos(theta))
942 proj = omega *
cos(theta) /
p_c
943 pol = this%lin_dir(iline)
946 pos(:) = mesh%x(ip, :) - shift(iline,:)
947 rho = norm2(pos(1:2))
948 phi_rho =
atan2(pos(2) , pos(1))
949 temp = proj * pos(3) + phi_rho * (mm + 1) - omega*time
950 temp2 = proj * pos(3) + phi_rho * (mm - 1) - omega*time
951 temp3 = proj * pos(3) + phi_rho * mm - omega*time
957 bessel_field(ip, 1) = amp * (
exp(
m_zi*temp) * wigner(3) * bessel_plus +
exp(
m_zi*temp2) * wigner(2) * bessel_minus)
961 bessel_field(ip, 2) =
m_zi * amp * (-
exp(
m_zi*temp) * wigner(3) * bessel_plus + &
962 exp(
m_zi*temp2) * wigner(2) * bessel_minus)
969 if (this%envelope(iline))
then
970 k_norm = norm2(k_vector)
971 velocity_time = k_vector *
p_c * c_factor * time / k_norm
972 x_prop(:) = pos(:) - velocity_time(:)
974 bessel_field(ip, :) = bessel_field(ip, :) * real(efield_ip, real64)
984 integer,
intent(in) :: nlines
985 integer,
intent(in) :: dim
987 safe_allocate(this%amp(1: nlines))
988 safe_allocate(this%omega(1:nlines))
989 safe_allocate(this%theta_k(1:nlines))
990 safe_allocate(this%m_order(1:nlines))
991 safe_allocate(this%helicity(1:nlines))
992 safe_allocate(this%shift(1:nlines, 1:dim))
993 safe_allocate(this%envelope(1:nlines))
994 safe_allocate(this%lin_dir(1:nlines))
1002 this%envelope = .false.
1010 safe_deallocate_a(this%amp)
1011 safe_deallocate_a(this%omega)
1012 safe_deallocate_a(this%theta_k)
1013 safe_deallocate_a(this%m_order)
1014 safe_deallocate_a(this%helicity)
1015 safe_deallocate_a(this%shift)
1016 safe_deallocate_a(this%lin_dir)
1017 safe_deallocate_a(this%envelope)
double exp(double __x) __attribute__((__nothrow__
double sin(double __x) __attribute__((__nothrow__
double cos(double __x) __attribute__((__nothrow__
double atan2(double __y, double __x) __attribute__((__nothrow__
subroutine, public accel_release_buffer(this)
pure logical function, public accel_is_enabled()
This module calculates the derivatives (gradients, Laplacians, etc.) of a function.
subroutine, public zderivatives_curl(der, ff, op_ff, ghost_update, set_bc)
apply the curl operator to a vector of mesh functions
subroutine, public dderivatives_curl(der, ff, op_ff, ghost_update, set_bc)
apply the curl operator to a vector of mesh functions
subroutine, public load_external_waves(partners, namespace)
subroutine bessel_beam_function(this, iline, shift, mesh, n_points, time, k_vector, c_factor, envelope_mxf, bessel_field)
. Evaluation of the Bessel beam expression
subroutine, public bessel_source_eval(external_waves, time, mesh, type_of_field, out_field_total, der)
Calculation of Bessel beam from parsed formula.
subroutine external_waves_update_quantity(this, label)
subroutine pw_mx_function_evaluation(external_waves, wn, time, mesh, n_points, pw_field)
Evaluate expression for plane wave that uses predefeined Maxwell function.
subroutine bessel_beam_init(this, nlines, dim)
. Initialization of Bessel beam arrays
subroutine external_waves_copy_quantities_to_interaction(partner, interaction)
subroutine, public external_waves_eval(external_waves, time, mesh, type_of_field, out_field_total, der)
Calculation of external waves from parsed formula.
class(external_waves_t) function, pointer external_waves_constructor(namespace)
subroutine, public external_waves_end(external_waves)
subroutine pw_parsed_evaluation(external_waves, wn, time, mesh, n_points, pw_field)
Evaluate expression for plane wave parsing the provided formula.
subroutine plane_waves_eval(external_waves, time, mesh, type_of_field, out_field_total, der)
Calculation of plane waves from parsed formula.
subroutine get_pw_b_field(external_waves, mesh, pwidx, e_field, b_field)
Calculation of magnetic field for a plane wave.
subroutine external_waves_init_interaction_as_partner(partner, interaction)
subroutine, public external_waves_init(external_waves, namespace)
Here, plane wave is evaluated from analytical formulae on grid.
subroutine bessel_beam_finalize(this)
. Finalize Bessel beam arrays
real(real64), parameter, public m_two
real(real64), parameter, public m_zero
complex(real64), parameter, public m_zi
real(real64), parameter, public p_c
Electron gyromagnetic ratio, see Phys. Rev. Lett. 130, 071801 (2023)
real(real64), parameter, public m_one
This module implements the underlying real-space grid.
This module implements the index, used for the mesh points.
integer, parameter, public mxll_vec_pot_to_matter
integer, parameter, public mxll_b_field_to_matter
integer, parameter, public mxll_e_field_to_matter
This module defines the abstract interaction_t class, and some auxiliary classes for interactions.
This module defines classes and functions for interaction partners.
subroutine, public io_close(iunit, grp)
subroutine, public io_mkdir(fname, namespace, parents)
integer function, public io_open(file, namespace, action, status, form, position, die, recl, grp)
integer, parameter, public e_field_electric
integer, parameter, public e_field_vector_potential
complex(real64) function mxf_envelope_eval(f, x)
Evaluation of envelope itself.
subroutine, public mxf_read(f, namespace, function_name, ierr)
This function initializes "f" from the MXFunctions block.
This module defines various routines, operating on mesh functions.
This module defines the meshes, which are used in Octopus.
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)
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)
Some general things and nomenclature:
integer function, public parse_block(namespace, name, blk, check_varinfo_)
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.
This module defines the quantity_t class and the IDs for quantities, which can be exposed by a system...
subroutine, public conv_to_c_string(str)
converts to c string
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.
type(unit_system_t), public units_inp
the units systems for reading and writing
type(unit_t), public unit_one
some special units required for particular quantities
class representing derivatives
abstract class for general interaction partners
surrogate interaction class to avoid circular dependencies between modules.
Lorenz force between a systems of particles and an electromagnetic field.
Describes mesh distribution to nodes.
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
Systems (system_t) can expose quantities that can be used to calculate interactions with other system...