Debian Codegraph @

packages/rol/example/PDE-OPT/topo-opt/navier-stokes/pde_navier-stokes.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_navier-stokes.hpp
11 \brief Implements the local PDE interface for the Navier-Stokes control problem.
12 */
13
14 #ifndef PDE_NAVIERSTOKES_HPP
15 #define PDE_NAVIERSTOKES_HPP
16
17 #include "../../TOOLS/pde.hpp"
18 #include "../../TOOLS/fe.hpp"
19 #include "../../TOOLS/fieldhelper.hpp"
20 #include "impermiability.hpp"
21
22 #include "../../TOOLS/Intrepid_HGRAD_C0_FEM.hpp"
23 #include "Intrepid_HGRAD_QUAD_C1_FEM.hpp"
24 #include "Intrepid_HGRAD_QUAD_C2_FEM.hpp"
25 #include "Intrepid_HGRAD_HEX_C1_FEM.hpp"
26 #include "Intrepid_HGRAD_HEX_C2_FEM.hpp"
27 #include "Intrepid_DefaultCubatureFactory.hpp"
28 #include "Intrepid_FunctionSpaceTools.hpp"
29 #include "Intrepid_CellTools.hpp"
30
31 #include "ROL_Ptr.hpp"
32
33 template <class Real>
34 class PDE_NavierStokes : public PDE<Real> {
35 private:
36 // Finite element basis information
37 ROL::Ptr<Intrepid::Basis<Real, Intrepid::FieldContainer<Real>>> basisPtrVel_;
38 ROL::Ptr<Intrepid::Basis<Real, Intrepid::FieldContainer<Real>>> basisPtrPrs_;
39 ROL::Ptr<Intrepid::Basis<Real, Intrepid::FieldContainer<Real>>> basisPtrCtrl_;
40 std::vector<ROL::Ptr<Intrepid::Basis<Real, Intrepid::FieldContainer<Real>>>> basisPtrs_;
41 std::vector<ROL::Ptr<Intrepid::Basis<Real, Intrepid::FieldContainer<Real>>>> basisPtrsCtrl_;
42 // Cell cubature information
43 ROL::Ptr<Intrepid::Cubature<Real>> cellCub_;
44 ROL::Ptr<Intrepid::Cubature<Real>> bdryCub_;
45 // Cell node information
46 ROL::Ptr<Intrepid::FieldContainer<Real>> volCellNodes_;
47 std::vector<std::vector<ROL::Ptr<Intrepid::FieldContainer<Real>>>> bdryCellNodes_;
48 std::vector<std::vector<std::vector<int>>> bdryCellLocIds_;
49 // Finite element definition
50 ROL::Ptr<FE<Real>> feVel_;
51 ROL::Ptr<FE<Real>> fePrs_;
52 ROL::Ptr<FE<Real>> feCtrl_;
53 std::vector<std::vector<ROL::Ptr<FE<Real>>>> feVelBdry_;
54 // Local degrees of freedom on boundary, for each side of the reference cell (first index).
55 std::vector<std::vector<int>> fvidx_;
56 std::vector<std::vector<int>> fpidx_;
57 // Coordinates of degrees freedom on boundary cells.
58 // Indexing: [sideset number][local side id](cell number, value at dof)
59 std::vector<std::vector<ROL::Ptr<Intrepid::FieldContainer<Real>>>> bdryCellDofValues_;
60 // Field pattern, offsets, etc.
61 std::vector<std::vector<int>> fieldPattern_; // local Field/DOF pattern; set from DOF manager
62 int numFields_; // number of fields (equations in the PDE)
63 int numDofs_; // total number of degrees of freedom for all (local) fields
64 std::vector<int> offset_; // for each field, a counting offset
65 std::vector<int> numFieldDofs_; // for each field, number of degrees of freedom
66 std::vector<std::vector<int>> fieldPatternCtrl_; // local Field/DOF pattern; set from DOF manager
67 int numFieldsCtrl_; // number of fields (equations in the PDE)
68 int numDofsCtrl_; // total number of degrees of freedom for all (local) fields
69 std::vector<int> offsetCtrl_; // for each field, a counting offset
70 std::vector<int> numFieldDofsCtrl_; // for each field, number of degrees of freedom
71
72 // Problem parameters.
73 Real viscosity_;
74
75 ROL::Ptr<Impermiability<Real>> imp_;
76 ROL::Ptr<FieldHelper<Real>> fieldHelper_;
77 ROL::Ptr<FieldUtils::FieldInfo> fieldInfo_, fieldInfoCtrl_;
78
79 // Extract velocity coefficients on boundary.
80 ROL::Ptr<Intrepid::FieldContainer<Real>> getBoundaryCoeff(
81 const Intrepid::FieldContainer<Real> & cell_coeff,
82 int sideSet, int cell) const {
83 std::vector<int> bdryCellLocId = bdryCellLocIds_[sideSet][cell];
84 const int numCellsSide = bdryCellLocId.size();
85 const int f = basisPtrVel_->getCardinality();
86
87 ROL::Ptr<Intrepid::FieldContainer<Real >> bdry_coeff =
88 ROL::makePtr<Intrepid::FieldContainer<Real >>(numCellsSide, f);
89 for (int i = 0; i < numCellsSide; ++i) {
90 for (int j = 0; j < f; ++j) {
91 (*bdry_coeff)(i, j) = cell_coeff(bdryCellLocId[i], j);
92 }
93 }
94 return bdry_coeff;
95 }
96
97 Real DirichletFunc(const std::vector<Real> & coords, int sideset, int locSideId, int dir) const {
98 const std::vector<Real> param = PDE<Real>::getParameter();
99 Real val(0);
100 if ((sideset==1) && (dir==0)) { // inflow
101 const Real one(1), four(4);
102 val = four*coords[1]*(one-coords[1]);
103 }
104 else if ((sideset==0) && (dir==0)) { // outflow
105 const Real one(1), two(2), three(3), c(108);
106 val = c*(coords[1]-one/three)*(two/three-coords[1]);
107 }
108 return val;
109 }
110
111 void computeDirichlet(void) {
112 // Compute Dirichlet values at DOFs.
113 int d = basisPtrVel_->getBaseCellTopology().getDimension();
114 int numSidesets = bdryCellLocIds_.size();
115 bdryCellDofValues_.resize(numSidesets);
116 for (int i=0; i<numSidesets; ++i) {
117 int numLocSides = bdryCellLocIds_[i].size();
118 bdryCellDofValues_[i].resize(numLocSides);
119 for (int j=0; j<numLocSides; ++j) {
120 int c = bdryCellLocIds_[i][j].size();
121 int f = basisPtrVel_->getCardinality();
122 bdryCellDofValues_[i][j] = ROL::makePtr<Intrepid::FieldContainer<Real>>(c, f, d);
123 ROL::Ptr<Intrepid::FieldContainer<Real>> coords =
124 ROL::makePtr<Intrepid::FieldContainer<Real>>(c, f, d);
125 if (c > 0) {
126 feVel_->computeDofCoords(coords, bdryCellNodes_[i][j]);
127 }
128 for (int k=0; k<c; ++k) {
129 for (int l=0; l<f; ++l) {
130 std::vector<Real> dofpoint(d);
131 //std::cout << "Sideset " << i << " LocalSide " << j << " Cell " << k << " Field " << l << " Coord ";
132 for (int m=0; m<d; ++m) {
133 dofpoint[m] = (*coords)(k, l, m);
134 //std::cout << dofpoint[m] << " ";
135 }
136
137 for (int m=0; m<d; ++m) {
138 (*bdryCellDofValues_[i][j])(k, l, m) = DirichletFunc(dofpoint, i, j, m);
139 //std::cout << " " << m << "-Value " << DirichletFunc(dofpoint, i, j, m);
140 }
141 //std::cout << std::endl;
142 }
143 }
144 }
145 }
146 }
147
148 Real viscosityFunc(const std::vector<Real> & coords) const {
149 return viscosity_;
150 }
151
152 void computeViscosity(ROL::Ptr<Intrepid::FieldContainer<Real>> &nu) const {
153 int c = feVel_->gradN()->dimension(0);
154 int p = feVel_->gradN()->dimension(2);
155 int d = feVel_->gradN()->dimension(3);
156 std::vector<Real> pt(d);
157 for (int i = 0; i < c; ++i) {
158 for (int j = 0; j < p; ++j) {
159 for ( int k = 0; k < d; ++k) {
160 pt[k] = (*feVel_->cubPts())(i,j,k);
161 }
162 // Compute spatially dependent viscosity
163 (*nu)(i,j) = viscosityFunc(pt);
164 }
165 }
166 }
167
168 public:
169 PDE_NavierStokes(Teuchos::ParameterList &parlist) {
170 // Finite element fields.
171 int cubDegree = parlist.sublist("Problem").get("Cubature Degree",4);
172 int bdryCubDegree = parlist.sublist("Problem").get("Boundary Cubature Degree",2);
173 int probDim = parlist.sublist("Problem").get("Problem Dimension",2);
174 int basisDegCtrl = parlist.sublist("Problem").get("Density Basis Degree",1);
175 if (probDim > 3 || probDim < 2) {
176 TEUCHOS_TEST_FOR_EXCEPTION(true, std::invalid_argument,
177 ">>> PDE-OPT/projects/navier-stokes-topopt/pde_navier-stokes.hpp: Problem dimension is not 2 or 3!");
178 }
179 if (probDim == 2) {
180 basisPtrVel_ = ROL::makePtr<Intrepid::Basis_HGRAD_QUAD_C2_FEM<Real, Intrepid::FieldContainer<Real>>>();
181 basisPtrPrs_ = ROL::makePtr<Intrepid::Basis_HGRAD_QUAD_C1_FEM<Real, Intrepid::FieldContainer<Real>>>();
182 if (basisDegCtrl == 1) {
183 basisPtrCtrl_ = ROL::makePtr<Intrepid::Basis_HGRAD_QUAD_C1_FEM<Real, Intrepid::FieldContainer<Real>>>();
184 }
185 else {
186 basisPtrCtrl_ = ROL::makePtr<Intrepid::Basis_HGRAD_C0_FEM<Real, Intrepid::FieldContainer<Real>>>();
187 }
188 }
189 else if (probDim == 3) {
190 basisPtrVel_ = ROL::makePtr<Intrepid::Basis_HGRAD_HEX_C2_FEM<Real, Intrepid::FieldContainer<Real>>>();
191 basisPtrPrs_ = ROL::makePtr<Intrepid::Basis_HGRAD_HEX_C1_FEM<Real, Intrepid::FieldContainer<Real>>>();
192 basisPtrCtrl_ = ROL::makePtr<Intrepid::Basis_HGRAD_HEX_C1_FEM<Real, Intrepid::FieldContainer<Real>>>();
193 }
194 basisPtrs_.clear(); basisPtrsCtrl_.clear();
195 for (int i=0; i<probDim; ++i) {
196 basisPtrs_.push_back(basisPtrVel_); // Velocity component
197 }
198 basisPtrs_.push_back(basisPtrPrs_); // Pressure component
199 basisPtrsCtrl_.push_back(basisPtrCtrl_); // Control component
200 // Quadrature rules.
201 shards::CellTopology cellType = basisPtrs_[0]->getBaseCellTopology(); // get the cell type from any basis
202 Intrepid::DefaultCubatureFactory<Real> cubFactory; // create cubature factory
203 cellCub_ = cubFactory.create(cellType, cubDegree); // create default cubature
204
205 shards::CellTopology bdryCellType = cellType.getCellTopologyData(probDim-1, 0);
206 bdryCub_ = cubFactory.create(bdryCellType, bdryCubDegree);
207
208 // Other problem parameters.
209 viscosity_ = parlist.sublist("Problem").get("Viscosity", 5e-3);
210 imp_ = ROL::makePtr<Impermiability<Real>>(parlist);
211
212 numDofs_ = 0;
213 numFields_ = basisPtrs_.size();
214 offset_.resize(numFields_);
215 numFieldDofs_.resize(numFields_);
216 for (int i=0; i<numFields_; ++i) {
217 if (i==0) {
218 offset_[i] = 0;
219 }
220 else {
221 offset_[i] = offset_[i-1] + basisPtrs_[i-1]->getCardinality();
222 }
223 numFieldDofs_[i] = basisPtrs_[i]->getCardinality();
224 numDofs_ += numFieldDofs_[i];
225 }
226 numDofsCtrl_ = 0;
227 numFieldsCtrl_ = basisPtrsCtrl_.size();
228 offsetCtrl_.resize(numFieldsCtrl_);
229 numFieldDofsCtrl_.resize(numFieldsCtrl_);
230 for (int i=0; i<numFieldsCtrl_; ++i) {
231 if (i==0) {
232 offsetCtrl_[i] = 0;
233 }
234 else {
235 offsetCtrl_[i] = offsetCtrl_[i-1] + basisPtrsCtrl_[i-1]->getCardinality();
236 }
237 numFieldDofsCtrl_[i] = basisPtrsCtrl_[i]->getCardinality();
238 numDofsCtrl_ += numFieldDofsCtrl_[i];
239 }
240 }
241
242 void residual(ROL::Ptr<Intrepid::FieldContainer<Real>> & res,
243 const ROL::Ptr<const Intrepid::FieldContainer<Real>> & u_coeff,
244 const ROL::Ptr<const Intrepid::FieldContainer<Real>> & z_coeff = ROL::nullPtr,
245 const ROL::Ptr<const std::vector<Real>> & z_param = ROL::nullPtr) override {
246 // Retrieve dimensions.
247 const int c = feVel_->gradN()->dimension(0);
248 const int fv = feVel_->gradN()->dimension(1);
249 const int fp = fePrs_->gradN()->dimension(1);
250 const int p = feVel_->gradN()->dimension(2);
251 const int d = feVel_->gradN()->dimension(3);
252 // Initialize residuals.
253 std::vector<ROL::Ptr<Intrepid::FieldContainer<Real>>> R;
254 R.resize(numFields_);
255 for (int i = 0; i < d; ++i) {
256 R[i] = ROL::makePtr<Intrepid::FieldContainer<Real>>(c, fv);
257 }
258 R[d] = ROL::makePtr<Intrepid::FieldContainer<Real>>(c, fp);
259 // Split coefficients into components.
260 std::vector<ROL::Ptr<Intrepid::FieldContainer<Real>>> U, Z;
261 FieldUtils::splitFieldCoeff<Real>(U, u_coeff, fieldInfo_);
262 FieldUtils::splitFieldCoeff<Real>(Z, z_coeff, fieldInfoCtrl_);
263 // Evaluate/interpolate finite element fields on cells.
264 std::vector<ROL::Ptr<Intrepid::FieldContainer<Real>>> nuGradVel(d), valVel(d), gradVel(d), valVelDotgradVel(d), alphaVel(d);
265 ROL::Ptr<Intrepid::FieldContainer<Real>> nu, valVel0, valPres, divVel, valCtrl, alpha;
266 nu = ROL::makePtr<Intrepid::FieldContainer<Real>>(c, p);
267 valVel0 = ROL::makePtr<Intrepid::FieldContainer<Real>>(c, p, d);
268 valPres = ROL::makePtr<Intrepid::FieldContainer<Real>>(c, p);
269 divVel = ROL::makePtr<Intrepid::FieldContainer<Real>>(c, p);
270 valCtrl = ROL::makePtr<Intrepid::FieldContainer<Real>>(c, p);
271 alpha = ROL::makePtr<Intrepid::FieldContainer<Real>>(c, p);
272 computeViscosity(nu);
273 feCtrl_->evaluateValue(valCtrl, Z[0]);
274 imp_->compute(alpha, valCtrl, feVel_->cubPts(), 0);
275 for (int i = 0; i < d; ++i) {
276 nuGradVel[i] = ROL::makePtr<Intrepid::FieldContainer<Real>>(c, p, d);
277 valVel[i] = ROL::makePtr<Intrepid::FieldContainer<Real>>(c, p);
278 gradVel[i] = ROL::makePtr<Intrepid::FieldContainer<Real>>(c, p, d);
279 valVelDotgradVel[i] = ROL::makePtr<Intrepid::FieldContainer<Real>>(c, p);
280 alphaVel[i] = ROL::makePtr<Intrepid::FieldContainer<Real>>(c, p);
281 // Evaluate on FE basis
282 feVel_->evaluateValue(valVel[i], U[i]);
283 feVel_->evaluateGradient(gradVel[i], U[i]);
284 // Multiply velocity gradients with viscosity.
285 Intrepid::FunctionSpaceTools::tensorMultiplyDataData<Real>(*nuGradVel[i], *nu, *gradVel[i]);
286 // Multiply velocity with alpha
287 Intrepid::FunctionSpaceTools::scalarMultiplyDataData<Real>(*alphaVel[i], *alpha, *valVel[i]);
288 // Assemble the velocity vector and its divergence.
289 for (int j = 0; j < c; ++j) {
290 for (int k = 0; k < p; ++k) {
291 (*valVel0)(j,k,i) = (*valVel[i])(j,k);
292 (*divVel)(j,k) += (*gradVel[i])(j,k,i);
293 }
294 }
295 }
296 // Compute nonlinear terms in the Navier-Stokes equations.
297 for (int i = 0; i < d; ++i) {
298 Intrepid::FunctionSpaceTools::dotMultiplyDataData<Real>(*valVelDotgradVel[i], *valVel0, *gradVel[i]);
299 }
300 // Negative pressure
301 fePrs_->evaluateValue(valPres, U[d]);
302 Intrepid::RealSpaceTools<Real>::scale(*valPres, static_cast<Real>(-1));
303 /*** Evaluate weak form of the residual. ***/
304 // Velocity equation.
305 for (int i = 0; i < d; ++i) {
306 Intrepid::FunctionSpaceTools::integrate<Real>(*R[i],
307 *nuGradVel[i], // nu gradUX
308 *(feVel_->gradNdetJ()), // gradPhi
309 Intrepid::COMP_CPP,
310 false);
311 Intrepid::FunctionSpaceTools::integrate<Real>(*R[i],
312 *valVelDotgradVel[i], // (U . gradUX)
313 *(feVel_->NdetJ()), // Phi
314 Intrepid::COMP_CPP,
315 true);
316 Intrepid::FunctionSpaceTools::integrate<Real>(*R[i],
317 *valPres, // p
318 *(feVel_->DNDdetJ(i)), // dPhi/dx
319 Intrepid::COMP_CPP,
320 true);
321 Intrepid::FunctionSpaceTools::integrate<Real>(*R[i],
322 *alphaVel[i], // alpha UX
323 *(feVel_->NdetJ()), // Phi
324 Intrepid::COMP_CPP,
325 true);
326 }
327 // Pressure equation.
328 Intrepid::FunctionSpaceTools::integrate<Real>(*R[d],
329 *divVel, // divU
330 *(fePrs_->NdetJ()), // Phi
331 Intrepid::COMP_CPP,
332 false);
333 Intrepid::RealSpaceTools<Real>::scale(*R[d], static_cast<Real>(-1));
334 // Boundary conditions.
335 int numSideSets = bdryCellLocIds_.size();
336 if (numSideSets > 0) {
337 // APPLY DIRICHLET CONDITIONS
338 computeDirichlet();
339 for (int i = 0; i < numSideSets; ++i) {
340 if (i==1 /* in flow */ || i==2 /* no slip */ ) { //|| i==0 /* out flow */) {
341 int numLocalSideIds = bdryCellLocIds_[i].size();
342 for (int j = 0; j < numLocalSideIds; ++j) {
343 int numCellsSide = bdryCellLocIds_[i][j].size();
344 int numBdryDofs = fvidx_[j].size();
345 for (int k = 0; k < numCellsSide; ++k) {
346 int cidx = bdryCellLocIds_[i][j][k];
347 for (int l = 0; l < numBdryDofs; ++l) {
348 //std::cout << "\n i=" << i << " cidx=" << cidx << " j=" << j << " l=" << l << " " << fvidx_[j][l] << " " << (*bdryCellDofValues_[i][j])(k,fvidx_[j][l],0);
349 //std::cout << "\n i=" << i << " cidx=" << cidx << " j=" << j << " l=" << l << " " << fvidx_[j][l] << " " << (*bdryCellDofValues_[i][j])(k,fvidx_[j][l],1);
350 for (int m=0; m < d; ++m) {
351 (*R[m])(cidx,fvidx_[j][l]) = (*U[m])(cidx,fvidx_[j][l]) - (*bdryCellDofValues_[i][j])(k,fvidx_[j][l],m);
352 }
353 }
354 }
355 }
356 }
357 }
358 }
359 // Combine the residuals.
360 FieldUtils::combineFieldCoeff<Real>(res, R, fieldInfo_);
361 }
362
363 void Jacobian_1(ROL::Ptr<Intrepid::FieldContainer<Real>> & jac,
364 const ROL::Ptr<const Intrepid::FieldContainer<Real>> & u_coeff,
365 const ROL::Ptr<const Intrepid::FieldContainer<Real>> & z_coeff = ROL::nullPtr,
366 const ROL::Ptr<const std::vector<Real>> & z_param = ROL::nullPtr) override {
367 // Retrieve dimensions.
368 const int c = feVel_->gradN()->dimension(0);
369 const int fv = feVel_->gradN()->dimension(1);
370 const int fp = fePrs_->gradN()->dimension(1);
371 const int p = feVel_->gradN()->dimension(2);
372 const int d = feVel_->gradN()->dimension(3);
373 // Initialize Jacobians.
374 std::vector<std::vector<ROL::Ptr<Intrepid::FieldContainer<Real>>>> J(numFields_);
375 J[d].resize(numFields_);
376 for (int i = 0; i < d; ++i) {
377 J[i].resize(numFields_);
378 for (int j = 0; j < d; ++j) {
379 J[i][j] = ROL::makePtr<Intrepid::FieldContainer<Real>>(c, fv, fv);
380 }
381 J[i][d] = ROL::makePtr<Intrepid::FieldContainer<Real>>(c, fv, fp);
382 J[d][i] = ROL::makePtr<Intrepid::FieldContainer<Real>>(c, fp, fv);
383 }
384 J[d][d] = ROL::makePtr<Intrepid::FieldContainer<Real>>(c, fp, fp);
385 // Split coefficients into components.
386 std::vector<ROL::Ptr<Intrepid::FieldContainer<Real>>> U, Z;
387 FieldUtils::splitFieldCoeff<Real>(U, u_coeff, fieldInfo_);
388 FieldUtils::splitFieldCoeff<Real>(Z, z_coeff, fieldInfoCtrl_);
389 // Evaluate/interpolate finite element fields on cells.
390 std::vector<ROL::Ptr<Intrepid::FieldContainer<Real>>> valVel(d), gradVel(d);
391 std::vector<std::vector<ROL::Ptr<Intrepid::FieldContainer<Real>>>> dVel(d), dVelPhi(d);
392 ROL::Ptr<Intrepid::FieldContainer<Real>> nu, nuGradPhi, alpha, alphaPhi, valCtrl;
393 ROL::Ptr<Intrepid::FieldContainer<Real>> valVel0, valVelDotgradPhi;
394 nu = ROL::makePtr<Intrepid::FieldContainer<Real>>(c, p);
395 nuGradPhi = ROL::makePtr<Intrepid::FieldContainer<Real>>(c, fv, p, d);
396 valCtrl = ROL::makePtr<Intrepid::FieldContainer<Real>>(c, p);
397 alpha = ROL::makePtr<Intrepid::FieldContainer<Real>>(c, p);
398 alphaPhi = ROL::makePtr<Intrepid::FieldContainer<Real>>(c, fv, p);
399 valVel0 = ROL::makePtr<Intrepid::FieldContainer<Real>>(c, p, d);
400 valVelDotgradPhi = ROL::makePtr<Intrepid::FieldContainer<Real>>(c, fv, p);
401 computeViscosity(nu);
402 feCtrl_->evaluateValue(valCtrl, Z[0]);
403 imp_->compute(alpha, valCtrl, feVel_->cubPts(), 0);
404 for (int i = 0; i < d; ++i) {
405 valVel[i] = ROL::makePtr<Intrepid::FieldContainer<Real>>(c, p);
406 gradVel[i] = ROL::makePtr<Intrepid::FieldContainer<Real>>(c, p, d);
407 feVel_->evaluateValue(valVel[i], U[i]);
408 feVel_->evaluateGradient(gradVel[i], U[i]);
409 for (int j = 0; j < c; ++j) {
410 for (int k = 0; k < p; ++k) {
411 (*valVel0)(j,k,i) = (*valVel[i])(j,k);
412 }
413 }
414 dVel[i].resize(d);
415 dVelPhi[i].resize(d);
416 for (int j = 0; j < d; ++j) {
417 dVel[i][j] = ROL::makePtr<Intrepid::FieldContainer<Real>>(c, p);
418 dVelPhi[i][j] = ROL::makePtr<Intrepid::FieldContainer<Real>>(c, fv, p);
419 for (int k = 0; k < c; ++k) {
420 for (int l = 0; l < p; ++l) {
421 (*dVel[i][j])(k,l) = (*gradVel[i])(k,l,j);
422 }
423 }
424 }
425 }
426 // Multiply velocity gradients with viscosity.
427 Intrepid::FunctionSpaceTools::tensorMultiplyDataField<Real>(*nuGradPhi, *nu, *(feVel_->gradN()));
428 // Compute nonlinear terms in the Navier-Stokes equations.
429 Intrepid::FunctionSpaceTools::dotMultiplyDataField<Real>(*valVelDotgradPhi, *valVel0, *(feVel_->gradN()));
430 for (int i = 0; i < d; ++i) {
431 for (int j = 0; j < d; ++j) {
432 Intrepid::FunctionSpaceTools::scalarMultiplyDataField<Real>(*dVelPhi[i][j], *dVel[i][j], *(feVel_->N()));
433 }
434 }
435 // Multiply velocity with alpha
436 Intrepid::FunctionSpaceTools::scalarMultiplyDataField<Real>(*alphaPhi, *alpha, *(feVel_->N()));
437 // Negative pressure basis.
438 Intrepid::FieldContainer<Real> negPrsN(*(fePrs_->N()));
439 Intrepid::RealSpaceTools<Real>::scale(negPrsN, static_cast<Real>(-1));
440 /*** Evaluate weak form of the Jacobian. ***/
441 for (int i = 0; i < d; ++i) {
442 // Velocity equation.
443 Intrepid::FunctionSpaceTools::integrate<Real>(*J[i][i],
444 *nuGradPhi, // nu gradPsi
445 *(feVel_->gradNdetJ()), // gradPhi
446 Intrepid::COMP_CPP,
447 false);
448 Intrepid::FunctionSpaceTools::integrate<Real>(*J[i][i],
449 *(feVel_->NdetJ()), // Phi
450 *valVelDotgradPhi, // (U . gradPhiX)
451 Intrepid::COMP_CPP,
452 true);
453 Intrepid::FunctionSpaceTools::integrate<Real>(*J[i][i],
454 *alphaPhi, // alpha Phi
455 *(feVel_->NdetJ()), // Phi
456 Intrepid::COMP_CPP,
457 true);
458 for (int j = 0; j < d; ++j) {
459 Intrepid::FunctionSpaceTools::integrate<Real>(*J[i][j],
460 *(feVel_->NdetJ()), // Phi
461 *dVelPhi[i][j], // (Phi . gradU)
462 Intrepid::COMP_CPP,
463 true);
464 }
465 Intrepid::FunctionSpaceTools::integrate<Real>(*J[i][d],
466 *(feVel_->DNDdetJ(i)), // dPhi/dx
467 negPrsN, // -Phi
468 Intrepid::COMP_CPP,
469 false);
470 // Pressure equation.
471 Intrepid::FunctionSpaceTools::integrate<Real>(*J[d][i],
472 *(fePrs_->NdetJ()), // Phi
473 *(feVel_->DND(i)), // dPhi/dx
474 Intrepid::COMP_CPP,
475 false);
476 Intrepid::RealSpaceTools<Real>::scale(*J[d][i], static_cast<Real>(-1));
477 }
478 // APPLY DIRICHLET CONDITIONS
479 int numSideSets = bdryCellLocIds_.size();
480 if (numSideSets > 0) {
481 for (int i = 0; i < numSideSets; ++i) {
482 if (i==1 /* in flow */ || i==2 /* no slip */ ) { // || i==0 /* out flow */) {
483 int numLocalSideIds = bdryCellLocIds_[i].size();
484 for (int j = 0; j < numLocalSideIds; ++j) {
485 int numCellsSide = bdryCellLocIds_[i][j].size();
486 int numBdryDofs = fvidx_[j].size();
487 for (int k = 0; k < numCellsSide; ++k) {
488 int cidx = bdryCellLocIds_[i][j][k];
489 for (int l = 0; l < numBdryDofs; ++l) {
490 for (int m=0; m < fv; ++m) {
491 for (int n=0; n < d; ++n) {
492 for (int p=0; p < d; ++p) {
493 (*J[n][p])(cidx,fvidx_[j][l],m) = static_cast<Real>(0);
494 }
495 (*J[n][n])(cidx,fvidx_[j][l],fvidx_[j][l]) = static_cast<Real>(1);
496 }
497 }
498 for (int m=0; m < fp; ++m) {
499 for (int n=0; n < d; ++n) {
500 (*J[n][d])(cidx,fvidx_[j][l],m) = static_cast<Real>(0);
501 }
502 }
503 }
504 }
505 }
506 }
507 }
508 }
509 // Combine the jacobians.
510 FieldUtils::combineFieldCoeff<Real>(jac, J, fieldInfo_, fieldInfo_);
511 }
512
513
514 void Jacobian_2(ROL::Ptr<Intrepid::FieldContainer<Real>> & jac,
515 const ROL::Ptr<const Intrepid::FieldContainer<Real>> & u_coeff,
516 const ROL::Ptr<const Intrepid::FieldContainer<Real>> & z_coeff = ROL::nullPtr,
517 const ROL::Ptr<const std::vector<Real>> & z_param = ROL::nullPtr) override {
518 // Retrieve dimensions.
519 const int c = feVel_->gradN()->dimension(0);
520 const int fv = feVel_->gradN()->dimension(1);
521 const int fp = fePrs_->gradN()->dimension(1);
522 const int fc = feCtrl_->gradN()->dimension(1);
523 const int p = feVel_->gradN()->dimension(2);
524 const int d = feVel_->gradN()->dimension(3);
525 // Initialize Jacobians.
526 std::vector<std::vector<ROL::Ptr<Intrepid::FieldContainer<Real>>>> J(numFields_);
527 for (int i = 0; i < d; ++i) {
528 J[i].resize(1,ROL::nullPtr);
529 J[i][0] = ROL::makePtr<Intrepid::FieldContainer<Real>>(c, fv, fc);
530 }
531 J[d].resize(1,ROL::nullPtr);
532 J[d][0] = ROL::makePtr<Intrepid::FieldContainer<Real>>(c, fp, fc);
533 // Split coefficients into components.
534 std::vector<ROL::Ptr<Intrepid::FieldContainer<Real>>> U, Z;
535 FieldUtils::splitFieldCoeff<Real>(U, u_coeff, fieldInfo_);
536 FieldUtils::splitFieldCoeff<Real>(Z, z_coeff, fieldInfoCtrl_);
537 // Evaluate on FE basis.
538 ROL::Ptr<Intrepid::FieldContainer<Real>> valCtrl, alpha, alphaPhi, valVel, alphaU;
539 valCtrl = ROL::makePtr<Intrepid::FieldContainer<Real>>(c, p);
540 alpha = ROL::makePtr<Intrepid::FieldContainer<Real>>(c, p);
541 alphaPhi = ROL::makePtr<Intrepid::FieldContainer<Real>>(c, fc, p);
542 valVel = ROL::makePtr<Intrepid::FieldContainer<Real>>(c, p);
543 alphaU = ROL::makePtr<Intrepid::FieldContainer<Real>>(c, fc, p);
544 feCtrl_->evaluateValue(valCtrl, Z[0]);
545 imp_->compute(alpha, valCtrl, feVel_->cubPts(), 1);
546 Intrepid::FunctionSpaceTools::scalarMultiplyDataField<Real>(*alphaPhi, *alpha, *feCtrl_->N());
547 for (int i = 0; i < d; ++i) {
548 alphaU->initialize();
549 valVel->initialize();
550 feVel_->evaluateValue(valVel, U[i]);
551 // Multiply velocity with alpha
552 Intrepid::FunctionSpaceTools::scalarMultiplyDataField<Real>(*alphaU, *valVel, *alphaPhi);
553 // Integrate
554 Intrepid::FunctionSpaceTools::integrate<Real>(*J[i][0],
555 *feVel_->NdetJ(), // Phi
556 *alphaU, // alpha' Phi U
557 Intrepid::COMP_CPP,
558 false);
559 }
560 // APPLY DIRICHLET CONDITIONS
561 int numSideSets = bdryCellLocIds_.size();
562 if (numSideSets > 0) {
563 for (int i = 0; i < numSideSets; ++i) {
564 if (i==1 /* in flow */ || i==2 /* no slip */ ) { // || i==0 /* out flow */) {
565 int numLocalSideIds = bdryCellLocIds_[i].size();
566 for (int j = 0; j < numLocalSideIds; ++j) {
567 int numCellsSide = bdryCellLocIds_[i][j].size();
568 int numBdryDofs = fvidx_[j].size();
569 for (int k = 0; k < numCellsSide; ++k) {
570 int cidx = bdryCellLocIds_[i][j][k];
571 for (int l = 0; l < numBdryDofs; ++l) {
572 //std::cout << "\n j=" << j << " l=" << l << " " << fidx[j][l];
573 for (int n=0; n < d; ++n) {
574 for (int m=0; m < fc; ++m) {
575 (*J[n][0])(cidx,fvidx_[j][l],m) = static_cast<Real>(0);
576 }
577 }
578 //for (int m=0; m < fc; ++m) {
579 // (*J[d][0])(cidx,fpidx_[j][l],m) = static_cast<Real>(0);
580 //}
581 }
582 }
583 }
584 }
585 }
586 }
587 // Combine the jacobians.
588 FieldUtils::combineFieldCoeff<Real>(jac, J, fieldInfo_, fieldInfoCtrl_);
589 }
590
591 void Hessian_11(ROL::Ptr<Intrepid::FieldContainer<Real>> & hess,
592 const ROL::Ptr<const Intrepid::FieldContainer<Real>> & l_coeff,
593 const ROL::Ptr<const Intrepid::FieldContainer<Real>> & u_coeff,
594 const ROL::Ptr<const Intrepid::FieldContainer<Real>> & z_coeff = ROL::nullPtr,
595 const ROL::Ptr<const std::vector<Real>> & z_param = ROL::nullPtr) override {
596 // Retrieve dimensions.
597 const int c = feVel_->gradN()->dimension(0);
598 const int fv = feVel_->gradN()->dimension(1);
599 const int fp = fePrs_->gradN()->dimension(1);
600 const int p = feVel_->gradN()->dimension(2);
601 const int d = feVel_->gradN()->dimension(3);
602 // Initialize hessians.
603 std::vector<std::vector<ROL::Ptr<Intrepid::FieldContainer<Real>>>> H;
604 H.resize(numFields_);
605 H[d].resize(numFields_);
606 for (int i = 0; i < d; ++i) {
607 H[i].resize(numFields_);
608 for (int j = 0; j < d; ++j) {
609 H[i][j] = ROL::makePtr<Intrepid::FieldContainer<Real>>(c, fv, fv);
610 }
611 H[i][d] = ROL::makePtr<Intrepid::FieldContainer<Real>>(c, fv, fp);
612 H[d][i] = ROL::makePtr<Intrepid::FieldContainer<Real>>(c, fp, fv);
613 }
614 H[d][d] = ROL::makePtr<Intrepid::FieldContainer<Real>>(c, fp, fp);
615 // Split coefficients into components.
616 std::vector<ROL::Ptr<Intrepid::FieldContainer<Real>>> L;
617 FieldUtils::splitFieldCoeff<Real>(L, l_coeff, fieldInfo_);
618 // Apply Dirichlet conditions
619 int numSideSets = bdryCellLocIds_.size();
620 if (numSideSets > 0) {
621 for (int i = 0; i < numSideSets; ++i) {
622 if (i==1 /* in flow */ || i==2 /* no slip */ ) { // || i==0 /* out flow */) {
623 int numLocalSideIds = bdryCellLocIds_[i].size();
624 for (int j = 0; j < numLocalSideIds; ++j) {
625 int numCellsSide = bdryCellLocIds_[i][j].size();
626 int numBdryDofs = fvidx_[j].size();
627 for (int k = 0; k < numCellsSide; ++k) {
628 int cidx = bdryCellLocIds_[i][j][k];
629 for (int l = 0; l < numBdryDofs; ++l) {
630 //std::cout << "\n j=" << j << " l=" << l << " " << fidx[j][l];
631 for (int m=0; m < d; ++m) {
632 (*L[m])(cidx,fvidx_[j][l]) = static_cast<Real>(0);
633 }
634 }
635 }
636 }
637 }
638 }
639 }
640 // Evaluate/interpolate finite element fields on cells.
641 std::vector<ROL::Ptr<Intrepid::FieldContainer<Real>>> Lval(d), LPhi(d);
642 for (int i = 0; i < d; ++i) {
643 Lval[i] = ROL::makePtr<Intrepid::FieldContainer<Real>>(c, p);
644 LPhi[i] = ROL::makePtr<Intrepid::FieldContainer<Real>>(c, fv, p);
645 feVel_->evaluateValue(Lval[i], L[i]);
646 Intrepid::FunctionSpaceTools::scalarMultiplyDataField<Real>(*LPhi[i], *Lval[i], *(feVel_->N()));
647 }
648 /*** Evaluate weak form of the Hessian. ***/
649 for (int i = 0; i < d; ++i) {
650 Intrepid::FunctionSpaceTools::integrate<Real>(*H[i][i],
651 *LPhi[i], // L Phi
652 *(feVel_->DNDdetJ(i)), // dPhi/dx
653 Intrepid::COMP_CPP,
654 false);
655 Intrepid::FunctionSpaceTools::integrate<Real>(*H[i][i],
656 *(feVel_->DNDdetJ(i)), // dPhi/dx
657 *LPhi[i], // L Phi
658 Intrepid::COMP_CPP,
659 true);
660 for (int j = 0; j < d; ++j) {
661 Intrepid::FunctionSpaceTools::integrate<Real>(*H[i][j],
662 *(feVel_->DNDdetJ(j)), // dPhi/dy
663 *LPhi[i], // L Phi
664 Intrepid::COMP_CPP,
665 false);
666 Intrepid::FunctionSpaceTools::integrate<Real>(*H[i][j],
667 *LPhi[j], // L Phi
668 *(feVel_->DNDdetJ(i)), // dPhi/dx
669 Intrepid::COMP_CPP,
670 true);
671 }
672 }
673 // Combine the Hessians.
674 FieldUtils::combineFieldCoeff<Real>(hess, H, fieldInfo_, fieldInfo_);
675 }
676
677 void Hessian_12(ROL::Ptr<Intrepid::FieldContainer<Real>> & hess,
678 const ROL::Ptr<const Intrepid::FieldContainer<Real>> & l_coeff,
679 const ROL::Ptr<const Intrepid::FieldContainer<Real>> & u_coeff,
680 const ROL::Ptr<const Intrepid::FieldContainer<Real>> & z_coeff = ROL::nullPtr,
681 const ROL::Ptr<const std::vector<Real>> & z_param = ROL::nullPtr) override {
682 // Retrieve dimensions.
683 const int c = feVel_->gradN()->dimension(0);
684 const int fv = feVel_->gradN()->dimension(1);
685 const int fp = fePrs_->gradN()->dimension(1);
686 const int fc = feCtrl_->gradN()->dimension(1);
687 const int p = feVel_->gradN()->dimension(2);
688 const int d = feVel_->gradN()->dimension(3);
689 // Initialize hessians.
690 std::vector<std::vector<ROL::Ptr<Intrepid::FieldContainer<Real>>>> H(1);
691 H[0].resize(numFields_);
692 for (int i = 0; i < d; ++i) {
693 H[0][i] = ROL::makePtr<Intrepid::FieldContainer<Real>>(c, fc, fv);
694 }
695 H[0][d] = ROL::makePtr<Intrepid::FieldContainer<Real>>(c, fc, fp);
696 // Split coefficients into components.
697 std::vector<ROL::Ptr<Intrepid::FieldContainer<Real>>> L, Z;
698 FieldUtils::splitFieldCoeff<Real>(L, l_coeff, fieldInfo_);
699 FieldUtils::splitFieldCoeff<Real>(Z, z_coeff, fieldInfoCtrl_);
700 // Apply Dirichlet conditions
701 int numSideSets = bdryCellLocIds_.size();
702 if (numSideSets > 0) {
703 for (int i = 0; i < numSideSets; ++i) {
704 if (i==1 /* in flow */ || i==2 /* no slip */ ) { // || i==0 /* out flow */) {
705 int numLocalSideIds = bdryCellLocIds_[i].size();
706 for (int j = 0; j < numLocalSideIds; ++j) {
707 int numCellsSide = bdryCellLocIds_[i][j].size();
708 int numBdryDofs = fvidx_[j].size();
709 for (int k = 0; k < numCellsSide; ++k) {
710 int cidx = bdryCellLocIds_[i][j][k];
711 for (int l = 0; l < numBdryDofs; ++l) {
712 //std::cout << "\n j=" << j << " l=" << l << " " << fidx[j][l];
713 for (int m=0; m < d; ++m) {
714 (*L[m])(cidx,fvidx_[j][l]) = static_cast<Real>(0);
715 }
716 }
717 }
718 }
719 }
720 }
721 }
722 // Evaluate/interpolate finite element fields on cells.
723 ROL::Ptr<Intrepid::FieldContainer<Real>> Z0, alpha, Lval, alphaL;
724 Z0 = ROL::makePtr<Intrepid::FieldContainer<Real>>(c, p);
725 alpha = ROL::makePtr<Intrepid::FieldContainer<Real>>(c, p);
726 Lval = ROL::makePtr<Intrepid::FieldContainer<Real>>(c, p);
727 alphaL = ROL::makePtr<Intrepid::FieldContainer<Real>>(c, fc, p);
728 feCtrl_->evaluateValue(Z0, Z[0]);
729 imp_->compute(alpha, Z0, feVel_->cubPts(), 1);
730 /*** Evaluate weak form of the Hessian. ***/
731 // Velocity equation.
732 for (int i = 0; i < d; ++i) {
733 // Multiply velocity with alpha
734 Lval->initialize(); alphaL->initialize();
735 feVel_->evaluateValue(Lval, L[i]);
736 for (int j = 0; j < c; ++j) {
737 for (int k = 0; k < fc; ++k) {
738 for (int l = 0; l < p; ++l) {
739 (*alphaL)(j,k,l) = (*alpha)(j,l) * (*feCtrl_->N())(j,k,l) * (*Lval)(j,l);
740 }
741 }
742 }
743 Intrepid::FunctionSpaceTools::integrate<Real>(*H[0][i],
744 *alphaL, // alpha' L Phi
745 *(feVel_->NdetJ()), // Phi
746 Intrepid::COMP_CPP,
747 false);
748 }
749 // Combine the Hessians.
750 FieldUtils::combineFieldCoeff<Real>(hess, H, fieldInfoCtrl_, fieldInfo_);
751 }
752
753 void Hessian_21(ROL::Ptr<Intrepid::FieldContainer<Real>> & hess,
754 const ROL::Ptr<const Intrepid::FieldContainer<Real>> & l_coeff,
755 const ROL::Ptr<const Intrepid::FieldContainer<Real>> & u_coeff,
756 const ROL::Ptr<const Intrepid::FieldContainer<Real>> & z_coeff = ROL::nullPtr,
757 const ROL::Ptr<const std::vector<Real>> & z_param = ROL::nullPtr) override {
758 // Retrieve dimensions.
759 const int c = feVel_->gradN()->dimension(0);
760 const int fv = feVel_->gradN()->dimension(1);
761 const int fp = fePrs_->gradN()->dimension(1);
762 const int fc = feCtrl_->gradN()->dimension(1);
763 const int p = feVel_->gradN()->dimension(2);
764 const int d = feVel_->gradN()->dimension(3);
765 // Initialize hessians.
766 std::vector<std::vector<ROL::Ptr<Intrepid::FieldContainer<Real>>>> H(numFields_);
767 for (int i = 0; i < d; ++i) {
768 H[i].resize(1,ROL::nullPtr);
769 H[i][0] = ROL::makePtr<Intrepid::FieldContainer<Real>>(c, fv, fc);
770 }
771 H[d].resize(1,ROL::nullPtr);
772 H[d][0] = ROL::makePtr<Intrepid::FieldContainer<Real>>(c, fp, fc);
773 // Split coefficients into components.
774 std::vector<ROL::Ptr<Intrepid::FieldContainer<Real>>> L, Z;
775 FieldUtils::splitFieldCoeff<Real>(L, l_coeff, fieldInfo_);
776 FieldUtils::splitFieldCoeff<Real>(Z, z_coeff, fieldInfoCtrl_);
777 // Apply Dirichlet conditions
778 int numSideSets = bdryCellLocIds_.size();
779 if (numSideSets > 0) {
780 for (int i = 0; i < numSideSets; ++i) {
781 if (i==1 /* in flow */ || i==2 /* no slip */ ) { // || i==0 /* out flow */) {
782 int numLocalSideIds = bdryCellLocIds_[i].size();
783 for (int j = 0; j < numLocalSideIds; ++j) {
784 int numCellsSide = bdryCellLocIds_[i][j].size();
785 int numBdryDofs = fvidx_[j].size();
786 for (int k = 0; k < numCellsSide; ++k) {
787 int cidx = bdryCellLocIds_[i][j][k];
788 for (int l = 0; l < numBdryDofs; ++l) {
789 //std::cout << "\n j=" << j << " l=" << l << " " << fidx[j][l];
790 for (int m=0; m < d; ++m) {
791 (*L[m])(cidx,fvidx_[j][l]) = static_cast<Real>(0);
792 }
793 }
794 }
795 }
796 }
797 }
798 }
799 // Evaluate/interpolate finite element fields on cells.
800 ROL::Ptr<Intrepid::FieldContainer<Real>> Z0, alpha, Lval, alphaL;
801 Z0 = ROL::makePtr<Intrepid::FieldContainer<Real>>(c, p);
802 alpha = ROL::makePtr<Intrepid::FieldContainer<Real>>(c, p);
803 Lval = ROL::makePtr<Intrepid::FieldContainer<Real>>(c, p);
804 alphaL = ROL::makePtr<Intrepid::FieldContainer<Real>>(c, fc, p);
805 feCtrl_->evaluateValue(Z0, Z[0]);
806 imp_->compute(alpha, Z0, feVel_->cubPts(), 1);
807 /*** Evaluate weak form of the Hessian. ***/
808 // Velocity equation.
809 for (int i = 0; i < d; ++i) {
810 // Multiply velocity with alpha
811 Lval->initialize(); alphaL->initialize();
812 feVel_->evaluateValue(Lval, L[i]);
813 for (int j = 0; j < c; ++j) {
814 for (int k = 0; k < fc; ++k) {
815 for (int l = 0; l < p; ++l) {
816 (*alphaL)(j,k,l) = (*alpha)(j,l) * (*feCtrl_->N())(j,k,l) * (*Lval)(j,l);
817 }
818 }
819 }
820 Intrepid::FunctionSpaceTools::integrate<Real>(*H[i][0],
821 *(feVel_->NdetJ()), // Phi
822 *alphaL, // alpha' L Phi
823 Intrepid::COMP_CPP,
824 false);
825 }
826 // Combine the Hessians.
827 FieldUtils::combineFieldCoeff<Real>(hess, H, fieldInfo_, fieldInfoCtrl_);
828 }
829
830 void Hessian_22(ROL::Ptr<Intrepid::FieldContainer<Real>> & hess,
831 const ROL::Ptr<const Intrepid::FieldContainer<Real>> & l_coeff,
832 const ROL::Ptr<const Intrepid::FieldContainer<Real>> & u_coeff,
833 const ROL::Ptr<const Intrepid::FieldContainer<Real>> & z_coeff = ROL::nullPtr,
834 const ROL::Ptr<const std::vector<Real>> & z_param = ROL::nullPtr) override {
835 // Retrieve dimensions.
836 const int c = feVel_->gradN()->dimension(0);
837 const int fc = feCtrl_->gradN()->dimension(1);
838 const int p = feVel_->gradN()->dimension(2);
839 const int d = feVel_->gradN()->dimension(3);
840 // Initialize hessians.
841 std::vector<std::vector<ROL::Ptr<Intrepid::FieldContainer<Real>>>> H(1);
842 H[0].resize(1,ROL::nullPtr);
843 H[0][0] = ROL::makePtr<Intrepid::FieldContainer<Real>>(c, fc, fc);
844 // Split coefficients into components.
845 std::vector<ROL::Ptr<Intrepid::FieldContainer<Real>>> L, U, Z;
846 FieldUtils::splitFieldCoeff<Real>(L, l_coeff, fieldInfo_);
847 FieldUtils::splitFieldCoeff<Real>(U, u_coeff, fieldInfo_);
848 FieldUtils::splitFieldCoeff<Real>(Z, z_coeff, fieldInfoCtrl_);
849 // Apply Dirichlet conditions
850 int numSideSets = bdryCellLocIds_.size();
851 if (numSideSets > 0) {
852 for (int i = 0; i < numSideSets; ++i) {
853 if (i==1 /* in flow */ || i==2 /* no slip */ ) { // || i==0 /* out flow */) {
854 int numLocalSideIds = bdryCellLocIds_[i].size();
855 for (int j = 0; j < numLocalSideIds; ++j) {
856 int numCellsSide = bdryCellLocIds_[i][j].size();
857 int numBdryDofs = fvidx_[j].size();
858 for (int k = 0; k < numCellsSide; ++k) {
859 int cidx = bdryCellLocIds_[i][j][k];
860 for (int l = 0; l < numBdryDofs; ++l) {
861 //std::cout << "\n j=" << j << " l=" << l << " " << fidx[j][l];
862 for (int m=0; m < d; ++m) {
863 (*L[m])(cidx,fvidx_[j][l]) = static_cast<Real>(0);
864 }
865 }
866 }
867 }
868 }
869 }
870 }
871 // Evaluate/interpolate finite element fields on cells.
872 std::vector<ROL::Ptr<Intrepid::FieldContainer<Real>>> Lval(d), Uval(d);
873 ROL::Ptr<Intrepid::FieldContainer<Real>> Z0, alpha, alphaUL;
874 Z0 = ROL::makePtr<Intrepid::FieldContainer<Real>>(c, p);
875 alpha = ROL::makePtr<Intrepid::FieldContainer<Real>>(c, p);
876 alphaUL = ROL::makePtr<Intrepid::FieldContainer<Real>>(c, fc, p);
877 for (int i = 0; i < d; ++i) {
878 Lval[i] = ROL::makePtr<Intrepid::FieldContainer<Real>>(c, p);
879 Uval[i] = ROL::makePtr<Intrepid::FieldContainer<Real>>(c, p);
880 feVel_->evaluateValue(Lval[i], L[i]);
881 feVel_->evaluateValue(Uval[i], U[i]);
882 }
883 feCtrl_->evaluateValue(Z0, Z[0]);
884 imp_->compute(alpha, Z0, feVel_->cubPts(), 2);
885 // Multiply velocity with alpha
886 Real dot(0);
887 for (int i = 0; i < c; ++i) {
888 for (int j = 0; j < fc; ++j) {
889 for (int k = 0; k < p; ++k) {
890 dot = static_cast<Real>(0);
891 for (int l = 0; l < d; ++l) {
892 dot += (*Uval[l])(i,k) * (*Lval[l])(i,k);
893 }
894 (*alphaUL)(i,j,k) = (*alpha)(i,k) * (*feCtrl_->N())(i,j,k) * dot;
895 }
896 }
897 }
898 /*** Evaluate weak form of the Hessian. ***/
899 // Velocity equation.
900 Intrepid::FunctionSpaceTools::integrate<Real>(*H[0][0],
901 *alphaUL, // alpha'' U L Phi
902 *(feCtrl_->NdetJ()), // Phi
903 Intrepid::COMP_CPP,
904 false);
905 // Combine hessians.
906 FieldUtils::combineFieldCoeff<Real>(hess, H, fieldInfoCtrl_, fieldInfoCtrl_);
907 }
908
909 void RieszMap_1(ROL::Ptr<Intrepid::FieldContainer<Real>> & riesz) override {
910 // Retrieve dimensions.
911 const int c = feVel_->gradN()->dimension(0);
912 const int fv = feVel_->gradN()->dimension(1);
913 const int fp = fePrs_->gradN()->dimension(1);
914 const int d = feVel_->gradN()->dimension(3);
915 // Initialize Riesz maps.
916 std::vector<std::vector<ROL::Ptr<Intrepid::FieldContainer<Real>>>> J(numFields_);
917 J[d].resize(numFields_);
918 for (int i = 0; i < d; ++i) {
919 J[i].resize(numFields_);
920 for (int j = 0; j < d; ++j) {
921 J[i][j] = ROL::makePtr<Intrepid::FieldContainer<Real>>(c, fv, fv);
922 }
923 J[i][d] = ROL::makePtr<Intrepid::FieldContainer<Real>>(c, fv, fp);
924 J[d][i] = ROL::makePtr<Intrepid::FieldContainer<Real>>(c, fp, fv);
925 }
926 J[d][d] = ROL::makePtr<Intrepid::FieldContainer<Real>>(c, fp, fp);
927 // Build Riesz maps.
928 for (int i = 0; i < d; ++i) {
929 *(J[i][i]) = *(feVel_->stiffMat());
930 Intrepid::RealSpaceTools<Real>::add(*(J[i][i]),*(feVel_->massMat()));
931 }
932 *(J[d][d]) = *(fePrs_->massMat());
933 // Combine Riesz maps.
934 FieldUtils::combineFieldCoeff<Real>(riesz, J, fieldInfo_, fieldInfo_);
935 }
936
937 void RieszMap_2(ROL::Ptr<Intrepid::FieldContainer<Real>> & riesz) override {
938 // Retrieve dimensions.
939 const int c = feVel_->gradN()->dimension(0);
940 const int fc = feCtrl_->gradN()->dimension(1);
941 // Initialize residuals.
942 std::vector<std::vector<ROL::Ptr<Intrepid::FieldContainer<Real>>>> J(1);
943 J[0].resize(1,ROL::nullPtr);
944 J[0][0] = ROL::makePtr<Intrepid::FieldContainer<Real>>(c, fc, fc);
945 *J[0][0] = *feCtrl_->massMat();
946 // Combine Riesz maps.
947 FieldUtils::combineFieldCoeff<Real>(riesz, J, fieldInfoCtrl_, fieldInfoCtrl_);
948 }
949
950 std::vector<ROL::Ptr<Intrepid::Basis<Real, Intrepid::FieldContainer<Real>>>> getFields() override {
951 return basisPtrs_;
952 }
953
954 std::vector<ROL::Ptr<Intrepid::Basis<Real, Intrepid::FieldContainer<Real>>>> getFields2() override {
955 return basisPtrsCtrl_;
956 }
957
958 void setCellNodes(const ROL::Ptr<Intrepid::FieldContainer<Real>> &volCellNodes,
959 const std::vector<std::vector<ROL::Ptr<Intrepid::FieldContainer<Real>>>> &bdryCellNodes,
960 const std::vector<std::vector<std::vector<int>>> &bdryCellLocIds) override {
961 volCellNodes_ = volCellNodes;
962 bdryCellNodes_ = bdryCellNodes;
963 bdryCellLocIds_ = bdryCellLocIds;
964 // Finite element definition.
965 feVel_ = ROL::makePtr<FE<Real>>(volCellNodes_,basisPtrVel_,cellCub_);
966 fePrs_ = ROL::makePtr<FE<Real>>(volCellNodes_,basisPtrPrs_,cellCub_);
967 feCtrl_ = ROL::makePtr<FE<Real>>(volCellNodes_,basisPtrCtrl_,cellCub_,false);
968 fvidx_ = feVel_->getBoundaryDofs();
969 fpidx_ = fePrs_->getBoundaryDofs();
970 // Construct control boundary FE
971 int numSideSets = bdryCellLocIds_.size();
972 if (numSideSets > 0) {
973 feVelBdry_.resize(numSideSets);
974 for (int i = 0; i < numSideSets; ++i) {
975 int numLocSides = bdryCellNodes[i].size();
976 feVelBdry_[i].resize(numLocSides);
977 for (int j = 0; j < numLocSides; ++j) {
978 if (bdryCellNodes[i][j] != ROL::nullPtr) {
979 feVelBdry_[i][j] = ROL::makePtr<FE<Real>>(bdryCellNodes[i][j],basisPtrVel_,bdryCub_,j);
980 }
981 }
982 }
983 }
984 }
985
986 void setFieldPattern(const std::vector<std::vector<int>> &fieldPattern,
987 const std::vector<std::vector<int>> &fieldPattern2) override {
988 fieldPattern_ = fieldPattern;
989 fieldInfo_ = ROL::makePtr<FieldUtils::FieldInfo>(numFields_,numDofs_,numFieldDofs_,fieldPattern_);
990 fieldPatternCtrl_ = fieldPattern2;
991 fieldInfoCtrl_ = ROL::makePtr<FieldUtils::FieldInfo>(numFieldsCtrl_,numDofsCtrl_,numFieldDofsCtrl_,fieldPatternCtrl_);
992 fieldHelper_ = ROL::makePtr<FieldHelper<Real>>(numFields_, numDofs_, numFieldDofs_, fieldPattern_);
993 }
994
995 const ROL::Ptr<FE<Real>> getVelocityFE(void) const {
996 return feVel_;
997 }
998
999 const ROL::Ptr<FE<Real>> getPressureFE(void) const {
1000 return fePrs_;
1001 }
1002
1003 const ROL::Ptr<FE<Real>> getControlFE(void) const {
1004 return feCtrl_;
1005 }
1006
1007 const std::vector<ROL::Ptr<FE<Real>>> getVelocityBdryFE(const int sideset = -1) const {
1008 int side = sideset;
1009 if ( sideset < 0 || sideset > 2 ) {
1010 //side = (useDirichletControl_) ? 6 : 10;
1011 side = 0;
1012 }
1013 return feVelBdry_[side];
1014 }
1015
1016 const std::vector<std::vector<int>> getBdryCellLocIds(const int sideset = -1) const {
1017 int side = sideset;
1018 if ( sideset < 0 || sideset > 2 ) {
1019 //side = (useDirichletControl_) ? 6 : 10;
1020 side = 0;
1021 }
1022 return bdryCellLocIds_[side];
1023 }
1024
1025 const ROL::Ptr<FieldHelper<Real>> getFieldHelper(void) const {
1026 return fieldHelper_;
1027 }
1028
1029 const ROL::Ptr<const FieldUtils::FieldInfo> getStateFieldInfo(void) const {
1030 return fieldInfo_;
1031 }
1032
1033 const ROL::Ptr<const FieldUtils::FieldInfo> getControlFieldInfo(void) const {
1034 return fieldInfoCtrl_;
1035 }
1036
1037 }; // PDE_NavierStokes
1038
1039 #endif