Procházet zdrojové kódy

Lemma V 0.2.0, ctor_key now only at root level

submodule
T-bone před 6 roky
rodič
revize
a941c7df1c
56 změnil soubory, kde provedl 99 přidání a 137 odebrání
  1. 2
    2
      CMakeLists.txt
  2. 0
    2
      Modules/FDEM1D/include/DipoleSource.h
  3. 0
    2
      Modules/FDEM1D/include/EMEarth1D.h
  4. 0
    2
      Modules/FDEM1D/include/FHTAnderson801.h
  5. 0
    2
      Modules/FDEM1D/include/FHTKey101.h
  6. 1
    4
      Modules/FDEM1D/include/FHTKey201.h
  7. 0
    2
      Modules/FDEM1D/include/FHTKey51.h
  8. 0
    4
      Modules/FDEM1D/include/FieldPoints.h
  9. 0
    3
      Modules/FDEM1D/include/GQChave.h
  10. 2
    2
      Modules/FDEM1D/include/HankelTransform.h
  11. 1
    1
      Modules/FDEM1D/include/KernelEM1DBase.h
  12. 0
    2
      Modules/FDEM1D/include/KernelEM1DManager.h
  13. 1
    1
      Modules/FDEM1D/include/KernelEM1DReflBase.h
  14. 2
    5
      Modules/FDEM1D/include/KernelEM1DReflSpec.h
  15. 2
    4
      Modules/FDEM1D/include/KernelEM1DSpec.h
  16. 0
    2
      Modules/FDEM1D/include/LayeredEarthEM.h
  17. 0
    2
      Modules/FDEM1D/include/PolygonalWireAntenna.h
  18. 0
    2
      Modules/FDEM1D/include/QWEKey.h
  19. 0
    3
      Modules/FDEM1D/include/WireAntenna.h
  20. 2
    2
      Modules/FDEM1D/src/DipoleSource.cpp
  21. 2
    2
      Modules/FDEM1D/src/EMEarth1D.cpp
  22. 3
    3
      Modules/FDEM1D/src/FHTAnderson801.cpp
  23. 3
    3
      Modules/FDEM1D/src/FHTKey101.cpp
  24. 3
    3
      Modules/FDEM1D/src/FHTKey201.cpp
  25. 3
    3
      Modules/FDEM1D/src/FHTKey51.cpp
  26. 3
    3
      Modules/FDEM1D/src/FieldPoints.cpp
  27. 3
    3
      Modules/FDEM1D/src/GQChave.cpp
  28. 3
    3
      Modules/FDEM1D/src/HankelTransform.cpp
  29. 2
    2
      Modules/FDEM1D/src/KernelEM1DManager.cpp
  30. 3
    3
      Modules/FDEM1D/src/LayeredEarthEM.cpp
  31. 4
    3
      Modules/FDEM1D/src/PolygonalWireAntenna.cpp
  32. 2
    2
      Modules/FDEM1D/src/QWEKey.cpp
  33. 3
    3
      Modules/FDEM1D/src/WireAntenna.cpp
  34. 3
    4
      Modules/LemmaCore/include/CubicSplineInterpolator.h
  35. 2
    2
      Modules/LemmaCore/include/Data.h
  36. 2
    2
      Modules/LemmaCore/include/DataReader.h
  37. 2
    2
      Modules/LemmaCore/include/EarthModel.h
  38. 2
    2
      Modules/LemmaCore/include/Filter.h
  39. 2
    2
      Modules/LemmaCore/include/Grid.h
  40. 2
    2
      Modules/LemmaCore/include/GridReader.h
  41. 1
    3
      Modules/LemmaCore/include/LayeredEarth.h
  42. 1
    1
      Modules/LemmaCore/include/RectilinearGrid.h
  43. 1
    1
      Modules/LemmaCore/include/RectilinearGridReader.h
  44. 1
    1
      Modules/LemmaCore/include/RectilinearGridVTKExporter.h
  45. 1
    1
      Modules/LemmaCore/include/WindowFilter.h
  46. 4
    4
      Modules/LemmaCore/src/CubicSplineInterpolator.cpp
  47. 3
    3
      Modules/LemmaCore/src/Data.cpp
  48. 3
    3
      Modules/LemmaCore/src/DataReader.cpp
  49. 3
    3
      Modules/LemmaCore/src/EarthModel.cpp
  50. 2
    2
      Modules/LemmaCore/src/Filter.cpp
  51. 2
    2
      Modules/LemmaCore/src/Grid.cpp
  52. 3
    3
      Modules/LemmaCore/src/LayeredEarth.cpp
  53. 2
    2
      Modules/LemmaCore/src/RectilinearGrid.cpp
  54. 2
    2
      Modules/LemmaCore/src/RectilinearGridReader.cpp
  55. 2
    2
      Modules/LemmaCore/src/RectilinearGridVTKExporter.cpp
  56. 3
    3
      Modules/LemmaCore/src/WindowFilter.cpp

+ 2
- 2
CMakeLists.txt Zobrazit soubor

@@ -219,8 +219,8 @@ if(COMPILER_SUPPORTS_OPENMP AND LEMMA_USE_OPENMP )
219 219
 endif()
220 220
 
221 221
 set(LEMMA_VERSION_MAJOR "0")
222
-set(LEMMA_VERSION_MINOR "1")
223
-set(LEMMA_VERSION_PATCH "2")
222
+set(LEMMA_VERSION_MINOR "2")
223
+set(LEMMA_VERSION_PATCH "0")
224 224
 set(LEMMA_VERSION "\"${LEMMA_VERSION_MAJOR}.${LEMMA_VERSION_MINOR}.${LEMMA_VERSION_PATCH}\"")
225 225
 set(LEMMA_VERSION_NOQUOTES "${LEMMA_VERSION_MAJOR}.${LEMMA_VERSION_MINOR}.${LEMMA_VERSION_PATCH}")
226 226
 

+ 0
- 2
Modules/FDEM1D/include/DipoleSource.h Zobrazit soubor

@@ -46,8 +46,6 @@ namespace Lemma {
46 46
 
47 47
         friend std::ostream &operator<<(std::ostream &stream, const DipoleSource &ob);
48 48
 
49
-        struct ctor_key{};
50
-
51 49
         public:
52 50
 
53 51
             // ====================  LIFECYCLE     ======================

+ 0
- 2
Modules/FDEM1D/include/EMEarth1D.h Zobrazit soubor

@@ -54,8 +54,6 @@ namespace Lemma {
54 54
 		friend std::ostream &operator<<(std::ostream &stream,
55 55
 			const EMEarth1D &ob);
56 56
 
57
-        struct ctor_key{};
58
-
59 57
         public:
60 58
 
61 59
             //friend class KernelEm1D;

+ 0
- 2
Modules/FDEM1D/include/FHTAnderson801.h Zobrazit soubor

@@ -61,8 +61,6 @@ class FHTAnderson801 : public HankelTransform {
61 61
 
62 62
     friend std::ostream &operator<<(std::ostream &stream, const FHTAnderson801 &ob);
63 63
 
64
-    struct ctor_key {};
65
-
66 64
     public:
67 65
 
68 66
         // ====================  LIFECYCLE     ==============================

+ 0
- 2
Modules/FDEM1D/include/FHTKey101.h Zobrazit soubor

@@ -39,8 +39,6 @@ namespace Lemma {
39 39
 
40 40
         friend std::ostream &operator<<(std::ostream &stream, const FHTKey101 &ob);
41 41
 
42
-        struct ctor_key {};
43
-
44 42
         public:
45 43
 
46 44
         // ====================  LIFECYCLE     =======================

+ 1
- 4
Modules/FDEM1D/include/FHTKey201.h Zobrazit soubor

@@ -38,13 +38,10 @@ namespace Lemma {
38 38
     class FHTKey201 : public HankelTransform {
39 39
 
40 40
         friend std::ostream &operator<<(std::ostream &stream, const FHTKey201 &ob);
41
-
42
-        struct ctor_key {};
41
+        // ====================  LIFECYCLE     =======================
43 42
 
44 43
         public:
45 44
 
46
-        // ====================  LIFECYCLE     =======================
47
-
48 45
         /** Default locked constructor, use NewSP */
49 46
         FHTKey201 ( const ctor_key& );
50 47
 

+ 0
- 2
Modules/FDEM1D/include/FHTKey51.h Zobrazit soubor

@@ -39,8 +39,6 @@ namespace Lemma {
39 39
 
40 40
         friend std::ostream &operator<<(std::ostream &stream, const FHTKey51 &ob);
41 41
 
42
-        struct ctor_key {};
43
-
44 42
         public:
45 43
 
46 44
         // ====================  LIFECYCLE     =======================

+ 0
- 4
Modules/FDEM1D/include/FieldPoints.h Zobrazit soubor

@@ -56,14 +56,10 @@ namespace Lemma {
56 56
          */
57 57
         friend std::ostream &operator<<(std::ostream &stream, const FieldPoints &ob);
58 58
 
59
-        struct ctor_key {};
60
-
61 59
         public:
62 60
 
63 61
             // ====================    FRIENDS     ===========================
64 62
 
65
-
66
-
67 63
             // ====================  LIFECYCLE     ===========================
68 64
 
69 65
             /** Default locked constructor. */

+ 0
- 3
Modules/FDEM1D/include/GQChave.h Zobrazit soubor

@@ -31,9 +31,6 @@ namespace Lemma {
31 31
 	class GQChave : public HankelTransform {
32 32
 
33 33
 		friend std::ostream &operator<<(std::ostream &stream, const GQChave &ob);
34
-
35
-        struct ctor_key{};
36
-
37 34
 		public:
38 35
 
39 36
 			// ====================  LIFECYCLE     ===========================

+ 2
- 2
Modules/FDEM1D/include/HankelTransform.h Zobrazit soubor

@@ -75,10 +75,10 @@ namespace Lemma {
75 75
                 // ====================  LIFECYCLE     =======================
76 76
 
77 77
                 /// Default protected constructor.
78
-                HankelTransform ( );
78
+                HankelTransform ( const ctor_key& );
79 79
 
80 80
                 /// Default protected constructor.
81
-                HankelTransform ( const YAML::Node& node );
81
+                HankelTransform ( const YAML::Node& node, const ctor_key& );
82 82
 
83 83
                 /// Default protected constructor.
84 84
                 ~HankelTransform ( );

+ 1
- 1
Modules/FDEM1D/include/KernelEM1DBase.h Zobrazit soubor

@@ -38,7 +38,7 @@ namespace Lemma {
38 38
             // ====================  LIFECYCLE     =======================
39 39
 
40 40
             /// Default protected constructor.
41
-            KernelEM1DBase ( ) : LemmaObject( ) {
41
+            KernelEM1DBase ( const ctor_key& key ) : LemmaObject( key ) {
42 42
 
43 43
             }
44 44
 

+ 0
- 2
Modules/FDEM1D/include/KernelEM1DManager.h Zobrazit soubor

@@ -32,8 +32,6 @@ namespace Lemma {
32 32
     // ===================================================================
33 33
     class KernelEM1DManager : public LemmaObject {
34 34
 
35
-        struct ctor_key {};
36
-
37 35
         /** Recursively streams information about this class */
38 36
         friend std::ostream &operator<<(std::ostream &stream, const KernelEM1DManager &ob);
39 37
 

+ 1
- 1
Modules/FDEM1D/include/KernelEM1DReflBase.h Zobrazit soubor

@@ -151,7 +151,7 @@ namespace Lemma {
151 151
             // ====================  LIFECYCLE     =======================
152 152
 
153 153
             /// Default protected constructor.
154
-            KernelEM1DReflBase ( ) : LemmaObject( )
154
+            KernelEM1DReflBase ( const ctor_key& key ) : LemmaObject( key )
155 155
             {
156 156
             }
157 157
 

+ 2
- 5
Modules/FDEM1D/include/KernelEM1DReflSpec.h Zobrazit soubor

@@ -38,9 +38,6 @@ namespace Lemma {
38 38
     template<EMMODE Mode, DIPOLE_LOCATION Isource, DIPOLE_LOCATION Irecv>
39 39
     class KernelEM1DReflSpec : public KernelEM1DReflBase {
40 40
 
41
-        // TODO can we use the manager's key instead to lock for that?
42
-        struct ctor_key{};
43
-
44 41
         public:
45 42
 
46 43
             //template<EMMODE Mode2, int Ikernel2, DIPOLE_LOCATION Isource2, DIPOLE_LOCATION Irecv2>
@@ -51,7 +48,7 @@ namespace Lemma {
51 48
             // ====================  LIFECYCLE     =======================
52 49
 
53 50
             /// Default locked constructor.
54
-            explicit KernelEM1DReflSpec ( const ctor_key& ) : KernelEM1DReflBase( ) {
51
+            explicit KernelEM1DReflSpec ( const ctor_key& key ) : KernelEM1DReflBase( key ) {
55 52
             }
56 53
 
57 54
             /// Default protected constructor.
@@ -72,7 +69,7 @@ namespace Lemma {
72 69
 
73 70
             virtual std::string GetName() {
74 71
                 return CName;
75
-            } 
72
+            }
76 73
 
77 74
         protected:
78 75
         private:

+ 2
- 4
Modules/FDEM1D/include/KernelEM1DSpec.h Zobrazit soubor

@@ -37,14 +37,12 @@ namespace Lemma {
37 37
     template<EMMODE Mode, int Ikernel, DIPOLE_LOCATION Isource, DIPOLE_LOCATION Irecv>
38 38
     class KernelEM1DSpec : public KernelEM1DBase {
39 39
 
40
-        struct ctor_key {};
41
-
42 40
         public:
43 41
 
44 42
             // ====================  LIFECYCLE     =======================
45 43
 
46 44
             /// Default locked constructor.
47
-            explicit KernelEM1DSpec (const ctor_key& ) : KernelEM1DBase( ), ReflCalc(nullptr) {
45
+            explicit KernelEM1DSpec (const ctor_key& key ) : KernelEM1DBase( key ), ReflCalc(nullptr) {
48 46
             }
49 47
 
50 48
             /// Default destructor.
@@ -59,7 +57,7 @@ namespace Lemma {
59 57
             }
60 58
 
61 59
             static std::shared_ptr<KernelEM1DSpec> NewSP(LayeredEarthEM* Earth, std::shared_ptr<DipoleSource> Dipole,
62
-                                                                                        const int& ifreq, const Real& rz) {
60
+                                                         const int& ifreq, const Real& rz) {
63 61
                 auto Obj = std::make_shared< KernelEM1DSpec > ( ctor_key() );
64 62
 
65 63
                 // under this scenario KernelEM1DSpec manages its own Refl Base

+ 0
- 2
Modules/FDEM1D/include/LayeredEarthEM.h Zobrazit soubor

@@ -34,8 +34,6 @@ namespace Lemma {
34 34
         /** Recursively streams information about this class */
35 35
         friend std::ostream &operator<<(std::ostream &stream, const LayeredEarthEM &ob);
36 36
 
37
-        struct ctor_key {};
38
-
39 37
         public:
40 38
 
41 39
             // ====================  LIFECYCLE     ===========================

+ 0
- 2
Modules/FDEM1D/include/PolygonalWireAntenna.h Zobrazit soubor

@@ -29,8 +29,6 @@ namespace Lemma {
29 29
 
30 30
         friend std::ostream &operator<<(std::ostream &stream, const PolygonalWireAntenna &ob);
31 31
 
32
-        struct ctor_key {};
33
-
34 32
         public:
35 33
 
36 34
             // ====================  LIFECYCLE     =======================

+ 0
- 2
Modules/FDEM1D/include/QWEKey.h Zobrazit soubor

@@ -50,8 +50,6 @@ namespace Lemma {
50 50
 
51 51
         friend std::ostream &operator<<(std::ostream &stream, const QWEKey &ob);
52 52
 
53
-        struct ctor_key {};
54
-
55 53
         public:
56 54
 
57 55
         // ====================  LIFECYCLE     =======================

+ 0
- 3
Modules/FDEM1D/include/WireAntenna.h Zobrazit soubor

@@ -33,9 +33,6 @@ namespace Lemma {
33 33
 
34 34
         friend std::ostream &operator<<(std::ostream &stream, const WireAntenna &ob);
35 35
 
36
-        protected:
37
-        struct ctor_key {};
38
-
39 36
         public:
40 37
 
41 38
             // ====================  LIFECYCLE     =======================

+ 2
- 2
Modules/FDEM1D/src/DipoleSource.cpp Zobrazit soubor

@@ -26,14 +26,14 @@ namespace Lemma {
26 26
 
27 27
     // ====================    FRIENDS     ======================
28 28
     std::ostream &operator<<(std::ostream &stream, const DipoleSource &ob) {
29
-        stream << ob.Serialize()  << "\n---\n"; // End of doc ---
29
+        stream << ob.Serialize()  << "\n";
30 30
         return stream;
31 31
     }
32 32
 
33 33
 
34 34
     // ====================  LIFECYCLE     ======================
35 35
 
36
-    DipoleSource::DipoleSource( const ctor_key& ) : LemmaObject( ),
36
+    DipoleSource::DipoleSource( const ctor_key& key ) : LemmaObject( key ),
37 37
                     Type(NOSOURCETYPE),
38 38
                     irec(-1),
39 39
                     Phase(0),

+ 2
- 2
Modules/FDEM1D/src/EMEarth1D.cpp Zobrazit soubor

@@ -22,7 +22,7 @@
22 22
 namespace Lemma {
23 23
 
24 24
     std::ostream &operator << (std::ostream &stream, const EMEarth1D &ob) {
25
-        stream << ob.Serialize()  << "\n---\n"; // End of doc ---
25
+        stream << ob.Serialize()  << "\n";
26 26
         return stream;
27 27
     }
28 28
 
@@ -70,7 +70,7 @@ namespace Lemma {
70 70
     // ====================  LIFECYCLE     ===================================
71 71
 
72 72
     // TODO init large arrays here.
73
-    EMEarth1D::EMEarth1D( const ctor_key& ) : LemmaObject( ),
73
+    EMEarth1D::EMEarth1D( const ctor_key& key ) : LemmaObject( key ),
74 74
             Dipole(nullptr), Earth(nullptr), Receivers(nullptr), Antenna(nullptr),
75 75
             FieldsToCalculate(BOTH), HankelType(ANDERSON801), icalcinner(0), icalc(0)
76 76
         //#ifdef HAVEBOOSTPROGRESS

+ 3
- 3
Modules/FDEM1D/src/FHTAnderson801.cpp Zobrazit soubor

@@ -16,7 +16,7 @@
16 16
 namespace Lemma {
17 17
 
18 18
     std::ostream &operator << (std::ostream &stream, const FHTAnderson801 &ob) {
19
-        stream << ob.Serialize()  << "\n---\n"; // End of doc ---
19
+        stream << ob.Serialize()  << "\n";
20 20
         return stream;
21 21
     }
22 22
 
@@ -841,13 +841,13 @@ namespace Lemma {
841 841
 	const Real FHTAnderson801::ABSER = 0.904837418035959573;      // 1/exp(.1)
842 842
 
843 843
 	// ====================  LIFECYCLE     ==============================
844
-	FHTAnderson801::FHTAnderson801(const ctor_key& ) : HankelTransform( ),
844
+	FHTAnderson801::FHTAnderson801(const ctor_key& key ) : HankelTransform( key ),
845 845
 			             Lambda(0), NumFun(0),
846 846
 						 NumConv(0), NumRel(0),
847 847
 						 BesselOrder(-1),  Manager(nullptr) {
848 848
 	}
849 849
 
850
-    FHTAnderson801::FHTAnderson801( const YAML::Node& node, const ctor_key& ) : HankelTransform( ) {
850
+    FHTAnderson801::FHTAnderson801( const YAML::Node& node, const ctor_key& key ) : HankelTransform( key ) {
851 851
         Lambda = node["Lambda"].as<Real>();
852 852
         NumFun = node["NumFun"].as<int>();
853 853
 		NumConv = node["NumConv"].as<int>();

+ 3
- 3
Modules/FDEM1D/src/FHTKey101.cpp Zobrazit soubor

@@ -23,7 +23,7 @@ namespace Lemma {
23 23
     // ====================  FRIEND METHODS  =====================
24 24
 
25 25
     std::ostream &operator<<(std::ostream &stream, const FHTKey101 &ob) {
26
-        stream << ob.Serialize()  << "\n---\n"; // End of doc ---
26
+        stream << ob.Serialize()  << "\n";
27 27
         return stream;
28 28
     }
29 29
 
@@ -141,7 +141,7 @@ namespace Lemma {
141 141
     //      Method:  FHTKey101
142 142
     // Description:  constructor (locked)
143 143
     //--------------------------------------------------------------------------------------
144
-    FHTKey101::FHTKey101 ( const ctor_key& ) : HankelTransform( ) {
144
+    FHTKey101::FHTKey101 ( const ctor_key& key ) : HankelTransform( key ) {
145 145
 
146 146
     }  // -----  end of method FHTKey101::FHTKey101  (constructor)  -----
147 147
 
@@ -150,7 +150,7 @@ namespace Lemma {
150 150
     //      Method:  FHTKey101
151 151
     // Description:  constructor (protected)
152 152
     //--------------------------------------------------------------------------------------
153
-    FHTKey101::FHTKey101( const YAML::Node& node, const ctor_key& ) : HankelTransform(node) {
153
+    FHTKey101::FHTKey101( const YAML::Node& node, const ctor_key& key ) : HankelTransform(node, key) {
154 154
 
155 155
     }
156 156
 

+ 3
- 3
Modules/FDEM1D/src/FHTKey201.cpp Zobrazit soubor

@@ -22,7 +22,7 @@ namespace Lemma {
22 22
     // ====================  FRIEND METHODS  =====================
23 23
 
24 24
     std::ostream &operator<<(std::ostream &stream, const FHTKey201 &ob) {
25
-        stream << ob.Serialize()  << "\n---\n"; // End of doc ---
25
+        stream << ob.Serialize()  << "\n";
26 26
         return stream;
27 27
     }
28 28
 
@@ -240,7 +240,7 @@ namespace Lemma {
240 240
     //      Method:  FHTKey201
241 241
     // Description:  constructor (locked)
242 242
     //--------------------------------------------------------------------------------------
243
-    FHTKey201::FHTKey201 (const ctor_key& ) : HankelTransform( ) {
243
+    FHTKey201::FHTKey201 (const ctor_key& key ) : HankelTransform( key ) {
244 244
 
245 245
     }  // -----  end of method FHTKey201::FHTKey201  (constructor)  -----
246 246
 
@@ -249,7 +249,7 @@ namespace Lemma {
249 249
     //      Method:  FHTKey201
250 250
     // Description:  constructor (locked)
251 251
     //--------------------------------------------------------------------------------------
252
-    FHTKey201::FHTKey201( const YAML::Node& node, const ctor_key& ) : HankelTransform(node) {
252
+    FHTKey201::FHTKey201( const YAML::Node& node, const ctor_key& key) : HankelTransform(node, key) {
253 253
 
254 254
     }
255 255
 

+ 3
- 3
Modules/FDEM1D/src/FHTKey51.cpp Zobrazit soubor

@@ -24,7 +24,7 @@ namespace Lemma {
24 24
     // ====================  FRIEND METHODS  =====================
25 25
 
26 26
     std::ostream &operator<<(std::ostream &stream, const FHTKey51 &ob) {
27
-        stream << ob.Serialize()  << "\n---\n"; // End of doc ---
27
+        stream << ob.Serialize()  << "\n"; // End of doc ---
28 28
         return stream;
29 29
     }
30 30
 
@@ -92,7 +92,7 @@ namespace Lemma {
92 92
     //      Method:  FHTKey51
93 93
     // Description:  constructor (locked)
94 94
     //--------------------------------------------------------------------------------------
95
-    FHTKey51::FHTKey51 (const ctor_key& ) : HankelTransform( ) {
95
+    FHTKey51::FHTKey51 (const ctor_key& key ) : HankelTransform( key ) {
96 96
 
97 97
     }  // -----  end of method FHTKey51::FHTKey51  (constructor)  -----
98 98
 
@@ -101,7 +101,7 @@ namespace Lemma {
101 101
     //      Method:  FHTKey51
102 102
     // Description:  constructor (protected)
103 103
     //--------------------------------------------------------------------------------------
104
-    FHTKey51::FHTKey51( const YAML::Node& node, const ctor_key& ) : HankelTransform(node) {
104
+    FHTKey51::FHTKey51( const YAML::Node& node, const ctor_key& key ) : HankelTransform(node, key) {
105 105
 
106 106
     }
107 107
 

+ 3
- 3
Modules/FDEM1D/src/FieldPoints.cpp Zobrazit soubor

@@ -18,13 +18,13 @@ namespace Lemma {
18 18
     // ====================    FRIENDS     ======================
19 19
 
20 20
     std::ostream &operator << (std::ostream &stream, const FieldPoints &ob) {
21
-        stream << ob.Serialize()  << "\n---\n"; // End of doc ---
21
+        stream << ob.Serialize()  << "\n";
22 22
         return stream;
23 23
     }
24 24
 
25 25
     // ====================  LIFECYCLE     ===================================
26 26
 
27
-    FieldPoints::FieldPoints( const ctor_key& ) : LemmaObject( ),
27
+    FieldPoints::FieldPoints( const ctor_key& key ) : LemmaObject( key ),
28 28
         NumberOfPoints(0), NumberOfBinsE(0), NumberOfBinsH(0) {
29 29
     }
30 30
 
@@ -33,7 +33,7 @@ namespace Lemma {
33 33
     //      Method:  FieldPoints
34 34
     // Description:  constructor (protected)
35 35
     //--------------------------------------------------------------------------------------
36
-    FieldPoints::FieldPoints (const YAML::Node& node, const ctor_key&) : LemmaObject(node) {
36
+    FieldPoints::FieldPoints (const YAML::Node& node, const ctor_key& key) : LemmaObject(node, key) {
37 37
         //DeSerialize
38 38
         NumberOfPoints = node["NumberOfPoints"].as<int>();
39 39
         NumberOfBinsE = node["NumberOfBinsE"].as<int>();

+ 3
- 3
Modules/FDEM1D/src/GQChave.cpp Zobrazit soubor

@@ -22,7 +22,7 @@
22 22
 namespace Lemma{
23 23
 
24 24
     std::ostream &operator<<(std::ostream &stream, const GQChave &ob) {
25
-        stream << ob.Serialize()  << "\n---\n"; // End of doc ---
25
+        stream << ob.Serialize()  << "\n";
26 26
         return stream;
27 27
     }
28 28
 
@@ -264,12 +264,12 @@ namespace Lemma{
264 264
     const Real J1_X12 = -0.5382308663841630e-15;
265 265
 */
266 266
 
267
-    GQChave::GQChave( const ctor_key& ) : HankelTransform( ) {
267
+    GQChave::GQChave( const ctor_key& key ) : HankelTransform( key ) {
268 268
         karg.resize(255, 100);
269 269
         kern.resize(510, 100);
270 270
     }
271 271
 
272
-    GQChave::GQChave( const YAML::Node& node, const ctor_key& ) : HankelTransform(node) {
272
+    GQChave::GQChave( const YAML::Node& node, const ctor_key& key ) : HankelTransform(node, key) {
273 273
 
274 274
     }
275 275
 

+ 3
- 3
Modules/FDEM1D/src/HankelTransform.cpp Zobrazit soubor

@@ -16,14 +16,14 @@
16 16
 namespace Lemma {
17 17
 
18 18
     std::ostream &operator << (std::ostream &stream, const HankelTransform &ob) {
19
-        stream << ob.Serialize()  << "\n---\n"; // End of doc ---
19
+        stream << ob.Serialize()  << "\n";
20 20
         return stream;
21 21
     }
22 22
 
23
-	HankelTransform::HankelTransform( ) : LemmaObject( )	{
23
+	HankelTransform::HankelTransform( const ctor_key& key ) : LemmaObject( key )	{
24 24
 	}
25 25
 
26
-    HankelTransform::HankelTransform( const YAML::Node& node ) : LemmaObject( node )	{
26
+    HankelTransform::HankelTransform( const YAML::Node& node, const ctor_key& key  ) : LemmaObject( node, key )	{
27 27
 	}
28 28
 
29 29
 	HankelTransform::~HankelTransform( ) {

+ 2
- 2
Modules/FDEM1D/src/KernelEM1DManager.cpp Zobrazit soubor

@@ -15,13 +15,13 @@
15 15
 namespace Lemma {
16 16
 
17 17
     std::ostream &operator<<(std::ostream &stream, const KernelEM1DManager &ob) {
18
-        stream << ob.Serialize() << "\n---\n";
18
+        stream << ob.Serialize() << "\n";
19 19
         return stream;
20 20
     }
21 21
 
22 22
     // ====================  LIFECYCLE     =======================
23 23
 
24
-    KernelEM1DManager::KernelEM1DManager( const ctor_key& ) : LemmaObject( ), TEReflBase(nullptr),
24
+    KernelEM1DManager::KernelEM1DManager( const ctor_key& key ) : LemmaObject( key ), TEReflBase(nullptr),
25 25
         TMReflBase(nullptr), Earth(nullptr), Dipole(nullptr) {
26 26
     }
27 27
 

+ 3
- 3
Modules/FDEM1D/src/LayeredEarthEM.cpp Zobrazit soubor

@@ -16,16 +16,16 @@
16 16
 namespace Lemma {
17 17
 
18 18
     std::ostream &operator << (std::ostream &stream, const LayeredEarthEM &ob) {
19
-        stream << ob.Serialize()  << "\n---\n"; // End of doc ---
19
+        stream << ob.Serialize()  << "\n";
20 20
         return stream;
21 21
     }
22 22
 
23 23
     // ====================  LIFECYCLE     ===================================
24 24
 
25
-    LayeredEarthEM::LayeredEarthEM( const ctor_key& key ) : LayeredEarth( LayeredEarth::ctor_key() ) {
25
+    LayeredEarthEM::LayeredEarthEM( const ctor_key& key ) : LayeredEarth( key ) {
26 26
     }
27 27
 
28
-    LayeredEarthEM::LayeredEarthEM( const YAML::Node& node, const ctor_key& ) : LayeredEarth(node) {
28
+    LayeredEarthEM::LayeredEarthEM( const YAML::Node& node, const ctor_key& key ) : LayeredEarth(node, key) {
29 29
         SetNumberOfLayers(NumberOfLayers);
30 30
         LayerThickness = node["LayerThickness"].as<VectorXr>();
31 31
         if (node["LayerConductivity"]) {

+ 4
- 3
Modules/FDEM1D/src/PolygonalWireAntenna.cpp Zobrazit soubor

@@ -16,19 +16,20 @@
16 16
 namespace Lemma {
17 17
 
18 18
     std::ostream &operator << (std::ostream &stream, const PolygonalWireAntenna &ob) {
19
-        stream << ob.Serialize()  << "\n---\n"; // End of doc ---
19
+        stream << ob.Serialize()  << "\n";
20 20
         return stream;
21 21
     }
22 22
 
23 23
 	// ====================  LIFECYCLE     =======================
24 24
 
25
-	PolygonalWireAntenna::PolygonalWireAntenna( const ctor_key& key ) : WireAntenna( WireAntenna::ctor_key() ), minDipoleRatio(.15),
25
+	PolygonalWireAntenna::PolygonalWireAntenna( const ctor_key& key ) :
26
+            WireAntenna( key ), minDipoleRatio(.15),
26 27
    		minDipoleMoment(1e-6), maxDipoleMoment(1e1), rRepeat(1e10,1e10,1e10) {
27 28
 		Points.setZero();
28 29
         //rRepeat.setOnes();
29 30
 	}
30 31
 
31
-    PolygonalWireAntenna::PolygonalWireAntenna( const YAML::Node& node, const ctor_key& ) : WireAntenna(node, WireAntenna::ctor_key() ) {
32
+    PolygonalWireAntenna::PolygonalWireAntenna( const YAML::Node& node, const ctor_key& key) : WireAntenna(node, key ) {
32 33
         minDipoleRatio   = node["minDipoleRatio"].as<Real>();
33 34
         maxDipoleMoment  = node["maxDipoleMoment"].as<Real>();
34 35
         minDipoleMoment  = node["minDipoleMoment"].as<Real>();

+ 2
- 2
Modules/FDEM1D/src/QWEKey.cpp Zobrazit soubor

@@ -43,7 +43,7 @@ namespace Lemma {
43 43
     // Description:  constructor (protected)
44 44
     //--------------------------------------------------------------------------------------
45 45
     //
46
-    QWEKey::QWEKey (const ctor_key& ) : HankelTransform( ), RelTol(1e-12), AbsTol(1e-32), nQuad(61), nDelay(1),
46
+    QWEKey::QWEKey (const ctor_key& key) : HankelTransform( key ), RelTol(1e-12), AbsTol(1e-32), nQuad(61), nDelay(1),
47 47
     //QWEKey::QWEKey (const std::string& name) : HankelTransform(name), RelTol(1e-38), AbsTol(1e-48), nQuad(39), nDelay(5),
48 48
         nIntervalsMax(40) {
49 49
         BesselWeights( J0 ); // TODO experiment with zero weight (J0, J1) options, should be static one time method
@@ -54,7 +54,7 @@ namespace Lemma {
54 54
     //      Method:  QWEKey
55 55
     // Description:  constructor (locked)
56 56
     //--------------------------------------------------------------------------------------
57
-    QWEKey::QWEKey( const YAML::Node& node, const ctor_key& ) : HankelTransform(node) {
57
+    QWEKey::QWEKey( const YAML::Node& node, const ctor_key& key ) : HankelTransform(node, key) {
58 58
 
59 59
     }
60 60
 

+ 3
- 3
Modules/FDEM1D/src/WireAntenna.cpp Zobrazit soubor

@@ -16,17 +16,17 @@
16 16
 namespace Lemma {
17 17
 
18 18
     std::ostream &operator << (std::ostream &stream, const WireAntenna &ob) {
19
-        stream << ob.Serialize()  << "\n---\n"; // End of doc ---
19
+        stream << ob.Serialize()  << "\n";
20 20
         return stream;
21 21
     }
22 22
 
23 23
     // ====================  LIFECYCLE     =======================
24 24
 
25
-    WireAntenna::WireAntenna( const ctor_key& ) : LemmaObject( ),
25
+    WireAntenna::WireAntenna( const ctor_key& key ) : LemmaObject( key ),
26 26
         NumberOfPoints(0), Current(1), NumberOfTurns(1) {
27 27
     }
28 28
 
29
-    WireAntenna::WireAntenna( const YAML::Node& node, const ctor_key& ) : LemmaObject( node ) {
29
+    WireAntenna::WireAntenna( const YAML::Node& node, const ctor_key& key ) : LemmaObject( node, key ) {
30 30
         Points =  node["Points"].as<Vector3Xr>();
31 31
         Freqs = node["Freqs"].as<VectorXr>();
32 32
         NumberOfPoints = node["NumberOfPoints"].as<int>();

+ 3
- 4
Modules/LemmaCore/include/CubicSplineInterpolator.h Zobrazit soubor

@@ -12,9 +12,8 @@
12 12
  * @date      09/25/2013 08:20:14 AM
13 13
  * @version   $Id$
14 14
  * @author    Trevor Irons (ti)
15
- * @email     Trevor.Irons@xri-geo.com
16
- * @copyright Copyright (c) 2013, XRI Geophysics, LLC
17
- * @copyright Copyright (c) 2013, Trevor Irons
15
+ * @email     Trevor.Irons@lemmasoftware.org
16
+ * @copyright Copyright (c) 2013,2018 Trevor Irons
18 17
  */
19 18
 
20 19
 #ifndef  CUBICSPLINEINTERPOLATOR_INC
@@ -62,7 +61,7 @@ class CubicSplineInterpolator : public LemmaObject {
62 61
     friend std::ostream &operator<<(std::ostream &stream,
63 62
             const CubicSplineInterpolator& ob);
64 63
 
65
-    struct ctor_key {};
64
+    //struct ctor_key {};
66 65
 
67 66
     public:
68 67
 

+ 2
- 2
Modules/LemmaCore/include/Data.h Zobrazit soubor

@@ -70,10 +70,10 @@ namespace Lemma {
70 70
             // ====================  LIFECYCLE     =======================
71 71
 
72 72
             /** Default protected constructor. */
73
-            Data (  );
73
+            Data ( const ctor_key& key  );
74 74
 
75 75
             /** Deserializing contructor */
76
-            Data ( const YAML::Node& node );
76
+            Data ( const YAML::Node& node, const ctor_key& key );
77 77
 
78 78
             /** Default protected constructor. */
79 79
             ~Data ( );

+ 2
- 2
Modules/LemmaCore/include/DataReader.h Zobrazit soubor

@@ -53,10 +53,10 @@ class DataReader : public LemmaObject {
53 53
         // ====================  LIFECYCLE     =======================
54 54
 
55 55
         /// Default protected constructor.
56
-        DataReader ( );
56
+        DataReader ( const ctor_key& key );
57 57
 
58 58
         /// Default protected constructor.
59
-        DataReader ( const YAML::Node& node );
59
+        DataReader ( const YAML::Node& node, const ctor_key& key );
60 60
 
61 61
         /// Default protected constructor.
62 62
         ~DataReader ( );

+ 2
- 2
Modules/LemmaCore/include/EarthModel.h Zobrazit soubor

@@ -99,10 +99,10 @@ namespace Lemma {
99 99
             // ====================  LIFECYCLE     =======================
100 100
 
101 101
             /// Default protected constructor.
102
-            EarthModel ( );
102
+            EarthModel ( const ctor_key& );
103 103
 
104 104
             /** Deserialize constructor */
105
-            EarthModel (const YAML::Node& node);
105
+            EarthModel (const YAML::Node& node, const ctor_key&);
106 106
 
107 107
             /// Default protected constructor.
108 108
             ~EarthModel ();

+ 2
- 2
Modules/LemmaCore/include/Filter.h Zobrazit soubor

@@ -56,10 +56,10 @@ namespace Lemma {
56 56
             // ====================  LIFECYCLE     =======================
57 57
 
58 58
             /// Default protected constructor.
59
-            Filter ( );
59
+            Filter ( const ctor_key&  );
60 60
 
61 61
             /// Default protected constructor.
62
-            Filter ( const YAML::Node& node );
62
+            Filter ( const YAML::Node& node, const ctor_key& );
63 63
 
64 64
             /// Default protected constructor.
65 65
             virtual ~Filter ();

+ 2
- 2
Modules/LemmaCore/include/Grid.h Zobrazit soubor

@@ -53,10 +53,10 @@ class Grid : public LemmaObject {
53 53
         // ====================  LIFECYCLE     ===================================
54 54
 
55 55
         /** Protected DeDerializing constructor, use factory DeSerialize  method on non abstract classes*/
56
-        Grid (const YAML::Node& node);
56
+        Grid (const YAML::Node& node, const ctor_key& );
57 57
 
58 58
         /// Default protected constructor.
59
-        Grid ( );
59
+        Grid ( const ctor_key& );
60 60
 
61 61
         /// Default protected constructor.
62 62
         virtual ~Grid ( );

+ 2
- 2
Modules/LemmaCore/include/GridReader.h Zobrazit soubor

@@ -60,11 +60,11 @@ namespace Lemma {
60 60
             // ====================  LIFECYCLE     =======================
61 61
 
62 62
             /** Default protected constructor, use New */
63
-            GridReader ( ) : LemmaObject( ) {
63
+            GridReader ( const ctor_key& key ) : LemmaObject( key ) {
64 64
             }
65 65
 
66 66
             /** Default protected constructor, use New */
67
-            GridReader ( const YAML::Node& node ) : LemmaObject( node ) {
67
+            GridReader ( const YAML::Node& node, const ctor_key& key ) : LemmaObject( node, key ) {
68 68
             }
69 69
 
70 70
             /** Default protected constructor, use Delete */

+ 1
- 3
Modules/LemmaCore/include/LayeredEarth.h Zobrazit soubor

@@ -30,8 +30,6 @@ namespace Lemma {
30 30
         friend class LayeredEarthEM;
31 31
         friend class LayeredEarthMR;
32 32
 
33
-        struct ctor_key{};
34
-
35 33
 		public:
36 34
 
37 35
 			// ====================    FRIENDS     ===========================
@@ -107,7 +105,7 @@ namespace Lemma {
107 105
 			LayeredEarth ( const ctor_key& );
108 106
 
109 107
             /** Default protected constructor. */
110
-			LayeredEarth (const YAML::Node& node);
108
+			LayeredEarth (const YAML::Node& node, const ctor_key& key);
111 109
 
112 110
 			/** Default protected constructor. */
113 111
 			~LayeredEarth ();

+ 1
- 1
Modules/LemmaCore/include/RectilinearGrid.h Zobrazit soubor

@@ -34,7 +34,7 @@ namespace Lemma {
34 34
         /*
35 35
          *  This key is used to lock the constructors
36 36
          */
37
-        struct ctor_key {};
37
+        //struct ctor_key {};
38 38
 
39 39
         public:
40 40
 

+ 1
- 1
Modules/LemmaCore/include/RectilinearGridReader.h Zobrazit soubor

@@ -39,7 +39,7 @@ namespace Lemma {
39 39
         /*
40 40
          *  This key is used to lock the constructors
41 41
          */
42
-        struct ctor_key {};
42
+        //struct ctor_key {};
43 43
 
44 44
         public:
45 45
 

+ 1
- 1
Modules/LemmaCore/include/RectilinearGridVTKExporter.h Zobrazit soubor

@@ -45,7 +45,7 @@ class RectilinearGridVTKExporter : public LemmaObject {
45 45
     friend std::ostream &operator<<(std::ostream &stream,
46 46
             const RectilinearGridVTKExporter &ob);
47 47
 
48
-    struct ctor_key {};
48
+    //struct ctor_key {};
49 49
 
50 50
     public:
51 51
 

+ 1
- 1
Modules/LemmaCore/include/WindowFilter.h Zobrazit soubor

@@ -30,7 +30,7 @@ namespace Lemma {
30 30
 
31 31
         friend std::ostream &operator<<(std::ostream &stream, const WindowFilter& ob);
32 32
 
33
-        struct ctor_key {};
33
+        //struct ctor_key {};
34 34
 
35 35
         public:
36 36
 

+ 4
- 4
Modules/LemmaCore/src/CubicSplineInterpolator.cpp Zobrazit soubor

@@ -12,8 +12,8 @@
12 12
  * @date      02/07/2014 12:50:52 PM
13 13
  * @version   $Id$
14 14
  * @author    Trevor Irons (ti)
15
- * @email     Trevor.Irons@xri-geo.com
16
- * @copyright Copyright (c) 2014, Trevor Irons
15
+ * @email     Trevor.Irons@lemmasoftware.org
16
+ * @copyright Copyright (c) 2014,2018 Trevor Irons
17 17
  */
18 18
 
19 19
 #include "CubicSplineInterpolator.h"
@@ -40,7 +40,7 @@ namespace Lemma {
40 40
     //      Method:  CubicSplineInterpolator
41 41
     // Description:  constructor (locked with ctor_key)
42 42
     //--------------------------------------------------------------------------------------
43
-    CubicSplineInterpolator::CubicSplineInterpolator ( const ctor_key& ) : LemmaObject( ) {
43
+    CubicSplineInterpolator::CubicSplineInterpolator ( const ctor_key& key ) : LemmaObject( key ) {
44 44
 
45 45
     }  // -----  end of method CubicSplineInterpolator::CubicSplineInterpolator  (constructor)  -----
46 46
 
@@ -49,7 +49,7 @@ namespace Lemma {
49 49
     //      Method:  CubicSplineInterpolator
50 50
     // Description:  DeSerializing constructor (locked with ctor_key)
51 51
     //--------------------------------------------------------------------------------------
52
-    CubicSplineInterpolator::CubicSplineInterpolator (const YAML::Node& node, const ctor_key& ) : LemmaObject(node) {
52
+    CubicSplineInterpolator::CubicSplineInterpolator (const YAML::Node& node, const ctor_key& key ) : LemmaObject(node, key) {
53 53
     }  // -----  end of method CubicSplineInterpolator::CubicSplineInterpolator  (constructor)  -----
54 54
 
55 55
     //--------------------------------------------------------------------------------------

+ 3
- 3
Modules/LemmaCore/src/Data.cpp Zobrazit soubor

@@ -16,14 +16,14 @@
16 16
 namespace Lemma {
17 17
 
18 18
     std::ostream &operator << (std::ostream &stream, const Data &ob) {
19
-        stream << ob.Serialize()  << "\n---\n"; // End of doc --- as a direct stream should encapulste thingy
19
+        stream << ob.Serialize()  << "\n";
20 20
         return stream;
21 21
     }
22 22
 
23
-	Data::Data(  ) : LemmaObject( ) {
23
+	Data::Data( const ctor_key& key  ) : LemmaObject( key ) {
24 24
 	}
25 25
 
26
-    Data::Data( const YAML::Node& node ) : LemmaObject( node ) {
26
+    Data::Data( const YAML::Node& node, const ctor_key& key ) : LemmaObject( node, key ) {
27 27
 	}
28 28
 
29 29
 

+ 3
- 3
Modules/LemmaCore/src/DataReader.cpp Zobrazit soubor

@@ -16,15 +16,15 @@
16 16
 namespace Lemma {
17 17
 
18 18
     std::ostream &operator << (std::ostream &stream, const DataReader &ob) {
19
-        stream << ob.Serialize()  << "\n---\n"; // End of doc --- as a direct stream should encapulste thingy
19
+        stream << ob.Serialize()  << "\n";
20 20
         return stream;
21 21
     }
22 22
 
23
-	DataReader::DataReader( ) : LemmaObject( ) {
23
+	DataReader::DataReader( const ctor_key& key ) : LemmaObject( key ) {
24 24
 
25 25
 	}
26 26
 
27
-    DataReader::DataReader( const YAML::Node& node ) : LemmaObject( node ) {
27
+    DataReader::DataReader( const YAML::Node& node, const ctor_key& key ) : LemmaObject( node, key ) {
28 28
 
29 29
 	}
30 30
 

+ 3
- 3
Modules/LemmaCore/src/EarthModel.cpp Zobrazit soubor

@@ -16,17 +16,17 @@
16 16
 namespace Lemma {
17 17
 
18 18
     std::ostream &operator << (std::ostream &stream, const EarthModel &ob) {
19
-        stream << ob.Serialize()  << "\n---\n"; // End of doc --- as a direct stream should encapulste thingy
19
+        stream << ob.Serialize()  << "\n";
20 20
         return stream;
21 21
     }
22 22
 
23 23
 	// ====================  LIFECYCLE     =======================
24 24
 
25
-	EarthModel::EarthModel() : LemmaObject( ),
25
+	EarthModel::EarthModel( const ctor_key& key ) : LemmaObject( key ),
26 26
         BField(0,0,0), BFieldUnit(0,0,0), BInc(0), BDec(0), BMag(0) {
27 27
 	}
28 28
 
29
-    EarthModel::EarthModel(const YAML::Node& node) : LemmaObject(node) {
29
+    EarthModel::EarthModel(const YAML::Node& node, const ctor_key& key) : LemmaObject(node, key) {
30 30
         BInc = node["BInc"].as<double>();
31 31
         BDec = node["BDec"].as<double>();
32 32
         BMag = node["BMag"].as<double>();

+ 2
- 2
Modules/LemmaCore/src/Filter.cpp Zobrazit soubor

@@ -25,7 +25,7 @@ namespace Lemma {
25 25
     //      Method:  Filter
26 26
     // Description:  constructor (protected)
27 27
     //--------------------------------------------------------------------------------------
28
-    Filter::Filter( ) : LemmaObject( ) { }
28
+    Filter::Filter( const ctor_key& key ) : LemmaObject( key ) { }
29 29
 
30 30
     //--------------------------------------------------------------------------------------
31 31
     //       Class:  Filter
@@ -39,7 +39,7 @@ namespace Lemma {
39 39
     //      Method:  Filter
40 40
     // Description:  DeSerializing constructor (protected)
41 41
     //--------------------------------------------------------------------------------------
42
-    Filter::Filter ( const YAML::Node& node ) : LemmaObject(node) {
42
+    Filter::Filter ( const YAML::Node& node, const ctor_key& key ) : LemmaObject(node, key) {
43 43
     }
44 44
 
45 45
     //--------------------------------------------------------------------------------------

+ 2
- 2
Modules/LemmaCore/src/Grid.cpp Zobrazit soubor

@@ -22,10 +22,10 @@ namespace Lemma {
22 22
 
23 23
     // ====================  LIFECYCLE     ===================================
24 24
 
25
-	Grid::Grid( ) : LemmaObject( ) {
25
+	Grid::Grid( const ctor_key& key ) : LemmaObject( key ) {
26 26
 	}
27 27
 
28
-    Grid::Grid( const YAML::Node& node ) : LemmaObject(node) {
28
+    Grid::Grid( const YAML::Node& node, const ctor_key& key ) : LemmaObject(node, key) {
29 29
 
30 30
     }
31 31
 

+ 3
- 3
Modules/LemmaCore/src/LayeredEarth.cpp Zobrazit soubor

@@ -18,20 +18,20 @@ namespace Lemma {
18 18
 	// ====================    FRIENDS     ======================
19 19
 
20 20
     std::ostream &operator << (std::ostream &stream, const LayeredEarth &ob) {
21
-        stream << ob.Serialize()  << "\n---\n"; // End of doc
21
+        stream << ob.Serialize()  << "\n";
22 22
         return stream;
23 23
     }
24 24
 
25 25
 	// ====================  LIFECYCLE     ===================================
26 26
 
27
-	LayeredEarth::LayeredEarth( const ctor_key& key ) : EarthModel( ),
27
+	LayeredEarth::LayeredEarth( const ctor_key& key ) : EarthModel( key ),
28 28
 		NumberOfLayers(0), 	NumberOfInterfaces(0) {
29 29
 	}
30 30
 
31 31
 	LayeredEarth::~LayeredEarth() {
32 32
 	}
33 33
 
34
-    LayeredEarth::LayeredEarth(const YAML::Node& node) : EarthModel(node) {
34
+    LayeredEarth::LayeredEarth(const YAML::Node& node, const ctor_key& key) : EarthModel(node, key) {
35 35
         NumberOfLayers = node["NumberOfLayers"].as<int>();
36 36
         NumberOfInterfaces = node["NumberOfInterfaces"].as<int>();
37 37
         LayerThickness = node["LayerThickness"].as<VectorXr>();

+ 2
- 2
Modules/LemmaCore/src/RectilinearGrid.cpp Zobrazit soubor

@@ -22,11 +22,11 @@ namespace Lemma {
22 22
 
23 23
     // ====================  LIFECYCLE     =======================
24 24
 
25
-    RectilinearGrid::RectilinearGrid( const ctor_key& ) : Grid( ), nx(0), ny(0), nz(0) {
25
+    RectilinearGrid::RectilinearGrid( const ctor_key& key ) : Grid( key ), nx(0), ny(0), nz(0) {
26 26
 
27 27
     }
28 28
 
29
-    RectilinearGrid::RectilinearGrid( const YAML::Node& node, const ctor_key& ) : Grid(node) {
29
+    RectilinearGrid::RectilinearGrid( const YAML::Node& node, const ctor_key& key ) : Grid(node, key) {
30 30
 
31 31
         nx = node["nx"].as<int>( );
32 32
         ny = node["ny"].as<int>( );

+ 2
- 2
Modules/LemmaCore/src/RectilinearGridReader.cpp Zobrazit soubor

@@ -33,7 +33,7 @@ namespace Lemma {
33 33
     //      Method:  RectilinearGridReader
34 34
     // Description:  constructor (locked)
35 35
     //--------------------------------------------------------------------------------------
36
-    RectilinearGridReader::RectilinearGridReader ( const ctor_key& ) : GridReader( ),
36
+    RectilinearGridReader::RectilinearGridReader ( const ctor_key& key ) : GridReader( key ),
37 37
         rGrid( nullptr ), Parser( nullptr ) {
38 38
 
39 39
     }  // -----  end of method RectilinearGridReader::RectilinearGridReader  (constructor)  -----
@@ -43,7 +43,7 @@ namespace Lemma {
43 43
     //      Method:  RectilinearGridReader
44 44
     // Description:  DeSerializing constructor (protected)
45 45
     //--------------------------------------------------------------------------------------
46
-    RectilinearGridReader::RectilinearGridReader (const YAML::Node& node, const ctor_key&  key) : GridReader(node) {
46
+    RectilinearGridReader::RectilinearGridReader (const YAML::Node& node, const ctor_key&  key) : GridReader(node, key) {
47 47
     }  // -----  end of method RectilinearGridReader::RectilinearGridReader  (constructor)  -----
48 48
 
49 49
     //--------------------------------------------------------------------------------------

+ 2
- 2
Modules/LemmaCore/src/RectilinearGridVTKExporter.cpp Zobrazit soubor

@@ -36,7 +36,7 @@ std::ostream &operator << (std::ostream &stream, const RectilinearGridVTKExporte
36 36
 //      Method:  RectilinearGridVTKExporter
37 37
 // Description:  constructor (protected)
38 38
 //--------------------------------------------------------------------------------------
39
-RectilinearGridVTKExporter::RectilinearGridVTKExporter ( const ctor_key& ) : LemmaObject( ), Grid(nullptr), VTKGrid(nullptr) {
39
+RectilinearGridVTKExporter::RectilinearGridVTKExporter ( const ctor_key& key ) : LemmaObject( key ), Grid(nullptr), VTKGrid(nullptr) {
40 40
 
41 41
 }  // -----  end of method RectilinearGridVTKExporter::RectilinearGridVTKExporter  (constructor)  -----
42 42
 
@@ -45,7 +45,7 @@ RectilinearGridVTKExporter::RectilinearGridVTKExporter ( const ctor_key& ) : Lem
45 45
 //      Method:  RectilinearGridVTKExporter
46 46
 // Description:  DeSerializing constructor (protected)
47 47
 //--------------------------------------------------------------------------------------
48
-RectilinearGridVTKExporter::RectilinearGridVTKExporter (const YAML::Node& node, const ctor_key&  key) : LemmaObject(node) {
48
+RectilinearGridVTKExporter::RectilinearGridVTKExporter (const YAML::Node& node, const ctor_key&  key) : LemmaObject(node, key) {
49 49
     if (node["Grid"]) {
50 50
         this->Grid = RectilinearGrid::DeSerialize( node["Grid"] );
51 51
     }

+ 3
- 3
Modules/LemmaCore/src/WindowFilter.cpp Zobrazit soubor

@@ -18,7 +18,7 @@ namespace Lemma {
18 18
     // ====================  FRIEND METHODS  =====================
19 19
 
20 20
     std::ostream &operator << (std::ostream &stream, const WindowFilter &ob) {
21
-        stream << ob.Serialize()  << "\n---\n"; // End of doc --- as a direct stream should encapulste thingy
21
+        stream << ob.Serialize()  << "\n";
22 22
         return stream;
23 23
     }
24 24
 
@@ -29,7 +29,7 @@ namespace Lemma {
29 29
     //      Method:  WindowFilter
30 30
     // Description:  constructor (locked with ctor_key)
31 31
     //--------------------------------------------------------------------------------------
32
-    WindowFilter::WindowFilter( const ctor_key& ) : Filter( ),
32
+    WindowFilter::WindowFilter( const ctor_key& key ) : Filter( key ),
33 33
         Width(0), SamplingRate(0), Bandwidth(0), Coefficients(), Type(RECTANGULAR)
34 34
     {
35 35
     }   // -----  end of method WindowFilter::WindowFilter  (constructor)  -----
@@ -39,7 +39,7 @@ namespace Lemma {
39 39
     //      Method:  WindowFilter
40 40
     // Description:  DeSerializing constructor (locked with ctor_key)
41 41
     //--------------------------------------------------------------------------------------
42
-    WindowFilter::WindowFilter( const YAML::Node& node, const ctor_key& ) : Filter( node ),
42
+    WindowFilter::WindowFilter( const YAML::Node& node, const ctor_key& key) : Filter( node, key ),
43 43
         Width(0), SamplingRate(0), Bandwidth(0), Coefficients(), Type(RECTANGULAR)
44 44
     {
45 45
         Width = node["Width"].as<int>( );

Načítá se…
Zrušit
Uložit