def METHOD_NAME(effective_irradiance, temp_cell,
                     k_a, k_d, tc_d, k_rs, k_rsh):
    '''
    Calculate PV module efficiency using the ADR model.
    The efficiency varies with irradiance and operating temperature
    and is determined by 5 model parameters as described in [1]_.
    Parameters
    ----------
    effective_irradiance : numeric, non-negative
        The effective irradiance incident on the PV module. [W/m^2]
    temp_cell : numeric
        The PV module operating temperature. [°C]
    k_a : numeric
        Absolute scaling factor, which is equal to the efficiency at
        reference conditions. This factor allows the model to be used
        with relative or absolute efficiencies, and to accommodate data sets
        which are not perfectly normalized but have a slight bias at
        the reference conditions. [unitless]
    k_d : numeric, negative
        “Dark irradiance” or diode coefficient which influences the voltage
        increase with irradiance. [unitless]
    tc_d : numeric
        Temperature coefficient of the diode coefficient, which indirectly
        influences voltage. Because it is the only temperature coefficient
        in the model, its value will also reflect secondary temperature
        dependencies that are present in the PV module. [unitless]
    k_rs : numeric
        Series resistance loss coefficient. Because of the normalization
        it can be read as a power loss fraction at reference conditions.
        For example, if ``k_rs`` is 0.05, the internal loss assigned to the
        series resistance has a magnitude equal to 5% of the module output.
        [unitless]
    k_rsh : numeric
        Shunt resistance loss coefficient. Can be interpreted as a power
        loss fraction at reference conditions like ``k_rs``.
        [unitless]
    Returns
    -------
    eta : numeric
        The efficiency of the module at the specified irradiance and
        temperature.
    Notes
    -----
    Efficiency values ``eta`` may be absolute or relative, and may be expressed
    as percent or per unit.  This is determined by the efficiency data
    used to derive values for the 5 model parameters.  The first model
    parameter ``k_a`` is equal to the efficiency at STC and therefore
    indicates the efficiency scale being used. ``k_a`` can also be changed
    freely to adjust the scale, or to change the module to a slightly
    higher or lower efficiency class.
    All arguments may be scalars or array-like. If multiple arguments
    are array-like they must be the same shape or broadcastable to the
    same shape.
    See also
    --------
    pvlib.pvarray.fit_pvefficiency_adr
    References
    ----------
    .. [1] A. Driesse and J. S. Stein, "From IEC 61853 power measurements
       to PV system simulations", Sandia Report No. SAND2020-3877, 2020.
       :doi:`10.2172/1615179`
    .. [2] A. Driesse, M. Theristis and J. S. Stein, "A New Photovoltaic Module
       Efficiency Model for Energy Prediction and Rating," in IEEE Journal
       of Photovoltaics, vol. 11, no. 2, pp. 527-534, March 2021.
       :doi:`10.1109/JPHOTOV.2020.3045677`
    Examples
    --------
    >>> pvefficiency_adr([1000, 200], 25,
            k_a=100, k_d=-6.0, tc_d=0.02, k_rs=0.05, k_rsh=0.10)
    array([100.        ,  92.79729308])
    >>> pvefficiency_adr([1000, 200], 25,
            k_a=1.0, k_d=-6.0, tc_d=0.02, k_rs=0.05, k_rsh=0.10)
    array([1.        , 0.92797293])
    '''
    # Contributed by Anton Driesse (@adriesse), PV Performance Labs, Dec. 2022
    # Adapted from https://github.com/adriesse/pvpltools-python
    k_a = np.array(k_a)
    k_d = np.array(k_d)
    tc_d = np.array(tc_d)
    k_rs = np.array(k_rs)
    k_rsh = np.array(k_rsh)
    # normalize the irradiance
    G_REF = np.array(1000.)
    s = effective_irradiance / G_REF
    # obtain the difference from reference temperature
    T_REF = np.array(25.)
    dt = temp_cell - T_REF
    # equation 29 in JPV
    s_o     = exp10(k_d + (dt * tc_d))                             # noQA: E221
    s_o_ref = exp10(k_d)
    # equation 28 and 30 in JPV
    # the constant k_v does not appear here because it cancels out
    v  = np.log(s / s_o     + 1)                                   # noQA: E221
    v /= np.log(1 / s_o_ref + 1)
    # equation 25 in JPV
    eta = k_a * ((1 + k_rs + k_rsh) * v - k_rs * s - k_rsh * v**2)
    return eta