src/CONVERTOR/VISU_Structures.hxx

Go to the documentation of this file.

// Copyright (C) 2007-2011  CEA/DEN, EDF R&D, OPEN CASCADE
//
// Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//

//  File   : 
//  Author : Alexey PETROV
//  Module : VISU
//
#ifndef VISU_Structures_HeaderFile
#define VISU_Structures_HeaderFile

#include "VISUConvertor.hxx"
#include "VISU_IDMapper.hxx"
#include "VISU_ConvertorDef.hxx"

#include "MED_Vector.hxx"

#include <map>
#include <set>
#include <string>
#include <stdexcept>

namespace VISU
{
  using MED::TVector;

  //---------------------------------------------------------------
  typedef std::string TName;
  typedef TVector<TName> TNames;

  //---------------------------------------------------------------
  struct VISU_CONVERTOR_EXPORT TIntId: virtual TBaseStructure
  {
    vtkIdType myId;

    TIntId();
  };


  //---------------------------------------------------------------
  struct VISU_CONVERTOR_EXPORT TIsVTKDone: virtual TBaseStructure
  {
    mutable bool myIsDone; 
    mutable bool myIsVTKDone; 

    TIsVTKDone();
  };

  
  //---------------------------------------------------------------
  typedef std::map<TEntity, PMeshOnEntity> TMeshOnEntityMap;
  typedef std::map<TName, PGroup> TGroupMap;


  struct VISU_CONVERTOR_EXPORT TMesh: virtual TBaseStructure
  {
    TMeshOnEntityMap myMeshOnEntityMap; 
    TGroupMap myGroupMap; 
    TName myName; 
    vtkIdType myDim; 

    std::string myGroupsEntry; 
    std::string myFieldsEntry; 
    std::string myPartsEntry; 

    TMesh();
  };
  typedef std::map<std::string, PMesh> TMeshMap;


  //---------------------------------------------------------------
  struct VISU_CONVERTOR_EXPORT TSubProfile: virtual TBaseStructure
  {
    virtual 
    vtkIdType 
    GetElemObjID(vtkIdType theID) const = 0;

    virtual 
    vtkIdType 
    GetElemVTKID(vtkIdType theID) const = 0;
  };


  //---------------------------------------------------------------
  struct VISU_CONVERTOR_EXPORT TProfile: virtual TNamedIDMapper
  {};


  //---------------------------------------------------------------
  bool VISU_CONVERTOR_EXPORT
  operator<(const PSubProfile& theLeft, const PSubProfile& theRight);

  typedef std::set<PSubProfile> TProfileKey;
  typedef std::map<TProfileKey, PProfile> TProfileMap;


  //---------------------------------------------------------------
  struct VISU_CONVERTOR_EXPORT TGauss: virtual TBaseStructure
  {};


  //---------------------------------------------------------------
  struct VISU_CONVERTOR_EXPORT TGaussSubMesh: virtual TBaseStructure
  {
    PSubProfile mySubProfile; 
  };

  
  //---------------------------------------------------------------
  struct VISU_CONVERTOR_EXPORT TGaussMesh: virtual TGaussPtsIDMapper
  {};


  //---------------------------------------------------------------
  bool VISU_CONVERTOR_EXPORT
  operator<(const PGaussSubMesh& theLeft, const PGaussSubMesh& theRight);

  typedef std::set<PGaussSubMesh> TGaussKey;
  typedef std::map<TGaussKey, PGaussMesh> TGaussMeshMap;


  //---------------------------------------------------------------

  typedef std::map<TName, PFamily> TFamilyMap;
  typedef std::map<TName, PField> TFieldMap;

  typedef std::map<vtkIdType, PFamily> TFamilyIDMap;


  struct VISU_CONVERTOR_EXPORT TMeshOnEntity: virtual TNamedIDMapper
  {
    TGaussMeshMap myGaussMeshMap; 
    TProfileMap myProfileMap; 

    TFamilyMap myFamilyMap; 
    TFamilyIDMap myFamilyIDMap; 

    TFieldMap myFieldMap; 

    TName myMeshName; 
    TEntity myEntity; 

    TMeshOnEntity();
  };


  //---------------------------------------------------------------
  struct VISU_CONVERTOR_EXPORT TFamily: virtual TIntId,
                  virtual TUnstructuredGridIDMapper
  {
    TEntity myEntity; 
    TName myName; 

    TFamily();
  };


  //---------------------------------------------------------------
  bool VISU_CONVERTOR_EXPORT
  operator<(const PFamily& theLeft, const PFamily& theRight);

  typedef std::pair<TEntity, PFamily> TEnity2Family;
  typedef std::set<TEnity2Family> TFamilySet;

  struct VISU_CONVERTOR_EXPORT TGroup: virtual TUnstructuredGridIDMapper
  {
    TFamilySet myFamilySet;
  };


  //---------------------------------------------------------------
  typedef std::map<vtkIdType, PValForTime> TValField;
  typedef std::pair<vtkFloatingPointType, vtkFloatingPointType> TMinMax;

  struct VISU_CONVERTOR_EXPORT TField: virtual TIntId
  {
    TEntity myEntity; 
    TName myName; 
    TName myMeshName; 
    TValField myValField; 
    TNames myCompNames; 
    TNames myUnitNames; 
    vtkIdType myNbComp; 
    bool myIsELNO;      


    virtual
    TMinMax 
    GetMinMax(vtkIdType theCompID,
              const TNames& theGroupNames,
              TGaussMetric theGaussMetric = VISU::AVERAGE_METRIC) = 0;
    
    virtual
    TMinMax 
    GetAverageMinMax(vtkIdType theCompID,
                     const TNames& theGroupNames,
                     TGaussMetric theGaussMetric = VISU::AVERAGE_METRIC) = 0;

    bool myIsMinMaxInitilized; 

    TField();
  };

  // MULTIPR
  struct VISU_CONVERTOR_EXPORT TPart: virtual TIntId
  {
    vtkIdType myCurrentRes; 

    TPart();
  };


  //---------------------------------------------------------------
  typedef std::pair<double, std::string> TTime;

  struct VISU_CONVERTOR_EXPORT TValForTime: virtual TIntId
  {
    TEntity myEntity; 
    TName myMeshName; 
    TName myFieldName; 
    TTime myTime;

    PProfile myProfile; 
    PGaussMesh myGaussMesh;

    virtual
    int
    GetMaxNbGauss() const = 0;
  };
 

  //---------------------------------------------------------------
}


#endif