UserSelections.h File Reference

#include "CLHEP/Vector/LorentzVector.h"
#include "Pythia8B_i/BsJpsiPhiAngles.h"
#include <cmath>

Include dependency graph for UserSelections.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
CLHEP::HepLorentzVector	convertVector (const Pythia8::Vec4 v)
double	BsJpsiPhi_PDF (const double *params, double *x, bool useHelicity)

Function Documentation

BsJpsiPhi_PDF()

double BsJpsiPhi_PDF	(	const double *	params,
		double *	x,
		bool	useHelicity )

Definition at line 27 of file UserSelections.h.

                                                                        {
 
    //  if ( !checkInput(x) ) return 0.;
 
    // Human-readable aliases of the parameters and observables.
    // Human-readable aliases of the parameters and observables.
    double A0 = std::sqrt(params[0] * (1 - params[2]));
    double Al = std::sqrt(params[1] * (1 - params[2]));
    double As = std::sqrt(params[2]);
    const double &GammaS = params[3];
    const double &DeltaGamma = params[4];
    const double &DeltaM = params[5];
    const double &phiS = params[6];
    const double &delta_p = params[7];
    const double &delta_l = params[8];
    double delta_s = params[7] - params[9];
 
    double &time = x[0];
    //  double &timeErr    = x[1]; // pico seconds
    double &tagprob = x[4]; // 0. anti-particle, 0.5 no tag, 1.0 particle
    
  // Calculate A perpendicular from the other parameters
  double Ap = 0;
  if ( 1. - As*As - A0*A0 - Al*Al >= 0 ) Ap = std::sqrt(1. - As*As - A0*A0 - Al*Al);
 
  // The tabulated function is Sum of: A[i] * ( B1[i] +/- B2[i] ) * C[i]
    
  double A[10], B1[10], B2[10], C[10];
    
  // Define A cells
  double sinphiS = std::sin(phiS);
  double cosphiS = std::cos(phiS);
    
  A[0] = 0.5 * A0*A0;
  A[1] = 0.5 * Al*Al;
  A[2] = 0.5 * Ap*Ap;
  A[3] = 0.5 * A0*Al * std::cos(delta_l);
  A[4] = Al*Ap;
  A[5] = A0*Ap;
  A[6] = 0.5 * As*As;
  A[7] = As*Al;
  A[8] = 0.5 * As*Ap * std::sin(delta_p - delta_s);
  A[9] = As*A0;
 
 
    
  // Define B cells
  double gammaH  = GammaS - DeltaGamma/2.;
  double gammaL  = GammaS + DeltaGamma/2.;
  double tauL = 1./gammaL;
  double tauH = 1./gammaH;
  double norm1 = (1./(tauL*(1.+cosphiS) + tauH*(1.-cosphiS)));
  double norm2 = (1./(tauL*(1.-cosphiS) + tauH*(1.+cosphiS)));
  double norm3 = (1./sqrt((tauL-tauH)*(tauL-tauH)*sinphiS*sinphiS+4.*tauL*tauH));
 
  double ExpGSSinMT = 0.0;
  double ExpGSCosMT = 0.0;
 
 
 
    // Calculate convolution of exp(-gammaL * time) with a gaussian. Not convoluted if sigma == 0.
    double ExpGL = std::exp(-time * gammaL);
 
    // Calculate convolution of exp(-gammaH * time) with a gaussian. Not convoluted if sigma == 0.      
    double ExpGH = std::exp(-time * gammaH);    
 
    B1[0] = ( (1. + cosphiS) * ExpGL + (1. - cosphiS) * ExpGH ) * norm1;
    B1[1] = B1[0];
    B1[2] = ( (1. - cosphiS) * ExpGL + (1. + cosphiS) * ExpGH ) * norm2;
    B1[3] = B1[0];
    B1[4] = 0.5 * std::cos(delta_p - delta_l) * sinphiS * (ExpGL - ExpGH) * norm3;
    B1[5] = 0.5 * std::cos(delta_p) * sinphiS * (ExpGL - ExpGH) * norm3;
    B1[6] = B1[2];
    B1[7] = 0.5 * sinphiS * std::sin(delta_l - delta_s) * (ExpGL - ExpGH) * norm3;
    B1[8] = B1[2];
    B1[9] = 0.5 * sinphiS * std::sin(delta_s) * (ExpGH - ExpGL) * norm3;
 
  
 
 
 
  // Tagged analysis
  if( std::abs(tagprob - 0.5) > 1e-6 ){   
 
 
    ExpGSSinMT = std::exp(-time * GammaS) * std::sin(DeltaM * time);
    ExpGSCosMT = std::exp(-time * GammaS) * std::cos(DeltaM * time);
 
 
    B2[0] = 2. * ExpGSSinMT * sinphiS * norm1;
    B2[1] = B2[0];
    B2[2] = -2. * ExpGSSinMT * sinphiS * norm2;
    B2[3] = B2[0];
    B2[4] = ( ExpGSCosMT * std::sin(delta_p - delta_l) - cosphiS * std::cos(delta_p - delta_l) * ExpGSSinMT ) * norm3;
    B2[5] = ( ExpGSCosMT * std::sin(delta_p) - cosphiS * std::cos(delta_p) * ExpGSSinMT ) * norm3;
    B2[6] = B2[2];
    B2[7] = ( ExpGSCosMT * std::cos(delta_l - delta_s) - cosphiS * std::sin(delta_l - delta_s) * ExpGSSinMT ) * norm3;
    B2[8] = B2[2];
    B2[9] = ( ExpGSCosMT * std::cos(delta_s) + cosphiS * std::sin(delta_s) * ExpGSSinMT ) * norm3;
 
  } // End of tagged terms
  else{
    // Untagged analysis
    for (int k = 0; k<10; k++) B2[k] = 0;
 
  }
  // Define C cells
 
    if (useHelicity) {
 
      // Helicity Basis: Input variables are costhetal, costhetak and chi
      double &costhetal = x[1];
      double &costhetak = x[2];
      double &chi = x[3];
 
      double sinsqthetal = 1. - (costhetal * costhetal);
      double sinsqthetak = 1. - (costhetak * costhetak);
      double cossqthetak = costhetak * costhetak;
      double coschi = std::cos(chi);
      double cossqchi = coschi * coschi;
      double sinchi = std::sin(chi);
      double sinsqchi = sinchi * sinchi;
      double sin2thetak = 2. * std::sqrt(1. - costhetak * costhetak) * costhetak;
      double sin2thetal = 2. * std::sqrt(1. - costhetal * costhetal) * costhetal;
      double sin2chi = std::sin(2. * chi);
      double sinthetak = std::sqrt(sinsqthetak);
 
      C[0] = 2. * cossqthetak * sinsqthetal; //cossqpsi * (1. - sinsqtheta * cossqphi);
      C[1] = sinsqthetak * (1 - sinsqthetal * cossqchi); //sinsqpsi * (1. - sinsqtheta * sinsqphi);
      C[2] = sinsqthetak * (1 - sinsqthetal * sinsqchi); //sinsqpsi * sinsqtheta;
      C[3] = 1. / std::sqrt(2.) * sin2thetak * sin2thetal * coschi; //* sin2psi * sinsqtheta * sin2phi;
      C[4] = -1. * sinsqthetak * sinsqthetal * sin2chi; //sinsqpsi * sin2theta * sinphi;
      C[5] = 1. / std::sqrt(2.) * sin2thetak * sin2thetal * sinchi; //* sin2psi * sin2theta * cosphi;
      C[6] = 2. / 3. * sinsqthetal; //(1. - sinsqtheta * cossqphi);
      C[7] = 1. / 3. * std::sqrt(6.) * sinthetak * sin2thetal * coschi; //sinpsi * sinsqtheta * sin2phi;
      C[8] = 1. / 3. * std::sqrt(6.) * sinthetak * sin2thetal * sinchi; //sinpsi * sin2theta * cosphi;
      C[9] = 4. / 3. * std::sqrt(3.) * costhetak * sinsqthetal; // cospsi * (1. - sinsqtheta * cossqphi); 
 
    }
    else {
 
      // Transversity Basis: Input variables are costheta, cospsi and phi
      double &costheta   = x[1];
      double &cospsi     = x[2];
      double &phi        = x[3];
 
      double sinsqtheta   = 1. - (costheta * costheta);
      double sinsqpsi     = 1. - (cospsi * cospsi);
      double cossqpsi     = cospsi * cospsi;
      double sin2theta    = 2. * std::sqrt(1. - costheta * costheta) * costheta;
      double sin2psi      = 2. * std::sqrt(1. - cospsi * cospsi) * cospsi;
      double cosphi       = std::cos(phi);
      double cossqphi     = cosphi * cosphi;
      double sinphi       = std::sin(phi);
      double sinsqphi     = sinphi * sinphi;
      double sin2phi      = std::sin(2. * phi);
      double sinpsi       = std::sqrt(1. - cospsi*cospsi);
        
      C[0] = 2. * cossqpsi * (1. - sinsqtheta * cossqphi);
      C[1] = sinsqpsi * (1.-sinsqtheta * sinsqphi);
      C[2] = sinsqpsi * sinsqtheta;
      C[3] = 1. / sqrt(2.) * sin2psi * sinsqtheta * sin2phi;
      C[4] = -1. * sinsqpsi * sin2theta * sinphi;
      C[5] = 1. / sqrt(2.) * sin2psi * sin2theta * cosphi;
      C[6] = 2. / 3. *(1. - sinsqtheta * cossqphi);
      C[7] = 1. / 3. *sqrt(6.) *sinpsi * sinsqtheta * sin2phi;
      C[8] = 1. / 3. *sqrt(6.) *sinpsi * sin2theta * cosphi;
      C[9] = 4. / 3. *sqrt(3.) *cospsi * (1. - sinsqtheta * cossqphi);
 
    }
 
  
    
  // Sum the tabulated formula  
  double Wplus  = 0;
  double Wminus = 0;
    
    
  for ( int i=0; i<10; ++i ) {
 
    Wplus  += A[i] * ( B1[i] + B2[i] ) * C[i];
    Wminus += A[i] * ( B1[i] - B2[i] ) * C[i];
 
  }
    
  double value = tagprob * Wplus + (1. - tagprob) * Wminus;
    if (value < 0)
        value = 0;
    return value;
}

convertVector()

CLHEP::HepLorentzVector convertVector

(

const Pythia8::Vec4

v

)

Definition at line 18 of file UserSelections.h.

                                                         {
        CLHEP::HepLorentzVector vect;
    vect.setPx(v.px());
    vect.setPy(v.py());
    vect.setPz(v.pz());
    vect.setE(v.e());
    return vect;
}