func.f90

FDS为火灾动力学模拟软件源代码,该软件为开源项目,代码语言主要为FORTRAN,可在WINDOWS和LINUX下编译运行,详细说明可参考http://fire.nist.gov/fds/官方网址

ZZ = Z_1 + Z_2 + Z_3
WGT =MIN(ZZ*10000._EB,10000._EB)
IZ1 = FLOOR(WGT)
IZ2 = MIN(10000,IZ1+1)
WGT = WGT - IZ1

z1z2z3: IF(ZZ <= 0._EB .OR. ZZ >= 1._EB) THEN
   C = 0._EB
   F = 0._EB
   Z_F = REACTION(1)%Z_F
ELSE
   IF (Z_1==ZZ) THEN
      F = 1._EB
      C = 0._EB
      Z_F = REACTION(1)%Z_F
   ELSE
      IF (Z_2 == 0._EB) THEN
         C = 1._EB
         Z_F = REACTION(2)%Z_F
      ELSE
         C = Z_3 / (Z_3 + Z_2)
         Z_F = 1._EB/(1._EB+(1._EB - C)*REACTION(1)%Z_F_CONS + C * REACTION(2)%Z_F_CONS)
      ENDIF
      IF (ZZ < Z_F) THEN
         F = Z_1 / ZZ
      ELSE
         F = (Z_1 * (1._EB - Z_F) - ZZ + Z_F) / (Z_F * (1._EB - ZZ))      
      ENDIF      
      Z_3_MAX = (1._EB-WGT)*SPECIES(I_PROG_CO)%Z_MAX(IZ1)+ WGT*SPECIES(I_PROG_CO)%Z_MAX(IZ2)
      C = MAX(0._EB,MIN(1._EB,Z_3 / Z_3_MAX / (1._EB - F)))
   ENDIF
ENDIF z1z2z3
F = MIN(1._EB,MAX(0._EB,F))

END SUBROUTINE GET_F_C

SUBROUTINE GET_F(Z_1,Z_3,F,Z_F)
!Returns progress variables for Mixture Fraction functions for suppression only
REAL(EB), INTENT(IN) :: Z_1,Z_3,Z_F
REAL(EB), INTENT(OUT) :: F
REAL(EB) :: ZZ

ZZ = Z_1 + Z_3
IF (ZZ > Z_F) THEN
   IF (ZZ >= 1._EB) THEN
      F = 1._EB
   ELSE
      F = (Z_1 * (1._EB - Z_F) - ZZ + Z_F) / (Z_F * (1._EB - ZZ))
   ENDIF
ELSE
   IF (ZZ <= 0._EB) THEN
      F = 0._EB
   ELSE
      F = Z_1 / ZZ
   ENDIF
ENDIF
F = MIN(1._EB,MAX(0._EB,F))
   
END SUBROUTINE GET_F

SUBROUTINE GET_MASS_FRACTION2(Z1,Z2,Z3,INDEX,YY_SUM,Y_MF)
! Y_MF returns the mass fraction of species INDEX
INTEGER, INTENT(IN) :: INDEX
REAL(EB), INTENT(IN) :: Z1,Z2,Z3,YY_SUM
REAL(EB) :: Z_1,Z_2,Z_3,Y_MF,ZZ
TYPE(REACTION_TYPE), POINTER :: RN

IF (YY_SUM >=1._EB) THEN
   Y_MF = 0._EB
   RETURN
ELSE
   Z_1 = MAX(0._EB,Z1)/(1._EB - MAX(0._EB,YY_SUM))
   Z_2 = MAX(0._EB,Z2)/(1._EB - MAX(0._EB,YY_SUM))         
   Z_3 = MAX(0._EB,Z3)/(1._EB - MAX(0._EB,YY_SUM))          
   ZZ  = Z_1 + Z_2 + Z_3
ENDIF

IF (CO_PRODUCTION) THEN
   RN => REACTION(2)
ELSE
   RN => REACTION(1)
ENDIF

SELECT CASE(INDEX)
   CASE(FUEL_INDEX)
      Y_MF = Z_1 * RN%Y_F_INLET
   CASE(N2_INDEX)
      Y_MF = (1._EB - ZZ) * RN%Y_N2_INFTY + Z_1 * RN%Y_N2_INLET + (Z_2 + Z_3) * RN%Y_F_INLET / RN%MW_FUEL * MW_N2 * RN%NU_N2
   CASE(O2_INDEX)
      Y_MF = (1._EB - ZZ) * RN%Y_O2_INFTY - Z_3 * RN%Y_F_INLET / RN%MW_FUEL * MW_O2 * RN%NU_O2
      IF (CO_PRODUCTION) Y_MF = Y_MF - Z_2 * RN%Y_F_INLET / RN%MW_FUEL * MW_O2 * REACTION(1)%NU_O2
   CASE(CO_INDEX)
      IF (CO_PRODUCTION) THEN
         Y_MF = Z_2 * RN%Y_F_INLET / RN%MW_FUEL * MW_CO * REACTION(1)%NU_CO
      ELSE
         Y_MF = Z_3 * RN%Y_F_INLET / RN%MW_FUEL * MW_CO * RN%NU_CO
      ENDIF
   CASE(CO2_INDEX)
      Y_MF = Z_3 * RN%Y_F_INLET / RN%MW_FUEL * MW_CO2 * RN%NU_CO2
   CASE(H2O_INDEX)
      Y_MF = (Z_2 + Z_3) * RN%Y_F_INLET / RN%MW_FUEL * MW_H2O * RN%NU_H2O
   CASE(H2_INDEX)
      Y_MF = (Z_2 + Z_3) * RN%Y_F_INLET / RN%MW_FUEL * MW_H2 * RN%NU_H2  
   CASE(SOOT_INDEX)
      Y_MF = (Z_2 + Z_3) * RN%Y_F_INLET / RN%MW_FUEL * MW_SOOT * RN%NU_SOOT
   CASE(OTHER_INDEX)
      Y_MF = (Z_2 + Z_3) * RN%Y_F_INLET / RN%MW_FUEL * RN%MW_OTHER * RN%NU_OTHER
END SELECT

Y_MF = MIN(1._EB,MAX(0._EB,Y_MF)) * (1._EB - MAX(YY_SUM,0._EB))

END SUBROUTINE GET_MASS_FRACTION2

SUBROUTINE GET_MASS_FRACTION_ALL(Z1,Z2,Z3,YY_SUM,Y_MF)
! Y_MF returns the mass fraction of all mixture fraction species
REAL(EB), INTENT(IN) :: Z1,Z2,Z3,YY_SUM
REAL(EB) :: ZZ,Z_1,Z_2,Z_3,Y_MF(9)
TYPE(REACTION_TYPE), POINTER :: RN

IF (YY_SUM >=1._EB) THEN
   Y_MF = 0._EB
   RETURN
ELSE
   Z_1 = MAX(0._EB,Z1)/(1._EB - MAX(0._EB,YY_SUM))
   Z_2 = MAX(0._EB,Z2)/(1._EB - MAX(0._EB,YY_SUM))         
   Z_3 = MAX(0._EB,Z3)/(1._EB - MAX(0._EB,YY_SUM))          
   ZZ = Z_1 + Z_2 + Z_3
ENDIF

IF (CO_PRODUCTION) THEN
   RN => REACTION(2)
ELSE
   RN => REACTION(1)
ENDIF

Y_MF(FUEL_INDEX) = Z_1 * RN%Y_F_INLET

Y_MF(N2_INDEX) = (1._EB - ZZ) * RN%Y_N2_INFTY + Z_1 * RN%Y_N2_INLET + (Z_2 + Z_3) * RN%Y_F_INLET / RN%MW_FUEL * MW_N2 * RN%NU_N2

Y_MF(O2_INDEX) = (1._EB - ZZ) * RN%Y_O2_INFTY - Z_3 * RN%Y_F_INLET / RN%MW_FUEL * MW_O2 * RN%NU_O2
IF (CO_PRODUCTION) Y_MF(O2_INDEX) = Y_MF(O2_INDEX) - Z_2 * RN%Y_F_INLET / RN%MW_FUEL * MW_O2 * REACTION(1)%NU_O2

IF (CO_PRODUCTION) THEN
   Y_MF(CO_INDEX) = Z_2 * RN%Y_F_INLET / RN%MW_FUEL * MW_CO * REACTION(1)%NU_CO
ELSE
   Y_MF(CO_INDEX) = Z_3 * RN%Y_F_INLET / RN%MW_FUEL * MW_CO * RN%NU_CO
ENDIF

Y_MF(CO2_INDEX) = Z_3 * RN%Y_F_INLET / RN%MW_FUEL * MW_CO2 * RN%NU_CO2

Y_MF(H2O_INDEX) = (Z_2 + Z_3) * RN%Y_F_INLET / RN%MW_FUEL * MW_H2O * RN%NU_H2O

Y_MF(H2_INDEX) = (Z_2 + Z_3) * RN%Y_F_INLET / RN%MW_FUEL * MW_H2 * RN%NU_H2  

Y_MF(SOOT_INDEX) = (Z_2 + Z_3) * RN%Y_F_INLET / RN%MW_FUEL * MW_SOOT * RN%NU_SOOT

Y_MF(OTHER_INDEX) = (Z_2 + Z_3) * RN%Y_F_INLET / RN%MW_FUEL * RN%MW_OTHER * RN%NU_OTHER

Y_MF = MIN(1._EB,MAX(0._EB,Y_MF)) * (1._EB - MAX(YY_SUM,0._EB))

END SUBROUTINE GET_MASS_FRACTION_ALL

SUBROUTINE GET_MOLECULAR_WEIGHT2(Z1,Z2,Z3,YY_SUM, MW_MF)
! Y_MF returns the mass fraction of species INDEX
REAL(EB), INTENT(IN) :: Z1,Z2,Z3,YY_SUM
REAL(EB) :: Z_1,Z_2,Z_3,MW_MF,Y_MF(9)
TYPE(REACTION_TYPE), POINTER :: RN

IF (YY_SUM >=1._EB) THEN
   MW_MF = MW_AIR
   RETURN
ELSE
   Z_1 = MAX(0._EB,Z1)/(1._EB - MAX(0._EB,YY_SUM))
   Z_2 = MAX(0._EB,Z2)/(1._EB - MAX(0._EB,YY_SUM))         
   Z_3 = MAX(0._EB,Z3)/(1._EB - MAX(0._EB,YY_SUM))          
ENDIF

CALL GET_MASS_FRACTION_ALL(Z_1,Z_2,Z_3,0._EB,Y_MF)
RN => REACTION(1)

MW_MF = 1._EB/(Y_MF(FUEL_INDEX)/RN%MW_FUEL + Y_MF(O2_INDEX)/MW_O2     + Y_MF(N2_INDEX)/MW_N2   + &
               Y_MF(H2O_INDEX)/MW_H2O      + Y_MF(CO2_INDEX)/MW_CO2   + Y_MF(CO_INDEX)/MW_CO   + &
               Y_MF(H2_INDEX)/MW_H2        + Y_MF(SOOT_INDEX)/MW_SOOT + Y_MF(OTHER_INDEX)/RN%MW_OTHER)

END SUBROUTINE GET_MOLECULAR_WEIGHT2

SUBROUTINE GET_MU2(Z1,Z2,Z3,YY_SUM,MU_MF,ITMP)
! GET_MU returns the viscosity of the mixture fraction
INTEGER, INTENT(IN) :: ITMP
REAL(EB), INTENT(IN) :: Z1,Z2,Z3,YY_SUM
REAL(EB) :: Z_1,Z_2,Z_3,MU_MF,Y_MF(9),MW_MF
TYPE(SPECIES_TYPE), POINTER :: SS
TYPE(REACTION_TYPE), POINTER :: RN

IF (YY_SUM >=1._EB) THEN
   MU_MF = SPECIES(0)%MU(ITMP)
   RETURN
ELSE
   Z_1 = MAX(0._EB,Z1)/(1._EB - MAX(0._EB,YY_SUM))
   Z_2 = MAX(0._EB,Z2)/(1._EB - MAX(0._EB,YY_SUM))         
   Z_3 = MAX(0._EB,Z3)/(1._EB - MAX(0._EB,YY_SUM))          
ENDIF
CALL GET_MASS_FRACTION_ALL(Z_1,Z_2,Z_3,0._EB,Y_MF)

SS => SPECIES(I_FUEL)
RN => REACTION(1)

MW_MF = 1._EB/(Y_MF(FUEL_INDEX)/RN%MW_FUEL + Y_MF(O2_INDEX)/MW_O2     + Y_MF(N2_INDEX)/MW_N2   + &
        Y_MF(H2O_INDEX)/MW_H2O      + Y_MF(CO2_INDEX)/MW_CO2   + Y_MF(CO_INDEX)/MW_CO   + &
        Y_MF(H2_INDEX)/MW_H2        + Y_MF(SOOT_INDEX)/MW_SOOT + Y_MF(OTHER_INDEX)/RN%MW_OTHER)

MU_MF = (Y_MF(FUEL_INDEX)*SS%MU_MF2(FUEL_INDEX,ITMP)/RN%MW_FUEL + Y_MF(O2_INDEX)*SS%MU_MF2(O2_INDEX,ITMP)/MW_O2 + &
         Y_MF(N2_INDEX)*SS%MU_MF2(N2_INDEX,ITMP)/MW_N2          + Y_MF(H2O_INDEX)*SS%MU_MF2(H2O_INDEX,ITMP)/MW_H2O + & 
         Y_MF(CO2_INDEX)*SS%MU_MF2(CO2_INDEX,ITMP)/MW_CO2       + Y_MF(CO_INDEX)*SS%MU_MF2(CO_INDEX,ITMP)/MW_CO   + &
         Y_MF(H2_INDEX)*SS%MU_MF2(H2_INDEX,ITMP)/MW_H2          + Y_MF(SOOT_INDEX)*SS%MU_MF2(SOOT_INDEX,ITMP)/MW_SOOT + &
         Y_MF(OTHER_INDEX)*SS%MU_MF2(OTHER_INDEX,ITMP)/RN%MW_OTHER) * MW_MF

END SUBROUTINE GET_MU2

SUBROUTINE GET_D2(Z1,Z2,Z3,YY_SUM,D_MF,ITMP)
! GET_D returns the diffusivity of the mixture fraction
INTEGER, INTENT(IN) :: ITMP
REAL(EB), INTENT(IN) :: Z1,Z2,Z3,YY_SUM
REAL(EB) :: Z_1,Z_2,Z_3,D_MF,Y_MF(9)
TYPE(SPECIES_TYPE), POINTER :: SS

IF (YY_SUM >=1._EB) THEN
   D_MF = SPECIES(0)%D(ITMP)
   RETURN
ELSE
   Z_1 = MAX(0._EB,Z1)/(1._EB - MAX(0._EB,YY_SUM))
   Z_2 = MAX(0._EB,Z2)/(1._EB - MAX(0._EB,YY_SUM))         
   Z_3 = MAX(0._EB,Z3)/(1._EB - MAX(0._EB,YY_SUM))          
ENDIF

CALL GET_MASS_FRACTION_ALL(Z_1,Z_2,Z_3,0._EB,Y_MF)
SS => SPECIES(I_FUEL)

D_MF = DOT_PRODUCT(Y_MF,SS%D_MF2(:,ITMP))

END SUBROUTINE GET_D2

SUBROUTINE GET_CP2(Z1,Z2,Z3,YY_SUM,CP_MF,ITMP)
! GET_D returns the specific heat of the mixture fraction
INTEGER, INTENT(IN) :: ITMP
REAL(EB), INTENT(IN) :: Z1,Z2,Z3,YY_SUM
REAL(EB) :: Z_1,Z_2,Z_3,CP_MF,Y_MF(9)
TYPE(SPECIES_TYPE), POINTER :: SS

IF (YY_SUM >=1._EB) THEN
   CP_MF = SPECIES(0)%CP(ITMP)
   RETURN
ELSE
   Z_1 = MAX(0._EB,Z1)/(1._EB - MAX(0._EB,YY_SUM))
   Z_2 = MAX(0._EB,Z2)/(1._EB - MAX(0._EB,YY_SUM))         
   Z_3 = MAX(0._EB,Z3)/(1._EB - MAX(0._EB,YY_SUM))          
ENDIF

CALL GET_MASS_FRACTION_ALL(Z_1,Z_2,Z_3,0._EB,Y_MF)
SS => SPECIES(I_FUEL)

CP_MF = DOT_PRODUCT(Y_MF,SS%CP_MF2(:,ITMP))

END SUBROUTINE GET_CP2

SUBROUTINE GET_K2(Z1,Z2,Z3,YY_SUM,K_MF,ITMP)
! GET_D returns the specific heat of the mixture fraction
INTEGER, INTENT(IN) :: ITMP
REAL(EB), INTENT(IN) :: Z1,Z2,Z3,YY_SUM
REAL(EB) :: Z_1,Z_2,Z_3,K_MF,Y_MF(9),MW_MF
TYPE(SPECIES_TYPE), POINTER :: SS
TYPE(REACTION_TYPE), POINTER :: RN

IF (YY_SUM >=1._EB) THEN
   K_MF = SPECIES(0)%K(ITMP)
   RETURN
ELSE
   Z_1 = MAX(0._EB,Z1)/(1._EB - MAX(0._EB,YY_SUM))
   Z_2 = MAX(0._EB,Z2)/(1._EB - MAX(0._EB,YY_SUM))         
   Z_3 = MAX(0._EB,Z3)/(1._EB - MAX(0._EB,YY_SUM))          
ENDIF

CALL GET_MASS_FRACTION_ALL(Z_1,Z_2,Z_3,0._EB,Y_MF)
SS => SPECIES(I_FUEL)
RN => REACTION(1)

MW_MF = 1._EB/(Y_MF(FUEL_INDEX)/RN%MW_FUEL + Y_MF(O2_INDEX)/MW_O2     + Y_MF(N2_INDEX)/MW_N2   + &
        Y_MF(H2O_INDEX)/MW_H2O      + Y_MF(CO2_INDEX)/MW_CO2   + Y_MF(CO_INDEX)/MW_CO   + &
        Y_MF(H2_INDEX)/MW_H2        + Y_MF(SOOT_INDEX)/MW_SOOT + Y_MF(OTHER_INDEX)/RN%MW_OTHER)

K_MF = (Y_MF(FUEL_INDEX)*SS%K_MF2(FUEL_INDEX,ITMP)/RN%MW_FUEL + Y_MF(O2_INDEX)*SS%K_MF2(O2_INDEX,ITMP)/MW_O2 + &
        Y_MF(N2_INDEX)*SS%K_MF2(N2_INDEX,ITMP)/MW_N2          + Y_MF(H2O_INDEX)*SS%K_MF2(H2O_INDEX,ITMP)/MW_H2O + & 
        Y_MF(CO2_INDEX)*SS%K_MF2(CO2_INDEX,ITMP)/MW_CO2       + Y_MF(CO_INDEX)*SS%K_MF2(CO_INDEX,ITMP)/MW_CO   + &
        Y_MF(H2_INDEX)*SS%K_MF2(H2_INDEX,ITMP)/MW_H2          + Y_MF(SOOT_INDEX)*SS%K_MF2(SOOT_INDEX,ITMP)/MW_SOOT + &
        Y_MF(OTHER_INDEX)*SS%K_MF2(OTHER_INDEX,ITMP)/RN%MW_OTHER) * MW_MF

END SUBROUTINE GET_K2

REAL(EB) FUNCTION DRAG(RE)
 
! Droplet drag coefficient

REAL(EB) :: RE
 
IF (RE<=1._EB) THEN
   DRAG = 24._EB/RE
ELSEIF (RE>1._EB .AND. RE<1000._EB) THEN
   DRAG = 24._EB*(1._EB+0.15_EB*RE**0.687_EB)/RE
ELSEIF (RE>=1000._EB) THEN
   DRAG = 0.44_EB
ENDIF
 
END FUNCTION DRAG


SUBROUTINE DROPLET_SIZE_DISTRIBUTION(DM,RR,CNF,NPT,GAMMA,SIGMA)
 
! Compute droplet Cumulative Number Fraction (CNF)
 
REAL(EB), INTENT(IN) :: DM,GAMMA,SIGMA
INTEGER, INTENT(IN) :: NPT
REAL(EB) :: SUM1,DD1,DI,ETRM,GFAC,SFAC
INTEGER  :: J
REAL(EB), INTENT(OUT) :: RR(0:NPT),CNF(0:NPT)
 
RR(0)  = 0._EB
CNF(0) = 0._EB
SUM1   = 0._EB
DD1    = (-LOG(1._EB-0.99_EB)/0.693_EB)**(1._EB/GAMMA)*DM/REAL(NPT,EB)
GFAC   = 0.693_EB*GAMMA*DD1/(DM**GAMMA)
SFAC   = DD1/(SQRT(TWOPI)*SIGMA)
 
INTLOOP: DO J=1,NPT
   DI = (J-.5_EB)*DD1
   RR(J) = .5_EB*DI
   IF (DI<=DM) THEN
      ETRM = EXP(-(LOG(DI/DM))**2/(2._EB*SIGMA**2))
      SUM1 = SUM1 + (SFAC/DI**4)*ETRM
   ELSE
      ETRM = EXP(-0.693_EB*(DI/DM)**GAMMA)
      SUM1 = SUM1 + GFAC*DI**(GAMMA-4._EB)*ETRM
   ENDIF
   CNF(J) = SUM1
ENDDO INTLOOP
 
CNF = CNF/SUM1
 
END SUBROUTINE DROPLET_SIZE_DISTRIBUTION


END MODULE PHYSICAL_FUNCTIONS



 
MODULE MATH_FUNCTIONS

USE PRECISION_PARAMETERS
IMPLICIT NONE 
 
CONTAINS
 
REAL(EB) FUNCTION AFILL(A111,A211,A121,A221,A112,A212,A122,A222,P,R,S)
! Linear interpolation function
REAL(EB) :: A111,A211,A121,A221,A112,A212,A122,A222,P,R,S,PP,RR,SS
PP = 1._EB-P
RR = 1._EB-R
SS = 1._EB-S
AFILL = ((PP*A111+P*A211)*RR+(PP*A121+P*A221)*R)*SS+((PP*A112+P*A212)*RR+(PP*A122+P*A222)*R)*S
END FUNCTION AFILL
 

REAL(EB) FUNCTION AFILL2(A,I,J,K,P,R,S)
! Linear interpolation function. Same as AFILL, only it reads in entire array.
REAL(EB), INTENT(IN), DIMENSION(0:,0:,0:) :: A
INTEGER, INTENT(IN) :: I,J,K
REAL(EB) A111,A211,A121,A221,A112,A212,A122,A222,P,R,S,PP,RR,SS
A111 = A(I,J,K)
A211 = A(I+1,J,K)
A121 = A(I,J+1,K)
A221 = A(I+1,J+1,K)
A112 = A(I,J,K+1)
A212 = A(I+1,J,K+1)
A122 = A(I,J+1,K+1)
A222 = A(I+1,J+1,K+1)
PP = 1._EB-P
RR = 1._EB-R
SS = 1._EB-S
AFILL2 = ((PP*A111+P*A211)*RR+(PP*A121+P*A221)*R)*SS+ ((PP*A112+P*A212)*RR+(PP*A122+P*A222)*R)*S
END FUNCTION AFILL2
 

REAL(EB) FUNCTION POLYVAL(N,TEMP,COEF)
! Calculate the value of polynomial function.
INTEGER N,I
REAL(EB) TEMP, COEF(N), VAL
VAL = 0._EB
DO I=1,N
   VAL  = VAL  + COEF(I)*TEMP**(I-1)
ENDDO
POLYVAL = VAL
END FUNCTION POLYVAL
 
 
SUBROUTINE GET_RAMP_INDEX(ID,TYPE,RAMP_INDEX)
USE GLOBAL_CONSTANTS, ONLY: N_RAMP,RAMP_ID,RAMP_TYPE
CHARACTER(*), INTENT(IN) :: ID,TYPE
INTEGER, INTENT(OUT) :: RAMP_INDEX
INTEGER :: NR
 
IF (ID=='null') THEN
   RAMP_INDEX = 0
   RETURN
ENDIF
 
SEARCH: DO NR=1,N_RAMP
   IF (ID==RAMP_ID(NR)) THEN
      RAMP_INDEX = NR
      RETURN
   ENDIF
ENDDO SEARCH
 
N_RAMP                = N_RAMP + 1
RAMP_INDEX            = N_RAMP
RAMP_ID(RAMP_INDEX)   = ID
RAMP_TYPE(RAMP_INDEX) = TYPE
END SUBROUTINE GET_RAMP_INDEX

SUBROUTINE GET_TABLE_INDEX(ID,TYPE,TABLE_INDEX)
USE GLOBAL_CONSTANTS, ONLY: N_TABLE,TABLE_ID,TABLE_TYPE
CHARACTER(*), INTENT(IN) :: ID
INTEGER, INTENT(IN) :: TYPE
INTEGER, INTENT(OUT) :: TABLE_INDEX
INTEGER :: NT
 
IF (ID=='null') THEN
   TABLE_INDEX = 0
   RETURN
ENDIF
 
SEARCH: DO NT=1,N_TABLE
   IF (ID==TABLE_ID(NT)) THEN
      TABLE_INDEX = NT
      RETURN
   ENDIF
ENDDO SEARCH
 
N_TABLE                = N_TABLE + 1
TABLE_INDEX            = N_TABLE
TABLE_ID(TABLE_INDEX)   = ID
TABLE_TYPE(TABLE_INDEX) = TYPE

END SUBROUTINE GET_TABLE_INDEX

REAL(EB) FUNCTION EVALUATE_RAMP(RAMP_INPUT,TAU,RAMP_INDEX)
USE TYPES, ONLY: RAMPS
USE DEVICE_VARIABLES, ONLY: DEVICE
USE CONTROL_VARIABLES, ONLY:CONTROL

! General time ramp up