docs: def match(self, ra1, dec1, ra2, dec2, radius, maxmatch=1, convertToArray=True):
          """*Crossmatch two lists of ra/dec points*
  
          This is very efficient for large search angles and large lists. Note, if you need to match against the same points many times, you should use a `Matcher` object
  
          **Key Arguments:**
              - ``ra1`` -- list, numpy array or single ra value (first coordinate set)
              - ``dec1`` -- list, numpy array or single dec value (first coordinate set - must match ra1 array length)
              - ``ra2`` -- list, numpy array or single ra value (second coordinate set)
              - ``dec2`` -- list, numpy array or single dec value (second coordinate set - must match ra2 array length)
              - ``radius`` -- search radius in degrees. Can be list, numpy array or single value. If list or numpy array must be same length as ra1 array length)
              - ``maxmatch`` -- maximum number of matches to return. Set to `0` to match all points. Default *1* (i.e. closest match)
              - ``convertToArray`` -- convert the coordinates into an array. Default *True*. Can bypass the conversion check if you are sure coordinates in numpy array
  
          **Return:**
              - ``matchIndices1`` -- match indices for list1 (ra1, dec1)
              - ``matchIndices2`` -- match indices for list2 (ra2, dec2)
              - ``sepDeg`` -- separations between matched corrdinates in degrees. All returned arrays are the same size
  
  
          **Usage:**
  
              To match 2 lists of corrdinates try something like this:
  
              .. code-block:: python
  
                  twoArcsec = 2.0 / 3600.
                  raList1 = [200.0, 200.0, 200.0, 175.23, 21.36]
                  decList1 = [24.3,  24.3,  24.3,  -28.25, -15.32]
                  raList2 = [200.0, 200.0, 200.0, 175.23, 55.25]
                  decList2 = [24.3 + 0.75 * twoArcsec, 24.3 + 0.25 * twoArcsec,
                              24.3 - 0.33 * twoArcsec, -28.25 + 0.58 * twoArcsec, 75.22]
                  matchIndices1, matchIndices2, seps = mesh.match(
                      ra1=raList1,
                      dec1=decList1,
                      ra2=raList2,
                      dec2=decList2,
                      radius=twoArcsec,
                      maxmatch=0
                  )
  
                  for m1, m2, s in zip(matchIndices1, matchIndices2, seps):
                      print raList1[m1], decList1[m1], " -> ", s * 3600., " arcsec -> ", raList2[m2], decList2[m2]
  
              Note from the print statement, you can index the arrays ``raList1``, ``decList1`` with the ``matchIndices1`` array values and  ``raList2``, ``decList2`` with the ``matchIndices2`` values.
          """
  
          # CONVERT LISTS AND SINGLE VALUES TO ARRAYS OF FLOATS
          ra1 = numpy.array(ra1, dtype='f8', ndmin=1, copy=False)
          dec1 = numpy.array(dec1, dtype='f8', ndmin=1, copy=False)
          ra2 = numpy.array(ra2, dtype='f8', ndmin=1, copy=False)
          dec2 = numpy.array(dec2, dtype='f8', ndmin=1, copy=False)
          radius = numpy.array(radius, dtype='f8', ndmin=1, copy=False)
  
          # CHECK ARRAY SIZES MATCH
          if (ra1.size != dec1.size
                  or ra2.size != ra2.size):
              stup = (ra1.size, dec1.size, ra2.size, dec2.size)
              raise ValueError("ra1 must equal dec1 in size "
                               "and ra2 must equal dec2 in size, "
                               "got %d,%d and %d,%d" % stup)
  
          if radius.size != 1 and radius.size != ra2.size:
              raise ValueError("radius size (%d) != 1 and"
                               " != ra2,dec2 size (%d)" % (radius.size, ra2.size))
  
          # QUICK TRIMMING IN DEC SPACE OF BOTH SETS OF ARRAYS
          decMatchIndices2 = (numpy.abs(dec1[:, None] - dec2) < radius).any(0)
          decMatchIndices2 = numpy.where(decMatchIndices2)[0]
          ra2a = ra2[decMatchIndices2]
          dec2a = dec2[decMatchIndices2]
  
          decMatchIndices1 = (numpy.abs(dec2[:, None] - dec1) < radius).any(0)
          decMatchIndices1 = numpy.where(decMatchIndices1)[0]
          ra1a = ra1[decMatchIndices1]
          dec1a = dec1[decMatchIndices1]
  
          # new way using a Matcher
          depth = self.depth
          matcher = Matcher(
              log=self.log,
              depth=depth,
              ra=ra2a,
              dec=dec2a,
              convertToArray=convertToArray)
          matchIndices1, matchIndices2, seps = matcher.match(
              ra=ra1a,
              dec=dec1a,
              radius=radius,
              maxmatch=maxmatch)
  
          matchIndices1 = decMatchIndices1[matchIndices1]
          matchIndices2 = decMatchIndices2[matchIndices2]
  
          return matchIndices1, matchIndices2, seps