LHPC::SlhaParser Class Reference

#include <SlhaParser.hpp>

Inheritance diagram for LHPC::SlhaParser:

Detailed Description

Definition at line 30 of file SlhaParser.hpp.

Public Member Functions
SLHA::SameNameBlockSet *	getBlockAsStrings (std::string blockName)
SLHA::SameNameBlockSet const *	getBlockAsStrings (std::string blockName) const
bool	readFile (std::string const &slhaFileName)
virtual void	registerBlock (SLHA::BaseSlhaBlock &blockToUpdate)
void	registerSpectrum (MassSpectrum &spectrumToUpdate)
	SlhaParser (bool const shouldRecordBlocksNotRegistered=true, bool const isVerbose=true)
virtual	~SlhaParser ()
Public Member Functions inherited from BOL::PushingObserved< SpectrumUpdater >
	PushingObserved ()
virtual void	registerObserver (PushedToObserver< SpectrumUpdater > *const joiningObserver)
void	removeAllObservers ()
virtual void	removeObserver (PushedToObserver< SpectrumUpdater > *const leavingObserver)
virtual void	updateObservers ()
virtual void	updateObservers (SpectrumUpdater const &pushedValue)
virtual	~PushingObserved ()

Static Public Member Functions
static void	copyWithoutBlock (std::string const &originalFilename, std::string const &blockToStrip, std::string const &copyFilename)

Protected Member Functions
void	checkForMassBlocksForSpectrum ()
void	clearBlocks ()
void	ensureSpectraRecordMasses ()
void	finishUpEitherBlockOrDecay ()
void	prepareForEitherBlockOrDecay ()
void	prepareToReadNewBlock ()
void	prepareToReadNewDecay ()
void	recordDecayLine ()

Protected Attributes
std::map< std::string, SLHA::SameNameBlockSet * >	blockMap
std::map< std::string, SLHA::SameNameBlockSet * >::iterator	blockMapIterator
std::string	commentString
SLHA::SameNameBlockSet *	currentBlockPointer
std::string	dataString
BOL::CommentedTextParser	fileParser
std::string	firstWordOfLine
SLHA::BaseSlhaBlock *	fmassBlockPointer
SLHA::BaseSlhaBlock *	fmasserrBlockPointer
std::multimap< int, RunningConstantError > const *	fmasserrMap
std::multimap< int, RunningConstant > const *	fmassMap
bool const	isVerbose
std::pair< std::string, SLHA::SameNameBlockSet * >	mapInserter
SLHA::BaseSlhaBlock *	massBlockPointer
std::map< int, double > const *	massMap
SpectrumUpdater	observingSpectrumUpdater
bool	ownsFmassBlock
bool	ownsFmasserrBlock
bool	ownsMassBlock
bool const	shouldRecordBlocksNotRegistered
bool	successfullyRead
BOL::VectorlikeArray< std::string >	wordsOfLine
Protected Attributes inherited from BOL::PushingObserved< SpectrumUpdater >
observerWithBoolListIterator	observerIterator
std::list< observerWithBool >	observerList

Additional Inherited Members
Protected Types inherited from BOL::PushingObserved< SpectrumUpdater >
typedef std::pair< PushedToObserver< SpectrumUpdater > *, bool >	observerWithBool
typedef std::list< observerWithBool >::iterator	observerWithBoolListIterator

Constructor & Destructor Documentation

SlhaParser()

LHPC::SlhaParser::SlhaParser	(	bool const	shouldRecordBlocksNotRegistered = true,
		bool const	isVerbose = true
	)

Definition at line 69 of file SlhaParser.cpp.

                                                 :
      isVerbose( isVerbose ),
      shouldRecordBlocksNotRegistered( shouldRecordBlocksNotRegistered ),
      fileParser( "#",
                  this->isVerbose ),
      blockMap(),
      blockMapIterator(),
      mapInserter( "",
                   NULL ),
      currentBlockPointer( NULL ),
      dataString( "" ),
      commentString( "" ),
      firstWordOfLine( "" ),
      wordsOfLine( 2 ),
      observingSpectrumUpdater(),
      ownsFmassBlock( false ),
      fmassBlockPointer( NULL ),
      fmassMap(),
      ownsFmasserrBlock( false ),
      fmasserrBlockPointer( NULL ),
      fmasserrMap(),
      ownsMassBlock( false ),
      massBlockPointer( NULL ),
      massMap(),
      successfullyRead( false )
  {
    // just an initialization list.
  }

~SlhaParser()

LHPC::SlhaParser::~SlhaParser ( )

virtual

Definition at line 99 of file SlhaParser.cpp.

  {
    if( ownsMassBlock )
    {
      delete massBlockPointer;
    }
    if( ownsFmassBlock )
    {
      delete fmassBlockPointer;
    }
    blockMapIterator = blockMap.begin();
    while( blockMap.end() != blockMapIterator )
    {
      delete blockMapIterator->second;
      ++blockMapIterator;
    }
  }

Member Function Documentation

checkForMassBlocksForSpectrum()

void LHPC::SlhaParser::checkForMassBlocksForSpectrum ( )

protected

Definition at line 215 of file SlhaParser.cpp.

  {
    if( !(observerList.empty()) )
    {
      if( NULL == fmassBlockPointer )
        // if there is at least 1 spectrum to update, but no fmass block...
      {
        ownsFmassBlock = true;
        fmassBlockPointer
        = new SLHA::SinglyIndexedMultipleEntriesBlock< RunningConstant >(
                                                                       "FMASS",
                                                             RunningConstant(),
                                                                     isVerbose,
                                                                          9 );
        blockMapIterator = blockMap.find( fmassBlockPointer->getName() );
        if( blockMap.end() == blockMapIterator )
        {
          mapInserter.first.assign( fmassBlockPointer->getName() );
          currentBlockPointer
          = new SLHA::SameNameBlockSet( mapInserter.first );
          mapInserter.second = currentBlockPointer;
          blockMap.insert( mapInserter );
        }
        else
        {
          currentBlockPointer = blockMapIterator->second;
        }
        currentBlockPointer->registerObserver( fmassBlockPointer );
      }
      if( NULL == fmasserrBlockPointer )
        // if there is at least 1 spectrum to update, but no fmasserr block...
      {
        ownsFmasserrBlock = true;
        fmasserrBlockPointer
        = new SLHA::SinglyIndexedMultipleEntriesBlock< RunningConstantError >(
                                                                    "FMASSERR",
                                                        RunningConstantError(),
                                                                     isVerbose,
                                                                           9 );
        blockMapIterator = blockMap.find( fmasserrBlockPointer->getName() );
        if( blockMap.end() == blockMapIterator )
        {
          mapInserter.first.assign( fmasserrBlockPointer->getName() );
          currentBlockPointer
          = new SLHA::SameNameBlockSet( mapInserter.first );
          mapInserter.second = currentBlockPointer;
          blockMap.insert( mapInserter );
        }
        else
        {
          currentBlockPointer = blockMapIterator->second;
        }
        currentBlockPointer->registerObserver( fmasserrBlockPointer );
      }
      if( NULL == massBlockPointer )
        // if there is at least 1 spectrum to update, but no mass block...
      {
        ownsMassBlock = true;
        massBlockPointer
        = new SLHA::SparseSinglyIndexedBlock< double >( "MASS",
                                                  BOL::UsefulStuff::notANumber,
                                                        isVerbose,
                                                        9 );
        blockMapIterator = blockMap.find( massBlockPointer->getName() );
        if( blockMap.end() == blockMapIterator )
        {
          mapInserter.first.assign( massBlockPointer->getName() );
          currentBlockPointer
          = new SLHA::SameNameBlockSet( mapInserter.first );
          mapInserter.second = currentBlockPointer;
          blockMap.insert( mapInserter );
        }
        else
        {
          currentBlockPointer = blockMapIterator->second;
        }
        currentBlockPointer->registerObserver( massBlockPointer );
      }
    }
  }

clearBlocks()

void LHPC::SlhaParser::clearBlocks ( )

inlineprotected

Definition at line 163 of file SlhaParser.hpp.

  {
    /* observingSpectrumUpdater is set so that only decays will be updated
     * in the observing spectra until later, when the mass map pointers will be
     * set so that the masses can be recorded.
     */
    observingSpectrumUpdater.setFmassMap( NULL );
    observingSpectrumUpdater.setMassMap( NULL );
    updateObservers();
    // the MassSpectrum class over-rides respondToObservedSignal() to call its
    // clearMassesAndDecays() function.
    blockMapIterator = blockMap.begin();
    while( blockMap.end() != blockMapIterator )
    {
      blockMapIterator->second->clearEntries();
      ++blockMapIterator;
    }
    currentBlockPointer = NULL;
  }

copyWithoutBlock()

void LHPC::SlhaParser::copyWithoutBlock ( std::string const &  originalFilename, std::string const &  blockToStrip, std::string const &  copyFilename  )

static

Definition at line 19 of file SlhaParser.cpp.

  {
    BOL::CommentedTextParser fileParser( "#",
                                         false );
    fileParser.openFile( originalFilename );
    std::string dataString;
    std::string commentString;
    std::string firstWordOfLine;
    std::string restOfLine;
    bool copyingLine( true );
    std::stringstream copyStream;
    while( fileParser.parseNextLineOfFile( dataString,
                                           commentString ) )
    {
      firstWordOfLine.assign( BOL::StringParser::firstWordOf( dataString,
                                                              &restOfLine ) );
      if( BOL::StringParser::stringsMatchIgnoringCase( firstWordOfLine,
                   SLHA::BlockClass::BaseStringBlock::decayIdentifierString ) )
      {
        // if we find a DECAY, then we're not stripping out a block any more.
        copyingLine = true;
      }
      else if( BOL::StringParser::stringsMatchIgnoringCase( firstWordOfLine,
                   SLHA::BlockClass::BaseStringBlock::blockIdentifierString ) )
      {
        /* if we find a BLOCK, then we're not stripping any more if this BLOCK
         * is not the type that we are stripping, but we are (still) stripping
         * if it is.
         */
        copyingLine = !( BOL::StringParser::stringsMatchIgnoringCase(
                                  BOL::StringParser::firstWordOf( restOfLine ),
                                                              blockToStrip ) );
      }
      if( copyingLine
          &&
          !( dataString.empty()
             && commentString.empty() ) )
      {
        // if we're not stripping out a block, record the line again (except
        // for blank lines).
        copyStream << dataString << commentString << "\n";
      }
    }
    std::ofstream outputStream( copyFilename.c_str() );
    outputStream << copyStream.str();
    outputStream.close();
  }

ensureSpectraRecordMasses()

void LHPC::SlhaParser::ensureSpectraRecordMasses ( )

inlineprotected

Definition at line 235 of file SlhaParser.hpp.

  {
    if( !(observerList.empty()) )
    {
      observingSpectrumUpdater.setFmassMap( fmassBlockPointer->getFmassMap() );
      observingSpectrumUpdater.setFmasserrMap(
                                      fmasserrBlockPointer->getFmasserrMap() );
      observingSpectrumUpdater.setMassMap( massBlockPointer->getMassMap() );
      updateObservers( observingSpectrumUpdater );
    }
  }

finishUpEitherBlockOrDecay()

void LHPC::SlhaParser::finishUpEitherBlockOrDecay ( )

inlineprotected

Definition at line 218 of file SlhaParser.hpp.

  {
    if( NULL != currentBlockPointer )
    {
      currentBlockPointer->finishRecordingLines();
      currentBlockPointer = NULL;
    }
    if( observingSpectrumUpdater.isHoldingDecay() )
    {
      updateObservers( observingSpectrumUpdater );
      observingSpectrumUpdater.clearDecay();
    }
  }

getBlockAsStrings() [1/2]

SLHA::SameNameBlockSet * LHPC::SlhaParser::getBlockAsStrings ( std::string  blockName )

inline

Definition at line 132 of file SlhaParser.hpp.

  {
    BOL::StringParser::transformToUppercase( blockName );
    blockMapIterator = blockMap.find( blockName );
    if( blockMap.end() == blockMapIterator )
    {
      return NULL;
    }
    else
    {
      return blockMapIterator->second;
    }
  }

getBlockAsStrings() [2/2]

SLHA::SameNameBlockSet const * LHPC::SlhaParser::getBlockAsStrings ( std::string  blockName ) const

inline

Definition at line 147 of file SlhaParser.hpp.

  {
    BOL::StringParser::transformToUppercase( blockName );
    std::map< std::string, SLHA::SameNameBlockSet* >::const_iterator
    constBlockMapIterator( blockMap.find( blockName ) );
    if( blockMap.end() == constBlockMapIterator )
    {
      return NULL;
    }
    else
    {
      return constBlockMapIterator->second;
    }
  }

prepareForEitherBlockOrDecay()

void LHPC::SlhaParser::prepareForEitherBlockOrDecay ( )

inlineprotected

Definition at line 250 of file SlhaParser.hpp.

  {
    finishUpEitherBlockOrDecay();
    wordsOfLine.clearEntries();
    BOL::StringParser::parseByChar( dataString,
                                    wordsOfLine,
                                    BOL::StringParser::whitespaceChars );
  }

prepareToReadNewBlock()

void LHPC::SlhaParser::prepareToReadNewBlock ( )

protected

Definition at line 299 of file SlhaParser.cpp.

  {
    prepareForEitherBlockOrDecay();
    if( 2 <= wordsOfLine.getSize() )
      // if the line at least has a string for the block name...
    {
      BOL::StringParser::transformToUppercase( wordsOfLine[ 1 ] );
      blockMapIterator = blockMap.find( wordsOfLine[ 1 ] );
      if( blockMap.end() != blockMapIterator )
        // if the name corresponds to a block that already exists in the map...
      {
        currentBlockPointer = blockMapIterator->second;
      }
      else if( shouldRecordBlocksNotRegistered )
        // otherwise, if it should be recorded anyway...
      {
        mapInserter.first.assign( wordsOfLine[ 1 ] );
        currentBlockPointer = new SLHA::SameNameBlockSet( mapInserter.first );
        // a new block is required.
        mapInserter.second = currentBlockPointer;
        blockMap.insert( mapInserter );
      }
      if( NULL != currentBlockPointer )
      {
        double currentBlockScale( 0.0 );
        // if no scale is given by "Q=", the block is assigned the default
        // scale of 0.0 GeV.
        if( 3 <= wordsOfLine.getSize() )
        {
          currentBlockScale =
          BOL::StringParser::stringToDouble( wordsOfLine.getBack() );
        }
        currentBlockPointer->recordHeader( dataString,
                                           commentString,
                                           currentBlockScale );
      }
    }
  }

prepareToReadNewDecay()

void LHPC::SlhaParser::prepareToReadNewDecay ( )

inlineprotected

Definition at line 186 of file SlhaParser.hpp.

  {
    prepareForEitherBlockOrDecay();
    if( !(observerList.empty())
        &&
        ( 3 == wordsOfLine.getSize() ) )
      // if there is a spectrum for recording decays, & if the line has the
      // right number of entries ("DECAY", particle code, decay width)...
    {
      observingSpectrumUpdater.recordDecayHeader( wordsOfLine[ 1 ],
                                                  wordsOfLine[ 2 ] );
    }
  }

readFile()

bool LHPC::SlhaParser::readFile

(

std::string const &

slhaFileName

)

Definition at line 167 of file SlhaParser.cpp.

  {
    checkForMassBlocksForSpectrum();
    clearBlocks();
    // new data should overwrite the old data, not append to it.
    successfullyRead = fileParser.openFile( slhaFileName );
    while( fileParser.parseNextLineOfFile( dataString,
                                           commentString ) )
    {
      firstWordOfLine.assign( BOL::StringParser::firstWordOf( dataString ) );
      // some perverts use tabs in their SLHA files.
      BOL::StringParser::transformToLowercase( firstWordOfLine );
      if( BOL::StringParser::stringsMatchIgnoringCase( firstWordOfLine,
                   SLHA::BlockClass::BaseStringBlock::blockIdentifierString ) )
      {
        prepareToReadNewBlock();
      }
      else if( BOL::StringParser::stringsMatchIgnoringCase( firstWordOfLine,
                   SLHA::BlockClass::BaseStringBlock::decayIdentifierString ) )
      {
        prepareToReadNewDecay();
      }
      else if( NULL != currentBlockPointer )
        // otherwise, if a block is being recorded...
      {
        currentBlockPointer->recordBodyLine( dataString,
                                             commentString );
      }
      else if( observingSpectrumUpdater.isHoldingDecay() )
        // otherwise, if a decay is being recorded...
      {
        recordDecayLine();
      }
      commentString.clear();
    }
    // the last block is closed after the last line has been read in:
    finishUpEitherBlockOrDecay();
    // after reading in the file, any recorded masses are passed to
    // spectrumToUpdate if it is not NULL:
    ensureSpectraRecordMasses();
    return successfullyRead;
  }

recordDecayLine()

void LHPC::SlhaParser::recordDecayLine ( )

inlineprotected

Definition at line 203 of file SlhaParser.hpp.

  {
    wordsOfLine.clearEntries();
    BOL::StringParser::parseByChar( dataString,
                                    wordsOfLine,
                                    BOL::StringParser::whitespaceChars );
    if( !(wordsOfLine.isEmpty()) )
      // if there is a decay to record...
    {
      observingSpectrumUpdater.recordDecayLine( wordsOfLine );
    }
  }

registerBlock()

void LHPC::SlhaParser::registerBlock ( SLHA::BaseSlhaBlock &  blockToUpdate )

virtual

Definition at line 120 of file SlhaParser.cpp.

  {
    blockMapIterator = blockMap.find( blockToUpdate.getName() );
    if( blockMap.end() == blockMapIterator )
    {
      mapInserter.first.assign( blockToUpdate.getName() );
      currentBlockPointer = new SLHA::SameNameBlockSet( mapInserter.first );
      mapInserter.second = currentBlockPointer;
      blockMap.insert( mapInserter );
    }
    else
    {
      currentBlockPointer = blockMapIterator->second;
    }
    if( blockToUpdate.isFmassBlock() )
    {
      if( ownsFmassBlock )
      {
        delete fmassBlockPointer;
        ownsFmassBlock = false;
      }
      fmassBlockPointer = &blockToUpdate;
    }
    else if( blockToUpdate.isFmasserrBlock() )
    {
      if( ownsFmasserrBlock )
      {
        delete fmasserrBlockPointer;
        ownsFmasserrBlock = false;
      }
      fmasserrBlockPointer = &blockToUpdate;
    }
    else if( blockToUpdate.isMassBlock() )
    {
      if( ownsMassBlock )
      {
        delete massBlockPointer;
        ownsMassBlock = false;
      }
      massBlockPointer = &blockToUpdate;
    }
    currentBlockPointer->registerObserver( &blockToUpdate );
  }

registerSpectrum()

void LHPC::SlhaParser::registerSpectrum ( MassSpectrum &  spectrumToUpdate )

inline

Definition at line 124 of file SlhaParser.hpp.

  {
    registerObserver( &spectrumToUpdate );
  }

Member Data Documentation

blockMap

std::map< std::string, SLHA::SameNameBlockSet* > LHPC::SlhaParser::blockMap

protected

Definition at line 67 of file SlhaParser.hpp.

blockMapIterator

std::map<std::string,SLHA::SameNameBlockSet*>::iterator LHPC::SlhaParser::blockMapIterator

protected

Definition at line 69 of file SlhaParser.hpp.

commentString

std::string LHPC::SlhaParser::commentString

protected

Definition at line 73 of file SlhaParser.hpp.

currentBlockPointer

SLHA::SameNameBlockSet* LHPC::SlhaParser::currentBlockPointer

protected

Definition at line 71 of file SlhaParser.hpp.

dataString

std::string LHPC::SlhaParser::dataString

protected

Definition at line 72 of file SlhaParser.hpp.

fileParser

BOL::CommentedTextParser LHPC::SlhaParser::fileParser

protected

Definition at line 66 of file SlhaParser.hpp.

firstWordOfLine

std::string LHPC::SlhaParser::firstWordOfLine

protected

Definition at line 74 of file SlhaParser.hpp.

fmassBlockPointer

SLHA::BaseSlhaBlock* LHPC::SlhaParser::fmassBlockPointer

protected

Definition at line 78 of file SlhaParser.hpp.

fmasserrBlockPointer

SLHA::BaseSlhaBlock* LHPC::SlhaParser::fmasserrBlockPointer

protected

Definition at line 81 of file SlhaParser.hpp.

fmasserrMap

std::multimap< int, RunningConstantError > const* LHPC::SlhaParser::fmasserrMap

protected

Definition at line 82 of file SlhaParser.hpp.

fmassMap

std::multimap< int, RunningConstant > const* LHPC::SlhaParser::fmassMap

protected

Definition at line 79 of file SlhaParser.hpp.

isVerbose

bool const LHPC::SlhaParser::isVerbose

protected

Definition at line 64 of file SlhaParser.hpp.

mapInserter

std::pair< std::string, SLHA::SameNameBlockSet* > LHPC::SlhaParser::mapInserter

protected

Definition at line 70 of file SlhaParser.hpp.

massBlockPointer

SLHA::BaseSlhaBlock* LHPC::SlhaParser::massBlockPointer

protected

Definition at line 84 of file SlhaParser.hpp.

massMap

std::map< int, double > const* LHPC::SlhaParser::massMap

protected

Definition at line 85 of file SlhaParser.hpp.

observingSpectrumUpdater

SpectrumUpdater LHPC::SlhaParser::observingSpectrumUpdater

protected

Definition at line 76 of file SlhaParser.hpp.

ownsFmassBlock

bool LHPC::SlhaParser::ownsFmassBlock

protected

Definition at line 77 of file SlhaParser.hpp.

ownsFmasserrBlock

bool LHPC::SlhaParser::ownsFmasserrBlock

protected

Definition at line 80 of file SlhaParser.hpp.

ownsMassBlock

bool LHPC::SlhaParser::ownsMassBlock

protected

Definition at line 83 of file SlhaParser.hpp.

shouldRecordBlocksNotRegistered

bool const LHPC::SlhaParser::shouldRecordBlocksNotRegistered

protected

Definition at line 65 of file SlhaParser.hpp.

successfullyRead

bool LHPC::SlhaParser::successfullyRead

protected

Definition at line 86 of file SlhaParser.hpp.

wordsOfLine

BOL::VectorlikeArray< std::string > LHPC::SlhaParser::wordsOfLine

protected

Definition at line 75 of file SlhaParser.hpp.

---

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

• SlhaParser.hpp
• SlhaParser.cpp