MdcGeomSvc-00-01-42/MdcGeomSvc/MdcGeoWire.h

Go to the documentation of this file.

// $Id: MdcGeoWire.h,v 1.3 2020/09/25 02:20:23 zhouh Exp $ // -*-c++-*-
// header file for a class called "MdcGeoWire"
#ifndef MDC_GEO_WIRE_H
#define MDC_GEO_WIRE_H
 
#include <CLHEP/Geometry/Point3D.h>
#include <iostream>
#include <vector>
#include "MdcGeomSvc/MdcGeoLayer.h"
#ifndef ENABLE_BACKWARDS_COMPATIBILITY
typedef HepGeom::Point3D<double> HepPoint3D;
#endif        
 
using namespace CLHEP;
using namespace std;
 
 
class MdcGeoWire {
 
    public:
        // Constructor.
        MdcGeoWire()
            : fId(0),
            fSlant(0),
            fnomSlant(0),
            fCell(0),
            fLayer(0),
            fStat(0)
            {
                HepPoint3D O(0,0,0);
                fBackward=O;
                fForward=O;
                fBwirepos=O;
                fFwirepos=O;
                fnomBackward=O;
                fnomForward=O;
                fLyr=NULL;
                fWireNeighbors.clear();
                fNeighborType.clear();
                fWireNeighborsID.clear();
            }
 
        // Copy and Assignment
        MdcGeoWire(const MdcGeoWire& e){
            fId=e.Id();
            fBackward=e.Backward(); 
            fForward=e.Forward();
            fBwirepos=e.BWirePos(); 
            fFwirepos=e.FWirePos();
            fSlant=e.Slant();
            fCell=e.Cell();
            fLayer=e.Layer();
            fStat=e.Stat();
            fLyr=e.Lyr();
            fWireNeighbors=e.GetNeighbors();
            fWireNeighborsID=e.GetIDofNeighbors();
            fNeighborType=e.GetNeighborsType();
        };
 
        MdcGeoWire& operator=(const MdcGeoWire& e) {
            if(this!=&e)
            {
                fId=e.Id();
                fBackward=e.Backward();
                fForward=e.Forward();
                fBwirepos=e.BWirePos();
                fFwirepos=e.FWirePos();
                fSlant=e.Slant();
                fCell=e.Cell();
                fLayer=e.Layer();
                fStat=e.Stat();
                fLyr=e.Lyr();
                fWireNeighbors=e.GetNeighbors();
                fWireNeighborsID=e.GetIDofNeighbors();
                fNeighborType=e.GetNeighborsType();
            }
            return *this;
        }
 
        // Destructor
        ~MdcGeoWire(){ };
 
    public: // Extractors
        int Id(void) const;
        HepPoint3D Backward(void) const;
        HepPoint3D Forward(void) const;
        HepPoint3D BWirePos(void) const;
        HepPoint3D FWirePos(void) const;
        double Slant(void) const;
        HepPoint3D nomBackward(void) const;
        HepPoint3D nomForward(void) const;
        double nomSlant(void) const;
        double Tension(void) const;
        const double Sag(void) const;
        const double Sagz(const double z) const;
        
        double GetX(const double z) const;
        double GetY(const double z) const;
               
        int NeiborType(int nid) const;//1:number decrease  2:number increase  3:lower layer  4:upper layer
        int NeighborID(int nid) const;//return cellID of a neighbor
        int NumOfNeibors(void) const;//return amount of adjacent cells
        vector<int> GetIDofNeighbors(void) const;
        vector<MdcGeoWire*> GetNeighbors(void) const;
 
        int GetNeighborIDType1(void) const;
        int GetNeighborIDType2(void) const;
        vector<int> GetNeighborIDType3(void) const;
        vector<int> GetNeighborIDType4(void) const;
        vector<int> GetNeighborsType(void) const;
        MdcGeoWire* GetNeighborType1(void) const;
        MdcGeoWire* GetNeighborType2(void) const;
        vector<MdcGeoWire*> GetNeighborType3(void) const;
        vector<MdcGeoWire*> GetNeighborType4(void) const;
        double WirePhi(double z) const;
        double CalculatePhi(double phi) const;
        
        vector<MdcGeoWire*> GetNeighboratZType3(double z) const;
        vector<MdcGeoWire*> GetNeighboratZType4(double z) const;
 
        int Cell(void) const;
        int Layer(void) const;
        int Stat(void) const;
        
        
        MdcGeoLayer * Lyr(void) const;
 
    public: // Modifiers
        int Id(int);
        HepPoint3D Backward(HepPoint3D);
        HepPoint3D Forward(HepPoint3D);
        HepPoint3D BWirePos(HepPoint3D);
        HepPoint3D FWirePos(HepPoint3D);
        double Slant(double);
        HepPoint3D nomBackward(HepPoint3D);
        HepPoint3D nomForward(HepPoint3D);
        double nomSlant(double);
        double Tension(double);
 
        void AddWireNeighbor(int id,int type);//add a neighbor cell
        void AddWireNeighbor(MdcGeoWire* awire,int type);
        void AddWireNeighbor(MdcGeoWire* awire,int id,int type);
        void ClearNeighbors();
        
 
        int Cell(int);
        int Layer(int);
        int Stat(int);
        MdcGeoLayer*  Lyr( MdcGeoLayer * );
 
    private:
        int fId;
        HepPoint3D fBackward;  //wire position at backward endplate (mm)
        HepPoint3D fForward;   //wire position at forward endplate (mm)
        HepPoint3D fBwirepos;  //wire position at backward endplate (mm)
        HepPoint3D fFwirepos;   //wire position at forward endplate (mm)
        double fSlant;         //slant angle of wire (rad)
        HepPoint3D fnomBackward;  //nominal wire position at backward endplate (mm)
        HepPoint3D fnomForward;   //nominal wire position at forward endplate (mm)
        double fnomSlant;         //nominal slant angle of wire (rad)
        double fTension;          // the tension of wire
 
        int fCell;         //#cell
        int fLayer;        //#layer
        int fStat;             //status (32 bits)
        MdcGeoLayer * fLyr;   
 
        std::vector<int> fWireNeighborsID;
        std::vector<MdcGeoWire*> fWireNeighbors;
        std::vector<int> fNeighborType;
 
};
 
// Extractors
inline int MdcGeoWire::Id(void) const { return fId; }
inline HepPoint3D MdcGeoWire::Backward(void) const { return fBackward;}
inline HepPoint3D MdcGeoWire::Forward(void) const { return fForward;}
inline HepPoint3D MdcGeoWire::BWirePos(void) const { return fBwirepos;}
inline HepPoint3D MdcGeoWire::FWirePos(void) const { return fFwirepos;}
inline double MdcGeoWire::Slant(void) const { return fSlant; }
inline HepPoint3D MdcGeoWire::nomBackward(void) const { return fnomBackward;}
inline HepPoint3D MdcGeoWire::nomForward(void) const { return fnomForward;}
inline double MdcGeoWire::nomSlant(void) const { return fnomSlant; }
inline double MdcGeoWire::Tension(void) const { return  fTension;}
inline int MdcGeoWire::Cell(void) const { return fCell; }
inline int MdcGeoWire::Layer(void) const { return fLayer; }
inline int MdcGeoWire::Stat(void) const { return fStat; }
inline MdcGeoLayer* MdcGeoWire::Lyr(void) const { return fLyr; }
 
inline int MdcGeoWire::GetNeighborIDType1(void) const {return fWireNeighborsID.at(0);}
inline int MdcGeoWire::GetNeighborIDType2(void) const {return fWireNeighborsID.at(1);}
inline vector<MdcGeoWire*> MdcGeoWire::GetNeighbors(void) const {return fWireNeighbors;}
inline MdcGeoWire* MdcGeoWire::GetNeighborType1(void) const {return fWireNeighbors.at(0);}
inline MdcGeoWire* MdcGeoWire::GetNeighborType2(void) const {return fWireNeighbors.at(1);}
inline int MdcGeoWire::NeighborID(int nid) const {return fWireNeighborsID.at(nid);}
inline int MdcGeoWire::NumOfNeibors(void) const  {return fWireNeighborsID.size();}
inline vector<int> MdcGeoWire::GetIDofNeighbors(void) const {return fWireNeighborsID;}
inline vector<int> MdcGeoWire::GetNeighborsType(void) const {return  fNeighborType;}
 
// Modifiers
inline int MdcGeoWire::Id(int i) {return fId=i;}
inline HepPoint3D MdcGeoWire::Backward(HepPoint3D i) {return fBackward=i;}
inline HepPoint3D MdcGeoWire::Forward(HepPoint3D i) {return fForward=i;}
inline HepPoint3D MdcGeoWire::BWirePos(HepPoint3D i) {return fBwirepos=i;}
inline HepPoint3D MdcGeoWire::FWirePos(HepPoint3D i) {return fFwirepos=i;}
inline HepPoint3D MdcGeoWire::nomBackward(HepPoint3D i) {return fnomBackward=i;}
inline HepPoint3D MdcGeoWire::nomForward(HepPoint3D i) {return fnomForward=i;}
inline double MdcGeoWire::Slant(double i) {return fSlant=i;}
inline double MdcGeoWire::nomSlant(double i) {return fnomSlant=i;}
inline double MdcGeoWire::Tension(double i) {return  fTension=i;}
inline int MdcGeoWire::Cell(int i) {return fCell=i;}
inline int MdcGeoWire::Layer(int i) {return fLayer=i;}
inline int MdcGeoWire::Stat(int i) {return fStat=i;}
inline MdcGeoLayer* MdcGeoWire::Lyr(MdcGeoLayer* i) {return fLyr = i;}
 
 
 
#endif /* MdcGeoWire_CLASS */