         (*============ считывание характеристики =============*)
Procedure ComDataType.ReadKom(fl      :namestr;   (* имя файла характеристики *)
                              tipx:byte;
                              var ierr:byte);
 var
     f     : text;
     i,j   : integer;
BEGIN
  ierr:=0;
  {$I-}
  if tipx=1 then
    Assign(f,Layout.SpecialDirName + fl+'.kom');
  if tipx=2 then
    Assign(f,Layout.SpecialDirName + fl+'.tur');
  if tipx=3 then
    Assign(f,Layout.SpecialDirName + fl+'.reg');

    reset(f);{$I+}

  if IOResult<>0 then
   Begin  ierr:=1;exit; end;
   with adHead do
       readln(f,kv,kt,R_C.G_max,R_C.G_min,R_C.P_max,
                           R_C.P_min,R_C.N_max,R_C.N_min);
  for i:=1 to adHead.kv do
  BEGIN
    with adxar[i] do
    begin
     readln(f,nv);
     for j:=1 to adhead.kt do
       read(f,vv.gv[j]);
     readln(f);
     for j:=1 to adhead.kt do
       read(f,vv.pv[j]);
     readln(f);
     for j:=1 to adhead.kt do
       read(f,vv.sv[j]);
     readln(f);
    end{-- with adxar --}
  END;
  close(f);
 name_xar :=UpperCase(fl);
 DeleteSpaces(@name_xar);
 END;
(*==================Методы расчета хар. компрессора=================*)

 procedure Koeff(x1,y1,x2,y2:real;var aa,bb:real);
Begin
 if x1=x2 then x1:=x1+0.000001;
 aa:=(y2-y1)/(x2-x1);
 bb:=((x2-x1)*y1-(y2-y1)*x1)/(x2-x1);
End;
(*----------------- Процедура расчета КПД ------------------------*)
 PROCEDURE ComDataType.Otkpd(nn,gg:real; var kpd:real);
  var i,j,d,c1,c2,n1,n2:integer;
      ch                      : char;
     w,u,cc:boolean;
     l,gob,pob,x,y,A,B:real;
     linnx,linny:array[1..70] of real; (* массивы x и y точек, из которых
                                        состоит искомая n *)
  Begin
       cc:=false;
 (*  нахождение соседних n *)

     for i:=0 to adhead.kv+1 do
     if n[i]=nn then
    (* если заданная n совпадает с веткой *)
       begin l:=0; d:=adhead.kt;
            for j:=adhead.kt downto 1 do
            begin
            (* заполняем linnx и linny реальными точками ветки *)
              linnx[j]:=g[i,j];
              linny[j]:=v[i,j];
            end;
       end;

    for i:=0 to adhead.kv do
      if (n[i]<nn) and (n[i+1]>nn) then
    (* если заданная n лежит между ветками *)
    begin
        n1:=i; n2:=i+1;
        l:=(nn-n[i+1])/(n[i]-n[i+1]);   (* вычисляем число, определяющее
        отношение между n[i] и n[i+1], соответствующее заданному n *)
        u:=false; cc:=true;
    end;
  if cc then  (* если заданное n не является веткой *)
  BEGIN
  (*  точка пересечения n1 и n2 *)
      for i:=1 to adhead.kt-1 do      (*          y-y1    x-x1       *)
       for j:=1 to adhead.kt-1 do     (*   из     ----- = -----  вы- *)
       begin                                (*          y2-y1   x2-x1      *)
       if g[n1,i+1]=g[n1,i] then g[n1,i+1]:=g[n1,i+1]+0.000001;
         A:=(v[n1,i+1]-v[n1,i])/(g[n1,i+1]-g[n1,i]);
       if g[n2,j+1]=g[n2,j] then g[n2,j+1]:=g[n2,j+1]+0.000001;
         B:=(v[n2,j+1]-v[n2,j])/(g[n2,j+1]-g[n2,j]);    (* ражаем x и y    *)
         if A<>B then   (* если прямые не параллельные *)
        begin
         x:=(v[n2,j]-v[n1,i]+A*g[n1,i]-B*g[n2,j])/(A-B);
         y:=((x-g[n1,i])*(v[n1,i+1]-v[n1,i]))/(g[n1,i+1]-g[n1,i])+v[n1,i];
    (* если т. пересечения есть т. пересечения отрезков  *)
        if ((g[n1,i]-g[n1,i+1])*(g[n1,i]-x)>=0) then  (* x - т. пересечения *)
          if ((v[n1,i]-v[n1,i+1])*(v[n1,i]-y)>=0) then
                        begin
                            c1:=i; c2:=j;
                            gob:=x; pob:=y; (* gob,pob - координаты т.
                                             пересечения прямых        *)
                            u:=true;
                        end;
        end;   (* --- прямые не параллельные --- *)
       end;
        if u then  (* т. пересечения существует *)
     begin
        d:=2; i:=1; j:=1; w:=true;
        linnx[1]:=g[n1,1]*l+g[n2,1]*(1-l);
        linny[1]:=v[n1,1]*l+v[n2,1]*(1-l);
       (* заполнение массивов linnx,linny до т. пересечения  *)
         while (i<>c1) or (j<>c2) do
      begin
        if i<c1 then Inc(i) else w:=false;
        if j<c2 then Inc(j) else w:=false;
        if w then begin
            linnx[d]:=g[n1,i]*l+g[n2,j-1]*(1-l);
            linny[d]:=v[n1,i]*l+v[n2,j-1]*(1-l);
            Inc(d);
                   end;
            linnx[d]:=g[n1,i]*l+g[n2,j]*(1-l);
            linny[d]:=v[n1,i]*l+v[n2,j]*(1-l);
            Inc(d);
      end;
        linnx[d]:=gob;  linny[d]:=pob;
        i:=c1+1; j:=c2+1; w:=true;
    (* заполнение массивов linnx,linny после т. пересечения  *)
         while (i<>adhead.kt) or (j<>adhead.kt) do
      begin
        if i<adhead.kt then Inc(i) else w:=false;
        if j<adhead.kt then Inc(j) else w:=false;
        if w then begin
            linnx[d]:=g[n1,i]*l+g[n2,j-1]*(1-l);
            linny[d]:=v[n1,i]*l+v[n2,j-1]*(1-l);
            Inc(d);
                   end;
            linnx[d]:=g[n1,i]*l+g[n2,j]*(1-l);
            linny[d]:=v[n1,i]*l+v[n2,j]*(1-l);
            Inc(d);
      end;
       d:=d-1;
    end
            else    (* т. пересечения  не существует *)

     begin
          d:=1;
        linnx[1]:=g[i,1]*l+g[i+1,1]*(1-l);
        linny[1]:=v[i,1]*l+v[i+1,1]*(1-l);
         for j:=2 to adhead.kt do
      begin
        linnx[d+1]:=g[i,j]*l+g[i+1,j-1]*(1-l);
        linny[d+1]:=v[i,j]*l+v[i+1,j-1]*(1-l);
        linnx[d+2]:=g[i,j]*l+g[i+1,j]*(1-l);
        linny[d+2]:=v[i,j]*l+v[i+1,j]*(1-l);
        d:=d+2;
      end;
      d:=d-2;
     end;

  END;

     (* определение kpd *)
           if linnx[1]<gg then linnx[1]:=gg;
           if linnx[d]>gg then linnx[d]:=gg;
       for i:=1 to d-1 do
                if (linnx[i+1]<=gg) and (linnx[i]>=gg) then
        begin
          if (linnx[i+1]-linnx[i])=0 then kpd:=linny[i+1]
                                     else
          kpd:=((gg-linnx[i])*(linny[i+1]-linny[i])/
                                     (linnx[i+1]-linnx[i]))+linny[i];
        end;
 End;
 PROCEDURE ComDataType.Oblast(x,y:real; var z:byte);
  var i,j,ks,sch:byte;
      ch: char;
      u:boolean;
     ras:array[1..70] of real;
     stor:array[1..70] of real;
     orienx:array[1..70] of real;
     orieny:array[1..70] of real;
     d,sinc,cosA,ugol,pw,pn,gl,gp,
     d2g,d2p,d2xg,d2yp,hel:real;
  Begin
   ks:=2*(adhead.kt+adhead.kv)-4;
   gl:=g[1,1]; gp:=g[adhead.kv,1];
   pw:=p[1,adhead.kt];
   pn:=p[1,1];
   for i:=1 to adhead.kv do
   begin
      if i=1 then
      for j:=1 to adhead.kt-1 do
      begin
         d2g:=sqr(g[i,j+1]-g[i,j]);
         d2p:=sqr(p[i,j+1]-p[i,j]);
         ras[j]:=sqrt(d2g+d2p);
         d2xg:=sqr(x-g[i,j]);
         d2yp:=sqr(y-p[i,j]);
         stor[j]:=sqrt(d2xg+d2yp);
         orienx[j]:=g[i,j]-x;
         orieny[j]:=p[i,j]-y;
      end;
         if i>1 then
      begin
         d2g:=sqr(g[i,adhead.kt]-g[i-1,adhead.kt]);
         d2p:=sqr(p[i,adhead.kt]-p[i-1,adhead.kt]);
         sch:=adhead.kt-2+i;
         ras[sch]:=sqrt(d2g+d2p);
         d2xg:=sqr(x-g[i-1,adhead.kt]);
         d2yp:=sqr(y-p[i-1,adhead.kt]);
         stor[sch]:=sqrt(d2xg+d2yp);
         orienx[sch]:=g[i-1,adhead.kt]-x;
         orieny[sch]:=p[i-1,adhead.kt]-y;

         d2g:=sqr(g[i,1]-g[i-1,1]);
         d2p:=sqr(p[i,1]-p[i-1,1]);
         sch:=2*(adhead.kt+adhead.kv)-2-i;
         ras[sch]:=sqrt(d2g+d2p);
         d2xg:=sqr(x-g[i,1]);
         d2yp:=sqr(y-p[i,1]);
         stor[sch]:=sqrt(d2xg+d2yp);
         orienx[sch]:=g[i,1]-x;
         orieny[sch]:=p[i,1]-y;
       end;
         if i=adhead.kv then
          for j:=1 to adhead.kt-1 do
       begin
        d2g:=sqr(g[i,adhead.kt-j]-g[i,adhead.kt+1-j]);
        d2p:=sqr(p[i,adhead.kt-j]-p[i,adhead.kt+1-j]);
        sch:=adhead.kt+adhead.kv-2+j;
        ras[sch]:=sqrt(d2g+d2p);
        d2xg:=sqr(x-g[i,adhead.kt+1-j]);
        d2yp:=sqr(y-p[i,adhead.kt+1-j]);
        stor[sch]:=sqrt(d2xg+d2yp);
         orienx[sch]:=g[i,adhead.kt+1-j]-x;
         orieny[sch]:=p[i,adhead.kt+1-j]-y;
       end;
  end;
       stor[ks+1]:=stor[1];
       orienx[ks+1]:=orienx[1];
       orieny[ks+1]:=orieny[1];
       ugol:=0;
  u:=false;
  for i:=1 to ks do
  begin
     if (stor[i]*stor[i+1])=0 then u:=true
                              else
       begin
         hel:=2*stor[i]*stor[i+1];
         cosA:=(sqr(stor[i])+sqr(stor[i+1])-sqr(ras[i]))/hel;
         if cosA=0 then  begin
                   if((orienx[i]*orieny[i+1]-orienx[i+1]*orieny[i])<=0) then
                         ugol:=ugol+pi/2    else
                         ugol:=ugol-pi/2;
                         end
                   else
                     begin
                      if cosA<0 then ugol:=ugol+(pi+ArcCos(cosA))
                                 else
                   if((orienx[i]*orieny[i+1]-orienx[i+1]*orieny[i])<=0) then
                         ugol:=ugol+ArcCos(cosA)    else
                         ugol:=ugol-ArcCos(cosA);
                      end;
      end;
  end;
      if u then ugol:=2*pi;
      ugol:=Grad(ugol); z:=0;
      if ((ugol<=360.1) and (ugol>=359.9)) or (ugol=0) then
        z:=0  else z:=1;
 End;

PROCEDURE ComDataType.Xap_n_G(tipx: byte;    {num=1 - KOM; num=2 - TUR}
                              xar_name:namestr;
                              nn,gg:real;
                              var pp,vichkpd,dKy:real;
                              var osh:byte);
  var i,j:integer;
      ch                      : char;
     u:boolean;
     G_gr,P_gr,l,grg,grp,a,b,a1,b1,v_min:real;
     linnx,linny:array[1..70] of real;
     d:byte;
BEGIN
  DeleteSpaces(@Xar_Name);
  If Xar_Name = '' then
    begin
      PutMessage(' Characteristic name is not set  ');
      osh:=1;
      Exit;
    end;
  if UpperCase(xar_name)<>name_xar then
   begin
    ReadKom(xar_name,tipx,osh);
    if osh<>0 then
    begin
     if tipx=1 then
     PutFileNotFoundMessage(Layout.SpecialDirName +
                                    xar_name + '.KOM');
     if tipx=2 then
     PutFileNotFoundMessage(Layout.SpecialDirName +
                                    xar_name + '.TUR');
     if tipx=3 then
     PutFileNotFoundMessage(Layout.SpecialDirName +
                                    xar_name + '.REG');

     exit;
    end;
   end;
  v_min:=2;
     for i:=1 to adhead.kv do
   begin
        with adxar[i] do
    begin
        n[i]:=nv;
     for j:=1 to adhead.kt do
       g[i,j]:=vv.gv[j];
     for j:=1 to adhead.kt do
       p[i,j]:=vv.pv[j];
     for j:=1 to adhead.kt do
          begin
           v[i,j]:=vv.sv[j];
           if v_min>v[i,j] then v_min:=v[i,j];
         end;
    end;
   end;
     osh:=0;
    if (gg<adhead.R_C.G_min) or (gg>adhead.R_C.G_max) then osh:=osh+10;
    if (nn<adhead.R_C.N_min) or (nn>adhead.R_C.N_max) then osh:=osh+20;
  if osh<10 then
  BEGIN  (* не вышли за прямоугольную область *)
      for i:=1 to adhead.kv do
       if n[i]=nn then
         begin l:=0;
            G_gr:=g[i,adhead.kt];
            P_gr:=p[i,adhead.kt];

            for j:=adhead.kt downto 1 do
            begin
              linnx[j]:=g[i,j];
              linny[j]:=p[i,j];
            end;
            for j:=adhead.kt+1 to 2*adhead.kt-1 do
            begin
              linnx[j]:=linnx[j-1];
              linny[j]:=linny[j-1];
            end;
         end;
     for i:=1 to adhead.kv-1 do
      if (n[i]<nn) and (n[i+1]>nn) then
    begin
         G_gr:=((nn-n[i])*(g[i+1,adhead.kt]-g[i,adhead.kt])/
                (n[i+1]-n[i]))+g[i,adhead.kt];

         P_gr:=((nn-n[i])*(p[i+1,adhead.kt]-p[i,adhead.kt])/
                (n[i+1]-n[i]))+p[i,adhead.kt];

        l:=(nn-n[i+1])/(n[i]-n[i+1]);
        d:=1;
        linnx[1]:=g[i,1]*l+g[i+1,1]*(1-l);
        linny[1]:=p[i,1]*l+p[i+1,1]*(1-l);
         for j:=2 to adhead.kt do
      begin
        linnx[d+1]:=g[i,j]*l+g[i+1,j-1]*(1-l);
        linny[d+1]:=p[i,j]*l+p[i+1,j-1]*(1-l);
        linnx[d+2]:=g[i,j]*l+g[i+1,j]*(1-l);
        linny[d+2]:=p[i,j]*l+p[i+1,j]*(1-l);
        d:=d+2;
      end;
    end;
    u:=false;
       for i:=1 to 2*adhead.kt-2 do
         if (linnx[i+1]<=gg) and (linnx[i]>=gg) then
        begin
          if (linnx[i+1]-linnx[i])=0 then pp:=linny[i+1]
                                     else
          pp:=((gg-linnx[i])*(linny[i+1]-linny[i])/
                                     (linnx[i+1]-linnx[i]))+linny[i];
              u:=true;
        end;
         if not u then
         BEGIN  (* G не соответствует n *)
           if gg<linnx[2*adhead.kt-1] then
             begin
        Koeff(linnx[2*adhead.kt-1],linny[2*adhead.kt-1],
          adhead.R_C.G_min-0.05,adhead.R_C.P_max+0.05,a,b);
        Otkpd(nn,linnx[2*adhead.kt-1],vichkpd);
        Koeff(linnx[2*adhead.kt-1],vichkpd,
              adhead.R_C.G_min-0.05,v_min-0.1,a1,b1);
        vichkpd:=a1*gg+b1;
             end;
           if gg>linnx[1] then
             begin
              Koeff(linnx[1],linny[1],adhead.R_C.G_max+0.05,
                    adhead.R_C.P_min-0.05,a,b);
               Otkpd(nn,linnx[1],vichkpd);
               Koeff(linnx[1],vichkpd,adhead.R_C.G_max+0.05,
                     v_min-0.1,a1,b1);
               vichkpd:=a1*gg+b1;
             end;
               pp:=a*gg+b;
         END;{-- G не соответствует n ---}
     if osh=0 then
    Otkpd(nn,gg,vichkpd);
    dKy:=(P_gr/G_gr/pp*gg-1.0)*100;
    if abs(dKy)<0.0001 then dKy:=0.0;

 END;
END;{---- Xap_n_G ----}

 PROCEDURE ComDataType.Xap_G_Pik(tipx: byte;
                                 xar_name:namestr;
                                 x,y:real;
                                 var nnov,vichkpd,dKy:real;
                                 var osh:byte);
  var
      vx,vy,dx,dy,vd,wx,wy,wd,nx,ny,y_sh,l,a1,b1:real;
      tg1,tg2,tg3,tg4,tp1,tp2,tp3,tp4,n1,n2,xx,v_min:real;
      g1,g2,p1,p2:array[0..22] of real;
      osh1,mm,i,j,ss            : byte;
      q:boolean;
      P_gr,G_gr:Real;

procedure poisk;
VAR
l,kk,j  : Byte;
shag_p:real;
procedure tochki;
    begin
    if j>0 then
    begin
         kk:=0;
         g1[i]:=g[i,j];
         g2[i]:=g[i,j-1];
         p1[i]:=p[i,j];
         p2[i]:=p[i,j-1];
       if i>0 then
              begin
                    wx:=g2[i]-g1[i];
                    wy:=p2[i]-p1[i];
                    if wx=0 then begin nx:=-1; ny:=0; end
                            else
                    if wy=0 then begin nx:=0; ny:=-1; end
                            else begin nx:=wy/wx; ny:=-1; end;
                    wd:=nx*dx+ny*dy;
                 if (wd>0) or (i=adhead.kv+1) then
                            begin
                                tg1:=g1[i-1];    tp1:=p1[i-1];
                                tg2:=g2[i-1];    tp2:=p2[i-1];
                                tg3:=g1[i];      tp3:=p1[i];
                                tg4:=g2[i];      tp4:=p2[i];
                                n1:=n[i-1];      n2:=n[i];
                                l:=0;
                             end;
              end;
      end;
   end;
     Begin
           l:=1; i:=0;
           shag_p:=(adhead.R_C.P_max-adhead.R_C.P_min)/
           (adhead.kt-1);
            g[0,1]:=adhead.R_C.G_min;
            p[0,1]:=adhead.R_C.P_min;
            v[0,1]:=v_min;
            g[adhead.kv+1,1]:=adhead.R_C.G_max;
            p[adhead.kv+1,1]:=adhead.R_C.P_min;
            v[adhead.kv+1,1]:=v_min;
                g[0,adhead.kt]:=adhead.R_C.G_min;
                p[0,adhead.kt]:=adhead.R_C.P_max;
                v[0,adhead.kt]:=v_min;
                g[adhead.kv+1,adhead.kt]:=adhead.R_C.G_max;
                p[adhead.kv+1,adhead.kt]:=adhead.R_C.P_max;
                v[adhead.kv+1,adhead.kt]:=v_min;
                  n[0]:=n[1]-0.05;
                  n[adhead.kv+1]:=n[adhead.kv]+0.05;
             for j:=2 to adhead.kt-1 do
            begin g[0,j]:=adhead.R_C.G_min;
                  p[0,j]:=p[0,j-1]+shag_p;
                  v[0,j]:=v_min;
                  g[adhead.kv+1,j]:=adhead.R_C.G_max;
                  p[adhead.kv+1,j]:=p[adhead.kv+1,j-1]+shag_p;
                  v[adhead.kv+1,j]:=v_min;
            end;
              while (i<=adhead.kv+1) and (l=1) do
         begin
               j:=0; kk:=1; g[i,adhead.kt+1]:=adhead.R_C.G_min-0.05;
                            p[i,adhead.kt+1]:=adhead.R_C.P_max+0.05;
                            g[i,0]:=adhead.R_C.G_max+0.05;
                            p[i,0]:=adhead.R_C.P_min-0.05;
               while kk=1 do
            begin
                vx:=g[i,j+1]-g[i,j];
                vy:=p[i,j+1]-p[i,j];
                dx:=x-g[i,j];
                dy:=y-p[i,j];
                vd:=vx*dx+vy*dy;
                  if vd<=0 then tochki;
                  j:=j+1;
                  if j=ss then
                  tochki;
                 end;
               i:=i+1;
          end;
       end;

procedure novn;
 var a1,a2,b1,b2,c1,c2,r1,r2,h1,h2:real;
   begin
       a1:=sqrt(sqr(tg1-tg2)+sqr(tp1-tp2));
       a2:=sqrt(sqr(tg3-tg4)+sqr(tp3-tp4));
       b1:=sqrt(sqr(x-tg1)+sqr(y-tp1));
       b2:=sqrt(sqr(x-tg3)+sqr(y-tp3));
       c1:=sqrt(sqr(x-tg2)+sqr(y-tp2));
       c2:=sqrt(sqr(x-tg4)+sqr(y-tp4));
       r1:=(a1+b1+c1)/2;
       r2:=(a2+b2+c2)/2;
       h1:=(2*sqrt(r1*(r1-a1)*(r1-b1)*(r1-c1)))/a1;
       h2:=(2*sqrt(r2*(r2-a2)*(r2-b2)*(r2-c2)))/a2;
       nnov:=(n1*h2+n2*h1)/(h1+h2);
   end;
 Begin
  DeleteSpaces(@Xar_Name);
  If Xar_Name = '' then
    begin
      PutMessage('  Characteristic name is not set  ');
      osh:=1;
      Exit;
    end;
  if UpperCase(xar_name)<>name_xar then
   begin
    ReadKom(xar_name,tipx,osh);
    if osh<>0 then
    begin
    if tipx=1 then
     PutFileNotFoundMessage(Layout.SpecialDirName +
                                    xar_name + '.KOM');
    if tipx=2 then
     PutFileNotFoundMessage(Layout.SpecialDirName +
                                    xar_name + '.TUR');
     if tipx=3 then
     PutFileNotFoundMessage(Layout.SpecialDirName +
                                    xar_name + '.REG');

     exit;
    end;
   end;
  v_min:=2;
  for i:=1 to adhead.kv do
   begin
        with adxar[i] do
    begin
        n[i]:=nv;
     for j:=1 to adhead.kt do
       g[i,j]:=vv.gv[j];
     for j:=1 to adhead.kt do
       p[i,j]:=vv.pv[j];
     for j:=1 to adhead.kt do
          begin
           v[i,j]:=vv.sv[j];
           if v_min>v[i,j] then v_min:=v[i,j];
         end;
    end;
   end;
 osh:=0;
 if (x<adhead.R_C.G_min) or (x>adhead.R_C.G_max) then osh:=osh+10;
 if (y<adhead.R_C.P_min) or (y>adhead.R_C.P_max) then osh:=osh+11;
  if osh<10 then
  BEGIN  (* не вышли за прямоугольную область *)
  Oblast(x,y,osh1);
     if osh1=0 then ss:=adhead.kt else ss:=adhead.kt+1;
      poisk;
      novn;
  if osh1=0 then
    Otkpd(nnov,x,vichkpd)
          else
          begin
            mm:=adhead.kt div 2;
            y_sh:=(p[1,mm]-p[adhead.kv,mm])*(x-g[adhead.kv,mm])/
            (g[1,mm]-g[adhead.kv,mm])+p[adhead.kv,mm];
        if y_sh<y then
          begin
            for i:=0 to adhead.kv+1 do
             if nnov=n[i] then
               vichkpd:=v[i,adhead.kt];
             for i:=1 to adhead.kv do
               if (n[i]<nnov) and (n[i+1]>nnov) then
             begin
                l:=(nnov-n[i+1])/(n[i]-n[i+1]);
                xx:=g[i,adhead.kt]*l+g[i+1,adhead.kt]*(1-l);
                Otkpd(nnov,xx,vichkpd);
             end;
               Koeff(xx,vichkpd,adhead.R_C.G_min-0.05,v_min-0.1,a1,b1);
               vichkpd:=a1*x+b1;
           end;
            if y_sh>y then
          begin
            for i:=0 to adhead.kv+1 do
             if nnov=n[i] then
                vichkpd:=v[i,1];
             for i:=0 to adhead.kv do
               if (n[i]<nnov) and (n[i+1]>nnov) then
             begin
                l:=(nnov-n[i+1])/(n[i]-n[i+1]);
                xx:=g[i,1]*l+g[i+1,1]*(1-l);
                Otkpd(nnov,xx,vichkpd);
             end;
             Koeff(xx,vichkpd,adhead.R_C.G_max+0.05,v_min-0.1,a1,b1);
               vichkpd:=a1*x+b1;
           end;
      end;
     for i:=1 to adhead.kv do
       if (abs(n[i]-nnov)<0.000001) then
          begin
            G_gr:=g[i,adhead.kt];
            P_gr:=p[i,adhead.kt];
          end;

      for i:=1 to adhead.kv-1 do
       if (n[i]<nnov) and (n[i+1]>nnov) then
          begin
            G_gr:=((nnov-n[i])*(g[i+1,adhead.kt]-g[i,adhead.kt])/
                (n[i+1]-n[i]))+g[i,adhead.kt];
            P_gr:=((nnov-n[i])*(p[i+1,adhead.kt]-p[i,adhead.kt])/
                (n[i+1]-n[i]))+p[i,adhead.kt];
          end;

      dKy:=(P_gr/G_gr/y*x-1.0)*100;
      if abs(dKy)<0.0001 then dKy:=0.0;
   END;
  End;
