def test_sanitize_name(self):
        '''
        Test the function sanitize_name().

        '''

        # Testing name conversions.
        name = simulator.sanitize_name('test+name')
        self.assertEqual(name, 'test_name', 'Names are not matching.')

        name = simulator.sanitize_name('0test+*.name')
        self.assertEqual(name, 'f_0test___name', 'Names are not matching.')
    def test_check_duplicates(self):
        '''
        Test the function check_duplicates().

        '''

        # Array does not contain duplicates variables.
        simulator.check_duplicates(['x1', 'x2', 'x3', 'x4'])

        # Array contain duplicates variables.
        with self.assertRaises(AssertionError):
            simulator.check_duplicates(['x1', 'x1', 'x3', 'x4'])
示例#3
0
    def test_updates_fmu(self):
        '''
        Test the export and updates of FMUs.

        '''

        for tool in  ['dymola', 'jmodelica', 'openmodelica']:
            print("Search executable for tool={!s}".format(tool))
            retVal=self.find_executable(tool)
            if ((retVal is not None) and retVal!=1):
                print("======tool={!s} was found. Unit Test will be run".format(tool))
            else:
                continue

            if (platform.system().lower() == 'linux' and tool == 'openmodelica'):
                print ('tool={!s} is not supported on Linux.'.format(tool))
                continue
            if tool == 'openmodelica':
                modPat = 'OPENMODELICALIBRARY'
                mosT = MOS_TEMPLATE_PATH_OPENMODELICA
            elif tool == 'dymola':
                modPat = 'MODELICAPATH'
                mosT = MOS_TEMPLATE_PATH_DYMOLA
            elif tool == 'jmodelica':
                if (os.environ.get('MODELICAPATH') is not None):
                    del os.environ['MODELICAPATH']
                modPat = None
                mosT = MOS_TEMPLATE_PATH_JMODELICA
            for version in ['2']:
                if (tool == 'openmodelica' or tool == 'jmodelica'):
                    version = str(float(version))
                for api in ['me']:
                    if (tool == 'openmodelica' and version == '1.0' and api == 'cs'):
                        print (
                            'tool={!s} with FMI version={!s} and FMI API={!s} is not supported.'.format(
                                tool, version, api))
                        continue
                    for cs_xml in ['true']:
                        if (version == '1'):
                            continue
                        for exc in ['python']:
                            if exc=='python':
                                scripts_path=python_scripts_path
                            elif exc=='server':
                                scripts_path=server_scripts_path
                            Simulator_Test = simulator.SimulatorToFMU(
                                '',
                                XML_INPUT_FILE,
                                SimulatorToFMU_LIB_PATH,
                                MO_TEMPLATE_PATH,
                                mosT,
                                XSD_FILE_PATH,
                                '27',
                                scripts_path,
                                version,
                                api,
                                tool,
                                None,
                                modPat,
                                cs_xml,
                                'true',
                                exc)
                            print (
                                'Export the simulator with tool={!s}, FMI version={!s}, FMI API={!s}, exc={!s}'.format(
                                    tool, version, api, exc))
                            start = datetime.now()
                            self.helper_export(Simulator_Test)
                            end = datetime.now()
                            print(
                                'Export the simulator as an FMU in {!s} seconds.'.format(
                                    (end - start).total_seconds()))
                            fmu_path = os.path.join(
                            script_path, '..', 'fmus', tool, platform.system().lower())
                            print(
                                'Copy simulator.fmu to {!s}.'.format(fmu_path))
                            shutil.copy2('simulator.fmu', fmu_path)
示例#4
0
    def test_simulator_to_fmu(self):
        '''
        Test the export of an FMU with various options.

        '''

        for tool in  ['dymola', 'jmodelica', 'openmodelica']:
            retVal=self.find_executable(tool)
            if ((retVal is not None) and retVal!=1):
                print("======tool={!s} was found. Unit Test will be run".format(tool))
            else:
                continue

            if (platform.system().lower() == 'linux' and tool == 'openmodelica'):
                print ('tool={!s} is not supported on Linux.'.format(tool))
                continue
            if tool == 'openmodelica':
                modPat = 'OPENMODELICALIBRARY'
                mosT = MOS_TEMPLATE_PATH_OPENMODELICA
            elif tool == 'dymola':
                modPat = 'MODELICAPATH'
                mosT = MOS_TEMPLATE_PATH_DYMOLA
            elif tool == 'jmodelica':
                if (os.environ.get('MODELICAPATH') is not None):
                    del os.environ['MODELICAPATH']
                modPat = None
                mosT = MOS_TEMPLATE_PATH_JMODELICA
            for version in ['1', '2']:
                if (tool == 'openmodelica' or tool == 'jmodelica'):
                    version = str(float(version))
                for api in ['me', 'cs']:
                    if (tool == 'openmodelica' and version == '1.0' and api == 'cs'):
                        print (
                            'tool={!s} with FMI version={!s} and FMI API={!s} is not supported.'.format(
                                tool, version, api))
                        continue
                    for cs_xml in ['true']:
                        if (version == '1'):
                            continue

                        for exc in ['python']:
                            if exc=='python':
                                scripts_path=python_scripts_path
                                if (platform.system().lower() == 'linux'):
                                    py_arr=['27']
                                else:
                                    py_arr=['27', '34', '37']
                                for py_vers in py_arr:
                                    Simulator_Test = simulator.SimulatorToFMU(
                                        '',
                                        XML_INPUT_FILE,
                                        SimulatorToFMU_LIB_PATH,
                                        MO_TEMPLATE_PATH,
                                        mosT,
                                        XSD_FILE_PATH,
                                        py_vers,
                                        scripts_path,
                                        version,
                                        api,
                                        tool,
                                        None,
                                        modPat,
                                        cs_xml,
                                        'true',
                                        exc)
                                    print ('Export the simulator with tool={!s},'\
                                        ' FMI version={!s}, FMI API={!s}, exc={!s}, py_vers={!s}'.format(
                                        tool, version, api, exc, py_vers))
                                    start = datetime.now()
                                    self.helper_export(Simulator_Test)
                                    end = datetime.now()
                                    print(
                                        'Export Simulator as an FMU in {!s} seconds.'.format(
                                            (end - start).total_seconds()))
                            elif exc=='server':
                                scripts_path=server_scripts_path
                                Simulator_Test = simulator.SimulatorToFMU(
                                    '',
                                    XML_INPUT_FILE,
                                    SimulatorToFMU_LIB_PATH,
                                    MO_TEMPLATE_PATH,
                                    mosT,
                                    XSD_FILE_PATH,
                                    '27',
                                    scripts_path,
                                    version,
                                    api,
                                    tool,
                                    None,
                                    modPat,
                                    cs_xml,
                                    'true',
                                    #None,
                                    exc)
                                print ('Export the simulator with tool={!s},'\
                                    ' FMI version={!s}, FMI API={!s}, exc={!s}'.format(
                                    tool, version, api, exc))
                                start = datetime.now()
                                self.helper_export(Simulator_Test)
                                end = datetime.now()
                                print(
                                    'Export Simulator as an FMU in {!s} seconds.'.format(
                                        (end - start).total_seconds()))
示例#5
0
    def run_simulator (self, tool):

        '''
        Function for running FMUs exported from Dymola, JModelica, and OpenModelica with PyFMI.

        '''
        try:
            from pyfmi import load_fmu
        except BaseException:
            print ('PyFMI not installed. Test will not be be run.')
            return
        if (tool=='openmodelica' and platform.system().lower() == 'linux'):
                print ('tool={!s} is not supported on Linux'.format(tool))
                return

        else:
        # Export FMUs which are needed to run the cases.
            if tool == 'openmodelica':
                modPat = 'OPENMODELICALIBRARY'
                mosT = MOS_TEMPLATE_PATH_OPENMODELICA
                # Add the library folder to the system pah so unit test can be run
                # with OpenModelica
                for arch in ['win32']:
                    lib_path_arch=os.path.join(
                        script_path, '..', 'parser', 'libraries', 'modelica',
                        'SimulatorToFMU', 'Resources','Library', arch)
                orig_path=os.environ.get('PATH')
                os.environ['PATH']=lib_path_arch + os.pathsep + orig_path
            elif tool == 'dymola':
                modPat = 'MODELICAPATH'
                mosT = MOS_TEMPLATE_PATH_DYMOLA
            elif tool == 'jmodelica':
                # Unset environment variable
                if (os.environ.get('MODELICAPATH') is not None):
                    del os.environ['MODELICAPATH']
                modPat = None
                mosT = MOS_TEMPLATE_PATH_JMODELICA
            for version in ['2']:
                if (tool == 'openmodelica' or tool == 'jmodelica'):
                    version = str(float(version))
                for api in ['me']:
                    if (tool == 'openmodelica' and version == '1.0' and api == 'cs'):
                        print (
                            'tool={!s} with FMI version={!s} and FMI API={!s} is not supported.'.format(
                                tool, version, api))
                        continue
                    for cs_xml in ['true']:
                        if (version == '1'):
                            continue
                        # Setting parameters for running Python or server architecture
                        if (platform.system().lower()=='linux'):
                            exc_arr=['python']
                            print('Server architecture is only supported on Windows')
                        elif (platform.system().lower()=='windows' and (tool=='jmodelica')):
                            exc_arr=['python'] # Exclude ServerFMU from the Unittests
                        elif (platform.system().lower()=='windows' and (tool in ['dymola', 'openmodelica'])):
                            exc_arr=['python']
                            # Dymola's FMUs cannot be instantiated twice in the same process
                            # This is the reason why we don't call it twice for the different
                            # architecture. Setting exc_arr='server' will allow testing the Python architecture
                            print('Only running the Python architecture for Dymola')
                        for exc in exc_arr:
                            if exc=='python':
                                scripts_path=python_scripts_path
                            elif exc=='server':
                                scripts_path=server_scripts_path
                            Simulator_Test = simulator.SimulatorToFMU(
                                '',
                                XML_INPUT_FILE,
                                SimulatorToFMU_LIB_PATH,
                                MO_TEMPLATE_PATH,
                                mosT,
                                XSD_FILE_PATH,
                                '27',
                                scripts_path,
                                version,
                                api,
                                tool,
                                None,
                                modPat,
                                cs_xml,
                                'true',
                                exc)

                            print (
                                'Export the simulator with tool={!s}, FMI version={!s}, FMI API={!s}, exc={!s}'.format(
                                    tool, version, api, exc))

                            start = datetime.now()
                            self.helper_export(Simulator_Test)
                            end = datetime.now()
                            print(
                                'Export the simulator as an FMU in {!s} seconds.'.format(
                                    (end - start).total_seconds()))

                            fmu_path = os.path.join(
                            script_path, '..', 'fmus', tool, platform.system().lower())
                            print(
                                'Copy simulator.fmu to {!s}.'.format(fmu_path))
                            shutil.copy2('simulator.fmu', fmu_path)

                            fmu_path = os.path.join(
                                    script_path, '..', 'fmus', tool, platform.system().lower(), 'simulator.fmu')
                            # Parameters which will be arguments of the function
                            start_time = 0.0
                            stop_time = 5.0

                            print ('Starting the simulation with {!s}'.format(tool))
                            start = datetime.now()

                            simulator_input_valref = []
                            simulator_output_valref = []

                            sim_mod = load_fmu(fmu_path, log_level=7)
                            sim_mod.setup_experiment(
                                start_time=start_time, stop_time=stop_time)

                            # Define the inputs
                            simulator_input_names = ['v']
                            simulator_input_values = [220.0]
                            simulator_output_names = ['i']

                            # Get the value references of simulator inputs
                            for elem in simulator_input_names:
                                simulator_input_valref.append(
                                    sim_mod.get_variable_valueref(elem))

                            # Get the value references of simulator outputs
                            for elem in simulator_output_names:
                                simulator_output_valref.append(
                                    sim_mod.get_variable_valueref(elem))

                            # Set the flag to save the results
                            sim_mod.set('_saveToFile', 'false')

                            # Initialize the FMUs
                            sim_mod.initialize()

                            # Call event update prior to entering continuous mode.
                            sim_mod.event_update()

                            # Enter continuous time mode
                            sim_mod.enter_continuous_time_mode()

                            sim_mod.set_real(simulator_input_valref, simulator_input_values)

                            end = datetime.now()

                            print(
                                'Ran a single Simulator simulation with {!s} FMU={!s} in {!s} seconds.'.format(
                                    tool, fmu_path, (end - start).total_seconds()))
                            if not (tool=='openmodelica'):
                                # PyFMI fails to get the output of an OpenModelica FMU
                                self.assertEqual(
                                    sim_mod.get_real(
                                        sim_mod.get_variable_valueref('i')),
                                    1.0,
                                    'Values are not matching.')
                            sim_mod.terminate()
            if(tool=='openmodelica'):
                del os.environ['PATH']
                # Reset environment variable
                os.environ['PATH']=orig_path
示例#6
0
server_scripts_path = [SERVER_SCRIPT_PATH]

if(platform.system().lower() == 'windows'):
    python_scripts_path = [item.replace('\\', '\\\\') for item in [
        PYTHON_SCRIPT_PATH]]
    server_scripts_path = [item.replace('\\', '\\\\') for item in [
        SERVER_SCRIPT_PATH]]

Simulator_T = simulator.SimulatorToFMU('',
                                       XML_INPUT_FILE,
                                       SimulatorToFMU_LIB_PATH,
                                       MO_TEMPLATE_PATH,
                                       MOS_TEMPLATE_PATH_DYMOLA,
                                       XSD_FILE_PATH,
                                       '27',
                                       python_scripts_path,
                                       '2.0',
                                       'me',
                                       'dymola',
                                       None,
                                       None,
                                       'true',
                                       'true',
                                       'python')





class Tester(unittest.TestCase):
    '''
    Class that runs all regression tests.
示例#7
0
    def run_simulator (self, tool):
        
        '''
        Function for running FMUs exported from Dymola, JModelica, and OpenModelica with PyFMI.

        '''
        
        try:
            from pyfmi import load_fmu
        except BaseException:
            print ('PyFMI not installed. Test will not be be run.')
            return
        if (tool=='openmodelica' and platform.system().lower() == 'linux'):
                print ('tool={!s} is not supported on Linux'.format(tool))
                return
            
        else:
        # Export FMUs which are needed to run the cases.
            if tool == 'openmodelica':
                modPat = 'OPENMODELICALIBRARY'
                mosT = MOS_TEMPLATE_PATH_OPENMODELICA
            elif tool == 'dymola':
                modPat = 'MODELICAPATH'
                mosT = MOS_TEMPLATE_PATH_DYMOLA
            elif tool == 'jmodelica':
                # Unset environment variable
                if (os.environ.get('MODELICAPATH') is not None):
                    del os.environ['MODELICAPATH']
                modPat = None
                mosT = MOS_TEMPLATE_PATH_JMODELICA
            for version in ['2']:
                if (tool == 'openmodelica' or tool == 'jmodelica'):
                    version = str(float(version))
                for api in ['me']:
                    if (tool == 'openmodelica' and version == '1.0' and api == 'cs'):
                        print (
                            'tool={!s} with FMI version={!s} and FMI API={!s} is not supported.'.format(
                                tool, version, api))
                        continue
                    for cs_xml in ['true']:
                        if (version == '1'):
                            continue
                        Simulator_Test = simulator.SimulatorToFMU(
                            '',
                            XML_INPUT_FILE,
                            SimulatorToFMU_LIB_PATH,
                            MO_TEMPLATE_PATH,
                            mosT,
                            XSD_FILE_PATH,
                            '27',
                            python_scripts_path,
                            version,
                            api,
                            tool,
                            None,
                            modPat,
                            cs_xml,
                            'true',
                            None)

                        print (
                            'Export the simulator with tool={!s}, FMI version={!s}, FMI API={!s}'.format(
                                tool, version, api))
                        start = datetime.now()
                        Simulator_Test.print_mo()
                        Simulator_Test.generate_fmu()
                        Simulator_Test.clean_temporary()
                        Simulator_Test.rewrite_fmu()
                        end = datetime.now()
                        print(
                            'Export the simulator as an FMU in {!s} seconds.'.format(
                                (end - start).total_seconds()))
                        
                        fmu_path = os.path.join(
                        script_path, '..', 'fmus', tool, platform.system().lower())
                        print(
                            'Copy simulator.fmu to {!s}.'.format(fmu_path))
                        shutil.copy2('simulator.fmu', fmu_path)
    
        fmu_path = os.path.join(
                script_path, '..', 'fmus', tool, platform.system().lower(), 'simulator.fmu')
        # Parameters which will be arguments of the function
        start_time = 0.0
        stop_time = 5.0

        print ('Starting the simulation with {!s}'.format(tool))
        start = datetime.now()

        simulator_input_valref = []
        simulator_output_valref = []

        sim_mod = load_fmu(fmu_path, log_level=7)
        sim_mod.setup_experiment(
            start_time=start_time, stop_time=stop_time)

        # Define the inputs
        simulator_input_names = ['v']
        simulator_input_values = [220.0]
        simulator_output_names = ['i']

        # Get the value references of simulator inputs
        for elem in simulator_input_names:
            simulator_input_valref.append(
                sim_mod.get_variable_valueref(elem))

        # Get the value references of simulator outputs
        for elem in simulator_output_names:
            simulator_output_valref.append(
                sim_mod.get_variable_valueref(elem))

        # Set the flag to save the results
        sim_mod.set('_saveToFile', 'false')

        # Initialize the FMUs
        sim_mod.initialize()

        # Call event update prior to entering continuous mode.
        sim_mod.event_update()

        # Enter continuous time mode
        sim_mod.enter_continuous_time_mode()

        sim_mod.set_real(simulator_input_valref, simulator_input_values)
        
        end = datetime.now()

        print(
            'Ran a single Simulator simulation with {!s} FMU={!s} in {!s} seconds.'.format(
                tool, fmu_path, (end - start).total_seconds()))
        if not (tool=='openmodelica'):
            # PyFMI fails to get the output of an OpenModelica FMU 
            self.assertEqual(
                sim_mod.get_real(
                    sim_mod.get_variable_valueref('i')),
                1.0,
                'Values are not matching.')
            
        # Terminate FMUs
        sim_mod.terminate()