This subroutine returns first spacetime function on overlapping regions fo given coordinate points for vectorial variable. Spacetime function are evaluated only on the coordinate which belong to st_fun shape.

Type | Intent | Optional | Attributes | Name | ||
---|---|---|---|---|---|---|

class(tem_varSys_op_type), | intent(in) | :: | fun |
Description of the method to obtain the variables, here some preset values might be stored, like the space time function to use or the required variables. |
||

type(tem_varSys_type), | intent(in) | :: | varSys |
The variable system to obtain the variable from. |
||

real(kind=rk), | intent(in) | :: | point(:,:) |
Three-dimensional coordinates at which the variable should be evaluated. Only useful for variables provided as space-time functions. |
||

type(tem_time_type), | intent(in) | :: | time |
Point in time at which to evaluate the variable. |
||

type(treelmesh_type), | intent(in) | :: | tree |
global treelm mesh info |
||

integer, | intent(in) | :: | nPnts |
Number of values to obtain for this variable (vectorized access). |
||

real(kind=rk), | intent(out) | :: | res(:) |
Resulting values for the requested variable. Dimension: n requested entries x nComponents of this variable Access: (iElem-1)*fun%nComponents + iComp |

```
recursive subroutine evaluate_first_spacetime_vectorByCoordinate( fun, &
& varsys, point, time, tree, nPnts, res )
!--------------------------------------------------------------------------!
!> Description of the method to obtain the variables, here some preset
!! values might be stored, like the space time function to use or the
!! required variables.
class(tem_varSys_op_type), intent(in) :: fun
!> The variable system to obtain the variable from.
type(tem_varSys_type), intent(in) :: varSys
!> Three-dimensional coordinates at which the variable should be
!! evaluated. Only useful for variables provided as space-time functions.
real(kind=rk), intent(in) :: point(:,:)
!> Point in time at which to evaluate the variable.
type(tem_time_type), intent(in) :: time
!> global treelm mesh info
type(treelmesh_type), intent(in) :: tree
!> Number of values to obtain for this variable (vectorized access).
integer, intent(in) :: nPnts
!> Resulting values for the requested variable.
!!
!! Dimension: n requested entries x nComponents of this variable
!! Access: (iElem-1)*fun%nComponents + iComp
real(kind=rk), intent(out) :: res(:)
!--------------------------------------------------------------------------!
! --------------------------------------------------------------------------
integer :: iStFun, iPoint, elemPos, pos
logical :: found
type(tem_st_fun_listElem_type), pointer :: fPtr
integer :: coord(4)
integer(kind=long_k):: treeID
real(kind=rk) :: st_res(1, fun%nComponents)
! --------------------------------------------------------------------------
!call C_F_POINTER( fun%method_Data, fPtr )
! avoid compiler warning about unused varsys
call C_F_POINTER( varsys%method%val(fun%mypos)%method_Data, fPtr )
res = 0.0_rk
! We have to loop over all requested points. For each point we have to
! figure out which is the first space time function that can fulfill the
! request. Thus a vectorized access is not possible here.
do iPoint = 1, nPnts
found = .false.
! The space time function has a custom shape, thus we have to check
! whether the coordinates are covered by the space time function.
! As we are dealing with vectorial access here, we have to loop over all
! requested points.
stLoop: do iStFun = 1, fPtr%nVals
if(fPtr%val(iStFun)%subTree%useGlobalMesh) then
found = .true.
else
! The space time function has a custom shape, thus we have to check
! whether the coordinates are covered by the space time function.
coord = tem_CoordOfReal(tree, point(iPoint,:), tree%global%maxLevel)
treeId = tem_IdOfCoord(coord)
elemPos = tem_PosofId(treeId, tree%treeID)
pos = tem_PositionInSorted( &
& me = fPtr%val(iStFun)%subTree%map2global, &
& val = elemPos )
! When the elemenet is covered by the space time function's shape, we
! evaluate it at the given coordinates.
if (pos > 0) then
found = .true.
end if ! point part of subtree
end if ! global mesh
! When the first space time function was able to fulfill the request, we
! stop looping over them, because we only want one value.
if (found) then
st_res = tem_spacetime_for( &
& me = fPtr%val(iStFun), &
& coord = reshape( source = (/ point(iPoint,1), &
& point(iPoint,2), &
& point(iPoint,3) /), &
& shape = (/ 1, 3 /) ), &
& time = time, &
& n = 1, &
& nComp = fun%nComponents )
res( (iPoint-1)*fun%nComponents + 1 : iPoint*fun%nComponents ) &
& = st_res(1, :)
exit stLoop
end if ! found
end do stLoop
end do !iVal
end subroutine evaluate_first_spacetime_vectorByCoordinate
```