Как уменьшить отклонение при расчете квадратичного значения из интерполированного набора данных? ⇐ Python

[Anonymous]

Я написал программу Python, которая вычисляет прочность полученного сигнала антенны, передающуюся с движущимся передатчиком. Данные по траектории для передатчика не распределены по равномерным, и требования к проекту требуют, чтобы я интерполировал его. Программа написана таким образом, чтобы пользователь мог выбрать скорость дискретизации интерполяции.
Существует квадратный термин в формуле силы сигнала, который рассчитывается из Положение передачи. Я заметил, что этот термин существенно варьируется, когда скорость дискретизации варьируется, что, как я предполагаю, связано с тем, что небольшие отклонения в интерполяции приводят к экспоненциальным изменениям в этом термине. < /P>
У меня мало Наука данных/опыт Scipy, поэтому я не уверен, как сгладить эти данные - честно говоря, я даже не уверен, какие ключевые слова для Google для этого.
Мой код интерполяции следующие - примечание что уникальные вещи, потому что пользователь также выбирает время траектории, которую он хочет рассчитать для повышения производительности: < /p>
def interp_position(times, sample_rate, position_vector, start_time=0, end_time= None, coord_system = "spherical",new_times=None):
#times with parameterized sample rate
if end_time is None:
end_time = times[-1]
if new_times is None:
new_times = np.arange(times[0], times[-1],1/sample_rate)

position_vector[:, 1] = np.radians(position_vector[:, 1])
position_vector[:, 2] = np.radians(position_vector[:, 2])

# Find the indices corresponding to the time interval
unique_indices = np.unique(times, return_index=True)[1]
times = times[unique_indices]
position_vector = position_vector[unique_indices]

interval_indices = np.where((new_times >= start_time) & (new_times
Термин, который квадрат в конечной формуле рассчитывается так: < /p>
def clip_norm_dots(vec1, vec2):
return np.clip(np.einsum('ij,ij->i',vec1, vec2),0,0.9999)
def unit_vector(vector):
return vector / np.linalg.norm(vector)
def get_polarization_loss(receiver, source, separation):

receiver_hat = unit_vector(receiver)
source_hat = unit_vector(source)
separation_hat = unit_vector(separation)
dot_rs = clip_norm_dots(receiver_hat,source_hat)
dot_rsep = clip_norm_dots(receiver_hat,separation_hat)
dot_ssep = clip_norm_dots(source_hat,separation_hat)
denominator = np.sqrt(1-dot_rsep**2)*np.sqrt(1-dot_ssep**2)
denominator = np.maximum(denominator,1e-6)
ploss = (dot_rs - (dot_rsep*dot_ssep))/denominator
return ploss
< /code>
Где вектор разделения является вектором положения от Interp_position на заданном временном шаге. В качестве MRE, приемники и векторы исходных векторов могут быть установлены на: < /p>
receiver = np.array([1,0,0])
source = np.array([1,1,0])
< /code>
На моей машине максимальные квадратные коэффициенты Ploss, рассчитанные с частотой дискретизации 30, отклоненных от той, которая с частотой дискретизации 60 в 10. Я ищу лучший метод Чтобы свести к минимуму это отклонение. Код идентичен коду в interp_position (). < /P>
Вот как вызываются функции, и используются дополнительные функции. < /P>
traj_arrays = ny.read_traj_data("Traj_Right.txt")
times = ny.get_times(traj_arrays)
positions = np.zeros((len(times),len(Receiver),3))
for i in range(len(Receiver)):
positions[:,i] = ny.get_spherical_position(coords[0], coords[1], traj_arrays)
losses = np.zeros((len(times_interp),len(Receiver),2))
for i in range(len(Receiver)):
losses[:,i,0] = ut.get_polarization_loss(receivers_ew,transmitters_aligned,positions_interp_cartesian[:,i])
losses[:,i,1] = ut.get_polarization_loss(receivers_ns,transmitters_aligned,positions_interp_cartesian[:,i])
< /code>
Дополнительные соответствующие функции: < /p>
def s_c_vec_conversion(spherical_vec):
x = spherical_vec[0] * np.sin(spherical_vec[1]) * np.cos(spherical_vec[2])
y = spherical_vec[0] * np.sin(spherical_vec[1]) * np.sin(spherical_vec[2])
z = spherical_vec[0] * np.cos(spherical_vec[1])
return np.array([x, y, z])
# cartesian to spherical
def c_s_vec_conversion(cartesian_vec):
r = np.sqrt(cartesian_vec[0]**2+cartesian_vec[1]**2+cartesian_vec[2]**2)
theta = np.arccos(cartesian_vec[2]/r)
phi = np.arctan(cartesian_vec[1]/cartesian_vec[0])
return np.array([r,theta,phi])
def interp_time(times, sample_rate, start_time=0, end_time=None):
if end_time is None:
end_time = times[-1]
new_times = np.arange(times[0], times[-1],1/sample_rate)
interval_indices = np.where((new_times >= start_time) & (new_times

Подробнее здесь: https://stackoverflow.com/questions/794 ... lated-data