Browse Source

Adding CircularLoop for optmized use cases

submodule
Trevor Irons 4 years ago
parent
commit
a2dc7df0c6

+ 134
- 0
Modules/FDEM1D/include/CircularLoop.h View File

@@ -0,0 +1,134 @@
1
+/* This file is part of Lemma, a geophysical modelling and inversion API.
2
+ * More information is available at http://lemmasoftware.org
3
+ */
4
+
5
+/* This Source Code Form is subject to the terms of the Mozilla Public
6
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
7
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8
+ */
9
+
10
+/**
11
+ * @file
12
+ * @date      02/01/2018 10:24:02 AM
13
+ * @version   $Id$
14
+ * @author    Trevor Irons (ti)
15
+ * @email     tirons@egi.utah.edu
16
+ * @copyright Copyright (c) 2018, University of Utah
17
+ * @copyright Copyright (c) 2018, Lemma Software, LLC
18
+ */
19
+
20
+#ifndef  CIRCULARLOOP_INC
21
+#define  CIRCULARLOOP_INC
22
+
23
+#pragma once
24
+#include "CompactSupportEMSource.h"
25
+
26
+namespace Lemma {
27
+
28
+    /**
29
+     * \ingroup FDEM1D
30
+     * \brief   Analytic solution of a circular loop.
31
+     * \details This specialized class provides the EM response of a circular loop on the surface of the earth.
32
+     *          More general use cases can use PolygonalWireAntenna.
33
+     */
34
+    class CircularLoop : public CompactSupportEMSource {
35
+
36
+        friend std::ostream &operator<<(std::ostream &stream, const CircularLoop &ob);
37
+
38
+        protected:
39
+        /*
40
+         *  This key is used to lock the constructor. It is protected so that inhereted
41
+         *  classes also have the key to contruct their base class.
42
+         */
43
+        struct ctor_key {};
44
+
45
+        public:
46
+
47
+        // ====================  LIFECYCLE     =======================
48
+
49
+        /**
50
+         * Default constructor.
51
+         * @note This method is locked, and cannot be called directly.
52
+         *       The reason that the method is public is to enable the use
53
+         *       of make_shared whilst enforcing the use of shared_ptr,
54
+         *       in c++-17, this curiosity may be resolved.
55
+         * @see CircularLoop::NewSP
56
+         */
57
+        explicit CircularLoop ( const ctor_key& );
58
+
59
+        /**
60
+         * DeSerializing constructor.
61
+         * @note This method is locked, and cannot be called directly.
62
+         *       The reason that the method is public is to enable the use
63
+         *       of make_shared whilst enforcing the use of shared_ptr,
64
+         *       in c++-17, this curiosity may be resolved.
65
+         * @see CircularLoop::DeSerialize
66
+         */
67
+        CircularLoop ( const YAML::Node& node, const ctor_key& );
68
+
69
+        /**
70
+         * Default destructor.
71
+         * @note This method should never be called due to the mandated
72
+         *       use of smart pointers. It is necessary to keep the method
73
+         *       public in order to allow for the use of the more efficient
74
+         *       make_shared constructor.
75
+         */
76
+        virtual ~CircularLoop ();
77
+
78
+        /**
79
+         *  Uses YAML to serialize this object.
80
+         *  @return a YAML::Node
81
+         *  @see CircularLoop::DeSerialize
82
+         */
83
+        virtual YAML::Node Serialize() const;
84
+
85
+        /*
86
+         *  Factory method for generating concrete class.
87
+         *  @return a std::shared_ptr of type CircularLoop
88
+         */
89
+        static std::shared_ptr< CircularLoop > NewSP();
90
+
91
+        /**
92
+         *   Constructs an CircularLoop object from a YAML::Node.
93
+         *   @see CircularLoop::Serialize
94
+         */
95
+        static std::shared_ptr<CircularLoop> DeSerialize(const YAML::Node& node);
96
+
97
+        // ====================  OPERATORS     =======================
98
+
99
+        // ====================  OPERATIONS    =======================
100
+
101
+        // ====================  ACCESS        =======================
102
+
103
+        // ====================  INQUIRY       =======================
104
+        /**
105
+         *  Returns the name of the underlying class, similiar to Python's type
106
+         *  @return string of class name
107
+         */
108
+        virtual inline std::string GetName() const {
109
+            return CName;
110
+        }
111
+
112
+        protected:
113
+
114
+        // ====================  LIFECYCLE     =======================
115
+
116
+        /** Copy is disabled */
117
+        CircularLoop( const CircularLoop& ) = delete;
118
+
119
+        // ====================  DATA MEMBERS  =========================
120
+
121
+        private:
122
+
123
+        /** ASCII string representation of the class name */
124
+        static constexpr auto CName = "CircularLoop";
125
+
126
+    }; // -----  end of class  CircularLoop  -----
127
+}  // -----  end of namespace Lemma ----
128
+
129
+/* vim: set tabstop=4 expandtab: */
130
+/* vim: set filetype=cpp: */
131
+
132
+
133
+#endif   // ----- #ifndef CIRCULARLOOP_INC  -----
134
+

+ 133
- 0
Modules/FDEM1D/include/CompactSupportEMSource.h View File

@@ -0,0 +1,133 @@
1
+/* This file is part of Lemma, a geophysical modelling and inversion API.
2
+ * More information is available at http://lemmasoftware.org
3
+ */
4
+
5
+/* This Source Code Form is subject to the terms of the Mozilla Public
6
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
7
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8
+ */
9
+
10
+/**
11
+ * @file
12
+ * @date      02/01/2018 08:26:44 AM
13
+ * @version   $Id$
14
+ * @author    Trevor Irons (ti)
15
+ * @email     tirons@egi.utah.edu
16
+ * @copyright Copyright (c) 2018, University of Utah
17
+ * @copyright Copyright (c) 2018, Lemma Software, LLC
18
+ */
19
+
20
+#ifndef  COMPACTSUPPORTEMSOURCE_INC
21
+#define  COMPACTSUPPORTEMSOURCE_INC
22
+
23
+#pragma once
24
+#include "LemmaObject.h"
25
+
26
+namespace Lemma {
27
+
28
+    /**
29
+     * \ingroup FDEM1D
30
+     * \brief   Abstract base class representing an EM source.
31
+     * \details Derived types include simple dipoles, as well as line sources or wire loops.
32
+     */
33
+    class CompactSupportEMSource : public LemmaObject {
34
+
35
+        friend std::ostream &operator<<(std::ostream &stream, const CompactSupportEMSource &ob);
36
+
37
+        protected:
38
+        /*
39
+         *  This key is used to lock the constructor. It is protected so that inhereted
40
+         *  classes also have the key to contruct their base class.
41
+         */
42
+        struct ctor_key {};
43
+
44
+        public:
45
+
46
+        // ====================  LIFECYCLE     =======================
47
+
48
+        /**
49
+         * Default constructor.
50
+         * @note This method is locked, and cannot be called directly.
51
+         *       The reason that the method is public is to enable the use
52
+         *       of make_shared whilst enforcing the use of shared_ptr,
53
+         *       in c++-17, this curiosity may be resolved.
54
+         * @see CompactSupportEMSource::NewSP
55
+         */
56
+        explicit CompactSupportEMSource ( const ctor_key& );
57
+
58
+        /**
59
+         * DeSerializing constructor.
60
+         * @note This method is locked, and cannot be called directly.
61
+         *       The reason that the method is public is to enable the use
62
+         *       of make_shared whilst enforcing the use of shared_ptr,
63
+         *       in c++-17, this curiosity may be resolved.
64
+         * @see CompactSupportEMSource::DeSerialize
65
+         */
66
+        CompactSupportEMSource ( const YAML::Node& node, const ctor_key& );
67
+
68
+        /**
69
+         * Default destructor.
70
+         * @note This method should never be called due to the mandated
71
+         *       use of smart pointers. It is necessary to keep the method
72
+         *       public in order to allow for the use of the more efficient
73
+         *       make_shared constructor.
74
+         */
75
+        virtual ~CompactSupportEMSource ();
76
+
77
+        /**
78
+         *  Uses YAML to serialize this object.
79
+         *  @return a YAML::Node
80
+         *  @see CompactSupportEMSource::DeSerialize
81
+         */
82
+        virtual YAML::Node Serialize() const;
83
+
84
+        /*
85
+         *  Factory method for generating concrete class.
86
+         *  @return a std::shared_ptr of type CompactSupportEMSource
87
+         */
88
+        static std::shared_ptr< CompactSupportEMSource > NewSP();
89
+
90
+        /**
91
+         *   Constructs an CompactSupportEMSource object from a YAML::Node.
92
+         *   @see CompactSupportEMSource::Serialize
93
+         */
94
+        static std::shared_ptr<CompactSupportEMSource> DeSerialize(const YAML::Node& node);
95
+
96
+        // ====================  OPERATORS     =======================
97
+
98
+        // ====================  OPERATIONS    =======================
99
+
100
+        // ====================  ACCESS        =======================
101
+
102
+        // ====================  INQUIRY       =======================
103
+        /**
104
+         *  Returns the name of the underlying class, similiar to Python's type
105
+         *  @return string of class name
106
+         */
107
+        virtual inline std::string GetName() const {
108
+            return CName;
109
+        }
110
+
111
+        protected:
112
+
113
+        // ====================  LIFECYCLE     =======================
114
+
115
+        /** Copy is disabled */
116
+        CompactSupportEMSource( const CompactSupportEMSource& ) = delete;
117
+
118
+        // ====================  DATA MEMBERS  =========================
119
+
120
+        private:
121
+
122
+        /** ASCII string representation of the class name */
123
+        static constexpr auto CName = "CompactSupportEMSource";
124
+
125
+    }; // -----  end of class  CompactSupportEMSource  -----
126
+}  // -----  end of namespace Lemma ----
127
+
128
+/* vim: set tabstop=4 expandtab: */
129
+/* vim: set filetype=cpp: */
130
+
131
+
132
+#endif   // ----- #ifndef COMPACTSUPPORTEMSOURCE_INC  -----
133
+

+ 2
- 0
Modules/FDEM1D/include/FDEM1D View File

@@ -3,6 +3,8 @@
3 3
 
4 4
 #include "FieldPoints.h"
5 5
 
6
+#include "CircularLoop.h"
7
+
6 8
 #include "WireAntenna.h"
7 9
 #include "PolygonalWireAntenna.h"
8 10
 

+ 2
- 1
Modules/FDEM1D/include/WireAntenna.h View File

@@ -24,7 +24,8 @@ namespace Lemma {
24 24
 
25 25
 
26 26
     // ===================================================================
27
-    /**      Class:  WireAntenna
27
+    /**
28
+      * \ingroup FDEM1D
28 29
       * \brief   Class representing a wire antennae.
29 30
       * \details This is an abstract class.
30 31
 	  */

+ 16
- 3
Modules/FDEM1D/src/CMakeLists.txt View File

@@ -1,30 +1,43 @@
1 1
 set (FDEM1DSOURCE
2 2
 	${FDEM1DSOURCE}
3 3
 
4
+	# model space
4 5
 	${CMAKE_CURRENT_SOURCE_DIR}/LayeredEarthEM.cpp
5 6
 	${CMAKE_CURRENT_SOURCE_DIR}/LayeredEarthEMReader.cpp
6 7
 	
8
+	# Calculation points
7 9
 	${CMAKE_CURRENT_SOURCE_DIR}/FieldPoints.cpp
8
-	
10
+
11
+	# Sources	
12
+	${CMAKE_CURRENT_SOURCE_DIR}/CompactSupportEMSource.cpp
13
+	${CMAKE_CURRENT_SOURCE_DIR}/CircularLoop.cpp
14
+
9 15
 	${CMAKE_CURRENT_SOURCE_DIR}/DipoleSource.cpp
10 16
 	${CMAKE_CURRENT_SOURCE_DIR}/WireAntenna.cpp
11 17
 	${CMAKE_CURRENT_SOURCE_DIR}/PolygonalWireAntenna.cpp
12
-	
18
+
19
+	# Kernel management	
13 20
 	${CMAKE_CURRENT_SOURCE_DIR}/KernelEM1DManager.cpp
14 21
 	${CMAKE_CURRENT_SOURCE_DIR}/KernelEM1DSpec.cpp
15 22
 	${CMAKE_CURRENT_SOURCE_DIR}/KernelEM1DReflSpec.cpp
16 23
 
24
+	#####################
25
+	# Hankel transforms #
26
+	#####################
27
+	# FHT
17 28
 	${CMAKE_CURRENT_SOURCE_DIR}/HankelTransform.cpp
18 29
 	${CMAKE_CURRENT_SOURCE_DIR}/FHTAnderson801.cpp
19 30
 	${CMAKE_CURRENT_SOURCE_DIR}/FHTKey201.cpp
20 31
 	${CMAKE_CURRENT_SOURCE_DIR}/FHTKey101.cpp
21 32
 	${CMAKE_CURRENT_SOURCE_DIR}/FHTKey51.cpp
22
-
33
+	# Gaussian Quadrature
23 34
 	${CMAKE_CURRENT_SOURCE_DIR}/GQChave.cpp
24 35
 	${CMAKE_CURRENT_SOURCE_DIR}/QWEKey.cpp
25 36
 	
37
+	# Calculation
26 38
 	${CMAKE_CURRENT_SOURCE_DIR}/EMEarth1D.cpp
27 39
 
40
+	# AEM 
28 41
 	${CMAKE_CURRENT_SOURCE_DIR}/AEMSurvey.cpp
29 42
 	${CMAKE_CURRENT_SOURCE_DIR}/AEMSurveyReader.cpp
30 43
 	

+ 96
- 0
Modules/FDEM1D/src/CircularLoop.cpp View File

@@ -0,0 +1,96 @@
1
+/* This file is part of Lemma, a geophysical modelling and inversion API.
2
+ * More information is available at http://lemmasoftware.org
3
+ */
4
+
5
+/* This Source Code Form is subject to the terms of the Mozilla Public
6
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
7
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8
+ */
9
+
10
+/**
11
+ * @file
12
+ * @date      02/01/2018 10:45:39 AM
13
+ * @version   $Id$
14
+ * @author    Trevor Irons (ti)
15
+ * @email     tirons@egi.utah.edu
16
+ * @copyright Copyright (c) 2018, University of Utah
17
+ * @copyright Copyright (c) 2018, Lemma Software, LLC
18
+ */
19
+
20
+#include "CircularLoop.h"
21
+
22
+namespace Lemma {
23
+
24
+    // ====================  FRIEND METHODS  =====================
25
+
26
+    std::ostream &operator << (std::ostream &stream, const CircularLoop &ob) {
27
+        stream << ob.Serialize()  << "\n---\n"; // End of doc ---
28
+        return stream;
29
+    }
30
+
31
+    // ====================  LIFECYCLE     =======================
32
+
33
+    //--------------------------------------------------------------------------------------
34
+    //       Class:  CircularLoop
35
+    //      Method:  CircularLoop
36
+    // Description:  constructor (locked)
37
+    //--------------------------------------------------------------------------------------
38
+    CircularLoop::CircularLoop (const ctor_key&) : CompactSupportEMSource( CompactSupportEMSource::ctor_key()  ) {
39
+
40
+    }  // -----  end of method CircularLoop::CircularLoop  (constructor)  -----
41
+
42
+    //--------------------------------------------------------------------------------------
43
+    //       Class:  CircularLoop
44
+    //      Method:  CircularLoop
45
+    // Description:  DeSerializing constructor (locked)
46
+    //--------------------------------------------------------------------------------------
47
+    CircularLoop::CircularLoop (const YAML::Node& node, const ctor_key&) : CompactSupportEMSource(node, CompactSupportEMSource::ctor_key()) {
48
+
49
+    }  // -----  end of method CircularLoop::CircularLoop  (constructor)  -----
50
+
51
+    //--------------------------------------------------------------------------------------
52
+    //       Class:  CircularLoop
53
+    //      Method:  NewSP()
54
+    // Description:  public constructor returing a shared_ptr
55
+    //--------------------------------------------------------------------------------------
56
+    std::shared_ptr< CircularLoop >  CircularLoop::NewSP() {
57
+        return std::make_shared< CircularLoop >( ctor_key() );
58
+    }
59
+
60
+    //--------------------------------------------------------------------------------------
61
+    //       Class:  CircularLoop
62
+    //      Method:  ~CircularLoop
63
+    // Description:  destructor (protected)
64
+    //--------------------------------------------------------------------------------------
65
+    CircularLoop::~CircularLoop () {
66
+
67
+    }  // -----  end of method CircularLoop::~CircularLoop  (destructor)  -----
68
+
69
+    //--------------------------------------------------------------------------------------
70
+    //       Class:  CircularLoop
71
+    //      Method:  Serialize
72
+    //--------------------------------------------------------------------------------------
73
+    YAML::Node  CircularLoop::Serialize (  ) const {
74
+        YAML::Node node = CompactSupportEMSource::Serialize();
75
+        node.SetTag( GetName() );
76
+        // FILL IN CLASS SPECIFICS HERE
77
+        return node;
78
+    }		// -----  end of method CircularLoop::Serialize  -----
79
+
80
+    //--------------------------------------------------------------------------------------
81
+    //       Class:  CircularLoop
82
+    //      Method:  DeSerialize
83
+    //--------------------------------------------------------------------------------------
84
+    std::shared_ptr<CircularLoop> CircularLoop::DeSerialize ( const YAML::Node& node  ) {
85
+        if (node.Tag() !=  "CircularLoop" ) {
86
+            throw  DeSerializeTypeMismatch( "CircularLoop", node.Tag());
87
+        }
88
+        return std::make_shared< CircularLoop > ( node, ctor_key() );
89
+    }		// -----  end of method CircularLoop::DeSerialize  -----
90
+
91
+} // ----  end of namespace Lemma  ----
92
+
93
+/* vim: set tabstop=4 expandtab: */
94
+/* vim: set filetype=cpp: */
95
+
96
+

+ 96
- 0
Modules/FDEM1D/src/CompactSupportEMSource.cpp View File

@@ -0,0 +1,96 @@
1
+/* This file is part of Lemma, a geophysical modelling and inversion API.
2
+ * More information is available at http://lemmasoftware.org
3
+ */
4
+
5
+/* This Source Code Form is subject to the terms of the Mozilla Public
6
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
7
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8
+ */
9
+
10
+/**
11
+ * @file
12
+ * @date      02/01/2018 08:33:23 AM
13
+ * @version   $Id$
14
+ * @author    Trevor Irons (ti)
15
+ * @email     tirons@egi.utah.edu
16
+ * @copyright Copyright (c) 2018, University of Utah
17
+ * @copyright Copyright (c) 2018, Lemma Software, LLC
18
+ */
19
+
20
+
21
+#include "CompactSupportEMSource.h"
22
+
23
+namespace Lemma {
24
+
25
+    // ====================  FRIEND METHODS  =====================
26
+
27
+    std::ostream &operator << (std::ostream &stream, const CompactSupportEMSource &ob) {
28
+        stream << ob.Serialize()  << "\n---\n"; // End of doc ---
29
+        return stream;
30
+    }
31
+
32
+    // ====================  LIFECYCLE     =======================
33
+
34
+    //--------------------------------------------------------------------------------------
35
+    //       Class:  CompactSupportEMSource
36
+    //      Method:  CompactSupportEMSource
37
+    // Description:  constructor (locked)
38
+    //--------------------------------------------------------------------------------------
39
+    CompactSupportEMSource::CompactSupportEMSource (const ctor_key&) : LemmaObject( LemmaObject::ctor_key() ) {
40
+
41
+    }  // -----  end of method CompactSupportEMSource::CompactSupportEMSource  (constructor)  -----
42
+
43
+    //--------------------------------------------------------------------------------------
44
+    //       Class:  CompactSupportEMSource
45
+    //      Method:  CompactSupportEMSource
46
+    // Description:  DeSerializing constructor (locked)
47
+    //--------------------------------------------------------------------------------------
48
+    CompactSupportEMSource::CompactSupportEMSource (const YAML::Node& node, const ctor_key&) : LemmaObject(node, LemmaObject::ctor_key()) {
49
+
50
+    }  // -----  end of method CompactSupportEMSource::CompactSupportEMSource  (constructor)  -----
51
+
52
+    //--------------------------------------------------------------------------------------
53
+    //       Class:  CompactSupportEMSource
54
+    //      Method:  NewSP()
55
+    // Description:  public constructor returing a shared_ptr
56
+    //--------------------------------------------------------------------------------------
57
+    std::shared_ptr< CompactSupportEMSource >  CompactSupportEMSource::NewSP() {
58
+        return std::make_shared< CompactSupportEMSource >( ctor_key() );
59
+    }
60
+
61
+    //--------------------------------------------------------------------------------------
62
+    //       Class:  CompactSupportEMSource
63
+    //      Method:  ~CompactSupportEMSource
64
+    // Description:  destructor (protected)
65
+    //--------------------------------------------------------------------------------------
66
+    CompactSupportEMSource::~CompactSupportEMSource () {
67
+
68
+    }  // -----  end of method CompactSupportEMSource::~CompactSupportEMSource  (destructor)  -----
69
+
70
+    //--------------------------------------------------------------------------------------
71
+    //       Class:  CompactSupportEMSource
72
+    //      Method:  Serialize
73
+    //--------------------------------------------------------------------------------------
74
+    YAML::Node  CompactSupportEMSource::Serialize (  ) const {
75
+        YAML::Node node = LemmaObject::Serialize();
76
+        node.SetTag( GetName() );
77
+        // FILL IN CLASS SPECIFICS HERE
78
+        return node;
79
+    }		// -----  end of method CompactSupportEMSource::Serialize  -----
80
+
81
+    //--------------------------------------------------------------------------------------
82
+    //       Class:  CompactSupportEMSource
83
+    //      Method:  DeSerialize
84
+    //--------------------------------------------------------------------------------------
85
+    std::shared_ptr<CompactSupportEMSource> CompactSupportEMSource::DeSerialize ( const YAML::Node& node  ) {
86
+        if (node.Tag() !=  "CompactSupportEMSource" ) {
87
+            throw  DeSerializeTypeMismatch( "CompactSupportEMSource", node.Tag());
88
+        }
89
+        return std::make_shared< CompactSupportEMSource > ( node, ctor_key() );
90
+    }		// -----  end of method CompactSupportEMSource::DeSerialize  -----
91
+
92
+} // ----  end of namespace Lemma  ----
93
+
94
+/* vim: set tabstop=4 expandtab: */
95
+/* vim: set filetype=cpp: */
96
+

+ 6
- 0
Modules/FDEM1D/testing/GetNameCheck.h View File

@@ -51,6 +51,12 @@ class MyTestSuite : public CxxTest::TestSuite
51 51
         TS_ASSERT_EQUALS( Obj->GetName(), std::string("WireAntenna") );
52 52
     }
53 53
 
54
+    void testCircularLoop( void )
55
+    {
56
+        auto Obj = CircularLoop::NewSP();
57
+        TS_ASSERT_EQUALS( Obj->GetName(), std::string("CircularLoop") );
58
+    }
59
+
54 60
     void testPolygonalWireAntenna( void )
55 61
     {
56 62
         auto Obj = PolygonalWireAntenna::NewSP();

+ 2
- 2
vim/lemma.cpp.template View File

@@ -287,7 +287,7 @@ std::ostream &operator << (std::ostream &stream, const |CLASSNAME| &ob) {
287 287
 //      Method:  |CLASSNAME|
288 288
 // Description:  constructor (locked)
289 289
 //--------------------------------------------------------------------------------------
290
-|CLASSNAME|::|CLASSNAME| (const ctor_key&) : |?BASECLASS|( ) {
290
+|CLASSNAME|::|CLASSNAME| (const ctor_key&) : |?BASECLASS|( |BASECLASS|::ctor_key()  ) {
291 291
 
292 292
 }  // -----  end of method |CLASSNAME|::|CLASSNAME|  (constructor)  -----
293 293
 
@@ -296,7 +296,7 @@ std::ostream &operator << (std::ostream &stream, const |CLASSNAME| &ob) {
296 296
 //      Method:  |CLASSNAME|
297 297
 // Description:  DeSerializing constructor (locked)
298 298
 //--------------------------------------------------------------------------------------
299
-|CLASSNAME|::|CLASSNAME| (const YAML::Node& node, const ctor_key&) : |BASECLASS|(node) {
299
+|CLASSNAME|::|CLASSNAME| (const YAML::Node& node, const ctor_key&) : |BASECLASS|(node, |BASECLASS|::ctor_key()) {
300 300
 
301 301
 }  // -----  end of method |CLASSNAME|::|CLASSNAME|  (constructor)  -----
302 302
 

Loading…
Cancel
Save