FTWire.h

Go to the documentation of this file.

#pragma once
 
#define FTWireHit 1                     // ---- ---- ---- ---- ---- ---- ---- ---x
#define FTWireHitInvalid 2              // ---- ---- ---- ---- ---- ---- ---- --x-
#define FTWireHitAppended 4             // ---- ---- ---- ---- ---- ---- ---- -x--
#define FTWireHitAppendedOrInvalid 6    // ---- ---- ---- ---- ---- ---- ---- -xx-
#define FTWireNeighbor0 8               // ---- ---- ---- ---- ---- ---- ---- x---
#define FTWireNeighbor1 16              // ---- ---- ---- ---- ---- ---- ---x ----
#define FTWireNeighbor2 32              // ---- ---- ---- ---- ---- ---- --x- ----
#define FTWireNeighbor3 64              // ---- ---- ---- ---- ---- ---- -x-- ----
#define FTWireNeighbor4 128             // ---- ---- ---- ---- ---- ---- x--- ----
#define FTWireNeighbor5 256             // ---- ---- ---- ---- ---- ---x ---- ----
#define FTWireHitSegment 16384          // ---- ---- ---- ---- -x-- ---- ---- ----
#define FTWireHitRight 32768            // ---- ---- ---- ---- x--- ---- ---- ----
#define FTWireHitLeft 65536             // ---- ---- ---- ---x ---- ---- ---- ----
#define FTWireHitLinked 131072          // ---- ---- ---- --x- ---- ---- ---- ----
#define FTWireFittingInvalid 0x10000000 // ---x ---- ---- ---- ---- ---- ---- ----
#define FTWireInvalid 0x20000000        // --x- ---- ---- ---- ---- ---- ---- ----
#define FTWireStateMask 0xf0000000      // xxxx ---- ---- ---- ---- ---- ---- ----
 
#ifndef M_PI
#  define M_PI 3.14159265358979323846
#endif
 
#include "FTLayer.h"
#include "TrackUtil/Lpav.h"
 
#include <array>
using std::array;
 
using namespace CLHEP;
 
class FTWire {
public:
  /// constructors
  FTWire( const float x, const float y, const float dx, const float dy, const int wireId,
          FTLayer* layer, const float phi );
  FTWire();
 
  /// destructor
  ~FTWire() {}
 
public: // Selectors
  /// initNeighbor
  void initNeighbor();
 
  /// returns position x
  const float x() const { return _x; }
 
  /// returns position y
  const float y() const { return _y; }
 
  /// returns phi
  float phi() const { return _phi; }
 
  /// returns local ID
  const int localId() const;
 
  /// returns layer
  FTLayer* layer() const { return _layer; }
 
  /// returns pointer of neighbor array
  array<FTWire*, 6>& getNeighbors() { return _neighbor; }
 
  /// returns drift distance
  float distance() const { return _distance; }
 
  /// returns z_distance from the center of wire by drift distance
  float distance_z() const;
 
  /// returns t0 read at begin run
  float t0() const { return _t0; }
 
  /// returns pedestal read at begin run
  float pedestal() const { return _pedestal; }
 
  /// returns state
  unsigned state() const { return _state; }
 
  /// returns state bit
  unsigned stateAND( const unsigned mask ) const { return _state & mask; }
 
  /// returns z for track la
  int z( const Lpav& la, double& z ) const;
 
  /// rerurns TDC time(after t0 subtraction)
  float time() const { return _time; }
 
  // wangdy add:return ADC value
  float getAdc() const { return m_adc; }
 
  // max add:return residual
  float getChi2() const { return m_chi2; }
 
public: // Modifires
  /// clear
  void clear();
 
  /// set drift distance
  float distance( const float distance ) { return _distance = distance; }
 
  /// set t0 at begin-run
  float t0( const float t0 ) { return _t0 = t0; }
 
  /// set pedestal at begin-run
  float pedestal( const float ped ) { return _pedestal = ped; }
 
  /// set state
  unsigned state( const unsigned state ) {
    return _state = ( _state & FTWireStateMask ) | state;
  }
 
  /// set state directly
  void setState( const unsigned state ) { _state = state; }
 
  /// set state bit
  void stateOR( const unsigned mask ) { _state |= mask; }
 
  /// invert state bit
  void stateXOR( const unsigned mask ) { _state ^= mask; }
 
  /// reset state bit
  void stateORXOR( const unsigned mask ) { _state = ( _state | mask ) ^ mask; }
 
  /// check neighbors of phi-side and raise invalid flag if both hits
  void chk_left_and_right();
 
  /// reset time
  float time( float t ) { return _time = t; }
 
  /// set wireId
  void wireId( int wireID ) { _wireId = wireID; }
 
  /// get wireId
  int getWireId() { return _wireId; }
 
  /// wangdy add:set Adc value
  void setAdc( float adc ) { m_adc = adc; }
 
  /// set residual fit chi2
  void setChi2( float chi2 ) { m_chi2 = chi2; }
 
private: // private member functions
  /// returns left wire;
  const FTWire* left() const;
 
  /// returns left wire;
  const FTWire* right() const;
 
  /// compute inner Neighbor
  void getInnerNeighbor();
 
  /// compute outer Neighbor
  void getOuterNeighbor();
 
  /// compute mid Neighbor
  void getMidNeighbor();
 
private: // private data members
  const float  _x;
  const float  _y;
  const float  _dx;
  const float  _dy;
  const float  _phi;
  int          _wireId;
  float        _distance;
  float        _t0;
  float        _time;
  float        _pedestal;
  unsigned int _state;
  float        m_posx;
  float        m_posy;
  float        m_posz;
  float        m_adc;  // wangdy adds
  float        m_chi2; // max adds
 
  FTLayer*          _layer;
  array<FTWire*, 6> _neighbor;
};