Files renamed and makefile make compatible with ifort.

src/modules/moduleCollisions.f90

@@ -0,0 +1,175 @@
+MODULE moduleCollisions
+  USE moduleTable
+
+  TYPE, ABSTRACT:: collisionBinary
+    REAL(8):: rMass !reduced mass
+    TYPE(table1D):: crossSec !cross section of collision
+    CONTAINS
+      PROCEDURE(initBinary_interface),    PASS, DEFERRED:: init
+      PROCEDURE(collideBinary_interface), PASS, DEFERRED:: collide
+
+  END TYPE collisionBinary
+
+  ABSTRACT INTERFACE
+    SUBROUTINE initBinary_interface(self, crossSectionFilename, mass_i, mass_j)
+      IMPORT:: collisionBinary
+      CLASS(collisionBinary), INTENT(inout):: self
+      CHARACTER(:), ALLOCATABLE, INTENT(in):: crossSectionFilename
+      REAL(8), INTENT(in):: mass_i, mass_j
+
+    END SUBROUTINE
+
+    SUBROUTINE collideBinary_interface(self, sigmaVRelMax, sigmaVrelMaxNew, part_i, part_j)
+      USE moduleSpecies
+      IMPORT:: collisionBinary
+
+      CLASS(collisionBinary), INTENT(in):: self
+      REAL(8), INTENT(in):: sigmaVrelMax
+      REAL(8), INTENT(inout):: sigmaVrelMaxNew
+      TYPE(particle), INTENT(inout):: part_i, part_j
+
+    END SUBROUTINE
+
+  END INTERFACE
+
+  !Container for binary collisions
+  TYPE:: collisionCont
+    CLASS(collisionBinary), ALLOCATABLE:: obj
+
+  END TYPE collisionCont
+
+  TYPE, EXTENDS(collisionBinary):: collisionBinaryElastic
+    !Weight distribution for Maxwellian function
+    REAL(8):: w_i = (1.D0+DSQRT(3.D0))/2.D0
+    REAL(8):: w_j = (DSQRT(3.D0)-1.D0)/2.D0
+    CONTAINS
+      PROCEDURE, PASS:: init    => initBinaryElastic
+      PROCEDURE, PASS:: collide => collideBinaryElastic
+
+  END TYPE collisionBinaryElastic
+
+  !Type for interaction matrix
+  TYPE:: interactionsBinary
+    INTEGER:: amount
+    TYPE(collisionCont), ALLOCATABLE:: collisions(:)
+    CONTAINS
+      PROCEDURE, PASS:: init => initInteractionBinary
+
+  END TYPE interactionsBinary
+
+  !Collision 'Matrix'. A symmetric 2D matrix put into a 1D array to save memory
+  TYPE(interactionsBinary), ALLOCATABLE:: interactionMatrix(:)
+  !Folder for collision cross section tables
+  CHARACTER(:), ALLOCATABLE:: pathCollisions
+
+  CONTAINS
+    SUBROUTINE initInteractionMatrix(interactionMatrix)
+      USE moduleSpecies
+      IMPLICIT NONE
+
+      TYPE(interactionsBinary), INTENT(inout), ALLOCATABLE:: interactionMatrix(:)
+      INTEGER:: nInteractions
+
+      nInteractions = (nSpecies*(nSpecies+1))/2
+      ALLOCATE(interactionMatrix(1:nInteractions))
+
+    END SUBROUTINE initInteractionMatrix
+
+    FUNCTION interactionIndex(i,j) RESULT(k)
+
+      INTEGER:: i, j
+      INTEGER:: p
+      INTEGER:: k
+
+      k = i + j
+      p = (k + ABS(i - j))/2
+      k = k + (p*(p-3))/2
+
+    END FUNCTION interactionIndex
+
+    SUBROUTINE initInteractionBinary(self, amount)
+      IMPLICIT NONE
+
+      CLASS(interactionsBinary), INTENT(inout):: self
+      INTEGER, INTENT(in):: amount
+      INTEGER:: k
+
+      self%amount = amount
+
+      ALLOCATE(self%collisions(1:self%amount))
+      DO k= 1, self%amount
+        !TODO: make type dependent
+        ALLOCATE(collisionBinaryElastic:: self%collisions(k)%obj)
+
+      END DO
+
+    END SUBROUTINE initInteractionBinary
+
+    SUBROUTINE initBinaryElastic(self, crossSectionFilename, mass_i, mass_j)
+      USE moduleTable
+      USE moduleRefParam
+      USE moduleConstParam
+      IMPLICIT NONE
+
+      CLASS(collisionBinaryElastic), INTENT(inout):: self
+      CHARACTER(:), ALLOCATABLE, INTENT(in):: crossSectionFilename
+      REAL(8), INTENT(in):: mass_i, mass_j
+
+      !Reads data from file
+      CALL self%crossSec%init(crossSectionFilename)
+
+      !Convert to no-dimensional units
+      CALL self%crossSec%convert(eV2J/(m_ref*v_ref**2), 1.D0/L_ref**2)
+
+      !Calculates reduced mass
+      self%rMass = (mass_i*mass_j)/(mass_i+mass_j)
+
+    END SUBROUTINE
+
+    SUBROUTINE collideBinaryElastic(self, sigmaVrelMax, sigmaVrelMaxNew, &
+                                    part_i, part_j)
+      USE moduleConstParam
+      USE moduleSpecies
+      USE moduleTable
+      IMPLICIT NONE
+
+      CLASS(collisionBinaryElastic), INTENT(in):: self
+      REAL(8), INTENT(in):: sigmaVrelMax
+      REAL(8), INTENT(inout):: sigmaVrelMaxNew
+      TYPE(particle), INTENT(inout):: part_i, part_j
+      REAL(8):: sigmaVrel
+      REAL(8):: vRel !relative velocity
+      REAL(8):: eRel !relative energy
+      REAL(8):: vp_i, vp_j, v_i, v_j !post and pre-collision velocities
+      REAL(8):: v_ij !sum of velocities modules
+      REAL(8):: alpha !random angle of scattering
+      REAL(8):: rnd
+
+      !eRel (in units of [m][L]^2[s]^-2
+      vRel = SUM(DABS(part_i%v-part_j%v)) !TODO make function of norm1
+      eRel = self%rMass*vRel**2
+      sigmaVrel = self%crossSec%get(eRel)*vRel
+      sigmaVrelMaxNew = sigmaVrelMaxNew + sigmaVrel
+      CALL RANDOM_NUMBER(rnd)
+      IF (sigmaVrelMaxNew/sigmaVrelMax > rnd) THEN
+        !Applies the collision
+        v_i = NORM2(part_i%v)
+        v_j = NORM2(part_j%v)
+        v_ij = v_i+v_j
+        vp_j = v_ij*self%w_i
+        vp_i = v_ij*self%w_j
+        CALL RANDOM_NUMBER(rnd)
+        alpha = PI*rnd
+        part_i%v(1) = v_i*DCOS(alpha)
+        part_i%v(2) = v_i*DSIN(alpha)
+        CALL RANDOM_NUMBER(rnd)
+        alpha = PI*rnd
+        part_j%v(1) = v_j*DCOS(alpha)
+        part_j%v(2) = v_j*DSIN(alpha)
+
+      END IF
+
+
+    END SUBROUTINE
+
+END MODULE moduleCollisions