def elasticity( d, s, string, hour):
dem = place_time(d,string,hour)
sup = place_time(s,string,hour)
con = inter(dem[1],dem[0])
pro = inter(sup[1],sup[0])
m=max(min(con.x),min(pro.x))
M=min(max(con.x),max(pro.x))
q = numpy.linspace(m,M,100000)
demand = con(q)
supply = pro(q)
diff = abs(demand - supply)
qmin = list(diff).index(min([x for x in diff if not math.isnan(x)]))
#eq = [q[q_min], demand[q_min]]
dx = (q[qmin+1] - q[qmin-1])/(.5*(q[qmin+1] + q[qmin-1]))
dy = (demand[qmin+1] - demand[qmin-1])/(.5*(demand[qmin+1] + demand[qmin-1]))
e = float(dx)/float(dy)
return e
def RA_DEC_from_lonlat(lat, lon):
"""
input: lat long angles
output: RA and DEC
"""
ra_map = inter([-180, 180], [0, 360])
ra = ra_map(lon) - 180 # Needs to be mapped
dec = lat
return ra, dec
def short_board(self):
x = np.array([
0, 300, self.length / 2 + self.mid_shift, self.length - 300,
self.length
])
y = np.array([
self.tail / 2, self.width * self.tail_width / 2, self.width / 2,
self.width * self.nose_width / 2, self.nose
])
f = inter(x, y, kind='cubic')
self.W_points = f(self.L_grid)
def linear_inter(list1, list2, intervals):
if len(list1) != len(list2):
print("Cannot be done.")
return None
else:
y = [1, intervals + 2]
x = list(range(len(list1)))
z = [list1, list2]
f = inter(x, y, z, kind="linear")
all_data = [list1]
for i in range(1, intervals + 1):
all_data.append(np.round(f(x, 1 + i)))
all_data.append(list2)
return all_data
def sky_mag(filt, rad):
"""
Calculate sky magnitude for a given filter
This function assumes that all filter files have the following units:
microns
ph/s/m2/micron/arcsec2
"""
band = np.genfromtxt(filt, skip_header=2).T
sky = pyfits.open(rad)
# rad = np.genfromtxt(rad, skip_header=2).T
band_inter = inter(band[0], band[1], k=3)
band_wvl = band_inter(sky[1].data.field('lam')).clip(0)
# in photon/s/m^2/micron:
bandflux = sky[1].data.field('flux')
plt.figure()
plt.plot(sky[1].data.field('lam'), sky[1].data.field('flux'), 'k')
plt.plot(sky[1].data.field('lam'), bandflux, 'b')
plt.plot(band[0], band[1] * bandflux.max(), 'r')
plt.plot(sky[1].data.field('lam'), band_wvl * bandflux.max(), 'r')
return sky[1].data.field('lam'), bandflux
def sky_vega(filt, vega_file):
"""
Calculate sky magnitude for a given filter
This function assumes that all filter files have the following units:
microns
ph/s/m2/micron/arcsec2
"""
band = np.genfromtxt(filt, skip_header=2).T
vega = at.read('libs/vega_rieke08.dat', data_start=8, names=['ldo', 'fl'])
# This is in microns so no change:
vega_ldo = np.array(vega['ldo'])
# this is w/m2/nm, so to put in photon/s/m^2/micron:
vega_flux = np.array(vega['fl']) * 1e3 * 5.034118201E+18 * vega_ldo
band_inter = inter(band[0], band[1], k=3)
band_wvl = band_inter(vega_ldo).clip(0)
bandflux = vega_flux * band_wvl
plt.figure()
plt.plot(vega_ldo, vega_flux, 'k')
plt.plot(vega_ldo, bandflux, 'b')
plt.plot(band[0], band[1] * bandflux.max(), 'r')
plt.plot(vega_ldo, band_wvl * bandflux.max(), 'r')
return vega_ldo, bandflux
def calc_flow(input_file = sys.stdin, verbose=False):
if verbose:
logging.basicConfig(level=logging.DEBUG)
else:
logging.basicConfig(filename='/dev/null')
i=0
#Para reset
while True:
#[t][sensor_id] = value
sensors_value = []
# Se o valor de t-1 foi interpolado
interpolado = False
ts_value = []
n_sensors = N_SENSORS
i = i +1
if i == 10:
break
try:
while True:
t = len(sensors_value)
value = 10
try:
value = read_sensors(input_file, n_sensors)
except SensorOutOfOrder, e:
#reset
logging.critical(e)
logging.critical('Reiniciando...')
print 'fail'
break
except InputEnd:
logging.critical('Fim do arquivo de entrada saindo...')
exit(0)
else:
sensors_value.append(value)
try:
ts_value.append(convert_volt_to_degree(get_ts(sensors_value[t])))
interpolado = False
# Nenhum sensor lido
except ValueError, e:
logging.critical(e)
if interpolado:
logging.critical("Valor anterior já é interpolado, " +
"reiniciando...")
print 'fail'
break
if len(ts_value) < 1:
logging.critial("Sem leituras para interpolar, " +
"reniciando...")
print 'fail'
break
ts_value.append(inter(range(len(ts_value)),
ts_value)(len(ts_value)+1))
interpolado = True
logging.debug("Interpolado valor previsto '%s'" %
ts_value[len(ts_value)-1])
caudal = get_caudal(ts_value)
conf = 0
if None in sensors_value[t]:
if (sensors_value[t][0] == None and
sensors_value[t][1] == None):
conf = 50
else:
conf = 70
else:
conf = 90
if caudal < 0:
print_caudal(0, conf)
elif caudal > 1000:
print_caudal(1000, conf)
else:
print_caudal(caudal, conf)
start = np.where(time > delta.days)[0][0]
stop = np.int(1 + 12 * (eyear + 1 - syear))
var = data.variables[vname][start:start + stop, :, :]
data.close()
var = np.ma.masked_array(var)
var = np.ma.masked_invalid(var)
np.ma.set_fill_value(var, 0)
var = var.filled()
lats, lons, vmap = calculate_map_data(lats, lons, var, lat_bound)
vmap = vmap * scale
if vmap.shape == omap.shape:
diff = vmap - omap
else:
imap = inter(lats, lons, vmap)
diff = imap(olats, olons) - omap
if mask_near0:
m0 = (vmap > near0 * (-1)) * (vmap < near0)
vmap = np.ma.masked_array(vmap, m0)
m1 = (diff > near0 * (-1)) * (diff < near0)
diff = np.ma.masked_array(diff, m1)
# Map plots
plt.clf()
fig, axs = plt.subplots(1, 2, figsize=(15, 8))
#fig.subplots_adjust(hspace=0.3)
#fig.subplots_adjust(wspace=0.3)
i = 0
# filt_file=at.read('filters/BrG_trans.dat',data_start=3,names=['ldo','tr'])
# filt_file = at.read('filters/H2_10_trans.dat', data_start=3, names=['ldo', 'tr'])
filt_file = at.read('filters/H2_21_trans.dat',
data_start=3,
names=['ldo', 'tr'])
filt_ldo[newfilt] = np.array(filt_file['ldo'])
filt_tr[newfilt] = np.array(filt_file['tr'])
#
# 5.- Now we need to interplate everything to a reasonable
# resolution in wvl, to make the integrals smoother
#
fine_ldo = np.arange(8000, 27500, 2) * 1e-4
# Vega
f = inter(vega_ldo, vega_flux)
vega_flux_fine = f(fine_ldo)
# Sky
f = inter(sky_ldo, sky_flux)
sky_flux_fine = f(fine_ldo)
# filters
fy = inter(filt_ldo['Y'], filt_tr['Y'])
fj = inter(filt_ldo['J'], filt_tr['J'])
fh = inter(filt_ldo['H'], filt_tr['H'])
fk = inter(filt_ldo['Ks'], filt_tr['Ks'])
fhk = inter(filt_ldo['HK'], filt_tr['HK'])
fyj = inter(filt_ldo['YJ'], filt_tr['YJ'])
fbrg = inter(filt_ldo[newfilt], filt_tr[newfilt])
filt_tr_fine = {
'Y': fy(fine_ldo).clip(0, 1),
pixels_per_cm = (pix /
area)**0.5 # root of pixel area/ known area from cell pic
photodiode_diam_pix = pixels_per_cm * 1.2
del pix
del area
#######################################################################################
# LED powermeter calibration:
nominal_v_cal = []
num_photons = []
with open(r"./calibration_data/ledcal.csv", "r") as file:
reader = csv.reader(file)
for row in reader:
nominal_v_cal.append(float(row[0]))
num_photons.append(float(row[1]))
ledf = inter(nominal_v_cal, num_photons) # function
del nominal_v_cal # Free up memory
del num_photons
#######################################################################################
# LED spectrum (From Thorlabs):
led_spec_wavel = []
led_spec = []
with open(r"./calibration_data/ledwavel.csv", "r") as file:
reader = csv.reader(file)
for row in reader:
led_spec_wavel.append(float(row[0]))
led_spec.append(float(row[1]))
ledspecf = inter(led_spec_wavel, led_spec)
del led_spec_wavel
del led_spec
output = open("../../inputs/SDSS_sigma.txt", "w")
jpas_out = open("../../inputs/JPAS_sigma.txt", "w")
output.write("{0:12d}{1:12d}\n".format(nbin, wlength.size))
jpas_out.write("{0:12d}{1:12d}\n".format(nbin, wl_jpas.size))
output.write((wlength.size * "{:12.1f}" + "\n").format(*wlength))
jpas_out.write((wl_jpas.size * "{:12.1f}" + "\n").format(*wl_jpas))
for i in range(1, nbin + 1) :
medians = np.median(sigmas[bin_ind == i], axis = 0)
mean = np.median(fluxes[bin_ind == i, 2] / sigmas[bin_ind == i, 2])
output.write(("{:12.1f}" + medians.size * "{:12.4e}" + "\n").format(mean, *medians))
plt.plot(wlength, medians / medians[2], "o-", label = str(round(mean/100.) * 100), mew = 0)
polint = inter(wlength, medians, k = 2)
tr_jpas = polint(wl_jpas)
plt.plot(wl_jpas, tr_jpas / tr_jpas[np.argmin(abs(wl_jpas - wlength[2]))], "-k", lw = 2)
jpas_out.write(("{:12.1f}" + tr_jpas.size * "{:12.4e}" + "\n").format(mean, *tr_jpas))
output.close()
jpas_out.close()
plt.gca().set_xticks(wlength)
plt.gca().set_xticklabels(["u'", "g'", "r'", "i'", "z'"])
plt.xlabel("wavelength [A]")
plt.ylabel("normalized flux at r'")
plt.legend(loc = 0, frameon = False, numpoints = 1, title = "~(S/N)_r'")
plt.tight_layout()
plt.show()
def calc_flow(input_file=sys.stdin, verbose=False):
if verbose:
logging.basicConfig(level=logging.DEBUG)
else:
logging.basicConfig(filename='/dev/null')
i = 0
#Para reset
while True:
#[t][sensor_id] = value
sensors_value = []
# Se o valor de t-1 foi interpolado
interpolado = False
ts_value = []
n_sensors = N_SENSORS
i = i + 1
if i == 10:
break
try:
while True:
t = len(sensors_value)
value = 10
try:
value = read_sensors(input_file, n_sensors)
except SensorOutOfOrder, e:
#reset
logging.critical(e)
logging.critical('Reiniciando...')
print 'fail'
break
except InputEnd:
logging.critical('Fim do arquivo de entrada saindo...')
exit(0)
else:
sensors_value.append(value)
try:
ts_value.append(
convert_volt_to_degree(get_ts(sensors_value[t])))
interpolado = False
# Nenhum sensor lido
except ValueError, e:
logging.critical(e)
if interpolado:
logging.critical("Valor anterior já é interpolado, " +
"reiniciando...")
print 'fail'
break
if len(ts_value) < 1:
logging.critial("Sem leituras para interpolar, " +
"reniciando...")
print 'fail'
break
ts_value.append(
inter(range(len(ts_value)),
ts_value)(len(ts_value) + 1))
interpolado = True
logging.debug("Interpolado valor previsto '%s'" %
ts_value[len(ts_value) - 1])
caudal = get_caudal(ts_value)
conf = 0
if None in sensors_value[t]:
if (sensors_value[t][0] == None
and sensors_value[t][1] == None):
conf = 50
else:
conf = 70
else:
conf = 90
if caudal < 0:
print_caudal(0, conf)
elif caudal > 1000:
print_caudal(1000, conf)
else:
print_caudal(caudal, conf)
output.write("{0:12d}{1:12d}\n".format(nbin, wlength.size))
output.write((wlength.size * "{:12.1f}" + "\n").format(*wlength))
for i in range(1, nbin + 1):
medians = np.median(sigmas[bin_ind == i], axis=0)
mean = np.median(fluxes[bin_ind == i, 2] / sigmas[bin_ind == i, 2])
output.write(
("{:12.1f}" + medians.size * "{:12.4e}" + "\n").format(mean, *medians))
plt.loglog(wlength[fil_ind],
medians[fil_ind] / medians[fil_ind][2],
"o-",
label=str(round(mean / 10.) * 10),
mew=0)
#plt.plot(V[bin_ind == i], dV[bin_ind == i], ".")
if i == 2:
polint = inter(wlength, medians, k=2)
tr_jpas = polint(wl_jpas)
plt.plot(wl_jpas, tr_jpas / tr_jpas[17], "-k", lw=2)
output.close()
plt.gca().set_xticks(wlength)
plt.gca().set_xticklabels(
["u", "B", "g", "V", "r", "i", "z", "K", "3.6", "4.5"])
plt.xlabel("wavelength [A]")
plt.ylabel("sigma [erg/s/cm^2/A]")
plt.legend(loc=0, frameon=False, numpoints=1, title="~(S/N)_V")
plt.tight_layout()
plt.show()
