Пример #1
0
    def get_constrains(self, fopt: List[float]) -> List[float]:
        """
        to get all constrains as a List[float]
        :param fopt: variable to optimize
        :return: all constrains as a List[float]
        """

        f = self.fopt_to_f(fopt)

        z, v, loaded_section_route = Assignment.get_alighting_and_boarding(self.Vij, self.hyperpaths, self.successors,
                                                                           self.assignment, f)

        most_loaded_section = Assignment.most_loaded_section(loaded_section_route)
        constrain_obj = Constrains()
        ineq_k = constrain_obj.most_loaded_section_constrains(self.network_obj.get_routes(), most_loaded_section)
        ineq_f = constrain_obj.fmax_constrains(self.graph_obj, self.network_obj.get_routes(),
                                               self.network_obj.get_modes(), f)

        con = []
        for c in ineq_k:
            con.append(c)
        for c in ineq_f:
            con.append(c)

        return con
Пример #2
0
 def get_k(loaded_section_route: defaultdict3_float) -> defaultdict_float:
     """
     :param loaded_section_route: dic[route_id][direction][stop: StopNode] = pax [pax/veh]
     :return: k: dic[route_id] = vehicle capacity [pax/veh]
     """
     most_loaded_section = Assignment.most_loaded_section(loaded_section_route)
     k = defaultdict(float)
     for route_id in most_loaded_section:
         k[route_id] = most_loaded_section[route_id]
     return k
Пример #3
0
    def constrains(self, loaded_section_route: defaultdict3_float, f: defaultdict_float) -> (
            List[float], List[float]):
        """
        to get k constrains and f constrains
        :param loaded_section_route: dic[route_id][direction][stop: StopNode] = pax [pax/veh]
        :param f: dict with frequency [veh/hr] for each route_id
        :return: (k_ineq_constrains, f_ineq_constrains)
        """

        most_loaded_section = Assignment.most_loaded_section(loaded_section_route)

        constrains_obj = Constrains()

        ineq_k = constrains_obj.most_loaded_section_constrains(self.network_obj.get_routes(), most_loaded_section)
        ineq_f = constrains_obj.fmax_constrains(self.graph_obj, self.network_obj.get_routes(),
                                                self.network_obj.get_modes(), f)

        return ineq_k, ineq_f
Пример #4
0
    def test_most_loaded_section(self):
        """
        to test most_loaded_section class assignment
        :return:
        """

        f = defaultdict(float)
        for route in self.network_obj.get_routes():
            f[route.id] = 28

        z, v, loaded_section_route = Assignment.get_alighting_and_boarding(Vij=self.Vij, hyperpaths=self.hyperpaths,
                                                                           successors=self.successors,
                                                                           assignment=self.OD_assignment, f=f)

        loaded_section = Assignment.most_loaded_section(loaded_section_route)

        self.assertEqual(len(loaded_section), 4)
        self.assertEqual(loaded_section['F_metro_1'], loaded_section['F_metro_2'])
        self.assertEqual(loaded_section['F_metro_1'], 0.044997165532879815)
        self.assertEqual(loaded_section['R_bus_1'], loaded_section['R_bus_2'])
        self.assertEqual(loaded_section['R_bus_1'], 1.4880952380952384)