►
From YouTube: SimPEG Meeting July 28th
Description
Weekly SimPEG meeting from July 28th, 2021
A
A
A
A
Like
where
it's
amp,
where,
like
the
numpy
style
guide,
leaves
things
ambiguous
like
we
need
to
be
like
okay?
Well,
let's
just
you
know,
choose
a
style
and
go
that
way
like
just
so
it's
at
least
codified
somewhere
things
like
okay.
Well,
when
describing
the
shape
of
an
input
array.
What
do
we?
Where
do
we
put
it?
Where
do
we?
A
A
So
you
can
see
the
type
like
all
the
edits
that
I
was
making
and
hopefully
that
should
like
key
you
and
like
okay.
Well,
let's
do
it.
You
guys
see
what's
going
on
it's
things
like
if
you
leave
blank
lines
in
the
examples
it
doesn't
like
it
doesn't
like
it
when
it
formats
it
in
the
output,
because
it
like
it.
Does
this
weird
thing
what
it's
like?
You
can
now
select
those
three
arrows
instead
of
before,
like
if
you
highlighted
them
all
like
it,
just
would
ignore
them.
B
A
B
B
A
It'll,
look
like
a
cell
demarcation,
and
the
reason
is
that
it's
like
most
like
most
editors
will
kind
of
or
some
editors
will
automatically
remove,
trailing
white
spaces
online
that
are
pointless
so
like
that
would
be
a
trailing
white
space
on
that
line
that
it's
like.
Oh,
I
don't
need
it
never
mind
like
it's.
A
B
B
A
A
A
C
B
Yeah
the
biggest,
I
think,
maybe
the
biggest
thing
that
I
have
right
now
for
the
pull
request,
is
sort
of
like
global
failures
of
the
doc
testing
and
it's
it's
always
been
something
where
it's
been
kind
of
hard
to
get
a
pinpoint
the
line
where
things
might
be
breaking
and
yeah.
Maybe
I'm
missing
a
place
where
I
can.
B
Oh,
okay,
like
this
link
broke-
or
you
know
it
took
me
forever
to
there-
was
like
a
a
piece
of
code
that
was
dependent
on
the
operating
system
for
like
connecting
file
paths
and
it
didn't
work
on
one
operator,
so
it
I
don't
know
if
there's
a
way
we
can
kind
of
get
more
comprehensive
write-outs
of
that
stuff.
But
that
seems
to
be.
I
I'd
like
to
be
able
to
have
the
pull
request,
be
passing
at
this
point
and
it's
it's
not
for
all
operating
systems.
A
B
B
Well,
I
guess
also
I
mean
so
it's
obviously
it's
going
to
pass
on
windows
because
I'm
using
a
windows
operating
system,
but
one
thing
that
I
guess
would
be
really
helpful
is
if
somebody
using
one
of
the
operating
systems
where
it's
failing,
is
going
to
build
that
locally
and
then
they
would.
They
would
be
able
to
kind
of
figure
out
what
line
that
might
be
one
way
of
figuring
it
out.
A
A
So
I
was
going
through
here
just
kind
of
editing.
Some
of
this,
let's
make
a
little
bit
cleaner,
so
like
here,
okay,
you
talk
about
what
you
do
like
it's
to
me.
It's
pretty
really
clear
like
okay!
Well,
this
is,
you
know,
constructing
a
mesh
and
I'm
just
plotting
it
here.
Maybe
we
could
separate
this
out
up
here.
A
A
B
Oh,
I
see
so
when
you,
you
ran
it
through
black
first
and
it
got
rid
of
the
space
that
I
had
after
after
the
three
arrows,
which
made
it
actually
formatted
nicely
yeah
and
then
now
it's
basically
like,
I
only
typed
three
arrows.
Instead
of
three
arrows
in
a
space
right
yeah
I
see
I
mean
you
can
also
just
put
like
a
comment
line
if
you're,
if
you
know,
if
you're,
really
that
it's
fine,
though
no
yeah,
no
no
blank
coding
lines,
something
has
to
be
there.
That's
fine,
and
then
we
can
just
separate
it.
B
B
A
B
A
A
D
B
A
A
F
A
A
A
B
B
D
There's
there's
little
things
we
can
do
to
actually
collapse
the
code
and
and
have
that
be
possible
later.
My
instinct
is,
I
think
these
are
worth
keeping
and
you
know
if
later
on,
if
we
want
to
parse
them
into
little
utility
functions
or
like
a
little,
you
know
almost
like
a
little
teaching
module
for
discretize
of
here's.
Some
useful
plots
for
understanding
what's
going
on,
but
just
being
able
to
see
that
I
think
is,
is
really
valuable.
Even
if
the
code
is,
it
is
a
bit
clunkier
right
now.
A
B
But
if
you
I
mean,
if
you're
going
to
look
through
and
you'll,
see
the
the
meat
of
it
and
then
you'll
see
oh,
it's
a
bunch
of
plotting
and
then
you'll
scroll
to
scroll
down
and
see
what
the
plots
are.
I
think
we
had
we
had.
We
touched
on
this,
maybe
sometime
in
the
last
couple
of
months
and
the
consensus
at
that
time
was
oh,
not
not
to
worry
about
it
too
much
like
they
can
scroll
down
and
get
more
information
if
they
want.
But
the
important
thing
is
it's
there,
yeah.
A
A
B
There
is
great
agreement
across
all
of
the
codes,
but
when
you
add
susceptibility,
the
the
sim
peg
code
is
seems
to
be
pretty
problematic
and
I
don't
know
if
it's
you
know,
I'm
sure.
We've
we've
worked
on
this
with
several
projects,
but
it
really
depends.
What
are
you
measuring?
Are
you
measuring
e
or
h?
B
What
is
your
source?
Is
it
galvanic?
Is
it
inductive
and
I'm
sure
that
when
it
was
developed,
there
was
some
testing
to
make
sure
that
it
was
accurate
for
the
situation
we
needed
it
at
the
time,
but
yeah
I've
noticed
that
for
just
having
this
inductive
source,
like
a
loop
sensor
in
the
middle
for
a
layered
earth
and
for
a
as
basically
a
sphere
and
a
vacuum,
it's
it's
not
particularly
accurate
and
it's
not
very
stable
for
later
time
channels.
B
So
yeah,
I'm
just
kind
of
looking
through
and
trying
to
trying
to
understand
ways
that
we
can
improve
it.
The
the
td
auctri
codes,
the
version
two
code
seems
to
be
really
good.
It's
it
solves
for
the
electric
field
and
it
integrates
over
the
the
receiver
loop
to
give
you
dbdt,
and
they
also.
There
was
also
some
some
consideration
in
the
stability
due
to
hanging
nodes.
So
I
think
that
code
might
be
a
little
bit
more
developed
than
what
we
have
in
simpeg
but
yeah.
D
B
Yeah,
that
sounds
great
yeah.
I
think
there's
there's
just
some
improvements
we
could
make,
maybe
in
the
formulations,
but
then
also
for
how
we're
defining
sources
and
then
how
we're
going
from
the
solution
of
the
fields
to
the
receivers,
like
we've,
we've
kind
of
got
that
first
level
of
implementation
of
the
finite
volume
method.
For
you
know
the
the
all
the
ways
that
we
could
do
it,
but
then
I
think
there's
a
level
of
improvement
that
could
happen
when
we
really
get
into
it.
So
yeah
yeah
that'd
be
sweet.
F
B
F
A
E
Short
short
update
here,
I
guess
all
the
tests
are
passing.
Finally
for
simulation
mt
pr
thanks
joe
for
taking
a
look
at
that.
I
didn't
even
think
to
look
at
the
like.
I
was
passing
on
my
computer,
but
yeah
it
wasn't
passing,
but
it
was.
I
had
the
old
version
of
I
guess,
hdf5.
The
new
module
download
yeah,
I
should
have-
should
have
thought
to
look
at
the
the
update.
A
No,
I
I
only
caught
it
because
I
saw
that
it's
like.
Why
is
this?
I
knew
it
wasn't
failing
on
my
computer
either,
but
it
was
on
there
like.
I
can
see
where
the
line
is
failing
and
it's
like.
Oh
it's
an
hdf5
document.
I
wonder
if
you
switched
something
then
I
went
up
and
like
like
started
playing
with
my
computer
and
I
got
like
a
deprecation
noting
but
notice
it's
like.
Oh
this
way
of
accessing
it
is
deprecated
there.
It
is
okay.
E
E
A
E
A
C
Couple
of
typos
like
small
bug.
That
happened
in
a
very
very
specific
case
and
but
most
importantly
also,
is
that
finalizing
the
implementation
of
the
gradient
and
asian
for
arbitrary
physical
property
distribution,
like
no
no
long
like
the
current
code
was
mostly
focused
on
when
you
had
like
distinct
clusters,
so,
like
distinct
units
that
we
are
not
overlapping,
but
now
with
the
with
the
spr
like
simple,
will
be
able
to
handle
any
physical
property
distribution
represented
as
a
gmm
and
that
you,
even
if
they
are,
they
are
overlapping.
C
After
that,
I
haven't
had
a
case
yet
where,
like
it's
really
like
a
key
feature,
because
we
were
often
looking
at
like
yeah
like
we
were
always
often
looking
at
like
in
like
with
dkc
or
those
like
at
more
like
things
like,
like
a
distinct
anomalies
in
the
gravity
and
magnetic.
But
I
think
that
would
be
a
nice
addition
for
other
applications.
G
C
G
If
you
make
it
like
a
so
you're
getting
a
large
variance
now,
then
would
it
make
the
spatial
distribution
smooth
still
or
it
may
actually
not
the
case?
Still
your
spatial
distribution
could
my
guess.
I
think
it
may
impact
your
spatial
distribution
if,
if
you're
getting
a
large
variance,
I
think
it's
probably
smoothed
out
or
like
some.
C
G
B
G
C
So,
no
not
really
like
because
for
uncertainty.
For
me,
the
only
way
to
do
that
is
you
have
several
models.
You
have
several
outcome
like.
If
you
have,
I,
I
don't
be
like.
If
you
have
a
single
outcome,
even
though
you
have
a
cell,
that's
like
oh,
like,
depending
on
my
physical
properties,
it's
like
you
can
get
different
like
like
it's
probability
to
belonging
to
each
clusters.
That's
still
one
outcome
and.
C
It's
gonna,
I
don't
think
it's
a
yeah.
I
don't
think
it's
like
a
be
a
proper
way
of
addressing
uncertainties
like
yeah,
like
you
need
several
outcomes
for
that,
but
it's
more
like,
if
you
it's
more
like
if
you,
if
things
are
like
not
gaussians
or
if
you
want
or
if
you're
interested
in
something
like
like
I'm
talking,
I'm
thinking
about
also
like
a
when
this
distribution,
that's
like
very
complicated
like
when
you
look
at
the
plot
of
density
versus.
A
A
So
the
idea
is,
we
would
extend
that
a
user
or
someone
would
extend
to
this
class
and
define
their
own
custom
call
so
for
like
an
iteration
stopper
would
initialize
it
with
some
maximum
iteration
and
then
it
just
compares
it
to
it
returns
to
boolean
whether
or
not
it
does
that
similar
for
like
a
target,
for
example,
a
target
misfit
stop
or
if
somebody
would
say,
tivo
wanted
to
do
a
pgi
condition
thing
where
it
was
had
a
picture
target.
It
was
comparing
it
to
some
value.
A
It
is
that
we
can
find
out
individually
and
then
arbitrarily
combine
them
afterwards.
So
let's
say
I
have
something
that
looks
like
this.
We
have
an
iteration.
I
want
the
areas
to
stop
at
10
this
target
misfit.
Once
the
first
data
misfit
hits
60
that
one's
satisfied
once
the
second
one,
it's
240
that
one's
satisfied
and
so
on,
and
then
I
combine
them.
A
So
this
would
provide
a
simple
stop
condition,
or
this
would
be
from
like
a
more
extensive
stopper,
stopping
condition
instead
of
having
to
define
every
having
to
define
a
new
like
inversion
directive.
Every
time
we
have
to
implement
another
stopping
condition,
it's
just
another
sentence,
just
like
another.
Oh
I'm
just
going
to
grab
these
stopping
conditions
and
use
them
it's
a
little
bit
and.
A
I
think
it's
a
little
bit
right
now,
the
way
we
kind
of
have
stopping
conditions,
it's
very
unclear
where
they're
at
and
where
they
define
them,
sometimes
they're
directives,
sometimes
they're
passed
to
the
optimization.
Sometimes
they're
passed-
I
don't
know,
sometimes
they
just
there,
there's
a
lot
of
defaults
that
we
can't
see,
but
this
is
just
kind
of
a
very
like
I
said,
a
very
bare
bones:
implementation
of
what
I'm
thinking
I
like
being
able
to
define
it
like
this.
A
A
E
D
D
D
Of
seems
like
it's
a
it's
a
natural
fit,
and
maybe
it's
its
own
kind
of
specific
style
of
directive,
but
passing
it
in
is
a
directive,
at
least
to
me
sort
of
seems
consistent
with
kind
of
what
we're
at
least
what
we're
doing
with
the
target
misfit
it's
it's
not
the
same
like
it's
true,
there's
shopping
criteria
in
the
objective
function
as
well,
which
there
probably
still
should
continue
to
be,
but
I
think
like
well.
What
I
would
envision
is
like
a
first
pass
and
be
very
curious
to
hear
others.
D
Thoughts
is
that
the
optimization
might
have
its
own
stopping
criteria,
and
the
user
might
also
define
some
stopping
criteria
like
what
joe's
got
an
example
of
here.
The
pgi
condition,
so
the
user-defined
ones
would
go
in
as
directives
and
then
the
inversion
it
has
access
to
the
optimization.
So
it
would
then
just
combine
combine
these
two
to
like
give
us
all
of
the
possible.
Stopping
criteria
would
be
just
first
past
thoughts,
but
I
don't
know
if
that
seems
like
it
jives
or
or
not
with
with
you
or
others
joe.
A
I
I
I
mean
I
kind
of
envision
it
being
a
little
bit
more
distinct
and
that
the
inversion
could
have
its
own
default,
stopping
conditions,
stopping
criteria
right
like
okay,
these
are
the
defaults,
and
then
you
could
always
overwrite
it
or
extend
it
in
the
same
manner.
Right
you
could
just
okay,
optimization
dot,
stop
like
is
equal
to
whatever,
like
times.
B
B
You
can
be
running
inversions
and
then
wonder
why
it's
not
working
so
and
also
it
doesn't
sound
like
we
have
that
many
options
for
the
starting
trade-off
parameter.
Do
we
it's
pretty
common
that
we
will
pick
we'll
pick
that
starting
beta
based
on
like
a
eigenvalue
estimate,
and
I
wasn't
really
able
to
find
something
that
just
says
start
with
this
trade-off
parameter
and
and
go.
G
B
000.
yeah,
that's
still
that's
like
kind
of
getting
into
the
code
and
then
setting
it
as
opposed
to
a
directive
that
says
start
at
this
beta
right
like
when
you
think
of
how
people
are
interacting
with
the
code
we're
trying
to
say:
oh
okay,
the
directives
are
used
to
go
and
define
the
cooling
schedule
or
the
or
the
trade-off
parameter
and
now
you're
saying
oh
wait.
We
can
do
it,
but
you
have
to
go
in
and
then
like
set
it.
B
G
D
I
think
this
leads
into
a
bigger
conversation
that
we
might
want
to
table
at
this
point,
because
I
think
this
leads
into
basically
do.
We
still
want
to
have
the
improv
joint
inversions.
Do
we
like
get
rid
of
the
improv
and
just
pass
an
objective
function?
So
I
think
it's
like
totally
a
valid
completely
a
valid
point
that
this
is
something
we
should
address,
but
just
want
to
make
sure
we
don't
sort
of
detract
too
much
from
sort
of
joe's
suggestions
here
of
focusing
in
on
a
stopping
criteria.
A
A
G
I
guess
so-
maybe
actually
that's
probably
a
starting
point
kind
of
just
making
it
clear
what
what
are
the
steps
and
criteria
we
have
and
how
you
actually
set
the
variables
there
and
like
what
you're
doing
is
seems
like
next
level
like
okay.
Now,
how
are
we
going
to
structure
like
a
class
that
can
be
used
as
a
stopping
criteria.
G
Where
I
am
also
not
sure
which
one
is
the
best,
it's
somewhat
fine
line
like
because,
if
you
think
about
the
real
like
what's
used
in
the
optimization,
it's
like
they
compare
the
relative
gradient.
How
much
increase
you
made
in
or
decrease
made
in
in
objective
function?
There
are
quite
a
few
other
criterias,
I'm
not
sure,
necessarily
that's
kind
of
useful
to
expose
to
the
user,
because
it's
somewhat
advanced
and
yeah
and
like
usually
what
I
use
is
just
a
target.
Misfit
like
okay.
G
B
If
you're
you're
solving
for
your
your
step
direction
and
you
you
know,
you
look
and
you
see
that
it's
not
accurate
enough
or
because,
like
there's
a
different,
you
guys
are
talking
about
two
different
kinds
of
stopping
criteria.
One
of
them
is,
like
you
know,
stopping
the
conjugate
gradient
solver
and
you
set
that
in
in
the
optimization
and
then
you're
talking
about-
and
I
think
joe
is
talking
about
global
stopping
criteria
that
says
terminate
the
inversion
if
any
of
these
conditions
are
met
or.
G
A
G
If
you
look
at
the
the
the
printing
of
that
inversion
in
simpac,
there's
total
f
told
g
and
whole
bunch
of
like
variables
that
says:
oh,
we
stopped
because
of
that,
but
that
I
think
it's
probably
not
clear
for
a
lot
of
users
like
what
what's
that
even
actually
mean.
So
I
think
that's
what
I
meant.
That's
something
under
the
hood
in
the
optimization
class
used
as
a
global,
stopping
criteria,
yeah.
B
G
B
A
Going
so
it
can
be
kind
of
odd
to
increase
or
like
like,
okay,
I
need
to
set
in
order
to
turn
off
the
relative
update,
stopping
criteria,
because
I
definitely
don't
want
it
to
stop
like
that.
You're
like
okay,
I
have
to
set
that
to.
I
I'd
have
to
turn
that
to
zero,
or
some
very
arbitrarily
small
number
that
it's
never
going
to
hit
instead
of
just
not
using
it.
B
Yeah
well
then,
with
the
iteratively
reweightedly
squares,
you,
you
bugger
the
thing:
if
you
use
the
target
misfit
directive,
you
have
to
set
a
you
know
a
target
for
the
l2
and
then
a
final
target
misfit,
but
in
iteratively
relatedly
squares,
specifically,
but
yeah.
That's
the
sort
of
getting
to
another.
B
B
A
Maybe
just
keep
thinking
about
it,
keep
it
on
your
mind,
keep
thinking
like
how
would
I
be
able
to
use
this
to
define
a
like
a
more
like
a
complex
inversion,
stopping
criterion
like
okay,
if
I
was
going
to
do
a
cross,
if
I
was
going
to
do
a
joint
inversion,
would
this
make
it
easier?
Would
this
make
it
harder
to
define
a
stopping
criterion.
A
D
A
A
F
A
A
A
A
And
then,
a
while
ago,
in
the
governance
structure-
and
we
were
chatting
about-
we
were
talking
about
having
like
you
know-
I
guess
associate
editors
type
of
thing-
you
could
be
more
specialized
and
responsible
for
certain
areas
of
it,
so
that
makes
sense.
I'm
sure
you
can
kind
of
get
back
into
that
kind
of
conversation
and
start
filling
positions
and
people
are
game
to
do
that.
I
would
certainly
appreciate
it.
A
A
A
Just
kind
of
start
priming
people
to
start
thinking
about
it,
we'll
have
a
little
bit
more
discussion
next
week,
I'm
just
gonna
we're
gonna.
My
plan
is
to
have
a
start
of
just
kind
of
a
status
of
all
the
current
pr's
on
syntag,
where
we
can
go
through
and
look
at
them,
and
maybe
at
least
for
now
have
people
like
okay
I'll,
do
an
in-depth
review
of
that
one
I'll.
Do
an
in-depth
review
of
that.
G
Just
briefly,
I
was
like
now
I'm
getting
into
a
little
bit
different
types
of
well
like
more
like
a
joint
types
of
inverse
fall
bomb,
and
I
was
wondering,
like
you
guys,
were
thinking
about
doing
how
to
implement
like
a
cooperative
types
of
inversion
in
simpex.
So
what
I'm
hoping
to
do
in
in
one
step
I
just
want
to
invert.
G
Okay,
like
I
sometimes
switch
off
certain
mapping,
let's
say
if
you're
inverting
for
sigma
and
mu
and
for
one
iteration
you
need
to
on
sigma
and
but
off
mu,
but
the
other
iteration
you
need
to
on
mu
and
then
off
sigma.
So
it's
a
it's
a
I'm
just
thinking,
but
that
yeah,
if
like
anybody
interested
in
you,
can
think
about
it
at
some
point
it
can
chat
at
some
point
would
be,
would
be
nice.
D
So
I
think
the
way
well,
one
way
to
do
it.
The
way
I
would
suggest
at
this
point
is
to
do
it's
a
directive
on
the
multipliers,
and
so,
if
you
change
the
like,
basically
the
beta
value:
well,
not
the
beta,
but
whatever
you're
gonna
call
your
multiplier
between
your
two
objective
functions.
If
you
change
it
between
zero
and
like
the
zero
object
in
simpeg
and
whatever
value
you
want
it
to
be,
that
will
short
short-circuit
and
not
evaluate
it.
D
D
But
basically
what
you
can
do
is
you
can
short
circuit
like
turn
this
data
misfit
off
by
changing
the
multiplier
to
the
zero
object
and
that
always
just
returns.
It'll
it'll
give
you
back
a
zero
and
it
won't
evaluate
that
objective
function,
so
you're
not
losing
anything
in
efficiency
like
it's
not
going
to
compute
the
data
misfit
or
the
derivatives
for
the
one
that
you
don't
care
about
in
that
iteration
great.
G
Oh,
I
see
yeah,
that's
probably
more
closer
to
what
I
was
kind
of
thinking.
Okay,
you
got
a
complicated
physics.
You
got
very
like
a
multiple
properties,
then
then
like
and
then
certain
property,
like
the
scale,
is
so
different.
So
even
if
you
do
a
good
job
on
scaling,
it's
just
like
it's
not
going
to
update
certain
things,
so
you
want
to
like
set
certain
things
going
to
update
and
this
or
like
a
first
and
then
move
on
to
the
other.
G
G
G
A
We
need
to
look
something
like
the
equivalent
of
like
a
block
zero.
That's
like
zero
blocks
or
something
I
don't
know
just
trying
to
think
about
how
to
like
make
sure
it
doesn't
about
like.
If
you
have
a
bunch
of
zeros,
it
doesn't
evaluate
part
of
the
model
like
I'd
say
like
all
like
you're
right
that
whole,
u
vector
is
zeros
for
all
the
sigmas
like
the
corresponding
sigmas
right
like
it
would
like.
Not
it
would
just
not
do
those
sigma
derivatives.
D
One
thing:
I
think
that
we
could
do
that
wouldn't
be
too
messy
is
actually
in
that
in
invertible
property
like
base
class,
so
within
simpeg
there's
the
prop
invertible
proper,
whatever
we
call
it
and
it
has
different
attributes
we
could
have.
We
could
just
add
an
active,
is
active,
attribute,
that's
either
true
or
false,
and
then
that
could
be
the
thing
that
you
switch
on
and
off
and
the
logic
then,
throughout
the
code
I
don't
think
would
get
too
too
messy.
A
D
Because,
what's
something
kind
of
nice
about
that,
too,
is
actually
if
you
wanted
to
basically
set
up
the
same
simulation
and
you
want
to
provide
a
model,
but
now
it's
for
a
fixed
mew,
and
you
just
don't
want
to
invert
from
you.
Then
you
don't
have
to
redefine
all
your
mappings
and
stuff.
Like
that,
you
just
say:
oh
don't
I
have
a
mu
mapping,
but
just
don't
don't
invert
for
it.