PARAMS_template.ini

;------------------------------------------------------------
;------------ WABBIT PARAMETER FILE TEMPLATE ----------------
;------------------------------------------------------------
; if you add new parameters, add them here.
; note values have to be declared "value=0;", with equal sign (=) and semicolon (;)


[Domain]
; 2D or 3D problem?
dim=2;
; box size of computational domain. [Lx Ly Lz]
domain_size=1 1;
; synchronization (on/off)on [x y z] domain boundaries
; (off (NON-PERIODIC): 0/false/yes | on (PERIODIC): 1/true/no)
periodic_BC=1 1;
; --- SINCE Apr 2023, SYMMETRY BC IS BROKEN ---
; symmetry BC. If a problem has e.g, x symmetry (mirror axis is then the y-axis), you'd set 1 0 here.
; symmetry still goes with periodicity in the code: we solve a symmetric periodic problem (cosine-transform)
; this implies all BC in symmetric directions are treated symmetrically (so, at x=const=0 and x=const=Lx)
; While it is possible to also set dirichlet BC on either, we have not currently implemented it.
; Hint: ensure to not impose a meanflow in symmetric directions! Default: (.not. periodic_BC)
symmetry_BC=0 0;
; symmetry comes in two ways: for scalars (phi, pressure, density) and tangential velocity components (for
; y symmetry, this would be ux, uz but NOT uy), we simply mirror the data. For the normal component (here: uy)
; we mirror the component, invert the sign and also have to set uy=0 right on the line of symmetry.
; Tell the code what is a scalar and which are vector components. For 2D ACM this would be x y 0, for 3D ACM this would be x y z 0,
; for 3D compressible Navier_Stokes this would be 0 x y z 0 (0: scalar). The length of this vector equals number_equations. Default: 0 for all
symmetry_vector_component=


[Wavelet]
; which wavelet to use: CDF20, CDF22, CDF40, CDF42 or CDF44
; required number of ghost nodes: 2, 3, 4, 5, 7
wavelet=CDF44;


[Blocks]
; size of each block, must be even, if given one value this is used
; for all directions, or specify value for each direction
number_block_nodes=32 32;
; ghost nodes for each block. If you leave it empty, it will be set according
; to the wavelet. (see Wavelet::wavelet). If the discretization scheme requires
; more ghost nodes, set the value here.
number_ghost_nodes=;
; For the right hand side, often less ghost nodes are required than for the wavelet, specify here.
; For a 4th order FD code, this is 2 (FD4) or 3 (TW4). 2nd order is 1. Default=number_ghost_nodes
number_ghost_nodes_rhs=;
; number of equations / components of state vector. Note you have to properly
; adjust this value for the physics module that you use.
; ACM: 3 (2D), 4 (3D)
; Convection: 1 (2D /3D)
number_equations=4;
; treelevel bounds: determine the highest (max_treelevel) and lowest (min_treelevel) refinement
; level of blocks. With each refinement level the grid gets refined by a factor of two. The maximum
; resolution at max_treelevel is dx = 2^-max_treelevel * L / Bs (L:domain size, Bs: blocksize)
max_treelevel=6;
; sometimes you want to restrict the minimum refinement as well, for example if we run equidistant
; simulations (which is quite rare!): in that case, max_treelevel = min_treelevel. coarsening beyond
; min_treelevel is not allowed.
min_treelevel=1;
; It is sometimes useful to start the simulation with a refined equidistant grid, i.e., start creating
; the initial condition on a higher grid level. This is for example useful for expensive mask functions
; such as the µCT data. After the initial condition, the code is allowed to refine down to min_treelevel again.
; the default values is the same as min_treelevel
ini_treelevel=1;
; max number of trees in the forest. A tree corresponds to a grid; this notation
; only is important for postprocessing, i.e. using the adaptive-POD module. For running
; simulations, you can leave the value empty - it is set automatically.
max_forest_size=22;
; Use adaptivity or not? If adapt_tree=1 then the grid is refined before a time step,
; the time evolution is done, and the grid is coarsened after the time step. If adapt_tree=0
; the grid does not change after the initial condition, and refinement/coarsening are disabled.
adapt_tree=1;
; adaptive initial conditon? i.e. create grid to respect error bounds
; default is same value as adapt_tree
adapt_inicond=1;
; in some situations, it is necessary to create the intial grid, and then refine it for a couple of times.
; for example if one does non-adaptive non-equidistant spatial convergence tests. default is 0.
inicond_refinements=0;
; block distribution for balancing (also used for start distribution)
; [sfc_z | sfc_hilbert]
; sfc_z  -> space filling curve -> z-curve
; sfc_hilbert -> hilbert space filling curve
block_dist=sfc_hilbert;
; coarsening indicator to be used in mesh adaptation (=coarsening) [threshold-state-vector, random, primary-variables]
; threshold-state-vector: evaluates wavelet criterion on components of state vector. specify below which ones.
; primary-variables: only available for NStokes: converts statevector to (rho,u,v,w,p) before thresholding
; random: randomly coarse some blocks. used for testing. note we tag for coarsening only once in the first iteration
; everywhere: coarsenes the entire grid by one level. note that this is strictly speaking, only guranteed to be possible
; if the grid has been refined "everyhwere" before.
coarsening_indicator=threshold-state-vector;
; sometimes, it can be useful to use a different indicator to generate the initial grid. For example, we can generate
; some non-equidistant grid for inicond, then use coarsening_indicator=everywhere
; default: same as coarsening_indicator
coarsening_indicator_inicond=;
; use normalization for eps or not? Thresholding means we control the absolute error in some norm (often Linfty norm, see below)
; but very often, you rather want to control the relative error. So, some norm of the field is computed, such that
; || u-u_eps || / ||u|| < eps  (using the norm specified below)
; default=0, even though this is stupid: if you have large pressure (say u=1 and pressure=10000), then only the pressure will determine
; the grid
eps_normalized=1;
; WABBIT uses interpolating, biorthogonal wavelets. These wavelets are, by default, normalized in the Linfty
; norm. That means setting a threshold eps=1.0e-3, we guarantee that the error is < 1.0e-3 in Linfty norm.
; For denoising, we rather need to control the L2 error, because Donohos work is applicable only to the L2 norm.
; For CVS finally, which mimicks applying the denoising to vorticity, we need to control the H1 norm.
; [Linfty (default), L2, H1]
eps_norm=Linfty;
; threshold value for thresholding wavelet coefficients. smaller values imply denser grids. Typical values are ~1e-3
eps=1e-3;
; which components to use for coarsening_indicator? default is all components.
; active only if coarsening_indicator=threshold-state-vector. select the components, set as
; many as number_equations
threshold_state_vector_component=1 1 0;
; it can be useful to also use the mask function (if penalization is used) for grid adaptation.
; i.e. the grid is always at the finest level on mask interfaces. Careful though: the Penalization
; is implemented on physics-module level, i.e. it is not available for all modules.
threshold_mask=0;
; if this flag is set (1), then blocks on max level have to coarsen, even if their
; details are significant. This is equivalent to ensuring dealiasing. Hence, if set to 1,
; wabbit will evaluate the right hand side of your equation on max_treelevel, but in the mesh
; coarsening it will, regardless of the solution, downsample the result to max_treelevel-1. Your
; expected precision is thus max_treelevel-1, but the computational cost (derivatives and timestep)
; is on max_treelevel.
force_maxlevel_dealiasing=0;
; if desired, we perform more than one time step
; before adapting the grid again. this can further reduce the overhead of adaptivity
; Note: the non-linear terms can create finer scales than resolved on the grid. they
; are usually filtered by the coarsening/refinement round trip. So if you do more than one time step
; on the grid, consider using a filter. default is "1", which is the classical scheme
N_dt_per_grid=1;
; coarseExtension means we delete wavelet coefficients near a coarse/fine interface. This
; allows us to skip the linear system that would occur otherwise, and it avoids artifacts
; observed with the lifted wavelets. Default=1, you shoudn't use 0
useCoarseExtension=1;
; the coarseExtension means deleting WC near the interface. However, if a significant WC travels towards
; this interface, then it may be deleted. The additional security zone (which is different from the safety
; zone = refine_everywhere) adds more blocks so that this will not happen. Default=1, you shoudn't use 0
useSecurityZone=1;

[Time]
; final time to reach in simulation
time_max=1.0;
; maximum walltime allowed for simulations (in hours). The run will be stopped if this duration
; is exceeded. This is useful on real clusters, where the walltime of a job is limited, and the
; system kills the job regardless of whether we're done or not. If WABBIT itself ends execution,
; a backup is written and you can resume the simulation right where it stopped. Note you can also
; stop a run using the file "runtime_control" (set runtime_control=save_stop;)
walltime_max=999.9;
; While we can save every write_time time units of the simulation, it may be desirable to save also
; every couple of hours of runtime (for very expensive runs) so that we can be sure to be able to
; resume the simulation with at most the loss of these hours. default unused, set value in HOURS.
walltime_write=;
; number of time steps performed. if not set, default value is very large
nt=;
; CFL criterium (velocity). Note the time step dt is dictated by the physics modules: some eqns (like
; the heat eqn, which is not implemented) may not even have a CFL restriction.
CFL=1.0;
; CFL critierum for penalization (dt<=CFL_eta*C_eta), if VPM is used. For RungeKuttaGeneric schemes, the constant
; has to be < 1.0 (otherwise the code is unstable). For krylov schemes, it can be greater
; 1, but be careful about the error. This parameter is used by ACM physics module only.
CFL_eta=0.99;
; time step restriction of viscous terms ( dt < CFL_NU * dx**2 / nu )
; runge kutta 4 has constraints: 2D=>0.14 3D=>0.094 (exact expression: 2.79/(dim*pi**2)), these are
; the default values
CFL_nu=;
; wabbit can save the heavy data (flow fiels) to HDF5. What is saved depends on the physics modules
; and the section [Saving]. Here you control WHEN you want to save the output: either after a fixed
; number of time steps [fixed_freq], or after a physical time interval [fixed_time]
write_method=fixed_time;
; if write_method=fixed_freq:
; write frequency for output, choose very large number for disabling output on disk
write_freq=2;
; if write_method=fixed_time:
; write time for output
write_time=100.05;
; fixed time step. if the value is greater 0.0, then the time step is fixed no matter what.
; the setting from the physics modules, which usually decide about dt, are ignored and over-
; written. The default is 0.0, so not used. NOTE: WABBIT still will adjust dt to precisely match
; the time for saving and statistics and the final time, if any of those is not a multiple of dt_fixed.
; In that case, some time steps may be smaller in order to reach those times.
dt_fixed=0.0;
; largest time step, if you want to set one. dt is always smaller than that, if the
; value is greater 0. default is 0.0, so not used. WABBIT overwrites the physics module dt
; by that value, if the timestep is larger than dt_max and dt_max > 0.
dt_max=0.0;
; time-step method. can be either "RungeKuttaGeneric" or "Krylov". In the former case,
; any explicit Runge-Kutta scheme can be set by using the Butcher-Tableau. (RK4 is default) In the latter,
; the number of Krylov subspaces M_krylov can be set.
; [ RungeKuttaGeneric, Krylov, RungeKuttaChebychev ]
time_step_method=RungeKuttaGeneric;
; The usual RungeKuttaChebychev method contains a number of hard coded schemes for different
; number of stages "s" and the fixed damping coefficient eps=10.0 (see Verwer and Sommeijer)
; if you want to use another RKC scheme, you can do so by settting it up in this INI-file.
; Provide coefficients with length "s". they are usually precomputed in python.
RKC_custom_scheme=no;
; (complicated) coefficients following Verwer & Sommeijer follow.
; longest scheme is 60 stages.
RKC_mu=;
RKC_mu_tilde=
RKC_nu=
RKC_gamma_tilde=
RKC_c=
; number of stages "s" for the RungeKuttaChebychev method. Memory is always 6 registers
; independent of stages.
s=10;
; if time_step_method is krylov, then you can specify the dimension of the krylov subspace
; below. If dynamic subspace dimensions are used, we interpret this number as the maximum
; number of spaces admissible (the method requires a lot of memory in general)
M_krylov=12;
; fixed or dynamic krylov subspace dimension:
; [ fixed, dynamic ]
krylov_subspace_dimension=fixed;
; if dynamic subspace dimensionality is used, provide the residuum threshold here. Note this is
; in general not an exact measure for the error, but rather a good indicator.
krylov_err_threshold=1.0e-3;
; butcher_tableau
; use your butcher_tableau for the Runge Kutta time step function
; e.g. RK4:
; butcher_tableau=(/ 0.0 0.0 0.0 0.0 0.0
; 0.5 0.5 0.0 0.0 0.0
; 0.5 0.0 0.5 0.0 0.0
; 1.0 0.0 0.0 1.0 0.0
; 0.0 0.16666666666666666 0.33333333333333331 0.33333333333333331  0.16666666666666666 /)


[Physics]
; what physics module is used?
; [ACM-new, ConvDiff-new, navier_stokes]
physics_type=navier_stokes;
; decide if you want to start from a given configuration (i.e. Statevector)
; 1:true, 0:false and we start from the initial conditions dictated by the physics
; modue.
read_from_files=0;
; sometimes you want to save the iteration number as fileid instead of the time:
use_iteration_as_fileid=0;
; if read_from_files is true, WABBIT will try to start from the given files
input_files=rho_000000000141.h5 Ux_000000000141.h5 Uy_000000000141.h5 p_000000000141.h5;


[Saving]
; WABBIT is in charge of saving, but what is saved is controled by the physics modules.
; here, you need to tell WABBIT how many fields are saved and how they will be labeled.
; The physics modules are then in charge of providing the respective data to WABBIT. I.e.
; if the field is called "mask", WABBIT will ask the physics module to return the array
; "mask" and then save that to disk.
; how many fields are you going to save?
N_fields_saved=6;
; how are the fields labeled?
field_names=rho Ux Uy p vort mask;


[Statistics]
; save every nsave time steps (leave empty to disable)
nsave_stats=10;
; and every tsave physical time units (leave empty to disable)
tsave_stats=0.20;


[ACM-new]
; speed of sound, used also for the CFL condition. The characteristic velocity is
; u_eigen = umax + sqrt(umax**2 + c0**2)
c_0=50.0;
; viscosity. We also respect the time step constraint imposed by explicit diffusion
nu=1e-2;
; damping term for pressure, see [Ohwada, Asinari, JCP2010]. This coefficent is a dashpot-like damping,
; dp/t = ... -gamma*p and it is used primarily for purely periodic flows without penalization (i.e.
; without boundary conditions: an example would be Taylor-Green Vortices)
gamma_p=1;
; mean flow, is imposed as initial condition (if inicond=meanflow) and in the sponge
; layer as far-field BC (if this is used!)
u_mean_set=0.0 0.0 0.0;
; initial condition
inicond=meanflow;
; if inicond= pressure-blob
beta=0.05;
; we can use passive scalars with the ACM. their parameters are specified in "ConvectionDiffusion" below
; but they need to be turned on here. Default is off.
use_passive_scalar=0;
; sometimes, but very rarely, we want to compute just the passive scalar and not
; the flow field, because the convection-diffusion physics module does not contain the
; penalized passive scalar eqns.
compute_flow=1;
;
use_HIT_linear_forcing=1;


[Sponge]
; sponge term, used in ACM module to mimick outflow conditions for pressure waves
; NOTE (ACM): when the sponge is used, be sure to allow for mask_time_dependent_part=1. Even
; though the sponge function is not explicitly time-dependent, it is treated as such because
; the sponge does not have to be at the maximum refinement level.
use_sponge=0;
; shape of the sponge. the tradional form (default) is "rect", but we have a smoothed
; version with round corners which is called "p-norm". It has the parameter p_sponge,
; which controls the roundedness of corners. The function is inspired by the p-norm
; ((x-x0)**p + (y-y0)**p + (z-z0)**p)**1/p [https://de.wikipedia.org/wiki/P-Norm]
; a good compromise is p=20.0
sponge_type=rect;
; p-sponge is used only in conjunction with sponge_type=p-norm;
p_sponge=20.0;
; thickness of sponge layer (in physial units)
L_sponge=0.1;
; sponge damping constant
C_sponge=1.0e-2;


[ConvectionDiffusion]
; how many scalar fields do you want to solve? should be the same as number_equations
; above.
N_scalars=1;
; --------------------------------------------------------------------------------
; note you need to specify one value per scalar field for ALL the below parameters
; --------------------------------------------------------------------------------
; viscosity. if nu<1.0e-10 (or 0.0), diffusion is disabled.
nu=0.0;
; initial condition for the scalar(s)
inicond=blob;
blob_width=0.01;
; position of blob
x0=0.5;
y0=0.75;
z0=0;
; velocity field for transportation, [swirl,constant,nonlinear]
velocity=swirl;
; if the velocity profile is the swirl test, one sometimes would want to compute
; an incomplete swirl, i.e. Tmax and Tswirl to not agree. Set T_swirl here if you want
; the default is the same as the simulation duration
T_swirl=5.0;
; if constant velocity, these are the values (one per scalar)
u0x=1.0;
u0y=1.0;
u0z=0.0;
; The BC can either be "neumann" (adiabatic, no flux) or "dirichlet" (isothermic, fixed concentration)
; default is neumann
scalar_BC_type=neumann;

[Navier_Stokes]
; choose your coordinate_system
;  + default cartesian 2D/3D = "cartesian"
;  + cylindrical 2D = "cylindrical"
Coordinate_system=cartesian;
; adiabatic coefficient
gamma_=1.4;
; specific gas constant
Rs=287.05         ;for air
; prandtl number
Pr=0.71;
; dynamic viscosity
mu0=1e-2;
; dissipation, 1=on, ...=off
dissipation=1;
; the navier stokes module provides different scenarios (/cases), with special initial conditions
; penalization, boundary conditions, etc. Not all cases have the same specifications, therefore we
; have to distinguish between them.
; case studies of the NStokes module:
; + simple_geometry: [triangle | cylinder | rhombus]
; + funnel
; + shock_tube: [sod_shock_tube| standing_shock | moving_shock]
; + pipe_flow
; + no: [pressure_blob | shear_layer | pressure_wave | taylor_green ]
case=funnel;

[Boundary_Conditions]
; NSTOKES 2D only: if you want to use boundary conditions, you
; can specify them here
; Remarks:
; 1. for non periodic BC you have to explicitly switch of
; the synchrinzation in the chosen direction
; 2. CURRENTLY: non periodic BC make use of the Sparse BLAS
; vector matrix multiplication, therefore you have to make sure
; that SBLAS is used during compile time
;-------------------------------------------------------------
; availabel BCs: in coordinate direction e_i
;   + symmetric-open -- symmetric BC in -e_i and open BC in +e_i
;   + symmetryAxis-wall -- adiabatic slip wall in -e_i and
;                           adiabatic non-slip wall in +e_i
;   + periodic
;----------------------
; choose BC on the corresponding boundary [x,y]
boundary_type=symmetric-open periodic;
; you may choose reference values of the
; statevector for the open boundaries:
state_xminus=1.645 0 0 1e-7;
state_xplus=1.645 0 0 1e-7;

[Pipe_flow]
; this is the validation test case for the cylindrical NS rhs
; P_in is the pressure set at the inlet of a tube.
; P_out is the pressure set at the outlet of the tube.
; Use the symmetryAxis-wall boundary condition in y direction,
; to get a velocity profile predicted by the Hagen-Poiseuille law.
p_in=10;
p_out=0.4;

[Initial_Values]
inicond=pressure_blob;
; initial conditions for the different szenarios:
; 1.)mask:
;	  inside penalized volume: velocity u=0,
;                            pressure p=rho_0 Rs T_0,
;   outside: velocity u=u_0 and pressure p=p_0;
; 2.)zeros:
;    sets initial velocitys to 0 regardles of initial_velocity
; 3.)pressure_blob
; 	 pressure blob with diameter inicond_width
; 4.)sod_shock_tube
; 	 sets initial conditions according to [Sod,1978]
; 5.)shear_layer
; 	 set initial conditions (rho_0,u_0,p_0) and the shear layer width from inifile;
; 6.)simple-shock
;    produces standing shock (1D) in x direction, specify inicond_(pressure,velocity,density,width);
;    inicond_width quantifies the shock location in x direction
; 7.)moving-shock
;    produces moving shock (1D) in x direction with initial_velocity(1) specifies shock speed
;    specify inicond_(pressure,velocity,density,inicond_width)
;    inicond_width is the location of the shock
inicond_width=0.01;
initial_pressure=101330.0;  p_0
initial_velocity=50.0 0.0 0; u_0
initial_temperature=200;     T_0
initial_density=1.645;      rho_0


[Discretization]
; order of derivatives [ FD_2nd_central, FD_4th_central, FD_6th_central, FD_4th_central_optimized ]
order_discretization=FD_4th_central;
; explicit filtering of state vector, after time evolution (and before coarsening).
; available filters: explicit_3pt, explicit_5pt, explicit_7pt, explicit_9pt, explicit_11pt
filter_type=;
; filter frequency (note: set filter to no_filter if you want to disable filtering completely)
; Note our clumsy nomenclature: we mean filtering every "filter_freq" time steps
filter_freq=10;


[VPM]
; Volume penalization method to take obstacles into account without adapting the
; grid. Penalization is an equation-dependent addon. It can not be used with any
; RHS, if the RHS does not support it.
; flag for penalization (0/1)
penalization=1;
; WABBIT needs to know about the mask function (if penalization is used): does it contain
; a time-dependent-part (e.g. moving obstacles, time-dependent forcing)? does it contain
; a time-independent part (fixed walls, homogeneous forcing)? or both? WABBIT needs to know
; that since we try to create the time-independent mask function only once, but the time-dependent
; part of course in every time step.
; NOTE: the flag threshold_mask has a critical impact here: if it is false, it is not guaranteed that the
; fluid-solid interface is on Jmax or Jmax-1, hence the technique of using a pre-generated static mask function
; that can be added to the time-dependent part cannot be used. If the mask function is expensive to compute,
; ensure that threshold_mask is set.
mask_time_dependent_part=1;
mask_time_independent_part=1;
dont_use_pruned_tree_mask=0;
; smooth mask for penalization term [0,1]. If the obstacle moves, this flag should
; be set, and in static cases as well. hard masks with only 0 and 1 are deprecated but
; included for completeness. Note some mask functions may ignore this flag (the insects for example)
smooth_mask=1;
; penalization factor. Can be seen as porosity, so smaller values = harder walls
; Note for explicit time integration, dt < C_eta
C_eta=1e-3;
; The mask geometry is PHYSICS MODULE SPECIFIC! Hence it depends on the module which values you can set.
; cNS: [funnel,triangle,cylinder,rhombus]
; ACM: [none,Insect,cylinder,two-cylinders, two-moving-cylinders, flapping-wings, rotating_cylinder] if "Insect", all other parameters are read from "Insect" section.
; ConvDiff: not implemented
geometry=triangle;
; frequency of moving object
freq=0.1
; center coordinate of object
x_cntr=0.5 0.5 0;
; radius of cylinder
R_cyl=0.25;
; [triangle,rhombus]: angle between symmetry axis and triangle side (in degrees please)
angle=30;
; [triangle,rhombus,cylinder]: length or diameter of the object
length=0.3


[BRIDGE]
; type 1 if a bridge shell be created and 0 if not
connect_with_bridge=0;
; The following parameters are only needed if there is a bridge

; Usage of a common MPI_comm_world  (1,yes,true,T=true / 0,no,false,F=false)
bridgeCommonMPI=0;
; If bridgeFluidMaster is true WABBIT is seen as the master and will
; spawn (split off) the processes of the other MPI_WORLD
;  (1,yes,true,T=true / 0,no,false,F=false)
bridgeFluidMaster=1;
; Command to use to launch the particle program (name of the executable)
particleCommand=./pig;


[Insects]
; NOTE: Those parameters are used only in ACM and only if VPM::geometry=Insect
;-------------------------------------------------------------------------------
; Body geometry
x_pivot_r=0.0 0.0 0.0; (vector) position of right wing in body system
x_pivot_l=0.0 0.0 0.0; (vector) position of left wing in body system
; Body (types: ellipsoid, drosophila, nobody, superSTL, sphere) if free sphere in geometry use sphere
BodyType=nobody;
; if the body is a superSTL file, specify the filename here. Note: the geometry
; is understood in the body frame of reference, hence 0,0,0 is the centre of the body
; (which does in our notation imply the centre of gravity there, but this is relevant
; only in free-fight, and the superSTL option is currently only used for tethered flight)
BodySuperSTLfile=;
HasDetails=all; legs; antennae_proboscis; no;
RightWing=yes;
LeftWing=no;
; if the insect has a fore- and hind wing, we end up with a four-winged insect
RightWing2=no;
LeftWing2=no;
b_body=0.2;
L_body=1.0;
R_head=0.20;
R_eye=0.075;
x_head=0.0 0.0 0.0; (vector)
x_eye_r=; (vector)
x_eye_l=; (vector)
J_body_yawpitchroll=1.0 1.0 1.0; Body moment of inertia in body reference frame
mass=1.0; total mass of animal
gravity=1.0; negative: falling in negative z-direction
;-------------------------------------------------------------------------------
; Wing geometry (Shapes: rectangular, TwoEllipses, drosophila, drosophila_mutated,
; drosophila_sandberg, drosophila_maeda, flapper_sane)
; You can also set WingShape=from_file::wing_shape.ini to read the wing geometry
; from an INI file. In the latter case, generic Fourier and rectangular wings with
; and without bristles are available.
WingShape=suzuki;
b_top=0.1; if WingShape=TwoEllipses, that's thickness of the forward one
b_bot=0.3; if WingShape=TwoEllipses, that's thickness of the backward one
L_chord=1.0;
; the variable L_span is used for bounding box testing and is required only for
; the WingShapes=[mosquito_iams, rectangular, TwoEllipses ]
L_span=1.0;
; wing tickness (from top to bottom surface, not divided by two)
; note if you use WingShape=from_file:: then the thickness is possibly overwritten
; by the value in this ini file. If the value is not found in the file, the one given
; here is used.
WingThickness=0.0417;
; wing inertia tensor (used to compute inertial power)
Jxx=0.0560;
Jyy=0.0031;
Jzz=0.0591;
Jxy=0.0061;
;-------------------------------------------------------------------------------
; Body motion
; motion of the body: (tethered, free_flight, yawpitchroll_param)
BodyMotion=tethered;
x0=2 2 2; initial (or tethered) position
v0=0 0 0; inital velocity
yawpitchroll_0=45.0 -45.0 0.0; initial (or tethered, or time-average) orientation in degrees
yawpitchroll_a1=0.0 15.0 0.0; if BodyMotion=yawpitchroll_param first cosine harmonic component
yawpitchroll_b1=0.0 10.0 0.0; if BodyMotion=yawpitchroll_param first sine harmonic component
eta0=-45.00; stroke plane angle in degrees
DoF=000000; x,y,z,yaw,pitch,roll DoF on=1 or off=0
;-------------------------------------------------------------------------------
; Wing motion
; (types: Drosophila_hovering_fry, Drosophila_hovering_maeda, flapper_sane,
; flapper_dickinson, takeoff, simplified, from_file, none)
FlappingMotion_right=suzuki;
FlappingMotion_left=suzuki;
; if flappingmotion=="from_file", which file to use?
infile=bumblebee_new_kinematics.ini;
;-------------------------------------------------------------------------------
; The fractal tree module is a submodule of the insect module. We can also simulate
; an insect together with a fractal tree
fractal_tree=no;
; a fractal tree is a list of cylinders. They are given in a simple ascii-file
; without header, containing one cylinder per line. The colums then are
; x1,y1,z1,x2,y2,z2,R
; so last column is radius and not diameter. We re-define the cylinder such that the
; origin of the very first one is at (/0,0,0/) before adding fractal_tree_x0
fractal_tree_file=tree_data.in;
; The fractal tree as a whole can be translated
fractal_tree_x0=0.0, 0.0, 0.0;
; we can scale the whole tree up as well:
fractal_tree_scaling=1.0;
;-------------------------------------------------------------------------------
; Parameters that control the smoothing of the mask function
; Discovered that this was done block based, i.e. the smoothing layer
; had different thickness, if some blocks happened to be at different levels (and still carry
; a part of the smoothing layer.) I don't know if that made sense, because the layer shrinks/expands then
; and because it might be discontinous. Both options are included now, default is "as before"
; Insect%smoothing_thickness=="local"  : smoothing_layer = c_sm * 2**-J * L/(BS-1)
; Insect%smoothing_thickness=="global" : smoothing_layer = c_sm * 2**-Jmax * L/(BS-1)
smoothing_thickness=; default: local
C_smooth=; default: 1.0
; when using CT data, code computes the mask function in a shell around fluid-solid interface.
; The tickness of the shell is not a critical parameter, but it affects performance. Thicker shell
; means more points and thus more comput effort. It is given in multiples of C_smooth, that means
; shell_thickness = C_shell_thickness * C_smooth * dx_min
C_shell_thickness=; default: 5.0


[funnel]
; NOTE: Those parameters are used only in Nstokes and only if [Navier_Stokes]::case=Funnel
;-------------------------------------------------------------------------------
outer_diameter=0.05;
maximal_inner_diameter=0.03;
minimal_inner_diameter=0.0025;
Number_of_plates=41;
Temperatur_of_plates=50;
jet_diameter=0.001;
inlet_velocity=400 0;
inlet_density=0.545;
inlet_pressure=33000;
outlet_pressure=1000.0;
pump_speed=200;

plates_thickness=0.0011;
first_plate_thickness=0.003;
distance_between_plates=0.0025;
diameter_slope_per_plate=0.002;


[simple_geometry]
; NOTE: Those parameters are used only in Nstokes and only if [Navier_Stokes]::case=simple_geometry
; + for implementation of the geometry we use the volume penalization method
; (see: https://doi.org/10.1016/j.compfluid.2008.07.003, Boiron 2008)
;     - Ceta is read from [VPM]::Ceta
;     - make sure [VPM]::penalization=1;
;     - for the in and out-flow we use sponges which mimic dirichlet BC
;       all Spong parameter are read form [Sponge]
;-------------------------------------------------------------------------------
; what geometry is it?
geometry=triangle; [ cylinder | rhombus | triangle ]
; center coordinate of object
x_cntr=0.5 0.5 0;
; [triangle,rhombus]: angle between symmetry axis and triangle side (in degrees please)
angle=30;
; [triangle,rhombus,cylinder]: length or diameter of the object
length=0.3;
; + initial condition:
; availabel intial conditions are [mask | moving-shock | pressure-blob | zeros]
; the initial values are taken form [initial_values]
; + note: inicond mask sets u=u0 and rho=rho0 and p=p0 for the sponge reference values
; -------------------------------------------------------------------------------
; FREE OUTLET for shock geometries
; if free_outlet_wall is true a free outlet sponge will be added to
; the domain boundary perpendicular to the
; the inlet flow direction (x-direction)
free_outlet_wall=1;


[Shock_Tube]
; This section is only available for NStokes! It is used to validate
; the RHS euler equations and test the filter methods
; ------------------------------------------------------------------
; available shock configurations: [sod_shock_tube | moving-shock | standing-shock]
name=sod_shock_tube;
; + sod_shock_tube: see Publication Gary A Sod.,1987
; + moving-shock:   - is a shock front which moves with speed Mach_shock
;                   - the statevector left and right of the shock is computed
;                     from the Rankine-Hugoniot conditions
;                     (see F.Toro "Riemann solvers and numerical methods for fluid dynamics
;                     p. 98ff)
; + standing-shock: - is a standing shock wave
;-------------------------------------------------------------------
; for moving and standing shocks,
; you have to provide the values for the left side of the shock:
; the values of the right side are then computed from Rankine-Hugoniot conditions
pressure_left=101330.0;
velocity_left=50.0;
temperature_left=200;
density_left=1.645;
; and the speed of the shock wave for the moving shock
shock_wave_speed=500;
; normal vector of the shock front:
; the normal vectors are parallel to the Standard basis vectors
; choose 1 for the normal vector e_1 (x-direction)
;        2 for ...               e_2 (y-direction) etc.
shock_front_normal=2;


[Debug]
; check if the ghost node synchronization gives the right order, on a random
; grid. this test costs some CPU time but no memory. It is done only once at startup.
test_ghost_nodes_synch=1;
test_wavelet_decomposition=0;
test_treecode=0;