def __init__(self, bolo_name, config):
self.name = bolo_name
self.config = Generic()
bolo_config = importlib.import_module(config.bolo_config_file).bolo_config.bolos[bolo_name]
self.config.__dict__.update(config.__dict__)
self.config.__dict__.update(bolo_config.__dict__)
if config.simulate_ts:
self.calculate_params()
self.beam = Beam(self.config, bolo_config)
self.noise_class = Noise(self.config)
if not config.sim_pol_type == "noise_only":
self.get_sky_map()
self.get_initial_axes()
self.get_nsamples()
self.set_bolo_dirs()
class Bolo:
def __init__(self, bolo_name, config):
self.name = bolo_name
self.config = Generic()
bolo_config = importlib.import_module(config.bolo_config_file).bolo_config.bolos[bolo_name]
self.config.__dict__.update(config.__dict__)
self.config.__dict__.update(bolo_config.__dict__)
if config.simulate_ts:
self.calculate_params()
self.beam = Beam(self.config, bolo_config)
self.noise_class = Noise(self.config)
if not config.sim_pol_type == "noise_only":
self.get_sky_map()
self.get_initial_axes()
self.get_nsamples()
self.set_bolo_dirs()
#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*
# Simulating the time-ordered data for a given bolo with any beam
#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*
# def get_timestream(self, segment, read_list=["signal", "v", "pol_ang"]):
# if config.simulate
def read_timestream(self, segment, noise_only=False, read_list=["signal", "v", "pol_ang"]):
segment_dir = self.get_segment_dir(segment)
t_stream = {"signal" : None, "v" : None, "pol_ang" : None}
if "signal" in read_list:
if noise_only:
t_stream["signal"] = np.load(os.path.join(segment_dir, "noise.npy"))
else:
t_stream["signal"] = np.load(os.path.join(segment_dir, "signal.npy"))
if "v" in read_list:
t_stream["v"] = np.load(os.path.join(segment_dir, "pointing_vec.npy"))
if "pol_ang" in read_list:
t_stream["pol_ang"] = np.load(os.path.join(segment_dir, "pol_ang.npy"))
return t_stream
def simulate_timestream(self, segment, return_field=["signal", "v", "pol_ang"]):
if segment == 0:
#self.display_params()
#self.beam.display_beam_settings()
if self.config.write_beam:
self.beam.write_beam(self.bolo_dir)
rot_qt = self.generate_quaternion(segment)
t_stream = {"signal" : None, "v" : None, "pol_ang" : None, "noise" : None}
prompter.prompt("0.0")
#Simulating the scan along the centre of the FOV
v_init = self.get_initial_vec(0.0)
v_central = self.get_v_obv(v_init, rot_qt)
t_stream['v'] = v_central
pol_ang = self.get_pol_ang(rot_qt, v_central)
t_stream['pol_ang'] = pol_ang
if self.config.sim_pol_type == "T":
cos2=None
sin2=None
else:
cos2 = np.cos(2*pol_ang)
sin2 = np.sin(2*pol_ang)
if "timestream_data" in self.config.timestream_data_products:
self.make_write_dir(segment)
self.write_timestream_data(v_central, "pointing_vec", segment)
self.write_timestream_data(pol_ang, "pol_ang", segment)
if not self.config.pipe_with_map_maker:
del pol_ang
beam_kernel_row = self.beam.get_beam_row(0.0) #The input argument is the beam offset from the centre
hit_pix = hp.vec2pix(self.config.nside_in, v_central[...,0], v_central[...,1], v_central[...,2])
signal = self.generate_signal(hit_pix, beam_kernel_row, cos2, sin2)
for del_beta in self.beam.del_beta:
if del_beta == 0.0:
continue
prompter.prompt(str(del_beta))
beam_kernel_row = self.beam.get_beam_row(del_beta)
v_init = self.get_initial_vec(del_beta)
v = quaternion.transform(rot_qt, v_init)
hit_pix = hp.vec2pix(self.config.nside_in, v[...,0], v[...,1], v[...,2])
signal += self.generate_signal(hit_pix, beam_kernel_row, cos2, sin2)
beam_sum = np.sum(self.beam.beam_kernel[0])
signal /= beam_sum
if self.config.add_noise:
noise = self.noise_class.simulate_timestream_noise_from_parameters()
if "timestream_data" in self.config.timestream_data_products:
self.write_timestream_data(noise, "noise", segment)
signal[::self.config.oversampling_rate] += noise
if "timestream_data" in self.config.timestream_data_products:
self.write_timestream_data(signal, "signal", segment)
if self.config.pipe_with_map_maker:
if self.config.do_pencil_beam:
t_stream["signal"] = signal
t_stream["v"] = v_central
t_stream["pol_ang"] = pol_ang
return t_stream
else:
t_stream["signal"] = signal[::self.config.oversampling_rate]
t_stream["v"] = v_central[self.pad:-self.pad][::self.config.oversampling_rate]
t_stream["pol_ang"] = pol_ang[self.pad:-self.pad][::self.config.oversampling_rate]
return t_stream
if "hitmap" in self.config.timestream_data_products:
del signal
hit_pix = hp.vec2pix(self.config.nside_in, v_central[...,0], v_central[...,1], v_central[...,2])
hitmap = self.get_hitmap(hit_pix)
return hitmap
def generate_signal(self, hit_pix, beam_kernel_row, cos2, sin2):
if self.config.sim_pol_type == "noise_only":
signal = np.zeros(self.nsamples - 2*self.pad)
elif self.config.sim_pol_type == "T":
if self.config.do_pencil_beam:
signal = 0.5*self.sky_map[hit_pix]
else:
signal = np.convolve(0.5*self.sky_map[hit_pix], beam_kernel_row[0], mode='valid')
elif self.config.sim_pol_type in ["QU", "_QU"]:
if self.config.do_pencil_beam:
signal = 0.5*(self.sky_map[0][hit_pix]*cos2 + self.sky_map[1][hit_pix]*sin2)
else:
signal = np.convolve(0.5*(self.sky_map[0][hit_pix]*cos2 + self.sky_map[1][hit_pix]*sin2), -1.0*beam_kernel_row[1], mode='valid')
signal += np.convolve(0.5*(self.sky_map[0][hit_pix]*sin2 + self.sky_map[1][hit_pix]*cos2), -1.0*beam_kernel_row[2], mode='valid')
elif self.config.sim_pol_type == "pol_only":
if self.config.do_pencil_beam:
signal = 0.5*(self.sky_map[1][hit_pix]*cos2 + self.sky_map[2][hit_pix]*sin2)
else:
signal = np.convolve(0.5*(self.sky_map[1][hit_pix]*cos2 + self.sky_map[2][hit_pix]*sin2), -1.0*beam_kernel_row[1], mode='valid')
signal += np.convolve(0.5*(self.sky_map[1][hit_pix]*sin2 + self.sky_map[2][hit_pix]*cos2), -1.0*beam_kernel_row[2], mode='valid')
else:
if self.config.do_pencil_beam:
signal = 0.5*(self.sky_map[0][hit_pix] + self.sky_map[1][hit_pix]*cos2 + self.sky_map[2][hit_pix]*sin2)
else:
signal = np.convolve(0.5*self.sky_map[0][hit_pix], beam_kernel_row[0], mode='valid')
signal += np.convolve(0.5*(self.sky_map[1][hit_pix]*cos2 + self.sky_map[2][hit_pix]*sin2), -1.0*beam_kernel_row[1], mode='valid')
signal += np.convolve(0.5*(self.sky_map[1][hit_pix]*sin2 + self.sky_map[2][hit_pix]*cos2), -1.0*beam_kernel_row[2], mode='valid')
return signal
def get_nsamples(self):
self.pad = self.beam.del_beta.size/2
self.nsamples = int(self.config.t_segment*self.config.sampling_rate)*self.config.oversampling_rate + 2*self.pad
def calculate_params(self):
self.config.theta_cross = 360.0*60.0*np.sin(np.radians(self.config.alpha))*self.config.t_spin/self.config.t_prec
self.config.theta_co = 360*60*np.sin(np.radians(self.config.beta))/self.config.sampling_rate/self.config.t_spin
self.config.scan_resolution = self.config.theta_co/self.config.oversampling_rate
def get_initial_axes(self):
alpha = np.deg2rad(self.config.alpha) #radians
beta = np.deg2rad(self.config.beta) #radians
self.axis_spin = np.array([np.cos(alpha), 0.0, np.sin(alpha)])
self.axis_prec = np.array([1.0, 0.0, 0.0])
self.axis_rev = np.array([0.0, 0.0, 1.0])
def get_initial_vec(self, del_beta):
alpha = np.deg2rad(self.config.alpha) #radians
beta = np.deg2rad(self.config.beta) #radians
if self.config.do_pencil_beam:
del_x = np.deg2rad(self.config.offset_x/60.0/60.0) #radians
del_y = np.deg2rad(self.config.offset_y/60.0/60.0) #radians
else:
del_x = 0.0
del_y = 0.0
del_beta_rad = np.deg2rad(del_beta/60.0) #radians
total_opening = alpha + beta + del_beta_rad
u_view = np.array([np.cos(total_opening), 0.0, np.sin(total_opening)])
x_roll_axis = np.array([0.0, 1.0, 0.0])
y_roll_axis = np.array([-np.sin(total_opening), 0.0, np.cos(total_opening)])
q_x_roll = quaternion.make_quaternion(del_x, x_roll_axis)
q_y_roll = quaternion.make_quaternion(del_y, y_roll_axis)
q_offset = quaternion.multiply(q_x_roll, q_y_roll)
u_view = quaternion.transform(q_offset, u_view)
return u_view
def generate_quaternion(self, segment):
t_start = self.config.t_segment*segment
t_steps = t_start + (1.0/self.config.sampling_rate/self.config.oversampling_rate)*np.arange(-self.pad, self.nsamples - self.pad)
w_spin = -2*np.pi/self.config.t_spin
w_prec = -2*np.pi/self.config.t_prec
w_rev = -2*np.pi/self.config.t_year
r_total = quaternion.multiply(quaternion.make_quaternion(w_rev*t_steps, self.axis_rev), quaternion.multiply(quaternion.make_quaternion(w_prec*t_steps, self.axis_prec), quaternion.make_quaternion(w_spin*t_steps, self.axis_spin)))
#r_total = quaternion.multiply(quaternion.make_quaternion(w_prec*t_steps, self.axis_prec), quaternion.make_quaternion(w_spin*t_steps, self.axis_spin))
return r_total
def get_v_obv(self, v_init, rot_qt):
v = quaternion.transform(rot_qt, v_init)
if self.config.gal_coords:
v = self.transform_to_gal_coords(v)
return v
def transform_to_gal_coords(self, v):
rot = hp.Rotator(coord=['E', 'G'])
theta, phi = hp.vec2ang(v)
theta_gal, phi_gal = rot(theta, phi)
return hp.ang2vec(theta_gal, phi_gal)
def get_pol_ang(self, rot_qt, v_dir):
alpha = np.deg2rad(self.config.alpha) #radians
beta = np.deg2rad(self.config.beta) #radians
total_opening = alpha + beta
pol_ini = np.deg2rad(self.config.pol_phase_ini)
pol_vec_ini = np.array([0.0, 1.0, 0.0])
pol_vec = quaternion.transform(rot_qt, np.tile(pol_vec_ini, self.nsamples).reshape(-1,3))
if self.config.gal_coords:
pol_vec = self.transform_to_gal_coords(pol_vec)
theta, phi = hp.vec2ang(v_dir)
x_local = np.array(zip(np.cos(theta)*np.cos(phi), np.cos(theta)*np.sin(phi), -np.sin(theta)))
y_local = np.array(zip(-np.sin(phi), np.cos(phi), np.zeros(phi.size)))
proj_x = np.sum(pol_vec*x_local, axis=-1)
proj_y = np.sum(pol_vec*y_local, axis=-1)
pol_ang = np.pi - (np.arctan2(proj_y, proj_x) + pol_ini) % np.pi
return pol_ang
def add_noise(self):
if self.config.noise_type == "white":
return np.random.normal(scale=self.config.noise_sigma, size=self.nsamples - 2*self.pad)
def get_hitmap(self, hitpix):
hitmap = np.bincount(hitpix, minlength=self.npix)
return hitmap
def get_sky_map(self):
if self.config.sim_pol_type == "noise_only":
self.sky_map = None
elif self.config.sim_pol_type == "T":
self.sky_map = hp.read_map(self.config.input_map, verbose=False)
elif self.config.sim_pol_type == "QU":
self.sky_map = hp.read_map(self.config.input_map, field=(0,1), verbose=False)
elif self.config.sim_pol_type == "_QU":
self.sky_map = hp.read_map(self.config.input_map, field=(1,2), verbose=False)
else:
self.sky_map = hp.read_map(self.config.input_map, field=(0,1,2), verbose=False)
if not self.config.sim_pol_type == "noise_only":
map_nside = hp.get_nside(self.sky_map)
if map_nside != self.config.nside_in:
prompter.prompt_warning("NSIDE of config does not match NSIDE of map")
sys.exit()
self.npix = hp.nside2npix(self.config.nside_in)
def make_write_dir(self, segment):
if not os.path.exists(self.bolo_dir):
try:
os.makedirs(self.bolo_dir)
except OSError:
pass
segment_dir = self.get_segment_dir(segment)
if os.path.exists(segment_dir):
shutil.rmtree(segment_dir)
os.makedirs(segment_dir)
def set_bolo_dirs(self):
self.sim_dir = os.path.join(self.config.general_data_dir, self.config.sim_tag)
self.scan_dir = os.path.join(self.sim_dir, self.config.scan_tag)
self.bolo_dir = os.path.join(self.scan_dir, self.name)
def get_segment_dir(self, segment):
segment_name = str(segment+1).zfill(4)
return os.path.join(self.bolo_dir, segment_name)
def write_timestream_data(self, ts_data, data_name, segment):
write_dir = self.get_segment_dir(segment)
if data_name == "signal":
np.save(os.path.join(write_dir, data_name), ts_data[::self.config.oversampling_rate])
elif data_name == "noise":
np.save(os.path.join(write_dir, data_name), ts_data)
else:
if self.config.do_pencil_beam:
np.save(os.path.join(write_dir, data_name), ts_data)
else:
np.save(os.path.join(write_dir, data_name), ts_data[self.pad:-self.pad][::self.config.oversampling_rate])
def display_params(self):
display_string = ""
display_string += "Alpha : %f degrees\n" % (self.config.alpha)
display_string += "Beta : %f degrees\n" % (self.config.beta)
t_flight = self.config.t_segment*len(self.config.segment_list)
display_string += "T flight : %f hours / %f days\n" % (t_flight/60.0/60.0, t_flight/60.0/60.0/24.0)
display_string += "T segment : %f hours / %f days\n" % (self.config.t_segment/60.0/60.0, self.config.t_segment/60.0/60.0/24)
display_string += "T precession : %f hours\n" % (self.config.t_prec/60.0/60.0)
display_string += "T spin : %f seconds\n" % (self.config.t_spin)
display_string += "Scan sampling rate : %f Hz\n" % (self.config.sampling_rate)
display_string += "Theta co : %f arcmin\n" % (self.config.theta_co)
display_string += "Theta cross : %f arcmin\n" % (self.config.theta_cross)
display_string += "Oversampling rate : %d\n" % (self.config.oversampling_rate)
display_string += "Scan resolution for beam integration : %f arcmin\n" % (self.config.scan_resolution)
display_string += "Pixel size for NSIDE = %d : %f arcmin\n" % (self.config.nside_in, hp.nside2resol(self.config.nside_in, arcmin=True))
n_steps = int(self.config.t_segment*self.config.sampling_rate)*self.config.oversampling_rate
display_string += "#Samples per segment : %d\n" %(n_steps)
prompter.prompt(display_string, True)