LLNL-PyDV 3.6.3__tar.gz → 3.7.0__tar.gz

{llnl_pydv-3.6.3 → llnl_pydv-3.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: LLNL-PyDV
-Version: 3.6.3
+Version: 3.7.0
 Summary: PyDV: Python Data Visualizer
 License: BSD
 Author: Sarah El-Jurf

{llnl_pydv-3.6.3 → llnl_pydv-3.7.0}/pydv/curve.py

@@ -76,6 +76,8 @@ class Curve(object):
                  title='',
                  record_id='',
                  step=False,
+                 step_original_x=np.empty(0),
+                 step_original_y=np.empty(0),
                  xticks_labels=None,
                  plotname='',
                  color='',
@@ -108,6 +110,8 @@ class Curve(object):
         self.title = title
         self.record_id = record_id
         self.step = step
+        self.step_original_x = step_original_x,
+        self.step_original_y = step_original_y,
         self.xticks_labels = xticks_labels
         self.plotname = plotname
         self.color = color
@@ -254,6 +258,8 @@ class Curve(object):
                   title=self.title,
                   record_id=self.record_id,
                   step=self.step,
+                  step_original_x=self.step_original_x,
+                  step_original_y=self.step_original_y,
                   xticks_labels=self.xticks_labels,
                   plotname=self.plotname,
                   color=self.color,

llnl_pydv-3.7.0/pydv/pdv

@@ -0,0 +1,22 @@
+#!/usr/bin/env bash
+pth=$(realpath $0)
+pth=$(dirname $pth)
+pth="$pth/pdv_launcher.py $*"
+
+if [[ $pth == *"pdv-sa"* ]]; then
+
+    /usr/tce/bin/python3 $pth
+
+else
+
+    FILE="/usr/apps/weave/weave-prod-cpu/bin/activate"
+
+    if [ -e "$FILE" ]; then
+
+        source $FILE
+
+    fi
+
+    python3 $pth
+
+fi

{llnl_pydv-3.6.3 → llnl_pydv-3.7.0}/pydv/pdv.py

@@ -5896,7 +5896,7 @@ class Command(cmd.Cmd, object):
 
     def do_linemarker(self, line):
         """
-        Set the marker symbol for the curves
+        Set the marker symbol and marker size for the curves
         """
 
         if not line:
@@ -6771,7 +6771,7 @@ class Command(cmd.Cmd, object):
                 if line_labels:  # Multiple curves and labels
                     curves = line.split('`')[0].split()
                 else:  # single curve and label
-                    curves = line.split()[0]
+                    curves = [line.split()[0]]
                     line_labels = [' '.join(line.split()[1:])]
 
                 for i in range(len(curves)):
@@ -7728,10 +7728,7 @@ class Command(cmd.Cmd, object):
             xmin = 1e-2
             for cur in orderlist:
                 if not cur.hidden:
-                    xdat = numpy.array(cur.x)
-                    for i in range(len(xdat)):
-                        if xdat[i] < 1e-300:
-                            xdat[i] = 1e301
+                    xdat = numpy.where(cur.x < 1e-300, 1e301, cur.x)
                     localmin = min(xdat)
                     if localmin and localmin < xmin:
                         xmin = localmin
@@ -8595,13 +8592,9 @@ class Command(cmd.Cmd, object):
                     xdat = numpy.array(cur.x)
                     ydat = numpy.array(cur.y)
                     if yls:
-                        for i in range(len(ydat)):
-                            if (ydat[i] < 0):
-                                ydat[i] = 1e-301  # custom ydata clipping
+                        ydat = numpy.where(ydat < 0, 1e-301, ydat)  # custom ydata clipping
                     if xls:
-                        for i in range(len(xdat)):
-                            if xdat[i] < 0:
-                                xdat[i] = 1e-301  # custom ydata clipping
+                        xdat = numpy.where(xdat < 0, 1e-301, xdat)  # custom ydata clipping
 
                     if cur.ebar is not None:
                         plt.errorbar(xdat,

llnl_pydv-3.6.3/pydv/pdv → llnl_pydv-3.7.0/pydv/pdv_launcher.py

@@ -1,5 +1,3 @@
-#!/usr/bin/env /usr/apps/weave/weave-prod-cpu/bin/python3
-
 import sys
 import os
 
@@ -14,4 +12,3 @@ try:
 except ImportError:
     import pydv.pdv
     pydv.pdv.Command().main()
-

{llnl_pydv-3.6.3 → llnl_pydv-3.7.0}/pydv/pdvutil.py

@@ -308,7 +308,7 @@ def getletterargs(line):
         temp_line = label_line[0].split(':')
         temp_line[-1] = temp_line[-1] + "`" + label_line[1]
         line = temp_line
-    elif len(re.split(r"(\b[a-zA-Z]:[a-zA-Z]\b)|(\b[a-zA-Z]:@\d+\b)|(\b@\d+:@\d+\b)", line)) == 1:  # single label w/ :
+    elif len(re.split(r"(^[a-zA-Z]:[a-zA-Z]$)|(^[a-zA-Z]:@\d+$)|(^@\d+:@\d+$)", line)) == 1:  # single label w/ :
         return line
     else:
         line = line.split(':')  # begin arduous list parsing

{llnl_pydv-3.6.3 → llnl_pydv-3.7.0}/pydv/pydvpy.py

@@ -70,12 +70,12 @@ A python interface for PyDV functionality.
 """
 
 import json
-import os
 import traceback
 import sys
 import re
 import copy
-import random as sysrand
+from multiprocessing import Pool, cpu_count
+import subprocess
 
 from distutils.version import LooseVersion
 
@@ -124,6 +124,8 @@ def makecurve(x=np.empty(0),
               title='',
               record_id='',
               step=False,
+              step_original_x=np.empty(0),
+              step_original_y=np.empty(0),
               xticks_labels=None,
               plotname='',
               color='',
@@ -172,6 +174,10 @@ def makecurve(x=np.empty(0),
     :type record_id: str
     :param step: whether this is a step curve.
     :type step: bool
+    :param step_original_x: list of original x values for step function
+    :type step_original_x: list
+    :param step_original_y: list of original y values for step function
+    :type step_original_y: list
     :param xticks_labels: Dictionary of x tick labels if x data are strings.
     :type xticks_labels: dict
     :param plotname: The plot name of the curve.
@@ -233,6 +239,8 @@ def makecurve(x=np.empty(0),
                     title=title,
                     record_id=record_id,
                     step=step,
+                    step_original_x=step_original_x,
+                    step_original_y=step_original_y,
                     xticks_labels=xticks_labels,
                     plotname=plotname,
                     color=color,
@@ -394,13 +402,9 @@ def create_plot(curvelist,
             ydat = np.array(cur.y)
 
             if (yls):
-                for i in range(len(ydat)):
-                    if (ydat[i] < 0):
-                        ydat[i] = 1e-301  # custom ydata clipping
+                ydat = np.where(ydat < 0, 1e-301, ydat)  # custom ydata clipping
             if (xls):
-                for i in range(len(xdat)):
-                    if (xdat[i] < 0):
-                        xdat[i] = 1e-301  # custom xdata clipping
+                xdat = np.where(xdat < 0, 1e-301, xdat)  # custom ydata clipping
 
             if cur.ebar is not None:
                 c = plt.errorbar(xdat, ydat, yerr=[cur.ebar[0], cur.ebar[1]],
@@ -483,15 +487,15 @@ def save(fname, curvelist, verbose=False, save_labels=False):
         curves.append(curvelist)
 
     try:
-        f = open(fname, 'w')
-        for cur in curves:
-            if save_labels:
-                print('# ' + cur.name + ' # xlabel ' + cur.xlabel + ' # ylabel ' + cur.ylabel + '\n')
-                f.write('# ' + cur.name + ' # xlabel ' + cur.xlabel + ' # ylabel ' + cur.ylabel + '\n')
-            else:
-                f.write('# ' + cur.name + '\n')
-            for dex in range(len(cur.x)):
-                f.write(' ' + str(cur.x[dex]) + ' ' + str(cur.y[dex]) + '\n')
+        with open(fname, "w") as f:
+            for cur in curves:
+                if save_labels:
+                    print('# ' + cur.name + ' # xlabel ' + cur.xlabel + ' # ylabel ' + cur.ylabel + '\n')
+                    f.write('# ' + cur.name + ' # xlabel ' + cur.xlabel + ' # ylabel ' + cur.ylabel + '\n')
+                else:
+                    f.write('# ' + cur.name + '\n')
+                for dex in range(len(cur.x)):
+                    f.write(' ' + str(cur.x[dex]) + ' ' + str(cur.y[dex]) + '\n')
     except:
         print('Error: Can not write to: ' + fname)
         if verbose:
@@ -575,203 +579,35 @@ def read(fname, gnu=False, xcol=0, verbose=False, pattern=None, matches=None):
         return readcsv(fname=fname, xcol=xcol, verbose=verbose)
     elif str(fname).endswith(".json"):
         return readsina(fname=fname, verbose=verbose)
-
-    def bundle_curve(_curve, build_x, build_y):
-
-        _curve.xticks_labels = {}
-
-        # Numerical data
+    elif gnu or str(fname).endswith(".gnu"):
+        return __loadcolumns(fname, xcol)
+    elif pdbLoaded:
         try:
-            float(build_x[0])
-
-        # X tick label data
+            fpdb = pdb.open(fname, 'r')
+            return __loadpdb(fname, fpdb)
         except:
+            pass
 
-            xticks = list(set(build_x))
-            xticks.sort()
-            xticks_dict = {}
-
-            for i, xtick in enumerate(xticks):
-                xticks_dict[xtick] = i
-
-            build_x = [xticks_dict[xtick] for xtick in build_x]
-
-            _curve.xticks_labels = xticks_dict
-
-        # Step Data
-        if len(build_x) != len(build_y):
-            build_y.append(build_y[-1])
-
-            _curve.x = np.array(build_x, dtype=float).repeat(2)[1:]
-            _curve.y = np.array(build_y, dtype=float).repeat(2)[:-1]
-            _curve.step = True
-            _curve.step_original_x = np.array(build_x, dtype=float)
-            _curve.step_original_y = np.array(build_y[:-1], dtype=float)
-        # Numerical Data
-        else:
-            _curve.x = np.array(build_x, dtype=float)
-            _curve.y = np.array(build_y, dtype=float)
-            _curve.step = False
-
-        return _curve
-
-    curve_list = list()
     regex = None
 
     if pattern:
         regex = re.compile(r"%s" % pattern)
-    fname = os.path.expanduser(fname)
-    _, ext = os.path.splitext(fname)
+
     try:
-        if gnu or ext == '.gnu':
-            return __loadcolumns(fname, xcol)
 
-        if pdbLoaded:
-            try:
-                fpdb = pdb.open(fname, 'r')
-                return __loadpdb(fname, fpdb)
-            except:
-                pass
-
-        match_count = 0
-        build_list_x = list()
-        build_list_y = list()
-        current = None
-        new_curve = True
-        potential_curve_name = ""
-        xlabels = {}
-        ylabels = {}
-        xlabel = ''
-        ylabel = ''
-        with open(fname, 'r') as f:
-            for line in f:
-                labels = False
-
-                # Check for labels
-                split_line_label = re.split(r'#', str.strip(line))
-                for split in split_line_label:
-                    if re.search('[a-zA-Z]', split):
-                        if 'xlabel' in split:
-                            xlabel = split.replace('xlabel', '').strip()
-                            labels = True
-                        if 'ylabel' in split:
-                            ylabel = split.replace('ylabel', '').strip()
-                            labels = True
-
-                # Contains x and/or y labels
-                if labels:
-                    split_line = [None] * 2
-                    split_line[0] = '#'
-                    split_line[1] = line.split("# xlabel")[0].split("# ylabel")[0].split("#xlabel")[0].split("#ylabel")[0][1:].strip()  # noqae501
-                    xlabels[split_line[1]] = xlabel
-                    ylabels[split_line[1]] = ylabel
-                    xlabel = ''
-                    ylabel = ''
-                else:  # might be numerical or text
-                    if "#" in line:  # text
-                        split_line = [None] * 2
-                        split_line[0] = '#'
-                        split_line[1] = line[1:].strip()
-                    else:  # numerical
-                        split_line = re.split(r'[ \t]+', str.strip(line))
-
-                if not split_line or not split_line[0]:
-                    continue
-                elif split_line[0] in {'##', 'end', 'End', 'END'}:
-                    continue
-                elif split_line[0] == '#':
-                    # We may have just finished buiding a curve, so we need to
-                    # add it to the list of curves.
-                    # If this is the first curve, then current will be None, so
-                    # we won't add anything.
-                    # If there is a sequence of lines that start with # before
-                    # getting to the actual data, then the new_curve flag will
-                    # keep us from adding all those comments as curves.
-                    if current and not new_curve:
-                        # Need this since it will add last match below and outside loop
-                        if matches and match_count >= matches:
-                            break
-
-                        curve_list.append(bundle_curve(current, build_list_x, build_list_y))
-                        build_list_x = list()
-                        build_list_y = list()
-
-                    # Begin setup of new curve
-                    new_curve = True
-                    potential_curve_name = ' '.join(split_line[1:])
-                else:
-                    if new_curve:
-                        curve_name = potential_curve_name
-                        new_curve = False
-                        if regex:
-                            if regex.search(curve_name):
-                                match_count += 1
-                                current = makecurve(name=curve_name,
-                                                    filename=fname,
-                                                    xlabel=xlabels.get(curve_name, ''),
-                                                    ylabel=ylabels.get(curve_name, ''))
-                                # Step Data
-                                if len(split_line) == 1:
-                                    build_list_x.append(split_line[0])
-                                # Numerical Data
-                                elif len(split_line) == 2:
-                                    build_list_x.append(split_line[0])
-                                    build_list_y.append(split_line[-1])
-                                # Label Data and Paired Data
-                                else:
-                                    try:  # Paired Data
-                                        float(split_line[0])
-                                        build_list_x += split_line[::2]
-                                        build_list_y += split_line[1::2]
-                                    except:  # Label Data
-                                        build_list_x.append(" ".join(split_line[:-1]))
-                                        build_list_y.append(split_line[-1])
-                            else:
-                                current = None
-                        else:
-                            current = makecurve(name=curve_name,
-                                                filename=fname,
-                                                xlabel=xlabels.get(curve_name, ''),
-                                                ylabel=ylabels.get(curve_name, ''))
-
-                            # Step Data
-                            if len(split_line) == 1:
-                                build_list_x.append(split_line[0])
-                            # Numerical Data
-                            elif len(split_line) == 2:
-                                build_list_x.append(split_line[0])
-                                build_list_y.append(split_line[-1])
-                            # Label Data and Paired Data
-                            else:
-                                try:  # Paired Data
-                                    float(split_line[0])
-                                    build_list_x += split_line[::2]
-                                    build_list_y += split_line[1::2]
-                                except:  # Label Data
-                                    build_list_x.append(" ".join(split_line[:-1]))
-                                    build_list_y.append(split_line[-1])
-
-                    elif current and not new_curve:  # add data to current curve
-
-                        # Step Data
-                        if len(split_line) == 1:
-                            build_list_x.append(split_line[0])
-                        # Numerical Data
-                        elif len(split_line) == 2:
-                            build_list_x.append(split_line[0])
-                            build_list_y.append(split_line[-1])
-                        # Label Data and Paired Data
-                        else:
-                            try:  # Paired Data
-                                float(split_line[0])
-                                build_list_x += split_line[::2]
-                                build_list_y += split_line[1::2]
-                            except:  # Label Data
-                                build_list_x.append(" ".join(split_line[:-1]))
-                                build_list_y.append(split_line[-1])
-
-        if current and build_list_x and build_list_y:
-            curve_list.append(bundle_curve(current, build_list_x, build_list_y))
+        # first get the lines that contain the candidate ULTRA curves
+        try:  # using grep and wc. Much faster
+            locs = _get_linelocs_from_text_ultra_grep(fname)
+        except:  # opening file directly
+            locs = _get_linelocs_from_text_ultra(fname)
+
+        # Parallel curve read using Pool()
+        with Pool(processes=cpu_count()) as pool:
+
+            # Create input tuples for each # line from locs above. Use -1 because last loc idx is end of file
+            input_tuples = list(map(lambda idx: (fname, locs, idx, regex), range(len(locs) - 1)))
+
+            curve_list = list(filter(None, pool.map(_get_curve_from_text_ultra_perproc, input_tuples)))
 
     except IOError:
         print('could not load file: {}'.format(fname))
@@ -2371,14 +2207,14 @@ def sqrtx(curvelist):
         curvelist.x = np.sqrt(curvelist.x)
 
 
-def xmax(curvelist, limit):
+def xmax(curvelist, max):
     """
     Filter out points in the curve or list of curves whose x values are greater than limit.
 
     :param curvelist: The curve or list of curves
     :type curvelist: curve or list
-    :param limit: The maximum value
-    :type limit: float
+    :param max: The maximum value
+    :type max: float
     """
 
     curves = list()
@@ -2389,16 +2225,8 @@ def xmax(curvelist, limit):
         curves.append(curvelist)
 
     for c in curves:
-        nx = []
-        ny = []
-
-        for i in range(len(c.x)):
-            if c.x[i] <= float(limit):
-                nx.append(c.x[i])
-                ny.append(c.y[i])
-
-        c.x = np.array(nx)
-        c.y = np.array(ny)
+        c.x = c.x[np.where(c.x <= float(max))]
+        c.y = c.y[np.where(c.x <= float(max))]
 
 
 def xmin(curvelist, min):
@@ -2419,16 +2247,8 @@ def xmin(curvelist, min):
         curves.append(curvelist)
 
     for c in curves:
-        nx = []
-        ny = []
-
-        for i in range(len(c.x)):
-            if c.x[i] >= float(min):
-                nx.append(c.x[i])
-                ny.append(c.y[i])
-
-        c.x = np.array(nx)
-        c.y = np.array(ny)
+        c.x = c.x[np.where(c.x >= float(min))]
+        c.y = c.y[np.where(c.x >= float(min))]
 
 
 def xminmax(curvelist, min, max):
@@ -2451,16 +2271,8 @@ def xminmax(curvelist, min, max):
         curves.append(curvelist)
 
     for c in curves:
-        nx = []
-        ny = []
-
-        for i in range(len(c.x)):
-            if float(min) <= c.x[i] <= float(max):
-                nx.append(c.x[i])
-                ny.append(c.y[i])
-
-        c.x = np.array(nx)
-        c.y = np.array(ny)
+        c.x = c.x[np.where(np.logical_and(c.x >= float(min), c.x <= float(max)))]
+        c.y = c.y[np.where(np.logical_and(c.x >= float(min), c.x <= float(max)))]
 
 
 def ymax(curvelist, max):
@@ -2481,16 +2293,8 @@ def ymax(curvelist, max):
         curves.append(curvelist)
 
     for c in curves:
-        nx = []
-        ny = []
-
-        for i in range(len(c.y)):
-            if c.y[i] <= float(max):
-                nx.append(c.x[i])
-                ny.append(c.y[i])
-
-        c.x = np.array(nx)
-        c.y = np.array(ny)
+        c.x = c.x[np.where(c.y <= float(max))]
+        c.y = c.y[np.where(c.y <= float(max))]
 
 
 def ymin(curvelist, min):
@@ -2511,16 +2315,8 @@ def ymin(curvelist, min):
         curves.append(curvelist)
 
     for c in curves:
-        nx = []
-        ny = []
-
-        for i in range(len(c.y)):
-            if c.y[i] >= float(min):
-                nx.append(c.x[i])
-                ny.append(c.y[i])
-
-        c.x = np.array(nx)
-        c.y = np.array(ny)
+        c.x = c.x[np.where(c.y >= float(min))]
+        c.y = c.y[np.where(c.y >= float(min))]
 
 
 def yminmax(curvelist, min, max):
@@ -2543,16 +2339,8 @@ def yminmax(curvelist, min, max):
         curves.append(curvelist)
 
     for c in curves:
-        nx = []
-        ny = []
-
-        for i in range(len(c.y)):
-            if float(min) <= c.y[i] <= float(max):
-                nx.append(c.x[i])
-                ny.append(c.y[i])
-
-        c.x = np.array(nx)
-        c.y = np.array(ny)
+        c.x = c.x[np.where(np.logical_and(c.y >= float(min), c.y <= float(max)))]
+        c.y = c.y[np.where(np.logical_and(c.y >= float(min), c.y <= float(max)))]
 
 
 def yn(curvelist, n):
@@ -2961,32 +2749,24 @@ def getymax(c, xmin=None, xmax=None):
              list -- a list of tuples where each tuple contains the x-value and
              the max y-value.
     """
-    try:
-        if xmin is not None:
-            r = __get_sub_range(c.x, xmin, xmax)
-            ymax = max(c.y[r[0]:r[1] + 1])
-        else:
-            ymax = max(c.y)
-            r = [0, len(c.x) - 1]
-    except:
-        pass
+    xl = c.x[0] if xmin is None else xmin
+    xr = c.x[-1] if xmax is None else xmax
+    domain = list(c.x[np.where(np.logical_and(c.x >= xl, c.x <= xr))])
+    domain.extend([xl, xr])
+    domain = list(set(domain))
+    domain.sort()
+    y_interp = np.interp(domain, c.x, c.y,
+                         left=c.math_interp_left,
+                         right=c.math_interp_right,
+                         period=c.math_interp_period)
 
-    if r[0] >= r[1]:
-        # User range is in between actual curve points
-        # c.x val1 val2 c.x
-        xl = c.x[0] if xmin is None else xmin
-        xr = c.x[-1] if xmax is None else xmax
-        range_x = np.linspace(xl, xr, num=1000)
-        y_interp = np.interp(range_x, c.x, c.y)
-        ymax = max(y_interp)
+    indices = np.where(y_interp == np.max(y_interp))[0]
 
-        # User range has only one curve point in between
-        # val1 c.x val2
-        if r[0] == r[1] and c.y[r[0]] > ymax:  # Local max
-            ymax = c.y[r[0]]
-    xy_pairs_at_max = getx(c, ymax, xmin, xmax)
+    xypairs = list()
+    for index in indices:
+        xypairs.append((domain[index], y_interp[index]))
 
-    return __toCurveString(c), xy_pairs_at_max
+    return __toCurveString(c), xypairs
 
 
 def getymin(c, xmin=None, xmax=None):
@@ -3003,33 +2783,24 @@ def getymin(c, xmin=None, xmax=None):
              list -- a list of tuples where each tuple contains the x-value and
              the min y-value.
     """
-    try:
-        if xmin is not None:
-            r = __get_sub_range(c.x, xmin, xmax)
-            ymin = min(c.y[r[0]:r[1] + 1])
-        else:
-            ymin = min(c.y)
-            r = [0, len(c.x) - 1]
-    except:
-        pass
+    xl = c.x[0] if xmin is None else xmin
+    xr = c.x[-1] if xmax is None else xmax
+    domain = list(c.x[np.where(np.logical_and(c.x >= xl, c.x <= xr))])
+    domain.extend([xl, xr])
+    domain = list(set(domain))
+    domain.sort()
+    y_interp = np.interp(domain, c.x, c.y,
+                         left=c.math_interp_left,
+                         right=c.math_interp_right,
+                         period=c.math_interp_period)
 
-    if r[0] >= r[1]:
-        # User range is in between actual curve points
-        # c.x val1 val2 c.x
-        xl = c.x[0] if xmin is None else xmin
-        xr = c.x[-1] if xmax is None else xmax
-        range_x = np.linspace(xl, xr, num=1000)
-        y_interp = np.interp(range_x, c.x, c.y)
-        ymin = min(y_interp)
+    indices = np.where(y_interp == np.min(y_interp))[0]
 
-        # User range has only one curve point in between
-        # val1 c.x val2
-        if r[0] == r[1] and c.y[r[0]] < ymin:  # Local min
-            ymin = c.y[r[0]]
-
-    xy_pairs_at_min = getx(c, ymin, xmin, xmax)
+    xypairs = list()
+    for index in indices:
+        xypairs.append((domain[index], y_interp[index]))
 
-    return __toCurveString(c), xy_pairs_at_min
+    return __toCurveString(c), xypairs
 
 
 def cumsum(c1):
@@ -3630,13 +3401,8 @@ def errorbar(scur, cury1, cury2, curx1=None, curx2=None, mod=1):
     :type mod: int
     """
     ebar = [np.zeros(len(scur.x)), np.zeros(len(scur.x)), np.zeros(len(scur.x)), np.zeros(len(scur.x))]
-    lowy = list()
-    for i in range(len(scur.x)):
-        y = np.interp(scur.x[i], cury1.x, cury1.y)
-        if scur.y[i] - y <= 0:
-            lowy.append(y)
-        else:
-            lowy.append(scur.y[i])
+    y = np.interp(scur.x, cury1.x, cury1.y)
+    lowy = np.where(scur.y - y <= 0, y, scur.y)
 
     ebar[0] = np.array(lowy)
     ebar[1] = np.interp(scur.x, cury2.x, cury2.y)
@@ -3942,7 +3708,7 @@ def getx(c, value, xmin=None, xmax=None):
     else:
 
         # User range is in between actual curve points
-        # c.x val1 val2 c.x
+        # c.x xmin xmax c.x
         xl = c.x[0] if xmin is None else xmin
         xr = c.x[-1] if xmax is None else xmax
         range_x = np.linspace(xl, xr, num=1000)
@@ -3952,7 +3718,7 @@ def getx(c, value, xmin=None, xmax=None):
                 xypairs.append((x, y))
 
         # User range has only one curve point in between
-        # val1 c.x val2
+        # xmin c.x xmax
         if r[0] == r[1]:
             if c.y[r[0]] == float(value):  # value exists in curve
                 xypairs.append((c.x[r[0]], float(value)))
@@ -3978,27 +3744,10 @@ def gety(c, value):
     """
     xypairs = list()
 
-    # if float(value) < np.amin(c.x) or float(value) > np.amax(c.x):
-    # raise ValueError, 'x-value out of range'
-
-    for i in range(len(c.x)):
-        if float(value) < np.amin(c.x):
-            xypairs.append((float(value), 0))   # c.y[0]))
-        elif float(value) > np.amax(c.x):
-            xypairs.append((float(value), 0))   # c.y[-1]))
-        elif c.x[i] == float(value):
-            xypairs.append((float(value), c.y[i]))
-        else:
-            xmax = c.x[i]
-            if i + 1 < len(c.x):
-                xmax = c.x[i + 1]
-
-            if c.x[i] < float(value) < xmax:
-                y = np.interp(float(value), [c.x[i], xmax], [c.y[i], c.y[i + 1]])
-                xypairs.append((float(value), y))
-            elif xmax < float(value) < c.x[i]:
-                y = np.interp(float(value), [xmax, c.x[i]], [c.y[i + 1], c.y[i]])
-                xypairs.append((float(value), y))
+    xypairs.append((float(value), np.interp(float(value), c.x, c.y,
+                                            left=c.math_interp_left,
+                                            right=c.math_interp_right,
+                                            period=c.math_interp_period)))
 
     return xypairs
 
@@ -4185,15 +3934,9 @@ def sort(curve):
     :type curve: Curve
     """
     index_array = np.argsort(curve.x)
-    x = list()
-    y = list()
-
-    for index in index_array:
-        x.append(curve.x[index])
-        y.append(curve.y[index])
 
-    curve.x = np.array(x)
-    curve.y = np.array(y)
+    curve.x = curve.x[index_array]
+    curve.y = curve.y[index_array]
 
 
 def rev(curve):
@@ -4225,8 +3968,7 @@ def random(curve):
     :param curve: The curve to sort
     :type curve: Curve
     """
-    for i in range(len(curve.y)):
-        curve.y[i] = sysrand.uniform(-1, 1)
+    curve.y = np.random.uniform(-1, 1, len(curve.y))
 
 
 def xindex(curvelist):
@@ -4313,21 +4055,16 @@ def max_curve(curvelist):
 
     # Calculate max
     x = np.array(ux)
-    y = np.zeros(len(x))
 
-    for i in range(len(x)):
-        y[i] = float(-sys.maxsize - 1)
-        for j in range(len(curvelist)):
-            try:
-                vals = gety(curvelist[j], x[i])
-                for val in vals:
-                    if y[i] < val[1]:
-                        y[i] = val[1]
-            except:
-                pass
+    all_data = []
+    for cur in curvelist:
+        all_data.append(np.interp(x, cur.x, cur.y,
+                                  left=cur.math_interp_left,
+                                  right=cur.math_interp_right,
+                                  period=cur.math_interp_period))
 
     nc = makecurve(x=x,
-                   y=y,
+                   y=np.max(all_data, axis=0),
                    name='Max(' + name_suffix + ')')
 
     return nc
@@ -4359,21 +4096,16 @@ def min_curve(curvelist):
 
     # Calculate min
     x = np.array(ux)
-    y = np.zeros(len(x))
 
-    for i in range(len(x)):
-        y[i] = float(sys.maxsize)
-        for j in range(len(curvelist)):
-            try:
-                vals = gety(curvelist[j], x[i])
-                for val in vals:
-                    if y[i] > val[1]:
-                        y[i] = val[1]
-            except:
-                pass
+    all_data = []
+    for cur in curvelist:
+        all_data.append(np.interp(x, cur.x, cur.y,
+                                  left=cur.math_interp_left,
+                                  right=cur.math_interp_right,
+                                  period=cur.math_interp_period))
 
     nc = makecurve(x=x,
-                   y=y,
+                   y=np.min(all_data, axis=0),
                    name='Min(' + name_suffix + ')')
 
     return nc
@@ -4404,23 +4136,16 @@ def average_curve(curvelist):
 
     # Calculate average
     x = np.array(ux)
-    y = np.zeros(len(x))
 
-    for i in range(len(x)):
-        cnt = 0
-        for j in range(len(curvelist)):
-            try:
-                vals = gety(curvelist[j], x[i])
-                for val in vals:
-                    y[i] += val[1]
-                    cnt += 1
-            except:
-                pass
-
-        y[i] /= cnt
+    all_data = []
+    for cur in curvelist:
+        all_data.append(np.interp(x, cur.x, cur.y,
+                                  left=cur.math_interp_left,
+                                  right=cur.math_interp_right,
+                                  period=cur.math_interp_period))
 
     nc = makecurve(x=x,
-                   y=y,
+                   y=np.mean(all_data, axis=0),
                    name='Average(' + name_suffix + ')')
 
     return nc
@@ -4471,10 +4196,7 @@ def __ifft(cr, ci):
     :type c: Curve
     :return: tuple - two curves, one with the real part and the other with the imaginary part for their y-values.
     """
-    carray = np.zeros(len(cr.y), dtype=complex)
-
-    for i in range(len(cr.y)):
-        carray[i] = complex(cr.y[i], ci.y[i])
+    carray = cr.y + 1j * ci.y
 
     numpy1_10 = LooseVersion(np.__version__) >= LooseVersion("1.10.0")
 
@@ -4659,6 +4381,172 @@ def __loadpdb(fname, fpdb):
     return curvelist
 
 
+def _get_linelocs_from_text_ultra_grep(fname):
+
+    # first find all the character offsets of the # lines in the ULTRA file
+    stdout_val = subprocess.check_output(['/usr/bin/grep',
+                                          '--byte-offset',
+                                          '--only-matching',
+                                          '--text',
+                                          '^#',
+                                          fname],
+                                         stderr=subprocess.STDOUT).decode('utf8')
+    locs = [int(line.strip().split(':')[0]) for line in stdout_val.split('\n')[:-1]]  # last is just empty newline
+
+    # now get the last character offset in the ULTRA file
+    stdout_val = subprocess.check_output(['/usr/bin/wc',
+                                          '-c',
+                                          fname],
+                                         stderr=subprocess.PIPE).decode('utf8')
+    locs.append(int(stdout_val.split()[0]))  # append end of file byte location
+
+    return locs
+
+
+def _get_linelocs_from_text_ultra(fname):
+    # These are byte locations not actual line locations, each standard ASCII character is one byte.
+
+    with open(fname, 'r') as openfile:
+
+        loc = 0  # byte tracker for whole file
+        locs = []  # location list of titles or comments
+
+        for line in openfile:
+
+            if line.strip()[:1] == '#':  # title or comment
+                locs.append(loc)  # append title or comment byte location to location list
+
+            loc += len(line)  # add number of bytes in line to byte tracker
+
+        locs.append(loc)  # append end of file byte location to location list
+
+        return locs
+
+
+def _get_curve_from_text_ultra_perproc(input_tuple):
+    fname, locs, idx, regex = input_tuple
+
+    # Defaults
+    xlabel = ''
+    ylabel = ''
+    step = False
+    step_original_x = np.empty(0)
+    step_original_y = np.empty(0)
+    xticks_labels = {}
+
+    try:
+        with open(fname, 'r') as openfile:
+
+            # Finds byte location
+            openfile.seek(locs[idx])
+
+            # ONLY reads content of single curve based on byte location
+            content = openfile.read(locs[idx + 1] - locs[idx])
+
+            # Creates a list of lines that splits on newline and creates x y pairs
+            lcont = list(filter(lambda line: len(line) > 0, map(lambda line: line.strip(), content.split('\n'))))
+
+            if len(lcont) < 2:  # at least one data point
+                return None
+
+            ##############
+            # Curve name #
+            ##############
+            name = lcont[0].split("# xlabel")[0].split("# ylabel")[0].split("#xlabel")[0].split("#ylabel")[0][1:].strip() # noqae501
+            if regex:
+                if regex.search(name):
+                    print(f'Found match: {name}')
+                else:
+                    return None
+
+            #################
+            # x and y label #
+            #################
+            split_line_label = re.split(r'#', str.strip(lcont[0]))
+            for split in split_line_label:
+                if re.search('[a-zA-Z]', split):
+                    if 'xlabel' in split:
+                        xlabel = split.replace('xlabel', '').strip()
+                    if 'ylabel' in split:
+                        ylabel = split.replace('ylabel', '').strip()
+
+            ########
+            # DATA #
+            ########
+
+            # xticklabel or horizontal data
+            if len(lcont[1].split()) > 2:
+
+                # horizontal data see tests/diff_formats.txt format 3a and format 3b
+                try:
+
+                    float(lcont[1].rsplit(None, 1)[0].split()[0])
+
+                    # Split the horizontal data into x y pairs
+                    pairs = []
+                    for line in lcont[1:]:
+                        numbers = [x for x in line.split() if x]
+                        line_pairs = ['{} {}'.format(numbers[i], numbers[i + 1]) for i in range(0, len(numbers), 2)]
+                        pairs.extend(line_pairs)
+
+                    lcont = [lcont[0]]
+                    lcont.extend(pairs)
+
+                # X tick label data see tests/diff_formats.txt My curve6
+                except ValueError:
+                    pass
+
+            # Splits newline x y pairs into individual x y
+            if lcont[-1] != 'end':
+                v = [item for s in lcont[1:] for item in s.rsplit(None, 1)]
+            else:
+                v = [item for s in lcont[1:-1] for item in s.rsplit(None, 1)]
+
+            xvals = v[::2]
+            yvals = v[1::2]
+
+            # Numerical data
+            try:
+                float(xvals[0])
+
+            # X tick label data
+            except:
+
+                xticks = list(set(xvals))
+                xticks.sort()
+                xticks_dict = {}
+
+                for i, xtick in enumerate(xticks):
+                    xticks_dict[xtick] = i
+
+                xvals = [xticks_dict[xtick] for xtick in xvals]
+
+                xticks_labels = xticks_dict
+
+            # Step Data
+            if len(xvals) != len(yvals):
+                step_original_x = np.array(xvals, dtype=float)
+                step_original_y = np.array(yvals, dtype=float)
+
+                yvals.append(yvals[-1])
+                xvals = np.array(xvals, dtype=float).repeat(2)[1:]
+                yvals = np.array(yvals, dtype=float).repeat(2)[:-1]
+                step = True
+
+            # Numerical Data
+            else:
+                xvals = np.array(xvals, dtype=float)
+                yvals = np.array(yvals, dtype=float)
+
+            return makecurve(x=xvals, y=yvals, name=name, filename=fname,
+                             xlabel=xlabel, ylabel=ylabel,
+                             step=step, step_original_x=step_original_x, step_original_y=step_original_y,
+                             xticks_labels=xticks_labels)
+    except Exception as e:
+        print(str(e))
+        return None
+
+
 ########################################################
 ################# Curve Comparisons ####################  # noqa e266
 ########################################################

llnl_pydv-3.7.0/pydv/scripts/date.txt

@@ -0,0 +1 @@
+07.07.2025

llnl_pydv-3.7.0/pydv/scripts/version.txt

@@ -0,0 +1 @@
+3.7.0

{llnl_pydv-3.6.3 → llnl_pydv-3.7.0}/pyproject.toml

@@ -1,7 +1,7 @@
 [tool]
 [tool.poetry]
 name = "LLNL-PyDV"
-version = "3.6.3"
+version = "3.7.0"
 description = "PyDV: Python Data Visualizer"
 license = "BSD"
 classifiers = [
@@ -65,7 +65,7 @@ build-backend = "poetry.core.masonry.api"
 line-length = 79
 
 [tool.bumpver]
-current_version = "3.6.3"
+current_version = "3.7.0"
 version_pattern = "MAJOR.MINOR.PATCH"
 commit_message = "bump version {old_version} -> {new_version}"
 commit = true

llnl_pydv-3.6.3/pydv/scripts/date.txt

@@ -1 +0,0 @@
-04.14.2025

llnl_pydv-3.6.3/pydv/scripts/version.txt

@@ -1 +0,0 @@
-3.6.3