anchor.diff:        it = it + 1
    
   !call Print_Glob_Vect(r,Msh,'global r===')
  +!write(stream,*)'present(CoarseMtx_):',present(CoarseMtx_)
         call preconditioner(sol=z,          &
                               A=A,          &
                             rhs=r,          &
  +                            M=Msh,        &
                       A_interf_=A_interf_,  &
                      CoarseMtx_=CoarseMtx_, &
                       Restrict=Restrict,    &
  
positive.code:     sol=0.0_rk
      if (present(CoarseMtx_)) then !{
  
          if (.not.present(Restrict)) call DOUG_abort("Restriction matrix needs to be passed along with the coarse matrix!")
          
      if (present(cdat)) then
  
  !do i=1,MG%nlf
  !   if (MG%inner_interf_fmask(i)/=0) & 
  !   write(stream,*) MG%lg_fmap(i), rhs(i)
  !enddo
  
  
          ! Not the first iteration, so send the coarse vector here
          if (.not.(present(refactor_).and.refactor_)) then
           call SpMtx_Ax(clrhs,Restrict,rhs,dozero=.true.) ! restrict <RA>
  !         call Vect_print(rhs,"RHS")
  
           ! And send
           call AllSendCoarseVector(clrhs,cdat%nprocs,cdat%cdisps,cdat%send, &
                                    useprev=.true.)
          else ! First iteration - send matrix
           call AllSendCoarseMtx(cdat%LAC,CoarseMtx_,cdat%lg_cfmap,&
                                  cdat%ngfc,cdat%nprocs,cdat%send)
           allocate(ctmp(cdat%ngfc))
  
          endif
        endif
  
        if (sctls%input_type==DCTL_INPUT_TYPE_ELEMENTAL) then
            call sparse_multisolve(sol=sol,A=a,rhs=rhs, &
                          A_interf_=A_interf_, &
                          refactor=refactor_) !fine solves 
        else
            call sparse_multisolve(sol=sol,A=a,rhs=rhs, &
                          A_interf_=A_interf_,AC=CoarseMtx_, &
                          refactor=refactor_,Restrict=Restrict) !fine solves 
        endif 
  
        if (sctls%levels>1) then
  
negative.code:     real(kind=rk),dimension(:),pointer :: sol
      type(SpMtx)                        :: A
      real(kind=rk),dimension(:),pointer :: rhs
      type(Mesh),intent(in)              :: M ! Mesh
      real(kind=rk),dimension(:),pointer :: res ! -- residual vector, allocated
                                                ! here for multiplicative Schwarz
      type(SpMtx),optional               :: A_interf_  ! matr@interf.
      type(SpMtx),optional               :: CoarseMtx_ ! Coarse matrix
      type(SpMtx),optional               :: Restrict ! Restriction matrix
      logical,intent(inout),optional :: refactor_
      type(CoarseData),intent(inout),optional :: cdat
      ! ----- local: ------
      real(kind=rk),dimension(:),pointer,save :: csol,crhs,tmpsol,tmpsol2,clrhs,ctmp
  