コード例 #1
0
class Layout(Structure):
    style = String()
    title = String()
    x_label = String()
    x_ticks = List()
    y_label = String()
    y_ticks = List()
    xlim = Tuple()
    ylim = Tuple()
コード例 #2
0
class FillRegion(Structure):
    color_index = Integer()
    start = UnsignedFloat()
    end = UnsignedFloat()

    y_max = UnsignedFloat()

    text = String()
コード例 #3
0
class ComponentSystem(metaclass=StructMeta):
    name = String()

    def __init__(self, name=None, n_comp=None):
        self.name = name
        self._components = []

        if n_comp is not None:
            for comp in range(n_comp):
                self.add_component()

    @property
    def components(self):
        return self._components

    @property
    def n_components(self):
        return len(self.components)

    @property
    def n_comp(self):
        return sum([comp.n_species for comp in self.components])

    def add_component(self, *args, **kwargs):
        component = Component(*args, **kwargs)
        self._components.append(component)

    @property
    def labels(self):
        labels = []
        index = 0
        for comp in self.components:
            for label in comp.labels:
                if label is None:
                    labels.append(str(index))
                else:
                   labels.append(label)
               
                index += 1

        return labels

    @property
    def charges(self):
        charges = []
        for comp in self.components:
            charges += comp.charges

        return charges
コード例 #4
0
class Component(Structure):
    name = String()
    species = List()
    charges = DependentlySizedList(dep='n_species')
    molecular_weight = DependentlySizedList(dep='n_species')

    @property
    def n_species(self):
        if self.species is None:
            return 1
        else:
            return len(self.species)

    @property
    def labels(self):
        if self.species is None:
            return [self.name]
        else:
            return self.species
コード例 #5
0
class OptimizationProblem(metaclass=StructMeta):
    """Class for configuring optimization problems

    Defines lists, dictionaries and variables for creating an
    OptimizationProblem. If no name is set it tries to set the name by the
    evaluation_object name. An excepted AttributeError is ignored.

    Attributes
    ----------
    name : str
        Name of the optimization problem
    evaluation_object :  obj
        Object containing parameters to be optimized.
    evaluator : obj
        Object used to evaluate evaluation_object. Returns performance.
    variables : list
        List of optimization variables
    objectives: list of callables
        Functions that return value of objective function for performance.
    nonlinear_constraints: list of callables
        Functions that return value of nonlinear constraints for performance.
    linear_constraints : list
        List of all linear constraints of an OptimizationProblem.
    linear_equality_constraints : list
        List with all linear equality constrains of an OptimizationProblem.
    eval_dict : dict
        Database for storing evaluated individuals
    """
    name = String()

    def __init__(self,
                 evaluation_object,
                 evaluator=None,
                 name=None,
                 save_log=False):
        if evaluator is not None:
            self.evaluator = evaluator
        else:
            self._evaluator = None

        self.evaluation_object = evaluation_object

        if name is None:
            try:
                name = evaluation_object.name + '_optimization'
            except AttributeError:
                msg = '__init__() missing 1 required positional argument: \'name\''
                raise TypeError(msg)
        self.name = name

        if save_log:
            self.logger = log.get_logger(self.name, log_directory=self.name)
        else:
            self.logger = log.get_logger(self.name)

        self._variables = []
        self._objectives = []
        self._nonlinear_constraints = []
        self._linear_constraints = []
        self._linear_equality_constraints = []
        self._x0 = None

    @property
    def evaluation_object(self):
        """obj : Object that contains all parameters that are optimized.

        Returns
        -------
        evaluation_object : obj
            Object to be evaluated during optimization.

        See also
        --------
        OptimizatonVariable
        Evaluator
        evaluate
        Performance
        objectives
        nonlinear_constraints
        """
        return self._evaluation_object

    @evaluation_object.setter
    def evaluation_object(self, evaluation_object):
        self._evaluation_object = evaluation_object

    @property
    def evaluator(self):
        """Object that performs evaluation object during optimization.

        The evaluator has to implement an evaluate method that returns a
        Performance object when called with the evaluation_object. The
        performance Object is required for calculating the objective function
        and nonlinear constraint function.

        Parameters
        ----------
        evaluator : obj
            Object to be evaluated during optimization.

        Raises
        ------
        CADETProcessError
            If evaluation object does not implement evaluation method.

        See also
        --------
        evaluation_object
        evaluate
        Performance
        objectives
        nonlinear_constraints
        """
        return self._evaluator

    @evaluator.setter
    def evaluator(self, evaluator):
        try:
            getattr(evaluator, 'evaluate')
        except TypeError:
            raise TypeError('Evaluator has to implement evaluate method')

        self._evaluator = evaluator

    @property
    def variables(self):
        """list: List of all optimization variables.
        """
        return self._variables

    @property
    def variables_dict(self):
        """Returns a dictionary with all events in a process.

        Returns
        -------
        events_dict : dict
            Dictionary with all events and durations, indexed by Event.name.
        """
        return {var.name: var for var in self._variables}

    @property
    def n_variables(self):
        """int: Number of optimization variables.
        """
        return len(self.variables)

    def add_variable(self,
                     parameter_path,
                     name=None,
                     lb=-math.inf,
                     ub=math.inf,
                     component_index=None):
        """Add optimization variable to the OptimizationProblem.

        The function encapsulates the creation of OoptimizationVariable objects
        in order to prevent invalid OptimizationVariables.

        Parameters
        ----------
        attr : str
            Attribute of the variable to be added.
        name : str
            Name of the variable to be added, default value is None.
        lb : float
            Lower bound of the variable value.
        ub : float
            Upper bound of the variable value.
        component_index : int
            Index for compnent specific variables

        Raises
        ------
        CADETProcessError
            If the Variable already exists in the dictionary.

        See also
        --------
        evaluation_object
        OptimizationVariable
        remove_variable
        """
        if name is None:
            name = parameter_path

        if name in self.variables_dict:
            raise CADETProcessError("Variable already exists")

        var = OptimizationVariable(name,
                                   self.evaluation_object,
                                   parameter_path,
                                   lb=lb,
                                   ub=ub,
                                   component_index=component_index)

        self._variables.append(var)
        super().__setattr__(name, var)

    def remove_variable(self, var_name):
        """Removes variables from the OptimizationProblem.

        Parameters
        ----------
        var_name : str
            Name of the variable to be removed from list of variables.

        Raises
        ------
        CADETProcessError
            If required variable does not exist.

        See also
        --------
        add_variable
        """
        try:
            var = self.variables_dict[var_name]
        except KeyError:
            raise CADETProcessError("Variable does not exist")

        self._variables.remove(var)
        self.__dict__.pop(var_name)

    def set_variables(self, x, make_copy=False):
        """Sets the values from the x-vector to the OptimizationVariables.

        Parameters
        ----------
         x : array_like
            Value of the optimization variables

        make_copy : Bool
            If True, a copy of the evaluation_object attribute is made on which
            the values are set. Otherwise, the values are set on the attribute.

        Returns
        -------
        evaluation_object : object
            Returns copy of evaluation object if make_copy is True, else returns
            the attribute evaluation_object with the values set.

        Raises
        ------
        ValueError
            If value of variable exceeds bounds

        See also
        --------
        OptimizationVariable
        evaluate
        """
        if len(x) != self.n_variables:
            raise CADETProcessError('Expected {} variables'.format(
                self.n_variables))
        if make_copy:
            evaluation_object = copy.deepcopy(self.evaluation_object)
        else:
            evaluation_object = self.evaluation_object

        for variable, value in zip(self.variables, x):
            if value < variable.lb:
                raise ValueError("Exceeds lower bound")
            if value > variable.ub:
                raise ValueError("Exceeds upper bound")

            if variable.component_index is not None:
                value_list = get_nested_value(evaluation_object.parameters,
                                              variable.parameter_path)
                value_list[variable.component_index] = value
                parameters = generate_nested_dict(variable.parameter_path,
                                                  value_list)
            else:
                parameters = generate_nested_dict(variable.parameter_path,
                                                  value)
            evaluation_object.parameters = parameters

        return evaluation_object

    def evaluate(self, x, make_copy=False, cache=None, force=False):
        """Evaluates the evaluation object at x.

        For performance reasons, the function first checks if the function has
        already been evaluated at x and returns the results. If force is True,
        the lookup is ignored and the function is evaluated regularly.

        Parameters
        ----------
         x : array_like
            Value of the optimization variables
        force : bool
            If True, reevaluation of previously evaluated values is enforced.

        Returns
        -------
        performance : Performance
            Performance object from fractionation.
        """
        x = np.array(x)

        # Try to get cached results
        if cache is not None and not force:
            try:
                performance = cache[tuple(x.tolist())]
                return performance
            except KeyError:
                pass

        # Get evaluation_object
        evaluation_object = self.set_variables(x, make_copy)

        # Set bad results if constraints are not met
        if not self.check_linear_constraints(x):
            self.logger.warn(
                f'Linear constraints not met at {x}. Returning bad performance.\
                cycle time: {evaluation_object.process_meta.cycle_time}')
            performance = get_bad_performance(evaluation_object.n_comp)
        # Pass evaluation_object to evaluator and evaluate
        elif self.evaluator is not None:
            try:
                performance = self.evaluator.evaluate(evaluation_object)
            except CADETProcessError:
                self.logger.warn(
                    'Evaluation failed. Returning bad performance')
                performance = get_bad_performance(evaluation_object.n_comp)
        else:
            performance = evaluation_object.performance

        if cache is not None:
            cache[tuple(x.tolist())] = performance

        self.logger.info('{} evaluated at x={} yielded {}'.format(
            self.evaluation_object.name, tuple(x.tolist()),
            performance.to_dict()))

        return performance

    def evaluate_population(self, population, n_cores=0):
        manager = multiprocess.Manager()
        cache = manager.dict()

        eval_fun = lambda ind: self.evaluate(ind, make_copy=True, cache=cache)

        if n_cores == 1:
            for ind in population:
                try:
                    eval_fun(ind)
                except CADETProcessError:
                    print(ind)
        else:
            if n_cores == 0:
                n_cores = None
            with pathos.multiprocessing.ProcessPool(ncpus=n_cores) as pool:
                pool.map(eval_fun, population)

        return cache

    @property
    def objectives(self):
        return self._objectives

    @property
    def n_objectives(self):
        return len(self.objectives)

    def add_objective(self, objective_fun):
        """Add objective function to optimization problem.

        Parameters
        ----------
        objective_fun : function
            Objective function. Funtion should take a Performance object as
            argument and return a scalar value.

        Raises
        ------
        TypeError
            If objective_fun is not callable.
        """
        if not callable(objective_fun):
            raise TypeError("Expected callable object")

        self._objectives.append(objective_fun)

    def evaluate_objectives(self, x, *args, **kwargs):
        """Function that evaluates at x and computes objective function.

        This function is usually presented to the optimization solver. The
        actual evaluation of the evaluation object is peformed by the evaluate
        function which also logs the results.

        Parameters
        ----------
        x : array_like
            Value of the optimization variables.

        Returns
        -------
        f : list
            Values of the objective functions at point x.

        See Also
        --------
        optimization.SolverBase
        add_objective
        evaluate
        evaluate_nonlinear_constraints
        """
        performance = self.evaluate(x, *args, **kwargs)
        f = np.array([obj(performance) for obj in self.objectives])
        return f

    def objective_gradient(self, x, dx=0.1):
        """Calculate the gradient of the objective functions at point x.

        Gradient is approximated using finite differences.

        Parameters
        ----------
        x : ndarray
            Value of the optimization variables.
        dx : float
            Increment to x to use for determining the function gradient.

        Returns
        -------
        grad: list
            The partial derivatives of the objective functions at point x.

        See Also
        --------
        OptimizationProblem
        objectives
        """
        dx = [dx] * len(x)
        grad = [optimize.approx_fprime(x, obj, dx) for obj in self.objectives]

        return grad

    @property
    def nonlinear_constraints(self):
        return self._nonlinear_constraints

    @property
    def n_nonlinear_constraints(self):
        return len(self.nonlinear_constraints)

    def add_nonlinear_constraint(self, nonlinear_constraint_fun):
        """Add nonlinear constraint function to optimization problem.

        Parameters
        ----------
        nonlinear_constraint_fun: function
            Nonlinear constraint function. Funtion should take a Performance 
            object as argument and return a scalar value or an array.

        Raises
        ------
        TypeError
            If nonlinear_constraint_fun is not callable.
        """
        if not callable(nonlinear_constraint_fun):
            raise TypeError("Expected callable object")

        self._nonlinear_constraints.append(nonlinear_constraint_fun)

    def evaluate_nonlinear_constraints(self, x, *args, **kwargs):
        """Function that evaluates at x and computes nonlinear constraitns.

        This function is usually presented to the optimization solver. The
        actual evaluation of the evaluation object is peformed by the evaluate
        function which also logs the results.

        Parameters
        ----------
        x : array_like
            Value of the optimization variables.

        Returns
        -------
        c : list
            Value(s) of the constraint functions at point x.

        See also
        --------
        nonlinear_constraints
        evaluate
        evaluate_objectives
        """
        performance = self.evaluate(x, *args, **kwargs)
        c = np.array(
            [constr(performance) for constr in self.nonlinear_constraints])
        return c

    def check_nonlinear_constraints(self, x):
        """Checks if all nonlinear constraints are kept.

        Parameters
        ----------
        x : array_like
            Value of the optimization variables.

        Returns
        -------
        flag : bool
            True if all nonlinear constraints are smaller or equal to zero,
            False otherwise.
        """
        c = self.evaluate_nonlinear_constraints(x)
        for constr in c:
            if np.any(constr > 0):
                return False
        return True

    def nonlinear_constraint_jacobian(self, x, dx=1e-3):
        """Return the jacobian matrix of the nonlinear constraints at point x.

        Parameters
        ----------
        x : array_like
            Value of the optimization variables
        dx : float
            Increment to x to use for determining the function gradient.

        Returns
        -------
        jacobian: list
            Value of the partial derivatives at point x.

        See also
        --------
        nonlinear_constraint_fun
        approximate_jac
        """
        jacobian = [
            approximate_jac(x, constr, dx)
            for constr in self.nonlinear_constraints
        ]
        return jacobian

    @property
    def lower_bounds(self):
        """list : List of the lower bounds of all OptimizationVariables.

        See also
        --------
        upper_bounds
        """
        return [var.lb for var in self.variables]

    @property
    def upper_bounds(self):
        """list : List of the upper bounds of all OptimizationVariables.

        See also
        --------
        upper_bounds
        """
        return [var.ub for var in self.variables]

    def check_bounds(self, x):
        """Checks if all bound constraints are kept.

        Parameters
        ----------
        x : array_like
            Value of the optimization variables

        First sets a local variable named flag to True. Then checks if the
        values of the list x are exceeding the lower and upper bounds and sets
        the value of the flag to False. For this the list x is converted into
        an np.array.

        Returns
        -------
        flag : Bool
            Returns True, if the values of the list x are in the defined bounds.
            Returns False if the values of the list x are violating the bound
            constraints.
        """
        flag = True

        if np.any(np.less(x, self.lower_bounds)):
            flag = False
        if np.any(np.greater(x, self.upper_bounds)):
            flag = False

        return flag

    @property
    def linear_constraints(self):
        """list : linear inequality constraints of OptimizationProblem
        
        See Also
        --------
        add_linear_constraint
        remove_linear_constraint
        linear_equality_constraints
        """
        return self._linear_constraints

    @property
    def n_linear_constraints(self):
        """int: number of linear inequality constraints
        """
        return len(self.linear_constraints)

    def add_linear_constraint(self, opt_vars, factors, b=0):
        """Add linear inequality constraints.

        Parameters
        -----------
        opt_vars : list of strings
            Names of the OptimizationVariable to be added.
        factors : list of  integers
            Factors for OptimizationVariables.
        b : float, optional
            Constraint of inequality constraint; default set to zero.

        Raises
        -------
        CADETProcessError
            If optimization variables do not exist.
            If length of factors does not match length of optimization variables.

        See also
        ---------
        linear_constraints
        remove_linear_constraint
        linear_equality_constraints
        """
        if not all(var in self.variables_dict for var in opt_vars):
            raise CADETProcessError('Variable not in variables')

        if len(factors) != len(opt_vars):
            raise CADETProcessError('Factors length does not match variables')

        lincon = dict()
        lincon['opt_vars'] = opt_vars
        lincon['factors'] = factors
        lincon['b'] = b

        self._linear_constraints.append(lincon)

    def remove_linear_constraint(self, index):
        """Removes linear inequality constraint.

        Parameters
        ----------
        index : int
            Index of the linear inequality constraint to be removed.
        
        See also
        --------
        add_linear_equality_constraint
        linear_equality_constraint
        """
        del (self._linear_constraints[index])

    @property
    def A(self):
        """np.ndarray: Matrix form of linear inequality constraints.

        See Also
        --------
        b
        add_linear_constraint
        remove_linear_constraint
        """
        A = np.zeros((len(self.linear_constraints), len(self.variables)))

        for lincon_index, lincon in enumerate(self.linear_constraints):
            for var_index, var in enumerate(lincon['opt_vars']):
                index = self.variables.index(self.variables_dict[var])
                A[lincon_index, index] = lincon['factors'][var_index]

        return A

    @property
    def b(self):
        """list: Vector form of linear constraints.

        See Also
        --------
        A
        add_linear_constraint
        remove_linear_constraint
        """
        b = [lincon['b'] for lincon in self.linear_constraints]

        return np.array(b)

    def evaluate_linear_constraints(self, x):
        """Calculate value of linear inequality constraints at point x.

        Parameters
        ----------
        x : array_like
            Value of the optimization variables.

        Returns
        -------
        constraints: np.array
            Value of the linear constraints at point x

        See Also
        --------
        A
        b
        linear_constraints
        """
        x = np.array(x)
        return self.A.dot(x) - self.b

    def check_linear_constraints(self, x):
        """Check if linear inequality constraints are met at point x.

        Parameters
        ----------
        x : array_like
            Value of the optimization variables.

        Returns
        -------
        flag : bool
            Returns True if linear inequality constraints are met. False otherwise.

        See also:
        ---------
        linear_constraints
        evaluate_linear_constraints
        A
        b
        """
        flag = True

        if np.any(self.evaluate_linear_constraints(x) > 0):
            flag = False

        return flag

    @property
    def linear_equality_constraints(self):
        """list: linear equality constraints of OptimizationProblem

        See Also
        --------
        add_linear_equality_constraint
        remove_linear_equality_constraint
        linear_constraints
        """
        return self._linear_equality_constraints

    @property
    def n_linear_equality_constraints(self):
        """int: number of linear equality constraints
        """
        return len(self.linear_constraints)

    def add_linear_equality_constraint(self, opt_vars, factors, beq=0):
        """Add linear equality constraints.

        Parameters
        -----------
        opt_vars : list of strings
            Names of the OptimizationVariable to be added.
        factors : list of  integers
            Factors for OptimizationVariables.
        b_eq : float, optional
            Constraint of equality constraint; default set to zero.

        Raises
        -------
        CADETProcessError
            If optimization variables do not exist.
            If length of factors does not match length of optimization variables.

        See also
        --------
        linear_equality_constraints
        remove_linear_equality_constraint
        linear_constraints
        """
        if not all(var in self.variables for var in opt_vars):
            return CADETProcessError('Variables not in variables')

        if len(factors) != len(opt_vars):
            return CADETProcessError('Factors length does not match variables')

        lineqcon = dict()
        lineqcon['opt_vars'] = opt_vars
        lineqcon['factors'] = factors
        lineqcon['beq'] = beq

        self._linear_equality_constraints.append(lineqcon)

    def remove_linear_equality_constraint(self, index):
        """Removes at given index the added linear equality conctraint.

        Parameters
        ----------
        index : int
            Index of the linear equality constraint to be removed.

        See also
        --------
        add_linear_equality_constraint
        linear_equality_constraint
        """
        del (self._linear_equality_constraints[index])

    @property
    def Aeq(self):
        """np.ndarray: Matrix form of linear equality constraints.

        See Also
        --------
        beq
        add_linear_equality_constraint
        remove_linear_equality_constraint
        """
        Aeq = np.zeros(
            (len(self.linear_equality_constraints), len(self.variables)))

        for lineqcon_index, lineqcon in enumerate(
                self.linear_equality_constraints):
            for var_index, var in enumerate(lineqcon.opt_vars):
                index = self.variables.index(var)
                Aeq[lineqcon_index, index] = lineqcon.factors[var_index]

        return Aeq

    @property
    def beq(self):
        """list: Vector form of linear equality constraints.

        See Also
        --------
        Aeq
        add_linear_equality_constraint
        remove_linear_equality_constraint
        """
        beq = np.zeros((len(self.linear_equality_constraints), ))
        beq = [lineqcon.beq for lineqcon in self.linear_equality_constraints]

        return beq

    def evaluate_linear_equality_constraints(self, x):
        """Calculate value of linear equality constraints at point x.

        Parameters
        ----------
        x : array_like
            Value of the optimization variables.

        Returns
        -------
        constraints: np.array 
            Value of the linear euqlity constraints at point x

        See Also
        --------
        Aeq
        beq
        linear_equality_constraints
        """
        x = np.array(x)
        return self.Aeq.dot(x) - self.beq

    def check_linear_equality_constraints(self, x):
        """Check if linear equality constraints are met at point x.

        Parameters
        ----------
        x : array_like
            Value of the optimization variables.

        Returns
        -------
        flag : bool
            Returns True if linear equality constraints are met. False otherwise.
        """
        flag = True

        if np.any(self.evaluate_linear_equality_constraints(x) != 0):
            flag = False

        return flag

    @property
    def x0(self):
        """Initival values for optimization.

        Parameters
        ----------
        x0 : array_like
            Initival values for optimization.

        Raises
        ------
        CADETProcessError
            If the initial value does not match length of optimization variables
        """
        return self._x0

    @x0.setter
    def x0(self, x0):
        if not len(x0) == len(self.variables):
            raise CADETProcessError(
                "Starting value must be given for all variables")
        self._x0 = x0

    def create_initial_values(self, n_samples=1, method='random', seed=None):
        """Create initial value within parameter space.
        
        Uses hopsy (Highly Optimized toolbox for Polytope Sampling) to retrieve
        uniformly distributed samples from the parameter space.
        
        Parameters
        ----------
        n_samples : int
            Number of initial values to be drawn
        method : str, optional
            chebyshev: Return center of the minimal-radius ball enclosing the 
                entire set .
            random: Any random valid point in the parameter space.
        seed : int, optional
            Seed to initialize random numbers. Only used if method == 'random'

        Returns
        -------
        init : ndarray
            Initial values for starting the optimization.
        """
        model = hopsy.UniformModel()

        problem = hopsy.Problem(self.A, self.b, model)
        problem = hopsy.add_box_constraints(problem, self.lower_bounds,
                                            self.upper_bounds)

        with warnings.catch_warnings():
            warnings.simplefilter("ignore")

            starting_points = [hopsy.compute_chebyshev_center(problem)]
            run = hopsy.Run(problem, starting_points=starting_points)
            if seed is None:
                seed = random.randint(0, 255)
            run.random_seed = seed
            run.sample(n_samples)

        states = np.array(run.data.states[0])

        if n_samples == 1:
            if method == 'chebyshev':
                states = hopsy.compute_chebyshev_center(problem)
            elif method == 'random':
                states = states[0]
            else:
                raise CADETProcessError("Unexpected method.")

        return states

    @property
    def parameters(self):
        parameters = Dict()

        parameters.variables = {
            opt.name: opt.parameters
            for opt in self.variables
        }
        parameters.linear_constraints = self.linear_constraints

        return parameters

    def __str__(self):
        return self.name
コード例 #6
0
class ReactionBaseClass(metaclass=StructMeta):
    """Abstract base class for parameters of binding models.

    Attributes
    ----------
    n_comp : UnsignedInteger
        number of components.
    parameters : dict
        dict with parameter values.
    name : String
        name of the binding model.
    """
    name = String()
    n_comp = UnsignedInteger()
    
    _parameter_names = []

    def __init__(self, component_system, name=None):
        self.component_system = component_system
        self.name = name
        
        self._parameters = {
            param: getattr(self, param)
            for param in self._parameter_names
        }
        
    @property
    def model(self):
        return self.__class__.__name__
    
    @property
    def component_system(self):
        return self._component_system

    @component_system.setter
    def component_system(self, component_system):
        if not isinstance(component_system, ComponentSystem):
            raise TypeError('Expected ComponentSystem')
        self._component_system = component_system
    
    @property
    def n_comp(self):
        return self.component_system.n_comp
    
    @property
    def parameters(self):
        """dict: Dictionary with parameter values.
        """
        return {param: getattr(self, param) for param in self._parameter_names}

    @parameters.setter
    def parameters(self, parameters):
        for param, value in parameters.items():
            if param not in self._parameter_names:
                raise CADETProcessError('Not a valid parameter')
            setattr(self, param, value)


    def __repr__(self):
        return '{}(n_comp={}, name=\'{}\')'.format(self.__class__.__name__,
            self.n_comp, self.name)

    def __str__(self):
        return self.name
コード例 #7
0
class SimulationResults(metaclass=StructMeta):
    """Class for storing simulation results including the solver configuration

    Attributes
    ----------
    solver_name : str
        Name of the solver used to simulate the process
    solver_parameters : dict
        Dictionary with parameters used by the solver
    exit_flag : int
        Information about the solver termination.
    exit_message : str
        Additional information about the solver status
    time_elapsed : float
        Execution time of simulation.
    process_name : str
        Name of the simulated proces
    process_config : dict
        Configuration of the simulated process
    process_meta : dict
        Meta information of the process.
    solution : dict
        Time signals for all cycles of all Unit Operations.
    system_state : dict
        Final state and state_derivative of the system.
    chromatograms : List of chromatogram
        Solution of the final cycle of the chromatogram_sinks.
    n_cycles : int
        Number of cycles that were simulated.

    Notes
    -----
    Ideally, the final state for each unit operation should be saved. However,
    CADET does currently provide this functionality.
    """
    solver_name = String()
    solver_parameters = Dict()
    exit_flag = UnsignedInteger()
    exit_message = String()
    time_elapsed = UnsignedFloat()
    process_name = String()
    process_config = Dict()
    solution_cycles = Dict()
    system_state = Dict()
    chromatograms = List()

    def __init__(self, solver_name, solver_parameters, exit_flag, exit_message,
                 time_elapsed, process_name, process_config, process_meta,
                 solution_cycles, system_state, chromatograms):
        self.solver_name = solver_name
        self.solver_parameters = solver_parameters

        self.exit_flag = exit_flag
        self.exit_message = exit_message
        self.time_elapsed = time_elapsed

        self.process_name = process_name
        self.process_config = process_config
        self.process_meta = process_meta

        self.solution_cycles = solution_cycles
        self.system_state = system_state
        self.chromatograms = chromatograms

    def update(self, new_results):
        if self.process_name != new_results.process_name:
            raise CADETProcessError('Process does not match')

        self.exit_flag = new_results.exit_flag
        self.exit_message = new_results.exit_message
        self.time_elapsed += new_results.time_elapsed

        self.system_state = new_results.system_state

        self.chromatograms = new_results.chromatograms
        for unit, solutions in self.solution_cycles.items():
            for sol in solutions:
                self.solution_cycles[unit][sol].append(
                    new_results.solution[unit][sol])

    @property
    def solution(self):
        """Construct complete solution from individual cyles.
        """
        cycle_time = self.process_config['parameters']['cycle_time']

        time_complete = self.time_cycle
        for i in range(1, self.n_cycles):
            time_complete = np.hstack(
                (time_complete, self.time_cycle[1:] + i * cycle_time))

        solution = addict.Dict()
        for unit, solutions in self.solution_cycles.items():
            for sol, cycles in solutions.items():
                solution[unit][sol] = copy.deepcopy(cycles[0])
                solution_complete = cycles[0].solution
                for i in range(1, self.n_cycles):
                    solution_complete = np.vstack(
                        (solution_complete, cycles[i].solution[1:]))
                solution[unit][sol].time = time_complete
                solution[unit][sol].solution = solution_complete

        return solution

    @property
    def n_cycles(self):
        return len(
            self.solution_cycles[self._first_unit][self._first_solution])

    @property
    def _first_unit(self):
        return next(iter(self.solution_cycles))

    @property
    def _first_solution(self):
        return next(iter(self.solution_cycles[self._first_unit]))

    @property
    def time_cycle(self):
        """np.array: Solution times vector
        """
        return \
            self.solution_cycles[self._first_unit][self._first_solution][0].time

    def save(self, case_dir, unit=None, start=0, end=None):
        path = os.path.join(settings.project_directory, case_dir)

        if unit is None:
            units = self.solution.keys()
        else:
            units = self.solution[unit]

        for unit in units:
            self.solution[unit][-1].plot(save_path=path + '/' + unit +
                                         '_last.png',
                                         start=start,
                                         end=end)

        for unit in units:
            self.solution_complete[unit].plot(save_path=path + '/' + unit +
                                              '_complete.png',
                                              start=start,
                                              end=end)

        for unit in units:
            self.solution[unit][-1].plot(
                save_path=path + '/' + unit + '_overlay.png',
                overlay=[cyc.signal for cyc in self.solution[unit][0:-1]],
                start=start,
                end=end)
コード例 #8
0
class UnitBaseClass(metaclass=StructMeta):
    """Base class for all UnitOperation classes.

    A UnitOperation object stores model parameters and states of a unit. 
    Every unit operation can be assotiated with a binding behavior and a 
    reaction model.
    UnitOperations can be connected in a FlowSheet. 

    Attributes
    ----------
    n_comp : UnsignedInteger
        Number of components in a system.
    parameters : list
        list of parameter names.
    name : String
        name of the unit_operation.
    binding_model : BindingBaseClass
        binding behavior of the unit. Defaults to NoBinding.
    
    See also
    --------
    FlowSheet
    CADETProcess.binding
    CADETProcess.reaction
    """
    name = String()

    _parameter_names = []
    _section_dependent_parameters = []
    _polynomial_parameters = []
    _initial_state = []

    supports_bulk_reaction = False
    supports_particle_reaction = False

    def __init__(self, component_system, name):
        self.name = name
        self.component_system = component_system

        self._binding_model = NoBinding()

        self._bulk_reaction_model = NoReaction()
        self._particle_reaction_model = NoReaction()

        self._discretization = NoDiscretization()

        self._parameters = {
            param: getattr(self, param)
            for param in self._parameter_names
        }

    @property
    def model(self):
        return self.__class__.__name__

    @property
    def component_system(self):
        return self._component_system

    @component_system.setter
    def component_system(self, component_system):
        if not isinstance(component_system, ComponentSystem):
            raise TypeError('Expected ComponentSystem')
        self._component_system = component_system

    @property
    def n_comp(self):
        return self.component_system.n_comp

    @property
    def parameters(self):
        """dict: Dictionary with parameter values.
        """
        parameters = self._parameters

        if not isinstance(self.binding_model, NoBinding):
            parameters['binding_model'] = self.binding_model.parameters
        if not isinstance(self.bulk_reaction_model, NoReaction):
            parameters[
                'bulk_reaction_model'] = self.bulk_reaction_model.parameters
        if not isinstance(self.particle_reaction_model, NoReaction):
            parameters['particle_reaction_model'] = \
                self.particle_reaction_model.parameters
        if not isinstance(self.discretization, NoDiscretization):
            parameters['discretization'] = \
                self.discretization.parameters

        return parameters

    @parameters.setter
    def parameters(self, parameters):
        try:
            self.binding_model.parameters = parameters.pop('binding_model')
        except KeyError:
            pass
        try:
            self.bulk_reaction_model.parameters = parameters.pop(
                'bulk_reaction_model')
        except KeyError:
            pass
        try:
            self.particle_reaction_model.parameters = parameters.pop(
                'particle_reaction_model')
        except KeyError:
            pass
        try:
            self.discretization.parameters = parameters.pop('discretization')
        except KeyError:
            pass

        for param, value in parameters.items():
            if param not in self._parameters:
                raise CADETProcessError('Not a valid parameter')
            if value is not None:
                setattr(self, param, value)

    @property
    def section_dependent_parameters(self):
        parameters = {
            key: value
            for key, value in self.parameters.items()
            if key in self._section_dependent_parameters
        }

        return parameters

    @property
    def polynomial_parameters(self):
        parameters = {
            key: value
            for key, value in self.parameters.items()
            if key in self._polynomial_parameters
        }
        return parameters

    @property
    def initial_state(self):
        """dict: Dictionary with initial states.
        """
        initial_state = {st: getattr(self, st) for st in self._initial_state}

        return initial_state

    @initial_state.setter
    def initial_state(self, initial_state):
        for st, value in initial_state.items():
            if st not in self._initial_state:
                raise CADETProcessError('Not a valid parameter')
            if value is not None:
                setattr(self, st, value)

    @property
    def binding_model(self):
        """binding_model: BindingModel of the unit_operation.

        Raises
        ------
        TypeError
            If binding_model object is not an instance of BindingBaseClass.
        CADETProcessError
            If number of components do not match.
        """
        return self._binding_model

    @binding_model.setter
    def binding_model(self, binding_model):
        if not isinstance(binding_model, BindingBaseClass):
            raise TypeError('Expected BindingBaseClass')

        if binding_model.component_system is not self.component_system:
            raise CADETProcessError('Component systems do not match.')

        self._binding_model = binding_model

    @property
    def _n_bound_states(self):
        return self.binding_model.n_states

    @property
    def bulk_reaction_model(self):
        """bulk_reaction_model: Reaction model in the bulk phase

        Raises
        ------
        TypeError
            If bulk_reaction_model object is not an instance of ReactionBaseClass.
        CADETProcessError
            If unit does not support bulk reaction model.
            If number of components do not match.
        """
        return self._bulk_reaction_model

    @bulk_reaction_model.setter
    def bulk_reaction_model(self, bulk_reaction_model):
        if not isinstance(bulk_reaction_model, ReactionBaseClass):
            raise TypeError('Expected ReactionBaseClass')
        if not self.supports_bulk_reaction:
            raise CADETProcessError('Unit does not support bulk reactions.')

        if bulk_reaction_model.component_system is not self.component_system \
                and not isinstance(bulk_reaction_model, NoReaction):
            raise CADETProcessError('Component systems do not match.')

        self._bulk_reaction_model = bulk_reaction_model

    @property
    def particle_reaction_model(self):
        """particle_liquid_reaction_model: Reaction model in the particle liquid phase

        Raises
        ------
        TypeError
            If particle_reaction_model object is not an instance of ReactionBaseClass.
        CADETProcessError
            If unit does not support particle reaction model.
            If number of components do not match.
        """
        return self._particle_reaction_model

    @particle_reaction_model.setter
    def particle_reaction_model(self, particle_reaction_model):
        if not isinstance(particle_reaction_model, ReactionBaseClass):
            raise TypeError('Expected ReactionBaseClass')
        if not self.supports_bulk_reaction:
            raise CADETProcessError(
                'Unit does not support particle reactions.')

        if particle_reaction_model.component_system is not self.component_system \
                and not isinstance(particle_reaction_model, NoReaction):
            raise CADETProcessError('Component systems do not match.')

        self._particle_reaction_model = particle_reaction_model

    @property
    def discretization(self):
        """discretization: Discretization Parameters
        """
        return self._discretization

    def __repr__(self):
        """String-depiction of the object, can be changed into an object by
        calling the method eval.

        Returns
        -------
        class.name(parameters with values) : str
            Information about the class's name of an object and its parameters
            like number of components and object name, depicted as a string.
        """
        return '{}(n_comp={}, name=\'{}\')'.format(self.__class__.__name__,
                                                   self.n_comp, self.name)

    def __str__(self):
        """Returns the information von __repr__ as a string object.

        Returns
        -------
        name : String
            Information about the class's name of an object and its paremeters
            like number of components and object name
        """
        return self.name
コード例 #9
0
class FlowSheet(metaclass=StructMeta):
    """Class to design process flow sheet.

    In this class, UnitOperation models are added and connected in a flow
    sheet.

    Attributes
    ----------
    n_comp : UnsignedInteger
        Number of components of the units in the flow sheet.
    name : String
        Name of the FlowSheet.
    units : list
        UnitOperations in the FlowSheet.
    connections : dict
        Connections of UnitOperations.
    output_states : dict
        Split ratios of outgoing streams of UnitOperations.
    """

    name = String()
    n_comp = UnsignedInteger()
    
    def __init__(self, component_system, name=None):
        self.component_system = component_system
        self.name = name
        self._units = []
        self._feed_sources = []
        self._eluent_sources = []
        self._chromatogram_sinks = []
        self._connections = Dict()
        self._output_states = Dict()
        self._flow_rates = Dict()
        self._parameters = Dict()
        self._section_dependent_parameters = Dict()
        self._polynomial_parameters = Dict()

    @property
    def component_system(self):
        return self._component_system

    @component_system.setter
    def component_system(self, component_system):
        if not isinstance(component_system, ComponentSystem):
            raise TypeError('Expected ComponentSystem')
        self._component_system = component_system
        
    @property
    def n_comp(self):
        return self.component_system.n_comp
            
    def _unit_name_decorator(func):
        def wrapper(self, unit, *args, **kwargs):
            """Enable calling functions with unit object or unit name.
            """
            if isinstance(unit, str):
                try:
                    unit = self.units_dict[unit]
                except KeyError:
                    raise CADETProcessError('Not a valid unit')
            return func(self, unit, *args, **kwargs)

        return wrapper
    
    def update_parameters(self):
        for unit in self.units:
            self._parameters[unit.name] = unit.parameters
            self._section_dependent_parameters[unit.name] = \
                unit.section_dependent_parameters
            self._polynomial_parameters[unit.name] = unit.polynomial_parameters
        
        self._parameters['output_states'] = {
            unit.name: self.output_states[unit] for unit in self.units
        }
        
        self._section_dependent_parameters['output_states'] = {
            unit.name: self.output_states[unit] 
            for unit in self.units
        }
        
    def update_parameters_decorator(func):
        def wrapper(self, *args, **kwargs):
            """Update parameters dict to save time.
            """
            results = func(self, *args, **kwargs)
            self.update_parameters()
            
            return results
        return wrapper

    @property
    def units(self):
        """list: list of all unit_operations in the flow sheet.
        """
        return self._units

    @property
    def units_dict(self):
        """dict: Unit names and objects.
        """
        return {unit.name: unit for unit in self.units}
    
    @property
    def unit_names(self):
        """list: Unit names
        """
        return [unit.name for unit in self.units]
    
    @property
    def number_of_units(self):
        """int: Number of unit operations in the FlowSheet.
        """
        return len(self._units)

    @_unit_name_decorator
    def get_unit_index(self, unit):
        """Return the unit index of the unit.

        Parameters
        ----------
        unit : UnitBaseClass
            UnitBaseClass object of which the index is to be returned.

        Raises
        ------
        CADETProcessError
            If unit does not exist in the current flow sheet.

        Returns
        -------
        unit_index : int
            Returns the unit index of the unit_operation.
        """
        if unit not in self.units:
            raise CADETProcessError('Unit not in flow sheet')

        return self.units.index(unit)

    @property
    def sources(self):
        """list: All UnitOperations implementing the SourceMixin interface.
        """
        return [unit for unit in self._units if isinstance(unit, SourceMixin)]

    @property
    def sinks(self):
        """list: All UnitOperations implementing the SinkMixin interface.
        """
        return [unit for unit in self._units if isinstance(unit, SinkMixin)]

    @property
    def units_with_binding(self):
        """list: UnitOperations with binding models.
        """
        return [unit for unit in self._units
                if not isinstance(unit.binding_model, NoBinding)]

    @update_parameters_decorator
    def add_unit(
            self, unit, 
            feed_source=False, eluent_source=False, chromatogram_sink=False
        ):
        """Add unit to the flow sheet.

        Parameters
        ----------
        unit : UnitBaseClass
            UnitBaseClass object to be added to the flow sheet.
        feed_source : bool
            If True, add unit to feed sources.
        eluent_source : bool
            If True, add unit to eluent sources.
        chromatogram_sink : bool
            If True, add unit to chromatogram sinks.

        Raises
        ------
        TypeError
            If unit is no instance of UnitBaseClass.
        CADETProcessError
            If unit already exists in flow sheet.
            If n_comp does not match with FlowSheet.

        See Also
        --------
        remove_unit
        """
        if not isinstance(unit, UnitBaseClass):
            raise TypeError('Expected UnitOperation')

        if unit in self._units:
            raise CADETProcessError('Unit already part of System')

        if unit.component_system is not self.component_system:
            raise CADETProcessError('Component systems do not match.')

        self._units.append(unit)
        self._connections[unit] = Dict({
            'origins': [], 
            'destinations': [],
        })
        self._output_states[unit] = []
        self._flow_rates[unit] = []
        
        super().__setattr__(unit.name, unit)

        if feed_source:
            self.add_feed_source(unit)
        if eluent_source:
            self.add_eluent_source(unit)
        if chromatogram_sink:
            self.add_chromatogram_sink(unit)


    @update_parameters_decorator
    def remove_unit(self, unit):
        """Remove unit from flow sheet.

        Removes unit from the list. Tries to remove units which are twice
        located as desinations. For this the origins and destinations are
        deleted for the unit. Raises a CADETProcessError if an ValueError is
        excepted. If the unit is specified as feed_source, eluent_source
        or chromatogram_sink, the corresponding attributes are deleted.

        Parameters
        ----------
        unit : UnitBaseClass
            UnitBaseClass object to be removed to the flow sheet.

        Raises
        ------
        CADETProcessError
            If unit does not exist in the flow sheet.

        See Also
        --------
        add_unit
        feed_source
        eluent_source
        chromatogram_sink
        """
        if unit not in self.units:
            raise CADETProcessError('Unit not in flow sheet')

        if unit is self.feed_sources:
            self.remove_feed_source(unit)
        if unit is self.eluent_sources:
            self.remove_eluent_source(unit)
        if unit is self.chromatogram_sinks:
            self.remove_chromatogram_sink(unit)

        origins = self.connections[unit].origins.copy()
        for origin in origins:
            self.remove_connection(origin, unit)

        destinations = self.connections[unit].destinations.copy()
        for destination in destinations:
            self.remove_connection(unit, destination)

        self._units.remove(unit)
        self._connections.pop(unit)
        self._output_states.pop(unit)
        self.__dict__.pop(unit.name)

    @property
    def connections(self):
        """dict: In- and outgoing connections for each unit.

        See Also
        --------
        add_connection
        remove_connection
        """
        return self._connections
    
    @update_parameters_decorator
    def add_connection(self, origin, destination):
        """Add connection between units 'origin' and 'destination'.

        Parameters
        ----------
        origin : UnitBaseClass
            UnitBaseClass from which the connection originates.
        destination : UnitBaseClass
            UnitBaseClass where the connection terminates.

        Raises
        ------
        CADETProcessError
            If origin OR destination do not exist in the current flow sheet.
            If connection already exists in the current flow sheet.

        See Also
        --------
        connections
        remove_connection
        output_state
        """
        if origin not in self._units:
            raise CADETProcessError('Origin not in flow sheet')
        if destination not in self._units:
            raise CADETProcessError('Destination not in flow sheet')
        
        if destination in self.connections[origin].destinations:
            raise CADETProcessError('Connection already exists')

        self._connections[origin].destinations.append(destination)
        self._connections[destination].origins.append(origin)        
        
        self.set_output_state(origin, 0)

    @update_parameters_decorator
    def remove_connection(self, origin, destination):
        """Remove connection between units 'origin' and 'destination'.

        Parameters
        ----------
        origin : UnitBaseClass
            UnitBaseClass from which the connection originates.
        destination : UnitBaseClass
            UnitBaseClass where the connection terminates.

        Raises
        ------
        CADETProcessError
            If origin OR destination do not exist in the current flow sheet.
            If connection does not exists in the current flow sheet.

        See Also
        --------
        connections
        add_connection
        """
        if origin not in self._units:
            raise CADETProcessError('Origin not in flow sheet')
        if destination not in self._units:
            raise CADETProcessError('Destination not in flow sheet')

        try:
            self._connections[origin].destinations.remove(destination)
            self._connections[destination].origins.remove(origin)
        except KeyError:
            raise CADETProcessError('Connection does not exist.')

    @property
    def output_states(self):
        return self._output_states
    
    @_unit_name_decorator
    @update_parameters_decorator
    def set_output_state(self, unit, state):
        """Set split ratio of outgoing streams for UnitOperation.
        
        Parameters
        ----------
        unit : UnitBaseClass
            UnitOperation of flowsheet.
        state : int or list of floats
            new output state of the unit. 

        Raises
        ------
        CADETProcessError
            If unit not in flowSheet
            If state is integer and the state >= the state_length.
            If the length of the states is unequal the state_length.
            If the sum of the states is not equal to 1.
        """
        if unit not in self._units:
            raise CADETProcessError('Unit not in flow sheet')
            
        state_length = len(self.connections[unit].destinations)

        if state_length == 0:
            output_state = []

        if isinstance(state, (int, np.int64)):
            if state >= state_length:
                raise CADETProcessError('Index exceeds destinations')

            output_state = [0] * state_length
            output_state[state] = 1

        else:
            if len(state) != state_length:
                raise CADETProcessError(
                    'Expected length {}.'.format(state_length))

            elif sum(state) != 1:
                raise CADETProcessError('Sum of fractions must be 1')

            output_state = state

        self._output_states[unit] = output_state                    

    
    def get_flow_rates(self, state=None):
        """Calculate flow rate for all connections.unit operation flow rates.
        
        If an additional state is passed, it will b
        
        Parameters
        ----------
        state : Dict, optional
            Output states

        Returns
        -------
        flow_rates : Dict
            Volumetric flow rate of each unit operation.

        """
        flow_rates = {
            unit.name: unit.flow_rate for unit in self.sources
        }
        output_states = self.output_states

        if state is not None:
            for param, value in state.items():
                param = param.split('.')
                unit_name = param[1]
                param_name = param[-1]
                if param_name == 'flow_rate':
                    flow_rates[unit_name] = value[0]
                elif unit_name == 'output_states':
                    unit = self.units_dict[param_name]
                    output_states[unit] = list(value.ravel())
        
        def list_factory():
            return [0,0,0,0]
        
        total_flow_rates = {unit.name: list_factory() for unit in self.units}
        destination_flow_rates = {
            unit.name: defaultdict(list_factory) for unit in self.units
        }
        
        for i in range(4):
            solution = self.solve_flow_rates(flow_rates, output_states, i)
            if solution is not None:
                for unit_index, unit in enumerate(self.units):
                    total_flow_rates[unit.name][i] = \
                        float(solution['Q_total_{}'.format(unit_index)])
                    
                    for destination in self.connections[unit].destinations:
                        destination_index = self.get_unit_index(destination)
                        destination_flow_rates[unit.name][destination.name][i] = \
                            float(solution['Q_{}_{}'.format(unit_index, destination_index)])
        
        flow_rates = Dict()
        for unit in self.units:
            flow_rates[unit.name].total = np.array(total_flow_rates[unit.name])
            for destination, flow_rate in destination_flow_rates[unit.name].items():
                flow_rates[unit.name].destinations[destination] = np.array(flow_rate)
        
        return flow_rates                

    def solve_flow_rates(self, source_flow_rates, output_states, coeff=0):
        """Solve flow rates of system using sympy.
        
        Because a simple 'push' algorithm cannot be used when closed loops are
        present in a FlowSheet (e.g. SMBs), sympy is used to set up and solve 
        the system of equations.
    
        Parameters
        ----------
        source_flow_rates: dict
            Flow rates of Source UnitOperations.
        output_states: dict
            Output states of all UnitOperations.
        coeff: int
            Polynomial coefficient of flow rates to be solved.
    
        Returns
        -------
        solution : dict
            Solution of the flow rates in the system
            
        Note
        ----
        Since dynamic flow rates can be described as cubic polynomials, the
        flow rates are solved individually for all coefficients.
        """
        coeffs = np.array(
            [source_flow_rates[unit.name][coeff] for unit in self.sources]
        )
        if not np.any(coeffs):
            return None
        
        # Setup lists for symbols
        unit_total_flow_symbols = sym.symbols(
            'Q_total_0:{}'.format(self.number_of_units)
        )
        unit_inflow_symbols = []
        unit_outflow_symbols = []
        
        unit_total_flow_eq = []
        unit_outflow_eq = []
        
        # Setup symbolic equations
        for unit_index, unit in enumerate(self.units):
            if isinstance(unit, SourceMixin):
                unit_total_flow_eq.append(
                    sym.Add(
                        unit_total_flow_symbols[unit_index], 
                        - float(source_flow_rates[unit.name][coeff])
                    )
                )
            else:
                unit_i_inflow_symbols = []
                
                for origin in self.connections[unit].origins:
                    origin_index = self.get_unit_index(origin)
                    unit_i_inflow_symbols.append(
                        sym.symbols('Q_{}_{}'.format(origin_index, unit_index))
                    )
                    
                unit_i_total_flow_eq = sym.Add(
                    *unit_i_inflow_symbols, -unit_total_flow_symbols[unit_index]
                )
                
                unit_inflow_symbols += unit_i_inflow_symbols
                unit_total_flow_eq.append(unit_i_total_flow_eq)
                
            if not isinstance(unit, Sink):
                output_state = output_states[unit]
                unit_i_outflow_symbols = []
                
                for destination in self.connections[unit].destinations:
                    destination_index = self.get_unit_index(destination)
                    unit_i_outflow_symbols.append(
                        sym.symbols('Q_{}_{}'.format(unit_index, destination_index))
                    )
                    
                unit_i_outflow_eq = [
                    sym.Add(
                        unit_i_outflow_symbols[dest],
                        -unit_total_flow_symbols[unit_index]*output_state[dest]
                    )
                    for dest in range(len(self.connections[unit].destinations))
                ]
                                     
                unit_outflow_symbols += unit_i_outflow_symbols
                unit_outflow_eq += unit_i_outflow_eq
                
        # Solve system of equations
        solution = sym.solve(
            unit_total_flow_eq + unit_outflow_eq, 
            (*unit_total_flow_symbols, *unit_inflow_symbols, *unit_outflow_symbols)
        )
        solution = {str(key): value for key, value in solution.items()}
        
        return solution
    
    @property
    def feed_sources(self):
        """list: List of sources considered for calculating recovery yield.
        """
        return self._feed_sources

    @_unit_name_decorator
    def add_feed_source(self, feed_source):
        """Add source to list of units to be considered for recovery.

        Parameters
        ----------
        feed_source : SourceMixin
            Unit to be added to list of feed sources

        Raises
        ------
        CADETProcessError
            If unit is not in a source object
            If unit is already marked as feed source
        """
        if feed_source not in self.sources:
            raise CADETProcessError('Expected Source')
        if feed_source in self._feed_sources:
            raise CADETProcessError(
                '{} is already eluent source'.format(feed_source)
            )
        self._feed_sources.append(feed_source)

    @_unit_name_decorator
    def remove_feed_source(self, feed_source):
        """Remove source from list of units to be considered for recovery.

        Parameters
        ----------
        feed_source : SourceMixin
            Unit to be removed from list of feed sources.
        """
        if feed_source not in self._feed_sources:
            raise CADETProcessError('Unit \'{}\' is not a feed source.'.format(
                    feed_source))
        self._feed_sources.remove(feed_source)

    @property
    def eluent_sources(self):
        """list: List of sources to be considered for eluent consumption.
        """
        return self._eluent_sources

    @_unit_name_decorator
    def add_eluent_source(self, eluent_source):
        """Add source to list of units to be considered for eluent consumption.

        Parameters
        ----------
        eluent_source : SourceMixin
            Unit to be added to list of eluent sources.

        Raises
        ------
        CADETProcessError
            If unit is not in a source object
            If unit is already marked as eluent source
        """
        if eluent_source not in self.sources:
            raise CADETProcessError('Expected Source')
        if eluent_source in self._eluent_sources:
            raise CADETProcessError('{} is already eluent source'.format(
                    eluent_source))
        self._eluent_sources.append(eluent_source)

    @_unit_name_decorator
    def remove_eluent_source(self, eluent_source):
        """Remove source from list of units to be considered eluent consumption.

        Parameters
        ----------
        eluent_source : SourceMixin
            Unit to be added to list of eluent sources.
        
        Raises
        ------
        CADETProcessError
            If unit is not in eluent sources
        """
        if eluent_source not in self._eluent_sources:
            raise CADETProcessError('Unit \'{}\' is not an eluent source.'.format(
                    eluent_source))
        self._eluent_sources.remove(eluent_source)

    @property
    def chromatogram_sinks(self):
        """list: List of sinks to be considered for fractionation.
        """
        return self._chromatogram_sinks

    @_unit_name_decorator
    def add_chromatogram_sink(self, chromatogram_sink):
        """Add sink to list of units to be considered for fractionation.

        Parameters
        ----------
        chromatogram_sink : SinkMixin
            Unit to be added to list of chromatogram sinks.

        Raises
        ------
        CADETProcessError
            If unit is not a sink object.
            If unit is already marked as chromatogram sink.
        """
        if chromatogram_sink not in self.sinks:
            raise CADETProcessError('Expected Sink')
        if chromatogram_sink in self._chromatogram_sinks:
            raise CADETProcessError(
                '{} is already chomatogram sink'.format(chromatogram_sink)
            )
        self._chromatogram_sinks.append(chromatogram_sink)

    @_unit_name_decorator
    def remove_chromatogram_sink(self, chromatogram_sink):
        """Remove sink from list of units to be considered for fractionation.

        Parameters
        ----------
        chromatogram_sink : SinkMixin
            Unit to be added to list of chromatogram sinks.

        Raises
        ------
        CADETProcessError
            If unit is not a chromatogram sink.
        """
        if chromatogram_sink not in self._chromatogram_sinks:
            raise CADETProcessError(
                'Unit \'{}\' is not a chromatogram sink.'.format(chromatogram_sink)
            )
        self._chromatogram_sinks.remove(chromatogram_sink)


    @property
    def parameters(self):
        return self._parameters

    @parameters.setter
    def parameters(self, parameters):
        try:
            output_states = parameters.pop('output_states')
            for unit, state in output_states.items():
                unit = self.units_dict[unit]
                self.set_output_state(unit, state)
        except KeyError:
            pass
        
        for unit, params in parameters.items():
            if unit not in self.units_dict:
                raise CADETProcessError('Not a valid unit')
            self.units_dict[unit].parameters = params
            
        self.update_parameters()

    @property
    def section_dependent_parameters(self):
        return self._section_dependent_parameters

    @property
    def polynomial_parameters(self):
        return self._polynomial_parameters

    @property
    def initial_state(self):
        initial_state = {unit.name: unit.initial_state for unit in self.units}

        return initial_state

    @initial_state.setter
    def initial_state(self, initial_state):
        for unit, st in initial_state.items():
            if unit not in self.units_dict:
                raise CADETProcessError('Not a valid unit')
            self.units_dict[unit].initial_state = st
            
            
    def __getitem__(self, unit_name):
        """Make FlowSheet substriptable s.t. units can be used as keys.

        Parameters
        ----------
        unit_name : str
            Name of the unit.

        Returns
        -------
        unit : UnitBaseClass
            UnitOperation of flowsheet.

        Raises
        ------
        KeyError
            If unit not in flowSheet
        """
        try:
            return self.units_dict[unit_name]
        except KeyError:
            raise KeyError('Not a valid unit')


    def __contains__(self, item):
        """Check if an item is part of units.

        Parameters
        ----------
        item : UnitBaseClass
            item to be searched

        Returns
        -------
        Bool : True if item is in units, otherwise False.

        Note
        ----
        maybe deficient in documentation.
        """
        if (item in self._units) or (item in self.unit_names):
            return True
        else:
            return False
コード例 #10
0
class TimeSignal(metaclass=StructMeta):
    """Class for storing concentration profiles after simulation.

    Attributes
    ----------
    time : NdArray
        NdArray object for the time of a chromatogram.
    signal : NdArray
        NdArray of the concentration of a chromatogram.
    cycle_time : float
            Maximum value of time vector.
    """
    time = NdArray()
    signal = NdArray()
    cycle_time = Float()
    name = String()

    def __init__(self, time, signal, name=''):
        self.time = time
        self.signal = signal
        self.name = name
        self.cycle_time = float(max(self.time))

    @plotting.save_fig
    def plot(self, start=0, end=None):
        """Plots the whole time_signal for each component.

        Parameters
        ----------
        start : float
            start time for plotting
        end : float
            end time for plotting

        See also
        --------
        plotlib
        plot_purity
        """
        x = self.time / 60
        y = self.signal

        fig, ax = plotting.setup_figure()
        ax.plot(x,y)

        layout = plotting.Layout()
        layout.x_label = '$time~/~min$'
        layout.y_label = '$c~/~mol \cdot L^{-1}$'
        layout.xlim = (start, end)
        layout.ylim = (0, 1.1*np.max(y))
        
        plotting.set_layout(fig, ax, layout)        

        return ax

    @property
    def local_purity(self):
        """Returns the local purity of the signal.

        Creates an array with the size of the signal with zero values. An array
        with the sum of the signal is created. Every value for signal_sum under
        a defined value is set to NaN. The other values are set for each
        component. Errorstatehandling of floating point error by the division:
        ignores the divide and invalid. Returns a NaN, for zero and infinity
        with large finite numbers.

        Returns
        -------
        local_purity : NdArray
            Returns the local purity for each component as an array.
        """
        purity = np.zeros(self.signal.shape)
        signal_sum = self.signal.sum(1)
        signal_sum[signal_sum < 1e-6] = np.nan
        for comp in range(self.n_comp):
            signal = self.signal[:,comp]
            with np.errstate(divide='ignore', invalid='ignore'):
                purity[:,comp] = np.divide(signal, signal_sum)
        purity = np.nan_to_num(purity)

        return np.nan_to_num(purity)
    
    @plotting.save_fig
    def plot_purity(self, start=0, end=None):
        """Plots the local purity for each component of the concentration
        profile.

        Parameters
        ----------
        start : float
            start time for plotting
        end : float
            ent time for plotting

        See also
        --------
        plotlib
        plot
        """
        x = self.time / 60
        y = self.local_purity * 100

        fig, ax = plotting.setup_figure()
        ax.plot(x,y)

        layout = plotting.Layout()
        layout.x_label = '$time~/~min$'
        layout.y_label = '$c~/~mol \cdot L^{-1}$'
        layout.xlim = (start, end)
        layout.ylim = (0, 1.1*np.max(y))
        
        plotting.set_layout(fig, ax, layout)        
        
        return ax

    @property
    def n_comp(self):
        """Number of components of the signal

        Returns
        --------
        n_comp : int
            Returns the number of the components for the signal.
        """
        return self.signal.shape[1]

    def __str__(self):
        return self.__class__.__name__
コード例 #11
0
class SecondaryAxis(Structure):
    component_indices = List()
    y_label = String()
    transform = Callable()
コード例 #12
0
class Annotation(Structure):
    text = String()
    xy = Tuple()
    xytext = Tuple()
    arrowstyle = '-|>'
コード例 #13
0
class Tick(Structure):
    location: Tuple()
    label: String()
コード例 #14
0
class OptimizationResults(metaclass=StructMeta):
    """Class for storing optimization results including the solver configuration

    Attributes
    ----------
    optimization_problem : OptimizationProblem
        Optimization problem
    evaluation_object : obj
        Evaluation object in optimized state.
    solver_name : str
        Name of the solver used to simulate the process
    solver_parameters : dict
        Dictionary with parameters used by the solver
    exit_flag : int
        Information about the solver termination.
    exit_message : str
        Additional information about the solver status
    time_elapsed : float
        Execution time of simulation.
    x : list
        Values of optimization variables at optimum.
    f : np.ndarray
        Value of objective function at x.
    c : np.ndarray
        Values of constraint function at x
    """
    x0 = List()
    solver_name = String()
    solver_parameters = Dict()
    exit_flag = UnsignedInteger()
    exit_message = String()
    time_elapsed = UnsignedFloat()
    x = List()
    f = NdArray()
    c = NdArray()
    performance = Dict()

    def __init__(
            self, optimization_problem, evaluation_object,
            solver_name, solver_parameters, exit_flag, exit_message,
            time_elapsed, x, f, c, performance, frac=None, history=None
        ):

        self.optimization_problem = optimization_problem
        self.evaluation_object = evaluation_object

        self.solver_name = solver_name
        self.solver_parameters = solver_parameters

        self.exit_flag = exit_flag
        self.exit_message = exit_message
        self.time_elapsed = time_elapsed

        self.x = x
        self.f = f
        if c is not None:
            self.c = c

        self.performance = performance

        self.frac = frac
        
        self.history = history


    def to_dict(self):
        return {
            'optimization_problem': self.optimization_problem.name,
            'optimization_problem_parameters':
                self.optimization_problem.parameters,
            'evaluation_object_parameters':
                self.evaluation_object.parameters,
            'x0': self.optimization_problem.x0,
            'solver_name': self.solver_name,
            'solver_parameters': self.solver_parameters,
            'exit_flag': self.exit_flag,
            'exit_message': self.exit_message,
            'time_elapsed': self.time_elapsed,
            'x': self.x,
            'f': self.f.tolist(),
            'c': self.c.tolist(),
            'performance': self.performance,
            'git': {
                'chromapy_branch': str(settings.repo.active_branch),
                'chromapy_commit': settings.repo.head.object.hexsha
            }
        }

    def save(self, directory):
        path = os.path.join(settings.project_directory, directory, 'results.json')
        with open(path, 'w') as f:
            json.dump(self.to_dict(), f, indent=4)

    def plot_solution(self):
        pass