TAGS


setup.cfg,0

MANIFEST.in,0

CITATION.cff,0

INSTALL.md,1001
## Install hIPPYlib using pipInstall hIPPYlib using pip28,1156
### Latest releaseLatest release30,1187
### Development version/topic branchesDevelopment version/topic branches44,1531
## Build the hIPPYlib documentation using SphinxBuild the hIPPYlib documentation using Sphinx61,2023
## FEniCS installationFEniCS installation68,2272
### Install FEniCS from Conda (Linux or MacOS)Install FEniCS from Conda (Linux or MacOS)70,2296
### Run FEniCS from Docker (Linux, MacOS, Windows)Run FEniCS from Docker (Linux, MacOS, Windows)82,2841
#### Docker for Mac, Docker for Windows and Linux users (Setup and first use instructions)Docker for Mac, Docker for Windows and Linux users (Setup and first use instructions)94,3475
#### Docker Toolbox users on Mac/Windows (Setup and first use instructions)Docker Toolbox users on Mac/Windows (Setup and first use instructions)110,4175
#### Subsequent usesSubsequent uses134,5354
### Other ways to build FEniCSOther ways to build FEniCS149,5697

CONTRIBUTING.md,705
# How to ContributeHow to Contribute22,1389
## Quick SummaryQuick Summary55,2869
## GitHub WorkflowGitHub Workflow67,3461
### hIPPYlib OrganizationhIPPYlib Organization79,3915
### New Feature DevelopmentNew Feature Development107,5122
### Developer GuidelinesDeveloper Guidelines143,6415
### Pull RequestsPull Requests174,7957
### Pull Request ChecklistPull Request Checklist204,8888
## Automated TestingAutomated Testing223,9972
## Contact InformationContact Information235,10387
## Slack channelSlack channel240,10613
## [Developer's Certificate of Origin 1.1](https://developercertificate.org/)[Developer's Certificate of Origin 1.1](https://developercertificate.org/)244,10963

CHANGELOG.md,1511
Version 3.1.0, released on Dec 21, 2022Version 3.1.0, released on Dec 21, 202218,877
Version 3.0.0, released on Feb 2, 2020Version 3.0.0, released on Feb 2, 202027,1351
Version 2.3.0, released on Sept 6, 2019Version 2.3.0, released on Sept 6, 201943,2305
Version 2.2.1, released on March 28, 2019Version 2.2.1, released on March 28, 201950,2893
Version 2.2.0, released on Dec 12, 2018Version 2.2.0, released on Dec 12, 201855,3120
Version 2.1.1, released on Oct 23, 2018Version 2.1.1, released on Oct 23, 201866,3792
Version 2.1.0, released on July 18, 2018Version 2.1.0, released on July 18, 201872,4038
Version 2.0.0, released on June 15, 2018Version 2.0.0, released on June 15, 201879,4408
Version 1.6.0, released on May 16, 2018Version 1.6.0, released on May 16, 201895,5493
Version 1.5.0, released on Jan 24, 2018Version 1.5.0, released on Jan 24, 2018103,5919
Version 1.4.0, released on Nov 8, 2017Version 1.4.0, released on Nov 8, 2017107,6035
Version 1.3.0, released on June 28, 2017Version 1.3.0, released on June 28, 2017116,6432
Version 1.2.0, released on April 24, 2017Version 1.2.0, released on April 24, 2017122,6617
Version 1.1.0, released on Nov 28, 2016Version 1.1.0, released on Nov 28, 2016129,6909
Version 1.0.2, released on Sep 30, 2016Version 1.0.2, released on Sep 30, 2016135,7115
Version 1.0.1, released on Aug 25, 2016Version 1.0.1, released on Aug 25, 2016142,7436
Version 1.0.0, released on Aug 8, 2016Version 1.0.0, released on Aug 8, 2016148,7640

LICENSE,0

setup.py,443
    from dolfin import __version__ as dolfin_versiondolfin_version23,719
    fenics_version_major = int(dolfin_version[0:4])fenics_version_major28,869
here = path.abspath(path.dirname(__file__))here37,1228
    long_description = f.read()long_description39,1336
version = {}version41,1369
VERSION = version['__version__']VERSION45,1467
REQUIREMENTS = [REQUIREMENTS47,1501
EXTRAS = {EXTRAS54,1578
KEYWORDS = """KEYWORDS58,1622

doc/hippylib.rst,106
hippylib packagehippylib package1,0
SubpackagesSubpackages4,35
Module contentsModule contents16,206

doc/hippylib.modeling.rst,1011
hippylib.modeling packagehippylib.modeling package1,0
SubmodulesSubmodules4,53
hippylib.modeling.PDEProblem modulehippylib.modeling.PDEProblem module7,76
hippylib.modeling.expression modulehippylib.modeling.expression module16,261
hippylib.modeling.misfit modulehippylib.modeling.misfit module24,441
hippylib.modeling.model modulehippylib.modeling.model module32,605
hippylib.modeling.modelVerify modulehippylib.modeling.modelVerify module40,766
hippylib.modeling.pointwiseObservation modulehippylib.modeling.pointwiseObservation module48,949
hippylib.modeling.posterior modulehippylib.modeling.posterior module56,1155
hippylib.modeling.prior modulehippylib.modeling.prior module64,1328
hippylib.modeling.reducedHessian modulehippylib.modeling.reducedHessian module72,1493
hippylib.modeling.timeDependentVector modulehippylib.modeling.timeDependentVector module80,1685
hippylib.modeling.variables modulehippylib.modeling.variables module88,1892
Module contentsModule contents96,2069

doc/conf.py,1497
autodoc_mock_imports = ["dolfin", "ufl", "matplotlib", "ffc", "petsc4py", "mpi4py", "scipy", "nuautodoc_mock_imports19,733
autodoc_default_flags = ['members', 'private-members', 'undoc-members']autodoc_default_flags20,835
autoclass_content = 'both'autoclass_content21,907
project = u'hIPPYlib'project25,1015
copyright = u'2018, Umberto Villa, Noemi Petra, Omar Ghattas'copyright26,1037
author = u'Umberto Villa, Noemi Petra, Omar Ghattas'author27,1099
version = {}version29,1153
root_directory = (os.path.abspath(os.path.dirname(os.path.dirname(__file__))))root_directory30,1166
VERSION = version['__version__']VERSION34,1343
version = u''version37,1401
release = VERSIONrelease39,1464
extensions = [extensions51,1809
templates_path = ['_templates']templates_path60,2012
source_suffix = '.rst'source_suffix66,2174
master_doc = 'index'master_doc69,2229
language = Nonelanguage76,2505
exclude_patterns = [u'_build', 'Thumbs.db', '.DS_Store']exclude_patterns81,2715
pygments_style = 'sphinx'pygments_style84,2836
html_theme = 'sphinx_rtd_theme'html_theme92,3050
html_show_sourcelink = Falsehtml_show_sourcelink93,3082
html_static_path = ['_static']html_static_path104,3534
htmlhelp_basename = 'hIPPYlibdoc'htmlhelp_basename120,4050
latex_elements = {latex_elements125,4166
latex_documents = [latex_documents146,4672
man_pages = [man_pages156,5008
texinfo_documents = [texinfo_documents167,5336
todo_include_todos = Truetodo_include_todos179,5738

doc/hippylib.algorithms.rst,1087
hippylib.algorithms packagehippylib.algorithms package1,0
SubmodulesSubmodules4,57
hippylib.algorithms.NewtonCG modulehippylib.algorithms.NewtonCG module7,80
hippylib.algorithms.bfgs modulehippylib.algorithms.bfgs module15,263
hippylib.algorithms.cgsampler modulehippylib.algorithms.cgsampler module23,430
hippylib.algorithms.cgsolverSteihaug modulehippylib.algorithms.cgsolverSteihaug module31,609
hippylib.algorithms.linalg modulehippylib.algorithms.linalg module40,814
hippylib.algorithms.lowRankOperator modulehippylib.algorithms.lowRankOperator module48,984
hippylib.algorithms.multivector modulehippylib.algorithms.multivector module57,1182
hippylib.algorithms.randomizedEigensolver modulehippylib.algorithms.randomizedEigensolver module66,1372
hippylib.algorithms.randomizedSVD modulehippylib.algorithms.randomizedSVD module74,1591
hippylib.algorithms.steepestDescent modulehippylib.algorithms.steepestDescent module83,1791
hippylib.algorithms.traceEstimator modulehippylib.algorithms.traceEstimator module91,1988
Module contentsModule contents99,2182

doc/installation.rst,30
InstallationInstallation1,0

doc/index.rst,90
hIPPYlib - Inverse Problem PYthon libraryhIPPYlib - Inverse Problem PYthon library6,219

doc/Makefile,233
SPHINXOPTS    =SPHINXOPTS5,100
SPHINXBUILD   = sphinx-buildSPHINXBUILD6,116
SPHINXPROJ    = hIPPYlibSPHINXPROJ7,145
SOURCEDIR     = .SOURCEDIR8,170
BUILDDIR      = _buildBUILDDIR9,188
help:help12,280
%: Makefile%19,523

doc/changelog.rst,24
ChangelogChangelog1,0

doc/hippylib.mcmc.rst,376
hippylib.mcmc packagehippylib.mcmc package1,0
SubmodulesSubmodules4,45
hippylib.mcmc.chain modulehippylib.mcmc.chain module7,68
hippylib.mcmc.diagnostics modulehippylib.mcmc.diagnostics module15,217
hippylib.mcmc.kernels modulehippylib.mcmc.kernels module23,384
hippylib.mcmc.tracers modulehippylib.mcmc.tracers module31,539
Module contentsModule contents40,695

doc/hippylib.forward_uq.rst,300
hippylib.forward\_uq packagehippylib.forward\_uq package1,0
SubmodulesSubmodules4,59
hippylib.forward\_uq.qoi modulehippylib.forward\_uq.qoi module7,82
hippylib.forward\_uq.varianceReductionMC modulehippylib.forward\_uq.varianceReductionMC module31,660
Module contentsModule contents40,872

doc/hippylib.utils.rst,487
hippylib.utils packagehippylib.utils package1,0
SubmodulesSubmodules4,47
hippylib.utils.checkDolfinVersion modulehippylib.utils.checkDolfinVersion module7,70
hippylib.utils.parameterList modulehippylib.utils.parameterList module16,262
hippylib.utils.vector2function modulehippylib.utils.vector2function module25,439
hippylib.utils.random modulehippylib.utils.random module33,625
hippylib.utils.nb modulehippylib.utils.nb module41,784
Module contentsModule contents49,927

doc/modules.rst,22
hippylibhippylib1,0

doc/hippylib.scheduling.rst,207
hippylib.scheduling packagehippylib.scheduling package1,0
SubmodulesSubmodules4,57
hippylib.scheduling.collective modulehippylib.scheduling.collective module7,80
Module contentsModule contents16,263

doc/contributing.rst,0

doc/requirements.txt,0

hippylib/version.py,119
version_info = (3, 1, 0)version_info16,627
__version__ = '.'.join([str(x) for x in version_info])__version__17,652

hippylib/modeling/model.py,1188
import dolfin as dldl16,627
class Model:Model20,709
    def __init__(self, problem, prior,misfit):__init__33,1104
    def generate_vector(self, component = "ALL"):generate_vector50,1675
    def init_parameter(self, m):init_parameter78,2799
    def cost(self, x):cost84,2984
    def solveFwd(self, out, x):solveFwd98,3585
    def solveAdj(self, out, x):solveAdj116,4205
    def evalGradientParameter(self,x, mg, misfit_only=False):evalGradientParameter136,4916
    def setPointForHessianEvaluations(self, x, gauss_newton_approx=False):setPointForHessianEvaluations161,5880
    def solveFwdIncremental(self, sol, rhs):solveFwdIncremental183,6964
    def solveAdjIncremental(self, sol, rhs):solveAdjIncremental195,7402
    def applyC(self, dm, out):applyC207,7823
    def applyCt(self, dp, out):applyCt221,8327
    def applyWuu(self, du, out):applyWuu236,8836
    def applyWum(self, dm, out):applyWum254,9510
    def applyWmu(self, du, out):applyWmu275,10238
    def applyR(self, dm, out):applyR295,10959
    def Rsolver(self):Rsolver309,11415
    def applyWmm(self, dm, out):applyWmm320,11750
    def apply_ij(self, i, j, d, out):apply_ij340,12505

hippylib/modeling/cpp_AssemblePointwiseObservation/AssemblePointwiseObservation.h,155
namespace hippylibhippylib21,752
class PointwiseObservationPointwiseObservation24,774
	Mat mat;mat39,1285
	std::vector<int> old_new;old_new40,1295

hippylib/modeling/cpp_AssemblePointwiseObservation/AssemblePointwiseObservation.cpp,490
namespace hippylibhippylib31,943
PetscInt PointwiseObservation::computeLGtargets(MPI_Comm comm,computeLGtargets34,965
PointwiseObservation::PointwiseObservation(const dolfin::FunctionSpace & Vh,PointwiseObservation111,2930
PointwiseObservation::~PointwiseObservation()~PointwiseObservation208,6741
std::shared_ptr<dolfin::Matrix> PointwiseObservation::GetMatrix()GetMatrix213,6811
PYBIND11_MODULE(SIGNATURE, m) {PYBIND11_MODULE220,6976
		          {__anona355e1690102223,7187

hippylib/modeling/prior.py,2570
import dolfin as dldl16,627
import numpy as npnp18,658
import scipy.linalg as scilascila19,677
class _RinvM:_RinvM35,1224
    def __init__(self, Rsolver, M):__init__40,1360
    def init_vector(self,x,dim):init_vector44,1455
    def mult(self,x,y):mult47,1535
class _Prior:_Prior50,1600
    def trace(self, method="Exact", tol=1e-1, min_iter=20, max_iter=100, r = 200):trace73,2586
    def pointwise_variance(self, method, k = 1000000, r = 200):pointwise_variance109,4549
    def cost(self,m):cost135,5671
    def grad(self,m, out):grad143,5879
    def init_vector(self,x,dim):init_vector148,5986
    def sample(self, noise, s, add_mean=True):sample151,6105
    def getHessianPreconditioner(self):getHessianPreconditioner154,6233
class LaplacianPrior(_Prior):LaplacianPrior158,6362
    def __init__(self, Vh, gamma, delta, mean=None, rel_tol=1e-12, max_iter=100):__init__169,6808
    def init_vector(self,x,dim):init_vector253,10325
    def sample(self, noise, s, add_mean=True):sample265,10738
class _BilaplacianR:_BilaplacianR279,11129
    def __init__(self, A, Msolver):__init__284,11275
    def init_vector(self,x, dim):init_vector292,11547
    def mpi_comm(self):mpi_comm295,11622
    def mult(self,x,y):mult298,11688
class _BilaplacianRsolver():_BilaplacianRsolver303,11842
    def __init__(self, Asolver, M):__init__308,12008
    def init_vector(self,x, dim):init_vector316,12284
    def solve(self,x,b):solve319,12359
def BiLaplacianComputeCoefficients(sigma2, rho, ndim):BiLaplacianComputeCoefficients326,12546
class SqrtPrecisionPDE_Prior(_Prior):SqrtPrecisionPDE_Prior343,13083
    def __init__(self, Vh, sqrt_precision_varf_handler, mean=None, rel_tol=1e-12, max_iter=1000)__init__351,13340
    def init_vector(self,x,dim):init_vector427,16788
    def sample(self, noise, s, add_mean=True):sample439,17197
def BiLaplacianPrior(Vh, gamma, delta, Theta = None, mean=None, rel_tol=1e-12, max_iter=1000, roBiLaplacianPrior451,17591
    def sqrt_precision_varf_handler(trial, test): sqrt_precision_varf_handler478,18985
def MollifiedBiLaplacianPrior(Vh, gamma, delta, locations, m_true, Theta = None, pen = 1e1, ordeMollifiedBiLaplacianPrior497,19667
    def sqrt_precision_varf_handler(trial, test): sqrt_precision_varf_handler535,21749
class GaussianRealPrior(_Prior):GaussianRealPrior557,22591
    def __init__(self, Vh, covariance, mean=None):__init__566,22963
    def init_vector(self, x, dim):init_vector653,26490
    def sample(self, noise, s, add_mean=True):sample667,26912

hippylib/modeling/timeDependentVector.py,576
import dolfin as dldl16,627
class TimeDependentVector(object):TimeDependentVector18,648
    def __init__(self, times, tol=1e-10, mpi_comm = dl.MPI.comm_world):__init__26,908
    def __imul__(self, other):__imul__43,1419
    def copy(self):copy49,1527
    def initialize(self,M,dim):initialize61,1840
    def axpy(self, a, other):axpy71,2109
    def zero(self):zero78,2327
    def store(self, u, t):store85,2465
    def retrieve(self, u, t):retrieve99,2910
    def norm(self, time_norm, space_norm):norm113,3350
    def inner(self, other):inner126,3707

hippylib/modeling/modelVerify.py,291
import numpy as npnp16,627
def modelVerify(model,m0, is_quadratic = False, misfit_only=False, verbose = True, eps = None):modelVerify22,781
def modelVerifyPlotErrors(is_quadratic, eps, err_grad, err_H):modelVerifyPlotErrors104,3256
        import matplotlib.pyplot as pltplt106,3328

hippylib/modeling/PDEProblem.py,1603
import dolfin as dldl16,627
class PDEProblem(object):PDEProblem23,853
    def generate_state(self):generate_state32,1164
    def generate_parameter(self):generate_parameter36,1342
    def init_parameter(self, m):init_parameter40,1532
    def solveFwd(self, state, x):solveFwd44,1696
    def solveAdj(self, adj, x, adj_rhs):solveAdj52,2017
    def evalGradientParameter(self, x, out):evalGradientParameter60,2365
    def setLinearizationPoint(self,x, gauss_newton_approx):setLinearizationPoint64,2616
    def solveIncremental(self, out, rhs, is_adj):solveIncremental72,2992
    def apply_ij(self,i,j, dir, out):   apply_ij91,3733
    def apply_ijk(self,i,j,k, x, jdir, kdir, out):apply_ijk99,4090
class PDEVariationalProblem(PDEProblem):PDEVariationalProblem107,4477
    def __init__(self, Vh, varf_handler, bc, bc0, is_fwd_linear = False):__init__108,4518
    def generate_state(self):generate_state136,5350
    def generate_parameter(self):generate_parameter140,5496
    def init_parameter(self, m):init_parameter144,5654
    def solveFwd(self, state, x):solveFwd149,5832
    def solveAdj(self, adj, x, adj_rhs):solveAdj176,7016
    def evalGradientParameter(self, x, out):evalGradientParameter197,7937
    def setLinearizationPoint(self,x, gauss_newton_approx):setLinearizationPoint207,8454
    def solveIncremental(self, out, rhs, is_adj):solveIncremental247,10232
    def apply_ij(self,i,j, dir, out):   apply_ij269,11110
    def apply_ijk(self,i,j,k, x, jdir, kdir, out):apply_ijk293,11893
    def _createLUSolver(self):   _createLUSolver312,12590

hippylib/modeling/expression.py,137
import dolfin as dldl16,627
cpp_code = '''cpp_code32,1196
ExpressionModule = dl.compile_cpp_code(cpp_code)ExpressionModule154,3969

hippylib/modeling/__init__.py,0

hippylib/modeling/reducedHessian.py,587
class ReducedHessian:ReducedHessian19,678
    def __init__(self, model, misfit_only=False):__init__29,1193
    def init_vector(self, x, dim):init_vector45,1804
    def mult(self,x,y):mult59,2536
    def inner(self,x,y):inner70,2867
    def GNHessian(self,x,y):GNHessian80,3198
    def TrueHessian(self, x, y):TrueHessian96,3788
class FDHessian:FDHessian118,4617
    def __init__(self, model, m0, h, misfit_only=False):__init__130,5285
    def init_vector(self, x, dim):init_vector148,5970
    def mult(self,x,y):mult162,6700
    def inner(self,x,y):inner193,7898

hippylib/modeling/variables.py,101
STATE= 0STATE21,736
PARAMETER = 1PARAMETER22,745
ADJOINT = 2ADJOINT23,759
NVAR = 3NVAR24,771

hippylib/modeling/pointwiseObservation.py,719
import dolfin as dldl16,627
import numpy as npnp18,658
abspath = os.path.dirname( os.path.abspath(__file__) )abspath21,692
source_directory = os.path.join(abspath,"cpp_AssemblePointwiseObservation")source_directory22,747
    cpp_code    = cpp_file.read()cpp_code24,918
include_dirs = [".", source_directory]include_dirs27,954
cpp_module = dl.compile_cpp_code(cpp_code, include_dirs=include_dirs)cpp_module28,993
def assemblePointwiseObservation(Vh, targets, prune_and_sort=False):assemblePointwiseObservation30,1064
def exportPointwiseObservation(Vh, B, data, fname, varname="observation"):exportPointwiseObservation46,1663
def write_vtk(points, data, fname, varname="observation"):write_vtk85,3239

hippylib/modeling/posterior.py,1219
import numpy as npnp18,720
class LowRankHessian:LowRankHessian20,740
    def __init__(self, prior, d, U):__init__25,887
    def init_vector(self,x, dim):init_vector35,1287
    def inner(self,x,y):inner38,1364
    def mult(self, x, y):mult44,1524
    def solve(self, sol, rhs):solve51,1718
class LowRankPosteriorSampler:LowRankPosteriorSampler57,1888
    def __init__(self, prior, d, U):__init__68,2142
    def init_vector(self,x, dim):init_vector76,2460
    def sample(self, noise, s):sample79,2541
class GaussianLRPosterior:GaussianLRPosterior85,2701
    def __init__(self, prior, d, U, mean=None):__init__100,3425
    def cost(self, m):cost118,4083
    def init_vector(self,x, dim):init_vector126,4289
    def sample(self, *args, **kwargs):sample134,4613
    def _sample_given_white_noise(self, noise, s_prior, s_post):_sample_given_white_noise176,6383
    def _sample_given_prior(self,s_prior, s_post):_sample_given_prior180,6560
    def trace(self, **kwargs):trace183,6661
    def trace_update(self):trace_update195,7086
    def pointwise_variance(self, **kwargs):pointwise_variance198,7175
    def klDistanceFromPrior(self, sub_comp = False):klDistanceFromPrior212,7931

hippylib/modeling/misfit.py,1842
import dolfin as dldl16,627
import numpy as npnp21,803
class Misfit(object):Misfit23,823
    def cost(self,x):cost32,1280
    def grad(self, i, x, out):grad39,1538
    def setLinearizationPoint(self,x, gauss_newton_approx=False):setLinearizationPoint46,1910
    def apply_ij(self,i,j, dir, out):apply_ij58,2318
class PointwiseStateObservation(Misfit):PointwiseStateObservation64,2596
    def __init__(self, Vh, obs_points):__init__69,2789
    def cost(self,x):cost85,3384
    def grad(self, i, x, out):grad94,3809
    def setLinearizationPoint(self,x, gauss_newton_approx=False):setLinearizationPoint109,4407
    def apply_ij(self,i,j,dir,out):apply_ij113,4572
class MultPointwiseStateObservation(Misfit):MultPointwiseStateObservation126,5096
    def __init__(self, Vh, obs_points, Mpar):__init__131,5287
    def cost(self,x):cost160,6282
    def grad(self, i, x, out):grad168,6557
    def setLinearizationPoint(self,x, gauss_newton_approx=False):setLinearizationPoint183,7074
    def apply_ij(self,i,j,dir,out):apply_ij188,7282
class ContinuousStateObservation(Misfit):ContinuousStateObservation202,7831
    def __init__(self, Vh, dX, bcs, form = None):__init__207,8028
    def cost(self,x):cost243,9610
    def grad(self, i, x, out):grad255,10107
    def setLinearizationPoint(self,x, gauss_newton_approx=False):setLinearizationPoint268,10618
    def apply_ij(self,i,j,dir,out):apply_ij272,10795
class MultiStateMisfit(Misfit):MultiStateMisfit284,11248
    def __init__(self, misfits):__init__285,11280
    def append(self, misfit):append289,11390
    def cost(self,x):cost293,11484
    def grad(self, i, x, out):grad300,11665
    def setLinearizationPoint(self,x, gauss_newton_approx=False):setLinearizationPoint312,12085
    def apply_ij(self,i,j,dir,out):apply_ij318,12325

hippylib/scheduling/collective.py,492
import dolfin as dldl16,627
import numpy as npnp17,647
class NullCollective:NullCollective20,690
    def __init__(self):__init__24,828
    def size(self):size27,870
    def rank(self):rank30,912
    def allReduce(self, v, op):allReduce33,954
class MultipleSerialPDEsCollective:MultipleSerialPDEsCollective41,1205
    def __init__(self, comm):__init__45,1369
    def size(self):size51,1501
    def rank(self):rank54,1562
    def allReduce(self, v, op):allReduce57,1623

hippylib/scheduling/__init__.py,0

hippylib/forward_uq/qoi.py,501
import dolfin as dldl16,631
import numpy as npnp17,651
class Qoi(object):Qoi22,768
    def eval(self, x):eval31,1169
    def grad(self,i, x,g):grad39,1452
    def setLinearizationPoint(self, x):setLinearizationPoint46,1726
    def apply_ij(self,i,j, dir, out):apply_ij49,1862
def qoiVerify(qoi, x, generate_state, h=None, plotting = True):qoiVerify57,2167
def qoiVerifyPlotErrors(eps, err_grad, err_H):qoiVerifyPlotErrors103,3397
        import matplotlib.pyplot as pltplt105,3453

hippylib/forward_uq/varianceReductionMC.py,175
import dolfin as dldl16,631
import numpy as npnp17,651
def varianceReductionMC(prior, rqoi, taylor_qoi, nsamples, filename="realizations.txt"):varianceReductionMC20,708

hippylib/forward_uq/variationalQoi.py,434
import dolfin as dldl16,631
class VariationalQoi(Qoi):VariationalQoi24,955
    def __init__(self, Vh, qoi_varf):__init__25,982
    def eval(self, x):eval31,1104
    def grad(self, i, x, g):grad40,1435
    def grad_state(self,x,g):grad_state48,1633
    def grad_param(self,x,g):grad_param56,2007
    def apply_ij(self,i,j, dir, out):apply_ij64,2389
    def setLinearizationPoint(self, x):setLinearizationPoint72,2659

hippylib/forward_uq/__init__.py,0

hippylib/forward_uq/parameter2QoiMap.py,1720
import numpy as npnp16,631
import dolfin as dldl17,650
class Parameter2QoiHessian:Parameter2QoiHessian22,768
    def __init__(self, p2qoimap):__init__29,1032
    def init_vector(self, x, dim):init_vector43,1567
    def mult(self,x,y):mult61,2358
    def inner(self,x,y):inner81,3102
class Parameter2QoiMap:Parameter2QoiMap92,3428
    def __init__(self, problem, qoi):__init__93,3452
    def generate_vector(self, component = "ALL"):generate_vector103,3830
    def init_parameter(self, m):init_parameter129,4900
    def eval(self, x):eval135,5088
    def solveFwd(self, out, x):solveFwd144,5375
    def solveAdj(self, out, x):solveAdj161,5949
    def evalGradientParameter(self,x, mg):evalGradientParameter180,6602
    def setLinearizationPoint(self, x):setLinearizationPoint197,7216
    def solveFwdIncremental(self, sol, rhs):solveFwdIncremental209,7627
    def solveAdjIncremental(self, sol, rhs):solveAdjIncremental220,8013
    def applyC(self, dm, out):applyC231,8382
    def applyCt(self, dp, out):applyCt245,8879
    def applyWuu(self, du, out):applyWuu260,9393
    def applyWum(self, dm, out):applyWum277,10004
    def applyWmu(self, du, out):applyWmu295,10639
    def applyWmm(self, dm, out):applyWmm312,11271
    def reduced_eval(self, m):reduced_eval329,11915
    def reduced_gradient(self, m, g):reduced_gradient341,12356
    def hessian(self, m=None, x=None):hessian354,12842
def parameter2QoiMapVerify(rQOI, m0, h=None, eps=None, plotting = True,verbose = True):parameter2QoiMapVerify378,13721
def parameter2QoiMapVerifyPlotErrors(eps, err_grad, err_H):parameter2QoiMapVerifyPlotErrors482,16723
        import matplotlib.pyplot as pltplt484,16792

hippylib/forward_uq/taylorApproximationQoi.py,498
import numpy as npnp16,631
class TaylorApproximationQoi:TaylorApproximationQoi20,769
    def __init__(self, p2qoimap, distribution):__init__27,1163
    def computeLowRankFactorization(self, Omega):computeLowRankFactorization50,2016
    def expectedValue(self, order=2):expectedValue80,3375
    def variance(self, order=2):variance98,3917
    def eval(self, m, order=2):eval124,4757
def plotEigenvalues(d):plotEigenvalues142,5396
        import matplotlib.pyplot as pltplt148,5579

hippylib/mcmc/chain.py,440
class NullQoi(object):NullQoi20,711
    def __init__(self):__init__21,734
    def eval(self,x):eval23,771
class SampleStruct:SampleStruct28,814
    def __init__(self, kernel):__init__29,834
    def assign(self, other):assign43,1357
class MCMC(object):MCMC56,1710
    def __init__(self, kernel):__init__57,1730
    def run(self, m0, qoi=None, tracer = None):run68,2106
    def consume_random(self):consume_random111,4139

hippylib/mcmc/tracers.py,467
import numpy as npnp19,730
class NullTracer(object):NullTracer22,751
    def __init__(self):__init__23,777
    def append(self,current, q):append25,814
class QoiTracer(object):QoiTracer28,865
    def __init__(self, n):__init__29,890
    def append(self,current, q):append33,977
class FullTracer(object):FullTracer37,1067
    def __init__(self, n, Vh, par_fid = None, state_fid = None):__init__38,1093
    def append(self,current, q):append45,1309

hippylib/mcmc/kernels.py,1784
import numpy as npnp19,677
import dolfin as dldl20,696
class MALAKernel:MALAKernel23,718
    def __init__(self, model):__init__24,736
    def name(self):name33,1062
    def derivativeInfo(self):derivativeInfo36,1117
    def init_sample(self, s):init_sample39,1169
    def sample(self, current, proposed): sample46,1484
    def proposal(self, current):proposal58,1889
    def acceptance_ratio(self, origin, destination):acceptance_ratio68,2377
    def consume_random(self):consume_random78,2785
class pCNKernel:pCNKernel84,2900
    def __init__(self, model):__init__85,2917
    def name(self):name93,3197
    def derivativeInfo(self):derivativeInfo96,3239
    def init_sample(self, current):init_sample99,3287
    def sample(self, current, proposed): sample103,3469
    def proposal(self, current):proposal113,3772
    def consume_random(self):consume_random127,4290
class gpCNKernel:gpCNKernel131,4392
    def __init__(self, model, nu):__init__138,4655
    def name(self):name148,4984
    def derivativeInfo(self):derivativeInfo151,5027
    def init_sample(self, current):init_sample154,5075
    def sample(self, current, proposed): sample158,5257
    def delta(self,sample):delta168,5581
    def proposal(self, current):proposal173,5751
    def consume_random(self):consume_random189,6342
class ISKernel:ISKernel194,6449
    def __init__(self, model, nu):__init__195,6465
    def name(self):name204,6739
    def derivativeInfo(self):derivativeInfo207,6780
    def init_sample(self, current):init_sample210,6828
    def sample(self, current, proposed): sample214,7010
    def delta(self,sample):delta224,7334
    def proposal(self, current):proposal229,7504
    def consume_random(self):consume_random240,7897

hippylib/mcmc/__init__.py,0

hippylib/mcmc/diagnostics.py,245
import numpy as npnp16,627
def _acorr(mean_free_samples, lag, norm = 1):_acorr18,647
def _acorr_vs_lag(samples, max_lag):_acorr_vs_lag22,891
def integratedAutocorrelationTime(samples, max_lag = None):integratedAutocorrelationTime36,1232

hippylib/__init__.py,0

hippylib/TAGS,0

hippylib/algorithms/steepestDescent.py,308
def SteepestDescent_ParameterList():SteepestDescent_ParameterList19,735
class SteepestDescent:SteepestDescent30,1480
    termination_reasons = [termination_reasons51,2650
    def __init__(self, model, parameters = SteepestDescent_ParameterList()):__init__57,2934
    def solve(self,x):solve71,3414

hippylib/algorithms/linSolvers.py,250
import dolfin as dldl16,627
def PETScKrylovSolver(comm, method, preconditioner):PETScKrylovSolver19,649
def _PETScLUSolver_set_operator(self, A):_PETScLUSolver_set_operator27,872
def PETScLUSolver(comm, method='default'):PETScLUSolver34,1058

hippylib/algorithms/randomizedEigensolver.py,430
import dolfin as dldl15,626
import numpy as npnp18,743
def singlePass(A,Omega,k,s=1,check=False):singlePass40,1470
def doublePass(A,Omega,k,s,check = False):doublePass89,2739
def singlePassG(A, B, Binv, Omega,k, s = 1, check = False):singlePassG138,4087
def doublePassG(A, B, Binv, Omega, k, s = 1, check = False):doublePassG191,5655
def check_std(A, U, d):check_std241,7195
def check_g(A,B, U, d):check_g282,8416

hippylib/algorithms/cpp_multivector/multivector.cpp,1786
namespace hippylibhippylib27,812
MultiVector::MultiVector()MultiVector30,834
MultiVector::MultiVector(const dolfin::GenericVector & v, std::size_t nvec):MultiVector34,866
MultiVector::MultiVector(const MultiVector & orig):MultiVector44,1017
void MultiVector::setSizeFromVector(const dolfin::GenericVector & v, std::size_t nvec)setSizeFromVector52,1189
std::shared_ptr<const dolfin::GenericVector> MultiVector::operator[](std::size_t i) constoperator []64,1359
std::shared_ptr<dolfin::GenericVector> MultiVector::operator[](std::size_t i)operator []69,1469
void MultiVector::dot(const dolfin::GenericVector & v, dolfin::Array<double> & m) constdot75,1568
void MultiVector::dot(const MultiVector & other, dolfin::Array<double> & m) constdot82,1732
void MultiVector::dot_self(dolfin::Array<double> & m) constdot_self95,1992
void MultiVector::reduce(dolfin::GenericVector & v, const dolfin::Array<double> & alpha) constreduce107,2257
void MultiVector::axpy(double a, const dolfin::GenericVector & y)axpy114,2441
void MultiVector::axpy(const dolfin::Array<double> & a, const MultiVector & y)axpy120,2551
void MultiVector::scale(std::size_t k, double a)scale130,2779
void MultiVector::scale(const dolfin::Array<double> & a)scale135,2856
void MultiVector::zero()zero142,3002
void MultiVector::norm_all(const std::string norm_type, dolfin::Array<double> & norms) constnorm_all148,3067
void MultiVector::swap(MultiVector & other)swap155,3253
MultiVector::~MultiVector()~MultiVector160,3322
PYBIND11_MODULE(SIGNATURE, m) {PYBIND11_MODULE167,3359
				{__anon2c5c403c0102182,4375
				{__anon2c5c403c0202193,4748
        		{__anon2c5c403c0302205,5221
				{__anon2c5c403c0402216,5764
				{__anon2c5c403c0502227,6214
				{__anon2c5c403c0602238,6579

hippylib/algorithms/cpp_multivector/multivector.hpp,199
namespace hippylibhippylib21,715
class MultiVectorMultiVector24,737
	std::size_t nvec() const {return mv.size();}nvec31,887
	std::vector<std::shared_ptr<dolfin::GenericVector> > mv;mv67,1944

hippylib/algorithms/NewtonCG.py,543
def LS_ParameterList():LS_ParameterList23,848
def TR_ParameterList():TR_ParameterList34,1284
def ReducedSpaceNewtonCG_ParameterList():ReducedSpaceNewtonCG_ParameterList44,1632
class ReducedSpaceNewtonCG:ReducedSpaceNewtonCG66,3019
    termination_reasons = [termination_reasons104,5424
    def __init__(self, model, parameters=ReducedSpaceNewtonCG_ParameterList(), callback = None):__init__111,5782
    def solve(self, x):solve136,6890
    def _solve_ls(self,x):_solve_ls159,7669
    def _solve_tr(self,x):_solve_tr276,12467

hippylib/algorithms/traceEstimator.py,354
import dolfin as dldl16,627
def rademacher_engine(v):rademacher_engine21,733
def gaussian_engine(v):gaussian_engine27,872
class TraceEstimator:TraceEstimator33,1010
    def __init__(self, A, solve_mode=False, accurancy = 1e-1, init_vector=None, random_engine=ra__init__45,1586
    def __call__(self, min_iter=5, max_iter=100):__call__75,2850

hippylib/algorithms/cgsampler.py,174
class CGSampler:CGSampler20,703
    def __init__(self):__init__29,1028
    def set_operator(self, A):set_operator52,1610
    def sample(self, noise, s):sample67,2116

hippylib/algorithms/randomizedSVD.py,273
import dolfin as dldl16,627
import numpy as npnp19,758
def accuracyEnhancedSVD(A,Omega,k,s=1,check=False):accuracyEnhancedSVD36,1236
def singlePassSVD(A,Omega_c,Omega_r,k,check=False):singlePassSVD99,3429
def check_SVD(A, U, sigma,V,tol = 1e-1):check_SVD168,5993

hippylib/algorithms/lowRankOperator.py,463
import numpy as npnp18,706
class LowRankOperator:LowRankOperator20,726
    def __init__(self,d,U, my_init_vector = None):__init__28,1005
    def init_vector(self, x, dim):init_vector36,1243
    def mult(self,x,y):mult43,1510
    def inner(self, x, y):inner52,1734
    def solve(self, sol, rhs):solve57,1876
    def get_diagonal(self, diag):get_diagonal67,2109
    def trace(self,W=None):trace80,2436
    def trace2(self,W=None):trace2105,3401

hippylib/algorithms/linalg.py,1368
import dolfin as dldl16,627
import numpy as npnp20,712
def amg_method(amg_type="ml_amg"):amg_method22,732
def MatMatMult(A,B):MatMatMult34,1087
def MatPtAP(A,P):MatPtAP46,1413
def MatAtB(A,B):MatAtB57,1727
def Transpose(A):Transpose69,2061
def SetToOwnedGid(v, gid, val):SetToOwnedGid80,2316
def GetFromOwnedGid(v, gid):GetFromOwnedGid84,2371
def to_dense(A, mpi_comm = dl.MPI.comm_world ):to_dense88,2424
def trace(A, mpi_comm = dl.MPI.comm_world ):trace130,3557
def get_diagonal(A, d):get_diagonal148,3959
def estimate_diagonal_inv2(Asolver, k, d):estimate_diagonal_inv2175,4674
class DiagonalOperator:DiagonalOperator207,5737
    def __init__(self, d):__init__208,5761
    def init_vector(self,x,dim):init_vector211,5816
    def mult(self,x,y):mult214,5895
    def inner(self,x,y):inner219,5990
class Solver2Operator:Solver2Operator223,6071
    def __init__(self,S,mpi_comm=dl.MPI.comm_world, init_vector = None):__init__224,6094
    def init_vector(self, x, dim):init_vector237,6665
    def mult(self,x,y):mult244,6872
    def inner(self, x, y):inner247,6931
class Operator2Solver:Operator2Solver251,7029
    def __init__(self,op, mpi_comm=dl.MPI.comm_world):__init__252,7052
    def init_vector(self, x, dim):init_vector256,7176
    def solve(self,y,x):solve262,7335
    def inner(self, x, y):inner265,7395

hippylib/algorithms/bfgs.py,854
import numpy as npnp16,627
def BFGSoperator_ParameterList():BFGSoperator_ParameterList22,794
def BFGS_ParameterList():BFGS_ParameterList28,1039
class RescaledIdentity(object):RescaledIdentity42,1973
    def __init__(self, init_vector=None):__init__46,2098
    def init_vector(self, x, dim):init_vector50,2211
    def solve(self, x, b):solve56,2346
class BFGS_operator:BFGS_operator61,2419
    def __init__(self,  parameters=BFGSoperator_ParameterList()):__init__63,2441
    def set_H0inv(self, H0inv):set_H0inv72,2675
    def solve(self, x, b):solve84,2922
    def update(self, s, y):update121,3979
class BFGS:BFGS174,5481
    termination_reasons = [termination_reasons194,6566
    def __init__(self, model, parameters=BFGS_ParameterList()):__init__201,6920
    def solve(self, x, H0inv, bounds_xPARAM=None):solve218,7420

hippylib/algorithms/__init__.py,0

hippylib/algorithms/multivector.py,1150
import dolfin as dldl16,627
import numpy as npnp18,699
abspath = os.path.dirname( os.path.abspath(__file__) )abspath21,729
source_directory = os.path.join(abspath,"cpp_multivector")source_directory22,784
    cpp_code    = cpp_file.read()cpp_code24,921
include_dirs = [".", source_directory]include_dirs27,957
cpp_module = dl.compile_cpp_code(cpp_code, include_dirs=include_dirs)cpp_module28,996
class MultiVector(cpp_module.MultiVector):MultiVector31,1068
    def dot_v(self, v):dot_v32,1111
    def dot_mv(self,mv):dot_mv35,1167
    def Borthogonalize(self,B):Borthogonalize40,1309
    def orthogonalize(self):orthogonalize62,1989
    def _mgs_stable(self, B):_mgs_stable83,2641
    def _mgs_reortho(self):_mgs_reortho138,4527
    def export(self, Vh, filename, varname = "mv", normalize=False):export175,5589
    def _exportXDMF(self, Vh, filename, varname, normalize):_exportXDMF191,6238
    def _exportFile(self, Vh, filename, varname, normalize):_exportFile213,7008
def MatMvMult(A, x, y):MatMvMult232,7621
def MatMvTranspmult(A, x, y):MatMvTranspmult240,7856
def MvDSmatMult(X, A, Y):MvDSmatMult249,8207

hippylib/algorithms/cgsolverSteihaug.py,692
import dolfin as dldl16,627
def CGSolverSteihaug_ParameterList():CGSolverSteihaug_ParameterList20,708
class CGSolverSteihaug:CGSolverSteihaug33,1543
    reason = ["Maximum Number of Iterations Reached",reason67,3322
    def __init__(self, parameters=CGSolverSteihaug_ParameterList(),comm = dl.MPI.comm_world ):__init__72,3542
    def set_operator(self, A):set_operator94,4151
    def set_preconditioner(self, B_solver):set_preconditioner105,4428
    def set_TR(self,radius,B_op):set_TR111,4572
    def update_x_without_TR(self,x,alpha,d):update_x_without_TR118,4813
    def update_x_with_TR(self,x,alpha,d):update_x_with_TR122,4904
    def solve(self,x,b):solve152,5868

hippylib/test/test_deprecation_warnings.py,437
def blabla(a):blabla24,772
def blu1(a):blu128,853
class TestDeprecationWarnings(unittest.TestCase):TestDeprecationWarnings32,893
    def test_deprecated_no_name(self):test_deprecated_no_name36,999
    def test_deprecated_with_name(self):test_deprecated_with_name43,1329
    import dolfin as dldl51,1681
    mpi_comm_world = dl.MPI.comm_worldmpi_comm_world52,1705
    mpi_size = dl.MPI.size(mpi_comm_world)mpi_size53,1744

hippylib/test/ptest_collectives.py,384
import dolfin as dldl17,644
import numpy as npnp18,664
from hippylib import scheduling as clcl25,765
class TestCollectives(unittest.TestCase):TestCollectives27,804
    def setUp(self):setUp28,846
    def testfloat(self):testfloat38,1163
    def testint(self):testint46,1406
    def testndarray(self):testndarray55,1638
    def testdlVector(self):testdlVector71,2118

hippylib/test/ptest_randomizedSVD.py,561
import dolfin as dldl17,644
import numpy as npnp19,675
class J_op:J_op25,756
    def __init__(self, B, Asolver, C):__init__29,831
    def init_vector(self, x, dim):init_vector40,1229
    def mpi_comm(self):mpi_comm48,1429
    def mult(self, x, y):mult51,1487
    def transpmult(self, x, y):transpmult56,1649
class TestRandomizedSVD(unittest.TestCase):TestRandomizedSVD62,1839
    def setUp(self):setUp63,1883
    def testAccuracyEnhancedSVD(self):testAccuracyEnhancedSVD113,3447
    def testSinglePassSVD(self):testSinglePassSVD146,4641

hippylib/test/ptest_randomizedEigensolver.py,608
import dolfin as dldl17,644
import numpy as npnp19,675
class Hop:Hop28,944
    def __init__(self,B, Asolver, C):__init__32,1028
    def mult(self,x,y):mult47,1425
    def mpi_comm(self):mpi_comm55,1733
    def init_vector(self,x,dim):init_vector58,1791
class TestRandomizedEigensolver(unittest.TestCase):TestRandomizedEigensolver63,1859
    def setUp(self):setUp64,1911
    def testSinglePass(self):testSinglePass118,3692
    def testDoublePass(self):testDoublePass145,4531
    def testSinglePassG(self):testSinglePassG172,5370
    def testDoublePassG(self):testDoublePassG201,6292

hippylib/test/ptest_numpy2expression.py,244
import dolfin as dldl17,644
import numpy as npnp18,664
class TestNumpy2Expression(unittest.TestCase):TestNumpy2Expression26,788
    def test1D(self):test1D28,844
    def test2D(self):test2D50,1470
    def test3D(self):test3D78,2312

hippylib/test/test_gaussian_real_prior.py,1064
import dolfin as dldl17,644
import numpy as npnp18,664
def get_prior_sample(pr):get_prior_sample26,788
class TestGaussianRealPrior(unittest.TestCase):TestGaussianRealPrior38,1015
    def setUp(self):setUp43,1123
    def tearDown(self):tearDown74,2051
    def test_incompatible_cov(self):test_incompatible_cov78,2108
    def test_int_cov(self):test_int_cov87,2402
    def test_cost_at_mean(self):test_cost_at_mean97,2676
    def test_cost_sample(self):test_cost_sample108,2973
    def test_sample_mean(self):test_sample_mean124,3411
    def test_sample_cov(self):test_sample_cov142,3946
    def test_trace(self):test_trace162,4503
    def test_grad(self):test_grad175,4848
    def test_Rinv_sqrt(self):test_Rinv_sqrt190,5321
    def test_R_sqrt(self):test_R_sqrt201,5635
    def test_precision_matrix(self):test_precision_matrix210,5940
    def test_covariance_matrix(self):test_covariance_matrix219,6233
    mpi_comm_world = dl.MPI.comm_worldmpi_comm_world230,6567
    mpi_size = dl.MPI.size(mpi_comm_world)mpi_size231,6606

hippylib/test/__init__.py,0

hippylib/test/test_experimental_warnings.py,444
def blabla(a):blabla24,776
def blu1(a):blu128,859
class TestExperimentalWarnings(unittest.TestCase):TestExperimentalWarnings32,899
    def test_experimental_no_name(self):test_experimental_no_name36,1006
    def test_deprecated_with_name(self):test_deprecated_with_name43,1353
    import dolfin as dldl51,1720
    mpi_comm_world = dl.MPI.comm_worldmpi_comm_world52,1744
    mpi_size = dl.MPI.size(mpi_comm_world)mpi_size53,1783

hippylib/test/ptest_numpy2meshFunction.py,248
import dolfin as dldl17,644
import numpy as npnp18,664
class TestNumpy2MeshFunction(unittest.TestCase):TestNumpy2MeshFunction26,788
    def test1D(self):test1D28,846
    def test2D(self):test2D45,1404
    def test3D(self):test3D67,2144

hippylib/test/ptest_pointwise_observation.py,375
import dolfin as dldl17,644
import numpy as npnp18,664
class TestPointwiseObservation(unittest.TestCase):TestPointwiseObservation26,788
    def setUp(self):setUp27,839
    def testScalarObservations(self):testScalarObservations37,1196
    def testVectorObservations(self):testVectorObservations51,1681
    def testRTObservations(self):testRTObservations65,2226

hippylib/test/ptest_qoi.py,521
import dolfin as dldl17,644
import numpy as npnp19,675
class GammaCenter(dl.SubDomain):GammaCenter25,756
    def inside(self, x, on_boundary):inside26,789
def u_boundary(x, on_boundary):u_boundary29,876
def v_boundary(x, on_boundary):v_boundary32,990
class TestVariationalQoi(unittest.TestCase):TestVariationalQoi35,1104
    def setUp(self):setUp36,1149
        def pde_varf(u,m,p):pde_varf56,1836
        def qoi_varf(u,m):qoi_varf68,2362
    def testVariationalQOI(self):testVariationalQOI74,2525

hippylib/test/ptest_multivector.py,294
import dolfin as dldl17,644
import numpy as npnp19,675
class TestMultiVector(unittest.TestCase):TestMultiVector26,786
    def setUp(self):setUp27,828
    def testOrthogonalization(self):testOrthogonalization42,1326
    def testBOrthogonalization(self):testBOrthogonalization51,1639

hippylib/utils/experimental.py,189
def experimental(name=None, version=None, msg=""):experimental24,851
    def experimental_function(f):experimental_function37,1480
        def wrapped(*args, **kwargs):wrapped39,1532

hippylib/utils/parameterList.py,252
class ParameterList(object):ParameterList16,627
    def __init__(self, data):__init__21,831
    def __getitem__(self,key):__getitem__27,998
    def __setitem__(self,key, value):__setitem__33,1163
    def showMe(self, indent=""):showMe39,1336

hippylib/utils/deprecate.py,181
def deprecated(name=None, version=None, msg=""):deprecated24,848
    def deprecated_function(f):deprecated_function37,1456
        def wrapped(*args, **kwargs):wrapped39,1506

hippylib/utils/cpp_cartesian2mesh/pybind_module.cpp,50
PYBIND11_MODULE(SIGNATURE, m)PYBIND11_MODULE1,0

hippylib/utils/cpp_cartesian2mesh/numpy2MeshFunction.cpp,379
void numpy2MeshFunction3D(dl::Mesh & mesh,numpy2MeshFunction3D15,244
void numpy2MeshFunction2D(dl::Mesh & mesh,numpy2MeshFunction2D57,1122
void numpy2MeshFunction1D(dl::Mesh & mesh,numpy2MeshFunction1D91,1804
void numpy2MeshFunction(dl::Mesh & mesh,numpy2MeshFunction115,2292
void numpy2MeshFunction_with_offsets(dl::Mesh & mesh,numpy2MeshFunction_with_offsets129,2742

hippylib/utils/cpp_cartesian2mesh/numpy2Expression.cpp,1707
class NumpyScalarExpression3D : public dolfin::ExpressionNumpyScalarExpression3D10,183
	NumpyScalarExpression3D() :NumpyScalarExpression3D13,251
void eval(Eigen::Ref<Eigen::VectorXd> values, Eigen::Ref<const Eigen::VectorXd> x) consteval25,391
  void setData(py::array_t<double>& d, double & hh_x, double & hh_y, double & hh_z)setData77,2046
  void setOffset(double & offset_x, double & offset_y, double & offset_z)setOffset84,2196
  py::array_t<double> data;data92,2351
  double h_x;h_x93,2379
  double h_y;h_y94,2393
  double h_z;h_z95,2407
  double off_x;off_x96,2421
  double off_y;off_y97,2437
  double off_z;off_z98,2453
class NumpyScalarExpression2D : public dolfin::ExpressionNumpyScalarExpression2D102,2474
	NumpyScalarExpression2D() :NumpyScalarExpression2D105,2542
void eval(Eigen::Ref<Eigen::VectorXd> values, Eigen::Ref<const Eigen::VectorXd> x) consteval115,2660
  void setData(py::array_t<double>& d, double & hh_x, double & hh_y)setData152,3660
  void setOffset(double & offset_x, double & offset_y)setOffset158,3780
  py::array_t<double> data;data165,3895
  double h_x;h_x166,3923
  double h_y;h_y167,3937
  double off_x;off_x168,3951
  double off_y;off_y169,3967
class NumpyScalarExpression1D : public dolfin::ExpressionNumpyScalarExpression1D173,3988
	NumpyScalarExpression1D() :NumpyScalarExpression1D176,4056
void eval(Eigen::Ref<Eigen::VectorXd> values, Eigen::Ref<const Eigen::VectorXd> x) consteval184,4152
  void setData(py::array_t<double>& d, double & hh_x)setData209,4687
  void setOffset(double & offset_x)setOffset214,4777
  py::array_t<double> data;data220,4852
  double h_x;h_x221,4880
  double off_x;off_x222,4894

hippylib/utils/__init__.py,0

hippylib/utils/cpp_rand/PRNG.cpp,786
namespace hippylibhippylib23,754
Random::Random(int seed):Random25,775
void Random::split(int _rank, int _nproc, int _block_size)split33,859
double Random::uniform(double a, double b)uniform38,963
double Random::normal(double mu, double sigma)normal44,1062
double Random::gamma(double alpha, double beta)gamma50,1165
double Random::rademacher()rademacher60,1437
void Random::uniform(dolfin::GenericVector & v, double a, double b)uniform69,1544
void Random::normal(dolfin::GenericVector & v, double sigma, bool zero_out)normal86,1933
void Random::gamma(dolfin::GenericVector & v, double alpha, double beta, bool dont_speckle)gamma106,2353
void Random::rademacher(dolfin::GenericVector & v)rademacher133,2916
PYBIND11_MODULE(SIGNATURE, m) {PYBIND11_MODULE157,3341

hippylib/utils/cpp_rand/PRNG.h,1035
namespace hippylibhippylib21,718
class PRNGPRNG25,763
	typedef typename Engine::result_type result_type;result_type28,784
	explicit PRNG(result_type value = Engine::default_seed):PRNG30,836
	explicit PRNG( Sseq & s):PRNG41,1016
	void seed( result_type value = Engine::default_seed )seed52,1133
	void seed( Sseq& seq )seed59,1261
	result_type operator()()operator ()65,1332
	void discard( unsigned long long z )discard80,1528
	static constexpr result_type min()min86,1623
	static constexpr result_type max()max91,1690
	void split(int _rank, int _nproc, int _block_size)split96,1757
	Engine eng;eng115,2095
	int rank;rank116,2108
	int nproc;nproc117,2119
	int block_size;block_size118,2131
	bool is_splitted;is_splitted119,2148
	int used;used120,2167
class RandomRandom125,2184
	PRNG<std::mt19937> eng;eng141,2695
	std::normal_distribution<> d_normal;d_normal142,2720
	std::uniform_real_distribution<> d_uniform;d_uniform143,2758
	std::bernoulli_distribution d_bernoulli;d_bernoulli144,2803

hippylib/utils/random.py,973
import dolfin as dldl16,627
abspath = os.path.dirname( os.path.abspath(__file__) )abspath19,658
source_directory = os.path.join(abspath,"cpp_rand")source_directory20,713
    cpp_code    = cpp_file.read()cpp_code23,837
include_dirs = [".", source_directory]include_dirs26,873
cpp_module = dl.compile_cpp_code(cpp_code, include_dirs=include_dirs)cpp_module29,922
class Random(cpp_module.Random):Random32,994
    def __init__(self,myid=0, nproc=1, blocksize=1000000, seed=1):__init__36,1117
    def uniform(self,a,b, out=None):uniform50,1683
    def normal(self, sigma, out=None):normal68,2377
    def normal_perturb(self,sigma, out):normal_perturb85,3098
    def speckle(self,M, out):speckle99,3716
    def rademacher(self, out=None):rademacher113,4326
_world_rank = dl.MPI.rank(dl.MPI.comm_world)_world_rank126,4807
_world_size = dl.MPI.size(dl.MPI.comm_world)_world_size127,4852
parRandom = Random(_world_rank, _world_size)parRandom129,4898

hippylib/utils/warnings.py,171
class hIPPYlibDeprecationWarning(DeprecationWarning):hIPPYlibDeprecationWarning16,631
class hIPPYlibExperimentalWarning(UserWarning):hIPPYlibExperimentalWarning19,695

hippylib/utils/nb.py,1172
import matplotlib.pyplot as pltplt16,627
import matplotlib.tri as tritri17,659
import matplotlib.colors as clscls18,688
import dolfin as dldl19,720
import numpy as npnp20,740
def _mesh2triang(mesh):_mesh2triang27,835
def _mplot_cellfunction(cellfn):_mplot_cellfunction31,951
def _mplot_function(f, vmin, vmax, logscale):_mplot_function36,1090
def plot(obj, colorbar=True, subplot_loc=None, mytitle=None, show_axis='off', vmin=None, vmax=Noplot66,2459
def multi1_plot(objs, titles, same_colorbar=True, show_axis='off', logscale=False, vmin=None, vmmulti1_plot102,3558
def plot_pts(points, values, colorbar=True, subplot_loc=None, mytitle=None, show_axis='on', vminplot_pts137,4701
def show_solution(Vh, ic, state, same_colorbar=True, colorbar=True, mytitle=None, show_solution170,5535
def animate(Vh, state, same_colorbar=True, colorbar=True,animate214,6804
    def my_animate(i):my_animate236,7356
def coarsen_v(fun, nx = 16, ny = 16):coarsen_v245,7763
def plot_eigenvalues(d, mytitle = None, subplot_loc=None):plot_eigenvalues254,8071
def plot_eigenvectors(Vh, U, mytitle, which = [0,1,2,5,10,15], cmap = None):plot_eigenvectors266,8397

hippylib/utils/vector2function.py,60
def vector2Function(x,Vh, **kwargs):vector2Function18,656

hippylib/utils/cartesian2mesh.py,712
import dolfin as dldl6,49
abspath = os.path.dirname( os.path.abspath(__file__) )abspath9,84
source_directory = os.path.join(abspath,"cpp_cartesian2mesh")source_directory10,139
cpp_code = ""cpp_code11,201
include_dirs = [".", source_directory]include_dirs16,413
cpp_module = dl.compile_cpp_code(cpp_code, include_dirs=include_dirs)cpp_module17,452
numpy2MeshFunction = cpp_module.numpy2MeshFunctionnumpy2MeshFunction19,523
NumpyScalarExpression3D = cpp_module.NumpyScalarExpression3DNumpyScalarExpression3D20,574
NumpyScalarExpression2D = cpp_module.NumpyScalarExpression2DNumpyScalarExpression2D21,635
NumpyScalarExpression1D = cpp_module.NumpyScalarExpression1DNumpyScalarExpression1D22,696

hippylib/utils/checkDolfinVersion.py,168
import dolfin as dldl16,627
def dlversion():dlversion19,649
supported_versions = [(2019,1,0)]supported_versions25,800
def checkdlversion():checkdlversion27,835

TAGS,0

README.md,0

applications/ad_diff/targets.txt,0

applications/ad_diff/model_ad_diff.py,5822
import dolfin as dldl16,627
import numpy as npnp18,658
import matplotlib.pyplot as pltplt19,677
class SpaceTimePointwiseStateObservation(Misfit):SpaceTimePointwiseStateObservation27,836
    def __init__(self, Vh,__init__28,886
    def observe(self, x, obs):        observe56,1751
    def cost(self, x):cost64,2024
    def grad(self, i, x, out):grad75,2433
    def setLinearizationPoint(self, x, gauss_newton_approx=False):setLinearizationPoint89,3010
    def apply_ij(self, i,j, direction, out):apply_ij92,3095
class TimeDependentAD:    TimeDependentAD106,3589
    def __init__(self, mesh, Vh, prior, misfit, simulation_times, wind_velocity, gls_stab):__init__107,3616
    def generate_vector(self, component = "ALL"):generate_vector153,5639
    def init_parameter(self, m):init_parameter177,6470
    def cost(self, x):cost181,6559
    def solveFwd(self, out, x):solveFwd192,6865
    def solveAdj(self, out, x):solveAdj205,7238
    def evalGradientParameter(self,x, mg, misfit_only=False):evalGradientParameter234,8067
    def setPointForHessianEvaluations(self, x, gauss_newton_approx=False):setPointForHessianEvaluations258,8695
    def solveFwdIncremental(self, sol, rhs):solveFwdIncremental269,9067
    def solveAdjIncremental(self, sol, rhs):solveAdjIncremental290,9637
    def applyC(self, dm, out):applyC310,10219
    def applyCt(self, dp, out):applyCt323,10564
    def applyWuu(self, du, out):applyWuu332,10782
    def applyWum(self, dm, out):applyWum337,10892
    def applyWmu(self, du, out):applyWmu341,10950
    def applyR(self, dm, out):applyR344,11007
    def applyWmm(self, dm, out):applyWmm347,11077
    def exportState(self, x, filename, varname):exportState350,11138
def v_boundary(x,on_boundary):v_boundary363,11724
def q_boundary(x,on_boundary):q_boundary366,11779
def computeVelocityField(mesh):computeVelocityField369,11876
    def strain(v):strain388,12503
    parser = argparse.ArgumentParser(description='Model Advection Diffusion')parser403,13037
    args = parser.parse_args()args412,13445
    sep = "\n"+"#"*80+"\n"sep418,13565
    nref = args.nrefnref420,13593
    mesh = dl.Mesh(args.mesh)mesh422,13615
        mesh = dl.refine(mesh)mesh424,13671
    rank = dl.MPI.rank(mesh.mpi_comm())rank426,13703
    nproc = dl.MPI.size(mesh.mpi_comm())nproc427,13743
    Vh = dl.FunctionSpace(mesh, "Lagrange", 2)Vh431,13909
    ndofs = Vh.dim()ndofs432,13956
    ic_expr = dl.Expression('min(0.5,exp(-100*(pow(x[0]-0.35,2) +  pow(x[1]-0.7,2))))', element=ic_expr439,14142
    true_initial_condition = dl.interpolate(ic_expr, Vh).vector()true_initial_condition440,14256
    gamma = 1.gamma443,14328
    delta = 8.delta444,14343
    prior = BiLaplacianPrior(Vh, gamma, delta, robin_bc=True)prior445,14358
    t_init         = 0.t_init452,14646
    t_final        = 4.t_final453,14670
    t_1            = 1.t_1454,14694
    dt             = .1dt455,14718
    observation_dt = .2observation_dt456,14742
    simulation_times = np.arange(t_init, t_final+.5*dt, dt)simulation_times458,14771
    observation_times = np.arange(t_1, t_final+.5*dt, observation_dt)observation_times459,14831
    targets = np.loadtxt('targets.txt')targets461,14906
    misfit = SpaceTimePointwiseStateObservation(Vh, observation_times, targets)misfit464,15042
    wind_velocity = computeVelocityField(mesh)wind_velocity466,15127
    problem = TimeDependentAD(mesh, [Vh,Vh,Vh], prior, misfit, simulation_times, wind_velocity, problem468,15175
    rel_noise = 0.01rel_noise472,15360
    utrue = problem.generate_vector(STATE)utrue473,15381
    x = [utrue, true_initial_condition, None]x474,15424
    MAX = misfit.d.norm("linf", "linf")MAX477,15536
    noise_std_dev = rel_noise * MAXnoise_std_dev478,15576
    m0 = true_initial_condition.copy()m0485,15825
    mg = problem.generate_vector(PARAMETER)mg493,16152
    grad_norm = problem.evalGradientParameter([u,m,p], mg)grad_norm494,16196
    H = ReducedHessian(problem, misfit_only=True) H502,16440
    k = 80k503,16491
    p = 20p504,16502
    Omega = MultiVector(x[PARAMETER], k+p)Omega508,16637
    d, U = doublePassG(H, prior.R, prior.Rsolver, Omega, k, s=1, check=False)d511,16713
    d, U = doublePassG(H, prior.R, prior.Rsolver, Omega, k, s=1, check=False)U511,16713
    posterior = GaussianLRPosterior(prior, d, U)posterior512,16791
        P = posterior.HlrP515,16858
        P = prior.RsolverP517,16894
    solver = CGSolverSteihaug()solver524,17030
    total_cost, reg_cost, misfit_cost = problem.cost([u,m,p])total_cost534,17335
    total_cost, reg_cost, misfit_cost = problem.cost([u,m,p])reg_cost534,17335
    total_cost, reg_cost, misfit_cost = problem.cost([u,m,p])misfit_cost534,17335
    compute_trace = Falsecompute_trace540,17555
        post_tr, prior_tr, corr_tr = posterior.trace(method="Randomized", r=200)post_tr542,17603
        post_tr, prior_tr, corr_tr = posterior.trace(method="Randomized", r=200)prior_tr542,17603
        post_tr, prior_tr, corr_tr = posterior.trace(method="Randomized", r=200)corr_tr542,17603
    post_pw_variance, pr_pw_variance, corr_pw_variance = posterior.pointwise_variance(method="Rapost_pw_variance545,17832
    post_pw_variance, pr_pw_variance, corr_pw_variance = posterior.pointwise_variance(method="Rapr_pw_variance545,17832
    post_pw_variance, pr_pw_variance, corr_pw_variance = posterior.pointwise_variance(method="Racorr_pw_variance545,17832
    fid_prmean  = dl.XDMFFile(mesh.mpi_comm(), "results/pr_mean.xdmf")fid_prmean564,18766
    nsamples = 50nsamples570,19004
    noise = dl.Vector()noise571,19022
    s_prior = dl.Function(Vh, name="sample_prior")s_prior573,19087
    s_post = dl.Function(Vh, name="sample_post")s_post574,19138

applications/ad_diff/ad_10k.xml,0

applications/ad_diff/ad_20.xml,0

applications/forward_uq/model_subsurf_effperm.py,2825
import dolfin as dldl18,655
import numpy as npnp24,795
    import matplotlib.pyplot as pltplt27,820
    has_plt = Truehas_plt28,856
    has_plt = Falsehas_plt30,883
class GammaCenter(dl.SubDomain):GammaCenter32,904
    def inside(self, x, on_boundary):inside33,937
def u_boundary(x, on_boundary):u_boundary36,1024
def v_boundary(x, on_boundary):v_boundary39,1138
def true_model(Vh, gamma, delta, anis_diff):true_model42,1252
    parser = argparse.ArgumentParser(description='Model Subsurface')parser53,1592
    args = parser.parse_args()args66,2159
    sep = "\n"+"#"*80+"\n"sep68,2219
    ndim = 2ndim69,2246
    nx = args.nxnx70,2259
    ny = args.nyny71,2276
    mesh = dl.UnitSquareMesh(nx, ny)mesh74,2347
    rank = dl.MPI.rank(mesh.mpi_comm())rank76,2389
    Vh2 = dl.FunctionSpace(mesh, 'Lagrange', 2)Vh278,2438
    Vh1 = dl.FunctionSpace(mesh, 'Lagrange', 1)Vh179,2486
    Vh = [Vh2, Vh1, Vh2]Vh80,2534
    ndofs = [Vh[STATE].dim(), Vh[PARAMETER].dim(), Vh[ADJOINT].dim()]ndofs81,2559
    f = dl.Constant(0.0)f87,2839
    u_bdr = dl.Expression("x[1]", degree=1)u_bdr89,2873
    u_bdr0 = dl.Constant(0.0)u_bdr090,2917
    bc = dl.DirichletBC(Vh[STATE], u_bdr, u_boundary)bc91,2947
    bc0 = dl.DirichletBC(Vh[STATE], u_bdr0, u_boundary)bc092,3001
    def pde_varf(u,m,p):pde_varf94,3062
    pde = PDEVariationalProblem(Vh, pde_varf, bc, bc0, is_fwd_linear=True)pde97,3174
    gamma = .1gamma106,3715
    delta = .5delta107,3730
    theta0 = 2.theta0109,3750
    theta1 = .5theta1110,3766
    alpha  = math.pi/4alpha111,3782
    anis_diff = dl.CompiledExpression(ExpressionModule.AnisTensor2D(), degree = 1)anis_diff113,3810
    mtrue = true_model(Vh[PARAMETER], gamma, delta,anis_diff)mtrue115,3934
    locations = np.array([[0.1, 0.1], [0.1, 0.9], [.5,.5], [.9, .1], [.9, .9]])locations117,3997
    pen = 1e1pen119,4078
    prior = MollifiedBiLaplacianPrior(Vh[PARAMETER], gamma, delta, locations, mtrue, anis_diff, prior120,4092
    GC = GammaCenter()GC125,4360
    marker = dl.MeshFunction("size_t", mesh, mesh.topology().dim()-1)marker126,4383
    dss = dl.Measure("dS", domain=mesh, subdomain_data=marker)dss129,4498
    n = dl.Constant((0.,1.))#dl.FacetNormal(Vh[STATE].mesh())n130,4561
    def qoi_varf(u,m):qoi_varf132,4624
    qoi = VariationalQoi(Vh,qoi_varf) qoi135,4716
    p2qoimap = Parameter2QoiMap(pde, qoi)p2qoimap136,4755
    k = 100    k141,4929
    Omega = MultiVector(prior.mean, k)Omega142,4945
    q_taylor = TaylorApproximationQoi(p2qoimap, prior)q_taylor145,5021
    e_lin  = q_taylor.expectedValue(order=1)e_lin151,5188
    e_quad = q_taylor.expectedValue(order=2)e_quad152,5233
    v_lin  = q_taylor.variance(order=1)v_lin153,5278
    v_quad = q_taylor.variance(order=1)v_quad154,5318

applications/mcmc/model_subsurf.py,4359
import dolfin as dldl16,627
import numpy as npnp19,670
import matplotlib.pyplot as pltplt20,689
class FluxQOI(object):FluxQOI28,848
    def __init__(self, Vh, dsGamma):__init__29,871
    def form(self, x):form38,1113
    def eval(self, x):eval42,1326
class GammaBottom(dl.SubDomain):GammaBottom51,1651
    def inside(self, x, on_boundary):inside52,1684
def u_boundary(x, on_boundary):u_boundary55,1775
def v_boundary(x, on_boundary):v_boundary58,1889
def true_model(Vh, gamma, delta, anis_diff):true_model61,2003
    parser = argparse.ArgumentParser(description='Model Subsurface')parser72,2343
    args = parser.parse_args()args85,2912
    sep = "\n"+"#"*80+"\n"sep90,3010
    ndim = 2ndim91,3037
    nx = args.nx  nx92,3050
    ny = args.nyny93,3069
    mesh = dl.UnitSquareMesh(nx, ny)mesh94,3086
    rank = dl.MPI.rank(mesh.mpi_comm())rank96,3128
    nproc = dl.MPI.size(mesh.mpi_comm())nproc97,3168
    Vh2 = dl.FunctionSpace(mesh, 'Lagrange', 2)Vh299,3218
    Vh1 = dl.FunctionSpace(mesh, 'Lagrange', 1)Vh1100,3266
    Vh = [Vh2, Vh1, Vh2]Vh101,3314
    ndofs = [Vh[STATE].dim(), Vh[PARAMETER].dim(), Vh[ADJOINT].dim()]ndofs103,3344
    f = dl.Constant(0.0)f109,3628
    u_bdr = dl.Expression("x[1]", degree = 1)u_bdr111,3662
    u_bdr0 = dl.Constant(0.0)u_bdr0112,3708
    bc = dl.DirichletBC(Vh[STATE], u_bdr, u_boundary)bc113,3738
    bc0 = dl.DirichletBC(Vh[STATE], u_bdr0, u_boundary)bc0114,3792
    def pde_varf(u,m,p):pde_varf116,3853
    pde = PDEVariationalProblem(Vh, pde_varf, bc, bc0, is_fwd_linear=True)pde119,3965
    ntargets = 300ntargets129,4503
    targets = np.random.uniform(0.1,0.9, [ntargets, ndim] )targets131,4549
    misfit = PointwiseStateObservation(Vh[STATE], targets)misfit134,4697
    gamma = .1gamma137,4766
    delta = .5delta138,4781
    theta0 = 2.theta0140,4801
    theta1 = .5theta1141,4817
    alpha  = math.pi/4alpha142,4833
    anis_diff = dl.CompiledExpression(ExpressionModule.AnisTensor2D(), degree = 1)anis_diff144,4861
    mtrue = true_model(Vh[PARAMETER], gamma, delta,anis_diff)mtrue147,4990
    prior = BiLaplacianPrior(Vh[PARAMETER], gamma, delta, anis_diff, robin_bc=True)prior149,5061
    utrue = pde.generate_state()utrue155,5360
    x = [utrue, mtrue, None]x156,5393
    rel_noise = 0.01rel_noise159,5490
    MAX = misfit.d.norm("linf")MAX160,5511
    noise_std_dev = rel_noise * MAXnoise_std_dev161,5543
    model = Model(pde,prior, misfit)model165,5694
    m = prior.mean.copy()m169,5809
    parameters = ReducedSpaceNewtonCG_ParameterList()parameters170,5835
    solver = ReducedSpaceNewtonCG(model, parameters)solver178,6131
    x = solver.solve([None, m, None])x180,6189
    Hmisfit = ReducedHessian(model, misfit_only=True)Hmisfit194,6724
    k = 50k195,6778
    p = 20p196,6789
    Omega = MultiVector(x[PARAMETER], k+p)Omega200,6924
    d, U = doublePassG(Hmisfit, prior.R, prior.Rsolver, Omega, k, s=2, check = False)d203,7008
    d, U = doublePassG(Hmisfit, prior.R, prior.Rsolver, Omega, k, s=2, check = False)U203,7008
    nu = GaussianLRPosterior(prior, d, U)nu205,7113
    GC = GammaBottom()GC209,7205
    marker = dl.MeshFunction("size_t", mesh, 1)marker210,7228
    dss = dl.Measure("ds", subdomain_data=marker)dss213,7321
    qoi = FluxQOI(Vh,dss(1))qoi214,7371
    kMALA = MALAKernel(model)kMALA216,7405
    kpCN = pCNKernel(model)kpCN219,7481
    kgpCN = gpCNKernel(model,nu)kgpCN222,7547
    kIS = ISKernel(model,nu)kIS225,7617
    noise = dl.Vector()noise227,7651
    pr_s = model.generate_vector(PARAMETER)pr_s230,7742
    post_s = model.generate_vector(PARAMETER)post_s231,7786
        fid_m = dl.XDMFFile("results/"+kernel.name()+"/parameter.xdmf")fid_m240,8016
        fid_u = dl.XDMFFile("results/"+kernel.name()+"/state.xdmf")fid_u243,8202
        chain = MCMC(kernel)chain246,8384
        tracer = FullTracer(chain.parameters["number_of_samples"], Vh, fid_m, fid_u)tracer250,8575
        n_accept = chain.run(post_s, qoi, tracer)n_accept254,8740
        iact, lags, acoors = integratedAutocorrelationTime(tracer.data[:,0])iact256,8799
        iact, lags, acoors = integratedAutocorrelationTime(tracer.data[:,0])lags256,8799
        iact, lags, acoors = integratedAutocorrelationTime(tracer.data[:,0])acoors256,8799

applications/poisson/model_continuous_obs.py,3218
import dolfin as dldl16,627
import numpy as npnp18,658
import matplotlib.pyplot as pltplt19,677
def u_boundary(x, on_boundary):u_boundary28,837
class Poisson:Poisson31,893
    def __init__(self, mesh, Vh, prior):__init__32,908
    def generate_vector(self, component="ALL"):generate_vector78,2682
    def init_parameter(self, m):init_parameter105,3694
    def assembleA(self,x, assemble_adjoint = False, assemble_rhs = False):assembleA111,3867
    def assembleC(self, x):assembleC134,4869
    def assembleWuu(self):assembleWuu148,5485
    def assembleWmu(self, x):assembleWmu162,5888
    def assembleWmm(self, x):assembleWmm177,6471
    def computeObservation(self, u_o):computeObservation190,7030
    def cost(self, x):cost204,7462
    def solveFwd(self, out, x):solveFwd229,8297
    def solveAdj(self, out, x):solveAdj240,8548
    def evalGradientParameter(self,x, mg, misfit_only=False):evalGradientParameter252,8937
    def setPointForHessianEvaluations(self, x, gauss_newton_approx=False):  setPointForHessianEvaluations281,9919
    def solveFwdIncremental(self, sol, rhs):solveFwdIncremental301,10657
    def solveAdjIncremental(self, sol, rhs):solveAdjIncremental308,10874
    def applyC(self, dm, out):applyC316,11177
    def applyCt(self, dp, out):applyCt319,11241
    def applyWuu(self, du, out, gn_approx=False):applyWuu322,11312
    def applyWum(self, dm, out):applyWum325,11398
    def applyWmu(self, du, out):applyWmu332,11551
    def applyR(self, dm, out):applyR338,11698
    def Rsolver(self):        Rsolver341,11773
    def applyWmm(self, dm, out):applyWmm344,11843
    parser = argparse.ArgumentParser(description='Model Continuous observations')parser351,12025
    args = parser.parse_args()args360,12443
    nx = args.nxnx365,12541
    ny = args.nyny366,12558
    mesh = dl.UnitSquareMesh(nx, ny)mesh367,12575
    rank = dl.MPI.rank(mesh.mpi_comm())rank369,12617
    nproc = dl.MPI.size(mesh.mpi_comm())nproc370,12657
    Vh2 = dl.FunctionSpace(mesh, 'Lagrange', 2)Vh2372,12707
    Vh1 = dl.FunctionSpace(mesh, 'Lagrange', 1)Vh1373,12755
    Vh = [Vh2, Vh1, Vh2]Vh374,12803
    prior = LaplacianPrior(Vh[PARAMETER], gamma=1e-8, delta=1e-9)prior376,12833
    model = Poisson(mesh, Vh, prior)model377,12899
    m0 = dl.interpolate(dl.Expression("sin(x[0])", element=Vh[PARAMETER].ufl_element()), Vh[PARAm0379,12945
    m0 = dl.interpolate(dl.Constant(0.0),Vh[PARAMETER])m0382,13129
    parameters = ReducedSpaceNewtonCG_ParameterList()parameters383,13185
    solver = ReducedSpaceNewtonCG(model, parameters)solver392,13490
    x = solver.solve([None, m0.vector(), None])x395,13549
    Hmisfit = ReducedHessian(model, misfit_only=True)Hmisfit408,14038
    p = 20p409,14092
    k = 50k410,14103
    Omega = MultiVector(x[PARAMETER], k+p)Omega411,14114
    d, U = doublePassG(Hmisfit, prior.R, prior.Rsolver, Omega, k, s=1, check=False)d414,14190
    d, U = doublePassG(Hmisfit, prior.R, prior.Rsolver, Omega, k, s=1, check=False)U414,14190
    xxname = ["state", "parameter", "adjoint"]xxname416,14279
    xx = [vector2Function(x[i], Vh[i], name=xxname[i]) for i in range(len(Vh))]xx417,14326

applications/poisson/model_subsurf.py,4207
import dolfin as dldl16,627
import numpy as npnp19,670
import matplotlib.pyplot as pltplt20,689
def u_boundary(x, on_boundary):u_boundary29,849
def v_boundary(x, on_boundary):v_boundary32,963
def true_model(prior):true_model35,1077
    parser = argparse.ArgumentParser(description='Model Subsurface')parser45,1336
    args = parser.parse_args()args58,1936
    sep = "\n"+"#"*80+"\n"sep63,2034
    ndim = 2ndim64,2061
    nx = args.nxnx65,2074
    ny = args.nyny66,2091
    mesh = dl.UnitSquareMesh(nx, ny)mesh67,2108
    rank = dl.MPI.rank(mesh.mpi_comm())rank69,2150
    nproc = dl.MPI.size(mesh.mpi_comm())nproc70,2190
    Vh2 = dl.FunctionSpace(mesh, 'Lagrange', 2)Vh272,2244
    Vh1 = dl.FunctionSpace(mesh, 'Lagrange', 1)Vh173,2292
    Vh = [Vh2, Vh1, Vh2]Vh74,2340
    ndofs = [Vh[STATE].dim(), Vh[PARAMETER].dim(), Vh[ADJOINT].dim()]ndofs76,2370
    f = dl.Constant(0.0)f82,2650
    u_bdr = dl.Expression("x[1]", element = Vh[STATE].ufl_element() )u_bdr84,2684
    u_bdr0 = dl.Constant(0.0)u_bdr085,2754
    bc = dl.DirichletBC(Vh[STATE], u_bdr, u_boundary)bc86,2784
    bc0 = dl.DirichletBC(Vh[STATE], u_bdr0, u_boundary)bc087,2838
    def pde_varf(u,m,p):pde_varf89,2899
    pde = PDEVariationalProblem(Vh, pde_varf, bc, bc0, is_fwd_linear=True)pde92,3011
    ntargets = 50ntargets103,3557
    targets_x = np.random.uniform(0.1,0.9, [ntargets] )targets_x106,3634
    targets_y = np.random.uniform(0.1,0.5, [ntargets] )targets_y107,3690
    targets = np.zeros([ntargets, ndim])targets108,3746
    misfit = PointwiseStateObservation(Vh[STATE], targets)misfit115,4018
    gamma = .1gamma117,4082
    delta = .5delta118,4097
    theta0 = 2.theta0120,4117
    theta1 = .5theta1121,4133
    alpha  = math.pi/4alpha122,4149
    anis_diff = dl.CompiledExpression(ExpressionModule.AnisTensor2D(), degree = 1)anis_diff124,4177
    prior = BiLaplacianPrior(Vh[PARAMETER], gamma, delta, anis_diff, robin_bc=True )prior127,4306
    mtrue = true_model(prior)mtrue129,4396
    utrue = pde.generate_state()utrue135,4646
    x = [utrue, mtrue, None]x136,4679
    rel_noise = 0.01rel_noise139,4776
    MAX = misfit.d.norm("linf")MAX140,4797
    noise_std_dev = rel_noise * MAXnoise_std_dev141,4829
    model = Model(pde,prior, misfit)model145,4980
    m0 = dl.interpolate(dl.Expression("sin(x[0])", element=Vh[PARAMETER].ufl_element() ), Vh[PARm0150,5121
    m = prior.mean.copy()m155,5374
    parameters = ReducedSpaceNewtonCG_ParameterList()parameters156,5400
    solver = ReducedSpaceNewtonCG(model, parameters)solver167,5751
    x = solver.solve([None, m, None])x169,5809
    Hmisfit = ReducedHessian(model, misfit_only=True)Hmisfit185,6406
    k = 50k186,6460
    p = 20p187,6471
    Omega = MultiVector(x[PARAMETER], k+p)Omega191,6606
    d, U = doublePassG(Hmisfit, prior.R, prior.Rsolver, Omega, k, s=1, check=False)d194,6682
    d, U = doublePassG(Hmisfit, prior.R, prior.Rsolver, Omega, k, s=1, check=False)U194,6682
    posterior = GaussianLRPosterior(prior, d, U)posterior195,6766
    post_tr, prior_tr, corr_tr = posterior.trace(method="Randomized", r=200)post_tr199,6859
    post_tr, prior_tr, corr_tr = posterior.trace(method="Randomized", r=200)prior_tr199,6859
    post_tr, prior_tr, corr_tr = posterior.trace(method="Randomized", r=200)corr_tr199,6859
    post_pw_variance, pr_pw_variance, corr_pw_variance = posterior.pointwise_variance(method="Rapost_pw_variance203,7076
    post_pw_variance, pr_pw_variance, corr_pw_variance = posterior.pointwise_variance(method="Rapr_pw_variance203,7076
    post_pw_variance, pr_pw_variance, corr_pw_variance = posterior.pointwise_variance(method="Racorr_pw_variance203,7076
    kl_dist = posterior.klDistanceFromPrior()kl_dist205,7199
    xxname = ["state", "parameter", "adjoint"]xxname219,7885
    xx = [vector2Function(x[i], Vh[i], name=xxname[i]) for i in range(len(Vh))]xx220,7932
    nsamples = args.nsamplesnsamples238,8788
    noise = dl.Vector()noise239,8817
    s_prior = dl.Function(Vh[PARAMETER], name="sample_prior")s_prior241,8882
    s_post = dl.Function(Vh[PARAMETER], name="sample_post")s_post242,8944

applications/poisson/model_subsurf_multNoise.py,4102
import dolfin as dldl16,627
import numpy as npnp19,670
import matplotlib.pyplot as pltplt20,689
def u_boundary(x, on_boundary):u_boundary29,849
def v_boundary(x, on_boundary):v_boundary32,963
def true_model(prior):true_model35,1077
    parser = argparse.ArgumentParser(description='Model Subsurface')parser45,1336
    args = parser.parse_args()args58,1936
    sep = "\n"+"#"*80+"\n"sep63,2034
    ndim = 2ndim64,2061
    nx = args.nxnx65,2074
    ny = args.nyny66,2091
    mesh = dl.UnitSquareMesh(nx, ny)mesh67,2108
    rank = dl.MPI.rank(mesh.mpi_comm())rank69,2150
    nproc = dl.MPI.size(mesh.mpi_comm())nproc70,2190
    Vh2 = dl.FunctionSpace(mesh, 'Lagrange', 2)Vh272,2244
    Vh1 = dl.FunctionSpace(mesh, 'Lagrange', 1)Vh173,2292
    Vh = [Vh2, Vh1, Vh2]Vh74,2340
    ndofs = [Vh[STATE].dim(), Vh[PARAMETER].dim(), Vh[ADJOINT].dim()]ndofs76,2370
    f = dl.Constant(0.0)f82,2650
    u_bdr = dl.Expression("x[1]", element = Vh[STATE].ufl_element() )u_bdr84,2684
    u_bdr0 = dl.Constant(0.0)u_bdr085,2754
    bc = dl.DirichletBC(Vh[STATE], u_bdr, u_boundary)bc86,2784
    bc0 = dl.DirichletBC(Vh[STATE], u_bdr0, u_boundary)bc087,2838
    def pde_varf(u,m,p):pde_varf89,2899
    pde = PDEVariationalProblem(Vh, pde_varf, bc, bc0, is_fwd_linear=True)pde92,3011
    ntargets = 50ntargets103,3557
    targets_x = np.random.uniform(0.1,0.9, [ntargets] )targets_x106,3634
    targets_y = np.random.uniform(0.1,0.5, [ntargets] )targets_y107,3690
    targets = np.zeros([ntargets, ndim])targets108,3746
    Mpar = 1e4Mpar115,4018
    misfit = MultPointwiseStateObservation(Vh[STATE], targets, Mpar)misfit116,4033
    gamma = .1gamma118,4107
    delta = .5delta119,4122
    theta0 = 2.theta0121,4142
    theta1 = .5theta1122,4158
    alpha  = math.pi/4alpha123,4174
    anis_diff = dl.CompiledExpression(ExpressionModule.AnisTensor2D(), degree = 1)anis_diff125,4202
    prior = BiLaplacianPrior(Vh[PARAMETER], gamma, delta, anis_diff, robin_bc=True )prior128,4331
    mtrue = true_model(prior)mtrue130,4421
    utrue = pde.generate_state()utrue136,4671
    x = [utrue, mtrue, None]x137,4704
    model = Model(pde,prior, misfit)model148,4920
    m0 = dl.interpolate(dl.Expression("sin(x[0])", element=Vh[PARAMETER].ufl_element() ), Vh[PARm0153,5061
    m = prior.mean.copy()m158,5332
    parameters = ReducedSpaceNewtonCG_ParameterList()parameters159,5358
    solver = ReducedSpaceNewtonCG(model, parameters)solver170,5709
    x = solver.solve([None, m, None])x172,5767
    Hmisfit = ReducedHessian(model, misfit_only=True)Hmisfit188,6364
    k = 50k189,6418
    p = 20p190,6429
    Omega = MultiVector(x[PARAMETER], k+p)Omega194,6564
    d, U = doublePassG(Hmisfit, prior.R, prior.Rsolver, Omega, k, s=1, check=False)d197,6640
    d, U = doublePassG(Hmisfit, prior.R, prior.Rsolver, Omega, k, s=1, check=False)U197,6640
    posterior = GaussianLRPosterior(prior, d, U)posterior198,6724
    post_tr, prior_tr, corr_tr = posterior.trace(method="Randomized", r=200)post_tr202,6817
    post_tr, prior_tr, corr_tr = posterior.trace(method="Randomized", r=200)prior_tr202,6817
    post_tr, prior_tr, corr_tr = posterior.trace(method="Randomized", r=200)corr_tr202,6817
    post_pw_variance, pr_pw_variance, corr_pw_variance = posterior.pointwise_variance(method="Rapost_pw_variance206,7034
    post_pw_variance, pr_pw_variance, corr_pw_variance = posterior.pointwise_variance(method="Rapr_pw_variance206,7034
    post_pw_variance, pr_pw_variance, corr_pw_variance = posterior.pointwise_variance(method="Racorr_pw_variance206,7034
    kl_dist = posterior.klDistanceFromPrior()kl_dist208,7157
    xxname = ["state", "parameter", "adjoint"]xxname222,7843
    xx = [vector2Function(x[i], Vh[i], name=xxname[i]) for i in range(len(Vh))]xx223,7890
    nsamples = args.nsamplesnsamples241,8746
    noise = dl.Vector()noise242,8775
    s_prior = dl.Function(Vh[PARAMETER], name="sample_prior")s_prior244,8840
    s_post = dl.Function(Vh[PARAMETER], name="sample_post")s_post245,8902

paper/paper.md,103
# SummarySummary29,867
# AcknowledgementsAcknowledgements105,5261
# ReferencesReferences109,5878

paper/paper.bib,382
@article{VillaPetraGhattas18,VillaPetraGhattas181,0
@book{LangtangenLogg17,LangtangenLogg178,330
@Book{LoggMardalGarth12,LoggMardalGarth1217,556
@Article{LoggWells10,LoggWells1027,1001
@Article{Bui-ThanhGhattasMartinEtAl13,Bui-ThanhGhattasMartinEtAl1338,1447
@Article{PetraMartinStadlerEtAl14,PetraMartinStadlerEtAl1449,2050
@Misc{petsc-web-page,petsc-web-page60,2637

tutorial/.ipynb_checkpoints/1_FEniCS101-checkpoint.ipynb,0

tutorial/.ipynb_checkpoints/2_PoissonDeterministic-checkpoint.ipynb,0

tutorial/targets.txt,0

tutorial/7_GaussianPriors.ipynb,0

tutorial/3_SubsurfaceBayesian.ipynb,0

tutorial/1_FEniCS101.ipynb,0

tutorial/4_AdvectionDiffusionBayesian.ipynb,0

tutorial/2_PoissonDeterministic.ipynb,0

tutorial/ad_20.xml,0

tutorial/5_HessianSpectrum.ipynb,0

tutorial/README,0

COPYRIGHT,0