def smooth(tod, srate, fknee=10, alpha=10):
ft = fft.rfft(tod)
freq = fft.rfftfreq(tod.shape[-1]) * srate
flt = 1 / (1 + (freq / fknee)**alpha)
ft *= flt
fft.ifft(ft, tod, normalize=True)
return tod
def smooth(tod, srate): ft = fft.rfft(tod) freq = fft.rfftfreq(tod.shape[-1])*srate flt = 1/(1+(freq/model_fknee)**model_alpha) ft *= flt fft.ifft(ft, tod, normalize=True) return tod
def smooth(tod, srate, fknee=10, alpha=10): ft = fft.rfft(tod) freq = fft.rfftfreq(tod.shape[-1])*srate flt = 1/(1+(freq/fknee)**alpha) ft *= flt fft.ifft(ft, tod, normalize=True) return tod
def smooth(tod, srate):
ft = fft.rfft(tod)
freq = fft.rfftfreq(tod.shape[-1]) * srate
flt = 1 / (1 + (freq / model_fknee)**model_alpha)
ft *= flt
fft.ifft(ft, tod, normalize=True)
return tod
def __init__(self, shape, inspec, scale):
freqs = fft.rfftfreq(shape[-2]) * scale
# Should check units of fourier space here. Should
# rescaling from samples to az change the value of the
# spectrum? How much of that is handled by the hitcounts?
self.spec_full = utils.interpol(inspec, freqs[None])
self.scale = scale
def __init__(self, shape, inspec, scale): freqs = fft.rfftfreq(shape[-2]) * scale # Should check units of fourier space here. Should # rescaling from samples to az change the value of the # spectrum? How much of that is handled by the hitcounts? self.spec_full = utils.interpol(inspec, freqs[None]) self.scale = scale
def estimate_atmosphere(tod, region_cut, srate, fknee, alpha):
model = gapfill.gapfill_joneig(tod, region_cut, inplace=False)
ft = fft.rfft(model)
freq = fft.rfftfreq(model.shape[-1]) * srate
flt = 1 / (1 + (freq / fknee)**alpha)
ft *= flt
fft.ifft(ft, model, normalize=True)
return model
def estimate_atmosphere(tod, region_cut, srate, fknee, alpha): model = gapfill.gapfill_joneig(tod, region_cut, inplace=False) ft = fft.rfft(model) freq = fft.rfftfreq(model.shape[-1])*srate flt = 1/(1+(freq/fknee)**alpha) ft *= flt fft.ifft(ft, model, normalize=True) return model
def broaden_beam_hor(tod, d, ibeam, obeam): ft = fft.rfft(tod) k = 2*np.pi*fft.rfftfreq(d.nsamp, 1/d.srate) el = np.mean(d.boresight[2,::100]) skyspeed = d.speed*np.cos(el) sigma = (obeam**2-ibeam**2)**0.5 ft *= np.exp(-0.5*(sigma/skyspeed)**2*k**2) fft.ifft(ft, tod, normalize=True)
def broaden_beam_hor(tod, d, ibeam, obeam):
ft = fft.rfft(tod)
k = 2 * np.pi * fft.rfftfreq(d.nsamp, 1 / d.srate)
el = np.mean(d.boresight[2, ::100])
skyspeed = d.speed * np.cos(el)
sigma = (obeam**2 - ibeam**2)**0.5
ft *= np.exp(-0.5 * (sigma / skyspeed)**2 * k**2)
fft.ifft(ft, tod, normalize=True)
def __init__(self, scan, model=None, window=None, filter=None):
model = config.get("noise_model", model)
window = config.get("tod_window", window)*scan.srate
nmat.apply_window(scan.tod, window)
self.nmat = nmat_measure.NmatBuildDelayed(model, cut=scan.cut_noiseest, spikes=scan.spikes)
self.nmat = self.nmat.update(scan.tod, scan.srate)
nmat.apply_window(scan.tod, window, inverse=True)
self.model, self.window = model, window
self.ivar = self.nmat.ivar
self.cut = scan.cut
# Optional extra filter
if filter:
freq = fft.rfftfreq(scan.nsamp, 1/scan.srate)
fknee, alpha = filter
with utils.nowarn():
self.filter = (1 + (freq/fknee)**-alpha)**-1
else: self.filter = None
def build_rangedata(tod, rcut, d, ivar):
nmax = np.max(rcut.ranges[:, 1] - rcut.ranges[:, 0])
nrange = rcut.nrange
rdata = bunch.Bunch()
rdata.detmap = np.zeros(nrange, int)
rdata.tod = np.zeros([nrange, nmax], dtype)
rdata.pos = np.zeros([nrange, nmax, 2])
rdata.ivar = np.zeros([nrange, nmax], dtype)
# Build our detector mapping
for di in range(rcut.ndet):
rdata.detmap[rcut.detmap[di]:rcut.detmap[di + 1]] = di
rdata.n = rcut.ranges[:, 1] - rcut.ranges[:, 0]
# Extract our tod samples and coordinates
for i, r in enumerate(rcut.ranges):
di = rdata.detmap[i]
rn = r[1] - r[0]
rdata.tod[i, :rn] = tod[di, r[0]:r[1]]
bore = d.boresight[:, r[0]:r[1]]
mjd = utils.ctime2mjd(bore[0])
pos_hor = bore[1:] + d.point_offset[di, :, None]
pos_rel = coordinates.transform(tod_sys,
sys,
pos_hor,
time=mjd,
site=d.site)
rdata.pos[i, :rn] = pos_rel.T
# Expand noise ivar too, including the effect of our normal data cut
rdata.ivar[
i, :rn] = ivar[di] * (1 - d.cut[di:di + 1, r[0]:r[1]].to_mask()[0])
# Precompute our fourier space units
rdata.freqs = fft.rfftfreq(nmax, 1 / d.srate)
# And precompute out butterworth filter
rdata.butter = filters.mce_filter(rdata.freqs, d.mce_fsamp, d.mce_params)
# Store the fiducial time constants for reference
rdata.tau = d.tau
# These are also nice to have
rdata.dsens = ivar**-0.5 / d.srate**0.5
rdata.asens = np.sum(ivar)**-0.5 / d.srate**0.5
rdata.srate = d.srate
rdata.dets = d.dets
rdata.beam = d.beam
rdata.id = d.entry.id
return rdata
def __init__(self,
fwhm,
vel,
dec_ref,
fknee,
alpha,
nsigma=1000,
nsub=50,
order=3):
# Vel is [dra,ddec]/s.
sigma = fwhm / (8 * np.log(2))**0.5
res = sigma / nsub
vel = np.array(vel)
vel[0] *= np.cos(dec_ref)
speed = np.sum(vel**2)**0.5
# Build coordinate system along velocity
npoint = 2 * nsigma * nsub
x = (np.arange(npoint) - npoint / 2) * res
# Build the beam along the velocity
vbeam = np.exp(-0.5 * (x**2 / sigma**2))
# Apply fourier filter. Our angular step size is res radians. This
# corresponds to a time step of res/speed in seconds.
fbeam = fft.rfft(vbeam)
freq = fft.rfftfreq(npoint, res / speed)
fbeam[1:] /= 1 + (freq[1:] / fknee)**-alpha
vbeam = fft.ifft(fbeam, vbeam, normalize=True)
# Beam should be zero at large distances
vbeam -= vbeam[0]
# Prefilter for fast lookups
vbeam = utils.interpol_prefilter(vbeam, npre=0, order=order)
# The total beam will be this beam times a normal one in the
# perpendicular direction.
self.dec_ref = dec_ref
self.e_para = vel / np.sum(vel**2)**0.5
self.e_orto = np.array([-self.e_para[1], self.e_para[0]])
self.sigma = sigma
self.res = res
self.vbeam = vbeam
self.order = order
# Not really necessary to store these
self.fwhm = fwhm
self.vel = vel # physical
self.fknee = fknee
self.alpha = alpha
def build_rangedata(tod, rcut, d, ivar): nmax = np.max(rcut.ranges[:,1]-rcut.ranges[:,0]) nrange = rcut.nrange rdata = bunch.Bunch() rdata.detmap = np.zeros(nrange,int) rdata.tod = np.zeros([nrange,nmax],dtype) rdata.pos = np.zeros([nrange,nmax,2]) rdata.ivar= np.zeros([nrange,nmax],dtype) # Build our detector mapping for di in range(rcut.ndet): rdata.detmap[rcut.detmap[di]:rcut.detmap[di+1]] = di rdata.n = rcut.ranges[:,1]-rcut.ranges[:,0] # Extract our tod samples and coordinates for i, r in enumerate(rcut.ranges): di = rdata.detmap[i] rn = r[1]-r[0] rdata.tod[i,:rn] = tod[di,r[0]:r[1]] bore = d.boresight[:,r[0]:r[1]] mjd = utils.ctime2mjd(bore[0]) pos_hor = bore[1:] + d.point_offset[di,:,None] pos_rel = coordinates.transform(tod_sys, sys, pos_hor, time=mjd, site=d.site) rdata.pos[i,:rn] = pos_rel.T # Expand noise ivar too, including the effect of our normal data cut rdata.ivar[i,:rn] = ivar[di] * (1-d.cut[di:di+1,r[0]:r[1]].to_mask()[0]) # Precompute our fourier space units rdata.freqs = fft.rfftfreq(nmax, 1/d.srate) # And precompute out butterworth filter rdata.butter = filters.mce_filter(rdata.freqs, d.mce_fsamp, d.mce_params) # Store the fiducial time constants for reference rdata.tau = d.tau # These are also nice to have rdata.dsens = ivar**-0.5 / d.srate**0.5 rdata.asens = np.sum(ivar)**-0.5 / d.srate**0.5 rdata.srate = d.srate rdata.dets = d.dets rdata.beam = d.beam rdata.id = d.entry.id return rdata
def __init__(self, fwhm, vel, dec_ref, fknee, alpha, nsigma=1000, nsub=50, order=3): # Vel is [dra,ddec]/s. sigma = fwhm/(8*np.log(2))**0.5 res = sigma/nsub vel = np.array(vel) vel[0]*= np.cos(dec_ref) speed = np.sum(vel**2)**0.5 # Build coordinate system along velocity npoint = 2*nsigma*nsub x = (np.arange(npoint)-npoint/2)*res # Build the beam along the velocity vbeam = np.exp(-0.5*(x**2/sigma**2)) # Apply fourier filter. Our angular step size is res radians. This # corresponds to a time step of res/speed in seconds. fbeam = fft.rfft(vbeam) freq = fft.rfftfreq(npoint, res/speed) fbeam[1:] /= 1 + (freq[1:]/fknee)**-alpha vbeam = fft.ifft(fbeam, vbeam, normalize=True) # Beam should be zero at large distances vbeam -= vbeam[0] # Prefilter for fast lookups vbeam = utils.interpol_prefilter(vbeam, npre=0, order=order) # The total beam will be this beam times a normal one in the # perpendicular direction. self.dec_ref = dec_ref self.e_para = vel/np.sum(vel**2)**0.5 self.e_orto = np.array([-self.e_para[1],self.e_para[0]]) self.sigma = sigma self.res = res self.vbeam = vbeam self.order = order # Not really necessary to store these self.fwhm = fwhm self.vel = vel # physical self.fknee = fknee self.alpha = alpha
entry = filedb.data[id]
try:
with bench.mark("read"):
d = actdata.read(entry)
with bench.mark("calib"):
d = actdata.calibrate(d, exclude=["autocut"])
if d.ndet < 2 or d.nsamp < 1: raise errors.DataMissing("no data in tod")
except errors.DataMissing as e:
print "%s skipped: %s" % (id, e.message)
continue
tod = d.tod.astype(dtype)
del d.tod
# Apply high-pass filter. Will assume white tod after this
with bench.mark("filter"):
freqs = fft.rfftfreq(d.nsamp)*d.srate
ft = fft.rfft(tod)
ps = np.abs(ft)**2
rpows = [measure_power(ps,rfreq,drfreq,d.srate) for rfreq,drfreq in zip(rfreqs, drfreqs)]
rpows = np.array(rpows)
# Determine the fknee to use. First get a typical spectrum.
# This does not work well with s16, which currently doesn't
# have time constants.
ps = np.median(ps,0)
bps = bin_spectrum(ps, bsize_fknee)
fknee = measure_fknee(bps, d.srate/2/ps.size*bsize_fknee)
#np.savetxt("ps.txt", ps)
#1/0
fknee *= args.fknee_mul
ft[:,0] = 0
ft[:,1:] /= 1 + (freqs[1:]/fknee)**-args.alpha
diff = diff[:,:diff.shape[-1]/csize*csize].reshape(d.ndet,-1,csize)
ivar = 1/(np.median(np.mean(diff**2,-1),-1)/2**0.5)
del diff
# Generate planet cut
with bench.show("planet cut"):
planet_cut = cuts.avoidance_cut(d.boresight, d.point_offset, d.site,
args.planet, R)
# Subtract atmospheric model
with bench.show("atm model"):
model= gapfill.gapfill_joneig(tod, planet_cut, inplace=False)
# Estimate noise level
asens = np.sum(ivar)**-0.5 / d.srate**0.5
print asens
with bench.show("smooth"):
ft = fft.rfft(model)
freq = fft.rfftfreq(model.shape[-1])*d.srate
flt = 1/(1+(freq/model_fknee)**model_alpha)
ft *= flt
fft.ifft(ft, model, normalize=True)
del ft, flt, freq
with bench.show("atm subtract"):
tod -= model
del model
tod = tod.astype(dtype, copy=False)
# Should now be reasonably clean of correlated noise.
# Proceed to make simple binned map
with bench.show("actscan"):
scan = actscan.ACTScan(entry, d=d)
with bench.show("pmat"):
pmap = pmat.PmatMap(scan, area, sys=sys)
pcut = pmat.PmatCut(scan)
entry = filedb.data[id]
try:
with bench.mark("read"):
d = actdata.read(entry)
with bench.mark("calib"):
d = actdata.calibrate(d, exclude=["autocut"])
if d.ndet < 2 or d.nsamp < 1:
raise errors.DataMissing("no data in tod")
except errors.DataMissing as e:
print "%s skipped: %s" % (id, str(e))
continue
tod = d.tod.astype(dtype)
del d.tod
# Apply high-pass filter. Will assume white tod after this
with bench.mark("filter"):
freqs = fft.rfftfreq(d.nsamp) * d.srate
ft = fft.rfft(tod)
ps = np.abs(ft)**2
rpows = [
measure_power(ps, rfreq, drfreq, d.srate)
for rfreq, drfreq in zip(rfreqs, drfreqs)
]
rpows = np.array(rpows)
# Determine the fknee to use. First get a typical spectrum.
# This does not work well with s16, which currently doesn't
# have time constants.
ps = np.median(ps, 0)
bps = bin_spectrum(ps, bsize_fknee)
fknee = measure_fknee(bps, d.srate / 2 / ps.size * bsize_fknee)
#np.savetxt("ps.txt", ps)
#1/0
diff = diff[:,:diff.shape[-1]//csize*csize].reshape(d.ndet,-1,csize)
ivar = 1/(np.median(np.mean(diff**2,-1),-1)/2**0.5)
del diff
# Generate planet cut
with bench.show("planet cut"):
planet_cut = cuts.avoidance_cut(d.boresight, d.point_offset, d.site,
args.planet, R)
# Subtract atmospheric model
with bench.show("atm model"):
model= gapfill.gapfill_joneig(tod, planet_cut, inplace=False)
# Estimate noise level
asens = np.sum(ivar)**-0.5 / d.srate**0.5
print(asens)
with bench.show("smooth"):
ft = fft.rfft(model)
freq = fft.rfftfreq(model.shape[-1])*d.srate
flt = 1/(1+(freq/model_fknee)**model_alpha)
ft *= flt
fft.ifft(ft, model, normalize=True)
del ft, flt, freq
with bench.show("atm subtract"):
tod -= model
del model
tod = tod.astype(dtype, copy=False)
# Should now be reasonably clean of correlated noise, so we can from now on use
# a white noise model.
with bench.show("pmat"):
P = PmatTot(scan, srcpos, sys=sys)
N = NmatWhite(ivar)