| Maabb | Axis Aligned Bounding Box (aabb) implementation in Fortran |
| Cmerge | Merge two aabbs |
| Cintersection | Intersect two aabbs |
| Caabb_t | Axis Aligned Bounding Box (aabb) data structure |
| Maabb_el_finder | |
| Caabb_el_finder_t | Implements global interpolation for arbitrary points in the domain |
| Maabb_pe_finder | Implements aabb_pe_finder given a dofmap |
| Caabb_pe_finder_t | Implements global interpolation for arbitrary points in the domain |
| Maabb_tree | Axis Aligned Bounding Box (aabb) Tree data structure |
| Caabb_node_t | Node type for the Axis Aligned Bounding Box (aabb) Tree |
| Caabb_tree_t | Axis Aligned Bounding Box (aabb) Tree |
| Mab_time_scheme | Adam-Bashforth scheme for time integration |
| Cab_time_scheme_t | Explicit Adam-Bashforth scheme for time integration |
| Madv_dealias | Subroutines to add advection terms to the RHS of a transport equation |
| Cadv_dealias_t | Type encapsulating advection routines with dealiasing |
| Madv_dummy | Implements adv_dummy_t |
| Cadv_dummy_t | A zero-valued advection that can be used to kill the advection term |
| Madv_no_dealias | Subroutines to add advection terms to the RHS of a transport equation |
| Cadv_no_dealias_t | Type encapsulating advection routines with no dealiasing applied |
| Madv_oifs | Subroutines to add advection terms to the RHS of a transport equation |
| Cadv_oifs_t | |
| Madvection | Subroutines to add advection terms to the RHS of a transport equation |
| Cadvection_t | Base abstract type for computing the advection operator |
| Ccompute_adv | A factory for advection_t decendants. Both creates and initializes the object |
| Ccompute_scalar_adv | Add advection operator to the right-hand-side for a scalar |
| Ccompute_ale_adv | Add advection operator to the right-hand-side for moving mesh |
| Cadvection_recompute_metrics | Update any geometry/metric data inside the advection object. For eg., in ALE, maps the coef_GLL to coef_GL at each iteration for dealiasing |
| Cadvection_free | Destructor |
| Male_manager | ALE Manager: Handles Mesh Motion |
| Cale_manager_t | |
| Male_rigid_kinematics | Defines data structures and algorithms for configuring, calculating, and time-integrating the rigid-body motion (translation and rotation) of objects in an ALE simulation. CPU-only module |
| Cstiffness_geometry_t | Stiff Geometry |
| Cale_body_t | Configuration for a single moving body |
| Cale_config_t | Global ALE Configuration |
| Cbody_kinematics_t | Calculated Kinematics for a body at current time |
| Cpivot_state_t | State history for time-integration of pivots |
| Cpoint_tracker_t | Type for a tracked point linked to a body |
| Male_routines_device | |
| Ckinematics_params_t | |
| Cadd_kinematics_to_mesh_velocity_hip | |
| Ccompute_cheap_dist_hip | |
| Martificial_viscosity | Implements artificial_viscosity_t |
| Cartificial_viscosity_t | The handler for the artificial viscosity |
| Martificial_viscosity_model | Implements avm_t |
| Cavm_t | Base abstract type for artificial viscosity models |
| Cavm_preprocess | Perform artificial viscosity related computations before the time step |
| Cavm_compute | Perform artificial viscosity related computations after the time step |
| Cavm_init | Common constructor |
| Cavm_free | Destructor |
| Cavm_allocate | Artificial viscosity model allocator |
| Callocator_entry | Called in user modules to add an allocator for custom types |
| Mavm_simcomp | Implements the avm_simcomp_t type |
| Cavm_simcomp_t | A simulation component that drives the computation of the artificial viscosity method |
| Max_helm | |
| Cax_helm_t | Matrix-vector product for a Helmholtz problem |
| Max_helm_compr_cpu | CPU Helmholtz matrix-vector product on compressed geometric factors |
| Cax_helm_compr_cpu_t | CPU matrix-vector product for a Helmholtz problem, reading the geometric factors \( G_{ij} \) from their compressed form in coef_t |
| Max_helm_compr_device | Device Helmholtz matrix-vector product on compressed geometric factors |
| Cax_helm_compr_device_t | Device matrix-vector product for a Helmholtz problem, reading the geometric factors \( G_{ij} \) from their compressed form in coef_t |
| Chip_ax_helm_compr | |
| Chip_ax_helm_compr_vector | |
| Chip_ax_helm_vector_part2 | |
| Max_helm_compr_sx | SX Helmholtz matrix-vector product on compressed geometric factors |
| Cax_helm_compr_sx_t | SX matrix-vector product for a Helmholtz problem, reading the geometric factors \( G_{ij} \) from their compressed form in coef_t |
| Max_helm_cpu | |
| Cax_helm_cpu_t | CPU matrix-vector product for a Helmholtz problem |
| Max_helm_device | |
| Cax_helm_device_t | |
| Chip_ax_helm | |
| Chip_ax_helm_vector | |
| Chip_ax_helm_vector_part2 | |
| Max_helm_full | |
| Cax_helm_full_t | Matrix-vector product for a Helmholtz problem |
| Max_helm_full_cpu | |
| Cax_helm_full_cpu_t | CPU matrix-vector product for a Helmholtz problem with full stress tensor |
| Max_helm_full_device | |
| Cax_helm_full_device_t | |
| Chip_ax_helm_stress_vector | |
| Chip_ax_helm_stress_vector_part2 | |
| Max_helm_svv | Base type for an SVV Helmholtz operator |
| Cax_helm_svv_t | Helmholtz operator carrying a non-owning SVV object |
| Max_helm_svv_full | Defines the full-stress SVV Helmholtz operator |
| Cax_helm_svv_full_t | Matrix-vector product for a Helmholtz problem |
| Max_helm_svv_one_sided_cpu | CPU implementation of the one-sided SVV Helmholtz operator |
| Cax_helm_svv_one_sided_cpu_t | CPU one-sided SVV Helmholtz operator |
| Max_helm_svv_one_sided_device | |
| Cax_helm_svv_one_sided_device_t | Device matrix-vector product for an SVV Helmholtz problem |
| Chip_ax_helm_svv_one_sided | |
| Max_helm_svv_one_sided_full_cpu | CPU implementation of the full-stress one-sided SVV Helmholtz operator |
| Cax_helm_svv_one_sided_full_cpu_t | CPU matrix-vector product for a Helmholtz problem |
| Max_helm_svv_one_sided_full_device | Device implementation of the full-stress one-sided SVV operator |
| Cax_helm_svv_one_sided_full_device_t | Device one-sided full-stress SVV Helmholtz operator |
| Chip_ax_helm_svv_one_sided_full | |
| Max_helm_sx | |
| Cax_helm_sx_t | |
| Max_helm_template | Template for a user-defined Helmholtz matrix-vector product |
| Cax_helm_template_t | A scalar Helmholtz-like operator. Extending ax_helm_t supplies compute_vector by applying compute to each component independently |
| Max_helm_xsmm | |
| Cax_helm_xsmm_t | |
| Max_product | Defines a Matrix-vector product |
| Cax_t | Base type for a matrix-vector product providing \( Ax \) |
| Cax_helm_allocate | Allocate a Helmholtz problem matrix-vector product. The implementation is selected by name and compute backend |
| Cax_helm_allocator_entry | Called in user modules to add an allocator for custom types |
| Cax_compute | Abstract interface for computing \( Ax \) inside a Krylov method |
| Cax_compute_vector | Abstract interface for computing \( Ax \) inside a Krylov method, taking 3 components of a vector field in a coupled manner |
| Mbc | Defines a boundary condition |
| Cbc_t | Base type for a boundary condition |
| Cbc_ptr_t | Pointer to a `bc_t` |
| Cbc_alloc_t | |
| Cbc_constructor | Constructor |
| Cbc_destructor | Destructor |
| Cbc_finalize | Finalize by building the mask and facet arrays |
| Cbc_apply_scalar | Apply the boundary condition to a scalar field |
| Cbc_apply_vector | Apply the boundary condition to a vector field |
| Cbc_apply_scalar_dev | Apply the boundary condition to a scalar field on the device |
| Cbc_apply_vector_dev | Apply the boundary condition to a vector field on the device |
| Mbc_list | Defines a list of bc_t |
| Cbc_list_t | A list of allocatable `bc_t`. Follows the standard interface of lists |
| Mbdf_time_scheme | Backward-differencing scheme for time integration |
| Cbdf_time_scheme_t | Implicit backward-differencing scheme for time integration |
| Mbicgstab | Provides a CPU implementation of the BiCGStab method |
| Cbicgstab_t | CPU implementation of the right-preconditioned BiCGStab method |
| Mbicgstab_cpld | Provides a coupled CPU implementation of the BiCGStab method |
| Cbicgstab_cpld_t | Coupled right-preconditioned CPU BiCGStab method |
| Mbicgstab_device | Provides a device implementation of the BiCGStab method |
| Cbicgstab_device_t | Device implementation of the right-preconditioned BiCGStab method |
| Chip_bicgstab_update_p | |
| Chip_bicgstab_product_and_norm | |
| Chip_bicgstab_part1 | |
| Chip_bicgstab_part2 | |
| Mblasius | Defines a Blasius profile dirichlet condition |
| Cblasius_t | Blasius profile for inlet (vector valued) |
| Mboundary_data | Implements the boundary_data_t type |
| Cboundary_data_t | Collects data on the boundary points of one or more labelled zones and perform some bounary operations |
| Mboundary_data_writer_simcomp | Implements the boundary_data_writer_t type |
| Cboundary_data_writer_t | A simulation component that writes registry fields sampled on labelled boundary zones. The component builds a mask over the requested labelled zones and, at every output, samples the requested quantities at the boundary GLL points. The result is written either as CSV or as HDF5 |
| Mboundary_flux | Implements boundary_flux_t |
| Cboundary_flux_t | A simulation component for total vector flux through labelled zones |
| Mboundary_operation | Implements boundary_operation_t |
| Cboundary_operation_t | A simulation component for boundary reductions on labelled zones |
| Mboussinesq_source_term | Implements the boussinesq_source_term_t type |
| Cboussinesq_source_term_t | Bouyancy source term accroding to the Boussinesq approximation |
| Mbox_point_zone | |
| Cbox_point_zone_t | A box-shaped point zone |
| Mbp_file | ADIOS2 bp file format |
| Cbp_file_t | Interface for ADIOS2 bp files |
| Mbrinkman_source_term | Implements the brinkman_source_term_t type |
| Cbrinkman_source_term_t | A Brinkman source term. The region and strength are controlled by assigning regions types and brinkman limits to the source term |
| Mbuffer | Generic buffer that is extended with buffers of varying rank |
| Cbuffer_t | |
| Mbuffer_1d | Generic buffer that is extended with buffers of varying rank |
| Cbuffer_1d_t | |
| Mbuffer_4d | Generic buffer that is extended with buffers of varying rank |
| Cbuffer_4d_t | |
| Mbuffer_4d_npar | Generic buffer that is extended with buffers of varying rank |
| Cbuffer_4d_npar_t | |
| Mcacg | Defines a communication avoiding Conjugate Gradient method |
| Ccacg_t | S-step communication avoiding preconditioned conjugate gradient method |
| Mcai_sagaut_model_ii | Implements cai_sagaut_model_ii_t |
| Ccai_sagaut_model_ii_t | Explicit wall model based on Model-II from Cai and Sagaut (2021) |
| Mcai_sagaut_model_ii_device | Device dispatch for cai_sagaut_model_ii_t |
| Chip_cai_sagaut_model_ii_compute | |
| Mcartesian_el_finder | |
| Ccartesian_el_finder_t | |
| Mcartesian_pe_finder | Implements cartesian_pe_finder given a dofmap |
| Ci8_mpi_t | |
| Ccartesian_pe_finder_t | Implements global interpolation for arbitrary points in the domain |
| Mcase | Defines a simulation case |
| Ccase_t | |
| Mcentrifugal_source_term | Implements the centrifugal_source_term_t type. Maintainer: Adam Peplinski |
| Ccentrifugal_source_term_t | This source term adds the centrifugal force |
| Mcg | Defines various Conjugate Gradient methods |
| Ccg_t | CPU implementation of the preconditioned conjugate gradient method |
| Mcg_cpld | Defines a coupled Conjugate Gradient method |
| Ccg_cpld_t | CPU implementation of the coupled preconditioned conjugate gradient method |
| Mcg_cpld_device | Defines a coupled Conjugate Gradient methods for accelerators |
| Ccg_cpld_device_t | Device based coupled preconditioned conjugate gradient method |
| Mcg_device | Defines various Conjugate Gradient methods for accelerators |
| Ccg_device_t | Device based preconditioned conjugate gradient method |
| Mcg_sx | Defines various Conjugate Gradient methods |
| Csx_cg_t | Standard preconditioned conjugate gradient method (SX version) |
| Mcheby | Chebyshev preconditioner |
| Ccheby_t | Defines a Chebyshev preconditioner |
| Mcheby_device | Chebyshev preconditioner |
| Ccheby_device_t | Defines a Chebyshev preconditioner |
| Chip_cheby_device_part1 | |
| Chip_cheby_device_part2 | |
| Mcheckpoint | Defines format-independent checkpoint registration and restart state |
| Cchkp_t | Collection of live simulation data registered for checkpointing |
| Mcheckpoint_payload | Format-independent checkpoint payloads |
| Ccheckpoint_array_t | A named real array and its selection in a global checkpoint dataset |
| Ccheckpoint_array_ptr_t | Pointer wrapper around checkpoint_array_t |
| Ccheckpoint_mesh_array_t | A named nodal real array distributed over mesh elements |
| Ccheckpoint_mesh_array_ptr_t | Pointer wrapper around checkpoint_mesh_array_t |
| Ccheckpoint_payload_t | A named collection of live fields to checkpoint together |
| Ccheckpoint_payload_ptr_t | Pointer wrapper used to keep payload addresses stable as the list grows |
| Mchkp_file | Neko legacy checkpoint file format |
| Clegacy_checkpoint_view_t | Temporary view of the payloads required by the positional .chkp format |
| Cchkp_file_t | Interface for Neko legacy checkpoint files |
| Mchkp_output | Defines an output for a checkpoint |
| Cchkp_output_t | |
| Mcoefs | Coefficients |
| Ccoef_t | Coefficients defined on a given (mesh, \( X_h \)) tuple. Arrays use indices (i,j,k,e): element e, local coordinate (i,j,k) |
| Mcombine_point_zone | |
| Ccombine_point_zone_t | A point zone that combines different point zones |
| Mcomm | |
| Cneko_comm_wrapper_init | |
| Mcompressible_ops_device | Device implementation of compressible flow operations |
| Chip_compute_max_wave_speed | |
| Chip_compute_entropy | |
| Chip_update_uvw | |
| Chip_update_mxyz_p_ruvw | |
| Chip_update_e | |
| Chip_update_temperature | |
| Chip_ns_flux_prepare | |
| Chip_ns_flux_finalize | |
| Chip_ns_flux_temperature | |
| Mcompressible_res_cpu | This implements CPU-based residual calculations for the compressible equations. It handles the time advancement of primitive variables using Runge-Kutta methods and evaluates the right-hand side terms of the compressible equations including artificial viscosity |
| Ccompressible_res_cpu_t | |
| Mcompressible_res_device | |
| Ccompressible_res_device_t | |
| Ccompressible_res_part_visc_hip | |
| Cinviscid_res_part_mx_flux_hip | |
| Cinviscid_res_part_my_flux_hip | |
| Cinviscid_res_part_mz_flux_hip | |
| Cinviscid_res_part_e_flux_hip | |
| Ccompressible_res_part_coef_mult_hip | |
| Ccompressible_res_part_rk_sum_hip | |
| Mcompressible_residual | |
| Ccompressible_rhs_t | Abstract type to compute rhs |
| Ccompressible_rhs | Abstract interface to evaluate rhs |
| Mconst_source_term | Implements the const_source_term_t type |
| Cconst_source_term_t | A constant source term. The strength is specified with the values keyword, which should be an array, with a value for each component of the source |
| Mcoriolis_source_term | Implements the coriolis_source_term_t type. Maintainer: Timofey Mukha |
| Ccoriolis_source_term_t | This source term adds the Coriolis force |
| Mcpr | Compression |
| Ccpr_t | Include information needed for compressing fields |
| Ccpr_init | |
| Mcsv_file | File format for .csv files, used for any read/write operations involving floating point data |
| Ccsv_file_t | |
| Mcuda_intf | Fortran CUDA interface |
| Ccudamalloc | |
| Ccudafree | |
| Ccudamemcpy | |
| Ccudamemcpyasync | |
| Ccudamemsetasync | |
| Ccudadevicesynchronize | |
| Ccudadevicereset | |
| Ccuda_buffer_free_all | |
| Ccudagetdeviceproperties | |
| Ccudastreamcreate | |
| Ccudastreamcreatewithflags | |
| Ccudastreamcreatewithpriority | |
| Ccudastreamdestroy | |
| Ccudastreamsynchronize | |
| Ccudastreamwaitevent | |
| Ccudadevicegetstreampriorityrange | |
| Ccudaprofilerstart | |
| Ccudaprofilerstop | |
| Ccudaeventcreate | |
| Ccudaeventdestroy | |
| Ccudaeventcreatewithflags | |
| Ccudaeventrecord | |
| Ccudaeventsynchronize | |
| Ccudagetdevicecount | |
| Ccuda_device_mp_count | Number of streaming multiprocessors of the current device (0 if unknown), see device/cuda/props.cu |
| Ccuda_device_total_mem | Total memory of the current device in bytes (0 if unknown), see device/cuda/props.cu |
| Ccudagetdevice | |
| Ccudasetdevice | |
| Mcuda_mappings | Cuda interface binding for mappings |
| Ccuda_smooth_step | |
| Ccuda_step_function | |
| Ccuda_permeability | |
| Mcuda_math | |
| Ccuda_copy | |
| Ccuda_masked_copy_0 | |
| Ccuda_masked_copy_aligned | |
| Ccuda_masked_gather_copy | |
| Ccuda_masked_gather_copy_aligned | |
| Ccuda_face_masked_gather_copy | |
| Ccuda_masked_scatter_copy | |
| Ccuda_masked_scatter_copy_aligned | |
| Ccuda_masked_atomic_reduction | |
| Ccuda_cfill_mask | |
| Ccuda_cmult | |
| Ccuda_cmult2 | |
| Ccuda_cdiv | |
| Ccuda_cdiv2 | |
| Ccuda_radd | |
| Ccuda_cadd2 | |
| Ccuda_cwrap | |
| Ccuda_sqrt_inplace | |
| Ccuda_power | |
| Ccuda_cfill | |
| Ccuda_rzero | |
| Ccuda_add2 | |
| Ccuda_add4 | |
| Ccuda_add2s1 | |
| Ccuda_add2s2 | |
| Ccuda_addsqr2s2 | |
| Ccuda_add3s2 | |
| Ccuda_add4s3 | |
| Ccuda_add5s4 | |
| Ccuda_invcol1 | |
| Ccuda_invcol2 | |
| Ccuda_invcol3 | |
| Ccuda_col2 | |
| Ccuda_col3 | |
| Ccuda_subcol3 | |
| Ccuda_sub2 | |
| Ccuda_sub3 | |
| Ccuda_add3 | |
| Ccuda_addcol3 | |
| Ccuda_addcol4 | |
| Ccuda_addcol3s2 | |
| Ccuda_vdot3 | |
| Ccuda_vcross | |
| Ccuda_vlsc3 | |
| Ccuda_add2s2_many | |
| Ccuda_glsc3 | |
| Ccuda_glsc3_many | |
| Ccuda_glsc2 | |
| Ccuda_glsubnorm2 | |
| Ccuda_glsum | |
| Ccuda_glmax | |
| Ccuda_glamax | |
| Ccuda_glmin | |
| Ccuda_absval | |
| Ccuda_pwmax_vec2 | |
| Ccuda_pwmax_vec3 | |
| Ccuda_pwmax_sca2 | |
| Ccuda_pwmax_sca3 | |
| Ccuda_pwmin_vec2 | |
| Ccuda_pwmin_vec3 | |
| Ccuda_pwmin_sca2 | |
| Ccuda_pwmin_sca3 | |
| Ccuda_iadd | |
| Mcurl_simcomp | Implements the curl_t type |
| Ccurl_t | A simulation component that computes the curl of a vector field. Added to the field registry as curl_x, curl_y``, and curl_z` by default, but can be controlled by the computed_field keyword |
| Mcurve | Defines a domain as a subset of facets in a mesh |
| Ccurve_t | |
| Mcustom_types | In this module we implement a custom source term, my_source_term and prep it for being recognized by Neko at run time. The source term doesn't really do anything, we just show how such a thing could be done |
| Cmy_source_term_t | |
| Mcylinder_point_zone | Implements a cylinder geometry subset |
| Ccylinder_point_zone_t | A cylindrical point zone |
| Mdata_streamer | Implements type data_streamer_t |
| Cdata_streamer_t | Provides access to data streaming by interfacing with c++ ADIOS2 subroutines |
| Mdata_streamer_simcomp | A simulation component that streams data using ADIOS2 |
| Cdata_streamer_simcomp_t | |
| Mdatadist | Defines practical data distributions |
| Cdist_t | |
| Clinear_dist_t | Load-balanced linear distribution \( M = PL + R \) |
| Mdeardorff | Implements deardorff_t |
| Cdeardorff_t | Implements the deardorff LES model |
| Mderivative_simcomp | Implements the derivative_t type |
| Cderivative_t | A simulation component that computes a derivative of a field. Wraps the duxyz operator |
| Mdevice | Device abstraction, common interface for various accelerators |
| Cdevice_memcpy | Copy data between host and device (or device and device) |
| Cdevice_map | Map a Fortran array to a device (allocate and associate) |
| Cdevice_unmap | Unmap a Fortran array from a device (deassociate and free) |
| Cdevice_associate | Associate a Fortran array to a (allocated) device pointer |
| Cdevice_associated | Check if a Fortran array is assoicated with a device pointer |
| Cdevice_deassociate | Deassociate a Fortran array from a device pointer |
| Cdevice_get_ptr | Return the device pointer for an associated Fortran array |
| Cdevice_sync | Synchronize a device or stream |
| Mdevice_array | Module containing device only array type |
| Cdevice_array_t | Device-only temporary array |
| Mdevice_coef | |
| Chip_coef_generate_geo | |
| Chip_coef_generate_dxyzdrst | |
| Chip_coef_generate_mass | |
| Chip_coef_generate_area_and_normal | |
| Chip_coef_get_normal | |
| Mdevice_constrain_mixed_bc | Device wrappers for basis-aware mixed boundary-condition constraint kernels. These routines operate on a resolved mixed-node mask together with a local orthonormal basis stored as nodewise normal and tangent vectors. They are used to impose homogeneous or prescribed constraints on vector fields in the local (n, t1, t2) basis on device backends |
| Chip_constrain_mixed_bc_zero | |
| Chip_constrain_mixed_bc_set | |
| Chip_constrain_mixed_bc_set_const | |
| Mdevice_coupled_vector_bc_projector | |
| Chip_coupled_vector_bc_projector_apply | |
| Mdevice_deardorff_nut | Device kernel wrapper for computing Deardorff SGS quantities |
| Chip_deardorff_nut_compute | |
| Mdevice_dirichlet | |
| Chip_dirichlet_apply_scalar | |
| Chip_dirichlet_apply_vector | |
| Mdevice_dong_outflow | |
| Chip_dong_outflow_apply_scalar | |
| Mdevice_dynamic_smagorinsky_nut | |
| Chip_s_abs_compute | |
| Chip_lij_compute_part1 | |
| Chip_lij_compute_part2 | |
| Chip_mij_compute_part1 | |
| Chip_mij_nut_compute_part2 | |
| Mdevice_facet_normal | |
| Chip_facet_normal_apply_surfvec | |
| Mdevice_gradient_jump_penalty | |
| Chip_pick_facet_value_hex | |
| Chip_gradient_jump_penalty_finalize | |
| Mdevice_identity | Identity Krylov preconditioner for accelerators |
| Cdevice_ident_t | Defines a canonical Krylov preconditioner for accelerators |
| Mdevice_inflow | |
| Chip_inflow_apply_vector | |
| Mdevice_inhom_dirichlet | Device backend wrappers for inhomogeneous Dirichlet boundary conditions |
| Chip_inhom_dirichlet_apply_vector | |
| Chip_inhom_dirichlet_apply_scalar | |
| Mdevice_jacobi | Jacobi preconditioner accelerator backend |
| Cdevice_jacobi_t | Defines a jacobi preconditioner |
| Chip_jacobi_update | |
| Ccuda_jacobi_update | |
| Copencl_jacobi_update | |
| Cmetal_jacobi_update | |
| Mdevice_local_interpolation | |
| Chip_find_rst_legendre | |
| Mdevice_math | |
| Cdevice_cadd | |
| Mdevice_mathops | |
| Chip_opchsign | |
| Chip_opcolv | |
| Chip_opcolv3c | |
| Chip_opadd2cm | |
| Chip_opadd2col | |
| Mdevice_neumann | |
| Chip_neumann_apply_scalar | |
| Chip_neumann_apply_vector | |
| Mdevice_projection | Interface for device projection |
| Chip_project_on | |
| Chip_project_ortho | |
| Mdevice_schwarz | |
| Chip_schwarz_extrude | |
| Chip_schwarz_toext3d | |
| Chip_schwarz_toreg3d | |
| Mdevice_sigma_nut | |
| Chip_sigma_nut_compute | |
| Mdevice_smagorinsky_nut | |
| Chip_smagorinsky_nut_compute | |
| Mdevice_symmetry_aligned | |
| Chip_symmetry_aligned_apply_vector | |
| Mdevice_tree_amg_smoother | Implements device kernels for use with TreeAMG smoothers |
| Chip_amg_cheby_solve_part1 | |
| Chip_amg_cheby_solve_part2 | |
| Mdevice_vreman_nut | |
| Chip_vreman_nut_compute | |
| Chip_vreman_nut_compute_buoy | |
| Mdevice_wale_nut | |
| Chip_wale_nut_compute | |
| Mdevice_zero_dirichlet | |
| Chip_zero_dirichlet_apply_scalar | |
| Chip_zero_dirichlet_apply_vector | |
| Mdirichlet | Defines a dirichlet boundary condition |
| Cdirichlet_t | Generic Dirichlet boundary condition \( x = g \) on \(\partial \Omega\) |
| Mdistdata | Distributed mesh data |
| Cdistdata_t | |
| Mdivergence_simcomp | Implements the divergence_t type |
| Cdivergence_t | A simulation component that computes the divergence of a vector field. Added to the field registry as div by default, bu can be controlled by the computed_field keyword |
| Mdofmap | Defines a mapping of the degrees of freedom |
| Cdofmap_t | |
| Mdong_outflow | Defines a dong outflow condition |
| Cdong_outflow_t | Dong outflow condition Follows "A Convective-like Energy-Stable Open Boundary Condition for
Simulations of Incompressible Flows" by S. Dong |
| Mdynamic_smagorinsky | Implements dynamic_smagorinsky_t |
| Cdynamic_smagorinsky_t | Implements the dynamic Smagorinsky LES model |
| Mel_finder | |
| Cel_finder_t | Base type for element finder providing element candidates for a given point in the domain |
| Cel_finder_free | |
| Cel_finder_find | |
| Cel_finder_find_batch | |
| Melement | |
| Celement_t | Base type for an element |
| Celement_diameter | |
| Celement_centroid | |
| Celement_equal | |
| Celement_facet_id | |
| Celement_facet_order | |
| Melementwise_filter | Implements elementwise_filter_t |
| Celementwise_filter_t | Implements the elementwise filter for SEM |
| Mentity | |
| Centity_t | Base type for an entity |
| Mentropy_viscosity | Implements the entropy-based artificial viscosity model |
| Centropy_viscosity_t | Entropy-based artificial viscosity model for compressible flow |
| Mentropy_viscosity_device | Device backend for entropy viscosity regularization |
| Chip_entropy_visc_compute_residual | |
| Chip_entropy_visc_compute_viscosity | |
| Chip_entropy_visc_apply_element_max | |
| Chip_entropy_visc_clamp_to_low_order | |
| Chip_entropy_visc_smooth_divide | |
| Mexpression | Evaluation of mathematical expressions given as strings in the case file |
| Ctoken_t | A single token of an expression |
| Cparser_t | State of the recursive descent parser |
| Cexpression_t | A compiled mathematical expression |
| Mexpression_dirichlet | Defines a Dirichlet condition prescribed by a mathematical expression |
| Cexpression_dirichlet_t | Dirichlet condition \( x = g(x, y, z, t) \) on \(\partial \Omega\), where \( g \) is a mathematical expression given in the case file |
| Mexpression_dirichlet_vector | Defines a vector valued Dirichlet condition prescribed by mathematical expressions |
| Cexpression_dirichlet_vector_t | Vector valued Dirichlet condition, with one mathematical expression per component, given in the case file |
| Mext_time_scheme | Explicit extrapolation scheme for time integration |
| Cext_time_scheme_t | Explicit extrapolation scheme for time integration |
| Mfacet_normal | Dirichlet condition applied in the facet normal direction |
| Cfacet_normal_t | Dirichlet condition in facet normal direction |
| Mfacet_zone | Defines a zone as a subset of facets in a mesh |
| Cfacet_zone_t | |
| Cfacet_zone_periodic_t | |
| Mfdm | Type for the Fast Diagonalization connected with the schwarz overlapping solves |
| Cfdm_t | |
| Csygv | |
| Mfdm_device | |
| Chip_fdm_do_fast | |
| Mfield | Defines a field |
| Cfield_t | |
| Cfield_ptr_t | Field_ptr_t, To easily obtain a pointer to a field |
| Cfield_wrapper_t | Field_wrapper_t, used to wrap an allocated field for use in a field list |
| Mfield_array | |
| Cfield_array_t | Field_array_t, To be able to group fields together |
| Mfield_dirichlet | Defines user dirichlet condition for a scalar field |
| Cfield_dirichlet_t | User defined dirichlet condition, for which the user can work with an entire field. The type stores a separate dummy field field_bc, which is passed to the user routine and can be populated with arbitrary values. The boundary condition then copy-pastes these values to the actual solution field using the mask of the boundary condition. So, in the end, only the relevant boundary values are updated |
| Cfield_dirichlet_update | Abstract interface defining a dirichlet condition on a list of fields |
| Mfield_dirichlet_vector | Defines inflow dirichlet conditions |
| Cfield_dirichlet_vector_t | Extension of the user defined dirichlet condition field_dirichlet |
| Mfield_list | |
| Cfield_list_t | Field_list_t, To be able to group fields together |
| Mfield_neumann | Defines user neumann condition for a scalar field |
| Cfield_neumann_t | User defined neumann condition, for which the user can work with an entire field. The type stores a separate dummy field field_bc, which is passed to the user routine and can be populated with arbitrary values. The boundary condition then gathers these values at the bc mask locations into a compact flux vector and applies the weak neumann contribution |
| Cfield_neumann_update | Abstract interface defining a neumann condition on a list of fields |
| Mfield_output | Implements field_output_t |
| Cfield_output_t | A simple output saving a list of fields to a file |
| Mfield_series | Contains the field_serties_t type |
| Cfield_series_t | Stores a series (sequence) of fields, logically connected to a base field, and arranged according to some ordering. Currently used to store time-lagged values of solution fields |
| Cfield_series_ptr_t | A wrapper for a pointer to a field_series_t |
| Mfield_series_list | Contains the field_series_list_t type for managing multiple field series |
| Cfield_series_list_t | A list of field series pointers, used for managing multiple scalar lag fields |
| Mfield_source_term | Implements the field_source_term_t type |
| Cfield_source_term_t | A source term that grabs the values from fields in the registry. The fields are specified with the field_names keyword, which should be an array, with a value for each component of the source |
| Mfield_subsampler | Implements type field_subsampler_t |
| Cfield_subsampler_t | Implements the field_subsampler_t simulation components, which allows for masking regions of the domain with a point_zone and to re-sample fields with a different polynomial order |
| Ccompute_intrf | Abstract interface for the compute() subroutine, which will be assigned at runtime depending on the subsampling method used |
| Mfield_writer | Implements the field_writer_t type |
| Cfield_writer_t | A simulation component that writes a 3d field to a file |
| Mfile | Module for file I/O operations |
| Cfile_t | A wrapper around a polymorphic generic_file_t that handles its init. This is essentially a factory for generic_file_t descendants additionally handling special CSV file parameters (header and precision) |
| Mfilter | Filter to be applied to a scalar field |
| Cfilter_t | Base abstract class for filter |
| Cfilter_init | The common constructor using a JSON dictionary |
| Cfilter_free | Destructor |
| Cfilter_apply | The application of the filter |
| Mfld_file | NEKTON fld file format |
| Cfld_file_t | Interface for NEKTON fld files |
| Mfld_file_data | Simple module to handle fld file series. Provides an interface to the different fields sotred in a fld file Also provides simple functions to scale and add different fld files. An example of using this module is shown in contrib/average_fields.f90 The fld_file_data_t should dynamically update each time one reads a new fld file. Martin Karp 1/2-2023 |
| Cfld_file_data_t | |
| Mfld_file_output | Implements fld_file_output_t |
| Cfld_file_output_t | A simple output saving a list of fields to a .fld file |
| Mflow_ic | Initial flow condition |
| Cset_flow_ic | |
| Mflow_profile | Defines a flow profile |
| Cblasius_profile | Abstract interface for computing a Blasius flow profile |
| Mfluid_output | Defines an output for a fluid |
| Cfluid_output_t | Fluid output |
| Mfluid_plan1 | Classic NEKTON formulation Compute pressure and velocity using consistent approximation spaces |
| Cfluid_plan1_t | |
| Mfluid_pnpn | Modular version of the Classic Nek5000 Pn/Pn formulation for fluids |
| Cfluid_pnpn_t | |
| Cfluid_pnpn_bc_allocate | Split a boundary condition entry of the case file into a velocity part and a pressure part |
| Cfluid_pnpn_bc_allocator_entry | Called in user modules to add an allocator for custom velocity boundary condition types |
| Mfluid_pnpn_bc_template | Template for a user-defined fluid Pn/Pn velocity boundary condition. A pressure condition is registered the same way, with register_fluid_pnpn_pressure_bc instead of register_fluid_pnpn_velocity_bc |
| Cfluid_pnpn_bc_template_t | A user-defined fluid Pn/Pn velocity boundary condition |
| Mfluid_scheme_base | |
| Cfluid_scheme_base_t | Base type of all fluid formulations |
| Cfluid_base_init_all_intrf | Initialize all fields |
| Cfluid_base_init_common_intrf | Initialize common data for the current scheme |
| Cfluid_base_free_intrf | Deallocate a fluid formulation |
| Cfluid_scheme_base_init_intrf | Abstract interface to initialize a fluid formulation |
| Cfluid_scheme_base_free_intrf | Abstract interface to dealocate a fluid formulation |
| Cfluid_scheme_base_step_intrf | Abstract interface to compute a time-step |
| Cfluid_scheme_base_restart_intrf | Abstract interface to restart a fluid scheme |
| Cfluid_scheme_base_set_user_initial_condition_intrf | Abstract interface to set the initial condition of a fluid scheme with the user routine |
| Cfluid_scheme_setup_bcs_intrf | Abstract interface to setup boundary conditions |
| Cvalidate_intrf | Abstract interface to validate the user inflow |
| Cupdate_material_properties | Abstract interface to sets rho and mu |
| Cfluid_scheme_base_compute_cfl_intrf | Compute the CFL number |
| Mfluid_scheme_compressible | |
| Cfluid_scheme_compressible_t | Base type of compressible fluid formulations |
| Mfluid_scheme_compressible_ns | |
| Cfluid_scheme_compressible_ns_t | |
| Mfluid_scheme_incompressible | Fluid formulations |
| Cfluid_scheme_incompressible_t | Base type of all fluid formulations |
| Mfluid_sgs_stats | Computes the subgrid-scale contributions for Reynolds stresses. We use the Reynolds decomposition for a field u = + u' = U + u' |
| Cfluid_sgs_stats_t | |
| Mfluid_sgs_stats_output | Implements fluid_sgs_stats_ouput_t |
| Cfluid_sgs_stats_output_t | Defines an output for the sgs statistics for fluid computed using the fluid_sgs_stats_t object |
| Mfluid_sgs_stats_simcomp | Implements the fluid_sgs_stats_simcomp_t type |
| Cfluid_sgs_stats_simcomp_t | A simulation component that computes the subgrid-scale contributions to the Reynolds stresses in LES |
| Mfluid_source_term | Implements the fluid_source_term_t type |
| Cfluid_source_term_t | Wrapper contaning and executing the fluid source terms |
| Mfluid_stats | Computes various statistics for the fluid fields. We use the Reynolds decomposition for a field u = + u' = U + u' Spatial derivatives i.e. du/dx we denote dudx |
| Cfluid_stats_t | |
| Mfluid_stats_output | Implements fluid_stats_ouput_t |
| Cfluid_stats_output_t | Defines an output for the fluid statistics computed using the fluid_stats_t object |
| Mfluid_stats_simcomp | Implements the fluid_stats_simcomp_t type |
| Cfluid_stats_simcomp_t | A simulation component that computes the velocity and pressure statistics up to 4th order. Can be used to reconstruct the term budget of transport equations for, e.g. the Reynolds stresses and the turbulent kinetic energy |
| Mfluid_volflow | |
| Cfluid_volflow_t | Defines volume flow |
| Mforce_torque | Implements the force_torque_t type |
| Cforce_torque_t | A simulation component that computes the force and torque on a given boundary zone |
| Mfusedcg_cpld_device | Defines a fused Conjugate Gradient method for accelerators |
| Cfusedcg_cpld_device_t | Fused preconditioned conjugate gradient method |
| Ccuda_fusedcg_cpld_part1 | |
| Ccuda_fusedcg_cpld_update_p | |
| Ccuda_fusedcg_cpld_update_x | |
| Ccuda_fusedcg_cpld_part2 | |
| Mfusedcg_device | Defines a fused Conjugate Gradient method for accelerators |
| Cfusedcg_device_t | Fused preconditioned conjugate gradient method |
| Ccuda_fusedcg_update_p | |
| Ccuda_fusedcg_update_x | |
| Ccuda_fusedcg_part2 | |
| Mgather_scatter | Gather-scatter |
| Cgs_t | Gather-scatter kernel |
| Mgeneric_file | |
| Cgeneric_file_t | A generic file handler |
| Cgeneric_file_write | |
| Cgeneric_file_read | |
| Mglb_intrp_comm | Defines global interpolation communication Based on the MPI based gather-scatter kernel |
| Cglb_intrp_comm_mpi_t | MPI buffer for non-blocking operations |
| Cglb_intrp_comm_t | Global interpolation communication method |
| Mglobal_interpolation | Implements global_interpolation given a dofmap |
| Cglobal_interpolation_settings_t | Implements the settings helper data container for global interpolation |
| Cglobal_interpolation_t | Implements global interpolation for arbitrary points in the domain |
| Mgmres | Implements gmres_t |
| Cgmres_t | CPU implementation of the preconditioned standard GMRES method |
| Mgmres_device | Defines various GMRES methods |
| Cgmres_device_t | Standard preconditioned generalized minimal residual method |
| Chip_gmres_part2 | |
| Mgmres_sx | Defines various GMRES methods |
| Csx_gmres_t | Standard preconditioned generalized minimal residual method (SX version) |
| Mgradient_jump_penalty | Implements gradient_jump_penalty_t |
| Cgradient_jump_penalty_t | Implements the gradient jump penalty |
| Mgradient_simcomp | Implements the gradient_t type |
| Cgradient_t | A simulation component that computes the gradient of a field. Wraps the gradient operator |
| Mgs_bcknd | Defines a gather-scatter backend |
| Cgs_bcknd_t | Gather-scatter backend |
| Cgs_backend_init | Abstract interface for initialising a Gather-Scatter backend |
| Cgs_backend_free | Abstract interface for deallocating a Gather-Scatter backend |
| Cgs_gather | Abstract interface for the Gather kernel \( v(dg(i)) = op(v(dg(i)), u(gd(i)) \) |
| Cgs_scatter | Abstract interface for the Scatter kernel \( u(gd(i) = v(dg(i)) \) |
| Mgs_caf | Defines Coarray Fortran gather-scatter communication |
| Cgs_caf_t | Gather-scatter communication using Coarray Fortran (F2008). Each image puts directly into the (module-level) receive coarray on the destination image. The signaling mode (NEKO_GS_CAF_SIGNALING) selects how segment ordering is established: sync uses sync
images over the union of send and recv peers, atomic uses per-peer atomic_define/atomic_ref on data_ready/buf_ready counters, and event uses coarray events |
| Mgs_comm | Defines a gather-scatter communication method |
| Cgs_comm_t | Gather-scatter communication method |
| Cgs_comm_init | Abstract interface for initializing a Gather-scatter communication method |
| Cgs_comm_free | Abstract interface for deallocating a Gather-scatter communication method |
| Cgs_nbsend | Abstract interface for initiating non-blocking send operations Sends the values in u(send_dof(send_pe(i))) to each rank send_pe(i) for all ranks in send_pe |
| Cgs_nbrecv | Abstract interface for initiating non-blocking recieve operations Posts non-blocking recieve of values and puts the values into buffers |
| Cgs_nbwait | Abstract interface for waiting on non-blocking operations Waits and checks that data is in buffers and unpacks buffers into correct location in u u(recv_dof(recv_pe(i))) = gs_op(recieve_buffers(recv_pe) for this dof) |
| Mgs_cpu | Generic Gather-scatter backend for CPUs |
| Cgs_cpu_t | Gather-scatter backend for CPUs |
| Mgs_crystal | Defines crystal router gather-scatter communication |
| Cgs_crystal_t | Gather-scatter communication using a crystal router |
| Mgs_crystal_plan | Routing plan for the crystal router gather-scatter comm. backends |
| Cgs_crystal_stage_t | One active communication stage of the routing plan |
| Cgs_crystal_plan_t | The full routing plan for one gather-scatter schedule |
| Mgs_device | Generic Gather-scatter backend for accelerators |
| Cgs_device_t | Gather-scatter backend for offloading devices |
| Chip_gather_kernel | |
| Chip_scatter_kernel | |
| Mgs_device_crystal | Defines GPU aware crystal router gather-scatter communication |
| Cgs_device_crystal_t | Gather-scatter communication using a crystal router on the device |
| Chip_gs_pack | |
| Chip_gs_unpack | |
| Chip_gs_pack_vec | |
| Chip_gs_unpack_vec | |
| Cdevice_mpi_init_reqs | |
| Cdevice_mpi_free_reqs | |
| Cdevice_mpi_isend | |
| Cdevice_mpi_irecv | |
| Cdevice_mpi_waitall | |
| Mgs_device_mpi | Defines GPU aware MPI gather-scatter communication |
| Cgs_device_mpi_buf_t | Buffers for non-blocking communication and packing/unpacking |
| Cgs_device_mpi_t | Gather-scatter communication using device MPI. The arrays are indexed per PE like send_pe and @ recv_pe |
| Chip_gs_pack | |
| Chip_gs_unpack | |
| Chip_gs_pack_vec | |
| Chip_gs_unpack_vec | |
| Cdevice_mpi_init_reqs | |
| Cdevice_mpi_free_reqs | |
| Cdevice_mpi_isend | |
| Cdevice_mpi_irecv | |
| Cdevice_mpi_test | |
| Cdevice_mpi_waitall | |
| Cdevice_mpi_waitany | |
| Mgs_device_nccl | Defines NCCL based gather-scatter communication |
| Cgs_device_nccl_buf_t | Buffers for non-blocking communication and packing/unpacking |
| Cgs_device_nccl_t | Gather-scatter communication using NCCL The arrays are indexed per PE like send_pe and @ recv_pe |
| Chip_gs_pack | |
| Chip_gs_unpack | |
| Chip_gs_pack_vec | |
| Chip_gs_unpack_vec | |
| Cdevice_nccl_sendrecv | |
| Mgs_device_shmem | Defines GPU aware MPI gather-scatter communication |
| Cgs_device_shmem_buf_t | Buffers for non-blocking communication and packing/unpacking |
| Cgs_device_shmem_t | Gather-scatter communication using device SHMEM. The arrays are indexed per PE like send_pe and @ recv_pe |
| Ccudamalloc_nvshmem | |
| Ccudafree_nvshmem | |
| Ccuda_gs_nvshmem_pack | |
| Ccuda_gs_nvshmem_pack_vec | |
| Ccuda_gs_push | |
| Ccuda_gs_push_wait | |
| Ccuda_gs_post_ready | |
| Ccuda_gs_unpack | |
| Ccuda_gs_unpack_vec | |
| Mgs_mpi | Defines MPI gather-scatter communication |
| Cgs_mpi_t | Gather-scatter communication using MPI |
| Mgs_mpi_rma | Defines MPI one-sided (RMA) gather-scatter communication |
| Cgs_mpi_rma_t | Gather-scatter communication using MPI one-sided puts into a passive target window, with per-rank signalling for completion |
| Mgs_neighbour | Defines gather-scatter communication using MPI neighbourhood collectives |
| Cgs_neighbour_t | Gather-scatter communication using an MPI neighbourhood collective. The whole halo exchange is carried out by a single MPI_Ineighbor_alltoallv over a distributed-graph communicator built once from the send/recv peer lists. Compared to the point-to-point gs_mpi_t this trades N Isend/Irecv pairs for one collective call: a single entry into the (serialised, on Fugaku) MPI runtime, leaving the library free to stripe the transfers across all network interfaces internally |
| Mgs_shmem | Defines OpenSHMEM gather-scatter communication |
| Cgs_shmem_buf_t | Symmetric buffer for one direction of OpenSHMEM communication |
| Cgs_shmem_t | Gather-scatter communication using OpenSHMEM one-sided puts with per-rank signaling for completion (OpenSHMEM 1.5) |
| Mgs_sx | Generic Gather-scatter backend for NEC Vector Engines |
| Cgs_sx_t | Gather-scatter backend for NEC SX-Aurora |
| Mgs_utofu | Defines a gather-scatter backend using the native Tofu interconnect (uTofu). Each rank registers its receive buffer once and a send is a single one-sided RDMA put straight into the neighbour's buffer, with the arrival signal fused into the descriptor (edata) instead of a separate atomic/credit message. Injection is non-blocking and thread-parallel: each OpenMP thread owns one injection VCQ (created thread-safe, dealt over the TNIs) and fires the puts for its share of the peers itself. The fused vector (multi-component) exchange of gs_op_r3 is supported through a second, independent context with its own buffers, receive VCQ, and parity. See gs_utofu_aux.c for the transport |
| Cgs_utofu_t | Gather-scatter communication using one-sided uTofu puts |
| Mhdf5_file | HDF5 file format |
| Chdf5_layout_t | Reusable distribution of a rank-ordered host array over NEKO_COMM. Counts are vector elements or matrix columns, not total matrix elements. Matrices distribute their second dimension; all ranks have the same number of rows and write every row of their local columns. Initialise collectively once, then reuse while every rank's local size and NEKO_COMM remain unchanged. Reinitialise after redistribution |
| Chdf5_dataset_t | Dataset resources retained while the active group remains open |
| Chdf5_file_t | Interface for HDF5 files |
| Chdf5_checkpoint_layout_t | Where the data in a checkpoint file sits and how it maps onto the running case. Built once per read and shared by every dataset in the file, so a mesh-to-mesh point search happens once rather than per field |
| Mhex | Defines a hexahedron element |
| Chex_t | Hexahedron element |
| Mhip_intf | Fortran HIP interface |
| Chipmalloc | |
| Chipfree | |
| Chipmap | Map host memory to the device (zero-copy on unified memory architectures, e.g. MI300A, see device/hip/unified.hip) |
| Chipmapfree | Free a device pointer obtained from hipMap (no-op for pointers aliasing host memory) |
| Chipmapmemset | Memset on a device pointer obtained from hipMap (host-side memset for pointers aliasing host memory) |
| Chipmapmemcpy | Copy between device/host pointers via the mapping layer (kernel-based copy under zero-copy, where either side may alias pageable host memory) |
| Chipmemcpy | |
| Chipmemcpyasync | |
| Chipmemsetasync | |
| Chipdevicesynchronize | |
| Chipdevicereset | |
| Chip_buffer_free_all | |
| Chipdevicegetname | |
| Chipgetdevicecount | |
| Chip_device_mp_count | Number of compute units of the current device (0 if unknown), see device/hip/props.hip |
| Chip_device_total_mem | Total memory of the current device in bytes (0 if unknown), see device/hip/props.hip |
| Chipstreamcreate | |
| Chipstreamcreatewithflags | |
| Chipstreamcreatewithpriority | |
| Chipstreamdestroy | |
| Chipstreamsynchronize | |
| Chipstreamwaitevent | |
| Chipdevicegetstreampriorityrange | |
| Chipeventcreate | |
| Chipeventdestroy | |
| Chipeventcreatewithflags | |
| Chipeventrecord | |
| Chipeventsynchronize | |
| Mhip_mappings | Hip interface binding for mappings |
| Chip_smooth_step | |
| Chip_step_function | |
| Chip_permeability | |
| Mhip_math | |
| Chip_copy | |
| Chip_masked_copy_0 | |
| Chip_masked_copy_aligned | |
| Chip_masked_gather_copy | |
| Chip_masked_gather_copy_aligned | |
| Chip_face_masked_gather_copy | |
| Chip_masked_scatter_copy | |
| Chip_masked_scatter_copy_aligned | |
| Chip_masked_atomic_reduction | |
| Chip_cfill_mask | |
| Chip_cmult | |
| Chip_cmult2 | |
| Chip_cdiv | |
| Chip_cdiv2 | |
| Chip_radd | |
| Chip_cadd2 | |
| Chip_cwrap | |
| Chip_sqrt_inplace | |
| Chip_power | |
| Chip_cfill | |
| Chip_rzero | |
| Chip_add2 | |
| Chip_add4 | |
| Chip_add2s1 | |
| Chip_add2s2 | |
| Chip_addsqr2s2 | |
| Chip_add3s2 | |
| Chip_add4s3 | |
| Chip_add5s4 | |
| Chip_invcol1 | |
| Chip_invcol2 | |
| Chip_invcol3 | |
| Chip_col2 | |
| Chip_col3 | |
| Chip_subcol3 | |
| Chip_sub2 | |
| Chip_sub3 | |
| Chip_add3 | |
| Chip_addcol3 | |
| Chip_addcol4 | |
| Chip_addcol3s2 | |
| Chip_vdot3 | |
| Chip_vcross | |
| Chip_vlsc3 | |
| Chip_add2s2_many | |
| Chip_glsc3 | |
| Chip_glsc3_many | |
| Chip_glsc2 | |
| Chip_glsubnorm2 | |
| Chip_glsum | |
| Chip_glmax | |
| Chip_glamax | |
| Chip_glmin | |
| Chip_absval | |
| Chip_pwmax_vec2 | |
| Chip_pwmax_vec3 | |
| Chip_pwmax_sca2 | |
| Chip_pwmax_sca3 | |
| Chip_pwmin_vec2 | |
| Chip_pwmin_vec3 | |
| Chip_pwmin_sca2 | |
| Chip_pwmin_sca3 | |
| Chip_iadd | |
| Mhost_array | Module containing host-only array type |
| Chost_array_t | Host-only temporary array |
| Mhpfrt_source_term | Implements the hpfrt_source_term_t type |
| Chpfrt_source_term_t | High-pass filter relaxation source term |
| Mhsmg | Krylov preconditioner |
| Cmultigrid_t | |
| Chsmg_t | |
| Mhtable | Implements a hash table ADT |
| Ch_tuple_t | Hash table entry, tuple (key, data) |
| Chtable_t | Base type for a hash table |
| Chtable_hash | |
| Chtable_i4_t | Integer based hash table |
| Chtable_i8_t | Integer*8 based hash table |
| Chtable_r8_t | Double precision based hash table |
| Chtable_pt_t | Point based hash table |
| Chtable_i4t2_t | Integer 2-tuple based hash table |
| Chtable_i4t4_t | Integer 4-tuple based hash table |
| Chtable_cptr_t | C pointer based hash table |
| Chtable_iter_t | Base type for a hash table iterator |
| Chtable_iter_i4_t | Iterator for an integer based hash table |
| Chtable_iter_i8_t | Iterator for an integer*8 based hash table |
| Chtable_iter_r8_t | Iterator for a double precision based hash table |
| Chtable_iter_pt_t | Iterator for a point based hash table |
| Chtable_iter_i4t2_t | Iterator for an integer based 2-tuple hash table |
| Chtable_iter_i4t4_t | Iterator for an integer based 4-tuple hash table |
| Chtable_iter_cptr_t | Iterator for a C pointer based hash table |
| Ch_cptr_t | |
| Midentity | Krylov preconditioner (identity) |
| Cident_t | Defines a canonical Krylov preconditioner |
| Miextm_time_scheme | |
| Ciextm_time_scheme_t | Explicit interface extrapolation scheme for overset grids |
| Mimport_field_utils | Importation of fields from fld files |
| Cimport_fields | |
| Minflow | Defines inflow dirichlet conditions |
| Cinflow_t | Dirichlet condition for inlet (vector valued) |
| Minterpolation | Routines to interpolate between different spaces |
| Cinterpolator_t | Interpolation between two space::space_t |
| Mintersection_detector | Implements a mesh intersection detector |
| Cintersect_detector_t | |
| Mjacobi | Jacobi preconditioner |
| Cjacobi_t | Defines a jacobi preconditioner |
| Mjobctrl | Job control |
| Cjobctrl_set_time_limit | |
| Mjson_utils | Utilities for retrieving parameters from the case files |
| Cjson_get | Retrieves a parameter by name or throws an error |
| Cjson_get_or_default | Retrieves a parameter by name or assigns a provided default value. In the latter case also adds the missing paramter to the json |
| Cjson_get_or_lookup | |
| Cjson_get_or_lookup_or_default | |
| Cjson_extract_item | |
| Mkrylov | Implements the base abstract type for Krylov solvers plus helper types |
| Cksp_monitor_t | Type for storing initial and final residuals in a Krylov solver |
| Cksp_t | Base abstract type for a canonical Krylov method, solving \( Ax = f \) |
| Cksp_init_intrf | Abstract interface for a Krylov method's constructor |
| Cksp_method | Abstract interface for a Krylov method's solve routine |
| Cksp_method_coupled | Abstract interface for a Krylov method's coupled solve routine |
| Cksp_t_free | Abstract interface for deallocating a Krylov method |
| Ckrylov_solver_factory | Factory for Krylov solvers. Both creates and initializes the object, either from its parameters or from a JSON solver block |
| Ckrylov_allocate | Krylov solver allocator |
| Ckrylov_allocator_entry | Called in user modules to add an allocator for custom types |
| Mkrylov_solver_template | Template for a user-defined Krylov solver |
| Ckrylov_solver_template_t | |
| Mlambda2 | A simulation component that computes lambda2 The values are stored in the field registry under the name 'lambda2' |
| Clambda2_t | |
| Mlegendre_rst_finder | |
| Clegendre_rst_finder_t | Type to compute local element (rst) coordinates for a gives set points in physical (xyz) space on a SEM grid |
| Mles_model | Implements les_model_t |
| Cles_model_t | Base abstract type for LES models based on the Boussinesq approximation |
| Cles_model_compute | Compute eddy viscosity |
| Cles_model_init | Common constructor |
| Cles_model_free | Destructor |
| Cles_model_allocate | LES model allocator |
| Callocator_entry | Called in user modules to add an allocator for custom types |
| Mles_model_template | Template for a user-defined LES model |
| Cles_model_template_t | |
| Mles_simcomp | Implements the les_simcomp_t type |
| Cles_simcomp_t | A simulation component that drives the computation of the SGS viscosity |
| Mlocal_interpolation | Routines to obtain interpolated values on a set of points with known rst coordinates in elements local to this process |
| Clocal_interpolator_t | Interpolation on a set of points with known rst coordinates in elements local to this process. Similar to point_interpolator, but prioritizes performance Only works with arrays of coordinates Performs interpolation with the configured NEKO_BCKND |
| Mlogger | Logging routines |
| Clog_t | |
| Mlpt | Implements lpt_t. (Lagrangian Particle Tracking) |
| Clpt_t | Passive Lagrangian particle tracking |
| Mlpt_migrate | Particle redistribution support for LPT |
| Clpt_migrate_t | |
| Mlpt_output | Output support for Lagrangian particle tracking |
| Clpt_output_t | |
| Mlpt_periodic_bc | Periodic and cyclic boundary-condition support for LPT |
| Clpt_periodic_bc_t | |
| Mlpt_periodic_bc_device | Device dispatch for LPT periodic boundary-condition wrapping |
| Chip_lpt_periodic_bc_wrap_translational | HIP kernel entry point for translational periodic wrapping |
| Chip_lpt_periodic_bc_wrap_rotational | HIP kernel entry point for rotational periodic wrapping |
| Mlpt_simcomp | Simulation-component handler for Lagrangian particle tracking |
| Clpt_simcomp_t | A simulation component that drives passive Lagrangian particle tracking |
| Mlpt_wall_collision_device | Device dispatch for LPT elastic wall-collision handling |
| Chip_lpt_handle_elastic_wall_collisions | HIP kernel entry point for elastic wall-collision reflection |
| Mmap | NEKTON map |
| Cmap_t | NEKTON vertex mapping |
| Mmap_1d | Creates a 1d GLL point map along a specified direction based on the connectivity in the mesh |
| Cmap_1d_t | Map every GLL point in the mesh to a level in one physical direction. Can be used to average across the two remaining directions |
| Mmap_2d | Maps a 3D dofmap to a 2D spectral element grid |
| Cmap_2d_t | |
| Mmap_file | NEKTON map file |
| Cmap_file_t | Interface for NEKTON map files |
| Mmask | Object for handling masks in Neko |
| Cmask_t | Type for consistently handling masks in Neko. This type encapsulates the mask array and its associated device pointer |
| Mmath | |
| Cabscmp | |
| Csort | |
| Cswap | |
| Creord | |
| Cflipv | |
| Crelcmp | |
| Mmatrix | Defines a matrix |
| Cmatrix_t | |
| Cmatrix_ptr_t | |
| Mmean_field | Implements mean_field_t |
| Cmean_field_t | Computes the temporal mean of a field |
| Mmean_field_output | Defines an output for a list of mean fields |
| Cmean_field_output_t | Output for a list of mean fields |
| Mmesh | Defines a mesh |
| Cmesh_element_t | |
| Cmesh_t | |
| Cmesh_deform | |
| Mmesh_field | Defines a mesh field |
| Cmesh_fld_t | |
| Mmetal_mappings | Metal interface binding for mappings |
| Cmetal_smooth_step | |
| Cmetal_step_function | |
| Cmetal_permeability | |
| Mmetal_math | |
| Cmetal_copy | |
| Cmetal_masked_copy_0 | |
| Cmetal_masked_gather_copy | |
| Cmetal_masked_gather_copy_aligned | |
| Cmetal_masked_scatter_copy | |
| Cmetal_masked_scatter_copy_aligned | |
| Cmetal_face_masked_gather_copy | |
| Cmetal_cwrap | |
| Cmetal_masked_atomic_reduction | |
| Cmetal_cfill_mask | |
| Cmetal_cmult | |
| Cmetal_cmult2 | |
| Cmetal_cdiv | |
| Cmetal_cdiv2 | |
| Cmetal_radd | |
| Cmetal_cadd2 | |
| Cmetal_cfill | |
| Cmetal_rzero | |
| Cmetal_add2 | |
| Cmetal_add4 | |
| Cmetal_add2s1 | |
| Cmetal_add2s2 | |
| Cmetal_addsqr2s2 | |
| Cmetal_add3s2 | |
| Cmetal_add4s3 | |
| Cmetal_add5s4 | |
| Cmetal_invcol1 | |
| Cmetal_invcol2 | |
| Cmetal_invcol3 | |
| Cmetal_col2 | |
| Cmetal_col3 | |
| Cmetal_subcol3 | |
| Cmetal_sub2 | |
| Cmetal_sub3 | |
| Cmetal_add3 | |
| Cmetal_addcol3 | |
| Cmetal_addcol4 | |
| Cmetal_addcol3s2 | |
| Cmetal_vdot3 | |
| Cmetal_vcross | |
| Cmetal_vlsc3 | |
| Cmetal_add2s2_many | |
| Cmetal_glsc3 | |
| Cmetal_glsc3_many | |
| Cmetal_glsc2 | |
| Cmetal_glsubnorm2 | |
| Cmetal_glsum | |
| Cmetal_glmax | |
| Cmetal_glamax | |
| Cmetal_glmin | |
| Cmetal_absval | |
| Cmetal_pwmax_vec2 | |
| Cmetal_pwmax_vec3 | |
| Cmetal_pwmax_sca2 | |
| Cmetal_pwmax_sca3 | |
| Cmetal_pwmin_vec2 | |
| Cmetal_pwmin_vec3 | |
| Cmetal_pwmin_sca2 | |
| Cmetal_pwmin_sca3 | |
| Cmetal_iadd | |
| Mmixed_bc | Implements mixed_bc_t |
| Cmixed_bc_t | Base type for mixed boundary conditions that need projector-provided local-basis data on the physical field |
| Mmost | Implements most_t |
| Cmost_t | Wall model based on the Monin-Obukhov Similarity Theory for atmospheric boundary layer flows. Automatically switches between stable, unstable and neutral layer formulations based on the Richardson number |
| Mmost_cpu | Implements the CPU kernel for the most_t type |
| Cslaw_m_interface | |
| Cslaw_h_interface | |
| Ccorr_m_interface | |
| Ccorr_h_interface | |
| Cf_interface | |
| Cdfdl_interface | |
| Mmost_device | Implements the device kernel for the most_t type |
| Chip_most_compute | |
| Mmxm_wrapper | Wrapper for all matrix-matrix product implementations |
| Cmxm_blas | |
| Cmxm_libxsmm | |
| Mneko_api_user | Neko API user callbacks |
| Capi_ic_callback | Abstract interface for initial condition callbacks |
| Capi_bc_callback | Abstract interface for boundary condition callbacks |
| Capi_ft_callback | Abstract interface for callbacks requiring a field list and time Used for material properties and source terms |
| Capi_gn_callback | Abstract interface for generic callbacks requiring only time Used for preprocess and compute callbacks |
| Capi_user_cb | Type defining all supported callbacks via the API |
| Cneko_api_user_cb_get_field | |
| Mneumann | Defines a Neumann boundary condition |
| Cneumann_t | A Neumann boundary condition. Sets the flux of the field to the chosen values |
| Mnmsh | Neko binary mesh format |
| Cnmsh_t | Neko binary mesh element data |
| Cnmsh_vertex_t | Neko binary mesh vertex data |
| Cnmsh_quad_t | Neko quad element data |
| Cnmsh_hex_t | Neko hex element data |
| Cnmsh_zone_t | Neko zone data |
| Cnmsh_curve_el_t | Neko curve data |
| Mnmsh_file | Neko binary mesh data |
| Cnmsh_file_t | Interface for Neko nmsh files |
| Mno_slip | Defines no-slip boundary condition (extends zero_dirichlet) |
| Cno_slip_t | |
| Mnon_normal | Implements non_normal_t |
| Cnon_normal_t | Mixed Dirichlet condition constraining the tangential vector components |
| Mnon_normal_aligned | Implements non_normal_aligned_t |
| Cnon_normal_aligned_t | Axis-aligned mixed Dirichlet condition in the non-normal direction |
| Moctree | Implements an Octree |
| Coct_ptr_t | |
| Coct_t | Defines an octree octant |
| Coctree_t | Defines an octree |
| Mopencl_intf | Fortran OpenCL interface |
| Cclgetplatformids | |
| Cclgetdeviceids | |
| Cclcreatecontext | |
| Cclcreatecommandqueue | |
| Cclcreatebuffer | |
| Cclcreateuserevent | |
| Cclenqueuereadbuffer | |
| Cclenqueuewritebuffer | |
| Cclenqueuecopybuffer | |
| Cclenqueuefillbuffer | |
| Cclenqueuemarkerwithwaitlist | |
| Cclenqueuemarker | |
| Cclenqueuebarrier | |
| Cclenqueuewaitforevents | |
| Cclwaitforevents | |
| Cclsetusereventstatus | |
| Cclgetdeviceinfo | |
| Cclreleasecontext | |
| Cclreleasecommandqueue | |
| Cclreleasedevice | |
| Cclreleaseprogram | |
| Cclreleasememobject | |
| Cclreleaseevent | |
| Cclflush | |
| Cclfinish | |
| Copencl_buffer_free_all | |
| Mopencl_mappings | OpenCL interface binding for mappings |
| Copencl_smooth_step | |
| Copencl_step_function | |
| Copencl_permeability | |
| Mopencl_math | |
| Copencl_copy | |
| Copencl_masked_copy_0 | |
| Copencl_masked_copy_aligned | |
| Copencl_masked_gather_copy | |
| Copencl_masked_gather_copy_aligned | |
| Copencl_face_masked_gather_copy | |
| Copencl_masked_scatter_copy | |
| Copencl_masked_scatter_copy_aligned | |
| Copencl_cfill_mask | |
| Copencl_cmult | |
| Copencl_cmult2 | |
| Copencl_cdiv | |
| Copencl_cdiv2 | |
| Copencl_radd | |
| Copencl_iadd | |
| Copencl_cadd2 | |
| Copencl_cwrap | |
| Copencl_sqrt_inplace | |
| Copencl_power | |
| Copencl_cfill | |
| Copencl_rzero | |
| Copencl_rone | |
| Copencl_add2 | |
| Copencl_add4 | |
| Copencl_add2s1 | |
| Copencl_add2s2 | |
| Copencl_add2s2_many | |
| Copencl_addsqr2s2 | |
| Copencl_add3s2 | |
| Copencl_add4s3 | |
| Copencl_add5s4 | |
| Copencl_invcol1 | |
| Copencl_invcol2 | |
| Copencl_invcol3 | |
| Copencl_col2 | |
| Copencl_col3 | |
| Copencl_subcol3 | |
| Copencl_sub2 | |
| Copencl_sub3 | |
| Copencl_add3 | |
| Copencl_addcol3 | |
| Copencl_addcol4 | |
| Copencl_addcol3s2 | |
| Copencl_vdot3 | |
| Copencl_vcross | |
| Copencl_glsc3 | |
| Copencl_glsc3_many | |
| Copencl_glsc2 | |
| Copencl_glsubnorm2 | |
| Copencl_glsum | |
| Copencl_glmax | |
| Copencl_glamax | |
| Copencl_glmin | |
| Copencl_absval | |
| Copencl_pwmax_vec2 | |
| Copencl_pwmax_vec3 | |
| Copencl_pwmax_sca2 | |
| Copencl_pwmax_sca3 | |
| Copencl_pwmin_vec2 | |
| Copencl_pwmin_vec3 | |
| Copencl_pwmin_sca2 | |
| Copencl_pwmin_sca3 | |
| Moperators | Operators |
| Cdudxyz | Compute derivative of a scalar field along a single direction |
| Cdiv | Compute the divergence of a vector field |
| Cgrad | Compute the gradient of a scalar field, multiplied by the mass matrix |
| Ccfl | Compute CFL condition |
| Ccfl_compressible | Compute CFL condition for compressible flow |
| Crotate_cyc | Apply cyclic boundary condition to a vector field |
| Cstrain_rate | Compute the strain rate tensor of a vector field |
| Mopr_device | Operators accelerator backends |
| Chip_dudxyz | |
| Chip_cdtp | |
| Chip_conv1 | |
| Chip_convect_scalar | |
| Chip_opgrad | |
| Chip_lambda2 | |
| Chip_cfl | |
| Chip_rotate_cyc | |
| Chip_set_convect_rst | |
| Moutput | Defines an output |
| Coutput_t | Abstract type defining an output type |
| Coutput_ptr_t | Wrapper around an output_t pointer |
| Coutput_sample | Abstract interface for sampling an output type at time t |
| Coutput_free | |
| Moutput_controller | Implements output_controller_t |
| Coutput_controller_t | Centralized controller for a list of outputs |
| Moverset_interface | Defines overset interface scalar boundary conditions |
| Coverset_interface_t | Overset interface BC for a scalar field |
| Cmorph_overset_interface | User callback for overset-interface morphing and boundary-value updates |
| Moverset_interface_vector | Defines overset interface vector boundary conditions |
| Coverset_interface_vector_t | Extension of the user defined dirichlet condition overset_interface |
| Mparmetis | Interface to ParMETIS |
| Cparmetis_v3_partmeshkway | |
| Cparmetis_v3_partgeom | |
| Mparticles | Defines a collection of Lagrangian particles |
| Cparticles_t | Particle positions, velocities, properties, and time-history data |
| Mpde_filter | A PDE based filter |
| Cpde_filter_t | A PDE based filter mapping \(\rho \mapsto \tilde{\rho}\), see Lazarov & O. Sigmund 2010, by solving an equation of the form \( -r^2 \nabla^2 \tilde{\rho} + \tilde{\rho} = \rho \) |
| Mpe_finder | Implements pe_finder given a dofmap |
| Cpe_finder_t | Implements global interpolation for arbitrary points in the domain |
| Cpe_finder_free | Destructor |
| Cpe_finder_find | Find rank candidates for a given point in the domain |
| Cpe_finder_find_batch | Find rank candidates for a batch of points in the domain |
| Mpfunit_comm_utils | |
| Ccomm_init_test | |
| Cneko_comm_wrapper_init | |
| Mphmg | Hybrid ph-multigrid preconditioner |
| Cphmg_lvl_t | |
| Cphmg_hrchy_t | |
| Cphmg_t | |
| Mpipecg | Defines a pipelined Conjugate Gradient methods |
| Cpipecg_t | Pipelined preconditioned conjugate gradient method |
| Mpipecg_device | Defines a pipelined Conjugate Gradient methods |
| Cpipecg_device_t | Pipelined preconditioned conjugate gradient method |
| Ccuda_pipecg_vecops | |
| Ccuda_cg_update_xp | |
| Mpipecg_sx | Defines a pipelined Conjugate Gradient methods SX-Aurora backend |
| Csx_pipecg_t | Pipelined preconditioned conjugate gradient method for SX-Aurora |
| Mpnpn_res_cpu | Residuals in the Pn-Pn formulation (CPU version) |
| Cpnpn_prs_res_cpu_t | |
| Cpnpn_vel_res_cpu_t | |
| Mpnpn_res_device | |
| Cpnpn_prs_res_device_t | |
| Cpnpn_vel_res_device_t | |
| Cpnpn_prs_res_part1_hip | |
| Cpnpn_prs_res_part2_hip | |
| Cpnpn_prs_res_part3_hip | |
| Cpnpn_vel_res_update_hip | |
| Mpnpn_res_stress_cpu | Residuals in the Pn-Pn formulation (CPU version) |
| Cpnpn_prs_res_stress_cpu_t | CPU implementation of the pressure residual for the PnPn fluid with full viscous stress formulation |
| Cpnpn_vel_res_stress_cpu_t | CPU implementation of the velocity residual for the PnPn fluid with full viscous stress formulation |
| Mpnpn_res_stress_device | Residuals in the Pn-Pn formulation (device version) |
| Cpnpn_prs_res_stress_device_t | Device implementation of the pressure residual for the PnPn fluid with full viscous stress formulation |
| Cpnpn_vel_res_stress_device_t | Device implementation of the velocity residual for the PnPn fluid with full viscous stress formulation |
| Cpnpn_prs_stress_res_part1_hip | |
| Cpnpn_prs_res_part2_hip | |
| Cpnpn_prs_stress_res_part3_hip | |
| Cpnpn_vel_res_update_hip | |
| Mpnpn_res_sx | Residuals in the Pn-Pn formulation (SX version) |
| Cpnpn_prs_res_sx_t | |
| Cpnpn_vel_res_sx_t | |
| Mpnpn_residual | Defines Pressure and velocity residuals in the Pn-Pn formulation |
| Cpnpn_prs_res_t | Abstract type to compute pressure residual |
| Cpnpn_vel_res_t | Abstract type to compute velocity residual |
| Cprs_res | |
| Cvel_res | |
| Mpoint | Implements a point |
| Cpoint_t | A point in \( \mathbb{R}^d \) with coordinates \( (x,y,z)\) |
| Cpoint_ptr | Defines a pointer to a point type |
| Mpoint_interpolator | Routines to interpolate fields on a given element on a point in that element with given r,s,t coordinates |
| Cpoint_interpolator_t | Field interpolator to arbitrary points within an element. Tailored for experimentation, and convenience, not performance Does all interpolation on the CPU. Only considers one element If performant interpolation on many elements is required Look at local_interpolator_t, similar but with less functionality |
| Mpoint_zone | |
| Cpoint_zone_t | Base abstract type for point zones |
| Cpoint_zone_wrapper_t | A helper type to build a list of polymorphic point_zones |
| Cpoint_zone_pointer_t | A helper type to build a list of pointers to point_zones |
| Cpoint_zone_criterion | Defines the criterion of selection of a GLL point to the point_zone |
| Cpoint_zone_init | The common constructor using a JSON object |
| Cpoint_zone_free | Destructor |
| Cpoint_zone_allocate | Point zone factory. Constructs, initializes, and maps the point zone object |
| Callocator_entry | Called in user modules to add an allocator for custom types |
| Mpoint_zone_registry | |
| Cpoint_zone_registry_t | |
| Mpoint_zone_template | Template for a user-defined point zone |
| Cpoint_zone_template_t | |
| Mprecon | Krylov preconditioner |
| Cpc_t | Defines a canonical Krylov preconditioner |
| Cpc_init | Abstract interface for initializing a preconditioner from the case file |
| Cpc_solve | Abstract interface for solving \( M z = r \) |
| Cpc_update | |
| Cpc_free | |
| Cprecon_allocate | Allocate a preconditioner |
| Cprecon_allocator_entry | Called in user modules to add an allocator for custom types |
| Mpreconditioner_template | Template for a user-defined Krylov preconditioner |
| Cpreconditioner_template_t | |
| Mprobes | Implements probes |
| Cprobes_t | |
| Mprojection | Project x onto X, the space of old solutions and back again |
| Cprojection_t | |
| Mprojection_vel | Project x onto X , the space of old solutions and back again Couple projections for velocity |
| Cprojection_vel_t | |
| Npyneko | |
| Nintf | |
| Cneko_dofmap_t | |
| Cneko_space_t | |
| Cneko_field_t | |
| Cneko_coef_t | |
| Mquad | Defines a quadrilateral element |
| Cquad_t | Quadrilateral element |
| Mre2 | NEKTON re2 format |
| Cre2v1_t | NEKTON re2 element data (version 1) |
| Cre2v1_xyz_t | NEKTON re2 element data (3d) (version 1) |
| Cre2v1_xy_t | NEKTON re2 element data (2d) (version 1) |
| Cre2v1_curve_t | NEKTON re2 curve data (version 1) |
| Cre2v1_bc_t | NEKTON re2 bc data (version 1) |
| Cre2v2_t | NEKTON re2 element data (version 2) |
| Cre2v2_xyz_t | NEKTON re2 element data (3d) (version 2) |
| Cre2v2_xy_t | NEKTON re2 element data (2d) (version 2) |
| Cre2v2_curve_t | NEKTON re2 curve data (version 2) |
| Cre2v2_bc_t | NEKTON re2 bc data (version 2) |
| Mre2_file | NEKTON mesh data in re2 format |
| Cre2_file_t | Interface for NEKTON re2 files |
| Mrea | NEKTON session data |
| Crea_t | NEKTON session data struct |
| Mrea_file | NEKTON session data reader |
| Crea_file_t | Interface for NEKTON ascii files |
| Mregistry | Defines a registry for storing solution fields |
| Cregistry_t | |
| Mregistry_entry | Defines a registry entry for storing and requesting temporary objects This is used in the registries to store a scalar, host array, device array, vector, matrix or field |
| Cregistry_entry_t | |
| Mrhs_maker | Routines to generate the right-hand sides for the convection-diffusion equation. Employs the EXT/BDF time integration schemes to compute the contributions coming from the explicitly extrapolated convective term and the BDF scheme applied to the time derivative. Inheritance is used to define implementation for different backends |
| Crhs_maker_sumab_t | Abstract type to compute extrapolated velocity field for the pressure equation |
| Crhs_maker_ext_t | Abstract type to sum up contributions to kth order extrapolation scheme |
| Crhs_maker_bdf_t | Abstract type to add contributions to F from lagged BD terms |
| Crhs_maker_oifs_t | Abstract type to add contributions of kth order OIFS scheme |
| Crhs_maker_sumab | |
| Crhs_maker_ext | |
| Cscalar_rhs_maker_ext | |
| Crhs_maker_bdf | |
| Cscalar_rhs_maker_bdf | |
| Crhs_maker_oifs | |
| Cscalar_rhs_maker_oifs | |
| Mrhs_maker_cpu | |
| Crhs_maker_sumab_cpu_t | |
| Crhs_maker_ext_cpu_t | |
| Crhs_maker_bdf_cpu_t | |
| Crhs_maker_oifs_cpu_t | |
| Mrhs_maker_device | |
| Crhs_maker_sumab_device_t | |
| Crhs_maker_ext_device_t | |
| Crhs_maker_bdf_device_t | |
| Crhs_maker_oifs_device_t | |
| Crhs_maker_sumab_hip | |
| Crhs_maker_ext_hip | |
| Cscalar_rhs_maker_ext_hip | |
| Crhs_maker_bdf_hip | |
| Cscalar_rhs_maker_bdf_hip | |
| Crhs_maker_oifs_hip | |
| Cscalar_rhs_maker_oifs_hip | |
| Mrhs_maker_sx | |
| Crhs_maker_sumab_sx_t | |
| Crhs_maker_ext_sx_t | |
| Crhs_maker_bdf_sx_t | |
| Crhs_maker_oifs_sx_t | |
| Mrichardson | Implements richardson_t |
| Crichardson_t | Wall model similar to the Monin-Obukhov Similarity Theory for atmospheric boundary layer flows, but which avoids the iterative computation of the Obukhov length, computing the Richardson number directly (Mauritsen, 2007) |
| Mrichardson_cpu | Implements the CPU kernel for the richardson_t type |
| Ctau_interface | |
| Cheat_flux_interface | |
| Mrichardson_device | Implements the device kernel for the richardson_t type |
| Chip_richardson_compute | |
| Mrough_log_law | Implements rough_log_law_t |
| Crough_log_law_t | Wall model based on the log-law for a rough wall. The formula defining the law is \( u^+ = log(z/z_0)/\kappa + B \). Here, \( z \) is the wall-normal distance, as per tradition in atmospheric sciences, where this law is often used |
| Mrough_log_law_device | Implements the device kernel for the rough_log_law_t type |
| Chip_rough_log_law_compute | |
| Mrunge_kutta_time_scheme | |
| Crunge_kutta_time_scheme_t | |
| Mruntime_stats | Runtime statistics |
| Cruntime_stats_t | |
| Mscalar_bc_projector | Implements scalar_projector_t |
| Cscalar_bc_projector_t | Projector for scalar boundary conditions |
| Mscalar_ic | Scalar initial condition |
| Cset_scalar_ic | |
| Mscalar_pnpn | Contains the scalar_pnpn_t type |
| Cscalar_pnpn_t | |
| Cscalar_pnpn_bc_allocate | Boundary condition factory. Both constructs and initializes the object |
| Cscalar_pnpn_bc_allocator_entry | Called in user modules to add an allocator for custom types |
| Mscalar_pnpn_bc_template | Template for a user-defined scalar Pn/Pn boundary condition |
| Cscalar_pnpn_bc_template_t | A user-defined scalar Pn/Pn boundary condition |
| Mscalar_residual | Defines the residual for the scalar transport equation |
| Cscalar_residual_t | Abstract type to compute scalar residual |
| Cscalar_residual_interface | Interface for computing the residual of a scalar transport equation |
| Mscalar_residual_cpu | Residuals in the scalar equation (CPU version) |
| Cscalar_residual_cpu_t | Wrapper type for the routine to compute the scalar residual on the CPU |
| Mscalar_residual_device | |
| Cscalar_residual_device_t | |
| Cscalar_residual_update_hip | |
| Mscalar_residual_sx | Residuals in the Pn-Pn formulation (SX version) |
| Cscalar_residual_sx_t | |
| Mscalar_scheme | Contains the scalar_scheme_t type |
| Cscalar_scheme_t | Base type for a scalar advection-diffusion solver |
| Cscalar_scheme_init_intrf | Abstract interface to initialize a scalar formulation |
| Cscalar_scheme_restart_intrf | Abstract interface to restart a scalar formulation |
| Cscalar_scheme_free_intrf | Abstract interface to dealocate a scalar formulation |
| Cscalar_scheme_step_intrf | Abstract interface to compute a time-step |
| Cscalar_scheme_wrapper_t | A helper type that is needed to have an array of polymorphic objects |
| Cscalar_scheme_allocate | Scalar scheme factory. Both constructs and initializes the object |
| Cscalar_scheme_allocator_entry | Called in user modules to add an allocator for custom types |
| Mscalar_scheme_template | Template for a user-defined scalar scheme |
| Cscalar_scheme_template_t | |
| Mscalar_sgs_stats | Computes the subgrid-scale contributions for the scalar fluxes. We use the Reynolds decomposition for a field u = + u' = U + u' |
| Cscalar_sgs_stats_t | |
| Mscalar_sgs_stats_output | Implements scalar_sgs_stats_ouput_t |
| Cscalar_sgs_stats_output_t | Defines an output for the sgs statistics for scalar computed using the scalar_sgs_stats_t object |
| Mscalar_sgs_stats_simcomp | Implements the scalar_sgs_stats_simcomp_t type |
| Cscalar_sgs_stats_simcomp_t | A simulation component that computes the subgrid-scale contributions to the Reynolds stresses in LES |
| Mscalar_source_term | Implements the scalar_source_term_t type |
| Cscalar_source_term_t | Wrapper contaning and executing the scalar source terms |
| Mscalar_stats | Computes various statistics for the scalar fields. We use the Reynolds decomposition for a field u = + u' = U + u' Spatial derivatives i.e. du/dx we denote dudx |
| Cscalar_stats_t | |
| Mscalar_stats_output | Implements scalar_stats_ouput_t |
| Cscalar_stats_output_t | Defines an output for the scalar statistics computed using the scalar_stats_t object |
| Mscalar_stats_simcomp | Implements the scalar_stats_simcomp_t type |
| Cscalar_stats_simcomp_t | A simulation component that computes the scalar statistics for the skewness, kurtosis, and the Reynolds-averaged mean scalar transport equation, scalar variance budget, and scalar flux budgets |
| Mscalars | Contains the scalars_t type that manages multiple scalar fields |
| Cscalars_t | Type to manage multiple scalar transport equations |
| Mschwarz | Overlapping schwarz solves |
| Cschwarz_t | |
| Mscratch_registry | Defines a registry for storing and requesting temporary objects This can be used when you have a function that will be called often and you do not want to create temporary objects (work arrays) inside it on each call |
| Cscratch_registry_t | Scratch registry type |
| Mshear_stress | Defines a shear stress boundary condition for a vector field. Maintainer: Timofey Mukha |
| Cshear_stress_t | A shear stress boundary condition |
| Mshmem | Fortran bindings to SHMEM's C API |
| Cshmem_init | |
| Cshmem_finalize | |
| Cshmem_me_pe | |
| Cshmem_n_pes | |
| Cshmem_info_get_name | |
| Cshmem_info_get_version | |
| Cshmem_pe_accessible | |
| Cshmem_addr_accessible | |
| Cshmem_malloc | |
| Cshmem_free | |
| Cshmem_realloc | |
| Cshmem_align | |
| Cshmem_calloc | |
| Cshmem_malloc_with_hints | |
| Cshmem_ptr | |
| Cshmem_init_thread | |
| Cshmem_query_thread | |
| Cshmem_ctx_create | |
| Cshmem_ctx_destroy | |
| Cshmem_putmem | |
| Cshmem_ctx_putmem | |
| Cshmem_getmem | |
| Cshmem_ctx_getmem | |
| Cshmem_putmem_nbi | |
| Cshmem_ctx_putmem_nbi | |
| Cshmem_getmem_nbi | |
| Cshmem_ctx_getmem_nbi | |
| Cshmem_putmem_signal_nbi | |
| Cshmem_signal_wait_until | |
| Cshmem_uint64_atomic_set | |
| Cshmem_uint64_wait_until | |
| Cshmem_alltoallmem | |
| Cshmem_barrier | |
| Cshmem_barrier_all | |
| Cshmem_broadcastmem | |
| Cshmem_collectmem | |
| Cshmem_fcollectmem | |
| Cshmem_sync | |
| Cshmem_sync_all | |
| Cshmem_fence | |
| Cshmem_ctx_fence | |
| Cshmem_quiet | |
| Cshmem_ctx_quiet | |
| Cshmem_clear_lock | |
| Cshmem_set_lock | |
| Cshmem_test_lock | |
| Msigma | Implements sigma_t |
| Csigma_t | Implements the Sigma LES model |
| Msignal | Interface to signal handler |
| Csighdl_timeout | |
| Csighdl_usr | |
| Csighdl_set_timeout | |
| Csighdl_trap_cpulimit | |
| Csighdl_trap_usr | |
| Msimcomp_executor | Contains the simcomp_executor_t type |
| Csimcomp_executor_t | Singleton type that serves as a driver for the simulation components. Stores all the components in the case and provides an interface matching that of a single simcomp, which executes the corresponding routines for each stored simcomp. The execution order is based on the order property of each simcomp. By default, the order is by the order of apparence in the case file |
| Msimulation | Simulation driver |
| Csimulation_restart | |
| Msimulation_component | Simulation components are objects that encapsulate functionality that can be fit to a particular compute pattern |
| Csimulation_component_t | Base abstract class for simulation components |
| Csimulation_component_wrapper_t | A helper type that is needed to have an array of polymorphic objects |
| Csimulation_component_init | The common constructor using a JSON dictionary |
| Csimulation_component_free | Destructor |
| Csimulation_component_allocate | Simulation component factory. Both constructs and initializes the object |
| Callocator_entry | Called in user modules to add an allocator for custom types |
| Msimulation_component_template | Template for a user-defined simulation component |
| Csimulation_component_template_t | |
| Msmagorinsky | Implements smagorinsky_t |
| Csmagorinsky_t | Implements the smagorinsky LES model |
| Msource_term | Implements the source_term_t type and a wrapper source_term_wrapper_t |
| Csource_term_t | Base abstract type for source terms |
| Csource_term_wrapper_t | A helper type that is needed to have an array of polymorphic objects |
| Csource_term_init | The common constructor using a JSON object |
| Csource_term_free | Destructor |
| Csource_term_compute | Computes the source term and adds the result to fields |
| Csource_term_allocate | Source term factory. Both constructs and initializes the object |
| Callocator_entry | Called in user modules to add an allocator for custom types |
| Msource_term_handler | Implements the source_term_handler_t type |
| Csource_term_handler_t | Abstract class for handling source terms |
| Csource_term_handler_init_user_source | |
| Msource_term_template | Template for a user-defined source term |
| Csource_term_template_t | |
| Mspace | Defines a function space |
| Cspace_t | The function space for the SEM solution fields |
| Coperator(.eq.) | |
| Coperator(.ne.) | |
| Mspalding | Implements spalding_t |
| Cspalding_t | Wall model based on Spalding's law of the wall. Reference: http://dx.doi.org/10.1115/1.3641728 |
| Mspalding_device | Implements the device kernel for the spalding_t type |
| Chip_spalding_compute | |
| Mspatial_average | Implements the spatial_average_t type |
| Cspatial_average_t | A simulation component that writes spatial averages of registry fields |
| Mspatial_average_output | Output for spatially averaged fields |
| Cspatial_average_output_t | Output for spatially averaged fields |
| Mspectral_error | Implements type spectral_error_t |
| Cspectral_error_t | Provides tools to calculate the spectral error indicator |
| Mspectral_vanishing_viscosity | Data and filter construction for spectral vanishing viscosity |
| Csvv_t | Spectral vanishing viscosity configuration and coefficients |
| Msphere_point_zone | |
| Csphere_point_zone_t | A sphere-shaped point zone |
| Msponge_source_term | Implements the sponge_t type |
| Csponge_source_term_t | |
| Mstack | Implements a dynamic stack ADT |
| Cstack_t | Base type for a stack |
| Cstack_i4_t | Integer based stack |
| Cstack_i8_t | Integer*8 based stack |
| Cstack_r8_t | Double precision based stack |
| Cstack_i4t2_t | Integer 2-tuple based stack |
| Cstack_i4t4_t | Integer 4-tuple based stack |
| Cstack_i4r8t2_t | Mixed integer-double precision 2-tuple based stack |
| Cstack_2i4r8t3_t | Mixed integer-double precision 3-tuple based stack |
| Cstack_curve_t | Curved element stack |
| Cstack_nq_t | Neko quad element based stack |
| Cstack_nh_t | Neko hex element based stack |
| Cstack_nz_t | Neko zone based stack |
| Cstack_nc_t | Neko curve info based stack |
| Cstack_pt_t | Point based stack |
| Mstats | Defines a container for all statistics |
| Cquantp_t | Pointer to an arbitrary quantitiy |
| Cstats_t | Statistics backend |
| Mstats_quant | Defines a statistical quantity |
| Cstats_quant_t | Abstract type defining a statistical quantity |
| Cstats_quant_update | Abstract interface for updating/adding data to a quantitiy |
| Mstl | Stereolithography format |
| Cstl_hdr_t | Defines a STL hdr |
| Cstl_triangle_t | Defines a STL triangle |
| Mstl_file | Stereolithography (STL) file |
| Cstl_file_t | Interface for STL files |
| Mstructs | Defines structs that are used... Dont know if we should keep it though |
| Cstruct_curve_t | |
| Carray_ptr_t | Pointer to array |
| Msx_jacobi | Jacobi preconditioner SX-Aurora backend |
| Csx_jacobi_t | Defines a jacobi preconditioner for SX-Aurora |
| Msymmetry | Implements symmetry_t |
| Csymmetry_t | Symmetry boundary condition constraining the normal vector component |
| Msymmetry_aligned | Implements symmetry_aligned_t |
| Csymmetry_aligned_t | Axis-aligned symmetry boundary condition |
| Msystem | Interface to system information routines |
| Csystem_cpuid | Interface to a C function to retrieve the CPU name (type) |
| Mtensor | Tensor operations |
| Ctranspose | |
| Ctriple_tensor_product | |
| Mtensor3 | Defines a rank-3 tensor |
| Ctensor3_t | |
| Ctensor3_ptr_t | |
| Mtensor4 | Defines a rank-4 tensor |
| Ctensor4_t | |
| Ctensor4_ptr_t | |
| Mtensor_device | |
| Chip_tnsr3d_el_list | |
| Chip_tnsr3d | |
| Mtet | Defines a tetrahedral element |
| Ctet_t | Tetrahedral element |
| Mtet_mesh | Defines a tetrahedral mesh |
| Ctet_mesh_t | |
| Mtime_based_controller | Contains the time_based_controller_t type |
| Ctime_based_controller_t | A utility type for determining whether an action should be executed based on the current time value. Used to e.g. control whether we should write a file or execute a simcomp |
| Mtime_interpolator | Implements type time_interpolator_t |
| Ctime_interpolator_t | Provides a tool to perform interpolation in time |
| Mtime_scheme | Base class for time integration schemes |
| Ctime_scheme_t | Base abstract class for time integration schemes |
| Ccompute_coeffs | Interface for setting the scheme coefficients |
| Mtime_scheme_controller | Compound scheme for the advection and diffusion operators in a transport equation |
| Ctime_scheme_controller_t | Implements the logic to compute the time coefficients for the advection and diffusion operators in a transport equation |
| Mtime_state | Module with things related to the simulation time |
| Ctime_state_t | A struct that contains all info about the time, expand as needed |
| Mtime_step_controller | Implements type time_step_controller |
| Ctime_step_controller_t | Provides a tool to set time step dt |
| Mtranslation_source_term | Implements the coriolis_source_term_t type. Implements the translation_source_term_t type |
| Ctranslation_source_term_t | This source term adds the translation force |
| Mtree_amg | Implements the base type for TreeAMG hierarchy structure |
| Ctamg_node_t | Type for storing TreeAMG tree node information |
| Ctamg_lvl_t | Type for storing TreeAMG level information |
| Ctamg_hierarchy_t | Type for a TreeAMG hierarchy |
| Mtree_amg_aggregate | Implements an aggregation for TreeAMG hierarchy structure |
| Ctamg_agg_monitor_t | |
| Mtree_amg_multigrid | Implements multigrid using the TreeAMG hierarchy structure. USE: |
| Ctamg_wrk_t | |
| Ctamg_solver_t | Type for the TreeAMG solver |
| Mtree_amg_smoother | Implements smoothers for use with TreeAMG matrix vector product |
| Camg_jacobi_t | Type for Chebyshev iteration using TreeAMG matvec |
| Camg_cheby_t | Type for Chebyshev iteration using TreeAMG matvec |
| Mtri | Defines a triangular element |
| Ctri_t | Triangular element |
| Mtri_mesh | Defines a triangular surface mesh |
| Ctri_mesh_t | |
| Mtuple | Implements a n-tuple |
| Ctuple_t | Base type for an n-tuple |
| Ctuple_i4_t | Integer based 2-tuple |
| Ctuple3_i4_t | Integer based 3-tuple |
| Ctuple4_i4_t | Integer based 4-tuple |
| Ctuple_r8_t | Double precision based 2-tuple |
| Ctuple_i4r8_t | Mixed integer ( \( x \)) double precision ( \( y \)) 2-tuple \((x, y)\) |
| Ctuple_2i4r8_t | Mixed integer ( \( x, y \)) double precision ( \( z \)) 3-tuple |
| Ctuple_assign_tuple | Abstract intf. for assigning a tuple to a tuple |
| Ctuple_assign_vector | Abstract intf. for assigning a vector to a n-tuple |
| Ctuple_equal | Abstract intf. for tuple comparison |
| Muser_access_singleton | User access singleton Defines a singleton object available in the user file. Intended to allow unrestricted access to the entire simulation case and enable all sorts of hacking, while keeping neko proper clear. The object is only initialized by makeneko, so trying to use it outside user code will result in a segfault—intentionally |
| Cuser_access_t | Helper type to give users global access to the simulation case |
| Muser_intf | Interfaces for user interaction with NEKO |
| Cuser_startup_intf | Abstract interface for a user start-up routine |
| Cuser_initial_conditions_intf | Abstract interface for user defined initial conditions |
| Cuser_initialize_intf | Abstract interface for initilialization of modules |
| Cuser_mesh_setup_intf | Abstract interface for user defined mesh deformation functions |
| Cuser_wall_sampling_gll_intf | Abstract interface for user-defined GLL sampling for wall models |
| Cuser_wall_sampling_distance_intf | Abstract interface for user-defined physical-distance for wall models |
| Cuser_compute_intf | Abstract interface for user defined check functions |
| Cuser_finalize_intf | Abstract interface for finalizating user variables |
| Cuser_source_term_intf | Abstract interface for user defined source term |
| Cuser_material_properties_intf | Abstract interface for setting material properties |
| Cuser_ale_mesh_velocity_intf | Abstract interface for user defined ALE mesh velocity |
| Cuser_ale_base_shapes_intf | Abstract interface for user defined ALE base shapes |
| Cuser_ale_rigid_kinematics_intf | Abstract interface for user defined ALE rigid body kinematics |
| Cuser_t | A type collecting all the overridable user routines and flag to suppress type injection from custom modules |
| Muser_source_term | Implements the user_source_term_t type |
| Cuser_source_term_t | A source term wrapping the user source term routine. Stores fields that are passed to the user routine so tha the user routine never touches the actual RHS fields directly |
| Muser_stats | Implements the user_stats_t type |
| Cuser_stats_t | A simulation component that computes the averages of fields in the registry |
| Muset | Implements an unordered set ADT |
| Cuset_t | Base type for an unordered set |
| Cuset_i4_t | Integer based unordered set |
| Cuset_i8_t | Integer*8 based unordered set |
| Cuset_r8_t | Double precision unordered set |
| Cuset_init | Interface for initializing an unordered set |
| Cuset_free | Interface for destroying an unordered set |
| Cuset_size | Interface for getting the cardinality of an unordered set |
| Cuset_clear | Interface for clearing an unordered set |
| Cuset_element | Interface for checking if key is an element of an unordered set |
| Cuset_add | Inteface for adding key to an unorderd set |
| Cuset_remove | Inteface for removing key in an unorderd set |
| Mutils | Utilities |
| Cneko_error | |
| Cread_duration | |
| Cthrow_intf | Interface for the throw procedure. Follows pFunit conventions |
| Cc_mkdir | |
| Mvector | Defines a vector |
| Cvector_t | |
| Cvector_ptr_t | |
| Mvector_bc_projector | Implements boundary condition projectors for vector fields. Two types concrete types are provided: segregated_vector_bc_projector_t for simple component-wise resolution, and coupled_vector_bc_projector_t for resolving mixed boundary conditions |
| Cvector_bc_projector_t | Abstract type for resolving vector boundary conditions |
| Csegregated_vector_bc_projector_t | A projector for vector fields that acts component-wise |
| Ccoupled_vector_bc_projector_t | A coupled projector for vector fields, suitable for mixed boundary conditions |
| Cvector_bc_projector_free_intrf | Free the vector boundary-condition projector |
| Cvector_bc_projector_init_intrf | Initialize the vector boundary-condition projector |
| Cvector_bc_projector_finalize_intrf | Finalize the vector boundary-condition projector |
| Cvector_bc_projector_apply_intrf | Apply the resolved vector boundary constraints |
| Cvector_bc_projector_mark_bc_intrf | Mark a boundary condition in the vector boundary-condition projector |
| Cvector_bc_projector_mark_bc_list_intrf | Mark a list of boundary conditions in the projector |
| Mvector_list | |
| Cvector_list_t | Vector_list_t, To be able to group vectors together |
| Mvector_series | Contains the vector_series_t type |
| Cvector_series_t | Stores a series (sequence) of vectors, logically connected to a base vector, and arranged according to some ordering. Currently used to store time-lagged values of solution vectors |
| Cvector_series_ptr_t | A wrapper for a pointer to a vector_series_t |
| Mviscous_regularization | Defines the base interface for viscous regularization methods |
| Cviscous_regularization_t | Base abstract type for viscous regularization methods |
| Creg_init | Initialize a viscous regularization method |
| Creg_free | Free a viscous regularization method |
| Creg_update | Update an effective viscosity field |
| Mvreman | Implements vreman_t |
| Cvreman_t | Implements the Vreman LES model |
| Mvtk_file | Legacy VTK file format |
| Cvtk_file_t | Interface for legacy VTK files |
| Mvtkhdf_file | VTKHDF file format |
| Cvtkhdf_file_t | Interface for HDF5 files |
| Mwale | Implements wale_t |
| Cwale_t | Implements the Wale LES model |
| Mwall_distance_sampler | Implements wall_distance_sampler_t |
| Cwall_distance_sampler_t | Implements wall-normal sampling at prescribed physical distances |
| Mwall_gll_sampler | Implements sampling from GLL nodes at prescribed off-wall indices |
| Cwall_gll_sampler_t | Wall sampler implementation for GLL nodes at prescribed off-wall indices |
| Mwall_model | Implements wall_model_t |
| Cwall_model_t | Base abstract type for wall-stress models for wall-modelled LES |
| Cwall_model_compute | Compute wall shear stress |
| Cwall_model_init | Common constructor |
| Cwall_model_partial_init | Partial constructor from JSON, meant to work as the first stage of initialization before the finalize call |
| Cwall_model_finalize | Finilzation of partial construction, similar to bc_t |
| Cwall_model_free | Destructor |
| Cwall_model_allocate | Wall model factory. Both constructs and initializes the object |
| Callocator_entry | Called in user modules to add an allocator for custom types |
| Mwall_model_bc | Defines the wall_model_bc_t type. Maintainer: Timofey Mukha |
| Cwall_model_bc_t | A shear stress boundary condition, computing the stress values using a wall model |
| Mwall_model_device | Implements the device kernel for the wall_model_t type |
| Chip_wall_model_compute_mag_field | |
| Mwall_model_template | Template for a user-defined wall model |
| Cwall_model_template_t | |
| Mwall_sampler | Defines the abstract interface for wall-model field samplers |
| Cwall_sampler_t | Base type for sampling solution fields at points associated with wall nodes. Samples belonging to one wall node are stored contiguously |
| Cwall_sampler_init | Parse sampler-specific configuration from JSON |
| Cwall_sampler_finalize | Complete sampler setup after geometric and wall-node data are known |
| Cwall_sampler_sample | Evaluate and store sampled field values at all sampling points |
| Cwall_sampler_free | Release sampler resources |
| Mwall_shear_stress_simcomp | Implements the wall_shear_stress_t type |
| Cwall_shear_stress_t | A simulation component that computes the wall shear stress on one or more labelled boundary zones and registers it in the neko_registry. The result is written into the registry fields <computed_field>_x, _y, _z and _mag, which are zero away from the marked zones |
| Mweak_gradient_simcomp | Implements the weak_gradient_t type |
| Cweak_gradient_t | A simulation component that computes the weak gradient of a field. Wraps the opgradient operator |
| Mzero_dirichlet | Defines a zero-valued Dirichlet boundary condition |
| Czero_dirichlet_t | Zero-valued Dirichlet boundary condition. Used for no-slip walls, but also for various auxillary conditions, such as for residuals |
| Cax_helm_compr_dmma_dispatch | |
| Cax_helm_compr_dmma_tma_batch_dispatch | |
| Cax_helm_compr_dmma_tma_dispatch | |
| Cax_helm_compr_dmma_tma_vector_dispatch | |
| Cax_helm_compr_dmma_vector_dispatch | |
| Cax_helm_compr_mfma_dispatch | |
| Cax_helm_compr_mfma_vector_dispatch | |
| Cax_helm_dmma_dispatch | |
| Cax_helm_dmma_tma_batch_dispatch | |
| Cax_helm_dmma_tma_dispatch | |
| Cax_helm_dmma_tma_vector_dispatch | |
| Cax_helm_dmma_vector_dispatch | |
| Cax_helm_mfma_dispatch | |
| Cax_helm_mfma_vector_dispatch | |
| Ccdtp_dmma_dispatch | |
| Ccdtp_dmma_tma_dispatch | |
| Ccdtp_mfma_dispatch | |
| Cchunk_block | |
| Cconv1_dmma_dispatch | |
| Cconv1_dmma_tma_dispatch | |
| Cconv1_mfma_dispatch | |
| Cconv1_tma_smem | |
| Ccuda_buffer | |
| Cdmma_tma_batch_smem | |
| Cdudxyz_dmma_dispatch | |
| Cdudxyz_dmma_tma_dispatch | |
| Cdudxyz_mfma_dispatch | |
| Celem_block | |
| Cgs_utofu_ctx_t | |
| Chip_buffer | |
| Ckinematics_params_t | |
| Clpt_periodic_params | |
| Cneko_tune_rej_t | |
| Cneko_tune_verify_t | |
| Copencl_buffer | |
| Copgrad_dmma_dispatch | |
| Copgrad_dmma_tma_dispatch | |
| Copgrad_mfma_dispatch | |
| Copgrad_tma_smem | |