gmFileIO.h

Go to the documentation of this file.

/************************************************************************
**
** Copyright (C) 2014 by Carlos Augusto Teixera Mendes
** All rights reserved.
**
** This file is part of the "GeMA" software. It's use should respect
** the terms in the license agreement that can be found together 
** with this source code.
** It is provided AS IS, with NO WARRANTY OF ANY KIND, 
** INCLUDING THE WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR 
** A PARTICULAR PURPOSE.
**
************************************************************************/
 
#ifndef _GEMA_FILE_IO_H_
#define _GEMA_FILE_IO_H_
 
#include "gmCoreConfig.h"
 
#include "gmStateDumpItem.h"
#include "gmGaussToElementNodeInterpolator.h"
 
#include <QStringList>
#include <QVariantMap>
 
class GmFileReader;
class GmFileWriter;
class GmFileFormat;
class GmFileFilter;
 
class GmLogCategory;
class GmSimulationData;
class GmMesh;
class GmCellMesh;
class GmElementMesh;
class GmCellGroupSet;
class GmBoundaryCondition;
class GmDiscontinuitySet;
 
class GmNodeAcResultsDataSrc;
class GmCellAcResultsDataSrc;
class GmGaussAcResultsDataSrc;
class GmResultsDataSrcInfo;
 
class GmValueInfo;
class GmValueSetStoredData;
class GmValueAccessor;
class GmSpatialIndex;
class GmNumSolver;
 
class GmNodeSet;
 
class UnitConverter;
 
class GMC_API_EXPORT GmFileIO : public GmGroupDumpItem
{
public:
  enum DumpMode
  {
    DISABLED,  
    DUMP,      
    RESTORE,   
  };
 
  enum DiscontinuityDataMode
  {
    NO_DISC_DATA,            
    ORIGINAL_DISC_DATA,      
    INTERSECTION_DISC_DATA,  
    BOTH_DISC_DATA,          
  };
 
  enum ExtraColumns {
    NODE_ID_COLUMN       = 0x001, 
    NODE_INTID_COLUMN    = 0x002, 
    CELL_ID_COLUMN       = 0x004, 
    CELL_INTID_COLUMN    = 0x008, 
    CELL_TYPE_COLUMN     = 0x010, 
    CELL_ACTIVE_COLUMN   = 0x020, 
    CELL_MATERIAL_COLUMN = 0x040, 
    GAUSS_ID_COLUMN      = 0x080, 
    NODE_BC_COLUMN       = 0x100, 
 
    // --- Combined options ---
    NODE_COLUMNS         = NODE_ID_COLUMN | NODE_INTID_COLUMN, 
    CELL_COLUMNS         = CELL_ID_COLUMN | CELL_INTID_COLUMN | CELL_TYPE_COLUMN | CELL_ACTIVE_COLUMN | CELL_MATERIAL_COLUMN,
    GAUSS_COLUMNS        = GAUSS_ID_COLUMN,
  };
 
  ~GmFileIO();
 
  static GmFileIO* createInstance(QString fileType, bool writeMode, const GmLogCategory& logger);
  static bool      acceptedFormat(QString fileType, bool writeMode);
 
  bool setNodeData (LuaTable& tab, GmMesh*        mesh, bool split);
  bool setCellData (LuaTable& tab, GmCellMesh*    mesh, bool split);
  bool setGaussData(LuaTable& tab, GmElementMesh* mesh, bool split);
 
  bool setNodeData (const QVector<const GmNodeAcResultsDataSrc*>&  data, GmMesh*        mesh, bool split);
  bool setCellData (const QVector<const GmCellAcResultsDataSrc*>&  data, GmCellMesh*    mesh, bool split);
  bool setGaussData(const QVector<const GmGaussAcResultsDataSrc*>& data, GmElementMesh* mesh, bool split);
 
  bool saveData(QString fileName, GmSimulationData* simData, GmMesh* mesh, const GmCellGroupSet* group, const QVariantMap& options);
                
  bool prepareForSaving(QString fileName, GmSimulationData* simData, GmMesh* mesh, const GmCellGroupSet* group, 
                        const QVariantMap& options, bool multipleTimeSteps = true);
 
  bool saveCurrentResult(double currentTime, bool meshChanged = false, bool discChanged = false);
  bool endWrite();
  bool closeFile();
 
  QString tempFile();
 
  virtual bool addStateItemsToGroup(GmStateDump* state, int groupId);
  virtual bool stateAboutToBeSaved (GmStateDump* state);
  virtual bool stateLoaded         (GmStateDump* state);
 
  static QString extraColumnName(ExtraColumns col, const GmCellMesh* mesh = NULL, int psIndex = -1);
 
private:
  GmFileIO(GmFileReader* reader, GmFileWriter* writer, const GmLogCategory& logger);
 
  Q_DISABLE_COPY(GmFileIO);
 
  template <class T, class Mesh, class DsF>
  bool setData(LuaTable& tab, Mesh* mesh, const DsF& dsF, QVector<T*>& dataList, const char* entity, bool split);
 
  template <class T, class Mesh>
  bool setData(const QVector<const T*>& data, Mesh* mesh, QVector<T*>& dataList, const char* entity, bool split);
 
  bool parseAndCheckDumpMode  (bool multipleTimeSteps);
  bool parseAndCheckStates    (bool multipleTimeSteps, int* state, bool* allStates, QVector<double>& timeList);
  bool parseAndCheckGaussRules(QVector<int>& rules);
  bool parseAndCheckGaussInterpolationOptions(GmSimulationData* simData);
  bool parseAndCheckCoordAccessor();
  bool parseAndCheckDiscontinuityOptions(const GmSimulationData* simData);
  bool parseAndCheckExtraColumnOptions(const GmSimulationData* simData);
  bool parseAndCheckTimeUnit(const GmSimulationData* simData, QString& timeUnit);
  bool checkDataForSaving(bool multipleTimeSteps);
  bool adjustAcStates    (int state);
  bool adjustAndCheckIds ();
 
  bool prepareNodeInterpolatedValues();
  bool prepareNodeBcValues();
 
  bool setCurrentTime(int iter, double time);
 
  bool savePrepare(QString fileName, GmSimulationData* simData, GmMesh* mesh, const GmCellGroupSet* group, 
                   const QVariantMap& options, bool multipleTimeSteps, QVector<double>& timeList);
 
  bool doSaveGeometry();
  bool doSaveDiscontinuities();
  bool doSaveData();
 
  void updateInterpData(); //In case mesh changes (added cells) we need to update interpolation data (cell groups and node sets)
 
  bool cleanup(bool deleteFiles = false);
 
  const GmLogCategory& _logger;    
  GmFileWriter*        _writer;    
  GmFileReader*        _reader;    
  GmFileFilter*        _filter;    
  QString              _fileName;  
  DumpMode             _dumpMode;  
 
  GmMesh*                           _mesh;      
  QVector<GmNodeAcResultsDataSrc*>  _nodeData;  
  QVector<GmCellAcResultsDataSrc*>  _cellData;  
  QVector<GmGaussAcResultsDataSrc*> _gaussData; 
 
  GmValueAccessor* _nodeAc;                  
  bool             _coordTransf;             
  double           _coordScaleFactor[3];     
  double           _coordOffset[3];          
  UnitConverter*   _timeConv;                
 
  bool         _openFiles;    
  int          _saveIter;     
  QVariantMap  _options;      
  int          _extraColumns; 
  QVector<int> _propertySets; 
  GmSimulationData* _simData;
 
  struct InternalVsData {
    GmValueInfo*            _info;  
    GmValueSetStoredData*   _vs;    
    GmNodeAcResultsDataSrc* _ds;    
 
    InternalVsData(GmValueInfo* info, GmValueSetStoredData* vs, GmNodeAcResultsDataSrc* ds) : _info(info), _vs(vs), _ds(ds) {}
    ~InternalVsData();
  private:
    Q_DISABLE_COPY(InternalVsData);
  };
 
  QVector<const GmBoundaryCondition*> _meshBcs;      
  InternalVsData*                     _nodeBcVsData; 
 
  enum InterpDataMode
  {
    ELEMENT_INT_MODE, 
    NODE_INT_MODE,    
    SPLINE_INT_MODE,  
    CLOUD_INT_MODE,   
  };
 
  struct InterpData {
    InterpDataMode           _mode;              
    bool                     _alsoSaveAtGauss;   
    GmInterpolatorType       _interpType;        
    QVariant                 _interpParam;       
    GmInterpolatorAveraging  _elemAvgMode;       
    bool                     _nodeClosest;       
    bool                     _searchModeRadius;  
    double                   _searchDomain;      
    const GmSpatialIndex*    _gaussIndex;        
    const GmSpatialIndex*    _interfaceGaussIndex;        
    const GmSpatialIndex*    _continuumGaussIndex;        
    const GmNumSolver*       _splineNumSolver;   
    double                   _alpha;             
    GmCellGroupSet*          _meshGroup;         
    int                      _interfaceGroupId;    
    int                      _continuumGroupId;    
    bool                     _hasIntSubset;      
    bool                     _hasContSubset;     
    const GmDiscontinuitySet* _discSet;
    QVector<InternalVsData*> _nodeVsData;        
        const GmNodeSet*         _meshNodeSet;       
        const GmNodeSet*         _interfaceNodeSet;  
        //const GmNodeSet*         _continuumNodeSet;  //!< The continuum node set used for interpolation
 
    InterpData();
    ~InterpData();
  private:
    Q_DISABLE_COPY(InterpData);
  };
 
  InterpData* _interpData; 
 
  QVector<GmDiscontinuitySet*> _dsList; 
  DiscontinuityDataMode        _dsMode; 
  UnitConverter*               _dsConv; 
 
  QVariantMap _stateMap;  
};
 
#endif