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 |
float rod::absolute | ( | float | in[3] | ) |
Get the absolute value of a vector.
Referenced by absolute_all(), ffea_test::connection_propagation(), get_absolute_length_from_array(), get_kb_i(), get_l_i(), get_mutual_axes_inverse(), get_stretch_energy(), get_weights(), normalize(), normalize_unsafe(), precise_normalize(), and rescale_attachment_node().
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.
void rod::apply_rotation_matrix | ( | float | vec[3], |
float | matrix[9], | ||
OUT float | rotated_vec[3] | ||
) |
This is just a straight matrix multiplication, multiplyning the a column vector by a rotation matrix.
Referenced by ffea_test::arbitrary_equilibrium_bend(), ffea_test::connection_propagation(), ffea_test::dump_twist_info(), equil_attachment_node_from_J(), rod::Rod_blob_interface::get_attachment_node(), parallel_transport(), rod::Rod_blob_interface::position_rod_from_blob(), rod::Rod_blob_interface::reorientate_connection(), rod::Rod::rotate_rod(), rotate_tet(), and update_m1_matrix().
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.
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().
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().
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().
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().
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().
void rod::cross_product_unsafe | ( | float | a[3], |
float | b[3], | ||
float | out[3] | ||
) |
Referenced by cross_all(), and rodrigues_rotation().
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.
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().
void rod::fix_m1_all | ( | float | m[4][3], |
float | new_t[4][3] | ||
) |
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.
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().
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.
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().
float rod::get_bend_energy | ( | float | omega_i_im1[2], |
float | omega_i_im1_equil[2], | ||
float | B_equil[4] | ||
) |
Where is the centreline curvature, defined above, is the bending response matrix, and is
Referenced by get_bend_energy_from_p(), and get_bend_energy_mutual_parallel_transport().
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.
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] | ||
) |
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().
float rod::get_delta_r | ( | float | friction, |
float | timestep, | ||
float | force, | ||
float | noise, | ||
float | external_force | ||
) |
Where is the change in r (either x, y, z or , is the viscous drag (derived from viscosity), is the force (or torque) due to the energy, is the external force being applied (if any) and 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().
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.
float rod::get_force | ( | float | bend_energy, |
float | stretch_energy, | ||
float | delta_x | ||
) |
Where is force due to the energy gradient, is the energy gradient, and is the size of the perturbation. This is just a rearrangement of the work function.
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.
Where is the gradient deformation matrix, is the Jacobian of the new deformed tetrahedron, and 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().
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().
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] | ||
) |
void rod::get_kb_i | ( | float | p_im1[3], |
float | p_i[3], | ||
OUT float | kb_i[3] | ||
) |
Where and are the i-1 and ith segments, respectively.
Referenced by get_bend_energy_from_p(), and get_bend_energy_mutual_parallel_transport().
float rod::get_l_i | ( | float | p_i[3], |
float | p_im1[3] | ||
) |
Get the value of L_i.
Referenced by get_bend_energy_from_p(), get_bend_energy_mutual_parallel_transport(), and get_twist_energy().
void rod::get_mutual_axes_inverse | ( | float | mim1[3], |
float | mi[3], | ||
float | weight, | ||
OUT float | m_mutual[3] | ||
) |
Referenced by get_bend_energy_mutual_parallel_transport().
void rod::get_mutual_element_inverse | ( | float | pim1[3], |
float | pi[3], | ||
float | weight, | ||
OUT float | mutual_element[3] | ||
) |
Referenced by get_bend_energy_mutual_parallel_transport().
float rod::get_noise | ( | float | timestep, |
float | kT, | ||
float | friction, | ||
float | random_number | ||
) |
Where is the force due to the thermal noise, is the temperature of the system, and 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().
void rod::get_omega_j_i | ( | float | kb_i[3], |
float | n_j[3], | ||
float | m_j[3], | ||
OUT float | omega_j_i[2] | ||
) |
Where is the curvature binormal, defined above, and and are the jth material axes.
Referenced by get_bend_energy_from_p(), and get_bend_energy_mutual_parallel_transport().
void rod::get_p_i | ( | float | curr_r[3], |
float | next_r[3], | ||
OUT float | p_i[3] | ||
) |
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] | ||
) |
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.
It works as follows:
Referenced by ffea_test::connection_propagation(), and rod::Rod::do_timestep().
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).
Where
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().
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().
float rod::get_rotational_friction | ( | float | viscosity, |
float | radius, | ||
float | length, | ||
bool | safe | ||
) |
Both statements of Stokes law. The friction for our dynamics can be computed from the viscosity of the medium, , and the radius of the rod, .
Referenced by rod::Rod::do_timestep().
float rod::get_signed_angle | ( | float | m1[3], |
float | m2[3], | ||
float | l[3] | ||
) |
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().
float rod::get_stretch_energy | ( | float | k, |
float | p_i[3], | ||
float | p_i_equil[3] | ||
) |
where is the spring constant, is the current segment and is the equilbrium one.
Referenced by rod::Rod_blob_interface::get_node_energy(), and get_perturbation_energy().
float rod::get_torque | ( | float | twist_energy, |
float | delta_theta | ||
) |
Where torque due to the energy gradient, is the energy gradient, and is the size of the perturbation. This is a rearrangement of the work function.
float rod::get_translational_friction | ( | float | viscosity, |
float | radius, | ||
bool | rotational | ||
) |
Statement of Stokes law. The friction for our dynamics can be computed from the viscosity of the medium, , and the radius of the rod, .
Referenced by rod::Rod::do_timestep().
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().
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] | ||
) |
Whereupon is , is the twisting energy constant, and
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().
float rod::get_weights | ( | float | a[3], |
float | b[3] | ||
) |
Referenced by get_bend_energy_mutual_parallel_transport().
bool rod::isinf | ( | float | x | ) |
Referenced by not_simulation_destroying().
bool rod::isnan | ( | float | x | ) |
Referenced by isinf(), normalize(), not_simulation_destroying(), and precise_normalize().
void rod::load_B_all | ( | float | B[4][4], |
float * | B_matrix, | ||
int | offset | ||
) |
Referenced by get_perturbation_energy().
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().
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().
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.
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().
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().
void rod::mesh_node_null_check | ( | mesh_node * | node, |
std::string | location | ||
) |
Utility function to check if a mesh node is null.
void rod::normalize | ( | 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.
Referenced by ffea_test::connection_propagation(), equil_attachment_node_from_J(), rod::Rod_blob_interface::get_attachment_material_axis(), rod::Rod_blob_interface::get_attachment_node(), get_bend_energy_from_p(), get_bend_energy_mutual_parallel_transport(), get_mutual_axes_inverse(), get_mutual_element_inverse(), rod::Rod_blob_interface::get_node_energy(), get_twist_energy(), ffea_test::identify_face(), perpendicularize(), rod::Rod_blob_interface::position_blob_from_rod(), rod::Rod_blob_interface::position_rod_from_blob(), QR_decompose_gram_schmidt(), rodrigues_rotation(), ffea_test::twist_bend_coil(), and update_m1_matrix().
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().
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().
bool rod::not_simulation_destroying | ( | float | x, |
std::string | message | ||
) |
Check if a single value is simulation destroying. Here, simulation destroying means NaN or infinite.
Referenced by absolute(), cross_product(), get_bend_energy(), get_bend_energy_from_p(), get_bend_energy_mutual_parallel_transport(), get_delta_r(), get_force(), get_kb_i(), get_noise(), get_omega_j_i(), get_p_i(), get_stretch_energy(), get_torque(), get_twist_energy(), normalize(), precise_normalize(), and rodrigues_rotation().
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.
bool rod::not_simulation_destroying | ( | float | x | ) |
bool rod::not_simulation_destroying | ( | float | x[3] | ) |
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().
void rod::perpendicularize | ( | float | m_i[3], |
float | p_i[3], | ||
OUT float | m_i_prime[3] | ||
) |
where is the normalized tangent, is the current material frame and is the new one.
Referenced by update_m1_matrix().
bool rod::point_inside_tetrahedron | ( | float | point[3], |
float | tet[12] | ||
) |
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().
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().
void rod::print_array | ( | std::string | array_name, |
float | array[], | ||
int | length | ||
) |
Print the contents of an array to the stdout.
Referenced by ffea_test::arbitrary_equilibrium_bend(), ffea_test::connection_energy(), ffea_test::connection_orientation_test(), ffea_test::connection_propagation(), ffea_test::connection_test(), rod::Rod_blob_interface::do_connection_timestep(), ffea_test::dump_twist_info(), equil_attachment_node_from_J(), rod::Rod_blob_interface::get_attachment_node(), get_bend_energy(), get_bend_energy_from_p(), get_bend_energy_mutual_parallel_transport(), get_gradient_deformation(), rod::Rod_blob_interface::get_node_energy(), get_signed_angle(), get_twist_energy(), World::init(), ffea_test::jacobian_rotate(), rod::Rod_blob_interface::position_blob_from_rod(), rod::Rod_blob_interface::position_rod_from_blob(), ffea_test::recover_normal(), rod::Rod_blob_interface::reorientate_connection(), rescale_attachment_node(), rod::Rod_blob_interface::Rod_blob_interface(), rod::Rod_blob_interface::select_face_nodes(), and rod::Rod_blob_interface::set_initial_values().
void rod::print_array | ( | std::string | array_name, |
double | array[], | ||
int | length | ||
) |
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:
Referenced by rod::Rod_blob_interface::reorientate_connection().
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().
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().
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().
void rod::rodrigues_rotation | ( | float | v[3], |
float | k[3], | ||
float | theta, | ||
OUT float | v_rot[3] | ||
) |
Where is the resultant vector, is the angle to rotate, is the original vector and 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 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().
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.
void rod::set_cutoff_values | ( | int | e_i_node_no, |
int | length, | ||
OUT int | start_cutoff, | ||
int | end_cutoff | ||
) |
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().
std::vector<float> rod::stof_vec | ( | std::vector< std::string > | vec_in, |
int | length | ||
) |
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().
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().
void rod::update_and_fix_m1_all | ( | float | old_e[4][3], |
float | new_e[4][3], | ||
float | m[4][3] | ||
) |
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] | ||
) |
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().
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().
const double rod::boltzmann_constant = 1.3806503e-23/mesoDimensions::Energy |
bool rod::dbg_print = false |
Referenced by ffea_test::connection_propagation(), ffea_test::connection_test(), rod::Rod::do_timestep(), ffea_test::dump_twist_info(), equil_attachment_node_from_J(), rod::Rod_blob_interface::get_attachment_node(), get_gradient_deformation(), rod::Rod_blob_interface::get_node_energy(), rod::Rod::get_p(), World::init(), rod::Rod_blob_interface::position_rod_from_blob(), ffea_test::recover_normal(), rescale_attachment_node(), rod::Rod_blob_interface::Rod_blob_interface(), and rod::Rod_blob_interface::select_face_nodes().
|
static |
Referenced by not_simulation_destroying().
|
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().
|
static |
index of i-1st thing
Referenced by get_perturbation_energy().
|
static |
index of i-2nd thing
Referenced by get_perturbation_energy().
|
static |
index of i+1th thing
Referenced by get_perturbation_energy().
|
static |
Referenced by rod::Rod::load_header().
|
static |
Referenced by absolute(), apply_rotation_matrix(), apply_rotation_matrix_row(), BEM_Poisson_Boltzmann::build_BEM_matrices(), NearestNeighbourLinkedListCube::build_nearest_neighbour_lookup(), PreComp_solver::build_pc_nearest_neighbour_lookup(), NoMassCGSolver::conjugate_gradient_residual_assume_x_zero(), ffea_test::connection_propagation(), cross_product(), cross_product_unsafe(), delta_e_all(), rod::Rod::do_timestep(), get_euler_angles(), get_kb_i(), rod::Rod::get_min_max(), get_omega_j_i(), get_rotation_matrix(), PreComp_solver::init(), isnan(), Blob::load_beads(), BlobLite::load_nodes(), Blob::load_nodes(), NoMassCGSolver::parallel_apply_preconditioner(), perpendicularize(), Blob::position_beads(), 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(), tetra_element_linear::print(), SparseMatrixFixedPattern::print_dense_to_file(), BlobLite::read_nodes_from_file(), PreComp_solver::read_tabulated_values(), rodrigues_rotation(), Blob::rotate(), mesh_node::set_pos(), VdW_solver::solve_sticky_wall(), and Solver::~Solver().
|
static |
Referenced by absolute(), apply_rotation_matrix(), apply_rotation_matrix_row(), NearestNeighbourLinkedListCube::build_nearest_neighbour_lookup(), PreComp_solver::build_pc_nearest_neighbour_lookup(), NoMassCGSolver::conjugate_gradient_residual_assume_x_zero(), cross_product(), cross_product_unsafe(), delta_e_all(), rod::Rod::do_timestep(), get_euler_angles(), get_kb_i(), rod::Rod::get_min_max(), get_omega_j_i(), get_rotation_matrix(), Blob::load_beads(), BlobLite::load_nodes(), Blob::load_nodes(), NoMassCGSolver::parallel_apply_preconditioner(), perpendicularize(), Blob::position_beads(), 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(), tetra_element_linear::print(), SparseMatrixFixedPattern::print_dense_to_file(), BlobLite::read_nodes_from_file(), rodrigues_rotation(), Blob::rotate(), mesh_node::set_pos(), and VdW_solver::solve_sticky_wall().
|
static |
Referenced by absolute(), apply_rotation_matrix(), apply_rotation_matrix_row(), BEM_Poisson_Boltzmann::build_BEM_matrices(), NearestNeighbourLinkedListCube::build_nearest_neighbour_lookup(), PreComp_solver::build_pc_nearest_neighbour_lookup(), cross_product(), cross_product_unsafe(), delta_e_all(), rod::Rod::do_timestep(), get_euler_angles(), get_kb_i(), rod::Rod::get_min_max(), get_omega_j_i(), get_rotation_matrix(), Blob::load_beads(), BlobLite::load_nodes(), Blob::load_nodes(), perpendicularize(), Blob::position_beads(), 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(), tetra_element_linear::print(), SparseMatrixFixedPattern::print_dense_to_file(), BlobLite::read_nodes_from_file(), rodrigues_rotation(), Blob::rotate(), mesh_node::set_pos(), and VdW_solver::solve_sticky_wall().