def __init__(self):

# Get the path to the OMC executable, if not installed this will be None

omc_env_home = os.environ.get('OPENMODELICAHOME')

if omc_env_home:

self.omhome = omc_env_home

else:

path_to_omc = spawn.find_executable("omc")

if path_to_omc is None:

raise ValueError("Cannot find OpenModelica executable, please install from openmodelica.org")

self.omhome = os.path.split(os.path.split(os.path.realpath(path_to_omc))[0])[0]

def _get_omc_path(self):

try:

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

except BaseException:

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

def __init__(self, readonly=False):

self.readonly = readonly

self.omc_cache = {}

self._omc_process = None

self._omc_command = None

self._omc = None

# 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

# omc log file

self._omc_log_file = None

def __del__(self):

try:

self.sendExpression("quit()")

except:

pass

self._omc_log_file.close()

if sys.version_info.major >= 3:

self._omc_process.wait(timeout=1.0)

else:

for i in range(0,100):

time.sleep(0.01)

if self._omc_process.poll() is not None:

break

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

if self._omc_process.returncode is None:

print("OMC did not exit after being sent the quit() command; killing the process with pid=%s" % str(self._omc_process.pid))

if sys.platform=="win32":

self._omc_process.kill()

self._omc_process.wait()

else:

os.killpg(os.getpgid(self._omc_process.pid), signal.SIGTERM)

self._omc_process.kill()

self._omc_process.wait()

def _create_omc_log_file(self, suffix):

if sys.platform == 'win32':

self._omc_log_file = open(os.path.join(self._temp_dir, "openmodelica.{0}.{1}.log".format(suffix, self._random_string)), 'w')

else:

try:

self._currentUser = getpass.getuser()

if not self._currentUser:

self._currentUser = "nobody"

except KeyError:

# We are running as a uid not existing in the password database... Pretend we are nobody

self._currentUser = "nobody"

# this file must be closed in the destructor

self._omc_log_file = open(os.path.join(self._temp_dir, "openmodelica.{0}.{1}.{2}.log".format(self._currentUser, suffix, self._random_string)), 'w')

def _start_omc_process(self):

if sys.platform == 'win32':

omhome_bin = os.path.join(self.omhome, 'bin').replace("\\", "/")

my_env = os.environ.copy()

my_env["PATH"] = omhome_bin + os.pathsep + my_env["PATH"]

self._omc_process = subprocess.Popen(self._omc_command, shell=True, stdout=self._omc_log_file, stderr=self._omc_log_file, env=my_env)

else:

# Because we spawned a shell, and we need to be able to kill OMC, create a new process group for this

self._omc_process = subprocess.Popen(self._omc_command, shell=True, stdout=self._omc_log_file, stderr=self._omc_log_file, preexec_fn=os.setsid)

return self._omc_process

def _set_omc_command(self, omc_path, args):

self._omc_command = "{0} {1}".format(omc_path, args)

return self._omc_command

@abc.abstractmethod

def _connect_to_omc(self, timeout):

pass

# 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.

@abc.abstractmethod

def execute(self, command):

pass

# 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.

@abc.abstractmethod

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

"""

pass

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.sendExpression(expression, parsed=False)

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, className="AllLoadedClasses"):

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))

# 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))

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))

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, readonly=False, serverFlag='--interactive=corba', timeout = 0.25):

OMCSessionHelper.__init__(self)

OMCSessionBase.__init__(self, readonly)

self._create_omc_log_file("objid")

# set omc executable path and args

self._set_omc_command(self._get_omc_path(), "{0} +c={1}".format(serverFlag, self._random_string))

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

self._start_omc_process()

# connect to the running omc instance using CORBA

self._connect_to_omc(timeout)

def __del__(self):

OMCSessionBase.__del__(self)

def _connect_to_omc(self, timeout):

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

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

# import the skeletons for the global module

try:

from omniORB import CORBA

from OMPythonIDL import _OMCIDL

except ImportError:

self._omc_process.kill()

self._omc_process.wait()

raise

# 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(timeout)

attempts += 1

if attempts == 10:

name = self._omc_log_file.name

self._omc_log_file.close()

with open(name) as fin:

contents = fin.read()

logger.error("OMC Server is down. Please start it! If the OMC version is old, try OMCSession(..., serverFlag='-d=interactiveCorba') or +d=interactiveCorba Log-file says:\n%s" % contents)

self._omc_process.kill()

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 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."

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 is True:

answer = OMTypedParser.parseString(result)

return answer

else:

return result

else:

def __init__(self, readonly=False, timeout = 0.25):

OMCSessionHelper.__init__(self)

OMCSessionBase.__init__(self, readonly)

self._create_omc_log_file("port")

# set omc executable path and args

self._set_omc_command(self._get_omc_path(), "--interactive=zmq +z={0}".format(self._random_string))

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

self._start_omc_process()

# connect to the running omc instance using CORBA

self._connect_to_omc(timeout)

def __del__(self):

OMCSessionBase.__del__(self)

def _connect_to_omc(self, timeout):

# Locating and using the IOR

if sys.platform == 'win32':

self._port_file = "openmodelica.port." + self._random_string

else:

self._port_file = "openmodelica." + self._currentUser + ".port." + self._random_string

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

self._omc_zeromq_uri = "file:///" + self._port_file

# See if the omc server is running

attempts = 0

while True:

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

time.sleep(timeout)

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("OMC Server is down. Could not open file %s" % self._port_file)

else:

continue

else:

logger.info("OMC Server is up and running at {0} pid={1}".format(self._omc_zeromq_uri, self._omc_process.pid))

break

# Read the port file

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

self._port = f_p.readline()

# Create the ZeroMQ socket and connect to OMC server

import zmq

context = zmq.Context.instance()

self._omc = context.socket(zmq.REQ)

self._omc.setsockopt(zmq.LINGER, 0) # Dismisses pending messages if closed

self._omc.connect(self._port)

def execute(self, command):

if self._omc is not None:

self._omc.send_string(command)

if command == "quit()":

self._omc.close()

self._omc = None

return None

else:

result = self._omc.recv_string()

answer = OMParser.check_for_values(result)

return answer

else:

raise Exception("No connection with OMC. Create an instance of OMCSessionZMQ.")

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

if self._omc is not None:

self._omc.send_string(str(command))

if command == "quit()":

self._omc.close()

self._omc = None

return None

else:

result = self._omc.recv_string()

if parsed is True:

answer = OMTypedParser.parseString(result)

return answer

else:

return result

else:

"""

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=[], useCorba=False): # 1

"""

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

if useCorba:

self.getconn = OMCSession()

else:

self.getconn = OMCSessionZMQ()

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]

if useCorba:

self.getconn = OMCSession()

else:

self.getconn = OMCSessionZMQ()

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")

# print the notification to users

if(loadfileResult==True and loadfileError):

print(loadfileError)

if (loadfileResult==False):

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 or Modelica files if needed

for element in lmodel:

if element is not None:

loadmodelError = ''

if element.endswith(".mo"):

loadModelResult = self.requestApi("loadFile", element)

loadmodelError = self.requestApi('getErrorString')

else:

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

loadmodelError = self.requestApi('getErrorString')

if loadmodelError:

print(loadmodelError)

# 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: