feat: Copy/archive input XML files into the output directory

src/cmake/GeosxConfig.cmake

@@ -66,6 +66,9 @@ endif()
 
 set( GEOS_CMAKE_BUILD_TYPE "\"${CMAKE_BUILD_TYPE}\"" )
 
+set( GEOS_SCHEMA_INSTALL_PATH "${CMAKE_INSTALL_FULL_DATAROOTDIR}/${CMAKE_PROJECT_NAME}/schema/schema.xsd" )
+set( GEOS_SCHEMA_SOURCE_PATH "${CMAKE_SOURCE_DIR}/coreComponents/schema/schema.xsd" )
+
 configure_file( ${CMAKE_SOURCE_DIR}/coreComponents/common/GeosxConfig.hpp.in
                 ${CMAKE_BINARY_DIR}/include/common/GeosxConfig.hpp )
 

src/coreComponents/common/GeosxConfig.hpp.in

@@ -131,6 +131,12 @@
 /// CMake option CMAKE_BUILD_TYPE
 #cmakedefine GEOS_CMAKE_BUILD_TYPE @GEOS_CMAKE_BUILD_TYPE@
 
+/// Absolute path to the XSD schema in the install tree
+#cmakedefine GEOS_SCHEMA_INSTALL_PATH "@GEOS_SCHEMA_INSTALL_PATH@"
+
+/// Absolute path to the XSD schema in the source tree (development builds)
+#cmakedefine GEOS_SCHEMA_SOURCE_PATH "@GEOS_SCHEMA_SOURCE_PATH@"
+
 /// The type that localIndex will be aliased to.
 #define GEOS_LOCALINDEX_TYPE @GEOS_LOCALINDEX_TYPE@
 

src/coreComponents/common/initializeEnvironment.hpp

@@ -93,6 +93,9 @@ struct CommandLineOptions
 
   /// Print memory usage in data repository
   real64 printMemoryUsage = -1.0;
+
+  /// Set the archiving level
+  integer archiveInputDeck = 1;
 };
 
 /**

src/coreComponents/fileIO/CMakeLists.txt

@@ -24,6 +24,7 @@ Contains:
 #
 set( fileIO_headers
      LogLevelsInfo.hpp
+     Outputs/ArchiveInputDeck.hpp
      Outputs/BlueprintOutput.hpp
      Outputs/MemoryStatsOutput.hpp
      Outputs/OutputBase.hpp
@@ -43,6 +44,7 @@ set( fileIO_headers
 # Specify all sources
 #
 set( fileIO_sources
+     Outputs/ArchiveInputDeck.cpp
      Outputs/BlueprintOutput.cpp
      Outputs/MemoryStatsOutput.cpp
      Outputs/OutputBase.cpp

src/coreComponents/fileIO/Outputs/ArchiveInputDeck.cpp

@@ -0,0 +1,252 @@
+/*
+ * ------------------------------------------------------------------------------------------------------------
+ * SPDX-License-Identifier: LGPL-2.1-only
+ *
+ * Copyright (c) 2016-2024 Lawrence Livermore National Security LLC
+ * Copyright (c) 2018-2024 TotalEnergies
+ * Copyright (c) 2018-2024 The Board of Trustees of the Leland Stanford Junior University
+ * Copyright (c) 2023-2024 Chevron
+ * Copyright (c) 2019-     GEOS/GEOSX Contributors
+ * All rights reserved
+ *
+ * See top level LICENSE, COPYRIGHT, CONTRIBUTORS, NOTICE, and ACKNOWLEDGEMENTS files for details.
+ * ------------------------------------------------------------------------------------------------------------
+ */
+
+/**
+ * @file ArchiveInputDeck.cpp
+ */
+
+#include "ArchiveInputDeck.hpp"
+
+#include "common/GeosxConfig.hpp"
+#include "common/Path.hpp"
+#include "common/format/Format.hpp"
+#include "common/logger/Logger.hpp"
+#include "dataRepository/xmlWrapper.hpp"
+
+#include <algorithm>
+#include <chrono>
+#include <filesystem>
+#include <system_error>
+
+namespace geos
+{
+
+using namespace dataRepository;
+
+namespace archiveInputDeck
+{
+
+namespace
+{
+
+string makeTimestamp()
+{
+  auto const now = std::chrono::system_clock::now();
+  auto const time_t_now = std::chrono::system_clock::to_time_t( now );
+  std::ostringstream timestampStream;
+  timestampStream << std::put_time( std::localtime( &time_t_now ), "%Y%m%d_%H%M%S" );
+  return timestampStream.str();
+}
+
+void stripMetadataAttributes( xmlWrapper::xmlNode node )
+{
+  node.remove_attribute( xmlWrapper::filePathString );
+  node.remove_attribute( xmlWrapper::charOffsetString );
+
+  for( xmlWrapper::xmlNode child : node.children() )
+  {
+    stripMetadataAttributes( child );
+  }
+}
+
+void reorderTags( xmlWrapper::xmlNode rootNode, string_array const & tagOrder )
+{
+  xmlWrapper::xmlNode lastInserted;
+  for( string const & tagName : tagOrder )
+  {
+    xmlWrapper::xmlNode tag = rootNode.child( tagName.c_str() );
+    if( !tag )
+    {
+      continue;
+    }
+
+    lastInserted ? rootNode.insert_move_after( tag, lastInserted )
+                  : rootNode.append_move( tag );
+
+    lastInserted = tag;
+  }
+
+  // ProblemManager's order list doesn't provide every XML tags available in GEOS
+  // so we put the missing ones below the ones it provides.
+  // And sort them alphabetically
+  stdVector< string > missingTags;
+
+  for( xmlWrapper::xmlNode const & tag : rootNode.children() )
+  {
+    string const & tagName = tag.name();
+
+    if( std::find( tagOrder.begin(), tagOrder.end(), tag.name() ) == tagOrder.end() )
+    {
+      missingTags.push_back( tagName );
+    }
+  }
+
+  std::sort( missingTags.begin(), missingTags.end() );
+
+  for( string const & tagName : missingTags )
+  {
+    xmlWrapper::xmlNode tag = rootNode.child( tagName.c_str() );
+
+    if( tag )
+    {
+      rootNode.append_move( tag );
+    }
+  }
+}
+
+void sortAttributes( xmlWrapper::xmlNode node )
+{
+  stdVector< std::pair< string, string > > attributes;
+  for( xmlWrapper::xmlAttribute attr = node.first_attribute();
+       attr;
+       attr = attr.next_attribute() )
+  {
+    attributes.emplace_back( attr.name(), attr.value() );
+  }
+
+  std::sort( attributes.begin(),
+             attributes.end(),
+             []( std::pair< string, string > const & a,
+                 std::pair< string, string > const & b )
+  {
+    // name attribute should be the first attribute, and not sorted alphabetically
+    bool const aIsName = ( a.first == "name" );
+    bool const bIsName = ( b.first == "name" );
+    if( aIsName != bIsName )
+    {
+      return aIsName;
+    }
+
+    // other attributes are sorted alphabetically
+    return a.first < b.first;
+  } );
+
+  // pugi doesn't have any move_attribute method yet, so we have to
+  // copy and remove attributes
+  while( node.remove_attribute( node.first_attribute() ) )
+  {}
+  for( auto const & attr : attributes )
+  {
+    node.append_attribute( attr.first.c_str() ).set_value( attr.second.c_str() );
+  }
+
+  for( xmlWrapper::xmlNode child : node.children() )
+  {
+    sortAttributes( child );
+  }
+}
+
+xmlWrapper::xmlDocument flattenXMLs( string_array const & fileNames )
+{
+  xmlWrapper::xmlDocument flatDoc;
+  xmlWrapper::xmlNode root = flatDoc.appendChild( "Problem" );
+
+  for( string const & fileName : fileNames )
+  {
+    xmlWrapper::xmlDocument doc;
+    xmlWrapper::xmlResult const result = doc.loadFile( fileName, true );
+    GEOS_THROW_IF( !result,
+                   GEOS_FMT( "Could not load XML file '{}': {}", fileName, result.description() ),
+                   InputError );
+    xmlWrapper::xmlNode docRoot = doc.getFirstChild();
+
+    doc.addIncludedXML( docRoot );
+
+    for( xmlWrapper::xmlNode & node : docRoot.children() )
+    {
+      root.append_copy( node );
+    }
+  }
+
+  return flatDoc;
+}
+
+void copySchemaToArchive( string const & archiveDir )
+{
+  std::filesystem::path const candidates[] = {
+    GEOS_SCHEMA_SOURCE_PATH,
+    GEOS_SCHEMA_INSTALL_PATH
+  };
+
+  std::error_code ec;
+  for( std::filesystem::path const & source : candidates )
+  {
+    if( source.empty() || !std::filesystem::is_regular_file( source, ec ) )
+    {
+      continue;
+    }
+
+    std::filesystem::path const destination = std::filesystem::path( archiveDir ) / "schema.xsd";
+    std::filesystem::copy_file( source,
+                                destination,
+                                ec );
+
+    if( ec )
+    {
+      GEOS_WARNING( GEOS_FMT( "Failed to copy XSD schema to archive '{}': {}",
+                              destination.string(), ec.message() ) );
+      return;
+    }
+
+    GEOS_LOG_RANK_0( GEOS_FMT( "Archived XSD schema: {}",
+                               getAbsolutePath( destination.string() ) ) );
+
+    return;
+  }
+
+  GEOS_WARNING( "Could not locate the XSD schema for archiving" );
+}
+
+
+}
+
+
+void archiveInputDeck( string_array const & inputFileNames,
+                       string const & outputDirectory,
+                       string_array const & xmlTagOrder,
+                       integer const level )
+{
+  if( level == 0 || inputFileNames.empty() || outputDirectory.empty() )
+  {
+    return;
+  }
+
+  string const timestamp = makeTimestamp();
+  string const archiveDir = joinPath( outputDirectory, "archive_inputFiles", timestamp );
+  makeDirsForPath( archiveDir + "/" );
+
+  xmlWrapper::xmlDocument flatDoc = flattenXMLs( inputFileNames );
+  xmlWrapper::xmlNode root = flatDoc.getFirstChild();
+
+  stripMetadataAttributes( root );
+  reorderTags( root, xmlTagOrder );
+  sortAttributes( root );
+
+  string const inputArchiveFile = joinPath( archiveDir, "input.xml" );
+  flatDoc.saveFile( inputArchiveFile );
+
+  GEOS_LOG_RANK_0( GEOS_FMT( "Archived XML inputs: {}",
+                             getAbsolutePath( inputArchiveFile ) ) );
+
+  if( level >= 2 )
+  {
+    copySchemaToArchive( archiveDir );
+  }
+}
+
+
+} /* namespace archiveInputDeck */
+
+} /* namespace geos */

src/coreComponents/fileIO/Outputs/ArchiveInputDeck.hpp

@@ -0,0 +1,56 @@
+/*
+ * ------------------------------------------------------------------------------------------------------------
+ * SPDX-License-Identifier: LGPL-2.1-only
+ *
+ * Copyright (c) 2016-2024 Lawrence Livermore National Security LLC
+ * Copyright (c) 2018-2024 TotalEnergies
+ * Copyright (c) 2018-2024 The Board of Trustees of the Leland Stanford Junior University
+ * Copyright (c) 2023-2024 Chevron
+ * Copyright (c) 2019-     GEOS/GEOSX Contributors
+ * All rights reserved
+ *
+ * See top level LICENSE, COPYRIGHT, CONTRIBUTORS, NOTICE, and ACKNOWLEDGEMENTS files for details.
+ * ------------------------------------------------------------------------------------------------------------
+ */
+
+/**
+ * @file ArchiveInputDeck.hpp
+ */
+
+#ifndef GEOS_FILEIO_OUTPUTS_ARCHIVEINPUTDECK_HPP_
+#define GEOS_FILEIO_OUTPUTS_ARCHIVEINPUTDECK_HPP_
+
+#include "common/DataTypes.hpp"
+
+namespace geos
+{
+
+namespace archiveInputDeck
+{
+
+/**
+ * @brief Archive the XML input deck (and optionally the XSD schema) into the
+ *        output directory.
+ * @param inputFileNames Container of XML file names to start the copy from
+ * @param outputDirectory The output directory to copy files into
+ * @param xmlTagOrder The order of the XML tags in the XML archive file
+ * @param level Archiving strategy level:
+ *              - 0: no archiving (returns immediately)
+ *              - 1: XML inputs only (flattened into a single file)
+ *              - 2: XML inputs + the XSD schema
+ *
+ * Copy XML input files and every included files they contain (specified in
+ * the Included tag) into a single flat file. When @p level is at least 2, the
+ * XSD schema is also copied next to the flattened input.
+ */
+void archiveInputDeck( string_array const & inputFileNames,
+                       string const & outputDirectory,
+                       string_array const & xmlTagOrder,
+                       integer level );
+
+} /* namespace archiveInputDeck */
+
+} /* namespace geos */
+
+
+#endif // GEOS_FILEIO_OUTPUTS_ARCHIVEINPUTDECK_HPP_

src/coreComponents/mainInterface/ProblemManager.cpp

@@ -37,6 +37,7 @@
 #include "finiteVolume/FluxApproximationBase.hpp"
 #include "finiteVolume/HybridMimeticDiscretization.hpp"
 #include "fieldSpecification/FieldSpecificationManager.hpp"
+#include "fileIO/Outputs/ArchiveInputDeck.hpp"
 #include "fileIO/Outputs/OutputBase.hpp"
 #include "fileIO/Outputs/OutputManager.hpp"
 #include "functions/FunctionManager.hpp"
@@ -323,6 +324,16 @@ void ProblemManager::parseCommandLineInput()
     GEOS_LOG_RANK_0( "Opened XML file: " << absPath );
   }
 
+  if( opts.archiveInputDeck && MpiWrapper::commRank() == 0 )
+  {
+    string_array xmlTagOrder;
+    initializationOrder( xmlTagOrder );
+    archiveInputDeck::archiveInputDeck( opts.inputFileNames,
+                                        outputDirectory,
+                                        xmlTagOrder,
+                                        opts.archiveInputDeck );
+  }
+
   inputFileName = xmlWrapper::buildMultipleInputXML( opts.inputFileNames, outputDirectory );
 
   string & schemaName = commandLine.getReference< string >( viewKeys.schemaFileName );