/data/refman/pasoursint/CMSSW_6_1_1/src/GeneratorInterface/ThePEGInterface/plugins/ThePEGLesHouchesInterface.cc

Go to the documentation of this file.

#include <algorithm>
#include <iostream>
#include <sstream>
#include <string>
#include <memory>
#include <set>

#include <boost/shared_ptr.hpp>

#include <ThePEG/Interface/ClassDocumentation.h>
#include <ThePEG/Interface/InterfacedBase.h>
#include <ThePEG/Interface/Parameter.h>
#include <ThePEG/Utilities/ClassTraits.h>

#include <ThePEG/LesHouches/LesHouches.h>
#include <ThePEG/LesHouches/LesHouchesReader.h>

#include "FWCore/Utilities/interface/Exception.h"

#include "SimDataFormats/GeneratorProducts/interface/LesHouches.h"

#include "GeneratorInterface/LHEInterface/interface/LHERunInfo.h"
#include "GeneratorInterface/LHEInterface/interface/LHEEvent.h"
#include "GeneratorInterface/LHEInterface/interface/LHEProxy.h"

using namespace lhef;

namespace ThePEG {

class LesHouchesInterface : public LesHouchesReader {
    public:
        LesHouchesInterface();
        virtual ~LesHouchesInterface();

        static void Init();

    protected:          
        virtual IBPtr clone() const { return new_ptr(*this); }
        virtual IBPtr fullclone() const { return new_ptr(*this); }

    private:
        virtual void open();
        virtual void close();
        virtual long scan();

        virtual double eventWeight();
        virtual double reweight();
        virtual double getEvent();
        virtual bool doReadEvent();

        LHEProxy::ProxyID       proxyID;
        bool                    initialized;

        static ClassDescription<LesHouchesInterface> initLesHouchesInterface;
};

// registration with ThePEG plugin system

template<>
struct BaseClassTrait<LesHouchesInterface, 1> : public ClassTraitsType {
        typedef LesHouchesReader NthBase;
};

template<>
struct ClassTraits<LesHouchesInterface> :
                        public ClassTraitsBase<LesHouchesInterface> {
        static string className() { return "ThePEG::LesHouchesInterface"; }
        static string library() { return "pluginGeneratorInterfaceThePEGHadronisation.so"; }
};

} // namespace ThePEG

using namespace ThePEG;

LesHouchesInterface::LesHouchesInterface() :
        initialized(false)
{
}

LesHouchesInterface::~LesHouchesInterface()
{
}

long LesHouchesInterface::scan()
{
        return 1000000000;
}

void LesHouchesInterface::open()
{
        const LHERunInfo *runInfo = LHEProxy::find(proxyID)->getRunInfo().get();
        const lhef::HEPRUP &orig = *runInfo->getHEPRUP();

        heprup.IDBMUP   = orig.IDBMUP;
        heprup.EBMUP    = orig.EBMUP;
        heprup.PDFGUP   = orig.PDFGUP;
        heprup.PDFSUP   = orig.PDFSUP;
        heprup.NPRUP    = orig.NPRUP;
        heprup.LPRUP    = orig.LPRUP;
        heprup.XSECUP   = orig.XSECUP;
        heprup.XERRUP   = orig.XERRUP;
        heprup.XMAXUP   = orig.XMAXUP;

        // We are cheating here, ThePEG does not need to know the real
        // weighting method, as it complains about anything but 3 anyway.
        // We just need to trick ThePEG into just processing each event
        // passed without doing anything fancy with it (and shut up).
        heprup.IDWTUP = 1;
}

void LesHouchesInterface::close()
{
}

double LesHouchesInterface::eventWeight()
{
        return 1.0;
}

// no reweighting
double LesHouchesInterface::reweight()
{
        preweight = 1.0;
        return 1.0;
}

// overwrite parent routine doing fancy stuff and just pass the event
double LesHouchesInterface::getEvent()
{
        reset();

        if (!doReadEvent())
                return 0.0;

        if (!initialized && !checkPartonBin())
                throw cms::Exception("ThePEGLesHouchesInterface")
                        << "Found event which cannot be handled by "
                        << "the assigned PartonExtractor." << std::endl;
        initialized = true;

        fillEvent();
        getSubProcess();

        return 1.0;
}

bool LesHouchesInterface::doReadEvent()
{
        reset();

        boost::shared_ptr<LHEEvent> event =
                                LHEProxy::find(proxyID)->releaseEvent();
        if (!event)
                throw Stop();

        hepeup.XPDWUP.first = hepeup.XPDWUP.second = 0;

        const lhef::HEPEUP &orig = *event->getHEPEUP();

        hepeup.NUP      = orig.NUP;
        hepeup.IDPRUP   = orig.IDPRUP;
        hepeup.XWGTUP   = orig.XWGTUP;
        hepeup.SCALUP   = orig.SCALUP;
        hepeup.AQEDUP   = orig.AQEDUP;
        hepeup.AQCDUP   = orig.AQCDUP;
        hepeup.resize();

        std::copy(orig.IDUP.begin(), orig.IDUP.end(), hepeup.IDUP.begin());
        hepeup.ISTUP    = orig.ISTUP;
        hepeup.MOTHUP   = orig.MOTHUP;
        hepeup.ICOLUP   = orig.ICOLUP;
        hepeup.VTIMUP   = orig.VTIMUP;
        hepeup.SPINUP   = orig.SPINUP;

        for(int i = 0; i < hepeup.NUP; i++)
                std::copy(&orig.PUP[i].x[0], &orig.PUP[i].x[5],
                          hepeup.PUP[i].begin());

        fillEvent();

        return true;
}

// register with ThePEG plugin system

ClassDescription<LesHouchesInterface> LesHouchesInterface::initLesHouchesInterface;

void LesHouchesInterface::Init() {
        typedef LHEProxy::ProxyID ProxyID;

        static ClassDocumentation<LesHouchesInterface> documentation
                ("ThePEG::LesHouchesInterface interfaces with LHEInterface");

        static Parameter<LesHouchesInterface, ProxyID> interfaceProxyID
                ("ProxyID", "The ProxyID.",
                 &LesHouchesInterface::proxyID, ProxyID(),
                 ProxyID(), ProxyID(), false, false, false);

        interfaceProxyID.rank(11);
}