Debian Codegraph @

packages/rol/example/PDE-OPT/topo-opt/multimat/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_MULTIMAT_HPP
15 #define PDEOPT_MATERIALTENSOR_MULTIMAT_HPP
16
17 #include "../../../TOOLS/fe.hpp"
18
19 template <class Real>
20 class MultiMat_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 std::vector<std::vector<Real>> materialMat_;
32
33 // Precomputed quantities.
34 std::vector<ROL::Ptr<Intrepid::FieldContainer<Real>>> BMat_;
35 std::vector<ROL::Ptr<Intrepid::FieldContainer<Real>>> BdetJMat_;
36 std::vector<ROL::Ptr<Intrepid::FieldContainer<Real>>> NMat_;
37 std::vector<ROL::Ptr<Intrepid::FieldContainer<Real>>> NdetJMat_;
38 std::vector<ROL::Ptr<Intrepid::FieldContainer<Real>>> CBdetJMat_;
39
40 void computeMaterialTensor(const int d) {
41 int matd = (d*(d+1))/2;
42 std::vector<Real> tmpvec(matd);
43 materialMat_.resize(matd, tmpvec);
44 if ((d==2) && (isPlainStress_)) {
45 Real one(1), half(0.5);
46 Real factor1 = youngsModulus_ /(one-poissonRatio_*poissonRatio_);
47 materialMat_[0][0] = factor1;
48 materialMat_[0][1] = factor1 * poissonRatio_;
49 materialMat_[1][0] = factor1 * poissonRatio_;
50 materialMat_[1][1] = factor1;
51 materialMat_[2][2] = factor1 * half * (one-poissonRatio_);
52 }
53 else if ((d==2) && (!isPlainStress_)) {
54 Real one(1), two(2), half(0.5);
55 Real factor2 = youngsModulus_ /(one+poissonRatio_)/(one-two*poissonRatio_);
56 materialMat_[0][0] = factor2 * (one-poissonRatio_);
57 materialMat_[0][1] = factor2 * poissonRatio_;
58 materialMat_[1][0] = factor2 * poissonRatio_;
59 materialMat_[1][1] = factor2 * (one-poissonRatio_);
60 materialMat_[2][2] = factor2 * half * (one-two*poissonRatio_);
61 }
62 else {
63 Real one(1), two(2), half(0.5);
64 Real lam = youngsModulus_*poissonRatio_/(one+poissonRatio_)/(one-two*poissonRatio_);
65 Real mu = half*youngsModulus_/(one+poissonRatio_);
66 materialMat_[0][0] = lam + two*mu;
67 materialMat_[0][1] = lam;
68 materialMat_[0][2] = lam;
69 materialMat_[1][0] = lam;
70 materialMat_[1][1] = lam + two*mu;
71 materialMat_[1][2] = lam;
72 materialMat_[2][0] = lam;
73 materialMat_[2][1] = lam;
74 materialMat_[2][2] = lam + two*mu;
75 materialMat_[3][3] = mu;
76 materialMat_[4][4] = mu;
77 materialMat_[5][5] = mu;
78 }
79 }
80
81 void computeNBmats(void) {
82 int c = fe_->gradN()->dimension(0);
83 int f = fe_->gradN()->dimension(1);
84 int p = fe_->gradN()->dimension(2);
85 int d = fe_->gradN()->dimension(3);
86 int matd = materialMat_.size();
87
88 for (int i=0; i<d; ++i) {
89 BMat_.push_back(ROL::makePtr<Intrepid::FieldContainer<Real>>(c,f,p,matd));
90 BdetJMat_.push_back(ROL::makePtr<Intrepid::FieldContainer<Real>>(c,f,p,matd));
91 CBdetJMat_.push_back(ROL::makePtr<Intrepid::FieldContainer<Real>>(c,f,p,matd));
92 NMat_.push_back(ROL::makePtr<Intrepid::FieldContainer<Real>>(c,f,p,d));
93 NdetJMat_.push_back(ROL::makePtr<Intrepid::FieldContainer<Real>>(c,f,p,d));
94 }
95
96 if (d==2) {
97 for (int i=0; i<c; ++i) {
98 for (int j=0; j<f; ++j) {
99 for (int k=0; k<p; ++k) {
100 (*NMat_[0])(i, j, k, 0) = (*fe_->N())(i, j, k);
101 (*NMat_[1])(i, j, k, 1) = (*fe_->N())(i, j, k);
102 (*NdetJMat_[0])(i, j, k, 0) = (*fe_->NdetJ())(i, j, k);
103 (*NdetJMat_[1])(i, j, k, 1) = (*fe_->NdetJ())(i, j, k);
104
105 (*BMat_[0])(i, j, k, 0) = (*fe_->gradN())(i, j, k, 0);
106 (*BMat_[1])(i, j, k, 1) = (*fe_->gradN())(i, j, k, 1);
107 (*BMat_[0])(i, j, k, 2) = (*fe_->gradN())(i, j, k, 1);
108 (*BMat_[1])(i, j, k, 2) = (*fe_->gradN())(i, j, k, 0);
109
110 (*BdetJMat_[0])(i, j, k, 0) = (*fe_->gradNdetJ())(i, j, k, 0);
111 (*BdetJMat_[1])(i, j, k, 1) = (*fe_->gradNdetJ())(i, j, k, 1);
112 (*BdetJMat_[0])(i, j, k, 2) = (*fe_->gradNdetJ())(i, j, k, 1);
113 (*BdetJMat_[1])(i, j, k, 2) = (*fe_->gradNdetJ())(i, j, k, 0);
114 }
115 }
116 }
117 }
118
119 if(d==3) {
120 for (int i=0; i<c; ++i) {
121 for (int j=0; j<f; ++j) {
122 for (int k=0; k<p; ++k) {
123 (*NMat_[0])(i, j, k, 0) = (*fe_->N())(i, j, k);
124 (*NMat_[1])(i, j, k, 1) = (*fe_->N())(i, j, k);
125 (*NMat_[2])(i, j, k, 2) = (*fe_->N())(i, j, k);
126 (*NdetJMat_[0])(i, j, k, 0) = (*fe_->NdetJ())(i, j, k);
127 (*NdetJMat_[1])(i, j, k, 1) = (*fe_->NdetJ())(i, j, k);
128 (*NdetJMat_[2])(i, j, k, 2) = (*fe_->NdetJ())(i, j, k);
129
130 (*BMat_[0])(i, j, k, 0) = (*fe_->gradN())(i, j, k, 0);
131 (*BMat_[1])(i, j, k, 1) = (*fe_->gradN())(i, j, k, 1);
132 (*BMat_[2])(i, j, k, 2) = (*fe_->gradN())(i, j, k, 2);
133 (*BMat_[1])(i, j, k, 3) = (*fe_->gradN())(i, j, k, 2);
134 (*BMat_[2])(i, j, k, 3) = (*fe_->gradN())(i, j, k, 1);
135 (*BMat_[0])(i, j, k, 4) = (*fe_->gradN())(i, j, k, 2);
136 (*BMat_[2])(i, j, k, 4) = (*fe_->gradN())(i, j, k, 0);
137 (*BMat_[0])(i, j, k, 5) = (*fe_->gradN())(i, j, k, 1);
138 (*BMat_[1])(i, j, k, 5) = (*fe_->gradN())(i, j, k, 0);
139
140 (*BdetJMat_[0])(i, j, k, 0) = (*fe_->gradNdetJ())(i, j, k, 0);
141 (*BdetJMat_[1])(i, j, k, 1) = (*fe_->gradNdetJ())(i, j, k, 1);
142 (*BdetJMat_[2])(i, j, k, 2) = (*fe_->gradNdetJ())(i, j, k, 2);
143 (*BdetJMat_[1])(i, j, k, 3) = (*fe_->gradNdetJ())(i, j, k, 2);
144 (*BdetJMat_[2])(i, j, k, 3) = (*fe_->gradNdetJ())(i, j, k, 1);
145 (*BdetJMat_[0])(i, j, k, 4) = (*fe_->gradNdetJ())(i, j, k, 2);
146 (*BdetJMat_[2])(i, j, k, 4) = (*fe_->gradNdetJ())(i, j, k, 0);
147 (*BdetJMat_[0])(i, j, k, 5) = (*fe_->gradNdetJ())(i, j, k, 1);
148 (*BdetJMat_[1])(i, j, k, 5) = (*fe_->gradNdetJ())(i, j, k, 0);
149 }
150 }
151 }
152 }
153
154 for (int i=0; i<c; ++i) {
155 for (int j=0; j<f; ++j) {
156 for (int k=0; k<p; ++k) {
157 for (int l=0; l<d; ++l) {
158 for (int m=0; m<matd; ++m) {
159 for (int n=0; n<matd; ++n) {
160 (*CBdetJMat_[l])(i,j,k,m) += materialMat_[m][n] * (*BdetJMat_[l])(i,j,k,n);
161 }
162 }
163 }
164 }
165 }
166 }
167 }
168
169 public:
170 MultiMat_MaterialTensor(Teuchos::ParameterList &parlist) {
171 // Problem parameters.
172 youngsModulus_ = parlist.get("Young's Modulus", 1.0);
173 poissonRatio_ = parlist.get("Poisson Ratio", 0.3);
174 isPlainStress_ = parlist.get("Use Plain Stress", true);
175 minDensity_ = parlist.get("Minimum Density", 1e-4);
176 maxDensity_ = parlist.get("Maximum Density", 1.0);
177 powerSIMP_ = parlist.get("SIMP Power", 3.0);
178 }
179
180 void setFE(ROL::Ptr<FE<Real>> &fe) {
181 fe_ = fe;
182 int d = fe_->gradN()->dimension(3);
183 computeMaterialTensor(d);
184 computeNBmats();
185 }
186
187 void applyTensor(ROL::Ptr<Intrepid::FieldContainer<Real>> & out, const ROL::Ptr<Intrepid::FieldContainer<Real>> & inData) const {
188 int c = fe_->gradN()->dimension(0);
189 int p = fe_->gradN()->dimension(2);
190 int matd = materialMat_.size();
191
192 for (int i=0; i<c; ++i) {
193 for (int j=0; j<p; ++j) {
194 for (int k=0; k<matd; ++k) {
195 for (int l=0; l<matd; ++l) {
196 (*out)(i,j,k) += materialMat_[k][l] * (*inData)(i,j,l);
197 }
198 }
199 }
200 }
201 }
202
203 void computeUmat(ROL::Ptr<Intrepid::FieldContainer<Real>> & UMat, std::vector<ROL::Ptr<Intrepid::FieldContainer<Real>>> & gradU) const {
204 int c = fe_->gradN()->dimension(0);
205 int p = fe_->gradN()->dimension(2);
206 int d = fe_->gradN()->dimension(3);
207 int matd = materialMat_.size();
208
209 UMat = ROL::makePtr<Intrepid::FieldContainer<Real>>(c,p,matd);
210
211 if (d==2) {
212 for (int i=0; i<c; ++i) {
213 for (int j=0; j<p; ++j) {
214 (*UMat)(i, j, 0) = (*gradU[0])(i, j, 0);
215 (*UMat)(i, j, 1) = (*gradU[1])(i, j, 1);
216 (*UMat)(i, j, 2) = (*gradU[0])(i, j, 1) + (*gradU[1])(i, j, 0);
217 }
218 }
219 }
220
221 if(d==3) {
222 for (int i=0; i<c; ++i) {
223 for (int j=0; j<p; ++j) {
224 (*UMat)(i, j, 0) = (*gradU[0])(i, j, 0);
225 (*UMat)(i, j, 1) = (*gradU[1])(i, j, 1);
226 (*UMat)(i, j, 2) = (*gradU[2])(i, j, 2);
227 (*UMat)(i, j, 3) = (*gradU[1])(i, j, 2) + (*gradU[2])(i, j, 1);
228 (*UMat)(i, j, 4) = (*gradU[0])(i, j, 2) + (*gradU[2])(i, j, 0);
229 (*UMat)(i, j, 5) = (*gradU[0])(i, j, 1) + (*gradU[1])(i, j, 0);
230 }
231 }
232 }
233 }
234
235 void computeDensity(ROL::Ptr<Intrepid::FieldContainer<Real>> & rho,
236 const ROL::Ptr<Intrepid::FieldContainer<Real>> & Z,
237 const int deriv = 0) const {
238 // Retrieve dimensions.
239 int c = rho->dimension(0);
240 int p = rho->dimension(1);
241
242 Real z(0);
243 const Real zero(0), one(1), two(2), diff = maxDensity_-minDensity_;
244 for (int i=0; i<c; ++i) {
245 for (int j=0; j<p; ++j) {
246 z = (*Z)(i,j);
247 if (deriv==0) {
248 (*rho)(i,j) = minDensity_ + diff*(powerSIMP_==one ? z : std::pow(z, powerSIMP_));
249 }
250 else if (deriv==1) {
251 (*rho)(i,j) = diff*(powerSIMP_==one ? one : powerSIMP_*std::pow(z, powerSIMP_-one));
252 }
253 else if (deriv==2) {
254 (*rho)(i,j) = diff*(powerSIMP_==one ? zero : powerSIMP_*(powerSIMP_-one)*std::pow(z, powerSIMP_-two));
255 }
256 }
257 }
258 }
259
260 const ROL::Ptr<Intrepid::FieldContainer<Real>> B(const int i) const {
261 return BMat_[i];
262 }
263
264 const ROL::Ptr<Intrepid::FieldContainer<Real>> BdetJ(const int i) const {
265 return BdetJMat_[i];
266 }
267
268 const ROL::Ptr<Intrepid::FieldContainer<Real>> N(const int i) const {
269 return NMat_[i];
270 }
271
272 const ROL::Ptr<Intrepid::FieldContainer<Real>> NdetJ(const int i) const{
273 return NdetJMat_[i];
274 }
275
276 const ROL::Ptr<Intrepid::FieldContainer<Real>> CBdetJ(const int i) const {
277 return CBdetJMat_[i];
278 }
279
280 int getMatrixDim(void) const {
281 return materialMat_.size();
282 }
283 };
284
285 #endif