test8.cpp

Go to the documentation of this file.

#include "indii/fmri/hemodynamic/NeuralBalloonModel.hpp"
#include "indii/fmri/hemodynamic/FlowBalloonModel.hpp"
#include "indii/fmri/hemodynamic/BOLDCalculator.hpp"
#include "indii/ml/ode/AdaptiveRungeKutta.hpp"

#include <iostream>
#include <string.h>
#include <math.h>

using namespace std;
using namespace indii::fmri::hemodynamic;
using namespace indii::ml::ode;

/**
 * @file test8.cpp
 *
 * Backward test of NeuralBalloonModel.
 *
 * This test uses a default NeuralBalloonModel with a driving neural
 * activity function \f$u(t)\f$ consisting of a brief 1 s long burst
 * of activity followed by no activity. The model is first simulated
 * forward for a set time period, and then backward for the same
 * period of time.
 *
 * Results from the backward simulation are output on stdout, tab
 * delimited, with columns representing:
 *
 * \li \f$t\f$; time
 * \li \f$f_{in}(t)\f$
 * \li \f$f_{out}(t)\f$
 * \li \f$u(t)\f$
 * \li \f$q\f$
 * \li \f$v\f$
 * \li \f$f\f$
 * \li \f$s\f$
 * \li \f$y\f$; BOLD response
 *
 * Results are as follows:
 *
 * \image html test8.png "Results"
 * \image latex test8.eps "Results"
 *
 * These should be identical to those for test3, which represents a
 * forward pass under the same conditions.
 */


/**
 * Duration of simulation (s).
 */
static const double END = 30.0;

/**
 * \f$u(t)\f$; 1 for 1 s, then 0.
 */
double U(double t, const double y[], void* o) {
  double u;
  if (t < 1.0) {
    u = 1.0;
  } else {
    u = 0.0;
  }
  return u;
}

double F_OUT(double t, const double y[], void* o) {
  return y[NeuralBalloonModel::V];
}

double E(double t, const double y[], void* o) {
  return 0.4;
}

/**
 * Run tests.
 */
int main(int argc, const char* argv[]) {
  NeuralBalloonModel balloonModel;
  AdaptiveRungeKutta ode(&balloonModel, balloonModel.suggestInitialState());
  BOLDCalculator boldCalculator(&balloonModel);

  ode.setErrorBounds(1.0e-12, 1.0e-12);

  /* set up balloon model */
  balloonModel.setFunction(NeuralBalloonModel::U, U);
  //balloonModel.setFunction(NeuralBalloonModel::F_OUT, F_OUT);
  //balloonModel.setFunction(NeuralBalloonModel::E, E);
  //balloonModel.setParameter(NeuralBalloonModel::ALPHA, 1.0);

  /* forward pass */
  double t = 0.0;
  while (t < END) {
    t = ode.step(END);
  }

  /* backward pass */
  while (t > 0.0) {
    cout << t << "\t";
    cout << balloonModel.getFunction(FlowBalloonModel::F_IN) << "\t";
    cout << balloonModel.getFunction(FlowBalloonModel::F_OUT) << "\t";
    cout << balloonModel.getFunction(NeuralBalloonModel::U) << "\t";
    cout << ode.getVariable(FlowBalloonModel::Q) << "\t";
    cout << ode.getVariable(FlowBalloonModel::V) << "\t";
    cout << ode.getVariable(NeuralBalloonModel::F) << "\t";
    cout << ode.getVariable(NeuralBalloonModel::S) << "\t";
    cout << boldCalculator.calculate(ode.getState()) * 100.0 << "\t";
    cout << endl;
    t = ode.stepBack(0.0);
  }

  return 0;
}

---