dof Namespace Reference

Kynema API: kynema::dof Namespace Reference
Kynema API
A flexible multibody structural dynamics code for wind turbines
Loading...
Searching...
No Matches
kynema::dof Namespace Reference

Classes

struct  AssembleNodeFreedomMapTable_Beams
 A Kernel for applying a Beam element's freedom signature to all nodes it contains. More...
 
struct  AssembleNodeFreedomMapTable_Constraints
 A Kernel for applying a constraint's freedom signature to its base and target nodes. More...
 
struct  AssembleNodeFreedomMapTable_Masses
 A Kernel for applying a mass element's freedom signature to its node. More...
 
struct  AssembleNodeFreedomMapTable_Springs
 A Kernel for applying a spring element's freedom signature to both of its nodes. More...
 
struct  ComputeNodeFreedomMapTable
 A Scanning Kernel which to convert the number of active degrees of freedom per node to a pointer map to the start of their degrees of freedom in a serialized global vector. More...
 
struct  CreateConstraintFreedomTable
 A Kernel that creates the node freedom tables for each the target and base nodes for a given constrain. More...
 
struct  CreateElementFreedomTable_Beams
 A Kernel that creates the element freedom table which maps each degree of freedom on the beam element to its global component number. More...
 
struct  CreateElementFreedomTable_Masses
 A Kernel that creates the element freedom table which maps each degree of freedom on the mass element to its global component number. More...
 
struct  CreateElementFreedomTable_Springs
 A Kernel that creates the element freedom table which maps each degree of freedom on the spring element to its global component number. More...
 

Enumerations

enum class  FreedomSignature : std::uint8_t { AllComponents = 0b00111111 , JustPosition = 0b00111000 , JustRotation = 0b00000111 , NoComponents = 0b00000000 }
 Represents the active degrees of freedom for a node. More...
 

Functions

template<typename DeviceType >
void assemble_node_freedom_allocation_table (State< DeviceType > &state, const Elements< DeviceType > &elements, const Constraints< DeviceType > &constraints)
 Creates the node freedom allocation table in state based on the connectivities defined in the elements and constraints structures.
 
template<typename DeviceType >
void compute_node_freedom_map_table (State< DeviceType > &state)
 Compute the node freedom map table, a pointer map to the start of the degrees of freedom ofa given node in a serialized global vector.
 
template<typename DeviceType >
void create_constraint_freedom_table (Constraints< DeviceType > &constraints, const State< DeviceType > &state)
 Creates node freedom tables for each the target and base nodes in the constraints.
 
template<typename DeviceType >
void create_element_freedom_table (Elements< DeviceType > &elements, const State< DeviceType > &state)
 Creates the element freedom tables for all of the elements in the system.
 
KOKKOS_INLINE_FUNCTION FreedomSignature operator| (FreedomSignature x, FreedomSignature y)
 Combines two freedom signatures using bitwise OR.
 
KOKKOS_INLINE_FUNCTION size_t count_active_dofs (FreedomSignature x)
 Counts the number of active degrees of freedom in a signature.
 

Enumeration Type Documentation

◆ FreedomSignature

enum class kynema::dof::FreedomSignature : std::uint8_t
strong

Represents the active degrees of freedom for a node.

Each bit in the 6-bit signature represents a degree of freedom:

  • Bits 5-3: Translational DOFs (x, y, z positions)
  • Bits 2-0: Rotational DOFs (rx, ry, rz rotations)

Binary format: 0b00[Tz][Ty][Tx][Rz][Ry][Rx]

Enumerator
AllComponents 
JustPosition 
JustRotation 
NoComponents 

Function Documentation

◆ assemble_node_freedom_allocation_table()

template<typename DeviceType >
void kynema::dof::assemble_node_freedom_allocation_table ( State< DeviceType > &  state,
const Elements< DeviceType > &  elements,
const Constraints< DeviceType > &  constraints 
)
inline

Creates the node freedom allocation table in state based on the connectivities defined in the elements and constraints structures.

The node freedom allocation table defines which degrees of freedom are defined on which nodes by collecting this information from all elements and constraints which contain this node. The most common action using this information is to query how many degrees of freedom are defined, so this information is also computed.

Template Parameters
DeviceTypeThe Kokkos device defining where Kynema's structures reside
Parameters
stateA structure containing the node freedom allocation table to be filled
elementsA structure containing all of the elements and their connectivities
constraintsA structure containing all of the constraints and their connectivities

◆ compute_node_freedom_map_table()

template<typename DeviceType >
void kynema::dof::compute_node_freedom_map_table ( State< DeviceType > &  state)
inline

Compute the node freedom map table, a pointer map to the start of the degrees of freedom ofa given node in a serialized global vector.

Template Parameters
DeviceTypeThe Kokkos Device where the State object resides
Parameters
stateA state object with a completed node freedom allocation table

◆ count_active_dofs()

KOKKOS_INLINE_FUNCTION size_t kynema::dof::count_active_dofs ( FreedomSignature  x)

Counts the number of active degrees of freedom in a signature.

Parameters
xThe freedom signature to count
Returns
The number of active degrees of freedom

◆ create_constraint_freedom_table()

template<typename DeviceType >
void kynema::dof::create_constraint_freedom_table ( Constraints< DeviceType > &  constraints,
const State< DeviceType > &  state 
)
inline

Creates node freedom tables for each the target and base nodes in the constraints.

The constraint freedom table maps each degree of freedom for each node of a constraint to its global degree of freedom number

Template Parameters
DeviceTypeThe Kokkos Device where constraints and state reside
Parameters
constraintsThe Constraints object used to create state's node freedom map table
stateA State object with a completed node freedom map table

◆ create_element_freedom_table()

template<typename DeviceType >
void kynema::dof::create_element_freedom_table ( Elements< DeviceType > &  elements,
const State< DeviceType > &  state 
)
inline

Creates the element freedom tables for all of the elements in the system.

The element freedom table for each element type maps the degrees of freedom for that element to their global degree of freedom number

Template Parameters
DeviceTypeThe Kokkos Device where elements and state reside
Parameters
elementsthe Elements object used to create state's node freedom map table
stateA State object with a completed node freedom map table

◆ operator|()

KOKKOS_INLINE_FUNCTION FreedomSignature kynema::dof::operator| ( FreedomSignature  x,
FreedomSignature  y 
)

Combines two freedom signatures using bitwise OR.

Parameters
xFirst freedom signature
ySecond freedom signature
Returns
Combined freedom signature with all DOFs from both inputs enabled