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 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 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 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 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 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 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 listoutputs(ctx, **kwargs):
"""List Gkeyll filename stems in the current directory
"""
vlog(ctx, 'Starting listoutputs')
files = glob('*.{:s}'.format(kwargs['extension']))
unique = []
for fn in files:
# remove extension
s = fn[:-(len(kwargs['extension'])+1)]
# strip "restart"
if s.endswith('_restart'):
s = s[:-8]
#end
#strip digits
s = re.sub(r'_\d+$', '', s)
if s not in unique:
unique.append(s)
#end
#end
for s in sorted(unique):
click.echo(s)
#end
vlog(ctx, 'Finishing listoutputs')
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 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 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 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 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 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 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 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 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 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 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 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 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')
def cli(ctx, **kwargs):
"""Postprocessing and plotting tool for Gkeyll
data. Datasets can be loaded, processed and plotted using a
command chaining mechanism. For full documentation see the Gkeyll
documentation webpages. Help for individual commands can be
obtained using the --help option for that command.
"""
ctx.obj = {} # The main contex object
ctx.obj['startTime'] = time.time(
) # Timings are written in the verbose mode
if kwargs['verbose']:
ctx.obj['verbose'] = True
# Monty Python references should be a part of any Python code
vlog(ctx, 'This is Postgkyl running in verbose mode!')
vlog(ctx, 'Spam! Spam! Spam! Spam! Lovely Spam! Lovely Spam!')
vlog(ctx, 'And now for something completelly different...')
else:
ctx.obj['verbose'] = False
#end
home = os.path.expanduser('~')
ctx.obj['savechainPath'] = (home + '/.pgkyl/pgkylchain')
if kwargs['savechain'] or kwargs['savechainas'] is not None:
ctx.obj['savechain'] = True
try:
os.makedirs(home + "/.pgkyl")
except FileExistsError:
# directory already exists
pass
#end
if kwargs['savechainas'] is not None:
ctx.obj['savechainPath'] = (home + '/.pgkyl/' +
str(kwargs['savechainas']))
#end
fh = open(ctx.obj['savechainPath'], 'w') # The default chain name
fh.close()
else:
ctx.obj['savechain'] = False
#end
ctx.obj['inDataStrings'] = []
ctx.obj['inDataStringsLoaded'] = 0
ctx.obj['data'] = DataSpace()
ctx.obj['fig'] = ''
ctx.obj['ax'] = ''
ctx.obj['compgrid'] = kwargs['compgrid']
ctx.obj['globalVarNames'] = kwargs['varname']
ctx.obj['globalCuts'] = (kwargs['z0'], kwargs['z1'], kwargs['z2'],
kwargs['z3'], kwargs['z4'], kwargs['z5'],
kwargs['component'])
