def ensemble_seed_test():
import os
import numpy as np
import pyemu
pst = pyemu.Pst(os.path.join("pst","pest.pst"))
cov = pyemu.Cov.from_parameter_data(pst)
pe1 = pyemu.ParameterEnsemble(pyemu.Pst(os.path.join("pst","pest.pst")))
pe2 = pyemu.ParameterEnsemble(pyemu.Pst(os.path.join("pst","pest.pst")))
pe1.reseed()
pe1.draw(cov,num_reals=10)
#np.random.seed(1111)
pe2.reseed()
pe2.draw(cov,num_reals=10)
assert (pe1-pe2).apply(np.abs).as_matrix().max() == 0.0
print(pe1.head())
print(pe2.head())
pe2.draw(cov,num_reals=10)
print(pe2.head())
assert (pe1-pe2).apply(np.abs).as_matrix().max() != 0.0
pe1.reseed()
pe1.draw(cov,num_reals=10,how="uniform")
pe2.reseed()
pe2.draw(cov,num_reals=10,how="uniform")
assert (pe1-pe2).apply(np.abs).as_matrix().max() == 0.0
def scale_offset_test():
import os
import pyemu
pst = pyemu.Pst(os.path.join("pst","scale_offest_test.pst"))
par = pst.parameter_data
print(par)
en1 = pyemu.ParameterEnsemble(pst)
en1.draw(pyemu.Cov.from_parameter_data(pst),num_reals=1000)
en2 = pyemu.ParameterEnsemble(pst)
en2.draw(cov=None,num_reals=1000,how="uniform")
print(en1)
print(en2)
def parrep_test():
import pyemu
import pandas as pd
import numpy as np
# make some fake parnames and values
parnames = ['p_{0:03}'.format(i) for i in range(20)]
np.random.seed(42)
parvals = np.random.random(20) + 5
parvals[0] = 0.001
# make a fake parfile
with open('fake.par','w') as ofp:
ofp.write('single point\n')
[ofp.write('{0:10s} {1:12.6f} 1.00 0.0\n'.format(i,j)) for i,j in zip(parnames,parvals)]
# make a fake ensemble parameter file
np.random.seed(99)
parens = pd.DataFrame(np.tile(parvals,(5,1))+np.random.randn(5,20)*.5, columns=parnames)
parens.index = list(range(4)) + ['base']
parens.index.name = 'real_name'
parens.loc['base'] = parvals[::-1]
# get cheeky and reverse the column names to test updating
parens.columns = parens.columns.sort_values(ascending = False)
parens.to_csv('fake.par.0.csv')
parens.drop('base').to_csv('fake.par.0.nobase.csv')
# and make a fake pst file
pst = pyemu.pst_utils.generic_pst(par_names=parnames)
pst.parameter_data['parval1'] = [float(i+1) for i in range(len(parvals))]
pst.parameter_data['parlbnd'] = 0.01
pst.parameter_data['parubnd'] = 100.01
pyemu.ParameterEnsemble(pst=pst,df=parens).to_binary('fake_parens.jcb')
# test the parfile style
pst.parrep('fake.par')
assert pst.parameter_data.parval1[0] == pst.parameter_data.parlbnd[0]
assert np.allclose(pst.parameter_data.iloc[1:].parval1.values,parvals[1:],atol=0.0001)
assert pst.control_data.noptmax == 0
pst.parrep('fake.par', noptmax=99, enforce_bounds=False)
assert np.allclose(pst.parameter_data.parval1.values,parvals,atol=0.0001)
assert pst.control_data.noptmax == 99
# now test the ensemble style
pst.parrep('fake.par.0.csv')
assert pst.parameter_data.parval1[0] == pst.parameter_data.parlbnd[0]
assert np.allclose(pst.parameter_data.iloc[1:].parval1.values,parvals[1:],atol=0.0001)
pst.parrep('fake.par.0.nobase.csv')
# flip the parameter ensemble back around
parens = parens[parens.columns.sort_values()]
assert np.allclose(pst.parameter_data.parval1.values[:-1],parens.T[0].values[:-1],atol=0.0001)
pst.parrep('fake.par.0.csv', real_name=3)
# flip the parameter ensemble back around
parens = parens[parens.columns.sort_values()]
assert np.allclose(pst.parameter_data.parval1.values[:-1],parens.T[3].values[:-1],atol=0.0001)
pst.parrep('fake_parens.jcb', real_name=2)
# confirm binary format works as csv did
assert np.allclose(pst.parameter_data.parval1.values[:-1],parens.T[2].values[:-1],atol=0.0001)
def binary_test():
from datetime import datetime
import numpy as np
import pandas as pd
import pyemu
npar = 100000
nobs = 500
par_names = ["p{0}".format(i) for i in range(npar)]
obs_names = ["o{0}".format(i) for i in range(nobs)]
arr = np.random.random((nobs,npar))
pst = pyemu.Pst.from_par_obs_names(par_names,obs_names)
df = pd.DataFrame(data=arr,columns=par_names,index=obs_names)
pe = pyemu.ParameterEnsemble(pst=pst,df=df)
s1 = datetime.now()
pe.to_dense("par.bin")
pe1 = pyemu.ParameterEnsemble.from_binary(pst=pst,filename="par.bin")
e1 = datetime.now()
d = (pe - pe1).apply(np.abs)
print(d.max().max())
assert d.max().max() < 1.0e-10
s2 = datetime.now()
pe.to_binary("par.bin")
pe1 = pyemu.ParameterEnsemble.from_binary(pst=pst,filename="par.bin")
e2 = datetime.now()
print((e1 - s1).total_seconds())
print((e2 - s2).total_seconds())
def pnulpar_test():
import os
import pyemu
dir = "mc"
mc = pyemu.MonteCarlo(jco=os.path.join("mc","freyberg_ord.jco"))
par_dir = os.path.join("mc","prior_par_draws")
par_files = [os.path.join(par_dir,f) for f in os.listdir(par_dir) if f.endswith('.par')]
mc.parensemble.read_parfiles(par_files)
real_num = [int(os.path.split(f)[-1].split('.')[0].split('_')[1]) for f in par_files]
mc.parensemble.index = real_num
#print(mc.parensemble)
print(mc.parensemble.istransformed)
en = mc.project_parensemble(nsing=1,inplace=False, enforce_bounds='reset')
#en.index = [i+1 for i in en.index]
print(mc.parensemble.istransformed)
par_dir = os.path.join("mc", "proj_par_draws")
par_files = [os.path.join(par_dir, f) for f in os.listdir(par_dir) if f.endswith('.par')]
real_num = [int(os.path.split(f)[-1].split('.')[0].split('_')[1]) for f in par_files]
en_pnul = pyemu.ParameterEnsemble(mc.pst)
en_pnul.read_parfiles(par_files)
en_pnul.index = real_num
en.sort_index(axis=1, inplace=True)
en.sort_index(axis=0, inplace=True)
en_pnul.sort_index(axis=1, inplace=True)
en_pnul.sort_index(axis=0, inplace=True)
diff = 100.0 * ((en - en_pnul) / en)
assert max(diff.max()) < 1.0e-4
def pnulpar_test():
pst = pyemu.Pst(ord_base+".pst")
# load the pnulpar projected ensemble
pnul_en = pyemu.ParameterEnsemble(pst)
pnul_en.read_parfiles_prefix(os.path.join(verf_dir,"proj_par_draws","draw_"))
pnul_en.loc[:,"fname"] = pnul_en.index
pnul_en.index = pnul_en.fname.apply(lambda x:str(int(x.split('.')[0].split('_')[-1])))
f = pnul_en.pop("fname")
mc = pyemu.MonteCarlo(jco=ord_base+".jco")
mc.parensemble.read_parfiles_prefix(os.path.join(verf_dir,"prior_par_draws","draw_"))
mc.parensemble.loc[:,"fname"] = mc.parensemble.index
mc.parensemble.index = mc.parensemble.fname.apply(lambda x:str(int(x.split('.')[0].split('_')[-1])))
f = mc.parensemble.pop("fname")
en = mc.project_parensemble(nsing=1,inplace=False)
diff = 100 * (np.abs(pnul_en - en) / en)
assert max(diff.max()) < 1.0e-3
# In[4]:
exe = os.path.join("exe", "pnulpar.exe")
args = [
ord_base + ".pst", "y", "5", "y", "pnulpar_qhalfx.mat", parfile_base,
projparfile_base
]
in_file = os.path.join("misc", "pnulpar.in")
with open(in_file, 'w') as f:
f.write('\n'.join(args) + '\n')
os.system(exe + ' <' + in_file)
# In[5]:
pnul_en = pyemu.ParameterEnsemble(mc.pst)
parfiles = [
os.path.join(proj_dir, f) for f in os.listdir(proj_dir)
if f.endswith(".par")
]
pnul_en.read_parfiles(parfiles)
# In[6]:
pnul_en.loc[:, "fname"] = pnul_en.index
pnul_en.index = pnul_en.fname.apply(
lambda x: str(int(x.split('.')[0].split('_')[-1])))
f = pnul_en.pop("fname")
# In[7]:
import os
import pyemu
pst = pyemu.Pst(os.path.join("freyberg.pst"))
par_dir = "proj_par_draws"
par_files = [
os.path.join(par_dir, f) for f in os.listdir(par_dir) if f.endswith(".par")
]
en = pyemu.ParameterEnsemble(pst)
en.read_parfiles(par_files)
sys.exit()
