def get_ray_s(ray, s, badval=1.31072000e+05):
sar=sqrt(ray['xar']**2 + ray['yar']**2)
ht=ray['zar']
elements=list(mathematics.where_fits(s, sar))
point={}
if elements[0] ==len(sar)-1:
point.update(dict([(var, badval) for var in set([ 'i_comp', 'j_comp', 'k_comp', 'VE','VR', 'CZ', 'RH', 'PH', 'ZD', 'SW'])& set(ray.keys())]))
#point.update(dict([(var, badval) for var in set([ 'VE',])& set(ray.keys())]))
else:
#print elements
if sar[elements[1]]-sar[elements[0]]!=0:
w=1.0-abs((sar[elements]-s)/(sar[elements[1]]-sar[elements[0]]))
else:
w=[0.5,0.5]
#print w
my_ht=(ht[elements]*w).sum()
if not(badval in ray['VE'][elements]):
point.update(dict([(var,(ray[var][elements]*w).sum()) for var in [ 'i_comp', 'j_comp', 'k_comp', 'VE']]))
#point.update(dict([(var,(ray[var][elements]*w).sum()) for var in [ 'VE']]))
else:
point.update(dict([(var,badval) for var in [ 'i_comp', 'j_comp', 'k_comp', 'VE']]))
#point.update(dict([(var,badval) for var in [ 'VE']]))
for var in set(['VR', 'CZ', 'RH', 'PH', 'ZD', 'SW'])& set(ray.keys()):
if not(badval in ray[var][elements]):
point.update({var:(ray[var][elements]*w).sum()})
else:
point.update({var:badval})
return point, my_ht
def unit_vector(x,y,h,debug=False, **kwargs):
"""
Calculate the unit vector of the ray through a layer
"""
max_range=kwargs.get('max_range', 250.0*1000.0)
d_range=kwargs.get('d_range', 200.0)
s=sqrt(x**2+y**2)
ele_ang=elev_of_scan(s,h)
s_ray, h_ray=ray(linspace(0.0, max_range, int(max_range/d_range)), ele_ang)
#This catch could be replaced by a try for better speed
if s_ray.max() < s: s_ray, h_ray=ray(linspace(0.0, 1.5*max_range, int(1.5*max_range/d_range)), ele_ang)
lh,rh=where_fits(s, s_ray)
ds=s_ray[rh]-s_ray[lh]
dh=h_ray[rh]-h_ray[lh]
angle=arctan(dh/ds)
k_comp=sin(angle)
r_comp=cos(angle)
i_comp=r_comp*x/sqrt(x**2+y**2)
j_comp=r_comp*y/sqrt(x**2+y**2)
return i_comp, j_comp, k_comp
def dhds(x,y,h,debug=False, **kwargs):
"""
Given an x and y displacement from the radar in Metres and and height above the earth return the gradient of the beam through that layer
"""
max_range=kwargs.get('max_range', 150.0*1000.0)
d_range=kwargs.get('d_range', 500.0)
s=sqrt(x**2+y**2)
ele_ang=elev_of_scan(s,h)
s_ray, h_ray=ray(linspace(0.0, max_range, int(max_range/d_range)), ele_ang)
#This catch could be replaced by a try for better speed
if s_ray.max() < s: s_ray, h_ray=ray(linspace(0.0, 1.5*max_range, int(1.5*max_range/d_range)), ele_ang)
lh,rh=where_fits(s, s_ray)
ds=s_ray[rh]-s_ray[lh]
dh=h_ray[rh]-h_ray[lh]
if debug:
print "elevation angle of scan=", ele_ang
print ds
print dh
print rh
print lh
return dh/ds
def make_stack_all(bundle,baz, bele, ele_array,s,az, ht_array, max_elev, badval=1.31072000e+05, order=0.5): abele=array(bele) #print len(ht_array) data_dict=dict([(var,[]) for var in get_ray_ht(bundle[0], ht_array[0])[0].keys()]) cbaz=zeros([len(baz)], dtype=float) for i in range(len(baz)): #deal with the 360 degree problem poss=array([baz[i], (baz[i]+360.0), (baz[i]-360.0)]) cbaz[i]=poss[where(abs(poss-az) ==abs(poss-az).min())[0]] for i in range(len(ht_array)): if ((ele_array[i] > abele.min()) and (ele_array[i] < abele.max())): uniq_eles=unique(bele) my_ele=uniq_eles[list(mathematics.where_fits(ele_array[i], uniq_eles))] az1=cbaz[where(bele==my_ele[0])[0]][list(mathematics.where_fits(az, cbaz[where(bele==my_ele[0])[0]]))] az2=cbaz[where(bele==my_ele[1])[0]][list(mathematics.where_fits(az, cbaz[where(bele==my_ele[1])[0]]))] rays=[] rays.append(where(cbaz==az1[0])[0][where(abele[where(cbaz==az1[0])[0]]==my_ele[0])[0]][0]) rays.append(where(cbaz==az1[1])[0][where(abele[where(cbaz==az1[1])[0]]==my_ele[0])[0]][0]) rays.append(where(cbaz==az2[0])[0][where(abele[where(cbaz==az2[0])[0]]==my_ele[1])[0]][0]) rays.append(where(cbaz==az2[1])[0][where(abele[where(cbaz==az2[1])[0]]==my_ele[1])[0]][0]) small_bundle=array(bundle)[rays] small_az=cbaz[rays] small_ele=abele[rays] small_z=[] small_s=[] dat=[] vdat=[] for spray in small_bundle: ht_v, my_s=get_ray_ht(spray, ht_array[i]) s_v, my_ht=get_ray_s(spray, s) dat.append(ht_v) small_s.append(my_s) vdat.append(s_v) small_z.append(my_ht) dat=array(dat) vdat=array(vdat) small_s=array(small_s) small_z=array(small_z) #print rays #print small_ele #print small_az #print dat if small_az[1]-small_az[0] !=0.0: wdown=1.0-abs((small_az[[0,1]]-az)/(small_az[1]-small_az[0])) else: wdown=[0.5,0.5] if small_az[3]-small_az[2] != 0.0: wup=1.0-abs((small_az[[2,3]]-az)/(small_az[3]-small_az[2])) else: wup=[0.5,0.5] if small_s[2]-small_s[0]!=0.0: w=1.0-abs((small_s[[0,2]]-s)/(small_s[2]-small_s[0])) else: w=[0.5,0.5] if small_z[2]-small_z[0]!=0.0: wz=1.0-abs((small_z[[0,2]]-ht_array[i])/(small_z[2]-small_z[0])) else: wz=[0.5,0.5] hwt=h_wts(ele_array[i], max_elev, order) #print hwt for var in dat[0].keys(): #print 'here', [ if not(badval in [dat[0][var], dat[1][var]]): #data_dict[var].append((wdown*dat[0:1][var]).sum()) vdown=(wdown*array([dat[0][var], dat[1][var]])).sum() else: vdown=badval if not(badval in [dat[2][var], dat[3][var]]): #data_dict[var].append((wdown*dat[0:1][var]).sum()) vup=(wdown*array([dat[2][var], dat[3][var]])).sum() else: vup=badval if not(badval in [vdown, vup]): horiz_int=(w*array([vdown,vup])).sum() #print "good val",p #p=p+1 else: horiz_int=badval #print 'badval', p #p=p+1 #VERTICAL if not(badval in [vdat[0][var], vdat[1][var]]): #data_dict[var].append((wdown*dat[0:1][var]).sum()) vdown=(wdown*array([vdat[0][var], vdat[1][var]])).sum() else: vdown=badval if not(badval in [vdat[2][var], vdat[3][var]]): #data_dict[var].append((wdown*dat[0:1][var]).sum()) vup=(wdown*array([vdat[2][var], vdat[3][var]])).sum() else: vup=badval if not(badval in [vdown, vup]): vert_int=(wz*array([vdown,vup])).sum() #print "good val",p #p=p+1 else: vert_int=badval #print 'badval', p #p=p+1 #data_dict[var].append(horiz_int) hbad=horiz_int==badval vbad=vert_int==badval if not(hbad) and not(vbad): data_dict[var].append(hwt*horiz_int+(1.0-hwt)*vert_int) elif hbad and not(vbad): data_dict[var].append(vert_int) elif vbad and not(hbad): data_dict[var].append(horiz_int) else: data_dict[var].append(badval) else: for var in data_dict.keys(): data_dict[var].append(badval) #print "out of range", p #p=p+1 #print data_dict['VE'] return data_dict
def make_stack_horiz(bundle,baz, bele, ele_array,az, ht_array, badval=1.31072000e+05): abele=array(bele) p=0 #print len(ht_array) data_dict=dict([(var,[]) for var in get_ray_ht(bundle[0], ht_array[0]).keys()]) cbaz=zeros([len(baz)], dtype=float) for i in range(len(baz)): #deal with the 360 degree problem poss=array([baz[i], (baz[i]+360.0), (baz[i]-360.0)]) cbaz[i]=poss[where(abs(poss-az) ==abs(poss-az).min())[0]] for i in range(len(ht_array)): if ((ele_array[i] > abele.min()) and (ele_array[i] < abele.max())): uniq_eles=unique(bele) my_ele=uniq_eles[list(mathematics.where_fits(ele_array[i], uniq_eles))] az1=cbaz[where(bele==my_ele[0])[0]][list(mathematics.where_fits(az, cbaz[where(bele==my_ele[0])[0]]))] az2=cbaz[where(bele==my_ele[1])[0]][list(mathematics.where_fits(az, cbaz[where(bele==my_ele[1])[0]]))] rays=[] rays.append(where(cbaz==az1[0])[0][where(abele[where(cbaz==az1[0])[0]]==my_ele[0])[0]][0]) rays.append(where(cbaz==az1[1])[0][where(abele[where(cbaz==az1[1])[0]]==my_ele[0])[0]][0]) rays.append(where(cbaz==az2[0])[0][where(abele[where(cbaz==az2[0])[0]]==my_ele[1])[0]][0]) rays.append(where(cbaz==az2[1])[0][where(abele[where(cbaz==az2[1])[0]]==my_ele[1])[0]][0]) small_bundle=array(bundle)[rays] small_az=cbaz[rays] small_ele=abele[rays] dat=[] for spray in small_bundle: dat.append(get_ray_ht(spray, ht_array[i])) dat=array(dat) #print rays #print small_ele #print small_az #print dat if small_az[1]-small_az[0] !=0.0: wdown=1.0-abs((small_az[[0,1]]-az)/(small_az[1]-small_az[0])) else: wdown=[0.5,0.5] if small_az[3]-small_az[2] != 0.0: wup=1.0-abs((small_az[[2,3]]-az)/(small_az[3]-small_az[2])) else: wup=[0.5,0.5] if small_ele[2]-small_ele[0]!=0.0: w=1.0-abs((small_ele[[0,2]]-ele_array[i])/(small_ele[2]-small_ele[0])) else: w=[0.5,0.5] for var in dat[0].keys(): #print 'here', [ if not(badval in [dat[0][var], dat[1][var]]): #data_dict[var].append((wdown*dat[0:1][var]).sum()) vdown=(wdown*array([dat[0][var], dat[1][var]])).sum() else: vdown=badval if not(badval in [dat[2][var], dat[3][var]]): #data_dict[var].append((wdown*dat[0:1][var]).sum()) vup=(wdown*array([dat[2][var], dat[3][var]])).sum() else: vup=badval if not(badval in [vdown, vup]): data_dict[var].append((w*array([vdown,vup])).sum()) #print "good val",p #p=p+1 else: data_dict[var].append(badval) #print 'badval', p #p=p+1 else: for var in data_dict.keys(): data_dict[var].append(badval) #print "out of range", p #p=p+1 #print data_dict['VE'] return data_dict
def get_value_at_xyz(scan_list, x,y,z, var, **kwargs):
"""
scan_list: a list of scans
x,y,z: position to find value (interpolation position) in metres
var: parameter to interpolate (eg VR, DZ,...)
"""
#Generate a array of elevations for the scan list
#We use the minus onth (last) element in the scan as the radar has settled by then
elevs=array([scan['Elev'][-1] for scan in scan_list])
#pick the above and below elevations
s=sqrt(x**2+y**2)
az=mathematics.vector_direction(x,y)
baddata=kwargs.get('baddata',1.31072000e+05)
my_elevation=propigation.elev_of_scan(s,z)
elev_numbers=mathematics.where_fits(my_elevation, elevs)
#for each elevation pick the ray on either side of the point
if not(elev_numbers[0] == elev_numbers[1]):
#we are neither at the top or bottom
top_scan=scan_list[elev_numbers[1]]
bottom_scan=scan_list[elev_numbers[0]]
#Scan above the point ----------TOP ELEVATION-----------
#work out what gates to use (ie range in S direction)
sar=sqrt(top_scan['xar'][0,:]**2 + top_scan['yar'][0,:]**2)
gates=mathematics.where_fits(s, sar)
ds=sar[gates[1]]-sar[gates[0]]
if ds==0.0:
top_gates_comp=[0.5,0.5]
else:
top_gates_comp=[ abs(s-sar[gates[1]])/ds, abs(s-sar[gates[0]])/ds]
scan_order=top_scan['Azmth'].argsort()
fits_order=mathematics.where_fits(az, top_scan['Azmth'][scan_order])
ray_numbers=[scan_order[fits_order[0]], scan_order[fits_order[1]]]
d_angle=top_scan['Azmth'][ray_numbers[1]]-top_scan['Azmth'][ray_numbers[0]]
top_ang_comp=[abs(az-top_scan['Azmth'][ray_numbers[1]])/d_angle, abs(az-top_scan['Azmth'][ray_numbers[0]])/d_angle]
if fits_order[0] == fits_order[1]:
#we are near 360
azd=az
ray_numbers=[scan_order[-1], scan_order[0]]
d_angle=top_scan['Azmth'][ray_numbers[1]]-(top_scan['Azmth'][ray_numbers[0]]-360.0)
if az > d_angle: azd=az-360.0
top_ang_comp=[abs(azd-top_scan['Azmth'][ray_numbers[1]])/d_angle,abs(azd-(top_scan['Azmth'][ray_numbers[0]]-360.0))/d_angle ]
tp1=cond_lin_int(top_scan[var][ray_numbers[0], gates[0]], top_scan[var][ray_numbers[0], gates[1]], top_gates_comp)
tp2=cond_lin_int(top_scan[var][ray_numbers[1], gates[0]], top_scan[var][ray_numbers[1], gates[1]], top_gates_comp)
top_point=cond_lin_int(tp1, tp2, top_ang_comp)
top_z=(top_scan['zar'][ray_numbers[0], gates[0]]*top_gates_comp[0]+ top_scan['zar'][ray_numbers[0], gates[1]]*top_gates_comp[1])
#BOTTTTTTTTOOMMMMMMMMMMMM!
sar=sqrt(bottom_scan['xar'][0,:]**2 + bottom_scan['yar'][0,:]**2)
gates=mathematics.where_fits(s, sar)
ds=sar[gates[1]]-sar[gates[0]]
if ds==0.:
bottom_gates_comp=[0.5,0.5]
else:
bottom_gates_comp=[ abs(s-sar[gates[1]])/ds, abs(s-sar[gates[0]])/ds]
scan_order=bottom_scan['Azmth'].argsort()
fits_order=mathematics.where_fits(az, bottom_scan['Azmth'][scan_order])
ray_numbers=[scan_order[fits_order[0]], scan_order[fits_order[1]]]
d_angle=bottom_scan['Azmth'][ray_numbers[1]]-bottom_scan['Azmth'][ray_numbers[0]]
bottom_ang_comp=[abs(az-bottom_scan['Azmth'][ray_numbers[1]])/d_angle, abs(az-bottom_scan['Azmth'][ray_numbers[0]])/d_angle]
if fits_order[0] == fits_order[1]:
#we are near 360
azd=az
ray_numbers=[scan_order[-1], scan_order[0]]
d_angle=bottom_scan['Azmth'][ray_numbers[1]]-(bottom_scan['Azmth'][ray_numbers[0]]-360.0)
if az > d_angle: azd=az-360.0
bottom_ang_comp=[abs(azd-bottom_scan['Azmth'][ray_numbers[1]])/d_angle,abs(azd-(bottom_scan['Azmth'][ray_numbers[0]]-360.0))/d_angle ]
bp1=cond_lin_int(bottom_scan[var][ray_numbers[0], gates[0]], bottom_scan[var][ray_numbers[0], gates[1]], bottom_gates_comp)
bp2=cond_lin_int(bottom_scan[var][ray_numbers[1], gates[0]], bottom_scan[var][ray_numbers[1], gates[1]], bottom_gates_comp)
bottom_point=cond_lin_int(bp1, bp2, bottom_ang_comp)
bottom_z=(bottom_scan['zar'][ray_numbers[0], gates[0]]*bottom_gates_comp[0]+ bottom_scan['zar'][ray_numbers[0], gates[1]]*bottom_gates_comp[1])
#calculate components
d_z=top_z-bottom_z
#print d_z
z_comps=[abs(z-top_z)/d_z, abs(z-bottom_z)/d_z]
my_point=cond_lin_int(bottom_point, top_point, z_comps)
#bottom_point*z_comps[0]+top_point*z_comps[1]
else:
my_point=0.0
if "az_range" in kwargs.keys():
a1=kwargs['az_range'][0]
a2=kwargs['az_range'][0]
if a1 > a2: #we go through 360
if not((az >= a1) or (az <=a2)):
my_point=baddata
else:
if not((az >= a1) or (az <= a2)):
my_point=baddata
return my_point
