void EvtPropSLPole::init(){
  
  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));

  SLPoleffmodel = new EvtSLPoleFF(getNArg(),getArgs());
  
  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];
    }
  }
}
Beispiel #3
0
//======================================================
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;
}
Beispiel #4
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 EvtTauVectornu::init(){

  // check that there are 0 arguments
  checkNArg(0);
  checkNDaug(2);

  checkSpinParent(EvtSpinType::DIRAC);
    
  checkSpinDaughter(0,EvtSpinType::VECTOR);
  checkSpinDaughter(1,EvtSpinType::NEUTRINO);
}
Beispiel #6
0
void EvtSSSCP::init(){

  // check that there are 7 arguments
  checkNArg(7);
  checkNDaug(2);
  checkSpinParent(EvtSpinType::SCALAR);

  checkSpinDaughter(0,EvtSpinType::SCALAR);
  checkSpinDaughter(1,EvtSpinType::SCALAR);

}
Beispiel #7
0
void EvtVSSMix::init(){

  // check that there are 1 arguments
  checkNArg(1);
  checkNDaug(2);

  checkSpinParent(EvtSpinType::VECTOR);
    
  checkSpinDaughter(0,EvtSpinType::SCALAR);
  checkSpinDaughter(1,EvtSpinType::SCALAR);

}
void EvtSVPHelAmp::init(){

  // check that there are 4 arguments
  checkNArg(4);
  checkNDaug(2);

  checkSpinParent(EvtSpinType::SCALAR);

  checkSpinDaughter(0,EvtSpinType::VECTOR);
  checkSpinDaughter(1,EvtSpinType::PHOTON);

}
Beispiel #9
0
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);

}
Beispiel #10
0
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;
  }

}
Beispiel #11
0
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);
}
Beispiel #12
0
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);
  }

}
Beispiel #13
0
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(); 

}
Beispiel #15
0
// 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)));
  }
}
Beispiel #17
0
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;
}