Segmentation.h

Go to the documentation of this file.

/*
 * Segmentation.h
 *
 *  Created on: Jun 27, 2013
 *      Author: Christian Grefe, CERN
 */

#ifndef DDSegmentation_SEGMENTATION_H_
#define DDSegmentation_SEGMENTATION_H_

#include "DDSegmentation/BitField64.h"
#include "DDSegmentation/SegmentationFactory.h"
#include "DDSegmentation/SegmentationParameter.h"

#include <map>
#include <utility>
#include <set>
#include <string>
#include <vector>

namespace DD4hep {
namespace DDSegmentation {

typedef SegmentationParameter* Parameter;
typedef std::vector<Parameter> Parameters;
typedef TypedSegmentationParameter<int>* IntParameter;
typedef TypedSegmentationParameter<float>* FloatParameter;
typedef TypedSegmentationParameter<double>* DoubleParameter;
typedef TypedSegmentationParameter<std::string>* StringParameter;
typedef TypedSegmentationParameter<std::vector<int> >* IntVecParameter;
typedef TypedSegmentationParameter<std::vector<float> >* FloatVecParameter;
typedef TypedSegmentationParameter<std::vector<double> >* DoubleVecParameter;
typedef TypedSegmentationParameter<std::vector<std::string> >* StringVecParameter;
typedef SegmentationParameter::UnitType UnitType;

typedef long long int CellID;
typedef long long int VolumeID;

struct Vector3D {
        Vector3D(double x_val = 0., double y_val = 0., double z_val = 0.) :
                        X(x_val), Y(y_val), Z(z_val) {
        }
        template<typename T> Vector3D(const T& v) {
                X = v.x();
                Y = v.y();
                Z = v.Z();
        }
        double x() const {
                return X;
        }
        double y() const {
                return Y;
        }
        double z() const {
                return Z;
        }
        double X, Y, Z;
};

class Segmentation {
public:
        virtual ~Segmentation();

  virtual void addSubsegmentation(long key_min, long key_max, Segmentation* entry);
        virtual Vector3D position(const CellID& cellID) const = 0;
        virtual CellID cellID(const Vector3D& localPosition, const Vector3D& globalPosition,
                        const VolumeID& volumeID) const = 0;
        virtual VolumeID volumeID(const CellID& cellID) const;
        virtual void neighbours(const CellID& cellID, std::set<CellID>& neighbours) const;
        virtual std::string fieldDescription() const {
                return _decoder->fieldDescription();
        }
        virtual const std::string& name() const {
                return _name;
        }
        virtual void setName(const std::string& value) {
                _name = value;
        }
        virtual const std::string& type() const {
                return _type;
        }
        virtual const std::string& description() const {
                return _description;
        }
        virtual BitField64* decoder()  const {
                return _decoder;
        }
        virtual void setDecoder(BitField64* decoder);
        virtual Parameter parameter(const std::string& parameterName) const;
        virtual Parameters parameters() const;
        virtual void setParameters(const Parameters& parameters);
        virtual std::vector<double> cellDimensions(const CellID& cellID) const;

protected:
        Segmentation(const std::string& cellEncoding = "");
        Segmentation(BitField64* decoder);

        template<typename TYPE> void registerParameter(const std::string& nam, const std::string& desc,
                        TYPE& param, const TYPE& defaultVal, UnitType unitTyp = SegmentationParameter::NoUnit,
                        bool isOpt = false) {
                _parameters[nam] = new TypedSegmentationParameter<TYPE>(nam,desc,param,defaultVal,unitTyp,isOpt);
        }
        void registerIdentifier(const std::string& nam, const std::string& desc, std::string& ident,
                        const std::string& defaultVal);

        static double binToPosition(CellID bin, double cellSize, double offset = 0.);
        static int positionToBin(double position, double cellSize, double offset = 0.);

  static double binToPosition(CellID bin, std::vector<double> const& cellBoundaries, double offset = 0.);
        static int positionToBin(double position, std::vector<double> const& cellBoundaries, double offset = 0.);

        std::string _name;
        std::string _type;
        std::string _description;
        std::map<std::string, Parameter> _parameters;
        std::map<std::string, StringParameter> _indexIdentifiers;
        mutable BitField64* _decoder;
        bool _ownsDecoder;
private:
        Segmentation(const Segmentation&);
};

#define REGISTER_SEGMENTATION(classname) \
        static const SegmentationCreator<classname> classname##_creator(#classname);

} /* namespace DDSegmentation */
} /* namespace DD4hep */
#endif /* DDSegmentation_SEGMENTATION_H_ */