Homec4science
Diffusion FENNECS lite (master) Browse

fennecslite/src/particletypes_mod.f90
50c62df45213master

Last Change
Raw File

particletypes_mod.f90
View Options

!------------------------------------------------------------------------------
! EPFL/Swiss Plasma Center
!------------------------------------------------------------------------------
!
! MODULE: particletypes
!
!> @author
!> Guillaume Le Bars EPFL/SPC
!> Patryk Kaminski EPFL/SPC
!> Trach Minh Tran EPFL/SPC
!
! DESCRIPTION:
!> Module responsible for defining the particle types and defining some subroutines to change their size,
!> initialize them or delete them
!------------------------------------------------------------------------------
MODULE particletypes
USE constants
!
IMPLICIT NONE
!> Stores the particles properties for the run.
TYPE particles
INTEGER :: Nploc !< Local number of simulated particles
INTEGER :: Nptot !< Total number of simulated particles
INTEGER :: Newindex !< Stores the higher partindex for the creation of new particles
REAL(kind=db) :: m !< Particle mass
REAL(kind=db) :: q !< Particle charge
REAL(kind=db) :: weight !< Number of particles represented by one macro-particle
REAL(kind=db) :: qmRatio !< Charge over mass ratio
REAL(kind=db) :: nudcol(3) !< Effective momentum drag frequency
REAL(kind=db) :: H0
REAL(kind=db) :: P0
REAL(kind=db) :: temperature
LOGICAL :: Davidson=.false.
LOGICAL :: is_test= .false. !< determines if particle is saved on ittracer
LOGICAL :: is_field= .true. !< determines if particle contributes to Poisson solver
LOGICAL :: calc_moments=.true.
INTEGER, allocatable :: nblost(:) !< number of particles lost in domain boundaries at current timestep
INTEGER :: nbadded !< number of particles added by source since last gather
INTEGER :: nbionisation !< number of particles collisions with neutrals ionisation, elastic)
INTEGER, DIMENSION(:,:), ALLOCATABLE :: Cellindex !< Index in the electric potential grid for the (r,theta,z) direction
INTEGER, DIMENSION(:), ALLOCATABLE :: partindex !< Index of the particle to be able to follow it when it goes from one MPI host to the other
INTEGER :: see_id=-1 !< Index defining whether or not secondary ee are considered
INTEGER :: iiee_id=-1 !< Index defining whether or not ion induced ee are considered
INTEGER :: neuttype_id=1 !< Index defining which type of neutral gas is used to produce the ions
INTEGER :: material_id=1 !< Index defining the type of material for the electrodes (1=304SS)
LOGICAL :: zero_vel=.false. !< Defines wether or not the electrons are gen. with init. vel
REAL(kind=db), DIMENSION(:,:), ALLOCATABLE :: pos !< (radial,azimuthal,longitudinal) coordinates of the particles
REAL(kind=db), DIMENSION(:,:), ALLOCATABLE :: B !< radial, axial Magnetic field
REAL(kind=db), DIMENSION(:), ALLOCATABLE :: collfreq !< Collision frequency with neutrals
REAL(kind=db), DIMENSION(:), ALLOCATABLE :: ionfreq !< Ionisation frequency of neutrals
REAL(kind=db), DIMENSION(:), ALLOCATABLE :: larmorrad !< Larmor radius
REAL(kind=db), DIMENSION(:), ALLOCATABLE :: pot !< Electric potential
REAL(kind=db), DIMENSION(:), ALLOCATABLE :: potxt !< External electric potential
REAL(kind=db), DIMENSION(:,:), ALLOCATABLE :: E !< Radial Axial Electric field
REAL(kind=db), DIMENSION(:), ALLOCATABLE :: Upar !< Velocity component parallel to the magnetic field
REAL(kind=db), DIMENSION(:,:), CONTIGUOUS, POINTER:: U !< normalized (radial, azimuthal, axial) velocity at the current time step
REAL(kind=db), DIMENSION(:,:), CONTIGUOUS, POINTER:: Uold !< normalized (radial, azimuthal, axial) velocity at the previous time step
REAL(kind=db), DIMENSION(:), CONTIGUOUS, POINTER:: Gamma !< Lorentz factor at the current time step
REAL(kind=db), DIMENSION(:), CONTIGUOUS, POINTER:: Gammaold !< Lorentz factor at the previous time step
Real(kind=db), Dimension(:,:),ALLOCATABLE:: geomweight !< geometric weight at the particle position
Real(kind=db), Dimension(:,:,:),ALLOCATABLE:: moments !< stores the moment matrix
INTEGER, DIMENSION(:), ALLOCATABLE :: losthole
INTEGER, DIMENSION(:), ALLOCATABLE :: sendhole
INTEGER:: nbsendandlost(3)=0
LOGICAL:: collected !< Stores if the particles data have been collected to MPI root process during this timestep
INTEGER, DIMENSION(:), ALLOCATABLE:: addedlist
END TYPE particles
!> Structure containing a single particle position and velocity used in MPI communications.
TYPE particle
INTEGER :: partindex = 0
INTEGER :: cellindex(3) = 0
REAL(kind=db) :: Pos(3) = 0
REAL(kind=db) :: U(3) = 0
REAL(kind=db) :: Upar = 0
REAL(kind=db) :: larmorrad = 0
REAL(kind=db) :: geomweight(3) = 0
REAL(kind=db) :: Gamma = 0
REAL(kind=db) :: pot = 0
END TYPE particle
TYPE linked_part
type(particle) p
type(linked_part), POINTER:: next=> NULL()
type(linked_part), POINTER:: prev=> NULL()
END TYPE linked_part
TYPE linked_part_row
INTEGER :: n = 0
type(linked_part), POINTER:: start=>NULL()
type(linked_part), POINTER:: end=>NULL()
END TYPE linked_part_row
CONTAINS
!---------------------------------------------------------------------------
!> @author
!> Guillaume Le Bars EPFL/SPC
!
! DESCRIPTION:
!>
!> @brief Allocate the memory for the particles variable storing the particles quantities.
!
!> @param[inout] p the particles variable needing to be allocated.
!> @param[in] nparts the maximum number of particles that will be stored in this variable
!---------------------------------------------------------------------------
SUBROUTINE creat_parts(p, nparts)
TYPE(particles) :: p
INTEGER, INTENT(in) :: nparts
IF (.NOT. ALLOCATED(p%pos) ) THEN
p%Nploc = nparts
p%Nptot = nparts
ALLOCATE(p%pos(3,nparts))
ALLOCATE(p%B(2,nparts))
ALLOCATE(p%U(3,nparts))
ALLOCATE(p%Upar(nparts))
ALLOCATE(p%larmorrad(nparts))
ALLOCATE(p%Uold(3,nparts))
ALLOCATE(p%Gamma(nparts))
Allocate(p%Cellindex(3,nparts))
ALLOCATE(p%partindex(nparts))
ALLOCATE(p%pot(nparts))
ALLOCATE(p%potxt(nparts))
ALLOCATE(p%E(3,nparts))
ALLOCATE(p%GAMMAold(nparts))
Allocate(p%geomweight(0:2,nparts))
Allocate(p%losthole(nparts))
Allocate(p%sendhole(nparts))
ALLOCATE(p%collfreq(nparts))
ALLOCATE(p%ionfreq(nparts))
if(.not.allocated(p%nblost)) allocate(p%nblost(4))
p%newindex=0
p%nblost=0
p%nbadded=0
p%partindex=-1
p%Uold=0
p%see_id=-1
p%iiee_id=-1
p%neuttype_id=1
p%material_id=1
p%zero_vel=.false.
p%cellindex=0
p%B=0
p%U=0
p%Upar=0
p%larmorrad=0
p%pos=0
p%Gamma=1
p%E=0
p%pot=0
p%potxt=0
p%collfreq=0
p%ionfreq=0
p%gammaold=1
p%collected=.false.
p%Davidson=.false.
p%is_test=.false.
p%is_field=.true.
p%calc_moments=.true.
p%m=me
p%q=-elchar
p%qmRatio=p%q/p%m
p%weight=1.0_db
p%H0=0
p%P0=0
p%temperature=0
p%geomweight=0
p%losthole=0
p%sendhole=0
END IF
END SUBROUTINE creat_parts
!---------------------------------------------------------------------------
!> @author
!> Guillaume Le Bars EPFL/SPC
!
! DESCRIPTION:
!>
!> @brief Copy one particle from the receive buffers to the local simulation variable parts.
!
!> @param [in] part particle parameters to copy from
!> @param [in] partsindex destination particle index in the local parts variable
!---------------------------------------------------------------------------
SUBROUTINE Insertincomingpart(p, part, partsindex)
TYPE(particles), INTENT(INOUT):: p
INTEGER, INTENT(in) :: partsindex
TYPE(particle), INTENT(in) :: part
p%partindex(partsindex) = part%partindex
p%Cellindex(1:3,partsindex) = part%cellindex(1:3)
p%pos(1:3,partsindex) = part%Pos(1:3)
p%U(1:3,partsindex) = part%U(1:3)
p%Upar = part%Upar
p%larmorrad = part%larmorrad
p%geomweight(0:2,partsindex) = part%geomweight(1:3)
p%Gamma(partsindex) = part%Gamma
p%pot(partsindex) = part%pot
!
END SUBROUTINE Insertincomingpart
!---------------------------------------------------------------------------
!> @author
!> Guillaume Le Bars EPFL/SPC
!
! DESCRIPTION:
!>
!> @brief Copy one particle from the local parts variable to the send buffer.
!
!> @param [in] buffer send buffer to copy to
!> @param [in] bufferindex particle index in the send buffer
!> @param [in] partsindex origin particle index in the local parts variable
!---------------------------------------------------------------------------
SUBROUTINE Insertsentpart(p, buffer, bufferindex, partsindex)
TYPE(particles), INTENT(INOUT):: p
INTEGER, INTENT(in) :: bufferindex, partsindex
TYPE(particle), DIMENSION(:), INTENT(inout) :: buffer
buffer(bufferindex)%partindex = p%partindex(partsindex)
buffer(bufferindex)%cellindex(1:3) = p%Cellindex(1:3,partsindex)
buffer(bufferindex)%Pos(1:3) = p%pos(1:3,partsindex)
buffer(bufferindex)%U(1:3) = p%U(1:3,partsindex)
buffer(bufferindex)%Upar = p%Upar(partsindex)
buffer(bufferindex)%larmorrad = p%larmorrad(partsindex)
buffer(bufferindex)%geomweight(1:3) = p%geomweight(0:2,partsindex)
buffer(bufferindex)%Gamma = p%Gamma(partsindex)
buffer(bufferindex)%pot = p%pot(partsindex)
!
END SUBROUTINE Insertsentpart
!---------------------------------------------------------------------------
!> @author
!> Guillaume Le Bars EPFL/SPC
!
! DESCRIPTION:
!> @brief Exchange two particles in the parts variable.
!
!> @param [in] index1 index in parts of the first particle to exchange.
!> @param [in] index2 index in parts of the second particle to exchange.
!---------------------------------------------------------------------------
SUBROUTINE exchange_parts(p, index1, index2)
TYPE(particles), INTENT(INOUT):: p
INTEGER, INTENT(IN) :: index1, index2
REAL(kind=db):: pos(3), Upar, U(3), Gamma, geomweight(0:2),pot, larmorrad
INTEGER :: Rindex, Zindex, partindex, cellindex(3)
!! Exchange particle at index1 with particle at index2
! Store part at index1 in temporary value
partindex = p%partindex(index1)
Gamma = p%Gamma(index1)
pot = p%pot(index1)
pos = p%pos(:,index1)
U = p%U(:,index1)
Upar = p%Upar(index1)
larmorrad = p%larmorrad(index1)
cellindex = p%cellindex(:,index1)
geomweight = p%geomweight(:,index1)
! Move part at index2 in part at index 1
p%partindex(index1) = p%partindex(index2)
p%Gamma(index1) = p%Gamma(index2)
p%pot(index1) = p%pot(index2)
p%pos(:,index1) = p%pos(:,index2)
p%U(:,index1) = p%U(:,index2)
p%Upar(index1) = p%Upar(index2)
p%larmorrad(index1) = p%larmorrad(index2)
p%cellindex(:,index1) = p%cellindex(:,index2)
p%geomweight(:,index1) = p%geomweight(:,index2)
! Move temporary values from part(index1) to part(index2)
p%partindex(index2) = partindex
p%Gamma(index2) = Gamma
p%pot(index2) = pot
p%pos(:,index2) = pos
p%U(:,index2) = U
p%Upar(index2) = Upar
p%larmorrad(index2) = larmorrad
p%geomweight(:,index2) = geomweight
p%cellindex(:,index2) = cellindex
END SUBROUTINE exchange_parts
SUBROUTINE change_parts_allocation(p, sizedifference)
implicit none
TYPE(particles), INTENT(INOUT):: p
INTEGER,INTENT(IN) :: sizedifference
CALL change_array_size_int(p%partindex, sizedifference)
CALL change_array_size_int2(p%cellindex, sizedifference)
CALL change_array_size_int(p%losthole, sizedifference)
CALL change_array_size_int(p%sendhole, sizedifference)
CALL change_array_size_dp12(p%E,sizedifference)
CALL change_array_size_dp(p%pot,sizedifference)
CALL change_array_size_dp(p%potxt,sizedifference)
CALL change_array_size_dp(p%collfreq,sizedifference)
CALL change_array_size_dp(p%ionfreq,sizedifference)
CALL change_array_size_dp12(p%pos,sizedifference)
CALL change_array_size_dp12(p%B,sizedifference)
CALL change_array_size_dp012(p%geomweight,sizedifference)
CALL change_array_size_dp(p%Upar,sizedifference)
CALL change_array_size_dp(p%larmorrad,sizedifference)
CALL change_array_size_dp_ptr12(p%U,sizedifference)
CALL change_array_size_dp_ptr12(p%Uold,sizedifference)
CALL change_array_size_dp_ptr(p%Gamma,sizedifference)
CALL change_array_size_dp_ptr(p%Gammaold,sizedifference)
p%Nploc=MIN(p%Nploc,size(p%pos,2))
END SUBROUTINE change_parts_allocation
SUBROUTINE change_array_size_dp(arr, sizedifference)
implicit none
REAL(kind=db), ALLOCATABLE, INTENT(INOUT):: arr(:)
INTEGER, INTENT(IN):: sizedifference
REAL(kind=db), ALLOCATABLE:: temp(:)
INTEGER:: current_size, new_size, i
if(allocated(arr)) THEN
current_size=size(arr)
new_size=current_size+sizedifference
ALLOCATE(temp(new_size))
Do i=1,min(current_size,new_size)
temp(i)=arr(i)
end do
DEALLOCATE(arr)
CALL move_alloc(temp, arr)
END IF
END SUBROUTINE change_array_size_dp
SUBROUTINE change_array_size_dp2(arr, sizedifference)
implicit none
REAL(kind=db), ALLOCATABLE, INTENT(INOUT):: arr(:,:)
INTEGER, INTENT(IN):: sizedifference
REAL(kind=db), ALLOCATABLE:: temp(:,:)
INTEGER:: current_size, new_size, i
if(allocated(arr)) THEN
current_size=size(arr,1)
new_size=current_size+sizedifference
ALLOCATE(temp(new_size,0:size(arr,2)-1))
Do i=1,min(current_size,new_size)
temp(i,:)=arr(i,:)
end do
DEALLOCATE(arr)
CALL move_alloc(temp, arr)
END IF
END SUBROUTINE change_array_size_dp2
SUBROUTINE change_array_size_dp12(arr, sizedifference)
implicit none
REAL(kind=db), ALLOCATABLE, INTENT(INOUT):: arr(:,:)
INTEGER, INTENT(IN):: sizedifference
REAL(kind=db), ALLOCATABLE:: temp(:,:)
INTEGER:: current_size, new_size, i
if(allocated(arr)) THEN
current_size=size(arr,2)
new_size=current_size+sizedifference
ALLOCATE(temp(size(arr,1),new_size))
Do i=1,min(current_size,new_size)
temp(:,i)=arr(:,i)
end do
DEALLOCATE(arr)
CALL move_alloc(temp, arr)
END IF
END SUBROUTINE change_array_size_dp12
SUBROUTINE change_array_size_dp012(arr, sizedifference)
implicit none
REAL(kind=db), ALLOCATABLE, INTENT(INOUT):: arr(:,:)
INTEGER, INTENT(IN):: sizedifference
REAL(kind=db), ALLOCATABLE:: temp(:,:)
INTEGER:: current_size, new_size, i
if(allocated(arr)) THEN
current_size=size(arr,2)
new_size=current_size+sizedifference
ALLOCATE(temp(0:size(arr,1)-1,new_size))
Do i=1,min(current_size,new_size)
temp(:,i)=arr(:,i)
end do
DEALLOCATE(arr)
CALL move_alloc(temp, arr)
END IF
END SUBROUTINE change_array_size_dp012
SUBROUTINE change_array_size_dp_ptr12(arr, sizedifference)
implicit none
REAL(kind=db), POINTER, INTENT(INOUT):: arr(:,:)
INTEGER, INTENT(IN):: sizedifference
REAL(kind=db), POINTER:: temp(:,:)
INTEGER:: current_size, new_size, i
if(associated(arr)) THEN
current_size=size(arr,2)
new_size=current_size+sizedifference
ALLOCATE(temp(size(arr,1),new_size))
!WRITE(*,*)"increase pointer size: ", current_size, new_size, "temp: ", size(temp,1),size(temp,2), "arr: ", size(arr,1),size(arr,2)
Do i=1,min(current_size,new_size)
temp(:,i)=arr(:,i)
end do
!WRITE(*,*)"copy done"
DEALLOCATE(arr)
arr=> temp
END IF
END SUBROUTINE change_array_size_dp_ptr12
SUBROUTINE change_array_size_dp_ptr(arr, sizedifference)
implicit none
REAL(kind=db), POINTER, INTENT(INOUT):: arr(:)
INTEGER, INTENT(IN):: sizedifference
REAL(kind=db), CONTIGUOUS, POINTER:: temp(:)
INTEGER:: current_size, new_size,i
if(associated(arr)) THEN
current_size=size(arr)
new_size=current_size+sizedifference
ALLOCATE(temp(new_size))
Do i=1,min(current_size,new_size)
temp(i)=arr(i)
end do
!temp(1:min(current_size,new_size))=arr(1:min(current_size,new_size))
DEALLOCATE(arr)
arr=> temp
END IF
END SUBROUTINE change_array_size_dp_ptr
SUBROUTINE change_array_size_int(arr, sizedifference)
implicit none
INTEGER, ALLOCATABLE, INTENT(INOUT):: arr(:)
INTEGER, INTENT(IN):: sizedifference
INTEGER, ALLOCATABLE:: temp(:)
INTEGER:: current_size, new_size,i
if(allocated(arr)) THEN
current_size=size(arr)
new_size=current_size+sizedifference
ALLOCATE(temp(new_size))
Do i=1,min(current_size,new_size)
temp(i)=arr(i)
end do
DEALLOCATE(arr)
CALL move_alloc(temp,arr)
END IF
END SUBROUTINE change_array_size_int
SUBROUTINE change_array_size_int2(arr, sizedifference)
implicit none
INTEGER, ALLOCATABLE, INTENT(INOUT):: arr(:,:)
INTEGER, INTENT(IN):: sizedifference
INTEGER, ALLOCATABLE:: temp(:,:)
INTEGER:: current_size, new_size,i
if(allocated(arr)) THEN
current_size=size(arr,2)
new_size=current_size+sizedifference
ALLOCATE(temp(size(arr,1),new_size))
Do i=1,min(current_size,new_size)
temp(:,i)=arr(:,i)
end do
DEALLOCATE(arr)
CALL move_alloc(temp,arr)
END IF
END SUBROUTINE change_array_size_int2
!---------------------------------------------------------------------------
!> @author
!> Guillaume Le Bars EPFL/SPC
!
! DESCRIPTION:
!>
!> @brief Move particle with index sourceindex to particle with index destindex.
!> !WARNING! This will overwrite particle at destindex.
!
!> @param [in] sourceindex index in parts of the particle to move.
!> @param [in] destindex index in parts of the moved particle destination.
!---------------------------------------------------------------------------
SUBROUTINE move_part(p, sourceindex, destindex)
!! This will destroy particle at destindex
INTEGER, INTENT(IN) :: destindex, sourceindex
TYPE(particles), INTENT(INOUT)::p
IF(sourceindex .eq. destindex) RETURN
IF(sourceindex .le. 0 .or. destindex .le. 0) RETURN
! Move part at sourceindex in part at destindex
Call copy_part(p,sourceindex,destindex,p)
END SUBROUTINE move_part
!---------------------------------------------------------------------------
!> @author
!> Guillaume Le Bars EPFL/SPC
!
! DESCRIPTION:
!>
!> @brief Copy particle with index sourceindex in particles sourcep to particle with index destindex in particles destp.
!> !WARNING! This will overwrite particle at destp(destindex).
!
!> @param [inout] sourcep Structure of source particles.
!> @param [in] sourceindex index in parts of the particle to move.
!> @param [in] destindex index in parts of the moved particle destination.
!> @param [inout] destp Structure of source particles.
!---------------------------------------------------------------------------
SUBROUTINE copy_part(sourcep, sourceindex, destindex, destp)
!! This will destroy particle at destindex
INTEGER, INTENT(IN) :: destindex, sourceindex
TYPE(particles), INTENT(IN)::sourcep
TYPE(particles), INTENT(INOUT)::destp
IF(sourceindex .le. 0 .or. destindex .le. 0) RETURN
IF( destindex .gt. size(destp%pos,2)) RETURN
! Move part at sourceindex in part at destindex
destp%partindex(destindex) = sourcep%partindex(sourceindex)
destp%Gamma(destindex) = sourcep%Gamma(sourceindex)
destp%Gammaold(destindex) = sourcep%Gammaold(sourceindex)
destp%pos(:,destindex) = sourcep%pos(:,sourceindex)
destp%U(:,destindex) = sourcep%U(:,sourceindex)
destp%Upar(destindex) = sourcep%Upar(sourceindex)
destp%larmorrad(destindex) = sourcep%larmorrad(sourceindex)
destp%Uold(:,destindex) = sourcep%Uold(:,sourceindex)
destp%cellindex(:,destindex) = sourcep%cellindex(:,sourceindex)
destp%geomweight(:,destindex) = sourcep%geomweight(:,sourceindex)
destp%pot(destindex) = sourcep%pot(sourceindex)
destp%potxt(destindex) = sourcep%potxt(sourceindex)
destp%collfreq(destindex) = sourcep%collfreq(sourceindex)
destp%ionfreq(destindex) = sourcep%ionfreq(sourceindex)
END SUBROUTINE copy_part
!________________________________________________________________________________
SUBROUTINE destroy_parts(p)
TYPE(particles) :: p
p%Nploc=0
IF(ALLOCATED(p%pos)) DEALLOCATE(p%pos)
IF(ALLOCATED(p%B)) DEALLOCATE(p%B)
IF(ALLOCATED(p%E)) DEALLOCATE(p%E)
IF(ALLOCATED(p%pot)) DEALLOCATE(p%pot)
IF(ALLOCATED(p%collfreq)) DEALLOCATE(p%collfreq)
IF(ALLOCATED(p%ionfreq)) DEALLOCATE(p%ionfreq)
IF(ALLOCATED(p%Upar)) DEALLOCATE(p%Upar)
IF(ALLOCATED(p%larmorrad)) DEALLOCATE(p%larmorrad)
IF(ASSOCIATED(p%U)) DEALLOCATE(p%U)
IF(Associated(p%Uold)) DEALLOCATE(p%Uold)
IF(Associated(p%Gamma)) DEALLOCATE(p%Gamma)
IF(Associated(p%Gammaold)) DEALLOCATE(p%Gammaold)
IF(ALLOCATED(p%cellindex)) DEALLOCATE(p%cellindex)
IF(ALLOCATED(p%losthole)) DEALLOCATE(p%losthole)
IF(ALLOCATED(p%sendhole)) DEALLOCATE(p%sendhole)
IF(ALLOCATED(p%partindex)) DEALLOCATE(p%partindex)
if(allocated(p%geomweight)) Deallocate(p%geomweight)
if(allocated(p%moments)) Deallocate(p%moments)
END SUBROUTINE
!________________________________________________________________________________
SUBROUTINE clean_beam(partslist)
!
INTEGER:: i
type(particles):: partslist(:)
Do i=1,size(partslist,1)
CALL destroy_parts(partslist(i))
END DO
!
END SUBROUTINE clean_beam
!________________________________________________________________________________
SUBROUTINE swappointer( pointer1, pointer2)
REAL(kind=db), DIMENSION(:), POINTER, INTENT(inout):: pointer1, pointer2
REAL(kind=db), DIMENSION(:), POINTER:: temppointer
temppointer=>pointer1
pointer1=>pointer2
pointer2=>temppointer
END SUBROUTINE swappointer
SUBROUTINE swappointer2( pointer1, pointer2)
REAL(kind=db), DIMENSION(:,:), POINTER, INTENT(inout):: pointer1, pointer2
REAL(kind=db), DIMENSION(:,:), POINTER:: temppointer
temppointer=>pointer1
pointer1=>pointer2
pointer2=>temppointer
END SUBROUTINE swappointer2
!---------------------------------------------------------------------------
!> @author
!> Guillaume Le Bars EPFL/SPC
!
! DESCRIPTION:
!>
!> @brief Deallocate recursively a linked_paticle linked list
!
!> @param [in] l_p linked_part particle to be dallocated.
!---------------------------------------------------------------------------
RECURSIVE SUBROUTINE destroy_linked_parts(l_p)
TYPE(linked_part), POINTER :: l_p
IF(associated(l_p%next)) call destroy_linked_parts(l_p%next)
deallocate(l_p)
END subroutine destroy_linked_parts
!--------------------------------------------------------------------------
!> @author
!> S.Guinchard EPFL/SPC
!> Last modified on: 11/15/2022
!
!DESCRIPTION
!> Function giving particle energy for a given partindex
!
!-------------------------------------------------------------------------
REAL(KIND=db) FUNCTION eKin_part(p, partind)
TYPE(particles), INTENT(INOUT):: p
INTEGER :: partind
eKin_part = 0.5* p%m * (p%U(1,partind)**2 + p%U(2,partind)**2 + p%U(3,partind)**2 )
END FUNCTION eKin_part
END MODULE particletypes
c4science · Help