PartPropSvc Class Reference

#include <src/PartPropSvc.h>

Inheritance diagram for PartPropSvc:

Collaboration diagram for PartPropSvc:

Public Member Functions
	PartPropSvc (const std::string &name, ISvcLocator *svc)
StatusCode	initialize () override
StatusCode	finalize () override
HepPDT::ParticleDataTable *	PDT () override
void	setUnknownParticleHandler (HepPDT::ProcessUnknownID *, const std::string &) override
	~PartPropSvc () override=default
Public Member Functions inherited from extends< BASE, Interfaces >
void *	i_cast (const InterfaceID &tid) const override
	Implementation of IInterface::i_cast. More...
StatusCode	queryInterface (const InterfaceID &ti, void **pp) override
	Implementation of IInterface::queryInterface. More...
std::vector< std::string >	getInterfaceNames () const override
	Implementation of IInterface::getInterfaceNames. More...
	~extends () override=default
	Virtual destructor. More...
void *	i_cast (const InterfaceID &tid) const override
	Implementation of IInterface::i_cast. More...
StatusCode	queryInterface (const InterfaceID &ti, void **pp) override
	Implementation of IInterface::queryInterface. More...
std::vector< std::string >	getInterfaceNames () const override
	Implementation of IInterface::getInterfaceNames. More...
	~extends () override=default
	Virtual destructor. More...
Public Member Functions inherited from extend_interfaces< Interfaces...>
	~extend_interfaces () override=default
	Virtual destructor. More...
	~extend_interfaces () override=default
	Virtual destructor. More...

Private Types
using	inputFunPtr = bool(*)(std::istream &, HepPDT::TableBuilder &)

Private Member Functions
StatusCode	createTable ()
inputFunPtr	parseTableType (const std::string &)

Private Attributes
std::vector< std::pair< std::string, inputFunPtr > >	m_inputs
StringProperty	m_pdtFiles
HepPDT::ProcessUnknownID *	m_upid = nullptr
std::string	m_upid_name
std::unique_ptr< HepPDT::ParticleDataTable >	m_pdt
MsgStream	m_log
bool	m_upid_local = false

Additional Inherited Members
Public Types inherited from extends< BASE, Interfaces >
using	base_class = extends
	Typedef to this class. More...
using	extend_interfaces_base = extend_interfaces< Interfaces...>
	Typedef to the base of this class. More...
using	base_class = extends
	Typedef to this class. More...
using	extend_interfaces_base = extend_interfaces< Interfaces...>
	Typedef to the base of this class. More...
Public Types inherited from extend_interfaces< Interfaces...>
using	ext_iids = typename Gaudi::interface_list_cat< typename Interfaces::ext_iids...>::type
	take union of the ext_iids of all Interfaces... More...
using	ext_iids = typename Gaudi::interface_list_cat< typename Interfaces::ext_iids...>::type
	take union of the ext_iids of all Interfaces... More...

Detailed Description

Definition at line 28 of file PartPropSvc.h.

Member Typedef Documentation

using PartPropSvc::inputFunPtr = bool(*)(std::istream&,HepPDT::TableBuilder&)

private

Definition at line 47 of file PartPropSvc.h.

Constructor & Destructor Documentation

PartPropSvc::PartPropSvc	(	const std::string &	name,
		ISvcLocator *	svc
	)

Definition at line 25 of file PartPropSvc.cpp.

  : base_class( name_, svc ),  m_log(msgSvc(), name())  {

  declareProperty( "InputFile", m_pdtFiles="PDGTABLE.MeV");

}

PartPropSvc::~PartPropSvc ( )

overridedefault

Member Function Documentation

StatusCode PartPropSvc::createTable ( )

private

Definition at line 158 of file PartPropSvc.cpp.

                         {

  // use a handler for unknown heavy ions
  if ( !m_upid  ) {
    setUnknownParticleHandler(new HepPDT::HeavyIonUnknownID,
                  "Default Heavy Ion Handler");
    m_upid_local = true;
  }

  m_pdt.reset( new HepPDT::ParticleDataTable(m_upid_name, m_upid) );

  HepPDT::TableBuilder  tb( *m_pdt );

  for (const auto& itr : m_inputs ) {
    const auto& f = itr.first;
    const auto& pF = itr.second;

    m_log << MSG::DEBUG << "Reading PDT file \"" << f << "\""
      << endmsg;

    std::ifstream pdfile{ f };
    // build a table from the file
    if ( ! pF(pdfile,tb) ) {
      m_log << MSG::ERROR << "Error reading PDT file: \"" << f
        << "\"" << endmsg;
      return StatusCode::FAILURE;
    }

  }

  return StatusCode::SUCCESS;

}

StatusCode PartPropSvc::finalize ( )

override

Definition at line 111 of file PartPropSvc.cpp.

                      {

  m_pdt.reset();

  if (m_upid_local && m_upid ) {
    m_upid_local = false;
    // This will cause a memory leak, but we can't delete it as the
    // destructor of HepPDT::processUnknownID is protected.
    // We need this though to call reinitialize successfully.
    m_upid = nullptr;
  }

  MsgStream m_log( msgSvc(), name() );
  StatusCode status = Service::finalize();

  if ( status.isSuccess() ) {
    m_log << MSG::DEBUG << "Service finalised successfully" << endmsg;
  }

  return status;
}

StatusCode PartPropSvc::initialize ( )

override

Definition at line 35 of file PartPropSvc.cpp.

                        {

  StatusCode status = Service::initialize();
  m_log.setLevel( m_outputLevel.value() );

  if ( status.isFailure() ) {
    m_log << MSG::ERROR << "Could not initialize main svc" << endmsg;
    return StatusCode::FAILURE;
  }


  std::string key = m_pdtFiles.value();

  typedef boost::tokenizer<boost::char_separator<char> > tokenizer;
  boost::char_separator<char> sep(", ");
  boost::char_separator<char> sep_eq("=");

  tokenizer tokens(key, sep);
  for (auto it = tokens.begin(); it != tokens.end(); ++it) {

    tokenizer tok2(*it, sep_eq);
    int nToks(distance(tok2.begin(), tok2.end()));    

    auto it2 = tok2.begin();
    const std::string fname = *it2;
    std::string fmt;
    if (nToks == 1) {
      m_log << MSG::INFO << "No table format type specified for \"" << fname
        << "\". Assuming PDG" << endmsg;
      fmt = "PDG";
    } else {
      ++it2;
      fmt = *it2;
    }

    // see if input file exists in $DATAPATH
    std::string rfile = System::PathResolver::find_file(fname,"DATAPATH");
    if (rfile.empty()) {
      m_log << MSG::ERROR << "Could not find PDT file: \"" << fname
        << "\" in $DATAPATH" << endmsg;
      return StatusCode::FAILURE;
    }

    // is the file readable?
    std::ifstream pdfile{ rfile };
    if (!pdfile) {
      m_log << MSG::ERROR << "Could not open PDT file: \"" << rfile
        << "\"" << endmsg;
      return StatusCode::FAILURE;
    }

    std::string FMT = boost::algorithm::to_upper_copy(fmt);

    inputFunPtr pF = nullptr;
    try {
      pF = parseTableType(FMT);
    } catch (...) {
      m_log << MSG::ERROR
        << "Could not determine Particle Property table type: \""
        << FMT << "\" for file \"" << fname << "\"" << endmsg;
      return StatusCode::FAILURE;
    }

    m_log << MSG::DEBUG << "Adding PDT file \"" << rfile << "\" type "
      << FMT << endmsg;

    m_inputs.emplace_back( rfile, pF );

  }


  return status;
}

PartPropSvc::inputFunPtr PartPropSvc::parseTableType ( const std::string &  typ )

private

Definition at line 136 of file PartPropSvc.cpp.

{
  static const auto table = { std::make_pair( "PDG"    , &HepPDT::addPDGParticles ),
                              std::make_pair( "PYTHIA" , &HepPDT::addPythiaParticles ),
                              std::make_pair( "EVTGEN" , &HepPDT::addEvtGenParticles ),
                              std::make_pair( "HERWIG" , &HepPDT::addHerwigParticles ),
                              std::make_pair( "ISAJET" , &HepPDT::addIsajetParticles ),
                              std::make_pair( "QQ"     , &HepPDT::addQQParticles ) };
  auto i = std::find_if( std::begin(table), std::end(table), 
                         [&](const std::pair<const char*,inputFunPtr>& p)
                         { return typ == p.first; } );
  if ( i == std::end(table) ) {
    m_log << MSG::ERROR << "Unknown Particle Data file type: \""
          << typ << "\"" << endmsg;
    throw  std::runtime_error("error parsing particle table type");
  }
  return i->second;
}

HepPDT::ParticleDataTable * PartPropSvc::PDT ( )

override

Definition at line 195 of file PartPropSvc.cpp.

                 {

  if (!m_pdt ) {
    m_log << MSG::DEBUG << "creating ParticleDataTable" << endmsg;
    if (createTable().isFailure()) {
      m_log << MSG::FATAL << "Could not create ParticleDataTable" << endmsg;
      m_pdt.reset(nullptr);
    }
  }

  return m_pdt.get();
}

void PartPropSvc::setUnknownParticleHandler ( HepPDT::ProcessUnknownID *  puid, const std::string &  n  )

override

Definition at line 211 of file PartPropSvc.cpp.

                                           {
  if (m_pdt) {
    m_log << MSG::ERROR << "not setting Unknown Particle Handler \"" << n
      << "\" as ParticleDataTable already instantiated" << endmsg;
    return;
  }

  m_log << MSG::DEBUG << "setting Unknown Particle Handler \"" << n
    << "\" at " << puid << endmsg;

  if (m_upid) {
    m_log << MSG::WARNING
      << "overriding previously selected Unknown Particle Handler \""
      << m_upid_name << "\" with \"" << n << "\"" << endmsg;
  }

  m_upid = puid;
  m_upid_name = n;

}

Member Data Documentation

std::vector<std::pair<std::string,inputFunPtr> > PartPropSvc::m_inputs

private

Definition at line 50 of file PartPropSvc.h.

MsgStream PartPropSvc::m_log

mutableprivate

Definition at line 60 of file PartPropSvc.h.

std::unique_ptr<HepPDT::ParticleDataTable> PartPropSvc::m_pdt

private

Definition at line 56 of file PartPropSvc.h.

StringProperty PartPropSvc::m_pdtFiles

private

Definition at line 52 of file PartPropSvc.h.

HepPDT::ProcessUnknownID* PartPropSvc::m_upid = nullptr

private

Definition at line 53 of file PartPropSvc.h.

bool PartPropSvc::m_upid_local = false

private

Definition at line 62 of file PartPropSvc.h.

std::string PartPropSvc::m_upid_name

private

Definition at line 54 of file PartPropSvc.h.

---

The documentation for this class was generated from the following files:

• PartPropSvc/src/PartPropSvc.h
• PartPropSvc/src/PartPropSvc.cpp