def runBCS(self):
pcmodel = self.pcModel
x_uq = mkSetDbl2D(self.x_np)
# Should this be the original LHS points or the actual physical parameters that we fed into the model?
y_uq = mkSetDbl1D(self.y_np)
eta = 1.e-9
adpt = 0
optml = 1
scl = 0.1
verb = -1
for iters in range(1, self.nBCS + 1):
print 'Starting BCS ' + str(iters)
self.nPCT = pcmodel.GetNumberPCTerms()
phi_uq = mkBlnkDbl2D()
midx_uq = mkBlnkInt2D()
sgm2_uq = mkSetDblRef((np.std(self.y_np)**2) / 1.0e6)
lmbdInit_uq = mkBlnkDbl1D()
wghts_uq = mkBlnkDbl1D()
usd_uq = mkBlnkInt1D()
errBrs_uq = mkBlnkDbl1D()
basis_uq = mkBlnkDbl1D()
alpha_uq = mkBlnkDbl1D()
lmbd_uq = mkDblRef()
newMIdx_uq = mkBlnkInt2D()
# evalulate pc model to get phi
pcmodel.EvalBasisAtCustPts(x_uq, phi_uq)
self.phi_np = uqtk2NumpyDbl(phi_uq)
self.saveDat(self.phi_np, 'phi_' + str(iters) + '.dat')
# Perform BCS
uqtkbcs.FastLaplace(phi_uq, y_uq, sgm2_uq, eta, lmbdInit_uq, adpt,
optml, scl, verb, wghts_uq, usd_uq, errBrs_uq,
basis_uq, alpha_uq, lmbd_uq)
usd_np = uqtkarray.uqtk2numpy(usd_uq)
print "BCS selected " + str(len(usd_np)) + " of " + str(
self.mIdx_np.shape[0]) + " Multi Index"
self.mIdx_np = self.mIdx_np[usd_np, :]
# skip add front for last iteration of BCS
if iters != self.nBCS:
# Update Multi Index with BCS Results
[mIdxNew_np, mIdxAdd_np,
mIdxFrnt_np] = uqtkmlti.mi_addfront(self.mIdx_np)
self.saveDat(mIdxNew_np, 'nIdexNew_' + str(iters) + '.dat')
# Redefine PCE with update Multi Index
mIdxNew_uq = mkSetInt2D(mIdxNew_np)
pcmodel = uqtkpce.PCSet('NISPnoq', mIdxNew_uq, 'LEG')
self.mIdx_np = uqtkarray.uqtk2numpy(mIdxNew_uq)
print ''
print ''
mIdxFin_uq = mkSetInt2D(self.mIdx_np)
pcmodel = uqtkpce.PCSet('NISPnoq', mIdxFin_uq, 'LEG')
print "Final mIdx size: " + str(self.mIdx_np.shape[0])
self.pcModel = pcmodel
self.wghts_uq = wghts_uq
def runPCE(self):
print "Instantiate PCE object"
pcmodel = uqtkpce.PCSet('NISPnoq',self.nord,self.ndim,'LEG')
mIdx_uq = mkBlnkInt2D();
pcmodel.GetMultiIndex(mIdx_uq);
self.mIdx_np = uqtk2NumpyDbl(mIdx_uq)
self.saveDat(self.mIdx_np,'mIdex.dat')
self.pcModel = pcmodel;
def generate_pc_model(self,
pce_dim,
nord=3,
pc_type="HG",
pc_alpha=0.0,
pc_beta=1.0,
quadtype='full'):
"""
Wrapper for uqtk PCSet with default values
"""
param = nord + 1 # Parameter for quadrature point generation. Equal to number of quad points per dimension for full quadrature
self.pc_model = uqtkpce.PCSet("NISP", nord, pce_dim, pc_type, pc_alpha,
pc_beta)
self.pc_model.SetQuadRule(pc_type, quadtype, param)
def runPCE(self):
print "Instantiate PCE object"
self.nord = 1
pcmodel = uqtkpce.PCSet('NISPnoq', self.nord, self.ndim, 'LEG')
# set quad rule for pc model
pcmodel.SetQuadRule(self.q)
# Get the multiindex for postprocessing
mIdx_uq = mkBlnkInt2D()
pcmodel.GetMultiIndex(mIdx_uq)
self.mIdx_np = uqtk2NumpyDbl(mIdx_uq)
self.saveDat(self.mIdx_np, 'mIdex.dat')
# get the coefficients using the quadrature rule to calculate the projections
nPCT = pcmodel.GetNumberPCTerms()
ck_uq = mkSzDbl1D(nPCT)
y_uq = mkSetDbl1D(self.y_np)
pcmodel.GalerkProjection(y_uq, ck_uq)
self.ck_np = uqtk2NumpyDbl(ck_uq)
self.saveDat(self.ck_np, 'ck.dat')
self.pcModel = pcmodel
self.mIdx_uq = mIdx_uq
self.ck_uq = ck_uq
def runBCS(self):
pcmodel = self.pcModel;
x_uq = mkSetDbl2D(self.x_np);
y_uq = mkSetDbl1D(self.y_np);
eta = 1.e-4;
adpt = 0;
optml = 1;
scl = 0.1;
verb = -1;
for iters in range(1, self.nBCS+1):
print 'Starting BCS ' + str(iters)
self.nPCT = pcmodel.GetNumberPCTerms();
phi_uq = mkBlnkDbl2D();
midx_uq = mkBlnkInt2D();
sgm2_uq = mkSetDblRef((np.std(self.y_np)**2)/1.0e6);
lmbdInit_uq = mkBlnkDbl1D();
wghts_uq = mkBlnkDbl1D();
usd_uq = mkBlnkInt1D();
errBrs_uq = mkBlnkDbl1D();
basis_uq = mkBlnkDbl1D();
alpha_uq = mkBlnkDbl1D();
lmbd_uq = mkDblRef();
newMIdx_uq = mkBlnkInt2D();
# evalulate pc model to get phi
pcmodel.EvalBasisAtCustPts(x_uq, phi_uq)
self.phi_np = uqtk2NumpyDbl(phi_uq)
self.saveDat(self.phi_np,'phi_' + str(iters) + '.dat')
# Perform BCS
uqtkbcs.FastLaplace(phi_uq, y_uq, sgm2_uq, eta, lmbdInit_uq, adpt, optml, scl, verb, wghts_uq, usd_uq, errBrs_uq, basis_uq, alpha_uq, lmbd_uq)
usd_np = uqtkarray.uqtk2numpy(usd_uq)
print "BCS selected " + str(len(usd_np)) + " of " + str(self.mIdx_np.shape[0]) + " Multi Index"
if (1.0*len(usd_np) / self.mIdx_np.shape[0]) > 0.5:
print 'No reduction, skipping BCS'
self.skp = self.skp + 1;
print str(self.skp) + ' of ' + str(self.cnt) + 'Skipped so far'
break;
self.mIdx_np = self.mIdx_np[usd_np,:]
# skip add front for last iteration of BCS
if iters != self.nBCS:
# Update Multi Index with BCS Results
[mIdxNew_np, mIdxAdd_np, mIdxFrnt_np] = uqtkmlti.mi_addfront(self.mIdx_np)
self.saveDat(mIdxNew_np,'nIdexNew_' + str(iters) + '.dat')
# Redefine PCE with update Multi Index
mIdxNew_uq = mkSetInt2D(mIdxNew_np);
pcmodel = uqtkpce.PCSet('NISPnoq',mIdxNew_uq,'LEG')
self.mIdx_np = uqtkarray.uqtk2numpy(mIdxNew_uq)
print ''
print ''
mIdxFin_uq = mkSetInt2D(self.mIdx_np);
pcmodel = uqtkpce.PCSet('NISPnoq',mIdxFin_uq,'LEG')
print "Final mIdx size: " + str(self.mIdx_np.shape[0])
self.pcModel = pcmodel;
self.wghts_uq = wghts_uq;
# Number of random samples
n = 100000
######### Forward Propagation using PCEs ##########
# Set verbose to 1 if you want intermediate print statements, otherwise set to 0
verbose = 0
nord = 4 # Order of the PCE
ndim = 12 # Number of dimensions of the PCE
pc_type = "HG"
pc_alpha = 0.0
pc_beta = 1.0
param = nord + 1 # Parameter for quadrature point generation
# Equal to number of quad points per dimension for full quadrature or level for sparse quadrature
# Instantiate PC Object with sparse quadrature methods
pc_model2 = uqtkpce.PCSet("NISPnoq", nord, ndim, pc_type, pc_alpha, pc_beta)
pc_model2.SetQuadRule(pc_type, 'sparse', param)
npce2 = pc_model2.GetNumberPCTerms() # Number of terms in the PCE
if verbose > 0:
print "The number of terms in each PCE is", npce2
pc_model2.PrintMultiIndexNormSquared()
print "\nInstantiation complete"
##### Sparse quadrature methods ######
#Get numpy array of quadrature points
qdpts2, totquat2 = get_quadpts(pc_model2, ndim)
# Convert Quadrature points in \xi_i to equivalent samples of input parameters
# (taking advantage of the fact that inputs are assumed to be Gaussian)
# define function for evaluation over [-1,1]
f = lambda x: 1. / (1 + x**2)
y = f(x_np)
y.shape = (len(y), ) # make 1d array
# convert numpy y to 1d array
ydata = uqtkarray.dblArray1D(len(y), 0)
ydata.setnpdblArray(y)
'''
Define PCSet object
'''
# Instantiate object
nord = 8
chaos_type = "LEG"
pcmodel = uqtkpce.PCSet('NISPnoq', nord, ndim, 'LEG')
# set quad rule for pc model
pcmodel.SetQuadRule(q)
nup = pcmodel.GetNumberPCTerms() - 1
totquad = pcmodel.GetNQuadPoints()
# Get the multiindex for postprocessing
mindex = uqtkarray.intArray2D()
pcmodel.GetMultiIndex(mindex)
# get the coefficients using the quadrature rule
# to calculate the projections
ck = uqtkarray.dblArray1D(nup + 1, 0.0)
pcmodel.GalerkProjection(ydata, ck)
c_np = zeros(len(ck))
def run_ddd(components,
working_directory,
max_iter=30,
tolerance=0.01,
pce_order=3,
exo_links=[],
restart=False):
"""
Perform deterministic domain decomposition wrapped in NISP
"""
working_directory = os.path.abspath(working_directory)
# Calculate pce dimension (total number of exogenous ports in network)
pce_dim = 0
for comp in components:
pce_dim += comp.get_num_exogenous_ports()
pce_dim -= len(exo_links)
print("Network has %d exogenous ports." % pce_dim)
# Generate PCE model
pc_type = "HG"
pc_alpha = 0.0
pc_beta = 1.0
param = pce_order + 1 # Parameter for quadrature point generation. Equal to number of quad points per dimension for full quadrature
pc_model = uqtkpce.PCSet("NISP", pce_order, pce_dim, pc_type, pc_alpha,
pc_beta)
pc_model.SetQuadRule(pc_type, 'full', param)
for comp in components:
comp.pc_model = pc_model
# Get Quadrature Points
qdpts_uqtk = uqtkarray.dblArray2D()
pc_model.GetQuadPoints(qdpts_uqtk)
totquat = pc_model.GetNQuadPoints()
qdpts = np.zeros((totquat, pce_dim))
qdpts_uqtk.getnpdblArray(qdpts)
# Create and populate working directories for each simulation
if not restart:
if os.path.isdir(working_directory):
shutil.rmtree(working_directory)
os.makedirs(working_directory)
for quad_iter in range(totquat):
# Create subdirectory for each quadrature point
# and copy required files into it
newfolder = os.path.join(working_directory, "qdpt_%d" % quad_iter)
if not os.path.isdir(newfolder):
os.makedirs(newfolder)
for c in components:
for f in c.get_required_files():
shutil.copy2(f, newfolder)
# Perform iterations
for jacobi_iter in range(max_iter):
print("Performing iteration %d..." % jacobi_iter)
old_endo_data = []
new_endo_data = []
exo_port_idx = []
exogenous_idx = 0
for compidx, comp in enumerate(components):
old_endo_data.append(comp.get_endogenous_data())
running_jobs = []
for quad_iter in range(totquat):
targetfolder = os.path.join(working_directory,
"qdpt_%d" % quad_iter)
os.chdir(targetfolder)
unique_ports = 0
my_ports = []
for portidx, port in enumerate(comp.exogenous_ports):
found = False
for link in exo_links:
if compidx == link[2] and portidx == link[3]:
port.value = port.mean + port.std * qdpts[
quad_iter, exo_port_idx[link[0]][link[1]]]
my_ports.append(exo_port_idx[link[0]][link[1]])
found = True
if not found:
port.value = port.mean + port.std * qdpts[
quad_iter, exogenous_idx + unique_ports]
my_ports.append(exogenous_idx + unique_ports)
unique_ports += 1
job = comp.execute()
running_jobs.append(job)
exo_port_idx.append(my_ports)
exogenous_idx += len(my_ports)
# Wait for all simulations to complete
print("Waiting for aria jobs to complete...")
for job in running_jobs:
job.communicate()
new_endo_data.append(comp.get_endogenous_data())
# Check for convergence
maxdiff = 0
for comp_idx in range(len(components)):
for timestep, nodal_data in enumerate(old_endo_data[comp_idx]):
for nid in nodal_data:
diff = abs(new_endo_data[comp_idx][timestep][nid] -
old_endo_data[comp_idx][timestep][nid])
maxdiff = max(maxdiff, diff)
print(maxdiff)
if maxdiff < tolerance:
break
# Collect update PCE coefficients
print("Collect Data")
QoI_pce_coeffs = []
for comp in components:
QoI_data = np.zeros(
(totquat, comp.get_num_QoI() * comp.get_num_timesteps()))
for quad_iter in range(totquat):
targetfolder = os.path.join(working_directory,
"qdpt_%d" % quad_iter)
os.chdir(targetfolder)
QoI_at_qdpt = comp.get_QoI_data()
for i, QoI in enumerate(comp.QoIs):
QoI_data[[quad_iter], (i * comp.get_num_timesteps()):(
(i + 1) * comp.get_num_timesteps())] = QoI_at_qdpt[QoI]
QoI_ck = np.zeros((QoI_data.shape[1], pc_model.GetNumberPCTerms()))
for i in range(QoI_data.shape[1]):
QoI_ck[i, ...] = GalerkinProjection(pc_model, QoI_data[:, i])
QoI_pce_coeffs.append(QoI_ck)
return QoI_pce_coeffs
