def get_likelihood(observables):
"""
get the likelihood for a point.
@param observables: Dictionary containing the observables for which the likelihood is to be computed. Observable values are keyed by observable name. If a theory uncertainty is given, it is taken to be the only uncertainty pertaining to the observable.
"""
product_likelihood = 1
for obs,obsval in observables.items():
if "special_case" in obsval.keys():#in case you need a non-standard handling of the likelihood, add the flag "special_case" as one of the keys in the likelihood_contributions dictionary
continue
if obs not in likelihood_contributions:
print(str(obs)+" has no experimental result in database")
continue
if "uncertainty" in obsval.keys(): #higgs-type case: center gauss on theory value with width= theory uncertainty, evaluate at experimental value
product_likelihood *= utils.gauss(likelihood_contributions[obs]["value"],obsval["value"],0.5*obsval["uncertainty"])
else:
if type(likelihood_contributions[obs]["uncertainty"]) == float:#usual case, symmetric error
product_likelihood *= utils.gauss(obsval["value"],likelihood_contributions[obs]["value"],likelihood_contributions[obs]["uncertainty"])
elif type(likelihood_contributions[obs]["uncertainty"]) == list:#non-symmetric error, use two-sided gaussian
product_likelihood *= utils.gauss_pm(obsval["value"],likelihood_contributions[obs]["value"],sigma_m = likelihood_contributions[obs]["uncertainty"][0],sigma_p = likelihood_contributions[obs]["uncertainty"][1])
#handle special cases
#superiso chi2
chi2 = observables["chi2"]["value"]
ndf = observables["chi2_ndf"]["value"]
gamma = math.gamma(float(ndf)/2)
coeff = pow(chi2,(float(ndf)/2)-1)/((pow(2,float(ndf)/2))*gamma)
product_likelihood*= (coeff*math.exp(-chi2/2))
return product_likelihood
def getisosweights_gauss(weights, age, metallicity, isos, sigma):
""" same as getisoweights, but adds Gaussian scatter """
w = [0.] * len(isos)
for m, a, feh in zip(weights, age, metallicity):
for x in utils.frange(feh - 4, feh + 4, 0.1):
w[getn(x, a, isos)] += m * utils.gauss(x, feh, sigma)
return w
def getisosweights_gauss(weights,age,metallicity,isos,sigma):
""" same as getisoweights, but adds Gaussian scatter """
w=[0.]*len(isos)
for m,a,feh in zip(weights,age,metallicity):
for x in utils.frange(feh-4,feh+4,0.1):
w[getn(x,a,isos)]+=m*utils.gauss(x,feh,sigma)
return w
def bolEstm(obj, sig, width):
'''
peakFinder.bolEstm(obj, sig, width)
=============================
Performs a SN estimation at each wavelength following the max-likelihood
approach of Bolton et al. (2012).
Parameters:
obj: The SDSS object/spectra on which applied the subtraction
sig: Width of the gaussian kernel
width: Width of the convolutional window
Returns:
SN: The SN at each wavelength as an array. Beginning and end are filled
with null values due to the convolution.
'''
NormGauss = gauss(np.linspace(-width * 0.5, width * 0.5, width), 0.0, 1.0,
sig**2.0)
NormGauss = NormGauss / np.sum(NormGauss)
Cj1 = np.array([
np.sum(
kernel(j + 0.5 * width, width, NormGauss, len(obj.wave)) *
obj.reduced_flux * obj.ivar)
for j in range(int(len(obj.wave) - width))
])
Cj2 = np.array([
np.sum(obj.ivar *
kernel(j + 0.5 * width, width, NormGauss, len(obj.wave))**2.0)
for j in range(int(len(obj.wave) - width))
])
SN = np.zeros(len(obj.wave))
SN[int(width * 0.5):int(width * 0.5 + len(Cj1))] = Cj1 / np.sqrt(Cj2)
return SN
def _cost(theta, stims, psth_data, sres, tres, channels):
tres = int(np.rint(theta[0]))
theta = theta[1:].reshape(channels,7)
for i in range(channels):
z1, p1, p2, p3, l, mu, sig = theta[i]
# bounds on the uniform prior distributions
if not (
5 < tres <= 150 and
-100 < z1 < 100 and
-100 < p1 < p2 < p3 < 100 and
0 < l < 50 and
0 < mu < sres and
0 < sig < sres
): return -np.inf
Sfilt = np.empty((channels,sres))
Tfilt = np.empty((channels,tres))
for i in range(channels):
z1,p1,p2,p3,l, mu, sig = theta[i]
Tfilt[i] = np.asarray(utils.overtime(0,tres,utils.P3Z1,z1,p1,p2,p3,l,1))
Sfilt[i] = utils.gauss(np.arange(0,sres),mu,sig)
nh = np.matmul(Sfilt.T,Tfilt)
out = 0
ntrials = np.size(psth_data)
for i,stim in enumerate(stims):
rate = utils.speccnov(nh,stim)
out += np.sum((utils.normalize(psth_data[i]) - utils.normalize(rate))**2)/len(psth_data[i])
return -out
def bolEstm(obj, sig, width):
'''
peakFinder.bolEstm(obj, sig, width)
=============================
Performs a SN estimation at each wavelength following the max-likelihood
approach of Bolton et al. (2012).
Parameters:
obj: The SDSS object/spectra on which applied the subtraction
sig: Width of the gaussian kernel
width: Width of the convolutional window
Returns:
SN: The SN at each wavelength as an array. Beginning and end are filled
with null values due to the convolution.
'''
NormGauss = gauss(np.linspace(-width * 0.5, width * 0.5, width), 0.0, 1.0,
sig ** 2.0)
NormGauss = NormGauss / np.sum(NormGauss)
Cj1 = np.array([np.sum(kernel(j + 0.5 * width, width, NormGauss,
len(obj.wave)) * obj.reduced_flux * obj.ivar)
for j in range(int(len(obj.wave) - width))])
Cj2 = np.array([np.sum(obj.ivar * kernel(j + 0.5 * width, width, NormGauss,
len(obj.wave)) ** 2.0)
for j in range(int(len(obj.wave) - width))])
SN = np.zeros(len(obj.wave))
SN[int(width * 0.5): int(width * 0.5 + len(Cj1))] = Cj1 / np.sqrt(Cj2)
return SN
def update(self, Z: list):
self.S = self.innov_cov(self.H, self.P, self.R)
zpred = self.zpred()
innovations = []
betas_unorm = []
for z in Z:
if z.size != 2:
raise Exception("z has wrong dimension", z)
innovations.append(z - zpred)
betas_unorm.append(self.P_D * gauss(z, zpred, self.S))
betas = betas_unorm / np.sum(betas_unorm)
# Reduce the mixture to a single innovation weighted by betas
ny = np.zeros_like(zpred)
for j, assoc_ny in enumerate(innovations):
ny += betas[j] * assoc_ny
W = self.P @ np.transpose(self.H) @ np.linalg.inv(self.S)
self.x = self.x + W @ ny
beta_boi = 0
for j, assoc_ny in enumerate(innovations):
beta_boi += betas[j] * assoc_ny @ assoc_ny.T
sprd_innov = W @ (beta_boi - ny @ ny.T) @ W.T
beta_0 = self.lam * (1 - self.P_D)
self.P = self.P - (1 - beta_0) * W @ self.S @ W.T + sprd_innov
def sumisos_gauss_slow(mass,age,metallicity,fehlist,agelist,isos,sigma):
"""slower version"""
summed_iso = 0.*isos[isos.keys()[0]]
for m,a,z in zip(mass,age,metallicity):
feh = numarray.log10(z)-numarray.log10(SOLAR)
for x in utils.frange(feh-4,feh+4,0.1):
summed_iso+= utils.gauss(x,feh,sigma)*m*getiso(x,a,fehlist,agelist,isos)
return summed_iso
def sumisos_gauss_slow(mass, age, metallicity, fehlist, agelist, isos, sigma):
"""slower version"""
summed_iso = 0. * isos[isos.keys()[0]]
for m, a, z in zip(mass, age, metallicity):
feh = numarray.log10(z) - numarray.log10(SOLAR)
for x in utils.frange(feh - 4, feh + 4, 0.1):
summed_iso += utils.gauss(x, feh, sigma) * m * getiso(
x, a, fehlist, agelist, isos)
return summed_iso
def calcEM(height):
##########初始化#################
N = len(height)
gp = 0.5 # girl probability
bp = 0.5 # boy probability
gmu, gsigma = min(height), 18 # 先验：直接取最大和最小值
bmu, bsigma = max(height), 20
# r(i,k):第i个样本由第k个组份生成的概率
ggamma = [0.0 for i in range(N)] # 第i个样本由女性生成的概率
bgamma = [0.0 for i in range(N)] # 第i个样本由男性生成的概率
cur = [gp, bp, gmu, gsigma, bmu, bsigma]
now = []
times = 0
##########迭代更新###############
while times < 100:
i = 0
for x in height:
ggamma[i] = gp * gauss(x, gmu, gsigma)
bgamma[i] = bp * gauss(x, bmu, bsigma)
s = ggamma[i] + bgamma[i]
ggamma[i] /= s
bgamma[i] /= s
i += 1
gn = sum(ggamma)
gp = float(gn) / float(N)
bn = sum(bgamma)
bp = float(bn) / float(N)
gmu = averageWeight(height, ggamma, gn)
gsigma = varianceWeight(height, ggamma, gmu, gn)
bmu = averageWeight(height, bgamma, bn)
bsigma = varianceWeight(height, bgamma, bmu, bn)
now = [gp, bp, gmu, gsigma, bmu, bsigma]
if isSame(cur, now):
break
cur = now
print("Times:\t", times)
print("Girl mean/gsigma:\t", gmu, gsigma)
print("Boy mean/bsigma:\t", bmu, bsigma)
print("Boy/Girl:\t", bn, gn, bn + gn)
print()
times += 1
return now
def sensor_model(particle_poses, beacon_pose, beacon_loc):
""" Apply sensor model and return particle weights.
Parameters
----------
particle_poses: an M x 3 array of particle_poses (in the map
coordinate system) where M is the number of particles. Each pose
is (x, y, theta) where x and y are in metres and theta is in
radians.
beacon_pose: the measured pose of the beacon (x, y, theta) in the
robot's camera coordinate system.
beacon_loc: the pose of the currently visible beacon (x, y, theta)
in the map coordinate system.
Returns
-------
An M element array of particle weights. The weights do not need to be
normalised.
"""
M = particle_poses.shape[0]
particle_weights = np.zeros(M)
# Calculate beacon measured from camera frame.
r = np.sqrt((beacon_pose[0]) ** 2 + (beacon_pose[1]) ** 2)
phi = arctan2(beacon_pose[1], beacon_pose[0])
for m in range(M):
# Calculate the true location of beacon from particle pose m.
r_m = np.sqrt((beacon_loc[0] - particle_poses[m][0]) ** 2 + (beacon_loc[1] - particle_poses[m][1]) ** 2)
phi_m = angle_difference(arctan2(beacon_loc[0] - particle_poses[m][0], beacon_loc[1] - particle_poses[m][1]), particle_poses[m][2])
# Calculate error.
r_val = r - r_m
phi_val = angle_difference(phi, phi_m)
# Update particle weights.
particle_weights[m] = gauss(r_val, mu=0, sigma=(r_m ** 2)) * gauss(phi_val, mu=0, sigma=(r_m ** 2))
return particle_weights
def getisosweights_vgauss(weights,age,metallicity,isos,sigma,dsigmadlogt):
""" same as getisoweights, but adds age-dependent Gaussian scatter """
w=[0.]*len(isos)
logt0 = numarray.log10(age[0])
for m,a,feh in zip(weights,age,metallicity):
logt = numarray.log10(a)
sig = sigma+dsigmadlogt*(logt-logt0)
for x in utils.frange(feh-4,feh+4,0.1):
w[getn(x,a,isos)]+=m*utils.gauss(x,feh,sig)
return w
def getisosweights_vgauss(weights, age, metallicity, isos, sigma, dsigmadlogt):
""" same as getisoweights, but adds age-dependent Gaussian scatter """
w = [0.] * len(isos)
logt0 = numarray.log10(age[0])
for m, a, feh in zip(weights, age, metallicity):
logt = numarray.log10(a)
sig = sigma + dsigmadlogt * (logt - logt0)
for x in utils.frange(feh - 4, feh + 4, 0.1):
w[getn(x, a, isos)] += m * utils.gauss(x, feh, sig)
return w
def qsoContfit(obj, peak, searchLyA, sig, window_width=40):
'''
peakFinder.qsoContfit(obj, peak, searchLyA, window_width)
=============================
A function to fit the QSO continuum near a peak with a 3rd order polynomial
and subtract it. Add the new SN of the peak in its class.
Parameters:
obj: The SDSS object/spectra on which applied the subtraction
peak: The inquired peak
sig: Sigma of gaussian to perform SN max-likelihood
searchLyA: True if we search for background LAE, False for backgroung ELGs
window_width: Half-width (Angstroms) on which the polynomial is fitted
Returns:
accept: True if the SN is still high after subtraction. False otherwise.
'''
x0 = peak.wavelength
window = np.linspace(obj.wave2bin(x0) - window_width,
obj.wave2bin(x0) + window_width,
2 * window_width + 1,
dtype=np.int16)
median_local = np.median(obj.reduced_flux[window])
fit_QSO = np.poly1d(np.polyfit(x=obj.wave[window],y=obj.reduced_flux[window],deg=3, \
w=(np.abs(obj.reduced_flux[window]-median_local)<5)*np.sqrt(obj.ivar[window])) )
new_flux = obj.reduced_flux[window] - fit_QSO(obj.wave[window])
NormGauss = gauss(
np.linspace(-window_width * 0.5, window_width * 0.5, window_width),
0.0, 1.0, sig**2.0)
NormGauss = NormGauss / np.sum(NormGauss)
cj1_new = np.sum(
new_flux *
kernel(int(len(window) / 2), window_width, NormGauss, len(new_flux)) *
obj.ivar[window])
cj2_new = np.sum(
obj.ivar[window] *
kernel(int(len(window) / 2), window_width, NormGauss, len(window))**2)
SN_fitted = cj1_new / np.sqrt(cj2_new)
if searchLyA and SN_fitted < 6:
return False #Reject
elif searchLyA and SN_fitted > 6:
peak.reduced_sn = SN_fitted
obj.reduced_flux_QSO[window] = new_flux
elif searchLyA == False and SN_fitted < 6:
return False # Reject
elif searchLyA == False and SN_fitted > 6:
peak.reduced_sn = SN_fitted
obj.reduced_flux_QSO[window] = new_flux
return True # Accept
def bolEstm(obj, sig, width):
NormGauss = gauss(np.linspace(-width * 0.5, width * 0.5, width), 0.0, 1.0,
sig ** 2.0)
NormGauss = NormGauss / np.sum(NormGauss)
Cj1 = np.array([np.sum(kernel(j + 0.5 * width, width, NormGauss,
len(obj.wave)) * obj.reduced_flux * obj.ivar)
for j in range(int(len(obj.wave) - width))])
Cj2 = np.array([np.sum(obj.ivar * kernel(j + 0.5 * width, width, NormGauss,
len(obj.wave)) ** 2.0)
for j in range(int(len(obj.wave) - width))])
SN = np.zeros(len(obj.wave))
SN[int(width * 0.5): int(width * 0.5 + len(Cj1))] = Cj1 / np.sqrt(Cj2)
return SN
def getisosweights_sgauss(weights,age,sfr,metallicity,isos,sigma,dsigmadlogt):
""" Same as getisoweights, but adds sfr-dependent Gaussian scatter.
**** CAUTION: not yet tested ****
"""
w=[0.]*len(isos)
logt0 = numarray.log10(age[0])
for m,a,feh,s in zip(weights,age,metallicity,sfr):
ss = numarray.maximum(sfr,1.e-5)
logs = numarray.log10(ss)
logt = numarray.log10(a)
sig = sigma+dsigmadlogs*(logs)
for x in utils.frange(feh-4,feh+4,0.1):
w[getn(x,a,isos)]+=m*utils.gauss(x,feh,sig)
return w
def sumisos_gauss(mass,age,metallicity,fehlist,agelist,isos,sigma):
"""Faster version."""
isoweight = {}
for k in isos.keys():
isoweight[k] = 0.
for m,a,z in zip(mass,age,metallicity):
feh = numarray.log10(z/SOLAR)
for x in utils.frange(feh-4,feh+4,0.1):
isoweight[getindices(x,a,fehlist,agelist)]+= utils.gauss(x,feh,sigma)*m
summed_iso = 0.*isos[isos.keys()[0]]
for k in isoweight.keys():
summed_iso+=isoweight[k]*isos[k]
# p(isoweight)
return summed_iso
def galSave(doublet, obj, peak_candidates, doublet_index, savedir, em_lines,
doPlot, prodCrit):
detection = False
preProd = 0.0
nxtProd = 0.0
if doublet:
preProd, nxtProd = fitcSpec(obj, peak_candidates[doublet_index])
if preProd + nxtProd > prodCrit:
raise Exception("Rejected by comparing to other fibers")
z_s = peak_candidates[doublet_index].wavelength / 3727.09 - 1.0
# Find peak near infered OIII and Hbeta by fitting
fitChi, fitRes, fitSn = _findPeak(obj, z_s, obj.SN, width=20.0)
detection = _doubletSave(obj, z_s, peak_candidates, doublet_index,
savedir, preProd, nxtProd, fitChi, fitSn)
detection = _dblmultSave(obj, z_s, peak_candidates, savedir,
detection, em_lines)
elif len(peak_candidates) > 1:
detection = _multletSave(obj, peak_candidates, savedir, em_lines)
if not detection:
raise Exception("Rejected since source too near")
peaks = []
for k in range(len(peak_candidates)):
peak = peak_candidates[k]
if k == doublet_index and doublet:
peaks.append([peak.wavDoublet[0], peak.ampDoublet[0],
peak.varDoublet])
peaks.append([peak.wavDoublet[1], peak.ampDoublet[1],
peak.varDoublet])
else:
peaks.append([peak.wavSinglet, peak.ampSinglet, peak.varSinglet])
peak_number = len(peak_candidates)
if (peak_number > 1 or doublet) and detection:
if doPlot:
fit = 0.0
for k in np.arange(len(peaks)):
fit = fit + gauss(obj.wave, x_0=peaks[k][0], A=peaks[k][1],
var=peaks[k][2])
o3hbflux = gauss3(obj.wave, fitRes, 4862.68 * (1.0 + z_s),
4960.30 * (1.0 + z_s), 5008.24 * (1.0 + z_s))
o3b = [4842.68 * (1.0 + z_s), 5028.24 * (1.0 + z_s)]
o3hbwave = [4862.68 * (1.0 + z_s) - fitRes[0],
5008.24 * (1.0 + z_s) - fitRes[3]]
plotGalaxyLens(doublet, obj, savedir, peak_candidates, preProd,
nxtProd, doublet_index, fit, o3hbflux, fitChi, o3b,
o3hbwave)
if doublet:
x_doublet = np.mean(peak_candidates[doublet_index].wavDoublet)
bd = np.linspace(obj.wave2bin(x_doublet) - 10,
obj.wave2bin(x_doublet) + 10, 21, dtype=np.int16)
galSaveflux(obj.reduced_flux[bd], obj.fiberid, savedir)
def getisosweights_sgauss(weights, age, sfr, metallicity, isos, sigma,
dsigmadlogt):
""" Same as getisoweights, but adds sfr-dependent Gaussian scatter.
**** CAUTION: not yet tested ****
"""
w = [0.] * len(isos)
logt0 = numarray.log10(age[0])
for m, a, feh, s in zip(weights, age, metallicity, sfr):
ss = numarray.maximum(sfr, 1.e-5)
logs = numarray.log10(ss)
logt = numarray.log10(a)
sig = sigma + dsigmadlogs * (logs)
for x in utils.frange(feh - 4, feh + 4, 0.1):
w[getn(x, a, isos)] += m * utils.gauss(x, feh, sig)
return w
def _results(self,sampler):
best = sampler.flatchain[sampler.flatlnprobability.argmax()]
tres = int(np.rint(best[0]))
best = best[1:].reshape(self.channels,7)
newSfilt = np.empty((self.channels,self.sres))
newTfilt = np.empty((self.channels,tres))
for i in range(self.channels):
z1,p1,p2,p3,l, mu, sig = best[i]
newTfilt[i] = np.asarray(utils.overtime(0,tres,utils.P3Z1,z1,p1,p2,p3,l,1))
newSfilt[i] = utils.gauss(np.arange(0,self.sres),mu,sig)
newstrf = np.dot(newSfilt.T,newTfilt)
newstrf /= np.max(np.abs(newstrf))
self.sampler = sampler
self.maxlik = (newstrf,newSfilt,newTfilt)
def gettruedailybaseline(self,maxadc=None,corr=None):
dataarray = []
nrofday = int((self.time[-1] - self.time[0])/(24*60*60))
firstday = utils.tstamptodatetime(self.time[0])
lastday = utils.tstamptodatetime(self.time[-1])
firstday = datetime.datetime(firstday.year,firstday.month,firstday.day,0,0,0)
hour = 0
minute = 0
length = 216
for d in range(0,nrofday,1):
t0 = firstday + datetime.timedelta(days=d)
t1 = firstday + datetime.timedelta(days=d+1)
t0 = utils.datettotimestamp(t0)
t1 = utils.datettotimestamp(t1)
daydata = self.getnewdataset(t0,t1)
if len(daydata.radio)== length and len(daydata.tempLL)== length:
dataarray.append(daydata)
count = 0
truebls = []
truetemps = []
radtemp = []
#produce fake signal
if maxadc!=None:
time = np.linspace(0,24,length)
a = maxadc
b = 17
c = 2
sig = utils.gauss(time,a,b,c)
for dat in dataarray:
rt = radiotemp.Radiotemp()
if corr == None or corr==True:
radiodata = dat.radioc
# print 'dat.radio = ', dat.radio
rt.corr = True
else:
radiodata = dat.radio
rt.corr = False
truebl = radiodata
if maxadc!=None:
truebl = truebl - sig
truetemps.append(dat.tempLL)
rt.radio = truebl
rt.temp = dat.tempLL
rt.date = dat.date
# print 'rt.date = ' , rt.date
radtemp.append(rt)
return radtemp
def sumisos_gauss(mass, age, metallicity, fehlist, agelist, isos, sigma):
"""Faster version."""
isoweight = {}
for k in isos.keys():
isoweight[k] = 0.
for m, a, z in zip(mass, age, metallicity):
feh = numarray.log10(z / SOLAR)
for x in utils.frange(feh - 4, feh + 4, 0.1):
isoweight[getindices(x, a, fehlist,
agelist)] += utils.gauss(x, feh, sigma) * m
summed_iso = 0. * isos[isos.keys()[0]]
for k in isoweight.keys():
summed_iso += isoweight[k] * isos[k]
# p(isoweight)
return summed_iso
def galSave(doublet, obj, peak_candidates, doublet_index, savedir, em_lines,
doPlot, prodCrit=0.6):
detection = False
preProd = 1.0
nxtProd = 1.0
if doublet:
if len(peak_candidates):
preProd, nxtProd = fitcSpec(obj, peak_candidates[doublet_index])
if preProd + nxtProd > prodCrit:
raise Exception("Rejected by comparing to other fibers")
z_s = peak_candidates[doublet_index].wavelength / 3727.24 - 1.0
detection = _doubletSave(obj, z_s, peak_candidates, doublet_index,
savedir, preProd, nxtProd)
if len(peak_candidates):
detection = _dblmultSave(obj, z_s, peak_candidates, savedir,
detection, em_lines)
elif len(peak_candidates) > 1:
detection = _multletSave(obj, peak_candidates, savedir, em_lines)
peaks = []
for k in range(len(peak_candidates)):
peak = peak_candidates[k]
if k == doublet_index and doublet:
peaks.append([peak.wavDoublet[0], peak.ampDoublet[0],
peak.varDoublet])
peaks.append([peak.wavDoublet[1], peak.ampDoublet[1],
peak.varDoublet])
else:
peaks.append([peak.wavSinglet, peak.ampSinglet, peak.varSinglet])
peak_number = len(peak_candidates)
if (peak_number > 1 or doublet) and detection:
if doPlot:
fit = 0.0
for k in np.arange(len(peaks)):
fit = fit + gauss(obj.wave, x_0=peaks[k][0], A=peaks[k][1],
var=peaks[k][2])
plotGalaxyLens(doublet, obj, savedir, peak_candidates, preProd,
nxtProd, doublet_index, fit)
if doublet:
x_doublet = np.mean(peak_candidates[doublet_index].wavDoublet)
bd = np.linspace(obj.wave2bin(x_doublet) - 10,
obj.wave2bin(x_doublet) + 10, 21, dtype=np.int16)
galSaveflux(obj.reduced_flux[bd], obj.fiberid, savedir)
def qsoContfit(obj, peak, searchLyA, sig, window_width = 40):
'''
peakFinder.qsoContfit(obj, peak, searchLyA, window_width)
=============================
A function to fit the QSO continuum near a peak with a 3rd order polynomial
and subtract it. Add the new SN of the peak in its class.
Parameters:
obj: The SDSS object/spectra on which applied the subtraction
peak: The inquired peak
sig: Sigma of gaussian to perform SN max-likelihood
searchLyA: True if we search for background LAE, False for backgroung ELGs
window_width: Half-width (Angstroms) on which the polynomial is fitted
Returns:
accept: True if the SN is still high after subtraction. False otherwise.
'''
x0 = peak.wavelength
window = np.linspace(obj.wave2bin(x0)-window_width,obj.wave2bin(x0)+window_width,2*window_width+1,dtype = np.int16)
median_local = np.median(obj.reduced_flux[window])
fit_QSO = np.poly1d(np.polyfit(x=obj.wave[window],y=obj.reduced_flux[window],deg=3, \
w=(np.abs(obj.reduced_flux[window]-median_local)<5)*np.sqrt(obj.ivar[window])) )
new_flux = obj.reduced_flux[window] - fit_QSO(obj.wave[window])
NormGauss = gauss(np.linspace(-window_width * 0.5, window_width * 0.5, window_width), 0.0, 1.0,sig ** 2.0)
NormGauss = NormGauss / np.sum(NormGauss)
cj1_new = np.sum(new_flux*kernel(int(len(window)/2),window_width,NormGauss,len(new_flux))*obj.ivar[window])
cj2_new = np.sum(obj.ivar[window]*kernel(int(len(window)/2),window_width,NormGauss,len(window))**2)
SN_fitted = cj1_new/np.sqrt(cj2_new)
if searchLyA and SN_fitted < 6:
return False #Reject
elif searchLyA and SN_fitted > 6:
peak.reduced_sn = SN_fitted
obj.reduced_flux_QSO[window]=new_flux
elif searchLyA == False and SN_fitted < 6:
return False # Reject
elif searchLyA == False and SN_fitted > 6:
peak.reduced_sn = SN_fitted
obj.reduced_flux_QSO[window]=new_flux
return True # Accept
def BeamElem(e):
"""
Calculate element stiffness matrix and element nodal body force vector
Args:
e : (int) element number
Returns: ke, fe
ke : (numpy(neqe,neqe)) element stiffness matrix
fe : (numpy(neqe,1)) element nodal force vector
"""
IENe = model.IEN[:, e] - 1 # extract local connectivity information
xe = model.x[IENe] # extract element x coordinates
J = (xe[model.nen - 1] - xe[0]) / 2 # compute Jacobian
w, gp = gauss(model.ngp)
ke = np.zeros((model.neqe, model.neqe))
fe = np.zeros((model.neqe, 1))
for i in range(model.ngp):
N = Nmatrix1D(gp[i], xe)
B = Bmatrix1D(gp[i], xe) * 1 / J**2
Ae = N[0][::2] @ model.CArea[IENe]
Ee = model.E[e]
be = model.body[e]
ke = ke + w[i] * Ae * Ee * (B.T @ B)
fe = fe + w[i] * N.T * be
ke = J * ke
fe = J * fe
for i in range(model.np):
Pi = model.P[i]
xpi = model.xp[i]
if xe[0] <= xpi < xe[-1]:
fe = fe + Pi * np.transpose(
Nmatrix1D((2 * xpi - xe[0] - xe[-1]) / (xe[-1] - xe[0]), xe))
return ke, fe
def find_gw(events, eventname, datadir):
"""Find Gravitational waves
Use utils.py function to search for GWs in LIGO data for a given event
Args:
events (dict): metadata about events, loaded from json file
eventname (str): name of a specific event
datadir (str): relative path to where the data is stored
"""
# permanent parameters (for plotting)
titlesize = 20
labelsize = 14
legsize = 14
# ############# OVERVIEW OF DATA #############
print('DATA OVERVIEW')
# load everything
time, fs, strains, templs = ut.load_event(eventname, datadir, events)
strain_H1, strain_L1 = strains
templ_H1, templ_L1 = templs
toff = time.min() # set time offset
# get frequencies for the dataset
freqs = np.fft.rfftfreq(strain_H1.size, 1.0 / fs)
# first plot of data and templates
fig, ax = plt.subplots(nrows=2, ncols=1, sharex=True, figsize=(8, 6))
ax[0].plot(time - toff,
strain_H1 * 1e19,
linewidth=0.5,
color='b',
label='H1 Data')
ax[0].plot(time - toff,
strain_L1 * 1e19,
linewidth=0.5,
color='r',
label='L1 Data')
ax[0].set_ylabel(r'Strain $\times 10^{19}$', fontsize=labelsize)
ax[0].legend(loc=1, fontsize=legsize)
ax[0].set_title('LIGO Data for event {}'.format(eventname),
fontsize=titlesize)
ax[1].plot(time - toff,
templ_H1 * 1e19,
linewidth=0.5,
color='b',
label='H1 Template')
ax[1].plot(time - toff,
templ_L1 * 1e19,
linewidth=0.5,
color='r',
label='L1 Template')
ax[1].set_ylabel(r'Strain $\times 10^{19}$', fontsize=labelsize)
ax[1].set_xlabel(r'GPS Time-{} $\times 10^{{9}}$ s'.format(toff / 1e9),
fontsize=labelsize)
ax[1].legend(loc=1, fontsize=legsize)
plt.show()
print()
print()
# ############# PART A (NOISE MODEL) #############
print('(a) NOISE MODEL')
# get power spectrum for each detector
window = np.blackman(strain_H1.size)
powers_H1 = ut.powerspec(strain_H1, window=window)
powers_L1 = ut.powerspec(strain_L1, window=window)
# plot the ASD
plt.loglog(freqs, np.sqrt(powers_H1), 'b', label='H1')
plt.loglog(freqs, np.sqrt(powers_L1), 'r', label='L1')
plt.xlim(20, 2000) # focus on interesting range
plt.ylabel(r'ASD (strain/$\sqrt{\textrm{Hz}}$)', fontsize=labelsize)
plt.xlabel(r'Frequency (Hz)', fontsize=labelsize)
plt.title(
r'Log-log plot of the Amplitude Spectrums for {}'.format(eventname),
fontsize=titlesize)
plt.legend(loc=1, fontsize=legsize)
plt.show()
print()
print()
# ############# PART B (MATCHED FILTER) #############
print('(b) MATCHED FILTER')
# get filter output
mf_H1 = ut.matchedfilt(strain_H1, templ_H1, powers_H1, window=window)
mf_L1 = ut.matchedfilt(strain_L1, templ_L1, powers_L1, window=window)
# show filter output
fig, ax = plt.subplots(nrows=2, ncols=1, sharex=True, figsize=(8, 6))
ax[0].plot(time - toff, mf_H1, linewidth=0.5, color='b', label='H1 Output')
ax[0].set_ylabel(r'Filter Output', fontsize=labelsize)
ax[0].legend(loc=1, fontsize=legsize)
ax[0].set_title('Matched Filtering Outputs in Time Domain',
fontsize=titlesize)
ax[1].plot(time - toff, mf_L1, linewidth=0.5, color='r', label='L1 Output')
ax[1].set_ylabel(r'Filter Output', fontsize=labelsize)
ax[1].set_xlabel(r'GPS Time-{} $\times 10^{{9}}$ s'.format(toff / 1e9),
fontsize=labelsize)
ax[1].legend(loc=1, fontsize=legsize)
plt.show()
print()
print()
# ############# PART C (SNR) #############
print('(c) SNR')
# get snr for each detector
snr_H1 = ut.get_snr(mf_H1, templ_H1, powers_H1, window=window)
snr_L1 = ut.get_snr(mf_L1, templ_L1, powers_L1, window=window)
snr_tot = np.sqrt(snr_H1**2 + snr_L1**2)
# print SNR max
print("Max SNR H1: {:.4f}".format(np.max(snr_H1)))
print("Max SNR L1: {:.4f}".format(np.max(snr_L1)))
print("Max SNR (total): {:.4f}".format(np.max(snr_tot)))
# show SNR
fig, ax = plt.subplots(nrows=3, ncols=1, sharex=True, figsize=(8, 9))
ax[0].plot(time - toff, snr_H1, linewidth=0.5, color='b', label='H1 SNR')
ax[0].set_ylabel(r'SNR', fontsize=labelsize)
ax[0].legend(loc=1, fontsize=legsize)
ax[0].set_title('Signal to Noise Ratio (SNR) in Time Domain',
fontsize=titlesize)
ax[1].plot(time - toff, snr_L1, linewidth=0.5, color='r', label='L1 SNR')
ax[1].set_ylabel(r'SNR', fontsize=labelsize)
ax[1].legend(loc=1, fontsize=legsize)
ax[2].plot(time - toff,
snr_tot,
linewidth=0.5,
color='g',
label='Combined SNR')
ax[2].set_ylabel(r'SNR', fontsize=labelsize)
ax[2].set_xlabel(r'GPS Time-{} $\times 10^{{9}}$ s'.format(toff / 1e9),
fontsize=labelsize)
ax[2].legend(loc=1, fontsize=legsize)
plt.show()
print()
print()
# ############# PART D (ANALYTIC SNR) #############
print('(d) ANALYTIC SNR')
# get snr for each detector
esnr_H1 = ut.expect_snr(templ_H1, powers_H1, window=window)
esnr_L1 = ut.expect_snr(templ_L1, powers_L1, window=window)
esnr_tot = np.sqrt(esnr_H1**2 + esnr_L1**2)
# print SNR max
print("Max SNR H1: {:.4f}".format(np.max(esnr_H1)))
print("Max SNR L1: {:.4f}".format(np.max(esnr_L1)))
print("Max SNR (total): {:.4f}".format(np.max(esnr_tot)))
# show SNR
fig, ax = plt.subplots(nrows=3, ncols=1, sharex=True, figsize=(8, 9))
ax[0].plot(time - toff, esnr_H1, linewidth=0.5, color='b', label='H1 SNR')
ax[0].set_ylabel(r'SNR', fontsize=labelsize)
ax[0].legend(loc=1, fontsize=legsize)
ax[0].set_title('Analytic Expected SNR in Time Domain', fontsize=titlesize)
ax[1].plot(time - toff, esnr_L1, linewidth=0.5, color='r', label='L1 SNR')
ax[1].set_ylabel(r'SNR', fontsize=labelsize)
ax[1].legend(loc=1, fontsize=legsize)
ax[2].plot(time - toff, esnr_tot, linewidth=0.5, color='g', label='L1 SNR')
ax[2].set_ylabel(r'SNR', fontsize=labelsize)
ax[2].set_xlabel(r'GPS Time-{} $\times 10^{{9}}$ s'.format(toff / 1e9),
fontsize=labelsize)
ax[2].legend(loc=1, fontsize=legsize)
plt.show()
print()
print()
# ############# PART E (HALF WEIGHT FREQUENCY) #############
print('(e) HALF POWER FREQUENCY')
# get half power frequency for each detector
hf_H1 = ut.get_hf(freqs, templ_H1, powers_H1, window=window)
hf_L1 = ut.get_hf(freqs, templ_L1, powers_L1, window=window)
print("Half frequency for H1: {} Hz".format(hf_H1))
print("Half frequency for L1: {} Hz".format(hf_L1))
print()
print()
# ############# PART F (TIME OF ARRIVAL) #############
print('(f) TIME OF ARRIVAL')
# find snr peak time
imax_H1 = np.argmax(snr_H1)
imax_L1 = np.argmax(snr_L1)
nside = 10
# get time and uncertainty for each detector
sguess = 0.001
ta_H1, eta_H1 = ut.toa(time, snr_H1, sguess=sguess, nside=nside)
ta_L1, eta_L1 = ut.toa(time, snr_L1, sguess=sguess, nside=nside)
print('H1 time of arrival: {} ± {}'.format(ta_H1, eta_H1))
print('L1 time of arrival: {} ± {}'.format(ta_L1, eta_L1))
# get Gaussian profiles
prof_H1 = ut.gauss(time[imax_H1 - nside:imax_H1 + nside], np.max(snr_H1),
ta_H1, eta_H1)
prof_L1 = ut.gauss(time[imax_L1 - nside:imax_L1 + nside], np.max(snr_L1),
ta_L1, eta_L1)
# Positional uncertainty in the sky => angle.
# We want to use the difference in time, the speed of light,
# and the difference in distance to infer an uncertainty in position angle.
# We use ~3000 km for distance
# (https://www.ligo.caltech.edu/page/ligo-detectors).
tdiff = np.abs(ta_H1 - ta_L1) * u.s
dist = 3e3 * u.km
c = 3e8 * u.m / u.s
epos = tdiff * c / dist
msg = ('Typical positional uncertainty:'
' {}'.format(epos.to('rad',
equivalencies=u.dimensionless_angles())))
print(msg)
fig, ax = plt.subplots(nrows=2, ncols=1, sharex=True, figsize=(8, 6))
ax[0].plot(
time[imax_H1 - nside:imax_H1 + nside] - toff, # SNR near arrival
snr_H1[imax_H1 - nside:imax_H1 + nside],
'bo',
label='SNR H1')
ax[0].plot(
time[imax_H1 - nside:imax_H1 + nside] - toff, # Gaussian profile
prof_H1,
'g-',
label='Gaussian profile (H1)')
ax[0].set_ylabel('SNR', fontsize=labelsize)
ax[0].set_title('Gaussian Profiles on SNR Peaks', fontsize=titlesize)
ax[0].legend(fontsize=legsize)
ax[1].plot(
time[imax_L1 - nside:imax_L1 + nside] - toff, # SNR near arrival
snr_L1[imax_L1 - nside:imax_L1 + nside],
'ro',
label='SNR L1')
ax[1].plot(
time[imax_L1 - nside:imax_L1 + nside] - toff, # Gaussian profile
prof_L1,
'c-',
label='Gaussian profile (L1)')
ax[1].set_ylabel('SNR', fontsize=labelsize)
ax[1].set_xlabel(r'GPS Time-{} $\times 10^{{9}}$ s'.format(toff / 1e9),
fontsize=labelsize)
ax[1].legend(fontsize=legsize)
plt.show()
def plot_histogram_filtering(self, good_matches, best_matches,
histogram_filter):
"""
Plots the result of the match histogram filtering
:param good_matches: array of match pairs (point in image 1 vs point in image 2)
:type good_matches: ndarray (nx2)
:param best_matches: array of histogram-filtered match pairs (point in image 1 vs point in image 2)
:type best_matches: ndarray (nx2)
:param histogram_filter: histogram filtering object
:type histogram_filter: HistogramLogicFilter
"""
img1 = self.train_image_manager.image
img2 = self.query_image_manager.image
kp1 = self.train_image_manager.keypoints
kp2 = self.query_image_manager.keypoints
angle_hist = histogram_filter.angle_histogram
length_hist = histogram_filter.length_histogram
angle_th = histogram_filter.angle_threshold
length_th = histogram_filter.length_threshold
initial_matches_img = cv2.drawMatches(img1,
kp1,
img2,
kp2,
good_matches,
None,
flags=2)
final_matches_img = cv2.drawMatches(img1,
kp1,
img2,
kp2,
best_matches,
None,
flags=2)
fig = Figure()
canvas = FigureCanvas(figure=fig)
ax = self.remove_figure_padding(fig)
n_bins = min(
int(np.pi / 10 * len(angle_hist.bin_centres) /
np.ptp(angle_hist.bin_centres)), 50)
histogram_span = [-np.pi / 20, np.pi / 20]
gaussian_samples = np.linspace(histogram_span[0], histogram_span[1],
n_bins)
ax.hist(angle_hist.data, bins=n_bins, range=histogram_span, color='b')
hist_fit_angle = gauss(gaussian_samples,
*angle_hist.fitted_gauss_coefficients)
ax.bar(angle_hist.fitted_gauss_coefficients[1] -
angle_th * angle_hist.fitted_gauss_coefficients[2] / 2,
np.max(angle_hist.histogram),
angle_th * angle_hist.fitted_gauss_coefficients[2],
alpha=0.4,
color='r')
ax.plot(gaussian_samples, hist_fit_angle, color='g')
initial_histogram_img = self.render_and_crop_canvas(canvas, ax)
fig_2 = Figure()
canvas = FigureCanvas(figure=fig_2)
ax = self.remove_figure_padding(fig_2)
ax.hist(length_hist.data, bins=length_hist.bins, color='b')
hist_fit_length = gauss(length_hist.bin_centres,
*length_hist.fitted_gauss_coefficients)
ax.bar(length_hist.fitted_gauss_coefficients[1] -
length_th * length_hist.fitted_gauss_coefficients[2] / 2,
np.max(length_hist.histogram),
length_th * length_hist.fitted_gauss_coefficients[2],
alpha=0.4,
color='r')
ax.plot(length_hist.bin_centres, hist_fit_length, color='g')
final_histogram_img = self.render_and_crop_canvas(canvas, ax)
matches_img = np.append(initial_matches_img, final_matches_img, axis=0)
final_img = self.resize_image_aspect_ratio(
np.append(initial_histogram_img, final_histogram_img, axis=0),
new_height=matches_img.shape[0])
final_img = np.append(matches_img, final_img, axis=1)
return self.image_bridge.cv2_to_compressed_imgmsg(final_img)
est_time_completion += proj.task[i].ed
est_mu += proj.task[i].mu
est_sigma += proj.task[i].sigma**2
est_sigma = est_sigma**0.5 ##### formula
proj_completion_time_3 = []
proj_completion_prob_3 = [DiscreteDistribution({
'1': 1,
'0': 0
})] * (2 * config.n_datum + 1)
for datum in range(-config.n_datum, config.n_datum + 1):
proj_completion_time_3.append(est_time_completion +
len(proj.critical) * datum)
for i in range(len(proj_completion_time_3)):
prob_node = Node('node')
td_node_prob = gauss(proj_completion_time_3[i], est_mu, est_sigma)
print(td_node_prob)
td_node = DiscreteDistribution({'1': td_node_prob, '0': 1 - td_node_prob})
prob_node.set_predecessor([td_node, total_risk_prob], prob=True)
prob_node.set_cpt(CPT_R_ED)
prob_node.calc_prob()
proj_completion_prob_3[i] = prob_node.prob.parameters[0]['1']
proj_completion_prob_2 = [i.parameters[0]['1'] for i in proj_completion_prob_2]
# print(proj_completion_prob_2)
print('=' * 50)
print('INFO TASK')
print(proj.info_task)
print('=' * 50)
print('Critical path: ', '-'.join(proj.critical_path))
print('Time to complete project: ', proj.time_completion)
def sensor_model(poses, beacon_pose, beacon_loc, tf, odom_pose):
"""Apply sensor model and return particle weights.
Parameters
----------
poses: an M x 3 array of robot poses where M is the number of
particles. Each pose is (x, y, theta) where x and y are in metres
and theta is in radians.
beacon_pose: the measured pose of the beacon (x, y, theta)
relative to the robot's camera pose.
beacon_loc: the known global pose of the beacon (x, y, theta).
Returns
-------
An M element array of particle weights. The weights do not need to be
normalised.
"""
# For each particle calculate its weight based on its pose,
# the relative beacon pose, and the global beacon location.
beacon_measured = np.zeros(3)
# Distance to the beacon from the robot
distance_b = np.sqrt(beacon_pose[0]**2 + beacon_pose[1]**2)
# This is bearing to beacon from local frame x axis
bearing = odom_pose[2] + np.arctan2(beacon_pose[1], beacon_pose[0])
# Using correct trig transform for the quadrant the bearing is in to find x and y as local
if (np.pi / 2) < bearing < -(np.pi / 2):
x_add = distance_b * np.sin(bearing % (np.pi / 2))
y_add = distance_b * np.cos(bearing % (np.pi / 2))
else:
x_add = distance_b * np.cos(bearing)
y_add = distance_b * np.sin(bearing)
#print(x_add, ' = x global ', y_add, ' = y global ')
#print(beacon_pose[0], ' = x ', beacon_pose[1], ' = y ')
#print('range global = ', np.sqrt(x_add**2 + y_add**2), 'range measured = ', np.sqrt(beacon_pose[0]**2 + beacon_pose[1]**2))
# This is the local beacon location from measurement
beacon_measured[0] = odom_pose[0] + x_add
beacon_measured[1] = odom_pose[1] + y_add
beacon_measured[2] = beacon_pose[2]
# This transforms the local poses into global poses
g_beacon_mes = transform.transform_pose(tf, beacon_measured)
g_robot_pose = transform.transform_pose(tf, odom_pose)
# This is the robot range and angle from pg. 122 of the notes.
robot_range = np.sqrt((g_beacon_mes[0] - g_robot_pose[0])**2 +
(g_beacon_mes[1] - g_robot_pose[1])**2)
robot_angle = angle_difference(
g_robot_pose[2],
np.arctan((g_beacon_mes[1] - g_robot_pose[1]) /
(g_beacon_mes[0] - g_robot_pose[0])))
# This is the particle range and angle from pg. 122 of the notes.
particle_range = np.sqrt((beacon_loc[0] - poses[:, 0])**2 +
(beacon_loc[1] - poses[:, 1])**2)
particle_angle = angle_difference(
poses[:, 2],
np.arctan(
(beacon_loc[1] - poses[:, 1]) / (beacon_loc[0] - poses[:, 0])))
M = poses.shape[0]
weights = np.ones(M)
#print('robot_range - particle_range', robot_range-particle_range)
#print('robot_angle - particle_angle', angle_difference(particle_angle, robot_angle))
#print('gauss of range diff = ', gauss(robot_range - particle_range, 0.01))
#print('gauss of angle diff = ', *gauss( angle_difference(particle_angle, robot_angle) , 0.01 ))
# Weights calculated by multiplying PDFs. dont need to be normalised.
weights = gauss(robot_range - particle_range, sigma=0.1) * gauss(
angle_difference(robot_angle, particle_angle), sigma=0.1)
return weights
def disp_moment_and_shear(e, ax1, ax2, ax3):
"""
Print the moments and shear forces at the Gauss points, plot displacements,
moments and shear forces distributions obtained by FE analysis.
Args:
e: (int) element number
ax1 : axis to draw displacement distribution
ax2 : axis to draw moment distribution
ax3 : axis to draw shear force distribution
"""
de = model.d[model.LM[:, e] - 1]
IENe = model.IEN[:, e] - 1
xe = model.x[IENe]
J = (xe[-1] - xe[0]) / 2
w, gp = gauss(model.ngp)
gauss_pt = np.zeros(model.ngp)
moment_gauss = np.zeros(model.ngp)
shear_gauss = np.zeros(model.ngp)
for i in range(model.ngp):
gauss_pt[i] = 0.5 * (xe[0] + xe[-1]) + J * gp[i]
N = Nmatrix1D(gp[i], xe)
B = Bmatrix1D(gp[i], xe) * 1 / J**2
S = Smatrix1D(gp[i], xe) * 1 / J**3
Ee = model.E[e]
moment_gauss[i] = Ee * B @ de
shear_gauss[i] = Ee * S @ de
print("%8d %12.6f %12.6f %16.6f %16.6f %16.6f %16.6f" %
(e, gauss_pt[0], gauss_pt[1], moment_gauss[0], moment_gauss[1],
shear_gauss[0], shear_gauss[1]))
# equally distributed coordinate within an element
xplot = np.linspace(xe[0], xe[-1], model.nplot)
xplotgauss = (2 * xplot - xe[0] - xe[-1]) / (xe[-1] - xe[0])
displacement = np.zeros(model.nplot)
moment = np.zeros(model.nplot)
shear = np.zeros(model.nplot)
for i in range(model.nplot):
xi = xplotgauss[i]
N = Nmatrix1D(xi, xe)
B = Bmatrix1D(xi, xe) * 1 / J**2
S = Smatrix1D(xi, xe) * 1 / J**3
Ee = model.E[e]
displacement[i] = N @ de
moment[i] = Ee * B @ de
shear[i] = Ee * S @ de
# plot displacements and moments and shear forces
line1, = ax1.plot(xplot, displacement)
line2, = ax2.plot(xplot, moment)
line3, = ax3.plot(xplot, shear)
if e == 0:
line1.set_label('FE')
line2.set_label('FE')
line3.set_label('FE')
def getfakedailybaseline(self,typeofbl=None,maxadc=None,corr=None):
# self.tempcorrection(1)
dataarray = []
nrofday = int((self.time[-1] - self.time[0])/(24*60*60))
firstday = utils.tstamptodatetime(self.time[0])
lastday = utils.tstamptodatetime(self.time[-1])
firstday = datetime.datetime(firstday.year,firstday.month,firstday.day,0,0,0)
hour = 0
minute = 0
for d in range(0,nrofday,1):
t0 = firstday + datetime.timedelta(days=d)
t1 = firstday + datetime.timedelta(days=d+1)
t0 = utils.datettotimestamp(t0)
t1 = utils.datettotimestamp(t1)
daydata = self.getnewdataset(t0,t1)
if len(daydata.radio) > 215:
dataarray.append(daydata)
sizeofdat = len(dataarray)
maxlen = 216 # maximum nr of point in one day (1 point every 400s)
# 1) create a average spectrum
maxfreq = np.fft.rfftfreq(maxlen,400)
specarray = np.ndarray(shape= (len(dataarray), len(maxfreq) ) )
phasearray =np.ndarray(shape= (len(dataarray), len(maxfreq) ) )
count = 0
for dat in dataarray:
if corr == None or corr==True:
radiodata = dat.radioc
else:
radiodata = dat.radio
fft = np.fft.rfft(radiodata)
spec = np.absolute(fft)
phase = np.angle(fft)
freq = np.fft.rfftfreq(len(radiodata),400)
spec = np.interp(maxfreq,freq,spec)
phase = np.interp(maxfreq,freq,phase)
specarray[count] = spec
phasearray[count] = phase
count +=1
meanspec = np.mean(specarray,axis=0)
stdspec = np.std(specarray,axis=0)
# we set the number of possible baseline as the possible combination
# of spectrum/phase from real data
nrfake = sizeofdat*sizeofdat
# we have implemented two possibilities to produce fake baseline:
# - either we draw a random spectrum around the mean spectrum and then
# assume one of the phase of the data
# - either we combine one spectrum with one phase.
# 2) draw random spectrum:
radtemp = []
fakebls = []
random = False
combine = False
if typeofbl.lower()=='random':
for i in range(nrfake):
fakespec = np.array([])
for m,s in zip(meanspec,stdspec):
specpoint = np.random.normal(m,s)
fakespec = np.append(fakespec,specpoint)
phaseindex = int(np.random.uniform(0,sizeofdat))
fakephase = phasearray[phaseindex]
fakefft = fakespec*np.exp(1J*fakephase)
fakebl = np.fft.irfft(fakefft)
fakebls.append(fakebl)
# 3) draw a particular phase
elif typeofbl.lower() == 'combine' or typeofbl==None:
for i in range(sizeofdat):
specindex = i
for j in range(i, i+sizeofdat):
phaseindex = j%sizeofdat
fakespec = specarray[specindex]
fakephase = phasearray[phaseindex]
fakefft = fakespec*np.exp(1J*fakephase)
fakebl = np.fft.irfft(fakefft)
fakebls.append(fakebl)
if maxadc == None:
maxadc = 0
#produce fake signal
time = np.linspace(0,24,len(fakebls[0]))
a = maxadc
b = 17
c = 2
sig = utils.gauss(time,a,b,c)
count = 0
for bl in fakebls:
rt = radiotemp.Radiotemp()
bl = bl - sig
fakebls[count] = bl
rt.radio = bl
rt.corr = corr
radtemp.append(rt)
count +=1
return radtemp
