Crate philote_mdo 

Philote-Rust: A high-performance library for building MDO analysis servers

This library provides a type-safe, async implementation for creating distributed analysis services in Multidisciplinary Design Optimization (MDO) frameworks using gRPC and Protocol Buffers.

Overview

Philote enables computational disciplines to be exposed as remote services that can be integrated into MDO frameworks. It supports both explicit and implicit analysis types with automatic gradient computation capabilities.

Key Features

• Type-safe gRPC communication using Protocol Buffers
• Async/await support with Tokio runtime for high-performance concurrent operations
• Flexible discipline types for different analysis patterns
• Efficient data streaming for large arrays
• Comprehensive error handling with domain-specific error types

Quick Start

Creating a Discipline Server

use async_trait::async_trait;
use philote_mdo::{
    traits::{Discipline, ExplicitDiscipline},
    server::ExplicitServer,
    ArrayMap, Result,
};
use ndarray::ArrayD;
use std::collections::HashMap;

struct MyDiscipline;

#[async_trait]
impl ExplicitDiscipline for MyDiscipline {
    async fn compute(&self, inputs: &ArrayMap) -> Result<ArrayMap> {
        let mut outputs = HashMap::new();
        // Your computation logic here
        Ok(outputs)
    }
}

impl Discipline for MyDiscipline {
    fn name(&self) -> &str { "MyDiscipline" }
    fn version(&self) -> &str { "1.0.0" }
    // Implement other required methods...
}

Connecting with a Client

use philote_mdo::client::ExplicitClient;

let mut client = ExplicitClient::connect("http://localhost:50051").await?;
let info = client.get_info().await?;
println!("Connected to: {} v{}", info.name, info.version);

Module Organization

• client - Client implementations for connecting to Philote servers
• server - Server implementations for hosting disciplines
• traits - Core trait definitions for disciplines
• types - Data structures and type conversions
• error - Error types and handling
• utils - Utility functions for array operations

Type Aliases

• Result<T> - Standard result type using PhiloteError
• ArrayMap - Map of variable names to N-dimensional arrays
• PartialMap - Map of (output, input) tuples to partial derivative arrays

Re-exports

pub use error::PhiloteError;

pub use traits::Discipline;

pub use traits::ExplicitDiscipline;

pub use traits::ImplicitDiscipline;

pub use types::ArrayData;

pub use types::VariableData;

Modules

client

Client implementations for connecting to Philote servers

error

Error types for Philote operations

philote_info

Protocol buffer definitions generated from the Philote MDO specification

server

Server implementations for hosting Philote disciplines

traits

Core trait definitions for computational disciplines

types

Data types and Protocol Buffer conversions

utils

Utility functions for array and variable operations

Type Aliases

ArrayMap

Map of variable names to their N-dimensional array values

DiscreteMap

PartialMap

Map of (output variable, input variable) pairs to their partial derivative arrays

Result

Standard result type for Philote operations