*match the orbfit generated object positions against atlas exposure footprint*

        **Key Arguments:**
            - ``orbfitEph`` -- the orbfit ephemerides
            - ``ra`` -- the ATLAS exposure RA (degrees)
            - ``dec`` -- the ATLAS exposure DEC (degrees)

        **Return:**
            - ``matchedEph`` -- the ephemerides of objects falling within the ATLAS exposure footprint

def _match_objects_against_atlas_footprint(
            self,
            orbfitEph,
            ra,
            dec):
        """*match the orbfit generated object positions against atlas exposure footprint*

        **Key Arguments:**
            - ``orbfitEph`` -- the orbfit ephemerides
            - ``ra`` -- the ATLAS exposure RA (degrees)
            - ``dec`` -- the ATLAS exposure DEC (degrees)

        **Return:**
            - ``matchedEph`` -- the ephemerides of objects falling within the ATLAS exposure footprint
        """
        self.log.info(
            'starting the ``_match_objects_against_atlas_footprint`` method')

        # GET THE ORBFIT MAG LIMIT
        magLimit = float(self.settings["orbfit"]["magnitude limit"])
        tileSide = float(self.settings["orbfit"]["atlas exposure match side"])

        pi = (4 * math.atan(1.0))
        DEG_TO_RAD_FACTOR = pi / 180.0
        RAD_TO_DEG_FACTOR = 180.0 / pi
        nside = 1024

        raFc = ra
        decFc = dec

        eph = []
        raArray = []
        decArray = []
        for o in orbfitEph:
            if float(o["apparent_mag"]) < magLimit:
                eph.append(o)
                raArray.append(float(o["ra_deg"]))
                decArray.append(float(o["dec_deg"]))

        raArray = np.array(raArray)
        decArray = np.array(decArray)
        healpix = hp.ang2pix(nside, theta=raArray, phi=decArray, lonlat=True)

        # GENERATE THE EXPOSURE HEALPIX ID MAP
        decCorners = (decFc - tileSide / 2,
                      decFc + tileSide / 2)
        corners = []
        for d in decCorners:
            if d > 90.:
                d = 180. - d
            elif d < -90.:
                d = -180 - d
            raCorners = (raFc - (tileSide / 2) / np.cos(d * DEG_TO_RAD_FACTOR),
                         raFc + (tileSide / 2) / np.cos(d * DEG_TO_RAD_FACTOR))
            for r in raCorners:
                if r > 360.:
                    r = 720. - r
                elif r < 0.:
                    r = 360. + r
                corners.append(hp.ang2vec(r, d, lonlat=True))

        # NEAR THE POLES RETURN SQUARE INTO TRIANGE - ALMOST DEGENERATE
        pole = False
        for d in decCorners:
            if d > 87.0 or d < -87.0:
                pole = True

        if pole == True:
            corners = corners[1:]
        else:
            # FLIP CORNERS 3 & 4 SO HEALPY UNDERSTANDS POLYGON SHAPE
            corners = [corners[0], corners[1],
                       corners[3], corners[2]]

        # RETURN HEALPIXELS IN EXPOSURE AREA
        expPixels = hp.query_polygon(nside, np.array(
            corners))

        # DICTIONARY STORES ALL THE RELEVANT COORDINATES
        dicto = defaultdict(list)
        for ind, (p, r, d, o) in enumerate(zip(healpix, raArray, decArray, eph)):
            dicto[p].append(o)

        matchedEph = []
        for ele in expPixels:
            if ele in dicto:
                matchedEph.append(dicto[ele][0])

        self.log.info(
            'completed the ``_match_objects_against_atlas_footprint`` method')
        return matchedEph