RestrictFromChildren Subroutine

  1. SELF_SolutionTransfer_2D.f90
  2. SELF_SolutionTransfer_2D
  3. RestrictFromChildren

public subroutine RestrictFromChildren(interp, nVar, uChildren, uParent)

Restrict (L2-project) the solution on four children back onto their parent element. Conservative, and the exact left inverse of ProlongToChildren.

Arguments

TypeIntentOptionalAttributesName
type(Lagrange), intent(in) :: interp
integer, intent(in) :: nVar
real(kind=prec), intent(in) :: uChildren(1:interp%N+1,1:interp%N+1,1:nVar,1:4)
real(kind=prec), intent(out) :: uParent(1:interp%N+1,1:interp%N+1,1:nVar)

Calls

proc~~restrictfromchildren~~CallsGraph proc~restrictfromchildren RestrictFromChildren tmp tmp proc~restrictfromchildren->tmp up up proc~restrictfromchildren->up

Called by

proc~~restrictfromchildren~~CalledByGraph proc~restrictfromchildren RestrictFromChildren proc~applytransferplanrange ApplyTransferPlanRange proc~applytransferplanrange->proc~restrictfromchildren proc~applytransferplan_dgmodel2d_t ApplyTransferPlan_DGModel2D_t proc~applytransferplan_dgmodel2d_t->proc~applytransferplanrange proc~applytransferplan ApplyTransferPlan proc~applytransferplan->proc~applytransferplanrange proc~applytransferplan_dgmodel2d ApplyTransferPlan_DGModel2D proc~applytransferplan_dgmodel2d->proc~applytransferplan_dgmodel2d_t

Contents

Source Code

RestrictFromChildren

Source Code

  subroutine RestrictFromChildren(interp,nVar,uChildren,uParent)
    !! Restrict (L2-project) the solution on four children back onto their parent element.
    !! Conservative, and the exact left inverse of ProlongToChildren.
    implicit none
    type(Lagrange),intent(in) :: interp
    integer,intent(in) :: nVar
    real(prec),intent(in) :: uChildren(1:interp%N+1,1:interp%N+1,1:nVar,1:4)
    real(prec),intent(out) :: uParent(1:interp%N+1,1:interp%N+1,1:nVar)
    ! Local
    integer :: v,Np

    Np = interp%N+1

    do concurrent(v=1:nVar)
      block
        integer :: c,i,j,ii,jj,kx,ky
        real(prec) :: acc
        real(prec) :: tmp(1:Np,1:Np) ! tmp(parentX, childY) after the x-direction projection
        real(prec) :: up(1:Np,1:Np)

        up(1:Np,1:Np) = 0.0_prec
        do c = 1,4
          kx = transferAxc(c)+1
          ky = transferAyc(c)+1
          ! x-direction: tmp(i,jj) = sum_ii mortarP(ii,i,kx) * uChild(ii,jj,c)
          do jj = 1,Np
            do i = 1,Np
              acc = 0.0_prec
              do ii = 1,Np
                acc = acc+interp%mortarP(ii,i,kx)*uChildren(ii,jj,v,c)
              enddo
              tmp(i,jj) = acc
            enddo
          enddo
          ! y-direction and accumulate over the four children
          do j = 1,Np
            do i = 1,Np
              acc = 0.0_prec
              do jj = 1,Np
                acc = acc+interp%mortarP(jj,j,ky)*tmp(i,jj)
              enddo
              up(i,j) = up(i,j)+acc
            enddo
          enddo
        enddo
        uParent(1:Np,1:Np,v) = up(1:Np,1:Np)
      endblock
    enddo

  endsubroutine RestrictFromChildren