async def runsim(openers, fights, stattable, abilities, party, pbuffs, buffs):
tasks = []
tasks2 = []
tasks3 = []
x = 0
while x < 2:
tasks.append(
asyncio.create_task(
sim(x, 600, openers['Late Trick'], fights['Default'],
stattable, abilities, party, pbuffs, buffs, True, False,
False).sim()))
tasks2.append(
asyncio.create_task(
sim(x, 600, openers['Late Trick'], fights['Default'],
stattable, abilities, party, pbuffs, buffs, True, False,
False).sim()))
tasks3.append(
asyncio.create_task(
sim(x, 600, openers['Late Trick'], fights['Default'],
stattable, abilities, party, pbuffs, buffs, True, False,
False).sim()))
x = x + 1
a = await asyncio.gather(*tasks)
b = await asyncio.gather(*tasks2)
c = await asyncio.gather(*tasks3)
return a + b + c
def run(param, env, controllers, initial_state = None, args = None):
if args is None:
args = parse_args()
if not args.disable_cuda and torch.cuda.is_available():
device = torch.device('cuda')
else:
device = torch.device('cpu')
if args.il:
train_il(param, env, device)
else:
sim(param, env, controllers, initial_state, args.animate)
def main():
""" This program's entrypoint. """
# Parse command line arguments.
psr = argparse.ArgumentParser(description="Generates training data.")
psr.add_argument(
"--log-dst", default=EMAIL_DST,
help="The email address to which updates will be sent.", type=str)
psr, psr_verify = cl_args.add_out(psr)
args = psr_verify(psr.parse_args())
# The ID of the experiment.
eid = str(round(time.time()))
# Create a new output directory based on the current time.
out_dir = path.join(args.out_dir, eid)
# For organization purposes, store the pcap files in a subdirectory.
sim_dir = path.join(out_dir, "sim")
# This also creates out_dir.
os.makedirs(sim_dir)
# Set up logging.
numeric_level = getattr(logging, LOG_LVL.upper(), None)
if not isinstance(numeric_level, int):
raise ValueError(f"Invalid log level: {LOG_LVL}")
logging.basicConfig(level=numeric_level)
log = logging.getLogger(LOGGER)
# Assemble the configurations.
cnfs = [{"bottleneck_bandwidth_Mbps": bw_Mbps,
"bottleneck_delay_us": dly_us,
# Calculate queue capacity as a multiple of the BDP. If the BDP is
# less than a single packet, then use 1 packet as the BDP anyway.
"bottleneck_queue_p": int(round(
que_p *
max(1, bdp_bps(bw_Mbps, dly_us * 6) / float(PACKET_SIZE_B)))),
"unfair_flows": UNFAIR_FLOWS,
"other_flows": flws,
"other_proto": OTHER_PROTO,
"unfair_edge_delays_us": f"[{dly_us}]",
"other_edge_delays_us": f"[{dly_us}]",
"payload_B": PACKET_SIZE_B,
"enable_mitigation": "false",
"duration_s": DUR_s,
"pcap": "true" if PCAP else "false",
"out_dir": sim_dir}
for bw_Mbps, dly_us, que_p, flws in itertools.product(
BWS_Mbps, DELAYS_us, QUEUE_p, OTHER_FLOWS)]
sim.sim(eid, cnfs, out_dir, log_par=LOGGER, log_dst=args.log_dst,
dry_run=DRY_RUN, sync=defaults.SYNC)
log.info("Results in: %s", out_dir)
log.critical("Finished.")
def compute_model(offset, maxframes, nskip, uth, ucl):
return Model(offset=offset,
maxframes=maxframes,
nskip=nskip,
uth=uth,
ucl=ucl,
states=list(
islice(sim(listgen(uth, ucl), offset), nskip, None)))
def run(param, env, controllers, initial_state=None):
parser = argparse.ArgumentParser()
parser.add_argument("--rl", action='store_true')
parser.add_argument("--il", action='store_true')
parser.add_argument("--rrt", action='store_true')
parser.add_argument("--scp", action='store_true')
parser.add_argument("--animate", action='store_true')
args = parser.parse_args()
if args.rl:
train_rl(param, env)
elif args.il:
train_il(param, env)
elif args.rrt:
rrt(param, env)
elif args.scp:
scp(param, env)
else:
sim(param, env, controllers, initial_state, args.animate)
def main():
env = GreenhouseEnv()
agent = DDPGagent(env)
noise = OUNoise(env.action_space)
action_dim = env.action_space.shape[0]
state_dim = env.observation_space.shape[0]
#writer_reward = SummaryWriter()
#writer_abs = SummaryWriter()
#writer_penalty = SummaryWriter()
t1 = time.time()
mpl.style.use('seaborn')
if len(sys.argv) != 1:
# Load trained model
PATH = sys.argv[1:].pop()
print('Se cargo el modelo')
agent.load(PATH + '/nets')
else:
PATH = create_path()
Constants(PATH)
all_params['PARAMS_DDPG']['hidden_sizes'] = agent.hidden_sizes
save_params(all_params, PATH + '/output')
#agent.actor.eval()
#agent.critic.eval()
rewards, avg_rewards, penalties, abs_rewards = train_agent(
agent, noise, PATH, save_freq=SAVE_FREQ)
figure_reward(rewards, avg_rewards, penalties, abs_rewards, PATH)
save_rewards(rewards, avg_rewards, penalties, abs_rewards, PATH)
S_climate, S_data, S_prod, A, df_inputs, start, Qdic = sim(agent,
ind=INDICE)
save_Q(Qdic, PATH)
start = df_inputs['Date'].iloc[0]
final_indexes = compute_indexes(
start, STEPS, env.frec
) #Es necesario crear nuevos indices para las graficas, depende de STEP
figure_cost_gain(Qdic, final_indexes, PATH)
figure_state(S_climate, final_indexes, PATH)
figure_rh_par(S_data, final_indexes, PATH)
figure_prod(S_prod, final_indexes, PATH)
figure_actions(A, final_indexes, PATH)
figure_inputs(df_inputs, PATH)
t2 = time.time()
season1_nn(agent, PATH, '')
violin_reward(PATH, 'nn') ##puede ser nn ó expert
violin_actions(PATH, 'nn')
if not (SHOW):
create_report(PATH, t2 - t1)
send_correo(PATH + '/reports/Reporte.pdf')
pass
async def runsim(runjobs, runtime, currentid, open, fight, stattable,
abilities, party, pbuffs, buffs, potion, ast, log):
tasks = []
tasks2 = []
tasks3 = []
a = []
b = []
c = []
one = False
two = False
three = False
x = 0
while x < runjobs:
one = True
tasks.append(
asyncio.create_task(
sim(1, runtime, open, fight, stattable, abilities, party,
pbuffs, buffs, potion, ast, log).sim()))
x = x + 1
if x < runjobs:
two = True
tasks2.append(
asyncio.create_task(
sim(1, runtime, open, fight, stattable, abilities, party,
pbuffs, buffs, potion, ast, log).sim()))
x = x + 1
if x < runjobs:
three = True
tasks3.append(
asyncio.create_task(
sim(1, runtime, open, fight, stattable, abilities, party,
pbuffs, buffs, potion, ast, log).sim()))
x = x + 1
if one:
a = await asyncio.gather(*tasks)
if two:
b = await asyncio.gather(*tasks2)
if three:
c = await asyncio.gather(*tasks3)
return a + b + c
def inner_objective(sim_params, expr_str):
fitness = 0
for trial in range(sim_params["n_trials_per_individual"]):
history_u_student, history_u_teacher, *_ = sim(
sim_params, expr_str=expr_str, trial=trial
)
fitness += -error(
history_u_student["V_m"], history_u_teacher["V_m"], 0.1 * sim_params["t_sim"]
) # skip first 10% (initial transients)
return fitness * 1.0 / sim_params["n_trials_per_individual"]
def sim_test():
# dev driver
f = 'U.pkl'
P = pickle.load(open(f))
log.info('loaded <%s>', f)
P.describe()
U = P[P.index >= '2005-01-01']
U.describe()
import sim
_, B = sim.sim(U)
#plot NAV
B.NAV.plot(title='Equal Weight Everyone')
return B
def doSim(model, reps, repe, dir):
for rep in range(reps, repe):
print("python sim.py " dir + "/" + model + ".conf" > dir + "/" + model + rep + ".sim" > dir + "/" + model + rep + ".gen")
cfg = (dir + "/" +model + ".conf" dir + "/" +model + rep)
prefOut = (dir + "/" +model + ".conf" dir + "/" +model + rep)
sim = sim(cfg, prefOut)
os.remove(dir + "/" + model + rep + ".sim.bz2")
os.remove(dir + "/" + model + rep + ".gen.bz2")
gzip_file(dir + "/" + model + rep + ".sim")
gzip_file(dir + "/" + model + rep + ".gen")
os.remove(dir + "/" + model + rep + ".sim")
os.remove(dir + "/" + model + rep + ".gen")
def __init__(self):
# interface to magnetometer
self.magnetometer = magnetometer(gauss=4.7, declination=(-2, 5))
# interface to barometer
self.barometer = barometer()
# interface to persistent store
self.store = store()
# interface to GPS/GPRS module
self.sim = sim()
# current heading
self.current_heading = None
# current GPS data (json returned from sim.get_gps())
self.current_gps = None
# current baromoeter data
self.current_barom = {}
def dosim(ba, bb, r, theta, dk, inputmap, rlz, sn, i, Ttt, QUtt):
s = sim.sim(ba,
bb,
r=r,
theta=theta,
dk=dk,
inputmap=inputmap,
rlz=rlz,
sn=sn)
s.runsim(sigtype='TnoP', Ttemptype=Ttt, QUtemptype=QUtt)
fnt = s.save(i)
s.runsim(sigtype='sig', Ttemptype=Ttt, QUtemptype=QUtt)
fns = s.save(i)
s.runsim(sigtype='noi', Ttemptype=Ttt, QUtemptype=QUtt)
fnn = s.save(i)
s.runsim(sigtype='EnoB', Ttemptype=Ttt, QUtemptype=QUtt)
fnn = s.save(i)
def main(players=1):
filename = 'not_alone_card_value_data_' + unicode(players) + '.csv'
with open(filename, 'w') as csvfile:
fieldnames = [
'players',
'hunted',
'artemia',
'survival card value',
'hunt card value',
'rounds',
]
writer = csv.DictWriter(csvfile, fieldnames = fieldnames)
writer.writeheader()
hunt_val = 0
data = []
while hunt_val <= 1.0:
survival_val = 0
while survival_val <= 1.0:
data.append(sim.sim(players, TRIALS, hunt_val, survival_val, False))
print 'players ' + unicode(players)
print 'hunt ' + unicode(hunt_val)
print 'suvive' + unicode(survival_val)
survival_val = round(survival_val + 0.05, 2)
hunt_val = round(hunt_val + 0.05, 2)
with open(filename, 'a') as csvfile:
fieldnames = [
'players',
'hunted',
'artemia',
'survival card value',
'hunt card value',
'rounds',
]
writer = csv.DictWriter(csvfile, fieldnames = fieldnames)
for x in data:
writer.writerow(x)
def dosim(ba, bb, r, theta, dk, inputmap, rlz, sn, i, Ttt, QUtt, tempNside):
s = sim.sim(ba,
bb,
r=r,
theta=theta,
dk=dk,
inputmap=inputmap,
rlz=rlz,
sn=sn,
i=i,
tempNside=tempNside)
s.runsim(sigtype='TnoP', Ttemptype=Ttt, QUtemptype=QUtt)
s.runsim(sigtype='sig', Ttemptype=Ttt, QUtemptype=QUtt)
s.runsim(sigtype='noi', Ttemptype=Ttt, QUtemptype=QUtt)
s.runsim(sigtype='EnoB', Ttemptype=Ttt, QUtemptype=QUtt)
s.runsim(sigtype='TnoPnosl', Ttemptype=Ttt, QUtemptype=QUtt)
s.runsim(sigtype='signosl', Ttemptype=Ttt, QUtemptype=QUtt)
s.runsim(sigtype='EnoBnosl', Ttemptype=Ttt, QUtemptype=QUtt)
return s
screen = pygame.display.set_mode(game_constants.size)
#Loop until the user clicks the close button.
game = game(pygame, scenario)
# initialize earth
earth = earth()
# initialize vehicle state
vehicle = vehicle(scenario)
# initialize display
display = display(scenario, game)
# initialize truth
sim = sim()
# initialize flight computer
flight_computer = flight_computer()
# begin the loop for the game
while game.done == False:
# http://www.pygame.org/docs/ref/key.html
# User did something
for event in pygame.event.get():
# update the game based on keystrokes
game.update_events(event, vehicle, display, pygame, sim)
# for loop around propagation
with open(f"{data_directory}/sim_params.json", "r") as f:
sim_params = json.load(f)
# use a different seed than evo runs to generate different spike
# train realization and class labels
sim_params["seed"] = 817818273
n_runs = 6
for i in range(n_runs):
with open(os.path.join(data_directory, f"res_{i}.pkl"), "rb") as f:
res = pickle.load(f)
print("sim for", res["expr_champion"][-1])
errors = np.empty(sim_params["n_trials_per_individual"])
for trial in range(sim_params["n_trials_per_individual"]):
print(
f' trial {trial + 1}/{sim_params["n_trials_per_individual"]}')
data_u, data_u_target, *_ = sim(sim_params,
expr_str=res["expr_champion"][-1],
trial=trial)
errors[trial] = -error(
data_u["V_m"], data_u_target["V_m"], 0.1 *
sim_params["t_sim"]) # skip first 10% (initial transients)
with open(os.path.join(data_directory, f"res_test_{i}.pkl"),
"wb") as f:
pickle.dump(errors, f)
#Space Launch Simulator
from sim import sim
pp = [[31, 0], [60, 26], [100, 46.85], [160, 68.8], [240, 60.8],
[390, 72.436], [540, 79.744], [620, 81.3], [700, 91.4]]
satv = sim()
satv.stage('payload',1939+45693,0,425)
satv.stage('LES',4042)
satv.stage(1,2239795,113,0,0,163)
satv.stage(1j,5206,0,0,0,193)
satv.stage(2,479964,79,0,0,550)
satv.stage(2j,3663,0,0,0,561)
satv.stage(3,119119,34,0,0)
satv.prog_pitch(0,pp)
satv.burn(1,.3,[13231,13348],304,49,1793760)
satv.burn(1,135.20,10638,304,39,281151)
satv.burn(1j,163,176.3,237,0,617,angle=10)
satv.burn(2,164,1224,424,3.*5,363053)
satv.burn(2,460.62,979,424,3.*4,38560)
satv.burn(2,500,728,434,3.*4,35111)
satv.burn(2j,549,13.38,231,0,53.524,angle=10)
satv.burn(3,552.2,213.416,431,3.,31400)
satv.burn(3,9856.2,204.91,445,3.,71068)
satv.run(712) # run 712s of simulation
dat=satv.analyse() # print energies
#Use this to generate a data file for gnuplot
def test_x(self):
# s = 'aaaaaa'
# s = 'abbababb'
s = 'ababaa'
# s = 'aabbabab'
print sim.sim(s)
def main(parsed_gtfs_prefix,
osm_data,
depots_filename,
output_dir,
battery_cap_kwh,
nondepot_charger_rate,
parameter_override=None):
"""Runs Dispatch simulator with the given scenarios, in series.
Parameters
----------
parsed_gtfs_prefix : str
location and prefix of the parsed files generated by `parse_gtfs.py`
osm_data : str
location of the OSM pbf file for the GTFS feed being simulated
depots_filename : str
location of a csv file of depots in the following format:
lat : float
latitude of depot
lng : float
longitude of depot
name : str
name of the depot
max_buses : int
bus capacity
url : str
hyperlink to source of depot details
output_dir : str
location
battery_cap_kwh : list
list of ints,start (inclusive), end (exclusive), and step size values for
generating battery capacity scenarios
nondepot_charger_rate : list
list of ints, start (inclusive), end (exclusive), and step size values for
generating non-depot EVSE charger scenarios
parameter_override : dict
dict that overrides any Dispatch parameter defaults. See
`sim.generateParams()` for details on possible inputs.
Returns
-------
scenarios_results: dataframe
a df of of summary results for each scenario run
"""
scenarios = genScenarios(battery_cap_kwh, nondepot_charger_rate)
b_caps, cpowers = list(zip(*scenarios.values()))
#TODO, probably should move these options into params of main(), but is that
#getting too long? Advise on best practice here.
an_costs = genAnnualizedCosts(b_caps,
cpowers,
rate=0.07,
years=14,
bus_base_price=500_000,
bprice_kwh=100)
params = {}
#TODO Note that this will overwrite params passed to main()
# It may be best to just move all this out of CLI and into params exclusively?
if parameter_override is not None:
params = parameter_override
scen_costs = {}
for key, val in scenarios.items():
bat_cap = val[0]
cpower = val[1]
prefix = f'{bat_cap}kwh_{cpower}_kw'
#set up scenario parameters
params['battery_cap_kwh'] = bat_cap
params['nondepot_charger_rate'] = cpower
params['bus_cost'] = an_costs['annualized_base_bus']
params['battery_cost_per_kwh'] = an_costs['annualized_bat'][bat_cap]
params['nondepot_charger_cost'] = an_costs['annualized_charger'][
cpower]
results = sim(parsed_gtfs_prefix,
osm_data,
depots_filename,
parameters=params)
# parse results and write to file
scen_costs[prefix] = {
'battery_cap_kwh': bat_cap,
'nondepot_charger_rate': cpower,
'optimized_buses': results['opti_buses'],
'optimized_chargers': results['opti_chargers'],
'optimized_cost': results['opti_cost'],
'nc_buses': results['nc_buses'],
'nc_chargers': results['nc_chargers'],
'nc_cost': results['nc_cost'],
'ac_buses': results['ac_buses'],
'ac_chargers': results['ac_chargers'],
'ac_costs': results['ac_cost']
}
#create output dir if needed, and write to file
if not os.path.exists(output_dir):
os.mkdir(output_dir)
results['opti_trips'].to_csv(f'{output_dir}/{prefix}_trips.csv')
depot_res_name = f'{output_dir}/{prefix}_depot_counts.csv'
with open(depot_res_name, 'w', newline='') as csvfile:
fieldnames = ['depot', 'bus_count']
writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
writer.writeheader()
#TODO include nc and ac depots as well
for key, val in results['opti_depot_counts'].items():
writer.writerow({'depot': key, 'bus_count': val})
#create DF of summary results and write to file
scen_costs = pd.DataFrame(scen_costs).T
scen_costs.to_csv(f'{output_dir}/scenarios_results.csv')
from sim import sim
sys.path.insert(0, "../includes/")
import utils # noqa: E402
if __name__ == "__main__":
nest.Install("us_sympy_synapse_module")
data_directory = utils.get_data_directory_from_cmd_args()
with open(f"{data_directory}/sim_params.json", "r") as f:
sim_params = json.load(f)
sim_params["t_sim"] *= 2.0
(history_u_student, history_u_teacher, history_weights_student, weights_teacher) = sim(
sim_params, expr_str="(x_0 - x_1) * x_2", trial=0
)
res = {
"data_u": history_u_student,
"data_u_teacher": history_u_teacher,
"data_syn": history_weights_student,
"data_syn_teacher": weights_teacher,
}
with open(os.path.join(data_directory, "traces.pkl"), "wb") as f:
pickle.dump(res, f)
def setup_and_sim(worm, time_to_run):
import sys
"""
# If no command-line arguments are given, prompt for them.
if (len (sys.argv) <= 1):
args = 'main.py ' + input('Arguments: ')
sys.argv = re.split (' ', args)
regress_mode = (len(sys.argv) == 4) and (sys.argv[3]=="--regress")
if (regress_mode):
sys.argv = sys.argv[0:3]
if (len(sys.argv) != 3):
raise SyntaxError('Usage: python3 main.py test-name-to-run sim-end-time')
"""
end_time = time_to_run
# Run whatever test got chosen on the command line.
GP = sim.Params()
setup_lab_worm(GP, worm)
#eval ('setup_'+sys.argv[1]+'(GP)')
#if (regress_mode): # Works even if setup_...() overrules these params!
# GP.adaptive_timestep = False # Force regression
# GP.sim_dump_interval = 1
# GP.sim_long_dump_interval = 10
# Initialize Vmem -- typically 0, or close to that.
Vm = sim.compute_Vm (sim.cc_cells, GP)
assert (Vm<.5).all() # I.e.,roughly charge neutral
np.set_printoptions (formatter={'float': '{: 6.3g}'.format}, linewidth=90)
#print ('Initial Vm ={}mV\n'.format(1000*Vm))
#print ('Starting main simulation loop')
t_shots, cc_shots = sim.sim (end_time, GP)
#print ('Simulation is finished.')
# Now, the simulation is over. Do any end-of-sim analysis.
#edb.analyze_equiv_network (GP)
# If your network contains cells that are interconnected by GJs, then
# pretty_plot() can make a nice picture of the interconnections and each
# cell's Vm.
Vm = sim.compute_Vm (sim.cc_cells, GP)
# print("Worm Fitness = " + str(worm.fitness))
# print("Km = " + str(worm.Km))
# print("N = " + str(worm.N))
# print("Gj_scale = " + str(worm.Gj_scale))
# print("num_cells = " + str(worm.num_cells))
# print("G_k = " + str(worm.G_k))
# print("G_k = " + str(worm.G_na))
# print("G_cl = " + str(worm.G_cl))
# print("Gj_diff_m = " + str(worm.Gj_diff_m))
#print("Vmem?: {}".format(Vm))
Vgrad = abs(Vm[0] - Vm[worm.num_cells -1])
worm.grad_stren = Vgrad
#eplt.pretty_plot (Vm*1e3)
# We often want a printed dump of the final simulation results.
np.set_printoptions (formatter={'float': '{:.6g}'.format}, linewidth=90)
#edb.dump (end_time, sim.cc_cells, edb.Units.mV_per_s, True)
#edb.dump (end_time, sim.cc_cells, edb.Units.mol_per_m2s, True)
# We often want graphs of various quantities vs. time.
# If so, then comment out the quit() here, and then modify the code below
# as desired.
# quit()
Na = sim.ion_i['Na']; K = sim.ion_i['K']; Cl=sim.ion_i['Cl']
# P=sim.ion_i['P']; M=sim.ion_i['M']
Vm_shots = [sim.compute_Vm (c,GP)*1000 for c in cc_shots]
n_cells = sim.cc_cells.shape[1]
# eplt.plot_Vmem_graph(t_shots,Vm_shots, np.arange(n_cells),'Vmem(mV)')
# eplt.plot_Vmem_graph(t_shots,[s[Na] for s in cc_shots],np.arange(n_cells),'[Na] (mol/m3')
# eplt.plot_Vmem_graph(t_shots,[s[K] for s in cc_shots],np.arange(n_cells),'[K] (mol/m3')
# eplt.plot_Vmem_graph(t_shots,[s[Cl] for s in cc_shots],np.arange(n_cells),'[Cl] (mol/m3')
#eplt.plot_Vmem_graph(t_shots,[s[M] for s in cc_shots],np.arange(n_cells),'[M] (mol/m3')
def _thunk():
env = sim(sim_config)
#print(sim_config)
return env
if prun:
f_P.make_fake_data()
if ndirun:
f_NDI.make_fake_data()
if jdrun:
f_DI.make_fake_data()
#####################
#######Save Fake Data
# if not os.path.exists(work_dir+ 'data/fake_data'):
# os.mkdir(work_dir+ 'data/fake_data')
if prun:
f_P.save_fake_data(P_plots_dir + 'FD'+fake_tag+'.txt.gz')
f_P.save_fake_data_key(P_plots_dir + 'FD_key'+fake_tag+'.txt.gz')
if ndirun:
f_NDI.save_fake_data(NDI_plots_dir + 'FD'+fake_tag+'.txt.gz')
f_NDI.save_fake_data_key(NDI_plots_dir + 'FD_key'+fake_tag+'.txt.gz')
if jdrun:
f_DI.save_fake_data(DI_plots_dir + 'FD'+fake_tag+'.txt.gz')
f_DI.save_fake_data_key(DI_plots_dir + 'FD_key'+fake_tag+'.txt.gz')
if do_sim:
sim()
async def run1sim(runjobs, runtime, currentid, open, fight, stattable,
abilities, party, pbuffs, buffs, potion, ast, log):
tasks = []
tasks2 = []
tasks3 = []
a = []
b = []
c = []
atime = []
btime = []
ctime = []
abilitydict = {}
returntable = []
one = False
two = False
three = False
x = 0
while x < runjobs:
one = True
sim1 = sim(1, runtime, open, fight, stattable, abilities, party,
pbuffs, buffs, potion, ast, log)
tasks.append(asyncio.create_task(sim1.sim()))
x = x + 1
if x < runjobs:
two = True
sim2 = sim(1, runtime, open, fight, stattable, abilities, party,
pbuffs, buffs, potion, ast, log)
tasks2.append(asyncio.create_task(sim2.sim()))
x = x + 1
if x < runjobs:
three = True
sim3 = sim(1, runtime, open, fight, stattable, abilities, party,
pbuffs, buffs, potion, ast, log)
tasks3.append(asyncio.create_task(sim3.sim()))
x = x + 1
if one:
a = await asyncio.gather(*tasks)
atime = sim1.timetable
ability = sim1.abilities
returntable.append(atime)
for i in ability.keys():
if i in abilitydict.keys():
abilitydict[i] = abilitydict[i] + ability[i].totalpotency
else:
abilitydict[i] = ability[i].totalpotency
if two:
b = await asyncio.gather(*tasks2)
btime = sim2.timetable
ability = sim2.abilities
returntable.append(btime)
for i in ability.keys():
if i in abilitydict.keys():
abilitydict[i] = abilitydict[i] + ability[i].totalpotency
else:
abilitydict[i] = ability[i].totalpotency
if three:
c = await asyncio.gather(*tasks3)
ability = sim3.abilities
for i in ability.keys():
if i in abilitydict.keys():
abilitydict[i] = abilitydict[i] + ability[i].totalpotency
else:
abilitydict[i] = ability[i].totalpotency
ctime = sim3.timetable
returntable.append(ctime)
return a + b + c, returntable, abilitydict
def diff_dirs(
diff,
dir1,
dir2,
usecache=True,
cache_dir_base=None,
include=[],
ignore1=[],
ignore2=[],
load_fact=False,
fact_dir=None,
fact_versions=[],
fact_proj='',
fact_proj_roots=[],
ignore_unmodified=False,
restrict_fact=False,
fact_for_changes=False,
fact_for_mapping=False,
fact_for_ast=False,
fact_into_virtuoso='',
fact_into_directory='',
fact_size_thresh=diffts.DEFAULT_FACT_SIZE_THRESH,
fact_for_cfg=False,
fact_encoding=Enc.FDLCO,
fact_hash_algo=HashAlgo.MD5,
line_sim=False,
dumpccs=False,
check=False,
keep_filtered_temp=False,
local_cache_name=None,
dump_delta=False,
fact_for_delta=False,
keep_going=False,
use_sim=False,
sim_thresh=0.7,
quiet=False,
):
filt = lambda x: True
if include:
filt = lambda x: any(x.startswith(p) for p in include)
logger.info('"{}" - "{}" cache_dir_base="{}"'.format(
dir1, dir2, cache_dir_base))
cost = 0
nmappings = 0
nnodes = 0
nnodes1 = 0
nnodes2 = 0
nrelabels = 0
line_sim_sum = 0.0
line_sim_count = 0
info = get_info(dir1,
dir2,
usecache=usecache,
cache_dir_base=cache_dir_base,
load_fact=load_fact,
fact_dir=fact_dir,
fact_versions=fact_versions,
fact_proj=fact_proj,
fact_proj_roots=fact_proj_roots,
fact_for_changes=fact_for_changes,
fact_for_cfg=fact_for_cfg,
fact_for_mapping=fact_for_mapping,
fact_into_virtuoso=fact_into_virtuoso,
fact_into_directory=fact_into_directory,
fact_size_thresh=fact_size_thresh,
fact_encoding=fact_encoding,
fact_hash_algo=fact_hash_algo,
local_cache_name=local_cache_name,
fact_for_delta=fact_for_delta,
keep_going=keep_going)
logger.info('"{}" - "{}" get_info finished'.format(dir1, dir2))
get_rel1 = lambda x: x
get_rel2 = lambda x: x
if len(fact_proj_roots) == 2:
(d1, d2) = fact_proj_roots
pat1 = re.compile(r'^{}{}'.format(d1.rstrip(os.path.sep), os.path.sep))
pat2 = re.compile(r'^{}{}'.format(d2.rstrip(os.path.sep), os.path.sep))
get_rel1 = lambda x: pat1.sub('', x)
get_rel2 = lambda x: pat2.sub('', x)
modified = filter_pairs(info['modified'], ignore1, ignore2, get_rel1,
get_rel2, filt)
unmodified = filter_pairs(info['unmodified'], ignore1, ignore2, get_rel1,
get_rel2, filt)
renamed = filter_pairs(info['renamed'], ignore1, ignore2, get_rel1,
get_rel2, filt)
moved = filter_pairs(info['moved'], ignore1, ignore2, get_rel1, get_rel2,
filt)
added = filter_sources(info['added'], ignore2, get_rel2, filt)
copied = filter_sources(info['copied'], ignore2, get_rel2, filt)
removed = filter_sources(info['removed'], ignore1, get_rel1, filt)
glued = filter_sources(info['glued'], ignore1, get_rel1, filt)
extra_pairs = []
if use_sim:
logger.debug('matching removed and added files...')
l = []
for x in removed:
logger.debug('{}'.format(x))
cs_ = []
for x_ in added:
s = sim.sim(x, x_)
if s > sim_thresh:
logger.debug(' {} ({})'.format(x_, s))
cs_.append((x_, s))
if cs_:
l.append((x, cs_))
pairs = set()
pairs0 = set()
for (x, cs_) in l:
if len(cs_) == 1:
pairs.add((x, cs_[0][0]))
else:
pairs0.add((x, max(cs_, key=lambda x: x[1])[0]))
l_ = []
for x_ in added:
logger.debug('{}'.format(x_))
cands = []
for x in removed:
s = sim.sim(x, x_)
if s > sim_thresh:
logger.debug(' {} ({})'.format(x, s))
cands.append((x, s))
if cands:
l_.append((cands, x_))
pairs_ = set()
pairs0_ = set()
for (cs, x_) in l_:
if len(cs) == 1:
pairs_.add((cs[0][0], x_))
else:
pairs0_.add((max(cs, key=lambda x: x[1])[0], x_))
extra_pairs = list((pairs & pairs_) | (pairs0 & pairs0_))
logger.info('extra pairs (sim_thresh={}):'.format(sim_thresh))
for p in extra_pairs:
logger.info(' {} - {}'.format(*p))
if extra_pairs:
for p in extra_pairs:
(x, x_) = p
removed.remove(x)
added.remove(x_)
modified.append(p)
modified0 = [p[0] for p in modified]
unmodified0 = [p[0] for p in unmodified]
moved0 = [p[0] for p in moved]
renamed0 = [p[0] for p in renamed]
# for multi-processing
random.shuffle(unmodified0)
random.shuffle(moved0)
random.shuffle(renamed0)
random.shuffle(added)
random.shuffle(copied)
random.shuffle(removed)
random.shuffle(glued)
count_opts = {
'cache_dir_base': cache_dir_base,
'load_fact': load_fact,
'fact_dir': fact_dir,
'fact_versions': fact_versions,
'fact_proj': fact_proj,
'fact_proj_roots': fact_proj_roots,
'fact_for_ast': fact_for_ast,
'fact_into_virtuoso': fact_into_virtuoso,
'fact_into_directory': fact_into_directory,
'fact_size_thresh': fact_size_thresh,
'restrict_fact': restrict_fact,
'fact_encoding': fact_encoding,
'fact_hash_algo': fact_hash_algo,
'local_cache_name': local_cache_name,
}
modified0set = set(modified0)
moved0set = set(moved0)
renamed0set = set(renamed0)
if ignore_unmodified:
nunmodified0 = 0
nmoved0 = len(moved0set - modified0set)
nrenamed0 = len(renamed0set - modified0set)
else:
nunmodified0 = count_nodes(unmodified0, **count_opts)
nmoved0 = count_nodes(moved0set - modified0set, **count_opts)
nrenamed0 = count_nodes(renamed0set - modified0set, **count_opts)
fvs0 = []
fvs1 = []
if len(fact_versions) == 2 and load_fact:
fvs0 = [fact_versions[0]]
fvs1 = [fact_versions[1]]
fpr0 = []
fpr1 = []
if len(fact_proj_roots) == 2 and load_fact:
fpr0 = [fact_proj_roots[0]]
fpr1 = [fact_proj_roots[1]]
count_opts['fact_versions'] = fvs1
count_opts['fact_proj_roots'] = fpr1
nadded = count_nodes(added, **count_opts)
ncopied = count_nodes(copied, **count_opts)
count_opts['fact_versions'] = fvs0
count_opts['fact_proj_roots'] = fpr0
nremoved = count_nodes(removed, **count_opts)
nglued = count_nodes(glued, **count_opts)
d_nnodes1 = nunmodified0 + nmoved0 + nrenamed0 + nremoved + nglued
d_nnodes2 = nunmodified0 + nmoved0 + nrenamed0 + nadded + ncopied
nnodes1 += d_nnodes1
nnodes2 += d_nnodes2
nnodes += d_nnodes1 + d_nnodes2
nmappings += nunmodified0 + nmoved0 + nrenamed0
cost += nadded + ncopied + nremoved + nglued
logger.info('nnodes={}, nmappings={}, cost={}'.format(
nnodes, nmappings, cost))
st_time = time.time()
try:
modified_all = modified
logger.info('{} modified files'.format(len(modified_all)))
random.shuffle(modified_all) # for multi-processing
n_modified_all = len(modified_all)
count = 0
for (file1, file2) in modified_all:
if is_auxfile(file1):
logger.info('pre-source "{}" is ignored'.format(file1))
continue
if is_auxfile(file2):
logger.info('pre-source "{}" is ignored'.format(file2))
continue
count += 1
logger.info('*** processing modified files ({}/{})'.format(
count, n_modified_all))
if line_sim:
line_sim_sum += sim.line_sim(file1, file2)
line_sim_count += 1
r = diff(
file1,
file2,
cache_dir_base=cache_dir_base,
load_fact=load_fact,
fact_dir=fact_dir,
fact_versions=fact_versions,
fact_proj_roots=fact_proj_roots,
restrict_fact=restrict_fact,
fact_for_changes=fact_for_changes,
fact_for_mapping=fact_for_mapping,
fact_for_ast=fact_for_ast,
fact_into_virtuoso=fact_into_virtuoso,
fact_into_directory=fact_into_directory,
fact_size_thresh=fact_size_thresh,
fact_encoding=fact_encoding,
fact_hash_algo=fact_hash_algo,
dumpccs=dumpccs,
check=check,
keep_filtered_temp=keep_filtered_temp,
local_cache_name=local_cache_name,
dump_delta=dump_delta,
fact_for_delta=fact_for_delta,
keep_going=keep_going,
quiet=quiet,
)
c = r['cost']
m = r['nmappings']
logger.info('"{}" - "{}": CMR=({}/{})'.format(file1, file2, c, m))
fvs0 = []
fvs1 = []
if len(fact_versions) == 2 and load_fact:
fvs0 = [fact_versions[0]]
fvs1 = [fact_versions[1]]
fpr0 = []
fpr1 = []
if len(fact_proj_roots) == 2 and load_fact:
fpr0 = [fact_proj_roots[0]]
fpr1 = [fact_proj_roots[1]]
count_opts['fact_versions'] = fvs0
count_opts['fact_proj_roots'] = fpr0
d_nnodes1 = count_nodes([file1], **count_opts)
count_opts['fact_versions'] = fvs1
count_opts['fact_proj_roots'] = fpr1
d_nnodes2 = count_nodes([file2], **count_opts)
nnodes1 += d_nnodes1
nnodes2 += d_nnodes2
nnodes += d_nnodes1 + d_nnodes2
cost += c
nmappings += m
nrelabels += r['nrelabels']
except Exception as e:
logger.warning('{}'.format(str(e)))
t = time.time() - st_time
m = t / 60.0
ncomp = len(modified)
logger.info('"{}" - "{}" --> {} comparisons ({} min.)'.format(
dir1, dir2, ncomp, m))
res = {
'cost': cost,
'ncomparisons': ncomp,
'nmappings': nmappings,
'nnodes1': nnodes1,
'nnodes2': nnodes2,
'nnodes': nnodes,
'nrelabels': nrelabels,
}
if line_sim and line_sim_count > 0:
res['line_sim'] = line_sim_sum / line_sim_count
return res
for n in range(0, N):
# random factor between (1-d) and (1+d)
factor = ((1.0 - d) + np.random.rand() * (2 * d))
Pref0 = 32 * 1.0 * factor
Pref1 = 32 * 0.5 * factor
Pref2 = 32 * 0.5 * factor
Pref3 = 32 * 0.25 * factor
Qref0 = 32 * 0.0 * factor
Qref1 = 32 * 0.0 * factor
Qref2 = 32 * 0.2 * factor
Qref3 = 32 * 0.2 * factor
Pref.append((Pref0, Pref1, Pref2, Pref3))
Qref.append((Qref0, Qref1, Qref2, Qref3))
(t, states, P, Q) = sim(Pref[0], Qref[0])
for n in range(1, N):
(tn, statesn, Pn, Qn) = sim(Pref[n], Qref[n])
P = P + Pn
Q = Q + Qn
for i, state in enumerate(states):
if (i > 0):
states[i] = states[i] + statesn[i]
# plot results
plt.figure(1)
plt.plot(t, states[0], color='b')
plt.xlabel('Time (sec)')
plt.ylabel('Angle mod 2*pi (rad)')
plt.title('Grid Angle')
def doSim(model, reps, repe, dir):
for rep in range(reps, repe):
sims = sim(dir + "/" + model + ".conf")
write(dir + "/" + model + rep + ".sim", sims)
write(dir + "/" + model + rep + ".gen", sims) #???
#coding=utf8
import sim
import baidu
f_sim = sim.sim()
f_sim.sim_init('mkb3new.txt')
def writeonly(txt):
ss = txt.encode("utf-8")
baidu.q = ss
tr = baidu.GetTrans()
st = tr[(tr.find('dst') + 6):(tr.find('"', tr.find('dst') + 6))]
result = f_sim.calc_sim(st)
return result[1]
if prun:
f_P.make_fake_data()
if ndirun:
f_NDI.make_fake_data()
if jdrun:
f_DI.make_fake_data()
#####################
#######Save Fake Data
# if not os.path.exists(work_dir+ 'data/fake_data'):
# os.mkdir(work_dir+ 'data/fake_data')
if prun:
f_P.save_fake_data(P_plots_dir + 'FD'+fake_tag+'.txt.gz')
f_P.save_fake_data_key(P_plots_dir + 'FD_key'+fake_tag+'.txt.gz')
if ndirun:
f_NDI.save_fake_data(NDI_plots_dir + 'FD'+fake_tag+'.txt.gz')
f_NDI.save_fake_data_key(NDI_plots_dir + 'FD_key'+fake_tag+'.txt.gz')
if jdrun:
f_DI.save_fake_data(DI_plots_dir + 'FD'+fake_tag+'.txt.gz')
f_DI.save_fake_data_key(DI_plots_dir + 'FD_key'+fake_tag+'.txt.gz')
if do_sim:
sim()
return _thunk
'''
# Select Device
use_cuda = torch.cuda.is_available()
device = torch.device("cuda" if use_cuda else "cpu")
# Vector Envs
envs = [make_env(i) for i in range(num_envs)]
envs = SubprocVecEnv(envs)
# Test Env
with open("sim-config.yaml", "r") as handle:
sim_config = yaml.load(handle)
env = sim(sim_config)
#env = gym.make("CartPole-v0")
# Network
class ActorCritic(nn.Module):
def __init__(self, num_inputs, num_outputs, hidden_size):
super(ActorCritic, self).__init__()
self.critic = nn.Sequential(nn.Linear(num_inputs, hidden_size),
nn.ReLU(), nn.Linear(hidden_size, 1))
self.actor = nn.Sequential(nn.Linear(num_inputs, hidden_size),
nn.ReLU(),
nn.Linear(hidden_size, num_outputs),
import numpy as np
import sim
from math import pi
import graph as g
k = 1.0
betas1 = np.array([10.0 * pi / 180] * 10)
sim.betas = betas1
print(sim.betas)
log = sim.sim()
# print(log)
s = log.shape
J1 = log[s[0] - 1, 1]**2
djdb = 5.0 * pi / 180
while True:
sim.betas = sim.betas - k * djdb
print(sim.betas)
log = sim.sim()
# print(log)
s = log.shape
J2 = log[s[0] - 1, 1]**2
# print((sim.betas-betas1))
djdb = (J2 - J1) / ((sim.betas - betas1))
print(J2, djdb)
def ypp_sim_strategy(home, away):
drives = 1000
home_score = sim.sim(ypp[home]['dist'], drives)
away_score = sim.sim(ypp[away]['dist'], drives)
return away if away_score > home_score else home
# ctg_idx = pool.run_one_iter(thresh)
# new_ctg = ctg1 if ctg_idx == 0 else ctg2
# new_err = err_fn(ctg1, ctg2)
#
# pbar.set_postfix_str(f"err: {new_err}")
# if np.abs((new_err - err) / err) < .00001 and err < err_tol * 10:
# break
# err = new_err
# if err < err_tol:
# break
#
# if (1+i) % 100 == 0:
# state_space.data[0] = new_ctg
# p = sim(f"outputs/videos/output_epoch_{1+i}", (0,0,0,0), env, state_space, action_space, thresh)
# np.save(f"outputs/precompute/new_new_ctg_{resolution}", new_ctg)
#
# pool.close()
#
# state_space.data[0] = new_ctg
# np.save(f"outputs/precompute/new_new_ctg_{resolution}", state_space.data[0])
# simulate
procs = []
for idx, start_state in enumerate([(0, 0, 0, 0), (pi, 0, 0, 0), (pi / 2., 0, 0 ,0), (1, 0, 0, 0)]):
#p = sim(f"outputs/videos/output_{idx}", start_state, env, state_space, action_space)
#procs.append(p)
p = sim(f"outputs/videos/natural_{idx}", start_state, env)
procs.append(p)
[p.join() for p in procs]
