def _start_server(self):

self._server = subprocess.Popen(self._omc_command, shell=True, stdout=self._omc_log_file,

stderr=self._omc_log_file)

return self._server

def _set_omc_corba_command(self, omc_path='omc'):

self._omc_command = "{0} +d=interactiveCorba +c={1}".format(omc_path, self._random_string)

return self._omc_command

def _start_omc(self):

self._server = None

self._omc_command = None

try:

self.omhome = os.environ.get('OPENMODELICAHOME')

if self.omhome is None:

self.omhome = os.path.split(os.path.split(os.path.realpath(spawn.find_executable("omc")))[0])[0]

elif os.path.exists('/opt/local/bin/omc'):

self.omhome = '/opt/local'

# add OPENMODELICAHOME\lib\python to PYTHONPATH so python can load omniORB imports

sys.path.append(os.path.join(self.omhome, 'lib', 'python'))

self._set_omc_corba_command(os.path.join(self.omhome, 'bin', 'omc'))

self._start_server()

except:

logger.error("The OpenModelica compiler is missing in the System path (%s), please install it" % os.path.join(self.omhome, 'bin', 'omc'))

raise

def _connect_to_omc(self):

self._omc = None

# import the skeletons for the global module

from omniORB import CORBA

from OMPythonIDL import _OMCIDL

# Locating and using the IOR

if sys.platform == 'win32':

self._ior_file = "openmodelica.objid." + self._random_string

else:

self._ior_file = "openmodelica." + self._currentUser + ".objid." + self._random_string

self._ior_file = os.path.join(self._temp_dir, self._ior_file).replace("\\","/")

self._omc_corba_uri = "file:///" + self._ior_file

# See if the omc server is running

if os.path.isfile(self._ior_file):

logger.info("OMC Server is up and running at {0}".format(self._omc_corba_uri))

else:

attempts = 0

while True:

if not os.path.isfile(self._ior_file):

time.sleep(0.25)

attempts += 1

if attempts == 10:

name = self._omc_log_file.name

self._omc_log_file.close()

logger.error("OMC Server is down. Please start it! Log-file says:\n%s" % open(name).read())

raise Exception

else:

continue

else:

logger.info("OMC Server is up and running at {0}".format(self._omc_corba_uri))

break

#initialize the ORB with maximum size for the ORB set

sys.argv.append("-ORBgiopMaxMsgSize")

sys.argv.append("2147483647")

self._orb = CORBA.ORB_init(sys.argv, CORBA.ORB_ID)

# Read the IOR file

with open(self._ior_file, 'r') as f_p:

self._ior = f_p.readline()

# Find the root POA

self._poa = self._orb.resolve_initial_references("RootPOA")

# Convert the IOR into an object reference

self._obj_reference = self._orb.string_to_object(self._ior)

# Narrow the reference to the OmcCommunication object

self._omc = self._obj_reference._narrow(_OMCIDL.OmcCommunication)

# Check if we are using the right object

if self._omc is None:

logger.error("Object reference is not valid")

raise Exception

def __init__(self, readonly=False):

self.readonly = readonly

self.omc_cache = {}

# FIXME: this code is not well written... need to be refactored

self._temp_dir = tempfile.gettempdir()

# generate a random string for this session

self._random_string = uuid.uuid4().hex

if sys.platform == 'win32':

self._omc_log_file = open(os.path.join(self._temp_dir, "openmodelica.objid." + self._random_string+".log"), 'w')

else:

self._currentUser = getpass.getuser()

if not self._currentUser:

self._currentUser = "nobody"

# this file must be closed in the destructor

self._omc_log_file = open(os.path.join(self._temp_dir, "openmodelica." + self._currentUser + ".objid." + self._random_string+".log"), 'w')

# start up omc executable, which is waiting for the CORBA connection

self._start_omc()

# connect to the running omc instance using CORBA

self._connect_to_omc()

def __del__(self):

if self._omc is not None:

self._omc.sendExpression("quit()")

self._omc_log_file.close()

# kill self._server process if it is still running/exists

if self._server.returncode is None:

self._server.kill()

# FIXME: we should have one function which interacts with OMC. Either execute OR sendExpression.

# Execute uses OMParser.check_for_values and sendExpression uses OMTypedParser.parseString.

# We should have one parser. Then we can get rid of one of these functions.

def execute(self, command):

if self._omc is not None:

result = self._omc.sendExpression(command)

if command == "quit()":

self._omc = None

return result

else:

answer = OMParser.check_for_values(result)

return answer

else:

return "No connection with OMC. Create an instance of OMCSession."

# FIXME: we should have one function which interacts with OMC. Either execute OR sendExpression.

# Execute uses OMParser.check_for_values and sendExpression uses OMTypedParser.parseString.

# We should have one parser. Then we can get rid of one of these functions.

def sendExpression(self, command, parsed=True):

"""

if self._omc is not None:

result = self._omc.sendExpression(str(command))

if command == "quit()":

self._omc = None

return result

else:

if (parsed==True):

answer = OMTypedParser.parseString(result)

return answer

else:

return result

else:

return "No connection with OMC. Create an instance of OMCSession."

def ask(self, question, opt=None, parsed=True):

p = (question, opt, parsed)

if self.readonly and question != 'getErrorString':

# can use cache if readonly

if p in self.omc_cache:

return self.omc_cache[p]

if opt:

expression = '{0}({1})'.format(question, opt)

else:

expression = question

logger.debug('OMC ask: {0} - parsed: {1}'.format(expression, parsed))

try:

if parsed:

res = self.execute(expression)

else:

res = self._omc.sendExpression(expression)

except Exception as e:

logger.error("OMC failed: {0}, {1}, parsed={2}".format(question, opt, parsed))

raise e

# save response

self.omc_cache[p] = res

return res

# TODO: Open Modelica Compiler API functions. Would be nice to generate these.

def loadFile(self, filename):

return self.ask('loadFile', '"{0}"'.format(filename))

def loadModel(self, className):

return self.ask('loadModel', className)

def isModel(self, className):

return self.ask('isModel', className)

def isPackage(self, className):

return self.ask('isPackage', className)

def isPrimitive(self, className):

return self.ask('isPrimitive', className)

def isConnector(self, className):

return self.ask('isConnector', className)

def isRecord(self, className):

return self.ask('isRecord', className)

def isBlock(self, className):

return self.ask('isBlock', className)

def isType(self, className):

return self.ask('isType', className)

def isFunction(self, className):

return self.ask('isFunction', className)

def isClass(self, className):

return self.ask('isClass', className)

def isParameter(self, className):

return self.ask('isParameter', className)

def isConstant(self, className):

return self.ask('isConstant', className)

def isProtected(self, className):

return self.ask('isProtected', className)

def getPackages(self):

return self.ask('getPackages')

def getPackages(self, className):

return self.ask('getPackages', className)

def getClassRestriction(self, className):

return self.ask('getClassRestriction', className)

def getDerivedClassModifierNames(self, className):

return self.ask('getDerivedClassModifierNames', className)

def getDerivedClassModifierValue(self, className, modifierName):

return self.ask('getDerivedClassModifierValue', '{0}, {1}'.format(className, modifierName))

def typeNameStrings(self, className):

return self.ask('typeNameStrings', className)

def getComponents(self, className):

return self.ask('getComponents', className)

def getClassComment(self, className):

try:

return self.ask('getClassComment', className)

except pyparsing.ParseException as ex:

logger.warning("Method 'getClassComment' failed for {0}".format(className))

logger.warning('OMTypedParser error: {0}'.format(ex.message))

return 'No description available'

def getNthComponent(self, className, comp_id):

""" returns with (type, name, description) """

return self.ask('getNthComponent', '{0}, {1}'.format(className, comp_id))

def getNthComponentAnnotation(self, className, comp_id):

return self.ask('getNthComponentAnnotation', '{0}, {1}'.format(className, comp_id))

def getImportCount(self, className):

return self.ask('getImportCount', className)

def getNthImport(self, className, importNumber):

# [Path, id, kind]

return self.ask('getNthImport', '{0}, {1}'.format(className, importNumber))

def getInheritanceCount(self, className):

return self.ask('getInheritanceCount', className)

def getNthInheritedClass(self, className, inheritanceDepth):

return self.ask('getNthInheritedClass', '{0}, {1}'.format(className, inheritanceDepth))

def getParameterNames(self, className):

try:

return self.ask('getParameterNames', className)

except KeyError as ex:

logger.warning('OMPython error: {0}'.format(ex.message))

# FIXME: OMC returns with a different structure for empty parameter set

return []

def getParameterValue(self, className, parameterName):

try:

return self.ask('getParameterValue', '{0}, {1}'.format(className, parameterName))

except pyparsing.ParseException as ex:

logger.warning('OMTypedParser error: {0}'.format(ex.message))

return ""

def getComponentModifierNames(self, className, componentName):

return self.ask('getComponentModifierNames', '{0}, {1}'.format(className, componentName))

def getComponentModifierValue(self, className, componentName):

try:

# FIXME: OMPython exception UnboundLocalError exception for 'Modelica.Fluid.Machines.ControlledPump'

return self.ask('getComponentModifierValue', '{0}, {1}'.format(className, componentName))

except pyparsing.ParseException as ex:

logger.warning('OMTypedParser error: {0}'.format(ex.message))

result = self.ask('getComponentModifierValue', '{0}, {1}'.format(className, componentName), parsed=False)

try:

answer = OMParser.check_for_values(result)

OMParser.result = {}

return answer[2:]

except (TypeError, UnboundLocalError) as ex:

logger.warning('OMParser error: {0}'.format(ex.message))

return result

def getExtendsModifierNames(self, className, componentName):

return self.ask('getExtendsModifierNames', '{0}, {1}'.format(className, componentName))

def getExtendsModifierValue(self, className, extendsName, modifierName):

try:

# FIXME: OMPython exception UnboundLocalError exception for 'Modelica.Fluid.Machines.ControlledPump'

return self.ask('getExtendsModifierValue', '{0}, {1}, {2}'.format(className, extendsName, modifierName))

except pyparsing.ParseException as ex:

logger.warning('OMTypedParser error: {0}'.format(ex.message))

result = self.ask('getExtendsModifierValue', '{0}, {1}, {2}'.format(className, extendsName, modifierName), parsed=False)

try:

answer = OMParser.check_for_values(result)

OMParser.result = {}

return answer[2:]

except (TypeError, UnboundLocalError) as ex:

logger.warning('OMParser error: {0}'.format(ex.message))

return result

def getNthComponentModification(self, className, comp_id):

# FIXME: OMPython exception Results KeyError exception

# get {$Code(....)} field

# \{\$Code\((\S*\s*)*\)\}

value = self.ask('getNthComponentModification', '{0}, {1}'.format(className, comp_id), parsed=False)

value = value.replace("{$Code(", "")

return value[:-3]

#return self.re_Code.findall(value)

# function getClassNames

# input TypeName class_ = $Code(AllLoadedClasses);

# input Boolean recursive = false;

# input Boolean qualified = false;

# input Boolean sort = false;

# input Boolean builtin = false "List also builtin classes if true";

# input Boolean showProtected = false "List also protected classes if true";

# output TypeName classNames[:];

# end getClassNames;

def getClassNames(self, className=None, recursive=False, qualified=False, sort=False, builtin=False,

showProtected=False):

if className:

value = self.ask('getClassNames',

'{0}, recursive={1}, qualified={2}, sort={3}, builtin={4}, showProtected={5}'.format(

className, str(recursive).lower(), str(qualified).lower(), str(sort).lower(),

str(builtin).lower(), str(showProtected).lower()))

else:

value = self.ask('getClassNames',

'recursive={1}, qualified={2}, sort={3}, builtin={4}, showProtected={5}'.format(

str(recursive).lower(), str(qualified).lower(), str(sort).lower(),

str(builtin).lower(), str(showProtected).lower()))

"""

def __init__(self, name, start, changable, variability, description, causality, alias, aliasvariable):

self.name = name

self.start = start

self.changable = changable

self.description = description

self.variability = variability

self.causality = causality

self.alias = alias

def __init__(self, fileName = None, modelName = None, lmodel = None): #1

"""

if fileName is None and modelName is None and lmodel is None: # all None

self.getconn = OMCSession()

return

if fileName is None:

return "File does not exist"

self.tree = None

self.linearquantitiesList=[] #linearization quantity list

self.linearinputs=[] #linearization input list

self.linearoutputs=[] #linearization output list

self.linearstates=[] #linearization states list

self.quantitiesList = [] #detail list of all Modelica quantity variables inc. name, changable, description, etc

self.qNamesList = [] #for all quantities name list

self.cNamesList = [] #for continuous quantities name list

self.cValuesList = [] #for continuous quantities value list

self.iNamesList = [] #for input quantities name list

self.inputsVal = [] #for input quantities value list

self.specialNames = []

self.oNamesList = [] #for output quantities name list

self.pNamesList = [] #for parameter quantities name list

self.pValuesList = [] #for parameter quantities value list

self.oValuesList = [] #for output quantities value list

self.simNamesList = ['startTime', 'stopTime', 'stepSize', 'tolerance', 'solver'] #simulation options list

self.simValuesList = [] #for simulation values list

self.optimizeOptionsNamesList = ['startTime', 'stopTime', 'numberOfIntervals', 'stepSize', 'tolerance']

self.optimizeOptionsValuesList = [0.0, 1.0, 500, 0.002,1e-8]

self.linearizeOptionsNamesList = ['startTime', 'stopTime', 'numberOfIntervals', 'stepSize', 'tolerance']

self.linearizeOptionsValuesList = [0.0, 1.0, 500, 0.002,1e-8]

self.getconn = OMCSession()

self.xmlFile = None

self.lmodel = lmodel #may be needed if model is derived from other model

self.modelName = modelName #Model class name

self.fileName = fileName #Model file/package name

self.inputFlag = False #for model with input quantity

self.simulationFlag = False #if the model is simulated?

self.linearizationFlag = False

self.outputFlag = False

self.csvFile = '' #for storing inputs condition

if not os.path.exists(self.fileName): #if file does not eixt

print ("File Error:"+os.path.abspath(self.fileName)+ " does not exist!!!")

return

(head, tail) = os.path.split(self.fileName)#to store directory/path and file)

self.currDir = os.getcwd()

self.modelDir = head

self.fileName_ = tail

if not self.modelDir:

file_ = os.path.exists(self.fileName_)

if(file_):#execution from path where file is located

self.__loadingModel(self.fileName_, self.modelName, self.lmodel)

else:

print ("Error: File does not exist!!!")

else:

os.chdir(self.modelDir)

file_ = os.path.exists(self.fileName_)

self.model = self.fileName_[:-3]

if(self.fileName_):#execution from different path

os.chdir(self.currDir)

self.__loadingModel(self.fileName, self.modelName, self.lmodel)

else:

print ("Error: File does not exist!!!")

def __del__(self):

if self.getconn is not None:

self.requestApi('quit')

#for loading file/package, loading model and building model

def __loadingModel(self, fName, mName, lmodel):

#load file

loadfileError = ''

loadfileResult = self.requestApi("loadFile", fName)

loadfileError = self.requestApi("getErrorString")

if loadfileError:

specError = 'Parser error: Unexpected token near: optimization (IDENT)'

if specError in loadfileError:

self.requestApi("setCommandLineOptions", '"+g=Optimica"')

self.requestApi("loadFile", fName)

else:

print ('loadFile Error: ' + loadfileError)

return

#load Modelica standard libraries if needed

if lmodel is not None:

loadmodelError = ''

loadModelResult = self.requestApi("loadModel", lmodel)

loadmodelError = self.requestApi('getErrorString')

if loadmodelError:

print (loadmodelError)

return

# build model

#buildModelError = ''

self.getconn.sendExpression("setCommandLineOptions(\"+d=initialization\")")

#buildModelResult=self.getconn.sendExpression("buildModel("+ mName +")")

buildModelResult = self.requestApi("buildModel", mName)

buildModelError = self.requestApi("getErrorString")

if ('' in buildModelResult):

print (buildModelError)

return

self.xmlFile = buildModelResult[1]

self.tree = ET.parse(self.xmlFile)

self.root = self.tree.getroot()

self.__createQuantitiesList() #initialize quantitiesList

self.__getQuantitiesNames() #initialize qNamesList

self.__getContinuousNames() #initialize cNamesList

self.__getParameterNames() #initialize pNamesList

self.__getInputNames() #initialize iNamesList

self.__setInputSize() #defing input value list size

self.__getOutputNames() #initialize oNamesList

self.__getContinuousValues() #initialize cValuesList

self.__getParameterValues() #initialize pValuesList

self.__getInputValues() #initialize input value list

self.__getOutputValues() #initialize oValuesList

self.__getSimulationValues() #initialize simulation value list

#request to OMC

def requestApi(self, apiName, entity=None, properties=None ):#2

if (entity is not None and properties is not None):

exp = '{}({}, {})'.format(apiName, entity, properties)

elif entity is not None and properties is None:

if (apiName == "loadFile" or apiName == "importFMU"):

exp = '{}("{}")'.format(apiName, entity)

else:

exp = '{}({})'.format(apiName, entity)

else:

exp = '{}()'.format(apiName)

try:

res = self.getconn.sendExpression(exp)

except Exception as e:

print (e)

res = None

return res

#create detail quantities list

def __createQuantitiesList(self):

rootCQ = self.root

if not self.quantitiesList:

for sv in rootCQ.iter('ScalarVariable'):

name = sv.get('name')

changable = sv.get('isValueChangeable')

description = sv.get('description')

variability = sv.get('variability')

causality = sv.get('causality')

alias = sv.get('alias')

aliasvariable = sv.get('aliasVariable')

ch = sv.getchildren()

start = None

for att in ch:

start = att.get('start')

self.quantitiesList.append(Quantity(name, start, changable, variability, description, causality,alias,aliasvariable))

return self.quantitiesList

#to get list of all quantities names

def __getQuantitiesNames(self):

if not self.qNamesList:

for q in self.quantitiesList:

self.qNamesList.append(q.name)

return self.qNamesList

#check if names exist

def __checkAvailability(self, names, chkList, inputFlag = None):

try:

if isinstance(names, list):

nonExistingList = []

for n in names:

if n not in chkList:

nonExistingList.append(n)

if nonExistingList:

print ('Error!!! ' + str(nonExistingList) + ' does not exist.')

return False

elif isinstance(names, str):

if names not in chkList:

print ('Error!!! ' + names + ' does not exist.')

return False

else:

print ('Error!!! Incorrect format')

return False

return True

except Exception as e:

print (e)

#to get details of quantities names

def getQuantities(self, names = None):#3

"""

try:

if names is not None:

checking = self.__checkAvailability(names, self.qNamesList)

if not checking:

return

if isinstance(names, str):

qlistnames = []

for q in self.quantitiesList:

if names == q.name:

qlistnames.append({'Name':q.name, 'Value':q.start,'Changeable' : q.changable, 'Variability': q.variability, 'alias':q.alias,'aliasvariable':q.aliasvariable, 'Description':q.description})

break

return qlistnames

elif isinstance(names, list):

qlist = []

for n in names:

for q in self.quantitiesList:

if n == q.name:

qlist.append({'Name':q.name, 'Value':q.start,'Changeable' : q.changable, 'Variability': q.variability,'alias':q.alias,'aliasvariable':q.aliasvariable, 'Description':q.description})

break

return qlist

else:

print ('Error!!! Incorrect format')

else:

qlist = []

for q in self.quantitiesList:

qlist.append({'Name':q.name, 'Value':q.start,'Changeable' : q.changable, 'Variability': q.variability, 'alias':q.alias,'aliasvariable':q.aliasvariable,'Description':q.description})

return qlist

except Exception as e:

print (e)

#to get list of quantities name that are continuous variability

def __getContinuousNames(self):

"""

if not self.cNamesList:

for l in self.quantitiesList:

if(l.variability == "continuous"):

self.cNamesList.append(l.name)

return self.cNamesList

def __checkTuple(self, names, chkList, inputFlag=None):

if isinstance(names, tuple) and (len(n) == 1 for n in names):

nonExistingList = []

for n in names:

if n not in chkList:

nonExistingList.append(n)

if nonExistingList:

print ('Error!!!' + str(nonExistingList) + ' does not exist.')

return False

return True

else:

print ('Error!!! Incorrect format')

return False

def getContinuous(self, *names):#4

"""

try:

if not self.simulationFlag:

return self.__getXXXs(names, self.__getContinuousNames(), self.__getContinuousValues())

else:

if len(names) == 0:

cQuantities = self.__getContinuousNames()

cTuple = tuple(cQuantities)

cSol = self.getSolutions(cTuple)

cDict = dict()

for name, val in zip(cQuantities, cSol):

cDict[name] = val[-1]

return cDict

else:

checking = self.__checkTuple(names, self.__getContinuousNames())

if not checking:

return

cSol = self.getSolutions(names)

cList = list()

for val in cSol:

cList.append(val[-1])

tupVal = tuple(cList)

if len(tupVal) == 1:

tupVal, = tupVal

return tupVal

except Exception:

if pyparsing.ParseException:

print ('Error!!! Name does not exist or incorrect format ')

else:

raise

def getParameters(self, *names):#5

"""

return self.__getXXXs(names, self.__getParameterNames(), self.__getParameterValues())

def getInputs(self, *names):#6

"""

return self.__getXXXs(names, self.__getInputNames(), self.__getInputValues())

def getOutputs(self, *names):#7

"""

try:

if not self.simulationFlag:

return self.__getXXXs(names, self.__getOutputNames(), self.__getOutputValues())

else:

if len(names) == 0:

op = self.__getOutputNames()

opTuple = tuple(op)

opSol = self.getSolutions(opTuple)

opDict = dict()

for name, val in zip(op, opSol):

opDict[name] = val[-1]

return opDict

else:

checking = self.__checkTuple(names, self.__getOutputNames())

if not checking:

return

opSol = self.getSolutions(names)

opList = list()

for val in opSol:

opList.append(val[-1])

tupVal = tuple(opList)

if len(tupVal) == 1:

tupVal, = tupVal

return tupVal

# else:

# print ('The model is not simulated yet!!!')

except Exception:

if pyparsing.ParseException:

print ('Error!!! Name does not exist or incorrect format ')

else:

raise

def __getParameterNames(self):

"""

if not self.pNamesList:

for l in self.quantitiesList:

if(l.variability == "parameter"):

self.pNamesList.append(l.name)

return self.pNamesList

#to get list of quantities name that are input

def __getInputNames(self):

"""

if not self.iNamesList:

for l in self.quantitiesList:

if(l.causality == "input"):

self.iNamesList.append(l.name)

return self.iNamesList

#set input value list size

def __setInputSize(self):

size = len(self.__getInputNames())

self.inputsVal = [None]*size

#to get list of quantities name that are output

#Todo: has not been tested yet due to lack of the model that contains output.

def __getOutputNames(self):

"""

if not self.oNamesList:

for l in self.quantitiesList:

if(l.causality == "output"):

self.oNamesList.append(l.name)

return self.oNamesList

#to get values of continuous quantities name

def __getContinuousValues(self, contiName=None):

"""

if contiName is None:

if not self.cValuesList:

for l in self.quantitiesList:

if(l.variability == "continuous"):

str_ = l.start

if str_ is None:

self.cValuesList.append(str_)

else:

self.cValuesList.append(float(str_))

return self.cValuesList

else:

try:

#if isinstance(contiName, list):

checking = self.__checkAvailability(contiName, self.__getContinuousNames())

#if checking is False:

if not checking:

return

if isinstance (contiName, str):

index_ = self.cNamesList.index(contiName)

return (self.cValuesList[index_])

valList = []

for n in contiName:

index_ = self.cNamesList.index(n)

valList.append(self.cValuesList[index_])

return valList

except Exception as e:

print (e)

#to get values of parameter quantities name

def __getParameterValues(self, paraName = None):

"""

if paraName is None:

if not self.pValuesList:

for l in self.quantitiesList:

if(l.variability == "parameter"):

str_ = l.start

if ((str_ is None) or (str_ == 'true' or str_ == 'false')):

if (str_ == 'true'):

str_ = True

elif str_ == 'false':

str_ = False

self.pValuesList.append(str_)

else:

self.pValuesList.append(float(str_))

return self.pValuesList

else:

try:

checking = self.__checkAvailability(paraName, self.__getParameterNames())

if not checking:

return

if isinstance(paraName, str):

index_ = self.pNamesList.index(paraName)

return (self.pValuesList[index_])

valList = []

for n in paraName:

index_ = self.pNamesList.index(n)

valList.append(self.pValuesList[index_])

return valList

except Exception as e:

print (e)

#to get values of input names

def __getInputValues(self, iName=None):

"""

try:

if iName is None:

return self.inputsVal

elif isinstance(iName, str):

checking = self.__checkAvailability(iName,self.__getInputNames())

if not checking:

return

index_ = self.iNamesList.index(iName)

return self.inputsVal[index_]

else:

print ('Error!!! Incorrect format')

except Exception as e:

print (e)

#to get values of output quantities name

#Todo: has not been tested yet due to lack of the model that contains output.

def __getOutputValues(self):

"""

if not self.oValuesList:

for l in self.quantitiesList:

if(l.causality == "output"):

self.oValuesList.append(l.start)

return self.oValuesList