Sti/StiDetectorContainer.h

//StiDetectorContainer.h
//M.L. Miller (Yale Software)
//02/02/01

#ifndef StiDetectorContainer_HH
#define StiDetectorContainer_HH

#include <vector>
using std::vector;
#include <map>
using std::map;

#include "Sti/Base/Named.h"
#include "Sti/Base/Described.h"
#include "Sti/Base/Factory.h"
#include "Sti/StiDetector.h"
#include "Sti/StiDetectorBuilder.h"
#include "Sti/StiMasterDetectorBuilder.h"
#include "Sti/StiCompositeLeafIterator.h"
#include "Sti/StiMapUtilities.h"
#include "Sti/StiCompositeTreeNode.h"

using namespace std;
using std::vector;
using std::map;
template <class FILTERED> class Filter;

class StiDetectorContainer : public Named, public Described
{
 public:
  StiDetectorContainer(const string & name, const string & description,StiMasterDetectorBuilder *);
  virtual ~StiDetectorContainer();
  void initialize();
  virtual void build(StiDetectorBuilder * builder);
  const StiDetectorNode* root() const;
  void add(StiDetector* det);
  void reset();
  void unset(){;}
  StiDetector* operator*() const;
  StiDetector* getCurrentDetector() const;
#if 0
  bool moveToNextRegion();
  bool moveToPreviousRegion();
  bool moveOut();
#endif
  bool moveIn();
#if 0
  void movePlusPhi();
  void moveMinusPhi();
#endif
  void setToDetector(const StiDetector* layer);
  void setToDetector(double position);
  void setToDetector(double position, double angle);
  vector<StiDetector*> & getDetectors();
  vector<StiDetector*> & getDetectors(Filter<StiDetector> & filter);
  StiMasterDetectorBuilder * getDetectorBuilder();
  vector<StiDetector*>::const_iterator  begin() const;
  vector<StiDetector*>::const_iterator  end() const;
  vector<StiDetector*>::iterator begin();
  vector<StiDetector*>::iterator end();

  vector<StiDetectorNode*>::const_iterator beginRadial(const StiDetector * detector) 
    {
      setToDetector(detector);
      return mradial_it;//(*mregion)->begin();
    }
  
  vector<StiDetectorNode*>::const_iterator endRadial() 
    {
      return (*mregion)->end();
    }  

  vector<StiDetectorNode*>::reverse_iterator rbeginRadial(const StiDetector * detector) 
    {
      setToDetector(detector);
      vector<StiDetectorNode*>::reverse_iterator it;
      for (it =(*mregion)->rbegin(); 
           it != (*mregion)->rend(); 
           ++it)
        {
          //if they point to the same node, we are done...
          if (*it==*mradial_it) break;
        }
      return  it;
    }

  StiDetectorNodeVector::const_reverse_iterator rendRadial() 
    {
      return (*mregion)->rend();
    }

  StiDetectorNodeVector::const_iterator beginPhi(StiDetectorNodeVector::const_iterator &radialIterator) 
    {
      //cout << " beginPhi: size:"<< (*radialIterator)->getChildCount()<<endl;
      return (*radialIterator)->begin();
    }
  StiDetectorNodeVector::const_iterator endPhi(StiDetectorNodeVector::const_iterator &radialIterator) 
    {
      return (*radialIterator)->end();
    }
  StiDetectorNodeVector::const_iterator beginPhi(StiDetectorNodeVector::const_reverse_iterator &radialIterator) 
    {
      //cout << " beginPhi: size:"<< (*radialIterator)->getChildCount()<<endl;
      return (*radialIterator)->begin();
    }
  StiDetectorNodeVector::const_iterator endPhi(StiDetectorNodeVector::const_reverse_iterator &radialIterator) 
    {
      return (*radialIterator)->end();
    }

private:
    bool setPhi(const StiOrderKey& oldOrder);
    // Utility function for moveIn(), moveOut() functions
    bool setPhiIterator(double oldOrder, unsigned int oldNDaughters,
                        StiDetectorNodeVector::difference_type oldDistance);
    StiDetectorNode* mroot;
    StiCompositeLeafIterator<StiDetector>* mLeafIt;
    StiDetectorNodeVector::const_iterator mregion; //Test (MLM)
    //StiDetectorNode* mregion;
    StiDetectorNodeVector::const_iterator mradial_it;
    StiDetectorNodeVector::const_iterator mphi_it;
    void setToLeaf(StiDetectorNode* node);
    vector<StiDetector *> _sortedDetectors;
    vector<StiDetector *> _selectedDetectors;
    StiMasterDetectorBuilder * _masterDetectorBuilder;
};


class RPhiLessThan
{
 public:
  bool operator()(const StiDetector* lhs, const StiDetector* rhs);
};

inline const StiDetectorNode* StiDetectorContainer::root() const
{
    return mroot;
}

inline StiMasterDetectorBuilder * StiDetectorContainer::getDetectorBuilder()
{
  return _masterDetectorBuilder;
}

#endif

---