def test_start_northwards(self):
# data = (north, east, tvd, inc_lower, azi_lower)
# Turn to the north east
data = dogleg_toolface(np.pi / 2, 0., 2 * np.pi * 1 / 4, 0.002, 300)
assert data[0] > 0.0
assert data[1] > 0.0
assert data[2] == pytest.approx(0.0)
# Directly north and down
data = dogleg_toolface(np.pi / 2, 0., 2 * np.pi * 2 / 4, 0.002, 300)
assert data[0] > 0.0
assert data[1] == pytest.approx(0.0)
assert data[2] > 0.0
# Turn north west
data = dogleg_toolface(np.pi / 2, 0., 2 * np.pi * 3 / 4, 0.002, 300)
assert data[0] > 0.0
assert data[1] < 0.0
assert data[2] == pytest.approx(0.0)
# Directly north and upward, at 2pi toolface
data = dogleg_toolface(np.pi / 2, 0., 2 * np.pi * 4 / 4, 0.002, 300)
assert data[0] > 0.0
assert data[1] == pytest.approx(0.0)
assert data[2] < 0.0
# North and upward, at 0 toolface
data = dogleg_toolface(np.pi / 2, 0.0, 0.0, 0.002, 300)
assert data[0] > 0.0
assert data[1] == pytest.approx(0.0)
assert data[2] < 0.0
def test_start_southwards(self):
# print("From (pi/2, pi\n")
# South westwards
data = dogleg_toolface(np.pi / 2, np.pi, 2 * np.pi * 1 / 4, 0.002, 300)
assert data[0] < 0.0
assert data[1] < 0.0
assert data[2] == pytest.approx(0.0)
# Directly south and down
data = dogleg_toolface(np.pi / 2, np.pi, 2 * np.pi * 2 / 4, 0.002, 300)
assert data[0] < 0.0
assert data[1] == pytest.approx(0.0)
assert data[2] > 0
# South eastwards
data = dogleg_toolface(np.pi / 2, np.pi, 2 * np.pi * 3 / 4, 0.002, 300)
assert data[0] < 0.0
assert data[1] > 0.0
assert data[2] == pytest.approx(0.0)
# Directly south and up
data = dogleg_toolface(np.pi / 2, np.pi, 2 * np.pi * 4 / 4, 0.002, 300)
assert data[0] < 0.0
assert data[1] == pytest.approx(0.0)
assert data[2] < 0.0
# Directly south and up, toolface 0
data = dogleg_toolface(np.pi / 2, np.pi, 0.0, 0.002, 300)
assert data[0] < 0.0
assert data[1] == pytest.approx(0.0)
assert data[2] < 0.0
def test_straight_north_tf(self):
data = dogleg_toolface(np.pi / 2, 0.0, -1.0, 0.002, 300)
assert data[0] == pytest.approx(300)
assert data[1] == pytest.approx(0.0)
assert data[2] == pytest.approx(0.0)
assert data[3] == pytest.approx(np.pi / 2)
assert data[4] == pytest.approx(0.0)
def test_get_params_from_state_and_net_random(self):
for i in range(1, 1000):
inc0 = np.pi * random()
azi0 = random() * 2 * np.pi
dls = 0.001 + 0.004 * random()
md = 2 * np.pi / dls * random()
tf0 = random() * 2 * np.pi
north = -2000 + 4000 * random()
east = -2000 + 4000 * random()
tvd = -2000 + 4000 * random()
from_state = np.array([north, east, tvd, inc0, azi0])
to_state = dogleg_toolface(inc0, azi0, tf0, dls, md)
to_state[0] = to_state[0] + north
to_state[1] = to_state[1] + east
to_state[2] = to_state[2] + tvd
tf_calc, dls_calc, md_calc = get_params_from_state_and_net(
from_state, to_state[0:3])
assert tf_calc == pytest.approx(tf0)
assert dls_calc == pytest.approx(dls)
assert md_calc == pytest.approx(md)
def test_straight_up_tf(self):
data = dogleg_toolface(np.pi, 0.0, -1.0, 0.002, 300)
assert data[0] == pytest.approx(0.0)
assert data[1] == pytest.approx(0.0)
assert data[2] == pytest.approx(-300.0)
assert data[3] == pytest.approx(np.pi)
assert data[4] == pytest.approx(0.0)
def test_straight_down_tf(self):
data = dogleg_toolface(0.0, 0.0, -1.0, 0.002, 300)
assert data[0] == pytest.approx(0.0)
assert data[1] == pytest.approx(0.0)
assert data[2] == pytest.approx(300)
assert data[3] == pytest.approx(0.0)
assert data[4] == pytest.approx(0.0)
def test_addition(self):
# Verify addition identiy of gravity toolface
dls = 0.002
md = 300
eps = 1e-3
toolface_vals = np.linspace(0, 2 * np.pi, num=100)
azi_vals = np.linspace(0, 2 * np.pi, num=100)
for toolface in toolface_vals:
for azi in azi_vals:
full_step = dogleg_toolface(np.pi / 2, azi, toolface, dls, md)
part_step_1 = dogleg_toolface(np.pi / 2, azi, toolface, dls,
md / 2)
part_step_2 = dogleg_toolface(part_step_1[3], part_step_1[4],
toolface, dls, md / 2)
north = part_step_1[0] + part_step_2[0]
east = part_step_1[1] + part_step_2[1]
tvd = part_step_1[2] + part_step_2[2]
inc_lower = part_step_2[3]
azi_lower = part_step_2[4]
# Horribe foating point accuary with all this trigonometric wizardy
eps_pos = 1e-0
assert abs(full_step[0] - north) < eps_pos
assert abs(full_step[1] - east) < eps_pos
assert abs(full_step[2] - tvd) < eps_pos
dn_part = np.cos(azi_lower)
de_part = np.sin(azi_lower)
dn_full = np.cos(full_step[4])
de_full = np.sin(full_step[4])
eps_dir = 1e-2
assert abs(dn_full - dn_part) < eps_dir
assert abs(de_full - de_part) < eps_dir
assert abs(full_step[3] - inc_lower) < eps_dir
def test_start_circle(self):
# Circle east
dls = 0.002
r = 1 / dls
data = dogleg_toolface(np.pi / 2, 0., np.pi / 2, dls, 2 * np.pi * r)
print("n: ", data[0])
print("e: ", data[1])
print("t: ", data[2])
assert data[0] == pytest.approx(0.0)
assert data[1] == pytest.approx(0.0)
assert data[2] == pytest.approx(0.0)
# Circle west
dls = 0.002
r = 1 / dls
data = dogleg_toolface(np.pi / 2, 0., 2 * np.pi * 3 / 4, dls,
2 * np.pi * r)
assert data[0] == pytest.approx(0.0)
assert data[1] == pytest.approx(0.0)
assert data[2] == pytest.approx(0.0)
def test_compare_ode_linalg(self):
n_tries = 5
for i in range(0, n_tries):
inc0 = np.pi * random()
azi0 = 2 * np.pi * random()
dls = 0.002
md = 2 * np.pi / dls * random()
tf0 = 2 * np.pi * random()
state_circ = dogleg_toolface(inc0, azi0, tf0, dls, md)
state_ode, sol, z = dogleg_toolface_ode(inc0, azi0, tf0, dls, md,
False)
diff = state_circ - state_ode
assert sum(abs(diff)) < 1
def test_get_params_from_state_and_net_three_quarter_circle(self):
for i in range(1, 1000):
inc0 = np.pi * random()
azi0 = random() * 2 * np.pi
dls = 0.001 + 0.004 * random()
md = 2 * np.pi * 3 / 4 * 1 / dls
tf0 = random() * 2 * np.pi
from_state = np.array([0., 0., 0., inc0, azi0])
to_state = dogleg_toolface(inc0, azi0, tf0, dls, md)
tf_calc, dls_calc, md_calc = get_params_from_state_and_net(
from_state, to_state[0:3])
assert tf_calc == pytest.approx(tf0)
assert dls_calc == pytest.approx(dls)
assert md_calc == pytest.approx(md)
def test_get_params_from_state_and_net_lines(self):
for i in range(1, 100):
inc0 = np.pi * random()
azi0 = random() * 2 * np.pi
dls = 0.0
md = 1000 * random()
tf0 = -1
from_state = np.array([0., 0., 0., inc0, azi0])
to_state = dogleg_toolface(inc0, azi0, tf0, dls, md)
tf_calc, dls_calc, md_calc = get_params_from_state_and_net(
from_state, to_state[0:3])
assert tf_calc == pytest.approx(tf0)
assert dls_calc == pytest.approx(dls)
assert md_calc == pytest.approx(md)
def test_start_upwards(self):
# North east
data = dogleg_toolface(np.pi, 0., 2 * np.pi * 1 / 8, 0.001, 800)
assert data[0] > 0.0
assert data[1] > 0.0
assert data[2] < 0.0
# East
data = dogleg_toolface(np.pi, 0., 2 * np.pi * 1 / 4, 0.002, 300)
assert data[0] == pytest.approx(0.0)
assert data[1] > 0.0
assert data[2] < 0.0
# South
data = dogleg_toolface(np.pi, 0., 2 * np.pi * 2 / 4, 0.002, 300)
assert data[0] < 0.0
assert data[1] == pytest.approx(0.0)
assert data[2] < 0.0
# West
data = dogleg_toolface(np.pi, 0., 2 * np.pi * 3 / 4, 0.002, 300)
assert data[0] == pytest.approx(0.0)
assert data[1] < 0.0
assert data[2] < 0.0
# North
data = dogleg_toolface(np.pi, 0., 2 * np.pi * 4 / 4, 0.002, 300)
assert data[0] > 0.0
assert data[1] == pytest.approx(0.0)
assert data[2] < 0.0
# North, tf=0
data = dogleg_toolface(np.pi, 0., 0, 0.002, 300)
assert data[0] > 0.0
assert data[1] == pytest.approx(0.0)
assert data[2] < 0.0
# South east
data = dogleg_toolface(np.pi, 0., np.pi * 3 / 4, 0.002, 300)
assert data[0] < 0.0
assert data[1] > 0.0
assert data[2] < 0.0
def test_start_downwards(self):
# North east
data = dogleg_toolface(0., 0., 2 * np.pi * 1 / 8, 0.001, 800)
assert data[0] > 0.0
assert data[1] > 0.0
assert data[2] > 0.0
# East and down
data = dogleg_toolface(0., 0., 2 * np.pi * 1 / 4, 0.002, 300)
assert data[0] == pytest.approx(0.0)
assert data[1] > 0.0
assert data[2] > 0.0
# South and down
data = dogleg_toolface(0., 0., 2 * np.pi * 2 / 4, 0.002, 300)
assert data[0] < 0.0
assert data[1] == pytest.approx(0.0)
assert data[2] > 0.0
# West and down
data = dogleg_toolface(0., 0., 2 * np.pi * 3 / 4, 0.002, 300)
assert data[0] == pytest.approx(0.0)
assert data[1] < 0.0
assert data[2] > 0.0
# North and down
data = dogleg_toolface(0., 0., 2 * np.pi * 4 / 4, 0.002, 300)
assert data[0] > 0.0
assert data[1] == pytest.approx(0.0)
assert data[2] > 0.0
# North andf down, tf=0
segment = dogleg_toolface(0., 0., 0, 0.002, 300)
assert data[0] > 0.0
assert data[1] == pytest.approx(0.0)
assert data[2] > 0.0
# South east and down
data = dogleg_toolface(0., 0., np.pi * 3 / 4, 0.002, 300)
assert data[0] < 0.0
assert data[1] > 0.0
assert data[2] > 0.0
def test_azi_change(self):
# Go north and down so far that azi should flip
data = dogleg_toolface(np.pi / 4, 0., np.pi, 0.002, 1400)
assert data[1] == pytest.approx(0.0)
assert data[2] > 0.0
assert data[4] == pytest.approx(np.pi)
def project_sti(start_state, target_state, sti):
"""
Project a sti from start to target resulting
in a well trajectory
Parameters
----------
start_state : nd.array
(north, east, tvd, inc, azi) of start state
target_state : nd.array
(north, east, tvd, inc, azi) of target state
sti : nd.array
two intermediate cartesian positions layed out as
(n0, e0, t0, n1, e1, t1)
Returns
-------
projected_state : nd.array
(north, east, tvd, inc, azi) at end of trajectory
max_dls : float
maximum dog leg severity of trajectory
md : float
measured depth from start to target along trajectory
"""
# HACK Just thorwing something on the wall here to see if the
# new approach using intermediate points is better
# Intermediate (north, east, tvd)
intermed_net0 = sti[0:3]
intermed_net1 = sti[3:6]
# Find parameters from start to first intermediate point
tf0, dls0, md0 = get_params_from_state_and_net(start_state, intermed_net0)
intermed_state0 = dogleg_toolface(start_state[3], start_state[4], tf0,
dls0, md0)
# Dogleg toolface returns increments
intermed_state0[0] = intermed_state0[0] + start_state[0]
intermed_state0[1] = intermed_state0[1] + start_state[1]
intermed_state0[2] = intermed_state0[2] + start_state[2]
# Find paramters between intermediate states
tf1, dls1, md1 = get_params_from_state_and_net(intermed_state0,
intermed_net1)
intermed_state1 = dogleg_toolface(intermed_state0[3], intermed_state0[4],
tf1, dls1, md1)
# Dogleg toolface returns increments
intermed_state1[0] = intermed_state1[0] + intermed_state0[0]
intermed_state1[1] = intermed_state1[1] + intermed_state0[1]
intermed_state1[2] = intermed_state1[2] + intermed_state0[2]
# Find paramters between intermediate states
final_net = target_state[0:3]
tf2, dls2, md2 = get_params_from_state_and_net(intermed_state1, final_net)
# Max dls and total md
max_dls = max(dls0, dls1, dls2)
md = md0 + md1 + md2
# Projected state
projected_state = dogleg_toolface(intermed_state1[3], intermed_state1[4],
tf2, dls2, md2)
# Dogleg toolface returns increments
projected_state[0] = projected_state[0] + intermed_state1[0]
projected_state[1] = projected_state[1] + intermed_state1[1]
projected_state[2] = projected_state[2] + intermed_state1[2]
return projected_state, max_dls, md
