Debian Codegraph @

src/num/aslFDElasticityBC.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 "aslFDElasticityBC.h"
25 #include "aslFDElasticity.h"
26 #include <data/aslDataWithGhostNodes.h>
27 #include "acl/aclMath/aclVectorOfElements.h"
28 #include "acl/acl.h"
29 #include "acl/aclHardware.h"
30 #include "acl/aclGenerators.h"
31 #include "acl/Kernels/aclExpressionContainer.h"
32 #include "acl/Kernels/aclKernel.h"
33 #include "acl/Kernels/aclKernelConfigurationTemplates.h"
34
35 #include <math/aslTemplateVE.h>
36 #include <math/aslTemplateVEExtras.h>
37 #include <aslGenerators.h>
38 #include <acl/aclMath/aclMathAlg.h>
39
40 #include "aslBasicBC.h"
41
42
43 using acl::generateVEConstant;
44 using acl::generateVEConstantN;
45
46 namespace asl
47 {
48 BCRigidWall::BCRigidWall(SPFDElasticityIncompressibleStatic nm):
49 BCond(nm->getDisplacementData()->getBlock(),nm->vectorTemplate),
50 kernel(new acl::Kernel(acl::KERNEL_BASIC)),
51 num(nm)
52 {
53 }
54
55
56 void BCRigidWall::init()
57 {
58 unsigned int nC(num->getDisplacementData()->getEContainer().size());
59 loadIndicesToACL();
60 loadNeighbourIndicesToACL();
61 (*kernel)<<(acl::excerpt(num->getDisplacementData()->getEContainer(),
62 *indicesACL) =
63 acl::generateVEConstantN(nC,0.));
64 (*kernel)<<(acl::excerpt(num->getPressureData()->getEContainer(),
65 *indicesACL) =
66 acl::excerpt(num->getPressureData()->getEContainer(),
67 *neighbourIndicesACL));
68 kernel->setup();
69 }
70
71
72 void BCRigidWall::execute()
73 {
74 kernel->compute();
75 }
76
77 SPBCond generateBCRigidWall(SPFDElasticityIncompressibleStatic nm,
78 const std::vector<SlicesNames> & sl)
79 {
80 auto bc(make_shared<BCRigidWall>(nm));
81 addSlices(*bc,sl);
82 return bc;
83 }
84
85 BCRigidWallRelaxation::BCRigidWallRelaxation(SPFDElasticityRelaxation nm):
86 BCond(nm->getDisplacementData()->getBlock(),nm->vectorTemplate),
87 kernel(new acl::Kernel(acl::KERNEL_BASIC)),
88 num(nm),
89 value(generateVEConstantN(nD(*nm),0.))
90 {
91 }
92
93 BCRigidWallRelaxation::BCRigidWallRelaxation(SPFDElasticityRelaxation nm, acl::VectorOfElements v):
94 BCond(nm->getDisplacementData()->getBlock(),nm->vectorTemplate),
95 kernel(new acl::Kernel(acl::KERNEL_BASIC)),
96 num(nm),
97 value(v)
98 {
99 }
100
101
102 void BCRigidWallRelaxation::init()
103 {
104 loadIndicesToACL();
105 loadNeighbourIndicesToACL();
106 (*kernel)<<(acl::excerpt(num->getDisplacementData()->getEContainer(),
107 *indicesACL) = value);
108 (*kernel)<<(acl::excerpt(num->getPressureData()->getEContainer(),
109 *indicesACL) =
110 acl::excerpt(num->getPressureData()->getEContainer(),
111 *neighbourIndicesACL));
112 kernel->setup();
113 }
114
115
116 void BCRigidWallRelaxation::execute()
117 {
118 kernel->compute();
119 }
120
121 SPBCond generateBCRigidWall(SPFDElasticityRelaxation nm,
122 const std::vector<SlicesNames> & sl)
123 {
124 auto bc(make_shared<BCRigidWallRelaxation>(nm));
125 addSlices(*bc,sl);
126 return bc;
127 }
128
129 SPBCond generateBCRigidWall(SPFDElasticityRelaxation nm,
130 const AVec<> & u0,
131 const std::vector<SlicesNames> & sl)
132 {
133 auto bc(make_shared<BCRigidWallRelaxation>(nm,acl::generateVEConstant(u0)));
134 addSlices(*bc,sl);
135 return bc;
136 }
137
138 SPBCond generateBCRigidWall(SPFDElasticity2 nm,
139 const std::vector<SlicesNames> & sl)
140 {
141 auto d(nm->getDisplacementData());
142 return generateBCConstantValue(d, AVec<>(nD(d->getBlock()),0), sl);
143 }
144
145 SPBCond generateBCRigidWall(SPFDElasticity2 nm,
146 const AVec<> & u0,
147 const std::vector<SlicesNames> & sl)
148 {
149 auto d(nm->getDisplacementData());
150 return generateBCConstantValue(d, u0, sl);
151 }
152
153 BCFreeSurface::BCFreeSurface(FDElasticityIncompressibleStatic* nm):
154 BCond(nm->getDisplacementData()->getBlock(),nm->vectorTemplate),
155 kernel(new acl::Kernel(acl::KERNEL_BASIC)),
156 num(nm)
157 {
158 }
159
160
161 void BCFreeSurface::init()
162 {
163 loadIndicesToACL();
164 loadNeighbourIndicesToACL();
165 (*kernel)<<(acl::excerpt(num->getDisplacementData()->getEContainer(),
166 *indicesACL) =
167 acl::excerpt(num->getDisplacementData()->getEContainer(),
168 *neighbourIndicesACL));
169 kernel->setup();
170 }
171
172
173 void BCFreeSurface::execute()
174 {
175 kernel->compute();
176 }
177
178 BCFreeSurface2::BCFreeSurface2(SPFDElasticity2 nm):
179 BCond(nm->getDisplacementData()->getBlock(),nm->vectorTemplate),
180 kernel(new acl::Kernel(acl::KERNEL_BASIC)),
181 num(nm)
182 {
183 }
184
185 BCFreeSurface2::~BCFreeSurface2()
186 {
187 }
188
189
190 void BCFreeSurface2::init()
191 {
192 loadIndicesToACL();
193 loadNeighbourIndicesToACL();
194 (*kernel)<<(acl::excerpt(num->getDisplacementData()->getEContainer(),
195 *indicesACL) =
196 acl::excerpt(num->getDisplacementData()->getEContainer(),
197 *neighbourIndicesACL));
198 kernel->setup();
199 }
200
201
202 void BCFreeSurface2::execute()
203 {
204 kernel->compute();
205 }
206
207
208 BCImposedDisplacementVelocityValue::
209 BCImposedDisplacementVelocityValue(SPFDElasticityIncompressibleStatic nm):
210 BCond(nm->getDisplacementData()->getBlock(),nm->vectorTemplate),
211 kernel(new acl::Kernel(acl::KERNEL_BASIC)),
212 num(nm),
213 displacement(AVec<double>(nD(*nm),0)),
214 bDisplacement(false),
215 velocity(AVec<double>(nD(*nm),0)),
216 bVelocity(false),
217 initialized(false)
218 {
219 }
220
221 void BCImposedDisplacementVelocityValue::setDisplacement(AVec<double> d)
222 {
223 if (initialized && !bDisplacement)
224 errorMessage ("Error (BCImposedDisplacementVelocityValue): An attempt to set displacment value after initialization");
225 displacement=d;
226 bDisplacement=true;
227 }
228
229
230 void BCImposedDisplacementVelocityValue::setVelocity(AVec<double> v)
231 {
232 if (initialized && !bVelocity)
233 errorMessage ("Error (BCImposedDisplacementVelocityValue): An attempt to set velocity value after initialization");
234 velocity=v;
235 bVelocity=true;
236 }
237
238 void BCImposedDisplacementVelocityValue::init()
239 {
240 loadIndicesToACL();
241 if (bDisplacement)
242 (*kernel)<<(
243 acl::excerpt(num->getDisplacementData()->getEContainer(),*indicesACL)=
244 acl::generateVEVariableR(displacement)
245 );
246 if (bVelocity)
247 // (*kernel)<<(
248 // acl::excerpt(num->getVelocityData()->getEContainer(),*indicesACL)=
249 // acl::generateVEVariableR(velocity)
250 // );
251 kernel->setup();
252 initialized=true;
253 }
254
255
256 void BCImposedDisplacementVelocityValue::execute()
257 {
258 kernel->compute();
259 }
260
261
262 BCAccelerationSource2::BCAccelerationSource2(FDElasticity2* nm):
263 BCond(nm->getDisplacementData()->getBlock(),nm->vectorTemplate),
264 kernel(new acl::Kernel(acl::KERNEL_BASIC)),
265 num(nm),
266 acceleration(nD(*nm)),
267 initialized(false)
268 {
269 }
270
271
272 void BCAccelerationSource2::setAcceleration(AVec<double> a)
273 {
274 copy(acl::generateVEVariableR(a)*(num->getDeltat()*num->getDeltat()),acceleration);
275 }
276
277 void BCAccelerationSource2::init()
278 {
279 loadIndicesToACL();
280 (*kernel)<<(
281 acl::excerpt(num->getDisplacementInternalData()->getEContainer(),*indicesACL)-=
282 acceleration);
283 kernel->setup();
284 initialized=true;
285 }
286
287
288 void BCAccelerationSource2::execute()
289 {
290 kernel->compute();
291 }
292
293 BCZeroStressMap::BCZeroStressMap(SPAbstractDataWithGhostNodes d,
294 acl::VectorOfElements l,
295 acl::VectorOfElements m,
296 SPAbstractDataWithGhostNodes map,
297 const VectorTemplate *const t):
298 BCondWithMap(map,t),
299 displacement(d),
300 lambda(l),
301 mu(m),
302 // kernel(new acl::Kernel(acl::KERNEL_SIMDUA)) //< Important _BASIC has better performance
303 kernel(new acl::Kernel(acl::KERNEL_BASIC)) //< It is important to fix generateDCFullSafe- SIMDUA issue
304 {
305 }
306
307 BCZeroStressMap::~BCZeroStressMap()
308 {
309 }
310
311
312 void BCZeroStressMap::init()
313 {
314 acl::ExpressionContainer kk;
315
316 auto dispX(generateDCFullSafe(displacement));
317 initMapInfrastructure(kk);
318
319 auto & vto(*mapTVE->vto);
320 unsigned int nd(nD(*templ));
321 vector<TemplateVE> duTVE(nd);
322 for(unsigned int i(0); i < nd; ++i)
323 {
324 duTVE[i].init(*dispX, *templ, i);
325 kk << duTVE[i].initValues;
326 }
327
328 unsigned int nCells(mapTVE->vto->elementaryCells.size());
329 acl::TypeID type(getElementType(mapTVE->values));
330 acl::TypeID typeI(acl::TYPE_SELECT[type]);
331
332 auto vNormal(generateVEPrivateVariable(nd,type));
333 auto vE(generateVEConstantN(nd,1.));
334 auto vB(generateVEPrivateVariable(nd,type));
335 auto mA(acl::generateMEPrivateVariable(nd,nd,type));
336 auto mDelta(acl::generateMEUnit(nd));
337 acl::MatrixOfElements mU(nd,nd);
338 acl::VectorOfElements u0(nd);
339 for(unsigned int j(0); j < nd; ++j)
340 u0[j]=duTVE[j].values[0];
341 auto muDlambda(mu/lambda);
342 auto vU0(generateVEPrivateVariable(nd,type));
343 auto vU0Res(generateVEPrivateVariable(nd,type));
344 auto isMatrixSol(generateVEPrivateVariable(1,typeI));
345 auto isBoundary(generateVEPrivateVariable(1,typeI));
346
347 kk << (vNormal = generateVEConstantN(nd, 0.));
348 kk << (mA = generateMEDiagonal(generateVEConstantN(nd, 0.)));
349 kk << (vB = generateVEConstantN(nd, 0.));
350 for(unsigned int i(0); i < nCells; ++i)
351 {
352 auto cellVal(cellValues(*mapTVE, i));
353 kk << (isBoundary = (isGhostNode(0)) &&
354 (sumOfElements(sign(subVE(cellVal,1,nd))) >
355 ((double)nd - .2)));
356 kk << (vNormal += select(generateVEConstantN(nd,0.),
357 gradient(*mapTVE, i),
358 isBoundary,
359 type));
360 }
361 kk << (gcNormalize(vNormal));
362
363 for(unsigned int i(0); i < nCells; ++i)
364 {
365 auto mT(acl::generateMEConstant(vto.cellMatrices[i]));
366
367 for(unsigned int j(0); j < nd; ++j)
368 for(unsigned int k(0); k < nd; ++k)
369 mU.setElement(j,k, subVE(duTVE[j].values,
370 vto.elementaryCells[i][k+1])[0]);
371
372 auto cellVal(cellValues(*mapTVE, i));
373 kk << (isBoundary = (isGhostNode(0)) &&
374 (sumOfElements(sign(subVE(cellVal,1,nd))) >
375 ((double)nd - .2)) );
376
377 kk << (mA.getInternalVector() += select((elementProduct(vNormal, vE * mT) +
378 elementProduct(vE * mT, muDlambda * vNormal) +
379 mDelta * generateME( vE * mT * (muDlambda * vNormal))).getInternalVector(),
380 isBoundary,
381 type));
382 kk << (vB += select(trace(mU, mT) * vNormal +
383 (muDlambda * vNormal * mU) * mT +
384 mU * (mT * vNormal* muDlambda),
385 isBoundary,
386 type));
387 }
388 kk << gcSolveSystem(mA,vB,vU0);
389 kk << (isMatrixSol = (acl::fabs(det(mA)) > .05));
390
391 auto counterD(generateVEPrivateVariable(1,type));
392 kk << (vU0 = generateVEConstantN(nd, 0.));
393 kk << (counterD = generateVEConstant(0));
394 unsigned int nDir(mapTVE->vectorTemplate->vectors.size());
395 for(unsigned int i(1); i < nDir; ++i)
396 {
397 kk << (isBoundary = (isComputationNode(i)));
398 kk << (counterD += select(generateVEConstant(1.), isBoundary, type));
399 acl::VectorOfElements vv(nd);
400 for(unsigned int k(0); k < nd; ++k)
401 vv[k] = duTVE[k].values[i];
402 kk << ( vU0 += select(vv, isBoundary, type));
403 }
404 kk << (vU0 /= max(counterD, generateVEConstant(.1), type));
405 kk << (vU0Res = select(vU0, vU0Res, isMatrixSol, type));
406 kk << (vU0Res = select(u0, vU0Res, isGhostNode(0), type));
407
408 kk << (acl::assignmentSafe(displacement->getEContainer(), vU0Res));
409
410 kernel->addExpression(acl::elementOperators::
411 ifElse(acl::elementOperators::any((isGhostNode() &&
412 map->getEContainer() > -.9999)[0]),
413 kk.expression,
414 {} ));
415 kernel->setup();
416 // cout<<kernel->getKernelSource()<<endl;
417
418 }
419 /*
420 void BCZeroStressMap::init()
421 {
422 acl::ExpressionContainer kk;
423
424 auto dispX(generateDCFullSafe(displacement));
425 initMapInfrastructure(kk);
426
427 auto & vto(*mapTVE->vto);
428 unsigned int nd(nD(*templ));
429 vector<TemplateVE> duTVE(nd);
430 for(unsigned int i(0); i < nd; ++i)
431 {
432 duTVE[i].init(*dispX, *templ, i);
433 kk << duTVE[i].initValues;
434 }
435
436 unsigned int nCells(mapTVE->vto->elementaryCells.size());
437 acl::TypeID type(getElementType(mapTVE->values));
438 acl::TypeID typeI(acl::TYPE_SELECT[type]);
439
440 auto vNormal(generateVEPrivateVariable(nd,type));
441 auto vE(generateVEConstantN(nd,1.));
442 auto vB(generateVEPrivateVariable(nd,type));
443 auto mA(acl::generateMEPrivateVariable(nd,nd,type));
444 auto mDelta(acl::generateMEUnit(nd));
445 acl::MatrixOfElements mU(nd,nd);
446 acl::VectorOfElements u0(nd);
447 for(unsigned int j(0); j < nd; ++j)
448 u0[j]=duTVE[j].values[0];
449 auto muDlambda(mu/lambda);
450 auto vU0(generateVEPrivateVariable(nd,type));
451 auto vU0Res(generateVEPrivateVariable(nd,type));
452 auto counter(generateVEPrivateVariable(1,type));
453 auto isBoundary(generateVEPrivateVariable(1,typeI));
454
455 kk << (counter = generateVEConstant(0));
456 kk << (vU0Res = generateVEConstantN(nd, 0.));
457 kk << (vNormal = generateVEConstantN(nd, 0.));
458 for(unsigned int i(0); i < nCells; ++i)
459 {
460 auto cellVal(cellValues(*mapTVE, i));
461 kk << (isBoundary = (isGhostNode(0)) &&
462 (sumOfElements(sign(subVE(cellVal,1,nd))) >
463 ((double)nd - .2)));
464 kk << (vNormal += select(generateVEConstantN(nd,0.),
465 gradient(*mapTVE, i),
466 isBoundary,
467 type));
468 }
469 kk << (gcNormalize(vNormal));
470
471 for(unsigned int i(0); i < nCells; ++i)
472 {
473 auto mT(acl::generateMEConstant(vto.cellMatrices[i]));
474
475 for(unsigned int j(0); j < nd; ++j)
476 for(unsigned int k(0); k < nd; ++k)
477 mU.setElement(j,k, subVE(duTVE[j].values,
478 vto.elementaryCells[i][k+1])[0]);
479 // kk << (vNormal = gradient(*mapTVE, i));
480 // kk << (gcNormalize(vNormal));
481 kk << (mA = elementProduct(vNormal, vE * mT) +
482 elementProduct(vE * mT, muDlambda * vNormal) +
483 mDelta * generateME( vE * mT * (muDlambda * vNormal)));
484 kk << (vB = trace(mU, mT) * vNormal +
485 (muDlambda * vNormal * mU) * mT +
486 mU * (mT * vNormal* muDlambda));
487
488 kk << gcSolveSystem(mA,vB,vU0);
489 auto cellVal(cellValues(*mapTVE, i));
490 kk << (isBoundary = (isGhostNode(0)) &&
491 (sumOfElements(sign(subVE(cellVal,1,nd))) >
492 ((double)nd - .2)) && (acl::fabs(det(mA)) > .1));
493 kk << (counter += select(generateVEConstant(0.),
494 generateVEConstant(1.),
495 isBoundary,
496 type));
497 kk << ( vU0Res += select(generateVEConstantN(nd,0.),
498 vU0,
499 isBoundary,
500 type));
501 }
502 kk << (vU0Res /= max(counter, generateVEConstant(.1), type));
503
504 auto counterD(generateVEPrivateVariable(1,type));
505 kk << (vU0 = generateVEConstantN(nd, 0.));
506 kk << (counterD = generateVEConstant(0));
507 unsigned int nDir(mapTVE->vectorTemplate->vectors.size());
508 for(unsigned int i(1); i < nDir; ++i)
509 {
510 kk << (isBoundary = (isComputationNode(i)));
511 kk << (counterD += select(generateVEConstant(0.),
512 generateVEConstant(1.),
513 isBoundary,
514 type));
515 acl::VectorOfElements vv(nd);
516 for(unsigned int k(0); k < nd; ++k)
517 vv[k] = duTVE[k].values[i];
518 kk << ( vU0 += select(generateVEConstantN(nd,0.),
519 vv,
520 isBoundary,
521 type));
522 }
523 kk << (vU0 /= max(counterD, generateVEConstant(.1), type));
524 kk << (vU0Res = select(vU0, vU0Res, counter > .1, type));
525 kk << (vU0Res = select(u0,
526 vU0Res,
527 isGhostNode(0),
528 type));
529
530 kk << (acl::assignmentSafe(displacement->getEContainer(), vU0Res));
531
532 kernel->addExpression(acl::elementOperators::
533 ifElse(acl::elementOperators::any((isGhostNode() &&
534 map->getEContainer() > -.9999)[0]),
535 kk.expression,
536 {} ));
537 kernel->setup();
538 // cout<<kernel->getKernelSource()<<endl;
539
540 }
541 */
542
543 void BCZeroStressMap::execute()
544 {
545 kernel->compute();
546 }
547
548 SPNumMethod generateBCZeroStress(SPElasticityCommonA nm,
549 SPAbstractDataWithGhostNodes map)
550 {
551 return std::make_shared<BCZeroStressMap>(
552 nm->getDisplacementData(),
553 nm->getBulkModulus() - nm->getShearModulus()/1.5,
554 nm->getShearModulus(),
555 map,
556 nm->vectorTemplate);
557 }
558
559 SPNumMethod generateBCZeroStressP(SPFDElasticityIncompressibleStatic nm,
560 SPAbstractDataWithGhostNodes map)
561 {
562 return generateBCConstantValueMiddlePoint(nm->getPressureData(),
563 0,
564 map,
565 nm->vectorTemplate);
566 }
567
568 SPNumMethod generateBCZeroStressP(SPFDElasticityRelaxation nm,
569 SPAbstractDataWithGhostNodes map)
570 {
571 return generateBCConstantValueMiddlePoint(nm->getPressureData(),
572 0,
573 map,
574 nm->vectorTemplate);
575 }
576
577
578 } // asl
579