lumiParser Class Reference

#include <lumiParser.h>

Inheritance diagram for lumiParser:

Collaboration diagram for lumiParser:

Public Types
typedef std::map< int, grl_run >	full_type
	full map type
typedef std::map< int, grl_run >::iterator	iterator
	iterators over the full map
typedef std::map< int, grl_run >::const_iterator	const_iterator

Public Member Functions
	lumiParser ()
	lumiParser (const std::string &file)
void	read (const std::string &f)
virtual	~lumiParser ()
void	setterse (bool b)
void	addRange (int run, int start, int stop)
	add a lumi block range for a given run
bool	inRange (int run, int lb)
	is this run, lumiblock in any of the ranges?
void	sort ()
	sort the runs by the number of good lumi blocks

Public Attributes
K	keys
	STL member.
T	elements
	STL member.

Private Member Functions
void	chomp (std::string &s, const std::string &regex)
	all these string manipulation routines should all be available from elsewhere
void	chop (std::string &s, const std::string &regex)
void	tail (std::string &s, const std::string &regex)
void	clean (std::string &s, const std::string &regex)
std::string	toupper (const std::string &s)
std::string	tolower (const std::string &s)

Private Attributes
bool	m_terse

Detailed Description

Definition at line 28 of file lumiParser.h.

Member Typedef Documentation

const_iterator

typedef std::map<int,grl_run>::const_iterator lumiList::const_iterator

inherited

Definition at line 37 of file lumiList.h.

full_type

typedef std::map< int, grl_run > lumiList::full_type

inherited

full map type

Definition at line 32 of file lumiList.h.

iterator

typedef std::map<int,grl_run>::iterator lumiList::iterator

inherited

iterators over the full map

Definition at line 35 of file lumiList.h.

Constructor & Destructor Documentation

lumiParser() [1/2]

lumiParser::lumiParser ( )

inline

Definition at line 32 of file lumiParser.h.

{ }

lumiParser() [2/2]

lumiParser::lumiParser ( const std::string & file )

inline

Definition at line 34 of file lumiParser.h.

{ read( file ); }

~lumiParser()

virtual lumiParser::~lumiParser ( )

inlinevirtual

Definition at line 126 of file lumiParser.h.

{ } 

Member Function Documentation

addRange()

void lumiList::addRange ( int run, int start, int stop )

inlineinherited

add a lumi block range for a given run

Definition at line 48 of file lumiList.h.

                                              {
 
    iterator it = find(run);
 
    if ( it == end() ) {
      std::pair< iterator, bool > in = insert( std::pair<int, grl_run >( run, grl_run( run ) ) );
      it = in.first;
    }
   
    it->second.add_range( start, stop );
   
    if ( !m_terse ) std::cout << "lumiList::addRange() run " << run << ";\t" << start << " - " << stop << std::endl;
  } 

chomp()

void lumiParser::chomp ( std::string & s, const std::string & regex )

inlineprivate

all these string manipulation routines should all be available from elsewhere

Definition at line 133 of file lumiParser.h.

                                                     { 
    size_t pos = s.find( regex );
    if ( pos!=std::string::npos ) s.erase( pos, s.size() );
  }

chop()

void lumiParser::chop ( std::string & s, const std::string & regex )

inlineprivate

Definition at line 138 of file lumiParser.h.

                                                    { 
    size_t pos = s.find( regex );
    if ( pos!=std::string::npos ) s.erase( 0, pos+regex.size() );  
  }

clean()

void lumiParser::clean ( std::string & s, const std::string & regex )

inlineprivate

Definition at line 151 of file lumiParser.h.

                                                     { 
    size_t pos = s.find( regex );
    while( pos!=std::string::npos ) { 
      s.erase( pos, regex.size() );
      pos = s.find( regex );
    }
  }

inRange()

bool lumiList::inRange ( int run, int lb )

inlineinherited

is this run, lumiblock in any of the ranges?

if the run is not in the list, it is assumed that all events from that run are required

Definition at line 67 of file lumiList.h.

                                  {
 
    iterator itr  = find(run);
    
    if ( itr == end() ) return true;
    else { 
      grl_run& v = itr->second;
      for ( unsigned i=0 ; i<v.size() ; i++ ) { 
    if ( lb>=v[i].first && lb<=v[i].second ) return true;
      }
    }
    return false; 
  }    

read()

void lumiParser::read ( const std::string & f )

inline

read GRL from web if required

save file if it exists to download again in case it has changed

open the file

go through all the lines ...

got a run

parse the run number

really need to check for upper or lower case in addition

parse the lumiblock ranges

Definition at line 36 of file lumiParser.h.

                                  {

    std::string file = f;
    size_t pos = file.find("http");
    if ( pos!=std::string::npos ) { 
      std::string cmd = "wget ";
      cmd += file;
      tail( file, "/" );
      if ( exists( file ) ) { 
    std::string mvcmd = "mv ";
    mvcmd += file + " " + file + ".bak";
    std::system( mvcmd.c_str() );
      }
      std::system( cmd.c_str() ); 
    }
 
    std::cout << "lumiParser file: " << file << std::endl;

    std::ifstream input( file.c_str() );
 
    int run;
    std::vector<int> lbstart;
    std::vector<int> lbend;
    
    for( std::string line; getline( input, line ); ) { 
      
      //    std::string s;
      //    std::cout << line << std::endl;
      
      std::string inputline = tolower(line);
      
      if ( inputline.find("run:")!=std::string::npos || 
       inputline.find("<run>")!=std::string::npos ) {
    

    std::string label = line;
    chop(  label, "Run:" );
    chop(  label, "<Run>" );
    chomp( label, "</Run>" );
    clean( label, " " );
    
    run = std::atoi(label.c_str());
    lbstart.clear();
    lbend.clear();
    
    //      std::cout << "\n\n" << line << "\trun: " << label << std::endl;

    for( std::string fline ; getline( input, fline ) ; ) { 
      if ( tolower(fline).find("from:")!=std::string::npos ) { 
        chop(  fline, "From:" );
        clean( fline, " ");
        std::string start = fline; 
        chomp( start, "to");
        chop(  fline, "to" );
        lbstart.push_back( std::atoi(start.c_str()) );
        lbend.push_back( std::atoi(fline.c_str()) );
      }
      else if ( tolower(fline).find("lbrange")!=std::string::npos ) {
        clean( fline, "\"" );
        clean( fline, " " );
        chop(  fline, "LBRange");
        chomp( fline, "/>" );
        chop(  fline, "Start=" );
        std::string start = fline; 
        chomp( start, "End");
        chop(  fline, "End=");
        lbstart.push_back( std::atoi(start.c_str()) );
        lbend.push_back( std::atoi(fline.c_str()) );
      }
      else break;
    }
        
    for ( unsigned  il=0 ; il<lbstart.size() ; il++ ) this->addRange( run, lbstart[il], lbend[il] );
    
      }
    }    
 
    std::cout << "lumiParser: read " << size() << " runs" << std::endl;
  }

setterse()

void lumiList::setterse ( bool b )

inlineinherited

Definition at line 45 of file lumiList.h.

{ m_terse=b; }

sort()

void lumiList::sort ( )

inlineinherited

sort the runs by the number of good lumi blocks

sort the vector

print out

Definition at line 83 of file lumiList.h.

              { 
    
    std::cout << "lumiList::sort() sorting ..." << std::endl; 
 
    std::vector< const grl_run*  > vec;
    
    const_iterator itr  = begin();
    
    while ( itr!=end() ) { 
      vec.push_back( &(itr->second) ); 
      ++itr;
    }

    std::sort(vec.begin(), vec.end(), grl_run::comparison );

 
    double total = 0;
    for ( unsigned i=vec.size() ; i-- ;  ) total += vec[i]->lbsize();
 
   
    double integral = 0;
    for ( unsigned i=0 ; i<vec.size() ; i++ ) {
 
      integral += vec[i]->lbsize();
 
      std::cout << i 
        << "\t" << int(100*(i+1.0)/vec.size()) 
        << "\t" << int(integral/total*1000)*0.1 
        << "\t" << *vec[i] << "\tfraction: " <<  vec[i]->lbsize()/total << std::endl;
 
    } 
  }

tail()

void lumiParser::tail ( std::string & s, const std::string & regex )

inlineprivate

Definition at line 143 of file lumiParser.h.

                                                    { 
    size_t pos = s.find( regex );
    while( pos!=std::string::npos ) { 
      s.erase( 0, pos+regex.size() );
      pos = s.find( regex );
    }
  }

tolower()

std::string lumiParser::tolower ( const std::string & s )

inlineprivate

Definition at line 166 of file lumiParser.h.

                                          { 
    std::string t = s;
    for ( unsigned i=0 ; i<t.size() ; i++ ) if ( t[i]>='A' && t[i]<='Z' ) t[i] -= 'A'-'a';  
    return t;
  }

toupper()

std::string lumiParser::toupper ( const std::string & s )

inlineprivate

Definition at line 159 of file lumiParser.h.

                                          { 
    std::string t = s;
    for ( unsigned i=0 ; i<t.size() ; i++ ) if ( t[i]>='a' && t[i]<='z' ) t[i] += 'A'-'a';  
    return t;
  }

Member Data Documentation

elements

T std::map< K, T >::elements

inherited

STL member.

keys

K std::map< K, T >::keys

inherited

STL member.

m_terse

bool lumiList::m_terse

privateinherited

Definition at line 120 of file lumiList.h.

---

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

• lumiParser.h