Exemplo n.º 1
0
    def createIncidentToIncidentMatrices(self):
        distances = {}
        incidentMap = self.simulation.getActiveIncidents(self.agent)
        router = Routing()

        for incidentType, incidents in incidentMap.iteritems():
            distances[incidentType] = {}
            for incidentId, pos in incidents.iteritems():
                for incident2Id, pos2 in incidents.iteritems():
                    if incidentId != incident2Id:
                        if incidentId not in distances[incidentType]:
                            distances[incidentType][incidentId] = {}
                        if incident2Id in distances[
                                incidentType] and incidentId in distances[
                                    incidentType][incident2Id]:
                            distances[incidentType][incidentId][
                                incident2Id] = distances[incidentType][
                                    incident2Id][incidentId]
                        else:
                            distance = len(
                                router.route(pos.lat, pos.lon, pos2.lat,
                                             pos2.lon)['timecoords'])
                            distances[incidentType][incidentId][
                                incident2Id] = distance
                            distances[incidentType][incidentId][
                                incident2Id] = distance

        return distances
Exemplo n.º 2
0
    def test_routing(self):
        self.test_field_finalization()

        r = Routing(self.field)
        ret = r.route(4)

        self.assertGreaterEqual(ret[0], 1)
Exemplo n.º 3
0
    def test_routing(self):
        self.test_field_finalization()

        r = Routing(self.field)
        ret = r.route(4)

        self.assertGreaterEqual(ret[0], 1)
Exemplo n.º 4
0
    def _full_simple(self, fn, nocheck=False):
        field = self.construct_field()
        blocks = self.parse_blocks(os.path.join(self.test_data_dir, fn))
        f = self.construct_force_algo_obj(self.field, self.blocks, self.pins)
        cid = fn.split("op")[1].split(".")[0]

        f.step_build(DEBUG)
        f1 = f.get_debug_field()
        if DEBUG:
            fn = draw_field(f1, "schematic_build_{}.pdf".format(cid))

        f.step_initial(DEBUG)
        f2 = f.get_debug_field()
        if DEBUG:
            fn = draw_field(f2, "schematic_init_{}.pdf".format(cid))

        f.step_main(DEBUG)
        f3 = f.get_debug_field()
        if DEBUG:
            fn = draw_field(f3, "schematic_main_{}.pdf".format(cid))

        f.step_last(DEBUG)
        f4 = f.get_debug_field()
        if DEBUG:
            f4.trim_size()
            fn = draw_field(f4, "schematic_final_{}.pdf".format(cid))

        # CHECK IF OVERLAPPING BLOCKS WERE FOUND
        overlap = f4.has_overlapping_blocks()
        if overlap:
            f4.show_blocks(sortkey=("groups", "pos"))
            f4.trim_size()
            draw_field(f4, "schematic_final_{}.pdf".format(cid))
        else:
            try:
                f = f4.to_field()
                f.optimize_size()
                f.optimize_block_dirs()
                r = Routing(f)
                ret = r.route(4)
                fn = draw_field(f, "schematic_real_{}.pdf".format(cid))
            except RoutingException as e:
                if not nocheck:
                    print "failed with circuit {}".format(cid)
                    print "continuing due to 'nocheck' == True"
                else:
                    raise e


        if not nocheck:
            self.assertFalse(overlap, "Found overlapping blocks!")
Exemplo n.º 5
0
    def _full_simple(self, fn, nocheck=False):
        field = self.construct_field()
        blocks = self.parse_blocks(os.path.join(self.test_data_dir, fn))
        f = self.construct_force_algo_obj(self.field, self.blocks, self.pins)
        cid = fn.split("op")[1].split(".")[0]

        f.step_build(DEBUG)
        f1 = f.get_debug_field()
        if DEBUG:
            fn = draw_field(f1, "schematic_build_{}.pdf".format(cid))

        f.step_initial(DEBUG)
        f2 = f.get_debug_field()
        if DEBUG:
            fn = draw_field(f2, "schematic_init_{}.pdf".format(cid))

        f.step_main(DEBUG)
        f3 = f.get_debug_field()
        if DEBUG:
            fn = draw_field(f3, "schematic_main_{}.pdf".format(cid))

        f.step_last(DEBUG)
        f4 = f.get_debug_field()
        if DEBUG:
            f4.trim_size()
            fn = draw_field(f4, "schematic_final_{}.pdf".format(cid))

        # CHECK IF OVERLAPPING BLOCKS WERE FOUND
        overlap = f4.has_overlapping_blocks()
        if overlap:
            f4.show_blocks(sortkey=("groups", "pos"))
            f4.trim_size()
            draw_field(f4, "schematic_final_{}.pdf".format(cid))
        else:
            try:
                f = f4.to_field()
                f.optimize_size()
                f.optimize_block_dirs()
                r = Routing(f)
                ret = r.route(4)
                fn = draw_field(f, "schematic_real_{}.pdf".format(cid))
            except RoutingException as e:
                if not nocheck:
                    print "failed with circuit {}".format(cid)
                    print "continuing due to 'nocheck' == True"
                else:
                    raise e

        if not nocheck:
            self.assertFalse(overlap, "Found overlapping blocks!")
    def test_full(self):

        ###
        # slice the self.files list to reduce test time!!!
        ###
        for fn in self.files[:7]:
            print "-> full run - fn: {}".format(fn)
            field = self.construct_field()
            blocks = self.parse_blocks(os.path.join(self.test_data_dir, fn))
            f = self.construct_force_algo_obj(self.field, self.blocks, self.pins)
            cid = fn.split("op")[1].split(".")[0]


            f.step_build(DEBUG)
            f1 = f.get_debug_field()
            fn = draw_field(f1, "schematic_build_{}.pdf".format(cid))

            f.step_initial(DEBUG)
            f2 = f.get_debug_field()
            fn = draw_field(f2, "schematic_init_{}.pdf".format(cid))

            f.step_main(DEBUG)
            f3 = f.get_debug_field()
            fn = draw_field(f3, "schematic_main_{}.pdf".format(cid))

            f.step_last(DEBUG)
            f4 = f.get_debug_field()
            fn = draw_field(f4, "schematic_final_{}.pdf".format(cid))

            # CHECK IF OVERLAPPING BLOCKS WERE FOUND
            overlap = f4.has_overlapping_blocks()
            if overlap:
                print "-"*80
                print "#### FAILED ..... FAILED ..... circ_id: {}".format(cid)
                #f4.show_blocks(sortkey="pos")
                #f4.show_blocks(sortkey="name")
                f4.show_blocks(sortkey=("groups", "pos"))
            else:
                print "-"*80
                print "#### {} ####".format(cid)
                f = f4.to_field()
                f.optimize_size()
                f.optimize_block_dirs()
                #f.expand_field(4)
                r = Routing(f)
                ret = r.route(4)
                fn = draw_field(f, "schematic_real_{}.pdf".format(cid))
Exemplo n.º 7
0
    def createResponderToIncidentMatrices(self):
        responders = self.simulation.getResponders(self.agent)
        incidents = self.simulation.getActiveIncidents(self.agent)

        distances = {}
        router = Routing()

        for t, respondersByType in responders.iteritems():
            distances[t] = {}
            for responderId, data in respondersByType.iteritems():
                lat, lon = data["route"][0]
                distances[t][responderId] = {}
                incidentType = "fire" if t == "fireFighters" else "injury" if t == "ambulances" else "looters"
                for incident, incidentPos in incidents[incidentType].iteritems(
                ):
                    distance = len(
                        router.route(lat, lon, incidentPos.lat,
                                     incidentPos.lon)['timecoords'])
                    distances[t][responderId][incident] = distance
        return distances