MegatileLayerGridXY.h

Go to the documentation of this file.

//==========================================================================
//  AIDA Detector description implementation 
//--------------------------------------------------------------------------
// Copyright (C) Organisation europeenne pour la Recherche nucleaire (CERN)
// All rights reserved.
//
// For the licensing terms see $DD4hepINSTALL/LICENSE.
// For the list of contributors see $DD4hepINSTALL/doc/CREDITS.
//
//==========================================================================
 
/*
 * MegatileLayerGridXY.h
 *
 *  Created on: April 19, 2016
 *      Author: S. Lu, DESY
 */
 
#ifndef DDSEGMENTATION_MEGATILELAYERGRIDXY_H
#define DDSEGMENTATION_MEGATILELAYERGRIDXY_H
 
#include <DDSegmentation/CartesianGrid.h>
 
#include <cassert>
 
 
namespace dd4hep {
  namespace DDSegmentation {
 
 
    class MegatileLayerGridXY: public CartesianGrid {
    public:
      MegatileLayerGridXY(const std::string& cellEncoding = "");
 
      MegatileLayerGridXY(const BitFieldCoder* decoder);
 
      virtual ~MegatileLayerGridXY();
 
      void setup();
 
      virtual Vector3D position(const CellID& cellID) const;
      virtual CellID cellID(const Vector3D& localPosition, const Vector3D& globalPosition, const VolumeID& volumeID) const;
 
      // set size of megatile in X,Y
      void setMegaTileSizeXY(double x, double y) {
        _megaTileSizeX = x;
        _megaTileSizeY = y;
      }
 
      void setMegaTileOffsetXY( double x, double y) {
        _megaTileOffsetX = x;
        _megaTileOffsetY = y;
      }
 
      void setMegaTileCellsXY( unsigned int layer, int ix, int iy ) {
        while ( _nCellsX.size()<=layer ) {
          _nCellsX.emplace_back(0);
          _nCellsY.emplace_back(0);
        }
        _nCellsX[layer] = ix;
        _nCellsY[layer] = iy;
 
      }
 
      void setSpecialMegaTile( unsigned int layer, unsigned int tile, 
                               double sizex, double sizey,
                               double offsetx, double offsety,
                               unsigned int ncellsx, unsigned int ncellsy );
 
      const std::string& fieldNameX() const {
        return _xId;
      }
      const std::string& fieldNameY() const {
        return _yId;
      }
      
      void setFieldNameX(const std::string& fieldName) {
        _xId = fieldName;
      }
      void setFieldNameY(const std::string& fieldName) {
        _yId = fieldName;
      }
 
      virtual std::vector<double> cellDimensions(const CellID& cellID) const;
      virtual std::vector<double> cellDimensions(const unsigned int ilayer, const unsigned int iwafer) const;
 
      int getUnifNCellsX() {return _unif_nCellsX;}
      int getUnifNCellsY() {return _unif_nCellsY;}
 
      struct segInfo {
        double megaTileSizeX = 0;
        double megaTileSizeY = 0;
        double megaTileOffsetX = 0;
        double megaTileOffsetY = 0;
        unsigned int nCellsX = 0;
        unsigned int nCellsY = 0;
        segInfo() = default;
      };
 
    protected:
 
 
      mutable segInfo _currentSegInfo;
 
      void getSegInfo( unsigned int layerIndex, unsigned int waferIndex) const;
 
      // the "usual" megatiles
      //  megatile size and offset is constant in all layers
      //  the segmentation may change layer-to-layer (e.g. orthogonal strips)
 
      // total size of surface in X,Y
      double  _megaTileSizeX = 0; // [MAX_LAYERS][MAX_WAFERS];
      double  _megaTileSizeY = 0; //[MAX_LAYERS][MAX_WAFERS];
 
      double  _megaTileOffsetX = 0;
      double  _megaTileOffsetY = 0;
 
      // number of cells per megatile in X, Y
      std::vector < int > _nCellsX;
      std::vector < int > _nCellsY;
 
      int _unif_nCellsX;
      int _unif_nCellsY;
 
      std::map < std::pair < unsigned int, unsigned int > , segInfo > specialMegaTiles_layerWafer;
 
      
      std::string _xId;
      std::string _yId;
      std::string _identifierLayer;
      std::string _identifierWafer;
 
      std::string _layerConfig;
 
      std::string _identifierModule;
 
    };
 
  }    /* namespace DDSegmentation              */
}      /* namespace dd4hep                      */
#endif // DDSEGMENTATION_MEGATILELAYERGRIDXY_H