//
// ********************************************************************
// * License and Disclaimer                                           *
// *                                                                  *
// * The  Geant4 software  is  copyright of the Copyright Holders  of *
// * the Geant4 Collaboration.  It is provided  under  the terms  and *
// * conditions of the Geant4 Software License,  included in the file *
// * LICENSE and available at  http://cern.ch/geant4/license .  These *
// * include a list of copyright holders.                             *
// *                                                                  *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work  make  any representation or  warranty, express or implied, *
// * regarding  this  software system or assume any liability for its *
// * use.  Please see the license in the file  LICENSE  and URL above *
// * for the full disclaimer and the limitation of liability.         *
// *                                                                  *
// * This  code  implementation is the result of  the  scientific and *
// * technical work of the GEANT4 collaboration.                      *
// * By using,  copying,  modifying or  distributing the software (or *
// * any work based  on the software)  you  agree  to acknowledge its *
// * use  in  resulting  scientific  publications,  and indicate your *
// * acceptance of all terms of the Geant4 Software license.          *
// ********************************************************************
//

#include "globals.hh"
#include "G4PhysicalConstants.hh"
#include "G4SystemOfUnits.hh"
#include "G4Proton.hh"
#include "G4Neutron.hh"
#include "G4LorentzRotation.hh"
#include "G4BinaryCascade.hh"
#include "G4KineticTrackVector.hh"
#include "G4DecayKineticTracks.hh"
#include "G4ReactionProductVector.hh"
#include "G4Track.hh"
#include "G4V3DNucleus.hh"
#include "G4Fancy3DNucleus.hh"
#include "G4Scatterer.hh"
#include "G4MesonAbsorption.hh"
#include "G4ping.hh"
#include "G4Delete.hh"

#include "G4CollisionManager.hh"
#include "G4Absorber.hh"

#include "G4CollisionInitialState.hh"
#include "G4ListOfCollisions.hh"
#include "G4Fragment.hh"
#include "G4RKPropagation.hh"

#include "G4NuclearShellModelDensity.hh"
#include "G4NuclearFermiDensity.hh"
#include "G4FermiMomentum.hh"

#include "G4PreCompoundModel.hh"
#include "G4ExcitationHandler.hh"
#include "G4HadronicInteractionRegistry.hh"

#include "G4FermiPhaseSpaceDecay.hh"

#include "G4PreCompoundModel.hh"

#include <algorithm>
#include "G4ShortLivedConstructor.hh"
#include <typeinfo>

//   turn on general debugging info, and consistency checks

//#define debug_G4BinaryCascade 1

//  more detailed debugging -- deprecated
//#define debug_H1_BinaryCascade 1

//  specific debugging info per method or functionality
//#define debug_BIC_ApplyCollision 1
//#define debug_BIC_CheckPauli 1
//#define debug_BIC_CorrectFinalPandE 1
//#define debug_BIC_Propagate 1
//#define debug_BIC_Propagate_Excitation 1
//#define debug_BIC_Propagate_Collisions 1
//#define debug_BIC_Propagate_finals 1
//#define debug_BIC_DoTimeStep 1
//#define debug_BIC_CorrectBarionsOnBoundary 1
//#define debug_BIC_GetExcitationEnergy 1
//#define debug_BIC_DeexcitationProducts 1
//#define debug_BIC_FinalNucleusMomentum 1
//#define debug_BIC_Final4Momentum 1
//#define debug_BIC_FillVoidnucleus 1
//#define debug_BIC_FindFragments 1
//#define debug_BIC_BuildTargetList 1
//#define debug_BIC_FindCollision 1
//#define debug_BIC_return 1

//-------
//#if defined(debug_G4BinaryCascade)
#if 0
  #define _CheckChargeAndBaryonNumber_(val) CheckChargeAndBaryonNumber(val)
  //#define debugCheckChargeAndBaryonNumberverbose 1
#else
  #define _CheckChargeAndBaryonNumber_(val)
#endif
//#if defined(debug_G4BinaryCascade)
#if 0
  #define _DebugEpConservation(val)  DebugEpConservation(val)
  //#define debugCheckChargeAndBaryonNumberverbose 1
#else
  #define _DebugEpConservation(val)
#endif

#ifdef G4MULTITHREADED
   G4Mutex G4BinaryCascade::BICMutex = G4MUTEX_INITIALIZER;
#endif
   G4int G4BinaryCascade::theBIC_ID = -1;

//
//  C O N S T R U C T O R S   A N D   D E S T R U C T O R S
//
G4BinaryCascade::G4BinaryCascade(G4VPreCompoundModel* ptr) :
G4VIntraNuclearTransportModel("Binary Cascade", ptr)
{
    // initialise the resonance sector
    G4ShortLivedConstructor ShortLived;
    ShortLived.ConstructParticle();

    theCollisionMgr = new G4CollisionManager;
    theDecay=new G4BCDecay;
    theImR.push_back(theDecay);
    theLateParticle= new G4BCLateParticle;
    G4MesonAbsorption * aAb=new G4MesonAbsorption;
    theImR.push_back(aAb);
    G4Scatterer * aSc=new G4Scatterer;
    theH1Scatterer = new G4Scatterer;
    theImR.push_back(aSc);

    thePropagator = new G4RKPropagation;
    theCurrentTime = 0.;
    theBCminP = 45*MeV;
    theCutOnP = 90*MeV;
    theCutOnPAbsorb= 0*MeV;   // No Absorption of slow Mesons, other than above G4MesonAbsorption

    // reuse existing pre-compound model
    if(!ptr) {
      G4HadronicInteraction* p =
	G4HadronicInteractionRegistry::Instance()->FindModel("PRECO");
      G4VPreCompoundModel* pre = static_cast<G4VPreCompoundModel*>(p);
      if(!pre) { pre = new G4PreCompoundModel(); }
      SetDeExcitation(pre);
    }
    theExcitationHandler = GetDeExcitation()->GetExcitationHandler();
    SetMinEnergy(0.0*GeV);
    SetMaxEnergy(10.1*GeV);
    //PrintWelcomeMessage();
    thePrimaryEscape = true;
    thePrimaryType = 0;

    SetEnergyMomentumCheckLevels(1.0*perCent, 1.0*MeV);

    // init data members
    currentA=currentZ=0;
    lateA=lateZ=0;
    initialA=initialZ=0;
    projectileA=projectileZ=0;
    currentInitialEnergy=initial_nuclear_mass=0.;
    massInNucleus=0.;
    theOuterRadius=0.;
    if ( theBIC_ID == -1 ) {
#ifdef G4MULTITHREADED
       G4MUTEXLOCK(&G4BinaryCascade::BICMutex);
       if ( theBIC_ID == -1 ) {
#endif
    	   theBIC_ID = G4PhysicsModelCatalog::Register("Binary Cascade");
#ifdef G4MULTITHREADED
       }
       G4MUTEXUNLOCK(&G4BinaryCascade::BICMutex);
#endif
    }

}

G4BinaryCascade::~G4BinaryCascade()
{
    ClearAndDestroy(&theTargetList);
    ClearAndDestroy(&theSecondaryList);
    ClearAndDestroy(&theCapturedList);
    delete thePropagator;
    delete theCollisionMgr;
    for(auto & ptr : theImR) { delete ptr; }
    theImR.clear();
    delete theLateParticle;
    delete theH1Scatterer;
}

void G4BinaryCascade::ModelDescription(std::ostream& outFile) const
{
    outFile << "G4BinaryCascade is an intra-nuclear cascade model in which\n"
            << "an incident hadron collides with a nucleon, forming two\n"
            << "final-state particles, one or both of which may be resonances.\n"
            << "The resonances then decay hadronically and the decay products\n"
            << "are then propagated through the nuclear potential along curved\n"
            << "trajectories until they re-interact or leave the nucleus.\n"
            << "This model is valid for incident pions up to 1.5 GeV and\n"
            << "nucleons up to 10 GeV.\n"
            << "The remaining excited nucleus is handed on to ";
            if (theDeExcitation)                // pre-compound
            {
              outFile << theDeExcitation->GetModelName() << " : \n ";
              theDeExcitation->DeExciteModelDescription(outFile);
            }
            else if (theExcitationHandler)    // de-excitation
            {
               outFile << "G4ExcitationHandler";    //theExcitationHandler->GetModelName();
               theExcitationHandler->ModelDescription(outFile);
            }
            else
            {
               outFile << "void.\n";
            }
    outFile<< " \n";
}
void G4BinaryCascade::PropagateModelDescription(std::ostream& outFile) const
{
    outFile << "G4BinaryCascade propagtes secondaries produced by a high\n"
            << "energy model through the wounded nucleus.\n"
            << "Secondaries are followed after the formation time and if\n"
            << "within the nucleus are propagated through the nuclear\n"
            << "potential along curved trajectories until they interact\n"
            << "with a nucleon, decay, or leave the nucleus.\n"
            << "An interaction of a secondary with a nucleon produces two\n"
            << "final-state particles, one or both of which may be resonances.\n"
            << "Resonances decay hadronically and the decay products\n"
            << "are in turn propagated through the nuclear potential along curved\n"
            << "trajectories until they re-interact or leave the nucleus.\n"
            << "This model is valid for pions up to 1.5 GeV and\n"
            << "nucleons up to about 3.5 GeV.\n"
            << "The remaining excited nucleus is handed on to ";
    if (theDeExcitation)                // pre-compound
    {
      outFile << theDeExcitation->GetModelName() << " : \n ";
      theDeExcitation->DeExciteModelDescription(outFile);
    }
    else if (theExcitationHandler)    // de-excitation
    {
       outFile << "G4ExcitationHandler";    //theExcitationHandler->GetModelName();
       theExcitationHandler->ModelDescription(outFile);
    }
    else
    {
       outFile << "void.\n";
    }
outFile<< " \n";
}

//----------------------------------------------------------------------------

//
//      I M P L E M E N T A T I O N
//


//----------------------------------------------------------------------------
G4HadFinalState * G4BinaryCascade::ApplyYourself(const G4HadProjectile & aTrack,
        G4Nucleus & aNucleus)
//----------------------------------------------------------------------------
{
    if(std::getenv("BCDEBUG") ) G4cerr << " ######### Binary Cascade Reaction starts ######### "<< G4endl;

    G4LorentzVector initial4Momentum = aTrack.Get4Momentum();
    const G4ParticleDefinition * definition = aTrack.GetDefinition();

    if(initial4Momentum.e()-initial4Momentum.m()<theBCminP &&
            ( definition==G4Neutron::NeutronDefinition() || definition==G4Proton::ProtonDefinition() ) )
    {
        return theDeExcitation->ApplyYourself(aTrack, aNucleus);
    }

    theParticleChange.Clear();
    // initialize the G4V3DNucleus from G4Nucleus
    the3DNucleus = new G4Fancy3DNucleus;

    // Build a KineticTrackVector with the G4Track
    G4KineticTrackVector * secondaries;// = new G4KineticTrackVector;
    G4ThreeVector initialPosition(0., 0., 0.); // will be set later

    if(!std::getenv("I_Am_G4BinaryCascade_Developer") )
    {
        if(definition!=G4Neutron::NeutronDefinition() &&
                definition!=G4Proton::ProtonDefinition() &&
                definition!=G4PionPlus::PionPlusDefinition() &&
                definition!=G4PionMinus::PionMinusDefinition() )
        {
            G4cerr << "You are trying to use G4BinaryCascade with " <<definition->GetParticleName()<<" as projectile."<<G4endl;
            G4cerr << "G4BinaryCascade should not be used for projectiles other than nucleons or pions."<<G4endl;
            G4cerr << "If you want to continue, please switch on the developer environment: "<<G4endl;
            G4cerr << "setenv I_Am_G4BinaryCascade_Developer 1 "<<G4endl<<G4endl;
            throw G4HadronicException(__FILE__, __LINE__, "G4BinaryCascade - used for unvalid particle type - Fatal");
        }
    }

    // keep primary
    thePrimaryType = definition;
    thePrimaryEscape = false;

    G4double timePrimary=aTrack.GetGlobalTime();

    // try until an interaction will happen
    G4ReactionProductVector * products=0;
    G4int interactionCounter = 0,collisionLoopMaxCount;
    do
    {
        // reset status that could be changed in previous loop event
        theCollisionMgr->ClearAndDestroy();

        if(products != 0)
        {  // free memory from previous loop event
            ClearAndDestroy(products);
            delete products;
            products=0;
        }

        G4int massNumber=aNucleus.GetA_asInt();
        the3DNucleus->Init(massNumber, aNucleus.GetZ_asInt());
        thePropagator->Init(the3DNucleus);
        G4KineticTrack * kt;
		  collisionLoopMaxCount = 200;
        do                  // sample impact parameter until collisions are found
        {
            theCurrentTime=0;
            G4double radius = the3DNucleus->GetOuterRadius()+3*fermi;
            initialPosition=GetSpherePoint(1.1*radius, initial4Momentum);  // get random position
            kt = new G4KineticTrack(definition, 0., initialPosition, initial4Momentum);
            kt->SetState(G4KineticTrack::outside);
            // secondaries has been cleared by Propagate() in the previous loop event
            secondaries= new G4KineticTrackVector;
            secondaries->push_back(kt);
            if(massNumber > 1) // 1H1 is special case
            {
                products = Propagate(secondaries, the3DNucleus);
            } else {
                products = Propagate1H1(secondaries,the3DNucleus);
            }
				    // until we FIND a collision ... or give up
        } while(! products && --collisionLoopMaxCount>0);   /* Loop checking, 31.08.2015, G.Folger */

        if(++interactionCounter>99) break;
		    // ...until we find an ALLOWED collision ... or give up
    } while(products && products->size() == 0);   /* Loop checking, 31.08.2015, G.Folger */

    if(products && products->size()>0)
    {
        //  G4cout << "BIC Applyyourself: number of products " << products->size() << G4endl;

        // Fill the G4ParticleChange * with products
        theParticleChange.SetStatusChange(stopAndKill);
        G4ReactionProductVector::iterator iter;

        for(iter = products->begin(); iter != products->end(); ++iter)
        {
        	G4DynamicParticle * aNewDP =
                    new G4DynamicParticle((*iter)->GetDefinition(),
                            (*iter)->GetTotalEnergy(),
                            (*iter)->GetMomentum());
        	G4HadSecondary aNew = G4HadSecondary(aNewDP);
            G4double time=(*iter)->GetFormationTime();
            if(time < 0.0) { time = 0.0; }
            aNew.SetTime(timePrimary + time);
            aNew.SetCreatorModelType((*iter)->GetCreatorModel());
            theParticleChange.AddSecondary(aNew);
        }

         //DebugFinalEpConservation(aTrack, products);


    } else {  // no interaction, return primary
        if(std::getenv("BCDEBUG") ) G4cerr << " ######### Binary Cascade Reaction void, return intial state ######### "<< G4endl;
        theParticleChange.SetStatusChange(isAlive);
        theParticleChange.SetEnergyChange(aTrack.GetKineticEnergy());
        theParticleChange.SetMomentumChange(aTrack.Get4Momentum().vect().unit());
    }

    if ( products ) 
	 {
	    ClearAndDestroy(products);
       delete products;
    }
	 
    delete the3DNucleus;
    the3DNucleus = NULL;

    if(std::getenv("BCDEBUG") ) G4cerr << " ######### Binary Cascade Reaction ends ######### "<< G4endl;

    return &theParticleChange;
}
//----------------------------------------------------------------------------
G4ReactionProductVector * G4BinaryCascade::Propagate(
        G4KineticTrackVector * secondaries, G4V3DNucleus * aNucleus)
//----------------------------------------------------------------------------
{
    G4ping debug("debug_G4BinaryCascade");
#ifdef debug_BIC_Propagate
    G4cout << "G4BinaryCascade Propagate starting -------------------------------------------------------" <<G4endl;
#endif

    the3DNucleus=aNucleus;
    G4ReactionProductVector * products = new G4ReactionProductVector;
    theOuterRadius = the3DNucleus->GetOuterRadius();
    theCurrentTime=0;
    theProjectile4Momentum=G4LorentzVector(0,0,0,0);
    theMomentumTransfer=G4ThreeVector(0,0,0);
    // build theSecondaryList, theProjectileList and theCapturedList
    ClearAndDestroy(&theCapturedList);
    ClearAndDestroy(&theSecondaryList);
    theSecondaryList.clear();
    ClearAndDestroy(&theFinalState);
    std::vector<G4KineticTrack *>::iterator iter;
    theCollisionMgr->ClearAndDestroy();

    theCutOnP=90*MeV;
    if(the3DNucleus->GetMass()>30) theCutOnP = 70*MeV;
    if(the3DNucleus->GetMass()>60) theCutOnP = 50*MeV;
    if(the3DNucleus->GetMass()>120) theCutOnP = 45*MeV;


    BuildTargetList();

#ifdef debug_BIC_GetExcitationEnergy
    G4cout << "ExcitationEnergy0 " << GetExcitationEnergy() << G4endl;
#endif

    thePropagator->Init(the3DNucleus);

    G4bool success = BuildLateParticleCollisions(secondaries);
    if (! success )   // fails if no excitation energy left....
    {
       products=HighEnergyModelFSProducts(products, secondaries);
       ClearAndDestroy(secondaries);
       delete secondaries;

#ifdef debug_G4BinaryCascade
       G4cout << "G4BinaryCascade::Propagate: warning - high energy model failed energy conservation, returning unchanged high energy final state" << G4endl;
#endif

       return products;
    }
    // check baryon and charge ...

    _CheckChargeAndBaryonNumber_("lateparticles");
    _DebugEpConservation(" be4 findcollisions");

    // if called stand alone find first collisions
    FindCollisions(&theSecondaryList);


    if(theCollisionMgr->Entries() == 0 )      //late particles ALWAYS create Entries
    {
        //G4cout << " no collsions -> return 0" << G4endl;
        delete products;
#ifdef debug_BIC_return
        G4cout << "return @ begin2,  no collisions "<< G4endl;
#endif
        return 0;
    }

    // end of initialization: do the job now
    // loop until there are no more collisions


    G4bool haveProducts = false;
    G4int collisionCount=0;
	 G4int collisionLoopMaxCount=1000000;
    while(theCollisionMgr->Entries() > 0 && currentZ && --collisionLoopMaxCount>0)  /* Loop checking, 31.08.2015, G.Folger */  
    {
      if(Absorb()) {  // absorb secondaries, pions only
            haveProducts = true;
      }
      if(Capture()) { // capture secondaries, nucleons only
            haveProducts = true;
        }

        // propagate to the next collision if any (collisions could have been deleted
        // by previous absorption or capture)
        if(theCollisionMgr->Entries() > 0)
        {
            G4CollisionInitialState *
            nextCollision = theCollisionMgr->GetNextCollision();
#ifdef debug_BIC_Propagate_Collisions
            G4cout << " NextCollision  * , Time, curtime = " << nextCollision << " "
                    <<nextCollision->GetCollisionTime()<< " " <<
                    theCurrentTime<< G4endl;
#endif
            if (!DoTimeStep(nextCollision->GetCollisionTime()-theCurrentTime) )
            {
                // Check if nextCollision is still valid, ie. particle did not leave nucleus
                if (theCollisionMgr->GetNextCollision() != nextCollision )
                {
                    nextCollision = 0;
                }
            }
           //_DebugEpConservation("Stepped");

            if( nextCollision )
            {
                if (ApplyCollision(nextCollision))
                {
                    //G4cerr << "ApplyCollision success " << G4endl;
                    haveProducts = true;
                    collisionCount++;
                    //_CheckChargeAndBaryonNumber_("ApplyCollision");
                    //_DebugEpConservation("ApplyCollision");

                } else {
                    //G4cerr << "ApplyCollision failure " << G4endl;
                    theCollisionMgr->RemoveCollision(nextCollision);
                }
            }
        }
    }

    //--------- end of on Collisions
    //G4cout << "currentZ @ end loop " << currentZ << G4endl;
    G4int nProtons(0);
    for(iter = theTargetList.begin(); iter != theTargetList.end(); ++iter)
    {
    	if ( (*iter)->GetDefinition() == G4Proton::Proton() ) ++nProtons;
    }
    if ( ! theTargetList.size() || ! nProtons ){
        // nucleus completely destroyed, fill in ReactionProductVector
       products = FillVoidNucleusProducts(products);
#ifdef debug_BIC_return
        G4cout << "return @ Z=0 after collision loop "<< G4endl;
        PrintKTVector(&theSecondaryList,std::string(" theSecondaryList"));
        G4cout << "theTargetList size: " << theTargetList.size() << G4endl;
        PrintKTVector(&theTargetList,std::string(" theTargetList"));
        PrintKTVector(&theCapturedList,std::string(" theCapturedList"));

        G4cout << " ExcitE be4 Correct : " <<GetExcitationEnergy() << G4endl;
        G4cout << " Mom Transfered to nucleus : " << theMomentumTransfer << " " << theMomentumTransfer.mag() << G4endl;
        PrintKTVector(&theFinalState,std::string(" FinalState uncorrected"));
        G4cout << "returned products: " << products->size() << G4endl;
        _CheckChargeAndBaryonNumber_("destroyed Nucleus");
        _DebugEpConservation("destroyed Nucleus");
#endif

        return products;
    }

    // No more collisions: absorb, capture and propagate the secondaries out of the nucleus
    if(Absorb()) {
        haveProducts = true;
        // G4cout << "Absorb sucess " << G4endl;
    }

    if(Capture()) {
        haveProducts = true;
        // G4cout << "Capture sucess " << G4endl;
    }

    if(!haveProducts)  // no collisions happened. Return an empty vector.
    {
#ifdef debug_BIC_return
        G4cout << "return 3, no products "<< G4endl;
#endif
        return products;
    }


#ifdef debug_BIC_Propagate
    G4cout << " Momentum transfer to Nucleus " << theMomentumTransfer << " " << theMomentumTransfer.mag() << G4endl;
    G4cout << "  Stepping particles out...... " << G4endl;
#endif

    StepParticlesOut();
    _DebugEpConservation("stepped out");


    if ( theSecondaryList.size() > 0 )
    {
#ifdef debug_G4BinaryCascade
        G4cerr << "G4BinaryCascade: Warning, have active particles at end" << G4endl;
        PrintKTVector(&theSecondaryList, "active particles @ end  added to theFinalState");
#endif
        //  add left secondaries to FinalSate
        for ( iter =theSecondaryList.begin(); iter != theSecondaryList.end(); ++iter)
        {
            theFinalState.push_back(*iter);
        }
        theSecondaryList.clear();

    }
    while ( theCollisionMgr->Entries() > 0 )                /* Loop checking, 31.08.2015, G.Folger */
    {
#ifdef debug_G4BinaryCascade
        G4cerr << " Warning: remove left over collision(s) " << G4endl;
#endif
        theCollisionMgr->RemoveCollision(theCollisionMgr->GetNextCollision());
    }

#ifdef debug_BIC_Propagate_Excitation

    PrintKTVector(&theSecondaryList,std::string(" theSecondaryList"));
    G4cout << "theTargetList size: " << theTargetList.size() << G4endl;
    //  PrintKTVector(&theTargetList,std::string(" theTargetList"));
    PrintKTVector(&theCapturedList,std::string(" theCapturedList"));

    G4cout << " ExcitE be4 Correct : " <<GetExcitationEnergy() << G4endl;
    G4cout << " Mom Transfered to nucleus : " << theMomentumTransfer << " " << theMomentumTransfer.mag() << G4endl;
    PrintKTVector(&theFinalState,std::string(" FinalState uncorrected"));
#endif

    //


    G4double ExcitationEnergy=GetExcitationEnergy();

#ifdef debug_BIC_Propagate_finals
    PrintKTVector(&theFinalState,std::string(" FinalState be4 corr"));
    G4cout << " Excitation Energy prefinal,  #collisions:, out, captured  "
            << ExcitationEnergy << " "
            << collisionCount << " "
            << theFinalState.size() << " "
            << theCapturedList.size()<<G4endl;
#endif

    if (ExcitationEnergy < 0 )
    {
        G4int maxtry=5, ntry=0;
        do {
            CorrectFinalPandE();
            ExcitationEnergy=GetExcitationEnergy();
        } while ( ++ntry < maxtry && ExcitationEnergy < 0 );       /* Loop checking, 31.08.2015, G.Folger */
    }
    _DebugEpConservation("corrected");

#ifdef debug_BIC_Propagate_finals
    PrintKTVector(&theFinalState,std::string(" FinalState corrected"));
    G4cout << " Excitation Energy final,  #collisions:, out, captured  "
            << ExcitationEnergy << " "
            << collisionCount << " "
            << theFinalState.size() << " "
            << theCapturedList.size()<<G4endl;
#endif


    if ( ExcitationEnergy < 0. )
    {
            #ifdef debug_G4BinaryCascade
              	  G4cerr << "G4BinaryCascade-Warning: negative excitation energy ";
              	  G4cerr <<ExcitationEnergy<<G4endl;
             	   PrintKTVector(&theFinalState,std::string("FinalState"));
             	   PrintKTVector(&theCapturedList,std::string("captured"));
             	  G4cout << "negative ExE:Final 4Momentum .mag: " << GetFinal4Momentum()
             	          << " "<< GetFinal4Momentum().mag()<< G4endl
             	          << "negative ExE:FinalNucleusMom  .mag: " << GetFinalNucleusMomentum()
             		  << " "<< GetFinalNucleusMomentum().mag()<< G4endl;
            #endif
            #ifdef debug_BIC_return
                    G4cout << "  negative Excitation E return empty products " << products << G4endl;
                    G4cout << "return 4, excit < 0 "<< G4endl;
            #endif

        ClearAndDestroy(products);
        return products;   // return empty products- FixMe
    }

    G4ReactionProductVector * precompoundProducts=DeExcite();


    G4DecayKineticTracks decay(&theFinalState);
    _DebugEpConservation("decayed");

    products= ProductsAddFinalState(products, theFinalState);

    products= ProductsAddPrecompound(products, precompoundProducts);

//    products=ProductsAddFakeGamma(products);


    thePrimaryEscape = true;

    #ifdef debug_BIC_return
    G4cout << "BIC: return @end, all ok "<< G4endl;
    //G4cout << "  return products " << products << G4endl;
    #endif

    return products;
}

//----------------------------------------------------------------------------
G4double G4BinaryCascade::GetExcitationEnergy()
//----------------------------------------------------------------------------
{

    // get A and Z for the residual nucleus
#if defined(debug_G4BinaryCascade) || defined(debug_BIC_GetExcitationEnergy)
    G4int finalA = theTargetList.size()+theCapturedList.size();
    G4int finalZ = GetTotalCharge(theTargetList)+GetTotalCharge(theCapturedList);
    if ( (currentA - finalA) != 0 || (currentZ - finalZ) != 0 )
    {
        G4cerr << "G4BIC:GetExcitationEnergy(): Nucleon counting error current/final{A,Z} "
                << "("<< currentA << "," << finalA << ") ("<< currentZ << "," << finalZ << ")" << G4endl;
    }

#endif

    G4double excitationE(0);
    G4double nucleusMass(0);
    if(currentZ>.5)
    {
        nucleusMass = GetIonMass(currentZ,currentA);
    }
    else if (currentZ==0 )     // Uzhi && currentA==1 )                     // Uzhi
    {                                                                       // Uzhi
        if(currentA == 1) {nucleusMass = G4Neutron::Neutron()->GetPDGMass();}// Uzhi
        else              {nucleusMass = GetFinalNucleusMomentum().mag()     // Uzhi
            - 3.*MeV*currentA;}                 // Uzhi
    }                                                                       // Uzhi
    else
    {
#ifdef debug_G4BinaryCascade
        G4cout << "G4BinaryCascade::GetExcitationEnergy(): Warning - invalid nucleus (A,Z)=("
                << currentA << "," << currentZ << ")" << G4endl;
#endif
        return 0;
    }

#ifdef debug_BIC_GetExcitationEnergy
    G4ping debug("debug_ExcitationEnergy");
    debug.push_back("====> current A, Z");
    debug.push_back(currentZ);
    debug.push_back(currentA);
    debug.push_back("====> final A, Z");
    debug.push_back(finalZ);
    debug.push_back(finalA);
    debug.push_back(nucleusMass);
    debug.push_back(GetFinalNucleusMomentum().mag());
    debug.dump();
    //  PrintKTVector(&theTargetList, std::string(" current target list info"));
    //PrintKTVector(&theCapturedList, std::string(" current captured list info"));
#endif

    excitationE = GetFinalNucleusMomentum().mag() - nucleusMass;

    //G4double exE2 = GetFinal4Momentum().mag() - nucleusMass;

    //G4cout << "old/new excitE " << excitationE << " / "<< exE2 << G4endl;

#ifdef debug_BIC_GetExcitationEnergy
    // ------ debug
    if ( excitationE < 0 )
    {
        G4cout << "negative ExE final Ion mass " <<nucleusMass<< G4endl;
        G4LorentzVector Nucl_mom=GetFinalNucleusMomentum();
        if(finalZ>.5) G4cout << " Final nuclmom/mass " << Nucl_mom << " " << Nucl_mom.mag()
		    		           << " (A,Z)=("<< finalA <<","<<finalZ <<")"
		    		           << " mass " << nucleusMass << " "
		    		           << " excitE " << excitationE << G4endl;


        G4int A = the3DNucleus->GetMassNumber();
        G4int Z = the3DNucleus->GetCharge();
        G4double initialExc(0);
        if(Z>.5)
        {
            initialExc = theInitial4Mom.mag()- GetIonMass(Z, A);
            G4cout << "GetExcitationEnergy: Initial nucleus A Z " << A << " " << Z << " " << initialExc << G4endl;
        }
    }

#endif

    return excitationE;
}


//----------------------------------------------------------------------------
//
//       P R I V A T E   M E M B E R   F U N C T I O N S
//
//----------------------------------------------------------------------------

//----------------------------------------------------------------------------
void G4BinaryCascade::BuildTargetList()
//----------------------------------------------------------------------------
{

    if(!the3DNucleus->StartLoop())
    {
        //    G4cerr << "G4BinaryCascade::BuildTargetList(): StartLoop() error!"
        //	   << G4endl;
        return;
    }

    ClearAndDestroy(&theTargetList);  // clear theTargetList before rebuilding

    G4Nucleon * nucleon;
    const G4ParticleDefinition * definition;
    G4ThreeVector pos;
    G4LorentzVector mom;
    // if there are nucleon hit by higher energy models, then SUM(momenta) != 0
    initialZ=the3DNucleus->GetCharge();
    initialA=the3DNucleus->GetMassNumber();
    initial_nuclear_mass=GetIonMass(initialZ,initialA);
    theInitial4Mom = G4LorentzVector(0,0,0,initial_nuclear_mass);
    currentA=0;
    currentZ=0;
    while((nucleon = the3DNucleus->GetNextNucleon()) != NULL)       /* Loop checking, 31.08.2015, G.Folger */
    {
        // check if nucleon is hit by higher energy model.
        if ( ! nucleon->AreYouHit() )
        {
            definition = nucleon->GetDefinition();
            pos = nucleon->GetPosition();
            mom = nucleon->GetMomentum();
            //    G4cout << "Nucleus " << pos.mag()/fermi << " " << mom.e() << G4endl;
            //theInitial4Mom += mom;
            //        the potential inside the nucleus is taken into account, and nucleons are on mass shell.
            mom.setE( std::sqrt( mom.vect().mag2() + sqr(definition->GetPDGMass()) ) );
            G4KineticTrack * kt = new G4KineticTrack(definition, 0., pos, mom);
            kt->SetState(G4KineticTrack::inside);
            kt->SetNucleon(nucleon);
            theTargetList.push_back(kt);
            ++currentA;
            if (definition->GetPDGCharge() > .5 ) ++currentZ;
        }

#ifdef debug_BIC_BuildTargetList
        else { G4cout << "nucleon is hit" << nucleon << G4endl;}
#endif
    }
    massInNucleus = 0;
    if(currentZ>.5)
    {
        massInNucleus = GetIonMass(currentZ,currentA);
    } else if (currentZ==0 && currentA>=1 )
    {
        massInNucleus = currentA * G4Neutron::Neutron()->GetPDGMass();
    } else
    {
        G4cerr << "G4BinaryCascade::BuildTargetList(): Fatal Error - invalid nucleus (A,Z)=("
                << currentA << "," << currentZ << ")" << G4endl;
        throw G4HadronicException(__FILE__, __LINE__, "G4BinaryCasacde::BuildTargetList()");
    }
    currentInitialEnergy=	theInitial4Mom.e() + theProjectile4Momentum.e();

#ifdef debug_BIC_BuildTargetList
    G4cout << "G4BinaryCascade::BuildTargetList():  nucleus (A,Z)=("
            << currentA << "," << currentZ << ") mass: " << massInNucleus <<
            ", theInitial4Mom " << theInitial4Mom <<
            ", currentInitialEnergy " << currentInitialEnergy << G4endl;
#endif

}

//----------------------------------------------------------------------------
G4bool  G4BinaryCascade::BuildLateParticleCollisions(G4KineticTrackVector * secondaries)
//----------------------------------------------------------------------------
{
   G4bool success(false);
   std::vector<G4KineticTrack *>::iterator iter;

   lateA=lateZ=0;
   projectileA=projectileZ=0;

   G4double StartingTime=DBL_MAX;        // Search for minimal formation time
   for(iter = secondaries->begin(); iter != secondaries->end(); ++iter)
   {
      if((*iter)->GetFormationTime() < StartingTime)
         StartingTime = (*iter)->GetFormationTime();
   }

   //PrintKTVector(secondaries, "initial late particles ");
   G4LorentzVector lateParticles4Momentum(0,0,0,0);
   for(iter = secondaries->begin(); iter != secondaries->end(); ++iter)
   {
      //  G4cout << " Formation time : " << (*iter)->GetDefinition()->GetParticleName() << " "
      //   << (*iter)->GetFormationTime() << G4endl;
      G4double FormTime = (*iter)->GetFormationTime() - StartingTime;
      (*iter)->SetFormationTime(FormTime);
      if( (*iter)->GetState() == G4KineticTrack::undefined  )   // particles from high energy generator
      {
         FindLateParticleCollision(*iter);
         lateParticles4Momentum += (*iter)->GetTrackingMomentum();
         lateA += (*iter)->GetDefinition()->GetBaryonNumber();
         lateZ += G4lrint((*iter)->GetDefinition()->GetPDGCharge()/eplus);
         //PrintKTVector(*iter, "late particle ");
      } else
      {
         theSecondaryList.push_back(*iter);
         //PrintKTVector(*iter, "incoming particle ");
         theProjectile4Momentum += (*iter)->GetTrackingMomentum();
         projectileA += (*iter)->GetDefinition()->GetBaryonNumber();
         projectileZ += G4lrint((*iter)->GetDefinition()->GetPDGCharge()/eplus);
#ifdef debug_BIC_Propagate
         G4cout << " Adding initial secondary " << *iter
               << " time" << (*iter)->GetFormationTime()
               << ", state " << (*iter)->GetState() << G4endl;
#endif
      }
   }
   //theCollisionMgr->Print();
   const G4HadProjectile * primary = GetPrimaryProjectile();  // check for primary from TheoHE model

   if (primary){
      G4LorentzVector mom=primary->Get4Momentum();
      theProjectile4Momentum += mom;
      projectileA = primary->GetDefinition()->GetBaryonNumber();
      projectileZ = G4lrint(primary->GetDefinition()->GetPDGCharge()/eplus);
      // now check if "excitation" energy left by TheoHE model
      G4double excitation= theProjectile4Momentum.e() + initial_nuclear_mass - lateParticles4Momentum.e() - massInNucleus;
#ifdef debug_BIC_GetExcitationEnergy
      G4cout << "BIC: Proj.e, nucl initial, nucl final, lateParticles"
            << theProjectile4Momentum << ",  "
            << initial_nuclear_mass<< ",  " << massInNucleus << ",  "
            << lateParticles4Momentum << G4endl;
      G4cout << "BIC: Proj.e / initial excitation: " << theProjectile4Momentum.e() << " / " << excitation << G4endl;
#endif
      success = excitation > 0;
#ifdef debug_G4BinaryCascade
      if ( ! success ) {
         G4cout << "G4BinaryCascade::BuildLateParticleCollisions(): Proj.e / initial excitation: " << theProjectile4Momentum.e() << " / " << excitation << G4endl;
         //PrintKTVector(secondaries);
      }
#endif
   } else {
      // no primary from HE model -> cascade
      success=true;
   }

   if (success) {
      secondaries->clear(); // Don't leave "G4KineticTrack *"s in two vectors
      delete secondaries;
   }
   return success;
}

//----------------------------------------------------------------------------
G4ReactionProductVector *  G4BinaryCascade::DeExcite()
//----------------------------------------------------------------------------
{
   // find a fragment and call the precompound model.
   G4Fragment * fragment = 0;
   G4ReactionProductVector * precompoundProducts = 0;

   G4LorentzVector pFragment(0);
   // G4cout << " final4mon " << GetFinal4Momentum() /MeV << G4endl;

   //   if ( ExcitationEnergy >= 0 )                                         // closed by Uzhi
   //   {                                                                    // closed by Uzhi
   fragment = FindFragments();


   if(fragment)                                                            // Uzhi
   {                                                                       // Uzhi
      if(fragment->GetA_asInt() >1)                                          // Uzhi
      {
         pFragment=fragment->GetMomentum();
         // G4cout << " going to preco with fragment 4 mom " << pFragment << G4endl;
         if (theDeExcitation)                // pre-compound
         {
            precompoundProducts= theDeExcitation->DeExcite(*fragment);
         }
         else if (theExcitationHandler)    // de-excitation
         {
            precompoundProducts=theExcitationHandler->BreakItUp(*fragment);
         }

      } else
      {                                   // fragment->GetA_asInt() <= 1, so a single proton, as a fragment must have Z>0
         if (theTargetList.size() + theCapturedList.size() > 1 ) {
            throw G4HadronicException(__FILE__, __LINE__, "G4BinaryCasacde:: Invalid Fragment");
         }

         std::vector<G4KineticTrack *>::iterator i;
         if ( theTargetList.size() == 1 )  {i=theTargetList.begin();}
         if ( theCapturedList.size() == 1 ) {i=theCapturedList.begin();}                             // Uzhi
         G4ReactionProduct * aNew = new G4ReactionProduct((*i)->GetDefinition());
         aNew->SetTotalEnergy((*i)->GetDefinition()->GetPDGMass());
         aNew->SetCreatorModel(theBIC_ID);
         aNew->SetMomentum(G4ThreeVector(0));// see boost for preCompoundProducts below..
         precompoundProducts = new G4ReactionProductVector();
         precompoundProducts->push_back(aNew);
      }                            // End of fragment->GetA() < 1.5
      delete fragment;
      fragment=0;

   } else                            // End of if(fragment)
   {                                 // No fragment, can be neutrons only  // Uzhi

      precompoundProducts = DecayVoidNucleus();
   }
   #ifdef debug_BIC_DeexcitationProducts

       G4LorentzVector fragment_momentum=GetFinalNucleusMomentum();
       G4LorentzVector Preco_momentum;
       if ( precompoundProducts )
       {
          std::vector<G4ReactionProduct *>::iterator j;
          for(j = precompoundProducts->begin(); j != precompoundProducts->end(); ++j)
          {
             G4LorentzVector pProduct((*j)->GetMomentum(),(*j)->GetTotalEnergy());
             Preco_momentum += pProduct;
           }
       }
       G4cout << "finalNuclMom / sum preco products" << fragment_momentum << "  / " << Preco_momentum
    		   << " delta E "<< fragment_momentum.e() - Preco_momentum.e() <<  G4endl;

   #endif

   return precompoundProducts;
}

//----------------------------------------------------------------------------
G4ReactionProductVector *  G4BinaryCascade::DecayVoidNucleus()
//----------------------------------------------------------------------------
{
   G4ReactionProductVector * result=0;
   if ( (theTargetList.size()+theCapturedList.size()) > 0 )
   {
      result = new G4ReactionProductVector;
      std::vector<G4KineticTrack *>::iterator aNuc;
      G4LorentzVector aVec;
      std::vector<G4double> masses;
      G4double sumMass(0);

      if ( theTargetList.size() != 0)                                      // Uzhi
            {
         for ( aNuc=theTargetList.begin(); aNuc != theTargetList.end(); aNuc++)
         {
            G4double mass=(*aNuc)->GetDefinition()->GetPDGMass();
            masses.push_back(mass);
            sumMass += mass;
         }
            }                                                                    // Uzhi

      if ( theCapturedList.size() != 0)                                    // Uzhi
      {                                                                    // Uzhi
         for(aNuc = theCapturedList.begin();                               // Uzhi
               aNuc != theCapturedList.end(); aNuc++)                        // Uzhi
         {                                                                 // Uzhi
            G4double mass=(*aNuc)->GetDefinition()->GetPDGMass();          // Uzhi
            masses.push_back(mass);                                        // Uzhi
            sumMass += mass;                                               // Uzhi
         }
      }

      G4LorentzVector finalP=GetFinal4Momentum();
      G4FermiPhaseSpaceDecay decay;
      // G4cout << " some neutrons? " << masses.size() <<" " ;
      // G4cout<< theTargetList.size()<<" "<<finalP <<" " << finalP.mag()<<G4endl;

      G4double eCMS=finalP.mag();
      if ( eCMS < sumMass )                    // @@GF --- Cheat!!
      {
         eCMS=sumMass + 2*MeV*masses.size();
         finalP.setE(std::sqrt(finalP.vect().mag2() + sqr(eCMS)));
      }

      precompoundLorentzboost.set(finalP.boostVector());
      std::vector<G4LorentzVector*> * momenta=decay.Decay(eCMS,masses);
      std::vector<G4LorentzVector*>::iterator aMom=momenta->begin();


      if ( theTargetList.size() != 0)
      {
         for ( aNuc=theTargetList.begin();
               (aNuc != theTargetList.end()) && (aMom!=momenta->end());
               aNuc++, aMom++ )
         {
            G4ReactionProduct * aNew = new G4ReactionProduct((*aNuc)->GetDefinition());
            aNew->SetTotalEnergy((*aMom)->e());
            aNew->SetMomentum((*aMom)->vect());
            aNew->SetCreatorModel(theBIC_ID);
            result->push_back(aNew);

            delete *aMom;
         }
      }

      if ( theCapturedList.size() != 0)                                    // Uzhi
            {                                                                    // Uzhi
         for ( aNuc=theCapturedList.begin();                                // Uzhi
               (aNuc != theCapturedList.end()) && (aMom!=momenta->end());    // Uzhi
               aNuc++, aMom++ )                                             // Uzhi
         {                                                                  // Uzhi
            G4ReactionProduct * aNew = new G4ReactionProduct(               // Uzhi
                  (*aNuc)->GetDefinition());            // Uzhi
            aNew->SetTotalEnergy((*aMom)->e());                             // Uzhi
            aNew->SetMomentum((*aMom)->vect());                             // Uzhi
            aNew->SetCreatorModel(theBIC_ID);
            result->push_back(aNew);                           // Uzhi
            delete *aMom;                                                   // Uzhi
         }                                                                  // Uzhi
            }                                                                    // Uzhi

      delete momenta;
   }
   return result;
}                   // End if(!fragment)

//----------------------------------------------------------------------------
G4ReactionProductVector * G4BinaryCascade::ProductsAddFinalState(G4ReactionProductVector * products, G4KineticTrackVector & fs)
//----------------------------------------------------------------------------
{
// fill in products the outgoing particles
    size_t i(0);
#ifdef debug_BIC_Propagate_finals
    G4LorentzVector mom_fs;
#endif
    for(i = 0; i< fs.size(); i++)
    {
        G4KineticTrack * kt = fs[i];
        G4ReactionProduct * aNew = new G4ReactionProduct(kt->GetDefinition());
        aNew->SetMomentum(kt->Get4Momentum().vect());
        aNew->SetTotalEnergy(kt->Get4Momentum().e());
        aNew->SetNewlyAdded(kt->IsParticipant());
        aNew->SetCreatorModel(theBIC_ID);
        products->push_back(aNew);

#ifdef debug_BIC_Propagate_finals
        mom_fs += kt->Get4Momentum();
        G4cout <<kt->GetDefinition()->GetParticleName();
        G4cout << " Particle Ekin " << aNew->GetKineticEnergy();
        G4cout << ", is " << (kt->GetDefinition()->GetPDGStable() ? "stable" :
                (kt->GetDefinition()->IsShortLived() ? "short lived " : "non stable"))  ;
        G4cout << G4endl;
#endif

    }
#ifdef debug_BIC_Propagate_finals
    G4cout << " Final state momentum " << mom_fs << G4endl;
#endif

    return products;
}
//----------------------------------------------------------------------------
G4ReactionProductVector * G4BinaryCascade::ProductsAddPrecompound(G4ReactionProductVector * products, G4ReactionProductVector * precompoundProducts)
//----------------------------------------------------------------------------
{
   G4LorentzVector pSumPreco(0), pPreco(0);

   if ( precompoundProducts )
   {
      std::vector<G4ReactionProduct *>::iterator j;
      for(j = precompoundProducts->begin(); j != precompoundProducts->end(); ++j)
      {
         // boost back to system of moving nucleus
         G4LorentzVector pProduct((*j)->GetMomentum(),(*j)->GetTotalEnergy());
         pPreco+= pProduct;
#ifdef debug_BIC_Propagate_finals
         G4cout << "BIC: pProduct be4 boost " <<pProduct << G4endl;
#endif
         pProduct *= precompoundLorentzboost;
#ifdef debug_BIC_Propagate_finals
         G4cout << "BIC: pProduct aft boost " <<pProduct << G4endl;
#endif
         pSumPreco += pProduct;
         (*j)->SetTotalEnergy(pProduct.e());
         (*j)->SetMomentum(pProduct.vect());
         (*j)->SetNewlyAdded(true);
         products->push_back(*j);
      }
      // G4cout << " unboosted preco result mom " << pPreco / MeV << "  ..- fragmentMom " << (pPreco - pFragment)/MeV<< G4endl;
      // G4cout << " preco result mom " << pSumPreco / MeV << "  ..-file4Mom " << (pSumPreco - GetFinal4Momentum())/MeV<< G4endl;
      precompoundProducts->clear();
      delete precompoundProducts;
   }
   return products;
}
//----------------------------------------------------------------------------
void  G4BinaryCascade::FindCollisions(G4KineticTrackVector * secondaries)
//----------------------------------------------------------------------------
{
    for(std::vector<G4KineticTrack *>::iterator i = secondaries->begin();
            i != secondaries->end(); ++i)
    {
        for(std::vector<G4BCAction *>::iterator j = theImR.begin();
                j!=theImR.end(); j++)
        {
            //      G4cout << "G4BinaryCascade::FindCollisions: at action " << *j << G4endl;
            const std::vector<G4CollisionInitialState *> & aCandList
            = (*j)->GetCollisions(*i, theTargetList, theCurrentTime);
            for(size_t count=0; count<aCandList.size(); count++)
            {
                theCollisionMgr->AddCollision(aCandList[count]);
                //4cout << "====================== New Collision ================="<<G4endl;
                //theCollisionMgr->Print();
            }
        }
    }
}


//----------------------------------------------------------------------------
void  G4BinaryCascade::FindDecayCollision(G4KineticTrack * secondary)
//----------------------------------------------------------------------------
{
    const std::vector<G4CollisionInitialState *> & aCandList
    = theDecay->GetCollisions(secondary, theTargetList, theCurrentTime);
    for(size_t count=0; count<aCandList.size(); count++)
    {
        theCollisionMgr->AddCollision(aCandList[count]);
    }
}

//----------------------------------------------------------------------------
void  G4BinaryCascade::FindLateParticleCollision(G4KineticTrack * secondary)
//----------------------------------------------------------------------------
{

    G4double tin=0., tout=0.;
    if (((G4RKPropagation*)thePropagator)->GetSphereIntersectionTimes(secondary,tin,tout))
    {
        if ( tin > 0 )
        {
            secondary->SetState(G4KineticTrack::outside);
        } else if ( tout > 0 )
        {
            secondary->SetState(G4KineticTrack::inside);
        } else {
            //G4cout << "G4BC set miss , tin, tout " << tin << " , " << tout <<G4endl;
            secondary->SetState(G4KineticTrack::miss_nucleus);
        }
    } else {
        secondary->SetState(G4KineticTrack::miss_nucleus);
        //G4cout << "G4BC set miss ,no intersect tin, tout " << tin << " , " << tout <<G4endl;
    }


#ifdef debug_BIC_FindCollision
    G4cout << "FindLateP Particle, 4-mom, times newState "
            << secondary->GetDefinition()->GetParticleName() << " "
            << secondary->Get4Momentum()
            << " times " <<  tin << " " << tout << " "
            << secondary->GetState() << G4endl;
#endif

    const std::vector<G4CollisionInitialState *> & aCandList
    = theLateParticle->GetCollisions(secondary, theTargetList, theCurrentTime);
    for(size_t count=0; count<aCandList.size(); count++)
    {
#ifdef debug_BIC_FindCollision
        G4cout << " Adding a late Col : " << aCandList[count] << G4endl;
#endif
        theCollisionMgr->AddCollision(aCandList[count]);
    }
}


//----------------------------------------------------------------------------
G4bool G4BinaryCascade::ApplyCollision(G4CollisionInitialState * collision)
//----------------------------------------------------------------------------
{
    G4KineticTrack * primary = collision->GetPrimary();

#ifdef debug_BIC_ApplyCollision
    G4cerr << "G4BinaryCascade::ApplyCollision start"<<G4endl;
    theCollisionMgr->Print();
    G4cout << "ApplyCollisions : projte 4mom " << primary->GetTrackingMomentum()<< G4endl;
#endif

    G4KineticTrackVector target_collection=collision->GetTargetCollection();
    G4bool haveTarget=target_collection.size()>0;
    if( haveTarget && (primary->GetState() != G4KineticTrack::inside) )
    {
#ifdef debug_G4BinaryCascade
        G4cout << "G4BinaryCasacde::ApplyCollision(): StateError " << primary << G4endl;
        PrintKTVector(primary,std::string("primay- ..."));
        PrintKTVector(&target_collection,std::string("... targets"));
        collision->Print();
        G4cout << G4endl;
        theCollisionMgr->Print();
        //*GF*     throw G4HadronicException(__FILE__, __LINE__, "G4BinaryCasacde::ApplyCollision()");
#endif
        return false;
//    } else {
//       G4cout << "G4BinaryCasacde::ApplyCollision(): decay " << G4endl;
//       PrintKTVector(primary,std::string("primay- ..."));
//       G4double tin=0., tout=0.;
//       if (((G4RKPropagation*)thePropagator)->GetSphereIntersectionTimes(primary,tin,tout))
//       {
//           G4cout << "tin tout: " << tin << " " << tout << G4endl;
//       }

    }

    G4LorentzVector mom4Primary=primary->Get4Momentum();

    G4int initialBaryon(0);
    G4int initialCharge(0);
    if (primary->GetState() == G4KineticTrack::inside)
    {
        initialBaryon = primary->GetDefinition()->GetBaryonNumber();
        initialCharge = G4lrint(primary->GetDefinition()->GetPDGCharge()/eplus);
    }

    // for primary resonances, subtract neutron ( = proton) field ( ie. add std::abs(field))
    G4double initial_Efermi=CorrectShortlivedPrimaryForFermi(primary,target_collection);
    //****************************************


    G4KineticTrackVector * products = collision->GetFinalState();

#ifdef debug_BIC_ApplyCollision
    DebugApplyCollisionFail(collision, products);
#endif

    // reset primary to initial state, in case there is a veto...
    primary->Set4Momentum(mom4Primary);

    G4bool lateParticleCollision= (!haveTarget) && products && products->size() == 1;
    G4bool decayCollision= (!haveTarget) && products && products->size() > 1;
    G4bool Success(true);


#ifdef debug_G4BinaryCascade
    G4int lateBaryon(0), lateCharge(0);
#endif

    if ( lateParticleCollision )
    {  // for late particles, reset charges
        //G4cout << "lateP, initial B C state " << initialBaryon << " "
        //        << initialCharge<< " " << primary->GetState() << " "<< primary->GetDefinition()->GetParticleName()<< G4endl;
#ifdef debug_G4BinaryCascade
        lateBaryon = initialBaryon;
        lateCharge = initialCharge;
#endif
        initialBaryon=initialCharge=0;
        lateA -= primary->GetDefinition()->GetBaryonNumber();
        lateZ -= G4lrint(primary->GetDefinition()->GetPDGCharge()/eplus);
    }

    initialBaryon += collision->GetTargetBaryonNumber();
    initialCharge += G4lrint(collision->GetTargetCharge());
    if (!lateParticleCollision)
    {
       if( !products || products->size()==0 || !CheckPauliPrinciple(products) )
       {
#ifdef debug_BIC_ApplyCollision
          if (products) G4cout << " ======Failed Pauli =====" << G4endl;
          G4cerr << "G4BinaryCascade::ApplyCollision blocked"<<G4endl;
#endif
          Success=false;
       }



       if (Success && primary->GetState() == G4KineticTrack::inside ) {   // if the primary was outside, nothing to correct
          if (! CorrectShortlivedFinalsForFermi(products, initial_Efermi)){
             Success=false;
          }
       }
    }

#ifdef debug_BIC_ApplyCollision
    DebugApplyCollision(collision, products);
#endif

    if ( ! Success ){
        if (products) ClearAndDestroy(products);
        if ( decayCollision ) FindDecayCollision(primary);  // for decay, sample new decay
        delete products;
        products=0;
        return false;
    }

    G4int finalBaryon(0);
    G4int finalCharge(0);
    G4KineticTrackVector toFinalState;
    for(std::vector<G4KineticTrack *>::iterator i =products->begin(); i != products->end(); i++)
    {
        if ( ! lateParticleCollision )
        {
            (*i)->SetState(primary->GetState());  // decay may be anywhere!
            if ( (*i)->GetState() == G4KineticTrack::inside ){
                finalBaryon+=(*i)->GetDefinition()->GetBaryonNumber();
                finalCharge+=G4lrint((*i)->GetDefinition()->GetPDGCharge()/eplus);
            } else {
               G4double tin=0., tout=0.;
               if (((G4RKPropagation*)thePropagator)->GetSphereIntersectionTimes((*i),tin,tout) &&
                     tin < 0 && tout > 0 )
               {
                  PrintKTVector((*i),"particle inside marked not-inside");
                   G4cout << "tin tout: " << tin << " " << tout << G4endl;
               }
            }
        } else {
            G4double tin=0., tout=0.;
            if (((G4RKPropagation*)thePropagator)->GetSphereIntersectionTimes((*i),tin,tout))
            {
                //G4cout << "tin tout: " << tin << " " << tout << G4endl;
                if ( tin > 0 )
                {
                    (*i)->SetState(G4KineticTrack::outside);
                }
                else if ( tout > 0 )
                {
                    (*i)->SetState(G4KineticTrack::inside);
                    finalBaryon+=(*i)->GetDefinition()->GetBaryonNumber();
                    finalCharge+=G4lrint((*i)->GetDefinition()->GetPDGCharge()/eplus);
                }
                else
                {
                    (*i)->SetState(G4KineticTrack::gone_out);
                    toFinalState.push_back((*i));
                }
            } else
            {
                (*i)->SetState(G4KineticTrack::miss_nucleus);
                //G4cout << " G4BC - miss -late Part- no intersection found " << G4endl;
                toFinalState.push_back((*i));
            }

        }
    }
    if(!toFinalState.empty())
    {
        theFinalState.insert(theFinalState.end(),
                toFinalState.begin(),toFinalState.end());
        std::vector<G4KineticTrack *>::iterator iter1, iter2;
        for(iter1 = toFinalState.begin(); iter1 != toFinalState.end();
                ++iter1)
        {
            iter2 = std::find(products->begin(), products->end(),
                    *iter1);
            if ( iter2 != products->end() ) products->erase(iter2);
        }
        theCollisionMgr->RemoveTracksCollisions(&toFinalState);
    }

    //G4cout << " currentA, Z be4: " << currentA << " " << currentZ << G4endl;
    currentA += finalBaryon-initialBaryon;
    currentZ += finalCharge-initialCharge;
    //G4cout << " ApplyCollision currentA, Z aft: " << currentA << " " << currentZ << G4endl;

    G4KineticTrackVector oldSecondaries;
    oldSecondaries.push_back(primary);
    primary->Hit();

#ifdef debug_G4BinaryCascade
    if ( (finalBaryon-initialBaryon-lateBaryon) != 0 || (finalCharge-initialCharge-lateCharge) != 0 )
    {
        G4cout << "G4BinaryCascade: Error in Balancing: " << G4endl;
        G4cout << "initial/final baryon number, initial/final Charge "
                << initialBaryon <<" "<< finalBaryon <<" "
                << initialCharge <<" "<< finalCharge <<" "
                << " in Collision type: "<< typeid(*collision->GetGenerator()).name()
                << ", with number of products: "<< products->size() <<G4endl;
        G4cout << G4endl<<"Initial condition are these:"<<G4endl;
        G4cout << "proj: "<<collision->GetPrimary()->GetDefinition()->GetParticleName()<<G4endl;
        for(size_t it=0; it<collision->GetTargetCollection().size(); it++)
        {
            G4cout << "targ: "
                    <<collision->GetTargetCollection()[it]->GetDefinition()->GetParticleName()<<G4endl;
        }
        PrintKTVector(&collision->GetTargetCollection(),std::string(" Target particles"));
        G4cout << G4endl<<G4endl;
    }
#endif

    G4KineticTrackVector oldTarget = collision->GetTargetCollection();
    for(size_t ii=0; ii< oldTarget.size(); ii++)
    {
        oldTarget[ii]->Hit();
    }

    UpdateTracksAndCollisions(&oldSecondaries, &oldTarget, products);
    std::for_each(oldSecondaries.begin(), oldSecondaries.end(), Delete<G4KineticTrack>());
    std::for_each(oldTarget.begin(), oldTarget.end(), Delete<G4KineticTrack>());

    delete products;
    return true;
}


//----------------------------------------------------------------------------
G4bool G4BinaryCascade::Absorb()
//----------------------------------------------------------------------------
{
    // Do it in two step: cannot change theSecondaryList inside the first loop.
    G4Absorber absorber(theCutOnPAbsorb);

    // Build the vector of G4KineticTracks that must be absorbed
    G4KineticTrackVector absorbList;
    std::vector<G4KineticTrack *>::iterator iter;
    //  PrintKTVector(&theSecondaryList, " testing for Absorb" );
    for(iter = theSecondaryList.begin();
            iter != theSecondaryList.end(); ++iter)
    {
        G4KineticTrack * kt = *iter;
        if(kt->GetState() == G4KineticTrack::inside)// absorption happens only inside the nucleus
        {
            if(absorber.WillBeAbsorbed(*kt))
            {
                absorbList.push_back(kt);
            }
        }
    }

    if(absorbList.empty())
        return false;

    G4KineticTrackVector toDelete;
    for(iter = absorbList.begin(); iter != absorbList.end(); ++iter)
    {
        G4KineticTrack * kt = *iter;
        if(!absorber.FindAbsorbers(*kt, theTargetList))
            throw G4HadronicException(__FILE__, __LINE__, "G4BinaryCascade::Absorb(): Cannot absorb a particle.");

        if(!absorber.FindProducts(*kt))
            throw G4HadronicException(__FILE__, __LINE__, "G4BinaryCascade::Absorb(): Cannot absorb a particle.");

        G4KineticTrackVector * products = absorber.GetProducts();
        G4int maxLoopCount = 1000;
        while(!CheckPauliPrinciple(products) && --maxLoopCount>0)   /* Loop checking, 31.08.2015, G.Folger */
        {
            ClearAndDestroy(products);
            if(!absorber.FindProducts(*kt))
                throw G4HadronicException(__FILE__, __LINE__,
                        "G4BinaryCascade::Absorb(): Cannot absorb a particle.");
        }
		  if ( --maxLoopCount < 0 ) throw G4HadronicException(__FILE__, __LINE__, "G4BinaryCascade::Absorb(): Cannot absorb a particle."); 
        // ------ debug
        //    G4cerr << "Absorb CheckPauliPrinciple count= " <<  maxLoopCount << G4endl;
        // ------ end debug
        G4KineticTrackVector toRemove;  // build a vector for UpdateTrack...
        toRemove.push_back(kt);
        toDelete.push_back(kt);  // delete the track later
        G4KineticTrackVector * absorbers = absorber.GetAbsorbers();
        UpdateTracksAndCollisions(&toRemove, absorbers, products);
        ClearAndDestroy(absorbers);
    }
    ClearAndDestroy(&toDelete);
    return true;
}



// Capture all p and n with Energy < theCutOnP
//----------------------------------------------------------------------------
G4bool G4BinaryCascade::Capture(G4bool verbose)
//----------------------------------------------------------------------------
{
    G4KineticTrackVector captured;
    G4bool capture = false;
    std::vector<G4KineticTrack *>::iterator i;

    G4RKPropagation * RKprop=(G4RKPropagation *)thePropagator;

    G4double capturedEnergy = 0;
    G4int particlesAboveCut=0;
    G4int particlesBelowCut=0;
    if ( verbose ) G4cout << " Capture: secondaries " << theSecondaryList.size() << G4endl;
    for(i = theSecondaryList.begin(); i != theSecondaryList.end(); ++i)
    {
        G4KineticTrack * kt = *i;
        if (verbose) G4cout << "Capture position, radius, state " <<kt->GetPosition().mag()<<" "<<theOuterRadius<<" "<<kt->GetState()<<G4endl;
        if(kt->GetState() == G4KineticTrack::inside) // capture happens only inside the nucleus
        {
            if((kt->GetDefinition() == G4Proton::Proton()) ||
                    (kt->GetDefinition() == G4Neutron::Neutron()))
            {
                //GF cut on kinetic energy    if(kt->Get4Momentum().vect().mag() >= theCutOnP)
                G4double field=RKprop->GetField(kt->GetDefinition()->GetPDGEncoding(),kt->GetPosition())
	            		           -RKprop->GetBarrier(kt->GetDefinition()->GetPDGEncoding());
                G4double energy= kt->Get4Momentum().e() - kt->GetActualMass() + field;
                if (verbose ) G4cout << "Capture: .e(), mass, field, energy" << kt->Get4Momentum().e() <<" "<<kt->GetActualMass()<<" "<<field<<" "<<energy<< G4endl;
                //	 if( energy < theCutOnP )
                //	 {
                capturedEnergy+=energy;
                ++particlesBelowCut;
                //	 } else
                //	 {
                //	    ++particlesAboveCut;
                //	 }
            }
        }
    }
    if (verbose) G4cout << "Capture particlesAboveCut,particlesBelowCut, capturedEnergy,capturedEnergy/particlesBelowCut <? 0.2*theCutOnP "
            << particlesAboveCut << " " << particlesBelowCut << " " << capturedEnergy
            << " "  << G4endl;
//    << " " << (particlesBelowCut>0) ? (capturedEnergy/particlesBelowCut) : (capturedEnergy) << " " << 0.2*theCutOnP << G4endl;
    //  if(particlesAboveCut==0 && particlesBelowCut>0 && capturedEnergy/particlesBelowCut<0.2*theCutOnP)
    if(particlesBelowCut>0 && capturedEnergy/particlesBelowCut<0.2*theCutOnP)
    {
        capture=true;
        for(i = theSecondaryList.begin(); i != theSecondaryList.end(); ++i)
        {
            G4KineticTrack * kt = *i;
            if(kt->GetState() == G4KineticTrack::inside) // capture happens only inside the nucleus
            {
                if((kt->GetDefinition() == G4Proton::Proton()) ||
                        (kt->GetDefinition() == G4Neutron::Neutron()))
                {
                    captured.push_back(kt);
                    kt->Hit();				//
                    theCapturedList.push_back(kt);
                }
            }
        }
        UpdateTracksAndCollisions(&captured, NULL, NULL);
    }

    return capture;
}


//----------------------------------------------------------------------------
G4bool G4BinaryCascade::CheckPauliPrinciple(G4KineticTrackVector * products)
//----------------------------------------------------------------------------
{
    G4int A = the3DNucleus->GetMassNumber();
    G4int Z = the3DNucleus->GetCharge();

    G4FermiMomentum fermiMom;
    fermiMom.Init(A, Z);

    const G4VNuclearDensity * density=the3DNucleus->GetNuclearDensity();

    G4KineticTrackVector::iterator i;
    const G4ParticleDefinition * definition;

    // ------ debug
    G4bool myflag = true;
    // ------ end debug
    //  G4ThreeVector xpos(0);
    for(i = products->begin(); i != products->end(); ++i)
    {
        definition = (*i)->GetDefinition();
        if((definition == G4Proton::Proton()) ||
                (definition == G4Neutron::Neutron()))
        {
            G4ThreeVector pos = (*i)->GetPosition();
            G4double d = density->GetDensity(pos);
            // energy correspondiing to fermi momentum
            G4double eFermi = std::sqrt( sqr(fermiMom.GetFermiMomentum(d)) + (*i)->Get4Momentum().mag2() );
            if( definition == G4Proton::Proton() )
            {
                eFermi -= the3DNucleus->CoulombBarrier();
            }
            G4LorentzVector mom = (*i)->Get4Momentum();
            // ------ debug
            /*
             *        G4cout << "p:[" << (1/MeV)*mom.x() << " " << (1/MeV)*mom.y() << " "
             *            << (1/MeV)*mom.z() << "] |p3|:"
             *            << (1/MeV)*mom.vect().mag() << " E:" << (1/MeV)*mom.t() << " ] m: "
             *            << (1/MeV)*mom.mag() << "  pos["
             *            << (1/fermi)*pos.x() << " "<< (1/fermi)*pos.y() << " "
             *            << (1/fermi)*pos.z() << "] |Dpos|: "
             *            << (1/fermi)*(pos-xpos).mag() << " Pfermi:"
             *            << (1/MeV)*p << G4endl;
             *         xpos=pos;
             */
            // ------ end debug
            if(mom.e() < eFermi )
            {
                // ------ debug
                myflag = false;
                // ------ end debug
                //      return false;
            }
        }
    }
#ifdef debug_BIC_CheckPauli
    if ( myflag  )
    {
        for(i = products->begin(); i != products->end(); ++i)
        {
            definition = (*i)->GetDefinition();
            if((definition == G4Proton::Proton()) ||
                    (definition == G4Neutron::Neutron()))
            {
                G4ThreeVector pos = (*i)->GetPosition();
                G4double d = density->GetDensity(pos);
                G4double pFermi = fermiMom.GetFermiMomentum(d);
                G4LorentzVector mom = (*i)->Get4Momentum();
                G4double field =((G4RKPropagation*)thePropagator)->GetField(definition->GetPDGEncoding(),pos);
                if ( mom.e()-mom.mag()+field > 160*MeV )
                {
                    G4cout << "momentum problem pFermi=" <<  pFermi
                            << " mom, mom.m " << mom << " " << mom.mag()
                            << " field " << field << G4endl;
                }
            }
        }
    }
#endif

    return myflag;
}

//----------------------------------------------------------------------------
void G4BinaryCascade::StepParticlesOut()
//----------------------------------------------------------------------------
{
    G4int counter=0;
    G4int countreset=0;
    //G4cout << " nucl. Radius " << radius << G4endl;
    // G4cerr <<"pre-while- theSecondaryList "<<G4endl;
    while( theSecondaryList.size() > 0 )               /* Loop checking, 31.08.2015, G.Folger */
	                                                    // if countreset reaches limit, there is a break from while, see below.
    {
        G4int nsec=0;
        G4double minTimeStep = 1.e-12*ns;   // about 30*fermi/(0.1*c_light);1.e-12*ns
                                            // i.e. a big step
        std::vector<G4KineticTrack *>::iterator i;
        for(i = theSecondaryList.begin(); i != theSecondaryList.end(); ++i)
        {
            G4KineticTrack * kt = *i;
            if( kt->GetState() == G4KineticTrack::inside )
            {
                nsec++;
                G4double tStep(0), tdummy(0);
                G4bool intersect =
                        ((G4RKPropagation*)thePropagator)->GetSphereIntersectionTimes(kt,tdummy,tStep);
#ifdef debug_BIC_StepParticlesOut
                G4cout << " minTimeStep, tStep Particle " <<minTimeStep << " " <<tStep
                        << " " <<kt->GetDefinition()->GetParticleName()
                        << " 4mom " << kt->GetTrackingMomentum()<<G4endl;
                if ( ! intersect );
                {
                    PrintKTVector(&theSecondaryList, std::string(" state ERROR....."));
                    throw G4HadronicException(__FILE__, __LINE__, "G4BinaryCascade::StepParticlesOut() particle not in nucleus");
                }
#endif
                if(intersect && tStep<minTimeStep && tStep> 0 )
                {
                    minTimeStep = tStep;
                }
            } else if ( kt->GetState() != G4KineticTrack::outside ){
                PrintKTVector(&theSecondaryList, std::string(" state ERROR....."));
                throw G4HadronicException(__FILE__, __LINE__, "G4BinaryCascade::StepParticlesOut() particle not in nucleus");
            }
        }
        minTimeStep *= 1.2;
        //    G4cerr << "CaptureCount = "<<counter<<" "<<nsec<<" "<<minTimeStep<<" "<<1*ns<<G4endl;
        G4double timeToCollision=DBL_MAX;
        G4CollisionInitialState * nextCollision=0;
        if(theCollisionMgr->Entries() > 0)
        {
            nextCollision = theCollisionMgr->GetNextCollision();
            timeToCollision = nextCollision->GetCollisionTime()-theCurrentTime;
            //  G4cout << " NextCollision  * , Time= " << nextCollision << " " <<timeToCollision<< G4endl;
        }
        if ( timeToCollision > minTimeStep )
        {
            DoTimeStep(minTimeStep);
            ++counter;
        } else
        {
            if (!DoTimeStep(timeToCollision) )
            {
                // Check if nextCollision is still valid, ie. partcile did not leave nucleus
                if (theCollisionMgr->GetNextCollision() != nextCollision )
                {
                    nextCollision = 0;
                }
            }
            // G4cerr <<"post- DoTimeStep 3"<<G4endl;

            if(nextCollision)
            {
                if  ( ApplyCollision(nextCollision))
                {
                    // G4cout << "ApplyCollision sucess " << G4endl;
                } else
                {
                    theCollisionMgr->RemoveCollision(nextCollision);
                }
            }
        }

        if(countreset>100)
        {
#ifdef debug_G4BinaryCascade
            G4cerr << "G4BinaryCascade.cc: Warning - aborting looping particle(s)" << G4endl;
            PrintKTVector(&theSecondaryList," looping particles added to theFinalState");
#endif

            //  add left secondaries to FinalSate
            std::vector<G4KineticTrack *>::iterator iter;
            for ( iter =theSecondaryList.begin(); iter != theSecondaryList.end(); ++iter)
            {
                theFinalState.push_back(*iter);
            }
            theSecondaryList.clear();

            break;
        }

        if(Absorb())
        {
            //       haveProducts = true;
            // G4cout << "Absorb sucess " << G4endl;
        }

        if(Capture(false))
        {
            //       haveProducts = true;
#ifdef debug_BIC_StepParticlesOut
            G4cout << "Capture sucess " << G4endl;
#endif
        }
        if ( counter > 100 && theCollisionMgr->Entries() == 0)   // no collision, and stepping for some time....
        {
#ifdef debug_BIC_StepParticlesOut
            PrintKTVector(&theSecondaryList,std::string("stepping 100 steps"));
#endif
            FindCollisions(&theSecondaryList);
            counter=0;
            ++countreset;
        }
        //G4cout << "currentZ @ end loop " << currentZ << G4endl;
        if ( ! currentZ ){
            // nucleus completely destroyed, fill in ReactionProductVector
           // products = FillVoidNucleusProducts(products);
    #ifdef debug_BIC_return
            G4cout << "return @ Z=0 after collision loop "<< G4endl;
            PrintKTVector(&theSecondaryList,std::string(" theSecondaryList"));
            G4cout << "theTargetList size: " << theTargetList.size() << G4endl;
            PrintKTVector(&theTargetList,std::string(" theTargetList"));
            PrintKTVector(&theCapturedList,std::string(" theCapturedList"));

            G4cout << " ExcitE be4 Correct : " <<GetExcitationEnergy() << G4endl;
            G4cout << " Mom Transfered to nucleus : " << theMomentumTransfer << " " << theMomentumTransfer.mag() << G4endl;
            PrintKTVector(&theFinalState,std::string(" FinalState uncorrected"));
          //  G4cout << "returned products: " << products->size() << G4endl;
    #endif
        }

    }
    //  G4cerr <<"Finished capture loop "<<G4endl;

    //G4cerr <<"pre- DoTimeStep 4"<<G4endl;
    DoTimeStep(DBL_MAX);
    //G4cerr <<"post- DoTimeStep 4"<<G4endl;


}

//----------------------------------------------------------------------------
G4double G4BinaryCascade::CorrectShortlivedPrimaryForFermi(
        G4KineticTrack* primary,G4KineticTrackVector target_collection)
//----------------------------------------------------------------------------
{
    G4double Efermi(0);
    if (primary->GetState() == G4KineticTrack::inside ) {
        G4int PDGcode=primary->GetDefinition()->GetPDGEncoding();
        Efermi=((G4RKPropagation *)thePropagator)->GetField(PDGcode,primary->GetPosition());

        if ( std::abs(PDGcode) > 1000 && PDGcode != 2112 && PDGcode != 2212 )
        {
            Efermi = ((G4RKPropagation *)thePropagator)->GetField(G4Neutron::Neutron()->GetPDGEncoding(),primary->GetPosition());
            G4LorentzVector mom4Primary=primary->Get4Momentum();
            primary->Update4Momentum(mom4Primary.e() - Efermi);
        }

        std::vector<G4KineticTrack *>::iterator titer;
        for ( titer=target_collection.begin() ; titer!=target_collection.end(); ++titer)
        {
            const G4ParticleDefinition * aDef=(*titer)->GetDefinition();
            G4int aCode=aDef->GetPDGEncoding();
            G4ThreeVector aPos=(*titer)->GetPosition();
            Efermi+= ((G4RKPropagation *)thePropagator)->GetField(aCode, aPos);
        }
    }
    return Efermi;
}

//----------------------------------------------------------------------------
G4bool G4BinaryCascade::CorrectShortlivedFinalsForFermi(G4KineticTrackVector * products,
        G4double initial_Efermi)
//----------------------------------------------------------------------------
{
    G4double final_Efermi(0);
    G4KineticTrackVector resonances;
    for ( std::vector<G4KineticTrack *>::iterator i =products->begin(); i != products->end(); i++)
    {
        G4int PDGcode=(*i)->GetDefinition()->GetPDGEncoding();
        //       G4cout << " PDGcode, state " << PDGcode << " " << (*i)->GetState()<<G4endl;
        final_Efermi+=((G4RKPropagation *)thePropagator)->GetField(PDGcode,(*i)->GetPosition());
        if ( std::abs(PDGcode) > 1000 && PDGcode != 2112 && PDGcode != 2212 )
        {
            resonances.push_back(*i);
        }
    }
    if ( resonances.size() > 0 )
    {
        G4double delta_Fermi= (initial_Efermi-final_Efermi)/resonances.size();
        for (std::vector<G4KineticTrack *>::iterator res=resonances.begin(); res != resonances.end(); res++)
        {
            G4LorentzVector mom=(*res)->Get4Momentum();
            G4double mass2=mom.mag2();
            G4double newEnergy=mom.e() + delta_Fermi;
            G4double newEnergy2= newEnergy*newEnergy;
            //G4cout << "mom = " << mom <<" newE " << newEnergy<< G4endl;
            if ( newEnergy2 < mass2 )
            {
                return false;
            }
            G4ThreeVector mom3=std::sqrt(newEnergy2 - mass2) * mom.vect().unit();
            (*res)->Set4Momentum(G4LorentzVector(mom3,newEnergy));
            	  //G4cout << " correct resonance from /to " << mom.e() << " / " << newEnergy<<
            	  //		    " 3mom from/to " << mom.vect() << " / " << mom3 << G4endl;
        }
    }
    return true;
}

//----------------------------------------------------------------------------
void G4BinaryCascade::CorrectFinalPandE()
//----------------------------------------------------------------------------
//
//  Modify momenta of outgoing particles.
//   Assume two body decay, nucleus(@nominal mass) + sum of final state particles(SFSP).
//   momentum of SFSP shall be less than momentum for two body decay.
//
{
#ifdef debug_BIC_CorrectFinalPandE
    G4cerr << "BIC: -CorrectFinalPandE called" << G4endl;
#endif

    if ( theFinalState.size() == 0 ) return;

    G4KineticTrackVector::iterator i;
    G4LorentzVector pNucleus=GetFinal4Momentum();
    if ( pNucleus.e() == 0 ) return;    // check against explicit 0 from GetNucleus4Momentum()
#ifdef debug_BIC_CorrectFinalPandE
    G4cerr << " -CorrectFinalPandE 3" << G4endl;
#endif
    G4LorentzVector pFinals(0);
    G4int nFinals(0);
    for(i = theFinalState.begin(); i != theFinalState.end(); ++i)
    {
        pFinals += (*i)->Get4Momentum();
        ++nFinals;
#ifdef debug_BIC_CorrectFinalPandE
        G4cout <<"CorrectFinalPandE a final " << (*i)->GetDefinition()->GetParticleName()
        		           << " 4mom " << (*i)->Get4Momentum()<< G4endl;
#endif
    }
#ifdef debug_BIC_CorrectFinalPandE
    G4cout << "CorrectFinalPandE pN pF: " <<pNucleus << " " <<pFinals << G4endl;
#endif
    G4LorentzVector pCM=pNucleus + pFinals;

    G4LorentzRotation toCMS(-pCM.boostVector());
    pFinals *=toCMS;
#ifdef debug_BIC_CorrectFinalPandE
    G4cout << "CorrectFinalPandE pCM, CMS pCM " << pCM << " " <<toCMS*pCM<< G4endl;
    G4cout << "CorrectFinal CMS pN pF " <<toCMS*pNucleus << " "
            <<pFinals << G4endl
            << " nucleus initial mass : " <<GetFinal4Momentum().mag()
            <<" massInNucleus m(nucleus) m(finals) std::sqrt(s): " << massInNucleus << " " <<pNucleus.mag()<< " "
            << pFinals.mag() << " " << pCM.mag() << G4endl;
#endif

    G4LorentzRotation toLab = toCMS.inverse();

    G4double s0 = pCM.mag2();
    G4double m10 = GetIonMass(currentZ,currentA);
    G4double m20 = pFinals.mag();
    if( s0-(m10+m20)*(m10+m20) < 0 )
    {
#ifdef debug_BIC_CorrectFinalPandE
        G4cout << "G4BinaryCascade::CorrectFinalPandE() : error! " << G4endl;

        G4cout << "not enough mass to correct: mass^2, A,Z, mass(nucl), mass(finals) "
                << (s0-(m10+m20)*(m10+m20)) << " "
                << currentA << " " << currentZ << " "
                << m10 << " " << m20
                << G4endl;
        G4cerr << " -CorrectFinalPandE 4" << G4endl;

        PrintKTVector(&theFinalState," mass problem");
#endif
        return;
    }

    // Three momentum in cm system
    G4double pInCM = std::sqrt((s0-(m10+m20)*(m10+m20))*(s0-(m10-m20)*(m10-m20))/(4.*s0));
#ifdef debug_BIC_CorrectFinalPandE
    G4cout <<" CorrectFinalPandE pInCM  new, CURRENT, ratio : " << pInCM
            << " " << (pFinals).vect().mag()<< " " <<  pInCM/(pFinals).vect().mag() << G4endl;
#endif
    if ( pFinals.vect().mag() > pInCM )
    {
        G4ThreeVector p3finals=pInCM*pFinals.vect().unit();

        //    G4ThreeVector deltap=(p3finals - pFinals.vect() ) / nFinals;
        G4double factor=std::max(0.98,pInCM/pFinals.vect().mag());   // small correction
        G4LorentzVector qFinals(0);
        for(i = theFinalState.begin(); i != theFinalState.end(); ++i)
        {
            //      G4ThreeVector p3((toCMS*(*i)->Get4Momentum()).vect() + deltap);
            G4ThreeVector p3(factor*(toCMS*(*i)->Get4Momentum()).vect());
            G4LorentzVector p(p3,std::sqrt((*i)->Get4Momentum().mag2() + p3.mag2()));
            qFinals += p;
            p *= toLab;
#ifdef debug_BIC_CorrectFinalPandE
            G4cout << " final p corrected: " << p << G4endl;
#endif
            (*i)->Set4Momentum(p);
        }
#ifdef debug_BIC_CorrectFinalPandE
        G4cout << "CorrectFinalPandE nucleus corrected mass : " << GetFinal4Momentum() << " "
                <<GetFinal4Momentum().mag() << G4endl
                << " CMS pFinals , mag, 3.mag : " << qFinals << " " << qFinals.mag() << " " << qFinals.vect().mag()<< G4endl;
        G4cerr << " -CorrectFinalPandE 5 " << factor <<  G4endl;
#endif
    }
#ifdef debug_BIC_CorrectFinalPandE
    else { G4cerr << " -CorrectFinalPandE 6 - no correction done" << G4endl; }
#endif

}

//----------------------------------------------------------------------------
void G4BinaryCascade::UpdateTracksAndCollisions(
        //----------------------------------------------------------------------------
        G4KineticTrackVector * oldSecondaries,
        G4KineticTrackVector * oldTarget,
        G4KineticTrackVector * newSecondaries)
{
    std::vector<G4KineticTrack *>::iterator iter1, iter2;

    // remove old secondaries from the secondary list
    if(oldSecondaries)
    {
        if(!oldSecondaries->empty())
        {
            for(iter1 = oldSecondaries->begin(); iter1 != oldSecondaries->end();
                    ++iter1)
            {
                iter2 = std::find(theSecondaryList.begin(), theSecondaryList.end(),
                        *iter1);
                if ( iter2 != theSecondaryList.end() ) theSecondaryList.erase(iter2);
            }
            theCollisionMgr->RemoveTracksCollisions(oldSecondaries);
        }
    }

    // remove old target from the target list
    if(oldTarget)
    {
        // G4cout << "################## Debugging 0 "<<G4endl;
        if(oldTarget->size()!=0)
        {

            // G4cout << "################## Debugging 1 "<<oldTarget->size()<<G4endl;
            for(iter1 = oldTarget->begin(); iter1 != oldTarget->end(); ++iter1)
            {
                iter2 = std::find(theTargetList.begin(), theTargetList.end(),
                        *iter1);
                theTargetList.erase(iter2);
            }
            theCollisionMgr->RemoveTracksCollisions(oldTarget);
        }
    }

    if(newSecondaries)
    {
        if(!newSecondaries->empty())
        {
            // insert new secondaries in the secondary list
            for(iter1 = newSecondaries->begin(); iter1 != newSecondaries->end();
                    ++iter1)
            {
                theSecondaryList.push_back(*iter1);
                if ((*iter1)->GetState() == G4KineticTrack::undefined)
                {
                   PrintKTVector(*iter1, "undefined in FindCollisions");
                }


            }
            // look for collisions of new secondaries
            FindCollisions(newSecondaries);
        }
    }
    // G4cout << "Exiting ... "<<oldTarget<<G4endl;
}


class SelectFromKTV
{
private:
    G4KineticTrackVector * ktv;
    G4KineticTrack::CascadeState wanted_state;
public:
    SelectFromKTV(G4KineticTrackVector * out, G4KineticTrack::CascadeState astate)
    :
        ktv(out), wanted_state(astate)
    {};
    void operator() (G4KineticTrack *& kt) const
    {
        if ( (kt)->GetState() == wanted_state ) ktv->push_back(kt);
    };
};



//----------------------------------------------------------------------------
G4bool G4BinaryCascade::DoTimeStep(G4double theTimeStep)
//----------------------------------------------------------------------------
{

#ifdef debug_BIC_DoTimeStep
    G4ping debug("debug_G4BinaryCascade");
    debug.push_back("======> DoTimeStep 1"); debug.dump();
    G4cerr <<"G4BinaryCascade::DoTimeStep: enter step="<< theTimeStep
            << " , time="<<theCurrentTime << G4endl;
    PrintKTVector(&theSecondaryList, std::string("DoTimeStep - theSecondaryList"));
    //PrintKTVector(&theTargetList, std::string("DoTimeStep - theTargetList"));
#endif

    G4bool success=true;
    std::vector<G4KineticTrack *>::iterator iter;

    G4KineticTrackVector * kt_outside = new G4KineticTrackVector;
    std::for_each( theSecondaryList.begin(),theSecondaryList.end(),
            SelectFromKTV(kt_outside,G4KineticTrack::outside));
    //PrintKTVector(kt_outside, std::string("DoTimeStep - found outside"));

    G4KineticTrackVector * kt_inside = new G4KineticTrackVector;
    std::for_each( theSecondaryList.begin(),theSecondaryList.end(),
            SelectFromKTV(kt_inside, G4KineticTrack::inside));
    //  PrintKTVector(kt_inside, std::string("DoTimeStep - found inside"));
    //-----
    G4KineticTrackVector dummy;   // needed for re-usability
#ifdef debug_BIC_DoTimeStep
    G4cout << "NOW WE ARE ENTERING THE TRANSPORT"<<G4endl;
#endif

    // =================== Here we move the particles  ===================

    thePropagator->Transport(theSecondaryList, dummy, theTimeStep);

    // =================== Here we move the particles  ===================

    //------

    theMomentumTransfer += thePropagator->GetMomentumTransfer();
#ifdef debug_BIC_DoTimeStep
    G4cout << "DoTimeStep : theMomentumTransfer = " << theMomentumTransfer << G4endl;
    PrintKTVector(&theSecondaryList, std::string("DoTimeStep - secondaries aft trsprt"));
#endif

    //_DebugEpConservation(" after stepping");

    // Partclies which went INTO nucleus

    G4KineticTrackVector * kt_gone_in = new G4KineticTrackVector;
    std::for_each( kt_outside->begin(),kt_outside->end(),
            SelectFromKTV(kt_gone_in,G4KineticTrack::inside));
    //  PrintKTVector(kt_gone_in, std::string("DoTimeStep - gone in"));


    // Partclies which  went OUT OF nucleus
    G4KineticTrackVector * kt_gone_out = new G4KineticTrackVector;
    std::for_each( kt_inside->begin(),kt_inside->end(),
            SelectFromKTV(kt_gone_out, G4KineticTrack::gone_out));

    //  PrintKTVector(kt_gone_out, std::string("DoTimeStep - gone out"));

    G4KineticTrackVector *fail=CorrectBarionsOnBoundary(kt_gone_in,kt_gone_out);

    if ( fail )
    {
        // some particle(s) supposed to enter/leave were miss_nucleus/captured by the correction
        kt_gone_in->clear();
        std::for_each( kt_outside->begin(),kt_outside->end(),
                SelectFromKTV(kt_gone_in,G4KineticTrack::inside));

        kt_gone_out->clear();
        std::for_each( kt_inside->begin(),kt_inside->end(),
                SelectFromKTV(kt_gone_out, G4KineticTrack::gone_out));

#ifdef debug_BIC_DoTimeStep
        PrintKTVector(fail,std::string(" Failed to go in/out -> miss_nucleus/captured"));
        PrintKTVector(kt_gone_in, std::string("recreated kt_gone_in"));
        PrintKTVector(kt_gone_out, std::string("recreated kt_gone_out"));
#endif
        delete fail;
    }

    // Add tracks missing nucleus and tracks going straight though  to addFinals
    std::for_each( kt_outside->begin(),kt_outside->end(),
            SelectFromKTV(kt_gone_out,G4KineticTrack::miss_nucleus));
    //PrintKTVector(kt_gone_out, std::string("miss to append to final state.."));
    std::for_each( kt_outside->begin(),kt_outside->end(),
            SelectFromKTV(kt_gone_out,G4KineticTrack::gone_out));

#ifdef debug_BIC_DoTimeStep
    PrintKTVector(kt_gone_out, std::string("append gone_outs to final state.. theFinalState"));
#endif

    theFinalState.insert(theFinalState.end(),
            kt_gone_out->begin(),kt_gone_out->end());

    // Partclies which could not leave nucleus,  captured...
    G4KineticTrackVector * kt_captured = new G4KineticTrackVector;
    std::for_each( theSecondaryList.begin(),theSecondaryList.end(),
            SelectFromKTV(kt_captured, G4KineticTrack::captured));

    // Check no track is part in next collision, ie.
    //  this step was to far, and collisions should not occur any more

    if ( theCollisionMgr->Entries()> 0 )
    {
        if (kt_gone_out->size() )
        {
            G4KineticTrack * nextPrimary = theCollisionMgr->GetNextCollision()->GetPrimary();
            iter = std::find(kt_gone_out->begin(),kt_gone_out->end(),nextPrimary);
            if ( iter !=  kt_gone_out->end() )
            {
                success=false;
#ifdef debug_BIC_DoTimeStep
                G4cout << " DoTimeStep - WARNING: deleting current collision!" << G4endl;
#endif
            }
        }
        if ( kt_captured->size() )
        {
            G4KineticTrack * nextPrimary = theCollisionMgr->GetNextCollision()->GetPrimary();
            iter = std::find(kt_captured->begin(),kt_captured->end(),nextPrimary);
            if ( iter !=  kt_captured->end() )
            {
                success=false;
#ifdef debug_BIC_DoTimeStep
                G4cout << " DoTimeStep - WARNING: deleting current collision!" << G4endl;
#endif
            }
        }

    }
    // PrintKTVector(kt_gone_out," kt_gone_out be4 updatetrack...");
    UpdateTracksAndCollisions(kt_gone_out,0 ,0);


    if ( kt_captured->size() )
    {
        theCapturedList.insert(theCapturedList.end(),
                kt_captured->begin(),kt_captured->end());
        //should be      std::for_each(kt_captured->begin(),kt_captured->end(),
        //              std::mem_fun(&G4KineticTrack::Hit));
        // but VC 6 requires:
        std::vector<G4KineticTrack *>::iterator i_captured;
        for(i_captured=kt_captured->begin();i_captured!=kt_captured->end();i_captured++)
        {
            (*i_captured)->Hit();
        }
        //     PrintKTVector(kt_captured," kt_captured be4 updatetrack...");
        UpdateTracksAndCollisions(kt_captured, NULL, NULL);
    }

#ifdef debug_G4BinaryCascade
    delete kt_inside;
    kt_inside = new G4KineticTrackVector;
    std::for_each( theSecondaryList.begin(),theSecondaryList.end(),
            SelectFromKTV(kt_inside, G4KineticTrack::inside));
    if ( currentZ != (GetTotalCharge(theTargetList)
            + GetTotalCharge(theCapturedList)
            + GetTotalCharge(*kt_inside)) )
    {
        G4cout << " error-DoTimeStep aft, A, Z: " << currentA << " " << currentZ
                << " sum(tgt,capt,active) "
                << GetTotalCharge(theTargetList) + GetTotalCharge(theCapturedList) + GetTotalCharge(*kt_inside)
                << " targets: "  << GetTotalCharge(theTargetList)
                << " captured: " << GetTotalCharge(theCapturedList)
                << " active: "   << GetTotalCharge(*kt_inside)
                << G4endl;
    }
#endif

    delete kt_inside;
    delete kt_outside;
    delete kt_captured;
    delete kt_gone_in;
    delete kt_gone_out;

    //  G4cerr <<"G4BinaryCascade::DoTimeStep: exit "<<G4endl;
    theCurrentTime += theTimeStep;

    //debug.push_back("======> DoTimeStep 2"); debug.dump();
    return success;

}

//----------------------------------------------------------------------------
G4KineticTrackVector* G4BinaryCascade::CorrectBarionsOnBoundary(
        G4KineticTrackVector *in,
        G4KineticTrackVector *out)
//----------------------------------------------------------------------------
{
    G4KineticTrackVector * kt_fail(0);
    std::vector<G4KineticTrack *>::iterator iter;
    //  G4cout << "CorrectBarionsOnBoundary,currentZ,currentA,"
    //         << currentZ << " "<< currentA << G4endl;
    if (in->size())
    {
        G4int secondaries_in(0);
        G4int secondaryBarions_in(0);
        G4int secondaryCharge_in(0);
        G4double secondaryMass_in(0);

        for ( iter =in->begin(); iter != in->end(); ++iter)
        {
            ++secondaries_in;
            secondaryCharge_in += G4lrint((*iter)->GetDefinition()->GetPDGCharge()/eplus);
            if ((*iter)->GetDefinition()->GetBaryonNumber()!=0 )
            {
                secondaryBarions_in += (*iter)->GetDefinition()->GetBaryonNumber();
                if((*iter)->GetDefinition() == G4Neutron::Neutron() ||
                        (*iter)->GetDefinition() == G4Proton::Proton()  )
                {
                    secondaryMass_in += (*iter)->GetDefinition()->GetPDGMass();
                } else 	  {
                    secondaryMass_in += G4Proton::Proton()->GetPDGMass();
                }
            }
        }
        G4double mass_initial= GetIonMass(currentZ,currentA);

        currentZ += secondaryCharge_in;
        currentA += secondaryBarions_in;

        //  G4cout << "CorrectBarionsOnBoundary,secondaryCharge_in, secondaryBarions_in "
        //         <<    secondaryCharge_in << " "<<  secondaryBarions_in << G4endl;

        G4double mass_final= GetIonMass(currentZ,currentA);

        G4double correction= secondaryMass_in + mass_initial - mass_final;
        if (secondaries_in>1)
        {correction /= secondaries_in;}

#ifdef debug_BIC_CorrectBarionsOnBoundary
        G4cout << "CorrectBarionsOnBoundary,currentZ,currentA,"
                << "secondaryCharge_in,secondaryBarions_in,"
                << "energy correction,m_secondry,m_nucl_init,m_nucl_final "
                << currentZ << " "<< currentA <<" "
                << secondaryCharge_in<<" "<<secondaryBarions_in<<" "
                << correction << " "
                << secondaryMass_in << " "
                << mass_initial << " "
                << mass_final << " "
                << G4endl;
        PrintKTVector(in,std::string("in be4 correction"));
#endif
        for ( iter = in->begin(); iter != in->end(); ++iter)
        {
            if ((*iter)->GetTrackingMomentum().e()+correction > (*iter)->GetActualMass())
            {
                (*iter)->UpdateTrackingMomentum((*iter)->GetTrackingMomentum().e() + correction);
            } else {
                //particle cannot go in, put to miss_nucleus
                G4RKPropagation * RKprop=(G4RKPropagation *)thePropagator;
                (*iter)->SetState(G4KineticTrack::miss_nucleus);
                // Undo correction for Colomb Barrier
                G4double barrier=RKprop->GetBarrier((*iter)->GetDefinition()->GetPDGEncoding());
                (*iter)->UpdateTrackingMomentum((*iter)->GetTrackingMomentum().e() + barrier);
                if ( ! kt_fail ) kt_fail=new G4KineticTrackVector;
                kt_fail->push_back(*iter);
                currentZ -= G4lrint((*iter)->GetDefinition()->GetPDGCharge()/eplus);
                currentA -= (*iter)->GetDefinition()->GetBaryonNumber();

            }

        }
#ifdef debug_BIC_CorrectBarionsOnBoundary
        G4cout << " CorrectBarionsOnBoundary, aft, Z, A, sec-Z,A,m,m_in_nucleus "
                << currentZ << " " << currentA << " "
                << secondaryCharge_in << " " << secondaryBarions_in << " "
                << secondaryMass_in  << " "
                << G4endl;
        PrintKTVector(in,std::string("in AFT correction"));
#endif

    }
    //----------------------------------------------
    if (out->size())
    {
        G4int secondaries_out(0);
        G4int secondaryBarions_out(0);
        G4int secondaryCharge_out(0);
        G4double secondaryMass_out(0);

        for ( iter =out->begin(); iter != out->end(); ++iter)
        {
            ++secondaries_out;
            secondaryCharge_out += G4lrint((*iter)->GetDefinition()->GetPDGCharge()/eplus);
            if ((*iter)->GetDefinition()->GetBaryonNumber() !=0 )
            {
                secondaryBarions_out += (*iter)->GetDefinition()->GetBaryonNumber();
                if((*iter)->GetDefinition() == G4Neutron::Neutron() ||
                        (*iter)->GetDefinition() == G4Proton::Proton()  )
                {
                    secondaryMass_out += (*iter)->GetDefinition()->GetPDGMass();
                } else {
                    secondaryMass_out += G4Neutron::Neutron()->GetPDGMass();
                }
            }
        }

        G4double mass_initial=  GetIonMass(currentZ,currentA);
        currentA -=secondaryBarions_out;
        currentZ -=secondaryCharge_out;

        //  G4cout << "CorrectBarionsOnBoundary,secondaryCharge_out, secondaryBarions_out "
        //         <<    secondaryCharge_out << " "<<  secondaryBarions_out << G4endl;

        //                        a delta minus will do currentZ < 0 in light nuclei
        //     if (currentA < 0 || currentZ < 0 )
        if (currentA < 0 )
        {
            G4cerr << "G4BinaryCascade - secondaryBarions_out,secondaryCharge_out " <<
                    secondaryBarions_out << " " << secondaryCharge_out << G4endl;
            PrintKTVector(&theTargetList,"CorrectBarionsOnBoundary Target");
            PrintKTVector(&theCapturedList,"CorrectBarionsOnBoundary Captured");
            PrintKTVector(&theSecondaryList,"CorrectBarionsOnBoundary Secondaries");
            G4cerr << "G4BinaryCascade - currentA, currentZ " << currentA << " " << currentZ << G4endl;
            throw G4HadronicException(__FILE__, __LINE__, "G4BinaryCascade::CorrectBarionsOnBoundary() - fatal error");
        }
        G4double mass_final=GetIonMass(currentZ,currentA);
        G4double correction= mass_initial - mass_final - secondaryMass_out;
        // G4cout << "G4BinaryCascade::CorrectBarionsOnBoundary() total out correction: " << correction << G4endl;

        if (secondaries_out>1) correction /= secondaries_out;
#ifdef debug_BIC_CorrectBarionsOnBoundary
        G4cout << "DoTimeStep,(current Z,A),"
                << "(secondaries out,Charge,Barions),"
                <<"* energy correction,(m_secondry,m_nucl_init,m_nucl_final) "
                << "("<< currentZ << ","<< currentA <<") ("
                << secondaries_out << ","
                << secondaryCharge_out<<","<<secondaryBarions_out<<") * "
                << correction << " ("
                << secondaryMass_out << ", "
                << mass_initial << ", "
                << mass_final << ")"
                << G4endl;
        PrintKTVector(out,std::string("out be4 correction"));
#endif

        for ( iter = out->begin(); iter != out->end(); ++iter)
        {
            if ((*iter)->GetTrackingMomentum().e()+correction > (*iter)->GetActualMass())
            {
                (*iter)->UpdateTrackingMomentum((*iter)->GetTrackingMomentum().e() + correction);
            } else
            {
                // particle cannot go out due to change of nuclear potential!
                //  capture protons and neutrons;
                if(((*iter)->GetDefinition() == G4Proton::Proton()) ||
                        ((*iter)->GetDefinition() == G4Neutron::Neutron()))
                {
                    (*iter)->SetState(G4KineticTrack::captured);
                    // Undo correction for Colomb Barrier
                    G4double barrier=((G4RKPropagation *)thePropagator)->GetBarrier((*iter)->GetDefinition()->GetPDGEncoding());
                    (*iter)->UpdateTrackingMomentum((*iter)->GetTrackingMomentum().e() - barrier);
                    if ( kt_fail == 0 ) kt_fail=new G4KineticTrackVector;
                    kt_fail->push_back(*iter);
                    currentZ += G4lrint((*iter)->GetDefinition()->GetPDGCharge()/eplus);
                    currentA += (*iter)->GetDefinition()->GetBaryonNumber();
                }
#ifdef debug_BIC_CorrectBarionsOnBoundary
                else
                {
                    G4cout << "Not correcting outgoing " << *iter << " "
                            << (*iter)->GetDefinition()->GetPDGEncoding() << " "
                            << (*iter)->GetDefinition()->GetParticleName() << G4endl;
                    PrintKTVector(out,std::string("outgoing, one not corrected"));
                }
#endif
            }
        }

#ifdef debug_BIC_CorrectBarionsOnBoundary
        PrintKTVector(out,std::string("out AFTER correction"));
        G4cout << " DoTimeStep, nucl-update, A, Z, sec-Z,A,m,m_in_nucleus, table-mass, delta "
                << currentA << " "<< currentZ << " "
                << secondaryCharge_out << " "<< secondaryBarions_out << " "<<
                secondaryMass_out << " "
                << massInNucleus << " "
                << GetIonMass(currentZ,currentA)
                << " " << massInNucleus - GetIonMass(currentZ,currentA)
                << G4endl;
#endif
    }

    return kt_fail;
}


//----------------------------------------------------------------------------

G4Fragment * G4BinaryCascade::FindFragments()
//----------------------------------------------------------------------------
{

#ifdef debug_BIC_FindFragments
    G4cout << "target, captured, secondary: "
            << theTargetList.size() << " "
            << theCapturedList.size()<< " "
            << theSecondaryList.size()
            << G4endl;
#endif

    G4int a = theTargetList.size()+theCapturedList.size();
    G4int zTarget = 0;
    G4KineticTrackVector::iterator i;
    for(i = theTargetList.begin(); i != theTargetList.end(); ++i)
    {
        if(G4lrint((*i)->GetDefinition()->GetPDGCharge()/eplus) == 1 )
        {
            zTarget++;
        }
    }

    G4int zCaptured = 0;
    G4LorentzVector CapturedMomentum(0.,0.,0.,0.);
    for(i = theCapturedList.begin(); i != theCapturedList.end(); ++i)
    {
        CapturedMomentum += (*i)->Get4Momentum();
        if(G4lrint((*i)->GetDefinition()->GetPDGCharge()/eplus) == 1 )
        {
            zCaptured++;
        }
    }

    G4int z = zTarget+zCaptured;

#ifdef debug_G4BinaryCascade
    if ( z != (GetTotalCharge(theTargetList) + GetTotalCharge(theCapturedList)) )
    {
        G4cout << " FindFragment Counting error z a " << z << " " <<a << " "
                << GetTotalCharge(theTargetList) << " " <<  GetTotalCharge(theCapturedList)<<
                G4endl;
        PrintKTVector(&theTargetList, std::string("theTargetList"));
        PrintKTVector(&theCapturedList, std::string("theCapturedList"));
    }
#endif
    //debug
    /*
     *   G4cout << " Fragment mass table / real "
     *          << GetIonMass(z, a)
     * 	 << " / " << GetFinal4Momentum().mag()
     * 	 << " difference "
     * 	 <<  GetFinal4Momentum().mag() - GetIonMass(z, a)
     * 	 << G4endl;
     */
    //
    //  if(getenv("BCDEBUG") ) G4cerr << "Fragment A, Z "<< a <<" "<< z<<G4endl;
    if ( z < 1 ) return 0;

    G4int holes = the3DNucleus->GetMassNumber() - theTargetList.size();
    G4int excitons = theCapturedList.size();
#ifdef debug_BIC_FindFragments
    G4cout << "Fragment: a= " << a << " z= " << z << " particles= " <<  excitons
            << " Charged= " << zCaptured << " holes= " << holes
            << " excitE= " <<GetExcitationEnergy()
            << " Final4Momentum= " << GetFinalNucleusMomentum() << " capturMomentum= " << CapturedMomentum
            << G4endl;
#endif

    G4Fragment * fragment = new G4Fragment(a,z,GetFinalNucleusMomentum());
    fragment->SetNumberOfHoles(holes);

    //GF  fragment->SetNumberOfParticles(excitons-holes);
    fragment->SetNumberOfParticles(excitons);
    fragment->SetNumberOfCharged(zCaptured);

    return fragment;
}

//----------------------------------------------------------------------------

G4LorentzVector G4BinaryCascade::GetFinal4Momentum()
//----------------------------------------------------------------------------
// Return momentum of reminder nulceus;
//  ie. difference of (initial state(primaries+nucleus) - final state) particles, ignoring remnant nucleus
{
    G4LorentzVector final4Momentum = theInitial4Mom + theProjectile4Momentum;
    G4LorentzVector finals(0,0,0,0);
    for(G4KineticTrackVector::iterator i = theFinalState.begin(); i != theFinalState.end(); ++i)
    {
        final4Momentum -= (*i)->Get4Momentum();
        finals		   += (*i)->Get4Momentum();
    }

    if(final4Momentum.e()> 0 && (final4Momentum.vect()/final4Momentum.e()).mag()>1.0 && currentA > 0)
    {
#ifdef debug_BIC_Final4Momentum
        G4cerr << G4endl;
        G4cerr << "G4BinaryCascade::GetFinal4Momentum - Fatal"<<G4endl;
        G4KineticTrackVector::iterator i;
        G4cerr <<"Total initial 4-momentum " << theProjectile4Momentum << G4endl;
        G4cerr <<" GetFinal4Momentum: Initial nucleus "<<theInitial4Mom<<G4endl;
        for(i = theFinalState.begin(); i != theFinalState.end(); ++i)
        {
            G4cerr <<" Final state: "<<(*i)->Get4Momentum()<<(*i)->GetDefinition()->GetParticleName()<<G4endl;
        }
        G4cerr << "Sum( 4-mom ) finals " << finals << G4endl;
        G4cerr<< " Final4Momentum = "<<final4Momentum <<" "<<final4Momentum.m()<<G4endl;
        G4cerr <<" current A, Z = "<< currentA<<", "<<currentZ<<G4endl;
        G4cerr << G4endl;
#endif

        final4Momentum=G4LorentzVector(0,0,0,0);
    }
    return final4Momentum;
}

//----------------------------------------------------------------------------
G4LorentzVector G4BinaryCascade::GetFinalNucleusMomentum()
//----------------------------------------------------------------------------
{
    // return momentum of nucleus for use with precompound model; also keep transformation to
    //   apply to precompoud products.

    G4LorentzVector CapturedMomentum(0,0,0,0);
    G4KineticTrackVector::iterator i;
    //  G4cout << "GetFinalNucleusMomentum Captured size: " <<theCapturedList.size() << G4endl;
    for(i = theCapturedList.begin(); i != theCapturedList.end(); ++i)
    {
        CapturedMomentum += (*i)->Get4Momentum();
    }
    //G4cout << "GetFinalNucleusMomentum CapturedMomentum= " <<CapturedMomentum << G4endl;
    //  G4cerr << "it 9"<<G4endl;

    G4LorentzVector NucleusMomentum = GetFinal4Momentum();
    if ( NucleusMomentum.e() > 0 )
    {
        // G4cout << "GetFinalNucleusMomentum GetFinal4Momentum= " <<NucleusMomentum <<" "<<NucleusMomentum.mag()<<G4endl;
        // boost nucleus to a frame such that the momentum of nucleus == momentum of Captured
        G4ThreeVector boost= (NucleusMomentum.vect() -CapturedMomentum.vect())/NucleusMomentum.e();
        if(boost.mag2()>1.0)
        {
#     ifdef debug_BIC_FinalNucleusMomentum
            G4cerr << "G4BinaryCascade::GetFinalNucleusMomentum - Fatal"<<G4endl;
            G4cerr << "it 0"<<boost <<G4endl;
            G4cerr << "it 01"<<NucleusMomentum<<" "<<CapturedMomentum<<" "<<G4endl;
            G4cout <<" testing boost "<<boost<<" "<<boost.mag()<<G4endl;
#      endif
            boost=G4ThreeVector(0,0,0);
            NucleusMomentum=G4LorentzVector(0,0,0,0);
        }
        G4LorentzRotation  nucleusBoost( -boost );
        precompoundLorentzboost.set( boost );
#ifdef debug_debug_BIC_FinalNucleusMomentum
        G4cout << "GetFinalNucleusMomentum be4 boostNucleusMomentum, CapturedMomentum"<<NucleusMomentum<<" "<<CapturedMomentum<<" "<<G4endl;
#endif
        NucleusMomentum *= nucleusBoost;
#ifdef debug_BIC_FinalNucleusMomentum
        G4cout << "GetFinalNucleusMomentum aft boost GetFinal4Momentum= " <<NucleusMomentum <<G4endl;
#endif
    }
    return NucleusMomentum;
}

//----------------------------------------------------------------------------
G4ReactionProductVector * G4BinaryCascade::Propagate1H1(
        //----------------------------------------------------------------------------
        G4KineticTrackVector * secondaries, G4V3DNucleus * nucleus)
{
    G4ReactionProductVector * products = new G4ReactionProductVector;
    const G4ParticleDefinition * aHTarg = G4Proton::ProtonDefinition();
    if (nucleus->GetCharge() == 0) aHTarg = G4Neutron::NeutronDefinition();
    G4double mass = aHTarg->GetPDGMass();
    G4KineticTrackVector * secs = 0;
    G4ThreeVector pos(0,0,0);
    G4LorentzVector mom(mass);
    G4KineticTrack aTarget(aHTarg, 0., pos, mom);
    G4bool done(false);
    std::vector<G4KineticTrack *>::iterator iter, jter;
    // data member    static G4Scatterer theH1Scatterer;
    //G4cout << " start 1H1 for " << (*secondaries).front()->GetDefinition()->GetParticleName()
    //       << " on " << aHTarg->GetParticleName() << G4endl;
    G4int tryCount(0);
    while(!done && tryCount++ <200)                                 /* Loop checking, 31.08.2015, G.Folger */
    {
        if(secs)
        {
            std::for_each(secs->begin(), secs->end(), DeleteKineticTrack());
            delete secs;
        }
        secs = theH1Scatterer->Scatter(*(*secondaries).front(), aTarget);
#ifdef debug_H1_BinaryCascade
        PrintKTVector(secs," From Scatter");
#endif
        for(size_t ss=0; secs && ss<secs->size(); ss++)
        {
            // must have one resonance in final state, or it was elastic, not allowed here.
            if((*secs)[ss]->GetDefinition()->IsShortLived()) done = true;
        }
    }

    ClearAndDestroy(&theFinalState);
    ClearAndDestroy(secondaries);
    delete secondaries;

    for(size_t current=0; secs && current<secs->size(); current++)
    {
        if((*secs)[current]->GetDefinition()->IsShortLived())
        {
            done = true; 	// must have one resonance in final state, elastic not allowed here!
            G4KineticTrackVector * dec = (*secs)[current]->Decay();
            for(jter=dec->begin(); jter != dec->end(); jter++)
            {
                //G4cout << "Decay"<<G4endl;
                secs->push_back(*jter);
                //G4cout << "decay "<<(*jter)->GetDefinition()->GetParticleName()<<G4endl;
            }
            delete (*secs)[current];
            delete dec;
        }
        else
        {
            //G4cout << "FS "<<G4endl;
            //G4cout << "FS "<<(*secs)[current]->GetDefinition()->GetParticleName()<<G4endl;
            theFinalState.push_back((*secs)[current]);
        }
    }

    delete secs;
#ifdef debug_H1_BinaryCascade
    PrintKTVector(&theFinalState," FinalState");
#endif
    for(iter = theFinalState.begin(); iter != theFinalState.end(); ++iter)
    {
        G4KineticTrack * kt = *iter;
        G4ReactionProduct * aNew = new G4ReactionProduct(kt->GetDefinition());
        aNew->SetMomentum(kt->Get4Momentum().vect());
        aNew->SetTotalEnergy(kt->Get4Momentum().e());
        aNew->SetCreatorModel(theBIC_ID);
        products->push_back(aNew);
#ifdef debug_H1_BinaryCascade
        if (! kt->GetDefinition()->GetPDGStable() )
        {
            if (kt->GetDefinition()->IsShortLived())
            {
                G4cout << "final shortlived : ";
            } else
            {
                G4cout << "final un stable : ";
            }
            G4cout <<kt->GetDefinition()->GetParticleName()<< G4endl;
        }
#endif
        delete kt;
    }
    theFinalState.clear();
    return products;

}

//----------------------------------------------------------------------------
G4ThreeVector G4BinaryCascade::GetSpherePoint(
        G4double r, const G4LorentzVector & mom4)
//----------------------------------------------------------------------------
{
    //  Get a point outside radius.
    //     point is random in plane (circle of radius r) orthogonal to mom,
    //      plus -1*r*mom->vect()->unit();
    G4ThreeVector o1, o2;
    G4ThreeVector mom = mom4.vect();

    o1= mom.orthogonal();  // we simply need any vector non parallel
    o2= mom.cross(o1);     //  o2 is now orthogonal to mom and o1, ie. o1 and o2  define plane.

    G4double x2, x1;

    do
    {
        x1=(G4UniformRand()-.5)*2;
        x2=(G4UniformRand()-.5)*2;
    } while (sqr(x1) +sqr(x2) > 1.);                      /* Loop checking, 31.08.2015, G.Folger */ // or random is badly broken.....

    return G4ThreeVector(r*(x1*o1.unit() + x2*o2.unit() - 1.5* mom.unit()));



    /*
     * // Get a point uniformly distributed on the surface of a sphere,
     * // with z < 0.
     *   G4double b = r*G4UniformRand();  // impact parameter
     *   G4double phi = G4UniformRand()*2*pi;
     *   G4double x = b*std::cos(phi);
     *   G4double y = b*std::sin(phi);
     *   G4double z = -std::sqrt(r*r-b*b);
     *   z *= 1.001; // Get position a little bit out of the sphere...
     *   point.setX(x);
     *   point.setY(y);
     *   point.setZ(z);
     */
}

//----------------------------------------------------------------------------

void G4BinaryCascade::ClearAndDestroy(G4KineticTrackVector * ktv)
//----------------------------------------------------------------------------
{
    std::vector<G4KineticTrack *>::iterator i;
    for(i = ktv->begin(); i != ktv->end(); ++i)
        delete (*i);
    ktv->clear();
}

//----------------------------------------------------------------------------
void G4BinaryCascade::ClearAndDestroy(G4ReactionProductVector * rpv)
//----------------------------------------------------------------------------
{
    std::vector<G4ReactionProduct *>::iterator i;
    for(i = rpv->begin(); i != rpv->end(); ++i)
        delete (*i);
    rpv->clear();
}

//----------------------------------------------------------------------------
void G4BinaryCascade::PrintKTVector(G4KineticTrackVector * ktv, std::string comment)
//----------------------------------------------------------------------------
{
    if (comment.size() > 0 ) G4cout << "G4BinaryCascade::PrintKTVector() " << comment << G4endl;
    if (ktv) {
        G4cout << "  vector: " << ktv << ", number of tracks: " << ktv->size()
			         << G4endl;
        std::vector<G4KineticTrack *>::iterator i;
        G4int count;

        for(count = 0, i = ktv->begin(); i != ktv->end(); ++i, ++count)
        {
            G4KineticTrack * kt = *i;
            G4cout << "  track n. " << count;
            PrintKTVector(kt);
        }
    } else {
        G4cout << "G4BinaryCascade::PrintKTVector():No KineticTrackVector given " << G4endl;
    }
}
//----------------------------------------------------------------------------
void G4BinaryCascade::PrintKTVector(G4KineticTrack * kt, std::string comment)
//----------------------------------------------------------------------------
{
    if (comment.size() > 0 ) G4cout << "G4BinaryCascade::PrintKTVector() "<< comment << G4endl;
    if ( kt ){
        G4cout << ", id: " << kt << G4endl;
        G4ThreeVector pos = kt->GetPosition();
        G4LorentzVector mom = kt->Get4Momentum();
        G4LorentzVector tmom = kt->GetTrackingMomentum();
        const G4ParticleDefinition * definition = kt->GetDefinition();
        G4cout << "    definition: " << definition->GetPDGEncoding() << " pos: "
                << 1/fermi*pos << " R: " << 1/fermi*pos.mag() << " 4mom: "
                << 1/MeV*mom <<"Tr_mom" <<  1/MeV*tmom << " P: " << 1/MeV*mom.vect().mag()
                << " M: " << 1/MeV*mom.mag() << G4endl;
        G4cout <<"    trackstatus: "<<kt->GetState() << " isParticipant " << (kt->IsParticipant()?"T":"F")   <<G4endl;
    } else {
        G4cout << "G4BinaryCascade::PrintKTVector(): No Kinetictrack given" << G4endl;
    }
}


//----------------------------------------------------------------------------
G4double G4BinaryCascade::GetIonMass(G4int Z, G4int A)
//----------------------------------------------------------------------------
{
    G4double mass(0);
    if ( Z > 0 && A >= Z )
    {
        mass = G4ParticleTable::GetParticleTable()->GetIonTable()->GetIonMass(Z,A);

    } else if ( A > 0 && Z>0 )
    {
        // charge Z > A; will happen for light nuclei with pions involved.
        mass = G4ParticleTable::GetParticleTable()->GetIonTable()->GetIonMass(A,A);

    } else if ( A >= 0 && Z<=0 )
    {
        // all neutral, or empty nucleus
        mass = A * G4Neutron::Neutron()->GetPDGMass();

    } else if ( A == 0  )
    {
        // empty nucleus, except maybe pions
        mass = 0;

    } else
    {
        G4cerr << "G4BinaryCascade::GetIonMass() - invalid (A,Z) = ("
                << A << "," << Z << ")" <<G4endl;
        throw G4HadronicException(__FILE__, __LINE__, "G4BinaryCascade::GetIonMass() - giving up");

    }
	 //  G4cout << "G4BinaryCascade::GetIonMass() Z, A, mass " << Z << " " << A << " " << mass << G4endl;
    return mass;
}
G4ReactionProductVector * G4BinaryCascade::FillVoidNucleusProducts(G4ReactionProductVector * products)
{
    // return product when nucleus is destroyed, i.e. charge=0, or theTargetList.size()=0
    G4double Esecondaries(0.);
    G4LorentzVector psecondaries;
    std::vector<G4KineticTrack *>::iterator iter;
    std::vector<G4ReactionProduct *>::iterator rpiter;
    decayKTV.Decay(&theFinalState);

    for(iter = theFinalState.begin(); iter != theFinalState.end(); ++iter)
    {
        G4ReactionProduct * aNew = new G4ReactionProduct((*iter)->GetDefinition());
        aNew->SetMomentum((*iter)->Get4Momentum().vect());
        aNew->SetTotalEnergy((*iter)->Get4Momentum().e());
        aNew->SetCreatorModel(theBIC_ID);
        Esecondaries +=(*iter)->Get4Momentum().e();
        psecondaries +=(*iter)->Get4Momentum();
        aNew->SetNewlyAdded(true);
        //G4cout << " Particle Ekin " << aNew->GetKineticEnergy() << G4endl;
        products->push_back(aNew);
    }

    // pull out late particles from collisions
    //theCollisionMgr->Print();
    while(theCollisionMgr->Entries() > 0)        /* Loop checking, 31.08.2015, G.Folger */
    {
        G4CollisionInitialState *
        collision = theCollisionMgr->GetNextCollision();

        if ( ! collision->GetTargetCollection().size() ){
            G4KineticTrackVector * lates = collision->GetFinalState();
            if ( lates->size() == 1 ) {
                G4KineticTrack * atrack=*(lates->begin());
                //PrintKTVector(atrack, " late particle @ void Nucl ");

                G4ReactionProduct * aNew = new G4ReactionProduct(atrack->GetDefinition());
                aNew->SetMomentum(atrack->Get4Momentum().vect());
                aNew->SetTotalEnergy(atrack->Get4Momentum().e());
                // FIXME: should take creator model from atrack:
                // aNew->SetCreatorModel(atrack->GetCreatorModel());
                Esecondaries +=atrack->Get4Momentum().e();
                psecondaries +=atrack->Get4Momentum();
                aNew->SetNewlyAdded(true);
                products->push_back(aNew);

            }
        }
        theCollisionMgr->RemoveCollision(collision);

    }

    // decay must be after loop on Collisions, and Decay() will delete entries in theSecondaryList, refered
    //   to by Collisions.
    decayKTV.Decay(&theSecondaryList);

    // Correct for momentum transfered to Nucleus
    G4ThreeVector transferCorrection(0);
    if ( (theSecondaryList.size() + theCapturedList.size()) > 0)
    {
    	transferCorrection= theMomentumTransfer /(theSecondaryList.size() + theCapturedList.size());
    }

    for(iter = theSecondaryList.begin(); iter != theSecondaryList.end(); ++iter)
    {
        G4ReactionProduct * aNew = new G4ReactionProduct((*iter)->GetDefinition());
        (*iter)->Update4Momentum((*iter)->Get4Momentum().vect()+transferCorrection);
        aNew->SetMomentum((*iter)->Get4Momentum().vect());
        aNew->SetTotalEnergy((*iter)->Get4Momentum().e());
        aNew->SetCreatorModel(theBIC_ID);
        Esecondaries +=(*iter)->Get4Momentum().e();
        psecondaries +=(*iter)->Get4Momentum();
        if ( (*iter)->IsParticipant() ) aNew->SetNewlyAdded(true);
        products->push_back(aNew);
    }


    for(iter = theCapturedList.begin(); iter != theCapturedList.end(); ++iter)
    {
        G4ReactionProduct * aNew = new G4ReactionProduct((*iter)->GetDefinition());
        (*iter)->Update4Momentum((*iter)->Get4Momentum().vect()+transferCorrection);
        aNew->SetMomentum((*iter)->Get4Momentum().vect());
        aNew->SetTotalEnergy((*iter)->Get4Momentum().e());
        aNew->SetCreatorModel(theBIC_ID);
        Esecondaries +=(*iter)->Get4Momentum().e();
        psecondaries +=(*iter)->Get4Momentum();
        aNew->SetNewlyAdded(true);
        products->push_back(aNew);
    }

    G4double SumMassNucleons(0.);
    G4LorentzVector pNucleons(0.);
    for(iter = theTargetList.begin(); iter != theTargetList.end(); ++iter)
    {
        SumMassNucleons += (*iter)->GetDefinition()->GetPDGMass();
        pNucleons += (*iter)->Get4Momentum();
    }

    G4double Ekinetic=theProjectile4Momentum.e() + initial_nuclear_mass - Esecondaries - SumMassNucleons;
     #ifdef debug_BIC_FillVoidnucleus
        G4LorentzVector deltaP=theProjectile4Momentum + G4LorentzVector(initial_nuclear_mass) -
    		                psecondaries - pNucleons;
        //G4cout << "BIC::FillVoidNucleus() nucleons : "<<theTargetList.size() << " ,  T: " << Ekinetic <<
    	//	     ", deltaP " <<  deltaP << " deltaPNoNucl " << deltaP + pNucleons << G4endl;
     #endif
    if (Ekinetic > 0. && theTargetList.size()){
        Ekinetic /= theTargetList.size();
    } else {
        G4double Ekineticrdm(0);
        if (theTargetList.size()) Ekineticrdm = ( 0.1 + G4UniformRand()*5.) * MeV;	// leave some  Energy for Nucleons
      	G4double TotalEkin(Ekineticrdm);
        for (rpiter=products->begin(); rpiter!=products->end(); ++rpiter){
        	TotalEkin+=(*rpiter)->GetKineticEnergy();
        }
        G4double correction(1.);
        if ( std::abs(Ekinetic) < 20*perCent * TotalEkin ){
        	correction=1. + (Ekinetic-Ekineticrdm)/TotalEkin;   // Ekinetic < 0 == IS < FS, need to reduce energies
        }
        #ifdef debug_G4BinaryCascade
			else {
				G4cout << "BLIC::FillVoidNucleus() fail correction, Ekinetic, TotalEkin " << Ekinetic << ""<< TotalEkin << G4endl;
			}
        #endif

        for (rpiter=products->begin(); rpiter!=products->end(); ++rpiter){
	    	(*rpiter)->SetKineticEnergy((*rpiter)->GetKineticEnergy()*correction);  // this sets kinetic & total energy
        	(*rpiter)->SetMomentum((*rpiter)->GetTotalMomentum() * (*rpiter)->GetMomentum().unit());

        }

        Ekinetic=Ekineticrdm*correction;
        if (theTargetList.size())Ekinetic /= theTargetList.size();

	}

    for(iter = theTargetList.begin(); iter != theTargetList.end(); ++iter) {
    	// set Nucleon it to be hit - as it is in fact
    	(*iter)->Hit();
        G4ReactionProduct * aNew = new G4ReactionProduct((*iter)->GetDefinition());
        aNew->SetKineticEnergy(Ekinetic);
        aNew->SetMomentum(aNew->GetTotalMomentum() * ((*iter)->Get4Momentum().vect().unit()));
        aNew->SetNewlyAdded(true);
        aNew->SetCreatorModel(theBIC_ID);
        products->push_back(aNew);
        Esecondaries += aNew->GetTotalEnergy();
        psecondaries += G4LorentzVector(aNew->GetMomentum(),aNew->GetTotalEnergy() );
    }
    psecondaries=G4LorentzVector(0);
    for (rpiter=products->begin(); rpiter!=products->end(); ++rpiter){
    	psecondaries += G4LorentzVector((*rpiter)->GetMomentum(),(*rpiter)->GetTotalEnergy() );
    }



    G4LorentzVector initial4Mom=theProjectile4Momentum + G4LorentzVector(initial_nuclear_mass);

    //G4cout << "::FillVoidNucleus()final e/p conservation initial" <<initial4Mom
    //	<< " final " << psecondaries << " delta " << initial4Mom-psecondaries << G4endl;

    G4ThreeVector SumMom=psecondaries.vect();

    SumMom=initial4Mom.vect()-SumMom;
    G4int loopcount(0);

    std::vector<G4ReactionProduct *>::reverse_iterator reverse;  // start to correct last added first
    while ( SumMom.mag() > 0.1*MeV && loopcount++ < 10)           /* Loop checking, 31.08.2015, G.Folger */
    {
	 	G4int index=products->size();
		for (reverse=products->rbegin(); reverse!=products->rend(); ++reverse, --index){
			SumMom=initial4Mom.vect();
			for (rpiter=products->begin(); rpiter!=products->end(); ++rpiter){
				SumMom-=(*rpiter)->GetMomentum();
			}

			G4double p=((*reverse)->GetMomentum()).mag();
			(*reverse)->SetMomentum(  p*(((*reverse)->GetMomentum()+SumMom).unit()));

		}
    }


    return products;
}
G4ReactionProductVector * G4BinaryCascade::HighEnergyModelFSProducts(G4ReactionProductVector * products,
        G4KineticTrackVector * secondaries)
{
    std::vector<G4KineticTrack *>::iterator iter;
    for(iter = secondaries->begin(); iter != secondaries->end(); ++iter)
    {
        G4ReactionProduct * aNew = new G4ReactionProduct((*iter)->GetDefinition());
        aNew->SetMomentum((*iter)->Get4Momentum().vect());
        aNew->SetTotalEnergy((*iter)->Get4Momentum().e());
        aNew->SetNewlyAdded(true);
        // FixMe: should take creator model from atrack:
        // aNew->SetCreatorModel(atrack->GetCreatorModel());

        //G4cout << " Particle Ekin " << aNew->GetKineticEnergy() << G4endl;
        products->push_back(aNew);
    }
    const G4ParticleDefinition* fragment = 0;
    if (currentA == 1 && currentZ == 0) {
        fragment = G4Neutron::NeutronDefinition();
    } else if (currentA == 1 && currentZ == 1) {
        fragment = G4Proton::ProtonDefinition();
    } else if (currentA == 2 && currentZ == 1) {
        fragment = G4Deuteron::DeuteronDefinition();
    } else if (currentA == 3 && currentZ == 1) {
        fragment = G4Triton::TritonDefinition();
    } else if (currentA == 3 && currentZ == 2) {
        fragment = G4He3::He3Definition();
    } else if (currentA == 4 && currentZ == 2) {
        fragment = G4Alpha::AlphaDefinition();;
    } else {
        fragment =
                G4ParticleTable::GetParticleTable()->GetIonTable()->GetIon(currentZ,currentA,0.0);
    }
    if (fragment != 0) {
        G4ReactionProduct * theNew = new G4ReactionProduct(fragment);
        theNew->SetMomentum(G4ThreeVector(0,0,0));
        theNew->SetTotalEnergy(massInNucleus);
        // FixMe: should take creator model from ???:
        // aNew->SetCreatorModel(???->GetCreatorModel());
        //theNew->SetFormationTime(??0.??);
        //G4cout << " Nucleus (" << currentZ << ","<< currentA << "), mass "<< massInNucleus << G4endl;
        products->push_back(theNew);
    }
    return products;
}

void G4BinaryCascade::PrintWelcomeMessage()
{
    G4cout <<"Thank you for using G4BinaryCascade. "<<G4endl;
}

//----------------------------------------------------------------------------
void G4BinaryCascade::DebugApplyCollisionFail(G4CollisionInitialState * collision,
      G4KineticTrackVector * products)
{
   G4bool havePion=false;
   if (products)
   {
      for ( std::vector<G4KineticTrack *>::iterator i =products->begin(); i != products->end(); i++)
      {
         G4int PDGcode=std::abs((*i)->GetDefinition()->GetPDGEncoding());
         if (std::abs(PDGcode)==211 || PDGcode==111 ) havePion=true;
      }
   }
   if ( !products  || havePion)
   {
		const G4BCAction &action= *collision->GetGenerator();
      G4cout << " Collision " << collision << ", type: "<< typeid(action).name()
							                    << ", with NO products! " <<G4endl;
      G4cout << G4endl<<"Initial condition are these:"<<G4endl;
      G4cout << "proj: "<<collision->GetPrimary()->GetDefinition()->GetParticleName()<<G4endl;
      PrintKTVector(collision->GetPrimary());
      for(size_t it=0; it<collision->GetTargetCollection().size(); it++)
      {
         G4cout << "targ: "
               <<collision->GetTargetCollection()[it]->GetDefinition()->GetParticleName()<<G4endl;
      }
      PrintKTVector(&collision->GetTargetCollection(),std::string(" Target particles"));
   }
   //  if ( lateParticleCollision ) G4cout << " Added late particle--------------------------"<<G4endl;
   //  if ( lateParticleCollision && products ) PrintKTVector(products, " reaction products");
}

//----------------------------------------------------------------------------

G4bool G4BinaryCascade::CheckChargeAndBaryonNumber(G4String where)
{
   static G4int lastdA(0), lastdZ(0);
   G4int iStateA = the3DNucleus->GetMassNumber() + projectileA;
   G4int iStateZ = the3DNucleus->GetCharge()  + projectileZ;

   G4int fStateA(0);
   G4int fStateZ(0);

   std::vector<G4KineticTrack *>::iterator i;
   G4int CapturedA(0), CapturedZ(0);
   G4int secsA(0), secsZ(0);
   for ( i=theCapturedList.begin(); i!=theCapturedList.end(); ++i) {
      CapturedA += (*i)->GetDefinition()->GetBaryonNumber();
      CapturedZ += G4lrint((*i)->GetDefinition()->GetPDGCharge()/eplus);
   }

   for ( i=theSecondaryList.begin(); i!=theSecondaryList.end(); ++i) {
      if ( (*i)->GetState() != G4KineticTrack::inside ) {
         secsA += (*i)->GetDefinition()->GetBaryonNumber();
         secsZ += G4lrint((*i)->GetDefinition()->GetPDGCharge()/eplus);
      }
   }

   for ( i=theFinalState.begin(); i!=theFinalState.end(); ++i) {
      fStateA += (*i)->GetDefinition()->GetBaryonNumber();
      fStateZ += G4lrint((*i)->GetDefinition()->GetPDGCharge()/eplus);
   }

   G4int deltaA= iStateA -  secsA - fStateA -currentA - lateA;
   G4int deltaZ= iStateZ -  secsZ - fStateZ -currentZ - lateZ;

#ifdef debugCheckChargeAndBaryonNumberverbose	
	G4cout << where <<" A: iState= "<< iStateA<<", secs= "<< secsA<< ", fState= "<< fStateA<< ", current= "<<currentA<< ", late= " <<lateA << G4endl;   
	G4cout << where <<" Z: iState= "<< iStateZ<<", secs= "<< secsZ<< ", fState= "<< fStateZ<< ", current= "<<currentZ<< ", late= " <<lateZ << G4endl;   
#endif

   if (deltaA != 0  || deltaZ!=0 ) {
      if (deltaA != lastdA || deltaZ != lastdZ ) {
         G4cout << "baryon/charge imbalance - " << where << G4endl
               << "deltaA " <<deltaA<<", iStateA "<<iStateA<< ",  CapturedA "<<CapturedA <<",  secsA "<<secsA
               << ", fStateA "<<fStateA << ", currentA "<<currentA << ", lateA "<<lateA << G4endl
               << "deltaZ "<<deltaZ<<", iStateZ "<<iStateZ<< ",  CapturedZ "<<CapturedZ <<",  secsZ "<<secsZ
               << ", fStateZ "<<fStateZ << ", currentZ "<<currentZ << ", lateZ "<<lateZ << G4endl<< G4endl;
         lastdA=deltaA;
         lastdZ=deltaZ;
      }
   } else { lastdA=lastdZ=0;}

   return true;
}
//----------------------------------------------------------------------------
void G4BinaryCascade::DebugApplyCollision(G4CollisionInitialState * collision,
        G4KineticTrackVector * products)
{

    PrintKTVector(collision->GetPrimary(),std::string(" Primary particle"));
    PrintKTVector(&collision->GetTargetCollection(),std::string(" Target particles"));
    PrintKTVector(products,std::string(" Scatterer products"));

#ifdef dontUse
    G4double thisExcitation(0);
    //  excitation energy from this collision
    //  initial state:
    G4double initial(0);
    G4KineticTrack * kt=collision->GetPrimary();
    initial +=  kt->Get4Momentum().e();

    G4RKPropagation * RKprop=(G4RKPropagation *)thePropagator;

    initial +=  RKprop->GetField(kt->GetDefinition()->GetPDGEncoding(),kt->GetPosition());
    initial -=  RKprop->GetBarrier(kt->GetDefinition()->GetPDGEncoding());
    G4cout << "prim. E/field/Barr/Sum " << kt->Get4Momentum().e()
        		          << " " << RKprop->GetField(kt->GetDefinition()->GetPDGEncoding(),kt->GetPosition())
        		          << " " << RKprop->GetBarrier(kt->GetDefinition()->GetPDGEncoding())
        		          << " " << initial << G4endl;;

    G4KineticTrackVector ktv=collision->GetTargetCollection();
    for ( unsigned int it=0; it < ktv.size(); it++)
    {
        kt=ktv[it];
        initial +=  kt->Get4Momentum().e();
        thisExcitation += kt->GetDefinition()->GetPDGMass()
     		    		         - kt->Get4Momentum().e()
     		    		         - RKprop->GetField(kt->GetDefinition()->GetPDGEncoding(),kt->GetPosition());
        //     initial +=  RKprop->GetField(kt->GetDefinition()->GetPDGEncoding(),kt->GetPosition());
        //     initial -=  RKprop->GetBarrier(kt->GetDefinition()->GetPDGEncoding());
        G4cout << "Targ. def/E/field/Barr/Sum " <<  kt->GetDefinition()->GetPDGEncoding()
  			          << " " << kt->Get4Momentum().e()
  			          << " " << RKprop->GetField(kt->GetDefinition()->GetPDGEncoding(),kt->GetPosition())
  			          << " " << RKprop->GetBarrier(kt->GetDefinition()->GetPDGEncoding())
  			          << " " << initial <<" Excit " << thisExcitation << G4endl;;
    }

    G4double final(0);
    G4double mass_out(0);
    G4int product_barions(0);
    if ( products )
    {
        for ( unsigned int it=0; it < products->size(); it++)
        {
            kt=(*products)[it];
            final +=  kt->Get4Momentum().e();
            final +=  RKprop->GetField(kt->GetDefinition()->GetPDGEncoding(),kt->GetPosition());
            final +=  RKprop->GetBarrier(kt->GetDefinition()->GetPDGEncoding());
            if ( kt->GetDefinition()->GetBaryonNumber()==1 ) product_barions++;
            mass_out += kt->GetDefinition()->GetPDGMass();
            G4cout << "sec. def/E/field/Barr/Sum " << kt->GetDefinition()->GetPDGEncoding()
  	    		         << " " << kt->Get4Momentum().e()
  	    		         << " " << RKprop->GetField(kt->GetDefinition()->GetPDGEncoding(),kt->GetPosition())
  	    		         << " " << RKprop->GetBarrier(kt->GetDefinition()->GetPDGEncoding())
  	    		         << " " << final << G4endl;;
        }
    }


    G4int finalA = currentA;
    G4int finalZ = currentZ;
    if ( products )
    {
        finalA -= product_barions;
        finalZ -= GetTotalCharge(*products);
    }
    G4double delta = GetIonMass(currentZ,currentA) - (GetIonMass(finalZ,finalA) + mass_out);
    G4cout << " current/final a,z " << currentA << " " << currentZ << " "<< finalA<< " "<< finalZ
            <<  " delta-mass " << delta<<G4endl;
    final+=delta;
    mass_out  = GetIonMass(finalZ,finalA);
    G4cout << " initE/ E_out/ Mfinal/ Excit " << currentInitialEnergy
            << " " <<   final << " "
            <<  mass_out<<" "
            <<  currentInitialEnergy - final - mass_out
            << G4endl;
    currentInitialEnergy-=final;
#endif
}

//----------------------------------------------------------------------------
G4bool G4BinaryCascade::DebugFinalEpConservation(const G4HadProjectile & aTrack,
        G4ReactionProductVector* products)
//----------------------------------------------------------------------------
{
    G4ReactionProductVector::iterator iter;
    G4double Efinal(0);
    G4ThreeVector pFinal(0);
    if (std::abs(theParticleChange.GetWeightChange() -1 ) > 1e-5 )
    {
        G4cout <<" BIC-weight change " << theParticleChange.GetWeightChange()<< G4endl;
    }

    for(iter = products->begin(); iter != products->end(); ++iter)
    {

           G4cout << " Secondary E - Ekin / p " <<
              (*iter)->GetDefinition()->GetParticleName() << " " <<
              (*iter)->GetTotalEnergy() << " - " <<
              (*iter)->GetKineticEnergy()<< " / " <<
              (*iter)->GetMomentum().x() << " " <<
              (*iter)->GetMomentum().y() << " " <<
              (*iter)->GetMomentum().z() << G4endl;
        Efinal += (*iter)->GetTotalEnergy();
        pFinal += (*iter)->GetMomentum();
    }

      G4cout << "e outgoing/ total : " << Efinal << " " << Efinal+GetFinal4Momentum().e()<< G4endl;
      G4cout << "BIC E/p delta " <<
            (aTrack.Get4Momentum().e()+theInitial4Mom.e() - Efinal)/MeV <<
            " MeV / mom " << (aTrack.Get4Momentum()  - pFinal ) /MeV << G4endl;

    return (aTrack.Get4Momentum().e() + theInitial4Mom.e() - Efinal)/aTrack.Get4Momentum().e() < perCent;

}
//----------------------------------------------------------------------------
G4bool G4BinaryCascade::DebugEpConservation(const G4String where)
//----------------------------------------------------------------------------
{
    G4cout << where << G4endl;
    G4LorentzVector psecs,    ptgts,    pcpts,    pfins;
    if (std::abs(theParticleChange.GetWeightChange() -1 ) > 1e-5 )
    {
        G4cout <<" BIC-weight change " << theParticleChange.GetWeightChange()<< G4endl;
    }

    std::vector<G4KineticTrack *>::iterator ktiter;
    for(ktiter = theSecondaryList.begin(); ktiter != theSecondaryList.end(); ++ktiter)
       {

              G4cout << " Secondary E - Ekin / p " <<
                 (*ktiter)->GetDefinition()->GetParticleName() << " " <<
                 (*ktiter)->Get4Momentum().e() << " - " <<
                 (*ktiter)->Get4Momentum().e() - (*ktiter)->Get4Momentum().mag() << " / " <<
                 (*ktiter)->Get4Momentum().vect() << G4endl;
           psecs += (*ktiter)->Get4Momentum();
       }

    for(ktiter = theTargetList.begin(); ktiter != theTargetList.end(); ++ktiter)
       {

              G4cout << " Target E - Ekin / p " <<
                 (*ktiter)->GetDefinition()->GetParticleName() << " " <<
                 (*ktiter)->Get4Momentum().e() << " - " <<
                 (*ktiter)->Get4Momentum().e() - (*ktiter)->Get4Momentum().mag() << " / " <<
                 (*ktiter)->Get4Momentum().vect() << G4endl;
           ptgts += (*ktiter)->Get4Momentum();
       }

    for(ktiter = theCapturedList.begin(); ktiter != theCapturedList.end(); ++ktiter)
        {

               G4cout << " Captured E - Ekin / p " <<
                  (*ktiter)->GetDefinition()->GetParticleName() << " " <<
                  (*ktiter)->Get4Momentum().e() << " - " <<
                  (*ktiter)->Get4Momentum().e() - (*ktiter)->Get4Momentum().mag() << " / " <<
                  (*ktiter)->Get4Momentum().vect() << G4endl;
            pcpts += (*ktiter)->Get4Momentum();
        }

    for(ktiter = theFinalState.begin(); ktiter != theFinalState.end(); ++ktiter)
        {

               G4cout << " Finals E - Ekin / p " <<
                  (*ktiter)->GetDefinition()->GetParticleName() << " " <<
                  (*ktiter)->Get4Momentum().e() << " - " <<
                  (*ktiter)->Get4Momentum().e() - (*ktiter)->Get4Momentum().mag() << " / " <<
                  (*ktiter)->Get4Momentum().vect() << G4endl;
            pfins += (*ktiter)->Get4Momentum();
        }

      G4cout << " Secondaries " << psecs << ", Targets " << ptgts << G4endl
    		  <<" Captured    " << pcpts << ", Finals  " << pfins << G4endl
    		  <<" Sum " << psecs + ptgts + pcpts + pfins << " PTransfer " << theMomentumTransfer
    		  <<" Sum+PTransfer " << psecs + ptgts + pcpts + pfins + theMomentumTransfer
    		  << G4endl<< G4endl;


    return true;

}

//----------------------------------------------------------------------------
G4ReactionProductVector * G4BinaryCascade::ProductsAddFakeGamma(G4ReactionProductVector *products )
//----------------------------------------------------------------------------
{
   //    else
//    {
//        G4ReactionProduct * aNew=0;
//        // return nucleus e and p
//        if  (fragment != 0 ) {
//            aNew = new G4ReactionProduct(G4Gamma::GammaDefinition());   // we only want to pass e/p
//            aNew->SetMomentum(fragment->GetMomentum().vect());
//            aNew->SetTotalEnergy(fragment->GetMomentum().e());
//            delete fragment;
//            fragment=0;
//        } else if (products->size() == 0) {
//            // FixMe GF: for testing without precompound, return 1 gamma of 0.01 MeV in +x
//#include "G4Gamma.hh"
//            aNew = new G4ReactionProduct(G4Gamma::GammaDefinition());
//            aNew->SetMomentum(G4ThreeVector(0.01*MeV,0,0));
//            aNew->SetTotalEnergy(0.01*MeV);
//        }
//        if ( aNew != 0 ) products->push_back(aNew);
//    }
   return products;
}

//----------------------------------------------------------------------------