G4INCL::DeltaDecayChannel Class Reference

#include <G4INCLDeltaDecayChannel.hh>

Inheritance diagram for G4INCL::DeltaDecayChannel:

Public Member Functions
	DeltaDecayChannel (Particle *, ThreeVector const &)
void	fillFinalState (FinalState *fs)
FinalState *	getFinalState ()
virtual	~DeltaDecayChannel ()

Static Public Member Functions
static G4double	computeDecayTime (Particle *p)

Private Member Functions
void	sampleAngles (G4double *, G4double *, G4double *)

Private Attributes
ThreeVector const	incidentDirection
Particle *	theParticle

Detailed Description

Definition at line 49 of file G4INCLDeltaDecayChannel.hh.

Constructor & Destructor Documentation

DeltaDecayChannel()

G4INCL::DeltaDecayChannel::DeltaDecayChannel	(	Particle *	p,
		ThreeVector const &	dir
	)

Definition at line 46 of file G4INCLDeltaDecayChannel.cc.

    :theParticle(p), incidentDirection(dir)
  { }

~DeltaDecayChannel()

G4INCL::DeltaDecayChannel::~DeltaDecayChannel ( )

virtual

Definition at line 50 of file G4INCLDeltaDecayChannel.cc.

{}

Member Function Documentation

computeDecayTime()

G4double G4INCL::DeltaDecayChannel::computeDecayTime ( Particle *  p )

static

Definition at line 52 of file G4INCLDeltaDecayChannel.cc.

                                                          {
    const G4double m = p->getMass();
    const G4double g0 = 115.0;
    G4double gg = g0;
    if(m > 1500.0) gg = 200.0;
    const G4double geff = p->getEnergy()/m;
    const G4double qqq = KinematicsUtils::momentumInCM(m, ParticleTable::effectiveNucleonMass, ParticleTable::effectivePionMass);
    const G4double psf = std::pow(qqq, 3)/(std::pow(qqq, 3) + 5832000.0); // phase space factor    5.832E6 = 180^3
    const G4double tdel = -G4INCL::PhysicalConstants::hc/(gg*psf)*std::log(Random::shoot())*geff; // fm
    if( m > 1400) return tdel * 1./(1. + std::pow((m-1400)/g0,2)); // reduction of Delta life time for high masses.
    return tdel; // fm
  }

References G4INCL::ParticleTable::effectiveNucleonMass, G4INCL::ParticleTable::effectivePionMass, G4INCL::Particle::getEnergy(), G4INCL::Particle::getMass(), G4INCL::PhysicalConstants::hc, m, G4INCL::KinematicsUtils::momentumInCM(), and G4INCL::Random::shoot().

Referenced by G4INCL::StandardPropagationModel::generateDecays().

fillFinalState()

void G4INCL::DeltaDecayChannel::fillFinalState ( FinalState *  fs )

virtual

Implements G4INCL::IChannel.

Definition at line 78 of file G4INCLDeltaDecayChannel.cc.

                                                       {
    //      SUBROUTINE DECAY2(P1,P2,P3,WP,ij,
    //     s       X1,X2,hel,B1,B2,B3)
 
    // This routine describes the anisotropic decay of a particle of mass
    // xi into 2 particles of masses x1,x2.
    // The anisotropy is supposed to follow a 1+3*hel*(cos(theta))**2
    // law with respect to the direction of the incoming particle.
    // In the input, p1,p2,p3 is the momentum of particle xi.
    // In the output, p1,p2,p3 is the momentum of particle x1 , while
    // q1,q2,q3 is the momentum of particle x2.
 
    //  COMMON/bl12/QQ1(200),QQ2(200),QQ3(200),QQ4(200),
    // s            YY1(200),YY2(200),YY3(200),YM(200),IPI(200)
    //   common/hazard/ial,IY1,IY2,IY3,IY4,IY5,IY6,IY7,IY8,IY9,IY10,
    // s               IY11,IY12,IY13,IY14,IY15,IY16,IY17,IY18,IY19
 
    // DATA IY8,IY9,IY10/82345,92345,45681/
    // PCM(E,A,C)=0.5*SQRT((E**2-(A+C)**2)*(E**2-(A-C)**2))/E            P-N20800
    // XI=YM(ij)
 
    // XE=WP                                                             P-N20810
    // B1=P1/XE                                                          P-N20820
    // B2=P2/XE                                                          P-N20830
    // B3=P3/XE
    // XQ=PCM(XI,X1,X2)
 
    const G4double deltaMass = theParticle->getMass();
 
    G4double fi, ctet, stet;
    sampleAngles(&ctet, &stet, &fi);
 
    G4double cfi = std::cos(fi);
    G4double sfi = std::sin(fi);
    G4double beta = incidentDirection.mag();
 
    G4double q1, q2, q3;
    G4double sal=0.0;
    if (beta >= 1.0e-10)
      sal = incidentDirection.perp()/beta;
    if (sal >= 1.0e-6) {
      G4double b1 = incidentDirection.getX();
      G4double b2 = incidentDirection.getY();
      G4double b3 = incidentDirection.getZ();
      G4double cal = b3/beta;
      G4double t1 = ctet+cal*stet*sfi/sal;
      G4double t2 = stet/sal;
      q1=(b1*t1+b2*t2*cfi)/beta;
      q2=(b2*t1-b1*t2*cfi)/beta;
      q3=(b3*t1/beta-t2*sfi);
    } else {
      q1 = stet*cfi;
      q2 = stet*sfi;
      q3 = ctet;
    }
    theParticle->setHelicity(0.0);
 
    ParticleType pionType;
    switch(theParticle->getType()) {
      case DeltaPlusPlus:
        theParticle->setType(Proton);
        pionType = PiPlus;
        break;
      case DeltaPlus:
        if(Random::shoot() < 1.0/3.0) {
          theParticle->setType(Neutron);
          pionType = PiPlus;
        } else {
          theParticle->setType(Proton);
          pionType = PiZero;
        }
        break;
      case DeltaZero:
        if(Random::shoot() < 1.0/3.0) {
          theParticle->setType(Proton);
          pionType = PiMinus;
        } else {
          theParticle->setType(Neutron);
          pionType = PiZero;
        }
        break;
      case DeltaMinus:
        theParticle->setType(Neutron);
        pionType = PiMinus;
        break;
      default:
        INCL_FATAL("Unrecognized delta type; type=" << theParticle->getType() << '\n');
        pionType = UnknownParticle;
        break;
    }
 
    G4double xq = KinematicsUtils::momentumInCM(deltaMass,
        theParticle->getMass(),
        ParticleTable::getINCLMass(pionType));
 
    q1 *= xq;
    q2 *= xq;
    q3 *= xq;
 
    ThreeVector pionMomentum(q1, q2, q3);
    ThreeVector pionPosition(theParticle->getPosition());
    Particle *pion = new Particle(pionType, pionMomentum, pionPosition);
    theParticle->setMomentum(-pionMomentum);
    theParticle->adjustEnergyFromMomentum();
 
    fs->addModifiedParticle(theParticle);
    fs->addCreatedParticle(pion);
    //      call loren(q1,q2,q3,b1,b2,b3,wq)
    //      call loren(p1,p2,p3,b1,b2,b3,wp)
    //      qq1(ij)=q1
    //      qq2(ij)=q2
    //      qq3(ij)=q3
    //      qq4(ij)=wq
    //      ym(ij)=xi
    //      RETURN                                                            P-N21120
    //      END                                                               P-N21130
  }

References G4INCL::FinalState::addCreatedParticle(), G4INCL::FinalState::addModifiedParticle(), G4INCL::Particle::adjustEnergyFromMomentum(), anonymous_namespace{G4PionRadiativeDecayChannel.cc}::beta, G4INCL::DeltaMinus, G4INCL::DeltaPlus, G4INCL::DeltaPlusPlus, G4INCL::DeltaZero, G4INCL::ParticleTable::getINCLMass(), G4INCL::Particle::getMass(), G4INCL::Particle::getPosition(), G4INCL::Particle::getType(), G4INCL::ThreeVector::getX(), G4INCL::ThreeVector::getY(), G4INCL::ThreeVector::getZ(), incidentDirection, INCL_FATAL, G4INCL::ThreeVector::mag(), G4INCL::KinematicsUtils::momentumInCM(), G4INCL::Neutron, G4INCL::ThreeVector::perp(), G4INCL::PiMinus, G4InuclParticleNames::pion(), G4INCL::PiPlus, G4INCL::PiZero, G4INCL::Proton, sampleAngles(), G4INCL::Particle::setHelicity(), G4INCL::Particle::setMomentum(), G4INCL::Particle::setType(), G4INCL::Random::shoot(), theParticle, and G4INCL::UnknownParticle.

getFinalState()

FinalState * G4INCL::IChannel::getFinalState ( )

inherited

Definition at line 50 of file G4INCLIChannel.cc.

                                      {
    FinalState *fs = new FinalState;
    fillFinalState(fs);
    return fs;
  }

References G4INCL::IChannel::fillFinalState().

sampleAngles()

void G4INCL::DeltaDecayChannel::sampleAngles ( G4double *  ctet_par, G4double *  stet_par, G4double *  phi_par  )

private

Definition at line 65 of file G4INCLDeltaDecayChannel.cc.

                                                                                                {
    const G4double hel = theParticle->getHelicity();
    unsigned long loopCounter = 0;
    const unsigned long maxLoopCounter = 10000000;
    do {
      (*ctet_par) = -1.0 + 2.0*Random::shoot();
      if(std::abs(*ctet_par) > 1.0) (*ctet_par) = Math::sign(*ctet_par);
      ++loopCounter;
    } while(loopCounter<maxLoopCounter && Random::shoot() > ((1.0 + 3.0 * hel * (*ctet_par) * (*ctet_par)) /(1.0 + 3.0 * hel))); /* Loop checking, 10.07.2015, D.Mancusi */
    (*stet_par) = std::sqrt(1.-(*ctet_par)*(*ctet_par));
    (*phi_par) = Math::twoPi * Random::shoot();
  }

References G4INCL::Particle::getHelicity(), G4INCL::Random::shoot(), G4INCL::Math::sign(), theParticle, and G4INCL::Math::twoPi.

Referenced by fillFinalState().

Field Documentation

incidentDirection

ThreeVector const G4INCL::DeltaDecayChannel::incidentDirection

private

Definition at line 61 of file G4INCLDeltaDecayChannel.hh.

Referenced by fillFinalState().

theParticle

Particle* G4INCL::DeltaDecayChannel::theParticle

private

Definition at line 60 of file G4INCLDeltaDecayChannel.hh.

Referenced by fillFinalState(), and sampleAngles().

---

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

• source/processes/hadronic/models/inclxx/incl_physics/include/G4INCLDeltaDecayChannel.hh
• source/processes/hadronic/models/inclxx/incl_physics/src/G4INCLDeltaDecayChannel.cc