►
From YouTube: SimPEG EM Tutorial
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).
B
C
So
to
get
started,
the
first
question
I
have
is:
were
you
able
to
access
the
the
notebooks
that
I
sent
around?
Yes,
yes,
okay
and
any
problems
installing
them
or
anything
like
that?
Is
that
something?
Oh?
Okay,
perfect?
So
then
we
can
sort
of
launch
right
into
that
and
what
I'm
hoping
like
as
we
go
to
this
day.
This
is
jump
in
and
interrupt.
If
you
have
questions
or
want
me
to
share
my
screen,
which
means
I,
won't
see
you
so.
E
A
C
A
C
These
are
a
whole
collection
of
notebooks,
mostly
around
electromagnetics,
that
we've
put
together
that
are
sort
of
tutorials
on
how
to
use
simpe.
So
we've
got
a
few
examples
that
look
at
forward
modelling.
So
that's
in
the
e/m
fundamentals,
we've
got
two,
and
these
are
ones
we
put
together
last
week
on
inverting
field
data,
so
we've
got
time
domain
and
frequency
domain
we'll
go
over
the
time
domain.
C
One
there's
also
a
tutorial
that
we
publish
in
the
leading
edge-
and
this
is
a
good
one-
for
just
getting
a
handle
on
some
of
the
fundamentals
of
inversion.
We
also
walk
through
in
a
lot
of
detail
about
some
of
the
parameters,
and
things
like
that
like
what
beta
is,
what
that
trade-off
parameter
in
the
inversion
is,
and
so
that
might
be
one
like
these
might
be
a
series
of
notebooks
that
are
worth
checking
out
afterwards.
C
A
C
C
So
let's
start
here,
I
guess
one
other
question
I
wanted
to
ask
is
how
familiar
are
people
with
Python?
Have
you
used
Python
before
I.
C
C
So
this
is
a
package
that
we've
written
it's
part
of
the
sim
page
ecosystem
and
this
actually
wraps
solvers
so
that
you
can
interact
with
them
like
what
we
can
do.
I'm.
Just
writing.
This
is
pseudocode.
This
isn't
going
to
run,
but
if
we
have
a
in
equals
solver
eight,
what
that
lets
you
do
is
then
I
can
do
a
n
times.
B
equals
x,
and
so
this
actually
just
factors
the
matrix.
It
doesn't
compute
the
inverse
it's
smarter
than
that.
C
A
C
G
C
G
C
All
right,
so
the
next
cell,
all
I'm
doing
here,
is
increasing
the
font
size
on
the
plots
so
that
they
look
nicer
okay.
So
then
what
we're
gonna
do
is
actually
look
at
the
contents
of
the
data
directory.
So
here
this
OS
dot
path,
thought
SEP,
sorry
for
that,
but
that
is
just
it
makes
this
both
windows
friendly
and
Mac
friendly.
So
all
this
does
like
on
my
Mac
is
computes.
Actually
I
can
show
you.
C
It
just
assembles
the
path
with
the
correct
path
separator
in
there.
So
it's
nothing
fancy,
but
that
is
where
our
data
are.
That's
where
the
data
file
is
stored
and
so
I'm
just
gonna
list
what
we
have
in
there.
So
there's
a
few
things
that
I've
stored
in
there
we've
got
a
path
file
that
defines
the
river
path.
C
We
have
a
couple
header
files,
you've
got
a
readme,
we've
got
some
data
files,
and
so
what
I'm
gonna
do
here
is
we're
just
gonna
look
at
the
readme
just
to
get
a
sense
of
what's
in
there
and
what
are
the
main
files
to
look
at
so
here
got
some
information
on
where
the
data
came
from
when
they
were
collected
and
then
importantly,
the
contents.
So
here
we've
got
the
header
file
for
the
resolve
data.
C
C
What
we
can
do
is
you
can
then,
each
of
the
fields
that
we
have
in
the
data
file
so
see.
We've
got
line
as
one
column
header.
We
can
access
all
of
the
values
just
by
doing
skies,
name
dot
line.
So
here
what
I'm
gonna
do
is
pull
out
all
the
unique
line
numbers
so
that
we
can
just
look
at
where
what
were
our
flight
paths
for
the
airborne
iam
data
and
then
we're
also
going
to
load
the
river
path.
C
Just
so,
we've
got
something
to
orient
ourselves
and
then
I
defined
some
plotting
code
just
so
that
we
can
actually
look
at
then,
where
our
flight
lines
are
so
you
can
see.
We
mostly
are
flying
straight
lines
along
here,
but
then
we've
got
a
couple
tile
inés.
This
one
I
think
was
potentially
overlapping
with
where
resolve
flu
or
something
like
that,
and
then
we've
got
a
few
lines
along
the
river
path.
C
So
one
of
the
things
that
we
want
to
do
like
if
we
were
looking
at
inverting
this
entire
data
set,
we
probably
only
want
to
invert
the
straight
lines
and
not
include
these.
These
different
paths,
and
so
what
I
wanted
to
do
is
actually
find
which
indices
those
were,
and
we
can
just
extract
them
from
the
data
set
so
that
we're
not
using
them,
and
so
you
might
want
to
do
this
if
we're
inverting
in
1d
or
3d.
C
F
C
So
what
happen
is
if
you
end
up
with
two
data
points
that
are
in
very
similar
locations
and
if
there's
errors
between
them,
then
the
inversion
has
to
like
fight
between
which
of
those
two
data
points
it
trusts
mark,
and
so
in
this
case,
when
they
fly
the
straight
lines,
it's
usually
all
in
sequence,
so
the
data
are
more
consistent
with
each
other.
Ideally,
you
know
all
of
the
data
should
agree,
but
they
should
be
redundant
data
points,
so
they
shouldn't
be
adding
any
new
information.
Oh
so.
A
C
All
right,
so
the
next
thing
that
I'm
going
to
do
is
to
just
pull
out
some
useful
pieces
of
information
for
this
now
pared-down
data
set.
So
here
we're
just
gonna
look
at
so
it's
kite,
M,
there's
both
Zed
oriented
so
vertical
coils
and
horizontal
coils,
we're
just
gonna.
Look
at
the
the
vertical
data.
So
here
the
way
I
knew
to
look
for.
Zed
is
I.
Looked
at
the
the
header,
titles
and
so
X
channel
seven
is
the
X
component,
whereas
Zed
to
channel
27
is
Zed
component
at
time,
channel
27.
C
So
all
we
want
is
the
Zed
to
compose
our
dataset,
and
then
we
want,
of
course,
the
easting/northing
and
an
elevation
and
the
way
I
knew
to
look
at
the
laser
altimeter
was
by
going
back
and
actually
reading
the
the
header
file
on
that
was
included
with
the
original
data.
So
now
we
thought
those
we've
got.
Our
data
set
assembled
okay,
so
now
we're
starting
to
get
closer
to
the
physics.
C
So
we
know
that
we've
got
you
know
the
the
headers
were
listed
as
channel
7
to
channel
30,
but
those
actually
mapped
to
specific
times
and
so
I.
Just
copy
and
pasted
these
values
from
the
header
file,
so
I
can
show
you
that
I'm
just
gonna
pull
it
up
I'm.
So
here,
if
we
look
at
the
sky
temps
sorry,
the
saitm
bootprint
on
header
file,
you
can
see
there's
a
system
description.
All
of
that
sort
of
stuff.
C
We're
gonna
end
up
using
these
values
later,
but
then
we
also
have
where
each
of
the
channels
are
so
here
we're
using
the
high
moment
data.
So
we've
got
all
the
channel
numbers
and
then
the
windows
Center
at
the
windows
start
in
the
window.
Width,
so
I've
just
used
the
the
center
values
here.
So
that's
all
this
is
and
then
now
that
we've
got
our
time
channels
and
our
data
set
paired
down.
We
can
actually
then
go
ahead
and
plot
the
data
at
each
time
channel.
C
So
the
first
thing
that
we
need
in
order
to
think
about
inverting
the
data
is,
we
need
to
be
able
to
forward
model
those
data,
and
so
what
we're
gonna
do
here
is
we're
gonna
use
a
cylindrical
asymmetric
mesh
because
we
have
a
vertical
coil
and
we're
using
a
1d
earth.
So
that's
a
cylindrically
symmetric
setup
and
it
runs
it's
a
faster
forward
simulation
than
if
we
were
to
run
on
a
full,
3d
mesh
and
so
in
order
to
set
that
up.
C
We
want
to
make
sure-
and
this
is
important
for
1d,
yours
or
3d-
is
that
we
want
to
make
sure
that
our
mesh
extends
well
beyond
the
diffusion
distance,
so
that
the
feet
so
that
we
satisfy
our
boundary
conditions,
because
we've
assumed
that
the
fields
have
decayed
by
the
time
they
hit
the
boundaries.
So
here,
if
we
look
at,
is
tomato
conductivity
of
10
or
sorry,
a
conductivity
of
0.1
Siemens
per
meter,
and
just
looking
at
our
latest
time
channel,
we
want
to
be
beyond
well
beyond
400
meters
for
this
mesh.
C
So
you
probably
want
to
double
that,
and
that
gives
you
a
good
idea
of
where
you
want
to
pad
out
to
so
now.
We're
gonna
assemble
the
mesh.
Just
please,
please
do
to
top
me
if
I'm
going
too
fast,
so
here
what
we're
gonna
do.
Is
we
define
our
core
cell
size?
So
that's
gonna
be
one
meter.
We
have
no.
D
B
C
C
So
here,
if
you
want
to
do
a
1b
inversion,
this
is
actually
where
you
should
be
looking:
okay,
I'm,
just
gonna
post
that
here
sorry
for
the
infinite
loop,
it's
about
where
you
should
be
looking.
If
you
want
to
do
larger
scale,
1d
inversions,
why
we're
using
the
cylindrical
mesh
in
this
case?
It's
because
this
is
very
close
to
what
you
would
do
in
a
3d
inversion.
So
in
a
3d
inversion,
we're
gonna
solve
it
on
a
finite
volume
style
mesh.
C
You
flipping
notes
pages
or
something
like
this.
Sorry
I
was
just
getting
a
lot
of
noise
on
the
on
the
hangout
I,
don't
know
who
is
not
muted,
oh
maybe.
C
E
C
Yeah,
so
here
these
each
of
these
parameters,
this
is
just
sort
of
common
shorthand
that
we
use,
but
it's
nothing
specific
to
synthetic.
So
CS
is
cell
size
n,
see
X
is
the
number
of
core
cells
in
the
X
direction,
so
we
have
10
of
those
and
then
ncz
is
the
number
of
core
cells
in
these
n
directions.
We
also
have
10
of
those
and
then
we've
got
20
padding
cells.
C
But
one
thing
that
we've
done
in
sempai
is
tried
to
make
it
easy
for
you
to
define
these
tensor
products,
so
this
is.
This
is
a
tensor
product
mesh
because
we
can
define
each
dimension
as
a
vector
of
cell
widths
and
that's
enough
to
define
the
entire
mesh.
So
we
have
au.
We
have
utilities
under
the
hood
that
will
convert
this
list,
so
this
is
a
list
of
tuples
in
Python
speak.
C
So
this
is
a
tuple,
and
so
here
we've
got
our
cell
size
and
our
number
of
cells
in
the
x-direction
cell
size
number
of
padding
cells
and
then
the
expansion
factor,
so
they're
gonna
expand
by
a
factor
of
1.3
and
then
what's
in
peg
does,
is
it's
actually
going
to
translate
this
list
into
then
a
vector
of
cell
widths?
So
this
is
just
a
convenience.
We
could,
alternatively,
actually
go
and
define
like.
C
So
then,
here
we
have
our
we're:
gonna
assemble
the
z-direction,
so
in
this
case
we
used
a
logarithmic
ly
varying
mesh,
so
the
the
cells
are
our
logarithmic
ly
expanding
in
the
vertical
direction,
and
this
is
sort
of
consistent
with
how
fields
decay.
And
so,
if
you
look
at
like
then
magneto
telluric
tutorial,
we
do
the
same
thing
there,
but
you
could
also
just
define
them
uniformly
and
that's
something
you
can
play
around
with
and
see
how
that
impacts,
both
the
ford
simulation
and
the
inversion
afterwards.
C
So
then,
to
set
up
the
mesh.
What
we
do
is
we
were
calling
the
mesh
class
and
we
set
up
a
cylindrical
mesh,
and
then
we
give
a
list
of
the
cell
weights
in
each
direction.
So
we've
got
HX,
which
we
assembled
here.
H
said,
which
we
assembled
here
and
then
the
one
in
the
cylindrical
asymmetric
mesh
just
indicates
hey.
We
want
two
cylindrical
asymmetric
mesh.
You
could
also
do
two
pi,
because
that
is
the
the
adds,
a
mutual
discord
causation.
So
you
know
discretizing
a
circle
by
two
pi.
C
You
get
back
the
whole
circle,
but
here
we've
used
one
as
a
shorthand.
Just
to
say,
I
want
a
cylindrical
asymmetric
mesh
and
then
the
zero
zero
see
what
this
is.
This
is
the
origin
of
the
mesh,
so
all
that
we've
said
is
we
want
X
to
start
from
zero
same
thing
with
Y,
which
doesn't
matter
in
the
case
of
a
cylindrical
asymmetric
mesh,
and
then
we
want
our
Z
to
be
centered.
So
here
you
can
see
the
mesh
is
centered
above
zero
in
the
vertical
direction.
I.
C
It
and
then
the
last
thing
that
we
do
is
we
know
that
we
want
our
active
cells
to
be
the
cells
below
the
earth's
surface.
So
when
we're
inverting,
we
don't
want
to
invert
for
air
cells.
So
this
is
just
keeping
track
of
our
active
indices.
There,
no
I,
guess
we
defined
that
twice
it
defined
anything
in
here
I
mean
this
makes
more
sense
here.
C
So
now
that
we've
got
a
mesh,
we're
gonna
define
a
model,
and
we
use
this
as
our
starting
model
and
also
just
a
forward
model
to
sort
of
sanity
check
that
we've
set
up
the
forward
simulation
correctly
with
respect
to
our
data.
So
here
we're
gonna,
set
the
connectivity
of
the
air
cells
to
be
ten
to
the
negative
eight
and
we're
gonna
do
just
a
half
space
Earth's,
where
we've
got
10
to
negative
one
Siemens
per
meter.
C
Our
active
cells
are
all
below
the
Earth
and
then
we're
gonna
also
define
we
want
to
invert
in
log
conductivity.
There's
a
couple
reasons
for
this.
First
of
all,
it
lets
us
have
the
conductivity
buried
by
orders
of
magnitude
fairly
easily.
It
also
makes
sure
that
the
conductivity
always
stays
positive,
because
if
you
take
the
exponential
of
any
positive
or
negative
number,
you
get,
you
get
a
positive
number
back.
C
So
the
way
that
we
keep
track
of
all
of
this
in
simpang
is
through
mappings.
So
here
what
we
do
is
we
assemble.
There's
gonna
be
three
maps,
so
the
first
thing
that
we
do
this
active
map
here
we've
actually
got
just
a
1d,
a
1d
layered
earth.
We
have
our
active
cells
are
below
the
subsurface,
and
so
all
that
the
active
map
does
is
includes
the
air
cells,
so
it
adds
the
air
cells
back,
but
that's
all
defined
in
1d.
C
We
also
need
to
then
map
our
1d
model
to
the
full
mesh,
and
so
in
that
case
we
use
a
surgical
1d
map.
So
it's
gonna
take
the
the
1d
vector
that
we
have
defined
vertically
and
it's
gonna
put
it
horizontally
throughout
the
whole
throughout
the
whole
mesh
and
then
finally,
we
take
the
the
exponential
so
that
we're
now
in
true
conductivity
space.
So
the
point
of
the
mapping
is
to
take
whatever
set
of
parameters.
C
E
G
C
So
right
now
they
are,
if
you
wanted,
you
could
define
another
mapping
in
between
that
performs
an
interpolation
if
you
wanted
to
have
different
meshes
only,
but
just
to
use
to
use
this,
as
stated,
it
always
has
to
be
that
the
number
of
parameters
like
this
is
basically
a
multiplication.
So
let
me
run
this
and
I'm
going
to
show
you
some
things.
So
if
we
look
at
the.
C
C
A
C
D
C
H
H
A
C
Is
basically
exactly
what
we're
doing
in
this
case,
so
we
start
with
the
model,
that's
defined
as
law
conductivity
just
below
the
sub
surface.
So
this
is
the
surface
right
here,
then
the
inject
active
cells
adds
the
air
cells,
but
that
is
now
only
defined
in
one
dimension,
because
we're
forward
modeling
on
the
cylindrical
asymmetric
mesh.
We
also
then
needed
out
in
the
x-direction.
C
G
C
H
C
A
G
So
the
exponential
map
is
okay.
I
was
just
saying
like
going
from
like
a
1d
mesh
to
if
I
create
2d
mesh.
Oh.
A
C
Yeah
good
question
so
we're
just
inverting
for
the
subsurface,
but
in
this
case
we
have
to
be
able
to
forward
simulate
the
data.
So
the
purpose
of
the
mapping
is
to
go
from
the
set
of
parameters
that
we
want
to
invert
for
to
what
we
need
in
the
forward
simulation.
And
so,
if
we're
simulating
in
3d,
and
so
we
discretized
the
world,
then
we
have
to
include
the
air
cells
when
we
model
electromagnetics,
because
the
I
mean
you,
you
still
have
eeehm
responses
in
the
air.
In
fact,
in
this
case
they're
being
collected.
A
A
C
And
so
there's
a
couple
other
things
that
like
I
realize
this
is
an
abstract
concept,
but
once
you
sort
of
get
your
head
around
it
a
little
bit
more,
it's
actually
pretty
powerful,
and
so,
if
you
wanted
to
do
a
parametric
model
or
anything
like
that,
this
whole
mapping
framework
lets
you
do
those
kinds
of
things
and
so
yeah.
You
can
basically
take
any
sort
of
set
of
numbers,
and
as
long
as
you
can
translate
that
to
fort
simulation
mesh,
then
then,
then
we
can
invert
for
those
parameters.
C
The
other
thing
that
the
mapping
do
is
now
keep
track
of
the
derivatives,
and
so
this
is
important
when
we
actually
are
performing
the
inversion
and
want
to
try
and
make
model
updates,
because
we
use
a
gradient
based
inversion.
So
we
need
derivatives
at
each
of
these
steps,
and
so
this
just
keeps
track
of
all
of
those.
C
So
if
we
look
at
the
length
of
M
naught
it's
39
right,
and
that
was
the
same
as
our
number
of
active
cells
and
then
in
order
to
plot
it.
What
I
do
is
actually
we're.
Gonna
take
we're
gonna
plot
it
in
log
space,
just
cuz,
that's
convenient,
but
to
translate
our
model
to
electrical
conductivity.
All
you
have
to
do
is
multiply
by
the
mapping,
so
we
think
of
it
like
a
matrix
operator,
and
so
in
that
case
this
is
what
our
starting
model
looks
like.
C
C
So
for
the
time
domain
we
actually
have
a
source
waveform
and
then
this
is
again
defined
in
that
header
file.
So
if
I
pull
up
our
header
file,
we
have
the
transmitter
waveform
and
so
we're
looking
at
the
high
moment
data,
and
so
we've
used
the
25
Hertz
high
moment
current
waveform.
So
we've
got
our
our
time
channels,
so
they've
started
at
minus
10,
milliseconds,
so
they're,
basically
treating
like
off
time
or
like
their
their
peak
time.
Sorry
is
at
0
milliseconds
and
then
they
shut
it
off.
So
you
can
sort
of
see
that
right.
C
C
C
We
could
do
a
linear
approximation
of
it,
or
in
this
case
the
vtm
waveform
shape
is
very
very
similar
and
we
have
an
analytic
solution
for
that
and
then
so.
We've
just
gone
in
and
basically
fit
just
by
hand
these
values
to
the
wave
one,
and
so
we
can
look
at
we're
gonna
plot
that
I'll
show
you
what
each
is.
Let
me
just
give
you
labels
so
here.
This
is
then.
A
C
C
I
C
C
So
what
you
can
do
is,
if
you
want
you,
can
copy
this
waveform
over
and
I'm
going
to
show
you
where
in
the
survey
it
needs
to
be
added
Oh.
I
C
Okay,
so
we've
defined
our
waveform
we've
got
our
source
waveform.
In
this
case
it
needs
to
be
the
source.
Waveform
object
in
simp
ik.
So
in
this
case,
if
you
go
under
the
time,
duranium
source
namespace
there's
a
few
different
waveforms
that
you
can
look
at
in
that
example
that
you
just
showed
paying
me
by
default.
We
always
use
a
step
off
waveform.
So
if
you
don't
specify
a
waveform,
we
assume
that
it
is
just
the
current
was
on
and
then
a
time
zero.
It
shuts
off.
C
C
The
other
thing
we
need
is
the
system
height
and
in
this
case
our
receiver
is
at
the
same
height
because
they
are
fixed
on
the
same
system,
so
that's
relevant
for
both
the
data
that
we're
measuring,
in
this
case
our
DB
DT
data.
So
there's
a
few
different
receiver
types
that
you
can
look
at
if
you're.
Looking
at
a
ground-based
survey,
you
might
look
at
electric
fields,
for
example,
but
here
we're
just
looking
at
point
measurements
of
DB
DT.
C
The
first
field
here
is
the
location
of
the
receiver,
so
we
put
it
for
sky
10,
the
the
receivers
at
the
back
end
of
the
loop,
so
it's
basically
sitting
on
the
radius
of
the
loop,
so
we
offset
it
by
that
amount
in
the
X
direction.
There's
no
offset
in
the
azimuthal
direction
right
because
we're
on
the
cylindrical
asymmetric
that
doesn't
matter
and
then
in
the
Z
direction.
It's
at
the
same
height
as
this
system
height,
the
orientation
of
the
loop
is
in
the
Z
direction.
C
C
So
if
you
want,
you
can
remove
that
and
try
and
fit
the
data,
see
what
you
can
do,
but
in
this
case
we
decided
to
cut
those
ones
out
and
then
we're
gonna
shift
them
by
that
source
where,
where
the
source
waveform
starts
right,
because
we
start
measuring
after
it's
been
shut
off,
so
all
of
our
measurements
should
be
with
respect
to
how
we
shifted
our
wave
1.
Does
that
make
sense
what
this
guy
is.
H
Claudia
I
think,
then
you
need
to
know
what
kind
of
transfer
function
they
have
used.
So
there's
a
kind
of
like
a
semi
analytic
solution
that
you
can
transfer
your
voltage
to
a
pair
of
Muses
tivity.
So
you
need
to
ask
that
provider
of
the
data
and
how
they
actually
transfer
their
parent.
A
parent
resistive
like
that
from
voltages
to
a
parent
stivity
what
they
have
measured
supposed
to
be
a
voltage,
not
a
ton
père
resistivity.
D
C
B
In
her
daughter,
she
has
electrical
resistance,
which
is
volts
per
amperes
and
per
se,
so
I
say
so,
and
you
also
have
to
me
meter
ohm
meter
resistivity,
but
we
also
have
electrical
resistance.
H
A
C
Yes,
you
need
to
find
out
how
they
normalized
it
think,
that's
something
that
they
should
be
able
to
provide
you
with.
H
H
C
Okay
yeah,
so
here
you
can
actually
look
and
see
what
the
different
types
of
receivers
that
we
have
are.
So
all
I
did
there.
We
did
got
and
then
hit
tap
so
B
DB,
DT,
v
HJ,
so
those
are
always
going
to
be
in
SI
units
so
that
that's
what
we
work
with
in
sin
peg
for
waveforms
there's
a
couple
of
examples
in
the
documentation
we're
working
on
improving
the
docks
so
like
you
can
expect
some
improvements
in
the
coming
months.
But,
as
is
right
now,
there's
still
some
examples
that
you
can
use.
C
So
if
you
look
at
time
domain,
electromagnetics,
here's
just
a
small
gallery
of
a
few
different
types
of
waveforms
that
we
have,
and
so
in
a
lot
of
cases
you
can
map
whatever
waveform
you're
working
with
to
something
that's
similar
to
one
of
these.
If
not,
we
can
help.
You
define
the
custom
waveform.
H
G
G
C
So
we
can
go
into
this
in
more
detail,
but
basically
the
thing
like
if
you
wanted
to
find
your
own
custom
waveform.
All
that
we
need
is
some
function
that
given
a
time,
gives
us
a
value
back
for
that
waveform.
And
so,
if
you
want
to
compute
that,
like
by
doing
interpolation
between
discrete
points
that
you
are
provided
in
a
waveform
file,
you
can
do
that.
C
G
C
C
But
here
because
we're
just
doing
one
one
sounding
we've
got
one
source
location,
and
so
we
have
one
source
in
our
list.
So
here
we're
going
to
use
a
circular
loop
source.
The
first
thing
that
all
of
our
source
sources
take
is
a
receiver
list
I'm.
So
in
this
case
we
defined
our
db/dt
Zed
receiver
at
this
location.
So
we
passed
that
in
as
a
list,
so
we
could
have
actually,
if
you're
doing
a
ground-based
survey,
for
example,
you
might
have
one
source
and
multiple
receivers,
so
we
could
have
another
receiver
here.
C
I'm,
that's
no
problem!
You
also
don't
have
to
define
receivers.
So
if
you
want
to
just
sort
of
look
at
the
physics
everywhere
on
the
mesh,
you
can
do
pass
this
as
an
empty
list.
But
if
we're
going
to
do
an
inversion,
you
need
to
have
receivers
they're,
the
location
of
our
source,
so
it's
centered
at
the
origin
at
the
same
height
as
the
system
height.
So
the
elevation
at
our
receiver
index
the
radius
of
the
loop.
C
We
defined
that
here
it's
oriented
in
the
z
direction
and
then
this
is
where
the
wave
form
is
passed
so
pain.
Coming
back
to
your
question,
if,
in
the
example
that
you
were
playing
that
you're
exploring,
if
you
want
to
change
the
wave
form,
when
you
define
your
transmitter,
you
can
provide
a
different
wave
form
there.
Does
that
make
sense?
Okay,.
C
So
we
define
our
wave
form
and
then
we
can
also
define
a
current.
So
in
this
case
the
data
that
we
we
were
provided
are
normalized
by
the
loop
area
on
so
again.
I
know
that
by
coming
back
to
the
header
file
and
they've,
they
told
us
that
I'd
forget
where,
but
it
is
in
here,
and
so
in
this
case
we
want
the
moment
the
moment
to
be
one
of
our
loop,
so
I
I
normalize,
the
current
by
the
area.
Does
that
make
sense?
Oh.
C
C
C
We
look
at
the
difference
between
the
off
time
and
the
peak
time
so
there
and
define
five
time
steps
through
there,
and
then
we
have
a
series
of
time
steps
going
from.
You
know,
five
of
them
that
are
10
to
the
negative
5
5
of
them
that
are
5
times
7
a
negative
5
10
of
them
1
times
10
a
4
and
15
that
are
5
times
10
to
the
negative
4.
C
So
afterwards,
I
encourage
you
to
go
in
and
play
with
these
see
how
that
changes,
the
the
fourth
simulation-
and
here
you
can
actually
see
so
I've
just
plotted.
So
we
have
our
wave
front
like
we
did
before
and
then
all
I
did
was
plot
the
times
where
we're
gonna
evaluate
the
problem
with
these
hash
marks
here.
So
you
can
see,
we've
got
five
time
steps
before
we
shut
off,
we
very
finely
discretized
immediately
afterwards,
and
then
we
expand
a
bit
as
we
go
later.
C
C
I
C
Ok,
so
so
what
so,
the
the
computation
is
running,
but
what
you
need
to
be
careful
with
when
you
run
a
time
domain
simulation.
Is
that
you
don't
course
in
too
quickly,
and
so
in
this
case,
when
you
jump
by
an
order
of
magnitude
like
we
lose
accuracy
in
the
simulation,
when
there
are
big
jumps
in
the
time
mesh
I'm.
So.
A
C
I
C
I
C
So
can
everyone
see
my
screen
again
hurry
back
on
line?
Okay,
so
I
want
to
come
back
to
this
cell
again
because
there's
a
lot
of
stuff
happening
in
here,
so
we
defined
our
time.
Stepping
and
now
we're
gonna
set
up
a
problem,
and
so
this
is
a
language
that
I
think
we're
gonna.
Eventually,
change
in
simpe
cause
it's
a
little
confusing,
but
what
the
problem
is
right
now
you
can
think
of
it
as
the
physics
engine.
C
So
it's
what
it's
all
the
machinery
to
actually
solve
the
partial
differential
equation,
and
so
here
we've
got
a
time
domain.
Eeehm
problem,
it's
gonna
be
solved.
It
is
a
3d.
It
is
a
3d
problem,
because,
even
though
this
the
mesh
is
cylindrically
symmetric,
we
still
have
everything
defined.
In
three-dimensional
space,
we
can
still
define
what
an
x
and
a
y
component
are.
C
So
it
is
still
a
3d
problem
and
then,
in
this
case
we're
using
there's
four
things
that
you
can
solve
for
when
we
look
at
Maxwell's
equations.
In
this
case,
we're
going
to
use
we're
going
to
solve
for
the
electric
field
and
then
from
that
you
can
compute
DB
DT,
be
any
any
other
fields
that
are
derived
from
that.
There's
some
more
details
on
like
why
you
would
choose
each
one
in
the
in
the
paper
that
we
have.
So
if
you
don't
have
this,
the
e/m
paper
that
sort
of
outlines
how
simple
em
works.
C
C
Okay,
I'll
just
keep
moving
on,
but
we
can
follow
up
if
people
are
curious
afterwards.
So
when
we
define
the
problem,
we
need
to
give
it
a
mesh.
So
that's
gonna
be
how
it
figures
out
what
all
of
the
differential
operators
are.
So
when
we
have
Maxwell's
equations,
we
know
we
need
to
compute
a
curl
on
the
mesh,
and
so
that's
the
mesh
object
knows
how
to
do
that.
C
Then
we
provide
the
time
steps,
so
that's
gonna
be
where
the
problem
is
evaluated.
In
this
case,
we
are
mapping
whose
defined
from
our
set
of
parameters
to
electrical
conductivity
Sigma.
So
we
define
the
Sigma
map
as
the
mapping
that
we
constructed.
If,
instead,
you
wanted
to
work
in
resistivity,
you
could
provide
a
row
map
and
then
you
would
be
providing
a
set
of
mappings
or
like
a
mapping,
object
that
takes
you
from
your
set
of
parameters
to
then
resistivity
on
the
mesh.
G
C
A
G
E
C
Then
so,
deep
on
this
is
then,
where
the
the
solver,
when
you
were
asking
about
that
earlier,
this
is
where
the
solver
comes
in.
So
we
tell
the
problem
which
solver
we
want
it
to
use.
So
by
default
it
uses
an
Lu
solver
that
comes
with
side
PI,
if
you're
solving
any
remotely
like
moderately-sized
e/m
problem,
that's
going
to
be
very
painful,
it'll,
be
painfully
slow,
so,
like
highly
recommend
that
you
use
the
the
paradiso
solver
okay,
that
gives
us
the
the
problem.
Then
we
also
have
to
create.
This
survey
object.
C
Why
I'm
sort
of
hesitating
here
is
that
we
are
going
to
simplify
these
steps
at
some
point,
so
we'll
explain
that
when
it
when
it
comes
out,
but
for
now
what
you
need
to
do
is
given
the
source
list,
we
create
a
survey,
and
the
survey
then
knows
how
to
create
data
when
it's
paired
with
the
problem.
So
that's
why
we
have
to.
C
We
have
to
communicate
basically
all
of
the
information
from
the
survey
about
where
the
source
is,
what
kind
of
source
it
is
to
the
problem,
so
that
we
can
actually
simulate
the
physics
and
then,
once
we've
simulated,
the
physics
everywhere
on
the
mesh.
We
then
ask
the
survey:
okay,
where
should
I
evaluate
my
fields
to
give
you
data?
So
that's
sort
of
the
back
and
forth
that
happens
between
those
right
now.
C
So
I
showed
you
this
before,
but
this
is
just
plotting
our
time
descritization
just
to
get
a
sense
of
where
we
should
be
discretized
and,
finally
right.
We
want
to
make
sure
that
we
do
a
good
job
with
these
early
times
and
then
we
can
expand
as
we
go
later
so
Peng
when
you're
looking
at
designing
different
discourses
different
time
discretization,
it's
worth
sort
of
plotting
this
out
and
seeing
what
your
time
discretization
looks
like
and
then
also
if
you
run
a
forward
simulation
and
you
see
something
that
looks
fishy.
C
Okay,
so
now
we've
got
all
of
our
machinery
that
we
need
to
perform
a
forward
simulation.
So
what
we're
gonna
do
is
assign
specify
what
are
our
observed.
Data
are
and
assign
some
uncertainties.
Those
will
be
used
in
the
inversion
and
then
we're
gonna
look
at
from
our
half
space
model.
What
do
Ford
simulated
data
look
like,
so
we
use
a
standard
deviation
of
five
percent.
That's
pretty
common!
If
you
don't
know
what
to
do.
C
That's
not
a
bad
place
to
start,
and
then
here
we
look
at
you
know
our
decays
are
going
to
found
to
about
ten
minute
of
twelve
we're
ignoring
those
last
three
data
points.
So,
let's,
let's
choose
10
than
the
negative
12
is
a
floor.
These
are
again
parameters
that
I
would
encourage
you
afterwards
to
come
and
play
with
and
see
how
it
impacts
the
inversion.
So
here
we
take
our
data,
so
our
observed
data
are
gonna,
be
the
sky
temp
data
at
the
receiver
index,
and
then
we
ignore
those
last
three
time
channels.
C
A
C
A
A
H
C
Good
to
know
okay,
so
now
we
brought
our
predictive
data
and
we
know
our
observed
data
so
just
plot
those
up,
and
so
in
this
case
the
this
forward
simulation
isn't
actually
strictly
necessary
in
order
to
run
the
inversion.
But
it's
a
really
good
idea
so
that
you
can
sanity
check
your
entire
setup.
So,
for
example,
the
first
time
I
set
up
this
notebook
I
forgot
to
normalize
the
current
by
the
area
and
the
difference
between
my
predicted
and
my
observed.
Data
was
three
orders
of
magnitude.
C
So
that's
a
you
know
they
shouldn't
be
that
far
away
from
each
other.
So
then
you
can
go
back
check
your
forward
simulation
set
up
and
just
make
sure
that
you
know
everything
is,
is
reasonable
and
we're
in
the
right
order
of
magnitude.
This
also
shows
us
that
you
know
our
forward
or
half
space
is
not
the
best
model
and
we
clearly
have
some
progress
that
can
be
made
by
inverting
these
data.
C
Question
so
in
this
case,
when
we're
looking
at
so
sky,
10
da
de
you
will
be
looking
at
like
the
positive
is
gonna,
be
whatever
is
in
the
same
direction
as
the
the
primary
field.
Right,
whereas
in
peg
is
always
looking
at
like
Zed,
is
always
positive
up.
G
C
A
H
More
like
a
look
at
what
they're
actually
measuring
is
a
voltage
right.
So
if
you,
if
you
actually
like
a
kind
of
keep
track
of
what
it's
a
sign
of,
the
voltage,
is
a
negative
DB
DT.
So
you
know
what
I
mean
like
if
you
integrate
that
curl
of
e,
that's
like
a
line
integral
of
the
loop
and
then
you
got
the
negative
sign
so
technically.
E
H
C
H
G
G
A
C
So-
and
that's
also
a
good
point
here,
so
that
when
we
actually
set
so
now,
we're
gonna
start
looking
into
the
inversion
and
setting
up
our
inversion.
So
when
we
set
our
observed
data,
we
want
to
make
sure
that
the
signs
are
consistent
right.
So
we
know
that
here,
I
actually
had
to
flip
the
sign
in
order
to
get
what
we
wanted.
So,
when
I
set
the
observed
data
on
my
survey,
I'm
going
to
flip
the
sign
here
so
that
we
don't
have
to
mess
with
anything
on
the
receiver
side
of
things.
G
So
so
inside
the
code
in
order
to
get
db/dt
basically
just
take
integration
or
longer
loop
in.
C
C
C
So
the
next
thing
that
we
do
is
we're
going
to
set
up
a
regularization,
so
here
we
need
to
actually
create
a
different
mesh,
because
our
our
model
parameters
don't
actually
live
on.
The
full
cylindrical
asymmetric
match
right,
so
we
want
to
regularize
on
a
1d
mesh.
So
here
all
we've
done
is
create
a
1d
mesh
that
is
only
for
the
active
cells.
So
let
me
just
comment
this
out
and
I'll
show
you
what
that
looks
like.
C
So
we
pass
that
then
to
a
regularization
object.
Here
we
use
the
T
knopf
regularization,
so
we
give
it
a
mesh.
In
this
case
we
don't
actually
need
this
mapping.
I'm
gonna
delete
that,
because
it's
not
necessary
but
I'll
tell
you
what
you
could
use
it
for
is,
if
you
needed
to
like
transform
your
model
in
any
way
to
get
it
on
to
the
regularization
mesh
or
change
where
your
regular
izing,
you
could
use
it
there.
You
could
use
a
mapping
to
do
that,
but
we
don't.
We
don't
need
that
in
this
case,.
C
Not
in
this
case,
because
the
regularization
is
on
the
set
of
parameters
that
were
inverting
for,
and
so
in
that
case
they
only
exist
in
1d
right
because
we're
only
inverting
for
conduct
or
log
conductivity
below
the
sub
surface.
So
we
need
some
sort
of
mesh
that
we
can
regularize
on
regularize
those
values
on
okay,.
E
C
D
C
C
C
So
the
t-top
regularization,
the
way
we
define
that
is
we're
gonna
work
with
a
smallness
term,
which
just
looks
at
the
difference
between
our
model
and
our
reference
model.
So
in
this
case
we
use
a
reference
model,
that's
the
same
as
that
hat
space
starting
model
and
then
alpha
X,
because
it's
only
in
1d,
we
always
treat
X
as
the
first
dimension
Y
as
the
second
dimension
and
Zed
is
the
third
dimension.
C
So
in
this
case
we
only
have
two
components
to
the
regularization,
because
it's
1d,
so
we
have
the
smallness,
and
then
we
have
one
derivative
for
smoothness.
So
we're
then
just
looking
at
okay.
If
we
compare
the
value
near
the
surface
to
the
next
cell
over
how
far
apart
are
the
those
values-
and
we
want
to
minimize
that
derivative,
so
we
penalize
it.
The.
C
C
C
C
Okay,
so
there's
there's
a
lot
of
details
here
and
the
MT
tutorial
does
a
good
job
of
explaining
what
each
of
these
parameters
are.
We
can
copy
some
of
that
over
and
actually
one
of
the
things
that
I
would
really
appreciate
after
this
tutorial
is,
if
you
do
come
in
and
work
with
this
notebook,
and
you
make
notes
and
explanations
of
what's
going
on,
if
you
would
be
willing
to
contribute
that
back
so
that
you
know,
other
people
can
benefit
from
what
you've
learned
in
what
you've
documented.
C
That
would
be
fantastic,
so
we
can
chat
about
that
after
ok,
so
we
defined
our
data
misfit
and
our
regularization,
and
so
now
we're
going
to
define
some
optimization
machinery
that
we're
going
to
use
to
solve
the
inverse
problem.
So
in
this
case
we're
going
to
use
in
exact
gauss
newton
and
we
specify
the
maximum
number
of
iterations
to
be
ten
here.
C
The
that's
the
default
anyways,
but
the
line
search
shortened
with
means
is,
if
you
try
and
take
a
step,
but
the
inversion
finds
that
the
value
of
the
objective
function
actually
increases
rather
than
decreases,
it's
gonna
say.
Okay,
let
me
take
a
step,
that's
half
that
length
and
we'll
try
that
again
and
then
it
continues
taking
a
step,
that's
half
the
length
until
we
get
to
something
that
actually
does
decrease
the
value
of
the
objective
function,
the
OP
dot.
C
Remember
what
this
is
doing
is
it's
gonna
remember
this
is
terrible
notation,
but
it's
going
to
remember
the
value
of
the
model
at
every
iteration.
So
if
we
wanted
to
go
back
and
look
through
the
different
models,
we
could
do
that
afterwards.
Otherwise
it
will
forget
them,
and
the
only
thing
that
you
get
out
is
the
end
model.
C
Okay,
so
then
we
set
up
in
in
Prague,
so
conceptually
you
can
think
of
this
as
basically
the
statement
of
the
inverse
problem.
So
we
want
to
minimize
some
data,
misfit
plus
a
regularization
using
some
optimization
machinery.
The
other
thing
that
I
wanted
to
mention
with
the
max
iterations
is,
if
you
are
gonna,
do
so.
For
example,
if
we
were
gonna
run
a
stitched,
1d
inversion
where
we're
gonna
invert
a
whole
bunch
of
different
soundings
and
then
bring
them
all
together
to
make
a
3d
model.
C
C
C
The
double
question
mark
I
believe
brings
up
the
code,
so
some
of
our
documentation
is
lacking
a
bit
and
so
sometimes
it's
helpful
to
actually
just
have
a
quick
look
at
the
code
and
see
what
it's
doing
so
here
we
specify
a
Phi
D
star,
so
that's
our
target
misfit
and
that's
based
on
the
the
number
of
data
that
we're
looking
at,
and
so
you
can
check
out
in
the
paper.
C
We
describe
a
bit
more
of
why
you
might
want
to
use
that,
but
here
you
can
play
around
with
this
inversion
and
try
running
it
beyond
that
and
see
what
happens
so.
The
MT
tutorial
again
like
talks
about
the
stuff
in
detail.
C
We
also
set
a
trade-off
parameter
so
in
the
inverse
problem.
We
need
to
tell
it
how
to
combine
the
data
misfit
and
the
regularization,
and
so
we
often
want
to
have
some
sort
of
waiting
between
those.
So
here
we
set
it
to
be
a
fixed
value
of
5.
You
could
also
estimate
it,
and
so
we've
got
some
utilities
that
will
try
and
estimate
based
on
sort
of
how
big
your
regularization
term
is
and
how
big
your
data
misfit
is
choose
a
reasonable
beta
between
the
two
of
those.
C
Yeah
to
find
the
beta
like
you
can
use
the
L
curve
method,
so
that
then
means
you're.
Gonna
run
an
inversion,
so
the
MT
tutorial
does
this.
So
you
run
an
inversion
at
a
whole
bunch
of
different
betas,
and
then
you
actually
pick
the
one.
That's
at
the
elbow
and
so
yeah
check
out
the
MT
tutorial
for
that.
Ok.
C
Not
automatically
so
we
don't
have
like
an
L
curve,
automated
yeah,
so
that
that's
one
that
you
would
need
to
like
you
can
you
can
find
it
manually
yourself,
but
all
the
machinery
to
do
that
is
in
synthase.
C
Yeah
and
then
like
sort
of
the
automatic
picking
that
we
have
in
Simpa,
is
this
beta
estimate
by
eigenvalue,
so
it
basically
tries
to
estimate
like
how
it
takes
a
random
vector
and
multiplies
the
regularization
by
that
and
the
data
misfit
by
that
and
says:
okay,
how
big
are
each
of
these
and
then
based
on
that
I
can
choose
some
ratio
between
them,
so
maybe
I
want
them
to
be
equal.
So
that's
what
this
would
say
or
if
I
wanted
the
regularization
to
be
five
times
more
important
than
the
data
misfit.
C
Okay,
so
here
then
we
create
an
inversion,
so
it
takes
the
inverse
problem.
So
this
is
like
just
the
statement
of
the
thing
that
we
want
to
optimize,
and
then
it
takes
any
directives
that
we
have.
So
basically
those
are
like
controllers
on
the
inversion.
So
in
this
case
the
target
misfit
is
a
controller
on
the
inversion
right.
You
want
to
check
in
at
every
iteration
and
say
how
do
we
hit
the
target
misfit?
If
yes
stop,
if
no
continue
on?
So
that's
an
example
of
a
directive.
C
If
you
wanted
to
use
the
beta
estimation,
that's
also
a
directive,
because
what
it
does
is
says:
okay,
at
the
very
beginning
of
the
inversion,
try
and
estimate
a
reasonable
beta
for
this
inversion
and
then
go
so
there's
a
there's,
a
few
other
ones
that
you
can
look
out,
but
these
are
the
most
probably
the
most
common
two
that
we
have
there's
also
stuff
for
saving
models
and
outputs,
and
things
like
that
as
the
inversion
runs
that
are
sometimes
useful.
C
If
you
want
to
have
that
written
out
to
a
file
and
then
here
once
we
have
our
inversion
object,
all
we
have
to
do
to
run.
It
is
run
the
dot
run
method
given
a
starting
model.
So
here
we
can
do
that.
So
there's
a
few
things
that
our
output,
so
we
see
beta,
here's
five.
So
that's
what
I
set!
We
can
look
at
Phi
D.
We
see
that
it's
decreasing,
so
that's
good
and
we
can
see
our
value
of
Phi
M.
Our
regularization.
B
C
In
that
case,
you
might
need
to
look
at
so
it
looks
at
fighty,
and
one
important
thing
that's
coming
into
phi
b
is
what
your
noise
model
is.
So
it's
very
possible
in
that
case,
if
it's
stabilized
that
maybe
your
uncertainties
are
too
low.
So
it's
trying
really
really
hard
to
continue
fitting
the
data,
but
it's
made
as
much
progress
as
it's
gonna
make.
So
that's
that's
one
possibility
so.
C
C
So
in
in
this
case,
it's
probably
not
quite
as
important
but
in
places
where
you
have
sign
changes
in
your
data,
it's
very
important
because
you
want
to
make
sure
that
you're
not
trying
to
fit.
So
if
Diab
is
zero,
you
don't
want
to
fit
that
exactly
right.
So,
okay,
we're
basically
gives
you.
It
says
you
know
what
my
0
is
10
to
the
negative
12.
So
don't
really
worry
about
anything,
that's
that's
less
than
that.
B
C
All
right,
so
this
one
converged
in
in
two
iterations.
If
you
go
back
and
play
with
different
parameters,
you
can
see
how
that
changes,
and
then
here
we
want
to
actually
look
at
the
predicted
data.
So
we
asked
the
inverse
problem.
What
what
was
the
predicted
data
at
the
end
of
the
inversion
and
then
we'll
compare
that
to
the
observed
data?
C
So
here
we
can
see.
We
did
a
very
good
job,
fitting
that,
with
maybe
the
exception
of
like
very
the
very
first
time
channel,
and
then
we
can
see
what
the
recovered
model
looks
like.
C
C
H
G
C
Yes,
so
in
this
case
let
me
share
my
screen
again
so
I
mean
they
could
be
coincident
or
they
they
don't
have
to
be,
and
so,
when
we
set
up
the
receiver,
we
specified
its
location
here.
So
we
offset
the
this
receiver
from
the
origin,
which
is
where
the
source
is
located
by
the
radius,
so
they
don't
have
to
be
coincident
all.
G
D
C
I
see
okay,
so
you're
muted
right
now,
so
we
cannot
hear
you.
C
C
Yes,
so
in
this
case,
these
are
things
that,
like
need
to
be
sorted
out
before
before
running
the
inversion,
because
it
like
we're
clearly
not
forward
modeling
the
same
thing
as
what
are
so
in
this
case.
That
requires
some
work,
looking
at
the
just,
comparing
forward
simulations
and
trying
to
understand.
First
of
all,
what
are
your
data
and
how
do
you
translate
those
two.
E
C
C
D
C
So
when
the
inversion
is
running
its
expecting
the
BDC,
because
when
you
specify
the
receiver
as
a
point
dvb-t
receiver,
it
is
then
expecting
that
it
is
gonna,
try
and
compare
itself
to
something.
That
is
those
data
are
not
that
then,
like
the
inversion,
is
going
to
struggle
or
do
something
nonsensical,
because
we're
not
comparing
two
things.
A
C
So,
like
squirting,
this
out
right
now
over
the
over
the
screen
is
a
bit
tricky,
but
what
I
would
encourage
you
to
do
is
take
a
look
at
sort
of
just
running
some
forward
simulations
see.
If
you
pick
a
single
location,
can
you
actually
get
data
the
observes
and
deep
red
that
are
behaving
it's
a
toilet
and
that
that's
the
first
place
you
have
to
start
and
make
sure
that
what's
more
for
simulating
actually
is
the
same
thing
as
what
the
observe
data
are.
D
C
On
just
about
two
hours
here
so
I
think
we
should
try
and
wrap
up
if
there
aren't
any
more
specific
questions
about
this.
What
we
can
do
is
if
anybody's
welcome
to
post
questions
on
black
are.
C
That
is
a
good
place
to
reach
us
with
any
sorts
of
questions,
or
things
like
that.
So
as
I
mentioned
before,
if
anybody
is
willing
to
work
through
these
notebooks
add
notes.
So
like
have
a
look
at
the
MT
tutorial
and
you
know
add
notes
from
there
explain
some
of
the
steps
of
what's
going
on.
That
would
be
an
excellent
contribution
back
to
something
and
other
people
can
then
use
this
as
training
material.
D
C
Yeah,
absolutely
so
yeah
so
feel
free
to
ping
us
on
slack
and
reach
us
that
way.
We
do
simply
getting
a
free
Tuesday,
so
today,
it'll
be
at
2
p.m.
so
anybody's.
Welcome
to
join
but
they're
also
live,
and
we
have
notes
afterwards.
So
if
you
can't
join
because
of
time
differences
because
I
know,
we've
got
the
world's
covered
at
this
point,
so
yeah
you
can.
You
can
watch
asynchronously
and
reach
us
on
slack
so
perfect.
Well,
thanks
everyone
for
taking
time
with
things.