LesHouches.h

Go to the documentation of this file.

// -*- C++ -*-
//
// Copyright (C) 1999-2007 Leif Lonnblad
//
// Modified by C.Saout
//
#ifndef SimDataFormats_GeneratorProducts_LesHouches_h
#define SimDataFormats_GeneratorProducts_LesHouches_h

#include <utility>
#include <vector>

namespace lhef {

class HEPRUP {
    public:
    HEPRUP() : IDWTUP(0), NPRUP(0) {}

    public:
    bool operator == (const HEPRUP &other) const
    {
        return IDBMUP == other.IDBMUP &&
               EBMUP == other.EBMUP &&
               PDFGUP == other.PDFGUP &&
               PDFSUP == other.PDFSUP &&
               IDWTUP == other.IDWTUP &&
               NPRUP == other.NPRUP &&
               XSECUP == other.XSECUP &&
               XERRUP == other.XERRUP &&
               XMAXUP == other.XMAXUP &&
               LPRUP == other.LPRUP;
    }

    void resize(int nrup)
    {
        NPRUP = nrup;
        resize();
    }

    void resize() {
        XSECUP.resize(NPRUP);
        XERRUP.resize(NPRUP);
        XMAXUP.resize(NPRUP);
        LPRUP.resize(NPRUP);
    }

    void swap(HEPRUP& other) {
        IDBMUP.swap(other.IDBMUP);
        EBMUP.swap(other.EBMUP);
        PDFGUP.swap(other.PDFGUP);
        PDFSUP.swap(other.PDFSUP);
        std::swap(IDWTUP, other.IDWTUP);
        std::swap(NPRUP, other.NPRUP);
        XSECUP.swap(other.XSECUP);
        XERRUP.swap(other.XERRUP);
        XMAXUP.swap(other.XMAXUP);
        LPRUP.swap(other.LPRUP);
    }

    std::pair<int, int> IDBMUP;

    std::pair<double, double> EBMUP;

    std::pair<int, int> PDFGUP;

    std::pair<int, int> PDFSUP;

    int IDWTUP;

    int NPRUP;

    std::vector<double> XSECUP;

    std::vector<double> XERRUP;

    std::vector<double> XMAXUP;

    std::vector<int> LPRUP;
};


class HEPEUP {
    public:
    HEPEUP() :
        NUP(0), IDPRUP(0), XWGTUP(0.0), XPDWUP(0.0, 0.0),
        SCALUP(0.0), AQEDUP(0.0), AQCDUP(0.0)
    {}

    public:
    struct FiveVector {
        double operator [] (unsigned int i) const { return x[i]; }
        double &operator [] (unsigned int i) { return x[i]; }

        double  x[5];
    };

    void resize(int nup)
    {
        NUP = nup;
        resize();
    }

    void resize()
    {
        IDUP.resize(NUP);
        ISTUP.resize(NUP);
        MOTHUP.resize(NUP);
        ICOLUP.resize(NUP);
        PUP.resize(NUP);
        VTIMUP.resize(NUP);
        SPINUP.resize(NUP);
    }

    int NUP;

    int IDPRUP;

    double XWGTUP;

    std::pair<double, double> XPDWUP;

    double SCALUP;

    double AQEDUP;

    double AQCDUP;

    std::vector<int> IDUP;

    std::vector<int> ISTUP;

    std::vector< std::pair<int, int> > MOTHUP;

    std::vector< std::pair<int, int> > ICOLUP;

    std::vector<FiveVector> PUP;

    std::vector<double> VTIMUP;

    std::vector<double> SPINUP;

};

} // namespace lhef

#endif // SimDataFormats_GeneratorProducts_LesHouches_h