Sti/StiDetector.h

#ifndef STI_DETECTOR_H
#define STI_DETECTOR_H
#include <vector>
#include <string>
#include <math.h>
#include "Stiostream.h"
using std::string;
#include "Sti/Base/Named.h"
#include "Sti/StiPlacement.h"
#include "StiIsActiveFunctor.h"
#include "StDetectorDbMaker/StiTrackingParameters.h"

class StiMaterial;
class StiShape;
template<class T> class StiCompositeTreeNode;
class StiHitErrorCalculator;
class StiElossCalculator;

class StiDetector : public Named
{
    
public:

  friend class StiHit;

    // con/destructor
    StiDetector();
    virtual ~StiDetector();
    void reset();
    void unset(){;}
    
    // accessors
    bool isOn() const                   { return on;}
    inline bool isActive(double dYlocal, double dZlocal) const {return (*isActiveFunctor)(dYlocal, dZlocal);}
    inline bool isActive()                               const {return isActiveFunctor->isActive();}
    bool isContinuousMedium() const     { return continuousMedium; }
    bool isDiscreteScatterer() const    { return discreteScatterer; }

    StiMaterial* getGas() const         { return gas; }
    StiMaterial* getMaterial() const    { return material; }

    StiShape* getShape() const { return shape; }
    StiPlacement* getPlacement() const  { return placement; }

    StiIsActiveFunctor* getIsActiveFunctor() {return isActiveFunctor;}

    // mutators
    void setIsOn(bool val) {on = val;}
    void setIsActive(StiIsActiveFunctor *val){ isActiveFunctor = val; }
    void setIsContinuousMedium(bool val) {continuousMedium = val;}
    void setIsDiscreteScatterer(bool val) {discreteScatterer = val;}

    void setGas(StiMaterial *val){ gas = val; }
    void setMaterial(StiMaterial *val){ material = val; }

    void setShape(StiShape *val){ shape = val; }
    void setPlacement(StiPlacement *val)
      { 
        placement = val; 
        _cos = cos(val->getNormalRefAngle());
        _sin = sin(val->getNormalRefAngle());
      }

    //action
    virtual void build(){}  //for now, build from SCL parsable ascii file

    virtual void copy(StiDetector &detector);
    
    //This is a bit of a hack, but we leave ourselves a reverse connection between
    // a detector and the tree node that it's stored on.
    void setTreeNode( StiCompositeTreeNode<StiDetector> * val) {mNode=val;}
    StiCompositeTreeNode<StiDetector> * getTreeNode() const {return mNode;}
    
    void setHitErrorCalculator(const StiHitErrorCalculator * calculator) {_hitErrorCalculator = calculator;}
    const StiHitErrorCalculator * getHitErrorCalculator() const {return _hitErrorCalculator;}

    void setGroupId(int id) {  _groupId = id;}
    int  getGroupId() const {return _groupId;}

    void setTrackingParameters(const StiTrackingParameters * pars) {_pars = pars;}
    const StiTrackingParameters * getTrackingParameters() const {return _pars;}

    friend ostream& operator<<(ostream&os, const StiDetector & det);

    void setKey(int index,int value)
      {
        switch (index)
          {
          case 1: _key1 = value; break;
          case 2: _key2 = value; break;
          }
      }

    int getKey(int index) const 
      {
        switch (index)
          {
          case 1: return _key1;
          case 2: return _key2;
          }
        return -1;
      }

    void setElossCalculator(StiElossCalculator * calculator)
      {
        _elossCalculator = calculator;
      }

    StiElossCalculator * getElossCalculator() const
      {
        return _elossCalculator;
      }

 protected:
    
    char mBeg[1];

    bool on;    
    StiIsActiveFunctor *isActiveFunctor; 
    bool continuousMedium;  
    bool discreteScatterer;   // is this a discrete scatterer?    (yes => scatterer given by "material" below)

    const StiHitErrorCalculator * _hitErrorCalculator;
    
    StiMaterial *gas;         
    StiMaterial *material;   
    
    StiShape     *shape;
    StiPlacement *placement;
    StiCompositeTreeNode<StiDetector>  * mNode;

    double _cos;
    double _sin;
    int _groupId;
    const StiTrackingParameters * _pars;
    int _key1, _key2;

    StiElossCalculator * _elossCalculator;
    char mEnd[1];
};
#endif

---