Conduit

CivetWeb is a powerful, easy-to-use, C/C++ embeddable web server. It is designed to be used in two ways:

1. As a library: Developers can embed it into existing applications to add HTTP/HTTPS functionality.
2. As a stand-alone server: End users can run it as a single executable with no installation required.

Key Features:

• License: MIT license (permissive and commercial-friendly).
• Platforms: Windows, Mac, Linux, UNIX, iPhone, Android, and more.
• Capabilities: Supports CGI, HTTPS (SSL/TLS), SSI, HTTP digest (MD5) authorization, Websocket, and WEbDAV.
• Scripting & Database: Optional support for Lua scripts, Lua Server Pages, CGI, SQLite, and Server-side JavaScript.
• Client Functionality: Includes an HTTP client for sending arbitrary requests and a Websocket client (WS/WSS).

Conduit is an open-source project designed for simplified data exchange in High-Performance Computing (HPC) simulations. It provides an intuitive model for describing hierarchical scientific data across multiple languages, including C++, C, Fortran, and Python.

Key use cases include:

• Data coupling between simulation packages in-core.
• Data serialization.
• I/O tasks.

The core API uses a JSON-inspired data model to describe hierarchical in-core scientific data and provides a dynamic API for rapid construction and consumption of these objects. It supports both Conduit-allocated memory and externally owned memory semantics, and it does not require code generation or data repacking.

Conduit is an open source project designed for simplified data exchange in High-Performance Computing (HPC) simulations. It provides an intuitive model for describing hierarchical scientific data across multiple languages, including C++, C, Fortran, and Python.

Developers use Conduit for:

• Data coupling: Facilitating exchange between different simulation packages in-core.
• Serialization: Converting data structures into formats suitable for storage or transmission.
• I/O tasks: Managing input and output operations for scientific datasets.

The Conduit repository is organized into several key directories that separate the core libraries, testing suites, and examples:

• src/libs/: Contains the source code for the primary libraries:
  • conduit/: The main Conduit library.
  • relay/: Relay libraries.
  • blueprint/: Blueprint library.
• src/tests/: Contains testing suites for the libraries (conduit/, relay/, blueprint/) and third-party libraries (thirdparty/).
• src/examples/: Provides basic examples for building and using Conduit.
• src/docs/: Project documentation.
• src/thirdparty_builtin/: Third-party libraries that are built and managed directly by the project.

RapidJSON is designed for high performance and low memory footprint. Key features include:

• Dual API: Supports both SAX (Simple API for XML style) and DOM (Document Object Model) interfaces.
• Performance: Highly optimized; optionally supports SSE2/SSE4.2 for hardware acceleration.
• Memory Efficiency: Uses a fast internal allocator; JSON values are stored compactly (typically 16/20 bytes per value on 32/64-bit machines, excluding text).
• Unicode Support: Full support for UTF-8, UTF-16, and UTF-32 (both Little and Big Endian), including validation and transcoding.
• Compliance: Fully compliant with RFC7159 and ECMA-404 JSON standards.

The table blueprint protocol is a convention for expressing tabular data in Conduit. It ensures that data can be easily translated to and from CSV files.

In a table blueprint:

• Each data entry represents a column.
• Each column contains the same number of rows.

To conform to the protocol, a Node must have a values child (which can be a list or an object) where:

1. All values children are data arrays or mcarrays.
2. All values children have the same number of elements (the number of rows).

A Node also conforms to the protocol if it is a collection of tables (a list or object where all children are valid tables).

The Relay I/O HDF5 interface allows reading and writing Conduit Nodes using HDF5 handles. This interface provides fine-grained control and efficient reuse of I/O handles.

Note: This interface is only available in C++. It serves as the underlying implementation for both the path-based and handle-based I/O interfaces for HDF5.

The Node class is the primary object in Conduit. It acts as a hierarchical variant object that can represent different types of data structures.

Conduit uses a hierarchy inspired by JSON:

• Objects: Collections of named nodes.
• Lists: Collections of unnamed nodes.
• Leaves: Concrete data types (e.g., numbers, arrays) that represent the end of a branch.

You can iterate through a Node's children and fetch sub-nodes using relative paths. Note that paths are relative to the current node; leading slashes (/) or redundant slashes (///) are ignored.

import conduit

# Basic Node creation
n = conduit.Node()

# Hierarchical construction (example pattern)
n.add_object("my_object")
n.add_list("my_list")

In Conduit, Node instances using the Object or List role interfaces can contain children.

• List role: A Node holds a set of indexed children.
• Object role: A Node holds a set of both indexed and named children.

Children can be accessed or removed using their index. The following methods are available for both Node and Schema instances:

• number_of_children(): Returns the count of children.
• child(index_t): Returns a child by index.
• child_ptr(index_t): Returns a pointer to a child by index.
• operator=(index_t): Access/assign via index operator.
• remove(index_t): Removes the child at the specified index.

The relay library provides I/O methods for integrating Conduit Nodes with common high-performance computing and data formats, including:

• HDF5
• Silo
• MPI