atl_maxwell_hc_flux Interface

  1. atl_maxwell_flux_module.f90
  2. atl_maxwell_flux_module
  3. atl_maxwell_hc_flux

public interface atl_maxwell_hc_flux

Interface for fluxes of Maxwell equations with hyperbolic divergence cleaning.

Calls

interface~~atl_maxwell_hc_flux~~CallsGraph interface~atl_maxwell_hc_flux atl_maxwell_hc_flux proc~maxwell_hc_flux_nonconst_cube_vec maxwell_hc_flux_nonconst_cube_vec interface~atl_maxwell_hc_flux->proc~maxwell_hc_flux_nonconst_cube_vec proc~maxwell_hc_flux_cube_vec maxwell_hc_flux_cube_vec interface~atl_maxwell_hc_flux->proc~maxwell_hc_flux_cube_vec proc~maxwell_hc_flux_cube maxwell_hc_flux_cube interface~atl_maxwell_hc_flux->proc~maxwell_hc_flux_cube proc~maxwell_hc_flux_nonconst_cube_vec->proc~maxwell_hc_flux_cube interface~ply_poly_project_n2m ply_poly_project_n2m proc~maxwell_hc_flux_nonconst_cube_vec->interface~ply_poly_project_n2m interface~ply_poly_project_m2n ply_poly_project_m2n proc~maxwell_hc_flux_nonconst_cube_vec->interface~ply_poly_project_m2n proc~ply_convert2oversample ply_convert2oversample proc~maxwell_hc_flux_nonconst_cube_vec->proc~ply_convert2oversample proc~ply_convertfromoversample ply_convertFromOversample proc~maxwell_hc_flux_nonconst_cube_vec->proc~ply_convertfromoversample proc~atl_physfluxmaxwelldivcor atl_physFluxMaxwellDivCor proc~maxwell_hc_flux_cube_vec->proc~atl_physfluxmaxwelldivcor proc~maxwell_hc_flux_cube->proc~atl_physfluxmaxwelldivcor proc~ply_poly_project_n2m_multivar ply_poly_project_n2m_multiVar interface~ply_poly_project_n2m->proc~ply_poly_project_n2m_multivar proc~ply_poly_project_m2n_multivar ply_poly_project_m2n_multiVar interface~ply_poly_project_m2n->proc~ply_poly_project_m2n_multivar proc~ply_convert2oversample_2d ply_convert2oversample_2d proc~ply_convert2oversample->proc~ply_convert2oversample_2d proc~ply_convert2oversample_3d ply_convert2oversample_3d proc~ply_convert2oversample->proc~ply_convert2oversample_3d proc~ply_convert2oversample_1d ply_convert2oversample_1d proc~ply_convert2oversample->proc~ply_convert2oversample_1d proc~ply_convertfromoversample_3d ply_convertFromOversample_3d proc~ply_convertfromoversample->proc~ply_convertfromoversample_3d proc~ply_convertfromoversample_1d ply_convertFromOversample_1d proc~ply_convertfromoversample->proc~ply_convertfromoversample_1d proc~ply_convertfromoversample_2d ply_convertFromOversample_2d proc~ply_convertfromoversample->proc~ply_convertfromoversample_2d proc~ply_fxt_n2m_1d ply_fxt_n2m_1D proc~ply_poly_project_n2m_multivar->proc~ply_fxt_n2m_1d interface~ply_pnttoleg_2d ply_pntToLeg_2D proc~ply_poly_project_n2m_multivar->interface~ply_pnttoleg_2d proc~ply_l2p_trafo_2d ply_l2p_trafo_2D proc~ply_poly_project_n2m_multivar->proc~ply_l2p_trafo_2d proc~ply_fxt_n2m_3d ply_fxt_n2m_3D proc~ply_poly_project_n2m_multivar->proc~ply_fxt_n2m_3d proc~ply_fxt_n2m_2d ply_fxt_n2m_2D proc~ply_poly_project_n2m_multivar->proc~ply_fxt_n2m_2d proc~ply_l2p_trafo_1d ply_l2p_trafo_1D proc~ply_poly_project_n2m_multivar->proc~ply_l2p_trafo_1d proc~ply_l2p_trafo_3d ply_l2p_trafo_3D proc~ply_poly_project_n2m_multivar->proc~ply_l2p_trafo_3d interface~ply_pnttoleg_3d ply_pntToLeg_3D proc~ply_poly_project_n2m_multivar->interface~ply_pnttoleg_3d proc~ply_fxt_m2n_3d ply_fxt_m2n_3D proc~ply_poly_project_m2n_multivar->proc~ply_fxt_m2n_3d interface~ply_legtopnt_2d ply_legToPnt_2D proc~ply_poly_project_m2n_multivar->interface~ply_legtopnt_2d proc~ply_fxt_m2n_1d ply_fxt_m2n_1D proc~ply_poly_project_m2n_multivar->proc~ply_fxt_m2n_1d proc~ply_poly_project_m2n_multivar->proc~ply_l2p_trafo_2d proc~ply_fxt_m2n_2d ply_fxt_m2n_2D proc~ply_poly_project_m2n_multivar->proc~ply_fxt_m2n_2d proc~ply_poly_project_m2n_multivar->proc~ply_l2p_trafo_1d proc~ply_poly_project_m2n_multivar->proc~ply_l2p_trafo_3d interface~ply_legtopnt_3d ply_LegTopnt_3D proc~ply_poly_project_m2n_multivar->interface~ply_legtopnt_3d

Called by

interface~~atl_maxwell_hc_flux~~CalledByGraph interface~atl_maxwell_hc_flux atl_maxwell_hc_flux proc~atl_modg_maxwelldivcor_numflux atl_modg_maxwellDivCor_numFlux proc~atl_modg_maxwelldivcor_numflux->interface~atl_maxwell_hc_flux proc~compute_rhs_cubes_modg compute_rhs_cubes_modg proc~compute_rhs_cubes_modg->proc~atl_modg_maxwelldivcor_numflux proc~compute_rhs_cubes compute_rhs_cubes proc~compute_rhs_cubes->proc~compute_rhs_cubes_modg interface~atl_compute_rhs atl_compute_rhs interface~atl_compute_rhs->proc~compute_rhs_cubes

Contents

Module Procedures


Module Procedures

private subroutine maxwell_hc_flux_cube(left, right, mat_left, mat_right, flux)

Subroutine to calculate the flux for pure Maxwell equations with

Read more…

Arguments

TypeIntentOptionalAttributesName
real(kind=rk), intent(in) :: left(8)

Left state vector (as conservative variables). The order of this vector has to be \f$ (D_x, D_y, D_z, B_1, B_2, B_3, phi, psi) \f$ where E and B denoted electric field vetor and magnetic field (also called magnetic induction) vector.
real(kind=rk), intent(in) :: right(8)

Right state vector (as conservative variables). The order of this vector has to be (D_x, D_y, D_z, B_1, B_2, B_3, phi, psi) where E and B denoted the electric field vetor and magnetic field (also called magnetic induction) vector.
real(kind=rk), intent(in) :: mat_left(4)

Material for the left face
real(kind=rk), intent(in) :: mat_right(4)

Material for the right face !> The magnetic permeability of the left element. real(kind=rk), intent(in) :: left_mu !> The electric permitivity of the left element. real(kind=rk), intent(in) :: left_epsi !> Parameter for the magnetic correction on the left element. real(kind=rk), intent(in) :: left_gam !> Parameter for the electric correction on the left element. real(kind=rk), intent(in) :: left_chi !> The magnetic permeability of the right element. real(kind=rk), intent(in) :: right_mu !> The electric permitivity of the right element. real(kind=rk), intent(in) :: right_epsi !> Parameter for the magnetic correction on the right element. real(kind=rk), intent(in) :: right_gam !> Parameter for the electric correction on the right element. real(kind=rk), intent(in) :: right_chi
real(kind=rk), intent(out) :: flux(8)

The flux between left and right cell. The order of this vector is the same as the input arguments.

JZ: Old implementation of the flux. There must be an error somewhere. I have to check my solution for the Riemann problem agian. So, I replaced the flux by a simple Lax-Friedrich type flux.

real(kind=rk) :: left_speedOfLight, right_speedOfLight real(kind=rk) :: inv_denom_mu, inv_denom_epsi ! --------------------------------------------------------------------------

! The speed of light in the left and right element left_speedOfLight = 1.0_rk / sqrt( left_mu * left_epsi ) right_speedOfLight = 1.0_rk / sqrt( right_mu * right_epsi )

! The inverse of the denominators inv_denom_mu = 1.0_rk / ((-1.0_rk)left_speedOfLightleft_mu - right_speedOfLightright_mu) inv_denom_epsi = 1.0_rk / (left_speedOfLightleft_epsi + right_speedOfLight*right_epsi)

! D_x flux(1) = inv_denom_mu * ( & & (-1.0_rk)left_chileft(1)/left_epsi & & - (-1.0_rk)right_chiright(1)/right_epsi & & ) & & + ( & & left_chileft_chileft(7) & & + right_chiright_chiright(7) & & ) / ( left_epsileft_mu + right_epsiright_mu ) ! B_x flux(4) = inv_denom_epsi * ( & & (-1.0_rk)left_gamleft(4)/left_mu & & - (-1.0_rk)right_gamright(4)/right_mu) & & + ( & & left_gamleft_gamleft(8) & & + right_gamright_gamright(8) & & ) / ( left_epsileft_mu + right_epsiright_mu )

! the flux for phi (electric correction) flux(7) = ( & & left_speedOfLightleft(1) & & + right_speedOfLightright(1) & & + left_speedOfLightleft_chileft(7) & & - right_speedOfLightright_chiright(7) & & ) / (left_speedOfLight + right_speedOfLight)

! the flux for psi (magnetic correction) flux(8) = ( & & left_speedOfLightleft(4) & & + right_speedOfLightright(4) & & + left_speedOfLightleft_gamleft(8) & & - right_speedOfLightright_gamright(8) & & ) / (left_speedOfLight + right_speedOfLight)

! the flux for D_y flux(2) = ( & & ( (-1.0_rkleft(2) / left_epsi) & & - (-1.0_rkright(2) / right_epsi) ) & & - ( left_speedOfLight * left(6) & & + right_speedOfLight * right(6) )) ! the flux for B_z flux(6) = ( & & ( left_speedOfLight * left(2) & & + right_speedOfLight * right(2) ) & & + ( ( left(6) / left_mu ) & & - ( right(6) / right_mu ) )) ! the flux for D_z flux(3) = ( & & ( ( -1.0_rk * left(3) / left_epsi ) & & - ( -1.0_rk * right(3) / right_epsi ) ) & & + ( left_speedOfLight * left(5) & & + right_speedOfLight * right(5) ) & & )

! the flux for B_y flux(5) = ( & & ( -1.0_rk * left_speedOfLight * left(3) & & - right_speedOfLight * right(3) ) & & + ( ( left(5) / left_mu ) & & - ( right(5) / right_mu) ) & & )

! Normalize the calculated fluxes
flux(2:3) = inv_denom_mu * flux(2:3)
flux(5:6) = inv_denom_epsi * flux(5:6)

private subroutine maxwell_hc_flux_cube_vec(nTotalFaces, nSides, nFaceDofs, faceRep, faceFlux, leftPos, rightPos, var, material_left, material_right)

calculate flux of maxwell equation with hyperbolic divergence

Read more…

Arguments

TypeIntentOptionalAttributesName
integer, intent(in) :: nTotalFaces
integer, intent(in) :: nSides
integer, intent(in) :: nFaceDofs
real(kind=rk), intent(in) :: faceRep(nTotalFaces,nFaceDofs,8,2)
real(kind=rk), intent(inout) :: faceFlux(nTotalFaces,nFaceDofs,8,2)
integer, intent(in) :: leftPos(nSides)
integer, intent(in) :: rightPos(nsides)
integer, intent(in) :: var(8)
real(kind=rk), intent(in) :: material_left(nSides,1,4)
real(kind=rk), intent(in) :: material_right(nSides,1,4)

integer :: iSide, left, right, iDof real(kind=rk) :: left_mu, right_mu real(kind=rk) :: left_epsi, right_epsi real(kind=rk) :: left_gam, right_gam real(kind=rk) :: left_chi, right_chi real(kind=rk) :: left_speedOfLight, right_speedOfLight real(kind=rk) :: inv_denom_mu, inv_denom_epsi ! --------------------------------------------------------------------------

! flux for D_X, B_Z, D_y and B_z do iDof = 1, nFaceDofs

do iSide = 1, nSides

 ! The position of the left and right element in the state
 ! vector.
 left = leftPos(iSide)
 right = rightPos(iSide)

 ! The material parameters of the left and right element
 left_mu = material_left(iSide,1,1)
 left_epsi = material_left(iSide,1,2)
 left_gam = material_left(iSide,1,3)
 left_chi = material_left(iSide,1,4)
 left_speedOfLight = 1.0_rk / sqrt( left_mu * left_epsi )
 right_mu = material_right(iSide,1,1)
 right_epsi = material_right(iSide,1,2)
 right_gam = material_right(iSide,1,3)
 right_chi = material_right(iSide,1,4)
 right_speedOfLight = 1.0_rk / sqrt( right_mu * right_epsi )

 ! The inverse of the denominators
 inv_denom_mu = 1.0_rk / ((-1.0_rk)*left_speedOfLight*left_mu - right_speedOfLight*right_mu)
 inv_denom_epsi = 1.0_rk / (left_speedOfLight*left_epsi + right_speedOfLight*right_epsi)

 ! flux for D_x
 faceFlux(left,iDof,var(1),2) = inv_denom_mu * (                                   &
                                &       (-1.0_rk)*left_chi*faceRep(left,iDof,var(1),2)/left_epsi    &
                                &     - (-1.0_rk)*right_chi*faceRep(right,iDof,var(1),1)/right_epsi &
                                &              )                                   &
                                & + (                                              &
                                &        left_chi*left_chi*faceRep(left,iDof,var(7),2) &
                                &      + right_chi*right_chi*faceRep(right,iDof,var(7),1) &
                                &   ) / ( left_epsi*left_mu + right_epsi*right_mu  )

 ! flux for B_x
 faceFlux(left,iDof,var(4),2) = inv_denom_epsi * (                                 &
                                &        (-1.0_rk)*left_gam*faceRep(left,iDof,var(4),2)/left_mu &
                                &      - (-1.0_rk)*right_gam*faceRep(right,iDof,var(4),1)/right_mu) &
                                & + (                                              &
                                &       left_gam*left_gam*faceRep(left,iDof,var(8),2) &
                                &     + right_gam*right_gam*faceRep(right,iDof,var(8),1) &
                                &   ) / ( left_epsi*left_mu + right_epsi*right_mu  )

 ! flux for phi (electric correction)
 faceFlux(left,iDof,var(7),2) = (                                            &
                                &    left_speedOfLight*faceRep(left,iDof,var(1),2) &
                                &  + right_speedOfLight*faceRep(right,iDof,var(1),1) &
                                &  + left_speedOfLight*left_chi*faceRep(left,iDof,var(7),2) &
                                &  - right_speedOfLight*right_chi*faceRep(right,iDof,var(7),1)   &
                                & ) / (left_speedOfLight + right_speedOfLight)

 ! flux for psi (magnetic correction)
 faceFlux(left,iDof,var(8),2) = (                                            &
                                &    left_speedOfLight*faceRep(left,iDof,var(4),2)               &
                                &  + right_speedOfLight*faceRep(right,iDof,var(4),1)             &
                                &  + left_speedOfLight*left_gam*faceRep(left,iDof,var(8),2)      &
                                &  - right_speedOfLight*right_gam*faceRep(right,iDof,var(8),1)   &
                                & ) / (left_speedOfLight + right_speedOfLight)

 ! the flux for D_y
 faceFlux(left,iDof,var(2),2) = ( &
   &                  ( ((-1.0_rk)*faceRep(left,iDof,var(2),2) / left_epsi)        &
   &                    - ((-1.0_rk)*faceRep(right,iDof,var(2),1) / right_epsi)  ) &
   &               -  ( left_speedOfLight * faceRep(left,iDof,var(6),2)          &
   &                    + right_speedOfLight * faceRep(right,iDof,var(6),1) ))


 ! the flux for B_z
 faceFlux(left,iDof,var(6),2) = ( &
   &                  ( left_speedOfLight * faceRep(left,iDof,var(2),2)     &
   &                  + right_speedOfLight * faceRep(right,iDof,var(2),1) )&
   &                + ( ( faceRep(left,iDof,var(6),2) / left_mu )     &
   &                  - ( faceRep(right,iDof,var(6),1) / right_mu ) ))

 ! the flux for D_z
 faceFlux(left,iDof,var(3),2) = ( &
   &                  ( ( (-1.0_rk) * faceRep(left,iDof,var(3),2) / left_epsi )     &
   &                  - ( (-1.0_rk) * faceRep(right,iDof,var(3),1) / right_epsi ) ) &
   &                + ( left_speedOfLight * faceRep(left,iDof,var(5),2)           &
   &                  + right_speedOfLight * faceRep(right,iDof,var(5),1) )       &
   &                            )

 ! the flux for B_y
 faceFlux(left,iDof,var(5),2) = ( &
   &                  ( (-1.0_rk) * left_speedOfLight * faceRep(left,iDof,var(3),2) &
   &                  - right_speedOfLight * faceRep(right,iDof,var(3),1) )       &
   &                + ( ( faceRep(left,iDof,var(5),2) / left_mu )                 &
   &                  - ( faceRep(right,iDof,var(5),1) / right_mu) )              &
   &                            )

 ! Normalize the calculated fluxes
 faceFlux(left,iDof,var(2),2) = inv_denom_mu * faceFlux(left,iDof,var(2),2)
 faceFlux(left,iDof,var(6),2) = inv_denom_epsi * faceFlux(left,iDof,var(6),2)
 faceFlux(left,iDof,var(3),2) = inv_denom_mu * faceFlux(left,iDof,var(3),2)
 faceFlux(left,iDof,var(5),2) = inv_denom_epsi * faceFlux(left,iDof,var(5),2)

 ! Assign the same flux for both adjacent elements
 faceFlux(right,iDof,:,1) = faceFlux(left,iDof,:,2)

end do

end do

private subroutine maxwell_hc_flux_nonconst_cube_vec(nTotalFaces, nSides, nFaceDofs, faceRep, faceFlux, leftPos, rightPos, var, material_left, material_right, poly_proj, left_modalCoeffs, right_modalCoeffs, left_pntVal, right_pntVal, nodalNumFlux, numFluxBuffer)

calculate flux of maxwell equation with hyperbolic divergence

Read more…

Arguments

TypeIntentOptionalAttributesName
integer, intent(in) :: nTotalFaces
integer, intent(in) :: nSides
integer, intent(in) :: nFaceDofs
real(kind=rk), intent(in) :: faceRep(nTotalFaces,nFaceDofs,8,2)

The modal representation on the faces, left and right trace.
real(kind=rk), intent(inout) :: faceFlux(nTotalFaces,nFaceDofs,8,2)

The fluxes for all faces, for left and right elements.
integer, intent(in) :: leftPos(nSides)

Positions for the left and right elements of all faces
integer, intent(in) :: rightPos(nsides)

Positions for the left and right elements of all faces
integer, intent(in) :: var(8)

Variable rotation indices
real(kind=rk), intent(in) :: material_left(nSides,nFaceDofs,4)

Material parameters for the left faces.
real(kind=rk), intent(in) :: material_right(nSides,nFaceDofs,4)

Material parameters for the right faces.
type(ply_poly_project_type) :: poly_proj

Data for projection method !> Working array for the left and right modal coefficients real(kind=rk), intent(inout) :: left_modalCoeffs((fpt%nQuadPoints)2,8) real(kind=rk), intent(inout) :: right_modalCoeffs((fpt%nQuadPoints)2,8) !> Working array for the left and right point values real(kind=rk), intent(inout) :: left_pntVal((fpt%nQuadPoints)2,8) real(kind=rk), intent(inout) :: right_pntVal((fpt%nQuadPoints)2,8) !> Working array for the nodal flux real(kind=rk), intent(inout) :: nodalNumFlux((fpt%nQuadPoints)2,8) !> Working array for the modal numerical flux real(kind=rk), intent(inout) :: numFluxBuffer((fpt%nQuadPoints)2,8)
real(kind=rk), intent(inout), allocatable:: left_modalCoeffs(:,:)

Working array for the left and right modal coefficients
real(kind=rk), intent(inout), allocatable:: right_modalCoeffs(:,:)
real(kind=rk), intent(inout), allocatable:: left_pntVal(:,:)

Working array for the left and right point values
real(kind=rk), intent(inout), allocatable:: right_pntVal(:,:)
real(kind=rk), intent(inout), allocatable:: nodalNumFlux(:,:)

Working array for the nodal flux
real(kind=rk), intent(inout), allocatable:: numFluxBuffer(:,:)

Working array for the modal numerical flux