StiHitContainer.h

//StiHitContainer.h
//M.L. Miller (Yale Software)
//03/01

#ifndef StiHitContainer_HH
#define StiHitContainer_HH

#include <cassert>
#include <vector>
#include <map>
#include <time.h>
#include <Stiostream.h>
#include "Stiostream.h"

#include "Sti/Base/Named.h"
#include "Sti/Base/Described.h"
#include "Sti/Base/Filter.h"
#include "Sti/Base/Factory.h"
#include "Sti/StiMapUtilities.h"
#include "Sti/StiHit.h"
#include "Sti/StiDetector.h"
#include "Sti/StiKalmanTrackNode.h"
using namespace std;

class VectorAndEnd
{       
 private:
    bool fEffectiveEndValid;
    vector<StiHit*>::iterator theEffectiveEnd;
protected:
    friend class StiHitContainer;
    vector<StiHit*>::iterator TheEffectiveEnd() { 
       return fEffectiveEndValid ? theEffectiveEnd
             : theHitVec.end();
    }
 public:
    VectorAndEnd();
    void TestId(int id);
    vector<StiHit*> theHitVec;
    int  fId;
    static int fIdCounter;
    void clear();
    void setEnd(vector<StiHit*>::iterator &endHit) {
      theEffectiveEnd    = endHit;
      fEffectiveEndValid = true;
    }
    void invalidateEnd(){ fEffectiveEndValid = false; }
    vector<StiHit*>  &hits() { return theHitVec; }
    const vector<StiHit*>  &hits() const { return theHitVec; }
    size_t  size() const  { return theHitVec.size(); }
    void push_back(StiHit *hit) { theHitVec.push_back(hit); }
    vector<StiHit*>::iterator begin() { return theHitVec.begin() ; }
 };
typedef map<HitMapKey, VectorAndEnd, MapKeyLessThan> HitMapToVectorAndEndType;

typedef HitMapToVectorAndEndType::value_type HitMapToVectorAndEndTypeValType;

class StiHitContainer : public Named, public Described
{
public:
    
  StiHitContainer(const string & name, const string & description, Factory<StiHit> *factory);
  virtual ~StiHitContainer();
  virtual void add(StiHit*);
  virtual unsigned int size() const;
  virtual void reset();
  virtual void unset(){;}
  virtual void clear();
  //Sort all of the hits in the container.
  virtual void sortHits();
  void setMaxTimes(int nTimes);
  vector<StiHit*> & getHits();
  vector<StiHit*> & getHits(Filter<StiHit> & filter);
  vector<StiHit*> & getHits(StiHit& ref, double dY, double dZ, bool fetchAll=false);
  vector<StiHit*> & getHits(double position, double refAngle, double y, double z, 
                            double dY, double dZ, bool fetchAll=false);
  vector<StiHit*> & getHits(StiKalmanTrackNode &, bool fetchAll=false);
  vector<StiHit*> & getHits(double refangle, double position);
  vector<StiHit*> & getHits(const StiDetector*);
  vector<StiHit*>::iterator hitsBegin(const StiDetector*);
  vector<StiHit*>::iterator hitsEnd(const StiDetector*);
  const HitMapToVectorAndEndType& hits() const;
  HitMapToVectorAndEndType& hits();
  StiHit * getNearestHit(StiHit& ref, double dY, double dZ, bool fetchAll=false);
  StiHit * getNearestHit(double position, double refAngle, double y, double z, 
                         double dY, double dZ, bool fetchAll=false);
  Factory<StiHit> * getHitFactory();
  StiHit * getHit();
  bool hasKey(double refangle, double position);
  bool hasDetector(const StiDetector* layer);
 protected:
  // Utility key used in hit retrieval (avoid constructor call per search)
  HitMapToVectorAndEndType::key_type _key; 
  // Utility hit used as a minimum position in searches
  StiHit _minPoint;
  // Utility hit used as a maximum position in searches
  StiHit _maxPoint;
  // Utility hit used as the reference in searches
  StiHit _utilityHit;
  // Utility iterator to mark the position of a hit vector (avoid constructor call per search)
  vector<StiHit*>::iterator _start;
  // Utility iterator to mark the position of a hit vector (avoid constructor call per search)
  vector<StiHit*>::iterator _stop;
  // Utility hit vector used to return hits  (avoid constructor call per search)
  vector<StiHit*> _selectedHits; 
  // Actual Hit container used for storage of all hits
  HitMapToVectorAndEndType _map; 
  Factory<StiHit> * _hitFactory;
  // Utility ostream operator
  friend ostream& operator<<(ostream&, const StiHitContainer&);

 private:
  StiHitContainer();
};

inline const HitMapToVectorAndEndType& StiHitContainer::hits() const 
{
  return _map;
}

inline HitMapToVectorAndEndType& StiHitContainer::hits()
{
  return _map;
}

inline vector<StiHit*> & StiHitContainer::getHits(double position, double refAngle,double y, double z, 
                                                  double dY, double dZ, bool fetchAll)
{
  _utilityHit.set(position,refAngle,y,z);
  return getHits(_utilityHit,dY,dZ,fetchAll);
}

inline vector<StiHit*> & StiHitContainer::getHits(StiKalmanTrackNode & node, bool fetchAll)
{
  _utilityHit.set(node.getRefPosition(),node.getLayerAngle(),node.getY(),node.getZ());
  return getHits(_utilityHit,node.getWindowY(),node.getWindowZ(), fetchAll);
}

inline vector<StiHit*>& StiHitContainer::getHits(double refangle, double position)
{
    _key.refangle = refangle;
    _key.position = position; 
    assert(_map.find(_key) != _map.end());
    return _map[_key].theHitVec;
}
inline bool StiHitContainer::hasKey(double refangle, double position)
{
    HitMapToVectorAndEndType::key_type key; 
    key.refangle = refangle;
    key.position = position; 
    return _map.find(key) != _map.end();
} 
inline bool StiHitContainer::hasDetector(const StiDetector* layer)
{  
   double refangle = layer->getPlacement()->getLayerAngle();
   double position = layer->getPlacement()->getLayerRadius();
   return  hasKey(refangle,position);  
}
inline vector<StiHit*>& StiHitContainer::getHits(const StiDetector* layer)
{
    _key.refangle = layer->getPlacement()->getLayerAngle();
    _key.position = layer->getPlacement()->getLayerRadius();
    assert(_map.find(_key) != _map.end());
    return _map[_key].theHitVec;
}


inline StiHit * StiHitContainer::getNearestHit(double position, double refAngle, double y, double z, 
                                               double dY, double dZ, bool fetchAll)
{
  _utilityHit.set(position,refAngle,y,z);
  return getNearestHit(_utilityHit,dY,dZ,fetchAll);
}

inline Factory<StiHit> * StiHitContainer::getHitFactory()
{  
  assert(_hitFactory);
  return _hitFactory;
}

inline StiHit * StiHitContainer::getHit()
{
  StiHit * hit = getHitFactory()->getInstance();
  hit->reset();
  return hit;
}

ostream& operator<<(ostream&, const vector<StiHit*>&);
ostream& operator<<(ostream&, const StiHitContainer&);





#endif