/home/bes3soft/bes3soft/Boss/7.0.2/dist/7.0.2/Reconstruction/MdcPatRec/MdcGeom/MdcGeom-00-01-17/src/MdcDetector.cxx

Go to the documentation of this file.

#include "MdcGeom/MdcDetector.h"
#include "Identifier/MdcID.h"
#include "MdcGeomSvc/MdcGeomSvc.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);
  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;
      }

---