testing improved, slow march

Modules/FDEM1D/examples/LayeredEarthEM.cpp

@@ -17,16 +17,34 @@
  * @copyright Copyright (c) 2016, Lemma Software, LLC
  */
 
-#include "FEM1D"
+#include <random>
+#include "FDEM1D"
 
 using namespace Lemma;
 
 int main() {
 
+       std::random_device rd;
+       std::mt19937 gen(rd());
+       std::discrete_distribution<> d({0,0,40, 10, 10, 40});
+           int nl = d(gen);
+
+    std::uniform_real_distribution<> dis(0, 1);
+    VectorXcr con = VectorXcr(nl);
+    con(0) = 0;
+    for ( int i=1; i<nl; ++i ) {
+        con(i) = Complex(dis(gen), dis(gen));
+    }
+    std::cout << con << std::endl;
+
     auto model = LayeredEarthEM::NewSP();
-        model->SetNumberOfLayers(6);
-        model->SetLayerThickness( (VectorXr(4) << 10,10,10,10).finished() );
-        model->SetLayerConductivity( (VectorXcr(6) << .1, .10,.10,.10,.10,.10).finished() );
-    std::cout << *model << std::endl;
+        model->SetNumberOfLayers(nl);
+        //model->SetLayerThickness( (VectorXr(4) << 10,10,10,10).finished() );
+        //model->SetLayerConductivity( (VectorXcr(6) << .1, .10,.10,.10,.10,.10).finished() );
+    auto model2 = LayeredEarthEM::DeSerialize(model->Serialize());
+
+    std::cout << model->GetNumberOfLayers() << std::endl;
+    std::cout << model2->GetNumberOfLayers() << std::endl;
+
 }
 

Modules/FDEM1D/testing/CMakeLists.txt

@@ -1,3 +1,7 @@
 include_directories(${CXXTEST_INCLUDE_DIR})
+
 CXXTEST_ADD_TEST(unittestFEM1D_GetNameCheck GetNameCheck.cc ${CMAKE_CURRENT_SOURCE_DIR}/GetNameCheck.h)
 target_link_libraries(unittestFEM1D_GetNameCheck "lemmacore" "fdem1d")
+
+CXXTEST_ADD_TEST(unittestFEM1D_SerializeCheck SerializeCheck.cc ${CMAKE_CURRENT_SOURCE_DIR}/SerializeCheck.h)
+target_link_libraries(unittestFEM1D_SerializeCheck "lemmacore" "fdem1d")

Modules/FDEM1D/testing/GetNameCheck.h

@@ -19,7 +19,7 @@
 
 #include <cxxtest/TestSuite.h>
 #include <LemmaCore>
-#include <FEM1D>
+#include <FDEM1D>
 
 using namespace Lemma;
 

Modules/LemmaCore/include/LayeredEarth.h

@@ -77,6 +77,12 @@ namespace Lemma {
              */
 			Real GetLayerThickness(const int & lay);
 
+            /** Returns the thickness of a layer
+             *  @param[in] lay is the layer indice
+             *  @return the thickness of all intermediary (non-infinite) layers
+             */
+			VectorXr GetLayerThickness( );
+
 			/** Returns the depth of the bottom interface of a layer
              *  @param[in] lay is the layer indice
              *  @return the depth of the bottom interface of a layer

Modules/LemmaCore/include/LemmaCore

@@ -24,7 +24,7 @@
 //#include "Grid.h"
 //#include "GridReader.h"
 //#include "Instrument.h"
-//#include "LayeredEarth.h"
+#include "LayeredEarth.h"
 //#include "LemmaObject.h"
 #include "RectilinearGrid.h"
 #include "RectilinearGridReader.h"

Modules/LemmaCore/src/LayeredEarth.cpp

@@ -34,6 +34,7 @@ namespace Lemma {
 	}
 
     LayeredEarth::LayeredEarth(const YAML::Node& node) : EarthModel(node) {
+        std::cout << "LayeredEarth(YAML::Node )" << std::endl;
         NumberOfLayers = node["NumberOfLayers"].as<int>();
         NumberOfInterfaces = node["NumberOfInterfaces"].as<int>();
         LayerThickness = node["LayerThickness"].as<VectorXr>();
@@ -68,6 +69,10 @@ namespace Lemma {
 		return this->NumberOfLayers - 1;
 	}
 
+    VectorXr LayeredEarth::GetLayerThickness( ) {
+        return LayerThickness;
+    }
+
 	Real LayeredEarth::GetLayerThickness(const int &ilay) {
 		// Take into account infinite top and bottom layers
 		// estimate infinity by 1000 m
@@ -83,10 +88,7 @@ namespace Lemma {
 	}
 
 	Real LayeredEarth::GetLayerDepth(const int &ilay) {
-
 		Real depth = 0;
-
-
 		if (ilay == 0) {
 			return depth;
 		} else {
@@ -98,17 +100,14 @@ namespace Lemma {
 	}
 
 	int LayeredEarth::GetLayerAtThisDepth(const Real& depth) {
-
 		if (depth <= 0 || NumberOfLayers < 2) {
 			return 0;
 		}
-
 		Real laydep = 0;
 		for (int ilay=0; ilay<NumberOfLayers-2; ++ilay) {
 			laydep += LayerThickness[ilay];
 			if (laydep >= depth) { return ilay+1; }
 		}
-
 		return NumberOfLayers-1;
 	}
 

Modules/LemmaCore/testing/GetNameCheck.h

@@ -50,14 +50,16 @@ class MyTestSuite : public CxxTest::TestSuite
         TS_ASSERT_EQUALS( Obj->GetName(), std::string("RectilinearGridReader") );
     }
 
-// INCLUDE GUARDS DON'T WORK WITH CXXTEST, NEED TO MOVE VTK TESTS OUT
-// #ifdef LEMMAUSEVTK
-//     void testRectilinearGridVTKExporter( void )
-//     {
-//         auto Obj = RectilinearGridVTKExporter::NewSP();
-//         TS_ASSERT_EQUALS( Obj->GetName(), std::string("RectilinearGridVTKExporter") );
-//     }
-// #endif
+    void testRectilinearGridVTKExporter( void )
+    {
+        #ifdef LEMMAUSEVTK
+        auto Obj = RectilinearGridVTKExporter::NewSP();
+        TS_ASSERT_EQUALS( Obj->GetName(), std::string("RectilinearGridVTKExporter") );
+        #else
+        // dummy test if no VTK
+        TS_ASSERT_EQUALS( 3, 2+1 );
+        #endif
+    }
 
     void testWindowFilter( void )
     {

Modules/LemmaCore/testing/SerializeCheck.h

@@ -76,6 +76,23 @@ class MyTestSuite : public CxxTest::TestSuite
         TS_ASSERT_EQUALS( Obj->GetName(), Obj2->GetName() );
     }
 
+// How do we test abstract classes?
+//     void testLayeredEarth( void )
+//     {
+//         std::random_device rd;
+//         std::mt19937 gen(rd());
+//         std::discrete_distribution<> d({0,40, 10, 10, 40});
+//         auto Obj = LayeredEarth::NewSP();
+//             int nl = d(gen);
+//             Obj->SetNumberOfLayers(nl);
+//         YAML::Node node = Obj->Serialize();
+//         auto Obj2 = LayeredEarth::DeSerialize(node);
+//         TS_ASSERT_EQUALS( Obj->GetName(), Obj2->GetName() );
+//         TS_ASSERT_EQUALS( Obj->GetNumberOfLayers(), Obj2->GetNumberOfLayers() );
+//
+//     }
+
+
 //     void testRectilinearGridVTKExporter( void )
 //     {
 //         auto Obj = RectilinearGridVTKExporter::NewSP();