FTGeom.cxx

Go to the documentation of this file.

#include "FTGeom.h"
#include "FTLayer.h"
#include "FTSuperLayer.h"
#include "FTWire.h"
 
#include "GaudiKernel/ISvcLocator.h"
 
#include "MdcGeomSvc/IMdcGeomSvc.h"
 
FTGeom::FTGeom() : m_virtualWire( new FTWire() ) {
  m_geom_relationship.clear();
  m_layerGeomInfo.clear();
  m_superLayerGeomInfo.clear();
 
  auto mdcGeomSvc = Gaudi::svcLocator()->service<IMdcGeomSvc>( "MdcGeomSvc" );
  if ( !mdcGeomSvc )
  {
    std::cerr << "FTGeom::FTGeom: can't get MdcGeomSvc" << std::endl;
    return;
  }
 
  const int Nwire = mdcGeomSvc->getWireSize();
  const int Nlyr  = mdcGeomSvc->getLayerSize();
  const int Nsup  = mdcGeomSvc->getSuperLayerSize();
 
  if ( !Nwire || !Nlyr )
  {
    std::cerr << "FTFINDER::GEOCDC not found (please put cdctable before l4)" << std::endl;
    std::cerr << "JOB will stop" << std::endl;
    exit( -1 );
  }
 
  // temporary variables for layer info
  FTList<int> layer_superLayerId( Nlyr, -1 );
  FTList<int> layer_wireStart( Nlyr, 9999 );
  FTList<int> layer_wireEnd( Nlyr, 0 );
 
  // temporary variables for super layer info
  FTList<int> super_layerStart( Nsup, 9999 );
  FTList<int> super_layerEnd( Nsup, 0 );
  FTList<int> super_wireStart( Nsup, 9999 );
  FTList<int> super_wireEnd( Nsup, 0 );
 
  // loop over ids, fill the geometry information
  for ( int wire_id = 0; wire_id < Nwire; wire_id++ )
  {
    int layer_id      = mdcGeomSvc->Wire( wire_id )->Layer();
    int superLayer_id = mdcGeomSvc->Layer( layer_id )->Sup()->Id();
    m_geom_relationship.push_back( std::make_tuple( wire_id, layer_id, superLayer_id ) );
 
    // layer info
    if ( layer_superLayerId[layer_id] < 0 ) layer_superLayerId[layer_id] = superLayer_id;
    layer_wireStart[layer_id] = std::min( layer_wireStart[layer_id], wire_id );
    layer_wireEnd[layer_id]   = std::max( layer_wireEnd[layer_id], wire_id );
 
    // super layer info
    super_layerStart[superLayer_id] = std::min( super_layerStart[superLayer_id], layer_id );
    super_layerEnd[superLayer_id]   = std::max( super_layerEnd[superLayer_id], layer_id );
    super_wireStart[superLayer_id]  = std::min( super_wireStart[superLayer_id], wire_id );
    super_wireEnd[superLayer_id]    = std::max( super_wireEnd[superLayer_id], wire_id );
  }
 
  // fill geom info
  for ( int layer_id = 0; layer_id < Nlyr; layer_id++ )
  {
    m_layerGeomInfo.push_back( FTLayerGeomInfo( layer_id,                     //
                                                layer_superLayerId[layer_id], //
                                                layer_wireStart[layer_id],    //
                                                layer_wireEnd[layer_id]       //
                                                ) );
  }
 
  for ( int superLayer_id = 0; superLayer_id < Nsup; superLayer_id++ )
  {
 
    m_superLayerGeomInfo.push_back( FTSuperLayerGeomInfo( superLayer_id,                   //
                                                          super_layerStart[superLayer_id], //
                                                          super_layerEnd[superLayer_id],   //
                                                          super_wireStart[superLayer_id],  //
                                                          super_wireEnd[superLayer_id]     //
                                                          ) );
  }
 
  // create FTSuperLayer
  for ( int superLayer_id = 0; superLayer_id < Nsup; superLayer_id++ )
  {
    const MdcGeoSuper* superLayer = mdcGeomSvc->SuperLayer( superLayer_id );
    m_superLayers.push_back( new FTSuperLayer( superLayer_id,                          //
                                               superLayer2layerStart( superLayer_id ), //
                                               superLayer2wireStart( superLayer_id ),  //
                                               superLayer2nLayers( superLayer_id ),    //
                                               superLayer2nWires( superLayer_id ) ) );
  }
 
  // create FTLayer
  for ( int layer_id = 0; layer_id < Nlyr; layer_id++ )
  {
    const MdcGeoLayer* layer = mdcGeomSvc->Layer( layer_id );
    m_layers.push_back( new FTLayer( 0.1 * layer->Radius(),              //
                                     layer->Slant(),                     //
                                     0.1 * ( +layer->Length() / 2 ),     //
                                     0.1 * ( -layer->Length() / 2 ),     //
                                     0.1 * layer->Offset(),              //
                                     layer_id,                           //
                                     this->layer2layerIndex( layer_id ), //
                                     this->layer2nWires( layer_id ) ) );
  }
 
  // create FTWire
  for ( auto row : m_geom_relationship )
  {
    int wire_id       = std::get<0>( row );
    int superLayer_id = std::get<2>( row );
 
    const MdcGeoWire* wire  = mdcGeomSvc->Wire( wire_id );
    FTLayer*          layer = getLayer( wire2layer( wire_id ) );
    const float       phi   = (const float)2 * M_PI * wire2wireIndexLayer( wire_id ) /
                          (float)getLayer( wire2layer( wire_id ) )->NWire() +
                      getLayer( wire2layer( wire_id ) )->offset();
 
    if ( superLayer_id == 2 || superLayer_id == 3 || superLayer_id == 4 ||
         superLayer_id == 9 || superLayer_id == 10 )
    {
      m_wires.push_back(
          new FTWire( 0.1 * (float)0.5 * ( wire->Backward().x() + wire->Forward().x() ), //
                      0.1 * (float)0.5 * ( wire->Backward().y() + wire->Forward().y() ), //
                      0.,                                                                //
                      0.,                                                                //
                      wire_id,                                                           //
                      layer,                                                             //
                      phi ) );
    }
    else
    {
      m_wires.push_back(
          new FTWire( 0.1 * (float)wire->Backward().x(),                                    //
                      0.1 * (float)wire->Backward().y(),                                    //
                      0.1 * (float)wire->Forward().x() - 0.1 * (float)wire->Backward().x(), //
                      0.1 * (float)wire->Forward().y() - 0.1 * (float)wire->Backward().y(), //
                      wire_id,                                                              //
                      layer,                                                                //
                      phi ) );
    }
  }
}
 
void FTGeom::init() {
  auto mdcGeomSvc = Gaudi::svcLocator()->service<IMdcGeomSvc>( "MdcGeomSvc" );
  if ( !mdcGeomSvc )
  {
    std::cerr << "FTGeom::FTGeom: can't get MdcGeomSvc" << std::endl;
    return;
  }
 
  const int Nwire = mdcGeomSvc->getWireSize();
  // set neighbor
  for ( int wire_id = 0; wire_id < Nwire; wire_id++ ) { m_wires[wire_id]->initNeighbor(); }
}
 
static FTGeom* instance_ptr = nullptr;
 
FTGeom* FTGeom::instance() {
  if ( !instance_ptr )
  {
    instance_ptr = new FTGeom();
    instance_ptr->init();
  }
  return instance_ptr;
}