MucGeoGeneral Class Reference

#include <MucGeoGeneral.h>

Public Member Functions
	MucGeoGeneral ()
	Constructor.
MucGeoGeneral &	operator= (const MucGeoGeneral &orig)
	Assignment constructor.
	MucGeoGeneral (const MucGeoGeneral &orig)
	Copy constructor.
	~MucGeoGeneral ()
	Destructor.
void	Init ()
	Initialize the instance of MucGeoGeneral.
void	InitFromDatabase ()
	Initialize from database.
void	InitFromASCII ()
	Initialize form ASCII.
void	InitFromXML ()
	Initialize from xml.
void	Destroy ()
	Destroy the single instance of MucGeoGeneral.
MucGeoGap *	GetGap (const int part, const int seg, const int gap) const
	Get a pointer to the gap identified by (part,seg,gap).
MucGeoGap *	GetGap (const Identifier id) const
	Get a pointer to the gap identified by Indentifier.
MucGeoStrip *	GetStrip (const int part, const int seg, const int gap, const int strip) const
	Get a pointer to the strip identified by (part,seg,gap,strip).
MucGeoStrip *	GetStrip (const Identifier id) const
	Get a pointer to the strip identified by Indentifier.
int	GetStripNumInGap (const int part, const int seg, const int gap)
int	GetStripNumTotal ()
	Get total number of strips.
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, 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, 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, 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 ()
	Clear the fgpMucGeoGap and fgpMucGeoStrip vector containers.

Static Public Member Functions
static MucGeoGeneral *	Instance ()
	Get a pointer to the single instance of MucGeoGeneral.

Detailed Description

Class MucGeoGeneral contains all of the objects necessary to describe the muon chamber geometry.

Author

Zhengyun You \URL{youzy.nosp@m.@hep.nosp@m..pku..nosp@m.cn}

Definition at line 50 of file MucGeoGeneral.h.

Constructor & Destructor Documentation

MucGeoGeneral() [1/2]

MucGeoGeneral::MucGeoGeneral

(

)

Constructor.

Definition at line 41 of file MucGeoGeneral.cxx.

{ 
  // Default constructor.
}

Referenced by Instance().

MucGeoGeneral() [2/2]

MucGeoGeneral::MucGeoGeneral

(

const MucGeoGeneral &

orig

)

Copy constructor.

~MucGeoGeneral()

MucGeoGeneral::~MucGeoGeneral

(

)

Destructor.

Definition at line 46 of file MucGeoGeneral.cxx.

{ 
  // Destructor.
  MucGeoGap* pGap = 0;
  while(m_gpMucGeoGap.size() > 0){
    map<Identifier, MucGeoGap*>::iterator iter = m_gpMucGeoGap.end();
    pGap = (*iter).second;
    delete pGap;
    m_gpMucGeoGap.erase(iter);
  }
 
  MucGeoStrip* pStrip = 0;
  while(m_gpMucGeoStrip.size() > 0){
    map<Identifier, MucGeoStrip*>::iterator iter = m_gpMucGeoStrip.end();
    pStrip = (*iter).second;
    delete pStrip;
    m_gpMucGeoStrip.erase(iter);
  }
}

Member Function Documentation

Clear()

void MucGeoGeneral::Clear

(

)

Clear the fgpMucGeoGap and fgpMucGeoStrip vector containers.

Destroy()

void MucGeoGeneral::Destroy

(

)

Destroy the single instance of MucGeoGeneral.

FindIntersectGaps()

vector< Identifier > MucGeoGeneral::FindIntersectGaps	(	const int	part,
		const int	gap,
		const HepPoint3D	gPoint,
		const Hep3Vector	gDirection
	)

Find the intersect gap of a trajectory with the given part and gap. The trajectory is given by the position and direction in global coordinate.

Definition at line 507 of file MucGeoGeneral.cxx.

{
  // Find the intersect gap of a trajectory with the given part and gap. The trajectory is
  // given by the position gPoint and direction gDirection in global coordinate.
  vector<Identifier> gapList;
 
  MucGeoGap *pGap = 0;
  Identifier  id = MucID::channel_id(0,0,0,0);
  HepPoint3D intersection, localIntersection;
  Hep3Vector intersectionDir;
  double cos = -1;
 
  for(unsigned int seg = 0; seg < MucID::getSegNum(part); seg++) {
    id = MucID::channel_id(part, seg, gap, 0);
    pGap = GetGap(id);
    if( pGap ) {
      intersection      = pGap->ProjectToGap(gPoint, gDirection);
      localIntersection = pGap->TransformToGap(intersection);
 
      intersectionDir = ((CLHEP::Hep3Vector)intersection) - ((CLHEP::Hep3Vector)gPoint);
      if( intersectionDir.mag() == 0 ) {
    cos = 0.0;
      }
      else {
    cos = intersectionDir.dot(gDirection) / 
      ( intersectionDir.mag() * gDirection.mag() );
      }
      
      if( ( cos >= 0.0 ) &&
      ( pGap->IsInGap(localIntersection.x(),
              localIntersection.y(),
              localIntersection.z()) ) ) { 
    id = MucID::channel_id(part, seg, gap, 0);
    gapList.push_back(id);
      }
      else {
      }
    
    }
    else{
      std::cout << "MucGeoGeneral::FindIntersectGaps(), Bad gap Pointer" 
        << "  part " << part 
        << "  seg "  << seg 
        << "  gap "  << gap 
        << std::endl;
    }
  }
  
  return gapList;
}

Referenced by FindIntersectStrips(), and main().

FindIntersection() [1/2]

void MucGeoGeneral::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
	)

Find the intersection position of a trajectory with the given gap. The trajectory is given by unit vector (vx,vy,vz) and intercept (x0,y0,z0) in global coordinates, such that (x-x0)/vx = (y-y0)/vy = (z-z0)/vz . If more than one seg lies along the trajectory, take the first one intersect with the trajectory.

Definition at line 783 of file MucGeoGeneral.cxx.

{
  x = 0.0; sigmaX = 0.0;
  y = 0.0; sigmaY = 0.0;
  z = 0.0; sigmaZ = 0.0;
 
  if ( (part < 0) || (part >= (int)MucID::getPartNum()) ) {
    cout << "MucGeoGeneral::FindIntersection-E101  invalid part = "
     << part << endl;
    return;
  }
 
  if ( (gap < 0) || (gap >= (int)MucID::getGapNum(part)) ) {
    //cout << "MucGeoGeneral::FindIntersection-E102  invalid gap = "
    // << gap << endl;
    return;
  }
  
  // "Brute-force" algorithm.
  //   1a. Find intersection with gap.
  //   1b. Transform intersection position to gap coords.
  //   2.  Check intersection position against gap boundaries.
  //       Save the intersection position and gap id if within
  //       boundaries.
 
  //bool found = false;
  float distance = 1e30;
  
  MucGeoGap *p = GetGap(part, seg, gap);
  if (p) {
    
    Hep3Vector  v(vx, vy, vz);
    HepPoint3D r0(x0, y0, z0);  // MucGeoGeneral::FindIntersection
   
    //Hep3Vector  vSigma(sigmaVx, sigmaVy, sigmaVz);
    //HepPoint3D r0Sigma(sigmaX0, sigmaY0, sigmaZ0);
 
    //HepPoint3D gCross(0.0, 0.0, 0.0);
    //HepPoint3D gCrossSigma(0.0, 0.0, 0.0);
    //cout <<"in MucGeoGeneral v ro"<< v << r0 << endl;
    //HepPoint3D r = p->ProjectToGapWithSigma(r0, v, r0Sigma, vSigma, gCross, gCrossSigma);
    HepPoint3D r = p->ProjectToGap(r0, v);
    HepPoint3D localIntersection = p->TransformToGap(r);
    //cout << "intersect gap point " << r << " local " << localIntersection << endl;    
 
 
    distance = r.distance(r0);
 
    x = r.x();
    y = r.y();
    z = r.z();
    
    //sigmaX = gCrossSigma.x();
    //sigmaY = gCrossSigma.y();
    //sigmaZ = gCrossSigma.z();
    
    
    // Should be in Gap? 
    // No, return intersection position however. 
 
    //if ( p->IsInGap(localIntersection.x(),
    //      localIntersection.y(),
    //      localIntersection.z()) ) {
    //cout << "found project in gap" << endl;
    //  found = true;
    //}
    //else{
    //cout << " not in gap" << endl;
    //}
 
 
  }
  
  else {
    cout << "FindIntersection-E103  bad panel pointer!"
     << "  Part" << part << " Seg" << seg << " Gap" << gap << endl;
  }
  
  // FIXME:  need a calculation of the uncertainty in the intercept!
  
  return;
}

Referenced by MucRec2DRoad::GetSearchWindowSize(), MucRec3DRoad::Project(), MucRec2DRoad::Project(), MucRec3DRoad::ProjectNoCurrentGap(), and MucRec3DRoad::ProjectWithSigma().

FindIntersection() [2/2]

void MucGeoGeneral::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,
		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
	)

Find the intersection position of a trajectory with the given gap. The trajectory is given by a parabola and a line in global coordinates, If more than one seg lies along the trajectory, take the first one whichhalf help to judge which intersection position is better, x1,y1,z1 return the better one . now reserver x2,y2,z2 temp.

Definition at line 977 of file MucGeoGeneral.cxx.

{
  x1 = 0.0; sigmaX = 0.0; x2 = 0.0;
  y1 = 0.0; sigmaY = 0.0; y2 = 0.0;
  z1 = 0.0; sigmaZ = 0.0; z2 = 0.0; 
 
  if ( (part < 0) || (part >= (int)MucID::getPartNum()) ) {
    cout << "MucGeoGeneral::FindIntersection-E101  invalid part = "
     << part << endl;
    return;
  }
 
  if ( (gap < 0) || (gap >= (int)MucID::getGapNum(part)) ) {
    //cout << "MucGeoGeneral::FindIntersection-E102  invalid gap = "
    // << gap << endl;
    return;
  }
  
  // "Brute-force" algorithm.
  //   1a. Find intersection with gap.
  //   1b. Transform intersection position to gap coords.
  //   2.  Check intersection position against gap boundaries.
  //       Save the intersection position and gap id if within
  //       boundaries.
 
  //bool found = false;
  float distance = 1e30;
  
  MucGeoGap *p = GetGap(part, seg, gap);
  if (p) {
    
    HepPoint3D r0(x0, y0, z0);  // MucGeoGeneral::FindIntersection
    
 
    
    HepPoint3D cross1(0,0,0), cross2(0,0,0);
    //cout <<"in MucGeoGeneral v ro"<< v << r0 << endl;
    HepPoint3D r = p->ProjectToGap(r0, vy, y0, a, b, c,whichhalf, cross1, cross2);
    //cout<<"in MucGeoGeneral r_quad = "<<r<<endl;
    HepPoint3D localIntersection = p->TransformToGap(r);
    //cout << "intersect gap point " << r << " local " << localIntersection << endl;    
 
    distance = r.distance(r0);
 
    x1 = cross1.x();
    y1 = cross1.y();
    z1 = cross1.z();
 
    x2 = cross2.x();
    y2 = cross2.y();
    z2 = cross2.z();
    
    // Should be in Gap? 
    // No, return intersection position however. 
 
    //if ( p->IsInGap(localIntersection.x(),
    //      localIntersection.y(),
    //      localIntersection.z()) ) {
    //cout << "found project in gap" << endl;
    //  found = true;
    //}
    //else{
    //cout << " not in gap" << endl;
    //}
  }
  
  else {
    cout << "FindIntersection-E103  bad panel pointer!"
     << "  Part" << part << " Seg" << seg << " Gap" << gap << endl;
  }
  
  // FIXME:  need a calculation of the uncertainty in the intercept!
  
  return;
}

FindIntersectionQuadLocal()

void MucGeoGeneral::FindIntersectionQuadLocal	(	const int	part,
		const int	seg,
		const int	gap,
		const float	a,
		const float	b,
		const float	c,
		const int	whichhalf,
		float &	x1,
		float &	y1,
		float &	z1,
		float &	x2,
		float &	y2,
		float &	z2,
		float &	sigmaX,
		float &	sigmaY,
		float &	sigmaZ
	)

Definition at line 887 of file MucGeoGeneral.cxx.

{
  x1 = 0.0; sigmaX = 0.0; x2 = 0.0;
  y1 = 0.0; sigmaY = 0.0; y2 = 0.0;
  z1 = 0.0; sigmaZ = 0.0; z2 = 0.0;
 
  if ( (part < 0) || (part >= (int)MucID::getPartNum()) ) {
    cout << "MucGeoGeneral::FindIntersection-E101  invalid part = "
         << part << endl;
    return;
  }
 
  if ( (gap < 0) || (gap >= (int)MucID::getGapNum(part)) ) {
    //cout << "MucGeoGeneral::FindIntersection-E102  invalid gap = "
        // << gap << endl;
    return;
  }
 
 
  float distance = 1e30;
 
  MucGeoGap *p = GetGap(part, seg, gap);
  if (p) {
 
    int orient = 0;
    if(part == 1 && gap%2 == 0) orient = 1;
    if(part != 1 && gap%2 == 1) orient = 1;
 
    HepPoint3D cross1(0,0,0), cross2(0,0,0);
    //cout <<"in MucGeoGeneral v ro"<< v << r0 << endl;
    HepPoint3D r = p->ProjectToGapQuadLocal(part, orient, a, b, c,whichhalf, cross1, cross2);
    //cout<<"in MucGeoGeneral r_quad = "<<r<<endl;
    HepPoint3D localIntersection = p->TransformToGap(r);
    //cout << "intersect gap point " << r << " local " << localIntersection << endl;    
 
 
    x1 = cross1.x();
    y1 = cross1.y();
    z1 = cross1.z();
 
    x2 = cross2.x();
    y2 = cross2.y();
    z2 = cross2.z();
 
    // Should be in Gap? 
    // No, return intersection position however. 
 
    //if ( p->IsInGap(localIntersection.x(),
    //      localIntersection.y(),
    //      localIntersection.z()) ) {
    //cout << "found project in gap" << endl;
    //  found = true;
    //}
    //else{
    //cout << " not in gap" << endl;
    //}
  }
 
  else {
    cout << "FindIntersection-E103  bad panel pointer!"
         << "  Part" << part << " Seg" << seg << " Gap" << gap << endl;
  }
 
  return;
 
}

Referenced by MucRec3DRoad::ProjectNoCurrentGap().

FindIntersections()

vector< HepPoint3D > MucGeoGeneral::FindIntersections	(	const int	part,
		const int	gap,
		const HepPoint3D	gPoint,
		const Hep3Vector	gDirection
	)

Find the intersection position of a trajectory with the given part and gap. The trajectory is given by the position and direction in global coordinate.

Definition at line 731 of file MucGeoGeneral.cxx.

{
  // Find the intersection position of a trajectory with the given part and gap.
  // The trajectory is given by the position and direction in global coordinate.
  vector<HepPoint3D> intersectionList;
  MucGeoGap* pGap;
 
  HepPoint3D intersection, localIntersection;
  Hep3Vector intersectionDir;
  double cos = -1;
 
  for(unsigned int seg = 0; seg < MucID::getSegNum(part); seg++ ) {
    pGap = GetGap(part, seg, gap);
    if( pGap ) {
      intersection      = pGap->ProjectToGap(gPoint, gDirection);
      localIntersection = pGap->TransformToGap(intersection);
      //cout << localIntersection << endl;
 
      intersectionDir = ((CLHEP::Hep3Vector)intersection) - ((CLHEP::Hep3Vector)gPoint);
      if( intersectionDir.mag() == 0 ) {
    cos = 0.0;
      }
      else {
    cos = intersectionDir.dot(gDirection) / 
      ( intersectionDir.mag() * gDirection.mag() );
      }
      
      if( ( cos >= 0.0 ) &&
      ( pGap->IsInGap(localIntersection.x(),
              localIntersection.y(),
              localIntersection.z()) ) ) { 
    intersectionList.push_back(intersection);
      }
      else {
      }
    }
    else{
    }
  }
 
  return intersectionList;
}

Referenced by main(), and RecMucTrack::Project().

FindIntersectionSurface() [1/2]

void MucGeoGeneral::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
	)

Definition at line 1085 of file MucGeoGeneral.cxx.

{
  x1 = 0.0; sigmaX1 = 0.0;
  y1 = 0.0; sigmaY1 = 0.0;
  z1 = 0.0; sigmaZ1 = 0.0;
  x2 = 0.0; sigmaX2 = 0.0;
  y2 = 0.0; sigmaY2 = 0.0;
  z2 = 0.0; sigmaZ2 = 0.0;
 
  if ( (part < 0) || (part >= (int)MucID::getPartNum()) ) {
    cout << "MucGeoGeneral::FindIntersection-E101  invalid part = "
     << part << endl;
    return;
  }
 
  if ( (gap < 0) || (gap >= (int)MucID::getGapNum(part)) ) {
    //cout << "MucGeoGeneral::FindIntersection-E102  invalid gap = "
    // << gap << endl;
    return;
  }
  
  // "Brute-force" algorithm.
  //   1a. Find intersection with gap.
  //   1b. Transform intersection position to gap coords.
  //   2.  Check intersection position against gap boundaries.
  //       Save the intersection position and gap id if within
  //       boundaries.
 
  //bool found = false;
  float distance = 1e30;
  
  MucGeoGap *p = GetGap(part, seg, gap);
  if (p) {
    
    Hep3Vector  v(vx, vy, vz);
    HepPoint3D r0(x0, y0, z0);  // MucGeoGeneral::FindIntersection
    
 
    //cout <<"in MucGeoGeneral v ro"<< v << r0 << endl;
 
    HepPoint3D cross1, cross2;
    p->ProjectToGapSurface(r0, v, cross1, cross2);
 
    x1 = cross1.x();
    y1 = cross1.y();
    z1 = cross1.z();
    x2 = cross2.x();
    y2 = cross2.y();
    z2 = cross2.z();
 
    // Should be in Gap? 
    // No, return intersection position however. 
 
    //if ( p->IsInGap(localIntersection.x(),
    //      localIntersection.y(),
    //      localIntersection.z()) ) {
    //cout << "found project in gap" << endl;
    //  found = true;
    //}
    //else{
    //cout << " not in gap" << endl;
    //}
  }
  
  else {
    cout << "FindIntersection-E103  bad panel pointer!"
     << "  Part" << part << " Seg" << seg << " Gap" << gap << endl;
  }
  
  // FIXME:  need a calculation of the uncertainty in the intercept!
  
  return;
}

Referenced by MucRec3DRoad::Project().

FindIntersectionSurface() [2/2]

void MucGeoGeneral::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,
		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
	)

Find the intersection position of a trajectory with two surfaces of the given gap. The trajectory is given by a parabola and a line in global coordinates, If more than one seg lies along the trajectory, take the first one whichhalf help to judge which intersection position is better,and return the better one only. x1,y1,z1 is the intersection position with inner surface and x2,y2,z2 be the outer!

Definition at line 1188 of file MucGeoGeneral.cxx.

{
  x1 = 0.0; sigmaX = 0.0; x2 = 0.0;
  y1 = 0.0; sigmaY = 0.0; y2 = 0.0;
  z1 = 0.0; sigmaZ = 0.0; z2 = 0.0; 
 
  if ( (part < 0) || (part >= (int)MucID::getPartNum()) ) {
    cout << "MucGeoGeneral::FindIntersection-E101  invalid part = "
     << part << endl;
    return;
  }
 
  if ( (gap < 0) || (gap >= (int)MucID::getGapNum(part)) ) {
    //cout << "MucGeoGeneral::FindIntersection-E102  invalid gap = "
    // << gap << endl;
    return;
  }
  
  // "Brute-force" algorithm.
  //   1a. Find intersection with gap.
  //   1b. Transform intersection position to gap coords.
  //   2.  Check intersection position against gap boundaries.
  //       Save the intersection position and gap id if within
  //       boundaries.
 
  //bool found = false;
  float distance = 1e30;
  
  MucGeoGap *p = GetGap(part, seg, gap);
  if (p) {
    
    HepPoint3D r0(x0, y0, z0);  // MucGeoGeneral::FindIntersection
    
 
    
    HepPoint3D cross1(0,0,0), cross2(0,0,0);
    p->ProjectToGapSurface(r0, vy, y0, a, b, c,whichhalf, cross1, cross2);
 
 
    x1 = cross1.x();
    y1 = cross1.y();
    z1 = cross1.z();
 
    x2 = cross2.x();
    y2 = cross2.y();
    z2 = cross2.z();
    
    // Should be in Gap? 
    // No, return intersection position however. 
 
    //if ( p->IsInGap(localIntersection.x(),
    //      localIntersection.y(),
    //      localIntersection.z()) ) {
    //cout << "found project in gap" << endl;
    //  found = true;
    //}
    //else{
    //cout << " not in gap" << endl;
    //}
  }
  
  else {
    cout << "FindIntersection-E103  bad panel pointer!"
     << "  Part" << part << " Seg" << seg << " Gap" << gap << endl;
  }
  
  // FIXME:  need a calculation of the uncertainty in the intercept!
  
  return;
}

FindIntersectStrips() [1/2]

vector< Identifier > MucGeoGeneral::FindIntersectStrips	(	const int	part,
		const int	gap,
		const HepPoint3D	gPoint,
		const Hep3Vector	gDirection
	)

Find the intersect strip of a trajectory with the given part and gap. The trajectory is given by the position and direction in global coordinate.

Definition at line 562 of file MucGeoGeneral.cxx.

{
  // Find the intersect strip of a trajectory with the given part and gap. The trajectory is
  // given by the position gPoint and direction gDirection in global coordinate.
  vector<Identifier> gapList;
  vector<Identifier> stripList;
  
  MucGeoGap   *pGap;
  MucGeoStrip *pStrip;
  
  int seg, iStripGuess, nStripMax;
  Identifier id;
  HepPoint3D intersection, localIntersection;
  Hep3Vector localDirection;
 
  gapList = FindIntersectGaps(part, gap, gPoint, gDirection);
 
  for(unsigned int i = 0; i < gapList.size(); i++) {
    // Get the gap data ...
    seg = MucID::seg(gapList[i]);
    pGap = GetGap(part, seg, gap);
    if(!pGap) {
      cout << "FindIntersectStrips : bad gap pointer!" << endl;
      return stripList;
    }
 
    intersection      = pGap->ProjectToGap(gPoint, gDirection);
    localIntersection = pGap->TransformToGap(intersection);
    localDirection    = pGap->RotateToGap(gDirection);
 
    // Search through gap to find the intersect strips.
    nStripMax   = pGap->GetStripNum() - 1;
    iStripGuess = pGap->GuessStrip(localIntersection.x(),
                   localIntersection.y(),
                   localIntersection.z());     
    //cout << "guess " << iStripGuess << endl;
 
    int iStripLow  = iStripGuess - 2;
    int iStripHigh = iStripGuess + 2;
    iStripLow  = max(0, iStripLow);
    iStripHigh = min(nStripMax,  iStripHigh);
 
    iStripLow = 0;
    iStripHigh = nStripMax;
 
    //cout << "intersection      : " << intersection << endl 
    // << "localIntersection : " << localIntersection << endl
    // << "localDirection    : " << localDirection << endl;
 
    for(int j = iStripLow; j < iStripHigh; j++) {
      pStrip = pGap->GetStrip(j);
    
       if(pStrip->CrossGasChamber(localIntersection, localDirection)) {
    id = MucID::channel_id(part, seg, gap, j);  
    stripList.push_back(id);
      }
    }
   
  }
 
  return stripList;
}

Referenced by main(), and MucRec3DRoad::ProjectToStrip().

FindIntersectStrips() [2/2]

vector< Identifier > MucGeoGeneral::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
	)

Definition at line 631 of file MucGeoGeneral.cxx.

{
  // Find the intersect strip of a trajectory with the given part and gap. The trajectory is
  // given by the position gPoint and direction gDirection in global coordinate.
  vector<Identifier> gapList;
  vector<Identifier> stripList;
  
  MucGeoGap   *pGap;
  MucGeoStrip *pStrip;
  
  int seg, iStripGuess, nStripMax;
  Identifier id;
  HepPoint3D intersection, localIntersection;
  Hep3Vector localDirection;
 
  gapList = FindIntersectGaps(part, gap, gPoint, gDirection);
 
  for(unsigned int i = 0; i < gapList.size(); i++) {
    // Get the gap data ...
    seg = MucID::seg(gapList[i]);
    pGap = GetGap(part, seg, gap);
    if(!pGap) {
      cout << "FindIntersectStrips : bad gap pointer!" << endl;
      return stripList;
    }
 
    intersection      = pGap->ProjectToGap(gPoint, gDirection);
    localIntersection = pGap->TransformToGap(intersection);
    localDirection    = pGap->RotateToGap(gDirection);
 
    // Search through gap to find the intersect strips.
    nStripMax   = pGap->GetStripNum() - 1;
    iStripGuess = pGap->GuessStrip(localIntersection.x(),
                   localIntersection.y(),
                   localIntersection.z());     
    //cout << "guess " << iStripGuess << endl;
 
    int iStripLow  = iStripGuess - 2;
    int iStripHigh = iStripGuess + 2;
    iStripLow  = max(0, iStripLow);
    iStripHigh = min(nStripMax,  iStripHigh);
 
    iStripLow = 0;
    iStripHigh = nStripMax;
 
    //cout << "intersection      : " << intersection << endl 
    // << "localIntersection : " << localIntersection << endl
    // << "localDirection    : " << localDirection << endl;
 
    for(int j = iStripLow; j < iStripHigh; j++) {
      pStrip = pGap->GetStrip(j);
    
       if(pStrip->CrossGasChamber(localIntersection, localDirection)) {
    //get id of intersect strip, now calc pad id!
        /*
        cout<<"Strip: ("<<part<<", "<<seg<<", "<<gap<<", "<<j<<")"<<endl;
    cout<<"xmin: "<<pStrip->GetXmin()<<" xmax: "<<pStrip->GetXmax()<<endl;
        cout<<"ymin: "<<pStrip->GetYmin()<<" ymax: "<<pStrip->GetYmax()<<endl;
    cout<<"zmin: "<<pStrip->GetZmin()<<" zmax: "<<pStrip->GetZmax()<<endl;
    */
    float posx,posy,posz;
        pStrip->GetCenterPos(posx,posy,posz);
    /*
        cout<<"orient:     "<<pGap->Orient()<<endl;
    cout<<"center pos: "<<posx<<" "<<posy<<" "<<posz<<endl;
        cout<<"inter  pos: "<<localIntersection<<endl;
    */
    int padid = -1;
    if(pGap->Orient() == 1)
         padid = (localIntersection.y() - pStrip->GetYmin())/(pStrip->GetXmax() - pStrip->GetXmin());
        else
         padid = (localIntersection.x() - pStrip->GetXmin())/(pStrip->GetYmax() - pStrip->GetYmin());
 
    //cout<<"padID: "<<padid<<endl;
        padID.push_back(padid);
        intersection_x.push_back(localIntersection.x());
        intersection_y.push_back(localIntersection.y());
        intersection_z.push_back(localIntersection.z());
 
    id = MucID::channel_id(part, seg, gap, j);  
    stripList.push_back(id);
      }
    }
   
  }
 
  return stripList;
}

GetGap() [1/2]

MucGeoGap * MucGeoGeneral::GetGap

(

const Identifier

id

)

const

Get a pointer to the gap identified by Indentifier.

Definition at line 461 of file MucGeoGeneral.cxx.

{
  // Get a pointer to the gap identified by Identifier.
  Identifier gapID = MucID::channel_id(MucID::part(id), 
                       MucID::seg(id),
                       MucID::gap(id),
                       0);
  
  return m_gpMucGeoGap[gapID];
}

GetGap() [2/2]

MucGeoGap * MucGeoGeneral::GetGap	(	const int	part,
		const int	seg,
		const int	gap
	)		const

Get a pointer to the gap identified by (part,seg,gap).

Definition at line 450 of file MucGeoGeneral.cxx.

{
  // Get a pointer to the gap identified by (part,seg,gap).
  Identifier gapID = MucID::channel_id(part, seg, gap, 0);
 
  return m_gpMucGeoGap[gapID];
}

Referenced by RecMucTrack::CalculateInsct(), RecMucTrack::ComputeDepth(), RecMucTrack::ComputeDistanceMatch(), MucRecTrkExt::execute(), FindIntersectGaps(), FindIntersection(), FindIntersectionQuadLocal(), FindIntersections(), FindIntersectionSurface(), FindIntersectStrips(), MucGeomSvc::GetGap(), MucRecLineFit::LineFit(), ExtMucKal::MucKalIniti(), MucRecHit::MucRecHit(), MucRecRoadFinder::TrackFinding(), MucRecTrkExt::TrackFinding(), and ExtSteppingAction::UserSteppingAction().

GetStrip() [1/2]

MucGeoStrip * MucGeoGeneral::GetStrip

(

const Identifier

id

)

const

Get a pointer to the strip identified by Indentifier.

Definition at line 485 of file MucGeoGeneral.cxx.

{
  // Get a pointer to the strip identified Identifier.
  return m_gpMucGeoStrip[id];
}

GetStrip() [2/2]

MucGeoStrip * MucGeoGeneral::GetStrip	(	const int	part,
		const int	seg,
		const int	gap,
		const int	strip
	)		const

Get a pointer to the strip identified by (part,seg,gap,strip).

Definition at line 473 of file MucGeoGeneral.cxx.

{
  // Get a pointer to the strip identified by (part, seg, gap, strip).
  Identifier id = MucID::channel_id(part, seg, gap, strip);
 
  return m_gpMucGeoStrip[id];
}

Referenced by MucGeomSvc::GetStrip(), main(), and MucRecHit::MucRecHit().

GetStripNumInGap()

int MucGeoGeneral::GetStripNumInGap ( const int  part, const int  seg, const int  gap  )

inline

Definition at line 96 of file MucGeoGeneral.h.

    { return m_StripNumInGap[part][seg][gap]; }

Referenced by GetStripNumTotal().

GetStripNumTotal()

int MucGeoGeneral::GetStripNumTotal

(

)

Get total number of strips.

Definition at line 492 of file MucGeoGeneral.cxx.

{
  int nStripTotal = 0;
  for(unsigned int part = 0; part < MucID::getPartNum(); part++) {
    for(unsigned int seg = 0; seg < MucID::getSegNum(part); seg++) {
      for(unsigned int gap = 0; gap < MucID::getGapNum(part); gap++) {
    nStripTotal += GetStripNumInGap(part, seg, gap);
      }
    }
  }
 
  return nStripTotal;
}

Referenced by MucGeomSvc::Dump().

Init()

void MucGeoGeneral::Init

(

)

Initialize the instance of MucGeoGeneral.

Definition at line 80 of file MucGeoGeneral.cxx.

{
  for(unsigned int part = 0; part < MucID::getPartNum(); part++) {
    for(unsigned int seg = 0; seg < MucID::getSegMax(); seg++) {
      for(unsigned int gap = 0; gap < MucID::getGapMax(); gap++) {
    m_StripNumInGap[part][seg][gap] = 0;
      }
    }
  }
}

Referenced by main().

InitFromASCII()

void MucGeoGeneral::InitFromASCII

(

)

Initialize form ASCII.

Definition at line 162 of file MucGeoGeneral.cxx.

{
  // Initialize Bes MUC Geometry for ASCII files.
  string gapSizeFile   = "muc-gap-size.dat";
  string gapGeomFile   = "muc-gap-geom.dat";
  string stripSizeFile = "muc-strip-size.dat";
  string stripGeomFile = "muc-strip-geom.dat";
 
  static const int bufSize=512;
  char lineBuf[bufSize];
 
  //
  // File gapSizeFile contains the gap sizes.
  //
 
  ifstream ifGapSize(gapSizeFile.c_str());
  if(!ifGapSize) {
    cout << "error opening gap size data file : "
     << gapSizeFile 
     << endl;
    return;
  }
 
  int part, seg, gap, strip, orient, panel;
  float xGapTemp, yGapTemp, zGapTemp;
  float xGapSize[m_kPartNum][m_kSegMax][m_kGapMax];
  float yGapSize[m_kPartNum][m_kSegMax][m_kGapMax];
  float zGapSize[m_kPartNum][m_kSegMax][m_kGapMax];;
 
  // Read the data line by line until we reach EOF.
 
  while ( ifGapSize.getline(lineBuf,bufSize,'\n')) {
    if (ifGapSize.gcount() > bufSize) {
      cout << "input buffer too small!  gcount = " << ifGapSize.gcount()
       << endl;
      return;
      }
    
    istrstream stringBuf(lineBuf,strlen(lineBuf));
      
    if (stringBuf >> part >> seg >> gap >> xGapTemp >> yGapTemp >> zGapTemp) {
      xGapSize[part][seg][gap] = xGapTemp;
      yGapSize[part][seg][gap] = yGapTemp;
      zGapSize[part][seg][gap] = zGapTemp;
 
      //cout << part << "  " << seg << "  " << gap << "  " 
      //   << " x " << xGapSize[part][seg][gap]
      //   << " y " << yGapSize[part][seg][gap]
      //     << " z " << zGapSize[part][seg][gap]
      //   << endl;
    }
    else {
      // Skip any header or comment lines.
      // cout << "read comment line" << endl;
    }
  }
  
  ifGapSize.close();
  
  //
  // File stripSizeFile contains the strip sizes.
  //
 
  ifstream ifStripSize(stripSizeFile.c_str());
  if (!ifStripSize) {
    cout << "error opening strip size data file : "
     << stripSizeFile 
     << endl;
    return;
  }
 
  float xStripTemp, yStripTemp, zStripTemp;
  float xStripSize[m_kPartNum][m_kSegMax][m_kGapMax][m_kStripMax];
  float yStripSize[m_kPartNum][m_kSegMax][m_kGapMax][m_kStripMax];
  float zStripSize[m_kPartNum][m_kSegMax][m_kGapMax][m_kStripMax];
 
  // Read the data line by line until we reach EOF.
 
  while (ifStripSize.getline(lineBuf,bufSize,'\n')) {
 
    if (ifStripSize.gcount() > bufSize) {
      cout << "input buffer too small!  gcount = " << ifStripSize.gcount()
       << endl;
      return;
    }
 
    istrstream stringBuf(lineBuf,strlen(lineBuf));
 
    if (stringBuf >> part >> seg >> gap >> strip >> xStripTemp >> yStripTemp >> zStripTemp) {
      xStripSize[part][seg][gap][strip] = xStripTemp;
      yStripSize[part][seg][gap][strip] = yStripTemp;
      zStripSize[part][seg][gap][strip] = zStripTemp;
 
      m_StripNumInGap[part][seg][gap]++;
      //cout << part << "  " << seg << "  " << gap << "  " 
      //     << strip << "  " 
      //     << " x " << xStripSize[part][seg][gap][strip]
      //     << " y " << yStripSize[part][seg][gap][strip]
      //     << " z " << zStripSize[part][seg][gap][strip]
      //     << endl;
    }
    else {
      // Skip any header or comment lines.
      //       cout << "read comment line" << endl;
    }
  }
 
  ifStripSize.close();
 
  //for(int part = 0; part < MucSoftID::m_kPart; part++) {
  //for(int seg = 0; seg < MucSoftID::m_kSegInPartMax; seg++) {
  //  for(int gap = 0; gap < MucSoftID::m_kGapInSegMax; gap++) {
  //cout << "nStrips In part " << part << " seg " << seg << " gap " << gap << " is " 
  //     << m_NStripInGap[part][seg][gap] << endl;
  //  }
  //}
  //}
 
  //
  // File gapGeomFile contains the gap positions, etc.
  //
 
  ifstream ifGapGeom(gapGeomFile.c_str());
  if (!ifGapGeom) {
    cout << "error opening gap geometry data file : " 
     << gapGeomFile
     << endl;
    return;
  }
 
  float xGapTarg1, yGapTarg1, zGapTarg1;
  float xGapTarg2, yGapTarg2, zGapTarg2;
  float xGapTarg3, yGapTarg3, zGapTarg3;
  float dzHighEdge;
 
  float dzFarFrontGas, dzNearFrontGas;
  float dzFarBackGas, dzNearBackGas;
 
  float dxTarget1ToFiducial, dyTarget1ToFiducial;
  float dxFiducialToCenter,  dyFiducialToCenter;
 
  Identifier gapID   = MucID::channel_id(0,0,0,0);
  Identifier stripID = MucID::channel_id(0,0,0,0);
 
  // Read the gap geometry data line by line until we reach EOF.
 
  while (ifGapGeom.getline(lineBuf,bufSize,'\n')) {
    
    if ( ifGapGeom.gcount() > bufSize ) {
      cout << "input buffer too small!  gcount = " << ifGapGeom.gcount()
       << endl;
      return;
    }
 
    istrstream stringBuf(lineBuf,strlen(lineBuf));
 
    if ( stringBuf >> part >> seg >> gap >> orient
     >> xGapTarg1 >> yGapTarg1 >> zGapTarg1
     >> xGapTarg2 >> yGapTarg2 >> zGapTarg2
     >> xGapTarg3 >> yGapTarg3 >> zGapTarg3
     >> dzHighEdge 
     >> dzFarFrontGas >> dzNearFrontGas
     >> dzNearBackGas >> dzFarBackGas
     >> dxTarget1ToFiducial
     >> dyTarget1ToFiducial
     >> dxFiducialToCenter
     >> dyFiducialToCenter ) {
      
      //cout << " " << part << " " << seg << "  " << gap 
      //   << " " << xGapTarg1 << " " << yGapTarg1 << " " << zGapTarg1
      //   << " " << xGapTarg2 << " " << yGapTarg2 << " " << zGapTarg2
      //   << " " << xGapTarg3 << " " << yGapTarg3 << " " << zGapTarg3
      //   << " " << dzHighEdge 
      //   << " " << dzFarFrontGas << " " << dzNearFrontGas
      //   << " " << dzFarBackGas  << " " << dzNearBackGas
      //   << " " << dxTarget1ToFiducial << " " << dyTarget1ToFiducial
      //   << " " << dxFiducialToCenter  << " " << dyFiducialToCenter
      //   << endl;
      
      gapID = MucID::channel_id(part,seg,gap,0);
      
      MucGeoGap *pGap = new MucGeoGap(part, seg, gap,
                      orient, 0,
                      xGapSize[part][seg][gap],
                      yGapSize[part][seg][gap],
                      zGapSize[part][seg][gap],
                      xGapTarg1, yGapTarg1, zGapTarg1,
                      xGapTarg2, yGapTarg2, zGapTarg2,
                      xGapTarg3, yGapTarg3, zGapTarg3,
                      dzHighEdge,
                      dzFarFrontGas, dzNearFrontGas,
                      dzNearBackGas, dzFarBackGas,  
                      dxTarget1ToFiducial,
                      dyTarget1ToFiducial,
                      dxFiducialToCenter,
                      dyFiducialToCenter);
      m_gpMucGeoGap[gapID] = pGap;
    }
    else {
      // Skip any header or comment lines.
      //      cout << "read comment line" << endl;
    }
 
  }
 
  ifGapGeom.close();
 
  //
  // File stripGeomFile contains the strip positions, etc.
  //
 
  ifstream ifStripGeom(stripGeomFile.c_str());
  if (!ifStripGeom) {
    cout << "error opening strip geometry data file" 
     << stripGeomFile
     << endl;
    return;
  }
  
  // Read the strip geometry data line by line until we reach EOF.
 
  float xStripTarg1, yStripTarg1, xStripTarg2, yStripTarg2;
 
  while (ifStripGeom.getline(lineBuf,bufSize,'\n')) {
 
    if (ifStripGeom.gcount() > bufSize) {
      cout << "input buffer too small!  gcount = " << ifStripGeom.gcount()
       << endl;
      return;
    }
 
    istrstream stringBuf(lineBuf,strlen(lineBuf));
 
    if (stringBuf >> part >> seg >> gap >> strip >> panel
    >> xStripTarg1 >> xStripTarg2
    >> yStripTarg1 >> yStripTarg2) {
      
      //       cout << part << " " << seg << " " << gap    << " " 
      //            << strip << " " << panel << " " << orient << " "
      //            << xStripTarg1 << " " << xStripTarg2 << " "
      //            << yStripTarg1 << " " << yStripTarg2
      //            << endl;
 
      MucGeoStrip* pStrip = 0;
      stripID = MucID::channel_id(part,seg,gap,strip);
      gapID   = MucID::channel_id(part,seg,gap,0);
 
      if (!m_gpMucGeoStrip[stripID]) {
    if (m_gpMucGeoGap[gapID]) {
      pStrip = m_gpMucGeoGap[gapID]->AddStrip(strip);
      pStrip->SetStrip(xStripTarg1, xStripTarg2,
               yStripTarg1, yStripTarg2,
               xStripSize[part][seg][gap][strip],
               yStripSize[part][seg][gap][strip],
               zStripSize[part][seg][gap][strip]);
      m_gpMucGeoStrip[stripID] = pStrip;
    }
    else {
      cout << "missing gap" << gapID << endl;
      continue;
    }
      }
 
    }
    else {
      // Skip any header or comment lines.
      //       cout << "read comment line" << endl;
    }
 
  }
 
  ifStripGeom.close();
 
  m_gGeometryInit = 1;  
}

InitFromDatabase()

void MucGeoGeneral::InitFromDatabase

(

)

Initialize from database.

InitFromXML()

void MucGeoGeneral::InitFromXML

(

)

Initialize from xml.

Definition at line 92 of file MucGeoGeneral.cxx.

{
  //new TRint("ROOT GDML converter", 0, 0);
  
  // Initialize Bes Muc Geometry for XML files.
  bool geomanager = true;
  if (!gGeoManager) {
    gGeoManager = new TGeoManager("BesGeo", "Bes geometry");
    geomanager = false;
  }
  //gGeoManager->SetVisOption(0);  // to show all visible volumes.
  //gGeoManager->SetVisLevel(5);
  
  MucROOTGeo *m_MucROOTGeo = new MucROOTGeo();
  
  TGeoVolume *volMuc = m_MucROOTGeo->GetVolumeMuc();
  if(volMuc) std::cout << "Construct Muc from Muc.gdml" << std::endl;
  else       std::cout << "volume Muc not found " << std::endl;
 
  float m_BesR = 5200;
  float m_BesZ = 5680;
  TGeoIdentity *identity = new TGeoIdentity();
  
  TGeoMaterial *mat = new TGeoMaterial("VOID",0,0,0);
  TGeoMedium   *med = new TGeoMedium("MED",1,mat);
  TGeoVolume   *m_Bes = gGeoManager->MakeBox("volBes", med, 0.5*m_BesR, 0.5*m_BesR, 0.5*m_BesZ);
  gGeoManager->SetTopVolume(m_Bes);
  m_Bes->AddNode(volMuc, 0, identity); 
  m_MucROOTGeo->SetChildNo(m_Bes->GetNdaughters()-1); 
  
  gGeoManager->SetDrawExtraPaths();  // draw physical node or not;
  if(!geomanager)gGeoManager->CloseGeometry();
  gGeoManager->SetNsegments(20);
 
  m_MucROOTGeo->SetPhysicalNode();
 
  for (int part = 0; part < m_MucROOTGeo->GetPartNum(); part++) {
    for (int seg = 0; seg < m_MucROOTGeo->GetSegNum(part); seg++) {
      for (int gap = 0; gap < m_MucROOTGeo->GetGapNum(part); gap++) {
    Identifier gapID = MucID::channel_id(part,seg,gap,0);
 
    float ironThickness = 0.0;
    if (part == 1) {
      if (gap > 0) ironThickness = m_MucROOTGeo->GetAbsorberThickness(part, seg, gap-1);
    }
    else {
      ironThickness = m_MucROOTGeo->GetAbsorberThickness(part, seg, gap);
    }
    //std::cout << "part " << part << " seg " << seg << " gap " << gap << " thick " << ironThickness << std::endl;
 
    int orient = 0;
    if ( (part == 1 && gap % 2 == 0) || (part != 1 && gap % 2 == 1) ) orient = 1;
    MucGeoGap *pGap = new MucGeoGap(part, seg, gap, orient, 0, m_MucROOTGeo->GetPhysicalGap(part, seg, gap), ironThickness); 
    m_gpMucGeoGap[gapID] = pGap;
 
    for (int strip = 0; strip < m_MucROOTGeo->GetStripNum(part, seg, gap); strip++) {
      Identifier stripID = MucID::channel_id(part,seg,gap,strip);
      
          MucGeoStrip* pStrip = m_gpMucGeoGap[gapID]->AddStrip(strip);
      pStrip->SetStrip(m_MucROOTGeo->GetPhysicalStrip(part, seg, gap, strip));
      m_gpMucGeoStrip[stripID] = pStrip;
    }
      }
    }
  }
 
  m_gGeometryInit = 1;  
}

Instance()

MucGeoGeneral * MucGeoGeneral::Instance ( )

static

Get a pointer to the single instance of MucGeoGeneral.

Definition at line 439 of file MucGeoGeneral.cxx.

{
  // Get a pointer to the single instance of MucGeoGeneral.
  if(!m_gpMucGeoGeneral) {
    m_gpMucGeoGeneral = new MucGeoGeneral;
  }
 
  return m_gpMucGeoGeneral;
}

Referenced by RecMucTrack::CalculateInsct(), RecMucTrack::ComputeDepth(), RecMucTrack::ComputeDistanceMatch(), MucRecTrkExt::execute(), MucRec2DRoad::GetSearchWindowSize(), MucRecLineFit::LineFit(), main(), ExtMucKal::MucKalIniti(), MucRecHit::MucRecHit(), MucRec3DRoad::Project(), MucRec2DRoad::Project(), RecMucTrack::Project(), MucRec3DRoad::ProjectNoCurrentGap(), MucRec3DRoad::ProjectToStrip(), MucRec3DRoad::ProjectWithSigma(), MucRecRoadFinder::TrackFinding(), MucRecTrkExt::TrackFinding(), and ExtSteppingAction::UserSteppingAction().

operator=()

MucGeoGeneral & MucGeoGeneral::operator=

(

const MucGeoGeneral &

orig

)

Assignment constructor.

Definition at line 67 of file MucGeoGeneral.cxx.

{
  // Assignment operator.
  if ( this != &orig ) {             // Watch out for self-assignment!
    m_gpMucGeoGeneral = orig.m_gpMucGeoGeneral;
    m_gpMucGeoGap     = orig.m_gpMucGeoGap;
    m_gpMucGeoStrip   = orig.m_gpMucGeoStrip;
  }
  return *this;
}

---

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

• MucGeoGeneral.h
• MucGeoGeneral.cxx