#include <G4INCLNDeltaToDeltaLKChannel.hh>

Inheritance diagram for G4INCL::NDeltaToDeltaLKChannel:

Public Member Functions
	NDeltaToDeltaLKChannel (Particle , Particle )

virtual	~NDeltaToDeltaLKChannel ()

void	fillFinalState (FinalState *fs)

Public Member Functions inherited from G4INCL::IChannel
	IChannel ()

virtual	~IChannel ()

FinalState *	getFinalState ()

virtual void	fillFinalState (FinalState *fs)=0

Detailed Description

Definition at line 47 of file G4INCLNDeltaToDeltaLKChannel.hh.

Constructor & Destructor Documentation

◆ NDeltaToDeltaLKChannel()

G4INCL::NDeltaToDeltaLKChannel::NDeltaToDeltaLKChannel	(	Particle *	p1,
		Particle *	p2
	)

Definition at line 51 of file G4INCLNDeltaToDeltaLKChannel.cc.

52 : particle1(p1), particle2(p2)

53 {}

◆ ~NDeltaToDeltaLKChannel()

G4INCL::NDeltaToDeltaLKChannel::~NDeltaToDeltaLKChannel ( )

virtual

Definition at line 55 of file G4INCLNDeltaToDeltaLKChannel.cc.

55{}

Member Function Documentation

◆ fillFinalState()

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

virtual

Implements G4INCL::IChannel.

Definition at line 96 of file G4INCLNDeltaToDeltaLKChannel.cc.

                                                              {
        // D++ p -> L K+ D++ (4)
        //
        // D++ n -> L K+ D+  (3)
        // D++ n -> L K0 D++ (4)
        //
        // D+  p -> L K0 D++ (3)
        // D+  p -> L K+ D+  (2)
        //
        // D+  n -> L K+ D0  (4)
        // D+  n -> L K0 D+  (2)
        
        Particle *delta;
        Particle *nucleon;
        
        if (particle1->isResonance()) {
            delta = particle1;
            nucleon = particle2;
        }
        else {
            delta = particle2;
            nucleon = particle1;
        }
        
        
        const G4double sqrtS = KinematicsUtils::totalEnergyInCM(particle1, particle2);
        
        const G4int iso = ParticleTable::getIsospin(particle1->getType()) + ParticleTable::getIsospin(particle2->getType());
        const G4int iso_d = ParticleTable::getIsospin(delta->getType());
        const G4double rdm = Random::shoot();
        
/*      const G4double m1 = particle1->getMass();
        const G4double m2 = particle2->getMass();
        const G4double pLab = KinematicsUtils::momentumInLab(particle1, particle2);*/
        
        ParticleType KaonType;
        ParticleType DeltaType;
        nucleon->setType(Lambda);
        
        if(std::abs(iso) == 4){// D++ p
            KaonType = ParticleTable::getKaonType(iso/4);
            DeltaType = ParticleTable::getDeltaType(3*iso/4);
        }
        else if(iso == 0){// D+  n
            if(rdm*3 < 2){
                KaonType = ParticleTable::getKaonType(iso_d);
                DeltaType = ParticleTable::getDeltaType(-iso_d);
            }
            else{
                KaonType = ParticleTable::getKaonType(-iso_d);
                DeltaType = ParticleTable::getDeltaType(iso_d);
            }
        }
        else if(ParticleTable::getIsospin(particle1->getType()) == ParticleTable::getIsospin(particle2->getType())){// D+  p
            if(rdm*5 < 3){
                KaonType = ParticleTable::getKaonType(-iso/2);
                DeltaType = ParticleTable::getDeltaType(3*iso/2);
            }
            else{
                KaonType = ParticleTable::getKaonType(iso/2);
                DeltaType = ParticleTable::getDeltaType(iso/2);
            }
        }
        else{// D++ n 
            if(rdm*7 < 3){
                KaonType = ParticleTable::getKaonType(iso/2);
                DeltaType = ParticleTable::getDeltaType(iso/2);
            }
            else{
                KaonType = ParticleTable::getKaonType(-iso/2);
                DeltaType = ParticleTable::getDeltaType(3*iso/2);
            }
        }
        
        delta->setType(DeltaType);
        delta->setMass(sampleDeltaMass(sqrtS));
        
        ParticleList list;
        list.push_back(delta);
        list.push_back(nucleon);
        const ThreeVector &rcol = nucleon->getPosition();
        const ThreeVector zero;
        Particle *kaon = new Particle(KaonType,zero,rcol);
        list.push_back(kaon);
        
        if(Random::shoot()<0.5) PhaseSpaceGenerator::generateBiased(sqrtS, list, 0, angularSlope);
        else PhaseSpaceGenerator::generateBiased(sqrtS, list, 1, angularSlope);
        
        
        fs->addModifiedParticle(delta);
        fs->addModifiedParticle(nucleon);
        fs->addCreatedParticle(kaon);
        
    }