RunningWidthCalculator.cpp File Reference

#include "Mint/CLHEPPhysicalConstants.h"
#include "TMath.h"
#include "TCanvas.h"
#include "TH1D.h"
#include "TF1.h"
#include "Mint/Utils.h"
#include "Mint/DalitzEventList.h"
#include "Mint/RunningWidthCalculator.h"
#include "Mint/SignalGenerator.h"
#include "Mint/ResonanceProperties.h"
#include "Mint/ResonancePropertiesList.h"
#include "Mint/BW_BW.h"
#include "Mint/phaseSpaceIntegrals.h"
#include <cmath>
#include <complex>
#include "Math/Integrator.h"
#include "Math/Functor.h"
#include "Math/GSLIntegrator.h"
#include "Mint/Minimisable.h"
#include "Mint/Minimiser.h"

Go to the source code of this file.

Classes
class	BF_Integrand
class	chi2BF
class	Dispersion_Integrand

Functions
Double_t	Bl_2 (double q, double r, int l)
Double_t	Q (double M, double m1, double m2)
Double_t	Gamma_2body (double M, double m1, double m2, int l, double r)
Double_t	Gamma_2body (Double_t *x, Double_t *par)
Double_t	BW_resonance (double m12, double m1, double m2, int l, double mass, double width, double r)
Double_t	Gamma_mother_3body_byM12 (Double_t *x, Double_t *par)
Double_t	Gamma_mother_3body (Double_t *x, Double_t *par)
Double_t	phaseSpaceIntegral (Double_t *x, Double_t *par)
double	Fermi_phaseSpace (double s, double lambda, double s0, double threshold)
Double_t	Fermi_phaseSpace (Double_t *x, Double_t *par)

Function Documentation

Bl_2()

Double_t Bl_2	(	double	q,
		double	r,
		int	l
	)

Definition at line 113 of file RunningWidthCalculator.cpp.

                                        {
    
    double z= q*r;
    if(l==1)return (2*z*z)/(1.+z*z);
    if(l==2)return (13*pow(z,4))/(9.+3.*z*z+pow(z,4));
    else return 1.;
}

BW_resonance()

Double_t BW_resonance	(	double	m12,
		double	m1,
		double	m2,
		int	l,
		double	mass,
		double	width,
		double	r
	)

Definition at line 146 of file RunningWidthCalculator.cpp.

                                                                                                      {
    double gamma = Gamma_2body(m12,m1,m2,l,r);
    double gamma0 = Gamma_2body(mass,m1,m2,l,r);
    
    gamma= width*gamma/gamma0;
    
    return m12*gamma/((mass*mass-m12*m12)*(mass*mass-m12*m12)+(mass*gamma)*(mass*gamma));
}

Fermi_phaseSpace() [1/2]

double Fermi_phaseSpace	(	double	s,
		double	lambda,
		double	s0,
		double	threshold
	)

Definition at line 749 of file RunningWidthCalculator.cpp.

                                                                             {
    if (s<threshold)return 0;
    return sqrt(1.- threshold/s)/(1.+ exp(lambda * (s0-s) ) );
}

Fermi_phaseSpace() [2/2]

Double_t Fermi_phaseSpace	(	Double_t *	x,
		Double_t *	par
	)

Definition at line 754 of file RunningWidthCalculator.cpp.

                                                     {
    return Fermi_phaseSpace(x[0],par[0],par[1],par[2]);
}

Gamma_2body() [1/2]

Double_t Gamma_2body	(	double	M,
		double	m1,
		double	m2,
		int	l,
		double	r
	)

Definition at line 132 of file RunningWidthCalculator.cpp.

                                                                     {
    
    double q = Q(M,m1,m2);
    
    double bl_2 = Bl_2(q,r,l); 
    
    return q/M * bl_2;
}

Gamma_2body() [2/2]

Double_t Gamma_2body	(	Double_t *	x,
		Double_t *	par
	)

Definition at line 141 of file RunningWidthCalculator.cpp.

                                                {
    if(sqrt(x[0])*GeV< (par[0]+par[1]))return 0;
    return Gamma_2body(sqrt(x[0])*GeV,par[0],par[1],(int)par[2],par[3]);
}

Gamma_mother_3body()

Double_t Gamma_mother_3body	(	Double_t *	x,
		Double_t *	par
	)

Definition at line 171 of file RunningWidthCalculator.cpp.

                                                       {
    
    const int nPar = 10;
    const int nPar_new = 11;
    double min_s12 = par[1]+par[2];
    double bachelorMass = par[3] ; 
    
    // Copy parameters
    Double_t par_new[nPar_new];
    for (int i=0; i< nPar; i++) {
        par_new[i] = par[i];
    }
    // Add m(1,2,3) as parameter
    par_new[10] = sqrt(x[0])*GeV;
    
    if(sqrt(x[0])*GeV-bachelorMass<min_s12)return 0.;
    
    TF1 *gamma_byS12 = new TF1("Gamma_mother_3body_byM12",Gamma_mother_3body_byM12,min_s12,par[9],nPar_new);
    gamma_byS12->SetParameters(par_new);
    double gamma  = gamma_byS12->Integral(min_s12, sqrt(x[0])*GeV-bachelorMass);
      
    return gamma;    
}

Gamma_mother_3body_byM12()

Double_t Gamma_mother_3body_byM12	(	Double_t *	x,
		Double_t *	par
	)

Definition at line 155 of file RunningWidthCalculator.cpp.

                                                             {
    
    //3 body decay : X -> (R->1 2) 3
    //par[0]: mother (X) radius
    //x[0]: m12, to be integrated over
    //par[i]: final state masses, i=1,2,3
    //par[4]: angular momentum in X -> R 3
    //par[5]: angular momentum in R -> 1 2
    //par[6]: resonance (R) mass
    //par[7]: resonance (R) width
    //par[8]: resonance (X) radius
    //par[10]: mother (X) mass

    return Gamma_2body(par[10],x[0],par[3],par[4],par[0])*BW_resonance(x[0],par[1],par[2],par[5],par[6],par[7],par[8])*x[0];
}

phaseSpaceIntegral()

Double_t phaseSpaceIntegral	(	Double_t *	x,
		Double_t *	par
	)

Definition at line 676 of file RunningWidthCalculator.cpp.

                                                       {
    
    //x[0]: mumsRecoMass()^2
    //par[0]: mumsMass()
    //par[i]: final state masses (i=1,2,3)
    
    PhaseSpaceIntegral3body ps;
    double ps_val = ps.getVal(sqrt(x[0])*GeV,par[1],par[2],par[3]);
    double ps0_val =  ps.getVal(par[0],par[1],par[2],par[3]);
    
    double ps_ratio=0.;
    if(ps0_val>0)ps_ratio= ps_val/ps0_val;
    
    return ps_ratio * par[0]/(sqrt(x[0])*GeV);
}

Q()

Double_t Q	(	double	M,
		double	m1,
		double	m2
	)

Definition at line 121 of file RunningWidthCalculator.cpp.

{
    Double_t q2 = (M*M-(m1+m2)*(m1+m2) ) * (M*M-(m1-m2)*(m1-m2) ) / (4.*M*M) ;  
    if(q2<0){
        cout << " q2 = " << q2 << " M = " << M << " m1 = " << m1 << " m2 = " << m2 << endl;
        q2=0;
        
    }
    return sqrt(q2); 
}