ee_WW.h

Go to the documentation of this file.

/* 
 * Copyright (C) 2012 HEPfit Collaboration
 *
 *
 * For the licensing terms see doc/COPYING.
 */
 
#ifndef EEWW_H
#define EEWW_H
 
#include <stdexcept>
#include <ThObservable.h>
#include "NPbase.h"
 
 
class xseeWW : public ThObservable {
public:
 
    xseeWW(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("xseeWW called with a class whose parent is not NPbase");
    }
 
    double computeThValue()
    {
        return myNPbase->xseeWW(sqrt_s);
    }
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class dxseeWWdcosBin : public ThObservable {
public:
 
    dxseeWWdcosBin(const StandardModel& SM_i, const double sqrt_s_i, const double cos1_i, const double cos2_i)
    : ThObservable(SM_i), sqrt_s(sqrt_s_i), cos1(cos1_i), cos2(cos2_i)
    {
        if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
            throw std::runtime_error("dxseeWWdcosBin called with a class whose parent is not NPbase");
    }
 
    double computeThValue()
    {
        return myNPbase->dxseeWWdcosBin(sqrt_s, cos1, cos2);
    }
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
    const double cos1, cos2;
};
 
 
class xseeWWlept : public ThObservable {
public:
 
    xseeWWlept(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("xseeWWlept called with a class whose parent is not NPbase");
    }
 
    double computeThValue()
    {
        return myNPbase->xseeWWleptLEP2(sqrt_s);
    }
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class deltaxseeWWlept : public ThObservable {
public:
 
    deltaxseeWWlept(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("deltaxseeWWlept called with a class whose parent is not NPbase");
    }
 
    double computeThValue()
    {
        return myNPbase->deltaxseeWWleptLEP2(sqrt_s);
    }
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class xseeWWsemil : public ThObservable {
public:
 
    xseeWWsemil(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("xseeWWsemil called with a class whose parent is not NPbase");
    }
 
    double computeThValue()
    {
        return myNPbase->xseeWWsemilLEP2(sqrt_s);
    }
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class deltaxseeWWsemil : public ThObservable {
public:
 
    deltaxseeWWsemil(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("deltaxseeWWsemil called with a class whose parent is not NPbase");
    }
 
    double computeThValue()
    {
        return myNPbase->deltaxseeWWsemilLEP2(sqrt_s);
    }
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class xseeWWhad : public ThObservable {
public:
 
    xseeWWhad(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("xseeWWhad called with a class whose parent is not NPbase");
    }
 
    double computeThValue()
    {
        return myNPbase->xseeWWhadLEP2(sqrt_s);
    }
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class deltaxseeWWhad : public ThObservable {
public:
 
    deltaxseeWWhad(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("deltaxseeWWhad called with a class whose parent is not NPbase");
    }
 
    double computeThValue()
    {
        return myNPbase->deltaxseeWWhadLEP2(sqrt_s);
    }
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class xseeWWtot : public ThObservable {
public:
 
    xseeWWtot(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("xseeWWtot called with a class whose parent is not NPbase");
    }
 
    double computeThValue()
    {
        return myNPbase->xseeWWtotLEP2(sqrt_s);
    }
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
class deltaxseeWWtot : public ThObservable {
public:
 
    deltaxseeWWtot(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("deltaxseeWWtot called with a class whose parent is not NPbase");
    }
 
    double computeThValue()
    {
        return myNPbase->deltaxseeWWtotLEP2(sqrt_s);
    }
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class dxseeWWLEP2Bin : public ThObservable {
public:
 
    dxseeWWLEP2Bin(const StandardModel& SM_i, const double sqrt_s_i, const int bin_i)
    : ThObservable(SM_i), sqrt_s(sqrt_s_i), bin(bin_i)
    {
        if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
            throw std::runtime_error("dxseeWWLEP2Bin called with a class whose parent is not NPbase");
    }
 
    double computeThValue()
    {
        return myNPbase->dxsdcoseeWWlvjjLEP2(sqrt_s, bin);
    }
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
    const int bin;
};
 
 
class deltadxseeWWLEP2Bin : public ThObservable {
public:
 
    deltadxseeWWLEP2Bin(const StandardModel& SM_i, const double sqrt_s_i, const int bin_i)
    : ThObservable(SM_i), sqrt_s(sqrt_s_i), bin(bin_i)
    {
        if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
            throw std::runtime_error("deltadxseeWWLEP2Bin called with a class whose parent is not NPbase");
    }
 
    double computeThValue()
    {
        return myNPbase->deltadxsdcoseeWWlvjjLEP2(sqrt_s, bin);
    }
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
    const int bin;
};
 
 
#endif  /* EEWW_H */