ModStatsRoutines.F90

Go to the documentation of this file.

! *********************************************************************
! * Rocstar Simulation Suite                                          *
! * Copyright@2015, Illinois Rocstar LLC. All rights reserved.        *
! *                                                                   *
! * Illinois Rocstar LLC                                              *
! * Champaign, IL                                                     *
! * www.illinoisrocstar.com                                           *
! * sales@illinoisrocstar.com                                         *
! *                                                                   *
! * License: See LICENSE file in top level of distribution package or *
! * http://opensource.org/licenses/NCSA                               *
! *********************************************************************
! *********************************************************************
! * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,   *
! * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES   *
! * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND          *
! * NONINFRINGEMENT.  IN NO EVENT SHALL THE CONTRIBUTORS OR           *
! * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER       *
! * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,   *
! * Arising FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE    *
! * USE OR OTHER DEALINGS WITH THE SOFTWARE.                          *
! *********************************************************************
! ******************************************************************************
!
! Purpose: Suite of statistics routines.
!
! Description: None.
!
! Notes: None.
!
! ******************************************************************************
!
! $Id: ModStatsRoutines.F90,v 1.11 2008/12/06 08:44:19 mtcampbe Exp $
!
! Copyright: (c) 2004 by the University of Illinois
!
! ******************************************************************************

MODULE modstatsroutines

  USE modglobal, ONLY: t_global 
  USE modparameters
  USE moddatatypes
  USE moderror
  USE moddatastruct, ONLY: t_region  
  USE modgrid, ONLY: t_grid
  USE modmpi

#ifdef PLAG
  USE plag_modeulerian, ONLY : plag_calceulerianfield
#endif
 
  IMPLICIT NONE

  PRIVATE
  PUBLIC :: statbuildversionstring, &
            getstatistics, &
            initstatistics, &
            statdataaccumulation1, &
            statdataaccumulation2, &
            statdatasampling, &
            statmapping, &
            stattimeaccumulation, &
            statwritemp
        
! ******************************************************************************
! Declarations and definitions
! ****************************************************************************** 
   
  CHARACTER(CHRLEN) :: RCSIdentString = & 
    '$RCSfile: ModStatsRoutines.F90,v $ $Revision: 1.11 $'        
             
! ******************************************************************************
! Routines
! ******************************************************************************

  CONTAINS
  
!******************************************************************************
!
! Purpose: Build version string for printing in header.
!
! Description: none.
!
! Input: none.
!
! Output: 
!   versionString = string containing version number and date.
!
! Notes: 
!   1. The strings are NOT to be edited by anyone except the developer of 
!      this physical module. 
!
!******************************************************************************

SUBROUTINE statbuildversionstring( versionString )

  IMPLICIT NONE

! ... parameters
  CHARACTER(*) :: versionstring

! ... local variables
  CHARACTER(LEN=2)  :: major, minor, patch
  CHARACTER(CHRLEN) :: date

!******************************************************************************
! set strings: DO NOT EDIT UNLESS YOU ARE STATS DEVELOPER

  major = '1'
  minor = '0'
  patch = '0'

  date  = '11/30/04'

! write into string

  WRITE(versionstring,'(A)') trim(major)//'.'//trim(minor)//'.'//trim(patch)
  WRITE(versionstring,'(A)') 'Version: '//trim(versionstring)
  WRITE(versionstring,'(A)') trim(versionstring)//', Date: '//trim(date)

END SUBROUTINE statbuildversionstring

!******************************************************************************
!
! Purpose: calling data sampling routines for time averaged statistics
!
! Description: data sampling for time averaged statistics of gas mixture 
!              and other physical module if desired; in addition
!              averaging time interval is integrated
!
! Input: regions = data of all regions
!
! Output: StatDataSampling and StatTimeAccumulation called
!
! Notes: none.
!
!******************************************************************************

SUBROUTINE getstatistics( regions )

  IMPLICIT NONE

! ... parameters
  TYPE(t_region), POINTER :: regions(:)

! ... loop variables
  INTEGER :: ireg

! ... local variables
  TYPE(t_global), POINTER :: global

#ifdef PLAG
    TYPE(t_region), POINTER :: pregion
#endif

!******************************************************************************

  global => regions(1)%global

  CALL registerfunction( global,'GetStatistics',&
  'ModStatsRoutines.F90' )

! perform data sampling --------------------------------------------------------

  IF (global%doStat == active) THEN
#ifdef RFLO
    DO ireg=1,global%nRegions
      IF (regions(ireg)%procid==global%myProcid .AND. &   ! region active and
          regions(ireg)%active==active) THEN              ! on my processor
#endif
#ifdef RFLU
    DO ireg=1,global%nRegionsLocal
#endif
        IF (global%mixtNStat>0) CALL statdatasampling( regions(ireg),ftype_mixt )
#ifdef TURB
        IF (global%turbNStat>0) THEN
          IF ((regions(ireg)%mixtInput%flowModel == flow_navst) .AND. &
              (regions(ireg)%mixtInput%turbModel /= turb_model_none)) THEN
            CALL statdatasampling( regions(ireg),ftype_turb )
          ENDIF
        ENDIF
#endif
#ifdef PLAG
        IF ( global%plagUsed .EQV. .true. ) THEN
          pregion => regions(ireg)

          CALL plag_calceulerianfield( pregion )
          IF ( global%plagNStat>0 ) & 
            CALL statdatasampling( regions(ireg),ftype_plag ) 
        ENDIF ! plagUsed
#endif
#ifdef RFLO
      ENDIF
#endif
    
    ENDDO
    CALL stattimeaccumulation( global ) 
  ENDIF

! finalize --------------------------------------------------------------------

  CALL deregisterfunction( global )

END SUBROUTINE getstatistics

!******************************************************************************
!
! Purpose: initiation of time averaged statistics
!
! Description: initiation proceeds for gas mixture and other physical 
!              module if desired; it is initiated by zero for new
!              time averaging and by old values for restarting from 
!              the previous process
!
! Input: regions = data of all regions
!
! Output: regions%levels%mixt%tav = time averaged mixture variables
!         regions%levels%turb%tav = time averaged TURB variables
!
! Notes: none.
!
!******************************************************************************

SUBROUTINE initstatistics( regions )

#ifdef RFLO
  USE modinterfaces, ONLY : rflo_readstat
#ifdef PLAG
  USE plag_rflo_modstats, ONLY : plag_rflo_readstat
#endif
#endif
#ifdef RFLU
  USE modinterfaces, ONLY : rflu_readstat
#ifdef GENX
  USE stat_rflu_modrocstaradmin, ONLY : stat_rflu_genxgetdata
#endif
#endif
  IMPLICIT NONE

! ... parameters
  TYPE(t_region), POINTER :: regions(:)

! ... loop variables
  INTEGER :: ireg

! ... local variables
  INTEGER :: ilev

  TYPE(t_global), POINTER :: global
#ifdef RFLU
  TYPE(t_region), POINTER :: pregion
#endif

!******************************************************************************

  global => regions(1)%global

  CALL registerfunction( global,'InitStatistics',&
  'ModStatsRoutines.F90' )

! check if the flow is unsteady -----------------------------------------------

  IF (global%flowType == flow_steady)  THEN
    global%doStat = off 
  ENDIF

! initialization of time averaging statistics ---------------------------------

  global%statBc = 0

  IF (global%doStat == active) THEN

! - restart from previous statistics

    IF (global%reStat == active) THEN

      IF (global%myProcid==masterproc .AND. global%verbLevel/=verbose_none)  &
        WRITE(stdout,'(A)') solver_name//' Restart statistics ...'
#ifndef GENX
#ifdef RFLO
      CALL rflo_readstat( regions )
#ifdef PLAG
      IF ( global%plagUsed .EQV. .true. ) &
        CALL plag_rflo_readstat( regions )
#endif
#endif
#ifdef RFLU
      DO ireg=1,global%nRegionsLocal
        CALL rflu_readstat( regions(ireg) )
      ENDDO
#endif

#else

#ifdef RFLU
      DO ireg=1,global%nRegionsLocal
        pregion => regions(ireg)
        CALL stat_rflu_genxgetdata( pregion )
      ENDDO
#endif
#endif

! - initialize new statistics

    ELSE

      IF (global%myProcid==masterproc .AND. global%verbLevel/=verbose_none)  &
        WRITE(stdout,'(A)') solver_name//' Start new statistics ...'
      global%integrTime = 0._rfreal      
#ifdef RFLO
      DO ireg=1,global%nRegions
        IF (regions(ireg)%procid==global%myProcid .AND. &   ! region active and
            regions(ireg)%active==active) THEN              ! on my processor
          ilev =  regions(ireg)%currLevel
          IF (global%mixtNStat > 0) THEN
            regions(ireg)%levels(ilev)%mixt%tav = 0._rfreal
          ENDIF
#ifdef TURB
          IF ((regions(ireg)%mixtInput%flowModel == flow_navst) .AND. &
              (regions(ireg)%mixtInput%turbModel /= turb_model_none) .AND. &
              (global%turbNStat > 0)) THEN
            regions(ireg)%levels(ilev)%turb%tav = 0._rfreal
          ENDIF
#endif
#ifdef PLAG
          IF ((global%plagUsed .EQV. .true.) .AND. &
              (global%plagNStat > 0)) THEN
            regions(ireg)%levels(ilev)%plag%tav = 0._rfreal
          ENDIF
#endif
        ENDIF     ! region on this processor and active
      ENDDO       ! iReg
#endif
#ifdef RFLU
      DO ireg=1,global%nRegionsLocal
        IF (global%mixtNStat > 0) THEN
          regions(ireg)%mixt%tav =  0._rfreal
        ENDIF
#ifdef TURB
        IF ((regions(ireg)%mixtInput%flowModel == flow_navst) .AND. &
            (regions(ireg)%mixtInput%turbModel /= turb_model_none) .AND. &
            (global%turbNStat > 0)) THEN
          regions(ireg)%turb%tav =  0._rfreal
        ENDIF
#endif
#ifdef PLAG
        IF ((global%plagUsed .EQV. .true.) .AND. &
            (global%plagNStat > 0)) THEN
          regions(ireg)%plag%tav = 0._rfreal
        ENDIF
#endif
      ENDDO       ! iReg
#endif

    ENDIF
  ENDIF

! finalize --------------------------------------------------------------------

  CALL deregisterfunction( global )

END SUBROUTINE initstatistics

!******************************************************************************
!
! Purpose: accumulate selected instantaneous quantities in time
!
! Description: this file containes two routines:
!              1st routine, StatDataAccumulation1, for first moment variables
!              2nd routine, StatDataAccumulation2, for second moment variables
!
! Input 1st routine:    ijkbeg, ijkend = begin and end cell indices
!                       id             = index of variable var
!                       idtav          = index of time-accumulated quantity
!                       dTime          = time step
!                       var            = variable to be time accumulated
!                      
! Input 2nd routine:    ijkbeg, ijkend = begin and end cell indices
!                       id1            = index of first component variable
!                       id2            = index of second component variable
!                       idtav          = index of time-accumulated quantity
!                       dTime          = time step
!                       var1           = 1st component of 2nd moment variable
!                       var2           = 2nd component of 2nd moment variable 
!                      
! Output of 1st and 2nd routine: qavg = quantity accumulated in time
!
! Notes: none.
!
!******************************************************************************

SUBROUTINE statdataaccumulation1( ijkbeg,ijkend,id,idtav,dTime,var,qavg )

  IMPLICIT NONE

! ... parameters
  INTEGER               :: ijkbeg, ijkend, id, idtav
  REAL(RFREAL)          :: dtime
  REAL(RFREAL), POINTER :: var(:,:), qavg(:,:)

! ... loop variables
  INTEGER :: ijk

!******************************************************************************

  DO ijk=ijkbeg,ijkend
    qavg(idtav,ijk) = qavg(idtav,ijk) + dtime*var(id,ijk)
  ENDDO

END SUBROUTINE statdataaccumulation1

! #############################################################################

SUBROUTINE statdataaccumulation2( ijkbeg,ijkend,id1,id2,idtav, &
                                  dtime,var1,var2,qavg )

  IMPLICIT NONE

! ... parameters
  INTEGER               :: ijkbeg, ijkend, id1, id2, idtav
  REAL(RFREAL)          :: dtime
  REAL(RFREAL), POINTER :: var1(:,:), var2(:,:), qavg(:,:)

! ... loop variables
  INTEGER :: ijk

!******************************************************************************

  DO ijk=ijkbeg,ijkend
    qavg(idtav,ijk) = qavg(idtav,ijk) + dtime*var1(id1,ijk)*var2(id2,ijk)
  ENDDO

END SUBROUTINE statdataaccumulation2

!******************************************************************************
!
! Purpose: sorting variables to be time averaged
!
! Description: sorting procedure based on selection taken by user 
!              stored in statId and mapped into statCode.
!
! Input: region              = data of current region
!        fluidType           = mixture, turb, plag, etc        
!        cv, dv, tv, gv      = variables to be time averaged
!        statCode            = mapping identifiers
!   
! Output: tav  = quantities accumulated in time
!
! Notes: none.
!
!******************************************************************************

SUBROUTINE statdatasampling( region,fluidType )

#ifdef RFLO
  USE modinterfaces, ONLY : rflo_getdimensdummy, rflo_getcelloffset

#include "Indexing.h"
#endif
  IMPLICIT NONE

! ... parameters
  TYPE(t_region) :: region
  INTEGER        :: fluidtype

! ... loop variables
  INTEGER :: l

! ... local variables
  INTEGER :: ilev, ioff, ijoff
  INTEGER :: idcbeg, jdcbeg, kdcbeg, idcend, jdcend, kdcend, ijkbeg, ijkend
  INTEGER :: nstat, id1, id2
  INTEGER, POINTER      :: statcode(:,:,:)

  REAL(RFREAL), POINTER :: cv(:,:),dv(:,:),tv(:,:),gv(:,:),ev(:,:),tav(:,:)
  REAL(RFREAL), POINTER :: sv(:,:),st(:,:)
  REAL(RFREAL), POINTER :: var1(:,:),var2(:,:) 

!******************************************************************************

  CALL registerfunction( region%global,'StatDataSampling',&
  'ModStatsRoutines.F90' )

! get dimensions and pointers -------------------------------------------------

#ifdef RFLO
  ilev = region%currLevel
#endif

  IF (fluidtype == ftype_mixt) THEN
    nstat = region%global%mixtNStat
    statcode => region%global%mixtStatCode
#ifdef RFLO
    cv    => region%levels(ilev)%mixt%cv
    dv    => region%levels(ilev)%mixt%dv
    tv    => region%levels(ilev)%mixt%tv
    gv    => region%levels(ilev)%mixt%gv
    tav   => region%levels(ilev)%mixt%tav
#endif
#ifdef RFLU
    cv    => region%mixt%cv
    dv    => region%mixt%dv
    tv    => region%mixt%tv
    gv    => region%mixt%gv
    tav   => region%mixt%tav
#endif
  ELSEIF (fluidtype == ftype_turb) THEN
#ifdef TURB
    nstat = region%global%turbNStat
    statcode => region%global%turbStatCode
#ifdef RFLO
    tv    => region%levels(ilev)%mixt%tv
    dv    => region%levels(ilev)%turb%dv
    sv    => region%levels(ilev)%turb%sv
    st    => region%levels(ilev)%turb%st
    tav   => region%levels(ilev)%turb%tav
#endif
#ifdef RFLU
    tv    => region%mixt%tv
    dv    => region%turb%dv
    sv    => region%turb%sv
    st    => region%turb%st
    tav   => region%turb%tav
#endif
#endif
  ELSEIF (fluidtype == ftype_plag) THEN
#ifdef PLAG
    nstat = region%global%plagNStat
    statcode => region%global%plagStatCode
#ifdef RFLO
    ev    => region%levels(ilev)%plag%ev
    tav   => region%levels(ilev)%plag%tav
#endif
#ifdef RFLU
    ev    => region%plag%ev
    tav   => region%plag%tav
#endif
#endif
  ELSEIF (fluidtype == ftype_peul) THEN
#ifdef PEUL
    nstat = region%global%peulNStat
    statcode => region%global%peulStatCode
#ifdef RFLO
!    cv    => region%levels(iLev)%peul%cv
!    dv    => region%levels(iLev)%peul%dv
!    tav   => region%levels(iLev)%peul%tav
#endif
#ifdef RFLU
!    cv    => region%peul%cv
!    dv    => region%peul%dv
!    tav   => region%peul%tav
#endif
#endif
  ENDIF

#ifdef RFLO
  CALL rflo_getdimensdummy( region,ilev,idcbeg,idcend, &
                            jdcbeg,jdcend,kdcbeg,kdcend )
  CALL rflo_getcelloffset( region,ilev,ioff,ijoff )
  ijkbeg = indijk(idcbeg,jdcbeg,kdcbeg,ioff,ijoff)
  ijkend = indijk(idcend,jdcend,kdcend,ioff,ijoff)
#endif
#ifdef RFLU
  ijkbeg = 1
  ijkend = region%grid%nCells
#endif

! Quantities to be time-averaged is determined from the index selected by user.
! Data accumulation proceeds afterwards for each quantity.

  DO l=1,nstat

    IF ((statcode(1,1,l)==stat_none).AND.(statcode(2,1,l)==stat_none)) &
    goto 999

    IF (statcode(1,1,l)==stat_cv) THEN
      var1 => cv
    ELSEIF (statcode(1,1,l)==stat_dv) THEN
      var1 => dv
    ELSEIF (statcode(1,1,l)==stat_tv) THEN
      var1 => tv
    ELSEIF (statcode(1,1,l)==stat_gv) THEN
      var1 => gv
    ELSEIF (statcode(1,1,l)==stat_sv) THEN
      var1 => sv
    ELSEIF (statcode(1,1,l)==stat_st) THEN
      var1 => st
    ELSEIF (statcode(1,1,l)==stat_plagev) THEN
      var1 => ev
    ENDIF

    IF (statcode(2,1,l)==stat_cv) THEN
      var2 => cv
    ELSEIF (statcode(2,1,l)==stat_dv) THEN
      var2 => dv
    ELSEIF (statcode(2,1,l)==stat_tv) THEN
      var2 => tv
    ELSEIF (statcode(2,1,l)==stat_gv) THEN
      var2 => gv
    ELSEIF (statcode(2,1,l)==stat_sv) THEN
      var2 => sv
    ELSEIF (statcode(2,1,l)==stat_st) THEN
      var2 => st
    ELSEIF (statcode(2,1,l)==stat_plagev) THEN
      var2 => ev
    ENDIF

    id1 = statcode(1,2,l)
    id2 = statcode(2,2,l)

    IF (statcode(1,1,l)==stat_none) THEN
      CALL statdataaccumulation1( ijkbeg,ijkend,id2,l, &
                                  region%global%dtMin,var2,tav )
    ELSEIF (statcode(2,1,l)==stat_none) THEN
      CALL statdataaccumulation1( ijkbeg,ijkend,id1,l, &
                                  region%global%dtMin,var1,tav )
    ELSE
      CALL statdataaccumulation2( ijkbeg,ijkend,id1,id2,l, &
                                  region%global%dtMin,var1,var2,tav )
    ENDIF

  ENDDO

! finalize --------------------------------------------------------------------

999 CONTINUE

  CALL deregisterfunction( region%global )

END SUBROUTINE statdatasampling

!******************************************************************************
!
! Purpose: mapping from mixture and physical module ID to statistics ID
!
! Description: mapping based on parameter mixtStatId, turbStatId, etc 
!              input by user
!
! Input: global%mixtStatId : mixture statistics ID from user input
!        global%turbStatId : TURB statistics ID from user input
!
! Output: global%mixtStatCode : mapped mixture statistics ID
!         global%turbStatCode : mapped TURB statistics ID
!
! Notes: none.
!
!******************************************************************************

SUBROUTINE statmapping( global )

#ifdef GENX
  USE modinterfacesstatistics, ONLY : genxstatnaming
#endif
#ifdef TURB
  USE modinterfacesturbulence, ONLY : turb_statmapping
#endif
#ifdef PLAG
  USE modinterfaceslagrangian, ONLY : plag_statmapping
#endif
#ifdef PEUL
!  USE ModInterfacesEulerian,   ONLY : PEUL_StatMapping
#endif
  IMPLICIT NONE

! ... parameters
  TYPE(t_global), POINTER :: global

! ... loop variables
  INTEGER  :: l, n

! ... local variables
#ifdef GENX
  CHARACTER(CHRLEN), POINTER :: statname(:,:,:)
#endif
  INTEGER :: errorflag
  INTEGER, POINTER  :: statid(:,:), statcode(:,:,:)

!******************************************************************************

  CALL registerfunction( global,'StatMapping',&
  'ModStatsRoutines.F90' )

! allocate mixture variables and set pointers ---------------------------------

  IF (global%mixtNStat <= 0) goto 111

  ALLOCATE( global%mixtStatCode(2,2,global%mixtNStat),stat=errorflag )
  global%error = errorflag
  IF (global%error /= 0) CALL errorstop( global,err_allocate,__line__ )

  statid   => global%mixtStatId
  statcode => global%mixtStatCode

#ifdef GENX
  ALLOCATE( global%mixtStatNm(2,2,global%mixtNStat),stat=errorflag )
  global%error = errorflag
  IF (global%error /= 0) CALL errorstop( global,err_allocate,__line__ )

  statname => global%mixtStatNm
#endif

! set mixture mapping ---------------------------------------------------------

  DO l=1,global%mixtNStat
    DO n=1,2
      IF (statid(n,l)==0) THEN 
        statcode(n,:,l) = stat_none
      ELSE IF (statid(n,l)==1) THEN 
        statcode(n,1,l) = stat_cv
        statcode(n,2,l) = cv_mixt_dens
#ifdef GENX
        statname(n,1,l) = 'rho'
        statname(n,2,l) = 'kg/m^3'
#endif
      ELSE IF (statid(n,l)==2) THEN 
#ifdef RFLO
        statcode(n,1,l) = stat_dv
        statcode(n,2,l) = dv_mixt_uvel
#endif
#ifdef RFLU
        statcode(n,1,l) = stat_cv
        statcode(n,2,l) = cv_mixt_xvel
#endif
#ifdef GENX
        statname(n,1,l) = 'u'
        statname(n,2,l) = 'm/s'
#endif
      ELSE IF (statid(n,l)==3) THEN 
#ifdef RFLO
        statcode(n,1,l) = stat_dv
        statcode(n,2,l) = dv_mixt_vvel
#endif
#ifdef RFLU
        statcode(n,1,l) = stat_cv 
        statcode(n,2,l) = cv_mixt_yvel 
#endif
#ifdef GENX
        statname(n,1,l) = 'v'
        statname(n,2,l) = 'm/s'
#endif
      ELSE IF (statid(n,l)==4) THEN 
#ifdef RFLO
        statcode(n,1,l) = stat_dv
        statcode(n,2,l) = dv_mixt_wvel
#endif
#ifdef RFLU
        statcode(n,1,l) = stat_cv 
        statcode(n,2,l) = cv_mixt_zvel 
#endif
#ifdef GENX
        statname(n,1,l) = 'w'
        statname(n,2,l) = 'm/s'
#endif
      ELSE IF (statid(n,l)==5) THEN 
        statcode(n,1,l) = stat_dv
        statcode(n,2,l) = dv_mixt_temp
#ifdef GENX
        statname(n,1,l) = 'T'
        statname(n,2,l) = 'K'
#endif
      ELSE IF (statid(n,l)==6) THEN 
        statcode(n,1,l) = stat_dv
        statcode(n,2,l) = dv_mixt_pres
#ifdef GENX
        statname(n,1,l) = 'p'
        statname(n,2,l) = 'N/m^2'
#endif
      ELSE IF (statid(n,l)==7) THEN 
        statcode(n,1,l) = stat_dv
        statcode(n,2,l) = dv_mixt_soun
#ifdef GENX
        statname(n,1,l) = 'c'
        statname(n,2,l) = 'm/s'
#endif
      ELSE IF (statid(n,l)==8) THEN 
        statcode(n,1,l) = stat_tv
        statcode(n,2,l) = tv_mixt_muel
#ifdef GENX
        statname(n,1,l) = 'mul'
        statname(n,2,l) = 'kg/ms'
#endif
      ELSE IF (statid(n,l)==9) THEN 
        statcode(n,1,l) = stat_tv
        statcode(n,2,l) = tv_mixt_tcol
#ifdef GENX
        statname(n,1,l) = 'tcol'
        statname(n,2,l) = 'kg m/Ks^3'
#endif
      ELSE
        CALL errorstop( global,err_stats_indexing,__line__, &
                        'mixture index out of range.' ) 
      ENDIF
    ENDDO
  ENDDO

#ifdef GENX
! defined names and units of mixture statistics

  CALL genxstatnaming( global, ftype_mixt )
#endif

111 CONTINUE

#ifdef TURB
! allocate TURB variables and set pointers ---------------------------------

  IF (global%turbNStat <= 0) goto 222

! set TURB mapping ---------------------------------------------------------

  CALL turb_statmapping( global )

222 CONTINUE
#endif

#ifdef PLAG
! allocate PLAG variables and set pointers ---------------------------------

  IF (global%plagNStat <= 0) goto 333

! set PLAG mapping ---------------------------------------------------------

  CALL plag_statmapping( global )

333 CONTINUE
#endif

#ifdef PEUL
! allocate PEUL variables and set pointers ---------------------------------

  IF (global%peulNStat <= 0) goto 444

! set PEUL mapping ---------------------------------------------------------

!  CALL PEUL_StatMapping( global )

444 CONTINUE
#endif

#ifdef RFLO
! check with regard to inlet turbulence recycling -----------------------------
! stats id 01-06 must exist and lined up in the same order

  IF (global%infloNijk < nijk_inflow_init) THEN
    DO l=1,global%mixtNStat
      IF (statid(1,l)==0) THEN 
        IF (statid(2,l) /= l) THEN
          CALL errorstop( global,err_stats_indexing,__line__, &
              'For recycturb inflow, set stats Id 01-06 in the given order.' ) 
        ENDIF
      ENDIF
    ENDDO
  ENDIF
#endif

! finalize --------------------------------------------------------------------

  CALL deregisterfunction( global )

END SUBROUTINE statmapping

!******************************************************************************
!
! Purpose: accumulation of time during time averaging process
!
! Description: time integration proceeds from STARTTIME to MAXTIME set by user
!              if statistics RESTART (global%reStat) active, the process is
!              continuation from previous process
!
! Input: global%dtMin = global minimum time advancement.
!
! Output: global%integrTime = accumulated time.
!
! Notes: none.
!
!******************************************************************************

SUBROUTINE stattimeaccumulation( global )

  IMPLICIT NONE

! ... parameters
  TYPE(t_global), POINTER :: global

! ... local variables

!******************************************************************************

  CALL registerfunction( global,'StatTimeAccumulation',&
  'ModStatsRoutines.F90' )

! accumulate time steps used in time-weighted averaging process

  global%integrTime = global%integrTime + global%dtMin

! finalize --------------------------------------------------------------------

  CALL deregisterfunction( global )

END SUBROUTINE stattimeaccumulation

!******************************************************************************
!
! Purpose: update bc and write time averaged solution for all active physical 
!          modules
!
! Description: none.
!
! Input: regions = tav of all physical modules in all regions 
!
! Output: to file
!
! Notes: none.
!
!******************************************************************************
!
! $Id: ModStatsRoutines.F90,v 1.11 2008/12/06 08:44:19 mtcampbe Exp $
!
! Copyright: (c) 2001 by the University of Illinois
!
!******************************************************************************

SUBROUTINE statwritemp( regions )

  USE moddatatypes
  USE moddatastruct, ONLY : t_region
  USE modglobal, ONLY     : t_global
#ifdef RFLO
  USE modinterfaces, ONLY : rflo_writestat
  USE rflo_modstatsboundaryconditions, ONLY : rflo_statboundaryconditionsset
#ifdef PLAG
  USE plag_rflo_modstats, ONLY : plag_rflo_writestat, &
                                 plag_rflo_commstatbuffwrapper
#endif
#endif
  USE moderror
  USE modparameters
  IMPLICIT NONE

#ifdef RFLO
#include "Indexing.h"
#endif

! ... parameters
  TYPE(t_region), POINTER :: regions(:)

! ... loop variables

! ... local variables

  TYPE(t_global), POINTER :: global

!******************************************************************************

  global => regions(1)%global

  CALL registerfunction( global,'StatWriteMP',&
  'ModStatsRoutines.F90' )

! start -----------------------------------------------------------------------

#ifdef RFLO
#ifdef PLAG
  CALL plag_rflo_commstatbuffwrapper( regions )
#endif
  CALL rflo_statboundaryconditionsset( regions )

  CALL rflo_writestat( regions )
#ifdef PLAG
  CALL plag_rflo_writestat( regions )
#endif
#endif

! finalize --------------------------------------------------------------------

  CALL deregisterfunction( global )

END SUBROUTINE statwritemp

! ******************************************************************************
! End
! ******************************************************************************
  
END MODULE modstatsroutines

! ******************************************************************************
!
! RCS Revision history:
!
! $Log: ModStatsRoutines.F90,v $
! Revision 1.11  2008/12/06 08:44:19  mtcampbe
! Updated license.
!
! Revision 1.10  2008/11/19 22:17:30  mtcampbe
! Added Illinois Open Source License/Copyright
!
! Revision 1.9  2006/01/10 05:02:34  wasistho
! Get statistics Genx data in RFLU
!
! Revision 1.8  2005/12/20 20:42:39  wasistho
! added ifdef RFLO around kernel using global%Nijk
!
! Revision 1.7  2005/12/01 09:00:10  wasistho
! sanity check stats Id with inlet turbulence
!
! Revision 1.6  2005/06/16 03:52:18  wasistho
! activated RFLO_ModStatsBc
!
! Revision 1.5  2005/05/21 07:07:50  wasistho
! backout RFLO_ModStatsBoundaryConditions temporarily
!
! Revision 1.4  2005/05/21 01:42:47  wasistho
! added statWriteMP
!
! Revision 1.3  2005/01/11 01:28:33  wasistho
! fixed bugs, PLAG data sampling was outside regions loop
!
! Revision 1.2  2005/01/08 20:36:44  fnajjar
! Added statistics infrastructure for PLAG and activated datastructure appropriately
!
! Revision 1.1  2004/12/29 23:28:21  wasistho
! moved ModStatisticsRoutines from libfloflu to modfloflu
!
! Revision 1.1  2004/12/28 20:30:00  wasistho
! moved statistics routines into module ModStatsRoutines
!
!
! ******************************************************************************