def bootstrap_uvfits_with_difmap_model( uv_fits_path, dfm_model_path, nonparametric=False, use_kde=False, use_v=False, n_boot=100, stokes='I', boot_dir=None, recenter=True, pairs=False, niter=100, bootstrapped_uv_fits=None, additional_noise=None, boot_mdl_outname_base="bootstrapped_model"): dfm_model_dir, dfm_model_fname = os.path.split(dfm_model_path) comps = import_difmap_model(dfm_model_fname, dfm_model_dir) if boot_dir is None: boot_dir = os.getcwd() if bootstrapped_uv_fits is None: uvdata = UVData(uv_fits_path) model = Model(stokes=stokes) model.add_components(*comps) boot = CleanBootstrap([model], uvdata, additional_noise=additional_noise) os.chdir(boot_dir) boot.run(nonparametric=nonparametric, use_kde=use_kde, recenter=recenter, use_v=use_v, n=n_boot, pairs=pairs) bootstrapped_uv_fits = sorted( glob.glob(os.path.join(boot_dir, 'bootstrapped_data*.fits'))) for j, bootstrapped_fits in enumerate(bootstrapped_uv_fits): modelfit_difmap(bootstrapped_fits, dfm_model_fname, '{}_{}.mdl'.format(boot_mdl_outname_base, j), path=boot_dir, mdl_path=dfm_model_dir, out_path=boot_dir, niter=niter) booted_mdl_paths = glob.glob( os.path.join(boot_dir, '{}*'.format(boot_mdl_outname_base))) # Clean uv_fits for file_ in bootstrapped_uv_fits: os.unlink(file_) logs = glob.glob(os.path.join(boot_dir, "*.log*")) for file_ in logs: os.unlink(file_) comms = glob.glob(os.path.join(boot_dir, "*commands*")) for file_ in comms: os.unlink(file_) return booted_mdl_paths
def create_sample(original_uv_fits, original_mdl_file, outdir=None, n_sample=100, stokes='I'): """ Create `sample` from `true` or `model` source :param outdir: (optional) Directory to store intermediate results. If ``None`` then use CWD. (default: ``None``) :param n_sample: (optional) Number of `samples` from infinite population to consider in coverage analysis of intervals. Here `samples` - observations of known source with different realisations of noise with known parameters. (default: ``100``) :param stokes: (optional) Stokes parameter to use. If ``None`` then use ``I``. (default: ``None``) """ original_uv_data = UVData(original_uv_fits) noise = original_uv_data.noise() path, _ = os.path.split(original_mdl_file) comps = import_difmap_model(original_mdl_file, path) original_model = Model(stokes=stokes) original_model.add_components(*comps) # Substitute uv-data with original model and create `model` uv-data print("Substituting `original` uv-data with CLEAN model...") model_uv_data = copy.deepcopy(original_uv_data) model_uv_data.substitute([original_model]) # Create `sample` uv-data # Add noise to `model` uv-data ``n_cov`` times and get ``n_cov`` `samples` # from population sample_uv_fits_paths = list() print("Creating {} `samples` from population".format(n_sample)) for i in range(n_sample): sample_uv_data = copy.deepcopy(model_uv_data) sample_uv_data.noise_add(noise) sample_uv_fits_path = os.path.join( outdir, 'sample_uv_{}.uvf'.format(str(i + 1).zfill(3))) sample_uv_data.save(sample_uv_fits_path) sample_uv_fits_paths.append(sample_uv_fits_path) # Fitting in difmap each `sample` FITS-file print("Fitting `samples` uv-data") for uv_fits_path in sample_uv_fits_paths: uv_fits_dir, uv_fits_fname = os.path.split(uv_fits_path) j = uv_fits_fname.split('.')[0].split('_')[-1] print("Fitting {} sample uv-data to" " {}".format( uv_fits_path, os.path.join(outdir, 'sample_model_{}.mdl'.format(j)))) modelfit_difmap(uv_fits_fname, original_mdl_file, 'sample_model_{}.mdl'.format(j), path=uv_fits_dir, mdl_path=uv_fits_dir, out_path=uv_fits_dir) sample_mdl_paths = sorted( glob.glob(os.path.join(outdir, 'sample_model_*.mdl'))) sample_uv_fits_paths = sorted( glob.glob(os.path.join(outdir, 'sample_uv_*.uvf'))) return sample_uv_fits_paths, sample_mdl_paths
def coverage_of_model(original_uv_fits, original_mdl_file, outdir=None, n_cov=100, n_boot=300, mapsize=(1024, 0.1), path_to_script=None): """ Conduct coverage analysis of uv-data & model :param original_uv_fits: Self-calibrated uv-fits file. :param original_mdl_file: Difmap txt-file with model. :param outdir: Output directory to store results. :param n_cov: Number of samples to create. """ # Create sample of 100 uv-fits data & models sample_uv_fits_paths, sample_model_paths = create_sample(original_uv_fits, original_mdl_file, outdir=outdir, n_sample=n_cov) # For each sample uv-fits & model find 1) conventional errors & 2) bootstrap # errors for j, (sample_uv_fits_path, sample_mdl_path) in enumerate( zip(sample_uv_fits_paths, sample_model_paths)): sample_uv_fits, dir = os.path.split(sample_uv_fits_path) sample_mdl_file, dir = os.path.split(sample_mdl_path) try: comps = import_difmap_model(sample_mdl_file, dir) except ValueError: print('Problem import difmap model') model = Model(stokes='I') model.add_components(*comps) # Find errors by using Fomalont way # 1. Clean uv-data clean_difmap(sample_uv_fits, 'sample_cc_{}.fits'.format(j), 'I', mapsize, path=dir, path_to_script=path_to_script, outpath=dir) # 2. Get beam ccimage = create_clean_image_from_fits_file( os.path.join(dir, 'sample_cc_{}.fits'.format(j))) beam = ccimage.beam_image # 2. Subtract components convolved with beam ccimage.substract_model(model) # Find errors by using Lee way # a) fit uv-data and find model # b) CLEAN uv-data # c) substract model from CLEAN image # d) find errors pass # Find errors by using bootstrap # FT model to uv-plane uvdata = UVData(sample_uv_fits_path) try: boot = CleanBootstrap([model], uvdata) # If uv-data contains only one Stokes parameter (e.g. `0838+133`) except IndexError: print('Problem bootstrapping') curdir = os.getcwd() os.chdir(dir) boot.run(n=n_boot, nonparametric=True, outname=[outname, '.fits']) os.chdir(curdir) booted_uv_paths = sorted( glob.glob(os.path.join(data_dir, outname + "*"))) # Modelfit bootstrapped uvdata for booted_uv_path in booted_uv_paths: path, booted_uv_file = os.path.split(booted_uv_path) i = booted_uv_file.split('_')[-1].split('.')[0] modelfit_difmap(booted_uv_file, dfm_model_fname, dfm_model_fname + '_' + i, path=path, mdl_path=data_dir, out_path=data_dir) # Get params of initial model used for bootstrap comps = import_difmap_model(dfm_model_fname, data_dir) comps_params0 = {i: [] for i in range(len(comps))} for i, comp in enumerate(comps): comps_params0[i].extend(list(comp.p)) # Load bootstrap models booted_mdl_paths = glob.glob( os.path.join(data_dir, dfm_model_fname + "_*")) comps_params = {i: [] for i in range(len(comps))} for booted_mdl_path in booted_mdl_paths: path, booted_mdl_file = os.path.split(booted_mdl_path) comps = import_difmap_model(booted_mdl_file, path) for i, comp in enumerate(comps): comps_params[i].extend(list(comp.p)) # Print 65-% intervals (1 sigma) for i, comp in enumerate(comps): errors_fname = '68_{}_{}_comp{}.txt'.format(source, last_epoch, i) fn = open(os.path.join(data_dir, errors_fname), 'w') print "Component #{}".format(i + 1) for j in range(len(comp)): low, high, mean, median = hdi_of_mcmc(np.array( comps_params[i]).reshape((n_boot, len(comp))).T[j], cred_mass=0.68, return_mean_median=True) fn.write("{} {} {} {} {}".format(comp.p[j], low, high, mean, median)) fn.write("\n") fn.close() # For source in sources with component close to core # 1. Find residuals or estimate noise # 2. N times add resampled residuals (or just gaussian noise) to model and # create N new datasets # 3. Fit them using difmap. # 4. Find errors using Fomalont, Yee and using bootstrap. Check coverage. base_dir = '/home/ilya/vlbi_errors/model_cov' n_boot = 300 outname = 'boot_uv' names = [ 'source', 'id', 'trash', 'epoch', 'flux', 'r', 'pa', 'bmaj', 'e', 'bpa' ] df = pd.read_table(os.path.join(base_dir, 'asu.tsv'), sep=';', header=None, names=names, dtype={key: str for key in names}, index_col=False) # Mow for all sources get the latest epoch and create directory for analysis for source in df['source'].unique(): epochs = df.loc[df['source'] == source]['epoch'] last_epoch_ = list(epochs)[-1] last_epoch = last_epoch_.replace('-', '_') data_dir = os.path.join(base_dir, source, last_epoch) if not os.path.exists(data_dir): os.makedirs(data_dir) try: download_mojave_uv_fits(source, epochs=[last_epoch], bands=['u'], download_dir=data_dir) except: open( 'problem_download_from_mojave_{}_{}'.format( source, last_epoch), 'a').close() continue uv_fits_fname = mojave_uv_fits_fname(source, 'u', last_epoch) # Create instance of Model and bootstrap uv-data dfm_model_fname = 'dfmp_original_model.mdl' fn = open(os.path.join(data_dir, dfm_model_fname), 'w') model_df = df.loc[np.logical_and(df['source'] == source, df['epoch'] == last_epoch_)] for (flux, r, pa, bmaj, e, bpa) in np.asarray( model_df[['flux', 'r', 'pa', 'bmaj', 'e', 'bpa']]): print flux, r, pa, bmaj, e, bpa if not r.strip(' '): r = '0.0' if not pa.strip(' '): pa = '0.0' if not bmaj.strip(' '): bmaj = '0.0' if not e.strip(' '): e = "1.0" if np.isnan(float(bpa)): bpa = "0.0" else: bpa = bpa + 'v' if bmaj == '0.0': type_ = 0 bpa = "0.0" else: bmaj = bmaj + 'v' type_ = 1 fn.write("{}v {}v {}v {} {} {} {} {} {}".format( flux, r, pa, bmaj, e, bpa, type_, "0", "0\n")) fn.close()
def cv_score(self, initial_dfm_model_path=None, data_dir=None, niter=100, path_to_script=None, mapsize_clean=None): if data_dir is None: data_dir = os.getcwd() train_uv_fits_paths = sorted( glob.glob(os.path.join(data_dir, self.train_fname_base + '*'))) test_uv_fits_paths = sorted( glob.glob(os.path.join(data_dir, self.test_fname_base + '*'))) cv_scores = list() train_scores = list() if initial_dfm_model_path is not None: for i, (train_uv_fits_path, test_uv_fits_path) in enumerate( zip(train_uv_fits_paths, test_uv_fits_paths)): print("Calculating CV-score for {} of {} splits".format( i + 1, self.k)) print("Training FITS: {}".format(train_uv_fits_path)) print("Testing FITS: {}".format(test_uv_fits_path)) out_mdl_fname = 'train_{}.mdl'.format(i) dfm_model_dir, dfm_model_fname = os.path.split( initial_dfm_model_path) modelfit_difmap(train_uv_fits_path, dfm_model_fname, out_mdl_fname, niter=niter, path=data_dir, mdl_path=dfm_model_dir, out_path=data_dir, stokes=self.stokes, show_difmap_output=True) cv_scores.append( score(test_uv_fits_path, os.path.join(data_dir, out_mdl_fname))) train_scores.append( score(train_uv_fits_path, os.path.join(data_dir, out_mdl_fname))) else: for i, (train_uv_fits_path, test_uv_fits_path) in enumerate( zip(train_uv_fits_paths, test_uv_fits_paths)): out_mdl_fname = 'train_{}.fits'.format(i) # This used when learning curves are created # clean_difmap(train_uv_fits_path, out_mdl_fname, 'I', # mapsize_clean, data_dir, path_to_script, # outpath=data_dir, show_difmap_output=True) # This used when different number of iterations are tested clean_n( train_uv_fits_path, out_mdl_fname, 'I', mapsize_clean, niter=niter, path_to_script=path_to_script, outpath=data_dir, show_difmap_output=True, ) cv_scores.append( score(test_uv_fits_path, os.path.join(data_dir, out_mdl_fname))) train_scores.append( score(train_uv_fits_path, os.path.join(data_dir, out_mdl_fname))) return cv_scores, train_scores
epoch_ = "{}_{}_{}".format(*epoch.split('-')) download_mojave_uv_fits(source, epochs=[epoch_], download_dir=source_dir, bands=['u']) fname = mojave_uv_fits_fname(source, 'u', epoch_) uvdata = UVData(os.path.join(source_dir, fname)) print(uvdata.stokes) if 'RR' not in uvdata.stokes or 'LL' not in uvdata.stokes: continue # Refit difmap model modelfit_difmap(fname, "{}_{}.mdl".format(source, epoch), "{}_{}.mdl".format(source, epoch), niter=200, path=source_dir, mdl_path=source_dir, out_path=source_dir, show_difmap_output=True) # Create sample of 100 artificial data sets sample_uv_fits_paths, sample_mdl_paths =\ create_sample(os.path.join(source_dir, fname), os.path.join(source_dir, "{}_{}.mdl".format(source, epoch)), outdir=source_dir, n_sample=100) for i, (sample_uv_fits_path, sample_mdl_path) in enumerate( zip(sample_uv_fits_paths, sample_mdl_paths)): # Create bootstrapped model files booted_mdl_paths =\ bootstrap_uvfits_with_difmap_model(sample_uv_fits_path,
mdl.add_components(cg1, cg2, cg3) uvdata = UVData(uv_fits_path) noise = uvdata.noise() for i in range(1, 101): uvdata = UVData(uv_fits_path) uvdata.substitute([mdl]) uvdata.noise_add(noise) art_fits_fname = 'art_{}_{}.fits'.format(freq, i) art_fits_path = os.path.join(data_dir, art_fits_fname) uvdata.save(art_fits_path) # Here we should MCMC posterior modelfit_difmap(art_fits_fname, 'initial.mdl', 'out_{}_{}.mdl'.format(freq, i), niter=100, path=data_dir, mdl_path=data_dir, out_path=data_dir) params = list() for i in range(1, 101): comps = import_difmap_model('out_{}_{}.mdl'.format(freq, i), data_dir) params.append([ comps[0].p[0], comps[0].p[2], comps[1].p[0], comps[1].p[2], comps[2].p[0], comps[2].p[2] ]) params = np.array(params) label_size = 16 import matplotlib
if bmaj == '0.0': type_ = 0 bpa = "0.0" else: bmaj = bmaj + 'v' type_ = 1 fn.write("{}v {}v {}v {} {} {} {} {} {}".format(flux, r, pa, bmaj, e, bpa, type_, "0", "0\n")) fn.close() refitted_mdl_fname = 'dfm_original_model_refitted.mdl' refitted_mdl_path = os.path.join(source_dir, refitted_mdl_fname) modelfit_difmap(uv_fits_fname, dfm_model_fname, refitted_mdl_fname, niter=300, path=source_dir, mdl_path=source_dir, out_path=source_dir) # comps = import_difmap_model(refitted_mdl_fname, source_dir) # model = Model(stokes='I') # model.add_components(*comps) # uvdata = UVData(uv_fits_path) # fig = uvdata.uvplot() # uvdata.substitute([model]) # uvdata.uvplot(fig=fig, color='r') # bootstrapped_uv_fits = sorted(glob.glob(os.path.join(source_dir, # 'bootstrapped_data*.fits'))) # fig = bootstrap_uvfits_with_difmap_model(uv_fits_path, refitted_mdl_path,
uvdata = UVData(os.path.join(data_dir, uv_fits)) noise = uvdata.noise(use_V=False) # noise = {bl: 0.1*noise_ for bl, noise_ in noise.items()} eg1 = EGComponent(5., 0, 0, 0.15, 0.33, 0.2) eg2 = EGComponent(2.5, 1, 1, 0.5, 0.5, 0.) model = Model(stokes='I') model.add_components(eg1, eg2) # model.add_components(eg1, eg2) uvdata_c = copy.deepcopy(uvdata) uvdata_c.substitute([model]) uvdata_c.noise_add(noise) uvdata_c.save(os.path.join(data_dir, 'fake.fits'), rewrite=True) modelfit_difmap('fake.fits', 'mod_c2_2ee.mdl', 'out_2c.mdl', path=data_dir, mdl_path=data_dir, out_path=data_dir, niter=100) comps = import_difmap_model('out_2c.mdl', data_dir) print[comp.p for comp in comps] model_fitted = Model(stokes='I') model_fitted.add_components(*comps) uvdata_mf = copy.deepcopy(uvdata) uvdata_mf.substitute([model_fitted]) fig = uvdata_c.uvplot(color='g', phase_range=[-1, 1]) uvdata_mf.uvplot(fig=fig, color='r', phase_range=[-1, 1]) hdus_orig = pf.open(os.path.join(data_dir, uv_fits)) hdus_fake = pf.open(os.path.join(data_dir, 'fake.fits'))
original_model_fname = '2017_01_28us' original_model_path = os.path.join(data_dir, original_model_fname) comps = import_difmap_model(original_model_fname, data_dir) model = Model(stokes='I') model.add_components(*comps) cv_scores = list() train_scores = list() for i, fname in enumerate(['1IF.fits', '12IF.fits', '123IF.fits', '1234IF.fits', '12345IF.fits', '123456IF.fits', '1234567IF.fits']): current_fits = os.path.join(data_dir, fname) modelfit_difmap(current_fits, original_model_fname, 'out_{}.mdl'.format(i), path=data_dir, mdl_path=data_dir, out_path=data_dir, niter=100) comps = import_difmap_model('out_{}.mdl'.format(i), data_dir) model = Model(stokes='I') model.add_components(*comps) # Calculate performance on training data uvdata_train_model = UVData(current_fits) uvdata_train = UVData(current_fits) uvdata_train_model.substitute([model]) uvdata_diff_train = uvdata_train - uvdata_train_model factor = np.count_nonzero(~uvdata_diff_train.uvdata_weight_masked.mask[:, :, :2]) squared_diff = uvdata_diff_train.uvdata_weight_masked[:, :, :2] *\ uvdata_diff_train.uvdata_weight_masked[:, :, :2].conj() score = float(np.sum(squared_diff)) / factor train_scores.append(score)
downscale_by_freq=True) # Self-calibrate selfcal_difmap( fname="artificial.uvf", outfname="artificial.uvf", path=data_dir, path_to_script="/home/ilya/github/ve/difmap/auto_selfcal", outpath=data_dir, show_difmap_output=True) modelfit_difmap("artificial.uvf", "{}.mod".format(epoch), "boot_artificial.mdl", niter=300, stokes=stokes, path=data_dir, mdl_path=data_dir, out_path=data_dir, show_difmap_output=True) new_dfm_model = import_difmap_model("boot_artificial.mdl", data_dir) print([cg.p for cg in new_dfm_model]) params.append([cg.p for cg in new_dfm_model]) n_comps = len(original_dfm_model) param_name_dict = {0: "flux", 1: "dx", 2: "dy", 3: "fwhm"} with open(os.path.join(data_dir, "{}_errors_100.txt".format(epoch)), "w") as fo: for n_comp in range(n_comps):
uvdata_ = UVData(os.path.join(data_dir, uv_fits)) mdl1 = Model(stokes='I') mdl1.add_component(comp) uvdata_.substitute([mdl1]) uvdata_diff = uvdata - uvdata_ uvdata_diff.save( os.path.join(data_dir, 'without_{}_ccs.uvp'.format(str(i + 350).zfill(3)))) fits_files = sorted(glob.glob(os.path.join(data_dir, 'without*'))) for fits_file in fits_files: fits_fname = os.path.split(fits_file)[-1] i = fits_fname.split('_')[1] modelfit_difmap(fits_file, model_fname, 'without_{}_css.mdl'.format(i), path=data_dir, mdl_path=data_dir, out_path=data_dir) bmajs = list() es = list() mdl_files = sorted(glob.glob(os.path.join(data_dir, 'without*.mdl'))) for mdl_file in mdl_files: mdl_fname = os.path.split(mdl_file)[-1] i = mdl_fname.split('_')[1] comps = import_difmap_model(mdl_fname, data_dir) core_comp = comps[0] bmaj = core_comp._p[3] e = core_comp._p[4] bmajs.append(bmaj) es.append(e)
from stats import LnLikelihood, LnPost from image import find_bbox from image import plot as iplot from image_ops import rms_image import emcee import corner import matplotlib.pyplot as plt data_dir = '/home/ilya/code/vlbi_errors/bin_q' # q - 43GHz, k - 23.8GHz, u - 15GHz, ... uv_fname = '0235+164.q1.2008_09_02.uvf_difmap' mdl_fname = '0235+164.q1.2008_09_02_delta.mdl' modelfit_difmap(uv_fname, mdl_fname, '0235+164.q1.2008_09_02_delta_fitted.mdl', niter=100, path=data_dir, mdl_path=data_dir, out_path=data_dir) # # Clean uv-data # clean_difmap(uv_fname, 'cc.fits', 'I', (1024, 0.03), path=data_dir, # path_to_script='/home/ilya/code/vlbi_errors/difmap/final_clean_nw', # outpath=data_dir, show_difmap_output=True) # # image = create_clean_image_from_fits_file(os.path.join(data_dir, 'cc.fits')) # rms = rms_image(image) # blc, trc = find_bbox(image.image, 2.*rms, delta=int(image._beam.beam[0])) # # Plot image # iplot(image.image, x=image.x, y=image.y, min_abs_level=3. * rms, # outfile='clean_image', outdir=data_dir, blc=blc, trc=trc, beam=image.beam,
for n_comp in np.arange(1, 10): cv_scores[n_comp] = dict() for i, (train_uvfits_fname, test_uvfits_fname) in enumerate(scans_cv): print("BASELINE = ", scans_cv.cur_bl, ", SCAN# = ", scans_cv.cur_scan, " ====================") # Optionally create entry in dict if scans_cv.cur_bl not in cv_scores[n_comp]: cv_scores[n_comp][scans_cv.cur_bl] = list() print(train_uvfits_fname, test_uvfits_fname) # Modelfit train data set modelfit_difmap(fname=train_uvfits_fname, mdl_fname="{}cg.mdl".format(n_comp), out_fname="trained.mdl", niter=100, stokes='i', path=data_dir, mdl_path=data_dir, out_path=data_dir, show_difmap_output=False) # Score trained model on test data set cv_score = score(os.path.join(data_dir, test_uvfits_fname), os.path.join(data_dir, "trained.mdl")) print("CV score = ", cv_score) cv_scores[n_comp][scans_cv.cur_bl].append(cv_score) print("Result for current k = {} is {}".format( n_comp, cv_scores[n_comp])) with open("cv_scores_dump.pkl", "wb") as fo: pickle.dump(cv_scores, fo)
# abs_levels=[2*std], colors_mask=None, color_clim=None, blc=blc, trc=trc, # beam=beam, close=False, show_beam=True, show=True, # cmap='viridis', contour_color='red', fig=fig) # # # fig.savefig(os.path.join(data_dir, "original_selfcaled.png"), dpi=300, bbox_inches="tight") # plt.close() # Find gains products corrections = uvdata_raw.uvdata/uvdata_sc.uvdata # Create artificial raw data with known sky model and given corrections original_dfm_model = import_difmap_model(os.path.join(data_dir, "2019_08_27.mod")) modelfit_difmap("myselfcaled.uvf", "2019_08_27.mod", "artificial.mdl", niter=100, stokes='I', path=data_dir, mdl_path=data_dir, out_path=data_dir, show_difmap_output=True) new_dfm_model = import_difmap_model("artificial.mdl", data_dir) print([cg.p for cg in new_dfm_model]) print([cg.p for cg in original_dfm_model]) # cg = CGComponent(0.5, 0, 0, 0.5) model = Model(stokes="I") model.add_components(*new_dfm_model) noise = uvdata_template.noise(use_V=True) params = list() for i in range(30): uvdata_template.substitute([model]) # uvdata_template.uvdata = uvdata_template.uvdata*corrections
# comps = import_difmap_model(mdl_fname, data_dir) # uvdata.uvplot(style='a&p') # uvdata.substitute([model]) # uvdata.uvplot(style='a&p', sym='.r') # # Radplot residuals # uvdata_ = create_uvdata_from_fits_file(os.path.join(data_dir, uv_fname_cc)) # res_uvdata = uvdata_ - uvdata # res_uvdata.uvplot(style='re&im') booted_uv_paths = glob.glob(os.path.join(data_dir, outname + "*")) # Modelfit bootstrapped uvdata for booted_uv_path in booted_uv_paths: path, booted_uv_file = os.path.split(booted_uv_path) i = booted_uv_file.split('_')[-1].split('.')[0] modelfit_difmap(booted_uv_file, mdl_fname, mdl_fname + '_' + i, path=path, mdl_path=data_dir, out_path=data_dir) # Load models and plot params = list() booted_mdl_paths = glob.glob(os.path.join(data_dir, mdl_fname + "_*")) for booted_mdl_path in booted_mdl_paths: path, booted_mdl_file = os.path.split(booted_mdl_path) comps = import_difmap_model(booted_mdl_file, path) comps_params = list() for comp in comps: if isinstance(comp, CGComponent): comps_params.append(np.array(list(comp.p) + [0., 0.])) elif isinstance(comp, EGComponent) and not isinstance(comp, CGComponent): comps_params.append(comp.p) elif isinstance(comp, DeltaComponent):
y, z = np.meshgrid(np.arange(imsize[0]), np.arange(imsize[1])) y = y - imsize[0] / 2. + 0.5 z = z - imsize[0] / 2. + 0.5 y_mas = y * mas_in_pix z_mas = z * mas_in_pix y_rad = mas_to_rad * y_mas z_rad = mas_to_rad * z_mas icomp = ImageComponent(image_g, y_rad[0, :], z_rad[:, 0]) noise = uvdata.noise(use_V=True) for key, value in noise.items(): noise[key] = 0.1 * value model = Model(stokes='I') model.add_component(icomp) # jet_comp = CGComponent(0.5, 1., 0., 0.3) # model.add_component(jet_comp) uvdata.substitute([model]) uvdata.noise_add(noise) uvdata.save('/home/ilya/github/bck/jetshow/uvf/test.fits', rewrite=True) modelfit_difmap('test.fits', 'initial_cg.mdl', 'out_test.mdl', niter=300, path='/home/ilya/github/bck/jetshow/uvf', mdl_path='/home/ilya/github/bck/jetshow', out_path='/home/ilya/github/bck/jetshow/uvf')