/afs/cern.ch/work/a/aaltunda/public/www/CMSSW_5_3_13_patch3/src/TrackPropagation/RungeKutta/src/RK4PreciseStep.cc

Go to the documentation of this file.

#include "RK4PreciseStep.h"
#include "RK4OneStep.h"
//#include "Utilities/UI/interface/SimpleConfigurable.h"
#include <iostream>

CartesianState
RK4PreciseStep::operator()( const CartesianState& start, const RKCartesianDerivative& deriv,
                            double step, double eps) const
{
    const double Safety = 0.9;
    double remainigStep = step;
    double stepSize = step;
    CartesianState currentStart = start;
    int nsteps = 0;
    std::pair<CartesianState, double> tryStep;

    do {
        tryStep = stepWithAccuracy( currentStart, deriv, stepSize);
        nsteps++;
        if (tryStep.second <eps) {
            if (remainigStep - stepSize < eps/2) {
                if (verbose()) std::cout << "Accuracy reached, and full step taken in " 
                                    << nsteps << " steps" << std::endl;
                return tryStep.first; // we are there
            }
            else {
                remainigStep -= stepSize;
                // increase step size
                double factor =  std::min( Safety * pow( fabs(eps/tryStep.second),0.2), 4.);
                stepSize = std::min( stepSize*factor, remainigStep);
                currentStart = tryStep.first;
                if (verbose()) std::cout << "Accuracy reached, but " << remainigStep 
                     << " remain after " << nsteps << " steps. Step size increased by " 
                     << factor << " to " << stepSize << std::endl;
            }
        }
        else {
            // decrease step size
            double factor =  std::max( Safety * pow( fabs(eps/tryStep.second),0.25), 0.1);
            stepSize *= factor;
            if (verbose()) std::cout << "Accuracy not yet reached: delta = " << tryStep.second
                 << ", step reduced by " << factor << " to " << stepSize 
                 << ", (R,z)= " << currentStart.position().perp() 
                 << ", " << currentStart.position().z() << std::endl;
        }
    } while (remainigStep > eps/2);

    return tryStep.first;
}

std::pair<CartesianState, double>
RK4PreciseStep::stepWithAccuracy( const CartesianState& start, const RKCartesianDerivative& deriv,
                                  double step) const
{
    RK4OneStep solver;
    CartesianState one(solver(start, deriv, step));
    CartesianState firstHalf(solver(start, deriv, step/2));
    CartesianState secondHalf(solver(firstHalf, deriv, step/2));
    double diff = distance(one, secondHalf);
    return std::pair<CartesianState, double>(secondHalf,diff);
}

double RK4PreciseStep::distance( const CartesianState& a, const CartesianState& b) const
{
    return (a.position() - b.position()).mag() + (a.momentum() - b.momentum()).mag() / b.momentum().mag();
}

bool RK4PreciseStep::verbose() const
{
  // static bool verb = SimpleConfigurable<bool>(false,"RK4PreciseStep:verbose").value();

  static bool verb = true;
  return verb;
}