Drop redundant T parameters per review feedback

Address @cncastillo's review on PR #782:
- DiscreteSequence: drop T<:Real, drop inner constructor, merge t/Δt types
- Magnetization: drop storage type params and parameterised Mag{T}(...) helper;
  T(2) → 2 in mul! and *; keep structural Mag(xy, z) outer for Functors walks
- Spinor.Q: drop Base.one. shadowing (extend Base.one(::Spinor) properly);
  hoist φ_half; @. on final Spinor build
- Update DiscreteSequence{T} dispatch sites to DiscreteSequence; T still bound
  from Phantom{T} / Mag{T} for the remaining T(γ) literals

sincos broadcast intentionally not adopted: incompatible with Reactant tracing
(no similar() method for array-of-tuples over TracedRNumber).

Author: KookiesNKareem

KomaMRIBase/src/datatypes/simulation/DiscreteSequence.jl

@@ -19,14 +19,12 @@ times. DiscreteSequence is the struct used for simulation.
 - `seqd`: (`::DiscreteSequence`) DiscreteSequence struct
 """
 struct DiscreteSequence{
-    T<:Real,
     GType<:AbstractVector,
     B1Type<:AbstractVector,
     ΔfType<:AbstractVector,
     ψType<:AbstractVector,
     ADCType<:AbstractVector{Bool},
     tType<:AbstractVector,
-    ΔtType<:AbstractVector,
 }
     Gx::GType
     Gy::GType
@@ -36,16 +34,7 @@ struct DiscreteSequence{
     ψ::ψType
     ADC::ADCType
     t::tType
-    Δt::ΔtType
-end
-
-function DiscreteSequence(
-    Gx::AbstractVector{T}, Gy, Gz, B1, Δf, ψ, ADC, t, Δt,
-) where {T<:Real}
-    return DiscreteSequence{
-        T, typeof(Gx), typeof(B1),
-        typeof(Δf), typeof(ψ), typeof(ADC), typeof(t), typeof(Δt),
-    }(Gx, Gy, Gz, B1, Δf, ψ, ADC, t, Δt)
+    Δt::tType
 end
 
 Base.length(seq::DiscreteSequence) = length(seq.Δt)

KomaMRICore/src/datatypes/Spinor.jl

@@ -29,7 +29,7 @@ struct Spinor{V<:AbstractVector}
 end
 Spinor(α::Complex{T}, β::Complex{T}) where {T<:Real} = Spinor([α], [β])
 Spinor(α::T, β::T) where {T<:Real} = Spinor([complex(α)], [complex(β)])
-one(T::Spinor) = Spinor(1.,0.)
+Base.one(::Spinor) = Spinor(1.,0.)
 Base.getindex(s::Spinor, i) = Spinor(s.α[i], s.β[i])
 Base.view(s::Spinor, i::UnitRange) = @views Spinor(s.α[i], s.β[i])
 """
@@ -158,10 +158,11 @@ IEEE Transactions on Medical Imaging, 10(1), 53-65. doi:10.1109/42.75611
 function Q(φ, nxy, nz)
     φ_half = φ ./ 2
     sin_φ_half = sin.(φ_half)
-    neg_im = complex.(zero.(φ), -Base.one.(φ))
+    cos_φ_half = cos.(φ_half)
+    neg_im = complex.(zero.(φ), -one.(φ))
     return Spinor(
-        cos.(φ_half) .+ neg_im .* nz .* sin_φ_half,
-        neg_im .* nxy .* sin_φ_half,
+        (@. cos_φ_half + neg_im * nz * sin_φ_half),
+        (@. neg_im * nxy * sin_φ_half),
     )
 end
 

KomaMRICore/src/simulation/SimMethods/Bloch/cpu/BlochCPU.jl

@@ -47,7 +47,7 @@ that they can be re-used from block to block.
 """
 function run_spin_precession!(
     p::Phantom{T},
-    seq::DiscreteSequence{T},
+    seq::DiscreteSequence,
     sig::AbstractArray{Complex{T}},
     M::Mag{T},
     sim_method::Bloch,
@@ -105,7 +105,7 @@ optimized for the CPU. Uses preallocation for all arrays to reduce memory usage.
 """
 function run_spin_excitation!(
     p::Phantom{T},
-    seq::DiscreteSequence{T},
+    seq::DiscreteSequence,
     sig::AbstractArray{Complex{T}},
     M::Mag{T},
     sim_method::Bloch,

KomaMRICore/src/simulation/SimMethods/Bloch/gpu/BlochGPU.jl

@@ -27,7 +27,7 @@ end
 
 function run_spin_precession!(
     p::Phantom{T},
-    seq::DiscreteSequence{T},
+    seq::DiscreteSequence,
     sig::AbstractArray{Complex{T}},
     M::Mag{T},
     sim_method::SM,
@@ -64,7 +64,7 @@ end
 
 function run_spin_excitation!(
     p::Phantom{T},
-    seq::DiscreteSequence{T},
+    seq::DiscreteSequence,
     sig::AbstractArray{Complex{T}},
     M::Mag{T},
     sim_method::SM,

KomaMRICore/src/simulation/SimMethods/BlochDict/BlochDict.jl

@@ -36,7 +36,7 @@ precession.
 """
 function run_spin_precession!(
     p::Phantom{T},
-    seq::DiscreteSequence{T},
+    seq::DiscreteSequence,
     sig::AbstractArray{Complex{T}},
     M::Mag{T},
     sim_method::BlochDict,

KomaMRICore/src/simulation/SimMethods/BlochMagnus/cpu/BlochMagnusCPU.jl

@@ -52,7 +52,7 @@ end
 # Use Bloch implementation for precession
 function run_spin_precession!(
     p::Phantom{T},
-    seq::DiscreteSequence{T},
+    seq::DiscreteSequence,
     sig::AbstractArray{Complex{T}},
     M::Mag{T},
     sim_method::BlochMagnus,
@@ -66,7 +66,7 @@ end
 # This part changes a bit more
 function run_spin_excitation!(
     p::Phantom{T},
-    seq::DiscreteSequence{T},
+    seq::DiscreteSequence,
     sig::AbstractArray{Complex{T}},
     M::Mag{T},
     sim_method::BlochMagnus,

KomaMRICore/src/simulation/SimMethods/BlochSimple/BlochSimple.jl

@@ -23,7 +23,7 @@ precession.
 """
 function run_spin_precession!(
     p::Phantom{T},
-    seq::DiscreteSequence{T},
+    seq::DiscreteSequence,
     sig::AbstractArray{Complex{T}},
     M::Mag{T},
     sim_method::SimulationMethod,
@@ -72,7 +72,7 @@ It gives rise to a rotation of `M0` with an angle given by the efective magnetic
 """
 function run_spin_excitation!(
     p::Phantom{T},
-    seq::DiscreteSequence{T},
+    seq::DiscreteSequence,
     sig::AbstractArray{Complex{T}},
     M::Mag{T},
     sim_method::SimulationMethod,

KomaMRICore/src/simulation/SimMethods/Magnetization.jl

@@ -10,24 +10,20 @@ The Magnetization struct.
 # Returns
 - `mag`: (`::Mag`) Magnetization struct
 """
-mutable struct Mag{T<:Real, XYType<:AbstractVector, ZType<:AbstractVector} <: SpinStateRepresentation{T}
-    xy::XYType
-    z::ZType
+mutable struct Mag{T<:Real} <: SpinStateRepresentation{T}
+    xy::AbstractVector
+    z::AbstractVector
 end
 
-function Mag(xy::AbstractVector{Complex{T}}, z::AbstractVector{T}) where {T<:Real}
-    return Mag{T,typeof(xy),typeof(z)}(xy, z)
-end
-function Mag{T}(xy::AbstractVector, z::AbstractVector) where {T<:Real}
-    return Mag{T,typeof(xy),typeof(z)}(xy, z)
-end
+# Convenience constructor used by Functors/concrete callers; Reactant paths use Mag{T}(...) directly
+Mag(xy::AbstractVector{Complex{T}}, z::AbstractVector{T}) where {T<:Real} = Mag{T}(xy, z)
 
 # Required indexing operations
 # M[i]
-Base.getindex(M::Mag, i::Integer) = Mag(M.xy[i,:], M.z[i,:])
+Base.getindex(M::Mag{T}, i::Integer) where {T} = Mag{T}(M.xy[i,:], M.z[i,:])
 # M[a:b]
-Base.getindex(M::Mag, i) = Mag(M.xy[i], M.z[i])
-Base.view(M::Mag, i) = @views Mag(M.xy[i], M.z[i])
+Base.getindex(M::Mag{T}, i) where {T} = Mag{T}(M.xy[i], M.z[i])
+Base.view(M::Mag{T}, i) where {T} = @views Mag{T}(M.xy[i], M.z[i])
 
 # Definition of rotation Spinor×SpinStateRepresentation
 @doc raw"""
@@ -52,23 +48,23 @@ Parameter relations for the Shinnar-Le Roux selective excitation pulse design al
 (NMR imaging).
 IEEE Transactions on Medical Imaging, 10(1), 53-65. doi:10.1109/42.75611
 """
-mul!(s::Spinor, M::Mag{T}) where {T<:Real} = begin
+mul!(s::Spinor, M::Mag{T}) where {T} = begin
     M_aux = Mag{T}(
-        T(2) .*conj.(s.α).*s.β.*M.z.+conj.(s.α).^2 .* M.xy.-s.β.^2 .*conj.(M.xy),
-        (abs.(s.α).^2 .-abs.(s.β).^2).*M.z.-T(2) .*real.(s.α.*s.β.*conj.(M.xy))
+        2 .*conj.(s.α).*s.β.*M.z.+conj.(s.α).^2 .* M.xy.-s.β.^2 .*conj.(M.xy),
+        (abs.(s.α).^2 .-abs.(s.β).^2).*M.z.-2 .*real.(s.α.*s.β.*conj.(M.xy))
      )
     M.xy .= M_aux.xy
     M.z  .= M_aux.z
 end
-mul!(s::Spinor, M::Mag{T}, Maux_xy, Maux_z) where {T<:Real} = begin
-    @. Maux_xy = T(2)*conj(s.α)*s.β*M.z+conj(s.α)^2*M.xy-s.β^2*conj(M.xy)
-    @. Maux_z = (abs(s.α)^2 -abs(s.β)^2)*M.z-T(2) *real(s.α*s.β*conj(M.xy))
+mul!(s::Spinor, M::Mag, Maux_xy, Maux_z) = begin
+    @. Maux_xy = 2*conj(s.α)*s.β*M.z+conj(s.α)^2*M.xy-s.β^2*conj(M.xy)
+    @. Maux_z = (abs(s.α)^2 -abs(s.β)^2)*M.z-2 *real(s.α*s.β*conj(M.xy))
     @. M.xy = Maux_xy
     @. M.z = Maux_z
 end
-*(s::Spinor, M::Mag{T}) where {T<:Real} = begin
+*(s::Spinor, M::Mag{T}) where {T} = begin
     Mag{T}(
-        T(2) .*conj.(s.α).*s.β.*M.z.+conj.(s.α).^2 .* M.xy.-s.β.^2 .*conj.(M.xy),
-        (abs.(s.α).^2 .-abs.(s.β).^2).*M.z.-T(2) .*real.(s.α.*s.β.*conj.(M.xy))
+        2 .*conj.(s.α).*s.β.*M.z.+conj.(s.α).^2 .* M.xy.-s.β.^2 .*conj.(M.xy),
+        (abs.(s.α).^2 .-abs.(s.β).^2).*M.z.-2 .*real.(s.α.*s.β.*conj.(M.xy))
      )
 end

KomaMRICore/src/simulation/SimulatorCore.jl

@@ -62,7 +62,7 @@ end
 
 function run_spin_precession_parallel!(
     obj::Phantom{T},
-    seq::DiscreteSequence{T},
+    seq::DiscreteSequence,
     sig::AbstractArray{Complex{T}},
     Xt::SpinStateRepresentation{T},
     sim_method::SimulationMethod,
@@ -84,7 +84,7 @@ end
 
 function run_spin_excitation_parallel!(
     obj::Phantom{T},
-    seq::DiscreteSequence{T},
+    seq::DiscreteSequence,
     sig::AbstractArray{Complex{T}},
     Xt::SpinStateRepresentation{T},
     sim_method::SimulationMethod,