Retau = args.Retau
dt = args.dt
maxstep = args.maxstep
maxiter = args.maxiter
restart = args.restart
tol = args.tol
objective = args.objective
nsamples = args.nsamples
sigma_obs = 1e-10
sigma_prior = 0.5
dirname ="base_solution"
y, u, R11, R12, R22, R33, omega = load_solution_stressomega(dirname)
eqn = StressOmegaEquation(y, u, R11, R12, R22, R33, omega, Retau)
eqn.writedir = "/tmp"
# first dt can be large as we restart from a good solution
eqn.force_boundary = False
eqn.tol = tol
eqn.dt = 1e1
eqn.solve()
beta_prior = np.ones_like(eqn.beta)
eqn_prior = copy.deepcopy(eqn)
up_prior = eqn.up.copy()
Q_prior = np.zeros([np.size(eqn.q), nsamples])
sample = 0
while sample < nsamples:
print "\rSampling prior %i of %i"%(sample, nsamples),
from utils import load_data, load_solution_stressomega
from objectives import BayesianObjective
from inverse import InverseSolver
class BayesianObjectiveU(BayesianObjective):
def objective(self, val, param):
J_obs = sum((val[::6] - self.val_target)**2)/self.sigma_obs
J_prior = sum((param - self.param_prior)**2)/self.sigma_prior**2
J = 0.5*(J_obs + J_prior)
return J
dirname ="base_solution"
y, u, R11, R12, R22, R33, omega = load_solution_stressomega(dirname)
Retau = 5.467390699999999697e+02
eqn = StressOmegaEquation(y, u, R11, R12, R22, R33, omega, Retau)
eqn.writedir = "solution/stress_omega"
eqn.dt = 1e2
eqn.force_boundary = False
eqn.tol = 1e-5
eqn.solve()
eqn_prior = copy.deepcopy(eqn)
up_prior = eqn.up.copy()
dns = np.loadtxt("data/DNSsol.dat")
utau = Retau*eqn.nu*2.0
ydns = dns[:,0]*0.5
udns = dns[:,2]*utau
f = interp1d(ydns, udns)
utarget = f(eqn.y)
parser.add_argument("--maxstep", type=float, default=0.05, required=True, help="Inverse max step size.")
parser.add_argument("--maxiter", type=int, default=10, required=True, help="Inverse max number of iterations.")
parser.add_argument("--restart", action="store_true", help="Read beta and restart from previous state.")
args = parser.parse_args()
Retau = args.Retau
dt = args.dt
maxstep = args.maxstep
maxiter = args.maxiter
restart = args.restart
tol = args.tol
objective = args.objective
dirname ="base_solution"
y, u, R11, R12, R22, R33, omega = load_solution_stressomega(dirname)
eqn = StressOmegaEquation(y, u, R11, R12, R22, R33, omega, Retau)
eqn.writedir = "solution"
# first dt can be large as we restart from a good solution
eqn.dt = 1e1
eqn.force_boundary = False
eqn.tol = tol
eqn.solve()
eqn.dt = dt
eqn_prior = copy.deepcopy(eqn)
up_prior = eqn.up.copy()
qtarget = np.zeros_like(eqn.q)
dns, wilcox, wilcox_kw = load_data()
utau = Retau*eqn.nu*2.0
import sys
sys.path.insert(1, "../../src")
import matplotlib.pyplot as plt
import numpy as np
from stressomega import StressOmegaEquation, get_beta
from utils import load_data, load_solution_stressomega
dirname ="base_solution"
y, u, R11, R12, R22, R33, omega = load_solution_stressomega(dirname)
Retau = 550.0
eqn = StressOmegaEquation(y, u, R11, R12, R22, R33, omega, Retau)
eqn.writedir = "solution/stress_omega"
eqn.dt = 1e2
eqn.force_boundary = False
eqn.tol = 1e-7
eqn.solve()
dJdbeta = eqn.calc_sensitivity()
dns, wilcox, wilcox_kw = load_data()
dJdbeta_cs = np.zeros_like(dJdbeta)
dbeta = 1e-30
for i in range(len(dJdbeta)):
eqn.beta[i] = eqn.beta[i] + 1j*dbeta
eqn.solve()
dJdbeta_cs[i] = np.imag(eqn.objective.objective(eqn.q, eqn.beta))/dbeta
eqn.beta[i] = eqn.beta[i] - 1j*dbeta
plt.figure(4)
dJdbeta11, dJdbeta12, dJdbeta22, dJdbeta33 = get_beta(dJdbeta)
dJdbeta11_cs, dJdbeta12_cs, dJdbeta22_cs, dJdbeta33_cs = get_beta(dJdbeta_cs)
parser.add_argument("--maxstep", type=float, default=0.05, required=True, help="Inverse max step size.")
parser.add_argument("--maxiter", type=int, default=10, required=True, help="Inverse max number of iterations.")
parser.add_argument("--restart", action="store_true", help="Read beta and restart from previous state.")
args = parser.parse_args()
Retau = args.Retau
dt = args.dt
maxstep = args.maxstep
maxiter = args.maxiter
restart = args.restart
tol = args.tol
objective = args.objective
dirname ="base_solution"
y, u, R11, R12, R22, R33, omega = load_solution_stressomega(dirname)
eqn = StressOmegaEquation(y, u, R11, R12, R22, R33, omega, Retau)
eqn.writedir = "/tmp"
# first dt can be large as we restart from a good solution
eqn.dt = 1e1
eqn.force_boundary = False
eqn.tol = tol
eqn.dt = dt
eqn.solve()
eqn_prior = copy.deepcopy(eqn)
up_prior = eqn.up.copy()
dirname ="solution"
y, u, R11, R12, R22, R33, omega = load_solution_stressomega(dirname)
eqn = StressOmegaEquation(y, u, R11, R12, R22, R33, omega, Retau)
eqn.writedir = "solution"
# first dt can be large as we restart from a good solution
weight_R33 = 1/np.mean(self.val_target[4::6])
J_obs = sum((val[::6] - self.val_target[::6])**2)/self.sigma_obs**2 * abs(weight_u)**2
J_obs += sum((val[1::6] - self.val_target[1::6])**2)/self.sigma_obs**2 * abs(weight_R11)**2
J_obs += sum((val[2::6] - self.val_target[2::6])**2)/self.sigma_obs**2 * abs(weight_R12)**2
J_obs += sum((val[3::6] - self.val_target[3::6])**2)/self.sigma_obs**2 * abs(weight_R22)**2
J_obs += sum((val[4::6] - self.val_target[4::6])**2)/self.sigma_obs**2 * abs(weight_R33)**2
J_prior = sum((param - self.param_prior)**2)/self.sigma_prior**2
J = 0.5*(J_obs + J_prior)
return J
dirname ="base_solution"
y, u, R11, R12, R22, R33, omega = load_solution_stressomega(dirname)
Retau = 5.467390699999999697e+02
eqn = StressOmegaEquation(y, u, R11, R12, R22, R33, omega, Retau)
eqn.writedir = "solution/stress_omega"
eqn.dt = 1e0
eqn.force_boundary = False
eqn.tol = 1e-5
eqn.solve()
eqn_prior = copy.deepcopy(eqn)
up_prior = eqn.up.copy()
qtarget = np.zeros_like(eqn.q)
dns, wilcox, wilcox_kw = load_data()
utau = Retau*eqn.nu*2.0
ydns = dns.y*0.5
ub = dns.u*utau
R11b = -(dns.ub*utau)**2
