def _srcFct(self, obsLoc, coordinates="cartesian"):
if getattr(self, '_loop', None) is None:
self._loop = CircularLoopWholeSpace(mu=self.mu,
location=self.loc,
orientation=self.orientation,
radius=self.radius,
current=self.current)
return self._loop.vector_potential(obsLoc, coordinates)
def _srcFct(self, obsLoc, coordinates="cartesian"):
# return MagneticLoopVectorPotential(
# self.loc, obsLoc, component, mu=self.mu, radius=self.radius
# )
if getattr(self, "_loop", None) is None:
self._loop = CircularLoopWholeSpace(
mu=self.mu,
location=self.loc,
orientation=self.orientation,
radius=self.radius,
current=self.current,
)
return self._loop.vector_potential(obsLoc, coordinates)
class CircularLoop(MagDipole):
radius = properties.Float("radius of the loop source",
default=1.0,
min=0.0)
current = properties.Float("current in the loop", default=1.0)
N = properties.Float("number of turns in the loop", default=1.0)
def __init__(self, receiver_list=None, **kwargs):
super(CircularLoop, self).__init__(receiver_list, **kwargs)
@property
def moment(self):
return np.pi * self.radius**2 * self.current * self.N
def _srcFct(self, obsLoc, coordinates="cartesian"):
# return MagneticLoopVectorPotential(
# self.loc, obsLoc, component, mu=self.mu, radius=self.radius
# )
if getattr(self, "_loop", None) is None:
self._loop = CircularLoopWholeSpace(
mu=self.mu,
location=self.loc,
orientation=self.orientation,
radius=self.radius,
current=self.current,
)
return self._loop.vector_potential(obsLoc, coordinates)
def test_frequency_loop(self):
frequencies = np.logspace(-3, 6, 25)
radius = 50
hz_total = f_hz_loop(frequencies, sigma=1E-2, radius=radius, secondary=False)
# test 0 frequency limit
np.testing.assert_allclose(hz_total[0].real, 1/(2 * radius))
hz_secondary = f_hz_loop(frequencies, sigma=1E-2, radius=radius)
h_p = hz_total - hz_secondary
loop = CircularLoopWholeSpace(radius=radius)
h_p2 = loop.magnetic_field(np.array([[0, 0, 0]]))[0, 0]
np.testing.assert_allclose(h_p, h_p2)
bz_secondary = f_bz_loop(frequencies, sigma=1E-2, radius=radius)
np.testing.assert_equal(mu_0 * hz_secondary, bz_secondary)
def _srcFct(self, obsLoc, coordinates="cartesian"):
# return MagneticLoopVectorPotential(
# self.loc, obsLoc, component, mu=self.mu, radius=self.radius
# )
if getattr(self, '_loop', None) is None:
self._loop = CircularLoopWholeSpace(
mu=self.mu, location=self.loc,
orientation=self.orientation, radius=self.radius,
current=self.current
)
return self._loop.vector_potential(obsLoc, coordinates)
class CircularLoop(MagDipole):
"""
Circular loop magnetic source calculated by taking the curl of a magnetic
vector potential. By taking the discrete curl, we ensure that the magnetic
flux density is divergence free (no magnetic monopoles!).
This approach uses a primary-secondary in frequency in the same fashion as
the MagDipole.
:param list receiver_list: receiver list
:param float freq: frequency
:param numpy.ndarray loc: source location
(ie: :code:`np.r_[xloc,yloc,zloc]`)
:param string orientation: 'X', 'Y', 'Z'
:param float moment: magnetic dipole moment
:param float mu: background magnetic permeability
"""
radius = properties.Float("radius of the loop", default=1.0, min=0.0)
current = properties.Float("current in the loop", default=1.0)
def __init__(self,
receiver_list=None,
frequency=None,
location=None,
**kwargs):
super(CircularLoop, self).__init__(receiver_list, frequency, location,
**kwargs)
@property
def moment(self):
return np.pi * self.radius**2 * self.current
def _srcFct(self, obsLoc, coordinates="cartesian"):
if getattr(self, "_loop", None) is None:
self._loop = CircularLoopWholeSpace(
mu=self.mu,
location=self.location,
orientation=self.orientation,
radius=self.radius,
current=self.current,
)
return self._loop.vector_potential(obsLoc, coordinates)
class CircularLoop(MagDipole):
radius = properties.Float(
"radius of the loop source", default=1., min=0.
)
current = properties.Float(
"current in the loop", default=1.
)
# waveform = None
# loc = None
# orientation = 'Z'
# radius = None
# mu = mu_0
def __init__(self, rxList, **kwargs):
# assert(self.orientation in ['X', 'Y', 'Z']), (
# "Orientation (right now) doesn't actually do anything! The methods"
# " in SrcUtils should take care of this..."
# )
# self.integrate = False
super(CircularLoop, self).__init__(rxList, **kwargs)
@property
def moment(self):
return np.pi * self.radius**2 * self.current
def _srcFct(self, obsLoc, coordinates="cartesian"):
# return MagneticLoopVectorPotential(
# self.loc, obsLoc, component, mu=self.mu, radius=self.radius
# )
if getattr(self, '_loop', None) is None:
self._loop = CircularLoopWholeSpace(
mu=self.mu, location=self.loc,
orientation=self.orientation, radius=self.radius,
current=self.current
)
return self._loop.vector_potential(obsLoc, coordinates)
