void
MAST::StructuralElement2D::
initialize_von_karman_strain_operator_sensitivity(const unsigned int qp,
RealMatrixX &vk_dwdxi_mat_sens) {
const std::vector<std::vector<libMesh::RealVectorValue> >& dphi = _fe->get_dphi();
const unsigned int n_phi = (unsigned int)dphi.size();
libmesh_assert_equal_to(vk_dwdxi_mat_sens.rows(), 3);
libmesh_assert_equal_to(vk_dwdxi_mat_sens.cols(), 2);
Real dw=0.;
vk_dwdxi_mat_sens.setConstant(0.);
RealVectorX phi_vec = RealVectorX::Zero(n_phi);
dw = 0.;
for ( unsigned int i_nd=0; i_nd<n_phi; i_nd++ ) {
phi_vec(i_nd) = dphi[i_nd][qp](0); // dphi/dx
dw += phi_vec(i_nd)*_local_sol_sens(2*n_phi+i_nd); // dw/dx
}
vk_dwdxi_mat_sens(0, 0) = dw; // epsilon-xx : dw/dx
vk_dwdxi_mat_sens(2, 1) = dw; // gamma-xy : dw/dx
dw = 0.;
for ( unsigned int i_nd=0; i_nd<n_phi; i_nd++ ) {
phi_vec(i_nd) = dphi[i_nd][qp](1); // dphi/dy
dw += phi_vec(i_nd)*_local_sol_sens(2*n_phi+i_nd); // dw/dy
}
vk_dwdxi_mat_sens(1, 1) = dw; // epsilon-yy : dw/dy
vk_dwdxi_mat_sens(2, 0) = dw; // gamma-xy : dw/dy
}
void
MAST::StructuralElement2D::_convert_prestress_B_mat_to_vector(const RealMatrixX& mat,
RealVectorX& vec) const {
libmesh_assert_equal_to(mat.rows(), 2);
libmesh_assert_equal_to(mat.cols(), 2);
vec = RealVectorX::Zero(3);
vec(0) = mat(0,0); // sigma x
vec(1) = mat(1,1); // sigma y
vec(2) = mat(0,1); // tau xy
}
virtual void operator() (const libMesh::Point& p,
const Real t,
RealMatrixX& m) const {
// add the values of each matrix to get the integrated value
RealMatrixX mi;
for (unsigned int i=0; i<_layer_mats.size(); i++) {
(*_layer_mats[i])(p, t, mi);
// use the size of the layer matrix to resize the output
// all other layers should return the same sized matrices
if (i==0)
m = RealMatrixX::Zero(mi.rows(), mi.cols());
m += mi;
}
}
virtual void derivative ( const MAST::FunctionBase& f,
const libMesh::Point& p,
const Real t,
RealMatrixX& m) const {
// add the values of each matrix to get the integrated value
RealMatrixX mi;
m = RealMatrixX::Zero(2,2);
for (unsigned int i=0; i<_layer_mats.size(); i++) {
_layer_mats[i]->derivative( f, p, t, mi);
// use the size of the layer matrix to resize the output
// all other layers should return the same sized matrices
if (i==0)
m = RealMatrixX::Zero(mi.rows(), mi.cols());
m += mi;
}
}
void
MAST::StructuralElement2D::
initialize_von_karman_strain_operator(const unsigned int qp,
RealVectorX& vk_strain,
RealMatrixX& vk_dwdxi_mat,
MAST::FEMOperatorMatrix& Bmat_vk) {
const std::vector<std::vector<libMesh::RealVectorValue> >& dphi = _fe->get_dphi();
const unsigned int n_phi = (unsigned int)dphi.size();
libmesh_assert_equal_to(vk_strain.size(), 3);
libmesh_assert_equal_to(vk_dwdxi_mat.rows(), 3);
libmesh_assert_equal_to(vk_dwdxi_mat.cols(), 2);
libmesh_assert_equal_to(Bmat_vk.m(), 2);
libmesh_assert_equal_to(Bmat_vk.n(), 6*n_phi);
Real dw=0.;
vk_strain.setConstant(0.);
vk_dwdxi_mat.setConstant(0.);
RealVectorX phi_vec = RealVectorX::Zero(n_phi);
dw = 0.;
for ( unsigned int i_nd=0; i_nd<n_phi; i_nd++ ) {
phi_vec(i_nd) = dphi[i_nd][qp](0); // dphi/dx
dw += phi_vec(i_nd)*_local_sol(2*n_phi+i_nd); // dw/dx
}
Bmat_vk.set_shape_function(0, 2, phi_vec); // dw/dx
vk_dwdxi_mat(0, 0) = dw; // epsilon-xx : dw/dx
vk_dwdxi_mat(2, 1) = dw; // gamma-xy : dw/dx
vk_strain(0) = 0.5*dw*dw; // 1/2 * (dw/dx)^2
vk_strain(2) = dw; // (dw/dx)*(dw/dy) only dw/dx is provided here
dw = 0.;
for ( unsigned int i_nd=0; i_nd<n_phi; i_nd++ ) {
phi_vec(i_nd) = dphi[i_nd][qp](1); // dphi/dy
dw += phi_vec(i_nd)*_local_sol(2*n_phi+i_nd); // dw/dy
}
Bmat_vk.set_shape_function(1, 2, phi_vec); // dw/dy
vk_dwdxi_mat(1, 1) = dw; // epsilon-yy : dw/dy
vk_dwdxi_mat(2, 0) = dw; // gamma-xy : dw/dy
vk_strain(1) = 0.5*dw*dw; // 1/2 * (dw/dy)^2
vk_strain(2) *= dw; // (dw/dx)*(dw/dy)
}
void
MAST::TimeDomainFlutterRoot::init(const Real ref_val, const Real b_ref,
const Complex num,
const Complex den,
const RealMatrixX& Bmat,
const ComplexVectorX& evec_right,
const ComplexVectorX& evec_left)
{
V = ref_val;
if (std::abs(den) > 0.)
{
root = num/den;
if (std::real(root) > 0.)
{
V = sqrt(1./std::real(root));
g = std::imag(root)/std::real(root);
omega = k_red*V/b_ref;
if_nonphysical_root = false;
}
else
{
V = 0.;
g = 0.;
omega = 0.;
if_nonphysical_root = true;
}
}
// calculate the modal participation vector
const unsigned int nvals = (int)Bmat.rows();
eig_vec_right = evec_right;
eig_vec_left = evec_left;
ComplexVectorX k_q;
k_q = Bmat * evec_right;
modal_participation.resize(nvals, 1);
for (unsigned int i=0; i<nvals; i++)
modal_participation(i) = std::abs(std::conj(evec_right(i)) * k_q(i));
modal_participation *= (1./modal_participation.sum());
}
void
MAST::StructuralElement2D::
_linearized_geometric_stiffness_sensitivity_with_static_solution
(const unsigned int n2,
const unsigned int qp,
const std::vector<Real>& JxW,
RealMatrixX& local_jac,
FEMOperatorMatrix& Bmat_mem,
FEMOperatorMatrix& Bmat_bend,
FEMOperatorMatrix& Bmat_vk,
RealMatrixX& stress_l,
RealMatrixX& vk_dwdxi_mat,
RealMatrixX& material_A_mat,
RealMatrixX& material_B_mat,
RealVectorX& vec1_n1,
RealVectorX& vec2_n1,
RealMatrixX& mat1_n1n2,
RealMatrixX& mat2_n2n2,
RealMatrixX& mat3)
{
this->initialize_direct_strain_operator(qp, Bmat_mem);
_bending_operator->initialize_bending_strain_operator(qp, Bmat_bend);
// first handle constant throught the thickness stresses: membrane and vonKarman
Bmat_mem.vector_mult(vec1_n1, _local_sol_sens);
vec2_n1 = material_A_mat * vec1_n1; // linear direct stress
// copy the stress values to a matrix
stress_l(0,0) = vec2_n1(0); // sigma_xx
stress_l(0,1) = vec2_n1(2); // sigma_xy
stress_l(1,0) = vec2_n1(2); // sigma_yx
stress_l(1,1) = vec2_n1(1); // sigma_yy
// get the von Karman operator matrix
this->initialize_von_karman_strain_operator(qp,
vec2_n1, // epsilon_vk
vk_dwdxi_mat,
Bmat_vk);
// sensitivity of the vk_dwdxi matrix due to solution sensitivity
this->initialize_von_karman_strain_operator_sensitivity(qp,
vk_dwdxi_mat);
// membrane - vk
mat3 = RealMatrixX::Zero(vk_dwdxi_mat.rows(), n2);
Bmat_vk.left_multiply(mat3, vk_dwdxi_mat);
mat3 = material_A_mat * mat3;
Bmat_mem.right_multiply_transpose(mat2_n2n2, mat3);
local_jac += JxW[qp] * mat2_n2n2;
// vk - membrane
Bmat_mem.left_multiply(mat1_n1n2, material_A_mat);
mat3 = vk_dwdxi_mat.transpose() * mat1_n1n2;
Bmat_vk.right_multiply_transpose(mat2_n2n2, mat3);
local_jac += JxW[qp] * mat2_n2n2;
// vk - vk: first order term
mat3 = RealMatrixX::Zero(2, n2);
Bmat_vk.left_multiply(mat3, stress_l);
Bmat_vk.right_multiply_transpose(mat2_n2n2, mat3);
local_jac += JxW[qp] * mat2_n2n2;
// bending - vk
mat3 = RealMatrixX::Zero(vk_dwdxi_mat.rows(), n2);
Bmat_vk.left_multiply(mat3, vk_dwdxi_mat);
mat3 = material_B_mat.transpose() * mat3;
Bmat_bend.right_multiply_transpose(mat2_n2n2, mat3);
local_jac += JxW[qp] * mat2_n2n2;
// vk - bending
Bmat_bend.left_multiply(mat1_n1n2, material_B_mat);
mat3 = vk_dwdxi_mat.transpose() * mat1_n1n2;
Bmat_vk.right_multiply_transpose(mat2_n2n2, mat3);
local_jac += JxW[qp] * mat2_n2n2;
}
void
MAST::StructuralElement2D::_internal_residual_operation
(bool if_bending,
bool if_vk,
const unsigned int n2,
const unsigned int qp,
const std::vector<Real>& JxW,
bool request_jacobian,
bool if_ignore_ho_jac,
RealVectorX& local_f,
RealMatrixX& local_jac,
FEMOperatorMatrix& Bmat_mem,
FEMOperatorMatrix& Bmat_bend,
FEMOperatorMatrix& Bmat_vk,
RealMatrixX& stress,
RealMatrixX& stress_l,
RealMatrixX& vk_dwdxi_mat,
RealMatrixX& material_A_mat,
RealMatrixX& material_B_mat,
RealMatrixX& material_D_mat,
RealVectorX& vec1_n1,
RealVectorX& vec2_n1,
RealVectorX& vec3_n2,
RealVectorX& vec4_2,
RealVectorX& vec5_2,
RealMatrixX& mat1_n1n2,
RealMatrixX& mat2_n2n2,
RealMatrixX& mat3,
RealMatrixX& mat4_2n2)
{
this->initialize_direct_strain_operator(qp, Bmat_mem);
// first handle constant throught the thickness stresses: membrane and vonKarman
Bmat_mem.vector_mult(vec1_n1, _local_sol);
vec2_n1 = material_A_mat * vec1_n1; // linear direct stress
// copy the stress values to a matrix
stress_l(0,0) = vec2_n1(0); // sigma_xx
stress_l(0,1) = vec2_n1(2); // sigma_xy
stress_l(1,0) = vec2_n1(2); // sigma_yx
stress_l(1,1) = vec2_n1(1); // sigma_yy
stress = stress_l;
// get the bending strain operator
vec2_n1.setConstant(0.); // used to store vk strain, if applicable
if (if_bending) {
_bending_operator->initialize_bending_strain_operator(qp, Bmat_bend);
Bmat_bend.vector_mult(vec2_n1, _local_sol);
vec1_n1 = material_B_mat * vec2_n1;
stress_l(0,0) += vec2_n1(0); // sigma_xx
stress_l(0,1) += vec2_n1(2); // sigma_xy
stress_l(1,0) += vec2_n1(2); // sigma_yx
stress_l(1,1) += vec2_n1(1); // sigma_yy
stress(0,0) += vec2_n1(0); // sigma_xx
stress(0,1) += vec2_n1(2); // sigma_xy
stress(1,0) += vec2_n1(2); // sigma_yx
stress(1,1) += vec2_n1(1); // sigma_yy
if (if_vk) { // get the vonKarman strain operator if needed
this->initialize_von_karman_strain_operator(qp,
vec2_n1, // epsilon_vk
vk_dwdxi_mat,
Bmat_vk);
vec1_n1 = material_A_mat * vec2_n1; // stress
stress(0,0) += vec1_n1(0); // sigma_xx
stress(0,1) += vec1_n1(2); // sigma_xy
stress(1,0) += vec1_n1(2); // sigma_yx
stress(1,1) += vec1_n1(1); // sigma_yy
}
}
// add the linear and nonlinear direct strains
Bmat_mem.vector_mult(vec1_n1, _local_sol);
vec2_n1 += vec1_n1; // epsilon_mem + epsilon_vk
// copy the total integrated stress to the vector
vec1_n1(0) = stress(0,0);
vec1_n1(1) = stress(1,1);
vec1_n1(2) = stress(0,1);
// now the internal force vector
// this includes the membrane strain operator with all A and B material operators
Bmat_mem.vector_mult_transpose(vec3_n2, vec1_n1);
local_f += JxW[qp] * vec3_n2;
if (if_bending) {
if (if_vk) {
// von Karman strain
vec4_2 = vk_dwdxi_mat.transpose() * vec1_n1;
Bmat_vk.vector_mult_transpose(vec3_n2, vec4_2);
local_f += JxW[qp] * vec3_n2;
}
// now coupling with the bending strain
// B_bend^T [B] B_mem
vec1_n1 = material_B_mat * vec2_n1;
Bmat_bend.vector_mult_transpose(vec3_n2, vec1_n1);
local_f += JxW[qp] * vec3_n2;
// now bending stress
Bmat_bend.vector_mult(vec2_n1, _local_sol);
vec1_n1 = material_D_mat * vec2_n1;
Bmat_bend.vector_mult_transpose(vec3_n2, vec1_n1);
local_f += JxW[qp] * vec3_n2;
}
if (request_jacobian) {
// membrane - membrane
Bmat_mem.left_multiply(mat1_n1n2, material_A_mat);
Bmat_mem.right_multiply_transpose(mat2_n2n2, mat1_n1n2);
local_jac += JxW[qp] * mat2_n2n2;
if (if_bending) {
if (if_vk) {
// membrane - vk
mat3 = RealMatrixX::Zero(vk_dwdxi_mat.rows(), n2);
Bmat_vk.left_multiply(mat3, vk_dwdxi_mat);
mat3 = material_A_mat * mat3;
Bmat_mem.right_multiply_transpose(mat2_n2n2, mat3);
local_jac += JxW[qp] * mat2_n2n2;
// vk - membrane
Bmat_mem.left_multiply(mat1_n1n2, material_A_mat);
mat3 = vk_dwdxi_mat.transpose() * mat1_n1n2;
Bmat_vk.right_multiply_transpose(mat2_n2n2, mat3);
local_jac += JxW[qp] * mat2_n2n2;
// if only the first order term of the Jacobian is needed, for
// example for linearized buckling analysis, then the linear
// stress combined with the variation of the von Karman strain
// is included. Otherwise, all terms are included
if (if_ignore_ho_jac) {
// vk - vk: first order term
mat3 = RealMatrixX::Zero(2, n2);
Bmat_vk.left_multiply(mat3, stress_l);
Bmat_vk.right_multiply_transpose(mat2_n2n2, mat3);
local_jac += JxW[qp] * mat2_n2n2;
}
else {
// vk - vk
mat3 = RealMatrixX::Zero(2, n2);
Bmat_vk.left_multiply(mat3, stress);
Bmat_vk.right_multiply_transpose(mat2_n2n2, mat3);
local_jac += JxW[qp] * mat2_n2n2;
mat3 = RealMatrixX::Zero(vk_dwdxi_mat.rows(), n2);
Bmat_vk.left_multiply(mat3, vk_dwdxi_mat);
mat3 = vk_dwdxi_mat.transpose() * material_A_mat * mat3;
Bmat_vk.right_multiply_transpose(mat2_n2n2, mat3);
local_jac += JxW[qp] * mat2_n2n2;
}
// bending - vk
mat3 = RealMatrixX::Zero(vk_dwdxi_mat.rows(), n2);
Bmat_vk.left_multiply(mat3, vk_dwdxi_mat);
mat3 = material_B_mat.transpose() * mat3;
Bmat_bend.right_multiply_transpose(mat2_n2n2, mat3);
local_jac += JxW[qp] * mat2_n2n2;
// vk - bending
Bmat_bend.left_multiply(mat1_n1n2, material_B_mat);
mat3 = vk_dwdxi_mat.transpose() * mat1_n1n2;
Bmat_vk.right_multiply_transpose(mat2_n2n2, mat3);
local_jac += JxW[qp] * mat2_n2n2;
}
// bending - membrane
Bmat_mem.left_multiply(mat1_n1n2, material_B_mat);
Bmat_bend.right_multiply_transpose(mat2_n2n2, mat1_n1n2);
local_jac += JxW[qp] * mat2_n2n2;
// membrane - bending
Bmat_bend.left_multiply(mat1_n1n2, material_B_mat);
Bmat_mem.right_multiply_transpose(mat2_n2n2, mat1_n1n2);
local_jac += JxW[qp] * mat2_n2n2;
// bending - bending
Bmat_bend.left_multiply(mat1_n1n2, material_D_mat);
Bmat_bend.right_multiply_transpose(mat2_n2n2, mat1_n1n2);
local_jac += JxW[qp] * mat2_n2n2;
}
}
}
void
MAST::LAPACK_DGGEV::compute(const RealMatrixX &A,
const RealMatrixX &B,
bool computeEigenvectors) {
libmesh_assert(A.cols() == A.rows() &&
B.cols() == A.rows() &&
B.cols() == B.rows());
_A = A;
_B = B;
RealMatrixX
Amat = A,
Bmat = B;
int n = (int)A.cols();
char L='N',R='N';
if (computeEigenvectors) {
L = 'V'; R = 'V';
VL.setZero(n, n);
VR.setZero(n, n);
}
int
lwork=16*n;
info_val=-1;
alpha.setZero(n);
beta.setZero(n);
RealVectorX
work,
aval_r,
aval_i,
bval;
RealMatrixX
vecl,
vecr;
work.setZero(lwork);
aval_r.setZero(n);
aval_i.setZero(n);
bval.setZero(n);
vecl.setZero(n,n);
vecr.setZero(n,n);
Real
*a_vals = Amat.data(),
*b_vals = Bmat.data(),
*alpha_r_v = aval_r.data(),
*alpha_i_v = aval_i.data(),
*beta_v = bval.data(),
*vecl_v = vecl.data(),
*vecr_v = vecr.data(),
*work_v = work.data();
dggev_(&L, &R, &n,
&(a_vals[0]), &n,
&(b_vals[0]), &n,
&(alpha_r_v[0]), &(alpha_i_v[0]), &(beta_v[0]),
&(vecl_v[0]), &n, &(vecr_v[0]), &n,
&(work_v[0]), &lwork,
&info_val);
// now sort the eigenvalues for complex conjugates
unsigned int n_located = 0;
while (n_located < n) {
// if the imaginary part of the eigenvalue is non-zero, it is a
// complex conjugate
if (aval_i(n_located) != 0.) { // complex conjugate
alpha( n_located) = std::complex<double>(aval_r(n_located), aval_i(n_located));
alpha(1+n_located) = std::complex<double>(aval_r(n_located), -aval_i(n_located));
beta ( n_located) = bval(n_located);
beta (1+n_located) = bval(n_located);
// copy the eigenvectors if they were requested
if (computeEigenvectors) {
std::complex<double> iota = std::complex<double>(0, 1.);
VL.col( n_located) = (vecl.col( n_located).cast<Complex>() +
vecl.col(1+n_located).cast<Complex>() * iota);
VL.col(1+n_located) = (vecl.col( n_located).cast<Complex>() -
vecl.col(1+n_located).cast<Complex>() * iota);
VR.col( n_located) = (vecr.col( n_located).cast<Complex>() +
vecr.col(1+n_located).cast<Complex>() * iota);
VR.col(1+n_located) = (vecr.col( n_located).cast<Complex>() -
vecr.col(1+n_located).cast<Complex>() * iota);
}
// two complex conjugate roots were found
n_located +=2;
}
else {
alpha( n_located) = std::complex<double>(aval_r(n_located), 0.);
beta ( n_located) = bval(n_located);
// copy the eigenvectors if they were requested
if (computeEigenvectors) {
VL.col(n_located) = vecl.col(n_located).cast<Complex>();
VR.col(n_located) = vecr.col(n_located).cast<Complex>();
}
// only one real root was found
n_located++;
}
}
if (info_val != 0)
libMesh::out
<< "Warning!! DGGEV returned with nonzero info = "
<< info_val << std::endl;
}
