Wie reduzieren Sie die Abweichung bei der Berechnung des quadratischen Werts aus interpoliertem Datensatz? ⇐ Python

[Anonymous]

Ich habe ein Python -Programm geschrieben, das die empfangene Signalstärke einer mit einem bewegenden Sender kommunizierten Antenne berechnet. Die Flugbahndaten für den Sender sind nicht gleichmäßig verteilt, und Projektanforderungen erfordern, dass ich ihn interpolieren muss. Das Programm ist so geschrieben, dass der Benutzer die Stichprobenrate der Interpolation auswählen kann. Übertragungsposition. Ich habe festgestellt, dass dieser Begriff variiert, wenn die Stichprobenrate variiert wird, was ich davongte, dass kleine Abweichungen in der Interpolation zu exponentiellen Änderungen in diesem Begriff führen. Data Science/Scipy Experience, daher bin ich mir nicht sicher, wie ich diese Daten ausfassen soll. Ehrlich gesagt bin ich mir nicht einmal sicher, welche Schlüsselwörter für Google dafür sind. - - Beachten Sie, dass das einzigartige Zeitpunkt darin besteht

Code: Select all

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 
Der Begriff, der in der endgültigen Formel quadriert wird, wird so berechnet: < /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>
wobei der Trennungsvektor der Positionsvektor von interp_position zu einem bestimmten Zeitschritt ist. Als MRE können der Empfänger und die Quellvektoren auf: < /p>
eingestellt werdenreceiver = np.array([1,0,0])
source = np.array([1,1,0])
< /code>
Auf meiner Maschine wurden die maximalen Ploss -Quadratfaktoren mit einer Stichprobenrate von 30 berechnet, die von einer Probenrate von 60 um einen Faktor von 10 abgewichen ist. Ich suche nach der besten Methode Um diese Abweichung zu minimieren.  Der Code ist identisch mit dem Code in Interp_Position ().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[i][0], coords[i][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>
Zusätzliche relevante Funktionen: < /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