►
From YouTube: SimPEG Meeting, August 16th, 2023
Description
Weekly SimPEG meeting from August 16th.
A discussion on TDEM implementations.
B
E
E
E
B
Let
me
get
this
yeah,
so
yeah
moving
the
the
user
tutorials
outside
of
where
we
have
the
code
base.
This
is
just
kind
of
a
landing
page
and
we
can
do
all
sorts
of
fancy
configurations,
but
it's
just
kind
of
starting
out
with
you
know
who,
who
should
actually
be
here
and
say
you
need
to
install
Sim
Peg,
and
this
is
kind
of
what
we're
doing
right.
So
what
are
these?
What
can
I
learn
from
them?
How
do
I
access
them?
B
So
probably
the
questions
people
would
want
to
answer
on
the
landing
page
a
little
bit
of
a
caution.
So
we
have
a
lot
of
admonition,
options
which
is
cool
but
just
trying
to
make
sure
that
people
know
if
they
they
want
to
guarantee
everything
works
properly.
They
need
to
keep
their
version
of
simpeg
up
to
date.
B
B
And
so
the
things
that
we
can
learn
is
quite
a
lot,
but
you
know
if
you
want
to
have
a
complete
knowledge.
You
need
all
of
the
pieces
of
this
puzzle
and
so
I
guess
I
was
going
to
focus
on
what
is
the
actual
physical
thing.
These
objects
represent
because
each
thing
kind
of
corresponds
to
either
something
mathematical
or
something
tangible
like
a
receiver,
creating
these
objects
using
them.
B
So
what
are
the
different
things
we
can
do
with
something
once
it's
created
and
then
the
big
thing
that
we're
going
to
use
to
augment
these
is
suitable
input
parameters,
so
things
like
well,
how
big
should
my
cells
be
stuff
like
that,
and
so
we
go
through
that
elaborate
on
it
and
then
accessing
them.
Well,
a
little
explanation
of
the
the
organization
and
that
you
know
you
go
to
the
top
and
click
this
button
to
download.
B
We
have
some
medium
weight
notebooks
where
you
know.
As
long
as
you've
got
about
eight
gigs
of
available
Ram,
you
could
run
it
on
your
computer,
but
it
might
take
a
few
minutes,
and
then
we
have
some
computationally
intensive
ones.
Once
we
start
putting
in
things
like
3D
em
inversion,
where
you
would
probably
have
to
have
access
to
some
form
of
cluster
Computing,
so
to
just
make
it
clear
that
these
are
laptop
examples,
and
then
these
are
full
examples
that
are
like
very
Advanced.
B
D
D
D
B
B
B
D
B
B
I
mean
building
this
thing
takes
no
time
whatsoever.
My
understanding
of
this
is
like
you,
you
run
the
notebooks
and
then
you've
you
stay
saved
the
status
of
that
notebook
and
then,
when
you
run
Mist,
it
builds
that
so
when
you're
building
the
website,
it's
just
building
it
from
the
current
status
of
those
notebooks.
So
if
I
did
like
a
if
I
did
like
a
I,
don't
know,
restart
and
clear
all
cells
and
then
I
ran,
missed
I'd
have
no
outputs
on
that
page,
because
I've
gotten
rid
of
all
the
outputs.
B
B
Yeah,
that's
the
idea.
Is
they
they
take
forever
to
run
and
they're
limited
to
being
as
lightweight
as
possible
and
now
there's
a
demand
to
actually
implement
sort
of
best
practices
or
rules
of
thumb,
and
so
I've
got
a
current
like
3D
frequency
domain,
Ford
modeling
in
simpeg,
which
takes
several
minutes
to
run,
but
it
the
mesh
is
so
coarse
that
the
numbers
aren't
really
accurately
reflecting
the
response
of
the
Target
that
I
put
in
so
now.
People
would
actually
like
to
get
realistic
numbers,
which
means
that
we,
we
really
have
to
take
that
out.
A
F
D
A
D
D
D
Going
to
wrap
it
up
or
what's
the
they're,
mostly
applicable
to
like
10
spear
meshes
so
I've
been
trying
to
think
more
abstractly
about
how
to
implement
it
towards
you
know,
actually,
measures
that
I
think
would
be
a
really
good
thing.
I
haven't
I
haven't
been
able
to
find
anything
really
actually
meshes
with
the
best
marketing
icon.
Soldiers
should
be
interesting.
D
D
A
On,
a
related
note,
I
actually
met
with
that
student
again
yesterday,
because
she's
interested
in
doing
basically
using
Das
cables
and
trying
to
get
a
like
stress
from
social
engineering,
geologic
engineering
trying
to
get
out
stress
from
travel
time.
We
like
get
out
the
velocity
and
then
infer
something
about
in-situ
stresses,
so
she
actually
went
through
our
code
and
I
was
like
it
was
a
one
of
those
humbling
experiences
where
she's
like.
Can
you
tell
me
what
this
line
is
doing
and
look
back
and
it's
like?
A
Oh,
our
variable
names
are
o
and
D.
This
is
useful,
so
actually
what
I
think
we
eventually
sorted
through
it?
It
was
kind
of
a
cool
debugging.
Go
back
in
time
exercise.
It
is,
you
know,
I
think
it's
doing
what
it
should
be
doing,
but
I
anticipate
we'll
actually
get
a
pull
request
from
her
as
a
first
pass,
just
fixing
all
the
variable
names,
because
I
said
before
you
go
ahead
and
try
and
Implement
something
in
3D.
A
Let's
just
write
out
like
everything
that
you
think
is
going
on
so
I
expect
we'll
have
a
pull
request
from
her
at
some
point.
She's
brand
new
to
contributing,
and
so
she
might
need
a
bit
of
support
in
that,
but
I
wanted
to
a
few
things
and
it's
a
nice.
It's
a
nice
place
to
start.
It's
just
go
in
and
fix
all
the
names
so.
A
A
A
C
C
E
D
C
C
A
C
I
can
go
on
X,
I'm
still
in
time
domain
and
found
the
final
ways
that
we
can
really
speed
things
up
for
the
fields,
calculation
and
the
the
sensitivity
calculation
so
turns
out
that
when
we
compute
fields,
we
Step
in
Time
right
over
all
the
sources,
but
if
the
waveform
we're
basically
doing
a
lot
of
computations
and
at
the
end,
multiplying
by
zero,
because
often
the
waveform
is,
is
not
zero
at
the
beginning.
But
after
this
we
have
a
lot
of
time.
C
Steps
that
it's
a
zero
waveform
sorry
right
inside
is
just
returning
zero
arrays
constantly
so
I
think
it
makes
sense
that
we
check
first
before
asking
for
the
right
hand
side
if
what's
the
status
of
the
waveform,
for
that
at
that
time
right,
the
question
is
currently
is
very
flexible.
Technically
each
Source
could
have
its
own
waveform,
but
in
most
cases
it's
always
used
to
be
the
same
function
right.
C
D
D
C
D
C
We're
wasting
a
lot
of
time
there
and
also,
when
I'm,
not
sure
how
that
works
for
JFK
gtvec,
but
when
we're
doing
backward
when
we're
moving
backward
in
time,
if
the
the
data
is
not
is
not
within
the
time
range,
we
don't
really
need
to
compute
the
sensitives
for
that
data
because
we're
having
March
in
time.
You
know
to
it
yet,
but
I'm,
not
sure
how
that
looks,
though,
for
if
you
just
if
we
don't
store
jmatrix
but
anyway,
some
interesting
cab,
yieldster.
D
A
C
A
B
This
conversation
before
because
we're
we're
interested
in
modeling
utem,
where
the
period
of
the
waveform
can
be
different
by
like
a
a
factor
of
10
and
so
in
order
to
model
that,
with
the
same
time,
stepping
it's
like
zero
time
steps
and
then,
like
your
waveform,
starts.
So
there's
like
a
lot
of
redundant
calculations.
So
it
would
be
useful
to
have
something
that
considers
this.
C
Yeah,
but
ideally,
is
that
if
we
don't
have
to
Loop
of
our
sources,
we
should
just
skip
to
not
look
over
the
sources,
because
just
that
in
Python,
if
you
have
thousands
of
sources
you're
just
waiting
for
to
do
nothing
right,
you
just
return.
Zero
arrays
I
think
we
can
skip
it
all
together,
that'll
be
even
better.
D
B
C
C
D
F
F
D
F
E
E
Speaking
about
time,
domain
I
was
revamping
the
time
domain
code
a
little
bit,
so
the
current
form
is
like
a
we
like
it,
discretize
the
waveform
and
then
solve
like
a
pde
with
the
waveform.
So
I
mentioned
a
couple
of
times
that
we
could
slightly
use
a
different
strategy
like
you
do,
step
off
and
then
combo.
E
So
we
so
I
was
working
with
a
Korean
postdoc
working
at
France.
The
issues
was
interested,
so
I
was
helping
her
and
then
we
were
implementing
that
and
that
the
current
Center
were
very
focused
on
opponium,
so
I
think
there's
a
few
things
that
I
like
I,
don't
like
about
the
Quran
time
domain
code
is
the
projection
and
the
way
how
the
field
class
is
working.
E
E
Yeah,
so
let
me
kind
of
quickly
show
you
how
we
were
thinking
about,
so
this
is
like
a
so
that
I
pulled
out
Joe's
code
to
which
calculates
The
Matrix.
So
once
you
got
a
step
off
data
and
enough
time
span,
then
you
can
generate
like
a
just
like
a
linear,
Matrix
yeah
that
you
could
just
simply
multiply.
Then
it
does
a
convolution
for
you.
So
all
you
need
to
do
is
accurately
calculating
the
step
off.
Then
you
can
simply
multiply
that
P
Matrix
that
convolves
it
for
you.
E
So
what
what's
actually
nice
about?
This
is
like
the
hard
part
about
time.
Domain
is
always
like,
oh,
which,
like
which
part
of
the
waveform
that
I
really
need
to
discretize
well
and
then
like
there's
two
parts
like
waveform
on
time
and
then
off
time
as
well,
so
it's
kind
of
like
a
simplify
the
issue,
and
so
let
me
show
you
so
this
is
like
a
it's
a
it's
in
the
syntax
research
that
anybody
I
think
about.
So
this
is
the
that's
sort
of
the
code
like
how
it
works
and,
and
then
so.
E
This
is
like
a
similar
to
I'm,
not
sure
if
you
use
the
h3d
TV,
there's
an
option
that
you
don't
have
to
store
the
fields.
So
sometimes,
when
you're
just
doing
the
like
predicted
data,
then
you
don't
need
to
store
the
fields
so
like
What's,
Happening
Here.
If
you
are
familiar
with
the
code,
then
what
you
do
is
just
to
calculate
the
voltage
of
step
off.
Then
then
I
think
then
you
convolve
with
this,
which
is
stored
in
the
source
and
that's
that's
how
it's
structured,
and
then
you
mentioned
the
sensitivity
part.
E
So
this,
like
we
implemented
the
sensitivity.
I
think
this
is
a
slightly
different
implementation,
but
what
it
does
like
it,
it
solves,
have
a
look,
I
think
the
current
implementation.
If
you
want
to
actually
store
the
sensitivity,
it's
very
inefficient,
so
this,
like
is
kind
of
like
a
change,
is
like
what
you
store
or
not.
So
if
you
look
at
here
what
it
stores
like,
it's
it's
a
back
propagation.
So
what
you
actually
store
is
like
this
three
fields
of
Y
and
then
three
different
steps.
E
E
So,
like
there's
like
an
end,
you
are
doing
a
Time
stepping
for
all
the
time
all
the
data
points
so
like
it's,
it's
like
a
solving
all
of
them
together
for
all
the
data
points,
because
the
the
JT
is
the
number
model
by
number
Theta,
so
she's
choosing
the
number
of
data
and
then
solving
everything
together.
I
think
it's!
It's
okay
like
if
your
message
is
not
so
big
but
I,
guess
if
your
system
is
getting
bigger,
I
think
it's.
It
may
not
be
a
great
great
choice.
D
D
E
E
Think
probably
there
was
some
problem
I
think
like
that.
Maybe
I
think
that
was
just
my
problem,
but
I
think
this
was
like
very
specifically
implementation
again
for
their
one
year.
It
doesn't
matter
a
single
source.
So
it's
like
very
specific.
It's
not
gonna
work,
all
the
problem
and
then
I
think
there's
another
layer
like
like
I
want
the
code
there's
a
global
simulation
that
basically
runs
for
parallel,
so
yeah
for
each
Source,
we're,
paralyzing
and
and
then
like
to
handle
like
thousands
of
sources.
Something
like
that.
E
So
we've
got
it
like
I
played
a
little
bit
with
the
desk
and
then
I
implemented,
but
I
I'm
still
not
exactly
sure
how
like
I'm
gonna.
It's
gonna
work
on
a
multiple
notes:
I
haven't
really
had
a
chance
to
test
them
and
that's
something
that
I
want
to
do
and
probably
I
need
some
help,
but
implementation
Wise
It's,
that's
it
so
yeah,
it's
pretty
simple:
either
multiprocessing
or
task
implementation
so
and
for
Ford,
and
then
this
Sigma
calculation.
E
E
D
D
D
D
E
E
True,
so
the
the
the
current
way
it
works
is
the
I
send
like
my
I
assigned
to
children,
to
calculate
the
J
and
then
pull
that
out
like
a
pull
that
up
pull
that
two
pull
it
to.
What
is
that
the
domain
and
then
all
the
jvac
and
jtvac
calculation,
because
it's
a
you,
have
a
like
a
little
match
and
local
mesh
there's
a
p
Matrix
involved
so
that
all
that
calculation
is
happening
in
the
main
which
I
wasn't
exactly
sure
whether
that's
a
good
way
to
go.
C
E
Oh
yeah
yeah,
so
I
think
yeah
as
we
still
need
to.
You
still
need
to
describe
the
waveform
like
step
up
waveform,
so
it's
like,
but
I
do
pretty
dance
like
in
general,
so
like
it
may
work
for
most
kids.
This
well
like
for
a
specific
application,
but
yes,
I
I
generate
a
couple
of
functions
like
doing
it.
I
said
probably
useful.
E
E
You
feel
like
they're,
all
like
a
system
system
response
and
those
kind
of
stuff
that
you
need
to
implement.
I
think
this
way
is
way
simpler
to
duration,
yeah
and
I.
Think
that
changing
current
implementation,
just
for
the
convolution
part,
could
be
relatively
straightforward,
because
it's
just
like
a
storing
that
P
Matrix
into
the
receiver
class
and
then
convolve
it
so
that
that
part
may
be
straightforward,
I
guess
maybe
not
or
maybe
maybe
or
maybe
not
because
I'm
not
exactly
sure
at
the
moment.