void MAST::FirstOrderNewmarkTransientSolver:: _update_velocity(libMesh::NumericVector<Real>& vec) { const libMesh::NumericVector<Real> &sol = _system->get_vector("transient_solution_0"), &prev_sol = _system->get_vector("transient_solution_1"), &prev_vel = _system->get_vector("transient_velocity_1"); vec = sol; vec.add(-1., prev_sol); vec.scale(1./beta/dt); vec.add(-(1.-beta)/beta, prev_vel); vec.close(); }
bool MAST::NonlinearImplicitAssembly:: sensitivity_assemble (const libMesh::ParameterVector& parameters, const unsigned int i, libMesh::NumericVector<Real>& sensitivity_rhs) { libMesh::NonlinearImplicitSystem& nonlin_sys = dynamic_cast<libMesh::NonlinearImplicitSystem&>(_system->system()); sensitivity_rhs.zero(); // iterate over each element, initialize it and get the relevant // analysis quantities RealVectorX vec, sol; RealMatrixX mat; std::vector<libMesh::dof_id_type> dof_indices; const libMesh::DofMap& dof_map = nonlin_sys.get_dof_map(); std::auto_ptr<MAST::ElementBase> physics_elem; std::auto_ptr<libMesh::NumericVector<Real> > localized_solution; localized_solution.reset(_build_localized_vector(nonlin_sys, *nonlin_sys.solution).release()); // if a solution function is attached, initialize it if (_sol_function) _sol_function->init_for_system_and_solution(*_system, *nonlin_sys.solution); libMesh::MeshBase::const_element_iterator el = nonlin_sys.get_mesh().active_local_elements_begin(); const libMesh::MeshBase::const_element_iterator end_el = nonlin_sys.get_mesh().active_local_elements_end(); for ( ; el != end_el; ++el) { const libMesh::Elem* elem = *el; dof_map.dof_indices (elem, dof_indices); physics_elem.reset(_build_elem(*elem).release()); // get the solution unsigned int ndofs = (unsigned int)dof_indices.size(); sol.setZero(ndofs); vec.setZero(ndofs); mat.setZero(ndofs, ndofs); for (unsigned int i=0; i<dof_indices.size(); i++) sol(i) = (*localized_solution)(dof_indices[i]); physics_elem->sensitivity_param = _discipline->get_parameter(parameters[i]); physics_elem->set_solution(sol); if (_sol_function) physics_elem->attach_active_solution_function(*_sol_function); // perform the element level calculations _elem_sensitivity_calculations(*physics_elem, vec); physics_elem->detach_active_solution_function(); // copy to the libMesh matrix for further processing DenseRealVector v; MAST::copy(v, vec); // constrain the quantities to account for hanging dofs, // Dirichlet constraints, etc. nonlin_sys.get_dof_map().constrain_element_vector(v, dof_indices); // add to the global matrices sensitivity_rhs.add_vector(v, dof_indices); } // if a solution function is attached, initialize it if (_sol_function) _sol_function->clear(); sensitivity_rhs.close(); return true; }
void MAST::ComplexAssemblyBase:: residual_and_jacobian_blocked (const libMesh::NumericVector<Real>& X, libMesh::NumericVector<Real>& R, libMesh::SparseMatrix<Real>& J, MAST::Parameter* p) { libmesh_assert(_system); libmesh_assert(_discipline); libmesh_assert(_elem_ops); START_LOG("residual_and_jacobian()", "ComplexSolve"); MAST::NonlinearSystem& nonlin_sys = _system->system(); R.zero(); J.zero(); // iterate over each element, initialize it and get the relevant // analysis quantities RealVectorX sol; ComplexVectorX delta_sol, vec; ComplexMatrixX mat, dummy; // get the petsc vector and matrix objects Mat jac_bmat = dynamic_cast<libMesh::PetscMatrix<Real>&>(J).mat(); PetscInt ierr; std::vector<libMesh::dof_id_type> dof_indices; const libMesh::DofMap& dof_map = nonlin_sys.get_dof_map(); const std::vector<libMesh::dof_id_type>& send_list = nonlin_sys.get_dof_map().get_send_list(); std::unique_ptr<libMesh::NumericVector<Real> > localized_base_solution, localized_complex_sol(libMesh::NumericVector<Real>::build(nonlin_sys.comm()).release()); // prepare a send list for localization of the complex solution std::vector<libMesh::dof_id_type> complex_send_list(2*send_list.size()); for (unsigned int i=0; i<send_list.size(); i++) { complex_send_list[2*i ] = 2*send_list[i]; complex_send_list[2*i+1] = 2*send_list[i]+1; } localized_complex_sol->init(2*nonlin_sys.n_dofs(), 2*nonlin_sys.n_local_dofs(), complex_send_list, false, libMesh::GHOSTED); X.localize(*localized_complex_sol, complex_send_list); // localize the base solution, if it was provided if (_base_sol) localized_base_solution.reset(build_localized_vector(nonlin_sys, *_base_sol).release()); // if a solution function is attached, initialize it //if (_sol_function) // _sol_function->init( X); libMesh::MeshBase::const_element_iterator el = nonlin_sys.get_mesh().active_local_elements_begin(); const libMesh::MeshBase::const_element_iterator end_el = nonlin_sys.get_mesh().active_local_elements_end(); MAST::ComplexAssemblyElemOperations& ops = dynamic_cast<MAST::ComplexAssemblyElemOperations&>(*_elem_ops); for ( ; el != end_el; ++el) { const libMesh::Elem* elem = *el; dof_map.dof_indices (elem, dof_indices); ops.init(*elem); // get the solution unsigned int ndofs = (unsigned int)dof_indices.size(); sol.setZero(ndofs); delta_sol.setZero(ndofs); vec.setZero(ndofs); mat.setZero(ndofs, ndofs); // first set the velocity to be zero ops.set_elem_velocity(sol); // next, set the base solution, if provided if (_base_sol) for (unsigned int i=0; i<dof_indices.size(); i++) sol(i) = (*localized_base_solution)(dof_indices[i]); ops.set_elem_solution(sol); // set the value of the small-disturbance solution for (unsigned int i=0; i<dof_indices.size(); i++) { // get the complex block for this dof delta_sol(i) = Complex((*localized_complex_sol)(2*dof_indices[i]), (*localized_complex_sol)(2*dof_indices[i]+1)); } ops.set_elem_complex_solution(delta_sol); // if (_sol_function) // physics_elem->attach_active_solution_function(*_sol_function); // perform the element level calculations ops.elem_calculations(true, vec, mat); // if sensitivity was requested, then ask the element for sensitivity // of the residual if (p) { // set the sensitivity of complex sol to zero delta_sol.setZero(); ops.set_elem_complex_solution_sensitivity(delta_sol); vec.setZero(); ops.elem_sensitivity_calculations(*p, vec); } ops.clear_elem(); //physics_elem->detach_active_solution_function(); // extract the real or the imaginary part of the matrix/vector // The complex system of equations // (J_R + i J_I) (x_R + i x_I) + (r_R + i r_I) = 0 // is rewritten as // [ J_R -J_I] {x_R} + {r_R} = {0} // [ J_I J_R] {x_I} + {r_I} = {0} // DenseRealVector v_R, v_I; DenseRealMatrix m_R, m_I1, m_I2; std::vector<Real> vals(4); // copy the real part of the residual and Jacobian MAST::copy( m_R, mat.real()); MAST::copy(m_I1, mat.imag()); m_I1 *= -1.; // this is the -J_I component MAST::copy(m_I2, mat.imag()); // this is the J_I component MAST::copy( v_R, vec.real()); MAST::copy( v_I, vec.imag()); dof_map.constrain_element_matrix(m_R, dof_indices); dof_map.constrain_element_matrix(m_I1, dof_indices); dof_map.constrain_element_matrix(m_I2, dof_indices); dof_map.constrain_element_vector(v_R, dof_indices); dof_map.constrain_element_vector(v_I, dof_indices); for (unsigned int i=0; i<dof_indices.size(); i++) { R.add(2*dof_indices[i], v_R(i)); R.add(2*dof_indices[i]+1, v_I(i)); for (unsigned int j=0; j<dof_indices.size(); j++) { vals[0] = m_R (i,j); vals[1] = m_I1(i,j); vals[2] = m_I2(i,j); vals[3] = m_R (i,j); ierr = MatSetValuesBlocked(jac_bmat, 1, (PetscInt*)&dof_indices[i], 1, (PetscInt*)&dof_indices[j], &vals[0], ADD_VALUES); } } } // if a solution function is attached, clear it //if (_sol_function) // _sol_function->clear(); R.close(); J.close(); libMesh::out << "R: " << R.l2_norm() << std::endl; STOP_LOG("residual_and_jacobian()", "ComplexSolve"); }
void MAST::ComplexAssemblyBase:: residual_and_jacobian_field_split (const libMesh::NumericVector<Real>& X_R, const libMesh::NumericVector<Real>& X_I, libMesh::NumericVector<Real>& R_R, libMesh::NumericVector<Real>& R_I, libMesh::SparseMatrix<Real>& J_R, libMesh::SparseMatrix<Real>& J_I) { libmesh_assert(_system); libmesh_assert(_discipline); libmesh_assert(_elem_ops); MAST::NonlinearSystem& nonlin_sys = _system->system(); R_R.zero(); R_I.zero(); J_R.zero(); J_I.zero(); // iterate over each element, initialize it and get the relevant // analysis quantities RealVectorX sol, vec_re; RealMatrixX mat_re; ComplexVectorX delta_sol, vec; ComplexMatrixX mat; std::vector<libMesh::dof_id_type> dof_indices; const libMesh::DofMap& dof_map = _system->system().get_dof_map(); std::unique_ptr<libMesh::NumericVector<Real> > localized_base_solution, localized_real_solution, localized_imag_solution; // localize the base solution, if it was provided if (_base_sol) localized_base_solution.reset(build_localized_vector(nonlin_sys, *_base_sol).release()); // localize sol to real vector localized_real_solution.reset(build_localized_vector(nonlin_sys, X_R).release()); // localize sol to imag vector localized_imag_solution.reset(build_localized_vector(nonlin_sys, X_I).release()); // if a solution function is attached, initialize it //if (_sol_function) // _sol_function->init( X); libMesh::MeshBase::const_element_iterator el = nonlin_sys.get_mesh().active_local_elements_begin(); const libMesh::MeshBase::const_element_iterator end_el = nonlin_sys.get_mesh().active_local_elements_end(); MAST::ComplexAssemblyElemOperations& ops = dynamic_cast<MAST::ComplexAssemblyElemOperations&>(*_elem_ops); for ( ; el != end_el; ++el) { const libMesh::Elem* elem = *el; dof_map.dof_indices (elem, dof_indices); ops.init(*elem); // get the solution unsigned int ndofs = (unsigned int)dof_indices.size(); sol.setZero(ndofs); delta_sol.setZero(ndofs); vec.setZero(ndofs); mat.setZero(ndofs, ndofs); // first set the velocity to be zero ops.set_elem_velocity(sol); // next, set the base solution, if provided if (_base_sol) for (unsigned int i=0; i<dof_indices.size(); i++) sol(i) = (*localized_base_solution)(dof_indices[i]); ops.set_elem_solution(sol); // set the value of the small-disturbance solution for (unsigned int i=0; i<dof_indices.size(); i++) delta_sol(i) = Complex((*localized_real_solution)(dof_indices[i]), (*localized_imag_solution)(dof_indices[i])); ops.set_elem_complex_solution(delta_sol); // if (_sol_function) // physics_elem->attach_active_solution_function(*_sol_function); // perform the element level calculations ops.elem_calculations(true, vec, mat); ops.clear_elem(); vec *= -1.; //physics_elem->detach_active_solution_function(); // extract the real or the imaginary part of the matrix/vector // The complex system of equations // (J_R + i J_I) (x_R + i x_I) + (r_R + i r_I) = 0 // is rewritten as // [ J_R -J_I] {x_R} + {r_R} = {0} // [ J_I J_R] {x_I} + {r_I} = {0} // DenseRealVector v; DenseRealMatrix m; // copy the real part of the residual and Jacobian MAST::copy(v, vec.real()); MAST::copy(m, mat.real()); dof_map.constrain_element_matrix_and_vector(m, v, dof_indices); R_R.add_vector(v, dof_indices); J_R.add_matrix(m, dof_indices); // copy the imag part of the residual and Jacobian v.zero(); m.zero(); MAST::copy(v, vec.imag()); MAST::copy(m, mat.imag()); dof_map.constrain_element_matrix_and_vector(m, v, dof_indices); R_I.add_vector(v, dof_indices); J_I.add_matrix(m, dof_indices); } // if a solution function is attached, clear it //if (_sol_function) // _sol_function->clear(); R_R.close(); R_I.close(); J_R.close(); J_I.close(); libMesh::out << "R_R: " << R_R.l2_norm() << " R_I: " << R_I.l2_norm() << std::endl; }