Beispiel #1
0
    def check_equal_regime(cls, rgm1, rgm2):

        assert_equal(rgm1.name, rgm2.name)

        # Check the OnEvents:
        on_event1dict = safe_dict([(ev.src_port_name, ev)
                                   for ev in rgm1.on_events])
        on_event2dict = safe_dict([(ev.src_port_name, ev)
                                   for ev in rgm2.on_events])
        assert_equal_list(on_event1dict.keys(), on_event2dict.keys())
        for eventport in on_event1dict.keys():
            ev1 = on_event1dict[eventport]
            ev2 = on_event2dict[eventport]
            cls.check_equal_transitions(ev1, ev2)

        # Check the OnEvents:
        # [We use safe_dict, to ensure that we don't have any duplicate
        # condition.rhs ]
        on_condition1dict = safe_dict([(cond.trigger.rhs, cond)
                                       for cond in rgm1.on_conditions])
        on_condition2dict = safe_dict([(cond.trigger.rhs, cond)
                                       for cond in rgm2.on_conditions])
        assert_equal_list(on_condition1dict.keys(), on_condition2dict.keys())
        for condition_trigger_rhs in on_condition1dict.keys():
            on_cond1 = on_condition1dict[condition_trigger_rhs]
            on_cond2 = on_condition2dict[condition_trigger_rhs]
            cls.check_equal_transitions(on_cond1, on_cond2)

        # Check the TimeDerivatives:
        time_deriv1s = [(td.dependent_variable, td.rhs)
                        for td in rgm1.time_derivatives]
        time_deriv2s = [(td.dependent_variable, td.rhs)
                        for td in rgm2.time_derivatives]
        assert_equal_list(time_deriv1s, time_deriv2s)
Beispiel #2
0
    def test_safe_dict(self):
        # Signature: name(vals)
                # Create a dict, like dict(), but ensure no duplicate keys are given!
                # [Python silently allows dict( [(1:True),(1:None)] ) !!


        self.assertEqual(
            safe_dict([[1, 'One'], [2, 'Two']]),
            {1: 'One', 2: 'Two'}
        )
        self.assertEqual(
            safe_dict([[1, 'One'], [2, 'Two'], [3, 'Three'], [4, 'Four']]),
            {1: 'One', 2: 'Two', 3: 'Three', 4: 'Four'}
        )

        self.assertRaises(
            NineMLRuntimeError,
            safe_dict,
            [[1, 'One'], [2, 'Two'], [3, 'Three'], [1, 'One'], [4, 'Four']]
        )
Beispiel #3
0
    def check_equal_component(cls, comp1, comp2, strict_aliases):

        # Check the component names are equal:
        assert_equal(comp1.name, comp2.name, 'Component Names')

        # CHECK THE INTERFACE:
        # -------------------#
        # Parameters:
        p1Names = sorted([p.name for p in comp1.parameters])
        p2Names = sorted([p.name for p in comp2.parameters])
        assert_equal_list(p1Names, p2Names)

        # Analog Ports: Check Modes & reduce ops:
        ap1Dict = safe_dict([(ap.name, ap) for ap in comp1.analog_ports])
        ap2Dict = safe_dict([(ap.name, ap) for ap in comp2.analog_ports])
        assert_equal_list(ap1Dict.keys(), ap2Dict.keys())
        for portname in ap1Dict.keys():
            assert_equal(ap1Dict[portname].mode, ap2Dict[portname].mode)
            assert_equal(ap1Dict[portname].reduce_op,
                         ap2Dict[portname].reduce_op)

        # Event Ports: Check Modes & reduce ops:
        ev1Dict = safe_dict([(ev.name, ev) for ev in comp1.event_ports])
        ev2Dict = safe_dict([(ev.name, ev) for ev in comp2.event_ports])
        assert_equal_list(ev1Dict.keys(), ev2Dict.keys())
        for portname in ev1Dict.keys():
            assert_equal(ev1Dict[portname].mode, ev2Dict[portname].mode)
            assert_equal(ev1Dict[portname].reduce_op,
                         ev2Dict[portname].reduce_op)

        # CHECK THE SUBNAMESPACES AND PORT CONNECTIONS
        # ------------------------------------------- #
        # Recurse over subnamespaces:
        assert_equal_list(comp1.subnodes.keys(), comp2.subnodes.keys())
        for subnamespace in comp1.subnodes.keys():
            subcomp1 = comp1.subnodes[subnamespace]
            subcomp2 = comp2.subnodes[subnamespace]
            check_equal_component(subcomp1, subcomp2)

        # Port Connections:
        # Tuples are comparable, so lets make 2 lists of tuples and compare
        # them:
        pc1 = [(src.loctuple, sink.loctuple)
               for (src, sink) in comp1.portconnections]
        pc2 = [(src.loctuple, sink.loctuple)
               for (src, sink) in comp2.portconnections]
        assert_equal_list(pc1, pc2)

        # CHECK THE DYNAMICS
        # ------------------- #
        d1 = comp1.dynamics
        d2 = comp2.dynamics

        # Check Aliases:
        assert strict_aliases
        a1 = [(a.lhs, a.rhs) for a in d1.aliases]
        a2 = [(a.lhs, a.rhs) for a in d2.aliases]
        assert_equal_list(a1, a2)

        # State Variables:
        sv1Names = sorted([sv.name for sv in d1.state_variables])
        sv2Names = sorted([sv.name for sv in d2.state_variables])
        assert_equal_list(sv1Names, sv2Names)

        # Check Regimes:

        rgm1Dict = d1.regimes_map
        rgm2Dict = d2.regimes_map
        assert_equal_list(rgm1Dict.keys(), rgm2Dict.keys())
        for regime_name in rgm1Dict.keys():
            rgm1 = rgm1Dict[regime_name]
            rgm2 = rgm2Dict[regime_name]
            cls.check_equal_regime(rgm1, rgm2)