Intrepid2
Intrepid2_FunctionSpaceToolsDef.hpp
Go to the documentation of this file.
1// @HEADER
2// *****************************************************************************
3// Intrepid2 Package
4//
5// Copyright 2007 NTESS and the Intrepid2 contributors.
6// SPDX-License-Identifier: BSD-3-Clause
7// *****************************************************************************
8// @HEADER
9
16#ifndef __INTREPID2_FUNCTIONSPACETOOLS_DEF_HPP__
17#define __INTREPID2_FUNCTIONSPACETOOLS_DEF_HPP__
18
19#include "Intrepid2_FunctorIterator.hpp"
20#include "Intrepid2_TensorArgumentIterator.hpp"
21
22#include "Teuchos_TimeMonitor.hpp"
23
24namespace Intrepid2 {
25 // ------------------------------------------------------------------------------------
26 template<typename DeviceType>
27 template<typename outputValueType, class ...outputProperties,
28 typename inputValueType, class ...inputProperties>
29 void
30 FunctionSpaceTools<DeviceType>::
31 HGRADtransformVALUE( Kokkos::DynRankView<outputValueType,outputProperties...> output,
32 const Kokkos::DynRankView<inputValueType, inputProperties...> input ) {
33 if(output.rank() == input.rank()) {
34#ifdef HAVE_INTREPID2_DEBUG
35 {
36 for (size_type i=0;i< input.rank();++i) {
37 INTREPID2_TEST_FOR_EXCEPTION( (input.extent(i) != output.extent(i)), std::invalid_argument,
38 ">>> ERROR (FunctionSpaceTools::HGRADtransformVALUE): Dimensions of input and output fields containers do not match.");
39 }
40 }
41#endif
42 RealSpaceTools<DeviceType>::clone(output, input);
43 }
44 else
45 ArrayTools<DeviceType>::cloneFields(output, input);
46 }
47
48 template<typename DeviceType>
49 template<typename outputValueType, class ...outputProperties,
50 typename inputValueType, class ...inputProperties>
51 void
52 FunctionSpaceTools<DeviceType>::
53 mapHGradDataFromPhysToRef( Kokkos::DynRankView<outputValueType,outputProperties...> output,
54 const Kokkos::DynRankView<inputValueType, inputProperties...> input ) {
55 if(output.rank() == input.rank()) {
56#ifdef HAVE_INTREPID2_DEBUG
57 {
58 for (size_type i=0;i< input.rank();++i) {
59 INTREPID2_TEST_FOR_EXCEPTION( (input.extent(i) != output.extent(i)), std::invalid_argument,
60 ">>> ERROR (FunctionSpaceTools::mapHGradDataFromPhysToRef): Dimensions of input and output fields containers do not match.");
61 }
62 }
63#endif
64 RealSpaceTools<DeviceType>::clone(output, input);
65 }
66 else
67 ArrayTools<DeviceType>::cloneFields(output, input);
68 }
69
70 template<typename DeviceType>
71 template<typename outputValueType, class ...outputProperties,
72 typename inputValueType, class ...inputProperties>
73 void
74 FunctionSpaceTools<DeviceType>::
75 mapHGradDataFromPhysSideToRefSide( Kokkos::DynRankView<outputValueType,outputProperties...> output,
76 const Kokkos::DynRankView<inputValueType, inputProperties...> input ) {
77 if(output.rank() == input.rank()) {
78#ifdef HAVE_INTREPID2_DEBUG
79 {
80 for (size_type i=0;i< input.rank();++i) {
81 INTREPID2_TEST_FOR_EXCEPTION( (input.extent(i) != output.extent(i)), std::invalid_argument,
82 ">>> ERROR (FunctionSpaceTools::mapHGradDataSideFromPhysToRefSide): Dimensions of input and output fields containers do not match.");
83 }
84 }
85#endif
86 RealSpaceTools<DeviceType>::clone(output, input);
87 }
88 else
89 ArrayTools<DeviceType>::cloneFields(output, input);
90 }
91
92 // ------------------------------------------------------------------------------------
93
94 namespace FunctorFunctionSpaceTools {
98 }
99
100 template<typename DeviceType>
101 template<typename OutputValViewType,
102 typename JacobianInverseViewType,
103 typename InputValViewType>
104 void
105 FunctionSpaceTools<DeviceType>::
106 HGRADtransformGRAD( OutputValViewType outputVals,
107 const JacobianInverseViewType jacobianInverse,
108 const InputValViewType inputVals ) {
109 return HCURLtransformVALUE(outputVals, jacobianInverse, inputVals);
110 }
111
112 // ------------------------------------------------------------------------------------
113
114 template<typename DeviceType>
115 template<typename outputValValueType, class ...outputValProperties,
116 typename jacobianInverseValueType, class ...jacobianInverseProperties,
117 typename inputValValueType, class ...inputValProperties>
118 void
119 FunctionSpaceTools<DeviceType>::
120 HCURLtransformVALUE( Kokkos::DynRankView<outputValValueType, outputValProperties...> outputVals,
121 const Kokkos::DynRankView<jacobianInverseValueType,jacobianInverseProperties...> jacobianInverse,
122 const Kokkos::DynRankView<inputValValueType, inputValProperties...> inputVals ) {
123 ArrayTools<DeviceType>::matvecProductDataField(outputVals, jacobianInverse, inputVals, 'T');
124 }
125
126 template<typename DeviceType>
127 template<typename outputValValueType, class ...outputValProperties,
128 typename jacobianValueType, class ...jacobianProperties,
129 typename inputValValueType, class ...inputValProperties>
130 void
131 FunctionSpaceTools<DeviceType>::
132 mapHCurlDataFromPhysToRef( Kokkos::DynRankView<outputValValueType, outputValProperties...> outputVals,
133 const Kokkos::DynRankView<jacobianValueType, jacobianProperties...> jacobian,
134 const Kokkos::DynRankView<inputValValueType, inputValProperties...> inputVals ) {
135 ArrayTools<DeviceType>::matvecProductDataData(outputVals, jacobian, inputVals, 'T');
136 }
137
138
139 namespace FunctorFunctionSpaceTools {
140
141 template<typename outViewType,
142 typename inputViewType,
143 typename metricViewType
144 >
145 struct F_negativeWeighted2dInputCrossK {
146 outViewType output_;
147 const inputViewType input_;
148 const metricViewType metricTensorDet_;
149
150 KOKKOS_INLINE_FUNCTION
151 F_negativeWeighted2dInputCrossK( outViewType output,
152 const inputViewType input,
153 const metricViewType metricTensorDet)
154 : output_(output), input_(input), metricTensorDet_(metricTensorDet){};
155
156 KOKKOS_INLINE_FUNCTION
157 void operator()(const size_type ic) const {
158 for (size_t pt=0; pt < input_.extent(1); pt++) {
159 auto measure = std::sqrt(metricTensorDet_(ic,pt));
160 output_(ic,pt,0) = - measure*input_(ic,pt,1);
161 output_(ic,pt,1) = measure*input_(ic,pt,0);
162 }
163 }
164 };
165 }
166
167 template<typename DeviceType>
168 template<typename outputValValueType, class ...outputValProperties,
169 typename tangentsValueType, class ...tangentsProperties,
170 typename metricTensorInvValueType, class ...metricTensorInvProperties,
171 typename metricTensorDetValueType, class ...metricTensorDetProperties,
172 typename inputValValueType, class ...inputValProperties>
173 void
174 FunctionSpaceTools<DeviceType>::
175 mapHCurlDataCrossNormalFromPhysSideToRefSide( Kokkos::DynRankView<outputValValueType, outputValProperties...> outputVals,
176 const Kokkos::DynRankView<tangentsValueType, tangentsProperties...> tangents,
177 const Kokkos::DynRankView<metricTensorInvValueType,metricTensorInvProperties...> metricTensorInv,
178 const Kokkos::DynRankView<metricTensorDetValueType,metricTensorDetProperties...> metricTensorDet,
179 const Kokkos::DynRankView<inputValValueType, inputValProperties...> inputVals ) {
180 auto work = Kokkos::DynRankView<outputValValueType, outputValProperties...>("work", outputVals.extent(0), outputVals.extent(1),outputVals.extent(2));
181 ArrayTools<DeviceType>::matvecProductDataData(outputVals, tangents, inputVals, 'T');
182 typename DeviceType::execution_space().fence();
183 ArrayTools<DeviceType>::matvecProductDataData(work, metricTensorInv, outputVals);
184 typename DeviceType::execution_space().fence();
185 using FunctorType = FunctorFunctionSpaceTools::F_negativeWeighted2dInputCrossK<decltype(outputVals),decltype(work),decltype(metricTensorDet)>;
186 Kokkos::parallel_for(Kokkos::RangePolicy<ExecSpaceType>(0,outputVals.extent(0)), FunctorType(outputVals, work, metricTensorDet) );
187 }
188
189
190 namespace FunctorFunctionSpaceTools {
191
192 template<typename outViewType,
193 typename inputViewType,
194 typename metricViewType
195 >
196 struct F_weighedInput {
197 outViewType output_;
198 const inputViewType input_;
199 const metricViewType metricTensorDet_;
200 const double scaling_;
201
202 KOKKOS_INLINE_FUNCTION
203 F_weighedInput( outViewType output,
204 const inputViewType input,
205 const metricViewType metricTensorDet,
206 const double scaling)
207 : output_(output), input_(input), metricTensorDet_(metricTensorDet), scaling_(scaling){};
208
209 KOKKOS_INLINE_FUNCTION
210 void operator()(const size_type ic) const {
211 for (size_t pt=0; pt < input_.extent(1); pt++) {
212 auto measure = std::sqrt(metricTensorDet_(ic,pt));
213 output_.access(ic,pt) = scaling_ * measure * input_.access(ic,pt);
214 }
215 }
216 };
217 }
218
219 template<typename DeviceType>
220 template<typename outputValValueType, class ...outputValProperties,
221 typename jacobianDetValueType, class ...jacobianDetProperties,
222 typename inputValValueType, class ...inputValProperties>
223 void
224 FunctionSpaceTools<DeviceType>::
225 mapHCurlDataCrossNormalFromPhysSideToRefSide(
226 Kokkos::DynRankView<outputValValueType, outputValProperties...> outputVals,
227 const Kokkos::DynRankView<jacobianDetValueType,jacobianDetProperties...> metricTensorDet,
228 const Kokkos::DynRankView<inputValValueType, inputValProperties...> inputVals ) {
229 using FunctorType = FunctorFunctionSpaceTools::F_weighedInput<decltype(outputVals),decltype(inputVals),decltype(metricTensorDet)>;
230 Kokkos::parallel_for(Kokkos::RangePolicy<ExecSpaceType>(0,outputVals.extent(0)), FunctorType(outputVals, inputVals, metricTensorDet, -1.0) );
231 }
232
233 // ------------------------------------------------------------------------------------
234
235 template<typename DeviceType>
236 template<typename outputValValueType, class ...outputValProperties,
237 typename jacobianValueType, class ...jacobianProperties,
238 typename jacobianDetValueType, class ...jacobianDetProperties,
239 typename inputValValueType, class ...inputValProperties>
240 void
241 FunctionSpaceTools<DeviceType>::
242 HCURLtransformCURL( Kokkos::DynRankView<outputValValueType, outputValProperties...> outputVals,
243 const Kokkos::DynRankView<jacobianValueType, jacobianProperties...> jacobian,
244 const Kokkos::DynRankView<jacobianDetValueType,jacobianDetProperties...> jacobianDet,
245 const Kokkos::DynRankView<inputValValueType, inputValProperties...> inputVals ) {
246 if(jacobian.data()==NULL || jacobian.extent(2)==2) //2D case
247 return HVOLtransformVALUE(outputVals, jacobianDet, inputVals);
248 else
249 return HDIVtransformVALUE(outputVals, jacobian, jacobianDet, inputVals);
250 }
251
252 // ------------------------------------------------------------------------------------
253
254 template<typename DeviceType>
255 template<typename outputValValueType, class ...outputValProperties,
256 typename jacobianDetValueType, class ...jacobianDetProperties,
257 typename inputValValueType, class ...inputValProperties>
258 void
259 FunctionSpaceTools<DeviceType>::
260 HCURLtransformCURL( Kokkos::DynRankView<outputValValueType, outputValProperties...> outputVals,
261 const Kokkos::DynRankView<jacobianDetValueType,jacobianDetProperties...> jacobianDet,
262 const Kokkos::DynRankView<inputValValueType, inputValProperties...> inputVals ) {
263#ifdef HAVE_INTREPID2_DEBUG
264 {
265 INTREPID2_TEST_FOR_EXCEPTION( outputVals.rank() == 4, std::invalid_argument,
266 ">>> ERROR (FunctionSpaceTools::HCURLtransformCURL): Output rank must have rank 3.\n If these are 3D fields, then use the appropriate overload of this function.");
267 }
268#endif
269 return HVOLtransformVALUE(outputVals, jacobianDet, inputVals);
270 }
271
272 // ------------------------------------------------------------------------------------
273
274 template<typename DeviceType>
275 template<typename outputValValueType, class ...outputValProperties,
276 typename jacobianValueType, class ...jacobianProperties,
277 typename jacobianDetValueType, class ...jacobianDetProperties,
278 typename inputValValueType, class ...inputValProperties>
279 void
280 FunctionSpaceTools<DeviceType>::
281 HGRADtransformCURL( Kokkos::DynRankView<outputValValueType, outputValProperties...> outputVals,
282 const Kokkos::DynRankView<jacobianValueType, jacobianProperties...> jacobian,
283 const Kokkos::DynRankView<jacobianDetValueType,jacobianDetProperties...> jacobianDet,
284 const Kokkos::DynRankView<inputValValueType, inputValProperties...> inputVals ) {
285#ifdef HAVE_INTREPID2_DEBUG
286 {
287 INTREPID2_TEST_FOR_EXCEPTION( outputVals.extent(3)!=2, std::invalid_argument,
288 ">>> ERROR (FunctionSpaceTools::HGRADtransformCURL):\n output field is 3D by the function is meant for 2D fields");
289 }
290#endif
291 return HDIVtransformVALUE(outputVals, jacobian, jacobianDet, inputVals);
292 }
293
294 // ------------------------------------------------------------------------------------
295
296 template<typename DeviceType>
297 template<typename outputValValueType, class ...outputValProperties,
298 typename jacobianValueType, class ...jacobianProperties,
299 typename jacobianDetValueType, class ...jacobianDetProperties,
300 typename inputValValueType, class ...inputValProperties>
301 void
302 FunctionSpaceTools<DeviceType>::
303 HDIVtransformVALUE( Kokkos::DynRankView<outputValValueType, outputValProperties...> outputVals,
304 const Kokkos::DynRankView<jacobianValueType, jacobianProperties...> jacobian,
305 const Kokkos::DynRankView<jacobianDetValueType,jacobianDetProperties...> jacobianDet,
306 const Kokkos::DynRankView<inputValValueType, inputValProperties...> inputVals ) {
307 ArrayTools<DeviceType>::matvecProductDataField(outputVals, jacobian, inputVals, 'N');
308 ArrayTools<DeviceType>::scalarMultiplyDataField(outputVals, jacobianDet, outputVals, true);
309 }
310
311 template<typename DeviceType>
312 template<typename outputValValueType, class ...outputValProperties,
313 typename jacobianInverseValueType, class ...jacobianInverseProperties,
314 typename jacobianDetValueType, class ...jacobianDetProperties,
315 typename inputValValueType, class ...inputValProperties>
316 void
317 FunctionSpaceTools<DeviceType>::
318 mapHDivDataFromPhysToRef( Kokkos::DynRankView<outputValValueType, outputValProperties...> outputVals,
319 const Kokkos::DynRankView<jacobianInverseValueType, jacobianInverseProperties...> jacobianInv,
320 const Kokkos::DynRankView<jacobianDetValueType,jacobianDetProperties...> jacobianDet,
321 const Kokkos::DynRankView<inputValValueType, inputValProperties...> inputVals ) {
322 ArrayTools<DeviceType>::matvecProductDataData(outputVals, jacobianInv, inputVals, 'N');
323 typename DeviceType::execution_space().fence();
324 ArrayTools<DeviceType>::scalarMultiplyDataData(outputVals, jacobianDet, outputVals, false);
325 }
326
327
328
329 template<typename DeviceType>
330 template<typename outputValValueType, class ...outputValProperties,
331 typename jacobianDetValueType, class ...jacobianDetProperties,
332 typename inputValValueType, class ...inputValProperties>
333 void
334 FunctionSpaceTools<DeviceType>::
335 mapHDivDataDotNormalFromPhysSideToRefSide(
336 Kokkos::DynRankView<outputValValueType, outputValProperties...> outputVals,
337 const Kokkos::DynRankView<jacobianDetValueType,jacobianDetProperties...> metricTensorDet,
338 const Kokkos::DynRankView<inputValValueType, inputValProperties...> inputVals ) {
339 using FunctorType = FunctorFunctionSpaceTools::F_weighedInput<decltype(outputVals),decltype(inputVals),decltype(metricTensorDet)>;
340 Kokkos::parallel_for(Kokkos::RangePolicy<ExecSpaceType>(0,outputVals.extent(0)), FunctorType(outputVals, inputVals, metricTensorDet, 1.0) );
341 }
342
343 // ------------------------------------------------------------------------------------
344
345 template<typename DeviceType>
346 template<typename outputValValueType, class ...outputValProperties,
347 typename jacobianDetValueType, class ...jacobianDetProperties,
348 typename inputValValueType, class ...inputValProperties>
349 void
350 FunctionSpaceTools<DeviceType>::
351 HDIVtransformDIV( Kokkos::DynRankView<outputValValueType, outputValProperties...> outputVals,
352 const Kokkos::DynRankView<jacobianDetValueType,jacobianDetProperties...> jacobianDet,
353 const Kokkos::DynRankView<inputValValueType, inputValProperties...> inputVals ) {
354 return HVOLtransformVALUE(outputVals, jacobianDet, inputVals);
355 }
356
357 // ------------------------------------------------------------------------------------
358
359 template<typename DeviceType>
360 template<typename outputValValueType, class ...outputValProperties,
361 typename jacobianDetValueType, class ...jacobianDetProperties,
362 typename inputValValueType, class ...inputValProperties>
363 void
364 FunctionSpaceTools<DeviceType>::
365 HVOLtransformVALUE( Kokkos::DynRankView<outputValValueType, outputValProperties...> outputVals,
366 const Kokkos::DynRankView<jacobianDetValueType,jacobianDetProperties...> jacobianDet,
367 const Kokkos::DynRankView<inputValValueType, inputValProperties...> inputVals ) {
368 ArrayTools<DeviceType>::scalarMultiplyDataField(outputVals, jacobianDet, inputVals, true);
369 }
370
371 template<typename DeviceType>
372 template<typename outputValValueType, class ...outputValProperties,
373 typename jacobianDetValueType, class ...jacobianDetProperties,
374 typename inputValValueType, class ...inputValProperties>
375 void
376 FunctionSpaceTools<DeviceType>::
377 mapHVolDataFromPhysToRef( Kokkos::DynRankView<outputValValueType, outputValProperties...> outputVals,
378 const Kokkos::DynRankView<jacobianDetValueType,jacobianDetProperties...> jacobianDet,
379 const Kokkos::DynRankView<inputValValueType, inputValProperties...> inputVals ) {
380 ArrayTools<DeviceType>::scalarMultiplyDataData(outputVals, jacobianDet, inputVals, false);
381 }
382
383
384
385 // ------------------------------------------------------------------------------------
386
387 template<typename DeviceType>
388 template<typename outputValueValueType, class ...outputValueProperties,
389 typename leftValueValueType, class ...leftValueProperties,
390 typename rightValueValueType, class ...rightValueProperties>
391 void
392 FunctionSpaceTools<DeviceType>::
393 integrate( Kokkos::DynRankView<outputValueValueType,outputValueProperties...> outputValues,
394 const Kokkos::DynRankView<leftValueValueType, leftValueProperties...> leftValues,
395 const Kokkos::DynRankView<rightValueValueType, rightValueProperties...> rightValues,
396 const bool sumInto ) {
397
398#ifdef HAVE_INTREPID2_DEBUG
399 {
400 INTREPID2_TEST_FOR_EXCEPTION( leftValues.rank() < 2 ||
401 leftValues.rank() > 4, std::invalid_argument,
402 ">>> ERROR (FunctionSpaceTools::integrate): Left data must have rank 2, 3 or 4.");
403 INTREPID2_TEST_FOR_EXCEPTION( outputValues.rank() < 1 ||
404 outputValues.rank() > 3, std::invalid_argument,
405 ">>> ERROR (FunctionSpaceTools::integrate): Output values must have rank 1, 2 or 3.");
406 }
407#endif
408
409 const ordinal_type outRank = outputValues.rank();
410 const ordinal_type leftRank = leftValues.rank();
411 const ordinal_type mode = outRank*10 + leftRank;
412
413 switch (mode) {
414 // DataData
415 case 12:
416 ArrayTools<DeviceType>::contractDataDataScalar( outputValues,
417 leftValues,
418 rightValues,
419 sumInto );
420 break;
421 case 13:
422 ArrayTools<DeviceType>::contractDataDataVector( outputValues,
423 leftValues,
424 rightValues,
425 sumInto );
426 break;
427 case 14:
428 ArrayTools<DeviceType>::contractDataDataTensor( outputValues,
429 leftValues,
430 rightValues,
431 sumInto );
432 break;
433
434 // DataField
435 case 22:
436 ArrayTools<DeviceType>::contractDataFieldScalar( outputValues,
437 leftValues,
438 rightValues,
439 sumInto );
440 break;
441 case 23:
442 ArrayTools<DeviceType>::contractDataFieldVector( outputValues,
443 leftValues,
444 rightValues,
445 sumInto );
446 break;
447 case 24:
448 ArrayTools<DeviceType>::contractDataFieldTensor( outputValues,
449 leftValues,
450 rightValues,
451 sumInto );
452 break;
453
454 // FieldField
455 case 33:
456 ArrayTools<DeviceType>::contractFieldFieldScalar( outputValues,
457 leftValues,
458 rightValues,
459 sumInto );
460 break;
461 case 34:
462 ArrayTools<DeviceType>::contractFieldFieldVector( outputValues,
463 leftValues,
464 rightValues,
465 sumInto );
466 break;
467 case 35:
468 ArrayTools<DeviceType>::contractFieldFieldTensor( outputValues,
469 leftValues,
470 rightValues,
471 sumInto );
472 break;
473 default: {
474 INTREPID2_TEST_FOR_EXCEPTION( outRank < 1 || outRank > 3, std::runtime_error,
475 ">>> ERROR (FunctionSpaceTools::integrate): outRank must be 1,2, or 3.");
476 INTREPID2_TEST_FOR_EXCEPTION( leftRank < 2 || leftRank > 4, std::runtime_error,
477 ">>> ERROR (FunctionSpaceTools::integrate): leftRank must be 1,2, 3 or 4.");
478 }
479 }
480 }
481
482 // ------------------------------------------------------------------------------------
483 namespace FunctorFunctionSpaceTools {
487 template<typename outputValViewType,
488 typename inputDetViewType,
489 typename inputWeightViewType>
490 struct F_computeCellMeasure {
491 outputValViewType _outputVals;
492 const inputDetViewType _inputDet;
493 const inputWeightViewType _inputWeight;
494
495 KOKKOS_INLINE_FUNCTION
496 F_computeCellMeasure( outputValViewType outputVals_,
497 inputDetViewType inputDet_,
498 inputWeightViewType inputWeight_)
499 : _outputVals(outputVals_),
500 _inputDet(inputDet_),
501 _inputWeight(inputWeight_) {}
502
503 typedef ordinal_type value_type;
504
505// KOKKOS_INLINE_FUNCTION
506// void init( value_type &dst ) const {
507// dst = false;
508// }
509
510// KOKKOS_INLINE_FUNCTION
511// void join( volatile value_type &dst,
512// const volatile value_type &src ) const {
513// dst |= src;
514// }
515
516 KOKKOS_INLINE_FUNCTION
517 void operator()(const size_type cl, value_type &dst) const {
518 // negative jacobian check
519 const bool hasNegativeDet = (_inputDet(cl, 0) < 0.0);
520 dst |= hasNegativeDet;
521
522 // make it absolute
523 const auto sign = (hasNegativeDet ? -1.0 : 1.0);
524 const ordinal_type pt_end = _outputVals.extent(1);
525 for (ordinal_type pt=0;pt<pt_end;++pt)
526 _outputVals(cl, pt) = sign*_inputDet(cl, pt)*_inputWeight(pt);
527 }
528 };
529 }
530
531 template<typename DeviceType>
532 template<typename OutputValViewType,
533 typename InputDetViewType,
534 typename InputWeightViewType>
535 bool
536 FunctionSpaceTools<DeviceType>::
537 computeCellMeasure( OutputValViewType outputVals,
538 const InputDetViewType inputDet,
539 const InputWeightViewType inputWeights ) {
540#ifdef HAVE_INTREPID2_DEBUG
541 {
542 INTREPID2_TEST_FOR_EXCEPTION( rank(inputDet) != 2 ||
543 rank(inputWeights) != 1 ||
544 rank(outputVals) != 2, std::invalid_argument,
545 ">>> ERROR (FunctionSpaceTools::computeCellMeasure): Ranks are not compatible.");
546 INTREPID2_TEST_FOR_EXCEPTION( outputVals.extent(0) != inputDet.extent(0), std::invalid_argument,
547 ">>> ERROR (FunctionSpaceTools::computeCellMeasure): Cell dimension does not match.");
548 INTREPID2_TEST_FOR_EXCEPTION( inputDet.extent(1) != outputVals.extent(1) ||
549 inputWeights.extent(0) != outputVals.extent(1), std::invalid_argument,
550 ">>> ERROR (FunctionSpaceTools::computeCellMeasure): Point dimension does not match.");
551 }
552#endif
553 constexpr bool are_accessible =
554 Kokkos::Impl::MemorySpaceAccess<MemSpaceType,
555 typename decltype(outputVals)::memory_space>::accessible &&
556 Kokkos::Impl::MemorySpaceAccess<MemSpaceType,
557 typename decltype(inputDet)::memory_space>::accessible &&
558 Kokkos::Impl::MemorySpaceAccess<MemSpaceType,
559 typename decltype(inputWeights)::memory_space>::accessible;
560 static_assert(are_accessible, "FunctionSpaceTools<DeviceType>::computeCellMeasure(..): input/output views' memory spaces are not compatible with DeviceType");
561
562 using FunctorType = FunctorFunctionSpaceTools::F_computeCellMeasure
563 <decltype(outputVals),decltype(inputDet),decltype(inputWeights)>;
564
565 const ordinal_type C = inputDet.extent(0);
566 Kokkos::RangePolicy<ExecSpaceType,Kokkos::Schedule<Kokkos::Static> > policy(0, C);
567
568 typename FunctorType::value_type hasNegativeDet = false;
569 Kokkos::parallel_reduce( policy, FunctorType(outputVals, inputDet, inputWeights), hasNegativeDet );
570
571 return hasNegativeDet;
572 }
573
574 // ------------------------------------------------------------------------------------
575
576 template<typename DeviceType>
577 template<typename outputValValueType, class ...outputValProperties,
578 typename inputJacValueType, class ...inputJacProperties,
579 typename inputWeightValueType, class ...inputWeightProperties,
580 typename scratchValueType, class ...scratchProperties>
581 void
582 FunctionSpaceTools<DeviceType>::
583 computeFaceMeasure( Kokkos::DynRankView<outputValValueType, outputValProperties...> outputVals,
584 const Kokkos::DynRankView<inputJacValueType, inputJacProperties...> inputJac,
585 const Kokkos::DynRankView<inputWeightValueType,inputWeightProperties...> inputWeights,
586 const ordinal_type whichFace,
587 const shards::CellTopology parentCell,
588 const Kokkos::DynRankView<scratchValueType, scratchProperties...> scratch ) {
589#ifdef HAVE_INTREPID2_DEBUG
590 INTREPID2_TEST_FOR_EXCEPTION( inputJac.rank() != 4, std::invalid_argument,
591 ">>> ERROR (FunctionSpaceTools::computeFaceMeasure): Input Jacobian container must have rank 4.");
592 INTREPID2_TEST_FOR_EXCEPTION( scratch.rank() != 1, std::invalid_argument,
593 ">>> ERROR (FunctionSpaceTools::computeFaceMeasure): Scratch view imust have rank 1.");
594 INTREPID2_TEST_FOR_EXCEPTION( scratch.size() < inputJac.size(), std::invalid_argument,
595 ">>> ERROR (FunctionSpaceTools::computeFaceMeasure): Scratch storage must be greater than or equal to inputJac's one.");
596#endif
597
598 // face normals (reshape scratch)
599 auto faceNormals = Impl::createMatchingUnmanagedDynRankView(inputJac, scratch.data(), inputJac.extent(0), inputJac.extent(1), inputJac.extent(2));
600
601 // compute normals
602 CellTools<DeviceType>::getPhysicalFaceNormals(faceNormals, inputJac, whichFace, parentCell);
603
604 // compute lenghts of normals
605 RealSpaceTools<DeviceType>::vectorNorm(outputVals, faceNormals, NORM_TWO);
606
607 // multiply with weights
608 ArrayTools<DeviceType>::scalarMultiplyDataData(outputVals, outputVals, inputWeights);
609 }
610
611 // ------------------------------------------------------------------------------------
612
613 template<typename DeviceType>
614 template<typename outputValValueType, class ...outputValProperties,
615 typename inputJacValueType, class ...inputJacProperties,
616 typename inputWeightValueType, class ...inputWeightProperties,
617 typename scratchValueType, class ...scratchProperties>
618 void
619 FunctionSpaceTools<DeviceType>::
620 computeEdgeMeasure( Kokkos::DynRankView<outputValValueType, outputValProperties...> outputVals,
621 const Kokkos::DynRankView<inputJacValueType, inputJacProperties...> inputJac,
622 const Kokkos::DynRankView<inputWeightValueType,inputWeightProperties...> inputWeights,
623 const ordinal_type whichEdge,
624 const shards::CellTopology parentCell,
625 const Kokkos::DynRankView<scratchValueType, scratchProperties...> scratch ) {
626#ifdef HAVE_INTREPID2_DEBUG
627 INTREPID2_TEST_FOR_EXCEPTION( (inputJac.rank() != 4), std::invalid_argument,
628 ">>> ERROR (FunctionSpaceTools::computeEdgeMeasure): Input Jacobian container must have rank 4.");
629 INTREPID2_TEST_FOR_EXCEPTION( scratch.rank() != 1, std::invalid_argument,
630 ">>> ERROR (FunctionSpaceTools::computeEdgeMeasure): Scratch view must have a rank 1.");
631 INTREPID2_TEST_FOR_EXCEPTION( scratch.size() < inputJac.size(), std::invalid_argument,
632 ">>> ERROR (FunctionSpaceTools::computeEdgeMeasure): Scratch storage must be greater than or equal to inputJac'one.");
633#endif
634
635 // edge tangents (reshape scratch)
636 auto edgeTangents = Impl::createMatchingUnmanagedDynRankView(inputJac, scratch.data(), inputJac.extent(0), inputJac.extent(1), inputJac.extent(2));
637
638 // compute normals
639 CellTools<DeviceType>::getPhysicalEdgeTangents(edgeTangents, inputJac, whichEdge, parentCell);
640
641 // compute lenghts of tangents
642 RealSpaceTools<DeviceType>::vectorNorm(outputVals, edgeTangents, NORM_TWO);
643
644 // multiply with weights
645 ArrayTools<DeviceType>::scalarMultiplyDataData(outputVals, outputVals, inputWeights);
646 }
647
648 // ------------------------------------------------------------------------------------
649
650 template<typename DeviceType>
651 template<typename outputValValueType, class ...outputValProperties,
652 typename inputMeasureValueType, class ...inputMeasureProperties,
653 typename inputValValueType, class ...inputValProperties>
654 void
655 FunctionSpaceTools<DeviceType>::
656 multiplyMeasure( Kokkos::DynRankView<outputValValueType, outputValProperties...> outputVals,
657 const Kokkos::DynRankView<inputMeasureValueType,inputMeasureProperties...> inputMeasure,
658 const Kokkos::DynRankView<inputValValueType, inputValProperties...> inputVals ) {
659 ArrayTools<DeviceType>::scalarMultiplyDataField( outputVals,
660 inputMeasure,
661 inputVals,
662 false );
663 }
664
665 // ------------------------------------------------------------------------------------
666
667 template<typename DeviceType>
668 template<typename outputFieldValueType, class ...outputFieldProperties,
669 typename inputDataValueType, class ...inputDataProperties,
670 typename inputFieldValueType, class ...inputFieldProperties>
671 void
672 FunctionSpaceTools<DeviceType>::
673 scalarMultiplyDataField( Kokkos::DynRankView<outputFieldValueType,outputFieldProperties...> outputFields,
674 const Kokkos::DynRankView<inputDataValueType, inputDataProperties...> inputData,
675 const Kokkos::DynRankView<inputFieldValueType, inputFieldProperties...> inputFields,
676 const bool reciprocal ) {
677 ArrayTools<DeviceType>::scalarMultiplyDataField( outputFields,
678 inputData,
679 inputFields,
680 reciprocal );
681 }
682
683 // ------------------------------------------------------------------------------------
684
685 template<typename DeviceType>
686 template<typename outputDataValuetype, class ...outputDataProperties,
687 typename inputDataLeftValueType, class ...inputDataLeftProperties,
688 typename inputDataRightValueType, class ...inputDataRightProperties>
689 void
690 FunctionSpaceTools<DeviceType>::
691 scalarMultiplyDataData( Kokkos::DynRankView<outputDataValuetype, outputDataProperties...> outputData,
692 const Kokkos::DynRankView<inputDataLeftValueType, inputDataLeftProperties...> inputDataLeft,
693 const Kokkos::DynRankView<inputDataRightValueType,inputDataRightProperties...> inputDataRight,
694 const bool reciprocal ) {
695 ArrayTools<DeviceType>::scalarMultiplyDataData( outputData,
696 inputDataLeft,
697 inputDataRight,
698 reciprocal );
699 }
700
701 // ------------------------------------------------------------------------------------
702
703 template<typename DeviceType>
704 template<typename outputFieldValueType, class ...outputFieldProperties,
705 typename inputDataValueType, class ...inputDataProperties,
706 typename inputFieldValueType, class ...inputFieldProperties>
707 void
708 FunctionSpaceTools<DeviceType>::
709 dotMultiplyDataField( Kokkos::DynRankView<outputFieldValueType,outputFieldProperties...> outputFields,
710 const Kokkos::DynRankView<inputDataValueType, inputDataProperties...> inputData,
711 const Kokkos::DynRankView<inputFieldValueType, inputFieldProperties...> inputFields ) {
712 ArrayTools<DeviceType>::dotMultiplyDataField( outputFields,
713 inputData,
714 inputFields );
715 }
716
717 // ------------------------------------------------------------------------------------
718
719 template<typename DeviceType>
720 template<typename outputDataValueType, class ...outputDataProperties,
721 typename inputDataLeftValueType, class ...inputDataLeftProperties,
722 typename inputDataRightValueType, class ...inputDataRightProperties>
723 void
724 FunctionSpaceTools<DeviceType>::
725 dotMultiplyDataData( Kokkos::DynRankView<outputDataValueType, outputDataProperties...> outputData,
726 const Kokkos::DynRankView<inputDataLeftValueType, inputDataLeftProperties...> inputDataLeft,
727 const Kokkos::DynRankView<inputDataRightValueType,inputDataRightProperties...> inputDataRight ) {
728 ArrayTools<DeviceType>::dotMultiplyDataData( outputData,
729 inputDataLeft,
730 inputDataRight );
731 }
732
733 // ------------------------------------------------------------------------------------
734
735 template<typename DeviceType>
736 template<typename outputFieldValueType, class ...outputFieldProperties,
737 typename inputDataValueType, class ...inputDataProperties,
738 typename inputFieldValueType, class ...inputFieldProperties>
739 void
740 FunctionSpaceTools<DeviceType>::
741 vectorMultiplyDataField( Kokkos::DynRankView<outputFieldValueType,outputFieldProperties...> outputFields,
742 const Kokkos::DynRankView<inputDataValueType, inputDataProperties...> inputData,
743 const Kokkos::DynRankView<inputFieldValueType, inputFieldProperties...> inputFields ) {
744 const auto outRank = outputFields.rank();
745 switch (outRank) {
746 case 3:
747 case 4:
748 ArrayTools<DeviceType>::crossProductDataField( outputFields,
749 inputData,
750 inputFields );
751 break;
752 case 5:
753 ArrayTools<DeviceType>::outerProductDataField( outputFields,
754 inputData,
755 inputFields );
756 break;
757 default: {
758 INTREPID2_TEST_FOR_EXCEPTION( outRank < 3 && outRank > 5, std::runtime_error,
759 ">>> ERROR (FunctionSpaceTools::vectorMultiplyDataField): Output container must have rank 3, 4 or 5.");
760 }
761 }
762 }
763
764 // ------------------------------------------------------------------------------------
765
766 template<typename DeviceType>
767 template<typename outputDataValueType, class ...outputDataProperties,
768 typename inputDataLeftValueType, class ...inputDataLeftProperties,
769 typename inputDataRightValueType, class ...inputDataRightProperties>
770 void
771 FunctionSpaceTools<DeviceType>::
772 vectorMultiplyDataData( Kokkos::DynRankView<outputDataValueType, outputDataProperties...> outputData,
773 const Kokkos::DynRankView<inputDataLeftValueType, inputDataLeftProperties...> inputDataLeft,
774 const Kokkos::DynRankView<inputDataRightValueType,inputDataRightProperties...> inputDataRight ) {
775 const auto outRank = outputData.rank();
776 switch (outRank) {
777 case 2:
778 case 3:
779 ArrayTools<DeviceType>::crossProductDataData( outputData,
780 inputDataLeft,
781 inputDataRight );
782 break;
783 case 4:
784 ArrayTools<DeviceType>::outerProductDataData( outputData,
785 inputDataLeft,
786 inputDataRight );
787 break;
788 default: {
789 INTREPID2_TEST_FOR_EXCEPTION( outRank < 2 && outRank > 4, std::runtime_error,
790 ">>> ERROR (FunctionSpaceTools::vectorMultiplyDataData): Output container must have rank 2, 3 or 4.");
791 }
792 }
793 }
794
795 // ------------------------------------------------------------------------------------
796
797 template<typename DeviceType>
798 template<typename outputFieldValueType, class ...outputFieldProperties,
799 typename inputDataValueType, class ...inputDataProperties,
800 typename inputFieldValueType, class ...inputFieldProperties>
801 void
802 FunctionSpaceTools<DeviceType>::
803 tensorMultiplyDataField( Kokkos::DynRankView<outputFieldValueType,outputFieldProperties...> outputFields,
804 const Kokkos::DynRankView<inputDataValueType, inputDataProperties...> inputData,
805 const Kokkos::DynRankView<inputFieldValueType, inputFieldProperties...> inputFields,
806 const char transpose ) {
807
808 const auto outRank = outputFields.rank();
809 switch (outRank) {
810 case 4:
811 ArrayTools<DeviceType>::matvecProductDataField( outputFields,
812 inputData,
813 inputFields,
814 transpose );
815 break;
816 case 5:
817 ArrayTools<DeviceType>::matmatProductDataField( outputFields,
818 inputData,
819 inputFields,
820 transpose );
821 break;
822 default: {
823 INTREPID2_TEST_FOR_EXCEPTION( outRank < 4 && outRank > 5, std::runtime_error,
824 ">>> ERROR (FunctionSpaceTools::tensorMultiplyDataField): Output container must have rank 4 or 5.");
825 }
826 }
827 }
828
829 // ------------------------------------------------------------------------------------
830
831 template<typename DeviceType>
832 template<typename outputDataValueType, class ...outputDataProperties,
833 typename inputDataLeftValueType, class ...inputDataLeftProperties,
834 typename inputDataRightValueType, class ...inputDataRightProperties>
835 void
836 FunctionSpaceTools<DeviceType>::
837 tensorMultiplyDataData( Kokkos::DynRankView<outputDataValueType, outputDataProperties...> outputData,
838 const Kokkos::DynRankView<inputDataLeftValueType, inputDataLeftProperties...> inputDataLeft,
839 const Kokkos::DynRankView<inputDataRightValueType,inputDataRightProperties...> inputDataRight,
840 const char transpose ) {
841 const auto outRank = outputData.rank();
842 switch (outRank) {
843 case 3:
844 ArrayTools<DeviceType>::matvecProductDataData( outputData,
845 inputDataLeft,
846 inputDataRight,
847 transpose );
848 break;
849 case 4:
850 ArrayTools<DeviceType>::matmatProductDataData( outputData,
851 inputDataLeft,
852 inputDataRight,
853 transpose );
854 break;
855 default: {
856 INTREPID2_TEST_FOR_EXCEPTION( outRank < 4 && outRank > 5, std::runtime_error,
857 ">>> ERROR (FunctionSpaceTools::tensorMultiplyDataField): Output container must have rank 4 or 5.");
858 }
859 }
860 }
861
862 // ------------------------------------------------------------------------------------
863
864 namespace FunctorFunctionSpaceTools {
865
869 template<typename inoutOperatorViewType,
870 typename fieldSignViewType>
871 struct F_applyLeftFieldSigns {
872 inoutOperatorViewType _inoutOperator;
873 const fieldSignViewType _fieldSigns;
874
875 KOKKOS_INLINE_FUNCTION
876 F_applyLeftFieldSigns( inoutOperatorViewType inoutOperator_,
877 fieldSignViewType fieldSigns_ )
878 : _inoutOperator(inoutOperator_), _fieldSigns(fieldSigns_) {}
879
880 KOKKOS_INLINE_FUNCTION
881 void operator()(const ordinal_type cl) const {
882 const ordinal_type nlbf = _inoutOperator.extent(1);
883 const ordinal_type nrbf = _inoutOperator.extent(2);
884
885 for (ordinal_type lbf=0;lbf<nlbf;++lbf)
886 for (ordinal_type rbf=0;rbf<nrbf;++rbf)
887 _inoutOperator(cl, lbf, rbf) *= _fieldSigns(cl, lbf);
888 }
889 };
890 }
891
892 template<typename DeviceType>
893 template<typename inoutOperatorValueType, class ...inoutOperatorProperties,
894 typename fieldSignValueType, class ...fieldSignProperties>
895 void
896 FunctionSpaceTools<DeviceType>::
897 applyLeftFieldSigns( Kokkos::DynRankView<inoutOperatorValueType,inoutOperatorProperties...> inoutOperator,
898 const Kokkos::DynRankView<fieldSignValueType, fieldSignProperties...> fieldSigns ) {
899
900#ifdef HAVE_INTREPID2_DEBUG
901 INTREPID2_TEST_FOR_EXCEPTION( inoutOperator.rank() != 3, std::invalid_argument,
902 ">>> ERROR (FunctionSpaceTools::applyLeftFieldSigns): Input operator container must have rank 3.");
903 INTREPID2_TEST_FOR_EXCEPTION( fieldSigns.rank() != 2, std::invalid_argument,
904 ">>> ERROR (FunctionSpaceTools::applyLeftFieldSigns): Input field signs container must have rank 2.");
905 INTREPID2_TEST_FOR_EXCEPTION( inoutOperator.extent(0) != fieldSigns.extent(0), std::invalid_argument,
906 ">>> ERROR (FunctionSpaceTools::applyLeftFieldSigns): Zeroth dimensions (number of cells) of the operator and field signs containers must agree!");
907 INTREPID2_TEST_FOR_EXCEPTION( inoutOperator.extent(1) != fieldSigns.extent(1), std::invalid_argument,
908 ">>> ERROR (FunctionSpaceTools::applyLeftFieldSigns): First dimensions (number of left fields) of the operator and field signs containers must agree!");
909#endif
910
911 constexpr bool are_accessible =
912 Kokkos::Impl::MemorySpaceAccess<MemSpaceType,
913 typename decltype(inoutOperator)::memory_space>::accessible &&
914 Kokkos::Impl::MemorySpaceAccess<MemSpaceType,
915 typename decltype(fieldSigns)::memory_space>::accessible;
916 static_assert(are_accessible, "FunctionSpaceTools<DeviceType>::applyLeftFieldSigns(..): input/output views' memory spaces are not compatible with DeviceType");
917
918 using FunctorType = FunctorFunctionSpaceTools::F_applyLeftFieldSigns
919 <decltype(inoutOperator),decltype(fieldSigns)>;
920
921 const ordinal_type C = inoutOperator.extent(0);
922 Kokkos::RangePolicy<ExecSpaceType,Kokkos::Schedule<Kokkos::Static> > policy(0, C);
923 Kokkos::parallel_for( policy, FunctorType(inoutOperator, fieldSigns) );
924 }
925
926 // ------------------------------------------------------------------------------------
927
928 namespace FunctorFunctionSpaceTools {
932 template<typename inoutOperatorViewType,
933 typename fieldSignViewType>
934 struct F_applyRightFieldSigns {
935 inoutOperatorViewType _inoutOperator;
936 const fieldSignViewType _fieldSigns;
937
938 KOKKOS_INLINE_FUNCTION
939 F_applyRightFieldSigns( inoutOperatorViewType inoutOperator_,
940 fieldSignViewType fieldSigns_ )
941 : _inoutOperator(inoutOperator_), _fieldSigns(fieldSigns_) {}
942
943 KOKKOS_INLINE_FUNCTION
944 void operator()(const ordinal_type cl) const {
945 const ordinal_type nlbf = _inoutOperator.extent(1);
946 const ordinal_type nrbf = _inoutOperator.extent(2);
947
948 for (ordinal_type lbf=0;lbf<nlbf;++lbf)
949 for (ordinal_type rbf=0;rbf<nrbf;++rbf)
950 _inoutOperator(cl, lbf, rbf) *= _fieldSigns(cl, rbf);
951 }
952 };
953 }
954
955 template<typename DeviceType>
956 template<typename inoutOperatorValueType, class ...inoutOperatorProperties,
957 typename fieldSignValueType, class ...fieldSignProperties>
958 void
959 FunctionSpaceTools<DeviceType>::
960 applyRightFieldSigns( Kokkos::DynRankView<inoutOperatorValueType,inoutOperatorProperties...> inoutOperator,
961 const Kokkos::DynRankView<fieldSignValueType, fieldSignProperties...> fieldSigns ) {
962
963#ifdef HAVE_INTREPID2_DEBUG
964 INTREPID2_TEST_FOR_EXCEPTION( inoutOperator.rank() != 3, std::invalid_argument,
965 ">>> ERROR (FunctionSpaceTools::applyRightFieldSigns): Input operator container must have rank 3.");
966 INTREPID2_TEST_FOR_EXCEPTION( fieldSigns.rank() != 2, std::invalid_argument,
967 ">>> ERROR (FunctionSpaceTools::applyRightFieldSigns): Input field signs container must have rank 2.");
968 INTREPID2_TEST_FOR_EXCEPTION( inoutOperator.extent(0) != fieldSigns.extent(0), std::invalid_argument,
969 ">>> ERROR (FunctionSpaceTools::applyRightFieldSigns): Zeroth dimensions (number of cells) of the operator and field signs containers must agree!");
970 INTREPID2_TEST_FOR_EXCEPTION( inoutOperator.extent(2) != fieldSigns.extent(1), std::invalid_argument,
971 ">>> ERROR (FunctionSpaceTools::applyRightFieldSigns): Second dimension of the operator container and first dimension of the field signs container (number of right fields) must agree!");
972#endif
973
974 constexpr bool are_accessible =
975 Kokkos::Impl::MemorySpaceAccess<MemSpaceType,
976 typename decltype(inoutOperator)::memory_space>::accessible &&
977 Kokkos::Impl::MemorySpaceAccess<MemSpaceType,
978 typename decltype(fieldSigns)::memory_space>::accessible;
979 static_assert(are_accessible, "FunctionSpaceTools<DeviceType>::applyRightFieldSigns(..): input/output views' memory spaces are not compatible with DeviceType");
980
981 using FunctorType = FunctorFunctionSpaceTools::F_applyRightFieldSigns
982 <decltype(inoutOperator),decltype(fieldSigns)>;
983
984 const ordinal_type C = inoutOperator.extent(0);
985 Kokkos::RangePolicy<ExecSpaceType,Kokkos::Schedule<Kokkos::Static> > policy(0, C);
986 Kokkos::parallel_for( policy, FunctorType(inoutOperator, fieldSigns) );
987 }
988
989 // ------------------------------------------------------------------------------------
990
991 namespace FunctorFunctionSpaceTools {
995 template<typename inoutFunctionViewType,
996 typename fieldSignViewType>
997 struct F_applyFieldSigns {
998 inoutFunctionViewType _inoutFunction;
999 const fieldSignViewType _fieldSigns;
1000
1001 KOKKOS_INLINE_FUNCTION
1002 F_applyFieldSigns( inoutFunctionViewType inoutFunction_,
1003 fieldSignViewType fieldSigns_)
1004 : _inoutFunction(inoutFunction_), _fieldSigns(fieldSigns_) {}
1005
1006 KOKKOS_INLINE_FUNCTION
1007 void operator()(const ordinal_type cl) const {
1008 const ordinal_type nbfs = _inoutFunction.extent(1);
1009 const ordinal_type npts = _inoutFunction.extent(2);
1010 const ordinal_type iend = _inoutFunction.extent(3);
1011 const ordinal_type jend = _inoutFunction.extent(4);
1012
1013 for (ordinal_type bf=0;bf<nbfs;++bf)
1014 for (ordinal_type pt=0;pt<npts;++pt)
1015 for (ordinal_type i=0;i<iend;++i)
1016 for (ordinal_type j=0;j<jend;++j)
1017 _inoutFunction(cl, bf, pt, i, j) *= _fieldSigns(cl, bf);
1018 }
1019 };
1020 }
1021
1022 template<typename DeviceType>
1023 template<typename inoutFunctionValueType, class ...inoutFunctionProperties,
1024 typename fieldSignValueType, class ...fieldSignProperties>
1025 void
1026 FunctionSpaceTools<DeviceType>::
1027 applyFieldSigns( Kokkos::DynRankView<inoutFunctionValueType,inoutFunctionProperties...> inoutFunction,
1028 const Kokkos::DynRankView<fieldSignValueType, fieldSignProperties...> fieldSigns ) {
1029
1030#ifdef HAVE_INTREPID2_DEBUG
1031 INTREPID2_TEST_FOR_EXCEPTION( inoutFunction.rank() < 2 || inoutFunction.rank() > 5, std::invalid_argument,
1032 ">>> ERROR (FunctionSpaceTools::applyFieldSigns): Input function container must have rank 2, 3, 4, or 5.");
1033 INTREPID2_TEST_FOR_EXCEPTION( fieldSigns.rank() != 2, std::invalid_argument,
1034 ">>> ERROR (FunctionSpaceTools::applyFieldSigns): Input field signs container must have rank 2.");
1035 INTREPID2_TEST_FOR_EXCEPTION( inoutFunction.extent(0) != fieldSigns.extent(0), std::invalid_argument,
1036 ">>> ERROR (FunctionSpaceTools::applyFieldSigns): Zeroth dimensions (number of integration domains) of the function and field signs containers must agree!");
1037 INTREPID2_TEST_FOR_EXCEPTION( inoutFunction.extent(1) != fieldSigns.extent(1), std::invalid_argument,
1038 ">>> ERROR (FunctionSpaceTools::applyFieldSigns): First dimensions (number of fields) of the function and field signs containers must agree!");
1039
1040#endif
1041
1042 constexpr bool are_accessible =
1043 Kokkos::Impl::MemorySpaceAccess<MemSpaceType,
1044 typename decltype(inoutFunction)::memory_space>::accessible &&
1045 Kokkos::Impl::MemorySpaceAccess<MemSpaceType,
1046 typename decltype(fieldSigns)::memory_space>::accessible;
1047 static_assert(are_accessible, "FunctionSpaceTools<DeviceType>::applyFieldSigns(..): input/output views' memory spaces are not compatible with DeviceType");
1048
1049 using FunctorType = FunctorFunctionSpaceTools::F_applyFieldSigns
1050 <decltype(inoutFunction),decltype(fieldSigns)>;
1051
1052 const ordinal_type C = inoutFunction.extent(0);
1053 Kokkos::RangePolicy<ExecSpaceType,Kokkos::Schedule<Kokkos::Static> > policy(0, C);
1054 Kokkos::parallel_for( policy, FunctorType(inoutFunction, fieldSigns) );
1055 }
1056
1057 // ------------------------------------------------------------------------------------
1058
1059 namespace FunctorFunctionSpaceTools {
1060
1064 template<typename outputPointViewType,
1065 typename inputCoeffViewType,
1066 typename inputFieldViewType>
1067 struct F_evaluateScalar {
1068 outputPointViewType _outputPointVals;
1069 const inputCoeffViewType _inputCoeffs;
1070 const inputFieldViewType _inputFields;
1071
1072 KOKKOS_INLINE_FUNCTION
1073 F_evaluateScalar( outputPointViewType outputPointVals_,
1074 inputCoeffViewType inputCoeffs_,
1075 inputFieldViewType inputFields_ )
1076 : _outputPointVals(outputPointVals_), _inputCoeffs(inputCoeffs_), _inputFields(inputFields_) {}
1077
1078 KOKKOS_INLINE_FUNCTION
1079 void operator()(const ordinal_type cl, const ordinal_type pt) const {
1080 const ordinal_type nbfs = _inputFields.extent(1);
1081
1082 for (ordinal_type bf=0;bf<nbfs;++bf)
1083 _outputPointVals(cl, pt) += _inputCoeffs(cl, bf) * _inputFields(cl, bf, pt);
1084 }
1085 };
1086
1087 template<typename outputPointViewType,
1088 typename inputCoeffViewType,
1089 typename inputFieldViewType>
1090 struct F_evaluateVector{
1091 outputPointViewType _outputPointVals;
1092 const inputCoeffViewType _inputCoeffs;
1093 const inputFieldViewType _inputFields;
1094
1095 KOKKOS_INLINE_FUNCTION
1096 F_evaluateVector( outputPointViewType outputPointVals_,
1097 inputCoeffViewType inputCoeffs_,
1098 inputFieldViewType inputFields_ )
1099 : _outputPointVals(outputPointVals_), _inputCoeffs(inputCoeffs_), _inputFields(inputFields_) {}
1100
1101 KOKKOS_INLINE_FUNCTION
1102 void operator()(const ordinal_type cl, const ordinal_type pt) const {
1103 const ordinal_type nbfs = _inputFields.extent(1);
1104 const ordinal_type iend = _inputFields.extent(3);
1105
1106 for (ordinal_type bf=0;bf<nbfs;++bf)
1107 for (ordinal_type i=0;i<iend;++i)
1108 _outputPointVals(cl, pt, i) += _inputCoeffs(cl, bf) * _inputFields(cl, bf, pt, i);
1109 }
1110 };
1111
1112 template<typename outputPointViewType,
1113 typename inputCoeffViewType,
1114 typename inputFieldViewType>
1115 struct F_evaluateTensor {
1116 outputPointViewType _outputPointVals;
1117 const inputCoeffViewType _inputCoeffs;
1118 const inputFieldViewType _inputFields;
1119
1120 KOKKOS_INLINE_FUNCTION
1121 F_evaluateTensor( outputPointViewType outputPointVals_,
1122 inputCoeffViewType inputCoeffs_,
1123 inputFieldViewType inputFields_ )
1124 : _outputPointVals(outputPointVals_), _inputCoeffs(inputCoeffs_), _inputFields(inputFields_) {}
1125
1126 KOKKOS_INLINE_FUNCTION
1127 void operator()(const ordinal_type cl, const ordinal_type pt) const {
1128 const ordinal_type nbfs = _inputFields.extent(1);
1129 const ordinal_type iend = _inputFields.extent(3);
1130 const ordinal_type jend = _inputFields.extent(4);
1131
1132 for (ordinal_type bf=0;bf<nbfs;++bf)
1133 for (ordinal_type i=0;i<iend;++i)
1134 for (ordinal_type j=0;j<jend;++j)
1135 _outputPointVals(cl, pt, i, j) += _inputCoeffs(cl, bf) * _inputFields(cl, bf, pt, i, j);
1136 }
1137 };
1138 }
1139
1140 template<typename DeviceType>
1141 template<typename outputPointValueType, class ...outputPointProperties,
1142 typename inputCoeffValueType, class ...inputCoeffProperties,
1143 typename inputFieldValueType, class ...inputFieldProperties>
1144 void
1145 FunctionSpaceTools<DeviceType>::
1146 evaluate( Kokkos::DynRankView<outputPointValueType,outputPointProperties...> outputPointVals,
1147 const Kokkos::DynRankView<inputCoeffValueType, inputCoeffProperties...> inputCoeffs,
1148 const Kokkos::DynRankView<inputFieldValueType, inputFieldProperties...> inputFields ) {
1149
1150#ifdef HAVE_INTREPID2_DEBUG
1151 INTREPID2_TEST_FOR_EXCEPTION( inputFields.rank() < 3 || inputFields.rank() > 5, std::invalid_argument,
1152 ">>> ERROR (FunctionSpaceTools::evaluate): Input fields container must have rank 3, 4, or 5.");
1153 INTREPID2_TEST_FOR_EXCEPTION( inputCoeffs.rank() != 2, std::invalid_argument,
1154 ">>> ERROR (FunctionSpaceTools::evaluate): Input coefficient container must have rank 2.");
1155 INTREPID2_TEST_FOR_EXCEPTION( outputPointVals.rank() != (inputFields.rank()-1), std::invalid_argument,
1156 ">>> ERROR (FunctionSpaceTools::evaluate): Output values container must have rank one less than the rank of the input fields container.");
1157 INTREPID2_TEST_FOR_EXCEPTION( inputCoeffs.extent(0) != inputFields.extent(0), std::invalid_argument,
1158 ">>> ERROR (FunctionSpaceTools::evaluate): Zeroth dimensions (number of cells) of the coefficient and fields input containers must agree!");
1159 INTREPID2_TEST_FOR_EXCEPTION( inputCoeffs.extent(1) != inputFields.extent(1), std::invalid_argument,
1160 ">>> ERROR (FunctionSpaceTools::evaluate): First dimensions (number of fields) of the coefficient and fields input containers must agree!");
1161 INTREPID2_TEST_FOR_EXCEPTION( outputPointVals.extent(0) != inputFields.extent(0), std::invalid_argument,
1162 ">>> ERROR (FunctionSpaceTools::evaluate): Zeroth dimensions (number of cells) of the input fields container and the output values container must agree!");
1163 for (size_type i=1;i<outputPointVals.rank();++i)
1164 INTREPID2_TEST_FOR_EXCEPTION( outputPointVals.extent(i) != inputFields.extent(i+1), std::invalid_argument,
1165 ">>> ERROR (FunctionSpaceTools::evaluate): outputPointVals dimension(i) does not match to inputFields dimension(i+1).");
1166#endif
1167
1168 constexpr bool are_accessible =
1169 Kokkos::Impl::MemorySpaceAccess<MemSpaceType,
1170 typename decltype(outputPointVals)::memory_space>::accessible &&
1171 Kokkos::Impl::MemorySpaceAccess<MemSpaceType,
1172 typename decltype(inputCoeffs)::memory_space>::accessible &&
1173 Kokkos::Impl::MemorySpaceAccess<MemSpaceType,
1174 typename decltype(inputFields)::memory_space>::accessible;
1175 static_assert(are_accessible, "FunctionSpaceTools<DeviceType>::evaluate(..): input/output views' memory spaces are not compatible with DeviceType");
1176
1177 using range_policy_type = Kokkos::MDRangePolicy< ExecSpaceType, Kokkos::Rank<2>, Kokkos::IndexType<ordinal_type> >;
1178
1179 const range_policy_type policy( { 0, 0 },
1180 { /*C*/ inputFields.extent(0), /*P*/ inputFields.extent(2)} );
1181
1182 if (inputFields.rank() == 3) {
1183 using FunctorType = FunctorFunctionSpaceTools::F_evaluateScalar<decltype(outputPointVals),decltype(inputCoeffs),decltype(inputFields)>;
1184 Kokkos::parallel_for( policy, FunctorType(outputPointVals, inputCoeffs, inputFields) );
1185 }
1186 else if (inputFields.rank() == 4) {
1187 using FunctorType = FunctorFunctionSpaceTools::F_evaluateVector<decltype(outputPointVals),decltype(inputCoeffs),decltype(inputFields)>;
1188 Kokkos::parallel_for( policy, FunctorType(outputPointVals, inputCoeffs, inputFields) );
1189 }
1190 else {
1191 using FunctorType = FunctorFunctionSpaceTools::F_evaluateTensor<decltype(outputPointVals),decltype(inputCoeffs),decltype(inputFields)>;
1192 Kokkos::parallel_for( policy, FunctorType(outputPointVals, inputCoeffs, inputFields) );
1193 }
1194 }
1195
1196 // ------------------------------------------------------------------------------------
1197
1198} // end namespace Intrepid2
1199
1200#endif
Intrepid2_FunctorIterator.hpp
Defines the Intrepid2::FunctorIterator class, as well as the Intrepid2::functor_returns_ref SFINAE he...
Intrepid2_TensorArgumentIterator.hpp
Defines TensorArgumentIterator, which allows systematic enumeration of a TensorData object.
Intrepid2::ArrayTools::contractFieldFieldTensor
static void contractFieldFieldTensor(Kokkos::DynRankView< outputFieldValueType, outputFieldProperties... > outputFields, const Kokkos::DynRankView< leftFieldValueType, leftFieldProperties... > leftFields, const Kokkos::DynRankView< rightFieldValueType, rightFieldProperties... > rightFields, const bool sumInto=false)
Contracts the "point" and "space" dimensions P, D1, and D2 of two rank-5 containers with dimensions (...
Definition Intrepid2_ArrayToolsDefContractions.hpp:494
Intrepid2::ArrayTools::contractDataDataVector
static void contractDataDataVector(Kokkos::DynRankView< outputDataValueType, outputDataProperties... > outputData, const Kokkos::DynRankView< inputDataLeftValueType, inputDataLeftProperties... > inputDataLeft, const Kokkos::DynRankView< inputDataRightValueType, inputDataRightProperties... > inputDataRight, const bool sumInto=false)
Contracts the "point" and "space" dimensions P and D of rank-3 containers with dimensions (C,...
Definition Intrepid2_ArrayToolsDefContractions.hpp:694
Intrepid2::ArrayTools::scalarMultiplyDataField
static void scalarMultiplyDataField(Kokkos::DynRankView< outputFieldValueType, outputFieldProperties... > outputFields, const Kokkos::DynRankView< inputDataValueType, inputDataProperties... > inputData, const Kokkos::DynRankView< inputFieldValueType, inputFieldProperties... > inputFields, const bool reciprocal=false)
There are two use cases: (1) multiplies a rank-3, 4, or 5 container inputFields with dimensions (C,...
Definition Intrepid2_ArrayToolsDefScalar.hpp:252
Intrepid2::ArrayTools::crossProductDataField
static void crossProductDataField(Kokkos::DynRankView< outputFieldValueType, outputFieldProperties... > outputFields, const Kokkos::DynRankView< inputDataValueType, inputDataProperties... > inputData, const Kokkos::DynRankView< inputFieldValueType, inputFieldProperties... > inputFields)
There are two use cases: (1) cross product of a rank-4 container inputFields with dimensions (C,...
Definition Intrepid2_ArrayToolsDefTensor.hpp:113
Intrepid2::ArrayTools::matmatProductDataField
static void matmatProductDataField(Kokkos::DynRankView< outputFieldValueType, outputFieldProperties... > outputFields, const Kokkos::DynRankView< inputDataValueType, inputDataProperties... > inputData, const Kokkos::DynRankView< inputFieldValueType, inputFieldProperties... > inputFields, const char transpose='N')
There are two use cases: (1) matrix-matrix product of a rank-5 container inputFields with dimensions ...
Definition Intrepid2_ArrayToolsDefTensor.hpp:1434
Intrepid2::ArrayTools::outerProductDataData
static void outerProductDataData(Kokkos::DynRankView< outputDataValueType, outputDataProperties... > outputData, const Kokkos::DynRankView< inputDataLeftValuetype, inputDataLeftProperties... > inputDataLeft, const Kokkos::DynRankView< inputDataRightValueType, inputDataRightProperties... > inputDataRight)
There are two use cases: (1) outer product of a rank-3 container inputDataRight with dimensions (C,...
Definition Intrepid2_ArrayToolsDefTensor.hpp:540
Intrepid2::ArrayTools::matmatProductDataData
static void matmatProductDataData(Kokkos::DynRankView< outputDataValueType, outputDataProperties... > outputData, const Kokkos::DynRankView< inputDataLeftValueType, inputDataLeftProperties... > inputDataLeft, const Kokkos::DynRankView< inputDataRightValueType, inputDataRightProperties... > inputDataRight, const char transpose='N')
There are two use cases: (1) matrix-matrix product of a rank-4 container inputDataRight with dimensio...
Definition Intrepid2_ArrayToolsDefTensor.hpp:1598
Intrepid2::ArrayTools::matvecProductDataData
static void matvecProductDataData(Kokkos::DynRankView< outputDataValueType, outputDataProperties... > outputData, const Kokkos::DynRankView< inputDataLeftValueType, inputDataLeftProperties... > inputDataLeft, const Kokkos::DynRankView< inputDataRightValueType, inputDataRightProperties... > inputDataRight, const char transpose='N')
There are two use cases: (1) matrix-vector product of a rank-3 container inputDataRight with dimensio...
Definition Intrepid2_ArrayToolsDefTensor.hpp:1156
Intrepid2::ArrayTools::contractFieldFieldScalar
static void contractFieldFieldScalar(Kokkos::DynRankView< outputFieldValueType, outputFieldProperties... > outputFields, const Kokkos::DynRankView< leftFieldValueType, leftFieldProperties... > leftFields, const Kokkos::DynRankView< rightFieldValueType, rightFieldProperties... > rightFields, const bool sumInto=false)
Contracts the "point" dimension P of two rank-3 containers with dimensions (C,L,P) and (C,...
Definition Intrepid2_ArrayToolsDefContractions.hpp:413
Intrepid2::ArrayTools::contractDataFieldScalar
static void contractDataFieldScalar(Kokkos::DynRankView< outputFieldValueType, outputFieldProperties... > outputFields, const Kokkos::DynRankView< inputDataValueType, inputDataProperties... > inputData, const Kokkos::DynRankView< inputFieldValueType, inputFieldProperties... > inputFields, const bool sumInto=false)
Contracts the "point" dimensions P of a rank-3 containers and a rank-2 container with dimensions (C,...
Definition Intrepid2_ArrayToolsDefContractions.hpp:537
Intrepid2::ArrayTools::contractDataDataTensor
static void contractDataDataTensor(Kokkos::DynRankView< outputDataValueType, outputDataProperties... > outputData, const Kokkos::DynRankView< inputDataLeftValueType, inputDataLeftProperties... > inputDataLeft, const Kokkos::DynRankView< inputDataRightValueType, inputDataRightProperties... > inputDataRight, const bool sumInto=false)
Contracts the "point" and "space" dimensions P, D1 and D2 of rank-4 containers with dimensions (C,...
Definition Intrepid2_ArrayToolsDefContractions.hpp:731
Intrepid2::ArrayTools::dotMultiplyDataData
static void dotMultiplyDataData(Kokkos::DynRankView< outputDataValueType, outputDataProperties... > outputData, const Kokkos::DynRankView< inputDataLeftValueType, inputDataLeftProperties... > inputDataLeft, const Kokkos::DynRankView< inputDataRightValueType, inputDataRightProperties... > inputDataRight)
There are two use cases: (1) dot product of a rank-2, 3 or 4 container inputDataRight with dimensions...
Definition Intrepid2_ArrayToolsDefDot.hpp:177
Intrepid2::ArrayTools::contractDataFieldVector
static void contractDataFieldVector(Kokkos::DynRankView< outputFieldValueType, outputFieldProperties... > outputFields, const Kokkos::DynRankView< inputDataValueType, inputDataProperties... > inputData, const Kokkos::DynRankView< inputFieldValueType, inputFieldProperties... > inputFields, const bool sumInto=false)
Contracts the "point" and "space" dimensions P and D of a rank-4 container and a rank-3 container wit...
Definition Intrepid2_ArrayToolsDefContractions.hpp:576
Intrepid2::ArrayTools::outerProductDataField
static void outerProductDataField(Kokkos::DynRankView< outputFieldValueType, outputFieldProperties... > outputFields, const Kokkos::DynRankView< inputDataValueType, inputDataProperties... > inputData, const Kokkos::DynRankView< inputFieldValueType, inputFieldProperties... > inputFields)
There are two use cases: (1) outer product of a rank-4 container inputFields with dimensions (C,...
Definition Intrepid2_ArrayToolsDefTensor.hpp:433
Intrepid2::ArrayTools::matvecProductDataField
static void matvecProductDataField(Kokkos::DynRankView< outputFieldValueType, outputFieldProperties... > outputFields, const Kokkos::DynRankView< inputDataValueType, inputDataProperties... > inputData, const Kokkos::DynRankView< inputFieldValueType, inputFieldProperties... > inputFields, const char transpose='N')
There are two use cases: (1) matrix-vector product of a rank-4 container inputFields with dimensions ...
Definition Intrepid2_ArrayToolsDefTensor.hpp:1002
Intrepid2::ArrayTools::contractDataFieldTensor
static void contractDataFieldTensor(Kokkos::DynRankView< outputFieldValueType, outputFieldProperties... > outputFields, const Kokkos::DynRankView< inputDataValueType, inputDataProperties... > inputData, const Kokkos::DynRankView< inputFieldValueType, inputFieldProperties... > inputFields, const bool sumInto=false)
Contracts the "point" and "space" dimensions P, D1 and D2 of a rank-5 container and a rank-4 containe...
Definition Intrepid2_ArrayToolsDefContractions.hpp:617
Intrepid2::ArrayTools::dotMultiplyDataField
static void dotMultiplyDataField(Kokkos::DynRankView< outputFieldValueType, outputFieldProperties... > outputFields, const Kokkos::DynRankView< inputDataValueType, inputDataProperties... > inputData, const Kokkos::DynRankView< inputFieldValueType, inputFieldProperties... > inputFields)
There are two use cases: (1) dot product of a rank-3, 4 or 5 container inputFields with dimensions (C...
Definition Intrepid2_ArrayToolsDefDot.hpp:113
Intrepid2::ArrayTools::contractFieldFieldVector
static void contractFieldFieldVector(Kokkos::DynRankView< outputFieldValueType, outputFieldProperties... > outputFields, const Kokkos::DynRankView< leftFieldValueType, leftFieldProperties... > leftFields, const Kokkos::DynRankView< rightFieldValueType, rightFieldProperties... > rightFields, const bool sumInto=false)
Contracts the "point" and "space" dimensions P and D1 of two rank-4 containers with dimensions (C,...
Definition Intrepid2_ArrayToolsDefContractions.hpp:453
Intrepid2::ArrayTools::scalarMultiplyDataData
static void scalarMultiplyDataData(Kokkos::DynRankView< outputDataValueType, outputDataProperties... > outputData, const Kokkos::DynRankView< inputDataLeftValueType, inputDataLeftProperties... > inputDataLeft, const Kokkos::DynRankView< inputDataRightValueType, inputDataRightProperties... > inputDataRight, const bool reciprocal=false)
There are two use cases: (1) multiplies a rank-2, 3, or 4 container inputDataRight with dimensions (C...
Definition Intrepid2_ArrayToolsDefScalar.hpp:376
Intrepid2::ArrayTools::crossProductDataData
static void crossProductDataData(Kokkos::DynRankView< outputDataValueType, outputDataProperties... > outputData, const Kokkos::DynRankView< inputDataLeftValueType, inputDataLeftProperties... > inputDataLeft, const Kokkos::DynRankView< inputDataRightValueType, inputDataRightProperties... > inputDataRight)
There are two use cases: (1) cross product of a rank-3 container inputDataRight with dimensions (C,...
Definition Intrepid2_ArrayToolsDefTensor.hpp:236
Intrepid2::ArrayTools::cloneFields
static void cloneFields(Kokkos::DynRankView< outputFieldValueType, outputFieldProperties... > outputFields, const Kokkos::DynRankView< inputFieldValueType, inputFieldProperties... > inputFields)
Replicates a rank-2, 3, or 4 container with dimensions (F,P), (F,P,D1) or (F,P,D1,...
Intrepid2::ArrayTools::contractDataDataScalar
static void contractDataDataScalar(Kokkos::DynRankView< outputDataValueType, outputDataProperties... > outputData, const Kokkos::DynRankView< inputDataLeftValueType, inputDataLeftProperties... > inputDataLeft, const Kokkos::DynRankView< inputDataRightValueType, inputDataRightProperties... > inputDataRight, const bool sumInto=false)
Contracts the "point" dimensions P of rank-2 containers with dimensions (C,P), and returns the result...
Definition Intrepid2_ArrayToolsDefContractions.hpp:659
Intrepid2::CellTools::getPhysicalFaceNormals
static void getPhysicalFaceNormals(Kokkos::DynRankView< faceNormalValueType, faceNormalProperties... > faceNormals, const Kokkos::DynRankView< worksetJacobianValueType, worksetJacobianProperties... > worksetJacobians, const ordinal_type worksetFaceOrd, const shards::CellTopology parentCell)
Computes non-normalized normal vectors to physical faces in a face workset ; (see Subcell worksets fo...
Definition Intrepid2_CellToolsDefNodeInfo.hpp:801
Intrepid2::CellTools::getPhysicalEdgeTangents
static void getPhysicalEdgeTangents(Kokkos::DynRankView< edgeTangentValueType, edgeTangentProperties... > edgeTangents, const Kokkos::DynRankView< worksetJacobianValueType, worksetJacobianProperties... > worksetJacobians, const ordinal_type worksetEdgeOrd, const shards::CellTopology parentCell)
Computes non-normalized tangent vectors to physical edges in an edge workset ; (see Subcell worksets ...
Definition Intrepid2_CellToolsDefNodeInfo.hpp:371
Intrepid2::FunctionSpaceTools::computeFaceMeasure
static void computeFaceMeasure(Kokkos::DynRankView< outputValValueType, outputValProperties... > outputVals, const Kokkos::DynRankView< inputJacValueType, inputJacProperties... > inputJac, const Kokkos::DynRankView< inputWeightValueType, inputWeightPropertes... > inputWeights, const int whichFace, const shards::CellTopology parentCell, const Kokkos::DynRankView< scratchValueType, scratchProperties... > scratch)
Returns the weighted integration measures outputVals with dimensions (C,P) used for the computation o...
Intrepid2::FunctionSpaceTools::HVOLtransformVALUE
static void HVOLtransformVALUE(Kokkos::DynRankView< outputValValueType, outputValProperties... > outputVals, const Kokkos::DynRankView< jacobianDetValueType, jacobianDetProperties... > jacobianDet, const Kokkos::DynRankView< inputValValueType, inputValProperties... > inputVals)
Transformation of a (scalar) value field in the H-vol space, defined at points on a reference cell,...
Definition Intrepid2_FunctionSpaceToolsDef.hpp:365
Intrepid2::FunctionSpaceTools::integrate
static void integrate(Kokkos::DynRankView< outputValueValueType, outputValueProperties... > outputValues, const Kokkos::DynRankView< leftValueValueType, leftValueProperties... > leftValues, const Kokkos::DynRankView< rightValueValueType, rightValueProperties... > rightValues, const bool sumInto=false)
Contracts leftValues and rightValues arrays on the point and possibly space dimensions and stores the...
Definition Intrepid2_FunctionSpaceToolsDef.hpp:393
Intrepid2::FunctionSpaceTools::applyRightFieldSigns
static void applyRightFieldSigns(Kokkos::DynRankView< inoutOperatorValueType, inoutOperatorProperties... > inoutOperator, const Kokkos::DynRankView< fieldSignValueType, fieldSignProperties... > fieldSigns)
Applies right (column) signs, stored in the user-provided container fieldSigns and indexed by (C,...
Definition Intrepid2_FunctionSpaceToolsDef.hpp:960
Intrepid2::FunctionSpaceTools::tensorMultiplyDataData
static void tensorMultiplyDataData(Kokkos::DynRankView< outputDataValueType, outputDataProperties... > outputData, const Kokkos::DynRankView< inputDataLeftValueType, inputDataLeftProperties... > inputDataLeft, const Kokkos::DynRankView< inputDataRightValueType, inputDataRightProperties... > inputDataRight, const char transpose='N')
Matrix-vector or matrix-matrix product of data and data; please read the description below.
Definition Intrepid2_FunctionSpaceToolsDef.hpp:837
Intrepid2::FunctionSpaceTools::computeCellMeasure
static bool computeCellMeasure(OutputValViewType outputVals, const InputDetViewType inputDet, const InputWeightViewType inputWeights)
Returns the weighted integration measures outputVals with dimensions (C,P) used for the computation o...
Definition Intrepid2_FunctionSpaceToolsDef.hpp:537
Intrepid2::FunctionSpaceTools::HCURLtransformCURL
static void HCURLtransformCURL(Kokkos::DynRankView< outputValValueType, outputValProperties... > outputVals, const Kokkos::DynRankView< jacobianValueType, jacobianProperties... > jacobian, const Kokkos::DynRankView< jacobianDetValueType, jacobianDetProperties... > jacobianDet, const Kokkos::DynRankView< inputValValueType, inputValProperties... > inputVals)
Transformation of a 3D curl field in the H-curl space, defined at points on a reference cell,...
Definition Intrepid2_FunctionSpaceToolsDef.hpp:242
Intrepid2::FunctionSpaceTools::computeEdgeMeasure
static void computeEdgeMeasure(Kokkos::DynRankView< outputValValueType, outputValProperties... > outputVals, const Kokkos::DynRankView< inputJacValueType, inputJacProperties... > inputJac, const Kokkos::DynRankView< inputWeightValueType, inputWeightProperties... > inputWeights, const int whichEdge, const shards::CellTopology parentCell, const Kokkos::DynRankView< scratchValueType, scratchProperties... > scratch)
Returns the weighted integration measures outVals with dimensions (C,P) used for the computation of e...
Definition Intrepid2_FunctionSpaceToolsDef.hpp:620
Intrepid2::FunctionSpaceTools::mapHGradDataFromPhysToRef
static void mapHGradDataFromPhysToRef(Kokkos::DynRankView< outputValueType, outputProperties... > output, const Kokkos::DynRankView< inputValueType, inputProperties... > input)
Transformation of a (scalar) data in the H-grad space, defined in physical space, stored in the user-...
Definition Intrepid2_FunctionSpaceToolsDef.hpp:53
Intrepid2::FunctionSpaceTools::mapHDivDataDotNormalFromPhysSideToRefSide
static void mapHDivDataDotNormalFromPhysSideToRefSide(Kokkos::DynRankView< outputValValueType, outputValProperties... > outputVals, const Kokkos::DynRankView< jacobianDetValueType, jacobianDetProperties... > metricTensorDet, const Kokkos::DynRankView< inputValValueType, inputValProperties... > inputVals)
Transformation of HDIV data from physical side to reference side. It takes the input defined on phys...
Definition Intrepid2_FunctionSpaceToolsDef.hpp:335
Intrepid2::FunctionSpaceTools::dotMultiplyDataData
static void dotMultiplyDataData(Kokkos::DynRankView< outputDataValueType, outputDataProperties... > outputData, const Kokkos::DynRankView< inputDataLeftValueType, inputDataLeftProperties... > inputDataLeft, const Kokkos::DynRankView< inputDataRightValueType, inputDataRightProperties... > inputDataRight)
Dot product of data and data; please read the description below.
Definition Intrepid2_FunctionSpaceToolsDef.hpp:725
Intrepid2::FunctionSpaceTools::multiplyMeasure
static void multiplyMeasure(Kokkos::DynRankView< outputValValueType, outputValProperties... > outputVals, const Kokkos::DynRankView< inputMeasureValueType, inputMeasureProperties... > inputMeasure, const Kokkos::DynRankView< inputValValueType, inputValProperteis... > inputVals)
Multiplies fields inputVals by weighted measures inputMeasure and returns the field array outputVals;...
Intrepid2::FunctionSpaceTools::mapHGradDataFromPhysSideToRefSide
static void mapHGradDataFromPhysSideToRefSide(Kokkos::DynRankView< outputValueType, outputProperties... > output, const Kokkos::DynRankView< inputValueType, inputProperties... > input)
Transformation of a (scalar) data in the H-grad space, defined in physical space, stored in the user-...
Definition Intrepid2_FunctionSpaceToolsDef.hpp:75
Intrepid2::FunctionSpaceTools::HGRADtransformCURL
static void HGRADtransformCURL(Kokkos::DynRankView< outputValValueType, outputValProperties... > outputVals, const Kokkos::DynRankView< jacobianValueType, jacobianProperties... > jacobian, const Kokkos::DynRankView< jacobianDetValueType, jacobianDetProperties... > jacobianDet, const Kokkos::DynRankView< inputValValueType, inputValProperties... > inputVals)
Transformation of a 2D curl field in the H-grad space, defined at points on a reference cell,...
Definition Intrepid2_FunctionSpaceToolsDef.hpp:281
Intrepid2::FunctionSpaceTools::mapHCurlDataCrossNormalFromPhysSideToRefSide
static void mapHCurlDataCrossNormalFromPhysSideToRefSide(Kokkos::DynRankView< outputValValueType, outputValProperties... > outputVals, const Kokkos::DynRankView< tangentsValueType, tangentsProperties... > tangents, const Kokkos::DynRankView< metricTensorInvValueType, metricTensorInvProperties... > metricTensorInv, const Kokkos::DynRankView< metricTensorDetValueType, metricTensorDetProperties... > metricTensorDet, const Kokkos::DynRankView< inputValValueType, inputValProperties... > inputVals)
Transformation of 3D HCURL data from physical side to reference side. It takes the input vector defi...
Definition Intrepid2_FunctionSpaceToolsDef.hpp:175
Intrepid2::FunctionSpaceTools::mapHCurlDataFromPhysToRef
static void mapHCurlDataFromPhysToRef(Kokkos::DynRankView< outputValValueType, outputValProperties... > outputVals, const Kokkos::DynRankView< jacobianValueType, jacobianProperties... > jacobian, const Kokkos::DynRankView< inputValValueType, inputValProperties... > inputVals)
Transformation of a (vector) data in the H-curl space, defined in the physical space,...
Definition Intrepid2_FunctionSpaceToolsDef.hpp:132
Intrepid2::FunctionSpaceTools::evaluate
static void evaluate(Kokkos::DynRankView< outputPointValueType, outputPointProperties... > outputPointVals, const Kokkos::DynRankView< inputCoeffValueType, inputCoeffProperties... > inputCoeffs, const Kokkos::DynRankView< inputFieldValueType, inputFieldProperties... > inputFields)
Computes point values outPointVals of a discrete function specified by the basis inFields and coeffic...
Definition Intrepid2_FunctionSpaceToolsDef.hpp:1146
Intrepid2::FunctionSpaceTools::scalarMultiplyDataField
static void scalarMultiplyDataField(Kokkos::DynRankView< outputFieldValueType, outputFieldProperties... > outputFields, const Kokkos::DynRankView< inputDataValueType, inputDataPropertes... > inputData, const Kokkos::DynRankView< inputFieldValueType, inputFieldProperties... > inputFields, const bool reciprocal=false)
Scalar multiplication of data and fields; please read the description below.
Intrepid2::FunctionSpaceTools::dotMultiplyDataField
static void dotMultiplyDataField(Kokkos::DynRankView< outputFieldValueType, outputFieldProperties... > outputFields, const Kokkos::DynRankView< inputDataValueType, inputDataProperties... > inputData, const Kokkos::DynRankView< inputFieldValueType, inputFieldProperties... > inputFields)
Dot product of data and fields; please read the description below.
Definition Intrepid2_FunctionSpaceToolsDef.hpp:709
Intrepid2::FunctionSpaceTools::applyLeftFieldSigns
static void applyLeftFieldSigns(Kokkos::DynRankView< inoutOperatorValueType, inoutOperatorProperties... > inoutOperator, const Kokkos::DynRankView< fieldSignValueType, fieldSignProperties... > fieldSigns)
Applies left (row) signs, stored in the user-provided container fieldSigns and indexed by (C,...
Definition Intrepid2_FunctionSpaceToolsDef.hpp:897
Intrepid2::FunctionSpaceTools::applyFieldSigns
static void applyFieldSigns(Kokkos::DynRankView< inoutFunctionValueType, inoutFunctionProperties... > inoutFunction, const Kokkos::DynRankView< fieldSignValueType, fieldSignProperties... > fieldSigns)
Applies field signs, stored in the user-provided container fieldSigns and indexed by (C,...
Definition Intrepid2_FunctionSpaceToolsDef.hpp:1027
Intrepid2::FunctionSpaceTools::HCURLtransformVALUE
static void HCURLtransformVALUE(Kokkos::DynRankView< outputValValueType, outputValProperties... > outputVals, const Kokkos::DynRankView< jacobianInverseValueType, jacobianInverseProperties... > jacobianInverse, const Kokkos::DynRankView< inputValValueType, inputValProperties... > inputVals)
Transformation of a (vector) value field in the H-curl space, defined at points on a reference cell,...
Definition Intrepid2_FunctionSpaceToolsDef.hpp:120
Intrepid2::FunctionSpaceTools::vectorMultiplyDataData
static void vectorMultiplyDataData(Kokkos::DynRankView< outputDataValueType, outputDataProperties... > outputData, const Kokkos::DynRankView< inputDataLeftValueType, inputDataLeftProperties... > inputDataLeft, const Kokkos::DynRankView< inputDataRightValueType, inputDataRightProperties... > inputDataRight)
Cross or outer product of data and data; please read the description below.
Definition Intrepid2_FunctionSpaceToolsDef.hpp:772
Intrepid2::FunctionSpaceTools::vectorMultiplyDataField
static void vectorMultiplyDataField(Kokkos::DynRankView< outputFieldValueType, outputFieldProperties... > outputFields, const Kokkos::DynRankView< inputDataValueType, inputDataProperties... > inputData, const Kokkos::DynRankView< inputFieldValueType, inputFieldProperties... > inputFields)
Cross or outer product of data and fields; please read the description below.
Definition Intrepid2_FunctionSpaceToolsDef.hpp:741
Intrepid2::FunctionSpaceTools::scalarMultiplyDataData
static void scalarMultiplyDataData(Kokkos::DynRankView< outputDataValuetype, outputDataProperties... > outputData, const Kokkos::DynRankView< inputDataLeftValueType, inputDataLeftProperties... > inputDataLeft, const Kokkos::DynRankView< inputDataRightValueType, inputDataRightProperties... > inputDataRight, const bool reciprocal=false)
Scalar multiplication of data and data; please read the description below.
Definition Intrepid2_FunctionSpaceToolsDef.hpp:691
Intrepid2::FunctionSpaceTools::HDIVtransformVALUE
static void HDIVtransformVALUE(Kokkos::DynRankView< outputValValueType, outputValProperties... > outputVals, const Kokkos::DynRankView< jacobianValueType, jacobianProperties... > jacobian, const Kokkos::DynRankView< jacobianDetValueType, jacobianDetProperties... > jacobianDet, const Kokkos::DynRankView< inputValValueType, inputValProperties... > inputVals)
Transformation of a (vector) value field in the H-div space, defined at points on a reference cell,...
Definition Intrepid2_FunctionSpaceToolsDef.hpp:303
Intrepid2::FunctionSpaceTools::mapHDivDataFromPhysToRef
static void mapHDivDataFromPhysToRef(Kokkos::DynRankView< outputValValueType, outputValProperties... > outputVals, const Kokkos::DynRankView< jacobianInverseValueType, jacobianInverseProperties... > jacobianInv, const Kokkos::DynRankView< jacobianDetValueType, jacobianDetProperties... > jacobianDet, const Kokkos::DynRankView< inputValValueType, inputValProperties... > inputVals)
Transformation of a (vector) data in the H-div space, defined in the physical space,...
Definition Intrepid2_FunctionSpaceToolsDef.hpp:318
Intrepid2::FunctionSpaceTools::mapHVolDataFromPhysToRef
static void mapHVolDataFromPhysToRef(Kokkos::DynRankView< outputValValueType, outputValProperties... > outputVals, const Kokkos::DynRankView< jacobianDetValueType, jacobianDetProperties... > jacobianDet, const Kokkos::DynRankView< inputValValueType, inputValProperties... > inputVals)
Transformation of a (scalar) data in the H-vol space, defined in the physical space,...
Definition Intrepid2_FunctionSpaceToolsDef.hpp:377
Intrepid2::FunctionSpaceTools::HDIVtransformDIV
static void HDIVtransformDIV(Kokkos::DynRankView< outputValValueType, outputValProperties... > outputVals, const Kokkos::DynRankView< jacobianDetValueType, jacobianDetProperties... > jacobianDet, const Kokkos::DynRankView< inputValValueType, inputValProperties... > inputVals)
Transformation of a divergence field in the H-div space, defined at points on a reference cell,...
Definition Intrepid2_FunctionSpaceToolsDef.hpp:351
Intrepid2::FunctionSpaceTools::tensorMultiplyDataField
static void tensorMultiplyDataField(Kokkos::DynRankView< outputFieldValueType, outputFieldProperties... > outputFields, const Kokkos::DynRankView< inputDataValueType, inputDataProperties... > inputData, const Kokkos::DynRankView< inputFieldValueType, inputFieldProperties... > inputFields, const char transpose='N')
Matrix-vector or matrix-matrix product of data and fields; please read the description below.
Definition Intrepid2_FunctionSpaceToolsDef.hpp:803
Intrepid2::FunctionSpaceTools::HGRADtransformVALUE
static void HGRADtransformVALUE(Kokkos::DynRankView< outputValueType, outputProperties... > output, const Kokkos::DynRankView< inputValueType, inputProperties... > input)
Transformation of a (scalar) value field in the H-grad space, defined at points on a reference cell,...
Definition Intrepid2_FunctionSpaceToolsDef.hpp:31
Intrepid2::FunctionSpaceTools::HGRADtransformGRAD
static void HGRADtransformGRAD(OutputValViewType outputVals, const JacobianInverseViewType jacobianInverse, const InputValViewType inputVals)
Transformation of a gradient field in the H-grad space, defined at points on a reference cell,...
Definition Intrepid2_FunctionSpaceToolsDef.hpp:106
Intrepid2::RealSpaceTools::vectorNorm
static void vectorNorm(Kokkos::DynRankView< normArrayValueType, normArrayProperties... > normArray, const Kokkos::DynRankView< inVecValueType, inVecProperties... > inVecs, const ENorm normType)
Computes norms (1, 2, infinity) of vectors stored in a array of total rank 2 (array of vectors),...
Definition Intrepid2_RealSpaceToolsDef.hpp:499
Intrepid2::RealSpaceTools::clone
static void clone(Kokkos::DynRankView< outputValueType, outputProperties... > output, const Kokkos::DynRankView< inputValueType, inputProperties... > input)
Clone input array.
Definition Intrepid2_RealSpaceToolsDef.hpp:333
Intrepid2::FunctorFunctionSpaceTools::F_applyFieldSigns
Functor for applyFieldSigns, see Intrepid2::FunctionSpaceTools for more.
Definition Intrepid2_FunctionSpaceToolsDef.hpp:997
Intrepid2::FunctorFunctionSpaceTools::F_applyLeftFieldSigns
Functor for applyLeftFieldSigns, see Intrepid2::FunctionSpaceTools for more.
Definition Intrepid2_FunctionSpaceToolsDef.hpp:871
Intrepid2::FunctorFunctionSpaceTools::F_applyRightFieldSigns
Functor for applyRightFieldSigns, see Intrepid2::FunctionSpaceTools for more.
Definition Intrepid2_FunctionSpaceToolsDef.hpp:934
Intrepid2::FunctorFunctionSpaceTools::F_computeCellMeasure
Functor for calculation of cell measure, see Intrepid2::FunctionSpaceTools for more.
Definition Intrepid2_FunctionSpaceToolsDef.hpp:490
Intrepid2::FunctorFunctionSpaceTools::F_evaluateScalar
Functor to evaluate functions, see Intrepid2::FunctionSpaceTools for more.
Definition Intrepid2_FunctionSpaceToolsDef.hpp:1067
Intrepid2::FunctorFunctionSpaceTools::F_evaluateTensor
Definition Intrepid2_FunctionSpaceToolsDef.hpp:1115
Intrepid2::FunctorFunctionSpaceTools::F_evaluateVector
Definition Intrepid2_FunctionSpaceToolsDef.hpp:1090
Intrepid2::FunctorFunctionSpaceTools::F_negativeWeighted2dInputCrossK
Definition Intrepid2_FunctionSpaceToolsDef.hpp:145
Intrepid2::FunctorFunctionSpaceTools::F_weighedInput
Definition Intrepid2_FunctionSpaceToolsDef.hpp:196
Generated by doxygen 1.9.8