def METHOD_NAME(
    self, smin, smax, dMag, subpop=-2, tmax=0.0, starMass=const.M_sun, IACbool=False
):
    """Calculates completeness for given minimum and maximum separations  and dMag
    Args:
        smin (float numpy.ndarray):
            Minimum separation(s) in AU
        smax (float numpy.ndarray):
            Maximum separation(s) in AU
        dMag (float numpy.ndarray):
            Difference in brightness magnitude
        subpop (int):
            planet subtype to use for calculation of int_comp
            -2 - planet population
            -1 - earthLike population
            (i,j) - kopparapu planet subtypes
        tmax (float):
            the integration time of the observation in days
        starMass (float):
            star mass in units of M_sun
        IACbool (bool):
            Use integration time-adjusted completeness or normal Brown completeness
            If False, tmax does nothing.  Defaults False.
    Returns:
        numpy.ndarray:
            comp, SubtypeCompleteness Completeness values (Brown's method mixed with
            classification) or integration time adjusted completeness
            totalCompleteness_maxIntTimeCorrected
    ..note::
        This method assumes scaling orbits when scaleOrbits == True has already
        occurred for smin, smax, dMag inputs
    """
    if IACbool:
        self.vprint(len(self.sma))
        sma = self.sma
        e = self.e
        W = self.W
        w = self.w
        inc = self.inc
        p = self.p
        Rp = self.Rp
        # If we are assuming a constant star mass
        if starMass.size == 1:
            # Pass in as TL object?
            # starMass #set as default of 1 M_sun
            plotBool = False  # need to remove eventually
            periods = self.periods * np.sqrt(
                const.M_sun / starMass
            )  # need to pass in
            # inputs
            s_inner = smin
            s_outer = smax
            dmag_upper = dMag
            if dmag_upper > 0.0:
                # input tmax
                totalCompleteness_maxIntTimeCorrected = (
                    integrationTimeAdjustedCompletness(
                        sma,
                        e,
                        W,
                        w,
                        inc,
                        p,
                        Rp,
                        starMass,
                        plotBool,
                        periods,
                        s_inner,
                        s_outer,
                        dmag_upper,
                        tmax,
                    )
                )
            else:
                totalCompleteness_maxIntTimeCorrected = 0
            return totalCompleteness_maxIntTimeCorrected
        else:  # sim.TargetList.MsEst >= 100
            totalCompleteness_maxIntTimeCorrected = np.zeros(len(starMass))
            # Iterate over each Star Mass Provided and calculate completeness
            # for each one
            for i in np.arange(len(starMass)):
                # Pass in as TL object?
                # starMass #set as default of 1 M_sun
                plotBool = False  # need to remove eventually
                periods = self.periods * np.sqrt(
                    const.M_sun / starMass[i]
                )  # need to pass in
                # inputs
                s_inner = smin[i]
                s_outer = smax[i]
                dmag_upper = dMag[i]
                if dmag_upper > 0.0:
                    # input tmax
                    totalCompleteness_maxIntTimeCorrected[
                        i
                    ] = integrationTimeAdjustedCompletness(
                        sma,
                        e,
                        W,
                        w,
                        inc,
                        p,
                        Rp,
                        np.ones(len(sma)) * starMass[i],
                        plotBool,
                        periods,
                        s_inner,
                        s_outer,
                        dmag_upper,
                        tmax[i].value,
                    )
                else:
                    totalCompleteness_maxIntTimeCorrected[i] = 0
            return totalCompleteness_maxIntTimeCorrected
    else:
        if subpop == -2:
            comp = self.EVPOC_pop(smin, smax, 0.0, dMag)
        elif subpop == -1:
            comp = self.EVPOC_earthlike(smin, smax, 0.0, dMag)
        else:
            comp = self.EVPOC_hs[subpop[0], subpop[1]](smin, smax, 0.0, dMag)
        # remove small values
        comp[comp < 1e-6] = 0.0
        return comp