// @HEADER // ***************************************************************************** // Rapid Optimization Library (ROL) Package // // Copyright 2014 NTESS and the ROL contributors. // SPDX-License-Identifier: BSD-3-Clause // ***************************************************************************** // @HEADER /*! \file pde_poisson_topOpt.hpp \brief Implements the local PDE interface for the Poisson topology optimization problem. */ #ifndef PDE_POISSON_TOPOPT_HPP #define PDE_POISSON_TOPOPT_HPP #include "../../TOOLS/pde.hpp" #include "../../TOOLS/fe.hpp" #include "../../TOOLS/Intrepid_HGRAD_C0_FEM.hpp" #include "Intrepid_HGRAD_QUAD_C1_FEM.hpp" #include "Intrepid_HGRAD_QUAD_C2_FEM.hpp" #include "Intrepid_DefaultCubatureFactory.hpp" #include "Intrepid_FunctionSpaceTools.hpp" #include "Intrepid_RealSpaceTools.hpp" #include "Intrepid_CellTools.hpp" #include "ROL_Ptr.hpp" template class PDE_Poisson_TopOpt : public PDE { private: // Finite element basis information ROL::Ptr>> basisPtr_; std::vector>>> basisPtrs_; ROL::Ptr>> basisPtrDens_; std::vector>>> basisPtrsDens_; // Cell cubature information ROL::Ptr> cellCub_; // Cell node information ROL::Ptr> volCellNodes_; std::vector>>> bdryCellNodes_; std::vector>> bdryCellLocIds_; // Finite element definition ROL::Ptr> fe_vol_, fe_dens_; // Local degrees of freedom on boundary, for each side of the reference cell (first index). std::vector> fidx_; // Coordinates of degrees freedom on boundary cells. // Indexing: [sideset number][local side id](cell number, value at dof) std::vector>>> bdryCellDofValues_; // Force function evaluated at cubature points ROL::Ptr> force_eval_; ROL::Ptr> nforce_eval_; // Inputs Real minConductivity_; Real SIMPpower_; bool getFields2called_; Real ForceFunc(const std::vector &x) const { return static_cast(0.01); } Real dirichletFunc(const std::vector & coords, const int sideset, const int locSideId) const { return static_cast(0); } public: PDE_Poisson_TopOpt(Teuchos::ParameterList &parlist) : getFields2called_(false) { // Finite element fields. int basisOrder = parlist.sublist("Problem").get("Order of FE discretization",1); int basisOrderDens = parlist.sublist("Problem").get("Density Basis Order",0); TEUCHOS_TEST_FOR_EXCEPTION(basisOrder > 2 || basisOrder < 1, std::invalid_argument, ">>> PDE-OPT/topopt/poisson/pde_poisson_topOpt.hpp: Basis order is not 1 or 2!"); TEUCHOS_TEST_FOR_EXCEPTION(basisOrderDens > 1 || basisOrderDens < 0, std::invalid_argument, ">>> PDE-OPT/topopt/poisson/pde_poisson_topOpt.hpp: Basis order is not 0 or 1!"); if (basisOrder == 1) basisPtr_ = ROL::makePtr>>(); else if (basisOrder == 2) basisPtr_ = ROL::makePtr>>(); if (basisOrderDens == 1) basisPtrDens_ = ROL::makePtr>>(); else basisPtrDens_ = ROL::makePtr>>(); basisPtrs_.clear(); basisPtrs_.push_back(basisPtr_); basisPtrsDens_.clear(); basisPtrsDens_.push_back(basisPtrDens_); // Density component // Quadrature rules. shards::CellTopology cellType = basisPtr_->getBaseCellTopology(); // get the cell type from any basis Intrepid::DefaultCubatureFactory cubFactory; // create cubature factory int cubDegree = parlist.sublist("Problem").get("Cubature Degree",2); // set cubature degree, e.g., 2 cellCub_ = cubFactory.create(cellType, cubDegree); // create default cubature minConductivity_ = parlist.sublist("Problem").get("Minimum Conductivity",1.e-3); SIMPpower_ = parlist.sublist("Problem").get("SIMP Power",3.0); } void residual(ROL::Ptr> & res, const ROL::Ptr> & u_coeff, const ROL::Ptr> & z_coeff = ROL::nullPtr, const ROL::Ptr> & z_param = ROL::nullPtr) { const Real one(1); // Get dimensions const int c = fe_vol_->gradN()->dimension(0); const int f = fe_vol_->gradN()->dimension(1); const int p = fe_vol_->gradN()->dimension(2); const int d = fe_vol_->gradN()->dimension(3); // Initialize residual storage res = ROL::makePtr>(c, f); // Temporary storage ROL::Ptr> valZ_eval, gradU_eval, KgradU; valZ_eval = ROL::makePtr>(c, p); gradU_eval = ROL::makePtr>(c, p, d); KgradU = ROL::makePtr>(c, p, d); // Build SIMP density at cubature points fe_dens_->evaluateValue(valZ_eval, z_coeff); for (int i = 0; i < c; ++i) { for (int j = 0; j < p; ++j) { (*valZ_eval)(i,j) = minConductivity_ + (one - minConductivity_) * std::pow((*valZ_eval)(i,j),SIMPpower_); } } // Build flux function fe_vol_->evaluateGradient(gradU_eval, u_coeff); Intrepid::FunctionSpaceTools::scalarMultiplyDataData(*KgradU, *valZ_eval, *gradU_eval); // Integrate stiffness term Intrepid::FunctionSpaceTools::integrate(*res, *KgradU, *(fe_vol_->gradNdetJ()), Intrepid::COMP_CPP, false); // Add force term Intrepid::FunctionSpaceTools::integrate(*res, *nforce_eval_, *(fe_vol_->NdetJ()), Intrepid::COMP_CPP, true); // Apply Dirichlet boundary conditions int numSideSets = bdryCellLocIds_.size(); if (numSideSets > 0) { for (int i = 0; i < numSideSets; ++i) { if (i==2) { int numLocalSideIds = bdryCellLocIds_[i].size(); for (int j = 0; j < numLocalSideIds; ++j) { int numCellsSide = bdryCellLocIds_[i][j].size(); int numBdryDofs = fidx_[j].size(); for (int k = 0; k < numCellsSide; ++k) { int cidx = bdryCellLocIds_[i][j][k]; for (int l = 0; l < numBdryDofs; ++l) { (*res)(cidx,fidx_[j][l]) = (*u_coeff)(cidx,fidx_[j][l]) - (*bdryCellDofValues_[i][j])(k,fidx_[j][l]); } } } } } } } void Jacobian_1(ROL::Ptr> & jac, const ROL::Ptr> & u_coeff, const ROL::Ptr> & z_coeff = ROL::nullPtr, const ROL::Ptr> & z_param = ROL::nullPtr) { const Real one(1); // Get dimensions const int c = fe_vol_->gradN()->dimension(0); const int f = fe_vol_->gradN()->dimension(1); const int p = fe_vol_->gradN()->dimension(2); const int d = fe_vol_->gradN()->dimension(3); // Initialize Jacobian storage jac = ROL::makePtr>(c, f, f); ROL::Ptr> valZ_eval, KgradN; valZ_eval = ROL::makePtr>(c, p); KgradN = ROL::makePtr>(c, f, p, d); // Build density-dependent conductivity function fe_dens_->evaluateValue(valZ_eval, z_coeff); for (int i = 0; i < c; ++i) { for (int j = 0; j < p; ++j) { (*valZ_eval)(i,j) = minConductivity_ + (one - minConductivity_) * std::pow((*valZ_eval)(i,j),SIMPpower_); } } // Build flux function Intrepid::FunctionSpaceTools::scalarMultiplyDataField(*KgradN, *valZ_eval, *(fe_vol_->gradN())); // Integrate stiffness term Intrepid::FunctionSpaceTools::integrate(*jac, *KgradN, *(fe_vol_->gradNdetJ()), Intrepid::COMP_CPP, false); // Apply Dirichlet boundary conditions int numSideSets = bdryCellLocIds_.size(); if (numSideSets > 0) { for (int i = 0; i < numSideSets; ++i) { if (i==2) { int numLocalSideIds = bdryCellLocIds_[i].size(); for (int j = 0; j < numLocalSideIds; ++j) { int numCellsSide = bdryCellLocIds_[i][j].size(); int numBdryDofs = fidx_[j].size(); for (int k = 0; k < numCellsSide; ++k) { int cidx = bdryCellLocIds_[i][j][k]; for (int l = 0; l < numBdryDofs; ++l) { for (int m = 0; m < f; ++m) { (*jac)(cidx,fidx_[j][l],m) = static_cast(0); } (*jac)(cidx,fidx_[j][l],fidx_[j][l]) = static_cast(1); } } } } } } } void Jacobian_2(ROL::Ptr> & jac, const ROL::Ptr> & u_coeff, const ROL::Ptr> & z_coeff = ROL::nullPtr, const ROL::Ptr> & z_param = ROL::nullPtr) { const Real one(1); // Get dimensions const int c = fe_vol_->gradN()->dimension(0); const int f = fe_vol_->gradN()->dimension(1); const int fd = fe_dens_->gradN()->dimension(1); const int p = fe_vol_->gradN()->dimension(2); const int d = fe_vol_->gradN()->dimension(3); // Initialize Jacobian storage jac = ROL::makePtr>(c, f, fd); ROL::Ptr> valZ_eval, gradU_eval, dKN, gradUgradN; // Temporary storage valZ_eval = ROL::makePtr>(c, p); gradU_eval = ROL::makePtr>(c, p, d); dKN = ROL::makePtr>(c, fd, p); gradUgradN = ROL::makePtr>(c, f, p); // Build density-dependent conductivity function fe_dens_->evaluateValue(valZ_eval, z_coeff); for (int i = 0; i < c; ++i) { for (int j = 0; j < p; ++j) { (*valZ_eval)(i,j) = SIMPpower_*(one - minConductivity_) * std::pow((*valZ_eval)(i,j),SIMPpower_-one); } } // Build derivative of conductivity function Intrepid::FunctionSpaceTools::scalarMultiplyDataField(*dKN, *valZ_eval, *(fe_dens_->N())); // Integrate stiffness term fe_vol_->evaluateGradient(gradU_eval, u_coeff); Intrepid::FunctionSpaceTools::dotMultiplyDataField(*gradUgradN, *gradU_eval, (*fe_vol_->gradNdetJ())); Intrepid::FunctionSpaceTools::integrate(*jac, *gradUgradN, *dKN, Intrepid::COMP_CPP, false); // Apply Dirichlet boundary conditions int numSideSets = bdryCellLocIds_.size(); if (numSideSets > 0) { for (int i = 0; i < numSideSets; ++i) { if (i==2) { int numLocalSideIds = bdryCellLocIds_[i].size(); for (int j = 0; j < numLocalSideIds; ++j) { int numCellsSide = bdryCellLocIds_[i][j].size(); int numBdryDofs = fidx_[j].size(); for (int k = 0; k < numCellsSide; ++k) { int cidx = bdryCellLocIds_[i][j][k]; for (int l = 0; l < numBdryDofs; ++l) { for (int m=0; m < f; ++m) { (*jac)(cidx,fidx_[j][l],m) = static_cast(0); } } } } } } } } void Hessian_11(ROL::Ptr> & hess, const ROL::Ptr> & l_coeff, const ROL::Ptr> & u_coeff, const ROL::Ptr> & z_coeff = ROL::nullPtr, const ROL::Ptr> & z_param = ROL::nullPtr) { throw Exception::Zero(">>> (PDE_Poisson_TopOpt::Hessian_11): Zero Hessian."); } void Hessian_12(ROL::Ptr> & hess, const ROL::Ptr> & l_coeff, const ROL::Ptr> & u_coeff, const ROL::Ptr> & z_coeff = ROL::nullPtr, const ROL::Ptr> & z_param = ROL::nullPtr) { const Real one(1); // Get dimensions const int c = fe_vol_->gradN()->dimension(0); const int f = fe_vol_->gradN()->dimension(1); const int fd = fe_dens_->gradN()->dimension(1); const int p = fe_vol_->gradN()->dimension(2); const int d = fe_vol_->gradN()->dimension(3); // Initialize Hessian storage hess = ROL::makePtr>(c, fd, f); // Temporary storage ROL::Ptr> valZ_eval, l0_coeff, dKN, gradL_eval, gradLgradN; valZ_eval = ROL::makePtr>(c, p); l0_coeff = ROL::makePtr>(c, f); dKN = ROL::makePtr>(c, fd, p); gradL_eval = ROL::makePtr>(c, p, d); gradLgradN = ROL::makePtr>(c, f, p); // Build density-dependent conductivity function fe_dens_->evaluateValue(valZ_eval, z_coeff); for (int i = 0; i < c; ++i) { for (int j = 0; j < p; ++j) { (*valZ_eval)(i,j) = SIMPpower_*(one - minConductivity_) * std::pow((*valZ_eval)(i,j),SIMPpower_-one); } } // Apply Dirichlet conditions to the multipliers. *l0_coeff = *l_coeff; int numSideSets = bdryCellLocIds_.size(); if (numSideSets > 0) { for (int i = 0; i < numSideSets; ++i) { if (i==2) { int numLocalSideIds = bdryCellLocIds_[i].size(); for (int j = 0; j < numLocalSideIds; ++j) { int numCellsSide = bdryCellLocIds_[i][j].size(); int numBdryDofs = fidx_[j].size(); for (int k = 0; k < numCellsSide; ++k) { int cidx = bdryCellLocIds_[i][j][k]; for (int l = 0; l < numBdryDofs; ++l) { (*l0_coeff)(cidx,fidx_[j][l]) = static_cast(0); } } } } } } // Build derivative of conductivity function Intrepid::FunctionSpaceTools::scalarMultiplyDataField(*dKN, *valZ_eval, *(fe_dens_->N())); // Integrate stiffness term fe_vol_->evaluateGradient(gradL_eval, l0_coeff); Intrepid::FunctionSpaceTools::dotMultiplyDataField(*gradLgradN, *gradL_eval, (*fe_vol_->gradNdetJ())); Intrepid::FunctionSpaceTools::integrate(*hess, *dKN, *gradLgradN, Intrepid::COMP_CPP, false); } void Hessian_21(ROL::Ptr> & hess, const ROL::Ptr> & l_coeff, const ROL::Ptr> & u_coeff, const ROL::Ptr> & z_coeff = ROL::nullPtr, const ROL::Ptr> & z_param = ROL::nullPtr) { const Real one(1); // Get dimensions const int c = fe_vol_->gradN()->dimension(0); const int f = fe_vol_->gradN()->dimension(1); const int fd = fe_dens_->gradN()->dimension(1); const int p = fe_vol_->gradN()->dimension(2); const int d = fe_vol_->gradN()->dimension(3); // Initialize Hessian storage hess = ROL::makePtr>(c, f, fd); // Temporary storage ROL::Ptr> valZ_eval, l0_coeff, dKN, gradL_eval, gradLgradN; valZ_eval = ROL::makePtr>(c, p); l0_coeff = ROL::makePtr>(c, f); dKN = ROL::makePtr>(c, fd, p); gradL_eval = ROL::makePtr>(c, p, d); gradLgradN = ROL::makePtr>(c, f, p); // Build density-dependent conductivity function fe_vol_->evaluateValue(valZ_eval, z_coeff); for (int i = 0; i < c; ++i) { for (int j = 0; j < p; ++j) { (*valZ_eval)(i,j) = SIMPpower_*(one - minConductivity_) * std::pow((*valZ_eval)(i,j),SIMPpower_-one); } } // Apply Dirichlet conditions to the multipliers. *l0_coeff = *l_coeff; int numSideSets = bdryCellLocIds_.size(); if (numSideSets > 0) { for (int i = 0; i < numSideSets; ++i) { if (i==2) { int numLocalSideIds = bdryCellLocIds_[i].size(); for (int j = 0; j < numLocalSideIds; ++j) { int numCellsSide = bdryCellLocIds_[i][j].size(); int numBdryDofs = fidx_[j].size(); for (int k = 0; k < numCellsSide; ++k) { int cidx = bdryCellLocIds_[i][j][k]; for (int l = 0; l < numBdryDofs; ++l) { (*l0_coeff)(cidx,fidx_[j][l]) = static_cast(0); } } } } } } // Build derivative of conductivity function Intrepid::FunctionSpaceTools::scalarMultiplyDataField(*dKN, *valZ_eval, *(fe_dens_->N())); // Integrate stiffness term fe_vol_->evaluateGradient(gradL_eval, l0_coeff); Intrepid::FunctionSpaceTools::dotMultiplyDataField(*gradLgradN, *gradL_eval, (*fe_vol_->gradNdetJ())); Intrepid::FunctionSpaceTools::integrate(*hess, *gradLgradN, *dKN, Intrepid::COMP_CPP, false); } void Hessian_22(ROL::Ptr> & hess, const ROL::Ptr> & l_coeff, const ROL::Ptr> & u_coeff, const ROL::Ptr> & z_coeff = ROL::nullPtr, const ROL::Ptr> & z_param = ROL::nullPtr) { const Real one(1), two(2); // Get dimensions const int c = fe_vol_->gradN()->dimension(0); const int f = fe_vol_->gradN()->dimension(1); const int fd = fe_dens_->gradN()->dimension(1); const int p = fe_vol_->gradN()->dimension(2); const int d = fe_vol_->gradN()->dimension(3); // Initialize Hessian storage hess = ROL::makePtr>(c, fd, fd); // Temporary storage ROL::Ptr> valZ_eval, l0_coeff, dKN, gradU_eval, gradL_eval, gradUgradL, NgradUgradL; valZ_eval = ROL::makePtr>(c, p); l0_coeff = ROL::makePtr>(c, f); dKN = ROL::makePtr>(c, fd, p); gradU_eval = ROL::makePtr>(c, p, d); gradL_eval = ROL::makePtr>(c, p, d); gradUgradL = ROL::makePtr>(c, p); NgradUgradL = ROL::makePtr>(c, fd, p); // Build density-dependent conductivity function fe_dens_->evaluateValue(valZ_eval, z_coeff); for (int i = 0; i < c; ++i) { for (int j = 0; j < p; ++j) { (*valZ_eval)(i,j) = SIMPpower_ * (SIMPpower_ - one)*(one - minConductivity_) * std::pow((*valZ_eval)(i,j),SIMPpower_-two); } } // Apply Dirichlet conditions to the multipliers. *l0_coeff = *l_coeff; int numSideSets = bdryCellLocIds_.size(); if (numSideSets > 0) { for (int i = 0; i < numSideSets; ++i) { if (i==2) { int numLocalSideIds = bdryCellLocIds_[i].size(); for (int j = 0; j < numLocalSideIds; ++j) { int numCellsSide = bdryCellLocIds_[i][j].size(); int numBdryDofs = fidx_[j].size(); for (int k = 0; k < numCellsSide; ++k) { int cidx = bdryCellLocIds_[i][j][k]; for (int l = 0; l < numBdryDofs; ++l) { (*l0_coeff)(cidx,fidx_[j][l]) = static_cast(0); } } } } } } // Build derivative of conductivity function Intrepid::FunctionSpaceTools::scalarMultiplyDataField(*dKN, *valZ_eval, *(fe_dens_->N())); // Integrate stiffness term fe_vol_->evaluateGradient(gradU_eval, u_coeff); fe_vol_->evaluateGradient(gradL_eval, l0_coeff); Intrepid::FunctionSpaceTools::dotMultiplyDataData(*gradUgradL, *gradU_eval, *gradL_eval); Intrepid::FunctionSpaceTools::scalarMultiplyDataField(*NgradUgradL, *gradUgradL, *(fe_dens_->NdetJ())); Intrepid::FunctionSpaceTools::integrate(*hess, *dKN, *NgradUgradL, Intrepid::COMP_CPP, false); } void RieszMap_1(ROL::Ptr> & riesz) { // GET DIMENSIONS int c = fe_vol_->N()->dimension(0); int f = fe_vol_->N()->dimension(1); // INITIALIZE RIESZ riesz = ROL::makePtr>(c, f, f); *riesz = *fe_vol_->stiffMat(); Intrepid::RealSpaceTools::add(*riesz,*(fe_vol_->massMat())); } void RieszMap_2(ROL::Ptr> & riesz) { // GET DIMENSIONS int c = fe_dens_->N()->dimension(0); int f = fe_dens_->N()->dimension(1); // INITIALIZE RIESZ riesz = ROL::makePtr>(c, f, f); *riesz = *fe_dens_->massMat(); } // This must be called before getFields2 void setDensityFields(const std::vector>>> &basisPtrs) { TEUCHOS_TEST_FOR_EXCEPTION(getFields2called_, std::invalid_argument, ">>> PDE-OPT/topo-opt/elasticity/src/pde_elasticity.hpp: Must call before getFields2!"); basisPtrDens_ = basisPtrs[0]; basisPtrsDens_ = basisPtrs; } std::vector>>> getFields() { return basisPtrs_; } std::vector>>> getFields2() { getFields2called_ = true; return basisPtrsDens_; } void setCellNodes(const ROL::Ptr> &volCellNodes, const std::vector>>> &bdryCellNodes, const std::vector>> &bdryCellLocIds) { volCellNodes_ = volCellNodes; bdryCellNodes_ = bdryCellNodes; bdryCellLocIds_ = bdryCellLocIds; // Finite element definition. fe_vol_ = ROL::makePtr>(volCellNodes_,basisPtr_,cellCub_); fe_dens_ = ROL::makePtr>(volCellNodes_,basisPtrDens_,cellCub_,false); fidx_ = fe_vol_->getBoundaryDofs(); computeForce(); computeDirichlet(); } void computeForce(void) { int c = fe_vol_->cubPts()->dimension(0); int p = fe_vol_->cubPts()->dimension(1); int d = fe_vol_->cubPts()->dimension(2); std::vector pt(d,0); force_eval_ = ROL::makePtr>(c,p); nforce_eval_ = ROL::makePtr>(c,p); for (int i = 0; i < c; ++i) { for (int j = 0; j < p; ++j) { for (int k = 0; k < d; ++k) { pt[k] = (*fe_vol_->cubPts())(i,j,k); } (*force_eval_)(i,j) = ForceFunc(pt); (*nforce_eval_)(i,j) = -(*force_eval_)(i,j); } } } void computeDirichlet(void) { // Compute Dirichlet values at DOFs. int d = basisPtr_->getBaseCellTopology().getDimension(); int numSidesets = bdryCellLocIds_.size(); bdryCellDofValues_.resize(numSidesets); for (int i=0; igetCardinality(); bdryCellDofValues_[i][j] = ROL::makePtr>(c, f); ROL::Ptr> coords = ROL::makePtr>(c, f, d); if (c > 0) { fe_vol_->computeDofCoords(coords, bdryCellNodes_[i][j]); } for (int k=0; k dofpoint(d); for (int m=0; m> getFE(void) const { return fe_vol_; } const ROL::Ptr> getDensityFE(void) const { return fe_dens_; } const ROL::Ptr> getForce(void) const { return force_eval_; } }; // PDE_Poisson #endif