D:/demona/2.0/manual/doc/2-31set/processor/run/RunMS.f90

Go to the documentation of this file.

subroutine RunMS

use global

use DFPORT

use mf

implicit none

integer i,j,msIter

integer,pointer :: IM(:,:,:,:)

integer,pointer :: nx,ny

integer nxStart,nxEnd

integer nyStart,nyEnd

integer MSIndexes(xPartition*yPartition,4)
integer MSBcs(xPartition*yPartition,4)

integer myDomainList(xPartition*yPartition)

integer index

integer xDomSize,yDomSize

integer,pointer :: minI, minJ, maxI, maxJ

integer dummyX,dummyY

real(8), allocatable :: myRandom(:)

!< boundary layer might be backup and new bc's can be given so neumann and robin is tried.


print*,'MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM'
print*,'MULTIPLICATIVE SCHWARZ STARTS'
print*,' '

print*,'for the time being assume 1 domain'
print*,'caller of modelsolver should be such that domains are called 1 by 1'

print*,'ghost cell idea is skipped!!!'
print*,'minI and the rest should be used, maybe transforming them from min:max to 1:n'


IM=>myModel%physics(currentPhysics)%domain(currentDomain)%dofMatrix

nx=>myModel%physics(currentPhysics)%domain(currentDomain)%nx
ny=>myModel%physics(currentPhysics)%domain(currentDomain)%ny

minI=>myModel%physics(currentPhysics)%domain(currentDomain)%minI
minJ=>myModel%physics(currentPhysics)%domain(currentDomain)%minJ
maxI=>myModel%physics(currentPhysics)%domain(currentDomain)%maxI
maxJ=>myModel%physics(currentPhysics)%domain(currentDomain)%maxJ


numberOfMSDomains=xPartition*yPartition


MSIndexes=0
MSBcs=1


xDomSize=(nx-1)/xPartition
yDomSize=(ny-1)/yPartition


!< first create the nonoverlapping case
dummyY=1

do j=1,yPartition


        dummyX=1

        do i=1,xPartition

                index=(j-1)*xPartition+i

                MSIndexes(index,1)=dummyX
                MSIndexes(index,2)=MSIndexes(index,1)+xDomSize

                dummyX=dummyX+xDomSize

                MSIndexes(index,3)=dummyY
                MSIndexes(index,4)=MSIndexes(index,3)+yDomSize

        end do

        dummyY=dummyY+yDomSize

end do



if (msArtificialBC.eqv.on) then

        do i=1,numberOfMSDomains

                !left
                MSBcs(i,1)=7 !7 ! should be addBc+1
                !right
                MSBcs(i,2)=8 !8 ! should be addBc+2 ...
                !bottom
                MSBcs(i,3)=9 !9
                !top
                MSBcs(i,4)=10 !10

        end do

end if





!< add overlap check for out of domain indexes and shrink if necessary

do i=1,numberOfMSDomains

        MSIndexes(i,1)=MSIndexes(i,1)-overlap

        if (MSIndexes(i,1).lt.minI) then
                
                MSIndexes(i,1)=minI
                
                MSBCs(i,1)=0 !< means keep the original bc here.

        
        end if
        
        MSIndexes(i,2)=MSIndexes(i,2)+overlap

        if (MSIndexes(i,2).gt.maxI) then
                
                MSIndexes(i,2)=maxI
                
                MSBCs(i,2)=0 !< means keep the original bc here.

        end if
        
        MSIndexes(i,3)=MSIndexes(i,3)-overlap

        if (MSIndexes(i,3).lt.minJ) then
        
                MSIndexes(i,3)=minJ

                MSBCs(i,3)=0 !< means keep the original bc here.

        end if
        
        MSIndexes(i,4)=MSIndexes(i,4)+overlap

        if (MSIndexes(i,4).gt.maxJ) then
        
                MSIndexes(i,4)=maxJ

                MSBCs(i,4)=0 !< means keep the original bc here.

        end if
        

end do


!< determines how the subdomains are visited
!< default is in this order.
do i=1,numberOfMSDomains

        myDomainList(i)=i
        

end do


dummyX=1

do i=numberOfMSDomains,1,-1

        myDomainList(i)=dummyX

        dummyX=dummyX+1
        

end do




msArtificialAlpha(1)=1.d0
msArtificialAlpha(2)=1.d0

!print*,MSIndexes(181,:)
!stop


do msIter=1,maxMSIter

        print*,'-------------------------------------------------------'
        print*,'ms iter=',msIter
        print*,'-------------------------------------------------------'
        if (msRandom.eqv.on) print*,'random domain list'
        if (msRandom.eqv.on) print*,'-------------------------------------------------------'

        ! add here an option for random list option
        ! random order at each msIter, might converge to global rather than local solution.

        
        if (msRandom.eqv.on) then

                allocate(myRandom(numberOfMSDomains))

                call random_seed()
                CALL RANDOM_NUMBER(myRandom)

                call qsortd(floor(myRandom*numberOfMSDomains),myDomainList,numberOfMSDomains)

                deallocate(myRandom)

        end if




        ! for different bc's like neumann or robin,
        ! do the changes here as IM modified. just use backup do keep the original
        ! this might not be necessary if global and local sets are defined.
        ! but the real bc domains should not be changed. so only artificial bc's should be modified
        ! find a way to do that and you are done with MS - or even AS
        
        ! it might be a better idea to use robin as a general bc and use bcAlpha do switch between them
        ! or to use an average of both. in that case, we need to change artificial bc's always.






        do i=1,numberOfMSDomains

                
                !       print*,'-------------------------------------------------'
                        print*,'domain=',i,'/',numberOfMSDomains,' MS iter=',msIter,'/',maxMsIter
                !       print*,'domain=',i,myDomainList(i),'/',numberOfMSDomains,' MS iter=',msIter,'/',maxMsIter
                !       print*,'-------------------------------------------------'


                index=myDomainList(i)


                nxStart=MSIndexes(index,1)
                nxEnd=MSIndexes(index,2)
                nyStart=MSIndexes(index,3)
                nyEnd=MSIndexes(index,4)

                !modify flag layer
                
                IM(:,:,:,flag)=0
                IM(nxStart:nxEnd,nyStart:nyEnd,:,flag)=1


                if (msArtificialBC.eqv.on) then







                end if



                call currentset


                !if (i.eq.21) test=1


                gsSolver=on

                call RunNewton

                !might use here picard then newton as well
                ! even runhybrid can be tried. try for high re flows
                ! add convergence criteria

                call postProcessor

                !pause


        end do

        
        !if (mod(msIter,1).eq.0) then
        
                call postProcessor

                !pause

        !end if


        
end do



print*,' '
print*,'MULTIPLICATIVE SCHWARZ ENDS'
print*,'MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM'






end subroutine RunMS

---