subroutine symbond(nbdata)
!
!-----------------------------------------------------------------
! Generation des symetriques des donnees
! en sortie : nbdata = nb de donnees generees par symetrie a partir
! de bond0
!
! en entree (lu sur ifilr) : bond0
!-----------------------------------------------------------------
!
Use lewis_module
use decode_multip_data
implicit real*8 (a-h,o-x,z),logical*1(y)
character(200) :: bond0
yw=.false.
yw=(yw.or.nprint==5).and..not.nprint==-5

rewind ifilr
rewind ifilw

do
   read(ifilr,'(2a)',end=2) bond0
   call fai_suppdata(bond0,suppdata)
   if(yw)print*,'symbond bond0 lu sur ifilr ',trim(bond0)
   if(yw)print*,'symbond suppdata lu sur ifilr ',trim(suppdata)
         !if(bond0(1:2)=='CP') exit
   call fai_Liaison_a_2_Atomes(bond0)
   if(yw)print*,'symbond bond0 apres fai_Liaison_a_2_Atomes ' &
   ,trim(bond0)
enddo
2    continue

ifilr=ifilrw-ifilr
ifilw=ifilrw-ifilw

rewind ifilr
rewind ifilw

nbdata=0
do
   read(ifilr,'(2a)',end=1) bond0
   if(yw)print*,'2. symbond bond0 lu sur ifilr ',trim(bond0)
   call fai_suppdata(bond0,suppdata)
   if(yw)print*,'symbond lu sur ifilr avant symbond1 ',trim(bond0)
   call symbond1(bond0,nbdata)
   if(yw)print*,'apres symbond1 ',trim(bond0),nbdata
enddo
1    continue

ifilr=ifilrw-ifilr
ifilw=ifilrw-ifilw
rewind ifilr
rewind ifilw

end


!*******************************************************************
 subroutine fai_Liaison_a_2_Atomes(bond)
!
!------------------------------------------------
! en entree : bond=ligne de donnees
! si bond = "B chaine_de_plus_de_2_atomes"
! transforme la chaine en une suite de donnees
! "B chaine_de_2_atomes"
! Toutes les donnees en entree sont ecrites sur la file 21
! qui sera la file de donnees pour la suite du programme
!--------------------------------------------------
!
use lewis_module
Use mod_script
use decode_multip_data
implicit real*8 (a-h,o-x,z),logical*1(y)
character(*) bond
dimension l(100)
yw=.false.
yw=(yw.or.nprint==5).and..not.nprint==-5
if(yw)print*,'entree fai_Liaison_a_2_Atomes'
if(bond(1:1)=='B') then
   n=0
   do k=1,len_trim(bond)
      if(bond(k:k)=='-'.or.bond(k:k)=='='.or.bond(k:k)=='~' &
      .or.bond(k:k)=='^') then
         n=n+1
         l(n)=k
      endif
   enddo
   l(n+1)=len_trim(bond)+1
         !print*,'n',nl
         !print*,'l',l
   write(ifilw,'(a,1x,a)') bond(1:l(2)-1),';'//trim(suppdata)
   if(yw)write(6,'(a)') bond(1:l(2)-1)
   do k=2,n
      write(ifilw,'(a,1x,a)') 'B '//bond(l(k-1)+1:l(k+1)-1) &
      ,';'//trim(suppdata)
      if(yw)write(6,'(a)') 'B '//bond(l(k-1)+1:l(k+1)-1)
   enddo
else
   write(ifilw,'(a,1x,a)') trim(bond),';'//trim(suppdata)
   if(yw)write(6,'(2a)') 'fai_Liaison_a_2_Atomes ',trim(bond)
endif
if(yw)print*,'sortie fai_Liaison_a_2_Atomes'
end
!*******************************************************************
 subroutine symbond1(bond,nbdata)
Use lewis_module
use decode_multip_data
implicit real*8 (a-h,o-x,z),logical*1(y)
character(200) :: bond,bond2,bond3,bond4
character(6) :: atomdat(20),atomdatloc
dimension limite(20),iat(20),multa(20)
integer cherche_at0,cherche_at
yw=.false.
yw=(yw.or.nprint==5).and..not.nprint==-5
if(yw) print *,' '
if(yw) print*,'Entree symbond1 bond=',trim(bond)

if(bond(1:2)=='CP') then
   nbdata=nbdata+1
   return
endif


!
!--------------------------------------------------
! Generation des donnees equivalentes en symetrie
! ex :
! en entree : une donnee "D2 O1 H1 C5"
! en sortie : une liste de nouvelles donnees
! "D2 O1  _1 H1  _1 C5  _1"
! "D2 O1  _2 H1  _2 C5  _2"
! ...
! les donnees sont ecrites sur ifilw (file des nouvelles donnees)
! nbdata est le nb de  nouvelles donnees
!
!--------------------------------------------------
!



!
!-----------------------------------------------------------
! atomes en donnee
!
! on calcule :
! nat = nb d'atomes en donnee (ex "D2 O1 H1 C5" : 3 atomes)
! atomdat(1:nat) : atomes en donnee (dans l'ex :
! atomdat='O1', 'H1', 'C5'
!-----------------------------------------------------------
!
! le nb d'atomes en donnee est egal au nombre de blancs ou de signes de
! liaisons
l=len_trim(bond)
nat=0
do k=1,l
   if(bond(k:k)==' '.or.bond(k:k)=='-'.or.bond(k:k)=='=' &
   .or.bond(k:k)=='~'.or.bond(k:k)=='^') then
      nat=nat+1
      limite(nat)=k
   endif
enddo
      !print*,bond
      !print*,limite
atomdat=' '
multa=0
do k=1,nat-1
   atomdat(k)=bond(limite(k)+1:limite(k+1)-1)
enddo
atomdat(nat)=bond(limite(nat)+1:)




!
!--------------------------------------
! numeros et multiplicite des atomes
!
! on calcule :
! - multa(1:nat) = nb d'atomes equivalents pour chaque
! atome donne
! - iat(1:nat) = numero des atomes en donnee dans la liste courte
! (liste en symetrie)
!--------------------------------------
!
do k=1,nat
   iat(k)=cherche_at0(atomdat(k)(1:4))
   multa(k)=liste_multat2(iat(k))
enddo
if(yw) then
   print*,' '
   print*,'symbond bond en entree :',bond
   do k=1,nat
      print*,'nat',atomdat(k),iat(k)
   enddo
endif




if(bond(1:1)=='B') then
!         if(atomdat(1)==atomdat(2)) then
   if(1==2) then
!
!---------------------------------------------------------------------
!   on a une liaison entre deux atomes de meme nom (liaison de part et
!   d'autre de l'operateur de symetrie)
!   ex : "B AT1-AT1"
!   Remarque : il n'y a pas d'quivalent de symetrie a chercher
!   parmi les autres atomes (le cas d'un carre, ou cube avec 4 ou
!   8 atoems equivalents reste a programmer)
!---------------------------------------------------------------------
!
!   on a atomdat(1)=AT1, atomdat(2)=AT1
      atomdat(1)(5:6)='_'//nums(1)
      atomdat(2)(5:6)='_'//nums(2)
!   on a maintenant atomdat(1)=AT1 _1, atomdat(2)=AT1 _2



      bond2=bond
!   on a bond2= "B AT1-AT1"
      if(yw)print*,bond2
      call repl(bond2,trim(atomdat(1)(1:4)),'####',yrepl)
      if(yw)print*,bond2
      call repl(bond2,trim(atomdat(2)(1:4)),atomdat(2),yrepl)
      if(yw)print*,bond2
      call repl(bond2,'####',atomdat(1),yrepl)
!   on a maintenant bond2= "B AT1 _1-AT1 _2"
      if(yw)print*,bond2
      if(yw) &
      print*,"desymetrisation de atomdat (ajout d'un suffixe)", &
      atomdat(1),atomdat(2),iat(1),iat(2)
      if(yw) &
      print*,'symbond : donnee generee et ecrite sur ifilw :' &
      ,bond2
!   Ecriture sur ifilw, file des nouvelles donnees
      write(ifilw,'(a,1x,a)') trim(bond2),';'//trim(suppdata)
      if(yw)print*,'symbond1 donnee ecrite  ', &
      trim(bond2),';'//trim(suppdata)
      nbdata=nbdata+1
   else




!
!--------------------------------------------------
! On a bond = "B AT1-AT2"
!
! on connait deja :
! - iat(1:nat) = numero des atomes en donnee dans la liste courte
! (liste en symetrie)
!
! pour chaque paire d'atomes de la liste longue AT1  _i et AT2 _j
! on calcule jat1 et jat2, numeros de AT1  _i et AT2 _j dans
! la liste longue (locale)
!
! on garde les donnees telles que
! distanc(jat1,jat2) = distancmin(iat(1),iat(2)
!
! Attention ! iat est dans la liste courte, jat est dans la longue !
!--------------------------------------------------
!
!   Boucle sur les symetriques du 1er atome
      ytest=.false.
      do k=1,multa(1)
         bond2=bond
         atomdat(1)(5:6)='_'//nums(k)
         jat1=cherche_at(atomdat(1))
         if(ytest(jat1)) cycle
         ytest(jat1)=.true.
         call repl(bond2,trim(atomdat(1)(1:4)),atomdat(1),yrepl)
!   a ce niveau, on a bond2=""B AT1 _i-AT2"
!   Boucle sur les symetriques du 2eme atome
         do l=1,multa(2)
            bond3=bond2
            atomdat(2)(5:6)='_'//nums(l)
            if(atomdat(1)==atomdat(2)) cycle
            if(yw) &
            print*, &
            "desymetrisation de atomdat (ajout d'un suffixe)", &
            atomdat(1),atomdat(2),iat(1),iat(2)

! La distance entre iat(1) et iat(2) doit etre le minimum des distances
! familles iat(1) et iat(2)
            jat2=cherche_at(atomdat(2))
            if(yw)print*,'jat',jat1,jat2,atom(jat1),atom(jat2)
            d=distanc(jat1,jat2)
            dmin=distancmin(iat(1),iat(2))
            if(yw)print*,'dmin',d,dmin
            if(abs(d-dmin)>1.d-8) cycle
            ytest(jat2)=.true.

! jat1 et jat2 sont bien voisins
            call repl(bond3(9:),trim(atomdat(2)(1:4)), &
            atomdat(2),yrepl)
!   a ce niveau, on a bond3=""B AT1 _i-AT2_j"
            if(yw) &
            print*,'symbond: donnee generee et ecrite sur ifilw :' &
            ,bond3

! on ecrit la donnee sur ifilw
            write(ifilw,'(a,1x,a)') trim(bond3), &
            ';'//trim(suppdata)
            if(yw)print*,'symbond1 donnee ecrite  ', &
            trim(bond3),';'//trim(suppdata)
            nbdata=nbdata+1
         enddo
      enddo
   endif
else
!
!----------------------------------------------------------------
! Cas d'un coeur, doublet...(bond= "C...", ="D...")
! Il faut autant de boucles que de valeurs non nulles de multat
! (donc autant que d'atomes donnes)
!----------------------------------------------------------------
!
!   On commence par generer les equivalents du 1er atome
!   ex : D2 O1 H1 C5    -->  D2 O1  _1 H1 C5,
!   puis plus tard D2 O1  _2 H1 C5



   if(yw) then
      print*,' '
      print*,'symbond bond en entree :',bond
      do k=1,nat
         print*,'atom,iat,multa   ',atomdat(k),iat(k),multa(k)
      enddo
   endif
         !   Boucle sur les symetriques du 1er atome
   do k=1,multa(1)
      atomdat(1)(5:6)='_'//nums(k) ! nom de l'atome unique
      jat1=cherche_at(atomdat(1))  ! numero de l'atome unique
      if(yw)print*,'atome portant le doublet ',atomdat(1),jat1
            ! On transforme maintenant les atomes suivants,
            ! en ne generant pour chacun que le voisin du 1er atome
            ! boucle sur les autres atomes de la donnee

      do l=2,nat
         atomdatloc=atomdat(l)
               ! on cherche l'atome le plus proche de atomdat(1)
         d0=huge(d)
         do kk=1,multa(l)
            atomdatloc(5:6)='_'//nums(kk)
                  ! on ne cherche pas si l'atome unique a deja ete trouve
                  ! pour un l inferieur
            if(any(atomdatloc==atomdat(2:l-1))) cycle
            jat2=cherche_at(atomdatloc)
            d=distanc(jat1,jat2)
            if(d<d0) then
               d0=d
               atomdat(l)=atomdatloc
            endif
         enddo
         if(yw)print*,'atome proche',l,'   ', atomdat(l),jat2
      enddo
            ! on fait la donnee :
      i=index(bond,' ')
      bond2=bond(1:i)//atomdat(1)
      do l=2,nat
         bond2=trim(bond2)//' '//atomdat(l)
               !bond2=bond2(1:i+6*(l-1))//' '//atomdat(l)
      enddo
            ! ecriture sur la nouvelle liste des donnees (file ifilw)
      if(suppdata==' ') then
         write(ifilw,'(a,1x,a)') trim(bond2)
         if(yw)print*,'symbond1 donnee ecrite  ', &
         trim(bond2)
      else
         write(ifilw,'(a,1x,a)') trim(bond2),';'//trim(suppdata)
         if(yw)print*,'symbond1 donnee ecrite  ', &
         trim(bond2),';'//trim(suppdata)
      endif
      nbdata=nbdata+1
   enddo
endif







!!   Boucle sur les symetriques du 1er atome
!         do k=1,multa(1)
!            ideb=index(bond,' ')+1
!!   ideb pointe sur O1
!            bond2=bond
!            atomdat(1)(5:6)='_'//nums(k)
!            jat1=cherche_at(atomdat(1))
!            if(yw)print*,'1bond2 ',trim(bond2)
!! a ce niveau : bond = "D2 O1 H1 C5"
!            call repl(bond2(ideb:),
!     *      trim(atomdat(1)(1:4)),atomdat(1),yrepl)
!! a ce niveau : bond = "D2 O1  _k H1 C5"
!            if(yw)print*,'2bond2 ',trim(bond2)
!
!
!! On transforme maintenant les atomes suivants,
!! en ne generant pour chacun que le voisin du 1er atome
!!   transformation des atomes suivants
!C            if(bond(1:1)/='C') then
!               if(yw) print*,'nat',nat
!               if(yw)print*,'1multa',multa(1:nat)
!               do l=2,nat
!                  if(l>2.and.atomdat(l)(1:4)==atomdat(l-1)(1:4)) cycle
!
!                  ideb=ideb+7
!!   ideb pointe sur l'atome suivant (H1, puis C5)
!
!C                  if(multa(l)==0) exit
!!   transformation du leme atome donne
!                  if(yw)print*,'ideb0',ideb
!                  do m=1,multa(l)
!                     if(yw)print*,'2multa',multa(l),multa(1),m
!                     !if(multa(l)>multa(1).and.m>1) exit
!                     atomdat(l)(5:6)='_'//nums(m)
!!   atomdat(l)=H1  _m
!                     if(atomdat(l)==atomdat(l-1)) cycle
!                     if(yw)print*,'atomdat(l) ',atomdat(l)
!
!! La distance entre iat(1) et iat(m) doit etre le minimum des distances
!! familles iat(1) et iat(m)
!                     jat2=cherche_at(atomdat(l))
!                     if(yw)print*,'jat2',jat2
!                     d=distanc(jat1,jat2)
!                     dmin=distancmin(iat(1),iat(l))
!                     if(yw)print*,'d,dmin',d,dmin
!                     if(abs(d-dmin)>1.d-8) cycle
!! les deux atomes (liste longue) atomdat(1) et atomdat(l) sont
!! bien voisins
!                     if(yw)print*,'Bond avant transf du ',l,'eme atome '
!     *               ,trim(bond2)
!                     if(yw)print*,'atomdat ',atomdat(l)
!                     if(yw)print*,'bond2 ',trim(bond2(ideb:))
!                     call repl(bond2(ideb:),trim(atomdat(l)(1:4)),
!     *               atomdat(l),yrepl)
!                     !ideb=ideb+7
!! a ce niveau : bond2 = "D2 O1  _k H1  _l C5"
!! puis pour le l suivant (l') bond2 = "D2 O1  _k H1  _l C5  l'"
!                     if(yw)print*,'bond apres transf du ',l,'eme atome '
!     *               ,trim(bond2)
!                     if(yw)print*,'ideb',ideb
!                     if(yw)print*,'------------------------------'
!                  enddo
!               enddo
!C            endif
!            if(yw) print*,'symbond bond2 ',bond2
!
! ecriture sur la nouvelle liste des donnees (file ifilw)
!            if(suppdata==' ') then
!               write(ifilw,'(a,1x,a)') trim(bond2)
!               if(yw)print*,'symbond1 donnee ecrite  ',
!     *         trim(bond2)
!            else
!               write(ifilw,'(a,1x,a)') trim(bond2),';'//trim(suppdata)
!               if(yw)print*,'symbond1 donnee ecrite  ',
!     *         trim(bond2),';'//trim(suppdata)
!            endif
!            nbdata=nbdata+1
!         enddo
!      endif
if(nbdata==0) stop'nbdata==0 dans symbond'
      !rewind ifilw
if(yw) print *,' '
if(yw) print*,'Sortie symbond1'
if(yw) print *,' '
return
end
