Пример #1
0
def plottimeseries(series, outfile, t0=0, zeroline=False, **kwargs):
    """
    Plot a REALXTimeSeries.
    """
    # construct list of series
    if hasattr(series, "__contains__"):
        serieslist = series
    else:
        serieslist = [series]

    # get limits
    xlim = kwargs.pop("xlim", None)
    ylim = kwargs.pop("ylim", None)
    if xlim:
        start, end = xlim
    else:
        start = min(float(s.epoch) for s in serieslist)
        end = max(
            float(s.epoch + s.data.length * s.deltaT) for s in serieslist)

    # get axis scales
    logx = kwargs.pop("logx", False)
    logy = kwargs.pop("logy", False)

    # get legend loc
    loc = kwargs.pop("loc", 0)
    alpha = kwargs.pop("alpha", 0.8)

    # get colorbar options
    hidden_colorbar = kwargs.pop("hidden_colorbar", False)

    # get savefig option
    bbox_inches = kwargs.pop("bbox_inches", None)

    #
    # get labels
    #

    xlabel = kwargs.pop("xlabel", None)
    if xlabel:
        unit = 1
    if not xlabel:
        unit, timestr = plotutils.time_axis_unit(end - start)
        if not t0:
            t0 = start
        t0 = lal.LIGOTimeGPS(t0)
        if int(t0.gpsNanoSeconds) == 0:
            xlabel = datetime.datetime(*lal.GPSToUTC(int(t0))[:6])\
                         .strftime("%B %d %Y, %H:%M:%S %ZUTC")
            xlabel = "Time (%s) since %s (%s)" % (timestr, xlabel, int(t0))
        else:
            xlabel = datetime.datetime(*lal.GPSToUTC(t0.gpsSeconds)[:6])\
                          .strftime("%B %d %Y, %H:%M:%S %ZUTC")
            xlabel = "Time (%s) since %s (%s)"\
                     % (timestr,
                        xlabel.replace(" UTC",".%.3s UTC" % t0.gpsNanoSeconds),\
                        t0)
        t0 = float(t0)
    ylabel = kwargs.pop("ylabel", "Amplitude (counts)")
    title = kwargs.pop("title", "")
    subtitle = kwargs.pop("subtitle", "")

    #
    # set default line params
    #

    color = kwargs.pop("color", None)
    if isinstance(color, str):
        color = color.split(',')
        if len(color) == 1:
            color = [color[0]] * len(serieslist)
    kwargs2 = dict()
    kwargs2.update(kwargs)
    if kwargs.has_key("marker"):
        kwargs.setdefault("markersize", 5)
        kwargs2.setdefault("markersize", 2)
    else:
        kwargs.setdefault("linestyle", "-")
        kwargs.setdefault("linewidth", "1")
        kwargs2.setdefault("linewidth", "0.1")

    #
    # make plot
    #

    allnames = [s.name for s in serieslist]
    namedseries = [
        s for s in serieslist if not re.search("(min|max)\Z", s.name)
    ]

    plot = plotutils.SimplePlot(xlabel, ylabel, title, subtitle)
    for i,(series,c) in enumerate(itertools.izip(namedseries,\
                                                 plotutils.default_colors())):
        if color:
            c = color[serieslist.index(series)]
        x = numpy.arange(series.data.length) * series.deltaT +\
            float(series.epoch) - float(t0)
        x = x.astype(float)
        x /= unit
        d = series.data.data
        if logy and ylim:
            numpy.putmask(d, d == 0, ylim[0] - abs(ylim[0]) * 0.01)
        plot.add_content(x, d, color=c,\
                         label=plotutils.display_name(series.name), **kwargs)
        # find min/max and plot
        for i, name in enumerate(allnames):
            for ext in ["min", "max"]:
                if re.match("%s[- _]%s" % (re.escape(series.name), ext), name):
                    if color:
                        c = color[i]
                    series2 = serieslist[i]
                    x2 = numpy.arange(series2.data.length) * series2.deltaT\
                         + float(series2.epoch) - float(t0)
                    x2 /= unit
                    d2 = series2.data.data
                    if logy and ylim:
                        numpy.putmask(d2, d2 == 0,
                                      ylim[0] - abs(ylim[0]) * 0.01)
                    plot.ax.plot(x2, d2, color=c, **kwargs2)
                    plot.ax.fill_between(x2, d, d2, alpha=0.1,\
                                         color=c)

    # finalize
    plot.finalize(loc=loc, alpha=alpha)
    if hidden_colorbar:
        plotutils.add_colorbar(plot.ax, visible=False)

    # add zero line
    axis_lims = plot.ax.get_ylim()
    if zeroline:
        plot.ax.plot([0, 0], [axis_lims[0], axis_lims[1]], 'r--', linewidth=2)
        plot.ax.set_ylim([axis_lims[0], axis_lims[1]])

    # set logscale
    if logx:
        plot.ax.xaxis.set_scale("log")
    if logy:
        plot.ax.yaxis.set_scale("log")
    plot.ax._update_transScale()

    # format axes
    if xlim:
        xlim = (numpy.asarray(xlim).astype(float) - t0) / unit
        plot.ax.set_xlim(xlim)
    if ylim:
        plot.ax.set_ylim(ylim)

    plotutils.set_time_ticks(plot.ax)
    plotutils.set_minor_ticks(plot.ax, x=False)

    # save and close
    plot.savefig(outfile, bbox_inches=bbox_inches,\
                 bbox_extra_artists=plot.ax.texts)
    plot.close()
Пример #2
0
def plottimeseries(series, outfile, t0=0, zeroline=False, **kwargs):
    """
    Plot a REALXTimeSeries.
    """
    # construct list of series
    if hasattr(series, "__contains__"):
        serieslist = series
    else:
        serieslist = [series]

    # get limits
    xlim = kwargs.pop("xlim", None)
    ylim = kwargs.pop("ylim", None)
    if xlim:
        start,end = xlim
    else:
        start = min(float(s.epoch) for s in serieslist)
        end   = max(float(s.epoch + s.data.length*s.deltaT) for s in serieslist)

    # get axis scales
    logx = kwargs.pop("logx", False)
    logy = kwargs.pop("logy", False)

    # get legend loc
    loc = kwargs.pop("loc", 0)
    alpha = kwargs.pop("alpha", 0.8)

    # get colorbar options
    hidden_colorbar = kwargs.pop("hidden_colorbar", False)

    # get savefig option
    bbox_inches = kwargs.pop("bbox_inches", None)

    #
    # get labels
    #

    xlabel = kwargs.pop("xlabel", None)
    if xlabel:
        unit = 1
    if not xlabel:
        unit, timestr = plotutils.time_axis_unit(end-start)
        if not t0:
            t0 = start
        t0 = lal.LIGOTimeGPS(t0)
        if int(t0.gpsNanoSeconds) == 0:
            xlabel = datetime.datetime(*lal.GPSToUTC(int(t0))[:6])\
                         .strftime("%B %d %Y, %H:%M:%S %ZUTC")
            xlabel = "Time (%s) since %s (%s)" % (timestr, xlabel, int(t0))
        else:
            xlabel = datetime.datetime(*lal.GPSToUTC(t0.gpsSeconds)[:6])\
                          .strftime("%B %d %Y, %H:%M:%S %ZUTC")
            xlabel = "Time (%s) since %s (%s)"\
                     % (timestr,
                        xlabel.replace(" UTC",".%.3s UTC" % t0.gpsNanoSeconds),\
                        t0)
        t0 = float(t0)
    ylabel   = kwargs.pop("ylabel", "Amplitude (counts)")
    title    = kwargs.pop("title", "")
    subtitle = kwargs.pop("subtitle", "")

    #
    # set default line params
    #

    color = kwargs.pop("color", None)
    if isinstance(color, str):
        color = color.split(',')
        if len(color) == 1:
            color = [color[0]]*len(serieslist)
    kwargs2 = dict()
    kwargs2.update(kwargs)
    if kwargs.has_key("marker"):
        kwargs.setdefault("markersize", 5)
        kwargs2.setdefault("markersize", 2)
    else:
        kwargs.setdefault("linestyle", "-")
        kwargs.setdefault("linewidth", "1")
        kwargs2.setdefault("linewidth", "0.1")

    #
    # make plot
    #

    allnames    = [s.name for s in serieslist]
    namedseries = [s for s in serieslist if not re.search("(min|max)\Z",s.name)]

    plot = plotutils.SimplePlot(xlabel, ylabel, title, subtitle)
    for i,(series,c) in enumerate(itertools.izip(namedseries,\
                                                 plotutils.default_colors())):
        if color:
            c = color[serieslist.index(series)]
        x = numpy.arange(series.data.length) * series.deltaT +\
            float(series.epoch) - float(t0)
        x = x.astype(float)
        x /= unit
        d = series.data.data
        if logy and ylim:
            numpy.putmask(d, d==0, ylim[0]-abs(ylim[0])*0.01)
        plot.add_content(x, d, color=c,\
                         label=plotutils.display_name(series.name), **kwargs)
        # find min/max and plot
        for i,name in enumerate(allnames):
            for ext in ["min", "max"]:
                if re.match("%s[- _]%s" % (re.escape(series.name), ext), name):
                    if color:
                        c = color[i]
                    series2 = serieslist[i]
                    x2 = numpy.arange(series2.data.length) * series2.deltaT\
                         + float(series2.epoch) - float(t0)
                    x2 /= unit
                    d2 = series2.data.data
                    if logy and ylim:
                        numpy.putmask(d2, d2==0, ylim[0]-abs(ylim[0])*0.01)
                    plot.ax.plot(x2, d2, color=c, **kwargs2)
                    plot.ax.fill_between(x2, d, d2, alpha=0.1,\
                                         color=c)

    # finalize
    plot.finalize(loc=loc, alpha=alpha)
    if hidden_colorbar:
        plotutils.add_colorbar(plot.ax, visible=False)
    
    # add zero line
    axis_lims = plot.ax.get_ylim()
    if zeroline:
        plot.ax.plot([0, 0], [axis_lims[0], axis_lims[1]], 'r--', linewidth=2)
        plot.ax.set_ylim([ axis_lims[0], axis_lims[1] ])

    # set logscale
    if logx:
        plot.ax.xaxis.set_scale("log")
    if logy:
        plot.ax.yaxis.set_scale("log")
    plot.ax._update_transScale()

    # format axes
    if xlim:
        xlim = (numpy.asarray(xlim).astype(float)-t0)/unit
        plot.ax.set_xlim(xlim)
    if ylim:
        plot.ax.set_ylim(ylim)

    plotutils.set_time_ticks(plot.ax)
    plotutils.set_minor_ticks(plot.ax, x=False)

    # save and close
    plot.savefig(outfile, bbox_inches=bbox_inches,\
                 bbox_extra_artists=plot.ax.texts)
    plot.close()
Пример #3
0
def plotspectrogram(sequencelist, outfile, epoch=0, deltaT=1, f0=0, deltaF=1,\
                    t0=0, ydata=None, **kwargs):
    """
    Plots a list of REAL?VectorSequences on a time-frequency-amplitude colour
    map. The epochand deltaT arguments define the spacing in the x direction
    for the given VectorSequence, and similarly f0 and deltaF in the
    y-direction. If a list of VectorSequences is given, any of these arguments
    can be in list form, one for each sequence.

    ydata can be given as to explicitly define the frequencies at which the
    sequences are sampled.
    """
    # construct list of series
    if not hasattr(sequencelist, "__contains__"):
        sequencelist = [sequencelist]
    numseq = len(sequencelist)

    # format variables
    if isinstance(epoch, numbers.Number) or isinstance(epoch, lal.LIGOTimeGPS):
        epoch = [epoch] * numseq
        epoch = map(float, epoch)
    if not len(epoch) == numseq:
        raise ValueError("Wrong number of epoch arguments given.")
    if isinstance(deltaT, numbers.Number):
        deltaT = [deltaT] * numseq
        deltaT = map(float, deltaT)
    if not len(deltaT) == numseq:
        raise ValueError("Wrong number of deltaT arguments given.")
    if not ydata is None:
        if isinstance(f0, numbers.Number):
            f0 = [f0] * numseq
            f0 = map(float, f0)
        if not len(f0) == numseq:
            raise ValueError("Wrong number of f0 arguments given.")
        if isinstance(deltaF, numbers.Number):
            deltaF = [deltaF] * numseq
            deltaF = map(float, deltaF)
        if not len(deltaF) == numseq:
            raise ValueError("Wrong number of deltaF arguments given.")

    # get limits
    xlim = kwargs.pop("xlim", None)
    ylim = kwargs.pop("ylim", None)
    colorlim = kwargs.pop("colorlim", None)
    if xlim:
        start, end = xlim
    else:
        start = min(epoch)
        end   = max(e + l.length * dt\
                    for e,l,dt in zip(epoch, sequencelist, deltaT))
    if not ydata is None and not ylim:
        ylim = [ydata.min(), ydata.max()]

    # get axis scales
    logx = kwargs.pop("logx", False)
    logy = kwargs.pop("logy", False)
    logcolor = kwargs.pop("logcolor", False)

    # get legend loc
    loc = kwargs.pop("loc", 0)
    alpha = kwargs.pop("alpha", 0.8)

    # get colorbar options
    hidden_colorbar = kwargs.pop("hidden_colorbar", False)

    # get savefig option
    bbox_inches = kwargs.pop("bbox_inches", None)

    #
    # get labels
    #

    xlabel = kwargs.pop("xlabel", None)
    if xlabel:
        unit = 1
    if not xlabel:
        unit, timestr = plotutils.time_axis_unit(end - start)
        if not t0:
            t0 = start
        t0 = lal.LIGOTimeGPS(t0)
        if int(t0.gpsNanoSeconds) == 0:
            xlabel = datetime.datetime(*lal.GPSToUTC(int(t0))[:6])\
                         .strftime("%B %d %Y, %H:%M:%S %ZUTC")
            xlabel = "Time (%s) since %s (%s)" % (timestr, xlabel, int(t0))
        else:
            xlabel = datetime.datetime(*lal.GPSToUTC(t0.gpsSeconds)[:6])\
                          .strftime("%B %d %Y, %H:%M:%S %ZUTC")
            xlabel = "Time (%s) since %s (%s)"\
                     % (timestr,
                        xlabel.replace(" UTC",".%.3s UTC" % t0.gpsNanoSeconds),\
                        t0)
        t0 = float(t0)
    ylabel = kwargs.pop("ylabel", "Frequency (Hz)")
    colorlabel = kwargs.pop("colorlabel", "Amplitude")
    title = kwargs.pop("title", "")
    subtitle = kwargs.pop("subtitle", "")

    #
    # restrict data to the correct limits for plotting
    #

    interpolate = logy and ydata is None

    for i, sequence in enumerate(sequencelist):
        if interpolate:
            # interpolate the data onto a log-scale
            sequence, ydata = loginterpolate(sequence, f0[i], deltaF[i])
        if logy and ylim:
            plotted = (ydata > ylim[0]) & (ydata <= ylim[1])
            newVectorLength = int(plotted.sum())
            newsequence = lal.CreateREAL8VectorSequence(sequence.length,\
                                                            newVectorLength)
            for j in range(sequence.length):
                newsequence.data[j, :] = sequence.data[j, :][plotted]
            del sequence
            sequencelist[i] = newsequence
    if len(sequencelist) and logy and ylim:
        ydata = ydata[plotted]

    #
    # format bins
    #

    xbins = []
    for i in range(numseq):
        xmin = epoch[i]
        xmax = epoch[i] + sequencelist[i].length * deltaT[i]
        xbins.append(rate.LinearBins(float(xmin-t0)/unit, float(xmax-t0)/unit,\
                                     2))

    ybins = []
    for i in range(numseq):
        if ydata is not None:
            ydata = numpy.asarray(ydata)
            ymin = ydata.min()
            ymax = ydata.max()
        else:
            ymin = f0[i]
            ymax = f0[i] + sequencelist[i].vectorLength * deltaF[i]
        if logy:
            if ymin == 0:
                ymin = deltaF[i]
            ybins.append(rate.LogarithmicBins(ymin, ymax, 2))
        else:
            ybins.append(rate.LinearBins(ymin, ymax, 2))

    #
    # plot
    #

    kwargs.setdefault("interpolation", "kaiser")

    plot = plotutils.ImagePlot(xlabel=xlabel, ylabel=ylabel, title=title,\
                               subtitle=subtitle, colorlabel=colorlabel)

    for sequence, x, y in zip(sequencelist, xbins, ybins):
        data = numpy.ma.masked_where(numpy.isnan(sequence.data), sequence.data,\
                                     copy=False)
        plot.add_content(data.T, x, y, **kwargs)

    # finalize
    plot.finalize(colorbar=True, logcolor=logcolor, minorticks=True,\
                  clim=colorlim)
    if hidden_colorbar:
        plotutils.add_colorbar(plot.ax, visible=False)

    # set logscale
    if logx:
        plot.ax.xaxis.set_scale("log")
    if logy:
        plot.ax.yaxis.set_scale("log")
    plot.ax._update_transScale()

    # format axes
    if xlim:
        xlim = (numpy.asarray(xlim).astype(float) - t0) / unit
        plot.ax.set_xlim(xlim)
    if ylim:
        plot.ax.set_ylim(ylim)

    # set grid and ticks
    plot.ax.grid(True, which="both")
    plotutils.set_time_ticks(plot.ax)
    plotutils.set_minor_ticks(plot.ax)

    # save and close
    plot.savefig(outfile, bbox_inches=bbox_inches,\
                 bbox_extra_artists=plot.ax.texts)
    plot.close()
def plottable(lsctable, outfile, xcolumn="time", ycolumn="snr",\
              colorcolumn=None, rankcolumn=None, t0=None, **kwargs):
    """
    Plot any column of a valid LigoLW table against any other, coloured by any
    other, or plot all the same if you're that way inclined. Multiple tables
    can be given for any non-coloured plot.

    "time" as a column means the output of get_peak for Burst tables, get_end
    for Inspiral tables, and get_start for ringdown tables

    Arguments:

        tables : [ dict | glue.ligolw.table.Table ]
            dict of ("name", table) pairs, or single LigoLW tables
        outfile : string
            string path for output plot

    Keyword arguments:

        xcolumn : string
            valid column of triggers table to plot on x-axis
        ycolumn : string
            valid column of triggers table to plot on y-axis
        zcolumn : string
            valid column of triggers table to use for colorbar (optional).
    """
    # work out dictionary or table
    if isinstance(lsctable, table.Table):
        tables = {"_": lsctable}
    else:
        tables = lsctable
    tablenames = tables.keys()
    tables = [tables[n] for n in tablenames]

    # get axis limits
    xlim = kwargs.pop('xlim', None)
    ylim = kwargs.pop('ylim', None)
    zlim = kwargs.pop('zlim', None)
    colorlim = kwargs.pop('colorlim', None)
    if zlim and not colorlim:
        colorlim = zlim

    # set up columns
    columns = list(map(str.lower, [xcolumn, ycolumn]))
    if colorcolumn:
        columns.append(colorcolumn.lower())
        if rankcolumn:
            columns.append(rankcolumn.lower())
        else:
            columns.append(colorcolumn.lower())

    # set up limits
    limits = [xlim, ylim, zlim, None]

    # get zero
    if "time" in columns and not t0:
        if xlim:
            t0 = float(xlim[0])
        else:
            t0 = numpy.infty
            for t in tables:
                timedata = get_column(t, "time").astype(float)
                if len(timedata):
                    t0 = min(t0, timedata.min())
            if numpy.isinf(t0):
                t0 = 0
            t0 = int(t0)

    #
    # get data
    #

    # extract columns
    data = list()
    for i, name in enumerate(tablenames):
        data.append(list())
        for c in columns:
            c = c.lower()
            if ((c not in tables[i].columnnames and c != "time")
                    and not hasattr(tables[i], "get_%s" % c.lower())):
                raise RuntimeError("Column '%s' not found in table '%s'."\
                                   % (c,name))
            data[-1].append(get_column(tables[i], c.lower()).astype(float))
            if not len(data[-1][-1].shape)\
            or data[-1][-1].shape[0] != len(tables[i]):
                raise AttributeError("No data loaded for column \"%s\" and "\
                                     "table \"%s\"" % (c, name))

    # add our own limits
    for i in range(len(columns)):
        if not limits[i]:
            mins = [data[j][i].min() for j in range(len(tablenames))\
                    if len(data[j][i].shape) and data[j][i].shape[0] != 0]
            if len(mins):
                lmin = min(mins)
                lmax = max(data[j][i].max() for j in range(len(tablenames))\
                           if len(data[j][i]))
                limits[i] = [lmin, lmax]

    # get time unit
    if "time" in columns:
        idx = columns.index("time")
        if limits[idx]:
            unit, timestr = plotutils.time_axis_unit(limits[idx][1]\
                                                     - limits[idx][0])
        else:
            unit, timestr = plotutils.time_axis_unit(1)

    # format data
    for i, name in enumerate(tablenames):
        for j, column in enumerate(columns):
            if column == "time":
                data[i][j] = (data[i][j] - t0) / unit
                if i == 0 and limits[j]:
                    limits[j] = [float(limits[j][0] - t0) / unit,\
                                 float(limits[j][1] - t0) / unit]

        # format a condition to reject triggers outside the plot range
        plotted = True
        for j, column in enumerate(columns):
            if limits[j]:
                plotted = plotted & (limits[j][0] <= data[i][j])\
                                  & (limits[j][1] >=  data[i][j])

        # apply the limits
        if not isinstance(plotted, bool):
            for j, d in enumerate(data[i]):
                data[i][j] = d[plotted]

    #
    # find loudest event
    #

    loudest = None
    if len(columns) == 4 and len(tablenames) == 1 and len(data[0][0]) > 0:
        idx = data[0][3].argmax()
        loudest = [data[0][j][idx] for j in range(len(columns))]

    #
    # get or set the labels
    #

    label = {}
    for i,(label,column) in enumerate(zip(["xlabel", "ylabel", "colorlabel"],\
                                          columns)):
        # get given label
        l = kwargs.pop(label, None)
        if l is None:
            # format time string
            if column == "time" and limits[i]:
                zerostr = datetime.datetime(\
                              *date.XLALGPSToUTC(LIGOTimeGPS(t0))[:6])\
                                       .strftime("%B %d %Y, %H:%M:%S %ZUTC")
                l = "Time (%s) since %s (%s)" % (timestr, zerostr, t0)
            # format any other column
            else:
                l = plotutils.display_name(column)
        if label == "xlabel":
            xlabel = l
        elif label == "ylabel":
            ylabel = l
        else:
            colorlabel = l

    title = kwargs.pop("title", "")
    subtitle = kwargs.pop("subtitle", None)
    if subtitle is None and loudest:
        subtitle = "Loudest event by %s:" % plotutils.display_name(columns[-1])
        for j, c in enumerate(columns):
            if j != 0 and c == columns[j - 1]: continue
            lstr = loudest[j]
            if c == "time":
                lstr = lstr * unit + t0
            subtitle += " %s=%.2f" % (plotutils.display_name(c), lstr)
    else:
        loudest = None

    #
    # get parameters
    #

    # get axis scales
    logx = kwargs.pop("logx", False)
    logy = kwargs.pop("logy", False)
    logcolor = kwargs.pop("logcolor", False)

    # get legend loc
    loc = kwargs.pop("loc", 0)

    # get colorbar options
    hidden_colorbar = kwargs.pop("hidden_colorbar", False)

    # get savefig option
    bbox_inches = kwargs.pop("bbox_inches", "tight")

    # get detchar plot params
    dqstyle = (kwargs.pop("detchar", False)
               or kwargs.pop('detchar_style', False))
    dqthresh = (kwargs.pop('dcthreshold', False)
                or kwargs.pop('detchar_style_threshold', 10))

    # get greyscale param
    greyscale = kwargs.pop("greyscale", False)
    if greyscale and not kwargs.has_key("cmap"):
        kwargs["cmap"] =\
            pylab.matplotlib.colors.LinearSegmentedColormap("clrs",\
                                        pylab.matplotlib.cm.hot_r._segmentdata)
    elif not kwargs.has_key("cmap"):
        kwargs["cmap"] = jet

    #
    # make the plot
    #

    tablenames = map(plotutils.display_name, tablenames)

    if len(columns) == 2:
        plot = plotutils.ScatterPlot(xlabel, ylabel, title, subtitle)
        for i in range(len(tablenames)):
            plot.add_content(data[i][0], data[i][1], label=tablenames[i],\
                             **kwargs)
        plot.finalize(loc=loc)
        if hidden_colorbar:
            plotutils.add_colorbar(plot.ax, visible=False)
    else:
        if dqstyle:
            plot = plotutils.DQScatterPlot(xlabel, ylabel, colorlabel,\
                                           title, subtitle)
        else:
            plot = plotutils.ColorbarScatterPlot(xlabel, ylabel, colorlabel,\
                                                 title, subtitle)
        plot.add_content(data[0][0], data[0][1], data[0][2],\
                         label=tablenames[0], **kwargs)
        kwargs.pop("cmap", None)
        if dqstyle:
            plot.finalize(logcolor=logcolor, clim=colorlim, loc=loc,\
                          threshold=dqthresh)
        else:
            plot.finalize(logcolor=logcolor, clim=colorlim, loc=loc)

    # plot loudest
    if loudest:
        plot.ax.plot([loudest[0]], [loudest[1]], marker="*", color="gold",\
                     markersize=15)

    # set axes
    if logx:
        plot.ax.set_xscale("log")
    if logy:
        plot.ax.set_yscale("log")
    plot.ax.autoscale_view(tight=True, scalex=True, scaley=True)

    if limits[0]:
        plot.ax.set_xlim(limits[0])
    if limits[1]:
        plot.ax.set_ylim(limits[1])

    plot.ax.grid(True, which="both")
    if xcolumn == "time":
        plotutils.set_time_ticks(plot.ax)
    plotutils.set_minor_ticks(plot.ax)

    # save and close
    if greyscale:
        plot.ax.patch.set_facecolor("#E8E8E8")
    plot.savefig(outfile, bbox_inches=bbox_inches,\
                 bbox_extra_artists=plot.ax.texts)
    plot.close()
Пример #5
0
def plotspectrogram(sequencelist, outfile, epoch=0, deltaT=1, f0=0, deltaF=1,\
                    t0=0, ydata=None, **kwargs):
    """
    Plots a list of REAL?VectorSequences on a time-frequency-amplitude colour
    map. The epochand deltaT arguments define the spacing in the x direction
    for the given VectorSequence, and similarly f0 and deltaF in the
    y-direction. If a list of VectorSequences is given, any of these arguments
    can be in list form, one for each sequence.

    ydata can be given as to explicitly define the frequencies at which the
    sequences are sampled.
    """
    # construct list of series
    if not hasattr(sequencelist, "__contains__"):
        sequencelist = [sequencelist]
    numseq = len(sequencelist)

    # format variables
    if isinstance(epoch, numbers.Number) or isinstance(epoch, lal.LIGOTimeGPS):
        epoch = [epoch]*numseq
        epoch = map(float, epoch)
    if not len(epoch) == numseq:
        raise ValueError("Wrong number of epoch arguments given.")
    if isinstance(deltaT, numbers.Number):
        deltaT = [deltaT]*numseq
        deltaT = map(float, deltaT)
    if not len(deltaT) == numseq:
        raise ValueError("Wrong number of deltaT arguments given.")
    if not ydata is None:
        if isinstance(f0, numbers.Number):
            f0 = [f0]*numseq
            f0 = map(float, f0)
        if not len(f0) == numseq:
            raise ValueError("Wrong number of f0 arguments given.")
        if isinstance(deltaF, numbers.Number):
            deltaF = [deltaF]*numseq
            deltaF = map(float, deltaF)
        if not len(deltaF) == numseq:
            raise ValueError("Wrong number of deltaF arguments given.")

    # get limits
    xlim = kwargs.pop("xlim", None)
    ylim = kwargs.pop("ylim", None)
    colorlim = kwargs.pop("colorlim", None)
    if xlim:
        start,end = xlim
    else:
        start = min(epoch)
        end   = max(e + l.length * dt\
                    for e,l,dt in zip(epoch, sequencelist, deltaT))
    if not ydata is None and not ylim:
        ylim = [ydata.min(), ydata.max()]

    # get axis scales
    logx = kwargs.pop("logx", False)
    logy = kwargs.pop("logy", False)
    logcolor = kwargs.pop("logcolor", False)

    # get legend loc
    loc = kwargs.pop("loc", 0)
    alpha = kwargs.pop("alpha", 0.8)

    # get colorbar options
    hidden_colorbar = kwargs.pop("hidden_colorbar", False)

    # get savefig option
    bbox_inches = kwargs.pop("bbox_inches", None)
    
    #
    # get labels
    #

    xlabel = kwargs.pop("xlabel", None)
    if xlabel:
        unit = 1
    if not xlabel:
        unit, timestr = plotutils.time_axis_unit(end-start)
        if not t0:
            t0 = start
        t0 = lal.LIGOTimeGPS(t0)
        if int(t0.gpsNanoSeconds) == 0:
            xlabel = datetime.datetime(*lal.GPSToUTC(int(t0))[:6])\
                         .strftime("%B %d %Y, %H:%M:%S %ZUTC")
            xlabel = "Time (%s) since %s (%s)" % (timestr, xlabel, int(t0))
        else:
            xlabel = datetime.datetime(*lal.GPSToUTC(t0.gpsSeconds)[:6])\
                          .strftime("%B %d %Y, %H:%M:%S %ZUTC")
            xlabel = "Time (%s) since %s (%s)"\
                     % (timestr,
                        xlabel.replace(" UTC",".%.3s UTC" % t0.gpsNanoSeconds),\
                        t0)
        t0 = float(t0)
    ylabel     = kwargs.pop("ylabel", "Frequency (Hz)")
    colorlabel = kwargs.pop("colorlabel", "Amplitude")
    title      = kwargs.pop("title", "")
    subtitle   = kwargs.pop("subtitle", "")

    #
    # restrict data to the correct limits for plotting
    #

    interpolate = logy and ydata is None

    for i,sequence in enumerate(sequencelist):
        if interpolate:
           # interpolate the data onto a log-scale
           sequence,ydata = loginterpolate(sequence, f0[i], deltaF[i])
        if logy and ylim:
           plotted = (ydata > ylim[0]) & (ydata <= ylim[1])
           newVectorLength = int(plotted.sum())
           newsequence = lal.CreateREAL8VectorSequence(sequence.length,\
                                                           newVectorLength)
           for j in range(sequence.length):
               newsequence.data[j,:] = sequence.data[j,:][plotted]
           del sequence
           sequencelist[i] = newsequence
    if len(sequencelist) and logy and ylim:
        ydata = ydata[plotted]

    #
    # format bins
    #

    xbins = []
    for i in range(numseq):
        xmin = epoch[i]
        xmax = epoch[i] + sequencelist[i].length * deltaT[i]
        xbins.append(rate.LinearBins(float(xmin-t0)/unit, float(xmax-t0)/unit,\
                                     2))

    ybins = []
    for i in range(numseq):
        if ydata is not None:
            ydata = numpy.asarray(ydata)
            ymin = ydata.min()
            ymax = ydata.max()
        else:
            ymin = f0[i]
            ymax = f0[i] + sequencelist[i].vectorLength * deltaF[i]
        if logy:
            if ymin == 0:
                ymin = deltaF[i]
            ybins.append(rate.LogarithmicBins(ymin, ymax, 2))
        else:
            ybins.append(rate.LinearBins(ymin, ymax, 2))

    #
    # plot
    # 

    kwargs.setdefault("interpolation", "kaiser")

    plot = plotutils.ImagePlot(xlabel=xlabel, ylabel=ylabel, title=title,\
                               subtitle=subtitle, colorlabel=colorlabel)

    for sequence,x,y in zip(sequencelist, xbins, ybins):
        data = numpy.ma.masked_where(numpy.isnan(sequence.data), sequence.data,\
                                     copy=False)
        plot.add_content(data.T, x, y, **kwargs)

    # finalize
    plot.finalize(colorbar=True, logcolor=logcolor, minorticks=True,\
                  clim=colorlim)
    if hidden_colorbar:
        plotutils.add_colorbar(plot.ax, visible=False)

    # set logscale
    if logx:
        plot.ax.xaxis.set_scale("log")
    if logy:
        plot.ax.yaxis.set_scale("log")
    plot.ax._update_transScale()

    # format axes
    if xlim:
        xlim = (numpy.asarray(xlim).astype(float)-t0)/unit
        plot.ax.set_xlim(xlim)
    if ylim:
        plot.ax.set_ylim(ylim)

    # set grid and ticks
    plot.ax.grid(True, which="both")
    plotutils.set_time_ticks(plot.ax)
    plotutils.set_minor_ticks(plot.ax)

    # save and close
    plot.savefig(outfile, bbox_inches=bbox_inches,\
                 bbox_extra_artists=plot.ax.texts)
    plot.close()
def plotdutycycle(segdict, outfile, binlength=3600, keys=None, t0=None,\
                  showmean=False, **kwargs):
    """
    Plot the percentage duty cycle each flag in the given
    glue.segments.segmentlistdict, binned over the given duration.
    """
    # get time limits
    xlim = kwargs.pop("xlim", None)
    if xlim is None:
        try:
            extents = [seg.extent() for seg in segdict.values()]
            start = min(s[0] for s in extents)
            end = max(s[1] for s in extents)
        except ValueError:
            start = 0
            end = 1
        xlim = start, end
    else:
        start, end = xlim

    # get unit for plot
    unit, timestr = plotutils.time_axis_unit(end - start)

    # set xlabel and renomalize time
    xlabel = kwargs.pop("xlabel", None)
    if not xlabel:
        if not t0:
            t0 = start
        unit, timestr = plotutils.time_axis_unit(end - start)
        t0 = LIGOTimeGPS(float(t0))
        if t0.nanoseconds == 0:
            xlabel = datetime.datetime(*date.XLALGPSToUTC(t0)[:6])\
                         .strftime("%B %d %Y, %H:%M:%S %ZUTC")
            xlabel = "Time (%s) since %s (%s)" % (timestr, xlabel, int(t0))
        else:
            xlabel = datetime.datetime(*date.XLALGPSToUTC(\
                                                  LIGOTimeGPS(t0.seconds))[:6])\
                          .strftime("%B %d %Y, %H:%M:%S %ZUTC")
            xlabel = "Time (%s) since %s (%s)"\
                     % (timestr,
                        xlabel.replace(" UTC", ".%.3s UTC" % t0.nanoseconds),\
                        t0)
        t0 = float(t0)
        xlim[0] = (start - t0) / unit
        xlim[1] = (end - t0) / unit
    ylabel = kwargs.pop("ylabel", "")
    title = kwargs.pop("title", "")
    subtitle = kwargs.pop("subtitle", "")

    # get other parameters
    loc = kwargs.pop("loc", 0)
    legalpha = kwargs.pop("alpha", 0.8)
    labels_inset = kwargs.pop("labels_inset", False)
    bbox_inches = kwargs.pop("bbox_inches", "tight")
    hidden_colorbar = kwargs.pop("hidden_colorbar", False)

    # escape underscores for latex text
    if not keys:
        keys = segdict.keys()
    if pylab.rcParams["text.usetex"]:
        newdict = segments.segmentlistdict()
        for i, key in enumerate(keys):
            newkey = re.sub('(?<!\\\\)_', '\_', key)
            keys[i] = newkey
            newdict[newkey] = segdict[key]
        segdict = newdict

    #
    # generate duty cycle info
    #

    # generate bins
    binlength = float(binlength)
    if int(end - start) % binlength == 0:
        numbins = int(end - start) / binlength
    else:
        numbins = float(end - start) // binlength + 1
    bins = numpy.arange(float(start), float(end), binlength) + binlength / 2
    duty = dict((key, numpy.zeros(numbins)) for key in keys)

    bs = float(start)
    for i in range(numbins):
        be = float(bs + binlength)
        seg = segments.segmentlist([segments.segment(bs, be)])
        for key in keys:
            duty[key][i] = float(abs(segdict[key] & seg)) / abs(seg) * 100
        bs += binlength

    if showmean:
        mean = dict((key, numpy.zeros(numbins)) for key in keys)
        for key in keys:
            mean[key] = [duty[key][:i + 1].mean() for i in range(numbins)]

    #
    # generate plot
    #

    bins = (bins - t0) / unit

    plot = plotutils.BarPlot(xlabel, ylabel, title, subtitle)
    for i, key in enumerate(keys):
        if showmean:
            thislabel = plotutils.display_name(
                key) + ' (%.2f\%%)' % (mean[key][-1])
        else:
            thislabel = plotutils.display_name(key)
        plot.add_content(bins, duty[key], label=thislabel,\
                           alpha=0.8, width=binlength/unit)
    plot.finalize(loc=loc, alpha=legalpha)

    # add running mean
    if showmean:
        for i, key in enumerate(keys):
            print i, key
            plot.ax.plot(bins, mean[key], linestyle='--')
        plot.ax.get_legend().get_frame().set_alpha(0.5)

    # add colorbar
    if hidden_colorbar:
        plotutils.add_colorbar(plot.ax, visible=False)

    # set limits
    plot.ax.autoscale_view(tight=True, scalex=True)
    if xlim:
        plot.ax.set_xlim(map(float, xlim))
    plot.ax.set_ylim(0, 100)

    # set grid
    plot.ax.grid(True, which="both")
    plotutils.set_time_ticks(plot.ax)
    plotutils.set_minor_ticks(plot.ax, x=False)

    # save figure
    plot.savefig(outfile, bbox_inches=bbox_inches,\
                 bbox_extra_artists=plot.ax.texts)
def plotrate(lsctable, outfile, stride=60, column="peak_frequency", bins=[],\
             t0=None, **kwargs):
    """
    Plot rate versus time for the given ligolw table triggers, binned by the
    given bincolumn using the bins list.

    Arguments:

        lsctable : glue.ligolw.table.Table
            LIGOLW table containing a list of triggers
        outfile : string
            string path for output plot
    """
    # get column data
    timedata = get_column(lsctable, "time")
    ratedata = get_column(lsctable, column)
    # sort in time
    if timedata.size:
        timedata, ratedata = map(numpy.asarray,\
                                 zip(*sorted(zip(timedata,ratedata),\
                                             key=lambda (t,r): t)))

    # get x-axis limits
    xlim = kwargs.pop("xlim", None)
    if xlim:
        start, end = xlim
    elif timedata.size:
        start = timedata.min()
        end = timedata.max()
        xlim = start, end
    else:
        start = 0
        end = 1

    # get other params
    logx = kwargs.pop("logx", False)
    logy = kwargs.pop("logy", False)
    ylim = kwargs.pop("ylim", False)
    hidden_colorbar = kwargs.pop("hidden_colorbar", False)
    bbox_inches = kwargs.pop("bbox_inches", "tight")
    loc = kwargs.pop("loc", 0)

    # get bins
    xbins = numpy.arange(float(start), float(end), stride)
    if not bins:
        bins = [[0, float("inf")]]
    ybins = [map(float, bin_) for bin_ in bins]

    # remove all triggers not in any bins
    xextent = (xbins[0], xbins[-1] + stride)
    yextent = (ybins[0][0], ybins[-1][-1])
    inanybin = (timedata > xextent[0]) & (timedata <= xextent[1])\
               & (ratedata > yextent[0]) & (ratedata <= yextent[1])
    timedata = timedata[inanybin]
    ratedata = ratedata[inanybin]

    ydata = numpy.zeros((len(xbins), len(ybins)))
    for i, xbin in enumerate(xbins):
        # work out index of first trigger outside x bin
        try:
            idx = (timedata >= xbin + stride).nonzero()[0][0]
            # get triggers in this time bin
            ratebin = numpy.asarray(sorted(ratedata[:idx]))
            break_ = False
            # get triggers in this time bin
            ratebin = numpy.asarray(sorted(ratedata[:idx]))
        except IndexError:
            idx = None
            ratebin = numpy.asarray(sorted(ratedata))
            break_ = True
        # loop over ybins
        for j, ybin in enumerate(ybins):
            # work out index of first trigger outside this y bin
            try:
                yidx = (ratebin >= ybin[1]).nonzero()[0][0]
            except IndexError:
                ydata[i][j] = len(ratebin) / stride
                break
            ydata[i][j] = len(ratebin[:yidx]) / stride
            ratebin = ratebin[yidx:]
        if break_: break
        timedata = timedata[idx:]
    xdata = xbins + stride / 2

    # set xlabel and renomalize time
    if t0:
        xdata -= t0
        start -= t0
        end -= t0
    xlabel = kwargs.pop("xlabel", None)
    if not xlabel:
        if not t0:
            t0 = start
            start -= t0
            end -= t0
            xdata -= t0
        unit, timestr = plotutils.time_axis_unit(end - start)
        start /= unit
        end /= unit
        xdata = xdata / unit
        t0 = LIGOTimeGPS(t0)
        if t0.nanoseconds == 0:
            xlabel = datetime.datetime(*date.XLALGPSToUTC(LIGOTimeGPS(t0))[:6])\
                         .strftime("%B %d %Y, %H:%M:%S %ZUTC")
        else:
            xlabel = datetime.datetime(*date.XLALGPSToUTC(\
                                                  LIGOTimeGPS(t0.seconds))[:6])\
                          .strftime("%B %d %Y, %H:%M:%S %ZUTC")
            xlabel = "Time (%s) since %s (%s)"\
                     % (timestr,
                        xlabel.replace(" UTC", ".%.3s UTC" % t0.nanoseconds),\
                        t0)
    ylabel = kwargs.pop("ylabel", "Rate (Hz)")
    title = kwargs.pop("title", "")
    subtitle = kwargs.pop("subtitle", "")

    #
    # plot object
    #

    plot = plotutils.ScatterPlot(xlabel, ylabel, title, subtitle)

    # mask zeros for log plot
    if logy:
        ydata = numpy.ma.masked_where(ydata == 0, ydata, copy=False)

    for i, ybin in enumerate(ybins):
        if list(ybin) == [0, numpy.inf]:
            label = "_"
        else:
            label = "%s-%s" % (ybin[0], ybin[1])
        plot.add_content(xdata, ydata[:, i], label=label, **kwargs)

    plot.finalize(loc=loc)
    if hidden_colorbar:
        plotutils.add_colorbar(plot.ax, visible=False)
    if logx:
        plot.ax.set_xscale("log")
    if logy:
        plot.ax.set_yscale("log")
    plot.ax.autoscale_view(tight=True, scalex=True, scaley=True)
    plot.ax.set_xlim(start, end)
    if ylim:
        plot.ax.set_ylim(ylim)

    # set grid and ticks
    plot.ax.grid(True, which="both")
    plotutils.set_time_ticks(plot.ax)
    plotutils.set_minor_ticks(plot.ax)

    # save
    plot.savefig(outfile, bbox_inches=bbox_inches,\
                 bbox_extra_artists=plot.ax.texts)
    plot.close()
def plotsegmentlistdict(segdict, outfile, keys=None, t0=None,\
                        highlight_segments=None, insetlabels=None,\
                        **kwargs):
    """
    Plots a glue.segments.segmentlistdict using the PlotSegmentsPlot class from
    pylal.plotutils.

    Arguments:

        segdict : glue.segments.segmentlistdict
            dictionary of (name, segmentlist) pairs to plot.
        outfile : str
            filepath to write to

    Keyword arguments:

        keys : list
            ordered list of keys to use in this order on the plot
        t0 : float
            GPS time around which to zero plot
        highlight_segments : glue.segments.segmentlistdict
            list of segments to highlight with vertical red dashed lines
        insetlabels : [ True | False ]
            write labels inside the plot axis

    Unnamed keyword arguments:

        xlabel : string
            label for x-axis
        ylabel : string
            label for y-axis
        title : string
            title for plot
        subtitle : string
            subtitle for plot
        bbox_inches : str
            use "tight" to get a bounding box tight to the axis.
    """
    # get time limits
    xlim = kwargs.pop("xlim", None)
    if xlim is None:
        try:
            extents = [seg.extent() for seg in segdict.values()]
            start = min(s[0] for s in extents)
            end = max(s[1] for s in extents)
        except ValueError:
            start = 0
            end = 1
        xlim = start, end
    else:
        start, end = xlim

    # get unit for plot
    unit, timestr = plotutils.time_axis_unit(end - start)

    # set xlabel and renomalize time
    xlabel = kwargs.pop("xlabel", None)
    if not xlabel:
        if not t0:
            t0 = start
        unit, timestr = plotutils.time_axis_unit(end - start)
        t0 = LIGOTimeGPS(float(t0))
        if t0.nanoseconds == 0:
            xlabel = datetime.datetime(*date.XLALGPSToUTC(t0)[:6])\
                         .strftime("%B %d %Y, %H:%M:%S %ZUTC")
            xlabel = "Time (%s) since %s (%s)" % (timestr, xlabel, int(t0))
        else:
            xlabel = datetime.datetime(*date.XLALGPSToUTC(\
                                                  LIGOTimeGPS(t0.seconds))[:6])\
                          .strftime("%B %d %Y, %H:%M:%S %ZUTC")
            xlabel = "Time (%s) since %s (%s)"\
                     % (timestr,
                        xlabel.replace(" UTC", ".%.3s UTC" % t0.nanoseconds),\
                        t0)
        t0 = float(t0)
    ylabel = kwargs.pop("ylabel", "")
    title = kwargs.pop("title", "")
    subtitle = kwargs.pop("subtitle", "")

    # get other parameters
    labels_inset = kwargs.pop("labels_inset", False)
    bbox_inches = kwargs.pop("bbox_inches", "tight")
    hidden_colorbar = kwargs.pop("hidden_colorbar", False)

    # escape underscores for latex text
    if not keys:
        keys = segdict.keys()
    if pylab.rcParams["text.usetex"]:
        newdict = segments.segmentlistdict()
        for i, key in enumerate(keys):
            newkey = re.sub('(?<!\\\\)_', '\_', key)
            keys[i] = newkey
            newdict[newkey] = segdict[key]
        segdict = newdict

    # generate plot
    plot = plotutils.PlotSegmentsPlot(xlabel, ylabel, title, subtitle,\
                                       t0=t0, dt=unit)
    plot.add_content(segdict, keys, **kwargs)
    plot.finalize(labels_inset=insetlabels)

    # highlight segments
    if highlight_segments:
        for seg in highlight_segments:
            plot.highlight_segment(seg)

    # add colorbar
    if hidden_colorbar:
        plotutils.add_colorbar(plot.ax, visible=False)

    # set axis limits
    xlim = [float(start - t0) / unit, float(end - t0) / unit]
    plot.ax.set_xlim(*xlim)

    # set grid
    plot.ax.grid(True, which="both")
    plotutils.set_time_ticks(plot.ax)
    plotutils.set_minor_ticks(plot.ax, x=False)

    # save
    plot.savefig(outfile, bbox_inches=bbox_inches,\
                 bbox_extra_artists=plot.ax.texts)
    plot.close()
Пример #9
0
def plotdutycycle(segdict, outfile, binlength=3600, keys=None, t0=None,\
                  showmean=False, **kwargs):
    """
    Plot the percentage duty cycle each flag in the given
    glue.segments.segmentlistdict, binned over the given duration.
    """
    # get time limits
    xlim = kwargs.pop("xlim", None)
    if xlim is None:
        try:
            extents = [seg.extent() for seg in segdict.values()]
            start = min(s[0] for s in extents)
            end   = max(s[1] for s in extents)
        except ValueError:
            start = 0
            end   = 1 
        xlim  = start,end
    else:
        start,end = xlim

    # get unit for plot
    unit, timestr = plotutils.time_axis_unit(end-start)

    # set xlabel and renomalize time
    xlabel = kwargs.pop("xlabel", None)
    if not xlabel:
        if not t0:
            t0 = start
        unit, timestr = plotutils.time_axis_unit(end-start)
        t0 = LIGOTimeGPS(float(t0))
        if t0.nanoseconds==0:
            xlabel = datetime.datetime(*date.XLALGPSToUTC(t0)[:6])\
                         .strftime("%B %d %Y, %H:%M:%S %ZUTC")
            xlabel = "Time (%s) since %s (%s)" % (timestr, xlabel, int(t0))
        else:
            xlabel = datetime.datetime(*date.XLALGPSToUTC(\
                                                  LIGOTimeGPS(t0.seconds))[:6])\
                          .strftime("%B %d %Y, %H:%M:%S %ZUTC")
            xlabel = "Time (%s) since %s (%s)"\
                     % (timestr,
                        xlabel.replace(" UTC", ".%.3s UTC" % t0.nanoseconds),\
                        t0)
        t0 = float(t0)
        xlim[0] = (start - t0)/unit
        xlim[1] = (end - t0)/unit
    ylabel   = kwargs.pop("ylabel",   "")
    title    = kwargs.pop("title",    "")
    subtitle = kwargs.pop("subtitle", "")

    # get other parameters
    loc = kwargs.pop("loc", 0)
    legalpha = kwargs.pop("alpha", 0.8)
    labels_inset    = kwargs.pop("labels_inset", False)
    bbox_inches     = kwargs.pop("bbox_inches", "tight")
    hidden_colorbar = kwargs.pop("hidden_colorbar", False)

    # escape underscores for latex text
    if not keys:
        keys = segdict.keys()
    if pylab.rcParams["text.usetex"]:
        newdict = segments.segmentlistdict()
        for i,key in enumerate(keys):
           newkey = re.sub('(?<!\\\\)_', '\_', key)
           keys[i] = newkey
           newdict[newkey] = segdict[key]
        segdict = newdict

    #
    # generate duty cycle info
    #

    # generate bins
    binlength = float(binlength)
    if int(end-start) % binlength == 0:
        numbins = int(end-start)/binlength
    else:
        numbins = float(end-start)//binlength+1
    bins = numpy.arange(float(start), float(end), binlength) + binlength/2
    duty = dict((key, numpy.zeros(numbins)) for key in keys)

    bs = float(start)
    for i in range(numbins):
        be = float(bs + binlength)
        seg = segments.segmentlist([segments.segment(bs, be)])
        for key in keys:
            duty[key][i] = float(abs(segdict[key] & seg))/abs(seg) * 100
        bs += binlength

    if showmean:
      mean = dict((key, numpy.zeros(numbins)) for key in keys)
      for key in keys:
        mean[key] = [duty[key][:i+1].mean() for i in range(numbins)]

    #
    # generate plot
    #

    bins = (bins-t0)/unit

    plot = plotutils.BarPlot(xlabel, ylabel, title, subtitle)
    for i,key in enumerate(keys):
      if showmean:
        thislabel = plotutils.display_name(key) + ' (%.2f\%%)' % (mean[key][-1])
      else:
        thislabel = plotutils.display_name(key)
      plot.add_content(bins, duty[key], label=thislabel,\
                         alpha=0.8, width=binlength/unit)
    plot.finalize(loc=loc, alpha=legalpha)

    # add running mean
    if showmean:
      for i,key in enumerate(keys):
        print i, key
        plot.ax.plot(bins, mean[key], linestyle = '--')
      plot.ax.get_legend().get_frame().set_alpha(0.5)

    # add colorbar
    if hidden_colorbar:
        plotutils.add_colorbar(plot.ax, visible=False)

    # set limits
    plot.ax.autoscale_view(tight=True, scalex=True)
    if xlim:
        plot.ax.set_xlim(map(float, xlim))
    plot.ax.set_ylim(0, 100)

    # set grid
    plot.ax.grid(True, which="both")
    plotutils.set_time_ticks(plot.ax)
    plotutils.set_minor_ticks(plot.ax, x=False)

    # save figure
    plot.savefig(outfile, bbox_inches=bbox_inches,\
                 bbox_extra_artists=plot.ax.texts)
Пример #10
0
def plotsegmentlistdict(segdict, outfile, keys=None, t0=None,\
                        highlight_segments=None, insetlabels=None,\
                        **kwargs):
    """
    Plots a glue.segments.segmentlistdict using the PlotSegmentsPlot class from
    pylal.plotutils.

    Arguments:

        segdict : glue.segments.segmentlistdict
            dictionary of (name, segmentlist) pairs to plot.
        outfile : str
            filepath to write to

    Keyword arguments:

        keys : list
            ordered list of keys to use in this order on the plot
        t0 : float
            GPS time around which to zero plot
        highlight_segments : glue.segments.segmentlistdict
            list of segments to highlight with vertical red dashed lines
        insetlabels : [ True | False ]
            write labels inside the plot axis

    Unnamed keyword arguments:

        xlabel : string
            label for x-axis
        ylabel : string
            label for y-axis
        title : string
            title for plot
        subtitle : string
            subtitle for plot
        bbox_inches : str
            use "tight" to get a bounding box tight to the axis.
    """
    # get time limits
    xlim = kwargs.pop("xlim", None)
    if xlim is None:
        try:
            extents = [seg.extent() for seg in segdict.values()]
            start = min(s[0] for s in extents)
            end   = max(s[1] for s in extents)
        except ValueError:
            start = 0
            end   = 1 
        xlim  = start,end
    else:
        start,end = xlim

    # get unit for plot
    unit, timestr = plotutils.time_axis_unit(end-start)

    # set xlabel and renomalize time
    xlabel = kwargs.pop("xlabel", None)
    if not xlabel:
        if not t0:
            t0 = start
        unit, timestr = plotutils.time_axis_unit(end-start)
        t0 = LIGOTimeGPS(float(t0))
        if t0.nanoseconds==0:
            xlabel = datetime.datetime(*date.XLALGPSToUTC(t0)[:6])\
                         .strftime("%B %d %Y, %H:%M:%S %ZUTC")
            xlabel = "Time (%s) since %s (%s)" % (timestr, xlabel, int(t0))
        else:
            xlabel = datetime.datetime(*date.XLALGPSToUTC(\
                                                  LIGOTimeGPS(t0.seconds))[:6])\
                          .strftime("%B %d %Y, %H:%M:%S %ZUTC")
            xlabel = "Time (%s) since %s (%s)"\
                     % (timestr,
                        xlabel.replace(" UTC", ".%.3s UTC" % t0.nanoseconds),\
                        t0)
        t0 = float(t0)
    ylabel   = kwargs.pop("ylabel",   "")
    title    = kwargs.pop("title",    "")
    subtitle = kwargs.pop("subtitle", "")

    # get other parameters
    labels_inset    = kwargs.pop("labels_inset", False)
    bbox_inches     = kwargs.pop("bbox_inches", "tight")
    hidden_colorbar = kwargs.pop("hidden_colorbar", False)

    # escape underscores for latex text
    if not keys:
        keys = segdict.keys()
    if pylab.rcParams["text.usetex"]:
        newdict = segments.segmentlistdict()
        for i,key in enumerate(keys):
           newkey = re.sub('(?<!\\\\)_', '\_', key)
           keys[i] = newkey
           newdict[newkey] = segdict[key]
        segdict = newdict

    # generate plot
    plot = plotutils.PlotSegmentsPlot(xlabel, ylabel, title, subtitle,\
                                       t0=t0, dt=unit)
    plot.add_content(segdict, keys, **kwargs)
    plot.finalize(labels_inset=insetlabels)

    # highlight segments
    if highlight_segments:
        for seg in highlight_segments:
            plot.highlight_segment(seg)
 
    # add colorbar
    if hidden_colorbar:
        plotutils.add_colorbar(plot.ax, visible=False)

    # set axis limits
    xlim = [float(start-t0)/unit, float(end-t0)/unit]
    plot.ax.set_xlim(*xlim)

    # set grid
    plot.ax.grid(True, which="both")
    plotutils.set_time_ticks(plot.ax)
    plotutils.set_minor_ticks(plot.ax, x=False)

    # save
    plot.savefig(outfile, bbox_inches=bbox_inches,\
                 bbox_extra_artists=plot.ax.texts)
    plot.close()
Пример #11
0
def plottable(lsctable, outfile, xcolumn="time", ycolumn="snr",\
              colorcolumn=None, rankcolumn=None, t0=None, **kwargs):
    """
    Plot any column of a valid LigoLW table against any other, coloured by any
    other, or plot all the same if you're that way inclined. Multiple tables
    can be given for any non-coloured plot.

    "time" as a column means the output of get_peak for Burst tables, get_end
    for Inspiral tables, and get_start for ringdown tables

    Arguments:

        tables : [ dict | glue.ligolw.table.Table ]
            dict of ("name", table) pairs, or single LigoLW tables
        outfile : string
            string path for output plot

    Keyword arguments:

        xcolumn : string
            valid column of triggers table to plot on x-axis
        ycolumn : string
            valid column of triggers table to plot on y-axis
        zcolumn : string
            valid column of triggers table to use for colorbar (optional).
    """
    # work out dictionary or table
    if isinstance(lsctable, table.Table):
        tables = {"_":lsctable}
    else:
        tables = lsctable
    tablenames = tables.keys()
    tables     = [tables[n] for n in tablenames]

    # get axis limits
    xlim = kwargs.pop('xlim', None)
    ylim = kwargs.pop('ylim', None)
    zlim = kwargs.pop('zlim', None)
    colorlim = kwargs.pop('colorlim', None)
    if zlim and not colorlim:
        colorlim = zlim

    # set up columns
    columns = list(map(str.lower, [xcolumn, ycolumn]))
    if colorcolumn:
        columns.append(colorcolumn.lower())
        if rankcolumn:
            columns.append(rankcolumn.lower())
        else:
            columns.append(colorcolumn.lower())

    # set up limits
    limits = [xlim, ylim, zlim, None]

    # get zero
    if "time" in columns and not t0:
        if xlim:
            t0 = float(xlim[0])
        else:
            t0 = numpy.infty
            for t in tables:
                timedata = get_column(t, "time").astype(float)
                if len(timedata):
                    t0 = min(t0, timedata.min())
            if numpy.isinf(t0):
                t0 = 0
            t0 = int(t0)

    #
    # get data
    #

    # extract columns
    data = list()
    for i,name in enumerate(tablenames):
        data.append(list())
        for c in columns:
            c = c.lower()
            if ((c not in tables[i].columnnames and c != "time") and not
                    hasattr(tables[i], "get_%s" % c.lower())):
                raise RuntimeError("Column '%s' not found in table '%s'."\
                                   % (c,name))
            data[-1].append(get_column(tables[i], c.lower()).astype(float))
            if not len(data[-1][-1].shape)\
            or data[-1][-1].shape[0] != len(tables[i]):
                raise AttributeError("No data loaded for column \"%s\" and "\
                                     "table \"%s\"" % (c, name))

    # add our own limits
    for i in range(len(columns)):
        if not limits[i]:
            mins = [data[j][i].min() for j in range(len(tablenames))\
                    if len(data[j][i].shape) and data[j][i].shape[0] != 0]
            if len(mins):
                lmin = min(mins)
                lmax = max(data[j][i].max() for j in range(len(tablenames))\
                           if len(data[j][i]))
                limits[i] = [lmin, lmax]

    # get time unit
    if "time" in columns:
        idx = columns.index("time")
        if limits[idx]:
            unit, timestr = plotutils.time_axis_unit(limits[idx][1]\
                                                     - limits[idx][0])
        else:
            unit, timestr = plotutils.time_axis_unit(1)

    # format data
    for i,name in enumerate(tablenames):
        for j,column in enumerate(columns):
            if column == "time":
                data[i][j] = (data[i][j] - t0) / unit
                if i==0 and limits[j]:
                    limits[j] = [float(limits[j][0] - t0) / unit,\
                                 float(limits[j][1] - t0) / unit]

        # format a condition to reject triggers outside the plot range
        plotted = True
        for j,column in enumerate(columns):
            if limits[j]:
                plotted = plotted & (limits[j][0] <= data[i][j])\
                                  & (limits[j][1] >=  data[i][j])

        # apply the limits
        if not isinstance(plotted, bool):
            for j,d in enumerate(data[i]):
                data[i][j] = d[plotted]

    #
    # find loudest event
    #

    loudest = None
    if len(columns) == 4 and len(tablenames) == 1 and len(data[0][0]) > 0:
        idx = data[0][3].argmax()   
        loudest = [data[0][j][idx] for j in range(len(columns))]

    #
    # get or set the labels
    #

    label = {}
    for i,(label,column) in enumerate(zip(["xlabel", "ylabel", "colorlabel"],\
                                          columns)):
        # get given label
        l = kwargs.pop(label, None)
        if l is None:
            # format time string
            if column == "time" and limits[i]:
                zerostr = datetime.datetime(\
                              *date.XLALGPSToUTC(LIGOTimeGPS(t0))[:6])\
                                       .strftime("%B %d %Y, %H:%M:%S %ZUTC")
                l = "Time (%s) since %s (%s)" % (timestr, zerostr, t0)
            # format any other column
            else:
                l = plotutils.display_name(column)
        if label == "xlabel":
            xlabel = l
        elif label == "ylabel":
            ylabel = l
        else:
            colorlabel = l

    title = kwargs.pop("title", "")
    subtitle = kwargs.pop("subtitle", None)
    if subtitle is None and loudest:
        subtitle = "Loudest event by %s:" % plotutils.display_name(columns[-1])
        for j,c in enumerate(columns):
            if j!= 0 and c == columns[j-1]: continue
            lstr = loudest[j]
            if c == "time":
                lstr = lstr * unit + t0
            subtitle += " %s=%.2f" % (plotutils.display_name(c), lstr)
    else:
        loudest = None

    #
    # get parameters
    #

    # get axis scales
    logx     = kwargs.pop("logx", False)
    logy     = kwargs.pop("logy", False)
    logcolor = kwargs.pop("logcolor", False)

    # get legend loc
    loc  = kwargs.pop("loc", 0)

    # get colorbar options
    hidden_colorbar = kwargs.pop("hidden_colorbar", False)

    # get savefig option
    bbox_inches = kwargs.pop("bbox_inches", "tight")

    # get detchar plot params
    dqstyle  = (kwargs.pop("detchar", False) or
                kwargs.pop('detchar_style', False))
    dqthresh = (kwargs.pop('dcthreshold', False) or
                kwargs.pop('detchar_style_threshold', 10))

    # get greyscale param
    greyscale = kwargs.pop("greyscale", False)
    if greyscale and not kwargs.has_key("cmap"):
        kwargs["cmap"] =\
            pylab.matplotlib.colors.LinearSegmentedColormap("clrs",\
                                        pylab.matplotlib.cm.hot_r._segmentdata)
    elif not kwargs.has_key("cmap"):
        kwargs["cmap"] = jet

    #
    # make the plot
    #

    tablenames = map(plotutils.display_name, tablenames)

    if len(columns) == 2:
        plot = plotutils.ScatterPlot(xlabel, ylabel,title, subtitle)
        for i in range(len(tablenames)):
            plot.add_content(data[i][0], data[i][1], label=tablenames[i],\
                             **kwargs)
        plot.finalize(loc=loc)
        if hidden_colorbar:
            plotutils.add_colorbar(plot.ax, visible=False)
    else:
        if dqstyle:
            plot = plotutils.DQScatterPlot(xlabel, ylabel, colorlabel,\
                                           title, subtitle)
        else:
            plot = plotutils.ColorbarScatterPlot(xlabel, ylabel, colorlabel,\
                                                 title, subtitle)
        plot.add_content(data[0][0], data[0][1], data[0][2],\
                         label=tablenames[0], **kwargs)
        kwargs.pop("cmap", None)
        if dqstyle:
            plot.finalize(logcolor=logcolor, clim=colorlim, loc=loc,\
                          threshold=dqthresh)
        else:
            plot.finalize(logcolor=logcolor, clim=colorlim, loc=loc)

    # plot loudest
    if loudest:
        plot.ax.plot([loudest[0]], [loudest[1]], marker="*", color="gold",\
                     markersize=15)

    # set axes
    if logx:
        plot.ax.set_xscale("log")
    if logy:
        plot.ax.set_yscale("log")
    plot.ax.autoscale_view(tight=True, scalex=True, scaley=True)

    if limits[0]:
        plot.ax.set_xlim(limits[0])
    if limits[1]:
        plot.ax.set_ylim(limits[1])

    plot.ax.grid(True, which="both")
    if xcolumn == "time":
        plotutils.set_time_ticks(plot.ax)
    plotutils.set_minor_ticks(plot.ax)

    # save and close
    if greyscale:
        plot.ax.patch.set_facecolor("#E8E8E8")
    plot.savefig(outfile, bbox_inches=bbox_inches,\
                 bbox_extra_artists=plot.ax.texts)
    plot.close()
Пример #12
0
def plotrate(lsctable, outfile, stride=60, column="peak_frequency", bins=[],\
             t0=None, **kwargs):
    """
    Plot rate versus time for the given ligolw table triggers, binned by the
    given bincolumn using the bins list.

    Arguments:

        lsctable : glue.ligolw.table.Table
            LIGOLW table containing a list of triggers
        outfile : string
            string path for output plot
    """
    # get column data
    timedata = get_column(lsctable, "time")
    ratedata = get_column(lsctable, column)
    # sort in time
    if timedata.size:
        timedata, ratedata = map(numpy.asarray,\
                                 zip(*sorted(zip(timedata,ratedata),\
                                             key=lambda (t,r): t)))
    

    # get x-axis limits
    xlim = kwargs.pop("xlim", None)
    if xlim:
        start,end = xlim
    elif timedata.size:
        start = timedata.min()
        end   = timedata.max()
        xlim  = start, end
    else:
        start = 0
        end   = 1

    # get other params
    logx            = kwargs.pop("logx", False)
    logy            = kwargs.pop("logy", False)
    ylim            = kwargs.pop("ylim", False)
    hidden_colorbar = kwargs.pop("hidden_colorbar", False)
    bbox_inches     = kwargs.pop("bbox_inches", "tight")
    loc             = kwargs.pop("loc", 0)

    # get bins
    xbins = numpy.arange(float(start), float(end), stride)
    if not bins:
        bins = [[0, float("inf")]]
    ybins = [map(float, bin_) for bin_ in bins]

    # remove all triggers not in any bins
    xextent = (xbins[0], xbins[-1]+stride)
    yextent = (ybins[0][0], ybins[-1][-1])
    inanybin = (timedata > xextent[0]) & (timedata <= xextent[1])\
               & (ratedata > yextent[0]) & (ratedata <= yextent[1])
    timedata = timedata[inanybin]
    ratedata = ratedata[inanybin]

    ydata = numpy.zeros((len(xbins), len(ybins)))
    for i,xbin in enumerate(xbins):
        # work out index of first trigger outside x bin
        try:
            idx = (timedata >= xbin+stride).nonzero()[0][0]
            # get triggers in this time bin
            ratebin = numpy.asarray(sorted(ratedata[:idx]))
            break_ = False
            # get triggers in this time bin
            ratebin = numpy.asarray(sorted(ratedata[:idx]))
        except IndexError:
            idx = None
            ratebin = numpy.asarray(sorted(ratedata))
            break_ = True
        # loop over ybins
        for j,ybin in enumerate(ybins):
            # work out index of first trigger outside this y bin
            try:
                yidx = (ratebin >= ybin[1]).nonzero()[0][0]
            except IndexError:
                ydata[i][j] = len(ratebin)/stride
                break
            ydata[i][j] = len(ratebin[:yidx])/stride
            ratebin = ratebin[yidx:]
        if break_: break
        timedata = timedata[idx:]
    xdata = xbins + stride/2
 
    # set xlabel and renomalize time
    if t0:
        xdata -= t0
        start -= t0
        end -= t0
    xlabel = kwargs.pop("xlabel", None)
    if not xlabel:
        if not t0:
            t0 = start
            start -= t0
            end   -= t0
            xdata -= t0
        unit, timestr = plotutils.time_axis_unit(end-start)
        start /= unit
        end   /= unit
        xdata = xdata/unit
        t0 = LIGOTimeGPS(t0)
        if t0.nanoseconds==0:
            xlabel = datetime.datetime(*date.XLALGPSToUTC(LIGOTimeGPS(t0))[:6])\
                         .strftime("%B %d %Y, %H:%M:%S %ZUTC")
        else:
            xlabel = datetime.datetime(*date.XLALGPSToUTC(\
                                                  LIGOTimeGPS(t0.seconds))[:6])\
                          .strftime("%B %d %Y, %H:%M:%S %ZUTC")
            xlabel = "Time (%s) since %s (%s)"\
                     % (timestr,
                        xlabel.replace(" UTC", ".%.3s UTC" % t0.nanoseconds),\
                        t0)
    ylabel   = kwargs.pop("ylabel",   "Rate (Hz)")
    title    = kwargs.pop("title",    "")
    subtitle = kwargs.pop("subtitle", "")

    #
    # plot object
    #

    plot = plotutils.ScatterPlot(xlabel, ylabel, title, subtitle)

    # mask zeros for log plot
    if logy:
        ydata = numpy.ma.masked_where(ydata==0, ydata, copy=False)

    for i,ybin in enumerate(ybins):
        if list(ybin) == [0, numpy.inf]:
            label = "_"
        else:
            label = "%s-%s" % (ybin[0], ybin[1])
        plot.add_content(xdata, ydata[:,i], label=label, **kwargs)

    plot.finalize(loc=loc)
    if hidden_colorbar:
        plotutils.add_colorbar(plot.ax, visible=False)
    if logx:
        plot.ax.set_xscale("log")
    if logy:
        plot.ax.set_yscale("log")
    plot.ax.autoscale_view(tight=True, scalex=True, scaley=True)
    plot.ax.set_xlim(start, end)
    if ylim:
        plot.ax.set_ylim(ylim)

    # set grid and ticks
    plot.ax.grid(True, which="both")
    plotutils.set_time_ticks(plot.ax)
    plotutils.set_minor_ticks(plot.ax)

    # save
    plot.savefig(outfile, bbox_inches=bbox_inches,\
                 bbox_extra_artists=plot.ax.texts)
    plot.close()