►
From YouTube: SimPEG meeting Dec 2, 2020
Description
No description was provided for this meeting.
If this is YOUR meeting, an easy way to fix this is to add a description to your video, wherever mtngs.io found it (probably YouTube).
A
As
we
go
perfect,
I
guess
just
like
a
first
question
for
the
meeting
planning
dom.
Are
you
good
to
get
the
demo
today
or
do
you.
A
A
couple
just
like
quick
things
to
put
on
folks
radar
and
then
we
can
go
around
the
room,
the
agu,
if
you
are
giving
a
talk,
you
have
to
have
three
slides
uploaded
by
friday,
so
I
sent
around
the
mt
ones
but
feel
free.
If
you
want
a
second
set
eyes
to
to
share
yours.
C
D
C
Quick
reports
if
you'd
like
I
can
go
first
on
that
after
we
had
the
we
had
a
nice.
You
know
hacking
party,
your
coding
party,
basically
on
friday,
it's
kind
of
just
fun.
It's
nice
to
see
people
it's
good
to
get
touched
up
on
a
few
of
those
things.
We
we
almost
got
the
discretized
pull
request
down
to
zero,
just
looking
at
it.
As
part
of
that
pull
request,
I
decided
to
go
over
the
weekend.
I
implemented
a
quick
like
a
faster
version
of
the
refined
box
and
refined
ball
functions.
C
I've
also
started
exercising
properties
from
the
discretized
library,
so
it's
just
a
matter
of
going
through
ensuring
that
it
still
behaves.
How
we
want
it
to
behave
and
it'll
give
us
a
little
bit
more
control
over
where
how
the
documentation
looks
and
where
things
are
it's
a
it's
not
too
much
of
a
problem
exercising.
C
B
Are
you
gonna
segment
because
we're
talking
about
basically
breaking
breaking
apart
rate
that
that
single
utility,
so
where
do
you
put
your
functions
and
is
it
gonna
be
called
through
that
utility?
Are
we
just
gonna
separate
them?
There.
C
E
B
Right
right
right
so
does
it
make
sense,
then
just
to
to
have
it
inside
that
because
we
could
we
could
just
basically,
you
know,
take
our
time
and
refactor
that
whole
thing
and
and
basically
get
rid
of
the
ball
and
the
in
the
box
for
the
current
utility
and
just
have
that
surface.
What
do
you
think.
C
B
And
I
guess
the
only
one
that
we're
missing
is
a
line
right
to
specify
basically
points
and
then
refine
on
the
on
an
edge
basically
of
a
different
part.
B
B
Oh,
I
see
and
if
you
give
a
quality
that
only
has
two
two
simplicities,
then
you
know
it's
a
line:
yeah
yeah.
That
makes
sense.
C
Yeah,
so
those
are
just
small
little
things
that
should
be
implemented.
It's
not
the
way
that
this
tree
mesh
works
is
it's
kind
of
simple.
It's
it's
it's
just
a
recursive
thing,
so
it
just
checks
that
okay!
Well,
if
I
contain
this
thing,
I'm
going
to
divide,
if
not,
then
don't
worry
about
it,
and
then
it
checks
itself
and
then
it
checks
its
children
and
it
keeps
going.
C
Moving
on
from
me,
who
else
had
a
does?
Anyone
else
want
to
go
next
before
we
start
telling
them.
D
Can
I
ask
a
quick
question,
joe
about
you,
were
talking
about
the
octo
mesh
right,
the
mesh
anything
right
so
that
that
is
a
way
of
possibly
parameterizing
the
surface
model
right
representing
the
earth
using
far
less
number
of
cells?
How
does
that
different
from
very
noise
cells,
because
in
monte,
carlo
2d,
3d,
monocular
method,
people
use
varying
a
lot.
C
Yeah
so
they're,
just
essentially
they're
different
fundamental
structures
like
fundamental
building
blocks,
essentially
right
right,
odd
tree
is
just
a
has
a
it's
like
a
semi-structured
mesh.
It's
it's
very.
B
C
Just
it
just
it's
another
match,
essentially
not
like,
we
couldn't
implement
the
tetrahedral
mesh,
but
it's
just
another
fundamentals
or
another.
You
know
unstructured
mesh
where
the
fundamental
parts
of
it
are
either.
You
know
quadrilateral,
quadrilaterals
or
boxes
in
3d
right
and
it
doesn't.
It
doesn't
necessarily
mean
you
understand
what
it's
like.
It's
just,
there's,
no
really
yeah
they're,
just
different
fundamental
parts.
F
Yeah,
but
I
think
that
georgia,
you
can
basically
use
dioptry
or
whatever,
like
club,
treat
in
the
same
way
they
use
the
vulnerability
cells
in
the
mcmc
because
they,
like
the
main
idea,
is
changing
the
mesh.
So
it's
not.
It's
rather
fixing
the
mesh
and
changing
the
mesh
in
the
inversion
process.
I
guess
so
yeah.
You
could
basically
use
that
like
different
types
of.
D
You
know
arc
tree
implementation.
Are
there
anything
similar
to
the
seeds
because
for
voronoi
we
just
have
a
whole
bunch
of
porn
street
food
plants
distributed
in
the
in
the
3d
space
they
are
called
seeds
and
the
seeds
defined
seeds
is
simply
the
center
of
each
unstructured
cell.
So
in
oxford,
mesh
implementation-
I
I
don't
know
anything
about
oxymes,
so
is
there
anything
similar?
So
maybe
this
is
a
major
difference.
C
They
have
cell
centers
as
well,
so
each
cell
has
a
cell
center
right
and
if
I
have
cell
centers
in
the
auction
mesh
is
uniquely
defined
right
cell
centers
with
their
associated
levels:
okay,
okay,
so
that
I
mean
that
define
that
would
define
like
how
like
where,
where
it
is
at
and
then
how
big
it
is.
Okay,.
F
D
G
H
D
Yeah
yeah,
so
don't
keep
that
in
mind?
Maybe
we
we
can
compare
this
to
octree
and
veroni
later
on
down
the
road
yeah.
E
E
You
can
be
going
through
the
theory
and
then
actually
running
code
in
a
tutorial,
basically
in
parallel,
so
all
the
things
that
you're
learning
about
you
can
actually
go
and
do
with
with
discretize
they're
all
connected
now
and
so
now,
I'm
you
know
I'm
at
a
point
where
I'm
starting
to
think
about
a
general
implementation
of
the
boundary
conditions,
because
it
would
be
good
to
have
a
theory
section
for
boundary
conditions
and
and
how
we're
implementing
it
and
then
that's
getting
me
thinking
about
just
a
very
end
user,
friendly
way
of
of
putting
in
dearly
neumann
or
mixed.
E
So
that's
kind
of
where
my
head's
at
lately
so
yeah.
I
could
keep
going
or
I'm
happy
to
get
input
from
from
you
guys,
if
it's
a
good,
a
good
time
for
that,
but
that's
sort
of
what
I'm
working
on
right
now.
E
Yeah
I
mean
I
guess
I
could.
I
could
show
you
guys
around
what
what
I'm
doing.
It
definitely
needs
some
form
of
review,
but
I
am
going
through
it
quite
thoroughly,
so
I
think
it's
more
personal
preference
details
whether
or
not
we
like
the
titles
some
of
the
layout,
but
you
know
I
have
I'm
not
leaving
typos
littered
through
it.
So
it's
it's
fairly
developed
but
that'd
be
great
yeah
I'll
do
that
next
week.
If
you
guys
want.
H
E
That
I'm
working
on
in
the
discretized-
and
I
I
know
we
talked
about
building
it
and
getting
it
to
you
in
a
way
that
didn't
force
you
to
build
the
website
locally.
I
haven't
gotten
around
to
that
part.
Yet
so,
right
now,
I'm
working
on
a
branch,
I'm
building
the
the
website
locally
and
that's
sort
of
where
it
exists.
E
E
H
F
E
Are,
you
know
more
general
for
tensor
mesh,
but
can't
be
done
in
tree
meshes
and
if
we're
making
a
general
finite
volume
package,
we
should
be
able
to
implement
these
things,
and
I
also
think
some
of
the
benefits
of
doing
this
is
that
our
implementation
of
boundary
conditions
in
simpeg
then,
is
actually
a
lot
cleaner,
and
then
we
don't
have
to
sort
of
write
the
this
functionality
for
specific
boundary
condition
implementation
for
some
of
the
the
electromagnetic
problems
we
can
then
just
say:
okay
call,
you
know,
implement.
A
E
Type
of
boundary
condition
sounds
like
it
comes
up
in
in
the
dc
and
then
lindsay
mentioned
it's
I
mean
it
comes
up
actually
in
in
mt.
That
could
be
really
powerful
because
that's
a
little
bit
more
of
a
complicated
boundary
value
problem
for
the
3d
problem.
C
E
C
C
E
Yeah
for
each
you
could
either
put
it
in
as
like
a
universal
thing
you
could
put
in
those
at
the
alpha
beta
and
the
gamma,
whatever
your
or
you
would
be
able
to
even
put
one
in
for
each
face.
E
Specifically,
if
you
had
some
kind
of
function
that
was
defined
on
the
boundary
I
just
yeah,
it
would
be
super
useful
and
then,
as
that's
being
developed,
it's
kind
of
neat
because
you
could
just
do
the
the
theory
section
as
well
it
I
don't
know,
I'm
pretty
happy
with
it.
So
I
guess
I'll
show
you
guys
next
week,
but
I'm
pretty
sure
you'll
like
it
anything
else.
E
C
Okay,
people,
I
see
you've,
got
some
notes
on
there.
I
Yeah
so
last
week
I
I've
been
working
on
putting
together
a
tutorial
for
like
joint
grab
mine
graph
mag
with
octree
and
pgi,
and
doing
that
was
actually
the
like.
I
was
reviving,
like
my
my
other
example
from
prior
to
simulation,
and
I
realized
that
the
new
mac
simulation
was
making.
There
were
some
incoherence
since
the
way
it
was
written
with
for.
I
So
I'd
like
to
reverence
is
like,
like,
especially
when
you
pass
the
wires
to
the
wires
as
a
mapping.
So
that's
that's
appear,
that's
it
doesn't
change
it
change
like
six
lines
of
code
and
change,
none
of
none
of
the
behavior,
except
when
you
do
a
joint
inversion,
so
that
should
be
fairly
straightforward
to
review
and
merging
and
otherwise
yeah
the
other.
I
My
streams
appear
still
like
two
of
them.
I,
like
probably
good,
to
go
or
close
to
be
good
to
go
and
then
yeah.
There
is
always
a
pgi
one.
That's
gonna
take
a
longer
time
so
yeah
and
that
and
that
tutorial
that
I've
been
putting
together.
I
will
be
putting
it
in
probably
maybe
another
pr
that
I
merge
in
my
pgi
branch
or
something
like
that.
I
But
so
we
can
work
on
that
and
maybe
devon
if
you
willing
to
help
me
if,
as
you
for
like
for
like
the
how
to
set
up
the
tutorial
and
like
how
it's
organized
that
might
be
useful
too,
but
yeah.
So
that's
kind
of
the
the
incoming
contribution
and
bug
fix
that's
happening.
E
Yeah
I
mean
there's
two
avenues
that
you
could
add
a
tutorial
or
something
there's
the
the
examples
gallery.
If
you
want
to
keep
it
just
general
and
then
the
tutorials
section
is,
I
think
it
may
be
a
bit
more
rigorous,
there's
a
bit
more
of
kind
of
people
learning
things
in
in
a
bit
more
of
a
an
order,
so
you
can
kind
of
decide
where
you
want
to
put
it
but
yeah.
I
can
show
you
around
how
to
do
that.
I
I
I
You
work
with
gravity
magnetic
oxymesh
mpgi
and
how
you
make
assumption
with
it.
So
that's
it's
yeah.
It's
a
it's
a
much
longer
tutorial,
but
I
what
I'm
trying
what
my
challenge
is
right
now
is
that
having
it
run
very
quickly,
so
like
I'm
trying
to
have
a
mesh,
that's
like
ten
thousand
cells
and
so
and
but
still
get
something
meaningful
full
out
of
it.
So
that's
kind
of
like
where
my
most
of
my
time
is
is
getting
right
now
in
the
in
the
design
of
something
that
runs
quickly
and
smoothly,
but
it's
still
meaningful.
E
I
E
I
That's
about
it
so
yeah,
if
you
joe
or
dumb,
if
you
could
take
a
look
at
maybe
it's
at
least
a
magnetic
one
soon.
I
think
this
one
is
like
extreme,
very
straightforward
to
to
bringing,
but
like
yeah
like
that
was
causing
me
shoes
when
writing
that
tutorial.
C
J
K
J
J
I
had
a
bit
of
pain
with
the
coveralls
and
also
seem
peggy
using
coat
cough
or
how
you
say
it
coat
coffee,
I
think
yeah.
So
I
first
thought
of
switching,
but
then
it
looked
like
this
would
be
the
bigger
pain,
switching
everything.
So
I
stayed
with
coveralls
and
found
another
way
to
do
that,
but
yeah,
okay
and
then
yeah.
It's
one
of
two
things.
Now
it's
fine
and
I
hope
I
don't
have
to
touch
it.
But
who
knows
when
we
have
to
move
again
so.
K
H
Yeah
a
couple
of
things:
let
me
I'm
just.
I
couldn't
figure
out
how
to
put
some
pictures
into
the
chat
box
here,
so
I
ended
up
putting
them
in
the
inner
slack
channel.
But
I
I
guess
the
things
that
I'd
like
to
kind
of.
H
And
with
the
senpai
codes
and
the
tkc
project
has
this:
is
that
kimberlite
for
those
who
aren't
part
of
the
group
in
northern
canada?
And
it's
been
a
kind
of
a
test
bed
for
us
for
a
lot
of
different
inversions
and
in
particular
the
em.
Both
frequency
and
time
domain
have
been
inverted,
so
we
wanted
to
go
back
and
take
a
look
at
that
dom
and
soggy
yeah.
Maybe
mike
mcmillan,
were
kind
of
involved
in
inverting
the
the
data
with
the
ubc
code
and
actually
got
a
pretty
nice
result.
H
The
problem
that
has
happened-
and
that
is
when
you
have
a
lot
of
symmetry
in
the
data
acquisition,
so
you
got
a
coincidence,
source
and
receiver
and
you're
just
flying
along
lines.
Then,
if
you
have
a
compact
conductor,
it
actually
comes
out
as
a
ring,
so
it
all
has
to
do
with
you
know
the
symmetry
and
the
sensitivities.
H
See
yesterday
of
writing
an
extended
email
soggy
to
you
to
dom
and
to
dequan,
because
all
three
of
you
and
maybe
mike
mcmillan,
also
has
has
addressed
this
problem
at
some
point
in
in
the
past,
declined.
H
In
order
to
kind
of
get
around
that
what
he
did
was
seed
the
inversion
with
a
conductor,
so
you
start
the
model
off
with
a
a
conductive
object
and
that's
the
our
understanding
at
that
point
was
that
was
enough
to
kind
of
get
the
vortex
currents
going.
So
if
you
just
have
a
half
space,
then
most
of
your
fields
are
just
resulting
from
basically
galvanic
responses
and
it's
just
difficult
to
get
out
you're
kind
of
trapped
in
that
local
meeting.
H
H
So
I
put
a
couple
of
images
in
the
in
our
slack
channel
just
to
kind
of
show.
You
know
what
they're
like,
but
in
both
of
those
cases
I'll
show
you
there.
We
start
off
with
some
kind
of
a
compact
conductor
and
you
end
up
with
with
rings,
so
I'm
quite
determined
that
this
is
the
last
time.
I
ever
want
to
see
this
as
a
problem,
because
we
keep
addressed
in
this
thing
and
then
it
never
quite
get
completed,
and
then
we
kind
of
come
back
and
yeah.
H
We
wanted
to
do
something
again
so,
as
as
I
said,
I'm
I'm
writing
an
extended
email
soggy
to
you
and
to
dom,
and
also
to
to
dequan
kind
of
laying
out
a
few
things,
but
there's
actually
one
thing
with
respect
to
simpeg
at
this
point
that
I'll
I'll
throw
out-
and
that
is
some
analytic,
modeling
or
at
least
semi-analytic
modeling,
for
you
know
our
conductive
permeable
sphere
in
a
half
space.
H
H
Some
of
the
people
here
can,
you
know,
provide
some
insight
as
to
our
analytic
solutions
for
a
yeah
for
a
conductive
permeable
sphere,
buried
in
a
half
space
of
variable,
conductivity
and
permeability.
H
That's
one
of
these
things
that
has
use
for
a
whole
bunch
of
things.
It
would
be
useful
for
this
tkc
data,
but
it's
also
useful
for
unexplored
ordinance,
stuff
and
just
kind
of
a
general
workhorse.
So
I
don't
know
if
anybody
has
got
that
solution
around
in
a
way
that
could
be,
you
know
easily
accessed.
E
Yeah,
exactly
I
don't
know
about
an
analytic
solution
or
a
semi-analytic.
That
is
a
the
sphere
in
a
half
space.
We
have.
We
have
the
the
vacuum
this
this
conductive
and
permeable
sphere
in
a
vacuum
which
is
pretty
useful,
but
I
don't
know
about
actually
burying
it
in
something
and
modeling
the
background
and
the
interaction
between
the
sphere.
In
the
background.
F
Do
you
think
we
should
ask
that
richard
smith
or
andre
studinski?
I
think
that
they,
I
think
richard
may
have
they
have
developed
that
code.
It's
like
a
I
sort
of
remember
I
kind
of
read
a
paper
about
that,
but
it's
complicated
solution
like
you
need
a
lot
of
integrals
but
yeah.
We
should
just
ask
him
first.
If
he
has
a
solution.
H
C
C
H
Exactly
exactly,
I
couldn't
agree
more,
and
I
think
this
is
you
know,
perhaps
the
time
now
to
really
investigate
this.
Lay
this
down
once
very.
It
would
make
a
really
nice
paper.
I
I'd
really
like
to
see
us
write
something
about.
You
know
this
whole
problem,
which
kind
of
perennially
comes
up
and
we
understand
it
and
we
have
a
way
of
how
to
proceed
well.
E
I
think
one
one
avenue
for
I
guess
putting
it
down
in
a
way
where
it's
reproducible
is
through
the
validations
section.
So
this
comparison
between
simpeg
and
ubc
codes
that
I've
kind
of
been
doing.
I
think
the
fem
is,
I
think,
maybe
the
next
one
that
we
want
to
tackle,
and
I
think
that
would
be
a
really
good
space
for
it.
E
F
Go
ahead
from
our
experience,
like
frequency
domain
was
less
kind
of
like
a
has
a
less
effect
than
time
domain
about
this
ringing
effect.
So
time
domain
is
for
sure,
like
it's
always
comes
up.
The
frequency
domain
from
our
experience
was
a
bit
less
and
because
I
think
the
sensitivity
function
is
a
little
bit
different
if
you
actually
like
apply
it
up.
The
main
thing
is
this
big
hole
in
the
center
because,
like
you're,
actually
not
sensitive
right
below
that
loop,
but
but
it's
actually
just
like.
F
Can
you
increase
just
the
number
of
frequency?
It's
you
got
like
three
frequency
or
four
frequency,
but
let's
say
you
got,
I
don't
know
like
20
frequency
like.
Would
it
just
help?
I
don't
know
just
just
a
thought
like
that.
H
Yeah,
so
there's
so
far,
we've
only
just
used
a
couple
of
of
frequencies
and
yeah,
maybe
more
will
will
will
help,
but
I
mean
there's
just
something:
that's
that's
really.
H
E
Also
one,
I
think,
one
important
detail
that
you
might
be
leaving
out
doug
and
that's
so
far
with
this
experiment.
We
started
with
just
inverting
the
imaginary
component
of
the
data,
because
we
have
some
pretty
significant
questions
about
how
we
are
modeling,
the
real
component.
E
The
fact
that
the
primary
field
has
such
like
a
higher
magnitude
than
the
real
component
of
the
secondary
field,
we're
kind
of
finding
that
the
forward
problem
is
maybe
not
being
solved
as
accurately
as
we'd,
like
the
the
imaginary
seems
to
be
pretty
happy.
But
the
real
component
when
we
do
the
forward
modeling,
is
not
showing
us
what
we
want,
and
we
have
some
questions
about
that.
E
So
for
now
the
inversion
that
we're
testing
with
the
ubc
code
we've
just
kind
of
been
putting
in
the
imaginary
component,
and
I
think
maybe
it
might
be
a
bit
better
constrained
if
the
the
real
component
of
the
data
is
inverted
as
well.
So
I'm
not
sure
if
we
get
as
much
ring
if
that
happens,
but
yeah.
E
C
Okay,
so
let's,
if
there's
nothing
else,
let's
move
along,
I
think
we've
only
got
about
20
minutes
left
or
so
for
the
hour.
So
if
does
anyone
else
have
anything
pressing
they'd
like
to
discuss?
If
not
we,
let's
I'd
like
to
move
on,
to
see
dom,
go
through
some
desk
information.
Sure.
E
C
E
Right
and
then,
and
then
a
3d
pseudo
section
type
plotting
so
really
the
hold
up
is
just
how
we
want
to
do
this
primary
secondary
and
whether
or
not
we're
happy
with
it.
So
maybe
it's
not
as
close
to
completion,
as
I
thought,
and
we
could
talk
about
it
later.
E
All
right,
I
haven't
touched
it
in
a
while,
so
I
mean
maybe
you
and
I
can
come
up
with
a
game
plan
on
what
we
want
to
bring
in
and
what
we
want
to
leave
out
for
now,
but
there's
useful
stuff
that
could
be
brought
in.
Oh.
E
A
Another
quick
item
is
the
simple
governance
discussion
tomorrow
I
put
the
calendar
link
in
the
notes
for
folks
who
want
to
join.
B
Yeah
I
can,
I
can
show
you.
B
Things,
okay,
so
what
I'm
gonna
show
you
right
now
guys
is
the
is
the
example.
That's
the
that's
in
the
what's
on
that
branch,
so
I
have
a
full
request
on
I'm
not
sure.
If
is
it
a
full
request,
I
think
it's
a
pro
request,
but
we
have
a
branch
called
called
sorry
for
the
background
channel
is
like
very
excited.
B
That's
a
nation,
so
this
guy
here
and
this
guy
there's
an
example
on
their
under
gravity,
and
it's
called
plot
tile
this
guy
here
and
so
what
this
example
is
going
to
show
is
how
to
create
basically
how
to
run
an
inversion
of
gravity
by
splitting
a
problem
into
multiple
tiles
right
and
then
this
is
going
to
be
using
all
the
all
the
desk
client
stuff
under
under
the
hood.
B
So
the
the
big
changes
from
the
current
desk
implementation
is
that
I
would
I
suggest,
starting
using
the
the
client,
the
client.
I
guess
you
can
see
my
screen
right.
Not
yet
there
you
go
sorry
about
that.
B
Okay,
now
you
can
see
my
screen
you're
good,
yeah,
okay,
okay
yeah.
So
the
big
change
now
is
start
using
clients
and
then
with
clients.
We
can
instantiate
workers,
which
means
that
let's
say
you
had
a
big
hpc
with
multiple
nodes
and
each
node
has
processors.
Then
you
can
assign
tasks
to
each
of
those
nodes
and
then
and
then
really
like
split
up
your
problem
into
into
a
cluster,
basically,
okay.
So
what
I'm
doing
in
this
script?
Here
john.
C
No,
I
I
don't
know,
I
guess
it'd
be
under
the
view
tag.
B
Appearance,
sorry,
it's
gonna
yeah!
It's
gonna!
Take
too
much
time.
Let's
just
let's
just
go
along
I'll
figure
out
the.
B
Yeah,
okay,
so
this
is
yeah,
so
this
is
the
script,
so
I'm
actually
seeing
a
client
on
top
of
my
script.
So
I'm
basically
telling
telling
my
computer
right
now
it's
going
to
be
a
local
cluster
right,
because
I
don't
have
multiple
machines,
so
it
will.
B
It
will
look
at
it
as
it
was
a
cluster
of
a
single
computer
with
the
with
12
or
12
threads,
okay
and
then
right
now
I
don't
have
any
workers,
so
I'm
just
going
to
give
it
nones
to
all
my
to
all
my
my
problems,
I'm
just
going
to
give
it
none,
so
it
will
basically,
when
a
client
receive
a
worker
called
none.
It
just
distributes
the
work
to
all
the
all
the
all
the
the
threads.
That's
just
how
it
works
by
default.
B
So
first
we'll
we
need
to
basically
create
tiles
right,
so
basically
take
the
take
the
survey
split
that
into
into
chunks
and
then
create
meshes
for
each
of
one,
each
one
of
them
and
then
for
each
of
those
simulations
we're
going
to
have
a
local
misfit
and
then
local
misfit
knows
how
to
project
itself
back
to
the
global
mesh.
B
So
this
is
a
delayed.
I
just
put
a
delay
decorator
on
this,
so
that
we
can
launch
all
those
mesh
creation
in
parallel.
Okay,
so
the
first
part
is
pretty
boring.
It's
just
creating
a
synthetic
survey
right.
Some
typography,
I
created
a
global
mesh
just
for
to
simulate
the
data.
Initially,
that's
that's
totally,
not
interesting
I'll.
Keep
going
yes
over
here,
I'm
just
simulating
some
some
data,
and
after
this
it's
this
part
is.
B
B
B
So
here
this
function
is
requiring
a
list
of
of
x
y's,
sorry,
a
list
of
indices
for
a
list
of
indices
for
for
each
of
the
tiles
okay,
and
then
I'm
just
feeding
this
into
the
delay
function
here
back
on
top
and
then
this
function
is
going
to
create.
You
know
from
this
list
of
locations
and
hubs
it's
going
to
create
a
local
mesh
and
then
the
local
misfit,
I'm
going
to
spit
out
the
local
mess
up.
B
Okay.
Now
the
neat
thing
with
with
with
this
with
the
client
and
then
I'm
going
to
go
back
to
it-
is
that
I
can
run
this
loop,
but
I
don't
need
to
wait
for
the
the
tiling
creation
to
be
over.
I
can
just
keep
going
right
and
I'm
just
appending
to
the
client
tasks.
Basically,
so
I'm
I'm
going
to
call
my
client
and
say
compute.
This
delay
function
here
and
then
I
can
append
this
to
a
list
and
what
this
returns.
B
What
this
this
part
returns
here
is
a
future,
and
basically
it's
just
gonna
be
running
in
the
background.
So
I'll
just
run
this
right
now,
I'm
in
debug
mode,
so
it's
going
to
be
pretty
slow,
but
it
will
run
hang
on.
B
B
Is
well,
I
think,
we'll
have
to
recon
being
because
my
whole
id
is
is
crashing
on
me.
F
One
question
there
so
now
you
got,
it
hasn't
run
yet
right
like
that
local
data,
mystery
function
hasn't
generated
yet,
but
you
had
a
delay
function
that
will
generate
that
will
do
that
computation
later
right.
B
B
B
C
B
Here
I'll
be
able
to
do
it
because
now
my
my
keyboard
works,
so
this
is
doing
nothing
right,
just
you're,
just
creating
the
delay
function
and
now,
if
I
launch
this
guy
here
I'll
show
you
what
happens.
If
I
put
this
here,
so
I
have
a
delay
function
and
if
I
do
this,
you
see
it
returns
a
future
and
the
future
right.
B
Now
it's
telling
you
the
status
that
it's
that
it's
pending
all
right,
but
if
then,
if
I
do
a
client
that,
if
I
do
a
clan.gather
on
this
it
will,
it
will
wait
for
the
calculation
to
be
over
and
then
you
will
return
the
result.
B
Right
and
now
it
returned
a
misfit
function,
so
it
it
fired
up
the
calculation
as
soon
as
it
was
over.
It
returned
me
the
the
result
of
the
delay
function,
which
in
this
case
is
a
misfit
function.
F
Yeah
one
curiosity
that
I
like
what
I'm
still
struggling
to
understand
is
so
you
got
a
global
mesh
and
a
local
mesh
and,
like
you,
need
some
sort
of
mapping
function
and
you
need
some
under
level
calculation
that
you
need
to,
let's
say
generating
the
sensitivity
for
a
local
mesh
where
that's
actually
happening.
Is
that
on
the
worker
side
or
on
the
parent
like?
Is
that
what
I'm
curious
about?
Where
that
computation
is
happening?
And
what
are
you
passing.
B
To
yeah
yeah,
that's
right,
so
the
calculation
is
happening
on
a
misspell.
So
the
misfit
knows
about
the
worker
that
you
want
to
assign
to
a
specific
local
match
right.
So
then,
when
we
go
to
the
actual
inversions
or
the
sensitivities,
I'm
just
going
to
show
I'm
going
to
go
down
to
it,
because
it's
taking
too
much
time,
let's
go
to
the
inverse
problem,
okay
and
then
inverse
problem.
We
have
the
the
get
fields
and
the
eval
function
right.
B
So
when
we
ask
for
get
fields,
it
goes
it
goes
in
here
and
then
it
cycles
through
all
the
misfit
functions
right
because
it's
a
combo,
it's
a
combo
misfit
at
this
point
and
then
for
each
of
these
guys
again,
it's
gonna,
it's
gonna
fire
off.
Basically,
the
the
calculations
of
the
fields
for
that
misfit
and
then
it's
going
to
use
the
workers
is
going
to
use
its
worker
all
right.
B
So
the
the
the
main
inversion,
the
the
main
branch,
only
only
holds
basically
a
bunch
of
small
misfit
functions
and
then
asked
to
execute
each
one
of
them
to
execute
its
own
field,
its
own
gradients
and
its
own
actions.
And
it's
just
going
to
collect
the
result
at
fdm.
B
F
Mesh
okay,
yeah,
and
is
that
that
local
mesh
information
is
stored
in
the
simulation
like
that
data,
local
data
misfit
object,
so
you
that's
the
container
and
you
are
passing
that
into
a
worker.
Is
that
the
idea?
So
it's
like
a
like
somehow
they
pickle
that
and
then
pass
it
into
a
worker?
Is
that
how
it
works?.
B
Yeah,
so
that's
a
that's
a
good
point
man,
because
currently,
currently
I
only
looked
at
the
at
the
pf
right
then,
and
the
the
sensitivities
would
be
stored
on
the
worker,
on
the
workers,
memory
or
like
drive,
and
that's
something
that
we
still
need
to
test
is
that
we
need
to
make
sure
that
we're
not
moving
the
mesh.
Are
we
not
moving
the
the
sensitivities
between
the
global
and
the
local
worker,
because
you
know
that's
too
much?
B
That's
too
much
passing
mem
stuff
on
the
network
yeah,
so,
basically
the
worker
we
will
need
to
hold
we'll
need
to
hold
the
staff.
You
know
the
simulation
parts
we'll
need
to
hold
it.
There
yeah.
E
Another
question
dom
is:
are
you,
are
you
tiling
for
every
receiver
location
or
are
you
tiling
for
little
groups,
or
can
you
do
both.
B
That's
that's
what
you
that's
what
you
can
decide
to
do.
It
doesn't
really
matter
right,
so
here
in
this
case,
I'm
creating
simulations
that
are
just
patches
of
receivers,
but
that's
just
this
just
depends
how
you
want
to
define
your
misfit
right.
If
you
understand
define
your
misfit
in
terms
of
frequencies,
you
just
create
simulations
one
for
each
frequency
and
then
you
just
have
10
a
bunch
of
simulations,
a
bunch
of
misfits.
That's
just
it!
Really!
It's
really
up
to
you.
It
doesn't
matter
right.
E
B
E
B
B
Okay
and
then
yeah
back
to
the
inverse
problem,
so
you
when
we
evaluate
the
function,
so
it's
gonna,
it's
gonna
do
this
for
the
fields
right,
it's
gonna
ask
all
the
workers
to
calculate
fields,
collect
the
result
and
then
for
the
gradients,
gradients,
radians,
it's
the
same
thing
right.
It's
gonna!
It's
basically
here
just
asking
the
global
misfit,
that's
derivative!
B
Then
we
have
a
das
data
misfil
and
the
dash
data
misfit,
just
it's
gonna
cycle
through
all
the
local
and
then
ask
for
its
own
derivatives
and
then
at
the
end
it
just
collects
it
all.
B
B
And
then
for
the
hessian
or
like
the
the
rf2,
then
it's
going
to
send
the
vector
to
all
the
workers
compute
it
and
then
just
sum
them
all
up
at
the
end.
B
So
you
guys
can,
you
know,
can
go
through
the
code
and
I
think
the
outstanding
questions,
as
you
said.
So
I
guess
we
need
to
make
sure
that
that
workers,
that
the
simulations
are
basically
stored
onto
the
worker
and
not
sent
back
and
forth
between
the
domain
between
the
client
and
the
workers.
Basically.
F
That's
actually
sort
of
I
I'm
still
having
like
I'm
struggling
to
kind
of
understand,
so
we
need
some
place
to
that
be
stored
right
so
that
that
that
local
misfit
class
need
to
be
stored.
At
some
point
like
and
at
some
place
like,
I
guess
that's
actually
not
on
the
workers
but
on
the
parent,
because
on
the
work
or
let's
say
about
10
nodes
or
10
workers,
10
processors,
but
you
got
like
100
meshes,
so
you
cannot
actually
like.
You
cannot
always
store
them.
F
So
I
think
that
that
process
in
the
worker
is
sort
of
on
the
fly.
So
you
always
need
to
pass
information
from
the
parent
that
needs
to
be
stored
and
then
that
that
can
be
evaluated
on
the
on
the
processor
or
workers
side.
So
that's.
That
was
my
question
and
the
one
other
thing
that
I
was
curious
that
that
suppose
you
got
pretty
big
mesh
big
global
mesh,
then
that
projection
function
you
need
to
project
right.
F
B
Currently,
currently
it's
gonna
be
a
client.
It's
gonna
be
your
own,
your
local,
your
main
node,
that's
gonna.
Currently,
that
is
holding
them
all
yeah.
B
I
see,
I
see
got
it
because,
because
I
mean
you
can
send,
you
can
broadcast
vectors
to
your
workers,
but
still
at
the
end
of
the
day,
it's
going
to
be
your
main
node,
that's
going
to
have
to
yeah,
because
when
you're,
when
you
think
about
it,
when
you're
building
your
misfit
functions,
you're
appending
them
all
as
a
list
and
then
your
your
main
node
when
it
has
the
global
the
global
misfit,
it
technically
holds
everything
in
inside
right,
so
the
main
node
would
have
it
all.
B
The
potential
fields
it's
pretty
easy
because
we're
doing
a
two
zar
and
a
from
zar
and
then
the
hope
is
that
since
the
calculation
is
done
on
a
worker,
the
two
czar
will
be
stored
locally,
where
the
worker
is
right
on
the
drive
of
the
worker
and
then
after
the
fronts,
are
it's
the
same
as
the
same
place.
So
in
theory,
if
we
store
sensitivities
that
it's
not
an
issue,
because
we
can
store
things
locally,.
B
Right,
we
obviously
need
to
double
check
this
with
with
a
real
like
distributed
system,
to
make
sure
and
that's
what
john
is
gonna.
It's
gonna
experiment
on,
because
he
has
one
to
be
able
to
make
sure
that
when
we're
doing
it
from
and
twos
are
that
the
czar
stays
stays
on
the
worker
or
on
the
node,
let's
call
it
the
node.
D
Hey
thomas
real,
quick
question
about
the
sensitivity,
so
so
I
don't
know
how
so
for
how
is
the
sensitivity
calculated?
It
is
calculated
that
at
each
small.
B
Region
or
yeah
that's
correct,
yeah,
so
each
small
region
has
its
own
home
little
sensitivity,
yeah,
that's
right!
So
the
simulation
right,
basically
we're
parsing
patches
of
data,
and
then
each
patch
of
data
has
its
own
sensitivities
and
at
the
end,
it's
just
a
projection
from
the
local
sensitivities
to
to
the
global
sensitivity
which
is
just
a
vector,
expanded
right,
it's
a
short
vector,
and
then
we
expand
it
to
the
global
vector.
B
Yeah
absolutely
yeah,
so
so
right
now
you
see
I'm
I'm
pre-computed
them
in
that
in
that
example.
So
I'm
just
doing
a
for
loop
all
right.
So
I'm
creating
all
my
problems
in
a
for
loop
and
after
this
here
I'm
just
triggering
right
away.
The
twos
are
for
the
sensitive
calculations,
all
in
parallel,
and
maybe
I
can
run
this
line
so
I'm
just
gonna,
I'm
just
gonna
run
to
here
and
you'll,
see
the
you'll
see
what
happens.
B
Paralyze
over
the
data
points
and
over
the
tiles
right,
so
it's
two
levels
of
prioritization,
I'll
and
I'll
show
you
the
I'll,
show
you
the
the
work
okay.
So
I
created
my
tiles
here
and
now.
I'm
gonna
start
spinning
the
sensitivities,
but
at
the
same
time,
because
it's
a
client,
I
don't
need
to
wait
for
it
to
be
over.
So
I'm
just
gonna
show
you
what
I
how
it
looks:
real,
quick
okay.
So
this
is
my
test
scheduler.
B
B
On,
oh,
I
guess
I
already
I
already
calculated
one
second,
I
need
to
kill
my
old
sensitivities.
B
B
I
was
cleaning
it,
I
was
cleaning
it
and
then
I
forgot
to
turn
it
back
on.
Okay,
all
right,
so
I'm
gonna
fire
up
four
sensitivities.
I'm
just
gonna
refresh
my
current
on
here.
Okay,
so
first
sensitivity
is
gonna.
It's
gonna
kick
in
all
right,
so
it
started
calculating
already
all
right,
but
I'm
not
gonna.
Wait,
I'm
gonna
fire,
the
third,
the
second
one
and
I'm
not
gonna,
wait
I'm
gonna
fire,
the
the
fourth
one,
the
third
and
fourth
one
all
right.
So
in
the
background,
it's
it's
just
sending
all
the
you
know.
B
B
Does
that
make
sense?
Joshua
am
I
am
I
saying
nonsense
here:
yeah,
yeah,
yes,
okay
and
what's
important
is
that
you
don't
want
to
have
a
white
white
gap
right
when
you
look
at
your
tasks.
You
don't
have
down
time
here
at
the
time,
because
I
paused
I
paused
it,
but
if
you
zoom
into
like
here,
you
know
your
your
calculations.
B
E
B
Paralyzed
and
then
just
quick
comment
just
to
finish
here,
because
we're
already
past
the
hour,
but
there
were
some
inefficiency
that
we're
doing
in
the
optimization,
and
I
think
would
be
nice
that
we
just
generally
try
to
to
fix
those.
If
you
look
at
the
inverse
problem,
one
thing
that
started
to
take
me
a
lot
of
time
was
the
regularizations
like
we
were
for
looping
over
multiple
objective
functions,
multiple
times
and
doing
a
ton
of
like
you
know,
even
if
it's
sparse
matrix
back
there,
it
still
takes
time.
B
So
I
would
recommend
that
we
just
should
just
form
the
the
regularization
it's
a
sparse,
matrix
right
and
just
form
it.
And
then
every
time
we
ask
for
j
and
and
the
hessian
we
just
do
one
matrix
vector
product.
It's
a
lot
faster
than
having
to
loop
and
to
do
a
you
know,
to
repeat
the
same
operations
over
and
over
again.
So
that's
that
was
a
nice
speed
up
and
and
then
what
about
it?.
F
B
F
B
F
Creation,
we
think
we're
all
like
only
valid
in
the
fields
once
but
like
something
like
a
deep.
For
instance,
it's
valid
a
lot
of
times
so
whenever,
whenever
getting
the
code
in
syntax,
you
make
sure
like
there
are
a
lot
of
function.
Evaluations
so
make
sure
yeah
like
remove
all
the
repetitive
calculations.
Absolutely
that's.
B
Not
required
yeah
optimization,
you
see,
I
kind
of
rework
the
the
gauss
newton
iterations,
but
really
the
the
big
chunk
here
is
just
the
the
hessian
call
right
and
then
we
only
need
to
do
it
once
so.
B
Yeah,
basically,
there's
not
much
way
changing
here.
I
always
just
double
checking
that
everything
was
done
properly
but
yeah.
That's
about
it!
That's
about
it!
So
obviously
there's
a
lot
of
details.
It's
gonna
require
a
lot
of
reviews
from
everyone,
but
I
think
it's
it's
moving
along.
I
have
a
little
graph
that
can
show
you
the
quickly
the
the
scale
up
right.
I
just
so.
I
ran
this
problem
over.
B
You
know
problem
sizes,
so
from
like
a
0.5,
gig
problem
to
a
50,
gig
problem
and
then
over
a
number
of
tiles,
and
you
see
that
we're.
You
know
at
some
point
if
you
keep
tiling
you're
increasing
the
overall
run
time
and
sensitivity
time,
just
because
the
overhead
of
creating
meshes
and
looping
and
all
this,
but
for
very
large
problems.
You
know
you
can
have
a
almost
a
factor,
10
of
a
run
times
improvement
as
you
increase
the
number,
the
number
of
tiles,
and
it
looks
like
this
new
client
thing
really
scales
up
quite
nicely.
H
I
I
was
just
going
to
bring
in
one
comment
that
that
looks
that
looks
really
nice,
I'm
wondering
if
you
or
any
of
the
the
group
has
really
been
interacting
at
all.
With
with
with
dequan,
I
mean
you
know,
a
lot
of
these
things
were
kind
of
at
the
heart
of
his
thesis.
I
know
when
he
went
back
to
china.
H
You
know
he
was
planning
to
continue
on
some
of
these
he's.
You
know
perhaps
a
little
bit
more
involved
with
machine
learning,
but
it
seems
that
this
might
be
a
problem
that
would
really
resonate
with
him
and
he
may
have
some.
You
know
valuable
thoughts
or
input
and
also
it
might
be
something
that
he
could
really
kind
of
connect
with
and
you'll.
Perhaps
you
know
get
the
chinese
community
or
hit
the
people
that
he's
been
working
with
kind
of
involved
with
the
project
and
a
bit
more
with
simpeg.
H
B
Yeah
totally,
I
totally
agree.
I
think
what
where
deeply
is
going
to
want
to
come
in
is
is
how
we
do
the
tiling,
because
that's
what's
its
focus
right
right
now,
at
this
point,
we're
just
laying
down
the
infrastructure
on
how
the
parallelization
is
done
over
the
tile.
So
it's
kind
of
it's
very,
like
it's
very
unrelated
to
geophysics
at
this
point,
but
yeah
we
should
bring
him
back
in
the
fall
for
sure.
Once
we
have
something
more
solid
running.
J
F
F
B
Yeah
so
there's
a
there's,
a
sweet
spot
right
where
okay,
so
every
time
you
tile
it,
you
basically
reduce
the
overall
sensitivity
space
right,
but
then
it's
a
summation
over
mesh
creation
and
then
what
else
is
going
on
here?
You
need
to
do
the
tiling
on
top
of
it,
so
eventually
you're
overhead
of
creating
tiles
gonna
start
to
to
take
over
and
eventually
also
eventually
going
to
get
a
saturation
right.
B
B
C
L
B
Absolutely
absolutely-
and
here,
on
top
of
this
there's
another
issue
of
the
the
ssd
drive,
as
you
said
right,
so
it's
a
hardware
thing
where
I'm
limited
eventually
by
the
the
speed
at
which
I
can
transfer
stuff
from
memory
to
ssd.
So
I
just
have
tons
of.
E
B
H
B
C
Yeah
well
thanks.