Debian Codegraph @

packages/rol/example/PDE-OPT/topo-opt/multimat/src/pde_selection.hpp

raw
1 // @HEADER
2 // *****************************************************************************
3 // Rapid Optimization Library (ROL) Package
4 //
5 // Copyright 2014 NTESS and the ROL contributors.
6 // SPDX-License-Identifier: BSD-3-Clause
7 // *****************************************************************************
8 // @HEADER
9
10 /*! \file pde_selection.hpp
11 \brief Implements the local selection constraint.
12 */
13
14 #ifndef PDE_TOPO_OPT_SELECTION_MULTIMAT_HPP
15 #define PDE_TOPO_OPT_SELECTION_MULTIMAT_HPP
16
17 #include "../../../TOOLS/pde.hpp"
18 #include "../../../TOOLS/fe.hpp"
19 #include "../../../TOOLS/fieldhelper.hpp"
20 #include "../../../TOOLS/Intrepid_HGRAD_C0_FEM.hpp"
21
22 #include "Intrepid_HGRAD_QUAD_C1_FEM.hpp"
23 #include "Intrepid_HGRAD_HEX_C1_FEM.hpp"
24 #include "Intrepid_DefaultCubatureFactory.hpp"
25 #include "Intrepid_FunctionSpaceTools.hpp"
26 #include "Intrepid_CellTools.hpp"
27
28 #include "ROL_Ptr.hpp"
29
30 template <class Real>
31 class PDE_MultiMat_Selection : public PDE<Real> {
32 private:
33 // Finite element basis information
34 ROL::Ptr<Intrepid::Basis<Real, Intrepid::FieldContainer<Real>>> basisPtr_;
35 std::vector<ROL::Ptr<Intrepid::Basis<Real, Intrepid::FieldContainer<Real>>>> basisPtrs_;
36 ROL::Ptr<Intrepid::Basis<Real, Intrepid::FieldContainer<Real>>> basisPtrDens_;
37 std::vector<ROL::Ptr<Intrepid::Basis<Real, Intrepid::FieldContainer<Real>>>> basisPtrsDens_;
38 // Cell cubature information
39 ROL::Ptr<Intrepid::Cubature<Real>> cellCub_;
40 // Cell node information
41 ROL::Ptr<Intrepid::FieldContainer<Real>> volCellNodes_;
42 std::vector<std::vector<ROL::Ptr<Intrepid::FieldContainer<Real>>>> bdryCellNodes_;
43 std::vector<std::vector<std::vector<int>>> bdryCellLocIds_;
44 // Finite element definition
45 ROL::Ptr<FE<Real>> fe_, feDens_;
46 // Field pattern, offsets, etc.
47 std::vector<std::vector<int>> fieldPattern_; // local Field/DOF pattern; set from DOF manager
48 int numFields_; // number of fields (equations in the PDE)
49 int numDofs_; // total number of degrees of freedom for all (local) fields
50 std::vector<int> offset_; // for each field, a counting offset
51 std::vector<int> numFieldDofs_; // for each field, number of degrees of freedom
52 std::vector<std::vector<int>> fieldPatternDens_; // local Field/DOF pattern; set from DOF manager
53 int numFieldsDens_; // number of fields (equations in the PDE)
54 int numDofsDens_; // total number of degrees of freedom for all (local) fields
55 std::vector<int> offsetDens_; // for each field, a counting offset
56 std::vector<int> numFieldDofsDens_; // for each field, number of degrees of freedom
57
58 ROL::Ptr<FieldUtils::FieldInfo> fieldInfo_, fieldInfoDens_;
59
60 public:
61 PDE_MultiMat_Selection(Teuchos::ParameterList &parlist) {
62 // Material properties
63 std::vector<Real> ym = ROL::getArrayFromStringParameter<Real>(parlist.sublist("Problem"), "Young's Modulus");
64 int T = ym.size();
65
66 // Finite element fields.
67 int basisOrderDens = parlist.sublist("Problem").get("Density Basis Order",0);
68 int cubDegree = parlist.sublist("Problem").get("Cubature Degree",4);
69 int probDim = parlist.sublist("Problem").get("Problem Dimension",2);
70 if (probDim> 3 || probDim < 2) {
71 TEUCHOS_TEST_FOR_EXCEPTION(true, std::invalid_argument,
72 ">>> PDE-OPT/binary/elasticity/pde_elasticity.hpp: Problem dimension is not 2 or 3!");
73 }
74 if (basisOrderDens > 1 || basisOrderDens < 0) {
75 TEUCHOS_TEST_FOR_EXCEPTION(true, std::invalid_argument,
76 ">>> PDE-OPT/binary/elasticity/pde_elasticity.hpp: Density basis order is not 0 1!");
77 }
78 if (probDim == 2) {
79 if (basisOrderDens == 0) {
80 basisPtr_ = ROL::makePtr<Intrepid::Basis_HGRAD_C0_FEM<Real, Intrepid::FieldContainer<Real>>>();
81 basisPtrDens_ = ROL::makePtr<Intrepid::Basis_HGRAD_C0_FEM<Real, Intrepid::FieldContainer<Real>>>();
82 }
83 else if (basisOrderDens == 1) {
84 basisPtr_ = ROL::makePtr<Intrepid::Basis_HGRAD_QUAD_C1_FEM<Real, Intrepid::FieldContainer<Real>>>();
85 basisPtrDens_ = ROL::makePtr<Intrepid::Basis_HGRAD_QUAD_C1_FEM<Real, Intrepid::FieldContainer<Real>>>();
86 }
87 }
88 else if (probDim == 3) {
89 if (basisOrderDens == 0) {
90 // This does not work in 3D
91 basisPtr_ = ROL::makePtr<Intrepid::Basis_HGRAD_C0_FEM<Real, Intrepid::FieldContainer<Real>>>();
92 basisPtrDens_ = ROL::makePtr<Intrepid::Basis_HGRAD_C0_FEM<Real, Intrepid::FieldContainer<Real>>>();
93 }
94 else if (basisOrderDens == 1) {
95 basisPtr_ = ROL::makePtr<Intrepid::Basis_HGRAD_HEX_C1_FEM<Real, Intrepid::FieldContainer<Real>>>();
96 basisPtrDens_ = ROL::makePtr<Intrepid::Basis_HGRAD_HEX_C1_FEM<Real, Intrepid::FieldContainer<Real>>>();
97 }
98 }
99 basisPtrs_.clear(); basisPtrsDens_.clear();
100 basisPtrs_.push_back(basisPtr_); // Displacement component
101 for (int i=0; i<T; ++i) {
102 basisPtrsDens_.push_back(basisPtrDens_); // Density components
103 }
104
105 // Quadrature rules.
106 shards::CellTopology cellType = basisPtr_->getBaseCellTopology(); // get cell type from basis
107 Intrepid::DefaultCubatureFactory<Real> cubFactory; // create cubature factory
108 cellCub_ = cubFactory.create(cellType, cubDegree); // create default cubature
109
110 numDofs_ = 0;
111 numFields_ = basisPtrs_.size();
112 offset_.resize(numFields_);
113 numFieldDofs_.resize(numFields_);
114 for (int i=0; i<numFields_; ++i) {
115 if (i==0) {
116 offset_[i] = 0;
117 }
118 else {
119 offset_[i] = offset_[i-1] + basisPtrs_[i-1]->getCardinality();
120 }
121 numFieldDofs_[i] = basisPtrs_[i]->getCardinality();
122 numDofs_ += numFieldDofs_[i];
123 }
124
125 numDofsDens_ = 0;
126 numFieldsDens_ = basisPtrsDens_.size();
127 offsetDens_.resize(numFieldsDens_);
128 numFieldDofsDens_.resize(numFieldsDens_);
129 for (int i=0; i<numFieldsDens_; ++i) {
130 if (i==0) {
131 offsetDens_[i] = 0;
132 }
133 else {
134 offsetDens_[i] = offsetDens_[i-1] + basisPtrsDens_[i-1]->getCardinality();
135 }
136 numFieldDofsDens_[i] = basisPtrsDens_[i]->getCardinality();
137 numDofsDens_ += numFieldDofsDens_[i];
138 }
139 }
140
141 void residual(ROL::Ptr<Intrepid::FieldContainer<Real>> & res,
142 const ROL::Ptr<const Intrepid::FieldContainer<Real>> & u_coeff,
143 const ROL::Ptr<const Intrepid::FieldContainer<Real>> & z_coeff = ROL::nullPtr,
144 const ROL::Ptr<const std::vector<Real>> & z_param = ROL::nullPtr) {
145 // Retrieve dimensions.
146 int c = fe_->gradN()->dimension(0);
147 int f = fe_->gradN()->dimension(1);
148 int p = fe_->gradN()->dimension(2);
149 int T = numFieldsDens_;
150
151 // Initialize residuals.
152 std::vector<ROL::Ptr<Intrepid::FieldContainer<Real>>> R(1);
153 R[0] = ROL::makePtr<Intrepid::FieldContainer<Real>>(c,f);
154
155 // Split z_coeff into components.
156 std::vector<ROL::Ptr<Intrepid::FieldContainer<Real>>> Z;
157 FieldUtils::splitFieldCoeff<Real>(Z, z_coeff, fieldInfoDens_);
158
159 // Evaluate/interpolate finite element fields on cells.
160 ROL::Ptr<Intrepid::FieldContainer<Real>> sum, valZ_eval;
161 sum = ROL::makePtr<Intrepid::FieldContainer<Real>>(c, p);
162 valZ_eval = ROL::makePtr<Intrepid::FieldContainer<Real>>(c, p);
163 sum->initialize(static_cast<Real>(-1));
164 for (int t=0; t<T; ++t) {
165 valZ_eval->initialize();
166 feDens_->evaluateValue(valZ_eval, Z[t]);
167 Intrepid::RealSpaceTools<Real>::add(*sum,*valZ_eval);
168 }
169 Intrepid::FunctionSpaceTools::integrate<Real>(*R[0],
170 *sum, // sum z[t]
171 *fe_->NdetJ(), // N
172 Intrepid::COMP_CPP,
173 false);
174
175 // Combine the residuals.
176 FieldUtils::combineFieldCoeff<Real>(res, R, fieldInfo_);
177 }
178
179 void Jacobian_1(ROL::Ptr<Intrepid::FieldContainer<Real>> & jac,
180 const ROL::Ptr<const Intrepid::FieldContainer<Real>> & u_coeff,
181 const ROL::Ptr<const Intrepid::FieldContainer<Real>> & z_coeff = ROL::nullPtr,
182 const ROL::Ptr<const std::vector<Real>> & z_param = ROL::nullPtr) {
183 throw Exception::Zero(">>> (PDE_TopoOpt::Jacobian_1): Jacobian is zero.");
184 }
185
186
187 void Jacobian_2(ROL::Ptr<Intrepid::FieldContainer<Real>> & jac,
188 const ROL::Ptr<const Intrepid::FieldContainer<Real>> & u_coeff,
189 const ROL::Ptr<const Intrepid::FieldContainer<Real>> & z_coeff = ROL::nullPtr,
190 const ROL::Ptr<const std::vector<Real>> & z_param = ROL::nullPtr) {
191 // Retrieve dimensions.
192 int c = fe_->gradN()->dimension(0);
193 int f = fe_->gradN()->dimension(1);
194 int fd = feDens_->gradN()->dimension(1);
195 int T = numFieldsDens_;
196
197 // Initialize Jacobians.
198 std::vector<std::vector<ROL::Ptr<Intrepid::FieldContainer<Real>>>> J(1);
199 for (int j=0; j<T; ++j) {
200 J[0].push_back(ROL::makePtr<Intrepid::FieldContainer<Real>>(c,f,fd));
201 }
202
203 // Evaluate/interpolate finite element fields on cells.
204 for (int t=0; t<T; ++t) {
205 Intrepid::FunctionSpaceTools::integrate<Real>(*J[0][t],
206 *fe_->NdetJ(), // N
207 *feDens_->N(), // N
208 Intrepid::COMP_CPP,
209 false);
210 }
211
212 // Combine the jacobians.
213 FieldUtils::combineFieldCoeff<Real>(jac, J, fieldInfo_, fieldInfoDens_);
214 }
215
216 void Hessian_11(ROL::Ptr<Intrepid::FieldContainer<Real>> & hess,
217 const ROL::Ptr<const Intrepid::FieldContainer<Real>> & l_coeff,
218 const ROL::Ptr<const Intrepid::FieldContainer<Real>> & u_coeff,
219 const ROL::Ptr<const Intrepid::FieldContainer<Real>> & z_coeff = ROL::nullPtr,
220 const ROL::Ptr<const std::vector<Real>> & z_param = ROL::nullPtr) {
221 throw Exception::Zero(">>> (PDE_TopoOpt::Hessian_11): Hessian is zero.");
222 }
223
224 void Hessian_12(ROL::Ptr<Intrepid::FieldContainer<Real>> & hess,
225 const ROL::Ptr<const Intrepid::FieldContainer<Real>> & l_coeff,
226 const ROL::Ptr<const Intrepid::FieldContainer<Real>> & u_coeff,
227 const ROL::Ptr<const Intrepid::FieldContainer<Real>> & z_coeff = ROL::nullPtr,
228 const ROL::Ptr<const std::vector<Real>> & z_param = ROL::nullPtr) {
229 throw Exception::Zero(">>> (PDE_TopoOpt::Hessian_12): Hessian is zero.");
230 }
231
232 void Hessian_21(ROL::Ptr<Intrepid::FieldContainer<Real>> & hess,
233 const ROL::Ptr<const Intrepid::FieldContainer<Real>> & l_coeff,
234 const ROL::Ptr<const Intrepid::FieldContainer<Real>> & u_coeff,
235 const ROL::Ptr<const Intrepid::FieldContainer<Real>> & z_coeff = ROL::nullPtr,
236 const ROL::Ptr<const std::vector<Real>> & z_param = ROL::nullPtr) {
237 throw Exception::Zero(">>> (PDE_TopoOpt::Hessian_21): Hessian is zero.");
238 }
239
240 void Hessian_22(ROL::Ptr<Intrepid::FieldContainer<Real>> & hess,
241 const ROL::Ptr<const Intrepid::FieldContainer<Real>> & l_coeff,
242 const ROL::Ptr<const Intrepid::FieldContainer<Real>> & u_coeff,
243 const ROL::Ptr<const Intrepid::FieldContainer<Real>> & z_coeff = ROL::nullPtr,
244 const ROL::Ptr<const std::vector<Real>> & z_param = ROL::nullPtr) {
245 throw Exception::Zero(">>> (PDE_TopoOpt::Hessian_22): Hessian is zero.");
246 }
247
248 void RieszMap_1(ROL::Ptr<Intrepid::FieldContainer<Real>> & riesz) {
249 //throw Exception::NotImplemented(">>> (PDE_TopoOpt::RieszMap_1): Not implemented.");
250
251 // Retrieve dimensions.
252 int c = fe_->gradN()->dimension(0);
253 int f = fe_->gradN()->dimension(1);
254
255 // Initialize Riesz maps.
256 std::vector<std::vector<ROL::Ptr<Intrepid::FieldContainer<Real>>>> R(1);
257 R[0].push_back(ROL::makePtr<Intrepid::FieldContainer<Real>>(c,f,f));
258
259 *(R[0][0]) = *(fe_->stiffMat());
260
261 // Combine the Riesz maps.
262 FieldUtils::combineFieldCoeff<Real>(riesz, R, fieldInfo_, fieldInfo_);
263 }
264
265 void RieszMap_2(ROL::Ptr<Intrepid::FieldContainer<Real>> & riesz) {
266 //throw Exception::NotImplemented(">>> (PDE_TopoOpt::RieszMap_2): Not implemented.");
267
268 // Retrieve dimensions.
269 int c = feDens_->gradN()->dimension(0);
270 int f = feDens_->gradN()->dimension(1);
271 int T = numFieldsDens_;
272
273 // Initialize Riesz maps.
274 std::vector<std::vector<ROL::Ptr<Intrepid::FieldContainer<Real>>>> R(T);
275 for (int i=0; i<T; ++i) {
276 for (int j=0; j<T; ++j) {
277 R[i].push_back(ROL::makePtr<Intrepid::FieldContainer<Real>>(c,f,f));
278 }
279 }
280
281 for (int i=0; i<T; ++i) {
282 *(R[i][i]) = *(fe_->massMat());
283 }
284
285 // Combine the Riesz maps.
286 FieldUtils::combineFieldCoeff<Real>(riesz, R, fieldInfoDens_, fieldInfoDens_);
287 }
288
289 std::vector<ROL::Ptr<Intrepid::Basis<Real, Intrepid::FieldContainer<Real>>>> getFields() {
290 return basisPtrs_;
291 }
292
293 std::vector<ROL::Ptr<Intrepid::Basis<Real, Intrepid::FieldContainer<Real>>>> getFields2() {
294 return basisPtrsDens_;
295 }
296
297 void setCellNodes(const ROL::Ptr<Intrepid::FieldContainer<Real>> &volCellNodes,
298 const std::vector<std::vector<ROL::Ptr<Intrepid::FieldContainer<Real>>>> &bdryCellNodes,
299 const std::vector<std::vector<std::vector<int>>> &bdryCellLocIds) {
300 volCellNodes_ = volCellNodes;
301 bdryCellNodes_ = bdryCellNodes;
302 bdryCellLocIds_ = bdryCellLocIds;
303 // Finite element definition.
304 fe_ = ROL::makePtr<FE<Real>>(volCellNodes_,basisPtr_,cellCub_,false);
305 feDens_ = ROL::makePtr<FE<Real>>(volCellNodes_,basisPtrDens_,cellCub_,false);
306 }
307
308 void setFieldPattern(const std::vector<std::vector<int>> &fieldPattern,
309 const std::vector<std::vector<int>> &fieldPattern2) {
310 fieldPattern_ = fieldPattern;
311 fieldPatternDens_ = fieldPattern2;
312 fieldInfo_ = ROL::makePtr<FieldUtils::FieldInfo>(numFields_, numDofs_, numFieldDofs_, fieldPattern_);
313 fieldInfoDens_ = ROL::makePtr<FieldUtils::FieldInfo>(numFieldsDens_, numDofsDens_, numFieldDofsDens_, fieldPatternDens_);
314 }
315
316 const ROL::Ptr<FE<Real>> getFE(void) const {
317 return fe_;
318 }
319
320 const ROL::Ptr<FE<Real>> getDensityFE(void) const {
321 return feDens_;
322 }
323
324 const ROL::Ptr<FieldUtils::FieldInfo> getFieldInfo(void) const {
325 return fieldInfo_;
326 }
327
328 const ROL::Ptr<FieldUtils::FieldInfo> getDensityFieldInfo(void) const {
329 return fieldInfoDens_;
330 }
331
332 }; // PDE_TopoOpt
333
334 #endif