![]() |
Contains mesh data for thin-wall analysis. Performs stress analysis on this mesh. More...
#include <LineMesh.h>
Public Member Functions | |
LineMesh (std::string fileName, Material baseMaterial, int extraLineSegments) | |
Constructor for the LineMeshClass. | |
void | transformCoordinates () |
Transforms coordinates for computation purposes. More... | |
void | calculatePrincipalMomentOfAreas () |
Calculates the principal moment of areas \(I_{xp}\) and \(I_{yp}\). More... | |
void | calculateAreaStiffness () |
Calculates the area stiffness EA. | |
void | printCoordinates () |
Prints node coordinates. | |
void | calculateMeshProperties () |
Calculates mesh properties. More... | |
void | calculateBendingStiffness () |
Calculates global bending stiffness EIx and EIy by summing the elements respective bending stiffnesses. | |
void | calculateAnglePrincipalAxes () |
Calculates angle of the principal axes. Then forced to be less than 45 and greater than -45 . More... | |
void | printCellAreas () |
Prints cell areas. | |
void | printCells () |
Prints each cell, and its elements. | |
void | constructBMatrix () |
Constructs coefficiant matrix \( \textbf{B} \). More... | |
void | constructAVector (CycleDetection c) |
Constructs area vector \(\boldsymbol{a}\). More... | |
void | solveSystemEquation () |
Solves the system of equations. More... | |
void | calculateStVenantStiffness (CycleDetection c) |
Calculates the St.Venant stiffness \( GI_t \). More... | |
void | calculateShearFlow () |
Calculates the shear flow for all elements in the cross-section. | |
void | calculateOmega_c () |
Calculates \( \omega_c \) for all the elements. More... | |
std::vector< LineElement * > | findCommonElements (std::vector< LineElement * > a, std::vector< LineElement * > b) |
Finds common elements in two vectors, could be moved to a UTILS class. More... | |
std::vector< LineElement * > | DFS () |
Creates a vector of LineElement pointers that are sorted in a DFS fashion, could be extracted to a UTILS class. More... | |
bool | contains (std::vector< int > a, int b) |
Checks wether a vector of ints contains a certain int, could be placed in a UTILS class. More... | |
void | printOmega () |
Prints omega values. | |
void | printOmega_c () |
prints omega_c values | |
void | printDeltaOmega_c () |
Prints delta_Omega_c values. | |
void | calculateShearCenter () |
Calculates shear center of the cross-section by summing the shear centers of each individual element. | |
void | calculateOmega () |
Calculates omega for each node in the cross-section. | |
void | calculateWarpingStiffness () |
Calculates the warping stiffness \((EI_w)\) for the mesh by summing the warping stiffness found in each element. | |
void | calculateOmegaIntersection () |
Iterates through all elements and finds an omega intersection point if it exists. | |
void | calculateSigmaZIntersection (int type, std::vector< std::vector< std::vector< double >>> *intersectionPoints, std::vector< std::vector< bool >> *intersection) |
Iterates through all elements and finds \( \omega \) intersection values if they exist. More... | |
void | calculateOmegaIntersection (int type, std::vector< std::vector< std::vector< double >>> *intersectionPoints, std::vector< std::vector< bool >> *intersection) |
Iterates through all elements and finds sigma_Z intersection values for omega diagrams if they exist. More... | |
void | calculateEk () |
Calculates average E value of all elements surrounding a node. | |
void | calculateAxialStress () |
Calculates the resulting axial stress \( \sigma_z \) for all nodes in the cross-section, as well as axial stress due to \(N, M_x, M_y and B\). More... | |
void | calculatePureStvTorsionStress () |
Calculates the pure St.Venants torsion stress. More... | |
void | addElementPoints (VectorXd f_d, int type) |
Adds points along the element used for visualization of quadratic stress distributions. More... | |
void | findElementIntersections (VectorXd f_d, int type) |
Finds the element intersection points for quadratic functions along the element. More... | |
void | calculateNodalTau (VectorXd f_d, int type) |
Calculates tau values for the nodes. More... | |
void | initiateCVectors () |
Initializes the C vectors for each element. More... | |
void | createA1Matrix () |
Creates A1 matrix. More... | |
void | createA2Matrix () |
Creates A2 matrix. More... | |
void | calculateG1Matrix () |
Calculates G1 matrix. More... | |
void | calculateG2Matrix () |
Calculates G2 matrix. More... | |
void | calculateQ0 (VectorXd f_d, int type) |
Calculates \(q_0\). More... | |
void | printEigenMatrix (MatrixXd A, std::string s) |
prints out a matrix on Eigen format More... | |
void | initializeMatrices () |
Initializes matrices. More... | |
double | calculateQs (double s, LineElement *element, VectorXd f_d, int type) |
Calculates the shear value at a distance s along the element. More... | |
void | calculateTau (VectorXd f_d, int type) |
Calculates \(\tau\) for different applied loads. More... | |
void | calculateTauSTV () |
Calculates tau for applied \(T_{stv}\). | |
void | findMidPoints () |
Finds the middle points of each element. | |
void | findElementsNextToNode () |
Finds the number of elements that are neighboring each node. | |
void | findIntersections () |
Finds diagram intersections for Sigma_z as well as omega. | |
void | calculateKappaX () |
Calculates shear deformation factor \(\kappa_x\). More... | |
void | calculateKappaY () |
Calculates shear deformation factor \( \kappa_y \). More... | |
void | calculateResultingSigmaExtra () |
Calculates to resulting sigma for all extra points in the element. | |
double | calculateVonMisesStress (LineElement *element, int j) |
Calculates von mises stress. More... | |
void | calculateEffectiveStress () |
Calculates effective stress for cross-section. | |
Public Attributes | |
int | TAU_DUE_TO_VX = 0 |
Int corrosponding to \(\tau\) due to \(V_x\). | |
int | TAU_DUE_TO_VY = 1 |
Int corrosponding to \(\tau\) due to \(V_y\). | |
int | TAU_DUE_TO_WRP = 2 |
Int corrosponding to \(\tau\) due to \(T_{wrp}\). | |
int | TAU_RESULTING = 3 |
Int corrosponding to \(\tau\) due to resulting tau. | |
int | TAU_STV = 4 |
Int corrosponding to \(\tau\) due to \(T_{stv}\). | |
int | SIGMA_Z_DUE_TO_N = 0 |
Int corrosponding to \(\sigma_z\) due to \(N\). | |
int | SIGMA_Z_DUE_TO_MX = 1 |
Int corrosponding to \(\sigma_z\) due to \(M_x\). | |
int | SIGMA_Z_DUE_TO_MY = 2 |
Int corrosponding to \(\sigma_z\) due to \(M_y\). | |
int | SIGMA_Z_DUE_TO_B = 3 |
Int corrosponding to \(sigma_z\) due to \(B\). | |
int | SIGMA_Z_RESULTING = 4 |
Int corrosponding to resulting \(\sigma_z\). | |
int | EFFECTIVE_STRESS = 5 |
Int corrosponding to resulting effective stress. | |
int | OMEGA_DIAGRAM = 0 |
Int corrosponding to omega diagram. | |
double | anglePrincipalAxes |
Stores the angle of the principal axes in degrees. | |
double | anglePrincipalAxesRad |
Stores the angle of the principal axes in radians. | |
double | Ax |
Area centre for mesh in x-direction. | |
double | Ay |
Area centre for mesh in y-direction. | |
double | EA |
Axial stiffness. | |
double | EIx |
Bending stiffness about global x-axes. | |
double | EIy |
Bending stiffness about global y-axes. | |
double | EIxy |
Bending stiffness product. | |
double | EImax |
Maximum bending stiffness. | |
double | EIxp |
Bending stiffness about principal x-axes. | |
double | EIyp |
Bending stiffness about principal y-axes. | |
double | Sx |
Weighted moment about global x-axis. | |
double | Sy |
Wighted moment about global y-axis. | |
double | xs |
x-position of shear center | |
double | ys |
y-position of hear center | |
double | C |
Shear center constant. | |
double | totalArea |
The sum of all element areas. | |
double | areaStiffness |
Area stiffness EA. | |
double | stVenantStiffness |
St.Venant stiffness \(GI_t\). | |
double | It |
St. Ventant torsion constant \(I_t\). | |
double | warpingStiffness |
Warping stiffness \(EI_\omega\). | |
double | warpingConstant |
Warping constant \(I_\omega\). | |
double | kappaX |
Shear deformation factor \(\kappa_x\). | |
double | kappaY |
Shear deformation factor \(\kappa_y\). | |
double | N |
Normal force to be applied to the cross section. | |
double | Mx |
Bending moment in x-direction to be applied to the cross section. | |
double | My |
Bending moment in y-direction to be applied to the cross section. | |
double | Vx |
Shear force in x-direction to be applied to the cross section. | |
double | Vy |
Shear force in y-direction to be applied to the cross section. | |
double | Bi |
Bimoment to be applied to the cross section. | |
double | T_stv |
St.Venant torsion to be applied to the cross section. | |
double | T_wrp |
Warping torsion to be applied to the cross section. | |
int | numberOfNodes |
Number of nodes in the cross-section. | |
int | numberOfElementSegments |
Number of element segments along an element, used for displaying quadratic functions. | |
int | numberOfExtraElementPoints |
Number of extra points along an element, used for displaying quadratic functions. | |
Material | baseMaterial |
Base material of thin-walled cross section. | |
MatrixXd | B |
Coefficiant matrix B is used to find st. venants stiffness. | |
VectorXd | a |
A vector of doubles representing the areas of the cells found in the elements. | |
VectorXd | p |
Modified shear flows around each cell. | |
MatrixXd | D |
D matrix. More... | |
VectorXd | f_d |
Vector containing input forces and moments. Forced negative to obtain correct results. \( f' = \begin{bmatrix} 0 & -V_y & -V_x & -T_{wrp} \end{bmatrix} \). | |
VectorXd | f_d_Vx |
Vector containing input forces and moments \( f'_{Vx} = \begin{bmatrix} 0 & 0 & -V_x & 0 \end{bmatrix} \). | |
VectorXd | f_d_Vy |
Vector containing input forces and moments \( f'_{V_y} = \begin{bmatrix} 0 & -V_y & 0 & 0 \end{bmatrix} \). | |
VectorXd | f_d_Wrp |
Vector containing input forces and moments \( f'_{Wrp} = \begin{bmatrix} 0 & 0 & 0 & -T_{wrp} \end{bmatrix} \). | |
MatrixXd | A1 |
Matrix with directional \( \eta \) values. The matrix dimensions are [nrOfNodes \(\times\) nrOfElements]. \( \eta \) is +1 if the LineElement direction is away from the node, and -1 if the direction is towards the node. | |
MatrixXd | A2 |
Matrix with directional \( \eta \) values. The matrix dimensions are [nrOfCells \(\times\) nrOfElements]. \( \eta \) is +1 if the LineElement coincides with a positive counter clockwise direction of the cell, and -1 otherwise. | |
MatrixXd | G1 |
Matrix with G values, used to calculate \(q_0\). | |
MatrixXd | G2 |
Matrix with G values, used to calculate \(q_0\). | |
VectorXd | q0 |
Vector of shear flow in the middle of each element. | |
std::vector< LineElement * > | elements |
List of all elements in mesh. | |
std::vector< Node > | nodes |
List of all nodes in mesh. | |
std::vector< std::vector< LineElement * > > | cycles |
2d vector containing all cycles in the cross-section | |
std::vector< LineElement * > | orderedElements |
List of all elements ordered in a DFS manner. | |
std::vector< std::vector< double > > | midPoints |
Vector containing the middle points of each elements. | |
std::vector< std::vector< std::vector< double > > > | omegaIntersectionPoints |
Three dimensional vector containing intersection points for \( \omega \). More... | |
std::vector< std::vector< std::vector< double > > > | sigmaZIntersectionPoints |
Three dimensional vector containing intersection points for \( \sigma_Z \). More... | |
std::vector< std::vector< bool > > | omegaIntersection |
Two dimensional vector containing boolean values if an element has an intersection of the omega diagram or not. | |
std::vector< double > | extraPoint |
Vector of function values at points along the element, used for display of quadratic functions. The size of the vector is decided by numberOfElementSegments. | |
std::vector< double > | tauIntersect |
Vector containing intersectionpoints of tau. | |
std::vector< std::vector< std::vector< double > > > | tauIntersectionPoints |
Three dimensional vector containing intersection points for . More... | |
std::vector< std::vector< bool > > | sigmaZIntersection |
Two dimensional vector containing boolean values if an element has an intersection or not. More... | |
Contains mesh data for thin-wall analysis. Performs stress analysis on this mesh.
void LineMesh::addElementPoints | ( | VectorXd | f_d, |
int | type | ||
) |
Adds points along the element used for visualization of quadratic stress distributions.
f_d | vector used to find shear flow |
type | type of load applied to cross-section |
void LineMesh::calculateAnglePrincipalAxes | ( | ) |
Calculates angle of the principal axes. Then forced to be less than 45 and greater than -45 .
\( t = \frac{EI_{x}- EI_{max}}{EI_{xy}} \)
\( \alpha = \arctan(t)\frac{180}{\pi} \)
\( \alpha_{rad} = \alpha \times \frac{\pi}{180} \)
void LineMesh::calculateAxialStress | ( | ) |
Calculates the resulting axial stress \( \sigma_z \) for all nodes in the cross-section, as well as axial stress due to \(N, M_x, M_y and B\).
\( \begin{bmatrix} \frac{N}{EA} + \frac{M_x}{EI_x}y - \frac{M_y}{EI_y}x - \frac{B}{EI_\omega}\omega \end{bmatrix} \)
void LineMesh::calculateG1Matrix | ( | ) |
Calculates G1 matrix.
\( \textbf{G}_1 = \begin{bmatrix} \sum_{n_{i}} E_k t_k \frac{\Delta l_k}{2}\textbf{C}_{0k}^T - \sum_{n_{i}} \eta_k E_k t_k \frac{\Delta l_k}{8}\boldsymbol{\Delta}\textbf{C}_k^T \end{bmatrix} \textbf{D} \)
void LineMesh::calculateG2Matrix | ( | ) |
Calculates G2 matrix.
\( \textbf{G}_2 = - \begin{bmatrix} \sum_{n_{r}} \eta_k \frac{E_k \Delta l_k^2}{24G_k}\boldsymbol{\Delta}\textbf{C}_k^T \end{bmatrix} \textbf{D} \)
void LineMesh::calculateKappaX | ( | ) |
Calculates shear deformation factor \(\kappa_x\).
\( \kappa_x = (GA)\sum_k \begin{bmatrix} \left (\frac{\Delta x_k}{\Delta L_k} \right)^2 \frac{t_k}{G_k} \int _{s_k} (\tau^2 |_{V_x = 1}) ds \end{bmatrix} \)
void LineMesh::calculateKappaY | ( | ) |
Calculates shear deformation factor \( \kappa_y \).
\( \kappa_y = (GA)\sum_k \begin{bmatrix} \left (\frac{\Delta y_k}{\Delta L_k} \right)^2 \frac{t_k}{G_k} \int _{s_k} (\tau^2 |_{V_y = 1}) ds \end{bmatrix} \)
void LineMesh::calculateMeshProperties | ( | ) |
Calculates mesh properties.
The function is run by constructor. It runs through all elements calculating element areas and element centres for each element.
It also calculates total area of mesh, and area centre of the mesh using
\( A_x = \sum{( \frac{dx_e*a_e}{A}) } \) and \( A_y = \sum{ (\frac{dy_e*a_e}{A}) } \)
void LineMesh::calculateNodalTau | ( | VectorXd | f_d, |
int | type | ||
) |
Calculates tau values for the nodes.
f_d | vector used to find shear flow |
type | type of load applied to cross-section |
void LineMesh::calculateOmega_c | ( | ) |
Calculates \( \omega_c \) for all the elements.
Assigns \( \omega_{c,1} \) = 0 to point number one. The rest of the \( \omega_c \) values are then calculated from \( \Delta \omega_c = \omega_{c,2} - \omega_{c,1} \), where \( \Delta \omega_c \) is found in advance and \(\omega_{c,1} , \omega_{c,2} \) are the values for node 1 and 2 in the element. To ensure that the calculation always have two known values, the elements are traversed in a DFS fashion.
void LineMesh::calculateOmegaIntersection | ( | int | type, |
std::vector< std::vector< std::vector< double >>> * | intersectionPoints, | ||
std::vector< std::vector< bool >> * | intersection | ||
) |
Iterates through all elements and finds sigma_Z intersection values for omega diagrams if they exist.
type | describes the type of force applied to the cross section |
*intersectionPoints | a 3d vector of doubles containing intersection points |
*intersection | a 2d vector containing boolean values if an element has an intersection point |
void LineMesh::calculatePrincipalMomentOfAreas | ( | ) |
Calculates the principal moment of areas \(I_{xp}\) and \(I_{yp}\).
\( I_{ xp } = \frac{EI_{xp}}{E_b} \) , \( I_{ yp } = \frac{EI_{yp}}{E_b} \)
void LineMesh::calculatePureStvTorsionStress | ( | ) |
Calculates the pure St.Venants torsion stress.
\( q_{k,stv} = \frac{2 T_{stv} \tilde{q}_k}{GI_t} \)
void LineMesh::calculateQ0 | ( | VectorXd | f_d, |
int | type | ||
) |
Calculates \(q_0\).
by solving the equation \( \begin{bmatrix} \textbf{A}_1 \\ \textbf{A}_2 \end{bmatrix} \textbf{q}_0 = \begin{bmatrix} \textbf{G}_1 \\ \textbf{G}_2 \end{bmatrix} \textbf{f'} \)
To solve the equation Eigen's ColPivHouseholderQR solver is used
f_d | Vector used in calculation of \(q_0\) |
type | of force applied |
double LineMesh::calculateQs | ( | double | s, |
LineElement * | element, | ||
VectorXd | f_d, | ||
int | type | ||
) |
Calculates the shear value at a distance s along the element.
s | position along the element, goes from -1 to 1 |
element | the element in question |
f_d | vector used in calculation of q |
type | type of force applied to cross-section |
void LineMesh::calculateSigmaZIntersection | ( | int | type, |
std::vector< std::vector< std::vector< double >>> * | intersectionPoints, | ||
std::vector< std::vector< bool >> * | intersection | ||
) |
Iterates through all elements and finds \( \omega \) intersection values if they exist.
type | describes the type of force applied to the cross section |
*intersectionPoints | a 3d vector of doubles containing intersection points |
*intersection | a 2d vector containing boolean values if an element has an intersection point |
void LineMesh::calculateStVenantStiffness | ( | CycleDetection | c | ) |
Calculates the St.Venant stiffness \( GI_t \).
\( GI_t = 4 \boldsymbol{p}^T \boldsymbol{a} + \frac{1}{3} \sum\limits_{k=1}^{n_f} G_k t_k^3 \Delta l_k \) where \( n_f \) is the number of open elements
c | cycle detection object, needed to get all the open elements of the cross-section |
void LineMesh::calculateTau | ( | VectorXd | f_d, |
int | type | ||
) |
Calculates \(\tau\) for different applied loads.
f_d | vector used in calculation of tau |
type | type of force applied to cross-section |
double LineMesh::calculateVonMisesStress | ( | LineElement * | element, |
int | j | ||
) |
Calculates von mises stress.
\( \sigma_y = \sqrt{\sigma_z^2 + 3 \tau^2} \)
void LineMesh::constructAVector | ( | CycleDetection | c | ) |
Constructs area vector \(\boldsymbol{a}\).
This method constructs the a vector that is used to solve for shear flows. The vector consists of the areas of all the cells in the cross-section
c | CycleDetection object |
void LineMesh::constructBMatrix | ( | ) |
Constructs coefficiant matrix \( \textbf{B} \).
This method constructs the \( \textbf{B} \) matrix that is used to solve for shear flows. The diagonal is found by taking \( B_{rr} = \sum_{k=1}^{n_{rr}}\frac{\Delta l_k}{G_k t_k} \) where \( n_{rr} \) is all the elements of cell r. The off diagonals are found by \( B_{rs} = - \sum_{k=1}^{n_{rs}}\frac{\Delta l_k}{G_k t_k} \) where \( n_{rs} \) is the number of common elements of cells r and s. If there are no common elements, the corrosponding coefficiant is 0.
bool LineMesh::contains | ( | std::vector< int > | a, |
int | b | ||
) |
Checks wether a vector of ints contains a certain int, could be placed in a UTILS class.
a | vector of ints |
b | int |
void LineMesh::createA1Matrix | ( | ) |
Creates A1 matrix.
The matrix dimensions are [nrOfNodes x nrOfElements]. \( %eta \) is +1 if the LineElement direction is away from the node, and -1 if the direction is towards the node.
void LineMesh::createA2Matrix | ( | ) |
Creates A2 matrix.
The matrix dimensions are [nrOfCells x nrOfElements]. \( %eta \) is +1 if the LineElement coincides with a positive counter clockwise direction of the cell, and -1 otherwise.
std::vector< LineElement * > LineMesh::DFS | ( | ) |
Creates a vector of LineElement pointers that are sorted in a DFS fashion, could be extracted to a UTILS class.
std::vector< LineElement * > LineMesh::findCommonElements | ( | std::vector< LineElement * > | a, |
std::vector< LineElement * > | b | ||
) |
Finds common elements in two vectors, could be moved to a UTILS class.
a | vector one |
b | vector two |
void LineMesh::findElementIntersections | ( | VectorXd | f_d, |
int | type | ||
) |
Finds the element intersection points for quadratic functions along the element.
f_d | vector used to find shear flow |
type | type of load applied to cross-section |
void LineMesh::initializeMatrices | ( | ) |
Initializes matrices.
\( f' = \begin{bmatrix} 0 & -V_y & -V_x & -T_{wrp} \end{bmatrix} \)
\( f'_{V_y} = \begin{bmatrix} 0 & V_y & 0 & 0 \end{bmatrix} \)
\( f'_{V_x} = \begin{bmatrix} 0 & 0 & -V_x & 0 \end{bmatrix} \)
\( f'_{wrp} = \begin{bmatrix} 0 & 0 & 0 & -T_{wrp} \end{bmatrix} \)
\( \textbf{D} = \begin{bmatrix} \frac{1}{EA} & 0 & 0 & 0\\ 0& \frac{1}{EI_x} & 0 & 0\\ 0 &0 & \frac{1}{EI_y} & 0\\ 0 & 0 & 0 & \frac{1}{EI_{\omega}} \end{bmatrix} \)
void LineMesh::initiateCVectors | ( | ) |
Initializes the C vectors for each element.
\( \textbf{c}_0^T = \begin{bmatrix} 1 & y_0 & x_0 & \omega_0 \end{bmatrix} \)
\( \boldsymbol{\Delta}\textbf{c}_0^T = \begin{bmatrix} 0 & \Delta y & \Delta x & \Delta \omega \end{bmatrix} \)
void LineMesh::printEigenMatrix | ( | MatrixXd | A, |
std::string | s | ||
) |
prints out a matrix on Eigen format
A | Eigen matrix |
s | Name of the matrix |
void LineMesh::solveSystemEquation | ( | ) |
Solves the system of equations.
This method solves the system of equations /f$ {B} {p} = {a} /f$, where the shear flows /f$ {p} /f$ are unknowns, /f$ {a} /f$ are the cell areas, and /f$ {B} /f$ is a coefficiant matrix
void LineMesh::transformCoordinates | ( | ) |
Transforms coordinates for computation purposes.
\( x' = (x-A_x)cos(\alpha) + (y-A_y)sin(\alpha) \)
\( y' = (y-A_y)cos(\alpha) - (x-A_x)sin(\alpha) \)
MatrixXd LineMesh::D |
D matrix.
\( \textbf{D} = \begin{bmatrix} \frac{1}{EA} & 0 & 0 & 0\\ 0& \frac{1}{EI_x} & 0 & 0\\ 0 &0 & \frac{1}{EI_y} & 0\\ 0 & 0 & 0 & \frac{1}{EI_{\omega}} \end{bmatrix} \)
std::vector<std::vector<std::vector<double> > > LineMesh::omegaIntersectionPoints |
Three dimensional vector containing intersection points for \( \omega \).
The three dimensional vector is formatted in the following way:
Intersection points = \( \begin{bmatrix} \omega\\ \end{bmatrix} = \begin{bmatrix} (x_1, y_1) & (x_2, y_2) & ... & (x_n, y_n)) \\ \end{bmatrix} \)
std::vector<std::vector<bool> > LineMesh::sigmaZIntersection |
Two dimensional vector containing boolean values if an element has an intersection or not.
The two dimensional vector is formatted in the following way:
\( \begin{bmatrix} \sigma_{z,N}\\ \sigma_{z,Mx}\\ \sigma_{z,My}\\ \sigma_{z,B}\\ \sigma_{z,Resulting} \end{bmatrix} = \begin{bmatrix} false & true & ... & true \\ true & true & ... & true \\ false & false & ... & false \\ flase & false & ... & true \\ false & false & ... & false \\ \end{bmatrix} \)
std::vector<std::vector<std::vector<double> > > LineMesh::sigmaZIntersectionPoints |
Three dimensional vector containing intersection points for \( \sigma_Z \).
The three dimensional vector is formatted in the following way:
Intersection points = \( \begin{bmatrix} \sigma_{z,N}\\ \sigma_{z,Mx}\\ \sigma_{z,My}\\ \sigma_{z,B}\\ \sigma_{z,Resulting} \end{bmatrix} = \begin{bmatrix} (x_1, y_1) & (x_2, y_2) & ... & (x_n, y_n)) \\ (x_1, y_1) & (x_2, y_2) & ... & (x_n, y_n)) \\ (x_1, y_1) & (x_2, y_2) & ... & (x_n, y_n)) \\ (x_1, y_1) & (x_2, y_2) & ... & (x_n, y_n)) \\ (x_1, y_1) & (x_2, y_2) & ... & (x_n, y_n)) \\ \end{bmatrix} \)
std::vector<std::vector<std::vector<double> > > LineMesh::tauIntersectionPoints |
Three dimensional vector containing intersection points for .
The three dimensional vector is formatted in the following way:
Intersection points = \( \begin{bmatrix} \tau_{V_x}\\ \tau_{V_y}\\ \tau_{T_{wrp}}\\ \tau_{resulting}\\ \tau_{T_{stv}} \end{bmatrix} = \begin{bmatrix} (x_1, y_1) & (x_2, y_2) & ... & (x_n, y_n)) \\ (x_1, y_1) & (x_2, y_2) & ... & (x_n, y_n)) \\ (x_1, y_1) & (x_2, y_2) & ... & (x_n, y_n)) \\ (x_1, y_1) & (x_2, y_2) & ... & (x_n, y_n)) \\ (x_1, y_1) & (x_2, y_2) & ... & (x_n, y_n)) \\ \end{bmatrix} \)