def calc(xi):
p3_ks_pip, p3_ks_pim, p4ks, lam_ks = xi[:, :
3], xi[:,
3:6], xi[:, 6:
10], xi[:,
10:15]
p4_ks_pip, p4_ks_pim = [p3top4(p, mpi) for p in [p3_ks_pip, p3_ks_pim]]
p3_phi_pip, p3_phi_pim, p4phi, lam_phi = xi[:, 15:
18], xi[:, 18:
21], xi[:, 21:
25], xi[:,
25:
30]
p4_phi_pip, p4_phi_pim = [
p3top4(p, mpi) for p in [p3_phi_pip, p3_phi_pim]
]
p4d0, lam_d0 = xi[:, 30:34], xi[:, 34:39]
grad = cascade_gradient(p3_ks_pip0, p3_ks_pim0, p4_ks_pip, p4_ks_pim,
p4ks, lam_ks, p3_phi_pip0, p3_phi_pim0,
p4_phi_pip, p4_phi_pim, p4phi, lam_phi, p4d0,
lam_d0, covInv)
hess = cascade_hessian(p4_ks_pip, p4_ks_pim, p4ks, lam_ks, p4_phi_pip,
p4_phi_pim, p4phi, lam_phi, p4d0, lam_d0,
covInv)
return (p4_ks_pip, p4_ks_pim, p4_phi_pip, p4_phi_pim, grad, hess)
def plot_pipi_mass(xi):
""" """
pi4p = p3top4(xi[:, 0:3], MASS_DICT['pi+'])
pi4m = p3top4(xi[:, 3:6], MASS_DICT['pi+'])
m = mass_sq(pi4p + pi4m)**0.5
if np.std(m) < 0.000001:
return
x, bins, e = make_hist(m) #, range=[497, 498])
plt.figure(figsize=(6, 5))
plt.errorbar(x, bins, e, linestyle='none', marker='.', markersize=4)
plt.grid()
plt.xlabel(r'$m(\pi^+\pi^-)$ (MeV)', fontsize=16)
plt.tight_layout()
def calc(xi):
p3pip, p3pim, p4ks, lam = xi[:, :3], xi[:, 3:6], xi[:, 6:10], xi[:,
10:]
p4pip, p4pim = [p3top4(p, mpi) for p in [p3pip, p3pim]]
grad = gradient(p3pip0, p3pim0, p4pip, p4pim, p4ks, covInv, lam)
hess = hessian(p4pip, p4pim, p4ks, covInv, lam)
return (p4pip, p4pim, grad, hess)
def plot_conservation(xi):
""" """
pi4p = p3top4(xi[:, 0:3], MASS_DICT['pi+'])
pi4m = p3top4(xi[:, 3:6], MASS_DICT['pi+'])
m = pi4m + pi4p - xi[:, 6:10]
plt.figure(figsize=(6, 5))
for i in range(4):
x, bins, e = make_hist(m[:, i])
plt.errorbar(x, bins, e, linestyle='none',
marker='.', markersize=4, label=i)
plt.legend()
plt.grid()
plt.xlabel(r'$Conservation$ (MeV)', fontsize=16)
plt.tight_layout()
def cascade_unpack(xi):
p3_ks_pip, p3_ks_pim, p4ks = xi[:, :3], xi[:, 3:6], xi[:, 6:10]
p4_ks_pip, p4_ks_pim = [
eg.p3top4(p, eg.MASS_DICT['pi+']) for p in [p3_ks_pip, p3_ks_pim]
]
e_ks_pip = p4_ks_pip[:, 0].reshape(-1, 1)
e_ks_pim = p4_ks_pim[:, 0].reshape(-1, 1)
p3_phi_pip, p3_phi_pim, p4phi = xi[:, 10:13], xi[:, 13:16], xi[:, 16:20]
p4_phi_pip, p4_phi_pim = [
eg.p3top4(p, eg.MASS_DICT['pi+']) for p in [p3_phi_pip, p3_phi_pim]
]
e_phi_pip = p4_phi_pip[:, 0].reshape(-1, 1)
e_phi_pim = p4_phi_pim[:, 0].reshape(-1, 1)
p4d0 = xi[:, 20:24]
return p4_ks_pip, p4_ks_pim, p4ks, e_ks_pip, e_ks_pim, \
p4_phi_pip, p4_phi_pim, p4phi, e_phi_pip, e_phi_pim, p4d0
def fit_to_ks(p3pip, p3pim, cov, nit=5):
""" cov [3 x 3] """
N = p3pip.shape[0]
mpi = MASS_DICT['pi+']
p3pip0, p3pim0 = p3pip.copy(), p3pim.copy()
p4pip, p4pim = [p3top4(p, mpi) for p in [p3pip, p3pim]]
p4ks = p4pip + p4pim
covInv = np.linalg.inv(cov)
print('Inverse covariance\n{}'.format(covInv))
print('N = {}'.format(N))
lam = 1 * np.ones((N, 5))
logs = {key: [] for key in ['chi2', 'xi', 'grad', 'hess', 'det', 'cov']}
def save_log(xi, p4pip, p4pim, grad, hess):
logs['chi2'].append(chi2(p3pip0, p3pim0, p4pip, p4pim, covInv))
logs['xi'].append(xi[:, :10].copy())
logs['grad'].append(grad.copy())
logs['hess'].append(hess.copy())
logs['det'].append(np.linalg.det(hess))
logs['cov'].append(2 * np.linalg.inv(hess))
def calc(xi):
p3pip, p3pim, p4ks, lam = xi[:, :3], xi[:, 3:6], xi[:, 6:10], xi[:,
10:]
p4pip, p4pim = [p3top4(p, mpi) for p in [p3pip, p3pim]]
grad = gradient(p3pip0, p3pim0, p4pip, p4pim, p4ks, covInv, lam)
hess = hessian(p4pip, p4pim, p4ks, covInv, lam)
return (p4pip, p4pim, grad, hess)
xi = np.column_stack([p3pip, p3pim, p4ks, lam])
for iter in range(nit):
print('Iteration {}'.format(iter))
p4pip, p4pim, grad, hess = calc(xi)
save_log(xi, p4pip, p4pim, grad, hess)
xi -= np.einsum('kij, ki -> kj', np.linalg.inv(hess), grad)
p4pip, p4pim, grad, hess = calc(xi)
save_log(xi, p4pip, p4pim, grad, hess)
return logs
def unpack(xi):
p3pip, p3pim, p4ks = xi[:, :3], xi[:, 3:6], xi[:, 6:10]
p4pip, p4pim = [eg.p3top4(p, eg.MASS_DICT['pi+']) for p in [p3pip, p3pim]]
epip = p4pip[:, 0].reshape(-1, 1)
epim = p4pim[:, 0].reshape(-1, 1)
return (p3pip, p3pim, p4ks, p4pip, p4pim, epip, epim)
def pfit_to_d0(p3_ks_pip,
p3_ks_pim,
p3_phi_pip,
p3_phi_pim,
cov,
nit=5,
gpit=3,
gmit=3):
""" Progressive mass-constrained fit for D0 -> Ks Phi """
md0, mphi, mks, mpi = [
eg.MASS_DICT[key] for key in ['D0', 'phi', 'K0_S', 'pi+']
]
N = p3_ks_pip.shape[0]
covInv = np.linalg.inv(cov)
p3_ks_pip0, p3_ks_pim0, p3_phi_pip0, p3_phi_pim0 = p3_ks_pip.copy(
), p3_ks_pim.copy(), p3_phi_pip.copy(), p3_phi_pim.copy()
p4_ks_pip, p4_ks_pim, p4_phi_pip, p4_phi_pim = [
eg.p3top4(p, mpi)
for p in [p3_ks_pip, p3_ks_pim, p3_phi_pip, p3_phi_pim]
]
p4ks = p4_ks_pip + p4_ks_pim
p4phi = p4_phi_pip + p4_phi_pim
p4d0 = p4ks + p4phi
ndim = 24
Ck = np.zeros((N, ndim, ndim))
Ck[:] = 10**3 * np.eye(ndim) * eg.UNIT**2
xi = np.column_stack(
[p3_ks_pip, p3_ks_pim, p4ks, p3_phi_pip, p3_phi_pim, p4phi, p4d0])
logs = {key: [] for key in ['xi', 'cov', 'chi2', 'mk', 'chi2v0']}
xi0 = xi.copy()
logs['xi'].append(xi.copy())
for idx in range(nit):
print('Iteration {}'.format(idx + 1))
Ck = np.zeros((N, ndim, ndim))
Ck[:] = 10**4 * np.eye(ndim) * eg.UNIT**2
chi2 = np.zeros(N)
# Apply pi+ momentum measurement constraint #
Hk = np.zeros((N, 3, ndim))
Hk[:, :, :3] = np.eye(3)
rk = xi[:, :3] - xi0[:, :3]
dxi, Ck, chi2k = apply_meas(Hk, -rk, cov, Ck)
xi += dxi
chi2 += chi2k
# Apply pi- momentum measurement constraint #
Hk = np.zeros((N, 3, ndim))
Hk[:, :, 3:6] = np.eye(3)
rk = xi[:, 3:6] - xi0[:, 3:6]
dxi, Ck, chi2k = apply_meas(Hk, -rk, cov, Ck)
xi += dxi
chi2 += chi2k
# Apply pi+ momentum measurement constraint #
Hk = np.zeros((N, 3, ndim))
Hk[:, :, 10:13] = np.eye(3)
rk = xi[:, 10:13] - xi0[:, 10:13]
dxi, Ck, chi2k = apply_meas(Hk, -rk, cov, Ck)
xi += dxi
chi2 += chi2k
# Apply pi- momentum measurement constraint #
Hk = np.zeros((N, 3, ndim))
Hk[:, :, 13:16] = np.eye(3)
rk = xi[:, 13:16] - xi0[:, 13:16]
dxi, Ck, chi2k = apply_meas(Hk, -rk, cov, Ck)
xi += dxi
chi2 += chi2k
# momentum conservation constraint #
p4_ks_pip, p4_ks_pim, p4ks, _, _, _, _, _, _, _, _ = cascade_unpack(xi)
gp_const = rf.gmomentum(p4_ks_pip, p4_ks_pim, p4ks)
for _ in range(gpit):
p4_ks_pip, p4_ks_pim, p4ks, e_ks_pip, e_ks_pim, _, _, _, _, _, _ = cascade_unpack(
xi)
gp = rf.gmomentum(p4_ks_pip, p4_ks_pim, p4ks)
Gk = np.zeros((N, 4, ndim))
Gk[:, 0, :3] = -p4_ks_pip[:, 1:4] / e_ks_pip
Gk[:, 0, 3:6] = -p4_ks_pim[:, 1:4] / e_ks_pim
Gk[:, 1:, :3] = Gk[:, 1:, 3:6] = -np.eye(3)
Gk[:, :, 6:10] = np.eye(4)
GCGTInv = gcgtinv(Gk, Ck)
Kk = gain_exact(Ck, Gk, GCGTInv)
xi += xi_upd(Kk, gp)
Ck = covariance_exact(Ck, Kk, Gk)
chi2 += et.chi2_item(gp_const, GCGTInv)
#=================================================================================
# momentum conservation constraint #
_, _, _, _, _, p4_phi_pip, p4_phi_pim, p4phi, e_phi_pip, e_phi_pim, p4d0 = cascade_unpack(
xi)
gp_const = rf.gmomentum(p4_phi_pip, p4_phi_pim, p4phi)
for _ in range(gpit):
_, _, _, _, _, p4_phi_pip, p4_phi_pim, p4phi, e_phi_pip, e_phi_pim, p4d0 = cascade_unpack(
xi)
gp = rf.gmomentum(p4_phi_pip, p4_phi_pim, p4phi)
Gk = np.zeros((N, 4, ndim))
Gk[:, 0, 10:13] = -p4_phi_pip[:, 1:4] / e_phi_pip
Gk[:, 0, 13:16] = -p4_phi_pim[:, 1:4] / e_phi_pim
Gk[:, 1:, 10:13] = Gk[:, 1:, 13:16] = -np.eye(3)
Gk[:, :, 16:20] = np.eye(4)
GCGTInv = gcgtinv(Gk, Ck)
Kk = gain_exact(Ck, Gk, GCGTInv)
xi += xi_upd(Kk, gp)
Ck = covariance_exact(Ck, Kk, Gk)
chi2 += et.chi2_item(gp_const, GCGTInv)
# momentum conservation constraint #
_, _, p4ks, _, _, _, _, p4phi, _, _, p4d0 = cascade_unpack(xi)
gp_const = rf.gmomentum(p4ks, p4phi, p4d0)
for _ in range(gpit):
_, _, p4ks, _, _, _, _, p4phi, _, _, p4d0 = cascade_unpack(xi)
gp = rf.gmomentum(p4ks, p4phi, p4d0)
Gk = np.zeros((N, 4, ndim))
Gk[:, :, 6:10] = -np.eye(4)
Gk[:, :, 16:20] = -np.eye(4)
Gk[:, :, 20:] = np.eye(4)
GCGTInv = gcgtinv(Gk, Ck)
Kk = gain_exact(Ck, Gk, GCGTInv)
xi += xi_upd(Kk, gp)
Ck = covariance_exact(Ck, Kk, Gk)
chi2 += et.chi2_item(gp_const, GCGTInv)
def gmass(mass, p4):
return mass**2 - rf.mass_sq(p4)
# mass constraint #
_, _, p4ks, _, _, _, _, p4phi, _, _, p4d0 = cascade_unpack(xi)
gm_const = gmass(mks, p4ks).reshape(-1, 1)
for _ in range(gmit):
print('Mass iteration {}'.format(_ + 1))
_, _, p4ks, _, _, _, _, p4phi, _, _, p4d0 = cascade_unpack(xi)
gm = gmass(mks, p4ks).reshape(-1, 1)
Gk = np.zeros((N, 1, ndim))
Gk[:, 0, 6:10] = 2 * np.einsum('ki, i -> ki', p4ks,
np.array([-1, 1, 1, 1]))
GCGTInv = gcgtinv(Gk, Ck)
Kk = gain_exact(Ck, Gk, GCGTInv)
xi += xi_upd(Kk, gm)
Ck = covariance_exact(Ck, Kk, Gk)
chi2 += et.chi2_item(gm_const, GCGTInv)
_, _, p4ks, _, _, _, _, p4phi, _, _, p4d0 = cascade_unpack(xi)
gm_const = gmass(mphi, p4phi).reshape(-1, 1)
for _ in range(gmit):
print('Mass iteration {}'.format(_ + 1))
_, _, p4ks, _, _, _, _, p4phi, _, _, p4d0 = cascade_unpack(xi)
gm = gmass(mphi, p4phi).reshape(-1, 1)
Gk = np.zeros((N, 1, ndim))
Gk[:, 0, 16:20] = 2 * np.einsum('ki, i -> ki', p4phi,
np.array([-1, 1, 1, 1]))
GCGTInv = gcgtinv(Gk, Ck)
Kk = gain_exact(Ck, Gk, GCGTInv)
xi += xi_upd(Kk, gm)
Ck = covariance_exact(Ck, Kk, Gk)
chi2 += et.chi2_item(gm_const, GCGTInv)
_, _, p4ks, _, _, _, _, p4phi, _, _, p4d0 = cascade_unpack(xi)
gm_const = gmass(md0, p4d0).reshape(-1, 1)
for _ in range(gmit):
print('Mass iteration {}'.format(_ + 1))
_, _, p4ks, _, _, _, _, p4phi, _, _, p4d0 = cascade_unpack(xi)
gm = gmass(md0, p4d0).reshape(-1, 1)
Gk = np.zeros((N, 1, ndim))
Gk[:, 0, 20:24] = 2 * np.einsum('ki, i -> ki', p4d0,
np.array([-1, 1, 1, 1]))
GCGTInv = gcgtinv(Gk, Ck)
Kk = gain_exact(Ck, Gk, GCGTInv)
xi += xi_upd(Kk, gm)
Ck = covariance_exact(Ck, Kk, Gk)
chi2 += et.chi2_item(gm_const, GCGTInv)
# write log #
_, _, p4ks, _, _, _, _, p4phi, _, _, p4d0 = cascade_unpack(xi)
logs['xi'].append(xi.copy())
logs['cov'].append(Ck.copy())
# logs['chi2v0'].append(rf.chi2(p3pip0, p3pim0, p4pip, p4pim, covInv))
logs['chi2'].append(chi2)
logs['mk'].append(eg.mass(p4ks))
# print('Final Ck\n{}'.format(Ck[0]))
return logs
def pfit_to_ks(p3pip, p3pim, cov, nit=5, gpit=3, gmit=3):
""" Progressive mass-constrained fit for Ks0 -> pi+ pi- """
mpi = eg.MASS_DICT['pi+']
N = p3pip.shape[0]
covInv = np.linalg.inv(cov)
p3pip0, p3pim0 = p3pip.copy(), p3pim.copy()
p4pip, p4pim = [eg.p3top4(p, mpi) for p in [p3pip, p3pim]]
p4ks = p4pip + p4pim
ndim = 10
Ck = np.zeros((N, ndim, ndim))
Ck[:] = 10**3 * np.eye(ndim) * eg.UNIT**2
xi = np.column_stack([p3pip, p3pim, p4ks])
logs = {key: [] for key in ['xi', 'cov', 'chi2', 'mk', 'chi2v0']}
xi0 = xi.copy()
_, _, p4ks, p4pip, p4pim, _, _ = unpack(xi)
logs['xi'].append(xi.copy())
for idx in range(nit):
print('Iteration {}'.format(idx + 1))
Ck = np.zeros((N, ndim, ndim))
Ck[:] = 10**4 * np.eye(ndim) * eg.UNIT**2
chi2 = np.zeros(N)
# Apply pi+ momentum measurement constraint #
Hk = np.zeros((N, 3, ndim))
Hk[:, :, :3] = np.eye(3)
rk = xi[:, :3] - xi0[:, :3]
dxi, Ck, chi2k = apply_meas(Hk, -rk, cov, Ck)
xi += dxi
chi2 += chi2k
# Apply pi- momentum measurement constraint #
Hk = np.zeros((N, 3, ndim))
Hk[:, :, 3:6] = np.eye(3)
rk = xi[:, 3:6] - xi0[:, 3:6]
dxi, Ck, chi2k = apply_meas(Hk, -rk, cov, Ck)
xi += dxi
chi2 += chi2k
# momentum conservation constraint #
gp_const = rf.gmomentum(p4pip, p4pim, p4ks)
for _ in range(gpit):
p3pip, p3pim, p4ks, p4pip, p4pim, epip, epim = unpack(xi)
gp = rf.gmomentum(p4pip, p4pim, p4ks)
Gk = np.zeros((N, 4, ndim))
Gk[:, 0, :3] = -p3pip / epip
Gk[:, 0, 3:6] = -p3pim / epim
Gk[:, 1:, :3] = Gk[:, 1:, 3:6] = -np.eye(3)
Gk[:, :, 6:] = np.eye(4)
GCGTInv = gcgtinv(Gk, Ck)
Kk = gain_exact(Ck, Gk, GCGTInv)
xi += xi_upd(Kk, gp)
# _, _, p4ks, p4pip, p4pim, _, _ = unpack(xi)
Ck = covariance_exact(Ck, Kk, Gk)
chi2 += et.chi2_item(gp_const, GCGTInv)
def gmass(p4ks):
return rf.MASS_DICT['K0_S']**2 - rf.mass_sq(p4ks)
# mass constraint #
_, _, p4ks, p4pip, p4pim, _, _ = unpack(xi)
gm_const = gmass(p4ks).reshape(-1, 1)
for _ in range(gmit):
print('Mass iteration {}'.format(_ + 1))
_, _, p4ks, p4pip, p4pim, _, _ = unpack(xi)
gm = gmass(p4ks).reshape(-1, 1)
# gm = rf.gmass(p4pip, p4pim).reshape(-1, 1)
Gk = np.zeros((N, 1, ndim))
Gk[:, 0, 6:] = 2 * np.einsum('ki, i -> ki', p4ks,
np.array([-1, 1, 1, 1]))
GCGTInv = gcgtinv(Gk, Ck)
Kk = gain_exact(Ck, Gk, GCGTInv)
xi += xi_upd(Kk, gm)
# _, _, _, p4pip, p4pim, _, _ = unpack(xi)
Ck = covariance_exact(Ck, Kk, Gk)
chi2 += et.chi2_item(gm_const, GCGTInv)
# write log #
_, _, p4ks, p4pip, p4pim, _, _ = unpack(xi)
logs['xi'].append(xi.copy())
logs['cov'].append(Ck.copy())
# logs['chi2v0'].append(rf.chi2(p3pip0, p3pim0, p4pip, p4pim, covInv))
logs['chi2'].append(chi2)
logs['mk'].append(eg.mass(p4ks))
# print('Final Ck\n{}'.format(Ck[0]))
return logs
def fit_to_d0(p3_ks_pip, p3_ks_pim, p3_phi_pip, p3_phi_pim, cov, nit=5):
""" cov [3 x 3] """
N = p3_ks_pip.shape[0]
mks, mphi, mpi = MASS_DICT['K0_S'], MASS_DICT['phi'], MASS_DICT['pi+']
p3_ks_pip0, p3_ks_pim0 = p3_ks_pip.copy(), p3_ks_pim.copy()
p4_ks_pip, p4_ks_pim = [p3top4(p, mpi) for p in [p3_ks_pip, p3_ks_pim]]
p4ks = p4_ks_pip + p4_ks_pim
p3_phi_pip0, p3_phi_pim0 = p3_phi_pip.copy(), p3_phi_pim.copy()
p4_phi_pip, p4_phi_pim = [p3top4(p, mpi) for p in [p3_phi_pip, p3_phi_pim]]
p4phi = p4_phi_pip + p4_phi_pim
p4d0 = p4phi + p4ks
covInv = np.linalg.inv(cov)
print('Inverse covariance\n{}'.format(covInv))
print('N = {}'.format(N))
lam_ks = 1 * np.ones((N, 5))
lam_phi = 1 * np.ones((N, 5))
lam_d0 = 1 * np.ones((N, 5))
logs = {key: [] for key in ['chi2', 'xi', 'grad', 'hess', 'det', 'cov']}
def save_log(xi, p4_ks_pip, p4_ks_pim, p4_phi_pip, p4_phi_pim, grad, hess):
logs['chi2'].append(
cascade_chi2(p3_ks_pip0, p3_ks_pim0, p4_ks_pip, p4_ks_pim,
p3_phi_pip0, p3_phi_pim0, p4_phi_pip, p4_phi_pim,
covInv))
logs['xi'].append(xi[:, ].copy())
logs['grad'].append(grad.copy())
logs['hess'].append(hess.copy())
logs['det'].append(np.linalg.det(hess))
logs['cov'].append(2 * np.linalg.inv(hess))
def calc(xi):
p3_ks_pip, p3_ks_pim, p4ks, lam_ks = xi[:, :
3], xi[:,
3:6], xi[:, 6:
10], xi[:,
10:15]
p4_ks_pip, p4_ks_pim = [p3top4(p, mpi) for p in [p3_ks_pip, p3_ks_pim]]
p3_phi_pip, p3_phi_pim, p4phi, lam_phi = xi[:, 15:
18], xi[:, 18:
21], xi[:, 21:
25], xi[:,
25:
30]
p4_phi_pip, p4_phi_pim = [
p3top4(p, mpi) for p in [p3_phi_pip, p3_phi_pim]
]
p4d0, lam_d0 = xi[:, 30:34], xi[:, 34:39]
grad = cascade_gradient(p3_ks_pip0, p3_ks_pim0, p4_ks_pip, p4_ks_pim,
p4ks, lam_ks, p3_phi_pip0, p3_phi_pim0,
p4_phi_pip, p4_phi_pim, p4phi, lam_phi, p4d0,
lam_d0, covInv)
hess = cascade_hessian(p4_ks_pip, p4_ks_pim, p4ks, lam_ks, p4_phi_pip,
p4_phi_pim, p4phi, lam_phi, p4d0, lam_d0,
covInv)
return (p4_ks_pip, p4_ks_pim, p4_phi_pip, p4_phi_pim, grad, hess)
xi = np.column_stack([
p3_ks_pip, p3_ks_pim, p4ks, lam_ks, p3_phi_pip, p3_phi_pim, p4phi,
lam_phi, p4d0, lam_d0
])
for iter in range(nit):
print('Iteration {}'.format(iter))
p4_ks_pip, p4_ks_pim, p4_phi_pip, p4_phi_pim, grad, hess = calc(xi)
save_log(xi, p4_ks_pip, p4_ks_pim, p4_phi_pip, p4_phi_pim, grad, hess)
xi -= np.einsum('kij, ki -> kj', np.linalg.inv(hess), grad)
p4_ks_pip, p4_ks_pim, p4_phi_pip, p4_phi_pim, grad, hess = calc(xi)
save_log(xi, p4_ks_pip, p4_ks_pim, p4_phi_pip, p4_phi_pim, grad, hess)
return logs
