monitor.f90

Go to the documentation of this file.

module monitor
!
!       This module contains the variables to be monitored during the
!       convergence as well as the arrays to store the convergence.
!       The latter are only allocated by processor 0.
!       The default variables to be monitored depend on the governing
!       equations to be solved.
!
    use constants, only: inttype, realtype, cgnsrealtype, &
                         maxcgnsnamelen
    implicit none
    save
!
!      Parameters for the format to write the convergence to stdout.
!
    integer, parameter :: fieldwidth = 12
    integer, parameter :: fieldwidthlarge = 24
    integer, parameter :: decimalwidth = 5
!
!       Variables to compute the convergence info.
!
    ! nMonSum: Number of monitoring variables for which the sum over
    !          all processors must be taken. Note that this is an
    !          integer, because of MPI.
    ! nMonMax: Number of monitoring variables for which the maximum
    !          over all processors must be taken. Note that this is
    !          an integer, because of MPI.
    ! nMon:    The sum of nmonSum and nmonMax
 
    integer :: nmonsum, nmonmax, nmon
 
    ! monLoc(nMon):  Array for the local summation/maximum of the
    !                monitoring variables.
    ! monGlob(nMon): Idem, but for the global summation/maximum.
    ! monRef(nMon):  Idem, but for the reference values needed
    !                for an unsteady computation.
    ! MassFluxL, G   Massflux out of bcOutflowSubsonic  (eran-msf)
 
    real(kind=realtype), dimension(:), allocatable :: monloc
    real(kind=realtype), dimension(:), allocatable :: monglob
    real(kind=realtype), dimension(:), allocatable :: monref
    real(kind=realtype) :: massfluxl, massfluxg  ! eran-msf
 
    ! monNames(nMon): The names of the variables to be monitored.
 
    character(len=maxCGNSNameLen), dimension(:), allocatable :: &
        monnames
 
    ! monMachOrHMax: Whether or not the maximum value of the Mach
    !                number and total enthalpy difference must be
    !                monitored and thus computed.
    ! showCPU:       Whether or not the CPU time must be shown
    !                in the output to screen.
 
    logical :: monmachorhmax
    logical :: showcpu
 
    ! monMassSliding:  Whether or not to monitor the mass flow of
    !                  the sliding interfaces.
    ! monMassFamilies: Whether or not the mass flow of at least
    !                  one family must be monitored.
 
    logical :: monmasssliding
    logical :: monmassfamilies
!
!       Variables to store the convergence info.
!
    ! convArray(0:nIterMax,nsps,nmon): 3D array to store the
    !                                  convergence histories.
 
    real(kind=cgnsrealtype), dimension(:, :, :), allocatable :: &
        convarray
 
    ! solverDataArray(0:Itermax, sps, 4): stores the cumulative number of iterations,
    !                       CFL, step size, and lin res at each major iter.
    !                       It is used post processing convergence histories
    real(kind=realtype), dimension(:, :, :), allocatable :: solverdataarray
 
    ! solverTypeArray(0:Itermax, sps): Stores string designating the iteration type on
    !                      each major iteration. Each string is 8 char long
    character(len=8), dimension(:, :), allocatable :: solvertypearray
 
!       Variables to store the time accurate history.
!       Only allocated for a time accurate computation.
!
    ! nTimeStepsRestart:   Number of time steps taken in an earlier
    !                      unsteady computation from which a restart
    !                      is performed.
    ! timeStepUnsteady:    The current unsteady time step number;
    !                      restart is not taken into account.
    ! timeUnsteady:        Amount of physical time of the current
    !                      simulation; only relevant in unsteady mode.
    ! timeUnsteadyRestart: Amount of physical time from a previous
    !                      simulation from which a restart is
    !                      performed.
 
    integer(kind=intType) :: ntimestepsrestart, timestepunsteady
    real(kind=realtype) :: timeunsteady, timeunsteadyrestart
 
    ! timeArray(nTimeMax):          Array to store the values of the
    !                               time at every time step.
    ! timeDataArray(nTimeMax,nMon): 2D array to store the variables
    !                               to be monitored at every time
    !                               step. No need to store a spectral
    !                               index here.
 
    real(kind=cgnsrealtype), dimension(:), allocatable :: timearray
 
    real(kind=cgnsrealtype), dimension(:, :), allocatable :: &
        timedataarray
 
    ! writeGrid:    Whether or not a grid file must be written.
    ! writeVolume:  Idem for a volume solution file.
    ! writeSurface: Idem for a surface solution file.
 
    logical :: writegrid, writevolume, writesurface, writesoleachiter
 
end module monitor