Line data    Source code

       1             : //--------------------------------------------------------------------------
       2             : //
       3             : // Environment:
       4             : //      This software is part of the EvtGen package developed jointly
       5             : //      for the BaBar and CLEO collaborations.  If you use all or part
       6             : //      of it, please give an appropriate acknowledgement.
       7             : //
       8             : // Copyright Information: See EvtGen/COPYRIGHT
       9             : //      Copyright (C) 1998      Caltech, UCSB
      10             : //
      11             : // Module: EvtTVSPwave.cc
      12             : //
      13             : // Description: Routine to decay tensor-> vector scalar
      14             : //              by specifying the partial waves
      15             : //
      16             : // Modification history:
      17             : //
      18             : //    DJL/RYD   August 11, 1997           Module created
      19             : //
      20             : //------------------------------------------------------------------------
      21             : // 
      22             : #include "EvtGenBase/EvtPatches.hh"
      23             : #include <stdlib.h>
      24             : #include "EvtGenBase/EvtParticle.hh"
      25             : #include "EvtGenBase/EvtGenKine.hh"
      26             : #include "EvtGenBase/EvtPDL.hh"
      27             : #include "EvtGenBase/EvtVector4C.hh"
      28             : #include "EvtGenBase/EvtTensor4C.hh"
      29             : #include "EvtGenBase/EvtReport.hh"
      30             : #include "EvtGenModels/EvtTVSPwave.hh"
      31             : #include <string>
      32             : 
      33           0 : EvtTVSPwave::~EvtTVSPwave() {}
      34             : 
      35             : std::string EvtTVSPwave::getName(){
      36             : 
      37           0 :   return "TVS_PWAVE";     
      38             : 
      39             : }
      40             : 
      41             : 
      42             : EvtDecayBase* EvtTVSPwave::clone(){
      43             : 
      44           0 :   return new EvtTVSPwave;
      45             : 
      46           0 : }
      47             : 
      48             : void EvtTVSPwave::init(){
      49             : 
      50             :   // check that there are 6 arguments
      51           0 :   checkNArg(6);
      52           0 :   checkNDaug(2);
      53             :     
      54           0 :   checkSpinParent(EvtSpinType::TENSOR);
      55             : 
      56           0 :   checkSpinDaughter(0,EvtSpinType::VECTOR);
      57           0 :   checkSpinDaughter(1,EvtSpinType::SCALAR);
      58           0 : }
      59             : 
      60             : void EvtTVSPwave::initProbMax(){
      61             : 
      62           0 :   setProbMax(0.5);
      63             : 
      64             : 
      65           0 : }
      66             : 
      67             : void EvtTVSPwave::decay( EvtParticle *p ){
      68             : 
      69           0 :   EvtComplex ap(getArg(0)*cos(getArg(1)),getArg(0)*sin(getArg(1)));
      70           0 :   EvtComplex ad(getArg(2)*cos(getArg(3)),getArg(2)*sin(getArg(3)));
      71           0 :   EvtComplex af(getArg(4)*cos(getArg(5)),getArg(4)*sin(getArg(5)));
      72             : 
      73           0 :   if (ap!=EvtComplex(0.0,0.0)||af!=EvtComplex(0.0,0.0)) {
      74           0 :     report(Severity::Error,"EvtGen") << "dfslkh8945wqh:In EvtTensorToVectorScalar.c\n";
      75           0 :     report(Severity::Error,"EvtGen") << "P or F wave not yet implemented!! (ryd) \n";
      76           0 :   }
      77             : 
      78           0 :   p->initializePhaseSpace(getNDaug(),getDaugs());
      79             :     
      80             :   EvtParticle *v;
      81           0 :   v = p->getDaug(0);
      82           0 :   EvtVector4R momv = v->getP4();
      83           0 :   double massv = v->mass();
      84             : 
      85           0 :   EvtComplex temp;
      86           0 :   temp = ad;
      87           0 :   double m_parent = p->mass();
      88             : 
      89           0 :   EvtVector4R p_parent;
      90             :   
      91           0 :   p_parent.set(m_parent,0.0,0.0,0.0);
      92             :   
      93           0 :   EvtVector4C  pep0,pep1,pep2,pep3,pep4;  
      94           0 :   EvtTensor4C pdual;
      95             :   
      96           0 :   EvtVector4C epsdual0,epsdual1,epsdual2;
      97             : 
      98           0 :   double norm=massv/(m_parent*momv.get(0)*momv.d3mag()*momv.d3mag());
      99           0 :   pdual=dual(EvtGenFunctions::directProd(norm*p_parent,momv));
     100             :   
     101           0 :   epsdual0=pdual.cont1(v->epsParent(0).conj());
     102           0 :   epsdual1=pdual.cont1(v->epsParent(1).conj());
     103           0 :   epsdual2=pdual.cont1(v->epsParent(2).conj());
     104             :   
     105           0 :   pep0=p->epsTensor(0).cont1(momv);
     106           0 :   pep1=p->epsTensor(1).cont1(momv);
     107           0 :   pep2=p->epsTensor(2).cont1(momv);
     108           0 :   pep3=p->epsTensor(3).cont1(momv);
     109           0 :   pep4=p->epsTensor(4).cont1(momv);
     110             : 
     111           0 :   vertex(0,0,pep0*epsdual0);
     112           0 :   vertex(1,0,pep1*epsdual0);
     113           0 :   vertex(2,0,pep2*epsdual0);
     114           0 :   vertex(3,0,pep3*epsdual0);
     115           0 :   vertex(4,0,pep4*epsdual0);
     116             :   
     117           0 :   vertex(0,1,pep0*epsdual1);
     118           0 :   vertex(1,1,pep1*epsdual1);
     119           0 :   vertex(2,1,pep2*epsdual1);
     120           0 :   vertex(3,1,pep3*epsdual1);
     121           0 :   vertex(4,1,pep4*epsdual1);
     122             :   
     123           0 :   vertex(0,2,pep0*epsdual2);
     124           0 :   vertex(1,2,pep1*epsdual2);
     125           0 :   vertex(2,2,pep2*epsdual2);
     126           0 :   vertex(3,2,pep3*epsdual2);
     127           0 :   vertex(4,2,pep4*epsdual2);
     128             :   
     129             :   return ;
     130           0 : }
     131             : 
     132             : std::string EvtTVSPwave::getParamName(int i) {
     133           0 :   switch(i) {
     134             :   case 0:
     135           0 :     return "PWave";
     136             :   case 1:
     137           0 :     return "PWavePhase";
     138             :   case 2:
     139           0 :     return "DWave";
     140             :   case 3:
     141           0 :     return "DWavePhase";
     142             :   case 4:
     143           0 :     return "FWave";
     144             :   case 5:
     145           0 :     return "FWavePhase";
     146             :   default:
     147           0 :     return "";
     148             :   }
     149           0 : }
     150             : 
     151             : std::string EvtTVSPwave::getParamDefault(int i) {
     152           0 :   switch(i) {
     153             :   case 0:
     154           0 :     return "0.0";
     155             :   case 1:
     156           0 :     return "0.0";
     157             :   case 2:
     158           0 :     return "1.0";
     159             :   case 3:
     160           0 :     return "0.0";
     161             :   case 4:
     162           0 :     return "0.0";
     163             :   case 5:
     164           0 :     return "0.0";
     165             :   default:
     166           0 :     return "";
     167             :   }
     168           0 : }