Implementation of 0D grid for analysis of collisional operators.

Still need to add a 0D pusher and the corresponding input configuration
and documentation.

src/modules/mesh/0D/makefile

@@ -0,0 +1,5 @@
+all: moduleMesh0D.o
+
+moduleMesh0D.o: moduleMesh0D.f90
+	$(FC) $(FCFLAGS) -c $(subst .o,.f90,$@) -o $(OBJDIR)/$@
+

src/modules/mesh/0D/moduleMesh0D.f90

@@ -0,0 +1,181 @@
+!moduleMesh1D: 0D mesh. No coordinates are relevant. No edges are used
+MODULE moduleMesh0D
+  USE moduleMesh
+  IMPLICIT NONE
+
+  TYPE, PUBLIC, EXTENDS(meshNode):: meshNode0D
+    INTEGER:: n1
+    CONTAINS
+      PROCEDURE, PASS:: init => initNode0D
+      PROCEDURE, PASS:: getCoordinates => getCoord0D
+
+  END TYPE meshNode0D
+
+  TYPE, PUBLIC, EXTENDS(meshVol):: meshVol0D
+    CLASS(meshNode), POINTER:: n1
+    CONTAINS
+      PROCEDURE, PASS:: init => initVol0D
+      PROCEDURE, PASS:: getNodes    => getNodes0D
+      PROCEDURE, PASS:: randPos     => randPos0D
+      PROCEDURE, PASS:: scatter     => scatter0D
+      PROCEDURE, PASS:: gatherEF    => gatherEF0D
+      PROCEDURE, PASS:: elemK       => elemK0D
+      PROCEDURE, PASS:: elemF       => elemF0D
+      PROCEDURE, PASS:: phy2log     => phy2log0D
+      PROCEDURE, NOPASS:: inside    => inside0D
+      PROCEDURE, PASS:: nextElement => nextElement0D
+
+  END TYPE meshVol0D
+
+  CONTAINS
+    !NODE FUNCTIONS
+    !Init node
+    SUBROUTINE initNode0D(self, n, r)
+      IMPLICIT NONE
+
+      CLASS(meshNode0D), INTENT(out):: self
+      INTEGER, INTENT(in):: n
+      REAL(8), INTENT(in):: r(1:3) !Unused variable
+
+      self%n = n
+
+    END SUBROUTINE initNode0D
+
+    !Get node coordinates
+    PURE FUNCTION getCoord0D(self) RESULT(r)
+      IMPLICIT NONE
+
+      CLASS(meshNode0D), INTENT(in):: self
+      REAL(8):: r(1:3)
+
+      r = 0.D0
+
+    END FUNCTION
+
+    !VOLUME FUNCTIONS
+    !Inits dummy 0D volume
+    SUBROUTINE initVol0D(self, n, p, nodes)
+      USE moduleRefParam
+      IMPLICIT NONE
+
+      CLASS(meshVol0D), INTENT(out):: self
+      INTEGER, INTENT(in):: n
+      INTEGER, INTENT(in):: p(:)
+      TYPE(meshNodeCont), INTENT(in), TARGET:: nodes(:)
+
+      self%n = n
+
+      self%n1 => nodes(p(1))%obj
+      self%volume = 1.D0
+      self%n1%v = 1.D0
+
+      self%sigmaVrelMax = sigma_ref/L_ref**2
+
+      CALL OMP_INIT_LOCK(self%lock)
+
+    END SUBROUTINE initVol0D
+
+    PURE FUNCTION getNodes0D(self) RESULT(n)
+      IMPLICIT NONE
+
+      CLASS(meshVol0D), INTENT(in):: self
+      INTEGER, ALLOCATABLE:: n(:)
+
+    END FUNCTION getNodes0D
+
+    FUNCTION randPos0D(self) RESULT(r)
+      IMPLICIT NONE
+
+      CLASS(meshVol0D), INTENT(in):: self
+      REAL(8):: r(1:3)
+
+      r = 0.D0
+
+    END FUNCTION randPos0D
+
+    SUBROUTINE scatter0D(self, part)
+      USE moduleMath
+      USE moduleSpecies
+      IMPLICIT NONE
+
+      CLASS(meshVol0D), INTENT(in):: self
+      CLASS(particle), INTENT(in):: part
+      REAL(8):: tensorS(1:3,1:3)
+      TYPE(outputNode), POINTER:: vertex
+
+      tensorS = outerProduct(part%v, part%v)
+
+      vertex => self%n1%output(part%species%n)
+      vertex%den          = vertex%den          + part%weight
+      vertex%mom(:)       = vertex%mom(:)       + part%weight*part%v(:)
+      vertex%tensorS(:,:) = vertex%tensorS(:,:) + part%weight*tensorS
+
+    END SUBROUTINE scatter0D
+
+    PURE FUNCTION gatherEF0D(self, xi) RESULT(EF)
+      IMPLICIT NONE
+
+      CLASS(meshVol0D), INTENT(in):: self
+      REAL(8), INTENT(in):: xi(1:3)
+      REAL(8):: EF(1:3)
+
+      EF = 0.D0
+
+    END FUNCTION gatherEF0D
+
+    PURE FUNCTION elemK0D(self) RESULT(localK)
+      IMPLICIT NONE
+
+      CLASS(meshVol0D), INTENT(in):: self
+      REAL(8), ALLOCATABLE:: localK(:,:)
+
+      ALLOCATE(localK(1:1, 1:1))
+      localK = 0.D0
+
+    END FUNCTION elemK0D
+
+    PURE FUNCTION elemF0D(self, source) RESULT(localF)
+      IMPLICIT NONE
+
+      CLASS(meshVol0D), INTENT(in):: self
+      REAL(8), INTENT(in):: source(1:)
+      REAL(8), ALLOCATABLE:: localF(:)
+
+      ALLOCATE(localF(1:1))
+      localF = 0.D0
+
+    END FUNCTION elemF0D
+
+    PURE FUNCTION phy2log0D(self,r) RESULT(xN) 
+      IMPLICIT NONE
+
+      CLASS(meshVol0D), INTENT(in):: self
+      REAL(8), INTENT(in):: r(1:3)
+      REAL(8):: xN(1:3)
+
+      xN = 0.D0
+
+    END FUNCTION phy2log0D
+
+    PURE FUNCTION inside0D(xi) RESULT(ins)
+      IMPLICIT NONE
+
+      REAL(8), INTENT(in):: xi(1:3)
+      LOGICAL:: ins
+
+      ins = .TRUE.
+
+    END FUNCTION inside0D
+
+    SUBROUTINE nextElement0D(self, xi, nextElement)
+      IMPLICIT NONE
+
+      CLASS(meshVol0D), INTENT(in):: self
+      REAL(8), INTENT(in):: xi(1:3)
+      CLASS(meshElement), POINTER, INTENT(out):: nextElement
+
+      nextElement => NULL()
+
+    END SUBROUTINE nextElement0D
+
+END MODULE moduleMesh0D