def main():
import argparse
parser = argparse.ArgumentParser(add_help=True)
addExtraArguments(parser)
mimc.MIMCRun.addOptionsToParser(parser)
mimcRun = mimc.MIMCRun(**vars(parser.parse_known_args()[0]))
if mimcRun.params.qoi_seed >= 0:
np.random.seed(mimcRun.params.qoi_seed)
fnItrDone = None
if mimcRun.params.db:
if hasattr(mimcRun.params, "db_user"):
db = mimcdb.MIMCDatabase(user=mimcRun.params.db_user,
host=mimcRun.params.db_host)
else:
db = mimcdb.MIMCDatabase(host=mimcRun.params.db_host)
run_id = db.createRun(mimc_run=mimcRun, tag=mimcRun.params.db_tag)
fnItrDone = lambda *a: db.writeRunData(run_id, mimcRun, *a)
mimcRun.setFunctions(fnSampleQoI=lambda *a: mySampleQoI(mimcRun, *a),
fnItrDone=fnItrDone)
try:
mimcRun.doRun()
except KeyboardInterrupt:
raise
except Exception as e:
if mimcRun.params.db:
print("Run failed", run_id, e)
db.markRunFailed(run_id)
raise
if mimcRun.params.db:
db.markRunSuccessful(run_id)
return mimcRun.data.calcEg()
def RunTest(mimcRun):
tStart = time.process_time()
try:
mimcRun.doRun()
except:
if hasattr(mimcRun.params, "db"):
db = mimcdb.MIMCDatabase(**__transform_db_args(mimcRun.params.db))
db.markRunFailed(mimcRun.db_data.run_id,
total_time=time.process_time() - tStart)
raise # If you don't want to raise, make sure the following code is not executed
if hasattr(mimcRun.params, "db"):
db = mimcdb.MIMCDatabase(**__transform_db_args(mimcRun.params.db))
db.markRunSuccessful(mimcRun.db_data.run_id,
total_time=time.process_time() - tStart)
return mimcRun
def main():
import argparse
parser = argparse.ArgumentParser(add_help=True)
addExtraArguments(parser)
import mimclib.test
args = mimclib.test.parse_known_args(parser)
db_args = dict()
if args.db_name is not None:
db_args["db"] = args.db_name
if args.db_user is not None:
db_args["user"] = args.db_user
if args.db_host is not None:
db_args["host"] = args.db_host
db = mimcdb.MIMCDatabase(**db_args)
if args.db_tag is None:
warnings.warn("You did not select a database tag!!")
run_data = db.readRuns(db.getRunsIDs(tag=args.db_tag, done_flag=1))
run_data = [
d for d in run_data if d.iteration_index + 1 == d.total_iterations
]
if len(run_data) == 0:
raise Exception("No runs!!!")
miplot.genPDFBooklet(run_data, fileName=args.o, exact=args.qoi_exact)
def RunStandardTest(fnSampleLvl=None,
fnAddExtraArgs=None,
fnInit=None,
fnSeed=np.random.seed,
profCalc=None):
import warnings
import os.path
import mimclib.mimc as mimc
import mimclib.db as mimcdb
warnings.formatwarning = lambda msg, cat, filename, lineno, line: \
"{}:{}: ({}) {}\n".format(os.path.basename(filename),
lineno, cat.__name__, msg)
import argparse
parser = argparse.ArgumentParser(add_help=True)
parser.register('type', 'bool', lambda v: v.lower() in
("yes", "true", "t", "1"))
parser.add_argument("-db_user",
type=str,
action="store",
help="Database User")
parser.add_argument("-db_password",
type=str,
action="store",
help="Database password")
parser.add_argument("-db_host",
type=str,
action="store",
help="Database Host")
parser.add_argument("-db_engine",
type=str,
default='mysql',
action="store",
help="Database Host")
parser.add_argument("-db_tag",
type=str,
default="NoTag",
action="store",
help="Database Tag")
parser.add_argument("-db",
type='bool',
default=False,
action="store",
help="Save in Database")
parser.add_argument("-qoi_seed",
type=int,
default=-1,
action="store",
help="Seed for random generator")
parser.add_argument("-db_name", type=str, action="store", help="")
if fnAddExtraArgs is not None:
fnAddExtraArgs(parser)
mimc.MIMCRun.addOptionsToParser(parser)
mimcRun = mimc.MIMCRun(**vars(parse_known_args(parser)))
fnSampleLvl = lambda inds, M, fn=fnSampleLvl: fn(mimcRun, inds, M)
mimcRun.setFunctions(fnSampleLvl=fnSampleLvl)
import time
tStart = time.time()
if fnInit is not None:
fnInit(mimcRun)
if mimcRun.params.qoi_seed >= 0 and fnSeed is not None:
fnSeed(mimcRun.params.qoi_seed)
fnItrDone = None
if mimcRun.params.db:
db_args = {}
if hasattr(mimcRun.params, "db_user"):
db_args["user"] = mimcRun.params.db_user
if hasattr(mimcRun.params, "db_password"):
db_args["passwd"] = mimcRun.params.db_password
if hasattr(mimcRun.params, "db_host"):
db_args["host"] = mimcRun.params.db_host
if hasattr(mimcRun.params, "db_engine"):
db_args["engine"] = mimcRun.params.db_engine
if hasattr(mimcRun.params, "db_name"):
db_args["db"] = mimcRun.params.db_name
db = mimcdb.MIMCDatabase(**db_args)
run_id = db.createRun(mimc_run=mimcRun, tag=mimcRun.params.db_tag)
fnItrDone = lambda: db.writeRunData(
run_id, mimcRun, iteration_idx=len(mimcRun.iters) - 1)
mimcRun.setFunctions(fnItrDone=fnItrDone)
try:
mimcRun.doRun()
except:
if mimcRun.params.db:
db.markRunFailed(run_id, totalTime=time.time() - tStart)
raise # If you don't want to raise, make sure the following code is not executed
if mimcRun.params.db:
db.markRunSuccessful(run_id, totalTime=time.time() - tStart)
return mimcRun.last_itr.calcEg()
def CreateStandardTest(fnSampleLvl=None,
fnSampleAll=None,
fnAddExtraArgs=None,
fnInit=None,
fnItrDone=None,
fnSeed=np.random.seed):
warnings.formatwarning = lambda msg, cat, filename, lineno, line: \
"{}:{}: ({}) {}\n".format(os.path.basename(filename),
lineno, cat.__name__, msg)
parser = argparse.ArgumentParser(add_help=True)
parser.add_argument("-db_user",
type=str,
action="store",
help="Database User",
dest="db.user")
parser.add_argument("-db_password",
type=str,
action="store",
help="Database password",
dest="db.password")
parser.add_argument("-db_host",
type=str,
action="store",
help="Database Host",
dest="db.host")
parser.add_argument("-db_engine",
type=str,
action="store",
help="Database Host",
dest="db.engine")
parser.add_argument("-db_tag",
type=str,
action="store",
help="Database Tag")
parser.add_argument("-qoi_seed",
type=int,
action="store",
help="Seed for random generator")
parser.add_argument("-db_name",
type=str,
action="store",
help="",
dest="db.db")
if fnAddExtraArgs is not None:
fnAddExtraArgs(parser)
mimc.MIMCRun.addOptionsToParser(parser)
mimcRun = mimc.MIMCRun(**vars(parse_known_args(parser)))
if fnSampleLvl is not None:
fnSampleLvl = lambda inds, M, fn=fnSampleLvl: fn(mimcRun, inds, M)
mimcRun.setFunctions(fnSampleLvl=fnSampleLvl)
else:
fnSampleAll = lambda lvls, M, moments, fn=fnSampleAll: \
fn(mimcRun, lvls, M, moments)
mimcRun.setFunctions(fnSampleAll=fnSampleAll)
if not hasattr(mimcRun.params, 'qoi_seed'):
mimcRun.params.qoi_seed = np.random.randint(2**32 - 1)
if fnInit is not None:
fnInit(mimcRun)
if fnSeed is not None:
fnSeed(mimcRun.params.qoi_seed)
if hasattr(mimcRun.params, "db"):
db = mimcdb.MIMCDatabase(**__transform_db_args(mimcRun.params.db))
mimcRun.db_data = mimc.Nestedspace()
mimcRun.db_data.run_id = db.createRun(mimc_run=mimcRun,
tag=mimcRun.params.db_tag)
if fnItrDone is None:
def ItrDone(db=db, r_id=mimcRun.db_data.run_id, r=mimcRun):
if r.is_itr_tol_satisfied(
): # Only save iterations that have tol satisifed
db.writeRunData(r_id, r, iteration_idx=len(r.iters) - 1)
return True
fnItrDone = ItrDone
else:
fnItrDone = lambda db=db, r_id=mimcRun.db_data.run_id, r=mimcRun, fn=fnItrDone: \
fn(db, r_id, r)
elif fnItrDone is not None:
fnItrDone = lambda r=mimcRun, fn=fnItrDone: \
fn(None, None, r)
mimcRun.setFunctions(fnItrDone=fnItrDone)
return mimcRun
def init_post_program():
from . import db as mimcdb
import argparse
import warnings
import os
warnings.formatwarning = lambda msg, cat, filename, lineno, line: \
"{}:{}: ({}) {}\n".format(os.path.basename(filename),
lineno, cat.__name__, msg)
try:
from matplotlib.cbook import MatplotlibDeprecationWarning
warnings.simplefilter('ignore', MatplotlibDeprecationWarning)
except:
pass # Ignore
parser = argparse.ArgumentParser(add_help=True)
parser.add_argument("-db_name",
type=str,
action="store",
help="Database Name",
dest="db.db")
parser.add_argument("-db_engine",
type=str,
action="store",
help="Database Name",
dest="db.engine")
parser.add_argument("-db_user",
type=str,
action="store",
help="Database User",
dest="db.user")
parser.add_argument("-db_host",
type=str,
action="store",
help="Database Host",
dest="db.host")
parser.add_argument("-db_password",
type=str,
action="store",
help="Database Password",
dest="db.password")
parser.add_argument("-db_tag",
type=str,
action="store",
help="Database Tags")
# parser.add_argument("-qoi_exact_tag", type=str, action="store")
# parser.add_argument("-qoi_exact", type=float, action="store", help="Exact value")
args = parse_known_args(parser)
db = mimcdb.MIMCDatabase(**__transform_db_args(args.db))
if not hasattr(args, "db_tag"):
warnings.warn("You did not select a database tag!!")
print("Reading data")
run_data = db.readRuns(tag=args.db_tag)
if len(run_data) == 0:
raise Exception("No runs!!!")
# fnNorm = run_data[0].fn.Norm
# if hasattr(args, "qoi_exact_tag"):
# assert args.qoi_exact is None, "Multiple exact values given"
# exact_runs = db.readRuns(tag=args.qoi_exact_tag)
# from . import plot
# args.qoi_exact, _ = plot.estimate_exact(exact_runs)
# print("Estimated exact value is {}".format(args.qoi_exact))
# if fnExactErr is not None:
# fnExactErr = lambda itrs, r=exact_runs[0], fn=fnExactErr: fn(r, itrs)
# elif fnExactErr is not None:
# fnExactErr = lambda itrs, fn=fnExactErr: fn(itrs[0].parent, itrs)
# if hasattr(args, "qoi_exact") and fnExactErr is None:
# fnExactErr = lambda itrs, e=args.qoi_exact: \
# fnNorm([v.calcEg() + e*-1 for v in itrs])
#print("Updating errors")
return db, run_data
def RunStandardTest(fnSampleQoI=None,
fnSampleLvl=None,
fnAddExtraArgs=None,
fnInit=None,
fnSeed=np.random.seed):
import warnings
import os.path
import mimclib.mimc as mimc
import mimclib.db as mimcdb
warnings.formatwarning = lambda msg, cat, filename, lineno, line: \
"{}:{}: ({}) {}\n".format(os.path.basename(filename),
lineno, cat.__name__, msg)
import argparse
parser = argparse.ArgumentParser(add_help=True)
parser.register('type', 'bool', lambda v: v.lower() in
("yes", "true", "t", "1"))
parser.add_argument("-db_user",
type=str,
action="store",
help="Database User")
parser.add_argument("-db_host",
type=str,
default='localhost',
action="store",
help="Database Host")
parser.add_argument("-db_tag",
type=str,
default="NoTag",
action="store",
help="Database Tag")
parser.add_argument("-db",
type='bool',
default=False,
action="store",
help="Save in Database")
parser.add_argument("-qoi_seed",
type=int,
default=-1,
action="store",
help="Seed for random generator")
if fnAddExtraArgs is not None:
fnAddExtraArgs(parser)
mimc.MIMCRun.addOptionsToParser(parser)
mimcRun = mimc.MIMCRun(**vars(parse_known_args(parser)))
if fnInit is not None:
fnInit(mimcRun)
if mimcRun.params.qoi_seed >= 0 and fnSeed is not None:
fnSeed(mimcRun.params.qoi_seed)
fnItrDone = None
if mimcRun.params.db:
if hasattr(mimcRun.params, "db_user"):
db = mimcdb.MIMCDatabase(user=mimcRun.params.db_user,
host=mimcRun.params.db_host)
else:
db = mimcdb.MIMCDatabase(host=mimcRun.params.db_host)
run_id = db.createRun(mimc_run=mimcRun, tag=mimcRun.params.db_tag)
fnItrDone = lambda *a: db.writeRunData(run_id, mimcRun, *a)
if fnSampleQoI is not None:
fnSampleQoI = lambda inds, fn=fnSampleQoI: fn(mimcRun, inds)
if fnSampleLvl is not None:
fnSampleLvl = lambda moments, mods, inds, M, fn=fnSampleLvl, *a: fn(
mimcRun, moments, mods, inds, M)
mimcRun.setFunctions(fnSampleQoI=fnSampleQoI,
fnSampleLvl=fnSampleLvl,
fnItrDone=fnItrDone)
try:
mimcRun.doRun()
except:
if mimcRun.params.db:
db.markRunFailed(run_id)
raise # If you don't want to raise, make sure the following code is not executed
if mimcRun.params.db:
db.markRunSuccessful(run_id)
return mimcRun.data.calcEg()