docs: 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])