Rules.h

Go to the documentation of this file.

// Mantid Repository : https://github.com/mantidproject/mantid
//
// Copyright © 2007 ISIS Rutherford Appleton Laboratory UKRI,
//   NScD Oak Ridge National Laboratory, European Spallation Source,
//   Institut Laue - Langevin & CSNS, Institute of High Energy Physics, CAS
// SPDX - License - Identifier: GPL - 3.0 +
#pragma once
 
#include <map>
#include <memory>
 
class TopoDS_Shape;
 
namespace Mantid {
namespace Kernel {
class V3D;
}
namespace Geometry {
 
class CSGObject;
class Surface;
 
class MANTID_GEOMETRY_DLL Rule {
private:
  Rule *Parent;                      
  virtual Rule *doClone() const = 0; 
 
  static int addToKey(std::vector<int> &AV, const int passN = -1);
 
  int getBaseKeys(std::vector<int> &) const; 
protected:
  Rule(const Rule &);
  Rule &operator=(const Rule &);
 
public:
  static int makeCNFcopy(std::unique_ptr<Rule> &);         
  static int makeFullDNF(std::unique_ptr<Rule> &);         
  static int makeCNF(std::unique_ptr<Rule> &);             
  static int removeComplementary(std::unique_ptr<Rule> &); 
  static int removeItem(std::unique_ptr<Rule> &TRule, const int SurfN);
 
  Rule();
  Rule(Rule *);
  std::unique_ptr<Rule> clone() const { return std::unique_ptr<Rule>(doClone()); }
  virtual ~Rule() = default;
  virtual std::string className() const { return "Rule"; } 
 
  virtual Rule *leaf(const int = 0) const { return nullptr; }
  void setParent(Rule *);
  Rule *getParent() const;
  void makeParents();
  int checkParents() const; 
  int getKeyList(std::vector<int> &) const;
  int commonType() const; 
 
  virtual void setLeaves(std::unique_ptr<Rule>,
                         std::unique_ptr<Rule>) = 0; 
  virtual void setLeaf(std::unique_ptr<Rule>,
                       const int = 0) = 0;      
  virtual int findLeaf(const Rule *) const = 0; 
  virtual Rule *findKey(const int) = 0;         
  virtual int type() const { return 0; }        
 
  virtual bool isValid(const Kernel::V3D &) const = 0;
  virtual bool isValid(const std::map<int, int> &) const = 0;
  virtual int simplify() = 0;
 
  virtual int isComplementary() const { return 0; } 
 
  int Eliminate(); 
  int substituteSurf(const int SurfN, const int newSurfN, const std::shared_ptr<Surface> &SPtr);
 
  virtual std::string display() const = 0;
  virtual std::string displayAddress() const = 0;
  virtual void getBoundingBox(double &xmax, double &ymax, double &zmax, double &xmin, double &ymin, double &zmin) = 0;
#ifdef ENABLE_OPENCASCADE
  virtual TopoDS_Shape analyze() = 0;
#endif
};
 
class MANTID_GEOMETRY_DLL Intersection : public Rule {
 
private:
  std::unique_ptr<Rule> A;                
  std::unique_ptr<Rule> B;                
  Intersection *doClone() const override; 
protected:
  Intersection(const Intersection &);
  Intersection &operator=(const Intersection &);
 
public:
  Intersection() = default;
  explicit Intersection(std::unique_ptr<Rule>, std::unique_ptr<Rule>);
  explicit Intersection(Rule *, std::unique_ptr<Rule>, std::unique_ptr<Rule>);
  std::unique_ptr<Intersection> clone() const;                      
  std::string className() const override { return "Intersection"; } 
 
  Rule *leaf(const int ipt = 0) const override { return ipt ? B.get() : A.get(); } 
  void setLeaves(std::unique_ptr<Rule>,
                 std::unique_ptr<Rule>) override; 
  void setLeaf(std::unique_ptr<Rule> nR,
               const int side = 0) override; 
  int findLeaf(const Rule *) const override;
  Rule *findKey(const int KeyN) override;
  int isComplementary() const override;
 
  int type() const override { return 1; } // effective name
  std::string display() const override;
  std::string displayAddress() const override;
 
  bool isValid(const Kernel::V3D &) const override;
  bool isValid(const std::map<int, int> &) const override;
  int simplify() override; 
  void getBoundingBox(double &xmax, double &ymax, double &zmax, double &xmin, double &ymin,
                      double &zmin) override; 
#ifdef ENABLE_OPENCASCADE
  TopoDS_Shape analyze() override;
#endif
};
 
class MANTID_GEOMETRY_DLL Union : public Rule {
 
private:
  std::unique_ptr<Rule> A; 
  std::unique_ptr<Rule> B; 
  Union *doClone() const override;
 
protected:
  Union(const Union &);
  Union &operator=(const Union &);
 
public:
  Union() = default;
  explicit Union(std::unique_ptr<Rule>, std::unique_ptr<Rule>);
  explicit Union(Rule *, std::unique_ptr<Rule>, std::unique_ptr<Rule>);
 
  std::unique_ptr<Union> clone() const;
  std::string className() const override { return "Union"; } 
 
  Rule *leaf(const int ipt = 0) const override { return ipt ? B.get() : A.get(); } 
  void setLeaves(std::unique_ptr<Rule>,
                 std::unique_ptr<Rule>) override; 
  void setLeaf(std::unique_ptr<Rule>, const int side = 0) override;
  int findLeaf(const Rule *) const override;
  Rule *findKey(const int KeyN) override;
 
  int isComplementary() const override;
  int type() const override { return -1; } 
 
  bool isValid(const Kernel::V3D &) const override;
  bool isValid(const std::map<int, int> &) const override;
  std::string display() const override;
  std::string displayAddress() const override;
  int simplify() override; 
  void getBoundingBox(double &xmax, double &ymax, double &zmax, double &xmin, double &ymin,
                      double &zmin) override; 
#ifdef ENABLE_OPENCASCADE
  TopoDS_Shape analyze() override;
#endif
};
 
class MANTID_GEOMETRY_DLL SurfPoint : public Rule {
private:
  std::shared_ptr<Surface> m_key; 
  SurfPoint *doClone() const override;
  int keyN; 
  int sign; 
public:
  SurfPoint();
  std::string className() const override { return "SurfPoint"; } 
  std::unique_ptr<SurfPoint> clone() const;
 
  Rule *leaf(const int = 0) const override { return nullptr; } 
  void setLeaves(std::unique_ptr<Rule>, std::unique_ptr<Rule>) override;
  void setLeaf(std::unique_ptr<Rule>, const int = 0) override;
  int findLeaf(const Rule *) const override;
  Rule *findKey(const int KeyNum) override;
 
  int type() const override { return 0; } 
 
  void setKeyN(const int Ky); 
  void setKey(const std::shared_ptr<Surface> &Spoint);
  bool isValid(const Kernel::V3D &) const override;
  bool isValid(const std::map<int, int> &) const override;
  int getSign() const { return sign; } 
  int getKeyN() const { return keyN; } 
  int simplify() override;
 
  Surface *getKey() const { return m_key.get(); } 
  std::string display() const override;
  std::string displayAddress() const override;
  void getBoundingBox(double &xmax, double &ymax, double &zmax, double &xmin, double &ymin,
                      double &zmin) override; 
#ifdef ENABLE_OPENCASCADE
  TopoDS_Shape analyze() override;
#endif
};
 
class MANTID_GEOMETRY_DLL CompObj : public Rule {
private:
  int objN;       
  CSGObject *key; 
  CompObj *doClone() const override;
 
protected:
  CompObj(const CompObj &) = default;
  CompObj &operator=(const CompObj &) = default;
 
public:
  CompObj();
  std::unique_ptr<CompObj> clone() const;
  std::string className() const override { return "CompObj"; } 
 
  void setLeaves(std::unique_ptr<Rule>, std::unique_ptr<Rule>) override;
  void setLeaf(std::unique_ptr<Rule>, const int = 0) override;
  int findLeaf(const Rule *) const override;
  Rule *findKey(const int i) override;
 
  int type() const override { return 0; }            
  int isComplementary() const override { return 1; } 
 
  void setObjN(const int Ky); 
  void setObj(CSGObject *);   
  bool isValid(const Kernel::V3D &) const override;
  bool isValid(const std::map<int, int> &) const override;
  int getObjN() const { return objN; }
  int simplify() override;
 
  CSGObject *getObj() const { return key; } 
  std::string display() const override;
  std::string displayAddress() const override;
  void getBoundingBox(double &xmax, double &ymax, double &zmax, double &xmin, double &ymin,
                      double &zmin) override; 
#ifdef ENABLE_OPENCASCADE
  TopoDS_Shape analyze() override;
#endif
};
 
class MANTID_GEOMETRY_DLL CompGrp : public Rule {
private:
  std::unique_ptr<Rule> A; 
  CompGrp *doClone() const override;
 
protected:
  CompGrp(const CompGrp &);
  CompGrp &operator=(const CompGrp &);
 
public:
  CompGrp() = default;
  explicit CompGrp(Rule *, std::unique_ptr<Rule>);
  std::unique_ptr<CompGrp> clone() const;
  std::string className() const override { return "CompGrp"; } 
 
  Rule *leaf(const int) const override { return A.get(); } 
  void setLeaves(std::unique_ptr<Rule>, std::unique_ptr<Rule>) override;
  void setLeaf(std::unique_ptr<Rule> nR, const int side = 0) override;
  int findLeaf(const Rule *) const override;
  Rule *findKey(const int i) override;
 
  int type() const override { return 0; }            
  int isComplementary() const override { return 1; } 
 
  bool isValid(const Kernel::V3D &) const override;
  bool isValid(const std::map<int, int> &) const override;
  int simplify() override;
 
  std::string display() const override;
  std::string displayAddress() const override;
  void getBoundingBox(double &xmax, double &ymax, double &zmax, double &xmin, double &ymin,
                      double &zmin) override; 
#ifdef ENABLE_OPENCASCADE
  TopoDS_Shape analyze() override;
#endif
};
 
class MANTID_GEOMETRY_DLL BoolValue : public Rule {
private:
  int status; 
  BoolValue *doClone() const override;
 
protected:
  BoolValue(const BoolValue &) = default;
  BoolValue &operator=(const BoolValue &);
 
public:
  BoolValue();
  std::unique_ptr<BoolValue> clone() const;
  std::string className() const override { return "BoolValue"; } 
 
  Rule *leaf(const int = 0) const override { return nullptr; } 
  void setLeaves(std::unique_ptr<Rule>, std::unique_ptr<Rule>) override;
  void setLeaf(std::unique_ptr<Rule>, const int = 0) override;
  int findLeaf(const Rule *) const override;
  Rule *findKey(const int) override { return nullptr; }
 
  int type() const override { return 0; } // effective name
 
  void setStatus(int val) {
    if (val == 0 || val == 1 || val == -1)
      status = val;
  }
  bool isValid(const Kernel::V3D &) const override;
  bool isValid(const std::map<int, int> &) const override; 
  int simplify() override;
 
  std::string display() const override;
  std::string displayAddress() const override;
  void getBoundingBox(double &xmax, double &ymax, double &zmax, double &xmin, double &ymin,
                      double &zmin) override; 
#ifdef ENABLE_OPENCASCADE
  TopoDS_Shape analyze() override;
#endif
};
 
} // NAMESPACE  Geometry
 
} // NAMESPACE  Mantid