LemmaCore is up to enhancement 3

Documentation/dox/tutorial.dox

   to deliver expressive, fast code. Their benchmarks are right in line with 
   fast BLAS and LAPACK implementations. If you honestly feel that 
 \code
-DGEMM ( TRANSA, TRANSB, M, N, K, ALPHA, A, LDA, B, LDB, BETA, C, LDC )
+    DGEMM ( TRANSA, TRANSB, M, N, K, ALPHA, A, LDA, B, LDB, BETA, C, LDC )
 \endcode  
  is superior to
 \code
-  C = A*B.transpose(); 
+    C = A*B.transpose(); 
 \endcode 
  you are living in denial. Check out the benchmarks if you are still sceptical
 http://eigen.tuxfamily.org/index.php?title=Benchmark 

Modules/LemmaCore/include/ASCIIParser.h

      *       in c++-17, this curiosity may be resolved.
      * @see ASCIIParser::DeSerialize
      */
-    ASCIIParser ( const YAML::Node& node, const ctor_key& );
+    explicit ASCIIParser ( const YAML::Node& node, const ctor_key& );
 
     /** Default  destructor
      *  @note This should never be called explicitly, use NewSP
 }		// -----  end of Lemma  name  -----
 
 #endif   // ----- #ifndef ASCIIPARSER_INC  -----
+
+/* vim: set tabstop=4 expandtab: */
+/* vim: set filetype=cpp syntax=cpp.doxygen: */

Modules/LemmaCore/include/CubicSplineInterpolator.h

     /** Default constructor */
     explicit CubicSplineInterpolator ( const ctor_key& );
 
-    /** DeSerializing constructor, usees factory DeSerialize  method*/
+    /** DeSerializing constructor, locked use factory DeSerialize  method*/
     CubicSplineInterpolator ( const YAML::Node& node, const ctor_key& );
 
     /** Destructor use smart pointers to auto delete */
 #endif   // ----- #ifndef CUBICSPLINEINTERPOLATOR_INC  -----
 
 /* vim: set tabstop=4 expandtab: */
-/* vim: set filetype=cpp: */
+/* vim: set filetype=cpp syntax=cpp.doxygen: */

Modules/LemmaCore/include/GridReader.h

             GridReader ( ) : LemmaObject( ) {
             }
 
+            /** Default protected constructor, use New */
+            GridReader ( const YAML::Node& node ) : LemmaObject( node ) {
+            }
+
             /** Default protected constructor, use Delete */
             ~GridReader () {
             }

Modules/LemmaCore/include/RectilinearGrid.h

 
 namespace Lemma {
 
-    // ===================================================================
-    //  Class:  RectilinearGrid
     /**
-      @class
-      \ingroup LemmaCore
-      \brief   Impliments a rectilinear grid.
-      \details A rectilinear grid can vary regularily in space but must be
-               constant variation across each dimension. In this way three
-               vectors can define the entire grid, and each cell is right
-               aligned with all its neighbours.
+     * \ingroup LemmaCore
+     * \brief   Impliments a rectilinear grid.
+     * \details A rectilinear grid can vary regularily in space but must be
+     *         constant variation across each dimension. In this way three
+     *         vectors can define the entire grid, and each cell is right
+     *         aligned with all its neighbours.
      */
-    // ===================================================================
     class RectilinearGrid : public Grid {
 
         friend std::ostream &operator<<(std::ostream &stream,
             // ====================  LIFECYCLE     =======================
 
             /**
-             *  Factory method for generating concrete class.
-             *  @return a std::shared_ptr of type RectilinearGrid
+             * DeSerializing constructor.
+             * @note This method is locked, and cannot be called directly.
+             *       The reason that the method is public is to enable the use
+             *       of make_shared whilst enforcing the use of shared_ptr,
+             *       in c++-17, this curiosity may be resolved.
+             * @see RectilinearGrid::NewSP
              */
-            static std::shared_ptr<RectilinearGrid> NewSP();
+            explicit RectilinearGrid ( const ctor_key& );
 
+            /**
+             * DeSerializing constructor.
+             * @note This method is locked, and cannot be called directly.
+             *       The reason that the method is public is to enable the use
+             *       of make_shared whilst enforcing the use of shared_ptr,
+             *       in c++-17, this curiosity may be resolved.
+             * @see DeSerialize
+             */
+            explicit RectilinearGrid (const YAML::Node& node, const ctor_key& );
+
+            /** Default destructor.
+             *  @note This should never be called explicitly, use NewSP
+             */
+            virtual ~RectilinearGrid ();
 
             /**
              *  Uses YAML to serialize this object.
             virtual YAML::Node Serialize() const;
 
             /**
+             *  Factory method for generating concrete class.
+             *  @return a std::shared_ptr of type RectilinearGrid
+             */
+            static std::shared_ptr<RectilinearGrid> NewSP();
+
+            /**
              *   Constructs an object from a YAML::Node.
              */
             static std::shared_ptr< RectilinearGrid > DeSerialize(const YAML::Node& node);
 
             // ====================  LIFECYCLE     =======================
 
-            /** Default protected constructor. */
-            RectilinearGrid ( );
-
-            /** Protected DeDerializing constructor, use factory DeSerialize  method*/
-            RectilinearGrid (const YAML::Node& node);
+        private:
 
-            /** Default protected constructor. */
-            ~RectilinearGrid ();
+            /** ASCII string representation of the class name */
+            static constexpr auto CName = "RectilinearGrid";
 
             // ====================  DATA MEMBERS  =========================
 
             /// Cell spacing in the z dimension
             VectorXr dz;
 
-        private:
-
-            /** ASCII string representation of the class name */
-            static constexpr auto CName = "RectilinearGrid";
-
     }; // -----  end of class  RectilinearGrid  -----
 
 }		// -----  end of Lemma  name  -----
 #endif   // ----- #ifndef RECTILINEARGRID_INC  -----
 
 /* vim: set tabstop=4 expandtab: */
-/* vim: set filetype=cpp: */
+/* vim: set filetype=cpp syntax=cpp.doxygen: */

Modules/LemmaCore/include/RectilinearGridReader.h

         friend std::ostream &operator<<(std::ostream &stream,
                 const RectilinearGridReader &ob);
 
+        /*
+         *  This key is used to lock the constructors
+         */
+        struct ctor_key {};
+
         public:
 
             // ====================  LIFECYCLE     =======================
 
+            /** Default constructor
+             * @note This method is locked
+             * @see NewSP
+             */
+            explicit RectilinearGridReader ( const ctor_key& );
+
+            /**
+             * DeSerializing constructor.
+             * @note This method is locked, and cannot be called directly.
+             *       The reason that the method is public is to enable the use
+             *       of make_shared whilst enforcing the use of shared_ptr,
+             *       in c++-17, this curiosity may be resolved.
+             * @see DeSerialize
+             */
+            explicit RectilinearGridReader ( const YAML::Node& node, const ctor_key& );
+
+            /** Default destructor.
+             *  @note This should never be called explicitly, use NewSP
+             */
+            ~RectilinearGridReader ( );
+
             /**
              *  Factory method for generating concrete class.
              *  @return a std::shared_ptr of type RectilinearGridReader
              */
             static std::shared_ptr< RectilinearGridReader > NewSP();
 
+            /**
+             *  Constructs an object from a YAML serialization
+             *  @return a std::shared_ptr of type RectilinearGridReader
+             */
+            static std::shared_ptr< RectilinearGridReader >  DeSerialize( const YAML::Node& node );
+
+            /**
+             *  Uses YAML to serialize this object.
+             *  @return a YAML::Node
+             */
+            virtual YAML::Node Serialize() const;
+
             // ====================  OPERATORS     =======================
 
             // ====================  OPERATIONS    =======================
 
             // ====================  LIFECYCLE     =======================
 
-            /** Default protected constructor, use New */
-            RectilinearGridReader ( );
-
-            /** Default protected constructor, use Delete */
-            ~RectilinearGridReader ();
-
         private:
 
             // ====================  DATA MEMBERS  =========================
 }		// -----  end of Lemma  name  -----
 
 #endif   // ----- #ifndef RECTILINEARGRIDREADER_INC  -----
+
+
+/* vim: set tabstop=4 expandtab: */
+/* vim: set filetype=cpp syntax=cpp.doxygen: */

Modules/LemmaCore/include/RectilinearGridVTKExporter.h

     friend std::ostream &operator<<(std::ostream &stream,
             const RectilinearGridVTKExporter &ob);
 
+    struct ctor_key {};
+
     public:
 
     // ====================  LIFECYCLE     =======================
 
     /**
-     * @copybrief LemmaObject::New()
-     * @copydetails LemmaObject::New()
-     */
-    static RectilinearGridVTKExporter* New();
-
-    /**
      *  Factory method for generating concrete class.
      *  @return a std::shared_ptr of type RectilinearGridVTKExporter
      */
     static std::shared_ptr< RectilinearGridVTKExporter > NewSP();
 
+    /** Default constructor */
+    explicit RectilinearGridVTKExporter ( const ctor_key& );
+
+    /** Deserializing constructor */
+    explicit RectilinearGridVTKExporter ( const YAML::Node& node, const ctor_key& );
+
+    /** Default protected destructor, use Delete */
+    virtual ~RectilinearGridVTKExporter ();
+
+    /**
+     *  Uses YAML to serialize this object.
+     *  @return a YAML::Node
+     */
+    virtual YAML::Node Serialize() const;
+
+    /**
+     *   Constructs an object from a YAML::Node.
+     */
+    static std::shared_ptr< RectilinearGridVTKExporter > DeSerialize(const YAML::Node& node);
+
     // ====================  OPERATORS     =======================
 
     // ====================  OPERATIONS    =======================
 
     // ====================  LIFECYCLE     =======================
 
-    /** Default protected constructor, use New */
-    RectilinearGridVTKExporter ( );
-
-    /** Default protected destructor, use Delete */
-    ~RectilinearGridVTKExporter ();
-
     private:
 
     /** ASCII string representation of the class name */
 
 #endif   // ----- #ifndef RECTILINEARGRIDVTKEXPORTER_INC  -----
 
+/* vim: set tabstop=4 expandtab: */
+/* vim: set filetype=cpp syntax=cpp.doxygen: */

Modules/LemmaCore/src/ASCIIParser.cpp

     // ====================  FRIEND METHODS  =====================
 
     std::ostream &operator << (std::ostream &stream, const ASCIIParser &ob) {
-        stream << ob.Serialize()  << "\n---\n"; // End of doc --- as a direct stream should encapulste thingy
+        stream << ob.Serialize()  << "\n---\n"; // End of doc
         return stream;
     }
 
     //--------------------------------------------------------------------------------------
     //       Class:  ASCIIParser
     //      Method:  ASCIIParser
-    // Description:  constructor (protected)
+    // Description:  constructor (locked)
     //--------------------------------------------------------------------------------------
     ASCIIParser::ASCIIParser ( const ctor_key& ) : LemmaObject( ), input(),
             CommentString("//"), BufferSize(255) {
 
 }		// -----  end of Lemma  name  -----
 
-
+/* vim: set tabstop=4 expandtab: */
+/* vim: set filetype=cpp syntax=cpp.doxygen: */

Modules/LemmaCore/src/CMakeLists.txt

 	${CMAKE_CURRENT_SOURCE_DIR}/ASCIIParser.cpp                # fixed, key 
 	${CMAKE_CURRENT_SOURCE_DIR}/CubicSplineInterpolator.cpp    # fixed, key 
 	${CMAKE_CURRENT_SOURCE_DIR}/Grid.cpp                       # ABC, no key 
-	${CMAKE_CURRENT_SOURCE_DIR}/RectilinearGrid.cpp
-	${CMAKE_CURRENT_SOURCE_DIR}/RectilinearGridReader.cpp
-	${CMAKE_CURRENT_SOURCE_DIR}/RectilinearGridVTKExporter.cpp
+	${CMAKE_CURRENT_SOURCE_DIR}/RectilinearGrid.cpp            # fixed, key
+	${CMAKE_CURRENT_SOURCE_DIR}/RectilinearGridReader.cpp      # fixed, key
+	${CMAKE_CURRENT_SOURCE_DIR}/RectilinearGridVTKExporter.cpp # fixed, key
 	${CMAKE_CURRENT_SOURCE_DIR}/Filter.cpp                     # ABC, no key
 	${CMAKE_CURRENT_SOURCE_DIR}/WindowFilter.cpp			   # fixed, key
 	${CMAKE_CURRENT_SOURCE_DIR}/EarthModel.cpp                 # ABC, no key

Modules/LemmaCore/src/RectilinearGrid.cpp

 
     // ====================  LIFECYCLE     =======================
 
-    RectilinearGrid::RectilinearGrid( ) : Grid( ), nx(0), ny(0), nz(0) {
+    RectilinearGrid::RectilinearGrid( const ctor_key& ) : Grid( ), nx(0), ny(0), nz(0) {
 
     }
 
-    RectilinearGrid::RectilinearGrid( const YAML::Node& node ) : Grid(node) {
+    RectilinearGrid::RectilinearGrid( const YAML::Node& node, const ctor_key& ) : Grid(node) {
 
         nx = node["nx"].as<int>( );
         ny = node["ny"].as<int>( );
     }
 
     std::shared_ptr< RectilinearGrid > RectilinearGrid::NewSP() {
-        std::shared_ptr<RectilinearGrid> sp(new  RectilinearGrid( ), LemmaObjectDeleter() );
-        return sp;
+        return std::make_shared< RectilinearGrid > ( ctor_key() );
     }
 
     YAML::Node RectilinearGrid::Serialize() const {
         if (node.Tag() != "RectilinearGrid") {
             throw  DeSerializeTypeMismatch( "RectilinearGrid", node.Tag());
         }
-        std::shared_ptr<RectilinearGrid> Object(new  RectilinearGrid(node), LemmaObjectDeleter() );
-        return Object ;
+        return std::make_shared< RectilinearGrid > ( node, ctor_key() );
     }
 
 
 }		// -----  end of Lemma  name  -----
 
 /* vim: set tabstop=4 expandtab: */
-/* vim: set filetype=cpp: */
+/* vim: set filetype=cpp: syntax=cpp.doxygen*/

Modules/LemmaCore/src/RectilinearGridReader.cpp

     // ====================  FRIEND METHODS  =====================
 
     std::ostream &operator << (std::ostream &stream, const RectilinearGridReader &ob) {
-        stream << ob.Serialize()  << "\n---\n"; // End of doc --- as a direct stream should encapulste thingy
+        stream << ob.Serialize()  << "\n---\n"; // End of doc
         return stream;
     }
 
     //--------------------------------------------------------------------------------------
     //       Class:  RectilinearGridReader
     //      Method:  RectilinearGridReader
-    // Description:  constructor (protected)
+    // Description:  constructor (locked)
     //--------------------------------------------------------------------------------------
-    RectilinearGridReader::RectilinearGridReader ( ) : GridReader( ),
+    RectilinearGridReader::RectilinearGridReader ( const ctor_key& ) : GridReader( ),
         rGrid( nullptr ), Parser( nullptr ) {
 
     }  // -----  end of method RectilinearGridReader::RectilinearGridReader  (constructor)  -----
 
+    //--------------------------------------------------------------------------------------
+    //       Class:  RectilinearGridReader
+    //      Method:  RectilinearGridReader
+    // Description:  DeSerializing constructor (protected)
+    //--------------------------------------------------------------------------------------
+    RectilinearGridReader::RectilinearGridReader (const YAML::Node& node, const ctor_key&  key) : GridReader(node) {
+    }  // -----  end of method RectilinearGridReader::RectilinearGridReader  (constructor)  -----
 
     //--------------------------------------------------------------------------------------
     //       Class:  RectilinearGridReader
     // Description:  constructor
     //--------------------------------------------------------------------------------------
     std::shared_ptr< RectilinearGridReader > RectilinearGridReader::NewSP() {
-        std::shared_ptr<RectilinearGridReader> sp(new  RectilinearGridReader( ), LemmaObjectDeleter() );
-        return sp;
+        return std::make_shared< RectilinearGridReader > ( ctor_key() );
     }
 
-
-
     //--------------------------------------------------------------------------------------
     //       Class:  RectilinearGridReader
     //      Method:  ~RectilinearGridReader
     }  // -----  end of method RectilinearGridReader::~RectilinearGridReader  (destructor)  -----
 
     //--------------------------------------------------------------------------------------
+    //       Class:  ASCIIParser
+    //      Method:  Serialize
+    //--------------------------------------------------------------------------------------
+    YAML::Node  RectilinearGridReader::Serialize (  ) const {
+        YAML::Node node = GridReader::Serialize();;
+        node.SetTag( GetName() );
+        //node["CommentString"] = CommentString;
+        //node["BufferSize"] = BufferSize;
+        return node;
+    }		// -----  end of method ASCIIParser::Serialize  -----
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  RectilinearGridReader
+    //      Method:  DeSerialize
+    //--------------------------------------------------------------------------------------
+    std::shared_ptr<RectilinearGridReader> RectilinearGridReader::DeSerialize ( const YAML::Node& node ) {
+        if (node.Tag() != "RectilinearGridReader") {
+            throw  DeSerializeTypeMismatch( "RectilinearGridReader", node.Tag());
+        }
+        return std::make_shared< RectilinearGridReader >( node, ctor_key() ); //, ctor_key() );
+    }		// -----  end of method ASCIIParser::DeSerialize  -----
+
+    //--------------------------------------------------------------------------------------
     //       Class:  RectilinearGridReader
     //      Method:  ReadASCIIGridFile
     //--------------------------------------------------------------------------------------

Modules/LemmaCore/src/RectilinearGridVTKExporter.cpp

  * @date      09/25/2013 08:20:14 AM
  * @version   $Id$
  * @author    Trevor Irons (ti)
- * @email     Trevor.Irons@xri-geo.com
+ * @email     tirons@egi.utah.edu
  * @copyright Copyright (c) 2013, Trevor Irons
  */
 
 // ====================  FRIEND METHODS  =====================
 
 std::ostream &operator << (std::ostream &stream, const RectilinearGridVTKExporter &ob) {
-    stream << ob.Serialize()  << "\n---\n"; // End of doc --- as a direct stream should encapulste thingy
+    stream << ob.Serialize()  << "\n---\n"; // End of doc
     return stream;
 }
 
-
 // ====================  LIFECYCLE     =======================
 
 //--------------------------------------------------------------------------------------
 //      Method:  RectilinearGridVTKExporter
 // Description:  constructor (protected)
 //--------------------------------------------------------------------------------------
-RectilinearGridVTKExporter::RectilinearGridVTKExporter ( ) : LemmaObject( ), Grid(nullptr), VTKGrid(nullptr) {
+RectilinearGridVTKExporter::RectilinearGridVTKExporter ( const ctor_key& ) : LemmaObject( ), Grid(nullptr), VTKGrid(nullptr) {
 
 }  // -----  end of method RectilinearGridVTKExporter::RectilinearGridVTKExporter  (constructor)  -----
 
+//--------------------------------------------------------------------------------------
+//       Class:  RectilinearGridVTKExporter
+//      Method:  RectilinearGridVTKExporter
+// Description:  DeSerializing constructor (protected)
+//--------------------------------------------------------------------------------------
+RectilinearGridVTKExporter::RectilinearGridVTKExporter (const YAML::Node& node, const ctor_key&  key) : LemmaObject(node) {
+    if (node["Grid"]) {
+        this->Grid = RectilinearGrid::DeSerialize( node["Grid"] );
+    }
+}  // -----  end of method RectilinearGridVTKExporter::RectilinearGridVTKExporter  (constructor)  -----
 
 //--------------------------------------------------------------------------------------
 //       Class:  RectilinearGridVTKExporter
 // Description:  public constructor
 //--------------------------------------------------------------------------------------
 std::shared_ptr< RectilinearGridVTKExporter > RectilinearGridVTKExporter::NewSP() {
-    std::shared_ptr<RectilinearGridVTKExporter> sp(new  RectilinearGridVTKExporter( ), LemmaObjectDeleter() );
-    return sp;
+    return std::make_shared< RectilinearGridVTKExporter > ( ctor_key() );
 }
 
-
-
 //--------------------------------------------------------------------------------------
 //       Class:  RectilinearGridVTKExporter
 //      Method:  ~RectilinearGridVTKExporter
 
 //--------------------------------------------------------------------------------------
 //       Class:  RectilinearGridVTKExporter
+//      Method:  Serialize
+//--------------------------------------------------------------------------------------
+YAML::Node  RectilinearGridVTKExporter::Serialize (  ) const {
+    YAML::Node node = LemmaObject::Serialize();;
+    node.SetTag( GetName() );
+    if (Grid != nullptr) {
+        node["Grid"] = Grid->Serialize();
+    }
+    return node;
+}		// -----  end of method RectilinearGridVTKExporter::Serialize  -----
+
+//--------------------------------------------------------------------------------------
+//       Class:  RectilinearGridVTKExporter
+//      Method:  DeSerialize
+//--------------------------------------------------------------------------------------
+std::shared_ptr<RectilinearGridVTKExporter> RectilinearGridVTKExporter::DeSerialize ( const YAML::Node& node ) {
+    if (node.Tag() != "RectilinearGridVTKExporter") {
+        throw  DeSerializeTypeMismatch( "RectilinearGridVTKExporter", node.Tag());
+    }
+    return std::make_shared< RectilinearGridVTKExporter >( node, ctor_key() ); //, ctor_key() );
+}		// -----  end of method RectilinearGridVTKExporter::DeSerialize  -----
+
+//--------------------------------------------------------------------------------------
+//       Class:  RectilinearGridVTKExporter
 //      Method:  GetVTKRectilinearGrid
 //--------------------------------------------------------------------------------------
 vtkSmartPointer<vtkRectilinearGrid> RectilinearGridVTKExporter::GetVTKGrid (  ) {
     return ;
 }		// -----  end of method RectilinearGridVTKExporter::BuildVTKRectilinearGrid  -----
 
-
-
 }		// -----  end of Lemma  name  -----
 
 #endif     // -----  not LEMMAUSEVTK  -----
+
+/* vim: set tabstop=4 expandtab: */
+/* vim: set filetype=cpp syntax=cpp.doxygen: */

Modules/LemmaCore/testing/SerializeCheck.h

 {
     public:
 
+//     void test_trace(void)
+//     {
+//         TS_TRACE("This is a test tracing message.");
+//     }
+//
+//     void test_warn(void)
+//     {
+//         TS_WARN("This is a test warning message.");
+//     }
+
     void testASCIIParser( void )
     {
         auto Obj = ASCIIParser::NewSP();
         TS_ASSERT_EQUALS( Obj->GetName(), Obj2->GetName() );
     }
 
+    void testRectilinearGridReader( void )
+    {
+        auto Obj = RectilinearGridReader::NewSP();
+        YAML::Node node = Obj->Serialize();
+        auto Obj2 = RectilinearGridReader::DeSerialize(node);
+        TS_ASSERT_EQUALS( Obj->GetName(), Obj2->GetName() );
+    }
+
     void testWindowFilter( void )
     {
         auto Obj = WindowFilter::NewSP();
         TS_ASSERT_EQUALS( Obj->GetName(), Obj2->GetName() );
     }
 
-// /*
-//     void testRectilinearGridReader( void )
-//     {
-//         auto Obj = RectilinearGridReader::NewSP();
-//         TS_ASSERT_EQUALS( Obj->GetName(), std::string("RectilinearGridReader") );
-//     }
-//
 //     void testRectilinearGridVTKExporter( void )
 //     {
 //         auto Obj = RectilinearGridVTKExporter::NewSP();
 //         TS_ASSERT_EQUALS( Obj->GetName(), std::string("RectilinearGridVTKExporter") );
 //     }
-//
-
-// */
 
 };
 

vim/c.vim

 
 " Lemma types
 highlight leType ctermfg=Yellow guifg=Yellow
-syn keyword leType HankelTransform KernelEm1D KernelEM1DManager DipoleSource EarthModel LayeredEarth LayeredEarthEM TEMSurvey TEMSurveyLine TEMSurveyLineRecord TEMInductiveReceiver PolygonalWireAntenna TEMTransmitter TEMReceiver Instrument InstrumentTem LemmaObject ReceiverPoints DCIPElectrode TEMSurveyData TEMSurveyLineData TEMSurveyLineRecordData  ASCIIParser CubicSplineInterpolator RectilinearGrid RectilinearGridReader RectilinearGridVTKExporter Filter WindowFilter DEMParticle DEMGrain Data DataReader
+syn keyword leType HankelTransform KernelEm1D KernelEM1DManager DipoleSource EarthModel LayeredEarth LayeredEarthEM TEMSurvey TEMSurveyLine TEMSurveyLineRecord TEMInductiveReceiver PolygonalWireAntenna TEMTransmitter TEMReceiver Instrument InstrumentTem LemmaObject ReceiverPoints DCIPElectrode TEMSurveyData TEMSurveyLineData TEMSurveyLineRecordData  ASCIIParser CubicSplineInterpolator RectilinearGrid GridReader RectilinearGridReader RectilinearGridVTKExporter Filter WindowFilter DEMParticle DEMGrain Data DataReader
 
 " Deprecated Lemma Types
 highlight dleType ctermfg=Blue guifg=Blue