mdo-lib 0.1.0__py3-none-any.whl

mdo_lib/__init__.py

@@ -0,0 +1,45 @@
+"""MDO (Multi-Disciplinary Optimization) library"""
+
+__version__ = "0.1.0"
+
+from .core import Problem, Parameter, Objective, Constraint, Evaluator, Sample, Result
+from .doe import DOE, FullFactorial, LatinHypercube, CentralComposite
+from .surrogate import SurrogateModel, PolynomialRegression, Kriging, RBF
+from .sensitivity import SensitivityAnalysis, SobolIndices, MorrisMethod, FAST
+from .optimization import Optimizer, GradientDescent, GeneticAlgorithm, ParticleSwarmOptimization, BayesianOptimization
+from .reliability import ReliabilityAnalysis, MonteCarlo, FORM, SORM
+from .uncertainty import UncertaintyOptimizer, RobustOptimization, ReliabilityBasedOptimization
+
+__all__ = [
+    "Problem",
+    "Parameter",
+    "Objective",
+    "Constraint",
+    "Evaluator",
+    "Sample",
+    "Result",
+    "DOE",
+    "FullFactorial",
+    "LatinHypercube",
+    "CentralComposite",
+    "SurrogateModel",
+    "PolynomialRegression",
+    "Kriging",
+    "RBF",
+    "SensitivityAnalysis",
+    "SobolIndices",
+    "MorrisMethod",
+    "FAST",
+    "Optimizer",
+    "GradientDescent",
+    "GeneticAlgorithm",
+    "ParticleSwarmOptimization",
+    "BayesianOptimization",
+    "ReliabilityAnalysis",
+    "MonteCarlo",
+    "FORM",
+    "SORM",
+    "UncertaintyOptimizer",
+    "RobustOptimization",
+    "ReliabilityBasedOptimization",
+]

mdo_lib/core/__init__.py

@@ -0,0 +1,18 @@
+"""Core module for MDO library"""
+
+from .parameter import Parameter
+from .objective import Objective
+from .constraint import Constraint
+from .problem import Problem
+from .evaluator import Evaluator
+from .result import Sample, Result
+
+__all__ = [
+    "Parameter",
+    "Objective",
+    "Constraint",
+    "Problem",
+    "Evaluator",
+    "Sample",
+    "Result",
+]

mdo_lib/core/constraint.py

@@ -0,0 +1,29 @@
+"""Constraint module"""
+
+class Constraint:
+    """Constraint class for optimization problems"""
+    
+    def __init__(self, name, type='inequality', upper_bound=0.0, lower_bound=None):
+        """Initialize a constraint
+        
+        Args:
+            name (str): Constraint name
+            type (str, optional): Constraint type ('inequality' or 'equality'). Defaults to 'inequality'.
+            upper_bound (float, optional): Upper bound for inequality constraint. Defaults to 0.0.
+            lower_bound (float, optional): Lower bound for equality constraint. Defaults to None.
+        """
+        self.name = name
+        self.type = type
+        self.upper_bound = upper_bound
+        self.lower_bound = lower_bound
+    
+    def evaluate(self, x):
+        """Evaluate the constraint
+        
+        Args:
+            x (list): Design variables
+            
+        Returns:
+            float: Constraint value
+        """
+        raise NotImplementedError("Subclass must implement evaluate method")

mdo_lib/core/evaluator.py

@@ -0,0 +1,60 @@
+"""Sample evaluation module"""
+
+from concurrent.futures import ThreadPoolExecutor
+
+class Evaluator:
+    """Evaluator class for evaluating samples"""
+    
+    def __init__(self, problem, parallel=False):
+        """Initialize an evaluator
+        
+        Args:
+            problem (Problem): Problem to evaluate
+            parallel (bool, optional): Whether to evaluate in parallel. Defaults to False.
+        """
+        self.problem = problem
+        self.parallel = parallel
+    
+    def evaluate(self, samples):
+        """Evaluate samples
+        
+        Args:
+            samples (list): List of Sample objects
+            
+        Returns:
+            list: List of Result objects
+        """
+        from .result import Result
+        
+        if self.parallel:
+            with ThreadPoolExecutor() as executor:
+                results = list(executor.map(self._evaluate_sample, samples))
+        else:
+            results = [self._evaluate_sample(sample) for sample in samples]
+        
+        return results
+    
+    def _evaluate_sample(self, sample):
+        """Evaluate a single sample
+        
+        Args:
+            sample (Sample): Sample to evaluate
+            
+        Returns:
+            Result: Evaluation result
+        """
+        from .result import Result
+        
+        # Evaluate objectives
+        objectives = []
+        for obj in self.problem.objectives:
+            value = obj.evaluate(sample.values)
+            objectives.append(value)
+        
+        # Evaluate constraints
+        constraints = []
+        for con in self.problem.constraints:
+            value = con.evaluate(sample.values)
+            constraints.append(value)
+        
+        return Result(sample, objectives, constraints)

mdo_lib/core/objective.py

@@ -0,0 +1,27 @@
+"""Objective function module"""
+
+class Objective:
+    """Objective function class for optimization problems"""
+    
+    def __init__(self, name, sense='minimize', weight=1.0):
+        """Initialize an objective function
+        
+        Args:
+            name (str): Objective name
+            sense (str, optional): Optimization sense ('minimize' or 'maximize'). Defaults to 'minimize'.
+            weight (float, optional): Objective weight. Defaults to 1.0.
+        """
+        self.name = name
+        self.sense = sense
+        self.weight = weight
+    
+    def evaluate(self, x):
+        """Evaluate the objective function
+        
+        Args:
+            x (list): Design variables
+            
+        Returns:
+            float: Objective value
+        """
+        raise NotImplementedError("Subclass must implement evaluate method")

mdo_lib/core/parameter.py

@@ -0,0 +1,41 @@
+"""Parameter management module"""
+
+class Parameter:
+    """Parameter class for optimization problems"""
+    
+    def __init__(self, name, value, bounds=None, is_continuous=True, is_integer=False):
+        """Initialize a parameter
+        
+        Args:
+            name (str): Parameter name
+            value (float): Initial value
+            bounds (tuple, optional): (lower, upper) bounds. Defaults to None.
+            is_continuous (bool, optional): Whether the parameter is continuous. Defaults to True.
+            is_integer (bool, optional): Whether the parameter is integer. Defaults to False.
+        """
+        self.name = name
+        self.value = value
+        self.bounds = bounds
+        self.is_continuous = is_continuous
+        self.is_integer = is_integer
+    
+    def validate(self, value):
+        """Validate a parameter value
+        
+        Args:
+            value (float): Value to validate
+            
+        Returns:
+            bool: True if valid, False otherwise
+        """
+        # Check if value is within bounds
+        if self.bounds:
+            lower, upper = self.bounds
+            if value < lower or value > upper:
+                return False
+        
+        # Check if value is integer if required
+        if self.is_integer and not isinstance(value, int) and not value.is_integer():
+            return False
+        
+        return True

mdo_lib/core/problem.py

@@ -0,0 +1,24 @@
+"""Problem definition module"""
+
+class Problem:
+    """Problem class for optimization problems"""
+    
+    def __init__(self, parameters, objectives, constraints=None):
+        """Initialize a problem
+        
+        Args:
+            parameters (list): List of Parameter objects
+            objectives (list): List of Objective objects
+            constraints (list, optional): List of Constraint objects. Defaults to None.
+        """
+        self.parameters = parameters
+        self.objectives = objectives
+        self.constraints = constraints or []
+    
+    def get_design_space(self):
+        """Get the design space
+        
+        Returns:
+            list: List of parameter bounds
+        """
+        return [param.bounds for param in self.parameters]

mdo_lib/core/result.py

@@ -0,0 +1,39 @@
+"""Result management module"""
+
+class Sample:
+    """Sample class for optimization problems"""
+    
+    def __init__(self, parameters, values):
+        """Initialize a sample
+        
+        Args:
+            parameters (list): List of Parameter objects
+            values (list): List of parameter values
+        """
+        self.parameters = parameters
+        self.values = values
+
+class Result:
+    """Result class for optimization problems"""
+    
+    def __init__(self, sample, objectives, constraints):
+        """Initialize a result
+        
+        Args:
+            sample (Sample): Sample that was evaluated
+            objectives (list): List of objective values
+            constraints (list): List of constraint values
+        """
+        self.sample = sample
+        self.objectives = objectives
+        self.constraints = constraints
+    
+    def get_best(self):
+        """Get the best result
+        
+        Returns:
+            Result: Best result
+        """
+        # This is a placeholder implementation
+        # In practice, you would compare results based on objectives and constraints
+        return self

mdo_lib/doe/__init__.py

@@ -0,0 +1,13 @@
+"""DOE (Design of Experiments) module"""
+
+from .base import DOE
+from .full_factorial import FullFactorial
+from .latin_hypercube import LatinHypercube
+from .central_composite import CentralComposite
+
+__all__ = [
+    "DOE",
+    "FullFactorial",
+    "LatinHypercube",
+    "CentralComposite",
+]

mdo_lib/doe/base.py

@@ -0,0 +1,22 @@
+"""Base DOE class"""
+
+class DOE:
+    """Base class for Design of Experiments"""
+    
+    def __init__(self, problem, n_samples):
+        """Initialize a DOE
+        
+        Args:
+            problem (Problem): Problem to generate samples for
+            n_samples (int): Number of samples to generate
+        """
+        self.problem = problem
+        self.n_samples = n_samples
+    
+    def generate(self):
+        """Generate samples
+        
+        Returns:
+            list: List of Sample objects
+        """
+        raise NotImplementedError("Subclass must implement generate method")

mdo_lib/doe/central_composite.py

@@ -0,0 +1,61 @@
+"""Central composite design"""
+
+import numpy as np
+from .base import DOE
+from ..core.result import Sample
+
+class CentralComposite(DOE):
+    """Central composite design"""
+    
+    def generate(self):
+        """Generate samples using central composite design
+        
+        Returns:
+            list: List of Sample objects
+        """
+        n_params = len(self.problem.parameters)
+        
+        # Calculate the number of factorial points
+        factorial_points = 2 ** n_params
+        
+        # Calculate the number of axial points
+        axial_points = 2 * n_params
+        
+        # Calculate the number of center points
+        center_points = self.n_samples - factorial_points - axial_points
+        if center_points < 1:
+            center_points = 1
+        
+        # Generate factorial points
+        factorial = np.array([list(np.binary_repr(i, width=n_params)) for i in range(factorial_points)], dtype=int)
+        factorial = 2 * factorial - 1  # Convert to {-1, 1}
+        
+        # Generate axial points
+        axial = np.zeros((axial_points, n_params))
+        alpha = 2 ** (n_params / 4)  # Rotatable design
+        for i in range(n_params):
+            axial[2*i, i] = alpha
+            axial[2*i + 1, i] = -alpha
+        
+        # Generate center points
+        center = np.zeros((center_points, n_params))
+        
+        # Combine all points
+        all_points = np.vstack([factorial, axial, center])
+        
+        # Scale to parameter bounds
+        samples = np.zeros_like(all_points)
+        for i, param in enumerate(self.problem.parameters):
+            if param.bounds:
+                lower, upper = param.bounds
+                # Scale from [-1, 1] to [lower, upper]
+                samples[:, i] = (all_points[:, i] + 1) / 2 * (upper - lower) + lower
+            else:
+                samples[:, i] = all_points[:, i]
+        
+        # Convert to Sample objects
+        result = []
+        for sample in samples:
+            result.append(Sample(self.problem.parameters, sample.tolist()))
+        
+        return result

mdo_lib/doe/full_factorial.py

@@ -0,0 +1,39 @@
+"""Full factorial design"""
+
+import numpy as np
+from .base import DOE
+from ..core.result import Sample
+
+class FullFactorial(DOE):
+    """Full factorial design"""
+    
+    def generate(self):
+        """Generate samples using full factorial design
+        
+        Returns:
+            list: List of Sample objects
+        """
+        # This is a simplified implementation
+        # In practice, you would need to calculate the number of levels based on n_samples
+        n_params = len(self.problem.parameters)
+        levels = int(np.round(self.n_samples ** (1/n_params)))
+        
+        # Generate full factorial design
+        ranges = []
+        for param in self.problem.parameters:
+            if param.bounds:
+                lower, upper = param.bounds
+                ranges.append(np.linspace(lower, upper, levels))
+            else:
+                ranges.append(np.linspace(0, 1, levels))
+        
+        # Create meshgrid and flatten
+        mesh = np.meshgrid(*ranges)
+        samples = np.vstack([grid.ravel() for grid in mesh]).T
+        
+        # Convert to Sample objects
+        result = []
+        for sample in samples:
+            result.append(Sample(self.problem.parameters, sample.tolist()))
+        
+        return result

mdo_lib/doe/latin_hypercube.py

@@ -0,0 +1,43 @@
+"""Latin hypercube design"""
+
+import numpy as np
+from .base import DOE
+from ..core.result import Sample
+
+class LatinHypercube(DOE):
+    """Latin hypercube design"""
+    
+    def generate(self):
+        """Generate samples using Latin hypercube design
+        
+        Returns:
+            list: List of Sample objects
+        """
+        n_params = len(self.problem.parameters)
+        
+        # Generate Latin hypercube design
+        samples = np.zeros((self.n_samples, n_params))
+        
+        for i in range(n_params):
+            # Generate equally spaced intervals
+            intervals = np.linspace(0, 1, self.n_samples + 1)
+            
+            # Randomly permute the intervals
+            permuted = np.random.permutation(self.n_samples)
+            
+            # Generate random points within each interval
+            for j in range(self.n_samples):
+                samples[j, i] = np.random.uniform(intervals[permuted[j]], intervals[permuted[j] + 1])
+        
+        # Scale to parameter bounds
+        for i, param in enumerate(self.problem.parameters):
+            if param.bounds:
+                lower, upper = param.bounds
+                samples[:, i] = samples[:, i] * (upper - lower) + lower
+        
+        # Convert to Sample objects
+        result = []
+        for sample in samples:
+            result.append(Sample(self.problem.parameters, sample.tolist()))
+        
+        return result

mdo_lib/examples/__init__.py

@@ -0,0 +1,13 @@
+"""Examples module"""
+
+from .basic_optimization import run_basic_optimization
+from .surrogate_modeling import run_surrogate_modeling
+from .sensitivity_analysis import run_sensitivity_analysis
+from .reliability_analysis import run_reliability_analysis
+
+__all__ = [
+    "run_basic_optimization",
+    "run_surrogate_modeling",
+    "run_sensitivity_analysis",
+    "run_reliability_analysis",
+]

mdo_lib/examples/basic_optimization.py

@@ -0,0 +1,51 @@
+"""Basic optimization example"""
+
+import sys
+import os
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..')))
+
+from mdo_lib import Problem, Parameter, Objective, Constraint
+from mdo_lib.optimization import GeneticAlgorithm
+
+def run_basic_optimization():
+    """Run basic optimization example"""
+    # 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, {
+        'population_size': 50,
+        'max_generations': 100,
+        'mutation_rate': 0.1,
+        'crossover_rate': 0.8
+    })
+    
+    # Run optimization
+    result = optimizer.optimize()
+    
+    # Print results
+    print("Optimization Results:")
+    print(f"Best point: {result.sample.values}")
+    print(f"Objective value: {result.objectives[0]}")
+    print(f"Constraint value: {result.constraints[0]}")
+
+if __name__ == "__main__":
+    run_basic_optimization()

mdo_lib/examples/reliability_analysis.py

@@ -0,0 +1,61 @@
+"""Reliability analysis example"""
+
+import sys
+import os
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..')))
+
+import numpy as np
+from mdo_lib import Problem, Parameter, Objective
+from mdo_lib.doe import LatinHypercube
+from mdo_lib.surrogate import Kriging
+from mdo_lib.reliability import MonteCarlo, FORM
+from mdo_lib.core import Evaluator
+from mdo_lib.utils import plot_reliability
+
+def run_reliability_analysis():
+    """Run reliability analysis example"""
+    # Define parameters
+    x1 = Parameter('x1', 0.5, bounds=[0, 1])
+    x2 = Parameter('x2', 0.5, bounds=[0, 1])
+    
+    # Define limit state function (failure when > 0)
+    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
+    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)
+    
+    # Perform Monte Carlo reliability analysis
+    print("Monte Carlo Reliability Analysis:")
+    monte_carlo = MonteCarlo(problem, model, n_samples=10000)
+    mc_results = monte_carlo.analyze()
+    print(mc_results)
+    plot_reliability(mc_results)
+    
+    # Perform FORM reliability analysis
+    print("\nFORM Reliability Analysis:")
+    form = FORM(problem, model)
+    form_results = form.analyze()
+    print(form_results)
+
+if __name__ == "__main__":
+    run_reliability_analysis()

mdo_lib/examples/sensitivity_analysis.py

@@ -0,0 +1,62 @@
+"""Sensitivity analysis example"""
+
+import sys
+import os
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..')))
+
+import numpy as np
+from mdo_lib import Problem, Parameter, Objective
+from mdo_lib.doe import LatinHypercube
+from mdo_lib.surrogate import Kriging
+from mdo_lib.sensitivity import SobolIndices, MorrisMethod
+from mdo_lib.core import Evaluator
+from mdo_lib.utils import plot_sensitivity
+
+def run_sensitivity_analysis():
+    """Run sensitivity analysis example"""
+    # Define parameters
+    x1 = Parameter('x1', 0.5, bounds=[0, 1])
+    x2 = Parameter('x2', 0.5, bounds=[0, 1])
+    x3 = Parameter('x3', 0.5, bounds=[0, 1])
+    
+    # Define objective function
+    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
+    doe = LatinHypercube(problem, n_samples=100)
+    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)
+    
+    # Perform Sobol indices analysis
+    print("Sobol Indices Analysis:")
+    sobol = SobolIndices(model, problem, n_samples=1000)
+    sobol_results = sobol.analyze()
+    print(sobol_results)
+    plot_sensitivity(sobol_results, sobol_results['parameter_names'])
+    
+    # Perform Morris method analysis
+    print("\nMorris Method Analysis:")
+    morris = MorrisMethod(model, problem, n_levels=4, n_trajectories=10)
+    morris_results = morris.analyze()
+    print(morris_results)
+
+if __name__ == "__main__":
+    run_sensitivity_analysis()