gwsumm 2.2.0__tar.gz → 2.2.2__tar.gz

{gwsumm-2.2.0 → gwsumm-2.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: gwsumm
-Version: 2.2.0
+Version: 2.2.2
 Summary: A python toolbox used by the LIGO Scientific Collaboration for detector characterisation
 Author-email: Alex Urban <alex.urban@ligo.org>, Duncan Macleod <duncan.macleod@ligo.org>
 Maintainer-email: Evan Goetz <evan.goetz@ligo.org>

{gwsumm-2.2.0 → gwsumm-2.2.2}/gwsumm/_version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '2.2.0'
-__version_tuple__ = version_tuple = (2, 2, 0)
+__version__ = version = '2.2.2'
+__version_tuple__ = version_tuple = (2, 2, 2)

{gwsumm-2.2.0 → gwsumm-2.2.2}/gwsumm/archive.py

@@ -176,6 +176,8 @@ def write_data_archive(outfile, channels=True, timeseries=True,
 
         # moves the new file to the backup directory
         shutil.move(temp_outfile, outfile)
+        # Changes permission to allow reading from any user
+        os.chmod(outfile, 0o664)
 
     except Exception:
         # if it fails for any reason, raise and continue

{gwsumm-2.2.0 → gwsumm-2.2.2}/gwsumm/channels.py

@@ -32,7 +32,7 @@ from .utils import re_quote
 
 __author__ = 'Duncan Macleod <duncan.macleod@ligo.org>'
 
-NDS2_TYPES = Nds2ChannelType.names()
+NDS2_TYPES = Nds2ChannelType.nds2names()
 CIS_URL = 'https://cis.ligo.org'
 re_channel = re.compile(r'[A-Z]\d:[a-zA-Z0-9]+'  # core channel section L1:TEST
                         r'(?:[-_][a-zA-Z0-9_]+)?'  # underscore-delimited parts

{gwsumm-2.2.0 → gwsumm-2.2.2}/gwsumm/plot/__init__.py

@@ -80,6 +80,7 @@ from .segments import (
     ODCDataPlot,
     SegmentPiePlot,
     NetworkDutyPiePlot,
+    NetworkDutyBarPlot,
     SegmentBarPlot,
     SegmentHistogramPlot,
 )
@@ -98,6 +99,7 @@ from .range import (
     RangeSpectrogramDataPlot,
     RangeSpectrumDataPlot,
     RangeCumulativeSpectrumDataPlot,
+    RangeCumulativeHistogramPlot,
     SimpleTimeVolumeDataPlot,
     GWpyTimeVolumeDataPlot,
 )

{gwsumm-2.2.0 → gwsumm-2.2.2}/gwsumm/plot/builtin.py

@@ -710,15 +710,14 @@ class TimeSeriesHistogramPlot(DataPlot):
 
         # plot
         for ax, arr, pargs in zip(cycle(axes), data, histargs):
-            # set range if not given
-            if pargs.get('range') is None:
-                pargs['range'] = self._get_range(
-                    data,
-                    # use range from first dataset if already calculated
-                    range=histargs[0].get('range'),
-                    # use xlim if manually set (user or INI)
-                    xlim=None if ax.get_autoscalex_on() else ax.get_xlim(),
-                )
+            # set range
+            pargs['range'] = self._get_range(
+                data,
+                # use range from first dataset if already calculated
+                range=histargs[0].get('range'),
+                # use xlim if manually set (user or INI)
+                xlim=None if ax.get_autoscalex_on() else ax.get_xlim(),
+            )
 
             # plot histogram
             _, _, patches = ax.hist(arr, **pargs)
@@ -759,8 +758,23 @@ class TimeSeriesHistogramPlot(DataPlot):
         return self.finalize(outputfile=outputfile)
 
     def _get_range(self, data, range=None, xlim=None):
-        if range is not None or xlim is not None:
-            return range or xlim
+        if range is not None:
+            if range == 'autoscaling':
+                return None
+            else:
+                range = list(range)
+                try:
+                    if range[0] == 'min':
+                        range[0] = numpy.min(data)
+                    if range[1] == 'max':
+                        range[1] = numpy.max(data)
+                    if range[0] < range[1]:
+                        return range
+                except (ValueError, IndexError) as exc:
+                    if not str(exc).startswith('zero-size array'):
+                        raise
+        if xlim is not None:
+            return xlim
         try:
             return numpy.min(data), numpy.max(data)
         except ValueError as exc:

{gwsumm-2.2.0 → gwsumm-2.2.2}/gwsumm/plot/core.py

@@ -212,7 +212,41 @@ class DataPlot(SummaryPlot):
     #: plot() call style
     _single_call = False
     #: dict of default plotting kwargs
-    defaults = {}
+    defaults = {
+        'animation.convert_args': ['-layers', 'OptimizePlus'],
+        'axes.axisbelow': False,
+        'axes.edgecolor': 'gray',
+        'axes.formatter.limits': [-3, 4],
+        'axes.formatter.use_mathtext': True,
+        'axes.grid': True,
+        'axes.labelpad': 5.0,
+        'axes.labelsize': 18.0,
+        'axes.titlesize': 22.0,
+        'contour.algorithm': 'mpl2014',
+        'figure.figsize': [12.0, 6.0],
+        'figure.labelsize': 'large',
+        'figure.labelweight': 'normal',
+        'font.sans-serif': ['Roboto'],
+        'grid.alpha': 0.5,
+        'grid.linewidth': 0.5,
+        'legend.edgecolor': 'inherit',
+        'legend.fancybox': False,
+        'legend.fontsize': 10.0,
+        'legend.handlelength': 1.0,
+        'legend.numpoints': 2,
+        'mathtext.bf': 'Roboto',
+        'mathtext.cal': 'Calligraffiti',
+        'mathtext.fontset': 'custom',
+        'mathtext.it': 'Roboto:italic',
+        'mathtext.rm': 'Roboto',
+        'mathtext.sf': 'Roboto',
+        'mathtext.tt': 'Roboto Slab',
+        'savefig.transparent': True,
+        'svg.fonttype': 'none',
+        'text.parse_math': True,
+        'xtick.labelsize': 14.0,
+        'ytick.labelsize': 14.0,
+    }
     #: list of parameters parsed for `plot()` calls
     DRAW_PARAMS = list(putils.ARTIST_PARAMS)
 

{gwsumm-2.2.0 → gwsumm-2.2.2}/gwsumm/plot/range.py

@@ -153,6 +153,23 @@ class RangeDataHistogramPlot(RangePlotMixin, get_plot('histogram')):
 register_plot(RangeDataHistogramPlot)
 
 
+class RangeCumulativeHistogramPlot(RangePlotMixin, get_plot('histogram')):
+    type = 'range-cumulative-histogram'
+    defaults = get_plot('histogram').defaults.copy()
+    defaults.update(RangePlotMixin.defaults.copy())
+    defaults.update({
+        'xlabel': 'Angle-averaged range [Mpc]',
+        'ylabel': 'Cumulative time duration',
+        'log': False,
+        'cumulative': True,
+        'density': True,
+        'range': (1, 'max'),
+    })
+
+
+register_plot(RangeCumulativeHistogramPlot)
+
+
 class RangeSpectrogramDataPlot(RangePlotMixin, get_plot('spectrogram')):
     type = 'range-spectrogram'
     defaults = get_plot('spectrogram').defaults.copy()

{gwsumm-2.2.0 → gwsumm-2.2.2}/gwsumm/plot/segments.py

@@ -1,5 +1,6 @@
 # -*- coding: utf-8 -*-
 # Copyright (C) Duncan Macleod (2013)
+#               Evan Goetz (2023)
 #
 # This file is part of GWSumm.
 #
@@ -31,7 +32,7 @@ from dateutil.relativedelta import relativedelta
 
 from matplotlib import rcParams
 from matplotlib.artist import setp
-from matplotlib.colors import (rgb2hex, is_color_like)
+from matplotlib.colors import (rgb2hex, is_color_like, TABLEAU_COLORS)
 from matplotlib.patches import Rectangle
 
 from glue import iterutils
@@ -1006,15 +1007,54 @@ class SegmentPiePlot(PiePlot, SegmentDataPlot):
         wedgeargs = self.parse_wedge_kwargs()
         plotargs = self.parse_plot_kwargs()
 
+        # Boolean logic flags to determine if this code is currently running:
+        # - before the span of interest (current time the code is running <
+        #   start of span)
+        # - after the span of interest (current time the code is running >= end
+        #   of span)
+        # - during the span of interest (any other time)
+        # The flag is set to True for the appropriate noun (before, during, or
+        # after).
+        # These flags are then used to set plot titles and labels and determine
+        # if there is any missing data.
+        before = during = after = False
+        if globalv.NOW < int(self.span[0]):
+            before = True
+        elif globalv.NOW >= int(self.span[1]):
+            after = True
+        else:
+            during = True
+
         # use state to generate suptitle with GPS span
+        # this will be different depending on if `include_future` is given
+        # as an option or whether running before, during, or after the time
+        # interval requested
         if self.state:
-            self.pargs.setdefault(
-                'suptitle',
-                '[%s-%s, state: %s]' % (self.span[0], self.span[1],
-                                        texify(str(self.state))))
+            if future or after:
+                self.pargs.setdefault(
+                    'suptitle',
+                    (f'[{self.span[0]}-{self.span[1]}, '
+                     f'state: {texify(str(self.state))}]'))
+            elif before:
+                self.pargs.setdefault(
+                    'suptitle',
+                    (f'[{self.span[0]}-{self.span[0]}, '
+                     f'state: {texify(str(self.state))}]'))
+            else:
+                self.pargs.setdefault(
+                    'suptitle',
+                    (f'[{self.span[0]}-{globalv.NOW}, '
+                     f'state: {texify(str(self.state))}]'))
         else:
-            self.pargs.setdefault(
-                'suptitle', '[%s-%s]' % (self.span[0], self.span[1]))
+            if future or after:
+                self.pargs.setdefault(
+                    'suptitle', f'[{self.span[0]}-{self.span[1]}]')
+            elif before:
+                self.pargs.setdefault(
+                    'suptitle', f'[{self.span[0]}-{self.span[0]}]')
+            else:
+                self.pargs.setdefault(
+                    'suptitle', f'[{self.span[0]}-{globalv.NOW}]')
 
         # get segments
         data = []
@@ -1028,12 +1068,39 @@ class SegmentPiePlot(PiePlot, SegmentDataPlot):
                                 padding=self.padding).coalesce()
             data.append(float(abs(segs.active)))
 
-        # handle missing or future data
+        # handle missing (undefined) segments
+        # if running before then all the time is future because segments
+        # haven't been generated
+        # if running after then some segments may not cover the whole time
+        # if during, it is somewhere in between
         total = float(sum(data))
-        if future or (total < alltime):
-            data.append(alltime - total)
+        undefined = future_seg = 0
+        if before:
+            future_seg = alltime
+        elif after:
+            undefined = alltime - total
+        elif during:
+            future_seg = int(self.span[1]) - globalv.NOW
+            undefined = alltime - future_seg - total
+            current_total = globalv.NOW - int(self.span[0])
+
+        # figure out the extra pieces to include in the pie chart and labels
+        # TODO: There is something messed up about "labels" and
+        #       "label" that should be cleaned up
+        if undefined > 0:
+            data.append(undefined)
+            if 'labels' in plotargs:
+                plotargs['labels'] = list(plotargs['labels']) + ['Undefined']
+            elif 'label' in plotargs:
+                plotargs['label'] = list(plotargs['label']) + ['Undefined']
+            if 'colors' in plotargs:
+                plotargs['colors'] = list(plotargs['colors']) + ['black']
+        if future or before:
+            data.append(future_seg)
             if 'labels' in plotargs:
                 plotargs['labels'] = list(plotargs['labels']) + [' ']
+            elif 'label' in plotargs:
+                plotargs['label'] = list(plotargs['label']) + [' ']
             if 'colors' in plotargs:
                 plotargs['colors'] = list(plotargs['colors']) + ['white']
 
@@ -1058,7 +1125,12 @@ class SegmentPiePlot(PiePlot, SegmentDataPlot):
                 pclabels.append(label)
             else:
                 try:
-                    pc = d / (total if future else alltime) * 100
+                    if future or after:
+                        pc = d / alltime * 100
+                    elif during:
+                        pc = d / current_total * 100
+                    else:
+                        pc = 0.0
                 except ZeroDivisionError:
                     pc = 0.0
                 pclabels.append(texify(
@@ -1150,28 +1222,45 @@ class NetworkDutyPiePlot(SegmentPiePlot):
         # construct compound flags for each network size
         flags = dict((f[:2], f) for f in self.flags)
         network = ''.join(sorted(set(flags)))
-        self.pargs.setdefault('title', '%s network duty factor' % network)
+        self.pargs.setdefault('title', f'{network} network duty factor')
         networkflags = []
         colors = []
         labels = []
+        # define an exclude DQ flag so that each subsequent time through
+        # We exclude triple time from double time and double time from single
+        # time
         exclude = DataQualityFlag()
         for i in list(range(len(flags)+1))[::-1]:
             name = self.NETWORK_NAME[i]
-            flag = '%s:%s' % (network, name)
+            flag = f'{network}:{name}'
             networksegs = DataQualityFlag(flag, known=valid)
+            # loop over the possible combinations inserting the flag to the
+            # network segments dictionary
             for ifoset in combinations(flags, i):
                 if not ifoset:
-                    compound = '!%s' % '!'.join(list(flags.values()))
+                    compound = f"!{'!'.join(list(flags.values()))}"
                 else:
                     compound = '&'.join(flags[ifo] for ifo in ifoset)
-                segs = get_segments(compound, validity=valid, query=False,
-                                    padding=self.padding).coalesce()
+                segs = get_segments(
+                    compound, validity=valid, query=False,
+                    padding=self.padding, ignore_undefined=True).coalesce()
                 networksegs += segs
+            # Final step in the loop for no detectors: if not wanting to plot
+            # future times, then exclude the time from now to the end of the
+            # span from the no detector network
+            if (i == 0 and
+                    not self.pargs.get('include_future', False) and
+                    globalv.NOW < self.span[1]):
+                exclude.active += SegmentList(
+                    [Segment(globalv.NOW, self.span[1])])
+            # insert this flag into the segments global variable and exclude
+            # any of the previous network (more detectors) time from this time
             globalv.SEGMENTS[flag] = networksegs.copy()
             globalv.SEGMENTS[flag].active -= exclude.active
+            # update the segements of times to exclude
             exclude = networksegs
             networkflags.append(flag)
-            labels.append('%s interferometer' % name.title())
+            labels.append(f'{name.title()} interferometer')
             colors.append(self.NETWORK_COLOR.get(name))
 
         self.pargs.setdefault('colors', colors)
@@ -1197,7 +1286,6 @@ class SegmentBarPlot(BarPlot, SegmentDataPlot):
         'color': GREEN,
         'edgecolor': 'green',
         'alpha': .6,
-        'align': 'edge',  # FIXME, updated for mpl 2.0, can simplify code
     }
     SCALE_UNIT = {
         None: 'seconds',
@@ -1208,17 +1296,24 @@ class SegmentBarPlot(BarPlot, SegmentDataPlot):
     }
 
     def draw(self, outputfile=None):
+        # Check if ylabel has been previously defined
+        # to avoid overwriting it
+        if 'ylabel' in self.pargs:
+            set_ylabel = False
+        else:
+            set_ylabel = True
+
         plot = self.init_plot(projection='rectilinear')
         ax = plot.gca()
 
         if self.state:
             self.pargs.setdefault(
                 'suptitle',
-                '[%s-%s, state: %s]' % (self.span[0], self.span[1],
-                                        texify(str(self.state))))
+                f'[{self.span[0]}-{self.span[1]},'
+                f'state: {texify(str(self.state))}]')
         else:
             self.pargs.setdefault(
-                'suptitle', '[%s-%s]' % (self.span[0], self.span[1]))
+                'suptitle', f'[{self.span[0]}-{self.span[1]}]')
         suptitle = self.pargs.pop('suptitle', None)
         if suptitle:
             plot.suptitle(suptitle, y=0.993, va='top')
@@ -1228,11 +1323,13 @@ class SegmentBarPlot(BarPlot, SegmentDataPlot):
             self.pargs.setdefault('ylim', (0, 100))
         elif isinstance(scale, (int, float)):
             self.pargs.setdefault('ylim', (0, abs(self.span) / scale))
-        try:
-            self.pargs.setdefault('ylabel', 'Livetime [%s]'
-                                  % self.SCALE_UNIT[scale])
-        except KeyError:
-            self.pargs.setdefault('ylabel', 'Livetime')
+
+        if set_ylabel:
+            try:
+                self.pargs.setdefault('ylabel',
+                                      f'Livetime [{self.SCALE_UNIT[scale]}]')
+            except KeyError:
+                self.pargs.setdefault('ylabel', 'Livetime')
 
         # extract plotting arguments
         sort = self.pargs.pop('sorted', False)
@@ -1263,7 +1360,7 @@ class SegmentBarPlot(BarPlot, SegmentDataPlot):
 
         # make bar chart
         width = plotargs.pop('width', .8)
-        x = numpy.arange(len(data)) - width/2.
+        x = numpy.arange(len(data))
         ax.bar(x, data, width=width, **plotargs)
 
         # set labels
@@ -1287,6 +1384,105 @@ class SegmentBarPlot(BarPlot, SegmentDataPlot):
 register_plot(SegmentBarPlot)
 
 
+class NetworkDutyBarPlot(SegmentBarPlot):
+
+    """Special case of the `SegmentPiePlot` for network duty factors.
+    """
+    type = 'network-duty-segment-bar'
+    NETWORK_NAME = {
+        0: 'no',
+        1: 'single',
+        2: 'double',
+        3: 'triple',
+        4: 'quadruple',
+        5: 'quintuple',
+        6: 'sextuple',
+    }
+    NETWORK_COLOR = GW_OBSERVATORY_COLORS.copy()
+    defaults = SegmentBarPlot.defaults.copy()
+    # remove SegmentBarPlot default colors as they overwrite
+    # the ones defined later.
+    defaults.pop('color')
+    defaults.pop('edgecolor')
+    defaults.update({
+        'title': 'Network duty factor',
+        'ylabel': 'Duty factor [%]',
+    })
+
+    def draw(self):
+        # get segments
+        if self.state and not self.all_data:
+            valid = self.state.active
+        else:
+            valid = SegmentList([self.span])
+
+        # construct compound flags for each network size
+        flags = dict((f[:2], f) for f in self.flags)
+        # construct all possible network combinations
+        networks = {}
+        for size in range(1, len(flags) + 1):
+            ifocombs = combinations(sorted(set(flags)), size)
+            for ifocomb in ifocombs:
+                key = "".join(ifocomb)
+                networks[key] = (size, ifocomb)
+
+        networkflags = []
+        colors = []
+        labels = []
+        color_id = 0
+        for network, values in networks.items():
+            i = values[0]
+            ifoset = values[1]
+            name = self.NETWORK_NAME[i]
+            if i == 1:
+                # this avoid having a redundant X1:single
+                # in the Segment information table
+                flag = flags[network]
+
+            else:
+                flag = f'{network}:{name}'
+
+                networksegs = DataQualityFlag(flag, known=valid)
+                if not ifoset:
+                    compound = f"!{'!'.join(list(flags.values()))}"
+                else:
+                    compound = '&'.join(flags[ifo] for ifo in ifoset)
+
+                segs = get_segments(compound, validity=valid, query=False,
+                                    padding=self.padding).coalesce()
+                networksegs += segs
+                globalv.SEGMENTS[flag] = networksegs.copy()
+            combined_flag = flag.split(':')[0]
+            if flag.startswith(tuple(networks.keys())):
+                networkflags.append(flag)
+
+            labels.append(combined_flag)
+            if self.NETWORK_COLOR.get(combined_flag) is not None:
+                colors.append(self.NETWORK_COLOR.get(combined_flag))
+            else:
+                # if color is not defined, use standard matplotlib colors
+                colors.append(list(TABLEAU_COLORS.values())[color_id])
+                if color_id < len(TABLEAU_COLORS) - 1:
+                    color_id += 1
+                else:
+                    color_id = 0
+
+        self.pargs.setdefault('colors', colors)
+        self.pargs.setdefault('edgecolor', colors)
+        self.pargs.setdefault('labels', labels)
+
+        # reset flags and generate plot
+        flags_ = self.flags
+        outputfile = self.outputfile
+        self.flags = networkflags
+        out = super(NetworkDutyBarPlot, self).draw(outputfile=outputfile)
+        self.flags = flags_
+        return out
+
+
+register_plot(NetworkDutyBarPlot)
+
+
 class SegmentHistogramPlot(get_plot('histogram'), SegmentDataPlot):
     """Histogram of segment duration
     """

{gwsumm-2.2.0 → gwsumm-2.2.2}/gwsumm/segments.py

@@ -1,5 +1,6 @@
 # -*- coding: utf-8 -*-
 # Copyright (C) Duncan Macleod (2013)
+#               Evan Goetz (2023)
 #
 # This file is part of GWSumm.
 #
@@ -22,7 +23,6 @@
 import sys
 import operator
 import warnings
-from functools import reduce
 from collections import OrderedDict
 from configparser import (
     DEFAULTSECT,
@@ -34,7 +34,7 @@ from configparser import (
 from astropy.io.registry import IORegistryError
 
 from gwpy.segments import (DataQualityFlag, DataQualityDict,
-                           SegmentList, Segment)
+                           SegmentListDict, SegmentList, Segment)
 
 from . import globalv
 from .utils import (
@@ -56,7 +56,8 @@ SEGDB_URLS = [
 
 def get_segments(flag, validity=None, config=ConfigParser(), cache=None,
                  query=True, return_=True, coalesce=True, padding=None,
-                 segdb_error='raise', url=None, **read_kw):
+                 ignore_undefined=False, segdb_error='raise', url=None,
+                 **read_kw):
     """Retrieve the segments for a given flag
 
     Segments will be loaded from global memory if already defined,
@@ -97,6 +98,11 @@ def get_segments(flag, validity=None, config=ConfigParser(), cache=None,
         `(start, end)` padding with which to pad segments that are
         downloaded/read
 
+    ignore_undefined : `bool`, optional, default: `False`
+        Special case needed for network calculation compound flags so that
+        when this is True, DataQualityFlag.known values are set to the same
+        value as ``validity``
+
     segdb_error : `str`, optional, default: ``'raise'``
         how to handle errors returned from the segment database, one of
 
@@ -168,11 +174,12 @@ def get_segments(flag, validity=None, config=ConfigParser(), cache=None,
     for f in allflags:
         globalv.SEGMENTS.setdefault(f, DataQualityFlag(f))
 
-    # read segments from global memory and get the union of needed times
+    # read segments from global memory and get the intersection of needed times
     try:
-        old = reduce(
-            operator.and_,
-            (globalv.SEGMENTS.get(f, DataQualityFlag(f)).known for f in flags))
+        old = SegmentListDict()
+        for f in flags:
+            old[f] = globalv.SEGMENTS.get(f, DataQualityFlag(f)).known
+        old = SegmentList(old.intersection(flags))
     except TypeError:
         old = SegmentList()
     newsegs = validity - old
@@ -260,15 +267,17 @@ def get_segments(flag, validity=None, config=ConfigParser(), cache=None,
         for compound in flags:
             union, intersection, exclude, notequal = split_compound_flag(
                 compound)
-            if len(union + intersection) == 1:
-                out[compound].description = globalv.SEGMENTS[f].description
-                out[compound].padding = padding.get(f, (0, 0))
+            if len(f := (union + intersection)) == 1:
+                out[compound].description = globalv.SEGMENTS[f[0]].description
+                out[compound].padding = padding.get(f[0], (0, 0))
             for flist, op in zip([exclude, intersection, union, notequal],
                                  [operator.sub, operator.and_, operator.or_,
                                   not_equal]):
                 for f in flist:
                     pad = padding.get(f, (0, 0))
                     segs = globalv.SEGMENTS[f].copy()
+                    if ignore_undefined:
+                        segs.known = validity
                     if isinstance(pad, (float, int)):
                         segs = segs.pad(pad, pad)
                     elif pad is not None:

{gwsumm-2.2.0 → gwsumm-2.2.2}/gwsumm/tabs/data.py

@@ -266,7 +266,8 @@ class DataTab(ProcessedTab, ParentTab):
             if cp.has_section(pdef):
                 type_ = cp.get(pdef, 'type')
                 PlotClass = get_plot(type_)
-            elif (pdef not in ['range-histogram', 'segment-histogram'] and
+            elif (pdef not in ['range-histogram', 'segment-histogram',
+                               'range-cumulative-histogram'] and
                     pdef.endswith('-histogram')):
                 type_ = None
                 etg, column = pdef.rsplit('-', 2)[:2]

{gwsumm-2.2.0 → gwsumm-2.2.2}/gwsumm/tests/test_plot.py

@@ -27,7 +27,7 @@ from configparser import ConfigParser
 
 from gwpy.detector import ChannelList
 from gwpy.plot import Plot
-from gwpy.plot.tex import HAS_TEX
+from gwpy.plot.tex import has_tex
 from gwpy.segments import Segment
 
 from .. import plot as gwsumm_plot
@@ -250,7 +250,7 @@ class TestDataPlot(TestSummaryPlot):
         assert plot.channels == [get_channel('X1:TEST'),
                                  get_channel('Y1:TEST')]
         assert plot.pargs == {'marker': 'o'}
-        assert plot.rcParams == {'figure.figsize': (2, 1)}
+        assert plot.rcParams['figure.figsize'] == (2, 1)
 
         cp.set('plot', 'type', 'blah')
         with pytest.warns(UserWarning):
@@ -281,7 +281,7 @@ class TestDataPlot(TestSummaryPlot):
         pytest.param(
             True,
             [{'label': r'TEST\_WITH\_UNDERSCORE'}, {'label': r'TEST\_QUOTED'}],
-            marks=pytest.mark.skipif(not HAS_TEX,
+            marks=pytest.mark.skipif(not has_tex(),
                                      reason='TeX is not available'),
         ),
     ])

{gwsumm-2.2.0 → gwsumm-2.2.2}/gwsumm/triggers.py

@@ -243,6 +243,24 @@ def get_triggers(channel, etg, segments, config=GWSummConfigParser(),
                 else:
                     trigs = read_cache(segcache, SegmentList([segment]), etg,
                                        nproc=nproc, **read_kw)
+
+                # extend columns if possible to include bandwidth, central
+                # frequency, and duration
+                if trigs is not None:
+                    if 'fstart' in columns and 'fend' in columns:
+                        if 'bandwidth' not in columns:
+                            trigs.add_column(trigs['fend'] - trigs['fstart'],
+                                             name='bandwidth')
+                        if 'central_freq' not in columns:
+                            trigs.add_column(
+                                0.5*(trigs['fstart'] + trigs['fend']),
+                                name='central_freq')
+                    if ('tstart' in columns and
+                            'tend' in columns and
+                            'duration' not in columns):
+                        trigs.add_column(trigs['tend'] - trigs['tstart'],
+                                         name='duration')
+
                 # record triggers
                 if trigs is not None:
                     # add metadata
@@ -260,6 +278,14 @@ def get_triggers(channel, etg, segments, config=GWSummConfigParser(),
                 raise KeyError
             TableClass = get_etg_table(etg)
         except KeyError:  # build simple table
+            if 'fstart' in columns and 'fend' in columns:
+                for colval in ['bandwidth', 'central_freq']:
+                    if colval not in columns:
+                        columns.extend([colval])
+            if ('tstart' in columns and
+                    'tend' in columns and
+                    'duration' not in columns):
+                columns.extend(['duration'])
             tab = EventTable(names=columns)
         else:  # map to LIGO_LW table with full column listing
             tab = EventTable(lsctables.New(TableClass))

{gwsumm-2.2.0 → gwsumm-2.2.2}/gwsumm.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: gwsumm
-Version: 2.2.0
+Version: 2.2.2
 Summary: A python toolbox used by the LIGO Scientific Collaboration for detector characterisation
 Author-email: Alex Urban <alex.urban@ligo.org>, Duncan Macleod <duncan.macleod@ligo.org>
 Maintainer-email: Evan Goetz <evan.goetz@ligo.org>