Added examples to CMake build and commented out FastDelegte calls. Still need to replace those calls with move semantics.

LemmaCore/CMakeLists.txt

@@ -16,3 +16,5 @@ if (VTK_SUPPORT)
 	target_link_libraries(lemmacore ${VTK_LIBRARIES})
 endif()
 target_link_libraries(lemmacore "yaml-cpp")
+
+add_subdirectory(examples)

LemmaCore/examples/CMakeLists.txt

@@ -0,0 +1,36 @@
+FILE(GLOB  examples  "*.cpp")
+
+add_executable( datatem datatem.cpp )
+target_link_libraries(datatem "lemmacore")
+
+add_executable( wireantenna wireantenna.cpp )
+target_link_libraries(wireantenna "lemmacore")
+
+add_executable( DCIPElectrode  DCIPElectrode.cpp )
+target_link_libraries(DCIPElectrode "lemmacore")
+
+add_executable( digitalfiltercostrans  digitalfiltercostrans.cpp )
+target_link_libraries(digitalfiltercostrans "lemmacore")
+
+add_executable( dipolefreqsweep  dipolefreqsweep.cpp )
+target_link_libraries(dipolefreqsweep "lemmacore")
+
+add_executable( dipolesource  dipolesource.cpp )
+target_link_libraries(dipolesource "lemmacore")
+
+add_executable( edipole  edipole.cpp )
+target_link_libraries(edipole "lemmacore")
+
+add_executable( emdipearth1d  emdipearth1d.cpp )
+target_link_libraries(emdipearth1d "lemmacore")
+
+add_executable( femforward  femforward.cpp )
+target_link_libraries(femforward "lemmacore")
+
+add_executable( filter  filter.cpp )
+target_link_libraries(filter "lemmacore")
+
+
+
+
+

LemmaCore/examples/DCIPElectrode.cpp

@@ -0,0 +1,116 @@
+/* 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      11/10/2014 12:31:01 PM
+ * @version   $Id$
+ * @author    Trevor Irons (ti)
+ * @email     Trevor.Irons@xri-geo.com
+ * @copyright Copyright (c) 2014, XRI Geophysics, LLC
+ * @copyright Copyright (c) 2014, Trevor Irons
+ */
+
+#include "DCIPElectrode.h"
+#include "DCSurvey.h"
+
+using namespace Lemma;
+
+int main() {
+
+
+    //DCIPElectrode* Electrode1 = DCIPElectrode::New();
+    DCIPElectrode* Electrode2 = DCIPElectrode::New();
+    DCIPElectrode* Electrode3 = DCIPElectrode::New();
+    DCIPElectrode* Electrode4 = DCIPElectrode::New();
+    DCIPElectrode* Electrode5 = DCIPElectrode::New();
+    DCIPElectrode* Electrode6 = DCIPElectrode::New();
+    DCIPElectrode* Electrode7 = DCIPElectrode::New();
+    DCIPElectrode* Electrode8 = DCIPElectrode::New();
+    DCIPElectrode* Electrode9 = DCIPElectrode::New();
+
+        //Electrode1->SetLocation( Vector3r( 23.23, 18.1, -45 )  );
+        Electrode2->SetLocation( Vector3r( 13.23, 18.1, -25 ) );
+        Electrode3->SetLocation( Vector3r( 13.23, 18.1, -25 ) );
+        Electrode4->SetLocation( Vector3r( 13.23, 18.1, -25 ) );
+        Electrode4->SetLocation( Vector3r( 13.23, 18.1, -25 ) );
+        Electrode5->SetLocation( Vector3r( 13.23, 18.1, -25 ) );
+        Electrode6->SetLocation( Vector3r( 13.23, 18.1, -25 ) );
+        Electrode7->SetLocation( Vector3r( 13.23, 18.1, -25 ) );
+        Electrode8->SetLocation( Vector3r( 13.23, 18.1, -25 ) );
+        Electrode9->SetLocation( Vector3r( 13.23, 18.1, -25 ) );
+
+//:        std::cout << *Electrode1 << std::endl;
+//     std::ofstream ofstr("DCIPElectrode.yaml");
+//         ofstr << *Electrode1;
+//         ofstr.close();
+
+    /*
+    //std::ifstream ifstr("DCIPElectrode.yaml");
+    std::ifstream ifstr("test.yaml");
+    YAML::Node node = YAML::Load(ifstr);
+    DCIPElectrode* Ex = DCIPElectrode::DeSerialize(node);
+    std::cout << *Ex << std::endl;
+    */
+    //exit(1);
+
+    //std::cout << *Electrode << std::endl;
+    //std::cout << *Electrode2 << std::endl;
+
+    // Set up a Survey
+    DCSurvey* Survey = DCSurvey::New();
+        // Instead we should just put location in, and then survey acts as factory?
+        DCIPElectrode* Electrode1 = Survey->PoundElectrode( Vector3r( 13.23, 18.1, -25 ), "L0-E0" );
+        Survey->PoundElectrode( Electrode2 , "L0-E1" );
+        Survey->PoundElectrode( Electrode3 , "L0-E2" );
+        Survey->PoundElectrode( Electrode4 , "L0-E3" );
+        Survey->PoundElectrode( Electrode5 , "L0-E4" );
+        Survey->PoundElectrode( Electrode6 , "L0-E5" );
+        Survey->PoundElectrode( Electrode7 , "L0-E6" );
+        Survey->PoundElectrode( Electrode8 , "L0-E7" );
+        Survey->PoundElectrode( Electrode9 , "L0-E8" );
+
+        int J0 = Survey->AddInjection( Electrode1, Electrode2, 1.0 );
+            Survey->AddMeasurement(J0, Electrode3, Electrode4 );
+            Survey->AddMeasurement(J0, Electrode5, Electrode6 );
+            Survey->AddMeasurement(J0, Electrode6, Electrode7 );
+            Survey->AddMeasurement(J0, "L0-E7", "L0-E8" );
+
+        int J1 = Survey->AddInjection( Electrode2, Electrode3, 1.0 );
+            Survey->AddMeasurement(J1, Electrode3, Electrode4 );
+            Survey->AddMeasurement(J1, Electrode5, Electrode6 );
+            Survey->AddMeasurement(J1, Electrode6, Electrode7 );
+
+        int J2 = Survey->AddInjection( Electrode3, Electrode4, 1.0 );
+            Survey->AddMeasurement(J2, Electrode3, Electrode4 );
+            Survey->AddMeasurement(J2, Electrode5, Electrode6 );
+            Survey->AddMeasurement(J2, Electrode6, Electrode7 );
+
+        //Survey->AddMeasurement(L1, L2)
+        std::cout << *Survey << std::endl;
+
+        std::ofstream outstr("DC.yaml");
+            outstr << *Survey << std::endl;
+            outstr.close();
+
+        Survey->Delete();
+
+        //TODO recheck DeSerialize make sure we are filling in all the Tag vectors
+
+        std::ifstream ifstr2("DC.yaml");
+        YAML::Node node2 = YAML::Load(ifstr2);
+        DCSurvey* Survey2 = DCSurvey::DeSerialize(node2);
+
+        std::cout << "==============================================================\n";
+        std::cout << *Survey2 << std::endl;
+
+    return(EXIT_SUCCESS);
+
+}
+

LemmaCore/examples/datatem.cpp

@@ -0,0 +1,44 @@
+// ===========================================================================
+//
+//       Filename:
+//
+//    Description:
+//
+//        Version:  0.0
+//        Created:  03/02/2010 02:10:53 PM
+//       Revision:  none
+//       Compiler:  Tested with g++, icpc, and MSVC 2000
+//
+//         Author:  Trevor Irons (ti)
+//
+//   Organisation:  Colorado School of Mines (CSM)
+//                  United States Geological Survey (USGS)
+//
+//          Email:  tirons@mines.edu, tirons@usgs.gov
+//
+//  This program is free software: you can redistribute it and/or modify
+//  it under the terms of the GNU General Public License as published by
+//  the Free Software Foundation, either version 3 of the License, or
+//  (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+//
+// ===========================================================================
+
+#include "Lemma"
+using namespace Lemma;
+
+int main() {
+
+	DataTEM * tdata = DataTEM::New();
+	std::cout << *tdata << std::endl;
+	tdata->Zero();
+	tdata->Delete();
+
+}

LemmaCore/examples/digitalfiltercostrans.cpp

@@ -0,0 +1,69 @@
+// ===========================================================================
+//
+//       Filename:  utdigitalfiltercostrans.cpp
+//
+//        Created:  02/08/2011 11:52:39 AM
+//       Compiler:  Tested with g++, icpc, and MSVC 2010
+//
+//         Author:  Trevor Irons (ti)
+//
+//   Organisation:  Colorado School of Mines (CSM)
+//                  United States Geological Survey (USGS)
+//
+//          Email:  tirons@mines.edu, tirons@usgs.gov
+//
+//  This program is free software: you can redistribute it and/or modify
+//  it under the terms of the GNU General Public License as published by
+//  the Free Software Foundation, either version 3 of the License, or
+//  (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+//
+// ===========================================================================
+
+/**
+  @file
+  @author   Trevor Irons
+  @date     02/08/2011
+  @version   0.0
+ **/
+
+#include "digitalfiltercostrans.h"
+#include "costransintegrationkernel.h"
+#include "integrationkernel.h"
+
+//class TestDriverKernel : public IntegrationKernel<Real> {
+//
+//};
+
+using namespace Lemma;
+
+int main() {
+
+	//Real A = 2.;
+	//Real B = 12.5;
+
+    Real A = 1.;
+    Real B = 2.;
+    DigitalFilterCosTrans* Cos = DigitalFilterCosTrans::New();
+    std::cout << *Cos << std::endl;
+    CosTransIntegrationKernel* Kernel = CosTransIntegrationKernel::New();
+    Cos->AttachKernel(Kernel);
+
+    Cos->Compute(B, 1, 1e-16);
+    std::cout << "numeric  " << Cos->GetAnswer() << std::endl;
+    Real SQPI = std::sqrt(PI);
+    Real analytic =  SQPI*std::exp(-B*B/(4.*A*A))/(2.*A);
+    std::cout << "analytic " << analytic <<std::endl;
+    std::cout << "absolute error " <<  Cos->GetAnswer()(0,0) - analytic <<std::endl;
+    std::cout << "relative error " << (Cos->GetAnswer()(0,0) - analytic) / analytic <<std::endl;
+
+    Cos->Delete();
+    Kernel->Delete();
+}

LemmaCore/examples/dipolefreqsweep.cpp

@@ -0,0 +1,345 @@
+/* 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/29/2014 09:53:49 PM
+ * @version   $Id$
+ * @author    Trevor Irons (ti)
+ * @email     Trevor.Irons@xri-geo.com
+ * @copyright Copyright (c) 2014, XRI Geophysics, LLC
+ * @copyright Copyright (c) 2014, Trevor Irons
+ */
+
+#include <iostream>
+#include <fstream>
+#include "dipolesource.h"
+#include "layeredearthem.h"
+#include "receiverpoints.h"
+#include "emearth1d.h"
+
+#ifdef LEMMAUSEOMP
+#include "omp.h"
+#endif
+
+// For testing purposes disable VTK and run scale.sh
+//#undef LEMMAUSEVTK
+//#undef KIHALEE_EM1D
+
+#ifdef LEMMAUSEVTK
+#include "vtkRenderer.h"
+#include "vtkRenderWindow.h"
+#include "vtkRenderWindowInteractor.h"
+#include "vtkDoubleArray.h"
+#include "vtkXYPlotActor.h"
+#include "vtkXYPlotWidget.h"
+#include "vtkProperty2D.h"
+#endif
+
+#include "timer.h"
+
+using namespace Lemma;
+
+int main() {
+
+    // Do calculation
+    jsw_timer timer;
+
+    DipoleSource *dipole = DipoleSource::New();
+    dipole->SetType(MAGNETICDIPOLE);
+        dipole->SetPolarisation(0., 0.0,  1.0);
+        //dipole->SetPolarisation(XPOLARISATION);
+        //dipole->SetPolarisation(YPOLARISATION);
+        //dipole->SetPolarisation(ZPOLARISATION);
+
+        //dipole->SetMoment(1);
+        //dipole->SetLocation(1,1,-.0100328);
+        dipole->SetLocation(0., 0., -0.001);
+        //dipole->SetLocation(-2.5,1.25,0);
+        int iif=10000;
+        dipole->SetNumberOfFrequencies(iif);
+        Real w0 = 10;
+        for (int iw=0; iw<iif; ++iw) {
+            dipole->SetFrequency(iw, w0);
+            w0 += 1523.;
+        }
+
+    VectorXcr sigma(8);
+    sigma << 0., 3e-4, 5e-4, 1e-2, .5, 5e-6, .03, .04;
+    VectorXr  thick(6);
+        thick << 10 , 10 , 10 , 10 , 10 , 10;
+
+    LayeredEarthEM *earth = LayeredEarthEM::New();
+        earth->SetNumberOfLayers(8);
+        earth->SetLayerConductivity(sigma);
+        earth->SetLayerThickness(thick);
+
+    ReceiverPoints *receivers = ReceiverPoints::New();
+        Vector3r loc;
+        receivers->SetNumberOfReceivers(1);
+        loc << 150, 175, -.01;
+        receivers->SetLocation(0, loc);
+
+    // EmEarth
+    EMEarth1D  *EmEarth = EMEarth1D::New();
+        EmEarth->AttachDipoleSource(dipole);
+        EmEarth->AttachLayeredEarthEM(earth);
+        EmEarth->AttachReceiverPoints(receivers);
+        //EmEarth->SetFieldsToCalculate(BOTH);
+        EmEarth->SetFieldsToCalculate(H);
+
+        //EmEarth->SetHankelTransformMethod(GAUSSIANQUADRATURE);
+        //EmEarth->SetHankelTransformMethod(DIGITALFILTERING);
+        //EmEarth->SetHankelTransformMethod(FHTKEY201);
+        EmEarth->SetHankelTransformMethod(QWEKEY);
+
+    timer.begin();
+    EmEarth->MakeCalc3();
+    //std::cout << "H\n" << receivers->GetHfield(0)
+    //          << "End of H" << std::endl;
+    Real  lemmaTime = timer.end();
+    //std::cout << receivers->GetHfield() << std::endl;
+    std::cout << lemmaTime << "\t";
+
+    #ifdef LEMMAUSEVTK
+    vtkDataObject *_dataObjectxr = receivers->GetVtkDataObjectFreq(HFIELDREAL, 0,
+                    0, iif, XCOMPONENT, dipole->GetFrequencies());
+
+    vtkDataObject *_dataObjectxi = receivers->GetVtkDataObjectFreq(HFIELDIMAG, 0,
+                    0, iif, XCOMPONENT, dipole->GetFrequencies());
+
+    vtkDataObject *_dataObjectyr= receivers->GetVtkDataObjectFreq(HFIELDREAL, 0,
+                    0, iif, YCOMPONENT, dipole->GetFrequencies());
+
+    vtkDataObject *_dataObjectyi = receivers->GetVtkDataObjectFreq(HFIELDIMAG, 0,
+                    0, iif, YCOMPONENT, dipole->GetFrequencies());
+
+    vtkDataObject *_dataObjectzr = receivers->GetVtkDataObjectFreq(HFIELDREAL, 0,
+                    0, iif, ZCOMPONENT, dipole->GetFrequencies());
+
+    vtkDataObject *_dataObjectzi = receivers->GetVtkDataObjectFreq(HFIELDIMAG, 0,
+                    0, iif, ZCOMPONENT, dipole->GetFrequencies());
+    #endif
+
+
+//     //dipole->SetPolarisation(XPOLARISATION);
+//     //std::cout << "Fortran Calc" << std::endl;
+//     #ifdef KIHALEE_EM1D
+//     timer.begin();
+//     EmEarth->MakeCalc();
+//     Real fortranTime = timer.end();
+//     std::cout << fortranTime << "\t";
+//     std::cout << fortranTime/lemmaTime << std::endl;
+//     #endif
+
+//     #ifdef LEMMAUSEVTK
+//     vtkDataObject *_fdataObjectxr = receivers->GetVtkDataObjectFreq(HFIELDREAL, 0,
+//                     0, receivers->GetNumberOfReceivers(), XCOMPONENT, dipole->GetFrequencies());
+//
+//     vtkDataObject *_fdataObjectxi = receivers->GetVtkDataObjectFreq(HFIELDIMAG, 0,
+//                     0, receivers->GetNumberOfReceivers(), XCOMPONENT, dipole->GetFrequencies());
+//
+//     vtkDataObject *_fdataObjectyr = receivers->GetVtkDataObjectFreq(HFIELDREAL, 0,
+//                     0, receivers->GetNumberOfReceivers(), YCOMPONENT, dipole->GetFrequencies());
+//
+//     vtkDataObject *_fdataObjectyi = receivers->GetVtkDataObjectFreq(HFIELDIMAG, 0,
+//                     0, receivers->GetNumberOfReceivers(), YCOMPONENT, dipole->GetFrequencies());
+//
+//     vtkDataObject *_fdataObjectzr = receivers->GetVtkDataObjectFreq(HFIELDREAL, 0,
+//                     0, receivers->GetNumberOfReceivers(), ZCOMPONENT, dipole->GetFrequencies());
+//
+//     vtkDataObject *_fdataObjectzi = receivers->GetVtkDataObjectFreq(HFIELDIMAG, 0,
+//                     0, receivers->GetNumberOfReceivers(), ZCOMPONENT, dipole->GetFrequencies());
+//     #endif
+
+
+    #ifdef LEMMAUSEVTK
+    vtkRenderer *_ren = vtkRenderer::New();
+    vtkRenderWindow *_renwin = vtkRenderWindow::New();
+    _renwin->AddRenderer(_ren);
+
+    ///////////////////////////////////////////////
+    // X Component Plot
+    vtkXYPlotActor *_xplot = vtkXYPlotActor::New();
+    //vtkXYPlotWidget *_wplot = vtkXYPlotWidget::New();
+        // Add the datasets
+        _xplot->AddDataObjectInput( _dataObjectxr);
+        _xplot->AddDataObjectInput( _dataObjectxi);
+        //_xplot->AddDataObjectInput(_fdataObjectxr);
+        //_xplot->AddDataObjectInput(_fdataObjectxi);
+        _xplot->SetTitle("X field");
+        _xplot->SetXTitle("Depth");
+        _xplot->SetYTitle("E Field");
+        _xplot->SetXValuesToValue();
+        //_plot->SetXValuesToIndex();
+
+        // set which parts of the data object are to be used for which axis
+        _xplot->SetDataObjectXComponent(0,1);
+        _xplot->SetDataObjectYComponent(0,0);
+        _xplot->SetDataObjectXComponent(1,1);
+        _xplot->SetDataObjectYComponent(1,0);
+        _xplot->SetDataObjectXComponent(2,1);
+        _xplot->SetDataObjectYComponent(2,0);
+        _xplot->SetDataObjectXComponent(3,1);
+        _xplot->SetDataObjectYComponent(3,0);
+        _xplot->SetNumberOfXLabels(3);
+        _xplot->SetPlotColor(0,1,1,1);
+        _xplot->SetPlotColor(1,1,1,1);
+        _xplot->SetPlotColor(2,1,0,0);
+        _xplot->SetPlotColor(3,1,0,0);
+        _xplot->GetProperty()->SetLineWidth(2);
+        _xplot->GetProperty()->SetPointSize(4);
+
+        //  _plot->SetPlotPoints(0,0);
+        //  _plot->SetPlotPoints(1,0);
+        //  _plot->SetPlotPoints(2,0);
+        //  _plot->SetPlotPoints(3,0);
+
+        //  _plot->SetPlotLines(0,0);
+        //  _plot->SetPlotLines(1,0);
+        //  _plot->SetPlotLines(2,0);
+        //  _plot->SetPlotLines(3,0);
+
+        _xplot->PlotCurvePointsOff();
+        _xplot->PlotCurveLinesOff();
+        _xplot->GetPositionCoordinate()->SetValue(0.0, 0.67, 0);
+        _xplot->GetPosition2Coordinate()->SetValue(1.0, 0.33, 0);
+        //_plot->SetReverseYAxis(1); // Just flips axis, not data!
+
+    ///////////////////////////////////////////////
+    // Y Component Plot
+    vtkXYPlotActor *_yplot = vtkXYPlotActor::New();
+    //vtkXYPlotWidget *_wplot = vtkXYPlotWidget::New();
+        // Add the datasets
+        _yplot->AddDataObjectInput( _dataObjectyr);
+        _yplot->AddDataObjectInput( _dataObjectyi);
+        //_yplot->AddDataObjectInput(_fdataObjectyr);
+        //_yplot->AddDataObjectInput(_fdataObjectyi);
+        _yplot->SetTitle("Y field");
+        _yplot->SetXTitle("Depth");
+        _yplot->SetYTitle("E Field");
+        _yplot->SetXValuesToValue();
+        //_yplot->SetXValuesToIndex();
+
+        // set which parts of the data object are to be used for which axis
+        _yplot->SetDataObjectXComponent(0,1);
+        _yplot->SetDataObjectYComponent(0,0);
+        _yplot->SetDataObjectXComponent(1,1);
+        _yplot->SetDataObjectYComponent(1,0);
+        _yplot->SetDataObjectXComponent(2,1);
+        _yplot->SetDataObjectYComponent(2,0);
+        _yplot->SetDataObjectXComponent(3,1);
+        _yplot->SetDataObjectYComponent(3,0);
+        _yplot->SetNumberOfXLabels(3);
+        _yplot->SetPlotColor(0,1,1,1);
+        _yplot->SetPlotColor(1,1,1,1);
+        _yplot->SetPlotColor(2,1,0,0);
+        _yplot->SetPlotColor(3,1,0,0);
+        _yplot->GetProperty()->SetLineWidth(2);
+        _yplot->GetProperty()->SetPointSize(4);
+        _yplot->GetPositionCoordinate()->SetValue(0.00, 0.33, 0);
+        _yplot->GetPosition2Coordinate()->SetValue(1.0, 0.33, 0);
+
+        //  _plot->SetPlotPoints(0,0);
+        //  _plot->SetPlotPoints(1,0);
+        //  _plot->SetPlotPoints(2,0);
+        //  _plot->SetPlotPoints(3,0);
+
+        //  _plot->SetPlotLines(0,0);
+        //  _plot->SetPlotLines(1,0);
+        //  _plot->SetPlotLines(2,0);
+        //  _plot->SetPlotLines(3,0);
+
+        _yplot->PlotCurvePointsOff();
+        _yplot->PlotCurveLinesOff();
+        //_plot->SetReverseYAxis(1)
+
+    ///////////////////////////////////////////////
+    // Z Component Plot
+    vtkXYPlotActor *_zplot = vtkXYPlotActor::New();
+    //vtkXYPlotWidget *_wplot = vtkXYPlotWidget::New();
+        // Add the datasets
+        _zplot->AddDataObjectInput( _dataObjectzr);
+        _zplot->AddDataObjectInput( _dataObjectzi);
+        //_zplot->AddDataObjectInput(_fdataObjectzr);
+        //_zplot->AddDataObjectInput(_fdataObjectzi);
+        _zplot->SetTitle("Z field");
+        _zplot->SetXTitle("Depth");
+        _zplot->SetYTitle("E Field");
+        _zplot->SetXValuesToValue();
+        //_plot->SetXValuesToIndex();
+
+        // set which parts of the data object are to be used for which axis
+        _zplot->SetDataObjectXComponent(0,1);
+        _zplot->SetDataObjectYComponent(0,0);
+        _zplot->SetDataObjectXComponent(1,1);
+        _zplot->SetDataObjectYComponent(1,0);
+        _zplot->SetDataObjectXComponent(2,1);
+        _zplot->SetDataObjectYComponent(2,0);
+        _zplot->SetDataObjectXComponent(3,1);
+        _zplot->SetDataObjectYComponent(3,0);
+        _zplot->SetNumberOfXLabels(3);
+        _zplot->SetPlotColor(0,1,1,1);
+        _zplot->SetPlotColor(1,1,1,1);
+        _zplot->SetPlotColor(2,1,0,0);
+        _zplot->SetPlotColor(3,1,0,0);
+        _zplot->GetProperty()->SetLineWidth(2);
+        _zplot->GetProperty()->SetPointSize(4);
+        _zplot->GetPositionCoordinate()->SetValue(0.0, 0.0, 0);
+        _zplot->GetPosition2Coordinate()->SetValue(1.0, 0.33, 0);
+        //  _plot->SetPlotPoints(0,0);
+        //  _plot->SetPlotPoints(1,0);
+        //  _plot->SetPlotPoints(2,0);
+        //  _plot->SetPlotPoints(3,0);
+
+        //  _plot->SetPlotLines(0,0);
+        //  _plot->SetPlotLines(1,0);
+        //  _plot->SetPlotLines(2,0);
+        //  _plot->SetPlotLines(3,0);
+
+        _zplot->PlotCurvePointsOff();
+        _zplot->PlotCurveLinesOff();
+        //_plot->SetReverseYAxis(1)
+
+    _ren->AddActor2D(_xplot);
+    _ren->AddActor2D(_yplot);
+    _ren->AddActor2D(_zplot);
+
+    vtkRenderWindowInteractor *_iren = vtkRenderWindowInteractor::New();
+    _iren->SetRenderWindow(_renwin);
+    _iren->Initialize();
+    _renwin->Render();
+
+    //_wplot->SetXYPlotActor(_plot);
+    //_wplot->SetInteractor(_iren);
+    //_wplot->EnabledOn();
+
+    _iren->Start();
+
+    // TODO clean up you dirty whore
+//  _iren->Delete();
+//  _plot->Delete();
+//  _dataObject->Delete();
+//  _fieldData->Delete();
+//  _renwin->Delete();
+//  _ren->Delete();
+//  _xdatareal->Delete();
+//  _ydata->Delete();
+//  _depth->Delete();
+    #endif
+
+    EmEarth->Delete();
+    receivers->Delete();
+    earth->Delete();
+    dipole->Delete();
+
+    return 0;
+
+
+}

LemmaCore/examples/dipolesource.cpp

@@ -0,0 +1,504 @@
+// ===========================================================================
+//
+//       Filename:  utdipolesource.cpp
+//
+//    Description:
+//
+//        Version:  0.0
+//        Created:  12/02/2009 11:57:14 AM
+//       Revision:  none
+//       Compiler:  g++ (c++)
+//
+//         Author:  Trevor Irons (ti)
+//
+//   Organisation:  Colorado School of Mines (CSM)
+//                  United States Geological Survey (USGS)
+//
+//          Email:  tirons@mines.edu, tirons@usgs.gov
+//
+//  This program is free software: you can redistribute it and/or modify
+//  it under the terms of the GNU General Public License as published by
+//  the Free Software Foundation, either version 3 of the License, or
+//  (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+//
+// ===========================================================================
+
+#include <iostream>
+#include <fstream>
+#include "dipolesource.h"
+#include "layeredearthem.h"
+#include "receiverpoints.h"
+#include "emearth1d.h"
+
+#ifdef LEMMAUSEOMP
+#include "omp.h"
+#endif
+
+// For testing purposes disable VTK and run scale.sh
+#undef LEMMAUSEVTK
+#undef KIHALEE_EM1D
+
+#ifdef LEMMAUSEVTK
+#include "vtkRenderer.h"
+#include "vtkRenderWindow.h"
+#include "vtkRenderWindowInteractor.h"
+#include "vtkDoubleArray.h"
+#include "vtkXYPlotActor.h"
+#include "vtkXYPlotWidget.h"
+#include "vtkProperty2D.h"
+#endif
+
+#include "timer.h"
+
+using namespace Lemma;
+
+int main() {
+
+    //////////////////
+    // TODO List of Dipole settings that aren't working
+
+    // Do calculation
+    jsw_timer timer;
+    timer.begin();
+
+    // Test with a single dipole
+    DipoleSource *dipole = DipoleSource::New();
+        //dipole->SetMoment(2);
+        ///////////////////////////////////
+        // E field Tests
+        // Sems to be working!
+        //dipole->SetType(GROUNDEDELECTRICDIPOLE);
+        //dipole->SetPolarisation(XPOLARISATION);
+        //dipole->SetPolarisation(YPOLARISATION);
+        //dipole->SetPolarisation(ZPOLARISATION);
+        //dipole->SetAzimuth(0);  // X - Northing
+        //dipole->SetAzimuth(90); // Y - Easting
+
+        dipole->SetType(GROUNDEDELECTRICDIPOLE);
+            //dipole->SetPolarisation(1., 0.0,  1.0);
+        //    dipole->SetPolarisation(XPOLARISATION);
+        dipole->SetPolarisation(YPOLARISATION);
+        //dipole->SetPolarisation(ZPOLARISATION);
+
+        /////////////
+        //dipole->SetType(MAGNETICDIPOLE);
+            //dipole->SetPolarisation(0., 0.0,  1.0);
+            //dipole->SetPolarisation(XPOLARISATION);
+        //dipole->SetPolarisation(YPOLARISATION);
+        //dipole->SetPolarisation(ZPOLARISATION);
+
+        //dipole->SetMoment(1);
+        //dipole->SetLocation(1,1,-.0100328);
+        dipole->SetLocation(0., 0., -0.001);
+        //dipole->SetLocation(-2.5,1.25,0);
+        dipole->SetNumberOfFrequencies(1);
+        dipole->SetFrequency(0, 2e7);
+        //dipole->SetFrequency(1,2000);
+        //dipole->SetPhase(0);
+
+        //////////////////////////////////
+        // H field Tests
+
+//     // Define model, this is a difficult case
+//     VectorXcr sigma(23);
+//         sigma << 0., 0.0625, 0.0166666666666667, 0.04, 0.0181818181818182,
+//                 0.05, 0.0222222222222222, 0.2, 0.025, 0.05, 0.025,
+//             0.05, 0.00833333333333333, 0.025, 0.05, 0.0222222222222222,
+//             0.0277777777777778, 0.0333333333333333, 0.0208333333333333,
+//             0.0181818181818182, 0.025, 0.04;
+//
+//     VectorXr  thick(21);
+//         //thick << 10, 10, 10, 10, 10, 10;
+//         thick << 11, 5, 5, 4, 3.5, 4.5, 4.5,
+//                  5.5, 3, 36, 15, 3, 6, 3, 8,
+//                  9, 10, 7, 8, 11, 68;
+
+    //VectorXcr sigma(8);
+    //    sigma << 0., Complex(.01,0.01), 0.001, .005, .0034, .0023, .0024, .0001;
+
+    VectorXcr sigma(8);
+        sigma << 0., 3e-4, 5e-4, 1e-2, .5, 5e-6, .03, .04;
+    //VectorXcr sigma(2);
+    //    sigma << 0., .0;
+    //VectorXr susl(3);
+    //    susl << 1., 1., 1.5;//, 5e-6, 5e-6, 5e-6;
+    //VectorXr sush(3);
+    //    sush << 1., 1.01;//, 5e-6, 5e-6, 5e-6;
+    //VectorXr sustau(2);
+    //    sustau << 1., 1.0;//, 5e-6, 5e-6, 5e-6;
+    //VectorXr susb(2);
+    //    susb << 0., .0;//, 5e-6, 5e-6, 5e-6;
+    VectorXr  thick(6);
+        thick << 10 , 10 , 10 , 10 , 10 , 10;
+
+    LayeredEarthEM *earth = LayeredEarthEM::New();
+        earth->SetNumberOfLayers(8);
+        //earth->SetNumberOfLayers(23);
+        earth->SetLayerConductivity(sigma);
+        //earth->SetLayerLowFreqSusceptibility(susl);
+        //earth->SetLayerHighFreqSusceptibility(sush);
+        //earth->SetLayerTauSusceptibility(sustau);
+        //earth->SetLayerBreathSusceptibility(susb);
+        //earth->SetLayerHighFreqSusceptibility(susl);
+        //earth->SetLayerHighFreqSusceptibility(susl);
+        earth->SetLayerThickness(thick);
+
+    // just a test
+    timer.end();
+
+    // Receivers
+    ReceiverPoints *receivers = ReceiverPoints::New();
+        Vector3r loc;
+        Real ox     =  50.;
+        Real oy     =  70. ;
+        Real depth  =  -40.13423;
+        Real depth2 =  depth;
+        Real dz     =  .25;
+        int  nz     =  3000;
+        Real dx     = .0;
+        receivers->SetNumberOfReceivers(nz);
+        int ir = 0;
+        for (int iz=0; iz<nz; ++iz) {
+            loc << ox, oy, depth;
+            receivers->SetLocation(ir, loc);
+            depth += dz;
+            ox += dx;
+            ++ ir;
+        }
+
+    // EmEarth
+    EMEarth1D  *EmEarth = EMEarth1D::New();
+        EmEarth->AttachDipoleSource(dipole);
+        EmEarth->AttachLayeredEarthEM(earth);
+        EmEarth->AttachReceiverPoints(receivers);
+        //EmEarth->SetFieldsToCalculate(BOTH);
+        EmEarth->SetFieldsToCalculate(H);
+
+        //EmEarth->SetHankelTransformMethod(GAUSSIANQUADRATURE);
+        //EmEarth->SetHankelTransformMethod(DIGITALFILTERING);
+        //EmEarth->SetHankelTransformMethod(FHTKEY201);
+        //EmEarth->SetHankelTransformMethod(QWEKEY);
+        EmEarth->SetHankelTransformMethod(FHTKEY51);
+
+    timer.begin();
+    EmEarth->MakeCalc3();
+    //std::cout << "H\n" << receivers->GetHfield(0)
+    //          << "End of H" << std::endl;
+    Real  lemmaTime = timer.end();
+    std::cout << lemmaTime << "\t";
+
+    //std::cout << "Make Calc3\n";
+    //receivers->ClearFields();
+
+    //EmEarth->MakeCalc3();
+    //std::cout << "Make Calc3 finished\n";
+
+    #ifdef LEMMAUSEVTK
+    int iif=0;
+    vtkDataObject *_dataObjectxr = receivers->GetVtkDataObject(HFIELDREAL, iif,
+                    0, receivers->GetNumberOfReceivers(), XCOMPONENT, ZCOORD);
+
+    vtkDataObject *_dataObjectxi = receivers->GetVtkDataObject(HFIELDIMAG, iif,
+                    0, receivers->GetNumberOfReceivers(), XCOMPONENT, ZCOORD);
+
+    vtkDataObject *_dataObjectyr= receivers->GetVtkDataObject(HFIELDREAL, iif,
+                    0, receivers->GetNumberOfReceivers(), YCOMPONENT, ZCOORD);
+
+    vtkDataObject *_dataObjectyi = receivers->GetVtkDataObject(HFIELDIMAG, iif,
+                    0, receivers->GetNumberOfReceivers(), YCOMPONENT, ZCOORD);
+
+    vtkDataObject *_dataObjectzr = receivers->GetVtkDataObject(HFIELDREAL, iif,
+                    0, receivers->GetNumberOfReceivers(), ZCOMPONENT, ZCOORD);
+
+    vtkDataObject *_dataObjectzi = receivers->GetVtkDataObject(HFIELDIMAG, iif,
+                    0, receivers->GetNumberOfReceivers(), ZCOMPONENT, ZCOORD);
+    #endif
+
+    /*
+    // Write out to file
+    depth = depth2;
+    std::fstream real("reale_lay.dat", std::ios::out);
+    std::fstream imag("image_lay.dat", std::ios::out);
+    std::fstream hreal("real_lay.dat", std::ios::out);
+    std::fstream himag("imag_lay.dat", std::ios::out);
+    for (int iz=0; iz<nz; ++iz) {
+        Vector3cr temp = receivers->GetEfield(0,iz);
+
+        //std::cout << temp << endl;
+        real << ox << "\t" << oy << "\t" << depth << "\t"
+                << temp(0).real() << "\t" << temp(1).real()
+                << "\t" << temp(2).real() << std::endl;
+
+        imag << ox << "\t" << oy << "\t" << depth << "\t"
+                << std::imag(temp(0)) << "\t" << std::imag(temp(1))
+                << "\t" << std::imag(temp(2)) << std::endl;
+
+        temp = receivers->GetHfield(0, iz);
+
+        hreal << ox << "\t" << oy << "\t" << depth << "\t"
+                << std::real(temp(0)) << "\t" << std::real(temp(1))
+                << "\t" << std::real(temp(2)) << std::endl;
+        himag << ox << "\t" << oy << "\t" << depth << "\t"
+                << std::imag(temp(0)) << "\t" << std::imag(temp(1))
+                << "\t" << std::imag(temp(2)) << std::endl;
+        depth += dz;
+    }
+    real.close();
+    imag.close();
+    */
+
+    // TODO check all field components for both E and H,
+    // diplay in some sort of reasonable manner.
+    // Then, and only then, optimise.
+
+    receivers->ClearFields();
+
+    //dipole->SetPolarisation(XPOLARISATION);
+    //std::cout << "Fortran Calc" << std::endl;
+    #ifdef KIHALEE_EM1D
+    timer.begin();
+    EmEarth->MakeCalc();
+    Real fortranTime = timer.end();
+    std::cout << fortranTime << "\t";
+    std::cout << fortranTime/lemmaTime << std::endl;
+    #endif
+
+    #ifdef LEMMAUSEVTK
+    vtkDataObject *_fdataObjectxr = receivers->GetVtkDataObject(HFIELDREAL, 0,
+                    0, receivers->GetNumberOfReceivers(), XCOMPONENT, ZCOORD);
+
+    vtkDataObject *_fdataObjectxi = receivers->GetVtkDataObject(HFIELDIMAG, 0,
+                    0, receivers->GetNumberOfReceivers(), XCOMPONENT, ZCOORD);
+
+    vtkDataObject *_fdataObjectyr = receivers->GetVtkDataObject(HFIELDREAL, 0,
+                    0, receivers->GetNumberOfReceivers(), YCOMPONENT, ZCOORD);
+
+    vtkDataObject *_fdataObjectyi = receivers->GetVtkDataObject(HFIELDIMAG, 0,
+                    0, receivers->GetNumberOfReceivers(), YCOMPONENT, ZCOORD);
+
+    vtkDataObject *_fdataObjectzr = receivers->GetVtkDataObject(HFIELDREAL, 0,
+                    0, receivers->GetNumberOfReceivers(), ZCOMPONENT, ZCOORD);
+
+    vtkDataObject *_fdataObjectzi = receivers->GetVtkDataObject(HFIELDIMAG, 0,
+                    0, receivers->GetNumberOfReceivers(), ZCOMPONENT, ZCOORD);
+    #endif
+
+    // Simple 2D plot in vtk to compare algorithms
+    #ifdef LEMMAUSEVTK
+    vtkRenderer *_ren = vtkRenderer::New();
+    vtkRenderWindow *_renwin = vtkRenderWindow::New();
+        _renwin->AddRenderer(_ren);
+
+    ///////////////////////////////////////////////
+    // X Component Plot
+    vtkXYPlotActor *_xplot = vtkXYPlotActor::New();
+    //vtkXYPlotWidget *_wplot = vtkXYPlotWidget::New();
+        // Add the datasets
+        _xplot->AddDataObjectInput( _dataObjectxr);
+        _xplot->AddDataObjectInput( _dataObjectxi);
+        _xplot->AddDataObjectInput(_fdataObjectxr);
+        _xplot->AddDataObjectInput(_fdataObjectxi);
+        _xplot->SetTitle("H_x");
+        _xplot->SetXTitle("");
+        _xplot->SetYTitle("");
+        _xplot->SetXValuesToValue();
+        //_plot->SetXValuesToIndex();
+
+        // set which parts of the data object are to be used for which axis
+        _xplot->SetDataObjectXComponent(0,1);
+        _xplot->SetDataObjectYComponent(0,0);
+        _xplot->SetDataObjectXComponent(1,1);
+        _xplot->SetDataObjectYComponent(1,0);
+        _xplot->SetDataObjectXComponent(2,1);
+        _xplot->SetDataObjectYComponent(2,0);
+        _xplot->SetDataObjectXComponent(3,1);
+        _xplot->SetDataObjectYComponent(3,0);
+        _xplot->SetNumberOfXLabels(3);
+
+        _xplot->SetPlotColor(0,1,1,1);
+        _xplot->SetPlotColor(1,0,0,1);
+
+        _xplot->SetPlotColor(2,1,0,0);
+        _xplot->SetPlotColor(3,0,1,0);
+
+        _xplot->SetPlotLabel(0, "Lemma real" );
+        _xplot->SetPlotLabel(1, "Lemma imag" );
+        _xplot->SetPlotLabel(2, "KiHa real" );
+        _xplot->SetPlotLabel(3, "KiHa imag" );
+
+        _xplot->GetProperty()->SetLineWidth(1);
+        _xplot->GetProperty()->SetPointSize(22);
+
+        _xplot->LegendOn();
+        //  _plot->SetPlotPoints(0,0);
+        //  _plot->SetPlotPoints(1,0);
+        //  _plot->SetPlotPoints(2,0);
+        //  _plot->SetPlotPoints(3,0);
+
+        //  _plot->SetPlotLines(0,0);
+        //  _plot->SetPlotLines(1,0);
+        //  _plot->SetPlotLines(2,0);
+        //  _plot->SetPlotLines(3,0);
+
+        _xplot->PlotCurvePointsOff();
+        _xplot->PlotCurveLinesOff();
+        _xplot->GetPositionCoordinate()->SetValue(0.0, 0.67, 0);
+        _xplot->GetPosition2Coordinate()->SetValue(1.0, 0.33, 0);
+        //_plot->SetReverseYAxis(1); // Just flips axis, not data!
+
+    ///////////////////////////////////////////////
+    // Y Component Plot
+    vtkXYPlotActor *_yplot = vtkXYPlotActor::New();
+    //vtkXYPlotWidget *_wplot = vtkXYPlotWidget::New();
+        // Add the datasets
+        _yplot->AddDataObjectInput( _dataObjectyr);
+        _yplot->AddDataObjectInput( _dataObjectyi);
+        _yplot->AddDataObjectInput(_fdataObjectyr);
+        _yplot->AddDataObjectInput(_fdataObjectyi);
+        _yplot->SetTitle("H_y");
+        _yplot->SetXTitle("");
+        _yplot->SetYTitle("");
+        _yplot->SetXValuesToValue();
+        //_yplot->SetXValuesToIndex();
+
+        // set which parts of the data object are to be used for which axis
+        _yplot->SetDataObjectXComponent(0,1);
+        _yplot->SetDataObjectYComponent(0,0);
+        _yplot->SetDataObjectXComponent(1,1);
+        _yplot->SetDataObjectYComponent(1,0);
+        _yplot->SetDataObjectXComponent(2,1);
+        _yplot->SetDataObjectYComponent(2,0);
+        _yplot->SetDataObjectXComponent(3,1);
+        _yplot->SetDataObjectYComponent(3,0);
+        _yplot->SetNumberOfXLabels(3);
+
+        _yplot->SetPlotColor(0,1,1,1);
+        _yplot->SetPlotColor(1,0,0,1);
+
+        _yplot->SetPlotColor(2,1,0,0);
+        _yplot->SetPlotColor(3,0,1,0);
+
+        _yplot->SetPlotLabel(0, "Lemma real" );
+        _yplot->SetPlotLabel(1, "Lemma imag" );
+        _yplot->SetPlotLabel(2, "KiHa real" );
+        _yplot->SetPlotLabel(3, "KiHa imag" );
+        _yplot->LegendOn();
+
+        _yplot->GetProperty()->SetLineWidth(1);
+        _yplot->GetProperty()->SetPointSize(12);
+        _yplot->GetPositionCoordinate()->SetValue(0.00, 0.33, 0);
+        _yplot->GetPosition2Coordinate()->SetValue(1.0, 0.33, 0);
+
+        //  _plot->SetPlotPoints(0,0);
+        //  _plot->SetPlotPoints(1,0);
+        //  _plot->SetPlotPoints(2,0);
+        //  _plot->SetPlotPoints(3,0);
+
+        //  _plot->SetPlotLines(0,0);
+        //  _plot->SetPlotLines(1,0);
+        //  _plot->SetPlotLines(2,0);
+        //  _plot->SetPlotLines(3,0);
+
+        _yplot->PlotCurvePointsOff();
+        _yplot->PlotCurveLinesOff();
+        //_plot->SetReverseYAxis(1)
+
+    ///////////////////////////////////////////////
+    // Z Component Plot
+    vtkXYPlotActor *_zplot = vtkXYPlotActor::New();
+    //vtkXYPlotWidget *_wplot = vtkXYPlotWidget::New();
+        // Add the datasets
+        _zplot->AddDataObjectInput( _dataObjectzr);
+        _zplot->AddDataObjectInput( _dataObjectzi);
+        _zplot->AddDataObjectInput(_fdataObjectzr);
+        _zplot->AddDataObjectInput(_fdataObjectzi);
+        _zplot->SetTitle("H_z");
+        _zplot->SetXTitle("Depth");
+        _zplot->SetYTitle("");
+        _zplot->SetXValuesToValue();
+        //_plot->SetXValuesToIndex();
+
+        // set which parts of the data object are to be used for which axis
+        _zplot->SetDataObjectXComponent(0,1);
+        _zplot->SetDataObjectYComponent(0,0);
+        _zplot->SetDataObjectXComponent(1,1);
+        _zplot->SetDataObjectYComponent(1,0);
+        _zplot->SetDataObjectXComponent(2,1);
+        _zplot->SetDataObjectYComponent(2,0);
+        _zplot->SetDataObjectXComponent(3,1);
+        _zplot->SetDataObjectYComponent(3,0);
+        _zplot->SetNumberOfXLabels(3);
+
+        _zplot->SetPlotColor(0,1,1,1);
+        _zplot->SetPlotColor(1,0,0,1);
+
+        _zplot->SetPlotColor(2,1,0,0);
+        _zplot->SetPlotColor(3,0,1,0);
+
+        _zplot->LegendOn();
+
+        _zplot->SetPlotLabel(0, "Lemma real" );
+        _zplot->SetPlotLabel(1, "Lemma imag" );
+        _zplot->SetPlotLabel(2, "KiHa real" );
+        _zplot->SetPlotLabel(3, "KiHa imag" );
+
+        _zplot->GetProperty()->SetLineWidth(1);
+        _zplot->GetProperty()->SetPointSize(14);
+        _zplot->GetPositionCoordinate()->SetValue(0.0, 0.0, 0);
+        _zplot->GetPosition2Coordinate()->SetValue(1.0, 0.33, 0);
+        //  _plot->SetPlotPoints(0,0);
+        //  _plot->SetPlotPoints(1,0);
+        //  _plot->SetPlotPoints(2,0);
+        //  _plot->SetPlotPoints(3,0);
+
+        //  _plot->SetPlotLines(0,0);
+        //  _plot->SetPlotLines(1,0);
+        //  _plot->SetPlotLines(2,0);
+        //  _plot->SetPlotLines(3,0);
+
+        _zplot->PlotCurvePointsOn();
+        _zplot->PlotCurveLinesOff();
+        //_plot->SetReverseYAxis(1)
+
+    _ren->AddActor2D(_xplot);
+    _ren->AddActor2D(_yplot);
+    _ren->AddActor2D(_zplot);
+
+    vtkRenderWindowInteractor *_iren = vtkRenderWindowInteractor::New();
+    _iren->SetRenderWindow(_renwin);
+    _iren->Initialize();
+    _renwin->Render();
+
+    //_wplot->SetXYPlotActor(_plot);
+    //_wplot->SetInteractor(_iren);
+    //_wplot->EnabledOn();
+
+    _iren->Start();
+
+    // TODO clean up you dirty whore
+//  _iren->Delete();
+//  _plot->Delete();
+//  _dataObject->Delete();
+//  _fieldData->Delete();
+//  _renwin->Delete();
+//  _ren->Delete();
+//  _xdatareal->Delete();
+//  _ydata->Delete();
+//  _depth->Delete();
+    #endif
+
+    EmEarth->Delete();
+    receivers->Delete();
+    earth->Delete();
+    dipole->Delete();
+
+    return 0;
+}

LemmaCore/examples/edipole.cpp

@@ -0,0 +1,231 @@
+// ===========================================================================
+//
+//       Filename:  utsnmrinversion1d.cpp
+//
+//        Created:  10/07/2010 08:57:04 AM
+//       Compiler:  Tested with g++, icpc, and MSVC 2010
+//
+//         Author:  Trevor Irons (ti)
+//
+//   Organisation:  Colorado School of Mines (CSM)
+//                  United States Geological Survey (USGS)
+//
+//          Email:  tirons@mines.edu, tirons@usgs.gov
+//
+//  This program is free software: you can redistribute it and/or modify
+//  it under the terms of the GNU General Public License as published by
+//  the Free Software Foundation, either version 3 of the License, or
+//  (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+//
+// ===========================================================================
+
+/**
+  @file
+  @author   Trevor Irons
+  @date     10/07/2010
+  @version   0.0
+ **/
+
+#include "receiverpoints.h"
+#include "emearth1d.h"
+#include "dipolesource.h"
+
+using namespace Lemma;
+
+std::vector<Real>  readinpfile(const std::string& fname);
+
+int main(int argc, char** argv) {
+
+    std::cout <<
+    "\n"
+    << "ediple.exe Copyright (C) 2011 Broken Spoke Development, LLC\n\n"
+    << "This program is free software: you can redistribute it and/or modify\n"
+    << "it under the terms of the GNU General Public License as published by\n"
+    << "the Free Software Foundation, either version 3 of the License, or\n"
+    << "(at your option) any later version.\n\n"
+
+    << "This program is distributed in the hope that it will be useful,\n"
+    << "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
+    << "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
+    << "GNU General Public License for more details.\n\n"
+
+    << "You should have received a copy of the GNU General Public License\n"
+    << "along with this program.  If not, see <http://www.gnu.org/licenses/>.\n\n";
+
+    if (argc < 4) {
+        std::cout << "usage: edipole.exe  dipole.inp cond.inp points.inp \n";
+        exit(0);
+    }
+
+    std::vector<Real> Trans   = readinpfile(std::string(argv[1]));
+    std::vector<Real> CondMod = readinpfile(std::string(argv[2]));
+    std::vector<Real> Points  = readinpfile(std::string(argv[3]));
+
+    //////////////////////////////////////
+    // Define dipole source
+    DipoleSource* dipole = DipoleSource::New();
+        switch ( (int)(Trans[0]) ) {
+            case 0:
+                dipole->SetType(MAGNETICDIPOLE);
+                break;
+            case 1:
+                dipole->SetType(GROUNDEDELECTRICDIPOLE);
+                break;
+            default:
+                std::cerr << "Undefined dipole type, must be:\n"
+                     << "\t0 -> Magnetic\n"
+                     << "\t1 -> Grounded Electric\n";
+                exit(EXIT_FAILURE);
+        }
+
+        switch ( (int)(Trans[1]) ) {
+            case 0:
+                dipole->SetPolarisation(XPOLARISATION);
+                break;
+            case 1:
+                dipole->SetPolarisation(YPOLARISATION);
+                break;
+            case 2:
+                dipole->SetPolarisation(ZPOLARISATION);
+                break;
+            default:
+                std::cerr << "Undefined orientation, must be:\n"
+                          << "\t0 -> x\n"
+                          << "\t1 -> y\n"
+                          << "\t2 -> z\n";
+                exit(EXIT_FAILURE);
+        }
+        dipole->SetNumberOfFrequencies(1);
+        dipole->SetFrequency(0, Trans[2]);
+        dipole->SetLocation(Trans[3], Trans[4], Trans[5]);
+        dipole->SetMoment(Trans[6]);
+
+	// Receivers
+ 	ReceiverPoints *receivers = ReceiverPoints::New();
+        int nx = (int)Points[0];
+        int ny = (int)Points[1];
+        int nz = (int)Points[2];
+        Real ox = Points[3];
+        Real oy = Points[4];
+        Real oz = Points[5];
+     	Vector3r loc;
+        VectorXr dx(nx-1); // TODO map the dx, dy, dz vectors
+        VectorXr dy(ny-1);
+        VectorXr dz(nz-1);
+        int ip = 6;
+        int ir = 0;
+        for ( ; ip <6+nx-1; ++ip) {
+            dx[ir] = Points[ip];
+            ++ir;
+        }
+        ir = 0;
+        for ( ; ip <6+ny-1+nx-1; ++ip) {
+            dy[ir] = Points[ip];
+            ++ir;
+        }
+        ir = 0;
+        for ( ; ip <6+nz-1+ny-1+nx-1; ++ip) {
+            dz[ir] = Points[ip];
+            ++ir;
+        }
+ 		receivers->SetNumberOfReceivers(nx*ny*nz);
+ 		ir = 0;
+        Real pz  = oz;
+ 		for (int iz=0; iz<nz; ++iz) {
+ 		    Real py    =  oy;
+ 		    for (int iy=0; iy<ny; ++iy) {
+ 		        Real px    =  ox;
+ 		        for (int ix=0; ix<nx; ++ix) {
+ 			        loc << px, py, pz;
+ 			        receivers->SetLocation(ir, loc);
+ 			        if (ix < nx-1) px += dx[ix];
+ 			        ++ ir;
+     	        }
+                if (iy<ny-1) py += dy[iy];
+            }
+            if (iz<nz-1) pz += dz[iz];
+        }
+
+    ////////////////////////////////////
+    // Define model
+    LayeredEarthEM *earth = LayeredEarthEM::New();
+    VectorXcr sigma;
+    VectorXr  thick;
+ 	earth->SetNumberOfLayers(CondMod[0]+1);
+ 	sigma.resize(CondMod[0]+1); sigma(0) = 0; // airlayer
+    thick.resize(CondMod[0]-1);
+    int ilay=1;
+    for ( ; ilay/2<CondMod[0]-1; ilay+=2) {
+        sigma(ilay/2+1) =  1./CondMod[ilay];
+        thick(ilay/2) =  CondMod[ilay+1];
+    }
+    sigma(ilay/2+1) = 1./ CondMod[ilay];
+	earth->SetLayerConductivity(sigma);
+    if (thick.size() > 0) earth->SetLayerThickness(thick);
+
+	EMEarth1D  *EmEarth = EMEarth1D::New();
+		EmEarth->AttachDipoleSource(dipole);
+		EmEarth->AttachLayeredEarthEM(earth);
+		EmEarth->AttachReceiverPoints(receivers);
+		EmEarth->SetFieldsToCalculate(E);
+        EmEarth->MakeCalc3();
+
+    ////////////////////////////////////
+    // Report
+ 	std::fstream hreal("efield.dat", std::ios::out);
+    hreal << *dipole << std::endl;
+    hreal << *earth << std::endl;
+    hreal << "Right hand coordinate system, z is positive down\n\n";
+    hreal << "x[m]\ty[m]\tz[m]\tRe(Ex) [V/m]\t Im(Ex) [V/m]\tRe(Ey) [V/m]\tIm(Ey) [V/m]\tRe(Ez) [V/m] Im(Ez) [V/m]\n";
+    hreal << "\\\\ ====================================================================================================\n";
+    hreal.precision(8);
+    int i=0;
+	for (int iz=0; iz<nz; ++iz) {
+	for (int iy=0; iy<ny; ++iy) {
+	for (int ix=0; ix<nx; ++ix) {
+        hreal << receivers->GetLocation(i).transpose() << "\t";
+ 		hreal << std::real(receivers->GetEfield(0, i).transpose()[0]) << "\t";
+ 		hreal << std::imag(receivers->GetEfield(0, i).transpose()[0]) << "\t";
+ 		hreal << std::real(receivers->GetEfield(0, i).transpose()[1]) << "\t";
+ 		hreal << std::imag(receivers->GetEfield(0, i).transpose()[1]) << "\t";
+ 		hreal << std::real(receivers->GetEfield(0, i).transpose()[2]) << "\t";
+ 		hreal << std::imag(receivers->GetEfield(0, i).transpose()[2]) << "\n";
+        ++i;
+    }
+    }
+    }
+    hreal.close();
+
+    // Clean up
+    EmEarth->Delete();
+    earth->Delete();
+    receivers->Delete();
+    dipole->Delete();
+}
+
+std::vector<Real>  readinpfile(const std::string& fname) {
+    std::string buf;
+    char dump[255];
+    std::vector<Real> vals;
+    std::fstream input(fname.c_str(), std::ios::in);
+    if (input.fail()) {
+        std::cerr << "Input file " << fname << " failed to open\n";
+        exit(EXIT_FAILURE);
+    }
+    while (input >> buf) {
+        if (buf.substr(0,2) == "//") {
+            input.getline(dump, 255);
+        } else {
+            vals.push_back( atof(buf.c_str() ));
+        }
+    }
+    return vals;
+}

LemmaCore/examples/emdipearth1d.cpp

@@ -0,0 +1,141 @@
+// ===========================================================================
+//
+//       Filename:  utemdipearth1d.cpp
+//
+//    Description:
+//
+//        Version:  0.0
+//        Created:  01/06/2010 04:27:56 PM
+//       Revision:  none
+//       Compiler:  g++ (c++)
+//
+//         Author:  Trevor Irons (ti)
+//
+//   Organisation:  Colorado School of Mines (CSM)
+//                  United States Geological Survey (USGS)
+//
+//          Email:  tirons@mines.edu, tirons@usgs.gov
+//
+//  This program is free software: you can redistribute it and/or modify
+//  it under the terms of the GNU General Public License as published by
+//  the Free Software Foundation, either version 3 of the License, or
+//  (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+//
+// ===========================================================================
+#include "emearth1d.h"
+#include "dipolesource.h"
+#include "layeredearthem.h"
+#include "receiverpoints.h"
+
+using namespace Lemma;
+
+int main() {
+
+	// Test with a single dipole
+	DipoleSource *dipole = DipoleSource::New();
+		dipole->SetType(GROUNDEDELECTRICDIPOLE);
+		dipole->SetPolarisation(XPOLARISATION);
+		dipole->SetNumberOfFrequencies(1);
+		dipole->SetMoment(1);
+		dipole->SetFrequency(0, 4400.1000);
+		//dipole->SetPhase(0);
+		//dipole->SetLocation( (VectorXr(3) << 49, 49, -1e-4).finished() );
+		dipole->SetLocation( 49, 49, -1e-4  );
+
+
+	// Define model
+	VectorXcr sigma(2);
+		sigma << 0., 1e-3;//, .1;//, .01, .001;
+	VectorXr  thick(1);
+		thick << 10;//, 10, 10;
+
+	LayeredEarthEM *earth = LayeredEarthEM::New();
+        earth->SetNumberOfLayers(2);
+		earth->SetLayerConductivity(sigma);
+		//earth->SetLayerThickness(thick);
+
+	// Receivers
+	ReceiverPoints *receivers = ReceiverPoints::New();
+		Vector3r loc;
+		//Real ox = -5.1456;
+		//Real oy =  2.2350;
+		Real ox =    50.;
+		Real oy =    20.;
+		Real depth = 18.10;
+		Real dz = 2.6;
+		int  nz = 1;
+
+		receivers->SetNumberOfReceivers(nz);
+		int ir = 0;
+		for (int iz=0; iz<nz; ++iz) {
+			loc << ox, oy, depth;
+			receivers->SetLocation(ir, loc);
+			depth += dz;
+			++ ir;
+		}
+	//receivers->SetLocation(1, ox, oy, depth);
+
+	EMEarth1D *EmEarth = EMEarth1D::New();
+        //EmEarth->SetHankelTransformMethod(DIGITALFILTERING);
+        EmEarth->SetFieldsToCalculate(BOTH); // Fortran needs this
+		EmEarth->AttachDipoleSource(dipole);
+		EmEarth->AttachLayeredEarthEM(earth);
+		EmEarth->AttachReceiverPoints(receivers);
+
+        //dipole->SetType(ELECTRICDIPOLE);
+//         receivers->SetNumberOfReceivers(1);
+//         //for
+// 	    receivers->SetLocation(0, ox, oy, depth);
+
+
+	std::cout << "C++\n";
+	EmEarth->MakeCalc3();
+	std::cout << receivers->GetEfield(0,0) << std::endl;
+	//std::cout << receivers->GetEfield(0) << std::endl;
+	//std::cout << receivers->GetHfield(1) << std::endl;
+	//std::cout << receivers->GetEfield(1) << std::endl;
+	receivers->ClearFields();
+
+    // swap tx rx posigion
+    receivers->SetLocation(0, dipole->GetLocation());
+    dipole->SetLocation(loc);
+	EmEarth->MakeCalc3();
+	std::cout << receivers->GetEfield(0,0) << std::endl;
+
+	receivers->ClearFields();
+ #ifdef KIHALEE_EM1D
+// 	//std::cout << "\nFORTRAN\n";
+ 	EmEarth->MakeCalc();
+// 	std::cout << receivers->GetHfield(0,0) << std::endl;
+ 	std::cout << receivers->GetEfield(0,0) << std::endl;
+ #endif
+
+    dipole->Delete();
+    EmEarth->Delete();
+    receivers->Delete();
+    earth->Delete();
+
+// 	try {
+//
+// 	}
+//
+// 	// Catch exceptions
+// 	catch (NullEarth) {
+// 			std::cout << "Earth model not set dummy\n";
+// 	}
+//
+// 	catch (NullReceivers) {
+// 			std::cout << "Receivers not set dummy\n";
+// 	}
+
+	//EmEarth->TestBess();
+
+}

LemmaCore/examples/femforward.cpp

@@ -0,0 +1,199 @@
+// ===========================================================================
+// 
+//       Filename:  utfemforward.cpp
+// 
+//    Description:  
+// 
+//        Version:  0.0
+//        Created:  01/15/2013 12:11:34 PM
+//       Revision:  none
+//       Compiler:  Tested with g++ 
+// 
+//         Author:  M. Andy Kass (MAK)
+//
+//   Organisation:  Broken Spoke Development, LLC
+//                  
+//
+//          Email:  mkass@numericalgeo.com
+// 
+//  This program is free software: you can redistribute it and/or modify
+//  it under the terms of the GNU General Public License as published by
+//  the Free Software Foundation, either version 3 of the License, or
+//  (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+//
+// ===========================================================================
+
+#include <time.h>
+#include "Lemma"
+#include "banner.h"
+
+using namespace Lemma;
+
+#ifdef LEMMAUSEVTK
+#include "matplot.h"
+using namespace matplot;
+#endif
+
+int main() {
+
+	clock_t launch = clock();
+
+	// Banner display
+	std::string name;
+	std::string version;
+	std::string usage;
+	name = "FEM Forward Modeller - 1D ";
+	version = "1.0alpha";
+	usage = "utfemforward [inputfile]";
+	banner(name,version,usage);
+
+	time_t curr = time(0);
+	std::cout << std::endl << "  Start time: " << ctime(&curr) << std::endl;
+
+	// Define some objects
+	DipoleSource* Trans = DipoleSource::New();
+	ReceiverPoints* Receivers = ReceiverPoints::New();
+	LayeredEarthEM* Earth = LayeredEarthEM::New();
+
+
+
+	// SINGLE SOUNDING
+
+	// Create new data object to receive forward model
+	DataFEM* modelledData = DataFEM::New();
+
+	// Create instrument object
+	InstrumentFem* theinstrument = InstrumentFem::New();	
+
+	// Set up EMEarthModel
+	Earth->SetNumberOfLayers(5);
+	Earth->SetLayerConductivity((VectorXcr(5) << 0.,1.e-4,1.e-2,
+		1.e-4,1.e-6).finished());
+	Earth->SetLayerThickness((VectorXr(3) << 20.,5.,50.).finished());
+	
+	// Set up transmitter
+	Real momtemp;
+	momtemp = 1;
+	Real freq;
+	freq = 391;
+	Trans->SetType(MAGNETICDIPOLE);
+	Trans->SetLocation(0,0,-1.e-3);
+	Trans->SetPolarisation(ZPOLARISATION);
+	// as a test
+	Trans->SetNumberOfFrequencies(1);
+	Trans->SetFrequency(0,freq);
+	Trans->SetMoment(momtemp);
+
+	// Set up receivers
+	Vector3r loc1;
+	Vector3r loc2;
+	Receivers->SetNumberOfReceivers(1);
+	loc1 << 9,0,-1.e-3;
+	Receivers->SetLocation(0,loc1);
+
+
+	// Attach to instrument
+	theinstrument->SetReceiverPoints(Receivers);
+	theinstrument->SetDipoleSource(Trans);
+	theinstrument->EMEarthModel(Earth);
+	theinstrument->SetOutputData(modelledData);
+
+	// Calculate
+	theinstrument->MakeCalculation();
+
+	// See what comes back...
+	std::cout << Receivers->GetHfield(0,0)(2) << std::endl;
+	
+	// Need to convert H field to ppm
+
+
+	theinstrument->Delete();
+	modelledData->Delete();
+
+	// MULTIPLE SOUNDING MODEL USING READ-IN DATA
+
+
+	InstrumentFem* theinstrument2 = InstrumentFem::New();
+	DataFEM* modelledData2 = DataFEM::New();
+
+	// Using the UBC data reader to read in the survey params
+	// this will be used for the multiple sounding testing
+	std::string datfile;
+	datfile = "126.obs";
+
+	DataReaderFemUBC* Reader = DataReaderFemUBC::New();
+	DataFEM* inpdata = DataFEM::New();
+	Reader->SetDataFEM(inpdata);
+	try {
+		Reader->ReadData(datfile,1);
+	} catch(std::exception& e) {
+		exit(EXIT_FAILURE);
+	}
+	std::cout << *inpdata << std::endl;
+	theinstrument2->SetOutputData(modelledData2);
+	theinstrument2->AlignWithData(inpdata);
+	// Now, how do I want to pass it an earth model for each sounding?
+	//
+	inpdata->Delete();
+
+
+
+
+	// Need to loop over transmitters
+	// The relative positions of the transmitter and receiver is fixed
+	// For testing, do some kind of random realisation of Earth model?
+//	int nObs;
+//	int nFreqs;
+//	nObs = inpdata->GetnObs();
+//	nFreqs = inpdata->GetnFreq();
+
+//	Trans->SetType(MAGNETICDIPOLE);
+//	Trans->SetLocation(0,0,-1e-3);
+
+//	Vector3r loc;
+//	Receivers->SetNumberOfReceivers(1);
+//	loc << 0,0,-1e-3;
+//	Receivers->SetLocation(0,loc);
+
+//	Earth->SetNumberOfLayers(5); //Including the two halfspaces
+//	Earth->SetLayerConductivity((VectorXcr(5) << 0.,1.e-4,1.e-2,
+//		1.e-4,1.e-6).finished());
+//	Earth->SetLayerThickness((VectorXr(3) << 20.,5.,50.).finished());
+
+//	for (int ii=0;ii<nObs;ii++) {
+//		for (int jj=0;jj<nFreqs;jj++) {
+//			Trans->SetMoment(inpdata->GetTxMom().coeff(jj));
+//			
+//		}
+//	}
+	
+	//This is a bunch of testing stuff
+	//theinstrument->AlignWithData(inpdata);
+	//theinstrument->MakeCalculation();
+	//inpdata->Delete();
+	//theinstrument->MakeCalculation();
+
+
+	theinstrument2->Delete();
+	Reader->Delete();
+	Earth->Delete();
+	Receivers->Delete();
+	Trans->Delete();
+
+	// Timey-wimey stuff
+	Real time;
+	clock_t done = clock();
+	time = (done-launch)/CLOCKS_PER_SEC;
+	std::cout << "  Execution time: " << time << " [CPU] seconds."
+		<< std::endl;
+
+	return EXIT_SUCCESS;
+}

LemmaCore/examples/filter.cpp

@@ -0,0 +1,53 @@
+// ===========================================================================
+//
+//       Filename:  utfilter.cpp
+//
+//        Created:  07/20/2010 10:12:07 AM
+//       Compiler:  Tested with g++, icpc, and MSVC 2010
+//
+//         Author:  Trevor Irons (ti)
+//
+//   Organisation:  Colorado School of Mines (CSM)
+//                  United States Geological Survey (USGS)
+//
+//          Email:  tirons@mines.edu, tirons@usgs.gov
+//
+//  This program is free software: you can redistribute it and/or modify
+//  it under the terms of the GNU General Public License as published by
+//  the Free Software Foundation, either version 3 of the License, or
+//  (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+//
+// ===========================================================================
+
+/**
+  @author   Trevor Irons
+  @date     07/20/2010
+  @version   0.0
+ **/
+
+#include "windowfilter.h"
+using namespace Lemma;
+
+int main() {
+
+    WindowFilter* Hamming = WindowFilter::New();
+
+        Hamming->SetWindowType( HANNING );
+        Hamming->SetSamplingInterval(1e-4);
+        Hamming->SetBandwidth(300);
+        Hamming->SetNumberOfSamples(1./1e-4);
+
+    std::cout << Hamming->GetFilterCoefficients() //.transpose()
+              << std::endl;
+
+    Hamming->Delete();
+
+}

LemmaCore/examples/utORS.cpp

@@ -0,0 +1,342 @@
+// ===========================================================================
+//
+//       Filename:  utdipolesource.cpp
+//
+//    Description:
+//
+//        Version:  0.0
+//        Created:  12/02/2009 11:57:14 AM
+//       Revision:  none
+//       Compiler:  g++ (c++)
+//
+//         Author:  Trevor Irons (ti)
+//
+//   Organisation:  Colorado School of Mines (CSM)
+//                  United States Geological Survey (USGS)
+//
+//          Email:  tirons@mines.edu, tirons@usgs.gov
+//
+//  This program is free software: you can redistribute it and/or modify
+//  it under the terms of the GNU General Public License as published by
+//  the Free Software Foundation, either version 3 of the License, or
+//  (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+//
+// ===========================================================================
+
+#include <iostream>
+#include <fstream>
+
+#include "dipolesource.h"
+#include "layeredearth.h"
+#include "receiverpoints.h"
+#include "emearth1d.h"
+#include "WireAntenna.h"
+#include "PolygonalWireAntenna.h"
+
+#if  LEMMAUSEVTK
+#include "vtkRenderer.h"
+#include "vtkRenderWindow.h"
+#include "vtkRenderWindowInteractor.h"
+#include "vtkRenderLargeImage.h"
+#include "vtkPNGWriter.h"
+#include "vtkRectilinearGrid.h"
+#include "vtkXMLRectilinearGridWriter.h"
+#include "vtkDoubleArray.h"
+#include "vtkFieldData.h"
+#include "vtkCellData.h"
+#endif     // -----  not LEMMA_USE_VTK  -----
+
+// For testing purposes disable VTK and run scale.sh
+//#undef LEMMAUSEVTK
+
+#include "timer.h"
+
+using namespace Lemma;
+
+double randDouble(double low, double high) {
+	//srand(time(0));
+	double temp;
+	/* swap low & high around if the user makes no sense */
+	if (low > high)	{
+	temp = low;
+	low = high;
+	high = temp;
+	}
+	/* calculate the random number & return it */
+	temp = (rand() / (static_cast<double>(RAND_MAX) + 1.0))
+	* (high - low) + low;
+	return temp;
+}
+
+
+int main() {
+
+	// Keep track of time
+	jsw_timer timer;
+
+
+	srand(time(0));
+
+	PolygonalWireAntenna *pa = PolygonalWireAntenna::New();
+	pa->SetNumberOfFrequencies(1);
+	pa->SetFrequency(0, 540000);
+    Real Depth  =   370;  // nominal depth
+    Real Width  = 0.14;  // transmitter height
+    Real Height = 0.70;//  .14;  //.014;  // transmitter width
+
+
+	pa->SetNumberOfPoints(5);
+    /*
+    pa->SetPoint(0, Vector3r(       0,       0, Depth));
+	pa->SetPoint(1, Vector3r(       0,       0, Depth+Height));
+	pa->SetPoint(2, Vector3r(       0,   Width, Depth+Height));
+	pa->SetPoint(3, Vector3r(       0,   Width, Depth));
+	pa->SetPoint(4, Vector3r(       0,       0, Depth));
+    */
+
+    pa->SetPoint(0, Vector3r(   -Width/2., -Height/2., Depth));
+	pa->SetPoint(1, Vector3r(    Width/2., -Height/2., Depth));
+	pa->SetPoint(2, Vector3r(    Width/2.,  Height/2., Depth));
+	pa->SetPoint(3, Vector3r(   -Width/2.,  Height/2., Depth));
+	pa->SetPoint(4, Vector3r(   -Width/2., -Height/2., Depth));
+
+	pa->SetCurrent(1.);
+    pa->SetNumberOfTurns(6);
+	//Vector3r rp = Vector3r::Random(3);
+	//rp << 150., 10, 0.;
+	//rp << -27.1456, 15.2350, -1e-3;
+	//rp << randDouble(-35,35), randDouble(-35,35), randDouble(-35,35);
+	//rp << 3.22806, -13.1548, 14.9695;
+	//rp.setRandom(3);
+	//std::cout <<  "rp " << rp.transpose() << std::endl;
+	//pa->ApproximateWithElectricDipoles(rp);
+
+
+	// Define model
+    Real Sigma = 1.0/20. ; // .05;
+	VectorXcr sigma(2);
+		sigma << Complex(0.,0), Complex(Sigma,0);
+	VectorXr  thick(1);
+		thick << 10;
+	LayeredEarthEM *earth = LayeredEarthEM::New();
+		earth->SetNumberOfLayers(2);
+		earth->SetLayerConductivity(sigma);
+		//earth->SetLayerThickness(thick);
+
+	// Receivers
+	ReceiverPoints *receivers = ReceiverPoints::New();
+		Vector3r loc;
+		Real ox    =    -5.*Width - .003373;
+		Real oy    =    -3.*Height - .003373;
+		Real oz    =    Depth - Height/2. - .003373;
+		int nx     =   120; // 60;
+		int ny     =   180; //  50;
+		int nz     =   100; // 40;
+		Real hx    =    11.*Width/nx;
+		Real hy    =     7.*Height/ny;
+		Real hz    =     1.*Height/nz;
+
+        receivers->SetNumberOfReceivers(nx*ny*nz);
+		int ir = 0;
+		for (int iz=0; iz<nz; ++iz) {
+		for (int iy=0; iy<ny; ++iy) {
+		for (int ix=0; ix<nx; ++ix) {
+			loc << ox+ix*hx, oy+iy*hy, oz+iz*hz;
+			receivers->SetLocation(ir, loc);
+			++ ir;
+		}
+        }
+        }
+
+	// EmEarth
+	EMEarth1D  *EmEarth = EMEarth1D::New();
+		//EmEarth->AttachWireAntenna(wire);
+		EmEarth->AttachWireAntenna(pa);
+		EmEarth->AttachLayeredEarthEM(earth);
+		EmEarth->AttachReceiverPoints(receivers);
+		EmEarth->SetFieldsToCalculate(E);
+        //EmEarth->SetHankelTransformMethod(GAUSSIANQUADRATURE);
+        EmEarth->SetHankelTransformMethod(ANDERSON801);
+
+	// Do calculation
+	timer.begin();
+	EmEarth->CalculateWireAntennaFields();
+	Real paTime = timer.end();
+	std::cout << "Polygonal wire antennae time: " << paTime << "\n";
+
+	//EmEarth->AttachWireAntenna(wire);
+	//timer.begin();
+	//EmEarth->CalculateWireAntennaFields();
+	//Real waTime = timer.end();
+	//std::cout << "Fixed wire antennae time: " << waTime << "\n";
+/*
+	depth = depth2;
+	std::fstream real("reale_lay.dat", std::ios::out);
+	std::fstream imag("image_lay.dat", std::ios::out);
+	for (int iz=0; iz<nz; ++iz) {
+		Vector3cr temp = receivers->GetEfield(0,iz);
+		real << ox << "\t" << oy << "\t" << depth << "\t"
+				<< temp(0).real() << "\t" << temp(1).real()
+				<< "\t" << temp(2).real() << std::endl;
+		imag << ox << "\t" << oy << "\t" << depth << "\t"
+				<< std::imag(temp(0)) << "\t" << std::imag(temp(1))
+				<< "\t" << std::imag(temp(2)) << std::endl;
+		depth += dx;
+	}
+	real.close();
+	imag.close();
+*/
+
+	//wire->Delete();
+#if  LEMMAUSEVTK
+
+    // Set Coordinates
+    vtkDoubleArray *xCoords = vtkDoubleArray::New();
+    xCoords->InsertNextValue(ox-hx/2.);
+    double xm1 = ox-hx/2.;
+    for (int ix=0; ix<nx; ix++) {
+        xCoords->InsertNextValue(xm1 + hx);
+        xm1 += hx;
+    }
+
+    vtkDoubleArray *yCoords = vtkDoubleArray::New();
+    yCoords->InsertNextValue(oy-hy/2.);
+    double ym1 = oy-hy/2.;
+    for (int iy=0; iy<ny; iy++) {
+        yCoords->InsertNextValue(ym1 + hy);
+        ym1 += hy;
+    }
+
+    vtkDoubleArray *zCoords = vtkDoubleArray::New();
+    zCoords->InsertNextValue(oz-hz/2.);
+    double zm1 = oz-hz/2.;
+    for (int iz=0; iz<nz; iz++) {
+        zCoords->InsertNextValue(zm1 + hz);
+        zm1 += hz;
+    }
+
+    vtkDoubleArray *EReal = vtkDoubleArray::New();
+    vtkDoubleArray *EImag = vtkDoubleArray::New();
+    vtkDoubleArray *Watts = vtkDoubleArray::New();
+    EReal->SetNumberOfComponents(3);
+    EImag->SetNumberOfComponents(3);
+    Watts->SetNumberOfComponents(1);
+
+    ir = 0;
+    Real WattsTotal(0);
+    Real WattsInterior(0);
+    for (int iz=0; iz<nz; ++iz) {
+    for (int iy=0; iy<ny; ++iy) {
+    for (int ix=0; ix<nx; ++ix) {
+        //sigmaArray->InsertTuple1(i,  sigma[ix][iy][iz] );
+		Vector3cr E = receivers->GetEfield(0, ir);
+        EReal-> InsertTuple3(ir, real(E(0)), real(E(1)), real(E(2)));
+        EImag-> InsertTuple3(ir, imag(E(0)), imag(E(1)), imag(E(2)));
+        //std::cout << std::abs(ox+ix*hx) << "\t"  <<  Width/2. << endl; // && std::abs(oy+iy*hy) > Height/2. ) { // && std::abs(oz+iz*hz - Depth) > Width/2. ) {
+        //if ( std::abs( ox+ix*hx ) < Width/2. && std::abs(oy+iy*hy) < Height/2. && std::abs(oz+iz*hz - Depth) < Width/2. ) {
+        if ( std::sqrt( std::pow(ox+ix*hx,2)  + std::pow(oz+iz*hz - Depth, 2) ) < .085 && std::abs(oy+iy*hy) < Height/2. ) {
+            Watts-> InsertTuple1(ir,  1e-20 );
+            WattsInterior += .5*  (( pow((std::abs(E(0)) + std::abs(E(1)) + std::abs(E(2))), 2)*Sigma)*hx*hy*hz );
+        } else {
+            Watts-> InsertTuple1(ir, .5* (pow( (std::abs(E(0)) + std::abs(E(1)) + std::abs(E(2))), 2)*Sigma)*hx*hy*hz );
+            //Watts-> InsertTuple1(ir,  1e-20 );
+            WattsTotal += .5*  (( pow((std::abs(E(0)) + std::abs(E(1)) + std::abs(E(2))), 2)*Sigma)*hx*hy*hz );
+        }
+		++ ir;
+    }
+    }
+    }
+    std::cout << "Total Power: " << Sigma << "\t" << WattsTotal << "\t" << WattsInterior << endl;
+
+    EReal->SetName("E_real");
+    EImag->SetName("E_imag");
+    Watts->SetName("Power");
+
+    vtkRectilinearGrid *rgrid = vtkRectilinearGrid::New();
+        rgrid->SetDimensions(nx+1,ny+1,nz+1);
+        rgrid->SetXCoordinates(xCoords);
+        rgrid->SetYCoordinates(yCoords);
+        rgrid->SetZCoordinates(zCoords);
+
+        rgrid->GetCellData()->AddArray(EReal);
+        rgrid->GetCellData()->AddArray(EImag);
+        rgrid->GetCellData()->AddArray(Watts);
+        //rgrid->Update();
+
+    vtkXMLRectilinearGridWriter *gridWrite = vtkXMLRectilinearGridWriter::New();
+        gridWrite->SetInputData(rgrid);
+        gridWrite->SetFileName("ors.vtr");
+        gridWrite->Write();
+        //gridWrite->Update();
+
+#endif
+	EmEarth->Delete();
+	receivers->Delete();
+	earth->Delete();
+
+#if  LEMMAUSEVTKX
+	// Create the usual rendering stuff.
+	vtkRenderer           *renderer = vtkRenderer::New();
+	vtkRenderWindow         *renWin = vtkRenderWindow::New();
+	vtkRenderWindowInteractor *iren = vtkRenderWindowInteractor::New();
+
+	std::cout << "wire antennae approximating " << std::endl;
+	loc << 0, .5*Width, Depth+.5*Height;
+	pa->ApproximateWithElectricDipoles(loc);
+    std::cout <<  "Wire approximated with " << pa->GetNumberOfDipoles() << std::endl;
+
+    vtkActor **pdipActors = new vtkActor*[pa->GetNumberOfDipoles()];
+	for (int id=0; id<pa->GetNumberOfDipoles(); ++id) {
+		pdipActors[id] = pa->GetVtkActor(id);
+		renderer->AddActor(pdipActors[id]);
+	}
+
+    /*
+    vtkActor **dipActors = new vtkActor*[wire->GetNumberOfDipoles()];
+	for (int id=0; id<wire->GetNumberOfDipoles(); ++id) {
+		dipActors[id] = wire->GetVtkActor(id);
+		renderer->AddActor(dipActors[id]);
+	}
+    */
+
+	renderer->SetBackground(1,1,1);
+
+	// Render the window
+	renWin->AddRenderer(renderer);
+	renWin->SetWindowName("Wire antennae");
+
+	iren->SetRenderWindow(renWin);
+	iren->Initialize();
+	iren->Start();
+	iren->Render();
+
+    #if 0
+	cout << "Enter File name?: ";
+	std::string pngName;
+	std::cin >> pngName;
+	vtkPNGWriter *pngwrite = vtkPNGWriter::New();
+	vtkRenderLargeImage *renlarge = vtkRenderLargeImage::New();
+	renlarge->SetInput(renderer);
+	renlarge->SetMagnification(2);
+	pngwrite->SetInputConnection(renlarge->GetOutputPort());
+	pngName.append(".png");
+	pngwrite->SetFileName(pngName.c_str());
+	pngwrite->Write();
+    #endif
+
+#endif     // -----  not LEMMA_USE_VTK  -----
+
+
+	//std::cout << *pa << std::endl;
+	//pa->Delete();
+
+	return 0;
+}

LemmaCore/examples/utQWEKey.cpp

@@ -0,0 +1,34 @@
+/* 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      02/12/2014 01:01:29 PM
+ * @version   $Id$
+ * @author    Trevor Irons (ti)
+ * @email     Trevor.Irons@xri-geo.com
+ * @copyright Copyright (c) 2014, XRI Geophysics, LLC
+ * @copyright Copyright (c) 2014, Trevor Irons
+ */
+
+#include "QWEKey.h"
+using namespace Lemma;
+
+int main() {
+
+    // TODO chech
+
+    QWEKey* QWE = QWEKey::New();
+    QWE->TestPrivate( 5 );
+    QWE->Delete();
+
+    return 0;
+}
+
+

LemmaCore/examples/utSerialize.cpp

@@ -0,0 +1,86 @@
+/* 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      09/29/2014 01:31:26 PM
+ * @version   $Id$
+ * @author    Trevor Irons (ti)
+ * @email     Trevor.Irons@xri-geo.com
+ * @copyright Copyright (c) 2014, XRI Geophysics, LLC
+ * @copyright Copyright (c) 2014, Trevor Irons
+ */
+
+#include "Lemma"
+
+using namespace Lemma;
+
+#ifdef  HAVE_YAMLCPP
+#include "yaml-cpp/yaml.h"
+
+int main() {
+
+    std::ofstream ofstr("output.yaml");
+    //ofstr << "%YAML 1.2\n" << "---\n";
+    //ofstr << "LEMMA_CLASSES:\n";
+
+    // This works for individual classes or even groups of unrelated classes. But
+    // How should references work? One option would be to hack YAML and allow for references
+    // across 'Docs'. This is maybe undesireable, as then it's not valid YAML anymore.
+    // OR we could have some other kind of IDENTIFIER that could be used and Connections could be
+    // made AFTER the whole file is processed?
+
+    // Alternative is each class is written to it's own file. And then implicit on the Serialize function, the file tags are written
+    // into the YAML instead of the pointer. Alternatively, tags could do this too.
+
+    // Or file could be saved as pointer.yaml
+
+    // *
+    // * Or a file contains all the subclasses it point to. So that it's self-enclosed. This is nice as it's quite
+    // * flexible. The only downwside is possible repeat of classes. Basically if the API is careful though, only 1
+    // * instance will need to be serialized.
+    // *
+
+
+    TEMTransmitter* Seq = TEMTransmitter::New();
+        Seq->SetRepFrequency( 20, KHZ );
+        VectorXr Times (18);
+        VectorXr Amps (18);
+        Times << 0.0, 0.03051, 0.10267, 0.19408, 0.19889, 0.21332, 0.74249, 1.3775, 1.83452, 2.52245, \
+                3.191132, 3.9031135, 4.0, 4.00484486, 4.123904, 4.200182, 4.20732, 4.212946;
+        Amps << 0.0, 14.71872, 62.34372, 114.84372, 117.84372, 118.96872, 118.96872, 118.96872, 118.96872,\
+                118.59372, 119.34372, 120.0, 120.0, 117.94176, 47.60364, 0.8905848, 0.1203888, 0.0;
+        Seq->SetWaveform(Times, Amps, MILLISEC);
+    // OK dump to disk
+    ofstr << *Seq ;
+    ofstr.close();
+    Seq->Delete();
+
+
+    // OK now load
+    std::ifstream ifstr("output.yaml");
+    std::vector<YAML::Node> nodes = YAML::LoadAll(ifstr);
+
+    TEMTransmitter* Seq2 = TEMTransmitter::DeSerialize( nodes[0] );
+    std::cout << "Loaded\n" << *Seq2;
+    Seq2->Delete();
+    ifstr.close();
+
+    //YAML::Node nodes = YAML::LoadFile("output.yaml");
+    //std::cout << nodes[0] << std::endl;
+    //std::cout << nodes[1] << std::endl;
+
+    exit(EXIT_SUCCESS);
+}
+
+#else
+int main() {
+
+}
+#endif

LemmaCore/examples/utSkyTEM.cpp

@@ -0,0 +1,31 @@
+/* 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      02/27/2015 11:02:43 AM
+ * @version   $Id$
+ * @author    Trevor Irons (ti)
+ * @email     Trevor.Irons@xri-geo.com
+ * @copyright Copyright (c) 2015, XRI Geophysics, LLC
+ * @copyright Copyright (c) 2015, Trevor Irons
+ */
+
+// SkyTEM forward modelling programme
+
+#include "TEMSurvey.h"
+
+int main() {
+
+    std::cout << "SkyTEM modelling\n";
+
+
+
+}
+

LemmaCore/examples/utTEMSurvey.cpp

@@ -0,0 +1,197 @@
+/* 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      10/06/2014 10:37:30 AM
+ * @version   $Id$
+ * @author    Trevor Irons (ti)
+ * @email     Trevor.Irons@xri-geo.com
+ * @copyright Copyright (c) 2014, XRI Geophysics, LLC
+ * @copyright Copyright (c) 2014, Trevor Irons
+ */
+
+#include "Lemma"
+using namespace Lemma;
+
+int main() {
+
+    // Each pulse sequence functions as an autonomous transmitter. A record may contain multiple transmitters (moments).
+    // There is some small overhead for wire loop locations, but generality is retained doing this, as well as monitoring of
+    // slight changes in geometry for both pulses.
+    TEMTransmitter* TxHM = TEMTransmitter::New();
+        TxHM->SetRepFrequency( 20, KHZ );
+        VectorXr Times (18);
+        VectorXr Amps (18);
+        Times << 0.0, 0.03051, 0.10267, 0.19408, 0.19889, 0.21332, 0.74249, 1.3775, 1.83452, 2.52245, \
+                3.191132, 3.9031135, 4.0, 4.00484486, 4.123904, 4.200182, 4.20732, 4.212946;
+        Amps << 0.0, 14.71872, 62.34372, 114.84372, 117.84372, 118.96872, 118.96872, 118.96872, 118.96872,\
+                118.59372, 119.34372, 120.0, 120.0, 117.94176, 47.60364, 0.8905848, 0.1203888, 0.0;
+        TxHM->SetWaveform( Times, Amps, MILLISEC );
+        // Define wire loop
+        TxHM->SetNumberOfPoints(8);
+        TxHM->SetPoint(0, Vector3r( -16.10,    2.13,  -34));
+        TxHM->SetPoint(1, Vector3r(  -7.51,   10.72,  -34));
+        TxHM->SetPoint(2, Vector3r(   7.51,   10.72,  -34));
+        TxHM->SetPoint(3, Vector3r(  14.92,    3.31,  -34));
+        TxHM->SetPoint(4, Vector3r(  14.92,   -3.31,  -34));
+        TxHM->SetPoint(5, Vector3r(   7.51,  -10.72,  -34));
+        TxHM->SetPoint(6, Vector3r(  -7.51,  -10.72,  -34));
+        TxHM->SetPoint(7, Vector3r( -16.10,   -2.13,  -34));
+        TxHM->SetNumberOfTurns(8);
+
+    // Each Transmitter needs its own `Receiver(s)', the only difference may be the time gates, but that's OK.
+    //     It's a minor amount of overhead for greatly improved genearality. As sometimes different gates are
+    //     masked.
+    TEMInductiveReceiver* RxHM = TEMInductiveReceiver::New();
+        RxHM->SetComponent( ZCOMPONENT );      // What about Overloaded to take (X), (X,Y), or (X,Y,Z) or what about tilt?
+        RxHM->SetMoment( 1 );                  // Normalized
+        RxHM->SetReferenceTime( 4., MILLISEC );
+        RxHM->SetRxLocation( (Vector3r() << -16.80, 0, -36.00).finished() );
+
+        // Gate Centres  ms
+        VectorXr centres (37);
+        centres << 7.15000000e-04,   2.21500000e-03,   4.21500000e-03,   6.21500000e-03,
+                   8.21500000e-03,   1.02150000e-02,   1.22150000e-02,   1.47150000e-02,
+                   1.82150000e-02,   2.27150000e-02,   2.82150000e-02,   3.52150000e-02,
+                   4.42150000e-02,   5.57150000e-02,   7.02150000e-02,   8.82150000e-02,
+                   1.10715000e-01,   1.38715000e-01,   1.74215000e-01,   2.19715000e-01,
+                   2.76715000e-01,   3.48715000e-01,   4.39715000e-01,   5.53715000e-01,
+                   6.97715000e-01,   8.79215000e-01,   1.10771500e+00,   1.39621500e+00,
+                   1.76021500e+00,   2.21871500e+00,   2.79671500e+00,   3.52571500e+00,
+                   4.44471500e+00,   5.60321500e+00,   7.06321500e+00,   8.90421500e+00,
+                   1.10667200e+01;
+        //centres.array() += 4.;
+
+        // Gate Widths  ms
+        VectorXr widths (37);
+        widths <<   4.30000000e-04,   1.43000000e-03,   3.43000000e-03,   5.43000000e-03,
+                    7.43000000e-03,   9.43000000e-03,   1.14300000e-02,   1.34300000e-02,
+                    1.64300000e-02,   2.04300000e-02,   2.54300000e-02,   3.14300000e-02,
+                    3.94300000e-02,   4.94300000e-02,   6.24300000e-02,   7.84300000e-02,
+                    9.84300000e-02,   1.23430000e-01,   1.54430000e-01,   1.94430000e-01,
+                    2.45430000e-01,   3.08430000e-01,   3.89430000e-01,   4.90430000e-01,
+                    6.17430000e-01,   7.78430000e-01,   9.80430000e-01,   1.23543000e+00,
+                    1.55743000e+00,   1.96343000e+00,   2.47443000e+00,   3.11943000e+00,
+                    3.93243000e+00,   4.95743000e+00,   6.24943000e+00,   7.87743000e+00,
+                    9.93143000e+00;
+
+        RxHM->SetWindows(centres, widths, MILLISEC);
+
+    TEMTransmitter* TxLM = TEMTransmitter::New();
+        TxLM->SetRepFrequency( 20, KHZ );
+        VectorXr TimesLM (18);
+        VectorXr AmpsLM (18);
+
+        TimesLM << -8.00000E-004, -7.86965E-004, -7.66493E-004, -7.23688E-004,
+                   -6.39938E-004, -5.16174E-004, -3.93340E-004, -2.63993E-004,
+                   -1.43952E-004, -7.15990E-006, -2.50712E-006,  0.00000E+000,
+                    2.19597E-007,  1.47193E-006,  3.34398E-006,  4.68669E-006,
+                    5.96484E-006,  7.04934E-006;
+        TimesLM.array() = TimesLM.array() + 8e-4;  // Valgrind Hack += yields error. Correct for SkyTEM convention
+
+
+        AmpsLM <<  0.00000E+000,  3.67188E-002,  6.17188E-002,  1.17969E-001,
+                   2.14844E-001,  3.28906E-001,	 4.75781E-001,  6.30469E-001,
+                   7.82031E-001,  9.92969E-001,	 1.00000E+000,  1.00000E+000,
+                   9.63459E-001,  6.01030E-001,  2.29652E-001,  8.64702E-002,
+                   2.53196E-002,  0.00000E+000;
+        AmpsLM.array() = AmpsLM.array() * 8.;   // Also correct for SkyTEM convention in .geo file
+
+        TxLM->SetWaveform( TimesLM, AmpsLM, SEC );
+        // Define wire loop
+        TxLM->SetNumberOfPoints(8);
+        TxLM->SetPoint(0, Vector3r( -16.10,    2.13,  -34));
+        TxLM->SetPoint(1, Vector3r(  -7.51,   10.72,  -34));
+        TxLM->SetPoint(2, Vector3r(   7.51,   10.72,  -34));
+        TxLM->SetPoint(3, Vector3r(  14.92,    3.31,  -34));
+        TxLM->SetPoint(4, Vector3r(  14.92,   -3.31,  -34));
+        TxLM->SetPoint(5, Vector3r(   7.51,  -10.72,  -34));
+        TxLM->SetPoint(6, Vector3r(  -7.51,  -10.72,  -34));
+        TxLM->SetPoint(7, Vector3r( -16.10,   -2.13,  -34));
+        TxLM->SetNumberOfTurns(8);
+
+
+    TEMInductiveReceiver* RxLM = TEMInductiveReceiver::New();
+        RxLM->SetComponent( ZCOMPONENT );      // What about Overloaded to take (X), (X,Y), or (X,Y,Z) or what about tilt?
+        RxLM->SetMoment( 1 );                  // Normalized
+        RxLM->SetReferenceTime( 8e-4, SEC );
+        RxLM->SetRxLocation( (Vector3r() << -16.80, 0, -36.00).finished() );
+
+        // Gate Centres  ms
+        VectorXr centresLM (26);
+            centresLM << 7.150000E-07, 2.215000E-06, 4.215000E-06, 6.215000E-06, 8.215000E-06,
+                         1.021500E-05, 1.221500E-05, 1.471500E-05, 1.821500E-05, 2.271500E-05,
+                         2.821500E-05, 3.521500E-05, 4.421500E-05, 5.571500E-05, 7.021500E-05,
+                         8.821500E-05, 1.107150E-04, 1.387150E-04, 1.742150E-04, 2.197150E-04,
+                         2.767150E-04, 3.487150E-04, 4.397150E-04, 5.537150E-04, 6.977150E-04,
+                         8.792150E-04;
+
+        VectorXr widthsLM (26);
+            widthsLM << 5.700000E-07, 1.570000E-06, 1.570000E-06, 1.570000E-06, 1.570000E-06,
+                        1.570000E-06, 1.570000E-06, 2.570000E-06, 3.570000E-06, 4.570000E-06,
+                        5.570000E-06, 7.570000E-06, 9.570000E-06, 1.257000E-05, 1.557000E-05,
+                        1.957000E-05, 2.457000E-05, 3.057000E-05, 3.957000E-05, 5.057000E-05,
+                        6.257000E-05, 8.057000E-05, 1.005700E-04, 1.265700E-04, 1.605700E-04,
+                        2.015700E-04;
+
+        RxLM->SetWindows(centresLM, widthsLM, SEC);
+
+
+
+    // Specifies survey, this is the Glue Class, the top of the structure, etc.
+    TEMSurvey* Survey = TEMSurvey::New();
+        Survey->SetNumberOfLines(1);  // Flight lines or
+                                      // Internally each line is a class? But that's sort of hidden to the
+                                      // end user. Having each line seperate is nice for constrained inversion, where
+                                      // each line is a nice thing to deal with.
+        Survey->GetLine(0)->SetNumberOfRecords(1);    // Each Record then contains everything needed for modelling response curve(s)
+        Survey->GetLine(0)->GetRecord(0)->SetNumberOfPulseSequences( 1 );
+        Survey->GetLine(0)->GetRecord(0)->SetTransmitterReceiverPair( 0, TxHM, RxHM );
+        //Survey->GetLine(0)->GetRecord(0)->SetTransmitterReceiverPair( 1, TxHM, RxHM );
+
+
+    LayeredEarthEM* Earth = LayeredEarthEM::New();
+        Earth->SetNumberOfLayers(31);
+        Earth->SetLayerThickness( (VectorXr(29) <<  5.00E+00,  5.40E+00,
+             5.80E+00, 6.30E+00, 6.80E+00, 7.30E+00, 7.80E+00, 8.50E+00,
+             9.10E+00, 9.80E+00, 1.06E+01, 1.14E+01, 1.23E+01, 1.33E+01,
+             1.43E+01, 1.54E+01, 1.66E+01, 1.79E+01, 1.93E+01, 2.08E+01,
+             2.25E+01, 2.42E+01, 2.61E+01, 2.81E+01, 3.03E+01, 3.27E+01,
+             3.52E+01, 3.80E+01, 4.10E+01).finished() );
+
+        VectorXcr rho = ( (VectorXcr(31) << 0, 1.54E+01, 4.21E+01,
+            9.25E+01, 1.26E+02, 1.17E+02, 7.57E+01, 3.21E+01, 1.40E+01, 1.96E+01,
+            2.67E+01, 2.56E+01, 2.00E+01, 1.86E+01, 2.31E+01, 2.97E+01, 3.50E+01,
+            3.79E+01, 3.75E+01, 3.32E+01, 2.52E+01, 1.57E+01, 8.38E+00, 5.38E+00,
+            5.49E+00, 6.34E+00, 7.07E+00, 7.81E+00, 8.67E+00, 9.59E+00, 1.05E+01
+        ).finished() ); // 200 Ohm-m half space
+
+        Earth->SetLayerConductivity( 1./rho.array() );
+        // ALL SET UP
+        std::cout << *Survey << std::endl;
+
+        // OK do your thinc
+        //DataTEM* data =
+        Survey->ForwardModel( Earth );
+
+
+    // Clean up
+
+
+
+//     //Survey->Delete();
+//     Earth->Delete();
+//
+//     TxHM->Delete();
+//     RxHM->Delete();
+//     TxLM->Delete();
+//     RxLM->Delete();
+
+}

LemmaCore/examples/utXMLParse.cpp

@@ -0,0 +1,168 @@
+/* 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      04/03/2014 01:08:28 PM
+ * @version   $Id$
+ * @author    Trevor Irons (ti)
+ * @email     Trevor.Irons@xri-geo.com
+ * @copyright Copyright (c) 2014, XRI Geophysics, LLC
+ * @copyright Copyright (c) 2014, Trevor Irons
+ */
+
+#include "Lemma"
+#ifdef TINYXMLSUPPORT
+#include "tinyxml2.h"
+
+#include <ctime>
+using namespace tinyxml2;
+using namespace Lemma;
+
+void ParseTEM( XMLElement* element );
+
+template <typename T>
+std::vector<T> ReadLine( const int& nr, const std::string& line ) ;
+
+int main(int argc, char **argv) {
+
+    if ( argc > 1 ) {
+		XMLDocument* doc = new XMLDocument();
+		clock_t startTime = clock();
+		doc->LoadFile( argv[1] );
+		clock_t loadTime = clock();
+		int errorID = doc->ErrorID();
+
+        // Get some info
+        //static const char* xml = "<element/>";
+        //doc->Parse( xml );
+        //XMLNode* titleElement = doc->FirstChild(); //Element()->FirstChildElement( "PLAY" )->FirstChildElement( "TITLE" );
+        XMLElement* titleElement = doc->FirstChildElement( ); //->FirstChildElement( "TITLE" );
+        //const char* title = titleElement->Value(); //GetText();
+        const char* title = titleElement->Value(); //GetText();
+
+        printf( "Test file '%s' loaded. ErrorID=%d\n", argv[1], errorID );
+        printf( "Name of FirstChildElement: %s\n", title );
+
+        if (strcmp ( titleElement->Value(), "NGXFile" ) != 0) {
+            std::cout <<"NGX file was not detected!" << std::endl;
+            exit(EXIT_FAILURE);
+        } else {
+            //std::cout <<
+            //titleElement->FirstAttribute() ;//"type");// << std::endl;;
+            if (strcmp(  titleElement->FindAttribute("type")->Value(),"tem") == 0) {
+                // Parse TEM file
+                ParseTEM( titleElement );
+            } else {
+                std::cout << "No parser for NGX filetype " << titleElement->FindAttribute("type")->Value() << std::endl;
+                std::cout << "YOU should write one!\n";
+                exit(EXIT_FAILURE);
+            }
+
+        }
+
+		delete doc; doc = 0;
+
+        clock_t deleteTime = clock();
+		if ( !errorID ) {
+			printf( "========================================================\n");
+			printf( "Load time=%u\n",   (unsigned)(loadTime - startTime) );
+			printf( "Delete time=%u\n", (unsigned)(deleteTime - loadTime) );
+			printf( "Total time=%u\n",  (unsigned)(deleteTime - startTime) );
+		}
+
+
+		exit(0);
+	} else {
+        std::cout << "Enter NGX.x file to parse\n";
+    }
+}
+
+void ParseTEM( XMLElement* element ) {
+
+    std::cout << "This is a NGX.t file" << std::endl;
+
+
+    if (strcmp( element->FindAttribute("version")->Value(),"0.1") == 0) {
+        std::cout << "Version 0.1 detected" << std::endl;
+    } else {
+        std::cout << "Unsupported NGX.t version" << std::endl;
+    }
+
+    // system description
+    std::cout << "System description" << std::endl;
+    std::cout << element->FirstChildElement("system")->FirstChildElement("name")->GetText() << std::endl;
+    XMLElement* system = element->FirstChildElement("system");
+        int ntx = atoi(system->FirstChildElement("transmitters")->FindAttribute("num")->Value());
+        std::cout << "numTx = " << ntx << std::endl;
+        // OK Parse Transmitter(s)
+        XMLElement* tx = system->FirstChildElement("transmitters")->FirstChildElement("transmitter");
+        //    std::cout << "Tx id = " << tx->FindAttribute("id")->Value() << std::endl;
+        //std::cout << tx->FirstChildElement("loop.coordinates")->FindAttribute("npoint")->Value();//->FirstChildElement("northingPoints")->Value() << std::endl;
+        //std::cout << tx->FirstChildElement("loop.coordinates")->FirstChildElement("northing.points")->GetText();//->FirstChildElement("northingPoints")->Value() << std::endl;
+        for (int it=0; it<ntx; ++it) {
+            std::cout << "\nTransmitter " << it << std::endl;
+            if (it > 0) tx = tx->NextSiblingElement();
+            int npoints = atoi(tx->FirstChildElement("loop.coordinates")->FindAttribute("npoint")->Value());
+
+            std::cout << "points= " << npoints; // tx->FirstChildElement("loop.coordinates")->FindAttribute("npoint")->Value();//->FirstChildElement("northingPoints")->Value() << std::endl;
+            std::vector<Real> LP = ReadLine<Real>( npoints, std::string(tx->FirstChildElement("loop.coordinates")->FirstChildElement("northing.points")->GetText()) );
+            for (int ii=0; ii<npoints; ++ii) std::cout << "\t"<< LP[ii] ;
+            //std::cout << tx->FirstChildElement("loop.coordinates")->FirstChildElement("northing.points")->GetText();//->FirstChildElement("northingPoints")->Value() << std::endl;
+            //std::cout << tx->FirstChildElement("loop.coordinates")->FirstChildElement("easting.points")->GetText();//->FirstChildElement("northingPoints")->Value() << std::endl;
+        }
+    std::cout << "\nEND system description\n";
+
+}
+
+
+template <typename T>
+std::vector<T> ReadLine( const int& nr, const std::string& line ) {
+
+    std::vector<T>   lineData;
+    std::stringstream  lineStream(line);
+
+    T value;
+    while(lineStream >> value) {
+        lineData.push_back(value);
+    }
+    return lineData;
+}
+#else
+
+int main() {
+    std::cout << "you have to compile lemma with external tinyxml library to use this" << std::endl;
+}
+
+#endif
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  ASCIIParser
+    //      Method:  ReadInts
+    //--------------------------------------------------------------------------------------
+//     std::vector<int> ReadInts ( const int& nr ) {
+//         std::string buf;
+//         char *dump = new char[BufferSize];
+//         std::vector<int> vals(0);
+//         while (input >> buf) {
+//             if (buf.substr(0, CommentString.size()) == CommentString) {
+//                 input.getline(dump, BufferSize);
+//             } else {
+//                 vals.push_back( atoi(buf.c_str() ));
+//             }
+//             if (static_cast<int>(vals.size()) == nr) {
+//                 delete [] dump;
+//                 return vals;
+//             }
+//
+//         }
+//         delete [] dump;
+//         return vals;
+//     }		// -----  end of method ASCIIParser::ReadInts  -----
+

LemmaCore/examples/utYAMLconfig.cpp

@@ -0,0 +1,67 @@
+#ifdef HAVE_YAMLCPP
+
+#include "yaml-cpp/yaml.h"
+#include "yaml-cpp/eventhandler.h"
+#include <fstream>
+#include <iostream>
+#include <vector>
+
+struct Params {
+	bool hasFile;
+	std::string fileName;
+};
+
+Params ParseArgs(int argc, char **argv) {
+	Params p;
+
+	std::vector<std::string> args(argv + 1, argv + argc);
+
+	return p;
+}
+
+class NullEventHandler: public YAML::EventHandler
+{
+public:
+	virtual void OnDocumentStart(const YAML::Mark&) {}
+	virtual void OnDocumentEnd() {}
+
+	virtual void OnNull(const YAML::Mark&, YAML::anchor_t) {}
+	virtual void OnAlias(const YAML::Mark&, YAML::anchor_t) {}
+	virtual void OnScalar(const YAML::Mark&, const std::string&, YAML::anchor_t, const std::string&) {}
+
+	virtual void OnSequenceStart(const YAML::Mark&, const std::string&, YAML::anchor_t) {}
+	virtual void OnSequenceEnd() {}
+
+	virtual void OnMapStart(const YAML::Mark&, const std::string&, YAML::anchor_t) {}
+	virtual void OnMapEnd() {}
+};
+
+void parse(std::istream& input)
+{
+	try {
+		YAML::Node doc = YAML::Load(input);
+		std::cout << doc << "\n";
+	} catch(const YAML::Exception& e) {
+		std::cerr << e.what() << "\n";
+	}
+}
+
+int main(int argc, char **argv)
+{
+	Params p = ParseArgs(argc, argv);
+
+	if(argc > 1) {
+		std::ifstream fin;
+		fin.open(argv[1]);
+		parse(fin);
+	} else {
+		parse(std::cin);
+	}
+
+	return 0;
+}
+#else
+int main() {
+}
+#endif
+

LemmaCore/examples/utgaussquad.cpp

@@ -0,0 +1,84 @@
+// ===========================================================================
+// 
+//       Filename:  utqaussquad.cpp
+// 
+//    Description:  Test for gaussian quadrature algorithm
+// 
+//        Version:  0.0
+//        Created:  10/05/2010 08:54:26 AM
+//       Revision:  none
+//       Compiler:  Tested with g++
+// 
+//         Author:  M. Andy Kass (MAK)
+//
+//   Organisation:  Colorado School of Mines (CSM)
+//                  Broken Spoke Development, LLC
+//
+//          Email:  mkass@numericalgeo.com
+// 
+//  This program is free software: you can redistribute it and/or modify
+//  it under the terms of the GNU General Public License as published by
+//  the Free Software Foundation, either version 3 of the License, or
+//  (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+//
+// ===========================================================================
+
+#include "Lemma"
+using namespace Lemma;
+using namespace std;
+
+#ifdef LEMMAUSEVTK
+#include "matplot.h"
+using namespace matplot;
+#endif
+
+int main() {
+
+	int N = 600;
+	int upb = 5;
+	int lowb = -1;
+	VectorXr func(N);
+	VectorXr wx(N);
+	Real integrationres,actres;
+
+	gaussianquadrature *lgqw = gaussianquadrature::New();
+	lgqw->SetFreqs(N,upb,lowb);
+	lgqw->CalcAW();
+
+	wx=lgqw->GetAbscissae();
+	func=cos(wx.array());
+//	for (int ii=0;ii<N;++ii) {
+//		cout << wx(ii) << "  " << func(ii) << endl;
+//	}
+
+	lgqw->SetFunc(func);
+	lgqw->Integrate();
+	integrationres=lgqw->GetResult();
+
+	actres = -sin((Real)upb)+sin((Real)lowb);
+	
+	cout << "Gaussian Quadrature Result: " << integrationres << endl;
+	cout << "Actual Result: " << actres << endl;
+	
+		
+	//Plot things
+	#ifdef LEMMAUSEVTK
+	double colour1[3] = {0.0,0.0,1.0};
+
+	Plot2D_VTK p1("X", "Y", 800,600);
+	p1.plot(wx,func,colour1,".-");
+	p1.show();
+
+	#endif
+
+	return EXIT_SUCCESS;
+}
+

LemmaCore/examples/utgmrprint.cpp

@@ -0,0 +1,258 @@
+// ===========================================================================
+//   This file is distributed with Lemma,
+//
+//       Filename:  utsnmrinversion1d.cpp
+//
+//        Created:  10/07/2010 08:57:04 AM
+//       Compiler:  Tested with g++, icpc, and MSVC 2010
+//
+//         Author:  Trevor Irons (ti)
+//
+//   Organisation:  Colorado School of Mines (CSM)
+//                  United States Geological Survey (USGS)
+//
+//          Email:  tirons@mines.edu, tirons@usgs.gov
+//
+//  This program is free software: you can redistribute it and/or modify
+//  it under the terms of the GNU General Public License as published by
+//  the Free Software Foundation, either version 3 of the License, or
+//  (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+//
+// ===========================================================================
+
+/**
+  @file
+  @author   Trevor Irons
+  @date     10/07/2010
+  @version   0.0
+ **/
+
+#ifdef LEMMAUSEVTK
+#include "vtkRenderer.h"
+#include "vtkRenderWindow.h"
+#include "vtkRenderWindowInteractor.h"
+#include "vtkPNGWriter.h"
+#include "vtkRenderLargeImage.h"
+#endif
+
+#include "receiverpoints.h"
+#include "emearth1d.h"
+#include "PolygonalWireAntenna.h"
+
+using namespace Lemma;
+
+std::vector<Real>  readinpfile(const std::string& fname);
+
+int main(int argc, char** argv) {
+
+    std::cout <<
+    "\n"
+    << "hantenna - a programme for computing the h field from polygonal wire\n"
+    << "loop sources \n\n"
+    << "The following copyrights apply to this application:\n"
+    << "Copyright (C) 2009, 2010, 2011, 2012 Colorado School of Mines\n"
+    << "Copyright (C) 2009, 2010, 2011, 2012 Trevor Irons\n"
+    << "Copyright (C) 2011 Broken Spoke Development, LLC\n\n"
+    << "hantenna was built using Lemma (Lemma is an Electromagnetics Modelling API)\n"
+    << "More information may be found at https://lemmasoftware.org\n\n"
+    << "This program is free software: you can redistribute it and/or modify\n"
+    << "it under the terms of the GNU General Public License as published by\n"
+    << "the Free Software Foundation, either version 3 of the License, or\n"
+    << "(at your option) any later version.\n\n"
+
+    << "This program is distributed in the hope that it will be useful,\n"
+    << "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
+    << "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
+    << "GNU General Public License for more details.\n\n"
+
+    << "You should have received a copy of the GNU General Public License\n"
+    << "along with this program.  If not, see <http://www.gnu.org/licenses/>.\n\n";
+
+    if (argc < 4) {
+        std::cout << "usage: hantenna.exe  trans.inp cond.inp points.inp \n";
+        exit(0);
+    }
+
+    std::vector<Real> Trans   = readinpfile(std::string(argv[1]));
+    std::vector<Real> CondMod = readinpfile(std::string(argv[2]));
+    std::vector<Real> Points  = readinpfile(std::string(argv[3]));
+
+    //////////////////////////////////////
+    // Define transmitter
+    PolygonalWireAntenna* trans = PolygonalWireAntenna::New();
+        trans->SetNumberOfPoints((int)(Trans[0]));
+        int ip=1;
+        for ( ; ip<=(int)(Trans[0])*2; ip+=2) {
+            trans->SetPoint(ip/2, Vector3r (Trans[ip], Trans[ip+1], -1e-3));
+        }
+ 	    trans->SetNumberOfFrequencies(1);
+ 	    trans->SetFrequency(0, Trans[ip]);
+        trans->SetCurrent(Trans[ip+1]);
+
+	// Receivers
+ 	ReceiverPoints *receivers = ReceiverPoints::New();
+        int nx = (int)Points[0];
+        int ny = (int)Points[1];
+        int nz = (int)Points[2];
+        Real ox = Points[3];
+        Real oy = Points[4];
+        Real oz = Points[5];
+     	Vector3r loc;
+        VectorXr dx(nx-1); // TODO map the dx, dy, dz vectors
+        VectorXr dy(ny-1);
+        VectorXr dz(nz-1);
+        ip = 6;
+        int ir = 0;
+        for ( ; ip <6+nx-1; ++ip) {
+            dx[ir] = Points[ip];
+            ++ir;
+        }
+        ir = 0;
+        for ( ; ip <6+ny-1+nx-1; ++ip) {
+            dy[ir] = Points[ip];
+            ++ir;
+        }
+        ir = 0;
+        for ( ; ip <6+nz-1+ny-1+nx-1; ++ip) {
+            dz[ir] = Points[ip];
+            ++ir;
+        }
+ 		receivers->SetNumberOfReceivers(nx*ny*nz);
+ 		ir = 0;
+        Real pz  = oz;
+ 		for (int iz=0; iz<nz; ++iz) {
+ 		    Real py    =  oy;
+ 		    for (int iy=0; iy<ny; ++iy) {
+ 		        Real px    =  ox;
+ 		        for (int ix=0; ix<nx; ++ix) {
+ 			        loc << px, py, pz;
+ 			        receivers->SetLocation(ir, loc);
+ 			        if (ix < nx-1) px += dx[ix];
+ 			        ++ ir;
+     	        }
+                if (iy<ny-1) py += dy[iy];
+            }
+            if (iz<nz-1) pz += dz[iz];
+        }
+
+    ////////////////////////////////////
+    // Define model
+    LayeredEarthEM *earth = LayeredEarthEM::New();
+    VectorXcr sigma;
+    VectorXr  thick;
+ 	earth->SetNumberOfLayers(CondMod[0]+1);
+ 	sigma.resize(CondMod[0]+1); sigma(0) = 0; // airlayer
+    thick.resize(CondMod[0]-1);
+    int ilay=1;
+    for ( ; ilay/2<CondMod[0]-1; ilay+=2) {
+        sigma(ilay/2+1) =  1./CondMod[ilay];
+        thick(ilay/2) =  CondMod[ilay+1];
+    }
+    sigma(ilay/2+1) = 1./ CondMod[ilay];
+	earth->SetLayerConductivity(sigma);
+    if (thick.size() > 0) earth->SetLayerThickness(thick);
+
+	EMEarth1D  *EmEarth = EMEarth1D::New();
+		EmEarth->AttachWireAntenna(trans);
+		EmEarth->AttachLayeredEarthEM(earth);
+		EmEarth->AttachReceiverPoints(receivers);
+		EmEarth->SetFieldsToCalculate(H);
+        EmEarth->CalculateWireAntennaFields();
+
+    #ifdef LEMMAUSEVTK
+	vtkRenderer           *renderer = vtkRenderer::New();
+	vtkRenderWindow         *renWin = vtkRenderWindow::New();
+	vtkRenderWindowInteractor *iren = vtkRenderWindowInteractor::New();
+    trans->ApproximateWithElectricDipoles( (VectorXr (3) << 0,0,0).finished() );
+	vtkActor **dipActors = new vtkActor*[trans->GetNumberOfDipoles()];
+	for (int id=0; id<trans->GetNumberOfDipoles(); ++id) {
+		dipActors[id] = trans->GetVtkActor(id);
+		renderer->AddActor(dipActors[id]);
+	}
+    vtkActor *hfield  = receivers->GetVtkGlyphActor (HFIELDREAL, 3, 1e2, 0);
+ 	vtkActor *hfieldi = receivers->GetVtkGlyphActor (HFIELDIMAG, 3, 1e2, 0);
+    hfieldi->GetProperty()->SetColor(1,0,1);
+ 	hfield->GetProperty()->SetColor(0,1,0);
+ 	renderer->AddActor(hfield);
+ 	renderer->AddActor(hfieldi);
+	renderer->SetBackground(0,0,0);
+	// Render the window
+	renWin->AddRenderer(renderer);
+	iren->SetRenderWindow(renWin);
+	iren->Initialize();
+	iren->Start();
+	iren->Render();
+	cout << "Enter File name?: ";
+	std::string pngName;
+	std::cin >> pngName;
+	vtkPNGWriter *pngwrite = vtkPNGWriter::New();
+	vtkRenderLargeImage *renlarge = vtkRenderLargeImage::New();
+	renlarge->SetInput(renderer);
+	renlarge->SetMagnification(2);
+	pngwrite->SetInputConnection(renlarge->GetOutputPort());
+	pngName.append(".png");
+	pngwrite->SetFileName(pngName.c_str());
+	pngwrite->Write();
+	iren->Delete();
+	renWin->Delete();
+	renderer->Delete();
+    #endif
+
+    ////////////////////////////////////
+    // Report
+ 	std::fstream hreal("hfield.dat", std::ios::out);
+    hreal << *trans << std::endl;
+    hreal << *earth << std::endl;
+    hreal << "Right hand coordinate system, z is positive down\n";
+    hreal << "x[m]\ty[m]\tz[m]\tHx[A/m]\tHy[A/m]\tHz[A/m]\n";
+    hreal.precision(8);
+    int i=0;
+	for (int iz=0; iz<nz; ++iz) {
+	for (int iy=0; iy<ny; ++iy) {
+	for (int ix=0; ix<nx; ++ix) {
+        hreal << receivers->GetLocation(i).transpose() << "\t";
+ 		hreal << std::real(receivers->GetHfield(0, i).transpose()[0]) << "\t";
+ 		hreal << std::imag(receivers->GetHfield(0, i).transpose()[0]) << "\t";
+ 		hreal << std::real(receivers->GetHfield(0, i).transpose()[1]) << "\t";
+ 		hreal << std::imag(receivers->GetHfield(0, i).transpose()[1]) << "\t";
+ 		hreal << std::real(receivers->GetHfield(0, i).transpose()[2]) << "\t";
+ 		hreal << std::imag(receivers->GetHfield(0, i).transpose()[2]) << "\n";
+        ++i;
+    }
+    }
+    }
+    hreal.close();
+
+    // Clean up
+    EmEarth->Delete();
+    earth->Delete();
+    receivers->Delete();
+    trans->Delete();
+}
+
+std::vector<Real>  readinpfile(const std::string& fname) {
+    std::string buf;
+    char dump[255];
+    std::vector<Real> vals;
+    std::fstream input(fname.c_str(), std::ios::in);
+    if (input.fail()) {
+        std::cerr << "Input file " << fname << " failed to open\n";
+        exit(EXIT_FAILURE);
+    }
+    while (input >> buf) {
+        if (buf.substr(0,2) == "//") {
+            input.getline(dump, 255);
+        } else {
+            vals.push_back( atof(buf.c_str() ));
+        }
+    }
+    return vals;
+}

LemmaCore/examples/uthankel2.cpp

@@ -0,0 +1,93 @@
+// ===========================================================================
+//
+//       Filename:  uthankel2.cpp
+//
+//    Description:
+//
+//        Version:  0.0
+//        Created:  05/14/2010 10:26:59 AM
+//       Revision:  none
+//       Compiler:  Tested with g++, icpc, and MSVC 2000
+//
+//         Author:  Trevor Irons (ti)
+//
+//   Organisation:  Colorado School of Mines (CSM)
+//                  United States Geological Survey (USGS)
+//
+//          Email:  tirons@mines.edu, tirons@usgs.gov
+//
+//  This program is free software: you can redistribute it and/or modify
+//  it under the terms of the GNU General Public License as published by
+//  the Free Software Foundation, either version 3 of the License, or
+//  (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+//
+// ===========================================================================
+
+#include "hankeltransformhankel2.h"
+#include "hankeltransformgaussianquadrature.h"
+#include "kernelem1d.h"
+#include "layeredearthem.h"
+
+using namespace Lemma;
+
+int main() {
+
+	// Define model
+	LayeredEarthEM *Earth = LayeredEarthEM::New();
+		VectorXcr sigma(3);
+		sigma << 0., .1, 0.01;
+		VectorXr  thick(1);
+		thick << 10;
+		Earth->SetNumberOfLayers(3);
+		Earth->SetLayerConductivity(sigma);
+		Earth->SetLayerThickness(thick);
+
+	// Source
+	// Test with a single dipole
+	DipoleSource *dipole = DipoleSource::New();
+		dipole->SetMoment(2);
+		dipole->SetType(MAGNETICDIPOLE);
+		dipole->SetPolarisation(ZPOLARISATION);
+		dipole->SetLocation(0,0,0);
+		dipole->SetNumberOfFrequencies(1);
+		dipole->SetFrequency(0,1000);
+		dipole->SetPhase(0);
+
+	KernelEm1D *Kernel = KernelEm1D::New();
+		Kernel->Initialise(Earth);
+		Kernel->SetUpSource(dipole, 0);
+		Kernel->SetUpReceiver(-0.4);
+    //std::vector< KernelEm1DBase* > KernelVec;
+    //    KernelVec.push_back( )
+
+	std::cout.precision(10);
+
+	Hankel2 *dig = Hankel2::New();
+//         dig->ComputeRelated(.23 , Kernel);
+//  		std::cout << "  dig->Zgauss "
+//  				  << dig->Zgauss(0, TE, 0, 100.,
+//  								  1000.*std::sqrt(MU0*EPSILON0), Kernel)
+//  			      << std::endl;
+
+// 	HankelTransformGaussianQuadrature *gauss =
+// 			HankelTransformGaussianQuadrature::New();
+// 		std::cout << "gauss->Zgauss "
+// 				  << gauss->Zgauss(0, TE, 0, 100.,
+// 								  1000.*std::sqrt(MU0*EPSILON0), Kernel)
+// 			      << std::endl;
+
+	Earth->Delete();
+	dig->Delete();
+	//gauss->Delete();
+    dipole->Delete();
+	Kernel->Delete();
+	return EXIT_SUCCESS;
+}

LemmaCore/examples/uthantenna.cpp

@@ -0,0 +1,257 @@
+// ===========================================================================
+//
+//       Filename:  hantenna.cpp
+//
+//        Created:  10/07/2010 08:57:04 AM
+//       Modified:  14 Aug 2012
+//       Compiler:  Tested with g++, icpc, and MSVC 2010
+//
+//         Author:  Trevor Irons (ti)
+//
+//       Copyright (C) 2011    Broken Spoke Development, LLC
+//       Copyright (C) 2012    Trevor Irons
+//
+//   Organisation:  Colorado School of Mines (CSM)
+//
+//          Email:  tirons@mines.edu
+//
+//  This program is free software: you can redistribute it and/or modify
+//  it under the terms of the GNU General Public License as published by
+//  the Free Software Foundation, either version 3 of the License, or
+//  (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+//
+// ===========================================================================
+
+/**
+  @file
+  @author   Trevor Irons
+  @date     10/07/2010
+  @version  $Revision: 208 $
+  $Id$
+ **/
+
+#include "receiverpoints.h"
+#include "emearth1d.h"
+#include "PolygonalWireAntenna.h"
+#ifdef LEMMAUSEOMP
+#include "omp.h"
+#endif
+
+#include "timer.h"
+
+using namespace Lemma;
+
+std::vector<Real>  readinpfile(const std::string& fname);
+
+std::vector<std::string>  readinpfile2(const std::string& fname);
+
+int main(int argc, char** argv) {
+
+    std::cout <<
+    "\n"
+    << "hantenna- $Date: 2015-01-26 10:11:24 -0700 (Mon, 26 Jan 2015) $ $Revision: 208 $\n\n"
+    << "hantenna is a programme for computing the h field from polygonal wire\n"
+    << "loop sources \n\n"
+    << "hantenna was built using Lemma (Lemma is an Electromagnetics Modelling API)\n"
+    << "Lemma is Free and Open Source Software (FOSS) and is released under\n"
+    << "the MPL, it is covered by the following copyrights:\n"
+    << "Copyright (C) 2009, 2010, 2011, 2012      Colorado School of Mines\n"
+    << "Copyright (C) 2009, 2010, 2011, 2012      Trevor P. Irons\n"
+    << "Copyright (C) 2011, 2012                  M. Andy Kass\n\n"
+    << "More information may be found at: https://lemmasoftware.org\n"
+    << "                                  info@lemmasoftware.org\n\n"
+    << "=====================================================================\n"
+    << "This programme is part of Lemma, a geophysical modelling and inversion API \n"
+    << "This Source Code Form is subject to the terms of the Mozilla Public\n"
+    << "License, v. 2.0. If a copy of the MPL was not distributed with this\n"
+    << "file, You can obtain one at http://mozilla.org/MPL/2.0/. \n"
+    << "=====================================================================\n\n\n";
+
+    if (argc < 5) {
+        std::cout << "usage: hantenna.exe  trans.inp cond.inp points.inp config.inp \n";
+        exit(0);
+    }
+
+    #ifdef LEMMAUSEOMP
+    std::cout << "OpenMP is using " << omp_get_max_threads() << " threads" << std::endl;
+    #endif
+
+    std::vector<Real> Trans   = readinpfile(std::string(argv[1]));
+    std::vector<Real> CondMod = readinpfile(std::string(argv[2]));
+    std::vector<Real> Points  = readinpfile(std::string(argv[3]));
+    std::vector<std::string> config  = readinpfile2(std::string(argv[4]));
+
+    //////////////////////////////////////
+    // Define transmitter
+    PolygonalWireAntenna* trans = PolygonalWireAntenna::New();
+        trans->SetNumberOfPoints((int)(Trans[0]));
+        int ip=1;
+        for ( ; ip<=(int)(Trans[0])*2; ip+=2) {
+            trans->SetPoint(ip/2, Vector3r (Trans[ip], Trans[ip+1], -1e-3));
+        }
+ 	    trans->SetNumberOfFrequencies(1);
+ 	    trans->SetFrequency(0, Trans[ip]);
+        trans->SetCurrent(Trans[ip+1]);
+        trans->SetMinDipoleRatio(atof(config[1].c_str()));
+        trans->SetMinDipoleMoment(atof(config[2].c_str()));
+        trans->SetMaxDipoleMoment(atof(config[3].c_str()));
+
+	// Receivers
+ 	ReceiverPoints *receivers = ReceiverPoints::New();
+        int nx = (int)Points[0];
+        int ny = (int)Points[1];
+        int nz = (int)Points[2];
+        Real ox = Points[3];
+        Real oy = Points[4];
+        Real oz = Points[5];
+     	Vector3r loc;
+        VectorXr dx(nx-1);
+        VectorXr dy(ny-1);
+        VectorXr dz(nz-1);
+        ip = 6;
+        int ir = 0;
+        for ( ; ip <6+nx-1; ++ip) {
+            dx[ir] = Points[ip];
+            ++ir;
+        }
+        ir = 0;
+        for ( ; ip <6+ny-1+nx-1; ++ip) {
+            dy[ir] = Points[ip];
+            ++ir;
+        }
+        ir = 0;
+        for ( ; ip <6+nz-1+ny-1+nx-1; ++ip) {
+            dz[ir] = Points[ip];
+            ++ir;
+        }
+ 		receivers->SetNumberOfReceivers(nx*ny*nz);
+ 		ir = 0;
+        Real pz  = oz;
+ 		for (int iz=0; iz<nz; ++iz) {
+ 		    Real py    =  oy;
+ 		    for (int iy=0; iy<ny; ++iy) {
+ 		        Real px    =  ox;
+ 		        for (int ix=0; ix<nx; ++ix) {
+ 			        loc << px, py, pz;
+ 			        receivers->SetLocation(ir, loc);
+ 			        if (ix < nx-1) px += dx[ix];
+ 			        ++ ir;
+     	        }
+                if (iy<ny-1) py += dy[iy];
+            }
+            if (iz<nz-1) pz += dz[iz];
+        }
+
+    ////////////////////////////////////
+    // Define model
+    LayeredEarthEM *earth = LayeredEarthEM::New();
+    VectorXcr sigma;
+    VectorXr  thick;
+ 	earth->SetNumberOfLayers(CondMod[0]+1);
+ 	sigma.resize(CondMod[0]+1); sigma(0) = 0; // airlayer
+    thick.resize(CondMod[0]-1);
+    int ilay=1;
+    for ( ; ilay/2<CondMod[0]-1; ilay+=2) {
+        sigma(ilay/2+1) =  1./CondMod[ilay];
+        thick(ilay/2) =  CondMod[ilay+1];
+    }
+    sigma(ilay/2+1) = 1./ CondMod[ilay];
+	earth->SetLayerConductivity(sigma);
+    if (thick.size() > 0) earth->SetLayerThickness(thick);
+
+	EMEarth1D  *EmEarth = EMEarth1D::New();
+		EmEarth->AttachWireAntenna(trans);
+		EmEarth->AttachLayeredEarthEM(earth);
+		EmEarth->AttachReceiverPoints(receivers);
+		EmEarth->SetFieldsToCalculate(H);
+        EmEarth->SetHankelTransformMethod(string2Enum<HANKELTRANSFORMTYPE>(config[0]));
+        EmEarth->SetHankelTransformMethod(FHTKEY201);
+
+	// Keep track of time
+	jsw_timer timer;
+  	timer.begin();
+    clock_t launch = clock();
+    EmEarth->CalculateWireAntennaFields(true);    // true=status bar
+	Real paTime = timer.end();
+
+    std::cout << "\n\n===========================================\ncalc. real time: " << paTime/60. << "\t[m]\n";
+
+    std::cout << "calc. user time: " <<  (clock()-launch)/CLOCKS_PER_SEC/60.   << "\t[CPU m]"
+		 << std::endl;
+
+    ////////////////////////////////////
+    // Report
+ 	std::fstream hrep("hfield.yaml", std::ios::out);
+    std::fstream hreal("hfield.dat", std::ios::out);
+
+    hrep << *EmEarth << std::endl;
+    hrep.close();
+    //hreal << *trans << std::endl;
+    //hreal << *earth << std::endl;
+
+    hreal << "// Right hand coordinate system, z is positive down\n";
+    hreal << "// x[m]\ty[m]\tz[m]\tHx[A/m]\tHy[A/m]\tHz[A/m]\n";
+    hreal.precision(8);
+    int i=0;
+	for (int iz=0; iz<nz; ++iz) {
+	for (int iy=0; iy<ny; ++iy) {
+	for (int ix=0; ix<nx; ++ix) {
+        hreal << receivers->GetLocation(i).transpose() << "\t";
+ 		hreal << receivers->GetHfield(0, i).transpose() << "\n";
+        ++i;
+    }
+    }
+    }
+    hreal.close();
+    // Clean up
+    EmEarth->Delete();
+    earth->Delete();
+    receivers->Delete();
+    trans->Delete();
+}
+
+std::vector<Real>  readinpfile(const std::string& fname) {
+    std::string buf;
+    char dump[255];
+    std::vector<Real> vals;
+    std::fstream input(fname.c_str(), std::ios::in);
+    if (input.fail()) {
+        std::cerr << "Input file " << fname << " failed to open\n";
+        exit(EXIT_FAILURE);
+    }
+    while (input >> buf) {
+        if (buf.substr(0,2) == "//") {
+            input.getline(dump, 255);
+        } else {
+            vals.push_back( atof(buf.c_str() ));
+        }
+    }
+    return vals;
+}
+
+std::vector<std::string>  readinpfile2(const std::string& fname) {
+    std::string buf;
+    char dump[255];
+    std::vector<std::string> vals;
+    std::fstream input(fname.c_str(), std::ios::in);
+    if (input.fail()) {
+        std::cerr << "Input file " << fname << " failed to open\n";
+        exit(EXIT_FAILURE);
+    }
+    while (input >> buf) {
+        if (buf.substr(0,2) == "//") {
+            input.getline(dump, 255);
+        } else {
+            vals.push_back( std::string(buf.c_str() ));
+        }
+    }
+    return vals;
+}

LemmaCore/examples/utlogbarriercg.cpp

@@ -0,0 +1,218 @@
+// ===========================================================================
+//
+//       Filename:  utlogbarriercg.cpp
+//
+//        Created:  12/29/2010 09:40:23 AM
+//       Compiler:  Tested with g++, icpc, and MSVC 2010
+//
+//         Author:  Trevor Irons (ti)
+//
+//   Organisation:  Colorado School of Mines (CSM)
+//                  United States Geological Survey (USGS)
+//
+//          Email:  tirons@mines.edu, tirons@usgs.gov
+//
+//  This program is free software: you can redistribute it and/or modify
+//  it under the terms of the GNU General Public License as published by
+//  the Free Software Foundation, either version 3 of the License, or
+//  (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+//
+// ===========================================================================
+
+/**
+  @file
+  @author   Trevor Irons
+  @date     12/29/2010
+  @version   0.0
+ **/
+
+#include "LemmaObject.h"
+//#include "logbarriercg.h"
+//#include "datasnmr.h"
+#include <ctime>
+
+#ifdef HAVEBOOSTRANDOM
+#include <boost/random.hpp>
+#include <boost/random/normal_distribution.hpp>
+#endif
+
+using namespace std;
+using namespace Lemma;
+
+MatrixXr BuildG(const Real& T2, const Real& Larmor, const Real& T,
+        const Real& dt, const VectorXr& nT2Bins, const Real& scale);
+
+MatrixXr BuildGw(const Real& T2, const Real& Larmor, const Real& T,
+        const Real& dt, const VectorXr& nT2Bins, const Real& scale,
+        const VectorXr& freqs);
+
+/// test driver program for log-barrier optimization algorithm
+int main() {
+    return 0;
+}
+
+#ifdef AA
+    // Parameters
+    Real T2(.200);
+    Real Larmor(2000); // Hz
+    Real wL = 2.*PI * Larmor;
+    Real T(.6);
+    Real dt(1e-4);
+    int  nT2(20);
+    Real T2Low(.020);
+    Real T2Hi(.220);
+
+    // T2 bins
+    VectorXr T2Bins = VectorXr::LinSpaced(nT2, T2Low, T2Hi);
+
+    // Build true model
+    VectorXr m = VectorXr::Zero(T2Bins.size());
+    //m[4]  = .15;
+    //m[5]  = .15;
+    //m[6]  = .15;
+    m[7]  = .15;
+    m[8]  = .15;
+    m[11] = .15;
+    m[12] = .15;
+    m[13] = .15;
+    m[14] = .15;
+
+    // Build G
+    srand ( std::time(NULL) );
+    Real scale = 1e-4*std::abs(VectorXr::Random(1)[0]);
+    MatrixXr G = BuildG(T2, wL, T, dt, T2Bins, scale);
+
+    #ifdef HAVEBOOSTRANDOM
+    Real mean = 0;
+    Real variance = scale*.05*(.5+.15);
+    boost::mt19937 randgen(static_cast<unsigned int> (std::time(0)));
+    boost::normal_distribution<Real> noise(mean, variance);
+    boost::variate_generator<boost::mt19937, boost::normal_distribution<Real> > nD(randgen, noise);
+    VectorXr noisy = G*m;
+//     for (int i=0; i < noisy.size(); ++i) {
+//        noisy(i) += nD();
+//     }
+    #else
+    VectorXr d = G * m;
+    VectorXr noisy = d.array();// + .05*( .5 + .15 ) *Eigen::ArrayXd::Random(d.size());
+    #endif
+
+    // Clean Data, and 10% random noise data
+    VectorXr RefMod = VectorXr::Zero(m.size());
+
+    // todo let alpha's be set.
+    Real alpha_s  =  .0;
+    Real alpha_t2 = 1.0;
+    Eigen::SparseMatrix<Real> Wd (G.rows(), G.rows());
+    Eigen::SparseMatrix<Real> Wm (G.cols(), G.cols());
+
+    /////////////////
+    // Model objective function
+    int ii = 0;
+    for (int iT2=0; iT2<nT2; ++iT2) {
+        Wm.coeffRef(ii, ii) += alpha_s - alpha_t2;
+        if (iT2 < nT2-1) {
+            Wm.coeffRef(ii, ii+1) += alpha_t2;
+        }
+        ++ii;
+    }
+    Wm.finalize();
+    std::fstream  WmOut( "wmMatrix.dat" , std::ios::out);
+    WmOut << Wm << std::endl;
+    WmOut.close();
+
+    // Data objective function
+    /// @todo add measure of suspected std dev to this.
+    for (int id=0; id<G.rows(); ++id) {
+        Wd.coeffRef(id, id) = 1.; // 1/sigma(i);
+    }
+    Wd.finalize();
+
+    // invert time-domain sinusoid exponent
+    //LogBarrierCG(G, RefMod, noisy, (Real)0., (Real)1e5, nT2, Wd, Wm, scale*1e1);
+    return EXIT_SUCCESS;
+
+//     #if 0
+//     // invert FD
+//     Eigen::FFT<Real> fft;
+//     fft.SetFlag(fft.HalfSpectrum);
+//     VectorXcr dw;
+//     fft.fwd(dw, noisy);
+//
+//     // Compute freqs Hz
+//     VectorXr freqs = DataSNMR::GetNMRSampledFrequencies(T/dt, dt);
+//     Real df = freqs[1];
+//     Real window = 300; // Hz
+//     int iL = (int)(Larmor/df);
+//     MatrixXr Gw = BuildGw(T2, wL, T, dt, T2Bins, scale, freqs.segment(iL-window/2, window));
+//
+//     VectorXr dwu = VectorXr::Zero(2.*window);
+//     dwu.head(window) = dw.segment(iL-window/2, window).real();
+//     dwu.tail(window) = dw.segment(iL-window/2, window).imag();
+//
+//     Eigen::DynamicSparseMatrix<Real> Wdw (Gw.rows(), Gw.rows());
+//     for (int id=0; id<Gw.rows(); ++id) {
+//         Wdw.coeffRef(id, id) = 1.; // 1/sigma(i);
+//     }
+//     Wdw.finalize();
+//     std::cout << "psize " << (Gw*RefMod).size() << std::endl;
+//     VectorXr dw2 = Gw*m;
+//     //std::cout << dw2 << std::endl;
+//     std::cout << "Gw " << Gw.rows() << "\t" << Gw.cols() << std::endl;
+//     std::cout << "dwu " << dwu.size() << std::endl;
+//     //RefMod.array() += .1;
+//     VectorXr mod = LogBarrierCG(Gw, RefMod, dwu, 0., 3., nT2, Wdw, Wm,scale*1e5);
+//     //VectorXr mod = LogBarrierCG(Gw, dwu, 0., 1e5);
+//
+//     std::fstream Gws("gw.out", std::ios::out);
+//     Gws << Gw << std::endl;
+//     Gws.close();
+//     #endif
+}
+
+#endif
+
+MatrixXr BuildG(const Real& T2, const Real& wL, const Real& T,
+            const Real& dt, const VectorXr& T2Bins, const Real& scale) {
+    std::cout << "scale " << scale << std::endl;
+    int nt = T/dt;
+    int nT2 = T2Bins.size();
+    MatrixXr G = MatrixXr::Zero(nt,nT2);
+    for (int iT2=0; iT2<nT2; ++iT2) {
+        Real t=0;
+        for (int it=0; it<nt; ++it) {
+            G(it, iT2) = scale * exp(-t/T2Bins(iT2)) * sin(wL * t);
+            t += dt;
+        }
+    }
+    return G;
+}
+
+
+MatrixXr BuildGw(const Real& T2, const Real& wL, const Real& T,
+            const Real& dt, const VectorXr& T2Bins, const Real& scale,
+            const VectorXr &freqs) {
+    VectorXr omegas = freqs.array() * 2.*PI;
+    std::cout << "scale " << scale << std::endl;
+    int nT2 = T2Bins.size();
+    MatrixXr Gw = MatrixXr::Zero(2*freqs.size(), nT2);
+    int nW = freqs.size();
+    Real sc = 1./dt;
+    for (int iT2=0; iT2<nT2; ++iT2) {
+        for (int iw=0; iw<freqs.size(); ++iw) {
+            Real a = 1./T2Bins(iT2);
+            Complex T = wL / ( wL*wL + (a+Complex(0, omegas[iw]))*(a+Complex(0,omegas[iw])) ) ;
+            Gw(iw, iT2)     = sc * scale * std::real(T);
+            Gw(iw+nW, iT2) = sc * scale * std::imag(T);
+        }
+    }
+    return Gw;
+}

LemmaCore/examples/utpolygonalantenna.cpp

@@ -0,0 +1,67 @@
+// ===========================================================================
+//
+//       Filename:  utpolygonalantennae.cpp
+//
+//    Description:  Unit test of PolygonalAntenna
+//
+//        Version:  0.0
+//        Created:  05/26/2010 04:30:56 PM
+//       Revision:  none
+//       Compiler:  Tested with g++, icpc, and MSVC 2000
+//
+//         Author:  Trevor Irons (ti)
+//
+//   Organisation:  Colorado School of Mines (CSM)
+//                  United States Geological Survey (USGS)
+//
+//          Email:  tirons@mines.edu, tirons@usgs.gov
+//
+//  This program is free software: you can redistribute it and/or modify
+//  it under the terms of the GNU General Public License as published by
+//  the Free Software Foundation, either version 3 of the License, or
+//  (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+//
+// ===========================================================================
+
+#include "Lemma"
+
+using namespace Lemma;
+
+int main() {
+
+    PolygonalWireAntenna *pa = PolygonalWireAntenna::New();
+        pa->SetNumberOfPoints(5);
+        pa->SetPoint(0, Vector3r(  0,  0, -1e-3));
+        pa->SetPoint(1, Vector3r( 10,  0, -1e-3));
+        pa->SetPoint(2, Vector3r( 10, 10, -1e-3));
+        pa->SetPoint(3, Vector3r(  0, 10, -1e-3));
+        pa->SetPoint(4, Vector3r(  0,  0, -1e-3));
+        pa->SetNumberOfFrequencies(1);
+        pa->SetFrequency(0,1000.);
+        pa->SetCurrent(10.);
+        pa->SetNumberOfTurns(1);
+
+    Vector3r pos;
+    pos << 23,23,23;
+    pa->ApproximateWithElectricDipoles(pos);
+    std::cout << "pos "<< pos.transpose() << "  ndipoles="
+              << pa->GetNumberOfDipoles() << std::endl;
+    pos << 2,2,2;
+    pa->ApproximateWithElectricDipoles(pos);
+    std::cout << "pos "<< pos.transpose() << "  ndipoles="
+              << pa->GetNumberOfDipoles() << std::endl;
+    pos << 1,1,1;
+    pa->ApproximateWithElectricDipoles(pos);
+    std::cout << "pos "<< pos.transpose() << "  ndipoles="
+              << pa->GetNumberOfDipoles() << std::endl;
+
+    pa->Delete();
+}

LemmaCore/examples/utreadfemubc.cpp

@@ -0,0 +1,68 @@
+// ===========================================================================
+// 
+//       Filename:  utreadfemubc.cpp
+// 
+//    Description:  
+// 
+//        Version:  0.0
+//        Created:  01/03/2013 02:47:24 PM
+//       Revision:  none
+//       Compiler:  Tested with g++ 
+// 
+//         Author:  M. Andy Kass (MAK)
+//
+//   Organisation:  Broken Spoke Development, LLC
+//                  
+//
+//          Email:  mkass@numericalgeo.com
+// 
+//  This program is free software: you can redistribute it and/or modify
+//  it under the terms of the GNU General Public License as published by
+//  the Free Software Foundation, either version 3 of the License, or
+//  (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+//
+// ===========================================================================
+
+#include "Lemma"
+
+using namespace Lemma;
+
+#ifdef LEMMAUSEVTK
+#include "matplot.h"
+using namespace matplot;
+#endif
+
+int main() {
+
+	std::string datfile;
+
+	datfile = "126.obs";
+	
+	DataReaderFemUBC* Reader = DataReaderFemUBC::New();
+	DataFEM* thedata = DataFEM::New();
+
+	Reader->SetDataFEM(thedata);
+
+	try {
+	Reader->ReadData(datfile,1);
+	} catch(std::exception& e) {
+		exit(EXIT_FAILURE);
+	}
+
+	std::cout << *Reader << std::endl;
+	std::cout << *thedata << std::endl;
+
+
+	thedata->Delete();
+	Reader->Delete();
+
+	return EXIT_SUCCESS;
+}

LemmaCore/examples/utsandbox.cpp

@@ -0,0 +1,54 @@
+// ===========================================================================
+//
+//       Filename:  utsandbox.cpp
+//
+//        Created:  07/29/2010 10:34:23 AM
+//       Compiler:  Tested with g++, icpc, and MSVC 2010
+//
+//         Author:  Trevor Irons (ti)
+//
+//   Organisation:  Colorado School of Mines (CSM)
+//                  United States Geological Survey (USGS)
+//
+//          Email:  tirons@mines.edu, tirons@usgs.gov
+//
+//  This program is free software: you can redistribute it and/or modify
+//  it under the terms of the GNU General Public License as published by
+//  the Free Software Foundation, either version 3 of the License, or
+//  (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+//
+// ===========================================================================
+
+/**
+  @file test sandbox helm1rameters
+  @author   Trevor Irons
+  @date     07/29/2010
+  @version   0.0
+ **/
+
+#include "Lemma"
+
+using namespace Lemma;
+
+int main() {
+
+    PolygonalWireAntenna *helm1 = PolygonalWireAntenna::New();
+	helm1->SetNumberOfFrequencies(1);
+	helm1->SetFrequency(0, 1000);
+	helm1->SetNumberOfPoints(5);
+	helm1->SetPoint(0, Vector3r(   0,   0, 0));
+	helm1->SetPoint(1, Vector3r(   0,   0, 0));
+	helm1->SetPoint(2, Vector3r(   0,   0, 0));
+	helm1->SetPoint(3, Vector3r(   0,   0, 0));
+	helm1->SetPoint(4, Vector3r(   0,   0, 0));
+	helm1->SetCurrent(1.);
+    helm1->Delete();
+}

LemmaCore/examples/uttemforward.cpp

@@ -0,0 +1,199 @@
+// ===========================================================================
+//
+//       Filename:  uttemforward.cpp
+//
+//    Description:  TEM Forward Modeller
+//
+//        Version:  0.0
+//        Created:  02/10/2011 03:32:18 PM
+//       Revision:  none
+//       Compiler:  Tested with g++, icpc, and MSVC 2000
+//
+//         Author:  M. Andy Kass (MAK)
+//
+//		Copyright:  2011 Trevor Irons and M. Andy Kass
+//
+//   Organisation:  Colorado School of Mines (CSM)
+//                  Broken Spoke Development, LLC
+//
+//          Email:  mkass@numericalgeo.com
+//
+//  This program is free software: you can redistribute it and/or modify
+//  it under the terms of the GNU General Public License as published by
+//  the Free Software Foundation, either version 3 of the License, or
+//  (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+//
+// ===========================================================================
+
+#include <time.h>
+#include "Lemma"
+#include "banner.h"
+
+using namespace Lemma;
+
+#ifdef LEMMAUSEVTK
+#include "matplot.h"
+using namespace matplot;
+#endif
+
+int main(int argv, char** argc) {
+
+	// Just for timing
+	clock_t launch =clock();
+
+	// Banner display
+	std::string name;
+	std::string version;
+	std::string usage;
+	name = "TEM Forward Modeller - 1D";
+	version = "1.0beta";
+	usage = "temforward1d [inputfile]";
+	banner(name,version,usage);
+    if ( argv < 2 ) {
+        std::cout << "No input file specified, should be of format\n";
+        std::cout <<
+"origparabk.obsy        ! Observations-style file.\n\
+origpara.con           ! Starting model.\n\
+100                    ! Number of Hankel kernel evaluations.\n\
+100 1. 1.0E+10         ! Number of Fourier kernel evaluations, & min & max freq.\n\
+N                      ! Is noise to be added?\n\
+5.  1.0E-08  30        ! Noise to be added: percentage, threshold, seed.\n\
+" << std::endl;
+
+        exit(0);
+    }
+
+	time_t curr=time(0);
+	std::cout << std::endl;
+	std::cout << "  Start time: " << ctime(&curr) << std::endl;
+
+	// Define objects
+	PolygonalWireAntenna* Trans = PolygonalWireAntenna::New();
+//     PolygonalWireAntenna* pa = PolygonalWireAntenna::New();
+//         pa->SetNumberOfPoints(5);
+// 	    pa->SetPoint(0, Vector3r(   0,   0, -30.001));
+// 	    pa->SetPoint(1, Vector3r(   0,  20, -35.001));
+// 	    pa->SetPoint(2, Vector3r(  20 , 20, -35.001));
+// 	    pa->SetPoint(3, Vector3r(  20,   0, -30.001));
+// 	    pa->SetPoint(4, Vector3r(   0,   0, -30.001));
+// 	    pa->SetCurrent(100.);
+//         pa->SetNumberOfTurns(1);
+
+
+	//DipoleSource* Trans = DipoleSource::New();
+	ReceiverPoints *Receivers = ReceiverPoints::New();
+	LayeredEarthEM *Earth = LayeredEarthEM::New();
+	VectorXr maintimes;
+
+    /////////////////////////////////////
+	// Using model reader
+	ModelReaderTem1DUBC* Reader = ModelReaderTem1DUBC::New();
+	    Reader->SetEMEarth1D(Earth);
+	    Reader->SetTransmitter(Trans);
+	    Reader->SetReceiver(Receivers);
+	    Reader->ReadParameters( argc[1] );
+	    maintimes = Reader->GetTimes();
+
+	// Attach it to instrumentTEM
+	InstrumentTem *instrument = InstrumentTem::New();
+	    instrument->EMEarthModel(Earth);
+	    instrument->SetTransmitLoop(Trans);
+	    //instrument->SetTransmitLoop(pa);
+	    //instrument->SetDipoleSource(Trans);
+	    instrument->SetReceiver(Receivers);
+
+
+
+        // TODO need to input these
+        VectorXr widths = VectorXr::Ones(maintimes.size()); // * 1e-5;
+        /*
+        widths.segment(0,5).array()  *= 5e-6;
+        widths.segment(5,5).array()  *= 1e-5;
+        widths.segment(10,5).array() *= 5e-5;
+        widths.segment(15,5).array() *= 2e-4;
+        widths.segment(20,5).array() *= 4e-4;
+        //widths.segment(25,5).array() *= 4e-4;
+        */
+        /*
+        widths << .48,4.,8.,8.,8.,8.,8.,12.,12.,12.,16.,16.,16.,20.,24.,24.,28.,32.,32.,36.,40.,44.,52.,
+  				56.,64.,68.,76.,88.,96.,104.,120.,132.,144.,160.,180.,200.,220.,248.,272.,304.,336.,376.,
+  				416.,464.,516.,572.,636.,708.,784.,872.,968.,1076.,1196.,1328.,1476.,1640.,1824.,2024.,
+  				2248.,2500. ;
+        */
+        widths *= 1e-6;
+        std::cout << widths.transpose() << std::endl;
+
+        instrument->SetReferenceTime(.025);
+        //instrument->SetReferenceTime(.025);
+	    instrument->SetTimeGates(maintimes, widths);
+
+        //instrument->SetReceiverType(MAGNETOMETER);
+        instrument->SetReceiverType(INDUCTIVE);
+        // Set the pulse
+        VectorXr Amp(4); Amp << 0,1,1,0;
+        VectorXr Times(4); Times << 0., .0005, .02497, .025;
+
+        //VectorXr Amp(4); Amp << 0,1,1,0;
+        //VectorXr Times(4); Times << -0.025, -0.0245, -0.00003, 0.0;
+        //instrument->SetPulse(Amp, Times);
+
+        //VectorXr Amp(3); Amp << 0,1,0;
+        //VectorXr Times(3); Times << 0, .015, .030;
+        //instrument->SetPulse(Amp, Times);
+
+        //VectorXr Amp(3); Amp << 0,1,0;
+        //VectorXr Times(3); Times << 0, .01, .020;
+        instrument->SetPulse(Amp, Times);
+
+    std::cout << *Earth << "\n" << *Trans << "\n" << *Receivers << std::endl;
+
+	// Perform the forward model
+	//instrument->MakeDirectCalculation( FHTKEY201  );
+	//instrument->MakeLaggedCalculation( ANDERSON801 );
+	//instrument->MakeLaggedCalculation( QWEKEY );
+	//instrument->MakeLaggedCalculation( CHAVE );
+	instrument->MakeLaggedCalculation( FHTKEY201 );
+	//instrument->MakeLaggedCalculation( FHTKEY101 );
+
+    int nlag = instrument->GetMeasurements().rows();
+	// Output results to screen
+	for (int ii=0; ii<nlag; ii++) {
+		std::cout<<"  "<<instrument->GetMeasurements()(ii,0)<<"  "<<instrument->GetMeasurements()(ii,1)<<std::endl;
+	}
+
+	// Output results to file
+	std::ofstream outfile1;
+	outfile1.open("solution.out");
+    //outfile1 << "//timegate [ms]\t dB/dt [nT/s]" << std::endl;
+    outfile1 << "//timegate [s]\t dB/dt [T/s]" << std::endl;
+	for (int ii=0; ii<nlag; ii++) {
+		//outfile1 << 1e3*instrument->GetMeasurements()(ii,0)<< "\t" << (MU0*1e9)*instrument->GetMeasurements()(ii,1)<<std::endl;
+		outfile1 << instrument->GetMeasurements()(ii,0)<< "\t" << MU0*instrument->GetMeasurements()(ii,1) << std::endl;
+		//outfile1 << instrument->GetMeasurements()(ii,0)<< "\t" << instrument->GetMeasurements()(ii,1)<<std::endl;
+	}
+	outfile1.close();
+
+
+	// Timing stuff
+	std::cout << "  Time for execution: " <<  (clock()-launch)/CLOCKS_PER_SEC   << " [CPU] seconds."
+		 << std::endl;
+
+
+	instrument->Delete();
+	Trans->Delete();
+	Earth->Delete();
+	Receivers->Delete();
+	Reader->Delete();
+
+	return EXIT_SUCCESS;
+}
+
+

LemmaCore/examples/utteminv1d.cpp

@@ -0,0 +1,131 @@
+// ===========================================================================
+//
+//       Filename:  utteminv1d.cpp
+//
+//    Description:  Invert for the difference in water table
+//
+//        Version:  0.0
+//        Created:  03/23/2011 02:07:19 PM
+//       Revision:  none
+//       Compiler:  Tested with g++, icpc, and MSVC 2000
+//
+//         Author:  M. Andy Kass (MAK)
+//
+//   Organisation:  Colorado School of Mines (CSM)
+//                  Broken Spoke Development, LLC
+//
+//          Email:  mkass@numericalgeo.com
+//
+//  This program is free software: you can redistribute it and/or modify
+//  it under the terms of the GNU General Public License as published by
+//  the Free Software Foundation, either version 3 of the License, or
+//  (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+//
+// ===========================================================================
+
+#include "Lemma"
+#include "banner.h"
+
+using namespace Lemma;
+
+int main () {
+
+	VectorXr maintimes;
+	int ntimes;
+
+	//Banner
+	std::string name;
+	std::string version;
+	std::string usage;
+	name = "TEM Inversion - 1D";
+	version = "1.0beta";
+	usage = "teminv1d [inputfile]";
+	banner(name,version,usage);
+
+	PolygonalWireAntenna* Trans = PolygonalWireAntenna::New();
+	ReceiverPoints* Receivers = ReceiverPoints::New();
+	LayeredEarthEM* StartingMod = LayeredEarthEM::New();
+	//LayeredEarthEM* RecoveredMod = LayeredEarthEM::New();
+	InverseSolverTEM1D* Inverse = InverseSolverTEM1D::New();
+
+
+	Trans->SetNumberOfPoints(5);
+    Trans->SetPoint(0, Vector3r(   0,   0, -1e-3));
+    Trans->SetPoint(1, Vector3r( 100,   0, -1e-3));
+    Trans->SetPoint(2, Vector3r( 100, 100, -1e-3));
+    Trans->SetPoint(3, Vector3r(   0, 100, -1e-3));
+    Trans->SetPoint(4, Vector3r(   0,   0, -1e-3));
+	Trans->SetCurrent(1);
+	Trans->SetNumberOfTurns(1);
+    Trans->SetMinDipoleRatio(1/2.);
+
+	Vector3r loc;
+	Real ox = 50.;
+	Real oy = 50.;
+	Real depth = -1.e-3;
+	Receivers->SetNumberOfReceivers(1);
+	loc << ox,oy,depth;
+	Receivers->SetLocation(0,loc);
+
+	StartingMod->SetNumberOfLayers(22);
+	StartingMod->SetLayerConductivity( (VectorXcr(22) << 0.,1.e-3,
+		1.e-3,1.e-3,1.e-3,1.e-3,1.e-3,1.e-3,1.e-3,1.e-3,1.e-3,1.e-3,1.e-3,
+		1.e-3,1.e-3,1.e-3,1.e-3,1.e-3,1.e-3,1.e-3,1.e-3,1.e-3).finished() );
+	StartingMod->SetLayerThickness((VectorXr(20)<<4,4,4,4,4,4,4,4,4,4,4,4,4,
+		4,4,4,4,4,4,4).finished());
+	//EM-47 gate times
+	ntimes = 30;
+	maintimes.resize(ntimes);
+	maintimes << 36.,45.25,57.,72.25,92.,117.,148.,186.5,234.,290.,
+		352.5,427.5,525.,647.5,802.5,1002.5,1257.5,1582.5,1997.5,2525.,
+		3197.5,4055.,5147.5,6542.5,8322.5,10592.,13490.,17187.,21902.,
+		27915.;
+	maintimes = maintimes.array() /1000000;
+
+	Inverse->AttachStartMod(StartingMod);
+	Inverse->AttachWireAntenna(Trans);
+	Inverse->AttachReceiver(Receivers);
+	Inverse->SetTimes(maintimes);
+	LayeredEarthEM* RecoveredMod = StartingMod->Clone();
+	Inverse->AttachRecMod(RecoveredMod);
+
+	//Read input data - temp for SEG!
+	/// TODO write a TEM data reader class.  and a functional TEM data class
+	std::fstream infile("rotateddat.dat",std::ios::in);
+	if (infile.fail()) {
+		std::cout << "Shit!" << std::endl;
+	}
+	MatrixXr rotinpdata;
+	rotinpdata.resize(30,1);
+	for (int ii=0;ii<30;ii++) {
+		infile >> rotinpdata(ii);
+	}
+	infile.close();
+
+
+	Inverse->AttachMeasuredData(rotinpdata);
+	//Inverse->SetFreeParams( (VectorXi(2)<<0,1).finished(),
+	//	(VectorXi(3)<<1,2,3).finished());
+
+	std::cout << *Inverse << std::endl;
+
+	Inverse->Calculate();
+	//Inverse->ShowSoln();
+	//Inverse->WriteSoln("temp.dat");
+
+	Inverse->Delete();
+	RecoveredMod->Delete();
+	StartingMod->Delete();
+	Receivers->Delete();
+	Trans->Delete();
+
+	return EXIT_SUCCESS;
+}

LemmaCore/examples/uttemreader.cpp

@@ -0,0 +1,84 @@
+// ===========================================================================
+// 
+//       Filename:  uttemreader.cpp
+// 
+//    Description:  
+// 
+//        Version:  0.0
+//        Created:  02/19/2011 12:30:59 PM
+//       Revision:  none
+//       Compiler:  Tested with g++, icpc, and MSVC 2000 
+// 
+//         Author:  M. Andy Kass (MAK)
+//
+//   Organisation:  Colorado School of Mines (CSM)
+//                  Broken Spoke Brewery, LLC
+//
+//          Email:  mkass@numericalgeo.com
+// 
+//  This program is free software: you can redistribute it and/or modify
+//  it under the terms of the GNU General Public License as published by
+//  the Free Software Foundation, either version 3 of the License, or
+//  (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+//
+// ===========================================================================
+
+#include "Lemma"
+
+using namespace Lemma;
+
+
+int main() {
+
+	/*
+	ModelReaderTem1DUBC* Reader = ModelReaderTem1DUBC::New();
+	PolygonalWireAntenna* Trans = PolygonalWireAntenna::New();
+	ReceiverPoints *Receivers = ReceiverPoints::New();
+	LayeredEarthEM *Earth = LayeredEarthEM::New();
+	Reader->SetEMEarth1D(Earth);
+	Reader->SetTransmitter(Trans);
+	Reader->SetReceiver(Receivers);
+	Reader->ReadParameters("em1dtmfwd.in");
+
+	Reader->Delete();
+	Earth->Delete();
+	Receivers->Delete();
+	Trans->Delete();
+	*/
+
+	int rnObs;
+	int rnGates;
+	std::string inputfile;
+	MatrixXr somedata;
+	Vector3Xr somepositions;
+
+	DataTEM* TheData = DataTEM::New();
+	DataReaderTem* Reader = DataReaderTem::New();
+
+	inputfile = "temreadertest.txt";
+
+	Reader->SetDataTEM(TheData);
+	Reader->ReadData(inputfile);
+
+	rnObs = TheData->GetnObs();
+	rnGates = TheData->GetnGates();
+	somedata = TheData->GetData();
+	somepositions = TheData->GetPositions();
+
+	std::cout << rnObs << " " << rnGates << std::endl;
+	std::cout << somedata << std::endl;
+	std::cout << somepositions << std::endl;
+
+	Reader->Delete();
+	TheData->Delete();
+
+	return EXIT_SUCCESS;
+}

LemmaCore/examples/uttemsandbox.cpp

@@ -0,0 +1,207 @@
+// ===========================================================================
+//
+//       Filename:  uttemsandbox.cpp
+//
+//        Created:  09/29/2010 07:38:26 AM
+//       Compiler:  Tested with g++, icpc, and MSVC 2010
+//
+//         Author:  Trevor Irons (ti), M. Andy Kass
+//
+//
+//   Organisation:  Colorado School of Mines (CSM)
+//                  United States Geological Survey (USGS)
+//					Broken Spoke Development, LLC
+//
+//          Email:  tirons@mines.edu, tirons@usgs.gov
+//					mkass@numericalgeo.com
+//
+//  This program is free software: you can redistribute it and/or modify
+//  it under the terms of the GNU General Public License as published by
+//  the Free Software Foundation, either version 3 of the License, or
+//  (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+//
+// ===========================================================================
+
+/**
+  @file
+  @author   Trevor Irons
+  @date     09/29/2010
+  @version   0.0
+ **/
+
+#include "Lemma"
+using namespace Lemma;
+
+#ifdef LEMMAUSEVTK
+#include "matplot.h"
+using namespace matplot;
+#endif
+
+int main() {
+
+
+    int nfreq  =    6000;  // Number of frequencies
+
+	// Specify receiver times
+	int ntimes	=	30;
+	VectorXr times(ntimes);
+	times <<
+	36.0, 45.25, 57.0, 72.25, 92.0,
+	117.0, 148.0, 186.5, 234.0, 290.0,
+	352.5, 427.5, 525.0, 647.5, 802.5,
+	1002.5, 1257.5, 1582.5, 1997.5, 2525.0,
+	3197.5, 4055.0, 5147.5, 6542.5, 8322.5,
+	10592.0, 13490.0, 17187.0, 21902.0, 27915.0;
+
+	times = times.array()*1.0e-6;
+
+	//CALCULATE ABSCISSA
+	//define bounds
+
+	gaussianquadrature *lgqw = gaussianquadrature::New();
+
+	Real lowb;
+	Real upb;
+	lowb = 1.0;
+	upb = 6000000.0;
+	lgqw->SetFreqs(nfreq,upb,lowb);
+	lgqw->CalcAW();
+
+	VectorXr xu(nfreq);
+	xu=lgqw->GetAbscissae();
+	DipoleSource* Trans=DipoleSource::New();
+	Trans->SetType(MAGNETICDIPOLE);
+	Trans->SetPolarisation(ZPOLARISATION);
+	Trans->SetLocation(0.0,0.0,-1e-4);
+
+
+    // Specify Transmitter
+    //PolygonalWireAntenna* Trans  = PolygonalWireAntenna::New();
+    //Trans->SetNumberOfPoints(5);
+    //Trans->SetPoint(0, Vector3r(   0,   0, -1e-3));
+    //Trans->SetPoint(1, Vector3r( 100,   0, -1e-3));
+    //Trans->SetPoint(2, Vector3r( 100, 100, -1e-3));
+    //Trans->SetPoint(3, Vector3r(   0, 100, -1e-3));
+    //Trans->SetPoint(4, Vector3r(   0,   0, -1e-3));
+    Trans->SetNumberOfFrequencies(nfreq);
+    VectorXr  f(nfreq);
+    for (int ifreq=0; ifreq<nfreq; ++ifreq) {
+    //    Trans->SetFrequency(ifreq, 1e-3 + dfreq*(Real)(ifreq));
+		Trans->SetFrequency(ifreq,xu(ifreq));
+        f(ifreq) = xu(ifreq);
+    }
+	//cout << Trans->GetFrequencies();
+    //Trans->SetCurrent(1);
+    //Trans->SetNumberOfTurns(1);
+
+    // Earth properties, top layer is air layer 0 conductivity is fine
+    LayeredEarthEM *Earth = LayeredEarthEM::New();
+        Earth->SetNumberOfLayers(4);
+        Earth->SetLayerConductivity( (VectorXcr(4) << 0.,1.e-6,1.e-2,1.e-6 ).finished() );
+        Earth->SetLayerThickness( (VectorXr(2) << 50, 20).finished() );
+
+    // Receivers, just 1 in the centre for now
+   	ReceiverPoints *Receivers = ReceiverPoints::New();
+		Vector3r loc;
+		Real ox     =    50.;
+		Real oy     =    50.;
+		Real depth  =  -1e-2;
+		Receivers->SetNumberOfReceivers(1);
+		loc << ox, oy, depth;
+		Receivers->SetLocation(0, loc);
+
+	// EmEarth
+	EMEarth1D  *EmEarth = EMEarth1D::New();
+		//EmEarth->AttachWireAntenna(Trans);
+		EmEarth->AttachDipoleSource(Trans);
+		EmEarth->AttachLayeredEarthEM(Earth);
+		EmEarth->AttachReceiverPoints(Receivers);
+		EmEarth->SetFieldsToCalculate(H);
+        // slower but may be more accurate, depending on frequencies
+        EmEarth->SetHankelTransformMethod(CHAVE);
+        //EmEarth->SetHankelTransformMethod(DIGITALFILTERING);
+
+    // Do calculation
+   	//EmEarth->CalculateWireAntennaFields();
+	//EmEarth->MakeCalc();
+	EmEarth->MakeCalc3();
+
+    // Grab Z component
+    // A little painful, I'll try to clean up the API
+    VectorXcr Hw(nfreq);
+    VectorXr  e(nfreq);
+    Hw(0) = 0.; // DC component
+    for (int ifreq=0; ifreq<nfreq; ++ifreq) {
+        Hw(ifreq) = (Receivers->GetHfield(ifreq, 0))(2);
+        e(ifreq) = ifreq;
+    }
+
+    VectorXr Ht(ntimes);                   // Time domain H field
+
+	//Sine transform
+	VectorXr func(nfreq);
+	for (int ii=0;ii<ntimes;++ii) {
+		func = (Hw.imag().array()*((f.array()*times(ii)).sin()));
+		lgqw->SetFunc(func);
+		lgqw->Integrate();
+		Ht(ii)=lgqw->GetResult();
+	}
+	Ht = Ht.array()*(-2.0/PI);
+
+	std::ofstream myfile1;
+	myfile1.open("solution.txt");
+	for (int ii=0;ii<ntimes;++ii) {
+		myfile1 << times(ii) << "   " << Ht(ii) << std::endl;
+	}
+	myfile1.close();
+
+	std::ofstream myfile2;
+	myfile2.open("freq_domain.txt");
+	for (int ii=0;ii<nfreq;++ii) {
+		myfile2 << f(ii) << "  " << Hw(ii).real() << "  " << Hw(ii).imag()
+			<< std::endl;
+	}
+	myfile2.close();
+
+    //std::cout << Ht << std::endl;
+    //std::cout << Hw.real() << std::endl;
+
+    // Quick and dirty plot
+    #ifdef  LEMMAUSEVTK
+    double colour1[3] = {0.0,0.0,1.0};
+    double colour2[3] = {1.0,0.0,0.0};
+
+    Plot2D_VTK p1("Hz", "Re(Hw)", 800, 600);
+    p1.plot(f, Hw.real().eval(), colour1, ".-");
+    p1.show();
+
+    Plot2D_VTK p2("Hz", "Im(Hw)", 800, 600);
+    p2.plot(f, Hw.imag().eval(), colour2, ".-");
+    p2.show();
+
+    Plot2D_VTK p3("Time (seconds)", "Ht", 800, 600);
+    p3.plot(times, Ht, colour2, ".-");
+    p3.show();
+
+	//Plot2D_VTK p4("index", "frequency",800,600);
+	//p4.plot(e,f,colour1,".-");
+	//p4.show();
+
+    #endif
+
+    // Clean up
+    Trans->Delete();
+    Earth->Delete();
+    Receivers->Delete();
+    EmEarth->Delete();
+
+    return EXIT_SUCCESS;
+}

LemmaCore/examples/wireantenna.cpp

@@ -0,0 +1,319 @@
+// ===========================================================================
+//
+//       Filename:  utdipolesource.cpp
+//
+//    Description:
+//
+//        Version:  0.0
+//        Created:  12/02/2009 11:57:14 AM
+//       Revision:  none
+//       Compiler:  g++ (c++)
+//
+//         Author:  Trevor Irons (ti)
+//
+//   Organisation:  Colorado School of Mines (CSM)
+//                  United States Geological Survey (USGS)
+//
+//          Email:  tirons@mines.edu, tirons@usgs.gov
+//
+//  This program is free software: you can redistribute it and/or modify
+//  it under the terms of the GNU General Public License as published by
+//  the Free Software Foundation, either version 3 of the License, or
+//  (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+//
+// ===========================================================================
+
+#include <iostream>
+#include <fstream>
+
+#include "dipolesource.h"
+#include "layeredearth.h"
+#include "receiverpoints.h"
+#include "emearth1d.h"
+#include "WireAntenna.h"
+#include "PolygonalWireAntenna.h"
+
+#if  LEMMAUSEVTK
+#include "vtkRenderer.h"
+#include "vtkRenderWindow.h"
+#include "vtkRenderWindowInteractor.h"
+#include "vtkRenderLargeImage.h"
+#include "vtkPNGWriter.h"
+#endif     // -----  not LEMMA_USE_VTK  -----
+
+// For testing purposes disable VTK and run scale.sh
+//#undef LEMMAUSEVTK
+
+#include "timer.h"
+
+using namespace Lemma;
+
+double randDouble(double low, double high) {
+	//srand(time(0));
+	double temp;
+	/* swap low & high around if the user makes no sense */
+	if (low > high)	{
+	temp = low;
+	low = high;
+	high = temp;
+	}
+	/* calculate the random number & return it */
+	temp = (rand() / (static_cast<double>(RAND_MAX) + 1.0))
+	* (high - low) + low;
+	return temp;
+}
+
+
+int main() {
+
+	// Keep track of time
+	jsw_timer timer;
+
+
+	srand(time(0));
+
+	PolygonalWireAntenna *pa = PolygonalWireAntenna::New();
+	pa->SetNumberOfFrequencies(1);
+	pa->SetFrequency(0, 1000);
+	pa->SetNumberOfPoints(5);
+	pa->SetPoint(0, Vector3r(   0,   0, -.001));
+	pa->SetPoint(1, Vector3r( 100,   0, -.001));
+	pa->SetPoint(2, Vector3r( 100, 100, -.001));
+	pa->SetPoint(3, Vector3r(   0, 100, -.001));
+	pa->SetPoint(4, Vector3r(   0,   0, -.001));
+	pa->SetCurrent(1.);
+    pa->SetNumberOfTurns(1);
+	//Vector3r rp = Vector3r::Random(3);
+	//rp << 150., 10, 0.;
+	//rp << -27.1456, 15.2350, -1e-3;
+	//rp << randDouble(-35,35), randDouble(-35,35), randDouble(-35,35);
+	//rp << 3.22806, -13.1548, 14.9695;
+	//rp.setRandom(3);
+	//std::cout <<  "rp " << rp.transpose() << std::endl;
+	//pa->ApproximateWithElectricDipoles(rp);
+
+	WireAntenna *wire = WireAntenna::New();
+		wire->SetNumberOfPoints(5);
+		wire->SetPoint(0, Vector3r(   0,   0, -1e-3));
+		wire->SetPoint(1, Vector3r( 10,   0, -1e-3));
+		wire->SetPoint(2, Vector3r( 10, 10, -1e-3));
+		wire->SetPoint(3, Vector3r(   0, 10, -1e-3));
+		wire->SetPoint(4, Vector3r(   0,   0, -1e-3));
+		// TODO change wire antennae to use my class
+		//wire->SetNumberOfFrequencies(1);
+		wire->SetCurrent(1.);
+		wire->SetNumberOfFrequencies(1);
+		wire->SetFrequency(0, 1000);
+        wire->SetNumberOfTurns(1);
+		//wire->ApproximateWithElectricDipoles(5);
+
+	// Define model
+	VectorXcr sigma(2);
+		sigma << Complex(0.,0), Complex(.1,0);
+	VectorXr  thick(1);
+		thick << 10;
+	LayeredEarthEM *earth = LayeredEarthEM::New();
+		earth->SetNumberOfLayers(2);
+		earth->SetLayerConductivity(sigma);
+		//earth->SetLayerThickness(thick);
+
+	// Receivers
+	ReceiverPoints *receivers = ReceiverPoints::New();
+		Vector3r loc;
+		Real ox    =    50.561 ;
+		Real oy    =   105.235 ;
+		Real depth =    -3.75e1;
+		Real depth2 =   depth;
+		Real dx    =    1.;
+		int nz     =    1;
+		receivers->SetNumberOfReceivers(nz);
+		int ir = 0;
+		for (int iz=0; iz<nz; ++iz) {
+			loc << ox, oy, depth;
+			receivers->SetLocation(ir, loc);
+			depth += dx;
+			++ ir;
+		}
+
+	// EmEarth
+	EMEarth1D  *EmEarth = EMEarth1D::New();
+		//EmEarth->AttachWireAntenna(wire);
+		EmEarth->AttachWireAntenna(pa);
+		EmEarth->AttachLayeredEarthEM(earth);
+		EmEarth->AttachReceiverPoints(receivers);
+		EmEarth->SetFieldsToCalculate(H);
+        //EmEarth->SetHankelTransformMethod(GAUSSIANQUADRATURE);
+
+	// Do calculation
+	timer.begin();
+	EmEarth->CalculateWireAntennaFields();
+	Real paTime = timer.end();
+	std::cout << "Polygonal wire antennae time: " << paTime << "\n";
+
+	//EmEarth->AttachWireAntenna(wire);
+	//timer.begin();
+	//EmEarth->CalculateWireAntennaFields();
+	//Real waTime = timer.end();
+	//std::cout << "Fixed wire antennae time: " << waTime << "\n";
+
+	depth = depth2;
+	std::fstream real("reale_lay.dat", std::ios::out);
+	std::fstream imag("image_lay.dat", std::ios::out);
+	std::fstream hreal("real_lay.dat", std::ios::out);
+	std::fstream himag("imag_lay.dat", std::ios::out);
+	for (int iz=0; iz<nz; ++iz) {
+		Vector3cr temp = receivers->GetEfield(0,iz);
+		real << ox << "\t" << oy << "\t" << depth << "\t"
+				<< temp(0).real() << "\t" << temp(1).real()
+				<< "\t" << temp(2).real() << std::endl;
+		imag << ox << "\t" << oy << "\t" << depth << "\t"
+				<< std::imag(temp(0)) << "\t" << std::imag(temp(1))
+				<< "\t" << std::imag(temp(2)) << std::endl;
+		temp = receivers->GetHfield(0, iz);
+		hreal << ox << "\t" << oy << "\t" << depth << "\t"
+				<< std::real(temp(0)) << "\t" << std::real(temp(1))
+				<< "\t" << std::real(temp(2)) << std::endl;
+		himag << ox << "\t" << oy << "\t" << depth << "\t"
+				<< std::imag(temp(0)) << "\t" << std::imag(temp(1))
+				<< "\t" << std::imag(temp(2)) << std::endl;
+		depth += dx;
+	}
+	real.close();
+	imag.close();
+	hreal.close();
+	himag.close();
+	EmEarth->Delete();
+	receivers->Delete();
+	earth->Delete();
+	//wire->Delete();
+
+#if  LEMMAUSEVTK
+	// Create the usual rendering stuff.
+	vtkRenderer           *renderer = vtkRenderer::New();
+	vtkRenderWindow         *renWin = vtkRenderWindow::New();
+	vtkRenderWindowInteractor *iren = vtkRenderWindowInteractor::New();
+
+	// Line of tx
+	vtkLineSource       *vline = vtkLineSource::New();
+	vtkTubeFilter       *vTube = vtkTubeFilter::New();
+ 	vtkPolyDataMapper   *vMapper = vtkPolyDataMapper::New();
+	vtkActor             *vActor = vtkActor::New();
+	vline->SetPoint1(0,0,0);
+	vline->SetPoint2(10,0,0);
+
+	vTube->SetInputConnection(vline->GetOutputPort());
+	vTube->SetRadius(.2);
+	vTube->SetNumberOfSides(6);
+	vMapper->SetInputConnection(vTube->GetOutputPort());
+	vActor->SetMapper(vMapper);
+	vActor->GetProperty()->SetColor(0.0, .0, 1.0);
+	vActor->GetProperty()->SetOpacity(.15);
+	renderer->AddActor(vActor);
+
+	vtkLineSource       *vline2 = vtkLineSource::New();
+	vtkTubeFilter       *vTube2 = vtkTubeFilter::New();
+ 	vtkPolyDataMapper   *vMapper2 = vtkPolyDataMapper::New();
+	vtkActor             *vActor2 = vtkActor::New();
+	vline2->SetPoint1(10,0,0);
+	vline2->SetPoint2(10,10,0);
+
+	vTube2->SetInputConnection(vline2->GetOutputPort());
+	vTube2->SetRadius(.2);
+	vTube2->SetNumberOfSides(6);
+	vMapper2->SetInputConnection(vTube2->GetOutputPort());
+	vActor2->SetMapper(vMapper2);
+	vActor2->GetProperty()->SetColor(0.0, .0, 1.0);
+	vActor2->GetProperty()->SetOpacity(.15);
+	renderer->AddActor(vActor2);
+
+	vtkLineSource       *vline3 = vtkLineSource::New();
+	vtkTubeFilter       *vTube3 = vtkTubeFilter::New();
+ 	vtkPolyDataMapper   *vMapper3 = vtkPolyDataMapper::New();
+	vtkActor             *vActor3 = vtkActor::New();
+	vline3->SetPoint1(10,10,0);
+	vline3->SetPoint2(0,10,0);
+
+	vTube3->SetInputConnection(vline3->GetOutputPort());
+	vTube3->SetRadius(.2);
+	vTube3->SetNumberOfSides(6);
+	vMapper3->SetInputConnection(vTube3->GetOutputPort());
+	vActor3->SetMapper(vMapper3);
+	vActor3->GetProperty()->SetColor(0.0, .0, 1.0);
+	vActor3->GetProperty()->SetOpacity(.15);
+	renderer->AddActor(vActor3);
+
+	vtkLineSource       *vline4 = vtkLineSource::New();
+	vtkTubeFilter       *vTube4 = vtkTubeFilter::New();
+ 	vtkPolyDataMapper   *vMapper4 = vtkPolyDataMapper::New();
+	vtkActor             *vActor4 = vtkActor::New();
+	vline4->SetPoint1(0,10,0);
+	vline4->SetPoint2(0,0,0);
+
+	vTube4->SetInputConnection(vline4->GetOutputPort());
+	vTube4->SetRadius(.2);
+	vTube4->SetNumberOfSides(6);
+	vMapper4->SetInputConnection(vTube4->GetOutputPort());
+	vActor4->SetMapper(vMapper4);
+	vActor4->GetProperty()->SetColor(0.0, .0, 1.0);
+	vActor4->GetProperty()->SetOpacity(.15);
+	renderer->AddActor(vActor4);
+
+    loc << 50, 50, -1e-3;
+	pa->ApproximateWithElectricDipoles(loc);
+
+    vtkActor **pdipActors = new vtkActor*[pa->GetNumberOfDipoles()];
+    std::cout <<  "Wire approximated with " << pa->GetNumberOfDipoles() << std::endl;
+	for (int id=0; id<pa->GetNumberOfDipoles(); ++id) {
+		pdipActors[id] = pa->GetVtkActor(id);
+		renderer->AddActor(pdipActors[id]);
+	}
+
+    /*
+    vtkActor **dipActors = new vtkActor*[wire->GetNumberOfDipoles()];
+	for (int id=0; id<wire->GetNumberOfDipoles(); ++id) {
+		dipActors[id] = wire->GetVtkActor(id);
+		renderer->AddActor(dipActors[id]);
+	}
+    */
+
+	renderer->SetBackground(1,1,1);
+
+	// Render the window
+	renWin->AddRenderer(renderer);
+	renWin->SetWindowName("Wire antennae");
+
+	iren->SetRenderWindow(renWin);
+	iren->Initialize();
+	iren->Start();
+	iren->Render();
+
+    #if 0
+	cout << "Enter File name?: ";
+	std::string pngName;
+	std::cin >> pngName;
+	vtkPNGWriter *pngwrite = vtkPNGWriter::New();
+	vtkRenderLargeImage *renlarge = vtkRenderLargeImage::New();
+	renlarge->SetInput(renderer);
+	renlarge->SetMagnification(2);
+	pngwrite->SetInputConnection(renlarge->GetOutputPort());
+	pngName.append(".png");
+	pngwrite->SetFileName(pngName.c_str());
+	pngwrite->Write();
+    #endif
+
+#endif     // -----  not LEMMA_USE_VTK  -----
+
+
+	//std::cout << *pa << std::endl;
+	//pa->Delete();
+
+	return 0;
+}

LemmaCore/include/Lemma

@@ -0,0 +1,61 @@
+/* This file is part of Lemma, a geophysical modelling and inversion API */
+
+/* Copyright (C) 2009-2013 Trevor Irons <trevorirons@gmail.com> */
+
+/* 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
+  @author   Trevor Irons
+  @version  $Id$
+ **/
+
+// Convenience include all of Lemma
+
+#ifndef  LEMMAINCLUDE_INC
+#define  LEMMAINCLUDE_INC
+
+// Basic EM Classes
+//#include "dipolesource.h"
+#include "emearth1d.h"
+#include "emearth3d.h"
+#include "kernel.h"
+#include "receiverpoints.h"
+#include "receivercubes.h"
+#include "hankeltransformgaussianquadrature.h"
+#include "layeredearthem.h"
+#include "WireAntenna.h"
+#include "PolygonalWireAntenna.h"
+#include "gaussianquadrature.h"
+#include "digitalfiltercostrans.h"
+#include "octreegrid.h"
+
+// TEM
+#include "TEMSurvey.h"
+#include "TEMInductiveReceiver.h"
+#include "TEMTransmitter.h"
+
+//#include "rectilineargrid.h"
+
+// Specialized EM Classes
+#include "instrumenttem.h"
+#include "instrumentfem.h"
+
+// TEM Classes
+#include "datatem.h"
+#include "modelreadertem1dubc.h"
+#include "datareadertem.h"
+
+// FEM Classes
+#include "datareaderfemubc.h"
+#include "datafem.h"
+
+// Inverse
+#include "quasinewtonbfgs.h"
+#include "inversesolvertem1d.h"
+#endif   // ----- #ifndef LEMMAINCLUDE_INC  -----
+
+/* vim: set tabstop=4 expandtab: */
+/* vim: set filetype=cpp: */

LemmaCore/include/logbarriercg.h

@@ -23,9 +23,6 @@
 #include "bicgstab.h"
 #include "lemma.h"
 
-#ifdef LEMMAUSEVTK
-#include "matplot.h"
-#endif
 
 namespace Lemma {
 

LemmaCore/include/logbarriercg_newton.h

@@ -23,9 +23,6 @@
 #include "bicgstab.h"
 #include "lemma.h"
 
-#ifdef LEMMAUSEVTK
-#include "matplot.h"
-#endif
 
 namespace Lemma {
 

LemmaCore/include/octreegrid.h

@@ -38,8 +38,8 @@
 //#include "layeredearthnmr.h"
 #include "inversesolver.h"
 
-#include "FastDelegate.h"
-#include "FastDelegateBind.h"
+//#include "FastDelegate.h"
+//#include "FastDelegateBind.h"
 
 namespace Lemma {
 
@@ -202,7 +202,12 @@ namespace Lemma {
             template <class Derived>
             void SampleScalarFromLayeredEarth(LayeredEarth* earth,
                     Real (Derived::*fcnptr)(const int& id), const std::string &name) {
-
+                std::cerr << "In octreegrid.h SampleScalrFromLayeredEarth FastDelegate method was "
+                         << "removed, need to fix with move semantics or function pointer." << std::endl;
+                exit(3);
+                //TODO fix SampleScalar below, as call to SampleScalarFromLayeredEarthFD is
+                //     removed there.
+/*
                 SampleScalarFromLayeredEarthFD.bind(static_cast<Derived*>(earth), fcnptr);
                 GetLayerInt.bind(earth, &LayeredEarth::GetLayerAtThisDepth);
                 // TODO, don't use KernelArray, instead create new Array, and set it
@@ -212,6 +217,7 @@ namespace Lemma {
                 SampleScalar();
                 this->Octree->GetLeafData()->SetScalars( KernelArray );
                 this->Octree->GetLeafData()->AddArray( KernelArray );
+*/
             }
 
             /** Sends cursor to root
@@ -247,14 +253,14 @@ namespace Lemma {
              */
             void GetPosition( Real* p );
 
-            /** Used to fill leaf data with a scalar value from a layered earth
+            /* Used to fill leaf data with a scalar value from a layered earth
              *  model
              */
-            fastdelegate::FastDelegate1< const int&, Real > SampleScalarFromLayeredEarthFD;
+            //fastdelegate::FastDelegate1< const int&, Real > SampleScalarFromLayeredEarthFD;
 
-            /** Used to get the Layer of delagated model.
+            /* Used to get the Layer of delagated model.
              */
-            fastdelegate::FastDelegate1< const Real&, int >  GetLayerInt;
+            //fastdelegate::FastDelegate1< const Real&, int >  GetLayerInt;
 
             /** Recursively determines the mesh to use
              */

LemmaCore/src/octreegrid.cpp

@@ -617,8 +617,8 @@ namespace Lemma {
 
         //  split if needed
         if (Cursor->CurrentIsLeaf())  {
-            KernelArray->InsertValue(Cursor->GetLeafId(),
-                SampleScalarFromLayeredEarthFD(GetLayerInt(cpos(2))));
+            //KernelArray->InsertValue(Cursor->GetLeafId(),
+            //    SampleScalarFromLayeredEarthFD(GetLayerInt(cpos(2))));
         } else {
             // Evaluate function at cell centre
             for (int child=0; child < Cursor->GetNumberOfChildren(); ++ child) {