def velocity_calc(OBJ,i,time,hstep,side,rs): #used
#LA=la()
[i_OBJ,i_next] = i_slr(i,side=side)
v_pos_l = OBJ.v_l_stat_func_tot(i_OBJ,time)
v_pos_r = OBJ.v_r_stat_func_tot(i_OBJ,time)
n = np.cross(v_pos_r,v_pos_l)
n = LA.unit(n)
if side=='l':
v_pos = v_pos_l
elif side=='r':
v_pos = v_pos_r
pos_OBJ = np.array(OBJ.putp(i_OBJ,time))
pos_next = np.array(OBJ.putp(i_next,time))
pos_OBJ_h = np.array(OBJ.putp(i_OBJ,time+np.float64(hstep)))
pos_next_h = np.array(OBJ.putp(i_next,time+np.float64(hstep)))
v = ((pos_next_h-pos_next) - (pos_OBJ_h - pos_OBJ))/hstep
v_out = n*(np.dot(v,n))
v_arm = v*(np.dot(LA.unit(v),LA.unit(v_pos)))
v_in = v - v_out - v_arm
v_out_sign = np.sign(np.dot(v_out,n))
v_arm_sign = np.sign(np.dot(LA.unit(v),LA.unit(v_pos)))
v_in_sign = np.sign(np.dot(v_in,v_pos_r - v_pos_l))
v_out_mag = np.linalg.norm(v_out)*v_out_sign
v_in_mag = np.linalg.norm(v_in)*v_in_sign
v_arm_mag = np.linalg.norm(v_arm)*v_arm_sign
ret = [v,v_in,v_out,v_arm,v_in_mag,v_out_mag,v_arm_mag]
return ret[rs]
def relativistic_aberrations(OBJ,i,t,tdel,side,relativistic=True): #used
[i_self,i_left,i_right] = i_slr(i)
if OBJ.calc_method=='Abram':
tdel0=0
elif OBJ.calc_method=='Waluschka':
tdel0 = tdel
if side=='l':
u_not_ab = np.array(OBJ.putp(i_self,t-tdel0)) - np.array(OBJ.putp(i_left,t-tdel))
u_ab = np.linalg.norm(u_not_ab)*(LA.unit(LA.unit(u_not_ab)*OBJ.c+(OBJ.vel.abs(i_self,t-tdel0) - OBJ.vel.abs(i_left,t-tdel))))
elif side=='r':
u_not_ab = np.array(OBJ.putp(i_self,t-tdel0)) - np.array(OBJ.putp(i_right,t-tdel))
u_ab = np.linalg.norm(u_not_ab)*(LA.unit(LA.unit(u_not_ab)*OBJ.c+(OBJ.vel.abs(i_self,t-tdel0) - OBJ.vel.abs(i_right,t-tdel))))
if relativistic==False:
return u_ab
elif relativistic==True:
coor = methods.coor_SC(OBJ,i_self,t-tdel0)
if side=='l':
velo = (OBJ.vel.abs(i_self,t-tdel0) - OBJ.vel.abs(i_left,t-tdel))
elif side=='r':
velo = (OBJ.vel.abs(i_self,t-tdel0) - OBJ.vel.abs(i_right,t-tdel))
c_vec = LA.unit(u_not_ab)*c
r = coor[0]
x_prime = LA.unit(velo)
n_prime = LA.unit(np.cross(velo,r))
r_prime = LA.unit(np.cross(n_prime,x_prime))
coor_velo = np.array([r_prime,n_prime,x_prime])
c_velo = LA.matmul(coor_velo,c_vec)
v = np.linalg.norm(velo)
den = 1.0 - ((v/(c**2))*coor_velo[2])
num = ((1.0-((v**2)/(c**2)))**0.5)
ux_prime = (c_velo[2] - v)/den
ur_prime = (num*c_velo[0])/den
un_prime = (num*c_velo[1])/den
c_prime = ux_prime*x_prime + un_prime*n_prime +ur_prime*r_prime
u_new=LA.unit(c_prime)*np.linalg.norm(u_not_ab)
return u_new
def PAA_func(self):
print('')
print('Importing Orbit')
tic = time.clock()
Orbit = ORBIT(input_param=self.input_param)
print(str(Orbit.linecount) + ' datapoints')
self.orbit = Orbit
utils.LISA_obj(self, type_select=self.LISA_opt)
print('Done in ' + str(time.clock() - tic))
self.SC = range(1, 4)
self.putp_sampled = pointLISA.methods.get_putp_sampled(self)
# Calculations
#LA=utils.la()
v_l_func_tot = []
v_r_func_tot = []
u_l_func_tot = []
u_r_func_tot = []
u_l0test_func_tot = []
u_r0test_func_tot = []
L_sl_func_tot = []
L_sr_func_tot = []
L_rl_func_tot = []
L_rr_func_tot = []
v_l_stat_func_tot = []
v_r_stat_func_tot = []
pos_func = []
#--- Obtaining Velocity
utils.velocity_func(self, hstep=self.hstep)
utils.velocity_abs(self, hstep=self.hstep)
for i in range(1, 4):
[[v_l_func, v_r_func, u_l_func, u_r_func],
[L_sl_func, L_sr_func, L_rl_func, L_rr_func],
[u_l0_func,
u_r0_func]] = utils.send_func(self,
i,
calc_method=self.calc_method)
v_l_func_tot.append(v_l_func)
v_r_func_tot.append(v_r_func)
u_l_func_tot.append(u_l_func)
u_r_func_tot.append(u_r_func)
u_l0test_func_tot.append(u_l0_func)
u_r0test_func_tot.append(u_r0_func)
L_sl_func_tot.append(L_sl_func)
L_sr_func_tot.append(L_sr_func)
L_rl_func_tot.append(L_rl_func)
L_rr_func_tot.append(L_rr_func)
[i_self, i_left, i_right] = utils.i_slr(i)
v_l_stat_func_tot.append(utils.get_armvec_func(self, i_self, 'l'))
v_r_stat_func_tot.append(utils.get_armvec_func(self, i_self, 'r'))
pos_func.append(utils.func_pos(self, i))
self.v_l_func_tot = utils.func_over_sc(v_l_func_tot)
self.v_r_func_tot = utils.func_over_sc(v_r_func_tot)
self.u_l_func_tot = utils.func_over_sc(u_l_func_tot)
self.u_r_func_tot = utils.func_over_sc(u_r_func_tot)
self.u_l0test_func_tot = utils.func_over_sc(u_l0test_func_tot)
self.u_r0test_func_tot = utils.func_over_sc(u_r0test_func_tot)
self.L_sl_func_tot = utils.func_over_sc(L_sl_func_tot)
self.L_sr_func_tot = utils.func_over_sc(L_sr_func_tot)
self.L_rl_func_tot = utils.func_over_sc(L_rl_func_tot)
self.L_rr_func_tot = utils.func_over_sc(L_rr_func_tot)
self.v_l_stat_func_tot = utils.func_over_sc(v_l_stat_func_tot)
self.v_r_stat_func_tot = utils.func_over_sc(v_r_stat_func_tot)
self.n_func = lambda i, t: LA.unit(
np.cross(self.v_l_stat_func_tot(i, t), self.v_r_stat_func_tot(
i, t)))
self.r_func = lambda i, t: utils.r_calc(self.v_l_stat_func_tot(
i, t), self.v_r_stat_func_tot(i, t), i)
self.pos_func = utils.func_over_sc(pos_func)
self.v_l_in_func_tot = lambda i, t: LA.inplane(self.v_l_func_tot(i, t),
self.n_func(i, t))
self.v_r_in_func_tot = lambda i, t: LA.inplane(self.v_r_func_tot(i, t),
self.n_func(i, t))
self.u_l_in_func_tot = lambda i, t: LA.inplane(self.u_l_func_tot(i, t),
self.n_func(i, t))
self.u_r_in_func_tot = lambda i, t: LA.inplane(self.u_r_func_tot(i, t),
self.n_func(i, t))
self.v_l_out_func_tot = lambda i, t: LA.outplane(
self.v_l_func_tot(i, t), self.n_func(i, t))
self.v_r_out_func_tot = lambda i, t: LA.outplane(
self.v_r_func_tot(i, t), self.n_func(i, t))
self.u_l_out_func_tot = lambda i, t: LA.outplane(
self.u_l_func_tot(i, t), self.n_func(i, t))
self.u_r_out_func_tot = lambda i, t: LA.outplane(
self.u_r_func_tot(i, t), self.n_func(i, t))
#--- Obtaining PAA ---
print('Aberration: ' + str(self.aberration))
selections = ['l_in', 'l_out', 'r_in', 'r_out']
PAA_func_val = {}
PAA_func_val[
selections[0]] = lambda i, t: utils.calc_PAA_lin(self, i, t)
PAA_func_val[
selections[1]] = lambda i, t: utils.calc_PAA_lout(self, i, t)
PAA_func_val[
selections[2]] = lambda i, t: utils.calc_PAA_rin(self, i, t)
PAA_func_val[
selections[3]] = lambda i, t: utils.calc_PAA_rout(self, i, t)
PAA_func_val['l_tot'] = lambda i, t: utils.calc_PAA_ltot(self, i, t)
PAA_func_val['r_tot'] = lambda i, t: utils.calc_PAA_rtot(self, i, t)
self.PAA_func = PAA_func_val
self.ang_breathing_din = lambda i, time: LA.angle(
self.v_l_func_tot(i, time), self.v_r_func_tot(i, time))
self.ang_breathing_in = lambda i, time: LA.angle(
self.u_l_func_tot(i, time), self.u_r_func_tot(i, time))
self.ang_breathing_stat = lambda i, time: LA.angle(
self.v_l_stat_func_tot(i, time), self.v_r_stat_func_tot(i, time))
self.ang_in_l = lambda i, t: LA.ang_in(self.v_l_func_tot(
i, t), self.n_func(i, t), self.r_func(i, t))
self.ang_in_r = lambda i, t: LA.ang_in(self.v_r_func_tot(
i, t), self.n_func(i, t), self.r_func(i, t))
self.ang_out_l = lambda i, t: LA.ang_out(self.v_l_func_tot(i, t),
self.n_func(i, t))
self.ang_out_r = lambda i, t: LA.ang_out(self.v_r_func_tot(i, t),
self.n_func(i, t))
return self
