CoreTypes.hpp

Go to the documentation of this file.

#pragma once

 
#include <concepts>
#include <cstdint>
#include <string>
 
// Re-export Janus types and concepts
#include <janus/core/JanusConcepts.hpp>
#include <janus/core/JanusTypes.hpp>
 
namespace icarus {
 
// =============================================================================
// Build Mode Detection
// =============================================================================

#ifdef ICARUS_DEBUG
constexpr bool kDebugMode = true;
#else
constexpr bool kDebugMode = false;
#endif
 
// =============================================================================
// Janus Type Re-exports
// =============================================================================
 
// Matrix and vector types (templated on Scalar)
using janus::JanusMatrix;
using janus::JanusVector;
 
// Fixed-size types
using janus::Mat2;
using janus::Mat3;
using janus::Mat4;
using janus::Vec2;
using janus::Vec3;
using janus::Vec4;
 
// Concrete backend types
using janus::NumericMatrix;
using janus::NumericScalar;
using janus::NumericVector;
using janus::SymbolicMatrix;
using janus::SymbolicScalar;
using janus::SymbolicVector;
 
// Sparse types (numeric only)
using janus::SparseMatrix;
using janus::SparseTriplet;
 
// Symbolic variable creation
using janus::as_mx;
using janus::as_vector;
using janus::sym;
using janus::sym_vec;
using janus::sym_vector;
using janus::to_eigen;
using janus::to_mx;
 
// =============================================================================
// Scalar Concepts
// =============================================================================

using janus::JanusScalar;

template <typename T>
concept IcarusScalar = JanusScalar<T>;
 
// =============================================================================
// Simulation Lifecycle
// =============================================================================

enum class Lifecycle : uint8_t {
    Uninitialized, 
    Provisioned,   
    Staged,        
    Running,       
    Paused,        
    Completed,     
    Error          
};
 
// =============================================================================
// Configuration Structures
// =============================================================================
 
// ComponentConfig with typed accessors is now in its own header
// (Phase 4.0: Configuration Infrastructure)

struct RunConfig {
    double t_start = 0.0;     
    double t_end = 10.0;      
    double dt = 0.001;        
    bool equilibrium = false; 
    // Additional fields for ICs, Monte Carlo, etc.
};
 
// =============================================================================
// Version Information
// =============================================================================
 
// Single source of truth for version numbers
#define ICARUS_VERSION_MAJOR 0
#define ICARUS_VERSION_MINOR 6
#define ICARUS_VERSION_PATCH 0
 
// Stringify helper
#define ICARUS_STRINGIFY(x) #x
#define ICARUS_VERSION_STR(major, minor, patch)                                                    \
    ICARUS_STRINGIFY(major) "." ICARUS_STRINGIFY(minor) "." ICARUS_STRINGIFY(patch)

constexpr int VersionMajor() { return ICARUS_VERSION_MAJOR; }

constexpr int VersionMinor() { return ICARUS_VERSION_MINOR; }

constexpr int VersionPatch() { return ICARUS_VERSION_PATCH; }

constexpr const char *Version() {
    return ICARUS_VERSION_STR(ICARUS_VERSION_MAJOR, ICARUS_VERSION_MINOR, ICARUS_VERSION_PATCH);
}
 
// =============================================================================
// Naming Utilities
// =============================================================================

inline std::string MakeFullPath(const std::string &entity, const std::string &name) {
    if (entity.empty())
        return name;
    return entity + "." + name;
}
 
// =============================================================================
// Component Concepts
// =============================================================================
 
// Forward declarations
class ComponentConfig;
template <typename Scalar> class Backplane;

template <typename T, typename Scalar>
concept ComponentType =
    requires(T &c, Backplane<Scalar> &bp, const ComponentConfig &cfg, Scalar t, Scalar dt) {
        // Component must have a name
        { c.Name() } -> std::convertible_to<std::string>;
 
        // Core lifecycle methods
        { c.Provision(bp, cfg) } -> std::same_as<void>;
        { c.Stage(bp, cfg) } -> std::same_as<void>;
        { c.Step(t, dt) } -> std::same_as<void>;
    };

template <typename T, typename Scalar>
concept ExtendedComponent = ComponentType<T, Scalar> && requires(T &c, Lifecycle lifecycle) {
    { c.OnPhaseEnter(lifecycle) } -> std::same_as<void>;
    { c.OnPhaseExit(lifecycle) } -> std::same_as<void>;
};
 
} // namespace icarus
 
// =============================================================================
// Debug Assertion Macros
// =============================================================================
 
#ifdef ICARUS_DEBUG

#define ICARUS_ASSERT(cond, msg)                                                                   \
    do {                                                                                           \
        if (!(cond)) {                                                                             \
            throw std::runtime_error(std::string("ICARUS_ASSERT failed: ") + (msg));               \
        }                                                                                          \
    } while (0)

#define ICARUS_DEBUG_ONLY(code) code

#define ICARUS_ASSERT_PTR(ptr, context) ICARUS_ASSERT((ptr) != nullptr, "Null pointer in " context)

#define ICARUS_ASSERT_LIFECYCLE(lifecycle, required, operation)                                    \
    ICARUS_ASSERT((lifecycle) >= (required), std::string(operation) +                              \
                                                 " requires lifecycle state >= " +                 \
                                                 std::to_string(static_cast<int>(required)))
 
#else // Release builds
 
// All debug macros compile to nothing
#define ICARUS_ASSERT(cond, msg) ((void)0)
#define ICARUS_DEBUG_ONLY(code) ((void)0)
#define ICARUS_ASSERT_PTR(ptr, context) ((void)0)
#define ICARUS_ASSERT_LIFECYCLE(lifecycle, required, operation) ((void)0)
 
#endif // ICARUS_DEBUG