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)); } }