unitarity.h

Go to the documentation of this file.

/* 
 * Copyright (C) 2015 HEPfit Collaboration
 * All rights reserved.
 *
 * For the licensing terms see doc/COPYING.
 */
 
#ifndef UNITARITY_H
#define UNITARITY_H
 
#include "ThObservable.h"
 
class THDM;
class THDMcache;
 
class unitarity : public ThObservable {
public:
   unitarity(const StandardModel& SM_i);
     
    double computeThValue();
 
    const THDM * myTHDM;
    
};
 
class unitarity1: public unitarity {
public:
 
    unitarity1(const StandardModel& SM_i);
 
    double computeThValue();
};
 
class unitarity2: public unitarity {
public:
 
    unitarity2(const StandardModel& SM_i);
 
    double computeThValue();
};
 
class unitarity3: public unitarity {
public:
 
    unitarity3(const StandardModel& SM_i);
 
    double computeThValue();
};
 
class unitarity4: public unitarity {
public:
 
    unitarity4(const StandardModel& SM_i);
 
    double computeThValue();
};
 
class unitarity5: public unitarity {
public:
 
    unitarity5(const StandardModel& SM_i);
 
    double computeThValue();
};
 
class unitarity6: public unitarity {
public:
 
    unitarity6(const StandardModel& SM_i);
 
    double computeThValue();
};
 
class unitarity7: public unitarity {
public:
 
    unitarity7(const StandardModel& SM_i);
 
    double computeThValue();
};
 
class unitarity8: public unitarity {
public:
 
    unitarity8(const StandardModel& SM_i);
 
    double computeThValue();
};
 
class unitarity9: public unitarity {
public:
 
    unitarity9(const StandardModel& SM_i);
 
    double computeThValue();
};
 
class unitarity10: public unitarity {
public:
 
    unitarity10(const StandardModel& SM_i);
 
    double computeThValue();
};
 
class unitarity11: public unitarity {
public:
 
    unitarity11(const StandardModel& SM_i);
 
    double computeThValue();
};
 
class unitarity12: public unitarity {
public:
 
    unitarity12(const StandardModel& SM_i);
 
    double computeThValue();
};
 
class unitarityNLO1: public ThObservable {
public:
 
    unitarityNLO1(const StandardModel& SM_i);
 
    double computeThValue();
private:
    const THDM& myTHDM;
};
 
class unitarityNLO2: public ThObservable {
public:
 
    unitarityNLO2(const StandardModel& SM_i);
 
    double computeThValue();
private:
    const THDM& myTHDM;
};
 
class unitarityNLO3: public ThObservable {
public:
 
    unitarityNLO3(const StandardModel& SM_i);
 
    double computeThValue();
private:
    const THDM& myTHDM;
};
 
class unitarityNLO4: public ThObservable {
public:
 
    unitarityNLO4(const StandardModel& SM_i);
 
    double computeThValue();
private:
    const THDM& myTHDM;
};
 
class unitarityNLO5: public ThObservable {
public:
 
    unitarityNLO5(const StandardModel& SM_i);
 
    double computeThValue();
private:
    const THDM& myTHDM;
};
 
class unitarityNLO6: public ThObservable {
public:
 
    unitarityNLO6(const StandardModel& SM_i);
 
    double computeThValue();
private:
    const THDM& myTHDM;
};
 
class unitarityNLO7: public ThObservable {
public:
 
    unitarityNLO7(const StandardModel& SM_i);
 
    double computeThValue();
private:
    const THDM& myTHDM;
};
 
class unitarityNLO8: public ThObservable {
public:
 
    unitarityNLO8(const StandardModel& SM_i);
 
    double computeThValue();
private:
    const THDM& myTHDM;
};
 
class unitarityNLO9: public ThObservable {
public:
 
    unitarityNLO9(const StandardModel& SM_i);
 
    double computeThValue();
private:
    const THDM& myTHDM;
};
 
class unitarityNLO10: public ThObservable {
public:
 
    unitarityNLO10(const StandardModel& SM_i);
 
    double computeThValue();
private:
    const THDM& myTHDM;
};
 
class unitarityNLO11: public ThObservable {
public:
 
    unitarityNLO11(const StandardModel& SM_i);
 
    double computeThValue();
private:
    const THDM& myTHDM;
};
 
class unitarityNLO12: public ThObservable {
public:
 
    unitarityNLO12(const StandardModel& SM_i);
 
    double computeThValue();
private:
    const THDM& myTHDM;
};
 
class unitarityNLO13: public ThObservable {
public:
 
    unitarityNLO13(const StandardModel& SM_i);
 
    double computeThValue();
private:
    const THDM& myTHDM;
};
 
class unitarityNLO14: public ThObservable {
public:
 
    unitarityNLO14(const StandardModel& SM_i);
 
    double computeThValue();
private:
    const THDM& myTHDM;
};
 
class unitarityNLO15: public ThObservable {
public:
 
    unitarityNLO15(const StandardModel& SM_i);
 
    double computeThValue();
private:
    const THDM& myTHDM;
};
 
class unitarityNLO16: public ThObservable {
public:
 
    unitarityNLO16(const StandardModel& SM_i);
 
    double computeThValue();
private:
    const THDM& myTHDM;
};
 
class unitarityNLO17: public ThObservable {
public:
 
    unitarityNLO17(const StandardModel& SM_i);
 
    double computeThValue();
private:
    const THDM& myTHDM;
};
 
class unitarityNLO18: public ThObservable {
public:
 
    unitarityNLO18(const StandardModel& SM_i);
 
    double computeThValue();
private:
    const THDM& myTHDM;
};
 
class unitarityNLO19: public ThObservable {
public:
 
    unitarityNLO19(const StandardModel& SM_i);
 
    double computeThValue();
private:
    const THDM& myTHDM;
};
 
class unitarityNLO20: public ThObservable {
public:
 
    unitarityNLO20(const StandardModel& SM_i);
 
    double computeThValue();
private:
    const THDM& myTHDM;
};
 
class unitarityNLO21: public ThObservable {
public:
 
    unitarityNLO21(const StandardModel& SM_i);
 
    double computeThValue();
private:
    const THDM& myTHDM;
};
 
class unitarityNLO22: public ThObservable {
public:
 
    unitarityNLO22(const StandardModel& SM_i);
 
    double computeThValue();
private:
    const THDM& myTHDM;
};
 
class unitarityNLO23: public ThObservable {
public:
 
    unitarityNLO23(const StandardModel& SM_i);
 
    double computeThValue();
private:
    const THDM& myTHDM;
};
 
class unitarityNLO24: public ThObservable {
public:
 
    unitarityNLO24(const StandardModel& SM_i);
 
    double computeThValue();
private:
    const THDM& myTHDM;
};
 
class unitarityNLO25: public ThObservable {
public:
 
    unitarityNLO25(const StandardModel& SM_i);
 
    double computeThValue();
private:
    const THDM& myTHDM;
};
 
class unitarityNLO26: public ThObservable {
public:
 
    unitarityNLO26(const StandardModel& SM_i);
 
    double computeThValue();
private:
    const THDM& myTHDM;
};
 
class unitarityNLOev1: public ThObservable {
public:
 
    unitarityNLOev1(const StandardModel& SM_i);
 
    double computeThValue();
private:
    const THDM& myTHDM;
};
 
class unitarityNLOev2: public ThObservable {
public:
 
    unitarityNLOev2(const StandardModel& SM_i);
 
    double computeThValue();
private:
    const THDM& myTHDM;
};
 
class unitarityNLOev3: public ThObservable {
public:
 
    unitarityNLOev3(const StandardModel& SM_i);
 
    double computeThValue();
private:
    const THDM& myTHDM;
};
 
class unitarityNLOev4: public ThObservable {
public:
 
    unitarityNLOev4(const StandardModel& SM_i);
 
    double computeThValue();
private:
    const THDM& myTHDM;
};
 
class unitarityNLOev5: public ThObservable {
public:
 
    unitarityNLOev5(const StandardModel& SM_i);
 
    double computeThValue();
private:
    const THDM& myTHDM;
};
 
class unitarityNLOev6: public ThObservable {
public:
 
    unitarityNLOev6(const StandardModel& SM_i);
 
    double computeThValue();
private:
    const THDM& myTHDM;
};
 
class unitarityNLOev7: public ThObservable {
public:
 
    unitarityNLOev7(const StandardModel& SM_i);
 
    double computeThValue();
private:
    const THDM& myTHDM;
};
 
class unitarityNLOev8: public ThObservable {
public:
 
    unitarityNLOev8(const StandardModel& SM_i);
 
    double computeThValue();
private:
    const THDM& myTHDM;
};
 
class unitarityNLOev9: public ThObservable {
public:
 
    unitarityNLOev9(const StandardModel& SM_i);
 
    double computeThValue();
private:
    const THDM& myTHDM;
};
 
class unitarityNLOev10: public ThObservable {
public:
 
    unitarityNLOev10(const StandardModel& SM_i);
 
    double computeThValue();
private:
    const THDM& myTHDM;
};
 
class unitarityNLOev11: public ThObservable {
public:
 
    unitarityNLOev11(const StandardModel& SM_i);
 
    double computeThValue();
private:
    const THDM& myTHDM;
};
 
class unitarityNLOev12: public ThObservable {
public:
 
    unitarityNLOev12(const StandardModel& SM_i);
 
    double computeThValue();
private:
    const THDM& myTHDM;
};
 
class unitarityNLOev13: public ThObservable {
public:
 
    unitarityNLOev13(const StandardModel& SM_i);
 
    double computeThValue();
private:
    const THDM& myTHDM;
};
 
class unitarityNLOev14: public ThObservable {
public:
 
    unitarityNLOev14(const StandardModel& SM_i);
 
    double computeThValue();
private:
    const THDM& myTHDM;
};
 
class unitarityNLOev15: public ThObservable {
public:
 
    unitarityNLOev15(const StandardModel& SM_i);
 
    double computeThValue();
private:
    const THDM& myTHDM;
};
 
class unitarityNLOev16: public ThObservable {
public:
 
    unitarityNLOev16(const StandardModel& SM_i);
 
    double computeThValue();
private:
    const THDM& myTHDM;
};
 
class unitarityNLOev17: public ThObservable {
public:
 
    unitarityNLOev17(const StandardModel& SM_i);
 
    double computeThValue();
private:
    const THDM& myTHDM;
};
 
class unitarityNLOev18: public ThObservable {
public:
 
    unitarityNLOev18(const StandardModel& SM_i);
 
    double computeThValue();
private:
    const THDM& myTHDM;
};
 
class unitarityRp1: public ThObservable {
public:
 
    unitarityRp1(const StandardModel& SM_i);
 
    double computeThValue();
private:
    const THDM& myTHDM;
};
 
class unitarityRp2: public ThObservable {
public:
 
    unitarityRp2(const StandardModel& SM_i);
 
    double computeThValue();
private:
    const THDM& myTHDM;
};
 
class unitarityRp3: public ThObservable {
public:
 
    unitarityRp3(const StandardModel& SM_i);
 
    double computeThValue();
private:
    const THDM& myTHDM;
};
 
class unitarityRp4: public ThObservable {
public:
 
    unitarityRp4(const StandardModel& SM_i);
 
    double computeThValue();
private:
    const THDM& myTHDM;
};
 
class unitarityRp5: public ThObservable {
public:
 
    unitarityRp5(const StandardModel& SM_i);
 
    double computeThValue();
private:
    const THDM& myTHDM;
};
 
class unitarityRp6: public ThObservable {
public:
 
    unitarityRp6(const StandardModel& SM_i);
 
    double computeThValue();
private:
    const THDM& myTHDM;
};
 
class unitarityRp7: public ThObservable {
public:
 
    unitarityRp7(const StandardModel& SM_i);
 
    double computeThValue();
private:
    const THDM& myTHDM;
};
 
class unitarityRp8: public ThObservable {
public:
 
    unitarityRp8(const StandardModel& SM_i);
 
    double computeThValue();
private:
    const THDM& myTHDM;
};
 
class unitarityRp9: public ThObservable {
public:
 
    unitarityRp9(const StandardModel& SM_i);
 
    double computeThValue();
private:
    const THDM& myTHDM;
};
 
class unitarityRp10: public ThObservable {
public:
 
    unitarityRp10(const StandardModel& SM_i);
 
    double computeThValue();
private:
    const THDM& myTHDM;
};
 
class unitarityRp11: public ThObservable {
public:
 
    unitarityRp11(const StandardModel& SM_i);
 
    double computeThValue();
private:
    const THDM& myTHDM;
};
 
class unitarityRp12: public ThObservable {
public:
 
    unitarityRp12(const StandardModel& SM_i);
 
    double computeThValue();
private:
    const THDM& myTHDM;
};
 
class unitarityRp13: public ThObservable {
public:
 
    unitarityRp13(const StandardModel& SM_i);
 
    double computeThValue();
private:
    const THDM& myTHDM;
};
 
class unitarityRp14: public ThObservable {
public:
 
    unitarityRp14(const StandardModel& SM_i);
 
    double computeThValue();
private:
    const THDM& myTHDM;
};
 
class unitarityRp15: public ThObservable {
public:
 
    unitarityRp15(const StandardModel& SM_i);
 
    double computeThValue();
private:
    const THDM& myTHDM;
};
 
class unitarityRp16: public ThObservable {
public:
 
    unitarityRp16(const StandardModel& SM_i);
 
    double computeThValue();
private:
    const THDM& myTHDM;
};
 
class unitarityRp17: public ThObservable {
public:
 
    unitarityRp17(const StandardModel& SM_i);
 
    double computeThValue();
private:
    const THDM& myTHDM;
};
 
class unitarityRp18: public ThObservable {
public:
 
    unitarityRp18(const StandardModel& SM_i);
 
    double computeThValue();
private:
    const THDM& myTHDM;
};
 
class unitarityRp19: public ThObservable {
public:
 
    unitarityRp19(const StandardModel& SM_i);
 
    double computeThValue();
private:
    const THDM& myTHDM;
};
 
class unitarityRp20: public ThObservable {
public:
 
    unitarityRp20(const StandardModel& SM_i);
 
    double computeThValue();
private:
    const THDM& myTHDM;
};
 
class unitarityR1: public ThObservable {
public:
 
    unitarityR1(const StandardModel& SM_i);
 
    double computeThValue();
private:
    const THDM& myTHDM;
};
 
class unitarityR2: public ThObservable {
public:
 
    unitarityR2(const StandardModel& SM_i);
 
    double computeThValue();
private:
    const THDM& myTHDM;
};
 
class unitarityR3: public ThObservable {
public:
 
    unitarityR3(const StandardModel& SM_i);
 
    double computeThValue();
private:
    const THDM& myTHDM;
};
 
class unitarityR4: public ThObservable {
public:
 
    unitarityR4(const StandardModel& SM_i);
 
    double computeThValue();
private:
    const THDM& myTHDM;
};
 
class unitarityR5: public ThObservable {
public:
 
    unitarityR5(const StandardModel& SM_i);
 
    double computeThValue();
private:
    const THDM& myTHDM;
};
 
class unitarityR6: public ThObservable {
public:
 
    unitarityR6(const StandardModel& SM_i);
 
    double computeThValue();
private:
    const THDM& myTHDM;
};
 
class unitarityR7: public ThObservable {
public:
 
    unitarityR7(const StandardModel& SM_i);
 
    double computeThValue();
private:
    const THDM& myTHDM;
};
 
class unitarityR8: public ThObservable {
public:
 
    unitarityR8(const StandardModel& SM_i);
 
    double computeThValue();
private:
    const THDM& myTHDM;
};
 
class unitarityR9: public ThObservable {
public:
 
    unitarityR9(const StandardModel& SM_i);
 
    double computeThValue();
private:
    const THDM& myTHDM;
};
 
class unitarityR10: public ThObservable {
public:
 
    unitarityR10(const StandardModel& SM_i);
 
    double computeThValue();
private:
    const THDM& myTHDM;
};
 
class unitarityR11: public ThObservable {
public:
 
    unitarityR11(const StandardModel& SM_i);
 
    double computeThValue();
private:
    const THDM& myTHDM;
};
 
class unitarityR12: public ThObservable {
public:
 
    unitarityR12(const StandardModel& SM_i);
 
    double computeThValue();
private:
    const THDM& myTHDM;
};
 
class unitarityR13: public ThObservable {
public:
 
    unitarityR13(const StandardModel& SM_i);
 
    double computeThValue();
private:
    const THDM& myTHDM;
};
 
class unitarityR14: public ThObservable {
public:
 
    unitarityR14(const StandardModel& SM_i);
 
    double computeThValue();
private:
    const THDM& myTHDM;
};
 
class unitarityR15: public ThObservable {
public:
 
    unitarityR15(const StandardModel& SM_i);
 
    double computeThValue();
private:
    const THDM& myTHDM;
};
 
class unitarityR16: public ThObservable {
public:
 
    unitarityR16(const StandardModel& SM_i);
 
    double computeThValue();
private:
    const THDM& myTHDM;
};
 
class unitarityR17: public ThObservable {
public:
 
    unitarityR17(const StandardModel& SM_i);
 
    double computeThValue();
private:
    const THDM& myTHDM;
};
 
class unitarityR18: public ThObservable {
public:
 
    unitarityR18(const StandardModel& SM_i);
 
    double computeThValue();
private:
    const THDM& myTHDM;
};
 
class unitarityR19: public ThObservable {
public:
 
    unitarityR19(const StandardModel& SM_i);
 
    double computeThValue();
private:
    const THDM& myTHDM;
};
 
class unitarityR20: public ThObservable {
public:
 
    unitarityR20(const StandardModel& SM_i);
 
    double computeThValue();
private:
    const THDM& myTHDM;
};
 
class unitaritya00evenpRe: public ThObservable {
public:
 
    unitaritya00evenpRe(const StandardModel& SM_i);
 
    double computeThValue();
private:
    const THDM& myTHDM;
};
 
class unitaritya00evenpIm: public ThObservable {
public:
 
    unitaritya00evenpIm(const StandardModel& SM_i);
 
    double computeThValue();
private:
    const THDM& myTHDM;
};
 
class unitaritya00evenmRe: public ThObservable {
public:
 
    unitaritya00evenmRe(const StandardModel& SM_i);
 
    double computeThValue();
private:
    const THDM& myTHDM;
};
 
class unitaritya00evenmIm: public ThObservable {
public:
 
    unitaritya00evenmIm(const StandardModel& SM_i);
 
    double computeThValue();
private:
    const THDM& myTHDM;
};
 
class unitaritya00oddpRe: public ThObservable {
public:
 
    unitaritya00oddpRe(const StandardModel& SM_i);
 
    double computeThValue();
private:
    const THDM& myTHDM;
};
 
class unitaritya00oddpIm: public ThObservable {
public:
 
    unitaritya00oddpIm(const StandardModel& SM_i);
 
    double computeThValue();
private:
    const THDM& myTHDM;
};
 
class unitaritya00oddmRe: public ThObservable {
public:
 
    unitaritya00oddmRe(const StandardModel& SM_i);
 
    double computeThValue();
private:
    const THDM& myTHDM;
};
 
class unitaritya00oddmIm: public ThObservable {
public:
 
    unitaritya00oddmIm(const StandardModel& SM_i);
 
    double computeThValue();
private:
    const THDM& myTHDM;
};
 
class unitaritya01evenpRe: public ThObservable {
public:
 
    unitaritya01evenpRe(const StandardModel& SM_i);
 
    double computeThValue();
private:
    const THDM& myTHDM;
};
 
class unitaritya01evenpIm: public ThObservable {
public:
 
    unitaritya01evenpIm(const StandardModel& SM_i);
 
    double computeThValue();
private:
    const THDM& myTHDM;
};
 
class unitaritya01evenmRe: public ThObservable {
public:
 
    unitaritya01evenmRe(const StandardModel& SM_i);
 
    double computeThValue();
private:
    const THDM& myTHDM;
};
 
class unitaritya01evenmIm: public ThObservable {
public:
 
    unitaritya01evenmIm(const StandardModel& SM_i);
 
    double computeThValue();
private:
    const THDM& myTHDM;
};
 
class unitaritya01oddpRe: public ThObservable {
public:
 
    unitaritya01oddpRe(const StandardModel& SM_i);
 
    double computeThValue();
private:
    const THDM& myTHDM;
};
 
class unitaritya01oddpIm: public ThObservable {
public:
 
    unitaritya01oddpIm(const StandardModel& SM_i);
 
    double computeThValue();
private:
    const THDM& myTHDM;
};
 
class unitaritya01oddmRe: public ThObservable {
public:
 
    unitaritya01oddmRe(const StandardModel& SM_i);
 
    double computeThValue();
private:
    const THDM& myTHDM;
};
 
class unitaritya01oddmIm: public ThObservable {
public:
 
    unitaritya01oddmIm(const StandardModel& SM_i);
 
    double computeThValue();
private:
    const THDM& myTHDM;
};
 
class unitaritya10oddRe: public ThObservable {
public:
 
    unitaritya10oddRe(const StandardModel& SM_i);
 
    double computeThValue();
private:
    const THDM& myTHDM;
};
 
class unitaritya10oddIm: public ThObservable {
public:
 
    unitaritya10oddIm(const StandardModel& SM_i);
 
    double computeThValue();
private:
    const THDM& myTHDM;
};
 
class unitaritya11evenpRe: public ThObservable {
public:
 
    unitaritya11evenpRe(const StandardModel& SM_i);
 
    double computeThValue();
private:
    const THDM& myTHDM;
};
 
class unitaritya11evenpIm: public ThObservable {
public:
 
    unitaritya11evenpIm(const StandardModel& SM_i);
 
    double computeThValue();
private:
    const THDM& myTHDM;
};
 
class unitaritya11evenmRe: public ThObservable {
public:
 
    unitaritya11evenmRe(const StandardModel& SM_i);
 
    double computeThValue();
private:
    const THDM& myTHDM;
};
 
class unitaritya11evenmIm: public ThObservable {
public:
 
    unitaritya11evenmIm(const StandardModel& SM_i);
 
    double computeThValue();
private:
    const THDM& myTHDM;
};
 
class unitaritya11oddRe: public ThObservable {
public:
 
    unitaritya11oddRe(const StandardModel& SM_i);
 
    double computeThValue();
private:
    const THDM& myTHDM;
};
 
class unitaritya11oddIm: public ThObservable {
public:
 
    unitaritya11oddIm(const StandardModel& SM_i);
 
    double computeThValue();
private:
    const THDM& myTHDM;
};
 
#endif  /* UNITARITY_H */