MdcGeomSvc Class Reference

#include <MdcGeomSvc.h>

Inheritance diagram for MdcGeomSvc:

Classes
struct	AdjCandiTgtLine2D
	forms a line in x-y space, ax + by + c = 0 More...

Public Member Functions
	MdcGeomSvc (const std::string &name, ISvcLocator *svcloc)
	~MdcGeomSvc ()
virtual StatusCode	queryInterface (const InterfaceID &riid, void **ppvUnknown)
virtual StatusCode	initialize ()
virtual StatusCode	finalize ()
void	handle (const Incident &inc)
	this handle function is prepared for special use
const MdcGeoWire *const	Wire (unsigned id)
const MdcGeoWire *const	Wire (unsigned lyrid, unsigned wirid)
const MdcGeoLayer *const	Layer (unsigned id)
const MdcGeoSuper *const	SuperLayer (unsigned id)
const MdcGeoGeneral *const	GeneralLayer (unsigned id)
const MdcGeoMisc *const	Misc (void)
const MdcGeoEnd *const	End (unsigned id)
const int	getWireSize ()
const int	getLayerSize ()
const int	getSuperLayerSize ()
const int	getGeneralLayerSize ()
const int	getSegmentNo ()
void	Dump ()
	MdcGeomSvc (const std::string &name, ISvcLocator *svcloc)
	~MdcGeomSvc ()
virtual StatusCode	queryInterface (const InterfaceID &riid, void **ppvUnknown)
virtual StatusCode	initialize ()
virtual StatusCode	finalize ()
void	handle (const Incident &inc)
const MdcGeoWire *const	Wire (unsigned id)
const MdcGeoWire *const	Wire (unsigned lyrid, unsigned wirid)
const MdcGeoLayer *const	Layer (unsigned id)
const MdcGeoSuper *const	SuperLayer (unsigned id)
const MdcGeoGeneral *const	GeneralLayer (unsigned id)
const MdcGeoMisc *const	Misc (void)
const MdcGeoEnd *const	End (unsigned id)
const int	getWireSize ()
const int	getLayerSize ()
const int	getSuperLayerSize ()
const int	getGeneralLayerSize ()
const int	getSegmentNo ()
void	Dump ()
vector< HepPoint3D >	getAdjacentIntersectionShape (const MdcGeoWire *wireA, const MdcGeoWire *wireB)
	get touching shape of 2 adjacent layer wires. return vertexs of intersection shape if the wires' sensitive area connects. return empty if not. points does go in order
vector< double >	getAdjacentIntersectionBounds (const MdcGeoWire *wireA, const MdcGeoWire *wireB)
	get bounding box in \varphi and z of touching shape of 2 adjacent layer wires.
HepPoint3D	getAdjacentIntersectionPointFast (const MdcGeoWire *wireA, const MdcGeoWire *wireB)
	find the z where points on wireA, wireB has same phi. point is given as avg(A(z),B(z))
HepPoint3D	getAdjacentIntersectionPointSlower (const MdcGeoWire *wireA, const MdcGeoWire *wireB)
vector< AdjCandiTgtLine2D >	getAdjacentCandidateWithDriftCircle (const MdcGeoWire *wireA, const MdcGeoWire *wireB, double driftA, double driftB)
	give the lines that is tangent to both drift circles at the approximate z that the wires cross. require wireA != wireB.
vector< AdjCandiTgtLine2D >	getAdjacentCandidateWithDriftCircle (const MdcGeoWire *wireA, const MdcGeoWire *wireB, double driftA, double driftB, double expectedZ)
	give the lines that is tangent to both drift circles at certain z. require wireA != wireB.
void	testAdjacentIntersection ()
Public Member Functions inherited from IMdcGeomSvc

Static Public Member Functions
static bool	getSagFlag (void)
static bool	getSagFlag (void)
Static Public Member Functions inherited from IMdcGeomSvc
static const InterfaceID &	interfaceID ()
static const InterfaceID &	interfaceID ()

Static Public Attributes
static bool	m_doSag = true
static bool	m_readAlignParDataBase = true
static bool	m_nomcalignment =true

Detailed Description

Definition at line 25 of file bak_MdcGeomSvc-00-01-39/MdcGeomSvc/MdcGeomSvc.h.

Constructor & Destructor Documentation

MdcGeomSvc() [1/2]

MdcGeomSvc::MdcGeomSvc	(	const std::string &	name,
		ISvcLocator *	svcloc )

Definition at line 30 of file bak_MdcGeomSvc-00-01-39/src/MdcGeomSvc.cxx.

                                                                   : Service(name, svcloc) {
    if(getenv("MDCGEOMSVCROOT")){
        m_alignFilePath = std::string(getenv("MDCGEOMSVCROOT"))+std::string("/share/MdcAlignPar.dat");
        //std::cout<<" the MDC alignment file: "<<m_alignFilePath<<std::endl;
 
        m_wirePosFilePath = std::string(getenv("MDCGEOMSVCROOT"))+std::string("/share/WirePosCalib.dat");
        //std::cout<<" the MDC wire position  file: "<<m_wirePosFilePath<<std::endl;
 
        m_wireTensionFilePath = std::string(getenv("MDCGEOMSVCROOT"))+std::string("/share/mdcWireTension.dat");
        //std::cout<<" the MDC wire tension file: "<<m_wireTensionFilePath<<std::endl;
 
    }
    else {
        std::cout<<"A fatal error, contact wangjk..."<<std::endl;
    }
 
    declareProperty("doSag",      m_doSag = true);
    declareProperty("readAlignParDataBase", m_readAlignParDataBase = true);
    declareProperty("mcnoalignment",m_nomcalignment=true);
    declareProperty("wholeShiftX",m_wholeShiftX = 0.);
    declareProperty("wholeShiftY",m_wholeShiftY = 0.);
    declareProperty("wholeShiftZ",m_wholeShiftZ = 0.);
    declareProperty("wholeRotatX",m_wholeRotatX = 0.);
    declareProperty("wholeRotatY",m_wholeRotatY = 0.);
    declareProperty("wholeRotatZ",m_wholeRotatZ = 0.);
    declareProperty("alignFilePath",m_alignFilePath);
    declareProperty("wirePosFilePath",m_wirePosFilePath);
    declareProperty("wireTensionFilePath",m_wireTensionFilePath);
    declareProperty("useCGEM",m_useCgem = true);
    
 
}

~MdcGeomSvc() [1/2]

MdcGeomSvc::~MdcGeomSvc

(

)

Definition at line 113 of file bak_MdcGeomSvc-00-01-39/src/MdcGeomSvc.cxx.

                       {
    for(vector<MdcGeoLayer*>::iterator it1 = fLayers.begin(); it1 != fLayers.end(); it1++) delete *it1;
    for(vector<MdcGeoSuper*>::iterator it2 = fSupers.begin(); it2 != fSupers.end(); it2++) delete *it2;
    for(vector<MdcGeoWire*>::iterator it3 = fWires.begin(); it3 != fWires.end(); it3++) delete *it3;
    for(vector<MdcGeoEnd*>::iterator it4 = fEnd.begin(); it4 != fEnd.end(); it4++) delete *it4;  
    fGenerals.clear();
    fWires.clear();
    fLayers.clear();
    fSupers.clear();
    fEnd.clear();  
}

MdcGeomSvc() [2/2]

MdcGeomSvc::MdcGeomSvc	(	const std::string &	name,
		ISvcLocator *	svcloc )

~MdcGeomSvc() [2/2]

MdcGeomSvc::~MdcGeomSvc

(

)

Member Function Documentation

Dump() [1/2]

void MdcGeomSvc::Dump ( )

virtual

Implements IMdcGeomSvc.

Definition at line 696 of file bak_MdcGeomSvc-00-01-39/src/MdcGeomSvc.cxx.

{}

Referenced by main().

Dump() [2/2]

void MdcGeomSvc::Dump ( )

virtual

Implements IMdcGeomSvc.

End() [1/2]

const MdcGeoEnd *const MdcGeomSvc::End

(

unsigned

id

)

Definition at line 815 of file bak_MdcGeomSvc-00-01-39/src/MdcGeomSvc.cxx.

                              {
        if (id < fEnd.size())     
            return  fEnd[id];
 
        return 0;
    }  

Referenced by BesMdcGeoParameter::InitFromSvc().

End() [2/2]

const MdcGeoEnd *const MdcGeomSvc::End

(

unsigned

id

)

finalize() [1/2]

StatusCode MdcGeomSvc::finalize ( )

virtual

Definition at line 107 of file bak_MdcGeomSvc-00-01-39/src/MdcGeomSvc.cxx.

                                  {
    MsgStream log(messageService(), name());
    log << MSG::INFO << name() << ": End of Run" << endreq;
    return StatusCode::SUCCESS;
}

Referenced by main().

finalize() [2/2]

virtual StatusCode MdcGeomSvc::finalize ( )

virtual

GeneralLayer() [1/2]

const MdcGeoGeneral *const MdcGeomSvc::GeneralLayer ( unsigned id )

virtual

Implements IMdcGeomSvc.

Definition at line 802 of file bak_MdcGeomSvc-00-01-39/src/MdcGeomSvc.cxx.

                                       {
        if (id < fGenerals.size()) 
            return & fGenerals[id];
 
        return 0;
    }

Referenced by BesMdcGeoParameter::InitFromSvc().

GeneralLayer() [2/2]

const MdcGeoGeneral *const MdcGeomSvc::GeneralLayer ( unsigned id )

virtual

Implements IMdcGeomSvc.

getAdjacentCandidateWithDriftCircle() [1/2]

vector< MdcGeomSvc::AdjCandiTgtLine2D > MdcGeomSvc::getAdjacentCandidateWithDriftCircle	(	const MdcGeoWire *	wireA,
		const MdcGeoWire *	wireB,
		double	driftA,
		double	driftB )

give the lines that is tangent to both drift circles at the approximate z that the wires cross. require wireA != wireB.

calls getAdjacentCandidateWithDriftCircle() with given Z. z calculated from center of bounds given in getAdjacentIntersectionBounds(); if no bound avaliable (the 2 wires has no neighbor), no line is returnd

Parameters

wireA,wireB	the 2 wires
driftA,driftB	the 2 drifts

Returns

vector<CLHEP::Hep2Vector>

Definition at line 1687 of file MdcGeomSvc-00-01-42/src/MdcGeomSvc.cxx.

                                                                                                                                                                {
    std::vector<double> bound=getAdjacentIntersectionBounds(wireA, wireB);
    //[phiL,phiU, zL,zU]
    double expectedZ;
    if (bound.size()==4)expectedZ=(bound[3]+bound[2])/2;
    else { 
        vector<MdcGeomSvc::AdjCandiTgtLine2D> ret;
        return ret ;
    }
    return getAdjacentCandidateWithDriftCircle(wireA, wireB, driftA, driftB,expectedZ);
}

Referenced by getAdjacentCandidateWithDriftCircle(), and testAdjacentIntersection().

getAdjacentCandidateWithDriftCircle() [2/2]

vector< MdcGeomSvc::AdjCandiTgtLine2D > MdcGeomSvc::getAdjacentCandidateWithDriftCircle	(	const MdcGeoWire *	wireA,
		const MdcGeoWire *	wireB,
		double	driftA,
		double	driftB,
		double	expectedZ )

give the lines that is tangent to both drift circles at certain z. require wireA != wireB.

inf is used to rep uninitialized value. gives AdjCandiTgtLine2D as the lines. mid of two tangent points are provided with AdjCandiTgtLine2D::location(). further check AdjCandiTgtLine2D.

Parameters

wireA,wireB	the 2 wires
driftA,driftB	the 2 drifts
expectedZ	the z to calc

Returns

vector<MdcGeomSvc::AdjCandiTgtLine2D>

Definition at line 1588 of file MdcGeomSvc-00-01-42/src/MdcGeomSvc.cxx.

                                                                                                                                                                                  {
 
    HepPoint3D A1=wireA->Forward();
    // HepPoint3D A2(wireA->GetX(expectedZ), wireA->GetY(expectedZ), expectedZ);
    HepPoint3D A3=wireA->Backward();
    HepPoint3D B1=wireB->Forward();  // is -
    // HepPoint3D B2(wireB->GetX(expectedZ), wireB->GetY(expectedZ), expectedZ);
    HepPoint3D B3=wireB->Backward();
    HepPoint3D directionA=(A3-A1);
    HepPoint3D directionB=(B3-B1);
    HepPoint3D directionABSurface=directionA.cross(directionB); // perp to the surface.
    if (directionABSurface.dot(A1)<0)
        directionABSurface=-directionABSurface; // make it outwards
    HepPoint3D directionABSurface2D=directionABSurface;
    directionABSurface2D.setZ(0);
    // double directionABSurface_mag=directionABSurface.mag(); 
    // HepPoint3D directionAlongAB_2D=A2-B2;                         // along the surface
    // double directionAlongAB_2D_mag=directionAlongAB_2D.mag();
 
    // static int runcount=0;
    // {
    //     runcount++;
    //     if (runcount<5){
    //     cout<<"debug_out:"<<__LINE__<<" "<<directionAlongAB_2D.x()<<' '<<directionAlongAB_2D.y()<<" "<<directionAlongAB_2D_mag<<endl;
    //     }
    // }
    CLHEP::Hep2Vector pA(wireA->GetX(expectedZ),wireA->GetY(expectedZ));
    CLHEP::Hep2Vector pB(wireB->GetX(expectedZ),wireB->GetY(expectedZ));
    vector<MdcGeomSvc::AdjCandiTgtLine2D> ret=_MdcGeomSvc_impl::tangents(pA,pB, driftA, driftB);
    CLHEP::Hep2Vector pMid=(pA+pB)/2;
    // line: x0 x + y0 y - x0 ^2 - y0 ^2 =0 
    // that is, we take the line as the line tangent to the circle passing my point
    // double r2=pMid.mag2();
    double x0=pMid.x();
    double y0=pMid.y();
    for (size_t i=0; i<ret.size(); i++) {
        double a=ret[i].a;
        double b=ret[i].b;
        double c=ret[i].c;
        // double a2b2=a*a+b*b; //=1
        // double mres=(x0*b - y0 * a);
        // if (abs(mres)<_MdcGeomSvc_impl::EPS){
        //     // the root of perp for pMid against line.
        //     ret[i].x0=AdjCandiTgtLine2D::INFTY;
        //     ret[i].y0=AdjCandiTgtLine2D::INFTY;
        //     ret[i].z0=expectedZ;
        //     continue;
        // }   
        // double x=(r2 * b + c * y0)/mres;
        // // double y=-(a*x+c)/b;    //what if b ==0.
        // double y=(c*x0+a*r2)/(-mres);
        double x=(b*b*x0 - a*b*y0 - a*c); // .../a2b2
        double y=(-a*b*x0 + a*a*y0 - b*c);
 
        ret[i].x0=x;
        ret[i].y0=y;
        ret[i].z0=expectedZ;
        HepPoint3D directionLine(b,-a,0);// is this right?
        if (directionLine.dot(HepPoint3D(x,y,0))<0)
            directionLine = -directionLine;
        HepPoint3D directionLineRotate90(-directionLine.y(),directionLine.x(),0);// spin pi/2 anti-clock.
        //double directionLine_mag=directionLine.mag(); // should be 1;
        //ret[i].angle3D=asin(directionLine.dot(directionABSurface )/(directionLine_mag*directionABSurface_mag));
        //double cosAngle2D=directionLine.dot(directionAlongAB_2D)/(directionLine_mag*directionAlongAB_2D_mag);
 
        // double sinAngle3D=directionLine.dot(directionABSurface )/(directionABSurface_mag);
        // if (sinAngle3D>1  && sinAngle3D < 1 + _MdcGeomSvc_impl::EPS) sinAngle3D=1;
        // if (sinAngle3D<-1 && sinAngle3D > -1 - _MdcGeomSvc_impl::EPS)sinAngle3D=-1;
        // ret[i].angle3D=asin(sinAngle3D);
        ret[i].angle2D=directionLineRotate90.angle(directionABSurface);
        ret[i].angle3D=directionLineRotate90.angle(directionABSurface2D);
        // double cosAngle2D=directionLine.dot(directionAlongAB_2D)/(directionAlongAB_2D_mag);
        // if (cosAngle2D>1 && cosAngle2D < 1+ _MdcGeomSvc_impl::EPS)cosAngle2D=1;
        // if (cosAngle2D<-1 && cosAngle2D > -1 - _MdcGeomSvc_impl::EPS) cosAngle2D=-1;
        // // in test, rounding errors can make the cosAngle>1 when it is supposed to be 1. we revert that effect here.
        // ret[i].angle2D=acos(cosAngle2D);
        // {
        // if (runcount<5){
        // cout<<"debug_out:"<<__LINE__<<" "<<directionLine.x()<<' '<<directionLine.y()<<" "<<directionLine_mag<< " "<<directionLine.dot(directionAlongAB_2D)/(directionLine_mag*directionAlongAB_2D_mag)<<endl;
        // }
        // }
 
    }// adding point of Hit.
 
    return ret;
 
}

getAdjacentIntersectionBounds()

vector< double > MdcGeomSvc::getAdjacentIntersectionBounds	(	const MdcGeoWire *	wireA,
		const MdcGeoWire *	wireB )

get bounding box in \varphi and z of touching shape of 2 adjacent layer wires.

Parameters

wireA
wireB

Returns

vector<double> empty if no touch. [phiL,phiU, zL,zU] if touching. may have phiL<0 if the box goes over phi=0. (circular)

Definition at line 1298 of file MdcGeomSvc-00-01-42/src/MdcGeomSvc.cxx.

                                                                                                       {
    vector<double> ret;
    vector<HepPoint3D> vertexs=getAdjacentIntersectionShape(wireA, wireB);
    if (vertexs.size()==0) return ret;
    else{
        // double maxZAllowed=std::max(
        //                             std::max(wireA->Backward().z(),wireB->Backward().z()),
        //                             std::max(wireA->Forward().z(), wireB->Forward().z())
        //                             );
        // double minZAllowed=std::min(
        //                             std::min(wireA->Forward().z(), wireB->Forward().z()),
        //                             std::min(wireA->Backward().z(),wireB->Backward().z())
        //                             );
 
        // vertexs.push_back(vertexs[0]);
 
        double phiL,phiU, zL,zU;
        bool firstp=true;
 
        for (size_t i=0;i<vertexs.size()-1;i++){
            HepPoint3D p1=vertexs[i];
            // HepPoint3D p2=vertexs[i+1];
            // int sgn1=0;
            // int sgn2=0; // for vertex 1,2.  0 for in range, 1 for >max, -1 for <min
            // if (p1.z() > maxZAllowed) sgn1=1;
            // else if (p1.z() < minZAllowed) sgn1 = -1;
            // if (p2.z() > maxZAllowed) sgn2=1;
            // else if (p2.z() < minZAllowed) sgn2 = -1; 
 
            // if (sgn1==sgn2 && sgn1 !=0){// both at outside
            //     continue;
            // }
            // else if (sgn1==sgn2 && sgn1 ==0){ // both at inside
 
            // }else {// crossed angle
            //     HepPoint3D pu,pl;
            //     pu = interpolate(p1,p2,maxZAllowed);
            //     pl = interpolate(p1,p2,minZAllowed);
            //     if (sgn1 ==1) p1 = pu;
            //     if (sgn1 ==-1) p1 = pl;
            //     if (sgn2 ==1) p2 = pu;
            //     if (sgn2 ==-1) p2 = pl;
 
            // }
 
            if (firstp){ // hate this copy-pasting
                HepPoint3D vertex=p1;
                zL=vertex.z();
                zU=vertex.z();
                phiL=vertex.getPhi();
                phiU=vertex.getPhi();
                firstp=false;
            }
            else{
                HepPoint3D vertex=p1;
                zL=std::min(zL,vertex.z());
                zU=std::max(zU,vertex.z());
                phiL=std::min(phiL,vertex.getPhi());
                phiU=std::max(phiU,vertex.getPhi());                        
            }
        }
 
 
        if (phiU >=M_PI *1.5 && phiL <= M_PI *.5) {//damn hated circular phi problem
            HepPoint3D vertex=vertexs[0];
            double phi2=vertex.getPhi();
            if (phi2>M_PI *1.5)phi2 -=M_PI *2;
            phiL=phiU=phi2;
            for (size_t i=1;i<vertexs.size();i++){
                HepPoint3D vertex=vertexs[i];
                double phi2=vertex.getPhi();
                if (phi2>M_PI *1.5)phi2 -=M_PI *2;
                phiL=std::min(phiL,phi2);
                phiU=std::max(phiU,phi2);
            }
        }
 
        ret.push_back(phiL);
        ret.push_back(phiU);
        ret.push_back(zL);
        ret.push_back(zU);
        return ret;
    }
}

Referenced by getAdjacentCandidateWithDriftCircle(), getAdjacentIntersectionPointSlower(), and testAdjacentIntersection().

getAdjacentIntersectionPointFast()

HepPoint3D MdcGeomSvc::getAdjacentIntersectionPointFast	(	const MdcGeoWire *	wireA,
		const MdcGeoWire *	wireB )

find the z where points on wireA, wireB has same phi. point is given as avg(A(z),B(z))

Parameters

wireA
wireB

Returns

HepPoint3D

Definition at line 1249 of file MdcGeomSvc-00-01-42/src/MdcGeomSvc.cxx.

                                                                                                      {
    HepPoint3D A1=wireA->Forward();
    HepPoint3D A2=wireA->Backward(); // OOps!!!
    HepPoint3D B1=wireB->Forward();  // is -
    HepPoint3D B2=wireB->Backward(); // is +
    double phiA1=A1.getPhi();
    double phiA2=A2.getPhi();
    double phiB1=B1.getPhi();
    double phiB2=B2.getPhi();
    circularPhiExtend(phiA1, phiA2);
    circularPhiExtend(phiB1, phiB2);
    double dPhiA=phiA2-phiA1;
    double dZA=A2.z()-A1.z();
    double phiAatB1=phiA1+(B1.z()-A1.z())/dZA*dPhiA;
    double dPhiB=phiB2-phiB1;
    double dZB=B2.z()-B1.z();
    // we want z that makes phiA(z)==phiB(z), 
    // that is phiAatB1+(z-zB1)*dPhiA/dZA == phiB1+(z-zB1)*dPhiB/dZB
    double z=B1.z()+(phiAatB1-phiB1)/(dPhiB/dZB-dPhiA/dZA);
    return HepPoint3D(
            (wireA->GetX(z)+wireB->GetX(z))/2, 
            (wireA->GetY(z)+wireB->GetY(z))/2,
            z
            );
}

getAdjacentIntersectionPointSlower()

HepPoint3D MdcGeomSvc::getAdjacentIntersectionPointSlower	(	const MdcGeoWire *	wireA,
		const MdcGeoWire *	wireB )

Definition at line 1275 of file MdcGeomSvc-00-01-42/src/MdcGeomSvc.cxx.

                                                                                                        {
    vector<double> bounds = getAdjacentIntersectionBounds(wireA,wireB);
    HepPoint3D ret(1./0,1./0,1./0);
    if (bounds.empty()) return ret;
    double z=(bounds[2]+bounds[3])/2;
    return HepPoint3D(
            (wireA->GetX(z)+wireB->GetX(z))/2, 
            (wireA->GetY(z)+wireB->GetY(z))/2,
            z
            );
 
}

getAdjacentIntersectionShape()

vector< HepPoint3D > MdcGeomSvc::getAdjacentIntersectionShape	(	const MdcGeoWire *	wireA,
		const MdcGeoWire *	wireB )

get touching shape of 2 adjacent layer wires.
return vertexs of intersection shape if the wires' sensitive area connects. return empty if not. points does go in order

Parameters

wireA
wireB

Returns

vector<HepPoint3D> return 4 vertexs of intersection parallelogram if the wires' sensitive area connects. return empty if not.

Definition at line 1045 of file MdcGeomSvc-00-01-42/src/MdcGeomSvc.cxx.

                                                                                                            {
    vector<HepPoint3D> ret;
 
    //to dbg: b MdcGeomSvc.cxx:MdcGeomSvc::getAdjacentIntersectionShape
 
    HepPoint3D A1=wireA->Forward();
    HepPoint3D A2=wireA->Backward(); // OOps!!!
    HepPoint3D B1=wireB->Forward();  // is -
    HepPoint3D B2=wireB->Backward(); // is +
 
    double maxZAllowed=(
            std::max(wireA->Backward().z(),wireB->Backward().z())
            // std::max(wireA->Forward().z(), wireB->Forward().z())
            );
    double minZAllowed=(
            std::min(wireA->Forward().z(), wireB->Forward().z())
            // std::min(wireA->Backward().z(),wireB->Backward().z())
            );
 
    HepPoint3D directionR=(A1+A2+B1+B2)/4;// in general, should be (almost) perpendicular to line A and B
    directionR.setZ(0);
    directionR.setMag(1); // now a directional vector.
    // HepPoint3D directionZ(0,0,1);
    // HepPoint3D directionPhi=directionR.cross(directionZ);
 
    const MdcGeoWire* wireAl=this->Wire(static_cast<unsigned int>(wireA->GetNeighborIDType1()));
    //const MdcGeoWire* wireA2=this->Wire(static_cast<unsigned int>(wireA->GetNeighborIDType2()));
    const MdcGeoWire* wireB1=this->Wire(static_cast<unsigned int>(wireB->GetNeighborIDType1()));
    // const MdcGeoWire* wireB2=this->Wire(static_cast<unsigned int>(wireB->GetNeighborIDType2()));
    double typicalWidthA=(wireAl->Forward() - wireA->Forward()).mag();
    double typicalWidthB=(wireB1->Forward() - wireB->Forward()).mag(); // using dist at endplate;
 
    // double radiusLayerA=this->Layer(wireA->Layer())->Radius();
    // double radiusLayerB=this->Layer(wireB->Layer())->Radius();
    // double typicalLayerThickness=(radiusLayerB-radiusLayerA)/(wireB->Layer()-wireA->Layer());
    // double dWAdr=typicalWidthA/typicalLayerThickness*2; // hope we have a better alternative.
    // double dWBdr=typicalWidthB/typicalLayerThickness*2;
 
    // if we have r implemented, this will be calced from dr and dWAdr
    double widthAtSurfaceA=typicalWidthA; 
    double widthAtSurfaceB=typicalWidthB;
    // double minWidth=min(widthAtSurfaceA,widthAtSurfaceB);
 
    //double centerZ=getClosestZ(wireA,wireB);
    //double rA=wireA->GetX(centerZ);
 
    double surfaceA=directionR.dot((A1+A2)/2); // centerZ
    double surfaceB=directionR.dot((B1+B2)/2);
    // double surfaceMid=(surfaceA+surfaceB)/2;
    double surfaceDiff=(surfaceB-surfaceA);
 
    // so the midsurface: any X that directionR.dot(X)==surfaceMid
    HepPoint3D A1m=A1+ surfaceDiff/2*directionR;
    HepPoint3D A2m=A2+ surfaceDiff/2*directionR;
    HepPoint3D B1m=B1- surfaceDiff/2*directionR;
    HepPoint3D B2m=B2- surfaceDiff/2*directionR;
    // HepPoint3D d1m=
 
    HepPoint3D direction1m=B1m - A1m;
    direction1m.setZ(0);
    {
        HepPoint3D direction2m=B2m - A2m;
        direction2m.setZ(0);
        if (direction2m.mag2() > direction1m.mag()) direction1m = direction2m;
    }
    direction1m.setMag(1);
 
    //HepPoint3D center=getIntersection(A1m,A2m, B1m, B2m );
    HepPoint3D directionA=(A2-A1);directionA/=directionA.z();
    HepPoint3D directionB=(B2-B1);directionB/=directionB.z();
    HepPoint3D deltaA=direction1m*(widthAtSurfaceA/2); // A1->B1 direction
    HepPoint3D deltaB=direction1m*(widthAtSurfaceB/2); // A1->B1 direction
 
    if ((directionA-directionB).mag2()<= 0.01*0.01){ // we know wire distance ~ 10 mm so a 10^-3 level error is allowed. 
        // if parallel
        if (direction1m.mag2()>squared(widthAtSurfaceA+widthAtSurfaceB)/4) {// have no relation at all. 
            return ret;
            // donothing. let it return.
        } 
        else{// has interection 
            ret.push_back(B1m-deltaB);
            ret.push_back(A1m+deltaA);
            ret.push_back(A2m+deltaA);
            ret.push_back(B2m-deltaB);
        }// if parallel and has intersection: intersection is a parallelogram, with a pair of lines tangent to Z 
    }
    else{// expect a parallelogram. Z: not now. we want 3, 4, 5 or 6 angle shape . take care! 
 
        HepPoint3D Ptop=getIntersection(A1m+deltaA,directionA,B1m-deltaB,directionB);  // appears wrong size..
        HepPoint3D Prht=getIntersection(A1m+deltaA,directionA,B1m+deltaB,directionB);
        HepPoint3D Plft=getIntersection(A1m-deltaA,directionA,B1m-deltaB,directionB); 
        HepPoint3D Pbot=getIntersection(A1m-deltaA,directionA,B1m+deltaB,directionB);
 
        if (Ptop.z() < Pbot.z()) std::swap(Ptop,Pbot);
 
        HepPoint3D Pmtp=Prht.z()>Plft.z()? Prht: Plft; // median top
        HepPoint3D Pmbt=Prht.z()>Plft.z()? Plft: Prht; // median bottom
 
        HepPoint3D PointsAtMaxZ[2]; //maxz or top
        int PointsAtMaxZCount=0;
        HepPoint3D PointsAtMinZ[2];
        int PointsAtMinZCount=0;
        HepPoint3D PointsLeftGood[1]={Plft};
        int PointsLeftGoodCount=1;
        HepPoint3D PointsRightGood[1]={Prht};
        int PointsRightGoodCount=1;
 
        // a chain of ifs
        if (Ptop.z()<=maxZAllowed){
            PointsAtMaxZ[0]=Ptop;
            PointsAtMaxZCount=1;
        }else if (Ptop.z()>maxZAllowed && maxZAllowed>=Pmtp.z()  ){ // only this 2
            PointsAtMaxZ[0]=interpolate(Ptop,Plft,maxZAllowed);//L
            PointsAtMaxZ[1]=interpolate(Ptop,Prht,maxZAllowed);//R
            PointsAtMaxZCount=2;
        }else if (Pmtp.z()>maxZAllowed && maxZAllowed>= Pmbt.z()  ){ // midian
            PointsAtMaxZ[0]=interpolate(Ptop,Pmbt,maxZAllowed);// Top-mbot
            PointsAtMaxZ[1]=interpolate(Pmtp,Pbot,maxZAllowed);// mrop-Bot
            PointsAtMaxZCount=2;
            if (Plft==Pmtp) {// lft is higher
                std::swap(PointsAtMaxZ[0],PointsAtMaxZ[1]);     // now 0=Left, 0-Right
                PointsLeftGoodCount=0; // so remove left point
            }else{ // rht is higher
                PointsRightGoodCount=0;
            }
 
            // glad i choose not to play it in order
        }else if (Pmbt.z()>maxZAllowed && maxZAllowed>= Pbot.z() ){ // lower
            PointsAtMaxZ[0]=interpolate(Pbot,Plft,maxZAllowed);//L
            PointsAtMaxZ[1]=interpolate(Pbot,Prht,maxZAllowed);//R
            PointsAtMaxZCount=2;
            PointsLeftGoodCount=PointsRightGoodCount=0; // remove both
        }else{ // no---- we got nothing at all
            return ret;
        }
        // and then with minZAllowed
        if ( minZAllowed <=Pbot.z() ){ // 
            PointsAtMinZ[0]=Pbot;
            PointsAtMinZCount=1;
        }else if (Pbot.z() < minZAllowed  && minZAllowed <=Pmbt.z()){ // lower.
            PointsAtMinZ[0]=interpolate(Pbot,Plft,minZAllowed);//L //TODO: change to Pbot
            PointsAtMinZ[1]=interpolate(Pbot,Prht,minZAllowed);//R //TODO: change to Pbot
            PointsAtMinZCount=2;
        }else if (Pmbt.z() < minZAllowed  && minZAllowed <=Pmtp.z()){// mid.
            PointsAtMinZ[0]=interpolate(Ptop,Pmbt,minZAllowed);// Top-mbot
            PointsAtMinZ[1]=interpolate(Pmtp,Pbot,minZAllowed);// mrop-Bot
            PointsAtMinZCount=2;
            if (Plft==Pmtp) {// lft is higher
                std::swap(PointsAtMaxZ[0],PointsAtMaxZ[1]);    // now 0=Left, 0-Right
                PointsRightGoodCount=0; // so remove lower point
            }else{ // rht is higher
                PointsLeftGoodCount=0;
            }
        }else if (Pmtp.z() < minZAllowed  && minZAllowed <=Ptop.z()){// higher
            PointsAtMinZ[0]=interpolate(Ptop,Plft,minZAllowed);//L
            PointsAtMinZ[1]=interpolate(Ptop,Prht,minZAllowed);//R
            PointsAtMinZCount=2;
            PointsRightGoodCount=PointsLeftGoodCount=0;
        }else{
            return ret;
        }
 
        // now insert items in clockwise order.
        for (int i=0;i<PointsAtMaxZCount;i++){
            ret.push_back(PointsAtMaxZ[i]);
        }
        for (int i=0;i<PointsRightGoodCount;i++){
            ret.push_back(PointsRightGood[i]);
        }
        for (int i=PointsAtMinZCount-1;i>=0;i--){//
            ret.push_back(PointsAtMinZ[i]); 
        }
        for (int i=0;i<PointsLeftGoodCount;i++){
            ret.push_back(PointsLeftGood[i]);
        }
 
 
    }
    return ret;
 
}

Referenced by getAdjacentIntersectionBounds(), and testAdjacentIntersection().

getGeneralLayerSize() [1/2]

const int MdcGeomSvc::getGeneralLayerSize ( )

virtual

Implements IMdcGeomSvc.

Definition at line 686 of file bak_MdcGeomSvc-00-01-39/src/MdcGeomSvc.cxx.

{
    return fGenerals.size();
}

getGeneralLayerSize() [2/2]

const int MdcGeomSvc::getGeneralLayerSize ( )

virtual

Implements IMdcGeomSvc.

getLayerSize() [1/2]

const int MdcGeomSvc::getLayerSize ( )

virtual

Implements IMdcGeomSvc.

Definition at line 676 of file bak_MdcGeomSvc-00-01-39/src/MdcGeomSvc.cxx.

{
    return fLayers.size();
}

Referenced by DotsConnection::initialize(), DotsHelixFitter::initialize(), MdcDetector::MdcDetector(), and KalFitAlg::set_Mdc().

getLayerSize() [2/2]

const int MdcGeomSvc::getLayerSize ( )

virtual

Implements IMdcGeomSvc.

getSagFlag() [1/2]

bool MdcGeomSvc::getSagFlag ( void )

static

Definition at line 823 of file bak_MdcGeomSvc-00-01-39/src/MdcGeomSvc.cxx.

                                {
 
    return m_doSag;
}  

Referenced by MdcGeoWire::Sag().

getSagFlag() [2/2]

static bool MdcGeomSvc::getSagFlag ( void )

static

getSegmentNo() [1/2]

const int MdcGeomSvc::getSegmentNo

(

)

Definition at line 691 of file bak_MdcGeomSvc-00-01-39/src/MdcGeomSvc.cxx.

{
    return fEnd.size();
}   

Referenced by BesMdcGeoParameter::InitFromSvc(), and DotsConnection::initialize().

getSegmentNo() [2/2]

const int MdcGeomSvc::getSegmentNo

(

)

getSuperLayerSize() [1/2]

const int MdcGeomSvc::getSuperLayerSize ( )

virtual

Implements IMdcGeomSvc.

Definition at line 681 of file bak_MdcGeomSvc-00-01-39/src/MdcGeomSvc.cxx.

{
    return fSupers.size();
}

Referenced by DotsConnection::initialize(), MdcDetector::MdcDetector(), and KalFitAlg::set_Mdc().

getSuperLayerSize() [2/2]

const int MdcGeomSvc::getSuperLayerSize ( )

virtual

Implements IMdcGeomSvc.

getWireSize() [1/2]

const int MdcGeomSvc::getWireSize ( )

virtual

Implements IMdcGeomSvc.

Definition at line 671 of file bak_MdcGeomSvc-00-01-39/src/MdcGeomSvc.cxx.

{
    return fWires.size();
}

Referenced by DotsConnection::initialize(), MdcDetector::MdcDetector(), and KalFitAlg::set_Mdc().

getWireSize() [2/2]

const int MdcGeomSvc::getWireSize ( )

virtual

Implements IMdcGeomSvc.

handle() [1/2]

void MdcGeomSvc::handle

(

const Incident &

inc

)

this handle function is prepared for special use

Definition at line 743 of file bak_MdcGeomSvc-00-01-39/src/MdcGeomSvc.cxx.

                                          {
    MsgStream log( messageService(), name() );
    log << MSG::DEBUG << "handle: " << inc.type() << endreq;
    IDataProviderSvc* m_eventSvc;
    Gaudi::svcLocator()->service("EventDataSvc", m_eventSvc, true);
    SmartDataPtr<Event::EventHeader> eventHeader(m_eventSvc,"/Event/EventHeader");
    if (!eventHeader) { 
    log << MSG::FATAL << "Could not find Event Header" << endreq;
      }
    if (m_updataalign) return;
    if (inc.type() == "NewRun" ){
        log << MSG::DEBUG << "Begin Event" << endreq;
        clean();
        m_updataalign = true;
    if(m_nomcalignment&&m_mindex==0) {  
        int   RunNo=eventHeader->runNumber();
        if(RunNo<0)  m_readAlignParDataBase=false ;
           else   m_readAlignParDataBase=true;
        m_mindex+=1;
    cout<<"m__RunNo="<<RunNo<<"m_mindex="<<m_mindex<<endl;
        }
   //std::cout<<"############"<<m_readAlignParDataBase<<std::endl;
        ReadFilePar();          
    }
}

handle() [2/2]

void MdcGeomSvc::handle

(

const Incident &

inc

)

initialize() [1/2]

StatusCode MdcGeomSvc::initialize ( )

virtual

Definition at line 73 of file bak_MdcGeomSvc-00-01-39/src/MdcGeomSvc.cxx.

                                    {
    MsgStream log(messageService(), name());
    log << MSG::INFO << name() << ": Start of run initialisation" << endreq;
 
    StatusCode sc = Service::initialize();
    if ( sc.isFailure() ) return sc;
    m_mindex=0; 
    m_updataalign = false;
    IIncidentSvc* incsvc;
    sc = service("IncidentSvc", incsvc);
    int priority = 100;
    if( sc.isSuccess() ){
        incsvc -> addListener(this, "NewRun", priority);
    }
 
    //    ReadFilePar(); //  get geometry data from file SimUtil/dat/Mdc.txt
    // Fill();  //  get geometry data from Database
 
    sc = service("CalibDataSvc", m_pCalibDataSvc, true);
 
    if ( !sc.isSuccess() ) {
        log << MSG::ERROR 
            << "Could not get IDataProviderSvc interface of CalibXmlCnvSvc" 
            << endreq;
        return sc;
    } else {
        log << MSG::DEBUG 
            << "Retrieved IDataProviderSvc interface of CalibXmlCnvSvc" 
            << endreq;
    }
     ReadFilePar(); 
    return StatusCode::SUCCESS;
}

Referenced by main().

initialize() [2/2]

virtual StatusCode MdcGeomSvc::initialize ( )

virtual

Layer() [1/2]

const MdcGeoLayer *const MdcGeomSvc::Layer ( unsigned id )

virtual

Implements IMdcGeomSvc.

Definition at line 786 of file bak_MdcGeomSvc-00-01-39/src/MdcGeomSvc.cxx.

                                {
        if (id < fLayers.size())
            return  fLayers[id];
 
        return 0;
    }

Referenced by BesMdcSD::Distance(), KalFitAlg::execute(), BesMdcGeoParameter::InitFromSvc(), DotsConnection::initialize(), DotsHelixFitter::initialize(), MdcDetector::MdcDetector(), MdcTrackUtil::nLayerTrackPassed(), BesMdcSD::ProcessHits(), KalFitAlg::set_Mdc(), testAdjacentIntersection(), and Wire().

Layer() [2/2]

const MdcGeoLayer *const MdcGeomSvc::Layer ( unsigned id )

virtual

Implements IMdcGeomSvc.

Misc() [1/2]

const MdcGeoMisc *const MdcGeomSvc::Misc

(

void

)

Definition at line 810 of file bak_MdcGeomSvc-00-01-39/src/MdcGeomSvc.cxx.

                    {
    return & fMisc;
}

Referenced by BesMdcGeoParameter::InitFromSvc().

Misc() [2/2]

const MdcGeoMisc *const MdcGeomSvc::Misc

(

void

)

queryInterface() [1/2]

StatusCode MdcGeomSvc::queryInterface ( const InterfaceID & riid, void ** ppvUnknown )

virtual

Definition at line 63 of file bak_MdcGeomSvc-00-01-39/src/MdcGeomSvc.cxx.

                                                                                   {
 
    if ( IID_IMdcGeomSvc.versionMatch(riid) ) { 
        *ppvInterface = static_cast<IMdcGeomSvc*> (this); 
    } else { 
        return Service::queryInterface(riid, ppvInterface) ; 
    }
    return StatusCode::SUCCESS;
}

queryInterface() [2/2]

virtual StatusCode MdcGeomSvc::queryInterface ( const InterfaceID & riid, void ** ppvUnknown )

virtual

SuperLayer() [1/2]

const MdcGeoSuper *const MdcGeomSvc::SuperLayer ( unsigned id )

virtual

Implements IMdcGeomSvc.

Definition at line 794 of file bak_MdcGeomSvc-00-01-39/src/MdcGeomSvc.cxx.

                                     {
        if (id < fSupers.size())
            return  fSupers[id];
 
        return 0;
    }

SuperLayer() [2/2]

const MdcGeoSuper *const MdcGeomSvc::SuperLayer ( unsigned id )

virtual

Implements IMdcGeomSvc.

testAdjacentIntersection()

void MdcGeomSvc::testAdjacentIntersection

(

)

Definition at line 1384 of file MdcGeomSvc-00-01-42/src/MdcGeomSvc.cxx.

                                         {
    clock_t time0=clock();
    ofstream fileout("testAdjacentIntersection.csv");
    MsgStream log(messageService(), name());
    log << MSG::WARNING<<__PRETTY_FUNCTION__<<endreq;
    const char * comma=", ";
    const char * endll="\n"; 
    fileout << "# A_layer" << comma 
        << "A_wireID" << comma 
        << "A_WirePhi(0)" << comma
        // << "A_FWirePos_phi" << comma
        // << "A_BWirePos_phi" << comma
        << "A_Forward_phi" << comma
        << "A_Backward_phi" << comma
        << "B_layer" << comma 
        << "B_wireID" << comma 
        << "B_WirePhi(0)" << comma 
        << "B_Forward_phi" << comma 
        << "B_Backward_phi" << comma 
 
        << "phiL,phiU, zL,zU" << comma
 
        << "wireA.x0, wireA.y0"<<comma
        << "wireB.x0, wireB.y0"<<comma
 
        << "line.a,line.b,line.c,line.x0, line.y0, line.z0, line.Angle2d, line.angle3d, line.cosAngleR"<< comma
        << "line.a,line.b,line.c,line.x0, line.y0, line.z0, line.Angle2d, line.angle3d, line.cosAngleR"<< comma
        << "line.a,line.b,line.c,line.x0, line.y0, line.z0, line.Angle2d, line.angle3d, line.cosAngleR"<< comma
        << "line.a,line.b,line.c,line.x0, line.y0, line.z0, line.Angle2d, line.angle3d, line.cosAngleR"<< comma
 
        << "xa1,ya1,za1" << comma // wireA.Forward
        << "xa2,ya2,za2" << comma // wireA.Backward
        << "xb1,yb1,zb1" << comma // wireB.Forward
        << "xb2,yb2,zb2" << comma // wireB.Backward
        << "x1,y1,z1" << comma //getAdjacentIntersectionShape.x,y,z
        << "x2,y2,z2" << comma
        << "x3,y3,z3" << comma
        << "x4,y4,z4" << endll;
 
    fileout << "# xn yn zn are coordinates of vertex" << endll;
    fileout << "# layer: ";
    for (unsigned i=0;i<43;++i){
        fileout<<comma<<i;
    }fileout << endll;
    fileout << "# layerRadius: ";
    for (unsigned i=0;i<43;++i){
        double r=this->Layer(i)->Radius();
        fileout<<comma<<r;
    }fileout << endll;
    fileout << "# distToNextLayerRadius: ";
    for (unsigned i=0;i<42;++i){
        double r=this->Layer(i+1)->Radius()-this->Layer(i)->Radius();
        fileout<<comma<<r;
    }fileout << endll;
 
    for (size_t _wire_index=0;_wire_index<fWires.size();++_wire_index){
        const MdcGeoWire * wire=fWires[_wire_index];
        // if (wire->Id()!=1726) continue;
        std::vector<MdcGeoWire *> cross_neighbors=wire->GetNeighborType4();
        for (size_t _neighbor_index=0;_neighbor_index<cross_neighbors.size();_neighbor_index++){
            const MdcGeoWire * neighbor=cross_neighbors[_neighbor_index];
            if (abs(neighbor->Layer()-wire->Layer())!=1) continue;
            std::vector<HepPoint3D> shape=getAdjacentIntersectionShape(wire, neighbor);
            std::vector<double> bound=getAdjacentIntersectionBounds(wire, neighbor);
            vector<AdjCandiTgtLine2D> psblines=getAdjacentCandidateWithDriftCircle(wire,neighbor,10,10);
            fileout << wire->Layer() << comma
                << wire->Id() << comma
                << wire->WirePhi(0) << comma
                // << wire->FWirePos().getPhi()<< comma
                // << wire->BWirePos().getPhi()<< comma
                << wire->Forward().getPhi() << comma
                << wire->Backward().getPhi() << comma
 
                << neighbor->Layer() << comma
                << neighbor->Id() << comma
                << neighbor->WirePhi(0) << comma
                << neighbor->Forward().getPhi() << comma
                << neighbor->Backward().getPhi() << comma;
            // << neighbor->FWirePos().getPhi()<<comma
            // << neighbor->BWirePos().getPhi()<<comma;
            // fileout<<"seg"<<comma;
            if (bound.empty()) {
                for (size_t i = 0; i < 4; ++i) fileout << 0. << comma;
            } else {
                for (size_t i = 0; i < bound.size(); i++){
                    fileout << bound.at(i) << comma;
                }
            }
            // fileout<<"seg"<<comma;
            //"wireA.x0, wireA.y0, wireB.x0, wireB.y0"
            double Z0=0;
            if (!psblines.empty())Z0=psblines[0].z0;
 
            fileout 
                << wire    ->GetX(Z0)<<comma
                << wire    ->GetY(Z0)<<comma
                << neighbor->GetX(Z0) << comma
                << neighbor->GetY(Z0) << comma;
            // fileout<<"seg"<<comma;
            {
                for (size_t i = 0; i < psblines.size(); ++i) 
                    fileout
                        <<psblines[i].a << comma
                        <<psblines[i].b << comma
                        <<psblines[i].c << comma
                        <<psblines[i].x0 << comma
                        <<psblines[i].y0 << comma
                        <<psblines[i].z0 << comma
                        <<psblines[i].angle2D << comma
                        <<psblines[i].angle3D << comma
                        <<psblines[i].angleWithR() << comma;
                for (size_t i = psblines.size(); i < 4; ++i)
                    for (size_t ii = 0; ii < 9; ii++)
                        fileout<<'0'<<comma;
            }
            // fileout<<"seg"<<comma;
            {
                HepPoint3D vertex;
                vertex=wire->Forward();
                fileout << vertex.x() << comma << vertex.y() << comma << vertex.z() <<comma;
                vertex=wire->Backward();
                fileout << vertex.x() << comma << vertex.y() << comma << vertex.z() <<comma;
                vertex=neighbor->Forward();
                fileout << vertex.x() << comma << vertex.y() << comma << vertex.z() <<comma;
                vertex=neighbor->Backward();
                fileout << vertex.x() << comma << vertex.y() << comma << vertex.z();// <<comma;
            }
            // fileout<<comma<<"seg";
            // if (shape.empty) // i dont want it to output. a csv don't need to be full-length
            for (size_t i = 0; i < shape.size(); i++){
                HepPoint3D vertex=shape[i];
                fileout <<comma<< vertex.x() << comma << vertex.y() << comma << vertex.z();
                //if (i+1<shape.size()) fileout<<comma; 
                // alittle fix when shape is empty and it will lead to a trailing comma.
            }
            fileout<< endll;
 
        }
    }
    clock_t time1=clock();
    cout<<"test_Adj_Complete, time="<<(time1-time0)*1000./CLOCKS_PER_SEC<<"ms"<<endl;
}

Wire() [1/4]

const MdcGeoWire *const MdcGeomSvc::Wire ( unsigned id )

virtual

Implements IMdcGeomSvc.

Definition at line 770 of file bak_MdcGeomSvc-00-01-39/src/MdcGeomSvc.cxx.

                               {
        if (id < fWires.size())
            return  fWires[id];
 
        return 0;
    }

Referenced by HoughTrack::calculateZ_S(), DotsConnection::CellAutomaton(), BesMdcSD::Distance(), DotsConnection::dotComp(), KalFitAlg::execute(), TrkReco::execute(), KalFitAlg::filter_fwd_anal(), KalFitAlg::filter_fwd_calib(), getAdjacentIntersectionShape(), HoughHit::HoughHit(), DotsConnection::initialize(), DotsHelixFitter::initialize(), main(), DotsConnection::makeDotCellEdge(), MdcDetector::MdcDetector(), DotsConnection::print(), KalFitAlg::set_Mdc(), KalFitAlg::smoother_anal(), KalFitAlg::smoother_calib(), and HoughHit::VHitPosition().

Wire() [2/4]

const MdcGeoWire *const MdcGeomSvc::Wire ( unsigned id )

virtual

Implements IMdcGeomSvc.

Wire() [3/4]

const MdcGeoWire *const MdcGeomSvc::Wire ( unsigned lyrid, unsigned wirid )

virtual

Implements IMdcGeomSvc.

Definition at line 778 of file bak_MdcGeomSvc-00-01-39/src/MdcGeomSvc.cxx.

                                                  {
        if ((lyrid <fLayers.size()) && ((int) wirid < Layer(lyrid)->NCell()))
            return fWires[Layer(lyrid)->Wirst() + wirid];
 
        return 0;
    }

Wire() [4/4]

const MdcGeoWire *const MdcGeomSvc::Wire ( unsigned lyrid, unsigned wirid )

virtual

Implements IMdcGeomSvc.

Member Data Documentation

m_doSag

bool MdcGeomSvc::m_doSag = true

static

Definition at line 54 of file bak_MdcGeomSvc-00-01-39/MdcGeomSvc/MdcGeomSvc.h.

Referenced by getSagFlag(), and MdcGeomSvc().

m_nomcalignment

bool MdcGeomSvc::m_nomcalignment =true

static

Definition at line 56 of file bak_MdcGeomSvc-00-01-39/MdcGeomSvc/MdcGeomSvc.h.

Referenced by handle(), and MdcGeomSvc().

m_readAlignParDataBase

bool MdcGeomSvc::m_readAlignParDataBase = true

static

Definition at line 55 of file bak_MdcGeomSvc-00-01-39/MdcGeomSvc/MdcGeomSvc.h.

Referenced by handle(), and MdcGeomSvc().

---

The documentation for this class was generated from the following files:

• bak_MdcGeomSvc-00-01-39/MdcGeomSvc/MdcGeomSvc.h
• MdcGeomSvc-00-01-42/MdcGeomSvc/MdcGeomSvc.h
• bak_MdcGeomSvc-00-01-39/src/MdcGeomSvc.cxx
• MdcGeomSvc-00-01-42/src/MdcGeomSvc.cxx