HiggsThObservables.h

Go to the documentation of this file.

/*
 * Copyright (C) 2014 HEPfit Collaboration
 * All rights reserved.
 *
 * For the licensing terms see doc/COPYING.
 */

#ifndef HIGGSTHOBSERVABLES_H
#define HIGGSTHOBSERVABLES_H

#include "ThObservable.h"
#include "NPbase.h"

class muggH : public ThObservable {
public:

    muggH(const StandardModel& SM_i, const double sqrt_s_i)
    : ThObservable(SM_i), sqrt_s(sqrt_s_i)
    {
        if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
            throw std::runtime_error("muggH called with a class whose parent is not NPbase");
    }

    double computeThValue()
    {
        return myNPbase->muggH(sqrt_s);
    }

private:
    const NPbase* myNPbase;
    const double sqrt_s;
};

class muVBF : public ThObservable {
public:

    muVBF(const StandardModel& SM_i, const double sqrt_s_i)
    : ThObservable(SM_i), sqrt_s(sqrt_s_i)
    {
        if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
            throw std::runtime_error("muVBF called with a class whose parent is not NPbase");

    }

    double computeThValue()
    {
        return myNPbase->muVBF(sqrt_s);
    }

private:
    const NPbase* myNPbase;
    const double sqrt_s;
};

class muWH : public ThObservable {
public:

    muWH(const StandardModel& SM_i, const double sqrt_s_i)
    : ThObservable(SM_i), sqrt_s(sqrt_s_i)
    {
        if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
            throw std::runtime_error("muWH called with a class whose parent is not NPbase");
    }

    double computeThValue()
    {
        return myNPbase->muWH(sqrt_s);
    }

private:
    const NPbase* myNPbase;
    const double sqrt_s;
};

class muZH : public ThObservable {
public:

    muZH(const StandardModel& SM_i, const double sqrt_s_i)
    : ThObservable(SM_i), sqrt_s(sqrt_s_i)
    {
        if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
            throw std::runtime_error("muZH called with a class whose parent is not NPbase");
    }

    double computeThValue()
    {
        return myNPbase->muZH(sqrt_s);
    }

private:
    const NPbase* myNPbase;
    const double sqrt_s;
};

class mueeZH : public ThObservable {
public:

    mueeZH(const StandardModel& SM_i, const double sqrt_s_i)
    : ThObservable(SM_i), sqrt_s(sqrt_s_i)
    {
        if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
            throw std::runtime_error("mueeZH called with a class whose parent is not NPbase");
    }

    double computeThValue()
    {
        return myNPbase->mueeZH(sqrt_s);
    }

private:
    const NPbase* myNPbase;
    const double sqrt_s;
};

class muVH : public ThObservable {
public:

    muVH(const StandardModel& SM_i, const double sqrt_s_i)
    : ThObservable(SM_i), sqrt_s(sqrt_s_i)
    {
        if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
            throw std::runtime_error("muVH called with a class whose parent is not NPbase");
    }

    double computeThValue()
    {
        return myNPbase->muVH(sqrt_s);
    }

private:
    const NPbase* myNPbase;
    const double sqrt_s;
};

class muVBFpVH : public ThObservable {
public:

    muVBFpVH(const StandardModel& SM_i, const double sqrt_s_i)
    : ThObservable(SM_i), sqrt_s(sqrt_s_i)
    {
        if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
            throw std::runtime_error("muVBFpVH called with a class whose parent is not NPbase");
    }

    double computeThValue()
    {
        return myNPbase->muVBFpVH(sqrt_s);
    }

private:
    const NPbase* myNPbase;
    const double sqrt_s;
};

class muttH : public ThObservable {
public:

    muttH(const StandardModel& SM_i, const double sqrt_s_i)
    : ThObservable(SM_i), sqrt_s(sqrt_s_i)
    {
        if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
            throw std::runtime_error("muttH called with a class whose parent is not NPbase");
    }

    double computeThValue()
    {
        return myNPbase->muttH(sqrt_s);
    }

private:
    const NPbase* myNPbase;
    const double sqrt_s;
};

class muggHpttH : public ThObservable {
public:

    muggHpttH(const StandardModel& SM_i, const double sqrt_s_i)
    : ThObservable(SM_i), sqrt_s(sqrt_s_i)
    {
        if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
            throw std::runtime_error("muggHpttH called with a class whose parent is not NPbase");
    }

    double computeThValue()
    {
        return myNPbase->muggHpttH(sqrt_s);
    }

private:
    const NPbase* myNPbase;
    const double sqrt_s;
};

class BrHtoggRatio : public ThObservable {
public:

    BrHtoggRatio(const StandardModel& SM_i)
    : ThObservable(SM_i)
    {
        if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
            throw std::runtime_error("BrHtoggRatio called with a class whose parent is not NPbase");
    }

    double computeThValue()
    {
        return myNPbase->BrHggRatio();
    }

private:
    const NPbase* myNPbase;
};

class BrHtoWWRatio : public ThObservable {
public:

    BrHtoWWRatio(const StandardModel& SM_i)
    : ThObservable(SM_i)
    {
        if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
            throw std::runtime_error("BrHtoWWRatio called with a class whose parent is not NPbase");
    }

    double computeThValue()
    {
        return myNPbase->BrHWWRatio();
    }

private:
    const NPbase* myNPbase;
};

class BrHtoZZRatio : public ThObservable {
public:

    BrHtoZZRatio(const StandardModel& SM_i)
    : ThObservable(SM_i)
    {
        if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
            throw std::runtime_error("BrHtoZZRatio called with a class whose parent is not NPbase");
    }

    double computeThValue()
    {
        return myNPbase->BrHZZRatio();
    }

private:
    const NPbase* myNPbase;
};

class BrHtoZgaRatio : public ThObservable {
public:

    BrHtoZgaRatio(const StandardModel& SM_i) : ThObservable(SM_i)
    {
        if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
            throw std::runtime_error("BrHtoZgaRatio called with a class whose parent is not NPbase");
    }

    double computeThValue()
    {
        return myNPbase->BrHZgaRatio();
    }

private:
    const NPbase* myNPbase;
};

class BrHtogagaRatio : public ThObservable {
public:

    BrHtogagaRatio(const StandardModel& SM_i) : ThObservable(SM_i)
    {
        if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
            throw std::runtime_error("BrHtogagaRatio called with a class whose parent is not NPbase");
    }

    double computeThValue()
    {
        return myNPbase->BrHgagaRatio();
    }

private:
    const NPbase* myNPbase;
};

class BrHtotautauRatio : public ThObservable {
public:

    BrHtotautauRatio(const StandardModel& SM_i) : ThObservable(SM_i)
    {
        if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
            throw std::runtime_error("BrHtotautauRatio called with a class whose parent is not NPbase");
    }

    double computeThValue()
    {
        return myNPbase->BrHtautauRatio();
    }

private:
    const NPbase* myNPbase;
};

class BrHtoccRatio : public ThObservable {
public:

    BrHtoccRatio(const StandardModel& SM_i) : ThObservable(SM_i)
    {
        if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
            throw std::runtime_error("BrHtoccRatio called with a class whose parent is not NPbase");
    }

    double computeThValue()
    {
        return myNPbase->BrHccRatio();
    }

private:
    const NPbase* myNPbase;
};

class BrHtobbRatio : public ThObservable {
public:

    BrHtobbRatio(const StandardModel& SM_i) : ThObservable(SM_i)
    {
        if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
            throw std::runtime_error("BrHtobbRatio called with a class whose parent is not NPbase");
    }

    double computeThValue()
    {
        return myNPbase->BrHbbRatio();
    }

private:
    const NPbase* myNPbase;
};

#endif  /* HIGGSTHOBSERVABLES_H */