genie::XSecAlgorithmMap Class Reference

An Interaction -> XSecAlgorithmI associative container. The container is being built for the loaded EventGeneratorList and for the input InitialState object. More...

#include <XSecAlgorithmMap.h>

Inheritance diagram for genie::XSecAlgorithmMap:

Collaboration diagram for genie::XSecAlgorithmMap:

Public Member Functions
	XSecAlgorithmMap ()
	XSecAlgorithmMap (const XSecAlgorithmMap &xsmap)
	~XSecAlgorithmMap ()
void	UseGeneratorList (const EventGeneratorList *list)
void	BuildMap (const InitialState &init_state)
const XSecAlgorithmI *	FindXSecAlgorithm (const Interaction *in) const
const InteractionList &	GetInteractionList (void) const
void	Reset (void)
void	Copy (const XSecAlgorithmMap &xsmap)
void	Print (ostream &stream) const
XSecAlgorithmMap &	operator= (const XSecAlgorithmMap &xsmap)

Private Member Functions
void	Init (void)
void	CleanUp (void)

Private Attributes
const EventGeneratorList *	fEventGeneratorList
InitialState *	fInitState
InteractionList *	fInteractionList

Friends
ostream &	operator<< (ostream &stream, const XSecAlgorithmMap &xsmap)

Detailed Description

An Interaction -> XSecAlgorithmI associative container. The container is being built for the loaded EventGeneratorList and for the input InitialState object.

Author

Costas Andreopoulos <c.andreopoulos cern.ch> University of Liverpool

Created:

January 23, 2006

License:

Copyright (c) 2003-2024, The GENIE Collaboration For the full text of the license visit http://copyright.genie-mc.org

Definition at line 42 of file XSecAlgorithmMap.h.

Constructor & Destructor Documentation

XSecAlgorithmMap::XSecAlgorithmMap

(

)

Definition at line 32 of file XSecAlgorithmMap.cxx.

References Init().

                                   :
map<string, const XSecAlgorithmI *> ()
{
  this->Init();
}

XSecAlgorithmMap::XSecAlgorithmMap

(

const XSecAlgorithmMap &

xsmap

)

Definition at line 38 of file XSecAlgorithmMap.cxx.

References Copy().

                                                                 :
map<string, const XSecAlgorithmI *> ()
{
  this->Copy(xsmap);
}

XSecAlgorithmMap::~XSecAlgorithmMap

(

)

Definition at line 44 of file XSecAlgorithmMap.cxx.

References CleanUp().

{
  this->CleanUp();
}

Member Function Documentation

void XSecAlgorithmMap::BuildMap

(

const InitialState &

init_state

)

Definition at line 95 of file XSecAlgorithmMap.cxx.

References genie::InteractionList::Append(), genie::InitialState::AsString(), genie::Interaction::AsString(), genie::InitialState::Copy(), genie::InteractionListGeneratorI::CreateInteractionList(), genie::EventGeneratorI::CrossSectionAlg(), fEventGeneratorList, fInitState, fInteractionList, genie::Algorithm::Id(), genie::EventGeneratorI::IntListGenerator(), genie::AlgId::Key(), LOG, pINFO, pNOTICE, pWARN, and SLOG.

{
  LOG("XSecAlgMap", pNOTICE)
                << "Building 'interaction' -> 'xsec algorithm' associations";
  LOG("XSecAlgMap", pNOTICE)
           << "Using all simulated interactions for init-state: "
                                                    << init_state.AsString();
  if(!fEventGeneratorList) {
     LOG("XSecAlgMap", pWARN)
      << "No EventGeneratorList was loaded. Will not build XSecAlgorithmMap";
     return;
  }

  fInitState->Copy(init_state);

  EventGeneratorList::const_iterator evgliter; // event generator list iter
  InteractionList::iterator          intliter; // interaction list iter

  // loop over all EventGenerator objects used in the current job
  for(evgliter = fEventGeneratorList->begin();
                       evgliter != fEventGeneratorList->end(); ++evgliter) {
     // current EventGenerator
     const EventGeneratorI * evgen = *evgliter;
     assert(evgen);

     // ask the event generator to produce a list of all interaction it can
     // generate for the input initial state
     LOG("XSecAlgMap", pNOTICE)
        << "Querying [" << evgen->Id().Key() << "] for its InteractionList";

     const InteractionListGeneratorI * ilstgen = evgen->IntListGenerator();
     InteractionList * ilst = ilstgen->CreateInteractionList(init_state);

     // no point to go on if the list is NULL - continue to next iteration
     if(!ilst) continue;

     // append the new InteractionList to the local copy
     fInteractionList->Append(*ilst);

     // cross section algorithm used by this EventGenerator
     const XSecAlgorithmI * xsec_alg = evgen->CrossSectionAlg();

     // loop over all interaction that can be genererated by the current
     // EventGenerator and link all of them to the current XSecAlgorithmI
     for(intliter = ilst->begin(); intliter != ilst->end(); ++intliter)
     {
        // current interaction
        Interaction * interaction = *intliter;
        string code = interaction->AsString();

         // link with the xsec algorithm
         SLOG("XSecAlgMap", pINFO)
           << "\nLinking: " << code
              << "\n     --> with xsec algorithm: " << xsec_alg->Id().Key();
         this->insert(
            map<string, const XSecAlgorithmI *>::value_type(code,xsec_alg));

     } // loop over interactions
     delete ilst;
     ilst = 0;
  } // loop over event generators
}

void XSecAlgorithmMap::CleanUp ( void  )

private

Definition at line 63 of file XSecAlgorithmMap.cxx.

References clear, fInitState, and fInteractionList.

Referenced by Reset(), and ~XSecAlgorithmMap().

{
  delete fInitState;
  delete fInteractionList;

  this->clear();
}

void XSecAlgorithmMap::Copy

(

const XSecAlgorithmMap &

xsmap

)

Definition at line 71 of file XSecAlgorithmMap.cxx.

References clear, fEventGeneratorList, fInitState, and fInteractionList.

Referenced by operator=(), and XSecAlgorithmMap().

{
  fEventGeneratorList = xsmap.fEventGeneratorList;

  fInitState       -> Copy (*xsmap.fInitState);
  fInteractionList -> Copy (*xsmap.fInteractionList);

  this->clear();

  XSecAlgorithmMap::const_iterator iter;

  for(iter = xsmap.begin(); iter != xsmap.end(); ++iter) {
    string code = iter->first;
    const XSecAlgorithmI * alg = iter->second;

    this->insert(map<string, const XSecAlgorithmI *>::value_type(code,alg));
  }
}

const XSecAlgorithmI * XSecAlgorithmMap::FindXSecAlgorithm

(

const Interaction *

in

)

const

Definition at line 158 of file XSecAlgorithmMap.cxx.

References genie::Interaction::AsString(), LOG, and pWARN.

{
  if(!interaction) {
    LOG("XSecAlgMap", pWARN) << "Null interaction!!";
    return 0;
  }

  string code = interaction->AsString();

  XSecAlgorithmMap::const_iterator xsec_alg_iter = this->find(code);
  if(xsec_alg_iter == this->end()) {
    LOG("XSecAlgMap", pWARN)
         << "No XSecAlgorithmI was found for interaction: \n" << code;
    return 0;
  }

  const XSecAlgorithmI * xsec_alg = xsec_alg_iter->second;
  return xsec_alg;
}

const InteractionList & XSecAlgorithmMap::GetInteractionList

(

void

)

const

Definition at line 179 of file XSecAlgorithmMap.cxx.

References fInteractionList.

{
  return *fInteractionList;
}

void XSecAlgorithmMap::Init ( void  )

private

Definition at line 55 of file XSecAlgorithmMap.cxx.

References fEventGeneratorList, fInitState, and fInteractionList.

Referenced by Reset(), and XSecAlgorithmMap().

{
  fEventGeneratorList = 0;

  fInitState       = new InitialState;
  fInteractionList = new InteractionList;
}

XSecAlgorithmMap & XSecAlgorithmMap::operator=

(

const XSecAlgorithmMap &

xsmap

)

Definition at line 201 of file XSecAlgorithmMap.cxx.

References Copy().

{
  this->Copy(xs);
  return (*this);
}

void XSecAlgorithmMap::Print

(

ostream &

stream

)

const

Definition at line 184 of file XSecAlgorithmMap.cxx.

References genie::Algorithm::Id(), and genie::AlgId::Key().

Referenced by genie::operator<<().

{
  XSecAlgorithmMap::const_iterator iter;

  stream<< "Printing 'interaction' -> 'xsec algorithm' associations" << endl;

  for(iter = this->begin(); iter != this->end(); ++iter) {
    string code = iter->first;
    const XSecAlgorithmI * alg = iter->second;
    if(alg) {
       stream << code << "  -> " << alg->Id().Key() << endl;
    } else {
       stream << code << "  ->  **** NULL XSEC ALGORITHM ****" << endl;
    }
  }
}

void XSecAlgorithmMap::Reset

(

void

)

Definition at line 49 of file XSecAlgorithmMap.cxx.

References CleanUp(), and Init().

{
  this->CleanUp();
  this->Init();
}

void XSecAlgorithmMap::UseGeneratorList

(

const EventGeneratorList *

list

)

Definition at line 90 of file XSecAlgorithmMap.cxx.

References fEventGeneratorList.

{
  fEventGeneratorList = list;
}

Friends And Related Function Documentation

ostream& operator<< ( ostream &  stream, const XSecAlgorithmMap &  xsmap  )

friend

Definition at line 25 of file XSecAlgorithmMap.cxx.

 {
   intl.Print(stream);
   return stream;
 }

Member Data Documentation

const EventGeneratorList* genie::XSecAlgorithmMap::fEventGeneratorList

private

Definition at line 68 of file XSecAlgorithmMap.h.

Referenced by BuildMap(), Copy(), Init(), and UseGeneratorList().

InitialState* genie::XSecAlgorithmMap::fInitState

private

Definition at line 70 of file XSecAlgorithmMap.h.

Referenced by BuildMap(), CleanUp(), Copy(), and Init().

InteractionList* genie::XSecAlgorithmMap::fInteractionList

private

Definition at line 71 of file XSecAlgorithmMap.h.

Referenced by BuildMap(), CleanUp(), Copy(), GetInteractionList(), and Init().

---

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

• XSecAlgorithmMap.h
• XSecAlgorithmMap.cxx