FileWriter.h

// ============================================================================
// ==                                                                        ==
// == AMDiS - Adaptive multidimensional simulations                          ==
// ==                                                                        ==
// ==  http://www.amdis-fem.org                                              ==
// ==                                                                        ==
// ============================================================================
//
// Software License for AMDiS
//
// Copyright (c) 2010 Dresden University of Technology 
// All rights reserved.
// Authors: Simon Vey, Thomas Witkowski et al.
//
// This file is part of AMDiS
//
// See also license.opensource.txt in the distribution.



/** \file FileWriter.h */

/** \defgroup Output Output module
 * @{ <img src="output.png"> @}
 */

#ifndef AMDIS_FILEWRITER_H
#define AMDIS_FILEWRITER_H

#include <vector>
#include <string>
#include "AMDiS_fwd.h"
#include "Mesh.h"
#include "DataCollector.h"

namespace AMDiS {

  using namespace std;

  typedef enum {
    NONE = 0,
    GZIP = 1,
    BZIP2 = 2
  } FileCompression;


  class FileWriterInterface
  {
  public:
    FileWriterInterface()
      : filename(""),
	traverseLevel(-1),
	traverseFlag(Mesh::CALL_LEAF_EL),
	writeElement(NULL)
    {}

    virtual ~FileWriterInterface() {}

    /** \brief
     * Interface. Must be overridden in subclasses.
     * \param time time index of solution vector.
     * \param force enforces the output operation for the last timestep.
     */
    virtual void writeFiles(AdaptInfo *adaptInfo, bool force,
			    int level = -1,
			    Flag traverseFlag = Mesh::CALL_LEAF_EL,
			    bool (*writeElem)(ElInfo*) = NULL) = 0;

    void setTraverseProperties(int level, 
			       Flag flag,
			       bool (*writeElem)(ElInfo*))
    {
      traverseLevel = level;
      traverseFlag |= flag;
      writeElement = writeElem;
    }

    string getFilename() 
    { 
      return filename; 
    }
    
    void setFilename(string n) 
    { 
      filename = n; 
    }

  protected:
    /// Used filename prefix.
    string filename;

    int traverseLevel;

    Flag traverseFlag;

    bool (*writeElement)(ElInfo*);  
  };

  /**  
   * \ingroup Output
   *
   * \brief
   * Base class of FileWriterScal and FileWriterVec. Manages the file output
   * of solution vectors.
   */
  template<typename T>
  class FileWriterTemplated : public FileWriterInterface
  {
  public:
    /// Constructor for a filewriter for one data component.
    FileWriterTemplated(string name, Mesh *mesh, DOFVector<T> *vec);

    /// Constructor for a filewriter with more than one data component.
    FileWriterTemplated(string name,
	       Mesh *mesh,
	       vector< DOFVector<T>* > vecs);

    /// Constructor for a filewriter with more than one data component.
    FileWriterTemplated(std::string name,
	       Mesh *mesh,
	       SystemVector *vecs);

    /// Destructor
    virtual ~FileWriterTemplated();

    /// Implementation of FileWriterInterface::writeFiles().
    virtual void writeFiles(AdaptInfo *adaptInfo, bool force,
			    int level = -1,
			    Flag traverseFlag = Mesh::CALL_LEAF_EL,
			    bool (*writeElem)(ElInfo*) = NULL);

  protected:
    /// Initialization of the filewriter.
    void initialize();

    /// Reads all file writer dependend parameters from the init file.
    void readParameters();

    /// Name of the writer.
    string name;

    /// AMDiS mesh-file extension.
    string amdisMeshExt;

    /// AMDiS solution-file extension.
    string amdisDataExt;

    /// VTK file extension.
    string paraviewFileExt;

    /// Parallel VTK file extension.
    string paraviewParallelFileExt;

    /// Periodic file extension.
    string periodicFileExt;

    /// 0: Don't write AMDiS files; 1: Write AMDiS files. 
    int writeAMDiSFormat;

    /// 0: Don't write ParaView files; 1: Write ParaView files.
    int writeParaViewFormat;

    /// 0: Don't write ParaView vector files; 1: Write ParaView vector files.
    int writeParaViewVectorFormat;

    /// 1: extend number of component to 3, so that paraview can display the vector as worldvector
    bool writeAs3dVector;

    /// 0: Don't write ParaView animation file; 1: Write ParaView animation file.
    int writeParaViewAnimation;

    /// 0: Don't write periodic files; 1: Write periodic files.
    int writePeriodicFormat;

    /// 0: Don't write png files; 1: Write png image files.
    int writePngFormat;

    /// 0: Gray color picture; 1: RGB picture.
    int pngType;

    /// 0: Don't write Povray scripts; 1: Write Povray scripts
    int writePovrayFormat;

    /// 0: Don't write DOF files; 1: Write DOF files
    int writeDofFormat;

    /// 0: Don't write ARH files; 1: Write ARH files
    int writeArhFormat;

    /// camera position for povray script files
    string povrayCameraLocation;

    /// orientation for camera in povray script files
    string povrayCameraLookAt;

    /// name of the template file that will be prepended to all created *.pov files 
    string povrayTemplate;

    /// 0: Don't append time index to filename prefix.
    /// 1: Append time index to filename prefix.
    int appendIndex;

    /// Total length of appended time index.
    int indexLength;

    /// Number of decimals in time index.
    int indexDecimals;

    /// Timestep modulo: write only every tsModulo-th timestep! 
    int tsModulo;

    /// Stores a set of pairs of timepoint and filename to write a ParaView 
    /// animation file.
    vector<pair<double, string> > paraviewAnimationFrames;

    ///
    int timestepNumber;

    /// Mesh used for output.
    Mesh *mesh;

    /// fespace used for output.
    const FiniteElemSpace *feSpace;

    /// Pointers to the vectors which store the solution.
    vector<DOFVector<T>*> solutionVecs;

    /** \brief
     * Stores the number of temporal solutions vectors, which have been created
     * in the constructor. If this number is greater than zero, the vectors
     * stored in solutionVecs_ must be deleted in the destructor.
     */
    int nTmpSolutions;

    /** \brief
     * Defines if, and with what kind of compression, the file should be compressed
     * during writing.
     */
    FileCompression compression;
  };

  template<>
  FileWriterTemplated<double>::FileWriterTemplated(std::string name_,
			 Mesh *mesh_,
			 SystemVector *vecs);

  template<>
  void FileWriterTemplated<double>::writeFiles(AdaptInfo *adaptInfo,
			      bool force,
			      int level,
			      Flag flag,
			      bool (*writeElem)(ElInfo*));
  
  typedef FileWriterTemplated<double> FileWriter;
  typedef FileWriterTemplated<WorldVector<double> > FileVectorWriter;

}

#endif // AMDIS_FILEWRITER_H