G4KineticTrack.cc

이 파일의 문서화 페이지로 가기

//
// ********************************************************************
// * 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.          *
// ********************************************************************
//
//
// -----------------------------------------------------------------------------
//      GEANT 4 class implementation file
//
//      History: first implementation, A. Feliciello, 20th May 1998
// -----------------------------------------------------------------------------

#include "globals.hh"
#include "G4ios.hh"
//#include <cmath>

#include "Randomize.hh"
#include "G4SimpleIntegration.hh"
#include "G4ThreeVector.hh"
#include "G4LorentzVector.hh"
#include "G4KineticTrack.hh"
#include "G4KineticTrackVector.hh"
#include "G4ParticleDefinition.hh"
#include "G4DecayTable.hh"
#include "G4GeneralPhaseSpaceDecay.hh"
#include "G4DecayProducts.hh"
#include "G4LorentzRotation.hh"
#include "G4SampleResonance.hh"
#include "G4Integrator.hh"
#include "G4KaonZero.hh"
#include "G4KaonZeroShort.hh"
#include "G4KaonZeroLong.hh"
#include "G4AntiKaonZero.hh"

#include "G4HadTmpUtil.hh"

//
// Some static clobal for integration
//

static G4ThreadLocal G4double  G4KineticTrack_Gmass, G4KineticTrack_xmass1;

//
//   Default constructor
//

G4KineticTrack::G4KineticTrack() :
                theDefinition(0),
                theFormationTime(0),
                thePosition(0),
                the4Momentum(0),
    theFermi3Momentum(0),
    theTotal4Momentum(0),
    theNucleon(0),
                nChannels(0),
                theActualMass(0),            
                theActualWidth(0),            
                theDaughterMass(0),
                theDaughterWidth(0),
    theStateToNucleus(undefined),
    theProjectilePotential(0)
{
//    DEBUG   //

/*
 G4cerr << G4endl << G4endl << G4endl;
 G4cerr << "   G4KineticTrack default constructor invoked! \n";
 G4cerr << "   =========================================== \n" << G4endl;
*/
}



//
//   Copy constructor
//

G4KineticTrack::G4KineticTrack(const G4KineticTrack &right) : G4VKineticNucleon()
{
 G4int i;
 theDefinition = right.GetDefinition();
 theFormationTime = right.GetFormationTime();
 thePosition = right.GetPosition();
 the4Momentum = right.GetTrackingMomentum();
 theFermi3Momentum = right.theFermi3Momentum;
 theTotal4Momentum = right.theTotal4Momentum;
 theNucleon=right.theNucleon;
 nChannels = right.GetnChannels();
 theActualMass = right.GetActualMass();
 theActualWidth = new G4double[nChannels];
 for (i = 0; i < nChannels; i++)
  {
    theActualWidth[i] = right.theActualWidth[i];
  }
  theDaughterMass = 0;
  theDaughterWidth = 0;
  theStateToNucleus=right.theStateToNucleus;
  theProjectilePotential=right.theProjectilePotential;
 
//    DEBUG   //

/*
 G4cerr << G4endl << G4endl << G4endl;
 G4cerr << "   G4KineticTrack copy constructor invoked! \n";
 G4cerr << "   ======================================== \n" <<G4endl;
*/
}


//
//   By argument constructor
//

G4KineticTrack::G4KineticTrack(const G4ParticleDefinition* aDefinition,
                               G4double aFormationTime,
                               const G4ThreeVector& aPosition,
                               const G4LorentzVector& a4Momentum) :
                theDefinition(aDefinition),
    theFormationTime(aFormationTime),
                thePosition(aPosition),
                the4Momentum(a4Momentum),
    theFermi3Momentum(0),
    theTotal4Momentum(a4Momentum),
    theNucleon(0),
    theStateToNucleus(undefined),
    theProjectilePotential(0)
{
  if(G4KaonZero::KaonZero() == theDefinition ||
    G4AntiKaonZero::AntiKaonZero() == theDefinition)
  {
    if(G4UniformRand()<0.5)
    {
      theDefinition = G4KaonZeroShort::KaonZeroShort();
    }
    else
    {
      theDefinition = G4KaonZeroLong::KaonZeroLong();
    }
  }

//
//      Get the number of decay channels
//

 G4DecayTable* theDecayTable = theDefinition->GetDecayTable();
 if (theDecayTable != 0)
    {
     nChannels = theDecayTable->entries();

    }
 else
    {
     nChannels = 0;
    }  

//
//   Get the actual mass value
//

 theActualMass = GetActualMass();

//
//   Create an array to Store the actual partial widths 
//   of the decay channels
//

  theDaughterMass = 0;
  theDaughterWidth = 0;
  theActualWidth = 0;
  G4bool * theDaughterIsShortLived = 0;
  
  if(nChannels!=0) theActualWidth = new G4double[nChannels];

  //  cout << " ****CONSTR*** ActualMass ******* " << theActualMass << G4endl;
  G4int index;
  for (index = nChannels - 1; index >= 0; index--)
    {
      G4VDecayChannel* theChannel = theDecayTable->GetDecayChannel(index);
      G4int nDaughters = theChannel->GetNumberOfDaughters();
      G4double theMotherWidth;
      if (nDaughters == 2 || nDaughters == 3) 
  {
          G4double thePoleMass  = theDefinition->GetPDGMass();
          theMotherWidth = theDefinition->GetPDGWidth();
          G4double thePoleWidth = theChannel->GetBR()*theMotherWidth;
          const G4ParticleDefinition* aDaughter;
          theDaughterMass = new G4double[nDaughters];
          theDaughterWidth = new G4double[nDaughters];
    theDaughterIsShortLived = new G4bool[nDaughters];
          G4int n;
          for (n = 0; n < nDaughters; n++)
      {
              aDaughter = theChannel->GetDaughter(n);
              theDaughterMass[n] = aDaughter->GetPDGMass();
              theDaughterWidth[n] = aDaughter->GetPDGWidth();
        theDaughterIsShortLived[n] = aDaughter->IsShortLived();
      }     
    
//
//           Check whether both the decay products are stable
//

          G4double theActualMom = 0.0;
          G4double thePoleMom = 0.0;
    G4SampleResonance aSampler;
    if (nDaughters==2) 
      {
        if ( !theDaughterIsShortLived[0] && !theDaughterIsShortLived[1] )
    {
      
      //              G4cout << G4endl << "Both the " << nDaughters <<
      //                              " decay products are stable!";
      //                 cout << " LB: Both decay products STABLE !" << G4endl;
      //                 cout << " parent:     " << theChannel->GetParentName() << G4endl;
      //                 cout << " particle1:  " << theChannel->GetDaughterName(0) << G4endl;
      //                 cout << " particle2:  " << theChannel->GetDaughterName(1) << G4endl;
      
      theActualMom = EvaluateCMMomentum(theActualMass, 
                theDaughterMass);   
      thePoleMom = EvaluateCMMomentum(thePoleMass, 
              theDaughterMass);
      //        cout << G4endl;
      //        cout << " LB: ActualMass/DaughterMass  " << theActualMass << "   " << theDaughterMass << G4endl; 
      //        cout << " LB: ActualMom " << theActualMom << G4endl;
      //        cout << " LB: PoleMom   " << thePoleMom << G4endl;
      //        cout << G4endl;
    }
        else if ( !theDaughterIsShortLived[0] && theDaughterIsShortLived[1] )   
    {
      
      //              G4cout << G4endl << "Only the first of the " << nDaughters <<" decay products is stable!";
      //         cout << " LB: only the first decay product is STABLE !" << G4endl;
      //         cout << " parent:     " << theChannel->GetParentName() << G4endl;
      //         cout << " particle1:  " << theChannel->GetDaughterName(0) << G4endl;
      //         cout << " particle2:  " << theChannel->GetDaughterName(1) << G4endl;
      
// global variable definition
      G4double lowerLimit = aSampler.GetMinimumMass(theChannel->GetDaughter(1));
      theActualMom = IntegrateCMMomentum(lowerLimit);
      thePoleMom = IntegrateCMMomentum(lowerLimit, thePoleMass);
      //        cout << " LB Parent Mass = " <<  G4KineticTrack_Gmass << G4endl;
      //        cout << " LB Actual Mass = " << theActualMass << G4endl;
      //        cout << " LB Daughter1 Mass = " <<  G4KineticTrack_Gmass1 << G4endl;
      //        cout << " LB Daughter2 Mass = " <<  G4KineticTrack_Gmass2 << G4endl;
      //        cout << " The Actual Momentum = " << theActualMom << G4endl;
      //        cout << " The Pole Momentum   = " << thePoleMom << G4endl;
      //        cout << G4endl;
      
    }        
        else if ( theDaughterIsShortLived[0] && !theDaughterIsShortLived[1] )   
    {
      
      //              G4cout << G4endl << "Only the second of the " << nDaughters <<
      //                              " decay products is stable!";
      //                 cout << " LB: only the second decay product is STABLE !" << G4endl;
      //         cout << " parent:     " << theChannel->GetParentName() << G4endl;
      //         cout << " particle1:  " << theChannel->GetDaughterName(0) << G4endl;
      //         cout << " particle2:  " << theChannel->GetDaughterName(1) << G4endl;
      
//
//               Swap the content of the theDaughterMass and theDaughterWidth arrays!!!
//
      
      G4SwapObj(theDaughterMass, theDaughterMass + 1);
      G4SwapObj(theDaughterWidth, theDaughterWidth + 1);
      
// global variable definition
      G4double lowerLimit = aSampler.GetMinimumMass(theChannel->GetDaughter(0));
      theActualMom = IntegrateCMMomentum(lowerLimit);
      thePoleMom = IntegrateCMMomentum(lowerLimit, thePoleMass);
      //        cout << " LB Parent Mass = " <<  G4KineticTrack_Gmass << G4endl;
      //        cout << " LB Actual Mass = " << theActualMass << G4endl;
      //        cout << " LB Daughter1 Mass = " <<  G4KineticTrack_Gmass1 << G4endl;
      //        cout << " LB Daughter2 Mass = " <<  G4KineticTrack_Gmass2 << G4endl;
      //        cout << " The Actual Momentum = " << theActualMom << G4endl;
      //        cout << " The Pole Momentum   = " << thePoleMom << G4endl;
      //              cout << G4endl;
      
    }        
        else if ( theDaughterIsShortLived[0] && theDaughterIsShortLived[1] )   
    {
         
//              G4cout << G4endl << "Both the " << nDaughters <<
//                              " decay products are resonances!";
      //         cout << " LB: both decay products are RESONANCES !" << G4endl;
      //         cout << " parent:     " << theChannel->GetParentName() << G4endl;
      //         cout << " particle1:  " << theChannel->GetDaughterName(0) << G4endl;
      //         cout << " particle2:  " << theChannel->GetDaughterName(1) << G4endl;
      
// global variable definition
      G4KineticTrack_Gmass = theActualMass;
      theActualMom = IntegrateCMMomentum2();
      G4KineticTrack_Gmass = thePoleMass;
      thePoleMom = IntegrateCMMomentum2();
      //        cout << " LB Parent Mass = " <<  G4KineticTrack_Gmass << G4endl;
      //        cout << " LB Daughter1 Mass = " <<  G4KineticTrack_Gmass1 << G4endl;
      //        cout << " LB Daughter2 Mass = " <<  G4KineticTrack_Gmass2 << G4endl;
      //              cout << " The Actual Momentum = " << theActualMom << G4endl;
      //              cout << " The Pole Momentum   = " << thePoleMom << G4endl;
      //              cout << G4endl;
      
    }        
      } 
    else  // (nDaughter==3)
      {
        
        G4int nShortLived = 0;
        if ( theDaughterIsShortLived[0] ) 
    { 
      nShortLived++; 
    }
        if ( theDaughterIsShortLived[1] )
    { 
      nShortLived++; 
      G4SwapObj(theDaughterMass, theDaughterMass + 1);
      G4SwapObj(theDaughterWidth, theDaughterWidth + 1);      
    }
        if ( theDaughterIsShortLived[2] )
    { 
      nShortLived++; 
      G4SwapObj(theDaughterMass, theDaughterMass + 2);
      G4SwapObj(theDaughterWidth, theDaughterWidth + 2);      
    }
        if ( nShortLived == 0 ) 
    {
      theDaughterMass[1]+=theDaughterMass[2];
      theActualMom = EvaluateCMMomentum(theActualMass, 
                theDaughterMass);   
      thePoleMom = EvaluateCMMomentum(thePoleMass, 
              theDaughterMass);
    }
//        else if ( nShortLived == 1 )
        else if ( nShortLived >= 1 )
    { 
      // need the shortlived particle in slot 1! (very bad style...)
      G4SwapObj(theDaughterMass, theDaughterMass + 1);
      G4SwapObj(theDaughterWidth, theDaughterWidth + 1);      
      theDaughterMass[0] += theDaughterMass[2];
      theActualMom = IntegrateCMMomentum(0.0);
      thePoleMom = IntegrateCMMomentum(0.0, thePoleMass);
    }
//        else
//    {
//      throw G4HadronicException(__FILE__, __LINE__,  ("can't handle more than one shortlived in 3 particle output channel");
//    }     
        
      }
    
    //if(nDaughters<3) theChannel->GetAngularMomentum(); 
    G4double theMassRatio = thePoleMass / theActualMass;
          G4double theMomRatio = theActualMom / thePoleMom;
    // VI 11.06.2015: for l=0 one not need use pow
          //G4double l=0;
          //theActualWidth[index] = thePoleWidth * theMassRatio *
          //                        std::pow(theMomRatio, (2 * l + 1)) *
          //                        (1.2 / (1+ 0.2*std::pow(theMomRatio, (2 * l))));
          theActualWidth[index] = thePoleWidth * theMassRatio *
                                  theMomRatio;
          delete [] theDaughterMass;
    theDaughterMass = 0;
          delete [] theDaughterWidth;
    theDaughterWidth = 0;
    delete [] theDaughterIsShortLived;
          theDaughterIsShortLived = 0;
  }
      
      else //  nDaughter = 1 ( e.g. K0  decays 50% to Kshort, 50% Klong 
  {
    theMotherWidth = theDefinition->GetPDGWidth();
    theActualWidth[index] = theChannel->GetBR()*theMotherWidth;
  }
    }

//    DEBUG   //

// for (G4int y = nChannels - 1; y >= 0; y--)
//     {
//      G4cout << G4endl << theActualWidth[y];
//     }
// G4cout << G4endl << G4endl << G4endl;

 /*
 G4cerr << G4endl << G4endl << G4endl;
 G4cerr << "   G4KineticTrack by argument constructor invoked! \n";
 G4cerr << "   =============================================== \n" << G4endl;
 */

}

G4KineticTrack::G4KineticTrack(G4Nucleon * nucleon,
                const G4ThreeVector& aPosition,
                                const G4LorentzVector& a4Momentum)
  :     theDefinition(nucleon->GetDefinition()),
  theFormationTime(0),
  thePosition(aPosition),
  the4Momentum(a4Momentum),
  theFermi3Momentum(nucleon->GetMomentum()),
        theNucleon(nucleon),
  nChannels(0),
  theActualMass(nucleon->GetDefinition()->GetPDGMass()),
  theActualWidth(0),
  theDaughterMass(0),
  theDaughterWidth(0),
  theStateToNucleus(undefined),
  theProjectilePotential(0)
{
  theFermi3Momentum.setE(0);
  Set4Momentum(a4Momentum);
}


G4KineticTrack::~G4KineticTrack()
{
 if (theActualWidth != 0) delete [] theActualWidth;
 if (theDaughterMass != 0) delete [] theDaughterMass;
 if (theDaughterWidth != 0) delete [] theDaughterWidth;
}



G4KineticTrack& G4KineticTrack::operator=(const G4KineticTrack& right)
{
 if (this != &right)
    {
     theDefinition = right.GetDefinition();
     theFormationTime = right.GetFormationTime();
     the4Momentum = right.the4Momentum;  
     the4Momentum = right.GetTrackingMomentum();
     theFermi3Momentum = right.theFermi3Momentum;
     theTotal4Momentum = right.theTotal4Momentum;
     theNucleon=right.theNucleon;
     theStateToNucleus=right.theStateToNucleus;
     if (theActualWidth != 0) delete [] theActualWidth;
     nChannels = right.GetnChannels();      
     theActualWidth = new G4double[nChannels];
     for ( G4int i = 0; i < nChannels; i++)
        {
         theActualWidth[i] = right.theActualWidth[i];
        }
    }
 return *this;
}



G4int G4KineticTrack::operator==(const G4KineticTrack& right) const
{
 return (this == & right);
}



G4int G4KineticTrack::operator!=(const G4KineticTrack& right) const
{
 return (this != & right);
}



G4KineticTrackVector* G4KineticTrack::Decay()
{
//
//   Select a possible decay channel
//
/*
    G4int index1;
    for (index1 = nChannels - 1; index1 >= 0; index1--)
      G4cout << "DECAY Actual Width IND/ActualW " << index1 << "  " << theActualWidth[index1] << G4endl;
      G4cout << "DECAY Actual Mass " << theActualMass << G4endl;
*/
  const G4ParticleDefinition* thisDefinition = this->GetDefinition();
  if(!thisDefinition)
  {
    G4cerr << "Error condition encountered in G4KineticTrack::Decay()"<<G4endl;
    G4cerr << "  track has no particle definition associated."<<G4endl;
    return 0;
  }
  G4DecayTable* theDecayTable = thisDefinition->GetDecayTable();
  if(!theDecayTable)
  {
    G4cerr << "Error condition encountered in G4KineticTrack::Decay()"<<G4endl;
    G4cerr << "  particle definiton has no decay table associated."<<G4endl;
    G4cerr << "  particle was "<<thisDefinition->GetParticleName()<<G4endl;
    return 0;
  }
 
 G4int chargeBalance = G4lrint(theDefinition->GetPDGCharge() );     
 G4int baryonBalance = G4lrint(theDefinition->GetBaryonNumber() );
 G4LorentzVector energyMomentumBalance(Get4Momentum());
 G4double theTotalActualWidth = this->EvaluateTotalActualWidth();
 if (theTotalActualWidth !=0)
    {

     //AR-16Aug2016 : Repeat the sampling of the decay channel until is 
     //               kinematically above threshold or a max number of attempts is reached
     G4bool isChannelBelowThreshold = true;
     const G4int maxNumberOfLoops = 10000;
     G4int loopCounter = 0;

     G4int chosench;
     G4String theParentName;
     G4double theParentMass;
     G4double theBR;
     G4int theNumberOfDaughters;
     G4String theDaughtersName1;
     G4String theDaughtersName2;
     G4String theDaughtersName3;
     G4String theDaughtersName4;
     G4double masses[4]={0.,0.,0.,0.};

     do {       

       G4int index;
       G4double theSumActualWidth = 0.0;
       G4double* theCumActualWidth = new G4double[nChannels];
       for (index = nChannels - 1; index >= 0; index--)
          {
           theSumActualWidth += theActualWidth[index];
           theCumActualWidth[index] = theSumActualWidth;
     //  cout << "DECAY Cum. Width " << index << "  " << theCumActualWidth[index] << G4endl;
    }
       //  cout << "DECAY Total Width " << theSumActualWidth << G4endl;
       //  cout << "DECAY Total Width " << theTotalActualWidth << G4endl;
       G4double r = theTotalActualWidth * G4UniformRand();
       G4VDecayChannel* theDecayChannel(0);
       chosench=-1;
       for (index = nChannels - 1; index >= 0; index--)
          {
           if (r < theCumActualWidth[index])
              {
               theDecayChannel = theDecayTable->GetDecayChannel(index);
         //      cout << "DECAY SELECTED CHANNEL" << index << G4endl;
               chosench=index;
               break; 
              }
          }

       delete [] theCumActualWidth;
   
       if(!theDecayChannel)
       {
         G4cerr << "Error condition encountered in G4KineticTrack::Decay()"<<G4endl;
         G4cerr << "  decay channel has 0x0 channel associated."<<G4endl;
         G4cerr << "  particle was "<<thisDefinition->GetParticleName()<<G4endl;
         G4cerr << "  channel index "<< chosench << "of "<<nChannels<<"channels"<<G4endl;
         return 0;
       }
       theParentName = theDecayChannel->GetParentName();
       theParentMass = this->GetActualMass();
       theBR = theActualWidth[index];
       //     cout << "**BR*** DECAYNEW  " << theBR << G4endl;
       theNumberOfDaughters = theDecayChannel->GetNumberOfDaughters();
       theDaughtersName1 = "";
       theDaughtersName2 = "";
       theDaughtersName3 = "";
       theDaughtersName4 = "";

       for (G4int i=0; i < 4; i++) masses[i]=0.;
       G4int shortlivedDaughters[4];
       G4int numberOfShortliveds(0);
       G4double SumLongLivedMass(0);
       for (G4int aD=0; aD < theNumberOfDaughters ; aD++)
       {
          const G4ParticleDefinition* aDaughter = theDecayChannel->GetDaughter(aD);
          masses[aD] = aDaughter->GetPDGMass();
          if ( aDaughter->IsShortLived() ) 
    {
        shortlivedDaughters[numberOfShortliveds]=aD;
        numberOfShortliveds++;
    } else {
        SumLongLivedMass += aDaughter->GetPDGMass();
    }
    
       }    
       switch (theNumberOfDaughters)
          {
           case 0:
              break;
           case 1:
              theDaughtersName1 = theDecayChannel->GetDaughterName(0);
              theDaughtersName2 = "";
              theDaughtersName3 = "";
              theDaughtersName4 = "";
              break;
           case 2:    
              theDaughtersName1 = theDecayChannel->GetDaughterName(0);      
              theDaughtersName2 = theDecayChannel->GetDaughterName(1);
              theDaughtersName3 = "";
              theDaughtersName4 = "";
        if (  numberOfShortliveds == 1) 
        {   G4SampleResonance aSampler;
                  G4double massmax=theParentMass - SumLongLivedMass;
      const G4ParticleDefinition * aDaughter=theDecayChannel->GetDaughter(shortlivedDaughters[0]);
            masses[shortlivedDaughters[0]]= aSampler.SampleMass(aDaughter,massmax);
        } else if (  numberOfShortliveds == 2) {
            // choose masses one after the other, start with randomly choosen
            G4int zero= (G4UniformRand() > 0.5) ? 0 : 1;
      G4int one = 1-zero;
      G4SampleResonance aSampler;
      G4double massmax=theParentMass - aSampler.GetMinimumMass(theDecayChannel->GetDaughter(shortlivedDaughters[one]));
      const G4ParticleDefinition * aDaughter=theDecayChannel->GetDaughter(shortlivedDaughters[zero]);
      masses[shortlivedDaughters[zero]]=aSampler.SampleMass(aDaughter,massmax);
      massmax=theParentMass - masses[shortlivedDaughters[zero]];
      aDaughter=theDecayChannel->GetDaughter(shortlivedDaughters[one]);
      masses[shortlivedDaughters[one]]=aSampler.SampleMass(aDaughter,massmax);
        }
        break;    
     case 3:    
              theDaughtersName1 = theDecayChannel->GetDaughterName(0);
              theDaughtersName2 = theDecayChannel->GetDaughterName(1);
              theDaughtersName3 = theDecayChannel->GetDaughterName(2);
              theDaughtersName4 = "";
        if (  numberOfShortliveds == 1) 
        {   G4SampleResonance aSampler;
                  G4double massmax=theParentMass - SumLongLivedMass;
          const G4ParticleDefinition * aDaughter=theDecayChannel->GetDaughter(shortlivedDaughters[0]);
            masses[shortlivedDaughters[0]]= aSampler.SampleMass(aDaughter,massmax);
        }
        break;
     default:    
              theDaughtersName1 = theDecayChannel->GetDaughterName(0);
              theDaughtersName2 = theDecayChannel->GetDaughterName(1);
              theDaughtersName3 = theDecayChannel->GetDaughterName(2);
              theDaughtersName4 = theDecayChannel->GetDaughterName(3);
        if (  numberOfShortliveds == 1) 
        {   G4SampleResonance aSampler;
                  G4double massmax=theParentMass - SumLongLivedMass;
          const G4ParticleDefinition * aDaughter=theDecayChannel->GetDaughter(shortlivedDaughters[0]);
            masses[shortlivedDaughters[0]]= aSampler.SampleMass(aDaughter,massmax);
        }
              if ( theNumberOfDaughters > 4 ) {
                G4ExceptionDescription ed;
                ed << "More than 4 decay daughters: kept only the first 4" << G4endl;
                G4Exception( "G4KineticTrack::Decay()", "KINTRK5", JustWarning, ed );
              }
        break;
    }

          //AR-16Aug2016 : Check whether the sum of the masses of the daughters is smaller than the parent mass.
          //               If this is still not the case, but the max number of attempts has been reached,
          //               then the subsequent call thePhaseSpaceDecayChannel.DecayIt() will throw an exception.
          G4double sumDaughterMasses = 0.0;
          for (G4int i=0; i < 4; i++) sumDaughterMasses += masses[i];
          if ( theParentMass - sumDaughterMasses > 0.0 ) isChannelBelowThreshold = false;

     } while ( isChannelBelowThreshold && ++loopCounter < maxNumberOfLoops );   /* Loop checking, 16.08.2016, A.Ribon */

//  
//      Get the decay products List
//
     
     G4GeneralPhaseSpaceDecay thePhaseSpaceDecayChannel(theParentName,
                                                        theParentMass,
                                                        theBR,
                                                        theNumberOfDaughters,
                                                        theDaughtersName1,                  
                                            theDaughtersName2,
                                            theDaughtersName3,
                                            theDaughtersName4,
              masses);
     G4DecayProducts* theDecayProducts = thePhaseSpaceDecayChannel.DecayIt();
     if(!theDecayProducts)
     {
       G4ExceptionDescription ed;
       ed << "Error condition encountered: phase-space decay failed." << G4endl
          << "\t the decaying particle is: " << thisDefinition->GetParticleName() << G4endl
          << "\t the channel index is: "<< chosench << " of "<< nChannels << "channels" << G4endl
          << "\t " << theNumberOfDaughters << " daughter particles: "
          << theDaughtersName1 << " " << theDaughtersName2 << " " << theDaughtersName3 << " " 
          << theDaughtersName4 << G4endl;
       G4Exception( "G4KineticTrack::Decay ", "HAD_KINTRACK_001", JustWarning, ed );
       return 0;
     }
                                            
//
//      Create the kinetic track List associated to the decay products
//
     G4LorentzRotation toMoving(Get4Momentum().boostVector());
     G4DynamicParticle* theDynamicParticle;
     G4double formationTime = 0.0;
     G4ThreeVector position = this->GetPosition();
     G4LorentzVector momentum;
     G4LorentzVector momentumBalanceCMS(0);
     G4KineticTrackVector* theDecayProductList = new G4KineticTrackVector;
     G4int dEntries = theDecayProducts->entries();
     const G4ParticleDefinition * aProduct = 0;
     for (G4int i=dEntries; i > 0; i--)
        {
   theDynamicParticle = theDecayProducts->PopProducts();
         aProduct = theDynamicParticle->GetDefinition();
         chargeBalance -= G4lrint(aProduct->GetPDGCharge() );
         baryonBalance -= G4lrint(aProduct->GetBaryonNumber() );
   momentumBalanceCMS += theDynamicParticle->Get4Momentum();
         momentum = toMoving*theDynamicParticle->Get4Momentum();
         energyMomentumBalance -= momentum;
         theDecayProductList->push_back(new G4KineticTrack (aProduct,
                                                         formationTime,
                                                         position,
                                                         momentum));
         delete theDynamicParticle;
        }
     delete theDecayProducts;
     if(getenv("DecayEnergyBalanceCheck"))
       std::cout << "DEBUGGING energy balance in cms and lab, charge baryon balance : "
                 << momentumBalanceCMS << " " 
             <<energyMomentumBalance << " " 
             <<chargeBalance<<" "
           <<baryonBalance<<" "
             <<G4endl;
     return theDecayProductList;
    }
 else
    {
     return 0;
    }
}

G4double G4KineticTrack::IntegrandFunction1(G4double xmass) const 
{
  G4double mass = theActualMass;   /* the actual mass value */
  G4double mass1 = theDaughterMass[0];
  G4double mass2 = theDaughterMass[1];
  G4double gamma2 = theDaughterWidth[1];
  
  G4double result = (1. / (2 * mass)) *
    std::sqrt(std::max((((mass * mass) - (mass1 + xmass) * (mass1 + xmass)) *
       ((mass * mass) - (mass1 - xmass) * (mass1 - xmass))),0.0)) *
    BrWig(gamma2, mass2, xmass);
  return result;
}

G4double G4KineticTrack::IntegrandFunction2(G4double xmass) const
{
  G4double mass = theDefinition->GetPDGMass();   /* the pole mass value */
  G4double mass1 = theDaughterMass[0];
  G4double mass2 = theDaughterMass[1];
  G4double gamma2 = theDaughterWidth[1];
  G4double result = (1. / (2 * mass)) *
    std::sqrt(std::max((((mass * mass) - (mass1 + xmass) * (mass1 + xmass)) *
       ((mass * mass) - (mass1 - xmass) * (mass1 - xmass))),0.0)) *
    BrWig(gamma2, mass2, xmass);
 return result;
}

G4double G4KineticTrack::IntegrandFunction3(G4double xmass) const
{
  const G4double mass =  G4KineticTrack_Gmass;   /* the actual mass value */
//  const G4double mass1 = theDaughterMass[0];
  const G4double mass2 = theDaughterMass[1];
  const G4double gamma2 = theDaughterWidth[1];

  const G4double result = (1. / (2 * mass)) *
    std::sqrt(((mass * mass) - (G4KineticTrack_xmass1 + xmass) * (G4KineticTrack_xmass1 + xmass)) *
   ((mass * mass) - (G4KineticTrack_xmass1 - xmass) * (G4KineticTrack_xmass1 - xmass))) *
    BrWig(gamma2, mass2, xmass);
  return result;
}

G4double G4KineticTrack::IntegrandFunction4(G4double xmass) const
{
  const G4double mass =  G4KineticTrack_Gmass;
  const G4double mass1 = theDaughterMass[0];
  const G4double gamma1 = theDaughterWidth[0];
//  const G4double mass2 = theDaughterMass[1];
  
  G4KineticTrack_xmass1 = xmass;
  
  const G4double theLowerLimit = 0.0;
  const G4double theUpperLimit = mass - xmass;
  const G4int nIterations = 100;
  
  G4Integrator<const G4KineticTrack, G4double(G4KineticTrack::*)(G4double) const> integral;
  G4double result = BrWig(gamma1, mass1, xmass)*
    integral.Simpson(this, &G4KineticTrack::IntegrandFunction3, theLowerLimit, theUpperLimit, nIterations);

  return result;
}

G4double G4KineticTrack::IntegrateCMMomentum(const G4double theLowerLimit) const
{
  const G4double theUpperLimit = theActualMass - theDaughterMass[0];
  const G4int nIterations = 100;
 
  if (theLowerLimit>=theUpperLimit) return 0.0;

  G4Integrator<const G4KineticTrack, G4double(G4KineticTrack::*)(G4double) const> integral;
  G4double theIntegralOverMass2 = integral.Simpson(this, &G4KineticTrack::IntegrandFunction1, 
               theLowerLimit, theUpperLimit, nIterations);
  return theIntegralOverMass2;
}

G4double G4KineticTrack::IntegrateCMMomentum(const G4double theLowerLimit, const G4double poleMass) const
{
  const G4double theUpperLimit = poleMass - theDaughterMass[0];
  const G4int nIterations = 100;
  
  if (theLowerLimit>=theUpperLimit) return 0.0;

  G4Integrator<const G4KineticTrack, G4double(G4KineticTrack::*)(G4double) const> integral;
  const G4double theIntegralOverMass2 = integral.Simpson(this, &G4KineticTrack::IntegrandFunction2,
                theLowerLimit, theUpperLimit, nIterations);
  return theIntegralOverMass2;
}


G4double G4KineticTrack::IntegrateCMMomentum2() const
{
  const G4double theLowerLimit = 0.0;
  const G4double theUpperLimit = theActualMass;
  const G4int nIterations = 100;
  
  if (theLowerLimit>=theUpperLimit) return 0.0;
  
  G4Integrator<const G4KineticTrack, G4double(G4KineticTrack::*)(G4double) const> integral;
  G4double theIntegralOverMass2 = integral.Simpson(this, &G4KineticTrack::IntegrandFunction4,
               theLowerLimit, theUpperLimit, nIterations);
  return theIntegralOverMass2;
}