Central Optimization Code.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from cvxpy import *\n",
    "# import gurobipy\n",
    "import numpy as np\n",
    "import scipy as sp\n",
    "import pandas as pd\n",
    "import cvxopt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Function definition for constraints\n",
    "def deferrableConstraints(p=np.asmatrix([1,2]).T,nT=24,earliestStart=1,latestStart=24):\n",
    "# function constraintStruct = deferrableConstraints(p,nT,earliestStart,latestStart)\n",
    "    # p: vector of power consumption in each time period; tall and skinny\n",
    "    # nT: Number of time steps in the study period (i.e. 24h in a day)\n",
    "    # earliestStart: Integer number of time step for allowable start\n",
    "    # latestEnd: Integer number of time time step for latest start,\n",
    "\n",
    "    # For Testing\n",
    "#     p = def_profile\n",
    "#     nT=24\n",
    "#     earliestStart=8\n",
    "    latestStart=nT-len(p)\n",
    "\n",
    "    L = nT\n",
    "    G = len(p) # Number of steps in operation of the deferrable load\n",
    "    lbar = 1   # For MPC/CEC, this is the time step we're currently considering\n",
    "\n",
    "    dim1 = L - lbar + 1\n",
    "    dim2 = L - lbar + min(lbar, G)\n",
    "\n",
    "    c1    = np.zeros((dim1,1))\n",
    "    c1[0] = p[0]\n",
    "    r1    = np.vstack((p,np.zeros((dim2-G,1))))\n",
    "    omega = sp.linalg.toeplitz(c1,r1)\n",
    "\n",
    "    r1   = np.zeros((dim2,1))\n",
    "    r1[0]= 1\n",
    "    r1[1]= -1\n",
    "    c1   = np.zeros((dim2,1))\n",
    "    c1[0]= r1[0]\n",
    "    y = sp.linalg.toeplitz(c1,r1)\n",
    "\n",
    "    # y.T * omega# * d  # This will produce the power consumption schedule for a given d \n",
    "\n",
    "    # Set up the a-vector (the dispatch command vector)\n",
    "    maxDelay  = L - latestStart - earliestStart\n",
    "    zeta = maxDelay    #zeta term from eqn (13b)\n",
    "\n",
    "    a = np.vstack((np.zeros((earliestStart-1,1)),np.ones((L-earliestStart+1,1)))) # Not sure what these are doing\n",
    "    a_shift = np.vstack((np.zeros((earliestStart+zeta,1)),np.ones((latestStart,1))))\n",
    "\n",
    "    # Constraint matrix for d(l-1)<=d(l), or d(l-1)-d(l)<=0.\n",
    "    #   Assumes that we prepend 0 to d for this constraint.\n",
    "    A_increasing = sp.linalg.toeplitz(np.vstack((1,np.zeros((L-1,1)))),np.vstack((1,-1,np.zeros((L-1,1)))))\n",
    "    # A_increasing = toeplitz([1;zeros(L-1,1)],[1;-1;zeros(L-1,1)]);\n",
    "\n",
    "    constraintStruct = {}\n",
    "    constraintStruct['y'] = y\n",
    "    constraintStruct['omega'] = omega\n",
    "    constraintStruct['A_increasing'] = A_increasing\n",
    "    constraintStruct['a'] = a\n",
    "    constraintStruct['a_shift'] = a_shift\n",
    "\n",
    "    return constraintStruct"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Network Data\n",
    "\n",
    "# Base values for Test Network\n",
    "s_base = 1.0e3 #VA\n",
    "v_base = 12.35e3 #V\n",
    "z_base = (v_base**2)/s_base\n",
    "\n",
    "# Test Network Data\n",
    "basic_data = pd.read_csv('Data/basic_data.csv',header=None)#, columns=['f','t','r','x'])\n",
    "basic_data.columns = ['f','t','r','x']\n",
    "\n",
    "cutNode = len(basic_data); # include the whole network\n",
    "cutNode = 17;  # Cut the network off after this node for faster run time. Good cuts: 17. Using Python indexing this is still 17, due to indexing!\n",
    "\n",
    "# Convert into a model of the network\n",
    "f = np.array(basic_data['f'].iloc[:cutNode])-1\n",
    "t = np.array(basic_data['t'].iloc[:cutNode])-1\n",
    "r = np.array(basic_data['r'].iloc[:cutNode])\n",
    "x = np.array(basic_data['x'].iloc[:cutNode])\n",
    "r = np.insert(r,0,0)/z_base\n",
    "x = np.insert(x,0,0)/z_base\n",
    "R = np.diag(r)\n",
    "X = np.diag(x)\n",
    "Rsub = R[1:,1:] # need these for constraints later\n",
    "Xsub = X[1:,1:]\n",
    "\n",
    "# Network Properties\n",
    "nb = np.int64(max(t)+1)  # Number of buses\n",
    "nl = np.int64(len(t))    # Number of lines\n",
    "\n",
    "# parent = sparse(t,f,ones(nl,1),nb,nb); #column is the parent of row\n",
    "# child = sparse(f,t,ones(nl,1),nb,nb); #column is the child of row (interestingly child = parent').\n",
    "\n",
    "from scipy.sparse import coo_matrix\n",
    "\n",
    "#column is the parent of row\n",
    "parent = coo_matrix((np.ones((nl,)), (t, f)), shape=(nb,nb)).toarray() # Column is the parent of this row # Lose the to array if dealing with big matrices and use the Constant function for cvxpy.\n",
    "child = coo_matrix((np.ones((nl,)), (f, t)), shape=(nb,nb)).toarray()  # Column is the child of this row (interestingly, child = parent')\n",
    "parent = parent.astype(int)\n",
    "child = child.astype(int)\n",
    "# parent = Constant(parent)\n",
    "# child = Constant(child)\n",
    "\n",
    "# Time Data\n",
    "T = np.int64(24) # if there is no time coupling, leave at 1 for low solve time.\n",
    "dt = np.int64(1) # time step in hours\n",
    "\n",
    "# Generator cost coefficients - random for now\n",
    "# alpha = zeros(nb,1);\n",
    "alpha = (0.1 + (0.2-0.1)*np.random.rand(nb,1))*s_base**2\n",
    "beta = (10 + (20-10)*np.random.rand(nb,1))*s_base\n",
    "gamma = 100 + (200-100)*np.random.rand(nb,1)\n",
    "\n",
    "# Price of electricity from the grid (if we want grid-connected)\n",
    "LMP_price = np.array(pd.read_csv('Data/EnergyPrice.csv',header=None))\n",
    "price = LMP_price / max(LMP_price) # Scale to [0,1]\n",
    "\n",
    "import numpy.random\n",
    "g_min = np.zeros((nb,T)) # These are setup to give feeder lots of power, other buses less so.\n",
    "g_max = (0.5e3 + (1e3-0.5e3)*np.random.rand(nl,1))\n",
    "g_max = np.insert(g_max,0,nl*10e3)/s_base\n",
    "import numpy.matlib\n",
    "g_max = np.matlib.repmat(np.asmatrix(g_max).transpose(),1,T)\n",
    "\n",
    "# Load Data - random for now\n",
    "fixed_load_p = np.vstack((np.zeros((1,T)),(2e3 + (10e3-2e3)*np.random.rand(nl,T))))/s_base\n",
    "fixed_load_q = np.vstack((np.zeros((1,T)),(100 + (200-1002)*np.random.rand(nl,T))))/s_base\n",
    "\n",
    "\n",
    "# Scale loads using the price profile, with random noise 20% of the signal\n",
    "fixed_load_p = 0.3 * fixed_load_p + 0.7 * np.dot(np.asmatrix(np.mean(fixed_load_p,axis=1)).T,price.transpose())\n",
    "fixed_load_q = 0.3 * fixed_load_q + 0.7 * np.dot(np.asmatrix(np.mean(fixed_load_q,axis=1)).T,price.transpose())\n",
    "\n",
    "nbOnes = np.ones((nb, 1)) # Use this to turn scalars into bus-vectors\n",
    "ntOnes = np.ones((T,1))   # Use this to turn scalars into time-vectors\n",
    "loadScale = 0.001;\n",
    "\n",
    "# Solar data\n",
    "p_sol = pd.read_csv('Data/SolarOutput.csv',header=None) # Just take solar output (not hours)\n",
    "p_sol = p_sol[1] / max(p_sol[1]) # Normalize profile\n",
    "p_sol = np.matlib.repmat(np.asmatrix(p_sol),nb,1) # Stack for each node\n",
    "solar_probability = 0.6\n",
    "solar_present = np.round(solar_probability - 0.5 + (np.random.rand(nb,1)))\n",
    "max_sol = 1.5*np.multiply(np.max(fixed_load_p,axis=1),solar_present)# 1.5 is the factor by which the solar panel is designed to exceed demand;\n",
    "p_sol = np.dot(np.diag(np.asarray(max_sol).flatten()),p_sol)  # Scale solar output by the max power of each node\n",
    "\n",
    "# Deferrable Load \n",
    "def_profile = np.asmatrix([0.1, 1.5, 2.0, 0.5, 0.5, 1.0]).T # Demand profile for the deferrable load\n",
    "# def_profile= np.asmatrix([1,2]).T  # Simple test load\n",
    "def_profile = def_profile / max(def_profile)\n",
    "def_profile = def_profile*np.mean(np.max(fixed_load_p,axis=1))  # Scale so that the fixed load maximum is the same as the average household maximum\n",
    "steps = len(def_profile)\n",
    "defConst = deferrableConstraints(def_profile, T, 8) # Generate constraints in form (p, T, ,earliestStart,latestStart)\n",
    "\n",
    "# Battery parameters\n",
    "eff_in = 0.95 # Battery efficiency\n",
    "eff_out = 0.95  \n",
    "p_battmax = np.max(fixed_load_p,axis=1)*0.5;\n",
    "hours = 4\n",
    "battsize = hours * p_battmax          # Battery size in Watts*dt (i.e. Wh if dt=1 hour)\n",
    "E_min = 0.2 * battsize  # SOC lower limits on batteries\n",
    "E_max = 0.8 * battsize  # SOC lower limits on batteries\n",
    "# E_init = 0.5 * battsize # Starting state of charge\n",
    "eps = 0.001              # Acceptable band for ending SOC \n",
    "\n",
    "# Shapeable load parameters\n",
    "P_shpmin = 0 * np.max(fixed_load_p,axis=1)\n",
    "P_shpmax = 2 * np.max(fixed_load_p,axis=1)\n",
    "E_dem = 3 * np.multiply(np.random.rand(nb,1),P_shpmax)    # Effectively how many hours of demand we have\n",
    "minStartTime = 9\n",
    "minStartTime = min(T-4,minStartTime) # Deal with short time horizons\n",
    "startProbPeriod = 9 # Start times will be uniformly distributed over this range\n",
    "startAfter = minStartTime + np.round(startProbPeriod * np.random.rand(nb,1).flatten())\n",
    "chargeTime = 4 + np.round(min(6,T-4) * np.random.rand(nb,1).flatten())\n",
    "endBy = np.minimum(startAfter + chargeTime,T)\n",
    "\n",
    "# Create a matrix where infeasible hours are 0 - buses in rows, times in columns\n",
    "selectShp = np.zeros((nb,T))\n",
    "for i in range(nb):# = 1:nb:\n",
    "    tooEarly = np.ones(  ( 1,int(startAfter[i]) ) )\n",
    "    okTimes  = np.zeros( ( 1,int(endBy[i]-startAfter[i]) ) )\n",
    "    tooLate  = np.ones(  ( 1,int(T-endBy[i]) ) )\n",
    "    selectShp[i,:] = np.hstack(( tooEarly, okTimes, tooLate))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Objective value: 30014.079\n"
     ]
    }
   ],
   "source": [
    "### Simple OPF Problem  ###\n",
    "# Dispatchable generators, linear generation costs, \n",
    "# Fixed loads, no deferrable or shapeable loads\n",
    "\n",
    "nb = int(nb)\n",
    "T = int(T)\n",
    "\n",
    "# Line flow variables\n",
    "P = Variable(nb,T)  # Real power flow from node to parent\n",
    "Q = Variable(nb,T)  # Reactive power flow from node to parent\n",
    "# l = Variable(nb,T)\n",
    "v = Variable(nb,T)  # squared voltage at node\n",
    "\n",
    "# Dummy variables\n",
    "p_g = Variable(nb,T)  # Generation real power\n",
    "q_g = Variable(nb,T)  # Generation reactive power\n",
    "p = Variable(nb,T)    # Nodal net power injection\n",
    "q = Variable(nb,T)\n",
    "# temp_var = Variable(3,T)\n",
    "\n",
    "alpha = np.random.rand(nb,1)\n",
    "beta = 20*np.random.rand(nb,1)\n",
    "obj = 0\n",
    "for t in range(T):\n",
    "#     obj = obj + beta.T*p_g[:,t]\n",
    "    obj = obj+alpha.T*(square(p_g[:,t]))+beta.T*p_g[:,t]\n",
    "    \n",
    "objective = Minimize(obj)\n",
    "constraints = []\n",
    "\n",
    "# Linearized Power Flow Equations\n",
    "constraints.append(p == P - child*P) # Lambda (prices) associated with this equation\n",
    "constraints.append(q == Q - child*Q)\n",
    "constraints.append(v[1:,:] == parent[1:,:]*v+2*(Rsub*P[1:,:]+Xsub*Q[1:,:]))\n",
    "\n",
    "# Injection Equations - Simple\n",
    "constraints.append(p == p_g - fixed_load_p)\n",
    "constraints.append(q == q_g - fixed_load_q)\n",
    "\n",
    "# Voltage constraints\n",
    "constraints.append(v <= 1.05)\n",
    "constraints.append(v >= 0.95)\n",
    "# Generator constraints\n",
    "constraints.append(g_min <= p_g)\n",
    "constraints.append(p_g <= g_max)\n",
    "\n",
    "# Root node constraints (root voltage is slack)\n",
    "constraints.append(P[0,:] == 0)\n",
    "constraints.append(Q[0,:] == 0)\n",
    "\n",
    "prob = Problem(objective, constraints)\n",
    "prob.solve(solver=ECOS)\n",
    "\n",
    "# Solve it!\n",
    "result = prob.solve()\n",
    "print(\"Objective value: %.3f\"%prob.value)\n",
    "# print(\"Value of p: %s\"%np.round(p.value,3).T.tolist()[0]) \n",
    "\n",
    "# Pull out values like\n",
    "# P.value[1,:]  # Power flow from bus 1 to parent over every hour\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Objective value: 104215.059\n"
     ]
    }
   ],
   "source": [
    "### FULL SMARTGRID PROBLEM ####\n",
    "# Deferable and shapeable loads\n",
    "\n",
    "# Set up constants\n",
    "# a = np.array([1,1]).T\n",
    "# b = 3\n",
    "# c = np.array([-2,1]).T\n",
    "# rho = np.array([0.5,0.5]);\n",
    "\n",
    "# n = max(a.shape)\n",
    "\n",
    "# Set up CVXPy problem\n",
    "\n",
    "nb = int(nb)\n",
    "T = int(T)\n",
    "\n",
    "# Opt variables\n",
    "P = Variable(nb,T)\n",
    "Q = Variable(nb,T)\n",
    "l = Variable(nb,T)\n",
    "v = Variable(nb,T)\n",
    "\n",
    "# Dummy variables\n",
    "p_g = Variable(nb,T)\n",
    "q_g = Variable(nb,T)\n",
    "p = Variable(nb,T)\n",
    "q = Variable(nb,T)\n",
    "\n",
    "# Deferrable decision variable\n",
    "# d = Variable(nb,T) # nonnegative\n",
    "# Battery variables\n",
    "p_bc = Variable(nb,T)\n",
    "p_bd = Variable(nb,T)\n",
    "E_batt = Variable(nb,T)\n",
    "# Shapeable load variables\n",
    "p_shp = Variable(nb,T) #nonnegative\n",
    "\n",
    "# p_def = np.zeros((nb,T))\n",
    "# for i in range(nb):\n",
    "#     p_def[i,:] = (np.dot(defConst['y'].T,defConst['omega'].T)*d[i,:].T).T # Deferrable  load calculation\n",
    "\n",
    "# p_def = d*(np.dot(defConst['y'].T,defConst['omega'].T))\n",
    "p_batt = p_bd-p_bc # batteries\n",
    "\n",
    "alpha = np.random.rand(nb,1)\n",
    "beta = np.vstack((LMP_price.T,20*np.random.rand(nb-1,T)))\n",
    "obj = 0\n",
    "for t in range(T):\n",
    "#     obj = obj + beta.T*p_g[:,t]\n",
    "    obj = obj+alpha.T*(square(p_g[:,t]))+beta[:,t].T*p_g[:,t]\n",
    "    \n",
    "objective = Minimize(obj)\n",
    "constraints = []\n",
    "\n",
    "# # Power Flow Equations\n",
    "# constraints.append(p == P - child*P + R*l) # Lambda (prices) associated with this equation\n",
    "# constraints.append(q == Q - child*Q + X*l)\n",
    "# constraints.append(v[1:,:] == parent.astype(int)[1:,:]*v+2*(Rsub*P[1:,:]+Xsub*Q[1:,:])-(Rsub*Rsub+Xsub*Xsub)*l[1:,:])\n",
    "\n",
    "# Linearized Power Flow Equations\n",
    "constraints.append(p == P - child*P) # Lambda (prices) associated with this equation\n",
    "constraints.append(q == Q - child*Q)\n",
    "constraints.append(v[1:,:] == parent[1:,:]*v+2*(Rsub*P[1:,:]+Xsub*Q[1:,:]))\n",
    "\n",
    "# for t in np.arange(T):\n",
    "#     for i in np.arange(1,nb):\n",
    "# #         constraints.append(l[i,t]+v[i,t] >= norm(np.vstack((2*P[i,t],2*Q[i,t],l[i,t]-v[i,t])),2))\n",
    "#         temp_square = square(2*P[i,t])+square(2*Q[i,t])+square(l[i,t]-v[i,t])\n",
    "#         constraints.append(l[i,t]+v[i,t] >= sqrt(temp_square))#norm([[2*P[i,t]],[2*Q[i,t]],[l[i,t]-v[i,t]]],2))\n",
    "#         [[2*P[i,t]],[2*Q[i,t]],[l[i,t]-v[i,t]]]\n",
    "        #l(i,t) >= (P(i,t)^2+Q(i,t)^2)/v(i,t);\n",
    "#         [2*P[i,t];2*Q[i,t];l[i,t]-v[i,t]]\n",
    "\n",
    "# Injection Equations\n",
    "# constraints.append(p == p_g + p_sol + p_batt - p_def - p_shp - fixed_load_p)  # Uncomment this to include solar\n",
    "constraints.append(p == p_g + p_sol + p_batt - p_shp - fixed_load_p)  # Uncomment this to include solar\n",
    "\n",
    "# p == p_g + p_batt - p_def - p_shp - fixed_load_p; % This assumes no solar\n",
    "constraints.append(q == q_g - fixed_load_q)\n",
    "\n",
    "# # Injection Equations - Simple\n",
    "# constraints.append(p == p_g - fixed_load_p)\n",
    "# constraints.append(q == q_g - fixed_load_q)\n",
    "\n",
    "# Voltage cons\n",
    "constraints.append(v <= 1.05)\n",
    "constraints.append(v >= 0.95)\n",
    "# Gen cons\n",
    "constraints.append(g_min <= p_g)\n",
    "constraints.append(p_g <= g_max)\n",
    "# Root node cons (root voltage is slack)\n",
    "constraints.append(P[0,:] == 0)\n",
    "constraints.append(Q[0,:] == 0)\n",
    "\n",
    "# # Deferrable loads\n",
    "# for i in range(nb):\n",
    "#     constraints.append(defConst['A_increasing'] * np.insert(d[i,:].T,0,0) <= 0)  # d(l-1) <= d(l), eqn (13a)\n",
    "#     constraints.append(d[i,:].T <= defConst['a'])                     # d(l) <= a(l)  , eqn (13a)\n",
    "#     constraints.append(defConst['a_shift'] <= d[i,:].T)               # a(l-zeta) <= d(l), eqn (13b)\n",
    "#     constraints.append(d[i,0]==0)                    # d(0) == 0\n",
    "#     constraints.append(d[i,T]== defConst['a'][T])             # d(L) == a(L)    eqn (13c)\n",
    "    \n",
    "#     # Nonnegative constraints\n",
    "#     constraints.append(d >= 0)\n",
    "    \n",
    "# Batteries\n",
    "constraints.append(0 <= p_bd)\n",
    "constraints.append(p_bd<= p_battmax * ntOnes.T)\n",
    "constraints.append(0 <= p_bc)\n",
    "constraints.append(p_bc<= p_battmax * ntOnes.T)\n",
    "constraints.append(E_min * ntOnes.T <= E_batt)\n",
    "constraints.append(E_batt <= E_max * ntOnes.T)\n",
    "\n",
    "constraints.append(E_batt[:,0] == E_batt[:,T-1] + p_bc[:,0] * dt * eff_in - p_bd[:,0]*dt/eff_out)\n",
    "for t in np.arange(1,T):\n",
    "    constraints.append(E_batt[:,t] == E_batt[:,t-1] + p_bc[:,t] * dt * eff_in - p_bd[:,t]*dt/eff_out)\n",
    "    \n",
    "#         constraints.append(E_batt[:,1] == E_init)\n",
    "constraints.append((1-eps)*E_batt[:,0] <= E_batt[:,T-1])# <= (1+eps)*E_batt[:,0])\n",
    "constraints.append(E_batt[:,T-1] <= (1+eps)*E_batt[:,0])\n",
    "\n",
    "# Shapeable loads\n",
    "constraints.append(P_shpmin * ntOnes.T <= p_shp)\n",
    "constraints.append(p_shp <= P_shpmax * ntOnes.T)\n",
    "for i in np.arange(nb):\n",
    "    constraints.append(ntOnes.T * p_shp[i,:].T == E_dem[i])      # Total energy consumption\n",
    "    constraints.append(selectShp[i,:] * p_shp[i,:].T == 0)  # No operation during non-allowed hours\n",
    "\n",
    "# Nonnegative constraints\n",
    "constraints.append(p_shp >= 0)\n",
    "\n",
    "prob = Problem(objective, constraints)\n",
    "prob.solve(solver=ECOS)\n",
    "\n",
    "# Solve it!\n",
    "result = prob.solve()\n",
    "print(\"Objective value: %.3f\"%prob.value)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXYAAAD8CAYAAABjAo9vAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nzCOTI5dcMMcAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x15e1c60f0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# p_g + p_sol + p_batt - p_shp - fixed_load_p\n",
    "# p_g\n",
    "# E_batt.value.astype(int)\n",
    "# p.value.astype(int)\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline \n",
    "\n",
    "node = 3\n",
    "plt.plot(np.arange(T),p_g[node,:].value.T,label='Gen')\n",
    "plt.plot(np.arange(T),-p_sol[node,:].T,label='Solar')\n",
    "plt.plot(np.arange(T),-p_batt[node,:].value.T,label='Battery')\n",
    "plt.plot(np.arange(T),p_shp[node,:].value.T,label='Shape')\n",
    "plt.plot(np.arange(T),fixed_load_p[node,:].T,label='Fixed')\n",
    "# plt.legend([a,b,c,d,e], ['Gen', 'Solar','Battery','Shape','Fixed'])\n",
    "plt.legend(loc=2)\n",
    "# ax.set_xticklabels(end.strftime('%m-%Y'),size = 'small')\n",
    "# plt.xticks(end.strftime('%m%Y'))#,size='small')\n",
    "# plt.xlabel('Date')\n",
    "# plt.ylabel('Number of Members')\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}