#include <G4CollisionNN.hh>

Inheritance diagram for G4CollisionNN:

Public Member Functions
void	AddComponent (G4VCollision *aC)

virtual G4double	CrossSection (const G4KineticTrack &trk1, const G4KineticTrack &trk2) const

void	establish_G4MT_TLS_G4VCollision ()

virtual G4KineticTrackVector *	FinalState (const G4KineticTrack &trk1, const G4KineticTrack &trk2) const

	G4CollisionNN ()

virtual G4String	GetName () const

G4bool	IsInCharge (const G4KineticTrack &trk1, const G4KineticTrack &trk2) const

G4bool	operator!= (const G4CollisionNN &right) const

G4bool	operator!= (const G4VCollision &right) const

G4bool	operator== (const G4CollisionNN &right) const

G4bool	operator== (const G4VCollision &right) const

virtual void	Print () const

virtual void	Print (const G4KineticTrack &trk1, const G4KineticTrack &trk2) const

virtual	~G4CollisionNN ()

Protected Member Functions
virtual const G4VAngularDistribution *	GetAngularDistribution () const

virtual const G4CollisionVector *	GetComponents () const

virtual const G4VCrossSectionSource *	GetCrossSectionSource () const

virtual const std::vector< G4String > &	GetListOfColliders (G4int whichOne) const

G4int	GetNumberOfPartons (const G4ParticleDefinition *aP) const

Private Member Functions
void	BufferCrossSection (const G4ParticleDefinition aP, const G4ParticleDefinition bP)

G4double	BufferedCrossSection (const G4KineticTrack &trk1, const G4KineticTrack &trk2) const

	G4CollisionNN (const G4CollisionNN &)

G4CollisionNN &	operator= (const G4CollisionNN &)

Private Attributes
G4Mutex	bufferMutex

std::vector< G4String >	colliders1

std::vector< G4String >	colliders2

G4CollisionVector *	components

G4VCrossSectionSource *	crossSectionSource

std::vector< G4CrossSectionBuffer >	theBuffer

Static Private Attributes
static const G4int	nPoints = 32

static const G4double	theT []

Detailed Description

Definition at line 39 of file G4CollisionNN.hh.

Constructor & Destructor Documentation

◆ G4CollisionNN() [1/2]

G4CollisionNN::G4CollisionNN ( )

Definition at line 54 of file G4CollisionNN.cc.

{ 
  components=0;
  crossSectionSource = new G4XNNTotal();
  G4CollisionComposite::Register aR;
  G4ForEach<theChannels>::Apply(&aR, this);
}

References G4ForEach< group >::Apply(), components, and crossSectionSource.

◆ ~G4CollisionNN()

G4CollisionNN::~G4CollisionNN ( )

virtual

Definition at line 63 of file G4CollisionNN.cc.

{ 
  if (components) {
    delete components;
    components=0;
  }
  delete crossSectionSource;
  crossSectionSource = 0;
}

References components, and crossSectionSource.

◆ G4CollisionNN() [2/2]

G4CollisionNN::G4CollisionNN ( const G4CollisionNN & )

private

Member Function Documentation

◆ AddComponent()

void G4CollisionComposite::AddComponent ( G4VCollision * aC )

inlineinherited

Definition at line 72 of file G4CollisionComposite.hh.

72{components.push_back(aC);}

G4CollisionComposite::components

G4CollisionVector components

Definition: G4CollisionComposite.hh:120

References G4CollisionComposite::components.

Referenced by G4CollisionMesonBaryon::G4CollisionMesonBaryon(), G4CollisionMesonBaryonToResonance::G4CollisionMesonBaryonToResonance(), G4CollisionComposite::Register::operator()(), and G4CollisionComposite::Resolve::operator()().

◆ BufferCrossSection()

void G4CollisionComposite::BufferCrossSection	(	const G4ParticleDefinition *	aP,
		const G4ParticleDefinition *	bP
	)

privateinherited

Definition at line 141 of file G4CollisionComposite.cc.

{
   // check if already buffered
   size_t i;
   for(i=0; i<theBuffer.size(); i++)
   {
     if(theBuffer[i].InCharge(aP, bP)) return;
   }
//   G4cerr << "Buffering for "<<aP->GetParticleName()<<" "<<bP->GetParticleName()<<G4endl;
   
   // buffer the new one.
   G4CrossSectionBuffer aNewBuff(aP, bP);
   size_t maxE=nPoints;
   for(size_t tt=0; tt<maxE; tt++)
   {
     G4double aT = theT[tt]*GeV;
     G4double crossSect = 0;
     // The total cross-section is summed over all the component channels
     
     //A.R. 28-Sep-2012 Fix reproducibility problem
     //                 Assign the kinetic energy to the lightest of the
     //                 two particles, instead to the first one always.
     G4double atime = 0;
     G4double btime = 0;
     G4ThreeVector aPosition(0,0,0);
     G4ThreeVector bPosition(0,0,0);
     G4double aM = aP->GetPDGMass();
     G4double bM = bP->GetPDGMass();
     G4double aE = aM;
     G4double bE = bM;
     G4ThreeVector aMom(0,0,0);
     G4ThreeVector bMom(0,0,0);
     if ( aM <= bM ) {
      aE += aT;
      aMom = G4ThreeVector(0,0,std::sqrt(aE*aE-aM*aM));
     } else {
      bE += aT;
      bMom = G4ThreeVector(0,0,std::sqrt(bE*bE-bM*bM));
     }
     G4LorentzVector a4Momentum(aE, aMom);
     G4LorentzVector b4Momentum(bE, bMom);
     G4KineticTrack a(aP, atime, aPosition, a4Momentum);
     G4KineticTrack b(bP, btime, bPosition, b4Momentum);
     
     for (i=0; i<components.size(); i++)
     {
       if(components[i]->IsInCharge(a,b))
       {
     crossSect += components[i]->CrossSection(a,b);
       }
     }
     G4double sqrts = (a4Momentum+b4Momentum).mag();
     aNewBuff.push_back(sqrts, crossSect);
   }
   theBuffer.push_back(aNewBuff);
//   theBuffer.back().Print();
}

References G4CollisionComposite::components, G4ParticleDefinition::GetPDGMass(), GeV, G4CollisionComposite::IsInCharge(), G4CollisionComposite::nPoints, G4CrossSectionBuffer::push_back(), G4CollisionComposite::theBuffer, and G4CollisionComposite::theT.

Referenced by G4CollisionComposite::CrossSection().

◆ BufferedCrossSection()

G4double G4CollisionComposite::BufferedCrossSection	(	const G4KineticTrack &	trk1,
		const G4KineticTrack &	trk2
	)		const

privateinherited

Definition at line 201 of file G4CollisionComposite.cc.

{
   for(size_t i=0; i<theBuffer.size(); i++)
   {
     if(theBuffer[i].InCharge(trk1.GetDefinition(), trk2.GetDefinition())) 
     {
       return theBuffer[i].CrossSection(trk1, trk2);
     }
   }
   throw G4HadronicException(__FILE__, __LINE__, "G4CollisionComposite::BufferedCrossSection - Blitz !!");
   return 0;
}

References G4KineticTrack::GetDefinition(), and G4CollisionComposite::theBuffer.

Referenced by G4CollisionComposite::CrossSection().

◆ CrossSection()

G4double G4CollisionNN::CrossSection	(	const G4KineticTrack &	trk1,
		const G4KineticTrack &	trk2
	)		const

virtual

Reimplemented from G4CollisionComposite.

Definition at line 81 of file G4CollisionNN.cc.

{
  G4double sigma = 0.;
 
  // nucleon-nucleon cross-sections made for on-shell particles.
  // here we take the kinetic energy as the quantity relevant
  // for calculating the scattering cross-sections for off-shell hadrons
  
  const G4VCrossSectionSource* xSource = GetCrossSectionSource();
  G4LorentzVector p1 = aTrk1.Get4Momentum();
  G4LorentzVector p2 = aTrk2.Get4Momentum();
  G4double t1 = p1.e()-aTrk1.GetActualMass();
  G4double t2 = p2.e()-aTrk2.GetActualMass();
  p1.setE(t1+aTrk1.GetDefinition()->GetPDGMass());
  p2.setE(t2+aTrk2.GetDefinition()->GetPDGMass());
  G4KineticTrack trk1(aTrk1);
  trk1.Set4Momentum(p1);
  G4KineticTrack trk2(aTrk2);
  trk2.Set4Momentum(p2);
  if( (p1+p2).mag()<aTrk1.GetDefinition()->GetPDGMass()+aTrk2.GetDefinition()->GetPDGMass())
  {
    return 0.;
  }
 
  if (xSource != 0)
    {
      // There is a cross section for this Collision
      sigma = xSource->CrossSection(trk1,trk2);
    }
  return sigma;
}

References G4VCrossSectionSource::CrossSection(), CLHEP::HepLorentzVector::e(), G4KineticTrack::Get4Momentum(), G4KineticTrack::GetActualMass(), GetCrossSectionSource(), G4KineticTrack::GetDefinition(), G4ParticleDefinition::GetPDGMass(), G4KineticTrack::Set4Momentum(), and CLHEP::HepLorentzVector::setE().

◆ establish_G4MT_TLS_G4VCollision()

void G4VCollision::establish_G4MT_TLS_G4VCollision ( )

inherited

Definition at line 143 of file G4VCollision.cc.

143{ }

Referenced by G4VScatteringCollision::establish_G4MT_TLS_G4VScatteringCollision().

◆ FinalState()

G4KineticTrackVector * G4CollisionComposite::FinalState	(	const G4KineticTrack &	trk1,
		const G4KineticTrack &	trk2
	)		const

virtualinherited

Implements G4VCollision.

Definition at line 79 of file G4CollisionComposite.cc.

{
  std::vector<G4double> cxCache;
  G4double partialCxSum = 0.0;
 
  size_t i;
  for (i=0; i<components.size(); i++) 
  {
    G4double partialCx;
//    cout << "comp" << i << " " << components[i]()->GetName();
    if (components[i]->IsInCharge(trk1,trk2)) 
    {
      partialCx = components[i]->CrossSection(trk1,trk2);
    } 
    else 
    {
      partialCx = 0.0;
    }
//    cout << "   cx=" << partialCx << endl;
    partialCxSum += partialCx;
    cxCache.push_back(partialCx);
  }
 
  G4double random = G4UniformRand()*partialCxSum;
  G4double running = 0;
  for (i=0; i<cxCache.size(); i++) 
  {
    running += cxCache[i];
    if (running > random) 
    {
      return components[i]->FinalState(trk1, trk2);
    }
  }
//  G4cerr <<"in charge = "<<IsInCharge(trk1, trk2)<<G4endl;
//  G4cerr <<"Cross-section = "<<CrossSection(trk1, trk2)/millibarn<<" "<<running<<" "<<cxCache.size()<<G4endl;
//  G4cerr <<"Names = "<<trk1.GetDefinition()->GetParticleName()<<", "<<trk2.GetDefinition()->GetParticleName()<<G4endl;
//  throw G4HadronicException(__FILE__, __LINE__, "G4CollisionComposite: no final state found!");
  return NULL;
}

References G4CollisionComposite::components, G4UniformRand, and G4CollisionComposite::IsInCharge().

◆ GetAngularDistribution()

virtual const G4VAngularDistribution * G4CollisionNN::GetAngularDistribution ( ) const

inlineprotectedvirtual

Reimplemented from G4CollisionComposite.

Definition at line 64 of file G4CollisionNN.hh.

64{ return 0; }

◆ GetComponents()

virtual const G4CollisionVector * G4CollisionNN::GetComponents ( ) const

inlineprotectedvirtual

Reimplemented from G4CollisionComposite.

Definition at line 66 of file G4CollisionNN.hh.

66{ return components; }

References components.

◆ GetCrossSectionSource()

virtual const G4VCrossSectionSource * G4CollisionNN::GetCrossSectionSource ( ) const

inlineprotectedvirtual

Reimplemented from G4CollisionComposite.

Definition at line 63 of file G4CollisionNN.hh.

63{ return crossSectionSource; }

References crossSectionSource.

Referenced by CrossSection().

◆ GetListOfColliders()

const std::vector< G4String > & G4CollisionNN::GetListOfColliders ( G4int whichOne ) const

protectedvirtual

Implements G4VCollision.

Definition at line 74 of file G4CollisionNN.cc.

{
      throw G4HadronicException(__FILE__, __LINE__, "G4CollisionNN::GetListOfColliders - Argument outside valid range"); 
      return colliders1;
}

References colliders1.

◆ GetName()

virtual G4String G4CollisionNN::GetName ( ) const

inlinevirtual

Implements G4VCollision.

Definition at line 51 of file G4CollisionNN.hh.

51{ return "NN CollisionComposite"; }

◆ GetNumberOfPartons()

G4int G4VCollision::GetNumberOfPartons ( const G4ParticleDefinition * aP ) const

inlineprotectedinherited

Definition at line 68 of file G4VCollision.hh.

  {
    G4int result = 0;
    for(G4int i=0; i<6; i++) 
    {
      result += aP->GetQuarkContent(i+1);
      result += aP->GetAntiQuarkContent(i+1);
    }
    return result;
  }

References G4ParticleDefinition::GetAntiQuarkContent(), and G4ParticleDefinition::GetQuarkContent().

Referenced by G4CollisionMesonBaryonElastic::IsInCharge().

◆ IsInCharge()

G4bool G4GeneralNNCollision::IsInCharge	(	const G4KineticTrack &	trk1,
		const G4KineticTrack &	trk2
	)		const

inlinevirtualinherited

Reimplemented from G4CollisionComposite.

Definition at line 40 of file G4GeneralNNCollision.hh.

  {
    G4bool result = false;
    const G4ParticleDefinition * aD = trk1.GetDefinition();
    const G4ParticleDefinition * bD = trk2.GetDefinition();
    if(  (aD==G4Proton::Proton() || aD == G4Neutron::Neutron())
       &&(bD==G4Proton::Proton() || bD == G4Neutron::Neutron()) ) result = true;
    return result;
  }

References G4KineticTrack::GetDefinition(), G4Neutron::Neutron(), and G4Proton::Proton().

◆ operator!=() [1/2]

G4bool G4CollisionNN::operator!= ( const G4CollisionNN & right ) const

◆ operator!=() [2/2]

G4bool G4VCollision::operator!= ( const G4VCollision & right ) const

inherited

Definition at line 48 of file G4VCollision.cc.

{
    return (this != (G4VCollision *) &right);
}

◆ operator=()

G4CollisionNN & G4CollisionNN::operator= ( const G4CollisionNN & )

private

◆ operator==() [1/2]

G4bool G4CollisionNN::operator== ( const G4CollisionNN & right ) const

◆ operator==() [2/2]

G4bool G4VCollision::operator== ( const G4VCollision & right ) const

inherited

Definition at line 42 of file G4VCollision.cc.

{
    return (this == (G4VCollision *) &right);
}

◆ Print() [1/2]

void G4VCollision::Print ( ) const

virtualinherited

Definition at line 70 of file G4VCollision.cc.

{
    G4String name = GetName();
 
    G4cout << "---- " << name << "---- Cross section" << G4endl;
 
    const G4VCrossSectionSource* xSource = GetCrossSectionSource();
    if (xSource) xSource->Print();
 
    G4int nComponents = 0;
    const G4CollisionVector* components = GetComponents();
    if (components)
    {
        nComponents = components->size();
    }
    G4cout << "---- " << name << "---- has " << nComponents << " components" <<G4endl;
    G4int i = 0;
    G4CollisionVector::const_iterator iter;
    if (components)
    {
        for (iter = components->begin(); iter != components->end(); ++iter)
        {
            G4cout << "---- " << name << " ---- Component " << i << G4endl;
            ((*iter))->Print();
            i++;
        }
    }
 
}

References G4cout, G4endl, G4VCollision::GetComponents(), G4VCollision::GetCrossSectionSource(), G4VCollision::GetName(), G4InuclParticleNames::name(), G4VCollision::Print(), and G4VCrossSectionSource::Print().

Referenced by G4VCollision::Print().

◆ Print() [2/2]

void G4VCollision::Print	(	const G4KineticTrack &	trk1,
		const G4KineticTrack &	trk2
	)		const

virtualinherited

Definition at line 101 of file G4VCollision.cc.

{
    G4String name = GetName();
 
    if (IsInCharge(trk1,trk2))
    {
        G4cout << "---- " << name << "is in charge ---- " << G4endl;
    }
    else
    {
        G4cout << "---- " << name << "is not in charge ---- " << G4endl;
    }
 
    G4cout << "---- " << name << "---- Cross section" << G4endl;
 
    const G4VCrossSectionSource* xSource = GetCrossSectionSource();
    if (xSource) xSource->Print();
    G4cout << "Cross section = " << CrossSection(trk1,trk2) << G4endl;
 
    G4int nComponents = 0;
    const G4CollisionVector* components = GetComponents();
    if (components)
    {
        nComponents = components->size();
    }
    G4cout << "---- " << name << "has " << nComponents << " components" <<G4endl;
 
    G4int i = 0;
    G4CollisionVector::const_iterator iter;
    if (components)
    {
        for (iter = components->begin(); iter != components->end(); ++iter)
        {
            G4cout << "Component " << i << G4endl;
            ((*iter))->Print();
            i++;
        }
    }
}

References G4VCollision::CrossSection(), G4cout, G4endl, G4VCollision::GetComponents(), G4VCollision::GetCrossSectionSource(), G4VCollision::GetName(), G4VCollision::IsInCharge(), G4InuclParticleNames::name(), G4VCollision::Print(), and G4VCrossSectionSource::Print().

Field Documentation

◆ bufferMutex

G4Mutex G4CollisionComposite::bufferMutex

mutableprivateinherited

Definition at line 126 of file G4CollisionComposite.hh.

Referenced by G4CollisionComposite::CrossSection(), G4CollisionComposite::G4CollisionComposite(), and G4CollisionComposite::~G4CollisionComposite().

◆ colliders1

std::vector<G4String> G4CollisionNN::colliders1

private

Definition at line 76 of file G4CollisionNN.hh.

Referenced by GetListOfColliders().

◆ colliders2

std::vector<G4String> G4CollisionNN::colliders2

private

Definition at line 77 of file G4CollisionNN.hh.

◆ components

G4CollisionVector* G4CollisionNN::components

private

Definition at line 72 of file G4CollisionNN.hh.

Referenced by G4CollisionNN(), GetComponents(), and ~G4CollisionNN().

◆ crossSectionSource

G4VCrossSectionSource* G4CollisionNN::crossSectionSource

private

Definition at line 74 of file G4CollisionNN.hh.

Referenced by G4CollisionNN(), GetCrossSectionSource(), and ~G4CollisionNN().

◆ nPoints

const G4int G4CollisionComposite::nPoints = 32

staticprivateinherited

Definition at line 123 of file G4CollisionComposite.hh.

Referenced by G4CollisionComposite::BufferCrossSection().

◆ theBuffer

std::vector<G4CrossSectionBuffer> G4CollisionComposite::theBuffer

privateinherited

Definition at line 121 of file G4CollisionComposite.hh.

Referenced by G4CollisionComposite::BufferCrossSection(), and G4CollisionComposite::BufferedCrossSection().

◆ theT

const G4double G4CollisionComposite::theT

staticprivateinherited

Initial value:

=

{.01, .03, .05, .1, .15, .2, .3, .4, .5, .6, .7, .8, .9, 1.0, 1.2, 1.4, 1.6, 1.8, 2.0, 2.2, 2.5, 3.0, 3.5, 4.0, 5.0, 6.0, 8.0, 10., 15, 20, 50, 100}

Definition at line 124 of file G4CollisionComposite.hh.

Referenced by G4CollisionComposite::BufferCrossSection().

The documentation for this class was generated from the following files:

source/processes/hadronic/models/im_r_matrix/include/G4CollisionNN.hh
source/processes/hadronic/models/im_r_matrix/src/G4CollisionNN.cc

Public Member Functions

Protected Member Functions

Private Member Functions

Private Attributes

Static Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ G4CollisionNN() [1/2]

◆ ~G4CollisionNN()

◆ G4CollisionNN() [2/2]

Member Function Documentation

◆ AddComponent()

◆ BufferCrossSection()

◆ BufferedCrossSection()

◆ CrossSection()

◆ establish_G4MT_TLS_G4VCollision()

◆ FinalState()

◆ GetAngularDistribution()

◆ GetComponents()

◆ GetCrossSectionSource()

◆ GetListOfColliders()

◆ GetName()

◆ GetNumberOfPartons()

◆ IsInCharge()

◆ operator!=() [1/2]

◆ operator!=() [2/2]

◆ operator=()

◆ operator==() [1/2]

◆ operator==() [2/2]

◆ Print() [1/2]

◆ Print() [2/2]

Field Documentation

◆ bufferMutex

◆ colliders1

◆ colliders2

◆ components

◆ crossSectionSource

◆ nPoints

◆ theBuffer

◆ theT