TrackerDetIdSelector.h

Go to the documentation of this file.

#ifndef FastSimulation_TrackingRecHitProducer_TrackerDetIdSelector_H
#define FastSimulation_TrackingRecHitProducer_TrackerDetIdSelector_H

#include "DataFormats/DetId/interface/DetId.h"
#include "DataFormats/TrackerCommon/interface/TrackerTopology.h"
#include "FWCore/Utilities/interface/Exception.h"


#include <boost/config/warning_disable.hpp>
#include <boost/spirit/include/qi.hpp>
#include <boost/spirit/include/qi_rule.hpp>
#include <boost/lambda/lambda.hpp>
#include <boost/spirit/include/phoenix.hpp>
#include <boost/phoenix/bind/bind_member_function.hpp>
#include <boost/spirit/include/qi_grammar.hpp>

#include <iostream>
#include <cstdlib>
#include <typeinfo>
#include <functional>
#include <unordered_map>

struct BinaryOP;
struct UnaryOP;
struct Nil {};

struct ExpressionAST
{

    typedef
        boost::variant<
          Nil,
          int,
          std::string,
          boost::recursive_wrapper<ExpressionAST>,
          boost::recursive_wrapper<BinaryOP>,
          boost::recursive_wrapper<UnaryOP>
        >
    Type;

    ExpressionAST():
        expr(Nil())
    {
    }

    template <typename Expr>
    ExpressionAST(Expr const& expr):
        expr(expr)
    {
    }

    int evaluate(const DetId& detId, const TrackerTopology& trackerTopology) const;

    ExpressionAST& operator!();

    Type expr;
};

ExpressionAST operator>(ExpressionAST const& lhs, ExpressionAST const& rhs);
ExpressionAST operator>=(ExpressionAST const& lhs, ExpressionAST const& rhs);
ExpressionAST operator==(ExpressionAST const& lhs, ExpressionAST const& rhs);
ExpressionAST operator<=(ExpressionAST const& lhs, ExpressionAST const& rhs);
ExpressionAST operator<(ExpressionAST const& lhs, ExpressionAST const& rhs);
ExpressionAST operator!=(ExpressionAST const& lhs, ExpressionAST const& rhs);
ExpressionAST operator&&(ExpressionAST const& lhs, ExpressionAST const& rhs);
ExpressionAST operator||(ExpressionAST const& lhs, ExpressionAST const& rhs);

struct BinaryOP
{
    enum class OP
    {
        GREATER, GREATER_EQUAL, EQUAL, LESS_EQUAL, LESS, NOT_EQUAL, AND, OR
    } op;
    ExpressionAST left;
    ExpressionAST right;

    BinaryOP(OP op, ExpressionAST const& left, ExpressionAST const& right):
        op(op),
        left(left),
        right(right)
    {
    }

    int evaluate(const DetId& detId, const TrackerTopology& trackerTopology) const
    {
        switch(op)
        {
            case OP::GREATER:
                return left.evaluate(detId,trackerTopology) > right.evaluate(detId,trackerTopology);
            case OP::GREATER_EQUAL:
                return left.evaluate(detId,trackerTopology) >= right.evaluate(detId,trackerTopology);
            case OP::EQUAL:
                return left.evaluate(detId,trackerTopology) == right.evaluate(detId,trackerTopology);
            case OP::LESS_EQUAL:
                return left.evaluate(detId,trackerTopology) <= right.evaluate(detId,trackerTopology);
            case OP::LESS:
                return left.evaluate(detId,trackerTopology) < right.evaluate(detId,trackerTopology);
            case OP::NOT_EQUAL:
                return left.evaluate(detId,trackerTopology) != right.evaluate(detId,trackerTopology);
            case OP::AND:
                return left.evaluate(detId,trackerTopology) && right.evaluate(detId,trackerTopology);
            case OP::OR:
                return left.evaluate(detId,trackerTopology) || right.evaluate(detId,trackerTopology);
        }
        return 0;
    }
};

struct UnaryOP
{
     enum class OP
     {
         NEG
     } op;
     ExpressionAST subject;
     UnaryOP(OP op, ExpressionAST const& subject):
         op(op),
         subject(subject)
     {
     }

     int evaluate(const DetId& detId, const TrackerTopology& trackerTopology) const
     {
        switch (op)
        {
            case OP::NEG:
                return !subject.evaluate(detId,trackerTopology);
        }
        return 0;
     }

};

class TrackerDetIdSelector
{
    private:
        const DetId& _detId;
        const TrackerTopology& _trackerTopology;

    public:
        typedef std::function<int(const TrackerTopology& trackerTopology, const DetId&)> DetIdFunction;
        typedef std::unordered_map<std::string, DetIdFunction> StringFunctionMap;
        const static StringFunctionMap functionTable;

        TrackerDetIdSelector(const DetId& detId, const TrackerTopology& trackerTopology):
            _detId(detId),
            _trackerTopology(trackerTopology)
        {
        }

        bool passSelection(std::string selectionStr) const;
};

class Accessor:
    public boost::static_visitor<int>
{
    private:
        const DetId& _detId;
        const TrackerTopology& _trackerTopology;
    public:
        Accessor(const DetId& detId, const TrackerTopology& trackerTopology):
            _detId(detId),
            _trackerTopology(trackerTopology)
        {
        }

        int operator()(Nil i) const
        {
            throw cms::Exception("FastSimulation/TrackingRecHitProducer/TrackerDetIdSelector","while evaluating a DetId selection a symbol was not set");
        }
        int operator()(const int& i) const
        {
            return i;
        }
        int operator()(const std::string& s) const
        {
            TrackerDetIdSelector::StringFunctionMap::const_iterator it = TrackerDetIdSelector::functionTable.find(s);
            int value = 0;
            if (it != TrackerDetIdSelector::functionTable.cend())
            {
                value = (it->second)(_trackerTopology,_detId);
                //std::cout<<"attr="<<s<<", value="<<value<<std::endl;
            }
            else
            {
                //std::cout<<"attr="<<s<<" unknown"<<std::endl;
                std::string msg = "error while parsing DetId selection: named identifier '"+s+"' not known. Possible values are: ";
                for (const TrackerDetIdSelector::StringFunctionMap::value_type& pair: TrackerDetIdSelector::functionTable)
                {
                    msg+=pair.first+",";
                }
                throw cms::Exception("FastSimulation/TrackingRecHitProducer/TrackerDetIdSelector",msg);
            }
            return value;
        }
        int operator()(const ExpressionAST& ast) const
        {
            return ast.evaluate(_detId,_trackerTopology);
        }
        int operator()(const BinaryOP& binaryOP) const
        {
            return binaryOP.evaluate(_detId,_trackerTopology);
        }
        int operator()(const UnaryOP& unaryOP) const
        {
            return unaryOP.evaluate(_detId,_trackerTopology);
        }
};





struct WalkAST
{
    Accessor _acc;
    
    WalkAST(const DetId& detId, const TrackerTopology& trackerTopology):
        _acc(detId,trackerTopology)
    {
    }

    typedef void result_type;

    void operator()() const {}
    void operator()(int n) const { std::cout << n; std::cout<<" ["<<_acc(n)<<"] "; }
    void operator()(std::string str) const { std::cout << str; std::cout<<" ["<<_acc(str)<<"] "; }
    void operator()(ExpressionAST const& ast) const
    {
        boost::apply_visitor(*this, ast.expr);
        std::cout<<" [="<<_acc(ast)<<"] ";
    }

    void operator()(BinaryOP const& expr) const
    {
        std::cout << "(";
        boost::apply_visitor(*this, expr.left.expr);
        switch(expr.op)
        {
            case BinaryOP::OP::GREATER:
                std::cout<<" > ";
                break;
            case BinaryOP::OP::GREATER_EQUAL:
                std::cout<<" >= ";
                break;
            case BinaryOP::OP::EQUAL:
                std::cout<<" == ";
                break;
            case BinaryOP::OP::LESS_EQUAL:
                std::cout<<" <= ";
                break;
            case BinaryOP::OP::LESS:
                std::cout<<" < ";
                break;
            case BinaryOP::OP::NOT_EQUAL:
                std::cout<<" != ";
                break;
            case BinaryOP::OP::AND:
                std::cout<<" && ";
                break;
            case BinaryOP::OP::OR:
                std::cout<<" || ";
                break;
        }
        boost::apply_visitor(*this, expr.right.expr);
        std::cout << ')';
    }

    void operator()(UnaryOP const& expr) const
    {
        switch (expr.op)
        {
            case UnaryOP::OP::NEG:
                std::cout<<" !(";
                break;
        }
        boost::apply_visitor(*this, expr.subject.expr);
        std::cout << ')';
    }
};

template <typename ITERATOR>
struct TrackerDetIdSelectorGrammar:
    boost::spirit::qi::grammar<
        ITERATOR,
        ExpressionAST(),
        boost::spirit::ascii::space_type,
        boost::spirit::qi::locals<ExpressionAST>
    >
{
    boost::spirit::qi::rule<
        ITERATOR,
        std::string(),
        boost::spirit::ascii::space_type
    > identifierFctRule;

    boost::spirit::qi::rule<
                ITERATOR,
                ExpressionAST(),
                boost::spirit::ascii::space_type
    > identifierRule, expressionRule;

    boost::spirit::qi::rule<
        ITERATOR,
        ExpressionAST(),
        boost::spirit::ascii::space_type,
        boost::spirit::qi::locals<ExpressionAST>
    >  comboRule;


    TrackerDetIdSelectorGrammar():
        TrackerDetIdSelectorGrammar::base_type(comboRule)
    {
        namespace qi = boost::spirit::qi;
        namespace ascii = boost::spirit::ascii;
        namespace phoenix = boost::phoenix;

        identifierFctRule =
            qi::lexeme[+qi::alpha[qi::_val+=qi::_1]];

        identifierRule =
            (qi::true_[qi::_val=1] | qi::false_[qi::_val=0]) |
            (qi::int_[qi::_val=qi::_1]) |
            identifierFctRule[qi::_val=qi::_1];

        comboRule =
            (expressionRule[qi::_a=qi::_1] >>
             *(
                 (qi::lit("&&") >> expressionRule[qi::_a=qi::_a && qi::_1]) |
                 (qi::lit("||") >> expressionRule[qi::_a=qi::_a || qi::_1])
             ))[qi::_val=qi::_a];

        expressionRule =
            qi::lit("(") >> comboRule[qi::_val=qi::_1] >> qi::lit(")") |
            (identifierRule >> qi::lit(">") >> identifierRule)[qi::_val=qi::_1>qi::_2] |
            (identifierRule >> qi::lit(">=") >> identifierRule)[qi::_val=qi::_1>=qi::_2] |
            (identifierRule >> qi::lit("<") >> identifierRule)[qi::_val=qi::_1<qi::_2] |
            (identifierRule >> qi::lit("<=") >> identifierRule)[qi::_val=qi::_1<=qi::_2] |
            (identifierRule >> qi::lit("==") >> identifierRule)[qi::_val=qi::_1==qi::_2] |
            (identifierRule >> qi::lit("!=") >> identifierRule)[qi::_val=qi::_1!=qi::_2] |
            identifierRule[qi::_val=qi::_1];
    }

};


bool TrackerDetIdSelector::passSelection(std::string selectionStr) const
{
    std::string::const_iterator begin = selectionStr.cbegin();
    std::string::const_iterator end = selectionStr.cend();


    TrackerDetIdSelectorGrammar<std::string::const_iterator> grammar;
    ExpressionAST exprAST;

    bool success = boost::spirit::qi::phrase_parse(begin,end, grammar, boost::spirit::ascii::space, exprAST);
    if (begin!=end)
    {
        throw cms::Exception("FastSimulation/TrackingRecHitProducer/TrackerDetIdSelector",
            "parsing selection '"+selectionStr+"' failed at "+std::string(selectionStr.cbegin(), begin)+"^^^"+std::string(begin, end));
    }
    if (!success)
    {
        throw cms::Exception("FastSimulation/TrackingRecHitProducer/TrackerDetIdSelector","parsing selection '"+selectionStr+"' failed.");
    }
    /* Comment out for debugging
    WalkAST walker(_detId,_trackerTopology);
    walker(exprAST);
    std::cout<<std::endl;
    */
    return exprAST.evaluate(_detId,_trackerTopology);

}



int ExpressionAST::evaluate(const DetId& detId, const TrackerTopology& trackerTopology) const
{
    return boost::apply_visitor(Accessor(detId,trackerTopology),this->expr);
}

#endif