def run_casa(cmdlist): """ Use drivecasa to run CASA commands """ #load drivecasa casa = drivecasa.Casapy() print 'Running CASA command {}'.format(cmdlist) casa_output, casa_error = casa.run_script(cmdlist)
def casa_imaging(ms_file, Nfacet, NID): casa = drivecasa.Casapy(working_dir=os.path.curdir, casa_logfile=False, timeout = 1200, echo_to_stdout=False) casa.run_script(["ms_file='{}'".format(ms_file)]) casa.run_script(["Nfacet={}".format(Nfacet)]) casa.run_script(["NID={}".format(NID)]) casa.run_script_from_file('/BIGDATA1/ac_shao_tan_1/OSKAR/IDOS/test/OSKAR_CASA/MPI/image.py',timeout = 60000000)
def setUp(self): self.casa = drivecasa.Casapy(echo_to_stdout=True) self.output_dir = os.path.join(drivecasa.default_test_ouput_dir, 'ms_generation_test') self.output_ms_path = os.path.join(self.output_dir, 'foobar.ms') # Ensure that the output dir will be created if not already present # (Also deletes the output ms if present) if os.path.isdir(self.output_dir): shutil.rmtree(self.output_dir) os.makedirs(self.output_dir)
def run_casa(cmd, raise_on_severe=False, timeout=1800): """Run a list of casa commands""" casa = drivecasa.Casapy() try: casa_output, casa_error = casa.run_script(cmd, raise_on_severe=True, timeout=timeout) logger.debug('\n'.join(casa_error)) except RuntimeError: logger.error("Casa command failed") if raise_on_severe: raise
def check_calibrated(msfile): if not _CASA: logger.error('requires drivecasa') return None try: casa = drivecasa.Casapy(casa_dir=casapy, working_dir=os.path.abspath(os.curdir), timeout=1200) except Exception, e: logger.error('Unable to instantiate casa:\n%s' % e) return None
def invoke_split(self, q, infile, outdir): import drivecasa try: script = [] casa = drivecasa.Casapy(casa_dir = self.casapy_path, timeout = self.timeout) drivecasa.commands.mstransform(script, infile, outdir, self.transform_args, overwrite = True) casa.run_script(script) q.put(0) except Exception: q.put(-1) raise
def make_image_map_fits(vis_ms_path, output_dir, image_size, cell_size, niter=150, threshold_in_jy=0.1): ensure_dir(output_dir) script = [] img_n_pix = int(image_size.to(u.pixel).value) cell_arcsec = cell_size.to(u.arcsec).value clean_args = { "imsize": [img_n_pix, img_n_pix], "cell": [str(cell_arcsec) + 'arcsec'], "weighting": 'briggs', "robust": 0.5, } dirty_maps = drivecasa.commands.clean(script, vis_paths=vis_ms_path, niter=0, threshold_in_jy=threshold_in_jy, other_clean_args=clean_args, out_dir=output_dir, overwrite=True) dirty_fits_path = drivecasa.commands.export_fits(script, dirty_maps.image, overwrite=True) clean_maps = drivecasa.commands.clean(script, vis_paths=vis_ms_path, niter=niter, threshold_in_jy=threshold_in_jy, other_clean_args=clean_args, out_dir=output_dir, overwrite=True) clean_fits_path = drivecasa.commands.export_fits(script, clean_maps.image, overwrite=True) logfile_basename = os.path.basename( vis_ms_path) + ".casa-clean-commands.log" commands_logfile = os.path.join(output_dir, logfile_basename) if os.path.isfile(commands_logfile): os.unlink(commands_logfile) casa = drivecasa.Casapy(commands_logfile=commands_logfile) casa.run_script(script) return dirty_fits_path, clean_fits_path
def run(self): inp = self.inputs[0] out = self.outputs[0] if logger.isEnabledFor(logging.INFO): logger.info('Calculating source flux on %s.image' % (inp.path)) import drivecasa casa = drivecasa.Casapy(casa_dir = self.casapy_path, timeout = self.timeout) casa.run_script(['ia.open("'"%s"'")' % (inp.path + '.image')]) casa.run_script(['flux = ia.pixelvalue([128,128,0,179])["'"value"'"]["'"value"'"]']) casaout, _ = casa.run_script(['print flux']) flux = float(casaout[0]) if flux > 9E-4: if logger.isEnabledFor(logging.INFO): logger.info('Valid flux found: %f' % (flux)) out.write(str(flux))
def test_command_logging(self): with tempfile.NamedTemporaryFile(delete=False) as tmpfile: commands_logfile = tmpfile.name #Use the temporary file path, but delete the empty file first... os.remove(commands_logfile) casa = drivecasa.Casapy(commands_logfile=commands_logfile, echo_to_stdout=False) script = ['tasklist()'] out, errors = casa.run_script(script) with open(commands_logfile) as f: commands_log = f.read() commands_logged = commands_log.split('\n') if not commands_logged[-1]: commands_logged.pop() self.assertEqual(commands_logged, script) # print "Command log", commands_log os.remove(commands_logfile)
def invoke_clean(self, q, vis, outcube): import drivecasa try: script = [] casa = drivecasa.Casapy(casa_dir = self.casapy_path, timeout = self.timeout) drivecasa.commands.clean(script, vis_paths = vis, out_path = outcube, niter = 0, threshold_in_jy = 0, other_clean_args = self.clean_args, overwrite = True) casa.run_script(script) q.put(0) except Exception: q.put(-1) raise
def setUpClass(cls): casa_dir = os.environ.get('CASA_DIR', drivecasa.default_casa_dir) cls.casa = drivecasa.Casapy(casa_dir, echo_to_stdout=False)
import os import sys import logging import drivecasa casa = drivecasa.Casapy(log2term=True, echo_to_stdout=True, timeout=24 * 3600 * 10) sys.path.append("/scratch/stimela") utils = __import__('utils') CONFIG = os.environ["CONFIG"] INPUT = os.environ["INPUT"] OUTPUT = os.environ["OUTPUT"] MSDIR = os.environ["MSDIR"] cab = utils.readJson(CONFIG) args = {} for param in cab['parameters']: name = param['name'] value = param['value'] if value is None: continue args[name] = value script = ['{0}(**{1})'.format(cab['binary'], args)]
def ms2miriad(self): ''' Converts the data from MS to MIRIAD format via UVFITS using drivecasa. Does it for the flux calibrator, polarisation calibrator, and target field independently. ''' subs.setinit.setinitdirs(self) beams = 37 # Create the parameters for the parameter file for converting from MS to UVFITS format convertfluxcalmsavailable = get_param_def(self, 'convert_fluxcal_MSavailable', False ) # Flux calibrator MS dataset available? convertpolcalmsavailable = get_param_def(self, 'convert_polcal_MSavailable', False ) # Polarised calibrator MS dataset available? converttargetbeamsmsavailable = get_param_def(self, 'convert_targetbeams_MSavailable', np.full((beams), False) ) # Target beam MS dataset available? convertfluxcalms2uvfits = get_param_def(self, 'convert_fluxcal_MS2UVFITS', False ) # Flux calibrator MS dataset converted to UVFITS? convertpolcalms2uvfits = get_param_def(self, 'convert_polcal_MS2UVFITS', False ) # Polarised calibrator MS dataset converted to UVFITS? converttargetbeamsms2uvfits = get_param_def(self, 'convert_targetbeams_MS2UVFITS', np.full((beams), False) ) # Target beam MS dataset converted to UVFITS? convertfluxcaluvfitsavailable = get_param_def(self, 'convert_fluxcal_UVFITSavailable', False ) # Flux calibrator UVFITS dataset available? convertpolcaluvfitsavailable = get_param_def(self, 'convert_polcal_UVFITSavailable', False ) # Polarised calibrator UVFITS dataset available? converttargetbeamsuvfitsavailable = get_param_def(self, 'convert_targetbeams_UVFITSavailable', np.full((beams), False) ) # Target beam UVFITS dataset available? convertfluxcaluvfits2miriad = get_param_def(self, 'convert_fluxcal_UVFITS2MIRIAD', False ) # Flux calibrator UVFITS dataset converted to MIRIAD? convertpolcaluvfits2miriad = get_param_def(self, 'convert_polcal_UVFITS2MIRIAD', False ) # Polarised calibrator UVFITS dataset converted to MIRIAD? converttargetbeamsuvfits2miriad = get_param_def(self, 'convert_targetbeams_UVFITS2MIRIAD', np.full((beams), False) ) # Target beam UVFITS dataset converted to MIRIAD? ################################################### # Check which datasets are available in MS format # ################################################### if self.fluxcal != '': convertfluxcalmsavailable = os.path.isdir(self.basedir + '00' + '/' + self.rawsubdir + '/' + self.fluxcal) else: self.logger.warning('# Flux calibrator dataset not specified. Cannot convert flux calibrator! #') if self.polcal != '': convertpolcalmsavailable = os.path.isdir(self.basedir + '00' + '/' + self.rawsubdir + '/' + self.polcal) else: self.logger.warning('# Polarised calibrator dataset not specified. Cannot convert polarised calibrator! #') if self.target != '': for b in range(beams): converttargetbeamsmsavailable[b] = os.path.isdir(self.basedir + str(b).zfill(2) + '/' + self.rawsubdir + '/' + self.target) else: self.logger.warning('# Target beam dataset not specified. Cannot convert target beams! #') # Save the derived parameters for the availability to the parameter file subs.param.add_param(self, 'convert_fluxcal_MSavailable', convertfluxcalmsavailable) subs.param.add_param(self, 'convert_polcal_MSavailable', convertpolcalmsavailable) subs.param.add_param(self, 'convert_targetbeams_MSavailable', converttargetbeamsmsavailable) ############################################### # Convert the available MS-datasets to UVFITS # ############################################### # Convert the flux calibrator if self.convert_fluxcal: if self.fluxcal != '': if convertfluxcaluvfits2miriad == False: if convertfluxcalmsavailable: self.logger.debug('# Converting flux calibrator dataset from MS to UVFITS format. #') subs.managefiles.director(self, 'mk', self.basedir + '00' + '/' + self.crosscalsubdir, verbose=False) fc_convert = 'exportuvfits(vis="' + self.basedir + '00' + '/' + self.rawsubdir + '/' + self.fluxcal + '", fitsfile="' + self.basedir + '00' + '/' + self.crosscalsubdir + '/' + str(self.fluxcal).rstrip('MS') + 'UVFITS' + '", datacolumn="data", combinespw=True, padwithflags=True, multisource=True, writestation=True)' casacmd = [fc_convert] casa = drivecasa.Casapy() casa.run_script(casacmd, raise_on_severe=False, timeout=3600) if os.path.isfile( self.basedir + '00' + '/' + self.crosscalsubdir + '/' + self.fluxcal.rstrip('MS') + 'UVFITS'): convertfluxcalms2uvfits = True self.logger.info('# Converted flux calibrator dataset from MS to UVFITS format! #') else: convertfluxcalms2uvfits = False self.logger.warning('# Could not convert flux calibrator dataset from MS to UVFITS format! #') else: self.logger.warning('# Flux calibrator dataset not available! #') else: self.logger.info('# Flux calibrator dataset was already converted from MS to UVFITS format #') else: self.logger.warning('# Flux calibrator dataset not specified. Cannot convert flux calibrator! #') else: self.logger.warning('# Not converting flux calibrator dataset! #') # Convert the polarised calibrator if self.convert_polcal: if self.polcal != '': if convertpolcaluvfits2miriad == False: if convertpolcalmsavailable: self.logger.debug('# Converting polarised calibrator dataset from MS to UVFITS format. #') subs.managefiles.director(self, 'mk', self.basedir + '00' + '/' + self.crosscalsubdir, verbose=False) pc_convert = 'exportuvfits(vis="' + self.basedir + '00' + '/' + self.rawsubdir + '/' + self.polcal + '", fitsfile="' + self.basedir + '00' + '/' + self.crosscalsubdir + '/' + str(self.polcal).rstrip('MS') + 'UVFITS' + '", datacolumn="data", combinespw=True, padwithflags=True, multisource=True, writestation=True)' casacmd = [pc_convert] casa = drivecasa.Casapy() casa.run_script(casacmd, raise_on_severe=False, timeout=3600) if os.path.isfile( self.basedir + '00' + '/' + self.crosscalsubdir + '/' + self.polcal.rstrip('MS') + 'UVFITS'): convertpolcalms2uvfits = True self.logger.info('# Converted polarised calibrator dataset from MS to UVFITS format! #') else: convertpolcalms2uvfits = False self.logger.warning('# Could not convert polarised calibrator dataset from MS to UVFITS format! #') else: self.logger.warning('# Polarised calibrator dataset not available! #') else: self.logger.info('# Polarised calibrator dataset was already converted from MS to UVFITS format #') else: self.logger.warning('# Polarised calibrator dataset not specified. Cannot convert polarised calibrator! #') else: self.logger.warning('# Not converting polarised calibrator dataset! #') # Convert the target beams if self.convert_target: if self.target != '': self.logger.info('# Converting target beam datasets from MS to UVFITS format. #') if self.convert_targetbeams == 'all': datasets = glob.glob(self.basedir + '[0-9][0-9]' + '/' + self.rawsubdir + '/' + self.target) self.logger.debug('# Converting all available target beam datasets #') else: beams = self.convert_targetbeams.split(",") datasets = [self.basedir + str(b).zfill(2) + '/' + self.rawsubdir + '/' + self.target for b in beams] self.logger.debug('# Converting all selected target beam datasets #') for vis in datasets: if converttargetbeamsuvfits2miriad[int(vis.split('/')[-3])] == False: if converttargetbeamsmsavailable[int(vis.split('/')[-3])]: subs.managefiles.director(self, 'mk', self.basedir + vis.split('/')[-3] + '/' + self.crosscalsubdir, verbose=False) tg_convert = 'exportuvfits(vis="' + self.basedir + vis.split('/')[-3] + '/' + self.rawsubdir + '/' + self.target + '", fitsfile="' + self.basedir + vis.split('/')[-3] + '/' + self.crosscalsubdir + '/' + self.target.rstrip('MS') + 'UVFITS' + '", datacolumn="data", combinespw=True, padwithflags=True, multisource=True, writestation=True)' casacmd = [tg_convert] casa = drivecasa.Casapy() casa.run_script(casacmd, raise_on_severe=False, timeout=7200) if os.path.isfile( self.basedir + vis.split('/')[-3] + '/' + self.crosscalsubdir + '/' + self.target.rstrip('MS') + 'UVFITS'): converttargetbeamsms2uvfits[int(vis.split('/')[-3])] = True self.logger.debug('# Converted dataset of target beam ' + vis.split('/')[-3] + ' from MS to UVFITS format! #') else: converttargetbeamsms2uvfits[int(vis.split('/')[-3])] = False self.logger.warning('# Could not convert dataset for target beam ' + vis.split('/')[-3] + ' from MS to UVFITS format! #') else: self.logger.warning('# Dataset for target beam ' + vis.split('/')[-3] + ' not available! #') else: self.logger.info('# Dataset for target beam ' + vis.split('/')[-3] + ' was already converted from MS to UVFITS format #') else: self.logger.warning('# Target beam dataset(s) not specified. Cannot convert target beam datasets! #') else: self.logger.warning('# Not converting target beam dataset(s)! #') # Save the derived parameters for the MS to UVFITS conversion to the parameter file subs.param.add_param(self, 'convert_fluxcal_MS2UVFITS', convertfluxcalms2uvfits) subs.param.add_param(self, 'convert_polcal_MS2UVFITS', convertpolcalms2uvfits) subs.param.add_param(self, 'convert_targetbeams_MS2UVFITS', converttargetbeamsms2uvfits) ####################################################### # Check which datasets are available in UVFITS format # ####################################################### if self.fluxcal != '': convertfluxcaluvfitsavailable = os.path.isfile(self.basedir + '00' + '/' + self.crosscalsubdir + '/' + self.fluxcal.rstrip('MS') + 'UVFITS') else: self.logger.warning('# Flux calibrator dataset not specified. Cannot convert flux calibrator! #') if self.polcal != '': convertpolcaluvfitsavailable = os.path.isfile(self.basedir + '00' + '/' + self.crosscalsubdir + '/' + self.polcal.rstrip('MS') + 'UVFITS') else: self.logger.warning('# Polarised calibrator dataset not specified. Cannot convert polarised calibrator! #') if self.target != '': for b in range(beams): converttargetbeamsuvfitsavailable[b] = os.path.isfile(self.basedir + str(b).zfill(2) + '/' + self.crosscalsubdir + '/' + self.target.rstrip('MS') + 'UVFITS') else: self.logger.warning('# Target beam dataset not specified. Cannot convert target beams! #') # Save the derived parameters for the availability to the parameter file subs.param.add_param(self, 'convert_fluxcal_UVFITSavailable', convertfluxcaluvfitsavailable) subs.param.add_param(self, 'convert_polcal_UVFITSavailable', convertpolcaluvfitsavailable) subs.param.add_param(self, 'convert_targetbeams_UVFITSavailable', converttargetbeamsuvfitsavailable) ########################################################## # Convert the available UVFITS-datasets to MIRIAD format # ########################################################## # Convert the flux calibrator if self.convert_fluxcal: if self.fluxcal != '': if convertfluxcaluvfits2miriad == False: if convertfluxcaluvfitsavailable: self.logger.debug('# Converting flux calibrator dataset from UVFITS to MIRIAD format. #') subs.managefiles.director(self, 'ch', self.basedir + '00' + '/' + self.crosscalsubdir, verbose=False) fits = lib.miriad('fits') fits.op = 'uvin' fits.in_ = self.basedir + '00' + '/' + self.crosscalsubdir + '/' + self.fluxcal.rstrip('MS') + 'UVFITS' fits.out = self.basedir + '00' + '/' + self.crosscalsubdir + '/' + self.fluxcal.rstrip('MS') + 'mir' fits.go() if os.path.isdir( self.basedir + '00' + '/' + self.crosscalsubdir + '/' + self.fluxcal.rstrip('MS') + 'mir'): convertfluxcaluvfits2miriad = True self.logger.info('# Converted flux calibrator dataset from UVFITS to MIRIAD format! #') else: convertfluxcaluvfits2miriad = False self.logger.warning('# Could not convert flux calibrator dataset from UVFITS to MIRIAD format! #') else: self.logger.warning('# Flux calibrator dataset not available! #') else: self.logger.info('# Flux calibrator dataset was already converted from UVFITS to MIRIAD format #') else: self.logger.warning('# Flux calibrator dataset not specified. Cannot convert flux calibrator! #') else: self.logger.warning('# Not converting flux calibrator dataset! #') # Convert the polarised calibrator if self.convert_polcal: if self.polcal != '': if convertpolcaluvfits2miriad == False: if convertpolcaluvfitsavailable: self.logger.debug('# Converting polarised calibrator dataset from UVFITS to MIRIAD format. #') subs.managefiles.director(self, 'ch',self.basedir + '00' + '/' + self.crosscalsubdir, verbose=False) fits = lib.miriad('fits') fits.op = 'uvin' fits.in_ = self.basedir + '00' + '/' + self.crosscalsubdir + '/' + self.polcal.rstrip('MS') + 'UVFITS' fits.out = self.basedir + '00' + '/' + self.crosscalsubdir + '/' + self.polcal.rstrip('MS') + 'mir' fits.go() if os.path.isdir(self.basedir + '00' + '/' + self.crosscalsubdir + '/' + self.polcal.rstrip('MS') + 'mir'): convertpolcaluvfits2miriad = True self.logger.info('# Converted polarised calibrator dataset from UVFITS to MIRIAD format! #') else: convertpolcaluvfits2miriad = False self.logger.warning('# Could not convert polarised calibrator dataset from UVFITS to MIRIAD format! #') else: self.logger.warning('# Polarised calibrator dataset not available! #') else: self.logger.info('# Polarised calibrator dataset was already converted from UVFITS to MIRIAD format #') else: self.logger.warning('# Polarised calibrator dataset not specified. Cannot convert polarised calibrator! #') else: self.logger.warning('# Not converting polarised calibrator dataset! #') # Convert the target beams if self.convert_target: if self.target != '': self.logger.info('# Converting target beam datasets from UVFITS to MIRIAD format. #') if self.convert_targetbeams == 'all': datasets = glob.glob(self.basedir + '[0-9][0-9]' + '/' + self.crosscalsubdir + '/' + self.target.rstrip('MS') + 'UVFITS') self.logger.debug('# Converting all available target beam datasets #') else: beams = self.convert_targetbeams.split(",") datasets = [self.basedir + str(b).zfill(2) + '/' + self.crosscalsubdir + '/' + self.target.rstrip('MS') + 'UVFITS' for b in beams] self.logger.debug('# Converting all selected target beam datasets #') for vis in datasets: if converttargetbeamsuvfits2miriad[int(vis.split('/')[-3])] == False: if converttargetbeamsuvfitsavailable[int(vis.split('/')[-3])]: subs.managefiles.director(self, 'ch', self.basedir + vis.split('/')[-3] + '/' + self.crosscalsubdir, verbose=False) fits = lib.miriad('fits') fits.op = 'uvin' fits.in_ = self.basedir + vis.split('/')[-3] + '/' + self.crosscalsubdir + '/' + self.target.rstrip('MS') + 'UVFITS' fits.out = self.basedir + vis.split('/')[-3] + '/' + self.crosscalsubdir + '/' + self.target.rstrip('MS') + 'mir' fits.go() if os.path.isdir( self.basedir + vis.split('/')[-3] + '/' + self.crosscalsubdir + '/' + self.target.rstrip('MS') + 'mir'): converttargetbeamsuvfits2miriad[int(vis.split('/')[-3])] = True self.logger.debug('# Converted dataset of target beam ' + vis.split('/')[-3] + ' from UVFITS to MIRIAD format! #') else: converttargetbeamsuvfits2miriad[int(vis.split('/')[-3])] = False self.logger.warning('# Could not convert dataset for target beam ' + vis.split('/')[-3] + ' from UVFITS to MIRIAD format! #') else: self.logger.warning('# Dataset for target beam ' + vis.split('/')[-3] + ' not available! #') else: self.logger.info('# Dataset for target beam ' + vis.split('/')[-3] + ' was already converted from MS to UVFITS format #') else: self.logger.warning('# Target beam dataset(s) not specified. Cannot convert target beam datasets! #') else: self.logger.warning('# Not converting target beam dataset(s)! #') # Save the derived parameters for the MS to UVFITS conversion to the parameter file subs.param.add_param(self, 'convert_fluxcal_UVFITS2MIRIAD', convertfluxcaluvfits2miriad) subs.param.add_param(self, 'convert_polcal_UVFITS2MIRIAD', convertpolcaluvfits2miriad) subs.param.add_param(self, 'convert_targetbeams_UVFITS2MIRIAD', converttargetbeamsuvfits2miriad) ##################################### # Remove the UVFITS files if wanted # ##################################### if self.convert_removeuvfits: self.logger.info('# Removing all UVFITS files #') subs.managefiles.director(self, 'rm', self.basedir + '00' + '/' + self.crosscalsubdir + '/' + self.fluxcal.rstrip('MS') + 'UVFITS') subs.managefiles.director(self, 'rm', self.basedir + '00' + '/' + self.crosscalsubdir + '/' + self.polcal.rstrip('MS') + 'UVFITS') for beam in range(beams): if os.path.isdir(self.basedir + str(beam).zfill(2) + '/' + self.crosscalsubdir): subs.managefiles.director(self, 'rm', self.basedir + str(beam).zfill(2) + '/' + self.crosscalsubdir + '/' + self.target.rstrip('MS') + 'UVFITS') else: pass
def setUpClass(cls): cls.casa = drivecasa.Casapy(echo_to_stdout=False)
from __future__ import print_function import drivecasa casa = drivecasa.Casapy() script = [] uvfits_path = '/path/to/uvdata.fits' vis = drivecasa.commands.import_uvfits(script, uvfits_path, out_dir='./') clean_args = { "imsize": [512, 512], "cell": ['5.0arcsec'], "weighting": 'briggs', "robust": 0.5, } dirty_maps = drivecasa.commands.clean(script, vis, niter=0, threshold_in_jy=1, other_clean_args=clean_args) dirty_map_fits_image = drivecasa.commands.export_fits(script, dirty_maps.image) print(script) casa.run_script(script)
def simulate_vis_with_casa(pointing_centre, source_list, output_dir): """ Use casapy to simulate a visibility measurementset with noise. (This also produces an initial set of UVW data) Args: pointing_centre (:class:`astropy.coordinates.SkyCoord`) source_list: list of :class:`fastimgproto.skymodel.helpers.SkySource` output_dir (str): Output directory which will contain `vis.ms` Returns (str): Full path to `vis.ms`. """ ensure_dir(output_dir) commands_logfile = os.path.join( output_dir, "./casa-visibilities_for_point_source-commands.log") component_list_path = os.path.join(output_dir, './sources.cl') output_visibility = os.path.abspath(os.path.join(output_dir, './vis.ms')) if os.path.isfile(commands_logfile): os.unlink(commands_logfile) casa = drivecasa.Casapy(commands_logfile=commands_logfile) script = [] # For VLA reference numbers, see: # https://science.nrao.edu/facilities/vla/docs/manuals/oss/performance/fov # https://science.nrao.edu/facilities/vla/docs/manuals/oss/performance/resolution # Define some observation parameters: obs_central_frequency = 3. * u.GHz obs_frequency_bandwidth = 0.125 * u.GHz primary_beam_fwhm = (45. * u.GHz / obs_central_frequency) * u.arcmin # Convert the sources to a CASA 'componentlist' component_list_path = sim.make_componentlist( script, source_list=[(s.position, s.flux, s.frequency) for s in source_list], out_path=component_list_path) # Open the visibility file sim.open_sim(script, output_visibility) # Configure the virtual telescope # sim.setpb(script, # telescope_name='VLA', # primary_beam_hwhm=primary_beam_fwhm * 0.5, # frequency=obs_central_frequency) sim.setconfig(script, telescope_name='VLA', antennalist_path=vla_c_antennalist_path) sim.setspwindow( script, freq_start=obs_central_frequency - 0.5 * obs_frequency_bandwidth, freq_resolution=obs_frequency_bandwidth, freq_delta=obs_frequency_bandwidth, n_channels=1, ) sim.setfeed(script, ) sim.setfield(script, pointing_centre) sim.setlimits(script) sim.setauto(script) ref_time = Time('2014-05-01T19:55:45', format='isot', scale='tai') sim.settimes(script, integration_time=10 * u.s, reference_time=ref_time) # Generate the visibilities sim.observe(script, stop_delay=10 * u.s) sim.predict(script, component_list_path) sim.set_simplenoise(script, noise_std_dev=1 * u.mJy) sim.corrupt(script) sim.close_sim(script) casa.run_script(script) return output_visibility
def Run_MockObs(bulked, GClrealisations, CASAmock=False, saveFITS=False, writeClusters=False, savewodetect=False, log=False, side_effects=False, filter_sp_phase=False, extract_subtracted=True): """ Runs a mock observation side_effects: put True if you want the input galaxy cluster to be changed, False if you want only a copy to be influenced """ (snap, Rmodel, emptySurvey) = bulked savefolder = emptySurvey.outfolder iom.check_mkdir(savefolder) #Variant B: Clean mask and .fits --> Source parameters; like variant A from step 4 on if CASAmock: import drivecasa as drica casa = drica.Casapy() smt = iom.SmartTiming( rate=5e4 ) # logf=outf+'smt.log' #; print( '###==== Step2a: Loading configuration files ====###' ) # Units, conversion factors, and input variables fac_rho = loadsnap.conversion_fact_gadget_rho_to_nb( snap.head) * loadsnap.conversion_fact_ne_per_nb() #electrons/cm^-3 fac_T = loadsnap.conversion_fact_gadget_U_to_keV(snap.head) # in [keV] fac_T2 = loadsnap.conversion_fact_gadget_U_to_keV( snap.head) / 8.61732814974056e-08 # to K """ determines if you want to change the galaxy cluster or not """ if side_effects: GClrealisations_used = GClrealisations else: GClrealisations_used = copy.deepcopy(GClrealisations) for jj, gcl in enumerate(GClrealisations_used): # Load variables and setting survey parameters mockobs = gcl.mockobs z = gcl.z.value hsize = mockobs.hsize dinf = gcl.dinfo # Some parameters of dinfo could change, because of adaptive pixelsize etc. fac_x = loadsnap.comH_to_phys(snap.head, z) eff = Rmodel.effList[0] # Units, conversion factors, and input variables radiounit = myu.radiounit_A * eff # erg/s/Hz --- Unit of particle luminousity in .radio snaps rot = mathut.Kep3D_seb(Omega=mockobs.theta, i=mockobs.phi, omega=mockobs.psi) posrot = np.dot(snap.pos, rot) * fac_x #velrot = np.dot(snap.vel, rot) Taken out, as long as we don't need to plot the velocity vetors smt(task='Bin_radio_[sub]') #print( '###==== Step 3b: Binning cluster data cube (radio) ====###' # Parameters implied # See Nuza+ 2012 Equ (1) relativistics = (1 + z) s_radio_SI = radiounit / myu.Jy_SI / ( 4 * np.pi * (gcl.cosmoDL * 1e-2)**2 ) * relativistics # radiounit*s_radioSI is Jy/particle #Umrechnung nbins = int(2 * hsize / (gcl.cosmoPS * dinf.spixel)) if nbins > mockobs.binmax: binsold = nbins spixelold = dinf.spixel dinf.spixel = dinf.spixel * np.power( float(nbins) / float(mockobs.binmax), 0.5) mockobs.hsize = mockobs.hsize * np.power( float(nbins) / float(mockobs.binmax), -0.5) dinf.update_Abeam() nbins = mockobs.binmax if log: print( 'At z=%.3f with an pixel size of %.1f arcsec, the number of pixels per image is %i^2. Due to that the pixelscale was increased to %.1f arcsec and the binned boxsize decreased to %i kpc.' % (z, spixelold, binsold, dinf.spixel, mockobs.hsize)) hsize = mockobs.hsize dinf.pcenter = [nbins / 2, nbins / 2] if filter_sp_phase: """ Filteres the cooled particles that no longer belong to the hot-ICM""" iL = np.where(( np.sqrt(snap.pos[:, 0]**2 + snap.pos[:, 1]**2 + snap.pos[:, 2]**2) * fac_x < 2.0 * gcl.R200()) & ((8.9 + 3.3 - np.log(snap.u * fac_T2) - 0.65 * np.log10(snap.rho * fac_rho)) < 0) & ((8.9 - 11.0 - np.log(snap.u * fac_T2) - 3.50 * np.log10(snap.rho * fac_rho)) < 0) & ((8.9 + 6.9 - np.log(snap.u * fac_T2) + 0.50 * np.log10(snap.rho * fac_rho)) < 0) & (snap.mach < 10))[0] else: iL = np.where( np.sqrt(snap.pos[:, 0]**2 + snap.pos[:, 1]**2 + snap.pos[:, 2]**2) * fac_x < 2.0 * gcl.R200())[0] if hasattr(snap, 'radiPre'): if log: print('Run_MockObs:: Ratio of PREs to total emission', (np.sum(snap.radiPre[iL])) / (np.sum(snap.radi[iL]) + np.sum(snap.radiPre[iL]))) H1, xedges, yedges = np.histogram2d(-posrot[iL, 0], -posrot[iL, 1], weights=s_radio_SI * snap.radi[iL], range=[[-hsize, hsize], [-hsize, hsize]], bins=nbins) """ Difference of gaussians method - accomplishing a simple subtraction of compact sources" We do this iteratively three times to also remove those particles that where shadowed by other bright particles before This method is defines by thresh: A threshold for masking scale_1: Smaller scale in kpc scale_2: Larger scale in kpc """ thresh = 0.75 scale_1 = 20 scale_2 = 60 DoG1_filter = copy.deepcopy(dinf) DoG1_filter.beam = [scale_1 / gcl.cosmoPS, scale_1 / gcl.cosmoPS, 0] DoG1_filter.update_Abeam() DoG2_filter = copy.deepcopy(dinf) DoG2_filter.beam = [scale_2 / gcl.cosmoPS, scale_2 / gcl.cosmoPS, 0] DoG2_filter.update_Abeam() DoG_mask = np.ones_like(H1) for no_use in range(2): convolved_sigma1 = DoG1_filter.convolve_map( H1 * DoG_mask) ## gaussian convolution convolved_sigma2 = DoG2_filter.convolve_map( H1 * DoG_mask) ## gaussian convolution DoG_rel = np.divide( np.abs(convolved_sigma2 - convolved_sigma1) + 1e-20, convolved_sigma2 + 1e-20) DoG_mask[np.where( DoG_rel < thresh)] = 0.2 * DoG_mask[np.where(DoG_rel < thresh)] #convolved_sigma1 = DoG1_filter.convolve_map(H1) ## gaussian convolution #convolved_sigma2 = DoG2_filter.convolve_map(H1) ## gaussian convolution H2 = dinf.convolve_map(H1 * DoG_mask) # print('____ Masked/Unmasked flux (mJy): %6.3f %6.3f' % (np.sum(H2)/dinf.Abeam[0]*1000,s_radio_SI*np.sum(snap.radi[iL])*1000)) smt(task='WriteDilMask_[sub]') #print( '###==== -- 4b: Writing dilated .mask ====###' # mask = maput.numpy2mask (H2, dinf.limit, Ndil) # outfile = outfile.replace('.fits','') + '_mask.fits', #img = bdsm.process_image(filename= outfile+'_simple_conv.fits', thresh_isl=args.tIs, thresh_pix=args.tPi, mean_map = 'zero', beam = (0.0125,0.0125,0), rms_map = False, rms_value = 0.00045, thresh = 'hard') #img.export_image(outfile= outfile+'_simple_conv.ismk.fits' , img_type='island_mask', img_format='fits', mask_dilation=5, clobber=True) #img.export_image(outfile= outfile+'_simple_conv.ismk.mask' , img_type='island_mask', img_format='casa', mask_dilation=5, clobber=True) if CASAmock: """ Removed implementation; original idea: #1. Python: Create convolved perfect simulational output image #2. PyBDSM/Python: Create clean mask on that with some dilation #3. Casa/Python: Create constant rms and beam-corrected image (clean) #4. Casa/Python: Apply this clean mask with immath on constant-rms image #5. PyBDSM/python: Use pybdsm with detection_image= 'masked_constant rms_image' #6. Python. Create masked .fits mock imagename #7 Python. Extract radio relics """ else: if log: print( '###==== - Using the simple convolved image ====###' ) IM0 = H2 #(fits.open(simpleconv))[0].data smt(task='CreateMask_[sub]') #print( '###==== Step 6: Create masked .fits mock image ====###' IM1 = np.squeeze( IM0) #!!! Here unmasked! ... np.multiply(np.squeeze(IM0), mask) """Outdated saveFITS, please update and put to end of procedure """ if saveFITS and CASAmock: maput.numpy2FITS(IM1, 'sim.vla.d.masked.fits', dinf.spixel) smt(task='RelicExtr_[sub]') relics = relex.RelicExtraction( IM1, z, GCl=gcl, dinfo=dinf, rinfo=cbclass.RelicRegion( '', [], rtype=1)) #, faintexcl=0.4, Mach=Hmach, Dens=Hdens, smt(task='RelicHandling_[sub]') relics = sorted(relics, key=lambda x: x.flux, reverse=True) gcl.add_relics(relics) if savewodetect or len(relics) > 0: if log: print( ' ++The brightest relic found has a flux density of %f mJy' % (relics[0].flux) ) #Could producese errors, once there is no relict in the list iom.check_mkdir(savefolder + '/maps/z%04.f' % (gcl.mockobs.z_snap * 1000)) """ Part to derive additional relic information like average and mach number and alpha. We also get the emission weighted density, as this works only on the bright parts it is fine to work with the subset of particles """ alpha_help = (snap.mach[iL]**2 + 1) / (snap.mach[iL]**2 - 1) Hmach = SPH_binning( snap, posrot, dinf, iL, immask=DoG_mask, HSize_z=hsize, nbins=nbins, weights=lambda x: s_radio_SI * x.radi[iL] * x.mach[iL]) Halpha = SPH_binning( snap, posrot, dinf, iL, immask=DoG_mask, HSize_z=hsize, nbins=nbins, weights=lambda x: s_radio_SI * x.radi[iL] * alpha_help) Hrho_up = SPH_binning(snap, posrot, dinf, iL, immask=DoG_mask, HSize_z=hsize, nbins=nbins, weights=lambda x: s_radio_SI * x.radi[iL] * x .rup[iL] * fac_rho) Htemp = SPH_binning( snap, posrot, dinf, iL, immask=DoG_mask, HSize_z=hsize, nbins=nbins, weights=lambda x: s_radio_SI * x.radi[iL] * x.u[iL] * fac_T) Harea = SPH_binning( snap, posrot, dinf, iL, immask=DoG_mask, HSize_z=hsize, nbins=nbins, weights=lambda x: s_radio_SI * x.radi[iL] * x.area[iL]) Hmag = SPH_binning( snap, posrot, dinf, iL, immask=DoG_mask, HSize_z=hsize, nbins=nbins, weights=lambda x: s_radio_SI * x.radi[iL] * x.B[iL]) Hpre = SPH_binning(snap, posrot, dinf, iL, immask=DoG_mask, HSize_z=hsize, nbins=nbins, weights=lambda x: s_radio_SI * x.radiPre[iL]) allflux = np.asarray([]) for relic in relics: relic.wMach = Hmach[relic.pmask] relic.wT = Htemp[relic.pmask] relic.wArea = Harea[relic.pmask] relic.wAlpha = Halpha[relic.pmask] relic.wB = Hmag[relic.pmask] relic.wPre = Hpre[relic.pmask] relic.wRho_up = Hrho_up[relic.pmask] # relic.wRho = Hrho [relic.pmask] # relic.wRho_down = Hrho_down[relic.pmask] # relic.wT_up = Htemp_up[relic.pmask] # relic.wT_down = Htemp_down[relic.pmask] relic.wDoG_rel = DoG_rel[relic.pmask] allflux = np.concatenate((relic.sparseW, allflux), axis=0) relic.averages_quantities() """Save maps""" allflux = allflux.flatten() """ I couldn't come up with something better to take the inverse """ mask = np.ones(snap.rho.shape, dtype=bool) mask[iL] = 0 Subtracted, xedges, yedges = np.histogram2d( -posrot[mask, 0], -posrot[mask, 1], weights=s_radio_SI * snap.radi[mask], range=[[-hsize, hsize], [-hsize, hsize]], bins=nbins) Subtracted += H1 * (1 - DoG_mask) Subtracted_conv = dinf.convolve_map(Subtracted) if extract_subtracted: relics_subtracted = relex.RelicExtraction( Subtracted_conv, z, GCl=gcl, dinfo=dinf, rinfo=cbclass.RelicRegion( '', [], rtype=1)) # , faintexcl=0.4, Mach=Hmach, Dens=Hdens, for relic in relics_subtracted: relic.wMach = Hmach[relic.pmask] relic.wT = Htemp[relic.pmask] relic.wArea = Harea[relic.pmask] relic.wAlpha = Halpha[relic.pmask] relic.wB = Hmag[relic.pmask] relic.wPre = Hpre[relic.pmask] relic.wRho_up = Hrho_up[relic.pmask] # relic.wRho = Hrho [relic.pmask] # relic.wRho_down = Hrho_down[relic.pmask] # relic.wT_up = Htemp_up[relic.pmask] # relic.wT_down = Htemp_down[relic.pmask] relic.wDoG_rel = DoG_rel[relic.pmask] relic.averages_quantities() gcl.compacts = relics_subtracted if saveFITS: """ Here the maps are already masked with the detection region """ smt(task='WriteFits_[writes,sub]') if log: print( '###==== Step 4: Preparing FITS file & folders ====###' ) parlist = (savefolder, gcl.mockobs.z_snap * 1000, gcl.name, Rmodel.id) gcl.maps_update(H1, 'Raw', '%s/maps/z%04.f/%s-%04i_native.fits' % parlist) gcl.maps_update(IM1, 'Diffuse', '%s/maps/z%04.f/%s-%04i.fits' % parlist) gcl.maps_update( Subtracted, 'CompModell', '%s/maps/z%04.f/%s-%04i_compact.fits' % parlist) gcl.maps_update( Subtracted_conv, 'Subtracted', '%s/maps/z%04.f/%s-%04i_compactObserved.fits' % parlist) if len(relics) > 0: gcl.maps_update( gcl.Mask_Map(Hmach, normalize=allflux), 'Mach', '%s/maps/z%04.f/%s-%04i_mach.fits' % parlist) gcl.maps_update( gcl.Mask_Map(Hrho_up, normalize=allflux), 'RhoUp', '%s/maps/z%04.f/%s-%04i_rhoup.fits' % parlist) gcl.maps_update( gcl.Mask_Map(Htemp, normalize=allflux), 'Temp', '%s/maps/z%04.f/%s-%04i_temp.fits' % parlist) gcl.maps_update(gcl.Mask_Map(Hmag, normalize=allflux), 'B', '%s/maps/z%04.f/%s-%04i_B.fits' % parlist) gcl.maps_update( gcl.Mask_Map(Hpre, normalize=allflux), 'PreRatio', '%s/maps/z%04.f/%s-%04i_prerat.fits' % parlist) gcl.maps_update( DoG_rel, 'DoG_rel', '%s/maps/z%04.f/%s-%04i_DoG_rel.fits' % parlist) gcl.maps_update( DoG_mask, 'DoG_mask', '%s/maps/z%04.f/%s-%04i_DoG_mask.fits' % parlist) """ PhD feature --> plot the DoF images in a subplot ## import matplotlib.pyplot as plt ## with np.errstate(divide='ignore', invalid='ignore'): ## DoG_rel = np.divide(np.abs(convolved_sigma2-convolved_sigma1)+1e-20,convolved_sigma2+1e-20) ## pixR200 = gcl.R200()/(gcl.cosmoPS*dinf.spixel) ## bou = gcl.R200()*1.5 # pixR200*1 ## f, ((ax1, ax2, ax3)) = plt.subplots(1, 3, figsize=(30,12)) #, sharey='row', sharex='col', sharey='row' ## ax1.imshow( np.power((np.abs(convolved_sigma1-convolved_sigma2)), 1/1 ) , extent=(-hsize, hsize, -hsize, hsize)) #-bou+cen ## im2 = ax2.imshow( DoG_rel , extent=(-hsize, hsize, -hsize, hsize), vmin=0.2, vmax=1 ) #-bou+cen ## XX,YY = np.meshgrid(xedges[0:-1]+0.5*gcl.cosmoPS*dinf.spixel,yedges[0:-1][::-1]+0.5*gcl.cosmoPS*dinf.spixel) #yedges[-1:0] ## ax2.contour(XX, YY, DoG_mask, colors='r', levels=[0.5]) ## ax3.imshow( np.power(dinf.convolve_map(H1*DoG_mask), 1/1 ), extent=(-hsize, hsize, -hsize, hsize) ) #-bou+cen ## ax1.set_xlim(-bou, bou) ## ax1.set_ylim(-bou, bou) ## ax2.set_xlim(-bou, bou) ## ax2.set_ylim(-bou, bou) ## ax3.set_xlim(-bou, bou) ## ax3.set_ylim(-bou, bou) ## ## ax1.set_title('DoG') ## ax2.set_title('DoG/LowResImage + mask (contours)') ## ax3.set_title('Filtered NVSS') ## ## print('CreateMokObs', pixR200, gcl.R200(),dinf.spixel, gcl.cosmoPS) ## circle1 = plt.Circle((0, 0), gcl.R200(), fill=False, color='w', ls='-') ## circle2 = plt.Circle((0, 0), gcl.R200(), fill=False, color='w', ls='-') ## circle3 = plt.Circle((0, 0), gcl.R200(), fill=False, color='w', ls='-') ## ## ax1.add_artist(circle1) ## ax2.add_artist(circle2) ## ax3.add_artist(circle3) ## ## cax2 = f.add_axes([0.42, 0.12, 0.2, 0.03]) ## cb2 = f.colorbar(im2, format='%.2f', ticks=[0.0, 0.25, 0.5, 0.75, 1.0], cax = cax2, orientation="horizontal") #label='average Mach', ## ## plt.savefig('%s/%s-%04i_joined.png' % (savefolder, gcl.name, Rmodel.id)) #dpi=400 ## plt.savefig('%s/%s-%04i_joined.pdf' % (savefolder, gcl.name, Rmodel.id)) #dpi=400 # """ """ gcl.add_relics(relics) PhD feature end """ if writeClusters: """This is here because some outputs get lost in a multiprocessing heavy input/output queue process""" for gcl in GClrealisations_used: filename = 'GCl-%05i' % (gcl.mockobs.id) iom.pickleObject((gcl, Rmodel), savefolder + '/pickled/', filename, append=False) if log: print('Finished with all efficency values') return True, smt, GClrealisations_used, Rmodel
import drivecasa.commands.simulation as sim from astropy.coordinates import SkyCoord from astropy.time import Time from drivecasa.utils import ensure_dir output_dir = './simulation_output' ensure_dir(output_dir) commands_logfile = os.path.join(output_dir, "./casa-commands.log") component_list_path = os.path.join(output_dir, './sources.cl') output_visibility = os.path.join(output_dir, './foovis.ms') if os.path.isfile(commands_logfile): os.unlink(commands_logfile) casa = drivecasa.Casapy( commands_logfile=commands_logfile, echo_to_stdout=True, ) script = [] # For VLA reference numbers, see: # https://science.nrao.edu/facilities/vla/docs/manuals/oss/performance/fov # https://science.nrao.edu/facilities/vla/docs/manuals/oss/performance/resolution # Define some observation parameters: obs_central_frequency = 3. * u.GHz obs_frequency_bandwidth = 0.125 * u.GHz primary_beam_fwhm = (45. * u.GHz / obs_central_frequency) * u.arcmin # Define the field centre and sources: centre_ra = 180 * u.deg centre_dec = 34 * u.deg
def simulate_vis_with_casa(pointing_centre, source_list, noise_std_dev, vis_path, overwrite=True, echo=False): """ Use casapy to simulate a visibility measurementset with noise. (This also produces an initial set of UVW data) Args: pointing_centre (:class:`astropy.coordinates.SkyCoord`) source_list: list of :class:`fastimgproto.skymodel.helpers.SkySource` noise_std_dev (astropy.units.Quantity): Standard deviation of the noise (units of Jy). vis_path (str): Path to visibilities generated. echo (bool): Echo the CASA output to terminal during processing. Returns (str): Full path to `vis.ms`. """ vis_abspath = os.path.abspath(vis_path) commands_logfile = vis_abspath + "_casa_commands.log" casa_logfile = vis_abspath + "_casa_log.log" component_list_path = vis_abspath + "_sources.cl" for outdir in vis_abspath, component_list_path: if os.path.isdir(outdir): if overwrite: shutil.rmtree(outdir) else: raise IOError( "{} already present and overwrite==False.".format(outdir)) if os.path.isfile(commands_logfile): os.remove(commands_logfile) ensure_dir(os.path.dirname(vis_abspath)) casa = drivecasa.Casapy(commands_logfile=commands_logfile, casa_logfile=casa_logfile, echo_to_stdout=echo) script = [] # Add subroutine definition, for manual reproduction with CASA: script.append( drivecasa.drivecasa.commands.subroutines.def_load_antennalist) # Define some observation parameters... # For VLA reference numbers, see: # https://science.nrao.edu/facilities/vla/docs/manuals/oss/performance/fov # https://science.nrao.edu/facilities/vla/docs/manuals/oss/performance/resolution obs_central_frequency = 3. * u.GHz obs_frequency_bandwidth = 0.125 * u.GHz primary_beam_fwhm = (45. * u.GHz / obs_central_frequency) * u.arcmin # Convert the sources to a CASA 'componentlist' component_list_path = sim.make_componentlist( script, source_list=[(s.position, s.flux, s.frequency) for s in source_list], out_path=component_list_path) # Open the visibility file sim.open_sim(script, vis_abspath) # Configure the virtual telescope # sim.setpb(script, # telescope_name='VLA', # primary_beam_hwhm=primary_beam_fwhm * 0.5, # frequency=obs_central_frequency) sim.setconfig(script, telescope_name='VLA', antennalist_path=vla_c_antennalist_path) sim.setspwindow( script, freq_start=obs_central_frequency - 0.5 * obs_frequency_bandwidth, freq_resolution=obs_frequency_bandwidth, freq_delta=obs_frequency_bandwidth, n_channels=1, ) sim.setfeed(script, ) sim.setfield(script, pointing_centre) sim.setlimits(script) sim.setauto(script) ref_time = Time('2014-05-01T19:55:45', format='isot', scale='tai') sim.settimes(script, integration_time=10 * u.s, reference_time=ref_time) # Generate the visibilities sim.observe(script, stop_delay=10 * u.s) sim.predict(script, component_list_path) sim.set_simplenoise(script, noise_std_dev=noise_std_dev) sim.corrupt(script) sim.close_sim(script) casa_output = casa.run_script(script) return casa_output