gen::ConcurrentExternalDecayDriver Class Reference

#include <ConcurrentExternalDecayDriver.h>

Public Member Functions
	ConcurrentExternalDecayDriver (const edm::ParameterSet &)
HepMC::GenEvent *	decay (HepMC::GenEvent *evt)
HepMC::GenEvent *	decay (HepMC::GenEvent *evt, lhef::LHEEvent *lheEvent)
void	init (const edm::EventSetup &)
const std::vector< int > &	operatesOnParticles ()
void	setRandomEngine (CLHEP::HepRandomEngine *)
const std::vector< std::string > &	specialSettings ()
void	statistics () const
	~ConcurrentExternalDecayDriver ()

Private Attributes
bool	fIsInitialized
std::vector< int >	fPDGs
std::vector< std::string >	fSpecialSettings

Detailed Description

Definition at line 28 of file ConcurrentExternalDecayDriver.h.

Constructor & Destructor Documentation

ConcurrentExternalDecayDriver::ConcurrentExternalDecayDriver

(

const edm::ParameterSet &

pset

)

Definition at line 23 of file ConcurrentExternalDecayDriver.cc.

References Exception, edm::ParameterSet::getParameter(), and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                     : fIsInitialized(false) {
  std::vector<std::string> extGenNames = pset.getParameter<std::vector<std::string> >("parameterSets");

  for (unsigned int ip = 0; ip < extGenNames.size(); ++ip) {
    std::string curSet = extGenNames[ip];
    throw cms::Exception("ThreadUnsafeDecayer") << "The decayer " << curSet << " is not thread-friendly.";
    /*
    if (curSet == "EvtGen") {
      fEvtGenInterface = std::unique_ptr<EvtGenInterfaceBase>(
          EvtGenFactory::get()->create("EvtGen", pset.getUntrackedParameter<ParameterSet>(curSet)));
      exSharedResources.emplace_back(edm::SharedResourceNames::kEvtGen);
      exSharedResources.emplace_back(edm::SharedResourceNames::kPythia6);
      exSharedResources.emplace_back(gen::FortranInstance::kFortranInstance);
    } else if (curSet == "EvtGen1" || curSet == "EvtGen130") {
      fEvtGenInterface = std::unique_ptr<EvtGenInterfaceBase>(
          EvtGenFactory::get()->create("EvtGen130", pset.getUntrackedParameter<ParameterSet>(curSet)));
      exSharedResources.emplace_back(edm::SharedResourceNames::kEvtGen);
      exSharedResources.emplace_back(edm::SharedResourceNames::kPythia8);
      exSharedResources.emplace_back(edm::SharedResourceNames::kTauola);
      exSharedResources.emplace_back(edm::SharedResourceNames::kPhotos);
      exSharedResources.emplace_back(gen::FortranInstance::kFortranInstance);
    } else if (curSet == "Tauola" || curSet == "Tauolapp" || curSet == "Tauolapp114") {
      fTauolaInterface = std::unique_ptr<TauolaInterfaceBase>(
          TauolaFactory::get()->create("Tauolapp114", pset.getUntrackedParameter<ParameterSet>(curSet)));
      fPhotosInterface = std::unique_ptr<PhotosInterfaceBase>(
          PhotosFactory::get()->create("Photos2155", pset.getUntrackedParameter<ParameterSet>(curSet)));
      fPhotosInterface->configureOnlyFor(15);
      fPhotosInterface->avoidTauLeptonicDecays();
      exSharedResources.emplace_back(edm::SharedResourceNames::kTauola);
      exSharedResources.emplace_back(edm::SharedResourceNames::kPhotos);
    } else if (curSet == "Photos" || curSet == "Photos2155") {
      if (!fPhotosInterface) {
        fPhotosInterface = std::unique_ptr<PhotosInterfaceBase>(
            PhotosFactory::get()->create("Photos2155", pset.getUntrackedParameter<ParameterSet>(curSet)));
        exSharedResources.emplace_back(edm::SharedResourceNames::kPhotos);
      }
    } else if (curSet == "Photospp" || curSet == "Photospp356") {
      if (!fPhotosInterface) {
        fPhotosInterface = std::unique_ptr<PhotosInterfaceBase>(
            PhotosFactory::get()->create("Photospp356", pset.getUntrackedParameter<ParameterSet>(curSet)));
        exSharedResources.emplace_back(edm::SharedResourceNames::kPhotos);
      }
    }
    */
  }
}

ConcurrentExternalDecayDriver::~ConcurrentExternalDecayDriver ( )

default

Member Function Documentation

HepMC::GenEvent * ConcurrentExternalDecayDriver::decay

(

HepMC::GenEvent *

evt

)

Definition at line 78 of file ConcurrentExternalDecayDriver.cc.

References fIsInitialized.

Referenced by decay().

                                                                      {
  if (!fIsInitialized)
    return evt;
  /*
  if (fEvtGenInterface) {
    evt = fEvtGenInterface->decay(evt);
    if (!evt)
      return nullptr;
  }

  if (fTauolaInterface) {
    evt = fTauolaInterface->decay(evt);
    if (!evt)
      return nullptr;
  }

  if (fPhotosInterface) {
    evt = fPhotosInterface->apply(evt);
    if (!evt)
      return nullptr;
  }
  */
  return evt;
}

HepMC::GenEvent * ConcurrentExternalDecayDriver::decay	(	HepMC::GenEvent *	evt,
		lhef::LHEEvent *	lheEvent
	)

Definition at line 72 of file ConcurrentExternalDecayDriver.cc.

References decay().

                                                                                              {
  /*  if (fTauolaInterface)
      fTauolaInterface->SetLHE(lheEvent); */
  return decay(evt);
}

void ConcurrentExternalDecayDriver::init

(

const edm::EventSetup &

es

)

Definition at line 103 of file ConcurrentExternalDecayDriver.cc.

References fIsInitialized.

                                                                {
  if (fIsInitialized)
    return;
  /*
  if (fTauolaInterface) {
    fTauolaInterface->init(es);
    for (std::vector<int>::const_iterator i = fTauolaInterface->operatesOnParticles().begin();
         i != fTauolaInterface->operatesOnParticles().end();
         i++)
      fPDGs.push_back(*i);
  }

  if (fEvtGenInterface) {
    fEvtGenInterface->init();
    for (std::vector<int>::const_iterator i = fEvtGenInterface->operatesOnParticles().begin();
         i != fEvtGenInterface->operatesOnParticles().end();
         i++)
      fPDGs.push_back(*i);
    for (unsigned int iss = 0; iss < fEvtGenInterface->specialSettings().size(); iss++) {
      fSpecialSettings.push_back(fEvtGenInterface->specialSettings()[iss]);
    }
  }

  if (fPhotosInterface) {
    fPhotosInterface->init();
    //   for tauola++
    if (fPhotosInterface) {
      for (unsigned int iss = 0; iss < fPhotosInterface->specialSettings().size(); iss++) {
        fSpecialSettings.push_back(fPhotosInterface->specialSettings()[iss]);
      }
    }
  }
  */

  fIsInitialized = true;

  return;
}

const std::vector<int>& gen::ConcurrentExternalDecayDriver::operatesOnParticles ( )

inline

Definition at line 36 of file ConcurrentExternalDecayDriver.h.

References fPDGs.

{ return fPDGs; }

void ConcurrentExternalDecayDriver::setRandomEngine

(

CLHEP::HepRandomEngine *

v

)

Definition at line 152 of file ConcurrentExternalDecayDriver.cc.

                                                                           {
  /*
  if (fTauolaInterface)
    fTauolaInterface->setRandomEngine(v);
  if (fEvtGenInterface)
    fEvtGenInterface->setRandomEngine(v);
  if (fPhotosInterface)
    fPhotosInterface->setRandomEngine(v);
  */
}

const std::vector<std::string>& gen::ConcurrentExternalDecayDriver::specialSettings ( )

inline

Definition at line 37 of file ConcurrentExternalDecayDriver.h.

References fSpecialSettings.

{ return fSpecialSettings; }

void ConcurrentExternalDecayDriver::statistics

(

)

const

Definition at line 142 of file ConcurrentExternalDecayDriver.cc.

                                                     {
  /*  if (fTauolaInterface)
    fTauolaInterface->statistics();
  if (fPhotosInterface)
    fPhotosInterface->statistics();
  */
  // similar for EvtGen if needed
  return;
}

Member Data Documentation

bool gen::ConcurrentExternalDecayDriver::fIsInitialized

private

Definition at line 47 of file ConcurrentExternalDecayDriver.h.

Referenced by decay(), and init().

std::vector<int> gen::ConcurrentExternalDecayDriver::fPDGs

private

Definition at line 51 of file ConcurrentExternalDecayDriver.h.

Referenced by operatesOnParticles().

std::vector<std::string> gen::ConcurrentExternalDecayDriver::fSpecialSettings

private

Definition at line 52 of file ConcurrentExternalDecayDriver.h.

Referenced by specialSettings().