Problem: I simulate polarised muons moving in the ~1.5 meter long beam pipe in 
         a uniform magnetic field. The field is parallel to the direction 
         of the muon beam.  The initial muon polarisation is perpendicular 
         to the beam (and thus also perpendicular to magnetic field). There 
         is very low density Argon inside the beam pipe.
	 The spin of the muons precess in the beam pipe (my code 
	 follows the description given in chapter 4.3.3 "Spin Tracking" in the
         Geant User's Guide for the Application Developers. I use G4ClassicalRK4
         for the calculation.  Everything is OK at low magnetic field.
         However, when the magnetic field is high with respect to the initial
         muon momentum, the magnitude of the muon polarisation deviates from 1.
         For example, when using muons with the momentum of 29 MeV/c and
         magnetic field of 0.3T, the magnitude of the muon polarisation at the
         end of the beam pipe is ~0.5 . Depending on the muon momentum, field
         intensity and the length of the beam pipe, the magnitude of the muon 
         polarisation can be smaller or larger than 1 (even very
         significantly!).

My investigation of the problem:
         I have found out that Geant uses just one single step to get from one
         end of the beam pipe to the other end (i.e. ~1.5 meter). When I set
         a small "Largest Acceptable Step", the problem goes away (at least
         for not too high magnetic field), and the magnitude of the muon
         polarisation is again 1, as it should be:
            G4TransportationManager* tmanager = G4TransportationManager::GetTransportationManager();
            tmanager->GetPropagatorInField()->SetLargestAcceptableStep(20*mm);
         However, this does not seem to be the most efficient solution of the
         problem, because the small "Largest Acceptable Step" slows down the
         execution time.

A possible solution of the problem?
         I believe it would be better to adjust the step length dynamically,
         as it is done in the G4ChordFinder.cc:FindNextChord(...) for the case
         of the large error on the end point in the following piece of code:

     if( ! validEndPoint ) {
        if( stepTrial<=0.0 )
	  stepTrial = stepForChord; 
        else if (stepForChord <= stepTrial) 
	  // Reduce by a fraction, possibly up to 20% 
	  stepTrial = std::min( stepForChord, 
	             		fFractionLast * stepTrial); 
        else
          stepTrial *= 0.1;

        // if(dbg) G4cerr<<"Dchord too big. Try new hstep="<<stepTrial<<G4endl;
     }


         Perhaps one could check the magnitude of the Spin stored in
         yCurrent inside G4ChordFinder.cc:FindNextChord(...).  If it deviates
         more than some epsilon from 1, the current step (stepTrial) 
         would be reduced.  This check would be done only for the particles 
         with a non-zero spin.

         Perhaps there is better way how to correct this problem.

         Cheers,
         Kamil