Surface NMR forward modelling
Nevar pievienot vairāk kā 25 tēmas Tēmai ir jāsākas ar burtu vai ciparu, tā var saturēt domu zīmes ('-') un var būt līdz 35 simboliem gara.

pyMerlin.cpp 21KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348
  1. /* This file is part of Lemma, a geophysical modelling and inversion API.
  2. * More information is available at http://lemmasoftware.org
  3. */
  4. /* This Source Code Form is subject to the terms of the Mozilla Public
  5. * License, v. 2.0. If a copy of the MPL was not distributed with this
  6. * file, You can obtain one at http://mozilla.org/MPL/2.0/.
  7. */
  8. /**
  9. * @file
  10. * @date 22/04/19 14:06:32
  11. * @version $Id$
  12. * @author Trevor Irons (ti)
  13. * @email Trevor.Irons@utah.edu
  14. * @copyright Copyright (c) 2019, University of Utah
  15. * @copyright Copyright (c) 2019, Lemma Software, LLC
  16. */
  17. #include <pybind11/pybind11.h>
  18. #include <pybind11/iostream.h>
  19. #include <pybind11/stl.h>
  20. #include <pybind11/complex.h>
  21. #include <pybind11/eigen.h>
  22. #include "Merlin"
  23. namespace py = pybind11;
  24. PYBIND11_MODULE(Merlin, m) {
  25. py::add_ostream_redirect(m, "ostream_redirect");
  26. m.doc() = "Python binding of Lemma::Merlin, additional details can be found at https://lemmasoftware.org";
  27. py::class_<Lemma::KernelV0, std::shared_ptr<Lemma::KernelV0> > KernelV0(m, "KernelV0");
  28. // lifecycle
  29. KernelV0.def(py::init(&Lemma::KernelV0::NewSP))
  30. .def_static("DeSerialize", py::overload_cast<const std::string&>(&Lemma::KernelV0::DeSerialize),
  31. "Construct object from yaml representation")
  32. // print
  33. .def("Serialize", &Lemma::KernelV0::Print, "YAML representation of the class")
  34. .def("__repr__", &Lemma::KernelV0::Print)
  35. // modifiers
  36. .def("PushCoil", &Lemma::KernelV0::PushCoil, "Adds a coil to the sNMR instrument")
  37. .def("SetLayeredEarthEM", &Lemma::KernelV0::SetLayeredEarthEM, "Sets the EM model used in kernel calculation")
  38. .def("SetIntegrationSize", &Lemma::KernelV0::SetIntegrationSize, "Sets the size of the volume to integrate the kernel")
  39. .def("SetIntegrationOrigin", &Lemma::KernelV0::SetIntegrationOrigin, "Sets the origin of the integration volume")
  40. .def("SetPulseCurrent", &Lemma::KernelV0::SetPulseCurrent, "Sets the current of the pulses")
  41. .def("SetTemperature", &Lemma::KernelV0::SetTemperature, "Sets the temperature, in K")
  42. .def("SetTolerance", &Lemma::KernelV0::SetTolerance, "Sets the tolerance used in octree splitting")
  43. .def("SetMinLevel", &Lemma::KernelV0::SetMinLevel, "Sets the minimum leaf level used in octree splitting")
  44. .def("SetMaxLevel", &Lemma::KernelV0::SetMaxLevel, "Sets the maximum leaf level used in octree splitting")
  45. .def("SetPulseDuration", &Lemma::KernelV0::SetPulseDuration, "Sets the duration of the pulse")
  46. .def("SetDepthLayerInterfaces", &Lemma::KernelV0::SetDepthLayerInterfaces, "Sets the layer depth interfaces")
  47. .def("SetHankelTransformType", &Lemma::KernelV0::SetHankelTransformType, "Sets the Hankel transform type")
  48. // accessors
  49. .def("GetName", &Lemma::KernelV0::GetName, "Returns the name of the class")
  50. .def("GetSigmaModel", &Lemma::KernelV0::GetSigmaModel, "Returns the conductivity model")
  51. .def("GetKernel", &Lemma::KernelV0::GetKernel, "Returns the imaging kernel in matrix form")
  52. .def("GetTolerance", &Lemma::KernelV0::GetTolerance, "Returns the tolerance which was used to construct the kernel")
  53. .def("GetInterfaces", &Lemma::KernelV0::GetInterfaces, "Returns the layer interfaces")
  54. .def("GetPulseCurrent", &Lemma::KernelV0::GetPulseCurrent, "Returns the pulse current")
  55. .def("GetPulseDuration", &Lemma::KernelV0::GetPulseDuration, "Returns the length of the pulse moment")
  56. // operations
  57. .def("CalculateK0", &Lemma::KernelV0::CalculateK0, "Calculates an intial amplitude kernel")
  58. //.def("AlignWithAkvoDataset", &Lemma::KernelV0::AlignWithAkvoDataset, "Aligns the kernel parameters with a dataset")
  59. .def("AlignWithAkvoDataset", py::overload_cast< const std::string& >(&Lemma::KernelV0::AlignWithAkvoDataset), "Aligns Kernel pulse with specified dataset file")
  60. ;
  61. //
  62. // py::class_<Lemma::PolygonalWireAntenna, std::shared_ptr<Lemma::PolygonalWireAntenna> > PolygonalWireAntenna(m,
  63. // "PolygonalWireAntenna", KernelV0);
  64. //
  65. // // lifecycle
  66. // PolygonalWireAntenna.def(py::init(&Lemma::PolygonalWireAntenna::NewSP))
  67. // .def_static("DeSerialize", py::overload_cast<const std::string&>(&Lemma::PolygonalWireAntenna::DeSerialize),
  68. // "Construct object from yaml representation")
  69. //
  70. // // print
  71. // .def("__repr__", &Lemma::PolygonalWireAntenna::Print)
  72. // .def("Serialize", &Lemma::PolygonalWireAntenna::Print, "YAML representation of the class")
  73. //
  74. // // accessors
  75. // .def("GetName", &Lemma::PolygonalWireAntenna::GetName, "Returns the name of the class")
  76. //
  77. // // operations
  78. // .def("ApproximateWithElectricDipoles", &Lemma::PolygonalWireAntenna::ApproximateWithElectricDipoles,
  79. // "Approximates loop with series of electric dipoles around loop")
  80. //
  81. // // modifiers
  82. // .def("SetMinDipoleRatio", &Lemma::PolygonalWireAntenna::SetMinDipoleRatio,
  83. // "Sets the minimum dipole ratio use, smaller values increase precision")
  84. // .def("SetMinDipoleMoment", &Lemma::PolygonalWireAntenna::SetMinDipoleMoment,
  85. // "Sets the minimum dipole moment which will be used, smaller values increase precision and computational time")
  86. // .def("SetMaxDipoleMoment", &Lemma::PolygonalWireAntenna::SetMaxDipoleMoment,
  87. // "Sets the maximum dipole moment which will be used, smaller values increase precision and computational time")
  88. // ;
  89. //
  90. // py::class_<Lemma::DipoleSource, std::shared_ptr<Lemma::DipoleSource> > DipoleSource(m, "DipoleSource");
  91. //
  92. // // lifecycle
  93. // DipoleSource.def(py::init(&Lemma::DipoleSource::NewSP))
  94. // .def_static("DeSerialize", py::overload_cast<const std::string&>(&Lemma::DipoleSource::DeSerialize),
  95. // "Construct object from yaml representation")
  96. //
  97. // // print
  98. // .def("Serialize", &Lemma::DipoleSource::Print, "YAML representation of the class")
  99. // .def("__repr__", &Lemma::DipoleSource::Print)
  100. //
  101. // // accessors
  102. // .def("GetName", &Lemma::DipoleSource::GetName, "Returns the name of the class")
  103. // .def("GetNumberOfFrequencies", &Lemma::DipoleSource::GetNumberOfFrequencies,
  104. // "Returns the number of frequencies")
  105. // .def("GetFrequencies", &Lemma::DipoleSource::GetFrequencies, "Returns an array of frequencies")
  106. // .def("GetFrequency", &Lemma::DipoleSource::GetFrequency, "Returns the frequency of the argument index")
  107. // .def("GetAngularFrequency", &Lemma::DipoleSource::GetAngularFrequency,
  108. // "Returns the angular frequency of the argument index")
  109. // .def("GetPhase", &Lemma::DipoleSource::GetPhase, "Returns the phase of the dipole")
  110. // .def("GetMoment", &Lemma::DipoleSource::GetMoment, "Returns the moment of the dipole")
  111. // .def("GetLocation", py::overload_cast< >(&Lemma::DipoleSource::GetLocation), "Returns the location of the dipole")
  112. // .def("GetPolarisation", &Lemma::DipoleSource::GetPolarisation, "Returns the polarisation of the dipole")
  113. //
  114. // // modifiers
  115. // .def("SetLocation", py::overload_cast<const Lemma::Vector3r&> (&Lemma::DipoleSource::SetLocation),
  116. // "Sets the location of the dipole")
  117. // .def("SetPolarisation", py::overload_cast<const Lemma::Vector3r&> (&Lemma::DipoleSource::SetPolarisation),
  118. // "Sets the polarisation of the dipole")
  119. // .def("SetType", &Lemma::DipoleSource::SetType, "Sets the type")
  120. // .def("SetMoment", &Lemma::DipoleSource::SetMoment, "Sets the moment of the dipole")
  121. // .def("SetPhase", &Lemma::DipoleSource::SetPhase, "Sets the phase of the dipole")
  122. // .def("SetNumberOfFrequencies", &Lemma::DipoleSource::SetNumberOfFrequencies,
  123. // "Sets the number of frequencies to calculate for the dipole")
  124. // .def("SetFrequency", &Lemma::DipoleSource::SetFrequency,
  125. // "Sets a single frequency, first argument is index, second argument is frequency")
  126. // .def("SetFrequencies", &Lemma::DipoleSource::SetFrequencies,
  127. // "Sets all frequencies, argument is numpy array of frequencies")
  128. // ;
  129. //
  130. // py::class_<Lemma::LayeredEarthEM, std::shared_ptr<Lemma::LayeredEarthEM> >
  131. // LayeredEarthEM(m, "LayeredEarthEM");
  132. //
  133. // // lifecycle
  134. // LayeredEarthEM.def(py::init(&Lemma::LayeredEarthEM::NewSP))
  135. // .def_static("DeSerialize", py::overload_cast<const std::string&>
  136. // (&Lemma::LayeredEarthEM::DeSerialize),"Construct object from yaml representation")
  137. //
  138. // // print
  139. // .def("Serialize", &Lemma::LayeredEarthEM::Print, "YAML representation of the class")
  140. // .def("__repr__", &Lemma::LayeredEarthEM::Print)
  141. //
  142. // // accessors
  143. // .def("GetName", &Lemma::LayeredEarthEM::GetName, "Returns the name of the class")
  144. //
  145. // .def("GetLayerConductivity", py::overload_cast<>(&Lemma::LayeredEarthEM::GetLayerConductivity),
  146. // "Returns the conductivity of all layers")
  147. // .def("GetLayerConductivity1", py::overload_cast<const int&>(&Lemma::LayeredEarthEM::GetLayerConductivity),
  148. // "Returns the conductivity of the specified layer")
  149. //
  150. // .def("GetLayerSusceptibility", py::overload_cast<>(&Lemma::LayeredEarthEM::GetLayerSusceptibility),
  151. // "Returns the susceptibility of all layers")
  152. // .def("GetLayerSusceptibility1", py::overload_cast<const int&>(&Lemma::LayeredEarthEM::GetLayerSusceptibility),
  153. // "Returns the susceptibilty of the specified layer")
  154. // .def("GetLayerLowFreqSusceptibility", py::overload_cast<>(&Lemma::LayeredEarthEM::GetLayerLowFreqSusceptibility),
  155. // "Returns the low frequqncy permitivity of all layers")
  156. // .def("GetLayerLowFreqSusceptibility1", py::overload_cast<const int&>(&Lemma::LayeredEarthEM::GetLayerLowFreqSusceptibility),
  157. // "Returns the low frequency permitivity of the specified layer")
  158. // .def("GetLayerHighFreqSusceptibility", py::overload_cast<>(&Lemma::LayeredEarthEM::GetLayerHighFreqSusceptibility),
  159. // "Returns the low frequency permitivity of all layers")
  160. // .def("GetLayerHighFreqSusceptibility1", py::overload_cast<const int&>(&Lemma::LayeredEarthEM::GetLayerHighFreqSusceptibility),
  161. // "Returns the low frequency permitivity of the specified layer")
  162. // .def("GetLayerTauSusceptibility", py::overload_cast<>(&Lemma::LayeredEarthEM::GetLayerTauSusceptibility),
  163. // "Returns the tau permitivity of all layers")
  164. // .def("GetLayerTauSusceptibility1", py::overload_cast<const int&>(&Lemma::LayeredEarthEM::GetLayerTauSusceptibility),
  165. // "Returns the tau permitivity of the specified layer")
  166. // .def("GetLayerBreathSusceptibility", py::overload_cast<>(&Lemma::LayeredEarthEM::GetLayerBreathSusceptibility),
  167. // "Returns the breth permitivity of all layers")
  168. // .def("GetLayerBreathSusceptibility1", py::overload_cast<const int&>(&Lemma::LayeredEarthEM::GetLayerBreathSusceptibility),
  169. // "Returns the breath permitivity of the specified layer")
  170. //
  171. // .def("GetLayerPermitivity", py::overload_cast<>(&Lemma::LayeredEarthEM::GetLayerPermitivity),
  172. // "Returns the permitivity of all layers")
  173. // .def("GetLayerPermitivity1", py::overload_cast<const int&>(&Lemma::LayeredEarthEM::GetLayerPermitivity),
  174. // "Returns the permitivity of the specified layer")
  175. // .def("GetLayerLowFreqPermitivity", py::overload_cast<>(&Lemma::LayeredEarthEM::GetLayerLowFreqPermitivity),
  176. // "Returns the low frequqncy permitivity of all layers")
  177. // .def("GetLayerLowFreqPermitivity1", py::overload_cast<const int&>(&Lemma::LayeredEarthEM::GetLayerLowFreqPermitivity),
  178. // "Returns the low frequency permitivity of the specified layer")
  179. // .def("GetLayerHighFreqPermitivity", py::overload_cast<>(&Lemma::LayeredEarthEM::GetLayerHighFreqPermitivity),
  180. // "Returns the low frequency permitivity of all layers")
  181. // .def("GetLayerHighFreqPermitivity1", py::overload_cast<const int&>(&Lemma::LayeredEarthEM::GetLayerHighFreqPermitivity),
  182. // "Returns the low frequency permitivity of the specified layer")
  183. // .def("GetLayerTauPermitivity", py::overload_cast<>(&Lemma::LayeredEarthEM::GetLayerTauPermitivity),
  184. // "Returns the tau permitivity of all layers")
  185. // .def("GetLayerTauPermitivity1", py::overload_cast<const int&>(&Lemma::LayeredEarthEM::GetLayerTauPermitivity),
  186. // "Returns the tau permitivity of the specified layer")
  187. // .def("GetLayerBreathPermitivity", py::overload_cast<>(&Lemma::LayeredEarthEM::GetLayerBreathPermitivity),
  188. // "Returns the breth permitivity of all layers")
  189. // .def("GetLayerBreathPermitivity1", py::overload_cast<const int&>(&Lemma::LayeredEarthEM::GetLayerBreathPermitivity),
  190. // "Returns the breath permitivity of the specified layer")
  191. //
  192. //
  193. // // modifiers
  194. // .def("SetNumberOfLayers", &Lemma::LayeredEarthEM::SetNumberOfLayers,
  195. // "Sets the number of layers in the model")
  196. // .def("SetLayerConductivity", py::overload_cast< const Lemma::VectorXcr& >(&Lemma::LayeredEarthEM::SetLayerConductivity),
  197. // "Sets the conductivity of the layers, the input is a complex array of conductivity")
  198. // .def("SetLayerConductivity1", py::overload_cast< const int&, const Lemma::Complex& >(&Lemma::LayeredEarthEM::SetLayerConductivity),
  199. // "Sets the conductivity of a single layer, the first input is the layer index, and the secondinput is a complex conductivity")
  200. // .def("SetLayerThickness", &Lemma::LayeredEarthEM::SetLayerThickness,
  201. // "Sets the thickness of layers, excluding the air and bottom which are infinite")
  202. //
  203. // .def("SetLayerHighFreqSusceptibility", &Lemma::LayeredEarthEM::SetLayerHighFreqSusceptibility,
  204. // "Sets the high frequency susceptibility for Cole-COle model")
  205. // .def("SetLayerLowFreqSusceptibility", &Lemma::LayeredEarthEM::SetLayerLowFreqSusceptibility,
  206. // "Sets the low frequency susceptibility for Cole-COle model")
  207. // .def("SetLayerBreathSusceptibility", &Lemma::LayeredEarthEM::SetLayerBreathSusceptibility,
  208. // "Sets thesusceptibility breath for Cole-COle model")
  209. //
  210. // .def("SetLayerHighFreqPermitivity", &Lemma::LayeredEarthEM::SetLayerHighFreqPermitivity,
  211. // "Sets the high frequency permitivity for Cole-COle model")
  212. // .def("SetLayerLowFreqPermitivity", &Lemma::LayeredEarthEM::SetLayerLowFreqPermitivity,
  213. // "Sets the low frequency permitivity for Cole-COle model")
  214. // .def("SetLayerBreathPermitivity", &Lemma::LayeredEarthEM::SetLayerBreathPermitivity,
  215. // "Sets the permitivity breath for Cole-COle model")
  216. //
  217. //
  218. // // methods
  219. // .def("EvaluateColeColeModel", &Lemma::LayeredEarthEM::EvaluateColeColeModel,
  220. // "Calculates complex resistivity based on cole-cole parameters")
  221. // ;
  222. //
  223. // py::class_<Lemma::EMEarth1D, std::shared_ptr<Lemma::EMEarth1D> >
  224. // EMEarth1D(m, "EMEarth1D");
  225. //
  226. // // lifecycle
  227. // EMEarth1D.def(py::init(&Lemma::EMEarth1D::NewSP))
  228. // //.def_static("DeSerialize", py::overload_cast<const std::string&>
  229. // // (&Lemma::EMEarth1D::DeSerialize),"Construct object from yaml representation")
  230. //
  231. // // print
  232. // .def("Serialize", &Lemma::EMEarth1D::Print, "YAML representation of the class")
  233. // .def("__repr__", &Lemma::EMEarth1D::Print)
  234. //
  235. // // accessors
  236. // .def("GetName", &Lemma::EMEarth1D::GetName, "Returns the name of the class")
  237. // .def("GetFieldPoints", &Lemma::EMEarth1D::GetFieldPoints, "Returns the FieldPoint class")
  238. //
  239. // // modifiers
  240. // .def("AttachWireAntenna", &Lemma::EMEarth1D::AttachWireAntenna,
  241. // "Sets the wire antenna to use for calculations")
  242. // .def("AttachDipoleSOurce", &Lemma::EMEarth1D::AttachDipoleSource,
  243. // "Sets a DipoleSource to use for calculations")
  244. // .def("AttachFieldPoints", &Lemma::EMEarth1D::AttachFieldPoints,
  245. // "Sets the FieldPoints to use for calculations")
  246. // .def("AttachLayeredEarthEM", &Lemma::EMEarth1D::AttachLayeredEarthEM,
  247. // "Sets the LayeredEarthEM to use for calculations")
  248. //
  249. // .def("SetFieldToCalculate", &Lemma::EMEarth1D::SetFieldsToCalculate,
  250. // "Sets which fields to calculate")
  251. // .def("SetHankelTransformMethod", &Lemma::EMEarth1D::SetHankelTransformMethod,
  252. // "Sets which Hankel transform to use")
  253. // .def("SetTxRxMode", &Lemma::EMEarth1D::SetTxRxMode,
  254. // "Sets the TxRx mode flag")
  255. //
  256. // //methods
  257. // #ifdef KIHALEE_EM1D
  258. // .def("MakeCalc", &Lemma::EMEarth1D::MakeCalc, "Calls KiHa Lee's EM1D FORTRAN77 code")
  259. // #endif
  260. //
  261. // .def("MakeCalc3", &Lemma::EMEarth1D::MakeCalc3, "Native Lemma EM calculation")
  262. // .def("CalculateWireAntennaFields", &Lemma::EMEarth1D::CalculateWireAntennaFields,
  263. // "Native Lemma calculation of a wire antenna")
  264. // ;
  265. //
  266. // py::class_<Lemma::FieldPoints, std::shared_ptr<Lemma::FieldPoints> >
  267. // FieldPoints(m, "FieldPoints");
  268. //
  269. // // lifecycle
  270. // FieldPoints.def(py::init(&Lemma::FieldPoints::NewSP))
  271. // .def_static("DeSerialize", py::overload_cast<const std::string&>
  272. // (&Lemma::FieldPoints::DeSerialize),"Construct object from yaml representation")
  273. //
  274. // // print
  275. // .def("Serialize", &Lemma::FieldPoints::Print, "YAML representation of the class")
  276. // .def("__repr__", &Lemma::FieldPoints::Print)
  277. //
  278. // // modifiers
  279. // .def("SetNumberOfPoints", &Lemma::FieldPoints::SetNumberOfPoints,
  280. // "Sets the number of locations to make calculations on.")
  281. // .def("SetLocation", py::overload_cast< const int&, const Lemma::Vector3r& >
  282. // (&Lemma::FieldPoints::SetLocation), "Sets the location of the index-specified point." )
  283. // .def("SetLocation", py::overload_cast< const int&,
  284. // const Lemma::Real&, const Lemma::Real&, const Lemma::Real& >
  285. // (&Lemma::FieldPoints::SetLocation),
  286. // "Sets the location of the index-specified point with the three coordinates")
  287. //
  288. // // accessors
  289. // .def("GetNumberOfPoints", &Lemma::FieldPoints::GetNumberOfPoints,
  290. // "Returns the number of locations to make calculations on.")
  291. // .def("GetLocations", &Lemma::FieldPoints::GetLocations,
  292. // "Returns the locations which calculations are made on.")
  293. // .def("GetLocationsMat", &Lemma::FieldPoints::GetLocationsMat,
  294. // "Returns a matrix of the locations which calculations are made on.")
  295. // .def("GetLocation", &Lemma::FieldPoints::GetLocation,
  296. // "Returns the location of the specified index.")
  297. // .def("GetLocationX", &Lemma::FieldPoints::GetLocationX,
  298. // "Returns the northing (x) location of the specified index.")
  299. // .def("GetLocationY", &Lemma::FieldPoints::GetLocationY,
  300. // "Returns the easting (y) location of the specified index.")
  301. // .def("GetLocationZ", &Lemma::FieldPoints::GetLocationZ,
  302. // "Returns the altitude/depth (z) location of the specified index.")
  303. // .def("GetEfield", py::overload_cast< > (&Lemma::FieldPoints::GetEfield),
  304. // "Returns the electric field for all frequencies.")
  305. // .def("GetEfield", py::overload_cast< const int& > (&Lemma::FieldPoints::GetEfield),
  306. // "Returns the electric field for the specified frequency index.")
  307. // .def("GetEfield", py::overload_cast< const int&, const int& > (&Lemma::FieldPoints::GetEfield),
  308. // "Returns the electric field for the specified frequency and location index.")
  309. // .def("GetEfieldMat", &Lemma::FieldPoints::GetEfieldMat,
  310. // "Returns the electric field for the specified frequency.")
  311. // .def("GetHfield", py::overload_cast< > (&Lemma::FieldPoints::GetHfield),
  312. // "Returns the H field for all frequencies.")
  313. // .def("GetHfield", py::overload_cast< const int& > (&Lemma::FieldPoints::GetHfield),
  314. // "Returns the H field for the specified frequency index.")
  315. // .def("GetHfield", py::overload_cast< const int&, const int& > (&Lemma::FieldPoints::GetHfield),
  316. // "Returns the H field for the specified frequency and location index.")
  317. // //.def("GetBfield", py::overload_cast< const int&, const int& > (&Lemma::FieldPoints::GetBfield),
  318. // // "Returns the magnetic (B) field for the specified frequency and location index.")
  319. // .def("GetHfieldMat", &Lemma::FieldPoints::GetHfieldMat,
  320. // "Returns the H field for the specified frequency.")
  321. // .def("GetMask", &Lemma::FieldPoints::MaskPoint, "Return the mask boolean value for the specified index")
  322. //
  323. // // methods
  324. // .def("ClearFields", &Lemma::FieldPoints::ClearFields, "Clears calculated fields")
  325. // .def("MaskPoint", &Lemma::FieldPoints::MaskPoint, "Masks the index resulting in no calculation")
  326. // .def("UnMaskPoint", &Lemma::FieldPoints::UnMaskPoint, "Unmasks the index resulting in a calculation")
  327. //
  328. // ;
  329. }