DDCompareTools.h

Go to the documentation of this file.

#include <functional>
#include <vector>

#include "DetectorDescription/Base/interface/DDRotationMatrix.h"
#include "DetectorDescription/Base/interface/DDTranslation.h"
#include "DetectorDescription/Core/interface/DDCompactView.h"
#include "DetectorDescription/Core/interface/DDExpandedView.h"
#include "DetectorDescription/Core/interface/DDLogicalPart.h"
#include "DetectorDescription/Core/interface/DDSolid.h"
#include "DetectorDescription/Core/interface/DDTransform.h"

class DDCompactView;
class DDExpandedView;


struct DDCompOptions {
  DDCompOptions() : compRotName_(false), attResync_(false),
            contOnError_(false), distTol_(0.0004),
            rotTol_(0.0004), specTol_(0.0004)
  { }

  bool compRotName_;
  bool attResync_;
  bool contOnError_;
  double distTol_;
  double rotTol_;
  double specTol_;
};

struct DDCompareEPV : public std::binary_function<DDExpandedView, DDExpandedView, bool> {
  DDCompareEPV();
  DDCompareEPV(const DDCompOptions& ddco);
  bool operator()(DDExpandedView& lhs, DDExpandedView& rhs) const ;
  DDCompOptions ddco_;
};

struct DDCompareCPV : public std::binary_function<DDCompactView, DDCompactView, bool> {
  DDCompareCPV();
  DDCompareCPV(const DDCompOptions& ddco);
  bool operator()(const DDCompactView& lhs, const DDCompactView& rhs) const ;
  DDCompOptions ddco_;
};


struct DDCompareLP : public std::binary_function<DDLogicalPart, DDLogicalPart, bool> {
  DDCompareLP();
  DDCompareLP(const DDCompOptions& ddco);
  bool operator()(const DDLogicalPart& lhs, const DDLogicalPart& rhs) const ;
  DDCompOptions ddco_;
};

struct DDCompareSolid : public std::binary_function<DDSolid, DDSolid, bool> {
  DDCompareSolid();
  DDCompareSolid(const DDCompOptions& ddco);
  bool operator()(const DDSolid& lhs, const DDSolid& rhs) const ;
  DDCompOptions ddco_;
};

struct DDCompareDBLVEC : public std::binary_function<std::vector<double>, std::vector<double>, bool> {
  DDCompareDBLVEC();
  DDCompareDBLVEC(double tol);
  bool operator()(const std::vector<double>& lhs, const std::vector<double>& rhs) const ;
  double tol_;
};

struct DDCompareBoolSol : public std::binary_function<DDBooleanSolid, DDBooleanSolid, bool> {
  DDCompareBoolSol();
  DDCompareBoolSol(const DDCompOptions& ddco);
  bool operator()(const DDBooleanSolid& lhs, const DDBooleanSolid& rhs) const ;
  DDCompOptions ddco_;
};

struct DDCompareDDTrans : public std::binary_function<DDTranslation, DDTranslation, bool> {
  DDCompareDDTrans();
  DDCompareDDTrans(double tol);
  bool operator()(const DDTranslation& lhs, const DDTranslation& rhs) const;
  double tol_;
};

struct DDCompareDDRot : public std::binary_function<DDRotation, DDRotation, bool> {
  DDCompareDDRot();
  DDCompareDDRot(const DDCompOptions& ddco);
  bool operator()(const DDRotation& lhs, const DDRotation& rhs) const;
  DDCompOptions ddco_;
};

struct DDCompareDDRotMat : public std::binary_function<DDRotationMatrix, DDRotationMatrix, bool> {
  DDCompareDDRotMat();
  DDCompareDDRotMat(double tol);
  bool operator()(const DDRotationMatrix& lhs, const DDRotationMatrix& rhs) const;
  double tol_;
};