►
From YouTube: SimPEG meeting 2018/05/08
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
B
B
C
B
E
E
C
E
E
E
H
D
B
E
That
so
this
is
something
I've
been
working
on.
My
golf
gone
for
about
I,
don't
know
six
months
to
a
year
when
I've
had
time,
let's
sit
down
and
like
it's
kind
of
something
to
distract
me
from
other
things,
I
was
doing
and
it
kind
of
motivated
cuz
the
tree
mesh
object.
Creation
has
always
been
kind
of
slow,
I
heard
what
it
could
like.
It's
really
really
powerful
once
it's
been
instructed,
but
it's
still
it
just
always
lag
and
I
was
just
kind
of
like
what
can
I
do
to
fix
this.
E
E
E
E
This
is
what
the
grid
would
look.
The
mesh
itself
looks
like
great
there's
nodes
before
there
before
we
define
these
nodes
is
hanging,
but
what's
really
happening
is
that
there's
two
nodes
plotted
on
top
of
each
other
right
there
great
there's
one,
that's
not
hanging
one
that
is
hanging
all
of
it
at
a
different
level.
It
kind
of
creates
a
little
bit
of
confusion
here,
so
we
do
the
same
thing
on
this
session.
So
this
is
the
new
version
right
through
me.
A.
E
Little
bit
so
just
could
they
keep
it
simple,
there's
only
a
refined
function
at
this
point,
there's
what
I
understood
it's
not
hasn't
been
very
common
to
use
the
Corson
function
at
all
event,
I,
don't
know
if
any
of
you
guys
have
ever
used
it
in
your
coding.
If
you
have,
you
can
correct
me,
but
I,
don't
think
I've
seen
much
of
it
being
used
outside
of
testings
if
it
worked
so
should
if
no
one's
actually
using
it
didn't
feel
like
supporting
it.
At
this
point,.
C
H
E
Mean
nobody
really
ever
used
it.
Just
there
is
something
that
could
use,
so
it
does
saving
for
this
small
little
mesh
for
this
one
to
the
fest.
My
implementation
took
one
through
five
milliseconds
this
one
to
22.9.
Most
of
that
is
just
other
calls
going
on
behind
them.
So
that's
about
20
times
faster
right
there
and
for
this
little
guy
how
much
of
a
difference-
it's
small,
mush
anyway.
E
The
biggest
difference
here
is
these
notes.
So
in
the
implementation
now
there's,
every
node
is
only
at
one
location.
There's
no
such
thing
as
they're.
Not
the
nodes
are
not
identified
by
which
level
they're
at
instead
they're
just
identified
by
where
they
are
in
space,
and
it
ensures
that
their
unique
notes,
so
the
only
hanging
nose
that
really
matter
are
the
ones
around
these
hanging
faces.
E
But
that's
the
know,
didn't
like
the
hanging
nodes,
everyone,
conditionally
and
time
differently,
because,
as
before
hanging
nodes
happen
when
they're
at
different
levels
for
now,
there's
not
as
if
Maddie
runs
up
to
the
level
associated
with
the
node.
It's
just
a
location
here
generates
the
same
faces.
E
And
it
would
generate
the
same
five
phases
as
well.
Another
thing
is
I've
implemented,
most
of
edges
X&Y
as
well
for
a
2d
match.
Just
they
hadn't
been
implemented
previously,
so
I
was
writing.
It
I
might
as
well
have
done
it
so
anyway,
that's
just
kind
of
you
guys
see
that
it's
doing
the
same
sort
of
stuff.
Now,
let's
keep
it
in
2d.
Let's
go
up
a
few
128
cells
in
each
to
my
generation.
E
D
E
G
D
E
G
E
E
D
E
E
But
all
the
order
tests
passing
the
only
thing,
the
tests
that
I
had
to
turn
off
were
tests
testing
that
had
to
deal
with
the
properties
class.
So
that's
another
thing
that
is
not
necessarily
super
supportive,
like
that.
Is
this
the
properties
class,
because
I
don't
have
as
much
experience
with
that,
but
another.
C
E
E
E
I
E
G
E
E
E
So,
there's
there's
a
lot
of
little
things
that
I
implemented
in
the
mesh
that
are
Kylie,
exciting
little
changes,
II
think
so
I'm
going
to
show
you
let's
look
at
through
some
of
the
code
as
well,
but
this
is
kind
of
that
first,
this
kind
of
gives
you
guys
an
idea
of
the
speed
ups
that
can
happen
from
it
now.
I'll
show
you
how
I
do
that.
E
So
this
is
just
the
Python
code
that
it's
cold,
so
I'm,
inheriting
a
tree,
this
underscore
tree
mesh,
which
is
what
is
defined.
This
is
the
class
that's
doing
a
bunch
of
that's
doing
all
of
the
work
basically
and
I
have
I'm,
inheriting
some
other,
the
other
classes
that
are
normally
that
you'd
normally
expect.
E
E
E
It's
this
is
a
cyclone
piloting
showing
all
of
the
underlying
code,
so
there's
a
little
bit
of
magic
here
that
happens
in
order
to
call
so
refine
function
that
are
just
defined
and
Python
I
need
to
actually
call
that
Python
function
all
the
way
down
to
the
seats
West
Plus
code.
That's
building
the
tree,
I
need
to
call
a
Python
function
from
C++.
E
So
one
of
the
ways
that
I
have
to
do
that
is
I'm.
Defining
a
see,
define
class,
so
scythe
on
has
it
you
can
define
classes
like
Python
classes
like
you
would
make
also
defined
seed
of
defined
scythe
on
extension
classes,
using
the
C
def
statement
and
as
these
classes
are
closer
to
what
you
would
expect
from
like
a
C
or
C++
type
class
where
they
have
members
and
they
don't
have
the
biggest
differences.
They
don't
have.
E
E
Well,
you
can't
do
that
with
these
C
defined
classes,
because,
like
as
a
choice
for
these
methods,
they
don't
it
makes
it
faster
not
having
to
go.
Look
up
that
dict
object,
so
this
class,
this
class
here
just
a
cell.
So
this
is
kind
of
what's
the
first
level
of
switching
between
C++
code
to
call
the
Python
code
underneath
I'd
if
I
give
in
a
a
cell
which
I've
defined
in
c++,
and
it
calculates
all
the
normal
values
that
are
expect.
E
So
this
is
essentially
going
to
look
and
work
exactly
like
the
cell
used
to
and
the
current
orientation
of
Kadesh
it
has
all
of
these
same
properties,
so
the
functions
there
were
fine
functions
that
we
were
using
before
should
still
work
on
this
anyway
and
then
I
have
to
define
a
little
function
that
wraps
whatever
function.
It
would
give
it
calls
the
cell
it
returns
the
function.
Do
you
see
a
little
bit
of
casting
going
out
here,
so
this
Python
function,
easy
it
passed
to
a
Python
object
and
then
I
construct?
E
E
E
E
Initializes
it
space
tensor
mesh
and
then
it
initializes.
The
underlying
to
English,
which
comes
in
here,
does
some
magic
to
set
its
max
level,
determine
the
locations
of
the
nodes
like
all
the
possible
locations
of
the
nodes,
meaning
the
XY
and
Z
defined
by
indexes
I,
X,
I,
Y
or
Z.
And
then
we
do
an
initial
summit
initialization
of
the
tree
in
C++.
E
E
So
this
is
the
C++
header
file
to
kind
of
give
you
guys
an
overview
of
all
the
things
that
are
implemented
if
you're
really
interested
in
the
exact
details
of
what
is
going
on,
you
can
look
through
the
functions,
but
the
big
big
takeaways
here
is
I
can
find
these
two
key
functions,
so
each
node
and
each
cell,
which
please
each
age,
is
the
presentation
to
fine
hi.
It's
free,
its
dimensional
indexing,
so
ixi.
Why
is
this
key
function?
Takes
those
numbers
and
uniquely
maps
it
to
a
single
integer.
E
So
even
a
integer,
x
and
y
map
to
another
number
is
unique.
This
ensures
as
I'm
creating
video
that
I
will
only
ever
one
node
or
one
edge
or
one
face
at
a
single
location.
I
use
this
key
function.
First,
to
see,
see
it's
to
value
all
of
the
nodes
edges
in
cases
it's
stored
in
a
map
which
maps
that
change
to
a
node.
So
if
I,
if
I
ever
wanted
to
create
a
node
in
the
mesh
I,
would
first
check
this
map
to
say
it
was
our
beginning.
E
C
E
E
Each
key
refers
to
only
one
object,
so
that's
how
this
app
works,
and
this
is
also
an
ordered
map,
so
they
are
ordered
by
their
key
values,
meaning
if
I
wanted
the
time
it
takes
to
look
up.
A
certain
node
based
off
of
its
key
is
small
because
they
are
order.
It
doesn't
really
matter
how
they're
ordered
it's
really
up
to
the
map
implementation
to
determine
the
ordering
of
the
objects.
E
E
Reference,
so
this
reference
is
something
that
I
use
to
keep
track
of
how
many
times
it's
referenced
by
other
objects
its
index.
So
this
would
be
its
location
in
that
array
that
you
would
need
to
in
the
higher-level
sequence.
Python
files
like
this
would
be
the
Cotter,
the
either
the
column
index
or
a
row
index
depending
on.
If
I'm
a
gypsy,
a
building,
every
node
will
also
know
whether
or
not
it
is
a
and
then
if
it
is
hanging
it
will
define
parent
notes.
E
G
E
Largest,
cities
actually
gonna
be
types.
These
int
types
are
defined
as
a
standard
size
T,
which
is
the
size
of
the
pointer
on
the
on
the
index
that
your
it's
the
size
of
the
pointer
on
the
machine
you're
currently
using
or
that
you're
used
to
compile
this.
So
if
it
was
compiled
with
a
64-bit
processor,
64
bit
d,
+
+
compiler,
this
n
type
would
be
a
unsigned
long
long,
though
it's
if
this
is
a
large,
this
will
adapt
to
whatever
size
your
on
so
it'd
be
undone
signed,
64-bit,
integer,
unsigned
32-bit.
B
E
E
Machine,
that's
4,
gigabytes,
roughly
3
point
something
and
on
a
63
minutes
whatever
that
largest
and
type
value
is
I,
don't
know
offhand
whatever
T
to
the
power.
64
is
more
power,
64
minus
1,
so
that
would
be
a
largest
size.
You
can
essentially
handle
in
these
now
the
key
function,
so
it
shouldn't
I.
Don't
imagine
any
issues
between
32-bit
64-bit
as
far
as
soaring
a
matrix
size,
because
they're
all
implemented
as
these
int
types.
E
I
E
Know
X's
because
they've
already
got
a
number
I,
don't
have
to
know
about
messing
with
a
lot
of
those
underlying
functions
to
okay.
I
need
to
get
a
note
in
the
level,
love
this
and
find
the
notes
around
everybody
already
knows
about
it.
That
makes
this
construction
very
quick
and
plus
follow-ons
arrays
are
created.
E
B
E
It's
just
has
two
parents
as
repeated,
so
the
implementation
is
the
same,
but
something
I
figured
out
the
relation
matrix,
essentially,
if
matrix
or
if
the
node
is
not
hanging,
it
is
just
an
identity
matrix,
and
if
it
is
a
hanging
note
it's
the
average
of
two
parents
right
well,
one
of
those
parents
could
be
hanging,
the
other
could
not
be
or
both
of
them.
I.
E
C
E
E
So
this
just
it
makes
what
happens
when
essentially,
edges
are
not
balanced,
which
is
not
being
something
that's
being
enforced,
okay,
which
hasn't
been
it
before,
but
it
this
is
just
a
quick
way
to
take
care
of
it.
Otherwise,
I
don't
have
to
search
in
the
construction
of
it.
I
just
kept
it
simple.
You'd
have
to
essentially
look
for
a
parent.
Okay
is
that
paying?
Then
you
have
that
parents,
parents
and
see
that,
isn't
it
just
kind
of
gets
recursive
this
way
was
just
once
I
realized.
I
could
do
this
way.
E
I
just
did
that
way
and
something
about
the
other
way.
That's
cleaner,
yeah
and
the
same
thing
to
happen
with
that
case
cannot
happen
with
the
faces
because,
like
we
said
the
faces
are
all
the
cells
are
balanced
along
the
faces,
but
it
can't
happen
with
the
edges.
Well,
here
is
my
delete
edges.
Where,
again,
you
see
that
same
kind
of
trick
happening
at
the
end.
Okay,.
E
But
again
because
every
object
knows
its
parenting
index,
it
makes
it
really
simple
to
construct
these
matrices,
please
to
understand.
What's
going
on
and
a
little
trick
here,
so
let
me
talk
again
about
these
edges
in
the
faces
to
the
edge
again,
that
knows
its
location
as
its
key.
Its
reference
indexes,
as
its
parents
edge,
also
knows
which
points
bound
it.
E
You
can
imagine
that
would
be
useful
for
constructing
things
like
the
edge
curl
matrix
right.
It
acts
from
points
edges
from
nodes
to
edges.
Similarly,
the
face
object
knows
its
edges,
there's
also
nose.
It's
very
does
its
points
and
it
also
knows
its
edges,
which
is
useful
for
creating
face
divergence,
matrices.
E
E
So
this
is
the
nodal
gradient.
The
Nilla
gradient
ex
from
loads
to
edges,
so
I
can
loop
all
over
all
of
the
X's.
Get
its
index
get
the
index
of
the
points
that
are
around
it
or
that
point
it
on
both
sides
of
the
edge
get
the
length
of
the
edge
of
constructive
agents.
So
it's
very
straightforward.
There's
not
a
lot
of
it's
at
least
I.
Think
it's
easier
to
understand,
what's
happening
here,
so
I
just
act
such
as
wire
to
see
and
then.
I
I
E
E
Or
at
least
implement
the
construction
of
it,
and
it
should
be
very
logical
that
Sun
anybody
who's
looking
at
this
code.
Oh,
this
is
exactly
that
this
is
doing,
whereas,
if
you're
trying
to
go
and
look
through
the
code
of
the
old
implementation,
it
is
least
when
I
first
saw
looking
at
it
was
not
as
clear
to
me
what
was
going
on
once
I
started,
really
understanding
it
and
doing
it.
I
was
like
okay.
E
E
E
G
E
So
the
other
thing
is
the
cells,
so
I
didn't
get
to
the
sole
object,
yet
so
the
sole
after
for
something
I
need
to
have
it
remember
it's
dimension.
It
knows
its
parent
cell,
so
there
so
one
level
above
it
that
contains
it.
If
it
is,
if
it
has
bent
but
it'll
know
all
of
the
children
below
it
and
it'll
also
know
all
the
adjacent
cells
around
it.
So
I
don't
know
it's
neighbor
cells,
which
makes
it
easier
to
construct
that
the
cell
grad
stencil,
because
I
can
just
look.
E
Okay,
I
want
to
look
at
a
neighbor
there's
a
little
bit
of
logic,
the
rest
of
the
old
window.
Its
neighbor
is
not
a
leaf,
so
whatever
what
I
mean
by
a
leaf?
Is
that
it?
If
a
cell
has
children,
it
is
not
a
leaf,
so
only
cells
without
children
are
leaf.
Cells
I
also
keep
references
to
all
the
points,
argues
and
cases
within
a
cell
as
well.
So
everything
is
kind
of
aware
of.
E
What's
around
it,
there's
a
lot
of
logic
that
deals
with
how
cells
are
spawned,
how
they're
divided,
but
if
you
can
kind
of
imagine
that
this
function
treats
if
a
cell
needs
to
be
split,
this
function
will
create
children.
It'll
also
set
up
all
the
yeah
it'll
create
the
children
and
then
divide
will
basically
tell
it.
This
is
the
function
that
you
would
call
to
recursively
define
itself.
E
E
So
the
cell
gets
created,
all
of
its
neighbors
are
initially
no
then
I
have
to
and
all
of
its
children
are
now.
So
if
cells
are
on
the
boundary
that
neighbor
will
never
have
been
set,
so
the
neighbors
only
get
set
when
things
are
created.
So
if
you
create
and
to
be,
if
you
create
for
children,
you
can
imagine
all
the
children
I
didn't
want
child
as
the
neighbor
of
another
child,
and
they
both
get
paired
up
like
that.
E
Not
really
listed
like
that
I
mean
I,
haven't
done
that
I
trying
to
imagine
how
I
could
know
in
that
I
mean
besides
looping,
you
mean
besides
looping
over
all
the
cell's
I'm,
just
saying
it's
around
the
boundary,
that's
a
mean!
Well,
it's
the
easy
way
to
do
it
great
this
loop
through
the
list
of
all
the
cells
and
determine
if
they
have
any
no
labors
or
determine
if
a
face
is
on
the
boundaries
determinants,
location
at
the
time,
the
boundary
I
guess
they
eat
this
way.
To
do
that,
with
that.
A
E
Could
define
a
function
that
would
give
all
of
them,
basically
by
always
going
to
the
outer
cell
of
each
division,
so
I
start
at
the
root
self,
which
is
just
one
large
thing.
Look
at
the
parent
here
that
it's
children
and
then
look
at
those
children's
foundry
cells
and
please
get
a
list
of
all
of
the
boundaries
yeah
like
that.
So
it
wasn't
really
something
I
was
concerned
about
I
mean
if
you
want,
you
can
film
it
yourself,
hopefully
right
the
logic,
it's
clear,
but.
E
E
If
a
face
was
on
the
outside,
he
right
it's
by
definition.
It's
not
hanging
so
I
just
skip.
Those
what's
happening
is
I'm
whipping
off
all
the
faces
and
I
I
have
this
reference
here.
This
is
what
I'm
using
to
determine
whether
it
even
check
if
it's
a
hey
node.
So
if
the
same
face
anything
that
it
has
the
same
center
location
is
referenced
twice.
It
is
not
in
hanging
face.
E
So
then,
if
it
was,
it
was
not.
That
means
that
it
could
either
then
apparent
chase
or
or
children
or
a
child
face
I
have
left
the
parent
faces
as
not
hanging.
This
is
what
happens
here
great
if
it's,
if
the
space
had
a
node
at
its
center,
that
meant
it's
gonna
have
children
faces
so
I'm
saying
that
that
is
not
a
taking
place.
There's
just
a
lot
of
operations
here,
so
I
I
find
my
parent.
E
If
I
was
a
child,
I
find
my
parent
knows
their
parent
face
and,
like
I
said
here,
this
is
kind
of
the
least
clear
bit
about
what's
going
on
here
that
I'm
using
a
bunch
of
bit
shift
operations
to
patterns.
So
this
one
would
be
so.
The
possible
values
of
this
IP
parameter
are
0,
1,
2
or
3,
and
this
is
the
corresponding
pattern
that
it
comes
up
that
this
big
shift
operation
comes
up
with
so
2
0,
2
0,
just
it's
just
dependent
on
the
ordering
that
I
had
the
points
and
faces.
E
E
E
Really
that
this
operation,
basically
on
that
little
if
at
any
and
I
skip
it,
this
only
works
because
this
next
guys
everything
is
labeled
or
indexed
non-immune,
first
Nanhe
me
and
if
it
wasn't
I,
would
have
to
define
a
matrix
that
essentially
removed
all
of
those
rows
from
the
output.
This
is
just
doing
that
automatically
in
the
current
implementation,
so
on
the
edge
around
the
little
gradient,
you
might
see
a
deflation
matrix
on
both
sides
here
that
would
remove
the
hanging
edges
on
the
left
and
one
that
deflates
the
hanging
notes
on
the
right
now.
C
E
H
E
Well,
you
just
don't
worry
about
it,
so
the
key
is
basically
I.
Don't
want
to
care
about
how
I'm
indexing
things
I
just
want
to
know
what
the
index
is,
and
it
makes
it
a
lot
faster
to
construct
these
matrices,
because
before
you
have
to
go
and
calculate
what
the
index
would
be
for
an
edge
depending
on
its
level,
its
location,
there's
a
lot
of
primaries
are
going
to
it.
I
don't
want
to
care
about
that.
I
just
want
to
know
what
the
index
is.
E
This
function
here
that
creates
all
of
the
ideas
and
faces
and
here's
all
the
Hangul
of
painting
stuff
is
in
this
function
called
finalized
lists,
which,
for
some
reason,
when
I
was
initially
doing
it
I.
So,
if
I
want
to
build
tree
from
a
function,
I
go
to
function
and
at
the
end
of
a
to
finalize,
is
the
list.
So
actually,
what
I
probably
should
do
is
remove
this
from
here
and
instead
move
it
into
the
refine.
E
And
this
without
this
would
have
an
option.
So
if
I
said
this
is
false,
I
could
calculate
I
could
keep
calling
her
for
me
and
that
this
would
fix
that
thing.
Where,
like
I
said
he
could
you
wouldn't
be
able
to
fun
refine
things.
So
this
would
this
function
then,
would
only
ever
create
more
cells.
It
would
never
get
rid
of
cells
because
of
the
way
it
works.
E
E
So
it
it's
right
now,
it's
just
a
a
list
of
you
can
either
give
an
integer
to
refine
everything
to
the
same
level.
I
haven't
added
specifically
like
oh
I,
want
to
find
these
cells
and
yet
are
a
list
of
cells,
so
something
that
could
be
implemented
later,
I,
don't
imagine
being
an
issue
actually
since
separating
out
this
like
finalized
lists
thing
there
just
have
to
be
once
the
once
you've
done,
refining
everything
you
would
have
to
finalize
the
object
before
you
could
use
it.
The.
G
G
E
So
yeah!
That's
what
that
does
I
had
to
implement
that,
and
it's
actually
pretty
simple
once
I
once
I
did
this
as
I
go
all
the
things
turned
out
being
simpler
than
I
thought
they
would
have
been
when
I
first
started
doing
it
I
do
that,
because
it's
essentially
how
I
built
things
from
how
I
read
in
the
UBC
tree
mesh
I,
guess
a
little
read
it
in
convert
it
up
to
a
bunch
of
points
and
levels
and
then
insert
all
those
cells
into
the
mesh,
and
that
creates
it.
E
G
E
E
G
So
what
does
he
do
that
before
you
switch
from
there
longer
the
coarser
to
define
our
joy,
then
sing?
We
say
the
finest
that
will
we
send
at
other
points
with
a
final
seven
of
like
what's
gonna
be
the
tree
augmentation
rate.
You
know
this
is
skipping
two
cells
or
three
cells,
or
as
fast
as
possible.
So.
E
C
E
C
So
just
correct
me
from
not
understanding
this
rate,
so
that
would
change
the
number
of
levels
of
refinement.
So,
if
I
had
once
elders
were
fine
by
3
next
to
once,
I
was
refined
by
2
and
I
triggered
this.
It
would
refine
everything
down
based
on
the
number
of
levels
that
we
set.
There.
C
So
I
guess
the
other
question
that
I
have
they
say:
I
refine
I
want
to
refine
around
a
source
or
receiver
location,
so
I
define
sort
of
which
level
that
I
want
the
refinement
right
around
my
source
to
be,
but
then
I
want
it
to
refine,
maybe
like,
instead
of
corseting
sort
of
by
one
neighbor
immediately.
It
may
be
due
to
neighbors
or
three
neighbors
thing
like
that,
so
it's
actually
sort
of
a
smoother
octree.
E
G
E
D
E
E
So
if
there's
a
lot
of
automatic
type
definitions
that
come
from
getting
a
C++
Python
file,
which
is
really
nice,
so
this
whole
loop
here
is
all
authorizes
down
C++
code,
as
well
as
all
of
those
operator
matrices
wherever
they
went.
So
this
is
all
the
grid
stuff,
exactly
how
you
would
think
they
were
implemented.
They're
elected
like
that.
E
E
E
Like
any
of
the
objects
to
sell,
centers
are
easy
because
everything
is
in
a
line.
Everything
is
aligned,
so
those
it's
easy
to
construct.
The
averaging.
The
extra
stuff
and
I
was
easy
to
construct
because
the
cell
knows
its
edges
and
it
knows
which
edges
it's.
So
it's
X
edges
and
it's
Y
ideas
or
NZ
edges.
E
E
E
And
it's
easy
to
think
about
when
it's
notes
when
you're
interpreting
from
nodes
on
a
tree
mush-
and
that's
just
it's
so
easy-
it
just
implemented
it
really
quickly.
So
you
calculate
the
weights
and
assign
those
weights
to
values
depending
on
each
note,
so
the
for
each
location,
I
get
its
XY
and
Z
locations
and
then
I
have
a
function.
That
I
could
look
that
I
can
return
the
containing
cell.
This
is
a
fast
lookup
because
of
the
structure
of
the
tree
mesh.
E
If
every
cell
knows
its
children
cells
in
the
center,
so
what
it
does
is
it
essentially
compares
the
value
to
its
center
and
depending
on
which
values
in
less
than
or
greater
than
it'll
look
into
a
child,
and
then
I'll
keep
going
until
it
finds
the
leaf
cell
letter
this
in
so
it's
it's
a,
and
so
it's
like
a
log
and
search
to
find
a
containing.
So
that's
pretty
fast
lookup
there.
E
So
this
the
nodal,
interpolation
matrix,
is
easiest
to
think
about
the
other
ones
required
a
little
bit
more
thinking
than
I
was
then
I
had
time
to
do
so.
In
that
meantime,
right
now
it
just
triangulates
the
input
points
using
a
de
l'année,
triangulation,
angulation
cannon
calculates.
The
very
eccentric
coordinates
for
each
of
the
points,
there's
a
little
bit
of
logic.
E
E
If
it's
a
lot
of
logic
that
comes
from
the
fact
that
cells
can
be
different
levels
next
to
each
other,
and
it's
what
it's
hard
to
determine,
which
cell
centers
it
should
be
weighted
of
it's
when
I
researched
a
lot
of
updater,
there's
only
throw
a
lot
of
research
papers
and
everybody's
just
like
this
is
not
necessary.
This
is
not
a
trivial
thing
to
do
so,
especially
for
a
linear
interpolation
like
that.
E
E
It's
it
just
yeah,
it's
something
to
think
about.
Hopefully
we
can
get
some
at
some
point
in
the
future,
but
I
just
implemented
it
too.
At
least
it
was
second-order.
Interpolation
matrices
flat
grid
is
basically
the
same
everything
it
won't
be.
The
same.
I
I
draw
the
grid
based
off
of
the
edges.
Instead
of
looping
through
the
cells,
I'm
Bob
excel
points,
it's
a
little
bit
cleaner
and
and
3d
else.
E
Yeah
it's
a
little
bit
cleaner
plot
image
is
essentially
a
copy/paste
from
before
Jeb
replacing
so
what
it
used
to
be
flat.
Slice
I
haven't
implemented
yet,
and
then
here
are
functions
allowing
this
thing
to
be
pickled.
So
because
there's
an
underlying
C
+
+
it
ain't.
It
contains
a
pointer
to
a
C++
object.
E
E
E
E
A
C
Try
and
jump
in
there
a
bit
in
a
lot
of
ways.
It
might
not
be
that
we
actually
even
need
to
inject
properties
in
this
case,
because,
as
you
said,
a
lot
of
this
stuff
is
already
strongly
typed.
I
mean
there.
There
might
be
some
small
validation
things
and
things
like
that.
That
would
be
helpful,
but
that
may
or
may
not
be
necessary.
It
might
just
be
the
case
that
we
actually
want,
like
a
layer
that
lets
us
treat
it
like
properties
and
the
saving
and
loading
word.
E
E
E
Another
thing
ever
said
why
I
had
to
write
this
wrapper
like
this.
It's
because
I
cannot
inherit
from
Python
classes.
I
cannot
see
to
find
Saipan
class
cannot
inherit
from
Python
classes,
so
it
requires
a
little
bit
of
a
small
wrapper
class.
Essentially,
the
other
thing
we
need
to
discuss
is
eventually
is
where
we
want
the
documentation
of
this
object
to
live
and
how
we
want
to
document
it.
E
If
we
would
just
want
to
leave
this
as
a
as
a
small
wrapper,
and
this
implements
everything
in
the
underlying
tree
motion
and
have
all
the
documentation,
was
there
just
list
all
the
documentation
for
everything
that
this
tree
much
defines
here,
just
a
little
things
and
then,
like
you
know,
then
yeah
I
want
to
implement
the
cell
grid
operator
inside
the
event
class
which,
because
all
the
cells
know
their
neighbors,
it
shouldn't
be
that
hard
to
work
up
to
work
out.
It'll
be
pretty
similar
to
the
logic
behind
the
cell
grad
stencil.
E
E
If
you
have
a
question
like
oh,
what
is
this
line
doing
that
I
could
go
in
and
comment
directly
on
to
that
in
general
is
just
a
lot
of
a
lot
of
things
have
been
moved
from
Python
to
C++
I
had
implemented
a
I
had
implemented
a
Python
version
of
the
tree
C++
file,
and
it
was
about
maybe
10
times
faster
than
the
current
Python
implementation.
So
at
that
point,
I
was
just
realized.
E
G
F
I
E
A
D
D
E
D
Versus
like
three
do
one
inversion
like
it
wasn't
even
hard
for
large
scale,
I
think
that
would
be
like
Colonel,
because
I
think
we
can
think
about
that
because
previous
toffee
version
yeah
it
was
just
too
slow
and
want
to
jump
in,
but
I
think
it
seems
like
now
we're
set
up
because
of
your
boring
and
like
yeah.
You
see
a
lot
of.