// @HEADER // ***************************************************************************** // Rapid Optimization Library (ROL) Package // // Copyright 2014 NTESS and the ROL contributors. // SPDX-License-Identifier: BSD-3-Clause // ***************************************************************************** // @HEADER /*! \file obj.hpp \brief Provides the interface for local (cell-based) objective function computations. */ #ifndef PDEOPT_QOI_NAVIERSTOKES_HPP #define PDEOPT_QOI_NAVIERSTOKES_HPP #include "../../TOOLS/qoi.hpp" #include "pde_navier-stokes.hpp" #include "impermiability.hpp" template class QoI_Power_NavierStokes : public QoI { private: const ROL::Ptr> feVel_; const ROL::Ptr> fePrs_; const ROL::Ptr> feCtrl_; const ROL::Ptr fieldInfo_; const ROL::Ptr fieldInfoCtrl_; ROL::Ptr> imp_; Real viscosity_; public: QoI_Power_NavierStokes(Teuchos::ParameterList &list, const ROL::Ptr> &feVel, const ROL::Ptr> &fePrs, const ROL::Ptr> &feCtrl, const ROL::Ptr &fieldInfo, const ROL::Ptr &fieldInfoCtrl) : feVel_(feVel), fePrs_(fePrs), feCtrl_(feCtrl), fieldInfo_(fieldInfo), fieldInfoCtrl_(fieldInfoCtrl) { viscosity_ = list.sublist("Problem").get("Viscosity",5e-3); imp_ = ROL::makePtr>(list); } Real value(ROL::Ptr> & val, const ROL::Ptr> & u_coeff, const ROL::Ptr> & z_coeff = ROL::nullPtr, const ROL::Ptr> & z_param = ROL::nullPtr) { // Get relevant dimensions const int c = feVel_->gradN()->dimension(0); const int p = feVel_->gradN()->dimension(2); const int d = feVel_->gradN()->dimension(3); // Initialize output val val = ROL::makePtr>(c); // Get components of the control std::vector>> U, Z; FieldUtils::splitFieldCoeff(U, u_coeff, fieldInfo_); FieldUtils::splitFieldCoeff(Z, z_coeff, fieldInfoCtrl_); // Evaluate on FE basis ROL::Ptr> alpha, Zval, Uval, aUval, Ugrad, nUgrad; Zval = ROL::makePtr>(c, p); alpha = ROL::makePtr>(c, p); Uval = ROL::makePtr>(c, p); aUval = ROL::makePtr>(c, p); Ugrad = ROL::makePtr>(c, p, d); nUgrad = ROL::makePtr>(c, p, d); feCtrl_->evaluateValue(Zval, Z[0]); imp_->compute(alpha, Zval, feVel_->cubPts(), 0); for (int i = 0; i < d; ++i) { Uval->initialize(); Ugrad->initialize(); aUval->initialize(); nUgrad->initialize(); // Evaluate on FE basis feVel_->evaluateValue(Uval, U[i]); feVel_->evaluateGradient(Ugrad, U[i]); // Scale Intrepid::FunctionSpaceTools::scalarMultiplyDataData(*aUval, *alpha, *Uval); Intrepid::RealSpaceTools::scale(*nUgrad, *Ugrad, viscosity_); // Integrate feVel_->computeIntegral(val, nUgrad, Ugrad, true); feVel_->computeIntegral(val, aUval, Uval, true); } Intrepid::RealSpaceTools::scale(*val, static_cast(0.5)); return static_cast(0); } void gradient_1(ROL::Ptr> & grad, const ROL::Ptr> & u_coeff, const ROL::Ptr> & z_coeff = ROL::nullPtr, const ROL::Ptr> & z_param = ROL::nullPtr) { // Get relevant dimensions const int c = feVel_->gradN()->dimension(0); const int fv = feVel_->gradN()->dimension(1); const int fp = fePrs_->gradN()->dimension(1); const int p = feVel_->gradN()->dimension(2); const int d = feVel_->gradN()->dimension(3); // Initialize output grad std::vector>> G; G.resize(fieldInfo_->numFields); for (int i = 0; i < d; ++i) { G[i] = ROL::makePtr>(c, fv); } G[d] = ROL::makePtr>(c, fp); // Get components of the control std::vector>> U, Z; FieldUtils::splitFieldCoeff(U, u_coeff, fieldInfo_); FieldUtils::splitFieldCoeff(Z, z_coeff, fieldInfoCtrl_); // Create storage ROL::Ptr> Zval, alpha, Uval, aUval, Ugrad; Zval = ROL::makePtr>(c, p); alpha = ROL::makePtr>(c, p); Uval = ROL::makePtr>(c, p); aUval = ROL::makePtr>(c, p); Ugrad = ROL::makePtr>(c, p, d); feCtrl_->evaluateValue(Zval, Z[0]); imp_->compute(alpha, Zval, feVel_->cubPts(), 0); for (int i = 0; i < d; ++i) { Uval->initialize(); Ugrad->initialize(); aUval->initialize(); // Evaluate on FE basis feVel_->evaluateValue(Uval, U[i]); feVel_->evaluateGradient(Ugrad, U[i]); // Scale Intrepid::FunctionSpaceTools::scalarMultiplyDataData(*aUval, *alpha, *Uval); Intrepid::RealSpaceTools::scale(*Ugrad, viscosity_); // Integrate Intrepid::FunctionSpaceTools::integrate(*G[i], *Ugrad, *(feVel_->gradNdetJ()), Intrepid::COMP_CPP, false); Intrepid::FunctionSpaceTools::integrate(*G[i], *aUval, *(feVel_->NdetJ()), Intrepid::COMP_CPP, true); } FieldUtils::combineFieldCoeff(grad, G, fieldInfo_); } void gradient_2(ROL::Ptr> & grad, const ROL::Ptr> & u_coeff, const ROL::Ptr> & z_coeff = ROL::nullPtr, const ROL::Ptr> & z_param = ROL::nullPtr) { // Get relevant dimensions const int c = feVel_->gradN()->dimension(0); const int fc = feCtrl_->gradN()->dimension(1); const int p = feVel_->gradN()->dimension(2); const int d = feVel_->gradN()->dimension(3); // Initialize output grad std::vector>> G; G.resize(fieldInfoCtrl_->numFields); G[0] = ROL::makePtr>(c, fc); // Get components of the control std::vector>> U, Z; FieldUtils::splitFieldCoeff(U, u_coeff, fieldInfo_); FieldUtils::splitFieldCoeff(Z, z_coeff, fieldInfoCtrl_); // Create storage ROL::Ptr> Zval, alpha, Uval, aUval, aU2val; Zval = ROL::makePtr>(c, p); alpha = ROL::makePtr>(c, p); Uval = ROL::makePtr>(c, p); aUval = ROL::makePtr>(c, p); aU2val = ROL::makePtr>(c, p); feCtrl_->evaluateValue(Zval, Z[0]); imp_->compute(alpha, Zval, feVel_->cubPts(), 1); for (int i = 0; i < d; ++i) { Uval->initialize(); aUval->initialize(); aU2val->initialize(); // Evaluate on FE basis feVel_->evaluateValue(Uval, U[i]); // Scale Intrepid::FunctionSpaceTools::scalarMultiplyDataData(*aUval, *alpha, *Uval); Intrepid::FunctionSpaceTools::scalarMultiplyDataData(*aU2val, *aUval, *Uval); // Integrate Intrepid::FunctionSpaceTools::integrate(*G[0], *aU2val, *(feCtrl_->NdetJ()), Intrepid::COMP_CPP, true); } Intrepid::RealSpaceTools::scale(*G[0], static_cast(0.5)); FieldUtils::combineFieldCoeff(grad, G, fieldInfoCtrl_); } void HessVec_11(ROL::Ptr> & hess, const ROL::Ptr> & v_coeff, const ROL::Ptr> & u_coeff, const ROL::Ptr> & z_coeff = ROL::nullPtr, const ROL::Ptr> & z_param = ROL::nullPtr) { // Get relevant dimensions const int c = feVel_->gradN()->dimension(0); const int fv = feVel_->gradN()->dimension(1); const int fp = fePrs_->gradN()->dimension(1); const int p = feVel_->gradN()->dimension(2); const int d = feVel_->gradN()->dimension(3); // Initialize output grad std::vector>> H; H.resize(fieldInfo_->numFields); for (int i = 0; i < d; ++i) { H[i] = ROL::makePtr>(c, fv); } H[d] = ROL::makePtr>(c, fp); // Get components of the control std::vector>> V, Z; FieldUtils::splitFieldCoeff(V, v_coeff, fieldInfo_); FieldUtils::splitFieldCoeff(Z, z_coeff, fieldInfoCtrl_); // Create storage ROL::Ptr> Zval, alpha, Vval, Vgrad, aVval; Zval = ROL::makePtr>(c, p); alpha = ROL::makePtr>(c, p); Vval = ROL::makePtr>(c, p); aVval = ROL::makePtr>(c, p); Vgrad = ROL::makePtr>(c, p, d); feCtrl_->evaluateValue(Zval, Z[0]); imp_->compute(alpha, Zval, feVel_->cubPts(), 0); for (int i = 0; i < d; ++i) { Vval->initialize(); Vgrad->initialize(); aVval->initialize(); // Evaluate on FE basis feVel_->evaluateValue(Vval, V[i]); feVel_->evaluateGradient(Vgrad, V[i]); // Scale Intrepid::FunctionSpaceTools::scalarMultiplyDataData(*aVval, *alpha, *Vval); Intrepid::RealSpaceTools::scale(*Vgrad, viscosity_); // Integrate Intrepid::FunctionSpaceTools::integrate(*H[i], *Vgrad, *(feVel_->gradNdetJ()), Intrepid::COMP_CPP, false); Intrepid::FunctionSpaceTools::integrate(*H[i], *aVval, *(feVel_->NdetJ()), Intrepid::COMP_CPP, true); } FieldUtils::combineFieldCoeff(hess, H, fieldInfo_); } void HessVec_12(ROL::Ptr> & hess, const ROL::Ptr> & v_coeff, const ROL::Ptr> & u_coeff, const ROL::Ptr> & z_coeff = ROL::nullPtr, const ROL::Ptr> & z_param = ROL::nullPtr) { // Get relevant dimensions const int c = feVel_->gradN()->dimension(0); const int fv = feVel_->gradN()->dimension(1); const int fp = fePrs_->gradN()->dimension(1); const int p = feVel_->gradN()->dimension(2); const int d = feVel_->gradN()->dimension(3); // Initialize output grad std::vector>> H; H.resize(fieldInfo_->numFields); for (int i = 0; i < d; ++i) { H[i] = ROL::makePtr>(c, fv); } H[d] = ROL::makePtr>(c, fp); // Get components of the control std::vector>> V, U, Z; FieldUtils::splitFieldCoeff(V, v_coeff, fieldInfoCtrl_); FieldUtils::splitFieldCoeff(U, u_coeff, fieldInfo_); FieldUtils::splitFieldCoeff(Z, z_coeff, fieldInfoCtrl_); // Create storage ROL::Ptr> Zval, alpha, Uval, aUval, Vval, aVval; Zval = ROL::makePtr>(c, p); alpha = ROL::makePtr>(c, p); Uval = ROL::makePtr>(c, p); aUval = ROL::makePtr>(c, p); Vval = ROL::makePtr>(c, p); aVval = ROL::makePtr>(c, p); feCtrl_->evaluateValue(Vval, V[0]); feCtrl_->evaluateValue(Zval, Z[0]); imp_->compute(alpha, Zval, feVel_->cubPts(), 1); Intrepid::FunctionSpaceTools::scalarMultiplyDataData(*aVval, *alpha, *Vval); for (int i = 0; i < d; ++i) { Uval->initialize(); aUval->initialize(); // Evaluate on FE basis feVel_->evaluateValue(Uval, U[i]); // Scale Intrepid::FunctionSpaceTools::scalarMultiplyDataData(*aUval, *aVval, *Uval); // Integrate Intrepid::FunctionSpaceTools::integrate(*H[i], *aUval, *(feVel_->NdetJ()), Intrepid::COMP_CPP, false); } FieldUtils::combineFieldCoeff(hess, H, fieldInfo_); } void HessVec_21(ROL::Ptr> & hess, const ROL::Ptr> & v_coeff, const ROL::Ptr> & u_coeff, const ROL::Ptr> & z_coeff = ROL::nullPtr, const ROL::Ptr> & z_param = ROL::nullPtr) { // Get relevant dimensions const int c = feVel_->gradN()->dimension(0); const int fc = feCtrl_->gradN()->dimension(1); const int p = feVel_->gradN()->dimension(2); const int d = feVel_->gradN()->dimension(3); // Initialize output grad std::vector>> H; H.resize(fieldInfoCtrl_->numFields); H[0] = ROL::makePtr>(c, fc); // Get components of the control std::vector>> V, U, Z; FieldUtils::splitFieldCoeff(V, v_coeff, fieldInfo_); FieldUtils::splitFieldCoeff(U, u_coeff, fieldInfo_); FieldUtils::splitFieldCoeff(Z, z_coeff, fieldInfoCtrl_); // Create storage ROL::Ptr> Zval, alpha, Uval, aUval, aUVval, Vval; Zval = ROL::makePtr>(c, p); alpha = ROL::makePtr>(c, p); Uval = ROL::makePtr>(c, p); aUval = ROL::makePtr>(c, p); aUVval = ROL::makePtr>(c, p); Vval = ROL::makePtr>(c, p); feCtrl_->evaluateValue(Zval, Z[0]); imp_->compute(alpha, Zval, feVel_->cubPts(), 1); for (int i = 0; i < d; ++i) { Vval->initialize(); Uval->initialize(); aUval->initialize(); aUVval->initialize(); // Evaluate on FE basis feVel_->evaluateValue(Vval, V[i]); feVel_->evaluateValue(Uval, U[i]); // Scale Intrepid::FunctionSpaceTools::scalarMultiplyDataData(*aUval, *alpha, *Uval); Intrepid::FunctionSpaceTools::scalarMultiplyDataData(*aUVval, *aUval, *Vval); // Integrate Intrepid::FunctionSpaceTools::integrate(*H[0], *aUVval, *(feCtrl_->NdetJ()), Intrepid::COMP_CPP, true); } FieldUtils::combineFieldCoeff(hess, H, fieldInfoCtrl_); } void HessVec_22(ROL::Ptr> & hess, const ROL::Ptr> & v_coeff, const ROL::Ptr> & u_coeff, const ROL::Ptr> & z_coeff = ROL::nullPtr, const ROL::Ptr> & z_param = ROL::nullPtr) { // Get relevant dimensions const int c = feVel_->gradN()->dimension(0); const int fc = feCtrl_->gradN()->dimension(1); const int p = feVel_->gradN()->dimension(2); const int d = feVel_->gradN()->dimension(3); // Initialize output grad std::vector>> H; H.resize(fieldInfoCtrl_->numFields); H[0] = ROL::makePtr>(c, fc); // Get components of the control std::vector>> V, U, Z; FieldUtils::splitFieldCoeff(V, v_coeff, fieldInfoCtrl_); FieldUtils::splitFieldCoeff(U, u_coeff, fieldInfo_); FieldUtils::splitFieldCoeff(Z, z_coeff, fieldInfoCtrl_); // Create storage ROL::Ptr> Zval, alpha, Uval, aUval, aU2val, Vval, aVval; Zval = ROL::makePtr>(c, p); alpha = ROL::makePtr>(c, p); Uval = ROL::makePtr>(c, p); aUval = ROL::makePtr>(c, p); aU2val = ROL::makePtr>(c, p); Vval = ROL::makePtr>(c, p); aVval = ROL::makePtr>(c, p); feCtrl_->evaluateValue(Vval, V[0]); feCtrl_->evaluateValue(Zval, Z[0]); imp_->compute(alpha, Zval, feVel_->cubPts(), 2); Intrepid::FunctionSpaceTools::scalarMultiplyDataData(*aVval, *alpha, *Vval); for (int i = 0; i < d; ++i) { Uval->initialize(); aUval->initialize(); aU2val->initialize(); // Evaluate on FE basis feVel_->evaluateValue(Uval, U[i]); // Scale Intrepid::FunctionSpaceTools::scalarMultiplyDataData(*aUval, *aVval, *Uval); Intrepid::FunctionSpaceTools::scalarMultiplyDataData(*aU2val, *aUval, *Uval); // Integrate Intrepid::FunctionSpaceTools::integrate(*H[0], *aU2val, *(feCtrl_->NdetJ()), Intrepid::COMP_CPP, true); } Intrepid::RealSpaceTools::scale(*H[0], static_cast(0.5)); FieldUtils::combineFieldCoeff(hess, H, fieldInfoCtrl_); } }; // QoI_Power_NavierStokes template class QoI_Volume_NavierStokes : public QoI { private: const ROL::Ptr> fe_; const ROL::Ptr fieldInfo_; ROL::Ptr> weight_; Real volFraction_; public: QoI_Volume_NavierStokes(ROL::ParameterList &list, const ROL::Ptr> &fe, const ROL::Ptr &fieldInfo) : fe_(fe), fieldInfo_(fieldInfo) { const Real one(1); volFraction_ = list.sublist("Problem").get("Volume Fraction",0.5); const int c = fe_->cubPts()->dimension(0); const int p = fe_->cubPts()->dimension(1); weight_ = ROL::makePtr>(c, p); weight_->initialize(one); } Real value(ROL::Ptr> & val, const ROL::Ptr> & u_coeff, const ROL::Ptr> & z_coeff = ROL::nullPtr, const ROL::Ptr> & z_param = ROL::nullPtr) { // Get relevant dimensions const int c = fe_->cubPts()->dimension(0); const int p = fe_->cubPts()->dimension(1); // Initialize output val val = ROL::makePtr>(c); // Get components of the control std::vector>> Z; FieldUtils::splitFieldCoeff(Z, z_coeff, fieldInfo_); // Evaluate on FE basis ROL::Ptr> Z0; Z0 = ROL::makePtr>(c, p); fe_->evaluateValue(Z0, Z[0]); // Integrate the density minus volume fraction for (int i = 0; i < c; ++i) { for (int j = 0; j < p; ++j) { (*Z0)(i,j) -= volFraction_; } } fe_->computeIntegral(val,weight_,Z0,true); return static_cast(0); } void gradient_1(ROL::Ptr> & grad, const ROL::Ptr> & u_coeff, const ROL::Ptr> & z_coeff = ROL::nullPtr, const ROL::Ptr> & z_param = ROL::nullPtr) { throw Exception::Zero(">>> QoI_Volume_NavierStokes::gradient_1 is zero."); } void gradient_2(ROL::Ptr> & grad, const ROL::Ptr> & u_coeff, const ROL::Ptr> & z_coeff = ROL::nullPtr, const ROL::Ptr> & z_param = ROL::nullPtr) { // Get relevant dimensions const int c = fe_->cubPts()->dimension(0); const int f = fe_->N()->dimension(1); // Initialize output grad std::vector>> G; G.resize(fieldInfo_->numFields); G[0] = ROL::makePtr>(c, f); // Integrate density Intrepid::FunctionSpaceTools::integrate(*G[0], *weight_, *(fe_->NdetJ()), Intrepid::COMP_CPP, false); FieldUtils::combineFieldCoeff(grad, G, fieldInfo_); } void HessVec_11(ROL::Ptr> & hess, const ROL::Ptr> & v_coeff, const ROL::Ptr> & u_coeff, const ROL::Ptr> & z_coeff = ROL::nullPtr, const ROL::Ptr> & z_param = ROL::nullPtr) { throw Exception::Zero(">>> QoI_Volume_NavierStokes::HessVec_11 is zero."); } void HessVec_12(ROL::Ptr> & hess, const ROL::Ptr> & v_coeff, const ROL::Ptr> & u_coeff, const ROL::Ptr> & z_coeff = ROL::nullPtr, const ROL::Ptr> & z_param = ROL::nullPtr) { throw Exception::Zero(">>> QoI_Volume_NavierStokes::HessVec_12 is zero."); } void HessVec_21(ROL::Ptr> & hess, const ROL::Ptr> & v_coeff, const ROL::Ptr> & u_coeff, const ROL::Ptr> & z_coeff = ROL::nullPtr, const ROL::Ptr> & z_param = ROL::nullPtr) { throw Exception::Zero(">>> QoI_Volume_NavierStokes::HessVec_21 is zero."); } void HessVec_22(ROL::Ptr> & hess, const ROL::Ptr> & v_coeff, const ROL::Ptr> & u_coeff, const ROL::Ptr> & z_coeff = ROL::nullPtr, const ROL::Ptr> & z_param = ROL::nullPtr) { throw Exception::Zero(">>> QoI_Volume_NavierStokes::HessVec_22 is zero."); } }; // QoI_Volume_NavierStokes #endif