def build_network(self, logger,env): # nic0 -> client to cache server # nic1 -> cross rach(between cache servers # nic2 -> between backend and cache servers links={} nic_count = int(self.config.get('Network', 'nic count')) self.nic_count = nic_count #print("nic COUNt is %d" %nic_count) coef = 1 speed_unit = self.config.get('Network', 'unit') if speed_unit == 'Gbps': coef = 1024/8 # based on MB #coef = 1024*1024*1024 elif speed_unit == 'Mbps': coef = 1 #coef = 1024*1024 elif speed_unit == 'Kbps': coef = 1024/8 elif speed_unit == 'Bps': coef = 1 for i in range(self.c_nodes): for j in range (nic_count-1): nic_id = "nic"+str(j)+" in" link_id = "nic"+str(j)+".in."+str(i) speed = float(self.config.get('Network', nic_id))*coef #speed = float(self.config.get('Network', nic_id).split("G")[0])/8*1000*1000*1000 links[link_id]=simpy.Container(env, speed, init=speed) nic_id = "nic"+str(j)+" out" link_id = "nic"+str(j)+".out."+str(i) speed = float(self.config.get('Network', nic_id))*coef #speed = float(self.config.get('Network',nic_id).split("G")[0])/8*1000*1000*1000 links[link_id]=simpy.Container(env, speed, init=speed) #DL link #nic_id = "nic"+str(nic_count-1)+" in" #link_id = "nic"+str(nic_count-1)+".in" #speed = float(self.config.get('Network', nic_id).split("G")[0])/8*1000*1000*1000 nic_id = "dl"+" nic"+str(nic_count-1)+" in" link_id = "nic"+str(nic_count-1)+".in" speed = float(self.config.get('Network', nic_id))*coef links[link_id]=simpy.Container(env, speed, init=speed) #nic_id = "nic"+str(nic_count-1)+" out" #link_id = "nic"+str(nic_count-1)+".out" #speed = float(self.config.get('Network', nic_id).split("G")[0])/8*1000*1000*1000 nic_id = "dl"+ " nic"+str(nic_count-1)+" out" link_id = "nic"+str(nic_count-1)+".out" speed = float(self.config.get('Network', nic_id))*coef links[link_id]=simpy.Container(env, speed, init=speed) #print("LINKS ARE %s" %links) return links
def set_environment(self, env=None, lock=False, p=1): """ La funzione associa l'ambiente di test alla coda: se non specificato, l'ambiente viene creato al volo - "env" e' l'ambiente di simulazione - "lock" e' in booleano, indica se l'arrivo di richieste e' controllato dalla coda precedente - "p" e' la probabilita' con cui viene accettata la richiesta in arrivo (valore compreso tra 0 ed 1) """ # Controllo dell'input ic.check_number(p, 'probability to accept a request', 0, 1) if env is None: # Creo al volo l'ambiente di test env = simpy.Environment() # Associazione self.env = env # Modulo per le statistiche self.stats = qs_stats.QS_StatsManager(self.env) # Sistema nel complesso e server interni sono modellizzati come risorse condivise self._QS = simpy.Resource(self.env, capacity=self.capacity) self._S = simpy.Resource(self.env, capacity=self.servers) # La popolazione viene modellizzata come contenitore di risorse condivise self._P = simpy.Container(self.env, capacity=self.population, init=self.population) # Se richiesto, e' possibile fare in modo che l'arrivo di una richiesta sia comandato dall'esterno (es: chained) if lock: self._LockedQueue = simpy.Container(self.env, capacity=INF, init=0) self.probToArrive = p else: # Nota: in questo caso, la coda di blocco e' totalmente ininfluente self._LockedQueue = simpy.Container(self.env, capacity=INF, init=INF) self.probToArrive = 1
def build_network(config, logger, env): # 1 Gbps = 125 MB/s # 10 Gbps = 1250 MB/s # 40 Gbps = 5000 MB/s TOR_SIZE = 1 links = {} L1_In = float(config.get('Network', 'L1_In').split("G")[0]) / 8 * 1000 * 1000 * 1000 L2_In = float(config.get('Network', 'L2_In').split("G")[0]) / 8 * 1000 * 1000 * 1000 L1_Out = float(config.get('Network', 'L1_Out').split("G")[0]) / 8 * 1000 * 1000 * 1000 L2_Out = float(config.get('Network', 'L2_Out').split("G")[0]) / 8 * 1000 * 1000 * 1000 numNodes = int(config.get('Simulation', 'nodeNum')) if config.get('Simulation', 'L1') == "true": for i in range(numNodes): linkId = "L1in1r" + str(i) links[linkId] = simpy.Container(env, L1_In, init=L1_In) linkId = "L1out0r" + str(i) links[linkId] = simpy.Container(env, L1_Out, init=L1_Out) if config.get('Simulation', 'L2') == "true": for i in range(numNodes): linkId = "L2in1r" + str(i) links[linkId] = simpy.Container(env, L2_In, init=L2_In) linkId = "L2out0r" + str(i) links[linkId] = simpy.Container(env, L2_Out, init=L2_Out) linkId = "Cephout" links[linkId] = simpy.Container(env, L2_In, init=L2_In) return links
def __init__(self, env): self.wood = simpy.Container(env, capacity=wood_capacity, init=initial_wood) self.dispatch = simpy.Container(env, capacity=dispatch_capacity, init=0)
def __init__(self, env): # input process self.machinery = simpy.Container(env, capacity=machinery_capacity, init=initial_machinery) self.machinery_control = env.process(self.machinery_stock_control(env)) self.components = simpy.Container(env, capacity=components_capacity, init=initial_components) self.components_control = env.process( self.components_stock_control(env)) self.assembler = simpy.Container(env, capacity=assembler_capacity, init=0) self.assembler_control = env.process(self.assembler_stock_control(env)) # activities #self.parts_sequencing = env.process(self.parts_sequencing_control(env)) #self.setting_up_schedule = env.process(self.setting_up_schedule_control(env)) #self.production_commence = env.process(self.production_commence_control(env)) # output #self.quality_check = env.process(self.quality_check_control(env)) #self.vehicle_assemble = env.process(self.vehicle_assemble_control(env)) self.dispatch = simpy.Container(env, capacity=dispatch_capacity, init=0) self.dispatch_control = env.process(self.dispatch_vehicle_control(env)) # Closure & monitor #self.transport_dealer = env.process(self.transport_dealer_control(env)) self.env_status_monitor = env.process(self.env_status(env))
def simular_turnoscapacidad(cantCajas, tiempoCaja, cantServidores, cantAsientos, tiempoCocina, cantMenus, cantCajasTarjeta, cantCapacidad): mes={2 : "FEBRERO", 3: "MARZO", 4: "ABRIL", 5: "MAYO", 6:"JUNIO", 7:"JULIO", 8:"AGOSTO",9:"SEPTIEMBRE",10:"OCTUBRE",11:"NOVIEMBRE", 12:"DICIEMBRE"} TOTAL=0 tiempoCocina=tiempoCocina*60 tiempoCaja=tiempoCaja*60 for i in range(2,13): d = pd.read_csv("data/CSVs/tablas_simulacion/{}.csv".format(mes[i]), sep =",") dato = d.transpose() TOTAL11 = dato.loc['11'].sum() TOTAL12 = dato.loc['12'].sum() TOTAL13 = dato.loc['13'].sum() TOTAL14 = dato.loc['14'].sum() INTERVALTURNO11 = (3600 / TOTAL11) INTERVALTURNO12 = (3600 / TOTAL12) INTERVALTURNO13 = (3600 / TOTAL13) INTERVALTURNO14 = (3600 / TOTAL14) TOTAL+=TOTAL11+TOTAL12+TOTAL13+TOTAL14 random.seed(RANDOM_SEED) env = simpy.Environment() automatic_clerk= MonitoredResource("automatic clerk", env, capacity=cantCajasTarjeta) clerk = MonitoredResource("clerk", env, capacity=cantCajas) # pasar de 2 a 3 cajas mejora muchisimo seats = MonitoredResource("seats", env, capacity=cantAsientos) server = MonitoredResource("server", env, capacity=cantServidores*2) delivery = simpy.Container(env, capacity=150) pase=simpy.Container(env, capacity=cantCapacidad) env.process(student_capacity_generator(env, 11, "", TOTAL11, INTERVALTURNO11, clerk, automatic_clerk, server, delivery, seats, tiempoCaja, pase, i)) start_delayed(env, student_capacity_generator(env, 12, "", TOTAL12, INTERVALTURNO12, clerk, automatic_clerk, server, delivery, seats, tiempoCaja, pase, i), 3600) start_delayed(env, student_capacity_generator(env, 13, "", TOTAL13, INTERVALTURNO13, clerk, automatic_clerk, server, delivery, seats, tiempoCaja, pase, i), 7200) start_delayed(env, student_capacity_generator(env, 14, "", TOTAL14, INTERVALTURNO14, clerk, automatic_clerk, server, delivery, seats, tiempoCaja, pase, i), 10800) env.process(door(env,pase,cantCapacidad)) env.process(kitchen(env, delivery, cantMenus, tiempoCocina)) env.run(until=25200) # name | month | facultad | start_time | end_time | clerk_queue | automatic_clerk_queue | delivery_queue | seating_queue | total_waiting_time | activity_time df = None df = pd.DataFrame(dataframe, columns=['name', 'turno', 'month', 'facultad', 'start_time', 'end_time', 'clerk_queue', 'automatic_clerk_queue','delivery_queue', 'seating_queue', 'total_waiting_time', 'activity_time']) resources.extend([clerk, automatic_clerk, server, seats]) return df
def update(self, RDSEED): self.reset() for episode in range(LEPI): self.reset() print ("qlearing episode %d setpcont %d" % (episode,self.stepcount)) random.seed(RDSEED) ul = soCoMM.UL() for i in range(ul.USERS_NUM): user = soCoMM.User(i) user.usersetting() user.usercreat() ul.USER_LIST.append(user) mec0 = soCoMM.MEC(0,ul) mec0.setMEC(0,0,0,2,50) mec1 = soCoMM.MEC(1,ul) mec1.setMEC(1000,0,0,4,50) mec2 = soCoMM.MEC(2,ul) mec2.setMEC(0,1000,0,6,50) mec3 = soCoMM.MEC(3,ul) mec3.setMEC(1000,1000,0,8,50) env_ = simpy.Environment() #env_.process(ul.mobile(env_))#user mobile WAITING_LEN0 = simpy.Container(env_,BUFFER, init=len(mec0.WAITING_LIST)) env_.process(mec0.runremote(env_,WAITING_LEN0)) env_.process(mec0.refreshtrans(env_,WAITING_LEN0)) env_.process(mec0.refreshsys(env_,flag=0)) env_.process(self.step(mec0,env_)) # initial observation WAITING_LEN1 = simpy.Container(env_,BUFFER, init=len(mec1.WAITING_LIST)) env_.process(mec1.runremote(env_,WAITING_LEN1)) env_.process(mec1.refreshtrans(env_,WAITING_LEN1)) env_.process(mec1.refreshsys(env_,flag=0)) env_.process(self.step(mec1,env_)) WAITING_LEN2 = simpy.Container(env_,BUFFER, init=len(mec2.WAITING_LIST)) env_.process(mec2.runremote(env_,WAITING_LEN2)) env_.process(mec2.refreshtrans(env_,WAITING_LEN2)) env_.process(mec2.refreshsys(env_,flag=0)) env_.process(self.step(mec2,env_)) # initial observation WAITING_LEN3 = simpy.Container(env_,BUFFER, init=len(mec3.WAITING_LIST)) env_.process(mec3.runremote(env_,WAITING_LEN3)) env_.process(mec3.refreshtrans(env_,WAITING_LEN3)) env_.process(mec3.refreshsys(env_,flag=0)) env_.process(self.step(mec3,env_)) # initial observation env_.run(until=SIM_TIME) self.reset()
def __init__(self, name, env, station, load_station, user_input=False): self.station = station self.load_station = load_station self.loaded_stock = load_station.finished_stock self.oven_stock = simpy.Container(env, 1) self.mold_stock = simpy.Container(env, 1) self.user_input = user_input self.name = name self.env = env self.cycles = 0 self.failures = 0 self.process = env.process(self.run(self.env))
def schedule(env): global __running__ global day_time #Res symbolisiert die frei zur Verfügung stehende Abfüll-Anlage #Bei Wartungsarbeiten wird so die Maschine blockiert res = simpy.PriorityResource(env, capacity=1) #Queque que_check = simpy.Container(env, capacity=100) que_fill = simpy.Container(env, capacity=FILLING_SATIONS) que_done = simpy.Container(env) que_rejected = simpy.Container(env) que_removed = simpy.Container(env) #Offset damit scheduling Funktioniert offset = 60 - (day_time.second % 60) if day_time.second % 60 > 0 else 0 logging.debug( f"Wartet {offset} Sekunden bis mit den Scheduling begonnen wird") yield env.timeout(offset) update_time(env) while True: logging.debug( f"Datum:{day_time}|Queue_Check:{que_check.level}|Queue_Fill:{que_fill.level}|Queue_Done:{que_done.level}|Queue_Rej:{que_rejected.level}" ) weekday = day_time.isoweekday() time = day_time.shift(minutes=VARIANCE_MEAN).format("HH:mm:ss") #Status if time in status.index: if not pd.isnull(status.loc[time][weekday]): if status.loc[time][weekday] == "r": env.process( proc_start_processes(env, res, que_check, que_fill, que_done, que_rejected, que_removed)) else: env.process(proc_end_processes(env)) #Wartung if time in maintenance.index: if not pd.isnull(maintenance.loc[time][weekday]): time = int(maintenance.loc[time][weekday]) env.process(proc_maintenance(env, time, res)) yield env.timeout(60) update_time(env)
def programm_execution(amount_cars, iterations): # Create environment and DSO contaier env = simpy.Environment() charger = simpy.Container(env, settings.DSO_CAP, init=settings.DSO_CAP) import_non_ev_loads() # start ampel monitor env.process(ampel_setter(env, charger)) env.process(charger_checker(env, time, charger_level, charger)) env.process(price_over_time(env, price)) # create distributions soc = soc_distribution() start = start_of_charging_distribution() end = end_of_charging_distribution() # run cars and market cars = [Car(env=env, charger=charger, start=random.choice(start), soc=random.choice(soc), end=random.choice(end), name=i) for i in range(amount_cars)] market = Flexmarket(env, charger, cars) env.process(market.operate()) for car in cars: env.process(car.operate()) #env.process(car_monitor(env, car, car_values_over_time)) # Execute! env.run(until=settings.SIM_TIME) #uncomment this for data export #data_export(cars, market, amount_cars, iterations, charger_level) plotter() plt.show()
def __init__(self, m=1, mu1=0.5, s1=0.1, t1=0.2, t2=0.5, mu2=20, s2=2, l=4/3): self.job_distr = lambda: random.expovariate(1 / m) self.proc_distr = lambda: random.normalvariate(mu1, s1) self.prep_distr = lambda: random.uniform(t1, t2) self.break_distr = lambda: random.normalvariate(mu2, s2) self.repair_distr = lambda: random.expovariate(l) self.env = simpy.Environment() self.container_queue = simpy.Container(self.env) self.queue = [] self.queue_times = [] self.queue_sizes = [] self.size_start_time = 0 self.empty_times = [] self.empty_start_time = 0 self.busy = False self.total_times = { "free": [], "prep": [], "working": [], "repair": [] } self.parts_need = 0 self.parts_made = 0 self.env.process(self.new_part()) self.env.process(self.break_machine()) self.process = self.env.process(self.working())
def __init__(self, train_id: str, env: simpy.core.Environment, capacity: int, max_speed: int, accel: float = 1.3): Locatable.__init__(self, (0, 0)) Identifiable.__init__(self, train_id) self.capacity = capacity self._max_speed = max_speed self._acceleration = accel self.train_line: Union[None, Schedule] = None self._env = env self._passengers = simpy.Container(self._env, capacity=capacity, init=0) self.driving_direction = 1 self._ticks_on_obj = 0 self._currently_on_object: Union[Driveable, type(None)] = None self._lock_pass_put = threading.Lock() self._lock_pass_pop = threading.Lock() self._lock_drain = threading.Lock() self.sim_force_stop_time = 0
def __init__(self, env, name, initial_stock=None): """ :param env: Environment of simpy simulation :param name: Unique FA name :param fa_name: Group name of FA such as Revenue, Tax etc. :param initial_stock: initial value of stocks for current FA """ Observable.__init__(self) print("Initialize container with name: ", name) if initial_stock is not None: self.container = simpy.Container(env, init=initial_stock) else: self.container = simpy.Container(env) self.env = env self.name = name
def __init__(self, env: simpy.Environment, name: str, product: Product, processing_times: list, debug: bool, deletion_point: int): """ Constructor for workstation :param env: the environment the workstation will be :param name: of the workstation :param product: the product that the workstation is building :param processing_times: the processing times generated in the .dat file :param debug: if debug mode should be on :param deletion_point: the deletion point of the model """ self.name = name self.product = product self.buffers = {} for i in product.required_components: self.buffers[i] = simpy.Container(env, 2) self.env = env self.processing_times = processing_times self.products_made = 0 env.process(self.workstation_process()) self.wait_time = 0 self.debug = debug self.deletion_point = deletion_point self.products_time = [0] * SIZE self.components_held = {} self.components_used = {}
def update(self, RDSEED): self.reset() for episode in range(LEPI): self.reset() print("learing episode %d" % (episode)) random.seed(RDSEED) for i in range(USERS_NUM): user = soCoM.User(i) user.usersetting() user.usercreat() self.mec.USER_LIST.append(user) env_ = simpy.Environment() WAITING_LEN_ = simpy.Container(env_, BUFFER, init=len(self.mec.WAITING_LIST)) observation = self.mec.getstate() env_.process(self.mec.runremote(env_, WAITING_LEN_)) env_.process(self.mec.refreshsys(env_, WAITING_LEN_)) env_.process(self.step(self.mec, observation, env_, WAITING_LEN_)) env_.run(until=SIM_TIME) self.stepcount += 1 self.setpcount = 0 self.reset()
def addLink(self, linkID=None, turns={}, type='link', length=0, t0=1, MU=1, nodeID=None, coordinates=((0, 0), (0, 0))): if linkID in self.links: print('Error: Link %d has already been defined!' % linkID) else: if 'exit' not in turns.keys(): turns['exit'] = np.min((1 - sum(turns.values()), 1)) self.links[linkID] = { 'length': length, 'turns': turns, 't0': t0, 'MU': MU } if nodeID is None: chars = string.ascii_uppercase + string.digits nodeID = ''.join([random.choice(chars) for i in range(8)]) if nodeID not in self.nodes.keys(): self.addNode(nodeID, cap=1) self.links[linkID]['node'] = self.nodes[nodeID] self.links[linkID]['queue'] = simpy.Container(self.env) self.links[linkID]['coordinates'] = coordinates print('Created link %s at node %s' % (linkID, nodeID))
def proceso(nombre, env, cpu, memoria): memoria = simpy.Container(env, MEMORIA_RAM, init=MEMORIA_RAM) with cpu.request() as req: print('%s llegando a %1.f' % (nombre, env.now)) start = env.now #se pide la cantidad de memoria necesaria yield req #Se da la memoria pedida memoria_requerida = random.randint(*NIVEL_DE_MEMORIA) yield memoria.get(memoria_requerida) #la ejecucion de instrucciones toma tiempo yield env.timeout(memoria_requerida / VELOCIDAD) tiempo_proceso = env.now - start print('%s termino ejecutando instrucciones en %.1f segundos.' % (nombre, tiempo_proceso)) #print (memoria_requerida) #print (memoria.level) lista.append(tiempo_proceso) #print (lista) total = sum(lista) print( 'PROMEDIO DE TIEMPO QUE ESTA EL PROCESO EN LA COMPUTADORA HASTA EL MOMENTO %1.f' % (total / CANT_PROCESOS))
def __init__(self, env): self.cpu = simpy.Resource(env, capacity=2) self.memoria = simpy.Container(env, init=100, capacity=100) self.average = 0 # How many programs the CPU is gonna work totalProcesses = 25 contador = 1 intervalo = 10 while contador <= totalProcesses: instrucciones = random.randint(1, 10) mem = random.randint(1, 10) respuesta = random.randint(1, 2) # el intervalo sirve para lambda = (1.0/intervalo) que nos dara # una secuencia de numeros del 0 al infinito, la cual siempre # se repetira si es ingresado el mismo numero al principio inicio = random.expovariate(1.0 / intervalo) # Finalmente se crea, con los argumentos anteriores, un nuevo proceso contador = contador + 1 env.process( self.Simulacion(env, "Proceso %d" % contador, inicio, mem, instrucciones, respuesta))
def __init__(self, env, plate, start_zone, start_soc, vehicle_config, energymix_conf, sim_scenario_conf, sim_start_time): engine_type = sim_scenario_conf["engine_type"] model = sim_scenario_conf["vehicle_model_name"] if engine_type == "electric": energymix = energymix_conf else: energymix = {} super().__init__(vehicle_config[engine_type][model], energymix) self.env = env self.plate = plate self.zone = start_zone #self.alpha = sim_scenario_conf["alpha"] #self.battery_capacity = vehicle_config["battery_capacity"] #self.energy_efficiency = vehicle_config["energy_efficiency"] self.available = True self.soc = simpy.Container(env, init=start_soc, capacity=100) self.current_status = { "time": sim_start_time, "status": "available", "soc": self.soc.level, "zone": self.zone } self.status_dict_list = [self.current_status]
def initialize_port(self): """ Initializes a Port object with a simpy.Container of scour protection material. """ self.port = simpy.Container(self.env)
def __init__(self,env,num_chargers,tanks_capacity,max_level, trucks_num): self.env = env self.dispenser = simpy.Resource(env,capacity= num_chargers) self.tanks = simpy.Container(env,init=100,capacity=tanks_capacity) self.max_level = max_level self.monitor_tank = env.process(self.monitor_tank(env,max_level)) self.trucks = simpy.Resource(env,capacity=trucks_num)
def __init__(self, env, instructionsRead): self.env = env self.ram = simpy.Container( env, init=100, capacity=100) #cambio de capacidad de memoria RAM self.cpu = simpy.Resource( env, capacity=2) #cambio de capacidada de procesar del CPU self.instructionsRead = instructionsRead
def __init__(self, env: simpy.Environment, products: Tuple[str, ...], capacities: Tuple[int, ...], init: Optional[Tuple[int, ...]] = None) -> None: """ Initialize. :param env: The simulation environment. :param products: The products handled. :param capacities: The capacity of the different Store incorporated. :param init: The initial quantities in the containers. If not provided is set by default equal to the capacity. """ self.env = env self.products = products self.capacities: Dict[str, int] = { p: q for p, q in zip(products, capacities) } init = init or tuple(capacities) self.containers: Dict[str, simpy.Container] = { p: simpy.Container(env, c, init=i) for p, c, i in zip(products, capacities, init) }
def test_container(env, log): """A *container* is a resource (of optinally limited capacity) where you can put in our take out a discrete or continuous amount of things (e.g., a box of lump sugar or a can of milk). The *put* and *get* operations block if the buffer is to full or to empty. If they return, the process nows that the *put* or *get* operation was successfull. """ def putter(env, buf, log): yield env.timeout(1) while True: yield buf.put(2) log.append(('p', env.now)) yield env.timeout(1) def getter(env, buf, log): yield buf.get(1) log.append(('g', env.now)) yield env.timeout(1) yield buf.get(1) log.append(('g', env.now)) buf = simpy.Container(env, init=0, capacity=2) env.process(putter(env, buf, log)) env.process(getter(env, buf, log)) env.run(until=5) assert log == [('p', 1), ('g', 1), ('g', 2), ('p', 2)]
def __init__(self, env, uid, latitude, longitude, capacity, count=1, init=0.1): ''' ''' assert capacity, f"capacity: {capacity}" assert count, f"count: {count}" self.env = env # Уникальный идентификатор контейнерной площадки self.uid = uid # Широта контейнерной площадки self.latitude = latitude # Долгота контейнерной площадки self.longitude = longitude # Количество контейнеров на контейнерной площадке self.count = count # Максимальная емкость self.capacity = capacity * self.count # Наряд на вывоз мусора self.order_uid = None self.resource = simpy.Container(self.env, capacity=self.capacity * 10, init=init)
def __init__(self, env, name): self.env = env self.name = name self.battery = simpy.Container(env, init=600, capacity=1000) self.fuel_tank = simpy.Container(env, init=500, capacity=1000) self.crew = simpy.Container(env, init=20, capacity=50) self.computation = simpy.Container(env, init=20, capacity=1000) self.dead = env.event() self.reactor = env.process(Reactor(env, self).run()) self.lifesupport = env.process(Lifesupport(env, self).run()) env.process(self.run())
def SimulationRL(rho, rl): random.seed(RANDOM_SEED) mec = soCoM.MEC() mec.RHO = rho * mec.RHO print("Envronment create!") env = simpy.Environment() print("User create!") for i in range(mec.USERS_NUM): user = soCoM.User(i) user.usersetting() user.usercreat() mec.USER_LIST.append(user) WAITING_LEN = simpy.Container(env, BUFFER, init=len(mec.WAITING_LIST)) env.process(mec.runremote(env, WAITING_LEN)) env.process( mec.refreshsys(env, WAITING_LEN, rl.name, 'rho' + str(mec.RHO), 1)) env.process(mec.offloadDQ(env, WAITING_LEN, rl)) env.process(mec.writelog(env, rl.name, 'rho', int(mec.RHO))) env.run(until=SIM_TIME) mec.writeoffload(rl.name, 'rho', int(mec.RHO)) for u in mec.USER_LIST: u.userprint()
def __init__(self, *args, **kwargs): super(TopTest, self).__init__(*args, **kwargs) self.container = simpy.Container(self.env) self.resource = simpy.Resource(self.env) self.queue = Queue(self.env) self.pool = Pool(self.env) self.a = CompA(self) self.b = CompB(self) hints = {} if self.env.config['sim.log.enable']: hints['log'] = {'level': 'INFO'} if self.env.config['sim.vcd.enable']: hints['vcd'] = {} if self.env.config['sim.db.enable']: hints['db'] = {} self.auto_probe('container', **hints) self.auto_probe('resource', **hints) self.auto_probe('queue', **hints) self.auto_probe('pool', **hints) self.trace_some = self.get_trace_function('something', vcd={'var_type': 'real'}, log={'level': 'INFO'}) self.trace_other = self.get_trace_function('otherthing', vcd={ 'var_type': 'integer', 'init': ('z', 'z'), 'size': (8, 8) }) self.add_process(self.loop)
def __init__(self, env, plate, start_zone, start_soc, vehicle_config, energymix_conf, sim_scenario_conf, sim_start_time): engine_type = sim_scenario_conf["engine_type"] model = sim_scenario_conf["vehicle_model_name"] if engine_type == "electric": energymix = energymix_conf else: energymix = {} # Get the vehicle config for "Electric"-"generic e scooter" super().__init__(vehicle_config[engine_type][model], energymix) self.env = env self.plate = plate self.zone = start_zone self.available = True self.soc = simpy.Container(env, init=start_soc, capacity=100) # soc: State of Charge self.current_status = { "time": sim_start_time, "status": "available", "soc": self.soc.level, "zone": self.zone } self.status_dict_list = [self.current_status]
def generateReservoirs(self, env, levels): ''' Helper method to generate reservoirs ''' for fuel in levels: self.RESERVOIRS[fuel] = simpy.Container(env, levels[fuel], init=levels[fuel])