/home/bes3soft/bes3soft/Boss/7.0.2/dist/7.0.2/Reconstruction/MdcFastTrkAlg/MdcFastTrkAlg-00-04-09/MdcFastTrkAlg/FTSegment.h

Go to the documentation of this file.

// -*- C++ -*-
//
// Package:     MdcFastTrkAlg
// Module:      FTSegment
// 
// Description:  segment class for MdcFastTrkAlg
//

#ifndef FTSegment_FLAG_
#define FTSegment_FLAG_

#include "MdcFastTrkAlg/FTList.h"
#include "MdcFastTrkAlg/FTWire.h"
#include "MdcFastTrkAlg/FTLayer.h"
#include "MagneticField/IMagneticFieldSvc.h"
#include "MagneticField/MagneticFieldSvc.h"
#include <iostream> 

class FTFinder;
class FTWire;
class FTLayer;
class FTSuperLayer;
class FTTrack;
class FTSegment{
public:

  FTSegment(FTSuperLayer * super, FTList<FTWire *> & hits);

  ~FTSegment();

public: // public member functions
  int examine(void);

#ifndef OnlineMode
  void printout(void);
#endif

  void update(void);

  int update3D(const FTTrack * track);

  void linkStereoSegments(void);

  void connect_outer(const FTList<FTWire *> &, const FTList<FTWire *> &);
  void connect_inner(const FTList<FTWire *> &, const FTList<FTWire *> &);

  void connect_outer(const FTWire *);

  void connect_inner(const FTWire *);

public: // Selectors
  FTList<FTWire *>& wireHits(void) const;

  FTSuperLayer & superLayer(void) const;

  FTList<FTWire *> & innerBoundHits(void) const;

  FTList<FTWire *> & outerBoundHits(void)  const;

  float outgoingX(void) const;

  float outgoingY(void) const;

  float incomingX(void) const;

  float incomingY(void) const;

  float incomingPhi(void) const;

  float outgoingPhi(void) const;

  float attr_const(void) const;
  
  FTTrack * track(void) const;

  float kappa(void) const;

  float r(void) const;

  float s(void) const;

  float z(void) const;

public: // Modifiers
  FTTrack * track(FTTrack *);
  static MdcParameter * param;

private: // private data members
  IMagneticFieldSvc* m_pmgnIMF;
  FTList<FTWire *>& _wireHits; 
  FTSuperLayer & _superLayer;
  FTList<FTWire *> & _innerBoundHits;
  FTList<FTWire *> & _outerBoundHits;
  FTList<float> * _sList;
  union{
    float _kappa;
    FTList<float> * _zList;
  };
  union{
    FTTrack * _track;
    FTList<FTTrack *> * _trackList;
  };
  float _r;
  float _outgoing_x;
  float _outgoing_y;
  float _incoming_x;
  float _incoming_y;
};


inline
FTSegment::FTSegment(FTSuperLayer * super, FTList<FTWire *> & hits)
  : _wireHits(hits),
    _superLayer(*super),
    _innerBoundHits(*(new FTList<FTWire *>(3))),
    _outerBoundHits(*(new FTList<FTWire *>(3))),
    _sList(NULL),
    _zList(NULL),
    _track(NULL)
{
  StatusCode scmgn = Gaudi::svcLocator()->service("MagneticFieldSvc",m_pmgnIMF);
  if(scmgn!=StatusCode::SUCCESS) {
    std::cout<< "Unable to open Magnetic field service"<<std::endl;
  }
}

inline
FTSegment::~FTSegment()
{
  delete &_wireHits;
  delete &_innerBoundHits;
  delete &_outerBoundHits;
  if (_sList){
    delete _sList;
    delete _zList;
    delete _trackList;
  }
}

inline
void
FTSegment::connect_outer(const FTList<FTWire *> & outerHits, 
                         const FTList<FTWire *> & outerBound)
{
  _wireHits.append(outerHits);
  _outerBoundHits.clear();
  _outerBoundHits.append(outerBound);
}

inline
void
FTSegment::connect_inner(const FTList<FTWire *> & innerHits, 
                         const FTList<FTWire *> & innerBound)
{
  _wireHits.append(innerHits);
  _innerBoundHits.clear();
  _innerBoundHits.append(innerBound);
}

inline
void
FTSegment::connect_outer(const FTWire * h)
{
  _wireHits.append((FTWire *)h);
  _outerBoundHits.clear();
  _outerBoundHits.append((FTWire *)h);
}

inline
void
FTSegment::connect_inner(const FTWire * h)
{
  _wireHits.append((FTWire *)h);
  _innerBoundHits.clear();
  _innerBoundHits.append((FTWire *)h);
}

inline
FTSuperLayer & 
FTSegment::superLayer(void) const
{
  return _superLayer;
}

inline
FTList<FTWire *>& 
FTSegment::wireHits(void) const
{
  return _wireHits;
}

inline
FTList<FTWire *>& 
FTSegment::innerBoundHits(void) const
{
  return _innerBoundHits;
}

inline
FTList<FTWire *>& 
FTSegment::outerBoundHits(void) const
{
  return _outerBoundHits;
}

inline
float
FTSegment::outgoingX(void) const
{
  return _outgoing_x;
}

inline
float
FTSegment::outgoingY(void) const
{
  return _outgoing_y;
}

inline
float
FTSegment::incomingX(void) const
{
  return _incoming_x;
}

inline
float
FTSegment::incomingY(void) const
{
  return _incoming_y;
}

inline
float
FTSegment::incomingPhi(void) const
{
  if (_innerBoundHits.length() ^ 1) {
    float phi_1st = _innerBoundHits[0]->phi();
    float phi_2nd = _innerBoundHits[1]->phi();
    float phi = 0.5 * (phi_1st + phi_2nd);
    if (fabs(phi_1st - phi_2nd) > M_PI) {
      return (phi>M_PI) ? (phi-M_PI) : (phi+M_PI);
    }
    return phi;
  }
  return _innerBoundHits[0]->phi();
}

inline
float
FTSegment::outgoingPhi(void) const
{
  if (_outerBoundHits.length() ^ 1) {
    float phi_1st = _outerBoundHits[0]->phi();
    float phi_2nd = _outerBoundHits[1]->phi();
    float phi = 0.5 * (phi_1st + phi_2nd);
    if (fabs(phi_1st - phi_2nd) > M_PI) {
      return (phi>M_PI) ? (phi-M_PI) : (phi+M_PI);
    }
    return phi;
  }
  return _outerBoundHits[0]->phi();
}

inline
float
FTSegment::attr_const(void) const
{
  float x_len = _outgoing_x - _incoming_x;
  float y_len = _outgoing_y - _incoming_y;
  float phi_l = outgoingPhi() - incomingPhi();
  return sin(phi_l) / sqrt(x_len*x_len + y_len*y_len);
}

inline
float
FTSegment::r(void) const
{
  return _r;
}

inline
float
FTSegment::kappa(void) const
{
  return _kappa;
}

inline
float
FTSegment::s(void) const
{
  return _sList->first();
}

inline
float
FTSegment::z(void) const
{
  return _zList->first();
}

inline
FTTrack *
FTSegment::track(void) const
{
  return _track;
}

inline
FTTrack *
FTSegment::track(FTTrack * src)
{
  return _track = src;
}


#endif /* FTSegment_FLAG_ */

---