mdo-lib 0.1.0

Multi-Disciplinary Optimization library

MDO - Multi-Disciplinary Optimization Library

MDO is a comprehensive Python library for optimization, surrogate modeling, sensitivity analysis, reliability analysis, and uncertainty optimization.

Features

• Parameter Management: Define and manage optimization parameters with bounds and constraints
• Design of Experiments (DOE): Generate samples using various DOE methods
• Surrogate Modeling: Build surrogate models for efficient function approximation
• Sensitivity Analysis: Analyze the impact of parameters on objectives
• Optimization Algorithms: Implement various optimization algorithms
• Reliability Analysis: Assess the reliability of designs under uncertainty
• Uncertainty Optimization: Optimize designs considering parameter uncertainty

Installation

pip install .

Dependencies

• numpy
• scipy
• pandas
• scikit-learn (for surrogate models)
• matplotlib (for visualization)

Usage Examples

Basic Optimization

from mdo import Problem, Parameter, Objective, Constraint
from mdo.optimization import GeneticAlgorithm

# Define parameters
x1 = Parameter('x1', 0.5, bounds=[0, 1])
x2 = Parameter('x2', 0.5, bounds=[0, 1])

# Define objective function
def objective_function(x):
    return (x[0] - 0.5)**2 + (x[1] - 0.5)**2

obj = Objective('f', 'minimize')
obj.evaluate = objective_function

# Define constraint function
def constraint_function(x):
    return x[0] + x[1] - 1.0

con = Constraint('g', 'inequality', upper_bound=0.0)
con.evaluate = constraint_function

# Create problem
problem = Problem([x1, x2], [obj], [con])

# Create optimizer
optimizer = GeneticAlgorithm(problem)

# Run optimization
result = optimizer.optimize()

print("Best point:", result.sample.values)
print("Objective value:", result.objectives[0])

Surrogate Modeling

from mdo import Problem, Parameter, Objective
from mdo.doe import LatinHypercube
from mdo.surrogate import Kriging
from mdo.core import Evaluator

# Define parameters and objective function
x1 = Parameter('x1', 0.5, bounds=[0, 1])
x2 = Parameter('x2', 0.5, bounds=[0, 1])

def objective_function(x):
    return np.sin(2 * np.pi * x[0]) * np.cos(2 * np.pi * x[1])

obj = Objective('f', 'minimize')
obj.evaluate = objective_function

# Create problem
problem = Problem([x1, x2], [obj])

# Generate samples
doe = LatinHypercube(problem, n_samples=50)
samples = doe.generate()

# Evaluate samples
evaluator = Evaluator(problem)
results = evaluator.evaluate(samples)

# Extract X and y
X = [sample.values for sample in samples]
y = [result.objectives[0] for result in results]

# Train surrogate model
model = Kriging()
model.fit(X, y)

# Predict
print(model.predict([[0.25, 0.25]]))

Sensitivity Analysis

from mdo import Problem, Parameter, Objective
from mdo.doe import LatinHypercube
from mdo.surrogate import Kriging
from mdo.sensitivity import SobolIndices
from mdo.core import Evaluator

# Define parameters and objective function
x1 = Parameter('x1', 0.5, bounds=[0, 1])
x2 = Parameter('x2', 0.5, bounds=[0, 1])
x3 = Parameter('x3', 0.5, bounds=[0, 1])

def objective_function(x):
    return (x[0] - 0.5)**2 + 2*(x[1] - 0.5)**2 + 3*(x[2] - 0.5)**2

obj = Objective('f', 'minimize')
obj.evaluate = objective_function

# Create problem
problem = Problem([x1, x2, x3], [obj])

# Generate samples and evaluate
doe = LatinHypercube(problem, n_samples=100)
samples = doe.generate()
evaluator = Evaluator(problem)
results = evaluator.evaluate(samples)

# Train surrogate model
X = [sample.values for sample in samples]
y = [result.objectives[0] for result in results]
model = Kriging()
model.fit(X, y)

# Perform sensitivity analysis
sobol = SobolIndices(model, problem)
results = sobol.analyze()
print(results)

Reliability Analysis

from mdo import Problem, Parameter, Objective
from mdo.doe import LatinHypercube
from mdo.surrogate import Kriging
from mdo.reliability import MonteCarlo
from mdo.core import Evaluator

# Define parameters and limit state function
x1 = Parameter('x1', 0.5, bounds=[0, 1])
x2 = Parameter('x2', 0.5, bounds=[0, 1])

def limit_state_function(x):
    return (x[0] - 0.7)**2 + (x[1] - 0.7)**2 - 0.1

obj = Objective('g', 'minimize')
obj.evaluate = limit_state_function

# Create problem
problem = Problem([x1, x2], [obj])

# Generate samples and evaluate
doe = LatinHypercube(problem, n_samples=50)
samples = doe.generate()
evaluator = Evaluator(problem)
results = evaluator.evaluate(samples)

# Train surrogate model
X = [sample.values for sample in samples]
y = [result.objectives[0] for result in results]
model = Kriging()
model.fit(X, y)

# Perform reliability analysis
monte_carlo = MonteCarlo(problem, model, n_samples=10000)
results = monte_carlo.analyze()
print(results)

Modules

• core: Core functionality for parameter management, problem definition, and evaluation
• doe: Design of Experiments methods
• surrogate: Surrogate models for function approximation
• sensitivity: Sensitivity analysis methods
• optimization: Optimization algorithms
• reliability: Reliability analysis methods
• uncertainty: Uncertainty optimization methods
• utils: Utility functions for parallel computing and visualization
• examples: Usage examples
• tests: Test cases

Contributing

Contributions are welcome! Please feel free to submit a Pull Request.

License

MIT License