FTWire.cxx

Go to the documentation of this file.

#include "FTWire.h"
#include "FTGeom.h"
#include "FTLayer.h"
#include "FTSuperLayer.h"
 
#include <iostream>
 
FTWire::FTWire( const float x, const float y, const float dx, const float dy, const int wireId,
                FTLayer* layer, const float phi )
    : _x( x ) // x position in z = 0;
    , _y( y ) // y position in z = 0;
    , _dx( dx )
    , _dy( dy )
    , _wireId( wireId )
    , _distance( 0 )
    , _t0( 0 )
    , _time( 0 )
    , m_adc( 0 )
    , _pedestal( 0 )
    , _layer( layer )
    , _phi( phi )
    , _state( FTWireHitInvalid ) {
  _neighbor.fill( nullptr );
}
 
FTWire::FTWire()
    : _x( 0 )
    , _y( 0 )
    , _dx( 0 )
    , _dy( 0 )
    , _layer( nullptr )
    , _phi( 0 )
    , _distance( 0 )
    , _t0( 0 )
    , _time( 0 )
    , m_adc( 0 )
    , _pedestal( 0 )
    , _state( FTWireHitInvalid ) {
  _neighbor.fill( nullptr );
}
 
const int FTWire::localId() const {
  return FTGeom::instance()->wire2wireIndexLayer( _wireId );
}
 
float FTWire::distance_z() const { return _distance * std::fabs( _layer->tanSlant() ); }
 
void FTWire::initNeighbor() {
  getInnerNeighbor();
  getMidNeighbor();
  getOuterNeighbor();
}
 
void FTWire::getInnerNeighbor() {
  auto geom = FTGeom::instance();
  if ( _layer->localLayerId() == 0 )
  {
    _neighbor[0] = _neighbor[1] = geom->getVirtualWire();
    return;
  }
 
  float thisPhi = phi();
 
  int innerLayer_id = _layer->layerId() - 1;
  int n             = geom->layer2nWires( innerLayer_id );
  int low = 0, high = n - 1, mid = 0;
  int innerPosition = 1;
 
  const int lastInnerId = geom->layer2wireEnd( innerLayer_id );
 
  while ( low <= high )
  {
    mid = ( low + high ) / 2;
    if ( geom->getWire( lastInnerId - mid )->phi() <= thisPhi ) high = mid - 1;
    else low = mid + 1;
  }
 
  innerPosition = mid;
 
  if ( geom->getWire( lastInnerId - innerPosition )->phi() <= thisPhi )
  {
    _neighbor[0] = geom->getWire( lastInnerId - innerPosition );
    if ( innerPosition == 0 ) _neighbor[1] = geom->getWire( lastInnerId - n + 1 );
    else _neighbor[1] = geom->getWire( lastInnerId - innerPosition + 1 );
  }
  else
  {
    if ( ( innerPosition + 1 ) == n ) _neighbor[0] = geom->getWire( lastInnerId );
    else _neighbor[0] = geom->getWire( lastInnerId - innerPosition - 1 );
    _neighbor[1] = geom->getWire( lastInnerId - innerPosition );
  }
}
 
void FTWire::getOuterNeighbor() {
  if ( !_layer )
  {
    std::cout << "this: " << this << "FTWire::getOuterNeighbor: _layer is nullptr"
              << std::endl;
  }
 
  auto geom = FTGeom::instance();
 
  int superLayer_id = geom->wire2superLayer( _wireId );
  int layerMaxId    = geom->superLayer2nLayers( superLayer_id ) - 1;
 
  if ( _layer->localLayerId() == layerMaxId )
  {
    _neighbor[4] = _neighbor[5] = geom->getVirtualWire();
    return;
  }
 
  float thisPhi = phi();
 
  int outerLayer_id = _layer->layerId() + 1;
  int n             = geom->layer2nWires( outerLayer_id );
  int low = 0, high = n - 1, mid = 0;
  int position;
 
  const int firstOuterId = geom->layer2wireStart( outerLayer_id );
 
  while ( low <= high )
  {
    mid = ( low + high ) / 2;
    if ( geom->getWire( firstOuterId + mid )->phi() > thisPhi ) high = mid - 1;
    else low = mid + 1;
  }
 
  position = mid;
  if ( geom->getWire( firstOuterId + position )->phi() <= thisPhi )
  {
    _neighbor[4] = geom->getWire( firstOuterId + position );
    if ( ( position + 1 ) == n ) _neighbor[5] = geom->getWire( firstOuterId );
    else _neighbor[5] = geom->getWire( firstOuterId + position + 1 );
  }
  else
  {
    if ( ( position - 1 ) == -1 ) _neighbor[4] = geom->getWire( firstOuterId + n - 1 );
    else _neighbor[4] = geom->getWire( firstOuterId + position - 1 );
    _neighbor[5] = geom->getWire( firstOuterId + position );
  }
}
 
void FTWire::getMidNeighbor() {
  _neighbor[2] = (FTWire*)left();
  _neighbor[3] = (FTWire*)right();
}
 
void FTWire::clear() {
  _distance = 0.;
  _time     = 0.;
  _t0       = 0.;
  m_adc     = 0.0;
  _pedestal = 0.;
  _state    = FTWireHitInvalid;
}
 
int FTWire::z( const Lpav& la, double& z ) const {
  HepVector center = la.center();
  double    rho    = la.radius();
  double    dx2    = center( 1 ) - _x;
  double    dy2    = center( 2 ) - _y;
  double    par1   = _dx * _dx + _dy * _dy;
  double    par2   = ( _dx * dx2 + _dy * dy2 ) / par1;
  double    par3   = _dx * dy2 - _dy * dx2;
  double    par4   = rho * rho * par1 - par3 * par3;
 
  if ( par4 < 0. ) return 0;
 
  par4         = std::sqrt( par4 ) / par1;
  double delta = par2 + par4;
 
  if ( delta >= 0. && delta < 1. )
  {
    z = _layer->zf() + delta * ( _layer->zb() - _layer->zf() );
    return 1;
  }
  else
  {
    delta = par2 - par4;
    if ( delta >= 0. && delta < 1. )
    {
      z = _layer->zf() + delta * ( _layer->zb() - _layer->zf() );
      return 1;
    }
  }
  return 0;
}
 
void FTWire::chk_left_and_right() {
  if ( ( _neighbor[2]->state() & FTWireHit ) && ( _neighbor[3]->state() & FTWireHit ) )
  {
    _state |= FTWireHitInvalid;
    _neighbor[2]->setState( _neighbor[2]->state() | FTWireHitInvalid );
    _neighbor[3]->setState( _neighbor[3]->state() | FTWireHitInvalid );
  }
}
 
const FTWire* FTWire::left() const {
  auto geom = FTGeom::instance();
  if ( _wireId == geom->wire2wireStartLayer( _wireId ) )
    return geom->getWire( geom->wire2wireEndLayer( _wireId ) );
  else return geom->getWire( _wireId - 1 );
}
 
const FTWire* FTWire::right() const {
  auto geom = FTGeom::instance();
  if ( _wireId == geom->wire2wireEndLayer( _wireId ) )
    return geom->getWire( geom->wire2wireStartLayer( _wireId ) );
  else return geom->getWire( _wireId + 1 );
}
 
#ifdef FZISAN_DEBUG
Gen_hepevt* FTWire::hep( Gen_hepevt* src ) { return _hep = src; }
 
Gen_hepevt* FTWire::hep() const { return _hep; }
#endif