pycufsm.solve.cfsm

Functions

base_column(→ numpy.ndarray)

this routine creates base vectors for a column with length length for all the

base_update(→ numpy.ndarray)

this routine optionally makes orthogonalization and normalization of base vectors

mode_select(→ numpy.ndarray)

this routine selects the required base vectors

constr_user(→ numpy.ndarray)

this routine creates the constraints matrix, r_user_matrix, as defined by the user

mode_constr(→ Tuple[numpy.ndarray, numpy.ndarray, ...)

this routine creates the constraint matrices necessary for mode

y_dofs(→ Tuple[numpy.ndarray, int])

this routine creates y-DOFs of main nodes for global buckling and

base_vectors(→ numpy.ndarray)

this routine creates the base vectors for global, dist., local and other modes

constr_xz_y(→ Tuple[numpy.ndarray, numpy.ndarray])

this routine creates the constraint matrix, Rxz, that defines relationship

constr_planar_xz(→ numpy.ndarray)

this routine creates the constraint matrix, r_p, that defines relationship

constr_yd_yg(→ numpy.ndarray)

this routine creates the constraint matrix, r_yd, that defines relationship

constr_ys_ym(→ numpy.ndarray)

this routine creates the constraint matrix, r_ys, that defines relationship

constr_yu_yd(→ numpy.ndarray)

this routine creates the constraint matrix, r_ud, that defines relationship

base_properties(→ Tuple[numpy.ndarray, numpy.ndarray, ...)

this routine creates all the data for defining the base vectors from the

meta_elems(→ Tuple[numpy.ndarray, numpy.ndarray, ...)

this routine re-organises the basic input data

mode_nr(→ Tuple[int, int])

this routine determines the number of distortional and local buckling modes

dof_ordering(→ numpy.ndarray)

this routine re-orders the DOFs,

classify(→ List[numpy.ndarray])

modal classificaiton

mode_class(→ numpy.ndarray)

to determine mode contribution in the current displacement

node_class(→ Tuple[int, int, int])

this routine determines how many nodes of the various types exist

Module Contents

pycufsm.solve.cfsm.base_column(nodes_base: numpy.ndarray, elements: numpy.ndarray, props: numpy.ndarray, length: float, B_C: str, m_a: numpy.ndarray, el_props: numpy.ndarray, node_props: numpy.ndarray, n_main_nodes: int, n_corner_nodes: int, n_sub_nodes: int, n_global_modes: int, n_dist_modes: int, n_local_modes: int, dof_perm: numpy.ndarray, r_x: numpy.ndarray, r_z: numpy.ndarray, r_ys: numpy.ndarray, d_y: numpy.ndarray) → numpy.ndarray

this routine creates base vectors for a column with length length for all the specified longitudinal terms in m_a

assumptions

orthogonalization is not performed unless the user wants orthogonalization is done by solving the eigen-value problem within each sub-space normalization is not done

Args:

nodes_base (np.ndarray): standard nodes parameter, but with zero stresses elements (np.ndarray): standard parameter props (np.ndarray): standard parameter length (float): half-wavelength B_C (str): [‘S-S’] a string specifying boundary conditions to be analyzed:

‘S-S’ simply-pimply supported boundary condition at loaded edges ‘C-C’ clamped-clamped boundary condition at loaded edges ‘S-C’ simply-clamped supported boundary condition at loaded edges ‘C-F’ clamped-free supported boundary condition at loaded edges ‘C-G_bulk’ clamped-guided supported boundary condition at loaded edges

m_a (np.ndarray): longitudinal terms (half-wave numbers) el_props (np.ndarray): standard parameter node_props (np.ndarray): _description_ n_main_nodes (int): _description_ n_corner_nodes (int): _description_ n_sub_nodes (int): _description_ n_global_modes (int): _description_ n_dist_modes (int): _description_ n_local_modes (int): _description_ dof_perm (np.ndarray): _description_ r_x (np.ndarray): _description_ r_z (np.ndarray): _description_ r_ys (np.ndarray): _description_ d_y (np.ndarray): _description_

Returns:
b_v_l (np.ndarray): base vectors (each column corresponds to a certain mode)

assemble for each half-wave number m_i on its diagonal b_v_l = diag(b_v_m) for each half-wave number m_i, b_v_m

columns 1..n_global_modes: global modes columns (n_global_modes+1)..(n_global_modes+n_dist_modes): dist. modes columns (n_global_modes+n_dist_modes+1)

..(n_global_modes+n_dist_modes+n_local_modes): local modes

columns (n_global_modes+n_dist_modes+n_local_modes+1)..n_dof: other modes

n_global_modes, n_dist_modes, n_local_modes - number of G_bulk, D, L modes, respectively

S. Adany, Aug 28, 2006 B. Schafer, Aug 29, 2006 Z. Li, Dec 22, 2009 Z. Li, June 2010

pycufsm.solve.cfsm.base_update(GBT_con: pycufsm._types.GBT_Con, b_v_l: numpy.ndarray, length: float, m_a: numpy.ndarray, nodes: numpy.ndarray, elements: numpy.ndarray, props: numpy.ndarray, n_global_modes: int, n_dist_modes: int, n_local_modes: int, B_C: str, el_props: numpy.ndarray) → numpy.ndarray

this routine optionally makes orthogonalization and normalization of base vectors

assumptions

orthogonalization is done by solving the EV problem for each sub-space three options for normalization is possible, set by ‘GBT_con[‘norm’]’ parameter

Args:
GBT_con (GBT_Con):
GBT_con[‘o_space’] - by GBT_con, choices of ST/O mode

1: ST basis 2: O space (null space of GDL) with respect to K_global 3: O space (null space of GDL) with respect to Kg_global 4: O space (null space of GDL) in vector sense

GBT_con[‘norm’] - by GBT_con, code for normalization (if normalization is done at all)

0: no normalization, 1: vector norm 2: strain energy norm 3: work norm

GBT_con[‘couple’] - by GBT_con, coupled basis vs uncoupled basis for general B.C.

especially for non-simply supported B.C.

1: uncoupled basis, the basis will be block diagonal 2: coupled basis, the basis is fully spanned

GBT_con[‘orth’] - by GBT_con, natural basis vs modal basis

1: natural basis 2: modal basis, axial orthogonality 3: modal basis, load dependent orthogonality

b_v_l (np.ndarray): natural base vectors for length (each column corresponds to a
certain mode) for each half-wave number m_i

columns 1..n_global_modes: global modes columns (n_global_modes+1)..(n_global_modes+n_dist_modes): dist. modes columns (n_global_modes+n_dist_modes+1)

..(n_global_modes+n_dist_modes+n_local_modes): local modes

columns (n_global_modes+n_dist_modes+n_local_modes+1)..n_dof_m: other modes

length (float): _description_ m_a (np.ndarray): _description_ nodes (np.ndarray): _description_ elements (np.ndarray): _description_ props (np.ndarray): _description_ n_global_modes (int): _description_ n_dist_modes (int): _description_ n_local_modes (int): _description_ B_C (str): _description_ el_props (np.ndarray): _description_

Returns:
b_v (np.ndarray): output base vectors (maybe natural, orthogonal or normalized,

depending on the selected options)

S. Adany, Oct 11, 2006 Z. Li modified on Jul 10, 2009 Z. Li, June 2010

pycufsm.solve.cfsm.mode_select(b_v: numpy.ndarray, n_global_modes: int, n_dist_modes: int, n_local_modes: int, GBT_con: pycufsm._types.GBT_Con, n_dof_m: int, m_a: numpy.ndarray) → numpy.ndarray
this routine selects the required base vectors
b_v_red forms a reduced space for the calculation, including the

selected modes only

b_v_red itself is the final constraint matrix for the selected modes

note: for all if_* indicator: 1 if selected, 0 if eliminated

Args:
b_v (np.ndarray): base vectors (each column corresponds to a certain mode)

columns 1..n_global_modes: global modes columns (n_global_modes+1)..(n_global_modes+n_dist_modes): dist. modes columns (n_global_modes+n_dist_modes+1)

..(n_global_modes+n_dist_modes+n_local_modes): local modes

columns (n_global_modes+n_dist_modes+n_local_modes+1)..n_dof: other modes

n_global_modes (int): _description_ n_dist_modes (int): _description_ n_local_modes (int): _description_ GBT_con (GBT_Con): GBT_con[‘glob’] - indicator which global modes are selected

GBT_con[‘dist’] - indicator which dist. modes are selected GBT_con[‘local’] - indicator whether local modes are selected GBT_con[‘other’] - indicator whether other modes are selected

n_dof_m (int): 4*n_nodes, total DOF for a single longitudinal term m_a (np.ndarray): _description_

Returns:

b_v_red (np.ndarray): reduced base vectors (each column corresponds to a certain mode)

S. Adany, Mar 22, 2004 BWS May 2004 modifed on Jul 10, 2009 by Z. Li for general B_C Z. Li, June 2010

pycufsm.solve.cfsm.constr_user(nodes: numpy.ndarray, constraints: numpy.ndarray, m_a: numpy.ndarray) → numpy.ndarray

this routine creates the constraints matrix, r_user_matrix, as defined by the user

Args:

nodes (np.ndarray): same as elsewhere throughout this program constraints (np.ndarray): same as ‘constraints’ throughout this program m_a (np.ndarray): longitudinal terms to be included for this length

Returns:
r_user_matrix (np.ndarray): the constraints matrix (in other words: base vectors) so that

displ_orig = r_user_matrix * displ_new

S. Adany, Feb 26, 2004 Z. Li, Aug 18, 2009 for general b.c. Z. Li, June 2010

pycufsm.solve.cfsm.mode_constr(nodes: numpy.ndarray, elements: numpy.ndarray, node_props: numpy.ndarray, main_nodes: numpy.ndarray, meta_elements: numpy.ndarray) → Tuple[numpy.ndarray, numpy.ndarray, numpy.ndarray, numpy.ndarray, numpy.ndarray]

this routine creates the constraint matrices necessary for mode separation/classification for each specified half-wave number m_i

assumptions

GBT-like assumptions are used the cross-section must not be closed and must not contain closed parts

must check whether ‘Warp’ works well for any open section !!!

notes:
m-el_i-? is positive if the starting nodes of m-el_i-? coincides with

the given m-nodes, otherwise negative

nodes types: 1-corner, 2-edge, 3-sub sub-nodes numbers are the original one, of course

Args:

nodes (np.ndarray): standard parameter elements (np.ndarray): standard parameter node_props (np.ndarray): array of [original nodes nr, new nodes nr, nr of adj elements,

nodes type]

main_nodes (np.ndarray): array of

[nr, x, z, orig nodes nr, nr of adj meta-elements, m_i-el_i-1, m_i-el_i-2, …]

meta_elements (np.ndarray): array of

[nr, main-nodes-1, main-nodes-2, nr of sub-nodes, sub-no-1, sub-nod-2, …]

Returns:

r_x (np.ndarray): constaint matrices for x dofs r_z (np.ndarray): constaint matrices for z dofs r_ys (np.ndarray): constaint matrices for y dofs of sub-nodes r_yd (np.ndarray): constaint matrices for y dofs of main nodes for distortional buckling r_ys (np.ndarray): constaint matrices for y dofs of indefinite (?independent?) main nodes

S. Adany, Mar 10, 2004 Z. Li, Jul 10, 2009

pycufsm.solve.cfsm.y_dofs(nodes: numpy.ndarray, elements: numpy.ndarray, main_nodes: numpy.ndarray, n_main_nodes: int, n_dist_modes: int, r_yd: numpy.ndarray, r_ud: numpy.ndarray, sect_props: pycufsm._types.Sect_Props, el_props: numpy.ndarray) → Tuple[numpy.ndarray, int]

this routine creates y-DOFs of main nodes for global buckling and distortional buckling, however:

only involves single half-wave number m_i

assumptions

GBT-like assumptions are used the cross-section must not be closed and must not contain closed parts

Args:

nodes (np.ndarray): standard parameter elements (np.ndarray): standard parameter main_nodes (np.ndarray): nodes of ‘meta’ cross-section n_main_nodes (int): _description_ n_dist_modes (int): _description_ r_yd (np.ndarray): constrain matrices r_ud (np.ndarray): constrain matrices sect_props (Sect_Props): _description_ el_props (np.ndarray): _description_

Returns:
d_y (np.ndarray): y-DOFs of main nodes for global buckling and distortional buckling

(each column corresponds to a certain mode)

S. Adany, Mar 10, 2004, modified Aug 29, 2006 Z. Li, Dec 22, 2009

pycufsm.solve.cfsm.base_vectors(d_y: numpy.ndarray, elements: numpy.ndarray, el_props: numpy.ndarray, length: float, m_i: float, node_props: numpy.ndarray, n_main_nodes: int, n_corner_nodes: int, n_sub_nodes: int, n_global_modes: int, n_dist_modes: int, n_local_modes: int, r_x: numpy.ndarray, r_z: numpy.ndarray, r_p: numpy.ndarray, r_ys: numpy.ndarray, dof_perm: numpy.ndarray) → numpy.ndarray

this routine creates the base vectors for global, dist., local and other modes

assumptions

GBT-like assumptions are used the cross-section must not be closed and must not contain closed parts

must check whether ‘Warp’ works well for any open section !!!

Args:

d_y (np.ndarray): _description_ elements (np.ndarray): standard parameter el_props (np.ndarray): standard parameter length (float): element length m_i (float): number of half-waves node_props (np.ndarray): some properties of the nodes n_main_nodes (int): number of nodes of given type n_corner_nodes (int): number of nodes of given type n_sub_nodes (int): number of nodes of given type n_global_modes (int): number of given modes n_dist_modes (int): number of given modes n_local_modes (int): number of given modes r_x (np.ndarray): constraint matrix r_z (np.ndarray): constraint matrix r_p (np.ndarray): constraint matrix r_ys (np.ndarray): constraint matrix dof_perm (np.ndarray):permutation matrix to re-order the DOFs

Returns:

np.ndarray: _description_

S. Adany, Mar 10, 2004, modified Aug 29, 2006 Z. Li, Dec 22, 2009

pycufsm.solve.cfsm.constr_xz_y(main_nodes: numpy.ndarray, meta_elements: numpy.ndarray) → Tuple[numpy.ndarray, numpy.ndarray]

this routine creates the constraint matrix, Rxz, that defines relationship between x, z displacements DOFs [for internal main nodes, referred also as corner nodes] and the longitudinal y displacements DOFs [for all the main nodes] if GBT-like assumptions are used

to make this routine length-independent, Rxz is not multiplied here by (1/k_m), thus it has to be multiplied outside of this routine!

additional assumption: cross section is opened!

note:

m-el_i-? is positive if the starting nodes of m-el_i-? coincides with the given m-nodes, otherwise negative

Args:
main_nodes (np.ndarray): array of

[nr, x, z, orig nodes nr, nr of adj meta-elements, m-el_i-1, m-el_i-2, …]

meta_elements (np.ndarray): array of

[nr, main-nodes-1, main-nodes-2, nr of sub-nodes, sub-no-1, sub-nod-2, …]

Returns:

r_x (np.ndarray): x dof restraints r_z (np.ndarray): z dof restraints

  1. Adany, Feb 05, 2004

pycufsm.solve.cfsm.constr_planar_xz(nodes: numpy.ndarray, elements: numpy.ndarray, props: numpy.ndarray, node_props: numpy.ndarray, dof_perm: numpy.ndarray, m_i: float, length: float, B_C: str, el_props: numpy.ndarray) → numpy.ndarray

this routine creates the constraint matrix, r_p, that defines relationship between x, z DOFs of any non-corner nodes + teta DOFs of all nodes, and the x, z displacements DOFs of corner nodes if GBT-like assumptions are used

Args:

nodes (np.ndarray): standard parameter elements (np.ndarray): standard parameter props (np.ndarray): standard parameter node_props (np.ndarray): array of [original nodes nr, new nodes nr, nr of adj elements,

nodes type]

dof_perm (np.ndarray): permutation matrix, so that

(orig-displacements-vect) = (dof_perm) � (new-displacements - vector)

m_i (float): _description_ length (float): element length B_C (str): standard parameter el_props (np.ndarray): standard parameter

Returns:
r_p (np.ndarray):constraint matrix, r_p, that defines relationship

between x, z DOFs of any non-corner nodes + teta DOFs of all nodes, and the x, z displacements DOFs of corner nodes

S. Adany, Feb 06, 2004 Z. Li, Jul 10, 2009

pycufsm.solve.cfsm.constr_yd_yg(nodes: numpy.ndarray, elements: numpy.ndarray, node_props: numpy.ndarray, r_ys: numpy.ndarray, n_main_nodes: int) → numpy.ndarray

this routine creates the constraint matrix, r_yd, that defines relationship between base vectors for distortional buckling, and base vectors for global buckling, but for y DOFs of main nodes only

Args:

nodes (np.ndarray): standard parameter elements (np.ndarray): standard parameter node_props (np.ndarray): array of [original nodes nr, new nodes nr, nr of adj elements,

nodes type]

r_ys (np.ndarray): constraint matrix, see function ‘constr_ys_ym’ n_main_nodes (int): nr of main nodes

Returns:

r_yd (np.ndarray): constraint matrix for y DOFs in distortional buckling

  1. Adany, Mar 04, 2004

pycufsm.solve.cfsm.constr_ys_ym(nodes: numpy.ndarray, main_nodes: numpy.ndarray, meta_elements: numpy.ndarray, node_props: numpy.ndarray) → numpy.ndarray

this routine creates the constraint matrix, r_ys, that defines relationship between y DOFs of sub-nodes, and the y displacements DOFs of main nodes by linear interpolation

Args:

nodes (np.ndarray): standard parameter main_nodes (np.ndarray): array of

[nr, x, z, orig nodes nr, nr of adj meta-elements, m-el_i-1, m-el_i-2, …]

meta_elements (np.ndarray): array of

[nr, main-nodes-1, main-nodes-2, nr of sub-nodes, sub-no-1, sub-nod-2, …]

node_props (np.ndarray): array of [original nodes nr, new nodes nr, nr of adj elements,

nodes type]

Returns:

r_ys (np.ndarray): constraint matrix for y DOFs of sub-nodes

  1. Adany, Feb 06, 2004

pycufsm.solve.cfsm.constr_yu_yd(main_nodes: numpy.ndarray, meta_elements: numpy.ndarray) → numpy.ndarray

this routine creates the constraint matrix, r_ud, that defines relationship between y displacements DOFs of indefinite main nodes and the y displacements DOFs of definite main nodes (definite main nodes = those main nodes which unambiguously define the y displacements pattern

indefinite main nodes = those nodes the y DOF of which can be calculated

from the y DOF of definite main nodes

note: for open sections with one single branch only there are no indefinite nodes)

important assumption: cross section is opened!

note:

m-el_i-? is positive if the starting nodes of m-el_i-? coincides with the given m-nodes, otherwise negative

Args:
main_nodes (np.ndarray): array of

[nr, x, z, orig nodes nr, nr of adj meta-elements, m-el_i-1, m-el_i-2, …]

meta_elements (np.ndarray): array of

[nr, main-nodes-1, main-nodes-2, nr of sub-nodes, sub-no-1, sub-nod-2, …]

Returns:

r_ud (np.ndarray): constraint matrix between definite and indefinite main nodes

  1. Adany, Mar 10, 2004

pycufsm.solve.cfsm.base_properties(nodes: numpy.ndarray, elements: numpy.ndarray) → Tuple[numpy.ndarray, numpy.ndarray, numpy.ndarray, int, int, int, int, int, numpy.ndarray]

this routine creates all the data for defining the base vectors from the cross section properties

Args:

nodes (np.ndarray): standard parameters elements (np.ndarray): standard parameters

Returns:
main_nodes (np.ndarray): array of

[nr, x, z, orig nodes nr, nr of adj meta-elements, m-el_i-1, m-el_i-2, …]

meta_elements (np.ndarray): array of

[nr, main-nodes-1, main-nodes-2, nr of sub-nodes, sub-no-1, sub-nod-2, …]

node_props (np.ndarray): array of

[original nodes nr, new nodes nr, nr of adj elements, nodes type]

n_main_nodes (int): number of main nodes n_corner_nodes (int): number of corner nodes n_sub_nodes (int): number of sub-nodes n_dist_modes (int): number of distortional modes n_local_modes (int): number of local modes dof_perm (np.ndarray): permutation matrix, so that

(orig-displacements-vect) = (dof_perm) � (new-displacements-vector)

S. Adany, Aug 28, 2006 B. Schafer, Aug 29, 2006 Z. Li, Dec 22, 2009

pycufsm.solve.cfsm.meta_elems(nodes: numpy.ndarray, elements: numpy.ndarray) → Tuple[numpy.ndarray, numpy.ndarray, numpy.ndarray]

this routine re-organises the basic input data to eliminate internal subdividing nodes to form meta-elements (corner-to-corner or corner-to-free edge) to identify main nodes (corner nodes and free edge nodes)

important assumption: cross section is opened!

note:
m-el_i-? is positive if the starting nodes of m-el_i-? coincides with

the given m-nodes, otherwise negative

nodes types: 1-corner, 2-edge, 3-sub sub-nodes numbers are the original ones, of course

Args:

nodes (np.ndarray): standard parameter elements (np.ndarray): standard parameter

Returns:
main_nodes (np.ndarray): main nodes (i.e. corner and free edge nodes) array of

[nr, x, z, orig nodes nr, nr of adj meta-elements, m-el_i-1, m-el_i-2, …]?

meta_elements (np.ndarray): elements connecting main nodes array of

[nr, main-nodes-1, main-nodes-2, nr of sub-nodes, sub-no-1, sub-nod-2, …]

node_props (np.ndarray): properties of main nodes array of

[original nodes nr, new nodes nr, nr of adj elements, nodes type]

  1. Adany, Feb 06, 2004

pycufsm.solve.cfsm.mode_nr(n_main_nodes: int, n_corner_nodes: int, n_sub_nodes: int, main_nodes: numpy.ndarray) → Tuple[int, int]

this routine determines the number of distortional and local buckling modes if GBT-like assumptions are used

Args:

n_main_nodes (int): number of main nodes n_corner_nodes (int): number of corner nodes n_sub_nodes (int): number of sub nodes main_nodes (np.ndarray): array of

[nr, x, z, orig nodes nr, nr of adj meta-elements, m-el_i-1, m-el_i-2, …]

Returns:

n_dist_modes (int): number of distortional modes n_local_modes (int): number of local modes

  1. Adany, Feb 09, 2004

pycufsm.solve.cfsm.dof_ordering(node_props: numpy.ndarray) → numpy.ndarray

this routine re-orders the DOFs, according to the need of forming shape vectors for various buckling modes

notes: (1) nodes types: 1-corner, 2-edge, 3-sub (2) the re-numbering of long. displacements. DOFs of main nodes, which may be

necessary for dist. buckling, is not included here but handled separately when forming Ry constraint matrix

Args:
node_props (np.ndarray): array of [original nodes nr, new nodes nr, nr of adj elements,

nodes type]

Returns:
dof_perm (np.ndarray): permutation matrix, so that

(orig-displacements-vect) = (dof_perm) � (new-displacements-vector)

  1. Adany, Feb 06, 2004

pycufsm.solve.cfsm.classify(props: numpy.ndarray, nodes: numpy.ndarray, elements: numpy.ndarray, lengths: numpy.ndarray, shapes: numpy.ndarray, GBT_con: pycufsm._types.GBT_Con, B_C: str, m_all: numpy.ndarray, sect_props: pycufsm._types.Sect_Props) → List[numpy.ndarray]

modal classificaiton

Args:

props (np.ndarray): [mat_num stiff_x E_y nu_x nu_y G_bulk] 6 x nmats nodes (np.ndarray): [nodes# x z dof_x dof_z dof_y dofrot stress] n_nodes x 8 elements (np.ndarray): [elements# node_i node_j thick mat_num] n_elements x 5 lengths (np.ndarray): lengths to be analysed shapes (np.ndarray): array of mode shapes dof x lengths x mode GBT_con (GBT_Con): _description_

method:

method = 1 = vector norm method = 2 = strain energy norm method = 3 = work norm

B_C (str): _description_ m_all (np.ndarray): _description_ sect_props (Sect_Props): _description_

Returns:

clas (List[np.ndarray]): array of # classification

BWS August 29, 2006 modified SA, Oct 10, 2006 Z.Li, June 2010

pycufsm.solve.cfsm.mode_class(b_v: numpy.ndarray, displacements: numpy.ndarray, n_global_modes: int, n_dist_modes: int, n_local_modes: int, m_a: numpy.ndarray, n_dof_m: int, GBT_con: pycufsm._types.GBT_Con) → numpy.ndarray

to determine mode contribution in the current displacement

Args:
b_v (np.ndarray): base vectors (each column corresponds to a certain mode)

columns 1..n_global_modes: global modes columns (n_global_modes+1)..(n_global_modes+n_dist_modes): dist. modes columns (n_global_modes+n_dist_modes+1)

..(n_global_modes+n_dist_modes+n_local_modes): local modes

columns (n_global_modes+n_dist_modes+n_local_modes+1)..n_dof: other modes

displacements (np.ndarray): vector of nodal displacements n_global_modes (int): number of modes n_dist_modes (int): number of modes n_local_modes (int): number of modes m_a (np.ndarray): _description_ n_dof_m (int): _description_ GBT_con (GBT_Con): _description_

GBT_con[‘couple’] - by GBT_con, coupled basis vs uncoupled basis for general B.C.

especially for non-simply supported B.C. 1: uncoupled basis, the basis will be block diagonal 2: coupled basis, the basis is fully spanned

Returns:
clas_gdlo (np.ndarray): array with the contributions of the modes in percentage

elem1: global, elem2: dist, elem3: local, elem4: other

S. Adany, Mar 10, 2004 Z. Li, June 2010

pycufsm.solve.cfsm.node_class(node_props: numpy.ndarray) → Tuple[int, int, int]

this routine determines how many nodes of the various types exist

notes:

node types in node_props: 1-corner, 2-edge, 3-sub sub-node numbers are the original one, of course

Args:
node_props (np.ndarray): array of [original node nr, new node nr, nr of adj elems,

node type]

Returns:

n_main_nodes (int): number of main nodes n_corner_nodes (int): number of corner nodes n_sub_nodes (int): number of sub-nodes

  1. Adany, Feb 09, 2004