fix: Restart files contain incorrect types for ArrayOfArrays

.integrated_tests.yaml

@@ -1,6 +1,6 @@
 baselines:
   bucket: geosx
-  baseline: integratedTests/baseline_integratedTests-pr3372-8610-4b9a7b3
+  baseline: integratedTests/baseline_integratedTests-pr3434-8609-327b5b9
 
 allow_fail:
   all: ''

BASELINE_NOTES.md

@@ -6,6 +6,10 @@ This file is designed to track changes to the integrated test baselines.
 Any developer who updates the baseline ID in the .integrated_tests.yaml file is expected to create an entry in this file with the pull request number, date, and their justification for rebaselining.
 These notes should be in reverse-chronological order, and use the following time format: (YYYY-MM-DD).
 
+PR #3434 (2024-11-09)
+=====================
+Bugfix: Fixed output of ArrayOfArray objects to restart files.
+
 PR #3372 (2024-11-09)
 ====================
 Fix a bug related to mass and energy updates for poromechanics.

src/coreComponents/dataRepository/wrapperHelpers.hpp

@@ -490,6 +490,112 @@
   std::memcpy( var.data(), valuesNode.data_ptr(), numBytesFromArray );
 }
 
+
+
+template< typename T, typename INDEX_TYPE >
+std::enable_if_t< bufferOps::can_memcpy< T > >
+pushDataToConduitNode( ArrayOfArrays< T, INDEX_TYPE > const & var2,
+                       conduit::Node & node )
+{
+  ArrayOfArraysView< T const, INDEX_TYPE > const & var = var2.toViewConst();
+  internal::logOutputType( LvArray::system::demangleType( var ), "Output array via external pointer: " );
+
+  // ArrayOfArrays::m_numArrays
+  INDEX_TYPE const numArrays = var.size();
+  conduit::DataType const numArraysType( conduitTypeInfo< INDEX_TYPE >::id, 1 );
+  node[ "__numberOfArrays__" ].set( numArraysType, const_cast< void * >( static_cast< void const * >(&numArrays) ) );
+
+  // ArrayOfArrays::m_offsets
+  INDEX_TYPE const * const offsets = var.getOffsets();
+  conduit::DataType const offsetsType( conduitTypeInfo< INDEX_TYPE >::id, numArrays+1 );
+  node[ "__offsets__" ].set_external( offsetsType, const_cast< void * >( static_cast< void const * >( offsets ) ) );
+
+  // ArrayOfArrays::m_sizes
+  INDEX_TYPE const * const sizes = var.getSizes();
+  conduit::DataType const sizesType( conduitTypeInfo< INDEX_TYPE >::id, numArrays );
+  node[ "__sizes__" ].set_external( sizesType, const_cast< void * >( static_cast< void const * >( sizes ) ) );
+
+  // Push the data into conduit
+  constexpr int conduitTypeID = conduitTypeInfo< T >::id;
+  constexpr int sizeofConduitType = conduitTypeInfo< T >::sizeOfConduitType;
+  conduit::DataType const dtype( conduitTypeID, offsets[numArrays] * sizeof( T ) / sizeofConduitType );
+  void * const ptr = const_cast< void * >( static_cast< void const * >( var.getValues() ) );
+  node[ "__values__" ].set_external( dtype, ptr );
+}
+
+template< typename T, typename INDEX_TYPE >
+std::enable_if_t< bufferOps::can_memcpy< T > >
+pullDataFromConduitNode( ArrayOfArrays< T, INDEX_TYPE > & var,
+                         conduit::Node const & node )
+{
+
+  // numArrays node
+  conduit::Node const & numArraysNode = node.fetch_existing( "__numberOfArrays__" );
+  INDEX_TYPE const * const numArrays = numArraysNode.value();
+
+  // offsets node
+  conduit::Node const & offsetsNode = node.fetch_existing( "__offsets__" );
+  conduit::DataType const & offsetsDataType = offsetsNode.dtype();
+  INDEX_TYPE const * const offsets = offsetsNode.value();
+  INDEX_TYPE const sizeOffsets = offsetsDataType.number_of_elements();
+
+  // sizes node
+  conduit::Node const & sizesNode = node.fetch_existing( "__sizes__" );
+  conduit::DataType const & sizesDataType = sizesNode.dtype();
+  INDEX_TYPE const * const sizes = sizesNode.value();
+  INDEX_TYPE const sizeSizes = sizesDataType.number_of_elements();
+
+  // Check that the numArrays, sizes and offsets are consistent.
+  GEOS_ERROR_IF_NE( *numArrays, sizeSizes );
+  GEOS_ERROR_IF_NE( *numArrays+1, sizeOffsets );
+
+  // values node
+  conduit::Node const & valuesNode = node.fetch_existing( "__values__" );
+  conduit::DataType const & valuesDataType = valuesNode.dtype();
+  const INDEX_TYPE valuesSize = valuesDataType.number_of_elements();
+
+  // resize var with estimated sizes
+  var.resize( *numArrays, valuesSize/(*numArrays) );
+
+  // correctly set the sizes and capacities of each sub-array
+  localIndex allocatedSize = 0;
+  for( INDEX_TYPE i = 0; i < *numArrays; ++i )
+  {
+    INDEX_TYPE const arrayAllocation = offsets[i+1] - offsets[i];
+    var.setCapacityOfArray( i, arrayAllocation );
+    var.resizeArray( i, sizes[ i ] );
+    allocatedSize += arrayAllocation;
+  }
+
+  // make sure that the allocated size is the same as the number of values read
+  GEOS_ERROR_IF_NE( valuesSize, allocatedSize );
+
+  // make sure the allocatedSize is consistent wit the last offset
+  GEOS_ERROR_IF_NE( allocatedSize, offsets[sizeOffsets-1] );
+
+  // get a view because the ArrayOfArraysView data accessors are protected
+  ArrayOfArraysView< T const, INDEX_TYPE > const & varView = var.toViewConst();
+  INDEX_TYPE const * const varOffsets = varView.getOffsets();
+  INDEX_TYPE const * const varSizes = varView.getSizes();
+
+  // check that the offsets that are read are the same as the ones that were allocated
+  GEOS_ERROR_IF_NE( varOffsets[0], offsets[0] );
+
+  // check each subarray has the identical capacity and size
+  for( INDEX_TYPE i = 0; i<*numArrays; ++i )
+  {
+    GEOS_ERROR_IF_NE( varOffsets[i+1], offsets[i+1] );
+    GEOS_ERROR_IF_NE( varSizes[i], sizes[i] );
+  }
+
+  // copy the values
+  localIndex numBytesFromArray =  allocatedSize * sizeof( T );
+  GEOS_ERROR_IF_NE( numBytesFromArray, valuesDataType.strided_bytes() );
+  std::memcpy( &var( 0, 0 ), valuesNode.data_ptr(), numBytesFromArray );
+}
+
+
+
 template< typename T >
 void pushDataToConduitNode( InterObjectRelation< T > const & var,
                             conduit::Node & node )