Debian Codegraph @

packages/rol/example/PDE-OPT/topo-opt/elasticity/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_ELASTICITY_LOAD_HPP
16 #define ROL_PDEOPT_ELASTICITY_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 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 ~Load() {}
41
42 Load(void) {}
43
44 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 ex == "3D L Beam") {
102 loadMagnitude_.clear();
103 loadPolar_.clear();
104 loadAzimuth_.clear();
105 loadX_.clear();
106 loadY_.clear();
107 loadZ_.clear();
108 loadWidthX_.clear();
109 loadWidthY_.clear();
110 loadWidthZ_.clear();
111 }
112 else {
113 if (parlist.isSublist("Load")) {
114 // Grab Magnitudes
115 Teuchos::Array<Real> magnitude
116 = Teuchos::getArrayFromStringParameter<double>(parlist.sublist("Load"), "Magnitude");
117 loadMagnitude_ = magnitude.toVector();
118 // Grab Polar Angle
119 Teuchos::Array<Real> polar
120 = Teuchos::getArrayFromStringParameter<double>(parlist.sublist("Load"), "Polar Angle");
121 loadPolar_ = polar.toVector();
122 // Grab Azimuth Angle
123 Teuchos::Array<Real> azimuth
124 = Teuchos::getArrayFromStringParameter<double>(parlist.sublist("Load"), "Azimuth Angle");
125 loadAzimuth_ = azimuth.toVector();
126 // Grab X Location
127 Teuchos::Array<Real> Xlocation
128 = Teuchos::getArrayFromStringParameter<double>(parlist.sublist("Load"), "X Location");
129 loadX_ = Xlocation.toVector();
130 // Grab Y Location
131 Teuchos::Array<Real> Ylocation
132 = Teuchos::getArrayFromStringParameter<double>(parlist.sublist("Load"), "Y Location");
133 loadY_ = Ylocation.toVector();
134 // Grab Z Location
135 Teuchos::Array<Real> Zlocation
136 = Teuchos::getArrayFromStringParameter<double>(parlist.sublist("Load"), "Z Location");
137 loadZ_ = Zlocation.toVector();
138 // Grab X Width
139 Teuchos::Array<Real> Xwidth
140 = Teuchos::getArrayFromStringParameter<double>(parlist.sublist("Load"), "X Width");
141 loadWidthX_ = Xwidth.toVector();
142 // Grab Y Width
143 Teuchos::Array<Real> Ywidth
144 = Teuchos::getArrayFromStringParameter<double>(parlist.sublist("Load"), "Y Width");
145 loadWidthY_ = Ywidth.toVector();
146 // Grab Z Width
147 Teuchos::Array<Real> Zwidth
148 = Teuchos::getArrayFromStringParameter<double>(parlist.sublist("Load"), "Z Width");
149 loadWidthZ_ = Zwidth.toVector();
150 }
151 }
152
153 int polarSize = loadPolar_.size();
154 for (int i=0; i<polarSize; ++i) {
155 loadPolar_[i] = DegreesToRadians(loadPolar_[i]);
156 }
157
158 int azimuthSize = loadAzimuth_.size();
159 for (int i=0; i<azimuthSize; ++i) {
160 loadAzimuth_[i] = DegreesToRadians(loadAzimuth_[i]);
161 }
162 }
163
164 bool isNull(void) const {
165 return (loadMagnitude_.size()==0);
166 }
167
168 virtual Real loadFunc(const std::vector<Real> &coords,
169 const int dir,
170 const std::vector<Real> &param) const {
171 Real val(0);
172 const Real half(0.5);
173 const int numLoads = loadMagnitude_.size();
174 const int paramSize = param.size();
175 const int d = coords.size();
176 for (int i = 0; i < numLoads; ++i) {
177 Real loadMagNoise(0), loadAngNoise0(0);
178 if (paramSize > 0 + d*i) {
179 loadMagNoise = param[0 + d*i];
180 }
181 if (paramSize > 1 + d*i) {
182 loadAngNoise0 = DegreesToRadians(param[1 + d*i]);
183 }
184 const Real loadMagnitude = loadMagnitude_[i] + loadMagNoise;
185 const Real loadAngle0 = loadPolar_[i] + loadAngNoise0;
186 const Real Gx = std::exp(-half*std::pow(coords[0]-loadX_[i],2)/std::pow(loadWidthX_[i],2));
187 const Real Gy = std::exp(-half*std::pow(coords[1]-loadY_[i],2)/std::pow(loadWidthY_[i],2));
188
189 if (d==2) {
190 if (dir==0) {
191 val += loadMagnitude*std::cos(loadAngle0)*Gx*Gy;
192 }
193 if (dir==1) {
194 val += loadMagnitude*std::sin(loadAngle0)*Gx*Gy;
195 }
196 }
197 if (d==3) {
198 Real loadAngNoise1(0);
199 if (paramSize > 2 + d*i) {
200 loadAngNoise1 = DegreesToRadians(param[2 + d*i]);
201 }
202 const Real loadAngle1 = loadAzimuth_[i] + loadAngNoise1;
203 const Real Gz = std::exp(-half*std::pow(coords[2]-loadZ_[i],2)/std::pow(loadWidthZ_[i],2));
204
205 if (dir==0) {
206 val += loadMagnitude*std::sin(loadAngle0)*std::cos(loadAngle1)*Gx*Gy*Gz;
207 }
208 if (dir==1) {
209 val += loadMagnitude*std::sin(loadAngle0)*std::sin(loadAngle1)*Gx*Gy*Gz;
210 }
211 if (dir==2) {
212 val += loadMagnitude*std::cos(loadAngle0)*Gx*Gy*Gz;
213 }
214 }
215 }
216 return val;
217 }
218
219 void compute(std::vector<ROL::Ptr<Intrepid::FieldContainer<Real> > > &load,
220 const ROL::Ptr<FE<Real> > &fe,
221 const std::vector<Real> &param,
222 const Real scale = 1) const {
223 // Retrieve dimensions.
224 int c = fe->gradN()->dimension(0);
225 int p = fe->gradN()->dimension(2);
226 int d = fe->gradN()->dimension(3);
227 std::vector<Real> coord(d);
228
229 for (int i=0; i<c; ++i) {
230 for (int j=0; j<p; ++j) {
231 for (int k=0; k<d; ++k) {
232 coord[k] = (*fe->cubPts())(i,j,k);
233 }
234 for (int k=0; k<d; ++k) {
235 (*load[k])(i,j) = loadFunc(coord, k, param)*scale;
236 }
237 }
238 }
239 }
240 };
241
242 #endif