MdcDetector.cxx

Go to the documentation of this file.

#include "MdcGeom/MdcDetector.h"
#include "Identifier/MdcID.h"
#include "MdcGeomSvc/IMdcGeomSvc.h"
 
#include "GaudiKernel/Bootstrap.h"
#include "GaudiKernel/IService.h"
#include "GaudiKernel/ISvcLocator.h"
 
static const int _layPerSL            = 4;
MdcDetector*     MdcDetector::_myself = 0;
bool             MdcDetector::_doSag  = false;
 
MdcDetector* MdcDetector::instance( bool doSag ) {
  _doSag = doSag;
  return instance();
}
 
MdcDetector* MdcDetector::instance() {
  if ( 0 == _myself ) { _myself = new MdcDetector(); }
  return _myself;
}
 
MdcDetector::MdcDetector() {
 
  std::cout << " +---------------------------------------------------+\n"
            << " |  Creating Mdc Geometry information                |\n"
            << " +---------------------------------------------------+\n";
 
  // IService* ser;
  // StatusCode sc = Gaudi::svcLocator()->getService("MdcGeomSvc",ser);
  // if (!sc.isSuccess())
  //   std::cout <<" MdcDetector::Could not open Geometry Service"<<std::endl;
  // MdcGeomSvc *mdcsvc = dynamic_cast<MdcGeomSvc*> (ser);
 
  IMdcGeomSvc* mdcsvc = Gaudi::svcLocator()->service<IMdcGeomSvc>( "MdcGeomSvc" );
  if ( !mdcsvc ) std::cout << "MdcDetector::Could not open Geometry Service" << std::endl;
 
  _nSWire = mdcsvc->getWireSize();
  _nLayer = mdcsvc->getLayerSize();
  _nSlay  = mdcsvc->getSuperLayerSize();
 
  _senseWire = new MdcSWire*[_nSWire];
  _dclayer   = new MdcLayer*[_nLayer];
  _slayList  = new MdcSuperLayer*[_nSlay];
 
  // build the sense wires
  for ( int iwire = 0; iwire < _nSWire; iwire++ )
  {
    const MdcGeoWire* geowir = mdcsvc->Wire( iwire );
    HepPoint3D        eastP  = geowir->Backward() / 10.0;
    HepPoint3D        westP  = geowir->Forward() / 10.0;
    // std::cout<< "wire ("<<geowir->Layer()<<","<<geowir->Cell()<<") east "<<eastP <<",west "
    // <<westP << std::endl;//yzhang debug
    double sag = 0.;
    if ( _doSag ) sag = geowir->Sag() / 10.; // mm->cm
 
    // std::cout<<"sag = "<<sag<<" "<< geowir->Sag()<<std::endl;
    _senseWire[iwire] = new MdcSWire( eastP, westP, sag, geowir->Id(), geowir->Cell() );
  }
 
  // build sense wire layers
  for ( int ilay = 0; ilay < _nLayer; ilay++ )
  {
    const MdcGeoLayer* geolay   = mdcsvc->Layer( ilay );
    int                nwir     = geolay->NCell();
    int                firstwir = geolay->Wirst();
    _dclayer[ilay]              = new MdcLayer( ilay, nwir, &_senseWire[firstwir], *this );
    _wires_in_layer[ilay]       = nwir;
  }
 
  // build pointers to make navigation faster
  buildpointers();
 
  // do superlayers
  // --------------
  buildSuperLayers();
  // set nominal cell height for each layer!!!! check!!!!
  double rOther;
  for ( int ilay = 0; ilay < _nLayer; ilay++ )
  {
    if ( ilay == 0 ) { rOther = Layer( ilay + 1 )->rMid(); }
    else { rOther = Layer( ilay - 1 )->rMid(); }
    double height = fabs( Layer( ilay )->rMid() - rOther );
    const_cast<MdcLayer*>( Layer( ilay ) )->setCellHeight( height );
  }
}
 
MdcDetector::~MdcDetector() {
  for ( int iwire = 0; iwire < _nSWire; iwire++ ) { delete _senseWire[iwire]; }
  for ( int ilay = 0; ilay < _nLayer; ilay++ ) { delete _dclayer[ilay]; }
  for ( int islay = 0; islay < _nSlay; islay++ )
  {
    _slayList[islay]->print( std::cout );
    delete _slayList[islay];
  }
 
  delete[] _senseWire;
  delete[] _dclayer;
  delete[] _slayList;
}
 
void MdcDetector::buildpointers( void ) {
  // first layers
  //  for (int index=0; index<lastLayNum()-firstLayNum()+1; index++) {
  for ( int index = 0; index < _nLayer; index++ )
  {
    // initialize
    _nextlay[index]     = 0;
    _prevlay[index]     = 0;
    _nextlayinvw[index] = 0;
    _prevlayinvw[index] = 0;
    //    int layi=index+firstLayNum();
 
    //    if ( !existDet(layi) ) {
    //      ErrMsg(fatal) << " layer # " << layi << " does not exist!" <<endmsg;
    //    }
    //    _dclayer[index] = dchLayer(layi);
 
    // next and previous pointers
    //     if (existDet(layi+1)) { _nextlay[index] = dchLayer(layi+1); }
    //     if (existDet(layi-1)) { _prevlay[index] = _dclayer[index-1]; }
 
    if ( index + 1 < _nLayer ) { _nextlay[index] = Layer( index + 1 ); }
    if ( index > 0 ) { _prevlay[index] = Layer( index - 1 ); }
 
    // next in view pointer
    //     int iview=dchLayer(layi)->view();
    int iview = Layer( index )->view();
    int jndex;
    //    for (jndex=index+1; jndex<lastLayNum()-firstLayNum()+1; jndex++) {
    for ( jndex = index + 1; jndex < _nLayer; jndex++ )
    {
      //      int layj=jndex+firstLayNum();
      //      if ( !existDet(layj) ) {
      //    ErrMsg(fatal) << " layer # " << layj << " does not exist!" <<endmsg;
      //      }
      if ( iview != Layer( jndex )->view() ) continue;
      _nextlayinvw[index] = Layer( jndex + 1 );
      break;
    } //(int jndex=index+1; _dclayer[jndex].Exist(); jndex++)
 
    // prev in view pointer
    for ( jndex = index - 1; jndex >= 0; jndex-- )
    {
      //      int layj=jndex+firstLayNum();
      //      if ( !existDet(layj) ) {
      //    ErrMsg(fatal) << " layer # " << layj << " does not exist!" <<endmsg;
      //      }
      if ( iview != Layer( jndex )->view() ) continue;
      _prevlayinvw[index] = Layer( jndex );
      break;
    } //(int jndex=index+1; _dclayer[jndex].exist(); jndex++)
 
  } //(int index=0; _dclayer[index].exist(); index++)
}
 
void MdcDetector::buildSuperLayers( void ) {
  // some initializations
  _nAxSlay      = 0;
  _nSterSlay[0] = _nSterSlay[1] = 0;
 
  //  _nSlay = _nLayer/_layPerSL;
 
  _firstSlayNum = 1;
  _lastSlayNum  = _nSlay;
  //  _slayList = new MdcSuperLayer*[_nSlay];
 
  // initialize pointers
  _firstSlayInView[0] = _firstSlayInView[1] = _firstSlayInView[2] = 0;
  _lastSlayInView[0] = _lastSlayInView[1] = _lastSlayInView[2] = 0;
 
  int islay;
 
  // build the SuperLayers
  for ( islay = 0; islay < _nSlay; islay++ )
  {
    //    MdcSuperLayer* superlay = new MdcSuperLayer("Dch SuperLayer",1001+islay);
    MdcSuperLayer* superlay = new MdcSuperLayer( islay );
    //    *_dchslayerset += *superlay;
    _slayList[islay] = superlay;
  }
  _firstSlay = _slayList[0];
  _lastSlay  = _slayList[_nSlay - 1];
 
  // set pointers to Layers in SuperLayers
  //  for (int lay=firstLayNum(); lay<=lastLayNum(); lay++) {
  for ( int lay = 0; lay < _nLayer; lay++ )
  {
    int superlayer = lay / _layPerSL;
    int index      = lay % _layPerSL;
    _slayList[superlayer]->addLayer( index, getMdcLayer( lay ) );
  }
  // update SuperLayer data members
  MdcSuperLayer* oldSlayByView[3] = { 0, 0, 0 };
 
  for ( islay = 0; islay < _nSlay; islay++ )
  {
    const MdcSuperLayer* prev = 0;
    const MdcSuperLayer* next = 0;
    //    const MdcSuperLayer* prevInView = 0;
    //    const MdcSuperLayer* nextInView = 0;
 
    // SuperLayer view
    int iview     = _slayList[islay]->layer( 0 )->view();
    int viewIndex = iview + 1;
    // count SuperLayer types
    if ( iview == 0 ) _nAxSlay++;
    else if ( iview == -1 ) _nSterSlay[0]++;
    else if ( iview == 1 ) _nSterSlay[1]++;
 
    // build pointer links
    if ( islay > 0 ) prev = _slayList[islay - 1];
    if ( islay < _nSlay - 1 ) next = _slayList[islay + 1];
 
    // fill first and last SuperLayer pointers
    if ( firstSlayInView( iview ) == 0 ) _firstSlayInView[viewIndex] = _slayList[islay];
    _lastSlayInView[viewIndex] = _slayList[islay];
 
    _slayList[islay]->updateInfo( prev, next );
    // now the poiters to SuperLayers of the same view
    if ( oldSlayByView[viewIndex] != 0 )
    {
      oldSlayByView[viewIndex]->setNextInView( _slayList[islay] );
      _slayList[islay]->setPrevInView( oldSlayByView[viewIndex] );
    }
 
    oldSlayByView[viewIndex] = _slayList[islay];
  }
}
 
const MdcSWire* MdcDetector::Wire( const Identifier& id ) const {
  int wire  = MdcID::wire( id );
  int layer = MdcID::layer( id );
  return Wire( layer, wire );
  //  unsigned wireid= Layer(layer)->Wirst()+wire;
  //  if( wireid < fWires.size()){
  //          return fWires[wireid];
  //  }
  //  else {
  //  return 0;
  //  }
}
 
const MdcLayer* MdcDetector::Layer( const Identifier& id ) const {
  unsigned layerid = MdcID::layer( id );
  return Layer( layerid );
  //  if (layerid < fLayers.size())
  //         return fLayers[layerid];
  //
  //         return 0;
}