Debian Codegraph @

packages/rol/example/PDE-OPT/topo-opt/multimat/src/dirichlet.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 dirichlet.hpp
11 \brief Implements Dirichlet boundary conditions for the structural
12 topology optimization problem.
13 */
14
15 #ifndef ROL_PDEOPT_MULTIMAT_DIRICHLET_HPP
16 #define ROL_PDEOPT_MULTIMAT_DIRICHLET_HPP
17
18 #include "ROL_Ptr.hpp"
19 #include "Teuchos_ParameterList.hpp"
20 #include "Intrepid_FieldContainer.hpp"
21 #include <vector>
22
23 template<class Real>
24 class MultiMat_Dirichlet {
25 private:
26 std::vector<int> sidesets_, types_;
27 std::vector<std::vector<ROL::Ptr<Intrepid::FieldContainer<Real> > > > bdryCellNodes_;
28 std::vector<std::vector<std::vector<int> > > bdryCellLocIds_;
29 std::vector<std::vector<int> > fidx_;
30
31 std::vector<int> getConstrainedDimensions(const int type, const int dim) const {
32 std::vector<int> conDim;
33 if ( type == 1 ) {
34 conDim.push_back(0);
35 }
36 else if ( type == 2 ) {
37 conDim.push_back(1);
38 }
39 else if ( type == 3 && dim > 2 ) {
40 conDim.push_back(2);
41 }
42 else if ( type == 4 && dim > 2 ) {
43 conDim.push_back(0);
44 conDim.push_back(1);
45 }
46 else if ( type == 5 && dim > 2 ) {
47 conDim.push_back(0);
48 conDim.push_back(2);
49 }
50 else if ( type == 6 && dim > 2 ) {
51 conDim.push_back(1);
52 conDim.push_back(2);
53 }
54 else {
55 for (int i = 0; i < dim; ++i) {
56 conDim.push_back(i);
57 }
58 }
59 return conDim;
60 }
61
62 public:
63 MultiMat_Dirichlet(Teuchos::ParameterList &parlist, std::string ex = "Default") {
64 if (ex == "2D Cantilever with 1 Load" ||
65 ex == "3D Cantilever" ||
66 ex == "2D Truss" ||
67 ex == "2D Beams") {
68 sidesets_.push_back(3);
69 types_.push_back(0);
70 }
71 else if (ex == "2D Cantilever with 3 Loads") {
72 sidesets_.push_back(8);
73 types_.push_back(0);
74 }
75 else if (ex == "2D Wheel") {
76 sidesets_.push_back(0);
77 sidesets_.push_back(4);
78 types_.push_back(0);
79 types_.push_back(2);
80 }
81 else if (ex == "2D Carrier Plate") {
82 sidesets_.push_back(0);
83 types_.push_back(0);
84 }
85 else {
86 // Grab sidesets
87 Teuchos::Array<int> sidesets
88 = Teuchos::getArrayFromStringParameter<int>(parlist.sublist("Dirichlet"), "Sidesets");
89 sidesets_ = sidesets.toVector();
90 // Grab type
91 Teuchos::Array<int> types
92 = Teuchos::getArrayFromStringParameter<int>(parlist.sublist("Dirichlet"), "Types");
93 types_ = types.toVector();
94 }
95 }
96
97 void setCellNodes(const std::vector<std::vector<ROL::Ptr<Intrepid::FieldContainer<Real> > > > &bdryCellNodes,
98 const std::vector<std::vector<std::vector<int> > > &bdryCellLocIds,
99 const std::vector<std::vector<int> > fidx) {
100 bdryCellNodes_ = bdryCellNodes;
101 bdryCellLocIds_ = bdryCellLocIds;
102 fidx_ = fidx;
103 }
104
105 void applyResidual(std::vector<ROL::Ptr<Intrepid::FieldContainer<Real> > > &R,
106 const std::vector<ROL::Ptr<Intrepid::FieldContainer<Real> > > &U) const {
107 const int d = R.size();
108 const int numSideSets = sidesets_.size();
109 if (numSideSets > 0) {
110 for (int i = 0; i < numSideSets; ++i) {
111 const std::vector<int> conDim = getConstrainedDimensions(types_[i],d);
112 const int numConDim = conDim.size();
113 const int numLocalSideIds = bdryCellLocIds_[sidesets_[i]].size();
114 for (int j = 0; j < numLocalSideIds; ++j) {
115 const int numCellsSide = bdryCellLocIds_[sidesets_[i]][j].size();
116 const int numBdryDofs = fidx_[j].size();
117 for (int k = 0; k < numCellsSide; ++k) {
118 const int cidx = bdryCellLocIds_[sidesets_[i]][j][k];
119 for (int l = 0; l < numBdryDofs; ++l) {
120 for (int m=0; m < numConDim; ++m) {
121 (*R[conDim[m]])(cidx,fidx_[j][l]) = (*U[conDim[m]])(cidx,fidx_[j][l]);
122 }
123 }
124 }
125 }
126 }
127 }
128 }
129
130 void applyJacobian1(std::vector<std::vector<ROL::Ptr<Intrepid::FieldContainer<Real> > > > &J) const {
131 const int d = J.size();
132 const int f = J[0][0]->dimension(1);
133 const int numSideSets = sidesets_.size();
134 if (numSideSets > 0) {
135 for (int i = 0; i < numSideSets; ++i) {
136 const std::vector<int> conDim = getConstrainedDimensions(types_[i],d);
137 const int numConDim = conDim.size();
138 const int numLocalSideIds = bdryCellLocIds_[sidesets_[i]].size();
139 for (int j = 0; j < numLocalSideIds; ++j) {
140 const int numCellsSide = bdryCellLocIds_[sidesets_[i]][j].size();
141 const int numBdryDofs = fidx_[j].size();
142 for (int k = 0; k < numCellsSide; ++k) {
143 const int cidx = bdryCellLocIds_[sidesets_[i]][j][k];
144 for (int l = 0; l < numBdryDofs; ++l) {
145 for (int m=0; m < f; ++m) {
146 for (int n=0; n < numConDim; ++n) {
147 for (int p=0; p < d; ++p) {
148 (*J[conDim[n]][p])(cidx,fidx_[j][l],m) = static_cast<Real>(0);
149 }
150 (*J[conDim[n]][conDim[n]])(cidx,fidx_[j][l],fidx_[j][l]) = static_cast<Real>(1);
151 }
152 }
153 }
154 }
155 }
156 }
157 }
158 }
159
160 void applyJacobian2(std::vector<std::vector<ROL::Ptr<Intrepid::FieldContainer<Real> > > > &J) const {
161 const int d = J.size();
162 const int T = J[0].size();
163 const int f = J[0][0]->dimension(2);
164 const int numSideSets = sidesets_.size();
165 if (numSideSets > 0) {
166 for (int i = 0; i < numSideSets; ++i) {
167 const std::vector<int> conDim = getConstrainedDimensions(types_[i],d);
168 const int numConDim = conDim.size();
169 const int numLocalSideIds = bdryCellLocIds_[sidesets_[i]].size();
170 for (int j = 0; j < numLocalSideIds; ++j) {
171 const int numCellsSide = bdryCellLocIds_[sidesets_[i]][j].size();
172 const int numBdryDofs = fidx_[j].size();
173 for (int k = 0; k < numCellsSide; ++k) {
174 const int cidx = bdryCellLocIds_[sidesets_[i]][j][k];
175 for (int l = 0; l < numBdryDofs; ++l) {
176 for (int m=0; m < f; ++m) {
177 for (int n=0; n < numConDim; ++n) {
178 for (int p=0; p < T; ++p) {
179 (*J[conDim[n]][p])(cidx,fidx_[j][l],m) = static_cast<Real>(0);
180 }
181 }
182 }
183 }
184 }
185 }
186 }
187 }
188 }
189
190 void applyMultiplier(std::vector<ROL::Ptr<Intrepid::FieldContainer<Real> > > &L) const {
191 const int d = L.size();
192 const int numSideSets = sidesets_.size();
193 if (numSideSets > 0) {
194 for (int i = 0; i < numSideSets; ++i) {
195 const std::vector<int> conDim = getConstrainedDimensions(types_[i],d);
196 const int numConDim = conDim.size();
197 const int numLocalSideIds = bdryCellLocIds_[sidesets_[i]].size();
198 for (int j = 0; j < numLocalSideIds; ++j) {
199 const int numCellsSide = bdryCellLocIds_[sidesets_[i]][j].size();
200 const int numBdryDofs = fidx_[j].size();
201 for (int k = 0; k < numCellsSide; ++k) {
202 const int cidx = bdryCellLocIds_[sidesets_[i]][j][k];
203 for (int l = 0; l < numBdryDofs; ++l) {
204 for (int m=0; m < numConDim; ++m) {
205 (*L[conDim[m]])(cidx,fidx_[j][l]) = static_cast<Real>(0);
206 }
207 }
208 }
209 }
210 }
211 }
212 }
213 };
214
215 #endif
216
217 // Real dirichletFunc(const std::vector<Real> & coords, const int sideset, const int locSideId, const int dir) const {
218 // Real val(0);
219 // return val;
220 // }
221 //
222 // void computeDirichlet(void) {
223 // // Compute Dirichlet values at DOFs.
224 // int d = basisPtr_->getBaseCellTopology().getDimension();
225 // int numSidesets = bdryCellLocIds_.size();
226 // bdryCellDofValues_.resize(numSidesets);
227 // for (int i=0; i<numSidesets; ++i) {
228 // int numLocSides = bdryCellLocIds_[i].size();
229 // bdryCellDofValues_[i].resize(numLocSides);
230 // for (int j=0; j<numLocSides; ++j) {
231 // int c = bdryCellLocIds_[i][j].size();
232 // int f = basisPtr_->getCardinality();
233 // bdryCellDofValues_[i][j] = ROL::makePtr<Intrepid::FieldContainer<Real>>(c, f, d);
234 // ROL::Ptr<Intrepid::FieldContainer<Real> > coords =
235 // ROL::makePtr<Intrepid::FieldContainer<Real>>(c, f, d);
236 // if (c > 0) {
237 // fe_->computeDofCoords(coords, bdryCellNodes_[i][j]);
238 // }
239 // for (int k=0; k<c; ++k) {
240 // for (int l=0; l<f; ++l) {
241 // std::vector<Real> dofpoint(d);
242 // //std::cout << "Sideset " << i << " LocalSide " << j << " Cell " << k << " Field " << l << " Coord ";
243 // for (int m=0; m<d; ++m) {
244 // dofpoint[m] = (*coords)(k, l, m);
245 // //std::cout << dofpoint[m] << " ";
246 // }
247 //
248 // for (int m=0; m<d; ++m) {
249 // (*bdryCellDofValues_[i][j])(k, l, m) = dirichletFunc(dofpoint, i, j, m);
250 // //std::cout << " " << m << "-Value " << dirichletFunc(dofpoint, i, j, m);
251 // }
252 // //std::cout << std::endl;
253 // }
254 // }
255 // }
256 // }
257 // }