G4LMsdGenerator.cc

Go to the documentation of this file.

//
// ********************************************************************
// * 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.          *
// ********************************************************************
//
//
// G4LMsdGenerator
//
//
 
#include "G4DynamicParticle.hh"
#include "G4LMsdGenerator.hh"
#include "G4ReactionProductVector.hh"
#include "G4ReactionProduct.hh"
#include "G4IonTable.hh"
#include "G4NucleiProperties.hh"
#include "G4ParticleDefinition.hh"
#include "G4HadFinalState.hh"
#include "G4KineticTrack.hh"
#include "G4DecayKineticTracks.hh"
#include "G4KineticTrackVector.hh"
#include "G4Log.hh"
#include "G4PhysicsModelCatalog.hh"
 
 
G4LMsdGenerator::G4LMsdGenerator(const G4String& name)
  : G4HadronicInteraction(name), secID(-1)
 
{
  fPDGencoding = 0;
  secID = G4PhysicsModelCatalog::GetModelID( "model_LMsdGenerator" );
  
  // theParticleChange = new G4HadFinalState;
}
 
G4LMsdGenerator::~G4LMsdGenerator()
{
  // delete theParticleChange;
}
 
void G4LMsdGenerator::ModelDescription(std::ostream& outFile) const
{
  outFile << GetModelName() <<" consists of a " 
      << " string model and a stage to de-excite the excited nuclear fragment."
      << "\n<p>"
      << "The string model simulates the interaction of\n"
          << "an incident hadron with a nucleus, forming \n"
          << "excited strings, decays these strings into hadrons,\n"
          << "and leaves an excited nucleus. \n"
          << "<p>The string model:\n";
}
 
/////////////////////////////////////////////////////////////////
//
// Particle and kinematical limitation od diffraction dissociation
 
G4bool   
G4LMsdGenerator::IsApplicable( const G4HadProjectile& aTrack, 
                                      G4Nucleus& targetNucleus )
{
  G4bool applied = false;
 
  if( ( aTrack.GetDefinition() == G4Proton::Proton() || 
    aTrack.GetDefinition() == G4Neutron::Neutron()  ) && 
        targetNucleus.GetA_asInt() >= 1 &&
      // aTrack.GetKineticEnergy() > 1800*CLHEP::MeV 
        aTrack.GetKineticEnergy() > 300*CLHEP::MeV 
    ) //  750*CLHEP::MeV )   
  {
    applied = true;
  }
  else if( ( aTrack.GetDefinition() == G4PionPlus::PionPlus() || 
         aTrack.GetDefinition() == G4PionMinus::PionMinus()  ) && 
             targetNucleus.GetA_asInt() >= 1 &&
             aTrack.GetKineticEnergy() > 2340*CLHEP::MeV )    
  {
    applied = true;
  }
  else if( ( aTrack.GetDefinition() == G4KaonPlus::KaonPlus() || 
         aTrack.GetDefinition() == G4KaonMinus::KaonMinus()  ) && 
             targetNucleus.GetA_asInt() >= 1 &&
             aTrack.GetKineticEnergy() > 1980*CLHEP::MeV ) 
  {
    applied = true;
  }
  return applied;
}
 
/////////////////////////////////////////////////////////////////
//
// Return dissociated particle products and recoil nucleus
 
G4HadFinalState*  
G4LMsdGenerator::ApplyYourself( const G4HadProjectile& aTrack, 
                                      G4Nucleus& targetNucleus )
{
  theParticleChange.Clear();
 
  const G4HadProjectile* aParticle = &aTrack;
  G4double eTkin = aParticle->GetKineticEnergy();
 
  if( eTkin <= 1.*CLHEP::GeV && aTrack.GetDefinition() != G4Proton::Proton()) 
  {
    theParticleChange.SetEnergyChange(eTkin);
    theParticleChange.SetMomentumChange(aTrack.Get4Momentum().vect().unit());
    return &theParticleChange;
  }
 
  G4int A = targetNucleus.GetA_asInt();
  G4int Z = targetNucleus.GetZ_asInt();
 
  G4double plab = aParticle->GetTotalMomentum();
  G4double plab2 = plab*plab;
  
  const G4ParticleDefinition* theParticle = aParticle->GetDefinition();
  G4double partMass = theParticle->GetPDGMass();
 
  G4double oldE = partMass + eTkin;
 
  G4double targMass   = G4NucleiProperties::GetNuclearMass(A, Z);
  G4double targMass2   = targMass*targMass;
 
  G4LorentzVector partLV = aParticle->Get4Momentum();
 
  G4double sumE = oldE + targMass;
  G4double sumE2 = sumE*sumE;
   
  G4ThreeVector p1     = partLV.vect();
  // G4cout<<"p1 = "<<p1<<G4endl;
  G4ParticleMomentum p1unit = p1.unit();
 
  G4double Mx = SampleMx(aParticle); // in GeV
  G4double t  = SampleT( aParticle, Mx); // in GeV
 
  Mx *= CLHEP::GeV;
 
  G4double Mx2 = Mx*Mx;
 
  // equation for q|| based on sum-E-P and new invariant mass
 
  G4double B = sumE2 + targMass2 - Mx2 - plab2;
 
  G4double a = 4*(plab2 - sumE2);
  G4double b = 4*plab*B;
  G4double c = B*B - 4*sumE2*targMass2;
  G4double det2 = b*b - 4*a*c;
  G4double qLong,  det, eRetard; // , x2, x3, e2;
 
  if( det2 >= 0.) 
  {
    det = std::sqrt(det2);
    qLong = (-b - det)/2./a;
    eRetard = std::sqrt((plab-qLong)*(plab-qLong)+Mx2);
  }
  else 
  {
    theParticleChange.SetEnergyChange(eTkin);
    theParticleChange.SetMomentumChange(aTrack.Get4Momentum().vect().unit());
    return &theParticleChange;
  }
  theParticleChange.SetStatusChange(stopAndKill);
 
  plab -= qLong;
 
  G4ThreeVector pRetard = plab*p1unit;
 
  G4ThreeVector pTarg = p1 - pRetard; 
 
  G4double eTarg = std::sqrt( targMass2 + pTarg.mag2()); // std::sqrt( targMass*targMass + pTarg.mag2() );
 
  G4LorentzVector lvRetard(pRetard, eRetard);
  G4LorentzVector lvTarg(pTarg, eTarg);
   
  lvTarg += lvRetard; // sum LV
 
  G4ThreeVector bst = lvTarg.boostVector();
 
  lvRetard.boost(-bst); // to CNS
 
  G4ThreeVector pCMS   = lvRetard.vect();
  G4double momentumCMS = pCMS.mag();
  G4double tMax        = 4.0*momentumCMS*momentumCMS;
 
  if( t > tMax ) t = tMax*G4UniformRand();
 
  G4double cost = 1. - 2.0*t/tMax;
  
 
  G4double phi  = G4UniformRand()*CLHEP::twopi;
  G4double sint;
 
  if( cost > 1.0 || cost < -1.0 ) // 
  {
    cost = 1.0;
    sint = 0.0;    
  } 
  else  // normal situation
  {
    sint = std::sqrt( (1.0-cost)*(1.0+cost) );
  }    
  G4ThreeVector v1( sint*std::cos(phi), sint*std::sin(phi), cost);
 
  v1 *= momentumCMS;
  
  G4LorentzVector lvRes( v1.x(),v1.y(),v1.z(), std::sqrt( momentumCMS*momentumCMS + Mx2));
 
  lvRes.boost(bst); // to LS
 
  lvTarg -= lvRes;
 
  G4double eRecoil =  lvTarg.e() - targMass;
 
  if( eRecoil > 100.*CLHEP::MeV ) // add recoil nucleus
  {
    G4ParticleDefinition * recoilDef = 0;
 
    if      ( Z == 1 && A == 1 ) { recoilDef = G4Proton::Proton(); }
    else if ( Z == 1 && A == 2 ) { recoilDef = G4Deuteron::Deuteron(); }
    else if ( Z == 1 && A == 3 ) { recoilDef = G4Triton::Triton(); }
    else if ( Z == 2 && A == 3 ) { recoilDef = G4He3::He3(); }
    else if ( Z == 2 && A == 4 ) { recoilDef = G4Alpha::Alpha(); }
    else 
    {
      recoilDef = 
    G4ParticleTable::GetParticleTable()->GetIonTable()->GetIon( Z, A, 0.0 );
    }
    G4DynamicParticle * aSec = new G4DynamicParticle( recoilDef, lvTarg);
    theParticleChange.AddSecondary(aSec, secID);
  } 
  else if( eRecoil > 0.0 ) 
  {
    theParticleChange.SetLocalEnergyDeposit( eRecoil );
  }
 
  G4ParticleDefinition* ddPart = G4ParticleTable::GetParticleTable()->
                                 FindParticle(fPDGencoding);
 
  // G4cout<<fPDGencoding<<", "<<ddPart->GetParticleName()<<", "<<ddPart->GetPDGMass()<<" MeV; lvRes = "<<lvRes<<G4endl;
 
  // G4DynamicParticle * aRes = new G4DynamicParticle( ddPart, lvRes);
  //  theParticleChange.AddSecondary(aRes); // simply return resonance
 
 
  
  // Recursive decay using methods of G4KineticTrack
 
  G4KineticTrack ddkt( ddPart, 0., G4ThreeVector(0.,0.,0.), lvRes);
  G4KineticTrackVector* ddktv = ddkt.Decay();
 
  G4DecayKineticTracks decay( ddktv );
 
  for( unsigned int i = 0; i < ddktv->size(); i++ ) // add products to partchange
  {
    G4DynamicParticle * aNew = 
      new G4DynamicParticle( ddktv->operator[](i)->GetDefinition(),
                             ddktv->operator[](i)->Get4Momentum());
 
    // G4cout<<"       "<<i<<", "<<aNew->GetDefinition()->GetParticleName()<<", "<<aNew->Get4Momentum()<<G4endl;
 
    theParticleChange.AddSecondary(aNew, secID);
    delete ddktv->operator[](i);
  }
  delete ddktv;
   
  return &theParticleChange;
}
 
//////////////////////////////////////
//
// Sample Mx as Roper resonances, set PDG encoding 
 
G4double G4LMsdGenerator::SampleMx(const G4HadProjectile* aParticle)                          
{
  G4double Mx = 0.;
  G4int i;
  G4double rand = G4UniformRand();
 
  for( i = 0; i < 60; i++)
  {
    if( rand >= fProbMx[i][1] ) break;
  }
  if(i <= 0)       Mx = fProbMx[0][0];
  else if(i >= 59) Mx = fProbMx[59][0];
  else             Mx = fProbMx[i][0];
 
  fPDGencoding = 0;
 
  if ( Mx <=  1.45 )   
  {   
    if( aParticle->GetDefinition() == G4Proton::Proton() )
    {        
      Mx = 1.44;
      // fPDGencoding = 12212;
      fPDGencoding = 2214;
    }
    else if( aParticle->GetDefinition() == G4Neutron::Neutron() ) 
    {
      Mx = 1.44;
      fPDGencoding = 12112;
    }
    else if( aParticle->GetDefinition() == G4PionPlus::PionPlus() ) 
    {
      // Mx = 1.3;
      // fPDGencoding = 100211;
      Mx = 1.26;
      fPDGencoding = 20213; // a1(1260)+
    }
    else if( aParticle->GetDefinition() == G4PionMinus::PionMinus() ) 
    {
      // Mx = 1.3;
      // fPDGencoding = -100211;
      Mx = 1.26;
      fPDGencoding = -20213; // a1(1260)-
    }
    else if( aParticle->GetDefinition() == G4KaonPlus::KaonPlus() ) 
    {
      Mx = 1.27;
      fPDGencoding = 10323;
    }
    else if( aParticle->GetDefinition() == G4KaonMinus::KaonMinus() ) 
    {
      Mx = 1.27;
      fPDGencoding = -10323;
    }
  }
  else if ( Mx <=  1.55 ) 
  {   
    if( aParticle->GetDefinition() == G4Proton::Proton() ) 
    {       
      Mx = 1.52;
      // fPDGencoding = 2124;
      fPDGencoding = 2214;
    }
    else if( aParticle->GetDefinition() == G4Neutron::Neutron() ) 
    {
      Mx = 1.52;
      fPDGencoding = 1214;
    }
    else if( aParticle->GetDefinition() == G4PionPlus::PionPlus() ) 
    {
      // Mx = 1.45;
      // fPDGencoding = 10211;
      Mx = 1.32;
      fPDGencoding = 215; // a2(1320)+
    }
    else if( aParticle->GetDefinition() == G4PionMinus::PionMinus() ) 
    {
      // Mx = 1.45;
      // fPDGencoding = -10211;
      Mx = 1.32;
      fPDGencoding = -215; // a2(1320)-
    }
    else if( aParticle->GetDefinition() == G4KaonPlus::KaonPlus() ) 
    {
      Mx = 1.46;
      fPDGencoding = 100321;
    }
    else if( aParticle->GetDefinition() == G4KaonMinus::KaonMinus() ) 
    {
      Mx = 1.46;
      fPDGencoding = -100321;
    }
  }
  else                    
  {    
    if( aParticle->GetDefinition() == G4Proton::Proton() ) 
    {       
      Mx = 1.68;
      // fPDGencoding = 12216;
      fPDGencoding = 2214;
    }
    else if( aParticle->GetDefinition() == G4Neutron::Neutron() ) 
    {
      Mx = 1.68;
      fPDGencoding = 12116;
    }
    else if( aParticle->GetDefinition() == G4PionPlus::PionPlus() ) 
    {
      Mx = 1.67;
      fPDGencoding = 10215;  // pi2(1670)+
      // Mx = 1.45;
      // fPDGencoding = 10211;
    }
    else if( aParticle->GetDefinition() == G4PionMinus::PionMinus() ) 
    {
      Mx = 1.67;     // f0 problems->4pi vmg 20.11.14
      fPDGencoding = -10215;  // pi2(1670)-
      // Mx = 1.45;
      // fPDGencoding = -10211;
    }
    else if( aParticle->GetDefinition() == G4KaonPlus::KaonPlus() ) 
    {
      Mx = 1.68;
      fPDGencoding = 30323;
    }
    else if( aParticle->GetDefinition() == G4KaonMinus::KaonMinus() ) 
    {
      Mx = 1.68;
      fPDGencoding = -30323;
    }
  } 
  if(fPDGencoding == 0)
  {
      Mx = 1.44;
      // fPDGencoding = 12212;   
      fPDGencoding = 2214;
  } 
  G4ParticleDefinition* myResonance = 
  G4ParticleTable::GetParticleTable()->FindParticle( fPDGencoding );
  
  if ( myResonance ) Mx = myResonance->GetPDGMass();
 
  // G4cout<<"PDG-ID = "<<fPDGencoding<<"; with mass = "<<Mx/CLHEP::GeV<<" GeV"<<G4endl;
 
  return Mx/CLHEP::GeV;
}
 
////////////////////////////////////// 
//
// Sample t with kinematic limitations of Mx and Tkin
 
G4double G4LMsdGenerator::SampleT(  const G4HadProjectile* aParticle, 
G4double Mx)                          
{
  G4double t=0., b=0., rTkin = 50.*CLHEP::GeV, eTkin = aParticle->GetKineticEnergy();
  G4int i;
 
  for( i = 0; i < 23; ++i)
  {
    if( Mx <= fMxBdata[i][0] ) break;
  }
  if( i <= 0 )       b = fMxBdata[0][1];
  else if( i >= 22 ) b = fMxBdata[22][1];
  else               b = fMxBdata[i][1];
 
  if( eTkin > rTkin ) b *= 1. + G4Log(eTkin/rTkin);
 
  G4double rand = G4UniformRand();
 
  t = -G4Log(rand)/b;
 
  t *= (CLHEP::GeV*CLHEP::GeV); // in G4 internal units
 
  return t;
}
 
 
////////////////////////////////////////////////
//
// Integral spectrum of Mx (GeV)
 
const G4double G4LMsdGenerator::fProbMx[60][2] = 
{
  {1.000000e+00,    1.000000e+00},
  {1.025000e+00,    1.000000e+00},
  {1.050000e+00,    1.000000e+00},
  {1.075000e+00,    1.000000e+00},
  {1.100000e+00,    9.975067e-01},
  {1.125000e+00,    9.934020e-01},
  {1.150000e+00,    9.878333e-01},
  {1.175000e+00,    9.805002e-01},
  {1.200000e+00,    9.716846e-01},
  {1.225000e+00,    9.604761e-01},
  {1.250000e+00,    9.452960e-01},
  {1.275000e+00,    9.265278e-01},
  {1.300000e+00,    9.053632e-01},
  {1.325000e+00,    8.775566e-01},
  {1.350000e+00,    8.441969e-01},
  {1.375000e+00,    8.076336e-01},
  {1.400000e+00,    7.682520e-01},
  {1.425000e+00,    7.238306e-01},
  {1.450000e+00,    6.769306e-01},
  {1.475000e+00,    6.303898e-01},
  {1.500000e+00,    5.824632e-01},
  {1.525000e+00,    5.340696e-01},
  {1.550000e+00,    4.873736e-01},
  {1.575000e+00,    4.422901e-01},
  {1.600000e+00,    3.988443e-01},
  {1.625000e+00,    3.583727e-01},
  {1.650000e+00,    3.205405e-01},
  {1.675000e+00,    2.856655e-01},
  {1.700000e+00,    2.537508e-01},
  {1.725000e+00,    2.247863e-01},
  {1.750000e+00,    1.985798e-01},
  {1.775000e+00,    1.750252e-01},
  {1.800000e+00,    1.539777e-01},
  {1.825000e+00,    1.352741e-01},
  {1.850000e+00,    1.187157e-01},
  {1.875000e+00,    1.040918e-01},
  {1.900000e+00,    9.118422e-02},
  {1.925000e+00,    7.980909e-02},
  {1.950000e+00,    6.979378e-02},
  {1.975000e+00,    6.097771e-02},
  {2.000000e+00,    5.322122e-02},
  {2.025000e+00,    4.639628e-02},
  {2.050000e+00,    4.039012e-02},
  {2.075000e+00,    3.510275e-02},
  {2.100000e+00,    3.044533e-02},
  {2.125000e+00,    2.633929e-02},
  {2.150000e+00,    2.271542e-02},
  {2.175000e+00,    1.951295e-02},
  {2.200000e+00,    1.667873e-02},
  {2.225000e+00,    1.416633e-02},
  {2.250000e+00,    1.193533e-02},
  {2.275000e+00,    9.950570e-03},
  {2.300000e+00,    8.181515e-03},
  {2.325000e+00,    6.601664e-03},
  {2.350000e+00,    5.188025e-03},
  {2.375000e+00,    3.920655e-03},
  {2.400000e+00,    2.782246e-03},
  {2.425000e+00,    1.757765e-03},
  {2.450000e+00,    8.341435e-04},
  {2.475000e+00,    0.000000e+00}
};
 
//////////////////////////////////////////////
//
// Slope b (1/GeV/GeV) vs Mx (GeV) for t-sampling over exp(-b*t) 
 
const G4double G4LMsdGenerator::fMxBdata[23][2] = 
{
  {1.09014,      17.8620},      
  {1.12590,      19.2831},    
  {1.18549,      17.6907},      
  {1.21693,      16.4760},      
  {1.25194,      15.3867},      
  {1.26932,      14.4236},      
  {1.29019,      13.2931},      
  {1.30755,      12.2882},      
  {1.31790,      11.4509},      
  {1.33888,      10.6969},      
  {1.34911,      9.44130},      
  {1.37711,      8.56148},      
  {1.39101,      7.76593},      
  {1.42608,      6.88582},      
  {1.48593,      6.13019},      
  {1.53179,      5.87723},      
  {1.58111,      5.37308},      
  {1.64105,      4.95217},      
  {1.69037,      4.44803},      
  {1.81742,      3.89879},      
  {1.88096,      3.68693},      
  {1.95509,      3.43278},      
  {2.02219,      3.30445}
};
 
 
 
//
//
/////////////////////////////////////////////