mirror of
https://git.salome-platform.org/gitpub/modules/smesh.git
synced 2024-12-24 16:30:34 +05:00
PAL10237. Add StdMeshers_AutomaticLength 1D hypothesis
This commit is contained in:
eap
parent
acf50ba8a3
commit
1f81f404ba
@ -48,7 +48,8 @@ EXPORT_HEADERS = \
|
||||
StdMeshers_Regular_1D.hxx \
|
||||
StdMeshers_Quadrangle_2D.hxx \
|
||||
StdMeshers_MEFISTO_2D.hxx \
|
||||
StdMeshers_Hexa_3D.hxx
|
||||
StdMeshers_Hexa_3D.hxx \
|
||||
StdMeshers_AutomaticLength.hxx
|
||||
|
||||
EXPORT_PYSCRIPTS =
|
||||
|
||||
@ -71,7 +72,8 @@ LIB_SRC = \
|
||||
StdMeshers_Quadrangle_2D.cxx \
|
||||
StdMeshers_MEFISTO_2D.cxx \
|
||||
StdMeshers_Penta_3D.cxx \
|
||||
StdMeshers_Hexa_3D.cxx
|
||||
StdMeshers_Hexa_3D.cxx \
|
||||
StdMeshers_AutomaticLength.cxx
|
||||
|
||||
LIB_SERVER_IDL =
|
||||
|
||||
|
||||
224
src/StdMeshers/StdMeshers_AutomaticLength.cxx
Normal file
224
src/StdMeshers/StdMeshers_AutomaticLength.cxx
Normal file
@ -0,0 +1,224 @@
|
||||
// SMESH SMESH : implementaion of SMESH idl descriptions
|
||||
//
|
||||
// Copyright (C) 2003 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
|
||||
//
|
||||
//
|
||||
//
|
||||
// File : StdMeshers_AutomaticLength.cxx
|
||||
// Author : Edward AGAPOV, OCC
|
||||
// Module : SMESH
|
||||
// $Header$
|
||||
|
||||
#include "StdMeshers_AutomaticLength.hxx"
|
||||
|
||||
#include "SMESH_Mesh.hxx"
|
||||
#include "SMESHDS_Mesh.hxx"
|
||||
#include "SMESH_Algo.hxx"
|
||||
|
||||
#include "utilities.h"
|
||||
|
||||
#include <TopTools_IndexedMapOfShape.hxx>
|
||||
#include <TopExp.hxx>
|
||||
#include <TopoDS.hxx>
|
||||
#include <TopoDS_Edge.hxx>
|
||||
|
||||
using namespace std;
|
||||
|
||||
//=============================================================================
|
||||
/*!
|
||||
*
|
||||
*/
|
||||
//=============================================================================
|
||||
|
||||
StdMeshers_AutomaticLength::StdMeshers_AutomaticLength(int hypId, int studyId,
|
||||
SMESH_Gen * gen):SMESH_Hypothesis(hypId, studyId, gen)
|
||||
{
|
||||
_name = "AutomaticLength";
|
||||
_param_algo_dim = 1; // is used by SMESH_Regular_1D
|
||||
|
||||
_mesh = 0;
|
||||
}
|
||||
|
||||
//=============================================================================
|
||||
/*!
|
||||
*
|
||||
*/
|
||||
//=============================================================================
|
||||
|
||||
StdMeshers_AutomaticLength::~StdMeshers_AutomaticLength()
|
||||
{
|
||||
}
|
||||
|
||||
//================================================================================
|
||||
/*!
|
||||
* \brief Return pointer to TopoDS_TShape
|
||||
* \param theShape - The TopoDS_Shape
|
||||
* \retval inline const TopoDS_TShape* - result
|
||||
*/
|
||||
//================================================================================
|
||||
|
||||
inline const TopoDS_TShape* getTShape(const TopoDS_Shape& theShape)
|
||||
{
|
||||
return theShape.TShape().operator->();
|
||||
}
|
||||
//================================================================================
|
||||
/*!
|
||||
* \brief Compute segment length for all edges
|
||||
* \param theMesh - The mesh
|
||||
* \param theTShapeToLengthMap - The map of edge to segment length
|
||||
*/
|
||||
//================================================================================
|
||||
|
||||
static void computeLengths( const SMESH_Mesh* theMesh,
|
||||
map<const TopoDS_TShape*, double> & theTShapeToLengthMap)
|
||||
{
|
||||
theTShapeToLengthMap.clear();
|
||||
|
||||
SMESHDS_Mesh* aMesh = const_cast< SMESH_Mesh* > ( theMesh )->GetMeshDS();
|
||||
TopoDS_Shape aMainShape = aMesh->ShapeToMesh();
|
||||
|
||||
// Find length of longest and shortest edge
|
||||
double Lmin = DBL_MAX, Lmax = -DBL_MAX;
|
||||
TopTools_IndexedMapOfShape edgeMap;
|
||||
TopExp::MapShapes( aMainShape, TopAbs_EDGE, edgeMap);
|
||||
for ( int i = 1; i <= edgeMap.Extent(); ++i )
|
||||
{
|
||||
TopoDS_Edge edge = TopoDS::Edge( edgeMap(i) );
|
||||
Standard_Real L = SMESH_Algo::EdgeLength( edge );
|
||||
if ( L > Lmax )
|
||||
Lmax = L;
|
||||
if ( L < Lmin )
|
||||
Lmin = L;
|
||||
// remember i-th edge length
|
||||
theTShapeToLengthMap.insert( theTShapeToLengthMap.end(),
|
||||
make_pair( getTShape( edge ), L ));
|
||||
}
|
||||
|
||||
// Compute S0
|
||||
|
||||
// image attached to PAL10237
|
||||
|
||||
// NbSeg
|
||||
// ^
|
||||
// |
|
||||
// 10|\
|
||||
// | \
|
||||
// | \
|
||||
// | \
|
||||
// 5| --------
|
||||
// |
|
||||
// +------------>
|
||||
// 1 10 Lmax/Lmin
|
||||
|
||||
const int NbSegMin = 5, NbSegMax = 10; // on axis NbSeg
|
||||
const double Lrat1 = 1., Lrat2 = 10.; // on axis Lmax/Lmin
|
||||
|
||||
double Lratio = Lmax/Lmin;
|
||||
double NbSeg = NbSegMin;
|
||||
if ( Lratio < Lrat2 )
|
||||
NbSeg += ( Lrat2 - Lratio ) / ( Lrat2 - Lrat1 ) * ( NbSegMax - NbSegMin );
|
||||
|
||||
double S0 = Lmin / (int) NbSeg;
|
||||
MESSAGE( "S0 = " << S0 << ", Lmin = " << Lmin << ", Nbseg = " << (int) NbSeg);
|
||||
|
||||
// Compute segments length for all edges
|
||||
|
||||
// S = S0 * f(L/Lmin) where f(x) = 1 + (2/Pi * 7 * atan(x/5) )
|
||||
// =>
|
||||
// S = S0 * ( 1 + 14/PI * atan( L / ( 5 * Lmin )))
|
||||
|
||||
const double a14divPI = 14. / PI, a5xLmin = 5 * Lmin;
|
||||
map<const TopoDS_TShape*, double>::iterator tshape_length = theTShapeToLengthMap.begin();
|
||||
for ( ; tshape_length != theTShapeToLengthMap.end(); ++tshape_length )
|
||||
{
|
||||
double & L = tshape_length->second;
|
||||
L = S0 * ( 1. + a14divPI * atan( L / a5xLmin ));
|
||||
}
|
||||
}
|
||||
|
||||
//=============================================================================
|
||||
/*!
|
||||
*
|
||||
*/
|
||||
//=============================================================================
|
||||
|
||||
double StdMeshers_AutomaticLength::GetLength(const SMESH_Mesh* theMesh,
|
||||
const TopoDS_Shape& anEdge)
|
||||
throw(SALOME_Exception)
|
||||
{
|
||||
if ( !theMesh ) throw SALOME_Exception(LOCALIZED("NULL Mesh"));
|
||||
|
||||
if ( anEdge.IsNull() || anEdge.ShapeType() != TopAbs_EDGE )
|
||||
throw SALOME_Exception(LOCALIZED("Bad edge shape"));
|
||||
|
||||
if ( theMesh != _mesh ) {
|
||||
computeLengths( theMesh, _TShapeToLength );
|
||||
_mesh = theMesh;
|
||||
}
|
||||
|
||||
map<const TopoDS_TShape*, double>::iterator tshape_length =
|
||||
_TShapeToLength.find( getTShape( anEdge ));
|
||||
ASSERT( tshape_length != _TShapeToLength.end() );
|
||||
return tshape_length->second;
|
||||
}
|
||||
|
||||
//=============================================================================
|
||||
/*!
|
||||
*
|
||||
*/
|
||||
//=============================================================================
|
||||
|
||||
ostream & StdMeshers_AutomaticLength::SaveTo(ostream & save)
|
||||
{
|
||||
return save;
|
||||
}
|
||||
|
||||
//=============================================================================
|
||||
/*!
|
||||
*
|
||||
*/
|
||||
//=============================================================================
|
||||
|
||||
istream & StdMeshers_AutomaticLength::LoadFrom(istream & load)
|
||||
{
|
||||
return load;
|
||||
}
|
||||
|
||||
//=============================================================================
|
||||
/*!
|
||||
*
|
||||
*/
|
||||
//=============================================================================
|
||||
|
||||
ostream & operator <<(ostream & save, StdMeshers_AutomaticLength & hyp)
|
||||
{
|
||||
return hyp.SaveTo( save );
|
||||
}
|
||||
|
||||
//=============================================================================
|
||||
/*!
|
||||
*
|
||||
*/
|
||||
//=============================================================================
|
||||
|
||||
istream & operator >>(istream & load, StdMeshers_AutomaticLength & hyp)
|
||||
{
|
||||
return hyp.LoadFrom( load );
|
||||
}
|
||||
67
src/StdMeshers/StdMeshers_AutomaticLength.hxx
Normal file
67
src/StdMeshers/StdMeshers_AutomaticLength.hxx
Normal file
@ -0,0 +1,67 @@
|
||||
// SMESH SMESH : implementaion of SMESH idl descriptions
|
||||
//
|
||||
// Copyright (C) 2003 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
|
||||
//
|
||||
//
|
||||
//
|
||||
// File : StdMeshers_AutomaticLength.hxx
|
||||
// Author : Edward AGAPOV, OCC
|
||||
// Module : SMESH
|
||||
// $Header$
|
||||
|
||||
#ifndef _SMESH_AutomaticLength_HXX_
|
||||
#define _SMESH_AutomaticLength_HXX_
|
||||
|
||||
#include "SMESH_Hypothesis.hxx"
|
||||
#include "Utils_SALOME_Exception.hxx"
|
||||
|
||||
#include <map>
|
||||
|
||||
class SMESH_Mesh;
|
||||
class TopoDS_Shape;
|
||||
class TopoDS_TShape;
|
||||
|
||||
/*!
|
||||
* \brief 1D Hypothesis to compute segment length free of thinking
|
||||
*
|
||||
* It computes segment length basing on max shape size to shortest edge length ratio:
|
||||
* S = S0 * f(L/Lmin) where f(x) = 1 + (2/Pi * 7 * atan(x/5) )
|
||||
*/
|
||||
|
||||
class StdMeshers_AutomaticLength:public SMESH_Hypothesis
|
||||
{
|
||||
public:
|
||||
StdMeshers_AutomaticLength(int hypId, int studyId, SMESH_Gen * gen);
|
||||
virtual ~ StdMeshers_AutomaticLength();
|
||||
|
||||
double GetLength(const SMESH_Mesh* aMesh, const TopoDS_Shape& anEdge)
|
||||
throw(SALOME_Exception);
|
||||
|
||||
virtual std::ostream & SaveTo(std::ostream & save);
|
||||
virtual std::istream & LoadFrom(std::istream & load);
|
||||
friend std::ostream & operator <<(std::ostream & save, StdMeshers_AutomaticLength & hyp);
|
||||
friend std::istream & operator >>(std::istream & load, StdMeshers_AutomaticLength & hyp);
|
||||
|
||||
protected:
|
||||
std::map<const TopoDS_TShape*, double> _TShapeToLength;
|
||||
const SMESH_Mesh* _mesh;
|
||||
};
|
||||
|
||||
#endif
|
||||
@ -38,6 +38,7 @@ using namespace std;
|
||||
#include "StdMeshers_Arithmetic1D.hxx"
|
||||
#include "StdMeshers_StartEndLength.hxx"
|
||||
#include "StdMeshers_Deflection1D.hxx"
|
||||
#include <StdMeshers_AutomaticLength.hxx>
|
||||
|
||||
#include "SMDS_MeshElement.hxx"
|
||||
#include "SMDS_MeshNode.hxx"
|
||||
@ -84,6 +85,7 @@ StdMeshers_Regular_1D::StdMeshers_Regular_1D(int hypId, int studyId,
|
||||
_compatibleHypothesis.push_back("StartEndLength");
|
||||
_compatibleHypothesis.push_back("Deflection1D");
|
||||
_compatibleHypothesis.push_back("Arithmetic1D");
|
||||
_compatibleHypothesis.push_back("AutomaticLength");
|
||||
}
|
||||
|
||||
//=============================================================================
|
||||
@ -198,6 +200,17 @@ bool StdMeshers_Regular_1D::CheckHypothesis
|
||||
_hypType = DEFLECTION;
|
||||
aStatus = SMESH_Hypothesis::HYP_OK;
|
||||
}
|
||||
|
||||
else if (hypName == "AutomaticLength")
|
||||
{
|
||||
StdMeshers_AutomaticLength * hyp = const_cast<StdMeshers_AutomaticLength *>
|
||||
(dynamic_cast <const StdMeshers_AutomaticLength * >(theHyp));
|
||||
ASSERT(hyp);
|
||||
_value[ BEG_LENGTH_IND ] = _value[ END_LENGTH_IND ] = hyp->GetLength( &aMesh, aShape );
|
||||
ASSERT( _value[ BEG_LENGTH_IND ] > 0 );
|
||||
_hypType = LOCAL_LENGTH;
|
||||
aStatus = SMESH_Hypothesis::HYP_OK;
|
||||
}
|
||||
else
|
||||
aStatus = SMESH_Hypothesis::HYP_INCOMPATIBLE;
|
||||
|
||||
|
||||
@ -50,7 +50,8 @@ EXPORT_HEADERS = \
|
||||
StdMeshers_Regular_1D_i.hxx \
|
||||
StdMeshers_Quadrangle_2D_i.hxx \
|
||||
StdMeshers_MEFISTO_2D_i.hxx \
|
||||
StdMeshers_Hexa_3D_i.hxx
|
||||
StdMeshers_Hexa_3D_i.hxx \
|
||||
StdMeshers_AutomaticLength_i.hxx
|
||||
|
||||
# Libraries targets
|
||||
|
||||
@ -71,7 +72,8 @@ LIB_SRC = \
|
||||
StdMeshers_Regular_1D_i.cxx \
|
||||
StdMeshers_Quadrangle_2D_i.cxx \
|
||||
StdMeshers_MEFISTO_2D_i.cxx \
|
||||
StdMeshers_Hexa_3D_i.cxx
|
||||
StdMeshers_Hexa_3D_i.cxx \
|
||||
StdMeshers_AutomaticLength_i.cxx
|
||||
|
||||
LIB_SERVER_IDL = SMESH_BasicHypothesis.idl
|
||||
|
||||
|
||||
143
src/StdMeshers_I/StdMeshers_AutomaticLength_i.cxx
Normal file
143
src/StdMeshers_I/StdMeshers_AutomaticLength_i.cxx
Normal file
@ -0,0 +1,143 @@
|
||||
// SMESH SMESH_I : idl implementation based on 'SMESH' unit's classes
|
||||
//
|
||||
// Copyright (C) 2003 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
|
||||
//
|
||||
//
|
||||
//
|
||||
// File : StdMeshers_AutomaticLength_i.cxx
|
||||
// Author : Edward AGAPOV
|
||||
// Module : SMESH
|
||||
// $Header$
|
||||
|
||||
using namespace std;
|
||||
#include "StdMeshers_AutomaticLength_i.hxx"
|
||||
#include "SMESH_Gen_i.hxx"
|
||||
#include "SMESH_Gen.hxx"
|
||||
|
||||
#include "Utils_CorbaException.hxx"
|
||||
#include "utilities.h"
|
||||
|
||||
#include <TCollection_AsciiString.hxx>
|
||||
|
||||
//=============================================================================
|
||||
/*!
|
||||
* StdMeshers_AutomaticLength_i::StdMeshers_AutomaticLength_i
|
||||
*
|
||||
* Constructor
|
||||
*/
|
||||
//=============================================================================
|
||||
|
||||
StdMeshers_AutomaticLength_i::StdMeshers_AutomaticLength_i( PortableServer::POA_ptr thePOA,
|
||||
int theStudyId,
|
||||
::SMESH_Gen* theGenImpl )
|
||||
: SALOME::GenericObj_i( thePOA ),
|
||||
SMESH_Hypothesis_i( thePOA )
|
||||
{
|
||||
MESSAGE( "StdMeshers_AutomaticLength_i::StdMeshers_AutomaticLength_i" );
|
||||
myBaseImpl = new ::StdMeshers_AutomaticLength( theGenImpl->GetANewId(),
|
||||
theStudyId,
|
||||
theGenImpl );
|
||||
}
|
||||
|
||||
//=============================================================================
|
||||
/*!
|
||||
* StdMeshers_AutomaticLength_i::~StdMeshers_AutomaticLength_i
|
||||
*
|
||||
* Destructor
|
||||
*/
|
||||
//=============================================================================
|
||||
|
||||
StdMeshers_AutomaticLength_i::~StdMeshers_AutomaticLength_i()
|
||||
{
|
||||
MESSAGE( "StdMeshers_AutomaticLength_i::~StdMeshers_AutomaticLength_i" );
|
||||
}
|
||||
|
||||
//=============================================================================
|
||||
/*!
|
||||
* StdMeshers_AutomaticLength_i::SetLength
|
||||
*
|
||||
* Set length
|
||||
*/
|
||||
//=============================================================================
|
||||
|
||||
// void StdMeshers_AutomaticLength_i::SetLength( CORBA::Double theLength )
|
||||
// throw ( SALOME::SALOME_Exception )
|
||||
// {
|
||||
// MESSAGE( "StdMeshers_AutomaticLength_i::SetLength" );
|
||||
// ASSERT( myBaseImpl );
|
||||
// try {
|
||||
// this->GetImpl()->SetLength( theLength );
|
||||
// }
|
||||
// catch ( SALOME_Exception& S_ex ) {
|
||||
// THROW_SALOME_CORBA_EXCEPTION( S_ex.what(),
|
||||
// SALOME::BAD_PARAM );
|
||||
// }
|
||||
|
||||
// // Update Python script
|
||||
// TCollection_AsciiString aStr, aStrLen ((double)theLength);
|
||||
// SMESH_Gen_i::AddObject(aStr, _this()) += ".SetLength(";
|
||||
// aStr += aStrLen + ")";
|
||||
|
||||
// SMESH_Gen_i::AddToCurrentPyScript(aStr);
|
||||
// }
|
||||
|
||||
//=============================================================================
|
||||
/*!
|
||||
* StdMeshers_AutomaticLength_i::GetLength
|
||||
*
|
||||
* Get length
|
||||
*/
|
||||
//=============================================================================
|
||||
|
||||
// CORBA::Double StdMeshers_AutomaticLength_i::GetLength()
|
||||
// {
|
||||
// MESSAGE( "StdMeshers_AutomaticLength_i::GetLength" );
|
||||
// ASSERT( myBaseImpl );
|
||||
// return this->GetImpl()->GetLength();
|
||||
// }
|
||||
|
||||
//=============================================================================
|
||||
/*!
|
||||
* StdMeshers_AutomaticLength_i::GetImpl
|
||||
*
|
||||
* Get implementation
|
||||
*/
|
||||
//=============================================================================
|
||||
|
||||
::StdMeshers_AutomaticLength* StdMeshers_AutomaticLength_i::GetImpl()
|
||||
{
|
||||
MESSAGE( "StdMeshers_AutomaticLength_i::GetImpl" );
|
||||
return ( ::StdMeshers_AutomaticLength* )myBaseImpl;
|
||||
}
|
||||
|
||||
//================================================================================
|
||||
/*!
|
||||
* \brief Verify whether hypothesis supports given entity type
|
||||
* \param type - dimension (see SMESH::Dimension enumeration)
|
||||
* \retval CORBA::Boolean - TRUE if dimension is supported, FALSE otherwise
|
||||
*
|
||||
* Verify whether hypothesis supports given entity type (see SMESH::Dimension enumeration)
|
||||
*/
|
||||
//================================================================================
|
||||
CORBA::Boolean StdMeshers_AutomaticLength_i::IsDimSupported( SMESH::Dimension type )
|
||||
{
|
||||
return type == SMESH::DIM_1D;
|
||||
}
|
||||
|
||||
69
src/StdMeshers_I/StdMeshers_AutomaticLength_i.hxx
Normal file
69
src/StdMeshers_I/StdMeshers_AutomaticLength_i.hxx
Normal file
@ -0,0 +1,69 @@
|
||||
// SMESH SMESH_I : idl implementation based on 'SMESH' unit's calsses
|
||||
//
|
||||
// Copyright (C) 2003 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
|
||||
//
|
||||
//
|
||||
//
|
||||
// File : StdMeshers_AutomaticLength_i.hxx
|
||||
// Author : Edward AGAPOV
|
||||
// Module : SMESH
|
||||
// $Header$
|
||||
|
||||
#ifndef _SMESH_AutomaticLength_I_HXX_
|
||||
#define _SMESH_AutomaticLength_I_HXX_
|
||||
|
||||
#include <SALOMEconfig.h>
|
||||
#include CORBA_SERVER_HEADER(SMESH_BasicHypothesis)
|
||||
|
||||
#include "SMESH_Hypothesis_i.hxx"
|
||||
#include "StdMeshers_AutomaticLength.hxx"
|
||||
|
||||
class SMESH_Gen;
|
||||
|
||||
// ======================================================
|
||||
// Local Length hypothesis
|
||||
// ======================================================
|
||||
class StdMeshers_AutomaticLength_i:
|
||||
public virtual POA_StdMeshers::StdMeshers_AutomaticLength,
|
||||
public virtual SMESH_Hypothesis_i
|
||||
{
|
||||
public:
|
||||
// Constructor
|
||||
StdMeshers_AutomaticLength_i( PortableServer::POA_ptr thePOA,
|
||||
int theStudyId,
|
||||
::SMESH_Gen* theGenImpl );
|
||||
// Destructor
|
||||
virtual ~StdMeshers_AutomaticLength_i();
|
||||
|
||||
// // Set length
|
||||
// void SetLength( CORBA::Double theLength )
|
||||
// throw ( SALOME::SALOME_Exception );
|
||||
// // Get length
|
||||
// CORBA::Double GetLength();
|
||||
|
||||
// Get implementation
|
||||
::StdMeshers_AutomaticLength* GetImpl();
|
||||
|
||||
// Verify whether hypothesis supports given entity type
|
||||
CORBA::Boolean IsDimSupported( SMESH::Dimension type );
|
||||
};
|
||||
|
||||
#endif
|
||||
|
||||
@ -31,6 +31,7 @@ using namespace std;
|
||||
#include "utilities.h"
|
||||
|
||||
#include "StdMeshers_LocalLength_i.hxx"
|
||||
#include "StdMeshers_AutomaticLength_i.hxx"
|
||||
#include "StdMeshers_StartEndLength_i.hxx"
|
||||
#include "StdMeshers_Arithmetic1D_i.hxx"
|
||||
#include "StdMeshers_NumberOfSegments_i.hxx"
|
||||
@ -81,6 +82,8 @@ extern "C"
|
||||
aCreator = new HypothesisCreator_i<StdMeshers_Deflection1D_i>;
|
||||
else if (strcmp(aHypName, "Arithmetic1D") == 0)
|
||||
aCreator = new HypothesisCreator_i<StdMeshers_Arithmetic1D_i>;
|
||||
else if (strcmp(aHypName, "AutomaticLength") == 0)
|
||||
aCreator = new HypothesisCreator_i<StdMeshers_AutomaticLength_i>;
|
||||
|
||||
// Algorithms
|
||||
else if (strcmp(aHypName, "Regular_1D") == 0)
|
||||
|
||||
Loading…
Reference in New Issue
Block a user