Sanders-type cylinder element (`bfsccylinder.bfsccylinder_sanders`)#

Sanders-type cylinder element (bfsccylinder.bfsccylinder_sanders)

The module provides the single-curvature BFSC element with Sanders-type kinematics, the class BFSCCylinderSanders, and the functions update_KC0(), update_KCNL(), update_KG(), update_KG_constant_stress() and update_M(), that write the contributions of one element to the linear constitutive stiffness matrix KC0, the nonlinear stiffness matrix KCNL, the sum of the nonlinear constitutive and geometric stiffness matrices \(\boldsymbol{K}_{CNL} + \boldsymbol{K}_{GNL}\), the geometric stiffness matrix KG and the mass matrix M in sparse row, column and value arrays, starting at the positions given by its init_k_* attributes, and update_fint(), that adds its internal forces to a global internal force vector. For a pressure that follows the deformation of the shell, update_fext_follower() adds the force vector of one element to a global external force vector and update_KCfollower() writes its load stiffness matrix KCfollower in sparse arrays, see the Notes. The row, column and value arrays of the elements can be gathered in a sparse matrix of coordinate format, e.g. with scipy.sparse.coo_matrix, which sums the values at repeated positions.

Each of the four nodes has DOF = 10 degrees of freedom, in the order \(u\), \(u_{,x}\), \(u_{,y}\), \(v\), \(v_{,x}\), \(v_{,y}\), \(w\), \(w_{,x}\), \(w_{,y}\), \(w_{,xy}\), where \(x\) is the axial and \(y\) the circumferential coordinate, and \(u\), \(v\) and \(w\) are the axial, circumferential and normal displacements. Element vectors of size 4*DOF = 40 have the degrees of freedom of nodes 1, 2, 3 and 4 in sequence.

The module also defines:

KC0_SPARSE_SIZE = 1600, KCNL_SPARSE_SIZE = 1456, KG_SPARSE_SIZE = 784, M_SPARSE_SIZE = 920 and KCfollower_SPARSE_SIZE = 1456: number of entries that one element writes in the row, column and value arrays of KC0, KCNL, KG, M and KCfollower. For n elements the arrays need n times these sizes;
DOUBLE = np.float64: NumPy type of the arrays of values.

The module bfsccylinder.bfsccylinder has the same contents for the element with Donnell-type kinematics. Compared with it, the curvatures given by BFSCCylinderSanders.update_Bb() and used in the matrices and in the internal forces also depend on the \(u\) and \(v\) degrees of freedom, with terms divided by R; KG also has the entries of the \(v\) degrees of freedom (784 instead of 256 entries), and KCNL also the entries that couple the \(v\) degrees of freedom with themselves and with the \(u\) degrees of freedom (1456 instead of 1024 entries), M also the entries that couple the \(v\) and \(w\) degrees of freedom (920 instead of 544 entries), and KCfollower also the entries of the \(v\) degrees of freedom with themselves (1456 instead of 1312 entries).

Notes#

The element is the one of the Notes of bfsccylinder.bfsccylinder, with the same geometry, interpolation, constitutive relation, strain energy, decomposition of the tangent stiffness matrix and quadrature; the statements made there on the number of integration points nint hold for this element too. Only the kinematics differ, and with them the rotary inertia of the mass matrix. Their linear part is the one of the thin shell theory of Sanders [1] and Koiter [2], with \(w\) positive outwards: the linear membrane strains \(\boldsymbol{\varepsilon}_L = \boldsymbol{B}_m\boldsymbol{u}_e\) are those of the Donnell-type kinematics, and the curvatures also have terms of \(u\) and \(v\) divided by \(R\):

\[\begin{split}\boldsymbol{\kappa} = \begin{Bmatrix} \kappa_{xx} \\ \kappa_{yy} \\ \kappa_{xy} \end{Bmatrix} = \begin{Bmatrix} -w_{,xx} \\ -w_{,yy} + v_{,y}/R \\ -2 w_{,xy} + \frac{3}{2R} v_{,x} - \frac{1}{2R} u_{,y} \end{Bmatrix} = \boldsymbol{B}_b\boldsymbol{u}_e\end{split}\]

with \(\boldsymbol{B}_b\) the rows Bb of BFSCCylinderSanders.update_Bb(). With the rotations \(\beta_x = -w_{,x}\) and \(\beta_y = -w_{,y} + v/R\), the nonlinear membrane strains are those of Sanders [3],

\[\begin{split}\boldsymbol{\varepsilon}_{NL} = \begin{Bmatrix} \beta_x^2/2 \\ \beta_y^2/2 \\ \beta_x \beta_y \end{Bmatrix} = \begin{Bmatrix} w_{,x}^2/2 \\ (w_{,y} - v/R)^2/2 \\ w_{,x} (w_{,y} - v/R) \end{Bmatrix} = \frac{1}{2} \boldsymbol{B}_{NL}\boldsymbol{u}_e\end{split}\]

\[\begin{split}\boldsymbol{B}_{NL} = \begin{bmatrix} w_{,x} \boldsymbol{S}^w_{,x} \\ (w_{,y} - v/R) \left( \boldsymbol{S}^w_{,y} - \boldsymbol{S}^v/R \right) \\ w_{,x} \left( \boldsymbol{S}^w_{,y} - \boldsymbol{S}^v/R \right) + (w_{,y} - v/R) \boldsymbol{S}^w_{,x} \end{bmatrix}, \qquad \boldsymbol{G} = \begin{bmatrix} \boldsymbol{S}^w_{,x} \\ \boldsymbol{S}^w_{,y} - \boldsymbol{S}^v/R \end{bmatrix}\end{split}\]

where \(v\), \(w_{,x}\) and \(w_{,y}\) are v, w_x and w_y of the current displacements in update_KCNL() and update_fint(), the rows of \(\boldsymbol{B}_{NL}\) are BmL1, BmL2 and BmL3 and those of \(\boldsymbol{G}\) are G1 and G2, such that \(\delta\boldsymbol{\varepsilon}_{NL} = \boldsymbol{B}_{NL}\delta \boldsymbol{u}_e\) and \(\boldsymbol{G}\boldsymbol{u}_e = \{w_{,x}, w_{,y} - v/R\}^\top = -\{\beta_x, \beta_y\}^\top\). Only the rotations \(\beta_x\) and \(\beta_y\) of the normal enter the nonlinear membrane strains; the rotation about the normal, \((v_{,x} - u_{,y}/R)/2\), enters only the linear twist \(\kappa_{xy}\).

With the terms in \(1/R\), the strains and the curvatures vanish for the small rigid-body translation \(w = c \cos(y/R)\), \(v = -c \sin(y/R)\), for which the Donnell-type curvatures do not, and the linear part is not restricted to displacements that vary over lengths small compared with \(R\). Because of the term \(-\boldsymbol{S}^v/R\) of \(\boldsymbol{G}\), KG, the matrix of update_KG_constant_stress() and KCNL also have entries at the degrees of freedom of \(v\). The rotary inertia of the mass matrix of update_M() uses the rotations \(\beta_x = -w_{,x}\) and \(\beta_y = -w_{,y} + v/R\), such that M also couples \(v\) and \(w\).

The follower pressure of update_fext_follower() and update_KCfollower() is that of the Notes of bfsccylinder.bfsccylinder, with the Sanders-type rotation \(\beta_y = -w_{,y} + v/R\): the tangent vector \(\boldsymbol{X}_{,y}\) of the deformed mid-surface has the component \(w_{,y} - v/R\) along the normal, such that \(\boldsymbol{X}_{,x} \times \boldsymbol{X}_{,y}\) is the exact area vector, and \(\boldsymbol{a}_1\) has the term \(v/R\) in its component along \(y\). The skew part of the load stiffness matrix, and the conditions under which it is symmetric, are those of the Donnell-type kinematics, the results of Hibbitt [4] and of Schweizerhof and Ramm [5] for a pressure that depends on the reference coordinates. With a dead pressure, the rigid rotation \(v\) = constant of a ring under the hoop prestress \(N_{yy} = p R\) has the energy \(\int_A N_{yy} (v/R)^2 dA\) in KG, negative under an external pressure, which gives a spurious buckling mode at a vanishing load whenever \(v\) is free; the follower load stiffness adds \(-\int_A p v^2/R \, dA\), which cancels it.

References#

[1]

Sanders, J. L., An improved first-approximation theory for thin shells, NASA Technical Report R-24, 1959.

[2]

Koiter, W. T., A consistent first approximation in the general theory of thin elastic shells, Proceedings of the IUTAM Symposium on the Theory of Thin Elastic Shells, Delft, 1959, North-Holland, Amsterdam, 1960, pp. 12-33.

[3]

Sanders, J. L., Nonlinear theories for thin shells, Quarterly of Applied Mathematics, 21(1), 21-36, 1963, doi:10.1090/qam/147023.

[4]

Hibbitt, H. D., Some follower forces and load stiffness, International Journal for Numerical Methods in Engineering, 14(6), 937-941, 1979, doi:10.1002/nme.1620140613.

[5]

Schweizerhof, K., and Ramm, E., Displacement dependent pressure loads in nonlinear finite element analyses, Computers & Structures, 18(6), 1099-1114, 1984, doi:10.1016/0045-7949(84)90154-8.

class bfsccylinder.bfsccylinder_sanders.BFSCCylinderSanders#

Single-curvature BFSC element with Sanders-type kinematics.

Nodal connectivity for cylindrical shell element similar to Nastran’s CQUAD4:

 ^ y (circumferential direction)
 |

4 ________ 3
 |       |
 |       |   --> x (axial direction)
 |       |
 |_______|
1         2

The constructor sets n1, n2, n3, n4 and c1, c2, c3, c4 to -1, lex, ley, rho, h and R to zero, and allocates every array filled with zeros; the init_k_* positions are zero. Before the functions of this module are called with the element, the caller sets c1, c2, c3, c4, the init_k_* positions of the matrices being computed, lex, ley and R, the stiffnesses A11, ..., D66, e.g. with bfsccylinder.utils.assign_constant_ABD(), and, for update_M(), rho, h and R.

Parameters:

nintint: Number of integration points in each direction: the size of the points and weights arrays later given to the functions of this module, which read the stiffness arrays A11, ..., D66 at the indices [i, j] from 0 to nint - 1.

Attributes:

n1, n2, n3, n4int: Node identification numbers. Not used by the functions of this module.
c1, c2, c3, c4int: Position of the first degree of freedom of nodes 1, 2, 3 and 4 in the global vectors and matrices. The DOF degrees of freedom of node 1 are at the positions c1 to c1 + 9, and likewise for the other nodes, e.g. c1 = DOF*i for the node of index i.
init_k_KC0, init_k_KCNL, init_k_KG, init_k_M, init_k_KCfollowerint: Position in the sparse arrays from which update_KC0(), update_KCNL(), update_KG() or update_KG_constant_stress(), update_M() and update_KCfollower() write the entries of the element, e.g. the index of the element times KC0_SPARSE_SIZE, KCNL_SPARSE_SIZE, KG_SPARSE_SIZE, M_SPARSE_SIZE and KCfollower_SPARSE_SIZE.
lex, leydouble: Length of the element along the axial direction \(x\) and along the circumferential direction \(y\), dimension of length.
rhodouble: Density, mass per unit volume. Used only by update_M().
hdouble: Thickness, dimension of length. Used only by update_M().
Rdouble: Radius of the cylinder, dimension of length. Terms of KC0, KCNL and KG, also of update_KG_constant_stress(), of the internal forces, of the follower pressure, of Bm and of Bb are divided by R, so it must be set to a nonzero value before these are computed. Also used by update_M(), through the term \(v/R\) of the Sanders-type rotation of the normal.
A11, A12, A16, A22, A26, A662-D array: Membrane stiffnesses, force per unit length. Shape (nint, nint), the entry [i, j] being used at the integration point xi = points[i], eta = points[j].
B11, B12, B16, B22, B26, B662-D array: Membrane-bending coupling stiffnesses, dimension of force. Same shape and use as A11.
D11, D12, D16, D22, D26, D662-D array: Bending stiffnesses, force times length. Same shape and use as A11.
Bm2-D array: Shape (3, 40), rows giving the linear membrane strains at the last point given to update_Bm(). Dimension of one over the dimension of each degree of freedom.
Bb2-D array: Shape (3, 40), rows giving the curvatures at the last point given to update_Bb(). Dimension of one over length times one over the dimension of each degree of freedom.
Su, Sv, Sw1-D array: Size 40, rows giving the displacements \(u\), \(v\) and \(w\) at the last point given to update_Su(), update_Sv() and update_Sw().
Su_x, Sv_x, Sw_x1-D array: Size 40, rows giving \(u_{,x}\), \(v_{,x}\) and \(w_{,x}\) at the last point given to update_Su_x(), update_Sv_x() and update_Sw_x().
Su_y, Sv_y, Sw_y1-D array: Size 40, rows giving \(u_{,y}\), \(v_{,y}\) and \(w_{,y}\) at the last point given to update_Su_y(), update_Sv_y() and update_Sw_y().
u1-D array: Size 40, element displacement vector, copied from the global displacement vector by update_KCNL(), update_KG() and update_fint(). Dimension of length for \(u\), \(v\), \(w\), dimensionless for the first derivatives and of one over length for \(w_{,xy}\).

Notes

The attributes have the meaning given in the Notes of bfsccylinder.bfsccylinder.BFSCCylinder, with Bb the operator of the Sanders-type curvatures of the Notes of bfsccylinder.bfsccylinder_sanders.

update_Bb(xi, eta)#

Update Bb at a natural coordinate point

The rows of Bb are computed at xi, eta from lex, ley and R. Their products with an element displacement vector, e.g. u, give at that point the curvatures \(\kappa_{xx}\), \(\kappa_{yy}\) and \(\kappa_{xy}\) for the rows 0, 1 and 2, dimension of one over length. Only the entries that are not identically zero are written, the other entries keep the zeros of the constructor: the row 0 has entries at the degrees of freedom \(w\), \(w_{,x}\), \(w_{,y}\), \(w_{,xy}\) of the nodes, the row 1 also at \(v\), \(v_{,x}\), \(v_{,y}\), divided by R, and the row 2 also at \(u\), \(u_{,x}\), \(u_{,y}\) and \(v\), \(v_{,x}\), \(v_{,y}\), divided by R. The functions of this module do not read Bb.

Parameters:

xi, etadouble: Natural coordinates of the point, dimensionless, from -1 to 1 over the element, xi along \(x\) and eta along \(y\).

Notes

With the rows of the interpolation of the Notes of bfsccylinder.bfsccylinder, the rows of the Sanders-type curvatures of the Notes of bfsccylinder.bfsccylinder_sanders are

\[\begin{split}\boldsymbol{B}_b = \begin{bmatrix} -\boldsymbol{S}^w_{,xx} \\ -\boldsymbol{S}^w_{,yy} + \boldsymbol{S}^v_{,y}/R \\ -2 \boldsymbol{S}^w_{,xy} + \frac{3}{2R} \boldsymbol{S}^v_{,x} - \frac{1}{2R} \boldsymbol{S}^u_{,y} \end{bmatrix}\end{split}\]

those of bfsccylinder.bfsccylinder.BFSCCylinder.update_Bb() plus the terms in \(1/R\).

update_Bm(xi, eta)#

Update Bm at a natural coordinate point

The rows of Bm are computed at xi, eta from lex, ley and R. Their products with an element displacement vector, e.g. u, give at that point the linear membrane strains \(\varepsilon_{xx}\), \(\varepsilon_{yy}\) and \(\gamma_{xy}\) for the rows 0, 1 and 2, dimensionless. Only the entries that are not identically zero are written, the other entries keep the zeros of the constructor. The functions of this module do not read Bm.

Parameters:

xi, etadouble: Natural coordinates of the point, dimensionless, from -1 to 1 over the element, xi along \(x\) and eta along \(y\).

Notes

The rows are the same as those of the Donnell-type kinematics, see the Notes of bfsccylinder.bfsccylinder.BFSCCylinder.update_Bm().

update_Su(xi, eta)#

Update Su at a natural coordinate point

Su is computed at xi, eta from lex and ley. Its product with an element displacement vector, e.g. u, gives the displacement \(u\) at that point, dimension of length. Only the entries at the degrees of freedom \(u\), \(u_{,x}\), \(u_{,y}\) of the nodes, the positions 0, 1, 2 plus 0, 10, 20 and 30, are written, the other entries keep the zeros of the constructor.

Parameters:

xi, etadouble: Natural coordinates of the point, dimensionless, from -1 to 1 over the element, xi along \(x\) and eta along \(y\).

Notes

The entries of node i, from 1 to 4, at the positions 10*(i - 1) + 0, 10*(i - 1) + 1 and 10*(i - 1) + 2, are the Hermite functions \(H_i\), \(H_{xi}\) and \(H_{yi}\) of the Notes of bfsccylinder.bfsccylinder evaluated at xi, eta, such that \(u = \boldsymbol{S}^u\boldsymbol{u}_e\).

update_Su_x(xi, eta)#

Update Su_x at a natural coordinate point

Su_x is computed at xi, eta from lex and ley. Its product with an element displacement vector, e.g. u, gives the derivative \(u_{,x}\) at that point, dimensionless. Only the entries at the degrees of freedom \(u\), \(u_{,x}\), \(u_{,y}\) of the nodes, the positions 0, 1, 2 plus 0, 10, 20 and 30, are written, the other entries keep the zeros of the constructor.

Parameters:

xi, etadouble: Natural coordinates of the point, dimensionless, from -1 to 1 over the element, xi along \(x\) and eta along \(y\).

Notes

The entries are the derivatives \(\partial/\partial x = (2/l_{ex}) \partial/\partial \xi\) of those of BFSCCylinderSanders.update_Su(), with the Hermite functions of the Notes of bfsccylinder.bfsccylinder.

update_Su_y(xi, eta)#

Update Su_y at a natural coordinate point

Su_y is computed at xi, eta from lex and ley. Its product with an element displacement vector, e.g. u, gives the derivative \(u_{,y}\) at that point, dimensionless. Only the entries at the degrees of freedom \(u\), \(u_{,x}\), \(u_{,y}\) of the nodes, the positions 0, 1, 2 plus 0, 10, 20 and 30, are written, the other entries keep the zeros of the constructor.

Parameters:

xi, etadouble: Natural coordinates of the point, dimensionless, from -1 to 1 over the element, xi along \(x\) and eta along \(y\).

Notes

The entries are the derivatives \(\partial/\partial y = (2/l_{ey}) \partial/\partial \eta\) of those of BFSCCylinderSanders.update_Su(), with the Hermite functions of the Notes of bfsccylinder.bfsccylinder.

update_Sv(xi, eta)#

Update Sv at a natural coordinate point

Sv is computed at xi, eta from lex and ley. Its product with an element displacement vector, e.g. u, gives the displacement \(v\) at that point, dimension of length. Only the entries at the degrees of freedom \(v\), \(v_{,x}\), \(v_{,y}\) of the nodes, the positions 3, 4, 5 plus 0, 10, 20 and 30, are written, the other entries keep the zeros of the constructor.

Parameters:

xi, etadouble: Natural coordinates of the point, dimensionless, from -1 to 1 over the element, xi along \(x\) and eta along \(y\).

Notes

The entries of node i, from 1 to 4, at the positions 10*(i - 1) + 3, 10*(i - 1) + 4 and 10*(i - 1) + 5, are the Hermite functions \(H_i\), \(H_{xi}\) and \(H_{yi}\) of the Notes of bfsccylinder.bfsccylinder evaluated at xi, eta, such that \(v = \boldsymbol{S}^v\boldsymbol{u}_e\).

update_Sv_x(xi, eta)#

Update Sv_x at a natural coordinate point

Sv_x is computed at xi, eta from lex and ley. Its product with an element displacement vector, e.g. u, gives the derivative \(v_{,x}\) at that point, dimensionless. Only the entries at the degrees of freedom \(v\), \(v_{,x}\), \(v_{,y}\) of the nodes, the positions 3, 4, 5 plus 0, 10, 20 and 30, are written, the other entries keep the zeros of the constructor.

Parameters:

xi, etadouble: Natural coordinates of the point, dimensionless, from -1 to 1 over the element, xi along \(x\) and eta along \(y\).

Notes

The entries are the derivatives \(\partial/\partial x = (2/l_{ex}) \partial/\partial \xi\) of those of BFSCCylinderSanders.update_Sv(), with the Hermite functions of the Notes of bfsccylinder.bfsccylinder.

update_Sv_y(xi, eta)#

Update Sv_y at a natural coordinate point

Sv_y is computed at xi, eta from lex and ley. Its product with an element displacement vector, e.g. u, gives the derivative \(v_{,y}\) at that point, dimensionless. Only the entries at the degrees of freedom \(v\), \(v_{,x}\), \(v_{,y}\) of the nodes, the positions 3, 4, 5 plus 0, 10, 20 and 30, are written, the other entries keep the zeros of the constructor.

Parameters:

xi, etadouble: Natural coordinates of the point, dimensionless, from -1 to 1 over the element, xi along \(x\) and eta along \(y\).

Notes

The entries are the derivatives \(\partial/\partial y = (2/l_{ey}) \partial/\partial \eta\) of those of BFSCCylinderSanders.update_Sv(), with the Hermite functions of the Notes of bfsccylinder.bfsccylinder.

update_Sw(xi, eta)#

Update Sw at a natural coordinate point

Sw is computed at xi, eta from lex and ley. Its product with an element displacement vector, e.g. u, gives the displacement \(w\) at that point, dimension of length. Only the entries at the degrees of freedom \(w\), \(w_{,x}\), \(w_{,y}\), \(w_{,xy}\) of the nodes, the positions 6, 7, 8, 9 plus 0, 10, 20 and 30, are written, the other entries keep the zeros of the constructor.

Parameters:

xi, etadouble: Natural coordinates of the point, dimensionless, from -1 to 1 over the element, xi along \(x\) and eta along \(y\).

Notes

The entries of node i, from 1 to 4, at the positions 10*(i - 1) + 6 to 10*(i - 1) + 9, are the Hermite functions \(H_i\), \(H_{xi}\), \(H_{yi}\) and \(H_{xyi}\) of the Notes of bfsccylinder.bfsccylinder evaluated at xi, eta, such that \(w = \boldsymbol{S}^w\boldsymbol{u}_e\).

update_Sw_x(xi, eta)#

Update Sw_x at a natural coordinate point

Sw_x is computed at xi, eta from lex and ley. Its product with an element displacement vector, e.g. u, gives the derivative \(w_{,x}\) at that point, dimensionless. Only the entries at the degrees of freedom \(w\), \(w_{,x}\), \(w_{,y}\), \(w_{,xy}\) of the nodes, the positions 6, 7, 8, 9 plus 0, 10, 20 and 30, are written, the other entries keep the zeros of the constructor.

Parameters:

xi, etadouble: Natural coordinates of the point, dimensionless, from -1 to 1 over the element, xi along \(x\) and eta along \(y\).

Notes

The entries are the derivatives \(\partial/\partial x = (2/l_{ex}) \partial/\partial \xi\) of those of BFSCCylinderSanders.update_Sw(), with the Hermite functions of the Notes of bfsccylinder.bfsccylinder.

update_Sw_y(xi, eta)#

Update Sw_y at a natural coordinate point

Sw_y is computed at xi, eta from lex and ley. Its product with an element displacement vector, e.g. u, gives the derivative \(w_{,y}\) at that point, dimensionless. Only the entries at the degrees of freedom \(w\), \(w_{,x}\), \(w_{,y}\), \(w_{,xy}\) of the nodes, the positions 6, 7, 8, 9 plus 0, 10, 20 and 30, are written, the other entries keep the zeros of the constructor.

Parameters:

xi, etadouble: Natural coordinates of the point, dimensionless, from -1 to 1 over the element, xi along \(x\) and eta along \(y\).

Notes

The entries are the derivatives \(\partial/\partial y = (2/l_{ey}) \partial/\partial \eta\) of those of BFSCCylinderSanders.update_Sw(), with the Hermite functions of the Notes of bfsccylinder.bfsccylinder.

bfsccylinder.bfsccylinder_sanders.update_KC0(shell, points, weights, KC0r, KC0c, KC0v)#

Update sparse vectors for linear constitutive stiffness matrix KC0

The element matrix, with 40*40 entries, is integrated with the integration points and weights given by points and weights, from lex, ley, R and the stiffnesses A11, ..., D66 of shell. All its entries are written: the global row and column indices to KC0r and KC0c, and the values added to KC0v, at the positions shell.init_k_KC0 to shell.init_k_KC0 + KC0_SPARSE_SIZE - 1. Before this function is called, c1, c2, c3, c4, init_k_KC0, lex, ley, R and the stiffnesses of shell must be set.

Parameters:

shellBFSCCylinderSanders object: The cylindrical shell element being added to KC0
pointsnp.array: Integration poins 1-D array of DOUBLE of size nint, the nint given to the constructor of shell, with natural coordinates from -1 to 1, e.g. from bfsccylinder.quadrature.get_points_weights(). Used in both directions, for nint*nint integration points.
weightsnp.array: Integration weights 1-D array of DOUBLE of the same size as points.
KC0rnp.array: Array to store row positions of sparse values 1-D array of integers (INT) of size at least init_k_KC0 + KC0_SPARSE_SIZE.
KC0cnp.array: Array to store column positions of sparse values Same type and size as KC0r.
KC0vnp.array: Array to store sparse values 1-D array of DOUBLE, same size as KC0r. The values are added to the existing ones. Dimension of force per unit length between the displacements \(u\), \(v\), \(w\), multiplied by a length for each of the row and the column that is a first derivative, and by a length squared for each that is \(w_{,xy}\).

See also

update_KCNL, update_KG

Notes

The matrix of the Notes of bfsccylinder.bfsccylinder.update_KC0(), with the rows \(\boldsymbol{B}_b\) of the Sanders-type curvatures of BFSCCylinderSanders.update_Bb().

bfsccylinder.bfsccylinder_sanders.update_KCNL(u, shell, points, weights, KCNLr, KCNLc, KCNLv)#

Update sparse vectors for nonlinear stiffness matrix KCNL

The element matrix is integrated with the integration points and weights given by points and weights, from lex, ley, R, the stiffnesses A11, ..., B66 of shell (the D stiffnesses are not used) and the displacements of the nodes of the element, copied from u to shell.u. The entries for which both the row and the column correspond to the degrees of freedom \(u\), \(u_{,x}\), \(u_{,y}\) are not written. The global row and column indices of the other entries are written to KCNLr and KCNLc, and their values added to KCNLv, at the positions shell.init_k_KCNL to shell.init_k_KCNL + KCNL_SPARSE_SIZE - 1. Before this function is called, c1, c2, c3, c4, init_k_KCNL, lex, ley, R and the stiffnesses of shell must be set. KC0 + KCNL + KG, computed with update_KC0(), this function and update_KG() with the same u, points and weights, is the tangent stiffness matrix of the internal forces of update_fint().

Parameters:

unp.array: Global displacement vector 1-D array of DOUBLE with DOF entries per node of the model, in the order of the degrees of freedom of a node given in the module documentation. The entries of the nodes of shell are read at the positions c1+i, c2+i, c3+i and c4+i, for i from 0 to 9. Dimension of length for \(u\), \(v\), \(w\), dimensionless for the first derivatives and of one over length for \(w_{,xy}\).
shellBFSCCylinderSanders object: The shell element being added to K
pointsnp.array: Integration poins 1-D array of DOUBLE of size nint, the nint given to the constructor of shell, with natural coordinates from -1 to 1, e.g. from bfsccylinder.quadrature.get_points_weights(). Used in both directions, for nint*nint integration points.
weightsnp.array: Integration weights 1-D array of DOUBLE of the same size as points.
KCNLrnp.array: Array to store row positions of sparse values 1-D array of integers (INT) of size at least init_k_KCNL + KCNL_SPARSE_SIZE.
KCNLcnp.array: Array to store column positions of sparse values Same type and size as KCNLr.
KCNLvnp.array: Array to store sparse values 1-D array of DOUBLE, same size as KCNLr. The values are added to the existing ones, with the dimensions given for KC0v in update_KC0().

See also

update_KC0, update_KG, update_fint

Notes

Assuming that KCNL = KC0L + KCL0 + KCLL + KGNL, that is \(\boldsymbol{K}_{CNL} + \boldsymbol{K}_{GNL}\): the nonlinear constitutive stiffness matrix \(\boldsymbol{K}_{CNL} = \boldsymbol{K}_{C0L} + \boldsymbol{K}_{CL0} + \boldsymbol{K}_{CLL}\) of the terms of \(\boldsymbol{B}_{NL}\) and the geometric stiffness matrix \(\boldsymbol{K}_{GNL}\) of the membrane stress resultants of the nonlinear strains.

The first three groups are the constitutive terms coupling the linear and the nonlinear parts of the membrane strain. KGNL is the geometric term carrying the stress of the nonlinear membrane strain, A*BmL*u/2.

KGNL is geometric rather than constitutive, and would normally sit in update_KG. It is collected here so that update_KG can stay homogeneous of degree one in u, which is what a linear buckling analysis needs. With it here,

KT = KC0 + KCNL(u) + KG(u)

is the exact Jacobian of the vector assembled by update_fint, so a Newton-Raphson built on these three converges quadratically.

The four terms are those of the Notes of bfsccylinder.bfsccylinder.update_KCNL(), with the Sanders-type \(\boldsymbol{B}_b\), \(\boldsymbol{B}_{NL}\) and \(\boldsymbol{G}\) of the Notes of bfsccylinder.bfsccylinder_sanders, evaluated at each integration point with v, w_x and w_y of the element displacements shell.u, and with \(\{N_{NLxx}, N_{NLyy}, N_{NLxy}\}^\top = \boldsymbol{A}\{w_{,x}^2/2, (w_{,y} - v/R)^2/2, w_{,x} (w_{,y} - v/R)\}^\top\). Since \(\boldsymbol{B}_{NL}\) and \(\boldsymbol{G}\) have entries at the degrees of freedom of \(v\) and \(w\), only the block of the degrees of freedom of \(u\) is zero.

bfsccylinder.bfsccylinder_sanders.update_KCfollower(u, shell, points, weights, p, KCfollowerr, KCfollowerc, KCfollowerv, quadratic=0)#

Update sparse vectors for the load stiffness matrix KCfollower

The load stiffness matrix of a follower pressure, minus the derivative of the force vector of update_fext_follower() with respect to the element displacements, is integrated with the integration points and weights given by points and weights, from lex, ley and R of shell, the pressure p at the integration points and the displacements of the nodes of the element, copied from u to shell.u, which enter only with quadratic=1. The matrix is unsymmetric in general and is written in full, it must not be symmetrized. Only the entries that are not identically zero for quadratic=1 are written, for both values of quadratic: those for which the row corresponds to the degrees of freedom \(u\), \(u_{,x}\), \(u_{,y}\) and the column to those of \(v\) or \(w\), and the row to those of \(v\) or \(w\) and the column to any degree of freedom. The entries between the degrees of freedom of \(u\) and \(v\) are zero for quadratic=0. The global row and column indices are written to KCfollowerr and KCfollowerc, and the values added to KCfollowerv, at the positions shell.init_k_KCfollower to shell.init_k_KCfollower + KCfollower_SPARSE_SIZE - 1. Before this function is called, c1, c2, c3, c4, init_k_KCfollower, lex, ley and R of shell must be set; the stiffnesses are not used. With quadratic=0 the values do not depend on u.

Parameters:

unp.array: Global displacement vector 1-D array of DOUBLE with DOF entries per node of the model, in the order of the degrees of freedom of a node given in the module documentation. The entries of the nodes of shell are read at the positions c1+i, c2+i, c3+i and c4+i, for i from 0 to 9. Dimension of length for \(u\), \(v\), \(w\), dimensionless for the first derivatives and of one over length for \(w_{,xy}\).
shellBFSCCylinderSanders object: The shell element being added to KCfollower
pointsnp.array: Integration poins 1-D array of DOUBLE of size nint, the nint given to the constructor of shell, with natural coordinates from -1 to 1, e.g. from bfsccylinder.quadrature.get_points_weights(). Used in both directions, for nint*nint integration points.
weightsnp.array: Integration weights 1-D array of DOUBLE of the same size as points.
pnp.array: Pressure at the integration points 2-D array of DOUBLE of shape (nint, nint), with the meaning, indices, units and sign given in update_fext_follower().
KCfollowerrnp.array: Array to store row positions of sparse values 1-D array of integers (INT) of size at least init_k_KCfollower + KCfollower_SPARSE_SIZE.
KCfollowercnp.array: Array to store column positions of sparse values Same type and size as KCfollowerr.
KCfollowervnp.array: Array to store sparse values 1-D array of DOUBLE, same size as KCfollowerr. The values are added to the existing ones, with the dimensions given for KC0v in update_KC0().
quadraticint, optional: 0, the default, or 1, the truncation of the area vector of update_fext_follower().

See also

update_fext_follower

Notes

The load stiffness matrix of the Notes of bfsccylinder.bfsccylinder.update_KCfollower(), with the area vector of update_fext_follower(), \(k_v = 1/R\). The term \(v/R\) of \(a_y\) adds, with quadratic=0, the block \(-(\boldsymbol{S}^v)^\top \boldsymbol{S}^v/R\) per unit \(p\) between \(v\) and \(v\), which cancels the energy of the rigid rotation \(v\) = constant of a ring under the hoop prestress of the pressure in update_KG(), and the terms of \(\boldsymbol{a}_2\) in \(v\) are added for quadratic=1.

bfsccylinder.bfsccylinder_sanders.update_KG(u, shell, points, weights, KGr, KGc, KGv)#

Update sparse vectors for geometric stiffness matrix KG

The element matrix is integrated with the integration points and weights given by points and weights, from lex, ley and R of shell. At each integration point the membrane stress resultants Nxx, Nyy and Nxy are computed from the stiffnesses A11, ..., B66 of shell and from the displacements of the nodes of the element, copied from u to shell.u. Only the entries for which both the row and the column correspond to the degrees of freedom \(v\), \(v_{,x}\), \(v_{,y}\), \(w\), \(w_{,x}\), \(w_{,y}\), \(w_{,xy}\) are written: the global row and column indices to KGr and KGc, and the values added to KGv, at the positions shell.init_k_KG to shell.init_k_KG + KG_SPARSE_SIZE - 1. Before this function is called, c1, c2, c3, c4, init_k_KG, lex, ley, R and the stiffnesses of shell must be set. Nxx, Nyy and Nxy are those of the linear strains, such that the values are linear in u; the corresponding term of the nonlinear strains is in update_KCNL().

Parameters:

unp.array: Global displacement vector 1-D array of DOUBLE with DOF entries per node of the model, in the order of the degrees of freedom of a node given in the module documentation. The entries of the nodes of shell are read at the positions c1+i, c2+i, c3+i and c4+i, for i from 0 to 9. Dimension of length for \(u\), \(v\), \(w\), dimensionless for the first derivatives and of one over length for \(w_{,xy}\).
shellBFSCCylinderSanders object: The cylindrical shell element being added to KG
pointsnp.array: Integration poins 1-D array of DOUBLE of size nint, the nint given to the constructor of shell, with natural coordinates from -1 to 1, e.g. from bfsccylinder.quadrature.get_points_weights(). Used in both directions, for nint*nint integration points.
weightsnp.array: Integration weights 1-D array of DOUBLE of the same size as points.
KGrnp.array: Array to store row positions of sparse values 1-D array of integers (INT) of size at least init_k_KG + KG_SPARSE_SIZE.
KGcnp.array: Array to store column positions of sparse values Same type and size as KGr.
KGvnp.array: Array to store sparse values 1-D array of DOUBLE, same size as KGr. The values are added to the existing ones, with the dimensions given for KC0v in update_KC0().

See also

update_KG_constant_stress, update_KCNL

Notes

Built from the membrane stress of the LINEAR strain alone, A*Bm*u + B*Bb*u, which keeps KG homogeneous of degree one in u. A linear buckling analysis needs exactly that, so that lambda*KG represents the stress state at load lambda*P.

The geometric term of the nonlinear membrane stress is therefore NOT here; update_KCNL carries it, so that KC0 + KCNL + KG is still the consistent tangent of update_fint.

The matrix is the \(\boldsymbol{K}_G\) of the Notes of bfsccylinder.bfsccylinder.update_KG(), with the Sanders-type \(\boldsymbol{B}_b\) in the stress resultants and the rows of \(\boldsymbol{G}\) of the Notes of bfsccylinder.bfsccylinder_sanders, \(\boldsymbol{S}^w_{,x}\) and \(\boldsymbol{S}^w_{,y} - \boldsymbol{S}^v/R\), such that \(\boldsymbol{G}\boldsymbol{u}_e = \{w_{,x}, w_{,y} - v/R\}^\top\).

bfsccylinder.bfsccylinder_sanders.update_KG_constant_stress(shell, points, weights, KGr, KGc, KGv, Nxx, Nyy, Nxy)#

Update sparse vectors for geometric stiffness matrix KG

The same matrix as update_KG(), with the membrane stress resultants Nxx, Nyy and Nxy given, constant over the element, instead of computed from displacements. It is integrated with the integration points and weights given by points and weights, from lex, ley and R of shell; the stiffnesses and shell.u are not used. The entries are those of update_KG(): the global row and column indices are written to KGr and KGc, and the values added to KGv, at the positions shell.init_k_KG to shell.init_k_KG + KG_SPARSE_SIZE - 1. Before this function is called, c1, c2, c3, c4, init_k_KG, lex, ley and R of shell must be set.

Parameters:

shellBFSCCylinderSanders object: The cylindrical shell element being added to KG
pointsnp.array: Integration poins 1-D array of DOUBLE of size nint, the nint given to the constructor of shell, with natural coordinates from -1 to 1, e.g. from bfsccylinder.quadrature.get_points_weights(). Used in both directions, for nint*nint integration points.
weightsnp.array: Integration weights 1-D array of DOUBLE of the same size as points.
KGrnp.array: Array to store row positions of sparse values 1-D array of integers (INT) of size at least init_k_KG + KG_SPARSE_SIZE.
KGcnp.array: Array to store column positions of sparse values Same type and size as KGr.
KGvnp.array: Array to store sparse values 1-D array of DOUBLE, same size as KGr. The values are added to the existing ones, with the dimensions given for KC0v in update_KC0().
Nxx, Nyy, Nxyfloat: Constant membrane stress state Force per unit length, used at every integration point.

See also

update_KG

Notes

The matrix is the \(\boldsymbol{K}_G\) of the Notes of update_KG() with the given \(N_{xx}\), \(N_{yy}\) and \(N_{xy}\); R enters through the row \(\boldsymbol{S}^w_{,y} - \boldsymbol{S}^v/R\) of \(\boldsymbol{G}\). See the Notes of bfsccylinder.bfsccylinder.update_KG_constant_stress() for its use in a linear buckling analysis.

bfsccylinder.bfsccylinder_sanders.update_M(shell, Mr, Mc, Mv)#

Update sparse vectors for mass matrix M

The element mass matrix is computed from lex, ley, rho, h and R of shell with closed-form expressions, without integration points; the stiffnesses are not used. Only the entries that couple the degrees of freedom \(u\), \(u_{,x}\), \(u_{,y}\) with themselves, and \(v\), \(v_{,x}\), \(v_{,y}\), \(w\), \(w_{,x}\), \(w_{,y}\), \(w_{,xy}\) with themselves and with each other are written, except the entries between \(v_{,y}\) and \(w_{,y}\) of the same node, whose integral is zero: the global row and column indices to Mr and Mc, and the values added to Mv, at the positions shell.init_k_M to shell.init_k_M + M_SPARSE_SIZE - 1. Before this function is called, c1, c2, c3, c4, init_k_M, lex, ley, rho, h and a nonzero R of shell must be set.

Parameters:

shellBFSCCylinderSanders object: The cylindrical shell element being added to M
Mrnp.array: Array to store row positions of sparse values 1-D array of integers (INT) of size at least init_k_M + M_SPARSE_SIZE.
Mcnp.array: Array to store column positions of sparse values Same type and size as Mr.
Mvnp.array: Array to store sparse values 1-D array of DOUBLE, same size as Mr. The values are added to the existing ones. Dimension of mass between the displacements \(u\), \(v\), \(w\), multiplied by a length for each of the row and the column that is a first derivative, and by a length squared for each that is \(w_{,xy}\).

Notes

The consistent mass matrix of the interpolation of the Notes of bfsccylinder.bfsccylinder, for a density \(\rho\) = rho uniform over the thickness \(h\) = h, with the Kirchhoff-Love displacements of the Sanders-type kinematics at the distance \(z\) from the mid-surface, \(u + z \beta_x\), \(v + z \beta_y\) and \(w\), with the rotations \(\beta_x = -w_{,x}\) and \(\beta_y = -w_{,y} + v/R\) of the Notes of bfsccylinder.bfsccylinder_sanders:

\[\boldsymbol{M} = \int_A \rho \left( h \left( (\boldsymbol{S}^u)^\top \boldsymbol{S}^u + (\boldsymbol{S}^v)^\top \boldsymbol{S}^v + (\boldsymbol{S}^w)^\top \boldsymbol{S}^w \right) + \frac{h^3}{12} \left( (\boldsymbol{S}^w_{,x})^\top \boldsymbol{S}^w_{,x} + \left( \boldsymbol{S}^w_{,y} - \boldsymbol{S}^v/R \right)^\top \left( \boldsymbol{S}^w_{,y} - \boldsymbol{S}^v/R \right) \right) \right) dA\]

The terms in \(h^3/12\) are the rotary inertia of \(\beta_x\) and \(\beta_y\); the term \(v/R\) of \(\beta_y\) couples \(v\) and \(w\) and adds \(h^3/(12 R^2) (\boldsymbol{S}^v)^\top \boldsymbol{S}^v\) to the entries of \(v\), which the matrix of bfsccylinder.bfsccylinder.update_M(), with the rotations of the Donnell-type kinematics, does not have. There is no coupling between \(u\) and the other displacements, which corresponds to a reference surface at the middle of the thickness, and the variation of the area with \(z\), the factor \(1 + z/R\), is neglected, as in a shallow shell. The integrand is a polynomial and the integral is exact.

bfsccylinder.bfsccylinder_sanders.update_fext_follower(u, shell, points, weights, p, fext, quadratic=0, reference=1)#

Update global external force vector of a follower pressure

The force vector of a pressure that follows the deformation of the element, normal to its deformed mid-surface and acting on its deformed area, is integrated with the integration points and weights given by points and weights, from lex, ley and R of shell, the pressure p at the integration points and the displacements of the nodes of the element, copied from u to shell.u. It is added to fext at the positions c1+i, c2+i, c3+i and c4+i, for i from 0 to 9. Before this function is called, c1, c2, c3, c4, lex, ley and R of shell must be set; the stiffnesses are not used.

Parameters:

unp.array: Global displacement vector 1-D array of DOUBLE with DOF entries per node of the model, in the order of the degrees of freedom of a node given in the module documentation. The entries of the nodes of shell are read at the positions c1+i, c2+i, c3+i and c4+i, for i from 0 to 9. Dimension of length for \(u\), \(v\), \(w\), dimensionless for the first derivatives and of one over length for \(w_{,xy}\).
shellBFSCCylinderSanders object: The shell element being added to fext
pointsnp.array: Integration poins 1-D array of DOUBLE of size nint, the nint given to the constructor of shell, with natural coordinates from -1 to 1, e.g. from bfsccylinder.quadrature.get_points_weights(). Used in both directions, for nint*nint integration points.
weightsnp.array: Integration weights 1-D array of DOUBLE of the same size as points.
pnp.array: Pressure at the integration points 2-D array of DOUBLE of shape (nint, nint), the entry [i, j] being used at the integration point xi = points[i], eta = points[j], as the entries of A11 of shell. Force per unit area of the undeformed mid-surface, already multiplied by the load factor if there is one. A positive pressure pushes along \(+z\), outwards, away from the axis of the cylinder, the direction of a positive \(w\), such that an external pressure is negative.
fextnp.array: Global external force vector 1-D array of DOUBLE of the same size as u. The values are added to the existing ones. Dimension of force for \(u\), \(v\), \(w\), multiplied by a length for the first derivatives and by a length squared for \(w_{,xy}\).
quadraticint, optional: 0, the default, to truncate the area vector of the deformed mid-surface to its terms of order 0 and 1 in the displacement gradients, such that the force vector is affine in u; 1 to also include its terms of order 2, see the Notes.
referenceint, optional: 1, the default, to include the term of order 0 of the area vector, which gives the dead pressure load of the undeformed configuration \(\boldsymbol{F}_p(\boldsymbol{0})\); 0 to leave it out, which gives \(\boldsymbol{F}_p(\boldsymbol{u}_e) - \boldsymbol{F}_p(\boldsymbol{0})\).

See also

update_KCfollower

Notes

The force vector of the Notes of bfsccylinder.bfsccylinder.update_fext_follower(), with \(k_v = 1/R\): the term \(w_{,y} - v/R\) of the tangent vector \(\boldsymbol{X}_{,y}\) is minus the Sanders-type rotation \(\beta_y\) of the Notes of bfsccylinder.bfsccylinder_sanders, and \(\boldsymbol{X}_{,x} \times \boldsymbol{X}_{,y}\) is the exact area vector of the deformed mid-surface. The area vector ax, ay, az is evaluated at each integration point with the displacement gradients u_x, u_y, v_x, v_y, v, w, w_x and w_y of u.

bfsccylinder.bfsccylinder_sanders.update_fint(u, shell, points, weights, fint)#

Update global internal force vector

The internal forces of the element are integrated with the integration points and weights given by points and weights, from lex, ley, R, the stiffnesses A11, ..., D66 of shell and the displacements of the nodes of the element, copied from u to shell.u, including the terms nonlinear in the displacements. They are added to fint at the positions c1+i, c2+i, c3+i and c4+i, for i from 0 to 9. Before this function is called, c1, c2, c3, c4, lex, ley, R and the stiffnesses of shell must be set.

Parameters:

unp.array: Global displacement vector 1-D array of DOUBLE with DOF entries per node of the model, in the order of the degrees of freedom of a node given in the module documentation. The entries of the nodes of shell are read at the positions c1+i, c2+i, c3+i and c4+i, for i from 0 to 9. Dimension of length for \(u\), \(v\), \(w\), dimensionless for the first derivatives and of one over length for \(w_{,xy}\).
shellBFSCCylinderSanders object: The shell element being added to fint
pointsnp.array: Integration poins 1-D array of DOUBLE of size nint, the nint given to the constructor of shell, with natural coordinates from -1 to 1, e.g. from bfsccylinder.quadrature.get_points_weights(). Used in both directions, for nint*nint integration points.
weightsnp.array: Integration weights 1-D array of DOUBLE of the same size as points.
fintnp.array: Global internal force array 1-D array of DOUBLE of the same size as u. The values are added to the existing ones. Dimension of force for \(u\), \(v\), \(w\), multiplied by a length for the first derivatives and by a length squared for \(w_{,xy}\).

See also

update_KCNL

Notes

The internal forces of the Notes of bfsccylinder.bfsccylinder.update_fint(), with the Sanders-type \(\boldsymbol{B}_b\) and \(\boldsymbol{B}_{NL}\) of the Notes of bfsccylinder.bfsccylinder_sanders, evaluated at each integration point with v, w_x and w_y. Their derivative is the sum of the matrices of update_KC0(), update_KCNL() and update_KG() of this module.

Sanders-type cylinder element (bfsccylinder.bfsccylinder_sanders)#

Notes#

References#

Sanders-type cylinder element (`bfsccylinder.bfsccylinder_sanders`)#