Debian Codegraph @

packages/rol/example/PDE-OPT/topo-opt/multimat/src/load.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 load.hpp
11 \brief Implements points loads for the structural topology
12 optimization problem.
13 */
14
15 #ifndef ROL_PDEOPT_MULTIMAT_LOAD_HPP
16 #define ROL_PDEOPT_MULTIMAT_LOAD_HPP
17
18 #include "ROL_Ptr.hpp"
19 #include "Teuchos_ParameterList.hpp"
20 #include "Intrepid_FieldContainer.hpp"
21
22 #include "../../../TOOLS/fe.hpp"
23
24 #include <vector>
25
26 template<class Real>
27 class MultiMat_Load {
28 private:
29 std::vector<Real> loadMagnitude_;
30 std::vector<Real> loadPolar_, loadAzimuth_;
31 std::vector<Real> loadX_, loadY_, loadZ_;
32 std::vector<Real> loadWidthX_, loadWidthY_, loadWidthZ_;
33
34 protected:
35 Real DegreesToRadians(const Real deg) const {
36 return deg * static_cast<Real>(M_PI) / static_cast<Real>(180);
37 }
38
39 public:
40 virtual ~MultiMat_Load() {}
41
42 MultiMat_Load(void) {}
43
44 MultiMat_Load(Teuchos::ParameterList & parlist, std::string ex = "Default") {
45 if (ex == "2D Cantilever with 1 Load") {
46 loadMagnitude_.push_back(static_cast<Real>(1));
47 loadPolar_.push_back(static_cast<Real>(270));
48 loadAzimuth_.push_back(static_cast<Real>(0));
49 loadX_.push_back(static_cast<Real>(1));
50 loadY_.push_back(static_cast<Real>(0));
51 loadZ_.push_back(static_cast<Real>(0));
52 loadWidthX_.push_back(static_cast<Real>(0.125));
53 loadWidthY_.push_back(static_cast<Real>(0.125));
54 loadWidthZ_.push_back(static_cast<Real>(0.125));
55 }
56 if (ex == "3D Cantilever") {
57 loadMagnitude_.push_back(static_cast<Real>(1));
58 loadPolar_.push_back(static_cast<Real>(270));
59 loadAzimuth_.push_back(static_cast<Real>(90));
60 loadX_.push_back(static_cast<Real>(1));
61 loadY_.push_back(static_cast<Real>(0));
62 loadZ_.push_back(static_cast<Real>(0));
63 loadWidthX_.push_back(static_cast<Real>(0.125));
64 loadWidthY_.push_back(static_cast<Real>(0.125));
65 loadWidthZ_.push_back(static_cast<Real>(0.125));
66 }
67 else if (ex == "2D Truss") {
68 loadMagnitude_.push_back(static_cast<Real>(1));
69 loadPolar_.push_back(static_cast<Real>(270));
70 loadAzimuth_.push_back(static_cast<Real>(0));
71 loadX_.push_back(static_cast<Real>(2));
72 loadY_.push_back(static_cast<Real>(0.5));
73 loadZ_.push_back(static_cast<Real>(0));
74 loadWidthX_.push_back(static_cast<Real>(1e-2));
75 loadWidthY_.push_back(static_cast<Real>(1e-2));
76 loadWidthZ_.push_back(static_cast<Real>(1e-2));
77 }
78 else if (ex == "2D Beams") {
79 loadMagnitude_.push_back(static_cast<Real>(1));
80 loadMagnitude_.push_back(static_cast<Real>(1));
81 loadPolar_.push_back(static_cast<Real>(180));
82 loadPolar_.push_back(static_cast<Real>(180));
83 loadAzimuth_.push_back(static_cast<Real>(0));
84 loadAzimuth_.push_back(static_cast<Real>(0));
85 loadX_.push_back(static_cast<Real>(2));
86 loadX_.push_back(static_cast<Real>(2));
87 loadY_.push_back(static_cast<Real>(0));
88 loadY_.push_back(static_cast<Real>(1));
89 loadZ_.push_back(static_cast<Real>(0));
90 loadZ_.push_back(static_cast<Real>(0));
91 loadWidthX_.push_back(static_cast<Real>(1e-2));
92 loadWidthX_.push_back(static_cast<Real>(1e-2));
93 loadWidthY_.push_back(static_cast<Real>(1e-2));
94 loadWidthY_.push_back(static_cast<Real>(1e-2));
95 loadWidthZ_.push_back(static_cast<Real>(1e-2));
96 loadWidthZ_.push_back(static_cast<Real>(1e-2));
97 }
98 else if (ex == "2D Cantilever with 3 Loads" ||
99 ex == "2D Carrier Plate" ||
100 ex == "2D Wheel") {
101 loadMagnitude_.clear();
102 loadPolar_.clear();
103 loadAzimuth_.clear();
104 loadX_.clear();
105 loadY_.clear();
106 loadZ_.clear();
107 loadWidthX_.clear();
108 loadWidthY_.clear();
109 loadWidthZ_.clear();
110 }
111 else {
112 if (parlist.isSublist("Load")) {
113 // Grab Magnitudes
114 Teuchos::Array<Real> magnitude
115 = Teuchos::getArrayFromStringParameter<double>(parlist.sublist("Load"), "Magnitude");
116 loadMagnitude_ = magnitude.toVector();
117 // Grab Polar Angle
118 Teuchos::Array<Real> polar
119 = Teuchos::getArrayFromStringParameter<double>(parlist.sublist("Load"), "Polar Angle");
120 loadPolar_ = polar.toVector();
121 // Grab Azimuth Angle
122 Teuchos::Array<Real> azimuth
123 = Teuchos::getArrayFromStringParameter<double>(parlist.sublist("Load"), "Azimuth Angle");
124 loadAzimuth_ = azimuth.toVector();
125 // Grab X Location
126 Teuchos::Array<Real> Xlocation
127 = Teuchos::getArrayFromStringParameter<double>(parlist.sublist("Load"), "X Location");
128 loadX_ = Xlocation.toVector();
129 // Grab Y Location
130 Teuchos::Array<Real> Ylocation
131 = Teuchos::getArrayFromStringParameter<double>(parlist.sublist("Load"), "Y Location");
132 loadY_ = Ylocation.toVector();
133 // Grab Z Location
134 Teuchos::Array<Real> Zlocation
135 = Teuchos::getArrayFromStringParameter<double>(parlist.sublist("Load"), "Z Location");
136 loadZ_ = Zlocation.toVector();
137 // Grab X Width
138 Teuchos::Array<Real> Xwidth
139 = Teuchos::getArrayFromStringParameter<double>(parlist.sublist("Load"), "X Width");
140 loadWidthX_ = Xwidth.toVector();
141 // Grab Y Width
142 Teuchos::Array<Real> Ywidth
143 = Teuchos::getArrayFromStringParameter<double>(parlist.sublist("Load"), "Y Width");
144 loadWidthY_ = Ywidth.toVector();
145 // Grab Z Width
146 Teuchos::Array<Real> Zwidth
147 = Teuchos::getArrayFromStringParameter<double>(parlist.sublist("Load"), "Z Width");
148 loadWidthZ_ = Zwidth.toVector();
149 }
150 }
151
152 int polarSize = loadPolar_.size();
153 for (int i=0; i<polarSize; ++i) {
154 loadPolar_[i] = DegreesToRadians(loadPolar_[i]);
155 }
156
157 int azimuthSize = loadAzimuth_.size();
158 for (int i=0; i<azimuthSize; ++i) {
159 loadAzimuth_[i] = DegreesToRadians(loadAzimuth_[i]);
160 }
161 }
162
163 bool isNull(void) const {
164 return (loadMagnitude_.size()==0);
165 }
166
167 virtual Real loadFunc(const std::vector<Real> &coords,
168 const int dir,
169 const std::vector<Real> &param) const {
170 Real val(0);
171 const Real half(0.5);
172 const int numLoads = loadMagnitude_.size();
173 const int paramSize = param.size();
174 const int d = coords.size();
175 for (int i = 0; i < numLoads; ++i) {
176 Real loadMagNoise(0), loadAngNoise0(0);
177 if (paramSize > 0 + d*i) {
178 loadMagNoise = param[0 + d*i];
179 }
180 if (paramSize > 1 + d*i) {
181 loadAngNoise0 = DegreesToRadians(param[1 + d*i]);
182 }
183 const Real loadMagnitude = loadMagnitude_[i] + loadMagNoise;
184 const Real loadAngle0 = loadPolar_[i] + loadAngNoise0;
185 const Real Gx = std::exp(-half*std::pow(coords[0]-loadX_[i],2)/std::pow(loadWidthX_[i],2));
186 const Real Gy = std::exp(-half*std::pow(coords[1]-loadY_[i],2)/std::pow(loadWidthY_[i],2));
187
188 if (d==2) {
189 if (dir==0) {
190 val += loadMagnitude*std::cos(loadAngle0)*Gx*Gy;
191 }
192 if (dir==1) {
193 val += loadMagnitude*std::sin(loadAngle0)*Gx*Gy;
194 }
195 }
196 if (d==3) {
197 Real loadAngNoise1(0);
198 if (paramSize > 2 + d*i) {
199 loadAngNoise1 = DegreesToRadians(param[2 + d*i]);
200 }
201 const Real loadAngle1 = loadAzimuth_[i] + loadAngNoise1;
202 const Real Gz = std::exp(-half*std::pow(coords[2]-loadZ_[i],2)/std::pow(loadWidthZ_[i],2));
203
204 if (dir==0) {
205 val += loadMagnitude*std::sin(loadAngle0)*std::cos(loadAngle1)*Gx*Gy*Gz;
206 }
207 if (dir==1) {
208 val += loadMagnitude*std::sin(loadAngle0)*std::sin(loadAngle1)*Gx*Gy*Gz;
209 }
210 if (dir==2) {
211 val += loadMagnitude*std::cos(loadAngle0)*Gx*Gy*Gz;
212 }
213 }
214 }
215 return val;
216 }
217
218 void compute(std::vector<ROL::Ptr<Intrepid::FieldContainer<Real> > > &load,
219 const ROL::Ptr<FE<Real> > &fe,
220 const std::vector<Real> &param,
221 const Real scale = 1) const {
222 // Retrieve dimensions.
223 int c = fe->gradN()->dimension(0);
224 int p = fe->gradN()->dimension(2);
225 int d = fe->gradN()->dimension(3);
226 std::vector<Real> coord(d);
227
228 for (int i=0; i<c; ++i) {
229 for (int j=0; j<p; ++j) {
230 for (int k=0; k<d; ++k) {
231 coord[k] = (*fe->cubPts())(i,j,k);
232 }
233 for (int k=0; k<d; ++k) {
234 (*load[k])(i,j) = loadFunc(coord, k, param)*scale;
235 }
236 }
237 }
238 }
239 };
240
241 #endif