G4ConcreteNStarNToNN Class Reference

#include <G4ConcreteNStarNToNN.hh>

Inheritance diagram for G4ConcreteNStarNToNN:

Public Member Functions
virtual G4double	CrossSection (const G4KineticTrack &trk1, const G4KineticTrack &trk2) const
void	establish_G4MT_TLS_G4ConcreteNNTwoBodyResonance (const G4ParticleDefinition *aPrimary, const G4ParticleDefinition *bPriamry, const G4ParticleDefinition *aSecondary, const G4ParticleDefinition *bSecondary, const G4VXResonanceTable &sigmaTable)
void	establish_G4MT_TLS_G4VCollision ()
void	establish_G4MT_TLS_G4VScatteringCollision ()
virtual G4KineticTrackVector *	FinalState (const G4KineticTrack &trk1, const G4KineticTrack &trk2) const
	G4ConcreteNStarNToNN (const G4ParticleDefinition *aPrimary, const G4ParticleDefinition *bPriamry, const G4ParticleDefinition *aSecondary, const G4ParticleDefinition *bSecondary)
virtual const G4VAngularDistribution *	GetAngularDistribution () const
virtual const std::vector< G4String > &	GetListOfColliders (G4int) const
virtual G4String	GetName () const
virtual G4bool	IsInCharge (const G4KineticTrack &trk1, const G4KineticTrack &trk2) const
G4bool	operator!= (const G4ConcreteNNTwoBodyResonance &right) const
G4bool	operator!= (const G4VCollision &right) const
G4bool	operator!= (const G4VScatteringCollision &right) const
G4bool	operator== (const G4ConcreteNNTwoBodyResonance &right) const
G4bool	operator== (const G4VCollision &right) const
G4bool	operator== (const G4VScatteringCollision &right) const
virtual void	Print () const
virtual void	Print (const G4KineticTrack &trk1, const G4KineticTrack &trk2) const
virtual	~G4ConcreteNStarNToNN ()

Protected Member Functions
virtual const G4CollisionVector *	GetComponents () const
virtual const G4VCrossSectionSource *	GetCrossSectionSource () const
G4int	GetNumberOfPartons (const G4ParticleDefinition *aP) const
virtual const std::vector< const G4ParticleDefinition * > &	GetOutgoingParticles () const

Private Member Functions
double	BrWigInt0 (const double x, const double gamma, const double m0) const
G4double	BrWigInt1 (const G4double x, const G4double gamma, const G4double m0) const
double	BrWigInv (const double x, const double gamma, const double m0) const
	G4ConcreteNStarNToNN (const G4ConcreteNStarNToNN &)
G4ConcreteNStarNToNN &	operator= (const G4ConcreteNStarNToNN &)
double	SampleResonanceMass (const double poleMass, const double width, const double minMass, const double maxMass) const

Private Attributes
G4VCrossSectionSource *	crossSectionSource
G4VAngularDistribution *	theAngularDistribution
std::vector< const G4ParticleDefinition * >	theOutGoing
const G4ParticleDefinition *	thePrimary1
const G4ParticleDefinition *	thePrimary2

Static Private Attributes
static G4ThreadLocal G4XNNstarTable *	theSigmaTable_G4MT_TLS_ = 0

Detailed Description

Definition at line 42 of file G4ConcreteNStarNToNN.hh.

Constructor & Destructor Documentation

G4ConcreteNStarNToNN() [1/2]

G4ConcreteNStarNToNN::G4ConcreteNStarNToNN	(	const G4ParticleDefinition *	aPrimary,
		const G4ParticleDefinition *	bPriamry,
		const G4ParticleDefinition *	aSecondary,
		const G4ParticleDefinition *	bSecondary
	)

Definition at line 35 of file G4ConcreteNStarNToNN.cc.

                                                                :
        G4ConcreteNNTwoBodyResonance(NULL, NULL, NULL, NULL, NULL, NULL, NULL)
{
   if (!theSigmaTable_G4MT_TLS_) theSigmaTable_G4MT_TLS_ = new G4XNNstarTable;
   G4XNNstarTable &theSigmaTable = *theSigmaTable_G4MT_TLS_;
   establish_G4MT_TLS_G4ConcreteNNTwoBodyResonance(aPrimary,bPrimary,aSecondary,bSecondary,
                                                   G4NNstarBuilder(aPrimary->GetParticleName(),theSigmaTable));
}

References G4ConcreteNNTwoBodyResonance::establish_G4MT_TLS_G4ConcreteNNTwoBodyResonance(), G4ParticleDefinition::GetParticleName(), and theSigmaTable_G4MT_TLS_.

~G4ConcreteNStarNToNN()

G4ConcreteNStarNToNN::~G4ConcreteNStarNToNN ( )

virtual

Definition at line 47 of file G4ConcreteNStarNToNN.cc.

{ if (theSigmaTable_G4MT_TLS_) delete theSigmaTable_G4MT_TLS_;
}

References theSigmaTable_G4MT_TLS_.

G4ConcreteNStarNToNN() [2/2]

G4ConcreteNStarNToNN::G4ConcreteNStarNToNN ( const G4ConcreteNStarNToNN &  )

private

Member Function Documentation

BrWigInt0()

double G4VScatteringCollision::BrWigInt0 ( const double  x, const double  gamma, const double  m0  ) const

inlineprivateinherited

Definition at line 84 of file G4VScatteringCollision.hh.

    { return 2.0*gamma*std::atan( 2.0 * (x-m0)/ gamma  ); }

Referenced by G4VScatteringCollision::BrWigInt1(), and G4VScatteringCollision::SampleResonanceMass().

BrWigInt1()

G4double G4VScatteringCollision::BrWigInt1 ( const G4double  x, const G4double  gamma, const G4double  m0  ) const

inlineprivateinherited

Definition at line 87 of file G4VScatteringCollision.hh.

    { return 0.5*gamma*gamma*G4Log( (x-m0)*(x-m0)+gamma*gamma/4.0 ) + m0*BrWigInt0(x,gamma,m0); }

References G4VScatteringCollision::BrWigInt0(), and G4Log().

BrWigInv()

double G4VScatteringCollision::BrWigInv ( const double  x, const double  gamma, const double  m0  ) const

inlineprivateinherited

Definition at line 90 of file G4VScatteringCollision.hh.

    { return 0.5*gamma*std::tan( 0.5*x/gamma )+m0; }

Referenced by G4VScatteringCollision::SampleResonanceMass().

CrossSection()

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

virtualinherited

Reimplemented in G4CollisionComposite, G4CollisionMesonBaryonToResonance, and G4CollisionNN.

Definition at line 54 of file G4VCollision.cc.

{
    G4double sigma = 0.;
 
    const G4VCrossSectionSource* xSource = GetCrossSectionSource();
 
    if (xSource != 0)
    {
        // There is a cross section for this Collision
        sigma = xSource->CrossSection(aTrk1,aTrk2);
    }
    return sigma;
}

References G4VCrossSectionSource::CrossSection(), and G4VCollision::GetCrossSectionSource().

Referenced by G4Scatterer::GetCrossSection(), G4Scatterer::GetTimeToInteraction(), G4VCollision::Print(), and G4Scatterer::Scatter().

establish_G4MT_TLS_G4ConcreteNNTwoBodyResonance()

void G4ConcreteNNTwoBodyResonance::establish_G4MT_TLS_G4ConcreteNNTwoBodyResonance ( const G4ParticleDefinition *  aPrimary, const G4ParticleDefinition *  bPriamry, const G4ParticleDefinition *  aSecondary, const G4ParticleDefinition *  bSecondary, const G4VXResonanceTable &  sigmaTable  )

inherited

Definition at line 82 of file G4ConcreteNNTwoBodyResonance.cc.

{
  establish_G4MT_TLS_G4VScatteringCollision();
  thePrimary1=aPrimary;
  thePrimary2=bPrimary;
  theOutGoing.push_back(aSecondary);
  theOutGoing.push_back(bSecondary);
 
  crossSectionSource = new G4XResonance(aPrimary, bPrimary, 
                    aSecondary->GetPDGiIsospin(), 
                    aSecondary->GetPDGiSpin(),
                    aSecondary->GetPDGMass(),
                    bSecondary->GetPDGiIsospin(), 
                    bSecondary->GetPDGiSpin(),
                    bSecondary->GetPDGMass(),
                    aSecondary->GetParticleName(),
                    bSecondary->GetParticleName(),
                    sigmaTable);
}

References G4ConcreteNNTwoBodyResonance::crossSectionSource, G4VScatteringCollision::establish_G4MT_TLS_G4VScatteringCollision(), G4ParticleDefinition::GetParticleName(), G4ParticleDefinition::GetPDGiIsospin(), G4ParticleDefinition::GetPDGiSpin(), G4ParticleDefinition::GetPDGMass(), G4ConcreteNNTwoBodyResonance::theOutGoing, G4ConcreteNNTwoBodyResonance::thePrimary1, and G4ConcreteNNTwoBodyResonance::thePrimary2.

Referenced by G4ConcreteNNToDeltaDelta::G4ConcreteNNToDeltaDelta(), G4ConcreteNNToDeltaDeltastar::G4ConcreteNNToDeltaDeltastar(), G4ConcreteNNToDeltaNstar::G4ConcreteNNToDeltaNstar(), G4ConcreteNNToNDelta::G4ConcreteNNToNDelta(), G4ConcreteNNToNDeltaStar::G4ConcreteNNToNDeltaStar(), G4ConcreteNNToNNStar::G4ConcreteNNToNNStar(), and G4ConcreteNStarNToNN().

establish_G4MT_TLS_G4VCollision()

void G4VCollision::establish_G4MT_TLS_G4VCollision ( )

inherited

Definition at line 143 of file G4VCollision.cc.

{ }

Referenced by G4VScatteringCollision::establish_G4MT_TLS_G4VScatteringCollision().

establish_G4MT_TLS_G4VScatteringCollision()

void G4VScatteringCollision::establish_G4MT_TLS_G4VScatteringCollision ( )

inherited

Definition at line 180 of file G4VScatteringCollision.cc.

{
  establish_G4MT_TLS_G4VCollision();
  if ( theAngularDistribution ) delete theAngularDistribution;
  theAngularDistribution = new G4AngularDistribution(true);
}

References G4VCollision::establish_G4MT_TLS_G4VCollision(), and G4VScatteringCollision::theAngularDistribution.

Referenced by G4ConcreteNNTwoBodyResonance::establish_G4MT_TLS_G4ConcreteNNTwoBodyResonance().

FinalState()

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

virtualinherited

Implements G4VCollision.

Definition at line 60 of file G4VScatteringCollision.cc.

{ 
  const G4VAngularDistribution* angDistribution = GetAngularDistribution();
  G4LorentzVector p = trk1.Get4Momentum() + trk2.Get4Momentum();
  G4double sqrtS = p.m();
  G4double S = sqrtS * sqrtS;
 
  std::vector<const G4ParticleDefinition*> OutputDefinitions = GetOutgoingParticles();
  if (OutputDefinitions.size() != 2)
    throw G4HadronicException(__FILE__, __LINE__, "G4VScatteringCollision: Too many output particles!");
 
  if (OutputDefinitions[0]->IsShortLived() && OutputDefinitions[1]->IsShortLived())
  {
    if(std::getenv("G4KCDEBUG")) G4cerr << "two shortlived for Type = "<<typeid(*this).name()<<G4endl;
    // throw G4HadronicException(__FILE__, __LINE__, "G4VScatteringCollision: can't handle two shortlived particles!"); // @hpw@
  }
  
  G4double outm1 = OutputDefinitions[0]->GetPDGMass();
  G4double outm2 = OutputDefinitions[1]->GetPDGMass();
 
  if (OutputDefinitions[0]->IsShortLived())
  {
    outm1 = SampleResonanceMass(outm1, 
                OutputDefinitions[0]->GetPDGWidth(),
        G4Neutron::NeutronDefinition()->GetPDGMass()+G4PionPlus::PionPlus()->GetPDGMass(),
        sqrtS-(G4Neutron::NeutronDefinition()->GetPDGMass()+G4PionPlus::PionPlus()->GetPDGMass()));
 
  }
  if (OutputDefinitions[1]->IsShortLived())
  {
    outm2 = SampleResonanceMass(outm2, OutputDefinitions[1]->GetPDGWidth(),
            G4Neutron::NeutronDefinition()->GetPDGMass()+G4PionPlus::PionPlus()->GetPDGMass(),
            sqrtS-outm1);
  }
  
  // Angles of outgoing particles
  G4double cosTheta = angDistribution->CosTheta(S, trk1.GetActualMass(), trk2.GetActualMass());
  G4double phi = angDistribution->Phi();
 
  // Unit vector of three-momentum
  G4LorentzRotation fromCMSFrame(p.boostVector());
  G4LorentzRotation toCMSFrame(fromCMSFrame.inverse());
  G4LorentzVector TempPtr = toCMSFrame*trk1.Get4Momentum();
  G4LorentzRotation toZ;
  toZ.rotateZ(-1*TempPtr.phi());
  toZ.rotateY(-1*TempPtr.theta());
  G4LorentzRotation toCMS(toZ.inverse());
 
  G4ThreeVector pFinal1(std::sin(std::acos(cosTheta))*std::cos(phi), std::sin(std::acos(cosTheta))*std::sin(phi), cosTheta);
 
  // Three momentum in cm system
  G4double pCM = std::sqrt( (S-(outm1+outm2)*(outm1+outm2)) * (S-(outm1-outm2)*(outm1-outm2)) /(4.*S));
  pFinal1 = pFinal1 * pCM;
  G4ThreeVector pFinal2 = -pFinal1;
 
  G4double eFinal1 = std::sqrt(pFinal1.mag2() + outm1*outm1);
  G4double eFinal2 = std::sqrt(pFinal2.mag2() + outm2*outm2);
 
  G4LorentzVector p4Final1(pFinal1, eFinal1);
  G4LorentzVector p4Final2(pFinal2, eFinal2);
  p4Final1 = toCMS*p4Final1;
  p4Final2 = toCMS*p4Final2;
 
 
  // Lorentz transformation
  G4LorentzRotation toLabFrame(p.boostVector());
  p4Final1 *= toLabFrame;
  p4Final2 *= toLabFrame;
 
  // Final tracks are copies of incoming ones, with modified 4-momenta
 
  G4double chargeBalance = OutputDefinitions[0]->GetPDGCharge()+OutputDefinitions[1]->GetPDGCharge();
  chargeBalance-= trk1.GetDefinition()->GetPDGCharge();
  chargeBalance-= trk2.GetDefinition()->GetPDGCharge();
  if(std::abs(chargeBalance) >.1)
  {
    G4cout << "Charges in "<<typeid(*this).name()<<G4endl;
    G4cout << OutputDefinitions[0]->GetPDGCharge()<<" "<<OutputDefinitions[0]->GetParticleName()
           << OutputDefinitions[1]->GetPDGCharge()<<" "<<OutputDefinitions[1]->GetParticleName()
       << trk1.GetDefinition()->GetPDGCharge()<<" "<<trk1.GetDefinition()->GetParticleName()
       << trk2.GetDefinition()->GetPDGCharge()<<" "<<trk2.GetDefinition()->GetParticleName()<<G4endl;
  }
  G4KineticTrack* final1 = new G4KineticTrack(OutputDefinitions[0], 0.0, trk1.GetPosition(), p4Final1);
  G4KineticTrack* final2 = new G4KineticTrack(OutputDefinitions[1], 0.0, trk2.GetPosition(), p4Final2);
 
  G4KineticTrackVector* finalTracks = new G4KineticTrackVector;
 
  finalTracks->push_back(final1);
  finalTracks->push_back(final2);
 
  return finalTracks;
}

References CLHEP::HepLorentzVector::boostVector(), G4VAngularDistribution::CosTheta(), G4cerr, G4cout, G4endl, G4KineticTrack::Get4Momentum(), G4KineticTrack::GetActualMass(), G4VScatteringCollision::GetAngularDistribution(), G4KineticTrack::GetDefinition(), G4VScatteringCollision::GetOutgoingParticles(), G4ParticleDefinition::GetParticleName(), G4ParticleDefinition::GetPDGCharge(), G4KineticTrack::GetPosition(), CLHEP::HepLorentzRotation::inverse(), CLHEP::HepLorentzVector::m(), CLHEP::Hep3Vector::mag2(), G4Neutron::NeutronDefinition(), CLHEP::HepLorentzVector::phi(), G4VAngularDistribution::Phi(), G4PionPlus::PionPlus(), CLHEP::HepLorentzRotation::rotateY(), CLHEP::HepLorentzRotation::rotateZ(), S(), G4VScatteringCollision::SampleResonanceMass(), and CLHEP::HepLorentzVector::theta().

GetAngularDistribution()

virtual const G4VAngularDistribution * G4VScatteringCollision::GetAngularDistribution ( ) const

inlinevirtualinherited

Implements G4VCollision.

Definition at line 69 of file G4VScatteringCollision.hh.

  {
    return theAngularDistribution;
  }

References G4VScatteringCollision::theAngularDistribution.

Referenced by G4VScatteringCollision::FinalState().

GetComponents()

virtual const G4CollisionVector * G4VCollision::GetComponents ( ) const

inlineprotectedvirtualinherited

Reimplemented in G4CollisionComposite, G4CollisionNN, G4CollisionNNToDeltaDelta1600, G4CollisionNNToDeltaDelta1620, G4CollisionNNToDeltaDelta1700, G4CollisionNNToDeltaDelta1900, G4CollisionNNToDeltaDelta1905, G4CollisionNNToDeltaDelta1910, G4CollisionNNToDeltaDelta1920, G4CollisionNNToDeltaDelta1930, G4CollisionNNToDeltaDelta1950, G4CollisionNNToNDelta, G4CollisionNNToNDelta1600, G4CollisionNNToNDelta1620, G4CollisionNNToNDelta1700, G4CollisionNNToNDelta1900, G4CollisionNNToNDelta1905, G4CollisionNNToNDelta1910, G4CollisionNNToNDelta1920, G4CollisionNNToNDelta1930, and G4CollisionNNToNDelta1950.

Definition at line 79 of file G4VCollision.hh.

{ return 0;}

Referenced by G4VCollision::Print().

GetCrossSectionSource()

virtual const G4VCrossSectionSource * G4ConcreteNNTwoBodyResonance::GetCrossSectionSource ( ) const

inlineprotectedvirtualinherited

Implements G4VCollision.

Definition at line 80 of file G4ConcreteNNTwoBodyResonance.hh.

{ return crossSectionSource; }

References G4ConcreteNNTwoBodyResonance::crossSectionSource.

GetListOfColliders()

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

inlinevirtualinherited

Implements G4VCollision.

Definition at line 62 of file G4ConcreteNNTwoBodyResonance.hh.

  {
    throw G4HadronicException(__FILE__, __LINE__, "Tried to call G4ConcreteNNTwoBodyResonance::GetListOfColliders. Please find out why!");
    std::vector<G4String> * aList = new std::vector<G4String>;
    return *aList;
  } 

GetName()

virtual G4String G4ConcreteNStarNToNN::GetName ( ) const

inlinevirtual

Reimplemented from G4ConcreteNNTwoBodyResonance.

Definition at line 51 of file G4ConcreteNStarNToNN.hh.

{ return "ConcreteNNToNNStar"; }

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().

GetOutgoingParticles()

virtual const std::vector< const G4ParticleDefinition * > & G4ConcreteNNTwoBodyResonance::GetOutgoingParticles ( ) const

inlineprotectedvirtualinherited

Implements G4VScatteringCollision.

Definition at line 82 of file G4ConcreteNNTwoBodyResonance.hh.

  {
    return theOutGoing;
  }

References G4ConcreteNNTwoBodyResonance::theOutGoing.

IsInCharge()

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

virtualinherited

Implements G4VCollision.

Definition at line 70 of file G4ConcreteNNTwoBodyResonance.cc.

{
  if (trk1.GetDefinition()==thePrimary1 && trk2.GetDefinition()==thePrimary2) return true;
  if (trk1.GetDefinition()==thePrimary2 && trk2.GetDefinition()==thePrimary1) return true;
  return false;
}

References G4KineticTrack::GetDefinition(), G4ConcreteNNTwoBodyResonance::thePrimary1, and G4ConcreteNNTwoBodyResonance::thePrimary2.

operator!=() [1/3]

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

inherited

operator!=() [2/3]

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

inherited

Definition at line 48 of file G4VCollision.cc.

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

operator!=() [3/3]

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

inherited

operator=()

G4ConcreteNStarNToNN & G4ConcreteNStarNToNN::operator= ( const G4ConcreteNStarNToNN &  )

private

operator==() [1/3]

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

inherited

operator==() [2/3]

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

inherited

Definition at line 42 of file G4VCollision.cc.

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

operator==() [3/3]

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

inherited

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().

SampleResonanceMass()

double G4VScatteringCollision::SampleResonanceMass ( const double  poleMass, const double  width, const double  minMass, const double  maxMass  ) const

privateinherited

Definition at line 156 of file G4VScatteringCollision.cc.

{
  // Chooses a mass randomly between minMass and maxMass 
  //     according to a Breit-Wigner function with constant 
  //     width gamma and pole poleMass
 
  G4double minMass = aMinMass;
  if (minMass > maxMass) G4cerr << "##################### SampleResonanceMass: particle out of mass range" << G4endl;
  if(minMass > maxMass) minMass -= G4PionPlus::PionPlus()->GetPDGMass();
  if(minMass > maxMass) minMass = 0;
 
  if (gamma < 1E-10*GeV)
    return std::max(minMass,std::min(maxMass, poleMass));
  else {
    double fmin = BrWigInt0(minMass, gamma, poleMass);
    double fmax = BrWigInt0(maxMass, gamma, poleMass);
    double f = fmin + (fmax-fmin)*G4UniformRand();
    return BrWigInv(f, gamma, poleMass);
  }
}

References G4VScatteringCollision::BrWigInt0(), G4VScatteringCollision::BrWigInv(), G4cerr, G4endl, G4UniformRand, G4ParticleDefinition::GetPDGMass(), GeV, G4INCL::Math::max(), G4INCL::Math::min(), and G4PionPlus::PionPlus().

Referenced by G4VScatteringCollision::FinalState().

Field Documentation

crossSectionSource

G4VCrossSectionSource* G4ConcreteNNTwoBodyResonance::crossSectionSource

privateinherited

Definition at line 93 of file G4ConcreteNNTwoBodyResonance.hh.

Referenced by G4ConcreteNNTwoBodyResonance::establish_G4MT_TLS_G4ConcreteNNTwoBodyResonance(), G4ConcreteNNTwoBodyResonance::G4ConcreteNNTwoBodyResonance(), G4ConcreteNNTwoBodyResonance::GetCrossSectionSource(), and G4ConcreteNNTwoBodyResonance::~G4ConcreteNNTwoBodyResonance().

theAngularDistribution

G4VAngularDistribution* G4VScatteringCollision::theAngularDistribution

privateinherited

Definition at line 99 of file G4VScatteringCollision.hh.

Referenced by G4VScatteringCollision::establish_G4MT_TLS_G4VScatteringCollision(), G4VScatteringCollision::G4VScatteringCollision(), G4VScatteringCollision::GetAngularDistribution(), and G4VScatteringCollision::~G4VScatteringCollision().

theOutGoing

std::vector<const G4ParticleDefinition*> G4ConcreteNNTwoBodyResonance::theOutGoing

privateinherited

Definition at line 96 of file G4ConcreteNNTwoBodyResonance.hh.

Referenced by G4ConcreteNNTwoBodyResonance::establish_G4MT_TLS_G4ConcreteNNTwoBodyResonance(), G4ConcreteNNTwoBodyResonance::G4ConcreteNNTwoBodyResonance(), and G4ConcreteNNTwoBodyResonance::GetOutgoingParticles().

thePrimary1

const G4ParticleDefinition* G4ConcreteNNTwoBodyResonance::thePrimary1

privateinherited

Definition at line 94 of file G4ConcreteNNTwoBodyResonance.hh.

Referenced by G4ConcreteNNTwoBodyResonance::establish_G4MT_TLS_G4ConcreteNNTwoBodyResonance(), and G4ConcreteNNTwoBodyResonance::IsInCharge().

thePrimary2

const G4ParticleDefinition* G4ConcreteNNTwoBodyResonance::thePrimary2

privateinherited

Definition at line 95 of file G4ConcreteNNTwoBodyResonance.hh.

Referenced by G4ConcreteNNTwoBodyResonance::establish_G4MT_TLS_G4ConcreteNNTwoBodyResonance(), and G4ConcreteNNTwoBodyResonance::IsInCharge().

theSigmaTable_G4MT_TLS_

G4ThreadLocal G4XNNstarTable * G4ConcreteNStarNToNN::theSigmaTable_G4MT_TLS_ = 0

staticprivate

Definition at line 59 of file G4ConcreteNStarNToNN.hh.

Referenced by G4ConcreteNStarNToNN(), and ~G4ConcreteNStarNToNN().

---

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

• source/processes/hadronic/models/im_r_matrix/include/G4ConcreteNStarNToNN.hh
• source/processes/hadronic/models/im_r_matrix/src/G4ConcreteNStarNToNN.cc