GEOS
CoupledReservoirAndWellKernels.hpp
1 /*
2  * ------------------------------------------------------------------------------------------------------------
3  * SPDX-License-Identifier: LGPL-2.1-only
4  *
5  * Copyright (c) 2016-2024 Lawrence Livermore National Security LLC
6  * Copyright (c) 2018-2024 TotalEnergies
7  * Copyright (c) 2018-2024 The Board of Trustees of the Leland Stanford Junior University
8  * Copyright (c) 2023-2024 Chevron
9  * Copyright (c) 2019- GEOS/GEOSX Contributors
10  * All rights reserved
11  *
12  * See top level LICENSE, COPYRIGHT, CONTRIBUTORS, NOTICE, and ACKNOWLEDGEMENTS files for details.
13  * ------------------------------------------------------------------------------------------------------------
14  */
15 
20 #ifndef GEOS_PHYSICSSOLVERS_MULTIPHYSICS_COUPLEDRESERVOIRANDWELLS_HPP
21 #define GEOS_PHYSICSSOLVERS_MULTIPHYSICS_COUPLEDRESERVOIRANDWELLS_HPP
22 
23 
24 #include "common/DataTypes.hpp"
25 #include "common/GEOS_RAJA_Interface.hpp"
26 #include "constitutive/fluid/multifluid/Layouts.hpp"
31 namespace geos
32 {
33 
34 namespace coupledReservoirAndWellKernels
35 {
36 
37 using namespace constitutive;
38 
44 template< integer NC, integer IS_THERMAL >
46 {
47 public:
48 
50  static constexpr integer numComp = NC;
51  static constexpr integer resNumDOF = NC+1+IS_THERMAL;
52 
53  // Well jacobian column and row indicies
56 
59 
60  using CP_Deriv = multifluid::DerivativeOffsetC< NC, IS_THERMAL >;
61 
63 
64 
65 
67  static constexpr integer numDof = WJ_COFFSET::nDer;
68 
70  static constexpr integer numEqn = WJ_ROFFSET::nEqn - 2;
71 
87  globalIndex const rankOffset,
88  string const wellDofKey,
89  WellElementSubRegion const & subRegion,
91  PerforationData const * const perforationData,
92  MultiFluidBase const & fluid,
93 
94  arrayView1d< real64 > const & localRhs,
96  bool const & detectCrossflow,
97  integer & numCrossFlowPerforations,
98  BitFlags< isothermalCompositionalMultiphaseBaseKernels::KernelFlags > kernelFlags )
99  :
100  m_dt( dt ),
101  m_numPhases ( fluid.numFluidPhases()),
102  m_rankOffset( rankOffset ),
103  m_compPerfRate( perforationData->getField< fields::well::compPerforationRate >() ),
104  m_dCompPerfRate( perforationData->getField< fields::well::dCompPerforationRate >() ),
105  m_perfWellElemIndex( perforationData->getField< fields::perforation::wellElementIndex >() ),
106  m_perfStatus( perforationData->getField< fields::perforation::perforationStatus >() ),
107  m_wellElemDofNumber( subRegion.getReference< array1d< globalIndex > >( wellDofKey ) ),
108  m_resElemDofNumber( resDofNumber ),
109  m_resElementRegion( perforationData->getField< fields::perforation::reservoirElementRegion >() ),
110  m_resElementSubRegion( perforationData->getField< fields::perforation::reservoirElementSubRegion >() ),
111  m_resElementIndex( perforationData->getField< fields::perforation::reservoirElementIndex >() ),
112  m_localRhs( localRhs ),
113  m_localMatrix( localMatrix ),
114  m_detectCrossflow( detectCrossflow ),
115  m_numCrossFlowPerforations( numCrossFlowPerforations ),
116  m_useTotalMassEquation ( kernelFlags.isSet( isothermalCompositionalMultiphaseBaseKernels::KernelFlags::TotalMassEquation ) )
117  { }
118 
119 
128  template< typename FUNC = NoOpFunc >
130  inline
131  void computeFlux( localIndex const iperf,
132  FUNC && compFluxKernelOp = NoOpFunc{} ) const
133  {
134 
135  using namespace compositionalMultiphaseUtilities;
136  if( m_perfStatus[iperf ] )
137  {
138  // local working variables and arrays
139  stackArray1d< localIndex, 2* numComp > eqnRowIndices( 2 * numComp );
140  stackArray1d< globalIndex, 2*resNumDOF > dofColIndices( 2 * resNumDOF );
141 
142  stackArray1d< real64, 2 * numComp > localPerf( 2 * numComp );
143  stackArray2d< real64, 2 * resNumDOF * 2 * numComp > localPerfJacobian( 2 * numComp, 2 * resNumDOF );
144 
145  // get the reservoir (sub)region and element indices
146  localIndex const er = m_resElementRegion[iperf];
147  localIndex const esr = m_resElementSubRegion[iperf];
148  localIndex const ei = m_resElementIndex[iperf];
149 
150  // get the well element index for this perforation
151  localIndex const iwelem = m_perfWellElemIndex[iperf];
152  globalIndex const resOffset = m_resElemDofNumber[er][esr][ei];
153  globalIndex const wellElemOffset = m_wellElemDofNumber[iwelem];
154 
155  for( integer ic = 0; ic < numComp; ++ic )
156  {
157  eqnRowIndices[TAG::RES * numComp + ic] = LvArray::integerConversion< localIndex >( resOffset - m_rankOffset ) + ic;
158  eqnRowIndices[TAG::WELL * numComp + ic] = LvArray::integerConversion< localIndex >( wellElemOffset - m_rankOffset ) + WJ_ROFFSET::MASSBAL + ic;
159  }
160  // Note res and well have same col lineup for P and compdens
161  for( integer jdof = 0; jdof < NC+1; ++jdof )
162  {
163  dofColIndices[TAG::RES * resNumDOF + jdof] = resOffset + jdof;
164  dofColIndices[TAG::WELL * resNumDOF + jdof] = wellElemOffset + WJ_COFFSET::dP + jdof;
165  }
166  // For temp its different
167  if constexpr ( IS_THERMAL )
168  {
169  dofColIndices[TAG::RES * resNumDOF + NC+1 ] = resOffset + NC+1;
170  dofColIndices[TAG::WELL * resNumDOF + NC+1 ] = wellElemOffset + WJ_COFFSET::dT;
171  }
172  // populate local flux vector and derivatives
173  for( integer ic = 0; ic < numComp; ++ic )
174  {
175  localPerf[TAG::RES * numComp + ic] = m_dt * m_compPerfRate[iperf][ic];
176  localPerf[TAG::WELL * numComp + ic] = -m_dt * m_compPerfRate[iperf][ic];
177 
178  if( m_detectCrossflow )
179  {
180  if( m_compPerfRate[iperf][ic] > LvArray::NumericLimits< real64 >::epsilon )
181  {
182  m_numCrossFlowPerforations += 1;
183  }
184  }
185  for( integer ke = 0; ke < 2; ++ke )
186  {
187  localIndex localDofIndexPres = ke * resNumDOF;
188 
189  localPerfJacobian[TAG::RES * numComp + ic][localDofIndexPres] = m_dt * m_dCompPerfRate[iperf][ke][ic][CP_Deriv::dP];
190  localPerfJacobian[TAG::WELL * numComp + ic][localDofIndexPres] = -m_dt * m_dCompPerfRate[iperf][ke][ic][CP_Deriv::dP];
191  for( integer jc = 0; jc < numComp; ++jc )
192  {
193  localIndex const localDofIndexComp = localDofIndexPres + jc + 1;
194 
195  localPerfJacobian[TAG::RES * numComp + ic][localDofIndexComp] = m_dt * m_dCompPerfRate[iperf][ke][ic][CP_Deriv::dC+jc];
196  localPerfJacobian[TAG::WELL * numComp + ic][localDofIndexComp] = -m_dt * m_dCompPerfRate[iperf][ke][ic][CP_Deriv::dC+jc];
197  }
198  if constexpr ( IS_THERMAL )
199  {
200  localIndex localDofIndexTemp = localDofIndexPres + NC + 1;
201  localPerfJacobian[TAG::RES * numComp + ic][localDofIndexTemp] = m_dt * m_dCompPerfRate[iperf][ke][ic][CP_Deriv::dT];
202  localPerfJacobian[TAG::WELL * numComp + ic][localDofIndexTemp] = -m_dt * m_dCompPerfRate[iperf][ke][ic][CP_Deriv::dT];
203  }
204  }
205  }
206 
207  if( m_useTotalMassEquation )
208  {
209  // Apply equation/variable change transformation(s)
210  stackArray1d< real64, 2 * resNumDOF > work( 2 * resNumDOF );
211  shiftBlockRowsAheadByOneAndReplaceFirstRowWithColumnSum( numComp, numComp, resNumDOF * 2, 2, localPerfJacobian, work );
212  shiftBlockElementsAheadByOneAndReplaceFirstElementWithSum( numComp, numComp, 2, localPerf );
213  }
214 
215  for( localIndex i = 0; i < localPerf.size(); ++i )
216  {
217  if( eqnRowIndices[i] >= 0 && eqnRowIndices[i] < m_localMatrix.numRows() )
218  {
219  m_localMatrix.addToRowBinarySearchUnsorted< parallelDeviceAtomic >( eqnRowIndices[i],
220  dofColIndices.data(),
221  localPerfJacobian[i].dataIfContiguous(),
222  2 * resNumDOF );
223  RAJA::atomicAdd( parallelDeviceAtomic{}, &m_localRhs[eqnRowIndices[i]], localPerf[i] );
224  }
225  }
226  compFluxKernelOp( resOffset, wellElemOffset, dofColIndices, iwelem );
227  }
228  }
229 
230 
239  template< typename POLICY, typename KERNEL_TYPE >
240  static void
241  launch( localIndex const numElements,
242  KERNEL_TYPE const & kernelComponent )
243  {
245  forAll< POLICY >( numElements, [=] GEOS_HOST_DEVICE ( localIndex const ie )
246  {
247  kernelComponent.computeFlux( ie );
248 
249  } );
250  }
251 
252 protected:
253 
255  real64 const m_dt;
256 
259 
260  globalIndex const m_rankOffset;
261  // Perfoation variables
262  arrayView2d< real64 const > const m_compPerfRate;
263  arrayView4d< real64 const > const m_dCompPerfRate;
264  arrayView1d< localIndex const > const m_perfWellElemIndex;
265  arrayView1d< integer const > const m_perfStatus;
266  // Element region, subregion, index
267  arrayView1d< globalIndex const > const m_wellElemDofNumber;
269  arrayView1d< localIndex const > const m_resElementRegion;
270  arrayView1d< localIndex const > const m_resElementSubRegion;
271  arrayView1d< localIndex const > const m_resElementIndex;
272 
273  // RHS and Jacobian
274  arrayView1d< real64 > const m_localRhs;
276 
277  bool const m_detectCrossflow;
278  integer & m_numCrossFlowPerforations;
279  integer const m_useTotalMassEquation;
280 };
281 
286 {
287 public:
288 
302  template< typename POLICY >
303  static void
304  createAndLaunch( integer const numComps,
305  real64 const dt,
306  globalIndex const rankOffset,
307  string const wellDofKey,
308  WellElementSubRegion const & subRegion,
310  PerforationData const * const perforationData,
311  MultiFluidBase const & fluid,
312  BitFlags< isothermalCompositionalMultiphaseBaseKernels::KernelFlags > kernelFlags,
313  bool const & detectCrossflow,
314  integer & numCrossFlowPerforations,
315  arrayView1d< real64 > const & localRhs,
317  )
318  {
319  isothermalCompositionalMultiphaseBaseKernels::internal::kernelLaunchSelectorCompSwitch( numComps, [&]( auto NC )
320  {
321  integer constexpr NUM_COMP = NC();
322 
324  kernelType kernel( dt, rankOffset, wellDofKey, subRegion, resDofNumber, perforationData,
325  fluid, localRhs, localMatrix, detectCrossflow, numCrossFlowPerforations, kernelFlags );
326  kernelType::template launch< POLICY >( perforationData->size(), kernel );
327  } );
328 
329  }
330 };
331 
332 
338 template< integer NC, integer IS_THERMAL >
340 {
341 public:
344  static constexpr integer numComp = NC;
345  static constexpr integer resNumDOF = NC+1+IS_THERMAL;
346 
347  // Well jacobian column and row indicies
350 
353 
354  using CP_Deriv = multifluid::DerivativeOffsetC< NC, IS_THERMAL >;
355 
357 
358  using Base::m_dt;
359  using Base::m_localRhs;
360  using Base::m_localMatrix;
361  using Base::m_rankOffset;
362 
363 
364 
366  static constexpr integer numDof = WJ_COFFSET::nDer;
367 
369  static constexpr integer numEqn = WJ_ROFFSET::nEqn - 2;
370 
386  integer const isProducer,
387  globalIndex const rankOffset,
388  string const wellDofKey,
389  WellElementSubRegion const & subRegion,
391  PerforationData const * const perforationData,
392  MultiFluidBase const & fluid,
393  arrayView1d< real64 > const & localRhs,
394  CRSMatrixView< real64, globalIndex const > const & localMatrix,
395  bool const & detectCrossflow,
396  integer & numCrossFlowPerforations,
397  BitFlags< isothermalCompositionalMultiphaseBaseKernels::KernelFlags > kernelFlags )
398  : Base( dt,
399  rankOffset,
400  wellDofKey,
401  subRegion,
402  resDofNumber,
403  perforationData,
404  fluid,
405  localRhs,
406  localMatrix,
407  detectCrossflow,
408  numCrossFlowPerforations,
409  kernelFlags ),
410  m_isProducer( isProducer ),
411  m_globalWellElementIndex( subRegion.getGlobalWellElementIndex() ),
412  m_energyPerfFlux( perforationData->getField< fields::well::energyPerforationFlux >()),
413  m_dEnergyPerfFlux( perforationData->getField< fields::well::dEnergyPerforationFlux >())
414 
415  { }
416 
417 
427  inline
428  void computeFlux( localIndex const iperf ) const
429  {
430  Base::computeFlux( iperf, [&] ( globalIndex const & resOffset,
431  globalIndex const & wellElemOffset,
433  localIndex const iwelem )
434  {
435  // No energy equation if top element and Injector
436  // Top element defined by global index == 0
437  // Assumption is global index == 0 is top segment with fixed temp BC
438  if( !m_isProducer )
439  {
440  if( m_globalWellElementIndex[iwelem] == 0 )
441  return;
442  }
443  // local working variables and arrays
444  stackArray1d< localIndex, 2* numComp > eqnRowIndices( 2 );
445 
447  stackArray2d< real64, 2 * resNumDOF * 2 * numComp > localPerfJacobian( 2, 2 * resNumDOF );
448 
449 
450  // equantion offsets - note res and well have different equation lineups
451  eqnRowIndices[TAG::RES ] = LvArray::integerConversion< localIndex >( resOffset - m_rankOffset ) + NC + 1;
452  eqnRowIndices[TAG::WELL ] = LvArray::integerConversion< localIndex >( wellElemOffset - m_rankOffset ) + WJ_ROFFSET::ENERGYBAL;
453 
454  // populate local flux vector and derivatives
455  localPerf[TAG::RES ] = m_dt * m_energyPerfFlux[iperf];
456  localPerf[TAG::WELL ] = -m_dt * m_energyPerfFlux[iperf];
457 
458  for( integer ke = 0; ke < 2; ++ke )
459  {
460  localIndex localDofIndexPres = ke * resNumDOF;
461  localPerfJacobian[TAG::RES ][localDofIndexPres] = m_dt * m_dEnergyPerfFlux[iperf][ke][CP_Deriv::dP];
462  localPerfJacobian[TAG::WELL ][localDofIndexPres] = -m_dt * m_dEnergyPerfFlux[iperf][ke][CP_Deriv::dP];
463 
464  // populate local flux vector and derivatives
465  for( integer ic = 0; ic < numComp; ++ic )
466  {
467  localIndex const localDofIndexComp = localDofIndexPres + ic + 1;
468  localPerfJacobian[TAG::RES ][localDofIndexComp] = m_dt * m_dEnergyPerfFlux[iperf][ke][CP_Deriv::dC+ic];
469  localPerfJacobian[TAG::WELL][localDofIndexComp] = -m_dt * m_dEnergyPerfFlux[iperf][ke][CP_Deriv::dC+ic];
470  }
471  localPerfJacobian[TAG::RES ][localDofIndexPres+NC+1] = m_dt * m_dEnergyPerfFlux[iperf][ke][CP_Deriv::dT];
472  localPerfJacobian[TAG::WELL][localDofIndexPres+NC+1] = -m_dt * m_dEnergyPerfFlux[iperf][ke][CP_Deriv::dT];
473  }
474 
475 
476  for( localIndex i = 0; i < localPerf.size(); ++i )
477  {
478  if( eqnRowIndices[i] >= 0 && eqnRowIndices[i] < m_localMatrix.numRows() )
479  {
480  m_localMatrix.template addToRowBinarySearchUnsorted< parallelDeviceAtomic >( eqnRowIndices[i],
481  dofColIndices.data(),
482  localPerfJacobian[i].dataIfContiguous(),
483  2 * resNumDOF );
484  RAJA::atomicAdd( parallelDeviceAtomic{}, &m_localRhs[eqnRowIndices[i]], localPerf[i] );
485  }
486  }
487  } );
488  }
489 
490 
499  template< typename POLICY, typename KERNEL_TYPE >
500  static void
501  launch( localIndex const numElements,
502  KERNEL_TYPE const & kernelComponent )
503  {
505  forAll< POLICY >( numElements, [=] GEOS_HOST_DEVICE ( localIndex const ie )
506  {
507  kernelComponent.computeFlux( ie );
508 
509  } );
510  }
511 
512 protected:
513 
516 
519 
522  arrayView3d< real64 const > const m_dEnergyPerfFlux;
523 };
524 
529 {
530 public:
531 
545  template< typename POLICY >
546  static void
547  createAndLaunch( integer const numComps,
548  integer const isProducer,
549  real64 const dt,
550  globalIndex const rankOffset,
551  string const wellDofKey,
552  WellElementSubRegion const & subRegion,
554  PerforationData const * const perforationData,
555  MultiFluidBase const & fluid,
556  BitFlags< isothermalCompositionalMultiphaseBaseKernels::KernelFlags > kernelFlags,
557  bool const & detectCrossflow,
558  integer & numCrossFlowPerforations,
559  arrayView1d< real64 > const & localRhs,
561  )
562  {
563  isothermalCompositionalMultiphaseBaseKernels::internal::kernelLaunchSelectorCompSwitch( numComps, [&]( auto NC )
564  {
565  integer constexpr NUM_COMP = NC();
566 
568  kernelType kernel( dt, isProducer, rankOffset, wellDofKey, subRegion, resDofNumber, perforationData,
569  fluid, localRhs, localMatrix, detectCrossflow, numCrossFlowPerforations, kernelFlags );
570  kernelType::template launch< POLICY >( perforationData->size(), kernel );
571  } );
572 
573  }
574 };
575 
576 } // end namespace coupledReservoirAndWellKernels
577 
578 } // end namespace geos
579 
580 #endif // GEOS_PHYSICSSOLVERS_MULTIPHYSICS_COUPLEDRESERVOIRANDWELLS_HPP
GEOS_HOST_DEVICE void shiftBlockRowsAheadByOneAndReplaceFirstRowWithColumnSum(integer const numRowsToShift, integer const numRowsInBlock, integer const numColsInBlock, integer const numBlocks, MATRIX &&mat, VEC &&work)
In each block, shift the elements from 0 to numRowsToShift-1, shifts all rows one position ahead and ...
GEOS_HOST_DEVICE void shiftBlockElementsAheadByOneAndReplaceFirstElementWithSum(integer const numRowsToShift, integer const numRowsInBlock, integer const numBlocks, VEC &&v)
In each block, shift the elements from 0 to numRowsToShift-1 one position ahead and replaces the firs...
#define GEOS_HOST_DEVICE
Marks a host-device function.
Definition: GeosxMacros.hpp:49
#define GEOS_MARK_FUNCTION
Mark function with both Caliper and NVTX if enabled.
typename ElementViewAccessor< VIEWTYPE >::NestedViewTypeConst ElementViewConst
The ElementViewAccessor at the ElementRegionManager level is the type resulting from ElementViewAcces...
This class describes a collection of local well elements and perforations.
static void createAndLaunch(integer const numComps, real64 const dt, globalIndex const rankOffset, string const wellDofKey, WellElementSubRegion const &subRegion, ElementRegionManager::ElementViewConst< arrayView1d< globalIndex const > > const resDofNumber, PerforationData const *const perforationData, MultiFluidBase const &fluid, BitFlags< isothermalCompositionalMultiphaseBaseKernels::KernelFlags > kernelFlags, bool const &detectCrossflow, integer &numCrossFlowPerforations, arrayView1d< real64 > const &localRhs, CRSMatrixView< real64, globalIndex const > const &localMatrix)
Create a new kernel and launch.
GEOS_HOST_DEVICE void computeFlux(localIndex const iperf, FUNC &&compFluxKernelOp=NoOpFunc{}) const
Compute the local flux contributions to the residual and Jacobian.
IsothermalCompositionalMultiPhaseFluxKernel(real64 const dt, globalIndex const rankOffset, string const wellDofKey, WellElementSubRegion const &subRegion, ElementRegionManager::ElementViewConst< arrayView1d< globalIndex const > > const resDofNumber, PerforationData const *const perforationData, MultiFluidBase const &fluid, arrayView1d< real64 > const &localRhs, CRSMatrixView< real64, globalIndex const > const &localMatrix, bool const &detectCrossflow, integer &numCrossFlowPerforations, BitFlags< isothermalCompositionalMultiphaseBaseKernels::KernelFlags > kernelFlags)
Constructor for the kernel interface.
static void launch(localIndex const numElements, KERNEL_TYPE const &kernelComponent)
Performs the kernel launch.
static void createAndLaunch(integer const numComps, integer const isProducer, real64 const dt, globalIndex const rankOffset, string const wellDofKey, WellElementSubRegion const &subRegion, ElementRegionManager::ElementViewConst< arrayView1d< globalIndex const > > const resDofNumber, PerforationData const *const perforationData, MultiFluidBase const &fluid, BitFlags< isothermalCompositionalMultiphaseBaseKernels::KernelFlags > kernelFlags, bool const &detectCrossflow, integer &numCrossFlowPerforations, arrayView1d< real64 > const &localRhs, CRSMatrixView< real64, globalIndex const > const &localMatrix)
Create a new kernel and launch.
GEOS_HOST_DEVICE void computeFlux(localIndex const iperf) const
Compute the local flux contributions to the residual and Jacobian.
ThermalCompositionalMultiPhaseFluxKernel(real64 const dt, integer const isProducer, globalIndex const rankOffset, string const wellDofKey, WellElementSubRegion const &subRegion, ElementRegionManager::ElementViewConst< arrayView1d< globalIndex const > > const resDofNumber, PerforationData const *const perforationData, MultiFluidBase const &fluid, arrayView1d< real64 > const &localRhs, CRSMatrixView< real64, globalIndex const > const &localMatrix, bool const &detectCrossflow, integer &numCrossFlowPerforations, BitFlags< isothermalCompositionalMultiphaseBaseKernels::KernelFlags > kernelFlags)
Constructor for the kernel interface.
static void launch(localIndex const numElements, KERNEL_TYPE const &kernelComponent)
Performs the kernel launch.
arrayView1d< globalIndex const > m_globalWellElementIndex
Global index of local element.
localIndex size() const
Get the "size" of the group, which determines the number of elements in resizable wrappers.
Definition: Group.hpp:1317
ArrayView< T, 1 > arrayView1d
Alias for 1D array view.
Definition: DataTypes.hpp:179
StackArray< T, 2, MAXSIZE > stackArray2d
Alias for 2D stack array.
Definition: DataTypes.hpp:203
GEOS_GLOBALINDEX_TYPE globalIndex
Global index type (for indexing objects across MPI partitions).
Definition: DataTypes.hpp:87
StackArray< T, 1, MAXSIZE > stackArray1d
Alias for 1D stack array.
Definition: DataTypes.hpp:187
double real64
64-bit floating point type.
Definition: DataTypes.hpp:98
GEOS_LOCALINDEX_TYPE localIndex
Local index type (for indexing objects within an MPI partition).
Definition: DataTypes.hpp:84
LvArray::CRSMatrixView< T, COL_INDEX, INDEX_TYPE const, LvArray::ChaiBuffer > CRSMatrixView
Alias for CRS Matrix View.
Definition: DataTypes.hpp:309
ArrayView< T, 4, USD > arrayView4d
Alias for 4D array view.
Definition: DataTypes.hpp:227
ArrayView< T, 2, USD > arrayView2d
Alias for 2D array view.
Definition: DataTypes.hpp:195
int integer
Signed integer type.
Definition: DataTypes.hpp:81
Array< T, 1 > array1d
Alias for 1D array.
Definition: DataTypes.hpp:175
ArrayView< T, 3, USD > arrayView3d
Alias for 3D array view.
Definition: DataTypes.hpp:211