Intrepid2
Intrepid2_ArrayToolsDefScalar.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_ARRAYTOOLS_DEF_SCALAR_HPP__
17 #define __INTREPID2_ARRAYTOOLS_DEF_SCALAR_HPP__
18 
19 namespace Intrepid2 {
20 
21  namespace FunctorArrayTools {
25  template<typename OutputViewType,
26  typename inputLeftViewType,
27  typename inputRightViewType,
28  bool equalRank,
29  bool reciprocal>
30  struct F_scalarMultiply {
31  OutputViewType _output;
32  const inputLeftViewType _inputLeft;
33  const inputRightViewType _inputRight;
34 
35  KOKKOS_INLINE_FUNCTION
36  F_scalarMultiply(OutputViewType output_,
37  inputLeftViewType inputLeft_,
38  inputRightViewType inputRight_)
39  : _output(output_),
40  _inputLeft(inputLeft_),
41  _inputRight(inputRight_) {}
42 
43  // DataData
44  KOKKOS_INLINE_FUNCTION
45  void operator()(const ordinal_type cl,
46  const ordinal_type pt) const {
47  const auto val = _inputLeft(cl , pt%_inputLeft.extent(1));
48 
49  //const ordinal_type cp[2] = { cl, pt };
50  //ViewAdapter<2,OutputViewType> out(cp, _output);
51  auto out = Kokkos::subview(_output, cl, pt, Kokkos::ALL(), Kokkos::ALL());
52  if (equalRank) {
53  //const ViewAdapter<2,inputRightViewType> right(cp, _inputRight);
54  const auto right = Kokkos::subview(_inputRight, cl, pt, Kokkos::ALL(), Kokkos::ALL());
55  if (reciprocal) Kernels::inv_scalar_mult_mat(out, val, right);
56  else Kernels:: scalar_mult_mat(out, val, right);
57  } else {
58  //const ordinal_type p[1] = { pt };
59  //const ViewAdapter<1,inputRightViewType> right(p, _inputRight);
60  const auto right = Kokkos::subview(_inputRight, pt, Kokkos::ALL(), Kokkos::ALL());
61  if (reciprocal) Kernels::inv_scalar_mult_mat(out, val, right);
62  else Kernels:: scalar_mult_mat(out, val, right);
63  }
64  }
65 
66  // DataField
67  KOKKOS_INLINE_FUNCTION
68  void operator()(const ordinal_type cl,
69  const ordinal_type bf,
70  const ordinal_type pt) const {
71  const auto val = _inputLeft(cl , pt%_inputLeft.extent(1));
72 
73  //const ordinal_type cfp[3] = { cl, bf, pt };
74  //ViewAdapter<3,OutputViewType> out(cfp, _output);
75  auto out = Kokkos::subview(_output, cl, bf, pt, Kokkos::ALL(), Kokkos::ALL());
76  if (equalRank) {
77  //const ViewAdapter<3,inputRightViewType> right(cfp, _inputRight);
78  auto right = Kokkos::subview(_inputRight, cl, bf, pt, Kokkos::ALL(), Kokkos::ALL());
79  if (reciprocal) Kernels::inv_scalar_mult_mat(out, val, right);
80  else Kernels:: scalar_mult_mat(out, val, right);
81  } else {
82  //const ordinal_type fp[2] = { bf, pt };
83  //const ViewAdapter<2,inputRightViewType> right(fp, _inputRight);
84  auto right = Kokkos::subview(_inputRight, bf, pt, Kokkos::ALL(), Kokkos::ALL());
85  if (reciprocal) Kernels::inv_scalar_mult_mat(out, val, right);
86  else Kernels:: scalar_mult_mat(out, val, right);
87  }
88  }
89  };
90  }
91 
92  template<typename DeviceType>
93  template<typename outputFieldValueType, class ...outputFieldProperties,
94  typename inputDataValueType, class ...inputDataProperties,
95  typename inputFieldValueType, class ...inputFieldProperties>
96  void
97  ArrayTools<DeviceType>::
98  scalarMultiplyDataField( Kokkos::DynRankView<outputFieldValueType,outputFieldProperties...> outputFields,
99  const Kokkos::DynRankView<inputDataValueType, inputDataProperties...> inputData,
100  const Kokkos::DynRankView<inputFieldValueType, inputFieldProperties...> inputFields,
101  const bool reciprocal ) {
102 
103 #ifdef HAVE_INTREPID2_DEBUG
104  {
105  INTREPID2_TEST_FOR_EXCEPTION( inputData.rank() != 2, std::invalid_argument,
106  ">>> ERROR (ArrayTools::scalarMultiplyDataField): Input data container must have rank 2.");
107 
108  if (outputFields.rank() <= inputFields.rank()) {
109  INTREPID2_TEST_FOR_EXCEPTION( inputFields.rank() < 3 || inputFields.rank() > 5, std::invalid_argument,
110  ">>> ERROR (ArrayTools::scalarMultiplyDataField): Input fields container must have rank 3, 4, or 5.");
111  INTREPID2_TEST_FOR_EXCEPTION( outputFields.rank() != inputFields.rank(), std::invalid_argument,
112  ">>> ERROR (ArrayTools::scalarMultiplyDataField): Input and output fields containers must have the same rank.");
113  INTREPID2_TEST_FOR_EXCEPTION( inputFields.extent(0) != inputData.extent(0), std::invalid_argument,
114  ">>> ERROR (ArrayTools::scalarMultiplyDataField): Zeroth dimensions (number of integration domains) of the fields and data input containers must agree!");
115  INTREPID2_TEST_FOR_EXCEPTION( inputData.extent(1) != inputFields.extent(2) &&
116  inputData.extent(1) != 1, std::invalid_argument,
117  ">>> ERROR (ArrayTools::scalarMultiplyDataField): Second dimension of the fields input container and first dimension of data input container (number of integration points) must agree, or first data dimension must be 1!");
118  for (size_type i=0;i<inputFields.rank();++i) {
119  INTREPID2_TEST_FOR_EXCEPTION( inputFields.extent(i) != outputFields.extent(i), std::invalid_argument,
120  ">>> ERROR (ArrayTools::scalarMultiplyDataField): inputFields dimension (i) does not match to the dimension (i) of outputFields");
121  }
122  }
123  else {
124  INTREPID2_TEST_FOR_EXCEPTION( inputFields.rank() < 2 || inputFields.rank() > 4, std::invalid_argument,
125  ">>> ERROR (ArrayTools::scalarMultiplyDataField): Input fields container must have rank 2, 3, or 4.");
126  INTREPID2_TEST_FOR_EXCEPTION( outputFields.rank() != (inputFields.rank()+1), std::invalid_argument,
127  ">>> ERROR (ArrayTools::scalarMultiplyDataField): The rank of the input fields container must be one less than the rank of the output fields container.");
128  INTREPID2_TEST_FOR_EXCEPTION( inputData.extent(1) != inputFields.extent(1) &&
129  inputData.extent(1) != 1, std::invalid_argument,
130  ">>> ERROR (ArrayTools::scalarMultiplyDataField): First dimensions of fields input container and data input container (number of integration points) must agree or first data dimension must be 1!");
131  INTREPID2_TEST_FOR_EXCEPTION( inputData.extent(0) != outputFields.extent(0), std::invalid_argument,
132  ">>> ERROR (ArrayTools::scalarMultiplyDataField): Zeroth dimensions of fields output container and data input containers (number of integration domains) must agree!");
133  for (size_type i=0;i<inputFields.rank();++i) {
134  INTREPID2_TEST_FOR_EXCEPTION( inputFields.extent(i) != outputFields.extent(i+1), std::invalid_argument,
135  ">>> ERROR (ArrayTools::scalarMultiplyDataField): inputFields dimension (i) does not match to the dimension (i+1) of outputFields");
136  }
137  }
138  }
139 #endif
140 
141  typedef Kokkos::DynRankView<outputFieldValueType,outputFieldProperties...> outputFieldViewType;
142  typedef Kokkos::DynRankView<inputDataValueType,inputDataProperties...> inputDataViewType;
143  typedef Kokkos::DynRankView<inputFieldValueType,inputFieldProperties...> inputFieldViewType;
144 
145  using range_policy_type = Kokkos::MDRangePolicy
146  < ExecSpaceType, Kokkos::Rank<3>, Kokkos::IndexType<ordinal_type> >;
147 
148  const range_policy_type policy( { 0, 0, 0 },
149  { /*C*/ outputFields.extent(0), /*F*/ outputFields.extent(1), /*P*/ outputFields.extent(2) } );
150 
151  const bool equalRank = ( outputFields.rank() == inputFields.rank() );
152  if (equalRank)
153  if (reciprocal) {
154  typedef FunctorArrayTools::F_scalarMultiply<outputFieldViewType,inputDataViewType,inputFieldViewType,true,true> FunctorType;
155  Kokkos::parallel_for( policy, FunctorType(outputFields, inputData, inputFields) );
156  } else {
157  typedef FunctorArrayTools::F_scalarMultiply<outputFieldViewType,inputDataViewType,inputFieldViewType,true,false> FunctorType;
158  Kokkos::parallel_for( policy, FunctorType(outputFields, inputData, inputFields) );
159  }
160  else
161  if (reciprocal) {
162  typedef FunctorArrayTools::F_scalarMultiply<outputFieldViewType,inputDataViewType,inputFieldViewType,false,true> FunctorType;
163  Kokkos::parallel_for( policy, FunctorType(outputFields, inputData, inputFields) );
164  } else {
165  typedef FunctorArrayTools::F_scalarMultiply<outputFieldViewType,inputDataViewType,inputFieldViewType,false,false> FunctorType;
166  Kokkos::parallel_for( policy, FunctorType(outputFields, inputData, inputFields) );
167  }
168  }
169 
170 
171  template<typename DeviceType>
172  template<typename outputDataValueType, class ...outputDataProperties,
173  typename inputDataLeftValueType, class ...inputDataLeftProperties,
174  typename inputDataRightValueType, class ...inputDataRightProperties>
175  void
176  ArrayTools<DeviceType>::
177  scalarMultiplyDataData( Kokkos::DynRankView<outputDataValueType, outputDataProperties...> outputData,
178  const Kokkos::DynRankView<inputDataLeftValueType, inputDataLeftProperties...> inputDataLeft,
179  const Kokkos::DynRankView<inputDataRightValueType,inputDataRightProperties...> inputDataRight,
180  const bool reciprocal ) {
181 
182 #ifdef HAVE_INTREPID2_DEBUG
183  {
184  INTREPID2_TEST_FOR_EXCEPTION( inputDataLeft.rank() != 2, std::invalid_argument,
185  ">>> ERROR (ArrayTools::scalarMultiplyDataData): Left input data container must have rank 2.");
186 
187  if (outputData.rank() <= inputDataRight.rank()) {
188  INTREPID2_TEST_FOR_EXCEPTION( inputDataRight.rank() < 2 || inputDataRight.rank() > 4, std::invalid_argument,
189  ">>> ERROR (ArrayTools::scalarMultiplyDataData): Right input data container must have rank 2, 3, or 4.");
190  INTREPID2_TEST_FOR_EXCEPTION( outputData.rank() != inputDataRight.rank(), std::invalid_argument,
191  ">>> ERROR (ArrayTools::scalarMultiplyDataData): Right input and output data containers must have the same rank.");
192  INTREPID2_TEST_FOR_EXCEPTION( inputDataRight.extent(0) != inputDataLeft.extent(0), std::invalid_argument,
193  ">>> ERROR (ArrayTools::scalarMultiplyDataData): Zeroth dimensions (number of integration domains) of the left and right data input containers must agree!");
194  INTREPID2_TEST_FOR_EXCEPTION( inputDataLeft.extent(1) != inputDataRight.extent(1) &&
195  inputDataLeft.extent(1) != 1, std::invalid_argument,
196  ">>> ERROR (ArrayTools::scalarMultiplyDataData): First dimensions of the left and right data input containers (number of integration points) must agree, or first dimension of the left data input container must be 1!");
197  for (size_type i=0;i<inputDataRight.rank();++i) {
198  INTREPID2_TEST_FOR_EXCEPTION( inputDataRight.extent(i) != outputData.extent(i), std::invalid_argument,
199  ">>> ERROR (ArrayTools::scalarMultiplyDataData): inputDataRight dimension (i) does not match to the dimension (i) of outputData");
200  }
201  } else {
202  INTREPID2_TEST_FOR_EXCEPTION( inputDataRight.rank() < 1 || inputDataRight.rank() > 3, std::invalid_argument,
203  ">>> ERROR (ArrayTools::scalarMultiplyDataData): Right input data container must have rank 1, 2, or 3.");
204  INTREPID2_TEST_FOR_EXCEPTION( outputData.rank() != (inputDataRight.rank()+1), std::invalid_argument,
205  ">>> ERROR (ArrayTools::scalarMultiplyDataData): The rank of the right input data container must be one less than the rank of the output data container.");
206  INTREPID2_TEST_FOR_EXCEPTION( inputDataLeft.extent(1) != inputDataRight.extent(0) &&
207  inputDataLeft.extent(1) != 1, std::invalid_argument,
208  ">>> ERROR (ArrayTools::scalarMultiplyDataData): Zeroth dimension of the right input data container and first dimension of the left data input container (number of integration points) must agree or first dimension of the left data input container must be 1!");
209  INTREPID2_TEST_FOR_EXCEPTION( inputDataLeft.extent(0) != outputData.extent(0), std::invalid_argument,
210  ">>> ERROR (ArrayTools::scalarMultiplyDataData): Zeroth dimensions of data output and left data input containers (number of integration domains) must agree!");
211  for (size_type i=0;i<inputDataRight.rank();++i) {
212  INTREPID2_TEST_FOR_EXCEPTION( inputDataRight.extent(i) != outputData.extent(i+1), std::invalid_argument,
213  ">>> ERROR (ArrayTools::scalarMultiplyDataData): inputDataRight dimension (i) does not match to the dimension (i+1) of outputData");
214  }
215  }
216  }
217 #endif
218 
219  typedef Kokkos::DynRankView<outputDataValueType,outputDataProperties...> outputDataViewType;
220  typedef Kokkos::DynRankView<inputDataLeftValueType,inputDataLeftProperties...> inputDataLeftViewType;
221  typedef Kokkos::DynRankView<inputDataRightValueType,inputDataRightProperties...> inputDataRightViewType;
222 
223  using range_policy_type = Kokkos::MDRangePolicy
224  < ExecSpaceType, Kokkos::Rank<2>, Kokkos::IndexType<ordinal_type> >;
225 
226  const range_policy_type policy( { 0, 0 },
227  { /*C*/ outputData.extent(0), /*P*/ outputData.extent(1) } );
228 
229  const bool equalRank = ( outputData.rank() == inputDataRight.rank() );
230  if (equalRank)
231  if (reciprocal) {
232  typedef FunctorArrayTools::F_scalarMultiply<outputDataViewType,inputDataLeftViewType,inputDataRightViewType,true,true> FunctorType;
233  Kokkos::parallel_for( policy, FunctorType(outputData, inputDataLeft, inputDataRight) );
234  } else {
235  typedef FunctorArrayTools::F_scalarMultiply<outputDataViewType,inputDataLeftViewType,inputDataRightViewType,true,false> FunctorType;
236  Kokkos::parallel_for( policy, FunctorType(outputData, inputDataLeft, inputDataRight) );
237  }
238  else
239  if (reciprocal) {
240  typedef FunctorArrayTools::F_scalarMultiply<outputDataViewType,inputDataLeftViewType,inputDataRightViewType,false,true> FunctorType;
241  Kokkos::parallel_for( policy, FunctorType(outputData, inputDataLeft, inputDataRight) );
242  } else {
243  typedef FunctorArrayTools::F_scalarMultiply<outputDataViewType,inputDataLeftViewType,inputDataRightViewType,false,false> FunctorType;
244  Kokkos::parallel_for( policy, FunctorType(outputData, inputDataLeft, inputDataRight) );
245  }
246  }
247 
248 } // end namespace Intrepid2
249 
250 #endif
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:177
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:98
Intrepid2::FunctorArrayTools::F_scalarMultiply
Functor for scalarMultiply see Intrepid2::ArrayTools for more.
Definition: Intrepid2_ArrayToolsDefScalar.hpp:30
Generated by   doxygen 1.8.5