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);
      
    virtual ~deltagZveveL();
 
    double computeThValue();
      
    const NPbase * myNPbase;
    
private:
 
 
};
 
class deltagZvmuvmuL : public ThObservable {
public:
 
    deltagZvmuvmuL(const StandardModel& SM_i);
      
    virtual ~deltagZvmuvmuL();
 
    double computeThValue();
      
    const NPbase * myNPbase;
    
private:
 
 
};
 
 
class deltagZvtavtaL : public ThObservable {
public:
 
    deltagZvtavtaL(const StandardModel& SM_i);
      
    virtual ~deltagZvtavtaL();
 
    double computeThValue();
      
    const NPbase * myNPbase;
    
private:
 
 
};
 
 
class deltagZeeL : public ThObservable {
public:
 
    deltagZeeL(const StandardModel& SM_i);
      
    virtual ~deltagZeeL();
 
    double computeThValue();
      
    const NPbase * myNPbase;
    
private:
 
 
};
 
class deltagZeeR : public ThObservable {
public:
 
    deltagZeeR(const StandardModel& SM_i);
      
    virtual ~deltagZeeR();
 
    double computeThValue();
      
    const NPbase * myNPbase;
    
private:
 
 
};
 
class deltagZmumuL : public ThObservable {
public:
 
    deltagZmumuL(const StandardModel& SM_i);
      
    virtual ~deltagZmumuL();
 
    double computeThValue();
      
    const NPbase * myNPbase;
    
private:
 
 
};
 
class deltagZmumuR : public ThObservable {
public:
 
    deltagZmumuR(const StandardModel& SM_i);
      
    virtual ~deltagZmumuR();
 
    double computeThValue();
      
    const NPbase * myNPbase;
    
private:
 
 
};
 
class deltagZtataL : public ThObservable {
public:
 
    deltagZtataL(const StandardModel& SM_i);
      
    virtual ~deltagZtataL();
 
    double computeThValue();
      
    const NPbase * myNPbase;
    
private:
 
 
};
 
class deltagZtataR : public ThObservable {
public:
 
    deltagZtataR(const StandardModel& SM_i);
      
    virtual ~deltagZtataR();
 
    double computeThValue();
      
    const NPbase * myNPbase;
    
private:
 
 
};
 
class deltagZuuL : public ThObservable {
public:
 
    deltagZuuL(const StandardModel& SM_i);
      
    virtual ~deltagZuuL();
 
    double computeThValue();
      
    const NPbase * myNPbase;
    
private:
 
 
};
 
class deltagZuuR : public ThObservable {
public:
 
    deltagZuuR(const StandardModel& SM_i);
      
    virtual ~deltagZuuR();
 
    double computeThValue();
      
    const NPbase * myNPbase;
    
private:
 
 
};
 
class deltagZuuV : public ThObservable {
public:
 
    deltagZuuV(const StandardModel& SM_i);
      
    virtual ~deltagZuuV();
 
    double computeThValue();
      
    const NPbase * myNPbase;
    
private:
 
 
};
 
class deltagZuuA : public ThObservable {
public:
 
    deltagZuuA(const StandardModel& SM_i);
      
    virtual ~deltagZuuA();
 
    double computeThValue();
      
    const NPbase * myNPbase;
    
private:
 
 
};
 
class deltagZccL : public ThObservable {
public:
 
    deltagZccL(const StandardModel& SM_i);
      
    virtual ~deltagZccL();
 
    double computeThValue();
      
    const NPbase * myNPbase;
    
private:
 
 
};
 
class deltagZccR : public ThObservable {
public:
 
    deltagZccR(const StandardModel& SM_i);
      
    virtual ~deltagZccR();
 
    double computeThValue();
      
    const NPbase * myNPbase;
    
private:
 
 
};
 
class deltagZttL : public ThObservable {
public:
 
    deltagZttL(const StandardModel& SM_i);
      
    virtual ~deltagZttL();
 
    double computeThValue();
      
    const NPbase * myNPbase;
    
private:
 
 
};
 
class deltagZttR : public ThObservable {
public:
 
    deltagZttR(const StandardModel& SM_i);
      
    virtual ~deltagZttR();
 
    double computeThValue();
      
    const NPbase * myNPbase;
    
private:
 
 
};
 
class deltagZttV : public ThObservable {
public:
 
    deltagZttV(const StandardModel& SM_i);
      
    virtual ~deltagZttV();
 
    double computeThValue();
      
    const NPbase * myNPbase;
    
private:
 
 
};
 
class deltagZttA : public ThObservable {
public:
 
    deltagZttA(const StandardModel& SM_i);
      
    virtual ~deltagZttA();
 
    double computeThValue();
      
    const NPbase * myNPbase;
    
private:
 
 
};
 
 
class deltagZddL : public ThObservable {
public:
 
    deltagZddL(const StandardModel& SM_i);
      
    virtual ~deltagZddL();
 
    double computeThValue();
      
    const NPbase * myNPbase;
    
private:
 
 
};
 
class deltagZddR : public ThObservable {
public:
 
    deltagZddR(const StandardModel& SM_i);
      
    virtual ~deltagZddR();
 
    double computeThValue();
      
    const NPbase * myNPbase;
    
private:
 
 
};
 
class deltagZddV : public ThObservable {
public:
 
    deltagZddV(const StandardModel& SM_i);
      
    virtual ~deltagZddV();
 
    double computeThValue();
      
    const NPbase * myNPbase;
    
private:
 
 
};
 
class deltagZddA : public ThObservable {
public:
 
    deltagZddA(const StandardModel& SM_i);
      
    virtual ~deltagZddA();
 
    double computeThValue();
      
    const NPbase * myNPbase;
    
private:
 
 
};
 
class deltagZssL : public ThObservable {
public:
 
    deltagZssL(const StandardModel& SM_i);
      
    virtual ~deltagZssL();
 
    double computeThValue();
      
    const NPbase * myNPbase;
    
private:
 
 
};
 
class deltagZssR : public ThObservable {
public:
 
    deltagZssR(const StandardModel& SM_i);
      
    virtual ~deltagZssR();
 
    double computeThValue();
      
    const NPbase * myNPbase;
    
private:
 
 
};
 
class deltagZbbL : public ThObservable {
public:
 
    deltagZbbL(const StandardModel& SM_i);
      
    virtual ~deltagZbbL();
 
    double computeThValue();
      
    const NPbase * myNPbase;
    
private:
 
 
};
 
class deltagZbbR : public ThObservable {
public:
 
    deltagZbbR(const StandardModel& SM_i);
      
    virtual ~deltagZbbR();
 
    double computeThValue();
      
    const NPbase * myNPbase;
    
private:
 
 
};
 
//-----  Wff couplings observables  ----------
 
class deltaUWeve : public ThObservable {
public:
 
    deltaUWeve(const StandardModel& SM_i);
      
    virtual ~deltaUWeve();
 
    double computeThValue();
      
    const NPbase * myNPbase;
    
private:
 
 
};
 
class deltaUWmuvmu : public ThObservable {
public:
 
    deltaUWmuvmu(const StandardModel& SM_i);
      
    virtual ~deltaUWmuvmu();
 
    double computeThValue();
      
    const NPbase * myNPbase;
    
private:
 
 
};
 
class deltaUWtavta : public ThObservable {
public:
 
    deltaUWtavta(const StandardModel& SM_i);
      
    virtual ~deltaUWtavta();
 
    double computeThValue();
      
    const NPbase * myNPbase;
    
private:
 
 
};
 
class deltaVudL : public ThObservable {
public:
 
    deltaVudL(const StandardModel& SM_i);
      
    virtual ~deltaVudL();
 
    double computeThValue();
      
    const NPbase * myNPbase;
    
private:
 
 
};
 
class deltaVudR : public ThObservable {
public:
 
    deltaVudR(const StandardModel& SM_i);
      
    virtual ~deltaVudR();
 
    double computeThValue();
      
    const NPbase * myNPbase;
    
private:
 
 
};
 
class deltaVcsL : public ThObservable {
public:
 
    deltaVcsL(const StandardModel& SM_i);
      
    virtual ~deltaVcsL();
 
    double computeThValue();
      
    const NPbase * myNPbase;
    
private:
 
 
};
 
class deltaVcsR : public ThObservable {
public:
 
    deltaVcsR(const StandardModel& SM_i);
      
    virtual ~deltaVcsR();
 
    double computeThValue();
      
    const NPbase * myNPbase;
    
private:
 
 
};
 
class deltaVtbL : public ThObservable {
public:
 
    deltaVtbL(const StandardModel& SM_i);
      
    virtual ~deltaVtbL();
 
    double computeThValue();
      
    const NPbase * myNPbase;
    
private:
 
 
};
 
class deltaVtbR : public ThObservable {
public:
 
    deltaVtbR(const StandardModel& SM_i);
      
    virtual ~deltaVtbR();
 
    double computeThValue();
      
    const NPbase * myNPbase;
    
private:
 
 
};
 
 
//-----  Hff couplings observables  ----------
 
class deltagHee : public ThObservable {
public:
 
    deltagHee(const StandardModel& SM_i);
      
    virtual ~deltagHee();
 
    double computeThValue();
      
    const NPbase * myNPbase;
    
private:
 
 
};
 
class deltagHmumu : public ThObservable {
public:
 
    deltagHmumu(const StandardModel& SM_i);
      
    virtual ~deltagHmumu();
 
    double computeThValue();
      
    const NPbase * myNPbase;
    
private:
 
 
};
 
class gHmumueff : public ThObservable {
public:
 
    gHmumueff(const StandardModel& SM_i);
      
    virtual ~gHmumueff();
 
    double computeThValue();
      
    const NPbase * myNPbase;
    
private:
 
 
};
 
class deltagHtata : public ThObservable {
public:
 
    deltagHtata(const StandardModel& SM_i);
      
    virtual ~deltagHtata();
 
    double computeThValue();
      
    const NPbase * myNPbase;
    
private:
 
 
};
 
class gHtataeff : public ThObservable {
public:
 
    gHtataeff(const StandardModel& SM_i);
      
    virtual ~gHtataeff();
 
    double computeThValue();
      
    const NPbase * myNPbase;
    
private:
 
 
};
 
 
class deltagHuu : public ThObservable {
public:
 
    deltagHuu(const StandardModel& SM_i);
      
    virtual ~deltagHuu();
 
    double computeThValue();
      
    const NPbase * myNPbase;
    
private:
 
 
};
 
 
class deltagHcc : public ThObservable {
public:
 
    deltagHcc(const StandardModel& SM_i);
      
    virtual ~deltagHcc();
 
    double computeThValue();
      
    const NPbase * myNPbase;
    
private:
 
 
};
 
class gHcceff : public ThObservable {
public:
 
    gHcceff(const StandardModel& SM_i);
      
    virtual ~gHcceff();
 
    double computeThValue();
      
    const NPbase * myNPbase;
    
private:
 
 
};
 
class deltagHtt : public ThObservable {
public:
 
    deltagHtt(const StandardModel& SM_i);
      
    virtual ~deltagHtt();
 
    double computeThValue();
      
    const NPbase * myNPbase;
    
private:
 
 
};
 
class deltagHdd : public ThObservable {
public:
 
    deltagHdd(const StandardModel& SM_i);
      
    virtual ~deltagHdd();
 
    double computeThValue();
      
    const NPbase * myNPbase;
    
private:
 
 
};
 
class deltagHss : public ThObservable {
public:
 
    deltagHss(const StandardModel& SM_i);
      
    virtual ~deltagHss();
 
    double computeThValue();
      
    const NPbase * myNPbase;
    
private:
 
 
};
 
 
class deltagHbb : public ThObservable {
public:
 
    deltagHbb(const StandardModel& SM_i);
      
    virtual ~deltagHbb();
 
    double computeThValue();
      
    const NPbase * myNPbase;
    
private:
 
 
};
 
class gHbbeff : public ThObservable {
public:
 
    gHbbeff(const StandardModel& SM_i);
      
    virtual ~gHbbeff();
 
    double computeThValue();
      
    const NPbase * myNPbase;
    
private:
 
 
};
 
//-----  HGG couplings observables  ----------
 
class deltagHGG : public ThObservable {
public:
 
    deltagHGG(const StandardModel& SM_i);
      
    virtual ~deltagHGG();
 
    double computeThValue();
      
    const NPbase * myNPbase;
    
private:
 
 
};
 
class gHGGeff : public ThObservable {
public:
 
    gHGGeff(const StandardModel& SM_i);
      
    virtual ~gHGGeff();
 
    double computeThValue();
      
    const NPbase * myNPbase;
    
private:
 
 
};
 
//-----  HZZ couplings observables  ----------
 
class deltagHZZ : public ThObservable {
public:
 
    deltagHZZ(const StandardModel& SM_i);
      
    virtual ~deltagHZZ();
 
    double computeThValue();
      
    const NPbase * myNPbase;
    
private:
 
 
};
 
class gHZZeff : public ThObservable {
public:
 
    gHZZeff(const StandardModel& SM_i);
      
    virtual ~gHZZeff();
 
    double computeThValue();
      
    const NPbase * myNPbase;
    
private:
 
 
};
 
class gHZZ1 : public ThObservable {
public:
 
    gHZZ1(const StandardModel& SM_i);
      
    virtual ~gHZZ1();
 
    double computeThValue();
      
    const NPbase * myNPbase;
    
private:
 
 
};
 
class gHZZ2 : public ThObservable {
public:
 
    gHZZ2(const StandardModel& SM_i);
      
    virtual ~gHZZ2();
 
    double computeThValue();
      
    const NPbase * myNPbase;
    
private:
 
 
};
 
//-----  HAA couplings observables  ----------
 
class deltagHAA : public ThObservable {
public:
 
    deltagHAA(const StandardModel& SM_i);
      
    virtual ~deltagHAA();
 
    double computeThValue();
      
    const NPbase * myNPbase;
    
private:
 
 
};
 
 
class gHAAeff : public ThObservable {
public:
 
    gHAAeff(const StandardModel& SM_i);
      
    virtual ~gHAAeff();
 
    double computeThValue();
      
    const NPbase * myNPbase;
    
private:
 
 
};
 
//-----  HZA couplings observables  ----------
 
class deltagHZA : public ThObservable {
public:
 
    deltagHZA(const StandardModel& SM_i);
      
    virtual ~deltagHZA();
 
    double computeThValue();
      
    const NPbase * myNPbase;
    
private:
 
 
};
 
class gHZAeff : public ThObservable {
public:
 
    gHZAeff(const StandardModel& SM_i);
      
    virtual ~gHZAeff();
 
    double computeThValue();
      
    const NPbase * myNPbase;
    
private:
 
 
};
 
class gHZA2 : public ThObservable {
public:
 
    gHZA2(const StandardModel& SM_i);
      
    virtual ~gHZA2();
 
    double computeThValue();
      
    const NPbase * myNPbase;
    
private:
 
 
};
 
//-----  HWW couplings observables  ----------
 
class deltagHWW : public ThObservable {
public:
 
    deltagHWW(const StandardModel& SM_i);
      
    virtual ~deltagHWW();
 
    double computeThValue();
      
    const NPbase * myNPbase;
    
private:
 
 
};
 
class gHWWeff : public ThObservable {
public:
 
    gHWWeff(const StandardModel& SM_i);
      
    virtual ~gHWWeff();
 
    double computeThValue();
      
    const NPbase * myNPbase;
    
private:
 
 
};
 
class gHWW1 : public ThObservable {
public:
 
    gHWW1(const StandardModel& SM_i);
      
    virtual ~gHWW1();
 
    double computeThValue();
      
    const NPbase * myNPbase;
    
private:
 
 
};
 
class gHWW2 : public ThObservable {
public:
 
    gHWW2(const StandardModel& SM_i);
      
    virtual ~gHWW2();
 
    double computeThValue();
      
    const NPbase * myNPbase;
    
private:
 
 
};
 
//-----  Other couplings observables  ----------
 
class gHWZeff : public ThObservable {
public:
 
    gHWZeff(const StandardModel& SM_i);
      
    virtual ~gHWZeff();
 
    double computeThValue();
      
    const NPbase * myNPbase;
    
private:
 
 
};
 
class gHbWeff : public ThObservable {
public:
 
    gHbWeff(const StandardModel& SM_i);
      
    virtual ~gHbWeff();
 
    double computeThValue();
      
    const NPbase * myNPbase;
    
private:
 
 
};
 
 
class gHtaWeff : public ThObservable {
public:
 
    gHtaWeff(const StandardModel& SM_i);
      
    virtual ~gHtaWeff();
 
    double computeThValue();
      
    const NPbase * myNPbase;
    
private:
 
 
};
 
//-----  HHH couplings observables  ----------
 
class deltalHHH : public ThObservable {
public:
 
    deltalHHH(const StandardModel& SM_i);
      
    virtual ~deltalHHH();
 
    double computeThValue();
      
    const NPbase * myNPbase;
    
private:
 
 
};
 
//-----  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();
      
    const NPbase * myNPbase;
    
private:
 
 
};
 
 
class deltaKgammaEff : public ThObservable {
public:
 
    deltaKgammaEff(const StandardModel& SM_i);
      
    virtual ~deltaKgammaEff();
 
    double computeThValue();
      
    const NPbase * myNPbase;
    
private:
 
 
};
 
 
//-----  Basic interactions of the so-called Higgs basis  ----------
 
class deltaytHB : public ThObservable {
public:
 
    deltaytHB(const StandardModel& SM_i);
      
    virtual ~deltaytHB();
 
    double computeThValue();
      
    const NPbase * myNPbase;
    
private:
 
 
};
 
class deltaybHB : public ThObservable {
public:
 
    deltaybHB(const StandardModel& SM_i);
      
    virtual ~deltaybHB();
 
    double computeThValue();
      
    const NPbase * myNPbase;
    
private:
 
 
};
 
class deltaytauHB : public ThObservable {
public:
 
    deltaytauHB(const StandardModel& SM_i);
      
    virtual ~deltaytauHB();
 
    double computeThValue();
      
    const NPbase * myNPbase;
    
private:
 
 
};
 
class deltaycHB : public ThObservable {
public:
 
    deltaycHB(const StandardModel& SM_i);
      
    virtual ~deltaycHB();
 
    double computeThValue();
      
    const NPbase * myNPbase;
    
private:
 
 
};
 
 
class deltaymuHB : public ThObservable {
public:
 
    deltaymuHB(const StandardModel& SM_i);
      
    virtual ~deltaymuHB();
 
    double computeThValue();
      
    const NPbase * myNPbase;
    
private:
 
 
};
 
 
class deltacZHB : public ThObservable {
public:
 
    deltacZHB(const StandardModel& SM_i);
      
    virtual ~deltacZHB();
 
    double computeThValue();
      
    const NPbase * myNPbase;
    
private:
 
 
};
 
 
class cZBoxHB : public ThObservable {
public:
 
    cZBoxHB(const StandardModel& SM_i);
      
    virtual ~cZBoxHB();
 
    double computeThValue();
      
    const NPbase * myNPbase;
    
private:
 
 
};
 
 
class cZZHB : public ThObservable {
public:
 
    cZZHB(const StandardModel& SM_i);
      
    virtual ~cZZHB();
 
    double computeThValue();
      
    const NPbase * myNPbase;
    
private:
 
 
};
 
 
class cZgaHB : public ThObservable {
public:
 
    cZgaHB(const StandardModel& SM_i);
      
    virtual ~cZgaHB();
 
    double computeThValue();
      
    const NPbase * myNPbase;
    
private:
 
 
};
 
 
class cgagaHB : public ThObservable {
public:
 
    cgagaHB(const StandardModel& SM_i);
      
    virtual ~cgagaHB();
 
    double computeThValue();
      
    const NPbase * myNPbase;
    
private:
 
 
};
 
 
class cggHB : public ThObservable {
public:
 
    cggHB(const StandardModel& SM_i);
      
    virtual ~cggHB();
 
    double computeThValue();
      
    const NPbase * myNPbase;
    
private:
 
 
};
 
 
class cggEffHB : public ThObservable {
public:
 
    cggEffHB(const StandardModel& SM_i);
      
    virtual ~cggEffHB();
 
    double computeThValue();
      
    const NPbase * myNPbase;
    
private:
 
 
};
 
 
class lambzHB : public ThObservable {
public:
 
    lambzHB(const StandardModel& SM_i);
      
    virtual ~lambzHB();
 
    double computeThValue();
      
    const NPbase * myNPbase;
    
private:
 
 
};
 
 
//-----  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();
      
    const NPbase * myNPbase;
    
private:
 
 
};
 
//-----  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);
      
    virtual ~delgZlL();
 
    double computeThValue();    
    
private:
    const NPbase * myNPbase;
    StandardModel::lepton lepton;
 
};
 
class delgZlR : public ThObservable {
public:
 
    delgZlR(const StandardModel& SM_i, const StandardModel::lepton lepton);
      
    virtual ~delgZlR();
 
    double computeThValue();
    
private:
    const NPbase * myNPbase;
    StandardModel::lepton lepton;
 
};
 
class delgZqL : public ThObservable {
public:
 
    delgZqL(const StandardModel& SM_i, const StandardModel::quark quark);
      
    virtual ~delgZqL();
 
    double computeThValue();    
    
private:
    const NPbase * myNPbase;
    StandardModel::quark quark;
 
};
 
class delgZqR : public ThObservable {
public:
 
    delgZqR(const StandardModel& SM_i, const StandardModel::quark quark);
      
    virtual ~delgZqR();
 
    double computeThValue();
    
private:
    const NPbase * myNPbase;
    StandardModel::quark quark;
 
};
 
 
//-----  Oblique parameters  ----------
 
class oblS : public ThObservable {
public:
 
    oblS(const StandardModel& SM_i);
      
    virtual ~oblS();
 
    double computeThValue();
      
    const NPbase * myNPbase;
    
private:
 
};
 
class oblT : public ThObservable {
public:
 
    oblT(const StandardModel& SM_i);
      
    virtual ~oblT();
 
    double computeThValue();
      
    const NPbase * myNPbase;
    
private:
 
};
 
 
class oblW : public ThObservable {
public:
 
    oblW(const StandardModel& SM_i);
      
    virtual ~oblW();
 
    double computeThValue();
      
    const NPbase * myNPbase;
    
private:
 
};
 
 
class oblY : public ThObservable {
public:
 
    oblY(const StandardModel& SM_i);
      
    virtual ~oblY();
 
    double computeThValue();
      
    const NPbase * myNPbase;
    
private:
 
};
 
 
//-----  Auxiliary observables  ----------
 
class AuxObsNP1 : public ThObservable {
public:
 
    AuxObsNP1(const StandardModel& SM_i);
      
    virtual ~AuxObsNP1();
 
    double computeThValue();
      
    const NPbase * myNPbase;
    
private:
 
};
 
 
class AuxObsNP2 : public ThObservable {
public:
 
    AuxObsNP2(const StandardModel& SM_i);
      
    virtual ~AuxObsNP2();
 
    double computeThValue();
      
    const NPbase * myNPbase;
    
private:
 
};
 
 
class AuxObsNP3 : public ThObservable {
public:
 
    AuxObsNP3(const StandardModel& SM_i);
      
    virtual ~AuxObsNP3();
 
    double computeThValue();
      
    const NPbase * myNPbase;
    
private:
 
};
 
 
class AuxObsNP4 : public ThObservable {
public:
 
    AuxObsNP4(const StandardModel& SM_i);
      
    virtual ~AuxObsNP4();
 
    double computeThValue();
      
    const NPbase * myNPbase;
    
private:
 
};
 
 
class AuxObsNP5 : public ThObservable {
public:
 
    AuxObsNP5(const StandardModel& SM_i);
      
    virtual ~AuxObsNP5();
 
    double computeThValue();
      
    const NPbase * myNPbase;
    
private:
 
};
 
 
class AuxObsNP6 : public ThObservable {
public:
 
    AuxObsNP6(const StandardModel& SM_i);
      
    virtual ~AuxObsNP6();
 
    double computeThValue();
      
    const NPbase * myNPbase;
    
private:
 
};
 
 
class AuxObsNP7 : public ThObservable {
public:
 
    AuxObsNP7(const StandardModel& SM_i);
      
    virtual ~AuxObsNP7();
 
    double computeThValue();
      
    const NPbase * myNPbase;
    
private:
 
};
 
 
class AuxObsNP8 : public ThObservable {
public:
 
    AuxObsNP8(const StandardModel& SM_i);
      
    virtual ~AuxObsNP8();
 
    double computeThValue();
      
    const NPbase * myNPbase;
    
private:
 
};
 
 
class AuxObsNP9 : public ThObservable {
public:
 
    AuxObsNP9(const StandardModel& SM_i);
      
    virtual ~AuxObsNP9();
 
    double computeThValue();
      
    const NPbase * myNPbase;
    
private:
 
};
 
 
class AuxObsNP10 : public ThObservable {
public:
 
    AuxObsNP10(const StandardModel& SM_i);
      
    virtual ~AuxObsNP10();
 
    double computeThValue();
      
    const NPbase * myNPbase;
    
private:
 
};
 
 
class AuxObsNP11 : public ThObservable {
public:
 
    AuxObsNP11(const StandardModel& SM_i);
      
    virtual ~AuxObsNP11();
 
    double computeThValue();
      
    const NPbase * myNPbase;
    
private:
 
};
 
 
class AuxObsNP12 : public ThObservable {
public:
 
    AuxObsNP12(const StandardModel& SM_i);
      
    virtual ~AuxObsNP12();
 
    double computeThValue();
      
    const NPbase * myNPbase;
    
private:
 
};
 
 
 
class AuxObsNP13 : public ThObservable {
public:
 
    AuxObsNP13(const StandardModel& SM_i);
      
    virtual ~AuxObsNP13();
 
    double computeThValue();
      
    const NPbase * myNPbase;
    
private:
 
};
 
 
class AuxObsNP14 : public ThObservable {
public:
 
    AuxObsNP14(const StandardModel& SM_i);
      
    virtual ~AuxObsNP14();
 
    double computeThValue();
      
    const NPbase * myNPbase;
    
private:
 
};
 
 
class AuxObsNP15 : public ThObservable {
public:
 
    AuxObsNP15(const StandardModel& SM_i);
      
    virtual ~AuxObsNP15();
 
    double computeThValue();
      
    const NPbase * myNPbase;
    
private:
 
};
 
 
class AuxObsNP16 : public ThObservable {
public:
 
    AuxObsNP16(const StandardModel& SM_i);
      
    virtual ~AuxObsNP16();
 
    double computeThValue();
      
    const NPbase * myNPbase;
    
private:
 
};
 
 
class AuxObsNP17 : public ThObservable {
public:
 
    AuxObsNP17(const StandardModel& SM_i);
      
    virtual ~AuxObsNP17();
 
    double computeThValue();
      
    const NPbase * myNPbase;
    
private:
 
};
 
 
class AuxObsNP18 : public ThObservable {
public:
 
    AuxObsNP18(const StandardModel& SM_i);
      
    virtual ~AuxObsNP18();
 
    double computeThValue();
      
    const NPbase * myNPbase;
    
private:
 
};
 
 
class AuxObsNP19 : public ThObservable {
public:
 
    AuxObsNP19(const StandardModel& SM_i);
      
    virtual ~AuxObsNP19();
 
    double computeThValue();
      
    const NPbase * myNPbase;
    
private:
 
};
 
 
class AuxObsNP20 : public ThObservable {
public:
 
    AuxObsNP20(const StandardModel& SM_i);
      
    virtual ~AuxObsNP20();
 
    double computeThValue();
      
    const NPbase * myNPbase;
    
private:
 
};
 
 
 
 
#endif  /* NPCOUPLINGS_H */