Model class added for forward modelling as well.

examples/ForwardFID.cpp

@@ -27,13 +27,16 @@ int main(int argc, char** argv) {
     //    return(EXIT_FAILURE);
     }
 
-    auto Forward = ForwardFID::NewSP();
-        Forward->SetWindowEdges( VectorXr::LinSpaced(10,0,1) );
-
-    std::cout << *Forward << std::endl;
+    auto Model = LayeredEarthMR::NewSP();
+        Model->SetNumberOfLayers(20);
+        Model->SetT2StarBins(10, 500, 20);
+        std::cout << *Model << std::endl;
 
-    //auto FID = Forward->ForwardModel();
-    //std::cout << *FID << std::endl;
+    auto Forward = ForwardFID::NewSP();
+        //Forward->SetWindowEdges( VectorXr::LinSpaced(10,0,1) );
+        Forward->SetLogSpacedWindows(10,1000,30);
+        //auto FID =  Forward->ForwardModel(Model);
+    //std::cout << *Forward << std::endl;
 
     return EXIT_SUCCESS;
 }

include/ForwardFID.h

@@ -116,6 +116,15 @@ namespace Lemma {
          */
         void SetWindowEdges( const VectorXr& Edges );
 
+        /**
+         *  Sets the windows for calculation as a series of log spaced windows.
+         *  This method calculates the window edges, so the centres will be n-1
+         *  @param[in] first is the beginning of the vector
+         *  @param[in] last is the last element in the vector
+         *  @param[in] n is the number of elements
+         */
+        void SetLogSpacedWindows(const Real& first, const Real& last, const int& n);
+
         // ====================  INQUIRY       =======================
         /**
          *  Returns the name of the underlying class, similiar to Python's type
@@ -135,6 +144,8 @@ namespace Lemma {
         // ====================  DATA MEMBERS  =========================
         private:
 
+        void CalcQTMatrix(  );
+
         /** ASCII string representation of the class name */
         static constexpr auto CName = "ForwardFID";
 

include/LayeredEarthMR.h

@@ -0,0 +1,143 @@
+/* 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 03:32:26 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  LAYEREDEARTHMR_INC
+#define  LAYEREDEARTHMR_INC
+
+
+#pragma once
+#include "LayeredEarth.h"
+#include "MerlinConfig.h"
+
+namespace Lemma {
+
+    /**
+     * \ingroup Merlin
+     * \brief
+     * \details
+     */
+    class LayeredEarthMR : public LayeredEarth {
+
+        friend std::ostream &operator<<(std::ostream &stream, const LayeredEarthMR &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 LayeredEarthMR::NewSP
+         */
+        explicit LayeredEarthMR ( 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 LayeredEarthMR::DeSerialize
+         */
+        LayeredEarthMR ( 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 ~LayeredEarthMR ();
+
+        /**
+         *  Uses YAML to serialize this object.
+         *  @return a YAML::Node
+         *  @see LayeredEarthMR::DeSerialize
+         */
+        virtual YAML::Node Serialize() const;
+
+        /*
+         *  Factory method for generating concrete class.
+         *  @return a std::shared_ptr of type LayeredEarthMR
+         */
+        static std::shared_ptr< LayeredEarthMR > NewSP();
+
+        /**
+         *   Constructs an LayeredEarthMR object from a YAML::Node.
+         *   @see LayeredEarthMR::Serialize
+         */
+        static std::shared_ptr<LayeredEarthMR> DeSerialize(const YAML::Node& node);
+
+        // ====================  OPERATORS     =======================
+
+        // ====================  OPERATIONS    =======================
+
+        // ====================  ACCESS        =======================
+
+
+        void SetNumberOfLayers(const int& nlay);
+
+        void SetT2StarBins(const Real& first, const Real& last, const int& nT2);
+
+        // ====================  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 */
+        LayeredEarthMR( const LayeredEarthMR& ) = delete;
+
+        // ====================  DATA MEMBERS  =========================
+
+        private:
+
+        /** ASCII string representation of the class name */
+        static constexpr auto CName = "LayeredEarthMR";
+
+        VectorXr T2StarBins;
+        VectorXr T2StarBinEdges;  // Convenience for pcolor
+
+    }; // -----  end of class  LayeredEarthMR  -----
+}  // -----  end of namespace Lemma ----
+
+/* vim: set tabstop=4 expandtab: */
+/* vim: set filetype=cpp: */
+
+
+#endif   // ----- #ifndef LAYEREDEARTHMR_INC  -----
+

include/Merlin

@@ -3,6 +3,7 @@
 #include "Coupling.h"
 #include "LoopInteractions.h"
 #include "DataFID.h"
+#include "LayeredEarthMR.h"
 
 /* vim: set tabstop=4 expandtab: */
 /* vim: set filetype=cpp: */

src/CMakeLists.txt

@@ -5,5 +5,6 @@ set (MERLINSOURCE
 	${CMAKE_CURRENT_SOURCE_DIR}/Coupling.cpp
 	${CMAKE_CURRENT_SOURCE_DIR}/LoopInteractions.cpp
 	${CMAKE_CURRENT_SOURCE_DIR}/DataFID.cpp
+	${CMAKE_CURRENT_SOURCE_DIR}/LayeredEarthMR.cpp
 	PARENT_SCOPE
 )

src/ForwardFID.cpp

@@ -114,6 +114,30 @@ namespace Lemma {
         return FID;
     }		// -----  end of method ForwardFID::ForwardModel  -----
 
+    //--------------------------------------------------------------------------------------
+    //       Class:  ForwardFID
+    //      Method:  LogSpaced
+    //--------------------------------------------------------------------------------------
+    void ForwardFID::SetLogSpacedWindows ( const Real& first, const Real& last,
+        const int& n ) {
+        WindowEdges = VectorXr::Zero(n);
+        Real m = 1./(n-1.);
+        Real quotient = std::pow(last/first, m);
+        WindowEdges[0] = first;
+        for (int i=1; i<n; ++i) {
+            WindowEdges[i] = WindowEdges[i-1]*quotient;
+        }
+        WindowCentres = (WindowEdges.head(n-1) + WindowEdges.tail(n-1)) / 2;
+        return;
+    }		// -----  end of method ForwardFID::LogSpaced  -----
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  ForwardFID
+    //      Method:  CalcQTMatrix
+    //--------------------------------------------------------------------------------------
+    void ForwardFID::CalcQTMatrix (  ) {
+        return ;
+    }		// -----  end of method ForwardFID::CalcQTMatrix  -----
 
 } // ----  end of namespace Lemma  ----
 

src/LayeredEarthMR.cpp

@@ -0,0 +1,129 @@
+/* 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 03:32:34 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 "LayeredEarthMR.h"
+
+namespace Lemma {
+
+    // ====================  FRIEND METHODS  =====================
+
+    std::ostream &operator << (std::ostream &stream, const LayeredEarthMR &ob) {
+        stream << ob.Serialize()  << "\n---\n"; // End of doc ---
+        return stream;
+    }
+
+    // ====================  LIFECYCLE     =======================
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  LayeredEarthMR
+    //      Method:  LayeredEarthMR
+    // Description:  constructor (locked)
+    //--------------------------------------------------------------------------------------
+    LayeredEarthMR::LayeredEarthMR (const ctor_key&) : LayeredEarth( ) {
+
+    }  // -----  end of method LayeredEarthMR::LayeredEarthMR  (constructor)  -----
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  LayeredEarthMR
+    //      Method:  LayeredEarthMR
+    // Description:  DeSerializing constructor (locked)
+    //--------------------------------------------------------------------------------------
+    LayeredEarthMR::LayeredEarthMR (const YAML::Node& node, const ctor_key&) : LayeredEarth(node) {
+
+    }  // -----  end of method LayeredEarthMR::LayeredEarthMR  (constructor)  -----
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  LayeredEarthMR
+    //      Method:  NewSP()
+    // Description:  public constructor returing a shared_ptr
+    //--------------------------------------------------------------------------------------
+    std::shared_ptr< LayeredEarthMR >  LayeredEarthMR::NewSP() {
+        return std::make_shared< LayeredEarthMR >( ctor_key() );
+    }
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  LayeredEarthMR
+    //      Method:  ~LayeredEarthMR
+    // Description:  destructor (protected)
+    //--------------------------------------------------------------------------------------
+    LayeredEarthMR::~LayeredEarthMR () {
+
+    }  // -----  end of method LayeredEarthMR::~LayeredEarthMR  (destructor)  -----
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  LayeredEarthMR
+    //      Method:  Serialize
+    //--------------------------------------------------------------------------------------
+    YAML::Node  LayeredEarthMR::Serialize (  ) const {
+        YAML::Node node = LayeredEarth::Serialize();
+        node.SetTag( GetName() );
+        // FILL IN CLASS SPECIFICS HERE
+        node["Merlin_VERSION"] = MERLIN_VERSION;
+        node["T2StarBins"] = T2StarBins;
+        node["T2StarBinEdges"] = T2StarBinEdges;
+        return node;
+    }		// -----  end of method LayeredEarthMR::Serialize  -----
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  LayeredEarthMR
+    //      Method:  DeSerialize
+    //--------------------------------------------------------------------------------------
+    std::shared_ptr<LayeredEarthMR> LayeredEarthMR::DeSerialize ( const YAML::Node& node  ) {
+        if (node.Tag() !=  "LayeredEarthMR" ) {
+            throw  DeSerializeTypeMismatch( "LayeredEarthMR", node.Tag());
+        }
+        return std::make_shared< LayeredEarthMR > ( node, ctor_key() );
+    }		// -----  end of method LayeredEarthMR::DeSerialize  -----
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  LayeredEarthMR
+    //      Method:  SetNumberOfLayers
+    //--------------------------------------------------------------------------------------
+    void LayeredEarthMR::SetNumberOfLayers ( const int& nlay  ) {
+        return ;
+    }		// -----  end of method LayeredEarthMR::SetNumberOfLayers  -----
+
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  LayeredEarthMR
+    //      Method:  SetNumberOfT2StarBins
+    //--------------------------------------------------------------------------------------
+    void LayeredEarthMR::SetT2StarBins ( const Real& first, const Real& last, const int& nT2 ) {
+        T2StarBinEdges = VectorXr::Zero(nT2+1);
+        Real m = 1./(nT2);
+        Real quotient = std::pow(last/first, m);
+        T2StarBinEdges[0] = first;
+        for (int i=1; i<nT2+1; ++i) {
+            T2StarBinEdges[i] = T2StarBinEdges[i-1]*quotient;
+        }
+        T2StarBins = (T2StarBinEdges.head(nT2) + T2StarBinEdges.tail(nT2)) / 2;
+        return;
+    }		// -----  end of method LayeredEarthMR::SetNumberOfT2StarBins  -----
+
+
+} // ----  end of namespace Lemma  ----
+
+
+
+
+
+/* vim: set tabstop=4 expandtab: */
+/* vim: set filetype=cpp: */
+
+