Version: 6.3.1
Public Types | Public Member Functions | Static Public Member Functions | Protected Attributes

StdMeshers_ImportSource2D Class Reference

Redefines name and dimension of inherited StdMeshers_ImportSource1D. More...

#include <StdMeshers_ImportSource.hxx>

Inheritance diagram for StdMeshers_ImportSource2D:
Inheritance graph
[legend]

Public Types

enum  Hypothesis_Status {
  HYP_OK = 0, HYP_MISSING, HYP_CONCURENT, HYP_BAD_PARAMETER,
  HYP_HIDDEN_ALGO, HYP_HIDING_ALGO, HYP_UNKNOWN_FATAL, HYP_INCOMPATIBLE,
  HYP_NOTCONFORM, HYP_ALREADY_EXIST, HYP_BAD_DIM, HYP_BAD_SUBSHAPE,
  HYP_BAD_GEOMETRY, HYP_NEED_SHAPE
}
enum  hypothesis_type {
  PARAM_ALGO, ALGO_0D, ALGO_1D, ALGO_2D,
  ALGO_3D
}

Public Member Functions

 StdMeshers_ImportSource2D (int hypId, int studyId, SMESH_Gen *gen)
 Creates StdMeshers_ImportSource2D.
void SetGroups (const std::vector< SMESH_Group * > &groups)
 Sets groups to import elements from.
const std::vector< SMESH_Group * > & GetGroups () const
void SetCopySourceMesh (bool toCopyMesh, bool toCopyGroups)
void GetCopySourceMesh (bool &toCopyMesh, bool &toCopyGroups) const
virtual std::ostream & SaveTo (std::ostream &save)
virtual std::istream & LoadFrom (std::istream &load)
virtual bool SetParametersByMesh (const SMESH_Mesh *theMesh, const TopoDS_Shape &theShape)
 Initialize my parameter values by the mesh built on the geometry.
virtual bool SetParametersByDefaults (const TDefaults &dflts, const SMESH_Mesh *theMesh=0)
 Initialize my parameter values by default parameters.
void RestoreGroups (const std::vector< SMESH_Group * > &groups)
 Restore source groups and result groups by _resultGroupsStorage.
void StoreResultGroups (const std::vector< SMESH_Group * > &groups, const SMESHDS_Mesh &srcMesh, const SMESHDS_Mesh &tgtMesh)
 Remember groups imported from other mesh.
std::vector< SMESH_Group * > * GetResultGroups (const SMESHDS_Mesh &srcMesh, const SMESHDS_Mesh &tgtMesh)
 Return groups imported from other mesh.
std::vector< SMESH_Mesh * > GetSourceMeshes () const
 Return source meshes.
virtual int GetDim () const
int GetStudyId () const
virtual void NotifySubMeshesHypothesisModification ()
virtual int GetShapeType () const
virtual const char * GetLibName () const
void SetLibName (const char *theLibName)
void SetParameters (const char *theParameters)
char * GetParameters () const
void SetLastParameters (const char *theParameters)
char * GetLastParameters () const
void ClearParameters ()
virtual bool IsAuxiliary () const
 Return true if me is an auxiliary hypothesis.
SMESH_Mesh * GetMeshByPersistentID (int id)
 Find a mesh with given persistent ID.
const char * GetName () const
int GetID () const
int GetType () const
virtual bool operator== (const SMESHDS_Hypothesis &other) const
 Equality.
bool operator!= (const SMESHDS_Hypothesis &other) const

Static Public Member Functions

static bool IsStatusFatal (Hypothesis_Status theStatus)

Protected Attributes

SMESH_Gen * _gen
int _studyId
int _shapeType
int _param_algo_dim
std::string _name
int _hypId
int _type

Detailed Description

Redefines name and dimension of inherited StdMeshers_ImportSource1D.

Definition at line 92 of file StdMeshers_ImportSource.hxx.

Member Enumeration Documentation

enum SMESH_Hypothesis::Hypothesis_Status [inherited]
Enumerator:
HYP_OK 
HYP_MISSING 
HYP_CONCURENT 
HYP_BAD_PARAMETER 
HYP_HIDDEN_ALGO 
HYP_HIDING_ALGO 
HYP_UNKNOWN_FATAL 
HYP_INCOMPATIBLE 
HYP_NOTCONFORM 
HYP_ALREADY_EXIST 
HYP_BAD_DIM 
HYP_BAD_SUBSHAPE 
HYP_BAD_GEOMETRY 
HYP_NEED_SHAPE 

Definition at line 50 of file SMESH_Hypothesis.hxx.

  {
    HYP_OK = 0,
    HYP_MISSING,      // algo misses a hypothesis
    HYP_CONCURENT,    // several applicable hypotheses
    HYP_BAD_PARAMETER,// hypothesis has a bad parameter value
    HYP_HIDDEN_ALGO,  // an algo is hidden by an upper dim algo generating all-dim elements
    HYP_HIDING_ALGO,  // an algo hides lower dim algos by generating all-dim elements
    HYP_UNKNOWN_FATAL,//  --- all statuses below should be considered as fatal
                      //      for Add/RemoveHypothesis operations
    HYP_INCOMPATIBLE, // hypothesis does not fit algo
    HYP_NOTCONFORM,   // not conform mesh is produced appling a hypothesis
    HYP_ALREADY_EXIST,// such hypothesis already exist
    HYP_BAD_DIM,      // bad dimension
    HYP_BAD_SUBSHAPE, // shape is neither the main one, nor its subshape, nor a group
    HYP_BAD_GEOMETRY, // shape geometry mismatches algorithm's expectation
    HYP_NEED_SHAPE    // algorithm can work on shape only
  };
enum SMESHDS_Hypothesis::hypothesis_type [inherited]
Enumerator:
PARAM_ALGO 
ALGO_0D 
ALGO_1D 
ALGO_2D 
ALGO_3D 

Definition at line 53 of file SMESHDS_Hypothesis.hxx.

{PARAM_ALGO, ALGO_0D, ALGO_1D, ALGO_2D, ALGO_3D};

Constructor & Destructor Documentation

StdMeshers_ImportSource2D::StdMeshers_ImportSource2D ( int  hypId,
int  studyId,
SMESH_Gen *  gen 
)

Creates StdMeshers_ImportSource2D.

Definition at line 68 of file StdMeshers_ImportSource.cxx.

References SMESHDS_Hypothesis._name, and SMESH_Hypothesis._param_algo_dim.

  :StdMeshers_ImportSource1D(hypId, studyId, gen)
{
  _name = "ImportSource2D";
  _param_algo_dim = 2; // is used by StdMeshers_Import_2D;
}

Member Function Documentation

void SMESH_Hypothesis.ClearParameters ( ) [inherited]
void StdMeshers_ImportSource1D.GetCopySourceMesh ( bool &  toCopyMesh,
bool &  toCopyGroups 
) const [inherited]
int SMESH_Hypothesis::GetDim ( ) const [virtual, inherited]

Definition at line 74 of file SMESH_Hypothesis.cxx.

{
  int dim = 0;
  switch (_type)
    {
    case ALGO_1D: dim = 1; break;
    case ALGO_2D: dim = 2; break;
    case ALGO_3D: dim = 3; break;
    case PARAM_ALGO:
      dim = ( _param_algo_dim < 0 ) ? -_param_algo_dim : _param_algo_dim; break;
    }
  return dim;
}
const std::vector<SMESH_Group*>& StdMeshers_ImportSource1D.GetGroups ( ) const [inherited]
int SMESHDS_Hypothesis::GetID ( ) const [inherited]

Definition at line 73 of file SMESHDS_Hypothesis.cxx.

Referenced by SMESHDS_Document.AddHypothesis(), and SMESH_Mesh_i.GetHypothesisList().

{
  return _hypId;
}
char* SMESH_Hypothesis.GetLastParameters ( ) const [inherited]
virtual const char* SMESH_Hypothesis.GetLibName ( ) const [virtual, inherited]
SMESH_Mesh * SMESH_Hypothesis::GetMeshByPersistentID ( int  id) [inherited]

Find a mesh with given persistent ID.

Definition at line 160 of file SMESH_Hypothesis.cxx.

References studyContextStruct.mapMesh, and PAL_MESH_041_mesh.mesh.

{
  StudyContextStruct* myStudyContext = _gen->GetStudyContext(_studyId);
  map<int, SMESH_Mesh*>::iterator itm = itm = myStudyContext->mapMesh.begin();
  for ( ; itm != myStudyContext->mapMesh.end(); itm++)
  {
    SMESH_Mesh* mesh = (*itm).second;
    if ( mesh->GetMeshDS()->GetPersistentId() == id )
      return mesh;
  }
  return 0;
}
const char * SMESHDS_Hypothesis::GetName ( ) const [inherited]

Definition at line 62 of file SMESHDS_Hypothesis.cxx.

Referenced by SMESH_DimHyp.checkAlgo(), StdMeshers_Quadrangle_2D.CheckHypothesis(), and StdMeshers_Projection_3D.CheckHypothesis().

{
  return _name.c_str();
}
char* SMESH_Hypothesis.GetParameters ( ) const [inherited]
std::vector< SMESH_Group * > * StdMeshers_ImportSource1D::GetResultGroups ( const SMESHDS_Mesh &  srcMesh,
const SMESHDS_Mesh &  tgtMesh 
) [inherited]

Return groups imported from other mesh.

Parameters:
srcMesh- source mesh
tgtMesh- destination mesh
Return values:
conststd.vector<SMESH_Group*>& - groups

Definition at line 405 of file StdMeshers_ImportSource.cxx.

{
  TResGroupMap::iterator key2groups = _resultGroups.find( getResMapKey(srcMesh,tgtMesh ));
  if ( key2groups == _resultGroups.end() )
    return 0;
  vector<SMESH_Group*> vec = getValidGroups((*key2groups).second,
                                            _gen->GetStudyContext(_studyId) );
  if ( vec.size() != key2groups->second.size())
    key2groups->second = vec;

  return & key2groups->second;
}
int SMESH_Hypothesis::GetShapeType ( ) const [virtual, inherited]

Definition at line 94 of file SMESH_Hypothesis.cxx.

{
  return _shapeType;
}
std::vector< SMESH_Mesh * > StdMeshers_ImportSource1D::GetSourceMeshes ( ) const [inherited]

Return source meshes.

Definition at line 216 of file StdMeshers_ImportSource.cxx.

References SMESHDS_GroupBase.GetMesh(), SMESHDS_Mesh.GetPersistentId(), studyContextStruct.mapMesh, and PAL_MESH_041_mesh.mesh.

{
  // GetPersistentId()'s of meshes
  set<int> meshIDs;
  const vector<SMESH_Group*>& groups = GetGroups();
  if ( !groups.empty() )
  {
    for ( unsigned i = 0; i < groups.size(); ++i )
    {
      const SMESHDS_GroupBase* gDS = groups[i]->GetGroupDS();
      int id = gDS->GetMesh()->GetPersistentId();
      meshIDs.insert( id );
    }
  }
  else
  {
    if ( _resultGroups.empty() )
      ((StdMeshers_ImportSource1D*)this)->RestoreGroups(_groups);
    TResGroupMap::const_iterator key_groups = _resultGroups.begin();
    for ( ; key_groups != _resultGroups.end(); ++key_groups )
      meshIDs.insert( getSrcMeshID( key_groups->first ));
  }

  // Find corresponding meshes
  vector<SMESH_Mesh*> meshes;
  if ( !meshIDs.empty() )
  {
    StudyContextStruct* studyContext = _gen->GetStudyContext(_studyId);
    for ( set<int>::iterator id = meshIDs.begin(); id != meshIDs.end(); ++id )
    {
      map<int, SMESH_Mesh*>::iterator itm = itm = studyContext->mapMesh.begin();
      for ( ; itm != studyContext->mapMesh.end(); itm++)
      {
        SMESH_Mesh* mesh = (*itm).second;
        if ( mesh->GetMeshDS()->GetPersistentId() == *id )
        {
          meshes.push_back( mesh );
          break;
        }
      }
    }
  }
  return meshes;
}
int SMESH_Hypothesis.GetStudyId ( ) const [inherited]
int SMESHDS_Hypothesis::GetType ( ) const [inherited]

Definition at line 84 of file SMESHDS_Hypothesis.cxx.

Referenced by SMESH_DimHyp.checkAlgo(), checkConformIgnoredAlgos(), SMESH_Hypothesis.IsAuxiliary(), and SMESH_Mesh.IsUsedHypothesis().

{
  return _type;
}
virtual bool SMESH_Hypothesis.IsAuxiliary ( ) const [virtual, inherited]

Return true if me is an auxiliary hypothesis.

Return values:
bool- auxiliary or not

An auxiliary hypothesis is optional, i.e. an algorithm can work without it and another hypothesis of the same dimention can be assigned to the shape

Definition at line 114 of file SMESH_Hypothesis.hxx.

References SMESHDS_Hypothesis.GetType().

  { return GetType() == PARAM_ALGO && _param_algo_dim < 0; }
static bool SMESH_Hypothesis.IsStatusFatal ( Hypothesis_Status  theStatus) [static, inherited]

Definition at line 68 of file SMESH_Hypothesis.hxx.

References SMESH.HYP_UNKNOWN_FATAL.

Referenced by SMESH_Mesh_i.addHypothesis(), SMESH_Mesh_i.AddHypothesis(), SMESH_Mesh.AddHypothesis(), SMESH_subMesh.AlgoStateEngine(), SMESH_Mesh_i.RemoveHypothesis(), and SMESH_Mesh.RemoveHypothesis().

  { return theStatus >= HYP_UNKNOWN_FATAL; }
virtual std::istream& StdMeshers_ImportSource1D.LoadFrom ( std::istream &  load) [virtual, inherited]

Implements SMESHDS_Hypothesis.

virtual void SMESH_Hypothesis.NotifySubMeshesHypothesisModification ( ) [virtual, inherited]

Referenced by StdMeshers_NumberOfSegments.SetReversedEdges(), StdMeshers_FixedPoints1D.SetReversedEdges(), StdMeshers_Arithmetic1D.SetReversedEdges(), and StdMeshers_ProjectionSource2D.SetSourceMesh().

bool SMESHDS_Hypothesis.operator!= ( const SMESHDS_Hypothesis &  other) const [inherited]

Definition at line 51 of file SMESHDS_Hypothesis.hxx.

{ return !(*this==other); }
bool SMESHDS_Hypothesis::operator== ( const SMESHDS_Hypothesis &  other) const [virtual, inherited]

Equality.

Definition at line 95 of file SMESHDS_Hypothesis.cxx.

References SMESHDS_Hypothesis._name.

{
  if ( this == &other )
    return true;
  if ( _name != other._name )
    return false;
  ostringstream mySave, otherSave;
  ((SMESHDS_Hypothesis*)this  )->SaveTo(mySave);
  ((SMESHDS_Hypothesis*)&other)->SaveTo(otherSave);
  return mySave.str() == otherSave.str();
}
void StdMeshers_ImportSource1D::RestoreGroups ( const std::vector< SMESH_Group * > &  groups) [inherited]

Restore source groups and result groups by _resultGroupsStorage.

Definition at line 338 of file StdMeshers_ImportSource.cxx.

References ex21_lamp.group, and PAL_MESH_041_mesh.mesh.

{
  _groups = groups;

  _resultGroups.clear();
  int i = 0;
  while ( i < _resultGroupsStorage.size() )
  {
    int key1 = _resultGroupsStorage[i++];
    int key2 = _resultGroupsStorage[i++];
    pair<int, int> resMapKey( key1, key2 );
    SMESH_Mesh* mesh = getTgtMeshByKey( resMapKey, _gen->GetStudyContext(_studyId));
    // restore mesh ids at least
    _resultGroups.insert( make_pair (resMapKey,vector<SMESH_Group*>() )); 

    int nbGroups = _resultGroupsStorage[i++];
    for ( int j = 0; j < nbGroups; ++j )
    {
      string::size_type nameSize = _resultGroupsStorage[i++];
      string groupName(nameSize, '\0');
      for ( unsigned k = 0; k < nameSize; ++k )
        groupName[k] = (char) _resultGroupsStorage[i++];

      // find a group by name
      if ( mesh )
      {
        SMESH_Group* group = 0;
        SMESH_Mesh::GroupIteratorPtr gIt = mesh->GetGroups();
        while ( !group && gIt->more() )
        {
          group = gIt->next();
          if ( !group->GetGroupDS() || groupName != group->GetGroupDS()->GetStoreName() )
            group = 0;
        }
        if ( group )
          _resultGroups[ resMapKey ].push_back( group );
      }
    }
  }
}
virtual std::ostream& StdMeshers_ImportSource1D.SaveTo ( std::ostream &  save) [virtual, inherited]

Implements SMESHDS_Hypothesis.

void StdMeshers_ImportSource1D::SetCopySourceMesh ( bool  toCopyMesh,
bool  toCopyGroups 
) [inherited]

Definition at line 101 of file StdMeshers_ImportSource.cxx.

{
  if ( !toCopyMesh ) toCopyGroups = false;
  if ( _toCopyMesh != toCopyMesh || _toCopyGroups != toCopyGroups )
  {
    _toCopyMesh = toCopyMesh; _toCopyGroups = toCopyGroups;
    NotifySubMeshesHypothesisModification();
  }
}
void StdMeshers_ImportSource1D::SetGroups ( const std::vector< SMESH_Group * > &  groups) [inherited]

Sets groups to import elements from.

Definition at line 92 of file StdMeshers_ImportSource.cxx.

{
  if (_groups != groups)
  {
    _groups = groups;
    NotifySubMeshesHypothesisModification();
  }
}
void SMESH_Hypothesis::SetLastParameters ( const char *  theParameters) [inherited]

Definition at line 224 of file SMESH_Hypothesis.cxx.

{
  _lastParameters = string(theParameters);
}
void SMESH_Hypothesis.SetLibName ( const char *  theLibName) [inherited]
void SMESH_Hypothesis::SetParameters ( const char *  theParameters) [inherited]

Definition at line 178 of file SMESH_Hypothesis.cxx.

{
  string aNewParameters(theParameters);
  if(aNewParameters.size()==0 && _parameters.size()==0)
    aNewParameters = " ";
  if(_parameters.size()>0)
    _parameters +="|";
  _parameters +=aNewParameters;
  SetLastParameters(theParameters);
}
virtual bool StdMeshers_ImportSource1D.SetParametersByDefaults ( const TDefaults &  dflts,
const SMESH_Mesh *  theMesh = 0 
) [virtual, inherited]

Initialize my parameter values by default parameters.

Return values:
bool- true if parameter values have been successfully defined

Implements SMESH_Hypothesis.

virtual bool StdMeshers_ImportSource1D.SetParametersByMesh ( const SMESH_Mesh *  theMesh,
const TopoDS_Shape &  theShape 
) [virtual, inherited]

Initialize my parameter values by the mesh built on the geometry.

Parameters:
theMesh- the built mesh
theShape- the geometry of interest
Return values:
bool- true if parameter values have been successfully defined

Implements SMESH_Hypothesis.

void StdMeshers_ImportSource1D::StoreResultGroups ( const std::vector< SMESH_Group * > &  groups,
const SMESHDS_Mesh &  srcMesh,
const SMESHDS_Mesh &  tgtMesh 
) [inherited]

Remember groups imported from other mesh.

Parameters:
groups- result groups
srcMesh- source mesh
tgtMesh- destination mesh

Definition at line 388 of file StdMeshers_ImportSource.cxx.

{
  _resultGroups[ getResMapKey(srcMesh,tgtMesh) ] = groups;
}

Field Documentation

SMESH_Gen* SMESH_Hypothesis._gen [protected, inherited]

Definition at line 123 of file SMESH_Hypothesis.hxx.

Referenced by SMESH_Hypothesis.SMESH_Hypothesis().

int SMESHDS_Hypothesis._hypId [protected, inherited]

Definition at line 57 of file SMESHDS_Hypothesis.hxx.

Referenced by SMESH_Hypothesis.SMESH_Hypothesis().

std::string SMESHDS_Hypothesis._name [protected, inherited]

Definition at line 56 of file SMESHDS_Hypothesis.hxx.

Referenced by SMESHDS_Hypothesis.operator==(), StdMeshers_Arithmetic1D.StdMeshers_Arithmetic1D(), StdMeshers_AutomaticLength.StdMeshers_AutomaticLength(), StdMeshers_Deflection1D.StdMeshers_Deflection1D(), StdMeshers_FixedPoints1D.StdMeshers_FixedPoints1D(), StdMeshers_ImportSource1D.StdMeshers_ImportSource1D(), StdMeshers_ImportSource2D(), StdMeshers_LayerDistribution.StdMeshers_LayerDistribution(), StdMeshers_LayerDistribution2D.StdMeshers_LayerDistribution2D(), StdMeshers_LengthFromEdges.StdMeshers_LengthFromEdges(), StdMeshers_LocalLength.StdMeshers_LocalLength(), StdMeshers_MaxElementArea.StdMeshers_MaxElementArea(), StdMeshers_MaxElementVolume.StdMeshers_MaxElementVolume(), StdMeshers_MaxLength.StdMeshers_MaxLength(), StdMeshers_NotConformAllowed.StdMeshers_NotConformAllowed(), StdMeshers_NumberOfLayers.StdMeshers_NumberOfLayers(), StdMeshers_NumberOfLayers2D.StdMeshers_NumberOfLayers2D(), StdMeshers_NumberOfSegments.StdMeshers_NumberOfSegments(), StdMeshers_ProjectionSource1D.StdMeshers_ProjectionSource1D(), StdMeshers_ProjectionSource2D.StdMeshers_ProjectionSource2D(), StdMeshers_ProjectionSource3D.StdMeshers_ProjectionSource3D(), StdMeshers_Propagation.StdMeshers_Propagation(), StdMeshers_QuadrangleParams.StdMeshers_QuadrangleParams(), StdMeshers_QuadranglePreference.StdMeshers_QuadranglePreference(), StdMeshers_QuadraticMesh.StdMeshers_QuadraticMesh(), StdMeshers_StartEndLength.StdMeshers_StartEndLength(), StdMeshers_TrianglePreference.StdMeshers_TrianglePreference(), and StdMeshers_ViscousLayers.StdMeshers_ViscousLayers().

int SMESH_Hypothesis._param_algo_dim [protected, inherited]

Definition at line 126 of file SMESH_Hypothesis.hxx.

Referenced by SMESH_Hypothesis.SMESH_Hypothesis(), StdMeshers_Arithmetic1D.StdMeshers_Arithmetic1D(), StdMeshers_AutomaticLength.StdMeshers_AutomaticLength(), StdMeshers_Deflection1D.StdMeshers_Deflection1D(), StdMeshers_FixedPoints1D.StdMeshers_FixedPoints1D(), StdMeshers_ImportSource1D.StdMeshers_ImportSource1D(), StdMeshers_ImportSource2D(), StdMeshers_LayerDistribution.StdMeshers_LayerDistribution(), StdMeshers_LayerDistribution2D.StdMeshers_LayerDistribution2D(), StdMeshers_LengthFromEdges.StdMeshers_LengthFromEdges(), StdMeshers_LocalLength.StdMeshers_LocalLength(), StdMeshers_MaxElementArea.StdMeshers_MaxElementArea(), StdMeshers_MaxElementVolume.StdMeshers_MaxElementVolume(), StdMeshers_MaxLength.StdMeshers_MaxLength(), StdMeshers_NotConformAllowed.StdMeshers_NotConformAllowed(), StdMeshers_NumberOfLayers.StdMeshers_NumberOfLayers(), StdMeshers_NumberOfLayers2D.StdMeshers_NumberOfLayers2D(), StdMeshers_NumberOfSegments.StdMeshers_NumberOfSegments(), StdMeshers_ProjectionSource1D.StdMeshers_ProjectionSource1D(), StdMeshers_ProjectionSource2D.StdMeshers_ProjectionSource2D(), StdMeshers_ProjectionSource3D.StdMeshers_ProjectionSource3D(), StdMeshers_Propagation.StdMeshers_Propagation(), StdMeshers_QuadrangleParams.StdMeshers_QuadrangleParams(), StdMeshers_QuadranglePreference.StdMeshers_QuadranglePreference(), StdMeshers_QuadraticMesh.StdMeshers_QuadraticMesh(), StdMeshers_StartEndLength.StdMeshers_StartEndLength(), StdMeshers_TrianglePreference.StdMeshers_TrianglePreference(), and StdMeshers_ViscousLayers.StdMeshers_ViscousLayers().

int SMESH_Hypothesis._shapeType [protected, inherited]

Definition at line 125 of file SMESH_Hypothesis.hxx.

Referenced by SMESH_Hypothesis.SMESH_Hypothesis().

int SMESH_Hypothesis._studyId [protected, inherited]

Definition at line 124 of file SMESH_Hypothesis.hxx.

Referenced by SMESH_Hypothesis.SMESH_Hypothesis().

int SMESHDS_Hypothesis._type [protected, inherited]

Definition at line 58 of file SMESHDS_Hypothesis.hxx.

Referenced by SMESH_Hypothesis.SMESH_Hypothesis().

Copyright © 2007-2011 CEA/DEN, EDF R&D, OPEN CASCADE
Copyright © 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN, CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS