EnsightWriter.cpp

#include<stdio.h>
#include<cstdlib>
#include<string>
#include<iostream>
#include<sstream>
#include<fstream>
#include<cmath>
#include "EnsightWriter.hpp"

EnsightWriter::EnsightWriter()
:Writer(),
_geoIsWritten(false),
_caseFileIsOpen(false),
posTimesInCase(0),
localCounter(0)
{}

EnsightWriter::EnsightWriter(Mesh * theMesh)
:Writer(theMesh),
_geoIsWritten(false),
_caseFileIsOpen(false),
posTimesInCase(0),
localCounter(0)
{}

EnsightWriter::~EnsightWriter()
{
  closeCaseFile();
  writeCaseFile();
}


void EnsightWriter::postProcess(const double & time)
{
  Writer::postProcess(time);
  if(!_geoIsWritten)
  {
    writeEnsightGeo();
    _geoIsWritten=true;
  }
  this->writeEnsightData( time);
}


// Write the geometry in the Ensight Format
void EnsightWriter::writeEnsightGeo()
{
    if(meshSetted())
    {
        size_t np   = mesh()->num_Points();
        size_t nTet = mesh()->num_Tetras();
        size_t nTri = mesh()->num_Trias();
        std::string fileName=output_dir()+"/"+prefix()+".geo";
        std::ofstream fileGeo(fileName.c_str());
        bool fileGeoIsOpened=false;

        if(fileGeo.fail())
        {
            std::cerr<<"WARNING: GEOMETRY FILE "<<fileName.c_str()<<" NOT OPENED"<<std::endl;
            fileGeoIsOpened=false;
        }
        else
        {
            fileGeoIsOpened = true;
        }
        if(fileGeoIsOpened)
        {
            fileGeo<<"Geometry file"<<std::endl;
            fileGeo<<"Geometry file"<<std::endl;
            fileGeo<<"node id assign"<<std::endl;
            fileGeo<<"element id assign"<<std::endl;
            fileGeo<<"coordinates"<<std::endl;
            fileGeo<<np<<std::endl;
            int oldPRec=fileGeo.precision(5);
            int oldWidth=fileGeo.width(12);
            for (size_t iPt=0;iPt<np; iPt++)
            {
                fileGeo.precision(5);
                fileGeo.width(12);
                fileGeo<<(mesh()->Pts(iPt)).coord[0]<<" "<<(mesh()->Pts(iPt)).coord[1]<<" "<<(mesh()->Pts(iPt)).coord[2]<<std::endl;
            }
            fileGeo.precision(oldPRec);
            fileGeo.width(oldWidth);
            fileGeo<<"part 1"<<std::endl;
            fileGeo<<"subdomain ref 0"<<std::endl;
            fileGeo<<"tetra4"<<std::endl;
            fileGeo<<nTet<<std::endl;
            for (size_t iTet=0;iTet<nTet; iTet++)
            {
                fileGeo<<(1+(mesh()->Tet(iTet)).vertices(0))<<" "<<(1+(mesh()->Tet(iTet)).vertices(1))<<" "<<(1+(mesh()->Tet(iTet)).vertices(2))<<" "<<(1+(mesh()->Tet(iTet)).vertices(3))<<std::endl;
            }
            fileGeo<<"part 2"<<std::endl;
            fileGeo<<"boundary ref 1"<<std::endl;
            fileGeo<<"tria3"<<std::endl;
            fileGeo<<nTri<<std::endl;
            for (size_t iTri=0;iTri<nTri; iTri++)
            {
                fileGeo<<(1+(mesh()->Tri(iTri)).vertices(0))<<" "<<(1+(mesh()->Tri(iTri)).vertices(1))<<" "<<(1+(mesh()->Tri(iTri)).vertices(2))<<std::endl;
            }
            fileGeo.close();
        }
    }
}


//Writes the variable in ensight format
void EnsightWriter::writeEnsightData(double _dumpTime)
{
  if(! _caseFileIsOpen)
  {
    bool status=openCaseFile();
    if(!status)
    {
        std::cerr<<"Warning: CASE FILE NOT OPENED"<<std::endl;
    }
  }    
  if(M_getPostfix())
  {
    _caseFile<<_dumpTime;
    localCounter=localCounter+1;
    if (localCounter==6)
    {
      _caseFile<<" "<<std::endl;
      localCounter=0;
    }
    else
    {
      _caseFile<<" ";
    }
    writeVariables();
  }
}


//Opens a temporary case file
bool EnsightWriter::openCaseFile()
{
  std::string caseFileName = output_dir()+"/"+prefix()+".case.tmp";
  bool opened=false;  
  localCounter=0;
  posTimesInCase=0;
  _caseFile.open(caseFileName.c_str());
  if (_caseFile.fail())
  {
    opened=false;
  }
  else
  {
    _caseFile<<"FORMAT"<<std::endl;
    _caseFile<<"type: ensight"<<std::endl;
    _caseFile<<"GEOMETRY"<<std::endl;
    _caseFile<<"model: 1 "<<prefix()<<".geo"<<std::endl;
    _caseFile<<"VARIABLE"<<std::endl;
    
    for (size_t ivar=0; ivar<_variablesContainer.size(); ivar++)
    {
      std::string nameVar = _variablesContainer[ivar].nameVar;
      _caseFile<<"scalar per node: 1 "<<nameVar<<" "<<nameVar<<".*****.scl"<<std::endl;
    }

    _caseFile<<"TIME"<<std::endl;
    _caseFile<<"time set: 1"<<std::endl;
    posTimesInCase =_caseFile.tellp();
    _caseFile<<"number of steps: "<<std::endl;
    _caseFile<<"filename start number: 0"<<std::endl;
    _caseFile<<"filename increment: 1"<<std::endl;
    _caseFile<<"time values:"<<std::endl;
    opened=true;
  }
  _caseFileIsOpen=opened;
  return(opened);
}


void EnsightWriter::writeVariables()
{
    for (size_t ivar=0; ivar<_variablesContainer.size(); ivar++)
    {
      write_scalar(_variablesContainer[ivar].values, _variablesContainer[ivar].nameVar);
    }
}


void EnsightWriter::write_scalar(const unkVecType * dvar, std::string nameVar)
{
  std::string strExt="." + postfix()+".scl";
  std::string fileNameVar=output_dir()+"/"+nameVar+strExt;
  std::ofstream outputFile(fileNameVar.c_str());
  
  bool IsOpen = (!outputFile.fail());
  std::string headerString = "Scalar per node\n";
  if(IsOpen)
  {
    outputFile<<headerString;
  }
  else
  {
    std::cerr<<"File "<<fileNameVar<<" not opened"<<std::endl;
    exit(1);
  }
  short int  count=0;
  size_t nPt = dvar->size();
  for(size_t  iPt=0; iPt<nPt; iPt++)
  {
      double * val = (*dvar)[iPt];
      outputFile.setf(std::ios_base::scientific);
      outputFile.precision(5);
      outputFile.width(12);
      outputFile<<*val;
      val=NULL;
      count=count+1;
      if(count==6)
      {
        outputFile<<std::endl;
        count=0;
    }
  }
  outputFile.close();
}


void EnsightWriter::closeCaseFile()
{
  if (_caseFile.is_open())
  {
    _caseFile.close();
    _caseFileIsOpen=false;
  }
}


void EnsightWriter::writeCaseFile()
{
  std::stringstream nbtime;
  nbtime<<counter();
  
  std::string caseFileName = output_dir()+"/"+ prefix()+".case";
  std::string tmpcaseFileName = output_dir()+"/"+ prefix()+".case.tmp";
  std::ifstream tmpCaseFile(tmpcaseFileName.c_str());

  _caseFile.open(caseFileName.c_str());

  if (_caseFile.fail())
  {
    _caseFileIsOpen=false;
  }
  else
  {
    _caseFileIsOpen=true;
    _caseFile<<"FORMAT"<<std::endl;
    _caseFile<<"type: ensight"<<std::endl;
    _caseFile<<"GEOMETRY"<<std::endl;
    _caseFile<<"model: 1 "<<prefix()<<".geo"<<std::endl;
    _caseFile<<"VARIABLE"<<std::endl;
    if (!tmpCaseFile.fail())
    {
      char line[1204];
      for(short int idiscard=0;idiscard<5;idiscard++)
      {
        tmpCaseFile.getline(line,1024);
      }
    }

    for (size_t ivar=0; ivar<_variablesContainer.size(); ivar++)
    {
      std::string nameVar = _variablesContainer[ivar].nameVar;
      _caseFile<<"scalar per node: 1 "<<nameVar<<" "<<nameVar<<".*****.scl"<<std::endl;
      if (!tmpCaseFile.fail())
      {
        char line[1204];
        tmpCaseFile.getline(line,1024);
      }
    }
    _caseFile<<"TIME"<<std::endl;
    _caseFile<<"time set: 1"<<std::endl;
    _caseFile<<"number of steps: "<<nbtime.str()<<std::endl;
    _caseFile<<"filename start number: 0"<<std::endl;
    _caseFile<<"filename increment: 1"<<std::endl;
    _caseFile<<"time values:"<<std::endl;
    if (!tmpCaseFile.fail())
    {
      char line[1204];
      for(short int idiscard=0;idiscard<6;idiscard++)
      {
        tmpCaseFile.getline(line,1024);
      }
    }
  }
  double timevalue=0.0;
  localCounter=0;
  for(size_t itim=0;itim<counter();itim++)
  {
    tmpCaseFile>>timevalue;
    _caseFile<<timevalue;
    localCounter=localCounter+1;
    if (localCounter==6)
    {
      _caseFile<<" "<<std::endl;
      localCounter=0;
    }
    else
    {
      _caseFile<<" ";
    }
  }
  if (_caseFile.is_open())
  {
    _caseFile.close();
    _caseFileIsOpen=false;
  }
  
  if(tmpCaseFile.is_open())
  {
      tmpCaseFile.close();
  }
 
  int file_removed = remove( tmpcaseFileName.c_str() );
  if(file_removed !=0)
  {
      std::cerr<<"file "<<tmpcaseFileName<<" not removed"<<std::endl;
  }  
}