//=============================================================================
// decay particle
//=============================================================================
void EvtBToDDalitzCPK::decay( EvtParticle * p )
{
if ( _flag == 1 ) {
// PHSP
p -> initializePhaseSpace( getNDaug() , getDaugs() ) ;
vertex ( 0. ) ;
}
else if ( _flag == 2 ) {
// SVS
p->initializePhaseSpace(getNDaug(),getDaugs());
EvtParticle *v;
v = p->getDaug(0);
double massv = v->mass();
EvtVector4R momv = v->getP4();
EvtVector4R moms = p->getDaug(1)->getP4();
double m_parent = p->mass();
EvtVector4R p4_parent = momv+moms;
double norm=massv/(momv.d3mag()*m_parent);
p4_parent = norm*p4_parent;
vertex(0,p4_parent*(v->epsParent(0)));
vertex(1,p4_parent*(v->epsParent(1)));
vertex(2,p4_parent*(v->epsParent(2)));
}
}
void EvtSSD_DirectCP::decay( EvtParticle *p) {
bool flip = false ;
EvtId daugs[2];
// decide it is B or Bbar:
if ( EvtRandom::Flat(0.,1.) < ( ( 1. - _acp ) / 2. ) ) {
// it is a B
if ( EvtPDL::getStdHep( getParentId() ) < 0 ) flip = true ;
} else {
// it is a Bbar
if ( EvtPDL::getStdHep( getParentId() ) > 0 ) flip = true ;
}
if ( flip ) {
if ( ( isB0Mixed( p ) ) || ( isBsMixed( p ) ) ) {
p->getParent()
->setId( EvtPDL::chargeConj( p->getParent()->getId() ) ) ;
p->setId( EvtPDL::chargeConj( p->getId() ) ) ;
}
else {
p->setId( EvtPDL::chargeConj( p->getId() ) ) ;
}
}
if (!flip) {
daugs[0]=getDaug(0);
daugs[1]=getDaug(1);
}
else {
daugs[0]=EvtPDL::chargeConj(getDaug(0));
daugs[1]=EvtPDL::chargeConj(getDaug(1));
}
EvtParticle *d;
p->initializePhaseSpace(2, daugs);
EvtVector4R p4_parent=p->getP4Restframe();
double m_parent=p4_parent.mass();
EvtSpinType::spintype d2type=EvtPDL::getSpinType(getDaug(1));
EvtVector4R momv;
EvtVector4R moms;
if (d2type==EvtSpinType::SCALAR) {
d2type=EvtPDL::getSpinType(getDaug(0));
d= p->getDaug(0);
momv = d->getP4();
moms = p->getDaug(1)->getP4();
}
else {
d= p->getDaug(1);
momv = d->getP4();
moms = p->getDaug(0)->getP4();
}
if (d2type==EvtSpinType::SCALAR) {
vertex(1.);
}
if (d2type==EvtSpinType::VECTOR) {
double norm=momv.mass()/(momv.d3mag()*p->mass());
vertex(0,norm*p4_parent*(d->epsParent(0)));
vertex(1,norm*p4_parent*(d->epsParent(1)));
vertex(2,norm*p4_parent*(d->epsParent(2)));
}
if (d2type==EvtSpinType::TENSOR) {
double norm=
d->mass()*d->mass()/(m_parent*d->getP4().d3mag()*d->getP4().d3mag());
vertex(0,norm*d->epsTensorParent(0).cont1(p4_parent)*p4_parent);
vertex(1,norm*d->epsTensorParent(1).cont1(p4_parent)*p4_parent);
vertex(2,norm*d->epsTensorParent(2).cont1(p4_parent)*p4_parent);
vertex(3,norm*d->epsTensorParent(3).cont1(p4_parent)*p4_parent);
vertex(4,norm*d->epsTensorParent(4).cont1(p4_parent)*p4_parent);
}
}
void EvtSVSNONCPEIGEN::decay( EvtParticle *p){
//added by Lange Jan4,2000
static EvtId B0=EvtPDL::getId("B0");
static EvtId B0B=EvtPDL::getId("anti-B0");
double t;
EvtId other_b;
EvtId daugs[2];
// MB: flip selects the final of the decay
int flip = ((p->getId() == B0) ? 0 : 1);
daugs[0]=getDaug(0);
daugs[1]=getDaug(1);
p->initializePhaseSpace(2, daugs);
EvtCPUtil::getInstance()->OtherB(p,t,other_b,0.5);
EvtComplex amp;
double dmt2 = (_dm * t) / (2 * EvtConst::c);
EvtComplex ePlusIPhi(cos(_phickm), sin(_phickm));
EvtComplex eMinusIPhi(cos(-_phickm), -sin(_phickm));
// flip == 0 : D-rho+
// flip == 1 : D+rho-
if (!flip) {
if (other_b==B0B){
// At t=0 we have a B0
amp = cos(dmt2)*_A_f + eMinusIPhi*EvtComplex(0.0,sin(dmt2))*_Abar_f;
}
if (other_b==B0){
// At t=0 we have a B0bar
amp = ePlusIPhi*EvtComplex(0.0,sin(dmt2))*_A_f + cos(dmt2)*_Abar_f;
}
}
else{
if (other_b==B0B){
// At t=0 we have a B0
amp = cos(dmt2)*_A_fbar + eMinusIPhi*EvtComplex(0.0,sin(dmt2))*_Abar_fbar;
}
if (other_b==B0){
// At t=0 we have a B0bar
amp = ePlusIPhi*EvtComplex(0.0,sin(dmt2))*_A_fbar + cos(dmt2)*_Abar_fbar;
}
}
EvtParticle *v;
v= p->getDaug(0);
EvtVector4R momv = p->getDaug(0)->getP4();
EvtVector4R moms = p->getDaug(1)->getP4();
EvtVector4R p4_parent=momv+moms;
double norm=momv.mass()/(momv.d3mag()*p->mass());
vertex(0,amp*norm*p4_parent*(v->epsParent(0)));
vertex(1,amp*norm*p4_parent*(v->epsParent(1)));
vertex(2,amp*norm*p4_parent*(v->epsParent(2)));
return ;
}
void EvtVectorIsr::decay( EvtParticle *p ){
//the elctron mass
double electMass=EvtPDL::getMeanMass(EvtPDL::getId("e-"));
static EvtId gammaId=EvtPDL::getId("gamma");
EvtParticle *phi;
EvtParticle *gamma;
//4-mom of the two colinear photons to the decay of the vphoton
EvtVector4R p4softg1(0.,0.,0.,0.);
EvtVector4R p4softg2(0.,0.,0.,0.);
//get pointers to the daughters set
//get masses/initial phase space - will overwrite the
//p4s below to get the kinematic distributions correct
p->initializePhaseSpace(getNDaug(),getDaugs());
phi=p->getDaug(0);
gamma=p->getDaug(1);
//Generate soft colinear photons and the electron and positron energies after emission.
//based on method of AfkQed and notes of Vladimir Druzhinin.
//
//function ckhrad(eb,q2m,r1,r2,e01,e02,f_col)
//eb: energy of incoming electrons in CM frame
//q2m: minimum invariant mass of the virtual photon after soft colinear photon emission
//returned arguments
//e01,e02: energies of e+ and e- after soft colinear photon emission
//fcol: weighting factor for Born cross section for use in an accept/reject test.
double wcm=p->mass();
double eb=0.5*wcm;
//TO guarantee the collinear photons are softer than the ISR photon, require q2m > m*wcm
double q2m=phi->mass()*wcm;
double f_col(0.);
double e01(0.);
double e02(0.);
double ebeam=eb;
double wcm_new = wcm;
double s_new = wcm*wcm;
double fran = 1.;
double f = 0;
int m = 0;
double largest_f=0;//only used when determining max weight for this vector particle mass
if (!firstorder){
while (fran > f){
m++;
int n=0;
while (f_col == 0.){
n++;
ckhrad(eb,q2m,e01,e02,f_col);
if (n > 10000){
report(Severity::Info,"EvtGen") << "EvtVectorIsr is having problems. Called ckhrad 10000 times.\n";
assert(0);
}
}
//Effective beam energy after soft photon emission (neglecting electron mass)
ebeam = sqrt(e01*e02);
wcm_new = 2*ebeam;
s_new = wcm_new*wcm_new;
//The Vector mass should never be greater than wcm_new
if (phi->mass() > wcm_new){
report(Severity::Info,"EvtGen") << "EvtVectorIsr finds Vector mass="<<phi->mass()<<" > Weff=" << wcm_new<<". Should not happen\n";
assert(0);
}
//Determine Born cross section @ wcm_new for e+e- -> gamma V. We aren't interested in the absolute normalization
//Just the functional dependence. Assuming a narrow resonance when determining cs_Born
double cs_Born = 1.;
if (EvtPDL::getMaxRange(phi->getId()) > 0.) {
double x0 = 1 - EvtPDL::getMeanMass(phi->getId())*EvtPDL::getMeanMass(phi->getId())/s_new;
//L = log(s/(electMass*electMass)
double L = 2.*log(wcm_new/electMass);
// W(x0) is actually 2*alpha/pi times the following
double W = (L-1.)*(1. - x0 +0.5*x0*x0);
//Born cross section is actually 12*pi*pi*Gammaee/EvtPDL::getMeanMass(phi->getId()) times the following
//(we'd need the full W(x0) as well)
cs_Born = W/s_new;
}
f = cs_Born*f_col;
//if fmax was set properly, f should NEVER be larger than fmax
if (f > fmax && fmax > 0.){
report(Severity::Info,"EvtGen") << "EvtVectorIsr finds a problem with fmax, the maximum weight setting\n"
<< "fmax is the third decay argument in the .dec file. VectorIsr attempts to set it reasonably if it wasn't provided\n"
<< "To determine a more appropriate value, build GeneratorQAApp, and set the third argument for this decay <0.\n"
<< "If you haven't been providing the first 2 arguments, set them to be 1. 1.). The program will report\n"
<< "the largest weight it finds. You should set fmax to be slightly larger.\n"
<< "Alternatively try the following values for various vector particles: "
<< "phi->1.15 J/psi-psi(4415)->0.105\n"
<< "The current value of f and fmax for " << EvtPDL::name(phi->getId()) << " are " << f << " " << fmax << "\n"
<< "Will now assert\n";
assert(0);
}
if (fmax > 0.) {
fran = fmax*EvtRandom::Flat(0.0,1.0);
}
else {
//determine max weight for this vector particle mass
if (f>largest_f) {
largest_f = f;
report(Severity::Info,"EvtGen") << m << " " << EvtPDL::name(phi->getId()) << " "
<< "vector_mass "
<< " " << EvtPDL::getMeanMass(phi->getId()) << " fmax should be at least " << largest_f
<< ". f_col cs_B = " << f_col << " " << cs_Born
<< std::endl;
}
if (m%10000 == 0) {
report(Severity::Info,"EvtGen") << m << " " << EvtPDL::name(phi->getId()) << " "
<< "vector_mass "
<< " " << EvtPDL::getMeanMass(phi->getId()) << " fmax should be at least " << largest_f
<< ". f_col cs_B = " << f_col << " " << cs_Born
<< std::endl;
}
f_col = 0.;
f = 0.;
//determine max weight for this vector particle mass
}
if (m > 100000){
if (fmax > 0.) report(Severity::Info,"EvtGen") << "EvtVectorIsr is having problems. Check the fmax value - the 3rd argument in the .dec file\n"
<< "Recommended values for various vector particles: "
<< "phi->1.15 J/psi-psi(4415)->0.105 "
<< "Upsilon(1S,2S,3S)->0.14\n";
assert(0);
}
}//while (fran > f)
}//if (firstorder)
//Compute parameters for boost to/from the system after colinear radiation
double bet_l;
double gam_l;
double betgam_l;
double csfrmn_new;
double csbkmn_new;
if (firstorder){
bet_l = 0.;
gam_l = 1.;
betgam_l = 0.;
csfrmn_new = csfrmn;
csbkmn_new = csbkmn;
} else {
double xx = e02/e01;
double sq_xx = sqrt(xx);
bet_l = (1.-xx)/(1.+xx);
gam_l = (1.+xx)/(2.*sq_xx);
betgam_l = (1.-xx)/(2.*sq_xx);
//Boost photon cos_theta limits in lab to limits in the system after colinear rad
csfrmn_new=(csfrmn - bet_l)/(1. - bet_l*csfrmn);
csbkmn_new=(csbkmn - bet_l)/(1. - bet_l*csbkmn);
}
// //generate kinematics according to Bonneau-Martin article
// //Nucl. Phys. B27 (1971) 381-397
// For backward compatibility with .dec files before SP5, the backward cos limit for
//the ISR photon is actually given as *minus* the actual limit. Sorry, this wouldn't be
//my choice. -Joe
//gamma momentum in the vpho restframe *after* soft colinear radiation
double pg = (s_new - phi->mass()*phi->mass())/(2.*wcm_new);
//calculate the beta of incoming electrons after colinear rad in the frame where e= and e- have equal momentum
double beta=electMass/ebeam; //electMass/Ebeam = 1/gamma
beta=sqrt(1. - beta*beta); //sqrt (1 - (1/gamma)**2)
double ymax=log((1.+beta*csfrmn_new)/(1.-beta*csfrmn_new));
double ymin=log((1.-beta*csbkmn_new)/(1.+beta*csbkmn_new));
// photon theta distributed as 2*beta/(1-beta**2*cos(theta)**2)
double y=(ymax-ymin)*EvtRandom::Flat(0.0,1.0) + ymin;
double cs=exp(y);
cs=(cs - 1.)/(cs + 1.)/beta;
double sn=sqrt(1-cs*cs);
double fi=EvtRandom::Flat(EvtConst::twoPi);
//four-vector for the phi
double phi_p0 = sqrt(phi->mass()*phi->mass()+pg*pg);
double phi_p3 = -pg*cs;
//boost back to frame before colinear radiation.
EvtVector4R p4phi(gam_l*phi_p0 + betgam_l*phi_p3,
-pg*sn*cos(fi),
-pg*sn*sin(fi),
betgam_l*phi_p0 + gam_l*phi_p3);
double isr_p0 = pg;
double isr_p3 = -phi_p3;
EvtVector4R p4gamma(gam_l*isr_p0 + betgam_l*isr_p3,
-p4phi.get(1),
-p4phi.get(2),
betgam_l*isr_p0 + gam_l*isr_p3);
//four-vectors of the collinear photons
if (!firstorder) {
p4softg1.set(0, eb-e02); p4softg1.set(3, e02-eb);
p4softg2.set(0, eb-e01); p4softg2.set(3, eb-e01);
}
//save momenta for particles
phi->init( getDaug(0),p4phi);
gamma->init( getDaug(1),p4gamma);
//add the two colinear photons as vphoton daughters
EvtPhotonParticle *softg1=new EvtPhotonParticle;;
EvtPhotonParticle *softg2=new EvtPhotonParticle;;
softg1->init(gammaId,p4softg1);
softg2->init(gammaId,p4softg2);
softg1->addDaug(p);
softg2->addDaug(p);
//try setting the spin density matrix of the phi
//get polarization vector for phi in its parents restframe.
EvtVector4C phi0=phi->epsParent(0);
EvtVector4C phi1=phi->epsParent(1);
EvtVector4C phi2=phi->epsParent(2);
//get polarization vector for a photon in its parents restframe.
EvtVector4C gamma0=gamma->epsParentPhoton(0);
EvtVector4C gamma1=gamma->epsParentPhoton(1);
EvtComplex r1p=phi0*gamma0;
EvtComplex r2p=phi1*gamma0;
EvtComplex r3p=phi2*gamma0;
EvtComplex r1m=phi0*gamma1;
EvtComplex r2m=phi1*gamma1;
EvtComplex r3m=phi2*gamma1;
EvtComplex rho33=r3p*conj(r3p)+r3m*conj(r3m);
EvtComplex rho22=r2p*conj(r2p)+r2m*conj(r2m);
EvtComplex rho11=r1p*conj(r1p)+r1m*conj(r1m);
EvtComplex rho13=r3p*conj(r1p)+r3m*conj(r1m);
EvtComplex rho12=r2p*conj(r1p)+r2m*conj(r1m);
EvtComplex rho23=r3p*conj(r2p)+r3m*conj(r2m);
EvtComplex rho31=conj(rho13);
EvtComplex rho32=conj(rho23);
EvtComplex rho21=conj(rho12);
EvtSpinDensity rho;
rho.setDim(3);
rho.set(0,0,rho11);
rho.set(0,1,rho12);
rho.set(0,2,rho13);
rho.set(1,0,rho21);
rho.set(1,1,rho22);
rho.set(1,2,rho23);
rho.set(2,0,rho31);
rho.set(2,1,rho32);
rho.set(2,2,rho33);
setDaughterSpinDensity(0);
phi->setSpinDensityForward(rho);
return ;
}