def init(self, sid, work_dir=None, model_name=None, instance_name=None, var_table=None, fmi_me_version=None, step_size=1, step_factor=1, integrator='ck', logging_on=False, stop_before_event=False, event_search_precision=1e-10, translation_table=None, automated_initialization=True): self.sid = sid # Set simulator parameters needed mostly for the FMU: self.work_dir = work_dir self.model_name = model_name self.instance_name = instance_name self.step_size = step_size self.step_factor = step_factor self.logging_on = logging_on self.stop_before_event = stop_before_event self.integrator = getattr(fmipp, integrator) self.event_search_precision = event_search_precision self.fmi_me_version = fmi_me_version self.automated_initialization = automated_initialization # Extract the module from the FMU: path_to_fmu = os.path.join(self.work_dir, self.model_name + '.fmu') self.uri_to_extracted_fmu = fmipp.extractFMU(path_to_fmu, self.work_dir) # Get the model description and use it if the user did not specify the variables: xmlfile = os.path.join(self.work_dir, self.model_name, 'modelDescription.xml') if var_table is None: self.var_table, self.translation_table = mosaik_fmume_test.parse_xml.get_var_table(xmlfile) else: self.var_table = var_table self.translation_table = translation_table self.adjust_var_table() self.adjust_meta() return self.meta
def __init__(self, host, input_attributes=None, output_attributes=None, is_first=False): # Implement OBNL client node super(Node, self).__init__(host, 'obnl_vhost', 'obnl', 'obnl', 'config_file.json', input_attributes=input_attributes, output_attributes=output_attributes, is_first=is_first) self.redis = redis.StrictRedis(host=host, port=6379, db=0) # Declare model work_dir = os.path.split( os.path.abspath(__file__))[0] # define working directory model_name = 'IBPSA_Fluid_FixedResistances_Examples_PlugFlowPipe' # define FMU model name print(work_dir) path_to_fmu = os.path.join(work_dir, model_name + '.fmu') # path to FMU uri_to_extracted_fmu = fmipp.extractFMU(path_to_fmu, work_dir) # extract FMU logging_on = False time_diff_resolution = 1e-9 self.fmu = fmipp.FMUCoSimulationV2(uri_to_extracted_fmu, model_name, logging_on, time_diff_resolution) print('successfully loaded the FMU') start_time = 0. stop_time = 3600. * 24. # 24 hours instance_name = "trnsys_fmu_test" visible = False interactive = False status = self.fmu.instantiate(instance_name, start_time, visible, interactive) assert status == fmipp.fmiOK print('successfully instantiated the FMU') stop_time_defined = True status = self.fmu.initialize(start_time, stop_time_defined, stop_time) assert status == fmipp.fmiOK print('successfully initialized the FMU') # Set initial values / model parameters with open('init_values.json') as json_data: init_values = json.load(json_data) for key, val in init_values.items(): self.fmu.setRealValue(key, val) print("DH set up done")
def init(self, sid, work_dir=None, model_name=None, instance_name=None, var_table=None, step_size=1, logging_on=False, time_diff_resolution=1e-9, interactive=False, visible=False, stop_time_defined=False, step_factor=1, stop_time=10000): self.sid = sid # Set simulator parameters needed mostly for the FMU: self.work_dir = work_dir self.model_name = model_name self.instance_name = instance_name self.step_size = step_size self.step_factor = step_factor self.logging_on = logging_on self.time_diff_resolution =time_diff_resolution self.interactive = interactive self.visible = visible self.stop_time_defined = stop_time_defined self.stop_time = stop_time # Extract the module from the FMU: path_to_fmu = os.path.join(self.work_dir, self.model_name + '.fmu') self.uri_to_extracted_fmu = fmipp.extractFMU(path_to_fmu, self.work_dir) # Get the model description and use it if the user did not specify the variables: xmlfile = os.path.join(self.work_dir, self.model_name, 'modelDescription.xml') if var_table is None: self.var_table, self.translation_table = mosaik_fmume_test.parse_xml.get_var_table(xmlfile) else: self.var_table = var_table self.translation_table = {} self.adjust_var_table() self.adjust_meta() return self.meta
def init(self, sid, work_dir, model_name, instance_name, step_size, start_time=0, stop_time=0, logging_on=False, time_diff_resolution=1e-9, timeout=0, interactive=False, visible=False, stop_time_defined=False, seconds_per_mosaik_timestep=1, var_table=None, translation_table=None, verbose=False): self.step_size = step_size self.work_dir = work_dir self.model_name = model_name self.instance_name = instance_name self.start_time = start_time self.stop_time = stop_time self.logging_on = logging_on self.time_diff_resolution = time_diff_resolution # How close should two events be to be considered equal? self.timeout = timeout self.interactive = interactive self.visible = visible self.stop_time_defined = stop_time_defined self.sec_per_mt = seconds_per_mosaik_timestep # Number of seconds of internaltime per mosaiktime (Default: 1, mosaiktime measured in seconds) self.verbose = verbose path_to_fmu = os.path.join(self.work_dir, self.model_name + '.fmu') if self.verbose: print('Attempted to extract FMU {0}, Path {1}'.format( path_to_fmu, self.work_dir)) self.uri_to_extracted_fmu = fmipp.extractFMU(path_to_fmu, self.work_dir) assert self.uri_to_extracted_fmu is not None '''If no variable table is given by user, parse the modelDescription.xml for a table - however, this will not work properly for some FMUs due to varying conventions.''' xmlfile = os.path.join(self.work_dir, self.model_name, 'modelDescription.xml') if var_table is None: self.var_table, self.translation_table = self.get_var_table( xmlfile) else: self.var_table = var_table self.translation_table = translation_table self.adjust_var_table() return self.meta
def __init__( self, name, group, inputs_map, outputs, init_values ): # If needed you can pass more values to your node constructor. super(MyNode, self).__init__( name, group, inputs_map, outputs, init_values ) # Keep this line, it triggers the parent class method. # This is where you define the attribute of your model, this one is pretty basic. # FMU loading work_dir = os.path.split( os.path.abspath(__file__))[0] # define working directory model_name = 'Exercise1D' # define FMU model name path_to_fmu = os.path.join(work_dir, model_name + '.fmu') # path to FMU uri_to_extracted_fmu = fmipp.extractFMU(path_to_fmu, work_dir) # extract FMU logging_on = False time_diff_resolution = 1e-9 self.fmu = fmipp.FMUCoSimulationV1(uri_to_extracted_fmu, model_name, logging_on, time_diff_resolution) print('successfully loaded the FMU') ## FMU instantiation start_time = 0. stop_time = 3600. * 24. # 24 hours self.step_size = 3600 # 1 hour self.tempo = self.step_size instance_name = "eplus_fmu_test" visible = False interactive = False status = self.fmu.instantiate(instance_name, start_time, visible, interactive) assert status == fmipp.fmiOK print('successfully instantiated the FMU') ## FMU initialization stop_time_defined = True status = self.fmu.initialize(start_time, stop_time_defined, stop_time) assert status == fmipp.fmiOK print('successfully initialized the FMU')
def __init__(self): super().__init__( ) # Keep this line, it triggers the parent class __init__ method. # This is where you define the attribute of your model, this one is pretty basic. # FMU loading work_dir = os.path.split( os.path.abspath(__file__))[0] # define working directory #self.ModelName = 'Residential_DH' # define FMU model name self.modelName = 'Residential_DH_2' path_to_fmu = os.path.join(work_dir, self.modelName + '.fmu') # path to FMU uri_to_extracted_fmu = fmipp.extractFMU(path_to_fmu, work_dir) # extract FMU logging_on = False time_diff_resolution = 1e-9 self.fmu = fmipp.FMUCoSimulationV1(uri_to_extracted_fmu, self.modelName, logging_on, time_diff_resolution) print('successfully loaded the FMU') ## FMU instantiation start_time = 3600. * 24. * 0. stop_time = 3600. * 24. * 31. # 24 hours self.step_size = 3600. # 1/6 hour self.tempo = start_time # self.step_size instance_name = "eplus_fmu_test" visible = False interactive = False status = self.fmu.instantiate(instance_name, start_time, visible, interactive) assert status == fmipp.fmiOK print('successfully instantiated the FMU') ## FMU initialization stop_time_defined = True status = self.fmu.initialize(start_time, stop_time_defined, stop_time) assert status == fmipp.fmiOK print('successfully initialized the FMU')
def __init__(self): super().__init__( ) # Keep this line, it triggers the parent class __init__ method. # This is where you define the attribute of your model, this one is pretty basic. # FMU loading work_dir = os.path.split( os.path.abspath(__file__))[0] # define working directory model_name = 'COGplant' # define FMU model name path_to_fmu = os.path.join(work_dir, model_name + '.fmu') # path to FMU uri_to_extracted_fmu = fmipp.extractFMU(path_to_fmu, work_dir) # extract FMU logging_on = False time_diff_resolution = 1e-9 self.fmu = fmipp.FMUCoSimulationV1(uri_to_extracted_fmu, model_name, logging_on, time_diff_resolution) print('successfully loaded the FMU') ## FMU instantiation start_time = 0. stop_time = 450. * 8. * 24 * 31. # 24 hours self.step_size = 3600 # 450. # 1 hour self.tempo = self.step_size instance_name = "trnsys_fmu_test" visible = False interactive = False status = self.fmu.instantiate(instance_name, start_time, visible, interactive) assert status == fmipp.fmiOK print('successfully instantiated the FMU') ## FMU initialization stop_time_defined = True status = self.fmu.initialize(start_time, stop_time_defined, stop_time) assert status == fmipp.fmiOK #fmu.setRealValue( 'Treturn', 40. ) # Very important to initialize print('successfully initialized the FMU')
import fmipp import os.path import math work_dir = os.path.split( os.path.abspath(__file__))[0] # define working directory model_name = 'Exercise1D' # define FMU model name path_to_fmu = os.path.join(work_dir, model_name + '.fmu') # path to FMU uri_to_extracted_fmu = fmipp.extractFMU(path_to_fmu, work_dir) # extract FMU logging_on = False time_diff_resolution = 1e-9 fmu = fmipp.FMUCoSimulationV1(uri_to_extracted_fmu, model_name, logging_on, time_diff_resolution) print('successfully loaded the FMU') start_time = 0. stop_time = 3600. * 24. # 24 hours instance_name = "eplus_fmu_test" visible = False interactive = False status = fmu.instantiate(instance_name, start_time, visible, interactive) assert status == fmipp.fmiOK print('successfully instantiated the FMU') stop_time_defined = True status = fmu.initialize(start_time, stop_time_defined, stop_time)
work_dir = os.getcwd() logging_on = False #------------------------------------------------------------------------------ # the matlab controller #------------------------------------------------------------------------------ model_name_M = 'RmsConverterController_R2014b_sf' stop_before_event = False event_search_precision = 1e-10 integrator_type = fmipp.eu path_to_fmu_M = os.path.join(work_dir, model_name_M + '.fmu') # Extract FMU and retrieve URI to directory. uri_to_extracted_fmu_M = fmipp.extractFMU(path_to_fmu_M, work_dir) # using the FMI 2.0 specification fmuM = fmipp.FMUModelExchangeV2(uri_to_extracted_fmu_M, model_name_M, logging_on, stop_before_event, event_search_precision, integrator_type) # Instantiate the FMU. status1 = fmuM.instantiate("my_RMS_controller") # instantiate model assert status1 == fmipp.fmiOK # Initialize the FMU. status1 = fmuM.initialize() # initialize model assert status1 == fmipp.fmiOK # Initialize the FMU. stop_time = 20. stop_time_defined = True
def test_IncrementalFMU(zip_command): work_dir = os.path.split( os.path.abspath(__file__))[0] # define working directory model_name = 'zigzag' # define FMU model name path_to_fmu = os.path.join(work_dir, model_name + '.fmu') # path to FMU uri_to_extracted_fmu = fmipp.extractFMU(path_to_fmu, work_dir, command=zip_command) # extract FMU # create FMI++ wrapper for FMU for Model Exchange (Version 1.0) logging_on = False event_search_precision = 1e-7 integrator_type = fmipp.bdf fmu = fmipp.IncrementalFMU(uri_to_extracted_fmu, model_name, logging_on, event_search_precision, integrator_type) # number of parameters that should be initialized n_init = 2 # construct string array for init parameter names init_vars = fmipp.new_string_array(n_init) fmipp.string_array_setitem(init_vars, 0, 'k') fmipp.string_array_setitem(init_vars, 1, 'x') # construct string array for init parameter values init_vals = fmipp.new_double_array(n_init) fmipp.double_array_setitem(init_vals, 0, 1.0) fmipp.double_array_setitem(init_vals, 1, 0.0) # define number of real outputs n_real_outputs = 1 # construct string array with output names outputs = fmipp.new_string_array(n_real_outputs) fmipp.string_array_setitem(outputs, 0, 'x') # define real outputs fmu.defineRealOutputs(outputs, n_real_outputs) start_time = 0.0 stop_time = 5.0 step_size = 0.3 horizon = 2 * step_size int_step_size = step_size / 2 status = fmu.init('zigzag1', init_vars, init_vals, n_init, start_time, horizon, step_size, int_step_size) # initialize model assert status == 1 # check status time = start_time next = start_time x_expected = { 0.0: 0.0, 0.3: 0.3, 0.6: 0.6, 0.9: 0.9, 1.0: 1.0, 1.3: 0.7, 1.6: 0.4, 1.9: 0.1, 2.2: -0.2, 2.5: -0.5, 2.8: -0.8, 3.0: -1.0, 3.3: -0.7, 3.6: -0.4, 3.9: -0.1, 4.2: 0.2, 4.5: 0.5, 4.8: 0.8, } while (time + step_size - stop_time < 1e-6): oldnext = next next = fmu.sync(time, min(time + step_size, next)) result = fmu.getRealOutputs() x = fmipp.double_array_getitem(result, 0) time = min(time + step_size, oldnext) assert round(x, 1) == x_expected[round(time, 1)]
def test_FMUExport(zip_command): from fmipp.export.createFMU import createFMU from FMUExportTest import FMUExportTestClass model_name = 'FMUExportTestCS' # define FMU model name start_values = { 'pr_y': 2.2, 'pr_x': 1.1, 'ir_y': 2., 'ir_x': 1., 'pi_y': 3, 'pi_x': 6, 'ii_y': 4, 'ii_x': 5, 'pb_y': True, 'pb_x': True, 'ib_y': False, 'ib_x': True, # 'ps_y' : 'abc', 'ps_x' : 'def', # 'is_y' : 'ghi', 'is_x' : 'jkl' } optional_files = ['extra.dat'] createFMU(FMUExportTestClass, model_name, fmi_version='2', verbose=False, start_values=start_values, optional_files=optional_files) work_dir = os.path.split( os.path.abspath(__file__))[0] # define working directory path_to_fmu = os.path.join(work_dir, model_name + '.fmu') # path to FMU uri_to_extracted_fmu = fmipp.extractFMU(path_to_fmu, work_dir, command=zip_command) # extract FMU logging_on = False time_diff_resolution = 1e-9 fmu = fmipp.FMUCoSimulationV2(uri_to_extracted_fmu, model_name, logging_on, time_diff_resolution) start_time = 0. stop_time = 10. instance_name = "test1" visible = False interactive = False status = fmu.instantiate(instance_name, start_time, visible, interactive) assert status == fmipp.fmiOK stop_time_defined = True status = fmu.initialize(start_time, stop_time_defined, stop_time) assert status == fmipp.fmiOK time = 0. step_size = 1. new_step = True status = fmu.doStep(time, step_size, new_step) assert status == fmipp.fmiOK assert 1.1 == fmu.getRealValue('or_x') assert fmu.getLastStatus() == fmipp.fmiOK assert 4.4 == fmu.getRealValue('or_y') assert fmu.getLastStatus() == fmipp.fmiOK assert 30 == fmu.getIntegerValue('oi_x') assert fmu.getLastStatus() == fmipp.fmiOK assert 12 == fmu.getIntegerValue('oi_y') assert fmu.getLastStatus() == fmipp.fmiOK assert True == fmu.getBooleanValue('ob_x') assert fmu.getLastStatus() == fmipp.fmiOK assert False == fmu.getBooleanValue('ob_y') assert fmu.getLastStatus() == fmipp.fmiOK
def test_FMUModelExchange(zip_command): work_dir = os.path.split( os.path.abspath(__file__))[0] # define working directory model_name = 'zigzag' # define FMU model name path_to_fmu = os.path.join(work_dir, model_name + '.fmu') # path to FMU uri_to_extracted_fmu = fmipp.extractFMU(path_to_fmu, work_dir, command=zip_command) # extract FMU # create FMI++ wrapper for FMU for Model Exchange (Version 1.0) logging_on = False stop_before_event = False event_search_precision = 1e-10 integrator_type = fmipp.bdf fmu = fmipp.FMUModelExchangeV1(uri_to_extracted_fmu, model_name, logging_on, stop_before_event, event_search_precision, integrator_type) status = fmu.instantiate("my_test_model_1") # instantiate model assert status == fmipp.fmiOK # check status status = fmu.setRealValue('k', 1.0) # set value of parameter 'k' assert status == fmipp.fmiOK # check status status = fmu.initialize() # initialize model assert status == fmipp.fmiOK # check status t = 0.0 stepsize = 0.125 tstop = 3.0 x_expected = { 0.125: 0.125, 0.250: 0.250, 0.375: 0.375, 0.500: 0.500, 0.625: 0.625, 0.750: 0.750, 0.875: 0.875, 1.000: 1.000, 1.000: 1.000, 1.125: 0.875, 1.250: 0.750, 1.375: 0.625, 1.500: 0.500, 1.625: 0.375, 1.750: 0.250, 1.875: 0.125, 2.000: 0.000, 2.125: -0.125, 2.250: -0.250, 2.375: -0.375, 2.500: -0.500, 2.625: -0.625, 2.750: -0.750, 2.875: -0.875, 3.000: -1.000, } while ((t + stepsize) - tstop < 1e-6): t = fmu.integrate(t + stepsize) # integrate model x = fmu.getRealValue("x") # retrieve output variable 'x' assert round(x, 3) == x_expected[round(t, 3)]
#------------------------------------------------------------------------------ #------------------------------------------------------------------------------ work_dir=os.getcwd() logging_on = False stop_before_event = False event_search_precision = 1e-10 integrator_type = fmipp.eu #------------------------------------------------------------------------------ # The First Matlab Controller (FRT) #------------------------------------------------------------------------------ model_name_M='FRTController_mar_v2_sf' path_to_fmu_M = os.path.join(work_dir, model_name_M + '.fmu') # Extract FMU and retrieve URI to directory. uri_to_extracted_fmu_M= fmipp.extractFMU( path_to_fmu_M, work_dir ) # using the FMI 2.0 specification fmuM1 = fmipp.FMUModelExchangeV2(uri_to_extracted_fmu_M, model_name_M, logging_on, stop_before_event, event_search_precision, integrator_type ) status1 = fmuM1.instantiate( "my_FRT_controller" ) # Instantiate the FMU model assert status1 == fmipp.fmiOK # set all internal parameters of the second FMU #------------------------------------------------------------------------------ fmuM1.setRealValue("Parameters.StateMachine_dT", step_size) # dT: time step size of the simulation federate fmuM1.setRealValue("Parameters.State_Machine.state_transition_RpS3", 0.5) #ramping rate when in state=3,, determines how long the converter will ramp up the active power and when it returns to normal operation, i.e., state=1 # Initializing the FMU model #------------------------------------------------------------------------------ fmuM1.setRealValue("Udc",1.0) # - Udc fmuM1.setRealValue("VPCC",1.0) # - VPCC fmuM1.setBooleanValue("release",False) # - release