Esempio n. 1
0
def wireframe(*args, **kwargs):
    """
  Wireframe plot of 2D data. 

  Wire(fileID,fileNumber,plotLimits,viewingAngles,figSize):
  Args:
    fileID: ID for data files where files look like fileID_fileNum.dat e.g.
    if data files for SQ_RT data are SQ_RT_0.dat,SQ_RT_1.dat,SQ_RT_2.dat,...
    then the fileID is simply 'SQ_RT'

    fileNumber: Specifies which data file number to plot e.g. Wire('RT',10)
    will make a surface plot of the data file 'RT_10.dat' if this data file
    is available

    plotLimits = [minX,maxX,minY,maxY,minZ,maxZ]
    plotLimits: Specifies the Wire plot limits 
      minX:  Minimum x value limit
      maxX:  Maximum x value limit
      minY:  Minimum y value limit
      maxY:  Maximum y value limit
      minZ:  Minimum z value limit
      maxZ:  Maximum z value limit
      If no plotLimit list is given, then all data is used in the plots and
      then minimum and maximum graph limits will depend on the minimum and
      maximum data limits of the input and output variables. The plotLimits
      list can be empty, contain just xmin and xmax limits, contain just
      xmin,xmax,ymin,and ymax, or contain all limits
        e.g. Wire('RT',10,[0,1]) will plot data with x-limits between 
          0 and 1 
        e.g. Wire('RT',10,[0,1,-2,2]) will plot data with x-limits between
          0 and 1 and y-limits between -2 and 2.  
        e.g. Wire('RT',10,[0,1,-2,2,0,10]) will plot data with x-limits 
        between 0 and 1, y-limits between -2 and 2, and z-limits from 
        0 to 10 
        e.g. Wire('RT',10,[]) is the same as Wire('RT',10)

    **kwargs (optional)
    figsize : array or tuple containing width and height of figure

    overwrite : np.bool
        True -> current wireframe graph will be overwritten if it exists 
        False -> new figure created for each wireframe graph

    elev : float
        figure elevation as used in view_init
    azim : float
        figure azimuth as used in view_init

  """

    x, y, Z, auxDict = GetData2D(*args)
    x, y, Z, auxDict = ProcessData2D(x, y, Z, auxDict)
    X, Y = np.meshgrid(x, y)
    elev, azim = GetView(*args)
    auxDict['elev'] = elev
    auxDict['azim'] = azim

    width, height = _WireSize(*args)
    if 'overwrite' in kwargs and kwargs['overwrite']:
        fig = plt.figure("Wireframe", figsize=(width, height))
        fig.clf()
    else:
        fig = plt.figure(figsize=(width, height))

    ax = fig.gca(projection='3d')
    ax.w_xaxis.set_pane_color((0.0, 0.0, 0.0, 0.0))
    ax.w_yaxis.set_pane_color((0.0, 0.0, 0.0, 0.0))
    ax.w_zaxis.set_pane_color((0.0, 0.0, 0.0, 0.0))
    surf = ax.plot_wireframe(X, Y, Z, rstride=1, cstride=1, color='black')
    AuxAxes3DLabel(ax, auxDict)
    plt.ion()
    plt.show()
    return surf
Esempio n. 2
0
def plot(filename,figsize=None,xlim=None,ylim=None,\
        overwrite=False,complex_op=None,**kwargs):
    """
    Graph of 1D data file using Matplotlib plt.plot

    INPUTS:
        filename: string
            name of file containing 1D data to be plotted
        figsize: tuple (width,height)
            size of figure to be displayed
        xlim: np.array
            x-axis limits of graph
        ylim: np.array
            y-axis limits of graph
        overwrite: bool
            add lines to an existing plt.plot graph if it exists
            (default is False which will plot graph on a new figure)
        complex_op : string in the following list ('real','imag','power','absolute','angle')
            complex operation used to plot complex data
        **kwargs: dictionary
            (optional) arguments to be passed onto plt.loglog plot

    OUTPUTS:

        ax : matplotlib.axes.Axes
            Matplotlib axes object, allows for setting limits and other manipulation of the axes
            (e.g. ax.set_xlim([0,1]) would set the graph x-limits to be between 0 and 1)

    """
    x, y, auxDict = LoadData1D(filename)
    if complex_op is not None:
        y = ProcessComplex(complex_op, y)
    ExtendDictionary(auxDict,
                     figsize=figsize,
                     xlim=xlim,
                     ylim=ylim,
                     overwrite=overwrite)
    x, y, auxDict = ProcessData1D(x, y, auxDict)

    figsize = PlotSize(figsize)
    if xlim is None:
        xlim = [x[0], x[-1]]
    if ylim is None:
        ylim = [np.min(y), np.max(y)]

    labs = plt.get_figlabels()
    if overwrite:
        if "Plot" not in labs:
            configs.defaultLS()
        else:
            configs.toggleLS()
        plt.figure("Plot", figsize=figsize)
        if (configs.LS == 'k--'):
            plt.plot(x, y, configs.LS, dashes=(4, 2), **kwargs)
        else:
            plt.plot(x, y, configs.LS, **kwargs)
    else:
        plt.figure(figsize=figsize)
        configs.defaultLS()
        plt.plot(x, y, configs.LS, **kwargs)

    AuxPlotLabel1D(auxDict)
    if 'legend' in auxDict and configs._G['legend'] == 'on':
        plt.legend([str(auxDict["legend"])], loc='best')
    if xlim:
        plt.xlim(xlim)
    if ylim:
        plt.ylim(ylim)
    plt.ion()
    plt.show()
    ax = plt.gca()
    return ax
Esempio n. 3
0
def contourflog(filename,
                numlevels,
                decades,
                figsize=None,
                xlim=None,
                ylim=None,
                complex_op=None,
                overwrite=False,
                **kwargs):
    """
    Logged data contour plot of 2D data file using Matplotlib plt.contourf

    INPUTS:
        filename: string
            name of file containing 2D data to be plotted
        numlevels : int
            number of contour levels to plot
        decades: int
            maximum number of log10 decades to be plotted (starting with max value)
        figsize: tuple (width,height) 
            size of figure to be displayed
        xlim: np.array
            x-axis limits of graph
        ylim: np.array
            y-axis limits of graph
        complex_op : string (note this parameter is not used unless the data is complex)
            cop = 'power' -> for complex data graph the surface of the power of the data
            cop = 'absolute' -> for complex data graph the surface of the absolute value (abs(data))
            cop = 'angle' -> for complex data graph the surface of the absolute value (angle(data))
        overwrite: bool
            false (default) -> create new contourf plot figure
            true -> clear figure named 'Contourf' and make new contourf plot
        **kwargs: dictionary
            (optional) arguments to be passed onto plt.contourf plot

    OUTPUTS:

        None

    """

    x, y, Z, auxDict = LoadData2D(filename)
    if complex_op is not None:
        Z = ProcessComplex(complex_op, Z)
    ExtendDictionary(auxDict,decades=decades,figsize=figsize,\
            xlim=xlim,ylim=ylim,overwrite=overwrite)
    x, y, Z, auxDict = ProcessData2D(x, y, Z, auxDict)
    #    Z = ProcessDecadeLimits(decades,Z)

    figsize = ContourfSize(figsize)
    X, Y = np.meshgrid(x, y)
    levels, levelTicks, _ = ContourLevelsL(numlevels, decades, Z)

    if overwrite:
        fig = plt.figure("Contourflog", figsize=figsize)
        fig.clf()
    else:
        fig = plt.figure(figsize=figsize)

    if 'cmap' in kwargs:
        cmap = kwargs['cmap']
        del kwargs['cmap']
    else:
        cmap = str(configs._G["cmap"])

    plt.contourf(X,
                 Y,
                 Z,
                 levels,
                 cmap=cmap,
                 locator=ticker.LogLocator(),
                 **kwargs)
    ax = plt.gca()
    ax.set_xlabel(LabelX(auxDict))
    ax.set_ylabel(LabelY(auxDict))
    plt.colorbar(ticks=ticker.LogLocator())
    plt.ion()
    plt.show()
Esempio n. 4
0
def contourf(filename,levels=None,figsize=None,xlim=None,ylim=None,zlim=None,\
        decades=None,complex_op=None,overwrite=False,**kwargs):
    """
    Graph of 2D data file using Matplotlib plt.contourf

    INPUTS:
        filename: string
            name of file containing 2D data to be plotted
        levels : int or array-like (optional) 
            determines number and position of contour lines/regions
        figsize: tuple (width,height)
            size of figure to be displayed
        xlim: np.array
            x-axis limits of graph
        ylim: np.array
            y-axis limits of graph
        zlim: np.array [zmin,zmax]
            zmin -> minimum value data can take
            zmax -> maximum value data can take
        decades: int
            maximum number of log10 decades to be plotted (starting with max value)
        overwrite: bool
            false (default) -> create new contourf plot figure
            true -> clear figure named 'Contourf' and make new contourf plot
        complex_op : string in the following list ('real','imag','power','absolute','angle')
            complex operation used to plot complex data
        **kwargs: dictionary
            (optional) arguments to be passed onto plt.contourf plot

    OUTPUTS:

        None

    """

    x, y, Z, auxDict = LoadData2D(filename)
    if complex_op is not None:
        Z = ProcessComplex(complex_op, Z)
    ExtendDictionary(auxDict,levels=levels,figsize=figsize,xlim=xlim,ylim=ylim,zlim=zlim,\
            decades=decades,overwrite=overwrite)
    x, y, Z, auxDict = ProcessData2D(x, y, Z, auxDict)
    figsize = ContourfSize(figsize)
    X, Y = np.meshgrid(x, y)
    if zlim is not None:
        Z = ProcessContourLimitZ(zlim, Z)

    levels, levelTicks, _ = ContourLevels(levels, Z)
    if overwrite:
        fig = plt.figure("Contourf", figsize=figsize)
        fig.clf()
    else:
        fig = plt.figure(figsize=figsize)

    if 'cmap' in kwargs:
        cmap = kwargs['cmap']
        del kwargs['cmap']
    else:
        cmap = str(configs._G["cmap"])

    plt.contourf(X, Y, Z, levels, cmap=cmap, **kwargs)
    ax = plt.gca()
    ax.set_xlabel(LabelX(auxDict))
    ax.set_ylabel(LabelY(auxDict))
    plt.colorbar(ticks=levelTicks, format='%0.2e')
    plt.ion()
    plt.show()
Esempio n. 5
0
def loglog(filename,figsize=None,decades=None,xlim=None,ylim=None,\
        complex_op=None,overwrite=False,**kwargs):
    """
    Loglog graph of 1D data file using Matplotlib plt.loglog

    INPUTS:

        filename: string
            name of file containing 1D data to be plotted
        figsize: tuple (width,height)
            size of figure to be displayed
        xlim: np.array
            x-axis limits of graph
        ylim: np.array
            x-axis limits of graph
        decades: int
            number of decades of data below maximum to plot
        overwrite: bool
            add lines to an existing plt.semilogy graph if it exists
            (default is False which will create graph on a new figure)
        **kwargs: dictionary 
            (optional) arguments to be passed onto plt.loglog plot

    OUTPUTS:

        ax : matplotlib.axes.Axes 
            Matplotlib axes object, allows for setting limits and other manipulation of the axes
            (e.g. ax.set_xlim([0,1]) would set the graph x-limits to be between 0 and 1)

    """

    x, y, auxDict = LoadData1D(filename)
    if complex_op is not None:
        y = ProcessComplex(complex_op, y)
    if decades is None:
        decades = configs._G['decades']
    if xlim is None:
        xlim = [x[0], x[-1]]
    if ylim is None:
        ylim = [np.min(y), np.max(y)]
    figsize = LogLogSize(figsize)

    ExtendDictionary(auxDict,figsize=figsize,decades=decades,\
            xlim=xlim,ylim=ylim,overwrite=overwrite)
    x, y, auxDict = ProcessData1D(x, y, auxDict)
    figsize = LogLogSize(figsize)
    if overwrite:
        labs = plt.get_figlabels()
        if "LogLog" not in labs:
            configs.defaultLS()
        else:
            configs.toggleLS()
        plt.figure("LogLog", figsize=figsize)
    else:
        configs.defaultLS()
        plt.figure(figsize=figsize)

    fig = plt.loglog(x, y, configs.LS, **kwargs)
    plt.grid(True)
    AuxPlotLabelLL1D(auxDict)
    if xlim:
        plt.xlim(xlim)
    if ylim:
        plt.ylim(ylim)

    plt.ion()
    plt.show()
    return fig
Esempio n. 6
0
def surface(filename,figsize=None,xlim=None,ylim=None,zlim=None,\
        overwrite=False,complex_op=None,**kwargs):
    """
    Graph of 2D data file using Matplotlib plt.surface

    INPUTS:
        filename: string
            name of file containing 2D data to be plotted
        figsize: tuple (width,height)
            size of figure to be displayed
        xlim: np.array
            x-axis limits of graph
        ylim: np.array
            y-axis limits of graph
        zlim: np.array
            z-axis limits of graph
        overwrite: bool
            false (default) -> create new surface plot figure
            true -> clear figure named 'Surface' and make new surface plot
        complex_op : string in the following list ('real','imag','power','absolute','angle')
            complex operation used to plot complex data
            
        **kwargs: dictionary
            (optional) arguments to be passed onto plt.surface plot

    OUTPUTS:

        None

    """

    x, y, Z, auxDict = LoadData2D(filename)
    if complex_op is not None:
        Z = ProcessComplex(complex_op, Z)
    ExtendDictionary(auxDict,
                     figsize=figsize,
                     xlim=xlim,
                     ylim=ylim,
                     overwrite=overwrite)
    x, y, Z, auxDict = ProcessData2D(x, y, Z, auxDict)
    figsize = SurfaceSize(figsize)
    elev, azim = GetView(**kwargs)
    auxDict['elev'] = elev
    auxDict['azim'] = azim

    if xlim is None:
        xlim = [x[0], x[-1]]
    if ylim is None:
        ylim = [y[0], y[-1]]

    X, Y = np.meshgrid(x, y)

    if 'cmap' in kwargs:
        cmap = kwargs['cmap']
    else:
        cmap = str(configs._G["cmap"])

    if overwrite:
        fig = plt.figure("Surface", figsize=figsize)
        fig.clf()
    else:
        fig = plt.figure(figsize=figsize)

    ax = fig.add_subplot(projection='3d')
    ax.w_xaxis.set_pane_color((0.0, 0.0, 0.0, 0.0))
    ax.w_yaxis.set_pane_color((0.0, 0.0, 0.0, 0.0))
    ax.w_zaxis.set_pane_color((0.0, 0.0, 0.0, 0.0))
    ax.plot_surface(X,
                    Y,
                    Z,
                    rstride=1,
                    cstride=1,
                    cmap=cmap,
                    linewidth=0,
                    antialiased=True,
                    shade=True,
                    **kwargs)
    if zlim:
        ax.set_zlim3d(zlim)

    xlabel, ylabel, zlabel = Labels2D(auxDict)
    ax.set_xlabel(xlabel)
    ax.set_ylabel(ylabel)
    ax.set_zlabel(zlabel)
    ax.view_init(auxDict['elev'], auxDict['azim'])

    numTicks = int(configs._G['NumberSurfaceTicks'])
    ax.xaxis.set_major_locator(ticker.LinearLocator(numTicks))
    ax.yaxis.set_major_locator(ticker.LinearLocator(numTicks))
    ax.zaxis.set_major_locator(ticker.LinearLocator(4))

    labelType = str(configs._G['SurfaceTickFormat'])
    ax.xaxis.set_major_formatter(ticker.FormatStrFormatter(labelType))
    ax.yaxis.set_major_formatter(ticker.FormatStrFormatter(labelType))
    ax.zaxis.set_major_formatter(ticker.FormatStrFormatter(labelType))

    plt.ion()
    plt.show()
Esempio n. 7
0
def waterfall(fileID : str, fileNumbers : list,figsize=None,xlim=None,ylim=None,\
        complex_op=None,zvalstr=None,aspect=None,**kwargs):
    """
    INPUTS:
        fileID: str
            ID for data files where files look like fileID_fileNum.dat e.g.
            if data files for T data are T_0.dat,T_1.dat, T_2.dat,..., then the
            fileID is simply 'T' (extension is a catchall, doesnt have to be dat)
        fileNumbers: list[int]
            Specifies which data file numbers to plot 
            e.g.  waterfall('T',[0:2:100]) will plot files T_0.dat,T_2.dat,...,T_100.dat
        (see graphdata.plot.plot for info on other arguments)

        xlim: np.array
            x-axis limits of graph
        zlim: np.array
            z-axis limits of graph
        complex_op : string in the following list ('real','imag','power','absolute','angle')
            complex operation used to plot complex data
        zvalstr: str
            looks for metadata labeled zvalstr in the files, and will use these to plot z-axis with units
        aspect: tuple
            aspect ratio to use for xyz graph, e.g. (1,1,1) corresponds to a box
        **kwargs: dictionary
            (optional) arguments to be passed onto plt.plot plots

    OUTPUTS:
        ax : matplotlib.axes.Axes 
            Matplotlib axes object, allows for setting limits and other manipulation of the axes
            (e.g. ax.set_xlim([0,1]) would set the graph x-limits to be between 0 and 1)

    """

    fileList = GetDataFileList(fileID, fileNumbers)
    fileLen = len(fileList)
    count = 0
    auxDict = dict()
    x1 = [0] * len(fileList)
    figsize = WaterfallSize(figsize)
    fig = plt.figure(figsize=figsize)
    ax = fig.add_subplot(projection='3d')

    ax.w_xaxis.set_pane_color((0.0, 0.0, 0.0, 0.0))
    ax.w_yaxis.set_pane_color((0.0, 0.0, 0.0, 0.0))
    ax.w_zaxis.set_pane_color((0.0, 0.0, 0.0, 0.0))
    count = 0
    normFact = 1.0
    for i, filename in enumerate(fileList):
        x, y, auxDict = LoadData1D(filename)
        if complex_op is not None:
            y = ProcessComplex(complex_op, y)
        ExtendDictionary(auxDict,figsize=figsize,xlim=xlim,\
                ylim=ylim,complex_op=complex_op)
        x, y, auxDict = ProcessData1D(x, y, auxDict)
        if zvalstr is not None and zvalstr in auxDict:
            x1[i] = float(auxDict[zvalstr])
        else:
            x1[i] = i
        ax.plot(x, x1[i] * np.ones_like(x), y, color='black', **kwargs)

    if xlim is None:
        xlim = [x[0], x[-1]]
    plt.xlim(xlim)

    if ylim is not None:
        ax.set_zlim3d(ylim)

    zmin = np.amin(x1)
    zmax = np.amax(x1)
    plt.ylim([zmin, zmax])

    if 'xlabel' in auxDict:
        ax.set_xlabel(auxDict['xlabel'])
    else:
        ax.set_xlabel('x')

    if 'ylabel' in auxDict:
        ax.set_zlabel(auxDict['ylabel'])
    else:
        ax.set_zlabel('y')

    if zvalstr is not None:
        ax.set_ylabel(zvalstr)
    else:
        ax.set_ylabel('file')

    elev, azim = GetView(**kwargs)
    ax.view_init(elev, azim)
    if aspect is not None:
        ax.set_box_aspect(aspect=aspect)
    plt.ion()
    plt.show()
    plt.tight_layout()
    return ax