public void computeIntegratorValues(int integrationMethod) {

		updateODE();

		double[] pos = startPosition.clone();

		double[][] integrationPoints = integrationPointsAll[integrationMethod];

		integrationPoints[0] = pos.clone();

		hitPointsX[integrationMethod] = -666.0;

		int i;
		boolean crossingFound = false;
		for (i = 1; i < 10000; i++) {
			double prevTime = (double) (i - 1) * timestepSize;

			switch (integrationMethod) {
			case 0:
				pos = new RungeKutta4().nextStep(pos, (double) (i - 1) * 0.01,
						0.01, ode);
				break;

			case 1:
				pos = new ExpliziterEuler().nextStep(pos, prevTime,
						timestepSize, ode);
				break;

			case 2:
				pos = new Heun().nextStep(pos, prevTime, timestepSize, ode);
				break;

			case 3:
				pos = new RungeKutta4().nextStep(pos, prevTime, timestepSize,
						ode);
				break;

			case 4:
				pos = new ImpliziterEuler().nextStep(pos, prevTime,
						timestepSize, ode);
				break;

			default:
				assert (false);
			}

			integrationPoints[i] = pos.clone();

			if (!crossingFound) {
				if (integrationPoints[i][1] <= 0.0) {
					crossingFound = true;

					double[] p1 = integrationPoints[i - 1];
					double[] p2 = integrationPoints[i];

					double deltay = (p1[1] - p2[1]);
					if (Math.abs(deltay) < 0.00001) {
						hitPointsX[integrationMethod] = p1[0];
					} else {
						hitPointsX[integrationMethod] = p1[0] + (p2[0] - p1[0])
								* (p1[1] / deltay);
					}
				}
			}
		}

		numberOfValidIntegrationPointsAll[integrationMethod] = i;
	}