LauBelleCPCoeffSet.cc

Go to the documentation of this file.

// Copyright University of Warwick 2006 - 2013.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

// Authors:
// Thomas Latham
// John Back
// Paul Harrison

#include <iostream>
#include <fstream>
#include <vector>
using std::cout;
using std::cerr;
using std::endl;
using std::vector;

#include "TMath.h"
#include "TRandom.h"

#include "LauComplex.hh"
#include "LauConstants.hh"
#include "LauBelleCPCoeffSet.hh"
#include "LauParameter.hh"
#include "LauPrint.hh"
#include "LauRandom.hh"

ClassImp(LauBelleCPCoeffSet)


LauBelleCPCoeffSet::LauBelleCPCoeffSet(const TString& compName, Double_t a, Double_t delta, Double_t b, Double_t phi,
                Bool_t aFixed, Bool_t deltaFixed, Bool_t bFixed, Bool_t phiFixed) :
        LauAbsCoeffSet(compName),
        minMag_(-10.0),
        maxMag_(+10.0),
        minPhase_(-LauConstants::threePi),
        maxPhase_(+LauConstants::threePi),
        a_(new LauParameter("A", a, minMag_, maxMag_, aFixed)),
        b_(new LauParameter("B", b, minMag_, maxMag_, bFixed)),
        delta_(new LauParameter("Delta", delta, minPhase_, maxPhase_, deltaFixed)),
        phi_(new LauParameter("Phi", phi, minPhase_, maxPhase_, phiFixed)),
        acp_("ACP", (-2.0*b*TMath::Cos(phi))/(1.0+b*b), -1.0, 1.0, bFixed&&phiFixed)
{
        // Print message
        cout<<"Set component \""<<this->name()<<"\" to have a-magnitude = "<<a_->value()<<",\tdelta = "<<delta_->value()<<",\t";
        cout<<"b-magnitude = "<<b_->value()<<",\tphi = "<<phi_->value()<<"."<<endl;
}

LauBelleCPCoeffSet::LauBelleCPCoeffSet(const LauBelleCPCoeffSet& rhs, Double_t constFactor) : LauAbsCoeffSet(rhs.name())
{
        minMag_ = rhs.minMag_;
        maxMag_ = rhs.maxMag_;
        minPhase_ = rhs.minPhase_;
        maxPhase_ = rhs.maxPhase_;
        a_ = rhs.a_->createClone(constFactor);
        b_ = rhs.b_->createClone(constFactor);
        delta_ = rhs.delta_->createClone(constFactor);
        phi_ = rhs.phi_->createClone(constFactor);
        acp_ = rhs.acp_;
}

LauBelleCPCoeffSet& LauBelleCPCoeffSet::operator=(const LauBelleCPCoeffSet& rhs)
{
        if (&rhs == this) {
                return *this;
        }
        this->name(rhs.name());
        minMag_ = rhs.minMag_;
        maxMag_ = rhs.maxMag_;
        minPhase_ = rhs.minPhase_;
        maxPhase_ = rhs.maxPhase_;
        a_ = rhs.a_->createClone();
        b_ = rhs.b_->createClone();
        delta_ = rhs.delta_->createClone();
        phi_ = rhs.phi_->createClone();
        acp_ = rhs.acp_;
        return *this;
}

vector<LauParameter*> LauBelleCPCoeffSet::getParameters()
{
        vector<LauParameter*> pars;
        pars.push_back(a_);
        pars.push_back(b_);
        pars.push_back(delta_);
        pars.push_back(phi_);
        return pars;
}

void LauBelleCPCoeffSet::printTableHeading(std::ostream& stream)
{
        stream<<"\\begin{tabular}{|l|c|c|c|c|}"<<endl;
        stream<<"\\hline"<<endl;
        stream<<"Component & a-Magnitude & delta & b-Magnitude & phi \\\\"<<endl;
        stream<<"\\hline"<<endl;
}

void LauBelleCPCoeffSet::printTableRow(std::ostream& stream)
{
        LauPrint print;
        TString resName = this->name();
        resName = resName.ReplaceAll("_", "\\_");
        stream<<resName<<"  &  $";
        print.printFormat(stream, a_->value());
        stream<<" \\pm ";
        print.printFormat(stream, a_->error());
        stream<<"$  &  $";
        print.printFormat(stream, delta_->value());
        stream<<" \\pm ";
        print.printFormat(stream, delta_->error());
        stream<<"$  &  $";
        print.printFormat(stream, b_->value());
        stream<<" \\pm ";
        print.printFormat(stream, b_->error());
        stream<<"$  &  $";
        print.printFormat(stream, phi_->value());
        stream<<" \\pm ";
        print.printFormat(stream, phi_->error());
        stream<<"$ \\\\"<<endl;
}

void LauBelleCPCoeffSet::randomiseInitValues()
{
        if (a_->fixed() == kFALSE) {
                // Choose an a-magnitude between 0.0 and 2.0
                Double_t mag = LauRandom::zeroSeedRandom()->Rndm()*2.0;
                a_->initValue(mag); a_->value(mag);
        }
        if (b_->fixed() == kFALSE) {
                // Choose a b-magnitude between 0.0 and 0.1
                Double_t mag = LauRandom::zeroSeedRandom()->Rndm()*0.1;
                b_->initValue(mag);  b_->value(mag);
        }
        if (delta_->fixed() == kFALSE) {
                // Choose a phase between +- pi
                Double_t phase = LauRandom::zeroSeedRandom()->Rndm()*LauConstants::twoPi - LauConstants::pi;
                delta_->initValue(phase); delta_->value(phase);
        }
        if (phi_->fixed() == kFALSE) {
                // Choose a phase between +- pi
                Double_t phase = LauRandom::zeroSeedRandom()->Rndm()*LauConstants::twoPi - LauConstants::pi;
                phi_->initValue(phase); phi_->value(phase);
        }
}

void LauBelleCPCoeffSet::finaliseValues()
{
        // retrieve the current values from the parameters
        Double_t aVal     = a_->value();
        Double_t bVal     = b_->value();
        Double_t deltaVal = delta_->value();
        Double_t phiVal   = phi_->value();
        Double_t genDelta = delta_->genValue();
        Double_t genPhi   = phi_->genValue();

        // Check whether we have a negative "a" magnitude.
        // If so make it positive and add pi to the "delta" phase.
        if (aVal < 0.0) {
                aVal *= -1.0;
                deltaVal += LauConstants::pi;
        }

        // Check whether we have a negative "b" magnitude.
        // If so make it positive and add pi to the "phi" phase.
        if (bVal < 0.0) {
                bVal *= -1.0;
                phiVal += LauConstants::pi;
        }

        // Check now whether the phases lies in the right range (-pi to pi).
        Bool_t deltaWithinRange(kFALSE);
        Bool_t phiWithinRange(kFALSE);
        while (deltaWithinRange == kFALSE && phiWithinRange == kFALSE) {
                if (deltaVal > -LauConstants::pi && deltaVal < LauConstants::pi) {
                        deltaWithinRange = kTRUE;
                } else {
                        // Not within the specified range
                        if (deltaVal > LauConstants::pi) {
                                deltaVal -= LauConstants::twoPi;
                        } else if (deltaVal < -LauConstants::pi) {
                                deltaVal += LauConstants::twoPi;
                        }
                }

                if (phiVal > -LauConstants::pi && phiVal < LauConstants::pi) {
                        phiWithinRange = kTRUE;
                } else {
                        // Not within the specified range
                        if (phiVal > LauConstants::pi) {
                                phiVal -= LauConstants::twoPi;
                        } else if (phiVal < -LauConstants::pi) {
                                phiVal += LauConstants::twoPi;
                        }
                }
        }

        // A further problem can occur when the generated phase is close to -pi or pi.
        // The phase can wrap over to the other end of the scale -
        // this leads to artificially large pulls so we wrap it back.
        Double_t diff = deltaVal - genDelta;
        if (diff > LauConstants::pi) {
                deltaVal -= LauConstants::twoPi;
        } else if (diff < -LauConstants::pi) {
                deltaVal += LauConstants::twoPi;
        }

        diff = phiVal - genPhi;
        if (diff > LauConstants::pi) {
                phiVal -= LauConstants::twoPi;
        } else if (diff < -LauConstants::pi) {
                phiVal += LauConstants::twoPi;
        }

        // finally store the new values in the parameters
        // and update the pulls
        a_->value(aVal);          a_->updatePull();
        b_->value(bVal);          b_->updatePull();
        delta_->value(deltaVal);  delta_->updatePull();
        phi_->value(phiVal);      phi_->updatePull();
}

LauComplex LauBelleCPCoeffSet::particleCoeff()
{
        LauComplex aTerm(a_->value()*TMath::Cos(delta_->value()), a_->value()*TMath::Sin(delta_->value()));
        LauComplex bTerm(b_->value()*TMath::Cos(phi_->value()), b_->value()*TMath::Sin(phi_->value()));
        LauComplex coeff(1.0,0.0);
        coeff += bTerm;
        coeff *= aTerm;
        return coeff;
}

LauComplex LauBelleCPCoeffSet::antiparticleCoeff()
{
        LauComplex aTerm(a_->value()*TMath::Cos(delta_->value()), a_->value()*TMath::Sin(delta_->value()));
        LauComplex bTerm(b_->value()*TMath::Cos(phi_->value()), b_->value()*TMath::Sin(phi_->value()));
        LauComplex coeff(1.0,0.0);
        coeff -= bTerm;
        coeff *= aTerm;
        return coeff;
}

void LauBelleCPCoeffSet::setCoeffValues( const LauComplex& coeff, const LauComplex& coeffBar )
{
        LauComplex sum = coeff + coeffBar;
        LauComplex diff = coeff - coeffBar;
        LauComplex ratio = diff / sum;

        a_->value( 0.5 * sum.abs() );
        delta_->value( sum.arg() );

        b_->value( ratio.abs() );
        phi_->value( ratio.arg() );
}

LauParameter LauBelleCPCoeffSet::acp()
{
        // set the name
        TString parName(this->baseName()); parName += "_ACP";
        acp_.name(parName);

        // work out the ACP value
        Double_t value = (-2.0*b_->value()*TMath::Cos(phi_->value()))/(1.0+b_->value()*b_->value());

        // is it fixed?
        Bool_t fixed = b_->fixed() && phi_->fixed();
        acp_.fixed(fixed);

        // we can't work out the error without the covariance matrix
        Double_t error(0.0);

        // set the value and error
        acp_.valueAndErrors(value,error);

        return acp_;
}

LauAbsCoeffSet* LauBelleCPCoeffSet::createClone(const TString& newName, Double_t constFactor)
{
        LauAbsCoeffSet* clone = new LauBelleCPCoeffSet( *this, constFactor );
        clone->name( newName );
        return clone;
}