Power control
=============

*This example is adapted from Boyd, Kim, Vandenberghe, and Hassibi,* "`A
Tutorial on Geometric
Programming <https://web.stanford.edu/~boyd/papers/pdf/gp_tutorial.pdf>`__."

*The problem data is adapted from the corresponding example in CVX's
example library (Almir Mutapcic).*

This example formulates and solves a power control problem for
communication systems, in which the goal is to minimize the total
transmitter power across n trasmitters, each trasmitting positive power
levels :math:`P_1`, :math:`P_2`, :math:`\ldots`, :math:`P_n` to
:math:`n` receivers, labeled :math:`1, \ldots, n`, with receiver
:math:`i` receiving signal from transmitter :math:`i`.

The power received from transmitter :math:`j` at receiver :math:`i` is
:math:`G_{ij} P_{j}`, where :math:`G_{ij} > 0` represents the path gain
from transmitter :math:`j` to receiver :math:`i`. The signal power at
receiver :math:`i` is :math:`G_{ii} P_i`, and the interference power at
receiver :math:`i` is :math:`\sum_{k \neq i} G_{ik}P_k`. The noise power
at receiver :math:`i` is :math:`\sigma_i`, and the signal to noise ratio
(SINR) of the :math:`i`\ th receiver-transmitter pair is

.. math::


   S_i = \frac{G_{ii}P_i}{\sigma_i + \sum_{k \neq i} G_{ik}P_k}.

The transmitters and receivers are constrained to have a minimum SINR
:math:`S^{\text{min}}`, and the :math:`P_i` are bounded between
:math:`P_i^{\text{min}}` and :math:`P_i^{\text{max}}`. This gives the
problem

.. math::


   \begin{array}{ll}
   \mbox{minimize} & P_1 + \cdots + P_n \\
   \mbox{subject to} & P_i^{\text{min}} \leq P_i \leq P_i^{\text{max}}, \\
   & 1/S^{\text{min}} \geq \frac{\sigma_i + \sum_{k \neq i} G_{ik}P_k}{G_{ii}P_i}.
   \end{array}

.. code:: python

    import cvxpy as cp
    import numpy as np
    
    # Problem data
    n = 5                     # number of transmitters and receivers
    sigma = 0.5 * np.ones(n)  # noise power at the receiver i
    p_min = 0.1 * np.ones(n)  # minimum power at the transmitter i
    p_max = 5 * np.ones(n)    # maximum power at the transmitter i
    sinr_min = 0.2            # threshold SINR for each receiver
    
    # Path gain matrix
    G = np.array(
       [[1.0, 0.1, 0.2, 0.1, 0.05],
        [0.1, 1.0, 0.1, 0.1, 0.05],
        [0.2, 0.1, 1.0, 0.2, 0.2],
        [0.1, 0.1, 0.2, 1.0, 0.1],
        [0.05, 0.05, 0.2, 0.1, 1.0]])
    p = cp.Variable(shape=(n,), pos=True)
    objective = cp.Minimize(cp.sum(p))
    
    S_p = []
    for i in range(n):
        S_p.append(cp.sum(cp.hstack(G[i, k]*p[k] for k in range(n) if i != k)))
    S = sigma + cp.hstack(S_p)
    signal_power = cp.multiply(cp.diag(G), p)
    inverse_sinr = S/signal_power
    constraints = [
        p >= p_min, 
        p <= p_max,
        inverse_sinr <= (1/sinr_min),
    ]
    
    problem = cp.Problem(objective, constraints)

.. code:: python

    problem.is_dgp()




.. parsed-literal::

    True



.. code:: python

    problem.solve(gp=True)
    problem.value




.. parsed-literal::

    0.9615384629119621



.. code:: python

    p.value




.. parsed-literal::

    array([0.18653846, 0.16730769, 0.23461538, 0.19615385, 0.17692308])



.. code:: python

    inverse_sinr.value




.. parsed-literal::

    array([5., 5., 5., 5., 5.])



.. code:: python

    (1/sinr_min)




.. parsed-literal::

    5.0