def plot(self, atrix, atriy, fname=None, numtype='ndump',
             legend=None, labelx=None, labely=None, indexx=None,
             indexy=None, title=None, shape='.', logx=False,
             logy=False, path='/', base=10, sparse=1, show=True, pdf=False,limits=None,
             markevery=None, linewidth=1):
        """
        Simple function that plots atriy as a function of atrix

        This method will automatically find and plot the requested data.

        Parameters
        ----------
        atrix : string
            The name of the attribute you want on the x axis.
        atriy : string
            The name of the attribute you want on the Y axis.
        fname : optional
            Be the filename, Ndump or time, or cycle, If fname is a
            list, this method will then save a png for each cycle in the
            list.  Warning, this must be a list of cycles and not a
            list of filenames. The default is None.
        numtype : string, optional
            designates how this function acts and how it interprets
            fname. if numtype is 'file', this function will get the
            desird attribute from that file.  if numtype is 'NDump'
            function will look at the cycle with that nDump.  if numtype
            is 't' or 'time' function will find the _cycle with the
            closest time stamp. The default is 'ndump'.
        legend : list or intager, optional
            A list of legends for each of your cycles, or one legend for
            all of the cycles. The default is None.
        labelx : string, optional
            The label on the X axis. The default is None.
        labely : string, optional
            The label on the Y axis. The default is None.
        indexx : optional
            Depreciated: If the get method returns a list of lists,
            indexx would be the list at the index indexx in the list.
            The default is None.
        indexy : optional
            Depreciated: If the get method returns a list of lists,
            indexy would be the list at the index indexx in the list.
            The default is None.
        title : string, optional
            The Title of the Graph. The default is None.
        shape : string, optional
            What shape and colour the user would like their plot in.
            Please see
            http://matplotlib.sourceforge.net/api/pyplot_api.html#matplotlib.pyplot.plot
            for all possible choices. The default is '.'.
        logx : boolean, optional
            A boolean of weather the user wants the x axi
            logarithmically. The default is False.
        logy : boolean, optional
            A boolean of weather the user wants the Y axis
            logarithmically. The default is False.
        path : string, optional
            Usef for PlotMulti, give the path where to save the Figures
        base : integer, optional
            The base of the logarithm. The Default is 10.
        sparse : integer, optional
            Argument that skips every so many data points. For example
            if this argument was 5, This method would plot the 0th, 5th,
            10th ... elements. The default is 1.
        show : boolean, optional
            A boolean of if the plot should be displayed useful with the
            multiPlot method. The default is True.
        pdf : boolean, optional
            PDF for PlotMulti? Default: False
        limits : list, optional
            The length four list of the x and y limits. The order of the
            list is xmin, xmax, ymin, ymax. The defautl is .
        markevery : integer or tupler, optional
            Set the markevery property to subsample the plot when
            using markers.  markevery can be None, very point will be
            plotted. It can be an integer N, Every N-th marker will be
            plotted starting with marker 0. It can be a tuple,
            markevery=(start, N) will start at point start and plot
            every N-th marker. The default is None.
        linewidth : integer, optional
            Set linewidth. The default is 1.

        Notes
        -----
        WARNING: Unstable if get returns a list with only one element (x=[0]).

        parameters: indexx and indexy have been deprecated.
        """
        t1=time.time()
        #Setting the axis labels

        if labelx== None :
            labelx=atrix
        if labely== None :
            labely=atriy

        if title!=None:
            title=title
        else:
            title=labely+' vs '+labelx

        if str(fname.__class__)=="<type 'list'>":
            self.plotMulti(atrix,atriy,fname,title,path,legend,labelx,labely,logx, logy, 10,1,pdf,limits)
            return
        tmpX=[]
        tmpY=[]
        singleX=False
        singleY=False
        #Getting data
        plotType=self._classTest()
        if plotType=='YProfile':
            if fname==None:
                fname=self.cycles[-1]

            listY=self.get(atriy,fname, numtype,resolution='a')
            listX=self.get(atrix,fname, numtype,resolution='a')
        elif plotType=='se':
            if fname==None:
                listY=self.get( atriy,sparse=sparse)
                listX=self.get(atrix,sparse=sparse)
            else:
                listY=self.get(fname, atriy,sparse=sparse)
                listX=self.get(fname, atrix,sparse=sparse)

            t2= time.time()
            print(t2 -t1)
        elif plotType=='PPN' :
            if fname==None and atrix not in self.cattrs and atriy not in self.cattrs:
                fname=len(self.files)-1
            if numtype=='ndump':
                numtype='cycNum'
            listY=self.get(atriy,fname,numtype)
            listX=self.get(atrix,fname,numtype)
        elif plotType=='xtime' or plotType=='mesa_profile' or plotType=='AsciiTable' or plotType=='mesa.star_log' or plotType=='starobs':
            listY=self.get(atriy)
            listX=self.get(atrix)
        else:
            listY=self.get(atriy)
            listX=self.get(atrix)
        tmpX=[]
        tmpY=[]
        if isinstance(listX[0], basestring) or isinstance(listY[0], basestring):
            for i in range(len(listX)):
                if '*****' == listX[i] or '*****' == listY[i]:
                    print('There seems to be a string of * in the lists')
                    print('Cutting out elements in both the lists that have an index equal to or greater than the index of the location of the string of *')
                    break
                tmpX.append(float(listX[i]))
                tmpY.append(float(listY[i]))

            listX=tmpX
            listY=tmpY




        #Determining if listX is a list or a list of lists
        try:
            j=listX[0][0]
        except:
            singleX = True

        if len(listX) == 1:  # If it is a list of lists with one element.
            tmpX=listX[0]
        elif singleX == True:# If it is a plain list of values.
            tmpX=listX
        elif indexx==None and len(listX)>1: # If it is a list of lists of values.
                                            # take the largest
            tmpX=listX[0]
            for i in range(len(listX)):
                if len(tmpX)<len(listX[i]):
                    tmpX=listX[i]
        elif indexx<len(listX): # If an index is specified, use that index
            tmpX=listX[indexx]
        else:
            print('Sorry that indexx does not exist, returning None')
            return None

        #Determining if listY is a list or a list of lists
        try:
            j=listY[0][0]
        except:
            singleY = True

        if len(listY) == 1: # If it is a list of lists with one element.
            #print 'hello'
            tmpY=listY[0]
        elif singleY == True: # If it is a plain list of values.
            #print 'world'
            tmpY=listY
        elif indexy==None and len(listY)>1:# If it is a list of lists of values.
                                            # take the largest
            #print 'fourth'
            tmpY=listY[0]
            for i in range(len(listY)):
                if len(tmpY)<len(listY[i]):
                    tmpY=listY[i]
        elif indexy<len(listY): # If an index is specified, use that index
            #print 'sixth'
            tmpY=listY[indexy]
        else:
            print('Sorry that indexy does not exist, returning None')
            return None
        '''
        elif indexy==None and len(listY)==1:
                #print 'fifth'
                tmpY=listY
        '''




        #Here, if we end up with different sized lists to plot, it
        #searches for a list that is of an equal length
        if len(tmpY)!=len(tmpX):
            found=False
            print("It seems like the lists are not of equal length")
            print("Now attempting to find a compatible list for ListX")
            for i in range(len(listY)):
                if not singleY and len(tmpX)==len(listY[i]):
                    tmpY=listY[i]
                    found=True

            if not found:
                print("Now attempting to find a compatible list for ListY")
                for i in range(len(listX)):

                    if not singleX and len(tmpY)==len(listX[i]):
                        tmpX=listX[i]
                        found=True

            if found:
                print("Suitable list found")
            else:

                print("There is no suitalble list, returning None")
                return None
        if len(tmpY)!=len(tmpX) and single == True:
            print('It seems that the selected lists are of different\nsize, now returning none')
            return None
        # Sparse stuff
        if plotType!='se':
            tmpX,tmpY=self._sparse(tmpX,tmpY, sparse)

        # Logarithm stuff
        if logy or logx:
            tmpX,tmpY=self._logarithm(tmpX,tmpY,logx,logy,base)

        # Here it ensures that if we are plotting ncycle no values of '*' will be plotted
        tmX=[]
        tmY=[]
        for i in range(len(tmpX)):
            tmX.append(str(tmpX[i]))
            tmY.append(str(tmpY[i]))

        tmpX=[]
        tmpY=[]
        for i in range(len(tmX)):
            if '*' in tmX[i] or '*' in tmY[i]:
                print('There seems to be a string of * in the lists')
                print('Cutting out elements in both the lists that have an index equal to or greater than the index of the location of the string of *')
                break
            tmpX.append(float(tmX[i]))
            tmpY.append(float(tmY[i]))
        listX=tmpX
        listY=tmpY

        #Setting the axis labels

        if logx:
            labelx='log '+labelx
        if logy:
            labely='log '+labely

        if legend!=None:
            legend=legend
        else:
            legend=labely+' vs '+labelx



        pl.plot(listX,listY,shape,label=legend,markevery=markevery,linewidth=linewidth)
        pl.legend()
        pl.title(title)
        pl.xlabel(labelx)
        pl.ylabel(labely)
        if show:
            pl.show()

        if limits != None and len(limits)==4:

            pl.xlim(limits[0],limits[1])
            pl.ylim(limits[2],limits[3])