Public Member Functions | Public Attributes | List of all members
LineMesh Class Reference

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< Nodenodes
 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...
 

Detailed Description

Contains mesh data for thin-wall analysis. Performs stress analysis on this mesh.

Member Function Documentation

void LineMesh::addElementPoints ( VectorXd  f_d,
int  type 
)

Adds points along the element used for visualization of quadratic stress distributions.

Parameters
f_dvector used to find shear flow
typetype 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} \)

Returns
Angle of inertial axis.
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.

Parameters
f_dvector used to find shear flow
typetype 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.

Parameters
typedescribes the type of force applied to the cross section
*intersectionPointsa 3d vector of doubles containing intersection points
*intersectiona 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

Parameters
f_dVector used in calculation of \(q_0\)
typeof 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.

Parameters
sposition along the element, goes from -1 to 1
elementthe element in question
f_dvector used in calculation of q
typetype of force applied to cross-section
Returns
double value of q at a distance s along the element
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.

Parameters
typedescribes the type of force applied to the cross section
*intersectionPointsa 3d vector of doubles containing intersection points
*intersectiona 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

Parameters
ccycle 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.

Parameters
f_dvector used in calculation of tau
typetype 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} \)

Returns
von Mises stress ( \(\sigma_y\))
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

Parameters
cCycleDetection 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.

Parameters
avector of ints
bint
Returns
true if vector a contains int b, false if not
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.

Returns
vector of LineElements ordered after their appearence in DFS search
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.

Parameters
avector one
bvector two
Returns
vector of common elements in list a and b
void LineMesh::findElementIntersections ( VectorXd  f_d,
int  type 
)

Finds the element intersection points for quadratic functions along the element.

Parameters
f_dvector used to find shear flow
typetype 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

Parameters
AEigen matrix
sName 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) \)

Member Data Documentation

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} \)


The documentation for this class was generated from the following files: