C:/Users/Andreas Schiffler/Desktop/SVN/NewGamePhysics/NewGamePhysics/PhysicalElements/CircularObjectSimulation.cs

//-----------------------------------------------------------------------------
// CircularObjectSimulation.cs
// (A. Schiffler, 2009)
//-----------------------------------------------------------------------------

namespace NewGamePhysics.PhysicalElements
{
    using System;
    using System.Collections.Generic;
    using System.Text;

    using Microsoft.Xna.Framework;

    using NewGamePhysics.Mathematics;
    using NewGamePhysics.Physics;

    public class CircularObjectSimulation
    {
        private CircularObjectAcceleration circularObjectAcceleration;
        
        private NystromIntegrator circularObjectIntegrator;

        private Vector2 circularObjectPosition;

        private double t;

        private double h;

        private VectorN p;

        private VectorN v;

        private VectorN acceleration;

        private double mass;

        private bool integratorNeedsReset;

        public CircularObjectSimulation(double objectDiameter, double objectDensity, double gravity, double atmosphereDensity)
        {
            // Time and stepsize
            t = 0;
            h = 0.01;

            // Drag coefficient (cD)
            double dragSphere = DragCoefficient.Sphere;

            // Ball mass = density * volume
            this.mass = objectDensity * Volume.Sphere(objectDiameter / 2.0);

            // Ball acceleration
            this.circularObjectAcceleration =
                new CircularObjectAcceleration(objectDiameter, objectDensity, dragSphere, -gravity, atmosphereDensity);

            // Reset state
            this.p = new VectorN(2);
            this.v = new VectorN(2);

            // Create integrator
            this.circularObjectIntegrator = new NystromIntegrator(
                (ISecondDerivative)this.circularObjectAcceleration, 
                this.h, 
                this.p, 
                this.v);
            this.integratorNeedsReset = false;

            // Allocate physical state variables as cache
            circularObjectPosition = new Vector2();
        }

        public void InitialConditionsAtRest()
        {
            SetInitialConditions(0.0, 0.0, 0.0, 0.0);
        }

        public void SetInitialConditions(double x, double y, double vx, double vy)
        {
            // Store values
            this.p[0] = x;
            this.p[1] = y;
            this.v[0] = vx;
            this.v[1] = vy;

            // Mark for integrator to require a reset
            this.integratorNeedsReset = true;
        }

        public void Animate()
        {
            // Check if integrator needs to be reset
            if (this.integratorNeedsReset)
            {
                this.acceleration = circularObjectIntegrator.Reset(this.p, this.v);
            }

            // Animate ball
            // double t; VectorN p, v, acceleration;
            circularObjectIntegrator.Step(out t, out p, out v, out acceleration);
        }

        public void Drive(Vector2 force)
        {
            v[0] = this.h * force.X * this.mass;
            v[1] = this.h * force.Y * this.mass;
        }

        public void SetPosition(Vector2 position)
        {
            // Set position
            p[0] = position.X;
            p[1] = position.Y;

            // Reset speed
            v[0] = 0.0f;
            v[1] = 0.0f;
        }

        public void SetPosition(Vector2 position, double scale)
        {
            // Set position
            if (scale != 0.0)
            {
                p[0] = position.X / scale;
                p[1] = position.Y / scale;
            }

            // Reset speed
            v[0] = 0.0f;
            v[1] = 0.0f;
        }

        public Vector2 GetPosition()
        {
            // Set position
            circularObjectPosition.X = (float)(p[0]);
            circularObjectPosition.Y = (float)(p[1]);

            return circularObjectPosition;
        }

        public Vector2 GetPosition(double scale)
        {
            // Set position
            circularObjectPosition.X = (float)(scale * p[0]);
            circularObjectPosition.Y = (float)(scale * p[1]);

            return circularObjectPosition;
        }
    }
}

---