Debian Codegraph @

src/num/aslLevelSet.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 "aslLevelSet.h"
25 #include "acl/acl.h"
26 #include "acl/aclHardware.h"
27 #include "acl/Kernels/aclKernel.h"
28 #include "acl/Kernels/aclKernelConfigurationTemplates.h"
29 #include "acl/aclGenerators.h"
30 #include "acl/aclMath/aclMathAlg.h"
31 #include <algorithm>
32 #include <math/aslTemplatesExtras.h>
33 #include <math/aslTemplateVE.h>
34
35 namespace asl
36 {
37
38 LevelSet::~LevelSet()
39 {}
40
41 LevelSet::LevelSet():
42 kernel(new acl::Kernel(acl::KERNEL_SIMDUA)),
43 distanceField(),
44 distanceFieldInternalData(),
45 vectorTemplate(NULL),
46 vto(NULL)
47 {
48 }
49
50 LevelSet::LevelSet(Data df):
51 kernel(new acl::Kernel(acl::KERNEL_SIMDUA)),
52 distanceField(df),
53 distanceFieldInternalData(),
54 // vectorTemplate(nearestNeigboursVT(nD(df->getBlock())))
55 vectorTemplate(nearestNeigboursPVT(nD(df->getBlock()))),
56 vto(vtObject(vectorTemplate))
57 {
58 }
59
60 void LevelSet::initKernelPropagation()
61 {
62 distanceTVE.reset(new TemplateVE(*distanceField, *vectorTemplate));
63 (*kernel) << distanceTVE->initValues;
64
65 initVelocityComputation();
66 initDistancesComputation();
67
68 kernel->setup();
69 cout<<"!!!!!!! "<<acl::getKernelPrivateMemSize(*kernel)<<endl;
70 cout<<"!!!!!!! "<<acl::getKernelLocalMemSize(*kernel)<<endl;
71 // cout<<kernel->getKernelSource()<<endl;
72
73 }
74
75
76 acl::VectorOfElements LevelSet::isBoundaryEl(unsigned int iEl)
77 {
78 unsigned int n(vto->elementaryCells[iEl].getSize());
79 acl::VectorOfElements v(n);
80 for(unsigned int i(0); i < n; ++i)
81 v[i] = distanceTVE->values[vto->elementaryCells[iEl][i]];
82 return acl::differentSign(v);
83 }
84
85 acl::VectorOfElements LevelSet::isBoundaryDir(unsigned int iDir)
86 {
87 return acl::differentSign(cat(subVE(distanceTVE->values,0),
88 subVE(distanceTVE->values,iDir)));
89 }
90
91 acl::VectorOfElements LevelSet::getBoundaryCenter(unsigned int iEl)
92 {
93 auto cell(vto->elementaryCells[iEl]);
94 auto &dVal(distanceTVE->values);
95 acl::TypeID type(getElementType(dVal));
96 unsigned int n(cell.getSize());
97 vector<AVec<>> cellPoints;
98 vto->getCellPoints(iEl, cellPoints);
99 unsigned int nd(nD(cellPoints[0]));
100
101 acl::VectorOfElements v(acl::generateVEConstantN(nd,0));
102 acl::VectorOfElements nP(acl::generateVEConstant(0));
103 for(unsigned int i(0); i < n; ++i)
104 for(unsigned int j(i+1); j < n; ++j)
105 {
106 auto di(subVE(dVal, cell[i]));
107 auto dj(subVE(dVal, cell[j]));
108
109 auto isB(acl::differentSign(cat(di, dj)));
110 auto x(di / (di - dj));
111 auto pi(acl::generateVEConstant(cellPoints[i]));
112 auto pj(acl::generateVEConstant(cellPoints[j]));
113
114 auto p(select(acl::generateVEConstantN(nd,0),
115 pi + (pj - pi) * x,
116 isB,
117 type));
118 copy(v + p, v);
119 copy(nP +select(acl::generateVEConstant(0),
120 acl::generateVEConstant(1),
121 isB,
122 type),nP);
123
124 }
125 return v/nP;
126 }
127
128 vector<acl::Element> LevelSet::gcBoundaryArea(unsigned int iEl,
129 acl::VectorOfElements & center,
130 acl::VectorOfElements & area)
131 {
132 auto cell(vto->elementaryCells[iEl]);
133 auto &dVal(distanceTVE->values);
134 acl::TypeID type(getElementType(dVal));
135 unsigned int n(cell.getSize());
136 vector<AVec<>> cellPoints;
137 vto->getCellPoints(iEl, cellPoints);
138 // unsigned int nd(nD(cellPoints[0]));
139
140 vector<acl::Element> code(0);
141 code.push_back((area = acl::generateVEConstant(0.))[0]);
142 auto aij(acl::generateVEPrivateVariable(1u, type));
143 auto aik(acl::generateVEPrivateVariable(1u, type));
144 auto ajk(acl::generateVEPrivateVariable(1u, type));
145
146 acl::VectorOfElements nP(acl::generateVEConstant(0));
147 for(unsigned int i(0); i < n-2; ++i)
148 for(unsigned int j(i+1); j < n-1; ++j)
149 for(unsigned int k(j+1); k < n; ++k)
150 {
151 auto di(subVE(dVal, cell[i]));
152 auto dj(subVE(dVal, cell[j]));
153 auto dk(subVE(dVal, cell[k]));
154
155 auto isBij(acl::differentSign(cat(di, dj)));
156 auto isBik(acl::differentSign(cat(di, dk)));
157 auto isBjk(acl::differentSign(cat(dj, dk)));
158 auto xij(di / (di - dj));
159 auto xik(di / (di - dk));
160 auto xjk(dj / (dj - dk));
161 auto pi(acl::generateVEConstant(cellPoints[i]));
162 auto pj(acl::generateVEConstant(cellPoints[j]));
163 auto pk(acl::generateVEConstant(cellPoints[k]));
164
165 auto pij(pi + (pj - pi) * xij);
166 auto pik(pi + (pk - pi) * xik);
167 auto pjk(pj + (pk - pj) * xjk);
168 auto nij(crossProduct(pik-center,pjk-center));
169 auto nik(crossProduct(pij-center,pjk-center));
170 auto njk(crossProduct(pij-center,pik-center));
171
172 auto codeij(gcLength2(nij,aij));
173 auto codeik(gcLength2(nij,aik));
174 auto codejk(gcLength2(nij,ajk));
175 code.reserve(code.size()+codeij.size()+codeik.size()+codejk.size());
176 copy(codeij.begin(),codeij.end(),back_inserter(code));
177 copy(codeik.begin(),codeik.end(),back_inserter(code));
178 copy(codejk.begin(),codejk.end(),back_inserter(code));
179
180 auto res(select(acl::generateVEConstant(0.),
181 fabs(select(select(ajk, aik, !isBik), aij, !isBij)),
182 isBij || isBik || isBjk,
183 type));
184 code.push_back((area+=res)[0]);
185 }
186 return code;
187 }
188
189
190 acl::VectorOfElements LevelSet::getBoundaryPoint(unsigned int iDir)
191 {
192 auto &dVal(distanceTVE->values);
193
194 auto d0(subVE(dVal, 0));
195 auto di(subVE(dVal, iDir));
196
197 auto x(d0 / (d0 - di));
198 auto pi(acl::generateVEConstant(vectorTemplate->vectors[iDir]));
199 return pi * x;
200 }
201
202
203 acl::VectorOfElements LevelSet::getValueOnBoundary(acl::VectorOfElements field,
204 unsigned int i)
205 {
206 auto d0(subVE(distanceTVE->values, 0));
207 auto di(subVE(distanceTVE->values, i));
208 return subVE(field,0) +
209 (subVE(field,i) - subVE(field,0)) * d0 / (d0 - di);
210 }
211
212
213 void LevelSet::init()
214 {
215 distanceFieldInternalData=clone(distanceField);
216 acl::initData(distanceFieldInternalData->getDContainer(),
217 distanceField->getEContainer());
218
219 initKernelPropagation();
220 }
221
222 void LevelSet::execute()
223 {
224 kernel->compute();
225 swapBuffers(distanceField->getDContainer(),
226 distanceFieldInternalData->getDContainer());
227 }
228
229 } // asl
230