Write single log for the right scheme into its ascii file. This routine dumps the element data
| 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 elements to output. |
|
| integer, | intent(in) | :: | nDofs |
The number of dofs for each scalar variable of the equation system |
subroutine hvs_ascii_dump_elem_data( ascii, outProc, varPos, varSys, mesh, &
& time, subTree, nDofs )
! ---------------------------------------------------------------------------
!> 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 elements to output.
type(tem_subtree_type), optional, intent(in) :: subtree
!> The number of dofs for each scalar variable of the equation system
integer, intent(in) :: nDofs
! ---------------------------------------------------------------------------
integer :: nVars, nElems, nScalars, elemOff, nChunkElems
integer :: nDofs_out
integer :: nScalars_out
integer :: iElem, iChunk, iScalar, iDof
integer :: buf_start, buf_end
real(kind=rk), allocatable :: res(:)
integer, allocatable :: elemPos(:)
character(len=4000) :: log_output ! output buffer
! ---------------------------------------------------------------------------
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 (present(subTree)) then
nElems = subTree%nElems
else
nElems = mesh%nElems
end if
if (ascii%isReduce) then
! open spatial reduction
call tem_reduction_spatial_open( me = ascii%redSpatial, &
& varSys = varSys, &
& varPos = varPos(:nVars) )
end if
! allocate elemPos to size of chunkSize
allocate(elemPos(ascii%chunkSize))
! Process all chunks to derive the quantities defined in the tracking object
do iChunk = 1, ascii%nChunks
! Number of elements read so far in previous chunks.
elemOff = ((iChunk-1)*ascii%chunkSize)
! number of elements written to THIS chunk
nChunkElems = min(ascii%chunkSize, nElems-elemOff)
! Compute the element lower and upper bound for the current chunk
buf_start = elemOff + 1
buf_end = elemOff + nChunkElems
if (present(subTree)) then
elemPos(1:nChunkElems) = subTree%map2Global(buf_start:buf_end)
else
elemPos(1:nChunkElems) = (/ (iElem, iElem=buf_start, buf_end) /)
end if
! evaluate all variables on current chunk
call tem_get_element_chunk(varSys = varSys, &
& varPos = varPos, &
& elemPos = elemPos(1:nChunkElems), &
& time = time, &
& tree = mesh, &
& nElems = nChunkElems, &
& nDofs = nDofs, &
& res = res )
! preform spatial reduction
if (ascii%isReduce) then
call tem_reduction_spatial_append( &
& me = ascii%redSpatial, &
& chunk = res, &
& nElems = nChunkElems, &
& treeID = mesh%treeID( &
& elemPos(1:nChunkElems) ), &
& tree = mesh, &
& varSys = varSys, &
& nDofs = nDofs, &
& varPos = varPos )
end if
end do ! iChunk
ndofs_out = ndofs
nscalars_out = nscalars
! 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 = nChunkElems )
ndofs_out = 1
nscalars_out = sum(ascii%redSpatial(:)%nComponents)
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 iElem = 1, nChunkElems
do iDof = 1, nDofs_out
do iScalar = 1, nScalars_out
write( log_output, '(a,1x,e24.16e3)' ) trim(log_output), &
& res( ((iElem-1)*nDofs_out+ (iDof-1))*nScalars_out + iScalar )
end do
end do
end do
! then write into the ascii file
write ( ascii%outunit , '(a)' ) trim(log_output)
end if
deallocate(elemPos)
deallocate(res)
end subroutine hvs_ascii_dump_elem_data