Mads

Reference

[method] —
allwellsoff!(madsdata::Associative{K, V})

Turn off all the wells in the MADS problem dictionary

[method] —
allwellson!(madsdata::Associative{K, V})

Turn on all the wells in the MADS problem dictionary

[method] —
asinetransform(params::Array{T, 1}, lowerbounds::Array{T, 1}, upperbounds::Array{T, 1}, indexlogtransformed::Array{T, 1})

Arcsine transformation of model parameters

[method] —
bayessampling(madsdata::Associative{K, V})

Bayesian Sampling

Mads.bayessampling(madsdata; nsteps=1000, burnin=100, thinning=1, seed=2016)
Mads.bayessampling(madsdata, numsequences; nsteps=1000, burnin=100, thinning=1, seed=2016)

Arguments:

  • madsdata : MADS problem dictionary
  • numsequences : number of sequences executed in parallel
  • nsteps : number of final realizations in the chain
  • burnin : number of initial realizations before the MCMC are recorded
  • thinning : removal of any thinning realization
  • seed : initial random number seed

Returns:

  • mcmcchain :
[method] —
calibrate(madsdata::Associative{K, V})

Calibrate

Mads.calibrate(madsdata; tolX=1e-3, tolG=1e-6, maxEval=1000, maxIter=100, maxJacobians=100, lambda=100.0, lambda_mu=10.0, np_lambda=10, show_trace=false, usenaive=false)

Arguments:

  • madsdata : MADS problem dictionary
  • tolX : parameter space tolerance
  • tolG : parameter space update tolerance
  • maxEval : maximum number of model evaluations
  • maxIter : maximum number of optimization iterations
  • maxJacobians : maximum number of Jacobian solves
  • lambda : initial Levenberg-Marquardt lambda
  • lambda_mu : lambda multiplication factor [10]
  • np_lambda : number of parallel lambda solves
  • show_trace : shows solution trace [default=false]
  • save_results : save intermediate results [default=true]
  • usenaive : use naive Levenberg-Marquardt solver

Returns:

  • minimumdict : model parameter dictionary with the optimal values at the minimum
  • results : optimization algorithm results (e.g. results.minimum)
[method] —
calibratenlopt(madsdata::Associative{K, V})

Do a calibration using NLopt

[method] —
calibraterandom(madsdata::Associative{K, V})

Calibrate with random initial guesses

Mads.calibraterandom(madsdata; tolX=1e-3, tolG=1e-6, maxEval=1000, maxIter=100, maxJacobians=100, lambda=100.0, lambda_mu=10.0, np_lambda=10, show_trace=false, usenaive=false)
Mads.calibraterandom(madsdata, numberofsamples; tolX=1e-3, tolG=1e-6, maxEval=1000, maxIter=100, maxJacobians=100, lambda=100.0, lambda_mu=10.0, np_lambda=10, show_trace=false, usenaive=false)

Arguments:

  • madsdata : MADS problem dictionary
  • numberofsamples : number of random initial samples
  • tolX : parameter space tolerance
  • tolG : parameter space update tolerance
  • maxEval : maximum number of model evaluations
  • maxIter : maximum number of optimization iterations
  • maxJacobians : maximum number of Jacobian solves
  • lambda : initial Levenberg-Marquardt lambda
  • lambda_mu : lambda multiplication factor [10]
  • np_lambda : number of parallel lambda solves
  • show_trace : shows solution trace [default=false]
  • save_results : save intermediate results [default=true]
  • usenaive : use naive Levenberg-Marquardt solver
  • seed : initial random seed

Returns:

  • bestresult : optimal results tuple: [1] model parameter dictionary with the optimal values at the minimum; [2] optimization algorithm results (e.g. bestresult[2].minimum)
[method] —
calibraterandom(madsdata::Associative{K, V}, numberofsamples)

Calibrate with random initial guesses

Mads.calibraterandom(madsdata; tolX=1e-3, tolG=1e-6, maxEval=1000, maxIter=100, maxJacobians=100, lambda=100.0, lambda_mu=10.0, np_lambda=10, show_trace=false, usenaive=false)
Mads.calibraterandom(madsdata, numberofsamples; tolX=1e-3, tolG=1e-6, maxEval=1000, maxIter=100, maxJacobians=100, lambda=100.0, lambda_mu=10.0, np_lambda=10, show_trace=false, usenaive=false)

Arguments:

  • madsdata : MADS problem dictionary
  • numberofsamples : number of random initial samples
  • tolX : parameter space tolerance
  • tolG : parameter space update tolerance
  • maxEval : maximum number of model evaluations
  • maxIter : maximum number of optimization iterations
  • maxJacobians : maximum number of Jacobian solves
  • lambda : initial Levenberg-Marquardt lambda
  • lambda_mu : lambda multiplication factor [10]
  • np_lambda : number of parallel lambda solves
  • show_trace : shows solution trace [default=false]
  • save_results : save intermediate results [default=true]
  • usenaive : use naive Levenberg-Marquardt solver
  • seed : initial random seed

Returns:

  • bestresult : optimal results tuple: [1] model parameter dictionary with the optimal values at the minimum; [2] optimization algorithm results (e.g. bestresult[2].minimum)
[method] —
checkout()

Checkout the latest version of the Mads modules

[method] —
checkout(git::Bool)

Checkout the latest version of the Mads modules

[method] —
cleancoverage()

Remove Mads coverage files

[method] —
cmadsins_obs(obsid::Array{T, 1}, instructionfilename::AbstractString, inputfilename::AbstractString)

Call C MADS ins_obs() function from the MADS dynamic library

[method] —
computemass(madsdata::Associative{K, V})

Compute injected/reduced contaminant mass

Mads.computemass(madsdata; time = 0)

Arguments:

  • madsdata : MADS problem dictionary
  • time : computational time

Returns:

  • mass_injected : total injected mass
  • mass_reduced : total reduced mass
[method] —
computemass(madsfiles)

Compute injected/reduced contaminant mass for a given set of mads input files

Mads.computemass(madsfiles; time = 0, path = ".")

Arguments:

  • madsfiles : matching pattern for Mads input files (string or regular expression accepted)
  • time : computational time
  • path : search directory for the mads input files

Returns:

  • lambda : array with all the lambda values
  • mass_injected : array with associated total injected mass
  • mass_reduced : array with associated total reduced mass
[method] —
computeparametersensitities(madsdata::Associative{K, V}, saresults::Associative{K, V})

Compute sensitivities for each model parameter; averaging the sensitivity indices over the entire observation range

Arguments:

  • madsdata : MADS problem dictionary
  • saresults : sensitivity analysis results
[method] —
contamination(wellx, welly, wellz, n, lambda, theta, vx, vy, vz, ax, ay, az, H, x, y, z, dx, dy, dz, f, t0, t1, t)

Compute concentration for a point in space and time (x,y,z,t)

Mads.contamination(wellx, welly, wellz, n, lambda, theta, vx, vy, vz, ax, ay, az, H, x, y, z, dx, dy, dz, f, t0, t1, t; anasolfunction="long_bbb_ddd_iir_c")

Arguments:

  • wellx - observation point (well) X coordinate
  • welly - observation point (well) Y coordinate
  • wellz - observation point (well) Z coordinate
  • n - porosity
  • lambda - first-order reaction rate
  • theta - groundwater flow direction
  • vx - advective transport velocity in X direction
  • vy - advective transport velocity in Y direction
  • vz - advective transport velocity in Z direction
  • ax - dispersivity in X direction (longitudinal)
  • ay - dispersivity in Y direction (transverse horizontal)
  • az - dispersivity in Y direction (transverse vertical)
  • H - Hurst coefficient for Fractional Brownian dispersion
  • x - X coordinate of contaminant source location
  • y - Y coordinate of contaminant source location
  • z - Z coordinate of contaminant source location
  • dx - source size (extent) in X direction
  • dy - source size (extent) in Y direction
  • dz - source size (extent) in Z direction
  • f - source mass flux
  • t0 - source starting time
  • t1 - source termination time
  • t - time to compute concentration at the observation point
  • anasolfunction : Anasol function to call (check out the Anasol module) [long_bbb_ddd_iir_c]

Returns:

  • predicted concentration at (wellx, welly, wellz, t)
[method] —
copyright()

Produce MADS copyright information

[method] —
create_documentation()

Create web documentation files for Mads functions

[method] —
create_tests_off()

Turn off the generation of MADS tests (default)

[method] —
create_tests_on()

Turn on the generation of MADS tests (dangerous)

[method] —
createmadsproblem(infilename::AbstractString, outfilename::AbstractString)

Create a new Mads problem where the observation targets are computed based on the model predictions

  • Mads.createmadsproblem(infilename, outfilename)
  • Mads.createmadsproblem(madsdata, outfilename)
  • `Mads.createmadsproblem(madsdata, predictions, outfilename)

Arguments:

  • infilename : input Mads file
  • outfilename : output Mads file
  • madsdata : MADS problem dictionary
  • predictions : dictionary of model predictions
[method] —
createobservations!(madsdata::Associative{K, V}, time, observation)

Create observations in the MADS problem dictionary based on time and observation arrays

[method] —
deleteNaN!(df::DataFrames.DataFrame)

Delete rows with NaN in a Dataframe df

[method] —
dobigdt(madsdata::Associative{K, V}, nummodelruns::Int64)

Perform BIG-DT analysis

Arguments:

  • madsdata : MADS problem dictionary
  • nummodelruns : number of model runs
  • numhorizons : number of info-gap horizons of uncertainty
  • maxHorizon : maximum info-gap horizons of uncertainty
  • numlikelihoods : number of Bayesian likelihoods

Returns:

  • bigdtresults : dictionary with BIG-DT results
[method] —
dumpasciifile(filename::AbstractString, data)

Dump ASCII file

[method] —
dumpjsonfile(filename::AbstractString, data)

Dump a JSON file

[method] —
dumpwelldata(filename::AbstractString, madsdata)

Dump well data from MADS problem dictionary into a ASCII file

[method] —
dumpyamlfile(filename::AbstractString, yamldata)

Dump YAML file in JSON format

[method] —
dumpyamlmadsfile(madsdata, filename::AbstractString)

Dump YAML Mads file

Arguments:

  • madsdata : MADS problem dictionary
  • filename : file name
[method] —
efast(md::Associative{K, V})

Sensitivity analysis using Saltelli's extended Fourier Amplitude Sensitivity Testing (eFAST) method

Arguments:

  • madsdata : MADS problem dictionary
  • N : number of samples
  • M : maximum number of harmonics
  • gamma : multiplication factor (Saltelli 1999 recommends gamma = 2 or 4)
  • seed : initial random seed
[method] —
evaluatemadsexpression(expressionstring, parameters)

Evaluate the expression in terms of the parameters, return a Dict() containing the expression names as keys, and the values of the expression as values

[method] —
evaluatemadsexpressions(madsdata::Associative{K, V}, parameters)

Evaluate the expressions in terms of the parameters, return a Dict() containing the expression names as keys, and the values of the expression as values

[method] —
filterkeys(dict::Associative{K, V}, key::Regex)

Filter dictionary keys based on a string or regular expression

[method] —
forward(madsdata::Associative{K, V})

Perform a forward run using the initial or provided values for the model parameters

  • forward(madsdata)
  • forward(madsdata, paramdict)
  • forward(madsdata, paramarray)

Arguments:

  • madsdata : MADS problem dictionary
  • paramdict : dictionary of model parameter values
  • paramarray : array of model parameter values

Returns:

  • obsvalues : dictionary of model predictions
[method] —
forwardgrid(madsdata::Associative{K, V})

Perform a forward run over a 3D grid defined in madsdata using the initial or provided values for the model parameters

  • forwardgrid(madsdata)
  • forwardgrid(madsdata, paramvalues))

Arguments:

  • madsdata : MADS problem dictionary
  • paramvalues : dictionary of model parameter values

Returns:

  • array3d : 3D array with model predictions along a 3D grid
[method] —
free()

Use the latest tagged versions of the Mads modules

[method] —
functions()

List available functions in the MADS modules:

Examples:

Mads.functions()
Mads.functions(BIGUQ)
Mads.functions("get")
Mads.functions(Mads, "get")

Arguments:

  • module : MADS module
  • string : matching string
[method] —
functions(string::AbstractString)

List available functions in the MADS modules:

Examples:

Mads.functions()
Mads.functions(BIGUQ)
Mads.functions("get")
Mads.functions(Mads, "get")

Arguments:

  • module : MADS module
  • string : matching string
[method] —
getextension(filename)

Get file name extension

Example:

ext = Mads.getextension("a.mads") # ext = "mads" 
[method] —
getimportantsamples(samples::Array{T, N}, llhoods::Array{T, 1})

Get important samples

Arguments:

  • samples : array of samples
  • llhoods : vector of log-likelihoods

Returns:

  • imp_samples : array of important samples
[method] —
getmadsdir()

Get the directory where currently Mads is running

problemdir = Mads.getmadsdir()

[method] —
getmadsinputfile()

Get the default MADS input file set as a MADS global variable using setmadsinputfile(filename)

Mads.getmadsinputfile()

Arguments: none

Returns:

  • filename : input file name (e.g. input_file_name.mads)
[method] —
getmadsproblemdir(madsdata::Associative{K, V})

Get the directory where the Mads data file is located

Mads.getmadsproblemdir(madsdata)

Example:

madsdata = Mads.loadmadsproblemdir("../../a.mads")
madsproblemdir = Mads.getmadsproblemdir(madsdata)

where madsproblemdir = "../../"

[method] —
getmadsrootname(madsdata::Associative{K, V})

Get the MADS problem root name

madsrootname = Mads.getmadsrootname(madsdata)

[method] —
getobskeys(madsdata::Associative{K, V})

Get keys for all observations in the MADS problem dictionary

[method] —
getparamdict(madsdata::Associative{K, V})

Get dictionary with all parameters and their respective initial values

Mads.getparamdict(madsdata)

Arguments:

  • madsdata : MADS problem dictionary

Returns:

  • paramdict : dictionary with all parameters and their respective initial values
[method] —
getparamdistributions(madsdata::Associative{K, V})

Get probabilistic distributions of all parameters in the MADS problem dictionary

Mads.getparamdistributions(madsdata; init_dist=false)

Note:

Probabilistic distribution of parameters can be defined only if dist or min/max model parameter fields are specified in the MADS problem dictionary madsdata.

Arguments:

  • madsdata : MADS problem dictionary
  • init_dist : if true use the distribution defined for initialization in the MADS problem dictionary (defined using init_dist parameter field); else use the regular distribution defined in the MADS problem dictionary (defined using dist parameter field)
[method] —
getparamkeys(madsdata::Associative{K, V})

Get keys of all parameters in the MADS dictionary

Mads.getparamkeys(madsdata)

Arguments:

  • madsdata : MADS problem dictionary

Returns:

  • paramkeys : array with the keys of all parameters in the MADS dictionary
[method] —
getparamsinit_max(madsdata)

Get an array with init_max values for all the MADS model parameters

[method] —
getparamsinit_max(madsdata, paramkeys)

Get an array with init_max values for parameters defined by paramkeys

[method] —
getparamsinit_min(madsdata)

Get an array with init_min values for all the MADS model parameters

[method] —
getparamsinit_min(madsdata, paramkeys)

Get an array with init_min values for parameters defined by paramkeys

[method] —
getparamsmax(madsdata)

Get an array with min values for all the MADS model parameters

[method] —
getparamsmax(madsdata, paramkeys)

Get an array with max values for parameters defined by paramkeys

[method] —
getparamsmin(madsdata)

Get an array with min values for all the MADS model parameters

[method] —
getparamsmin(madsdata, paramkeys)

Get an array with min values for parameters defined by paramkeys

[method] —
getprocs()

Get the number of processors

[method] —
getrestartdir(madsdata::Associative{K, V})

Get the directory where restarts will be stored.

[method] —
getrestartdir(madsdata::Associative{K, V}, suffix)

Get the directory where restarts will be stored.

[method] —
getrootname(filename::AbstractString)

Get file name root

Example:

r = Mads.getrootname("a.rnd.dat") # r = "a"
r = Mads.getrootname("a.rnd.dat", first=false) # r = "a.rnd"
[method] —
getsourcekeys(madsdata::Associative{K, V})

Get keys of all source parameters in the MADS dictionary

Mads.getsourcekeys(madsdata)

Arguments:

  • madsdata : MADS problem dictionary

Returns:

  • sourcekeys : array with keys of all source parameters in the MADS dictionary
[method] —
gettarget(o::Associative{K, V})

Get observation target

[method] —
gettargetkeys(madsdata::Associative{K, V})

Get keys for all targets (observations with weights greater than zero) in the MADS problem dictionary

[method] —
gettime(o::Associative{K, V})

Get observation time

[method] —
getweight(o::Associative{K, V})

Get observation weight

[method] —
getwellkeys(madsdata::Associative{K, V})

Get keys for all wells in the MADS problem dictionary

[method] —
haskeyword(madsdata::Associative{K, V}, keyword::AbstractString)

Check for a keyword in a class within the Mads dictionary madsdata

  • Mads.haskeyword(madsdata, keyword)
  • Mads.haskeyword(madsdata, class, keyword)

Arguments:

  • madsdata : MADS problem dictionary
  • class : dictionary class; if not provided searches for keyword in Problem class
  • keyword : dictionary key

Returns: true or false

Examples:

  • Mads.haskeyword(madsdata, "disp") ... searches in Problem class by default
  • Mads.haskeyword(madsdata, "Wells", "R-28") ... searches in Wells class for a keyword "R-28"
[method] —
help()

Produce MADS help information

[method] —
importeverywhere(finename)

Import function everywhere from a file. The first function in the file is the one that will be called by Mads to perform the model simulations.

[method] —
indexkeys(dict::Associative{K, V}, key::Regex)

Find indexes for dictionary keys based on a string or regular expression

[method] —
ins_obs(instructionfilename::AbstractString, inputfilename::AbstractString)

Apply Mads instruction file instructionfilename to read model input file inputfilename

[method] —
instline2regexs(instline::AbstractString)

Convert an instruction line in the Mads instruction file into regular expressions

[method] —
invobsweights!(madsdata::Associative{K, V}, value::Number)

Inversely proportional observation weights in the MADS problem dictionary

[method] —
invwellweights!(madsdata::Associative{K, V}, value::Number)

Inversely proportional observation weights in the MADS problem dictionary

[method] —
islog(madsdata::Associative{K, V}, parameterkey::AbstractString)

Is parameter with key parameterkey log-transformed?

[method] —
isobs(madsdata::Associative{K, V}, dict::Associative{K, V})

Is a dictionary containing all the observations

[method] —
isopt(madsdata::Associative{K, V}, parameterkey::AbstractString)

Is parameter with key parameterkey optimizable?

[method] —
isparam(madsdata::Associative{K, V}, dict::Associative{K, V})

Is the dictionary containing all the parameters

[method] —
levenberg_marquardt(f::Function, g::Function, x0)

Levenberg-Marquardt optimization

Arguments:

  • f : forward model function
  • g : gradient function for the forward model
  • x0 : initial parameter guess
  • root : Mads problem root name
  • tolX : parameter space tolerance
  • tolG : parameter space update tolerance
  • tolOF : objective function update tolerance
  • maxEval : maximum number of model evaluations
  • maxIter : maximum number of optimization iterations
  • maxJacobians : maximum number of Jacobian solves
  • lambda : initial Levenberg-Marquardt lambda [eps(Float32)]
  • lambda_scale : lambda scaling factor
  • lambda_mu : lambda multiplication factor μ [10]
  • lambda_nu : lambda multiplication factor ν [10]
  • np_lambda : number of parallel lambda solves
  • show_trace : shows solution trace [default=false]
  • alwaysDoJacobian: computer Jacobian each iteration [false]
  • callback : call back function for debugging
[method] —
levenberg_marquardt(f::Function, g::Function, x0, o::Function)

Levenberg-Marquardt optimization

Arguments:

  • f : forward model function
  • g : gradient function for the forward model
  • x0 : initial parameter guess
  • root : Mads problem root name
  • tolX : parameter space tolerance
  • tolG : parameter space update tolerance
  • tolOF : objective function update tolerance
  • maxEval : maximum number of model evaluations
  • maxIter : maximum number of optimization iterations
  • maxJacobians : maximum number of Jacobian solves
  • lambda : initial Levenberg-Marquardt lambda [eps(Float32)]
  • lambda_scale : lambda scaling factor
  • lambda_mu : lambda multiplication factor μ [10]
  • lambda_nu : lambda multiplication factor ν [10]
  • np_lambda : number of parallel lambda solves
  • show_trace : shows solution trace [default=false]
  • alwaysDoJacobian: computer Jacobian each iteration [false]
  • callback : call back function for debugging
[method] —
loadasciifile(filename::AbstractString)

Load ASCII file

[method] —
loadjsonfile(filename::AbstractString)

Load a JSON file

[method] —
loadmadsfile(filename::AbstractString)

Load MADS input file defining a MADS problem dictionary

  • Mads.loadmadsfile(filename)
  • Mads.loadmadsfile(filename; julia=false)
  • Mads.loadmadsfile(filename; julia=true)

Arguments:

  • filename : input file name (e.g. input_file_name.mads)
  • julia : if true, force using julia parsing functions; if false (default), use python parsing functions [boolean]

Returns:

  • madsdata : Mads problem dictionary

Example: md = loadmadsfile("input_file_name.mads")

[method] —
loadyamlfile(filename::AbstractString)

Load YAML file

[method] —
localsa(madsdata::Associative{K, V})

Local sensitivity analysis based on eigen analysis of covariance matrix

Arguments:

  • madsdata : MADS problem dictionary
  • madsdata : MADS problem dictionary
  • filename : output file name
  • format : output plot format (png, pdf, etc.)
  • par : parameter set
  • obs : observations for the parameter set
[method] —
long_tests_off()

Turn off execution of long MADS tests (default)

[method] —
long_tests_on()

Turn on execution of long MADS tests (dangerous)

[method] —
madscritical(message::AbstractString)

MADS critical error messages

[method] —
madsdebug(message::AbstractString)

MADS debug messages (controlled by quiet and debuglevel)

[method] —
madsdebug(message::AbstractString, level::Int64)

MADS debug messages (controlled by quiet and debuglevel)

[method] —
madserror(message::AbstractString)

MADS error messages

[method] —
madsinfo(message::AbstractString)

MADS information/status messages (controlled by quiet` and verbositylevel)

[method] —
madsinfo(message::AbstractString, level::Int64)

MADS information/status messages (controlled by quiet` and verbositylevel)

[method] —
madsoutput(message::AbstractString)

MADS output (controlled by quiet` and verbositylevel)

[method] —
madsoutput(message::AbstractString, level::Int64)

MADS output (controlled by quiet` and verbositylevel)

[method] —
madswarn(message::AbstractString)

MADS warning messages

[method] —
makearrayconditionalloglikelihood(madsdata::Associative{K, V}, conditionalloglikelihood)

Make a conditional log likelihood function that accepts an array containing the opt parameters' values

[method] —
makearrayfunction(madsdata::Associative{K, V})

Model section information criteria

[method] —
makearrayfunction(madsdata::Associative{K, V}, f)

Make a version of the function f that accepts an array containing the optimal parameters' values

Mads.makearrayfunction(madsdata, f)

Arguments:

  • madsdata : MADS problem dictionary
  • f : ...

Returns:

  • arrayfunction : function accepting an array containing the optimal parameters' values
[method] —
makearrayfunction(madsdata::Associative{K, V}, par::Array{T, N})

Model section information criteria

[method] —
makearrayloglikelihood(madsdata::Associative{K, V}, loglikelihood)

Make a log likelihood function that accepts an array containing the opt parameters' values

[method] —
makebigdt!(madsdata::Associative{K, V}, choice::Associative{K, V})

Setup BIG-DT problem

Arguments:

  • madsdata : MADS problem dictionary
  • choice : dictionary of BIG-DT choices (scenarios)

Returns:

  • bigdtproblem : BIG-DT problem type
[method] —
makebigdt(madsdata::Associative{K, V}, choice::Associative{K, V})

Setup BIG-DT problem

Arguments:

  • madsdata : MADS problem dictionary
  • choice : dictionary of BIG-DT choices (scenarios)

Returns:

  • bigdtproblem : BIG-DT problem type
[method] —
makecomputeconcentrations(madsdata::Associative{K, V})

Create a function to compute concentrations for all the observation points using Anasol

Mads.makecomputeconcentrations(madsdata)

Arguments:

  • madsdata : MADS problem dictionary

Returns:

  • computeconcentrations : function to compute concentrations; computeconcentrations returns a dictionary of observations and model predicted concentrations

Examples:

computeconcentrations()

or

computeconcentrations = Mads.makecomputeconcentrations(madsdata)
paramkeys = Mads.getparamkeys(madsdata)
paramdict = OrderedDict(zip(paramkeys, map(key->madsdata["Parameters"][key]["init"], paramkeys)))
forward_preds = computeconcentrations(paramdict)
[method] —
makedoublearrayfunction(madsdata::Associative{K, V})

Make a version of the function f that accepts an array containing the optimal parameters' values, and returns an array of observations

Mads.makedoublearrayfunction(madsdata, f)

Arguments:

  • madsdata : MADS problem dictionary
  • f : ...

Returns:

  • doublearrayfunction : function accepting an array containing the optimal parameters' values, and returning an array of observations
[method] —
makedoublearrayfunction(madsdata::Associative{K, V}, f)

Make a version of the function f that accepts an array containing the optimal parameters' values, and returns an array of observations

Mads.makedoublearrayfunction(madsdata, f)

Arguments:

  • madsdata : MADS problem dictionary
  • f : ...

Returns:

  • doublearrayfunction : function accepting an array containing the optimal parameters' values, and returning an array of observations
[method] —
makelmfunctions(madsdata::Associative{K, V})

Make forward model, gradient, objective functions needed for Levenberg-Marquardt optimization

[method] —
makelocalsafunction(madsdata::Associative{K, V})

Make gradient function needed for local sensitivity analysis

[method] —
makelogprior(madsdata::Associative{K, V})

Make a function to compute the prior log-likelihood of the model parameters listed in the MADS problem dictionary madsdata

[method] —
makemadscommandfunction(madsdatawithobs::Associative{K, V})

Make MADS function to execute the model defined in the MADS problem dictionary madsdata

Usage:

Mads.makemadscommandfunction(madsdata)

MADS can be coupled with any internal or external model. The model coupling is defined in the MADS problem dictionary. The expectations is that for a given set of model inputs, the model will produce a model output that will be provided to MADS. The fields in the MADS problem dictionary that can be used to define the model coupling are:

  • Model : execute a Julia function defined in an input Julia file. The function that should accept a parameter dictionary with all the model parameters as an input argument and should return an observation dictionary with all the model predicted observations. MADS will execute the first function defined in the file.
  • MADS model : create a Julia function based on an input Julia file. The input file should contain a function that accepts as an argument the MADS problem dictionary. MADS will execute the first function defined in the file. This function should a create a Julia function that will accept a parameter dictionary with all the model parameters as an input argument and will return an observation dictionary with all the model predicted observations.
  • Julia model : execute an internal Julia function that accepts a parameter dictionary with all the model parameters as an input argument and will return an observation dictionary with all the model predicted observations.
  • Command : execute an external UNIX command or script that will execute an external model.
  • Julia command : execute a Julia script that will execute an external model. The Julia script is defined in an input Julia file. The input file should contain a function that accepts as an argument the MADS problem dictionary; MADS will execute the first function defined in the file. The Julia script should be capable to (1) execute the model (making a system call of an external model), (2) parse the model outputs, (3) return an observation dictionary with model predictions.

Both Command and Julia command can use different approaches to pass model parameters to the external model.

Only Command uses different approaches to get back the model outputs. The script defined under Julia command parses the model outputs using Julia.

The available options for writing model inputs and reading model outputs are as follows.

Options for writing model inputs:

  • Templates : template files for writing model input files as defined at http://mads.lanl.gov
  • ASCIIParameters : model parameters written in a ASCII file
  • JLDParameters : model parameters written in a JLD file
  • YAMLParameters : model parameters written in a YAML file
  • JSONParameters : model parameters written in a JSON file

Options for reading model outputs:

  • Instructions : instruction files for reading model output files as defined at http://mads.lanl.gov
  • ASCIIPredictions : model predictions read from a ASCII file
  • JLDPredictions : model predictions read from a JLD file
  • YAMLPredictions : model predictions read from a YAML file
  • JSONPredictions : model predictions read from a JSON file
[method] —
makemadscommandfunctionandgradient(madsdata::Associative{K, V})

Make MADS forward & gradient functions for the model defined in the MADS problem dictionary madsdata

[method] —
makemadscommandgradient(madsdata::Associative{K, V})

Make MADS gradient function to compute the parameter-space gradient for the model defined in the MADS problem dictionary madsdata

[method] —
makemadsconditionalloglikelihood(madsdata::Associative{K, V})

Make a function to compute the conditional log-likelihood of the model parameters conditioned on the model predictions/observations. Model parameters and observations are defined in the MADS problem dictionary madsdata.

[method] —
makemadsloglikelihood(madsdata::Associative{K, V})

Make a function to compute the log-likelihood for a given set of model parameters, associated model predictions and existing observations. The function can be provided as an external function in the MADS problem dictionary under LogLikelihood or computed internally.

[method] —
maxtorealmaxFloat32!(df::DataFrames.DataFrame)

Scale down values larger than max(Float32) in a Dataframe df so that Gadfly can plot the data

[method] —
modobsweights!(madsdata::Associative{K, V}, value::Number)

Modify (multiply) observation weights in the MADS problem dictionary

[method] —
modwellweights!(madsdata::Associative{K, V}, value::Number)

Modify (multiply) well weights in the MADS problem dictionary

[method] —
montecarlo(madsdata::Associative{K, V})

Monte Carlo analysis

Mads.montecarlo(madsdata; N=100)

Arguments:

  • madsdata : MADS problem dictionary sampling uniformly between mins/maxs
  • N : number of samples (default = 100)

Returns:

  • outputdicts : parameter dictionary containing the data arrays

Dumps:

  • YAML output file with the parameter dictionary containing the data arrays (<mads_root_name>.mcresults.yaml)
[method] —
naive_get_deltax(JpJ::Array{T, 2}, Jp::Array{T, 2}, f0::Array{T, 1}, lambda::Real)

Naive Levenberg-Marquardt optimization: get the LM parameter space step

[method] —
naive_levenberg_marquardt(f::Function, g::Function, x0::Array{T, 1})

Naive Levenberg-Marquardt optimization

Arguments:

  • f : forward model function
  • g : gradient function for the forward model
  • x0 : initial parameter guess
  • o : objective function
  • tolX : parameter space tolerance
  • tolG : parameter space update tolerance
  • tolOF : objective function update tolerance
  • maxEval : maximum number of model evaluations
  • maxIter : maximum number of optimization iterations
  • lambda : initial Levenberg-Marquardt lambda [100]
  • lambda_mu : lambda multiplication factor μ [10]
  • np_lambda : number of parallel lambda solves
[method] —
naive_levenberg_marquardt(f::Function, g::Function, x0::Array{T, 1}, o::Function)

Naive Levenberg-Marquardt optimization

Arguments:

  • f : forward model function
  • g : gradient function for the forward model
  • x0 : initial parameter guess
  • o : objective function
  • tolX : parameter space tolerance
  • tolG : parameter space update tolerance
  • tolOF : objective function update tolerance
  • maxEval : maximum number of model evaluations
  • maxIter : maximum number of optimization iterations
  • lambda : initial Levenberg-Marquardt lambda [100]
  • lambda_mu : lambda multiplication factor μ [10]
  • np_lambda : number of parallel lambda solves
[method] —
naive_lm_iteration(f::Function, g::Function, o::Function, x0::Array{T, 1}, f0::Array{T, 1}, lambdas::Array{T, 1})

Naive Levenberg-Marquardt optimization: perform LM iteration

[method] —
noplot()

Disable MADS plotting

[method] —
obslineismatch(obsline::AbstractString, regexs::Array{Regex, 1})

Match an instruction line in the Mads instruction file with model input file

[method] —
of(madsdata::Associative{K, V}, results::Array{T, 1})

Compute objective function

[method] —
paramarray2dict(madsdata::Associative{K, V}, array::Array{T, N})

Convert parameter array to a parameter dictionary of arrays

[method] —
parametersample(madsdata::Associative{K, V}, numsamples::Integer)

Independent sampling of model parameters defined in the MADS problem dictionary

Arguments:

  • madsdata : MADS problem dictionary
  • numsamples : number of samples
  • parameterkey : model parameter key
  • init_dist : if true use the distribution defined for initialization in the MADS problem dictionary (defined using init_dist parameter field); else use the regular distribution defined in the MADS problem dictionary (defined using dist parameter field)
[method] —
parametersample(madsdata::Associative{K, V}, numsamples::Integer, parameterkey::AbstractString)

Independent sampling of model parameters defined in the MADS problem dictionary

Arguments:

  • madsdata : MADS problem dictionary
  • numsamples : number of samples
  • parameterkey : model parameter key
  • init_dist : if true use the distribution defined for initialization in the MADS problem dictionary (defined using init_dist parameter field); else use the regular distribution defined in the MADS problem dictionary (defined using dist parameter field)
[method] —
paramrand(madsdata::Associative{K, V}, parameterkey::AbstractString)

Random numbers for a MADS model parameter defined by parameterkey

Arguments:

  • madsdata : MADS problem dictionary
  • parameterkey : model parameter key
  • numsamples : number of samples
  • paramdist : dictionary with parameter distributions
[method] —
parsemadsdata(madsdata::Associative{K, V})

Parse loaded Mads problem dictionary

Arguments:

  • madsdata : Mads problem dictionary
[method] —
parser_amanzi()

Parse Amanzi output provided in an external file (filename)

Mads.parser_amanzi()
Mads.parser_amanzi("observations.out")

Arguments:

  • filename : external file name (optional)

Returns:

  • dict : a dictionary with model observations following MADS requirements
[method] —
parser_amanzi(filename::AbstractString)

Parse Amanzi output provided in an external file (filename)

Mads.parser_amanzi()
Mads.parser_amanzi("observations.out")

Arguments:

  • filename : external file name (optional)

Returns:

  • dict : a dictionary with model observations following MADS requirements
[method] —
partialof(madsdata::Associative{K, V}, resultdict::Associative{K, V}, regex::Regex)

Compute the sum of squared residuals for observations that match a regular expression

[method] —
plotSAresults_monty(wellname, madsdata, result)

Plot the sensitivity analysis results for each well (Specific plot requested by Monty)

[method] —
plotgrid(madsdata::Associative{K, V}, s::Array{Float64, N})

Plot a 3D grid solution based on model predictions in array s, initial parameters, or user provided parameter values

plotgrid(madsdata, s; addtitle=true, title="", filename="", format="")
plotgrid(madsdata; addtitle=true, title="", filename="", format="")
plotgrid(madsdata, parameters; addtitle=true, title="", filename="", format="")

Arguments:

  • madsdata : MADS problem dictionary
  • parameters : dictionary with model parameters
  • s : model predictions array
  • addtitle : add plot title [true]
  • title : plot title
  • filename : output file name
  • format : output plot format (png, pdf, etc.)
[method] —
plotmadsproblem(madsdata::Associative{K, V})

Plot contaminant sources and wells defined in MADS problem dictionary

Arguments:

  • madsdata : MADS problem dictionary
  • filename : output file name
  • format : output plot format (png, pdf, etc.)
  • keyword : to be added in the filename
[method] —
plotmass(lambda, mass_injected, mass_reduced, filename::AbstractString)

Plot injected/reduced contaminant mass

  • Mads.plotmass(lambda, mass_injected, mass_reduced, filename="file_name")

Arguments:

  • lambda : array with all the lambda values
  • mass_injected : array with associated total injected mass
  • mass_reduced : array with associated total reduced mass
  • filename : output filename for the generated plot
  • format : output plot format (png, pdf, etc.)

Dumps: image file with name filename and in specified format

[method] —
plotmatches(madsdata_in::Associative{K, V})

Plot the matches between model predictions and observations

plotmatches(madsdata; filename="", format="")
plotmatches(madsdata, param; filename="", format="")
plotmatches(madsdata, result; filename="", format="")
plotmatches(madsdata, result, r"NO3"; filename="", format="")

Arguments:

  • madsdata : MADS problem dictionary
  • param : dictionary with model parameters
  • result : dictionary with model predictions
  • rx : regular expression to filter the outputs
  • filename : output file name
  • format : output plot format (png, pdf, etc.)
[method] —
plotobsSAresults(madsdata, result)

Plot the sensitivity analysis results for the observations

Arguments:

  • madsdata : MADS problem dictionary
  • result : sensitivity analysis results
  • filter : string or regex to plot only observations containing filter
  • keyword : to be added in the auto-generated filename
  • filename : output file name
  • format : output plot format (png, pdf, etc.)
[method] —
plotrobustnesscurves(madsdata::Associative{K, V}, bigdtresults::Dict{K, V})

Plot BIG-DT robustness curves

Arguments:

  • madsdata : MADS problem dictionary
  • bigdtresults : BIG-DT results
  • filename : output file name used to dump plots
  • format : output plot format (png, pdf, etc.)
[method] —
plotseries(X::Array{T, 2}, filename::AbstractString)

Create plots of data series

Arguments:

  • X : matrix with the series data
  • filename : output file name
  • format : output plot format (png, pdf, etc.)
  • xtitle : x-axis title
  • ytitle : y-axis title
  • title : plot title
  • name : series name
  • combined : true by default
[method] —
plotwellSAresults(madsdata, result)

Plot the sensitivity analysis results for all the wells in the MADS problem dictionary (wells class expected)

Arguments:

  • madsdata : MADS problem dictionary
  • result : sensitivity analysis results
  • xtitle : x-axis title
  • ytitle : y-axis title
  • filename : output file name
  • format : output plot format (png, pdf, etc.)
[method] —
plotwellSAresults(madsdata, result, wellname)

Plot the sensitivity analysis results for a given well in the MADS problem dictionary (wells class expected)

Arguments:

  • madsdata : MADS problem dictionary
  • result : sensitivity analysis results
  • wellname : well name
  • xtitle : x-axis title
  • ytitle : y-axis title
  • filename : output file name
  • format : output plot format (png, pdf, etc.)
[method] —
printSAresults(madsdata::Associative{K, V}, results::Associative{K, V})

Print sensitivity analysis results

[method] —
quietoff()

Make MADS not quiet

[method] —
quieton()

Make MADS quiet

[method] —
readasciipredictions(filename::AbstractString)

Read MADS predictions from an ASCII file

[method] —
readjsonpredictions(filename::AbstractString)

Read MADS model predictions from a JSON file

[method] —
readobservations(madsdata::Associative{K, V})

Read observations

[method] —
readobservations(madsdata::Associative{K, V}, obsids)

Read observations

[method] —
readobservations_cmads(madsdata::Associative{K, V})

Read observations using C Mads library

[method] —
readyamlpredictions(filename::AbstractString)

Read MADS model predictions from a YAML file filename

[method] —
regexs2obs(obsline, regexs, obsnames, getparamhere)

Get observations for a set of regular expressions

[method] —
resetmodelruns()

Reset the model runs count to be equal to zero

[method] —
residuals(madsdata::Associative{K, V}, results::Array{T, 1})

Compute residuals

[method] —
reweighsamples(madsdata::Associative{K, V}, predictions::Array{T, N}, oldllhoods::Array{T, 1})

Reweigh samples using importance sampling – returns a vector of log-likelihoods after reweighing

Arguments:

  • madsdata : MADS problem dictionary
  • predictions : the model predictions for each of the samples
  • oldllhoods : the log likelihoods of the parameters in the old distribution

Returns:

  • newllhoods : vector of log-likelihoods after reweighing
[method] —
rosenbrock(x::Array{T, 1})

Rosenbrock test function

[method] —
rosenbrock2_gradient_lm(x)

Parameter gradients of the Rosenbrock test function

[method] —
rosenbrock2_lm(x)

Rosenbrock test function (more difficult to solve)

[method] —
rosenbrock_gradient!(x::Array{T, 1}, storage::Array{T, 1})

Parameter gradients of the Rosenbrock test function

[method] —
rosenbrock_gradient_lm(x::Array{T, 1})

Parameter gradients of the Rosenbrock test function for LM optimization (returns the gradients for the 2 components separetely)

[method] —
rosenbrock_hessian!(x::Array{T, 1}, storage::Array{T, 2})

Parameter Hessian of the Rosenbrock test function

[method] —
rosenbrock_lm(x::Array{T, 1})

Rosenbrock test function for LM optimization (returns the 2 components separetely)

[method] —
saltelli(madsdata::Associative{K, V})

Saltelli sensitivity analysis

Arguments:

  • madsdata : MADS problem dictionary
  • N : number of samples
  • seed : initial random seed
  • restartdir : directory where files will be stored containing model results for fast simulation restarts
  • parallel : set to true if the model runs should be performed in parallel
[method] —
saltellibrute(madsdata::Associative{K, V})

Saltelli sensitivity analysis (brute force)

Arguments:

  • madsdata : MADS problem dictionary
  • N : number of samples
  • seed : initial random seed
[method] —
saltelliprintresults2(madsdata::Associative{K, V}, results::Associative{K, V})

Print sensitivity analysis results (method 2)

[method] —
savemadsfile(madsdata::Associative{K, V})

Save MADS problem dictionary madsdata in MADS input file filename

  • Mads.savemadsfile(madsdata)
  • Mads.savemadsfile(madsdata, "test.mads")
  • Mads.savemadsfile(madsdata, parameters, "test.mads")
  • Mads.savemadsfile(madsdata, parameters, "test.mads", explicit=true)

Arguments:

  • madsdata : Mads problem dictionary
  • parameters : Dictinary with parameters (optional)
  • filename : input file name (e.g. input_file_name.mads)
  • julia : if true use Julia JSON module to save
  • explicit : if true ignores MADS YAML file modifications and rereads the original input file
[method] —
savemadsfile(madsdata::Associative{K, V}, filename::AbstractString)

Save MADS problem dictionary madsdata in MADS input file filename

  • Mads.savemadsfile(madsdata)
  • Mads.savemadsfile(madsdata, "test.mads")
  • Mads.savemadsfile(madsdata, parameters, "test.mads")
  • Mads.savemadsfile(madsdata, parameters, "test.mads", explicit=true)

Arguments:

  • madsdata : Mads problem dictionary
  • parameters : Dictinary with parameters (optional)
  • filename : input file name (e.g. input_file_name.mads)
  • julia : if true use Julia JSON module to save
  • explicit : if true ignores MADS YAML file modifications and rereads the original input file
[method] —
savemcmcresults(chain::Array{T, N}, filename::AbstractString)

Save MCMC chain in a file

[method] —
scatterplotsamples(madsdata, samples::Array{T, 2}, filename::AbstractString)

Create histogram/scatter plots of model parameter samples

Arguments:

  • madsdata : MADS problem dictionary
  • samples : matrix with model parameters
  • filename : output file name
  • format : output plot format (png, pdf, etc.)
[method] —
searchdir(key::Regex)

Get files in the current directory or in a directory defined by path matching pattern key which can be a string or regular expression

  • Mads.searchdir(key)
  • Mads.searchdir(key; path = ".")

Arguments:

  • key : matching pattern for Mads input files (string or regular expression accepted)
  • path : search directory for the mads input files

Returns:

  • filename : an array with file names matching the pattern in the specified directory
[method] —
setallparamsoff!(madsdata::Associative{K, V})

Set all parameters OFF

[method] —
setallparamson!(madsdata::Associative{K, V})

Set all parameters ON

[method] —
setdebuglevel(level::Int64)

Set MADS debug level

[method] —
setdir(dir::ASCIIString)

Set the working directory (for parallel environments)

@everywhere Mads.setdir()
@everywhere Mads.setdir("/home/monty")
[method] —
setdynamicmodel(madsdata::Associative{K, V}, f::Function)

Set Dynamic Model for MADS model calls using internal Julia functions

[method] —
setplotfileformat(filename, format)

Set image file format based on the filename extension, or sets the filename extension based on the requested format. The default format is SVG. PNG, PDF, ESP, and PS are also supported.

setplotfileformat(filename, format)

Arguments:

  • filename : output file name
  • format : output plot format (png, pdf, etc.)

Returns:

  • filename : output file name
  • format : output plot format (png, pdf, etc.)
[method] —
setmadsinputfile(filename::AbstractString)

Set a default MADS input file

Mads.setmadsinputfile(filename)

Arguments:

  • filename : input file name (e.g. input_file_name.mads)
[method] —
setobservationtargets!(madsdata::Associative{K, V}, predictions::Associative{K, V})

Set observations (calibration targets) in the MADS problem dictionary based on a predictions dictionary

[method] —
setobstime!(madsdata::Associative{K, V}, separator::AbstractString)

Set observation time based on the observation name in the MADS problem dictionary

Usage:

Mads.setobstime!(madsdata, separator)
Mads.setobstime!(madsdata, regex)

Arguments:

  • madsdata : MADS problem dictionary
  • separator : string to separator
  • regex : regular expression to match

Examples:

Mads.setobstime!(madsdata, "_t")
Mads.setobstime!(madsdata, r"[A-x]*_t([0-9,.]+)")
[method] —
setobsweights!(madsdata::Associative{K, V}, value::Number)

Set observation weights in the MADS problem dictionary

[method] —
setparamoff!(madsdata::Associative{K, V}, parameterkey)

Set a specific parameter with a key parameterkey OFF

[method] —
setparamon!(madsdata::Associative{K, V}, parameterkey::AbstractString)

Set a specific parameter with a key parameterkey ON

[method] —
setparamsdistnormal!(madsdata::Associative{K, V}, mean, stddev)

Set normal parameter distributions for all the model parameters in the MADS problem dictionary

Mads.setparamsdistnormal!(madsdata, mean, stddev)

Arguments:

  • madsdata : MADS problem dictionary
  • mean : array with the mean values
  • stddev : array with the standard deviation values
[method] —
setparamsdistuniform!(madsdata::Associative{K, V}, min, max)

Set uniform parameter distributions for all the model parameters in the MADS problem dictionary

Mads.setparamsdistuniform!(madsdata, min, max)

Arguments:

  • madsdata : MADS problem dictionary
  • min : array with the minimum values
  • max : array with the maximum values
[method] —
setparamsinit!(madsdata::Associative{K, V}, paramdict::Associative{K, V})

Set initial parameter guesses in the MADS dictionary

Mads.setparamsinit!(madsdata, paramdict)

Arguments:

  • madsdata : MADS problem dictionary
  • paramdict : dictionary with initial model parameter values
[method] —
setprocs()

Set the available processors based on environmental variables. Supports SLURM only at the moment.

Usage:

Mads.setprocs()
Mads.setprocs(ntasks_per_node=4)
Mads.setprocs(ntasks_per_node=32, mads_servers=true)
Mads.setprocs(ntasks_per_node=64, machinenames=["madsmax", "madszem"])
Mads.setprocs(ntasks_per_node=64, mads_servers=true, exename="/home/monty/bin/julia", dir="/home/monty")

Optional arguments:

  • ntasks_per_node : number of parallel tasks per node
  • machinenames : array with machines names to invoked
  • dir : common directory shared by all the jobs
  • exename : location of the julia executable (the same version of julia is needed on all the workers)
  • mads_servers : if true use MADS servers (LANL only)
  • quiet : suppress output [default true]
  • test : test the servers and connect to each one ones at a time [default false]
[method] —
setprocs(np::Int64, nt::Int64)

Set the number of processors to np and the number of threads to nt

Usage:

Mads.setprocs(4)
Mads.setprocs(4, 8)

Arguments:

  • np : number of processors
  • nt : number of threads
[method] —
setseed(seed::Number)

Set current seed

[method] —
settarget!(o::Associative{K, V}, target)

Set observation target

[method] —
settime!(o::Associative{K, V}, time)

Set observation time

[method] —
setverbositylevel(level::Int64)

Set MADS verbosity level

[method] —
setweight!(o::Associative{K, V}, weight)

Set observation weight

[method] —
setwellweights!(madsdata::Associative{K, V}, value::Number)

Set well weights in the MADS problem dictionary

[method] —
showallparameters(madsdata::Associative{K, V})

Show all parameters in the MADS problem dictionary

[method] —
showobservations(madsdata::Associative{K, V})

Show observations in the MADS problem dictionary

[method] —
showparameters(madsdata::Associative{K, V})

Show optimizable parameters in the MADS problem dictionary

[method] —
sinetransform(sineparams::Array{T, 1}, lowerbounds::Array{T, 1}, upperbounds::Array{T, 1}, indexlogtransformed::Array{T, 1})

Sine transformation of model parameters

[method] —
sinetransformfunction(f::Function, lowerbounds::Array{T, 1}, upperbounds::Array{T, 1}, indexlogtransformed::Array{T, 1})

Sine transformation of a function

[method] —
sinetransformgradient(g::Function, lowerbounds::Array{T, 1}, upperbounds::Array{T, 1}, indexlogtransformed::Array{T, 1})

Sine transformation of a gradient function

[method] —
spaghettiplot(madsdata::Associative{K, V}, number_of_samples::Int64)

Generate a combined spaghetti plot for the selected (type != null) model parameter

Mads.spaghettiplot(madsdata, paramdictarray; filename="", keyword = "", format="", xtitle="X", ytitle="Y", obs_plot_dots=true)
Mads.spaghettiplot(madsdata, obsmdictarray; filename="", keyword = "", format="", xtitle="X", ytitle="Y", obs_plot_dots=true)
Mads.spaghettiplot(madsdata, number_of_samples; filename="", keyword = "", format="", xtitle="X", ytitle="Y", obs_plot_dots=true)

Arguments:

  • madsdata : MADS problem dictionary
  • paramdictarray : parameter dictionary array containing the data arrays to be plotted
  • obsdictarray : observation dictionary array containing the data arrays to be plotted
  • number_of_samples : number of samples
  • filename : output file name used to output the produced plots
  • keyword : keyword to be added in the file name used to output the produced plots (if filename is not defined)
  • format : output plot format (png, pdf, etc.)
  • xtitle : x axis title
  • ytitle : y axis title
  • obs_plot_dots : plot observation as dots (true [default] or false)
  • seed : initial random seed

Returns: none

Dumps:

  • Image file with a spaghetti plot (<mads_rootname>-<keyword>-<number_of_samples>-spaghetti.<default_image_extension>)
[method] —
spaghettiplots(madsdata::Associative{K, V}, number_of_samples::Int64)

Generate separate spaghetti plots for each selected (type != null) model parameter

Mads.spaghettiplots(madsdata, paramdictarray; format="", keyword="", xtitle="X", ytitle="Y", obs_plot_dots=true)
Mads.spaghettiplots(madsdata, number_of_samples; format="", keyword="", xtitle="X", ytitle="Y", obs_plot_dots=true)

Arguments:

  • madsdata : MADS problem dictionary
  • paramdictarray : parameter dictionary containing the data arrays to be plotted
  • number_of_samples : number of samples
  • keyword : keyword to be added in the file name used to output the produced plots
  • format : output plot format (png, pdf, etc.)
  • xtitle : x axis title
  • ytitle : y axis title
  • obs_plot_dots : plot observation as dots (true [default] or false)
  • seed : initial random seed

Dumps:

  • A series of image files with spaghetti plots for each selected (type != null) model parameter (<mads_rootname>-<keyword>-<param_key>-<number_of_samples>-spaghetti.<default_image_extension>)
[method] —
sprintf(args...)

Convert @sprintf macro into sprintf function

[method] —
status()

Status of the Mads modules

[method] —
tag()

Tag the Mads modules with a default argument :patch

[method] —
tag(sym::Symbol)

Tag the Mads modules with a default argument :patch

[method] —
test()

Execute Mads tests (the tests will be in parallel if processors are defined)

[method] —
test(testmod)

Execute Mads tests (the tests will be in parallel if processors are defined)

[method] —
testj()

Execute Mads tests using Julia Pkg.test (the default Pkg.test in Julia is executed in serial)

[method] —
testj(coverage::Bool)

Execute Mads tests using Julia Pkg.test (the default Pkg.test in Julia is executed in serial)

[method] —
void2nan!(dict::Associative{K, V})

Convert Void's into NaN's in a dictionary

[method] —
weightedstats(samples::Array{T, N}, llhoods::Array{T, 1})

Get weighted mean and variance samples

Arguments:

  • samples : array of samples
  • llhoods : vector of log-likelihoods

Returns:

  • mean : vector of sample means
  • var : vector of sample variances
[method] —
welloff!(madsdata, wellname::AbstractString)

Turn off a specific well in the MADS problem dictionary

[method] —
wellon!(madsdata::Associative{K, V}, wellname::AbstractString)

Turn on a specific well in the MADS problem dictionary

[method] —
wells2observations!(madsdata::Associative{K, V})

Convert Wells class to Observations class in the MADS problem dictionary

[method] —
writeparameters(madsdata::Associative{K, V})

Write initial parameters

[method] —
writeparameters(madsdata::Associative{K, V}, parameters)

Write parameters

[method] —
writeparametersviatemplate(parameters, templatefilename, outputfilename)

Write parameters via MADS template (templatefilename) to an output file (outputfilename)