def test_empty_collate(tmpdir):
# Set up a fresh campaign called "cannon"
my_campaign = uq.Campaign(name='cannon', work_dir=tmpdir)
# Define parameter space for the cannonsim app
params = {
"angle": {
"type": "float",
"min": 0.0,
"max": 6.28,
"default": 0.79
},
"air_resistance": {
"type": "float",
"min": 0.0,
"max": 1.0,
"default": 0.2
},
"height": {
"type": "float",
"min": 0.0,
"max": 1000.0,
"default": 1.0
},
"time_step": {
"type": "float",
"min": 0.0001,
"max": 1.0,
"default": 0.01
},
"gravity": {
"type": "float",
"min": 0.0,
"max": 1000.0,
"default": 9.8
},
"mass": {
"type": "float",
"min": 0.0001,
"max": 1000.0,
"default": 1.0
},
"velocity": {
"type": "float",
"min": 0.0,
"max": 1000.0,
"default": 10.0
}
}
# Create an encoder, decoder and collater for the cannonsim app
encoder = uq.encoders.GenericEncoder(
template_fname='tests/cannonsim/test_input/cannonsim.template',
delimiter='#',
target_filename='in.cannon')
decoder = uq.decoders.SimpleCSV(
target_filename='output.csv',
output_columns=['Dist', 'lastvx', 'lastvy'],
header=0)
collater = uq.collate.AggregateSamples(average=False)
# Add the cannonsim app
my_campaign.add_app(name="cannonsim",
params=params,
encoder=encoder,
decoder=decoder,
collater=collater)
# Set the active app to be cannonsim (this is redundant when only one app
# has been added)
my_campaign.set_app("cannonsim")
# Set up samplers
vary = {
"gravity": cp.Uniform(9.8, 1.0),
"mass": cp.Uniform(2.0, 10.0),
}
sampler = uq.sampling.RandomSampler(vary=vary, max_num=5)
# Set the campaign to use this sampler
my_campaign.set_sampler(sampler)
# Test reloading
my_campaign.save_state(tmpdir + "test_multisampler.json")
reloaded_campaign = uq.Campaign(state_file=tmpdir +
"test_multisampler.json",
work_dir=tmpdir)
# Draw all samples
my_campaign.draw_samples()
# Encode
my_campaign.populate_runs_dir()
# Do an early collation, before anything has been executed. This means the collation element
# may attempt to add an empty dataframe to the database (which will cause issues upon subsequent
# collates due to an empty set of columns (Issue 163).
my_campaign.collate()
# Execute
my_campaign.apply_for_each_run_dir(
uq.actions.ExecuteLocal(
"tests/cannonsim/bin/cannonsim in.cannon output.csv"))
# Attempt to collate() again, now that the runs have been executed. If Issue 163 is not
# fixed then an error will occur here.
my_campaign.collate()
print("data:", my_campaign.get_collation_result())
pprint(my_campaign._log)
"margin_error": 0.25,
},
"Ti_boundary": {
"type": "float",
"distribution": "Normal",
"margin_error": 0.25,
}
}
# For the output: quantities of intersts
output_columns = ["Te", "Ti"]
# Initialize Campaign object
print('>>> Initialize Campaign object')
campaign_name = "uq_ets"
my_campaign = uq.Campaign(name=campaign_name, work_dir=tmp_dir)
# Create new directory for inputs (to be ended with /)
campaign_dir = my_campaign.campaign_dir
common_dir = campaign_dir +"/common/"
os.system("mkdir " + common_dir)
# Copy input CPO files (cf test_ets.f90)
os.system("cp " + cpo_dir + "/*.cpo " + common_dir)
# Copy XML and XSD files
os.system("cp " + xml_dir + "/ets.xml " + common_dir)
os.system("cp " + xml_dir + "/ets.xsd " + common_dir)
# Create the encoder and get the app parameters
print('>>> Create the encoder')
ets_run = os.path.abspath("../bin/" + SYS + "/ets_run ")
#uncertain_params = ["D1", "D2", "D3", "D4"]#, "Te_boundary", "Ti_boundary"]
uncertain_params = ["Te_boundary", "Ti_boundary"]
# Define parameter space
print('Define parameter space')
params = {k: {"type": "float", "default": "0."} for k in uncertain_params}
params.update({"out_file": {"type": "string", "default": "output.csv"}})
output_filename = params["out_file"]["default"]
output_columns = ["Te", 'Ti']
# Initialize Campaign object
print('Initialize Campaign object')
my_campaign = uq.Campaign(name='uq_ets', work_dir=tmp_dir)
# Copy XML files needed in the ETS wrappers
campaign_dir = my_campaign.campaign_dir
os.system("mkdir " + campaign_dir + "/workflows")
os.system("cp ../../workflows/ets.xml " + campaign_dir + "/workflows")
os.system("cp ../../workflows/ets.xsd " + campaign_dir + "/workflows")
# Copy CPO files in common directory
common_dir = campaign_dir + "/common/"
os.system("mkdir " + common_dir)
os.system("cp " + cpo_dir + "/*.cpo " + common_dir)
# Create an encoder and decoder
encoder = uq.encoders.GenericEncoder(template_fname='inputs/ets.template',
delimiter='#',
def flee_analyse_PCE(config, ** args):
'''
============================================================================
fab <remote_machine> flee_analyse_PCE:<conflict_name>
example:
fab eagle_vecma flee_analyse_PCE:mali
============================================================================
'''
load_campaign_files()
# reload Campaign
campaign = uq.Campaign(state_file=os.path.join(work_dir_PCESampler,
"campaign_state.json"),
work_dir=work_dir_PCESampler
)
print('========================================================')
print('Reloaded campaign', campaign._campaign_dir)
print('========================================================')
sampler = campaign.get_active_sampler()
campaign.set_sampler(sampler)
# fetch only the required folder from remote machine
with_config(config)
# fetch results from remote machine
job_label = campaign._campaign_dir
job_folder_name = template(env.job_name_template + "_{}".format(job_label))
print("fetching results from remote machine ...")
with hide('output', 'running', 'warnings'), settings(warn_only=True):
fetch_results(regex=job_folder_name)
print("Done\n")
# copy only output folder into local campaign_dir :)
src = os.path.join(env.local_results, job_folder_name, 'RUNS')
des = os.path.join(work_dir_PCESampler, campaign._campaign_dir, 'SWEEP')
print("Syncing output_dir ...")
with hide('output', 'running', 'warnings'), settings(warn_only=True):
local(
"rsync -av -m -v \
--include='/*/' \
--include='out.csv' \
--exclude='*' \
{}/ {} ".format(src, des)
)
print("Done\n")
campaign.collate()
# Return dataframe containing all collated results
collation_result = campaign.get_collation_result()
collation_result.to_csv(os.path.join(work_dir_PCESampler,
'collation_result.csv'
),
index=False
)
print(collation_result)
# Post-processing analysis
analysis = uq.analysis.PCEAnalysis(
sampler=campaign._active_sampler,
qoi_cols=output_columns
)
campaign.apply_analysis(analysis)
results = campaign.get_last_analysis()
# --------------------------------------------------------------------------
# Plotting
# --------------------------------------------------------------------------
analysis_log_file = os.path.join(work_dir_PCESampler, 'analysis_log.txt')
for output_column in output_columns:
fig = plt.figure()
ax = fig.add_subplot(111,
xlabel="days", ylabel=output_column)
mean = results["statistical_moments"][output_column]["mean"]
std = results["statistical_moments"][output_column]["std"]
ax.plot(mean)
ax.plot(mean + std, '--r')
ax.plot(mean - std, '--r')
#ax.title.set_text('statistical_moments for {}'.format(output_column))
plt.tight_layout()
plt.savefig(os.path.join(
work_dir_PCESampler, 'plot_statistical_moments_{}'.format(output_column)),
dpi=400)
# analysis.plot_grid()
'''
plot_grid(analysis, ['max_move_speed',
'max_walk_speed'],
os.path.join(work_dir_PCESampler, 'analysis_plot_grid')
)
'''
original = sys.stdout
with open(analysis_log_file, 'w') as file:
sys.stdout = custom_redirection(sys.stdout, file)
print(config)
# print(analysis.samples)
print('mean Total error = %f' % (mean))
print('std Total error = %f' % (std))
print('=================================================')
print('percentiles:')
print(results['percentiles'][output_column])
print('sobols_first:')
print(results['sobols_first'][output_column])
print('=================================================')
sys.stdout = original
def test_anisotropic_order(tmpdir):
# Set up a fresh campaign called "sc"
my_campaign = uq.Campaign(name='sc', work_dir=tmpdir, db_location='sqlite:///')
# Define parameter space
params = {
"Pe": {
"type": "float",
"min": 1.0,
"max": 2000.0,
"default": 100.0},
"f": {
"type": "float",
"min": 0.0,
"max": 10.0,
"default": 1.0},
"out_file": {
"type": "string",
"default": "output.csv"}}
output_filename = params["out_file"]["default"]
output_columns = ["u"]
# Create an encoder, decoder and collation element
encoder = uq.encoders.GenericEncoder(
template_fname='tests/sc/sc.template',
delimiter='$',
target_filename='ade_in.json')
decoder = uq.decoders.SimpleCSV(target_filename=output_filename,
output_columns=output_columns,
header=0)
collater = uq.collate.AggregateSamples()
# Add the SC app (automatically set as current app)
my_campaign.add_app(name="sc",
params=params,
encoder=encoder,
decoder=decoder,
collater=collater)
# Create the sampler
vary = {
"Pe": cp.Uniform(100.0, 200.0),
"f": cp.Uniform(0.95, 1.05)
}
# different orders for the 2 parameters
my_sampler = uq.sampling.SCSampler(vary=vary, polynomial_order=[2, 5],
quadrature_rule="G")
# Associate the sampler with the campaign
my_campaign.set_sampler(my_sampler)
# Will draw all (of the finite set of samples)
my_campaign.draw_samples()
my_campaign.populate_runs_dir()
# Use this instead to run the samples using EasyVVUQ on the localhost
my_campaign.apply_for_each_run_dir(uq.actions.ExecuteLocal(
"tests/sc/sc_model.py ade_in.json"))
my_campaign.collate()
# Post-processing analysis
analysis = uq.analysis.SCAnalysis(sampler=my_sampler, qoi_cols=output_columns)
my_campaign.apply_analysis(analysis)
#import pickle
#pickle.dump(analysis, open('analysis.p', 'wb'))
results = my_campaign.get_last_analysis()
return results, my_sampler, analysis
from shutil import rmtree
work_dir = os.path.dirname(os.path.abspath(__file__))
campaign_work_dir = os.path.join(work_dir, "easyvvuq_gp")
# clear the target campaign dir
if os.path.exists(campaign_work_dir):
rmtree(campaign_work_dir)
os.makedirs(campaign_work_dir)
# Set up a fresh campaign called "coffee_pce"
db_location = "sqlite:///" + campaign_work_dir + "/campaign.db"
my_campaign = uq.Campaign(
name="coffee_pce",
db_location=db_location,
work_dir=campaign_work_dir
)
# Define parameter space
params = {
"temp_init": {"type": "float", "min": 0.0, "max": 100.0, "default": 95.0},
"kappa": {"type": "float", "min": 0.0, "max": 0.1, "default": 0.025},
"t_env": {"type": "float", "min": 0.0, "max": 40.0, "default": 15.0},
"out_file": {"type": "string", "default": "output.csv"}
}
# Create an encoder, decoder and collater for PCE test app
encoder = uq.encoders.GenericEncoder(
template_fname="cooling.template",
delimiter="$",
"""
@author: Federica Gugole
__license__ = "LGPL"
"""
import chaospy as cp
import easyvvuq as uq
import os, subprocess
#home dir of this file
HOME = os.path.abspath(os.path.dirname(__file__))
# Set up a fresh campaign
workdir = '/export/scratch2/home/federica/'
campaign = uq.Campaign(name='virsim_PO_bio_', work_dir=workdir)
# Define parameter space
params = {
"seed": {
"type": "integer", # set to "float" when using MCSampler
"min": 0,
"max": 2**31,
"default": 12345
},
"trace_prob_E": {
"type": "float",
"min": 0.0,
"max": 1.0,
"default": .6
},
def flee_analyse_vvp_LoR(config):
"""
flee_analyse_vvp_LoR will analysis the output of each vvp ensemble series
usage example:
fab localhost flee_analyse_vvp_LoR:mali
"""
update_environment()
#############################################
# load flee vvp configuration from yml file #
#############################################
flee_VVP_config_file = os.path.join(
get_plugin_path("FabFlee"),
"VVP",
"flee_VVP_config.yml"
)
VVP_campaign_config = load_VVP_campaign_config(flee_VVP_config_file)
polynomial_order_range = range(
VVP_campaign_config["polynomial_order_range"]["start"],
VVP_campaign_config["polynomial_order_range"]["end"],
VVP_campaign_config["polynomial_order_range"]["step"]
)
sampler_name = VVP_campaign_config["sampler_name"]
###########################################
# set a default dir to save results sobol #
###########################################
sobol_work_dir = os.path.join(
get_plugin_path("FabFlee"),
"VVP",
"flee_vvp_LoR_{}_{}".format(sampler_name, config),
"sobol"
)
###################################
# delete sobol_work_dir is exists #
###################################
if os.path.exists(sobol_work_dir):
rmtree(sobol_work_dir)
os.makedirs(sobol_work_dir)
for polynomial_order in polynomial_order_range:
campaign_name = "flee_vvp_LoR_{}_po{}_{}_".format(
sampler_name,
polynomial_order,
config
)
campaign_work_dir = os.path.join(
get_plugin_path("FabFlee"),
"VVP",
"flee_vvp_LoR_{}_{}".format(sampler_name, config),
"campaign_po{}".format(polynomial_order)
)
load_campaign_files(campaign_work_dir)
###################
# reload Campaign #
###################
db_location = "sqlite:///" + campaign_work_dir + "/campaign.db"
campaign = uq.Campaign(name=campaign_name, db_location=db_location)
print("===========================================")
print("Reloaded campaign {}".format(campaign_name))
print("===========================================")
sampler = campaign.get_active_sampler()
campaign.set_sampler(sampler, update=True)
####################################################
# fetch results from remote machine #
# here, we ONLY fetch the required results folders #
####################################################
env.job_desc = "_vvp_LoR_{}_po{}".format(
sampler_name,
polynomial_order
)
with_config(config)
job_folder_name = template(env.job_name_template)
print("fetching results from remote machine ...")
with hide("output", "running", "warnings"), settings(warn_only=True):
fetch_results(regex=job_folder_name)
print("Done\n")
#####################################################
# copy ONLY the required output files for analyse, #
# i.e., EasyVVUQ.decoders.target_filename #
#####################################################
output_filename = VVP_campaign_config["params"]["out_file"]["default"]
src = os.path.join(env.local_results, job_folder_name, "RUNS")
des = campaign.campaign_db.runs_dir()
print("Syncing output_dir ...")
# with hide('output', 'running', 'warnings'), settings(warn_only=True):
local(
"rsync -pthrz "
"--include='/*/' "
"--include='{}' "
"--exclude='*' "
"{}/ {} ".format(output_filename, src, des)
)
print("Done ...\n")
#################################
# Create a decoder #
#################################
output_column = VVP_campaign_config["decoder_output_column"]
decoder = uq.decoders.SimpleCSV(
target_filename=output_filename,
output_columns=[output_column]
)
#####################
# execute collate() #
#####################
actions = uq.actions.Actions(
uq.actions.Decode(decoder)
)
campaign.replace_actions(campaign_name, actions)
campaign.execute().collate()
collation_result = campaign.get_collation_result()
##################################################
# save dataframe containing all collated results #
##################################################
collation_result.to_csv(
os.path.join(campaign_work_dir, "collation_result.csv"),
index=False
)
collation_result.to_pickle(
os.path.join(campaign_work_dir, "collation_result.pickle")
)
###################################
# Post-processing analysis #
###################################
if sampler_name == "SCSampler":
analysis = uq.analysis.SCAnalysis(
sampler=campaign._active_sampler,
qoi_cols=[output_column]
)
elif sampler_name == "PCESampler":
analysis = uq.analysis.PCEAnalysis(
sampler=campaign._active_sampler,
qoi_cols=[output_column]
)
campaign.apply_analysis(analysis)
results = campaign.get_last_analysis()
###################
# Plotting #
###################
fig_desc = "polynomial_order = {}, num_runs = {}, sampler = {}".format(
polynomial_order,
campaign.campaign_db.get_num_runs(),
sampler_name
)
props = dict(boxstyle="round", facecolor="wheat", alpha=0.5)
########################
# Plot raw data #
########################
output_files = glob.glob(
os.path.join(campaign_work_dir + "/**/%s" % (output_filename)),
recursive=True
)
fig, ax = plt.subplots()
ax.set_xlabel("days")
ax.set_ylabel(output_column)
fig.suptitle(
"RAW data : column {}\n".format(output_column),
fontsize=10, fontweight="bold"
)
ax.set_title(
fig_desc, fontsize=8, loc="center",
fontweight="bold", bbox=props
)
for output_file in output_files:
total_errors = pd.read_csv(output_file)[
output_column].values.tolist()
ax.plot(total_errors)
plot_file_name = "raw[{}]".format(output_column)
plt.savefig(os.path.join(campaign_work_dir, plot_file_name),
dpi=400)
###################################
# Plot statistical_moments #
###################################
fig, ax = plt.subplots()
ax.set_xlabel("days")
ax.set_ylabel("velocity {}".format(output_column))
fig.suptitle(
"code mean +/- standard deviation\n",
fontsize=10, fontweight="bold"
)
ax.set_title(
fig_desc, fontsize=8, loc="center",
fontweight="bold", bbox=props
)
mean = results.describe(output_column, "mean")
std = results.describe(output_column, "std")
X = range(len(mean))
ax.plot(X, mean, "b-", label="mean")
ax.plot(X, mean - std, "--r", label="+1 std-dev")
ax.plot(X, mean + std, "--r")
ax.fill_between(X, mean - std, mean + std, color="r", alpha=0.2)
# plt.tight_layout()
plt.legend(loc="best")
plot_file_name = "plot_statistical_moments[{}]".format(output_column)
plt.savefig(os.path.join(campaign_work_dir, plot_file_name),
dpi=400)
###################################
# Plot sobols_first #
###################################
fig, ax = plt.subplots()
ax.set_xlabel("days")
ax.set_ylabel("Sobol indices")
fig.suptitle(
"First order Sobol index [output column = {}]\n".format(
output_column),
fontsize=10, fontweight="bold"
)
ax.set_title(
fig_desc, fontsize=8, loc='center',
fontweight='bold', bbox=props
)
sobols_first = results.raw_data["sobols_first"][output_column]
param_i = 0
for v in sobols_first:
y = sobols_first[v].ravel()
important = False
if y[-1] != 0:
ax.plot(y, label=v)
else:
print("%s ignored for plotting" % (v))
param_i = param_i + 1
plt.legend(loc='best')
# plt.tight_layout()
plot_file_name = 'plot_sobols_first[%s]' % (output_column)
plt.savefig(os.path.join(campaign_work_dir, plot_file_name),
dpi=400)
###############################################################
# yml_results contains all campaign info and analysis results #
# it will be saved in sobols.yml file #
###############################################################
S = ruamel.yaml.scalarstring.DoubleQuotedScalarString
yml_results = ruamel.yaml.comments.CommentedMap()
yml_results.update({'campaign_info': {}})
yml_results['campaign_info'].update({
'name': S(campaign._active_app_name),
'work_dir': S(campaign.work_dir),
'num_runs': campaign.campaign_db.get_num_runs(),
'output_column': S(output_column),
'polynomial_order': polynomial_order,
'sampler': S(VVP_campaign_config['sampler_name']),
'distribution_type': S(VVP_campaign_config['distribution_type']),
'sparse': S(VVP_campaign_config['sparse']),
'growth': S(VVP_campaign_config['growth'])
})
if sampler_name == 'SCSampler':
yml_results['campaign_info'].update({
'quadrature_rule': S(VVP_campaign_config['quadrature_rule']),
'midpoint_level1': S(VVP_campaign_config['midpoint_level1']),
'dimension_adaptive': S(VVP_campaign_config
['dimension_adaptive'])
})
elif sampler_name == 'PCESampler':
yml_results['campaign_info'].update({
'rule': S(VVP_campaign_config['quadrature_rule']),
})
ROUND_NDIGITS = 4
for param in VVP_campaign_config['selected_vary_parameters']:
# I used CommentedMap for adding comments
yml_results[param] = ruamel.yaml.comments.CommentedMap()
# yml_results.update({param: {}})
yml_results[param].update({
"sobols_first_mean":
round(float(np.mean(sobols_first[param].ravel())),
ROUND_NDIGITS),
"sobols_first_gmean":
round(float(gmean(sobols_first[param].ravel())),
ROUND_NDIGITS),
"sobols_first":
np.around(sobols_first[param].ravel(),
ROUND_NDIGITS).tolist()
})
# add comments to yml
'''
yml_results[param].yaml_add_eol_comment(
"geometric mean, i.e., n-th root of (x1 * x2 * … * xn)",
"sobols_first_gmean")
yml_results[param].yaml_add_eol_comment(
"arithmetic mean i.e., (x1 + x2 + … + xn)",
"sobols_first_mean")
'''
yml_results[param].yaml_set_comment_before_after_key(
"sobols_first_gmean",
before="geometric mean, i.e., n-th root of (x1 * x2 * … * xn)",
indent=2)
yml_results[param].yaml_set_comment_before_after_key(
"sobols_first_mean",
before="arithmetic mean i.e., (x1 + x2 + … + xn)/n",
indent=2)
yaml = ruamel.yaml.YAML()
yaml.preserve_quotes = True
yaml.default_flow_style = None
# to Prevent long lines getting wrapped in ruamel.yaml
# we set the yaml.width to a big enough value to prevent line-wrap
yaml.width = sys.maxsize
res_file_name = os.path.join(campaign_work_dir, 'sobols.yml')
print(res_file_name)
with open(res_file_name, 'w') as outfile:
yaml.dump(yml_results, outfile)
'''
yaml.dump(yml_results, outfile,
default_flow_style=None, width=1000)
'''
########################################
# copy sobols.yml file to sobol folder #
########################################
print("copy sobols.yml file to sobol folder ...")
# here instead of mkdirs and copy, I used rsync
local(
"rsync -pthrz "
"--include='/*/' "
"--include='sobols.yml' "
"--include='*.png' "
"--exclude='*' "
"{} {} ".format(campaign_work_dir, sobol_work_dir)
)
print("Done ...\n")
#####################################################
# Check the convergence of the SC Sobols indices #
# with polynomial refinement #
#####################################################
ensemble_vvp_LoR(
results_dirs_PATH=sobol_work_dir,
load_QoIs_function=load_QoIs_function,
aggregation_function=plot_convergence,
plot_file_path=sobol_work_dir
)
def init_VVP_campaign(campaign_name, campaign_config,
polynomial_order, campaign_work_dir):
######################################
# delete campaign_work_dir is exists #
######################################
if os.path.exists(campaign_work_dir):
rmtree(campaign_work_dir)
os.makedirs(campaign_work_dir)
#####################
# Create an encoder #
#####################
encoder = uq.encoders.GenericEncoder(
template_fname=os.path.join(get_plugin_path("FabFlee"),
"templates",
campaign_config["encoder_template_fname"]
),
delimiter=campaign_config["encoder_delimiter"],
target_filename=campaign_config["encoder_target_filename"]
)
###########################
# Set up a fresh campaign #
###########################
db_location = "sqlite:///" + campaign_work_dir + "/campaign.db"
actions = uq.actions.Actions(
uq.actions.CreateRunDirectory(root=campaign_work_dir, flatten=True),
uq.actions.Encode(encoder),
)
campaign = uq.Campaign(
name=campaign_name,
db_location=db_location,
work_dir=campaign_work_dir
)
################################
# Add the flee-vvp-Sampler app #
################################
campaign.add_app(
name=campaign_name,
params=campaign_config["params"],
actions=actions
)
######################
# parameters to vary #
######################
vary = {}
for param in campaign_config["selected_vary_parameters"]:
lower_value = campaign_config[
"vary_parameters_range"][param]["range"][0]
upper_value = campaign_config[
"vary_parameters_range"][param]["range"][1]
if campaign_config["distribution_type"] == "DiscreteUniform":
vary.update({param: cp.DiscreteUniform(lower_value, upper_value)})
elif campaign_config["distribution_type"] == "Uniform":
vary.update({param: cp.Uniform(lower_value, upper_value)})
####################
# create Sampler #
####################
sampler_name = campaign_config["sampler_name"]
if sampler_name == "SCSampler":
sampler = uq.sampling.SCSampler(
vary=vary,
polynomial_order=polynomial_order,
quadrature_rule=campaign_config["quadrature_rule"],
growth=campaign_config["growth"],
sparse=campaign_config["sparse"],
midpoint_level1=campaign_config["midpoint_level1"],
dimension_adaptive=campaign_config["dimension_adaptive"]
)
elif sampler_name == "PCESampler":
sampler = uq.sampling.PCESampler(
vary=vary,
polynomial_order=polynomial_order,
rule=campaign_config["quadrature_rule"],
sparse=campaign_config["sparse"],
growth=campaign_config["growth"]
)
# TODO: add other sampler here
###########################################
# Associate the sampler with the campaign #
###########################################
campaign.set_sampler(sampler)
#########################################
# draw all of the finite set of samples #
#########################################
campaign.execute().collate()
#########################################
# extract generated runs id by campaign #
#########################################
runs_dir = []
for _, run_info in campaign.campaign_db.runs(
status=uq.constants.Status.NEW
):
runs_dir.append(run_info["run_name"])
campaign_dir = campaign.campaign_db.campaign_dir()
######################################################
# backup campaign files, i.e, *.db, *.json, *.pickle #
######################################################
backup_campaign_files(campaign.work_dir)
print("=" * 50)
print("With user's specified parameters for {}".format(sampler_name))
print("campaign name : {}".format(campaign_name))
print("number of generated runs : {}".format(len(runs_dir)))
print("campaign dir : {}".format(campaign_work_dir))
print("=" * 50)
return runs_dir, campaign_dir
def test_cannonsim(tmpdir):
# Define parameter space for the cannonsim app
params = {
"angle": {
"type": "float",
"min": 0.0,
"max": 6.28,
"default": 0.79},
"air_resistance": {
"type": "float",
"min": 0.0,
"max": 1.0,
"default": 0.2},
"height": {
"type": "float",
"min": 0.0,
"max": 1000.0,
"default": 1.0},
"time_step": {
"type": "float",
"min": 0.0001,
"max": 1.0,
"default": 0.01},
"gravity": {
"type": "float",
"min": 0.0,
"max": 1000.0,
"default": 9.8},
"mass": {
"type": "float",
"min": 0.0001,
"max": 1000.0,
"default": 1.0},
"velocity": {
"type": "float",
"min": 0.0,
"max": 1000.0,
"default": 10.0}}
# Create an encoder and decoder for the cannonsim app
encoder = uq.encoders.GenericEncoder(
template_fname='tests/cannonsim/test_input/cannonsim.template',
delimiter='#',
target_filename='in.cannon')
output_cols = ['Dist', 'lastvx', 'lastvy']
decoder = uq.decoders.SimpleCSV(
target_filename='output.csv', output_columns=output_cols, header=0)
# Create a collation element for this campaign
collater = uq.collate.AggregateByVariables(average=False)
# Make a random sampler
sweep = {
"angle": [0.1, 0.2, 0.3],
"height": [2.0, 10.0],
"velocity": [10.0, 10.1, 10.2]
}
sampler = uq.sampling.BasicSweep(sweep=sweep)
my_campaign = uq.Campaign(name='aggregate_by_var', work_dir=tmpdir)
my_campaign.add_app(name="cannon_test",
params=params,
encoder=encoder,
decoder=decoder,
collater=collater)
my_campaign.set_app("cannon_test")
sampler = uq.sampling.BasicSweep(sweep=sweep)
my_campaign.set_sampler(sampler)
my_campaign.draw_samples()
my_campaign.populate_runs_dir()
actions = uq.actions.ExecuteLocal("tests/cannonsim/bin/cannonsim in.cannon output.csv")
my_campaign.apply_for_each_run_dir(actions)
my_campaign.collate()
results = my_campaign.get_collation_result()
assert 'Variable' in results.columns
assert 'Value' in results.columns
n_runs = sampler.count
n_vars = len(output_cols)
assert len(results) == n_runs * n_vars
def flee_analyse_vvp_QoI(config):
"""
flee_analyse_vvp_LoR will analysis the output of each vvp ensemble series
usage example:
fab localhost flee_analyse_vvp_QoI:mali
fab training_hidalgo flee_analyse_vvp_QoI:mali
"""
update_environment()
#############################################
# load flee vvp configuration from yml file #
#############################################
flee_VVP_config_file = os.path.join(
get_plugin_path("FabFlee"),
"VVP",
"flee_VVP_config.yml"
)
VVP_campaign_config = load_VVP_campaign_config(flee_VVP_config_file)
polynomial_order = VVP_campaign_config["polynomial_order"]
sampler_name = VVP_campaign_config["sampler_name"]
campaign_name = "flee_VVP_{}_{}".format(sampler_name, config)
###########################################
# set a default dir to save results sobol #
###########################################
campaign_work_dir = os.path.join(
get_plugin_path("FabFlee"),
"VVP",
"flee_vvp_QoI_{}_PO{}_{}".format(
sampler_name, polynomial_order, config
),
)
###################
# reload Campaign #
###################
load_campaign_files(campaign_work_dir)
db_location = "sqlite:///" + campaign_work_dir + "/campaign.db"
campaign = uq.Campaign(name=campaign_name, db_location=db_location)
print("===========================================")
print("Reloaded campaign {}".format(campaign_name))
print("===========================================")
sampler = campaign.get_active_sampler()
campaign.set_sampler(sampler, update=True)
####################################################
# fetch results from remote machine #
# here, we ONLY fetch the required results folders #
####################################################
env.job_desc = "_vvp_QoI_{}_PO{}".format(
sampler_name,
polynomial_order
)
with_config(config)
job_folder_name = template(env.job_name_template)
print("fetching results from remote machine ...")
with hide("output", "running", "warnings"), settings(warn_only=True):
fetch_results(regex=job_folder_name)
print("Done\n")
#####################################################
# copy ONLY the required output files for analyse, #
# i.e., EasyVVUQ.decoders.target_filename #
#####################################################
src = os.path.join(env.local_results, job_folder_name, "RUNS")
des = campaign.campaign_db.runs_dir()
print("Syncing output_dir ...")
# with hide('output', 'running', 'warnings'), settings(warn_only=True):
local(
"rsync -pthrz "
"--include='/*/' "
"--include='out_uncertainty.csv' "
"--include='out.csv' "
"--exclude='*' "
"{}/ {} ".format(src, des)
)
print("Done ...\n")
#########################
# find output csv files #
#########################
out_csv_files = glob.glob(des + '/**/out.csv', recursive=True)
uncertainty_csv_files = glob.glob(des + '/**/out_uncertainty.csv',
recursive=True)
###########################################################
# take the number of refugees number by day per each camp #
###########################################################
pd_out_csv = []
for csv_file in out_csv_files:
pd_csv = pd.read_csv(csv_file)
pd_csv = pd_csv.drop(
[column_name
for column_name in pd_csv.columns.values
if " sim" not in column_name and column_name != "Day"
],
1
)
pd_out_csv.append(pd_csv)
pd_uncertainty_csv = []
for csv_file in uncertainty_csv_files:
pd_csv = pd.read_csv(csv_file)
pd_csv = pd_csv.drop(
[column_name
for column_name in pd_csv.columns.values
if " sim" not in column_name and column_name != "Day"
],
1
)
pd_uncertainty_csv.append(pd_csv)
QoIs = [column_name
for column_name in list(pd_out_csv[0].columns.values)
if column_name != "Day"
]
agg_input = {column_name: lambda x: list(x) for column_name in QoIs}
pd_out_csv = pd.concat(pd_out_csv, axis=0,
ignore_index=True
).groupby(['Day']).agg(agg_input)
pd_uncertainty_csv = pd.concat(pd_uncertainty_csv, axis=0,
ignore_index=True
).groupby(['Day']).agg(agg_input)
results = {}
for QoI in QoIs:
print("QoI = {}".format(QoI))
sim_result = pd_out_csv[QoI].tolist()
uncertainty_result = pd_uncertainty_csv[QoI].tolist()
res = ensemble_vvp_QoI(sim_result, uncertainty_result, QoI)
for key, value in res.items():
if key not in results:
results.update({key: {}})
results[key].update(value)
with open(os.path.join(campaign_work_dir, "results.json"), "w") as f:
f.write(json.dumps(results))
for similarity_measure_name, data in results.items():
# print(data)
print("=" * 50)
print("=" * 50)
print("=" * 50)
print("similarity_measure_name = {}".format(similarity_measure_name))
print("locations name : {}".format(data.keys()))
# find the number of rows and columns for subplots
size = len(data.keys())
cols = round(math.sqrt(size))
rows = cols
while rows * cols < size:
rows += 1
fig, ax_arr = plt.subplots(rows, cols, figsize=(8, 5))
fig.suptitle(
'similarity measure : {}'.format(similarity_measure_name),
fontsize=15
)
max_y = -float("inf")
ax_arr = ax_arr.reshape(-1)
for i, (location_name, values) in enumerate(data.items()):
print("location_name = {} max(values) = {}".format(
location_name, max(values))
)
ax_arr[i].plot(values)
ax_arr[i].set_xlim([1, len(values)])
ax_arr[i].set_title(
location_name, fontsize=10, fontweight='bold', loc='center'
)
for j in range(i + 1, rows * cols):
ax_arr[j].axis('off')
mng = plt.get_current_fig_manager()
mng.window.showMaximized()
fig.tight_layout()
plot_file_name = "vvp_QoI_{}.png".format(similarity_measure_name)
plt.savefig(os.path.join(campaign_work_dir, plot_file_name),
dpi=400)
def _campaign(work_dir, campaign_name, app_name, params, encoder, decoder, sampler,
collater, actions, stats, vary, num_samples=0, replicas=1, db_type='sql',
call_fn=None):
my_campaign = uq.Campaign(name=campaign_name, work_dir=work_dir, db_type=db_type)
logging.debug("Serialized encoder: %s", str(encoder.serialize()))
logging.debug("Serialized decoder: %s", str(decoder.serialize()))
logging.debug("Serialized collation: %s", str(collater.serialize()))
# Add the cannonsim app
my_campaign.add_app(name=app_name,
params=params,
encoder=encoder,
decoder=decoder,
collater=collater)
my_campaign.set_app(app_name)
logging.debug("Serialized sampler: %s", str(sampler.serialize()))
# Set the campaign to use this sampler
my_campaign.set_sampler(sampler)
# Draw 5 samples
my_campaign.draw_samples(num_samples=num_samples, replicas=replicas)
# Print the list of runs now in the campaign db
logging.debug("List of runs added:")
logging.debug(pformat(my_campaign.list_runs()))
logging.debug("---")
# Encode all runs into a local directory
logging.debug(pformat(
f"Encoding all runs to campaign runs dir {my_campaign.get_campaign_runs_dir()}"))
my_campaign.populate_runs_dir()
assert(len(my_campaign.get_campaign_runs_dir()) > 0)
assert(os.path.exists(my_campaign.get_campaign_runs_dir()))
assert(os.path.isdir(my_campaign.get_campaign_runs_dir()))
if call_fn is not None:
my_campaign.call_for_each_run(call_fn)
# Local execution
if actions is not None:
my_campaign.apply_for_each_run_dir(actions)
# Collate all data into one pandas data frame
my_campaign.collate()
logging.debug("data: %s", str(my_campaign.get_collation_result()))
# Save the state of the campaign
state_file = work_dir + "{}_state.json".format(app_name)
my_campaign.save_state(state_file)
my_campaign = None
# Load state in new campaign object
reloaded_campaign = uq.Campaign(state_file=state_file, work_dir=work_dir)
reloaded_campaign.set_app(app_name)
# Draw 3 more samples, execute, and collate onto existing dataframe
logging.debug("Running 3 more samples...")
reloaded_campaign.draw_samples(num_samples=num_samples, replicas=replicas)
logging.debug("List of runs added:")
logging.debug(pformat(reloaded_campaign.list_runs()))
logging.debug("---")
reloaded_campaign.populate_runs_dir()
if call_fn is not None:
reloaded_campaign.call_for_each_run(call_fn)
if actions is not None:
reloaded_campaign.apply_for_each_run_dir(actions)
logging.debug("Completed runs:")
logging.debug(pformat(reloaded_campaign.scan_completed()))
logging.debug("All completed? %s", str(reloaded_campaign.all_complete()))
reloaded_campaign.collate()
logging.debug("data:\n %s", str(reloaded_campaign.get_collation_result()))
logging.debug(reloaded_campaign)
# Create a BasicStats analysis element and apply it to the campaign
if stats is not None:
reloaded_campaign.apply_analysis(stats)
logging.debug("stats:\n %s", str(reloaded_campaign.get_last_analysis()))
# Print the campaign log
logging.debug(pformat(reloaded_campaign._log))
logging.debug("All completed? %s", str(reloaded_campaign.all_complete()))
def __init__(self, campaign_name, work_dir, db_type='sql'):
self.campaign = uq.Campaign(name=campaign_name, work_dir=work_dir, db_type=db_type)
import numpy as np
import easyvvuq as uq
import os
import matplotlib.pyplot as plt
plt.close('all')
# author: Wouter Edeling
__license__ = "LGPL"
# home directory of user
home = os.path.expanduser('~')
HOME = os.path.abspath(os.path.dirname(__file__))
# Set up a fresh campaign called "sc"
my_campaign = uq.Campaign(name='sc', work_dir='/tmp')
# Define parameter space
params = {
"Pe": {
"type": "float",
"min": 1.0,
"max": 2000.0,
"default": 100.0
},
"f": {
"type": "float",
"min": 0.0,
"max": 10.0,
"default": 1.0
},
def run_sc_samples(work_dir):
# Set up a fresh campaign called "sc"
my_campaign = uq.Campaign(name='ocean', work_dir=work_dir)
# Define parameter space
params = {
"decay_time_nu": {
"type": "float",
"min": 0.0,
"max": 1000.0,
"default": 5.0},
"decay_time_mu": {
"type": "float",
"min": 0.0,
"max": 1000.0,
"default": 90.0},
"out_file": {
"type": "string",
"default": "output.csv"}}
output_filename = params["out_file"]["default"]
output_columns = ["E_mean", "Z_mean", "E_std", "Z_std"]
# Create an encoder, decoder and collation element for PCE test app
encoder = uq.encoders.GenericEncoder(
template_fname= HOME + '/sc/ocean.template',
delimiter='$',
target_filename='ocean_in.json')
decoder = uq.decoders.SimpleCSV(target_filename=output_filename,
output_columns=output_columns,
header=0)
collater = uq.collate.AggregateSamples(average=False)
# Add the SC app (automatically set as current app)
my_campaign.add_app(name="sc",
params=params,
encoder=encoder,
decoder=decoder,
collater=collater)
# Create the sampler
vary = {
"decay_time_nu": cp.Uniform(1.0, 5.0),
"decay_time_mu": cp.Uniform(85.0, 95.0)
}
my_sampler = uq.sampling.SCSampler(vary=vary, polynomial_order=2)
# Associate the sampler with the campaign
my_campaign.set_sampler(my_sampler)
# Will draw all (of the finite set of samples)
my_campaign.draw_samples()
my_campaign.populate_runs_dir()
#Run execution using Fabsim
fab.run_uq_ensemble(my_campaign.campaign_dir, 'ocean', machine='localhost')
#Save the Campaign
my_campaign.save_state("campaign_state.json")
},
uparams[1]: {
"type": "real",
"default": "180."
},
"out_file": {
"type": "str",
"default": "output.csv"
}
}
output_filename = params["out_file"]["default"]
output_columns = ["te", "ti"]
# Initialize Campaign object
my_campaign = uq.Campaign(name='uq_boundaries', work_dir=tmp_dir)
# Copy XML files needed in the ETS, CHEASE and BOHMGB wrappers
campaign_dir = my_campaign.campaign_dir
os.system("mkdir " + campaign_dir + "/workflows")
os.system("cp ../../workflows/ets.xml " + campaign_dir + "/workflows")
os.system("cp ../../workflows/ets.xsd " + campaign_dir + "/workflows")
os.system("cp ../../workflows/chease.xml " + campaign_dir + "/workflows")
os.system("cp ../../workflows/chease.xsd " + campaign_dir + "/workflows")
os.system("cp ../../workflows/bohmgb.xml " + campaign_dir + "/workflows")
os.system("cp ../../workflows/bohmgb.xsd " + campaign_dir + "/workflows")
# Copy CPO files in common directory
common_dir = campaign_dir + "/common/"
os.system("mkdir " + common_dir)
os.system("cp " + cpo_dir + "/*.cpo " + common_dir)
import chaospy as cp
import easyvvuq as uq
import os, subprocess
import fabsim3_cmd_api as fab
config = 'virsim'
script = 'virsim_FC'
machine = 'eagle_vecma'
workdir = '/export/scratch1/federica/VirsimCampaigns'
#home dir of this file
HOME = os.path.abspath(os.path.dirname(__file__))
# Set up a fresh campaign called "corona"
campaign = uq.Campaign(name='virsim_FC', work_dir=workdir)
# Define parameter space
params = {
"seed": {
"type": "float",
"min": 0,
"max": 2**31,
"default": 12345
},
"trace_prob_E": {
"type": "float",
"min": 0.0,
"max": 1.0,
"default": .6
},
import chaospy as cp
import numpy as np
import easyvvuq as uq
import matplotlib.pyplot as plt
import os
import fabsim3_cmd_api as fab
# author: Wouter Edeling
__license__ = "LGPL"
#home dir of this file
HOME = os.path.abspath(os.path.dirname(__file__))
# Set up a fresh campaign called "sc"
my_campaign = uq.Campaign(name='corona', work_dir='/tmp')
# Define parameter space
params = {
"incubation": {
"type": "float",
"min": 1.0,
"max": 10.0,
"default": 5.2
},
"r0": {
"type": "float",
"min": 1.0,
"max": 10.0,
"default": 2.5
},
"out_file": {
axis=0)
idx_sort_descend_1st = np.argsort(sobol[:, 0], axis=0)[::-1]
sobol = sobol[idx_sort_descend_1st, :]
sobol_idx_bool = sobol_idx_bool[idx_sort_descend_1st]
sobol_idx = [0 for _ in range(sobol_idx_bool.shape[0])]
for i_sobol in range(sobol_idx_bool.shape[0]):
sobol_idx[i_sobol] = np.array(
[i for i, x in enumerate(sobol_idx_bool[i_sobol, :]) if x])
var = ((coefficients[1:]**2).sum(axis=0))
sobol = sobol / var
return sobol, sobol_idx, sobol_idx_bool
# Read an old campaign
time_start = time.time()
old_campaign = uq.Campaign(state_file="campaign_state.json", work_dir=".")
time_end = time.time()
print('Time for phase 1 = %.3f' % (time_end - time_start))
time_start = time.time()
results_df = old_campaign.get_collation_result()
time_end = time.time()
print('Time for phase 2 = %.3f' % (time_end - time_start))
# Post-processing analysis
time_start = time.time()
analysis = uq.analysis.PCEAnalysis(sampler=old_campaign.get_active_sampler(),
qoi_cols=["te", "ne", "rho", "rho_norm"],
sampling=False)
old_campaign.apply_analysis(analysis)
time_end = time.time()
},
uparams[5]: {
"type": "real",
"default": "0.2"
},
"out_file": {
"type": "str",
"default": "output.csv"
}
}
output_filename = params["out_file"]["default"]
output_columns = ["te", "ti"]
# Initialize Campaign object
my_campaign = uq.Campaign(name='uq_sources', work_dir=tmp_dir)
# Copy XML files needed in the ETS, CHEASE and BOHMGB codes
campaign_dir = my_campaign.campaign_dir
os.system("mkdir " + campaign_dir + "/workflows")
os.system("cp ../../workflows/ets.xml " + campaign_dir + "/workflows")
os.system("cp ../../workflows/ets.xsd " + campaign_dir + "/workflows")
os.system("cp ../../workflows/chease.xml " + campaign_dir + "/workflows")
os.system("cp ../../workflows/chease.xsd " + campaign_dir + "/workflows")
os.system("cp ../../workflows/bohmgb.xml " + campaign_dir + "/workflows")
os.system("cp ../../workflows/bohmgb.xsd " + campaign_dir + "/workflows")
os.system("cp ../../workflows/source_dummy_new.xml " + campaign_dir +
"/workflows/source_dummy.xml")
os.system("cp ../../workflows/source_dummy.xsd " + campaign_dir + "/workflows")
# Copy CPO files in common directory
def adaptive_campaign():
d = 3
number_of_adaptations = 3
campaign = uq.Campaign(name='sc', work_dir='/tmp')
params = {}
for i in range(d):
params["x%d" % (i + 1)] = {"type": "float",
"min": 0.0,
"max": 1.0,
"default": 0.5}
params["out_file"] = {"type": "string", "default": "output.csv"}
output_filename = params["out_file"]["default"]
output_columns = ["f"]
# Create an encoder, decoder and collation element
encoder = uq.encoders.GenericEncoder(
template_fname='tests/sc/poly_model_anisotropic.template',
# template_fname='./sc/poly_model_anisotropic.template',
delimiter='$',
target_filename='poly_in.json')
decoder = uq.decoders.SimpleCSV(target_filename=output_filename,
output_columns=output_columns)
execute = ExecuteLocal(os.path.abspath("tests/sc/poly_model_anisotropic.py") + " poly_in.json")
actions = Actions(CreateRunDirectory('/tmp'), Encode(encoder), execute, Decode(decoder))
# Add the SC app (automatically set as current app)
campaign.add_app(name="sc",
params=params,
actions=actions)
# Create the sampler
vary = {}
for i in range(d):
vary["x%d" % (i + 1)] = cp.Uniform(0, 1)
sampler = uq.sampling.SCSampler(vary=vary, polynomial_order=1,
quadrature_rule="C",
sparse=True, growth=True,
midpoint_level1=True,
dimension_adaptive=True)
campaign.set_sampler(sampler)
campaign.execute().collate()
data_frame = campaign.get_collation_result()
analysis = uq.analysis.SCAnalysis(sampler=sampler, qoi_cols=output_columns)
campaign.apply_analysis(analysis)
for i in range(number_of_adaptations):
sampler.look_ahead(analysis.l_norm)
campaign.execute().collate()
data_frame = campaign.get_collation_result()
analysis.adapt_dimension('f', data_frame)
campaign.apply_analysis(analysis)
logging.debug(analysis.l_norm)
logging.debug(sampler.admissible_idx)
results = campaign.get_last_analysis()
return sampler, analysis, results
"""
*****************
* VVUQ ANALYSES *
*****************
"""
config = 'virsim_CT'
script = 'virsim_CT'
machine = 'eagle_vecma'
workdir = '/export/scratch1/federica/VirsimCampaigns'
# home directory of this file
HOME = os.path.abspath(os.path.dirname(__file__))
# Reload the campaign
campaign = uq.Campaign(state_file = "campaign_state_CT_MC2k_newdistr.json", work_dir = workdir)
print('========================================================')
print('Reloaded campaign', campaign.campaign_dir.split('/')[-1])
print('========================================================')
# get sampler and output columns from my_campaign object
sampler = campaign._active_sampler
# print(type(sampler._samples))
# print(sampler._samples.shape)
output_columns = campaign._active_app_decoder.output_columns
fab.verify(config, campaign.campaign_dir,
campaign._active_app_decoder.target_filename,
machine=machine, PJ=True)
def flee_init_PCE(config, simulation_period=-1, mode='parallel', ** args):
'''
============================================================================
fab <remote_machine> flee_init_PCE:<conflict_name>,simulation_period=<number>
example:
fab eagle_vecma flee_init_PCE:mali,simulation_period=100
============================================================================
'''
# delete work_dir_PCESampler is exists
if os.path.exists(work_dir_PCESampler):
rmtree(work_dir_PCESampler)
os.mkdir(work_dir_PCESampler)
# Set up a fresh campaign called "flee-PCESampler"
campaign = uq.Campaign(name='flee-PCESampler',
work_dir=work_dir_PCESampler)
# to make sure we are not overwriting the new simulation on previous ones
job_label = campaign._campaign_dir
# Define parameter space for the flee-PCESampler app
params = json.load(open(os.path.join(get_plugin_path("FabFlee"),
'templates',
'params.json'
)
)
)
output_filename = params["out_file"]["default"]
encoder = uq.encoders.GenericEncoder(
template_fname=get_plugin_path("FabFlee") +
'/templates/simsetting.template',
delimiter='$',
target_filename='simsetting.csv'
)
decoder = uq.decoders.SimpleCSV(target_filename=output_filename,
output_columns=output_columns,
header=0)
# Create a collation element for this campaign
collater = uq.collate.AggregateSamples(average=True)
# Add the flee-PCESampler app
campaign.add_app(name="flee-PCESampler",
params=params,
encoder=encoder,
decoder=decoder,
collater=collater)
# parameters to vary
vary = {
"max_move_speed": cp.Uniform(100, 500),
"max_walk_speed": cp.Uniform(10, 100),
#"camp_move_chance": cp.Uniform(0.0, 0.1),
#"conflict_move_chance": cp.Uniform(0.1, 1.0),
#"default_move_chance": cp.Uniform(0.1, 1.0),
#"camp_weight": cp.Uniform(1.0, 10.0),
#"conflict_weight": cp.Uniform(0.1, 1.0)
}
# create PCESampler
sampler = uq.sampling.PCESampler(vary=vary,
polynomial_order=1
)
# Associate the sampler with the campaign
campaign.set_sampler(sampler)
# Will draw all (of the finite set of samples)
campaign.draw_samples()
run_ids = campaign.populate_runs_dir()
# copy generated run folders to SWEEP directory in config folder
# 1. clean config SWEEP dir
# 2. copy all generated runs by easyvvuq to config SWEEP folder
path_to_config = find_config_file_path(config)
sweep_dir = path_to_config + "/SWEEP"
if os.path.exists(sweep_dir):
rmtree(sweep_dir)
os.mkdir(sweep_dir)
print('=' * 20)
print("Copying easyvvuq runs to %s SWEEP folder ..." % (config))
with hide('output', 'running', 'warnings'), settings(warn_only=True):
local(
"rsync -av -m -v \
{}/ {} ".format(os.path.join(campaign.work_dir,
campaign.campaign_dir,
'SWEEP'), os.path.join(sweep_dir))
)
print("Done")
print('=' * 20)
if mode == 'serial':
flee_script = 'flee'
else:
flee_script = 'pflee'
if simulation_period == -1:
flee_ensemble(config,
script=flee_script,
label=job_label,
**args)
else:
flee_ensemble(config,
simulation_period,
script=flee_script,
label=job_label,
**args)
# save campaign and sampler state
campaign.save_state(os.path.join(
work_dir_PCESampler, "campaign_state.json"))
backup_campaign_files()
import easyvvuq as uq
import chaospy as cp
# 0. Setup some variables describing app to be run
#
# gauss.py is in current directory and takes one input file
# and writes to 'output.csv'.
cwd = os.getcwd()
input_filename = 'gauss_in.json'
cmd = f"{cwd}/gauss.py {input_filename}"
out_file = "output.csv"
# Template input to substitute values into for each run
template = f"{cwd}/gauss.template"
# 1. Create campaign
my_campaign = uq.Campaign(name='gauss', work_dir=".")
# 2. Parameter space definition
params = {
"sigma": {
"type": "float",
"min": 0.0,
"max": 100000.0,
"default": 0.25
},
"mu": {
"type": "float",
"min": 0.0,
"max": 100000.0,
"default": 1
},
from sklearn.neighbors.kde import KernelDensity
from scipy import stats
# author: Wouter Edeling
__license__ = "LGPL"
#post processing of UQ samples executed via FabSim. All samples must have been completed
#before this subroutine is executed. Use 'fabsim <machine_name> job_stat' to check their status
#home dir of this file
HOME = os.path.abspath(os.path.dirname(__file__))
# work_dir = home + "/VECMA/Campaigns/"
work_dir = '/tmp'
#Reload the campaign
my_campaign = uq.Campaign(state_file = 'campaign_state.json', work_dir = work_dir)
print('========================================================')
print('Reloaded campaign', my_campaign.campaign_dir.split('/')[-1])
print('========================================================')
#get sampler and output columns from my_campaign object
my_sampler = my_campaign.get_active_sampler()
output_columns = my_campaign._active_app_decoder.output_columns
#fetch the results from the (remote) host via FabSim3
fab.get_uq_samples(my_campaign.campaign_dir, machine='localhost')
#collate output
my_campaign.collate()
import chaospy as cp
from pprint import pprint
# 0. Setup some variables describing app to be run
#
# gauss.py is in current directory and takes one input file
# and writes to 'output.csv'.
cwd = os.getcwd()
input_filename = 'gauss_in.json'
cmd = f"{cwd}/gauss.py {input_filename}"
out_file = "output.csv"
# Template input to substitute values into for each run
template = f"{cwd}/gauss.template"
# 1. Create campaign
my_campaign = uq.Campaign(name='gauss', work_dir=".")
# 2. Parameter space definition
params = {
"sigma": {
"type": "float",
"min": 0.0,
"max": 100000.0,
"default": 0.25
},
"mu": {
"type": "float",
"min": 0.0,
"max": 100000.0,
"default": 1
},
from matplotlib.ticker import ScalarFormatter, NullFormatter
plt.rcParams.update({'font.size': 18, 'legend.fontsize': 15})
plt.rcParams['figure.figsize'] = 12,7
"""
*************
* Load data *
*************
"""
# home directory of this file
HOME = os.path.abspath(os.path.dirname(__file__))
# Reload the FC campaign without biology
workdir = '/export/scratch2/home/federica/'
campaign = uq.Campaign(state_file = "campaign_state_IL_nobio.json", work_dir = workdir)
print('========================================================')
print('Reloaded campaign', campaign.campaign_dir.split('/')[-1])
print('========================================================')
# get sampler and output columns from campaign object
sampler = campaign._active_sampler
#output_columns = campaign._active_app_decoder.output_columns
# collate output
campaign.collate()
# get full dataset of data
data = campaign.get_collation_result()
#print(data.columns)
"""
def test_pce(tmpdir):
# Set up a fresh campaign called "pce"
my_campaign = uq.Campaign(name='pce', work_dir=tmpdir)
# Define parameter space
params = {
"kappa": {
"type": "real",
"min": "0.0",
"max": "0.1",
"default": "0.025"
},
"t_env": {
"type": "real",
"min": "0.0",
"max": "40.0",
"default": "15.0"
},
"out_file": {
"type": "str",
"default": "output.csv"
}
}
output_filename = params["out_file"]["default"]
output_columns = ["te", "ti"]
# Create an encoder and decoder for PCE test app
encoder = uq.encoders.GenericEncoder(
template_fname='tests/cooling/cooling.template',
delimiter='$',
target_filename='cooling_in.json')
decoder = uq.decoders.SimpleCSV(target_filename=output_filename,
output_columns=output_columns,
header=0)
# Add the PCE app (automatically set as current app)
my_campaign.add_app(name="pce",
params=params,
encoder=encoder,
decoder=decoder)
# Create a collation element for this campaign
collater = uq.collate.AggregateSamples(average=False)
my_campaign.set_collater(collater)
# Create the sampler
vary = {"kappa": cp.Uniform(0.025, 0.075), "t_env": cp.Uniform(15, 25)}
my_sampler = uq.sampling.PCESampler(vary=vary, polynomial_order=3)
# Associate the sampler with the campaign
my_campaign.set_sampler(my_sampler)
# Will draw all (of the finite set of samples)
my_campaign.draw_samples()
my_campaign.populate_runs_dir()
my_campaign.apply_for_each_run_dir(
uq.actions.ExecuteLocal(
"tests/cooling/cooling_model.py cooling_in.json"))
my_campaign.collate()
# Update after here
# Post-processing analysis
my_analysis = uq.analysis.PCEAnalysis(sampler=my_sampler,
qoi_cols=output_columns)
my_campaign.apply_analysis(my_analysis)
results = my_campaign.get_last_analysis()
# Get Descriptive Statistics
stats = results['statistical_moments']['te']
per = results['percentiles']['te']
sobols = results['sobol_first_order']['te']
# Test saving and reloading campaign
#state_file = tmpdir + "pce_state.json"
#my_campaign.save_state(state_file)
#new = uq.Campaign(state_file=state_file, work_dir=tmpdir)
#print(new)
return stats, per, sobols
def encode(self, params={}, target_dir='', fixtures=None):
simulation_time = 10**params["equilibration2_time_power"]
params["n_steps_loop"] = int(
round(simulation_time / params["timestep"], -1))
params["n_steps"] = 15 * int(
round(simulation_time / params["timestep"], -1))
super().encode(params, target_dir, fixtures)
home = os.path.abspath(os.path.dirname(__file__))
#output_columns = ["drug","replica","binding_energy_avg","binding_energy_stdev"]
output_columns = ["binding_energy_avg"]
work_dir = '/hppfs/work/pn72qu/di36yax3/tmp/uq_namd2/campaigns'
campaign = uq.Campaign(state_file="namd_easyvvuq_state.json",
work_dir=work_dir)
print('========================================================')
print('Reloaded campaign', campaign.campaign_dir.split('/')[-1])
print('========================================================')
sampler = campaign.get_active_sampler()
sampler.load_state("namd_sampler_state.pickle")
campaign.set_sampler(sampler)
#get results
#fab.get_uq_samples(config, campaign.campaign_dir, sampler._number_of_samples,
# machine='eagle_vecma')
campaign.collate()
# Post-processing analysis
analysis = uq.analysis.SCAnalysis(sampler=campaign._active_sampler,
qoi_cols=output_columns)
def test_premature_run_addition(tmp_path):
with pytest.raises(Exception):
our_campaign = uq.Campaign(name='test', work_dir=tmp_path)
# Requires an active app to be set
our_campaign.add_runs([])
