Debian Codegraph @

src/math/aslDistanceFunctionAlg.cxx

raw
1 /*
2 * Advanced Simulation Library <http://asl.org.il>
3 *
4 * Copyright 2015 Avtech Scientific <http://avtechscientific.com>
5 *
6 *
7 * This file is part of Advanced Simulation Library (ASL).
8 *
9 * ASL is free software: you can redistribute it and/or modify it
10 * under the terms of the GNU Affero General Public License as
11 * published by the Free Software Foundation, version 3 of the License.
12 *
13 * ASL is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU Affero General Public License for more details.
17 *
18 * You should have received a copy of the GNU Affero General Public License
19 * along with ASL. If not, see <http://www.gnu.org/licenses/>.
20 *
21 */
22
23
24 #include "aslDistanceFunction.h"
25 #include "acl/aclMath/aclVectorOfElements.h"
26 #include <acl/aclGenerators.h>
27 #include <acl/acl.h>
28 #include <data/aslBlocks.h>
29 #include <aslGenerators.h>
30 #include <math/aslIndex2Position.h>
31 #include "acl/aclMath/aclMathAlg.h"
32 #include <math/aslTemplatesExtras.h>
33 #include <math/aslTemplateVE.h>
34
35
36
37 namespace asl
38 {
39
40 acl::VectorOfElements isGhostNode(TemplateVE & distanceTVE, unsigned int i)
41 {
42 return (distanceTVE.getValue(i) <= 0.);
43 }
44
45 acl::VectorOfElements isComputationNode(TemplateVE & distanceTVE, unsigned int i)
46 {
47 return (distanceTVE.getValue(i) > 0.);
48 }
49
50
51 acl::VectorOfElements nGhostNodesInCell(TemplateVE & distanceTVE, unsigned int iEl)
52 {
53 auto cell(distanceTVE.vto->elementaryCells[iEl]);
54 acl::VectorOfElements nGhost(1);
55 acl::TypeID type(getElementType(distanceTVE.values));
56 copy(select(acl::generateVEConstant(1),
57 isGhostNode(distanceTVE,cell[0]),
58 type),
59 nGhost);
60
61 for(unsigned int i(1); i< cell.getSize(); ++i)
62 {
63 copy(nGhost + select(acl::generateVEConstant(1),
64 isGhostNode(distanceTVE,cell[i]),
65 type),
66 nGhost);
67 }
68 return nGhost;
69 }
70
71 acl::VectorOfElements isBoundaryBetween(TemplateVE & distanceTVE,
72 unsigned int iE,
73 unsigned int i,
74 unsigned int j)
75 {
76 auto vto(distanceTVE.vto);
77 auto cell(vto->elementaryCells[iE]);
78 return (isGhostNode(distanceTVE, cell[i]) &&
79 isComputationNode(distanceTVE, cell[j])) ||
80 (isGhostNode(distanceTVE, cell[j]) &&
81 isComputationNode(distanceTVE, cell[i]));
82 }
83
84 acl::VectorOfElements exBoundaryX(TemplateVE & distanceTVE, unsigned int i)
85 {
86 return distanceTVE.getValue(0)/(distanceTVE.getValue(0)-distanceTVE.getValue(i));
87 }
88
89 acl::VectorOfElements exBoundaryCenter(TemplateVE & distanceTVE, unsigned int iEl)
90 {
91 auto vto(distanceTVE.vto);
92 auto cell(vto->elementaryCells[iEl]);
93 auto &dVal(distanceTVE.values);
94 acl::TypeID type(getElementType(dVal));
95 unsigned int n(cell.getSize());
96 vector<AVec<>> cellPoints;
97 vto->getCellPoints(iEl, cellPoints);
98 unsigned int nd(nD(cellPoints[0]));
99
100 acl::VectorOfElements v(acl::generateVEConstantN(nd,0));
101 acl::VectorOfElements nP(acl::generateVEConstant(0));
102 for(unsigned int i(0); i < n-1; ++i)
103 for(unsigned int j(i+1); j < n; ++j)
104 {
105 auto di(subVE(dVal, cell[i]));
106 auto dj(subVE(dVal, cell[j]));
107
108 auto isB(isBoundaryBetween(distanceTVE,iEl,i,j));
109 auto x(di / (di - dj));
110 auto pi(acl::generateVEConstant(cellPoints[i]));
111 auto pj(acl::generateVEConstant(cellPoints[j]));
112
113 auto p(select(pi + (pj - pi) * x, isB, type));
114 copy(v + p, v);
115 copy(nP +select(acl::generateVEConstant(1), isB, type),nP);
116
117 }
118 return v/nP;
119 }
120
121 vector<acl::Element> gcBoundaryArea(TemplateVE & distanceTVE,
122 unsigned int iEl,
123 acl::VectorOfElements & center,
124 acl::VectorOfElements & area)
125 {
126 auto vto(distanceTVE.vto);
127
128 auto cell(vto->elementaryCells[iEl]);
129 auto &dVal(distanceTVE.values);
130 acl::TypeID type(getElementType(area));
131 unsigned int n(cell.getSize());
132 vector<AVec<>> cellPoints;
133 vto->getCellPoints(iEl, cellPoints);
134 // unsigned int nd(nD(cellPoints[0]));
135
136 vector<acl::Element> code(0);
137 code<<(area = acl::generateVEConstant(0.));
138 auto aij(acl::generateVEPrivateVariable(1u, type));
139 auto aik(acl::generateVEPrivateVariable(1u, type));
140 auto ajk(acl::generateVEPrivateVariable(1u, type));
141
142 acl::VectorOfElements nP(acl::generateVEConstant(0));
143 for(unsigned int i(0); i < n-2; ++i)
144 for(unsigned int j(i+1); j < n-1; ++j)
145 for(unsigned int k(j+1); k < n; ++k)
146 {
147 auto di(subVE(dVal, cell[i]));
148 auto dj(subVE(dVal, cell[j]));
149 auto dk(subVE(dVal, cell[k]));
150
151 auto isBij(isBoundaryBetween(distanceTVE,iEl, i, j));
152 auto isBik(isBoundaryBetween(distanceTVE,iEl, i, k));
153 auto isBjk(isBoundaryBetween(distanceTVE,iEl, j, k));
154 auto xij(di / (di - dj));
155 auto xik(di / (di - dk));
156 auto xjk(dj / (dj - dk));
157 auto pi(acl::generateVEConstant(cellPoints[i]));
158 auto pj(acl::generateVEConstant(cellPoints[j]));
159 auto pk(acl::generateVEConstant(cellPoints[k]));
160
161 auto pij(pi + (pj - pi) * xij);
162 auto pik(pi + (pk - pi) * xik);
163 auto pjk(pj + (pk - pj) * xjk);
164 auto nij(crossProduct(pik-center,pjk-center));
165 auto nik(crossProduct(pij-center,pjk-center));
166 auto njk(crossProduct(pij-center,pik-center));
167
168 auto codeij(gcLength2(nij,aij));
169 auto codeik(gcLength2(nik,aik));
170 auto codejk(gcLength2(njk,ajk));
171 code<<codeij;
172 code<<codeik;
173 code<<codejk;
174
175 auto res(select(sqrt(select(select(ajk, aik, !isBik), aij, !isBij)),
176 isBij || isBik || isBjk, type)*.5);
177 code<<(area+=res);
178 }
179 return code;
180 }
181
182 vector<acl::Element> gcBoundaryArea(TemplateVE & distanceTVE,
183 acl::VectorOfElements & area)
184 {
185 unsigned int nCells(distanceTVE.vto->elementaryCells.size());
186 acl::TypeID type(getElementType(area));
187
188 vector<acl::Element> code;
189 auto areaCell(acl::generateVEPrivateVariable(1u, type));
190 auto centerCell(acl::generateVEPrivateVariable(3u, type));
191
192 code<<(area = acl::generateVEConstant(0.));
193
194 for(unsigned int i(0); i<nCells; ++i)
195 {
196 code<<(centerCell = exBoundaryCenter(distanceTVE, i));
197 code<<gcBoundaryArea(distanceTVE,i,centerCell,areaCell);
198 code<<(area+=areaCell);
199 }
200
201
202 return code;
203 }
204
205 acl::VectorOfElements zeroNodeWeight(TemplateVE & distanceTVE, unsigned int iEl)
206 {
207 auto cell(distanceTVE.vto->elementaryCells[iEl]);
208 acl::VectorOfElements w0(1);
209 acl::VectorOfElements wC(1);
210 acl::TypeID type(getElementType(distanceTVE.values));
211 copy(select(acl::generateVEConstant(distanceTVE.vectorTemplate->laplasCoefs[cell[1]]),
212 isComputationNode(distanceTVE,cell[1]),
213 type),
214 w0);
215
216 for(unsigned int i(2); i< cell.getSize(); ++i)
217 {
218 copy(w0+select(acl::generateVEConstant(distanceTVE.vectorTemplate->laplasCoefs[cell[i]]),
219 isComputationNode(distanceTVE,cell[i]),
220 type),
221 w0);
222 }
223 return w0;
224 }
225
226 acl::VectorOfElements surfaceCellWeight(TemplateVE & distanceTVE, unsigned int iEl)
227 {
228 auto cell(distanceTVE.vto->elementaryCells[iEl]);
229 acl::VectorOfElements w0(1);
230 acl::VectorOfElements wC(1);
231 acl::TypeID type(getElementType(distanceTVE.values));
232 copy(select(acl::generateVEConstant(distanceTVE.vectorTemplate->laplasCoefs[cell[1]]),
233 isComputationNode(distanceTVE,cell[1]),
234 type),
235 w0);
236
237 for(unsigned int i(2); i< cell.getSize(); ++i)
238 {
239 copy(w0+select(acl::generateVEConstant(distanceTVE.vectorTemplate->laplasCoefs[cell[i]]),
240 isComputationNode(distanceTVE,cell[i]),
241 type),
242 w0);
243 }
244 copy(w0,wC);
245 for(unsigned int i(1); i<cell.getSize()-1; ++i)
246 for(unsigned int j(i+1); j< cell.getSize(); ++j)
247 {
248 copy(wC+select(acl::generateVEConstant(edgeWeight(*distanceTVE.vto,iEl,i,j)),
249 isBoundaryBetween(distanceTVE,iEl,i,j),
250 type),
251 wC);
252 }
253
254 return wC;
255 }
256 vector<acl::Element> gcBoundaryAreaPerGhostPoint(TemplateVE & distanceTVE,
257 unsigned int iEl,
258 acl::VectorOfElements & center,
259 acl::VectorOfElements & area)
260 {
261 auto code(gcBoundaryArea(distanceTVE,iEl,center,area));
262 acl::TypeID type(getElementType(area));
263 // auto wc(acl::generateVEPrivateVariable(1u, type));
264 auto nGhost(acl::generateVEPrivateVariable(1u, type));
265 code << (nGhost = nGhostNodesInCell(distanceTVE, iEl));
266
267 // code << (wc = surfaceCellWeight(distanceTVE, iEl));
268 // code << (area *=select(acl::generateVEConstant(1.),
269 // zeroNodeWeight(distanceTVE,iEl)/wc,
270 // wc>.01,
271 // type));
272 /* code << (area *=select(acl::generateVEConstant(1.),
273 zeroNodeWeight(distanceTVE,iEl),
274 wc>.01,
275 type));
276 */
277 code << (area /=select(acl::generateVEConstant(1.),
278 nGhost,
279 nGhost>.1,
280 type));
281
282 return code;
283 }
284
285 vector<acl::Element> gcBoundaryAreaPerGhostPoint(TemplateVE & distanceTVE,
286 acl::VectorOfElements & area)
287 {
288 unsigned int nCells(distanceTVE.vto->elementaryCells.size());
289 acl::TypeID type(getElementType(area));
290
291 vector<acl::Element> code;
292 auto areaCell(acl::generateVEPrivateVariable(1u, type));
293 auto centerCell(acl::generateVEPrivateVariable(3u, type));
294
295 code<<(area = acl::generateVEConstant(0.));
296
297 for(unsigned int i(0); i<nCells; ++i)
298 {
299 code<<(centerCell = exBoundaryCenter(distanceTVE, i));
300 code<<gcBoundaryAreaPerGhostPoint(distanceTVE,i,centerCell,areaCell);
301 code<<(area+=areaCell);
302 }
303
304 return code;
305 }
306
307 } // asl