From bd0c0d4ab8689b9af7f6f44f1239db8ad7f8d8c5 Mon Sep 17 00:00:00 2001 From: Jean-Philippe ARGAUD Date: Mon, 15 Oct 2012 00:06:34 +0200 Subject: [PATCH] Simplifying operators definition by function script --- bin/AdaoCatalogGenerator.py | 9 +- src/daEficas/generator_adao.py | 16 ++ .../daYacsSchemaCreator/help_methods.py | 10 + .../daYacsSchemaCreator/infos_daComposant.py | 6 +- src/daSalome/daYacsSchemaCreator/methods.py | 176 ++++++++++++++++++ 5 files changed, 212 insertions(+), 5 deletions(-) diff --git a/bin/AdaoCatalogGenerator.py b/bin/AdaoCatalogGenerator.py index 8ae595c..a3615b4 100644 --- a/bin/AdaoCatalogGenerator.py +++ b/bin/AdaoCatalogGenerator.py @@ -57,6 +57,11 @@ def F_${data_name}(statut) : return FACT(statut = statut, SCRIPTWITHFUNCTIONS_FILE = SIMP(statut = "o", typ = "FichierNoAbs", validators=(OnlyStr()), fr="En attente d'un nom de fichier script, avec ou sans le chemin complet pour le trouver, contenant en variables internes trois fonctions de calcul nommées DirectOperator, TangentOperator et AdjointOperator", ang="Waiting for a script file name, with or without the full path to find it, containing as internal variables three computation functions named DirectOperator, TangentOperator and AdjointOperator"), ), + SCRIPTWITHONEFUNCTION_DATA = BLOC ( condition = " FROM in ( 'ScriptWithOneFunction', ) ", + + SCRIPTWITHONEFUNCTION_FILE = SIMP(statut = "o", typ = "FichierNoAbs", validators=(OnlyStr()), fr="En attente d'un nom de fichier script, avec ou sans le chemin complet pour le trouver, contenant en variable interne une seule fonction de calcul nommée DirectOperator", ang="Waiting for a script file name, with or without the full path to find it, containing as internal variable only one function named DirectOperator"), + DifferentialIncrement = SIMP(statut="o", typ = "R", val_min=0, val_max=1, defaut=0.01, fr="Incrément de la perturbation dX pour calculer la dérivée, construite en multipliant X par l'incrément en évitant les valeurs nulles", ang="Increment of dX perturbation to calculate the derivative, build multiplying X by the increment avoiding null values"), + ), SCRIPTWITHSWITCH_DATA = BLOC ( condition = " FROM in ( 'ScriptWithSwitch', ) ", SCRIPTWITHSWITCH_FILE = SIMP(statut = "o", typ = "FichierNoAbs", validators=(OnlyStr()), fr="En attente d'un nom de fichier script, avec ou sans le chemin complet pour le trouver, contenant un switch pour les calculs direct, tangent et adjoint", ang="Waiting for a script file name, with or without the full path to find it, containing a switch for direct, tangent and adjoint computations"), @@ -135,7 +140,7 @@ ASSIMILATION_STUDY = PROC(nom="ASSIMILATION_STUDY", op=None, repetable = "n", Study_name = SIMP(statut="o", typ = "TXM"), - Study_repertory = SIMP(statut="f", typ = "TXM"), + Study_repertory = SIMP(statut="f", typ = "Repertoire", min=1, max=1), Debug = SIMP(statut="o", typ = "I", into=(0, 1), defaut=0), Algorithm = SIMP(statut="o", typ = "TXM", into=(${algos_names})), Background = F_Background("o"), @@ -157,7 +162,7 @@ CHECKING_STUDY = PROC(nom="CHECKING_STUDY", op=None, repetable = "n", Study_name = SIMP(statut="o", typ = "TXM"), - Study_repertory = SIMP(statut="f", typ = "TXM"), + Study_repertory = SIMP(statut="f", typ = "Repertoire", min=1, max=1), Debug = SIMP(statut="o", typ = "I", into=(0, 1), defaut=0), Algorithm = SIMP(statut="o", typ = "TXM", into=(${check_names})), CheckingPoint = F_CheckingPoint("o"), diff --git a/src/daEficas/generator_adao.py b/src/daEficas/generator_adao.py index 924d4b9..7e7faf6 100644 --- a/src/daEficas/generator_adao.py +++ b/src/daEficas/generator_adao.py @@ -158,6 +158,8 @@ class AdaoGenerator(PythonGenerator): data = self.dictMCVal[search_type + "SCRIPTWITHSWITCH_DATA__SCRIPTWITHSWITCH_FILE"] elif from_type == "ScriptWithFunctions": data = self.dictMCVal[search_type + "SCRIPTWITHFUNCTIONS_DATA__SCRIPTWITHFUNCTIONS_FILE"] + elif from_type == "ScriptWithOneFunction": + data = self.dictMCVal[search_type + "SCRIPTWITHONEFUNCTION_DATA__SCRIPTWITHONEFUNCTION_FILE"] elif from_type == "FunctionDict": data = self.dictMCVal[search_type + "FUNCTIONDICT_DATA__FUNCTIONDICT_FILE"] else: @@ -198,6 +200,20 @@ class AdaoGenerator(PythonGenerator): self.text_da += data_name + "_config['Data'] = " + data_name + "_ScriptWithFunctions\n" self.text_da += "study_config['" + data_name + "'] = " + data_name + "_config\n" + if from_type == "ScriptWithOneFunction": + self.text_da += data_name + "_ScriptWithOneFunction = {}\n" + self.text_da += data_name + "_ScriptWithOneFunction['Function'] = ['Direct', 'Tangent', 'Adjoint']\n" + self.text_da += data_name + "_ScriptWithOneFunction['Script'] = {}\n" + self.text_da += data_name + "_ScriptWithOneFunction['Script']['Direct'] = '" + data + "'\n" + self.text_da += data_name + "_ScriptWithOneFunction['Script']['Tangent'] = '" + data + "'\n" + self.text_da += data_name + "_ScriptWithOneFunction['Script']['Adjoint'] = '" + data + "'\n" + self.text_da += data_name + "_ScriptWithOneFunction['DifferentialIncrement'] = " + str(float(self.dictMCVal[search_type + "SCRIPTWITHONEFUNCTION_DATA__DifferentialIncrement"])) + "\n" + self.text_da += data_name + "_config = {}\n" + self.text_da += data_name + "_config['Type'] = 'Function'\n" + self.text_da += data_name + "_config['From'] = 'ScriptWithOneFunction'\n" + self.text_da += data_name + "_config['Data'] = " + data_name + "_ScriptWithOneFunction\n" + self.text_da += "study_config['" + data_name + "'] = " + data_name + "_config\n" + if from_type == "FunctionDict": self.text_da += data_name + "_FunctionDict = {}\n" self.text_da += data_name + "_FunctionDict['Function'] = ['Direct', 'Tangent', 'Adjoint']\n" diff --git a/src/daSalome/daYacsSchemaCreator/help_methods.py b/src/daSalome/daYacsSchemaCreator/help_methods.py index 639ce6c..0ac7b2b 100644 --- a/src/daSalome/daYacsSchemaCreator/help_methods.py +++ b/src/daSalome/daYacsSchemaCreator/help_methods.py @@ -231,3 +231,13 @@ def check_data(data_name, data_config, repertory_check=False, repertory=""): check_file_name = ScriptWithFunctions["Script"][FunctionName] if not os.path.exists(check_file_name): raise ValueError("\n\n The script file cannot be found for the \"%s\" keyword, please \n check its availability. The given user file is:\n %s\n"%(from_type,check_file_name)) + elif from_type == "ScriptWithOneFunction": + ScriptWithOneFunction = data_config["Data"] + for FunctionName in ScriptWithOneFunction["Function"]: + check_file_name = "" + if repertory_check: + check_file_name = os.path.join(repertory, os.path.basename(ScriptWithOneFunction["Script"][FunctionName])) + else: + check_file_name = ScriptWithOneFunction["Script"][FunctionName] + if not os.path.exists(check_file_name): + raise ValueError("\n\n The script file cannot be found for the \"%s\" keyword, please \n check its availability. The given user file is:\n %s\n"%(from_type,check_file_name)) diff --git a/src/daSalome/daYacsSchemaCreator/infos_daComposant.py b/src/daSalome/daYacsSchemaCreator/infos_daComposant.py index 600a285..29eba0c 100644 --- a/src/daSalome/daYacsSchemaCreator/infos_daComposant.py +++ b/src/daSalome/daYacsSchemaCreator/infos_daComposant.py @@ -50,7 +50,7 @@ FromNumpyList = {} FromNumpyList["Vector"] = ["String", "Script"] FromNumpyList["VectorSerie"] = ["String", "Script"] FromNumpyList["Matrix"] = ["String", "Script"] -FromNumpyList["Function"] = ["ScriptWithFunctions", "ScriptWithSwitch", "FunctionDict"] +FromNumpyList["Function"] = ["ScriptWithFunctions", "ScriptWithOneFunction", "ScriptWithSwitch", "FunctionDict"] FromNumpyList["Dict"] = ["Script"] # -- Infos from daAlgorithms -- @@ -134,14 +134,14 @@ AlgoType["QuantileRegression"] = "Optim" # catalogue Eficas # Basic data types -BasicDataInputs = ["String", "Script", "ScriptWithFunctions", "ScriptWithSwitch", "FunctionDict"] +BasicDataInputs = ["String", "Script", "ScriptWithFunctions", "ScriptWithOneFunction", "ScriptWithSwitch", "FunctionDict"] # Data input dict DataTypeDict = {} DataTypeDict["Vector"] = ["String", "Script"] DataTypeDict["VectorSerie"] = ["String", "Script"] DataTypeDict["Matrix"] = ["String", "Script"] -DataTypeDict["Function"] = ["ScriptWithFunctions", "ScriptWithSwitch", "FunctionDict"] +DataTypeDict["Function"] = ["ScriptWithFunctions", "ScriptWithOneFunction", "ScriptWithSwitch", "FunctionDict"] DataTypeDict["Dict"] = ["Script"] DataTypeDefaultDict = {} diff --git a/src/daSalome/daYacsSchemaCreator/methods.py b/src/daSalome/daYacsSchemaCreator/methods.py index 7cf84ea..d59383f 100644 --- a/src/daSalome/daYacsSchemaCreator/methods.py +++ b/src/daSalome/daYacsSchemaCreator/methods.py @@ -374,6 +374,26 @@ def create_yacs_proc(study_config): else: CAS_node.getInputPort(port_name).edInitPy(ScriptWithFunctions["Script"][FunctionName]) + if data_config["Type"] == "Function" and data_config["From"] == "ScriptWithOneFunction" and key == "ObservationOperator": + ScriptWithOneFunction = data_config["Data"] + for FunctionName in ScriptWithOneFunction["Function"]: + port_name = "ObservationOperator" + FunctionName + CAS_node.edAddInputPort(port_name, t_string) + if repertory: + CAS_node.getInputPort(port_name).edInitPy(os.path.join(base_repertory, os.path.basename(ScriptWithOneFunction["Script"][FunctionName]))) + else: + CAS_node.getInputPort(port_name).edInitPy(ScriptWithOneFunction["Script"][FunctionName]) + + if data_config["Type"] == "Function" and data_config["From"] == "ScriptWithOneFunction" and key == "EvolutionModel": + ScriptWithOneFunction = data_config["Data"] + for FunctionName in ScriptWithOneFunction["Function"]: + port_name = "EvolutionModel" + FunctionName + CAS_node.edAddInputPort(port_name, t_string) + if repertory: + CAS_node.getInputPort(port_name).edInitPy(os.path.join(base_repertory, os.path.basename(ScriptWithOneFunction["Script"][FunctionName]))) + else: + CAS_node.getInputPort(port_name).edInitPy(ScriptWithOneFunction["Script"][FunctionName]) + # Step 3: create compute bloc compute_bloc = runtime.createBloc("compute_bloc") ADAO_Case.edAddChild(compute_bloc) @@ -441,6 +461,7 @@ def create_yacs_proc(study_config): opt_script_nodeOO.setScript(node_script) opt_script_nodeOO.edAddInputPort("computation", t_param_input) opt_script_nodeOO.edAddOutputPort("result", t_param_output) + elif data_config["Type"] == "Function" and data_config["From"] == "ScriptWithFunctions": # Get script ScriptWithFunctions = data_config["Data"] @@ -520,6 +541,84 @@ def create_yacs_proc(study_config): opt_script_nodeOO.setScript(node_script) opt_script_nodeOO.edAddInputPort("computation", t_param_input) opt_script_nodeOO.edAddOutputPort("result", t_param_output) + + elif data_config["Type"] == "Function" and data_config["From"] == "ScriptWithOneFunction": + # Get script + ScriptWithOneFunction = data_config["Data"] + script_filename = "" + for FunctionName in ScriptWithOneFunction["Function"]: + # We currently support only one file + script_filename = ScriptWithOneFunction["Script"][FunctionName] + break + + # We create a new pyscript node + opt_script_nodeOO = runtime.createScriptNode("", "FunctionNodeOO") + if repertory: + script_filename = os.path.join(base_repertory, os.path.basename(script_filename)) + try: + script_str= open(script_filename, 'r') + except: + raise ValueError("Exception in opening function script file: " + script_filename) + node_script = "#-*-coding:iso-8859-1-*-\n" + node_script += "import sys, os, numpy, logging\n" + node_script += "filepath = \"" + os.path.dirname(script_filename) + "\"\n" + node_script += "if sys.path.count(filepath)==0 or (sys.path.count(filepath)>0 and sys.path.index(filepath)>0):\n" + node_script += " sys.path.insert(0,filepath)\n" + node_script += """# ==============================================\n""" + node_script += script_str.read() + node_script += """# ==============================================\n""" + node_script += """__method = None\n""" + node_script += """for param in computation["specificParameters"]:\n""" + node_script += """ if param["name"] == "method": __method = param["value"]\n""" + node_script += """if __method not in ["Direct", "Tangent", "Adjoint"]:\n""" + node_script += """ raise ValueError("ComputationFunctionNode: no valid computation method is given, it has to be Direct, Tangent or Adjoint (\'%s\' given)."%__method)\n""" + node_script += """logging.debug("ComputationFunctionNode: Found method is \'%s\'"%__method)\n""" + node_script += """#\n""" + node_script += """try:\n""" + node_script += """ DirectOperator\n""" + node_script += """except NameError:\n""" + node_script += """ raise ValueError("ComputationFunctionNode: DirectOperator not found in the imported user script file")\n""" + node_script += """import ApproximatedDerivatives\n""" + node_script += """FDA = ApproximatedDerivatives.FDApproximation(\n""" + node_script += """ Function = DirectOperator,\n""" + node_script += """ increment = %s,\n"""%str(ScriptWithOneFunction['DifferentialIncrement']) + node_script += """ )\n""" + node_script += """#\n""" + node_script += """__data = []\n""" + node_script += """if __method == "Direct":\n""" + node_script += """ logging.debug("ComputationFunctionNode: Direct computation")\n""" + node_script += """ __Xcurrent = computation["inputValues"][0][0][0]\n""" + node_script += """ __data = FDA.DirectOperator(numpy.matrix( __Xcurrent ).T)\n""" + node_script += """#\n""" + node_script += """if __method == "Tangent":\n""" + node_script += """ logging.debug("ComputationFunctionNode: Tangent computation")\n""" + node_script += """ __Xcurrent = computation["inputValues"][0][0][0]\n""" + node_script += """ __dXcurrent = computation["inputValues"][0][0][1]\n""" + node_script += """ __data = FDA.TangentOperator((numpy.matrix( __Xcurrent ).T, numpy.matrix( __dXcurrent ).T))\n""" + node_script += """#\n""" + node_script += """if __method == "Adjoint":\n""" + node_script += """ logging.debug("ComputationFunctionNode: Adjoint computation")\n""" + node_script += """ __Xcurrent = computation["inputValues"][0][0][0]\n""" + node_script += """ __Ycurrent = computation["inputValues"][0][0][1]\n""" + node_script += """ __data = FDA.AdjointOperator((numpy.matrix( __Xcurrent ).T, numpy.matrix( __Ycurrent ).T))\n""" + node_script += """#\n""" + node_script += """logging.debug("ComputationFunctionNode: Formatting the output")\n""" + node_script += """it = numpy.ravel(__data)\n""" + node_script += """outputValues = [[[[]]]]\n""" + node_script += """for val in it:\n""" + node_script += """ outputValues[0][0][0].append(val)\n""" + node_script += """#\n""" + node_script += """result = {}\n""" + node_script += """result["outputValues"] = outputValues\n""" + node_script += """result["specificOutputInfos"] = []\n""" + node_script += """result["returnCode"] = 0\n""" + node_script += """result["errorMessage"] = ""\n""" + node_script += """# ==============================================\n""" + # + opt_script_nodeOO.setScript(node_script) + opt_script_nodeOO.edAddInputPort("computation", t_param_input) + opt_script_nodeOO.edAddOutputPort("result", t_param_output) + else: factory_opt_script_node = catalogAd.getNodeFromNodeMap("FakeOptimizerLoopNode") opt_script_nodeOO = factory_opt_script_node.cloneNode("FakeFunctionNode") @@ -554,6 +653,7 @@ def create_yacs_proc(study_config): opt_script_nodeEM.setScript(node_script) opt_script_nodeEM.edAddInputPort("computation", t_param_input) opt_script_nodeEM.edAddOutputPort("result", t_param_output) + elif data_config["Type"] == "Function" and data_config["From"] == "ScriptWithSwitch": # Get script ScriptWithSwitch = data_config["Data"] @@ -658,6 +758,82 @@ def create_yacs_proc(study_config): opt_script_nodeEM.setScript(node_script) opt_script_nodeEM.edAddInputPort("computation", t_param_input) opt_script_nodeEM.edAddOutputPort("result", t_param_output) + + elif data_config["Type"] == "Function" and data_config["From"] == "ScriptWithOneFunction": + # Get script + ScriptWithOneFunction = data_config["Data"] + script_filename = "" + for FunctionName in ScriptWithOneFunction["Function"]: + # We currently support only one file + script_filename = ScriptWithOneFunction["Script"][FunctionName] + break + # We create a new pyscript node + opt_script_nodeEM = runtime.createScriptNode("", "FunctionNodeEM") + if repertory: + script_filename = os.path.join(base_repertory, os.path.basename(script_filename)) + try: + script_str= open(script_filename, 'r') + except: + raise ValueError("Exception in opening function script file: " + script_filename) + node_script = "#-*-coding:iso-8859-1-*-\n" + node_script += "import sys, os, numpy, logging\n" + node_script += "filepath = \"" + os.path.dirname(script_filename) + "\"\n" + node_script += "if sys.path.count(filepath)==0 or (sys.path.count(filepath)>0 and sys.path.index(filepath)>0):\n" + node_script += " sys.path.insert(0,filepath)\n" + node_script += script_str.read() + node_script += """# ==============================================\n""" + node_script += """__method = None\n""" + node_script += """for param in computation["specificParameters"]:\n""" + node_script += """ if param["name"] == "method": __method = param["value"]\n""" + node_script += """if __method not in ["Direct", "Tangent", "Adjoint"]:\n""" + node_script += """ raise ValueError("ComputationFunctionNode: no valid computation method is given, it has to be Direct, Tangent or Adjoint (\'%s\' given)."%__method)\n""" + node_script += """logging.debug("ComputationFunctionNode: Found method is \'%s\'"%__method)\n""" + node_script += """#\n""" + node_script += """try:\n""" + node_script += """ DirectOperator\n""" + node_script += """except NameError:\n""" + node_script += """ raise ValueError("ComputationFunctionNode: DirectOperator not found in the imported user script file")\n""" + node_script += """import ApproximatedDerivatives\n""" + node_script += """FDA = ApproximatedDerivatives.FDApproximation(\n""" + node_script += """ Function = DirectOperator,\n""" + node_script += """ increment = %s,\n"""%str(ScriptWithOneFunction['DifferentialIncrement']) + node_script += """ )\n""" + node_script += """#\n""" + node_script += """__data = []\n""" + node_script += """if __method == "Direct":\n""" + node_script += """ logging.debug("ComputationFunctionNode: Direct computation")\n""" + node_script += """ __Xcurrent = computation["inputValues"][0][0][0]\n""" + node_script += """ __data = FDA.DirectOperator(numpy.matrix( __Xcurrent ).T)\n""" + node_script += """#\n""" + node_script += """if __method == "Tangent":\n""" + node_script += """ logging.debug("ComputationFunctionNode: Tangent computation")\n""" + node_script += """ __Xcurrent = computation["inputValues"][0][0][0]\n""" + node_script += """ __dXcurrent = computation["inputValues"][0][0][1]\n""" + node_script += """ __data = FDA.TangentOperator((numpy.matrix( __Xcurrent ).T, numpy.matrix( __dXcurrent ).T))\n""" + node_script += """#\n""" + node_script += """if __method == "Adjoint":\n""" + node_script += """ logging.debug("ComputationFunctionNode: Adjoint computation")\n""" + node_script += """ __Xcurrent = computation["inputValues"][0][0][0]\n""" + node_script += """ __Ycurrent = computation["inputValues"][0][0][1]\n""" + node_script += """ __data = FDA.AdjointOperator((numpy.matrix( __Xcurrent ).T, numpy.matrix( __Ycurrent ).T))\n""" + node_script += """#\n""" + node_script += """logging.debug("ComputationFunctionNode: Formatting the output")\n""" + node_script += """it = numpy.ravel(__data)\n""" + node_script += """outputValues = [[[[]]]]\n""" + node_script += """for val in it:\n""" + node_script += """ outputValues[0][0][0].append(val)\n""" + node_script += """#\n""" + node_script += """result = {}\n""" + node_script += """result["outputValues"] = outputValues\n""" + node_script += """result["specificOutputInfos"] = []\n""" + node_script += """result["returnCode"] = 0\n""" + node_script += """result["errorMessage"] = ""\n""" + node_script += """# ==============================================\n""" + # + opt_script_nodeEM.setScript(node_script) + opt_script_nodeEM.edAddInputPort("computation", t_param_input) + opt_script_nodeEM.edAddOutputPort("result", t_param_output) + else: factory_opt_script_node = catalogAd.getNodeFromNodeMap("FakeOptimizerLoopNode") opt_script_nodeEM = factory_opt_script_node.cloneNode("FakeFunctionNode") -- 2.39.2