Metadata-Version: 2.1
Name: mdo-lib
Version: 0.1.0
Summary: Multi-Disciplinary Optimization library
Home-page: https://github.com/yourusername/mdo-lib
Author: Your Name
Author-email: your.email@example.com
License: UNKNOWN
Platform: UNKNOWN
Classifier: Programming Language :: Python :: 3
Classifier: License :: OSI Approved :: MIT License
Classifier: Operating System :: OS Independent
Requires-Python: >=3.7
Description-Content-Type: text/markdown
Requires-Dist: numpy
Requires-Dist: scipy
Requires-Dist: pandas
Requires-Dist: scikit-learn
Requires-Dist: matplotlib

# 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

```bash
pip install .
```

## Dependencies

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

## Usage Examples

### Basic Optimization

```python
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

```python
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

```python
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

```python
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


