vtkXdmfReaderInternal.h

Go to the documentation of this file.

/*=========================================================================
 
  Program:   Visualization Toolkit
  Module:    vtkXdmfReaderInternal.h
 
  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
  All rights reserved.
  See Copyright.txt or http://www.kitware.com/Copyright.htm 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 vtkXdmfReaderInternal_h
#define vtkXdmfReaderInternal_h
#ifndef __VTK_WRAP__
#ifndef VTK_WRAPPING_CXX
 
// NAMING CONVENTION *********************************************************
// * all member variables of the type XdmfXml* begin with XML eg. XMLNode
// * all non-member variables of the type XdmfXml* begin with xml eg. xmlNode
// * all member variables of the type XdmfElement (and subclasses) begin with
//   XMF eg. XMFGrid
// * all non-member variables of the type XdmfElement (and subclasses) begin
//   with xmf eg. xmfGrid
// ***************************************************************************
 
#include "vtkMutableDirectedGraph.h"
#include "vtkSILBuilder.h"
 
#include "vtk_xdmf2.h"
#include VTKXDMF2_HEADER(XdmfArray.h)
#include VTKXDMF2_HEADER(XdmfAttribute.h)
#include VTKXDMF2_HEADER(XdmfDOM.h)
//?
#include VTKXDMF2_HEADER(XdmfDataDesc.h)
//?
#include VTKXDMF2_HEADER(XdmfDataItem.h)
#include VTKXDMF2_HEADER(XdmfGrid.h)
//?
#include VTKXDMF2_HEADER(XdmfTopology.h)
//?
#include VTKXDMF2_HEADER(XdmfGeometry.h)
//?
#include VTKXDMF2_HEADER(XdmfTime.h)
//?
#include VTKXDMF2_HEADER(XdmfSet.h)
 
#include <algorithm>
#include <cassert>
#include <functional>
#include <map>
#include <set>
#include <sstream>
#include <string>
#include <vector>
#include <vtksys/SystemTools.hxx>
 
class vtkXdmfDomain;
class VTKIOXDMF2_EXPORT vtkXdmfDocument
{
public:
  //---------------------------------------------------------------------------
 
  bool Parse(const char* xmffilename);
  bool ParseString(const char* xmfdata, size_t length);
 
  //---------------------------------------------------------------------------
  const std::vector<std::string>& GetDomains() { return this->Domains; }
 
  //---------------------------------------------------------------------------
 
  bool SetActiveDomain(const char* domainname);
  bool SetActiveDomain(int index);
 
  //---------------------------------------------------------------------------
  vtkXdmfDomain* GetActiveDomain() { return this->ActiveDomain; }
 
  //---------------------------------------------------------------------------
 
  vtkXdmfDocument();
  ~vtkXdmfDocument();
 
private:
  // Populates the list of domains.
  void UpdateDomains();
 
private:
  int ActiveDomainIndex;
  xdmf2::XdmfDOM XMLDOM;
  vtkXdmfDomain* ActiveDomain;
  std::vector<std::string> Domains;
 
  char* LastReadContents;
  size_t LastReadContentsLength;
  std::string LastReadFilename;
};
 
// I don't use vtkDataArraySelection since it's very slow when it comes to large
// number of arrays.
class vtkXdmfArraySelection : public std::map<std::string, bool>
{
public:
  void Merge(const vtkXdmfArraySelection& other)
  {
    vtkXdmfArraySelection::const_iterator iter = other.begin();
    for (; iter != other.end(); ++iter)
    {
      (*this)[iter->first] = iter->second;
    }
  }
 
  void AddArray(const char* name, bool status = true) { (*this)[name] = status; }
 
  bool ArrayIsEnabled(const char* name)
  {
    vtkXdmfArraySelection::iterator iter = this->find(name);
    if (iter != this->end())
    {
      return iter->second;
    }
 
    // don't know anything about this array, enable it by default.
    return true;
  }
 
  bool HasArray(const char* name)
  {
    vtkXdmfArraySelection::iterator iter = this->find(name);
    return (iter != this->end());
  }
 
  int GetArraySetting(const char* name) { return this->ArrayIsEnabled(name) ? 1 : 0; }
 
  void SetArrayStatus(const char* name, bool status) { this->AddArray(name, status); }
 
  const char* GetArrayName(int index)
  {
    int cc = 0;
    for (vtkXdmfArraySelection::iterator iter = this->begin(); iter != this->end(); ++iter)
    {
 
      if (cc == index)
      {
        return iter->first.c_str();
      }
      cc++;
    }
    return nullptr;
  }
 
  int GetNumberOfArrays() { return static_cast<int>(this->size()); }
};
 
//***************************************************************************
class VTKIOXDMF2_EXPORT vtkXdmfDomain
{
private:
  XdmfInt64 NumberOfGrids;
  xdmf2::XdmfGrid* XMFGrids;
 
  XdmfXmlNode XMLDomain;
  xdmf2::XdmfDOM* XMLDOM;
 
  unsigned int GridsOverflowCounter;
  // these are node indices used when building the SIL.
  vtkIdType SILBlocksRoot;
  std::map<std::string, vtkIdType> GridCenteredAttrbuteRoots;
  std::map<vtkIdType, std::map<XdmfInt64, vtkIdType>> GridCenteredAttrbuteValues;
 
  vtkSILBuilder* SILBuilder;
  vtkMutableDirectedGraph* SIL;
  vtkXdmfArraySelection* PointArrays;
  vtkXdmfArraySelection* CellArrays;
  vtkXdmfArraySelection* Grids;
  vtkXdmfArraySelection* Sets;
  std::map<XdmfFloat64, int> TimeSteps; //< Only discrete timesteps are currently
                                        //  supported.
  std::map<int, XdmfFloat64> TimeStepsRev;
 
public:
  //---------------------------------------------------------------------------
  // does not take ownership of the DOM, however the xmlDom must exist as long
  // as the instance is in use.
  vtkXdmfDomain(xdmf2::XdmfDOM* xmlDom, int domain_index);
 
  //---------------------------------------------------------------------------
  bool IsValid() { return (this->XMLDomain != 0); }
 
  //---------------------------------------------------------------------------
  vtkGraph* GetSIL() { return this->SIL; }
 
  //---------------------------------------------------------------------------
  XdmfInt64 GetNumberOfGrids() { return this->NumberOfGrids; }
 
  //---------------------------------------------------------------------------
  xdmf2::XdmfGrid* GetGrid(XdmfInt64 cc);
 
  //---------------------------------------------------------------------------
  int GetVTKDataType();
 
  //---------------------------------------------------------------------------
  const std::map<XdmfFloat64, int>& GetTimeSteps() { return this->TimeSteps; }
  const std::map<int, XdmfFloat64>& GetTimeStepsRev() { return this->TimeStepsRev; }
 
  //---------------------------------------------------------------------------
  int GetIndexForTime(double time);
 
  //---------------------------------------------------------------------------
 
  XdmfFloat64 GetTimeForIndex(int index)
  {
    std::map<int, XdmfFloat64>::iterator iter = this->TimeStepsRev.find(index);
    return (iter != this->TimeStepsRev.end()) ? iter->second : 0.0;
  }
 
  //---------------------------------------------------------------------------
  xdmf2::XdmfGrid* GetGrid(xdmf2::XdmfGrid* xmfGrid, double time);
 
  //---------------------------------------------------------------------------
  bool IsStructured(xdmf2::XdmfGrid*);
 
  //---------------------------------------------------------------------------
  bool GetWholeExtent(xdmf2::XdmfGrid*, int extents[6]);
 
  //---------------------------------------------------------------------------
  bool GetOriginAndSpacing(xdmf2::XdmfGrid*, double origin[3], double spacing[3]);
 
  //---------------------------------------------------------------------------
  ~vtkXdmfDomain();
 
  // Returns VTK data type based on grid type and topology.
  // Returns -1 on error.
  int GetVTKDataType(xdmf2::XdmfGrid* xmfGrid);
 
  // Returns the dimensionality (or rank) of the topology for the given grid.
  // Returns -1 is the xmfGrid is not a uniform i.e. is a collection or a tree.
  static int GetDataDimensionality(xdmf2::XdmfGrid* xmfGrid);
 
  vtkXdmfArraySelection* GetPointArraySelection() { return this->PointArrays; }
  vtkXdmfArraySelection* GetCellArraySelection() { return this->CellArrays; }
  vtkXdmfArraySelection* GetGridSelection() { return this->Grids; }
  vtkXdmfArraySelection* GetSetsSelection() { return this->Sets; }
 
private:
  void CollectMetaData();
 
  // Used by CollectMetaData().
  void CollectMetaData(xdmf2::XdmfGrid* xmfGrid, vtkIdType silParent);
 
  // Used by CollectMetaData().
  void CollectNonLeafMetaData(xdmf2::XdmfGrid* xmfGrid, vtkIdType silParent);
 
  // Used by CollectMetaData().
  void CollectLeafMetaData(xdmf2::XdmfGrid* xmfGrid, vtkIdType silParent);
 
 
  bool UpdateGridAttributeInSIL(xdmf2::XdmfAttribute* xmfAttribute, vtkIdType gridSILId);
};
 
#endif
#endif
#endif
// VTK-HeaderTest-Exclude: vtkXdmfReaderInternal.h