def info(ctx, **kwargs):
vlog(ctx, 'Starting info')
pushChain(ctx, 'info', **kwargs)
data = ctx.obj['data']
if kwargs['allsets']:
onlyActive = False
else:
onlyActive = True
#end
for i, dat in data.iterator(kwargs['use'], enum=True, onlyActive=onlyActive):
if dat.getStatus():
color = 'green'
bold = True
else:
color = None
bold = False
#end
click.echo(click.style("Set {:s} ({:s}#{:d})".format(dat.getLabel(), dat.getTag(), i,),
fg=color, bold=bold))
if not kwargs['compact']:
click.echo(dat.info() + "\n")
#end
#end
vlog(ctx, 'Finishing info')
def recovery(ctx, **kwargs):
vlog(ctx, 'Starting recovery')
pushChain(ctx, 'recovery', **kwargs)
data = ctx.obj['data']
if kwargs['basistype'] is not None:
if kwargs['basistype'] == 'ms' or kwargs['basistype'] == 'ns':
basisType = 'serendipity'
elif kwargs['basistype'] == 'mo':
basisType = 'maximal-order'
else:
basisType = None
#end
for dat in data.iterator(kwargs['use']):
dg = GInterpModal(dat, kwargs['polyorder'], basisType,
kwargs['interp'], kwargs['periodic'])
numNodes = dg.numNodes
numComps = int(dat.getNumComps() / numNodes)
#vlog(ctx, 'interplolate: interpolating dataset #{:d}'.format(s))
#dg.recovery(tuple(range(numComps)), stack=True)
if kwargs['tag']:
out = Data(tag=kwargs['tag'],
label=kwargs['label'],
compgrid=ctx.obj['compgrid'],
meta=dat.meta)
grid, values = dg.recovery(0, kwargs['c1'])
out.push(grid, values)
data.add(out)
else:
dg.recovery(0, kwargs['c1'], overwrite=True)
#end
#end
vlog(ctx, 'Finishing recovery')
def log(ctx):
vlog(ctx, 'Calculating the natural log')
pushChain(ctx, 'temp.log')
for s in ctx.obj['sets']:
values = ctx.obj['dataSets'][s].getValues()
values = np.log(values)
ctx.obj['dataSets'][s].push(values)
def abs(ctx):
vlog(ctx, 'Calculating the absolute value')
pushChain(ctx, 'transform.log')
for s in ctx.obj['sets']:
values = ctx.obj['dataSets'][s].getValues()
values = np.abs(values)
ctx.obj['dataSets'][s].push(values)
def mult(ctx, **kwargs):
vlog(ctx, 'Multiplying by {:f}'.format(kwargs['factor']))
pushChain(ctx, 'temp.mult', **kwargs)
for s in ctx.obj['sets']:
values = ctx.obj['dataSets'][s].getValues()
values = values * kwargs['factor']
ctx.obj['dataSets'][s].push(values)
def pow(ctx, **kwargs):
vlog(ctx, 'Calculating the power of {:f}'.format(kwargs['power']))
pushChain(ctx, 'temp.pow', **kwargs)
for s in ctx.obj['sets']:
values = ctx.obj['dataSets'][s].getValues()
values = values**kwargs['power']
ctx.obj['dataSets'][s].push(values)
def energetics(ctx, **kwargs):
vlog(ctx, 'Starting energetics decomposition')
pushChain(ctx, 'energetics', **kwargs)
data = ctx.obj['data'] # shortcut
for elc, ion, em in zip(data.iterator(kwargs['elc']),
data.iterator(kwargs['ion']),
data.iterator(kwargs['field'])):
grid = em.getGrid()
outEnergetics = np.zeros(em.getValues()[..., 0:7].shape)
out = Data(tag=kwargs['tag'],
compgrid=ctx.obj['compgrid'],
label=kwargs['label'],
meta=em.meta)
grid, outEnergetics = diag.energetics(elc, ion, em)
out.push(grid, outEnergetics)
data.add(out)
#end
data.deactivateAll(tag=kwargs['elc'])
data.deactivateAll(tag=kwargs['ion'])
data.deactivateAll(tag=kwargs['field'])
vlog(ctx, 'Finishing energetics decomposition')
#end
def agyro(ctx, **kwargs):
"""Compute a measure of agyrotropy. Default measure is taken from
Swisdak 2015. Optionally computes agyrotropy as Frobenius norm of
agyrotropic pressure tensor. Pressure-tensor must be the first
dataset and magnetic field the second dataset.
"""
vlog(ctx, 'Starting agyro')
pushChain(ctx, 'agyro', **kwargs)
grid = ctx.obj['dataSets'][ctx.obj['sets'][0]].getGrid()
lo, up = ctx.obj['dataSets'][ctx.obj['sets'][0]].getBounds()
pij = ctx.obj['dataSets'][ctx.obj['sets'][0]].getValues()
B = ctx.obj['dataSets'][ctx.obj['sets'][1]].getValues()
if kwargs['forb']:
tmp = getForb(pij, B)
else:
tmp = getSwisdak(pij, B)
tmp = tmp[..., np.newaxis]
ctx.obj['dataSets'].append(GData())
idx = len(ctx.obj['dataSets']) - 1
ctx.obj['dataSets'][idx].push(tmp, grid)
ctx.obj['sets'] = [idx]
vlog(ctx, 'Finishing agyro')
def bparrotate(ctx, **kwargs):
"""Rotate an array parallel to the unit vectors of the magnetic field.
For two arrays u and b, where b is the unit vector in the direction of the magnetic field,
the operation is (u dot b_hat) b_hat. Note that the magnetic field is a three-component field,
so the output is a new vector whose components are (u_{b_x}, u_{b_y}, u_{b_z}), i.e.,
the x, y, and z components of the vector u parallel to the magnetic field.
"""
vlog(ctx, 'Starting rotation parallel to magnetic field')
pushChain(ctx, 'arrayBpar', **kwargs)
data = ctx.obj['data'] # shortcut
for a, rot in zip(data.iterator(kwargs['array']),
data.iterator(kwargs['field'])):
# Magnetic field is components 3, 4, & 5 in field array
grid, outrot = diag.parrotate(a, rot, '3:6')
# Create new GData structure with appropriate outtag and labels to store output.
out = Data(tag=kwargs['tag'],
compgrid=ctx.obj['compgrid'],
label=kwargs['label'],
meta=a.meta)
out.push(grid, outrot)
data.add(out)
#end
data.deactivateAll(tag=kwargs['array'])
data.deactivateAll(tag=kwargs['field'])
vlog(ctx, 'Finishing rotation parallel to magnetic field')
def mask(ctx, **kwargs):
vlog(ctx, 'Starting mask')
pushChain(ctx, 'mask', **kwargs)
data = ctx.obj('data')
if kwargs['filename']:
maskFld = Data(kwargs['filename']).getValues()
#end
for dat in data.interator(kwargs['use']):
values = dat.getValues()
if kwargs['filename']:
maskFldRep = np.repeat(maskFld, dat.getNumComps(), axis=-1)
data.push(np.ma.masked_where(maskFldRep < 0.0, values))
elif kwargs['lower'] is not None and kwargs['upper'] is not None:
dat.push(
np.ma.masked_outside(values, kwargs['lower'], kwargs['upper']),
grid)
elif kwargs['lower'] is not None:
dat.push(np.ma.masked_less(values, kwargs['lower']))
elif kwargs['upper'] is not None:
dat.push(np.ma.masked_greater(values, kwargs['upper']))
else:
data.push(values, grid)
click.echo(
click.style(
"WARNING in 'mask': No masking information specified.",
fg='yellow'))
#end
#end
vlog(ctx, 'Finishing mask')
def perprotate(ctx, **kwargs):
"""Rotate an array perpendicular to the unit vectors of a second array.
For two arrays u and v, where v is the rotator, operation is u - (u dot v_hat) v_hat.
"""
vlog(ctx, 'Starting rotation perpendicular to rotator array')
pushChain(ctx, 'rotarraypar', **kwargs)
data = ctx.obj['data'] # shortcut
for a, rot in zip(data.iterator(kwargs['array']),
data.iterator(kwargs['rotator'])):
grid, outrot = diag.perprotate(a, rot)
# Create new GData structure with appropriate outtag and labels to store output.
out = Data(tag=kwargs['tag'],
compgrid=ctx.obj['compgrid'],
label=kwargs['label'],
meta=a.meta)
out.push(outrot, grid)
data.add(out)
#end
data.deactivateAll(tag=kwargs['array'])
data.deactivateAll(tag=kwargs['rotator'])
vlog(ctx, 'Finishing rotation perpendicular to rotator array')
def deactivate(ctx, **kwargs):
"""Select datasets(s) to pass further down the command
chain. Datasets are indexed starting 0. Multiple datasets can be
selected using a comma separated list or a range specifier. Unless
'--focused' is selected, all unselected datasets will be
activated.
'--tag' and '--index' allow to specify tags and indices. The not
specified, 'deactivate' applies to all. Both parameters support
comma-separated values. '--index' also supports slices following
the Python conventions, e.g., '3:7' or ':-5:2'.
'info' command (especially with the '-ac' flags) can be helpful
when activating/deactivating multiple datasets.
"""
vlog(ctx, 'Starting deactivate')
pushChain(ctx, 'deactivate', **kwargs)
data = ctx.obj['data']
if kwargs['focused']:
data.activateAll()
#end
for dat in data.iterator(tag=kwargs['tag'],
onlyActive=False,
select=kwargs['index']):
dat.deactivate()
#end
vlog(ctx, 'Finishing deactivate')
def bperprotate(ctx, **kwargs):
"""Rotate an array perpendicular to the unit vectors of the magnetic field.
For two arrays u and b, where b is the unit vector in the direction of the magnetic field,
the operation is u - (u dot b_hat) b_hat.
"""
vlog(ctx, 'Starting rotation perpendicular to magnetic field')
pushChain(ctx, 'arrayBpar', **kwargs)
data = ctx.obj['data'] # shortcut
for a, rot in zip(data.iterator(kwargs['array']),
data.iterator(kwargs['field'])):
# Magnetic field is components 3, 4, & 5 in field array
grid, outrot = diag.perprotate(a, rot, '3:6')
# Create new GData structure with appropriate outtag and labels to store output.
out = Data(tag=kwargs['tag'],
compgrid=ctx.obj['compgrid'],
label=kwargs['label'],
meta=a.meta)
out.push(grid, outrot)
data.add(out)
#end
data.deactivateAll(tag=kwargs['array'])
data.deactivateAll(tag=kwargs['field'])
vlog(ctx, 'Finishing rotation perpendicular to magnetic field')
def interpolate(ctx, **kwargs):
vlog(ctx, 'Starting interpolate')
pushChain(ctx, 'interpolate', **kwargs)
data = ctx.obj['data']
basisType = None
isModal = None
if kwargs['basistype'] is not None:
if kwargs['basistype'] == 'ms':
basisType = 'serendipity'
isModal = True
elif kwargs['basistype'] == 'ns':
basisType = 'serendipity'
isModal = False
elif kwargs['basistype'] == 'mo':
basisType = 'maximal-order'
isModal = True
elif kwargs['basistype'] == 'mt':
basisType = 'tensor'
isModal = True
#end
#end
for dat in data.iterator(kwargs['use']):
if kwargs['basistype'] is None and dat.meta['basisType'] is None:
ctx.fail(click.style("ERROR in interpolate: no 'basistype' was specified and dataset {:s} does not have required metadata".format(dat.getLabel()), fg='red'))
#end
if isModal or dat.meta['isModal']:
dg = GInterpModal(dat,
kwargs['polyorder'], kwargs['basistype'],
kwargs['interp'], kwargs['read'])
else:
dg = GInterpNodal(dat,
kwargs['polyorder'], basisType,
kwargs['interp'], kwargs['read'])
#end
numNodes = dg.numNodes
numComps = int(dat.getNumComps() / numNodes)
if not kwargs['new']:
if kwargs['tag']:
out = Data(tag=kwargs['tag'],
label=kwargs['label'],
compgrid=ctx.obj['compgrid'],
meta=dat.meta)
grid, values = dg.interpolate(tuple(range(numComps)))
out.push(grid, values)
data.add(out)
else:
dg.interpolate(tuple(range(numComps)), overwrite=True)
#end
else:
interpFn(dat, kwargs['polyorder'])
#end
#end
vlog(ctx, 'Finishing interpolate')
def trajectory(ctx, **kwargs):
vlog(ctx, 'Starting trajectory')
pushChain(ctx, 'trajectory', **kwargs)
data = ctx.obj['data']
tags = list(data.tagIterator(kwargs['use']))
if len(tags) > 1:
ctx.fail(
click.echo(
"'trajectory' supports only one 'tag', was provided {:d}".
format(len(tags)),
fg='red'))
else:
tag = tags[0]
#end
numSets = len(ctx.obj['sets'])
fig = plt.figure()
ax = Axes3D(fig)
kwargs['figure'] = fig
kwargs['legend'] = False
dat = ctx.obj['data'].getDataset(tag, 0)
numPos = dat.getNumCells()[0]
jump = 1
if kwargs['numframes'] is not None:
jump = int(math.floor(numPos / kwargs['numframes']))
numPos = int(kwargs['numframes'])
#end
anim = FuncAnimation(fig,
update,
numPos,
fargs=(ax, ctx, jump, kwargs['velocity'],
kwargs['xmin'], kwargs['xmax'], kwargs['ymin'],
kwargs['ymax'], kwargs['zmin'], kwargs['zmax'],
tag),
interval=kwargs['interval'])
ax.view_init(elev=kwargs['elevation'], azim=kwargs['azimuth'])
if kwargs['fixaspect']:
plt.setp(ax, aspect=1.0)
fName = 'anim.mp4'
if kwargs['saveas']:
fName = str(kwargs['saveas'])
#end
if kwargs['save'] or kwargs['saveas']:
anim.save(fName, writer='ffmpeg')
#end
if kwargs['show']:
plt.show()
#end
vlog(ctx, 'Finishing trajectory')
def val2coord(ctx, **kwargs):
"""Given a dataset (typically a DynVector) selects columns from it to
create new datasets. For example, you can choose say column 1 to
be the X-axis of the new dataset and column 2 to be the
Y-axis. Multiple columns can be choosen using range specifiers and
as many datasets are then created.
"""
vlog(ctx, 'Starting val2coord')
pushChain(ctx, 'val2coord', **kwargs)
data = ctx.obj['data']
activeSets = []
colors = ['C0', 'C1', 'C2', 'C3', 'C4', 'C5', 'C6', 'C7', 'C8', 'C9']
tags = list(data.tagIterator())
outTag = kwargs['tag']
if outTag is None:
if len(tags) == 1:
outTag = tags[0]
else:
outTag = 'val2coord'
#end
#end
for setIdx, dat in data.iterator(kwargs['use'], enum=True):
values = dat.getValues()
xComps = _getRange(kwargs['x'], len(values[0, :]))
yComps = _getRange(kwargs['y'], len(values[0, :]))
if len(xComps) > 1 and len(xComps) != len(yComps):
click.echo(click.style("ERROR 'val2coord': Length of the x-components ({:d}) is greater than 1 and not equal to the y-components ({:d}).".format(len(xComps), len(yComps)), fg='red'))
ctx.exit()
#end
for i, yc in enumerate(yComps):
if len(xComps) > 1:
xc = xComps[i]
else:
xc = xComps[0]
#end
x = values[..., xc]
y = values[..., yc, np.newaxis]
out = Data(tag=outTag,
label=kwargs['label'],
compgrid=ctx.obj['compgrid'],
meta=dat.meta)
out.push([x], y)
out.color = 'C0'
data.add(out)
#end
dat.deactivate()
#end
vlog(ctx, 'Finishing val2coord')
def blot(ctx, **kwargs):
vlog(ctx, 'Starting blot')
pushChain(ctx, 'blot', **kwargs)
# if kwargs['group'] is not None:
# kwargs['group'] = int(kwargs['group'])
#end
fName = ""
for dat in ctx.obj['data'].iterator(kwargs['use']):
# if len(ctx.obj['sets']) > 1 or kwargs['forcelegend']:
# label = ctx.obj['labels'][s]
# else:
# label = ''
#end
# if kwargs['arg'] is not None:
# gplot(dat, kwargs['arg'], labelPrefix=label,
# **kwargs)
# else:
# gplot(dat, labelPrefix=label,
# **kwargs)
# #end
fig = postgkyl.output.blot(dat, **kwargs)
# if (kwargs['save'] or kwargs['saveas']):
# if kwargs['saveas']:
# fName = kwargs['saveas']
# else:
# if fName != "":
# fName = fName + "_"
# #end
# if dat.fName:
# fName = fName + dat.fName.split('.')[0]
# else:
# fName = fName + 'ev_'+ctx.obj['labels'][s].replace(' ', '_')
# #end
# #end
# #end
# if (kwargs['save'] or kwargs['saveas']) and kwargs['figure'] is None:
# fName = str(fName) + '.png'
# plt.savefig(fName, dpi=kwargs['dpi'])
# fName = ""
# #end
#end
#if (kwargs['save'] or kwargs['saveas']) and kwargs['figure'] is not None:
# fName = str(fName) + '.png'
# plt.savefig(fName, dpi=kwargs['dpi'])
#end
if kwargs['show']:
blt.show(fig)
#end
vlog(ctx, 'Finishing blot')
def growth(ctx, **kwargs):
"""Attempts to compute growth rate (i.e. fit e^(2x)) from DynVector
data, typically an integrated quantity like electric or magnetic
field energy.
"""
vlog(ctx, 'Starting growth')
pushChain( ctx, 'growth', **kwargs)
data = ctx.obj['data']
for dat in data.iterator(kwargs['use']):
time = dat.getGrid()
values = dat.getValues()
numDims = dat.getNumDims()
if numDims > 1:
click.fail(click.style("'growth' is available only for 1D data (used on {:d}D data)".format(numDims), fg='red'))
#end
bestParams, bestR2, bestN = fitGrowth(time[0], values[..., 0],
minN=kwargs['minn'],
maxN=kwargs['maxn'],
p0=kwargs['guess'])
if kwargs['plot'] is True:
vlog(ctx, 'growth: Plotting data and fit')
plt.style.use(os.path.dirname(os.path.realpath(__file__)) \
+ "/../output/postgkyl.mplstyle")
fig, ax = plt.subplots()
ax.plot(time[0], values[..., 0], '.')
ax.set_autoscale_on(False)
ax.plot(time[0], exp2(time[0], *bestParams))
ax.grid(True)
plt.show()
#end
if kwargs['instantaneous'] is True:
vlog(ctx, 'growth: Plotting instantaneous growth rate')
gammas = []
for i in range(1,len(time[0])-1):
gamma = (values[i+1,0] - values[i-1,0])/(2*values[i,0]*(time[0][i+1] - time[0][i-1]))
gammas.append(gamma)
plt.style.use(os.path.dirname(os.path.realpath(__file__)) \
+ "/../output/postgkyl.mplstyle")
fig, ax = plt.subplots()
ax.plot(time[0][1:-1], gammas)
#ax.set_autoscale_on(False)
ax.grid(True)
plt.show()
#end
#end
vlog(ctx, 'Finishing growth')
def extractinput(ctx, **kwargs):
vlog(ctx, 'Starting ')
pushChain(ctx, 'extractinput', **kwargs)
data = ctx.obj['data']
for dat in data.iterator(kwargs['use']):
encInp = dat.getInputFile()
if encInp:
inpfile = base64.decodebytes(
encInp.encode('utf-8')).decode('utf-8')
click.echo(inpfile)
else:
click.echo("No embedded input file!")
#end
#end
vlog(ctx, 'Finishing extractinput')
def write(ctx, **kwargs):
"""Write active dataset to a file. The output file format can be set
with ``--mode``, and is ADIOS BP by default. If data is
saved as BP file it can be later loaded back into pgkyl to further
manipulate or plot it.
"""
vlog(ctx, 'Starting write')
pushChain(ctx, 'write', **kwargs)
data = ctx.obj['data']
for dat in data.iterator(kwargs['use']):
dat.write(outName=kwargs['filename'],
mode=kwargs['mode'],
bufferSize=kwargs['buffersize'])
#end
vlog(ctx, 'Finishing write')
def norm(ctx, **kwargs):
vlog(ctx, 'Normalizing data')
pushChain(ctx, 'temp.norm', **kwargs)
for s in ctx.obj['sets']:
values = ctx.obj['dataSets'][s].getValues()
numComps = ctx.obj['dataSets'][s].getNumComps()
valuesOut = values.copy()
for comp in range(numComps):
if kwargs['shift']:
valuesOut[..., comp] -= valuesOut[..., comp].min()
if kwargs["usefirst"]:
valuesOut[..., comp] /= valuesOut[..., comp].item(0)
else:
valuesOut[..., comp] /= np.abs(valuesOut[..., comp]).max()
#end
#end
ctx.obj['dataSets'][s].push(valuesOut)
def pr(ctx, **kwargs):
vlog(ctx, 'Starting pr')
pushChain(ctx, 'pr', **kwargs)
data = ctx.obj['data']
for dat in data.iterator(kwargs['use']):
if kwargs['grid']:
grid = dat.getGrid()
for g in grid:
click.echo(g)
#end
else:
click.echo(dat.getValues().squeeze())
#end
#end
vlog(ctx, 'Finishing pr')
def current(ctx, **kwargs):
vlog(ctx, 'Starting current accumulation')
pushChain(ctx, 'current', **kwargs)
data = ctx.obj['data']
for dat in data.iterator(kwargs['use']):
grid = dat.getGrid()
outcurrent = np.zeros(dat.getValues().shape)
grid, outcurrent = diag.accumulate_current(dat, kwargs['qbym'])
dat.deactivate()
out = Data(tag=kwargs['tag'],
compgrid=ctx.obj['compgrid'],
label=kwargs['label'],
meta=dat.meta)
out.push(grid, outcurrent)
data.add(out)
#end
vlog(ctx, 'Finishing current accumulation')
def integrate(ctx, **kwargs):
vlog(ctx, 'Starting integrate')
pushChain(ctx, 'integrate', **kwargs)
data = ctx.obj['data']
for dat in data.iterator(kwargs['use']):
if kwargs['tag']:
grid, values = diag.integrate(dat, kwargs['axis'])
out = Data(tag=kwargs['tag'],
label=kwargs['label'],
compgrid=ctx.obj['compgrid'],
meta=dat.meta)
out.push(grid, values)
data.add(out)
else:
diag.integrate(dat, kwargs['axis'], overwrite=True)
#en
#end
vlog(ctx, 'Finishing integrate')
def tenmoment(ctx, **kwargs):
"""Extract ten-moment primitive variables from ten-moment conserved
variables.
"""
vlog(ctx, 'Starting tenmoment')
pushChain(ctx, 'tenmoment', **kwargs)
data = ctx.obj['data']
v = kwargs['variable_name']
for dat in data.iterator(kwargs['use']):
vlog(ctx,
'tenmoment: Extracting {:s} from data set #{:d}'.format(v, s))
if v == "density":
diag.getDensity(dat, stack=True)
elif v == "xvel":
diag.getVx(dat, stack=True)
elif v == "yvel":
diag.getVy(dat, stack=True)
elif v == "zvel":
diag.getVz(dat, stack=True)
elif v == "vel":
diag.getVi(dat, stack=True)
elif v == "pxx":
diag.getPxx(dat, stack=True)
elif v == "pxy":
diag.getPxy(dat, stack=True)
elif v == "pxz":
diag.getPxz(dat, stack=True)
elif v == "pyy":
diag.getPyy(dat, stack=True)
elif v == "pyz":
diag.getPyz(dat, stack=True)
elif v == "pzz":
diag.getPzz(dat, stack=True)
elif v == "pressure":
diag.getP(dat, numMoms=10, stack=True)
elif v == "pressureTensor":
diag.getPij(dat, stack=True)
#end
vlog(ctx, 'Finishing tenmoment')
def magsq(ctx, **kwargs):
"""Calculate the magnitude squared of an input array
"""
vlog(ctx, 'Starting magnitude squared computation')
pushChain(ctx, 'magsq', **kwargs)
data = ctx.obj['data']
for dat in data.iterator(kwargs['use']):
if kwargs['tag']:
out = Data(tag=kwargs['tag'],
label=kwargs['label'],
compgrid=ctx.obj['compgrid'],
meta=dat.meta)
grid, values = diag.magsq(dat)
out.push(grid, values)
data.add(out)
else:
diag.magsq(dat, overwrite=True)
#end
#end
vlog(ctx, 'Finishing magnitude squared computation')
def euler(ctx, **kwargs):
"""Compute Euler (five-moment) primitive and some derived variables
from fluid conserved variables.
"""
vlog(ctx, 'Starting euler')
pushChain(ctx, 'euler', **kwargs)
data = ctx.obj['data']
v = kwargs['variable_name']
for dat in data.iterator(kwargs['use']):
vlog(ctx, 'euler: Extracting {:s} from data set'.format(v))
if v == "density":
diag.getDensity(dat, overwrite=True)
elif v == "xvel":
diag.getVx(dat, overwrite=True)
elif v == "yvel":
diag.getVy(dat, overwrite=True)
elif v == "zvel":
diag.getVz(dat, overwrite=True)
elif v == "vel":
diag.getVi(dat, overwrite=True)
elif v == "pressure":
diag.getP(dat,
gasGamma=kwargs['gas_gamma'],
numMom=5,
overwrite=True)
elif v == "ke":
diag.getKE(dat,
gasGamma=kwargs['gas_gamma'],
numMom=5,
overwrite=True)
elif v == "mach":
diag.getMach(dat,
gasGamma=kwargs['gas_gamma'],
numMom=5,
overwrite=True)
#end
vlog(ctx, 'Finishing euler')
def fft(ctx, **kwargs):
"""Calculate the Fourier Transform or the power-spectral density of
input data. Only works on 1D data at present.
"""
vlog(ctx, 'Starting FFT')
pushChain(ctx, 'fft', **kwargs)
data = ctx.obj['data']
for dat in data.iterator(kwargs['use']):
if kwargs['tag']:
out = Data(tag=kwargs['tag'],
label=kwargs['label'],
compgrid=ctx.obj['compgrid'],
meta=dat.meta)
grid, values = diag.fft(dat, kwargs['psd'], kwargs['iso'])
out.push(grid, values)
data.add(out)
else:
diag.fft(dat, kwargs['psd'], kwargs['iso'], overwrite=True)
#end
#end
vlog(ctx, 'Finishing FFT')
def velocity(ctx, **kwargs):
vlog(ctx, 'Starting velocity')
pushChain(ctx, 'velocity', **kwargs)
data = ctx.obj['data'] # shortcut
for m0, m1 in zip(data.iterator(kwargs['density']),
data.iterator(kwargs['momentum'])):
grid = m0.getGrid()
valsM0 = m0.getValues()
valsM1 = m1.getValues()
out = Data(tag=kwargs['tag'],
compgrid=ctx.obj['compgrid'],
label=kwargs['label'],
meta=m0.meta)
out.push(grid, valsM1 / valsM0)
data.add(out)
#end
data.deactivateAll(tag=kwargs['density'])
data.deactivateAll(tag=kwargs['momentum'])
vlog(ctx, 'Finishing velocity')
def select(ctx, **kwargs):
r"""Subselect data from the active dataset(s). This command allows, for
example, to choose a specific component of a multi-component
dataset, select a index or coordinate range. Index ranges can also
be specified using python slice notation (start:end:stride).
"""
vlog(ctx, 'Starting select')
pushChain(ctx, 'select', **kwargs)
data = ctx.obj['data']
for dat in data.iterator(kwargs['use']):
if kwargs['tag']:
out = Data(tag=kwargs['tag'],
label=kwargs['label'],
compgrid=ctx.obj['compgrid'],
meta=dat.meta)
grid, values = postgkyl.data.select(dat,
z0=kwargs['z0'],
z1=kwargs['z1'],
z2=kwargs['z2'],
z3=kwargs['z3'],
z4=kwargs['z4'],
z5=kwargs['z5'],
comp=kwargs['comp'])
out.push(grid, values)
data.add(out)
else:
postgkyl.data.select(dat, overwrite=True,
z0=kwargs['z0'], z1=kwargs['z1'],
z2=kwargs['z2'], z3=kwargs['z3'],
z4=kwargs['z4'], z5=kwargs['z5'],
comp=kwargs['comp'])
#end
#end
vlog(ctx, 'Finishing select')
