rod Namespace Reference

Data Structures

struct  Rod
 
struct  Rod_blob_interface
 

Functions

void get_tri_norm (float node0[3], float node1[3], float node2[3], OUT float tri_norm[3])
 
void get_jacobian (mesh_node **tet_nodes, OUT float J[0])
 
void float_3x3_invert (float m[9], OUT float m_inv[9])
 
void float_3x3_mult_unrolled (float A[9], float B[9], OUT float result[9])
 
void transpose_3x3 (float in[9], OUT float transposed[9])
 
void get_gradient_deformation (float J_inv_0[0], mesh_node **nodes_curr, OUT float transposed_gradient_deformation_3x3[9])
 
void QR_decompose_gram_schmidt (float matrix_3x3[9], OUT float Q[9], float R[9])
 
void construct_euler_rotation_matrix (float a, float b, float g, float rotmat[9])
 
void rotate_tet (float rotmat[9], mesh_node **nodes, OUT mesh_node **rotated_nodes)
 
void get_euler_angles (float rm[9], OUT float euler_angles[3])
 
void get_rotation_matrix_from_euler (float euler_angles[3], OUT float rm[9])
 
bool array_equal (float arr1[3], float arr2[3])
 
bool array_contains (float large_arr[4][3], float small_arr[3][3])
 
void mesh_node_null_check (mesh_node *node, std::string location)
 
void rescale_attachment_node (float attachment_node[3], float end_node[3], float attachment_node_equil[3], float end_node_equil[3], OUT float scaled_attachment_node[3], float scaled_attachment_node_equil[3])
 
void matrix_invert_3x3 (float m[9], OUT float inverted_matrix[9])
 
void equil_attachment_node_from_J (float J_inv_0[9], int face_node_indices[3], bool ends_at_rod, float node_weighting[3], float tet_origin[3], float edge_vecs[3][3], float rotation[3], OUT float equil_attachment_node[3])
 
bool points_out_of_tet (float node1[3], float node2[3], float node3[3], float node4[3], float attachment_element[3], float attachment_node[3])
 
void get_attachment_node_pos (float face_node_1[3], float face_node_2[3], float face_node_3[3], float edge_vecs[3][3], float node_weighting[3], float tet_origin[3], OUT float attachment_node_pos[3])
 
void rod_abort (std::string message)
 
bool isnan (float x)
 
bool isinf (float x)
 
bool not_simulation_destroying (float x, std::string message)
 
bool not_simulation_destroying (float x[3], std::string message)
 
void print_array (std::string array_name, float array[], int length)
 
void print_array (std::string array_name, double array[], int length)
 
void normalize (float in[3], OUT float out[3])
 
void normalize_unsafe (float in[3], OUT float out[3])
 
void precise_normalize (float in[3], float out[3])
 
float absolute (float in[3])
 
void cross_product (float a[3], float b[3], float out[3])
 
void cross_product_unsafe (float a[3], float b[3], float out[3])
 
void get_rotation_matrix (float a[3], float b[3], float rotation_matrix[9])
 
void apply_rotation_matrix (float vec[3], float matrix[9], OUT float rotated_vec[3])
 
void apply_rotation_matrix_row (float vec[3], float matrix[9], OUT float rotated_vec[3])
 
void matmul_3x3_3x3 (float a[9], float b[9], OUT float out[9])
 
void get_p_i (float curr_r[3], float next_r[3], OUT float p_i[3])
 
void rodrigues_rotation (float v[3], float k[3], float theta, OUT float v_rot[3])
 
float safe_cos (float in)
 
float get_l_i (float p_i[3], float p_im1[3])
 
float get_signed_angle (float m1[3], float m2[3], float l[3])
 
void perpendicularize (float m_i[3], float p_i[3], OUT float m_i_prime[3])
 
void update_m1_matrix (float m_i[3], float p_i[3], float p_i_prime[3], float m_i_prime[3])
 
float get_stretch_energy (float k, float p_i[3], float p_i_equil[3])
 
void parallel_transport (float m[3], float m_prime[3], float p_im1[3], float p_i[3])
 
float get_twist_energy (float beta, float m_i[3], float m_im1[3], float m_i_equil[3], float m_im1_equil[3], float p_im1[3], float p_i[3], float p_im1_equil[3], float p_i_equil[3])
 
void get_kb_i (float p_im1[3], float p_i[3], OUT float kb_i[3])
 
void get_omega_j_i (float kb_i[3], float n_j[3], float m_j[3], OUT float omega_j_i[2])
 
float get_bend_energy (float omega_i_im1[2], float omega_i_im1_equil[2], float B_equil[4])
 
float get_bend_energy_from_p (float p_im1[3], float p_i[3], float p_im1_equil[3], float p_i_equil[3], float n_im1[3], float m_im1[3], float n_im1_equil[3], float m_im1_equil[3], float n_i[3], float m_i[3], float n_i_equil[3], float m_i_equil[3], float B_i_equil[4], float B_im1_equil[4])
 
float get_weights (float a[3], float b[3])
 
void get_mutual_element_inverse (float pim1[3], float pi[3], float weight, OUT float mutual_element[3])
 
void get_mutual_axes_inverse (float mim1[3], float mi[3], float weight, OUT float m_mutual[3])
 
float get_bend_energy_mutual_parallel_transport (float p_im1[3], float p_i[3], float p_im1_equil[3], float p_i_equil[3], float n_im1[3], float m_im1[3], float n_im1_equil[3], float m_im1_equil[3], float n_i[3], float m_i[3], float n_i_equil[3], float m_i_equil[3], float B_i_equil[4], float B_im1_equil[4])
 
float get_translational_friction (float viscosity, float radius, bool rotational)
 
float get_rotational_friction (float viscosity, float radius, float length, bool safe)
 
float get_force (float bend_energy, float stretch_energy, float delta_x)
 
float get_torque (float twist_energy, float delta_theta)
 
float get_delta_r (float friction, float timestep, float force, float noise, float external_force)
 
float get_noise (float timestep, float kT, float friction, float random_number)
 
void load_p (float p[4][3], float *r, int offset)
 
void load_m (float m_loaded[4][3], float *m, int offset)
 
void normalize_all (float p[4][3])
 
void absolute_all (float p[4][3], float absolutes[4])
 
void cross_all (float p[4][3], float m[4][3], OUT float n[4][3])
 
void delta_e_all (float p[4][3], float new_p[4][3], OUT float delta_p[4][3])
 
void update_m1_matrix_all (float m[4][3], float p[4][3], float p_prime[4][3], OUT float m_prime[4][3], int start_cutoff, int end_cutoff)
 
void load_B_all (float B[4][4], float *B_matrix, int offset)
 
void make_diagonal_B_matrix (float B, OUT float B_matrix[4])
 
void set_cutoff_values (int p_i_node_no, int num_nodes, OUT int *start_cutoff, int *end_cutoff)
 
float get_absolute_length_from_array (float *array, int node_no, int length)
 
void get_centroid_generic (float *r, int length, OUT float centroid[3])
 
void get_perturbation_energy (float perturbation_amount, int perturbation_dimension, float *B_matrix, float *material_params, int start_cutoff, int end_cutoff, int p_i_node_no, float *r_all, float *r_all_equil, float *m_all, float *m_all_equil, OUT float energies[3])
 
std::vector< float > stof_vec (std::vector< std::string > vec_in)
 
float random_number (float A, float B, RngStream rng[], int thread_id)
 
void get_jacobian (mesh_node **tet_nodes, OUT float J[9])
 
bool point_inside_tetrahedron (float point[3], float tet[12])
 
void get_kb_i (float p_im1[3], float p_i[3], float e_im1_equil[3], float e_i_equil[3], OUT float kb_i[3])
 
void update_m1_all (float m[4][3], float absolutes[4], float t[4][3], float delta_e[4][3], OUT float m_out[4][3])
 
void fix_m1_all (float m[4][3], float new_t[4][3])
 
void update_and_fix_m1_all (float old_e[4][3], float new_e[4][3], float m[4][3])
 
void set_cutoff_values (int e_i_node_no, int length, OUT int start_cutoff, int end_cutoff)
 
bool not_simulation_destroying (float x)
 
bool not_simulation_destroying (float x[3])
 
void get_perturbation_energy (float perturbation_amount, int perturbation_dimension, float B_equil[4], float *material_params, int start_cutoff, int end_cutoff, int p_i_node_no, float *r_all, float *r_all_equil, float *m_all, float *m_all_equil, float energies[3])
 
std::vector< float > stof_vec (std::vector< std::string > vec_in, int length)
 

Variables

bool dbg_print = false
 
static const bool debug_nan = false
 
const double boltzmann_constant = 1.3806503e-23/mesoDimensions::Energy
 
static const int x = 0
 
static const int y = 1
 
static const int z = 2
 
static const int im2 = 0
 index of i-2nd thing More...
 
static const int im1 = 1
 index of i-1st thing More...
 
static const int i = 2
 index of ith thing More...
 
static const int ip1 = 3
 index of i+1th thing More...
 
static const float rod_software_version = 0.3
 

Function Documentation

◆ absolute()

◆ absolute_all()

void rod::absolute_all ( float  p[4][3],
float  absolutes[4] 
)

This gets the absolute value of every segment in a 4-segment section of the rod.

◆ apply_rotation_matrix()

void rod::apply_rotation_matrix ( float  vec[3],
float  matrix[9],
OUT float  rotated_vec[3] 
)

◆ apply_rotation_matrix_row()

void rod::apply_rotation_matrix_row ( float  vec[3],
float  matrix[9],
OUT float  rotated_vec[3] 
)

Same as above, but modifies a row vector instead of a row vector.

◆ array_contains()

bool rod::array_contains ( float  large_arr[4][3],
float  small_arr[3][3] 
)

Utility function to check if a large [4][3] array contains (non-sequential) a smaller [3][3] array. The reason for this code is checking if face nodes are contained within the nodes for an element. ParamsL: large_arr - the positional data for the nodes of an element. small_arr - the positional data for the nodes of a face.

Referenced by rod::Rod_blob_interface::get_element_id().

◆ array_equal()

bool rod::array_equal ( float  arr1[3],
float  arr2[3] 
)

Check that all of the elements in two arrays are equal. Generally it's not good practice to do comparisons like this based on floating point numbers, but this is the only way I have to check for equality between face nodes and element nodes (and hence get the indices of the face nodes) because whoever programmed that part of the original FFEA data structure apparently didn't think that information was important.

Referenced by array_contains(), equil_attachment_node_from_J(), rod::Rod_blob_interface::get_attachment_node(), and rod::Rod_blob_interface::select_face_nodes().

◆ construct_euler_rotation_matrix()

void rod::construct_euler_rotation_matrix ( float  a,
float  b,
float  g,
float  rotmat[9] 
)

Construct an euler rotation matrix of the X1Y2Z3 type. Parameters, a, b and c, the angles of rotation. Populates the array 'rotmat'.

Referenced by ffea_test::connection_test().

◆ cross_all()

void rod::cross_all ( float  p[4][3],
float  m[4][3],
OUT float  n[4][3] 
)

This returns the value of m_2 (the cross product of e and m) for every segment in a 4-segment section of the rod.

Referenced by get_perturbation_energy().

◆ cross_product()

void rod::cross_product ( float  a[3],
float  b[3],
float  out[3] 
)

Compute the cross product of a 3x1 vector x a 3x1 vector (the result is also a 3x1 vector).

Referenced by ffea_test::arbitrary_equilibrium_bend(), get_bend_energy_mutual_parallel_transport(), get_kb_i(), rod::Rod_blob_interface::get_node_energy(), get_rotation_matrix(), and get_signed_angle().

◆ cross_product_unsafe()

void rod::cross_product_unsafe ( float  a[3],
float  b[3],
float  out[3] 
)

Referenced by cross_all(), and rodrigues_rotation().

◆ delta_e_all()

void rod::delta_e_all ( float  p[4][3],
float  new_p[4][3],
OUT float  delta_p[4][3] 
)

This computes the difference between two values of e for a given 4-segment section of the rod.

◆ equil_attachment_node_from_J()

void rod::equil_attachment_node_from_J ( float  J_inv_0[9],
int  face_node_indices[3],
bool  ends_at_rod,
float  node_weighting[3],
float  tet_origin[3],
float  edge_vecs[3][3],
float  rotation[3],
OUT float  equil_attachment_node[3] 
)

Get the equilibrium configuration of the attachment element. This uses the inverse Jacobian of the element to reconstruct the element at equilibrium. This is okay, because we don't need the absolute position of anything, only the relative positions. Params: J_inv_0, the inverse jacobian of the tetrahedron. ends_at_rod - if true, the attachment goes blob-to-rod, else it goes rod-to-blob node_weighting - the positioning of the attachment node inside the rod, given as a fraction of the tetrahedron edges tet_origin - origin of the tetrahedron (where the edge vectors originate) edge_vecs - the edge vectors themselves. Returns: equil_attachment_node - the equilibrium attachment element

Referenced by rod::Rod_blob_interface::get_attachment_node(), ffea_test::recover_normal(), and rod::Rod_blob_interface::set_initial_values().

◆ fix_m1_all()

void rod::fix_m1_all ( float  m[4][3],
float  new_t[4][3] 
)

◆ float_3x3_invert()

void rod::float_3x3_invert ( float  m[9],
OUT float  m_inv[9] 
)

Find the inverse of a 3x3 matrix (m), and populate the 1-D array m_inv. This is identical to the matrix inversion in mat_vec_fns, only it operates on 1-D arrays of floats instead of 2-D ones of scalars.

◆ float_3x3_mult_unrolled()

void rod::float_3x3_mult_unrolled ( float  A[9],
float  B[9],
OUT float  result[9] 
)

Multiply the 3x3 matrices A and B. This one is unrolled. Store the result in result. A, B and result are 1-D arrays of length 9 representing 3x3 matrices. Again, this does the same thing as the mat_vec_fn, but with 1-D arrays of floats.

Referenced by get_gradient_deformation().

◆ get_absolute_length_from_array()

float rod::get_absolute_length_from_array ( float *  array,
int  node_no,
int  length 
)

Returns the absolute length of an element, given an array of elements and the index of the element itself.

◆ get_attachment_node_pos()

void rod::get_attachment_node_pos ( float  face_node_1[3],
float  face_node_2[3],
float  face_node_3[3],
float  edge_vecs[3][3],
float  node_weighting[3],
float  tet_origin[3],
OUT float  attachment_node_pos[3] 
)

equivalent to Rod::get_attachment_node_pos. Partial refactoring. Todo: replace the get_attachment_node_pos stuff inside rod_blob_interface with calls to this.

Referenced by equil_attachment_node_from_J().

◆ get_bend_energy()

float rod::get_bend_energy ( float  omega_i_im1[2],
float  omega_i_im1_equil[2],
float  B_equil[4] 
)

\[ E_{bend} = \frac{1}{2 \widetilde{l}_i} \sum^i_{j=i-1} (\omega(i,j) - \widetilde{\omega}(i,j) )^T \widetilde{B}^i ( \omega(i,j) - \widetilde{\omega}(i,j) ) \]

Where $ \omega $ is the centreline curvature, defined above, $ B $ is the bending response matrix, and $l_i$ is $ |p_i| + |p_{i-1}| $

Referenced by get_bend_energy_from_p(), and get_bend_energy_mutual_parallel_transport().

◆ get_bend_energy_from_p()

float rod::get_bend_energy_from_p ( float  p_im1[3],
float  p_i[3],
float  p_im1_equil[3],
float  p_i_equil[3],
float  n_im1[3],
float  m_im1[3],
float  n_im1_equil[3],
float  m_im1_equil[3],
float  n_i[3],
float  m_i[3],
float  n_i_equil[3],
float  m_i_equil[3],
float  B_i_equil[4],
float  B_im1_equil[4] 
)

This function combines the curvature binormal, centerline curvature and bend energy formulae together, for a given set of segmments and material frames.

◆ get_bend_energy_mutual_parallel_transport()

float rod::get_bend_energy_mutual_parallel_transport ( float  p_im1[3],
float  p_i[3],
float  p_im1_equil[3],
float  p_i_equil[3],
float  n_im1[3],
float  m_im1[3],
float  n_im1_equil[3],
float  m_im1_equil[3],
float  n_i[3],
float  m_i[3],
float  n_i_equil[3],
float  m_i_equil[3],
float  B_i_equil[4],
float  B_im1_equil[4] 
)

◆ get_centroid_generic()

void rod::get_centroid_generic ( float *  r,
int  length,
OUT float  centroid[3] 
)

Get the centroid of a particular rod, specified by the array of node positions for that rod (and the length). Updates the 'centroid' array given as a parameter.

Referenced by rod::Rod::rotate_rod().

◆ get_delta_r()

float rod::get_delta_r ( float  friction,
float  timestep,
float  force,
float  noise,
float  external_force 
)

\[ \Delta \underline{r}_i = \frac{\Delta t}{S} (F_c + F_{ext} + f_i) \]

Where $ \Delta \underline{r}_i $ is the change in r (either x, y, z or $ \theta $, $ S $ is the viscous drag (derived from viscosity), $ F_C $ is the force (or torque) due to the energy, $ F_{ext} $ is the external force being applied (if any) and $ f_i $ is the random force or torque. This expression is a rearrangement of the first order equation of motion for an object with viscous drag.

Referenced by rod::Rod::do_timestep().

◆ get_euler_angles()

void rod::get_euler_angles ( float  rm[9],
OUT float  euler_angles[3] 
)

This is a candidate for removal. It will convert a rotation matrix to a set of euler angles. I thought I needed it due to the way the blob interface is written, turns out I don't.

◆ get_force()

float rod::get_force ( float  bend_energy,
float  stretch_energy,
float  delta_x 
)

\[ F = \frac{\Delta E}{\Delta r} \]

Where $ F$ is force due to the energy gradient, $ \Delta E $ is the energy gradient, and $ \Delta r $ is the size of the perturbation. This is just a rearrangement of the work function.

◆ get_gradient_deformation()

void rod::get_gradient_deformation ( float  J_inv_0[0],
mesh_node **  nodes_curr,
OUT float  transposed_gradient_deformation_3x3[9] 
)

Get the 3x3 gradient deformation matrix of a tetrahedron. The tetrahedron is given as an array of the mesh_node object defined in mesh_node.cpp. Two arrays are needed, one representing the tetrahedron before it was deformed, the other one representing the tetrahedron after deformation.

\[ \mathbf{F_e} = (\mathbf{J'} \mathbf{J}^{-1})^T \]

Where $ \mathbf{F} $ is the gradient deformation matrix, $ \mathbf{J'} $ is the Jacobian of the new deformed tetrahedron, and $ \mathbf{J} $ is the Jacobian of the undeformed one. Note: this is mostly the same as the one in tetra_element_linear.cpp, but that one is a member function that operates on member variables of tetra_element_linear, whereas this one is a pure function (and uses the same floats and 1-d arrays as the rest of the rod stuff).

Referenced by rod::Rod_blob_interface::reorientate_connection().

◆ get_jacobian() [1/2]

void rod::get_jacobian ( mesh_node **  tet_nodes,
OUT float  J[9] 
)

◆ get_jacobian() [2/2]

void rod::get_jacobian ( mesh_node **  tet_nodes,
OUT float  J[0] 
)

For an array of 9 tet_nodes (defined in object defined in mesh_node.cpp/mesh_node.h) populate a 1-D array with the 3x3 Jacobian of the shape functions.

Referenced by ffea_test::connection_test(), get_gradient_deformation(), ffea_test::jacobian_rotate(), and rod::Rod_blob_interface::update_J_0().

◆ get_kb_i() [1/2]

void rod::get_kb_i ( float  p_im1[3],
float  p_i[3],
float  e_im1_equil[3],
float  e_i_equil[3],
OUT float  kb_i[3] 
)

◆ get_kb_i() [2/2]

void rod::get_kb_i ( float  p_im1[3],
float  p_i[3],
OUT float  kb_i[3] 
)

\[ \frac{2p_{i-1} \times p_i}{|p_i|\cdot|p_{i-1}| + p_{i-1}\cdot p_i } \]

Where $p_i$ and $p_{i-1}$ are the i-1 and ith segments, respectively.

Referenced by get_bend_energy_from_p(), and get_bend_energy_mutual_parallel_transport().

◆ get_l_i()

float rod::get_l_i ( float  p_i[3],
float  p_im1[3] 
)

◆ get_mutual_axes_inverse()

void rod::get_mutual_axes_inverse ( float  mim1[3],
float  mi[3],
float  weight,
OUT float  m_mutual[3] 
)

◆ get_mutual_element_inverse()

void rod::get_mutual_element_inverse ( float  pim1[3],
float  pi[3],
float  weight,
OUT float  mutual_element[3] 
)

◆ get_noise()

float rod::get_noise ( float  timestep,
float  kT,
float  friction,
float  random_number 
)

\[ g = \sqrt{ \frac{24k_B T \delta t }{S} } \]

Where $ g $ is the force due to the thermal noise, $ T $ is the temperature of the system, and $ S $ is the viscous drag, derived from the viscosity. This expression is derived from the fluctuation dissipation relation for the langevin equation of the .

Referenced by rod::Rod::do_timestep().

◆ get_omega_j_i()

void rod::get_omega_j_i ( float  kb_i[3],
float  n_j[3],
float  m_j[3],
OUT float  omega_j_i[2] 
)

\[ \omega(i,j) = \left( (k\vec{b})_i \cdot \vec{n}_j, -(k\vec{b})_i \cdot m_j \right)^T \]

Where $ (k\vec{b})_i $ is the curvature binormal, defined above, and $ m_j $ and $ n_j $ are the jth material axes.

Referenced by get_bend_energy_from_p(), and get_bend_energy_mutual_parallel_transport().

◆ get_p_i()

void rod::get_p_i ( float  curr_r[3],
float  next_r[3],
OUT float  p_i[3] 
)

\[ p_i = r_{i+1} - r_i \]

The segment $ e_i $ is the vector that runs from the node $ r_i $ to $ r_{i+1} $

Referenced by rod::Rod::do_timestep().

◆ get_perturbation_energy() [1/2]

void rod::get_perturbation_energy ( float  perturbation_amount,
int  perturbation_dimension,
float  B_equil[4],
float *  material_params,
int  start_cutoff,
int  end_cutoff,
int  p_i_node_no,
float *  r_all,
float *  r_all_equil,
float *  m_all,
float *  m_all_equil,
float  energies[3] 
)

◆ get_perturbation_energy() [2/2]

void rod::get_perturbation_energy ( float  perturbation_amount,
int  perturbation_dimension,
float *  B_matrix,
float *  material_params,
int  start_cutoff,
int  end_cutoff,
int  p_i_node_no,
float *  r_all,
float *  r_all_equil,
float *  m_all,
float *  m_all_equil,
OUT float  energies[3] 
)

The get_perturbation_energy function ties together everything in this file. It will compute the energy in a specified degree of freedom for a given node.

  • perturbation_amount - the amount of perturbation to do in the numerical differentiation.
  • perturbation_dimension - which dimension to get dE/dr in (x,y,z or twist)
  • B_equil, k and beta - the bending response matrix, spring and twist constants
  • start and end cutoff, p_i_node_no - your position in the rod
  • r_all, r_all_equil, m_all, m_all_equil - pointers to arrays containing the complete state of the rod
  • energies - an array containing 3 values - stretch, bend and twist energy.

It works as follows:

  • Load up a 2-d array for each e, m, e_equil and m_equil in the 4-segment zone needed to compute a dE
  • Perturb a degree of freedom and update the material frame accordingly
  • Compute the value of j
  • Compute each energy based on the contribution from each segment affected by the numerical differentiation

Referenced by ffea_test::connection_propagation(), and rod::Rod::do_timestep().

◆ get_rotation_matrix()

void rod::get_rotation_matrix ( float  a[3],
float  b[3],
float  rotation_matrix[9] 
)

Get the rotation matrix (3x3) that rotates a (3x1) onto b (3x1).

\[R = I + [v]_\times + [v]_\times^2 \frac{1}{1+c}\]

Where

\[v = a \times b\]

\[c = a \cdot b\]

\[[v]_\times = \begin{bmatrix} 0 & -v_3 & v_2 \\ v_3 & 0 & -v_1 \\ -v_2 & v_1 & 0 \end{bmatrix}\]

This seemed like the cheapest way to do it.

Referenced by ffea_test::connection_propagation(), parallel_transport(), rod::Rod_blob_interface::position_blob_from_rod(), rod::Rod_blob_interface::position_rod_from_blob(), and update_m1_matrix().

◆ get_rotation_matrix_from_euler()

void rod::get_rotation_matrix_from_euler ( float  euler_angles[3],
OUT float  rm[9] 
)

This one should be pretty self-explanatory, it does the inverse of the previous function. Given a set of euler angles, it produces a rotation matrix.

Referenced by ffea_test::arbitrary_equilibrium_bend(), ffea_test::connection_propagation(), equil_attachment_node_from_J(), and rod::Rod_blob_interface::get_attachment_node().

◆ get_rotational_friction()

float rod::get_rotational_friction ( float  viscosity,
float  radius,
float  length,
bool  safe 
)

\[ S_{translation} = \xi_{translation} = 6 \pi \mu a \]

\[ S_{rotation} = 8 \pi \mu a^3\]

\[ S_{rotation} = 8 \pi \mu a^2 l \]

Both statements of Stokes law. The friction $ S $ for our dynamics can be computed from the viscosity of the medium, $\mu $, and the radius of the rod, $a$.

Referenced by rod::Rod::do_timestep().

◆ get_signed_angle()

float rod::get_signed_angle ( float  m1[3],
float  m2[3],
float  l[3] 
)

\[ arctan2( (m2 \cross m1) \cdot l), m1 \cdot m2) ) \]

Get the angle between two vectors. The angle is signed (left hand rotation). Params: m1, m2 - the two material axis vectors being measured. l: the normalized element vector. returns: the angle between them, in radians. Credit: StackOverflow user Adrian Leonhard (https://stackoverflow.com/a/33920320)

Referenced by get_twist_energy().

◆ get_stretch_energy()

float rod::get_stretch_energy ( float  k,
float  p_i[3],
float  p_i_equil[3] 
)

\[ E_{stretch} = \frac{1}{2}k(|\vec{p}_i| - |\widetilde{p}_i|)^2 \]

where $k$ is the spring constant, $p$ is the current segment and $m'$ is the equilbrium one.

Referenced by rod::Rod_blob_interface::get_node_energy(), and get_perturbation_energy().

◆ get_torque()

float rod::get_torque ( float  twist_energy,
float  delta_theta 
)

\[ T = \frac{\Delta E}{\Delta \theta} \]

Where $ T$ torque due to the energy gradient, $ \Delta E $ is the energy gradient, and $ \Delta \theta $ is the size of the perturbation. This is a rearrangement of the work function.

◆ get_translational_friction()

float rod::get_translational_friction ( float  viscosity,
float  radius,
bool  rotational 
)

\[ S_{translation} = \xi_{translation} = 6 \pi \mu a \]

Statement of Stokes law. The friction $ S $ for our dynamics can be computed from the viscosity of the medium, $\mu $, and the radius of the rod, $a$.

Referenced by rod::Rod::do_timestep().

◆ get_tri_norm()

void rod::get_tri_norm ( float  node0[3],
float  node1[3],
float  node2[3],
OUT float  tri_norm[3] 
)

Given the three nodes in a triangle (or the face of a tetrahedron, if you prefer), get the direction vector of the normal to to that face.

Referenced by equil_attachment_node_from_J(), and rod::Rod_blob_interface::get_attachment_node().

◆ get_twist_energy()

float rod::get_twist_energy ( float  beta,
float  m_i[3],
float  m_im1[3],
float  m_i_equil[3],
float  m_im1_equil[3],
float  p_im1[3],
float  p_i[3],
float  p_im1_equil[3],
float  p_i_equil[3] 
)

\[ E_{twist} = \frac{\beta}{l_i} \left( \Delta \theta_i - \Delta \widetilde{\theta}_i \right)^2 \]

Whereupon $l_i$ is $ |p_i| + |p_{i-1}| $, $\beta$ is the twisting energy constant, and

\[ \Delta\theta = \cos^{-1} ( P(m_{i+1}) \cdot m_i ) \]

Where P represents parallel transport.

Referenced by ffea_test::arbitrary_equilibrium_twist(), ffea_test::dump_twist_info(), rod::Rod_blob_interface::get_node_energy(), and get_perturbation_energy().

◆ get_weights()

float rod::get_weights ( float  a[3],
float  b[3] 
)

◆ isinf()

bool rod::isinf ( float  x)

◆ isnan()

bool rod::isnan ( float  x)

◆ load_B_all()

void rod::load_B_all ( float  B[4][4],
float *  B_matrix,
int  offset 
)

Referenced by get_perturbation_energy().

◆ load_m()

void rod::load_m ( float  m_loaded[4][3],
float *  m,
int  offset 
)

This does the same, only it loads m instead.

Referenced by get_perturbation_energy().

◆ load_p()

void rod::load_p ( float  p[4][3],
float *  r,
int  offset 
)

This will load a region of a 1-d array containing nodes into an array of 4 p_i arrays, from i-2 to i+1. This is all the info we need to compute each type of energy.

Referenced by rod::Rod::do_timestep(), and get_perturbation_energy().

◆ make_diagonal_B_matrix()

void rod::make_diagonal_B_matrix ( float  B,
OUT float  B_matrix[4] 
)

This is a utility function that will (arbitrarily) create a 4x4 diagonal matrix with a symmetric bending response B.

◆ matmul_3x3_3x3()

void rod::matmul_3x3_3x3 ( float  a[9],
float  b[9],
OUT float  out[9] 
)

Dot product of two 3x3 matrices.

Referenced by rod::Rod::rotate_rod().

◆ matrix_invert_3x3()

void rod::matrix_invert_3x3 ( float  m[9],
OUT float  inverted_matrix[9] 
)

Inverts a 3x3 matrix. Yeah, nothing clever going on here. Params: m - a matrix. Counted row-wise, so a11, a12, a13, a21... etc Returns: the same, but inverted.

Referenced by equil_attachment_node_from_J(), and rod::Rod_blob_interface::update_J_0().

◆ mesh_node_null_check()

void rod::mesh_node_null_check ( mesh_node node,
std::string  location 
)

Utility function to check if a mesh node is null.

◆ normalize()

◆ normalize_all()

void rod::normalize_all ( float  p[4][3])

This normalizes every segment in a 4-segment section of the rod.

Referenced by get_perturbation_energy().

◆ normalize_unsafe()

void rod::normalize_unsafe ( float  in[3],
OUT float  out[3] 
)

Normalize a 3-d vector. The there is no return value, but it populates an array whose pointer is specified as a function parameter, stl-style. Note: this version is 'unsafe' because it does not check for the presence of NaN or infinity.

Referenced by cross_all(), and normalize_all().

◆ not_simulation_destroying() [1/4]

bool rod::not_simulation_destroying ( float  x,
std::string  message 
)

◆ not_simulation_destroying() [2/4]

bool rod::not_simulation_destroying ( float  x[3],
std::string  message 
)

This will do the same thing, but check an array 3 in length, and print a warning specifying which value it is.

◆ not_simulation_destroying() [3/4]

bool rod::not_simulation_destroying ( float  x)

◆ not_simulation_destroying() [4/4]

bool rod::not_simulation_destroying ( float  x[3])

◆ parallel_transport()

void rod::parallel_transport ( float  m[3],
float  m_prime[3],
float  p_im1[3],
float  p_i[3] 
)

Use the previously defined rotation matrix functions to parallel transport a material frame m into the orientation m', from segment p_im1 to segment p_i.

Referenced by rod::Rod_blob_interface::get_attachment_material_axis(), get_bend_energy_mutual_parallel_transport(), and get_twist_energy().

◆ perpendicularize()

void rod::perpendicularize ( float  m_i[3],
float  p_i[3],
OUT float  m_i_prime[3] 
)

\[\widetilde{m_{1 i}}' = \widetilde{m_{1 i}} - ( \widetilde{m_{1 i}} \cdot \widetilde{l_i}) \widetilde{\hat{l_i}}\]

where $l$ is the normalized tangent, $m$ is the current material frame and $m'$ is the new one.

Referenced by update_m1_matrix().

◆ point_inside_tetrahedron()

bool rod::point_inside_tetrahedron ( float  point[3],
float  tet[12] 
)

◆ points_out_of_tet()

bool rod::points_out_of_tet ( float  node1[3],
float  node2[3],
float  node3[3],
float  node4[3],
float  attachment_element[3],
float  attachment_node[3] 
)

Check to see whether an attachment element points out of or into its attached tetrahedron. If it points into the tetrahedron, it should be flipped around. Params: node1, node2, node3, node4 - nodes in the tetrahedron attachment_element - the attachment element attachment_node - position of the attachment node Returns: points_out, a boolean. True if it points out.

Referenced by equil_attachment_node_from_J(), and rod::Rod_blob_interface::get_attachment_node().

◆ precise_normalize()

void rod::precise_normalize ( float  in[3],
float  out[3] 
)

There is some weird behaviour in FFEA when -ffast-math and -O1 or more are both turned on (which are our default compiler settings). It normalizes vectors to floating-point precision, but the std::acos function will take the absolute value of that vector to be <1. Do not remove this function! If you compare the values it returns to rod::normalize, they will look identical, but they do not behave identically.

Referenced by get_twist_energy().

◆ print_array() [1/2]

◆ print_array() [2/2]

void rod::print_array ( std::string  array_name,
double  array[],
int  length 
)

◆ QR_decompose_gram_schmidt()

void rod::QR_decompose_gram_schmidt ( float  matrix_3x3[9],
OUT float  Q[9],
float  R[9] 
)

QR decompose a 3x3 matrix (given here as a 1-d array of floats) using the Gram-Schmidt process. Like the matrix multiplication above, this is again unrolled. This populates arrays for both Q and R, although only R is used. We wish to decompose the 3x3 matrix A ([a_1 ... a_n]) into two 3x3 matrices, Q and R. The elements e_n of our Q matrix are given by the following recursive definition:

\[ u_1 = a_1, ~ e_1 = \frac{u1}{||u_1||} \]

\[ u_{k+1} = a_{k+1} - (a_{k+1} \cdot e_1)e1 - ... - (a_{k+1} \cdot e_k)e_k, ~ e_1 = \frac{u1}{||u_1||}, e_{k+1} = \frac{u_{k+1}}{||u_{k+1}||} \]

\[A = [ a_1 | a_2 | \dots | a_n] = [ e_1 | e_2 | \dots | e_n] \begin{bmatrix} a_{1}\cdot e_1 & a_2\cdot e_1 & \dots & a_n \cdot e_1 \\ 0 & a_2 \cdot e_2 & \dots & a_n \cdot e_2 \\ \vdots & \vdots & \ddots & \vdots \\ 0 & 0 & \dots & a_n \cdot e_n \end{bmatrix} = QR \]

Referenced by rod::Rod_blob_interface::reorientate_connection().

◆ random_number()

float rod::random_number ( float  A,
float  B,
RngStream  rng[],
int  thread_id 
)

Generate a random number between A and B, given an array of RngStream objects, and the id of the RngStream objects to be used.

Referenced by rod::Rod::do_timestep(), and get_noise().

◆ rescale_attachment_node()

void rod::rescale_attachment_node ( float  attachment_node[3],
float  end_node[3],
float  attachment_node_equil[3],
float  end_node_equil[3],
OUT float  scaled_attachment_node[3],
float  scaled_attachment_node_equil[3] 
)

This will scale the attachment element such that, if the end element gets longer, it gets shorter and vice-versa. The short reason for this is so that the attachment element respects the node weighting feature of the mutual material axis bend energy calculation, bearing in mind that shorter elements have the mutual elements weighted more heavily toward them. Params: attachment_node, the attachment element end_node, the end element equilibrium versions of those two Returns: scaled_attachment_node - the scaled version of the attachment element scaled_attachment_node_equil - the same, at equilibrium

Referenced by rod::Rod_blob_interface::get_node_energy().

◆ rod_abort()

void rod::rod_abort ( std::string  message)

Hopefully I won't ever have to use this. Edit: I used it

Referenced by rod::Rod::do_timestep(), and not_simulation_destroying().

◆ rodrigues_rotation()

void rod::rodrigues_rotation ( float  v[3],
float  k[3],
float  theta,
OUT float  v_rot[3] 
)

\[ {\mathbf {v}}_{{\mathrm {rot}}}={\mathbf {v}}\cos \theta +({\mathbf {k}}\times {\mathbf {v}})\sin \theta +{\mathbf {k}}({\mathbf {k}}\cdot {\mathbf {v}})(1-\cos \theta )~. \]

Where $ v_{rot} $ is the resultant vector, $ \theta $ is the angle to rotate, $ v $ is the original vector and $ k $ is the axis of rotation. This is Rodrigues' rotation formula, a cheap way to rotate a vector around an axis.

Referenced by ffea_test::arbitrary_equilibrium_twist(), ffea_test::connection_propagation(), rod::Rod::do_timestep(), ffea_test::dump_twist_info(), get_perturbation_energy(), and ffea_test::twist_bend_coil().

◆ rotate_tet()

void rod::rotate_tet ( float  rotmat[9],
mesh_node **  nodes,
OUT mesh_node **  rotated_nodes 
)

Rotate a tetrahedron (given by an array of mesh_node objects) by a 3x3 rotation matrix (given as a 1-d array of floats) about its centroid. Populates a new mesh_node object. Note that this function is not used in the main simulation loop, it is only used in the rod_blob_interface unit test.

Referenced by ffea_test::connection_test().

◆ safe_cos()

float rod::safe_cos ( float  in)

the c++ acos function will return nan for acos(>1), which we sometimes get (mostly 1.000001) due to some imprecisions. Obviously acos(a milllion) isn't a number, but for values very close to 1, we4 will give the float the benefit of the doubt and say the acos is zero.

◆ set_cutoff_values() [1/2]

void rod::set_cutoff_values ( int  e_i_node_no,
int  length,
OUT int  start_cutoff,
int  end_cutoff 
)

◆ set_cutoff_values() [2/2]

void rod::set_cutoff_values ( int  p_i_node_no,
int  num_nodes,
OUT int *  start_cutoff,
int *  end_cutoff 
)

The two variables, start and end cutoff, determine whether to skip some calculations (energies, material frame updates, etc). They're computed based on the position of the current node, and whether that node's 4-segment 'window of influence' goes off the side of the rod or not. The values of start and end cutoff are how many nodes on their respective ends of the rod do not exist.

Referenced by ffea_test::connection_propagation(), and rod::Rod::do_timestep().

◆ stof_vec() [1/2]

std::vector<float> rod::stof_vec ( std::vector< std::string >  vec_in,
int  length 
)

◆ stof_vec() [2/2]

std::vector<float> rod::stof_vec ( std::vector< std::string >  vec_in)

Utility ---—— Convert a vector containing strings to a vector of floats.

Referenced by rod::Rod::load_contents().

◆ transpose_3x3()

void rod::transpose_3x3 ( float  in[9],
OUT float  transposed[9] 
)

Transpose a 3x3 matrix, represented as a 1-D array of floats. Populate the array 'transposed'.

Referenced by get_gradient_deformation().

◆ update_and_fix_m1_all()

void rod::update_and_fix_m1_all ( float  old_e[4][3],
float  new_e[4][3],
float  m[4][3] 
)

◆ update_m1_all()

void rod::update_m1_all ( float  m[4][3],
float  absolutes[4],
float  t[4][3],
float  delta_e[4][3],
OUT float  m_out[4][3] 
)

◆ update_m1_matrix()

void rod::update_m1_matrix ( float  m_i[3],
float  p_i[3],
float  p_i_prime[3],
float  m_i_prime[3] 
)

Say that the segment p_i is rotated into the position p_i_prime. This function rotates the material frame m_i by the same amount. Used to compute m_i of the 'perturbed' p_i values during the numerical differentation. And also when the new e_i values are computed at the end of each frame!

Referenced by rod::Rod::do_timestep(), rod::Rod_blob_interface::position_rod_ends(), and update_m1_matrix_all().

◆ update_m1_matrix_all()

void rod::update_m1_matrix_all ( float  m[4][3],
float  p[4][3],
float  p_prime[4][3],
OUT float  m_prime[4][3],
int  start_cutoff,
int  end_cutoff 
)

This performs the material frame update described earlier on every segment in a 4-segment section of the rod. Because this operation is more expensive than the others in this list, it uses a lookup table, and skips non-existent segments.

Referenced by get_perturbation_energy().

Variable Documentation

◆ boltzmann_constant

const double rod::boltzmann_constant = 1.3806503e-23/mesoDimensions::Energy

◆ dbg_print

◆ debug_nan

const bool rod::debug_nan = false
static

◆ i

const int rod::i = 2
static

index of ith thing

Referenced by Blob::absolutely_get_face(), World::activate_springs(), tetra_element_linear::add_diffusion_matrix(), Face::add_force_to_node(), tetra_element_linear::add_force_to_node(), Face::add_force_to_node_atomic(), PoissonMatrixQuadratic::add_grad_dot_products(), tetra_element_linear::add_K_alpha(), MassMatrixQuadratic::add_psi_dot_products(), Blob::add_steric_nodes(), Blob::aggregate_forces_and_solve(), SparseMatrixFixedPattern::am_i_diagonally_dominant(), SparseMatrixFixedPattern::apply(), SparseMatrixUnknownPattern::apply(), Blob::apply_ctforces(), World::apply_dense_matrix(), BiCGSTAB_solver::apply_diagonal_matrix(), tetra_element_linear::apply_element_mass_matrix(), ConjugateGradientSolver::apply_matrix(), MassLumpedSolver::apply_matrix(), World::apply_springs(), tetra_element_linear::apply_stress_tensor(), arr3arr3Add(), arr3arr3Distance(), arr3arr3DotProduct(), arr3arr3Substract(), arr3Initialise(), arr3Normalise(), arr3Normalise2(), arr3Resize(), arr3Resize2(), arr3Resize3(), arr3Store(), array_contains(), array_equal(), SimulationParams::assign(), SparseMatrixFixedPattern::block_apply(), MassMatrixLinear::build(), MassMatrixQuadratic::build(), SparseMatrixFixedPattern::build(), PoissonMatrixQuadratic::build(), BEM_Poisson_Boltzmann::build_BEM_matrices(), World::build_kinetic_identity_maps(), Blob::build_linear_node_elasticity_matrix(), Blob::build_linear_node_mass_matrix(), Blob::build_linear_node_rp_diffusion_matrix(), Blob::build_linear_node_viscosity_matrix(), NearestNeighbourLinkedListCube::build_nearest_neighbour_lookup(), PreComp_solver::build_pc_nearest_neighbour_lookup(), Blob::calc_all_centroids(), World::calc_blob_corr_matrix(), Blob::calc_centroids_and_normals_of_all_faces(), SecondOrderFunctions::calc_det_J(), PreComp_solver::calc_force_from_pot(), SparseMatrixUnknownPattern::calc_inverse_diagonal(), SparseMatrixFixedPattern::calc_inverse_diagonal(), Blob::calc_rest_state_info(), Blob::calc_volume(), tetra_element_linear::calculate_electrostatic_forces(), World::calculate_kinetic_rates(), Blob::calculate_node_element_connectivity(), BlobLite::center_of_coord(), NoMassCGSolver::check(), SparsityPattern::check_for_contribution(), SparseMatrixFixedPattern::check_symmetry(), Face::checkTetraIntersection(), Face::checkTetraIntersectionAndGetVolume(), World::choose_new_kinetic_state(), BiCGSTAB_solver::complicated_machine(), Blob::compress_blob(), PreComp_solver::compute_bead_positions(), CG_solver::conjugate_gradient_residual(), NoMassCGSolver::conjugate_gradient_residual_assume_x_zero(), ConjugateGradientSolver::conjugate_gradient_residual_assume_x_zero(), ffea_test::connection_energy(), ffea_test::connection_energy_2(), ffea_test::connection_propagation(), ffea_test::connection_test(), VdW_solver::consider_interaction(), Blob::copy_node_positions(), BiCGSTAB_solver::copy_vector(), Blob::create_pinned_nodes(), SparsityPattern::create_sparse_matrix(), Blob::create_viewer_node_file(), tetra_element_linear::create_viscosity_matrix(), World::dmm(), World::dmm_rp(), rod::Rod_blob_interface::do_connection_timestep(), World::do_es(), VdW_solver::do_gensoft_interaction(), VdW_solver::do_lj_interaction(), VdW_solver::do_sticky_xz_interaction(), rod::Rod::do_timestep(), CG_solver::dot(), BiCGSTAB_solver::dot(), ffea_test::dump_twist_info(), Blob::enforce_box_boundaries(), rod::Rod::equilibrate_rod(), Blob::euler_integrate(), exists(), findCM(), BEM_Poisson_Boltzmann::gauss_quadrature_4_point(), NoMassCGSolver::get_alpha_denominator(), rod::Rod_blob_interface::get_attachment_node(), Blob::get_bead_assignment(), Blob::get_bead_position(), Blob::get_bead_type(), rod::Rod::get_centroid(), get_centroid_generic(), Blob::get_element(), rod::Rod_blob_interface::get_element_id(), Blob::get_face(), VdW_solver::get_field_energy(), PreComp_solver::get_field_energy(), tetra_element_linear::get_grad_phi_at_stu(), PoissonMatrixQuadratic::get_K_alpha_mem_loc(), PoissonMatrixQuadratic::get_K_alpha_value(), MassMatrixLinear::get_M_alpha_mem_loc(), MassMatrixQuadratic::get_M_alpha_mem_loc(), MassMatrixLinear::get_M_alpha_value(), MassMatrixQuadratic::get_M_alpha_value(), SimulationParams::get_max_num_states(), rod::Rod::get_min_max(), Blob::get_min_max(), rod::Rod_blob_interface::get_node_energy(), BindingSite::get_nodes(), SparseMatrixFixedPattern::get_num_columns(), Blob::get_num_linear_nodes(), get_perturbation_energy(), BiCGSTAB_solver::get_residual_vector(), get_rotation_matrix(), World::get_smallest_time_constants(), World::get_spring_field_energy(), Blob::get_ssint_area(), World::get_system_centroid(), World::get_system_CoM(), World::get_system_dimensions(), getLocalCoordinatesForLinTet(), getMissingPair(), RngStream::GetState(), getTetrahedraCM(), Face::getTetraIntersectionVolume(), Face::getTetraIntersectionVolumeAndArea(), Face::getTetraIntersectionVolumeTotalGradientAndShapeFunctions(), getUnitNormal(), MatrixFixedSparsityPattern::init(), VdW_solver::init(), SparseMatrixUnknownPattern::init(), SparseMatrixFixedPattern::init(), ConjugateGradientSolver::init(), MassLumpedSolver::init(), SparseSubstitutionSolver::init(), NoMassCGSolver::init(), PreComp_solver::init(), BindingSite_matrix::init(), World::init(), Blob::init(), SSINT_matrix::init_ssint(), GaussianQuadrature_tri::integrate_face_to_face(), GaussianQuadrature_1d::integrate_function_1d(), GaussianQuadrature_1d::integrate_function_1d_tri(), GaussianQuadrature_tri::integrate_point_to_face(), ffea_test::jacobian_rotate(), Blob::kinetically_set_faces(), World::lem(), Face::length_of_longest_edge(), tetra_element_linear::length_of_longest_edge(), Blob::linearise_elements(), Blob::linearise_force(), Blob::load_beads(), Blob::load_binding_sites(), rod::Rod::load_contents(), Blob::load_ctforces(), rod::Rod::load_header(), World::load_kinetic_maps(), World::load_kinetic_rates(), World::load_kinetic_states(), Blob::load_material_params(), BlobLite::load_nodes(), Blob::load_nodes(), Blob::load_pinned_nodes(), World::load_springs(), Blob::load_ssint(), Blob::load_stokes_params(), Blob::load_surface(), Blob::load_surface_no_topology(), BlobLite::load_topology(), Blob::load_topology(), ffea_test::lower_sphere(), mag(), mag2(), Blob::make_measurements(), World::make_measurements(), World::make_trajectory_from_eigenvector(), mat12_apply(), mat12_set_zero(), mat3_mult(), mat3_mult_both_transposed(), mat3_mult_transpose(), mat3_set_identity(), mat3_set_zero(), mat4_set_zero(), maxVolume(), maxVolumeAndArea(), NoMassCGSolver::modx(), Blob::move(), not_simulation_destroying(), vector3::operator[](), arr3_view< t_scalar, brr3 >::operator[](), CG_solver::parallel_apply_preconditioner(), NoMassCGSolver::parallel_apply_preconditioner(), ConjugateGradientSolver::parallel_apply_preconditioner(), ConjugateGradientSolver::parallel_sparse_matrix_apply(), CG_solver::parallel_vector_add(), ConjugateGradientSolver::parallel_vector_add(), CG_solver::parallel_vector_add_self(), ConjugateGradientSolver::parallel_vector_add_self(), FFEA_input_reader::parse_tag(), Blob::position(), Blob::position_beads(), rod::Rod_blob_interface::position_rod_from_blob(), Blob::pre_print(), NearestNeighbourLinkedListCube::prebuild_nearest_neighbour_lookup(), NearestNeighbourLinkedListCube::prebuild_nearest_neighbour_lookup_and_swap(), PreComp_solver::prebuild_pc_nearest_neighbour_lookup(), PreComp_solver::prebuild_pc_nearest_neighbour_lookup_and_swap(), SparseMatrixUnknownPattern::print(), SparsityPattern::print(), SparseMatrixFixedPattern::print(), tetra_element_linear::print(), print_array(), Blob::print_bead_positions(), World::print_checkpoints(), SparseMatrixFixedPattern::print_dense(), SparseMatrixFixedPattern::print_dense_to_file(), MassMatrixLinear::print_details(), MassMatrixQuadratic::print_details(), World::print_evals_to_file(), World::print_evecs_to_file(), World::print_kinetic_files(), World::print_kinetic_rates_to_screen(), print_matrix12(), print_matrix3(), print_matrix4(), Face::print_nodes(), SparseMatrixFixedPattern::print_row_column(), BindingSite_matrix::print_to_screen(), World::print_trajectory_and_measurement_files(), World::print_trajectory_conformation_changes(), print_vector12(), tetra_element_linear::print_viscosity_matrix(), World::read_and_build_system(), BlobLite::read_nodes_from_file(), Blob::read_nodes_from_file(), PreComp_solver::read_tabulated_values(), SparsityPattern::register_contribution(), VdW_solver::reset_fieldenergy(), PreComp_solver::reset_fieldenergy(), RngStream::ResetNextSubstream(), RngStream::ResetStartStream(), RngStream::ResetStartSubstream(), CG_solver::residual2(), NoMassCGSolver::residual2(), ConjugateGradientSolver::residual2(), RngStream::RngStream(), rod::Rod_blob_interface::Rod_blob_interface(), Blob::rotate(), rod::Rod::rotate_rod(), rotate_tet(), World::run(), BiCGSTAB_solver::scalar_vector_add(), PoissonMatrixQuadratic::scale(), rod::Rod::scale_rod(), rod::Rod_blob_interface::select_face_nodes(), Blob::set_forces_to_zero(), rod::Rod_blob_interface::set_initial_values(), Blob::set_node_positions(), Blob::set_pos_0(), sparse_entry_sources::set_source(), rod::Rod_blob_interface::set_tet(), rod::Rod::set_units(), RngStream::SetPackageSeed(), RngStream::SetSeed(), CG_solver::solve(), VdW_solver::solve(), BiCGSTAB_solver::solve(), ConjugateGradientSolver::solve(), MassLumpedSolver::solve(), NoMassCGSolver::solve(), PreComp_solver::solve(), SparseSubstitutionSolver::solve(), Blob::solve_poisson(), PreComp_solver::solve_using_neighbours(), PreComp_solver::solve_using_neighbours_non_critical(), FFEA_input_reader::split_string(), stof_vec(), sparse_entry_sources::sum_all_sources(), tangent(), tetra_element_linear::tetra_element_linear(), Blob::translate_linear(), rod::Rod::translate_rod(), ffea_test::twist_bend_coil(), rod::Rod_blob_interface::update_J_0(), SimulationParams::validate(), vec12_add(), vec12_scale(), vec12_set_zero(), vec3_add_to_scaled(), vec3_scale_and_add(), Face::vec3Vec3SubsToArr3Mod(), Blob::velocity_all(), volumeAndAreaForIntPoint(), volumeAndAreaForNode(), volumeAndAreaIntersection(), volumeForIntPoint(), volumeForIntPointII(), volumeForNode(), volumeIntersection(), tetra_element_linear::what_node_is_this(), rod::Rod::write_array(), PreComp_solver::write_beads_to_file(), World::write_detailed_measurements_to_file(), World::write_eig_to_files(), rod::Rod::write_mat_params_array(), Blob::write_nodes_to_file(), Blob::write_pre_print_to_file(), World::write_pre_print_to_trajfile(), SimulationParams::write_to_file(), RngStream::WriteState(), RngStream::WriteStateFull(), MassMatrixLinear::zero(), SparseMatrixUnknownPattern::zero(), MassMatrixQuadratic::zero(), PoissonMatrixQuadratic::zero(), CG_solver::zero(), BiCGSTAB_solver::zero(), Face::zero_force(), tetra_element_linear::zero_force(), Blob::zero_force(), SparsityPattern::~SparsityPattern(), VdW_solver::~VdW_solver(), and World::~World().

◆ im1

const int rod::im1 = 1
static

index of i-1st thing

Referenced by get_perturbation_energy().

◆ im2

const int rod::im2 = 0
static

index of i-2nd thing

Referenced by get_perturbation_energy().

◆ ip1

const int rod::ip1 = 3
static

index of i+1th thing

Referenced by get_perturbation_energy().

◆ rod_software_version

const float rod::rod_software_version = 0.3
static

Referenced by rod::Rod::load_header().

◆ x

◆ y

◆ z