{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "81be473b-d43f-4859-a9cc-ae879376673a",
   "metadata": {},
   "source": [
    "# Center of Mass estimator: explanation of the code"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3900ba9d-2cd1-47e7-beaf-c3832c889b16",
   "metadata": {},
   "source": [
    "If the center_of_mass package is not installed, run the following lines:\n",
    "```\n",
    "import sys\n",
    "sys.path.insert(0, '../src')\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "cb632a9b-ea99-4d04-add1-8e6bc518b97a",
   "metadata": {},
   "outputs": [],
   "source": [
    "import center_of_mass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "f9d63bf9-f27e-4fc4-9353-930119db8954",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy, pickle, sys"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b779d4ca-8eaa-434c-89bb-22278bd69db1",
   "metadata": {},
   "source": [
    "Measurement errors used for calculating the optimal estimator gains"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "3d7824b3-6df6-4fe9-9295-2d5a0fc76485",
   "metadata": {},
   "outputs": [],
   "source": [
    "Position_std = 0.0035 # standard deviation of the error in CoM position obtained from the kinematics alone (in m)\n",
    "Force_std    = 2      # standard deviation of the error in Ground reaction force (in N)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e4f09dbb-038f-468f-bc23-100cf632add6",
   "metadata": {},
   "source": [
    "The example data file is loaded"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "a38d719f-73f0-40be-aae7-83879e85a2da",
   "metadata": {},
   "outputs": [],
   "source": [
    "input_file     = '..\\examples\\example_data.pkl'\n",
    "pickle_file    = open(input_file,'rb')\n",
    "data           = pickle.load(pickle_file)\n",
    "pickle_file.close()\n",
    "\n",
    "sex                 = data['sex']                # 'female' or 'male'\n",
    "Labels              = data['Labels']             # list of marker labels\n",
    "Kinematic_frequency = data['Position_frequency'] # in Hertz\n",
    "Position            = data['Position']           # dictionary with, for each marker, the position in meters (numpy.ndarray of shape (3,duration*Position_frequency)\n",
    "Force_frequency     = data['Force_frequency']    # in Hertz\n",
    "GroundReactionForce = data['GroundReactionForce']# in Newtons (numpy.ndarray of shape (3,duration*Force_frequency)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dd605c35-07f2-433a-a2a1-fe0ffed44340",
   "metadata": {},
   "source": [
    "The center of mass is calculated (in this example we use the method of Dumas et al. 2007)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "a7d519aa-0b2b-4e29-8e60-01ff4a4ea27f",
   "metadata": {},
   "outputs": [],
   "source": [
    "kinematics    = center_of_mass.Kinematics(Position, Labels, sex)\n",
    "Kinematic_com = kinematics.calculate_CoM()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6b706e15-c7d6-4a00-b71b-6e0f8c50382e",
   "metadata": {},
   "source": [
    "The person's mass is determined as the median vertical ground reaction force during the initial 1.5 seconds of quiet standing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "f8d445eb-a837-4087-b1d7-d9a96231b5cf",
   "metadata": {},
   "outputs": [],
   "source": [
    "mass = numpy.median(GroundReactionForce[2,:int(1.5*Force_frequency)])/9.81"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8eab6637-12fd-44b6-953d-08fd20103a01",
   "metadata": {},
   "source": [
    "The Center of Mass acceleration is calculated by subtracting the weight from the ground reaction force and dividing by mass. By default, the vertical axis is assumed to correspond to the third row of the Ground Reaction Force, and to be oriented upwards. However, this can be changed through the arguments 'vertical' and 'direction'."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "8baddc82-507c-4b8a-ac8b-ee8b5fb843b3",
   "metadata": {},
   "outputs": [],
   "source": [
    "def com_acceleration(GroundReactionForce, mass, gravity_direction = numpy.array([0,0,-1])):\n",
    "    '''Calculates the CoM acceleration from the Ground reaction force and mass \n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    GroundReactionForce: (NbOfDimensions,NbOfSamples) numpy.ndarray\n",
    "        Ground reaction force (in Newton)\n",
    "    mass: float \n",
    "        subject's mass (in kg)\n",
    "    gravity_direction: (NbOfDimensions) numpy.ndarray, optional\n",
    "        direction of the gravity vector used to subtract the subject's weight, default is numpy.array([0,0,-1])\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    Acceleration: (NbOfDimensions,NbOfSamples) numpy.ndarray\n",
    "        Acceleration of the Center of Mass (in m/s^2)\n",
    "    '''\n",
    "    ## The net force is the sum of the ground reaction force and the person's weight \n",
    "    NetForce = GroundReactionForce + mass*9.81*numpy.array([gravity_direction]).T\n",
    "    ## Acceleration is force divided by mass\n",
    "    Acceleration = NetForce/mass\n",
    "    return Acceleration"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "973a634c-5697-43d0-a6ba-22147a7f4c82",
   "metadata": {},
   "outputs": [],
   "source": [
    "Acceleration = com_acceleration(GroundReactionForce, mass)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c90e929f-e3e3-4724-856d-a8625c413971",
   "metadata": {},
   "source": [
    "The position and acceleration signals must be synchronised before applying the filtering. If they have a different sampling frequency, they are sub-sampled at a common frequency. The user can specify a desired sub-sampling frequency (which must be a common divisor of both Position_frequency and Acceleration_frequency). Otherwise, the greatest common divisor is used as the sub-sampling frequency."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "b7d1dd21-ad17-40b1-91dd-c99a03c5768f",
   "metadata": {},
   "outputs": [],
   "source": [
    "def subsample_one_signal(signal, signal_frequency, sub_frequency):\n",
    "    '''Subsample a signal at a given Frequency\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    signal: (NbOfDimensions, NbOfSamples) numpy.ndarray\n",
    "        Signal to subsample\n",
    "    signal_frequency: int \n",
    "        Sampling frequency (in Hertz) of the signal\n",
    "    sub_frequency: int \n",
    "        Desired sub-sampling frequency (in Hertz)\n",
    "        \n",
    "    Returns\n",
    "    -------   \n",
    "    signal_subsampled: (NbOfDimensions, NbOfSamples_sub) numpy.ndarray\n",
    "        Subsampled signal\n",
    "    '''\n",
    "    # The sub-sampling frequency must be a divisor of the signal frequency:\n",
    "    if signal_frequency % sub_frequency != 0:\n",
    "        raise ValueError('The sub-sampling frequency is not a divisor of the signal frequency. This would lead to synchronisation issues when sub-sampling.')\n",
    "    else:\n",
    "        if signal_frequency == sub_frequency:\n",
    "            return signal\n",
    "        else:    \n",
    "            bin_size          = int(signal_frequency/sub_frequency) # the signal will be averaged over bins of this size\n",
    "            NbOfDimensions    = numpy.shape(signal)[0]\n",
    "            NbOfSamples_sub   = int(numpy.shape(signal)[1]/bin_size)\n",
    "            signal_truncated  = signal[:,:bin_size*NbOfSamples_sub] \n",
    "            signal_subsampled = numpy.zeros((NbOfDimensions,NbOfSamples_sub))\n",
    "            for dim in range(NbOfDimensions):\n",
    "                signal_reshape         = signal_truncated[dim].reshape(NbOfSamples_sub,bin_size)\n",
    "                signal_subsampled[dim] = numpy.mean(signal_reshape, axis = 1)   \n",
    "            return signal_subsampled\n",
    "\n",
    "\n",
    "def subsample_two_signals(signal1, frequency1, signal2, frequency2, sub_frequency = None):\n",
    "    '''Subsample two signals at a common frequency\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    signal1: (NbOfDimensions,NbOfSamples1) numpy.ndarray\n",
    "        First signal\n",
    "    frequency1: int \n",
    "        Sampling frequency (in Hertz) of the first signal\n",
    "    signal2: (NbOfDimensions,NbOfSamples2) numpy.ndarray\n",
    "        Second signal\n",
    "    frequency2: int \n",
    "        Sampling frequency (in Hertz) of the second signal\n",
    "    sub_frequency: int, optional \n",
    "        Desired sub-sampling frequency (in Hertz), default is None\n",
    "        \n",
    "    Returns\n",
    "    -------   \n",
    "    signal1_subsampled: (NbOfDimensions,NbOfSamples_sub) numpy.ndarray\n",
    "        Subsampled first signal\n",
    "    signal2_subsampled: (NbOfDimensions,NbOfSamples_sub) numpy.ndarray\n",
    "        Subsampled second signal\n",
    "    sub_frequency: int \n",
    "        Subsampling frequency (in Hertz)\n",
    "        If the sub-sampling frequency was not specified by the user, this is the greatest common divisor of frequency1 and frequency2\n",
    "    '''\n",
    "    if not sub_frequency:\n",
    "        ## The frequency at which both signals will be subsampled is the greatest common divisor of the two frequencies\n",
    "        import math\n",
    "        sub_frequency = math.gcd(int(frequency1), int(frequency2))\n",
    "        \n",
    "    signal1_subsampled = subsample_one_signal(signal1, frequency1, sub_frequency)\n",
    "    signal2_subsampled = subsample_one_signal(signal2, frequency2, sub_frequency)\n",
    "    \n",
    "    # Truncate the signals so that they have the same length\n",
    "    NbOfSamples_sub = min(numpy.shape(signal1_subsampled)[1],numpy.shape(signal2_subsampled)[1])\n",
    "    signal1_subsampled = signal1_subsampled[:,:NbOfSamples_sub]\n",
    "    signal2_subsampled = signal2_subsampled[:,:NbOfSamples_sub]\n",
    "    \n",
    "    return signal1_subsampled, signal2_subsampled, sub_frequency"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "3b97900e-f938-4ac3-8a06-70096b2a2a74",
   "metadata": {},
   "outputs": [],
   "source": [
    "Acc_subsampled, Pos_subsampled, Frequency = subsample_two_signals(Acceleration, Force_frequency, Kinematic_com, Kinematic_frequency)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9bfb2375-9812-44e5-a94c-15fb272acfd8",
   "metadata": {},
   "source": [
    "The optimal estimator gains depend on the dimensionless ratio of position to acceleration noise:\n",
    "$$ r = \\frac{p_{std}Freq^2}{a_{std}} = \\frac{p_{std}Freq^2}{F_{std}}mass$$\n",
    "$$l_2 =\\frac{1+4r-\\sqrt{1+8r}}{4r^2}$$\n",
    "$$l_1 = 1 - r^2 l_2$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "88e6827c-bf62-444c-860d-62a773f14603",
   "metadata": {},
   "outputs": [],
   "source": [
    "def estimator_gains(Force_std, Position_std, Frequency, mass):\n",
    "    '''Calculates the optimal estimator gains according to the measurement errors and sampling frequency\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    Force_std: float or (NbOfDimensions,) numpy.ndarray\n",
    "        Standard deviation of the error in Ground reaction force (in N) (can be provided for each dimension independently)\n",
    "    Position_std: float or (NbOfDimensions,) numpy.ndarray\n",
    "        Standard deviation of the error in CoM position obtained from the kinematics (in m) (can be provided for each dimension independently)\n",
    "    Frequency: int\n",
    "        Sampling frequency of the (sub-sampled) CoM position and acceleration \n",
    "    mass: float\n",
    "        Mass of the subject (in kg)\n",
    "        \n",
    "    Returns\n",
    "    -------\n",
    "    l1: float or (NbOfDimensions,) numpy.ndarray\n",
    "        Optimal estimator gain for position (dimensionless)\n",
    "    l2: float or (NbOfDimensions,) numpy.ndarray\n",
    "        Optimal estimator gain for velocity (dimensionless)\n",
    "    '''\n",
    "    Acceleration_std = Force_std/mass\n",
    "    ratio = Position_std/Acceleration_std*Frequency**2\n",
    "    l2    = numpy.array((4*ratio+1 - numpy.sqrt(1+8*ratio))/(4*ratio**2))\n",
    "    l1    = numpy.array(1 - ratio**2*l2**2)\n",
    "    if not numpy.array(((Position_std > 0)*(Force_std > 0))).all():\n",
    "        if numpy.array((Force_std == 0)*(Position_std == 0)).any():\n",
    "            raise ValueError('Either Force_std or Position_std must be strictly positive')\n",
    "        elif numpy.array(Force_std == 0).any(): \n",
    "            l1[Force_std == 0] = 0\n",
    "            l2[Force_std == 0] = 0\n",
    "        elif numpy.array(Position_std == 0).any():\n",
    "            l1[Position_std == 0] = 1\n",
    "            l2[Position_std == 0] = 2\n",
    "        else:\n",
    "            raise ValueError('Force_std and Position_std must be positive')\n",
    "    return l1, l2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "01658a52-40af-461f-a23f-3f56fa8214eb",
   "metadata": {},
   "outputs": [],
   "source": [
    "l1, l2 = estimator_gains(Force_std, Position_std, Frequency, mass)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "028999b9-444f-4607-9efd-d6232cd7fe30",
   "metadata": {},
   "source": [
    "Unless they are specified by the user, the initial estimates of position and velocity are obtained as a least-squares fit on the first few samples of the position measurement.\n",
    "$$\\left(\\begin{matrix}p_{measured}^0 \\\\ \\vdots\\\\ p_{measured}^{k_0}\\end{matrix}\\right)\\approx p_{estimate}^0\\left(\\begin{matrix}1 \\\\ \\vdots\\\\ 1\\end{matrix}\\right)+v_{estimate}^0\\left(\\begin{matrix}0 \\\\ \\vdots\\\\ k_0 T\\end{matrix}\\right)= \\left(\\begin{matrix}1 & 0 \\\\ \\vdots & \\vdots \\\\ 1 & k_0 T\\end{matrix}\\right)\\left(\\begin{matrix}p_{estimate}^0 & v_{estimate}^0\\end{matrix}\\right)$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "7c809dba-9bbf-4bdb-bdd5-dffeaace6402",
   "metadata": {},
   "outputs": [],
   "source": [
    "def initial_conditions(Pos_measurement, T, initial_samples = 10):\n",
    "    '''The initial estimates of position and velocity are obtained as a least-squares fit on the first few samples of the position measurement.\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    Pos_measurement: (NbOfSamples,) numpy.ndarray\n",
    "        Position measurement (in m)\n",
    "    T: float \n",
    "        duration (in seconds) between successive samples (i.e. 1/Sampling_frequency)\n",
    "    initial_samples: int, optional   \n",
    "        Number of samples used to estimate initial position and velocity (default is 10)\n",
    "        \n",
    "        \n",
    "    Returns\n",
    "    -------\n",
    "    pos_initial: float\n",
    "        Initial position estimate (in m)\n",
    "    vel_initial: float\n",
    "        Initial velocity estimate (in m/s)\n",
    "    '''\n",
    "    Coefficients = numpy.array([numpy.ones(initial_samples),numpy.arange(initial_samples)*T]).T\n",
    "    [pos_initial, vel_initial] = numpy.linalg.lstsq(Coefficients, Pos_measurement[:initial_samples], rcond=None)[0]\n",
    "    return pos_initial, vel_initial "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "42bd5e65-2bbc-4cfb-add1-dc53af3c0de3",
   "metadata": {},
   "source": [
    "Given the estimate $\\left(\\begin{matrix}p_{estimate}^k\\\\v_{estimate}^k\\\\\\end{matrix}\\right)$ of the state position and velocity at timepoint $k$ and the acceleration mesurement $a_{measurement}^k$ at timepoint $k$, we obtain a prediction $\\left(\\begin{matrix}p_{prediction}^k\\\\v_{prediction}^k\\\\\\end{matrix}\\right)$ of the system state at timepoint $k+1$ by double integration of the measured acceleration:\n",
    "$$\\left(\\begin{matrix}p_{prediction}^{k+1}\\\\v_{prediction}^{k+1}\\\\\\end{matrix}\\right)=\\left(\\begin{matrix}1&T\\\\0&1\\\\\\end{matrix}\\right) \\left(\\begin{matrix}p_{estimate}^k\\\\v_{estimate}^k\\\\\\end{matrix}\\right) + \\left(\\begin{matrix}\\frac{T^2}{2}\\\\T\\\\\\end{matrix}\\right) a_{measurement}^k$$"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ce208de2-e351-452f-94f8-d530e6718315",
   "metadata": {},
   "source": [
    "The position prediction $p_{prediction}^{k+1}$ is then compared to the position measurement $p_{measurement}^{k+1}$ and the difference (i.e. prediction error) is used to adjust the estimates of position and speed at timepoint $k+1$ using the estimator gains $\\left(\\begin{matrix}l_1\\\\\\frac{l_2}{T}\\\\\\end{matrix}\\right)$:\n",
    "$$\\left(\\begin{matrix}p_{estimate}^{k+1}\\\\v_{estimate}^{k+1}\\\\\\end{matrix}\\right) = \\left(\\begin{matrix}p_{prediction}^{k+1}\\\\v_{prediction}^{k+1}\\\\\\end{matrix}\\right) + \\left(\\begin{matrix}l_1\\\\\\frac{l_2}{T}\\\\\\end{matrix}\\right)(p_{measurement}^{k+1}-p_{prediction}^{k+1})$$\n",
    "$$ = \\left(\\begin{matrix}p_{prediction}^{k+1}(1-l_1)+l_1p_{measurement}^{k+1}\\\\v_{prediction}^{k+1}+\\frac{l_2}{T}(p_{measurement}^{k+1}-p_{prediction}^{k+1})\\\\\\end{matrix}\\right)$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "d7a73e2d-8135-436d-9d4f-76c1817ebc80",
   "metadata": {},
   "outputs": [],
   "source": [
    "def estimator(Acc_measurement, Pos_measurement, l1, l2, T, Initial_conditions):\n",
    "    '''Estimation of the position and velocity, given (noisy) measurements of position and acceleration,\n",
    "    estimator gains, and initial conditions\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    Acc_measurement: (NbOfSamples,) numpy.ndarray\n",
    "        Acceleration measurement (in m/s^2)\n",
    "    Pos_measurement: (NbOfSamples,) numpy.ndarray\n",
    "        Position measurement (in m)\n",
    "    l1: float or (NbOfDimensions,) numpy.ndarray\n",
    "        Position estimator gain (dimensionless)\n",
    "    l2: float or (NbOfDimensions,) numpy.ndarray\n",
    "        Velocity estimator gain (dimensionless)\n",
    "    T: float \n",
    "        duration (in seconds) between successive samples (i.e. 1/Sampling_frequency)\n",
    "    Initial_conditions: (2,) numpy.ndarray\n",
    "        initial estimates of position (in m) and velocity (in m/s)\n",
    "    \n",
    "    Returns\n",
    "    -------\n",
    "    Pos_estimate: (NbOfSamples,) numpy.ndarray\n",
    "        Position estimate (in m)\n",
    "    Vel_estimate: (NbOfSamples,) numpy.ndarray\n",
    "        Velocity estimate (in m/s)\n",
    "    '''\n",
    "    Pos_estimate    = numpy.zeros(len(Pos_measurement))\n",
    "    Vel_estimate    = numpy.zeros(len(Pos_measurement))\n",
    "    Pos_estimate[0], Vel_estimate[0] = Initial_conditions\n",
    "    for k in range(len(Pos_measurement)-1):\n",
    "        pos_prediction    = Pos_estimate[k]+T*Vel_estimate[k]+T**2/2*Acc_measurement[k]\n",
    "        vel_prediction    = Vel_estimate[k]+T*Acc_measurement[k]\n",
    "        Pos_estimate[k+1] = (1-l1)*pos_prediction   +l1*Pos_measurement[k+1]\n",
    "        Vel_estimate[k+1] = vel_prediction +l2/T*(Pos_measurement[k+1]-pos_prediction)\n",
    "    return Pos_estimate, Vel_estimate    "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "82cb7e05-6154-4b95-b164-a866528bacdf",
   "metadata": {},
   "source": [
    "The estimator is applied, for each dimension separately, both forwards and backwards in time, and the forwards and backwards averaged are then merged. Note that when reversing time, velocity changes sign, whereas position and acceleration are unchanged."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "ce5d1a39-10d8-4dd5-9969-ff9c65beb283",
   "metadata": {},
   "outputs": [],
   "source": [
    "def estimator_backandforth(Acc_measurement, Pos_measurement, l1, l2, Frequency, Initial_conditions = None, Final_conditions = None, initial_samples = 10):\n",
    "    '''The estimator is applied, for each dimension separately, both forwards and backwards in time, and the forwards and backwards estimates are then merged.\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    Acc_measurement: (NbOfDimensions, NbOfSamples) numpy.ndarray\n",
    "        Acceleration measurement (in m/s^2)\n",
    "    Pos_measurement: (NbOfDimensions, NbOfSamples) numpy.ndarray\n",
    "        Position measurement (in m)\n",
    "    l1: float or (NbOfDimensions,) numpy.ndarray\n",
    "        Position estimator gain (dimensionless)\n",
    "    l2: float or (NbOfDimensions,) numpy.ndarray\n",
    "        Velocity estimator gain (dimensionless)\n",
    "    Frequency: float \n",
    "        Sampling frequency (in Hertz)\n",
    "    Initial_conditions: (NbOfDimensions,2) numpy.ndarray, optional\n",
    "        Initial estimates of position (in m) and velocity (in m/s), used when the estimator is applied forwards in time (default is None).\n",
    "        If None, the initial conditions are determined by a least-squares fit on the first few samples.\n",
    "    Final_conditions: (NbOfDimensions,2) numpy.ndarray, optional\n",
    "        Final estimates of position (in m) and velocity (in m/s), used when the estimator is applied backwards in time (default is None).\n",
    "        If None, the final conditions are determined by a least-squares fit on the first few samples.\n",
    "    initial_samples: int, optional\n",
    "        Number of samples used to estimate initial and final position and velocity (default is 10)\n",
    "    \n",
    "    Returns\n",
    "    -------\n",
    "    Pos_estimate: (NbOfDimensions, NbOfSamples) numpy.ndarray\n",
    "        Position estimate (in m)\n",
    "    Vel_estimate: (NbOfDimensions, NbOfSamples) numpy.ndarray\n",
    "        Velocity estimate (in m/s)\n",
    "    '''\n",
    "    NbOfDimensions, NbOfSamples = numpy.shape(Pos_measurement)\n",
    "    Pos_estimate_forw  = numpy.zeros((NbOfDimensions, NbOfSamples))\n",
    "    Vel_estimate_forw  = numpy.zeros((NbOfDimensions, NbOfSamples))\n",
    "    Pos_estimate_back  = numpy.zeros((NbOfDimensions, NbOfSamples))\n",
    "    Vel_estimate_back  = numpy.zeros((NbOfDimensions, NbOfSamples))\n",
    "    \n",
    "    # If a single value is given for l1 and l2, these are used for all dimensions\n",
    "    if len(numpy.shape(l1)) == 0: \n",
    "        l1 = l1*numpy.ones((NbOfDimensions))\n",
    "    if len(numpy.shape(l2)) == 0:     \n",
    "        l2 = l2*numpy.ones((NbOfDimensions))\n",
    "    \n",
    "    for dim in range(NbOfDimensions):\n",
    "        # If the user does not specify the initial estimate of position and velocity, these are estimated from the first few samples of position \n",
    "        if numpy.sum(Initial_conditions==None) > 0:\n",
    "            Initial_conditions_dim = initial_conditions(Pos_measurement[dim], 1/Frequency, initial_samples = initial_samples)\n",
    "        else:\n",
    "            Initial_conditions_dim = Initial_conditions[dim]\n",
    "        if numpy.sum(Final_conditions==None) > 0:\n",
    "            Final_conditions_dim = initial_conditions(Pos_measurement[dim,::-1], 1/Frequency, initial_samples = initial_samples)\n",
    "        else:\n",
    "            Final_conditions_dim = Final_conditions[dim]\n",
    "        Pos_estimate_forw[dim], Vel_estimate_forw[dim] = estimator(Acc_measurement[dim],      Pos_measurement[dim],      l1[dim], l2[dim], 1/Frequency, Initial_conditions_dim)\n",
    "        Pos_estimate_back[dim], Vel_estimate_back[dim] = estimator(Acc_measurement[dim,::-1], Pos_measurement[dim,::-1], l1[dim], l2[dim], 1/Frequency, Final_conditions_dim)\n",
    "    Pos_estimate = 0.5*(Pos_estimate_forw+Pos_estimate_back[:,::-1])\n",
    "    Vel_estimate = 0.5*(Vel_estimate_forw-Vel_estimate_back[:,::-1])    \n",
    "    return Pos_estimate, Vel_estimate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "53add51b-ac17-4271-b815-dc16e6de167e",
   "metadata": {},
   "outputs": [],
   "source": [
    "Pos_estimate, Vel_estimate = estimator_backandforth(Acc_subsampled, Pos_subsampled, l1, l2, Frequency)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bd20e1de-b108-467e-b068-6fa60ed58f66",
   "metadata": {},
   "source": [
    "Visualisation of the measurements and estimates"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "5b3321ad-df84-4faa-9c55-ad17e4ef5e31",
   "metadata": {},
   "outputs": [],
   "source": [
    "def visualise(Acc_subsampled, Pos_subsampled, Pos_estimate, Vel_estimate, Frequency):\n",
    "    import matplotlib.pyplot as plt\n",
    "    plt.rcParams['axes.spines.right'] = False\n",
    "    plt.rcParams['axes.spines.top'] = False\n",
    "    NbOfDimensions, NbOfSamples = numpy.shape(Acc_subsampled)\n",
    "    time = numpy.arange(NbOfSamples)/Frequency\n",
    "    \n",
    "    fig, axes = plt.subplots(3,NbOfDimensions)\n",
    "    for dim in range(NbOfDimensions):\n",
    "        axes[0,dim].plot(time, Pos_subsampled[dim], color = 'k', label = 'measurement')\n",
    "        axes[0,dim].plot(time, Pos_estimate[dim], color = 'b', label = 'estimate')\n",
    "        axes[1,dim].plot(time, Vel_estimate[dim], color = 'b')\n",
    "        axes[2,dim].plot(time, Acc_subsampled[dim], color = 'k')\n",
    "    axes[0,0].legend()\n",
    "    labels = ['Position (m)','Velocity (m/s)',r'Acceleration $(m/s^2)$']\n",
    "    for l in range(3):\n",
    "        axes[l,0].set_ylabel(labels[l])\n",
    "    for t in range(NbOfDimensions):\n",
    "        axes[2,t].set_xlabel('Time (s)')\n",
    "    plt.show()\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "381eb372-2536-42b5-9099-57f1251b5720",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 9 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "visualise(Acc_subsampled, Pos_subsampled, Pos_estimate, Vel_estimate, Frequency)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c98c577a-c8b9-40fa-8f9c-896c89699852",
   "metadata": {},
   "source": [
    "The function optimal_combination combines all these successive steps"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "c14859c5-55ca-4c59-85fd-a5511304fcdd",
   "metadata": {},
   "outputs": [],
   "source": [
    "def optimal_combination(GroundReactionForce, Force_frequency, Kinematic_com, Kinematic_frequency, mass,\n",
    "    Force_std = 2, Position_std = 0.002, gravity_direction = numpy.array([0,0,-1]), sub_frequency = None, Initial_conditions = None, Final_conditions = None, initial_samples = 10):\n",
    "    '''Combines the Center of Mass position obtained from kinematic measurements with Ground reaction force to estimate the Center of Mass position and velocity\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    GroundReactionForce: (NbOfDimensions,NbOfSamples1) numpy.ndarray\n",
    "        Ground reaction force (in Newton)\n",
    "    Force_frequency: int \n",
    "        Sampling frequency (in Hertz) of the Ground reaction force\n",
    "    Kinematic_com: (NbOfDimensions,NbOfSamples2) numpy.ndarray\n",
    "        Center of Mass position obtained from kinematic measurements (in m)\n",
    "    Kinematic_frequency: int \n",
    "        Sampling frequency (in Hertz) of the kinematics\n",
    "    mass: float \n",
    "        subject's mass (in kg)\n",
    "    Force_std: float or (NbOfDimensions,) numpy.ndarray, optional\n",
    "        Standard deviation of the error in Ground reaction force (in N) (can be provided for each dimension independently), default is 2 N\n",
    "    Position_std: float or (NbOfDimensions,) numpy.ndarray, optional\n",
    "        Standard deviation of the error in CoM position obtained from the kinematics (in m) (can be provided for each dimension independently), default is 0.002 m\n",
    "    gravity_direction: (NbOfDimensions) numpy.ndarray, optional\n",
    "        direction of the gravity vector used to subtract the subject's weight, default is numpy.array([0,0,-1])\n",
    "    sub_frequency: int, optional \n",
    "        Desired sub-sampling frequency (in Hertz), default is None\n",
    "    Initial_conditions: (NbOfDimensions,2) numpy.ndarray, optional\n",
    "        Initial estimates of position (in m) and velocity (in m/s), used when the estimator is applied forwards in time (default is None).\n",
    "        If None, the initial conditions are determined by a least-squares fit on the first few samples.\n",
    "    Final_conditions: (NbOfDimensions,2) numpy.ndarray, optional\n",
    "        Final estimates of position (in m) and velocity (in m/s), used when the estimator is applied backwards in time (default is None).\n",
    "        If None, the final conditions are determined by a least-squares fit on the first few samples.\n",
    "    initial_samples: int, optional\n",
    "        Number of samples used to estimate initial and final position and velocity (default is 10)\n",
    "    \n",
    "    Returns\n",
    "    -------\n",
    "    Pos_estimate: (NbOfDimensions, NbOfSamples) numpy.ndarray\n",
    "        Position estimate (in m)\n",
    "    Vel_estimate: (NbOfDimensions, NbOfSamples) numpy.ndarray\n",
    "        Velocity estimate (in m/s)\n",
    "    Frequency: int \n",
    "        Sampling frequency of the position and velocity estimates\n",
    "    '''\n",
    "    \n",
    "    \n",
    "    # The CoM acceleration is calculated from the Ground reaction force and mass \n",
    "    Acceleration = com_acceleration(GroundReactionForce, mass, gravity_direction = gravity_direction)\n",
    "\n",
    "    # Position and Acceleration are sub-sampled at a common frequency\n",
    "    Acc_subsampled, Pos_subsampled, Frequency = subsample_two_signals(Acceleration, Force_frequency, Kinematic_com, Kinematic_frequency, sub_frequency = sub_frequency)\n",
    "    \n",
    "    # The optimal estimator gains at that Frequency are calculated\n",
    "    l1, l2 = estimator_gains(Force_std, Position_std, Frequency, mass)\n",
    "    \n",
    "    ## The estimator is applied both forwards in time and backwards, and the forwards and backwards estimates are merged.\n",
    "    Pos_estimate, Vel_estimate = estimator_backandforth(Acc_subsampled, Pos_subsampled, l1, l2, Frequency, Initial_conditions = Initial_conditions, Final_conditions = Final_conditions, initial_samples = initial_samples)\n",
    "    \n",
    "    return Pos_estimate, Vel_estimate, Frequency"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "c14006b3-62c9-4ff1-b983-dd67325dd91b",
   "metadata": {},
   "outputs": [],
   "source": [
    "Pos_estimate, Vel_estimate, Frequency = optimal_combination(GroundReactionForce, Force_frequency, Kinematic_com, Kinematic_frequency, mass)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "46882f3e-14cf-4c62-9e2d-3a1df5102441",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 9 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "visualise(Acc_subsampled, Pos_subsampled, Pos_estimate, Vel_estimate, Frequency)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}