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., updated_on_demand = .
true., iteration =
clock_t()))
150 class(external_waves_t),
intent(in) :: partner
151 class(interaction_surrogate_t),
intent(inout) :: interaction
155 select type (interaction)
165 message(1) =
"Unsupported interaction."
174 character(len=*),
intent(in) :: label
179 case (
"E field",
"B field",
"vector potential")
200 select type(interaction)
202 quantity => partner%quantities%get(
"E field")
205 interaction%system_field)
206 call interaction%do_mapping()
209 quantity => partner%quantities%get(
"vector potential")
210 interaction%system_field =
m_zero
212 "vector potential", interaction%system_field)
213 call interaction%do_mapping()
216 quantity => partner%quantities%get(
"B field")
217 interaction%system_field =
m_zero
218 call external_waves_eval(partner, quantity%iteration%value(), interaction%system_gr,
"B field", &
219 interaction%system_field, der=interaction%system_gr%der)
220 call interaction%do_mapping()
223 message(1) =
"Incompatible interaction."
234 type(namespace_t),
intent(in) :: namespace
236 logical :: has_source
247 call parse_variable(namespace,
'AnalyticalExternalSource', .false., has_source)
261 type(namespace_t),
intent(in) :: namespace
263 integer :: il, nlines, ncols, iex_norm, idim
264 integer,
parameter :: sys_dim = 3
265 real(real64) :: k_vector(sys_dim), velocity(sys_dim), x_pos(sys_dim)
266 real(real64) :: x_norm, dummy(sys_dim), k_dot_e , test_limit, k_norm, output_pos(3)
267 complex(real64) :: e_field(sys_dim)
268 character(len=1024) :: k_string(sys_dim)
269 character(len=1),
dimension(sys_dim),
parameter :: dims = [
"x",
"y",
"z"]
270 character(len=1024) :: mxf_expression
276 test_limit = 10.0e-9_real64
294 if (
parse_block(namespace,
'ExternalSourceBesselOutput', blk) == 0)
then
296 if (nlines > 1 )
then
297 message(2) =
'ExternalSource output is limited to one point.'
301 if (ncols /= 3 )
then
302 message(1) =
'ExternalSourceBesselOutput must have 3 columns.'
305 external_waves%output_from_point= .
true.
306 safe_allocate(external_waves%selected_point_coordinate(1:3))
307 safe_allocate(external_waves%selected_point_field(1:3))
312 external_waves%selected_point_coordinate(1:3) = output_pos(1:3)
313 external_waves%selected_point_field(1:3) =
m_zero
317 external_waves%out_file =
io_open(
'bessel_source_at_point', namespace=namespace, action=
'write')
318 write(external_waves%out_file,
'(12a) ')
'# Time (a.u.) ' ,
' Field-x ' ,
' Field-y ' ,
' Field-z '
321 external_waves%output_from_point= .false.
365 if (
parse_block(namespace,
'MaxwellIncidentWaves', blk) == 0)
then
372 external_waves%number = nlines
373 safe_allocate(external_waves%modus(1:nlines))
374 safe_allocate(external_waves%e_field_string(1:3, 1:nlines))
375 safe_allocate(external_waves%e_field(1:3, 1:nlines))
376 safe_allocate(external_waves%k_vector(1:3, 1:nlines))
377 safe_allocate(external_waves%v_vector(1:3, 1:nlines))
378 safe_allocate(external_waves%mx_function(1:nlines))
379 safe_allocate(external_waves%field_type(1:nlines))
380 safe_allocate(external_waves%pw_phase(1:nlines))
381 external_waves%pw_phase =
m_zero
383 call external_waves%bessel%init(nlines, 3)
387 if ((ncols < 5) .or. (ncols > 9))
then
388 message(1) =
'Each line in the MaxwellIncidentWaves block must have five to nine columns.'
397 if (external_waves%modus(il) == option__maxwellincidentwaves__plane_wave_parser)
then
400 call parse_block_string( blk, il - 1, 3 + idim + 1, external_waves%e_field_string(idim, il))
402 write(
message(1),
'(a,i2,a) ')
'Substituting electromagnetic incident wave ', il,
' with the expressions: '
405 write(
message(idim),
'(6a)')
' Wave vector k('//dims(idim)//
') = ', trim(k_string(idim))
406 write(
message(idim+1),
'(2a)')
' E-field('//dims(idim)//
') for t_0 = ', trim(external_waves%e_field_string(idim, il))
422 k_norm = norm2(k_vector)
424 velocity(:) = k_vector(:) / k_norm *
p_c * external_waves%c_factor
425 external_waves%k_vector(:,il) = k_vector(:)
426 external_waves%v_vector(:,il) = velocity(:)
428 else if (external_waves%modus(il) == option__maxwellincidentwaves__plane_wave_mx_function)
then
434 write(
message(1),
'(a,i2) ')
'Substituting electromagnetic incident wave ', il
435 write(
message(2),
'(a)' )
'with the expression: '
439 write(
message(idim),
'(a,f9.4,sp,f9.4,"i")')
' E-field('//trim(dims(idim))//
') complex amplitude = ', &
440 real(e_field(idim)), aimag(e_field(idim))
442 write(
message(4),
'(2a)' )
' Maxwell wave function name = ', trim(mxf_expression)
445 call mxf_read(external_waves%mx_function(il), namespace, trim(mxf_expression), iex_norm)
446 if (iex_norm /= 0)
then
447 write(
message(1),
'(3A)')
'Ex_norm in the ""', trim(mxf_expression), &
448 '"" field defined in the MaxwellIncidentWaves block'
455 k_vector(1:3) = external_waves%mx_function(il)%k_vector(1:3)
456 k_norm = norm2(k_vector)
458 k_dot_e = real(dot_product(k_vector, e_field), real64)
459 if (abs(k_dot_e) > test_limit)
then
460 write(
message(1),
'(a) ')
'The wave vector k or its electric field are not perpendicular. '
461 write(
message(2),
'(a,f8.3,a)' )
'Their dot product yields the magnitude', abs(k_dot_e) ,
' while'
462 write(
message(3),
'(a,f8.3,a)' )
'tolerance is ', test_limit ,
'.'
465 if (k_norm < 1e-10)
then
466 message(1) =
'The k vector is not set correctly: |k|~0 .'
470 external_waves%e_field(:,il) = e_field(:)
471 external_waves%k_vector(:,il) = k_vector(:)
472 external_waves%v_vector(:,il) = k_vector(:) / k_norm *
p_c * external_waves%c_factor
474 else if (external_waves%modus(il) == option__maxwellincidentwaves__bessel_function)
then
482 external_waves%bessel%envelope(il) = .
true.
483 call mxf_read(external_waves%mx_function(il), namespace, trim(mxf_expression), iex_norm)
489 write(
message(1),
'(a,i2) ')
'Incident Bessel Beam', il
492 if (abs(external_waves%bessel%helicity(il)) /= 1)
then
493 write(
message(1),
'(A)')
'Helicity has to be either +1 or -1 !'
497 write(
message(1),
'(a,f5.3)' )
' Bessel Amplitude ', external_waves%bessel%amp(il)
498 write(
message(2),
'(a,i2)' )
' Bessel Order m', external_waves%bessel%m_order(il)
499 write(
message(3),
'(a,f5.3)' )
' Bessel Frequency ', external_waves%bessel%omega(il)
500 write(
message(4),
'(a,i2)' )
' Bessel Helicity ', external_waves%bessel%helicity(il)
501 write(
message(5),
'(a,f5.3)' )
' Bessel Opening Angle ', external_waves%bessel%theta_k(il)
504 if (external_waves%bessel%lin_dir(il)/= 0)
then
505 write(
message(5),
'(a,i2)' )
' Bessel is Linearly Polarized in Direction : ', external_waves%bessel%lin_dir(il)
516 external_waves%number = 0
534 if (
parse_block(namespace,
'BesselBeamAxisShift', blk) == 0)
then
537 if (ncols /= 3 )
then
538 message(1) =
'BesselBeamAxisShift must have 3 columns.'
562 if (external_waves%output_from_point)
then
563 call io_close(external_waves%out_file)
564 safe_deallocate_a(external_waves%selected_point_coordinate)
565 safe_deallocate_a(external_waves%selected_point_field)
568 safe_deallocate_a(external_waves%bessel%shift)
569 safe_deallocate_a(external_waves%points_map)
570 safe_deallocate_a(external_waves%modus)
571 safe_deallocate_a(external_waves%e_field_string)
572 safe_deallocate_a(external_waves%k_vector)
573 safe_deallocate_a(external_waves%v_vector)
574 safe_deallocate_a(external_waves%e_field)
575 safe_deallocate_a(external_waves%mx_function)
576 safe_deallocate_a(external_waves%pw_phase)
587 subroutine external_waves_eval(external_waves, time, mesh, type_of_field, out_field_total, der)
589 real(real64),
intent(in) :: time
590 class(
mesh_t),
intent(in) :: mesh
591 character(len=*),
intent(in) :: type_of_field
592 real(real64),
intent(out) :: out_field_total(:, :)
602 call plane_waves_eval(external_waves, time, mesh, type_of_field, out_field_total, der=der)
603 call bessel_source_eval(external_waves, time, mesh, type_of_field, out_field_total, der=der)
612 subroutine plane_waves_eval(external_waves, time, mesh, type_of_field, out_field_total, der)
614 real(real64),
intent(in) :: time
615 class(
mesh_t),
intent(in) :: mesh
616 character(len=*),
intent(in) :: type_of_field
617 real(real64),
intent(out) :: out_field_total(:, :)
621 real(real64),
allocatable :: pw_field(:,:), ztmp(:,:), b_field_aux(:,:)
623 integer,
allocatable :: indices_pw_parser(:)
624 integer,
allocatable :: indices_mx_ftc(:)
625 integer :: n_plane_waves, n_points
631 indices_pw_parser = pack([(wn, wn = 1,external_waves%number)], &
632 external_waves%modus == option__maxwellincidentwaves__plane_wave_parser)
634 indices_mx_ftc = pack([(wn, wn = 1,external_waves%number)], &
635 external_waves%modus == option__maxwellincidentwaves__plane_wave_mx_function)
637 n_plane_waves =
size(indices_pw_parser) +
size(indices_mx_ftc)
639 p_c_ =
p_c * external_waves%c_factor
641 if (n_plane_waves == 0)
then
649 safe_allocate(ztmp(mesh%np,
size(out_field_total, dim=2)))
650 n_points = mesh%np_part
654 safe_allocate(pw_field(n_points,
size(out_field_total, dim=2)))
658 do wn = 1, external_waves%number
660 select case(external_waves%modus(wn))
661 case (option__maxwellincidentwaves__plane_wave_parser)
664 case (option__maxwellincidentwaves__plane_wave_mx_function)
668 select case (external_waves%field_type(wn))
672 select case (type_of_field)
674 out_field_total(1:mesh%np,:) = out_field_total(1:mesh%np,:) + pw_field(1:mesh%np,:)
675 case (
"vector potential")
678 safe_allocate(b_field_aux(1:mesh%np, 1:mesh%box%dim))
679 call get_pw_b_field(external_waves, mesh, wn, pw_field, b_field_aux)
680 out_field_total(:,:) = out_field_total(:,:) + b_field_aux(:,:)
681 safe_deallocate_a(b_field_aux)
686 select case (type_of_field)
689 case (
"vector potential")
690 out_field_total(1:mesh%np,:) = out_field_total(1:mesh%np,:) -
m_one/p_c_ * pw_field(1:mesh%np,1:3)
692 call dderivatives_curl(der, pw_field(1:mesh%np_part,1:3), ztmp(1:mesh%np,1:3), set_bc = .false.)
693 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)
699 safe_deallocate_a(pw_field)
700 safe_deallocate_a(ztmp)
711 integer,
intent(in) :: wn
712 real(real64),
intent(in) :: time
713 class(
mesh_t),
intent(in) :: mesh
714 integer,
intent(in) :: n_points
715 real(real64),
intent(out) :: pw_field(:,:)
717 real(real64) :: x_prop(3), x_norm
718 real(real64) :: velocity_time(3)
719 real(real64) :: parsed_field(3)
720 real(real64) :: dummy(3)
723 velocity_time(:) = external_waves%v_vector(1:3, wn) * time
726 external_waves%e_field_string(idim, wn))
728 x_prop = mesh%x(ip, :) - velocity_time
729 x_norm = norm2(x_prop(1:3))
740 integer,
intent(in) :: wn
741 real(real64),
intent(in) :: time
742 class(
mesh_t),
intent(in) :: mesh
743 integer,
intent(in) :: n_points
744 real(real64),
intent(out) :: pw_field(:,:)
746 real(real64) :: x_prop(3), x_norm
747 real(real64) :: velocity_time(3)
748 complex(real64) :: efield_ip(3)
749 complex(real64) :: e0(3)
752 velocity_time(:) = external_waves%v_vector(1:3, wn) * time
753 e0(:) = external_waves%e_field(1:3, wn)
755 x_prop = mesh%x(ip, :) - velocity_time
756 x_norm = norm2(x_prop(1:3))
757 efield_ip =
mxf(external_waves%mx_function(wn), x_prop, external_waves%pw_phase(wn))
758 pw_field(ip, :) = real(e0(1:3) * efield_ip, real64)
765 subroutine get_pw_b_field(external_waves, mesh, pwidx, e_field, b_field)
767 class(
mesh_t),
intent(in) :: mesh
768 real(real64),
intent(in) :: e_field(:,:)
769 real(real64),
intent(out) :: b_field(:,:)
770 integer,
intent(in) :: pwidx
772 real(real64) :: k_vector(3), k_vector_abs
773 real(real64) :: velocity(3)
775 complex(real64) :: e0(3)
778 velocity = external_waves%v_vector(1:3, pwidx)
779 k_vector = external_waves%k_vector(1:3, pwidx)
780 k_vector_abs = norm2(k_vector(1:3))
781 e0 = external_waves%e_field(1:3, pwidx)
782 p_c_ =
p_c * external_waves%c_factor
786 b_field(ip, :) =
m_one/(p_c_ * k_vector_abs) * dcross_product(k_vector, e_field(ip, :))
793 subroutine bessel_source_eval(external_waves, time, mesh, type_of_field, out_field_total, der)
795 real(real64),
intent(in) :: time
796 class(
mesh_t),
intent(in) :: mesh
797 character(len=*),
intent(in) :: type_of_field
798 real(real64),
intent(out) :: out_field_total(:, :)
801 real(real64) :: dmin, omega, k_vector(3), c_factor
802 integer :: iline, wn, pos_index, n_points, rankmin
803 real(real64),
allocatable :: shift(:,:)
804 complex(real64),
allocatable :: bessel_field_total(:,:), ztmp(:,:), vec_pot(:,:)
805 integer,
allocatable :: indices_bessel_ftc(:)
806 type(
mxf_t) :: envelope_mxf
812 indices_bessel_ftc = pack([(wn, wn = 1,external_waves%number)], &
813 external_waves%modus == option__maxwellincidentwaves__bessel_function)
815 if (
size(indices_bessel_ftc) == 0)
then
822 if (
allocated(external_waves%bessel%shift) .and. &
823 size(external_waves%bessel%shift(:,1)) /=
size(indices_bessel_ftc))
then
824 message(1) =
'Number of BesselBeamAxisShift defined in input file'
825 message(2) =
'does not match the number of Bessel beams.'
829 safe_allocate(shift(
size(indices_bessel_ftc), 3))
830 if (
allocated(external_waves%bessel%shift))
then
831 shift = external_waves%bessel%shift
836 if (type_of_field ==
"B field")
then
838 safe_allocate(vec_pot(mesh%np_part,
size(out_field_total, dim=2)))
839 safe_allocate(ztmp(
size(out_field_total, dim=1),
size(out_field_total, dim=2)))
840 n_points = mesh%np_part
846 safe_allocate(bessel_field_total(1:n_points, 1:3))
847 bessel_field_total =
m_zero
849 do iline = 1,
size(indices_bessel_ftc)
850 wn = indices_bessel_ftc(iline)
851 omega = external_waves%bessel%omega(wn)
852 k_vector = external_waves%mx_function(wn)%k_vector
853 c_factor = external_waves%c_factor
854 envelope_mxf = external_waves%mx_function(wn)
856 call external_waves%bessel%function(wn, shift, mesh, n_points, time, k_vector, c_factor, envelope_mxf, bessel_field_total)
858 select case (external_waves%field_type(wn))
862 select case (type_of_field)
864 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))
865 case (
"vector potential")
868 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))
870 call zderivatives_curl(der, bessel_field_total(1:mesh%np_part,1:3), ztmp(1:mesh%np,1:3), set_bc = .false.)
871 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))
876 select case (type_of_field)
878 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))
879 case (
"vector potential")
882 out_field_total(1:mesh%np,1:3) = out_field_total(1:mesh%np,1:3) -
m_one/
p_c * &
883 real(bessel_field_total(1:mesh%np,1:3)/M_zI/omega)
885 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)
887 out_field_total(1:mesh%np,1:3) = out_field_total(1:mesh%np,1:3) - real(ztmp(1:mesh%np, 1:3))
893 if (external_waves%output_from_point)
then
894 pos_index =
mesh_nearest_point(mesh, external_waves%selected_point_coordinate(1:3), dmin, rankmin)
895 if (mesh%mpi_grp%rank == rankmin)
then
896 external_waves%selected_point_field(:) = out_field_total(pos_index,:)
897 write(external_waves%out_file,
"(4F14.8, 4x)") time, external_waves%selected_point_field(:)
901 safe_deallocate_a(shift)
902 safe_deallocate_a(ztmp)
903 safe_deallocate_a(vec_pot)
904 safe_deallocate_a(bessel_field_total)
913 subroutine bessel_beam_function(this, iline, shift, mesh, n_points, time, k_vector, c_factor, envelope_mxf, bessel_field)
915 integer,
intent(in) :: iline
916 real(real64),
intent(in) :: shift(:,:), time, k_vector(3), c_factor
917 class(
mesh_t),
intent(in) :: mesh
918 integer,
intent(in) :: n_points
919 type(
mxf_t),
intent(in) :: envelope_mxf
920 complex(real64),
intent(out) :: bessel_field(:,:)
922 real(real64) :: pos(3), temp, temp2, temp3, rho, phi_rho, wigner(3)
923 real(real64) :: hel, theta, omega, amp, kappa, proj, k_norm, velocity_time(3), x_prop(3)
924 complex(real64) :: efield_ip(3)
925 real(real64) :: bessel_plus, bessel_minus
926 integer :: ip, mm, pol
928 assert(iline <=
size(this%omega))
929 hel = real(this%helicity(iline), real64)
930 theta = this%theta_k(iline)
931 mm = this%m_order(iline)
933 omega = this%omega(iline)
934 proj = omega *
cos(theta) /
p_c
935 kappa =
sqrt(omega**2 - (proj*
p_c)**2)
938 wigner(2) = 0.5 * (1 + hel *
cos(theta))
939 wigner(3) = 0.5 * (1 - hel *
cos(theta))
940 proj = omega *
cos(theta) /
p_c
941 pol = this%lin_dir(iline)
944 pos(:) = mesh%x(ip, :) - shift(iline,:)
945 rho = norm2(pos(1:2))
946 phi_rho =
atan2(pos(2) , pos(1))
947 temp = proj * pos(3) + phi_rho * (mm + 1) - omega*time
948 temp2 = proj * pos(3) + phi_rho * (mm - 1) - omega*time
949 temp3 = proj * pos(3) + phi_rho * mm - omega*time
955 bessel_field(ip, 1) = amp * (
exp(
m_zi*temp) * wigner(3) * bessel_plus +
exp(
m_zi*temp2) * wigner(2) * bessel_minus)
959 bessel_field(ip, 2) =
m_zi * amp * (-
exp(
m_zi*temp) * wigner(3) * bessel_plus + &
960 exp(
m_zi*temp2) * wigner(2) * bessel_minus)
967 if (this%envelope(iline))
then
968 k_norm = norm2(k_vector)
969 velocity_time = k_vector *
p_c * c_factor * time / k_norm
970 x_prop(:) = pos(:) - velocity_time(:)
972 bessel_field(ip, :) = bessel_field(ip, :) * real(efield_ip, real64)
982 integer,
intent(in) :: nlines
983 integer,
intent(in) :: dim
985 safe_allocate(this%amp(1: nlines))
986 safe_allocate(this%omega(1:nlines))
987 safe_allocate(this%theta_k(1:nlines))
988 safe_allocate(this%m_order(1:nlines))
989 safe_allocate(this%helicity(1:nlines))
990 safe_allocate(this%shift(1:nlines, 1:dim))
991 safe_allocate(this%envelope(1:nlines))
992 safe_allocate(this%lin_dir(1:nlines))
1000 this%envelope = .false.
1008 safe_deallocate_a(this%amp)
1009 safe_deallocate_a(this%omega)
1010 safe_deallocate_a(this%theta_k)
1011 safe_deallocate_a(this%m_order)
1012 safe_deallocate_a(this%helicity)
1013 safe_deallocate_a(this%shift)
1014 safe_deallocate_a(this%lin_dir)
1015 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...