def run_task(self, fw_spec):
if self.get('contents', None) is not None:
# where the template can be found
target = utils.dump_directory(
os.path.join(self.get('workdir', ''), 'template'), self['contents'])
return fw.FWAction(
update_spec={
# pass reference to this Treant to future Fireworks
'template': target,
}
)
else:
return fw.FWAction()
def run_rask(self, fw_spec):
# results are given as (T, P, mean, std, g)
results = (fw_spec['results_array'] + self.get('previous_results', []))
finished = self.decide_if_flat(results)
if not finished:
# issue detour with more pressures
return fw.FWAction(detours=self.make_detour(
previous=results,
nparallel=self['nparallel'],
))
else:
# continue to IsothermCreate
return fw.FWAction(update_spec={'results_array': results})
def run_task(self, fw_spec):
sim_t = self.copy_template(
workdir=self.get('workdir', ''),
simhash=fw_spec.get('simhash', ''),
template=fw_spec['template'],
P=self['pressure'],
T=self['temperature'],
p_id=self.get('parallel_id', 0),
)
# Modify input to match the spec
self.update_input(
target=sim_t,
fmt=self['fmt'],
T=self['temperature'],
P=self['pressure'],
n=self.get('ncycles', None),
)
if self.get('previous_simdir', None) is not None:
self.set_as_restart(
self['fmt'],
old=self['previous_simdir'],
new=sim_t,
)
return fw.FWAction(
update_spec={'simtree': os.path.abspath(sim_t)}
)
def run_task(self, fw_spec):
my_candidate = fw_spec['candidates'][self['candidate_id']]
updater = utils.unpickle_func(self['updater'])
updater(fw_spec['simtree'], my_candidate)
return fw.FWAction()
def run_task(self, fw_spec):
tarpath = self.write_tarball(fw_spec['template'].rstrip(os.path.sep),
self.get('workdir', ''))
# then rename tar according to hash of file
sha1 = self.calc_hash(tarpath)
os.rename(tarpath,
os.path.join(self.get('workdir', ''), '{}.tar.gz'.format(sha1)))
return fw.FWAction(update_spec={'simhash': sha1})
def run_task(self, fw_spec):
# merge candidates and fitness
children = self.collate(fw_spec['candidates'], fw_spec['fitness'])
new_parents = self.replace(fw_spec['parents'], children)
return fw.FWAction(
stored_data={
'candidates': children,
'population': new_parents,
},
update_spec={'parents': new_parents},
)
def run_task(self, fw_spec):
simtree = fw_spec['simtree']
# check exit
# will raise Error if simulation didn't finish
finished = self.check_exit(self['fmt'], simtree)
# parse results
results = self.parse_results(self['fmt'], simtree)
# save csv of results from *this* simulation
utils.save_csv(results, os.path.join(simtree, 'this_sim_results.csv'))
if self.get('previous_result', None) is not None:
results = self.prepend_previous(self['previous_result'], results)
# csv of results from all generations of this simulation
utils.save_csv(results, os.path.join(simtree, 'total_results.csv'))
if not finished:
new_fws = self.prepare_restart(
template=fw_spec['template']
previous_simdir=simtree,
current_result=results,
wfname=fw_spec['_category'],
)
return fw.FWAction(
detours=fw.Workflow(new_fws)
)
else:
parallel_id = self['parallel_id']
return fw.FWAction(
stored_data={'result': results.to_csv()},
mod_spec=[{
'_push': {
'results': (parallel_id, results.to_csv()),
'simpaths': (parallel_id, simtree),
}
}]
)
def run_task(self, fw_spec):
# create sorted version
results = sorted(fw_spec['results_array'],
key=lambda x: (x[0], x[1]))
outfile = os.path.join(self.get('workdir', ''), 'results.csv')
with open(outfile, 'w') as out:
out.write('temperature,pressure,mean,std,g\n')
for row in results:
out.write(','.join(str(val) for val in row))
out.write('\n')
return fw.FWAction(
stored_data={'final_result': results}
)
def run_task(self, fw_spec):
my_id = self['candidate_id']
# final fitness is sum of square of errors
my_fitness = sum(v**2 for v in fw_spec['error'])
f = (my_id, my_fitness)
return fw.FWAction(
stored_data={'fitness': f},
mod_spec=[{
'_push': {
'fitness': f
}
}],
)
def run_task(self, fw_spec):
result = self.grab_result(fw_spec['simtree'], self['fmt'])
ref = self['reference']
my_fitness = abs(result - ref) / ref
return fw.FWAction(
stored_data={'error': my_fitness},
mod_spec=[{
'_push': {
'error':
my_fitness,
'results_array':
(self['temperature'], self['pressure'], result, 1, 1),
}
}],
)
def run_task(self, fw_spec):
timeseries = {p_id: utils.make_series(ts)
for (p_id, ts) in fw_spec['results']}
simple = self.get('simple', True)
g = 0.0
means = []
stds = []
# starts True, turns false once a single sim wasn't equilibrated
equilibrated = True
for p_id, ts in timeseries.items():
try:
eq = analysis.find_eq(ts)
except NotEquilibratedError:
equilibrated &= False
production = ts.loc[eq:]
# how many eq periods have we sampled for?
g += (production.index[-1] - production.index[0]) / eq
means.append(production.mean())
stds.append(production.std())
if equilibrated and (simple or (g > 20.0)):
finished = True
mean = np.mean(means)
std = np.mean(stds)
else:
finished = False
if finished:
return fw.FWAction(
stored_data={'result': (mean, std)},
mod_spec=[{
# push the results of this condition to the Create task
'_push': {'results_array': (self['temperature'],
self['pressure'],
mean, std, g)}
}],
)
else:
# TODO: Calc N remaining here
# or estimate how many are required
if not equilibrated:
nreq = 'something'
else:
# make educated guess
nreq = 'something else'
return fw.FWAction(
detours=self.prepare_resample(
previous_simdirs={p_id: path
for (p_id, path) in fw_spec['simpaths']},
previous_results=timeseries,
ncycles=nreq,
wfname=fw_spec['_category'],
template=fw_spec['template'],
)
)
def run_task(self, fw_spec):
candidates = self.blend_crossover(fw_spec['candidates'])
candidates = self.gaussian_mutation(candidates)
return fw.FWAction(update_spec={'candidates': candidates})
def run_task(self, fw_spec):
candidates = self.tournament(fw_spec['parents'])
return fw.FWAction(update_spec={'candidates': candidates})
def run_task(self, fw_spec):
return fw.FWAction(update_spec={k: fw_spec[k] for k in self['keys']})
def run_task(self, fw_spec):
return fw.FWAction(
update_spec={
'candidates': self['initial_population'],
'parents': [] # no parents initially
})
