INRT_ReadBurning.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: Reads in information related to the interaction Burning
!
! Description: none.
!
! Input: regions = data of all regions
!
! Output: fills user data into region%inrtInput%inrts
!
! Notes: none.
!
!******************************************************************************
!
! $Id: INRT_ReadBurning.F90,v 1.3 2008/12/06 08:44:31 mtcampbe Exp $
!
! Copyright: (c) 2003 by the University of Illinois
!
!******************************************************************************

SUBROUTINE inrt_readburning( regions )

  USE moddatatypes
  USE moddatastruct, ONLY : t_region
  USE modglobal,     ONLY : t_global
  USE modmaterials,  ONLY : t_material
  USE modinteract,   ONLY : t_inrt_input,t_inrt_interact
  USE moderror
  USE modparameters
  USE inrt_modparameters

#ifdef RFLO
  USE modinterfaces,         ONLY : readbothregionsection
#endif
#ifdef RFLU
  USE modinterfaces,         ONLY : readbothsection
#endif
  USE modinterfaces,         ONLY : makenumberedkeys

  USE modinterfacesinteract, ONLY : inrt_setmaterial
  USE inrt_modinterfaces,    ONLY : inrt_setactiveness,inrt_setpermission, &
                                    inrt_determinetokens,inrt_defineburning
  IMPLICIT NONE

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

! ... loop variables
  INTEGER :: ireg,iplag,ipeul,ipeuloutedge

! ... local variables
  INTEGER, PARAMETER :: nstrkeys_max = 5
  INTEGER, PARAMETER :: nkeys_max    = 50
  INTEGER, PARAMETER :: npeul_max    = 10

  CHARACTER(CHRLEN)  :: rcsidentstring
  CHARACTER(CHRLEN)  :: strkeys(nstrkeys_max),keys(nkeys_max)
  CHARACTER(CHRLEN)  :: strvals(nstrkeys_max)

  INTEGER :: brbeg,brend
  INTEGER :: nplag,npeul
  INTEGER :: iedge,nedges,npeuloutedges,npeuloxedges
  INTEGER :: nstrkeys,nfixedimplkeys,nfixednodekeys,nkeys
  INTEGER :: ind,indmixt,indplag0,indpeul0,indintl
  INTEGER :: istrkeymaterialin,istrkeymaterialout,istrkeymaterialox
  INTEGER :: ikey,ikeyused,ikeymodel,ikeyoxused,ikeyheatcoef
  INTEGER :: ikeyvapormeth,ikeyvaportemp
  INTEGER :: ikeymfrcplag,ikeymfrcpeul0
  INTEGER :: ikeynode0,ikeymixtactv,ikeymixtperm,ikeyplagactv,ikeyplagperm
  INTEGER :: ikeypeulactv0,ikeypeulperm0,ikeyactv,ikeyperm

  LOGICAL :: plagoutexists,oxused
  LOGICAL :: defined(nkeys_max),strdefined(nstrkeys_max)

  REAL(RFREAL) :: coef
  REAL(RFREAL) :: vals(nkeys_max)

  TYPE(t_material),      POINTER :: matin,matout,matox
  TYPE(t_inrt_input),    POINTER :: input
  TYPE(t_inrt_interact), POINTER :: inrt
  TYPE(t_global),        POINTER :: global

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

  rcsidentstring = '$RCSfile: INRT_ReadBurning.F90,v $ $Revision: 1.3 $'

  global => regions(1)%global

  CALL registerfunction( global,'INRT_ReadBurning',&
  'INRT_ReadBurning.F90' )

! begin -----------------------------------------------------------------------

! define string keys

  istrkeymaterialin  = 1
  istrkeymaterialout = 2
  istrkeymaterialox  = 3
  nstrkeys = 3

  strkeys(istrkeymaterialin)  = 'MATERIAL_IN'
  strkeys(istrkeymaterialout) = 'MATERIAL_OUT'
  strkeys(istrkeymaterialox)  = 'MATERIAL_OX'

  IF (nstrkeys > nstrkeys_max) &
    CALL errorstop( global,err_exceeds_decl_mem,__line__ )

! define implementation-dependent keys

  ikeyused      = 1
  ikeymodel     = 2
  ikeyoxused    = 3
  ikeyvapormeth = 4
  ikeyvaportemp = 5
  ikeyheatcoef  = 6
  ikeymfrcplag  = 7
  nfixedimplkeys = 8

  keys(ikeyused)      = 'USED'
  keys(ikeymodel)     = 'MODEL'
  keys(ikeyoxused)    = 'OX_USED'
  keys(ikeyvapormeth) = 'VAPOR_METH'
  keys(ikeyvaportemp) = 'VAPOR_TEMP'
  keys(ikeyheatcoef)  = 'HEAT_COEF'
  keys(ikeymfrcplag)  = 'MFRC_PLAG'

  ikeymfrcpeul0 = nfixedimplkeys

#ifdef RFLO
  CALL makenumberedkeys(keys,ikeymfrcpeul0+1,'MFRC_PEUL',1,npeul_max,1)
#endif
#ifdef RFLU
  CALL makenumberedkeys(keys,ikeymfrcpeul0+1,'MFRC_SPEC',1,npeul_max,1)
#endif

! define Node keys

  ikeynode0 = ikeymfrcpeul0 + npeul_max
  ikeymixtactv = ikeynode0 + 1
  ikeymixtperm = ikeynode0 + 2
  ikeyplagactv = ikeynode0 + 3
  ikeyplagperm = ikeynode0 + 4
  nfixednodekeys = 4

  keys(ikeymixtactv) = 'MIXT_ACTV'
  keys(ikeymixtperm) = 'MIXT_PERM'
  keys(ikeyplagactv) = 'PLAG_ACTV'
  keys(ikeyplagperm) = 'PLAG_PERM'

  ikeypeulactv0 = ikeynode0 + nfixednodekeys
  ikeypeulperm0 = ikeypeulactv0 + npeul_max

#ifdef RFLO
  CALL makenumberedkeys(keys,ikeypeulactv0+1,'PEUL',1,npeul_max,1)
  CALL makenumberedkeys(keys,ikeypeulperm0+1,'PEUL',1,npeul_max,1)
#endif
#ifdef RFLU
  CALL makenumberedkeys(keys,ikeypeulactv0+1,'SPEC',1,npeul_max,1)
  CALL makenumberedkeys(keys,ikeypeulperm0+1,'SPEC',1,npeul_max,1)
#endif

  DO ipeul=1,npeul_max
    keys(ikeypeulactv0+ipeul) = trim(keys(ikeypeulactv0+ipeul))//'_ACTV'
    keys(ikeypeulperm0+ipeul) = trim(keys(ikeypeulperm0+ipeul))//'_PERM'
  END DO ! iPeul

  nkeys = ikeypeulperm0 + npeul_max

  IF (nkeys > nkeys_max) CALL errorstop( global,err_exceeds_decl_mem,__line__ )

! Read interaction section from input file

#ifdef RFLO
  CALL readbothregionsection( global,if_input,nkeys,nstrkeys,keys,strkeys, &
                              vals,strvals,brbeg,brend,defined,strdefined )
#endif
#ifdef RFLU
  CALL readbothsection( global,if_input,nkeys,nstrkeys,keys,strkeys, &
                        vals,strvals,defined,strdefined )
  brbeg = lbound(regions,1)
  brend = ubound(regions,1)
#endif

  DO ireg=brbeg,brend

    input => regions(ireg)%inrtInput
    inrt  => input%inrts(inrt_type_burning)

! - Check that INRT_DEFAULT section has been read, and that interaction has not

    IF (.NOT. input%defaultRead) &
      CALL errorstop( global,err_inrt_defunread,__line__ )

    IF (inrt%used) CALL errorstop( global,err_inrt_read,__line__ )

! - Use local variables for some useful quantities

    nplag = input%nPlag
    npeul = input%nPeul

    IF (npeul > npeul_max) &
      CALL errorstop( global,err_exceeds_decl_mem,__line__ )

    indmixt  = input%indMixt
    indplag0 = input%indPlag0
    indpeul0 = input%indPeul0
    indintl  = input%indIntl

! - Check if interaction is used

    inrt%used = .true. ! used by default when its section appears

    IF (defined(ikeyused)) THEN
      IF (nint(vals(ikeyused)) == 0) inrt%used = .false.
    END IF ! defined(iKeyUsed)

    IF (nplag < 1) inrt%used = .false. ! cannot occur without particles

    IF (.NOT. inrt%used) cycle ! do not bother with unused interactions

! - Check if oxidizer is used

    oxused = .false.

    IF (defined(ikeyoxused) .AND. npeul > 0) THEN

      SELECT CASE (nint(vals(ikeyoxused)))

      CASE (0)
        oxused = .false.

      CASE (1)
        oxused = .true.

      CASE default
        CALL errorstop( global,err_inrt_badswitch,__line__ )

      END SELECT ! vals(iKeyOxUsed)

    END IF ! defined(iKeyOxUsed)

! - Set pointers to in, out, and ox materials

    IF (strdefined(istrkeymaterialin)) THEN
      CALL inrt_setmaterial(global,matin,strvals(istrkeymaterialin))
    ELSE
      CALL errorstop( global,err_inrt_missingmat,__line__ )
    END IF ! strDefined(iStrKeyMaterialIn)

    IF (strdefined(istrkeymaterialout)) THEN
      CALL inrt_setmaterial(global,matout,strvals(istrkeymaterialout))
    ELSE
      CALL errorstop( global,err_inrt_missingmat,__line__ )
    END IF ! strDefined(iStrKeyMaterialOut)

    IF (strdefined(istrkeymaterialox)) THEN
      CALL inrt_setmaterial(global,matox,strvals(istrkeymaterialox))
    ELSE
! --- Give missing material error if oxidizer used but material undefined
      IF (oxused) CALL errorstop( global,err_inrt_missingmat,__line__ )
! --- set matOx to point to something even if it is not defined
      CALL inrt_setmaterial(global,matox,strvals(istrkeymaterialin))
    END IF ! strDefined(iStrKeyMaterialOx)

! - Define interaction (using any relevant information from input deck)

    CALL inrt_defineburning(regions(ireg),matin%index,matout%index, &
      matox%index,oxused,plagoutexists)

! - Check for switches

! - Which burning model is used

    inrt%switches(inrt_swi_burning_model) = inrt_burning_model_default

    IF (defined(ikeymodel)) THEN

      SELECT CASE (nint(vals(ikeymodel)))

      CASE (1)
        inrt%switches(inrt_swi_burning_model) = inrt_burning_model_beckstead

      CASE default
        CALL errorstop( global,err_inrt_badswitch,__line__ )

      END SELECT ! vals(iKeyModel)

    END IF ! defined(iKeyModel)

! - Whether oxidizer is used

    IF (oxused) THEN
      inrt%switches(inrt_swi_burning_oxused) = 1
      npeuloxedges = 1
    ELSE
      inrt%switches(inrt_swi_burning_oxused) = 0
      npeuloxedges = 0
    END IF ! oxUsed

! - Which Vapor Energy method is used

    inrt%switches(inrt_swi_burning_vapor_meth) = inrt_burning_vapor_meth_used

    IF (defined(ikeyvapormeth)) THEN

      SELECT CASE (nint(vals(ikeyvapormeth)))

      CASE (0)
        inrt%switches(inrt_swi_burning_vapor_meth) = &
          inrt_burning_vapor_meth_none

      CASE (1)
        inrt%switches(inrt_swi_burning_vapor_meth) = &
          inrt_burning_vapor_meth_used

      CASE default
        CALL errorstop( global,err_inrt_badswitch,__line__ )

      END SELECT ! vals(iKeyVaporMeth)

    END IF ! defined(iKeyVaporMeth)

! - Check for data

! - temperature above which to shunt burning energy to vapor

    coef = matout%Tboil

    IF (defined(ikeyvaportemp)) coef = vals(ikeyvaportemp)

    IF (coef < 0._rfreal) CALL errorstop( global,err_inrt_badval,__line__ )

    inrt%data(inrt_dat_burning_vapor_temp) = coef

! - fraction of heat actually released

    coef = 1._rfreal ! default heat release coefficient

    IF (defined(ikeyheatcoef)) coef = vals(ikeyheatcoef)

    IF (coef < 0._rfreal) CALL errorstop( global,err_inrt_badval,__line__ )

    inrt%data(inrt_dat_burning_heat_coef) = coef

! - fraction of substance produced that goes immediately back to the particle

    coef = 0._rfreal ! default mass fraction that goes back to particle

    IF (defined(ikeymfrcplag)) coef = vals(ikeymfrcplag)

    IF (.NOT. plagoutexists) coef = 0._rfreal ! no transfer to non-existent Node

    IF (coef < 0._rfreal) CALL errorstop( global,err_inrt_badval,__line__ )

    inrt%data(inrt_dat_burning_mfrc_plag) = coef

! - fraction of substance going to smoke that goes to each smoke type

    npeuloutedges = inrt%nEdges - npeuloxedges - inrt_burning_nedges0

    DO ipeuloutedge = 1,npeuloutedges ! loop over edges that output smoke

      iedge = inrt_burning_x_mass_s0 + npeuloxedges + ipeuloutedge

      ipeul = inrt%edges(iedge)%iNode(2) - indpeul0

      IF (ipeul < 1 .OR. ipeul > npeul) &
        CALL errorstop( global,err_inrt_indexrange,__line__ )

      ikey = ikeymfrcpeul0 + ipeul
      ind  = inrt_dat_burning_mfrc_peul0 + ipeuloutedge

      coef = 0._rfreal ! default mass fraction that goes to a smoke type

      IF (defined(ikey)) coef = vals(ikey)

      IF (coef < 0._rfreal) CALL errorstop( global,err_inrt_badval,__line__ )

      inrt%data(ind) = coef

    END DO ! iPeulOutEdge

! - Check for Mixture controls

    IF (defined(ikeymixtactv)) &
      CALL inrt_setactiveness(global,vals(ikeymixtactv), &
                              inrt%activeness(indmixt))

    IF (defined(ikeymixtperm)) &
      CALL inrt_setpermission(global,vals(ikeymixtperm), &
                              inrt%permission(indmixt))

! - Check for Lagrangian particle controls

    DO iplag=1,nplag+1

      ind = indplag0 + iplag

      IF (defined(ikeyplagactv)) &
        CALL inrt_setactiveness(global,vals(ikeyplagactv), &
                                inrt%activeness(ind))

      IF (defined(ikeyplagperm)) &
        CALL inrt_setpermission(global,vals(ikeyplagperm), &
                                inrt%permission(ind))

    END DO ! iPlag

! - Check for Smoke controls

    DO ipeul = 1,npeul

      ikeyactv = ikeypeulactv0 + ipeul
      ikeyperm = ikeypeulperm0 + ipeul
      ind      = indpeul0      + ipeul

      IF (defined(ikeyactv)) &
        CALL inrt_setactiveness(global,vals(ikeyactv), &
                                inrt%activeness(ind))

      IF (defined(ikeyperm)) &
        CALL inrt_setpermission(global,vals(ikeyperm), &
                                inrt%permission(ind))

    END DO ! iPeul

! - Define Activeness of Internal Node

! - For the Burning interaction, this is defined as the minimum of the
! - Activeness of the Gas and the Lagrangian particles

    inrt%activeness(indintl) = min(inrt%activeness(indmixt), &
                                   inrt%activeness(indplag0+1))

! - Determine permission Tokens

    CALL inrt_determinetokens(regions(ireg),inrt)

  END DO ! iReg

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

  CALL deregisterfunction( global )

END SUBROUTINE inrt_readburning

!******************************************************************************
!
! RCS Revision history:
!
! $Log: INRT_ReadBurning.F90,v $
! Revision 1.3  2008/12/06 08:44:31  mtcampbe
! Updated license.
!
! Revision 1.2  2008/11/19 22:17:44  mtcampbe
! Added Illinois Open Source License/Copyright
!
! Revision 1.1  2004/12/01 21:56:33  fnajjar
! Initial revision after changing case
!
! Revision 1.11  2004/07/23 22:43:16  jferry
! Integrated rocspecies into rocinteract
!
! Revision 1.10  2004/03/08 21:57:36  jferry
! better error checking for burning without smoke case
!
! Revision 1.9  2004/03/05 22:09:03  jferry
! created global variables for peul, plag, and inrt use
!
! Revision 1.8  2004/03/02 21:47:29  jferry
! Added After Update interactions
!
! Revision 1.7  2003/09/26 21:46:54  fnajjar
! Modified ModInterfaces call to ModInterfacesInteract
!
! Revision 1.6  2003/09/25 15:46:31  jferry
! removed temporary comments
!
! Revision 1.5  2003/09/19 20:35:26  jferry
! Implemented oxidizer species for burning interaction
!
! Revision 1.4  2003/04/02 22:32:04  jferry
! codified Activeness and Permission structures for rocinteract
!
! Revision 1.3  2003/03/24 23:30:52  jferry
! overhauled rocinteract to allow interaction design to use user input
!
! Revision 1.2  2003/03/11 16:09:39  jferry
! Added comments
!
! Revision 1.1  2003/03/04 22:12:35  jferry
! Initial import of Rocinteract
!
!******************************************************************************