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')
