def __init__(self): # Dictionary containing a street object for each street name (key) self.streets = dict() self.corresponding_intersections = dict() self.adjacent_street_names = dict() street_config_root = XmlParser.parse("streetconfig.xml").getroot() xml_street_list = street_config_root[0] for xml_street in xml_street_list: street = Street() street.street_name = xml_street.attrib['name'] street.traffic_light_number = int( xml_street.attrib['trafficLightNumber']) for xml_street_child in xml_street.iter('RoadComponent'): start_point = MapPoint(int(xml_street_child[0].attrib['x']), int(xml_street_child[0].attrib['y'])) end_point = MapPoint(int(xml_street_child[1].attrib['x']), int(xml_street_child[1].attrib['y'])) road_component = RoadComponent( heading=MapHeading[xml_street_child.attrib['heading']], start=start_point, end=end_point) street.road_component_list.append(road_component) # Insert adjacent streets self.adjacent_street_names[street.street_name] = list() for xml_adjacent_street in xml_street.iter('AdjacentStreet'): self.adjacent_street_names[street.street_name].append( xml_adjacent_street.attrib['streetName']) # Append street to dictionary self.streets[street.street_name] = street self.build_intersections()
def test_f(self): ''' ''' cases = {} # Each case: t, N, Dmax, Smax, c_h, adaptive, slope, placement_optimistic, bcharge, pt = result # Case 1a: consumer first, thus generator last, who creates negative 1 # consumer always adds 2.75 cases[(26, 10, 3, 1, 1.2, True, .5, True, 0, .5)] = (round(5 * 2.787 + 5 * -1, 4), -1) # Case 1b: Now price is adapted, so they buy 2.887 cases[(26, 10, 3, 1, 1.2, True, .5, True, 0, .3)] = (round(5 * 2.887 + 5 * -1, 4), -1) # Case 1c: Now try pessimistic cases[(26, 10, 3, 1, 1.2, True, .5, False, 0, .3)] = (round(5 * 2.887 + 5 * -1, 4), -5) # Case 2: try higher N cases[(26, 30, 3, 1, 1.2, True, .5, True, 0, .3)] = (round(15 * 2.887 + 15 * -1, 4), -1) # Case 3: test non-adaptive case. They buy 2.924 cases[(26, 10, 3, 1, 1.2, False, .5, True, 0, .3)] = (round(5 * 2.924 + 5 * -1, 4), -1) # Case 4: different time step: let house batteries charge, no PV cases[(38, 10, 3, 1, 1.2, True, .5, True, 0, .3)] = (round(5 * 3.887, 4), 0) # Case 5a: our battery charges 0.6 cases[(26, 10, 3, 1, 1.2, True, .5, True, 0.6, .3)] = \ (round(.6 + (5 * 2.887 + 5 * -1), 4), -1 + 0.6) # Case 5b: and discharge cases[(26, 10, 3, 1, 1.2, True, .5, True, -0.6, .3)] = \ (round(-.6 + (5 * 2.887 + 5 * -1), 4), -1 - 0.6) for c in cases.keys(): T = c[0] s = Street(T=T+1, N=c[1], C=None, Dmax=c[2], Smax=c[3], pmax=.452, pmin=.074, c_h=c[4], adaptive=c[5], slope=c[6], placement_optimistic=c[7]) #s.draw(T, c[8], c[9]) fp, fm = s.f(T, c[8], c[9]) self.assertEqual((round(fp, 4), round(fm, 4)), cases[c])
def add_street(street_name, nodes): """ add street to database and process :param street_name: str :param nodes: [Point] """ streets.append(Street(street_name, nodes))
def parsing (self,value): if 'vertices' in value: for i in value['vertices']: tmpVertex = Vertex() tmpVertex.parsing(i) self.verticesList.append(tmpVertex) if 'streets' in value: for i in value['streets']: tmpStreet = Street() tmpStreet.parsing(i) self.streetsList.append(tmpStreet) if 'bridges' in value: for i in value['bridges']: tmpBridge = Bridge() tmpBridge.parsing(i) self.bridgesList.append(tmpBridge) if 'weight' in value: self.weight.parsing(value['weight'])
def parsing(self, value): if 'vertices' in value: for i in value['vertices']: tmpVertex = Vertex() tmpVertex.parsing(i) self.verticesList.append(tmpVertex) if 'streets' in value: for i in value['streets']: tmpStreet = Street() tmpStreet.parsing(i) self.streetsList.append(tmpStreet) if 'bridges' in value: for i in value['bridges']: tmpBridge = Bridge() tmpBridge.parsing(i) self.bridgesList.append(tmpBridge) if 'weight' in value: self.weight.parsing(value['weight'])
def base_add_street(street_name, coordinates): # create the street new_street = Street(street_name, coordinates) # check for any intersections with the existing streets for street in streets.values(): intersections = street.find_intersections(new_street) # add the intersections to the graph for intersection in intersections: graph.add_vertex(intersection) # add the street to the database (dictionary) streets[street_name] = new_street
def new_street(self, from_: str, to: str, distance: float, max_speed: Optional[float] = None) -> None: """Cria um novo trecho de rua (:class:`Street`) de um nó para outro :param from\_: nó inicial :param to: nó objetivo :param distance: distância do trecho :param max_speed: velocidade máxima do trecho, se for diferente da velocidade máxima geral """ speed = max_speed or self._max_speed self.make_edge(from_, to, Street(distance, speed))
def __init__(self, *args, **kwargs): super(ApartmentBlock, self).__init__(width=ApartmentBlock.WIDTH, *args, **kwargs) builds = [] ####################################################################### # build entire apt block from spans: # "concrete" structure (smooth stone) builds.append( BuildingBlock(ApartmentBlock.APT_BLOCK_SPAN[0], block.STONE, ApartmentBlock.APT_BLOCK_SPAN[1], description="Apt block stone super structure")) # 17 apt wall sections per floor can be done using 5 wood spans & 6 interior spaces # build wood plank spans for key, span in ApartmentBlock.WOOD_PLANK_SPANS.items(): for pos in ApartmentBlock.WOOD_PLANK_POS[key]: # ground floor builds.append( BuildingBlock(span[0] + pos, block.WOOD_PLANKS, span[1] + pos, description="%s wood span ground floor" % (key))) # 2nd floor builds.append( BuildingBlock(span[0] + pos + Vec3(0, 4, 0), block.WOOD_PLANKS, span[1] + pos + Vec3(0, 4, 0), description="%s wood span 2nd floor" % (key))) # clear apt interiors (this will leave concrete floors & ceilings) for pos in ApartmentBlock.APT_INTERIOR_POS: # ground floor builds.append( BuildingBlock(ApartmentBlock.APT_INTERIOR_SPAN[0] + pos, block.AIR, ApartmentBlock.APT_INTERIOR_SPAN[1] + pos, description="Clear apt interior ground floor")) # 2nd floor builds.append( BuildingBlock( ApartmentBlock.APT_INTERIOR_SPAN[0] + pos + Vec3(0, 4, 0), block.AIR, ApartmentBlock.APT_INTERIOR_SPAN[1] + pos + Vec3(0, 4, 0), description="Clear apt interior 2nd floor")) # add torch to SW croner of block to indicte when this section has completed buiding in game #builds.append(Torch(Vec3(-11,3,-3), block.TORCH.withData(Torch.WEST), # description="section complete indicator")) self._add_section("Apt block super structure", builds) # doors & torches # TODO: debug this: East side apartments have doors "facing" east (built on east side of block) # East side apts torches should face west, but applied on east face of containing block (west face of support block) # TODO: add doc strings to doors and torches on what the orientation means for pos in ApartmentBlock.APT_DOORS_POS["East"]: # ground floor builds.append( Door(Door.HINGE_RIGHT, pos, block.DOOR_WOOD.withData(Door.EAST), description="Ground floor door east side")) builds.append( Torch(pos + Vec3(-1, 2, 0), block.TORCH.withData(Torch.WEST), description="Ground floor interior torch")) builds.append( Torch(pos + Vec3(1, 2, 0), block.TORCH.withData(Torch.EAST), description="Ground floor exterior torch")) # 2nd floor builds.append( Door(Door.HINGE_RIGHT, pos + Vec3(0, 4, 0), block.DOOR_WOOD.withData(Door.EAST), description="2nd floor door east side")) builds.append( Torch(pos + Vec3(-1, 6, 0), block.TORCH.withData(Torch.WEST), description="2nd floor interior torch")) builds.append( Torch(pos + Vec3(1, 6, 0), block.TORCH.withData(Torch.EAST), description="2nd floor exterior torch")) for pos in ApartmentBlock.APT_DOORS_POS["West"]: # ground floor builds.append( Door(Door.HINGE_LEFT, pos, block.DOOR_WOOD.withData(Door.WEST), description="Ground floor door west side")) builds.append( Torch(pos + Vec3(1, 2, 0), block.TORCH.withData(Torch.EAST), description="Ground floor interior torch")) builds.append( Torch(pos + Vec3(-1, 2, 0), block.TORCH.withData(Torch.WEST), description="Ground floor exterior torch")) # 2nd floor builds.append( Door(Door.HINGE_LEFT, pos + Vec3(0, 4, 0), block.DOOR_WOOD.withData(Door.WEST), description="2nd floor door west side")) builds.append( Torch(pos + Vec3(1, 6, 0), block.TORCH.withData(Torch.EAST), description="2nd floor interior torch")) builds.append( Torch(pos + Vec3(-1, 6, 0), block.TORCH.withData(Torch.WEST), description="2nd floor exterior torch")) # windows for pos in ApartmentBlock.APT_WINS_POS: builds.append( BuildingBlock(pos, block.GLASS_PANE, description="ground floor window")) builds.append( BuildingBlock(pos + Vec3(0, 4, 0), block.GLASS_PANE, description="2nd floor window")) # add torch to SW croner of block to indicte when this section has completed buiding in game #builds.append(Torch(Vec3(-11,2,-3), block.TORCH.withData(Torch.WEST), # description="section complete indicator")) self._add_section("Apt block fittings", builds) ####################################################################### # Ground floor walkway & steps # stone walk way builds.extend(self._add_walkway(block.STONE, 0)) # stone steps at end of each walkway # TODO: block data for stone brick stairs builds.append( Stair(ApartmentBlock.CORNER_POS['South East'] + Vec3(0, 0, 1), Block(109).withData(Stair.NORTH), ApartmentBlock.CORNER_POS['South East'] + Vec3(-1, 0, 1), description="Ground floor steps")) builds.append( Stair(ApartmentBlock.CORNER_POS['South West'] + Vec3(1, 0, 1), Block(109).withData(Stair.NORTH), ApartmentBlock.CORNER_POS['South West'] + Vec3(0, 0, 1), description="Ground floor steps")) self._add_section("Ground floor walkway", builds) ####################################################################### # Support posts for 2nd floor walkway for pos in ApartmentBlock.CORNER_POS.values(): builds.append( BuildingBlock(pos + Vec3(0, 1, 0), block.FENCE, pos + Vec3(0, 3, 0), description="Corner post")) self._add_section("2nd floor support posts", builds) ####################################################################### # 2nd floor walkway # wooden walk way around 2nd floor builds.extend(self._add_walkway(block.WOOD_PLANKS, 4)) self._add_section("2nd floor wooden walkway", builds) ####################################################################### # Stairs to 2nd floor for i in range(0, 5): # wooden steps to 2nd floor. builds.append( Stair(ApartmentBlock.CORNER_POS['South East'] + Vec3(-8 + i, i, 1), block.STAIRS_WOOD.withData(Stair.EAST), description="Steps to upper floor")) # TODO: figure out block data for upside down stairs and use this instead of support block builds.append( BuildingBlock(ApartmentBlock.CORNER_POS['South East'] + Vec3(-7 + i, i, 1), block.WOOD_PLANKS, description="stair support")) self._add_section("Stairs to 2nd floor", builds) ####################################################################### if DO_2ND_FLOOR_RAILINGS: # 2nd floor walkway railings (should extend these out by 1 block all around so walkway is 2 blocks wide) # west side railings builds.append( BuildingBlock( ApartmentBlock.CORNER_POS['North West'] + Vec3(0, 5, 0), block.FENCE, ApartmentBlock.CORNER_POS['South West'] + Vec3(0, 5, 0), description="Balcony railings")) # close off west side railings on north end builds.append( BuildingBlock(ApartmentBlock.CORNER_POS['North West'] + Vec3(1, 5, 0), block.FENCE, description="Balcony railings")) # east side railings builds.append( BuildingBlock( ApartmentBlock.CORNER_POS['North East'] + Vec3(0, 5, 0), block.FENCE, ApartmentBlock.CORNER_POS['South East'] + Vec3(0, 5, 0), description="Balcony railings")) # close off east side railings on north end builds.append( BuildingBlock(ApartmentBlock.CORNER_POS['North East'] + Vec3(-1, 5, 0), block.FENCE, description="Balcony railings")) # south balcony railings builds.append( BuildingBlock( ApartmentBlock.CORNER_POS['South East'] + Vec3(0, 5, 0), block.FENCE, ApartmentBlock.CORNER_POS['South East'] + Vec3(-5, 5, 0), description="Balcony railings")) builds.append( BuildingBlock( ApartmentBlock.CORNER_POS['South West'] + Vec3(0, 5, 0), block.FENCE, ApartmentBlock.CORNER_POS['South West'] + Vec3(6, 5, 0), description="Balcony railings")) self._add_section("2nd floor railings", builds) ####################################################################### # Add the streets between as subbuildings street_ew = Street(9, Building.WEST) street_ns = Street(8, Building.NORTH) builds.append( SubBuilding(street_ew, Building.SE_CORNER_POS + Vec3(0, 0, 1))) builds.append( SubBuilding(street_ew, Building.SE_CORNER_POS + Vec3(0, 0, -24))) builds.append( SubBuilding(street_ns, Building.SE_CORNER_POS + Vec3(-13, 0, 0))) self._add_section("Streets", builds) ####################################################################### # Add the farm subbuildings farms = [Farm(Building.WEST), LargeFarm(Building.NORTH)] for pos in ApartmentBlock.WEST_FARMS_POS: builds.append(SubBuilding(farms[0], pos)) self._add_section("West Farms", builds) for pos in ApartmentBlock.NORTH_FARMS_POS: builds.append(SubBuilding(farms[1], pos)) self._add_section("North Double Farms", builds) ####################################################################### self._set_orientation()
def main(conf, log, seed): ws = [.05, .2, .5, 1, 2] battery_types = (NoBattery, OfflineBattery, BaseBattery, HeuristicBattery, NonDeterministicOfflineBattery) #battery_types = (NoBattery, BaseBattery, HeuristicBattery,) T = 48 # this is given by the price data structure: half-hour intervals N = conf.getint('params', 'N') C = conf.getint('params', 'C') B = conf.getfloat('params', 'B') alpha = conf.getfloat('params', 'alpha') max_rate = conf.getfloat('params', 'max_rate') econ_slope = conf.getfloat('params', 'econ_slope') Dmax = conf.getfloat('params', 'Dmax') Smax = conf.getfloat('params', 'Smax') pmax = conf.getfloat('params', 'pmax') pmin = conf.getfloat('params', 'pmin') c_h = conf.getfloat('params', 'c_h') adaptive = conf.getboolean('params', 'adaptive') placement_optimistic = conf.getboolean('params', 'placement_optimistic') LP_max_runtime = conf.getint('params', 'LP_max_runtime') # in minutes LP_max_k = conf.getint('params', 'LP_max_k') # max. assumed k debug = conf.getboolean('params', 'debug') # get price series for us to use in this run pfile = open('price_data/APXReferencePriceDataUkPowerMarket2012_noweekends.csv', 'r') random.seed(seed) row = random.randint(1, 219) # 219: number of days in data for _ in range(row): pfile.readline() line = pfile.readline().strip().split('\t') day = line[0] actual_prices = [float(p) / 300. for p in line[1:]] # get expected prices for the right month from pre-computed avg file exp_prices_in = open('price_data/APXReferencePriceDataUkPowerMarket2012_noweekends_avg.csv', 'r') exp_prices_in.readline() # Title for line in exp_prices_in.readlines(): line = line.strip().split('\t') if '-{}-'.format(line[0]) in day: # we reached the correct month avg_price = float(line[1]) exp_prices = [float(p) for p in line[2:]] break street = Street(T=T, N=N, C=C, Dmax=Dmax, Smax=Smax, pmax=pmax, pmin=pmin, c_h=c_h, adaptive=adaptive, slope=econ_slope, placement_optimistic=placement_optimistic) log.write('# w, ') for btype in battery_types: log.write('{}, '.format(btype.name)) log.write('\n') for w in ws: line = '{}, '.format(w) for btype in battery_types: b = btype(capacity=B, efficiency=alpha, max_rate=max_rate, street=street, exp_prices=exp_prices, avg_price=avg_price, T=T, c_h=c_h) if btype in (OfflineBattery, DeterministicH2Battery): b.exp_prices = actual_prices if btype in (OfflineBattery, NonDeterministicOfflineBattery): b.max_runtime = LP_max_runtime b.max_k = LP_max_k b.solve_offline(w) accumulated_costs = 0 for t in xrange(0, T): pt = actual_prices[t] bcharge = b.compute_charge(t, pt) if debug: fp, fm = street.f(t, bcharge, pt) print("[{}][{}] exp. price: {}, act. price:{}, fp:{}, fm:{}, magnitude before:{}, magnitude after:{}, b.level:{}, bcharge:{}".format( t, b.name, round(exp_prices[t], 2), round(pt, 2), round(fp, 2), round(fm, 2), round(street.maxf(t, 0, pt), 2), round(street.maxf(t, bcharge, pt), 2), round(b.level, 2), round(bcharge, 2))) revenue = b.execute_charge(bcharge, pt) cost = street.cost(t, bcharge, pt) accumulated_costs += w * cost - revenue # now sell the rest in the battery at an assumed worth of the # average price of that month if not btype is NoBattery: accumulated_costs -= b.level * avg_price b.level = 0 line += '{},'.format(accumulated_costs) if debug: print "Acc. Costs: ", accumulated_costs log.write('{}\n'.format(line[:-1])) # write line w/o last comma log.flush() log.close()
WHITE = (255, 255, 255) GREEN = (94, 221, 95) YELLOW = (100, 85, 0) BROWN = (118, 92, 72) GRAY = (175, 175, 175) #Create Frog object frog = Frog() #Create log object log = Log() #Create log object streets = [] number_of_buses = 3 street_height = 400 for _ in range(2): streets.append( Street(street_height, 'Left', random.randint(1, number_of_buses))) streets.append( Street(street_height - 40, 'Right', random.randint(1, number_of_buses))) street_height -= 80 #Game Loop while True: # Tick forward at 60 frames per second CLOCK.tick(FPS) #Event listener:Listens for an input the player provides for event in pygame.event.get(): #User closes if event.type == pygame.QUIT: sys.exit()