►
From YouTube: simPEG Meeting May 1
Description
Dom Fournier shares his work on plugging SimPEG into GIFtools
D
A
Big
high
pressure
regions,
but
it's
just
beautiful
theorem
you
just
have
to
like
wear
sunglasses
all
the
time.
Oh
well,
I,
that's
good
for
an
extra
20
degrees
when
it's
sunny
and
dry
compared
to
that
Cougars
and
easier
I
think
to
keep
warm
to
put
on
extra
moon.
You
just
don't
have
that
penetrating
humidity
yeah.
E
At
the
same
time,
we're
all
that
programmers
are
all
day
lockers
for
this
library,
so
we
kind
of
have
this
left
nice
nice
window,
where
we
have
the
chance
to
be
able
to
ease
the
attention
of
these.
It's
people
right.
There
was
like
a
handful
of
users,
but
there
are
users
that
have
needs
constantly
needs
any
happen
to
research
budgets,
correctly,
initiatives
being
really
well
they're
released
version,
fonts
are
increasing,
so
those
have
been
X
here
is
gonna,
be
a
pretty
good
year
for
everybody,
so
I'm
ecstatic
with
it
were.
E
We've
been
really
good.
That
started
like
pushing
the
code
rules
and
pushing
invariance
and
all
fronts,
but
we
haven't
spent
much
time
on
the
user
on
an
end
user
part
of
it
right
so
right
now
we're
publishing
everything.
There's
our
scripts
notebooks,
which
is
good
for
other
programmers,
but
like
for
industry,
there
were
no
they're
likely
not
going
to
dive
in
it's
kind
of
a
and
catch
me
to
love.
You
only.
E
E
So
the
idea
here
is
that
including
little
sounds
you
can
just
connect
movie
in
their
face
that
we
have
our
users
to
be
able
to
leverage
this.
This
effort
of
lucky
make
me
inversion
easier,
just
connected
with
the
open
source,
the
open
source-
and
that
sounds
me.
Yes,
then,
on
sniffing
sighs,
no
need
to
worry
about
visualizing
and
handling
file
version,
and
on
to
flip
side
when
were
like
sensing.
C
E
E
Tools,
the
basic
edge
it
feels
dizzy,
it's
a
fairly
simple
other
face
its
building
in
Java
and
a
scrub
down
being
used
be
able
to
view
operations
import.
They
create
initiatives,
written
versions
of
Obama
and
currently
this
is
like
a
hundred
percent
bill
towards
running
UBC
goes
all
the
fortune,
a
schools,
but
because
we
built
synthetic
like
it's
us
in
our
language.
That
UBC
is
you,
students
there's
a
conversion
methodology.
Anything
the
connection
is
fairly
straightforward.
They
will
do
instead
of
sending
a
job
to
the
Fortran.
E
E
Yeah,
yes,
that
in
jiff
tools
we
have
an
inversion
object
which
come
things
which
knows
about
about
Meadows.
It
knows
about
theta
or
get
stuck
with
my
bucket
and
all
that
stuff
and
inversion
parameters
which
were
used
also
Sunday
once
this
object
is
created.
Usually
good
way
to
go
is
that
we
just
wanted
a
job
of
the
UVC
codes
right,
so
it
just
goes
and
calls
a
poor
trap.
Runs
it
to
the
bag.
E
E
Click
on
this
and
what's
happening
in
the
background,
is
that
it
calls
fight
on
from
the
outside
and
currently
just
built
an
inversion
script
right.
So
this
is
just
creating
breaking
this
sort
of
any
like
we're,
usually
doing
the
books.
Written
is
certainly
the
problem
organization
and
just
exchange
all
the
parameters
that
we
seven
just
little
just
send
them
to
this
MPEG
and
run
out.
E
E
Fine,
despite
meets
all
the
things
we
need
to
come
up
to
the
Rd
acres,
but
he
did
they
do
and
then
on
a
map
they
math
aggressive
I,
have
a
small
script
and
math
out
of
it
once
this
is
run,
just
slows
this
guy
back
in
and
then
reformatted
for
justice
people
to
digest
again.
Did
they
once
the
inversion
is
dead,
I'm,
al
d'amato
agro
them,
and
then
we
have
the
same
functionality
that
that
chip-
those
hats
where
we
can
visualize
the
model.
F
C
E
E
C
Could
I
mean
because
then
it's
very
easy
to
load
it
back
into
Python
and
figure
out
what's
going
on
and
if
MATLAB
ever
changes
how
things
are
safely
null
hi
and
the
people
we
sort
of
found
that
between
Python
to
you
in
Python
3,
there
are
few
changes,
and
so
they
made
it
backwards
compatible.
But
it
was
a
little
bit
of
a
headache,
whereas
hdf5
is
yeah
so
good.
That
would
be
easy
way
to
go
and
then
to
if
somebody
wants
to
look
at
it
with
different
software,
that's
an
easy
thing
to
standardize.
E
So
it's
just
it's
just
stories
as
static
as
a
stack
of
objects
means
random
means
of
age,
5,
arguing
today
the
I
don't
search
3d
art
the
query
from
the
outside.
No
it's
a
container,
but
it's
not
really
easily
very
wearable.
That
events
did
you
guess,
just
one
hasn't
you
slower
didn't
eat
burger,
saying
like
what,
if
someone
wants
to
interact
with
a
pony
on
the
outside,
okay
legit
will
not
read
and
write
from
a
safe
spot,
but
it's
not
structured
and
easy.
We
didn't
just
we're
keeping
all
the
items
of
a
nice.
A
E
C
E
C
E
H
E
E
E
C
B
C
In
this
case,
what
you're
effectively
doing
and
like
this
is
sort
of
looking
forward,
but
it's
setting
up
an
easy
way
for
your
user
to
just
generate
that
like
set
of
parameters,
basically
like
the
set
of
JSON.
Well,
I
mean
it's
a
dictionary.
So
your
your
set
of
dictionary
parameters,
and
so
then
all
we
need
to
do
on
this
in
peg
end
is.
It
should
be
as
simple
as
just
deserializing.
D
C
Yeah,
okay,
so
this
is
where,
like
JSON
or
hdf5
I
think
is
a
much
better
way
than
dealing
with.
C
B
C
To
use
only
simple
Python
right
because
for
me
I
mean,
if
I
generate
a
like
an
inversion.
Basically,
that's
ready
to
go
on
my
laptop,
but
I,
don't
necessarily
want
to
run
it
there.
I
want
to
ship
it
over
to
the
cluster
like
doing
that.
Eh
ef5.
It's
a
very
easy
and
stable
way
to
do
that,
whereas
writing,
civic
dot,
mad
and
sort
of
creating
all
that
functionality
doesn't
make
sense,
not
work.
Full-Time
yeah.
E
C
And
so
how
that
will
happen,
and
this
is
something
that
we
can
sketch
out
and
I
think
the
simulation
refractors
can
help
clarify
that.
But
basically,
what
we're
doing
is
we
write
things
with
properties
is
recreating
like
in
a
census
of
the
amount
of
how
to
interact
with
sin.
Think
so
like
set
your
frequencies
and
all
these
kinds
of
things.
What
are
the
key
words
and
then
how
are
things
nested?
And
so
basically,
once
we
have
that
structure
right,
you
don't
need
to
know
about
the
inner
workings
of
sin
peg.
I
I
C
Serialize
that
one
be
serialized
the
simulation
right,
there's
all
the
instructions,
all
the
way
down,
that
like
dependency
path,
are
serializable,
so
that
than
what
we
need
to
implement
on
the
inversion
side
as
well
is
then
looking
at
all
of
our
directives
that
I
think
the
optimizing
or
the
objective
function.
Stuff
is
really
close,
if
not
they're,
basically
already
yeah,
but
then
once
we
have
like
directives,
the
optimization
serializing
and
the
objective
function,
stuff
serializing,
but
then
basically
means
you
can
serialize
the
inversion
object
right.
B
C
We
need
to
be
careful
with,
and
this
is
something
I'm
trying
to
do,
and
this
is
why
I
like
I
sent
that
over
well
when
I'm
in
looking
at
the
simulation
stuff
I'm
trying
to
tease
apart
what
needs
to
be
a
property
and
what
doesn't,
and
so
there's
some
cases
where
properties
isn't
used
and
it
needs
to
be
injected.
There's
other
cases
where
properties
is
being
overused,
and
so
what
I
mean
by
that
is
that
if
there's
something
that
can
be
generated
based
on
user
input
data,
then
it
should
not
be
a
property.
H
I
H
G
C
H
I
D
C
A
I
C
I
A
It's
actually
very
important
if
you're,
especially
when
you're
testing
with
you
know,
say
a
few
days,
as
did
you
know,
frequency-domain
p.m.
right
and
then,
if
you
start
off
with
your
adding
errors,
you're
having
a
different
round
receipt,
I
mean
you
actually
can
get
quite
different
errors
and
what
results
can
really
be
quite
different,
so
we're
not
paying
for
the
errors.
A
C
C
So
this
this
is
just
one
example
that
is-
and
this
is
like
not
a
knock
on
anybody's
coding
like
it
makes
it
makes
perfect
sense.
But
this
is
an
example
when
we're
thinking
about
serializing
of
redundant
information
that
we
don't
need
serialized.
So
in
this
case,
when
we
create
a
survey,
the
survey
this
actually
the
source
list
will
be
a
property,
and
so
I
know
I
can't
remember
if
that's
done
yet
or
not,
but
it
will
be
so.
C
The
source
list
is
a
property
and
it
contains
all
of
its
locations
and
then
each
source
has
its
receiver
list.
So
in
that
case,
all
of
the
information
about
the
electrode
locations
is
actually
contained
in
the
source
list
and
the
receiver
list
right,
and
so
in
this
case,
if
we
were
to
serialize
this
object,
that
information
is
redundant
right,
the
a
locations,
B
locations,
m
and
n.
All
of
that
is
completely
redundant
because
it's
already
contained
in
these
sources
receiver
list.
C
C
B
B
C
G
C
It'll
set
it
so
like
it'll,
be
very
similar
to
the
mesh,
for
example,
when
you're
creating
an
edge
curl
right.
So
the
very
basic
information
that
we
need
to
create
a
tensor
mesh
is
the
tensor
dimension
right,
and
so,
when
you
save
the
mesh,
that's
the
only
information.
That's
going
to
be
saved
like
that
and
you're
working
right.
So
those
those
are
the
pieces
of
information.
We
need
to
recreate
it.
C
So
then,
when
you
recreate
it,
those
are
the
only
things
that
it
knows
about,
but
then
because
we
have
the
set
of
instructions
attached
to
the
class
about
how
to
create
the
edge
curl.
If
it's
not
there,
when
you
call
it
edge,
curl
it'll
get
cream.
So
it's
very
much
just
like.
So
we,
when
you
initially
set
up
a
class,
it's
going
to
behave
exactly.
C
So
if
we
have
problems
with
space
or
like,
if
things
are
very
large,
we
can
specify
how
its
serializes,
so
we
may
end
up
wanting
to
do
something
a
little
more
clever
and
like
compressed
data
files
and
things
like
that,
but
that
can
all
be
taken
care
of
in
the
same
way.
So
it
was
kind
of
nice
is
like
we
can.
Basically,
as
long
as
we
can
specify
the
schema
and
like
how
what
keywords
there
are
that
you
need
to
set
as
a
user,
then
how
we
compress
and
store
it
actually
is
irrelevant.
C
C
C
C
C
E
C
To
like,
with
respect
to
data
files
and
things
like
that,
we
don't
necessarily
have
to
resave
like
us
big
data
file,
we
can
be
smart
about
that
in
the
sense
that,
like
as
long
as
we
know,
for
example,
it
is
in
like
our
iam
data
and
this
gos
I,
like
X
Y
Zed
file,
and
we
know
we
should
be
using
this
parser
like
we
see,
realize
those
instructions
to
say.
Look
at
this
file
use
this
function.
C
In
that
case,
your
idea,
so
that's
sort
of
like
down
the
road
right
now
we
probably
will
have
to
copy
it
because
that's
just
easier
but
yeah,
but
those
types
of
things,
because,
especially
when,
if
you
start
getting
to
very
large
data
sets,
we
certainly
don't
want
to
be
generating
copies.
So
that's
yeah.
Those
are
all
things
that
are
doable.
B
C
E
C
And
then
so
then,
in
this
case,
like
some
of
the
things
that
I've
been
playing
around
with
and
don't
necessarily
have,
it
figured
out
yet
well.
I've
got
a
first
pass
but
like
of
how
to
point
like
this,
can
either
be
an
array
or
it
can
be
a
pointer
to
a
file
and
so
that
it's
working
like
substances
so.
C
I
E
G
G
E
D
D
I
L
C
C
C
Actually,
all
that
I
needed
to
run
the
simulation,
so
this
is
getting
closer
to
how
we
actually
want
to
work
with
this.
All
of
the
stuff
below
was
for
it,
okay,
2d,
but
this
this
is
all
that
I
needed.
So
ideally,
that
should
be
like
how
we
should
be
able
to
serialize
and
run.
This
is
a
forward
simulation
of
what
we
should
be.
E
C
What
this
like,
there's
a
number
of
things-
I,
really
don't
like
about
this
right
now,
because
it
is
it's
a
weird
extra
layer
of
simple
but
like
I,
was
sort
of
using
it
to
think
through
what
the
simulations
you
did
look
like.
So
it's
sort
of
like
these
weird
classes,
strapped
on
to
simpe,
to
create
the
way
that
I
wanted
to
interact
with
it,
and
so
ideally,
this
actually
should
just
be
how
we
promise
like
a
a
time
domain
simulation.
So
this
should
be
core
same
peg.
C
C
Good
yeah,
that's
one
okay,
because
what
I
think
would
be
nice
to
do
is
to
be
able
to
call
simpe
like
from
the
command
line,
and
so
what
I
mean
by
that?
This
is
a
package.
I
was
reviewing
sauce,
which
is
kind.
E
C
So
what
he's
done
is
created
like
a
structured
ya,
mol
file
that
then
you
can
just
run
on
the
command
line.
So
in
this
case,
what
we
would
be
doing
is
creating
the
structure
JSON
file
so
so
like
this
is
how
you
they're
calling
their
Python
code.
It's
just
like
you
know.
The
package
name
simulate
this,
and
so
it
would
be
really
kind
of
cool
and
this
interesting
to
see
if
we
have
like
simple
simulate
and
then
your
simulation
file
or
simple
game
per
conversion
file.
Okay,.
C
E
C
The
other
thing
that
I
think
could
be
nice,
too,
is
that
if
we
do
change
like
simple
things
in
the
API,
this
like
we
can
sort
of
do
all
those
change
itself
consistently.
Whereas
right
now,
if
we
change
something
in
the
API,
you
then
need
to
update
your
jiff
tools,
the
mechanism
with
which
it
writes
the
script
that
make
sense
so
like
if
we
change
I,
don't
know
something
to
pay
paid
so
NC.
J
C
C
So
it
is
like
just
their
parameters.
Basically,
oh
I
see,
so
it
is
a
effectively
a
dictionary.
Yamo
is
meant
to
be
like
a
little
more
human
writable
for
us.
I.
Think
JSON
is
better
because
there's
more
information
that
we
need
to
inject
than
this,
like
you,
don't
want
to
be
going
in
and
trying
to
manually
enter
time,
steps
and
stuff
like
that.
G
I
C
C
I
C
C
C
C
So
that
those
steps
should
be
on
this
impact
site,
but
for
now
it
makes
sense
that
you're
doing
it
on
the
Digital
side,
todrick
I
think
so,
like
we're.
Trying
to
I
guess,
bring
these
things
closer
together,
but
right
now,
because
there's
still
a
development
that
needs
to
happen
on
impact
like
as
long
as
that
sort
of
interfaces
is
fairly
clean
with
how
you're
writing
out
the
script.
Yes,
then
there
won't
be
any
problem
like
transition.