PARAMS_template_ACM.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=3;
; box size of computational domain. [Lx Ly Lz]
domain_size=4 4 4;
; synchronization (on/off)on [x y z] domain boundaries
; (off (NON-PERIODIC): 0/false/yes | on (PERIODIC): 1/true/no)
periodic_BC=1 1 1;
; 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=


[Blocks]
; size of each block, must be odd (17, 19, 33, etc), if given one value this is used
; for all directions, or specify value for each direction
number_block_nodes=17 17 17;
; ghost nodes for each block. you need to know this value depending on the discretization and the multiresolution
; interpolation.
number_ghost_nodes=4;
; 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) +  nscalars
; Convection: 1 (2D /3D)
number_equations=3;
; threshold value for thresholding wavelet coefficients
eps=1e-3;
; 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
min_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=;
; Use adaptivity or not? If adapt_mesh=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_mesh=0
; the grid does not change after the initial condition, and refinement/coarsening are disabled.
adapt_mesh=1;
; adaptive initial conditon? i.e. create grid to respect error bounds
; default is same value as adapt_mesh
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.
; random: randomly coarse some blocks. used for testing. note we tag for coarsening only once in the first iteration
coarsening_indicator=threshold-state-vector;
; 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;
; 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 1 1;
; 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=1;
; 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=1;
; 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;


[Wavelet]
; if we use harten-multiresolution, the coarsening operator is just taking every second
; grid point. This is nice and local but the resulting wavelet has no vannishing moments.
; If biorthogonal is used, a smoothing low-pass filter is applied prior to downsampling.
; The biorthogonal option does however use harten for the ghost nodes at this time (09/2019)
transform_type=harten-multiresolution; biorthogonal;
; only used if transform_type=biorthogonal
wavelet=CDF4,4;


[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=0.01;
; 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. Default code allows up to 40 stages for eps=10.0 (hard-coded)
; coefficients. other schemes can be defined manually above.
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=ACM-new;
; 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;
; 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=ux uy uz p mask scalar1;


[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]
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=0;


[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]
; adding passive scalars to the flow. (tracers / odors)
; how many scalar fields do you want to solve? Each scalar requires solving an equation and
; this the number_equations = N_fluid + N_scalars, N_fluid = 3 (2d) or 4 (3d)
N_scalars=0;
; 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. NOTE: if coupled to ACM,
; provide Schmidt number instead of nu
nu=0.0e-6;
; if ConvectionDiffusion is run together with ACM, you specify the Schmidt number below
; and NOT the viscosity nu
Sc=1.0 1.0;
; initial condition for the scalar(s)
inicond=empty empty;
; source for scalars. "gaussian": at the point specified below, a source term.
; "mask_color_emission": scalar is emmited at mask parts with the color specified in widthsource
; (which in this case is no longer the width)
; each entry has N_scalars values.
source=gaussian gaussian;
x0source=1 2;
y0source=1 1;
z0source=0 0;
; width of "gaussian" or color of "mask_color_emission"
widthsource=0.2 0.1;
; the penalization for the scalar is independent of that of the fluid for the neumann
; no-flux BC on the obstacles. For Dirichlet sources, the usual [VPM]::C_eta is used.
C_eta=1e-3 1.e-3;
; sponges are used to impose dirichlet BC at domain borders: for the passive scalar,
; you have to choice to activate this or not. If set, scalars are absorbed in the sponge
; layer
absorbing_sponge=1;


[Discretization]
; order of derivatives [ FD_2nd_central | FD_4th_central_optimized ]
order_discretization=FD_4th_central_optimized;
; order of refinement predictor [ multiresolution_4th | multiresolution_2nd ]
order_predictor=multiresolution_4th;
; filtering of equations. NOTE: the filters are PHYSICS MODULE SPECIFIC! Hence it depends on the module
; which values you can set here.
; cNS: [no_filter | explicit_5pt | explicit_7pt | explicit_9pt | explicit_11pt | bogey_shock | wavelet_filter]
; ACM: [no_filter | wavelet_filter | explicit_7pt]
; ConvDiff: not implemented
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;
; usually, a filter would be applied to all blocks, but it is also sometimes useful to apply it just for
; the finest blocks (those that cannot be refined anymore). If maxlevel dealiasing is FALSE and this option is TRUE,
; the result is equivalent to maxlevel_dealiasing TRUE, if the filter is wavelet and it is applied in every time step
filter_only_maxlevel=no;
; filter on all blocks, except the highest level. if adapt_mesh=0, this can be used to model a refine-evolve-coarsen
; step without dealiasing on maxlevel. Then of course as adapt_mesh=0, no finer scales can emerge.
filter_all_except_maxlevel=no;

[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;
; [none, Insect, cylinder, two-cylinders, rotating_cylinder] if "Insect", all other parameters are read from "Insect" section.
geometry=triangle;
; center coordinate of object
x_cntr=0.5 0.5 0;
; [triangle,rhombus,cylinder]: length or diameter of the object
length=0.3;


[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)
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; first cosine harmonic component used with yawpitchroll_param
yawpitchroll_b1=0.0 10.0 0.0; first sine harmonic component used with yawpitchroll_param
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;
;-------------------------------------------------------------------------------

[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_treecode=0;
; internal testing routine for the ghost nodes: allocates HUGE amounts of memory
check_redundant_nodes=0;