Add some homogeneous fields (#38)

* Add fields

* Fix tests

* Change `SequencedField`

* Add some tests

* Switch to rotated FFL

* Some fixes and additions

* Add coverage

* Fix tests

* Fix tests

* Fix coverage

* Add ErrorException

* Update Project.toml

---------

Co-authored-by: jonschumacher <[email protected]>

Author: jonschumacher

Project.toml

@@ -1,20 +1,25 @@
 name = "MPIMagneticFields"
 uuid = "f6dda52a-86e9-4b50-afb7-f39836a99446"
 authors = ["Marija Boberg <[email protected]> and contributors"]
-version = "0.0.7"
+version = "0.0.8"
 
 [deps]
 DocStringExtensions = "ffbed154-4ef7-542d-bbb7-c09d3a79fcae"
 LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
+Random = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c"
 StaticArrays = "90137ffa-7385-5640-81b9-e52037218182"
+Unitful = "1986cc42-f94f-5a68-af5c-568840ba703d"
+Waveforms = "cb13b1c6-351e-5134-b3ad-d6a530956a82"
 
 [compat]
 Aqua = "0.8"
 DocStringExtensions = "0.8, 0.9"
 JuliaFormatter = "1.0"
 LinearAlgebra = "1"
+Random = "1"
 StaticArrays = "1.5"
 Test = "1"
+Unitful = "1.15"
 Waveforms = "0.1"
 julia = "1"
 
@@ -23,7 +28,8 @@ Aqua = "4c88cf16-eb10-579e-8560-4a9242c79595"
 JuliaFormatter = "98e50ef6-434e-11e9-1051-2b60c6c9e899"
 LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
 Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
+Unitful = "1986cc42-f94f-5a68-af5c-568840ba703d"
 Waveforms = "cb13b1c6-351e-5134-b3ad-d6a530956a82"
 
 [targets]
-test = ["Aqua", "JuliaFormatter", "LinearAlgebra", "Test", "Waveforms"]
+test = ["Aqua", "JuliaFormatter", "LinearAlgebra", "Test", "Unitful", "Waveforms"]

example/FFLOrientation.jl

@@ -1,7 +1,7 @@
 using MPIMagneticFields
 using PyPlot
 
-field = IdealXYFFL(5.0)
+field = IdealXYRotatedFFL(5.0)
 
 for angle ∈ 0:(pi / 10):(2pi)
   imshow([

example/SequencedFFL.jl

@@ -0,0 +1,28 @@
+using PyPlot
+using LinearAlgebra
+using Unitful
+
+using MPIMagneticFields
+
+field_ = IdealXYRotatedTranslatedFFL(5u"T/m")
+
+f_ff = 200u"Hz"
+A_ff = 80.0u"mT"
+f_rot = 1u"Hz"
+ωᵣₒₜ = 2π * u"rad" * f_rot
+ϕᵣₒₜ = 0u"rad"
+T = 1.0u"s"
+
+sequence_ = RotationalTranslationalSequence(
+  T,
+  StandardRotationPattern(; ω = ωᵣₒₜ, ϕ = ϕᵣₒₜ),
+  SinusoidalTranslationPattern(; f = f_ff, amplitude = A_ff, offset = 0.0u"mT"),
+)
+
+sequencedField = SequencedField(field_, sequence_)
+
+figure()
+for t in range(0, 1, 20)u"s"
+  imshow(ustrip.(u"T", norm.(MPIMagneticFields.value(sequencedField, t, [-0.03:0.001:0.03, -0.03:0.001:0.03, 0.0]u"m"))))
+  sleep(0.1)
+end

src/CommonFields/CommonFields.jl

@@ -1,4 +1,3 @@
-
 include("FFL.jl")
 include("FFP.jl")
 include("Homogeneous.jl")

src/CommonFields/FFL.jl

@@ -15,6 +15,7 @@ function value_(field::IdealXYRotatedFFL, r, ϕ)
   mat = SMatrix{3, 3}(1/2 .- 1/2 .* sincos_[2], -1/2 .* sincos_[1], 0, -1/2 .* sincos_[1], 1/2 .+ 1/2 .* sincos_[2], 0, 0, 0, 1) .* field.gradient
   return mat * r
 end
+value_(field::IdealXYRotatedFFL, r, ϕ::T) where {T <: AbstractVector} = [value_(field, r, ϕ_) for ϕ_ in ϕ]
 
 export IdealXYRotatedTranslatedFFL
 mutable struct IdealXYRotatedTranslatedFFL{GT} <: AbstractMagneticField where {GT <: Number}
@@ -38,3 +39,5 @@ function value_(field::IdealXYRotatedTranslatedFFL, r, ϕ, δ)
   shift = SVector{3}(sincos_[1], sincos_[2], 0) .* δ
   return mat * r .+ shift
 end
+value_(field::IdealXYRotatedTranslatedFFL, r, ϕ::T, δ) where {T <: AbstractVector} = [value_(field, r, ϕ_, δ) for ϕ_ in ϕ]
+value_(field::IdealXYRotatedTranslatedFFL, r, ϕ::T, δ::V) where {T <: AbstractVector, V <: AbstractVector} = [value_(field, r, ϕ_, δ_) for (ϕ_, δ_) in zip(ϕ, δ)]

src/CommonFields/Homogeneous.jl

@@ -11,27 +11,80 @@ FieldTimeDependencyStyle(::IdealHomogeneousField) = TimeConstant()
 
 value_(field::IdealHomogeneousField, r) = field.value
 
-# TODO: Define other combinations
-export IdealXYRotatedHomogeneousField
-mutable struct IdealXYRotatedHomogeneousField{T} <: AbstractMagneticField where {T <: Number}
+export FunctionDefinedHomogeneousField
+mutable struct FunctionDefinedHomogeneousField{F} <: AbstractMagneticField where {F <: Function}
+  function_::F
+end
+
+FieldStyle(::FunctionDefinedHomogeneousField) = HomogeneousField()
+FieldDefinitionStyle(::FunctionDefinedHomogeneousField) = MethodBasedFieldDefinition()
+FieldTimeDependencyStyle(::FunctionDefinedHomogeneousField) = TimeVarying()
+
+value_(field::FunctionDefinedHomogeneousField, t, r) = field.function_(t)
+
+export OneDimensionalVariableTranslationHomogeneousField
+mutable struct OneDimensionalVariableTranslationHomogeneousField <: AbstractMagneticField
+  direction::Direction
+end
+
+FieldStyle(::OneDimensionalVariableTranslationHomogeneousField) = HomogeneousField()
+FieldDefinitionStyle(::OneDimensionalVariableTranslationHomogeneousField) = MethodBasedFieldDefinition()
+FieldTimeDependencyStyle(::OneDimensionalVariableTranslationHomogeneousField) = TimeVarying()
+FieldMovementStyle(::OneDimensionalVariableTranslationHomogeneousField) = TranslationalMovement()
+RotationalDimensionalityStyle(::OneDimensionalVariableTranslationHomogeneousField) = RotationalDimensionalityStyle{ZeroDimensional}()
+TranslationalDimensionalityStyle(::OneDimensionalVariableTranslationHomogeneousField) = TranslationalDimensionalityStyle{OneDimensional}()
+
+value_(field::OneDimensionalVariableTranslationHomogeneousField, t, r, δ) = value_(field.direction, field, t, r, δ)
+value_(field::OneDimensionalVariableTranslationHomogeneousField, t, r, δ::T) where {T <: AbstractVector} = [value_(field, t, r, δ_) for δ_ in δ]
+value_(direction::XDirection, field::OneDimensionalVariableTranslationHomogeneousField, t, r, δ) = SVector(δ, zero(eltype(δ)), zero(eltype(δ)))
+value_(direction::YDirection, field::OneDimensionalVariableTranslationHomogeneousField, t, r, δ) = SVector(zero(eltype(δ)), δ, zero(eltype(δ)))
+value_(direction::ZDirection, field::OneDimensionalVariableTranslationHomogeneousField, t, r, δ) = SVector(zero(eltype(δ)), zero(eltype(δ)), δ)
+
+export IdealRotatedHomogeneousField
+mutable struct IdealRotatedHomogeneousField{RT, T} <: AbstractMagneticField where {RT <: RotationPlane, T <: Number}
+  rotationPlane::RT
   amplitude::T
 end
 
-FieldStyle(::IdealXYRotatedHomogeneousField) = HomogeneousField()
-FieldDefinitionStyle(::IdealXYRotatedHomogeneousField) = MethodBasedFieldDefinition()
-FieldTimeDependencyStyle(::IdealXYRotatedHomogeneousField) = TimeConstant()
-FieldMovementStyle(::IdealXYRotatedHomogeneousField) = RotationalMovement()
+export IdealXYRotatedHomogeneousField
+IdealXYRotatedHomogeneousField(amplitude::T) where T <: Number = IdealRotatedHomogeneousField(XYRotationPlane(), amplitude)
+
+export IdealXZRotatedHomogeneousField
+IdealXZRotatedHomogeneousField(amplitude::T) where T <: Number = IdealRotatedHomogeneousField(XZRotationPlane(), amplitude)
+
+export IdealYZRotatedHomogeneousField
+IdealYZRotatedHomogeneousField(amplitude::T) where T <: Number = IdealRotatedHomogeneousField(YZRotationPlane(), amplitude)
+
+FieldStyle(::IdealRotatedHomogeneousField) = HomogeneousField()
+FieldDefinitionStyle(::IdealRotatedHomogeneousField) = MethodBasedFieldDefinition()
+FieldTimeDependencyStyle(::IdealRotatedHomogeneousField) = TimeConstant()
+FieldMovementStyle(::IdealRotatedHomogeneousField) = RotationalMovement()
 
-value_(field::IdealXYRotatedHomogeneousField, r, ϕ) = [sin(ϕ), cos(ϕ), 0] .* field.amplitude
+value_(field::IdealRotatedHomogeneousField{XYRotationPlane, T}, r, ϕ) where {T <: Number} = [sin(ϕ), cos(ϕ), 0] .* field.amplitude
+value_(field::IdealRotatedHomogeneousField{XZRotationPlane, T}, r, ϕ) where {T <: Number} = [sin(ϕ), 0, cos(ϕ)] .* field.amplitude
+value_(field::IdealRotatedHomogeneousField{YZRotationPlane, T}, r, ϕ) where {T <: Number} = [0, sin(ϕ), cos(ϕ)] .* field.amplitude
+
+export IdealRotatedTranslatedHomogeneousField
+mutable struct IdealRotatedTranslatedHomogeneousField{RT} <: AbstractMagneticField where {RT <: RotationPlane}
+  rotationPlane::RT
+end
 
 export IdealXYRotatedTranslatedHomogeneousField
-mutable struct IdealXYRotatedTranslatedHomogeneousField <: AbstractMagneticField end
+IdealXYRotatedTranslatedHomogeneousField() = IdealRotatedTranslatedHomogeneousField(XYRotationPlane())
+
+export IdealXZRotatedTranslatedHomogeneousField
+IdealXZRotatedTranslatedHomogeneousField() = IdealRotatedTranslatedHomogeneousField(XZRotationPlane())
+
+export IdealYZRotatedTranslatedHomogeneousField
+IdealYZRotatedTranslatedHomogeneousField() = IdealRotatedTranslatedHomogeneousField(YZRotationPlane())
 
-FieldStyle(::IdealXYRotatedTranslatedHomogeneousField) = HomogeneousField()
-FieldDefinitionStyle(::IdealXYRotatedTranslatedHomogeneousField) = MethodBasedFieldDefinition()
-FieldTimeDependencyStyle(::IdealXYRotatedTranslatedHomogeneousField) = TimeConstant()
-FieldMovementStyle(::IdealXYRotatedTranslatedHomogeneousField) = RotationalTranslationalMovement()
-RotationalDimensionalityStyle(::IdealXYRotatedTranslatedHomogeneousField) = RotationalDimensionalityStyle{OneDimensional}()
-TranslationalDimensionalityStyle(::IdealXYRotatedTranslatedHomogeneousField) = TranslationalDimensionalityStyle{OneDimensional}()
+FieldStyle(::IdealRotatedTranslatedHomogeneousField) = HomogeneousField()
+FieldDefinitionStyle(::IdealRotatedTranslatedHomogeneousField) = MethodBasedFieldDefinition()
+FieldTimeDependencyStyle(::IdealRotatedTranslatedHomogeneousField) = TimeConstant()
+FieldMovementStyle(::IdealRotatedTranslatedHomogeneousField) = RotationalTranslationalMovement()
+RotationalDimensionalityStyle(::IdealRotatedTranslatedHomogeneousField) = RotationalDimensionalityStyle{OneDimensional}()
+TranslationalDimensionalityStyle(::IdealRotatedTranslatedHomogeneousField) = TranslationalDimensionalityStyle{OneDimensional}()
 
-value_(field::IdealXYRotatedTranslatedHomogeneousField, r, ϕ, δ) = [sin(ϕ), cos(ϕ), 0] .* δ
+value_(field::IdealRotatedTranslatedHomogeneousField{XYRotationPlane}, r, ϕ, δ) = [sin(ϕ), cos(ϕ), 0] .* δ
+value_(field::IdealRotatedTranslatedHomogeneousField{XZRotationPlane}, r, ϕ, δ) = [sin(ϕ), 0, cos(ϕ)] .* δ
+value_(field::IdealRotatedTranslatedHomogeneousField{YZRotationPlane}, r, ϕ, δ) = [0, sin(ϕ), cos(ϕ)] .* δ