TiledLayerSegmentation.h

Go to the documentation of this file.

/*
 * TiledLayerSegmentation.h
 *
 *  Created on: Mar 10, 2014
 *      Author: cgrefe
 */

#ifndef DDSegmentation_TILEDLAYERSEGMENTATION_H_
#define DDSegmentation_TILEDLAYERSEGMENTATION_H_

#include "DDSegmentation/Segmentation.h"

// C/C++ includes
#include <string>
#include <vector>

namespace DD4hep {
namespace DDSegmentation {

class TiledLayerSegmentation: public Segmentation {
public:
        struct LayerDimensions {
                LayerDimensions(double _x = 1., double _y = 1.) :
                        x(_x), y(_y) {}
                double x, y;
        };

        TiledLayerSegmentation(const std::string& cellEncoding = "");
        TiledLayerSegmentation(BitField64* decoder);
        virtual ~TiledLayerSegmentation();

        virtual Vector3D position(const CellID& cellID) const;
        virtual CellID cellID(const Vector3D& localPosition, const Vector3D& globalPosition,
                        const VolumeID& volumeID) const;

        double gridSizeX() const {
                return _gridSizeX;
        }
        double gridSizeY() const {
                return _gridSizeY;
        }

        double layerGridSizeX(int layerIndex) const;
        double layerGridSizeY(int layerIndex) const;

        const std::string& identifierX() const {
                return _identifierX;
        }
        const std::string& identifierY() const {
                return _identifierY;
        }
        const std::string& identifierLayer() const {
                return _identifierLayer;
        }

        LayerDimensions layerDimensions(int layerIndex) const;

        void setGridSizeX(double cellSize) {
                _gridSizeX = cellSize;
        }
        void setGridSizeY(double cellSize) {
                _gridSizeY = cellSize;
        }

        void setIdentifierX(const std::string& fieldName) {
                _identifierX = fieldName;
        }
        void setIdentifierY(const std::string& fieldName) {
                _identifierY = fieldName;
        }
        void setIdentifierLayer(const std::string& fieldName) {
                _identifierLayer = fieldName;
        }

        void setLayerDimensions(int layerIndex, double x, double y);



protected:
        double _gridSizeX; 
        double _gridSizeY; 
        std::string _identifierX; 
        std::string _identifierY; 
        std::string _identifierLayer; 
        std::vector<int> _layerIndices; 
        std::vector<double> _layerDimensionsX; 
        std::vector<double> _layerDimensionsY; 

        static double calculateOptimalCellSize(double nominalCellSize, double totalSize);
        static double calculateOffset(double cellSize, double totalSize);
};

} /* namespace DDSegmentation */
} /* namespace DD4hep */

#endif /* TILEDLAYERSEGMENTATION_H_ */