Cones #18

valeriaRaffuzzi · 2023-01-18T13:51:33Z

Here's a cone quadratic surface. It's an infinite cone, aligned with the x, y or z axis.
The input definition is the same as MCNP (need to specify the tangent of the opening angle and the orientation of the cone), compatible with Serpent as well.

I wrote a unit test and compared my results with Serpent, which agree.

Mikolaj-A-Kowalski

Thanks for the contribution and sorry that surfaces are bit of the mess in SCONE.

The only major question I have is if wouldn't it be easier to just include both cones in the surface instead of trying to use only one? I guess it makes it more user friendly but it seems to require considerable complication when evaluating the surface expression or finding the distance.

Geometry/Surfaces/Tests/cone_test.f90

Mikolaj-A-Kowalski · 2023-02-03T11:07:29Z

Geometry/Surfaces/QuadSurfaces/cone_class.f90

+   call self % setID(id)
+
+   ! Set surface tolerance
+   call self % setTol(TWO * SURF_TOL)


It probably should be made consistent with the value in the doc-comment.

Sadly there is a general problem with the surfaces and surface tolerance I missed when the current geometry was first made.

I wanted the surface tolerance to be well defined and be approximately a shell of constant 'fuzzy thickness' around the surface, but it sadly will not work with general quadratic surfaces where the 'radius' changes. Hence one cannot get away with the approximation of 2 * r * SURF_TOL which worked well for cylinders and spheres...

I think it is fine to leave it as it is but perhaps there should be a comment that will say that 'the thickness of the fuzzy region around the surface will depend on the position on the surface and is not constant'.

We probably should open an issue about it as well. We need to rethink how the surface tolerance is done.

The tests were a bit challenges because of this weird tolerance constant through a changing radius. Now everything should work but I agree that it's a bit annoying and suboptimal.

Hopefully this could be discussed in an issue and addressed in another PR!

I changed the tolerance to be proportional to the 'mean radius' of the cone now. That is the radius of the cone at mid-height.

Geometry/Surfaces/QuadSurfaces/cone_class.f90

Geometry/Surfaces/Tests/cone_test.f90

Geometry/geometryStd_class.f90

…Cones

Mikolaj-A-Kowalski

Looks good and thanks for the changes.
But because it is geometry it makes me super paranoid 😨 Did you run a lot of surface tracking calculations with the cones yet? We probably should construct geometries and torture them with the rayVol physics package a bit before merging.
I will try to run some when I have some time.

Geometry/Surfaces/QuadSurfaces/cone_class.f90

Geometry/Cells/simpleCell_class.f90

Geometry/Surfaces/QuadSurfaces/cone_class.f90

Mikolaj-A-Kowalski · 2024-05-10T12:29:47Z

Geometry/Surfaces/QuadSurfaces/cone_class.f90

+    ! If one the distance found is smaller than the surface tolerance, then the particles
+    ! is on a surface: set that distance to infinity
+    if (d1 < self % surfTol()) d1 = INF
+    if (d2 < self % surfTol()) d2 = INF


I am not sure if this approach will work I'm afraid... :-(
The problem are particles hitting the surface at very shallow angle. They may be well within the tolerance but the distance to the surface may be still quite large. This is why in the e.g. 'cylinder' we need an extra case in the if-else for when a particle is within surface tolerance.

Sorry... geometry is super annoying.

I see, I hadn't thought about that! I will reintroduce the extra if-else case when solving the quadratic, hopefully that will do it!

Mikolaj-A-Kowalski · 2024-05-10T12:38:27Z

Geometry/Surfaces/QuadSurfaces/cone_class.f90

+    ! Check that point found would be inside the cone
+    testPoint1 = r(self % axis) + dist * u(self % axis) - self % vertex(self % axis)
+    if (testPoint1 > self % hMax .or. testPoint1 < self % hMin) dist = INF
+
+    ! Calculate the distances from the basis of the cone
+    d1 = (self % hMax - diff(self % axis)) / u(self % axis)
+    d2 = (self % hMin - diff(self % axis)) / u(self % axis)
+
+    ! Verify if the points found would fall inside the cone
+    testPoint2 = r(self % plane) + d1 * u(self % plane) - self % vertex(self % plane)
+    testRadius = dot_product(testPoint2, testPoint2)
+    maxRadius  = self % hMax * self % hMax * self % tan2
+    if (testRadius > maxRadius) d1 = INF
+
+    testPoint2 = r(self % plane) + d2 * u(self % plane) - self % vertex(self % plane)
+    testRadius = dot_product(testPoint2, testPoint2)
+    maxRadius  = self % hMin * self % hMin * self % tan2
+    if (testRadius > maxRadius) d2 = INF


As an optimisation we can switch to the approach similar to the one used in the box... basically it involves calculating the ranges on the line that fall within a particular body (e.g. inside of the cylinder or space between a pair of planes) and then performing the intersections on the ranges. But is is sadly a bit difficult to explain in the short comment ;-( We can talk about it in person perhaps.

That being said we can leave the explicit approach if it works well and include the alternative as a TODO in the comment.

No that's ok, over the weekend I will have a look at the box and fix this! But I would still need to calculate explicitly whether the particle would intersect the circles? Because in a box or cylinder the two faces are of the same size but this is not true here.

Ok, the new distance calculation should be more like box and truncated cylinder now. The only thing I had to add is a check to make sure that the intersection found is on the right half-cone. Otherwise, the segment between two intersections could have been outside of the cone. If an intersection is on the wrong side of the cone, the distance is set to + or - infinity in a way that the intersection 'segment' (or ray) crosses the truncated cone (when here is an actual crossing). This might not be clear, in case let me know!

valeriaRaffuzzi · 2024-05-10T12:54:25Z

Looks good and thanks for the changes. But because it is geometry it makes me super paranoid 😨 Did you run a lot of surface tracking calculations with the cones yet? We probably should construct geometries and torture them with the rayVol physics package a bit before merging. I will try to run some when I have some time.

Thanks a lot for reviewing this, I am a geometry beginner! I ran a couple of cases but not rayVol to be fair. I would say hold on with this, I will work on it a bit more during the weekend and fix everything you mentioned, and then do a bit more testing :)

Hopefully at least we're converging to something with these cones!

valeriaRaffuzzi · 2024-05-27T22:53:13Z

Looks good and thanks for the changes. But because it is geometry it makes me super paranoid 😨 Did you run a lot of surface tracking calculations with the cones yet? We probably should construct geometries and torture them with the rayVol physics package a bit before merging. I will try to run some when I have some time.

Thanks a lot for reviewing this, I am a geometry beginner! I ran a couple of cases but not rayVol to be fair. I would say hold on with this, I will work on it a bit more during the weekend and fix everything you mentioned, and then do a bit more testing :)

Hopefully at least we're converging to something with these cones!

I think rayVol might be broken. I tried to use it on regular JEZ and POPSY and I get an error: Coordinate list is not placed in the geometry, in move. We should open an issue about that. However, I tested the cones on a few configurations doing ST vs DT and they always agree perfectly! I also tried to make the unit test as varied as I could in terms of distance calculations. Let me know if there is anything else I could do to test this.

ChasingNeutrons · 2024-09-05T12:24:03Z

Geometry/Surfaces/QuadSurfaces/cone_class.f90

+    end if
+
+    if (angle <= ZERO .or. angle >= 90.0_defReal) then
+      call fatalError(Here, 'Opening angle of cone must be in the range 0-90 degrees &


Maybe my Fortran is getting rusty, shouldn't this be:

Suggested change

call fatalError(Here, 'Opening angle of cone must be in the range 0-90 degrees &

call fatalError(Here, 'Opening angle of cone must be in the range 0-90 degrees '//&

'(extremes excluded). It is: '//numToChar(angle))

ChasingNeutrons · 2024-09-05T12:24:44Z

Geometry/Surfaces/QuadSurfaces/cone_class.f90

+                            & (extremes excluded). It is: '//numToChar(angle))
+    end if
+
+    if (hMin >= hMax) call fatalError(Here, 'hMin is greater or equal hMax.')


Suggested change

if (hMin >= hMax) call fatalError(Here, 'hMin is greater or equal hMax.')

if (hMin >= hMax) call fatalError(Here, 'hMin is greater than or equal to hMax.')

ChasingNeutrons · 2024-09-05T12:25:54Z

Geometry/Surfaces/QuadSurfaces/cone_class.f90

+    aabb(self % axis) = self % vertex(self % axis) + self % hMin
+    aabb(self % axis + 3) = self % vertex(self % axis) + self % hMax
+
+    ! On the plane of the basis


Suggested change

! On the plane of the basis

! On the plane of the base

ChasingNeutrons · 2024-09-05T12:27:27Z

Geometry/Surfaces/QuadSurfaces/cone_class.f90

+  !!
+  !! See surface_inter for details
+  !!
+  pure function evaluate(self, r) result(c)


Throughout this function I think 'basis' should be replaced with 'base' or 'bases'

ChasingNeutrons · 2024-09-05T12:29:05Z

Geometry/Surfaces/QuadSurfaces/cone_class.f90

+  pure function evaluate(self, r) result(c)
+    class(cone), intent(in)                 :: self
+    real(defReal), dimension(3), intent(in) :: r
+    real(defReal)                           :: c, cMin, cMax, cBasis


Suggested change

real(defReal) :: c, cMin, cMax, cBasis

real(defReal) :: c, cMin, cMax, cBase

ChasingNeutrons · 2024-09-05T12:29:15Z

Geometry/Surfaces/QuadSurfaces/cone_class.f90

+    c = dot_product(diff(self % plane), diff(self % plane)) - &
+        self % tanSquare * diff(self % axis) ** 2
+
+    ! Evaluate the expressions for the two basis of the cone and find the maximum


Suggested change

! Evaluate the expressions for the two basis of the cone and find the maximum

! Evaluate the expressions for the two bases of the cone and find the maximum

ChasingNeutrons · 2024-09-05T12:29:29Z

Geometry/Surfaces/QuadSurfaces/cone_class.f90

+    ! Evaluate the expressions for the two basis of the cone and find the maximum
+    cMin = - diff(self % axis) + self % hMin
+    cMax = diff(self % axis) - self % hMax
+    cBasis = max(cMin, cMax)


Suggested change

cBasis = max(cMin, cMax)

cBase = max(cMin, cMax)

ChasingNeutrons · 2024-09-05T12:29:40Z

Geometry/Surfaces/QuadSurfaces/cone_class.f90

+    cBasis = max(cMin, cMax)
+
+    ! Find the overall maximum
+    c = max(c, cBasis)


Suggested change

c = max(c, cBasis)

c = max(c, cBase)

ChasingNeutrons · 2024-09-05T12:30:16Z

Geometry/Surfaces/QuadSurfaces/cone_class.f90

+    ! Vector for the difference between position provided and vertex
+    diff = r - self % vertex
+
+    ! Evaluate the expression for the surface of the cone


All of the cone is arguably a surface.

Suggested change

! Evaluate the expression for the surface of the cone

! Evaluate the expression for the slanted surface of the cone

ChasingNeutrons · 2024-09-05T12:32:29Z

Geometry/Surfaces/QuadSurfaces/cone_class.f90

+    c = dot_product(diff(self % plane), diff(self % plane)) - &
+        self % tanSquare * diff(self % axis) ** 2
+
+    ! Calculate delta/4


What is delta? You mean the discriminant? That also does not appear to be what is calculated here - that would be b^2 / 4 - a*c

Maybe it's a bit confusion but the quadratic equation in this case is (comment in line 265): ad^2 + 2bd + a = 0

Sure, but it isn't clear what delta is. If you say 'calculate delta/4' there is no way for someone reading afterwards to understand what you are referring to.

Should I call it discriminant instead? Is this what you mean?

Yes, that would be easier to follow.

ChasingNeutrons · 2024-09-05T12:33:05Z

Geometry/Surfaces/QuadSurfaces/cone_class.f90

+    ! Calculate delta/4
+    delta = b * b - a * c
+
+    ! Calculate the distances from the cone surface


Suggested change

! Calculate the distances from the cone surface

! Calculate the distances from the slanted surface

ChasingNeutrons · 2024-09-05T12:33:50Z

Geometry/Surfaces/QuadSurfaces/cone_class.f90

+    near = min(d1, d2)
+    far  = max(d1, d2)
+
+    ! Calculate the distances from the basis of the cone


Suggested change

! Calculate the distances from the basis of the cone

! Calculate the distances from the bases of the cone

ChasingNeutrons · 2024-09-05T12:35:22Z

Geometry/Surfaces/QuadSurfaces/cone_class.f90

+    else                                            ! Particle parallel to axis: check location
+
+      if (diff(self % axis) > self % hMin .and. diff(self % axis) < self % hMax) then
+        ! Inside the cone: basis intersection segment is -INF:+INF


Should this be distance rather than segment?

Suggested change

! Inside the cone: basis intersection segment is -INF:+INF

! Inside the cone: base intersection distance is -INF:+INF

I think segment is ok: each couple of distances (base1 and base2, or slanted1 and slanted2) identifies 2 points that create a segment. The intersection between the two segments is what is actually internal to the cone. This is what the code is doing, and I think the docs are consistent with the cylinder and box where this approach is used.

I would then say the segment lies between -INF:INF. It is not clear what a segment being -INF:INF means.

ChasingNeutrons · 2024-09-05T12:35:45Z

Geometry/Surfaces/QuadSurfaces/cone_class.f90

+        d1 = -INF
+        d2 = INF
+      else
+        ! Outside the cone: basis intersection segment doesn't exist


Suggested change

! Outside the cone: basis intersection segment doesn't exist

! Outside the cone: base intersection distance doesn't exist

ChasingNeutrons · 2024-09-05T12:36:00Z

Geometry/Surfaces/QuadSurfaces/cone_class.f90

+
+    end if
+
+    ! Save minimum and maximum distance from cone basis


Suggested change

! Save minimum and maximum distance from cone basis

! Save minimum and maximum distance from cone bases

ChasingNeutrons · 2024-09-05T12:36:45Z

Geometry/Surfaces/QuadSurfaces/cone_class.f90

+
+    diff = r - self % vertex
+
+    ! Check the location of the particle, i.e., basis or cone surface, to calculate


Suggested change

! Check the location of the particle, i.e., basis or cone surface, to calculate

! Check the location of the particle, i.e., base or cone surface, to calculate

ChasingNeutrons · 2024-09-05T12:40:10Z

Geometry/Surfaces/Tests/cone_test.f90

+    @assertFalse(this % surf % halfspace(r, u))
+
+    ! Out within tolerance
+    ! NOTE THAT the tolerance is very sensitive: if using eps = HALF * TOL, the


Suggested change

! NOTE THAT the tolerance is very sensitive: if using eps = HALF * TOL, the

! NOTE that the tolerance is very sensitive: if using eps = HALF * TOL, the

ChasingNeutrons · 2024-09-05T12:40:52Z

Geometry/Surfaces/Tests/cone_test.f90

+    eps = -HALF
+    @assertTrue(this % surf % halfspace(r + eps*u, u))
+
+    ! Well withn


Suggested change

! Well withn

! Well within

ChasingNeutrons · 2024-09-05T12:40:58Z

Geometry/Surfaces/Tests/cone_test.f90

+    eps = -TWO * tolerance
+    @assertTrue(this % surf % halfspace(r + eps*u, u))
+
+    ! Well Outside


Suggested change

! Well Outside

! Well outside

ChasingNeutrons · 2024-09-05T12:41:17Z

Geometry/Surfaces/Tests/cone_test.f90

+    u = u /norm2(u)
+    @assertTrue(this % surf % halfspace(r, u))
+
+    ! Choose point on one of the basis of the cone, moving out


Suggested change

! Choose point on one of the basis of the cone, moving out

! Choose point on one of the bases of the cone, moving out

ChasingNeutrons · 2024-09-05T12:42:14Z

Geometry/Surfaces/Tests/cone_test.f90

+    ref   = 4.0_defReal
+    @assertEqual(ref, this % surf % distance(r, u), TOL * ref)
+
+    ! Impacting the basis


Suggested change

! Impacting the basis

! Impacting the bases

ChasingNeutrons · 2024-09-05T12:42:57Z

Geometry/Surfaces/Tests/cone_test.f90

+    u   = u/norm2(u)
+    @assertEqual(INF, this % surf % distance(r, u))
+
+    ! Parallel to the basis


Suggested change

! Parallel to the basis

! Parallel to the bases

ChasingNeutrons · 2024-09-05T12:43:25Z

Geometry/Surfaces/Tests/cone_test.f90

+    ref = 3.0_defReal
+    @assertEqual(ref, this % surf % distance(r, u), TOL * ref)
+
+    ! Parallel to basis


Suggested change

! Parallel to basis

! Parallel to bases

Geometry/geometryStd_class.f90

ChasingNeutrons · 2024-09-05T12:45:39Z

docs/User Manual.rst

@@ -517,6 +517,23 @@ Example: ::

      billy { id 92; type xCylinder; origin (0.0 0.0 9.0); radius 4.8; }

+* cone: cone aligned with x, y or z axis, and truncated arbitrarily on both sides. 
+  The input type has to be ``xCone``, ``yCone`` or ``zCone``. The orientation of the


Orientation is ambiguous with x, y, and z

Suggested change

The input type has to be ``xCone``, ``yCone`` or ``zCone``. The orientation of the

The input type has to be ``xCone``, ``yCone`` or ``zCone``. The gradient of the

ChasingNeutrons · 2024-09-05T12:46:15Z

docs/User Manual.rst

+
+Example: ::
+
+      billy { id 92; type xCone; vertex (1.1 4.0 2.98); angle 30; hMin 5.0; hMax 15.0; }


Suggested change

billy { id 92; type xCone; vertex (1.1 4.0 2.98); angle 30; hMin 5.0; hMax 15.0; }

connor { id 92; type xCone; vertex (1.1 4.0 2.98); angle 30; hMin 5.0; hMax 15.0; }

Did you change name to Connor because it sounds like cone?

Fair enough. I love bad humor

ChasingNeutrons

All small things I think. Should be straightforward.

Co-authored-by: Paul Cosgrove <pmc55@cam.ac.uk>

valeriaRaffuzzi added 4 commits July 15, 2022 09:08

Adding cone quadratic surface

1c39929

Trying to fix test

f09f0ac

Fixing calculation distance and cone test

d26e7e6

add documentation and aesthetic change to cone surface

489c4c8

Mikolaj-A-Kowalski added enhancement New feature or request Geometry labels Jan 19, 2023

Mikolaj-A-Kowalski self-requested a review February 3, 2023 10:32

Mikolaj-A-Kowalski reviewed Feb 3, 2023

View reviewed changes

ChasingNeutrons reviewed Apr 18, 2024

View reviewed changes

Geometry/Surfaces/QuadSurfaces/cone_class.f90 Outdated Show resolved Hide resolved

ChasingNeutrons reviewed Apr 18, 2024

View reviewed changes

Geometry/Surfaces/QuadSurfaces/cone_class.f90 Outdated Show resolved Hide resolved

ChasingNeutrons reviewed Apr 18, 2024

View reviewed changes

Geometry/Surfaces/Tests/cone_test.f90 Outdated Show resolved Hide resolved

ChasingNeutrons reviewed Apr 18, 2024

View reviewed changes

Geometry/geometryStd_class.f90 Outdated Show resolved Hide resolved

V. Raffuzzi(vr339) added 3 commits May 5, 2024 23:28

Merge branch 'main' of https://github.com/valeriaRaffuzzi/SCONE into …

fc18574

…Cones

Restructuring cones to allow to truncate them

d619d94

Adding few comments

7f157d0

Mikolaj-A-Kowalski reviewed May 10, 2024

View reviewed changes

V. Raffuzzi(vr339) added 3 commits May 15, 2024 15:31

reviews part I

dfe64ce

Optimising distance calculation in cones

6d7f413

Updating user manual

5edcb6c

Remove italianisms in User Manual.rst

f512729

ChasingNeutrons reviewed Sep 5, 2024

View reviewed changes

Geometry/geometryStd_class.f90 Outdated Show resolved Hide resolved

ChasingNeutrons reviewed Sep 5, 2024

View reviewed changes

ChasingNeutrons approved these changes Sep 5, 2024

View reviewed changes

valeriaRaffuzzi and others added 6 commits September 5, 2024 14:15

Fixing docs in cone_class

6c586f2

Fixing comments in cone_test.f90

09598e9

Update Geometry/geometryStd_class.f90

6928ce7

Co-authored-by: Paul Cosgrove <pmc55@cam.ac.uk>

Update User Manual.rst

99a955f

Update cone_test.f90 to pFUnit4

6a8e2f1

Update docs in cone_class.f90

c1f523c

valeriaRaffuzzi merged commit d718945 into CambridgeNuclear:main Sep 5, 2024
5 checks passed

valeriaRaffuzzi deleted the Cones branch September 5, 2024 14:29

	call fatalError(Here, 'Opening angle of cone must be in the range 0-90 degrees &
	call fatalError(Here, 'Opening angle of cone must be in the range 0-90 degrees '//&
	'(extremes excluded). It is: '//numToChar(angle))

	if (hMin >= hMax) call fatalError(Here, 'hMin is greater or equal hMax.')
	if (hMin >= hMax) call fatalError(Here, 'hMin is greater than or equal to hMax.')

	real(defReal) :: c, cMin, cMax, cBasis
	real(defReal) :: c, cMin, cMax, cBase

	! Evaluate the expressions for the two basis of the cone and find the maximum
	! Evaluate the expressions for the two bases of the cone and find the maximum

	! Evaluate the expression for the surface of the cone
	! Evaluate the expression for the slanted surface of the cone

	! Calculate the distances from the cone surface
	! Calculate the distances from the slanted surface

	! Calculate the distances from the basis of the cone
	! Calculate the distances from the bases of the cone

	! Inside the cone: basis intersection segment is -INF:+INF
	! Inside the cone: base intersection distance is -INF:+INF

	! Outside the cone: basis intersection segment doesn't exist
	! Outside the cone: base intersection distance doesn't exist

	! Save minimum and maximum distance from cone basis
	! Save minimum and maximum distance from cone bases


		diff = r - self % vertex

		! Check the location of the particle, i.e., basis or cone surface, to calculate

	! NOTE THAT the tolerance is very sensitive: if using eps = HALF * TOL, the
	! NOTE that the tolerance is very sensitive: if using eps = HALF * TOL, the

	! Choose point on one of the basis of the cone, moving out
	! Choose point on one of the bases of the cone, moving out

	The input type has to be ``xCone``, ``yCone`` or ``zCone``. The orientation of the
	The input type has to be ``xCone``, ``yCone`` or ``zCone``. The gradient of the


		Example: ::

		billy { id 92; type xCone; vertex (1.1 4.0 2.98); angle 30; hMin 5.0; hMax 15.0; }

	billy { id 92; type xCone; vertex (1.1 4.0 2.98); angle 30; hMin 5.0; hMax 15.0; }
	connor { id 92; type xCone; vertex (1.1 4.0 2.98); angle 30; hMin 5.0; hMax 15.0; }

Cones #18

Cones #18

Conversation

valeriaRaffuzzi commented Jan 18, 2023

Mikolaj-A-Kowalski left a comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Mikolaj-A-Kowalski left a comment • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

valeriaRaffuzzi commented May 10, 2024 • edited Loading

valeriaRaffuzzi commented May 27, 2024

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

valeriaRaffuzzi Sep 5, 2024 • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

ChasingNeutrons Sep 5, 2024 • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

ChasingNeutrons left a comment

Choose a reason for hiding this comment

Mikolaj-A-Kowalski left a comment •

edited

Loading

valeriaRaffuzzi commented May 10, 2024 •

edited

Loading

valeriaRaffuzzi Sep 5, 2024 •

edited

Loading

ChasingNeutrons Sep 5, 2024 •

edited

Loading