Split MirrorSymmetry in cylindrical and cartesian version

JuliaPhysics · Aug 29, 2022 · 1791d83 · 1791d83
1 parent 5ea6d53
commit 1791d83
Show file tree

Hide file tree

Showing 3 changed files with 42 additions and 35 deletions.
diff --git a/src/Simulation/Simulation.jl b/src/Simulation/Simulation.jl
@@ -468,7 +468,7 @@ Determines the grid for a certain contact, constrained by its symmetry.
 function Grid(sim::Simulation{T}, contact_id::Int) where T
     symmetry = sim.symmetry[Symbol(string(contact_id))]
     intervals = _get_grid_intervals(sim.world, symmetry)
-    Grid(sim, world = World{SolidStateDetectors.world_types(sim.world)...}(intervals...))
+    Grid(sim, world = World{world_types(sim.world)...}(intervals...))
 end
 
 """
@@ -480,31 +480,31 @@ Determines the grid intervals for a world with certain symmetry constraint.
 * `world::World{T, 3, Cartesian}` : Symmetry unconstrained [`World`](@ref)
 * `symmetry::MirrorSymmetry{T}` : Mirror plane which defines a reflective symmetry
 """
-function _get_grid_intervals(world::World{T, 3, Cartesian}, symmetry::MirrorSymmetry{T}) where {T}
+function _get_grid_intervals(world::World{T, 3, Cartesian}, symmetry::CartesianMirrorSymmetry{T}) where {T}
     x_interval = symmetry.symmetry_plane.normal[1] == 0 ? world.intervals[1] : 
-        SSDInterval{T, SolidStateDetectors.get_boundary_types(world.intervals[1])[1], :closed,
-        SolidStateDetectors.get_boundary_types(world.intervals[1])[3], :reflecting}(world.intervals[1].left, 
+        SSDInterval{T, get_boundary_types(world.intervals[1])[1], :closed,
+        get_boundary_types(world.intervals[1])[3], :reflecting}(world.intervals[1].left, 
         symmetry.symmetry_plane.origin[1])
     y_interval = symmetry.symmetry_plane.normal[2] == 0 ? world.intervals[2] : 
-        SSDInterval{T, SolidStateDetectors.get_boundary_types(world.intervals[2])[1], :closed,
-        SolidStateDetectors.get_boundary_types(world.intervals[2])[3], :reflecting}(world.intervals[2].left, 
+        SSDInterval{T, get_boundary_types(world.intervals[2])[1], :closed,
+        get_boundary_types(world.intervals[2])[3], :reflecting}(world.intervals[2].left, 
         symmetry.symmetry_plane.origin[2])
     z_interval = symmetry.symmetry_plane.normal[3] == 0 ? world.intervals[3] : 
-        SSDInterval{T, SolidStateDetectors.get_boundary_types(sim.world.intervals[3])[1], :closed,
-        SolidStateDetectors.get_boundary_types(world.intervals[3])[3], :reflecting}(world.intervals[3].left, 
+        SSDInterval{T, get_boundary_types(sim.world.intervals[3])[1], :closed,
+        get_boundary_types(world.intervals[3])[3], :reflecting}(world.intervals[3].left, 
         symmetry.symmetry_plane.origin[3])
     intervals = (x_interval, y_interval, z_interval)
 end
 
-function _get_grid_intervals(world::World{T, 3, Cylindrical}, symmetry::MirrorSymmetry{T}) where {T}
+function _get_grid_intervals(world::World{T, 3, Cylindrical}, symmetry::CylindricalMirrorSymmetry{T}) where {T}
     r_interval = world.intervals[1]
-    φ_interval = symmetry.symmetry_plane.normal[2] == 0 ? world.intervals[2] : 
+    φ_interval = symmetry.normal[2] == 0 ? world.intervals[2] : 
         SSDInterval{T, :closed, :closed, :reflecting, :reflecting}(world.intervals[2].left,
-        CylindricalPoint(symmetry.symmetry_plane.origin)[2])
-    z_interval = symmetry.symmetry_plane.normal[3] == 0 ? world.intervals[3] : 
-        SSDInterval{T, SolidStateDetectors.get_boundary_types(world.intervals[3])[1], :closed,
-        SolidStateDetectors.get_boundary_types(world.intervals[3])[3], :reflecting}(world.intervals[3].left, 
-        symmetry.symmetry_plane.origin[3])
+        symmetry.origin[2])
+    z_interval = symmetry.normal[3] == 0 ? world.intervals[3] : 
+        SSDInterval{T, get_boundary_types(world.intervals[3])[1], :closed,
+        get_boundary_types(world.intervals[3])[3], :reflecting}(world.intervals[3].left, 
+        symmetry.origin[3])
     intervals = (r_interval, φ_interval, z_interval)
 end
 

diff --git a/src/SolidStateDetectors.jl b/src/SolidStateDetectors.jl
@@ -62,7 +62,7 @@ export SSD_examples
 
 export Grid, GridPoint
 
-export MirrorSymmetry
+export CartesianMirrorSymmetry, CylindricalMirrorSymmetry
 export ElectricPotential, PointTypes, EffectiveChargeDensity, DielectricDistribution, WeightingPotential, ElectricField
 export apply_initial_state!
 export calculate_electric_potential!, calculate_weighting_potential!, calculate_electric_field!, calculate_drift_fields!

diff --git a/src/Symmetry/Mirror_Symmetry.jl b/src/Symmetry/Mirror_Symmetry.jl
@@ -1,35 +1,42 @@
-struct MirrorSymmetry{T}
+struct CartesianMirrorSymmetry{T}
     symmetry_plane::Plane{T} #Plane{T}(origin, normal)
 end
 
-function MirrorSymmetry{T}(origin::CylindricalPoint{T}, normal::CylindricalVector{T}) where {T}
-    _origin = CartesianPoint(origin)
-    _normal = CartesianVector{T}(cos(origin[2]) * normal[1] - sin(origin[2]) * normal[2], 
-        sin(origin[2]) * normal[1] + cos(origin[2]) * normal[2], normal[3])
-    MirrorSymmetry{T}(Plane{T}(_origin, _normal))
+struct CylindricalMirrorSymmetry{T}
+    origin::CylindricalPoint{T}
+    normal::CylindricalVector{T}
 end
 
-function MirrorSymmetry{T}(origin::CartesianPoint{T}, normal::CartesianVector{T}) where {T}
-    MirrorSymmetry{T}(Plane{T}(origin, normal))
+function CartesianMirrorSymmetry{T}(origin::CartesianPoint{T}, normal::CartesianVector{T}) where {T}
+    CartesianMirrorSymmetry{T}(Plane{T}(origin, normal))
 end
 
-function MirrorSymmetry(axis, value::T, units::NamedTuple = default_unit_tuple()) where {T<:SSDFloat}
+function CartesianMirrorSymmetry(axis, value::T, units::NamedTuple = default_unit_tuple()) where {T<:SSDFloat}
     length_unit = units.length
     angle_unit = units.angle
-    if axis == "phi" || axis == "φ"
-        MirrorSymmetry{T}(CylindricalPoint{T}(r=to_internal_units(1 * length_unit), φ = to_internal_units(value * angle_unit)),
-            CylindricalVector{T}(0, to_internal_units(1 * length_unit), 0))
-    elseif axis == "x"
-        MirrorSymmetry{T}(CartesianPoint{T}(x = to_internal_units(value * length_unit)), CartesianVector{T}(1,0,0))
+    if axis == "x"
+        CartesianMirrorSymmetry{T}(CartesianPoint{T}(x = to_internal_units(value * length_unit)), CartesianVector{T}(1,0,0))
     elseif axis == "y"
-        MirrorSymmetry{T}(CartesianPoint{T}(y = to_internal_units(value * length_unit)), CartesianVector{T}(0,1,0))
+        CartesianMirrorSymmetry{T}(CartesianPoint{T}(y = to_internal_units(value * length_unit)), CartesianVector{T}(0,1,0))
     elseif axis == "z"
-        MirrorSymmetry{T}(CartesianPoint{T}(z = to_internal_units(value * length_unit)), CartesianVector{T}(0,0,1))
+        CartesianMirrorSymmetry{T}(CartesianPoint{T}(z = to_internal_units(value * length_unit)), CartesianVector{T}(0,0,1))
+    else
+        @error "Wrong axis"
+    end
+end
+
+function CylindricalMirrorSymmetry(axis, value::T, units::NamedTuple = default_unit_tuple()) where {T<:SSDFloat}
+    length_unit = units.length
+    angle_unit = units.angle
+    if axis == "phi" || axis == "φ"
+        CylindricalMirrorSymmetry{T}(CylindricalPoint{T}(r=to_internal_units(1 * length_unit), φ = to_internal_units(value * angle_unit)),
+            CylindricalVector{T}(0, to_internal_units(1 * length_unit), 0))   
+    elseif axis == "z"
+        CylindricalMirrorSymmetry{T}(CartesianPoint{T}(z = to_internal_units(value * length_unit)), CartesianVector{T}(0,0,1))
     elseif axis == "r"
         @error "Mirror symmetry along r not defined"
     else
         @error "Wrong axis"
-    end
+    end 
 end
-
-
+