public void reset() {
   super.reset();
   system.reset();
   if (s != null) {
     for (int i = 0; i < numberOfSubstances; i++) {
       s[i].storeValue();
       s[i].storeRate();
     }
     timer.storeTimePoint();
   }
 }
  public void update() {
    double t = 0.0;
    double errRatio;
    if (step > samplingStep) step = samplingStep;
    int nSteps = 0;
    for (; ; ) {
      if ((samplingStep - t < step) && (samplingStep - t > 0.0)) step = samplingStep - t;

      rkckStep(step);
      errRatio = Numerics.max(yerr) / tolerance;

      //
      // Update the substance levels and go to the next step if
      // 1. The target tolerance is reached.
      // 2. The maximum # of iteractions is exceeded.
      // 3. The minimum time step is reached.
      //
      if (errRatio <= 1.0) {
        t += step;
        updateSystem(step);
        //
        // grow the step a little bit. but not more than a factor of
        // five
        //
        step *= Math.min(SAFETY * Math.pow(errRatio, PGROW), 5.0);
      } else if (nSteps > maxIterations) {
        System.out.println(" WARNING: # of iterations exceeds " + maxIterations);
        t += step;
        updateSystem(step);
      } else if (step < minStep) {
        System.out.println(" WARNING: Minimum integrateion step size (" + minStep + ") reached");
        t += step;
        updateSystem(step);
      } else {
        // step size too large.
        // Need to reset the values of all the substances
        //
        for (int i = 0; i < numberOfSubstances; i++) s[i].setValue(y1[i]);
        //
        // reset the Timer back to where it started.
        //
        timer.step(0 - step);

        //
        // shrink the step size
        // and recompute. But shrink by a factor smaller than 10.
        //
        step *= Math.max(SAFETY * Math.pow(errRatio, PSHRINK), 0.1);
      }
      if (t >= samplingStep) break;
    }

    //
    // Store the data if the sampling step is reached.
    //
    timer.storeTimePoint();
    for (int i = 0; i < numberOfSubstances; i++) {
      s[i].storeValue();
      s[i].storeRate();
    }
  }
  //
  // rkckStep takes a Cash-Karp Runge-Kutta step
  // to estimate the error and the substance levels
  // after the attempted step.
  //
  private void rkckStep(double h) {
    double t = timer.getTime();

    // step 1
    for (int i = 0; i < numberOfSubstances; i++) {
      //
      // get the substance values before this step
      //
      y1[i] = s[i].getValue();
      //
      // k1 = h * f(t, y);
      //
      k1[i] = h * s[i].getRate();
    }

    // step 2
    //
    // k2 = h * f (t + a2 * h, y + b21 * k1)
    //
    timer.setTime(t + a2 * h);
    for (int i = 0; i < numberOfSubstances; i++) {

      s[i].setValue(y1[i] + k1[i] * b21);
      k2[i] = h * s[i].getRate();
    }

    // step 3
    //
    // k3 = h * f (t + a3 * h, y + b31 * k1 + b32 * k2)
    //
    timer.setTime(t + a3 * h);
    for (int i = 0; i < numberOfSubstances; i++) {
      s[i].setValue(y1[i] + b31 * k1[i] + b32 * k2[i]);
      k3[i] = h * s[i].getRate();
    }

    // step 4
    //
    // k4 = h * f (t + a4 * h, y + b41 * k1 + b42 * k2 + b43 * k3)
    //
    timer.setTime(t + a4 * h);
    for (int i = 0; i < numberOfSubstances; i++) {

      s[i].setValue(y1[i] + b41 * k1[i] + b42 * k2[i] + b43 * k3[i]);
      k4[i] = h * s[i].getRate();
    }

    // step 5
    // k5 = h * f (t + a5 * h, y + b51 * k1 + b52 * k2 + b53 * k3 + b54 *
    // k4)
    //
    timer.setTime(t + a5 * h);
    for (int i = 0; i < numberOfSubstances; i++) {
      s[i].setValue(y1[i] + b51 * k1[i] + b52 * k2[i] + b53 * k3[i] + b54 * k4[i]);
      k5[i] = h * s[i].getRate();
    }

    // step 6
    // k6 = h * f (t + a6 * h, y + b61 * k1 + b62 * k2 + b63 * k3 + b64 * k4
    // + k65 * k5)
    //
    timer.setTime(t + a5 * h);
    for (int i = 0; i < numberOfSubstances; i++) {
      s[i].setValue(y1[i] + b61 * k1[i] + b62 * k2[i] + b63 * k3[i] + b64 * k4[i] + b65 * k5[i]);
      k6[i] = h * s[i].getRate();
    }

    for (int i = 0; i < numberOfSubstances; i++) {
      y2[i] = y1[i] + c1 * k1[i] + c3 * k3[i] + c4 * k4[i] + c6 * k6[i]; // fifth
      // order
      // estimate

      //
      // error between 4th and 5th
      //
      // note that the errors are scaled with respect to estimated new
      // values
      // if the new values are smaller than 1e-8, scale to 1e-8. This
      // number is
      // used to avoid scaling with respect to a number that is too small.
      //
      yerr[i] =
          Math.abs(
              (dc1 * k1[i] + dc3 * k3[i] + dc4 * k4[i] + dc5 * k5[i] + dc6 * k6[i])
                  / Math.max(Math.abs(y2[i]), 1e-8));
    }
  }