Maxwell-TD-Scattering/MaxwellTD_GPU_Port/utils/vtkwriter.cc

#include "vtkwriter.h"
#include "Constants.h"

#include "vtk-5.0/vtkCellArray.h"
#include "vtk-5.0/vtkCellData.h"
#include "vtk-5.0/vtkDoubleArray.h"
#include "vtk-5.0/vtkIntArray.h"
#include "vtk-5.0/vtkPointData.h"
#include "vtk-5.0/vtkPoints.h"
#include "vtk-5.0/vtkPolyData.h"
#include "vtk-5.0/vtkXMLPolyDataWriter.h"
#include "vtk-5.0/vtkUnstructuredGrid.h"
#include "vtk-5.0/vtkMergeCells.h" 
#include "vtk-5.0/vtkXMLUnstructuredGridWriter.h"
#include "vtk-5.0/vtkXMLPUnstructuredGridWriter.h"
#include "vtk-5.0/vtkXMLPUnstructuredGridReader.h"
#include "vtk-5.0/vtkXMLUnstructuredGridReader.h"

#include "vtk-5.0/vtkActor.h"
#include "vtk-5.0/vtkDataSetMapper.h"
// #include "vtk-5.0/vtkMath.h"
#include "vtk-5.0/vtkRenderWindow.h"
#include "vtk-5.0/vtkRenderWindowInteractor.h"
#include "vtk-5.0/vtkRenderer.h"
#include "vtk-5.0/vtkShrinkFilter.h"
#include "vtk-5.0/vtkStructuredGrid.h"
#include "vtk-5.0/vtkSmartPointer.h"
// 2D plot
// #include "vtk-5.0/vtkDataSetMapper.h"
// #include "vtk-5.0/vtkSphereSource.h"
// #include "vtk-5.0/vtkDoubleArray.h"
// #include "vtk-5.0/vtkFieldData.h"
// #include "vtk-5.0/vtkPolyData.h"
// #include "vtk-5.0/vtkPolyDataMapper.h"
// #include "vtk-5.0/vtkXYPlotActor.h"

// #include "vtkwriter.h"
// #include "Constants.h"
// #include "vtkCellArray.h"
// #include "vtkCellData.h"
// #include "vtkDoubleArray.h"
// #include "vtkIntArray.h"
// #include "vtkPointData.h"
// #include "vtkPoints.h"
// #include "vtkPolyData.h"
// #include "vtkXMLPolyDataWriter.h"
// #include "vtkUnstructuredGrid.h"
// #include "vtkMergeCells.h" 
// #include "vtkXMLUnstructuredGridWriter.h"
// #include "vtkXMLPUnstructuredGridWriter.h"
// #include "vtkXMLPUnstructuredGridReader.h"
// #include "vtkXMLUnstructuredGridReader.h"
// 
// #include "vtkActor.h"
// #include "vtkDataSetMapper.h"
// // #include "vtk-5.0/vtkMath.h"
// #include "vtkRenderWindow.h"
// #include "vtkRenderWindowInteractor.h"
// #include "vtkRenderer.h"
// #include "vtkShrinkFilter.h"
// #include "vtkStructuredGrid.h"
// #include "vtkSmartPointer.h"


const char* E_FIELD_NAME = "E";
const char* H_FIELD_NAME = "H";
const char* M_FIELD_NAME = "M";
const char* J_FIELD_NAME = "J";
// const int   STRLEN           = 256;
// const char* VTK_DIR     = "vtk";
const char* DOMAIN_NAME = "domain";
const char* MATERIAL_NAME = "material";
const char* SUBDOMAIN_NAME = "domain_reord";
const char* POLY_ORDER_NAME  = "poly_order";

const char* COMP_STR[3] = {"_x", "_y", "_z"};

VtkWriter::VtkWriter(fp_t unit){
  unit_ = unit;
}

VtkWriter::~VtkWriter(){}

void VtkWriter::writeMesh(char* outFilePrefix, const int nodeNum, node** nodeArray, const int tetNum, tetra** tetArray){
  vtkUnstructuredGrid* mesh = vtkUnstructuredGrid::New();
  addNodes(mesh, nodeNum, nodeArray);
  addCells(mesh, tetNum, tetArray);
  addCellMaterial(mesh, tetNum, tetArray);

  string outputFile(outFilePrefix);
  outputFile.append(".vtu");

  vtkXMLUnstructuredGridWriter* writer = vtkXMLUnstructuredGridWriter::New();
  writer->SetFileName(outputFile.c_str());
  writer->SetDataModeToBinary();
  writer->SetInput(mesh);
  writer->Write();
  writer->Delete();
  mesh->Delete();
}

void VtkWriter::writeMesh(char* outFilePrefix, const int nodeNum, node* nodeArray, const int tetNum, tetra* tetArray){
  vtkUnstructuredGrid* mesh = vtkUnstructuredGrid::New();
  addNodes(mesh, nodeNum, nodeArray);
  addCells(mesh, tetNum, tetArray);
  addCellMaterial(mesh, tetNum, tetArray);

  string outputFile(outFilePrefix);
  outputFile.append(".vtu");

  vtkXMLUnstructuredGridWriter* writer = vtkXMLUnstructuredGridWriter::New();
  writer->SetFileName(outputFile.c_str());
  writer->SetDataModeToBinary();
  writer->SetInput(mesh);
  writer->Write();
  writer->Delete();
  mesh->Delete();
}

void VtkWriter::writeField(char* outFilePrefix, const int nodeNum, node* nodeArray,const int tetNum, tetra* tetArray,
                           vtr* eField, vtr* hField, int* polyOrder, int* LTS_Flag, int* Ghost_Flag){
  vtkUnstructuredGrid* mesh = vtkUnstructuredGrid::New();
  addNodes(mesh, nodeNum, nodeArray);
  addCells(mesh, tetNum, tetArray);
  addCellMaterial(mesh, tetNum, tetArray);
  // addPointVector(mesh, nodeNum, eField, "E");
  // addPointVector(mesh, nodeNum, hField, "H");
  addPointScalars(mesh, nodeNum, eField, "E");
  addPointScalars(mesh, nodeNum, hField, "H");
  if (polyOrder != 0)
    addCellScalar(mesh, tetNum, polyOrder, "PolynomialOrder");
  
  if (LTS_Flag != 0)
    addCellScalar(mesh, tetNum, LTS_Flag, "LTS_Flag");
  
  if (Ghost_Flag != 0)
    addCellScalar(mesh, tetNum, Ghost_Flag, "Ghost_Flag");  

  string outputFile(outFilePrefix);
  outputFile.append(".vtu");

  // cout << "nodeNum in writeFields = " << nodeNum << endl;
  // cout << "polyOrder in writeFields = " << polyOrder << endl;
  // cout << "LTS_Flag in writeFields = " << LTS_Flag << endl;

  vtkXMLUnstructuredGridWriter* writer = vtkXMLUnstructuredGridWriter::New();
  writer->SetFileName(outputFile.c_str());
  writer->SetDataModeToBinary();
  // writer->SetDataModeToAscii();
  writer->SetInput(mesh);
  writer->Write();
  writer->Delete();
  mesh->Delete();
}

void VtkWriter::InteractiveFieldViz(char* outFilePrefix, const int nodeNum, node* nodeArray, const int tetNum, 
                                    tetra* tetArray, vtr* eField, vtr* hField, int* polyOrder, int* LTS_Flag, int* Ghost_Flag){
//   vtkUnstructuredGrid* mesh = vtkUnstructuredGrid::New();
//   addNodes(mesh, nodeNum, nodeArray);
//   addCells(mesh, tetNum, tetArray);
//   addCellMaterial(mesh, tetNum, tetArray);
// //   addPointVector(mesh, nodeNum, eField, "E");
// //   addPointVector(mesh, nodeNum, hField, "H");
//   addPointScalars(mesh, nodeNum, eField, "E");
//   addPointScalars(mesh, nodeNum, hField, "H");
//   if (polyOrder != 0)
//     addCellScalar(mesh, tetNum, polyOrder, "PolynomialOrder");
//   
//   if (LTS_Flag != 0)
//     addCellScalar(mesh, tetNum, polyOrder, "PolynomialOrder");
//   
//   if (Ghost_Flag != 0)
//     addCellScalar(mesh, tetNum, polyOrder, "PolynomialOrder");  
// 
//   string outputFile(outFilePrefix);
//   outputFile.append(".vtu");

//   vtkSmartPointer<vtkStructuredGrid> structuredGrid = 
//     vtkSmartPointer<vtkStructuredGrid>::New();
//  
//   vtkSmartPointer<vtkPoints> points = 
//     vtkSmartPointer<vtkPoints>::New();
//   unsigned int numi = 3;
//   unsigned int numj = 4;
//   unsigned int numk = 5;
//  
//   for(unsigned int k = 0; k < numk; k++)
//     {
//     for(unsigned int j = 0; j < numj; j++)
//       {
//       for(unsigned int i = 0; i < numi; i++)
//         {
//         points->InsertNextPoint(i, j, k);
//         }
//       }
//     }
//  
//   // Specify the dimensions of the grid
//   structuredGrid->SetDimensions(numi, numj, numk);
//   structuredGrid->SetPoints(points);
//  
//   std::cout << "There are "
//             << structuredGrid->GetNumberOfPoints() << " points."
//             << std::endl;
//   std::cout << "There are "
//             << structuredGrid->GetNumberOfCells() << " cells."
//             << std::endl;
//  
//   vtkSmartPointer<vtkShrinkFilter> shrinkFilter = vtkSmartPointer<vtkShrinkFilter>::New();
//   shrinkFilter->SetInputConnection(structuredGrid->GetProducerPort());
//   shrinkFilter->SetShrinkFactor(.8);
//  
//   // Create a mapper and actor
//   vtkSmartPointer<vtkDataSetMapper> mapper = vtkSmartPointer<vtkDataSetMapper>::New();
//   mapper->SetInputConnection(shrinkFilter->GetOutputPort());
//   vtkSmartPointer<vtkActor> actor = 
//     vtkSmartPointer<vtkActor>::New();
//   actor->SetMapper(mapper);
 
//   // Create a renderer, render window, and interactor
//   vtkSmartPointer<vtkRenderer>     renderer     = vtkSmartPointer<vtkRenderer>::New();
//   vtkSmartPointer<vtkRenderWindow> renderWindow = vtkSmartPointer<vtkRenderWindow>::New();
//   renderWindow->AddRenderer(renderer);
//   vtkSmartPointer<vtkRenderWindowInteractor> renderWindowInteractor = vtkSmartPointer<vtkRenderWindowInteractor>::New();
//   renderWindowInteractor->SetRenderWindow(renderWindow);
//  
//   // Add the actor to the scene
//   renderer->AddActor(actor);
//   renderer->SetBackground(.2, .3, .4);
//  
//   // Render and interact
//   renderWindow->Render();
//   renderWindowInteractor->Start();
}

void VtkWriter::addNodes(vtkUnstructuredGrid* mesh, const int nodeNum, node* nodeList){
  int i = 0;

  vtkPoints* points = vtkPoints::New();
  points->SetNumberOfPoints(nodeNum);
  fp_t coord[3];
  for (i = 0; i < nodeNum; i++) {
    coord[0] = nodeList[i].getCoord().getx() * unit_;
    coord[1] = nodeList[i].getCoord().gety() * unit_;
    coord[2] = nodeList[i].getCoord().getz() * unit_;
    points->InsertPoint(i, coord);
  }
  mesh->SetPoints(points);
  points->Delete();
}

void VtkWriter::addNodes(vtkUnstructuredGrid* mesh, const int nodeNum, node** nodeList){
  int i = 0;

  vtkPoints* points = vtkPoints::New();
  points->SetNumberOfPoints(nodeNum);
  fp_t coord[3];
  for (i = 0; i < nodeNum; i++) {
    coord[0] = nodeList[i]->getCoord().getx() * unit_;
    coord[1] = nodeList[i]->getCoord().gety() * unit_;
    coord[2] = nodeList[i]->getCoord().getz() * unit_;
    points->InsertPoint(i, coord);
  }
  mesh->SetPoints(points);
  points->Delete();
}

void VtkWriter::addCells(vtkUnstructuredGrid* mesh, const int tetNum, tetra* tetArray){
  int i = 0;
  int j = 0;

  int nodePerElem = 4;
  vtkIdType vtkId = VTK_TETRA;

  vtkCellArray* cells = vtkCellArray::New();
  vtkIdType sz = cells->EstimateSize(tetNum, nodePerElem);
  cells->Allocate(sz);
  vtkIdType* conn = new vtkIdType[nodePerElem];
  for (i = 0; i < tetNum; i++) {
    for (j = 0; j < nodePerElem; j++)
      conn[EMOFFICE_TO_VTK_TET2_NODES[j]] = tetArray[i].getNode(j)->getid();
    cells->InsertNextCell(nodePerElem, conn);
  }
  mesh->SetCells(vtkId, cells);

  cells->Delete();
  delete [] conn;
}

void VtkWriter::addCells(vtkUnstructuredGrid* mesh, const int tetNum, tetra** tetArray){
  int i = 0;
  int j = 0;

  int nodePerElem = 4;
  vtkIdType vtkId = VTK_TETRA;

  vtkCellArray* cells = vtkCellArray::New();
  vtkIdType* conn = new vtkIdType[nodePerElem];
  for (i = 0; i < tetNum; i++) {
    for (j = 0; j < nodePerElem; j++)
      conn[EMOFFICE_TO_VTK_TET2_NODES[j]] = tetArray[i]->getNode(j)->getid();
    cells->InsertNextCell(nodePerElem, conn);
  }
  mesh->SetCells(vtkId, cells);
  cells->Delete();
  delete [] conn;
}

void VtkWriter::addCells(vtkUnstructuredGrid* mesh, list<tetra*>& tetList){
  int i = 0;

  int nodePerElem = 4;
  vtkIdType vtkId = VTK_TETRA;

  vtkCellArray* cells = vtkCellArray::New();
  vtkIdType*    conn  = new vtkIdType[nodePerElem];
  list<tetra*>::iterator tetIter;
  for (tetIter = tetList.begin(); tetIter != tetList.end(); tetIter++) {
    for (i = 0; i < nodePerElem; i++)
      conn[EMOFFICE_TO_VTK_TET2_NODES[i]] = (*tetIter)->getNode(i)->getid();
    cells->InsertNextCell(nodePerElem, conn);
  }
  mesh->SetCells(vtkId, cells);
  cells->Delete();
  delete [] conn;
}

void VtkWriter::addCells(vtkUnstructuredGrid* mesh, const int faceNum, face* faceList){
  int i = 0;
  int j = 0;

  int nodePerElem = 4;
  vtkIdType vtkId = VTK_TETRA;

  vtkCellArray* cells = vtkCellArray::New();
  vtkIdType*    conn  = new vtkIdType[nodePerElem];
  for (i = 0; i < faceNum; i++) {
    for (j = 0; j < nodePerElem; j++)
      conn[EMOFFICE_TO_VTK_TRI2_NODES[j]] = faceList[i].getNode(j)->getid();
    cells->InsertNextCell(nodePerElem, conn);
  }
  mesh->SetCells(vtkId, cells);
  cells->Delete();
  delete [] conn;
}

void VtkWriter::addCells(vtkUnstructuredGrid* mesh, const unsigned int nodeNum){
  vtkCellArray* cells = vtkCellArray::New();
  for (vtkIdType i = 0; i < static_cast<vtkIdType>(nodeNum); i++)
    cells->InsertNextCell(1, &i);
  mesh->SetCells(VTK_VERTEX, cells);
  cells->Delete();
}

void VtkWriter::addPointVector(vtkUnstructuredGrid* mesh, const unsigned int pointNum, vtr* data, const string& dataName){
  unsigned int i = 0;

  char name[STRLEN];
  fp_t tuple[3];

  vtkDoubleArray* array = vtkDoubleArray::New();
  array->SetNumberOfComponents(3);
  array->SetNumberOfTuples(pointNum);
  array->SetName(dataName.c_str());
  for (i = 0; i < pointNum; i++) {
    tuple[0] = data[i].getx();
    tuple[1] = data[i].gety();
    tuple[2] = data[i].getz();
    array->SetTuple(i, tuple);
  }
  mesh->GetPointData()->AddArray(array);
  array->Delete();
}

void VtkWriter::addPointScalars(vtkUnstructuredGrid* mesh, const unsigned int pointNum, vtr* data, const string& dataName){
  unsigned int i = 0;

  vtkDoubleArray* dataArray = NULL;
  char name[STRLEN];

  memset(name, 0, STRLEN*sizeof(char));
  sprintf(name, "%s%s", dataName.c_str(), COMP_STR[0]);
  dataArray = vtkDoubleArray::New();
  dataArray->SetName(name);
  dataArray->SetNumberOfComponents(1);
  dataArray->SetNumberOfTuples(pointNum);
  for (i = 0; i < pointNum; i++)
    dataArray->SetValue(i, data[i].getx());
  mesh->GetPointData()->AddArray(dataArray);
  dataArray->Delete();

  memset(name, 0, STRLEN*sizeof(char));
  sprintf(name, "%s%s", dataName.c_str(), COMP_STR[1]);
  dataArray = vtkDoubleArray::New();
  dataArray->SetName(name);
  dataArray->SetNumberOfComponents(1);
  dataArray->SetNumberOfTuples(pointNum);
  for (i = 0; i < pointNum; i++)
    dataArray->SetValue(i, data[i].gety());
  mesh->GetPointData()->AddArray(dataArray);
  dataArray->Delete();

  memset(name, 0, STRLEN*sizeof(char));
  sprintf(name, "%s%s", dataName.c_str(), COMP_STR[2]);
  dataArray = vtkDoubleArray::New();
  dataArray->SetName(name);
  dataArray->SetNumberOfComponents(1);
  dataArray->SetNumberOfTuples(pointNum);
  for (i = 0; i < pointNum; i++)
    dataArray->SetValue(i, data[i].getz());
  mesh->GetPointData()->AddArray(dataArray);
  dataArray->Delete();

  fp_t valx;
  fp_t valy;
  fp_t valz;
  memset(name, 0, STRLEN*sizeof(char));
  sprintf(name, "%s_mag", dataName.c_str());
  dataArray = vtkDoubleArray::New();
  dataArray->SetName(name);
  dataArray->SetNumberOfComponents(1);
  dataArray->SetNumberOfTuples(pointNum);
  for (i = 0; i < pointNum; i++) {
    valx = data[i].getx();
    valy = data[i].gety();
    valz = data[i].getz();
    dataArray->SetValue(i, sqrt(valx*valx + valy*valy + valz*valz));
  }
  mesh->GetPointData()->AddArray(dataArray);
  dataArray->Delete();
}

void VtkWriter::addCellScalar(vtkUnstructuredGrid* mesh, const int cellNum, int* data, const string& dataName){
  int i = 0;

  vtkIntArray* array = vtkIntArray::New();
  array->SetName(dataName.c_str());
  array->SetNumberOfComponents(1);
  array->SetNumberOfTuples(cellNum);
  for (i = 0; i < cellNum; i++)
    array->SetValue(i, data[i]);
  mesh->GetCellData()->AddArray(array);
  array->Delete();
}

void VtkWriter::addCellMaterial(vtkUnstructuredGrid* mesh, const int tetraNum, tetra* tetraList)
{
  int i = 0;

  vtkIntArray* array = vtkIntArray::New();
  array->SetName("material");// here
  array->SetNumberOfComponents(1);
  array->SetNumberOfTuples(tetraNum);
  for (i = 0; i < tetraNum; i++)
    array->SetValue(i, tetraList[i].getobjNum());
  mesh->GetCellData()->AddArray(array);
  array->Delete();
}

void VtkWriter::addCellMaterial(vtkUnstructuredGrid* mesh, const int tetraNum, tetra** tetraList){
  int i = 0;

  vtkIntArray* array = vtkIntArray::New();
  array->SetName("Material");
  array->SetNumberOfComponents(1);
  array->SetNumberOfTuples(tetraNum);
  for (i = 0; i < tetraNum; i++)
    array->SetValue(i, tetraList[i]->getobjNum());
  mesh->GetCellData()->AddArray(array);
  array->Delete();
}

void VtkWriter::addCellMaterial(vtkUnstructuredGrid* mesh, list<tetra*>& tetList){
  int i = 0;

  vtkIntArray* array = vtkIntArray::New();
  array->SetName("Material");
  array->SetNumberOfComponents(1);
  array->SetNumberOfTuples(tetList.size());
  list<tetra*>::iterator tetIter;
  for (tetIter = tetList.begin(); tetIter != tetList.end(); tetIter++) {
    array->SetValue(i, (*tetIter)->getobjNum());
    i++;
  }
  mesh->GetCellData()->AddArray(array);
  array->Delete();
}

void VtkWriter::addCellOrder(vtkUnstructuredGrid* mesh, const int tetraNum, tetra* tetraList){
  int i = 0;

  vtkIntArray* array = vtkIntArray::New();
  array->SetName(POLY_ORDER_NAME);
  array->SetNumberOfComponents(1);
  array->SetNumberOfTuples(tetraNum);
  for (i = 0; i < tetraNum; i++)
    array->SetValue(i, tetraList[i].get_PolyOrderFlag());
  mesh->GetCellData()->AddArray(array);
  array->Delete();
}

void VtkWriter::addCellOrder(vtkUnstructuredGrid* mesh, const int tetraNum, tetra** tetraList){
  int i = 0;

  vtkIntArray* array = vtkIntArray::New();
  array->SetName(POLY_ORDER_NAME);
  array->SetNumberOfComponents(1);
  array->SetNumberOfTuples(tetraNum);
  for (i = 0; i < tetraNum; i++)
    array->SetValue(i, tetraList[i]->get_PolyOrderFlag());
  mesh->GetCellData()->AddArray(array);
  array->Delete();
}

void VtkWriter::addCellOrder(vtkUnstructuredGrid* mesh, list<tetra*>& tetList){
  int i = 0;

  vtkIntArray* array = vtkIntArray::New();
  array->SetName(POLY_ORDER_NAME);
  array->SetNumberOfComponents(1);
  array->SetNumberOfTuples(tetList.size());
  list<tetra*>::iterator tetIter;
  for (tetIter = tetList.begin(); tetIter != tetList.end(); tetIter++) {
    array->SetValue(i, (*tetIter)->get_PolyOrderFlag());
    i++;
  }
  mesh->GetCellData()->AddArray(array);
  array->Delete();
}

void VtkWriter::writeTriUg(char* outFilePrefix, const int nodeNum, node** nodeArray, const int faceNum, 
                           face** faceArray, vtr* eField, vtr* hField, int order){
  vtkUnstructuredGrid* mesh = vtkUnstructuredGrid::New();
  addNodes(mesh, nodeNum, nodeArray);
  addCells(mesh, faceNum, faceArray, order);
  // if (eField != 0) addPointVector(mesh, nodeNum, eField, E_FIELD_NAME);
  // if (hField != 0) addPointVector(mesh, nodeNum, hField, H_FIELD_NAME);
  if (eField != 0)
    addPointScalars(mesh, nodeNum, eField, E_FIELD_NAME);
  if (hField != 0)
    addPointScalars(mesh, nodeNum, hField, H_FIELD_NAME);

  string outputFile(outFilePrefix);
  outputFile.append(VTK_UG_FILE_EXT);

  vtkXMLUnstructuredGridWriter* writer = vtkXMLUnstructuredGridWriter::New();
  writer->SetFileName(outputFile.c_str());
//   writer->SetDataModeToBinary();
  writer->SetDataModeToAscii();
  writer->SetInput(mesh);
  writer->Write();
  writer->Delete();
  mesh->Delete();
}

void VtkWriter::writeTriUg(char* outFilePrefix, const int nodeNum, node** nodeArray, const int faceNum, face** faceArray, int order){
  vtkUnstructuredGrid* mesh = vtkUnstructuredGrid::New();
  addNodes(mesh, nodeNum, nodeArray);
  addCells(mesh, faceNum, faceArray, order);

  string outputFile(outFilePrefix);
  outputFile.append(VTK_UG_FILE_EXT);

  vtkXMLUnstructuredGridWriter* writer = vtkXMLUnstructuredGridWriter::New();
  writer->SetFileName(outputFile.c_str());
  // writer->SetDataModeToBinary();
  writer->SetDataModeToAscii();
  writer->SetInput(mesh);
  writer->Write();
  writer->Delete();
  mesh->Delete();
}

void VtkWriter::writePointUg(char* outFilePrefix, const int nodeNum, node** nodeArray, vtr* eField, vtr* hField){
  vtkUnstructuredGrid* mesh = vtkUnstructuredGrid::New();
  addNodes(mesh, nodeNum, nodeArray);
  addCells(mesh, nodeNum);
  // if (eField != 0) addPointVector(mesh, nodeNum, eField, E_FIELD_NAME);
  // if (hField != 0) addPointVector(mesh, nodeNum, hField, H_FIELD_NAME);
  if (eField != 0)
    addPointScalars(mesh, nodeNum, eField, E_FIELD_NAME);
  if (hField != 0)
    addPointScalars(mesh, nodeNum, hField, H_FIELD_NAME);
  string outputFile(outFilePrefix);
  outputFile.append(VTK_UG_FILE_EXT);

  vtkXMLUnstructuredGridWriter* writer = vtkXMLUnstructuredGridWriter::New();
  writer->SetFileName(outputFile.c_str());
  writer->SetDataModeToBinary();
  writer->SetInput(mesh);
  writer->Write();
  writer->Delete();
}

void VtkWriter::addCells(vtkUnstructuredGrid* mesh, const int faceNum, face** faceList, int order){
  int nodePerElem = 0;
  vtkIdType vtkId;
  if (order == 1) {
    nodePerElem = 3;
    vtkId = VTK_TRIANGLE;
  } else if (order == 2) {
    nodePerElem = 6;
    vtkId = VTK_QUADRATIC_TRIANGLE;
  } else {
    cerr << "ERROR : VtkWriter::addCells requires 1st or 2nd order triangles" << endl;
    return;
  }

  vtkCellArray* cells = vtkCellArray::New();
  vtkIdType*    conn  = new vtkIdType[nodePerElem];
  for (int i = 0; i < faceNum; i++) {
    for (int j = 0; j < nodePerElem; j++)
      conn[EMOFFICE_TO_VTK_TRI2_NODES[j]] = faceList[i]->getNode(j)->getid();
    cells->InsertNextCell(nodePerElem, conn);
  }
  mesh->SetCells(vtkId, cells);
  cells->Delete();
  delete [] conn;
}

 // 2D Plot
// void VtkWriter::Plot_XY(int Xdim, int Ydim, fp_t* Xdata, fp_t* Ydata)
// {
// 
//   vtkSmartPointer<vtkXYPlotActor> plot = vtkSmartPointer<vtkXYPlotActor>::New();
//   plot->ExchangeAxesOff();
//   plot->SetLabelFormat( "%g" );
//   plot->SetXTitle( "Level" );
//   plot->SetYTitle( "Frequency" );
//   plot->SetXValuesToIndex();
//  
//   for (unsigned int i = 0 ; i < 2 ; i++) {
//     vtkSmartPointer<vtkDoubleArray> array_s = vtkSmartPointer<vtkDoubleArray>::New();
//     vtkSmartPointer<vtkFieldData>   field   = vtkSmartPointer<vtkFieldData>::New();
//     vtkSmartPointer<vtkDataObject>  data    = vtkSmartPointer<vtkDataObject>::New();
//  
//     for (int b = 0; b < 30; b++){   /// Assuming an array of 30 elements
//       fp_t val = b*1.2312123;
//       array_s->InsertValue(b, val);
//     }
//     field->AddArray(array_s);
//     data->SetFieldData(field);
//     plot->AddDataObjectInput(data);    
//   }
//  
//   plot->SetPlotColor(0,1,0,0);
//   plot->SetPlotColor(1,0,1,0);
//  
//   vtkSmartPointer<vtkRenderer> renderer2 = vtkSmartPointer<vtkRenderer>::New();
//   renderer2->AddActor(plot);
//  
//   vtkSmartPointer<vtkRenderWindow> renderWindow2 = vtkSmartPointer<vtkRenderWindow>::New();
//   renderWindow2->AddRenderer( renderer2 );
//   renderWindow2->SetSize(500,500);
//  
//   vtkSmartPointer<vtkRenderWindowInteractor> interactor = vtkSmartPointer<vtkRenderWindowInteractor>::New();
//   interactor->SetRenderWindow( renderWindow2 );
//  
//   // Initialize the event loop and then start it
//   interactor->Initialize();
//   interactor->Start(); 
//  
// //   return EXIT_SUCCESS;
// }