TriggerSelector.cc

Go to the documentation of this file.

// $Id: TriggerSelector.cc,v 1.8.4.1 2011/03/07 11:33:05 mommsen Exp $

#include "EventFilter/StorageManager/interface/TriggerSelector.h"

#include "FWCore/Framework/interface/TriggerNamesService.h"
#include "FWCore/Utilities/interface/RegexMatch.h"
#include "FWCore/MessageLogger/interface/MessageLogger.h"

#include <iostream>
#include <boost/regex.hpp>
#include <algorithm>
#include <cassert>

namespace stor
{

  //compatibility constructor

  TriggerSelector::TriggerSelector
  (
    Strings const& pathspecs,
    Strings const& names
  ):
  useOld_(true)
  {
    acceptAll_=false;
    eventSelector_.reset( new edm::EventSelector(pathspecs,names));
  }

  TriggerSelector::TriggerSelector
  (
    edm::ParameterSet const& config,
    Strings const& triggernames,
    bool old_
  ):
  useOld_(old_)
  {
    acceptAll_=false;
    if (old_) {
      //old mode forced
      eventSelector_.reset( new edm::EventSelector(config, triggernames));
      return;
    }
    if (!config.empty()) {

      //let's see if non empty TriggerSelector is present
      try {
    std::string myPath = trim(config.getParameter<std::string>("TriggerSelector"));
    if (!myPath.empty()) { 
      init(myPath, triggernames);
      return;
    }
      }
      catch(...) {}

      //now try with the SelectEvents 
      try {
    Strings paths;
    paths = config.getParameter<Strings>("SelectEvents");
    if (!paths.empty()) {
      useOld_=true;
      eventSelector_.reset( new edm::EventSelector(config, triggernames));
      return;
    }     
      }
      catch(...) {}
    }
    //if selection parameters aren't present, don't do selection
    //log
    acceptAll_=true;
  }

  TriggerSelector::TriggerSelector
  (
    std::string const & expression,
    Strings const& triggernames
  ):
  useOld_(false)
  {
    init (trim(expression),triggernames);
  }

  void
  TriggerSelector::init
  (
    std::string const& expression,
    Strings const& triggernames
  )
  {
    //debug_ = true;
    if (expression.empty())
    {
      acceptAll_ = true;
      return;
    }
    if (expression.size()==1 && expression.at(0)=='*') acceptAll_=true;
    else acceptAll_=false;

    //replace all possible alternate operators (.AND. and .OR.)
    {
      using namespace boost;
      std::string temp;
      temp = regex_replace( expression , regex(".AND."), "&&");
      expression_ = regex_replace( temp, regex(".and."), "&&");
      temp = regex_replace( expression_, regex(".OR."), "||"); 
      expression_ = regex_replace( temp, regex(".or."), "||");
    }

    //build decision tree
    masterElement_.reset( new TreeElement(expression_,triggernames));
  }

  /*
        Obsolete
  */
  std::vector<std::string>
  TriggerSelector::getEventSelectionVString(edm::ParameterSet const& pset)
  {
    return edm::EventSelector::getEventSelectionVString(pset);
  }

  bool TriggerSelector::acceptEvent(edm::TriggerResults const& tr) const
  {
    if (useOld_) {
      return eventSelector_->acceptEvent(tr);
    }

    if (acceptAll_) return true;
    
    return masterElement_->returnStatus(tr);
  }

  bool 
  TriggerSelector::acceptEvent
  (
    unsigned char const* array_of_trigger_results,
    int number_of_trigger_paths
  ) const
  {

    if (useOld_)
      return eventSelector_->acceptEvent(array_of_trigger_results,number_of_trigger_paths);

    if (acceptAll_) return true;

    // Form HLTGlobalStatus object to represent the array_of_trigger_results
    edm::HLTGlobalStatus tr(number_of_trigger_paths);
    int byteIndex = 0;
    int subIndex  = 0;
    for (int pathIndex = 0; pathIndex < number_of_trigger_paths; ++pathIndex)
    {
      int state = array_of_trigger_results[byteIndex] >> (subIndex * 2);
      state &= 0x3;
      edm::HLTPathStatus pathStatus(static_cast<edm::hlt::HLTState>(state));
      tr[pathIndex] = pathStatus;
      ++subIndex;
      if (subIndex == 4)
      { ++byteIndex;
    subIndex = 0;
      }
    }
    // Now make the decision, based on the HLTGlobalStatus tr,
    // which we have created from the supplied array of results
    return masterElement_->returnStatus(tr);
  }


  TriggerSelector::TreeElement::TreeElement
  (
    std::string const& inputString,
    Strings const& tr,
    TreeElement* parentElement
  ) :
    op_(NonInit),
    trigBit_(-1)
  {
    std::string str_ = trim(inputString);
    children_.clear();
    parent_ = parentElement;

    size_t offset_=0;
    bool occurrences_=false;

    if (str_.empty())
      throw edm::Exception(edm::errors::Configuration)
        << "Syntax Error (empty element)" << std::endl;

    static const size_t bopsSize_ = 2;
    static const std::string binaryOperators_[bopsSize_] = {"||","&&"};

    for (size_t opr=0;opr<bopsSize_;opr++) {
      bool exitloop_=false;
      while(!exitloop_) {
    size_t t_end_;

    std::string tmpStr = str_.substr(offset_);
    t_end_ = tmpStr.find(binaryOperators_[opr]);
    if (debug_) std::cout << "offset: " << offset_ << " length: " << t_end_ <<" string: " << tmpStr << std::endl;

    if (t_end_ == std::string::npos) {
      //right side element
      if (occurrences_) children_.push_back(new TreeElement(tmpStr,tr,this));
      break;
    }
    t_end_ += offset_;
    if (t_end_==0 || t_end_+2>=str_.size()) 
      throw edm::Exception(edm::errors::Configuration) << "Syntax Error (operator is not unary)\n";
    else {
      //count bracket in preceeding part
      int brackets_=0;
      for (size_t k=offset_;k<t_end_;k++) {
        if (str_.at(k)=='(') brackets_++;
        if (str_.at(k)==')') brackets_--;
        if (brackets_<0)
          throw edm::Exception(edm::errors::Configuration)
                << "Syntax Error (brackets)\n";
      }
      if (brackets_==0) {
        std::string next = str_.substr(offset_,t_end_-offset_);
        children_.push_back(new TreeElement(next,tr,this));
        occurrences_=true;
        offset_ = t_end_+2;
      }
      else {
        //operator is inside brackets, find another
        int bracketcnt_ = 0;
        for (size_t k=offset_;true;k++) {
          if (k>=str_.size()) {
        if (bracketcnt_!=0)
          throw edm::Exception(edm::errors::Configuration)
                    << "Syntax Error (brackets)\n";
        exitloop_=true;
        if (occurrences_) {
          children_.push_back(new TreeElement(str_.substr(offset_),tr,this));
        }
        break;
          }
          //look for another operator
          if (k>=t_end_+2 && bracketcnt_==0) {
        std::string temp = str_.substr(k);
        size_t pos = temp.find(binaryOperators_[opr]);
        if (pos == std::string::npos) {
          exitloop_=true;
          if (occurrences_) {
            children_.push_back(new TreeElement(str_.substr(offset_),tr,this));
          }
          break;
        }
        else {
          int brcount_ = 0;
          for (size_t s=0;s<pos;s++) {
            //counting check of brackets from last position to operator
            if (temp.at(pos)=='(') brcount_++;
            if (temp.at(pos)==')') brcount_--;
            if (brcount_<0)
              throw edm::Exception(edm::errors::Configuration)
            << "Syntax error (brackets)\n";
          }
          if (brcount_!=0) 
            throw edm::Exception(edm::errors::Configuration)
              << "Syntax error (brackets)\n";

          children_.push_back(new TreeElement(str_.substr(offset_,pos+k),tr,this));
          offset_=k+pos+2;
          occurrences_=true;
          if (offset_>=str_.size())
            throw edm::Exception(edm::errors::Configuration) 
              << "Syntax Error (operator is not unary)\n";
          break;
        }

          }


          if (str_.at(k)=='(') bracketcnt_++;
          if (str_.at(k)==')') bracketcnt_--;

        }
      }
    }

      }
      if (occurrences_) {
    if (opr==0) op_=OR;
    else        op_=AND;
    return;
      }
    }

    if (str_.empty()) {
      op_=AND;
      if (debug_) std::cout << "warning: empty element (will return true)"<< std::endl;
      return;
    }

    if (str_.at(0)=='!') {
      op_=NOT;
      std::string next = str_.substr(1);
      children_.push_back(new TreeElement(next,tr,this));
      return;
    }
    size_t beginBlock_ =str_.find('(');
    size_t endBlock_ =str_.rfind(')');
    bool found_lbracket = (beginBlock_ != std::string::npos);
    bool found_rbracket = (endBlock_ != std::string::npos);

    if (found_lbracket != found_rbracket) {
      throw edm::Exception(edm::errors::Configuration) << "Syntax Error (brackets)\n";
    }
    else if (found_lbracket && found_rbracket)
    {
      if (beginBlock_>=endBlock_) {
        throw edm::Exception(edm::errors::Configuration) << "Syntax Error (brackets)\n";
      }
      if (beginBlock_!=0 || endBlock_!=str_.size()-1)
    throw edm::Exception(edm::errors::Configuration) << "Syntax Error (invalid character)\n";

      std::string next = str_.substr(beginBlock_+1,endBlock_-beginBlock_-1);

      children_.push_back(new TreeElement(next,tr,this));
      op_=BR; //a bracket
      return;
    }
    else if (!found_lbracket && !found_rbracket) //assume single trigger or wildcard (parsing)
    {
      bool ignore_if_missing = true;
      size_t chr_pos = str_.find("@");
      if (chr_pos!= std::string::npos) {
    ignore_if_missing=false;
    str_=str_.substr(0,chr_pos);
      }

      std::vector<Strings::const_iterator> matches = edm::regexMatch(tr,str_);
      if (matches.empty()) {
    if (!ignore_if_missing)// && !edm::is_glob(str_)) 
      throw edm::Exception(edm::errors::Configuration) << "Trigger name (or match) not present" << std::endl;
    else { 
      if (debug_)
        std::cout << "TriggerSelector: Couldn't match any triggers from: "<< str_<< std::endl
          << "                 Node will not be added "<< std::endl;
      op_=OR;
      return;
    }
      }
      if (matches.size()==1) {
    //Single Trigger match
    trigBit_ = distance(tr.begin(),matches[0]);
    if (debug_) std::cout << "added trigger path: " << trigBit_ << std::endl;
    return;
      }
      if (matches.size()>1) {
    op_=OR;
    for (size_t l=0;l<matches.size();l++)
      children_.push_back(new TreeElement(*(matches[l]),tr,this));
      }
    }
  }

  std::string TriggerSelector::trim(std::string input) 
  {
    if (!input.empty())
    {
      std::string::size_type pos = input.find_first_not_of(" ");
      if (pos != std::string::npos)
    input.erase(0,pos);

      pos = input.find_last_not_of(" ");
      if (pos != std::string::npos)
    input.erase(pos+1);
    }
    return input;
  } 

  std::string TriggerSelector::makeXMLString(std::string const& input)
  {
    std::string output;
    if (!input.empty()) {
      for (size_t pos=0;pos<input.size();pos++) {
    char ch = input.at(pos);
    if (ch=='&') output.append("&amp;");
    else output.append(1,ch);
      }
    }
    return output;
  }


  bool TriggerSelector::TreeElement::returnStatus
  (
    edm::HLTGlobalStatus const& trStatus
  ) const 
  {

    if (children_.empty()) {

      if (op_==OR  || op_==NOT) return false;
      if (op_==AND || op_==BR) return true;

      if (trigBit_<0 || (unsigned int)trigBit_>=trStatus.size())
    throw edm::Exception(edm::errors::Configuration)
          << "Internal Error: array out of bounds " << std::endl;

      if ((trStatus[trigBit_]).state() == edm::hlt::Pass) return true;
      //else if ((trStatus[trigBit]).state() == edm::hlt::Fail) return false;

      return false;
    }
    if (op_==NOT) { //NEGATION
      return !children_[0]->returnStatus(trStatus);
    }
    if (op_==BR) { //BRACKET
      return children_[0]->returnStatus(trStatus);
    } 
    if (op_==AND) { //AND
      bool status = true;
      for (size_t i=0;i<children_.size();i++) status = status && children_[i]->returnStatus(trStatus);
      return status;
    }
    else if (op_==OR) { //OR
      bool status = false;
      for (size_t i=0;i<children_.size();i++) status = status || children_[i]->returnStatus(trStatus);
      return status;
    }
    throw edm::Exception(edm::errors::Configuration) << "Internal error: reached end of returnStatus(...)  op:state= " << op_ << std::endl;
    return false;
  }


  TriggerSelector::TreeElement::~TreeElement()
  {
    for (std::vector<TreeElement*>::iterator it=children_.begin();it!=children_.end();it++)
      delete *it;
    children_.clear();
  }

} // namespace stor