Addition of data and forward modeling classes, not yet completed

CMakeLists.txt

@@ -1,24 +1,37 @@
+# Configure Merlin 
+set(MERLIN_VERSION_MAJOR "0")
+set(MERLIN_VERSION_MINOR "0")
+set(MERLIN_VERSION_PATCH "1")
+set(MERLIN_VERSION "\"${MERLIN_VERSION_MAJOR}.${MERLIN_VERSION_MINOR}.${MERLIN_VERSION_PATCH}\"")
+set(MERLIN_VERSION_NOQUOTES "${MERLIN_VERSION_MAJOR}.${MERLIN_VERSION_MINOR}.${MERLIN_VERSION_PATCH}")
+
+configure_file (
+	"${CMAKE_CURRENT_SOURCE_DIR}/config/MerlinConfig.h.in"
+	"${PROJECT_BINARY_DIR}/include/MerlinConfig.h"
+)
+install ( FILES  ${PROJECT_BINARY_DIR}/include/MerlinConfig.h   DESTINATION ${CMAKE_INSTALL_PREFIX}/include/Lemma/ )
+
 add_subdirectory("src")
 add_library( merlin ${MERLINSOURCE} )  
 target_include_directories( merlin PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/include" )
 
 set_target_properties(merlin PROPERTIES 
-	VERSION  "${LEMMA_VERSION_NOQUOTES}"
-	SOVERSION "${LEMMA_VERSION_MAJOR}.${LEMMA_VERSION_MINOR}"
-	PROJECT_LABEL "FDEM1D ${LABEL_SUFFIX}"
+	VERSION  "${MERLIN_VERSION_NOQUOTES}"
+	SOVERSION "${MERLIN_VERSION_MAJOR}.${MERLIN_VERSION_MINOR}"
+	PROJECT_LABEL "MERLIN ${LABEL_SUFFIX}"
 )
 
 # Linking
 target_link_libraries(merlin "lemmacore" "fdem1d" )
 
 # Linking
-if ( LEMMA_VTK6_SUPPORT OR LEMMA_VTK7_SUPPORT ) 
+if ( MERLIN_VTK6_SUPPORT OR MERLIN_VTK7_SUPPORT ) 
 	target_link_libraries(merlin ${VTK_LIBRARIES})
 #	target_link_libraries(lemmacore "matplot")
 endif()
 
 # Testing
-if (LEMMA_ENABLE_TESTING)
+if (MERLIN_ENABLE_TESTING)
 	add_subdirectory(testing)
 endif()
 

config/MerlinConfig.h.in

@@ -0,0 +1,23 @@
+/* This file is part of Lemma, a geophysical modelling and inversion API.
+ * More information is available at http://lemmasoftware.org
+ */
+
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+/**
+ * @file
+ * @date      01/15/2016 09:52:10 PM
+ * @author    Trevor Irons (ti)
+ * @email     tirons@egi.utah.edu
+ * @copyright Copyright (c) 2016, University of Utah
+ * @copyright Copyright (c) 2016, Trevor Irons & Lemma Software, LLC
+ */
+
+// Sets the Lemma version used in keeping track of releases
+#define MERLIN_VERSION_MAJOR @MERLIN_VERSION_MAJOR@
+#define MERLIN_VERSION_MINOR @MERLIN_VERSION_MINOR@
+#define MERLIN_VERSION_PATCH @MERLIN_VERSION_PATCH@
+#define MERLIN_VERSION @MERLIN_VERSION@

examples/CMakeLists.txt

@@ -7,6 +7,9 @@ target_link_libraries(  KernelV0-2  "lemmacore" "fdem1d" "merlin")
 add_executable( KV0-3loops KV0-3loops.cpp  )
 target_link_libraries(  KV0-3loops  "lemmacore" "fdem1d" "merlin")
 
+add_executable( ForwardFID ForwardFID.cpp  )
+target_link_libraries(  ForwardFID  "lemmacore" "fdem1d" "merlin")
+
 add_executable( Coupling Coupling.cpp  )
 target_link_libraries(  Coupling  "lemmacore" "fdem1d" "merlin")
 

examples/ForwardFID.cpp

@@ -0,0 +1,39 @@
+/* This file is part of Lemma, a geophysical modelling and inversion API.
+ * More information is available at http://lemmasoftware.org
+ */
+
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+/**
+ * @file
+ * @date      08/28/2017 09:07:04 AM
+ * @version   $Id$
+ * @author    Trevor Irons (ti)
+ * @email     tirons@egi.utah.edu
+ * @copyright Copyright (c) 2017, University of Utah
+ * @copyright Copyright (c) 2017, Lemma Software, LLC
+ */
+
+#include <Merlin>
+using namespace Lemma;
+
+int main(int argc, char** argv) {
+
+    if (argc<5) {
+        std::cout << "./ForwardFID Kernel.yaml TxString RxString  vtkoutput<true/false> \n";
+    //    return(EXIT_FAILURE);
+    }
+
+    auto Forward = ForwardFID::NewSP();
+        Forward->SetWindowEdges( VectorXr::LinSpaced(10,0,1) );
+
+    std::cout << *Forward << std::endl;
+
+    //auto FID = Forward->ForwardModel();
+    //std::cout << *FID << std::endl;
+
+    return EXIT_SUCCESS;
+}

examples/KernelV0-2.cpp

@@ -68,6 +68,7 @@ int main(int argc, char** argv) {
     out << *Kern;
     out.close();
 
+    return EXIT_SUCCESS;
 }
 
 

include/DataFID.h

@@ -0,0 +1,134 @@
+/* This file is part of Lemma, a geophysical modelling and inversion API.
+ * More information is available at http://lemmasoftware.org
+ */
+
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+/**
+ * @file
+ * @date      08/28/2017 01:04:12 PM
+ * @version   $Id$
+ * @author    Trevor Irons (ti)
+ * @email     tirons@egi.utah.edu
+ * @copyright Copyright (c) 2017, University of Utah
+ * @copyright Copyright (c) 2017, Lemma Software, LLC
+ */
+
+#ifndef  DATAFID_INC
+#define  DATAFID_INC
+
+#pragma once
+#include "MerlinObject.h"
+
+namespace Lemma {
+
+    /**
+     * \ingroup Merlin
+     * \brief   Base class for representation of FID data in Merlin.
+     * \details Simplest form of FID data used in Merlin. Field data derives
+                from this class for specific instrumentation details. See
+                the Akvo project for further details (akvo.lemmasoftware.org).
+     */
+    class DataFID : public MerlinObject {
+
+        friend std::ostream &operator<<(std::ostream &stream, const DataFID &ob);
+
+        protected:
+        /*
+         *  This key is used to lock the constructor. It is protected so that inhereted
+         *  classes also have the key to contruct their base class.
+         */
+        struct ctor_key {};
+
+        public:
+
+        // ====================  LIFECYCLE     =======================
+
+        /**
+         * Default 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 DataFID::NewSP
+         */
+        explicit DataFID ( 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 DataFID::DeSerialize
+         */
+        DataFID ( const YAML::Node& node, const ctor_key& );
+
+        /**
+         * Default destructor.
+         * @note This method should never be called due to the mandated
+         *       use of smart pointers. It is necessary to keep the method
+         *       public in order to allow for the use of the more efficient
+         *       make_shared constructor.
+         */
+        virtual ~DataFID ();
+
+        /**
+         *  Uses YAML to serialize this object.
+         *  @return a YAML::Node
+         *  @see DataFID::DeSerialize
+         */
+        virtual YAML::Node Serialize() const;
+
+        /*
+         *  Factory method for generating concrete class.
+         *  @return a std::shared_ptr of type DataFID
+         */
+        static std::shared_ptr< DataFID > NewSP();
+
+        /**
+         *   Constructs an DataFID object from a YAML::Node.
+         *   @see DataFID::Serialize
+         */
+        static std::shared_ptr<DataFID> DeSerialize(const YAML::Node& node);
+
+        // ====================  OPERATORS     =======================
+
+        // ====================  OPERATIONS    =======================
+
+        // ====================  ACCESS        =======================
+
+        // ====================  INQUIRY       =======================
+        /**
+         *  Returns the name of the underlying class, similiar to Python's type
+         *  @return string of class name
+         */
+        virtual inline std::string GetName() const {
+            return CName;
+        }
+
+        protected:
+
+        // ====================  LIFECYCLE     =======================
+
+        /** Copy is disabled */
+        DataFID( const DataFID& ) = delete;
+
+        // ====================  DATA MEMBERS  =========================
+
+        private:
+
+        /** ASCII string representation of the class name */
+        static constexpr auto CName = "DataFID";
+
+    }; // -----  end of class  DataFID  -----
+}  // -----  end of namespace Lemma ----
+
+/* vim: set tabstop=4 expandtab: */
+/* vim: set filetype=cpp: */
+
+
+#endif   // ----- #ifndef DATAFID_INC  -----

include/ForwardFID.h

@@ -0,0 +1,160 @@
+/* This file is part of Lemma, a geophysical modelling and inversion API.
+ * More information is available at http://lemmasoftware.org
+ */
+
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+/**
+ * @file
+ * @date      08/28/2017 08:49:51 AM
+ * @version   $Id$
+ * @author    Trevor Irons (ti)
+ * @email     tirons@egi.utah.edu
+ * @copyright Copyright (c) 2017, University of Utah
+ * @copyright Copyright (c) 2017, Lemma Software, LLC
+ */
+
+#ifndef  FORWARDFID_INC
+#define  FORWARDFID_INC
+
+#pragma once
+#include "LayeredEarthEM.h"
+#include "PolygonalWireAntenna.h"
+#include "EMEarth1D.h"
+#include "MerlinObject.h"
+#include "DataFID.h"
+#include "KernelV0.h"
+
+namespace Lemma {
+
+    /**
+     * \ingroup Merlin
+     * \brief Forward modelling for FID sNMR pulses
+     * \details This class performs forward modelling of sNMR
+     *          FID experiments.
+     */
+    class ForwardFID : public MerlinObject {
+
+        friend std::ostream &operator<<(std::ostream &stream, const ForwardFID &ob);
+
+        protected:
+        /*
+         *  This key is used to lock the constructor. It is protected so that inhereted
+         *  classes also have the key to contruct their base class.
+         */
+        struct ctor_key {};
+
+        public:
+
+        // ====================  LIFECYCLE     =======================
+
+        /**
+         * Default 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 ForwardFID::NewSP
+         */
+        explicit ForwardFID ( 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 ForwardFID::DeSerialize
+         */
+        ForwardFID ( const YAML::Node& node, const ctor_key& );
+
+        /**
+         * Default destructor.
+         * @note This method should never be called due to the mandated
+         *       use of smart pointers. It is necessary to keep the method
+         *       public in order to allow for the use of the more efficient
+         *       make_shared constructor.
+         */
+        virtual ~ForwardFID ();
+
+        /**
+         *  Uses YAML to serialize this object.
+         *  @return a YAML::Node
+         *  @see ForwardFID::DeSerialize
+         */
+        virtual YAML::Node Serialize() const;
+
+        /*
+         *  Factory method for generating concrete class.
+         *  @return a std::shared_ptr of type ForwardFID
+         */
+        static std::shared_ptr< ForwardFID > NewSP();
+
+        /**
+         *   Constructs an ForwardFID object from a YAML::Node.
+         *   @see ForwardFID::Serialize
+         */
+        static std::shared_ptr<ForwardFID> DeSerialize(const YAML::Node& node);
+
+        // ====================  OPERATORS     =======================
+
+        // ====================  OPERATIONS    =======================
+
+        /**
+         *  Performs forward model calculation based on input parameters
+         *  @return Merlin class representing data
+         */
+        std::shared_ptr<DataFID> ForwardModel();
+
+        // ====================  ACCESS        =======================
+        /**
+         *  Sets windows using the edges in a Eigen VectorXr
+         *  @param[in] Edges are the edges of the time gate windows
+         */
+        void SetWindowEdges( const VectorXr& Edges );
+
+        // ====================  INQUIRY       =======================
+        /**
+         *  Returns the name of the underlying class, similiar to Python's type
+         *  @return string of class name
+         */
+        virtual inline std::string GetName() const {
+            return CName;
+        }
+
+        protected:
+
+        // ====================  LIFECYCLE     =======================
+
+        /** Copy is disabled */
+        ForwardFID( const ForwardFID& ) = delete;
+
+        // ====================  DATA MEMBERS  =========================
+        private:
+
+        /** ASCII string representation of the class name */
+        static constexpr auto CName = "ForwardFID";
+
+        /** Imaging kernel used in calculation */
+        std::shared_ptr< KernelV0 >   Kernel = nullptr;
+
+        /** Time gate windows */
+        VectorXr WindowEdges;
+
+        /** Time gate centres */
+        VectorXr WindowCentres;
+
+        /** Include RDP effects? */
+        bool RDP = false;
+
+    }; // -----  end of class  ForwardFID  -----
+
+}  // -----  end of namespace Lemma ----
+
+/* vim: set tabstop=4 expandtab: */
+/* vim: set filetype=cpp: */
+
+#endif   // ----- #ifndef FORWARDFID_INC  -----

include/Merlin

@@ -1,6 +1,8 @@
 #include "KernelV0.h"
+#include "ForwardFID.h"
 #include "Coupling.h"
 #include "LoopInteractions.h"
+#include "DataFID.h"
 
 /* vim: set tabstop=4 expandtab: */
 /* vim: set filetype=cpp: */

include/MerlinObject.h

@@ -0,0 +1,135 @@
+/* This file is part of Lemma, a geophysical modelling and inversion API.
+ * More information is available at http://lemmasoftware.org
+ */
+
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+/**
+ * @file
+ * @date      08/28/2017 11:40:40 AM
+ * @version   $Id$
+ * @author    Trevor Irons (ti)
+ * @email     tirons@egi.utah.edu
+ * @copyright Copyright (c) 2017, University of Utah
+ * @copyright Copyright (c) 2017, Lemma Software, LLC
+ */
+
+#ifndef  MERLINOBJECT_INC
+#define  MERLINOBJECT_INC
+
+
+#pragma once
+#include "LemmaObject.h"
+#include "LemmaObject.h"
+#include "MerlinConfig.h"
+
+namespace Lemma {
+
+    /**
+     * \ingroup Merlin
+     * \brief  Abstract base class for all of Merlin
+     * \details
+     */
+    class MerlinObject : public LemmaObject {
+
+        friend std::ostream &operator<<(std::ostream &stream, const MerlinObject &ob);
+
+        protected:
+        /*
+         *  This key is used to lock the constructor. It is protected so that inhereted
+         *  classes also have the key to contruct their base class.
+         */
+
+        public:
+
+        // ====================  LIFECYCLE     =======================
+
+        /**
+         * Default 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 MerlinObject::NewSP
+         */
+        explicit MerlinObject ( );
+
+        /**
+         * 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 MerlinObject::DeSerialize
+         */
+        MerlinObject ( const YAML::Node& node );
+
+        /**
+         * Default destructor.
+         * @note This method should never be called due to the mandated
+         *       use of smart pointers. It is necessary to keep the method
+         *       public in order to allow for the use of the more efficient
+         *       make_shared constructor.
+         */
+        virtual ~MerlinObject ();
+
+        /**
+         *  Uses YAML to serialize this object.
+         *  @return a YAML::Node
+         *  @see MerlinObject::DeSerialize
+         */
+        virtual YAML::Node Serialize() const ;
+
+        /*
+         *  Factory method for generating concrete class.
+         *  @return a std::shared_ptr of type MerlinObject
+         */
+        static std::shared_ptr< MerlinObject > NewSP();
+
+        /**
+         *   Constructs an MerlinObject object from a YAML::Node.
+         *   @see MerlinObject::Serialize
+         */
+        static std::shared_ptr<MerlinObject> DeSerialize(const YAML::Node& node);
+
+        // ====================  OPERATORS     =======================
+
+        // ====================  OPERATIONS    =======================
+
+        // ====================  ACCESS        =======================
+
+        // ====================  INQUIRY       =======================
+        /**
+         *  Returns the name of the underlying class, similiar to Python's type
+         *  @return string of class name
+         */
+        virtual inline std::string GetName() const {
+            return CName;
+        }
+
+        protected:
+
+        // ====================  LIFECYCLE     =======================
+
+        /** Copy is disabled */
+        MerlinObject( const MerlinObject& ) = delete;
+
+        // ====================  DATA MEMBERS  =========================
+
+        private:
+
+        /** ASCII string representation of the class name */
+        static constexpr auto CName = "MerlinObject";
+
+    }; // -----  end of class  MerlinObject  -----
+}  // -----  end of namespace Lemma ----
+
+/* vim: set tabstop=4 expandtab: */
+/* vim: set filetype=cpp: */
+
+
+#endif   // ----- #ifndef MERLINOBJECT_INC  -----
+

src/CMakeLists.txt

@@ -1,6 +1,9 @@
 set (MERLINSOURCE
+	${CMAKE_CURRENT_SOURCE_DIR}/MerlinObject.cpp
 	${CMAKE_CURRENT_SOURCE_DIR}/KernelV0.cpp
+	${CMAKE_CURRENT_SOURCE_DIR}/ForwardFID.cpp
 	${CMAKE_CURRENT_SOURCE_DIR}/Coupling.cpp
 	${CMAKE_CURRENT_SOURCE_DIR}/LoopInteractions.cpp
+	${CMAKE_CURRENT_SOURCE_DIR}/DataFID.cpp
 	PARENT_SCOPE
 )

src/DataFID.cpp

@@ -0,0 +1,97 @@
+/* This file is part of Lemma, a geophysical modelling and inversion API.
+ * More information is available at http://lemmasoftware.org
+ */
+
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+/**
+ * @file
+ * @date      08/28/2017 01:04:19 PM
+ * @version   $Id$
+ * @author    Trevor Irons (ti)
+ * @email     tirons@egi.utah.edu
+ * @copyright Copyright (c) 2017, University of Utah
+ * @copyright Copyright (c) 2017, Lemma Software, LLC
+ */
+
+
+#include "DataFID.h"
+
+namespace Lemma {
+
+    // ====================  FRIEND METHODS  =====================
+
+    std::ostream &operator << (std::ostream &stream, const DataFID &ob) {
+        stream << ob.Serialize()  << "\n---\n"; // End of doc ---
+        return stream;
+    }
+
+    // ====================  LIFECYCLE     =======================
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  DataFID
+    //      Method:  DataFID
+    // Description:  constructor (locked)
+    //--------------------------------------------------------------------------------------
+    DataFID::DataFID (const ctor_key&) : MerlinObject( ) {
+
+    }  // -----  end of method DataFID::DataFID  (constructor)  -----
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  DataFID
+    //      Method:  DataFID
+    // Description:  DeSerializing constructor (locked)
+    //--------------------------------------------------------------------------------------
+    DataFID::DataFID (const YAML::Node& node, const ctor_key&) : MerlinObject(node) {
+
+    }  // -----  end of method DataFID::DataFID  (constructor)  -----
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  DataFID
+    //      Method:  NewSP()
+    // Description:  public constructor returing a shared_ptr
+    //--------------------------------------------------------------------------------------
+    std::shared_ptr< DataFID >  DataFID::NewSP() {
+        return std::make_shared< DataFID >( ctor_key() );
+    }
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  DataFID
+    //      Method:  ~DataFID
+    // Description:  destructor (protected)
+    //--------------------------------------------------------------------------------------
+    DataFID::~DataFID () {
+
+    }  // -----  end of method DataFID::~DataFID  (destructor)  -----
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  DataFID
+    //      Method:  Serialize
+    //--------------------------------------------------------------------------------------
+    YAML::Node  DataFID::Serialize (  ) const {
+        YAML::Node node = MerlinObject::Serialize();
+        node.SetTag( GetName() );
+        // FILL IN CLASS SPECIFICS HERE
+        return node;
+    }		// -----  end of method DataFID::Serialize  -----
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  DataFID
+    //      Method:  DeSerialize
+    //--------------------------------------------------------------------------------------
+    std::shared_ptr<DataFID> DataFID::DeSerialize ( const YAML::Node& node  ) {
+        if (node.Tag() !=  "DataFID" ) {
+            throw  DeSerializeTypeMismatch( "DataFID", node.Tag());
+        }
+        return std::make_shared< DataFID > ( node, ctor_key() );
+    }		// -----  end of method DataFID::DeSerialize  -----
+
+} // ----  end of namespace Lemma  ----
+
+/* vim: set tabstop=4 expandtab: */
+/* vim: set filetype=cpp: */
+
+

src/ForwardFID.cpp

@@ -0,0 +1,123 @@
+/* This file is part of Lemma, a geophysical modelling and inversion API.
+ * More information is available at http://lemmasoftware.org
+ */
+
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+/**
+ * @file
+ * @date      08/28/2017 09:03:03 AM
+ * @version   $Id$
+ * @author    Trevor Irons (ti)
+ * @email     tirons@egi.utah.edu
+ * @copyright Copyright (c) 2017, University of Utah
+ * @copyright Copyright (c) 2017, Lemma Software, LLC
+ */
+
+#include "ForwardFID.h"
+
+namespace Lemma {
+
+    // ====================  FRIEND METHODS  =====================
+
+    std::ostream &operator << (std::ostream &stream, const ForwardFID &ob) {
+        stream << ob.Serialize()  << "\n---\n"; // End of doc ---
+        return stream;
+    }
+
+    // ====================  LIFECYCLE     =======================
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  ForwardFID
+    //      Method:  ForwardFID
+    // Description:  constructor (locked)
+    //--------------------------------------------------------------------------------------
+    ForwardFID::ForwardFID (const ctor_key&) : MerlinObject( ) {
+
+    }  // -----  end of method ForwardFID::ForwardFID  (constructor)  -----
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  ForwardFID
+    //      Method:  ForwardFID
+    // Description:  DeSerializing constructor (locked)
+    //--------------------------------------------------------------------------------------
+    ForwardFID::ForwardFID (const YAML::Node& node, const ctor_key&) : MerlinObject(node) {
+
+    }  // -----  end of method ForwardFID::ForwardFID  (constructor)  -----
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  ForwardFID
+    //      Method:  NewSP()
+    // Description:  public constructor returing a shared_ptr
+    //--------------------------------------------------------------------------------------
+    std::shared_ptr< ForwardFID >  ForwardFID::NewSP() {
+        return std::make_shared< ForwardFID >( ctor_key() );
+    }
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  ForwardFID
+    //      Method:  ~ForwardFID
+    // Description:  destructor (protected)
+    //--------------------------------------------------------------------------------------
+    ForwardFID::~ForwardFID () {
+
+    }  // -----  end of method ForwardFID::~ForwardFID  (destructor)  -----
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  ForwardFID
+    //      Method:  Serialize
+    //--------------------------------------------------------------------------------------
+    YAML::Node  ForwardFID::Serialize (  ) const {
+        YAML::Node node = MerlinObject::Serialize();
+        node.SetTag( GetName() );
+        // FILL IN CLASS SPECIFICS HERE
+        if (Kernel != nullptr) {
+            node["Kernel"] = Kernel->Serialize();
+        }
+        node["WindowEdges"] = WindowEdges;
+        node["WindowCentres"] = WindowCentres;
+        node["RDP"] = RDP;
+        return node;
+    }		// -----  end of method ForwardFID::Serialize  -----
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  ForwardFID
+    //      Method:  DeSerialize
+    //--------------------------------------------------------------------------------------
+    std::shared_ptr<ForwardFID> ForwardFID::DeSerialize ( const YAML::Node& node  ) {
+        if (node.Tag() !=  "ForwardFID" ) {
+            throw  DeSerializeTypeMismatch( "ForwardFID", node.Tag());
+        }
+        return std::make_shared< ForwardFID > ( node, ctor_key() );
+    }		// -----  end of method ForwardFID::DeSerialize  -----
+
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  ForwardFID
+    //      Method:  SetWindowEdges
+    //--------------------------------------------------------------------------------------
+    void ForwardFID::SetWindowEdges ( const VectorXr& Edges ) {
+        WindowEdges = Edges;
+        return ;
+    }		// -----  end of method ForwardFID::SetWindowEdges  -----
+
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  ForwardFID
+    //      Method:  ForwardModel
+    //--------------------------------------------------------------------------------------
+    std::shared_ptr<DataFID> ForwardFID::ForwardModel (  ) {
+        auto FID = DataFID::NewSP();
+        return FID;
+    }		// -----  end of method ForwardFID::ForwardModel  -----
+
+
+} // ----  end of namespace Lemma  ----
+
+/* vim: set tabstop=4 expandtab: */
+/* vim: set filetype=cpp: */
+
+