NP_couplings.h

Go to the documentation of this file.

/*
 * Copyright (C) 2014 HEPfit Collaboration
 *
 *
 * For the licensing terms see doc/COPYING.
 */
 
#ifndef NPCOUPLINGS_H
#define NPCOUPLINGS_H
 
#include "gslpp.h"
#include "StandardModel.h"
 
#include <ThObservable.h>
#include <string.h>
#include <stdexcept>
 
class NPbase;
 
//-----  Zff couplings observables  ----------
 
class deltagZveveL : public ThObservable {
public:
 
    deltagZveveL(const StandardModel& SM_i, const double mu_i);
      
    virtual ~deltagZveveL();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
    const double mu;
};
 
class deltagZvmuvmuL : public ThObservable {
public:
 
    deltagZvmuvmuL(const StandardModel& SM_i, const double mu_i);
      
    virtual ~deltagZvmuvmuL();
 
    double computeThValue();
    
private:
    const NPbase * myNPbase;
    const double mu;
};
 
 
class deltagZvtavtaL : public ThObservable {
public:
 
    deltagZvtavtaL(const StandardModel& SM_i, const double mu_i);
      
    virtual ~deltagZvtavtaL();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
    const double mu;
};
 
 
class deltagZeeL : public ThObservable {
public:
 
    deltagZeeL(const StandardModel& SM_i, const double mu_i);
      
    virtual ~deltagZeeL();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
    const double mu;
};
 
class deltagZeeR : public ThObservable {
public:
 
    deltagZeeR(const StandardModel& SM_i, const double mu_i);
      
    virtual ~deltagZeeR();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
    const double mu;
};
 
class deltagZmumuL : public ThObservable {
public:
 
    deltagZmumuL(const StandardModel& SM_i, const double mu_i);
      
    virtual ~deltagZmumuL();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
    const double mu;
};
 
class deltagZmumuR : public ThObservable {
public:
 
    deltagZmumuR(const StandardModel& SM_i, const double mu_i);
      
    virtual ~deltagZmumuR();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
    const double mu;
};
 
class deltagZtataL : public ThObservable {
public:
 
    deltagZtataL(const StandardModel& SM_i, const double mu_i);
      
    virtual ~deltagZtataL();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
    const double mu;
};
 
class deltagZtataR : public ThObservable {
public:
 
    deltagZtataR(const StandardModel& SM_i, const double mu_i);
      
    virtual ~deltagZtataR();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
    const double mu;
};
 
class deltagZuuL : public ThObservable {
public:
 
    deltagZuuL(const StandardModel& SM_i, const double mu_i);
      
    virtual ~deltagZuuL();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
    const double mu;
};
 
class deltagZuuR : public ThObservable {
public:
 
    deltagZuuR(const StandardModel& SM_i, const double mu_i);
      
    virtual ~deltagZuuR();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
    const double mu;
};
 
class deltagZuuV : public ThObservable {
public:
 
    deltagZuuV(const StandardModel& SM_i, const double mu_i);
      
    virtual ~deltagZuuV();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
    const double mu;
};
 
class deltagZuuA : public ThObservable {
public:
 
    deltagZuuA(const StandardModel& SM_i, const double mu_i);
      
    virtual ~deltagZuuA();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
    const double mu;
};
 
class deltagZccL : public ThObservable {
public:
 
    deltagZccL(const StandardModel& SM_i, const double mu_i);
      
    virtual ~deltagZccL();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
    const double mu;
};
 
class deltagZccR : public ThObservable {
public:
 
    deltagZccR(const StandardModel& SM_i, const double mu_i);
      
    virtual ~deltagZccR();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
    const double mu;
};
 
class deltagZttL : public ThObservable {
public:
 
    deltagZttL(const StandardModel& SM_i, const double mu_i);
      
    virtual ~deltagZttL();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
    const double mu;
};
 
class deltagZttR : public ThObservable {
public:
 
    deltagZttR(const StandardModel& SM_i, const double mu_i);
      
    virtual ~deltagZttR();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
    const double mu;
};
 
class deltagZttV : public ThObservable {
public:
 
    deltagZttV(const StandardModel& SM_i, const double mu_i);
      
    virtual ~deltagZttV();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
    const double mu;
};
 
class deltagZttA : public ThObservable {
public:
 
    deltagZttA(const StandardModel& SM_i, const double mu_i);
      
    virtual ~deltagZttA();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
    const double mu;
};
 
 
class deltagZddL : public ThObservable {
public:
 
    deltagZddL(const StandardModel& SM_i, const double mu_i);
      
    virtual ~deltagZddL();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
    const double mu;
};
 
class deltagZddR : public ThObservable {
public:
 
    deltagZddR(const StandardModel& SM_i, const double mu_i);
      
    virtual ~deltagZddR();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
    const double mu;
};
 
class deltagZddV : public ThObservable {
public:
 
    deltagZddV(const StandardModel& SM_i, const double mu_i);
      
    virtual ~deltagZddV();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
    const double mu;
};
 
class deltagZddA : public ThObservable {
public:
 
    deltagZddA(const StandardModel& SM_i, const double mu_i);
      
    virtual ~deltagZddA();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
    const double mu;
};
 
class deltagZssL : public ThObservable {
public:
 
    deltagZssL(const StandardModel& SM_i, const double mu_i);
      
    virtual ~deltagZssL();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
    const double mu;
};
 
class deltagZssR : public ThObservable {
public:
 
    deltagZssR(const StandardModel& SM_i, const double mu_i);
      
    virtual ~deltagZssR();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
    const double mu;
};
 
class deltagZbbL : public ThObservable {
public:
 
    deltagZbbL(const StandardModel& SM_i, const double mu_i);
      
    virtual ~deltagZbbL();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
    const double mu;
};
 
class deltagZbbR : public ThObservable {
public:
 
    deltagZbbR(const StandardModel& SM_i, const double mu_i);
      
    virtual ~deltagZbbR();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
    const double mu;
};
 
 
//-----  Zff EFFECTIVE couplings observables: relative corrections (derived from Af and Gamma(Z->ff)  ----------
 
 
class deltagEffZveveL : public ThObservable {
public:
 
    deltagEffZveveL(const StandardModel& SM_i);
      
    virtual ~deltagEffZveveL();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
 
};
 
class deltagEffZvmuvmuL : public ThObservable {
public:
 
    deltagEffZvmuvmuL(const StandardModel& SM_i);
      
    virtual ~deltagEffZvmuvmuL();
 
    double computeThValue();
    
private:
    const NPbase * myNPbase;
 
};
 
 
class deltagEffZvtavtaL : public ThObservable {
public:
 
    deltagEffZvtavtaL(const StandardModel& SM_i);
      
    virtual ~deltagEffZvtavtaL();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
 
};
 
 
class deltagEffZeeL : public ThObservable {
public:
 
    deltagEffZeeL(const StandardModel& SM_i);
      
    virtual ~deltagEffZeeL();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
 
};
 
class deltagEffZeeR : public ThObservable {
public:
 
    deltagEffZeeR(const StandardModel& SM_i);
      
    virtual ~deltagEffZeeR();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
 
};
 
class deltagEffZmumuL : public ThObservable {
public:
 
    deltagEffZmumuL(const StandardModel& SM_i);
      
    virtual ~deltagEffZmumuL();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
 
};
 
class deltagEffZmumuR : public ThObservable {
public:
 
    deltagEffZmumuR(const StandardModel& SM_i);
      
    virtual ~deltagEffZmumuR();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
 
};
 
class deltagEffZtataL : public ThObservable {
public:
 
    deltagEffZtataL(const StandardModel& SM_i);
      
    virtual ~deltagEffZtataL();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
 
};
 
class deltagEffZtataR : public ThObservable {
public:
 
    deltagEffZtataR(const StandardModel& SM_i);
      
    virtual ~deltagEffZtataR();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
 
};
 
class deltagEffZccL : public ThObservable {
public:
 
    deltagEffZccL(const StandardModel& SM_i);
      
    virtual ~deltagEffZccL();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
 
};
 
class deltagEffZccR : public ThObservable {
public:
 
    deltagEffZccR(const StandardModel& SM_i);
      
    virtual ~deltagEffZccR();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
 
};
 
 
class deltagEffZssL : public ThObservable {
public:
 
    deltagEffZssL(const StandardModel& SM_i);
      
    virtual ~deltagEffZssL();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
 
};
 
class deltagEffZssR : public ThObservable {
public:
 
    deltagEffZssR(const StandardModel& SM_i);
      
    virtual ~deltagEffZssR();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
 
};
 
class deltagEffZbbL : public ThObservable {
public:
 
    deltagEffZbbL(const StandardModel& SM_i);
      
    virtual ~deltagEffZbbL();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
 
};
 
class deltagEffZbbR : public ThObservable {
public:
 
    deltagEffZbbR(const StandardModel& SM_i);
      
    virtual ~deltagEffZbbR();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
 
};
 
//-----  Wff couplings observables  ----------
 
class deltaUWeve : public ThObservable {
public:
 
    deltaUWeve(const StandardModel& SM_i, const double mu_i);
      
    virtual ~deltaUWeve();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
    const double mu;
};
 
class deltaUWmuvmu : public ThObservable {
public:
 
    deltaUWmuvmu(const StandardModel& SM_i, const double mu_i);
      
    virtual ~deltaUWmuvmu();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
    const double mu;
};
 
class deltaUWtavta : public ThObservable {
public:
 
    deltaUWtavta(const StandardModel& SM_i, const double mu_i);
      
    virtual ~deltaUWtavta();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
    const double mu;
};
 
class deltaVudL : public ThObservable {
public:
 
    deltaVudL(const StandardModel& SM_i, const double mu_i);
      
    virtual ~deltaVudL();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
    const double mu;
};
 
class deltaVudR : public ThObservable {
public:
 
    deltaVudR(const StandardModel& SM_i, const double mu_i);
      
    virtual ~deltaVudR();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
    const double mu;
};
 
class deltaVcsL : public ThObservable {
public:
 
    deltaVcsL(const StandardModel& SM_i, const double mu_i);
      
    virtual ~deltaVcsL();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
    const double mu;
};
 
class deltaVcsR : public ThObservable {
public:
 
    deltaVcsR(const StandardModel& SM_i, const double mu_i);
      
    virtual ~deltaVcsR();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
    const double mu;
};
 
class deltaVtbL : public ThObservable {
public:
 
    deltaVtbL(const StandardModel& SM_i, const double mu_i);
      
    virtual ~deltaVtbL();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
    const double mu;
};
 
class deltaVtbR : public ThObservable {
public:
 
    deltaVtbR(const StandardModel& SM_i, const double mu_i);
      
    virtual ~deltaVtbR();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
    const double mu;
};
 
 
//-----  Hff couplings observables  ----------
 
class deltagHee : public ThObservable {
public:
 
    deltagHee(const StandardModel& SM_i, const double mu_i);
      
    virtual ~deltagHee();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
    const double mu;
};
 
class deltagHmumu : public ThObservable {
public:
 
    deltagHmumu(const StandardModel& SM_i, const double mu_i);
      
    virtual ~deltagHmumu();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
    const double mu;
};
 
class gHmumueff : public ThObservable {
public:
 
    gHmumueff(const StandardModel& SM_i);
      
    virtual ~gHmumueff();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
};
 
class deltagHtata : public ThObservable {
public:
 
    deltagHtata(const StandardModel& SM_i, const double mu_i);
      
    virtual ~deltagHtata();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
    const double mu;
};
 
class gHtataeff : public ThObservable {
public:
 
    gHtataeff(const StandardModel& SM_i);
      
    virtual ~gHtataeff();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
};
 
 
class deltagHuu : public ThObservable {
public:
 
    deltagHuu(const StandardModel& SM_i, const double mu_i);
      
    virtual ~deltagHuu();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
    const double mu;
};
 
 
class deltagHcc : public ThObservable {
public:
 
    deltagHcc(const StandardModel& SM_i, const double mu_i);
      
    virtual ~deltagHcc();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
    const double mu;
};
 
class gHcceff : public ThObservable {
public:
 
    gHcceff(const StandardModel& SM_i);
      
    virtual ~gHcceff();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
};
 
class deltagHtt : public ThObservable {
public:
 
    deltagHtt(const StandardModel& SM_i, const double mu_i);
      
    virtual ~deltagHtt();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
    const double mu;
};
 
class deltagHdd : public ThObservable {
public:
 
    deltagHdd(const StandardModel& SM_i, const double mu_i);
      
    virtual ~deltagHdd();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
    const double mu;
};
 
class deltagHss : public ThObservable {
public:
 
    deltagHss(const StandardModel& SM_i, const double mu_i);
      
    virtual ~deltagHss();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
    const double mu;
};
 
 
class deltagHbb : public ThObservable {
public:
 
    deltagHbb(const StandardModel& SM_i, const double mu_i);
      
    virtual ~deltagHbb();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
    const double mu;
};
 
class gHbbeff : public ThObservable {
public:
 
    gHbbeff(const StandardModel& SM_i);
      
    virtual ~gHbbeff();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
};
 
//-----  HGG couplings observables  ----------
 
class deltagHGG : public ThObservable {
public:
 
    deltagHGG(const StandardModel& SM_i, const double mu_i);
      
    virtual ~deltagHGG();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
    const double mu;
};
 
class gHGGeff : public ThObservable {
public:
 
    gHGGeff(const StandardModel& SM_i);
      
    virtual ~gHGGeff();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
};
 
//-----  HZZ couplings observables  ----------
 
class deltagHZZ : public ThObservable {
public:
 
    deltagHZZ(const StandardModel& SM_i, const double mu_i);
      
    virtual ~deltagHZZ();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
    const double mu;
};
 
class gHZZeff : public ThObservable {
public:
 
    gHZZeff(const StandardModel& SM_i);
      
    virtual ~gHZZeff();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
};
 
class gHZZ4feff : public ThObservable {
public:
 
    gHZZ4feff(const StandardModel& SM_i);
      
    virtual ~gHZZ4feff();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
};
 
class gHZZ1 : public ThObservable {
public:
 
    gHZZ1(const StandardModel& SM_i, const double mu_i);
      
    virtual ~gHZZ1();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
    const double mu;
};
 
class gHZZ2 : public ThObservable {
public:
 
    gHZZ2(const StandardModel& SM_i, const double mu_i);
      
    virtual ~gHZZ2();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
    const double mu;
};
 
//-----  HAA couplings observables  ----------
 
class deltagHAA : public ThObservable {
public:
 
    deltagHAA(const StandardModel& SM_i, const double mu_i);
      
    virtual ~deltagHAA();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
    const double mu;
};
 
 
class gHAAeff : public ThObservable {
public:
 
    gHAAeff(const StandardModel& SM_i);
      
    virtual ~gHAAeff();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
};
 
//-----  HZA couplings observables  ----------
 
class deltagHZA : public ThObservable {
public:
 
    deltagHZA(const StandardModel& SM_i, const double mu_i);
      
    virtual ~deltagHZA();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
    const double mu;
};
 
class gHZAeff : public ThObservable {
public:
 
    gHZAeff(const StandardModel& SM_i);
      
    virtual ~gHZAeff();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
};
 
class gHZA2 : public ThObservable {
public:
 
    gHZA2(const StandardModel& SM_i, const double mu_i);
      
    virtual ~gHZA2();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
    const double mu;
};
 
//-----  HWW couplings observables  ----------
 
class deltagHWW : public ThObservable {
public:
 
    deltagHWW(const StandardModel& SM_i, const double mu_i);
      
    virtual ~deltagHWW();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
    const double mu;
};
 
class gHWWeff : public ThObservable {
public:
 
    gHWWeff(const StandardModel& SM_i);
      
    virtual ~gHWWeff();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
};
 
class gHWW4feff : public ThObservable {
public:
 
    gHWW4feff(const StandardModel& SM_i);
      
    virtual ~gHWW4feff();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
};
 
class gHWW1 : public ThObservable {
public:
 
    gHWW1(const StandardModel& SM_i, const double mu_i);
      
    virtual ~gHWW1();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
    const double mu;
};
 
class gHWW2 : public ThObservable {
public:
 
    gHWW2(const StandardModel& SM_i, const double mu_i);
      
    virtual ~gHWW2();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
    const double mu;
};
 
//-----  Other couplings observables  ----------
 
class gHWZeff : public ThObservable {
public:
 
    gHWZeff(const StandardModel& SM_i);
      
    virtual ~gHWZeff();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
};
 
class gHWZSMLin : public ThObservable {
public:
 
    gHWZSMLin(const StandardModel& SM_i, const double mu_i);
      
    virtual ~gHWZSMLin();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
    const double mu;
};
 
class gHbWeff : public ThObservable {
public:
 
    gHbWeff(const StandardModel& SM_i);
      
    virtual ~gHbWeff();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
};
 
 
class gHtaWeff : public ThObservable {
public:
 
    gHtaWeff(const StandardModel& SM_i);
      
    virtual ~gHtaWeff();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
};
 
//-----  HHH couplings observables  ----------
 
class deltalHHH : public ThObservable {
public:
 
    deltalHHH(const StandardModel& SM_i, const double mu_i);
      
    virtual ~deltalHHH();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
    const double mu;
};
 
//-----  VVV couplings observables  ----------
 
// See aTGC in EW. Here we define only the Effective couplings used in arXiv: 1708.09079 [hep-ph]
 
class deltag1ZEff : public ThObservable {
public:
 
    deltag1ZEff(const StandardModel& SM_i);
      
    virtual ~deltag1ZEff();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
};
 
 
class deltaKgammaEff : public ThObservable {
public:
 
    deltaKgammaEff(const StandardModel& SM_i);
      
    virtual ~deltaKgammaEff();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
};
 
 
//-----  Basic interactions of the so-called Higgs basis  ----------
 
class deltaytHB : public ThObservable {
public:
 
    deltaytHB(const StandardModel& SM_i, const double mu_i);
      
    virtual ~deltaytHB();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
    const double mu;
};
 
class deltaybHB : public ThObservable {
public:
 
    deltaybHB(const StandardModel& SM_i, const double mu_i);
      
    virtual ~deltaybHB();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
    const double mu;
};
 
class deltaytauHB : public ThObservable {
public:
 
    deltaytauHB(const StandardModel& SM_i, const double mu_i);
      
    virtual ~deltaytauHB();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
    const double mu;
};
 
class deltaycHB : public ThObservable {
public:
 
    deltaycHB(const StandardModel& SM_i, const double mu_i);
      
    virtual ~deltaycHB();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
    const double mu;
};
 
 
class deltaymuHB : public ThObservable {
public:
 
    deltaymuHB(const StandardModel& SM_i, const double mu_i);
      
    virtual ~deltaymuHB();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
    const double mu;
};
 
 
class deltacZHB : public ThObservable {
public:
 
    deltacZHB(const StandardModel& SM_i, const double mu_i);
      
    virtual ~deltacZHB();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
    const double mu;
};
 
 
class cZBoxHB : public ThObservable {
public:
 
    cZBoxHB(const StandardModel& SM_i, const double mu_i);
      
    virtual ~cZBoxHB();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
    const double mu;
};
 
 
class cZZHB : public ThObservable {
public:
 
    cZZHB(const StandardModel& SM_i, const double mu_i);
      
    virtual ~cZZHB();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
    const double mu;
};
 
 
class cZgaHB : public ThObservable {
public:
 
    cZgaHB(const StandardModel& SM_i, const double mu_i);
      
    virtual ~cZgaHB();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
    const double mu;
};
 
 
class cgagaHB : public ThObservable {
public:
 
    cgagaHB(const StandardModel& SM_i, const double mu_i);
      
    virtual ~cgagaHB();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
    const double mu;
};
 
 
class cggHB : public ThObservable {
public:
 
    cggHB(const StandardModel& SM_i, const double mu_i);
      
    virtual ~cggHB();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
    const double mu;
};
 
 
class cggEffHB : public ThObservable {
public:
 
    cggEffHB(const StandardModel& SM_i, const double mu_i);
      
    virtual ~cggEffHB();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
    const double mu;
};
 
 
class lambzHB : public ThObservable {
public:
 
    lambzHB(const StandardModel& SM_i, const double mu_i);
      
    virtual ~lambzHB();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
    const double mu;
};
 
 
//-----  Other useful observables to work with new physics  ----------
 
 
//-----  Relative correction to W mass  ----------
 
class deltaMW : public ThObservable {
public:
 
    deltaMW(const StandardModel& SM_i);
      
    virtual ~deltaMW();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
};
 
 
//-----  Relative correction to EM constant  ----------
 
class deltae : public ThObservable {
public:
 
    deltae(const StandardModel& SM_i, const double mu_i);
      
    virtual ~deltae();
 
    double computeThValue();    
    
private:
    const NPbase * myNPbase;
    const double mu;
};
 
 
//-----  Absolute correction to some EW couplings (factoring e/sc or e/sqrt(2)s  ----------
 
class delgZlL : public ThObservable {
public:
 
    delgZlL(const StandardModel& SM_i, const StandardModel::lepton lepton, const double mu_i);
      
    virtual ~delgZlL();
 
    double computeThValue();    
    
private:
    const NPbase * myNPbase;
    StandardModel::lepton lepton;
    const double mu;
 
};
 
class delgZlR : public ThObservable {
public:
 
    delgZlR(const StandardModel& SM_i, const StandardModel::lepton lepton, const double mu_i);
      
    virtual ~delgZlR();
 
    double computeThValue();
    
private:
    const NPbase * myNPbase;
    StandardModel::lepton lepton;
    const double mu;
 
};
 
class delgZqL : public ThObservable {
public:
 
    delgZqL(const StandardModel& SM_i, const StandardModel::quark quark, const double mu_i);
      
    virtual ~delgZqL();
 
    double computeThValue();    
    
private:
    const NPbase * myNPbase;
    StandardModel::quark quark;
    const double mu;
 
};
 
class delgZqR : public ThObservable {
public:
 
    delgZqR(const StandardModel& SM_i, const StandardModel::quark quark, const double mu_i);
      
    virtual ~delgZqR();
 
    double computeThValue();
    
private:
    const NPbase * myNPbase;
    StandardModel::quark quark;
    const double mu;
 
};
 
 
//-----  Oblique parameters  ----------
 
class oblS : public ThObservable {
public:
 
    oblS(const StandardModel& SM_i);
      
    virtual ~oblS();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
};
 
class oblT : public ThObservable {
public:
 
    oblT(const StandardModel& SM_i);
      
    virtual ~oblT();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
};
 
 
class oblW : public ThObservable {
public:
 
    oblW(const StandardModel& SM_i);
      
    virtual ~oblW();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
};
 
 
class oblY : public ThObservable {
public:
 
    oblY(const StandardModel& SM_i);
      
    virtual ~oblY();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
};
 
 
//-----  Combinations of Warsaw basis coefficients constrained by EWPO  ----------
 
class CEWHL111 : public ThObservable {
public:
 
    CEWHL111(const StandardModel& SM_i);
      
    virtual ~CEWHL111();
 
    double computeThValue();
      
    const NPbase * myNPbase;
    
private:
 
 
};
 
class CEWHL122 : public ThObservable {
public:
 
    CEWHL122(const StandardModel& SM_i);
      
    virtual ~CEWHL122();
 
    double computeThValue();
      
    const NPbase * myNPbase;
    
private:
 
 
};
 
class CEWHL133 : public ThObservable {
public:
 
    CEWHL133(const StandardModel& SM_i);
      
    virtual ~CEWHL133();
 
    double computeThValue();
      
    const NPbase * myNPbase;
    
private:
 
 
};
 
 
class CEWHL311 : public ThObservable {
public:
 
    CEWHL311(const StandardModel& SM_i);
      
    virtual ~CEWHL311();
 
    double computeThValue();
      
    const NPbase * myNPbase;
    
private:
 
 
};
 
class CEWHL322 : public ThObservable {
public:
 
    CEWHL322(const StandardModel& SM_i);
      
    virtual ~CEWHL322();
 
    double computeThValue();
      
    const NPbase * myNPbase;
    
private:
 
 
};
 
class CEWHL333 : public ThObservable {
public:
 
    CEWHL333(const StandardModel& SM_i);
      
    virtual ~CEWHL333();
 
    double computeThValue();
      
    const NPbase * myNPbase;
    
private:
 
 
};
 
 
class CEWHQ111 : public ThObservable {
public:
 
    CEWHQ111(const StandardModel& SM_i);
      
    virtual ~CEWHQ111();
 
    double computeThValue();
      
    const NPbase * myNPbase;
    
private:
 
 
};
 
class CEWHQ122 : public ThObservable {
public:
 
    CEWHQ122(const StandardModel& SM_i);
      
    virtual ~CEWHQ122();
 
    double computeThValue();
      
    const NPbase * myNPbase;
    
private:
 
 
};
 
class CEWHQ133 : public ThObservable {
public:
 
    CEWHQ133(const StandardModel& SM_i);
      
    virtual ~CEWHQ133();
 
    double computeThValue();
      
    const NPbase * myNPbase;
    
private:
 
 
};
 
 
class CEWHQ311 : public ThObservable {
public:
 
    CEWHQ311(const StandardModel& SM_i);
      
    virtual ~CEWHQ311();
 
    double computeThValue();
      
    const NPbase * myNPbase;
    
private:
 
 
};
 
class CEWHQ322 : public ThObservable {
public:
 
    CEWHQ322(const StandardModel& SM_i);
      
    virtual ~CEWHQ322();
 
    double computeThValue();
      
    const NPbase * myNPbase;
    
private:
 
 
};
 
class CEWHQ333 : public ThObservable {
public:
 
    CEWHQ333(const StandardModel& SM_i);
      
    virtual ~CEWHQ333();
 
    double computeThValue();
      
    const NPbase * myNPbase;
    
private:
 
 
};
 
 
class CEWHQd33 : public ThObservable {
public:
 
    CEWHQd33(const StandardModel& SM_i);
      
    virtual ~CEWHQd33();
 
    double computeThValue();
      
    const NPbase * myNPbase;
    
private:
 
 
};
 
 
class CEWHe11 : public ThObservable {
public:
 
    CEWHe11(const StandardModel& SM_i);
      
    virtual ~CEWHe11();
 
    double computeThValue();
      
    const NPbase * myNPbase;
    
private:
 
 
};
 
 
class CEWHe22 : public ThObservable {
public:
 
    CEWHe22(const StandardModel& SM_i);
      
    virtual ~CEWHe22();
 
    double computeThValue();
      
    const NPbase * myNPbase;
    
private:
 
 
};
 
 
class CEWHe33 : public ThObservable {
public:
 
    CEWHe33(const StandardModel& SM_i);
      
    virtual ~CEWHe33();
 
    double computeThValue();
      
    const NPbase * myNPbase;
    
private:
 
 
};
 
 
class CEWHu11 : public ThObservable {
public:
 
    CEWHu11(const StandardModel& SM_i);
      
    virtual ~CEWHu11();
 
    double computeThValue();
      
    const NPbase * myNPbase;
    
private:
 
 
};
 
 
class CEWHu22 : public ThObservable {
public:
 
    CEWHu22(const StandardModel& SM_i);
      
    virtual ~CEWHu22();
 
    double computeThValue();
      
    const NPbase * myNPbase;
    
private:
 
 
};
 
 
class CEWHu33 : public ThObservable {
public:
 
    CEWHu33(const StandardModel& SM_i);
      
    virtual ~CEWHu33();
 
    double computeThValue();
      
    const NPbase * myNPbase;
    
private:
 
 
};
 
 
class CEWHd11 : public ThObservable {
public:
 
    CEWHd11(const StandardModel& SM_i);
      
    virtual ~CEWHd11();
 
    double computeThValue();
      
    const NPbase * myNPbase;
    
private:
 
 
};
 
 
class CEWHd22 : public ThObservable {
public:
 
    CEWHd22(const StandardModel& SM_i);
      
    virtual ~CEWHd22();
 
    double computeThValue();
      
    const NPbase * myNPbase;
    
private:
 
 
};
 
 
class CEWHd33 : public ThObservable {
public:
 
    CEWHd33(const StandardModel& SM_i);
      
    virtual ~CEWHd33();
 
    double computeThValue();
      
    const NPbase * myNPbase;
    
private:
 
 
};
 
 
//-----  Auxiliary observables  ----------
 
class AuxObsNP1 : public ThObservable {
public:
 
    AuxObsNP1(const StandardModel& SM_i);
      
    virtual ~AuxObsNP1();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
};
 
 
class AuxObsNP2 : public ThObservable {
public:
 
    AuxObsNP2(const StandardModel& SM_i);
      
    virtual ~AuxObsNP2();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
};
 
 
class AuxObsNP3 : public ThObservable {
public:
 
    AuxObsNP3(const StandardModel& SM_i);
      
    virtual ~AuxObsNP3();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
};
 
 
class AuxObsNP4 : public ThObservable {
public:
 
    AuxObsNP4(const StandardModel& SM_i);
      
    virtual ~AuxObsNP4();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
};
 
 
class AuxObsNP5 : public ThObservable {
public:
 
    AuxObsNP5(const StandardModel& SM_i);
      
    virtual ~AuxObsNP5();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
};
 
 
class AuxObsNP6 : public ThObservable {
public:
 
    AuxObsNP6(const StandardModel& SM_i);
      
    virtual ~AuxObsNP6();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
};
 
 
class AuxObsNP7 : public ThObservable {
public:
 
    AuxObsNP7(const StandardModel& SM_i);
      
    virtual ~AuxObsNP7();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
};
 
 
class AuxObsNP8 : public ThObservable {
public:
 
    AuxObsNP8(const StandardModel& SM_i);
      
    virtual ~AuxObsNP8();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
};
 
 
class AuxObsNP9 : public ThObservable {
public:
 
    AuxObsNP9(const StandardModel& SM_i);
      
    virtual ~AuxObsNP9();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
};
 
 
class AuxObsNP10 : public ThObservable {
public:
 
    AuxObsNP10(const StandardModel& SM_i);
      
    virtual ~AuxObsNP10();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
};
 
 
class AuxObsNP11 : public ThObservable {
public:
 
    AuxObsNP11(const StandardModel& SM_i);
      
    virtual ~AuxObsNP11();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
};
 
 
class AuxObsNP12 : public ThObservable {
public:
 
    AuxObsNP12(const StandardModel& SM_i);
      
    virtual ~AuxObsNP12();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
};
 
 
 
class AuxObsNP13 : public ThObservable {
public:
 
    AuxObsNP13(const StandardModel& SM_i);
      
    virtual ~AuxObsNP13();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
};
 
 
class AuxObsNP14 : public ThObservable {
public:
 
    AuxObsNP14(const StandardModel& SM_i);
      
    virtual ~AuxObsNP14();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
};
 
 
class AuxObsNP15 : public ThObservable {
public:
 
    AuxObsNP15(const StandardModel& SM_i);
      
    virtual ~AuxObsNP15();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
};
 
 
class AuxObsNP16 : public ThObservable {
public:
 
    AuxObsNP16(const StandardModel& SM_i);
      
    virtual ~AuxObsNP16();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
};
 
 
class AuxObsNP17 : public ThObservable {
public:
 
    AuxObsNP17(const StandardModel& SM_i);
      
    virtual ~AuxObsNP17();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
};
 
 
class AuxObsNP18 : public ThObservable {
public:
 
    AuxObsNP18(const StandardModel& SM_i);
      
    virtual ~AuxObsNP18();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
};
 
 
class AuxObsNP19 : public ThObservable {
public:
 
    AuxObsNP19(const StandardModel& SM_i);
      
    virtual ~AuxObsNP19();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
};
 
 
class AuxObsNP20 : public ThObservable {
public:
 
    AuxObsNP20(const StandardModel& SM_i);
      
    virtual ~AuxObsNP20();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
};
 
 
class AuxObsNP21 : public ThObservable {
public:
 
    AuxObsNP21(const StandardModel& SM_i);
      
    virtual ~AuxObsNP21();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
};
 
 
class AuxObsNP22 : public ThObservable {
public:
 
    AuxObsNP22(const StandardModel& SM_i);
      
    virtual ~AuxObsNP22();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
};
 
 
 
class AuxObsNP23 : public ThObservable {
public:
 
    AuxObsNP23(const StandardModel& SM_i);
      
    virtual ~AuxObsNP23();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
};
 
 
class AuxObsNP24 : public ThObservable {
public:
 
    AuxObsNP24(const StandardModel& SM_i);
      
    virtual ~AuxObsNP24();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
};
 
 
class AuxObsNP25 : public ThObservable {
public:
 
    AuxObsNP25(const StandardModel& SM_i);
      
    virtual ~AuxObsNP25();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
};
 
 
class AuxObsNP26 : public ThObservable {
public:
 
    AuxObsNP26(const StandardModel& SM_i);
      
    virtual ~AuxObsNP26();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
};
 
 
class AuxObsNP27 : public ThObservable {
public:
 
    AuxObsNP27(const StandardModel& SM_i);
      
    virtual ~AuxObsNP27();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
};
 
 
class AuxObsNP28 : public ThObservable {
public:
 
    AuxObsNP28(const StandardModel& SM_i);
      
    virtual ~AuxObsNP28();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
};
 
 
class AuxObsNP29 : public ThObservable {
public:
 
    AuxObsNP29(const StandardModel& SM_i);
      
    virtual ~AuxObsNP29();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
};
 
 
class AuxObsNP30 : public ThObservable {
public:
 
    AuxObsNP30(const StandardModel& SM_i);
      
    virtual ~AuxObsNP30();
 
    double computeThValue();
      
private:
    const NPbase * myNPbase;
};
 
 
 
 
//-----  Deviations of SM inputs with respect to reference value  ----------
// (To use in future collider studies where the predictions are assumed to be SM at some
//  reference point)
 
class dalphaMzRef : public ThObservable {
public:
 
    dalphaMzRef(const StandardModel& SM_i);
      
    virtual ~dalphaMzRef();
 
    double computeThValue();
 
    const NPbase * myNPbase;
    
private:
 
 
};
 
 
class dalphaSMzRef : public ThObservable {
public:
 
    dalphaSMzRef(const StandardModel& SM_i);
      
    virtual ~dalphaSMzRef();
 
    double computeThValue();
      
    const NPbase * myNPbase;
    
private:
 
    
};
 
 
class dMzRef : public ThObservable {
public:
 
    dMzRef(const StandardModel& SM_i);
      
    virtual ~dMzRef();
 
    double computeThValue();
      
    const NPbase * myNPbase;
    
private:
 
    
};
 
 
class dMHRef : public ThObservable {
public:
 
    dMHRef(const StandardModel& SM_i);
      
    virtual ~dMHRef();
 
    double computeThValue();
      
    const NPbase * myNPbase;
    
private:
 
    
};
 
 
class dmtRef : public ThObservable {
public:
 
    dmtRef(const StandardModel& SM_i);
      
    virtual ~dmtRef();
 
    double computeThValue();
      
    const NPbase * myNPbase;
    
private:
 
    
};
 
// Top Wilson coefficients in the notation of LHC Top WG arXiv: 1802.07237
 
class TWGcQQ1 : public ThObservable {
public:
 
    TWGcQQ1(const StandardModel& SM_i, const double mu_i);
      
    virtual ~TWGcQQ1();
 
    double computeThValue();
          
private:
    const NPbase * myNPbase;
    const double mu;
 
};
 
 
class TWGcQQ8 : public ThObservable {
public:
 
    TWGcQQ8(const StandardModel& SM_i, const double mu_i);
      
    virtual ~TWGcQQ8();
 
    double computeThValue();
          
private:
    const NPbase * myNPbase;
    const double mu;
 
};
 
 
class TWGctt1 : public ThObservable {
public:
 
    TWGctt1(const StandardModel& SM_i, const double mu_i);
      
    virtual ~TWGctt1();
 
    double computeThValue();
          
private:
    const NPbase * myNPbase;
    const double mu;
 
};
 
 
class TWGcQt1 : public ThObservable {
public:
 
    TWGcQt1(const StandardModel& SM_i, const double mu_i);
      
    virtual ~TWGcQt1();
 
    double computeThValue();
          
private:
    const NPbase * myNPbase;
    const double mu;
 
};
 
 
class TWGcQt8 : public ThObservable {
public:
 
    TWGcQt8(const StandardModel& SM_i, const double mu_i);
      
    virtual ~TWGcQt8();
 
    double computeThValue();
          
private:
    const NPbase * myNPbase;
    const double mu;
 
};
 
 
class TWGcQq31 : public ThObservable {
public:
 
    TWGcQq31(const StandardModel& SM_i, const double mu_i);
      
    virtual ~TWGcQq31();
 
    double computeThValue();
          
private:
    const NPbase * myNPbase;
    const double mu;
 
};
 
 
class TWGcQq38 : public ThObservable {
public:
 
    TWGcQq38(const StandardModel& SM_i, const double mu_i);
      
    virtual ~TWGcQq38();
 
    double computeThValue();
          
private:
    const NPbase * myNPbase;
    const double mu;
 
};
 
 
class TWGcQq11 : public ThObservable {
public:
 
    TWGcQq11(const StandardModel& SM_i, const double mu_i);
      
    virtual ~TWGcQq11();
 
    double computeThValue();
          
private:
    const NPbase * myNPbase;
    const double mu;
 
};
 
 
class TWGcQq18 : public ThObservable {
public:
 
    TWGcQq18(const StandardModel& SM_i, const double mu_i);
      
    virtual ~TWGcQq18();
 
    double computeThValue();
          
private:
    const NPbase * myNPbase;
    const double mu;
 
};
 
 
class TWGcQu1 : public ThObservable {
public:
 
    TWGcQu1(const StandardModel& SM_i, const double mu_i);
      
    virtual ~TWGcQu1();
 
    double computeThValue();
          
private:
    const NPbase * myNPbase;
    const double mu;
 
};
 
 
class TWGcQu8 : public ThObservable {
public:
 
    TWGcQu8(const StandardModel& SM_i, const double mu_i);
      
    virtual ~TWGcQu8();
 
    double computeThValue();
          
private:
    const NPbase * myNPbase;
    const double mu;
 
};
 
 
class TWGcQd1 : public ThObservable {
public:
 
    TWGcQd1(const StandardModel& SM_i, const double mu_i);
      
    virtual ~TWGcQd1();
 
    double computeThValue();
          
private:
    const NPbase * myNPbase;
    const double mu;
 
};
 
 
class TWGcQd8 : public ThObservable {
public:
 
    TWGcQd8(const StandardModel& SM_i, const double mu_i);
      
    virtual ~TWGcQd8();
 
    double computeThValue();
          
private:
    const NPbase * myNPbase;
    const double mu;
 
};
 
 
class TWGctq1 : public ThObservable {
public:
 
    TWGctq1(const StandardModel& SM_i, const double mu_i);
      
    virtual ~TWGctq1();
 
    double computeThValue();
          
private:
    const NPbase * myNPbase;
    const double mu;
 
};
 
 
class TWGctq8 : public ThObservable {
public:
 
    TWGctq8(const StandardModel& SM_i, const double mu_i);
      
    virtual ~TWGctq8();
 
    double computeThValue();
          
private:
    const NPbase * myNPbase;
    const double mu;
 
};
 
 
class TWGctu1 : public ThObservable {
public:
 
    TWGctu1(const StandardModel& SM_i, const double mu_i);
      
    virtual ~TWGctu1();
 
    double computeThValue();
          
private:
    const NPbase * myNPbase;
    const double mu;
 
};
 
 
class TWGctu8 : public ThObservable {
public:
 
    TWGctu8(const StandardModel& SM_i, const double mu_i);
      
    virtual ~TWGctu8();
 
    double computeThValue();
          
private:
    const NPbase * myNPbase;
    const double mu;
 
};
 
 
class TWGctd1 : public ThObservable {
public:
 
    TWGctd1(const StandardModel& SM_i, const double mu_i);
      
    virtual ~TWGctd1();
 
    double computeThValue();
          
private:
    const NPbase * myNPbase;
    const double mu;
 
};
 
 
class TWGctd8 : public ThObservable {
public:
 
    TWGctd8(const StandardModel& SM_i, const double mu_i);
      
    virtual ~TWGctd8();
 
    double computeThValue();
          
private:
    const NPbase * myNPbase;
    const double mu;
 
};
 
 
class TWGctH : public ThObservable {
public:
 
    TWGctH(const StandardModel& SM_i, const double mu_i);
      
    virtual ~TWGctH();
 
    double computeThValue();
          
private:
    const NPbase * myNPbase;
    const double mu;
 
};
 
class TWGcHQm : public ThObservable {
public:
 
    TWGcHQm(const StandardModel& SM_i, const double mu_i);
      
    virtual ~TWGcHQm();
 
    double computeThValue();
          
private:
    const NPbase * myNPbase;
    const double mu;
 
};
 
 
class TWGcHQp : public ThObservable {
public:
 
    TWGcHQp(const StandardModel& SM_i, const double mu_i);
      
    virtual ~TWGcHQp();
 
    double computeThValue();
          
private:
    const NPbase * myNPbase;
    const double mu;
 
};
 
 
class TWGcHQ3 : public ThObservable {
public:
 
    TWGcHQ3(const StandardModel& SM_i, const double mu_i);
      
    virtual ~TWGcHQ3();
 
    double computeThValue();
          
private:
    const NPbase * myNPbase;
    const double mu;
 
};
 
 
class TWGcHt : public ThObservable {
public:
 
    TWGcHt(const StandardModel& SM_i, const double mu_i);
      
    virtual ~TWGcHt();
 
    double computeThValue();
          
private:
    const NPbase * myNPbase;
    const double mu;
 
};
 
 
class TWGcHb : public ThObservable {
public:
 
    TWGcHb(const StandardModel& SM_i, const double mu_i);
      
    virtual ~TWGcHb();
 
    double computeThValue();
          
private:
    const NPbase * myNPbase;
    const double mu;
 
};
 
 
class TWGcHtb : public ThObservable {
public:
 
    TWGcHtb(const StandardModel& SM_i, const double mu_i);
      
    virtual ~TWGcHtb();
 
    double computeThValue();
          
private:
    const NPbase * myNPbase;
    const double mu;
 
};
 
 
class TWGctW : public ThObservable {
public:
 
    TWGctW(const StandardModel& SM_i, const double mu_i);
      
    virtual ~TWGctW();
 
    double computeThValue();
          
private:
    const NPbase * myNPbase;
    const double mu;
 
};
 
 
class TWGImctW : public ThObservable {
public:
 
    TWGImctW(const StandardModel& SM_i, const double mu_i);
      
    virtual ~TWGImctW();
 
    double computeThValue();
          
private:
    const NPbase * myNPbase;
    const double mu;
 
};
 
 
class TWGctZ : public ThObservable {
public:
 
    TWGctZ(const StandardModel& SM_i, const double mu_i);
      
    virtual ~TWGctZ();
 
    double computeThValue();
          
private:
    const NPbase * myNPbase;
    const double mu;
 
};
 
 
class TWGImctZ : public ThObservable {
public:
 
    TWGImctZ(const StandardModel& SM_i, const double mu_i);
      
    virtual ~TWGImctZ();
 
    double computeThValue();
          
private:
    const NPbase * myNPbase;
    const double mu;
 
};
 
 
class TWGctG : public ThObservable {
public:
 
    TWGctG(const StandardModel& SM_i, const double mu_i);
      
    virtual ~TWGctG();
 
    double computeThValue();
          
private:
    const NPbase * myNPbase;
    const double mu;
 
};
 
 
class TWGcbW : public ThObservable {
public:
 
    TWGcbW(const StandardModel& SM_i, const double mu_i);
      
    virtual ~TWGcbW();
 
    double computeThValue();
          
private:
    const NPbase * myNPbase;
    const double mu;
 
};
 
 
class TWGcQlM : public ThObservable {
public:
 
    TWGcQlM(const StandardModel& SM_i, const double mu_i);
      
    virtual ~TWGcQlM();
 
    double computeThValue();
          
private:
    const NPbase * myNPbase;
    const double mu;
 
};
 
 
class TWGcQlP : public ThObservable {
public:
 
    TWGcQlP(const StandardModel& SM_i, const double mu_i);
      
    virtual ~TWGcQlP();
 
    double computeThValue();
          
private:
    const NPbase * myNPbase;
    const double mu;
 
};
 
 
class TWGcQl3 : public ThObservable {
public:
 
    TWGcQl3(const StandardModel& SM_i, const double mu_i);
      
    virtual ~TWGcQl3();
 
    double computeThValue();
          
private:
    const NPbase * myNPbase;
    const double mu;
 
};
 
 
class TWGcQe : public ThObservable {
public:
 
    TWGcQe(const StandardModel& SM_i, const double mu_i);
      
    virtual ~TWGcQe();
 
    double computeThValue();
          
private:
    const NPbase * myNPbase;
    const double mu;
 
};
 
 
class TWGctl : public ThObservable {
public:
 
    TWGctl(const StandardModel& SM_i, const double mu_i);
      
    virtual ~TWGctl();
 
    double computeThValue();
          
private:
    const NPbase * myNPbase;
    const double mu;
 
};
 
 
class TWGcte : public ThObservable {
public:
 
    TWGcte(const StandardModel& SM_i, const double mu_i);
      
    virtual ~TWGcte();
 
    double computeThValue();
          
private:
    const NPbase * myNPbase;
    const double mu;
 
};
 
 
class TWGctlS : public ThObservable {
public:
 
    TWGctlS(const StandardModel& SM_i, const double mu_i);
      
    virtual ~TWGctlS();
 
    double computeThValue();
          
private:
    const NPbase * myNPbase;
    const double mu;
 
};
 
class TWGctlT : public ThObservable {
public:
 
    TWGctlT(const StandardModel& SM_i, const double mu_i);
      
    virtual ~TWGctlT();
 
    double computeThValue();
          
private:
    const NPbase * myNPbase;
    const double mu;
 
};
 
 
#endif  /* NPCOUPLINGS_H */