Ejemplo n.º 1
0
class OptiProblem(FrozenClass):
    """Multi-objectives optimization problem with some constraints"""

    VERSION = 1

    # cf Methods.Optimization.OptiProblem.eval_pb
    if isinstance(eval_pb, ImportError):
        eval_pb = property(fget=lambda x: raise_(
            ImportError("Can't use OptiProblem method eval_pb: " + str(eval_pb)
                        )))
    else:
        eval_pb = eval_pb
    # save method is available in all object
    save = save

    def __init__(
            self,
            output=-1,
            design_var=dict(),
            obj_func=dict(),
            eval_func=None,
            constraint=dict(),
            init_dict=None,
    ):
        """Constructor of the class. Can be use in two ways :
        - __init__ (arg1 = 1, arg3 = 5) every parameters have name and default values
            for Matrix, None will initialise the property with an empty Matrix
            for pyleecan type, None will call the default constructor
        - __init__ (init_dict = d) d must be a dictionnary wiht every properties as keys

        ndarray or list can be given for Vector and Matrix
        object or dict can be given for pyleecan Object"""

        if output == -1:
            output = Output()
        if init_dict is not None:  # Initialisation by dict
            check_init_dict(
                init_dict,
                [
                    "output", "design_var", "obj_func", "eval_func",
                    "constraint"
                ],
            )
            # Overwrite default value with init_dict content
            if "output" in list(init_dict.keys()):
                output = init_dict["output"]
            if "design_var" in list(init_dict.keys()):
                design_var = init_dict["design_var"]
            if "obj_func" in list(init_dict.keys()):
                obj_func = init_dict["obj_func"]
            if "eval_func" in list(init_dict.keys()):
                eval_func = init_dict["eval_func"]
            if "constraint" in list(init_dict.keys()):
                constraint = init_dict["constraint"]
        # Initialisation by argument
        self.parent = None
        # output can be None, a Output object or a dict
        if isinstance(output, dict):
            self.output = Output(init_dict=output)
        else:
            self.output = output
        # design_var can be None or a dict of OptiDesignVar object
        self.design_var = dict()
        if type(design_var) is dict:
            for key, obj in design_var.items():
                if isinstance(obj, dict):
                    self.design_var[key] = OptiDesignVar(init_dict=obj)
                else:
                    self.design_var[key] = obj
        elif design_var is None:
            self.design_var = dict()
        else:
            self.design_var = design_var  # Should raise an error
        # obj_func can be None or a dict of OptiObjFunc object
        self.obj_func = dict()
        if type(obj_func) is dict:
            for key, obj in obj_func.items():
                if isinstance(obj, dict):
                    self.obj_func[key] = OptiObjFunc(init_dict=obj)
                else:
                    self.obj_func[key] = obj
        elif obj_func is None:
            self.obj_func = dict()
        else:
            self.obj_func = obj_func  # Should raise an error
        self.eval_func = eval_func
        # constraint can be None or a dict of OptiConstraint object
        self.constraint = dict()
        if type(constraint) is dict:
            for key, obj in constraint.items():
                if isinstance(obj, dict):
                    self.constraint[key] = OptiConstraint(init_dict=obj)
                else:
                    self.constraint[key] = obj
        elif constraint is None:
            self.constraint = dict()
        else:
            self.constraint = constraint  # Should raise an error

        # The class is frozen, for now it's impossible to add new properties
        self._freeze()

    def __str__(self):
        """Convert this objet in a readeable string (for print)"""

        OptiProblem_str = ""
        if self.parent is None:
            OptiProblem_str += "parent = None " + linesep
        else:
            OptiProblem_str += ("parent = " + str(type(self.parent)) +
                                " object" + linesep)
        if self.output is not None:
            tmp = self.output.__str__().replace(linesep,
                                                linesep + "\t").rstrip("\t")
            OptiProblem_str += "output = " + tmp
        else:
            OptiProblem_str += "output = None" + linesep + linesep
        if len(self.design_var) == 0:
            OptiProblem_str += "design_var = dict()" + linesep
        for key, obj in self.design_var.items():
            tmp = (self.design_var[key].__str__().replace(
                linesep, linesep + "\t") + linesep)
            OptiProblem_str += "design_var[" + key + "] =" + tmp + linesep + linesep
        if len(self.obj_func) == 0:
            OptiProblem_str += "obj_func = dict()" + linesep
        for key, obj in self.obj_func.items():
            tmp = (
                self.obj_func[key].__str__().replace(linesep, linesep + "\t") +
                linesep)
            OptiProblem_str += "obj_func[" + key + "] =" + tmp + linesep + linesep
        if self._eval_func[1] is None:
            OptiProblem_str += "eval_func = " + str(self._eval_func[1])
        else:
            OptiProblem_str += ("eval_func = " + linesep +
                                str(self._eval_func[1]) + linesep + linesep)
        if len(self.constraint) == 0:
            OptiProblem_str += "constraint = dict()" + linesep
        for key, obj in self.constraint.items():
            tmp = (self.constraint[key].__str__().replace(
                linesep, linesep + "\t") + linesep)
            OptiProblem_str += "constraint[" + key + "] =" + tmp + linesep + linesep
        return OptiProblem_str

    def __eq__(self, other):
        """Compare two objects (skip parent)"""

        if type(other) != type(self):
            return False
        if other.output != self.output:
            return False
        if other.design_var != self.design_var:
            return False
        if other.obj_func != self.obj_func:
            return False
        if other.eval_func != self.eval_func:
            return False
        if other.constraint != self.constraint:
            return False
        return True

    def as_dict(self):
        """Convert this objet in a json seriable dict (can be use in __init__)
        """

        OptiProblem_dict = dict()
        if self.output is None:
            OptiProblem_dict["output"] = None
        else:
            OptiProblem_dict["output"] = self.output.as_dict()
        OptiProblem_dict["design_var"] = dict()
        for key, obj in self.design_var.items():
            OptiProblem_dict["design_var"][key] = obj.as_dict()
        OptiProblem_dict["obj_func"] = dict()
        for key, obj in self.obj_func.items():
            OptiProblem_dict["obj_func"][key] = obj.as_dict()
        if self.eval_func is None:
            OptiProblem_dict["eval_func"] = None
        else:
            OptiProblem_dict["eval_func"] = [
                dumps(self._eval_func[0]).decode("ISO-8859-2"),
                self._eval_func[1],
            ]
        OptiProblem_dict["constraint"] = dict()
        for key, obj in self.constraint.items():
            OptiProblem_dict["constraint"][key] = obj.as_dict()
        # The class name is added to the dict fordeserialisation purpose
        OptiProblem_dict["__class__"] = "OptiProblem"
        return OptiProblem_dict

    def _set_None(self):
        """Set all the properties to None (except pyleecan object)"""

        if self.output is not None:
            self.output._set_None()
        for key, obj in self.design_var.items():
            obj._set_None()
        for key, obj in self.obj_func.items():
            obj._set_None()
        self.eval_func = None
        for key, obj in self.constraint.items():
            obj._set_None()

    def _get_output(self):
        """getter of output"""
        return self._output

    def _set_output(self, value):
        """setter of output"""
        check_var("output", value, "Output")
        self._output = value

        if self._output is not None:
            self._output.parent = self

    # Default output to define the default simulation.
    # Type : Output
    output = property(
        fget=_get_output,
        fset=_set_output,
        doc=u"""Default output to define the default simulation. """,
    )

    def _get_design_var(self):
        """getter of design_var"""
        for key, obj in self._design_var.items():
            if obj is not None:
                obj.parent = self
        return self._design_var

    def _set_design_var(self, value):
        """setter of design_var"""
        check_var("design_var", value, "{OptiDesignVar}")
        self._design_var = value

    # Dict of design variables
    # Type : {OptiDesignVar}
    design_var = property(fget=_get_design_var,
                          fset=_set_design_var,
                          doc=u"""Dict of design variables""")

    def _get_obj_func(self):
        """getter of obj_func"""
        for key, obj in self._obj_func.items():
            if obj is not None:
                obj.parent = self
        return self._obj_func

    def _set_obj_func(self, value):
        """setter of obj_func"""
        check_var("obj_func", value, "{OptiObjFunc}")
        self._obj_func = value

    # Dict of objective functions
    # Type : {OptiObjFunc}
    obj_func = property(fget=_get_obj_func,
                        fset=_set_obj_func,
                        doc=u"""Dict of objective functions""")

    def _get_eval_func(self):
        """getter of eval_func"""
        return self._eval_func[0]

    def _set_eval_func(self, value):
        """setter of eval_func"""
        try:
            check_var("eval_func", value, "list")
        except CheckTypeError:
            check_var("eval_func", value, "function")
        if isinstance(value, list):  # Load function from saved dict
            self._eval_func = [loads(value[0].encode("ISO-8859-2")), value[1]]
        elif value is None:
            self._eval_func = [None, None]
        elif callable(value):
            self._eval_func = [value, getsource(value)]
        else:
            raise TypeError(
                "Expected function or list from a saved file, got: " +
                str(type(value)))

    # Function to evaluate before computing obj function and constraints
    # Type : function
    eval_func = property(
        fget=_get_eval_func,
        fset=_set_eval_func,
        doc=
        u"""Function to evaluate before computing obj function and constraints""",
    )

    def _get_constraint(self):
        """getter of constraint"""
        for key, obj in self._constraint.items():
            if obj is not None:
                obj.parent = self
        return self._constraint

    def _set_constraint(self, value):
        """setter of constraint"""
        check_var("constraint", value, "{OptiConstraint}")
        self._constraint = value

    # Dict containing the constraints
    # Type : {OptiConstraint}
    constraint = property(
        fget=_get_constraint,
        fset=_set_constraint,
        doc=u"""Dict containing the constraints """,
    )
Ejemplo n.º 2
0
class OutputMulti(FrozenClass):

    # cf Methods.Output.OutputMulti.add_output
    if isinstance(add_output, ImportError):
        add_output = property(fget=lambda x: raise_(
            ImportError("Can't use OutputMulti method add_output: " + str(
                add_output))))
    else:
        add_output = add_output
    # save method is available in all object
    save = save

    def __init__(
        self,
        output_ref=-1,
        outputs=list(),
        is_valid=[],
        design_var=[],
        design_var_names=[],
        init_dict=None,
    ):
        """Constructor of the class. Can be use in two ways :
        - __init__ (arg1 = 1, arg3 = 5) every parameters have name and default values
            for Matrix, None will initialise the property with an empty Matrix
            for pyleecan type, None will call the default constructor
        - __init__ (init_dict = d) d must be a dictionnary wiht every properties as keys

        ndarray or list can be given for Vector and Matrix
        object or dict can be given for pyleecan Object"""

        if output_ref == -1:
            output_ref = Output()
        if init_dict is not None:  # Initialisation by dict
            check_init_dict(
                init_dict,
                [
                    "output_ref", "outputs", "is_valid", "design_var",
                    "design_var_names"
                ],
            )
            # Overwrite default value with init_dict content
            if "output_ref" in list(init_dict.keys()):
                output_ref = init_dict["output_ref"]
            if "outputs" in list(init_dict.keys()):
                outputs = init_dict["outputs"]
            if "is_valid" in list(init_dict.keys()):
                is_valid = init_dict["is_valid"]
            if "design_var" in list(init_dict.keys()):
                design_var = init_dict["design_var"]
            if "design_var_names" in list(init_dict.keys()):
                design_var_names = init_dict["design_var_names"]
        # Initialisation by argument
        self.parent = None
        # output_ref can be None, a Output object or a dict
        if isinstance(output_ref, dict):
            self.output_ref = Output(init_dict=output_ref)
        else:
            self.output_ref = output_ref
        # outputs can be None or a list of Output object
        self.outputs = list()
        if type(outputs) is list:
            for obj in outputs:
                if obj is None:  # Default value
                    self.outputs.append(Output())
                elif isinstance(obj, dict):
                    self.outputs.append(Output(init_dict=obj))
                else:
                    self.outputs.append(obj)
        elif outputs is None:
            self.outputs = list()
        else:
            self.outputs = outputs
        self.is_valid = is_valid
        self.design_var = design_var
        self.design_var_names = design_var_names

        # The class is frozen, for now it's impossible to add new properties
        self._freeze()

    def __str__(self):
        """Convert this objet in a readeable string (for print)"""

        OutputMulti_str = ""
        if self.parent is None:
            OutputMulti_str += "parent = None " + linesep
        else:
            OutputMulti_str += ("parent = " + str(type(self.parent)) +
                                " object" + linesep)
        if self.output_ref is not None:
            tmp = (self.output_ref.__str__().replace(linesep, linesep +
                                                     "\t").rstrip("\t"))
            OutputMulti_str += "output_ref = " + tmp
        else:
            OutputMulti_str += "output_ref = None" + linesep + linesep
        if len(self.outputs) == 0:
            OutputMulti_str += "outputs = []" + linesep
        for ii in range(len(self.outputs)):
            tmp = self.outputs[ii].__str__().replace(linesep,
                                                     linesep + "\t") + linesep
            OutputMulti_str += "outputs[" + str(
                ii) + "] =" + tmp + linesep + linesep
        OutputMulti_str += (
            "is_valid = " + linesep +
            str(self.is_valid).replace(linesep, linesep + "\t") + linesep)
        OutputMulti_str += (
            "design_var = " + linesep +
            str(self.design_var).replace(linesep, linesep + "\t") + linesep)
        OutputMulti_str += ("design_var_names = " + linesep + str(
            self.design_var_names).replace(linesep, linesep + "\t") + linesep)
        return OutputMulti_str

    def __eq__(self, other):
        """Compare two objects (skip parent)"""

        if type(other) != type(self):
            return False
        if other.output_ref != self.output_ref:
            return False
        if other.outputs != self.outputs:
            return False
        if other.is_valid != self.is_valid:
            return False
        if other.design_var != self.design_var:
            return False
        if other.design_var_names != self.design_var_names:
            return False
        return True

    def as_dict(self):
        """Convert this objet in a json seriable dict (can be use in __init__)
        """

        OutputMulti_dict = dict()
        if self.output_ref is None:
            OutputMulti_dict["output_ref"] = None
        else:
            OutputMulti_dict["output_ref"] = self.output_ref.as_dict()
        OutputMulti_dict["outputs"] = list()
        for obj in self.outputs:
            OutputMulti_dict["outputs"].append(obj.as_dict())
        OutputMulti_dict["is_valid"] = self.is_valid
        OutputMulti_dict["design_var"] = self.design_var
        OutputMulti_dict["design_var_names"] = self.design_var_names
        # The class name is added to the dict fordeserialisation purpose
        OutputMulti_dict["__class__"] = "OutputMulti"
        return OutputMulti_dict

    def _set_None(self):
        """Set all the properties to None (except pyleecan object)"""

        if self.output_ref is not None:
            self.output_ref._set_None()
        for obj in self.outputs:
            obj._set_None()
        self.is_valid = None
        self.design_var = None
        self.design_var_names = None

    def _get_output_ref(self):
        """getter of output_ref"""
        return self._output_ref

    def _set_output_ref(self, value):
        """setter of output_ref"""
        check_var("output_ref", value, "Output")
        self._output_ref = value

        if self._output_ref is not None:
            self._output_ref.parent = self

    # Reference output of the multi simulation
    # Type : Output
    output_ref = property(
        fget=_get_output_ref,
        fset=_set_output_ref,
        doc=u"""Reference output of the multi simulation""",
    )

    def _get_outputs(self):
        """getter of outputs"""
        for obj in self._outputs:
            if obj is not None:
                obj.parent = self
        return self._outputs

    def _set_outputs(self, value):
        """setter of outputs"""
        check_var("outputs", value, "[Output]")
        self._outputs = value

        for obj in self._outputs:
            if obj is not None:
                obj.parent = self

    # list of output from the multi-simulation
    # Type : [Output]
    outputs = property(
        fget=_get_outputs,
        fset=_set_outputs,
        doc=u"""list of output from the multi-simulation""",
    )

    def _get_is_valid(self):
        """getter of is_valid"""
        return self._is_valid

    def _set_is_valid(self, value):
        """setter of is_valid"""
        check_var("is_valid", value, "list")
        self._is_valid = value

    # list to indicate if the corresponding output is valid
    # Type : list
    is_valid = property(
        fget=_get_is_valid,
        fset=_set_is_valid,
        doc=u"""list to indicate if the corresponding output is valid""",
    )

    def _get_design_var(self):
        """getter of design_var"""
        return self._design_var

    def _set_design_var(self, value):
        """setter of design_var"""
        check_var("design_var", value, "list")
        self._design_var = value

    # list of design variables corresponding to the output
    # Type : list
    design_var = property(
        fget=_get_design_var,
        fset=_set_design_var,
        doc=u"""list of design variables corresponding to the output""",
    )

    def _get_design_var_names(self):
        """getter of design_var_names"""
        return self._design_var_names

    def _set_design_var_names(self, value):
        """setter of design_var_names"""
        check_var("design_var_names", value, "list")
        self._design_var_names = value

    # list of str containing the design variables names sorted alphabetically
    # Type : list
    design_var_names = property(
        fget=_get_design_var_names,
        fset=_set_design_var_names,
        doc=
        u"""list of str containing the design variables names sorted alphabetically""",
    )