/home/bes3soft/bes3soft/Boss/7.0.2/dist/7.0.2/Muc/MucGeomSvc/MucGeomSvc-00-02-25/MucGeomSvc/MucGeoGeneral.h

Go to the documentation of this file.

//$id$
//
//$log$

/*
 *    2003/08/30   Zhengyun You      Peking University
 * 
 *    2004/09/09   Zhengyun You     Peking University
 *                 transplanted to Gaudi framework
 */

#ifndef MUC_GEO_GENERAL_H
#define MUC_GEO_GENERAL_H

#include <stdlib.h>
#include <math.h>
#include <vector>
#include <map>
#include <CLHEP/Vector/ThreeVector.h>
#include <CLHEP/Geometry/Point3D.h>
#include <CLHEP/Geometry/Plane3D.h>
#include <CLHEP/Vector/Rotation.h>

#include "Identifier/Identifier.h"
#include "Identifier/MucID.h"
#include "MucGeomSvc/MucGeoStrip.h"
#include "MucGeomSvc/MucGeoGap.h"

#ifndef ENABLE_BACKWARDS_COMPATIBILITY
typedef HepGeom::Point3D<double> HepPoint3D;
#endif
#ifndef ENABLE_BACKWARDS_COMPATIBILITY
typedef HepGeom::Vector3D<double> HepVector3D;
#endif

using namespace std;
using namespace CLHEP;

//class MucGeoGap;
//class MucGeoStrip;

class MucGeoGeneral
{
 public:

  MucGeoGeneral();

  MucGeoGeneral& operator=(const MucGeoGeneral& orig);

  MucGeoGeneral(const MucGeoGeneral& orig);

  ~MucGeoGeneral();

  void Init();

  void InitFromDatabase();

  void InitFromASCII();

  void InitFromXML();

  void Destroy();

  static MucGeoGeneral *Instance();

  MucGeoGap *GetGap(const int part, const int seg, const int gap) const;

  MucGeoGap *GetGap(const Identifier id) const;

  MucGeoStrip* GetStrip(const int part, const int seg, const int gap, const int strip) const;
  
  MucGeoStrip* GetStrip(const Identifier id) const;

  int GetStripNumInGap(const int part, const int seg, const int gap)
    { return m_StripNumInGap[part][seg][gap]; }

  int GetStripNumTotal();

  vector<Identifier> FindIntersectGaps(const int part, const int gap,
                                       const HepPoint3D gPoint, const Hep3Vector gDirection);
  
  vector<Identifier> FindIntersectStrips(const int part, const int gap,
                                         const HepPoint3D gPoint, const Hep3Vector gDirection);
 
  vector<Identifier> FindIntersectStrips(const int part, const int gap,
                                         const HepPoint3D gPoint, const Hep3Vector gDirection,
                                         vector<int> &padID, vector<float> &intersection_x,
                                         vector<float> &intersection_y,vector<float> &intersection_z);
 
  vector<HepPoint3D> FindIntersections(const int part, const int gap,
                                       const HepPoint3D gPoint, const Hep3Vector gDirection);

  void FindIntersection(const int part,      const int seg,       const int gap,
                        const float vx,      const float vy,      const float vz,
                        const float x0,      const float y0,      const float z0,
                        const float sigmaVx, const float sigmaVy, const float sigmaVz,
                        const float sigmaX0, const float sigmaY0, const float sigmaZ0,
                        float& x,            float& y,            float& z,
                        float& sigmaX,       float& sigmaY,       float& sigmaZ);
  

  void FindIntersectionQuadLocal(const int part,      const int seg,       const int gap,
                        const float a,       const float b,       const float c,
                        const int whichhalf,   //help to emit one solution.
                        float& x1,            float& y1,            float& z1,
                        float& x2,            float& y2,            float& z2,
                        float& sigmaX,       float& sigmaY,       float& sigmaZ);




  void FindIntersection(const int part,      const int seg,       const int gap,
                        const float vy,      
                        const float x0,      const float y0,      const float z0,
                        const float a,       const float b,       const float c,
                        const int whichhalf,   //help to emit one solution.
                        const float sigmaVx, const float sigmaVy, const float sigmaVz,
                        const float sigmaX0, const float sigmaY0, const float sigmaZ0,
                        float& x1,            float& y1,            float& z1,
                        float& x2,            float& y2,            float& z2,
                        float& sigmaX,       float& sigmaY,       float& sigmaZ);


  void FindIntersectionSurface(const int part,      const int seg,       const int gap,
                               const float vx,      const float vy,      const float vz,
                               const float x0,      const float y0,      const float z0,
                               const float sigmaVx, const float sigmaVy, const float sigmaVz,
                               const float sigmaX0, const float sigmaY0, const float sigmaZ0,
                               float& x1,           float& y1,           float& z1,
                               float& x2,           float& y2,           float& z2,
                               float& sigmaX1,      float& sigmaY1,      float& sigmaZ1,
                               float& sigmaX2,      float& sigmaY2,      float& sigmaZ2);

  void FindIntersectionSurface(const int part,      const int seg,       const int gap,
                        const float vy,      
                        const float x0,      const float y0,      const float z0,
                        const float a,       const float b,       const float c,
                        const int whichhalf,   //help to emit one solution.
                        const float sigmaVx, const float sigmaVy, const float sigmaVz,
                        const float sigmaX0, const float sigmaY0, const float sigmaZ0,
                        float& x1,            float& y1,            float& z1,
                        float& x2,            float& y2,            float& z2,
                        float& sigmaX,       float& sigmaY,       float& sigmaZ);


  void Clear();

 private:

  // Have we initialize the geometry.
  static int m_gGeometryInit;                    
  // Pointer to the instance of MucGeoGeneral.
  static MucGeoGeneral *m_gpMucGeoGeneral;  

  // map containing the pointers to gaps.
  static map<Identifier, MucGeoGap*> m_gpMucGeoGap;   
  // map containing the pointers to strips.
  static map<Identifier, MucGeoStrip*> m_gpMucGeoStrip;
  
  static const int m_kPartNum  = 3;
  static const int m_kSegMax   = 8;
  static const int m_kGapMax   = 9;
  static const int m_kStripMax = 112;
  
  // number of strips on each gap.
  //int m_StripNumInGap[MucID::getPartNum()][MucID::getSegMax()][MucID::getGapMax()];
  int m_StripNumInGap[m_kPartNum][m_kSegMax][m_kGapMax];
};

ostream& operator << (ostream& s, const MucGeoGeneral& geom);

#endif   /* MUC_GEO_GENERAL_H */

---