Adding template objects

CMakeLists.txt

@@ -292,6 +292,7 @@ if(NOT XDMF_BUILD_CORE_ONLY)
     XdmfGridCollection
     XdmfGridCollectionType
     XdmfGridController
+    XdmfGridTemplate
     XdmfItemFactory
     XdmfMap
     XdmfReader
@@ -299,6 +300,7 @@ if(NOT XDMF_BUILD_CORE_ONLY)
     XdmfRegularGrid
     XdmfSet
     XdmfSetType
+    XdmfTemplate
     XdmfTime
     XdmfTopology
     XdmfTopologyType

XdmfGridTemplate.hpp

+/*****************************************************************************/
+/*                                    XDMF                                   */
+/*                       eXtensible Data Model and Format                    */
+/*                                                                           */
+/*  Id : XdmfTemplate.hpp                                                    */
+/*                                                                           */
+/*  Author:                                                                  */
+/*     Andrew Burns                                                          */
+/*     andrew.j.burns2@us.army.mil                                           */
+/*     US Army Research Laboratory                                           */
+/*     Aberdeen Proving Ground, MD                                           */
+/*                                                                           */
+/*     Copyright @ 2013 US Army Research Laboratory                          */
+/*     All Rights Reserved                                                   */
+/*     See Copyright.txt for details                                         */
+/*                                                                           */
+/*     This software is distributed WITHOUT ANY WARRANTY; without            */
+/*     even the implied warranty of MERCHANTABILITY or FITNESS               */
+/*     FOR A PARTICULAR PURPOSE.  See the above copyright notice             */
+/*     for more information.                                                 */
+/*                                                                           */
+/*****************************************************************************/
+
+#ifndef XDMFGRIDTEMPLATE_HPP_
+#define XDMFGRIDTEMPLATE_HPP_
+
+// C Compatible Includes
+#include "Xdmf.hpp"
+#include "XdmfItem.hpp"
+#include "XdmfGridCollection.hpp"
+#include "XdmfItemFactory.hpp"
+#include "XdmfTemplate.hpp"
+#include "XdmfArray.hpp"
+#include "XdmfHeavyDataWriter.hpp"
+
+#ifdef __cplusplus
+
+// Includes
+
+/**
+ * @brief Defines a template that can be filled with multiple sets of data.
+ *
+ * An XdmfTemplate defines a structure. The arrays within that structure
+ * are stored if they are not initialized when the structure is first set.
+ * Steps can then be added and references to heavy data are produced and
+ * stored for later retrieval.
+ *
+ * This effectively lets an object have several variations with different
+ * contained data.
+ */
+class XDMF_EXPORT XdmfGridTemplate : public XdmfTemplate,
+                                     public XdmfGridCollection {
+
+public:
+
+  /**
+   * Creates a new instance of the XdmfTemplate object
+   *
+   * @return    A constructed XdmfTemplate object.
+   */
+  static shared_ptr<XdmfGridTemplate> New();
+
+  virtual ~XdmfGridTemplate();
+
+  LOKI_DEFINE_VISITABLE(XdmfGridTemplate, XdmfGrid);
+  static const std::string ItemTag;
+
+  /**
+   * Writes all tracked arrays to heavy data via the provided
+   * heavy data writer then stores the heavy data descriptions.
+   *
+   * @return    The ID of the step that was added
+   */
+  virtual unsigned int addStep();
+
+  std::map<std::string, std::string> getItemProperties() const;
+
+  std::string getItemTag() const;
+
+  using XdmfGrid::insert;
+
+  // Overriding the parent versions so that all of these reference the Base item
+  // instead of the template
+
+  virtual shared_ptr<XdmfArray> getTimes();
+
+  virtual shared_ptr<XdmfGridCollection> getGridCollection(const unsigned int index);
+
+  virtual shared_ptr<const XdmfGridCollection> getGridCollection(const unsigned int index) const;
+
+  virtual shared_ptr<XdmfGridCollection> getGridCollection(const std::string & Name);
+
+  virtual shared_ptr<const XdmfGridCollection> getGridCollection(const std::string & Name) const;
+
+  virtual unsigned int getNumberGridCollections() const;
+
+  virtual void insert(const shared_ptr<XdmfGridCollection> GridCollection);
+
+  virtual void removeGridCollection(const unsigned int index);
+
+  virtual void removeGridCollection(const std::string & Name);
+
+  virtual shared_ptr<XdmfCurvilinearGrid> getCurvilinearGrid(const unsigned int index);
+
+  virtual shared_ptr<const XdmfCurvilinearGrid> getCurvilinearGrid(const unsigned int index) const;
+
+  virtual shared_ptr<XdmfCurvilinearGrid> getCurvilinearGrid(const std::string & Name);
+
+  virtual shared_ptr<const XdmfCurvilinearGrid> getCurvilinearGrid(const std::string & Name) const;
+
+  virtual unsigned int getNumberCurvilinearGrids() const;
+
+  virtual void insert(const shared_ptr<XdmfCurvilinearGrid> CurvilinearGrid);
+
+  virtual void removeCurvilinearGrid(const unsigned int index);
+
+  virtual void removeCurvilinearGrid(const std::string & Name);
+
+  virtual shared_ptr<XdmfRectilinearGrid> getRectilinearGrid(const unsigned int index);
+
+  virtual shared_ptr<const XdmfRectilinearGrid> getRectilinearGrid(const unsigned int index) const;
+
+  virtual shared_ptr<XdmfRectilinearGrid> getRectilinearGrid(const std::string & Name);
+
+  virtual shared_ptr<const XdmfRectilinearGrid> getRectilinearGrid(const std::string & Name) const;
+
+  virtual unsigned int getNumberRectilinearGrids() const;
+
+  virtual void insert(const shared_ptr<XdmfRectilinearGrid> RectilinearGrid);
+
+  virtual void removeRectilinearGrid(const unsigned int index);
+
+  virtual void removeRectilinearGrid(const std::string & Name);
+
+  virtual shared_ptr<XdmfRegularGrid> getRegularGrid(const unsigned int index);
+
+  virtual shared_ptr<const XdmfRegularGrid> getRegularGrid(const unsigned int index) const;
+
+  virtual shared_ptr<XdmfRegularGrid> getRegularGrid(const std::string & Name);
+
+  virtual shared_ptr<const XdmfRegularGrid> getRegularGrid(const std::string & Name) const;
+
+  virtual unsigned int getNumberRegularGrids() const;
+
+  virtual void insert(const shared_ptr<XdmfRegularGrid> RegularGrid);
+
+  virtual void removeRegularGrid(const unsigned int index);
+
+  virtual void removeRegularGrid(const std::string & Name);
+
+  virtual shared_ptr<XdmfUnstructuredGrid> getUnstructuredGrid(const unsigned int index);
+
+  virtual shared_ptr<const XdmfUnstructuredGrid> getUnstructuredGrid(const unsigned int index) const;
+
+  virtual shared_ptr<XdmfUnstructuredGrid> getUnstructuredGrid(const std::string & Name);
+
+  virtual shared_ptr<const XdmfUnstructuredGrid> getUnstructuredGrid(const std::string & Name) const;
+
+  virtual unsigned int getNumberUnstructuredGrids() const;
+
+  virtual void insert(const shared_ptr<XdmfUnstructuredGrid> UnstructuredGrid);
+
+  virtual void removeUnstructuredGrid(const unsigned int index);
+
+  virtual void removeUnstructuredGrid(const std::string & Name);
+
+  /**
+   *
+   */
+  virtual void removeStep(unsigned int stepId);
+
+  virtual void setBase(shared_ptr<XdmfItem> newBase);
+
+  /**
+   * Reads in the heavy data associated with the provided step id.
+   *
+   * @param     stepId  The id of the step whose heavy data
+   *                    is to be read in from file
+   */
+  void setStep(unsigned int stepId);
+
+  void setStep(shared_ptr<XdmfTime> time);
+
+  void traverse(const shared_ptr<XdmfBaseVisitor> visitor);
+
+  XdmfGridTemplate(XdmfGridTemplate &);
+
+protected:
+
+  XdmfGridTemplate();
+
+  virtual void
+  populateItem(const std::map<std::string, std::string> & itemProperties,
+               const std::vector<shared_ptr<XdmfItem> > & childItems,
+               const XdmfCoreReader * const reader);
+
+  shared_ptr<XdmfArray> mTimeCollection;
+
+private:
+
+  XdmfGridTemplate(const XdmfGridTemplate &);  // Not implemented.
+  void operator=(const XdmfGridTemplate &);  // Not implemented.
+
+};
+
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// C wrappers go here
+
+struct XDMFGRIDTEMPLATE; // Simply as a typedef to ensure correct typing
+typedef struct XDMFGRIDTEMPLATE XDMFGRIDTEMPLATE;
+
+XDMF_ITEM_C_CHILD_DECLARE(XdmfGridTemplate, XDMFGRIDTEMPLATE, XDMF)
+
+#ifdef __cplusplus
+}
+#endif
+
+
+#endif /* XDMFGRIDTEMPLATE_HPP_ */

XdmfItemFactory.cpp

@@ -32,6 +32,7 @@
 #include "XdmfGeometryType.hpp"
 #include "XdmfGraph.hpp"
 #include "XdmfGridCollection.hpp"
+#include "XdmfGridTemplate.hpp"
 #include "XdmfInformation.hpp"
 #include "XdmfItemFactory.hpp"
 #include "XdmfAggregate.hpp"
@@ -40,6 +41,7 @@
 #include "XdmfRegularGrid.hpp"
 #include "XdmfSet.hpp"
 #include "XdmfSparseMatrix.hpp"
+#include "XdmfTemplate.hpp"
 #include "XdmfTime.hpp"
 #include "XdmfTopology.hpp"
 #include "XdmfUnstructuredGrid.hpp"
@@ -230,6 +232,22 @@ XdmfItemFactory::createItem(const std::string & itemTag,
   else if(itemTag.compare(XdmfSparseMatrix::ItemTag) == 0) {
     return XdmfSparseMatrix::New(0, 0);
   }
+  else if (itemTag.compare(XdmfTemplate::ItemTag) == 0) {
+    std::map<std::string, std::string>::const_iterator type =
+      itemProperties.find("BaseType");
+    if(type == itemProperties.end()) {
+      return XdmfTemplate::New();
+    }
+    else {
+      if (type->second.compare("Grid") == 0) {
+        return XdmfGridTemplate::New();
+      }
+      else {
+        return XdmfTemplate::New();
+      }
+    }
+    return XdmfTemplate::New();
+  }
   else if(itemTag.compare(XdmfTime::ItemTag) == 0) {
     return XdmfTime::New();
   }

XdmfTemplate.hpp

+/*****************************************************************************/
+/*                                    XDMF                                   */
+/*                       eXtensible Data Model and Format                    */
+/*                                                                           */
+/*  Id : XdmfTemplate.hpp                                                    */
+/*                                                                           */
+/*  Author:                                                                  */
+/*     Andrew Burns                                                          */
+/*     andrew.j.burns2@us.army.mil                                           */
+/*     US Army Research Laboratory                                           */
+/*     Aberdeen Proving Ground, MD                                           */
+/*                                                                           */
+/*     Copyright @ 2013 US Army Research Laboratory                          */
+/*     All Rights Reserved                                                   */
+/*     See Copyright.txt for details                                         */
+/*                                                                           */
+/*     This software is distributed WITHOUT ANY WARRANTY; without            */
+/*     even the implied warranty of MERCHANTABILITY or FITNESS               */
+/*     FOR A PARTICULAR PURPOSE.  See the above copyright notice             */
+/*     for more information.                                                 */
+/*                                                                           */
+/*****************************************************************************/
+
+#ifndef XDMFTEMPLATE_HPP_
+#define XDMFTEMPLATE_HPP_
+
+// C Compatible Includes
+#include "Xdmf.hpp"
+#include "XdmfItem.hpp"
+#include "XdmfItemFactory.hpp"
+#include "XdmfArray.hpp"
+#include "XdmfHeavyDataWriter.hpp"
+
+#ifdef __cplusplus
+
+// Includes
+
+/**
+ * @brief Defines a template that can be filled with multiple sets of data.
+ *
+ * An XdmfTemplate defines a structure. The arrays within that structure
+ * are stored if they are not initialized when the structure is first set.
+ * Steps can then be added and references to heavy data are produced and
+ * stored for later retrieval.
+ *
+ * This effectively lets an object have several variations with different
+ * contained data.
+ */
+class XDMF_EXPORT XdmfTemplate : public virtual XdmfItem {
+
+public:
+
+  /**
+   * Creates a new instance of the XdmfTemplate object
+   *
+   * @return    A constructed XdmfTemplate object.
+   */
+  static shared_ptr<XdmfTemplate> New();
+
+  virtual ~XdmfTemplate();
+
+  LOKI_DEFINE_VISITABLE(XdmfTemplate, XdmfItem);
+  static const std::string ItemTag;
+
+  /**
+   * Writes all tracked arrays to heavy data via the provided
+   * heavy data writer then stores the heavy data descriptions.
+   *
+   * @return    The ID of the step that was added
+   */
+  virtual unsigned int addStep();
+
+  /**
+   * Clears the current data from the tracked arrays.
+   */
+  virtual void clearStep();
+
+  /**
+   * Gets the XdmfItem that serves as the structure for the template.
+   *
+   * @return    The XdmfItem that serves as the structure for the template.
+   */
+  virtual shared_ptr<XdmfItem> getBase();
+
+  /**
+   * Gets the heavy data writer that is used to write step data to heavy data.
+   *
+   * @return    The heavy data writer
+   */
+  shared_ptr<XdmfHeavyDataWriter> getHeavyDataWriter();
+
+  std::map<std::string, std::string> getItemProperties() const;
+
+  std::string getItemTag() const;
+
+  /**
+   * Gets the number of steps currently contained within the template.
+   *
+   * @return    The number of steps contained within the template.
+   */
+  unsigned int getNumberSteps() const;
+
+  /**
+   * Gets the number of arrays tracked across timesteps.
+   *
+   * @return    The numer of tracked arrays.
+   */
+  unsigned int getNumberTrackedArrays() const;
+
+  /**
+   * Gets the tracked array at the specified index. The index of the array
+   * depends on when the internal visitor encountered the array in question.
+   *
+   * @return    The requested array.
+   */
+  XdmfArray * getTrackedArray(unsigned int index);
+
+  using XdmfItem::insert;
+
+  /*
+   *
+   */
+  virtual void preallocateSteps(unsigned int numSteps);
+
+  /**
+   * 
+   */
+  virtual void removeStep(unsigned int stepId);
+
+  /**
+   * Sets the item to define the structure for each step of the template.
+   *
+   * When the base is set all uninitialized arrays are added to
+   * the list of tracked arrays.
+   *
+   * @param     newBase The item to serve as the structure.
+   */
+  virtual void setBase(shared_ptr<XdmfItem> newBase);
+
+  /**
+   * Sets the heavy data writer with which the template will write
+   * to heavy data when adding a step.
+   *
+   * @param     writer  The writer to be used to write to heavy data.
+   */
+  void setHeavyDataWriter(shared_ptr<XdmfHeavyDataWriter> writer);
+
+  /**
+   * Reads in the heavy data associated with the provided step id.
+   *
+   * @param     stepId  The id of the step whose heavy data
+   *                    is to be read in from file
+   */
+  virtual void setStep(unsigned int stepId);
+
+  /**
+   * Adds an array to the list of tracked arrays if that array
+   * is not already there.
+   *
+   * The setBase method automatically sets uninitialized arrays
+   * to be tracked, this can be used to add any missed by setBase.
+   *
+   * @param     newArray        The array to be tracked.
+   */
+  virtual void trackArray(shared_ptr<XdmfArray> newArray);
+
+  virtual void traverse(const shared_ptr<XdmfBaseVisitor> visitor);
+
+  XdmfTemplate(XdmfTemplate &);
+
+protected:
+
+  XdmfTemplate();
+
+  virtual void
+  populateItem(const std::map<std::string, std::string> & itemProperties,
+               const std::vector<shared_ptr<XdmfItem> > & childItems,
+               const XdmfCoreReader * const reader);
+
+  shared_ptr<XdmfHeavyDataWriter> mHeavyWriter;
+
+  shared_ptr<XdmfItem> mBase;
+  std::vector<XdmfArray *> mTrackedArrays;
+  std::vector<std::string> mDataTypes;
+  std::vector<std::string> mDataDescriptions;
+  std::vector<std::vector<shared_ptr<XdmfHeavyDataController> > > mDataControllers;
+  std::vector<shared_ptr<const XdmfArrayType> > mTrackedArrayTypes;
+  std::vector<std::vector<unsigned int> > mTrackedArrayDims;
+  int mCurrentStep;
+  unsigned int mNumSteps;
+  shared_ptr<XdmfItemFactory> mItemFactory;
+
+private:
+
+  XdmfTemplate(const XdmfTemplate &);  // Not implemented.
+  void operator=(const XdmfTemplate &);  // Not implemented.
+
+};
+
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// C wrappers go here
+
+struct XDMFTEMPLATE; // Simply as a typedef to ensure correct typing
+typedef struct XDMFTEMPLATE XDMFTEMPLATE;
+
+XDMF_ITEM_C_CHILD_DECLARE(XdmfTemplate, XDMFTEMPLATE, XDMF)
+
+#ifdef __cplusplus
+}
+#endif
+
+
+#endif /* XDMFTEMPLATE_HPP_ */