Filters/FlowPaths/vtkTemporalInterpolatedVelocityField.cxx

@@ -21,6 +21,8 @@
 #include "vtkStaticPointLocator.h"
 #include "vtkUnstructuredGrid.h"
 
+#include <cassert>
+
 //------------------------------------------------------------------------------
 VTK_ABI_NAMESPACE_BEGIN
 vtkStandardNewMacro(vtkTemporalInterpolatedVelocityField);
@@ -252,6 +254,8 @@ void vtkTemporalInterpolatedVelocityField::InitializeWithLocators(
   // Now initialize the new strategies
   for (size_t i = 0; i < datasets.size(); ++i)
   {
+    assert(datasets.size() == locators.size());
+
     auto& datasetInfo = ivf->DataSetsInfo[i];
     if (auto pointSet = vtkPointSet::SafeDownCast(datasetInfo.DataSet))
     {
@@ -328,6 +332,12 @@ void vtkTemporalInterpolatedVelocityField::Initialize(
   }
   else // t0 != t1
   {
+    if (this->Locators[1].size() != datasets[1].size())
+    {
+      vtkErrorMacro("Locators have not been initialized as expected, aborting");
+      return;
+    }
+
     datasets[0] = vtkCompositeDataSet::GetDataSets(t0);
     switch (this->MeshOverTime)
     {

Filters/General/Testing/Cxx/TestOverlappingAMRLevelIdScalars.cxx

 // SPDX-FileCopyrightText: Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
 // SPDX-License-Identifier: BSD-3-Clause
 
+#include "vtkAMRBox.h"
 #include "vtkCellData.h"
 #include "vtkDataArray.h"
 #include "vtkNew.h"
@@ -18,10 +19,39 @@ int TestOverlappingAMRLevelIdScalars(int, char*[])
   // Attach datasets to the AMR
   vtkNew<vtkUniformGrid> root;
   root->SetDimensions(3, 3, 3);
-  root->SetSpacing(1.0, 1.0, 1.0);
+  double spacing[3] = { 1, 1, 1 };
+  double origin[3] = { 0, 0, 0 };
+  root->SetSpacing(spacing);
+  root->SetOrigin(origin);
+  amr->SetOrigin(origin);
+
+  // AMR level 0
+  amr->SetSpacing(0, spacing);
   amr->SetDataSet(0, 0, root);
+  vtkAMRBox box(
+    root->GetOrigin(), root->GetDimensions(), spacing, origin, amr->GetGridDescription());
+  amr->SetAMRBox(0, 0, box);
+
   amr->SetDataSet(0, 1, root);
-  amr->SetDataSet(1, 0, root);
+  vtkAMRBox box1(
+    root->GetOrigin(), root->GetDimensions(), spacing, origin, amr->GetGridDescription());
+  amr->SetAMRBox(0, 1, box1);
+
+  // AMR level 1
+  spacing[0] /= 2.;
+  spacing[1] /= 2.;
+  spacing[2] /= 2.;
+  amr->SetSpacing(1, spacing);
+  vtkNew<vtkUniformGrid> block;
+  block->SetDimensions(3, 3, 3);
+  block->SetOrigin(origin);
+  block->SetSpacing(spacing);
+  amr->SetDataSet(1, 0, block);
+  vtkAMRBox box2(
+    block->GetOrigin(), block->GetDimensions(), spacing, origin, amr->GetGridDescription());
+  amr->SetAMRBox(1, 0, box2);
+
+  amr->Audit();
 
   // Apply id filter
   vtkNew<vtkOverlappingAMRLevelIdScalars> levelIdFilter;

GUISupport/Qt/QVTKRenderWindowAdapter.cxx

@@ -218,6 +218,7 @@ public:
     if (auto iren = this->RenderWindow->GetInteractor())
     {
       iren->UpdateSize(deviceSize.width(), deviceSize.height());
+      iren->InvokeEvent(vtkCommand::ConfigureEvent);
     }
     else
     {

IO/CatalystConduit/Testing/Cxx/TestConduitSource.cxx

@@ -493,6 +493,60 @@ bool CheckFieldDataMeshConversion(conduit_cpp::Node& mesh_node, int expected_num
   return true;
 }
 
+//----------------------------------------------------------------------------
+bool ValidateDistributedAMR()
+{
+  auto controller = vtkMultiProcessController::GetGlobalController();
+  auto rank = controller->GetLocalProcessId();
+
+  conduit_cpp::Node amrmesh;
+
+  auto domain = amrmesh["domain0"];
+
+  // Each rank contains a new level
+  int level = rank;
+
+  domain["state/domain_id"] = rank;
+  domain["state/cycle"] = 0;
+  domain["state/time"] = 0;
+  domain["state/level"] = level;
+
+  auto coords = domain["coordsets/coords"];
+  coords["type"] = "uniform";
+  coords["dims/i"] = 3;
+  coords["dims/j"] = 3;
+  coords["dims/k"] = 3;
+  // spacing depends on level
+  coords["spacing/dx"] = 1. / std::pow(2, level);
+  coords["spacing/dy"] = 1. / std::pow(2, level);
+  coords["spacing/dz"] = 1. / std::pow(2, level);
+  coords["origin/x"] = 0.0;
+  coords["origin/y"] = 0.0;
+  coords["origin/z"] = 0.0;
+
+  auto topo = domain["topologies/topo"];
+  topo["type"] = "uniform";
+  topo["coordset"] = "coords";
+
+  vtkNew<vtkConduitSource> source;
+  source->SetUseAMRMeshProtocol(true);
+  source->SetNode(conduit_cpp::c_node(&amrmesh));
+  source->Update();
+  auto data = source->GetOutputDataObject(0);
+
+  VERIFY(vtkOverlappingAMR::SafeDownCast(data) != nullptr,
+    "Incorrect data type, expected vtkOverlappingAMR, got %s", vtkLogIdentifier(data));
+
+  auto amr = vtkOverlappingAMR::SafeDownCast(data);
+  amr->Audit();
+  int generatedLevels = amr->GetNumberOfLevels();
+  auto nbOfProcess = controller->GetNumberOfProcesses();
+  VERIFY(generatedLevels == nbOfProcess, "Incorrect number of levels, expexts %d but has %d",
+    generatedLevels, nbOfProcess);
+
+  return true;
+}
+
 //----------------------------------------------------------------------------
 bool ValidateMeshTypeAMR(const std::string& file)
 {
@@ -1321,7 +1375,8 @@ int TestConduitSource(int argc, char** argv)
       ValidateMeshTypeStructured() && ValidateMeshTypeUnstructured() && ValidateFieldData() &&
       ValidateRectilinearGridWithDifferentDimensions() && Validate1DRectilinearGrid() &&
       ValidateMeshTypeMixed() && ValidateMeshTypeMixed2D() && ValidateMeshTypeAMR(amrFile) &&
-      ValidateAscentGhostCellData() && ValidateAscentGhostPointData() && ValidateMeshTypePoints()
+      ValidateAscentGhostCellData() && ValidateAscentGhostPointData() && ValidateMeshTypePoints() &&
+      ValidateDistributedAMR()
 
     ? EXIT_SUCCESS
     : EXIT_FAILURE;

IO/Geometry/Testing/Cxx/TestAMRReadWrite.cxx

@@ -34,8 +34,8 @@ vtkSmartPointer<vtkOverlappingAMR> CreateTestAMR(int argc, char* argv[])
 
 int TestAMRReadWrite(int argc, char* argv[])
 {
-
   vtkSmartPointer<vtkOverlappingAMR> amr = CreateTestAMR(argc, argv);
+  amr->Audit();
   vtkNew<vtkCompositeDataWriter> writer;
   writer->SetInputData(amr);
   writer->SetFileName("testamr");
@@ -47,9 +47,7 @@ int TestAMRReadWrite(int argc, char* argv[])
 
   vtkSmartPointer<vtkOverlappingAMR> amr1 =
     vtkOverlappingAMR::SafeDownCast(reader->GetOutputDataObject(0));
+  amr1->Audit();
 
-  int errors(0);
-  errors += !(*amr1->GetAMRInfo() == *amr->GetAMRInfo());
-
-  return errors;
+  return (*amr1->GetAMRInfo() == *amr->GetAMRInfo()) ? EXIT_SUCCESS : EXIT_FAILURE;
 }

IO/HDF/Testing/Cxx/TestHDFWriterTemporal.cxx

@@ -2,16 +2,27 @@
 // SPDX-License-Identifier: BSD-3-Clause
 
 #include "vtkCleanUnstructuredGrid.h"
+#include "vtkDataAssemblyUtilities.h"
+#include "vtkDataObjectTree.h"
+#include "vtkDataSet.h"
 #include "vtkExtractSurface.h"
 #include "vtkForceStaticMesh.h"
 #include "vtkGenerateTimeSteps.h"
+#include "vtkGroupDataSetsFilter.h"
 #include "vtkHDFReader.h"
 #include "vtkHDFWriter.h"
+#include "vtkInformation.h"
+#include "vtkInformationVector.h"
 #include "vtkLogger.h"
 #include "vtkNew.h"
+#include "vtkPartitionedDataSetCollection.h"
+#include "vtkPartitionedDataSetCollectionAlgorithm.h"
+#include "vtkPassArrays.h"
+#include "vtkPointData.h"
 #include "vtkPointDataToCellData.h"
 #include "vtkPolyData.h"
 #include "vtkSpatioTemporalHarmonicsSource.h"
+#include "vtkStreamingDemandDrivenPipeline.h"
 #include "vtkTestUtilities.h"
 #include "vtkTesting.h"
 #include "vtkTransform.h"
@@ -32,6 +43,35 @@ struct WriterConfigOptions
   bool UseExternalPartitions;
   std::string FileNameSuffix;
 };
+
+/**
+ * Simple filter that adds a vtkDataAssembly to a PDC that does not have one.
+ * This can be removed when vtkGroupDataSetsFilter will support generating an assembly automatically
+ * for PartitionedDataSetCollections
+ */
+class vtkAddAssembly : public vtkPartitionedDataSetCollectionAlgorithm
+{
+public:
+  static vtkAddAssembly* New();
+  vtkTypeMacro(vtkAddAssembly, vtkDataObjectAlgorithm);
+
+protected:
+  int RequestData(
+    vtkInformation* request, vtkInformationVector** inVector, vtkInformationVector* ouInfo) override
+  {
+    this->vtkPartitionedDataSetCollectionAlgorithm::RequestData(request, inVector, ouInfo);
+    auto pdc = vtkPartitionedDataSetCollection::SafeDownCast(vtkDataObject::GetData(ouInfo, 0));
+    vtkPartitionedDataSetCollection* input = vtkPartitionedDataSetCollection::SafeDownCast(
+      inVector[0]->GetInformationObject(0)->Get(vtkDataObject::DATA_OBJECT()));
+
+    vtkNew<vtkDataAssembly> hierarchy;
+    vtkDataAssemblyUtilities::GenerateHierarchy(input, hierarchy, pdc);
+    return 1;
+  }
+};
+
+vtkStandardNewMacro(vtkAddAssembly);
+
 }
 
 //----------------------------------------------------------------------------
@@ -84,13 +124,12 @@ bool TestTemporalData(const std::string& tempDir, const std::string& dataRoot,
   }
 
   // Compare the data at each timestep from both readers
-  for (int i = 0; i < totalTimeStepsXML; i++)
+  for (int step = 0; step < totalTimeStepsXML; step++)
   {
-    std::cout << "Comparing timestep " << i << std::endl;
-    HDFReaderBaseline->SetStep(i);
+    HDFReaderBaseline->SetStep(step);
     HDFReaderBaseline->Update();
 
-    HDFReader->SetStep(i);
+    HDFReader->SetStep(step);
     HDFReader->Update();
 
     // Time values must be the same
@@ -105,7 +144,7 @@ bool TestTemporalData(const std::string& tempDir, const std::string& dataRoot,
     if (!vtkTestUtilities::CompareDataObjects(
           HDFReaderBaseline->GetOutput(), HDFReader->GetOutput()))
     {
-      vtkLog(ERROR, "data objects do not match");
+      vtkLog(ERROR, << "data objects do not match for time step " << step);
       return false;
     }
   }
@@ -172,6 +211,118 @@ bool TestTemporalStaticMesh(
   return true;
 }
 
+//----------------------------------------------------------------------------
+bool TestTemporalComposite(const std::string& tempDir, const std::string& dataRoot,
+  const std::vector<std::string>& baseNames, int compositeType)
+{
+  std::vector<vtkSmartPointer<vtkHDFReader>> baselineReaders;
+  for (const auto& baseName : baseNames)
+  {
+    const std::string filePath = dataRoot + "/Data/" + baseName + ".hdf";
+    vtkNew<vtkHDFReader> baseHDFReader;
+    baseHDFReader->SetFileName(filePath.c_str());
+    baselineReaders.emplace_back(baseHDFReader);
+  }
+
+  // Create a composite structure
+  vtkNew<vtkGroupDataSetsFilter> groupDataSets;
+  groupDataSets->SetOutputType(compositeType);
+  for (int i = 0; i < static_cast<int>(baseNames.size()); i++)
+  {
+    groupDataSets->AddInputConnection(baselineReaders[i]->GetOutputPort());
+    groupDataSets->SetInputName(i, baseNames[i].c_str());
+  }
+
+  // vtkGroupDataSetsFilter does not create an assembly for PDC, but the VTKHDF requires one.
+  // vtkNew<vtkPassInputTypeAlgorithm> addAssembly;
+  vtkNew<::vtkAddAssembly> addAssembly;
+  addAssembly->SetInputConnection(groupDataSets->GetOutputPort());
+
+  // Write out the composite temporal dataset
+  vtkNew<vtkHDFWriter> HDFWriterGrouped;
+  HDFWriterGrouped->SetInputConnection(compositeType == VTK_PARTITIONED_DATA_SET_COLLECTION
+      ? addAssembly->GetOutputPort()
+      : groupDataSets->GetOutputPort());
+
+  std::string tempPath = tempDir + "/HDFWriter_";
+  tempPath += "composite" + std::to_string(compositeType) + ".vtkhdf";
+  HDFWriterGrouped->SetFileName(tempPath.c_str());
+  HDFWriterGrouped->SetWriteAllTimeSteps(true);
+  HDFWriterGrouped->Write();
+
+  // Read back the grouped dataset
+  vtkNew<vtkHDFReader> readerGrouped;
+  readerGrouped->SetFileName(tempPath.c_str());
+  readerGrouped->Update();
+
+  // Make sure the number of timesteps match for all readers
+  int totalTimeStepsGrouped = readerGrouped->GetNumberOfSteps();
+
+  for (auto& readerPart : baselineReaders)
+  {
+    int totalTimeStepsPart = readerPart->GetNumberOfSteps();
+    if (totalTimeStepsGrouped != totalTimeStepsPart)
+    {
+      vtkLog(ERROR,
+        "total time steps in both HDF files do not match: "
+          << totalTimeStepsPart << " instead of " << totalTimeStepsGrouped << " for dataset "
+          << readerPart->GetFileName());
+      return false;
+    }
+  }
+
+  // Make sure we now control time manually using SetStep, don't let the pipeline handle it anymore
+  for (auto& reader : baselineReaders)
+  {
+    reader->GetOutputInformation(0)->Remove(vtkStreamingDemandDrivenPipeline::UPDATE_TIME_STEP());
+  }
+
+  // Compare the data at each timestep
+  for (int step = 0; step < totalTimeStepsGrouped; step++)
+  {
+    readerGrouped->SetStep(step);
+    readerGrouped->Update();
+
+    auto composite = vtkCompositeDataSet::SafeDownCast(readerGrouped->GetOutputDataObject(0));
+    vtkCompositeDataIterator* iter = vtkCompositeDataSet::SafeDownCast(composite)->NewIterator();
+    iter->SkipEmptyNodesOn();
+    iter->GoToFirstItem();
+
+    for (int compositeID = 0; compositeID < static_cast<int>(baseNames.size()); compositeID++)
+    {
+      if (iter->IsDoneWithTraversal())
+      {
+        vtkLog(ERROR, "Wrong number of datasets in composite output");
+        return false;
+      }
+
+      baselineReaders[compositeID]->SetStep(step);
+      baselineReaders[compositeID]->Update();
+
+      auto currentGroupedDO = vtkDataSet::SafeDownCast(iter->GetCurrentDataObject());
+      auto baselineDO =
+        vtkDataSet::SafeDownCast(baselineReaders[compositeID]->GetOutputDataObject(0));
+
+      // After grouping datasets, field data (time values) are not expected to match with the
+      // original dataset field values. Copy them to avoid failing comparison.
+      currentGroupedDO->SetFieldData(baselineDO->GetFieldData());
+      currentGroupedDO->GetPointData()->RemoveArray(0);
+      currentGroupedDO->GetPointData()->AddArray(baselineDO->GetPointData()->GetArray(0));
+
+      if (!vtkTestUtilities::CompareDataObjects(currentGroupedDO, baselineDO))
+      {
+        vtkLog(ERROR, << "data objects do not match for time step " << step);
+        return false;
+      }
+
+      iter->GoToNextItem();
+    }
+    iter->Delete();
+  }
+
+  return true;
+}
+
 //----------------------------------------------------------------------------
 int TestHDFWriterTemporal(int argc, char* argv[])
 {
@@ -208,6 +359,13 @@ int TestHDFWriterTemporal(int argc, char* argv[])
     }
   }
 
+  // Use a modified version of transient_harmonics to make sure that the time values match between
+  // both datasets
+  std::vector<std::string> baseNamesComposite = { "transient_sphere", "transient_harmonics" };
+  result &= TestTemporalComposite(tempDir, dataRoot, baseNamesComposite, VTK_MULTIBLOCK_DATA_SET);
+  result &= TestTemporalComposite(
+    tempDir, dataRoot, baseNamesComposite, VTK_PARTITIONED_DATA_SET_COLLECTION);
+
   result &= TestTemporalStaticMesh(
     tempDir, "transient_static_sphere_ug_source", ::supportedDataSetTypes::vtkUnstructuredGridType);
   result &= TestTemporalStaticMesh(

IO/HDF/vtkHDFWriter.h

@@ -232,8 +232,8 @@ private:
   /**
    * For temporal data, update the steps group with information relevant to the current timestep.
    */
-  bool UpdateStepsGroup(vtkUnstructuredGrid* input);
-  bool UpdateStepsGroup(vtkPolyData* input);
+  bool UpdateStepsGroup(hid_t group, vtkUnstructuredGrid* input);
+  bool UpdateStepsGroup(hid_t group, vtkPolyData* input);
   ///@}
 
   ///@{
@@ -241,8 +241,8 @@ private:
    * Initialize the `Steps` group for temporal data, and extendable datasets where needed.
    * This way, the other functions will append to existing datasets every step.
    */
-  bool InitializeTemporalPolyData();
-  bool InitializeTemporalUnstructuredGrid();
+  bool InitializeTemporalPolyData(hid_t group);
+  bool InitializeTemporalUnstructuredGrid(hid_t group);
   ///@}
 
   ///@{
@@ -348,10 +348,10 @@ private:
   /**
    * Append the offset data in the steps group for the current array for temporal data
    */
-  bool AppendDataArrayOffset(
-    vtkAbstractArray* array, const std::string& arrayName, const std::string& offsetsGroupName);
-  bool AppendDataArraySizeOffset(
-    vtkAbstractArray* array, const std::string& arrayName, const std::string& offsetsGroupName);
+  bool AppendDataArrayOffset(hid_t baseGroup, vtkAbstractArray* array, const std::string& arrayName,
+    const std::string& offsetsGroupName);
+  bool AppendDataArraySizeOffset(hid_t baseGroup, vtkAbstractArray* array,
+    const std::string& arrayName, const std::string& offsetsGroupName);
   ///@}
 
   /**

IO/HDF/vtkHDFWriterImplementation.cxx

@@ -202,17 +202,24 @@ std::string vtkHDFWriter::Implementation::GetGroupName(hid_t group)
 }
 
 //------------------------------------------------------------------------------
-bool vtkHDFWriter::Implementation::CreateStepsGroup()
+bool vtkHDFWriter::Implementation::CreateStepsGroup(hid_t group)
 {
   vtkHDF::ScopedH5GHandle stepsGroup{ H5Gcreate(
-    this->Root, "Steps", H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT) };
-  if (stepsGroup == H5I_INVALID_HID)
+    group, "Steps", H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT) };
+  return stepsGroup != H5I_INVALID_HID;
+}
+
+//------------------------------------------------------------------------------
+hid_t vtkHDFWriter::Implementation::GetStepsGroup(hid_t currentGroup)
+{
+  if (H5Lexists(currentGroup, "Steps", H5P_DEFAULT))
   {
-    return false;
+    // Store the last steps group accessed. There can be multiple for a given file
+    // if it composite. This Steps group is only used internally.
+    this->StepsGroup = H5Gopen(currentGroup, "Steps", H5P_DEFAULT);
+    return this->StepsGroup;
   }
-
-  this->StepsGroup = std::move(stepsGroup);
-  return true;
+  return H5I_INVALID_HID;
 }
 
 //------------------------------------------------------------------------------
@@ -350,17 +357,17 @@ vtkHDF::ScopedH5GHandle vtkHDFWriter::Implementation::CreateHdfGroupWithLinkOrde
 }
 
 //------------------------------------------------------------------------------
-herr_t vtkHDFWriter::Implementation::CreateSoftLink(
+bool vtkHDFWriter::Implementation::CreateSoftLink(
   hid_t group, const char* groupName, const char* targetLink)
 {
-  return H5Lcreate_soft(targetLink, group, groupName, H5P_DEFAULT, H5P_DEFAULT);
+  return H5Lcreate_soft(targetLink, group, groupName, H5P_DEFAULT, H5P_DEFAULT) >= 0;
 }
 
 //------------------------------------------------------------------------------
-herr_t vtkHDFWriter::Implementation::CreateExternalLink(
+bool vtkHDFWriter::Implementation::CreateExternalLink(
   hid_t group, const char* filename, const char* source, const char* targetLink)
 {
-  return H5Lcreate_external(filename, source, group, targetLink, H5P_DEFAULT, H5P_DEFAULT);
+  return H5Lcreate_external(filename, source, group, targetLink, H5P_DEFAULT, H5P_DEFAULT) >= 0;
 }
 
 //------------------------------------------------------------------------------

IO/HDF/vtkHDFWriterImplementation.h

@@ -26,7 +26,7 @@ class vtkHDFWriter::Implementation
 public:
   hid_t GetRoot() { return this->Root; }
   hid_t GetFile() { return this->File; }
-  hid_t GetStepsGroup() { return this->StepsGroup; }
+  hid_t GetStepsGroup(hid_t currentGroup);
 
   /**
    * Write version and type attributes to the root group
@@ -76,10 +76,9 @@ public:
   ///@}
 
   /**
-   * Create the steps group in the root group. Set a member variable to store the group, so it can
-   * be retrieved later using `GetStepsGroup` function.
+   * Create the steps group in the given group. It can be retrieved later using `GetStepsGroup`
    */
-  bool CreateStepsGroup();
+  bool CreateStepsGroup(hid_t group);
 
   /**
    * @struct PolyDataTopos
@@ -141,13 +140,15 @@ public:
 
   /**
    * Create a soft link to the real group containing the block dataset.
+   * Return true if the operation succeeded.
    */
-  herr_t CreateSoftLink(hid_t group, const char* groupName, const char* targetLink);
+  bool CreateSoftLink(hid_t group, const char* groupName, const char* targetLink);
 
   /**
    * Create an external link to the real group containing the block dataset.
+   * Return true if the operation succeeded.
    */
-  herr_t CreateExternalLink(
+  bool CreateExternalLink(
     hid_t group, const char* filename, const char* source, const char* targetLink);
 
   /**

Rendering/ANARI/CMakeLists.txt

@@ -20,6 +20,7 @@ set(classes
   vtkAnariCameraNode
   vtkAnariCompositePolyDataMapperNode
   vtkAnariDevice
+  vtkAnariGlyph3DMapperNode
   vtkAnariLightNode
   vtkAnariPass
   vtkAnariPolyDataMapperNode
@@ -34,6 +35,7 @@ set(classes
   )
 
 set(nowrap_classes
+  vtkAnariPolyDataMapperInheritInterface
   vtkAnariProfiling
 )
 
@@ -59,6 +61,7 @@ vtk_module_link(VTK::RenderingAnari
   PUBLIC
     anari::anari
     VTK::FiltersGeometry
+    VTK::FiltersSources
   PRIVATE
     $<$<BOOL:${VTK_ANARI_ENABLE_NVTX}>:CUDA::nvToolsExt>
 )

Rendering/ANARI/Testing/Cxx/TestAnariAmbient.cxx

@@ -76,11 +76,11 @@ int TestAnariAmbient(int argc, char* argv[])
   auto* ar = anariPass->GetAnariRenderer();
   for (double i = 0.; i < 3.14; i += 0.1)
   {
-    ar->SetParameter("ambientRadiance", float(sin(i)));
+    ar->SetParameterf("ambientRadiance", float(sin(i)));
     renWin->Render();
   }
 
-  ar->SetParameter("ambientRadiance", 0.2f);
+  ar->SetParameterf("ambientRadiance", 0.2f);
   renWin->Render();
 
   int retVal = vtkTesting::PASSED;

Rendering/ANARI/Testing/Cxx/TestAnariCellData.cxx

@@ -107,7 +107,7 @@ int TestAnariCellData(int argc, char* argv[])
 
   SetParameterDefaults(anariPass, ren, useDebugDevice, "TestAnariCellData");
   auto* ar = anariPass->GetAnariRenderer();
-  ar->SetParameter("ambientRadiance", 0.5f);
+  ar->SetParameterf("ambientRadiance", 0.5f);
 
   renWin->Render();
   ren->ResetCamera();

Rendering/ANARI/Testing/Cxx/TestAnariLights.cxx

@@ -203,7 +203,7 @@ int TestAnariLights(int argc, char* argv[])
 
   SetParameterDefaults(anariPass, renderer, useDebugDevice, "TestAnariLights");
   auto* ar = anariPass->GetAnariRenderer();
-  ar->SetParameter("ambientRadiance", 0.2f);
+  ar->SetParameterf("ambientRadiance", 0.2f);
 
   renWin->Render();
 

Rendering/ANARI/Testing/Cxx/vtkAnariTestUtilities.cxx

@@ -27,12 +27,12 @@ void SetParameterDefaults(
   ad->SetupAnariDeviceFromLibrary("environment", "default", useDebugDevice);
 
   // General renderer parameters:
-  ar->SetParameter("ambientRadiance", 1.f);
+  ar->SetParameterf("ambientRadiance", 1.f);
 
   // VisRTX specific renderer parameters:
-  ar->SetParameter("lightFalloff", 0.5f);
-  ar->SetParameter("denoise", true);
-  ar->SetParameter("pixelSamples", 8);
+  ar->SetParameterf("lightFalloff", 0.5f);
+  ar->SetParameterb("denoise", true);
+  ar->SetParameteri("pixelSamples", 8);
 
   vtkAnariSceneGraph::SetCompositeOnGL(renderer, 1);
 }

Rendering/ANARI/vtkAnariActorNode.cxx

@@ -12,6 +12,7 @@
 #include "vtkInformationIntegerKey.h"
 #include "vtkInformationObjectBaseKey.h"
 #include "vtkInformationStringKey.h"
+#include "vtkInformationStringVectorKey.h"
 #include "vtkMapper.h"
 #include "vtkPiecewiseFunction.h"
 #include "vtkPolyData.h"
@@ -29,6 +30,11 @@ vtkInformationKeyMacro(vtkAnariActorNode, LUMINOSITY, Double);
 vtkInformationKeyMacro(vtkAnariActorNode, ENABLE_SCALING, Integer);
 vtkInformationKeyMacro(vtkAnariActorNode, SCALE_ARRAY_NAME, String);
 vtkInformationKeyMacro(vtkAnariActorNode, SCALE_FUNCTION, ObjectBase);
+vtkInformationKeyMacro(vtkAnariActorNode, ACTOR_NODE_NAME, String);
+vtkInformationKeyMacro(vtkAnariActorNode, OUTPUT_POINT_AND_CELL_ARRAYS, Integer);
+vtkInformationKeyMacro(vtkAnariActorNode, OUTPUT_POINT_AND_CELL_ARRAYS_DOUBLE_TO_FLOAT, Integer);
+vtkInformationKeyMacro(vtkAnariActorNode, SCENEGRAPH_TIME_CONSTANT_POINT_ARRAYS, StringVector);
+vtkInformationKeyMacro(vtkAnariActorNode, SCENEGRAPH_TIME_CONSTANT_CELL_ARRAYS, StringVector);
 
 //----------------------------------------------------------------------------
 vtkAnariActorNode::vtkAnariActorNode()

Rendering/ANARI/vtkAnariActorNode.h

@@ -24,6 +24,7 @@ class vtkActor;
 class vtkInformationDoubleKey;
 class vtkInformationIntegerKey;
 class vtkInformationObjectBaseKey;
+class vtkInformationStringVectorKey;
 class vtkInformationStringKey;
 class vtkMapper;
 class vtkPiecewiseFunction;
@@ -118,6 +119,36 @@ public:
   static double GetLuminosity(vtkProperty*);
   //@}
 
+  /**
+   * Name of the node, used for debugging or representation
+   * metadata in case an ANARI backend is chosen which - instead
+   * of rendering to a screen - outputs to intermediate
+   * authoring stages (such as files or network resources).
+   */
+  static vtkInformationStringKey* ACTOR_NODE_NAME();
+
+  /**
+   * Indicates that the actor includes point and cell attribute arrays
+   * within its rendering output. This allows ANARI backends that transfer
+   * rendering data to intermediate authoring stages to get access to
+   * additional data than what is typically used by VTK's rendering itself.
+   */
+  static vtkInformationIntegerKey* OUTPUT_POINT_AND_CELL_ARRAYS();
+
+  /**
+   * Whether the output enabled with OUTPUT_POINT_AND_CELL_ARRAYS should
+   * convert double arrays to float.
+   */
+  static vtkInformationIntegerKey* OUTPUT_POINT_AND_CELL_ARRAYS_DOUBLE_TO_FLOAT();
+
+  /**
+   * Array metadata for intermediate authoring steps, which denotes the arrays
+   * which are not written out separately for every timestep,
+   * but instead contain only a single representation for all timesteps.
+   */
+  static vtkInformationStringVectorKey* SCENEGRAPH_TIME_CONSTANT_POINT_ARRAYS();
+  static vtkInformationStringVectorKey* SCENEGRAPH_TIME_CONSTANT_CELL_ARRAYS();
+
 protected:
   vtkAnariActorNode();
   ~vtkAnariActorNode() = default;

Rendering/ANARI/vtkAnariCompositePolyDataMapperNode.cxx

@@ -53,6 +53,8 @@ void vtkAnariCompositePolyDataMapperNode::Synchronize(bool prepass)
     return;
   }
 
+  this->SetActorNodeName();
+
   vtkProperty* prop = act->GetProperty();
 
   // Push base-values on the state stack.
@@ -75,16 +77,16 @@ void vtkAnariCompositePolyDataMapperNode::Synchronize(bool prepass)
 
   // render using the composite data attributes
   unsigned int flat_index = 0;
-  vtkCompositePolyDataMapper* cpdm = vtkCompositePolyDataMapper::SafeDownCast(act->GetMapper());
+  vtkMapper* baseMapper = vtkMapper::SafeDownCast(this->GetRenderable());
   vtkDataObject* dobj = nullptr;
 
-  if (cpdm)
+  if (baseMapper)
   {
-    dobj = cpdm->GetInputDataObject(0, 0);
+    dobj = baseMapper->GetInputDataObject(0, 0);
 
     if (dobj)
     {
-      this->SynchronizeBlock(cpdm, act, dobj, flat_index);
+      this->SynchronizeBlock(baseMapper, act, dobj, flat_index);
     }
   }
 
@@ -98,12 +100,12 @@ void vtkAnariCompositePolyDataMapperNode::Synchronize(bool prepass)
 
 //------------------------------------------------------------------------------
 void vtkAnariCompositePolyDataMapperNode::SynchronizeBlock(
-  vtkCompositePolyDataMapper* cpdm, vtkActor* actor, vtkDataObject* dobj, unsigned int& flat_index)
+  vtkMapper* baseMapper, vtkActor* actor, vtkDataObject* dobj, unsigned int& flat_index)
 {
   vtkAnariProfiling startProfiling(
     "vtkAnariCompositePolyDataMapperNode::SynchronizeBlock", vtkAnariProfiling::BROWN);
 
-  vtkCompositeDataDisplayAttributes* cda = cpdm->GetCompositeDataDisplayAttributes();
+  vtkCompositeDataDisplayAttributes* cda = this->GetCompositeDisplayAttributes();
 
   vtkProperty* prop = actor->GetProperty();
   vtkColor3d ecolor(prop->GetEdgeColor());
@@ -145,7 +147,7 @@ void vtkAnariCompositePolyDataMapperNode::SynchronizeBlock(
     {
       if (auto child = dataObjTree->GetChild(i))
       {
-        this->SynchronizeBlock(cpdm, actor, child, flat_index);
+        this->SynchronizeBlock(baseMapper, actor, child, flat_index);
       }
       else
       {
@@ -168,7 +170,7 @@ void vtkAnariCompositePolyDataMapperNode::SynchronizeBlock(
       vtkColor3d& aColor = this->BlockState.AmbientColor.top();
       vtkColor3d& dColor = this->BlockState.DiffuseColor.top();
       std::string& material = this->BlockState.Material.top();
-      cpdm->ClearColorArrays(); // prevents reuse of stale color arrays
+      baseMapper->ClearColorArrays(); // prevents reuse of stale color arrays
 
       double color[3] = { aColor.GetRed() * dColor.GetRed(), aColor.GetGreen() * dColor.GetGreen(),
         aColor.GetBlue() * dColor.GetBlue() };
@@ -196,4 +198,13 @@ void vtkAnariCompositePolyDataMapperNode::SynchronizeBlock(
   }
 }
 
+//----------------------------------------------------------------------------
+vtkCompositeDataDisplayAttributes*
+vtkAnariCompositePolyDataMapperNode::GetCompositeDisplayAttributes()
+{
+  vtkCompositePolyDataMapper* cpdm =
+    vtkCompositePolyDataMapper::SafeDownCast(this->GetRenderable());
+  return cpdm ? cpdm->GetCompositeDataDisplayAttributes() : nullptr;
+}
+
 VTK_ABI_NAMESPACE_END

Rendering/ANARI/vtkAnariCompositePolyDataMapperNode.h

@@ -22,8 +22,11 @@
 
 VTK_ABI_NAMESPACE_BEGIN
 
+class vtkActor;
+class vtkMapper;
 class vtkDataObject;
 class vtkCompositePolyDataMapper;
+class vtkCompositeDataDisplayAttributes;
 
 class VTKRENDERINGANARI_EXPORT vtkAnariCompositePolyDataMapperNode
   : public vtkAnariPolyDataMapperNode
@@ -47,7 +50,9 @@ protected:
   vtkAnariCompositePolyDataMapperNode() = default;
   ~vtkAnariCompositePolyDataMapperNode() = default;
 
-  void SynchronizeBlock(vtkCompositePolyDataMapper*, vtkActor*, vtkDataObject*, unsigned int&);
+  void SynchronizeBlock(vtkMapper*, vtkActor*, vtkDataObject*, unsigned int&);
+
+  virtual vtkCompositeDataDisplayAttributes* GetCompositeDisplayAttributes();
 
   class RenderBlockState
   {