phaseSpaceIntegrals.cpp File Reference

#include "Mint/phaseSpaceIntegrals.h"
#include "Mint/CLHEPPhysicalConstants.h"
#include "Mint/lambda.h"
#include <iostream>
#include <cmath>
#include "TF2.h"

Go to the source code of this file.

Functions
double	d4body_by_ds12 (Double_t *x, Double_t *p)
double	d3body_by_ds12 (Double_t *x, Double_t *p)
double	d_ps4_by_ds12ds34_withFct (Double_t *x, Double_t *p)
double	d_ps4_by_ds123ds12_withFct (Double_t *x, Double_t *p)
double	phaseSpaceIntegral_upTo4body (const DalitzEventPattern &pat)

Variables
IGenFct *	Global_s12Fct =0
IGenFct *	Global_s34Fct =0
IGenFct *	Global_s123Fct =0

Function Documentation

d3body_by_ds12()

double d3body_by_ds12	(	Double_t *	x,
		Double_t *	p
	)

Definition at line 52 of file phaseSpaceIntegrals.cpp.

                                               {
  bool dbThis=false;

  double s12 = x[0];
  if(s12 < 0) return 0;
  double m12 = sqrt(s12);
  double mum = p[0];
  double m1  = p[1];
  double m2  = p[2];
  double m3  = p[3];
  if(dbThis) cout << " d3body_by_ds12 called with " 
          << mum << ", "
          << m1 << ", "
          << m2 << ", "
          << m3 << endl;

  return phaseSpaceIntegral2body(mum, m12, m3)
    *    phaseSpaceIntegral2body(m12, m1, m2);
}

d4body_by_ds12()

double d4body_by_ds12	(	Double_t *	x,
		Double_t *	p
	)

Definition at line 22 of file phaseSpaceIntegrals.cpp.

                                               {
  bool dbThis=false;
  double s12 = x[0];
  if(s12 < 0) return 0;
  double m12 = sqrt(s12);
  double mum = p[0];
  double m1  = p[1];
  double m2  = p[2];
  double m3  = p[3];
  double m4  = p[4];

  if(dbThis) cout << " d4body_by_ds12 called with " 
          << mum << ", "
          << m1 << ", "
          << m2 << ", "
          << m3 << ", "
          << m4 << endl;

  PhaseSpaceIntegral3body p3;

  double p3val = p3.getVal(mum, m12, m3, m4);
  double p2val = phaseSpaceIntegral2body(m12, m1, m2);
  if(dbThis){
    cout << " d4body_by_ds12: returning " << p2val << " * " << p3val
     << " = " << p2val * p3val
     << endl;
  }
  return p2val * p3val;
}

d_ps4_by_ds123ds12_withFct()

double d_ps4_by_ds123ds12_withFct	(	Double_t *	x,
		Double_t *	p
	)

Definition at line 115 of file phaseSpaceIntegrals.cpp.

                                                           {


  double rho123 = x[0];
  double rho12  = x[1];

  double s123 = Global_s123Fct->coordTransformToS(rho123);
  double  s12 =  Global_s12Fct->coordTransformToS(rho12);


  
  if(s123 < 0) return 0;
  double m123 = sqrt(s123);
  if(m123 + p[4] > p[0]) return 0;
  if(m123 < p[1] + p[2] + p[3]) return 0;
  
  if(s12 < 0) return 0;
  double m12 = sqrt(s12);
  if(m12 + p[3] > m123)return 0;
  if(m12 < p[1] + p[2]) return 0;
  

  double ps1 = phaseSpaceIntegral2body(p[0]
                       , m123
                       , p[4]);

  if(ps1 <=0) return 0;

    
  double ps2 = phaseSpaceIntegral2body(m123
                       , sqrt(s12)
                       , p[3]);

  if(ps2 <=0) return 0;

  double ps3 = phaseSpaceIntegral2body(m12
                  , p[1]
                  , p[2]);

  if(ps3 <=0) return 0;

  double fct123 = Global_s123Fct->transformedFctValue(rho123);
  double fct12  = Global_s12Fct->transformedFctValue(rho12);

  return fct123*fct12 * ps1*ps2*ps3;

}

d_ps4_by_ds12ds34_withFct()

double d_ps4_by_ds12ds34_withFct	(	Double_t *	x,
		Double_t *	p
	)

Definition at line 72 of file phaseSpaceIntegrals.cpp.

                                                           {
  //bool dbThis=false;

  double rho12 = x[0];
  double rho34 = x[1];
  double s12= Global_s12Fct->coordTransformToS(rho12);
  double s34= Global_s34Fct->coordTransformToS(rho34);

  
  if(s12 < 0) return 0;
  double m12 = sqrt(s12);
  if(m12 < p[1] + p[2]) return 0;

  if(s34 < 0) return 0;
  double m34 = sqrt(s34);
  if(m34 < p[3] + p[4]) return 0;
  if(m12 + m34 > p[0]) return 0;
  

  double ps1 = phaseSpaceIntegral2body(p[0]
                      , m12
                      , m34);

  if(ps1 <=0) return 0;
    
  double ps2 = phaseSpaceIntegral2body(m12
                       , p[1]
                       , p[2]);
  
  if(ps2 <=0) return 0;
    
  double ps3 = phaseSpaceIntegral2body(m34
                       , p[3]
                       , p[4]);
  if(ps3 <=0) return 0;


  double fct12 = Global_s12Fct->transformedFctValue(rho12);
  double fct34 = Global_s34Fct->transformedFctValue(rho34);

  return fct12 * fct34 * ps1*ps2*ps3;
}

phaseSpaceIntegral_upTo4body()

double phaseSpaceIntegral_upTo4body

(

const DalitzEventPattern &

pat

)

Definition at line 488 of file phaseSpaceIntegrals.cpp.

                                                                  {

  if(pat.numDaughters() < 2 ){
    return 0;
  }else if(pat.numDaughters() == 2 ){
    return phaseSpaceIntegral2body(pat);
  }else if(pat.numDaughters() == 3){
    PhaseSpaceIntegral3body p3;
    return p3.getVal(pat);
  }else if(pat.numDaughters() == 4){
    PhaseSpaceIntegral4body p4;
    return p4.getVal(pat);
  }else{
    return -9999;
  }

}

Variable Documentation

Global_s123Fct

IGenFct* Global_s123Fct =0

Definition at line 20 of file phaseSpaceIntegrals.cpp.

Global_s12Fct

IGenFct* Global_s12Fct =0

Definition at line 18 of file phaseSpaceIntegrals.cpp.

Global_s34Fct

IGenFct* Global_s34Fct =0

Definition at line 19 of file phaseSpaceIntegrals.cpp.