def makedata(testpath, tint):
""" This will make the input data for the test case. The data will have cases
where there will be enhancements in Ne, Ti and Te in one location. Each
case will have 3 integration periods. The first 3 integration periods will
be the default set of parameters Ne=Ne=1e11 and Te=Ti=2000.
Inputs
testpath - Directory that will hold the data.
tint - The integration time in seconds.
"""
testpath = Path(testpath).expanduser()
finalpath = testpath.joinpath('Origparams')
if not finalpath.is_dir():
finalpath.mkdir()
data = sp.array([[1e11, 1100.], [1e11, 2100.]])
z = (50. + sp.arange(50) * 10.)
nz = len(z)
params = sp.tile(data[sp.newaxis, sp.newaxis], (nz, 1, 1, 1))
epnt = range(20, 22)
p2 = sp.tile(params, (1, 4, 1, 1))
#enhancement in Ne
p2[epnt, 1, :, 0] = 5e11
#enhancement in Ti
p2[epnt, 2, 0, 1] = 2200.
#enhancement in Te
p2[epnt, 3, 1, 1] = 4200.
coords = sp.column_stack((sp.ones(nz), sp.ones(nz), z))
species = ['O+', 'e-']
times = sp.array([[0, 1e3]])
times2 = sp.column_stack((sp.arange(0, 4), sp.arange(1, 5))) * 3 * tint
vel = sp.zeros((nz, 1, 3))
vel2 = sp.zeros((nz, 4, 3))
Icontstart = IonoContainer(coordlist=coords,
paramlist=params,
times=times,
sensor_loc=sp.zeros(3),
ver=0,
coordvecs=['x', 'y', 'z'],
paramnames=None,
species=species,
velocity=vel)
Icont1 = IonoContainer(coordlist=coords,
paramlist=p2,
times=times2,
sensor_loc=sp.zeros(3),
ver=0,
coordvecs=['x', 'y', 'z'],
paramnames=None,
species=species,
velocity=vel2)
finalfile = finalpath.joinpath('0 stats.h5')
Icont1.saveh5(str(finalfile))
Icontstart.saveh5(str(testpath.joinpath('startfile.h5')))
def makedata(testpath):
"""
This will make the input data for the test case. The data will have the
default set of parameters Ne=Ne=1e11 and Te=Ti=2000.
Inputs
testpath - Directory that will hold the data.
"""
finalpath = testpath.joinpath('Origparams')
if not finalpath.exists():
finalpath.mkdir()
data = SIMVALUES
z = sp.linspace(50., 1e3, 50)
nz = len(z)
params = sp.tile(data[sp.newaxis, sp.newaxis, :, :], (nz, 1, 1, 1))
coords = sp.column_stack((sp.ones(nz), sp.ones(nz), z))
species = ['O+', 'e-']
times = sp.array([[0, 1e9]])
vel = sp.zeros((nz, 1, 3))
Icont1 = IonoContainer(coordlist=coords,
paramlist=params,
times=times,
sensor_loc=sp.zeros(3),
ver=0,
coordvecs=['x', 'y', 'z'],
paramnames=None,
species=species,
velocity=vel)
finalfile = finalpath.joinpath('0 stats.h5')
Icont1.saveh5(str(finalfile))
# set start temp to 1000 K.
Icont1.Param_List[:, :, :, 1] = 1e3
Icont1.saveh5(str(testpath.joinpath('startfile.h5')))
def makeinputh5(Iono,basedir):
"""This will make a h5 file for the IonoContainer that can be used as starting
points for the fitter. The ionocontainer taken will be average over the x and y dimensions
of space to make an average value of the parameters for each altitude.
Inputs
Iono - An instance of the Ionocontainer class that will be averaged over so it can
be used for fitter starting points.
basdir - A string that holds the directory that the file will be saved to.
"""
# Get the parameters from the original data
Param_List = Iono.Param_List
dataloc = Iono.Cart_Coords
times = Iono.Time_Vector
velocity = Iono.Velocity
zlist,idx = sp.unique(dataloc[:,2],return_inverse=True)
siz = list(Param_List.shape[1:])
vsiz = list(velocity.shape[1:])
datalocsave = sp.column_stack((sp.zeros_like(zlist),sp.zeros_like(zlist),zlist))
outdata = sp.zeros([len(zlist)]+siz)
outvel = sp.zeros([len(zlist)]+vsiz)
# Do the averaging across space
for izn,iz in enumerate(zlist):
arr = sp.argwhere(idx==izn)
outdata[izn]=sp.mean(Param_List[arr],axis=0)
outvel[izn]=sp.mean(velocity[arr],axis=0)
Ionoout = IonoContainer(datalocsave,outdata,times,Iono.Sensor_loc,ver=0,
paramnames=Iono.Param_Names, species=Iono.Species,velocity=outvel)
Ionoout.saveh5(str(basedir/'startdata.h5'))
def makeinputh5(Iono, basedir):
basedir = Path(basedir).expanduser()
Param_List = Iono.Param_List
dataloc = Iono.Cart_Coords
times = Iono.Time_Vector
velocity = Iono.Velocity
zlist, idx = sp.unique(dataloc[:, 2], return_inverse=True)
siz = list(Param_List.shape[1:])
vsiz = list(velocity.shape[1:])
datalocsave = sp.column_stack(
(sp.zeros_like(zlist), sp.zeros_like(zlist), zlist))
outdata = sp.zeros([len(zlist)] + siz)
outvel = sp.zeros([len(zlist)] + vsiz)
for izn, iz in enumerate(zlist):
arr = sp.argwhere(idx == izn)
outdata[izn] = sp.mean(Param_List[arr], axis=0)
outvel[izn] = sp.mean(velocity[arr], axis=0)
Ionoout = IonoContainer(datalocsave,
outdata,
times,
Iono.Sensor_loc,
ver=0,
paramnames=Iono.Param_Names,
species=Iono.Species,
velocity=outvel)
ofn = basedir / 'startdata.h5'
print('writing {}'.format(ofn))
Ionoout.saveh5(str(ofn))
def pyglowinput(
latlonalt=[65.1367, -147.4472, 250.00],
dn_list=[datetime(2015, 3, 21, 8, 00),
datetime(2015, 3, 21, 20, 00)],
z=None):
if z is None:
z = sp.linspace(50., 1000., 200)
dn_diff = sp.diff(dn_list)
dn_diff_sec = dn_diff[-1].seconds
timelist = sp.array([calendar.timegm(i.timetuple()) for i in dn_list])
time_arr = sp.column_stack((timelist, sp.roll(timelist, -1)))
time_arr[-1, -1] = time_arr[-1, 0] + dn_diff_sec
v = []
coords = sp.column_stack((sp.zeros((len(z), 2), dtype=z.dtype), z))
all_spec = ['O+', 'NO+', 'O2+', 'H+', 'HE+']
Param_List = sp.zeros((len(z), len(dn_list), len(all_spec), 2))
for idn, dn in enumerate(dn_list):
for iz, zcur in enumerate(z):
latlonalt[2] = zcur
pt = Point(dn, *latlonalt)
pt.run_igrf()
pt.run_msis()
pt.run_iri()
# so the zonal pt.u and meriodinal winds pt.v will coorispond to x and y even though they are
# supposed to be east west and north south. Pyglow does not seem to have
# vertical winds.
v.append([pt.u, pt.v, 0])
for is1, ispec in enumerate(all_spec):
Param_List[iz, idn, is1, 0] = pt.ni[ispec] * 1e6
Param_List[iz, idn, :, 1] = pt.Ti
Param_List[iz, idn, -1, 0] = pt.ne * 1e6
Param_List[iz, idn, -1, 1] = pt.Te
Param_sum = Param_List[:, :, :, 0].sum(0).sum(0)
spec_keep = Param_sum > 0.
species = sp.array(all_spec)[spec_keep[:-1]].tolist()
species.append('e-')
Param_List[:, :] = Param_List[:, :, spec_keep]
Iono_out = IonoContainer(coords,
Param_List,
times=time_arr,
species=species)
return Iono_out
def run_sim(args_commd):
fitoutput = fitterone.fitdata(specfuncs.ISRSfitfunction,
fitterone.simparams['startfile'], fittimes=fitlist,
printlines=printlines)
(fitteddata, fittederror, funcevals, fittedcov) = fitoutput
fittederronly = sp.sqrt(fittederror)
paramnames = []
species = fitterone.simparams['species']
# Seperate Ti and put it in as an element of the ionocontainer.
Ti = fitteddata[:, :, 1]
nTi = fittederronly[:, :, 1]
nTiTe = fittedcov[:, :, 0, 1]
nTiNe = fittedcov[:, :, 0, 2]
nTiVi = fittedcov[:, :, 0, 3]
nTeNe = fittedcov[:, :, 1, 2]
nTeVi = fittedcov[:, :, 1, 3]
nNeVi = fittedcov[:, :, 2, 3]
cov_list = [nTiTe[:, :, sp.newaxis], nTiNe[:, :, sp.newaxis],
nTiVi[:, :, sp.newaxis], nTeNe[:, :, sp.newaxis],
nTeVi[:, :, sp.newaxis], nNeVi[:, :, sp.newaxis]]
cov_list_names = ['nTiTe', 'nTiNe', 'nTiVi', 'nTeNe', 'nTeVi','nNeVi']
paramlist = sp.concatenate([fitteddata, Ti[:, :, sp.newaxis], fittederronly,
nTi[:, :, sp.newaxis], funcevals[:, :, sp.newaxis]]
+ cov_list, axis=2)
ionoout = IonoContainer(Ionoin.Cart_Coords, paramlist.real, timevec, ver=newver,
coordvecs=Ionoin.Coord_Vecs, paramnames=paranamsf,
species=species)
ionoout.saveh5(str(outfile))
def runfitter(paramdict, SNR, n_pulses, n_runs, Niratio, x_0=SVALS):
"""
paramdict
"""
data = SIMVALUES
z = sp.linspace(50., 1e3, 50)
nz = len(z)
params = sp.tile(data[sp.newaxis, sp.newaxis, :, :], (nz, 1, 1, 1))
coords = sp.column_stack((sp.ones(nz), sp.ones(nz), z))
species = ['O+', 'e-']
times = sp.array([[0, 1e9]])
vel = sp.zeros((nz, 1, 3))
(sensdict, simparams) = readconfigfile(defcon)
species = paramdict['species']
nspecies = len(species)
ni = nspecies-1
Icont1 = IonoContainer(coordlist=coords, paramlist=params, times=times,
sensor_loc=sp.zeros(3), ver=0, coordvecs=['x', 'y', 'z'],
paramnames=None, species=species, velocity=vel)
omeg, outspecs = specfuncs.ISRSspecmake(Icont1, sensdict, int(simparams['numpoints']))
tau, acf = spect2acf(omeg, outspecs)
t_log = sp.logical_and(tau<simparams['Pulselength'],tau>=0)
plen = t_log.sum()
amb_dict = simparams['amb_dict']
amb_mat_flat = sp.zeros_like(amb_dict['WttMatrix'])
eyemat = sp.eye(plen)
amb_mat_flat[:plen, t_log] = eyemat
fitmode = simparams['fitmode']
simparams['amb_dict']['WttMatrix'] = amb_mat_flat
Nloc, Nt = acf.shape[:2]
# output Files
fittedarray = sp.zeros((Nloc, Nt, nparams+1))*sp.nan
fittederror = sp.zeros((Nloc, Nt, nparams+1))*sp.nan
fittedcov = sp.zeros((Nloc, Nt, 4, 4))*sp.nan
funcevals = sp.zeros((Nloc, Nt))
for iloc, ilocvec in acf:
for itn, iacf in ilocvec:
curlag = sp.dot(amb_mat_flat, iacf)
std_lag = sp.absolute(curlag)(1.+1./SNR)/sp.sqrt(n_pulses)
covar_lag = sp.diag(sp.power(std_lag,2.))
curlag = curlag + std_lag*sp.random.randn(curlag.shape)
d_func = (curlag, sensdict, simparams, Niratio)
# Only fit Ti, Te, Ne and Vi
# change variables because of new fit mode
# Perform the fitting
optresults = scipy.optimize.least_squares(fun=specfuncs.ISRSfitfunction, x0=x_0,
method='lm', verbose=0, args=d_func)
x_res = optresults.x.real
# Derive data for the ions using output from the fitter and ion
# species ratios which are assumed to be given.
ionstuff = sp.zeros(ni*2-1)
ionstuff[:2*ni:2] = x_res[1]*Niratio
ionstuff[1:2*ni-1:2] = x_res[0]
# change variables because of new fit mode
if fitmode == 1:
x_res[2] = x_res[2]*x_res[0]
fittedarray[iloc, itn] = sp.append(ionstuff,
sp.append(x_res, Ne_start[iloc, itime]))
funcevals[iloc, itn] = optresults.nfev
# fittedarray[iloc,itime] = sp.append(optresults.x,Ne_start[iloc,itime])
resid = optresults.cost
jac = optresults.jac
# combine the rows because of the complex conjugates
jacc = jac[0::2]+jac[1::2]
try:
# Derive covariances for the ions using output from the fitter and ion species ratios which are assumed to be given.
#covf = sp.linalg.inv(sp.dot(jac.transpose(),jac))*resid/dof
covf = sp.linalg.inv(sp.dot(sp.dot(jacc.transpose(),
sp.linalg.inv(covar_lag)), jacc))
# change variables because of new fit mode
if fitmode == 1:
# is this right?
covf[2] = covf[2]*x_res[0]
covf[:,2] = covf[:,2]*x_res[0]
vars_vec = sp.diag(covf).real
ionstuff = sp.zeros(ni*2-1)
ionstuff[:2*ni:2] = vars_vec[1]*Niratio
ionstuff[1:2*ni-1:2] = vars_vec[0]
vars_vec = sp.append(ionstuff, vars_vec)
fittedcov[iloc, itn] = covf
except:#sp.linalg.LinAlgError('singular matrix'):
vars_vec = sp.ones(nparams)*float('nan')
# if len(vars_vec)<fittederror.shape[-1]-1:
# pdb.set_trace()
fittederror[iloc, itn, :-1] = vars_vec
return(fittedarray, fittederror, funcevals, fittedcov)
def lagdict2ionocont(DataLags, NoiseLags, sensdict, simparams, time_vec):
"""This function will take the data and noise lags and create an instance of the
Ionocontanier class. This function will also apply the summation rule to the lags.
Inputs
DataLags - A dictionary """
# Pull in Location Data
angles = simparams['angles']
ang_data = sp.array([[iout[0], iout[1]] for iout in angles])
rng_vec = simparams['Rangegates']
n_samps = len(rng_vec)
# pull in other data
pulse = simparams['Pulse']
p_samps = len(pulse)
pulsewidth = p_samps * sensdict['t_s']
txpower = sensdict['Pt']
if sensdict['Name'].lower() in ['risr', 'pfisr', 'risr-n']:
Ksysvec = sensdict['Ksys']
else:
beamlistlist = sp.array(simparams['outangles']).astype(int)
inplist = sp.array([i[0] for i in beamlistlist])
Ksysvec = sensdict['Ksys'][inplist]
ang_data_temp = ang_data.copy()
ang_data = sp.array(
[ang_data_temp[i].mean(axis=0) for i in beamlistlist])
sumrule = simparams['SUMRULE']
rng_vec2 = simparams['Rangegatesfinal']
Nrng2 = len(rng_vec2)
minrg = p_samps - 1 + sumrule[0].min()
maxrg = Nrng2 + minrg
# Copy the lags
lagsData = DataLags['ACF'].copy()
# Set up the constants for the lags so they are now
# in terms of density fluxtuations.
angtile = sp.tile(ang_data, (Nrng2, 1))
rng_rep = sp.repeat(rng_vec2, ang_data.shape[0], axis=0)
coordlist = sp.zeros((len(rng_rep), 3))
[coordlist[:, 0], coordlist[:, 1:]] = [rng_rep, angtile]
(Nt, Nbeams, Nrng, Nlags) = lagsData.shape
# make a range average to equalize out the conntributions from each gate
plen2 = int(sp.floor(float(p_samps - 1) / 2))
samps = sp.arange(0, p_samps, dtype=int)
rng_ave = sp.zeros((Nrng, p_samps))
for isamp in range(plen2, Nrng + plen2):
for ilag in range(p_samps):
toplag = int(sp.floor(float(ilag) / 2))
blag = int(sp.ceil(float(ilag) / 2))
if toplag == 0:
sampsred = samps[blag:]
else:
sampsred = samps[blag:-toplag]
cursamps = isamp - sampsred
keepsamps = sp.logical_and(cursamps >= 0, cursamps < Nrng)
cursamps = cursamps[keepsamps]
rng_samps = rng_vec[cursamps]**2 * 1e6
keepsamps2 = rng_samps > 0
if keepsamps2.sum() == 0:
continue
rng_samps = rng_samps[keepsamps2]
rng_ave[isamp - plen2, ilag] = 1. / (sp.mean(1. / (rng_samps)))
rng_ave_temp = rng_ave.copy()
if simparams['Pulsetype'].lower() is 'barker':
rng_ave_temp = rng_ave[:, 0][:, sp.newaxis]
# rng_ave = rng_ave[int(sp.floor(plen2)):-int(sp.ceil(plen2))]
# rng_ave = rng_ave[minrg:maxrg]
rng3d = sp.tile(rng_ave_temp[sp.newaxis, sp.newaxis, :, :],
(Nt, Nbeams, 1, 1))
ksys3d = sp.tile(Ksysvec[sp.newaxis, :, sp.newaxis, sp.newaxis],
(Nt, 1, Nrng, Nlags))
# rng3d = sp.tile(rng_ave[:, sp.newaxis, sp.newaxis, sp.newaxis], (1, Nlags, Nt, Nbeams))
# ksys3d = sp.tile(Ksysvec[sp.newaxis, sp.newaxis, sp.newaxis, :], (Nrng2, Nlags, Nt, 1))
radar2acfmult = rng3d / (pulsewidth * txpower * ksys3d)
pulses = sp.tile(DataLags['Pulses'][:, :, sp.newaxis, sp.newaxis],
(1, 1, Nrng, Nlags))
time_vec = time_vec[:Nt]
# Divid lags by number of pulses
lagsData = lagsData / pulses
# Set up the noise lags and divid out the noise.
lagsNoise = NoiseLags['ACF'].copy()
lagsNoise = sp.mean(lagsNoise, axis=2)
pulsesnoise = sp.tile(NoiseLags['Pulses'][:, :, sp.newaxis], (1, 1, Nlags))
lagsNoise = lagsNoise / pulsesnoise
lagsNoise = sp.tile(lagsNoise[:, :, sp.newaxis, :], (1, 1, Nrng, 1))
# multiply the data and the sigma by inverse of the scaling from the radar
lagsData = lagsData * radar2acfmult
lagsNoise = lagsNoise * radar2acfmult
# Apply summation rule
# lags transposed from (time,beams,range,lag)to (range,lag,time,beams)
lagsData = sp.transpose(lagsData, axes=(2, 3, 0, 1))
lagsNoise = sp.transpose(lagsNoise, axes=(2, 3, 0, 1))
lagsDatasum = sp.zeros((Nrng2, Nlags, Nt, Nbeams), dtype=lagsData.dtype)
lagsNoisesum = sp.zeros((Nrng2, Nlags, Nt, Nbeams), dtype=lagsNoise.dtype)
for irngnew, irng in enumerate(sp.arange(minrg, maxrg)):
for ilag in range(Nlags):
lsumtemp = lagsData[irng + sumrule[0, ilag]:irng +
sumrule[1, ilag] + 1, ilag].sum(axis=0)
lagsDatasum[irngnew, ilag] = lsumtemp
nsumtemp = lagsNoise[irng + sumrule[0, ilag]:irng +
sumrule[1, ilag] + 1, ilag].sum(axis=0)
lagsNoisesum[irngnew, ilag] = nsumtemp
# subtract out noise lags
lagsDatasum = lagsDatasum - lagsNoisesum
# Put everything in a parameter list
Paramdata = sp.zeros((Nbeams * Nrng2, Nt, Nlags), dtype=lagsData.dtype)
# Put everything in a parameter list
# transpose from (range,lag,time,beams) to (beams,range,time,lag)
# lagsDatasum = lagsDatasum*radar2acfmult
# lagsNoisesum = lagsNoisesum*radar2acfmult
lagsDatasum = sp.transpose(lagsDatasum, axes=(3, 0, 2, 1))
lagsNoisesum = sp.transpose(lagsNoisesum, axes=(3, 0, 2, 1))
# multiply the data and the sigma by inverse of the scaling from the radar
# lagsDatasum = lagsDatasum*radar2acfmult
# lagsNoisesum = lagsNoisesum*radar2acfmult
# Calculate a variance using equation 2 from Hysell's 2008 paper. Done use full covariance matrix because assuming nearly diagonal.
# Get the covariance matrix
pulses_s = sp.transpose(pulses, axes=(1, 2, 0, 3))[:, :Nrng2]
Cttout = makeCovmat(lagsDatasum, lagsNoisesum, pulses_s, Nlags)
Paramdatasig = sp.zeros((Nbeams * Nrng2, Nt, Nlags, Nlags),
dtype=Cttout.dtype)
curloc = 0
for irng in range(Nrng2):
for ibeam in range(Nbeams):
Paramdata[curloc] = lagsDatasum[ibeam, irng].copy()
Paramdatasig[curloc] = Cttout[ibeam, irng].copy()
curloc += 1
ionodata = IonoContainer(coordlist,
Paramdata,
times=time_vec,
ver=1,
paramnames=sp.arange(Nlags) * sensdict['t_s'])
ionosigs = IonoContainer(
coordlist,
Paramdatasig,
times=time_vec,
ver=1,
paramnames=sp.arange(Nlags**2).reshape(Nlags, Nlags) * sensdict['t_s'])
return (ionodata, ionosigs)
def fitdata(basedir,configfile,optinputs):
""" This function will run the fitter on the estimated ACFs saved in h5 files.
Inputs:
basedir: A string for the directory that will hold all of the data for the simulation.
configfile: The configuration file for the simulation.
optinputs:A string that helps determine the what type of acfs will be fitted.
"""
# determine the input folders which can be ACFs from the full simulation
dirdict = {'fitting':('ACF', 'Fitted'), 'fittingmat':('ACFMat', 'FittedMat'),
'fittinginv':('ACFInv', 'FittedInv'), 'fittingmatinv':('ACFMatInv', 'FittedMatInv')}
dirio = dirdict[optinputs[0]]
inputdir = basedir/dirio[0]
outputdir = basedir/dirio[1]
fitlist = optinputs[1]
if len(optinputs) > 2:
exstr = optinputs[2]
printlines = optinputs[3]
else:
exstr = ''
dirlist = [str(i) for i in inputdir.glob('*lags{0}.h5'.format(exstr))]
dirlistsig = [str(i) for i in inputdir.glob('*sigs{0}.h5'.format(exstr))]
Ionoin = IonoContainer.readh5(dirlist[0])
if len(dirlistsig) == 0:
Ionoinsig = None
else:
Ionoinsig = IonoContainer.readh5(dirlistsig[0])
fitterone = Fitterionoconainer(Ionoin, Ionoinsig, configfile)
fitoutput = fitterone.fitdata(specfuncs.ISRSfitfunction,
fitterone.simparams['startfile'], fittimes=fitlist,
printlines=printlines)
#ipdb.set_trace()
(fitteddata, fittederror, funcevals, fittedcov) = fitoutput
if fitterone.simparams['Pulsetype'].lower() == 'barker':
paramlist = fitteddata
species = fitterone.simparams['species']
paramnames = ['Ne']
if not fittederror is None:
fittederronly = sp.sqrt(fittederror)
paramlist = sp.concatenate([fitteddata, fittederronly], axis=2)
paramnamese = ['n'+ip for ip in paramnames]
paranamsf = sp.array(paramnames+paramnamese)
else:
paranamsf = sp.array(paramnames)
else:
fittederronly = sp.sqrt(fittederror)
paramnames = []
species = fitterone.simparams['species']
# Seperate Ti and put it in as an element of the ionocontainer.
Ti = fitteddata[:, :, 1]
nTi = fittederronly[:, :, 1]
nTiTe = fittedcov[:, :, 0, 1]
nTiNe = fittedcov[:, :, 0, 2]
nTiVi = fittedcov[:, :, 0, 3]
nTeNe = fittedcov[:, :, 1, 2]
nTeVi = fittedcov[:, :, 1, 3]
nNeVi = fittedcov[:, :, 2, 3]
cov_list = [nTiTe[:, :, sp.newaxis], nTiNe[:, :, sp.newaxis],
nTiVi[:, :, sp.newaxis], nTeNe[:, :, sp.newaxis],
nTeVi[:, :, sp.newaxis], nNeVi[:, :, sp.newaxis]]
cov_list_names = ['nTiTe', 'nTiNe', 'nTiVi', 'nTeNe', 'nTeVi','nNeVi']
paramlist = sp.concatenate([fitteddata, Ti[:, :, sp.newaxis], fittederronly,
nTi[:, :, sp.newaxis], funcevals[:, :, sp.newaxis]]
+ cov_list, axis=2)
for isp in species[:-1]:
paramnames.append('Ni_'+isp)
paramnames.append('Ti_'+isp)
paramnames = paramnames+['Ne', 'Te', 'Vi', 'Nepow', 'Ti']
paramnamese = ['n'+ip for ip in paramnames]
paranamsf = sp.array(paramnames+paramnamese+['FuncEvals']+cov_list_names)
if fitlist is None:
timevec = Ionoin.Time_Vector
else:
if len(fitlist) == 0:
timevec = Ionoin.Time_Vector
else:
timevec = Ionoin.Time_Vector[fitlist]
# This requires
if set(Ionoin.Coord_Vecs) == {'x', 'y', 'z'}:
newver = 0
ionoout = IonoContainer(Ionoin.Cart_Coords, paramlist.real, timevec, ver=newver,
coordvecs=Ionoin.Coord_Vecs, paramnames=paranamsf,
species=species)
elif set(Ionoin.Coord_Vecs) == {'r', 'theta', 'phi'}:
newver = 1
ionoout = IonoContainer(Ionoin.Sphere_Coords, paramlist.real, timevec, ver=newver,
coordvecs=Ionoin.Coord_Vecs, paramnames=paranamsf,
species=species)
outfile = outputdir.joinpath('fitteddata{0}.h5'.format(exstr))
ionoout.saveh5(str(outfile))
def lagdict2ionocont(DataLags, NoiseLags, sensdict, simparams, time_vec):
"""This function will take the data and noise lags and create an instance of the
Ionocontanier class. This function will also apply the summation rule to the lags.
Inputs
DataLags - A dictionary """
# Pull in Location Data
angles = simparams['angles']
ang_data = sp.array([[iout[0], iout[1]] for iout in angles])
rng_vec = simparams['Rangegates']
# pull in other data
pulsewidth = len(simparams['Pulse']) * sensdict['t_s']
txpower = sensdict['Pt']
if sensdict['Name'].lower() in ['risr', 'pfisr', 'risr-n']:
Ksysvec = sensdict['Ksys']
else:
beamlistlist = sp.array(simparams['outangles']).astype(int)
inplist = sp.array([i[0] for i in beamlistlist])
Ksysvec = sensdict['Ksys'][inplist]
ang_data_temp = ang_data.copy()
ang_data = sp.array(
[ang_data_temp[i].mean(axis=0) for i in beamlistlist])
sumrule = simparams['SUMRULE']
rng_vec2 = simparams['Rangegatesfinal']
minrg = -sumrule[0].min()
maxrg = len(rng_vec) - sumrule[1].max()
Nrng2 = len(rng_vec2)
# Copy the lags
lagsData = DataLags['ACF'].copy()
# Set up the constants for the lags so they are now
# in terms of density fluxtuations.
angtile = sp.tile(ang_data, (Nrng2, 1))
rng_rep = sp.repeat(rng_vec2, ang_data.shape[0], axis=0)
coordlist = sp.zeros((len(rng_rep), 3))
[coordlist[:, 0], coordlist[:, 1:]] = [rng_rep, angtile]
(Nt, Nbeams, Nrng, Nlags) = lagsData.shape
rng3d = sp.tile(rng_vec[sp.newaxis, sp.newaxis, :, sp.newaxis],
(Nt, Nbeams, 1, Nlags)) * 1e3
ksys3d = sp.tile(Ksysvec[sp.newaxis, :, sp.newaxis, sp.newaxis],
(Nt, 1, Nrng, Nlags))
radar2acfmult = rng3d * rng3d / (pulsewidth * txpower * ksys3d)
pulses = sp.tile(DataLags['Pulses'][:, :, sp.newaxis, sp.newaxis],
(1, 1, Nrng, Nlags))
time_vec = time_vec[:Nt]
# Divid lags by number of pulses
lagsData = lagsData / pulses
# Set up the noise lags and divid out the noise.
lagsNoise = NoiseLags['ACF'].copy()
lagsNoise = sp.mean(lagsNoise, axis=2)
pulsesnoise = sp.tile(NoiseLags['Pulses'][:, :, sp.newaxis], (1, 1, Nlags))
lagsNoise = lagsNoise / pulsesnoise
lagsNoise = sp.tile(lagsNoise[:, :, sp.newaxis, :], (1, 1, Nrng, 1))
# subtract out noise lags
lagsData = lagsData - lagsNoise
# Calculate a variance using equation 2 from Hysell's 2008 paper. Done use full covariance matrix because assuming nearly diagonal.
# multiply the data and the sigma by inverse of the scaling from the radar
lagsData = lagsData * radar2acfmult
lagsNoise = lagsNoise * radar2acfmult
# Apply summation rule
# lags transposed from (time,beams,range,lag)to (range,lag,time,beams)
lagsData = sp.transpose(lagsData, axes=(2, 3, 0, 1))
lagsNoise = sp.transpose(lagsNoise, axes=(2, 3, 0, 1))
lagsDatasum = sp.zeros((Nrng2, Nlags, Nt, Nbeams), dtype=lagsData.dtype)
lagsNoisesum = sp.zeros((Nrng2, Nlags, Nt, Nbeams), dtype=lagsNoise.dtype)
for irngnew, irng in enumerate(sp.arange(minrg, maxrg)):
for ilag in range(Nlags):
lagsDatasum[irngnew,
ilag] = lagsData[irng + sumrule[0, ilag]:irng +
sumrule[1, ilag] + 1,
ilag].sum(axis=0)
lagsNoisesum[irngnew,
ilag] = lagsNoise[irng + sumrule[0, ilag]:irng +
sumrule[1, ilag] + 1,
ilag].sum(axis=0)
# Put everything in a parameter list
Paramdata = sp.zeros((Nbeams * Nrng2, Nt, Nlags), dtype=lagsData.dtype)
# Put everything in a parameter list
# transpose from (range,lag,time,beams) to (beams,range,time,lag)
lagsDatasum = sp.transpose(lagsDatasum, axes=(3, 0, 2, 1))
lagsNoisesum = sp.transpose(lagsNoisesum, axes=(3, 0, 2, 1))
# Get the covariance matrix
pulses_s = sp.transpose(pulses, axes=(1, 2, 0, 3))[:, :Nrng2]
Cttout = makeCovmat(lagsDatasum, lagsNoisesum, pulses_s, Nlags)
Paramdatasig = sp.zeros((Nbeams * Nrng2, Nt, Nlags, Nlags),
dtype=Cttout.dtype)
curloc = 0
for irng in range(Nrng2):
for ibeam in range(Nbeams):
Paramdata[curloc] = lagsDatasum[ibeam, irng].copy()
Paramdatasig[curloc] = Cttout[ibeam, irng].copy()
curloc += 1
ionodata = IonoContainer(coordlist,
Paramdata,
times=time_vec,
ver=1,
paramnames=sp.arange(Nlags) * sensdict['t_s'])
ionosigs = IonoContainer(
coordlist,
Paramdatasig,
times=time_vec,
ver=1,
paramnames=sp.arange(Nlags * Nlags).reshape(Nlags, Nlags) *
sensdict['t_s'])
return (ionodata, ionosigs)
def mult_iono(self, ionoin_list):
"""
This will apply the forward model to the contents of an ionocontainer object. It is assuming that
this is an ionocontainer holding the spectra.
"""
ntout = self.Time_Out.shape[0]
nlout = self.Cart_Coords_Out.shape[0]
blist_in, blist_out = self.blocklocs
amb_dict = self.simparams['amb_dict']
ambmat = amb_dict['WttMatrix']
overlaps = self.overlaps
t_s = self.sensdict['t_s']
if isinstance(ionoin_list, list) or isinstance(ionoin_list, str):
Iono_in = makeionocombined(ionoin_list)
else:
Iono_in = ionoin_list
ionocart = Iono_in.Cart_Coords
if self.simparams['numpoints'] == Iono_in.Param_List.shape[-1]:
tau, acf = spect2acf(Iono_in.Param_Names, Iono_in.Param_List)
np = ambmat.shape[0]
else:
acf = Iono_in.Param_List
np = acf.shape[-1]
np_in = acf.shape[-1]
tau_out = t_s * np.arange(np)
outdata = np.zeros((nlout, ntout, np), dtype=acf.dtype)
assert np.allclose(
ionocart,
self.Cart_Coords_In), "Spatial Coordinates need to be the same"
for it_out in range(ntout):
overlists = overlaps[it_out]
irows = blist_out[it_out]
curintimes = [i[0] for i in overlists]
curintratio = [i[1] for i in overlists]
if self.mattype.lower() == 'sim':
curintimes = [curintimes[0]]
curintratio = [1.]
cur_outmat = self.RSTMat[irows[0]:irows[1], :]
icols = blist_in[it_out]
cur_mat = cur_outmat[:, icols[0]:icols[1]]
for i_it, it_in in enumerate(curintimes):
tempdata = np.zeros((np_in, nlout), dtype=acf.dtype)
for iparam in range(np_in):
tempdata[iparam] = cur_mat.dot(acf[:, it_in, iparam])
if self.simparams['numpoints'] == Iono_in.Param_List.shape[-1]:
tempdata = np.dot(ambmat, tempdata)
outdata[:, it_out] = np.transpose(
tempdata) * curintratio[i_it] + outdata[:, it_out]
outiono = IonoContainer(self.Sphere_Coords_Out,
outdata,
times=self.Time_Out,
sensor_loc=Iono_in.Sensor_loc,
ver=1,
coordvecs=['r', 'theta', 'phi'],
paramnames=tau_out)
return outiono
