InstrumentDefinitionParser.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 "MantidGeometry/Instrument.h"
#include "MantidGeometry/Instrument/IDFObject.h"
#include "MantidKernel/V3D.h"
#include <Poco/AutoPtr.h>
#include <Poco/DOM/Document.h>
#include <string>
#include <vector>
 
namespace Poco {
namespace XML {
class Element;
}
} // namespace Poco
 
namespace Mantid {
namespace Kernel {
class ProgressBase;
}
 
namespace Geometry {
class ICompAssembly;
class IComponent;
class Instrument;
class ObjComponent;
class IObject;
class ShapeFactory;
 
class MANTID_GEOMETRY_DLL InstrumentDefinitionParser {
public:
  InstrumentDefinitionParser();
  InstrumentDefinitionParser(const std::string &filename, const std::string &instName, const std::string &xmlText);
  InstrumentDefinitionParser(const IDFObject_const_sptr &xmlFile, const IDFObject_const_sptr &expectedCacheFile,
                             const std::string &instName, const std::string &xmlText);
  ~InstrumentDefinitionParser() = default;
 
  enum CachingOption { NoneApplied, ReadGeomCache, ReadFallBack, WroteGeomCache, WroteCacheTemp };
 
  std::shared_ptr<Instrument> parseXML(Kernel::ProgressBase *progressReporter);
 
  void setComponentLinks(std::shared_ptr<Geometry::Instrument> &instrument, Poco::XML::Element *pRootElem,
                         Kernel::ProgressBase *progress = nullptr, const std::string &requestedDate = std::string());
 
  void setComponentLinks(const std::shared_ptr<const Geometry::Instrument> &instrument, Poco::XML::Element *pRootElem,
                         InstrumentParameterCache &logfileCache, Kernel::ProgressBase *progress = nullptr,
                         const std::string &requestedDate = std::string());
 
  std::string getMangledName();
 
  static Poco::XML::Element *getParentComponent(const Poco::XML::Element *pLocElem);
 
  static std::string getNameOfLocationElement(const Poco::XML::Element *pElem, const Poco::XML::Element *pCompElem);
 
  void saveDOM_Tree(const std::string &outFilename);
 
  CachingOption getAppliedCachingOption() const;
 
  const std::string createVTPFileName();
 
private:
  void initialise(const std::string &filename, const std::string &instName, const std::string &xmlText,
                  const std::string &vtpFilename);
 
  Poco::AutoPtr<Poco::XML::Document> getDocument();
 
  void setLocation(Geometry::IComponent *comp, const Poco::XML::Element *pElem, const double angleConvertConst,
                   const bool deltaOffsets = false);
  void setSideBySideViewLocation(Geometry::IComponent *comp, const Poco::XML::Element *pCompElem);
 
  Kernel::V3D getRelativeTranslation(const Geometry::IComponent *comp, const Poco::XML::Element *pElem,
                                     const double angleConvertConst, const bool deltaOffsets = false);
 
  void setValidityRange(const Poco::XML::Element *pRootElem);
 
  void readDefaults(Poco::XML::Element *defaults);
 
  struct IdList {
    int counted;
    std::vector<int> vec;
    std::string idname;
 
    IdList() : counted(0) {};
 
    bool empty() { return vec.empty(); };
 
    void reset() {
      counted = 0;
      vec.clear();
    };
  };
 
  void populateIdList(Poco::XML::Element *pE, IdList &idList);
 
  std::vector<std::string> buildExcludeList(const Poco::XML::Element *const location);
 
  void appendAssembly(Geometry::ICompAssembly *parent, const Poco::XML::Element *pLocElem,
                      const Poco::XML::Element *pCompElem, IdList &idList);
  bool isAssembly(const std::string &) const;
 
  void appendLeaf(Geometry::ICompAssembly *parent, const Poco::XML::Element *pLocElem,
                  const Poco::XML::Element *pCompElem, IdList &idList);
 
  void createDetectorOrMonitor(Geometry::ICompAssembly *parent, const Poco::XML::Element *pLocElem,
                               const Poco::XML::Element *pCompElem, const std::string &filename, IdList &idList,
                               const std::string &category);
 
  void createGridDetector(Geometry::ICompAssembly *parent, const Poco::XML::Element *pLocElem,
                          const Poco::XML::Element *pCompElem, const std::string &filename,
                          const Poco::XML::Element *pType);
 
  void createRectangularDetector(Geometry::ICompAssembly *parent, const Poco::XML::Element *pLocElem,
                                 const Poco::XML::Element *pCompElem, const std::string &filename,
                                 const Poco::XML::Element *pType);
 
  void createStructuredDetector(Geometry::ICompAssembly *parent, const Poco::XML::Element *pLocElem,
                                const Poco::XML::Element *pCompElem, const std::string &filename,
                                const Poco::XML::Element *pType);
 
  void appendLocations(Geometry::ICompAssembly *parent, const Poco::XML::Element *pLocElems,
                       const Poco::XML::Element *pCompElem, IdList &idList);
 
  void setLogfile(const Geometry::IComponent *comp, const Poco::XML::Element *pElem,
                  InstrumentParameterCache &logfileCache, const std::string &requestedDate = std::string());
 
  Kernel::V3D parseFacingElementToV3D(Poco::XML::Element *pElem);
  void setFacing(Geometry::IComponent *comp, const Poco::XML::Element *pElem);
  void makeXYplaneFaceComponent(Geometry::IComponent *&in, const Geometry::ObjComponent *facing);
  void makeXYplaneFaceComponent(Geometry::IComponent *&in, const Kernel::V3D &facingPoint);
 
  CachingOption setupGeometryCache();
 
  void createNeutronicInstrument();
 
  void adjust(Poco::XML::Element *pElem, const std::map<std::string, bool> &isTypeAssembly,
              std::map<std::string, Poco::XML::Element *> &getTypeElement);
 
  Poco::AutoPtr<Poco::XML::Document> convertLocationsElement(const Poco::XML::Element *pElem);
 
  double attrToDouble(const Poco::XML::Element *pElem, const std::string &name);
 
  void getTypeAndComponentPointers(const Poco::XML::Element *pRootElem, std::vector<Poco::XML::Element *> &typeElems,
                                   std::vector<Poco::XML::Element *> &compElems) const;
 
  void throwIfTypeNameNotUnique(const std::string &filename, const std::string &typeName) const;
 
  void createShapeIfTypeIsNotAnAssembly(Mantid::Geometry::ShapeFactory &shapeCreator, size_t iType,
                                        Poco::XML::Element *pTypeElem, const std::string &typeName);
 
  void adjustTypesContainingCombineComponentsElement(ShapeFactory &shapeCreator, const std::string &filename,
                                                     const std::vector<Poco::XML::Element *> &typeElems,
                                                     size_t numberOfTypes);
 
  void createVectorOfElementsContainingAParameterElement(Poco::XML::Element *pRootElem);
 
  void checkIdListExistsAndDefinesEnoughIDs(const IdList &idList, Poco::XML::Element *pElem,
                                            const std::string &filename) const;
 
  void checkComponentContainsLocationElement(Poco::XML::Element *pElem, const std::string &filename) const;
 
  void parseLocationsForEachTopLevelComponent(Kernel::ProgressBase *progressReporter, const std::string &filename,
                                              const std::vector<Poco::XML::Element *> &compElems);
 
  void collateTypeInformation(const std::string &filename, const std::vector<Poco::XML::Element *> &typeElems,
                              ShapeFactory &shapeCreator);
 
public: // for testing
  Kernel::V3D getAbsolutPositionInCompCoorSys(Geometry::ICompAssembly *comp, Kernel::V3D);
 
private:
  bool applyCache(const IDFObject_const_sptr &cacheToApply);
 
  CachingOption writeAndApplyCache(IDFObject_const_sptr firstChoiceCache, IDFObject_const_sptr fallBackCache);
 
  std::string getShapeCoorSysComp(Geometry::ICompAssembly *parent, const Poco::XML::Element *pLocElem,
                                  std::map<std::string, Poco::XML::Element *> &getTypeElement,
                                  Geometry::ICompAssembly *&endAssembly);
 
  std::string translateRotateXMLcuboid(Geometry::ICompAssembly *comp, const Poco::XML::Element *cuboidEle,
                                       const std::string &cuboidName);
  std::string translateRotateXMLcuboid(Geometry::ICompAssembly *comp, const std::string &cuboidXML,
                                       const std::string &cuboidName);
 
  Poco::XML::Element *getShapeElement(const Poco::XML::Element *pElem, const std::string &name);
 
  Kernel::V3D parsePosition(Poco::XML::Element *pElem);
 
  IDFObject_const_sptr m_xmlFile;
 
  IDFObject_const_sptr m_cacheFile;
 
  std::string m_instName;
 
  bool m_sideBySideViewLocation_exists;
 
  Poco::AutoPtr<Poco::XML::Document> m_pDoc;
 
  std::vector<Poco::XML::Element *> m_hasParameterElement;
  bool m_hasParameterElement_beenSet;
  std::map<std::string, bool> isTypeAssembly;
  std::map<std::string, std::shared_ptr<Geometry::IObject>> mapTypeNameToShape;
  std::vector<Geometry::ObjComponent *> m_facingComponent;
  bool m_haveDefaultFacing;
  Kernel::V3D m_defaultFacing;
  std::map<std::string, Poco::XML::Element *> getTypeElement;
 
  std::shared_ptr<Geometry::Instrument> m_instrument;
 
  bool m_deltaOffsets;
 
  double m_angleConvertConst;
 
  bool m_indirectPositions; 
  std::map<Geometry::IComponent *, Poco::XML::Element *> m_neutronicPos;
 
  bool m_mixedNeutronicPositions;
 
  struct SphVec {
    double r, theta, phi;
    SphVec() : r(0.0), theta(0.0), phi(0.0) {}
    SphVec(const double &r, const double &theta, const double &phi) : r(r), theta(theta), phi(phi) {}
  };
 
  std::map<const Geometry::IComponent *, SphVec> m_tempPosHolder;
 
  CachingOption m_cachingOption;
};
 
} // namespace Geometry
} // namespace Mantid