-# Copyright (C) 2009-2010 EDF R&D
+# Copyright (C) 2009-2011 EDF R&D
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
# $Id$
#
+import os
import logging
import threading
import inspect
import traceback
+import platform
+import thread
import salome
import GENERICSOLVER_ORB__POA
import SALOME_DriverPy
import SALOME
-from pal.logger import Logger
-from pal import termcolor
+from salome.kernel.logger import Logger
+from salome.kernel import termcolor
logger = Logger("DEVIATION", color = termcolor.RED_FG)
logger.setLevel(logging.INFO)
+from salome.kernel.parametric.compo_utils import \
+ create_input_dict, create_normal_parametric_output, create_error_parametric_output
+
VARIABLE_ID = 1030
###
# Get the values of the variables and make them a list
for name in ("E", "F", "L", "I"):
var = getSubSObjectByName( studyId, case, name )
- if var == None:
- logger.error("GENERICSOLVER.GetDataFromCase : ERROR! no variable '%s'" % name)
- break
+ if var is None:
+ raise Exception('No variable "%s" was found in case "%s" (entry %s). '
+ 'It is probably not a case for the code DEVIATION.' %
+ (name, case.GetName(), caseEntry))
theCase[ name ] = getValueOfVariable( builder, var )
return theCase
"""
def __init__ ( self, orb, poa, contID, containerName, instanceName,
interfaceName ):
- logger.info("DEVIATION.__init__: " + containerName + ' ; ' + instanceName)
+ logger.info("__init__: " + containerName + ' ; ' + instanceName)
SALOME_ComponentPy.SALOME_ComponentPy_i.__init__(self, orb, poa,
contID, containerName, instanceName, interfaceName, 0)
SALOME_DriverPy.SALOME_DriverPy_i.__init__(self, interfaceName)
# On stocke dans l'attribut _naming_service, une reference sur
# le Naming Service CORBA
self._naming_service = SALOME_ComponentPy.SALOME_NamingServicePy_i( self._orb )
- self.inputVarList = None
- self.outputVarList = None
- self.evalPoint = None
+ self.deterministicValues = {}
######################################################################
# This is the Wrapper part of the GENERICSOLVER module, ie
exc = SALOME.ExceptionStruct(SALOME.INTERNAL_ERROR, message,
inspect.stack()[1][1], inspect.stack()[1][2])
raise SALOME.SALOME_Exception(exc)
+
+ def _getIdMessage(self):
+ return "%s in container %s running on %s, process %d, thread %d" % \
+ (self._instanceName, self._containerName,
+ platform.node(), os.getpid(), thread.get_ident())
- def Init(self, inputVarList, outputVarList, studyId, caseEntry):
+ def Init(self, studyId, detCaseEntry):
"""
This method is an example for the initialization of a computation component for
use with OpenTURNS in SALOME 5.1.5 and later (for YACS integration)
"""
try:
- logger.info("DEVIATION.Init: " + self._containerName +
- ' ; ' + self._instanceName)
+ logger.info("Init: " + self._getIdMessage())
DEVIATION.lock.acquire()
salome.salome_init()
DEVIATION.lock.release()
- self.inputVarList = inputVarList
- self.outputVarList = outputVarList
- self.evalPoint = GetDataFromCase(studyId, caseEntry)
- logger.debug("inputVarList: %s" % self.inputVarList)
- logger.debug("outputVarList: %s" % self.outputVarList)
- logger.debug("evalPoint: %s" % self.evalPoint)
+ self.deterministicValues = GetDataFromCase(studyId, detCaseEntry)
+ logger.debug("deterministic values: %s" % self.deterministicValues)
except:
self._raiseSalomeError()
- def Exec(self, inPoint):
+ def Exec(self, paramInput):
"""
This method is an example for the execution of a computation component for
use with OpenTURNS in SALOME 5.1.5 and later (for YACS integration)
"""
try:
- logger.info("DEVIATION.Exec: " + self._containerName +
- ' ; ' + self._instanceName)
- if self.inputVarList is None:
- raise Exception("Init not run")
- if len(inPoint) != len(self.inputVarList):
- raise Exception("Size mismatch between inputVarList and point to evaluate")
-
- logger.debug("DEVIATION.Exec (1): inPoint = %s" % inPoint)
- for i in range(len(self.inputVarList)):
- self.evalPoint[self.inputVarList[i]] = inPoint[i]
- logger.debug("evalPoint = %s" % self.evalPoint)
-
- resDict = {}
- resDict["dev"] = self.BeamModel(**self.evalPoint)
-
- outPoint = []
- for outputVar in self.outputVarList:
- outPoint.append(resDict[outputVar])
- logger.debug("DEVIATION.Exec (2): outPoint = %s" % outPoint)
- return outPoint
+ logger.info("Exec: " + self._getIdMessage())
+ logger.debug("inputVarList: %s" % paramInput.inputVarList)
+ logger.debug("outputVarList: %s" % paramInput.outputVarList)
+ logger.debug("inputValues: %s" % paramInput.inputValues)
+
+ # Get id
+ id = ""
+ for parameter in paramInput.specificParameters:
+ if parameter.name == "id":
+ id = parameter.value
+ logger.debug("ID: %s" % id)
+
+ inputDict = create_input_dict(self.deterministicValues, paramInput)
+ logger.debug("inputDict = %s" % inputDict)
+
+ # Test for an invalid parameter and return an error in this case
+ if inputDict["L"] <= 0:
+ return create_error_parametric_output("Invalid value: L must be positive")
+
+ outputDict = {}
+ outputDict["dev"] = self.BeamModel(**inputDict)
+
+ paramOutput = create_normal_parametric_output(outputDict, paramInput)
+ logger.debug("outputValues: %s" % paramOutput.outputValues)
+ return paramOutput
except:
self._raiseSalomeError()
It cleans everything set so far.
"""
try:
- logger.info("DEVIATION.Finalize: " + self._containerName + ' ; ' + self._instanceName)
+ logger.info("Finalize: " + self._getIdMessage())
except:
self._raiseSalomeError()
-
+
+ def GetFilesToTransfer(self, studyId, detCaseEntry):
+ """
+ This method can be used to specify files to transfer to the
+ computation resource. It is not useful for DEVIATION since it only
+ uses values from Salome study.
+ """
+ try:
+ logger.info("GetFilesToTransfer: " + self._getIdMessage())
+ inputFiles = []
+ outputFiles = []
+ return (inputFiles, outputFiles)
+ except:
+ self._raiseSalomeError()
+
######################################################################
# This is the computation part of the GENERICSOLVER module, ie
# the following method realizes what the solver is intended to do.
deviation = ( Force * Length^3 ) / ( 3 * YoungModulus * InertiaSection )
"""
d = (F * L * L * L) / (3. * E * I)
- logger.debug("DEVIATION.BeamModel (E=%g, F=%g, L=%g, I=%g) = %g" % (E, F, L, I, d))
+ logger.debug("BeamModel (E=%g, F=%g, L=%g, I=%g) = %g" % (E, F, L, I, d))
return d