example-inc-output.ipynb

{
 "metadata": {},
 "nbformat": 3,
 "nbformat_minor": 0,
 "worksheets": [
  {
   "cells": [
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "\n",
      "import numpy as np\n",
      "import scipy as sp\n",
      "import sympy as sy\n",
      "from sympy.matrices import Matrix\n",
      "from sympy import *\n",
      "# LaTeX rendered SymPy output\n",
      "from sympy import init_printing\n",
      "init_printing()\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "\n",
      "def Transpose(matrix):\n",
      "    return sy.transpose(matrix)\n",
      "\n",
      "def VectorRow(vector_list):\n",
      "    return sy.transpose(Matrix(vector_list))\n",
      "\n",
      "def VectorAdd(a, b):\n",
      "    return a+b\n",
      "\n",
      "def Multiply(a, b):\n",
      "    return a*b\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "D_blade_1 = Symbol('D_blade_1')\n",
      "D_blade_2 = Symbol('D_blade_2')\n",
      "D_tower = Symbol('D_tower')\n",
      "JB = Symbol('JB')\n",
      "JT = Symbol('JT')\n",
      "Jblade = Symbol('Jblade')\n",
      "Jtower = Symbol('Jtower')\n",
      "Omega = Symbol('Omega')\n",
      "Omega1 = Symbol('Omega1')\n",
      "OmegaXomega1 = Symbol('OmegaXomega1')\n",
      "OmegaXomega2 = Symbol('OmegaXomega2')\n",
      "OmegaXomegarho = Symbol('OmegaXomegarho')\n",
      "R = Symbol('R')\n",
      "R_cg_T = Symbol('R_cg_T')\n",
      "R_cg_T_0 = Symbol('R_cg_T_0')\n",
      "R_cg_T_flux = Symbol('R_cg_T_flux')\n",
      "R_cg_beta_1 = Symbol('R_cg_beta_1')\n",
      "R_cg_beta_1_flux = Symbol('R_cg_beta_1_flux')\n",
      "R_cg_beta_2 = Symbol('R_cg_beta_2')\n",
      "R_cg_beta_2_flux = Symbol('R_cg_beta_2_flux')\n",
      "R_cg_blade_1_0 = Symbol('R_cg_blade_1_0')\n",
      "R_cg_blade_2_0 = Symbol('R_cg_blade_2_0')\n",
      "Rbeta1 = Symbol('Rbeta1')\n",
      "Rbeta2 = Symbol('Rbeta2')\n",
      "Rpsi1 = Symbol('Rpsi1')\n",
      "Rpsi2 = Symbol('Rpsi2')\n",
      "Rrho = Symbol('Rrho')\n",
      "T1_eq_beta1full = Symbol('T1_eq_beta1full')\n",
      "T1_eq_beta2full = Symbol('T1_eq_beta2full')\n",
      "T1_eq_rhofull = Symbol('T1_eq_rhofull')\n",
      "T2_eq_beta1full = Symbol('T2_eq_beta1full')\n",
      "T2_eq_beta2full = Symbol('T2_eq_beta2full')\n",
      "T2_eq_rhofull = Symbol('T2_eq_rhofull')\n",
      "T3_eq_beta1full = Symbol('T3_eq_beta1full')\n",
      "T3_eq_beta2full = Symbol('T3_eq_beta2full')\n",
      "T3_eq_rhofull = Symbol('T3_eq_rhofull')\n",
      "T4_eq_rhofull = Symbol('T4_eq_rhofull')\n",
      "T5_eq_rhofull = Symbol('T5_eq_rhofull')\n",
      "T_blade_1 = Symbol('T_blade_1')\n",
      "T_blade_2 = Symbol('T_blade_2')\n",
      "T_rot_blade_1 = Symbol('T_rot_blade_1')\n",
      "T_rot_blade_2 = Symbol('T_rot_blade_2')\n",
      "T_rot_tower = Symbol('T_rot_tower')\n",
      "T_total = Symbol('T_total')\n",
      "T_tower = Symbol('T_tower')\n",
      "V_g = Symbol('V_g')\n",
      "V_springs = Symbol('V_springs')\n",
      "V_total = Symbol('V_total')\n",
      "Xomega1 = Symbol('Xomega1')\n",
      "Xomega2 = Symbol('Xomega2')\n",
      "Xomegarho = Symbol('Xomegarho')\n",
      "aa_FF = Symbol('aa_FF')\n",
      "bb_FF_1 = Symbol('bb_FF_1')\n",
      "bb_FF_2 = Symbol('bb_FF_2')\n",
      "beta1 = Symbol('beta1')\n",
      "beta2 = Symbol('beta2')\n",
      "betaflux1 = Symbol('betaflux1')\n",
      "betaflux2 = Symbol('betaflux2')\n",
      "blade = Symbol('blade')\n",
      "dT_dbeta1 = Symbol('dT_dbeta1')\n",
      "dT_dbeta1_t = Symbol('dT_dbeta1_t')\n",
      "dT_dbeta1_tt = Symbol('dT_dbeta1_tt')\n",
      "dT_dbeta1flux = Symbol('dT_dbeta1flux')\n",
      "dT_dbeta1flux_t = Symbol('dT_dbeta1flux_t')\n",
      "dT_dbeta1flux_tt = Symbol('dT_dbeta1flux_tt')\n",
      "dT_dbeta2 = Symbol('dT_dbeta2')\n",
      "dT_dbeta2_t = Symbol('dT_dbeta2_t')\n",
      "dT_dbeta2_tt = Symbol('dT_dbeta2_tt')\n",
      "dT_dbeta2flux = Symbol('dT_dbeta2flux')\n",
      "dT_dbeta2flux_t = Symbol('dT_dbeta2flux_t')\n",
      "dT_dbeta2flux_tt = Symbol('dT_dbeta2flux_tt')\n",
      "dT_drho = Symbol('dT_drho')\n",
      "dT_drho_t = Symbol('dT_drho_t')\n",
      "dT_drho_tt = Symbol('dT_drho_tt')\n",
      "dT_drhoflux = Symbol('dT_drhoflux')\n",
      "dT_drhoflux_t = Symbol('dT_drhoflux_t')\n",
      "dT_drhoflux_tt = Symbol('dT_drhoflux_tt')\n",
      "dV_dbeta1 = Symbol('dV_dbeta1')\n",
      "dV_dbeta1_t = Symbol('dV_dbeta1_t')\n",
      "dV_dbeta1_tt = Symbol('dV_dbeta1_tt')\n",
      "dV_dbeta2 = Symbol('dV_dbeta2')\n",
      "dV_dbeta2_t = Symbol('dV_dbeta2_t')\n",
      "dV_dbeta2_tt = Symbol('dV_dbeta2_tt')\n",
      "dV_drho = Symbol('dV_drho')\n",
      "dV_drho_t = Symbol('dV_drho_t')\n",
      "dV_drho_tt = Symbol('dV_drho_tt')\n",
      "ddt_dT_dbeta1flux = Symbol('ddt_dT_dbeta1flux')\n",
      "ddt_dT_dbeta2flux = Symbol('ddt_dT_dbeta2flux')\n",
      "ddt_dT_drhoflux = Symbol('ddt_dT_drhoflux')\n",
      "diff = Symbol('diff')\n",
      "e = Symbol('e')\n",
      "eq_beta1full = Symbol('eq_beta1full')\n",
      "eq_beta2full = Symbol('eq_beta2full')\n",
      "eq_mo_beta1_FF_lin = Symbol('eq_mo_beta1_FF_lin')\n",
      "eq_mo_beta2_FF_lin = Symbol('eq_mo_beta2_FF_lin')\n",
      "eq_mo_rho_FF_lin = Symbol('eq_mo_rho_FF_lin')\n",
      "eq_rhofull = Symbol('eq_rhofull')\n",
      "flux = Symbol('flux')\n",
      "flux1 = Symbol('flux1')\n",
      "full = Symbol('full')\n",
      "g = Symbol('g')\n",
      "g_ = Symbol('g_')\n",
      "horner = Symbol('horner')\n",
      "ka = Symbol('ka')\n",
      "kb = Symbol('kb')\n",
      "l = Symbol('l')\n",
      "m_b = Symbol('m_b')\n",
      "m_t = Symbol('m_t')\n",
      "omega1 = Symbol('omega1')\n",
      "omega2 = Symbol('omega2')\n",
      "omegaOmega1 = Symbol('omegaOmega1')\n",
      "omegaOmega2 = Symbol('omegaOmega2')\n",
      "omegabeta1 = Symbol('omegabeta1')\n",
      "omegabeta2 = Symbol('omegabeta2')\n",
      "omegarho = Symbol('omegarho')\n",
      "p_omega1 = Symbol('p_omega1')\n",
      "p_omega2 = Symbol('p_omega2')\n",
      "psi = Symbol('psi')\n",
      "psi1 = Symbol('psi1')\n",
      "psiflux = Symbol('psiflux')\n",
      "q_omega1 = Symbol('q_omega1')\n",
      "q_omega2 = Symbol('q_omega2')\n",
      "r_0 = Symbol('r_0')\n",
      "r_2 = Symbol('r_2')\n",
      "r_3_beta_1 = Symbol('r_3_beta_1')\n",
      "r_3_beta_1_flux = Symbol('r_3_beta_1_flux')\n",
      "r_3_beta_2 = Symbol('r_3_beta_2')\n",
      "r_3_beta_2_flux = Symbol('r_3_beta_2_flux')\n",
      "r_cg_T = Symbol('r_cg_T')\n",
      "r_cg_beta = Symbol('r_cg_beta')\n",
      "r_omega1 = Symbol('r_omega1')\n",
      "r_omega2 = Symbol('r_omega2')\n",
      "rho = Symbol('rho')\n",
      "rhoflux = Symbol('rhoflux')\n",
      "solve = Symbol('solve')\n",
      "subs = Symbol('subs')\n",
      "t = Symbol('t')\n",
      "tower = Symbol('tower')\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#load linear algebra package\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#> restart;\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#> with(CodeGeneration):\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#> with(LinearAlgebra):\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#Transformation matrices for tower middle\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "Rrho=Matrix([[cos(rho),0,-sin(rho)],[0,1,0],[sin(rho),0,cos(rho)]])"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#Transformation matrices for blade 1\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "Rpsi1=Matrix([[-cos(psi),sin(psi),0],[-sin(psi),-cos(psi),0],[0,0,1]])"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "Rbeta1=Matrix([[cos(beta1),0,-sin(beta1)],[0,1,0],[sin(beta1),0,cos(beta1)]])"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#Transformation matrices for blade 2\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "Rpsi2=Matrix([[cos(psi),-sin(psi),0],[sin(psi),cos(psi),0],[0,0,1]])"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "Rbeta2=Matrix([[cos(beta2),0,-sin(beta2)],[0,1,0],[sin(beta2),0,cos(beta2)]])"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#omega of blade 1, in function of {E_beta_1}\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#omega of the tower, in function of {E_1}\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "omegarho=VectorRow([0,rhoflux,0])"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "omegarho[0]=Multiply(omegarho,Multiply(Transpose(Rpsi[0]),Transpose(Rbeta1)))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "omegaOmega1=Multiply(VectorRow([0,0,-Omega]),Transpose(Rbeta1))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "omegabeta1=VectorRow([0,betaflux[0],0])"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "omega1=VectorAdd(VectorAdd(omegarho[0],omegaOmega[0]),omegabeta1)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "p_omega1=omega1"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "q_omega1=omega1"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "r_omega1=omega1"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#omega of blade 2, in function of {E_beta_2}\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "omegarho[1]=Multiply(omegarho,Multiply(Transpose(Rpsi[1]),Transpose(Rbeta2)))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "omegaOmega2=Multiply(VectorRow([0,0,-Omega]),Transpose(Rbeta2))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "omegabeta2=VectorRow([0,betaflux[1],0])"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "omega2=VectorAdd(VectorAdd(omegarho[1],omegaOmega[1]),omegabeta2)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "p_omega2=omega2"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "q_omega2=omega2"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "r_omega2=omega2"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#rotation operators\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "OmegaXomegarho=Matrix([[0,0,-rhoflux],[0,0,0],[rhoflux,0,0]])"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "OmegaXomega1=Matrix([[0,r_omega1,-q_omega1],[-r_omega1,0,p_omega1],[q_omega1,-p_omega1,0]])"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "OmegaXomega2=Matrix([[0,r_omega2,-q_omega2],[-r_omega2,0,p_omega2],[q_omega2,-p_omega2,0]])"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#Position vectors for the cg of the blades and the cg of the 2nd tower section\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#All captial R position vectors here are expressed in {E_1}\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#all r position vectors are in local reference frame\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "r_2=VectorRow([l/2,0,0])"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "r_0=VectorRow([l/2,0,0])"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "r_cg_beta=VectorRow([R/2,0,0])"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "r_cg_T=VectorRow([l/4,0,0])"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "r_3_beta_1=VectorRow([(-e*cos(psi)),(e*sin(psi)),0])"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "r_3_beta_2=VectorRow([(e*cos(psi)),(-e*sin(psi)),0])"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "r_3_beta_1_flux=VectorRow([(e*sin(psi)*psiflux),(e*cos(psi)*psiflux),0])"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "r_3_beta_2_flux=VectorRow([(-e*sin(psi)*psiflux),(-e*cos(psi)*psiflux),0])"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "R_cg_beta_1=Multiply(r_0,Transpose(Rrho))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "R_cg_beta_2=Multiply(r_0,Transpose(Rrho))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "R_cg_T=Multiply(r_0,Transpose(Rrho))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "R_cg_beta_1_flux=Multiply(r_2,OmegaXomegarho)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "R_cg_beta_2_flux=Multiply(r_2,OmegaXomegarho)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "R_cg_T_flux=Multiply(r_cg_T,OmegaXomegarho)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#Inertia matrices of cg\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#> JB = (1/12)*m_b*R*R;\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "Jblade=Matrix([[0,0,0],[0,JB,0],[0,0,JB]])"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#> JT = (1/12)*m_t*(l/2)*(l/2);\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "Jtower=Matrix([[0,0,0],[0,JT,0],[0,0,JT]])"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#Kinetic energy: translational part\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "T_blade_1=0.5*m_b*((R_cg_beta_1_flux[0]*R_cg_beta_1_flux[0])+(R_cg_beta_1_flux[1]*R_cg_beta_1_flux[1])+(R_cg_beta_1_flux[2]*R_cg_beta_1_flux[2]))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "T_blade_2=0.5*m_b*((R_cg_beta_2_flux[0]*R_cg_beta_2_flux[0])+(R_cg_beta_2_flux[1]*R_cg_beta_2_flux[1])+(R_cg_beta_2_flux[2]*R_cg_beta_2_flux[2]))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "T_tower=0.5*m_t*((R_cg_T_flux[0]*R_cg_T_flux[0])+(R_cg_T_flux[1]*R_cg_T_flux[1])+(R_cg_T_flux[2]*R_cg_T_flux[2]))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#Kinetic energy: rotational part\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "D_blade_1=Multiply(omega1,Jblade)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "D_blade_2=Multiply(omega2,Jblade)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "D_tower=Multiply(omegarho,Jtower)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "T_rot_blade_1=0.5*"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "T_rot_blade_2=0.5*"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "T_rot_tower=0.5*"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#Total kinetic energy\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "T_total=T_blade_1+T_blade_2+T_tower+T_rot_blade_1+T_rot_blade_2+T_rot_tower"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#> `starting length` = length(%), `converting to horner`=length(convert(%,horner)),  factoring=length(factor(%)), `simplify length` = length(symplify(%));\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#Potential energy\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "g=VectorRow([g_,0,0])"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#Position vectors expressed in {E_0} for the potential energy\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "R_cg_blade_1_0=r_0+Multiply(r_2,Rrho)+Multiply(r_3_beta_1,Rrho)+Multiply(r_cg_beta,Multiply(Rbeta1,Multiply(Rpsi1,Rrho)))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "R_cg_blade_2_0=r_0+Multiply(r_2,Rrho)+Multiply(r_3_beta_2,Rrho)+Multiply(r_cg_beta,Multiply(Rbeta2,Multiply(Rpsi2,Rrho)))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "R_cg_T_0=r_0+Multiply(r_cg_T,Rrho)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "V_g=(m_b*g[0]*(R_cg_blade_1_0[0]+R_cg_blade_2_0[0]))+(m_t*g[0]*R_cg_T_0[0])"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "V_springs=1/2*kb*beta1*beta1+1/2*kb*beta2*beta2+1/2*ka*rho*rho"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "V_total=V_g+V_springs"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#> `starting length` = length(V_total), `converting to horner`=length(convert(V_total,horner)),  factoring=length(factor(V_total)), `simplify length` = length(symplify(V_total));\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#Full equations of motion using the Lagrangian\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#eq of motion for beta_1\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "dT_dbeta1flux=diff(T_total,betaflux[0])"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "dT_dbeta1=diff(T_total,beta1)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "dV_dbeta1=diff(V_total,beta1)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#indicate time dependencies\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#indicate time dependencies\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "dT_dbeta1_t=subs"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "dV_dbeta1_t=subs"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "dT_dbeta1flux_t=subs"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#change q_flux to d/dt(q)\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "dT_dbeta1_tt=subs"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "dV_dbeta1_tt=subs"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "dT_dbeta1flux_tt=subs"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#> `starting length` = length(%), `converting to horner`=length(convert(%,horner)),  factoring=length(factor(%)), `simplify length` = length(symplify(%));\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "dT_dbeta1flux_tt=convert(dT_dbeta1flux_tt,horner)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#differentiate with respect to t and construct equations of motion for beta 1\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "ddt_dT_dbeta1flux=diff(dT_dbeta1flux_tt,t)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#> `starting length` = length(%), `converting to horner`=length(convert(%,horner)),  factoring=length(factor(%)), `simplify length` = length(symplify(%));\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "ddt_dT_dbeta1flux=convert(ddt_dT_dbeta1flux,horner)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "eq_beta1full=ddt_dT_dbeta1flux-dT_dbeta1_tt+dV_dbeta1_tt"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#> `starting length` = length(%), `converting to horner`=length(convert(%,horner)),  factoring=length(factor(%)), `simplify length` = length(symplify(%));\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "eq_beta1full=convert(eq_beta1full,horner)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "eq_beta1full=solve(eq_beta1full,diff(beta1(t),t,t))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#simplify expression and lose time dependencie notation and d/dt\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "T1_eq_beta1full=subs"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "T2_eq_beta1full=subs"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "T3_eq_beta1full=subs"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "bb_FF_1=T3_eq_beta1full"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#eq of motion for beta_2\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "dT_dbeta2flux=diff(T_total,betaflux[1])"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "dT_dbeta2=diff(T_total,beta2)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "dV_dbeta2=diff(V_total,beta2)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#indicate time dependencies\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#indicate time dependencies\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "dT_dbeta2_t=subs"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "dV_dbeta2_t=subs"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "dT_dbeta2flux_t=subs"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#change q_flux to d/dt(q)\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "dT_dbeta2_tt=subs"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "dV_dbeta2_tt=subs"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "dT_dbeta2flux_tt=subs"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#> `starting length` = length(%), `converting to horner`=length(convert(%,horner)),  factoring=length(factor(%)), `simplify length` = length(symplify(%));\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "dT_dbeta2flux_tt=convert(dT_dbeta2flux_tt,horner)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#differentiate with respect to t and construct equations of motion for beta 2\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "ddt_dT_dbeta2flux=diff(dT_dbeta2flux_tt,t)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#> `starting length` = length(%), `converting to horner`=length(convert(%,horner)),  factoring=length(factor(%)), `simplify length` = length(symplify(%));\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "ddt_dT_dbeta2flux=convert(ddt_dT_dbeta2flux,horner)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "eq_beta2full=ddt_dT_dbeta2flux-dT_dbeta2_tt+dV_dbeta2_tt"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#> `starting length` = length(%), `converting to horner`=length(convert(%,horner)),  factoring=length(factor(%)), `simplify length` = length(symplify(%));\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "eq_beta2full=convert(eq_beta2full,horner)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "eq_beta2full=solve(eq_beta2full,diff(beta2(t),t,t))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#simplify expression and lose time dependencie notation and d/dt\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "T1_eq_beta2full=subs"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "T2_eq_beta2full=subs"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "T3_eq_beta2full=subs"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "bb_FF_2=T3_eq_beta2full"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#eq of motion for rho\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "dT_drhoflux=diff(T_total,rhoflux)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#> `starting length` = length(%), `converting to horner`=length(convert(%,horner)),  factoring=length(factor(%)), `simplify length` = length(symplify(%));\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#replace first rho[flux] with rho_f, otherwise maple will display the partial derivative of d/drho (rho[flux]) which is ofcourse zero, but maple doesn't know\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "dT_drho=diff"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "dV_drho=diff(V_total,rho)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#indicate time dependencies\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#indicate time dependencies\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "dT_drho_t=subs"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "dV_drho_t=subs"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "dT_drhoflux_t=subs"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#change q_flux to d/dt(q)\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "dT_drho_tt=subs"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "dV_drho_tt=subs"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "dT_drhoflux_tt=subs"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#> `starting length` = length(%), `converting to horner`=length(convert(%,horner)),  factoring=length(factor(%)), `simplify length` = length(symplify(%));\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#differentiate with respect to t and construct equations of motion for rho\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "ddt_dT_drhoflux=diff(dT_drhoflux_tt,t)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#> `starting length` = length(%), `converting to horner`=length(convert(%,horner)),  factoring=length(factor(%));\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "eq_rhofull=ddt_dT_drhoflux-dT_drho_tt+dV_drho_tt"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#> `starting length` = length(%), `converting to horner`=length(convert(%,horner)),  factoring=length(factor(%));\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "eq_rhofull=solve(eq_rhofull,diff(rho(t),t,t))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#> `starting length` = length(%), `converting to horner`=length(convert(%,horner)),  factoring=length(factor(%));\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "eq_rhofull=convert(eq_rhofull,horner)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#simplify expression for matlab en lose time dependencie notation and d/dt\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "T1_eq_rhofull=subs"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#> length(%);\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "T2_eq_rhofull=subs"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "T3_eq_rhofull=subs"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#> `starting length` = length(%), `converting to horner`=length(convert(%,horner)),  factoring=length(factor(%));\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "T3_eq_rhofull=collect(T3_eq_rhofull,aa_FF)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#> `starting length` = length(%), `converting to horner`=length(convert(%,horner)),  factoring=length(factor(%));\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#Solve again for aa_FF: since bb_FF_1 and bb_FF_2 are now substituted and are also functions aa_FF - CAN NOT SIMPLIFY FURTHER\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "T4_eq_rhofull=solve"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#> `starting length` = length(%), `converting to horner`=length(convert(%,horner)),  factoring=length(factor(%));\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "T5_eq_rhofull=convert(T4_eq_rhofull,horner)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#> length(%);\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#Linearized equations of motion using the Lagrangian \n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#lin eq of motion for beta_1\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "eq_mo_beta1_FF_lin=subs"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#> `starting length` = length(%), `converting to horner`=length(convert(%,horner)),  factoring=length(factor(%)), `simplify length` = length(symplify(%));\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#lin eq of motion for beta_2\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "eq_mo_beta2_FF_lin=subs"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#> `starting length` = length(%), `converting to horner`=length(convert(%,horner)),  factoring=length(factor(%));\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#lin eq of motion for rho\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "eq_mo_rho_FF_lin=subs"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#Matlab code\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#rho\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#> Matlab(T5_eq_rho[full], resultname=\"aa_FF\");\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# too long..."
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#> Matlab(eq_mo_rho_FF_lin, resultname=\"aa_FF_lin\");\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# too long..."
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#beta_1\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#> Matlab(bb_FF_1, resultname=\"bb_FF_1\");\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# too long..."
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#> Matlab(eq_mo_beta1_FF_lin, resultname=\"bb_FF_1_lin\");\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# too long..."
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#beta_2\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#> Matlab(bb_FF_2, resultname=\"bb_FF_2\");\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# too long..."
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#> Matlab(eq_mo_beta2_FF_lin, resultname=\"bb_FF_2_lin\");\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# too long..."
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    }
   ],
   "metadata": {}
  }
 ]
}