inputParam.F90

Go to the documentation of this file.

module inputdiscretization
    !
    !       Input parameters which are related to the discretization of
    !       the governing equations, i.e. scheme parameters, time accuracy
    !       (in case of an unsteady computation) and preconditioning info.
    !
    use constants, only: inttype, realtype
    implicit none
    save
    !
    !       Definition of the discretization input parameters.
    !
    ! spaceDiscr:             Fine grid discretization.
    ! spaceDiscrCoarse:       Coarse grid discretization.
    ! orderTurb:              Order of the discretization of the advective
    !                         terms of the turbulent transport equations.
    !                         Possibilities are 1st and 2nd order.
    ! riemann:                Fine grid riemann solver, upwind schemes only.
    ! riemannCoarse:          Idem, but on the coarse grids.
    ! limiter:                Limiter, upwind schemes only.
    ! precond:                Preconditioner.
    ! eulerWallBCTreatment:   Wall boundary condition treatment for inviscid
    !                         simulations.
    ! viscWallBCTreatment:    Wall boundary condition treatment for viscous
    !                         simulations.
    ! outflowTreatment:       Treatment of the outflow boundaries. Either
    !                         constantExtrapol or linExtrapol.
    ! nonMatchTreatment:      Treatment of the non-matching block
    !                         boundaries. Either NonConservative or
    !                         Conservative.
    ! vis2:                   Coefficient of the second order dissipation.
    ! vis4:                   Coefficient of the fourth order dissipation.
    ! vis2Coarse:             Coefficient of the second order dissipation
    !                         on the coarser grids in the mg cycle. On the
    !                         coarser grids a first order scheme is used.
    ! adis:                   Exponent for directional scaling of the
    !                         dissipation. adis == 0: no directional scaling,
    !                                      adis == 1: isotropic dissipation.
    ! kappaCoef:              Coefficient in the upwind reconstruction
    !                         schemes, both linear and nonlinear.
    ! vortexCorr:             Whether or not a vortex correction must be
    !                         applied. Steady flow only.
    ! dirScaling:             Whether or not directional scaling must be
    !                         applied.
    ! hScalingInlet:          Whether or not the outgoing Riemann invariant
    !                         must be scaled for a subsonic inlet. May be
    !                         needed for stability when strong total
    !                         temperature gradients are present.
    ! radiiNeededFine:        Whether or not the spectral radii are needed
    !                         to compute the fluxes of the fine grid.
    ! radiiNeededCoarse:      Idem for the coarse grid.
    ! lumpedDiss :            logical factor for determining whether or not
    !                         lumped dissipation is used for preconditioner
    ! approxSA:               Determines if the approximate source terms form
    !                         the SA model is used.
    ! sigma      :            Scaling parameter for dissipation lumping in
    !                         approximateprecondtioner
    ! useApproxWallDistance : logical to determine if the user wants to
    !                         use the fast approximate wall distance
    !                         computations. Typically only used for
    !                         repeated calls when the wall distance would
    !                         not have changed significantly
    ! updateWallAssociations: Logical to determine if the full wall distance
    !                         assocation is to be performed on the next
    !                         wall distance calculation. This is only
    !                         significant when useApproxWallDistance is
    !                         set to True. This allows the user to
    !                         reassociate the face a cell is associated
    !                         with.
    ! lowspeedpreconditoner:  Whether or not to use low-speed precondioner
 
    integer(kind=intType) :: spacediscr, spacediscrcoarse
    integer(kind=intType) :: orderturb, limiter
    integer(kind=intType) :: riemann, riemanncoarse, precond
    integer(kind=intType) :: eulerwallbctreatment, viscwallbctreatment, outflowtreatment
    integer(kind=intType) :: nonmatchtreatment
 
    real(kind=realtype) :: vis2, vis4, vis2coarse, adis
    real(kind=realtype) :: acousticscalefactor
    real(kind=realtype) :: kappacoef
    logical :: lumpeddiss
    logical :: approxsa
    real(kind=realtype) :: sigma
    logical :: useblockettes
 
#ifndef USE_TAPENADE
    real(kind=realtype) :: vis2b, vis4b, vis2coarseb, adisb
    real(kind=realtype) :: kappacoefb
    real(kind=realtype) :: sigmab
#endif
    logical :: vortexcorr, dirscaling, hscalinginlet
    logical :: radiineededfine, radiineededcoarse
 
    logical :: useapproxwalldistance
    logical :: updatewallassociations
    logical :: lowspeedpreconditioner
end module inputdiscretization
 
!      ==================================================================
 
module inputio
    !
    !       Input parameters which are related to io issues, like file
    !       names and corresponding info.
    !
    use constants
    implicit none
    save
    !
    !       Definition of the IO input parameters.
    !
    ! paramFile:           Parameter file, command line argument.
    ! firstWrite:          Whether or not this is the first time a
    !                      solution is written. Needed when different
    !                      file formats are used for reading and
    !                      writing.
    ! gridFile:            Grid file.
    ! newGridFile:         File to which the changed grid is
    !                      written. Needed for moving and/or
    !                      deforming geometries.
    ! restartFiles:        Restart solution files; for cgns this
    !                      could be the same as the grid file, but
    !                      not necesarrily.
    ! solFile:             Solution file; for cgns this could be the
    !                      same as the grid or restart file, but not
    !                      necesarrily.
    ! surfaceSolFile:      Surface solution file.
    ! sliceSolFile:        File name of a slice of a surface solution. TEMPORARY
    ! liftDistributionFile:File name of a lift file. TEMPORARY
    ! cpFile:              File which contains the curve fits for cp.
    ! precisionGrid:       Precision of the grid file to be written.
    !                      Possibilities are precisionSingle and
    !                      precisionDouble.
    ! precisionSol:        Idem for the solution file(s).
 
    ! precisionSurfGrid:   Precision of the grid in the surface file
    ! precisionSurfSol:    Precision of the solution in the surface file
    ! storeRindLayer:      Whether or not to store 1 layer of rind
    !                      (halo) cells in the solution file.
    ! checkRestartSol:     Whether or not the solution in the restart
    !                      file must be checked for correct
    !                      nondimensionalization.
    ! autoParameterUpdate: Whether or not the parameter file must be
    !                      updated automatically. After a restart file
    !                      is written, such that a restart can be made
    !                      without editing the parameter file.
    ! writeCoorMeter:      Whether or not the coordinates in the
    !                      solution files must be written in meters.
    !                      If not, the original units are used.
    ! storeConvInnerIter:  Whether or not to store the convergence of
    !                      the inner iterations for unsteady mode.
    !                      On systems with a limited amount of memory
    !                      the storage of this info could be a
    !                      bottleneck for memory.
 
    integer(kind=intType) :: precisiongrid, precisionsol
    integer(kind=intType) :: precisionsurfgrid, precisionsurfsol
    character(len=maxStringLen) :: paramfile, gridfile
    character(len=maxStringLen) :: newgridfile
    character(len=maxStringLen) :: solfile
    character(len=maxstringlen), dimension(:), allocatable :: restartfiles
    character(len=maxStringLen) :: surfacesolfile, cpfile, slicesolfile, liftdistributionfile
 
    logical :: storerindlayer, checkrestartsol
    logical :: autoparameterupdate, writecoormeter
    logical :: storeconvinneriter
    logical :: firstwrite = .true.
    logical :: viscoussurfacevelocities = .true.
 
    ! Extra file names (set from python) that specify the name of
    ! the volume, surface, lift and slice files written from an
    ! interrupt.
    character(len=maxStringLen) :: forcedsurfacefile, forcedvolumefile
    character(len=maxStringLen) :: forcedliftfile, forcedslicefile
    character(len=maxStringLen) :: convsolfilebasename
    ! logical to control the us of the transition model
    logical :: laminartoturbulent
 
end module inputio
 
!      ==================================================================
 
module inputiteration
    !
    !       Input parameters which are related to the iteration process,
    !       i.e. multigrid parameters, cfl numbers, smoothers and
    !       convergence.
    !
    use constants
    implicit none
    save
    !
    !       Definition of the iteration input parameters.
    !
    ! nCycles:          Maximum number of multigrid cycles.
    ! nCyclesCoarse:    Idem, but on the coarse grids in full multigrid.
    ! nSaveVolume:      Number of fine grid cycles after which a volume
    !                   solution file is written.
    ! nSaveSurface:     Number of fine grid cycles after which a
    !                   surface solution file is written.
    ! nsgStartup:       Number of single grid iterations, before
    !                   switching to multigrid. Could be useful for
    !                   supersonic problems with strong shocks.
    ! nSubIterTurb:     Number of turbulent subiterations when using
    !                   a decoupled approach for the turbulence.
    ! nUpdateBleeds:    Number of iterations after which the bleed
    !                   boundary conditions must be updated.
    ! smoother:         Smoother to be used.
    ! nRKStages:        Number of stages in the runge kutta scheme.
    ! nSubiterations:   Maximum number of subiterations used in
    !                   DADI.
    ! turbTreatment:    Treatment of the turbulent transport equations;
    !                   either decoupled or coupled.
    ! turbSmoother:     Smoother to use in case a decoupled solver
    !                   is to be used.
    ! turbRelax:        What kind of turbulent relaxation to use.
    !                   Either turbRelaxExplicit or
    !                   turbRelaxImplicit.
    ! resAveraging:     What kind of residual averaging to use.
    ! freezeTurbSource: Whether or not the turbulent source terms must
    !                   be frozen on the coarser grid levels; only if
    !                   a coupled solver is to be used.
    ! mgBoundCorr:      Treatment of the boundary halo's for the
    !                   multigrid corrections. Either dirichlet0,
    !                   set the corrections to zero, or neumann.
    ! mgStartlevel:     Grid level on which the multigrid must be
    !                   started in the full mg cycle. In case a restart
    !                   is specified this info is overruled and the
    !                   start level is the finest grid.
    ! nMGSteps:         Number of steps in the array cycleStrategy.
    ! nMGLevels:        Number of levels in the multigrid. This info
    !                   is derived from the cycle strategy.
    ! cycleStrategy:    Array which describes the mg cycle.
    ! cfl:              Cfl number on the fine grid.
    ! cflCoarse:        Idem, but on the coarse grids.
    ! cfllimit          Limit used to determine how much residuals are smoothed
    ! alfaTurb:         Relaxation factor in turbulent dd-adi smoother.
    ! betaTurb:         Relaxation factor in vf dd-adi smoother.
    ! relaxBleeds:      Relaxation coefficient for the update
    !                   of the bleed boundary condition.
    ! smoop:            Coefficient in the implicit smoothing.
    ! fcoll:            Relaxation factor for the restricted residuals.
    ! L2Conv:           Relative L2 norm of the density residuals for
    !                   which the computation is assumed converged.
    ! L2ConvCoarse:     Idem, but on the coarse grids during full mg.
    ! etaRk:            Coefficients in the runge kutta scheme. The
    !                   values depend on the number of stages specified.
    ! cdisRk:           Dissipative coefficients in the runge kutta
    !                   scheme. The values depend on the number of
    !                   stages specified.
    ! printIterations:  If True, iterations are printed to stdout
    ! turbresscale:     Scaling factor for turbulent residual. Necessary for
    !                   NKsolver with RANS. Only tested on SA.
    ! meshMaxSkewness   If one cell has a highe skewness than this, the Solver
    !                   errors out.
    ! iterType : String used for specifying which type of iteration was taken
    !
    ! Definition of the string, which stores the multigrid cycling
    ! strategy.
    !
 
    integer(kind=intType) :: ncycles, ncyclescoarse
    integer(kind=intType) :: nsavevolume, nsavesurface
    integer(kind=intType) :: nsgstartup, smoother, nrkstages
    integer(kind=intType) :: nsubiterations
    integer(kind=intType) :: nsubiterturb, nupdatebleeds
    integer(kind=intType) :: resaveraging
    real(kind=realtype) :: cfllimit
    integer(kind=intType) :: turbtreatment, turbsmoother, turbrelax
    integer(kind=intType) :: mgboundcorr, mgstartlevel
    integer(kind=intType) :: nmgsteps, nmglevels
    real(kind=realtype) :: timelimit
    integer(kind=intType), allocatable, dimension(:) :: cyclestrategy
    integer(kind=intType) :: miniternum
    real(kind=realtype) :: cfl, cflcoarse, fcoll, smoop
    real(kind=realtype) :: alfaturb, betaturb
    real(kind=realtype) :: l2conv, l2convcoarse
    real(kind=realtype) :: l2convrel
    real(kind=realtype) :: maxl2deviationfactor
    real(kind=realtype) :: relaxbleeds
    real(kind=realtype) :: epscoefconv
    integer(kind=inttype) :: convcheckwindowsize
    real(kind=realtype), allocatable, dimension(:) :: etark, cdisrk
    character(len=maxStringLen) :: mgdescription
    logical :: rkreset
    logical :: uselinresmonitor
    logical :: freezeturbsource
    logical :: printiterations
    logical :: printwarnings
    logical :: printnegativevolumes
    logical :: printbadlyskewedcells
    logical :: printbcwarnings
    real(kind=realtype), dimension(4) :: turbresscale
    real(kind=realtype) :: meshmaxskewness
    logical :: useskewnesscheck
    logical :: usedisscontinuation
    real(kind=realtype) :: disscontmagnitude, disscontmidpoint, disscontsharpness
 
end module inputiteration
 
module inputcostfunctions
    use constants
    logical :: computesepsensorks
    real(kind=realtype) :: sepsensoroffset
    real(kind=realtype) :: sepsensorksoffset
    real(kind=realtype) :: sepsensorksphi
    real(kind=realtype) :: sepsensorsharpness
    real(kind=realtype) :: sepsensorkssharpness
    real(kind=realtype) :: cavsensoroffset
    real(kind=realtype) :: cavsensorsharpness
    integer(kind=inttype) :: cavexponent
    logical :: computecavitation
 
end module inputcostfunctions
 
!      ==================================================================
 
module inputmotion
    !
    !       Input parameters which are related to the rigid body motion of
    !       the entire mesh, i.e. translation and rotation.
    !       These parameters can only be specified for an external flow
    !       computation.
    !
    use precision
    implicit none
    save
    ! rotPoint(3): Rotation point of the rigid body rotation.
 
    real(kind=realtype), dimension(3) :: rotpoint
    real(kind=realtype), dimension(3) :: rotpointd
 
    ! degreePolXRot: Degree of the x-rotation polynomial.
    ! degreePolYRot: Degree of the y-rotation polynomial.
    ! degreePolZRot: Degree of the z-rotation polynomial.
 
    integer(kind=intType) :: degreepolxrot
    integer(kind=intType) :: degreepolyrot
    integer(kind=intType) :: degreepolzrot
 
    ! coefPolXRot(0:): coefficients of the x-rotation polynomial.
    ! coefPolYRot(0:): coefficients of the y-rotation polynomial.
    ! coefPolZRot(0:): coefficients of the z-rotation polynomial.
 
    real(kind=realtype), dimension(:), allocatable :: coefpolxrot
    real(kind=realtype), dimension(:), allocatable :: coefpolyrot
    real(kind=realtype), dimension(:), allocatable :: coefpolzrot
 
    ! degreeFourXRot: Degree of the x-rotation fourier series.
    ! degreeFourYRot: Degree of the y-rotation fourier series.
    ! degreeFourZRot: Degree of the z-rotation fourier series.
 
    integer(kind=intType) :: degreefourxrot
    integer(kind=intType) :: degreefouryrot
    integer(kind=intType) :: degreefourzrot
 
    ! omegaFourXRot: Fourier frequency of the x-rotation; the
    !                   period of the motion is 2*pi/omega.
    ! omegaFourYRot: Fourier frequency of the y-rotation.
    ! omegaFourZRot: Fourier frequency of the z-rotation.
 
    real(kind=realtype) :: omegafourxrot, omegafourxrotb
    real(kind=realtype) :: omegafouryrot, omegafouryrotb
    real(kind=realtype) :: omegafourzrot, omegafourzrotb
 
    ! cosCoefFourXRot(0:): cosine coefficients of the
    !                      x-rotation fourier series.
    ! cosCoefFourYRot(0:): cosine coefficients of the
    !                      y-rotation fourier series.
    ! cosCoefFourZRot(0:): cosine coefficients of the
    !                      z-rotation fourier series.
 
    real(kind=realtype), dimension(:), allocatable :: coscoeffourxrot
    real(kind=realtype), dimension(:), allocatable :: coscoeffouryrot
    real(kind=realtype), dimension(:), allocatable :: coscoeffourzrot
 
    ! sinCoefFourXRot(1:): sine coefficients of the
    !                      x-rotation fourier series.
    ! sinCoefFourYRot(1:): sine coefficients of the
    !                      y-rotation fourier series.
    ! sinCoefFourZRot(1:): sine coefficients of the
    !                      z-rotation fourier series.
 
    real(kind=realtype), dimension(:), allocatable :: sincoeffourxrot
    real(kind=realtype), dimension(:), allocatable :: sincoeffouryrot
    real(kind=realtype), dimension(:), allocatable :: sincoeffourzrot
 
    ! degreePolAlpha: Degree of the Alpha polynomial.
 
    integer(kind=intType) :: degreepolalpha
 
    ! coefPolAlpha(0:): coefficients of the Alpha polynomial.
 
    real(kind=realtype), dimension(:), allocatable :: coefpolalpha
    real(kind=realtype), dimension(:), allocatable :: coefpolalphab
 
    ! degreeFourAlpha: Degree of the Alpha fourier series.
 
    integer(kind=intType) :: degreefouralpha
 
    ! omegaFourAlpha: Fourier frequency of the Alpha; the
    !                   period of the motion is 2*pi/omega.
 
    real(kind=realtype) :: omegafouralpha, omegafouralphab
 
    ! cosCoefFourAlpha(0:): cosine coefficients of the
    !                      x-rotation fourier series.
 
    real(kind=realtype), dimension(:), allocatable :: coscoeffouralpha
    real(kind=realtype), dimension(:), allocatable :: coscoeffouralphab
 
    ! sinCoefFourAlpha(1:): sine coefficients of the
    !                      Alpha fourier series.
 
    real(kind=realtype), dimension(:), allocatable :: sincoeffouralpha
    real(kind=realtype), dimension(:), allocatable :: sincoeffouralphab
 
    ! degreePolXRot: Degree of the Beta polynomial.
 
    integer(kind=intType) :: degreepolbeta
 
    ! coefPolXRot(0:): coefficients of the Beta polynomial.
 
    real(kind=realtype), dimension(:), allocatable :: coefpolbeta
    real(kind=realtype), dimension(:), allocatable :: coefpolbetab
 
    ! degreeFourBeta: Degree of the Beta fourier series.
 
    integer(kind=intType) :: degreefourbeta
 
    ! omegaFourBeta: Fourier frequency of the Beta; the
    !                   period of the motion is 2*pi/omega.
 
    real(kind=realtype) :: omegafourbeta, omegafourbetab
 
    ! cosCoefFourBeta(0:): cosine coefficients of the
    !                      Beta fourier series.
 
    real(kind=realtype), dimension(:), allocatable :: coscoeffourbeta
    real(kind=realtype), dimension(:), allocatable :: coscoeffourbetab
 
    ! sinCoefFourBeta(1:): sine coefficients of the
    !                      Beta fourier series.
 
    real(kind=realtype), dimension(:), allocatable :: sincoeffourbeta
    real(kind=realtype), dimension(:), allocatable :: sincoeffourbetab
 
    ! degreePolMach: Degree of the Mach polynomial.
 
    integer(kind=intType) :: degreepolmach
 
    ! coefPolMach(0:): coefficients of the Mach polynomial.
 
    real(kind=realtype), dimension(:), allocatable :: coefpolmach
    real(kind=realtype), dimension(:), allocatable :: coefpolmachb
 
    ! degreeFourMach: Degree of the Mach fourier series.
 
    integer(kind=intType) :: degreefourmach
 
    ! omegaFourMach: Fourier frequency of the Mach Number; the
    !                   period of the motion is 2*pi/omega.
 
    real(kind=realtype) :: omegafourmach, omegafourmachb
 
    ! cosCoefFourMach(0:): cosine coefficients of the
    !                      Mach Number fourier series.
 
    real(kind=realtype), dimension(:), allocatable :: coscoeffourmach
    real(kind=realtype), dimension(:), allocatable :: coscoeffourmachb
 
    ! sinCoefFourMach(1:): sine coefficients of the
    !                      Mach Number fourier series.
 
    real(kind=realtype), dimension(:), allocatable :: sincoeffourmach
    real(kind=realtype), dimension(:), allocatable :: sincoeffourmachb
 
    ! gridMotionSpecified: Whether or not a rigid body motion of
    !                      the grid has been specified.
 
    logical :: gridmotionspecified
 
end module inputmotion
 
!      ==================================================================
 
module inputparallel
    !
    !       Input parameters which are related to the parallelization.
    !
    use precision
    implicit none
    save
 
    ! loadImbalance: Allowable load imbalance
    ! splitBlocks:   Whether or not blocks can be split to improve
    !                the load balance.
    ! loadBalanceIter: The number of refinment iterations to run to try
    !                   to get better load balancing.
    real(realtype) :: loadimbalance
    logical :: splitblocks
    integer(kind=inttype) :: loadbalanceiter, partitionlikenproc
end module inputparallel
 
!      ==================================================================
 
module inputphysics
    !
    !       Input parameters which are related to the physics of the flow,
    !       like governing equations, mode of the equations, turbulence
    !       model and free stream conditions.
    !
    use precision
    implicit none
    save
 
    !       Definition of the physics input parameters.
    !
    ! equations:           Governing equations to be solved.
    ! equationMode:        Mode of the equations, steady, unsteady
    !                      or timeSpectral.
    ! flowType:            Type of flow, internal or external.
    ! cpModel:             Which cp model, constant or function of
    !                      temperature via curve fits.
    ! turbModel:           Turbulence model.
    ! turbProd:            Which production term to use in the transport
    !                      turbulence equations, strain, vorticity or
    !                      kato-launder.
    ! rvfN:                Determines the version of v2f turbulence model.
    ! rvfB:                Whether or not to solve v2f with an
    !                      upper bound.
    ! useQCR:              Determines if the QCR term is applied to the shear tensor computation
    !                      when considering turbulence model effects
    ! useRotationSA:       Determines if we will use rotation correction (SA model only)
    ! useft2SA:            Determines if we will use the ft2 term (SA model only)
    ! wallFunctions:       Whether or not to use wall functions.
    ! wallDistanceNeeded:  Whether or not the wall distance is needed
    !                      for the turbulence model in a RANS problem.
    ! Mach:                Free stream Mach number.
    ! MachCoef:            Mach number used to compute coefficients;
    !                      only relevant for translating geometries.
    ! MachGrid:            Mach number of the Mesh. Used in stability
    !                      derivative calculations. Specified as the
    !                      negative of the desired freestream Mach number.
    !                      When this option is set, set Mach = 0.0...
    ! velDirFreestream(3): Direction of the free-stream velocity.
    !                      Internally this vector is scaled to a unit
    !                      vector, so there is no need to specify a
    !                      unit vector. Specifying this vector solves
    !                      the problem of angle of attack and yaw angle
    !                      definition as well as the direction of the
    !                      axis (e.g. y- or z-axis in spanwise direction).
    ! liftDirection(3):    Direction vector for the lift.
    ! dragDirection(3):    Direction vector for the drag.
    ! gammaConstant:       Constant specific heat ratio.
    ! RGasDim:             Gas constant in S.I. units.
    ! Prandtl:             Prandtl number.
    ! PrandtlTurb:         Turbulent prandtl number.
    ! pklim:               Limiter for the production of k, the production
    !                      is limited to pklim times the destruction.
    ! wallOffset:          Offset from the wall when wall functions
    !                      are used.
    ! eddyVisInfRatio:     Free stream value of the eddy viscosity.
    ! turbIntensityInf:    Free stream value of the turbulent intensity.
    ! surfaceRef:          Reference area for the force and moments
    !                      computation.
    ! lengthRef:           Reference length for the moments computation.
    ! pointRef(3):         Moment reference point.
    ! pointRefEC(3):       Elastic center. Bending moment refernce point
    ! SSuthDim:            Sutherlands law temperature (SI Units)
    ! muSuthDim:           Reference viscosity at reference temperature for Sutherlands law (SI Units)
    ! TSuthDim:            Reference temperature for Sutherlands law (SI Units)
    ! momentAxis(3,2)      Axis about which to calculate a moment, provided as 2 points in 3-D
    ! cavitationnumber     Negative Cp value that triggers the traditional
    !                      step-function based cavitation sensor.
    ! cpmin_rho            The rho parameter used with the KS-based cavitation sensor.
    ! cpmin_family         The cpmin for a given surface family that does not use
    !                      KS-aggregation, but rather an exact min computation.
    ! sepSenMaxRho           The rho parameter used with the KS-based separation sensor.
    ! sepSenMaxFamily     The maximum sepsensor value for a given surface family that does not use
    !                      KS-aggregation, but rather an exact max computation.
 
    integer(kind=intType) :: equations, equationmode, flowtype
    integer(kind=intType) :: turbmodel, cpmodel, turbprod
    integer(kind=intType) :: rvfn
    logical :: rvfb
    logical :: useqcr, userotationsa, useft2sa
 
    logical :: wallfunctions, walldistanceneeded
 
    real(kind=realtype) :: alpha, beta
    integer(kind=intType) :: liftindex
    real(kind=realtype) :: mach, machcoef, machgrid
    real(kind=realtype) :: reynolds, reynoldslength
    real(kind=realtype) :: gammaconstant, rgasdim
    real(kind=realtype) :: prandtl, prandtlturb, pklim, walloffset, walldistcutoff
    real(kind=realtype) :: eddyvisinfratio, turbintensityinf
    real(kind=realtype) :: surfaceref, lengthref
    real(kind=realtype), dimension(3) :: veldirfreestream
    real(kind=realtype), dimension(3) :: liftdirection
    real(kind=realtype), dimension(3) :: dragdirection
    real(kind=realtype), dimension(3) :: pointref
    real(kind=realtype), dimension(3, 2) :: momentaxis
    real(kind=realtype) :: ssuthdim, musuthdim, tsuthdim
    real(kind=realtype) :: cavitationnumber
    real(kind=realtype) :: cpmin_rho
    real(kind=realtype), dimension(:), allocatable :: cpmin_family
    real(kind=realtype) :: sepsenmaxrho
    real(kind=realtype), dimension(:), allocatable :: sepsenmaxfamily
 
#ifndef USE_TAPENADE
    real(kind=realtype) :: alphad, betad
    real(kind=realtype), dimension(3) :: veldirfreestreamd, veldirfreestreamb
    real(kind=realtype), dimension(3) :: liftdirectiond, liftdirectionb
    real(kind=realtype), dimension(3) :: dragdirectiond, dragdirectionb
    real(kind=realtype), dimension(3) :: pointrefd, pointrefb
    real(kind=realtype), dimension(3, 2) :: momentaxisd, momentaxisb
    real(kind=realtype) :: machd, machcoefd, machgridd
    real(kind=realtype) :: reynoldsd, reynoldslengthd
    real(kind=realtype) :: gammaconstantd
    real(kind=realtype) :: surfacerefd, lengthrefd
    real(kind=realtype) :: rgasdimd
    real(kind=realtype) :: prandtlb, prandtlturbb
#endif
 
    real(kind=realtype), dimension(3) :: pointrefec
 
    ! Return forces as tractions instead of forces:
    logical :: forcesastractions
 
end module inputphysics
 
!      ==================================================================
 
module inputtimespectral
    !
    !       Input parameters for time spectral problems.
    !
    use precision
    implicit none
    save
 
    ! nTimeIntervalsSpectral: Number of time instances used.
 
    integer(kind=intType) :: ntimeintervalsspectral
 
    ! dscalar(:,:,:): Matrix for the time derivatices of scalar
    !                 quantities; different for every section to
    !                 allow for different periodic angles.
    !                 The second and third dimension equal the
    !                 number of time intervals.
    ! dvector(:,:,:): Matrices for the time derivatives of vector
    !                 quantities; different for every section to
    !                 allow for different periodic angles and for
    !                 sector periodicity.
    !                 The second and third dimension equal 3 times
    !                 the number of time intervals.
 
    real(kind=realtype), dimension(:, :, :), allocatable :: dscalar
    real(kind=realtype), dimension(:, :, :), allocatable :: dvector
 
    ! writeUnsteadyRestartSpectral: Whether or not a restart file
    !                               must be written, which is
    !                               capable to do a restart in
    !                               unsteady mode.
    ! dtUnsteadyRestartSpectral:    The corresponding time step.
 
    real(kind=realtype) :: dtunsteadyrestartspectral
    logical :: writeunsteadyrestartspectral
 
    ! writeUnsteadyVolSpectral:  Whether or not the corresponding
    !                            unsteady volume solution files
    !                            must be written after the
    !                            computation.
    ! writeUnsteadySurfSpectral: Idem for the surface solution
    !                            files.
    ! nUnsteadySolSpectral:      The corresponding number of
    !                            unsteady solutions to be created.
 
    integer(kind=intType) :: nunsteadysolspectral
    logical :: writeunsteadyvolspectral
    logical :: writeunsteadysurfspectral
 
    ! rotMatrixSpectral(:,3,3):  The corresponding rotation matrices
    !                            for the velocity. No rotation
    !                            point is needed, because only the
    !                            velocities need to be transformed.
    !                            The matrix stored is the one used
    !                            when the upper bound of the mode
    !                            number is exceeded; for the lower
    !                            bound the inverse (== transpose)
    !                            must be used. The 1st dimension
    !                            is the number of sections.
 
    real(kind=realtype), dimension(:, :, :), allocatable :: &
        rotmatrixspectral
    logical :: usetsinterpolatedgridvelocity
 
    real(kind=realtype) :: omegafourier
 
end module inputtimespectral
 
!      ==================================================================
 
module inputunsteady
    !
    !       Input parameters for unsteady problems.
    !
    use constants
    implicit none
    save
 
    ! timeIntegrationScheme: Time integration scheme to be used for
    !                        unsteady problems. Possibilities are
    !                        Backward difference schemes, explicit
    !                        RungeKutta schemes and implicit
    !                        RungeKutta schemes.
 
    integer(kind=intType) :: timeintegrationscheme
 
    ! timeAccuracy:     Accuracy of the time integrator for unsteady
    !                   problems. Possibilities are 1st, 2nd and 3rd
    !                   order accurate schemes.
    ! nTimeStepsCoarse: Number of time steps on the coarse mesh;
    !                   only relevant for periodic problems for
    !                   which a full mg can be used.
    ! nTimeStepsFine:   Number of time steps on the fine mesh.
    ! deltaT:           Physical time step in seconds.
 
    integer(kind=intType) :: timeaccuracy
    integer(kind=intType) :: ntimestepscoarse, ntimestepsfine
 
    real(kind=realtype) :: deltat
 
    ! nRKStagesUnsteady:   Number of stages used in the Runge-Kutta
    !                      schemes for a time accurate computation.
    ! betaRKUnsteady(:,:): Matrix with the Runge-Kutta coefficients
    !                      for the residuals.
    ! gammaRKUnsteady(:):  Vector with the time portion of the
    !                      Runge-Kutta stages.
 
    integer(kind=intType) :: nrkstagesunsteady
 
    real(kind=realtype), dimension(:, :), allocatable :: betarkunsteady
    real(kind=realtype), dimension(:), allocatable :: gammarkunsteady
 
    ! nOldGridRead: Number of old grid levels read from the grid
    !               files. Needed only for a consistent restart
    !               on the deforming meshes.
 
    integer(kind=intType) :: noldgridread
 
    ! useALE: Use the deforming mesh ale formuation.
    logical :: useale
 
    ! updateWallDistanceUnsteady: Whether or not to update the wall
    !                             distance in unsteady mode. For a
    !                             RANS simulation on a changing grid
    !                             this should be done if the
    !                             turbulence model requires the wall
    !                             distance. However, the user may
    !                             overrule this if he thinks it is
    !                             not necessary.
 
    logical :: updatewalldistanceunsteady
 
end module inputunsteady
 
module inputadjoint
    !
    !       Definition of some parameters ADjoint.
    !       The actual values of this parameters are arbitrary;
    !       in the code always the symbolic names are (should be) used.
    !
    use constants
    implicit none
    save
    !
    !       Definition of the adjoint input parameters.
    !
 
    ! Monitor      : Whether or not to enable the monitor for the KSP
    !                contexts.
    ! ApproxPC     : Whether or not to use the approximate jacobian
    !                preconditioner
    ! ADPC         : Whether or not to use AD for preconditioning
    ! viscPC       : Whether or not to keep cross derivative terms
    !                in viscous preconditioner.
    ! FrozenTurbulence: Whether to use frozen turbulence assumption
    ! useDiagTSPC   : Whether or not the off time instance terms are
    !                 included in the TS preconditioner.
    logical :: setmonitor, approxpc, usediagtspc
    logical :: frozenturbulence, viscpc, adpc
 
    ! ADjointSolverType: Type of linear solver for the ADjoint
    ! PreCondType      : Type of Preconditioner to use
    ! Matrix Ordering  : Type of matrix ordering to use
    ! LocalPCType      : Type of preconditioner to use on subdomains
    character(maxStringLen) :: adjointsolvertype
    character(maxStringLen) :: gmresorthogtype
    character(maxStringLen) :: precondtype
    character(maxStringLen) :: matrixordering
    character(maxStringLen) :: adjointpcside
    character(maxStringLen) :: localpctype
 
    ! FillLevel     : Number of levels of fill for the ILU local PC
    ! Overlap       : Amount of overlap in the ASM PC
    integer(kind=intType) :: filllevel, overlap
    integer(kind=intType) :: filllevelcoarse, overlapcoarse
 
    ! adjRelTol     : Relative tolerance
    ! adjAbsTol     : Absolute tolerance
    ! adjDivTol     : Relative tolerance increase to divergence
    ! adjMaxIter    : Maximum number of iterations
    ! adjRestart    : Maximum number of steps before restart
    !                 It has a high impact on the required memory!
    ! adjMonStep    : Convergence monitor step
 
    real(kind=alwaysrealtype) :: adjreltol
    real(kind=alwaysrealtype) :: adjabstol
    real(kind=alwaysrealtype) :: adjreltolrel
    real(kind=alwaysrealtype) :: adjdivtol
    real(kind=realtype) :: adjmaxl2dev
    integer(kind=intType) :: adjmaxiter
    integer(kind=intType) :: adjrestart
    integer(kind=intType) :: adjmonstep
 
    ! outerPCIts : Number of iterations to run for on (global) preconditioner
    ! intterPCIts : Number of iterations to run on local preconditioner
    integer(kind=intType) :: outerpreconits
    integer(kind=intType) :: innerpreconits, innerpreconitscoarse
    integer(kind=intType) :: adjamglevels, adjamgnsmooth
 
    logical :: printtiming
    integer(kind=intType) :: subkspsubspacesize
    integer(kind=intType) :: applyadjointpcsubspacesize
 
    ! firstRun     :  Whether this is the first run of the TGT debugger
    ! verifyState  :  Whether to verify state
    ! verifySpatial:  Whether to verify spatial
    ! verifyExtra  :  Whether to verify extra
    logical :: firstrun
    logical :: verifystate
    logical :: verifyspatial
    logical :: verifyextra
 
    ! Logicals for specifiying if we are using matrix-free forms of
    ! drdw
    logical :: usematrixfreedrdw
 
end module inputadjoint
 
module inputtsstabderiv
    !
    !       Definition of some parameters for Time Spectral stability
    !       derivatives.
    !       The actual values of this parameters are arbitrary;
    !       in the code always the symbolic names are (should be) used.
    !
 
    ! TSStability : Whether or not the TS stability derivatives should
    !               be computed
    logical :: tsstability, tsalphamode, tsbetamode, tspmode, &
               tsqmode, tsrmode, tsaltitudemode, tsmachmode
    ! TSAlphaFollowing : Whether or not alpha follows the body in p,q,r mode
    logical :: tsalphafollowing
 
    ! useWindAxis : whether to rotate around the wind axis or the body
    !               axis...
    logical :: usewindaxis
 
end module inputtsstabderiv
 
module inputoverset
    use constants
    implicit none
    save
    !
    !       Definition of parameters for the overset implementation
    !
    logical :: useoversetloadbalance = .true.
    real(kind=realtype) :: overlapfactor = 0.9
    real(kind=realtype) :: nearwalldist = 0.1
    real(kind=realtype) :: oversetprojtol = 1e-12
    real(kind=realtype) :: backgroundvolscale = 1.0
    logical :: debugzipper = .false.
    integer(kind=intType) :: oversetupdatemode
    real(kind=realtype) :: selfzipcutoff
    ! nRefine: number of connectivity loops to run
    integer(kind=intType) :: nrefine
    integer(kind=intType) :: nflooditer
    logical :: usezippermesh
    logical :: useoversetwallscaling
    logical :: recomputeoverlapmatrix
    logical :: oversetdebugprint
end module inputoverset