restrict1D Subroutine

public subroutine restrict1D(tabfin, lb_fin, tabgros, lb_gros, ub_gros, ordre)

Restrict evenly spaced points, taking into account the borders

Arguments

Type IntentOptional Attributes Name
real(kind=R8), intent(in), dimension(lb_fin:) :: tabfin

tableau de départ
integer(kind=I4), intent(in) :: lb_fin

indice inférieur de tab_fin
real(kind=R8), intent(out), dimension(lb_gros:) :: tabgros

tableau grossier résultant
integer(kind=I4), intent(in) :: lb_gros

indice inférieur
integer(kind=I4), intent(in) :: ub_gros

taille de tabgros
integer(kind=I4), intent(in) :: ordre

ordre de la restriction

Calls

proc~~restrict1d~~CallsGraph proc~restrict1d restrict1D proc~restrict restrict proc~restrict1d->proc~restrict

Called by

proc~~restrict1d~~CalledByGraph proc~restrict1d restrict1D proc~restrict2d restrict2D proc~restrict2d->proc~restrict1d proc~test_interp_pond test_interp_pond proc~test_interp_pond->proc~restrict1d proc~test_interp_pond->proc~restrict2d program~test_intpl test_intpl program~test_intpl->proc~test_interp_pond

Source Code

subroutine restrict1D(tabfin, lb_fin, tabgros, lb_gros, ub_gros, ordre)
!! Restrict evenly spaced points, taking into account the borders
implicit none
integer(kind=I4), intent(in )                      :: lb_fin      !! *indice inférieur de tab_fin*
integer(kind=I4), intent(in )                      :: lb_gros     !! *indice inférieur*
integer(kind=I4), intent(in )                      :: ub_gros     !! *taille de tabgros*
integer(kind=I4), intent(in )                      :: ordre       !! *ordre de la restriction*
real(kind=R8),    intent(in ), dimension(lb_fin:)  :: tabfin      !! *tableau de départ*
real(kind=R8),    intent(out), dimension(lb_gros:) :: tabgros     !! *tableau grossier résultant*

   integer(kind=I4) :: l_inf, l_sup, i, ii
   real(kind=R8)    :: tmp0, dtmp

   real(kind=R8), dimension(          -   ordre:          2*ordre) :: tab_inf
   real(kind=R8), dimension(2*ub_gros - 2*ordre:2*ub_gros + ordre) :: tab_sup

   ! bornes pour déterminer les limites d'utilisation de la fonction restrict
   l_inf = ordre/2
   l_sup = ub_gros -l_inf

   ! extension du tableau par prolongement de la dérivée
   tab_inf(0:2*ordre) = tabfin(0:2*ordre)
   tmp0 = tab_inf(0)
   dtmp = tab_inf(0)-tab_inf(1)

   do i = 1, ordre
      tab_inf(-i) = tmp0 + i*dtmp
   enddo

   do ii = 0, l_inf
      i = 2*ii
      tabgros(ii) = restrict( tab   = tab_inf,  &  !
                              lb    = -ordre,   &  !
                              ind   = i,        &  !
                              ordre = ordre )      !
   enddo

   ! utilisation d'interp dans les limites normales
   do ii = l_inf+1, l_sup-1
      i = 2*ii
      tabgros(ii) = restrict( tab   = tabfin,   &  !
                              lb    = lb_fin,   &  !
                              ind   = i,        &  !
                              ordre = ordre )      !
   enddo

   ! extension du tableau par prolongement de la dérivée
   tab_sup(2*ub_gros-2*ordre:2*ub_gros) = tabfin(2*ub_gros-2*ordre:2*ub_gros)
   tmp0 = tab_sup(2*ub_gros)
   dtmp = tab_sup(2*ub_gros)-tab_sup(2*ub_gros-1)

   do i = 1, ordre
      tab_sup(2*ub_gros+i) = tmp0 + i*dtmp
   enddo

   do ii = l_sup, ub_gros
      i = 2*ii
      tabgros(ii) = restrict( tab   = tab_sup,              &  !
                              lb    = 2*ub_gros - 2*ordre,  &  !
                              ind   = i,                    &  !
                              ordre = ordre )                  !
   enddo

return
endsubroutine restrict1D