My Project
|
Contains mesh data and has function to calculate and retrieve mesh properties. More...
#include <LineMesh.h>
Public Member Functions | |
LineMesh (std::string fileName) | |
Constructor for the LineMeshClass. | |
void | transformCoordinates () |
Transforms coordinates for computation purposes. More... | |
void | calculatePrincipalMomentOfAreas () |
Calculates the principal moment of areas EIxp and EIyp. | |
void | calculateAreaStiffness () |
Calculates the area stiffness. | |
void | printCoordinates () |
Prints node coordinates. | |
void | calculateMeshProperties () |
Calculates mesh properties. More... | |
void | calculateBendingStiffness () |
Calculates seccond area moments. More... | |
void | calculateAnglePrincipalAxes () |
Calculates angle of the principal axes. More... | |
void | printCellAreas () |
Prints cell areas. | |
void | printCells () |
Prints each cell, and it's elements. | |
void | constructBMatrix () |
Constructs coefficiant matrix \( \textbf{B} \). More... | |
void | constructAVector (CycleDetection c) |
Constructs area vector 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 | calculateSigmaXIntersection (int type, std::vector< std::vector< std::vector< double >>> *intersectionPoints, std::vector< std::vector< bool >> *intersection) |
Iterates through all elements and finds /f$ /f$ 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_x 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_x \) for all nodes in the cross-section, as well as axial stress due to N, Mx, My 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 functions. 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 q0. 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_x as well as omega. | |
void | calculateKappaX () |
Calculates shear deformation factor x. More... | |
void | calculateKappaY () |
Calculates shear deformation factor 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 Vx. | |
int | TAU_DUE_TO_VY = 1 |
Int corrosponding to tau due to Vy. | |
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_X_DUE_TO_N = 0 |
Int corrosponding to sigma_x due to N. | |
int | SIGMA_X_DUE_TO_MX = 1 |
Int corrosponding to sigma_x due to Mx. | |
int | SIGMA_X_DUE_TO_MY = 2 |
Int corrosponding to sigma_x due to My. | |
int | SIGMA_X_DUE_TO_B = 3 |
Int corrosponding to sigma_x due to B. | |
int | SIGMA_X_RESULTING = 4 |
Int corrosponding to resulting sigma_x. | |
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 |
double | Ay |
Area centre for mesh in X- and Y-direction. | |
double | EA |
Axial stiffness. | |
double | EIx |
double | EIy |
double | EIxy |
double | EImax |
Bending stiffness about global x- and y-axes. | |
double | EIxp |
double | EIyp |
Bending stiffness about principal x- and y-axes. | |
double | Sx |
double | Sy |
TODO. | |
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 | warpingStiffness |
Warping stiffness EI_. | |
double | kappaX |
Shear deformation factor x. | |
double | kappaY |
Shear deformation factor y. | |
double | baseE = 210000 |
Young's modulus of base material. | |
double | baseG = 80770 |
Shear modulus of base material. | |
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. | |
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 \( f' = \begin{bmatrix} 0 & Vy & -Vx & -T_{wrp} \end{bmatrix} \). | |
VectorXd | f_d_Vx |
Vector containing input forces and moments \( f'_{Vx} = \begin{bmatrix} 0 & 0 & -Vx & 0 \end{bmatrix} \). | |
VectorXd | f_d_Vy |
Vector containing input forces and moments \( f'_{Vy} = \begin{bmatrix} 0 & Vy & 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 x 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 x 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 > > > | sigmaXIntersectionPoints |
Three dimensional vector containing intersection points for \( \sigma_x \). 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 > > | sigmaXIntersection |
Two dimensional vector containing boolean values if an element has an intersection or not. More... | |
Contains mesh data and has function to calculate and retrieve mesh properties.
void LineMesh::addElementPoints | ( | VectorXd | f_d, |
int | type | ||
) |
Adds points along the element used for visualization of quadratic functions.
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.
\( t = \frac{-2EI_{xy}}{EI_x - EI_y} \)
\( \alpha = \frac{1}{2}\arctan(t)\frac{180}{\pi} \)
void LineMesh::calculateAxialStress | ( | ) |
Calculates the resulting axial stress \( \sigma_x \) for all nodes in the cross-section, as well as axial stress due to N, Mx, My 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::calculateBendingStiffness | ( | ) |
Calculates seccond area moments.
Loops through all elements calculating the distance between mesh- and element area centres, and calculates the second moment of inertia for the mesh's x-, y- and xy-axis.
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 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 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_{c1} \) = 0 to point number one. The rest of the \( \omega_c \) values are then calculated from \( \Delta \omega_c = \omega_{c2} - \omega_{c1} \), where \( \Delta \omega_c \) is found in advance and \(\omega_{c1} , \omega_{c2} \) 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_x 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::calculatePureStvTorsionStress | ( | ) |
Calculates the pure St.Venants torsion stress.
q_{k,stv} = {2 T_{stv} {q}_k}{GI_t}
void LineMesh::calculateQ0 | ( | VectorXd | f_d, |
int | type | ||
) |
Calculates q0.
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 q0 |
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::calculateSigmaXIntersection | ( | int | type, |
std::vector< std::vector< std::vector< double >>> * | intersectionPoints, | ||
std::vector< std::vector< bool >> * | intersection | ||
) |
Iterates through all elements and finds /f$ /f$ 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_x^2 + 3 \tau^2} \)
void LineMesh::constructAVector | ( | CycleDetection | c | ) |
Constructs area vector 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 & Vy & -Vx & -T_{wrp} \end{bmatrix} f'_{Vy} = \begin{bmatrix} 0 & Vy & 0 & 0 \end{bmatrix} f'_{Vx} = \begin{bmatrix} 0 & 0 & -Vx & 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) \)
\( x' = (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::sigmaXIntersection |
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_{x,N}\\ \sigma_{x,Mx}\\ \sigma_{x,My}\\ \sigma_{x,B}\\ \sigma_{x,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::sigmaXIntersectionPoints |
Three dimensional vector containing intersection points for \( \sigma_x \).
The three dimensional vector is formatted in the following way:
Intersection points = \( \begin{bmatrix} \sigma_{x,N}\\ \sigma_{x,Mx}\\ \sigma_{x,My}\\ \sigma_{x,B}\\ \sigma_{x,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_{Vx}\\ \tau_{Vy}\\ \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} \)