Merge pull request #7 from pydy/jason

Just some cleanup to the site.

Author: moorepants

README.rst

@@ -1,6 +1,14 @@
 This repository contains the source files for the website hosted through Github
 Pages at http://github.com/pydy/pydy.github.io.
 
+How make a blog post
+====================
+
+Create a new rst file in `source/blog/<year>` and make sure to include a rst
+directive with the date of the post, e.g.::
+
+   .. post:: 22 Jan, 2014
+
 Dependencies
 ============
 

source/blog/2013/first_post.rst

@@ -28,5 +28,3 @@ email to the
 with a brief statement explaining your experience and why you think you are a
 good candidate for the position(s). The PyDy team will work directly with the
 top candidates to strengthen their GSoC applications.
-
-

source/blog/2013/may31_2013.rst

@@ -9,20 +9,14 @@ Foundation. The following projects have been accepted:
 
 Student (Project): Mentor
 
-
-*  Tarun Gaba (PyDy: Visualization): Jason Moore
-
-*  Varun Josh (PyDy: Code Generation for sympy.physics.mechanics): Jason Moore
+- Tarun Gaba (PyDy: Visualization): Jason Moore
+- Varun Josh (PyDy: Code Generation for sympy.physics.mechanics): Jason Moore
 
 Additionally, two related proposals will be accepted through SymPy that relate
 to PyDy:
 
+-  Prasoon Shukla (Vector calculus module): Stefan Krastanov and Gilbert Gede
+-  Sachin Joglekar (Addition of electromagnetism features to sympy.physics):
+   Gilbert Gede and Stefan Krastanov
 
-*  Prasoon Shukla (Vector calculus module): Stefan Krastanov and Gilbert Gede
-
-*  Sachin Joglekar (Addition of electromagnetism features to sympy.physics):
-  Gilbert Gede and Stefan Krastanov
- 
 Join me in congratulating these students on their acceptance.
-
-

source/blog/2014/scipy2014.rst

@@ -5,19 +5,14 @@ PyDy at SciPy 2014
 
 PyDy is going to be at PyCon 2014 in Montréal! Jason Moore's presentation
 titled "Dynamics and Control with Python" has been accepted as a Tutorial, to
-be shown 9:00am - 12:00pm on Wednesday, April 9, 2014
-(`tutorial schedules <https://us.pycon.org/2014/schedule/tutorials/>`_). Topics
-covered will include:
+be shown 9:00am - 12:00pm on Wednesday, April 9, 2014 (`tutorial schedules
+<https://us.pycon.org/2014/schedule/tutorials/>`_). Topics covered will
+include:
 
-*  Symbolic derivation of equations of motion for rigid body systems
-
-*  Numerical simulation of the system
-
-*  2D and 3D visualization of the motion of the system
-
-*  Using feedback control for stabilization
+- Symbolic derivation of equations of motion for rigid body systems
+- Numerical simulation of the system
+- 2D and 3D visualization of the motion of the system
+- Using feedback control for stabilization
 
 Keep an eye on the Github repository being used to develop the presentation:
 `PyDy tutorial materials for PYCON 2014 <https://github.com/PythonDynamics/pydy-tutorial-pycon-2014>`_.
-
-

source/conf.py

@@ -51,7 +51,7 @@
 
 # General information about the project.
 project = 'PyDy'
-copyright = '2014, PyDy Team'
+copyright = '2015, PyDy Team'
 
 # The version info for the project you're documenting, acts as replacement for
 # |version| and |release|, also used in various other places throughout the

source/examples/beginners_tutorial.rst

@@ -6,7 +6,7 @@ operates. The first step is to open up your python interpreter. This varies
 depending on your work style, but the simplest way is to type python in a
 command prompt:
 
-.. code-block:: bash
+.. code:: bash
 
     $ python
 
@@ -15,14 +15,14 @@ functionality from SymPy and the Mechanics module, otherwise you will only have
 basic python commands available to work with. We will use the import * method
 to bring in all functions from the two modules:
 
-.. code-block:: python
+.. code:: python
 
     >>> from sympy import *
     >>> from sympy.physics.mechanics import *
 
 You can now see what functions and variables that are available to you with:
 
-.. code-block:: python
+.. code:: python
 
     >>> dir()
 
@@ -37,45 +37,45 @@ know the name of the command that you want to use simply use the builtin help
 function to bring up the documentation for the function. In our case we need to
 use the ReferenceFrame class:
 
-.. code-block:: python
+.. code:: python
 
     >>> help(ReferenceFrame)
 
 Press `q` to return to the command line. Now create an inertial reference frame
 called N for Newtonian as was described in the help:
 
-.. code-block:: python
+.. code:: python
 
     >>> N = ReferenceFrame('N')
 
 Keep in mind that N is the variable name of which the reference frame named 'N'
 is stored. It is important to note that `N` is an object and it has properties
 and functions associated with it. To see a list of them type:
 
-.. code-block:: python
+.. code:: python
 
     >>> dir(N)
 Notice that three of the properties are `x`, `y`, and `z`. These are the
 orthonormal unit vectors associated with the reference frame and are the
 building blocks for creating vectors. We can create a vector by simply building
 a linear combination of the unit vectors:
 
-.. code-block:: python
+.. code:: python
 
     >>> v = 1 * N.x + 2 * N.y + 3 * N.z
 
 Now a vector expressed in the N reference frame is stored in the variable `v`.
 We can print `v` to the screen by typing:
 
-.. code-block:: python
+.. code:: python
 
     >>> print(v)
     N.x + 2*N.y + 3*N.z
 
 The vector `v` can be manipulated as expected. You can multiply and divide them
 by scalars:
 
-.. code-block:: python
+.. code:: python
 
     >>> 2 * v
     2*N.x + 4*N.y + 6*N.z
@@ -88,7 +88,7 @@ remember to always declare numbers as floats (i.e. include a decimal).
 
 You can add and subtract vectors:
 
-.. code-block:: python
+.. code:: python
 
     >>> v + v
     2*N.x + 4*N.y + 6*N.z
@@ -98,28 +98,28 @@ You can add and subtract vectors:
 
 Vectors also have some useful properties:
 
-.. code-block:: python
+.. code:: python
 
     >>> dir(v)
 
 You can find the magnitude of a vector by typing:
 
-.. code-block:: python
+.. code:: python
 
     >>> v.magnitude()
     sqrt(14)
 
 You can compute a unit vector in the direction of `v`:
 
-.. code-block:: python
+.. code:: python
 
     >>> v.normalize()
     sqrt(14)/14*N.x + sqrt(14)/7*N.y + 3*sqrt(14)/14*N.z
 
 You can find the measure numbers and the reference frame the vector was defined
 in with:
 
-.. code-block:: python
+.. code:: python
 
     >>> v.args
     [([1]
@@ -128,7 +128,7 @@ in with:
 
 Dot and cross products of vectors can also be computed:
 
-.. code-block:: python
+.. code:: python
 
     >>> dot(v, w)
     19
@@ -139,14 +139,14 @@ We've only used numbers as our measure numbers so far, but it is just as easy
 to use symbols. We will introduce six symbols for our measure numbers with the
 SymPy `symbols` [`help(symbols) for the documentation`] function:
 
-.. code-block:: python
+.. code:: python
 
     >>> a1, a2, a3 = symbols('a1 a2 a3')
     >>> b1, b2, b3 = symbols('b1 b2 b3')
 
 And create two new vectors that are completely symbolic:
 
-.. code-block:: python
+.. code:: python
 
     >>> x = a1 * N.x + a2 * N.y + a3 * N.z
     >>> y = b1 * N.x + b2 * N.y + b3 * N.z
@@ -157,15 +157,15 @@ And create two new vectors that are completely symbolic:
 
 Numbers and symbols work together seamlessly:
 
-.. code-block:: python
+.. code:: python
 
     >>> dot(v, x)
     a1 + 2*a2 + 3*a3
 
 You can also differentiate a vector with respect to a variable in a reference
 frame:
 
-.. code-block:: python
+.. code:: python
 
     >>> x.diff(a1, N)
     N.x
@@ -175,7 +175,7 @@ create a new reference frame and orient it with respect to the `N` frame that
 has already been created. We will use the `orient` method of the new frame to
 do a simple rotation through `alpha` about the `N.x` axis:
 
-.. code-block:: python
+.. code:: python
 
     >>> A = ReferenceFrame('A')
     >>> alpha = symbols('alpha')
@@ -184,7 +184,7 @@ do a simple rotation through `alpha` about the `N.x` axis:
 Now the direction cosine matrix with of `A` with respect to `N` can be
 computed:
 
-.. code-block:: python
+.. code:: python
 
     >>> A.dcm(N)
     [1,           0,          0]
@@ -194,7 +194,7 @@ computed:
 Now that SymPy knows that `A` and `N` are oriented with respect to each other
 we can express the vectors that we originally wrote in the `A` frame:
 
-.. code-block:: python
+.. code:: python
 
     >>> v.express(A)
     A.x + (3*sin(alpha) + 2*cos(alpha))*A.y + (-2*sin(alpha) + 3*cos(alpha))*A.z
@@ -208,7 +208,7 @@ frames and vectors are time varying. The mechanics module provides a way to
 specify quantities as time varying. Let's define two variables `beta` and `d`
 as variables which are functions of time:
 
-.. code-block:: python
+.. code:: python
 
     >>> beta, d = dynamicsymbols('beta d')
 
@@ -217,23 +217,23 @@ frame by `beta` and create a vector in that new frame that is a function of
 `d`. This time we will use the `orientnew` method of the `A` frame to create
 the new reference frame `B`:
 
-.. code-block:: python
+.. code:: python
 
     >>> B = A.orientnew('B', 'Axis', [beta, A.y])
     >>> vec = d * B.z
 
 We can now compute the angular velocity of the reference frame `B` with respect
 to other reference frames:
 
-.. code-block:: python
+.. code:: python
 
     >>> B.ang_vel_in(N)
     beta'*A.y
 
 This allows us to now differentiate the vector, `vec`, with respect to time and
 a reference frame:
 
-.. code-block:: python
+.. code:: python
 
     >>> vecdot = vec.dt(N)
     >>> vecdot
@@ -248,7 +248,7 @@ varying variables. For example, we can define `omega` as the first time
 derivative of `beta` which allows you to explicitly interact with the
 derivatives:
 
-.. code-block:: python
+.. code:: python
 
     >>> theta = dynamicsymbols('theta')
     >>> omega = dynamicsymbols('theta', 1)
@@ -257,33 +257,33 @@ At this point we now have all the tools needed to setup the kinematics for a
 dynamic system. Let's start with a simple system where a point can move back
 and forth on a spinning disc. First create an inertial reference frame:
 
-.. code-block:: python
+.. code:: python
 
     >>> N = ReferenceFrame('N')
 
 Now create a reference frame for the disc:
 
-.. code-block:: python
+.. code:: python
 
     >>> D = ReferenceFrame('D')
 
 The disc rotates with respect to `N` about the `N.x` axis through `theta`:
 
-.. code-block:: python
+.. code:: python
 
     >>> theta = dynamicsymbols('theta')
     >>> D.orient(N, 'Axis', [theta, N.x])
 
 Define one point at the origin of rotation which is fixed in `N`:
 
-.. code-block:: python
+.. code:: python
 
     >>> no = Point('no')
     >>> no.set_vel(N, 0)
 
 The second point, `p`, can move through `x` along the `D.y` axis:
 
-.. code-block:: python
+.. code:: python
 
     >>> p = Point('p')
     >>> x = dynamicsymbols('x')
@@ -293,7 +293,7 @@ The second point, `p`, can move through `x` along the `D.y` axis:
 
 The velocity of the point in the `N` frame can now be computed:
 
-.. code-block:: python
+.. code:: python
 
     >>> p.vel(N)
     x'*D.y + x*theta'*D.z
@@ -302,7 +302,7 @@ The velocity of the point in the `N` frame can now be computed:
 
 The acceleration of the point can also be computed:
 
-.. code-block:: python
+.. code:: python
 
     >>> p.acc(N)
     (-x*theta'**2 + x'')*D.y + (x*theta'' + 2*theta'*x')*D.z

source/examples/commands.rst

@@ -7,14 +7,14 @@ you would type in an interactive session are preceded by ''>>> ''.
 SymPy Commands
 --------------
 
-.. code-block:: python
+.. code:: python
 
     >>> from sympy import *
 
 This imports all of the classes and functions in the ''SymPy'' package.  Now we
 can do some symbolic math:
 
-.. code-block:: python
+.. code:: python
 
     >>> x, y, z = symbols('x y z')
     >>> e = x**2 + y**2 + z**2
@@ -32,11 +32,13 @@ Mechanics commands
 What follows is a list of objects you can create, and functions you can run.
 The first step is to import the functions and classes related to mechanics:
 
-.. code-block:: python
+.. code:: python
 
     >>> from sympy.physics.mechanics import *
 
-==== Classes ====
+Classes
+-------
+
 Here is a list of classes:
   * ReferenceFrame
   * Point
@@ -48,55 +50,57 @@ Here is a list of classes:
 You can call ''help(class)'' to see the help entry for ''class''. For example,
 ''help(ReferenceFrame)'' to see the help entry for ''ReferenceFrame''.
 
-=== Code Snippets ===
-Here are some brief usage examples of common functions and classes. 
+Code Snippets
+-------------
+
+Here are some brief usage examples of common functions and classes.
 
-.. code-block:: python
+.. code:: python
 
     >>> q1, q2 = dynamicsymbols('q1 q2')
 
 Creates two time varying symbols, ''q1'' and ''q2''
 
-.. code-block:: python
+.. code:: python
 
     >>> N = ReferenceFrame('N')
 
 This creates a new reference frame named N.
 
-.. code-block:: python
+.. code:: python
 
     >>> N.x
 
 Access to the ''x'' basis vector in the ''N'' reference frame
 
-.. code-block:: python
+.. code:: python
 
     >>> a = N.x + N.y
 
 Creates a new vector, ''a'', which is the sum of the ''x'' and ''y'' basis
 vectors in the ''N'' reference frame.
 
-.. code-block:: python
+.. code:: python
 
     >>> P = Point('P')
 
 Creates a point named P.
 
-.. code-block:: python
+.. code:: python
 
     >>> K = KanesMethod(N)
 
-FIXME Creates a new ''KanesMethod'' object, used to generate $F_r + F_r^*$,
-with ''N'' as the inertial reference frame.
+FIXME Creates a new ''KanesMethod'' object, used to generate :math:`F_r +
+F_r^*`, with ''N'' as the inertial reference frame.
 
-.. code-block:: python
+.. code:: python
 
     >>> D = RigidBody('BodyD', masscenter=P, frame=N, mass=2, inertia=I)
 
 Creates a rigid body container and defines the center of mass location, the
 body fixed frame, the mass and the inertia.
 
-.. code-block:: python
+.. code:: python
 
     >>> Par = Particle()
 
@@ -122,26 +126,26 @@ function is and how to use it.
 Code Snippets
 -------------
 
-.. code-block:: python
+.. code:: python
 
     >>> mechanics_printing()
 
 Sets the default printing to use the mechanics printing.
 
-.. code-block:: python
+.. code:: python
 
     >>> mprint(q1)
 
 Prints ''q1'' using the mechanics printer; use if mechanics_printing is not on.
 
-.. code-block:: python
+.. code:: python
 
     >>> I = inertia(N, 1, 2, 3)
 
 Creates an inertia dyadic in the frame N with principle measure numbers of 1,
 2, and 3.
 
-.. code-block:: python
+.. code:: python
 
     >>> mprint(kinematic_equations([u1,u2,u3], [q1,q2,q3], 'body', '313'))
 

source/examples/examples.rst

@@ -6,30 +6,21 @@ Some general help and examples for using PyDy. Please add your own!
 Tutorials and References
 ------------------------
 
-*  :doc:`Commands </examples/commands>`
-
-*  :doc:`Beginner's Tutorial </examples/beginners_tutorial>`
+- :doc:`Commands </examples/commands>`
+- :doc:`Beginner's Tutorial </examples/beginners_tutorial>`
 
 
 Internal Examples
 -----------------
 
-*  :doc:`Double Pendulum </examples/double_pendulum>`
-
-*  :doc:`Chaos Pendulum </examples/chaos_pendulum>`
+- :doc:`Double Pendulum </examples/double_pendulum>`
+- :doc:`Chaos Pendulum </examples/chaos_pendulum>`
 
 External Examples
 -----------------
 
-*  `The PyDy example repository <https://github.com/PythonDynamics/pydy_examples>`_
-
-*  `Rolling Disc <http://docs.sympy.org/dev/modules/physics/mechanics/examples.html#the-rolling-disc>`_
-
-*  `Bicycle <http://docs.sympy.org/dev/modules/physics/mechanics/examples.html#the-bicycle>`_
-
-*  `N Link Pendulum <http://www.moorepants.info/blog/npendulum.html>`_
-
-*  `Another bicycle model <https://github.com/hazelnusse/bicycle.model>`_
-
-*  `Human Balance Tutorial <https://github.com/pydy/pydy-tutorial-pycon-2014>`_
-
+- `The PyDy example repository <https://github.com/pydy/pydy/tree/master/examples>`_
+- `Symbolic Examples <http://docs.sympy.org/latest/modules/physics/mechanics/examples.html>`_
+- `N Link Pendulum <http://www.moorepants.info/blog/npendulum.html>`_
+- `A bicycle model <https://github.com/hazelnusse/bicycle.model>`_
+- `Human Balance Tutorial <https://github.com/pydy/pydy-tutorial-pycon-2014>`_

source/management/project_management.rst source/gsoc.rst

@@ -1,13 +1,5 @@
-Project Management
-==================
-
-A history of the development of PyDy can be found :doc:`here </management/history>`.
-
-There is also an (out of date) :doc:`roadmap </management/roadmap>` for planned
-and desired features.
-
 Google Summer of Code
----------------------
+=====================
 
 PyDy exists because of support provided by multiple Google Summers of Code. We
 still apply for student positions annual, both as an independent organization

source/history.rst

@@ -0,0 +1,44 @@
+History
+=======
+
+Dale Peterson started graduate school at UC Davis in Fall of 2006 and met
+`Jason Moore <http://www.moorepants.info/>`_ in the
+[[http://biosport.ucdavis.edu/|Sports Biomechanics Lab]]. They shared a passion
+for bicycles, dynamics and control and had both taken the multibody system
+dynamics course  at UC Davis (MAE 223, taught by `Dr. Mont Hubbard
+<http://mae.ucdavis.edu/faculty/hubbard/hubbard.html>`_ and `Dr. Fedelis Eke
+<http://mae.ucdavis.edu/faculty/eke/eke.html>`_). This course teaches Kane's
+method for deriving equations of motion, and at that time they also taught
+`Autolev <http://www.autolev.com/>`_ (now defunct) in the course.  Autolev is
+very powerful at symbolic dynamics but lacks important functionality and they
+both found themselves wanting a richer set of tools for studying bicycles,
+rolling discs, rattlebacks, and other systems that are well described by
+classical mechanics. They dreamed of creating an open source tool that was
+more extensible and nicer to use, but at the time neither of them had the
+programming skills to make the dream a reality.
+
+In Spring of 2007, Dale took `Dr. Jim Crutchfield's
+<http://csc.ucdavis.edu/~chaos/>`_ graduate physics course in nonlinear
+dynamics and chaos, in which all homework was required to be done using Python.
+This was a tall order for a single class! This was Dale's favorite course in
+graduate school and his first introduction to chaos and to Python (and some of
+the chaos of Python).  About a year and a half later (December 2008), Dale was
+tinkering with Python and trying to replicate some of the kinematic
+functionality that made Autolev so convenient to use. He got some basic classes
+created and contacted `Ondřej Čertík <http://ondrejcertik.com/>`, the creator
+of the SymPy project to see if he was interested in helping him get started. He
+made a trip up to his apartment one weekend in January of 2009, and before he
+knew it, he had a good chunk of the functionality he was looking for. Whcih was
+really exciting!  Ondřej encouraged Dale to apply to a Google Summer of Code,
+so he did, and he spent the summer of 2009 working on a GSoC project that was a
+separate project from SymPy.  This was a big learning experience, and one of
+the things that was learned by the end of the summer was that the software
+should have been part of the SymPy project, rather than its own standalone
+project. This led to Gilbert Gede (another UC Davis graduate student) taking on
+a second GSoC project in which he ported the `original PyDy code
+<http://code.google.com/p/pydy/>`_ into SymPy as a sub-package
+''sympy.physics.mechanics''. This is what is currently is in the SymPy
+repository. The software was introduced to the UC Davis multibody dynamics
+course at the beginning of 2012, to replace the aging Autolev. A third GoSC
+grant allowed Angadh Nanjangud to add Lagrangian dynamics and many other
+features to the code base during the summer of 2012.

source/index.rst

@@ -1,10 +1,26 @@
-.. PyDy documentation master file, created by
-   sphinx-quickstart on Sun Jan 26 13:02:27 2014.
-   You can adapt this file completely to your liking, but it should at least
-   contain the root `toctree` directive.
+PyDy: Multibody Dynamics with Python
+====================================
 
-Welcome to the PyDy Wiki!
-=========================
+Introduction
+------------
+
+Welcome to the PyDy project website. PyDy, short for Python Dynamics, is a both
+a *workflow* that utlizes an array of scientific tools written in the Python
+programming language to study multibody dynamics and a set of software packages
+that help automate and enhance the workflow. The core of this toolset is the
+SymPy_ **mechanics** package which generates symbolic equations of motion for
+complex multibody systems and PyDy which extends the SymPy output to the
+numerical domain for simulation, analyses, and visualization. PyDy builds on
+the popular scientific Python stack such as NumPy_, SciPy_, IPython_,
+matplotlib_, Cython_, and Theano_.
+
+.. _SymPy: http://www.sympy.org
+.. _NumPy: http://numpy.org
+.. _SciPy: http://scipy.org
+.. _IPython: http://ipython.org
+.. _matplotlib: http://matplotlib.org
+.. _Cython: http://cython.org/
+.. _Theano: http://deeplearning.net/software/theano/
 
 Site Overview
 -------------
@@ -19,26 +35,10 @@ Site Overview
 
    installation/installation_general
    examples/examples
-   management/project_management
-
-
-Introduction
-------------
-
-Welcome to the PyDy project page. PyDy, short for Python Dynamics, is a
-*workflow* that utlizes an array of scientific tools written in the Python
-programming language to study multibody dynamics. The core of this toolset is
-the `SymPy <http://www.sympy.org>`_ **mechanics** package which generates
-symbolic equations of motion for complex multibody systems. The remaining tools
-used in the PyDy workflow are popular scientific Python packages such as
-`NumPy <http://numpy.org/>`_, `SciPy <http://scipy.org>`_,
-`IPython <http://ipython.org>`_, and `matplotlib <http://matplotlib.org>`_
-which provide code for numerical analyses, simulation, and visualization. We
-are a group of engineers and scientists who for one reason or another prefer to
-work in Python. You can learn more by reading about our [features](features)
-and our [history](history) or [examples](examples).
+   history
+   gsoc
 
 Blog
 ----
-.. postlist:: 4
 
+.. postlist:: 4