omega_h
Reliable mesh adaptation
Namespaces | Classes | Typedefs | Enumerations | Functions | Variables
Omega_h Namespace Reference

Namespaces

 exodus
 
 meshsim
 

Classes

struct  UserTransfer
 
struct  TransferOpts
 
struct  AdaptOpts
 
struct  MetricSource
 
struct  MetricInput
 
struct  IsFlipped
 
struct  IsFlipped< 4 >
 
struct  IsFlipped< 3 >
 
struct  IsFlipped< 2 >
 
struct  IsMatch
 
struct  IsMatch< 2 >
 
struct  IsMatch< 3 >
 
struct  IsMatch< 4 >
 
class  elements_across_sides_count_functor
 
struct  Adj
 
struct  Parents
 
struct  Children
 
struct  Affine
 
struct  FlipAdj
 
struct  FlipAdj< 4 >
 
struct  FlipAdj< 3 >
 
struct  FlipAdj< 2 >
 
class  bad_any_cast
 
class  any
 
class  NonNullPtr
 
class  HostWrite
 
class  Write
 
class  Read
 
class  HostRead
 
struct  Int128Plus
 
struct  MinMax
 
struct  UniteOp
 
struct  GetBBoxOp
 
struct  BBox
 
struct  StateCompare
 
struct  Config
 
struct  ActionInProgress
 
struct  StateInProgress
 
struct  StateConfig
 
struct  ParserInProgress
 
class  CastIterator
 
struct  ItemTraits
 
struct  ItemTraits< std::string >
 
struct  ItemTraits< double >
 
struct  ItemTraits< int >
 
class  CmdLineItem
 
class  CmdLineArg
 
class  CmdLineFlag
 
class  CmdLine
 
class  Comm
 
struct  CompareArrays
 
struct  CompareArrays< Real >
 
struct  VarCompareOpts
 
struct  MeshCompareOpts
 
struct  Cavs
 
struct  SeparationResult
 
struct  ConservedBools
 
struct  OpConservation
 
struct  AllBounded
 
class  Dist
 an MPI distributor object which encapsulates the idea of a communication pattern between lots of small actors on each MPI rank. More...
 
struct  Egads
 
struct  Roots
 
struct  DiagDecomp
 
struct  ConstOp
 
struct  SemicolonOp
 
struct  AssignOp
 
struct  VarOp
 
struct  NegOp
 
struct  TernaryOp
 
struct  CallOp
 
struct  ExprEnv
 
struct  ExprOp
 
class  ExprOpsReader
 
class  ExprReader
 
class  Few
 
struct  StateSetPtrLess
 
struct  StateRowLess
 
struct  IsSymbol
 
struct  IsSymbol< T, true >
 
struct  IsSymbol< T, false >
 
struct  GetSymbol
 
struct  GetSymbol< T, true >
 
struct  GetSymbol< T, false >
 
struct  FiniteAutomaton
 
struct  MaxFitPoints
 
struct  AndFunctor
 
struct  MaxFunctor
 
struct  MinFunctor
 
struct  SumFunctor
 
class  Future
 Abstraction for asynchronous communication. More...
 
struct  RemoteGraph
 
struct  Grammar
 
struct  FilteredGraph
 
struct  Graph
 directed graph (as defined by graph theory) in compressed row format More...
 
struct  Histogram
 
class  HostFew
 
struct  QualityCompare
 
struct  NameValue
 
class  InputYamlReader
 
struct  Input
 
struct  InputScalar
 
class  InputMapIterator
 
struct  InputMap
 
struct  InputList
 
struct  Int128
 
class  IntIterator
 
struct  Language
 
class  Library
 
class  Matrix
 
class  SharedRef
 
struct  ClassPair
 
class  Mesh
 
class  ScopedChangeRCFieldsToMesh
 
class  Mesh2D
 
class  MixedMesh
 
class  Overlay
 
struct  Action
 
struct  Parser
 
class  ParserFail
 
struct  Pool
 
class  CompareFreeIndices
 
class  StaticKokkosPool
 A memory pool for allocating and deallocating chunks of memory. More...
 
class  KokkosPool
 A memory pool for allocating and deallocating chunks of memory. More...
 
struct  ScopedTimer
 
struct  QRFactorization
 
struct  MetricElementQualities
 
class  UnitUniformDistribution
 
class  StandardNormalDistribution
 
struct  Rb_tree_node_base
 
struct  Rb_tree_node
 
struct  Rb_tree_base_iterator
 
struct  Rb_tree_iterator
 
struct  Rb_tree_base
 
class  Rb_tree
 
struct  rb_tree
 
struct  Rb_value_as_key
 
struct  Rb_first_as_key
 
struct  map
 
class  Reader
 
class  DebugReader
 
struct  IndentInfo
 
struct  ReaderTables
 
struct  MetricRefineQualities
 
struct  FlipNewElem
 
struct  FlipNewElem< 2 >
 
struct  FlipNewElem< 3 >
 
struct  Remotes
 
struct  c_Remotes
 
struct  Promoted
 
struct  Promoted< I8 >
 
struct  ArithTraits
 
struct  ArithTraits< unsigned char >
 
struct  ArithTraits< signed char >
 
struct  ArithTraits< unsigned int >
 
struct  ArithTraits< int >
 
struct  ArithTraits< unsigned long >
 
struct  ArithTraits< signed long >
 
struct  ArithTraits< unsigned long long >
 
struct  ArithTraits< signed long long >
 
struct  ArithTraits< double >
 
struct  Raise
 
struct  Raise< 0, T >
 
struct  Root
 
struct  Root< 0 >
 
struct  Root< 1 >
 
struct  Root< 2 >
 
struct  Root< 3 >
 
struct  Power
 
struct  Power< np, dp, 1 >
 
struct  Power< p, p, 1 >
 
struct  plus
 
struct  logical_and
 
struct  maximum
 
struct  minimum
 
struct  identity
 
struct  multiplies
 
struct  Sphere
 
struct  Plane
 
struct  RealEdgeLengths
 
struct  MetricEdgeLengths
 
struct  RealSimplexSizes
 
struct  Alloc
 
struct  HighWaterRecord
 
struct  Allocs
 
struct  SharedAlloc
 
struct  SimplexAvgDegree
 
struct  SimplexAvgDegree< 1, 0, 1 >
 
struct  SimplexAvgDegree< 2, 0, 1 >
 
struct  SimplexAvgDegree< 2, 0, 2 >
 
struct  SimplexAvgDegree< 3, 0, 1 >
 
struct  SimplexAvgDegree< 3, 0, 3 >
 
struct  CompareKeySets
 
struct  SurfaceInfo
 
struct  Givens
 
struct  SVD
 
class  swap2d_topology_functor
 
struct  Table
 
struct  TagTraits
 
struct  TagTraits< I8 >
 
struct  TagTraits< I32 >
 
struct  TagTraits< I64 >
 
struct  TagTraits< Real >
 
class  TagBase
 
class  Tag
 
struct  TemplateUp
 
struct  SplitVertex
 
struct  Now
 

Typedefs

using Bytes = Read< Byte >
 
using LOs = Read< LO >
 
using GOs = Read< GO >
 
using Reals = Read< Real >
 
using Assoc = std::array< ClassSets, NSET_TYPES >
 
using MeshDimSets = std::map< std::string, LOs >
 
using MeshSets = std::array< MeshDimSets, NSET_TYPES >
 
using StatePtr2StateIndex = std::map< StateInProgress const *, int, StateCompare >
 
using FirstSet = std::set< int >
 
using Contexts = std::vector< Context >
 
using Configs = std::vector< Config >
 
using Context = std::set< int >
 
using StatesInProgress = std::vector< std::unique_ptr< StateInProgress > >
 
using StateConfigs = std::vector< StateConfig >
 
typedef std::shared_ptr< Comm > CommPtr
 
using CavsByColor = std::vector< Cavs >
 
using CavsByColorMethod = std::array< CavsByColor, 3 >
 
using CavsByBdryStatus = std::array< CavsByColorMethod, 3 >
 
typedef std::int8_t I8
 
typedef std::int16_t I16
 
typedef std::int32_t I32
 
typedef std::int64_t I64
 
typedef I8 Byte
 
typedef I32 Int
 
typedef I32 LO
 
typedef I32 ClassId
 
typedef I64 GO
 
typedef double Real
 
using OpPtr = std::shared_ptr< ExprOp >
 
using StateSet = std::set< int >
 
using StateQueue = std::queue< int >
 
using StateSetPtr = StateSet *
 
using StateSetPtr2State = std::map< StateSetPtr, int, StateSetPtrLess >
 
using StateSetUniqPtrVector = std::vector< std::unique_ptr< StateSet > >
 
using StateRow2SimpleState = std::map< int, int, StateRowLess >
 
using GrammarPtr = std::shared_ptr< Grammar const >
 
using ExecSpace = Kokkos::DefaultExecutionSpace
 
using Space = ExecSpace::memory_space
 
using Device = Kokkos::Device< ExecSpace, Space >
 
using StaticSched = Kokkos::Schedule< Kokkos::Static >
 
using Policy = Kokkos::RangePolicy< ExecSpace, StaticSched, Omega_h::LO >
 
template<class T >
using View = Kokkos::View< T, Device >
 
using LanguagePtr = std::shared_ptr< Language >
 
template<Int dim>
using Tensor = Matrix< dim, dim >
 
using ClassSets = std::map< std::string, std::vector< ClassPair > >
 
using TagSet = std::array< std::set< std::string >, DIMS >
 
using NodeEdges = std::vector< int >
 
using ParserGraph = std::vector< NodeEdges >
 
using VoidPtr = void *
 
using BlockList = std::vector< VoidPtr >
 
using MallocFunc = std::function< VoidPtr(std::size_t)>
 
using FreeFunc = std::function< void(VoidPtr, std::size_t)>
 
using IndexPair = std::pair< size_t, size_t >
 
using MultiSetBySizeT = std::multiset< IndexPair, CompareFreeIndices >
 
using SetByIndexT = std::set< IndexPair >
 
typedef bool Rb_tree_Color_type
 
template<class Key >
using set = rb_tree< Key, Key, Rb_value_as_key< Key > >
 
using ReaderTablesPtr = std::shared_ptr< ReaderTables const >
 
template<typename T >
using promoted_t = typename Promoted< T >::type
 
template<Int n>
using Vector = Few< Real, n >
 

Enumerations

enum  Verbosity { SILENT , EACH_ADAPT , EACH_REBUILD , EXTRA_STATS }
 
enum  SetType { ELEM_SET , SIDE_SET , NODE_SET }
 
enum  { NSET_TYPES = 3 }
 
enum  { FIRST_NULL = -425 }
 
enum  { MARKER = -433 }
 
enum  { ZERO = -100 }
 
enum  { NCHARS = 98 }
 
enum  OvershootLimit { DESIRED , ALLOWED }
 
enum  Improve { DONT_IMPROVE , IMPROVE_LOCALLY }
 
enum  { DONT_COLLAPSE = 0x0 , COLLAPSE_LEFT = 0x1 , COLLAPSE_RIGHT = 0x2 , COLLAPSE_BOTH = 0x3 }
 
enum  BdryStatus { NOT_BDRY , TOUCH_BDRY , KEY_BDRY }
 
enum  ColorMethod { NO_COLOR , CLASS_COLOR , CLASS_BDRY_COLOR }
 
enum  { DIMS = OMEGA_H_DIMS }
 
enum  : Int { VERT = OMEGA_H_VERT , EDGE = OMEGA_H_EDGE , FACE = OMEGA_H_FACE , REGION = OMEGA_H_REGION }
 
enum  { OMEGA_H_INTERIOR_VAL = 127 }
 
enum  { TOPO_TYPES = 8 }
 
enum  ActionKind { ACTION_NONE , ACTION_SHIFT , ACTION_REDUCE }
 
enum class  ArrayType { VectorND , SymmetricSquareMatrix }
 

Functions

Real min_fixable_quality (Mesh *mesh, AdaptOpts const &opts)
 
bool print_adapt_status (Mesh *mesh, AdaptOpts const &opts)
 
void print_adapt_histograms (Mesh *mesh, AdaptOpts const &opts)
 
bool adapt (Mesh *mesh, AdaptOpts const &opts)
 
void add_rcField_transferMap (AdaptOpts *opts, std::string const &name, Omega_h_Transfer const transfer)
 
void add_rcField_integralMap (AdaptOpts *opts, std::string const &name, std::string const &map)
 
void fix_momentum_velocity_verts (Mesh *mesh, std::vector< ClassPair > const &class_pairs, Int comp)
 
bool warp_to_limit (Mesh *mesh, AdaptOpts const &opts, bool exit_on_stall=false, Int max_niters=40)
 
bool approach_metric (Mesh *mesh, AdaptOpts const &opts, Real min_step=1e-4)
 
Reals generate_metrics (Mesh *mesh, MetricInput const &input)
 
void add_metric_tag (Mesh *mesh, Reals metrics, std::string const &name="metric")
 
void generate_metric_tag (Mesh *mesh, MetricInput const &input)
 
void generate_target_metric_tag (Mesh *mesh, MetricInput const &input)
 
void add_implied_metric_tag (Mesh *mesh)
 
void add_implied_isos_tag (Mesh *mesh)
 
void add_implied_metric_based_on_target (Mesh *mesh)
 
void fix (Mesh *mesh, AdaptOpts const &adapt_opts, Omega_h_Isotropy isotropy, bool verbose)
 
void fix_for_given_metric (Mesh *mesh, AdaptOpts const &adapt_opts, bool verbose)
 
void grade_fix_adapt (Mesh *mesh, AdaptOpts const &opts, Reals target_metric, bool verbose)
 
Adj unmap_adjacency (LOs const a2b, Adj const b2c)
 
template<Int deg, typename T >
Read< I8 > get_codes_to_canonical_deg (Read< T > const ev2v)
 
template<typename T >
Read< I8 > get_codes_to_canonical (Int const deg, Read< T > const ev2v)
 
Read< I8 > find_canonical_jumps (Int const deg, LOs const canon, LOs const e_sorted2e)
 
LOs find_unique (LOs const hv2v, Omega_h_Family const family, Int const high_dim, Int const low_dim)
 
LOs find_unique (LOs const hv2v, Topo_type const high_type, Topo_type const low_type)
 
LOs form_uses (LOs const hv2v, Omega_h_Family const family, Int const high_dim, Int const low_dim)
 
LOs form_uses (LOs const hv2v, Topo_type const high_type, Topo_type const low_type)
 
void sort_by_high_index (LOs const l2lh, Write< LO > const lh2h, Write< I8 > const codes)
 
void separate_upward_with_codes (LO const nlh, LOs const lh2hl, Int const nlows_per_high, Write< LO > const lh2h, Bytes const down_codes, Write< Byte > const codes)
 
void separate_upward_no_codes (LO const nlh, LOs const lh2hl, Int const nlows_per_high, Write< LO > const lh2h, Write< Byte > const codes)
 
Adj invert_adj (Adj const down, Int const nlows_per_high, LO const nlows, Topo_type high_type, Topo_type low_type)
 
Adj invert_adj (Adj const down, Int const nlows_per_high, LO const nlows, Int const high_dim, Int const low_dim)
 
Bytes filter_parents (Parents const c2p, Int const parent_dim)
 
Children invert_parents (Parents const c2p, Int const parent_dim, Int const nparent_dim_ents)
 
template<Int deg, typename T >
void find_matches_deg (LOs const a2fv, Read< T > const av2v, Read< T > const bv2v, Adj const v2b, Write< LO > *a2b_out, Write< I8 > *codes_out, bool const allow_duplicates)
 
template<typename T >
void find_matches_ex (Int const deg, LOs const a2fv, Read< T > const av2v, Read< T > const bv2v, Adj const v2b, Write< LO > *a2b_out, Write< I8 > *codes_out, bool const allow_duplicates)
 
void find_matches (Omega_h_Family const family, Int const dim, LOs const av2v, LOs const bv2v, Adj const v2b, Write< LO > *a2b_out, Write< I8 > *codes_out)
 
void find_matches (Topo_type const ent_type, LOs const av2v, LOs const bv2v, Adj const v2b, Write< LO > *a2b_out, Write< I8 > *codes_out)
 
Adj reflect_down (LOs const hv2v, LOs const lv2v, Adj const v2l, Omega_h_Family const family, Int const high_dim, Int const low_dim)
 
Adj reflect_down (LOs const hv2v, LOs const lv2v, Adj const v2l, Topo_type const high_type, Topo_type const low_type)
 
Adj reflect_down (LOs const hv2v, LOs const lv2v, Omega_h_Family const family, LO const nv, Int const high_dim, Int const low_dim)
 
Adj transit (Adj const h2m, Adj const m2l, Omega_h_Family const family, Int const high_dim, Int const low_dim)
 
Graph verts_across_edges (Adj const e2v, Adj const v2e)
 
Adj transit (Adj const h2m, Adj const m2l, Topo_type const high_type, Topo_type const low_type, Topo_type const mid_type)
 
Graph edges_across_tris (Adj const f2e, Adj const e2f)
 
Graph edges_across_tets (Adj const r2e, Adj const e2r)
 
Graph elements_across_sides (Int const dim, Adj const elems2sides, Adj const sides2elems, Read< I8 > const side_is_exposed)
 
template<Int nhhl>
OMEGA_H_DEVICE Few< LO, nhhl > gather_down (LOs const &hl2l, Int h)
 
template<Int neev>
OMEGA_H_DEVICE Few< LO, neev > gather_verts (LOs const &ev2v, Int e)
 
template<Int neev, typename T >
OMEGA_H_DEVICE Few< T, neev > gather_values (Read< T > const &a, Few< LO, neev > v)
 
template<Int neev>
OMEGA_H_DEVICE Vector< neev > gather_scalars (Read< Real > const &a, Few< LO, neev > v)
 
template<Int neev, Int dim>
OMEGA_H_DEVICE Matrix< dim, neev > gather_vectors (Reals const &a, Few< LO, neev > v)
 
template<Int neev, Int dim>
OMEGA_H_DEVICE Few< Matrix< dim, dim >, neev > gather_symms (Reals const &a, Few< LO, neev > v)
 
template<Int dim>
OMEGA_H_INLINE Vector< dim > operator* (Affine< dim > a, Vector< dim > v)
 
template<Int dim>
OMEGA_H_INLINE Affine< dim > invert (Affine< dim > a)
 
template<Int deg, typename T >
Read< T > align_ev2v_deg (Read< T > ev2v, Read< I8 > codes)
 
template<typename T >
Read< T > align_ev2v (Int deg, Read< T > ev2v, Read< I8 > codes)
 
constexpr OMEGA_H_INLINE bool code_is_flipped (I8 code)
 
constexpr OMEGA_H_INLINE Int code_rotation (I8 code)
 
constexpr OMEGA_H_INLINE Int code_which_down (I8 code)
 
constexpr OMEGA_H_INLINE I8 make_code (bool is_flipped, Int rotation, Int which_down)
 
constexpr OMEGA_H_INLINE Int rotate_index (Int nverts_per_ent, Int index, Int rotation)
 
constexpr OMEGA_H_INLINE Int invert_rotation (Int nverts_per_ent, Int rotation)
 
constexpr OMEGA_H_INLINE Int reverse_index (Int n, Int i)
 
constexpr OMEGA_H_INLINE Int flip_vert_index (Int n, Int i)
 
constexpr OMEGA_H_INLINE Int flip_edge_index (Int n, Int i)
 
constexpr OMEGA_H_INLINE Int align_vert_index (Int nverts_per_ent, Int index, I8 code)
 
constexpr OMEGA_H_INLINE Int align_edge_index (Int nverts_per_ent, Int index, I8 code)
 
constexpr OMEGA_H_INLINE Int align_index (Int nverts_per_ent, Int index_dim, Int index, I8 code)
 
constexpr OMEGA_H_INLINE Int rotation_to_first (Int nverts_per_ent, Int new_first)
 
constexpr OMEGA_H_INLINE I8 invert_alignment (Int nverts_per_ent, I8 code)
 
template<Int nverts_per_ent>
OMEGA_H_INLINE I8 compound_alignments (I8 code1, I8 code2)
 
OMEGA_H_INLINE I8 compound_alignments (Int deg, I8 code1, I8 code2)
 
template<Int nverts_per_ent, typename In , typename Out >
OMEGA_H_DEVICE void rotate_adj (Int rotation, In const &in, LO in_offset, Out &out, LO out_offset)
 
template<Int deg, typename InOut >
OMEGA_H_DEVICE void flip_adj (InOut &adj, LO offset)
 
template<Int nverts_per_ent, typename In , typename Out >
OMEGA_H_DEVICE void align_adj (I8 code, In const &in, LO in_offset, Out &out, LO out_offset)
 
template<typename ValueType >
ValueType any_cast (const any &operand)
 
template<typename ValueType >
ValueType any_cast (any &operand)
 
template<typename ValueType >
ValueType any_cast (any &&operand)
 
template<typename T >
const T * any_cast (const any *operand) noexcept
 
template<typename T >
T * any_cast (any *operand) noexcept
 
template<typename T >
T && move_value (any &a)
 
void swap (Omega_h::any &lhs, Omega_h::any &rhs) noexcept
 
template<typename T >
T * nonnull (T *p)
 
template<typename T >
void fill (Write< T > a, T val)
 
template<typename T >
void fill_linear (Write< T > a, T offset, T stride)
 
template<class T >
void copy_into (Read< T > a, Write< T > b)
 
template<class T >
Write< T > deep_copy (Read< T > a, std::string const &name)
 
template<typename T >
Read< T > read (Write< T > a)
 
template<typename T >
bool operator== (Read< T > a, Read< T > b)
 
template<typename T >
promoted_t< T > get_sum (Read< T > a)
 
template<typename T >
promoted_t< T > get_sum (CommPtr comm, Read< T > a)
 
template<typename T >
T get_min (Read< T > a)
 
template<typename T >
T get_max (Read< T > a)
 
template<typename T >
T get_min (CommPtr comm, Read< T > a)
 
template<typename T >
T get_max (CommPtr comm, Read< T > a)
 
template<typename T >
MinMax< T > get_minmax (CommPtr comm, Read< T > a)
 
bool are_close (Reals a, Reals b, Real tol, Real floor)
 
bool are_close_abs (Reals a, Reals b, Real tol)
 
template<typename T >
Write< T > multiply_each (Read< T > a, Read< T > b, std::string const &name)
 
template<typename T >
Read< T > multiply_each_by (Read< T > a, T b)
 
template<typename T >
Write< T > divide_each (Read< T > a, Read< T > b, std::string const &name)
 
template<typename T >
Write< T > concat (Read< T > a, Read< T > b, std::string const &name)
 
Reals divide_each_maybe_zero (Reals a, Reals b)
 
Reals pow_each (Reals a, Reals b)
 
template<typename T >
Read< T > divide_each_by (Read< T > a, T b)
 
template<typename T >
Read< T > add_each (Read< T > a, Read< T > b, std::string const &name)
 
template<typename T >
Read< T > subtract_each (Read< T > a, Read< T > b)
 
template<typename T >
Read< T > add_to_each (Read< T > a, T b)
 
template<typename T >
Read< T > subtract_from_each (Read< T > a, T b)
 
template<typename T >
Bytes each_geq_to (Read< T > a, T b)
 
template<typename T >
Bytes each_leq_to (Read< T > a, T b)
 
template<typename T >
Bytes each_gt (Read< T > a, T b)
 
template<typename T >
Bytes each_lt (Read< T > a, T b)
 
template<typename T >
Bytes gt_each (Read< T > a, Read< T > b)
 
template<typename T >
Bytes lt_each (Read< T > a, Read< T > b)
 
template<typename T >
Bytes eq_each (Read< T > a, Read< T > b)
 
template<typename T >
Bytes neq_each (Read< T > a, Read< T > b)
 
template<typename T >
Bytes geq_each (Read< T > a, Read< T > b)
 
template<typename T >
Read< T > min_each (Read< T > a, Read< T > b)
 
template<typename T >
Read< T > max_each (Read< T > a, Read< T > b)
 
template<typename T >
Read< T > ternary_each (Bytes cond, Read< T > a, Read< T > b)
 
template<typename T >
Read< T > each_max_with (Read< T > a, T b)
 
template<typename T >
Bytes each_neq_to (Read< T > a, T b)
 
template<typename T >
Bytes each_eq (Read< T > a, Read< T > b)
 
template<typename T >
Bytes each_eq_to (Read< T > a, T b)
 
Bytes land_each (Bytes a, Bytes b)
 
Bytes lor_each (Bytes a, Bytes b)
 
Bytes bit_or_each (Bytes a, Bytes b)
 
Bytes bit_neg_each (Bytes a)
 
Read< Real > fabs_each (Read< Real > a)
 
template<typename T >
Read< T > get_component (Read< T > a, Int ncomps, Int comp)
 
template<typename T >
void set_component (Write< T > out, Read< T > a, Int ncomps, Int comp)
 
template<typename T >
LO find_last (Read< T > array, T value)
 
template<typename T >
bool is_sorted (Read< T > a)
 
template<typename T >
Read< T > interleave (std::vector< Read< T >> arrays)
 
template<typename T >
Read< T > coalesce (std::vector< Read< T >> arrays)
 
int max_exponent (Reals a)
 
Int128 int128_sum (Reals const a, double const unit)
 
Real repro_sum (Reals a)
 
Real repro_sum (CommPtr comm, Reals a)
 
void repro_sum (CommPtr comm, Reals a, Int ncomps, Real result[])
 
Reals interpolate_between (Reals a, Reals b, Real t)
 
Reals invert_each (Reals a)
 
template<typename Tout , typename Tin >
Read< Tout > array_cast (Read< Tin > in)
 
template Read< Real > array_cast (Read< I32 >)
 
template Read< I32 > array_cast (Read< I8 >)
 
Int get_assoc_dim (size_t set_type, Int mesh_dim)
 
MeshSets invert (Mesh *mesh, Assoc const &geom_sets)
 
void update_from_file (Assoc *p_assoc, std::string const &filepath)
 
Assoc read_assoc_file (std::string const &filepath)
 
Assoc get_box_assoc (int dim)
 
OMEGA_H_DEVICE int atomic_fetch_add (int *const dest, const int val)
 
OMEGA_H_DEVICE void atomic_increment (int *const dest)
 
OMEGA_H_DEVICE void atomic_add (int *const dest, const int val)
 
template<Int dim>
BBox< dim > find_bounding_box (Reals coords)
 
template BBox< 1 > find_bounding_box< 1 > (Reals coords)
 
template BBox< 2 > find_bounding_box< 2 > (Reals coords)
 
template BBox< 3 > find_bounding_box< 3 > (Reals coords)
 
template<Int dim>
BBox< dim > get_bounding_box (Mesh *mesh)
 
template BBox< 1 > get_bounding_box< 1 > (Mesh *mesh)
 
template BBox< 2 > get_bounding_box< 2 > (Mesh *mesh)
 
template BBox< 3 > get_bounding_box< 3 > (Mesh *mesh)
 
template<Int dim>
OMEGA_H_INLINE BBox< dim > unite (BBox< dim > a, BBox< dim > b)
 
template<Int dim>
OMEGA_H_INLINE bool are_close (BBox< dim > a, BBox< dim > b)
 
template<Int dim>
OMEGA_H_INLINE BBox< dim > make_equilateral (BBox< dim > bbox)
 
template<Int dim>
OMEGA_H_INLINE Affine< dim > get_affine_from_bbox_into_unit (BBox< dim > bbox)
 
void bcast_mesh (Mesh *mesh, CommPtr new_comm, bool is_source)
 
Dist bi_partition (CommPtr comm, Read< I8 > marks)
 
void make_1d_box (Real x, LO nx, LOs *ev2v_out, Reals *coords_out)
 
void make_2d_box (Real x, Real y, LO nx, LO ny, LOs *qv2v_out, Reals *coords_out)
 
void make_3d_box (Real x, Real y, Real z, LO nx, LO ny, LO nz, LOs *hv2v_out, Reals *coords_out)
 
template<Int dim>
void classify_box_dim (Mesh *mesh, Int ent_dim, Reals centroids, Few< LO, 3 > nel, Vector< 3 > const l)
 
void classify_box (Mesh *mesh, Real x, Real y, Real z, LO nx, LO ny, LO nz)
 
ClassSets get_box_class_sets (Int dim)
 
void add_ents2verts (Mesh *mesh, Int ent_dim, LOs ev2v, GOs vert_globals, GOs elem_globals)
 
void build_verts_from_globals (Mesh *mesh, GOs vert_globals)
 
void build_ents_from_elems2verts (Mesh *mesh, LOs ev2v, GOs vert_globals, GOs elem_globals)
 
void build_from_elems2verts (Mesh *mesh, CommPtr comm, Omega_h_Family family, Int edim, LOs ev2v, Read< GO > vert_globals)
 
void build_from_elems2verts (Mesh *mesh, Omega_h_Family family, Int edim, LOs ev2v, LO nverts)
 
void build_from_elems_and_coords (Mesh *mesh, Omega_h_Family family, Int edim, LOs ev2v, Reals coords)
 
void build_box_internal (Mesh *mesh, Omega_h_Family family, Real x, Real y, Real z, LO nx, LO ny, LO nz, bool symmetric)
 
Mesh build_box (CommPtr comm, Omega_h_Family family, Real x, Real y, Real z, LO nx, LO ny, LO nz, bool symmetric)
 
LOs sort_locally_based_on_rank (LOs servers_to_served, Read< I32 > served_to_rank)
 
void resolve_derived_copies (CommPtr comm, Read< GO > verts2globs, Int deg, LOs *p_ent_verts2verts, Remotes *p_ents2owners)
 
void suggest_slices (GO total, I32 comm_size, I32 comm_rank, GO *p_begin, GO *p_end)
 
void assemble_slices (CommPtr comm, Omega_h_Family family, Int dim, GO global_nelems, GO elem_offset, GOs conn_in, GO global_nverts, GO vert_offset, Reals vert_coords, Dist *p_slice_elems2elems, LOs *p_conn_out, Dist *p_slice_verts2verts)
 
StateConfigs form_state_configs (StatesInProgress const &states)
 
ParserGraph form_states_to_state_configs (StateConfigs const &scs, StatesInProgress const &states)
 
void print_dot (std::string const &filepath, ParserInProgress const &pip)
 
ParserInProgress build_lalr1_parser (GrammarPtr grammar, bool verbose)
 
Parser accept_parser (ParserInProgress const &pip)
 
template<typename To , typename From >
OMEGA_H_INLINE CastIterator< To, From > operator+ (typename CastIterator< To, From >::difference_type n, CastIterator< To, From > it)
 
Read< I8 > check_collapse_class (Mesh *mesh, LOs cands2edges, Read< I8 > cand_codes)
 
Read< I8 > check_collapse_exposure (Mesh *mesh, LOs cands2edges, Read< I8 > cand_codes, Int cell_dim)
 
Read< I8 > check_collapse_exposure (Mesh *mesh, LOs cands2edges, Read< I8 > cand_codes)
 
void classify_sides_by_exposure (Mesh *mesh, Read< I8 > side_is_exposed)
 
void classify_hinges_by_sharpness (Mesh *mesh, Read< I8 > hinge_is_exposed, Read< I8 > hinge_is_sharp)
 
void classify_elements (Mesh *mesh)
 
void classify_by_angles (Mesh *mesh, Real sharp_angle)
 
void project_classification (Mesh *mesh, Int ent_dim, Write< I8 > class_dim, Write< ClassId > class_id, bool relaxed)
 
void project_classification (Mesh *mesh, Int ent_dim, bool relaxed)
 
void finalize_classification (Mesh *mesh)
 
void classify_equal_order (Mesh *mesh, Int ent_dim, LOs eqv2v, Read< ClassId > eq_class_ids)
 
void classify_equal_order (Mesh *mesh, Topo_type ent_type, LOs eqv2v, Read< ClassId > eq_class_ids)
 
bool coarsen_verts (Mesh *mesh, AdaptOpts const &opts, Read< I8 > vert_marks, OvershootLimit overshoot, Improve improve)
 
bool coarsen_by_size (Mesh *mesh, AdaptOpts const &opts)
 
bool coarsen_slivers (Mesh *mesh, AdaptOpts const &opts)
 
HostFew< Read< I8 >, 4 > mark_dead_ents (Mesh *mesh, LOs rails2edges, Read< I8 > rail_col_dirs)
 
Adj find_coarsen_domains (Mesh *mesh, LOs keys2verts, Int ent_dim, Read< I8 > ents_are_dead)
 
Reals coarsen_qualities (Mesh *mesh, LOs cands2edges, Read< I8 > cand_codes)
 
Read< I8 > filter_coarsen_min_qual (Read< I8 > cand_codes, Reals cand_quals, Real min_qual)
 
Read< I8 > filter_coarsen_improve (Mesh *mesh, LOs cands2edges, Read< I8 > cand_codes, Reals cand_quals)
 
Read< I8 > prevent_coarsen_overshoot (Mesh *mesh, Real max_length, LOs cands2edges, Read< I8 > cand_codes)
 
Bytes prevent_coarsen_flip (Mesh *mesh, LOs cands2edges, Bytes cand_codes)
 
void choose_rails (Mesh *mesh, LOs cands2edges, Read< I8 > cand_edge_codes, Reals cand_edge_quals, Read< I8 > *verts_are_cands, Reals *vert_quals, Read< GO > *vert_rails)
 
void find_rails (Mesh *mesh, LOs keys2verts, Read< GO > verts2rail, LOs *rails2edges, Read< I8 > *rail_col_dirs)
 
LOs get_verts_onto (Mesh *mesh, LOs rails2edges, Read< I8 > rail_col_dirs)
 
LOs coarsen_topology (Mesh *mesh, LOs keys2verts_onto, Int dom_dim, Adj keys2doms, LOs old_verts2new_verts)
 
template<Int dim>
Reals compute_flip_normals_dim (Mesh *mesh, Bytes sides_are_exposed, Bytes verts_matter, Real simple_algorithm_threshold=0.95)
 
template<Int dim>
Bytes prevent_coarsen_flip2_dim (Mesh *mesh, Bytes sides_matter, Bytes verts_matter, Reals vert_normals, LOs cands2edges, Bytes cand_codes, Real epsilon=OMEGA_H_EPSILON)
 
template<Int dim>
Bytes prevent_coarsen_flip_dim (Mesh *mesh, LOs cands2edges, Bytes cand_codes)
 
template<Int mesh_dim, Int metric_dim>
Read< I8 > prevent_coarsen_overshoot_tmp (Mesh *mesh, Real max_length, LOs cands2edges, Read< I8 > cand_codes)
 
template<Int mesh_dim, Int metric_dim>
Reals coarsen_qualities_tmpl (Mesh *mesh, LOs cands2edges, Read< I8 > cand_codes)
 
Read< I8 > filter_coarsen_dirs (Read< I8 > codes, Read< I8 > keep_dirs)
 
void mark_dead_ents (Mesh *mesh, LOs rails2edges, Read< I8 > rail_col_dirs, Int cell_dim, Write< I8 > &dead_cells, Write< I8 > &dead_sides)
 
OMEGA_H_INLINE I8 collapses (I8 code, Int col_v)
 
OMEGA_H_INLINE I8 do_collapse (I8 code, Int col_v)
 
OMEGA_H_INLINE I8 dont_collapse (I8 code, Int col_v)
 
Real get_real_diff (Real a, Real b, VarCompareOpts opts)
 
bool compare_real (Real a, Real b, VarCompareOpts opts)
 
template<typename T >
bool compare_arrays (CommPtr comm, Read< T > a, Read< T > b, VarCompareOpts opts, Int ncomps, Int dim, bool verbose)
 
Omega_h_Comparison compare_meshes (Mesh *a, Mesh *b, MeshCompareOpts const &opts, bool verbose, bool full)
 
void get_diff_program_cmdline (std::string const &a_name, std::string const &b_name, CmdLine *p_cmdline)
 
void accept_diff_program_cmdline (CmdLine const &cmdline, Mesh const *mesh, MeshCompareOpts *p_opts, Omega_h_Comparison *p_max_result)
 
bool check_same (Mesh *a, Mesh *b)
 
bool check_regression (filesystem::path const &prefix, Mesh *mesh)
 
Bytes find_bridge_edges (Mesh *mesh)
 
template<Int dim>
Reals get_edge_pad_dists (Mesh *mesh, Read< I8 > edges_are_bridges)
 
template<Int dim>
Reals get_tri_pad_dists (Mesh *mesh, Read< I8 > edges_are_bridges)
 
Reals get_tet_pad_dists (Mesh *mesh, Read< I8 > edges_are_bridges)
 
Reals get_pad_dists (Mesh *mesh, Int pad_dim, Read< I8 > edges_are_bridges)
 
template<Int dim>
Reals get_pinched_tri_angles_dim (Mesh *mesh)
 
Reals get_pinched_tet_angles (Mesh *mesh)
 
Reals get_pinched_angles (Mesh *mesh, Int pinched_dim)
 
SeparationResult separate_by_color_once (Cavs cavs, LOs old_elem_colors, LOs new_elem_colors)
 
void transfer_conserve_refine (Mesh *old_mesh, TransferOpts const &opts, Mesh *new_mesh, LOs keys2edges, LOs keys2prods, LOs prods2new_ents, LOs same_ents2old_ents, LOs same_ents2new_ents)
 
template<Int dim>
void transfer_by_intersection_dim (Mesh *old_mesh, Mesh *new_mesh, TagBase const *tagbase, Cavs cavs, Write< Real > new_data_w)
 
void transfer_densities_and_conserve_swap (Mesh *old_mesh, TransferOpts const &opts, Mesh *new_mesh, LOs keys2edges, LOs keys2prods, LOs prods2new_ents, LOs same_ents2old_ents, LOs same_ents2new_ents)
 
void transfer_densities_and_conserve_coarsen (Mesh *old_mesh, TransferOpts const &opts, Mesh *new_mesh, LOs keys2verts, Adj keys2doms, LOs prods2new_ents, LOs same_ents2old_ents, LOs same_ents2new_ents)
 
void transfer_conserve_motion (Mesh *old_mesh, TransferOpts const &opts, Mesh *new_mesh, LOs keys2verts, Graph keys2elems, LOs same_ents2old_ents, LOs same_ents2new_ents)
 
void setup_conservation_tags (Mesh *mesh, AdaptOpts const &opts)
 
Reals diffuse_densities_once (Mesh *mesh, Graph g, Reals densities, Reals cell_sizes)
 
void correct_momentum_error (Mesh *mesh, TransferOpts const &xfer_opts, Graph diffusion_graph, TagBase const *tagbase, bool verbose)
 
void correct_integral_errors (Mesh *mesh, AdaptOpts const &opts)
 
OMEGA_H_INLINE const char * proc ()
 
OMEGA_H_INLINE const char * rank ()
 
OMEGA_H_INLINE const char * size ()
 
template<class T = int, class U = int>
std::vector< T > range (T start, T stop, bool inclusive=false, U step=1)
 
template<class T = int, class U = int>
std::vector< T > rangeInclusive (T start, T stop, U step=1)
 
template<class T = int, class U = int>
std::vector< T > rangeExclusive (T start, T stop, U step=1)
 
template<class T = int>
std::string to_string (const std::vector< T > &v, const std::string &sep_in=" ")
 
template<class T = int>
std::string to_string (const std::set< T > &v, const std::string &sep_in=" ")
 
template<class K , class V >
std::string to_string (const std::map< K, V > &v, const std::string &sep_in=" ")
 
template<typename F >
auto apply_to_omega_h_types (Omega_h_Type type, const F &&f)
 
Dist create_dist_for_variable_sized (Dist copies2owners, LOs copies2data)
 Creates a Dist object that can be re-used to synchronize variable-sized data per actor. More...
 
void to_dolfin (dolfin::Mesh &mesh_dolfin, Mesh *mesh_osh)
 
void from_dolfin (Mesh *mesh_osh, dolfin::Mesh const &mesh_dolfin)
 
void from_dolfin (Mesh *mesh_osh, dolfin::Function const &function, std::string const &name)
 
Egads * egads_load (std::string const &filename)
 
void egads_classify (Egads *eg, int nadj_faces, int const adj_face_ids[], int *class_dim, int *class_id)
 
void egads_free (Egads *eg)
 
void egads_reclassify (Mesh *mesh, Egads *eg)
 
Reals egads_get_snap_warp (Mesh *mesh, Egads *eg, bool verbose)
 
template<Int n_max, typename T >
OMEGA_H_INLINE T maximum_magnitude (Few< T, n_max > x, Int n)
 
template<Int dim>
Reals get_max_eigenvalues_dim (Reals symms)
 
Reals get_max_eigenvalues (Int dim, Reals symms)
 
OMEGA_H_INLINE Roots< 3 > find_polynomial_roots (Few< Real, 3 > coeffs, Real eps=1e-6)
 
OMEGA_H_INLINE Roots< 2 > find_polynomial_roots (Few< Real, 2 > coeffs, Real eps=1e-6)
 
OMEGA_H_INLINE Roots< 1 > find_polynomial_roots (Few< Real, 1 > coeffs, Real eps=1e-6)
 
OMEGA_H_INLINE Few< Real, 3 > characteristic_polynomial (Tensor< 3 > A)
 
OMEGA_H_INLINE Few< Real, 2 > characteristic_polynomial (Tensor< 2 > A)
 
OMEGA_H_INLINE Few< Real, 1 > characteristic_polynomial (Tensor< 1 > A)
 
template<Int n>
OMEGA_H_INLINE Roots< n > get_eigenvalues (Tensor< n > A)
 
template<Int m>
OMEGA_H_INLINE Tensor< m > subtract_from_diag (Tensor< m > a, Real const mu)
 
OMEGA_H_INLINE Vector< 3 > single_eigenvector (Tensor< 3 > const m, Real const l)
 
template<Int m>
OMEGA_H_INLINE Vector< m > get_1d_row_space (Tensor< m > const a)
 
OMEGA_H_INLINE Few< Vector< 3 >, 2 > double_eigenvector (Tensor< 3 > const m, Real const l)
 
OMEGA_H_INLINE DiagDecomp< 3 > decompose_eigen_dim (Tensor< 3 > const m)
 
OMEGA_H_INLINE Vector< 2 > single_eigenvector (Tensor< 2 > const m, Real const l)
 
OMEGA_H_INLINE DiagDecomp< 2 > decompose_eigen_dim (Tensor< 2 > const m)
 
OMEGA_H_INLINE DiagDecomp< 1 > decompose_eigen_dim (Tensor< 1 > const m)
 
template<Int dim>
OMEGA_H_INLINE DiagDecomp< dim > decompose_eigen (Tensor< dim > m)
 
template<Int dim>
OMEGA_H_INLINE Tensor< dim > compose_eigen (Tensor< dim > const q, Vector< dim > const l)
 
template<Int dim>
OMEGA_H_INLINE Tensor< dim > compose_ortho (Tensor< dim > const q, Vector< dim > l)
 
template<Int dim>
OMEGA_H_INLINE Real norm_off_diag (Tensor< dim > const a)
 
template<Int dim>
OMEGA_H_INLINE Few< Int, 2 > arg_max_off_diag (Tensor< dim > const a)
 
OMEGA_H_INLINE Vector< 2 > schur_sym (Real f, Real g, Real h)
 
template<Int dim>
OMEGA_H_INLINE Tensor< dim > givens_left (Real const c, Real const s, Int const i, Int const k, Tensor< dim > a)
 
template<Int dim>
OMEGA_H_INLINE Tensor< dim > givens_right (Real const c, Real const s, Int const i, Int const k, Tensor< dim > a)
 
template<Int dim>
OMEGA_H_INLINE DiagDecomp< dim > decompose_eigen_jacobi (Tensor< dim > a, Real const eps=DBL_EPSILON, Int max_iter=-1)
 
template<Int dim>
OMEGA_H_INLINE DiagDecomp< dim > sort_by_magnitude (DiagDecomp< dim > const dd)
 
template<Int dim>
OMEGA_H_INLINE_BIG Tensor< dim > log_spd_old (Tensor< dim > const m) OMEGA_H_NOEXCEPT
 
template<Int dim>
OMEGA_H_INLINE_BIG Tensor< dim > exp_spd_old (Tensor< dim > const m) OMEGA_H_NOEXCEPT
 
template<Int dim>
OMEGA_H_INLINE_BIG Tensor< dim > log_spd (Tensor< dim > const m) OMEGA_H_NOEXCEPT
 
template<Int dim>
OMEGA_H_INLINE_BIG Tensor< dim > exp_spd (Tensor< dim > const m) OMEGA_H_NOEXCEPT
 
template<Int dim>
OMEGA_H_INLINE_BIG Tensor< dim > sqrt_spd (Tensor< dim > const m) OMEGA_H_NOEXCEPT
 
OMEGA_H_INLINE Int element_down_template (Omega_h_Family family, Int elem_dim, Int bdry_dim, Int which_bdry, Int which_vert)
 
constexpr OMEGA_H_INLINE Int element_down_template (Int elem_type, Int bdry_type, Int which_bdry, Int which_vert)
 
OMEGA_H_INLINE Int element_degree (Omega_h_Family family, Int from_dim, Int to_dim)
 
OMEGA_H_INLINE Int element_degree (Topo_type from_type, Topo_type to_type)
 
OMEGA_H_INLINE TemplateUp element_up_template (Omega_h_Family family, Int elem_dim, Int bdry_dim, Int which_bdry, Int which_up)
 
OMEGA_H_INLINE TemplateUp element_up_template (Int elem_type, Int bdry_type, Int which_bdry, Int which_up)
 
constexpr char const * dimensional_singular_name (Int dim)
 
constexpr char const * dimensional_singular_name (Topo_type ent_type)
 
constexpr char const * dimensional_plural_name (Int dim)
 
constexpr char const * dimensional_plural_name (Topo_type ent_type)
 
constexpr char const * topological_singular_name (Omega_h_Family family, Int dim)
 
constexpr char const * topological_plural_name (Omega_h_Family family, Int dim)
 
 OMEGA_H_BINARY_OP (OrOp, eval_or(lhs_val, rhs_val))
 
 OMEGA_H_BINARY_OP (AndOp, eval_and(lhs_val, rhs_val))
 
 OMEGA_H_BINARY_OP (GtOp, gt(lhs_val, rhs_val))
 
 OMEGA_H_BINARY_OP (LtOp, lt(lhs_val, rhs_val))
 
 OMEGA_H_BINARY_OP (EqOp, eq(lhs_val, rhs_val))
 
 OMEGA_H_BINARY_OP (AddOp, add(env.dim, lhs_val, rhs_val))
 
 OMEGA_H_BINARY_OP (SubOp, sub(env.dim, lhs_val, rhs_val))
 
 OMEGA_H_BINARY_OP (MulOp, mul(env.size, env.dim, lhs_val, rhs_val))
 
 OMEGA_H_BINARY_OP (DivOp, div(env.dim, lhs_val, rhs_val))
 
 OMEGA_H_BINARY_OP (PowOp, eval_pow(env.dim, lhs_val, rhs_val))
 
void fail (char const *format,...)
 
void protect ()
 
 __attribute__ ((noreturn, format(printf, 1, 2))) void fail(char const *format
 
void fence ()
 
template<Int capacity, typename T >
OMEGA_H_INLINE void add_unique (Few< T, capacity > &stack, Int &n, T e) OMEGA_H_NOEXCEPT
 
template<Int n, typename T >
OMEGA_H_INLINE T average (Few< T, n > x) OMEGA_H_NOEXCEPT
 
template<Int n, typename T , typename Op >
OMEGA_H_INLINE T reduce (Few< T, n > x, Op op) OMEGA_H_NOEXCEPT
 
template<Int n, typename T >
decltype(std::declval< T >() *std::declval< T >()) OMEGA_H_INLINE inner_product (Few< T, n > a, Few< T, n > b) OMEGA_H_NOEXCEPT
 
bool is_little_endian_cpu ()
 
void write_reals_txt (filesystem::path const &filename, Reals a, Int ncomps)
 
void write_reals_txt (std::ostream &stream, Reals a, Int ncomps)
 
Reals read_reals_txt (filesystem::path const &filename, LO n, Int ncomps)
 
Reals read_reals_txt (std::istream &stream, LO n, Int ncomps)
 
OMEGA_H_DLL Mesh read_mesh_file (filesystem::path const &path, CommPtr comm)
 
int get_nstates (FiniteAutomaton const &fa)
 
int get_nsymbols (FiniteAutomaton const &fa)
 
bool get_determinism (FiniteAutomaton const &fa)
 
int get_epsilon0 (FiniteAutomaton const &fa)
 
int get_epsilon1 (FiniteAutomaton const &fa)
 
int add_state (FiniteAutomaton &fa)
 
void add_transition (FiniteAutomaton &fa, int from_state, int at_symbol, int to_state)
 
void add_accept (FiniteAutomaton &fa, int state, int token)
 
void remove_accept (FiniteAutomaton &fa, int state)
 
int step (FiniteAutomaton const &fa, int state, int symbol)
 
int accepts (FiniteAutomaton const &fa, int state)
 
int get_nsymbols_eps (FiniteAutomaton const &fa)
 
void append_states (FiniteAutomaton &fa, FiniteAutomaton const &other)
 
FiniteAutomaton make_char_nfa (bool is_deterministic_init, int nstates_reserve)
 
void add_char_transition (FiniteAutomaton &fa, int from_state, char at_char, int to_state)
 
bool is_symbol (char c)
 
int get_symbol (char c)
 
char get_char (int symbol)
 
FiniteAutomaton make_char_set_nfa (std::set< char > const &accepted, int token)
 
FiniteAutomaton make_char_range_nfa (char range_start, char range_end, int token)
 
FiniteAutomaton make_char_single_nfa (char symbol_char, int token)
 
std::set< char > negate_set (std::set< char > const &s)
 
std::ostream & operator<< (std::ostream &os, FiniteAutomaton const &fa)
 
template<Int dim>
OMEGA_H_DEVICE QRFactorization< MaxFitPoints< dim >::value, dim+1 > get_cavity_qr_factorization (LO k, LOs const &k2ke, LOs const &ke2e, LOs const &ev2v, Reals const &coords)
 
template<Int dim>
OMEGA_H_DEVICE Vector< dim+1 > fit_cavity_polynomial (QRFactorization< MaxFitPoints< dim >::value, dim+1 > qr, LO k, LOs const &k2ke, LOs const &ke2e, Reals const &e_data, Int comp, Int ncomps)
 
template<Int dim>
OMEGA_H_DEVICE Real eval_polynomial (Vector< dim+1 > coeffs, Vector< dim > x)
 
template<Int dim>
void compute_ill_metric_dim (Mesh *mesh, AdaptOpts const &opts, Omega_h_Isotropy isotropy)
 
template<typename InputIterator , typename UnaryFunction >
void for_each (InputIterator first, InputIterator last, UnaryFunction &&f)
 
template<typename UnaryFunction >
void parallel_for (LO n, UnaryFunction &&f)
 
template<typename T >
void parallel_for (LO n, T const &f, char const *name="")
 
template<typename T >
void parallel_for (char const *name, LO n, T const &f)
 
Dist get_local_elem_uses2own_verts (Mesh *mesh)
 
Remotes get_local_elem_uses2own_elems (Mesh *mesh)
 
Remotes push_elem_uses (RemoteGraph own_verts2own_elems, Dist own_verts2verts)
 
void ghost_mesh (Mesh *mesh, Int nlayers, bool verbose)
 
void partition_by_verts (Mesh *mesh, bool verbose)
 
void partition_by_elems (Mesh *mesh, bool verbose)
 
void get_own_verts2own_elem_uses (Mesh *mesh, Remotes &serv_uses2own_elems, LOs &own_verts2serv_uses)
 
template<typename T >
GOs rescan_globals (Mesh *mesh, Read< T > counts)
 
int get_nnonterminals (Grammar const &g)
 
bool is_terminal (Grammar const &g, int symbol)
 
bool is_nonterminal (Grammar const &g, int symbol)
 
int as_nonterminal (Grammar const &g, int symbol)
 
int find_goal_symbol (Grammar const &g)
 
void add_end_terminal (Grammar &g)
 
int get_end_terminal (Grammar const &g)
 
void add_accept_production (Grammar &g)
 
int get_accept_production (Grammar const &g)
 
int get_accept_nonterminal (Grammar const &g)
 
std::ostream & operator<< (std::ostream &os, Grammar const &g)
 
Graph add_edges (Graph g1, Graph g2)
 combine the edges of two graphs that have the same set of nodes
 
Graph unmap_graph (LOs a2b, Graph b2c)
 traverse two graphs a2b and b2c to form and return a graph from a2c
 
template<typename T >
Read< T > graph_reduce (Graph a2b, Read< T > b_data, Int width, Omega_h_Op op)
 apply reduction operation op to the edge data associated with each source node More...
 
Reals graph_weighted_average_arc_data (Graph a2b, Reals ab_weights, Reals ab_data, Int width)
 
Reals graph_weighted_average (Graph a2b, Reals ab_weights, Reals b_data, Int width)
 
Graph filter_graph_edges (Graph g, Read< I8 > keep_edge)
 
Graph filter_graph_nodes (Graph g, Read< I8 > keep_node)
 
bool operator== (Graph a, Graph b)
 
Graph identity_graph (LO nnodes)
 
Graph add_self_edges (Graph g)
 
template<typename T >
void map_into (Read< T > a_data, Graph a2b, Write< T > b_data, Int width)
 
template<typename T >
Read< T > map_onto (Read< T > a_data, Graph a2b, LO nb, T init_val, Int width)
 
Histogram get_histogram (Mesh *mesh, Int dim, Int nbins, Real min_value, Real max_value, Reals values)
 
void print_histogram (Histogram const &histogram, std::string const &name)
 
void print_goal_stats (Mesh *mesh, char const *name, Int ent_dim, Reals values, MinMax< Real > desired, MinMax< Real > actual)
 
void render_histogram_matplotlib (Histogram const &histogram, std::string const &filepath)
 
OMEGA_H_INLINE Int hypercube_down_template (Int elem_dim, Int bdry_dim, Int which_bdry, Int which_vert)
 Relates bounding hypercube vertices the parent hypercube's vertices. More...
 
OMEGA_H_INLINE TemplateUp hypercube_up_template (Int elem_dim, Int bdry_dim, Int which_bdry, Int which_up)
 
constexpr OMEGA_H_INLINE Int hypercube_degree (Int from_dim, Int to_dim)
 
constexpr char const * hypercube_singular_name (Int dim)
 
constexpr char const * hypercube_plural_name (Int dim)
 
constexpr OMEGA_H_INLINE Int hypercube_split_degree (Int parent_dim, Int child_dim)
 
OMEGA_H_INLINE SplitVertex hypercube_split_template (Int parent_dim, Int child_dim, Int which_child, Int which_child_vtx)
 
Read< I8 > find_indset (Mesh *mesh, Int ent_dim, Graph graph, Reals quality, Read< I8 > candidates)
 
Read< I8 > find_indset (Mesh *mesh, Int ent_dim, Reals quality, Read< I8 > candidates)
 
std::string get_full_name (Input const &input)
 
template<class InputType >
bool is_type (Input &input)
 
template<class InputType >
InputType & as_type (Input &input)
 
InputMap read_input (Omega_h::filesystem::path const &path)
 
void update_class_sets (ClassSets *p_sets, InputMap &pl)
 
void echo_input (std::ostream &stream, Input &input)
 
void check_unused (Input &input)
 
OMEGA_H_INLINE Int128 operator+ (Int128 lhs, Int128 rhs)
 
OMEGA_H_INLINE Int128 operator- (Int128 lhs, Int128 rhs)
 
OMEGA_H_INLINE Int128 operator- (Int128 x)
 
OMEGA_H_INLINE Int128 operator>> (Int128 x, int expo)
 
OMEGA_H_INLINE bool operator== (Int128 lhs, Int128 rhs)
 
OMEGA_H_INLINE bool operator< (Int128 lhs, Int128 rhs)
 
OMEGA_H_INLINE IntIterator operator+ (IntIterator::difference_type n, IntIterator it) noexcept
 
template<typename T >
LOs offset_scan (Read< T > a, std::string const &name)
 
template LOs offset_scan (Read< I8 > a, std::string const &name)
 
template LOs offset_scan (Read< I32 > a, std::string const &name)
 
void fill_right (Write< LO > a)
 
Policy policy (LO n)
 
GrammarPtr build_grammar (Language const &language)
 
std::ostream & operator<< (std::ostream &os, Language const &lang)
 
FiniteAutomaton build_lexer (Language const &language)
 
ReaderTablesPtr build_reader_tables (Language const &language)
 
Reals solve_laplacian (Mesh *mesh, Reals initial, Int width, Real tol, Real floor)
 
OMEGA_H_INLINE Vector< 4 > quaternion_from_tensor (Matrix< 3, 3 > const R) OMEGA_H_NOEXCEPT
 
OMEGA_H_INLINE Vector< 3 > axis_angle_from_quaternion (Vector< 4 > const q) OMEGA_H_NOEXCEPT
 
OMEGA_H_INLINE Vector< 3 > axis_angle_from_tensor (Matrix< 3, 3 > const R) OMEGA_H_NOEXCEPT
 
OMEGA_H_INLINE Vector< 1 > axis_angle_from_tensor (Matrix< 2, 2 > const R) OMEGA_H_NOEXCEPT
 
OMEGA_H_INLINE Vector< 4 > quaternion_from_axis_angle (Vector< 3 > const aa) OMEGA_H_NOEXCEPT
 
OMEGA_H_INLINE Matrix< 3, 3 > tensor_from_quaternion (Vector< 4 > const qq)
 
OMEGA_H_INLINE Matrix< 3, 3 > tensor_from_axis_angle (Vector< 3 > const aa) OMEGA_H_NOEXCEPT
 
OMEGA_H_INLINE Matrix< 2, 2 > tensor_from_axis_angle (Vector< 1 > const aa) OMEGA_H_NOEXCEPT
 
OMEGA_H_INLINE Matrix< 3, 3 > pack_polar (Matrix< 3, 3 > const spd, Vector< 3 > const aa) OMEGA_H_NOEXCEPT
 
OMEGA_H_INLINE Matrix< 3, 3 > unpack_polar_spd (Matrix< 3, 3 > const packed) OMEGA_H_NOEXCEPT
 
OMEGA_H_INLINE Vector< 3 > unpack_polar_axis_angle (Matrix< 3, 3 > const packed) OMEGA_H_NOEXCEPT
 
OMEGA_H_INLINE Matrix< 2, 2 > pack_polar (Matrix< 2, 2 > const spd, Vector< 1 > const aa) OMEGA_H_NOEXCEPT
 
OMEGA_H_INLINE Matrix< 2, 2 > unpack_polar_spd (Matrix< 2, 2 > const packed) OMEGA_H_NOEXCEPT
 
OMEGA_H_INLINE Vector< 1 > unpack_polar_axis_angle (Matrix< 2, 2 > const packed) OMEGA_H_NOEXCEPT
 
template<Int dim>
OMEGA_H_INLINE Matrix< dim, dim > log_polar (Matrix< dim, dim > const F) OMEGA_H_NOEXCEPT
 
OMEGA_H_INLINE Matrix< 1, 1 > log_polar (Matrix< 1, 1 > const F) OMEGA_H_NOEXCEPT
 
template<Int dim>
OMEGA_H_INLINE Matrix< dim, dim > exp_polar (Matrix< dim, dim > const packed_polar) OMEGA_H_NOEXCEPT
 
OMEGA_H_INLINE Matrix< 1, 1 > exp_polar (Matrix< 1, 1 > const log_F) OMEGA_H_NOEXCEPT
 
template<Int dim>
OMEGA_H_INLINE void align_packed_axis_angles (Matrix< dim, dim > *const a, Int const n, Real const tolerance) OMEGA_H_NOEXCEPT
 
OMEGA_H_INLINE void align_packed_axis_angles (Matrix< 1, 1 > *const, Int const, Real const) OMEGA_H_NOEXCEPT
 
Remotes globals_to_linear_owners (Read< GO > globals, GO total, I32 comm_size)
 
LO linear_partition_size (GO total, I32 comm_size, I32 comm_rank)
 
Remotes globals_to_linear_owners (CommPtr comm, Read< GO > globals, GO total)
 
LO linear_partition_size (CommPtr comm, GO total)
 
GO find_total_globals (CommPtr comm, Read< GO > globals)
 
Dist copies_to_linear_owners (CommPtr comm, Read< GO > globals)
 
void * host_malloc (std::size_t size)
 
void host_free (void *ptr, std::size_t)
 
void enable_pooling ()
 
void disable_pooling ()
 
bool is_pooling_enabled ()
 
void * maybe_pooled_host_malloc (std::size_t size)
 
void maybe_pooled_host_free (void *ptr, std::size_t size)
 
template<typename T >
void add_into (Read< T > a_data, LOs a2b, Write< T > b_data, Int width)
 
template<typename T >
void map_into (Read< T > a_data, LOs a2b, Write< T > b_data, Int width)
 
template<typename T >
void map_value_into (T a_value, LOs a2b, Write< T > b_data)
 
template<typename T >
void map_into_range (Read< T > a_data, LO begin, LO end, Write< T > b_data, Int width)
 
template<typename T >
Read< T > map_onto (Read< T > a_data, LOs a2b, LO nb, T init_val, Int width)
 
template<typename T >
Write< T > unmap (LOs a2b, Read< T > b_data, Int width)
 return the array of b_data in the order specified by a2b More...
 
template<typename T >
Read< T > unmap_range (LO begin, LO end, Read< T > b_data, Int width)
 
template<typename T >
void expand_into (Read< T > a_data, LOs a2b, Write< T > b_data, Int width)
 
template<typename T >
Read< T > expand (Read< T > a_data, LOs a2b, Int width)
 
template<typename T >
Read< T > permute (Read< T > a_data, LOs a2b, Int width)
 
LOs multiply_fans (LOs a2b, LOs a2c)
 
LOs compound_maps (LOs a2b, LOs b2c)
 
LOs invert_permutation (LOs a2b)
 
Read< I8 > invert_marks (Read< I8 > marks)
 
LOs collect_marked (Read< I8 > marks)
 collect the indices of all marked entries into a compact array More...
 
Read< I8 > mark_image (LOs a2b, LO nb)
 
void inject_map (LOs a2b, Write< LO > b2a)
 
LOs invert_injective_map (LOs a2b, LO nb)
 
LOs invert_funnel (LOs ab2a, LO na)
 given the source node index in A for a list of edges between nodes in set A and B, sorted by their source node in A, and the number of nodes in A, construct the map from source nodes to edges (the 'offset' array, 'a2ab'). More...
 
Graph invert_map_by_sorting (LOs a2b, LO nb)
 see invert_map_by_atomics
 
Graph invert_map_by_atomics (LOs const a2b, LO const nb, std::string const &b2ba_name="", std::string const &ba2a_name="")
 given a bipartite graph from set A to B with nodes in A having degree 1 and nodes in B having degree > 1, and the array of indices mapping A to B (a2b), construct the graph from B to A. More...
 
LOs get_degrees (LOs offsets, std::string const &name)
 
LOs invert_fan (LOs a2b)
 the opposite of invert_funnel More...
 
Bytes mark_fan_preimage (LOs a2b)
 
template<typename Functor >
Read< typename Functor::input_type > fan_reduce_tmpl (LOs a2b, Read< typename Functor::input_type > b_data, Int width)
 
template<typename T >
Read< T > fan_reduce (LOs a2b, Read< T > b_data, Int width, Omega_h_Op op)
 apply reduction operation op to each sub-array of data from b_data defined by the offset array a2b More...
 
template<typename T >
Read< T > fan_sum (LOs a2b, Read< T > b_data)
 
template<typename T >
Read< T > fan_max (LOs a2b, Read< T > b_data)
 
template<typename T >
Read< T > fan_min (LOs a2b, Read< T > b_data)
 
Read< I8 > mark_exposed_sides (Mesh *mesh)
 
Read< I8 > mark_down (Graph l2h, Read< I8 > high_marked)
 
Read< I8 > mark_down (Mesh *mesh, Int high_dim, Int low_dim, Read< I8 > high_marked)
 
Read< I8 > mark_up (Mesh *mesh, Int low_dim, Int high_dim, Read< I8 > low_marked)
 
Read< I8 > mark_adj (Mesh *mesh, Int from_dim, Int to_dim, Read< I8 > from_marked)
 
Read< I8 > mark_up_all (Mesh *mesh, Int low_dim, Int high_dim, Read< I8 > low_marked)
 
Read< I8 > mark_by_class_dim (Mesh *mesh, Int ent_dim, Int class_dim)
 
Read< I8 > mark_by_class (Mesh *mesh, Int ent_dim, Int class_dim, I32 class_id)
 
Read< I8 > mark_class_closure (Mesh *mesh, Int ent_dim, Int class_dim, ClassId class_id)
 
Read< I8 > get_eq_marks (Mesh *mesh, Int class_dim, std::vector< ClassId > const &class_ids)
 
Read< I8 > mark_class_closures (Mesh *mesh, Int ent_dim, Int class_dim, std::vector< ClassId > const &class_ids)
 
Read< I8 > mark_class_closures (Mesh *mesh, Int class_dim, std::vector< ClassId > const &class_ids, Graph nodes2ents)
 
Read< I8 > mark_class_closures (Mesh *mesh, Int ent_dim, std::vector< ClassPair > const &class_pairs)
 
Read< I8 > mark_class_closures (Mesh *mesh, std::vector< ClassPair > const &class_pairs, Graph nodes2ents[4])
 
Read< I8 > mark_dual_layers (Mesh *mesh, Read< I8 > marks, Int nlayers)
 
GO count_owned_marks (Mesh *mesh, Int ent_dim, Read< I8 > marks)
 
Read< I8 > mark_sliver_layers (Mesh *mesh, Real qual_ceil, Int nlayers)
 
Read< I8 > mark_by_owner (Mesh *mesh, Int ent_dim, I32 rank)
 
template<typename T >
OMEGA_H_DEVICE Int binary_search (Read< T > const &a, T v, LO n)
 
template<Int dim>
Reals repeat_symm (LO const n, Tensor< dim > const symm)
 
template Reals repeat_symm (LO const n, Tensor< 3 > const symm)
 
template Reals repeat_symm (LO const n, Tensor< 2 > const symm)
 
template Reals repeat_symm (LO const n, Tensor< 1 > const symm)
 
template<Int old_dim, Int new_dim>
Reals resize_symms_tmpl (Reals old_symms)
 
Reals resize_symms (Reals old_symms, Int old_dim, Int new_dim)
 
template<Int dim>
Reals repeat_matrix (LO const n, Tensor< dim > const m)
 
template Reals repeat_matrix (LO const n, Tensor< 3 > const m)
 
template Reals repeat_matrix (LO const n, Tensor< 2 > const m)
 
template Reals repeat_matrix (LO const n, Tensor< 1 > const m)
 
template<Int dim>
Reals matrices_times_vectors_dim (Reals ms, Reals vs)
 
Reals matrices_times_vectors (Reals ms, Reals vs, Int dim)
 
template<Int dim>
Reals matrices_times_matrices_dim (Reals a, Reals b)
 
Reals matrices_times_matrices (Reals a, Reals b, Int dim)
 
template<Int dim>
Reals symms_inria2osh_dim (Reals symms)
 
Reals symms_inria2osh (Int dim, Reals symms)
 
template<Int dim>
Reals symms_osh2inria_dim (Reals symms)
 
Reals symms_osh2inria (Int dim, Reals symms)
 
template<Int dim>
Reals matrices_to_symms_dim (Reals const matrices)
 
Reals matrices_to_symms (Reals const matrices, Int const dim)
 
template<Int m, Int n>
OMEGA_H_INLINE Real * scalar_ptr (Matrix< m, n > &a)
 
template<Int m, Int n>
OMEGA_H_INLINE Real const * scalar_ptr (Matrix< m, n > const &a)
 
template<Int m, Int n>
OMEGA_H_INLINE Vector< m > operator* (Matrix< m, n > a, Vector< n > b) OMEGA_H_NOEXCEPT
 
template<Int m, Int n, Int p>
OMEGA_H_INLINE Matrix< m, n > operator* (Matrix< m, p > a, Matrix< p, n > b)
 
template<Int m, Int n>
OMEGA_H_INLINE Matrix< n, m > transpose (Matrix< m, n > a)
 
template<Int max_m, Int max_n>
OMEGA_H_INLINE Matrix< max_m, max_n > identity_matrix (Int m, Int n)
 
template<Int max_m, Int max_n>
OMEGA_H_INLINE Matrix< max_m, max_n > identity_matrix ()
 
template<Int dim>
OMEGA_H_INLINE Tensor< dim > identity_tensor ()
 
OMEGA_H_INLINE Matrix< 1, 1 > matrix_1x1 (Real a)
 
OMEGA_H_INLINE Tensor< 1 > tensor_1 (Real a)
 
OMEGA_H_INLINE Matrix< 2, 2 > matrix_2x2 (Real a, Real b, Real c, Real d)
 
OMEGA_H_INLINE Tensor< 2 > tensor_2 (Real a, Real b, Real c, Real d)
 
OMEGA_H_INLINE Matrix< 3, 3 > matrix_3x3 (Real a, Real b, Real c, Real d, Real e, Real f, Real g, Real h, Real i)
 
OMEGA_H_INLINE Tensor< 3 > tensor_3 (Real a, Real b, Real c, Real d, Real e, Real f, Real g, Real h, Real i)
 
template<Int m, Int n>
OMEGA_H_INLINE Matrix< m, n > operator* (Matrix< m, n > a, Real b)
 
template<Int m, Int n>
OMEGA_H_INLINE Matrix< m, n > & operator*= (Matrix< m, n > &a, Real b)
 
template<Int m, Int n>
OMEGA_H_INLINE Matrix< m, n > operator* (Real a, Matrix< m, n > b)
 
template<Int m, Int n>
OMEGA_H_INLINE Matrix< m, n > operator/ (Matrix< m, n > a, Real b)
 
template<Int m, Int n>
OMEGA_H_INLINE Matrix< m, n > & operator/= (Matrix< m, n > &a, Real b)
 
template<Int m, Int n>
OMEGA_H_INLINE Matrix< m, n > operator+ (Matrix< m, n > a, Matrix< m, n > b)
 
template<Int m, Int n>
OMEGA_H_INLINE Matrix< m, n > & operator+= (Matrix< m, n > &a, Matrix< m, n > b)
 
template<Int m, Int n>
OMEGA_H_INLINE Matrix< m, n > operator- (Matrix< m, n > a, Matrix< m, n > b)
 
template<Int m, Int n>
OMEGA_H_INLINE Matrix< m, n > & operator-= (Matrix< m, n > &a, Matrix< m, n > b)
 
template<Int m, Int n>
OMEGA_H_INLINE Matrix< m, n > operator- (Matrix< m, n > a)
 
template<Int m, Int n>
OMEGA_H_INLINE Real max_norm (Matrix< m, n > a)
 
template<Int m, Int n>
OMEGA_H_INLINE bool are_close (Matrix< m, n > a, Matrix< m, n > b, Real tol=EPSILON, Real floor=EPSILON)
 
template<Int m, Int n>
OMEGA_H_INLINE Matrix< m, n > outer_product (Vector< m > a, Vector< n > b)
 
template<Int m>
OMEGA_H_INLINE Real trace (Tensor< m > a)
 
template<Int m>
OMEGA_H_INLINE Vector< m > diagonal (Tensor< m > a)
 
template<Int m, Int n>
OMEGA_H_INLINE Matrix< m, n > zero_matrix ()
 
OMEGA_H_INLINE Real determinant (Tensor< 1 > m)
 
OMEGA_H_INLINE Real determinant (Tensor< 2 > m)
 
OMEGA_H_INLINE Real determinant (Tensor< 3 > m)
 
template<Int max_m, Int max_n>
OMEGA_H_INLINE Real inner_product (Int m, Int n, Matrix< max_m, max_n > a, Matrix< max_m, max_n > b)
 
template<Int m, Int n>
OMEGA_H_INLINE Real inner_product (Matrix< m, n > a, Matrix< m, n > b)
 
template<Int max_m, Int max_n>
OMEGA_H_INLINE Real norm (Int const m, Int const n, Matrix< max_m, max_n > const &a)
 
template<Int m, Int n>
OMEGA_H_INLINE Real norm (Matrix< m, n > const &a)
 
OMEGA_H_INLINE Tensor< 3 > cross (Vector< 3 > const &a)
 
OMEGA_H_INLINE Vector< 3 > uncross (Tensor< 3 > const &c)
 
OMEGA_H_INLINE Tensor< 1 > invert (Tensor< 1 > const &m)
 
OMEGA_H_INLINE Tensor< 2 > invert (Tensor< 2 > const &m)
 
OMEGA_H_INLINE Tensor< 3 > invert (Tensor< 3 > const &a)
 
template<Int m, Int n>
OMEGA_H_INLINE std::enable_if<(n==m), Matrix< n, m > >::type pseudo_invert (Matrix< m, n > const &a)
 
template<Int m, Int n>
OMEGA_H_INLINE std::enable_if<(n< m), Matrix< n, m > >::type pseudo_invert (Matrix< m, n > const &a)
 
template<Int m, Int n>
OMEGA_H_INLINE std::enable_if<(n > m), Matrix< n, m > >::type pseudo_invert (Matrix< m, n > const &a)
 
template<Int m>
OMEGA_H_INLINE Tensor< m > diagonal (Vector< m > v)
 
constexpr OMEGA_H_INLINE Int symm_ncomps (Int dim)
 
OMEGA_H_INLINE Vector< 1 > symm2vector (Tensor< 1 > symm)
 
OMEGA_H_INLINE Tensor< 1 > vector2symm (Vector< 1 > v)
 
OMEGA_H_INLINE Vector< 3 > symm2vector (Tensor< 2 > symm)
 
OMEGA_H_INLINE Tensor< 2 > vector2symm (Vector< 3 > v)
 
OMEGA_H_INLINE Vector< 6 > symm2vector (Tensor< 3 > symm)
 
OMEGA_H_INLINE Tensor< 3 > vector2symm (Vector< 6 > v)
 
OMEGA_H_INLINE Tensor< 1 > vector2symm_inria (Vector< 1 > v)
 
OMEGA_H_INLINE Tensor< 2 > vector2symm_inria (Vector< 3 > v)
 
OMEGA_H_INLINE Tensor< 3 > vector2symm_inria (Vector< 6 > v)
 
OMEGA_H_INLINE Vector< 1 > symm2vector_inria (Tensor< 1 > symm)
 
OMEGA_H_INLINE Vector< 3 > symm2vector_inria (Tensor< 2 > symm)
 
OMEGA_H_INLINE Vector< 6 > symm2vector_inria (Tensor< 3 > symm)
 
constexpr OMEGA_H_INLINE Int matrix_ncomps (Int m, Int n)
 
template<Int m, Int n>
OMEGA_H_INLINE Vector< matrix_ncomps(m, n)> matrix2vector (Matrix< m, n > a)
 
template<Int m, Int n>
OMEGA_H_INLINE Matrix< m, n > vector2matrix (Vector< matrix_ncomps(m, n)> v)
 
template<Int n>
OMEGA_H_DEVICE void set_symm (Write< Real > const &a, Int i, Tensor< n > symm)
 
template<Int n, typename Arr >
OMEGA_H_DEVICE Tensor< n > get_symm (Arr const &a, Int i)
 
template<Int m, Int n>
OMEGA_H_DEVICE void set_matrix (Write< Real > const &matrices, Int i, Matrix< m, n > matrix)
 
template<Int m, Int n, typename Arr >
OMEGA_H_DEVICE Matrix< m, n > get_matrix (Arr const &matrices, Int const i)
 
OMEGA_H_INLINE Tensor< 3 > rotate (Real const angle, Vector< 3 > const axis)
 
OMEGA_H_INLINE Tensor< 2 > rotate (Real const angle)
 
OMEGA_H_INLINE Real rotation_angle (Tensor< 2 > const r)
 
OMEGA_H_INLINE Real rotation_angle (Tensor< 3 > const r)
 
OMEGA_H_INLINE Tensor< 1 > form_ortho_basis (Vector< 1 > const v)
 
OMEGA_H_INLINE Tensor< 2 > form_ortho_basis (Vector< 2 > const v)
 
OMEGA_H_INLINE Tensor< 3 > form_ortho_basis (Vector< 3 > const v)
 
template<Int dim>
OMEGA_H_INLINE Tensor< dim > deviator (Tensor< dim > const a)
 
template<int new_dim, int old_dim>
OMEGA_H_INLINE Tensor< new_dim > resize (Tensor< old_dim > const m)
 
bool can_print (Mesh *mesh)
 
Real repro_sum_owned (Mesh *mesh, Int ent_dim, Reals a)
 
Reals average_field (Mesh *mesh, Int ent_dim, LOs a2e, Int ncomps, Reals v2x)
 
Reals average_field (Mesh *mesh, Int ent_dim, Int ncomps, Reals v2x)
 
void get_all_dim_tags (Mesh *mesh, Int dim, TagSet *tags)
 
TagSet get_all_mesh_tags (Mesh *mesh)
 
void ask_for_mesh_tags (Mesh *mesh, TagSet const &tags)
 
LOs ents_on_closure (Mesh *mesh, std::set< std::string > const &class_names, Int ent_dim)
 
LOs nodes_on_closure (Mesh *mesh, std::set< std::string > const &class_names, Graph nodes2ents[4])
 
void assign (Mesh &a, Mesh const &b)
 
void reorder_by_hilbert (Mesh *mesh)
 
void reorder_by_globals (Mesh *mesh)
 
bool is_rc_tag (std::string const &name)
 
Int get_metric_dim (Int ncomps)
 
Int get_metrics_dim (LO nmetrics, Reals metrics)
 
Int get_metric_dim (Mesh *mesh)
 
template<Int dim>
Reals clamp_metrics_dim (LO nmetrics, Reals metrics, Real h_min, Real h_max)
 
Reals clamp_metrics (LO nmetrics, Reals metrics, Real h_min, Real h_max)
 Clamps metric tensors to enforce bounds on desired edge lengths. More...
 
template<Int mdim, Int edim>
Reals get_mident_metrics_tmpl (Mesh *mesh, LOs a2e, Reals v2m, bool has_degen)
 
Reals get_mident_metrics (Mesh *mesh, Int ent_dim, LOs entities, Reals v2m, bool has_degen)
 
Reals get_mident_metrics (Mesh *mesh, Int ent_dim, Reals v2m, bool has_degen)
 
Reals interpolate_between_metrics (LO nmetrics, Reals a, Reals b, Real t)
 
template<Int dim>
Reals linearize_metrics_dim (Reals metrics)
 
template<Int dim>
Reals delinearize_metrics_dim (Reals lms)
 
Reals linearize_metrics (LO nmetrics, Reals metrics)
 
Reals delinearize_metrics (LO nmetrics, Reals linear_metrics)
 
template<Int mesh_dim, Int metric_dim>
Reals limit_gradation_once_tmpl (Mesh *mesh, Reals values, Real max_rate)
 
Reals limit_metric_gradation (Mesh *mesh, Reals values, Real max_rate, Real tol, bool verbose)
 
template<Int metric_dim>
Reals project_metrics_dim (Mesh *mesh, Reals e2m)
 
Reals project_metrics (Mesh *mesh, Reals e2m)
 
Reals smooth_metric_once (Mesh *mesh, Reals v2m, bool has_degen)
 
template<Int dim>
Reals element_implied_length_metrics_dim (Mesh *mesh)
 
Reals get_element_implied_length_metrics (Mesh *mesh)
 
Reals get_pure_implied_metrics (Mesh *mesh)
 
Reals get_implied_metrics (Mesh *mesh)
 
Reals get_pure_implied_isos (Mesh *mesh)
 
Reals get_implied_isos (Mesh *mesh)
 
template<Int dim>
Reals metric_from_hessians_dim (Reals hessians, Real eps)
 
Reals get_hessian_metrics (Int dim, Reals hessians, Real eps)
 
template<Int dim>
Reals metric_from_gradients_dim (Reals gradients, Real eps)
 
Reals get_gradient_metrics (Int dim, Reals gradients, Real eps)
 
template<Int dim>
void get_curve_curvature_metrics (SurfaceInfo surface_info, Real segment_angle, Write< Real > out)
 
Reals get_curvature_metrics (Mesh *mesh, Real segment_angle)
 
template<Int mesh_dim, Int metric_dim>
Reals get_complexity_per_elem_tmpl (Mesh *mesh, Reals v2m)
 
Reals get_complexity_per_elem (Mesh *mesh, Reals v2m)
 
Reals get_nelems_per_elem (Mesh *mesh, Reals v2m)
 
Real get_complexity (Mesh *mesh, Reals v2m)
 
Real get_expected_nelems_from_complexity (Real complexity, Int dim)
 
Real get_expected_nelems (Mesh *mesh, Reals v2m)
 
Real get_metric_scalar_for_nelems (Int elem_dim, Real expected_nelems, Real target_nelems)
 
Real get_metric_scalar_for_nelems (Mesh *mesh, Reals v2m, Real target_nelems)
 
template<Int dim>
Reals intersect_metrics_dim (Reals a, Reals b)
 
Reals intersect_metrics (LO nmetrics, Reals a, Reals b)
 
template<Int new_dim>
Reals metrics_from_isos_dim (Reals isos)
 
Reals metrics_from_isos (Int new_dim, Reals isos)
 
template<Int dim>
Reals get_size_isos_dim (Reals metrics)
 
Reals apply_isotropy (LO nmetrics, Reals metrics, Omega_h_Isotropy isotropy)
 
Reals isos_from_lengths (Reals h)
 
Reals lengths_from_isos (Reals l)
 
template<Int dim>
OMEGA_H_INLINE Real metric_product (Tensor< dim > const m, Vector< dim > const v)
 
template<Int space_dim>
OMEGA_H_INLINE std::enable_if<(space_dim > 1), Real >::type metric_product (Tensor< 1 > const m, Vector< space_dim > const v)
 
template<Int metric_dim, Int space_dim>
OMEGA_H_INLINE Real metric_length (Tensor< metric_dim > const m, Vector< space_dim > const v)
 
template<Int dim>
OMEGA_H_INLINE Real metric_desired_length (Tensor< dim > const m, Vector< dim > const dir)
 
OMEGA_H_INLINE Real metric_length_from_eigenvalue (Real const l)
 
OMEGA_H_INLINE Real metric_eigenvalue_from_length (Real const h)
 
template<Int dim>
OMEGA_H_INLINE Vector< dim > metric_lengths_from_eigenvalues (Vector< dim > const l)
 
template<Int dim>
OMEGA_H_INLINE Vector< dim > metric_eigenvalues_from_lengths (Vector< dim > const h)
 
template<Int dim>
OMEGA_H_INLINE Tensor< dim > compose_metric (Tensor< dim > const r, Vector< dim > const h)
 
template<Int dim>
OMEGA_H_INLINE_BIG DiagDecomp< dim > decompose_metric (Tensor< dim > const m)
 
template<Int dim>
OMEGA_H_INLINE_BIG Tensor< dim > linearize_metric (Tensor< dim > const m)
 
template<Int dim>
OMEGA_H_INLINE_BIG Tensor< dim > delinearize_metric (Tensor< dim > const log_m)
 
template<Int n, typename T >
OMEGA_H_INLINE_BIG Few< T, n > linearize_metrics (Few< T, n > ms)
 
template<Int dim>
OMEGA_H_INLINE_BIG void average_metric_contrib (Tensor< dim > &am, Int &n, Tensor< dim > const m, bool const has_degen)
 
template<Int dim>
OMEGA_H_INLINE_BIG Tensor< dim > average_metric_finish (Tensor< dim > am, Int const n, bool const has_degen)
 
template<Int dim, Int n>
OMEGA_H_INLINE_BIG Tensor< dim > average_metric (Few< Tensor< dim >, n > const ms, bool const has_degen)
 
template<Int dim>
OMEGA_H_INLINE_BIG Tensor< dim > clamp_metric (Tensor< dim > const m, Real const h_min, Real const h_max)
 
template<Int dim, Int n>
OMEGA_H_INLINE_BIG Tensor< dim > maxdet_metric (Few< Tensor< dim >, n > const ms)
 
Reals get_derivative_metrics (Mesh *mesh, std::string const &name, Real knob)
 
Reals get_variation_metrics (Mesh *mesh, std::string const &name, Real knob)
 
template<Int dim>
OMEGA_H_INLINE_BIG Tensor< dim > intersect_metrics (Tensor< dim > const m1, Tensor< dim > const m2)
 
OMEGA_H_INLINE Tensor< 1 > intersect_degenerate_metrics (Tensor< 1 > const m1, DiagDecomp< 1 > const, Few< Int, 1 > const, Int const, Tensor< 1 > const, DiagDecomp< 1 > const, Few< Int, 1 > const, Int const)
 
OMEGA_H_INLINE_BIG Tensor< 2 > intersect_degenerate_metrics (Tensor< 2 > const m1, DiagDecomp< 2 > const m1_dc, Few< Int, 2 > const m1_ew_is_degen, Int const, Tensor< 2 > const m2, DiagDecomp< 2 > const m2_dc, Few< Int, 2 > const m2_ew_is_degen, Int const)
 
OMEGA_H_INLINE_BIG Tensor< 3 > intersect_degenerate_metrics (Tensor< 3 > const m1, DiagDecomp< 3 > const m1_dc, Few< Int, 3 > const m1_ew_is_degen, Int const nm1_degen_ews, Tensor< 3 > const m2, DiagDecomp< 3 > const m2_dc, Few< Int, 3 > const m2_ew_is_degen, Int const nm2_degen_ews)
 
Remotes form_down_use_owners (Mesh *mesh, Int high_dim, Int low_dim)
 
Dist get_old_owners2uniq_uses (Dist uses2old_owners)
 
Dist get_new_copies2old_owners (Dist uses2old_owners, GOs old_owner_globals)
 
LOs form_new_conn (Dist new_ents2old_owners, Dist old_owners2new_uses)
 
void push_down (Mesh *old_mesh, Int ent_dim, Int low_dim, Dist old_owners2new_ents, Adj &new_ents2new_lows, Dist &old_low_owners2new_lows)
 
void push_tags (Mesh *old_mesh, Mesh *new_mesh, Int ent_dim, Dist old_owners2new_ents)
 
void push_ents (Mesh *old_mesh, Mesh *new_mesh, Int ent_dim, Dist new_ents2old_owners, Dist old_owners2new_ents, Omega_h_Parting mode)
 
void migrate_matches (Mesh *mesh, Mesh *new_mesh, Int const d, Dist const *old_owners2new_ents)
 
void migrate_mesh (Mesh *mesh, Dist new_elems2old_owners, Omega_h_Parting mode, bool verbose)
 
Remotes form_down_use_owners_matched (Mesh *mesh, Int high_dim, Int low_dim)
 
void get_all_type_tags (MixedMesh *mesh, Int dim, Topo_type ent_type, TagSet *tags)
 
LOs get_mods2reps (Mesh *mesh, Int ent_dim, Int mod_dim, LOs mods2mds)
 
LOs get_rep_counts (Mesh *mesh, Int ent_dim, Few< LOs, 4 > mods2mds, Few< LOs, 4 > mods2reps, Few< LOs, 4 > mods2nprods, LOs same_ents2ents, bool count_non_owned)
 
LOs get_rep2md_order_adapt (Mesh *mesh, Int key_dim, Int rep_dim, Bytes kds_are_keys)
 
Few< LOs, 4 > get_rep2md_order (Mesh *mesh, Int rep_dim, Few< LOs, 4 > mods2mds, Few< LOs, 4 > mods2nprods, Few< bool, 4 > mods_have_prods)
 
template<typename T >
void assign_new_numbering (Read< T > old_ents2new_numbers, LOs same_ents2old_ents, Few< LOs, 4 > mods2mds, Few< LOs, 4 > mods2reps, Few< LOs, 4 > mods2prods, Few< LOs, 4 > rep2md_order, Read< T > *p_same_ents2new_numbers, Read< T > *p_prods2new_numbers, bool keep_mods)
 
void modify_ents_adapt (Mesh *old_mesh, Mesh *new_mesh, Int ent_dim, Int key_dim, LOs keys2kds, LOs keys2prods, LOs prod_verts2verts, LOs old_lows2new_lows, LOs *p_prods2new_ents, LOs *p_same_ents2old_ents, LOs *p_same_ents2new_ents, LOs *p_old_ents2new_ents)
 
void modify_ents (Mesh *old_mesh, Mesh *new_mesh, Int ent_dim, Few< LOs, 4 > mods2mds, Few< Bytes, 4 > mds_are_mods, Few< LOs, 4 > mods2prods, LOs prod_verts2verts, LOs old_lows2new_lows, bool keep_mods, bool mods_can_be_shared, LOs *p_prods2new_ents, LOs *p_same_ents2old_ents, LOs *p_same_ents2new_ents, LOs *p_old_ents2new_ents)
 
void set_owners_by_indset (Mesh *mesh, Int key_dim, LOs keys2kds, Graph kds2elems)
 
template<Int nmax>
OMEGA_H_INLINE Vector< 3 > get_most_normal_normal (Few< Vector< 3 >, nmax > N, Int n, Real inside_tol=OMEGA_H_EPSILON)
 
template<Int nmax>
OMEGA_H_INLINE Vector< 2 > get_most_normal_normal (Few< Vector< 2 >, nmax > N, Int)
 
Remotes update_ownership (Dist copies2old_owners, Read< I32 > own_ranks)
 
Remotes owners_from_globals (CommPtr comm, Read< GO > globals, Read< I32 > own_ranks)
 
template<typename T >
Read< T > reduce_data_to_owners (Read< T > copy_data, Dist copies2owners, Int ncomps)
 
GOs globals_from_owners (Mesh *mesh, Int ent_dim)
 
int get_nstates (Parser const &p)
 
int add_state (Parser &p)
 
void add_terminal_action (Parser &p, int state, int terminal, Action action)
 
void add_nonterminal_action (Parser &p, int state, int nonterminal, int next_state)
 
Action const & get_action (Parser const &p, int state, int terminal)
 
int execute_action (Parser const &p, std::vector< int > &stack, Action const &action)
 
GrammarPtr const & get_grammar (Parser const &p)
 
ParserGraph make_graph_with_nnodes (int nnodes)
 
int get_nnodes (ParserGraph const &g)
 
void add_edge (ParserGraph &g, int i, int j)
 
NodeEdges const & get_edges (ParserGraph const &g, int i)
 
NodeEdges & get_edges (ParserGraph &g, int i)
 
ParserGraph make_transpose (ParserGraph const &g)
 
int at (ParserGraph const &g, int i, int j)
 
std::ostream & operator<< (std::ostream &os, ParserGraph const &g)
 
void * allocate (Pool &pool, std::size_t size)
 
void deallocate (Pool &pool, void *data, std::size_t size)
 
template<class T >
std::ostream & operator<< (std::ostream &stream, HostRead< T > hr)
 
template<class T >
std::ostream & operator<< (std::ostream &stream, Read< T > r)
 
template<class T >
std::ostream & operator<< (std::ostream &stream, Write< T > r)
 
template<class T , Int n>
std::ostream & operator<< (std::ostream &stream, Few< T, n > f)
 
void begin_code (char const *name, char const *file=0)
 
double get_runtime ()
 
void end_code ()
 
template<Int max_m, Int max_n>
OMEGA_H_INLINE Vector< max_m > householder_vector (Int m, Matrix< max_m, max_n > a, Int k)
 
template<Int max_m, Int max_n>
OMEGA_H_INLINE void reflect_columns (Int m, Int n, Matrix< max_m, max_n > &a, Vector< max_m > v_k, Int k)
 
template<Int max_m, Int max_n>
OMEGA_H_INLINE QRFactorization< max_m, max_n > factorize_qr_householder (Int m, Int n, Matrix< max_m, max_n > a)
 
template<Int max_m, Int max_n>
OMEGA_H_INLINE Vector< max_n > implicit_q_trans_b (Int m, Int n, Few< Vector< max_m >, max_n > v, Vector< max_m > b)
 
template<Int max_m, Int max_n>
OMEGA_H_INLINE void implicit_q_x (Int m, Int n, Vector< max_m > &x, Few< Vector< max_m >, max_n > v)
 
template<Int max_m, Int max_n>
OMEGA_H_INLINE Tensor< max_n > reduced_r_from_full (Int n, Matrix< max_m, max_n > fr)
 
template<Int max_m>
OMEGA_H_INLINE Vector< max_m > solve_upper_triangular (Int m, Tensor< max_m > a, Vector< max_m > b)
 
template<Int max_m, Int max_n>
OMEGA_H_INLINE Vector< max_n > solve_using_qr (Int m, Int n, Matrix< max_m, max_n > a, Vector< max_m > b)
 
template<Int max_m, Int max_n>
OMEGA_H_INLINE Vector< max_n > solve_using_qr (Matrix< max_m, max_n > a, Vector< max_m > b)
 
template<Int mesh_dim, Int metric_dim>
Reals measure_qualities_tmpl (Mesh *mesh, LOs a2e, Reals metrics)
 
Reals measure_qualities (Mesh *mesh, LOs a2e, Reals metrics)
 
Reals measure_qualities (Mesh *mesh, LOs a2e)
 
Reals measure_qualities (Mesh *mesh)
 
Reals measure_qualities (Mesh *mesh, Reals metrics)
 
Reals get_1d_cavity_qualities (Mesh *mesh, Int key_dim, LOs keys2kds)
 
template<Int dim>
OMEGA_H_INLINE Real mean_ratio (Real size, Real mean_squared_length)
 
template<Int dim, typename Metric >
OMEGA_H_INLINE Real metric_element_quality (Few< Vector< dim >, dim+1 > p, Metric metric)
 
template<Int n>
OMEGA_H_INLINE Vector< n > from_r3d (r3d::Vector< n > a)
 
template<Int n, Int dim>
OMEGA_H_INLINE Few< Vector< dim >, n > from_r3d (r3d::Few< r3d::Vector< dim >, n > a)
 
template<Int n>
OMEGA_H_INLINE r3d::Vector< n > to_r3d (Vector< n > a)
 
template<Int n, Int dim>
OMEGA_H_INLINE r3d::Few< r3d::Vector< dim >, n > to_r3d (Few< Vector< dim >, n > a)
 
Reals unit_uniform_random_reals_from_globals (GOs const globals, I64 const seed, I64 const counter)
 
OMEGA_H_INLINE Few< std::uint64_t, 2 > run_philox_cbrng (Few< std::uint64_t, 2 > ctr, std::uint64_t key)
 
OMEGA_H_INLINE Real unit_uniform_deviate_from_uint64 (std::uint64_t x)
 
OMEGA_H_INLINE Real weibull_quantile (Real shape, Real scale, Real p)
 
OMEGA_H_INLINE Real standard_normal_density (Real value)
 
OMEGA_H_INLINE Real general_normal_density (Real mean, Real standard_deviation, Real value)
 
OMEGA_H_INLINE Real weibull_density (Real shape, Real scale, Real value)
 
OMEGA_H_INLINE Real regularized_lower_incomplete_gamma (Real s, Real z)
 
OMEGA_H_INLINE Real cumulative_chi_squared_density (Real ndofs, Real chi_squared)
 
OMEGA_H_INLINE Real cumulative_standard_normal_density (Real x)
 
OMEGA_H_INLINE Real cumulative_general_normal_density (Real mean, Real standard_deviation, Real x)
 
OMEGA_H_INLINE Real cumulative_weibull_density (Real shape, Real scale, Real x)
 
bool operator== (const Rb_tree_base_iterator &x, const Rb_tree_base_iterator &y)
 
bool operator!= (const Rb_tree_base_iterator &x, const Rb_tree_base_iterator &y)
 
void Rb_tree_rotate_left (Rb_tree_node_base *x, Rb_tree_node_base *&root)
 
void Rb_tree_rotate_right (Rb_tree_node_base *x, Rb_tree_node_base *&root)
 
void Rb_tree_rebalance (Rb_tree_node_base *x, Rb_tree_node_base *&root)
 
Rb_tree_node_base * Rb_tree_rebalance_for_erase (Rb_tree_node_base *z, Rb_tree_node_base *&root, Rb_tree_node_base *&leftmost, Rb_tree_node_base *&rightmost)
 
template<class Key , class Value , class KeyOfValue , class Compare >
bool operator== (const Rb_tree< Key, Value, KeyOfValue, Compare > &x, const Rb_tree< Key, Value, KeyOfValue, Compare > &y)
 
template<class Key , class Value , class KeyOfValue , class Compare >
bool operator< (const Rb_tree< Key, Value, KeyOfValue, Compare > &x, const Rb_tree< Key, Value, KeyOfValue, Compare > &y)
 
void sort_by_high_index (LOs const l2lh, Write< LO > const lh2h)
 
template<Int dim>
Reals get_interior_coeffs_dim (Mesh *mesh, Reals e_data, Int ncomps)
 
void diffuse_to_exterior (Mesh *mesh, Reals *p_v_data, Int ncomps, Read< I8 > *p_visited)
 
template<Int dim>
Reals evaluate_coeffs_dim (Mesh *mesh, Reals v_coeffs, Int ncomps)
 
bool has_interior_verts (Mesh *mesh)
 
Reals project_by_fit (Mesh *mesh, Reals e_data)
 
Reals project_by_average (Mesh *mesh, Reals e_data)
 
template<Int dim>
OMEGA_H_INLINE Matrix< dim, dim > get_simplex_jacobian (Few< Vector< dim >, dim+1 > evv2x)
 
template<Int dim>
Reals derive_element_gradients_dim (Mesh *mesh, Reals vert_values)
 
template<Int dim>
Reals derive_element_hessians_dim (Mesh *mesh, Reals vert_gradients)
 
Reals derive_element_gradients (Mesh *mesh, Reals vert_values)
 
Reals derive_element_hessians (Mesh *mesh, Reals vert_gradients)
 
Reals recover_gradients (Mesh *mesh, Reals vert_values)
 
Reals recover_hessians_from_gradients (Mesh *mesh, Reals vert_gradients)
 
Reals recover_hessians (Mesh *mesh, Reals vert_values)
 
template<typename T >
T::value_type parallel_reduce (LO n, T f, char const *name="")
 
template<class Iterator , class Tranform , class Result , class Op >
Result transform_reduce (Iterator first, Iterator last, Result init, Op op, Tranform &&transform)
 
bool refine_by_size (Mesh *mesh, AdaptOpts const &opts)
 
template<Int mesh_dim, Int metric_dim>
Reals refine_qualities_tmpl (Mesh *mesh, LOs candidates)
 
Reals refine_qualities (Mesh *mesh, LOs candidates)
 
void refine_edges_to_pairs (Mesh *mesh, LOs keys2edges, LOs keys2midverts, LOs old_verts2new_verts, LOs &keys2pairs, LOs &pair_verts2verts)
 
void refine_domains_to_pairs (Mesh *mesh, Int dim, LOs keys2edges, LOs keys2midverts, LOs old_verts2new_verts, LOs &keys2pairs, LOs &pair_verts2verts)
 
void refine_domains_to_cuts (Mesh *mesh, Int dim, LOs keys2edges, LOs keys2midverts, LOs old_verts2new_verts, LOs &keys2cuts, LOs &cut_verts2verts)
 
void combine_pairs_and_cuts (Int ent_dim, LOs keys2cuts, LOs keys2pairs, LOs cut_verts2verts, LOs pair_verts2verts, LOs &keys2prods, LOs &prod_verts2verts)
 
void refine_products (Mesh *mesh, Int ent_dim, LOs keys2edges, LOs keys2midverts, LOs old_verts2new_verts, LOs &keys2prods, LOs &prod_verts2verts)
 
template<Int dim, typename T >
OMEGA_H_INLINE void flip_new_elem (T ev[])
 
template<typename T >
OMEGA_H_INLINE void flip_new_elem (Int dim, T ev[])
 
Remotes expand (Remotes a2c, LOs a2b)
 
Remotes unmap (LOs a2b, Remotes b2c)
 
Remotes identity_remotes (CommPtr comm, LO n)
 
template<typename T >
constexpr OMEGA_H_INLINE T max2 (T a, T b) noexcept
 
template<typename T >
constexpr OMEGA_H_INLINE T min2 (T a, T b) noexcept
 
template<typename T >
OMEGA_H_INLINE void swap2 (T &a, T &b) noexcept
 
template<typename T >
constexpr OMEGA_H_INLINE_BIG T factorial (T x) noexcept
 
template<typename T >
constexpr OMEGA_H_INLINE T average (T a, T b) noexcept
 
template<Int p, typename T >
constexpr OMEGA_H_INLINE T raise (T x) noexcept
 
template<typename T >
constexpr OMEGA_H_INLINE T square (T x) noexcept
 
template<typename T >
OMEGA_H_INLINE T cube (T x) noexcept
 
OMEGA_H_INLINE Real sign (Real x) noexcept
 
OMEGA_H_INLINE Real clamp (Real x, Real low, Real high) noexcept
 
template<Int p>
OMEGA_H_INLINE Real root (Real x) noexcept
 
constexpr OMEGA_H_INLINE Int gcd (Int a, Int b) noexcept
 
template<Int np, Int dp>
OMEGA_H_INLINE Real power (Real x) noexcept
 
OMEGA_H_INLINE Real power (Real x, Int np, Int dp) noexcept
 
OMEGA_H_INLINE Real rel_diff_with_floor (Real a, Real b, Real floor=EPSILON) noexcept
 
OMEGA_H_INLINE bool are_close (Real a, Real b, Real tol=EPSILON, Real floor=EPSILON) noexcept
 
template<typename T >
T divide_no_remainder (T a, T b)
 
OMEGA_H_INLINE Real sin_x_over_x (Real x)
 
template<typename T >
void parallel_scan (LO n, T f, char const *name="")
 
template<typename InputIterator , typename OutputIterator >
OutputIterator inclusive_scan (InputIterator first, InputIterator last, OutputIterator result)
 
template<typename InputIterator , typename OutputIterator , typename BinaryOp , typename UnaryOp >
OutputIterator transform_inclusive_scan (InputIterator first, InputIterator last, OutputIterator result, BinaryOp op, UnaryOp &&transform)
 
template<Int dim>
Reals get_linear_scatter_coords (Reals coords, Vector< dim > direction, Vector< dim > origin)
 
template<Int dim>
Reals get_radial_scatter_coords (Reals coords, Vector< dim > center)
 
void write_scatterplot (std::string const &path, CommPtr comm, Reals coords_1d, Reals data, std::string const &separator)
 
void write_scatterplot (std::string const &path, Mesh *mesh, Int ent_dim, Reals coords_1d, Reals data, std::string const &separator)
 
template<Int dim>
void write_linear_scatterplot (std::string const &path, Mesh *mesh, Int ent_dim, Reals data, Vector< dim > direction, Vector< dim > origin, std::string const &separator)
 
template<Int dim>
void write_radial_scatterplot (std::string const &path, Mesh *mesh, Int ent_dim, Reals data, Vector< dim > center, std::string const &separator)
 
template<typename T >
void unite_with (std::set< T > &a, std::set< T > const &b)
 
template<typename T >
std::set< T > unite (std::set< T > const &a, std::set< T > const &b)
 
template<typename T >
void subtract_from (std::set< T > &a, std::set< T > const &b)
 
template<typename T >
bool intersects (std::set< T > &a, std::set< T > const &b)
 
template<Int mesh_dim, Int metric_dim>
Reals measure_edges_metric_tmpl (Mesh *mesh, LOs a2e, Reals metrics)
 
Reals measure_edges_metric (Mesh *mesh, LOs a2e, Reals metrics)
 
Reals measure_edges_metric (Mesh *mesh, LOs a2e)
 
Reals measure_edges_metric (Mesh *mesh, Reals metrics)
 
Reals measure_edges_metric (Mesh *mesh)
 
template<Int sdim, Int edim>
Reals measure_ents_real_tmpl (Mesh *mesh, LOs a2e, Reals coords)
 
Reals measure_ents_real (Mesh *mesh, Int ent_dim, LOs a2e, Reals coords)
 
Reals measure_elements_real (Mesh *mesh, LOs a2e)
 
Reals measure_elements_real (Mesh *mesh)
 
Reals measure_edges_real (Mesh *mesh, LOs a2e)
 
Reals measure_edges_real (Mesh *mesh)
 
template<Int sdim, Int edim>
OMEGA_H_INLINE Matrix< sdim, edim > simplex_basis (Few< Vector< sdim >, edim+1 > const &p)
 
template<Int dim>
OMEGA_H_INLINE Real distance (Plane< dim > plane, Vector< dim > point)
 
template<Int dim>
OMEGA_H_INLINE Plane< dim > normalize (Plane< dim > p)
 
template<Int dim>
OMEGA_H_INLINE Vector< dim+1 > form_barycentric (Vector< dim > const &c)
 Constructs full barycentric representation (xi_0,xi_1,...) from xi_1, xi_2, ...
 
template<Int sdim, Int edim>
OMEGA_H_INLINE Vector< edim+1 > barycentric_from_global (Vector< sdim > const &global_coordinate, Few< Vector< sdim >, edim+1 > const &node_coordinates)
 Compute the barycentric coordinates from a position in global coordinates and the element nodal coordinates.
 
template<Int n>
OMEGA_H_INLINE bool is_barycentric_inside (Vector< n > xi, Real fuzz=0)
 
template<Int sdim>
OMEGA_H_INLINE Real edge_length_from_basis (Few< Vector< sdim >, 1 > b)
 
template<Int sdim>
OMEGA_H_INLINE Real simplex_size_from_basis (Few< Vector< sdim >, 1 > b)
 
OMEGA_H_INLINE Real triangle_area_from_basis (Few< Vector< 2 >, 2 > b)
 
OMEGA_H_INLINE Real triangle_area_from_basis (Few< Vector< 3 >, 2 > b)
 
template<Int sdim>
OMEGA_H_INLINE Real simplex_size_from_basis (Few< Vector< sdim >, 2 > b)
 
OMEGA_H_INLINE Real tet_volume_from_basis (Few< Vector< 3 >, 3 > b)
 
OMEGA_H_INLINE Real simplex_size_from_basis (Few< Vector< 3 >, 3 > b)
 
OMEGA_H_INLINE Real anisotropic_edge_length (Real l_a, Real l_b)
 
template<Int space_dim, Int metric_dim>
OMEGA_H_INLINE Real metric_edge_length (Few< Vector< space_dim >, 2 > p, Few< Matrix< metric_dim, metric_dim >, 2 > ms)
 
template<Int space_dim, Int metric_dim>
OMEGA_H_DEVICE Real metric_edge_length (Few< LO, 2 > v, Reals coords, Reals metrics)
 
template<Int sdim, Int edim>
OMEGA_H_INLINE Real real_simplex_size (Few< Vector< sdim >, edim+1 > p)
 
OMEGA_H_INLINE Few< Vector< 1 >, 1 > element_edge_vectors (Few< Vector< 1 >, 2 >, Few< Vector< 1 >, 1 > b)
 
OMEGA_H_INLINE Few< Vector< 2 >, 3 > element_edge_vectors (Few< Vector< 2 >, 3 > p, Few< Vector< 2 >, 2 > b)
 
OMEGA_H_INLINE Few< Vector< 3 >, 6 > element_edge_vectors (Few< Vector< 3 >, 4 > p, Few< Vector< 3 >, 3 > b)
 
template<Int space_dim, Int metric_dim>
OMEGA_H_INLINE Real squared_metric_length (Vector< space_dim > v, Matrix< metric_dim, metric_dim > m)
 
template<typename EdgeVectors , typename Metric >
OMEGA_H_INLINE Real mean_squared_metric_length (EdgeVectors edge_vectors, Metric metric)
 
template<typename EdgeVectors >
OMEGA_H_INLINE Real mean_squared_real_length (EdgeVectors edge_vectors)
 
OMEGA_H_INLINE Matrix< 1, 1 > element_implied_metric (Few< Vector< 1 >, 2 > p)
 
OMEGA_H_INLINE Matrix< 2, 2 > element_implied_metric (Few< Vector< 2 >, 3 > p)
 
OMEGA_H_INLINE Matrix< 3, 3 > element_implied_metric (Few< Vector< 3 >, 4 > p)
 
template<Int dim>
OMEGA_H_INLINE Vector< dim > get_triangle_normal (Vector< dim > a, Vector< dim > b, Vector< dim > c)
 
OMEGA_H_INLINE Vector< 1 > get_side_vector (Few< Vector< 1 >, 2 >, Int ivert)
 
OMEGA_H_INLINE Vector< 2 > get_side_vector (Few< Vector< 2 >, 2 > p)
 
OMEGA_H_INLINE Vector< 2 > get_side_vector (Few< Vector< 2 >, 3 > p, Int iedge)
 
OMEGA_H_INLINE Vector< 3 > get_side_vector (Few< Vector< 3 >, 3 > p)
 
OMEGA_H_INLINE Vector< 3 > get_side_vector (Few< Vector< 3 >, 4 > p, Int iface)
 
template<Int dim>
OMEGA_H_INLINE Plane< dim > get_side_plane (Few< Vector< dim >, dim+1 > p, Int iside)
 
template<Int dim>
OMEGA_H_INLINE Sphere< dim > get_inball (Few< Vector< dim >, dim+1 > p)
 
template<Int dim>
OMEGA_H_INLINE Vector< dim > get_size_gradient (Few< Vector< dim >, dim+1 > p, Int ivert)
 
template<Int dim>
OMEGA_H_INLINE Matrix< dim, dim+1 > get_size_gradients (Few< Vector< dim >, dim+1 > p)
 
OMEGA_H_INLINE Vector< 3 > get_circumcenter_vector (Few< Vector< 3 >, 2 > basis)
 
template<Int space_dim, Int metric_dim>
OMEGA_H_INLINE Real metric_size (Real real_size, Matrix< metric_dim, metric_dim > metric)
 
constexpr OMEGA_H_INLINE Real equilateral_simplex_size (Int dim)
 
template<Int dim>
OMEGA_H_INLINE Affine< dim > simplex_affine (Few< Vector< dim >, dim+1 > p)
 
template<Int dim>
Real max_simplex_edge_length (Few< Vector< dim >, dim+1 > p)
 
void start_tracking_allocations ()
 
void stop_tracking_allocations (Library *lib)
 
constexpr OMEGA_H_INLINE Int simplex_down_template (Int elem_dim, Int bdry_dim, Int which_bdry, Int which_vert)
 Relates bounding simplex vertices to the parent simplex's vertices. More...
 
OMEGA_H_INLINE TemplateUp simplex_up_template (Int elem_dim, Int bdry_dim, Int which_bdry, Int which_up)
 
OMEGA_H_INLINE Int simplex_opposite_template (Int elem_dim, Int bdry_dim, Int which_bdry)
 
constexpr OMEGA_H_INLINE Int simplex_degree (Int from_dim, Int to_dim)
 
constexpr char const * simplex_singular_name (Int dim)
 
constexpr char const * simplex_plural_name (Int dim)
 
LOs tris_from_quads (LOs qv2v)
 
LOs tets_from_hexes (LOs hv2v)
 
void tris_from_quads_symmetric (Mesh *mesh)
 
void tets_from_hexes_symmetric (Mesh *mesh)
 
template<typename T >
LOs sort_by_keys (Read< T > keys, Int width)
 
template<typename T >
T next_smallest_value (Read< T > const a, T const value)
 
template<typename T >
LO number_same_values (Read< T > const a, T const value, Write< LO > const tmp_perm)
 
template<typename T >
void combine_perms (Read< T > const a, T const value, Write< LO > const tmp_perm, Write< LO > const perm, LO ndone)
 
template<typename T >
void sort_small_range (Read< T > a, LOs *p_perm, LOs *p_fan, Read< T > *p_uniq)
 
template void sort_small_range (Read< I32 > items2values, LOs *p_perm, LOs *p_fan, Read< I32 > *p_uniq)
 
template<typename T >
int size (std::stack< T > const &s)
 
template<typename T >
int size (std::vector< T > const &v)
 
template<typename T >
std::vector< T >::reference at (std::vector< T > &v, int i)
 
template<typename T >
std::vector< T >::const_reference at (std::vector< T > const &v, int i)
 
template<typename T >
void resize (std::vector< T > &v, int n)
 
template<typename T >
void reserve (std::vector< T > &v, int n)
 
template<typename T >
std::vector< T > make_vector (int n, T const &init_val=T())
 
int size (std::string const &s)
 
std::string::reference at (std::string &s, int i)
 
std::string::const_reference at (std::string const &s, int i)
 
Reals get_side_vectors (Mesh *mesh, LOs surf_side2side)
 
template<Int dim>
Reals get_curv_edge_tangents_dim (Mesh *mesh, LOs curv_edge2edge)
 
Reals get_curv_edge_tangents (Mesh *mesh, LOs curv_edge2edge)
 
Reals get_hinge_angles (Mesh *mesh, Reals surf_side_normals, LOs surf_hinge2hinge, LOs side2surf_side)
 
Reals tri_vert_normal_weights (Mesh *mesh, Adj surf_verts2tris, LOs tri2surf_tri)
 
Reals get_recip_length_weights (Mesh *mesh, Adj surf_verts2edges, LOs edge2surf_edge)
 
Reals get_side_vert_normals (Mesh *mesh, LOs surf_side2side, Reals surf_side_normals, LOs surf_vert2vert)
 
Read< I8 > get_curv_vert_edge_flips (Adj curv_verts2edges, LOs edge2curv_edge)
 
Read< I8 > get_curv_edge_vert_flips (Mesh *mesh, Adj curv_verts2edges, LOs edge2curv_edge)
 
template<Int dim>
Reals get_curv_vert_tangents_dim (Mesh *mesh, LOs curv_edge2edge, Reals curv_edge_tangents, LOs curv_vert2vert)
 
Reals get_curv_vert_tangents (Mesh *mesh, LOs curv_edge2edge, Reals curv_edge_tangents, LOs curv_vert2vert)
 
Reals get_surf_tri_IIs (Mesh *mesh, LOs surf_tri2tri, Reals surf_tri_normals, LOs surf_vert2vert, Reals surf_vert_normals)
 
OMEGA_H_INLINE Real get_mixed_area (Few< Vector< 3 >, 3 > p, Int ttv)
 
OMEGA_H_INLINE Matrix< 3, 3 > rotate_to_plane (Vector< 3 > n, Matrix< 3, 3 > tnuv)
 
Reals get_surf_vert_IIs (Mesh *mesh, LOs surf_tri2tri, Reals surf_tri_normals, Reals surf_tri_IIs, LOs surf_vert2vert, Reals surf_vert_normals)
 
template<Int dim>
Reals get_curv_edge_curvatures_dim (Mesh *mesh, LOs curv_edge2edge, Reals curv_edge_tangents, LOs curv_vert2vert, Reals curv_vert_tangents)
 
Reals get_curv_edge_curvatures (Mesh *mesh, LOs curv_edge2edge, Reals curv_edge_tangents, LOs curv_vert2vert, Reals curv_vert_tangents)
 
template<Int dim>
Reals get_curv_vert_curvatures_dim (Mesh *mesh, LOs curv_edge2edge, Reals curv_edge_curvatures, LOs curv_vert2vert)
 
Reals get_curv_vert_curvatures (Mesh *mesh, LOs curv_edge2edge, Reals curv_edge_curvatures, LOs curv_vert2vert)
 
SurfaceInfo get_surface_info (Mesh *mesh)
 
Reals get_vert_curvatures (Mesh *mesh, SurfaceInfo surface_info)
 
OMEGA_H_INLINE Givens givens (Real const a, Real const b) noexcept
 
OMEGA_H_INLINE SVD< 2 > svd_bidiagonal (Real f, Real const g, Real h) noexcept
 
OMEGA_H_INLINE SVD< 2 > svd_2x2 (Matrix< 2, 2 > const A) OMEGA_H_NOEXCEPT
 
template<Int dim>
OMEGA_H_INLINE SVD< dim > decompose_svd (Matrix< dim, dim > const A) OMEGA_H_NOEXCEPT
 
bool swap_part1 (Mesh *mesh, AdaptOpts const &opts)
 
void filter_swap (Read< I8 > keep_cands, LOs *cands2edges, Reals *cand_quals)
 
Read< I8 > filter_swap_improve (Mesh *mesh, LOs cands2edges, Reals cand_quals)
 
bool swap_edges (Mesh *mesh, AdaptOpts const &opts)
 
bool swap_edges_2d (Mesh *mesh, AdaptOpts const &opts)
 
Reals swap2d_qualities (Mesh *mesh, AdaptOpts const &opts, LOs cands2edges)
 
void swap2d_topology (Mesh *mesh, LOs keys2edges, HostFew< LOs, 3 > *keys2prods_out, HostFew< LOs, 3 > *prod_verts2verts_out)
 
template<Int metric_dim>
Reals swap2d_qualities_tmpl (Mesh *mesh, AdaptOpts const &opts, LOs cands2edges)
 
bool swap_edges_3d (Mesh *mesh, AdaptOpts const &opts)
 
void swap3d_qualities (Mesh *mesh, AdaptOpts const &opts, LOs cands2edges, Reals *cand_quals, Read< I8 > *cand_configs)
 
HostFew< LOs, 4 > swap3d_keys_to_prods (Mesh *mesh, LOs keys2edges)
 
HostFew< LOs, 4 > swap3d_topology (Mesh *mesh, LOs keys2edges, Read< I8 > edge_configs, HostFew< LOs, 4 > keys2prods)
 
template<Int metric_dim>
void swap3d_qualities_tmpl (Mesh *mesh, AdaptOpts const &opts, LOs cands2edges, Reals *cand_quals, Read< I8 > *cand_configs)
 
template<typename T >
int get_nrows (Table< T > const &t)
 
template<typename T >
int get_ncols (Table< T > const &t)
 
template<typename T >
void resize (Table< T > &t, int new_nrows, int new_ncols)
 
template<typename T >
Table< T >::Ref at (Table< T > &t, int row, int col)
 
template<typename T >
Table< T >::ConstRef at (Table< T > const &t, int row, int col)
 
template<typename T >
bool is (TagBase const *t)
 
template<typename T >
Tag< T > const * as (TagBase const *t)
 
template<typename T >
Tag< T > * as (TagBase *t)
 
void check_tag_name (std::string const &name)
 
Now now ()
 
Real operator- (Now b, Now a)
 
bool is_transfer_required (TransferOpts const &opts, std::string const &name, Omega_h_Transfer type)
 
bool should_inherit (Mesh *mesh, TransferOpts const &opts, Int, TagBase const *tag)
 
bool should_interpolate (Mesh *, TransferOpts const &opts, Int dim, TagBase const *tag)
 
bool should_fit (Mesh *mesh, TransferOpts const &opts, Int dim, TagBase const *tag)
 
bool is_density (Mesh *mesh, TransferOpts const &opts, Int dim, TagBase const *tag)
 
bool should_conserve (Mesh *mesh, TransferOpts const &opts, Int dim, TagBase const *tag)
 
bool has_densities_or_conserved (Mesh *mesh, TransferOpts const &opts)
 
bool should_conserve_any (Mesh *mesh, TransferOpts const &opts)
 
bool is_metric (Mesh *mesh, TransferOpts const &opts, Int dim, TagBase const *tag)
 
bool is_momentum_velocity (Mesh *mesh, TransferOpts const &opts, Int dim, TagBase const *tag)
 
bool has_momentum_velocity (Mesh *mesh, TransferOpts const &opts)
 
template<typename T >
void transfer_common3 (Mesh *new_mesh, Int ent_dim, TagBase const *tagbase, Write< T > new_data)
 
template<typename T >
void transfer_common2 (Mesh *old_mesh, Mesh *new_mesh, Int ent_dim, LOs same_ents2old_ents, LOs same_ents2new_ents, TagBase const *tagbase, Write< T > new_data)
 
template<typename T >
void transfer_common (Mesh *old_mesh, Mesh *new_mesh, Int ent_dim, LOs same_ents2old_ents, LOs same_ents2new_ents, LOs prods2new_ents, TagBase const *tagbase, Read< T > prod_data)
 
template<typename T >
void transfer_inherit_refine (Mesh *old_mesh, Mesh *new_mesh, LOs keys2edges, Int prod_dim, LOs keys2prods, LOs prods2new_ents, LOs same_ents2old_ents, LOs same_ents2new_ents, std::string const &name)
 
void transfer_inherit_refine (Mesh *old_mesh, Mesh *new_mesh, LOs keys2edges, Int prod_dim, LOs keys2prods, LOs prods2new_ents, LOs same_ents2old_ents, LOs same_ents2new_ents, TagBase const *tagbase)
 
void transfer_length (Mesh *old_mesh, Mesh *new_mesh, LOs same_ents2old_ents, LOs same_ents2new_ents, LOs prods2new_ents)
 
void transfer_quality (Mesh *old_mesh, Mesh *new_mesh, LOs same_ents2old_ents, LOs same_ents2new_ents, LOs prods2new_ents)
 
void transfer_size (Mesh *old_mesh, Mesh *new_mesh, LOs same_ents2old_ents, LOs same_ents2new_ents, LOs prods2new_ents)
 
void transfer_refine (Mesh *old_mesh, TransferOpts const &opts, Mesh *new_mesh, LOs keys2edges, LOs keys2midverts, Int prod_dim, LOs keys2prods, LOs prods2new_ents, LOs same_ents2old_ents, LOs same_ents2new_ents)
 
template<Int dim>
void transfer_pointwise_tmpl (Mesh *old_mesh, Mesh *new_mesh, Int key_dim, LOs keys2kds, LOs keys2prods, LOs prods2new_elems, LOs same_elems2old_elems, LOs same_elems2new_elems, TagBase const *tagbase)
 
void transfer_pointwise (Mesh *old_mesh, TransferOpts const &opts, Mesh *new_mesh, Int key_dim, LOs keys2kds, LOs keys2prods, LOs prods2new_ents, LOs same_ents2old_ents, LOs same_ents2new_ents)
 
void transfer_coarsen (Mesh *old_mesh, TransferOpts const &opts, Mesh *new_mesh, LOs keys2verts, Adj keys2doms, Int prod_dim, LOs prods2new_ents, LOs same_ents2old_ents, LOs same_ents2new_ents)
 
void transfer_copy (Mesh *old_mesh, TransferOpts const &opts, Mesh *new_mesh, Int prod_dim)
 
void transfer_swap (Mesh *old_mesh, TransferOpts const &opts, Mesh *new_mesh, Int prod_dim, LOs keys2edges, LOs keys2prods, LOs prods2new_ents, LOs same_ents2old_ents, LOs same_ents2new_ents)
 
void unmap_tags (Mesh *old_mesh, Mesh *new_mesh, Int ent_dim, LOs new_ents2old_ents)
 
void unmap_down (Mesh *old_mesh, Mesh *new_mesh, Int ent_dim, LOs new_ents2old_ents, LOs old_lows2new_lows)
 
Remotes unmap_owners (Mesh *old_mesh, Int ent_dim, LOs new_ents2old_ents, LOs old_ents2new_ents)
 
void unmap_owners (Mesh *old_mesh, Mesh *new_mesh, Int ent_dim, LOs new_ents2old_ents, LOs old_ents2new_ents)
 
void unmap_parents (Mesh *old_mesh, Mesh *new_mesh, LOs new_ents2old_ents_a[], Few< LOs, 4 > old_ents2new_ents)
 
void unmap_leaves (Mesh *new_mesh)
 
void unmap_mesh (Mesh *mesh, LOs new_ents2old_ents[])
 
template<Int dim>
Reals get_vector_norms_tmpl (Reals vs)
 
Reals get_vector_norms (Reals vs, Int dim)
 
template<Int dim>
Reals normalize_vectors_tmpl (Reals vs)
 
Reals normalize_vectors (Reals vs, Int dim)
 
template<Int dim>
Reals dot_vectors_dim (Reals a, Reals b)
 
Reals dot_vectors (Reals a, Reals b, Int dim)
 
Reals resize_vectors (Reals old_vectors, Int old_dim, Int new_dim)
 
template<Int dim>
Reals repeat_vector (LO n, Vector< dim > v)
 
template Reals repeat_vector (LO n, Vector< 1 > v)
 
template Reals repeat_vector (LO n, Vector< 2 > v)
 
template Reals repeat_vector (LO n, Vector< 3 > v)
 
template Reals repeat_vector (LO n, Vector< 4 > v)
 
template Reals repeat_vector (LO n, Vector< 6 > v)
 
template Reals repeat_vector (LO n, Vector< 9 > v)
 
template<Int n>
OMEGA_H_INLINE Real * scalar_ptr (Vector< n > &v)
 
template<Int n>
OMEGA_H_INLINE Real const * scalar_ptr (Vector< n > const &v)
 
template<Int n>
OMEGA_H_INLINE Vector< n > operator+ (Vector< n > a, Vector< n > b) OMEGA_H_NOEXCEPT
 
template<Int n>
OMEGA_H_INLINE Vector< n > & operator+= (Vector< n > &a, Vector< n > b) OMEGA_H_NOEXCEPT
 
template<Int n>
OMEGA_H_INLINE Vector< n > operator- (Vector< n > a, Vector< n > b) OMEGA_H_NOEXCEPT
 
template<Int n>
OMEGA_H_INLINE Vector< n > & operator-= (Vector< n > &a, Vector< n > b) OMEGA_H_NOEXCEPT
 
template<Int n>
OMEGA_H_INLINE Vector< n > operator- (Vector< n > a) OMEGA_H_NOEXCEPT
 
template<Int n>
OMEGA_H_INLINE Vector< n > operator* (Vector< n > a, Real b) OMEGA_H_NOEXCEPT
 
template<Int n>
OMEGA_H_INLINE Vector< n > & operator*= (Vector< n > &a, Real b) OMEGA_H_NOEXCEPT
 
template<Int n>
OMEGA_H_INLINE Vector< n > operator* (Real a, Vector< n > b) OMEGA_H_NOEXCEPT
 
template<Int n>
OMEGA_H_INLINE Vector< n > operator/ (Vector< n > a, Real b) OMEGA_H_NOEXCEPT
 
template<Int n>
OMEGA_H_INLINE Vector< n > & operator/= (Vector< n > &a, Real b) OMEGA_H_NOEXCEPT
 
template<Int n>
OMEGA_H_INLINE Real operator* (Vector< n > a, Vector< n > b) OMEGA_H_NOEXCEPT
 
template<Int n>
OMEGA_H_INLINE Real norm_squared (Vector< n > v) OMEGA_H_NOEXCEPT
 
template<Int n>
OMEGA_H_INLINE Real norm (Vector< n > v) OMEGA_H_NOEXCEPT
 
OMEGA_H_INLINE Real norm (Vector< 1 > v) OMEGA_H_NOEXCEPT
 
template<Int n>
OMEGA_H_INLINE Vector< n > normalize (Vector< n > v) OMEGA_H_NOEXCEPT
 
OMEGA_H_INLINE Vector< 1 > vector_1 (Real x) OMEGA_H_NOEXCEPT
 
OMEGA_H_INLINE Vector< 2 > vector_2 (Real x, Real y) OMEGA_H_NOEXCEPT
 
OMEGA_H_INLINE Vector< 3 > vector_3 (Real x, Real y, Real z) OMEGA_H_NOEXCEPT
 
template<Int n>
OMEGA_H_INLINE bool are_close (Vector< n > a, Vector< n > b, Real tol=EPSILON, Real floor=EPSILON) OMEGA_H_NOEXCEPT
 
template<Int n>
OMEGA_H_INLINE Vector< n > fill_vector (Real value) OMEGA_H_NOEXCEPT
 
template<Int n>
OMEGA_H_INLINE Vector< n > zero_vector () OMEGA_H_NOEXCEPT
 
template<Int n>
OMEGA_H_INLINE Vector< n > pseudo_invert (Vector< n > a) OMEGA_H_NOEXCEPT
 
template<Int n>
OMEGA_H_INLINE Vector< n > positivize (Vector< n > v) OMEGA_H_NOEXCEPT
 
OMEGA_H_INLINE Real cross (Vector< 2 > a, Vector< 2 > b) OMEGA_H_NOEXCEPT
 
OMEGA_H_INLINE Vector< 3 > cross (Omega_h::Vector< 3 > a, Omega_h::Vector< 3 > b) OMEGA_H_NOEXCEPT
 
OMEGA_H_INLINE Vector< 2 > perp (Vector< 2 > v) OMEGA_H_NOEXCEPT
 
template<Int n>
OMEGA_H_INLINE Vector< n > project (Vector< n > a, Vector< n > b) OMEGA_H_NOEXCEPT
 
template<Int n>
OMEGA_H_INLINE Vector< n > reject (Vector< n > a, Vector< n > b) OMEGA_H_NOEXCEPT
 
template<Int n>
OMEGA_H_DEVICE void set_vector (Write< Real > const &a, Int i, Vector< n > v) OMEGA_H_NOEXCEPT
 
template<Int n, class Arr >
OMEGA_H_DEVICE Vector< n > get_vector (Arr const &a, Int i) OMEGA_H_NOEXCEPT
 
template<int new_dim, int old_dim>
OMEGA_H_INLINE Vector< new_dim > resize (Vector< old_dim > v) OMEGA_H_NOEXCEPT
 
void pybind11_defines (py::module &module)
 
void pybind11_array (py::module &module)
 
void pybind11_comm (py::module &module)
 
void pybind11_library (py::module &module)
 
void pybind11_mesh (py::module &module)
 
void pybind11_build (py::module &module)
 
void pybind11_adapt (py::module &module)
 
void pybind11_file (py::module &module)
 
void pybind11_class (py::module &module)
 
void pybind11_dolfin (py::module &module)
 

Variables

char const *const assoc_names [NSET_TYPES]
 
int const chartab [OMEGA_H_CHARTAB_SIZE]
 
char const inv_chartab [NCHARS]
 
constexpr std::size_t NSIGS
 
char * max_memory_stacktrace = nullptr
 
constexpr size_t DEFAULT_BYTES_PER_CHUNK = 1000
 
constexpr size_t DEFAULT_NUMBER_OF_CHUNKS = 700'000
 
constexpr size_t DEFAULT_GROWTH_CONSTANT = 2
 
OMEGA_H_DLL bool entering_parallel = false
 
Allocs * global_allocs = nullptr
 
const std::unordered_map< ArrayType, std::string > ArrayTypeNames
 
const std::unordered_map< std::string, ArrayType > NamesToArrayType
 
std::unique_ptr< Library > pybind11_global_library
 

Detailed Description

Top-level namespace

Function Documentation

◆ any_cast() [1/5]

template<typename ValueType >
ValueType Omega_h::any_cast ( any &&  operand)
inline

If ANY_IMPL_ANYCAST_MOVEABLE is not defined, does as N4562 specifies: Performs *any_cast<remove_reference_t<ValueType>>(&operand), or throws bad_any_cast on failure.

If ANY_IMPL_ANYCAST_MOVEABLE is defined, does as LWG Defect 2509 specifies: If ValueType is MoveConstructible and isn't a lvalue reference, performs std::move(*any_cast<remove_reference_t<ValueType>>(&operand)), otherwise *any_cast<remove_reference_t<ValueType>>(&operand). Throws bad_any_cast on failure.

◆ any_cast() [2/5]

template<typename ValueType >
ValueType Omega_h::any_cast ( any &  operand)
inline

Performs *any_cast<remove_reference_t<ValueType>>(&operand), or throws bad_any_cast on failure.

◆ any_cast() [3/5]

template<typename T >
T* Omega_h::any_cast ( any *  operand)
inlinenoexcept

If operand != nullptr && operand->type() == typeid(ValueType), a pointer to the object contained by operand, otherwise nullptr.

◆ any_cast() [4/5]

template<typename ValueType >
ValueType Omega_h::any_cast ( const any &  operand)
inline

Performs *any_cast<add_const_t<remove_reference_t<ValueType>>>(&operand), or throws bad_any_cast on failure.

◆ any_cast() [5/5]

template<typename T >
const T* Omega_h::any_cast ( const any *  operand)
inlinenoexcept

If operand != nullptr && operand->type() == typeid(ValueType), a pointer to the object contained by operand, otherwise nullptr.

◆ clamp_metrics()

Reals Omega_h::clamp_metrics ( LO  nmetrics,
Reals  metrics,
Real  h_min,
Real  h_max 
)

Clamps metric tensors to enforce bounds on desired edge lengths.

For each metric tensor, performs eigendecomposition and clamps the eigenvalues to ensure mesh adaptation produces edges with lengths between h_min and h_max in all directions. This prevents the mesh from becoming too fine or too coarse.

Parameters
nmetrics(In) The number of metric tensors to process (typically number of vertices)
metrics(In) The input array of metric tensors (stored as symmetric matrices)
h_min(In) The minimum desired edge length in physical space
h_max(In) The maximum desired edge length in physical space
Returns
Array of clamped metric tensors with eigenvalues in range [1/(h_max^2), 1/(h_min^2)]

◆ collect_marked()

LOs Omega_h::collect_marked ( Read< I8 >  marks)

collect the indices of all marked entries into a compact array

Parameters
marks(in) array of marks where marks[i] != 0 indicates entry i is marked
Returns
array of indices where marks[i] != 0, in ascending order

Converts a sparse marking array into a dense array of marked indices. The returned array has size equal to the number of marked entries (sum of marks). For example, if marks = [0, 1, 1, 0, 1], the result is [1, 2, 4]. This is commonly used after filtering operations to map from kept entities to their original indices.

◆ create_dist_for_variable_sized()

Dist Omega_h::create_dist_for_variable_sized ( Dist  copies2owners,
LOs  copies2data 
)

Creates a Dist object that can be re-used to synchronize variable-sized data per actor.

Parameters
copies2ownersDist which sends data from each actor in this MPI rank to its owner
copies2dataA "fan" which, for each actor in this MPI rank, points to the start of its variable-sized data in the array of all packed variable-sized data

This function assumes and does not verify that the amount of variable-sized data per actor is consistent between MPI ranks.

◆ fan_reduce()

template<typename T >
Read< T > Omega_h::fan_reduce ( LOs  a2b,
Read< T >  b_data,
Int  width,
Omega_h_Op  op 
)

apply reduction operation op to each sub-array of data from b_data defined by the offset array a2b

Parameters
a2b(in) map from source nodes to edges (the 'offset' array, 'a2ab') with size = na + 1
b_data(in) edge data, size = number of edges * width
width(in) number of data points per edge
op(in) the reduction operation, i.e., min, max, sum
Returns
an array with width data points per source node

◆ graph_reduce()

template<typename T >
Read< T > Omega_h::graph_reduce ( Graph  a2b,
Read< T >  b_data,
Int  width,
Omega_h_Op  op 
)

apply reduction operation op to the edge data associated with each source node

Parameters
a2b(in) graph from source nodes to edges
b_data(in) edge data, size = number of edges * width
width(in) number of data points per edge
op(in) the reduction operation, i.e., min, max, sum
Returns
an array with width data points per source node

◆ hypercube_down_template()

OMEGA_H_INLINE Int Omega_h::hypercube_down_template ( Int  elem_dim,
Int  bdry_dim,
Int  which_bdry,
Int  which_vert 
)

Relates bounding hypercube vertices the parent hypercube's vertices.

Parameters
elem_dimThe parent hypercube's dimension
bdry_dimThe bounding hypercube's dimension
which_bdryThe parent-local index of the bounding hypercube
which_vertThe bounding-local index of the vertex
Returns
The parent-local index of the vertex

◆ invert_fan()

LOs Omega_h::invert_fan ( LOs  a2b)

the opposite of invert_funnel

Parameters
a2b(in) map from source nodes to edges (the 'offset' array, 'a2ab') with size = na + 1
Returns
list of source node indices for edges between nodes in A and B, sorted by source node index

◆ invert_funnel()

LOs Omega_h::invert_funnel ( LOs  ab2a,
LO  na 
)

given the source node index in A for a list of edges between nodes in set A and B, sorted by their source node in A, and the number of nodes in A, construct the map from source nodes to edges (the 'offset' array, 'a2ab').

the term 'funnel' is in the context of 'incoming' edges being collected/grouped into the source nodes. This interface counts the degree/offset for the source nodes in the 'outgoing' graph. The implementation does not use atomics.

Parameters
ab2a(in) list of source node indices for edges between nodes in A and B, sorted by source node index
na(in) number of nodes in set A
Returns
map from source nodes to edges (the 'offset' array, 'a2ab') with size = na + 1

◆ invert_map_by_atomics()

Graph Omega_h::invert_map_by_atomics ( LOs const  a2b,
LO const  nb,
std::string const &  b2ba_name = "",
std::string const &  ba2a_name = "" 
)

given a bipartite graph from set A to B with nodes in A having degree 1 and nodes in B having degree > 1, and the array of indices mapping A to B (a2b), construct the graph from B to A.

see Appendix A of Dan Ibanez's 2016 Ph.D. Thesis, "CONFORMAL MESH ADAPTATION ON HETEROGENEOUS SUPERCOMPUTERS"

Parameters
a2b(in) map of indices in A to B
nb(in) size of set B
b2ba_name(in) name of offset array in returned Graph
ba2a_name(in) name of values array in returned Graph
Returns
Graph of B to A

◆ simplex_down_template()

constexpr OMEGA_H_INLINE Int Omega_h::simplex_down_template ( Int  elem_dim,
Int  bdry_dim,
Int  which_bdry,
Int  which_vert 
)
constexpr

Relates bounding simplex vertices to the parent simplex's vertices.

Parameters
elem_dimThe parent simplex's dimension
bdry_dimThe bounding simplex's dimension
which_bdryThe parent-local index of the bounding simplex
which_vertThe bounding-local index of the vertex
Returns
The parent-local index of the vertex

◆ unmap()

template<typename T >
Write< T > Omega_h::unmap ( LOs  a2b,
Read< T >  b_data,
Int  width 
)

return the array of b_data in the order specified by a2b

Remarks
a2b does not need to use all entries of b_data; it can replicate values from b_data by using an index multiple times.
Parameters
a2b(in) specifies output order of data from b_data
b_data(in) data to reorder, size = size(a2b)*width
width(in) number of entries in b_data per item
Returns
reordered array of b_data

Variable Documentation

◆ ArrayTypeNames

const std::unordered_map<ArrayType, std::string> Omega_h::ArrayTypeNames
Initial value:
= {
{ArrayType::VectorND, "VectorND"},
{ArrayType::SymmetricSquareMatrix, "SymmetricSquareMatrix"}
}

◆ chartab

int const Omega_h::chartab
Initial value:
= {-1, -1, -1, -1, -1, -1, -1, -1, -1,
0, 1, -1, -1, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, 3, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 81, 82, 83, 84, 85, 86, 87, 30, 31,
32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50,
51, 52, 53, 54, 55, 88, 89, 90, 91, 92, 93, 4, 5, 6, 7, 8, 9, 10, 11, 12,
13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 94, 95,
96, 97, -1}

◆ inv_chartab

char const Omega_h::inv_chartab
Initial value:
= {'\t', '\n', '\r', ' ', 'a', 'b', 'c', 'd',
'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's',
't', 'u', 'v', 'w', 'x', 'y', 'z', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H',
'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W',
'X', 'Y', 'Z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '!', '"',
'#', '$', '%', '&', '\'', '(', ')', '*', '+', ',', '-', '.', '/', ':', ';',
'<', '=', '>', '?', '@', '[', '\\', ']', '^', '_', '`', '{', '|', '}', '~'}

◆ NamesToArrayType

const std::unordered_map<std::string, ArrayType> Omega_h::NamesToArrayType
Initial value:
= {
{"VectorND", ArrayType::VectorND},
{"SymmetricSquareMatrix", ArrayType::SymmetricSquareMatrix}
}

◆ NSIGS

constexpr std::size_t Omega_h::NSIGS
constexpr
Initial value:
=
(sizeof(known_signals) / sizeof(known_signals[0]))
Generated by doxygen 1.9.1