dmap = doppler.Map.rfits(doppler.afits(args.map))
ddat = doppler.Data.rfits(doppler.afits(args.data))
# make copies
cmap = copy.deepcopy(dmap)
cdat = copy.deepcopy(ddat)
for i in xrange(args.ntrial):
# fill map with random noise
for image in dmap.data:
image.data = np.asarray(
np.random.normal(size=image.data.shape),dtype=np.float32)
# enact opus
doppler.comdat(dmap, cdat)
# fill data with random noise
for spectra in ddat.data:
spectra.flux = np.asarray(
np.random.normal(size=spectra.flux.shape),dtype=np.float32)
# enact tropus
doppler.datcom(ddat, cmap)
# now compute quadratic forms
qform1 = 0.
dnorm1 = 0.
dnorm2 = 0.
for spectra1, spectra2 in zip(ddat.data, cdat.data):
qform1 += (spectra1.flux*spectra2.flux).sum()
osfacs = []
for ni, image in enumerate(dmap.data):
for ns in xrange(len(image.scale)):
sindices.append((ni,ns))
osfacs.append(image.scale[ns])
image.scale[ns] = 0.
# compute a set of data vectors with each scale factor
# set to 1 with all others set = 0, one by one
dvecs = []
for ni, ns in sindices:
dmap.data[ni].scale[ns] = 1.0
# compute data equivelent to data
dvec = copy.deepcopy(data)
doppler.comdat(dmap, dvec)
dvecs.append(retarr(dvec)[0])
dmap.data[ni].scale[ns] = 0.0
# compile least-squares matrix & right-hand vector
nvec = len(dvecs)
A = np.empty((nvec,nvec))
b = np.empty((nvec))
for j in xrange(nvec):
b[j] = (wgt[ok]*dvecs[j]*flux[ok]).sum()
for i in xrange(j+1):
A[j][i] = (wgt[ok]*dvecs[j]*dvecs[i]).sum()
A[i][j] = A[j][i]
nsfacs = linalg.solve(A,b)
parser.add_argument('-n', dest='noise', action='store_true',
help='add noise according to uncertainty array in template')
# OK, done with arguments.
args = parser.parse_args()
# load map and data
dmap = doppler.Map.rfits(doppler.afits(args.map))
dtemp = doppler.Data.rfits(doppler.afits(args.dtemp))
flux = dtemp.data[0].flux
ferr = dtemp.data[0].ferr
# compute data
dcopy = copy.deepcopy(dtemp)
doppler.comdat(dmap, dtemp)
# optionally add noise
if args.noise:
for spectra in dtemp.data:
spectra.flux = np.random.normal(spectra.flux, np.abs(spectra.ferr))
else:
chisq = 0.
ndata = 0
for cspec, dspec in zip(dtemp.data, dcopy.data):
ok = dspec.ferr > 0.
chisq += (((dspec.flux[ok]-cspec.flux[ok])/dspec.ferr[ok])**2).sum()
ndata += cspec.flux.size
print 'Chi**2 = ',chisq,', chi**2/N =',chisq/ndata,', N =',ndata
quad = 0.
wave = model.data[0].wave
gamma = model.data[0].gamma
scale = model.data[0].scale
grid = doppler.Grid(head,dat,tzero,period,quad,vgrid,fratio,wave,gamma,scale)
# computations
# first the frequency array
tbase = data.data[0].time.max() - data.data[0].time.min()
nfreq = int((fhigh-flow)*tbase/delta)
fs = np.linspace(flow,fhigh,nfreq)
# compute data without noise
doppler.comdat(model, data)
# space for the data with noise
buffer = []
nbuff = 0
for spectra in data.data:
buffer.append(np.empty((nmonte,
spectra.flux.shape[0],spectra.flux.shape[1])))
nbuff += buffer[-1].size
# nmonte realisations
for nd, spectra in enumerate(data.data):
for nm in xrange(nmonte):
buffer[nd][nm] = np.random.normal(spectra.flux, spectra.ferr)
# allocate space for results as we need to complete all
