Salome HOME
PAL10237. Add StdMeshers_AutomaticLength 1D hypothesis
authoreap <eap@opencascade.com>
Tue, 1 Nov 2005 10:07:11 +0000 (10:07 +0000)
committereap <eap@opencascade.com>
Tue, 1 Nov 2005 10:07:11 +0000 (10:07 +0000)
src/StdMeshers/Makefile.in
src/StdMeshers/StdMeshers_AutomaticLength.cxx [new file with mode: 0644]
src/StdMeshers/StdMeshers_AutomaticLength.hxx [new file with mode: 0644]
src/StdMeshers/StdMeshers_Regular_1D.cxx
src/StdMeshers_I/Makefile.in
src/StdMeshers_I/StdMeshers_AutomaticLength_i.cxx [new file with mode: 0644]
src/StdMeshers_I/StdMeshers_AutomaticLength_i.hxx [new file with mode: 0644]
src/StdMeshers_I/StdMeshers_i.cxx

index 88661b5..762fbf7 100644 (file)
@@ -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 = 
 
diff --git a/src/StdMeshers/StdMeshers_AutomaticLength.cxx b/src/StdMeshers/StdMeshers_AutomaticLength.cxx
new file mode 100644 (file)
index 0000000..36ae6be
--- /dev/null
@@ -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 );
+}
diff --git a/src/StdMeshers/StdMeshers_AutomaticLength.hxx b/src/StdMeshers/StdMeshers_AutomaticLength.hxx
new file mode 100644 (file)
index 0000000..b4d9c83
--- /dev/null
@@ -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
index a24abbb..2bdf91d 100644 (file)
@@ -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;
 
index 6b50f0c..3f24a08 100644 (file)
@@ -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
 
diff --git a/src/StdMeshers_I/StdMeshers_AutomaticLength_i.cxx b/src/StdMeshers_I/StdMeshers_AutomaticLength_i.cxx
new file mode 100644 (file)
index 0000000..5af0952
--- /dev/null
@@ -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;
+}
+
diff --git a/src/StdMeshers_I/StdMeshers_AutomaticLength_i.hxx b/src/StdMeshers_I/StdMeshers_AutomaticLength_i.hxx
new file mode 100644 (file)
index 0000000..f7f85ce
--- /dev/null
@@ -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
+
index f045bbe..e21d44d 100644 (file)
@@ -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)