Write single log for the right scheme into its ascii file. This routine calls the get_point routine and dumps the exact point data for the point specified in the tracking table
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| type(hvs_ascii_type), | intent(inout) | :: | ascii |
ascii file to write data to. |
||
| type(tem_comm_env_type), | intent(in) | :: | outProc |
Parallel environment to use for the output. |
||
| integer, | intent(in) | :: | varpos(:) |
Position of the variable to write |
||
| type(tem_varSys_type), | intent(in) | :: | varsys |
Description of the available variable system to get the given varnames from. |
||
| type(treelmesh_type), | intent(in) | :: | mesh |
Mesh to write the data on. |
||
| type(tem_time_type), | intent(in) | :: | time |
Point in time to use for this data. Can be important for space-time function evaluations. |
||
| type(tem_subTree_type), | intent(in), | optional | :: | subtree |
Optional restriction of the points to output. Contains array of points passed in the config to output. |
subroutine hvs_ascii_dump_point_data( ascii, outProc, varPos, varSys, mesh, &
& time, subTree )
! ---------------------------------------------------------------------------
!> ascii file to write data to.
type(hvs_ascii_type), intent(inout) :: ascii
!> Parallel environment to use for the output.
type(tem_comm_env_type ), intent(in) :: outProc
!> Position of the variable to write
integer, intent(in) :: varpos(:)
!> Description of the available variable system to get the given varnames
!! from.
type(tem_varSys_type), intent(in) :: varsys
!> Mesh to write the data on.
type(treelmesh_type), intent(in) :: mesh
!> Point in time to use for this data.
!!
!! Can be important for space-time function evaluations.
type(tem_time_type), intent(in) :: time
!> Optional restriction of the points to output.
!! Contains array of points passed in the config to output.
type(tem_subtree_type), optional, intent(in) :: subtree
! ---------------------------------------------------------------------------
integer :: nVars, nPoints, nScalars, pointsOff, nChunkPoints
integer :: iPoint, iChunk, iScalar, counter
integer :: buf_start, buf_end
real(kind=rk), allocatable :: res(:)
character(len=4000) :: log_output ! output buffer
real(kind=rk), allocatable :: points(:,:)
! ---------------------------------------------------------------------------
if (present(subTree)) then
nPoints = subTree%nPoints
else
nPoints = mesh%nElems
end if
allocate(res(io_buffer_size))
! Number of variables to dump
nVars = size(varPos)
! Number of scalars in current output
nScalars = sum(varSys%method%val(varPos(:))%nComponents)
if (ascii%isReduce) then
! open spatial reduction
call tem_reduction_spatial_open( me = ascii%redSpatial, &
& varSys = varSys, &
& varPos = varPos(:nVars) )
end if
! allocate points to size of chunkSize
allocate(points(ascii%chunkSize,3))
! Process all chunks to derive the quantities defined in the tracking object
do iChunk = 1, ascii%nChunks
! Number of points read so far in previous chunks.
pointsOff = ((iChunk-1)*ascii%chunkSize)
! number of points written to THIS chunk
nChunkPoints = min(ascii%chunkSize, nPoints-pointsOff)
! Compute the points lower and upper bound for the current chunk
buf_start = pointsOff + 1
buf_end = pointsOff + nChunkPoints
if (present(subTree)) then
points(1:nChunkPoints,:) = subTree%points(buf_start:buf_end,:)
else
counter = 0
do iPoint = buf_start, buf_end
counter = counter + 1
points(counter, :) = tem_BaryOfId( mesh, &
& mesh%treeID(iPoint) )
end do
end if
! evaluate all variables on current chunk
call tem_get_point_chunk( varSys = varSys, &
& varPos = varPos, &
& point = points(1:nChunkPoints,:), &
& time = time, &
& tree = mesh, &
& nPnts = nChunkPoints, &
& res = res )
! preform spatial reduction
if (ascii%isReduce) then
! NA : The reduction for the get points needs to be thought
! through as we would like at one point to have all the segment paoints
! stored and reduction applied. In that case, l2 norm and weighted sum
! requires the treeID information. Maybe we should write a new routine to
! do that tem_reduction_spatial_append_point
! KM: changed treeID argument optional because for point values
! no need to do volume reduction
call tem_reduction_spatial_append( me = ascii%redSpatial, &
& chunk = res, &
& nElems = nChunkPoints, &
& tree = mesh, &
& varSys = varSys, &
& varPos = varPos )
end if
end do ! iChunk
! If a reduction is present in the tracking, then the output is
! changed completely to only the reduced values
! For each variable, a reduction has to be assigned
if( ascii%isReduce ) then
! Perform the global reduction on the data which was appended
! inside trackVariable by tem_reduction_spatial_append
call tem_reduction_spatial_close( me = ascii%redSpatial, &
& proc = outProc )
! Re-assign the chunk here to the stuff which was produced in the
! reduction operation
call tem_reduction_spatial_toChunk(me = ascii%redSpatial, &
& chunk = res, &
& nChunkElems = nChunkPoints )
end if
! If reduction is active only root of this output
! dumps data else all process writes their own result file
if ( (ascii%isReduce .and. outProc%rank == 0) .or. &
& (.not. ascii%isReduce) ) then
! First assemble the complete row consisting of the time ...
write( log_output, '(e24.16e3)' ) time%sim
! add all the scalars entries of the variable systems for each elements
do iPoint = 1, nChunkPoints
do iScalar = 1, nScalars
write( log_output, '(a,1x,e24.16e3)' ) trim(log_output), &
& res( (iPoint-1)*nScalars + iScalar )
end do
end do
! then write into the ascii file
write ( ascii%outunit , '(a)' ) trim(log_output)
end if
deallocate(points)
deallocate(res)
end subroutine hvs_ascii_dump_point_data