*Filtre actif trinome/trinome tel que gain en HF = 1
      program statvar2
      implicit none
      real f0, f1, q0, q1, fc, w0, w1, cinteg, x0, x1
      real rgen, r3, r1, r2, r5, rp2, r123, r789
      real r8, r7, r9, r10, rp4, qdep, finf, fsup
      real k, k1, k0, pi, raptfreq, rinteg, gzero
      real gplus0, gplus1, mod100k1, mod100k2

      integer nbptdec
      character*2 suffixe
      character*72 shiftleft
      character*20 bidon
      character*21 nomcir

      common raptfreq, k, gzero
      data pi/3.141592/
      data cinteg/2.2e-9/
      rgen = 2.7e3

      print *, '(Si < 0 c''est gain global BF)'
      call readelec('Gain global HF', k)
      call readelec('Frequence zero', f1)
      write (bidon, *) f1
      bidon = shiftleft(bidon)
      suffixe(1:1) = bidon(1:1)

      call readelec('Q zero', q1)
      call readelec('Frequence pole', f0)
      write (bidon, *) f0
      bidon = shiftleft(bidon)
      suffixe(2:2) = bidon(1:1)

      nomcir = '../spice/sttvar'//suffixe//'.cir'
      call readelec('Q pole', q0)
      if (k.lt.0) then
        k = -f0*f0/(f1*f1*k)
        call printelec('Gain global HF', k)
        gzero = k
      else
        gzero = k*f1*f1/(f0*f0)
        call printelec('Gain global BF', gzero)
      endif

      call printelec('Capa integrateurs', cinteg)
      call printelec('Frequence centrale conseillee', sqrt(f0*f1))
      call readelec('Frequence centrale', fc)
      print *, ' ' 
      rinteg = 1/(2*pi*fc*cinteg)
      w0 = f0/fc
      w1 = f1/fc
      k0 = sqrt(k*(1+w1*w1))
      k1 = sqrt(k/(1+w1*w1))
      gplus0 = 1 + k0 + w0*w0        !    gains from "+" inputs. fff
      gplus1 = 1 + k1 + k1*w1*w1
      x0 = w0/(q0*gplus0)
      x1 = k1*w1/(q1*gplus1)
      qdep = w0/gplus0

*      r1 = rgen
*      r2 = rgen*k0/(w0*w0)
*      r3 = rgen*k0
      r123 = rgen/min(1., k0, k0/(w0*w0)) ! garantit que aucune < rgen. 
      r1 = r123
      r2 = r123*k0/(w0*w0)
      r3 = r123*k0

      r5 = rgen
      rp2 = rgen*x0/(1-x0)

      r789 = rgen/min(1., k1, 1/(w1*w1)) ! garantit que aucune < rgen. 
      r7 = r789/(w1*w1)
      r8 = r789
      r9 = r789*k1

      r10 = rgen
      rp4 = rgen*x1/(1-x1)

      call printelec2('Res des integrateurs', rinteg,
     + 'Resistance generique', rgen)
      call printelec2('R1: entree 1er ampli', r1,
     + 'R2: 2e integ vers "-"', r2)
      call printelec2('R3: feedback   ,,', r3,
     + 'RP2: "+" 1er amp/GND', rp2)
      print *, ' ' 
      call printelec2('R8: 1er amp => amp_out', r8,
     + 'R7: 2e integ vers "-" ', r7)
      call printelec2('R9: feedback   ,,', r9,
     + 'RP4: "+" amp_out/GND', rp4)
      print *, ' ' 
      call printelec2 ('k0', k0, 'k1', k1)
      gplus0 = 1 + k0 + w0*w0
      gplus1 = 1 + k1 + k1*w1*w1
      call printelec2('retards :  1er ampli', gplus0,
     +     'amp_out (tau_opamp)', gplus1)

*      call readelec('Zero simple ? ( 0 = aucun )', w1s)
*      if (w1s.ne.0) then
*        xs = w1s/(fc*(2. + w1*w1))
*        call printelec('Autre rapport   ,,   = ', xs)
*      endif

*      call printelec('Passe bas @ f0', 1/q0)
* Limites de frequence pour SPICE  et cherchemax :
      raptfreq = max(f0,f1)/min(f0,f1)
      if (raptfreq.le.10) raptfreq = 10
      finf = min(f0,f1)/raptfreq
      fsup = max(f0,f1)*raptfreq

      call cherchemax(f0, q0, f1, q1, mod100k1)
      call printelec('si RP2 depluggee : Q0', qdep)
      call cherchemax(f0, qdep, f1, q1, mod100k2)


      call ouvrefichier(10, nomcir)
*      open (unit=10, status='unknown', file=nomcir)
      write (10,*) nomcir
      write (10,*) '* f_pole =',f0,' Q0 = ',q0, ' G_HF= ', k
      write (10,*) '* f_zero =',f1,' q1 = ',q1
      write (10,*) '*'
      write (10,*) 'Vin 4 0 ac {', 1/mod100k2, '+',
     + (1/mod100k1-1/mod100k2),'*myparam} ' !  courbe passe par 1 @ 100KHz
      write (10,*) 'r1'//suffixe//' 4 2 ', r1
      write (10,*) 'r2'//suffixe//' 8 2 ', r2
      write (10,*) 'r3'//suffixe//' 2 1 ', r3
      write (10,*) 'r5'//suffixe//' 3 14 ', r5
      write (10,*) 'rp2'//suffixe//' 3 0 {', rp2, '/myparam}'
      write (10,*) 'Est0'//suffixe//' 1 0 3 2 1e6'
      write (10,*) 'Xst1'//suffixe//' 1 14 Intgr'//suffixe
      write (10,*) 'Xst2'//suffixe//' 14 8 Intgr'//suffixe
      write (10,*) 'r7'//suffixe//' 8 6 ', r7
      write (10,*) 'r8'//suffixe//' 1 6 ', r8
      write (10,*) 'r9'//suffixe//' 6 7 ', r9
      write (10,*) 'r10'//suffixe//' 14 5 ', r10
      write (10,*) 'rp4'//suffixe//' 5 0 ', rp4
      write (10,*) 'Est1'//suffixe//' 7 0 5 6 1e6'
      write (10,*) ' '
      write (10,*) '.subckt Intgr'//suffixe//' 10 12'
      write (10,*) 'Rint'//suffixe//' 10 11 ', rinteg
      write (10,*) 'Cint'//suffixe//' 11 12 ', cinteg
*      write (10,*) 'Eint'//suffixe//' 12 0 11 0 -1e6'  ! opamp id‚al
       write (10,*) 'xopamp 11 12 myopamp'
      write (10,*) '.ends'
      write (10,*) ' '
* l'ampli op avec GB = 28 MHz :
      write (10,*) '.subckt myopamp 101 102'
      write (10,*) 'egain 102 0 101 0 -1e6'
      write (10,*) 'rpole 102 103 5.684K'
      write (10,*) 'cpole 103 0 1e-6'
      write (10,*) 'ebuff 104 0 103 0 1'
      write (10,*) '.ends'
      write (10,*) ' '
      nbptdec = int(100*log10(fsup/finf))
      write (10, *) '.param myparam=1'
      write (10, *) '.step param myparam list 1 1e-6'
      write (10, *) '.ac dec 200 ', finf, fsup
      write (10, *) '.print AC v(7)'
      write (10, *) '.probe'
      write (10, *) '.end'

*      close (unit=10)

      print *, 'Fichier ', nomcir, ' pret, avec le suffixe: ', suffixe
      end

* recherche min et max effectifs/valeur a 100 KHz 
      subroutine cherchemax(fp, qp, fz, qz, mod100K) 
      implicit none
      integer ifreq, imax, imin
      real fz, fp, qz, qp, modmax, modmin, fsup, finf, raptfreq
      real fmax, fmin, k, modabs, freq, mod100k 
      complex jay, module
      common raptfreq, k

      data jay/(0,1)/

      mod100k = abs(k*(fz*fz + jay*fz*1e5/qz - 1e10)
     +            /(fp*fp + jay*fp*1e5/qp - 1e10))
      finf = min(fp,fz)/raptfreq
      fsup = max(fp,fz)*raptfreq
      modmax = k*.9
      modmin = k*1.1
      do ifreq = 0, 10000
        freq = finf*raptfreq**(.5 + .0002*float(ifreq))
        module = k*(fz*fz + jay*fz*freq/qz - freq*freq)
     +            /(fp*fp + jay*fp*freq/qp - freq*freq)
        modabs = abs(module)
        if (modabs.gt.modmax) then
          modmax = modabs
          imax = ifreq
          fmax = freq
        endif
        if (modabs.lt.modmin) then
          modmin = modabs
          imin = ifreq
          fmin = freq
        endif
*        if (abs(ifreq-240).le.10)
*        if (mod(ifreq,500).eq.0)
*     +    print *, ifreq, freq, modabs, modmin, modmax
      enddo
      if ((imax.ne.0).and.(imax.ne.10000)) 
     +   call printelec2('Max/G100K', modmax/mod100k, 'at f', fmax)
      if ((imin.ne.0).and.(imin.ne.10000)) then
        call printelec2('Min/G100K', modmin/mod100k, 'at f', fmin)
      endif
      return
      end
      
      character*72 function shiftleft(chaine)

      implicit none
      character*(*) chaine
      character*1 firstchar
      integer longueur
      
      firstchar = chaine(1:1)
      do while (((firstchar.eq.' ').or.(firstchar.eq.char(9))).
     +  and.(longueur(chaine).ge.2))
        chaine = chaine(2:longueur(chaine))
        firstchar = chaine(1:1)
      enddo
      shiftleft = chaine
      return
      end 

      include 'longueur.inc'
      include 'rwelec.inc'      
      include 'ouvrefile.inc'



