Debian Codegraph @

packages/rol/example/PDE-OPT/topo-opt/elasticity/src/materialtensor.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 obj.hpp
11 \brief Provides the interface for local (cell-based) objective function computations.
12 */
13
14 #ifndef PDEOPT_MATERIALTENSOR_HPP
15 #define PDEOPT_MATERIALTENSOR_HPP
16
17 #include "../../../TOOLS/fe.hpp"
18
19 template <class Real>
20 class MaterialTensor {
21 private:
22 ROL::Ptr<FE<Real> > fe_;
23
24 // Problem parameters.
25 Real youngsModulus_;
26 Real poissonRatio_;
27 bool isPlainStress_;
28 Real minDensity_;
29 Real maxDensity_;
30 Real powerSIMP_;
31 bool usePhaseField_;
32 bool useProjection_;
33 Real beta_, eta_;
34 std::vector<std::vector<Real>> materialMat_;
35
36 // Precomputed quantities.
37 std::vector<ROL::Ptr<Intrepid::FieldContainer<Real>>> BMat_;
38 std::vector<ROL::Ptr<Intrepid::FieldContainer<Real>>> BdetJMat_;
39 std::vector<ROL::Ptr<Intrepid::FieldContainer<Real>>> NMat_;
40 std::vector<ROL::Ptr<Intrepid::FieldContainer<Real>>> NdetJMat_;
41 std::vector<ROL::Ptr<Intrepid::FieldContainer<Real>>> CBdetJMat_;
42
43 void computeMaterialTensor(const int d) {
44 int matd = (d*(d+1))/2;
45 std::vector<Real> tmpvec(matd);
46 materialMat_.resize(matd, tmpvec);
47 if ((d==2) && (isPlainStress_)) {
48 Real one(1), half(0.5);
49 Real factor1 = youngsModulus_ /(one-poissonRatio_*poissonRatio_);
50 materialMat_[0][0] = factor1;
51 materialMat_[0][1] = factor1 * poissonRatio_;
52 materialMat_[1][0] = factor1 * poissonRatio_;
53 materialMat_[1][1] = factor1;
54 materialMat_[2][2] = factor1 * half * (one-poissonRatio_);
55 }
56 else if ((d==2) && (!isPlainStress_)) {
57 Real one(1), two(2), half(0.5);
58 Real factor2 = youngsModulus_ /(one+poissonRatio_)/(one-two*poissonRatio_);
59 materialMat_[0][0] = factor2 * (one-poissonRatio_);
60 materialMat_[0][1] = factor2 * poissonRatio_;
61 materialMat_[1][0] = factor2 * poissonRatio_;
62 materialMat_[1][1] = factor2 * (one-poissonRatio_);
63 materialMat_[2][2] = factor2 * half * (one-two*poissonRatio_);
64 }
65 else {
66 Real one(1), two(2), half(0.5);
67 Real lam = youngsModulus_*poissonRatio_/(one+poissonRatio_)/(one-two*poissonRatio_);
68 Real mu = half*youngsModulus_/(one+poissonRatio_);
69 materialMat_[0][0] = lam + two*mu;
70 materialMat_[0][1] = lam;
71 materialMat_[0][2] = lam;
72 materialMat_[1][0] = lam;
73 materialMat_[1][1] = lam + two*mu;
74 materialMat_[1][2] = lam;
75 materialMat_[2][0] = lam;
76 materialMat_[2][1] = lam;
77 materialMat_[2][2] = lam + two*mu;
78 materialMat_[3][3] = mu;
79 materialMat_[4][4] = mu;
80 materialMat_[5][5] = mu;
81 }
82 }
83
84 void computeNBmats(void) {
85 int c = fe_->gradN()->dimension(0);
86 int f = fe_->gradN()->dimension(1);
87 int p = fe_->gradN()->dimension(2);
88 int d = fe_->gradN()->dimension(3);
89 int matd = materialMat_.size();
90
91 for (int i=0; i<d; ++i) {
92 BMat_.push_back(ROL::makePtr<Intrepid::FieldContainer<Real>>(c,f,p,matd));
93 BdetJMat_.push_back(ROL::makePtr<Intrepid::FieldContainer<Real>>(c,f,p,matd));
94 CBdetJMat_.push_back(ROL::makePtr<Intrepid::FieldContainer<Real>>(c,f,p,matd));
95 NMat_.push_back(ROL::makePtr<Intrepid::FieldContainer<Real>>(c,f,p,d));
96 NdetJMat_.push_back(ROL::makePtr<Intrepid::FieldContainer<Real>>(c,f,p,d));
97 }
98
99 if (d==2) {
100 for (int i=0; i<c; ++i) {
101 for (int j=0; j<f; ++j) {
102 for (int k=0; k<p; ++k) {
103 (*NMat_[0])(i, j, k, 0) = (*fe_->N())(i, j, k);
104 (*NMat_[1])(i, j, k, 1) = (*fe_->N())(i, j, k);
105 (*NdetJMat_[0])(i, j, k, 0) = (*fe_->NdetJ())(i, j, k);
106 (*NdetJMat_[1])(i, j, k, 1) = (*fe_->NdetJ())(i, j, k);
107
108 (*BMat_[0])(i, j, k, 0) = (*fe_->gradN())(i, j, k, 0);
109 (*BMat_[1])(i, j, k, 1) = (*fe_->gradN())(i, j, k, 1);
110 (*BMat_[0])(i, j, k, 2) = (*fe_->gradN())(i, j, k, 1);
111 (*BMat_[1])(i, j, k, 2) = (*fe_->gradN())(i, j, k, 0);
112
113 (*BdetJMat_[0])(i, j, k, 0) = (*fe_->gradNdetJ())(i, j, k, 0);
114 (*BdetJMat_[1])(i, j, k, 1) = (*fe_->gradNdetJ())(i, j, k, 1);
115 (*BdetJMat_[0])(i, j, k, 2) = (*fe_->gradNdetJ())(i, j, k, 1);
116 (*BdetJMat_[1])(i, j, k, 2) = (*fe_->gradNdetJ())(i, j, k, 0);
117 }
118 }
119 }
120 }
121
122 if(d==3) {
123 for (int i=0; i<c; ++i) {
124 for (int j=0; j<f; ++j) {
125 for (int k=0; k<p; ++k) {
126 (*NMat_[0])(i, j, k, 0) = (*fe_->N())(i, j, k);
127 (*NMat_[1])(i, j, k, 1) = (*fe_->N())(i, j, k);
128 (*NMat_[2])(i, j, k, 2) = (*fe_->N())(i, j, k);
129 (*NdetJMat_[0])(i, j, k, 0) = (*fe_->NdetJ())(i, j, k);
130 (*NdetJMat_[1])(i, j, k, 1) = (*fe_->NdetJ())(i, j, k);
131 (*NdetJMat_[2])(i, j, k, 2) = (*fe_->NdetJ())(i, j, k);
132
133 (*BMat_[0])(i, j, k, 0) = (*fe_->gradN())(i, j, k, 0);
134 (*BMat_[1])(i, j, k, 1) = (*fe_->gradN())(i, j, k, 1);
135 (*BMat_[2])(i, j, k, 2) = (*fe_->gradN())(i, j, k, 2);
136 (*BMat_[1])(i, j, k, 3) = (*fe_->gradN())(i, j, k, 2);
137 (*BMat_[2])(i, j, k, 3) = (*fe_->gradN())(i, j, k, 1);
138 (*BMat_[0])(i, j, k, 4) = (*fe_->gradN())(i, j, k, 2);
139 (*BMat_[2])(i, j, k, 4) = (*fe_->gradN())(i, j, k, 0);
140 (*BMat_[0])(i, j, k, 5) = (*fe_->gradN())(i, j, k, 1);
141 (*BMat_[1])(i, j, k, 5) = (*fe_->gradN())(i, j, k, 0);
142
143 (*BdetJMat_[0])(i, j, k, 0) = (*fe_->gradNdetJ())(i, j, k, 0);
144 (*BdetJMat_[1])(i, j, k, 1) = (*fe_->gradNdetJ())(i, j, k, 1);
145 (*BdetJMat_[2])(i, j, k, 2) = (*fe_->gradNdetJ())(i, j, k, 2);
146 (*BdetJMat_[1])(i, j, k, 3) = (*fe_->gradNdetJ())(i, j, k, 2);
147 (*BdetJMat_[2])(i, j, k, 3) = (*fe_->gradNdetJ())(i, j, k, 1);
148 (*BdetJMat_[0])(i, j, k, 4) = (*fe_->gradNdetJ())(i, j, k, 2);
149 (*BdetJMat_[2])(i, j, k, 4) = (*fe_->gradNdetJ())(i, j, k, 0);
150 (*BdetJMat_[0])(i, j, k, 5) = (*fe_->gradNdetJ())(i, j, k, 1);
151 (*BdetJMat_[1])(i, j, k, 5) = (*fe_->gradNdetJ())(i, j, k, 0);
152 }
153 }
154 }
155 }
156
157 for (int i=0; i<c; ++i) {
158 for (int j=0; j<f; ++j) {
159 for (int k=0; k<p; ++k) {
160 for (int l=0; l<d; ++l) {
161 for (int m=0; m<matd; ++m) {
162 for (int n=0; n<matd; ++n) {
163 (*CBdetJMat_[l])(i,j,k,m) += materialMat_[m][n] * (*BdetJMat_[l])(i,j,k,n);
164 }
165 }
166 }
167 }
168 }
169 }
170
171 }
172
173 public:
174 MaterialTensor(Teuchos::ParameterList &parlist) {
175 // Problem parameters.
176 youngsModulus_ = parlist.get("Young's Modulus", 1.0);
177 poissonRatio_ = parlist.get("Poisson Ratio", 0.3);
178 isPlainStress_ = parlist.get("Use Plain Stress", true);
179 minDensity_ = parlist.get("Minimum Density", 1e-4);
180 maxDensity_ = parlist.get("Maximum Density", 1.0);
181 powerSIMP_ = parlist.get("SIMP Power", 3.0);
182 usePhaseField_ = parlist.get("Use Phase Field", false);
183 useProjection_ = parlist.get("Use Projection", false);
184 beta_ = parlist.get("Projection Parameter", 1.0);
185 eta_ = parlist.get("Projection Threshold", 0.5);
186 }
187
188 void setFE(ROL::Ptr<FE<Real> > &fe) {
189 fe_ = fe;
190 int d = fe_->gradN()->dimension(3);
191 computeMaterialTensor(d);
192 computeNBmats();
193 }
194
195 void applyTensor(ROL::Ptr<Intrepid::FieldContainer<Real> > & out, const ROL::Ptr<Intrepid::FieldContainer<Real> > & inData) const {
196 int c = fe_->gradN()->dimension(0);
197 int p = fe_->gradN()->dimension(2);
198 int matd = materialMat_.size();
199
200 for (int i=0; i<c; ++i) {
201 for (int j=0; j<p; ++j) {
202 for (int k=0; k<matd; ++k) {
203 for (int l=0; l<matd; ++l) {
204 (*out)(i,j,k) += materialMat_[k][l] * (*inData)(i,j,l);
205 }
206 }
207 }
208 }
209 }
210
211 void computeUmat(ROL::Ptr<Intrepid::FieldContainer<Real> > & UMat, std::vector<ROL::Ptr<Intrepid::FieldContainer<Real> > > & gradU) const {
212 int c = fe_->gradN()->dimension(0);
213 int p = fe_->gradN()->dimension(2);
214 int d = fe_->gradN()->dimension(3);
215 int matd = materialMat_.size();
216
217 UMat = ROL::makePtr<Intrepid::FieldContainer<Real>>(c,p,matd);
218
219 if (d==2) {
220 for (int i=0; i<c; ++i) {
221 for (int j=0; j<p; ++j) {
222 (*UMat)(i, j, 0) = (*gradU[0])(i, j, 0);
223 (*UMat)(i, j, 1) = (*gradU[1])(i, j, 1);
224 (*UMat)(i, j, 2) = (*gradU[0])(i, j, 1) + (*gradU[1])(i, j, 0);
225 }
226 }
227 }
228
229 if(d==3) {
230 for (int i=0; i<c; ++i) {
231 for (int j=0; j<p; ++j) {
232 (*UMat)(i, j, 0) = (*gradU[0])(i, j, 0);
233 (*UMat)(i, j, 1) = (*gradU[1])(i, j, 1);
234 (*UMat)(i, j, 2) = (*gradU[2])(i, j, 2);
235 (*UMat)(i, j, 3) = (*gradU[1])(i, j, 2) + (*gradU[2])(i, j, 1);
236 (*UMat)(i, j, 4) = (*gradU[0])(i, j, 2) + (*gradU[2])(i, j, 0);
237 (*UMat)(i, j, 5) = (*gradU[0])(i, j, 1) + (*gradU[1])(i, j, 0);
238 }
239 }
240 }
241
242 }
243
244 void computeDensity(ROL::Ptr<Intrepid::FieldContainer<Real> > & rho,
245 const ROL::Ptr<Intrepid::FieldContainer<Real> > & Z,
246 const int deriv = 0) const {
247 // Retrieve dimensions.
248 int c = rho->dimension(0);
249 int p = rho->dimension(1);
250
251 Real z(0);
252 const Real half(0.5), one(1), two(2), diff = maxDensity_-minDensity_;
253 for (int i=0; i<c; ++i) {
254 for (int j=0; j<p; ++j) {
255 z = (*Z)(i,j);
256 if (!usePhaseField_) {
257 if (!useProjection_) {
258 if (deriv==0) {
259 (*rho)(i,j) = minDensity_ + diff*std::pow(z, powerSIMP_);
260 }
261 else if (deriv==1) {
262 (*rho)(i,j) = powerSIMP_*diff*std::pow(z, powerSIMP_-one);
263 }
264 else if (deriv==2) {
265 (*rho)(i,j) = powerSIMP_*(powerSIMP_-one)*diff*std::pow(z, powerSIMP_-two);
266 }
267 }
268 else {
269 if (deriv==0) {
270 Real pz = project(z,0);
271 (*rho)(i,j) = minDensity_ + diff*std::pow(pz, powerSIMP_);
272 }
273 else if (deriv==1) {
274 Real pz = project(z,0), pz1 = project(z,1);
275 (*rho)(i,j) = powerSIMP_*diff*std::pow(pz, powerSIMP_-one)*pz1;
276 }
277 else if (deriv==2) {
278 Real pz = project(z,0), pz1 = project(z,1), pz2 = project(z,2);
279 (*rho)(i,j) = powerSIMP_*(powerSIMP_-one)*diff*std::pow(pz, powerSIMP_-two)*pz1*pz1
280 +powerSIMP_*diff*std::pow(pz, powerSIMP_-one)*pz2;
281 }
282 }
283 }
284 else {
285 z += one;
286 z *= half;
287 if (deriv==0) {
288 (*rho)(i,j) = minDensity_ + diff*std::pow(z, 2);
289 }
290 else if (deriv==1) {
291 (*rho)(i,j) = diff*z;
292 }
293 else if (deriv==2) {
294 (*rho)(i,j) = half*diff;
295 }
296 }
297 }
298 }
299 }
300
301 const ROL::Ptr<Intrepid::FieldContainer<Real> > B(const int i) const {
302 return BMat_[i];
303 }
304
305 const ROL::Ptr<Intrepid::FieldContainer<Real> > BdetJ(const int i) const {
306 return BdetJMat_[i];
307 }
308
309 const ROL::Ptr<Intrepid::FieldContainer<Real> > N(const int i) const {
310 return NMat_[i];
311 }
312
313 const ROL::Ptr<Intrepid::FieldContainer<Real> > NdetJ(const int i) const{
314 return NdetJMat_[i];
315 }
316
317 const ROL::Ptr<Intrepid::FieldContainer<Real> > CBdetJ(const int i) const {
318 return CBdetJMat_[i];
319 }
320
321 int getMatrixDim(void) const {
322 return materialMat_.size();
323 }
324
325 private:
326 Real project(Real &rho, int deriv) const {
327 if (deriv==1) {
328 const Real one(1), tbe(std::tanh(beta_*eta_)), tbe1(std::tanh(beta_*(one-eta_)));
329 const Real tber(std::tanh(beta_*(rho-eta_)));
330 return (one-tber*tber)/(tbe+tbe1)*beta_;
331 }
332 else if (deriv==2) {
333 const Real one(1), tbe(std::tanh(beta_*eta_)), tbe1(std::tanh(beta_*(one-eta_)));
334 const Real tber(std::tanh(beta_*(rho-eta_))), two(2);
335 return -two*tber*(one-tber*tber)/(tbe+tbe1)*beta_*beta_;
336 }
337 const Real one(1), tbe(std::tanh(beta_*eta_)), tbe1(std::tanh(beta_*(one-eta_)));
338 return (tbe+std::tanh(beta_*(rho-eta_)))/(tbe+tbe1);
339 //if (deriv==1) {
340 // const Real expB(std::exp(-beta_));
341 // return beta_*std::exp(-beta_*rho) + expB;
342 //}
343 //else if (deriv==2) {
344 // return -beta_*beta_*std::exp(-beta_*rho);
345 //}
346 //const Real one(1), expB(std::exp(-beta_));
347 //return one - std::exp(-beta_*rho) + rho*expB;
348 }
349 };
350
351 #endif