In This Package:

HistorianCustomRules.h

Go to the documentation of this file.

#ifndef HISTORIANCUSTOMRULES_H
#define HISTORIANCUSTOMRULES_H


#include "RuleParser/RuleFactory.h"
#include "RuleParser/Rules.h"
#include <DetDesc/IDetectorElement.h>
#include <DetDesc/IGeometryInfo.h>
#include <iostream>

template<class Q>
struct DetElemContainsRuleFactory : public RuleParser::RuleFactory
{
  DetElemContainsRuleFactory(Q* caller) : mCaller(caller) {};
  RuleParser::Rule* createRule(
                           const RuleParser::ParameterDescription& paramter, 
                           int operation,                  
                           const std::string& value,       
                           bool param_on_left              
                           );
   Q* mCaller;
};

template<class Q>
class DetElemContainsRule : public RuleParser::Rule
{
  public:
  DetElemContainsRule(std::string n, const IDetectorElement* value) 
          : Rule(n) 
          , mValue(value) {};
  virtual ~DetElemContainsRule() {};
  virtual bool select(const RuleParser::Queriable* thing); 
  private:
  const IDetectorElement* mValue;
};

// Template code follows.

template<class Q>
bool DetElemContainsRule<Q>::select(const RuleParser::Queriable* thing)
 {
   const Q* q = dynamic_cast<const Q*>(thing);
   assert(q && "Was given the wrong kind of Queriable!");
   const IDetectorElement* curElement = q->getDetectorElement();
   if(!curElement) return false;
   if(!mValue) return false;
   // The problem with this method is that parentIDetectorElement() seems to crash.
   // bool done = false;
   // while(!done) {
   //   if(curElement == mValue) return true;
   //   if(curElement == 0) return false;
   //   curElement = curElement->parentIDetectorElement();
   // }
   const IGeometryInfo* curGeo = curElement->geometry();
   const IGeometryInfo* valGeo = mValue->geometry();
   ILVolume::ReplicaPath dummy;
   while(true){
     if(!curGeo) break;  // We got to the top of the tree and never hit the Value
     if(curGeo == valGeo) return true; // The value matches a parent of the current position.. it's contained
     IGeometryInfo* nextGeo = 0;
     curGeo->location(nextGeo, dummy); 
     curGeo = nextGeo;  // Ok, move up a level and check again.
   }
   return false;
}




template<class Q>
RuleParser::Rule* DetElemContainsRuleFactory<Q>::createRule(
                 const RuleParser::ParameterDescription& parameter,
                 int operation,                  
                 const std::string& value,       
                 bool /*param_on_left*/          
                )
{
  
  // Go find the data object we want to compare to.
  DataObject* d;
  mCaller->detSvc()->retrieveObject(value,d);
  const IDetectorElement* valueDetElem 
    = dynamic_cast<const IDetectorElement*>(d);
  
  if(!valueDetElem){
    mCaller->err() << "DetElemContainsRuleFactory: Can't build DetElemContainsRule because given value (" 
      << value << ") doesn't correspond to a known IDetectorElement object." << endreq;
    assert(0);
  }
  
  std::string name = parameter.name() + " " + parameter.operators()[operation] + " " + valueDetElem->name();
  return new DetElemContainsRule<Q>(name,valueDetElem);
}



#endif /* CUSTOMRULES_H */

---