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
 
// 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 "XdmfArray.h"
#include "XdmfAttribute.h"
#include "XdmfDOM.h"
//?
#include "XdmfDataDesc.h"
//?
#include "XdmfDataItem.h"
#include "XdmfGrid.h"
//?
#include "XdmfTopology.h"
//?
#include "XdmfGeometry.h"
//?
#include "XdmfTime.h"
//?
#include "XdmfSet.h"
 
#include <string>
#include <vector>
#include <set>
#include <map>
#include <vtksys/SystemTools.hxx>
#include <cassert>
#include <functional>
#include <algorithm>
#include <vtksys/ios/sstream>
 
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 NULL;
    }
 
  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