void EvtSSD_DirectCP::init() {
// check that there is 1 argument and 2-body decay
checkNArg(1);
checkNDaug(2);
EvtSpinType::spintype d1type=EvtPDL::getSpinType(getDaug(0));
EvtSpinType::spintype d2type=EvtPDL::getSpinType(getDaug(1));
if ( (!(d1type == EvtSpinType::SCALAR || d2type == EvtSpinType::SCALAR))||
(!((d2type==EvtSpinType::SCALAR)||(d2type==EvtSpinType::VECTOR)||
(d2type==EvtSpinType::TENSOR)))||
(!((d1type==EvtSpinType::SCALAR)||(d1type==EvtSpinType::VECTOR)||
(d1type==EvtSpinType::TENSOR)))
) {
EvtGenReport(EVTGEN_ERROR,"EvtGen") << "EvtSSD_DirectCP generator expected "
<< "one of the daugters to be a scalar, "
<< "the other either scalar, vector, or tensor, "
<< "found:"
<< EvtPDL::name(getDaug(0)).c_str()
<<" and "
<<EvtPDL::name(getDaug(1)).c_str()<<std::endl;
EvtGenReport(EVTGEN_ERROR,"EvtGen") << "Will terminate execution!"<<std::endl;
::abort();
}
_acp = getArg( 0 ) ; // A_CP defined as A_CP = (BR(fbar)-BR(f))/(BR(fbar)+BR(f))
}
void EvtISGW2::init() {
checkNArg(0);
checkNDaug(3);
//We expect the parent to be a scalar
//and the daughters to be X lepton neutrino
checkSpinParent(EvtSpinType::SCALAR);
checkSpinDaughter(1,EvtSpinType::DIRAC);
checkSpinDaughter(2,EvtSpinType::NEUTRINO);
EvtSpinType::spintype mesontype=EvtPDL::getSpinType(getDaug(0));
isgw2ffmodel = new EvtISGW2FF;
if ( mesontype==EvtSpinType::SCALAR ) {
calcamp = new EvtSemiLeptonicScalarAmp;
}
if ( mesontype==EvtSpinType::VECTOR ) {
calcamp = new EvtSemiLeptonicVectorAmp;
}
if ( mesontype==EvtSpinType::TENSOR ) {
calcamp = new EvtSemiLeptonicTensorAmp;
}
}
void EvtSVVNONCPEIGEN::init(){
// check that there are 27 arguments
checkNArg(27,15);
checkNDaug(2);
checkSpinDaughter(0,EvtSpinType::VECTOR);
checkSpinDaughter(1,EvtSpinType::VECTOR);
// The ordering of A_f is :
// A_f[0-2] = A_f
// A_f[3-5] = Abar_f
// A_f[6-8] = A_fbar
// A_f[9-11] = Abar_fbar
//
// Each of the 4 amplitudes include the 3 different helicity states in
// the order +, 0, -. See more about helicity amplitude ordering in ::decay
int i=0;
int j=(getNArg()-3)/2;
for(i=0; i<j; ++i){
_A_f[i] = getArg((2*i)+3) * EvtComplex( cos(getArg((2*i)+4)),sin(getArg((2*i)+4)) );
}
// If only 6 amplitudes are specified, calculate the last 6 from the first 6:
if(6 == j){
for(i = 0; i < 3; ++i){
_A_f[6+i] = _A_f[3+i];
_A_f[9+i] = _A_f[i];
}
}
}
//======================================================
void EvtBcVNpi::init(){
//cout<<"BcVNpi::init()"<<endl;
checkNArg(1);
checkSpinParent(EvtSpinType::SCALAR);
checkSpinDaughter(0,EvtSpinType::VECTOR);
for (int i=1; i<=(getNDaug()-1);i++) {
checkSpinDaughter(i,EvtSpinType::SCALAR);
};
if(getNDaug()<2 || getNDaug()>6) {
report(Severity::Error,"EvtGen") << "Have not yet implemented this final state in BcVNpi model" << endl;
report(Severity::Error,"EvtGen") << "Ndaug="<<getNDaug() << endl;
for ( int id=0; id<(getNDaug()-1); id++ )
report(Severity::Error,"EvtGen") << "Daug " << id << " "<<EvtPDL::name(getDaug(id)).c_str() << endl;
return;
}
// for(int i=0; i<getNDaug(); i++)
// cout<<"BcVNpi::init \t\t daughter "<<i<<" : "<<getDaug(i).getId()<<" "<<EvtPDL::name(getDaug(i)).c_str()<<endl;
idVector = getDaug(0).getId();
whichfit = int(getArg(0)+0.1);
// cout<<"BcVNpi: whichfit ="<<whichfit<<" idVector="<<idVector<<endl;
ffmodel = new EvtBCVFF(idVector,whichfit);
wcurr = new EvtWnPi();
nCall = 0;
}
void EvtVVP::init(){
// check that there are 8 arguments
checkNArg(8);
checkNDaug(2);
checkSpinParent(EvtSpinType::VECTOR);
checkSpinDaughter(0,EvtSpinType::VECTOR);
checkSpinDaughter(1,EvtSpinType::PHOTON);
}
void EvtSSSCP::init(){
// check that there are 7 arguments
checkNArg(7);
checkNDaug(2);
checkSpinParent(EvtSpinType::SCALAR);
checkSpinDaughter(0,EvtSpinType::SCALAR);
checkSpinDaughter(1,EvtSpinType::SCALAR);
}
void EvtTauVectornu::init(){
// check that there are 0 arguments
checkNArg(0);
checkNDaug(2);
checkSpinParent(EvtSpinType::DIRAC);
checkSpinDaughter(0,EvtSpinType::VECTOR);
checkSpinDaughter(1,EvtSpinType::NEUTRINO);
}
void EvtVSSMix::init(){
// check that there are 1 arguments
checkNArg(1);
checkNDaug(2);
checkSpinParent(EvtSpinType::VECTOR);
checkSpinDaughter(0,EvtSpinType::SCALAR);
checkSpinDaughter(1,EvtSpinType::SCALAR);
}
//=============================================================================
// Initialisation method
//=============================================================================
void EvtBToDDalitzCPK::init ( )
{
// Check that there are 3 arguments
checkNArg( 3 ) ;
// Check that there are 2 daughters
checkNDaug( 2 ) ;
// Check that the particles of the decay are :
// B+/- -> D0/bar K+/-
// B+/- -> K+/- D0/bar
// B0/bar -> K*0/bar D0/bar
// and nothing else ...
static EvtId BP = EvtPDL::getId( "B+" ) ;
static EvtId BM = EvtPDL::getId( "B-" ) ;
static EvtId B0 = EvtPDL::getId( "B0" ) ;
static EvtId B0B = EvtPDL::getId( "anti-B0" ) ;
static EvtId KP = EvtPDL::getId( "K+" ) ;
static EvtId KM = EvtPDL::getId( "K-" ) ;
static EvtId KS = EvtPDL::getId( "K*0" ) ;
static EvtId KSB = EvtPDL::getId( "anti-K*0" ) ;
static EvtId D0 = EvtPDL::getId( "D0" ) ;
static EvtId D0B = EvtPDL::getId( "anti-D0" ) ;
_flag = 0 ;
EvtId parent = getParentId() ;
EvtId d1 = getDaug( 0 ) ;
EvtId d2 = getDaug( 1 ) ;
if ( ( ( parent == BP ) || ( parent == BM ) ) &&
( ( d1 == D0 ) || ( d1 == D0B ) ) &&
( ( d2 == KP ) || ( d2 == KM ) ) ) {
_flag = 1 ;
// PHSP Decay
}
else if ( ( ( parent == BP ) || ( parent == BM ) ) &&
( ( d1 == KP ) || ( d1 == KM ) ) &&
( ( d2 == D0 ) || ( d2 == D0B ) ) ) {
_flag = 1 ;
// also PHSP decay
}
else if ( ( ( parent == B0 ) || ( parent == B0B ) ) &&
( ( d1 == KS ) || ( d1 == KSB ) ) &&
( ( d2 == D0 ) || ( d2 == D0B ) ) ) {
_flag = 2 ;
// SVS Decay
}
if ( _flag == 0 ) {
EvtGenReport(EVTGEN_ERROR , "EvtGen" ) << "EvtBToDDalitzCPK : Invalid mode."
<< std::endl ;
assert( 0 ) ;
}
}
void EvtSVPHelAmp::init(){
// check that there are 4 arguments
checkNArg(4);
checkNDaug(2);
checkSpinParent(EvtSpinType::SCALAR);
checkSpinDaughter(0,EvtSpinType::VECTOR);
checkSpinDaughter(1,EvtSpinType::PHOTON);
}
void EvtPVVCPLH::init(){
// check that there are 8 arguments (deltaMs no argument anymore)
checkNArg(8);
checkNDaug(2);
checkSpinParent(EvtSpinType::SCALAR);
checkSpinDaughter(0,EvtSpinType::VECTOR);
checkSpinDaughter(1,EvtSpinType::VECTOR);
}
void EvtD0gammaDalitz::init()
{
// check that there are 0 arguments
checkNArg(0);
// Check that this model is valid for the specified decay.
checkNDaug( 3 );
checkSpinParent ( _SCALAR );
checkSpinDaughter( 0, _SCALAR );
checkSpinDaughter( 1, _SCALAR );
checkSpinDaughter( 2, _SCALAR );
// Get the values of the EvtId objects from the data files.
readPDGValues();
// Get the EvtId of the D0 and its 3 daughters.
getParentId();
EvtId dau[ 3 ];
for ( int index = 0; index < 3; index++ )
{
dau[ index ] = getDaug( index );
}
// Look for K0bar h+ h-. The order will be K[0SL] h+ h-
for ( int index = 0; index < 3; index++ )
{
if ( ( dau[ index ] == _K0B ) || ( dau[ index ] == _KS ) || ( dau[ index ] == _KL ) )
{
_d1 = index;
}
else if ( ( dau[ index ] == _PIP ) || ( dau[ index ] == _KP ) )
{
_d2 = index;
}
else if ( ( dau[ index ] == _PIM ) || ( dau[ index ] == _KM ) )
{
_d3 = index;
}
else
{
reportInvalidAndExit();
}
}
// Check if we're dealing with Ks pi pi or with Ks K K.
_isKsPiPi = false;
if ( dau[ _d2 ] == _PIP || dau[ _d2 ] == _PIM )
{
_isKsPiPi = true;
}
}
void EvtEtaDalitz::init(){
// check that there are 0 arguments
checkNArg(0);
checkNDaug(3);
checkSpinParent(EvtSpinType::SCALAR);
checkSpinDaughter(0,EvtSpinType::SCALAR);
checkSpinDaughter(1,EvtSpinType::SCALAR);
checkSpinDaughter(2,EvtSpinType::SCALAR);
}
void EvtBcBsNPi::init() {
checkNArg(0);
// check spins
checkSpinParent(EvtSpinType::SCALAR);
checkSpinDaughter(0,EvtSpinType::SCALAR);
// the others are scalar
for (int i=1; i<=(getNDaug()-1);i++) {
checkSpinDaughter(i,EvtSpinType::SCALAR);
}
}
void EvtKstarnunu::init(){
// check that there are 0 arguments
checkNArg(0);
checkNDaug(3);
//We expect the parent to be a scalar
//and the daughters to be K neutrino netrino
checkSpinParent(EvtSpinType::SCALAR);
checkSpinDaughter(0,EvtSpinType::VECTOR);
checkSpinDaughter(1,EvtSpinType::NEUTRINO);
checkSpinDaughter(2,EvtSpinType::NEUTRINO);
}
// The inicialization of the decay model
void EvtB2MuMuMuNu::init(){
// check that there are 0 arguments
checkNArg(0);
// check that there are 4 daughteres
checkNDaug(4);
// We expect that the parent to be a scalar (B^{-} meson)
// and the daughters to be Mu^+(k_1), Mu^-(k_2), barNu_{Mu}(k_3) and Mu^-(k_4).
checkSpinParent(EvtSpinType::SCALAR);
checkSpinDaughter(0,EvtSpinType::DIRAC); // Mu^+(k_1)
checkSpinDaughter(1,EvtSpinType::DIRAC); // Mu^-(k_2)
checkSpinDaughter(2,EvtSpinType::NEUTRINO); // barNu_{Mu}(k_3)
checkSpinDaughter(3,EvtSpinType::DIRAC); // Mu^-(k_4)
_msffmodel = new EvtbTosllMSFF();
_calcamp = new EvtB2MuMuMuNuAmp();
}
// The inicialization of the decay model
//
// Tn the our model we have are following 4 arguments:
//
// mu - the scale parameter, GeV;
// Nf - number of "effective" flavors (for b-quark Nf=5);
// res_swch - resonant switching parametr:
// = 0 the resonant contribution switched OFF,
// = 1 the resonant contribution switched ON;
// ias - switching parametr for \alpha_s(M_Z) value:
// = 0 PDG 1sigma minimal alpha_s(M_Z),
// = 1 PDG average value alpha_s(M_Z),
// = 2 PDG 1sigma maximal alpha_s(M_Z).
// Wolfenstein parameterization for CKM matrix
// CKM_A, CKM_lambda, CKM_barrho, CKM_bareta
//
void EvtbsToLLLL::init(){
// check that there are 8 arguments
checkNArg(8);
// check that there are 4 daughteres
checkNDaug(4);
// We expect that the parent to be a scalar (B-meson)
// and the daughters to be l^+, l^-, l^+ and l^-
checkSpinParent(EvtSpinType::SCALAR);
// We expect that the all daughters are the ell+ or ell- == DIRAC
checkSpinDaughter(0,EvtSpinType::DIRAC);
checkSpinDaughter(1,EvtSpinType::DIRAC);
checkSpinDaughter(2,EvtSpinType::DIRAC);
checkSpinDaughter(3,EvtSpinType::DIRAC);
_mntffmodel = new Evtbs2llGammaFFMNT();
_wilscoeff = new EvtbTosllWilsCoeffNLO();
_calcamp = new EvtbsToLLLLAmp();
}
void EvtSVSNONCPEIGEN::init(){
// check that there are 11 arguments
checkNArg(11,7);
checkNDaug(2);
checkSpinDaughter(0,EvtSpinType::VECTOR);
checkSpinDaughter(1,EvtSpinType::SCALAR);
_dm=getArg(1);
_phickm=2*getArg(0)+getArg(2);
_A_f=EvtComplex(getArg(3)*cos(getArg(4)),getArg(3)*sin(getArg(4)));
_Abar_f=EvtComplex(getArg(5)*cos(getArg(6)),getArg(5)*sin(getArg(6)));
_A_fbar=_Abar_f;
_Abar_fbar=_A_f;
if (getNArg()==11){
_A_fbar=EvtComplex(getArg(7)*cos(getArg(8)),getArg(7)*sin(getArg(8)));
_Abar_fbar=EvtComplex(getArg(9)*cos(getArg(10)),getArg(9)*sin(getArg(10)));
}
}
void EvtVectorIsr::init(){
// check that there are 2 arguments
checkNDaug(2);
checkSpinParent(EvtSpinType::VECTOR);
checkSpinDaughter(0,EvtSpinType::VECTOR);
checkSpinDaughter(1,EvtSpinType::PHOTON);
int narg = getNArg();
if ( narg > 4 ) checkNArg(4);
csfrmn=1.;
csbkmn=1.;
fmax=1.2;
firstorder=false;
if ( narg > 0 ) csfrmn=getArg(0);
if ( narg > 1 ) csbkmn=getArg(1);
if ( narg > 2 ) fmax=getArg(2);
if ( narg > 3 ) firstorder=true;
}