EvtSpinDensity EvtAmp::getForwardSpinDensity(EvtSpinDensity *rho_list,int i){
EvtSpinDensity rho;
rho.setDim(dstates[i]);
int k;
if (dstates[i]==1) {
rho.set(0,0,EvtComplex(1.0,0.0));
return rho;
}
EvtAmp ampprime;
ampprime=(*this);
if (_pstates!=1){
ampprime=ampprime.contract(0,rho_list[0]);
}
for(k=0;k<i;k++){
if (dstates[k]!=1){
ampprime=ampprime.contract(_dnontrivial[k],rho_list[k+1]);
}
}
return ampprime.contract(_dnontrivial[i],(*this));
}
EvtSpinDensity EvtAmp::getBackwardSpinDensity(EvtSpinDensity *rho_list){
EvtSpinDensity rho;
rho.setDim(_pstates);
if (_pstates==1){
rho.set(0,0,EvtComplex(1.0,0.0));
return rho;
}
int k;
EvtAmp ampprime;
ampprime=(*this);
for(k=0;k<_ndaug;k++){
if (dstates[k]!=1){
ampprime=ampprime.contract(_dnontrivial[k],rho_list[k+1]);
}
}
return ampprime.contract(0,(*this));
}
void EvtDecayAmp::makeDecay(EvtParticle* p, bool recursive){
//original default value
int ntimes=10000;
int more;
EvtSpinDensity rho;
double prob,prob_max;
_amp2.init(p->getId(),getNDaug(),getDaugs());
do{
_daugsDecayedByParentModel=false;
_weight = 1.0;
decay(p);
rho=_amp2.getSpinDensity();
prob=p->getSpinDensityForward().normalizedProb(rho);
if (prob<0.0) {
EvtGenReport(EVTGEN_ERROR,"EvtGen")<<"Negative prob:"<<p->getId().getId()
<<" "<<p->getChannel()<<endl;
EvtGenReport(EVTGEN_ERROR,"EvtGen") << "rho_forward:"<<endl;
EvtGenReport(EVTGEN_ERROR,"EvtGen") << p->getSpinDensityForward();
EvtGenReport(EVTGEN_ERROR,"EvtGen") << "rho decay:"<<endl;
EvtGenReport(EVTGEN_ERROR,"EvtGen") << rho <<endl;
}
if (prob!=prob) {
EvtGenReport(EVTGEN_DEBUG,"EvtGen") << "Forward density matrix:"<<endl;
EvtGenReport(EVTGEN_DEBUG,"EvtGen") << p->getSpinDensityForward();
EvtGenReport(EVTGEN_DEBUG,"EvtGen") << "Decay density matrix:"<<endl;
EvtGenReport(EVTGEN_DEBUG,"EvtGen") << rho;
EvtGenReport(EVTGEN_DEBUG,"EvtGen") << "prob:"<<prob<<endl;
EvtGenReport(EVTGEN_DEBUG,"EvtGen") << "Particle:"
<<EvtPDL::name(p->getId()).c_str()<<endl;
EvtGenReport(EVTGEN_DEBUG,"EvtGen") << "channel :"<<p->getChannel()<<endl;
EvtGenReport(EVTGEN_DEBUG,"EvtGen") << "Momentum:" << p->getP4() << " " << p->mass() << endl;
if( p->getParent()!=0){
EvtGenReport(EVTGEN_DEBUG,"EvtGen") << "parent:"
<<EvtPDL::name(
p->getParent()->getId()).c_str()<<endl;
EvtGenReport(EVTGEN_DEBUG,"EvtGen") << "parent channel :"
<<p->getParent()->getChannel()<<endl;
size_t i;
EvtGenReport(EVTGEN_DEBUG,"EvtGen") << "parent daughters :";
for (i=0;i<p->getParent()->getNDaug();i++){
EvtGenReport(EVTGEN_DEBUG,"") << EvtPDL::name(
p->getParent()->getDaug(i)->getId()).c_str()
<< " ";
}
EvtGenReport(EVTGEN_DEBUG,"") << endl;
EvtGenReport(EVTGEN_DEBUG,"EvtGen") << "daughters :";
for (size_t i=0;i<p->getNDaug();i++){
EvtGenReport(EVTGEN_DEBUG,"") << EvtPDL::name(
p->getDaug(i)->getId()).c_str()
<< " ";
}
EvtGenReport(EVTGEN_DEBUG,"") << endl;
EvtGenReport(EVTGEN_DEBUG,"EvtGen") << "daughter momenta :" << endl;;
for (size_t i=0;i<p->getNDaug();i++){
EvtGenReport(EVTGEN_DEBUG,"") << p->getDaug(i)->getP4() << " " << p->getDaug(i)->mass();
EvtGenReport(EVTGEN_DEBUG,"") << endl;
}
}
}
prob/=_weight;
prob_max = getProbMax(prob);
p->setDecayProb(prob/prob_max);
more=prob<EvtRandom::Flat(prob_max);
ntimes--;
}while(ntimes&&more);
if (ntimes==0){
EvtGenReport(EVTGEN_DEBUG,"EvtGen") << "Tried accept/reject: 10000"
<<" times, and rejected all the times!"<<endl;
EvtGenReport(EVTGEN_DEBUG,"EvtGen")<<p->getSpinDensityForward()<<endl;
EvtGenReport(EVTGEN_DEBUG,"EvtGen") << "Is therefore accepting the last event!"<<endl;
EvtGenReport(EVTGEN_DEBUG,"EvtGen") << "Decay of particle:"<<
EvtPDL::name(p->getId()).c_str()<<"(channel:"<<
p->getChannel()<<") with mass "<<p->mass()<<endl;
for(size_t ii=0;ii<p->getNDaug();ii++){
EvtGenReport(EVTGEN_DEBUG,"EvtGen") <<"Daughter "<<ii<<":"<<
EvtPDL::name(p->getDaug(ii)->getId()).c_str()<<" with mass "<<
p->getDaug(ii)->mass()<<endl;
}
}
EvtSpinDensity rho_list[10];
rho_list[0]=p->getSpinDensityForward();
EvtAmp ampcont;
if (_amp2._pstates!=1){
ampcont=_amp2.contract(0,p->getSpinDensityForward());
}
else{
ampcont=_amp2;
}
// it may be that the parent decay model has already
// done the decay - this should be rare and the
// model better know what it is doing..
if ( !daugsDecayedByParentModel() ){
if(recursive) {
for(size_t i=0;i<p->getNDaug();i++){
rho.setDim(_amp2.dstates[i]);
if (_amp2.dstates[i]==1) {
rho.set(0,0,EvtComplex(1.0,0.0));
}
else{
rho=ampcont.contract(_amp2._dnontrivial[i],_amp2);
}
if (!rho.check()) {
EvtGenReport(EVTGEN_ERROR,"EvtGen") << "-------start error-------"<<endl;
EvtGenReport(EVTGEN_ERROR,"EvtGen")<<"forward rho failed Check:"<<
EvtPDL::name(p->getId()).c_str()<<" "<<p->getChannel()<<" "<<i<<endl;
p->printTree();
for (size_t idaug = 0; idaug < p->getNDaug(); idaug++) {
EvtParticle* daughter = p->getDaug(idaug);
if (daughter != 0) {daughter->printTree();}
}
EvtParticle* pParent = p->getParent();
if (pParent != 0) {
EvtGenReport(EVTGEN_ERROR,"EvtGen")<<"Parent:"<<EvtPDL::name(pParent->getId()).c_str()<<endl;
EvtParticle* grandParent = pParent->getParent();
if (grandParent != 0) {
EvtGenReport(EVTGEN_ERROR,"EvtGen")<<"GrandParent:"<<EvtPDL::name(grandParent->getId()).c_str()<<endl;
}
}
EvtGenReport(EVTGEN_ERROR,"EvtGen") << " EvtSpinDensity rho: " << rho;
_amp2.dump();
for(size_t ii=0;ii<i+1;ii++){
EvtGenReport(EVTGEN_ERROR,"EvtGen") << "rho_list[" << ii << "] = " << rho_list[ii];
}
EvtGenReport(EVTGEN_ERROR,"EvtGen") << "-------Done with error-------"<<endl;
}
p->getDaug(i)->setSpinDensityForward(rho);
p->getDaug(i)->decay();
rho_list[i+1]=p->getDaug(i)->getSpinDensityBackward();
if (_amp2.dstates[i]!=1){
ampcont=ampcont.contract(_amp2._dnontrivial[i],rho_list[i+1]);
}
}
p->setSpinDensityBackward(_amp2.getBackwardSpinDensity(rho_list));
if (!p->getSpinDensityBackward().check()) {
EvtGenReport(EVTGEN_ERROR,"EvtGen")<<"rho_backward failed Check"<<
p->getId().getId()<<" "<<p->getChannel()<<endl;
EvtGenReport(EVTGEN_ERROR,"EvtGen") << p->getSpinDensityBackward();
}
}
}
if (getPHOTOS() || EvtRadCorr::alwaysRadCorr()) {
int n_daug_orig=p->getNDaug();
EvtRadCorr::doRadCorr(p);
int n_daug_new=p->getNDaug();
for (int i=n_daug_orig;i<n_daug_new;i++){
p->getDaug(i)->decay();
}
}
}
EvtSpinDensity EvtAmp::contract(int k,const EvtAmp& amp2){
int i,j,l;
EvtComplex temp;
EvtSpinDensity rho;
rho.setDim(_nstate[k]);
int allloop = 1;
int indflag,ii;
for (i=0;i<_nontrivial;i++) {
allloop *= _nstate[i];
}
int index[10];
int index1[10];
// int l;
for(i=0;i<_nstate[k];i++){
for(j=0;j<_nstate[k];j++){
if (_nontrivial==0) {
report(Severity::Error,"EvtGen")<<"Should not be here1 EvtAmp!"<<endl;
rho.set(0,0,EvtComplex(1.0,0.0));
return rho;
}
for (ii=0;ii<10;ii++) {
index[ii] = 0;
index1[ii] = 0;
}
index[k] = i;
index1[k] = j;
temp = EvtComplex(0.0);
for ( l=0;l<int(allloop/_nstate[k]);l++) {
temp+=getAmp(index)*conj(amp2.getAmp(index1));
indflag = 0;
for ( ii=0;ii<_nontrivial;ii++) {
if ( ii!= k) {
if ( indflag == 0 ) {
if ( index[ii] == (_nstate[ii]-1) ) {
index[ii] = 0;
index1[ii] = 0;
}
else {
indflag = 1;
index[ii] += 1;
index1[ii] += 1;
}
}
}
}
}
rho.set(i,j,temp);
}
}
return rho;
}
EvtSpinDensity EvtAmp::getSpinDensity(){
EvtSpinDensity rho;
rho.setDim(_pstates);
EvtComplex temp;
int i,j,n;
if (_pstates==1) {
if (_nontrivial==0) {
rho.set(0,0,_amp[0]*conj(_amp[0]));
return rho;
}
n=1;
temp = EvtComplex(0.0);
for(i=0;i<_nontrivial;i++){
n*=_nstate[i];
}
for(i=0;i<n;i++){
temp+=_amp[i]*conj(_amp[i]);
}
rho.set(0,0,temp);;
return rho;
}
else{
for(i=0;i<_pstates;i++){
for(j=0;j<_pstates;j++){
temp = EvtComplex(0.0);
int kk;
int allloop = 1;
for (kk=0;kk<_ndaug; kk++ ) {
allloop *= dstates[kk];
}
for (kk=0; kk<allloop; kk++) {
temp += _amp[_pstates*kk+i]*conj(_amp[_pstates*kk+j]);}
// if (_nontrivial>3){
//report(Severity::Error,"EvtGen") << "Can't handle so many states in EvtAmp!"<<endl;
//}
rho.set(i,j,temp);
}
}
return rho;
}
}
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 ;
}