model.cpp

//---------------------------------------------------------------------------
#pragma hdrstop

#include "model.h"
//---------------------------------------------------------------------------
PObjectList ObjectList;    // ñîäåðæèò ñïèñîê âñåõ ñîçäàííûõ îáúåêòîâ
//---------------------------------------------------------------------------
PObjectList::~PObjectList(){
   // íàõîäèì âñå îáúåêòû èç ñïèñêà, ó êîòîðûõ íåò âëàäåëüöà
   vector<PElement*> toDel;
   vector<PElement*>::iterator iter = Obj.begin();
    while( iter != Obj.end() ){
      if((*iter)->Owner == NULL) // óäàëÿåì îáúåêòû áåç âëàäåëüöà, îñòàëüíûå äîëæíû áûòü óäàëåíû âëàäåëüöàìè
         toDel.push_back(*iter);
      iter++;
      }
   // óäàëÿåì âñå îáúåêòû èç ñïèñêà, ó êîòîðûõ íåò âëàäåëüöà
   for(int i=0, n=toDel.size(); i<n; i++)
      delete toDel[i];
   Obj.clear();
}
//---------------------------------------------------------------------------
void PObjectList::Add    (PElement* obj){
   Obj.push_back(obj);
}
//---------------------------------------------------------------------------
bool PObjectList::Delete (PElement* obj){
   vector<PElement*>::iterator iter = Obj.begin();
    while( iter != Obj.end() )
    {
      if( *iter == obj){
        Obj.erase( iter );
        return true;
        }
      else
        ++iter;
    }
   return false;
}
//---------------------------------------------------------------------------
// èìÿ ìîæåò áûòü óêàçàíî ÷åðåç ñ óêàçàíèåì ñåòåé, â êîòîðûå âõîäèò îáúåêò
// íàïðèìåð ÎÝÑ_Öåíðòà.Ñàìàðñêèå_ÐÝÑ.Ò1
// èìÿ îáúåêòà (ñåòè èëè îáîðóäîâàíèÿ) â ñâîåé ïîäñåòè äîëæíî áûòü óíèêàëüíî
PElement* PObjectList::Find (String Name){
   String obj, grid;   // îáúåêò è îáúåêò êîòîðûé â íåãî âõîäèò, íàïðèìåð ÎÝÑ.Ñåòü2.T2
   // çàçäåëÿåì èìÿ è ïîëíîå èìÿ ñåòè
   int point = 0;
   for(int i=Name.Length(); i>0; i--) if(Name[i]=='.') {point=i;break;}
   if(point!=0){
      grid = Name.SubString(1,point-1);
      obj = Name.SubString(point+1, Name.Length()-point);
   }else{
      grid = "";
      obj = Name;
      }
   // íàéäåì ýòîò îáúåêò
   for(int i=0,n=Obj.size(); i<n; i++)
   	if( Obj[i]->Name == obj && Obj[i]->GridName() == grid)
      	return Obj[i];
   return NULL;
   /*/ çàçäåëÿåì èìÿ äî ïåðâîé òî÷êè
   int point=Name.Pos(".");
   if(point!=0){
      grid = Name.SubString(1,point-1);
      obj = Name.SubString(point+1, Name.Length()-point);
   }else{
      grid = "";
      obj = Name;
      }
   // âåðíåì îáúåêò
   if(grid!=""){
   	// èùåì âíóòðè óêàçàííîé ñåòè
      // èìÿ ñåòè ïåðâîãî óðîâíÿ äîëæíî áûòü óíèêàëüíî
      PSubGrid *gr = dynamic_cast<PSubGrid*>(  Find( grid ) );
      if ( gr ) return gr->obj_from_name( obj );
      else      return NULL;
      }
	else
		{
      // óêàçàíî èìÿ áåç ðîäèòåëÿ
      PElement *ret = NULL;
      int cnt=0;
   	for(int i=0,n=Obj.size(); i<n; i++)
      	if( Obj[i]->Name == Name && Obj[i]->Grid == NULL){  // èùåì â ñåòè âåðõíåãî óðîâíÿ
         	ret = Obj[i];
            cnt++;
            }
      if( cnt>1 ){
      	err(0, "PObjectList: èìåòñÿ "+ IntToStr(cnt) +" îáúåêòà ñ èìåíåì: "+Name);
         return NULL;}
      else
      	return ret;
		} */
}
//---------------------------------------------------------------------------
PPin* PObjectList::FindPin(String Name, unsigned pin){
   PElement* obj = Find(Name);
   if(obj){
      for(int i=0, n=obj->Out.Count(); i<n; i++)
         for(int j=0, m=obj->Out[i].Count; j<m; j++)
            if(obj->Out[i][j].Node() == pin)
               return &obj->Out[i][j];
      }
   return NULL;
}
//---------------------------------------------------------------------------
PElement::PElement():null(0),MIN(1e-3),MAX(1e8){
   M = NULL;
   N = NULL;
   R = NULL;
   L = NULL;
   C = NULL;
   Lm = NULL;
   D = NULL;
   E = NULL;
   J = NULL;
   U_C = NULL;
   U_L = NULL;
   U_Lm = NULL;
   U_D = NULL;
   Z = NULL;
   I = NULL;
   f = NULL;
   Owner = NULL;
   Grid = NULL;
   Grounded_Node = 0;   // çàçåìëÿåìûé óçåë
   // ñîõðàíÿåì îáúåêò â ñïèñîê
   ObjectList.Add( this );
   // îïèøåì ïîëÿ êëàññà
   Describe_Fields();
}
//---------------------------------------------------------------------------
PElement::PElement(unsigned NumBranches, unsigned NumNodes, unsigned NumCircuit):null(0),MIN(1e-3),MAX(1e8){
   v = NumBranches;
   u = NumNodes;
   k = NumCircuit;
   E = new PType*[v];
   U_C= new PType*[v];
   U_L= new PType*[v];
   U_Lm= new PType*[v];
   D = new Throttle*[v];  for(unsigned i=0;i<v;i++) D[i] = NULL; // äðîññåëè ñîçäàþòñÿ ïî ìåðå íåîáõîäèìîñòè
   U_D= new PType*[v];
   R = new PType*[v];
   L = new PType*[v];
   C = new PType*[v];
   Z = new PType*[v];
   I = new PType*[v];
   J = new PType*[u];
   f = new PType*[u];
   //Lm = new vector<PType>::iterator*[v]; for(unsigned i=0;i<v;i++)Lm[i] = new vector<PType>::iterator [v];
   Lm = new PType**[v]; for(unsigned i=0;i<v;i++)Lm[i] = new PType*[v];
   M = new Matrix<char>(u, v);
   N = new Matrix<char>(k, v);
   Owner = NULL;
   Grid = NULL;
   Grounded_Node = 0;   // çàçåìëÿåìûé óçåë
   // ñîõðàíÿåì îáúåêò â ñïèñîê
   ObjectList.Add( this );
   // îïèøåì ïîëÿ êëàññà
   Describe_Fields();
}
//---------------------------------------------------------------------------
PElement::PElement(PElement *obj):null(0),MIN(1e-3),MAX(1e8){
   if(obj->M->Cols != obj->N->Cols){err(0,"Ñîçäàíèå îáúåêòà Element ÷èñëî ñòðîê ìàòðèö èíöåäåíöèé íå ðàâíû ìåæäó ñîáîé");}
   v = obj->M->Cols;
   u = obj->M->Rows;
   k = obj->N->Rows;
   _Lm = obj->_Lm;
   E = new PType*[v];
   U_C= new PType*[v];
   U_L= new PType*[v];
   U_Lm= new PType*[v];
   D = new Throttle*[v];   for(unsigned i=0;i<v;i++) D[i] = obj->D[i];  // êîïèðóåì óêàçàòåëè íà äðîññåëè
   U_D= new PType*[v];
   R = new PType*[v];
   L = new PType*[v];
   C = new PType*[v];
   Z = new PType*[v];
   I = new PType*[v];
   J = new PType*[u];
   f = new PType*[u];
   //Lm = new vector<PType>::iterator*[v]; for(unsigned i=0;i<v;i++)Lm[i] = new vector<PType>::iterator [v];
   Lm = new PType**[v]; for(unsigned i=0;i<v;i++)Lm[i] = new PType*[v];
   M = new Matrix<char>(*obj->M);
   N = new Matrix<char>(*obj->N);
   Owner = NULL;
   Grid = NULL;
   Grounded_Node = obj->Grounded_Node;   // çàçåìëÿåìûé óçåë
   // ñîõðàíÿåì îáúåêò â ñïèñîê
   ObjectList.Add( this );
   // îïèøåì ïîëÿ êëàññà
   Describe_Fields();
}
//---------------------------------------------------------------------------
void PElement::Describe_Fields(){
   // Ñîõðàíÿåì èíôîðìàöèþ î ñâîéñòâàõ êëàññà
   PFieldInfo fi;
   fi.Name = "Èìÿ";
   fi.Type = "String";
   fi.ptr = (void*) &Name;
   Fields.push_back(fi);
}
//---------------------------------------------------------------------------
PElement::~PElement(){
   delete M;
   delete N;
   delete [] R;
   delete [] L;
   delete [] C;
   if(Lm!=NULL)
      for(unsigned j=0;j<v;j++)
         delete [] Lm[j];
   delete [] Lm;
   delete [] D;
   delete [] E;
   delete [] J;
   delete [] U_C;
   delete [] U_L;
   delete [] U_Lm;
   delete [] U_D;
   delete [] Z;
   delete [] I;
   delete [] f;
   // óäàëÿåì îáúåêò èç ñïèñîêà
   ObjectList.Delete( this );
}
//---------------------------------------------------------------------------
unsigned __fastcall PElement::Branches(){ return v; }
unsigned __fastcall PElement::Nodes(){ return u; }
unsigned __fastcall PElement::Circuit(){ return k; }
//---------------------------------------------------------------------------
void PElement::mutual_inductance(unsigned branch_1, unsigned branch_2, const PType &value){
   if(value==0) return;
   // âçàèìîèíäóêòèâíîñòü íå ìîæåò áûòü áîëüøå êîðíÿ ïðîèçâåäåíèÿ èíäóêòèâíîñòåé
   if((fabs(value) - sqrt((*L[branch_1])*(*L[branch_2])))>1e-300){
   	err(0, "mutual_inductance: óñòàíîâëåííàÿ âçàèìîèíäóêòèâíîñòü áîëüøå êîðíÿ ïðîèçâåäåíèÿ èíäóêòèâíîñòåé. Ôèçè÷åñêè ýòî íå âîçìîæíî");
      }
   PType *p = &_Lm.push_back(value);
   //Lm[ branch_1 ][ branch_2 ] = _Lm.end()-1;
   //Lm[ branch_2 ][ branch_1 ] = _Lm.end()-1;
   Lm[ branch_1 ][ branch_2 ] = p;
   Lm[ branch_2 ][ branch_1 ] = p;
}
//---------------------------------------------------------------------------
void PElement::magnetic_link(unsigned Electric_Branch, unsigned Magnetic_Branch, unsigned Windings){
   // ñîçäàåì íîâûé äðîññåëü
   D[ Electric_Branch ] = new Throttle;
   D[ Electric_Branch ]->EBranch = Electric_Branch;
   D[ Electric_Branch ]->MBranch = Magnetic_Branch;
   D[ Electric_Branch ]->Windings = Windings;
   D[ Electric_Branch ]->Obj = this;
}
//---------------------------------------------------------------------------
PPin PElement::set_pin(unsigned Node){
	PPin pin;
   pin.obj = this;
   pin.node = Node;
   //pin.branch = -1;
   return pin;
}
//---------------------------------------------------------------------------
/* Ïåðåñ÷åò äèôôåðåíöèàëüíîãî ñîïðîòèâëåíèÿ äëÿ ìåòîäà ïðèìîóãîëüíèêîâ ïðè íàõîæäåíèè èíòåãðàëà /
void PElement::update_differential_resistance_rect(){
   for(unsigned i=0; i<v; i++)
   	if(*C[i])
      	*Z[i] = *R[i] + *L[i]/smp + smp/(*C[i]);
      else
      	*Z[i] = *R[i] + *L[i]/smp;
} */
//---------------------------------------------------------------------------
/* Ïåðåñ÷åò äèôôåðåíöèàëüíîãî ñîïðîòèâëåíèÿ äëÿ ìåòîäà òðàïåöèé*/
void PElement::update_differential_resistance(){
   for(unsigned i=0; i<v; i++)
   	if(*C[i])
      	*Z[i] = *R[i] + *L[i]/smp + smp/(*C[i])/2;
      else
      	*Z[i] = *R[i] + *L[i]/smp;
}
//---------------------------------------------------------------------------
/* Ðàññ÷åò ïàðàìåòðîâ ñõåìû ïî èçìåíåííûì íà÷àëüíûì äàííûì */
bool PElement::accept(){
   update_differential_resistance();
   return true;
};
//---------------------------------------------------------------------------
void PElement::Save(ostream &stream){		// ñîõðàíåíèå ïàðàìåòðîâ îáúåêòà â ïîòîê
   // èìÿ
   stream << StringForSave( &Name ) << " ";
	// ñåòü, â êîòîðóþ âõîäèì
   String grName = GridName(); if( grName == "" ) grName = "N";
   stream << StringForSave( &grName ) << " ";
}
//---------------------------------------------------------------------------
void PElement::Read(istream &stream){    // çàãðóçêà ïàðàìåòðîâ îáúåêòà èç ïîòîêà
   char name[1024];
   // èìÿ
	stream >> name;    Name = name;
   // ñåòü, â êîòîðóþ âõîäèì
   stream >> name;    String grName = name;
   if(grName == "N")		Grid = NULL;
   else						Grid = ObjectList.Find( grName );
}
//---------------------------------------------------------------------------
String PElement::ClassName(){ return "PElement";}
//---------------------------------------------------------------------------
// ïîëíîå èìÿ ñåòè, â êîòîðóþ âõîäèò îáúåêò
String PElement::GridName(){
	if( Grid == NULL ) return "";
   else					 return Grid->FullName();
}
//---------------------------------------------------------------------------
// èìÿ îáúåêòà ñ ó÷åòîì âñåõ ïîäñåòåé, â êîòîðûå îí âõîäèò
String PElement::FullName(){
	if( Grid == NULL ) return Name;
   else					 return Grid->FullName() + "." + Name;
}
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------








unsigned __fastcall PPin::Node(){ return node;}
//unsigned __fastcall PPin::GetBranch(){ return branch;}
PElement* __fastcall PPin::Obj(){ return obj; }
PType __fastcall PPin::f(){ return *obj->f[node]; }
PType __fastcall PPin::I(){
	// âû÷èñëèì òîê âñåõ âåòâåé, ïîäõîäÿùèõ ê óçëó
   PType I=0;
   unsigned n=obj->Branches();
   for(unsigned j=0; j<n;j++){
   	I += (*obj->M)[node][j] * (*obj->I[j]);
      }
   return I;
}
//---------------------------------------------------------------------------
void PPin::Save(ostream &stream){			// ñîõðàíèòü èíôîðìàöèþ î âûâîäå
   stream << StringForSave(&obj->FullName()) << " ";
   stream << node << " ";
}
//---------------------------------------------------------------------------
void PPin::Read(istream &stream){			// ïðî÷èòàòü èíôîðìàöèþ î âûâîäå
   char n[1024];
   stream >> n;
   obj = ObjectList.Find( (String)n );
   if( !obj ){
      err(0, "PPin: ÷òåíèå èç ïîòîêà. Èìÿ îáúåêòà ("+ (String)n +") íå íàéäåíî â ñïèñêå îáúåêòîâ");
      }
   stream >> node;
}
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------






//---------------------------------------------------------------------------
/* Ãðóïïà âûâîäîâ */
Pins::Pins(unsigned Number):
   Count(Number){
   _Pin = new PPin[Count];
}
//---------------------------------------------------------------------------
Pins::Pins(Pins& obj):
	Count(obj.Count){
   _Pin = new PPin[Count];
   Name = obj.Name;
   for(unsigned i=0; i<Count; i++)
   	_Pin[i] = obj[i];
}
//---------------------------------------------------------------------------
PPin& Pins::operator[](unsigned int i){
   if(i<Count)
      return _Pin[i];
   else{
      err(0,"Pins: Äîñòóï ê íåñóùåñòâóþùåìó ýëåìåíòó. Âåðíóëè 0 ýëåìåíò");
      return _Pin[0];
      }
}
//---------------------------------------------------------------------------
Pins::~Pins(){
   delete [] _Pin;
}
//---------------------------------------------------------------------------
Pins Pins::operator=(Pins &op2){
	if(Count != op2.Count){
      err(0, "Pins::operator=: îøèáêà ïðè ïðèñâàèâàíèè. ×èñëî âûâîäîâ â Âûõîäíûõ ìîäóëÿõ íå ðàâíû");
   	return *this;
   	}
   Name = op2.Name;
	for(unsigned i=0; i<Count; i++)
   	_Pin[i] = op2[i];
   return *this;
}
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------






void Pins_Link::add(PPin &First, PPin &Second){
   Pair_Pin pair;
   pair.First = &First;
   pair.Second = &Second;
	Link.push_back(pair);
}
//---------------------------------------------------------------------------
void Pins_Link::add(Pins& First, Pins& Second){
   Pair_Pin pair;
   if(First.Count != Second.Count) {err(0, "Pins_Link::add: ÷èñëî âûâîäîâ â ãðóïïàõ âûâîäîâ íå îäèíàêîâî. Íå âñå âûâîäû îäíîãî óñòðîéñòà ñîåäèíåíû ñî âòîðûì");}
   for(unsigned i=0, n=First.Count; i<n; i++){
   	pair.First = &First[i];
   	pair.Second = &Second[i];
		Link.push_back(pair);
      }
}
//---------------------------------------------------------------------------
// äîáàâèòü ñâÿçè èç îáúåêòà obj â ýòîò îáúåêò
void Pins_Link::add(Pins_Link obj){
   for(unsigned i=0, n=obj.Link.size(); i<n; i++)
      Link.push_back(obj.Link[i]);
}
//---------------------------------------------------------------------------
unsigned __fastcall Pins_Link::Number(){ return Link.size(); }
//---------------------------------------------------------------------------
Pair_Pin& Pins_Link::operator[](const unsigned int i){ return Link[i]; }
//---------------------------------------------------------------------------
void Pins_Link::clear(){ Link.clear(); };
/*/---------------------------------------------------------------------------
Pins_Link Pins_Link::operator=(const Pins_Link &Obj){
   Link.clear();
   Link = Obj.Link;
   return *this;
} */
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------








//---------------------------------------------------------------------------
void Pins_List::add(Pins* X){ _Pins.push_back(X); }   /* Ñîõðàíèëè ãðóïïó âûâîäîâ */
Pins& Pins_List::operator[](unsigned int i){          // Âåðíóëè ãðóïïó âûâîäîâ
	if(i<_Pins.size()) return *_Pins[i];
   else{
      err(0, "Pins_List::operator[]: îáðàòèëèñü ê íåñóùåñòâóþùåé ãðóïïå âûâîäîâ.");
   	return *_Pins[0];
   	}
}
unsigned Pins_List::Count(){ return _Pins.size();} // ÷èñëî ãðóïï âûâîäîâ
//---------------------------------------------------------------------------
void Pins_List::Clear(){_Pins.clear();}
//---------------------------------------------------------------------------
void Pins_List::Delete(Pins* pins){
	for(int i=0, n=_Pins.size(); i<n; i++)
   	if( _Pins[i] == pins ){
      	_Pins.erase(_Pins.begin() + i);
         break;
         }
}
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------








PUnit::PUnit(unsigned NumBranches, unsigned NumNodes, unsigned NumCircuit):PElement(NumBranches, NumNodes, NumCircuit){
   _E = new PType[v];
   _U_C= new PType[v];
   _U_L= new PType[v];
   _U_Lm= new PType[v];
   _U_D= new PType[v];
   _R = new PType[v];
   _L = new PType[v];
   _C = new PType[v];
   _Z = new PType[v];
   _I = new PType[v];
   _J = new PType[u];
   _f = new PType[u];
   for(unsigned i=0;i<v;i++){
      _E[i]=0;
      _U_C[i]=0;
      _U_L[i]=0;
      _U_Lm[i]=0;
      _U_D[i]=0;
      _R[i]=MIN;     // ÷òîáû íå áûëî êîðîòêîçàìêíóòûõ âåòâåé, ïðè êîòîðûõ âåñü îáúåêò ïðåâðàùàåòñÿ â òî÷êó
      _L[i]=0;
      _C[i]=0;
      _Z[i]=0;
      _I[i]=0;
      }
   for(unsigned i=0;i<u;i++){
      _J[i]=0;
      _f[i]=0;
      }
   // óêàçàòåëè óêàçûâàþò íà ýòè çíà÷åíèÿ
   _Lm.push_back(0); const PType *first = _Lm.begin();
   for(unsigned i=0;i<v;i++){
      E[i]=&_E[i];
      U_C[i]=&_U_C[i];
      U_L[i]=&_U_L[i];
      U_Lm[i]=&_U_Lm[i];
      U_D[i]=&_U_D[i];
      R[i]=&_R[i];
      L[i]=&_L[i];
      C[i]=&_C[i];
      Z[i]=&_Z[i];
      I[i]=&_I[i];
      for(unsigned j=0;j<v;j++) Lm[i][j] = (PType*)first;
      }
   for(unsigned i=0;i<u;i++){
      J[i]=&_J[i];
      f[i]=&_f[i];
      }
   // îïèøåì ïîëÿ êëàññà
   Describe_Fields();
}
//---------------------------------------------------------------------------
void PUnit::Describe_Fields(){
}
//---------------------------------------------------------------------------
PUnit::PUnit(PUnit *obj):PElement(obj){
   _E = new PType[v];
   _U_C= new PType[v];
   _U_L= new PType[v];
   _U_Lm= new PType[v];
   _U_D= new PType[v];
   _R = new PType[v];
   _L = new PType[v];
   _C = new PType[v];
   _Z = new PType[v];
   _I = new PType[v];
   _J = new PType[u];
   _f = new PType[u];
   for(unsigned i=0;i<v;i++){
      _E[i]=obj->_E[i];
      _U_C[i]=obj->_U_C[i];
      _U_L[i]=obj->_U_L[i];
      _U_Lm[i]=obj-> _U_Lm[i];
      _U_D[i]=obj-> _U_D[i];
      _R[i]=obj->_R[i];
      _L[i]=obj->_L[i];
      _C[i]=obj->_C[i];
      _Z[i]=obj->_Z[i];
      _I[i]=obj->_I[i];
      }
   for(unsigned i=0;i<u;i++){
      _J[i]=obj->_J[i];
      _f[i]=obj->_I[i];
      }
   // óêàçàòåëè óêàçûâàþò íà ýòè çíà÷åíèÿ
   _Lm.push_back(0);
   for(unsigned i=0;i<v;i++){
      E[i]=&_E[i];
      U_C[i]=&_U_C[i];
      U_L[i]=&_U_L[i];
      U_Lm[i]=&_U_Lm[i];
      U_D[i]=&_U_D[i];
      R[i]=&_R[i];
      L[i]=&_L[i];
      C[i]=&_C[i];
      Z[i]=&_Z[i];
      I[i]=&_I[i];
      //for(unsigned j=0;j<v;j++) Lm[i][j] = _Lm.begin() + distance(obj->_Lm.begin(), obj->Lm[i][j]);
      for(unsigned j=0;j<v;j++) Lm[i][j] = &_Lm[  obj->_Lm.index( obj->Lm[i][j] )  ];
      }
   for(unsigned i=0;i<u;i++){
      J[i]=&_J[i];
      f[i]=&_f[i];
      }
   Fields = obj->Fields;   // òåæå ñâîéñòâà ïîëåé
}
//---------------------------------------------------------------------------
PUnit::~PUnit(){
   delete [] _R;
   delete [] _L;
   delete [] _C;
   delete [] _E;
   delete [] _J;
   delete [] _U_C;
   delete [] _U_L;
   delete [] _U_Lm;
   delete [] _U_D;
   delete [] _Z;
   delete [] _I;
   delete [] _f;
}
//---------------------------------------------------------------------------
String PUnit::ClassName(){return "PUnit";}
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
















PLine::PLine(unsigned Num_Of_Cells):
   PUnit(15*Num_Of_Cells+12, 1+3*Num_Of_Cells+3, 12*Num_Of_Cells+9),
   X1(4),               // âûâîäû ïåðâîé ãðóïïû
   X2(4){               // âûâîäû âòîðîé ãðóïïû
   z=Num_Of_Cells;	   // ÷èñëî çâåíüåâ
   set_pins();          // îáîçíà÷åíèå âûâîäîâ îò óñòðîéñòâà
   Describe_Fields();   // Ñîõðàíÿåì èíôîðìàöèþ î ñâîéñòâàõ êëàññà
	/*/ çàïîëíÿåì ìàòðèöû
   u= 1 + 3*z + 3;
   v=15*z + 12;
   k=4*z + 2;	// ÷èñëî óçëîâ, âåòâåé, íåçàâ. êîíòóðîâ*/
   char _M[4][15] = {{ 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0},
   	               {-1, 0, 1,-1, 0, 1,-1, 0, 0,-1, 0, 0,-1, 0, 0},
                     { 1,-1, 0, 1,-1, 0, 0,-1, 0, 0,-1, 0, 0,-1, 0},
                     { 0, 1,-1, 0, 1,-1, 0, 0,-1, 0, 0,-1, 0, 0,-1}};
   for(unsigned k=0;k<z;k++){
      for(unsigned j=0;j<15;j++)
      		(*M)[0][15*k+j] = _M[0][j];
   	for(unsigned i=1;i<4;i++)
      	for(unsigned j=0;j<15;j++)
      		(*M)[3*k+i][15*k+j] = _M[i][j];
      (*M)[3*k+4][15*k+12]=1;
      (*M)[3*k+5][15*k+13]=1;
      (*M)[3*k+6][15*k+14]=1;
      }
   for(unsigned i=1;i<4;i++)
     	for(unsigned j=0;j<12;j++)
     		(*M)[u-4+i][v-12+j] = _M[i][j];
   (*M)[0][v-6]=1;
   (*M)[0][v-5]=1;
   (*M)[0][v-4]=1;
   (*M)[0][v-3]=1;
   (*M)[0][v-2]=1;
   (*M)[0][v-1]=1;
   char _N[12][15] = {{ 1, 0, 0, 0, 0, 0,-1, 1, 0, 0, 0, 0, 0, 0, 0},
   						 { 0, 1, 0, 0, 0, 0, 0,-1, 1, 0, 0, 0, 0, 0, 0},
                      { 0, 0,-1, 0, 0, 0,-1, 0, 1, 0, 0, 0, 0, 0, 0},
                      { 1, 0, 0,-1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
                      { 0, 1, 0, 0,-1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
                      { 0, 0, 1, 0, 0,-1, 0, 0, 0, 0, 0, 0, 0, 0, 0},
                      { 0, 0, 0, 0, 0, 0, 1, 0, 0,-1, 0, 0, 0, 0, 0},
                      { 0, 0, 0, 0, 0, 0, 0, 1, 0, 0,-1, 0, 0, 0, 0},
                      { 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0,-1, 0, 0, 0},
                      { 0, 0, 0, 0, 0, 0,-1, 0, 0, 0, 0, 0, 1, 0, 0},
                      { 0, 0, 0, 0, 0, 0, 0,-1, 0, 0, 0, 0, 0, 1, 0},
                      { 0, 0, 0, 0, 0, 0, 0, 0,-1, 0, 0, 0, 0, 0, 1}};
   for(unsigned n=0;n<z;n++){
   	for(unsigned i=0;i<12;i++)
      	for(unsigned j=0;j<15;j++)
      		(*N)[12*n+i][15*n+j] = _N[i][j];
      (*N)[12*n+9][15*(n+1)+6]=1;
      (*N)[12*n+10][15*(n+1)+7]=1;
      (*N)[12*n+11][15*(n+1)+8]=1;
      }
   for(unsigned i=0;i<9;i++)
     	for(unsigned j=0;j<12;j++)
     		(*N)[k-9+i][v-12+j] = _N[i][j];
   Name = "ËÝÏ";        // èìÿ îáúåêòà
   Grounded_Node = 0;   // çàçåìëÿåìûé óçåë
   // èñõîäíûå  ïàðàìåòðû ëèíèè
   for(int i=_N_;i<=_C_;i++){
      R0[i] = MIN;
      C0[i] = 0;
      L0[i] = 0 ;
      Cz0[i] = 0 ;
      Gz0[i] = 1/MAX;
      }
   for(int i=_AB_;i<=_CA_;i++){
      Cm0[i] = 0;
      Gm0[i] = 1/MAX;
      M0 [i] = 0 ;
      }
   /*/ áîëüøèå ìåæäóôàçíûå àêòèâíûå ñîïðîòèâëåíèÿ
   for(unsigned i=0; i<(z+1); i++)
      *R[i*15]   = *R[i*15+1] = *R[i*15+2] =
      *R[i*15+3] = *R[i*15+4] = *R[i*15+5] =
      *R[i*15+6] = *R[i*15+7] = *R[i*15+8] =
      *R[i*15+9] = *R[i*15+10]= *R[i*15+11]= MAX;
   // ìèíèìàëüíûå ïðîäîëüíûå ñîïðîòèâëåíèÿ G (íåîáõîäèìû äëÿ âîçìîæíîñòè çàïèñè 2 çàêîíà Êèðõãîôà)
   for(unsigned i=0; i<z; i++)
      *R[i*15+12] = *R[i*15+13] = *R[i*15+14] = MIN; */
   length = 1;  // äëèííà ëèíèè
}
//---------------------------------------------------------------------------
PLine::PLine(PLine &ob):
   PUnit(&ob),
   X1(4),
   X2(4){
   z=ob.z;	      // ÷èñëî çâåíüåâ
   set_pins();    // îáîçíà÷åíèå âûâîäîâ îò óñòðîéñòâà
}
//---------------------------------------------------------------------------
PLine::~PLine(){ ;}
//---------------------------------------------------------------------------
/* Óñòàíîâêà ÷åëîâåêî-ïîíÿòíûõ âûâîäîâ îò óñòðîéñòâà */
void PLine::set_pins(){
   Out.add(&X1);  // óêàçàòåëè íà ãðóïïû ýëåìåíòîâ   Pins_Group[0] = &X1
   Out.add(&X2);
   X1.Name = "X1";
   X2.Name = "X2";
	X1[ _N_ ] = set_pin(0);
   X1[ _A_ ] = set_pin(1);
   X1[ _B_ ] = set_pin(2);
   X1[ _C_ ] = set_pin(3);
   X2[ _N_ ] = set_pin(0);
   X2[ _A_ ] = set_pin(u-3); //, 12+15*(z-1) );
   X2[ _B_ ] = set_pin(u-2); //, 13+15*(z-1) );
   X2[ _C_ ] = set_pin(u-1); //, 14+15*(z-1) );
}
//---------------------------------------------------------------------------
void PLine::Describe_Fields(){
   PFieldInfo fi;
   String name;
   // äëèííà
   fi.Name = "Äëèííà";
   fi.Type = "PType";
   fi.ptr = (void*) &length;
   Fields.push_back(fi);
   // ÷èñëî çâåíüåâ
   fi.Name = "Çâåíüåâ";
   fi.Type = "int";
   fi.ptr = (void*) &z;
   fi.Mode = ro;        // òîëüêî ÷òåíèå
   Fields.push_back(fi);
   // âîçâðÿùàåì ðåæèì çàïèñè äëÿ ïîñëåäóþùèõ ïîëåé
   fi.Mode = rw;
   // àêòèâíûå ñîïðîòèâëåíèÿ
   for(int i=0; i<3; i++){
      fi.Name = "R0[_" + (String)((char)('A'+i)) + "_]";
      fi.Type = "PType";
      fi.ptr = (void*) &R0[_A_+i];
      Fields.push_back(fi);
      }
   // èíäóêòèâíîñòè
   for(int i=0; i<3; i++){
      fi.Name = "L0[_" + (String)((char)('A'+i)) + "_]";
      fi.Type = "PType";
      fi.ptr = (void*) &L0[_A_+i];
      Fields.push_back(fi);
      }
   /*/ åìêîñòè â ëèíèè
   for(int i=0; i<3; i++){
      fi.Name = "C0[_" + (String)((char)('A'+i)) + "_]";
      fi.Type = "PType";
      fi.ptr = (void*) &C0[_A_+i];
      Fields.push_back(fi);
      } */
   // âçàèìíàÿ èíäóêòèâíîñòü
   for(int i=0; i<3; i++){
      switch(i){
         case _AB_: name = "AB"; break;
         case _BC_: name = "ÂÑ"; break;
         case _CA_: name = "ÑÀ"; break;
         default:   name = "";
      }
      fi.Name = "M_[_" + name + "_]";
      fi.Type = "PType";
      fi.ptr = (void*) &M0[_AB_+i];
      Fields.push_back(fi);
      }
   // àêòèâíàÿ ïðîâîäèìîñòü íà çåìëþ
   for(int i=0; i<3; i++){
      fi.Name = "Gz0[_" + (String)((char)('A'+i)) + "_]";
      fi.Type = "PType";
      fi.ptr = (void*) &Gz0[_A_+i];
      Fields.push_back(fi);
      }
   // åìêîñòíàÿ ïðîâîäèìîñòü íà çåìëþ
   for(int i=0; i<3; i++){
      fi.Name = "Cz0[_" + (String)((char)('A'+i)) + "_]";
      fi.Type = "PType";
      fi.ptr = (void*) &Cz0[_A_+i];
      Fields.push_back(fi);
      }
   // àêòèâíàÿ ìåæäóôàçíàÿ ïðîâîäèìîñòü
   for(int i=0; i<3; i++){
      switch(i){
         case _AB_: name = "AB"; break;
         case _BC_: name = "ÂÑ"; break;
         case _CA_: name = "ÑÀ"; break;
         default:   name = "";
      }
      fi.Name = "Gm0[_"+ name +"_]";
      fi.Type = "PType";
      fi.ptr = (void*) &Gm0[_AB_+i];
      Fields.push_back(fi);
      }
   // åìêîñòíàÿ ìåæäóôàçíàÿ ïðîâîäèìîñòü
   for(int i=0; i<3; i++){
      switch(i){
         case _AB_: name = "AB"; break;
         case _BC_: name = "ÂÑ"; break;
         case _CA_: name = "ÑÀ"; break;
         default:   name = "";
      }
      fi.Name = "Cm0[_"+ name +"_]";
      fi.Type = "PType";
      fi.ptr = (void*) &Cm0[_AB_+i];
      Fields.push_back(fi);
      }   
}
//---------------------------------------------------------------------------
PLine PLine::operator=(PLine &ob){
   if(z != ob.z ||
      u != ob.u ||
      v != ob.v ||
      k != ob.k) {err(0,"Ïðèñâàèâàíèå îáúåêòà ëèíèÿ: ÷èñëî çâåíüåâ ðàçíîå (TPL::operator=).");return *this; }
   length = ob.length;  // äëèííà ëèíèè
   *M = *ob.M;
   *N = *ob.N;
   // çíà÷åíèÿ ïàðàìåòðîâ
   for(unsigned i=0;i<v;i++){
      _E[i]=*ob.E[i];
      _U_C[i]=*ob.U_C[i];
      _U_L[i]=*ob.U_L[i];
      _U_Lm[i]=*ob.U_Lm[i];
      _R[i]=*ob.R[i];
      _L[i]=*ob.L[i];
      _C[i]=*ob.C[i];
      _Z[i]=*ob.Z[i];
      _I[i]=*ob.I[i];
      }
   _Lm = ob._Lm;
   for(unsigned i=0;i<v;i++)
      for(unsigned j=0;j<v;j++)
         //Lm[i][j] = _Lm.begin() + distance(ob._Lm.begin(), ob.Lm[i][j]);
           Lm[i][j] = &_Lm[  ob._Lm.index( ob.Lm[i][j] )  ];
   for(unsigned i=0;i<u;i++){
      _J[i]=*ob.J[i];
      _f[i]=*ob.f[i];
      }
   return *this;
}
//---------------------------------------------------------------------------
/* Ïàðàìåòðû ëèíèè 
void PLine::setR_(PType value){  // óñòàíîâêà àêòèâíûõ ñîïðîòèâëåíèé íà ôàçó
   PType R_zvena = value / z;
   for(unsigned i=0;i<z;i++){
      *R[i*15+12] = R_zvena;
      *R[i*15+13] = R_zvena;
      *R[i*15+14] = R_zvena;
      }
}
void PLine::setL_(PType value){  // óñòàíîâêà èíäóêòèâíîñòè ôàçû
   PType L_zvena = value / z;
   for(unsigned i=0;i<z;i++){
      *L[i*15+12] = L_zvena;
      *L[i*15+13] = L_zvena;
      *L[i*15+14] = L_zvena;
      }
}
void PLine::setC_(PType value){  // óñòàíîâêà óìêîñòè ôàçû
   PType C_zvena = value * z;   // îáðàòè âíèìàíèå! óìíîæèòü
   for(unsigned i=0;i<z;i++){
      *C[i*15+12] = C_zvena;
      *C[i*15+13] = C_zvena;
      *C[i*15+14] = C_zvena;
      }
}
void PLine::setGz_(PType value){ // óñòàíîâêà àêòèâíûõ ïðîâîäèìîñòåé íà çåìëþ
   PType Rz_zvena = (z+1) / value;   // ÷èñëî ïðîâîäèìîñòåé íà 1 áîëüøå, ÷åì ÷èñëî çâåíüåâ
   for(unsigned i=0, cnt=z+1; i<cnt; i++){
      *R[i*15+6] = Rz_zvena;
      *R[i*15+7] = Rz_zvena;
      *R[i*15+8] = Rz_zvena;
      }
}
void PLine::setCz_(PType value){ // óñòàíîâêà åìêîñòåé íà çåìëþ
   PType Cz_zvena = value / (z+1);   // äà-äà! èìåííî äåëèòü
   for(unsigned i=0, cnt=z+1; i<cnt; i++){
      *C[i*15+9 ] = Cz_zvena;
      *C[i*15+10] = Cz_zvena;
      *C[i*15+11] = Cz_zvena;
      }
   // îáíóëÿåì àêòèâíîå ñîïðîòèâëåíèå â ýòèõ âåòâÿõ
   if(value!=0)
      for(unsigned i=0, cnt=z+1; i<cnt; i++){
         *R[i*15+9 ] = 0;
         *R[i*15+10] = 0;
         *R[i*15+11] = 0;
         }
   else
      for(unsigned i=0, cnt=z+1; i<cnt; i++){
         *R[i*15+9 ] = MAX;
         *R[i*15+10] = MAX;
         *R[i*15+11] = MAX;
         }

}
void PLine::setGm_(PType value){ // óñòàíîâêà àêòèâíûõ ìåæäóôàçíûõ ïðîâîäèìîñòåé
   PType Rm_zvena = (z+1) / value;   // ÷èñëî ïðîâîäèìîñòåé íà 1 áîëüøå, ÷åì ÷èñëî çâåíüåâ
   for(unsigned i=0, cnt=z+1; i<cnt; i++){
      *R[i*15+0] = Rm_zvena;
      *R[i*15+1] = Rm_zvena;
      *R[i*15+2] = Rm_zvena;
      }
}
void PLine::setCm_(PType value){ // óñòàíîâêà ìåæäóôàçíûõ åìêîñòåé
   PType Cm_zvena = value / (z+1);   // äà-äà! èìåííî äåëèòü
   for(unsigned i=0, cnt=z+1; i<cnt; i++){
      *C[i*15+3] = Cm_zvena;
      *C[i*15+4] = Cm_zvena;
      *C[i*15+5] = Cm_zvena;
      }
   // îáíóëÿåì àêòèâíîå ñîïðîòèâëåíèå â ýòèõ âåòâÿõ
   if(value!=0)
      for(unsigned i=0, cnt=z+1; i<cnt; i++){
         *R[i*15+3] = 0;
         *R[i*15+4] = 0;
         *R[i*15+5] = 0;
         }
   else
      for(unsigned i=0, cnt=z+1; i<cnt; i++){
         *R[i*15+3] = MAX;
         *R[i*15+4] = MAX;
         *R[i*15+5] = MAX;
         }
}
void PLine::setLm_(PType value){ // óñòàíîâêà ìåæäóôàçíûõ âçàèìîèíäóêòèâíîñòåé
   PType Lm_zvena = value / z;
   for(unsigned i=0;i<z;i++){
   	mutual_inductance(i*15+12, i*15+13, Lm_zvena);
      mutual_inductance(i*15+12, i*15+14, Lm_zvena);
      mutual_inductance(i*15+13, i*15+14, Lm_zvena);
   	}
}
//---------------------------------------------------------------------------
// Óäåëüíûå ïàðàìåòðû
void PLine::setR0(PType value){  // óñòàíîâêà àêòèâíûõ ñîïðîòèâëåíèé íà ôàçó
   PType R_zvena = value * length / z;
   for(unsigned i=0;i<z;i++){
      *R[i*15+12] = R_zvena;
      *R[i*15+13] = R_zvena;
      *R[i*15+14] = R_zvena;
      }
}
void PLine::setL0(PType value){  // óñòàíîâêà èíäóêòèâíîñòè ôàçû
   PType L_zvena = value * length / z;
   for(unsigned i=0;i<z;i++){
      *L[i*15+12] = L_zvena;
      *L[i*15+13] = L_zvena;
      *L[i*15+14] = L_zvena;
      }
}
void PLine::setC0(PType value){  // óñòàíîâêà óìêîñòè ôàçû
   PType C_zvena = (value / length) * z;   // îáðàòè âíèìàíèå! óìíîæèòü
   for(unsigned i=0;i<z;i++){
      *C[i*15+12] = C_zvena;
      *C[i*15+13] = C_zvena;
      *C[i*15+14] = C_zvena;
      }
}
void PLine::setGz0(PType value){ // óñòàíîâêà àêòèâíûõ ïðîâîäèìîñòåé íà çåìëþ
   PType Rz_zvena = (z+1) / (value * length);   // ÷èñëî ïðîâîäèìîñòåé íà 1 áîëüøå, ÷åì ÷èñëî çâåíüåâ
   for(unsigned i=0, cnt=z+1; i<cnt; i++){
      *R[i*15+6] = Rz_zvena;
      *R[i*15+7] = Rz_zvena;
      *R[i*15+8] = Rz_zvena;
      }
}
void PLine::setCz0(PType value){ // óñòàíîâêà åìêîñòåé íà çåìëþ
   PType Cz_zvena = (value * length ) / (z+1);   // äà-äà! èìåííî äåëèòü
   for(unsigned i=0, cnt=z+1; i<cnt; i++){
      *C[i*15+9 ] = Cz_zvena;
      *C[i*15+10] = Cz_zvena;
      *C[i*15+11] = Cz_zvena;
      }
   // îáíóëÿåì àêòèâíîå ñîïðîòèâëåíèå â ýòèõ âåòâÿõ
   if(value!=0)
      for(unsigned i=0, cnt=z+1; i<cnt; i++){
         *R[i*15+9 ] = 0;
         *R[i*15+10] = 0;
         *R[i*15+11] = 0;
         }
   else
      for(unsigned i=0, cnt=z+1; i<cnt; i++){
         *R[i*15+9 ] = MAX;
         *R[i*15+10] = MAX;
         *R[i*15+11] = MAX;
         }
}
void PLine::setGm0(PType value){ // óñòàíîâêà àêòèâíûõ ìåæäóôàçíûõ ïðîâîäèìîñòåé
   PType Rm_zvena = (z+1) / (value * length);   // ÷èñëî ïðîâîäèìîñòåé íà 1 áîëüøå, ÷åì ÷èñëî çâåíüåâ
   for(unsigned i=0, cnt=z+1; i<cnt; i++){
      *R[i*15+0] = Rm_zvena;
      *R[i*15+1] = Rm_zvena;
      *R[i*15+2] = Rm_zvena;
      }
}
void PLine::setCm0(PType value){ // óñòàíîâêà ìåæäóôàçíûõ åìêîñòåé
   PType Cm_zvena = (value * length) / (z+1);   // äà-äà! èìåííî äåëèòü
   for(unsigned i=0, cnt=z+1; i<cnt; i++){
      *C[i*15+3] = Cm_zvena;
      *C[i*15+4] = Cm_zvena;
      *C[i*15+5] = Cm_zvena;
      }
   // îáíóëÿåì àêòèâíîå ñîïðîòèâëåíèå â ýòèõ âåòâÿõ
   if(value!=0)
      for(unsigned i=0, cnt=z+1; i<cnt; i++){
         *R[i*15+3] = 0;
         *R[i*15+4] = 0;
         *R[i*15+5] = 0;
         }
   else
      for(unsigned i=0, cnt=z+1; i<cnt; i++){
         *R[i*15+3] = MAX;
         *R[i*15+4] = MAX;
         *R[i*15+5] = MAX;
         }
}
void PLine::setLm0(PType value){ // óñòàíîâêà ìåæäóôàçíûõ âçàèìîèíäóêòèâíîñòåé
   PType Lm_zvena = (value * length) / z;
   for(unsigned i=0;i<z;i++){
   	mutual_inductance(i*15+12, i*15+13, Lm_zvena);
      mutual_inductance(i*15+12, i*15+14, Lm_zvena);
      mutual_inductance(i*15+13, i*15+14, Lm_zvena);
   	}
}*/
//---------------------------------------------------------------------------
/* îïðåäåëåíèå ïàðàìåòðîâ ñõåìû çàìåùåíèÿ ëèíèè ïî äàííûõ õîëîñòîãî õîäà */
bool PLine::set_params(const PType _L0, const PType _R0, const PType _M0, const PType dP_f, const PType dQ_f, const PType U_n_f, const PType U_k_f, const PType dP, const PType dQ, const PType U_n, const PType U_k, const PType freq ){
	// ïîèñê ñîïðîòèâëåíèé ïðîäîëüíûõ âåòâåé
   PType Xz = 2*M_PI*freq*(_L0*length/z);
   //PType Lz = L0*length/z;
   PType Rz = 2*M_PI*freq*(_R0*length/z);
	// ïîèñê ïðîâîäèìîñòåé ïîïåðå÷íûõ âåòâåé íà çåìëþ
	PType a = (U_k_f-U_n_f)/(z*U_k_f);
   PType C1 = z*(z-1)*(3*a*a*pow(z,3) - z*z*(12*a*a+15*a) + z*(13*a*a+35*a+20) - 2*a*a - 10*a - 10 )/60;
	PType C2 = (z+1)*(2*a*a*z*z + z*(a*a-6*a) + 6 )/6;
   PType k = (dP_f-Rz*dQ_f/Xz)/(U_k_f*U_k_f*C2);
   PType A1 = Xz*U_k_f*U_k_f*C1*(1+pow(Rz/Xz,2));
   PType B1 = 2*k*Rz*U_k_f*U_k_f*C1 + U_k_f*U_k_f*C2;
   PType D1 = Xz*U_k_f*U_k_f*k*k*C1 - dQ_f;
   PType b2z = (sqrt(B1*B1-4*A1*D1) - B1)/(2*A1);
   PType C2z = b2z/(2*M_PI*freq);
   PType g2z = (k + Rz/Xz*b2z);
   // ïîèñê ìåæäóôàçíûõ ïðîâîäèìîñòåé
   PType Xmz = 2*M_PI*freq*((_L0-_M0)*length/z);
   //PType Mz = M0*length/z;
   a = (U_k-U_n)/(z*U_k);
   C1 = z*(z-1)*(3*a*a*pow(z,3) - z*z*(12*a*a+15*a) + z*(13*a*a+35*a+20) - 2*a*a - 10*a - 10 )/60;
	C2 = (z+1)*(2*a*a*z*z + z*(a*a-6*a) + 6 )/6;
   k = (dP-Rz*dQ/Xmz)/(3*U_k*U_k*C2);
	A1 = Xmz*U_k*U_k*C1*(1+pow(Rz/Xmz,2));
   B1 = 2*k*Rz*U_k*U_k*C1 + U_k*U_k*C2;
   D1 = Xmz*U_k*U_k*k*k*C1 - dQ/3;
   PType bz = (sqrt(B1*B1-4*A1*D1) - B1)/(2*A1);
   PType gz = k + Rz/Xmz*bz;
   PType b1z = (bz - b2z)/3;
   PType C1z = b1z/(2*M_PI*freq);
   PType g1z = (gz - g2z)/3;
   // óñòàíîâêà çíà÷åíèé
   for(int i=_A_; i<=_C_; i++){
      R0[i] = _R0;
      L0[i] = _L0;
      C0[i] = 0;
      M0[i] = _M0;
      Gz0[i] = g2z * (z+1) / length;
      Cz0[i] = C2z * (z+1) / length;
      }
   for(int i=_AB_; i<=_CA_; i++){
      Gm0[i] = g1z * (z+1) / length;
      Cm0[i] = C1z * (z+1) / length;
      }
   /*setR_ ( _R0 * length );
   setL_ ( _L0 * length );
   setC_ ( 0 );
   setLm_ ( _M0 * length );
   setGz_ ( g2z * (z+1) );
   setCz_ ( C2z * (z+1) );
   setGm_ ( g1z * (z+1) );
   setCm_ ( C1z * (z+1) ); */
   return true;
}
//---------------------------------------------------------------------------
/* îïðåäåëåíèå ïàðàìåòðîâ ñõåìû çàìåùåíèÿ ôàçû äëÿ ËÝÏ*/
bool PLine::Phase_Params(Phase phase, PType __R, PType __L, PType __C, PType Gz, PType Cz){
   PType R2;	   // ñîïðîòèâëåíèÿ íà çåìëþ
   if(Gz) R2 = (z+1)/Gz;
   else R2 = MAX;
   PType C2 = Cz/(z+1);
   PType L_zvena  = __L/z;
   PType R_zvena  = __R/z;
   PType C_zvena  = __C/z;
   // îïðåäåëÿåì ôàçó
   unsigned p;
   switch (phase){
   	case _A_: p=0; break;
      case _B_: p=1; break;
      case _C_: p=2; break;
      default:	 return false;
      }
   // óñòàíîâêà çíà÷åíèé
   for(unsigned i=0;i<(z+1);i++){
      // âåòêà àêòèâíîé ïðîâîäèìîñòè
      *R[i*15+6+p] = R2;
      *L[i*15+6+p] = 0;
      *C[i*15+6+p] = 0;
      // âåòêà åìêîñòíîé ïðîâîäèìîñòè
      if(C2){
         *C[i*15+9+p] = C2;
         *R[i*15+9+p] = 0;
         *L[i*15+9+p] = 0;
         }
      else
         *R[i*15+9+p] = MAX;
      }
   for(unsigned i=0;i<z;i++){
      *R[i*15+12+p] = R_zvena;
      *L[i*15+12+p]	= L_zvena;
      *C[i*15+12+p]	= C_zvena;
      }
   return true;
}
//---------------------------------------------------------------------------
/* îïðåäåëåíèå ïàðàìåòðîâ ñõåìû çàìåùåíèÿ ôàçû äëÿ ËÝÏ*/
bool PLine::Phase_Params_0(Phase phase, PType R0, PType L0, PType Gz0, PType Cz0){
   return  Phase_Params(phase, R0*length, L0*length, 0, Gz0*length, Cz0*length);
}
//---------------------------------------------------------------------------
bool PLine::Mutual_Inductance(PType M_ab, PType M_bc, PType M_ca){
   for(unsigned i=0;i<z;i++){
   	mutual_inductance(i*15+12, i*15+13, M_ab/z);
      mutual_inductance(i*15+13, i*15+14, M_bc/z);
      mutual_inductance(i*15+14, i*15+12, M_ca/z);
   	}
   return true;
}
//---------------------------------------------------------------------------
/* îïðåäåëåíèå ïàðàìåòðîâ ñõåìû çàìåùåíèÿ ëèíèè - âçàèìîèíäóêòèâíîñòè */
bool PLine::Mutual_Inductance_0(PType M0_ab, PType M0_bc, PType M0_ca){
   return Mutual_Inductance(M0_ab*length, M0_bc*length, M0_ca*length);
}
//---------------------------------------------------------------------------
/* îïðåäåëåíèå ïàðàìåòðîâ ñõåìû çàìåùåíèÿ äëÿ ËÝÏ - ìåæäóôàçíûå ïðîâîäèìîñòè */
bool PLine::Mutual_Conductance(unsigned Phase1, unsigned Phase2, PType Gm, PType Cm){
   PType R1 = (z+1)/Gm;	// ìåæäóôàçíûå ñîïðîòèâëåíèÿ
   PType C1 = Cm/(z+1);
   // îïðåäåëÿåì ôàçó
   unsigned p;
   switch (Phase1 + Phase2){
   	case (_A_ + _B_): p=0; break;
      case (_B_ + _C_): p=1; break;
      case (_C_ + _A_): p=2; break;
      default:	 return false;
      }
   // óñòàíîâêà çíà÷åíèé
   for(unsigned i=0;i<(z+1);i++){
      // àêòèâíàÿ ïðîâîäèìîñòü
      *R[i*15+p] = R1;
      *L[i*15+p] = 0;
      *C[i*15+p] = 0;
      // åìêîñòíàÿ ïðîâîäèìîñòü
      if(C1){
         *C[i*15+3+p] = C1;
         *R[i*15+3+p] = 0;
         *L[i*15+3+p] = 0;
         }
      else
         *R[i*15+3+p] = MAX;
      }
   return true;
}
//---------------------------------------------------------------------------
/* îïðåäåëåíèå ïàðàìåòðîâ ñõåìû çàìåùåíèÿ äëÿ ËÝÏ - ìåæäóôàçíûå ïðîâîäèìîñòè */
bool PLine::Mutual_Conductance_0(Phase Phase1, Phase Phase2, PType Gm0, PType Cm0){
   return Mutual_Conductance(Phase1, Phase2, Gm0*length, Cm0*length);
}
//---------------------------------------------------------------------------
bool PLine::accept(){
   bool ret = true;
   // ôàçíûå ïàðàìåòðû
   for(int i=_A_; i<=_C_; i++)
      ret = ret & Phase_Params_0((Phase) i, R0[i], L0[i], Gz0[i], Cz0[i]);
   // ìåæäóôàçíûå èíäóêòèâíîñòè
   ret = ret & Mutual_Inductance_0(M0[_AB_], M0[_BC_], M0[_CA_]);
   // ìåæäóôàçíûå ïðîâîäèìîñòè
   ret = ret & Mutual_Conductance_0(_A_, _B_, Gm0[_AB_], Cm0[_AB_]);
   ret = ret & Mutual_Conductance_0(_B_, _C_, Gm0[_BC_], Cm0[_BC_]);
   ret = ret & Mutual_Conductance_0(_C_, _A_, Gm0[_CA_], Cm0[_CA_]);
   update_differential_resistance();
   return ret;
}
//---------------------------------------------------------------------------
void PLine::Save(ostream &stream){		// ñîõðàíåíèå ïàðàìåòðîâ îáúåêòà â ïîòîê
   // ñíà÷àëà ñîõðàíèòñÿ áàçîâûé êëàññ
   sire::Save(stream);
   // òåïåðü ñîõðàíÿåì ýòîò êëàññ
	stream << length << " ";
   for(int i=0; i<4; i++){
      stream << R0[i] << " ";
      stream << L0[i] << " ";
      stream << C0[i] << " ";
      stream << Gz0[i] << " ";
      stream << Cz0[i] << " ";
   	}
   for(int i=0; i<3; i++){
      stream << M0[i] << " ";
      stream << Gm0[i] << " ";
      stream << Cm0[i] << " ";
   	}
}
//---------------------------------------------------------------------------
void PLine::Read(istream &stream){    // çàãðóçêà ïàðàìåòðîâ îáúåêòà èç ïîòîêà
   // ñíà÷àëà ÷èòàåò äàííûå áàçîâûé êëàññ
   sire::Read(stream);
   // òåïåðü ÷èòàåò ýòîò êëàññ
	stream >> length;
   for(int i=0; i<4; i++){
      stream >> R0[i];
      stream >> L0[i];
      stream >> C0[i];
      stream >> Gz0[i];
      stream >> Cz0[i];
   	}
   for(int i=0; i<3; i++){
      stream >> M0[i];
      stream >> Gm0[i];
      stream >> Cm0[i];
   	}
}
//---------------------------------------------------------------------------
String PLine::ClassName(){ return "PLine";}
//---------------------------------------------------------------------------
unsigned PLine::Cells(){return z;};
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------












//---------------------------------------------------------------------------
PGrid::PGrid(){
	// óñòàíàâëèâàåì íóëåâûå óêàçàòåëè
   A=NULL;
   B=NULL;
   F=NULL;
   _J=NULL;
   Branch=NULL;
   Node=NULL;
   Element=NULL;
   Links = NULL;
   U=NULL;
   _U_Lm2=NULL;
   U_Lm2=NULL;
   _I2=NULL;
   // çàäàåì èìÿ
   Name = "Ñåòü";
   Describe_Fields();	// çàäàòü îïèñàíèå ïîëåé
   BuildOK = false;      // ñåòü íåëüçÿ èñïîëüçîâàòü äëÿ ðåøåíèÿ
}
//---------------------------------------------------------------------------
/* Ñîçäàåì ñåòü èç îäíîãî îáúåêòà */
PGrid::PGrid(PUnit *obj){
   PElement **Block = new  PElement*[1];
   Block[0] = obj;
   if(obj->Internal_Links.Number() == 0)   // ìåæäó óçëàìè íåò ñîåäèíåíé
      Link_Elements(1, Block, 0, NULL);
   else{     // ìåæäó óçëàìè åñòü ñâÿçè
      Pins_Link Link;
      Link.add(obj->Internal_Links);
	   unsigned *link = new unsigned [Link.Number() * 4];
      for(unsigned i=0,m=Link.Number();i<m;i++) {
         // ïåðâûé óçåë
         link[4*i] = 0;
         link[4*i + 1] = Link[i].First->Node();
         // âòîðîé îáúåêò
         link[4*i + 2] = 0;
         link[4*i + 3] = Link[i].Second->Node();
         }
	   BuildOK = Link_Elements(1, Block, Link.Number(), (unsigned (*)[2][2])link);
      delete [] link;
      }
   delete [] Block;
   // çàäàåì èìÿ
   Name = "Ñåòü";
   Describe_Fields();	// çàäàòü îïèñàíèå ïîëåé
}
//---------------------------------------------------------------------------
/* Ïîóçëîâîå ñîåäèíåíèé ýëåìåíòîâ */
PGrid::PGrid(Pins_Link Link){
   if(Link.Number() <=0 ){
      err(0, "PGrid: íå âîçìîæíî ñîáðàòü ñåòü, ò.ê. íå óêàçàíî íè îäíîé ñâÿçè ìåæäó ýëåìåíòàìè");
   	return;
   	}
   /*/ â ñåòè èìåíà âñåõ ýëåìåíòîâ äîëæíû áûòü óíèêàëüíû
   // äîäåëàòü ïîçæå
   for(unsigned i=0, n=Link.Number(); i<n; i++){
      String nameA = Block[i]->Name;
      for(unsigned j=i+1; j<num; j++)
         if( name == Block[j]->Name ){
            err(0, "PGrid: âíóòðè ñåòè èìåíà âñåõ îáúåêòîâ äîëæíû áûòü óíèêàëüíû. Ñåòü íå ñîáðàíà");
            return false;
         	} */
   // ïîäãîòîâêà äàííûõ äëÿ ñáîðêè ñåòè
   vector<PElement*> Block;
   vector<int> link;
   for(unsigned i=0;i<Link.Number();i++) {
      // ïåðâûé îáúåêò
      unsigned j, n=Block.size(); // óæå äîáàâèëè ?
      PElement *e = Link[i].First->Obj();
         for(j=0;j<n;j++)
      	   if(e == Block[j]) break;
         if(j==n){
            Block.push_back(Link[i].First->Obj());
            Link.add(((PUnit*)Link[i].First->Obj())->Internal_Links);   // ó÷òåì âíóòðåííèå ñîåäèíåíèÿ ìåæäó óçëàìè îäíîãî îáúåêòà
            }
         link.push_back( j );
         link.push_back( Link[i].First->Node() );
      // âòîðîé îáúåêò
      n=Block.size(); // óæå äîáàâèëè ?
      e = Link[i].Second->Obj();
         for(j=0;j<n;j++)
      	   if(e == Block[j]) break;
         if(j==n) {
            Block.push_back(Link[i].Second->Obj());
            Link.add(((PUnit*)Link[i].Second->Obj())->Internal_Links);   // ó÷òåì âíóòðåííèå ñîåäèíåíèÿ ìåæäó óçëàìè îäíîãî îáúåêòà
            }
         link.push_back( j );
         link.push_back( Link[i].Second->Node() );
      }
	BuildOK = Link_Elements(Block.size(), Block.begin(), Link.Number(), (unsigned (*)[2][2])link.begin());
   // çàäàåì èìÿ
   Name = "Ñåòü";
   Describe_Fields();	// çàäàòü îïèñàíèå ïîëåé
}
//---------------------------------------------------------------------------
void PGrid::Describe_Fields(){
   /*PFieldInfo fi;
   // ñîïðîòèâëåíèå âî âêëþ÷. ñîñòîÿíèè
   fi.Name = "Ãðóïïû âûâîäîâ";
   fi.Type = "Pins_List";
   fi.ptr = (void*)this;
   Fields.push_back(fi);*/
}
//---------------------------------------------------------------------------
/* num - ÷èñëî áëîêîâ äëÿ ïîñòðîåíèÿ ñåòè
   Block - ìàññèâ èç ýòèõ ýëåìåíòîâ
   Link  - ìàññèâ, óêàçûâàþùèé êàê ñâÿçàíû áëîêè {  { {¹_áëîêà_1, âåðøèíà_áëîêà_1},{¹_áëîêà_2, âåðøèíà_áëîêà_2} }, ...}
*/
bool PGrid::Link_Elements(unsigned num, PElement *Block[], unsigned numLink,unsigned Link[][2][2]){
	// óñòàíàâëèâàåì íóëåâûå óêàçàòåëè
   A=NULL;
   B=NULL;
   F=NULL;
   _J=NULL;
   Branch=NULL;
   Node=NULL;
   Element=NULL;
   Links = NULL;
   U=NULL;
   _U_Lm2=NULL;
   U_Lm2=NULL;
   _I2=NULL;
   if(num==0){err(0,"PGrid::Link_Elements(): Ïðè ñîçäàíèè ñåòè èñïîëüçîâàíî 0 ýëåìåíòîâ. Ñåòü íå ñîçäàíà."); return false;}
   // çàïîìèíàåì ïåðåäàííûå ýëåìåíòû
   numElement = num;
   Element = new PElement*[numElement];
   for(unsigned i=0;i<numElement;i++)
      Element[i] = Block[i];
   // çàïîìèíàåì ñâÿçè
   numLinks = numLink;
   Links = new unsigned [numLink * 4];
   for(unsigned i=0; i<numLink; i++){
      Links[0+4*i] = Link[i][0][0];
      Links[1+4*i] = Link[i][0][1];
      Links[2+4*i] = Link[i][1][0];
      Links[3+4*i] = Link[i][1][1];
   	}
   // ïðîâåðèì óíèêàëüíû ëè èìåíà ýëåìåíòîâ îáúåêòîâ
   for(unsigned i=0; i<numElement; i++){
      String name = Element[i]->FullName();
      for(unsigned j=i+1; j<numElement; j++)
         if( name == Element[j]->FullName() ){
            err(0, "PSubGrid: âíóòðè ñåòè èìåíà âñåõ îáúåêòîâ äîëæíû áûòü óíèêàëüíû, ñåòü íå ñîáðàíà");
            return false;
         	}
      }
   // ñîçäàåì è çàïîëíÿåì ïåðâóþ ìàòðèöó ñâÿçåé âåòâåé â óçëàõ
   u = 0;
   v = 0;
   k = 0;
   for(unsigned i=0; i<num;i++){
      PElement *p = Block[i];
      u += p->M->Rows;     // îáùåå ÷èñëî óçëîâ
      v += p->M->Cols;    // îáùåå ÷èñëî âåòâåé
      k += p->N->Rows;    // îáùåå ÷èñëî êîíòóðîâ
      }
   //numNode = u;
   //numBranch = v;
   if(u<numLink) {err(0, "PGrid::Link_Elements(): îòðèöàòåëüíîå çíà÷åíèå âåðøèí"); return false;};
   if(v==0) {err(0, "PGrid::Link_Elements(): ÷èñëî âåðâåé ðàâíî 0"); return false;};
   //u = u - numLink;  // c ó÷åòîì îáúåäèíÿåìûõ óçëîâ

   Branch = new unsigned*[numElement];
   for(unsigned i=0; i<num;i++){
      unsigned tmp_v = Block[i]->Branches();
      Branch[i] = new unsigned[tmp_v];
      for(unsigned j=0;j<tmp_v;j++)
         Branch[i][j] = -1;
      }
   Node = new unsigned*[numElement];
   for(unsigned i=0; i<num;i++){
      unsigned tmp_u = Block[i]->Nodes();
      Node[i] = new unsigned[tmp_u];
      for(unsigned j=0;j<tmp_u;j++)
         Node[i][j] = -1;
      }
   // ñîõðàíÿåì ñîîòâåòñòâèå âåòâåé
   unsigned i_branch=0; // òåêóùåå ÷èñëî âåòâåé â ðåçóëüòèðóþùåé ìàòðèöå
   for(unsigned i=0; i<num;i++){
      PElement *p = Block[i];
      unsigned tmp_rows = p->M->Cols;
      for(unsigned j=0; j<tmp_rows; j++){
         Branch[i][j] = i_branch;
         i_branch++;
         }
      }
   // ñîõðàíÿåì ñîîòâåòñòâèÿ óçëîâ (ñ ó÷åòîì ñâÿçåé)
   unsigned i_node=0;         // òåêóùåå ÷èñëî óçëîâ â ðåçóëüòèðóþùåé ìàòðèöå
   Grounded_Node = i_node;    // îáúÿâëÿåì ýòîò óçåë êàê çàçåìëåííûé
   bool *link_use = new bool[numLink];
   for(unsigned i=0; i<numLink;i++) link_use[i]=false;
   // à) îáúåäèíÿåì çàçåìëÿåìûå óçëû
   for(unsigned b=0; b<num;b++){
   	PElement *p = Block[b];
      Node[  b  ][  p->Grounded_Node  ] = Grounded_Node;
      // íàéäåì ñâÿçàííûå óçëû
      for(unsigned i=0; i<numLink; i++)
   	   if( ! link_use[i])
            if( Link[i][0][0]==b &&   Link[i][0][1]==p->Grounded_Node )
			      linked_nodes(numLink, Link, link_use, Grounded_Node, Link[i][0][0], Link[i][0][1]);
            else if( Link[i][1][0]==b &&  Link[i][1][1]==p->Grounded_Node )
			      linked_nodes(numLink, Link, link_use, Grounded_Node, Link[i][1][0], Link[i][1][1]);
      }
   i_node++;
   // b) ñîçäàåì îäèí íîâûé óçåë äëÿ íåñêîëüêèõ îáúåäèíÿåìûõ
   for(unsigned i=0; i<numLink; i++)
   	if( ! link_use[i] ){
      	// ñàì óçåë
         Node[  Link[i][0][0]  ][  Link[i][0][1]  ] = i_node;
         // c íèì ñâÿçàííûå
			linked_nodes(numLink, Link, link_use, i_node, Link[i][0][0], Link[i][0][1]);//, i_node);//tmp);
      	// óçëîâ â ðåçóëüòèðóþùåé ìàòðèöå ñòàëî íà 1 áîëüøå
      	i_node++;
      	}
   delete [] link_use;
   // c) ñîçäàåì îäèí íîâûé óçåë íà îäèí ÍÅ ñâÿçàííûé óçåë
   for(unsigned i=0; i<num;i++){
      unsigned tmp_rows = Block[i]->M->Rows;
      for(unsigned j=0; j<tmp_rows; j++){
      	// ìû íå çàïèñûâàëè ýòîò óçåë êàê îáúåäèíåííûé?
         if( -1 == Node_From_LocalNode(i,j) ){
         	// óçåë åùå íå áûë ó÷òåí
            Node[i][j] = i_node;
            i_node++;
         	}
      	}
      }
   u = i_node; // âñåãî ñòîëüêî óçëîâ íàñ÷èòàëè
   // çàïîëíÿåì ìàòðèöó M ñâÿçåé âåòâåé ñ óçëàìè
   M = new Matrix<char>(u, v);
   unsigned *Short_Branch = new unsigned[v];  // êîðîòêî-çàìêíóòûå âåòâè, íà÷àëî è êîíåö êîòîðûõ â îäíîì óçëå
   unsigned num_Short_Branch = 0; // ÷èñëî êîðîòêî-çàìêíóòûõ âåòâåé
   for(unsigned b=0; b<num;b++){
   	PElement *p = Block[b];
      unsigned tmp_rows = p->M->Rows;
      unsigned tmp_cols = p->M->Cols;
      for(unsigned i=0; i<tmp_rows; i++)
      	for(unsigned j=0; j<tmp_cols; j++){
         unsigned br = Branch_From_LocalBranch(b,j);
         unsigned nd = Node_From_LocalNode(b,i);
         if(br>=v || nd>=u)
            {err(0,"PGrid::Link_Elements(): íîìåð óçëà(âåòâè) áîëüøå ÷èñëà óçëîâ(âåéòâåé)");return false;}
         (*M)[nd][br] += (*p->M)[i][j];	// åñëè âåòêà íà÷èíàåòñÿ òàì æå ãäå çàêàí÷èâàåòñÿ, òî ïîëó÷èì 0 â èòîãå
         if(fabs((*M)[nd][br]) < 0.01 && fabs((*p->M)[i][j])>0.01){  // åñëè òàê, òî ýòî êîðîòêî-çàìêíóòàÿ âåòêà
            Short_Branch[num_Short_Branch]=br;
            num_Short_Branch++;}
      	}
      }

   // ñîçäàåì 2 ìàòðèöó èíöåäåíöèé N (2 çàêîí êèðõãîôà)
   k = v-u+1;
   N = new Matrix<char>(k,v);
   //if(k != N->Rows){err(0, "Ñîçäàíèå ñåòè: ÷èñëî êîíòóðîâ íå ñîîòâåòñòâóåò íåîõîäèìîìó êîëè÷åñòâó äëÿ ðåøåíèÿ óðàâíåíèé ( PGrid() )");}
   unsigned nd = 0;  // ÷èñëî óæå çàïèñàííûõ óðàâíåíèé
   for(unsigned b=0; b<num;b++){
   	PElement *p = Block[b];
      unsigned tmp_rows = p->N->Rows;
      unsigned tmp_cols = p->N->Cols;
      for(unsigned i=0; i<tmp_rows; i++){
      	for(unsigned j=0; j<tmp_cols; j++){
            unsigned br = Branch_From_LocalBranch(b,j);
            (*N)[nd][br] = (*p->N)[i][j];
      	   }
         nd++;   // çàïèøåì ñëåäóþùåå óðàâíåíèå
         }
      }
   // 2 çàêîí Êèðõãîôà èç ðàâåíñòâà ïîòåíöèàëîâ îáúåäèíåííûõ óçëîâ
   if( nd < N->Rows ){
   	/* Ïðè îáúåäèíåíèè n óçëîâ (2 îáúåêòà) ìîæíî ñîñòàâèòü n-1 íåçàâèñèìîå óðàâíåíèå ñëåäóþùèì îáðàçîì:
      ïðèðàâíèâàòü ïîòåíöèàëû 2õ îáúåäèíÿåìûõ óçëîâ îòíîñèòåëüíî 2õ äðóãèõ îáúåäèíÿåìûõ óçëîâ.
      Óðàâíåíèÿ áóäåì çàïèñûâàòü äëÿ óçëîâ, êîòîðûå îáúåäèíÿþòñÿ ïðè ñîåäèíåíèè äâóõ ðàçíûõ
      îáúåêòîâ.
      	Ïðè îáúåäèíåíèè 2õ óçëîâ îäíîãî îáúåêòà, íà êàæäóþ îáúåäèíÿåìóþ ïàðó ìîæíî ñîñòàâèòü
      õàêîí êèðõãîôà.
      */
      // Èùåì óçëû îáðàçóåìûå ïðè îáúåäèíåíèè 2x îáúåêòîâ
      bool *Used_Link = new bool[numLink]; for(unsigned i=0;i<numLink;i++) Used_Link[i] = false;
      bool Loop = true; // ïðîäîëæàåì öèêë
      while(Loop){
      	unsigned i;
      	for(i=0; i<numLink;i++) if( !Used_Link[i] )break; // èùåì íå èñïîëüçîâàííûå ñâÿçè
         if (i!=numLink){ // íàøëè
         	unsigned Obj1 = Link[i][0][0];	// ïåðâûé îáúåêò
         	unsigned Obj2 = Link[i][1][0];   // âòîðîé îáúåêò
      		vector<unsigned>  Node_For_Obj1; // ñîõðàíÿåì èñïîëüçîâàííûå óçëû 1 îáúåêòà
      		vector<unsigned>  Node_For_Obj2; // ñîõðàíÿåì èñïîëüçîâàííûå óçëû 2 îáúåêòà
            Node_For_Obj1.push_back(Link[i][0][1]);
            Node_For_Obj2.push_back(Link[i][1][1]);
            Used_Link[i] = true;
            if( Obj1 == Obj2 ){ //îáúåäèíÿåì óçëû îäíîãî îáúåêòà
               Matrix<char> Way(1,v);
               Matrix<char> Way1 = Element[Obj1]->M->Way(Node_For_Obj1[0], Node_For_Obj2[0]);
               for(unsigned s=0, n=Way1.Cols; s<n; s++)
                  Way[0][Branch_From_LocalBranch(Obj1, s)] += Way1[0][s];    // Way = Way1
               /*/ åñëè òî÷åê áîëüøå 2
               if( Element[Obj1]->Nodes > 2){
                  // âûáèðàåì òðåòüþ òî÷êó
               	unsigned node_A = (Node_For_Obj1[0] + Node_For_Obj2[0])/2;
               	if( node_A == Node_For_Obj1[0] ) node_A = (node_A++)%Element[Obj1]->Nodes;
               	if( node_A == Node_For_Obj2[0] ) node_A = (node_A++)%Element[Obj1]->Nodes;
                  Matrix<char> Way1 = Element[Obj1]->M->Way(node_A, Node_For_Obj1[0]);
                  Matrix<char> Way2 = Element[Obj2]->M->Way(node_A, Node_For_Obj2[0]);
                  for(unsigned s=0, n=Way1.Cols; s<n; s++)
            			Way[0][Branch_From_LocalBranch(Obj1, s)] += Way1[0][s];    // Way = Way1
                  for(unsigned s=0, n=Way2.Cols; s<n; s++)
            			Way[0][Branch_From_LocalBranch(Obj2, s)] -= Way2[0][s];    // Way = Way1 - Way2
                  }
               else if( Element[Obj1]->Nodes == 2){ // óçëîâ òîëüêî 2
                  Matrix<char> Way1 = Element[Obj1]->M->Way(Node_For_Obj1[0], Node_For_Obj2[0]);
               	for(unsigned s=0, n=Way1.Cols; s<n; s++)
            			Way[0][ Branch_From_LocalBranch(Obj1, s) ] += Way1[0][s];    // Way = Way2
               	}*/
               // ñ÷èòàåì ÷èñëî âåòâåé â êîíòóðå (äîëæíî áûòü áîëåå 0)
               unsigned branches=0; for(unsigned s=0;s<v;s++) if(Way[0][s]!=0) branches++;
               // ñîõðàíÿåì çàêîí
   //PType t0[2000];
               if(branches > 0){    // >1
            		for(unsigned s=0;s<v;s++) {(*N)[nd][s] = Way[0][s];}//t0[s] = Way[0][s];}
         			nd++;	// çàïèøåì åùå îäíî óðàâíåíèå ïî 2 çàêîíó Êèðõãîôà
                  if(nd>=N->Rows) Loop = false; // óðàâíåíèé äîñòàòî÷íî
         			}
            	}
            else{  // îáúåäèíÿåì 2 ðàçíûõ îáúåêòà
             // èùåì äðóãèå îáúåäèíÿåìûå óçëû ïðè îáúåäèíåíèè ýòèõ îáúåêòîâ äðóã ñ äðóãîì
             for(unsigned j=0; j<numLink;j++)
            	if( !Used_Link[j] ){
               	if( Link[j][0][0] == Obj1 && Link[j][1][0] == Obj2){
            			Node_For_Obj1.push_back(Link[j][0][1]);
            			Node_For_Obj2.push_back(Link[j][1][1]);
                     Used_Link[j] = true;
                  	}
                  else if( Link[j][1][0] == Obj1 && Link[j][0][0] == Obj2){
            			Node_For_Obj1.push_back(Link[j][1][1]);
            			Node_For_Obj2.push_back(Link[j][0][1]);
                     Used_Link[j] = true;
                  	}
                  }
            // Â Node_For_Obj1 è Node_For_Obj2 ïîä îäèíàêîâûìè èíäåêñàìè ëåæàò îáúåäèíÿåìûå óçëû
            // ñîñòàâèì 2 çàêîí êèðõãîôà (ïðèðàâíÿåì ïîòåíöèàëû ýòèõ óçëîâ)
            // ïóòè áóäåì ñîñòàâëÿòü îò ïåðâûõ óçëîâ (ó=0) äî îñòàëüíûõ
            unsigned node_A = Block[Obj1]->Grounded_Node; //Node_For_Obj1[0];
            unsigned node_B = Block[Obj2]->Grounded_Node; //Node_For_Obj2[0];
            Matrix<char> Way_AB = M->Way( Node_From_LocalNode(Obj1, node_A), Node_From_LocalNode(Obj2, node_B));  // node_A è node_Â îäèí è òîò æå óçåë - ïóòü ä.á. íóëåâûì
            for(unsigned y=0, n=Node_For_Obj1.size(); y<n; y++){  // y=1
               if( Node_For_Obj1[y] != node_A || Node_For_Obj2[y] != node_B ){
            	   // êðàò÷àéøèå ïóòè
      			   Matrix<char> Way1 = Element[Obj1]->M->Way(node_A, Node_For_Obj1[y]);
         		   Matrix<char> Way2 = Element[Obj2]->M->Way(node_B, Node_For_Obj2[y]);
                  // ñîñòàâëÿåì çàêîí
                  Matrix<char> Way(Way_AB);  // Way = way_AB
                  for(unsigned s=0, n=Way2.Cols; s<n; s++){
            		   unsigned br = Branch_From_LocalBranch(Obj2, s);
            		   Way[0][br] += Way2[0][s];    // Way = ay_AB + way2
               	   }
            	   for(unsigned s=0, n=Way1.Cols; s<n; s++){
               	   unsigned br = Branch_From_LocalBranch(Obj1, s);
            		   Way[0][br] -=  Way1[0][s];                      // Way = Way_AB + way2 - way1
                     }
                  // ñ÷èòàåì ÷èñëî âåòâåé â êîíòóðå (äîëæíî áûòü áîëåå 0)
                  unsigned branches=0;
                  for(unsigned s=0;s<v;s++) {if(Way[0][s]!=0) branches++;}
                  // åñëè ÷èñëî âåòâåé áîëüøå 0 ñîõðàíÿåì çàêîí
                  //PType t0[3200];
         		   if(branches > 0){    // >1
            		   for(unsigned s=0;s<v;s++) {(*N)[nd][s] = Way[0][s];}//t0[s] = Way[0][s];}
         			   nd++;	// çàïèøåì åùå îäíî óðàâíåíèå ïî 2 çàêîíó Êèðõãîôà
         			   }
                  if(nd>=N->Rows) {Loop = false; break; } // óðàâíåíèé äîñòàòî÷íî
                  } // óñëîâèå if
            	}  // êîíåö öèêëà áûáîðà ïàð
             } // êîíåö äëÿ 2õ îáúåäèíÿåìûõ óçëîâ
            }
         else
         	Loop = false; // ïðîñìîòðåëè âñå ñâÿçè
         }
      delete [] Used_Link;
      /* Áåðåì ïðîèçâîëüíûé óçåë è ñ÷èòàåì ïî èìåþùåéñÿ 1 ìàòðèöå èíöèäåíöèé M
      äâà ðàçâûõ ïóòè äî îáúåäèíÿåìûõ óçëîâ. È òàê êàê ýòè óçëû îáúåäèíåíû ïîëó÷èì êîíòóð.
      Íóæíà ôóíêöèÿ íàõîæäåíèÿ ïóòè ìåæäó óçëàìè:
      1) áåðåì óçåë A 1 îáúåêòà è ñ÷èòàåì ïóòü äî îáúåäèíÿåìîãî óçëà U1 ïî ìàòðèöå Ì1
      2) ñ÷èòàåì ïóòü îò óçëà A äî ëþáîãî óçëà  2 îáúåêòà ïî ìàòðèöå Ì
      3) ñ÷èòàåì ïóòü îò  äî îáúåäèíÿåìîãî óçëà U2 ïî ìàòðèöå Ì2
      3.1) çàïîìèíàåì ïàðû {A,U1} {B,U2} è áîëüøå èõ íå èñïîëüçóåì äëÿ çàäàííûõ îáúåêòîâ
      4) ñîòàâëÿåì 2 çàêîí Êèðõãîôà
      5) ýòîò çàêîí ìîæåò áûòü çàêîíîì äëÿ êîðîòêîçàìêíóòîé âåòâè, òîãäà åãî íå ñîõðàíÿåì,
      	è èùåì äðóãîé óçåë Â è ïîâòîðèì ï.3-5
      6) ýòîò çàêîí ìîæåò èìåòü 0 âåòâåé, òîãäà åãî íå ñîõðàíÿåì,
      	è èùåì äðóãîé óçåë Â è ïîâòîðèì ï.3-5
      7) ýòîò çàêîí ìîæåò ñîäåðæàòü âåòâè òîëüêî îäíîãî îáúåêòà - íå ñîõðàíÿåì, ïîâòîðèì ï.3-5
      //
      vector< vector<unsigned> >  First_Node_For_Obj(numElement); // ñîõðàíÿåì èñïîëüçîâàííûå ïàðû óçëîâ - Pairs_Node_For_Obj[Obj][¹][0/1]
      vector< vector<unsigned> >  Second_Node_For_Obj(numElement);// ñîõðàíÿåì èñïîëüçîâàííûå óçëû
      for(unsigned i=0; i<numLink;i++){
      	unsigned Obj1 = Link[i][0][0];
         unsigned Obj2 = Link[i][1][0];
      	// A = 0, B = 0, U1 = Link[i][0][1], U2 = Link[i][1][1]
         unsigned node_U1 = Link[i][0][1];
         unsigned node_U2 = Link[i][1][1];
         unsigned node_A = 0;
         unsigned node_B = 0;
         //*Pairs_Node_For_Obj = new vector<unsigned[2]>[numElement];
         Matrix<char> Way(1, v); // íàéäåííûé êîíòóð
         unsigned branches = 0;	// ÷èñëî âåòâåé â ðåçóëüòèðóþùåì çàêîíå
         bool Loop = false;		// ïîâòîðèòü ðàñ÷åò äëÿ äðóãèõ óçëîâ A, B
//PType t0[200];
         do{
            branches=0;
            // Íå èñïîëüçîâàëè ëè ìû ðàíüøå ýòîé ïàðû óçëîâ
            bool use_1, use_2;
            do{
         	   if(node_A == node_U1)  node_A = node_A++;
               if(node_B == node_U2)  node_B = node_B++;
                  // ïî 1 îáúåêòó
               use_1=false;
               for(unsigned i=0, n=First_Node_For_Obj[ Obj1 ].size(); i<n; i++)
                  if( First_Node_For_Obj[ Obj1 ][i] == node_A  && Second_Node_For_Obj[ Obj1 ][i] == node_U1) {use_1 = true; break;}
                  else if( First_Node_For_Obj[ Obj1 ][i] == node_U1  && Second_Node_For_Obj[ Obj1 ][i] == node_A  ) {use_1 = true; break;}
                  // ïî 2 îáúåêòó
               use_2=false;
               for(unsigned i=0, n=First_Node_For_Obj[ Obj2 ].size(); i<n; i++)
                  if( First_Node_For_Obj[ Obj2 ][i] == node_B  && Second_Node_For_Obj[ Obj2 ][i] == node_U2) {use_2 = true; break;}
                  else if( First_Node_For_Obj[ Obj2 ][i] == node_U2  && Second_Node_For_Obj[ Obj2 ][i] == node_B  ) {use_2 = true; break;}
               if(use_1) node_A = node_A++;
               if(use_2) node_B = node_B++;
               if(   node_A >= Element[Obj1]->Nodes  ||
                     node_B >= Element[Obj2]->Nodes     ){
                     use_1 = false; // è äàëåå ïðåðâåì ïðîöåññ ïîèñêà
                     use_2 = false;
                     }
               }while( use_1 || use_2);
            if(   node_A >= Element[Obj1]->Nodes  ||
                  node_B >= Element[Obj2]->Nodes     ){ break;}
            // çàïîìèíàåì ýòè óçëû
            First_Node_For_Obj[ Obj1 ].push_back(node_U1);
            Second_Node_For_Obj[ Obj1 ].push_back(node_A);
            First_Node_For_Obj[ Obj2 ].push_back(node_U2);
            Second_Node_For_Obj[ Obj2 ].push_back(node_B);
            // êðàò÷àéøèå ïóòè
      		Matrix<char> Way1 = Element[Obj1]->M->Way(node_A, node_U1);
         	Matrix<char> Way2 = Element[Obj2]->M->Way(node_B, node_U2);
            Matrix<char> Way_AB = M->Way( Node_From_LocalNode(Obj1, node_A), Node_From_LocalNode(Obj2, node_B));
            // ïðîâåðêà: à íå ïðèíàäëå÷àòëè âåòâè êîíå÷íîãî çàêîíà îäíîìó îáúåêòó
            unsigned branches_1 = 0;// ÷èñëî âåòâåé îò ïåðâîãî îáúåêòà
            unsigned branches_2 = 0;// ÷èñëî âåòâåé îò âòîðîãî îáúåêòà
            for(unsigned i=0, n=Way1.Cols; i<n; i++){
            	unsigned br = Branch_From_LocalBranch(Obj1, i);
               if( (Way1[0][i] + Way_AB[0][ br ])!=0 ) branches_1++;
               }
            if( branches_1>0 ){ // åñòü âåòâè îò ïåðâîãî îáúåêòà
               for(unsigned i=0; i<v; i++)Way[0][i]=Way_AB[0][i]; // Way = way_AB
            	for(unsigned i=0, n=Way2.Cols; i<n; i++){
            		unsigned br = Branch_From_LocalBranch(Obj2, i);
            		Way[0][ br ] = Way2[0][i] + Way_AB[0][ br ];    // Way = ay_AB + way2
               	if( Way[0][ br ]!=0 ) branches_2++;
               	}
               if( branches_2>0){ // åñòü âåòâè îò âòîðîãî îáúåêòà
            		// ñîñòàâëÿåì óðàâíåíèå
         			for(unsigned i=0, n=Way1.Cols; i<n; i++){
                  	unsigned br = Branch_From_LocalBranch(Obj1, i);
            			Way[0][br] -=  Way1[0][i];                      // Way = ay_AB + way2 - way1
                     }
         			// ñ÷èòàåì ÷èñëî âåòâåé â êîíòóðå (äîëæíî áûòü áîëåå 2õ)
            		branches=0;
         			for(unsigned i=0;i<v;i++) if(Way[0][i]!=0) branches++;
               	}
               }
            if(branches <= 1 ||	// íàøëè çàêîí äëÿ êîðîòêîçàìêíóòîé âåòâè,íàøëè çàêîí èç 0 âåòâåé
            	branches_1==0 || branches_2==0){// èëè çàêîí âêëþ÷àþùèé âåòâè òîëüêî îäíîãî îúåêòà
               Loop = true; // ïîâòîðèì ðàñ÷åò äëÿ ýòèõ îáúåäèíÿåìûõ âåòâåé èçìåíèâ óçëà À è/èëè Â
            	node_B++;
               if(node_B >= Element[Obj2]->Nodes){
               	node_B = 0;
               	node_A++;
               	}
               }
            else
            	Loop = false;	// íàéäåííûé çàêîí óäîâëåòâîðÿåò âñåì óñëîâèÿì, èäåì ê äðóãîé ïàðå îáúåäèíÿåìûõ óçëîâ
         	}while( Loop && node_A<Element[Obj1]->Nodes);  // <=1
         //PType t1[8000];
         if(branches > 1){    // >1
            for(unsigned i=0;i<v;i++) {(*N)[nd][i] = Way[0][i];}//  t1[i]= Way[0][i];}
         	nd++;	// çàïèøåì åùå îäíî óðàâíåíèå ïî 2 çàêîíó Êèðõãîôà
         	}
         if (nd == N->Rows) break; // óðàâíåíèé äîñòàòî÷íî
         } */
   	}
   // 2 çàêîí êèðõãîôà äëÿ êîðîòêîçàìêíóòûõ âåòâåé (åñëè íå õâàòàåò óðàâíåíèé) - â íîðìàëüíîì ðåæèìå äîëæíî õâàòàòü
   if( nd < N->Rows ){
   	unsigned num_use_SB = N->Rows - nd;
      if( num_use_SB>num_Short_Branch ) num_use_SB = num_Short_Branch;
   	for(unsigned i=0; i<num_use_SB;i++){
      	(*N)[nd][ Short_Branch[i] ] = 1;
      	nd++; // çàïèøåì ñëåäóþùåå óðàâíåíèå
      	}
   	}
   delete [] Short_Branch;
   if(nd < N->Rows) {err(0, "PGrid::Link_Elements: íå óäàëîñü ñîñòàâèòü äîñòàòî÷íîå êîëè÷åñòâî óðàâíåíèé ïî 2 çàêîíó Êèðõãîôà");}
   // ìàòðèöà óçëîâûõ òîêîâ è ìàòðèöà ïîòåíöèàëîâ
   _J = new PType[u];
   J = new PType*[u];
   for(unsigned j=0;j<u;j++) {_J[j]=0; J[j]=&_J[j];}
   // îáíóëÿåì ìàòðèöó ïîòåíöèàëîâ
   f = new PType*[u];
   for(unsigned j=0;j<u;j++) {f[j]=NULL;}
   for(unsigned b=0; b<numElement; b++){
      PElement *p = Element[b];
      unsigned tmp_rows = p->Nodes();
      for(unsigned i=0; i<tmp_rows; i++){
         unsigned nd = Node_From_LocalNode(b,i);
         (*J[nd]) += *(p->J[i]);	// åñëè óçëû áûëè îáúåäèíåíû, òî èõ çàäàþùèå òîêè ñêëàäûâàþòñÿ
         if( f[nd]==NULL )
            f[nd] = p->f[i];
         else  // i-ûé óçåë ýëåìåíòà p óæå óêàçûâàåò íà óçåë äðóãîãî ýëåìåíòà_2 (îíè ñâÿçàíû)
         	p->f[i] = f[nd];	// òîãäà ïîòåíöèàë i-îãî óçåëà ýëåìåíòà p, áóäåò ðàâåí ïîòåíöèàëó óçëà ýëåìåíòà_2
      	}
      }

   // ìàòðèöà äèôôåðåíöèàëüíûõ ñîïðîòèâëåíèé, íà÷àëüíûõ óñëîâèé
   // ìàòðèöà ýäñ â âåòâÿõ
   E = new PType*[v];
   // ìàòðèöà äèôôåðåíöèàëüûõ ñîïðîòèâëåíèé
   Z = new PType*[v];
   // íàïðÿæåíèé íà åìêîñòÿõ â âåòâÿõ (íà÷àëüíûå óñëîâèÿ)
   U_C= new PType*[v];
   // íàïðÿæåíèé íà èíäóêòèâíîñòÿõ â âåòâÿõ (íà÷àëüíûå óñëîâèÿ)
   U_L= new PType*[v];
   // íàïðÿæåíèé íà îáóçëîâëåííûå âçàèìîèíäóêòèâíîñòÿìè â âåòâÿõ (íà÷àëüíûå óñëîâèÿ)
   U_Lm= new PType*[v];
   // äðîññåëè â âåòâÿõ
   D = new Throttle*[v];
   // íàïðÿæåíèé íà äðîñåëëÿõ â âåòâÿõ
   U_D= new PType*[v];
   // ìàòðèöà ðåçóëüòàòîâ
   I = new PType*[v];
   R = new PType*[v];
   L = new PType*[v];
   C = new PType*[v];
   _Lm.clear();
	_Lm.push_back(0);
   //Lm = new vector<PType>::iterator *[v];  for(unsigned i=0;i<v;i++)Lm[i] = new vector<PType>::iterator [v];
   Lm = new PType **[v];  for(unsigned i=0;i<v;i++)Lm[i] = new PType*[v];
      const PType *first = _Lm.begin();
      for(unsigned i=0;i<v;i++)
         for(unsigned j=0;j<v;j++)
            Lm[i][j] = (PType*)first;  // ïî óìîë÷àíèþ ññûëàåìñÿ íà ëîêàëüíóþ ìàòðèöó âçàèìîèíäóêòèâíîñòåé
   for(unsigned b=0; b<numElement;b++){
   	PElement *p = Element[b];
      //p->accept(); // <-- îíà äîëæíà âûçûâàòüñÿ äî ñáîðêè ñåòè, ò.ê. îíà ìîæåò
      					// èçìåíÿòü âíóòðåííèå ñâÿçè, íåîáõîäèìûå ïðè ñáîðêå ñåòè
                     // (íàïð òðåõôàçíûé òðàíñ. PTransformer_3). Çäåñü âûçûâàòü íåò åå ñìûñëà
      ((PUnit*)p)->update_differential_resistance(); // ïåðåñ÷åò ìàòðèöû Z - àòî íå äàé áîã çàáûëè
      unsigned tmp_cols = p->Branches();
      for(unsigned j=0; j<tmp_cols; j++){
         unsigned br = Branch_From_LocalBranch(b,j);
         E[br] = p->E[j];
         Z[br] = p->Z[j];      // ìàòðèöà äèôôåðåíöèàëüíûõ ñîïðîòèâëåíèé
         U_C[br] = p->U_C[j];  // íàïðÿæåíèé íà åìêîñòÿõ â âåòâÿõ (íà÷àëüíûå óñëîâèÿ)
         U_L[br] = p->U_L[j];  // íàïðÿæåíèé íà èíäóêòèâíîñòÿõ â âåòâÿõ (íà÷àëüíûå óñëîâèÿ)
         U_Lm[br] = p->U_Lm[j];// íàïðÿæåíèé íà îáóçëîâëåííûå âçàèìîèíäóêòèâíîñòÿìè â âåòâÿõ (íà÷àëüíûå óñëîâèÿ)
         D[br] = p->D[j];      // äðîññåëü â âåòêå
         U_D[br] = p->U_D[j];  // íàïðÿæåíèé íà äðîñåëëÿõ â âåòâÿõ
         I[br] = p->I[j];      // ðåçóëüòàòû ðàñ÷åòà òîêîâ
         R[br] = p->R[j];      // àêòèâíîå ñîïðîòèâîåíèå âåòâè
         L[br] = p->L[j];      // èíäóêòèâíîñòü âåòâè
         C[br] = p->C[j];      // åìêîñòü âåòâè
         for(unsigned k=0;k<tmp_cols;k++){
            unsigned br2 = Branch_From_LocalBranch(b,k);
            Lm[br][br2] = p->Lm[j][k];  // âçàèìîèíäóêòèâíîñòü ìåæäó âåòâÿìè (ññûëàåìñÿ íà _Lm ïåðâîíà÷àëüíîãî îáúåêòà, íî ïðè èñïîëüçîâàíèè mutual_inductence áóäåì ñîçäàâàòü çíà÷åíèå ñâîåì âåêòîðå _Lm è ññûëàòüñÿ íà íåãî)
            }
      	}
      }
   // çíà÷åíèÿ ïðåäøåñòâóþùåãî òîêà
   _I2= new PType[v];
   for(unsigned i=0;i<v;i++)
        _I2[i] = *I[i];

   update_sources(true); // ïðèíóäèòåëüíî îáíîâëÿåì çíà÷åíèÿ
   update_elements(true);  // ïðèíóäèòåëüíî îáíîâëÿåì çíà÷åíèÿ
   // Ñîçäàäèì ãðóïïû âûâîäîâ
   for(unsigned b=0; b<numElement;b++){
   	PElement *p = Element[b];
      for(unsigned j=0, n=p->Out.Count(); j<n; j++){
         Pins *unit_pins = &p->Out[j];                	// ýòî ãðóïïà âûâîäîâ èñõîäíîãî îáúåêòà
         Pins *grid_pins = new Pins(*unit_pins);     		// ñîçäàåì Ãðóïïó âûâîäîâ äëÿ ñåòè êàê êîïèþ
         grid_pins->Name = p->FullName() + "." + unit_pins->Name; // ìåíÿåì èìÿ
         Out.add(grid_pins); 										// äîáàâëÿåì ãðóïïó âûâîäîâ â ñïèñîê
      	}
      }
   return true;
}
//---------------------------------------------------------------------------
PGrid::~PGrid(){
   // ÷èñòèì ïàìÿòü, âûäåëåííóþ ïîä ïåðåìåííûå
   delete A;      A = NULL;
   delete [] B;   B = NULL;
   delete F;      F = NULL;
   delete [] _J;  _J= NULL;
   if(Branch!=NULL)
      for(unsigned j=0;j<numElement;j++)
         delete [] Branch[j];
   delete [] Branch; Branch = NULL;
   if(Node!=NULL)
      for(unsigned j=0;j<numElement;j++)
         delete [] Node[j];
   delete [] Node;      Node = NULL;
   delete [] Element;   Element = NULL;
   delete [] Links;     Links = NULL;
   delete [] U;         U = NULL;
   delete [] _U_Lm2;    _U_Lm2 = NULL;
   delete [] U_Lm2;      U_Lm2 = NULL;
   delete [] _I2;       _I2 = NULL;
   // óäàëÿåì äèíàìè÷åñêè ñîçäàííûå ãðóïïû âûâîäîâ
   for(unsigned i=0, n=Out.Count(); i<n; i++)
   	delete &Out[i];
}
//---------------------------------------------------------------------------
/* Íàõîäèò âñå óçëû îáúåäèíåííûå ñ çàäàííûì
   numLink  - ÷èñëî ñâÿçåé
   Link[][2][2] - îïèñàíèå ñâÿçåé
   link_use[] - ñâÿçü îáðàáîòàíà èëè íåò?
   i_node - íîìåð óçëà ñåòè, êîòîðûé ïðèñâàèâàåòñÿ âñåì îáúåäèíÿåìûì óçëàì (òåêóùåå ÷èñëî âåðøèí â ðåçóëüòèðóþùåé ìàòðèöå)
   obj, node - ñâÿçü ñ êàêîé âåðøèíîé èùåì
*/
void PGrid::linked_nodes(const unsigned numLink, const unsigned Link[][2][2], bool link_use[],const unsigned i_node,const unsigned obj,const unsigned node){//, unsigned &tmp){
   for(unsigned j=0; j<numLink; j++){
   	if( ! link_use[j] ){
      	if( Link[j][0][0] == obj && Link[j][0][1] == node ){ // åñëè òåêóùèé óçåë îáúåäèíÿåì ñ íèì
         	// ñ íèì ñâÿçàííûé
            Node[  Link[j][1][0]  ][  Link[j][1][1]  ] = i_node;
            link_use[j]=true;  // ñâÿçü îáðàáîòàíà
            // êàêèå ñ ýòèì ñâÿçàííû?
            linked_nodes(numLink, Link, link_use, i_node, Link[j][1][0], Link[j][1][1]);
            }
         else if( Link[j][1][0] == obj && Link[j][1][1] == node ){ // åñëè òåêóùèé óçåë îáúåäèíÿåì ñ íèì
         	// ñ íèì ñâÿçàííûé
            Node[  Link[j][0][0]  ][  Link[j][0][1]  ] = i_node;
            link_use[j]=true;  // ñâÿçü îáðàáîòàíà
            // êàêèå ñ ýòèì ñâÿçàííû?
            linked_nodes(numLink, Link, link_use, i_node, Link[j][0][0], Link[j][0][1]);
            }
         }
      }
}
//---------------------------------------------------------------------------
/* Âîçâðàùàåò íîìåð ãëîáàëüíîé âåðøèíû ïî íîìåðó îáúåêòà â ñåòè è íîìåðó åãî ëîêàëüíîé âåðøèíû   */
unsigned __fastcall PGrid::Node_From_LocalNode(unsigned Obj, unsigned LocalNode) { return Node[Obj][LocalNode]; }
//---------------------------------------------------------------------------
/*  Âîçâðàùàåò íîìåð ãëîáàëüíîé âåòâè ïî íîìåðó îáúåêòà â ñåòè è íîìåðó åãî ëîêàëüíîé âåòâè  */
unsigned __fastcall PGrid::Branch_From_LocalBranch(unsigned Obj, unsigned LocalBranch){ return Branch[Obj][LocalBranch]; }
//---------------------------------------------------------------------------
unsigned PGrid::ObjNum_From_Object(PElement *obj){
   for(unsigned i=0; i<numElement; i++)
      if( Element[i] == obj )
         return i;
   return -1;  // íåò îáúåêòà â ñïèñêå
}
//---------------------------------------------------------------------------
/* Âîçâðàùàåò íîìåð ãëîáàëüíîé âåðøèíû ïî íîìåðó îáúåêòà â ñåòè è íîìåðó åãî ëîêàëüíîé âåðøèíû   */
unsigned __fastcall PGrid::Node_From_LocalNode(PElement* Obj, unsigned LocalNode) {
   unsigned obj_num = ObjNum_From_Object(Obj);
   if(obj_num == -1) return -1;
   return Node[obj_num][LocalNode];
}
//---------------------------------------------------------------------------
/*  Âîçâðàùàåò íîìåð ãëîáàëüíîé âåòâè ïî íîìåðó îáúåêòà â ñåòè è íîìåðó åãî ëîêàëüíîé âåòâè  */
unsigned __fastcall PGrid::Branch_From_LocalBranch(PElement* Obj, unsigned LocalBranch){
   unsigned obj_num = ObjNum_From_Object(Obj);
   if(obj_num == -1) return -1;
   return Branch[obj_num][LocalBranch];
}
//---------------------------------------------------------------------------
bool PGrid::Make_Equation(){
   if( !BuildOK ){
      err(0, "PGrid: óðàâíåíèÿ äëÿ ñåòè íå ñîñòàâëåíû, ò.ê. ñåòü áûëà ñîáðàíà ñ îøèáêàìè");
      return false;
      }
   // èíèöèàëèçèðóåì ìàòðèöû ïî óðàâíåíèÿì êèðõãîôà
   unsigned n = u-1+k;
   if( n != v) {err(0, "PGrid::Make_Equation: ÷èñëî óðàâíåíèé ïî çàêîíàì Êèðõãîôà íå ðàâíî ÷èñëó âåòâåé. Îøèáêà â êîäå.");}
   A = new Matrix<PType>(n, v);
   B = new PType[v];  	// ïî ÷èñëó óðàâíåíèé == ÷èñëó âåòâåé
   U = new PType[v];	// ïàäåíèÿ íàïðÿæåíèé â âåòâÿõ
   F = new Matrix<PType>( M->Rows-1, M->Cols );
   _U_Lm2 = new PType[v];  		// ïàäåíèÿ íàïðÿæåíèé íà âçàèìîèíäóêòèâíîòÿõ îò òåêóùåãî òîêà
   U_Lm2 = new PType*[v];  		// ïàäåíèÿ íàïðÿæåíèé íà âçàèìîèíäóêòèâíîòÿõ îò òåêóùåãî òîêà
   for(unsigned i=0;i<v;i++) _U_Lm2[i]=0;
   for(unsigned i=0;i<v;i++) U_Lm2[i]=&_U_Lm2[i];

   // çàïîëíÿåì ìàòðèöó A ïî óðàâíåíèÿì ñîñòîÿíèÿ
   Update_Equation();

   // ïîëó÷àåì ìàòðèöó äëÿ íàõîæäåíèÿ ïîòåíöèàëîâ
   Matrix<PType> *tmp = new Matrix<PType>( M->Rows, M->Rows-1 );
   bool *deleted_branch = new bool[M->Cols];
   Copy_Matrix( & M->tree(deleted_branch), tmp);
   //bool as[8];for(int i=0;i<M->Cols;i++) as[i]=deleted_branch[i];
   tmp->Delete_Row((unsigned)(tmp->Rows-1));
   *tmp = -1.0*(tmp->transpose().inverse());

   for(unsigned j=0, k=0; j<F->Cols; j++)
   	if( deleted_branch[j] ){
         // âåòêà áûëà óäàëåíà ïðè ñîñòàâëåíèè ìàòðèöû tmp
         for(unsigned i=0; i<F->Rows; i++) (*F)[i][j] = 0;
      	}
      else{ // âåòêà áûëà ñîõðàíåíà ïðè ïîñòðîåíèè ìàòðèöû tmp
   		for(unsigned i=0; i<F->Rows; i++) (*F)[i][j] = (*tmp)[i][k];
         k++; // áåðåì ñëåäóþùóþ âåòêó â ìàòðèöå tmp
         }
   delete tmp;
   delete [] deleted_branch;
   return true;
}
//---------------------------------------------------------------------------
void PGrid::Update_Equation(){
   // èíèöèàëèçèðóåì ìàòðèöû ïî óðàâíåíèÿì êèðõãîôà
   unsigned n = u-1+k;
   if( n != v) {err(0, "PGrid::Update_Equation: ÷èñëî óðàâíåíèé ïî çàêîíàì Êèðõãîôà íå ðàâíî ÷èñëó âåòâåé. Îøèáêà â êîäå.");}
   // çàïîëíÿåì ìàòðèöû ïî óðàâíåíèÿì Êèðõãîôà
   // 1 çàêîí Êèðõãîôà
   for(unsigned i=0; i<u-1; i++)
   	for(unsigned j=0; j<v; j++)
      	(*A)[i][j]= (*M)[i][j];
   // ó÷åò âçàèìîèíäóêòèâíîñòè äëÿ 2 çàêîíà Êèðõãîôà
   Matrix<PType> *Nm = new Matrix<PType>(k,v);
   *Nm = (1/smp) * Multiply_Matrix(N, Lm, v, v);
/*PType t0[3][3];
for(int i=0;i<2;i++)
	for(int j=0;j<3;j++)
   	t0[i][j] = (*N)[i][j];*/

   // 2 çàêîí Êèðõãîôà
   for(unsigned i=0; i<k; i++)
   	for(unsigned j=0; j<v; j++)
     	(*A)[i+u-1][j]= (*N)[i][j]*(*Z[j]) + (*Nm)[i][j];
   delete Nm;

   // ó÷åò äðîññåëåé
   for(unsigned j=0; j<v; j++)
      if( D[j]!=NULL ){ // âåòâü â êîòîðîé óñòàíîâëåí äðîññåëü
      // ìàãíèòíàÿ âåòêà
      unsigned br = Branch_From_LocalBranch(D[j]->Obj, D[j]->MBranch);
      // ïîèñê óðàâíåíèé â êîòîðûå âõîäèò âåòêà ñ äðîññåëåì
      for(unsigned i=0; i<k; i++){
         if( (*N)[i][j] != 0 ){  // óðàâíåíèå â êîòîðóþ âõîäèò âåòêà ñ äðîññåëåì
            int sgn_for_branch = (*N)[i][j];               // âåòêà ñîíàïðàâëåíà èëè ïðîòèâîíàïðàâëåíà ñ êîíòóðîì
            (*A)[i+u-1][br] += sgn_for_branch * D[j]->Windings / smp;  // ó÷åò âëèÿíèÿ ïîòîêà â ìàãíèòîïðîâîäå íà ýòó âåòêó
            }
      	// ïîèñê óðàâíåíèé, â êîòîðûå âõîäèò ìàãíèòíàÿ âåòâü
         if( (*N)[i][br] != 0 ){  // óðàâíåíèå â êîòîðóþ âõîäèò âåòêà ñ äðîññåëåì
            int sgn_for_branch = (*N)[i][br];      // âåòêà ñîíàïðàâëåíà èëè ïðîòèâîíàïðàâëåíà ñ êîíòóðîì
            (*A)[i+u-1][j] += - sgn_for_branch * D[j]->Windings;	// ó÷åò ÌÄÑ
         	}
         }
      }
   //Matrix<PType> R1(*A);
   *A = A->inverse();
   /*
   R1=(*A) * R1;
   unsigned NotNull=0;
   //PType Sum=0;
   //PType t0[3][3];
   for(unsigned i=0;i<A->Cols; i++)
      for (unsigned j=0; j<A->Rows; j++){
      	if(R1[i][j]>0.01)
            NotNull++;
         //Sum += fabs(R1[i][j]);
         //t0[i][j] = R1[i][j];
         }
   if(NotNull != A->Rows)
      err(0,"PGrid::Update_Equation(): Îáðàòíàÿ ìàòðèöà íàéäåíà ñ ïîãðåøíîñòüþ áîëåå 1%.");
   */
}
//---------------------------------------------------------------------------
// îáíîâëÿåì èíôîðìàöèþ îá èñòî÷íèêà òîêà è ÇÄÑ â âåòâÿõ
bool PGrid::update_sources(bool force_update){
   bool ret=false;
   //PType i = *Element[0]->I[1];
   for(unsigned i=0; i<numElement; i++){
      bool ret2 = Element[i]->update_sources(force_update);
      ret = ret | ret2;
      }
   // åñëè îáíîâèëèñü
   if(ret || force_update){
      // ìàòðèöà óçëîâûõ òîêîâ
      for(unsigned j=0;j<u;j++) *J[j]=0;
      for(unsigned b=0; b<numElement; b++){
         PElement *p = Element[b];
         unsigned tmp_rows = p->Nodes();
         for(unsigned i=0; i<tmp_rows; i++){
            unsigned nd = Node_From_LocalNode(b,i);
            (*J[nd]) += *(p->J[i]);	// åñëè óçëû áûëè îáúåäèíåíû, òî èõ çàäàþùèå òîêè ñêëàäûâàþòñÿ
      	   }
         }
      }
   return ret;
}
//---------------------------------------------------------------------------
// îáíîâëÿåì èíôîðìàöèþ î ïàäåíèè íàïðÿæåíèé â âåòâÿõ (ó÷åò íåëèíåéíûõ ýëåìåíòîâ)
bool PGrid::update_elements(bool force_update){
   bool ret=false;
   for(unsigned i=0; i<numElement; i++){
      bool  ret_i = Element[i]->update_elements(force_update);
      if(ret_i) Element[i]->update_differential_resistance();  // åñëè ïîìåíÿëèñü ñîïðîòèâëåíèÿ, èçìåíèì çíà÷åíèÿ äèôôåðåíöèàëüíûõ ñîïðîòèâëåíèé
                                                               // ó ýëåìåíòà. À òàê êàê ñåòü èñïîëüçóåò óêàçàòåëè íà çíà÷åíèÿ ñîïðîòèâëåíèé ó
                                                               // îáúåêòîâ, òî ïîìåíÿþòñÿ äèôôåðåíöèàëüíûå ñîïðîòèâëåíèÿ è âåòâåé ñåòè
      ret = ret | ret_i;
      }
   return ret;
}
//---------------------------------------------------------------------------
PElement* PGrid::obj_from_name(String Name){
   String obj, Child;   // îáúåêò è îáúåêò êîòîðûé â íåãî âõîäèò, íàïðèìåð ÎÝÑ.Ñåòü2.T2
   // çàçäåëÿåì èìÿ äî ïåðâîé òî÷êè
   int point=Name.Pos(".");
   if(point!=0){
      obj = Name.SubString(1,point-1);
      Child = Name.SubString(point+1, Name.Length()-point);
   }else{
      obj = Name;
      Child = "";
      }
   for(unsigned i=0; i<numElement;i++)
      if(Element[i]->Name == obj){   // íàøëè îáúåêò
         if(Child!="")  // èùåì îáúåêò êîòîðûé â íåãî âõîäèò
            return ((PGrid*)Element[i])->obj_from_name(Child);
         else
            return Element[i];
         }
   return NULL;   // íå íàøëè îáúåêò ñ ýòèì èìåíåì
}
/*/---------------------------------------------------------------------------
void PGrid::calc(){
   // îáíîâëÿåì èíôîðìàöèþ îá èñòî÷íèêà òîêà è ÇÄÑ â âåòâÿõ
   update_sources();
   // îáíîâëÿåì èíôîðìàöèþ î ñîïðîòèâëåíèè âåòâåé
   bool elm = update_elements();
   // åñëè èçìåíèëèñü ñîïðîòèâëåíèÿ ýëåìåíòîâ, òî ìåíÿþòñÿ óðàâíåíèÿ ñîñòîÿíèÿ
   if( elm ) Update_Equation();
	// íà îñíîâàíèè î òîêàõ ïðåäøåñòâóþùåãî ðåæèìà ðàññ÷èòàåì ýäñ íà åìêîñòÿõ (íà÷àëüíûå óñëîâèÿ)
   for(unsigned i=0; i<v; i++)
 		if(*C[i])*U_C[i] = *U_C[i] + *I[i]*smp/(*C[i]);
		else *U_C[i]=0;
   // íà îñíîâàíèè ïðåäøåñòâóþùåãî ðåæèìà ðàññ÷èòàåì ýäñ â èíäóêòèâíîñòÿõ (íà÷àëüíûå óñëîâèÿ)
   for(unsigned i=0; i<v; i++)
		*U_L[i] = *L[i]*(*I[i])/smp;
   // íà îñíîâàíèè ïðåäøåñòâóþùåãî ðåæèìà ðàññ÷èòàåì äîïîëíèòåëüíóþ ýäñ âî âçàèìîèíäóêòèâíûõ ýëåìåíòàõ(íà÷àëüíûå óñëîâèÿ)
   for(unsigned int j=0; j<v; j++)
   	(*U_Lm[j]) = *U_Lm2[j];
   // ðàññ÷åò ìàòðèöû B èç óðàâíåíèÿ A*I=B
   for(unsigned i=0; i<u-1; i++)
      B[i] = *J[i];	// ïðàâûå ÷àñòè óðàâíåíèé ïî 1 çàêîíó Êèðõãîôà
	for(unsigned i=u-1; i<v; i++){
   	B[i] = 0;
   	for(unsigned j=0; j<v; j++)
			B[i] += (*N)[i-u+1][j]*((*E[j])+(*U_L[j])-(*U_C[j])+(*U_Lm[j])); // ïðàâûå ÷àñòè ïî 2 çàêîíó Êèðõãîôà
      }

   // ðàñ÷åò íîâûõ çíà÷åíèé òîêîâ I=A*B
   Multiply_Matrix( A, B, I);

   // Ðàçíîñòü ïîòåíöèàëîâ â âåòâÿõ
   for(unsigned i=0; i<v; i++){
   	U[i] = (*Z[i])*(*I[i]) - (*E[i]) - (*U_L[i]) + (*U_C[i]) - (*U_Lm[i]); // Z âêëþ÷àåò ïàäåíèÿ íàïðÿæåíèÿ íà åìê è èíä, íî íå âêëþ÷àåò ïàäåíèå íàïðÿæåíèÿ íà âçàèìîèíä (ó÷òåì íèæå)
      // ïàäåíèÿ íàïðÿæåíèÿ íà âçàèìîèíäóêòèâíîñòÿõ îò òåêóùåãî òîêà
      *U_Lm2[i]=0;
   	for(unsigned int j=0; j<v; j++)
			(*U_Lm2[i]) += (*Lm[i][j])/smp * (*I[j]);
      // ó÷åò ýòîãî ïàäåíèÿ íàïðÿæåíèÿ
      U[i] += *U_Lm2[i];
      }
	// ðàñ÷åò ïîòåíöèàëîâ óçëîâ
   Multiply_Matrix( F, U, f);
   *f[u-1]=0; // ïîòåíöèàë ñàìîãî ïîñëåäíåãî óçëà == 0
}*/
//---------------------------------------------------------------------------
void PGrid::calc(){
   // îáíîâëÿåì èíôîðìàöèþ îá èñòî÷íèêà òîêà è ÇÄÑ â âåòâÿõ
   update_sources();
   // îáíîâëÿåì èíôîðìàöèþ î ñîïðîòèâëåíèè âåòâåé
   bool elm = update_elements();
   // åñëè èçìåíèëèñü ñîïðîòèâëåíèÿ ýëåìåíòîâ, òî ìåíÿþòñÿ óðàâíåíèÿ ñîñòîÿíèÿ
   if( elm ) Update_Equation();
	// íà îñíîâàíèè î òîêàõ ïðåäøåñòâóþùåãî ðåæèìà ðàññ÷èòàåì ýäñ íà åìêîñòÿõ (íà÷àëüíûå óñëîâèÿ)
   for(unsigned i=0; i<v; i++)
 		if(*C[i])*U_C[i] = *U_C[i] + smp/(*C[i])*(_I2[i] + *I[i])/2;
		else *U_C[i]=0;
   // íà îñíîâàíèè ïðåäøåñòâóþùåãî ðåæèìà ðàññ÷èòàåì ýäñ â èíäóêòèâíîñòÿõ (íà÷àëüíûå óñëîâèÿ)
   for(unsigned i=0; i<v; i++)
		*U_L[i] = *L[i]*(*I[i])/smp;
   // íà îñíîâàíèè ïðåäøåñòâóþùåãî ðåæèìà ðàññ÷èòàåì äîïîëíèòåëüíóþ ýäñ âî âçàèìîèíäóêòèâíûõ ýëåìåíòàõ(íà÷àëüíûå óñëîâèÿ)
   for(unsigned int j=0; j<v; j++)
   	(*U_Lm[j]) = *U_Lm2[j];
   // íà îñíîâàíèè ïðåäøåñòâóþùåãî ðåæèìà ðàññ÷èòàåì ÝÄÑ íà äðîññåëÿõ
   for(unsigned i=0; i<v; i++)
      if( D[i]!=NULL ){ // âåòêà, â êîòîðîé óñòàíîâëåí äðîññåëü
         // ìàãíèòíàÿ âåòêà, íà êîòîðóþ íàìîòàí äðîññåëü
         unsigned br = Branch_From_LocalBranch(D[i]->Obj, D[i]->MBranch);
         if(br!=-1) *U_D[i] = *I[br] * D[i]->Windings / smp;
         }
   // ðàññ÷åò ìàòðèöû B èç óðàâíåíèÿ A*I=B
   for(unsigned i=0; i<u-1; i++)
      B[i] = *J[i];	// ïðàâûå ÷àñòè óðàâíåíèé ïî 1 çàêîíó Êèðõãîôà
	for(unsigned i=u-1; i<v; i++){
   	B[i] = 0;
   	for(unsigned j=0; j<v; j++)
         B[i] += (*N)[i-u+1][j]*( (*E[j])+(*U_L[j])-(*U_C[j])+(*U_Lm[j])+(*U_D[j]) ); // ïðàâûå ÷àñòè ïî 2 çàêîíó Êèðõãîôà
         if(*C[i])    B[i] = B[i] - smp/(*C[i])/2*(*I[i]);
      }

   // ñîõðàíÿåì ïðåäøåñòâóþùèå çíà÷åíèÿ òîêà
   for(unsigned i=0; i<v;i++)
        _I2[i] = *I[i];

   // ðàñ÷åò íîâûõ çíà÷åíèé òîêîâ I=A*B
   Multiply_Matrix( A, B, I);

   // Ðàçíîñòü ïîòåíöèàëîâ â âåòâÿõ
   for(unsigned i=0; i<v; i++){
   	U[i] = (*Z[i])*(*I[i]) - (*E[i]) - (*U_L[i]) + (*U_C[i]) - (*U_Lm[i]) - (*U_D[i]); // Z âêëþ÷àåò ïàäåíèÿ íàïðÿæåíèÿ íà åìê, èíä è äðîññåëå, íî íå âêëþ÷àåò ïàäåíèå íàïðÿæåíèÿ íà âçàèìîèíä (ó÷òåì íèæå)
      if(*C[i])    U[i] = U[i] + smp/(*C[i])/2*_I2[i];
      // ïàäåíèÿ íàïðÿæåíèÿ íà âçàèìîèíäóêòèâíîñòÿõ îò òåêóùåãî òîêà
      *U_Lm2[i]=0;
   	for(unsigned int j=0; j<v; j++)
			(*U_Lm2[i]) += (*Lm[i][j])/smp * (*I[j]);
      // ó÷åò ýòîãî ïàäåíèÿ íàïðÿæåíèÿ
      U[i] += *U_Lm2[i];
      // ïàäåíèÿ íàïðÿæåíèÿ íà äðîññåëå îò òåêóùåãî òîêà
      if(D[i]!=NULL){
         unsigned br = Branch_From_LocalBranch(D[i]->Obj, D[i]->MBranch);
         U[i] += D[i]->Windings * (*I[br]) / smp;
         }
      }
	// ðàñ÷åò ïîòåíöèàëîâ óçëîâ
   Multiply_Matrix( F, U, f);
   *f[u-1]=0; // ïîòåíöèàë ñàìîãî ïîñëåäíåãî óçëà == 0

   /*/ âûáîð îïòèìàëüíîãî øàãà
   PType d = fabs(*I[0] - _I2[0]);
   if(d>0.001){
   	smp = smp/2;
      update_elements(true);
      Update_Equation();
      } */
   /*if(d<1e-17){
   	smp = smp*2;
      update_elements(true);
      Update_Equation();
      } */
}
//---------------------------------------------------------------------------
PElement* __fastcall PGrid::Unit(int Index) { return Element[Index];};
//---------------------------------------------------------------------------
unsigned  __fastcall PGrid::num_Units(){ return numElement; }
//---------------------------------------------------------------------------
void PGrid::Save(ostream &stream){
   // ñîõðàíÿåì äàííûå áàçîâîãî êëàññà
	sire::Save(stream);
   // ÷èñëî îáúåêòîâ
   stream << numElement << " ";
   // ñîõðàíÿåì îáúåêòû
   for(unsigned i=0; i<numElement; i++)
      SaveObj(Element[i], stream);
   // ÷èñëî ñâÿçåé
   stream << numLinks << " ";
   // ñîõðàíÿåì èíôîðìàöèþ î ñâÿçÿõ
   for(unsigned i=0; i<numLinks; i++){
      stream << Links[0+4*i] << " ";
      stream << Links[1+4*i] << " ";
      stream << Links[2+4*i] << " ";
      stream << Links[3+4*i] << " ";
   	}
   // ñîõðàíÿåì èíôîðìàöèþ î ãðóïïàõ âûâîäîâ
   String outs = getOuts();
   stream << StringForSave( &outs )  << " ";
}
//---------------------------------------------------------------------------
void PGrid::Read(istream &stream){
   // ÷èòàåì äàííûå áàçîâîãî êëàññà
	sire::Read(stream);
   PElement **el;
   unsigned *lnk;
   unsigned numEl;
   unsigned numLnk;
   // ÷èñëî îáúåêòîâ
   stream >> numEl;
   el = new PElement*[numEl];
   // ñîçäàåì îáúåêòû
   char cname[1024]; String ClassName;
   for(unsigned i=0; i<numEl; i++)
      el[i] = CreateObj( stream );
   // ÷èñëî ñâÿçåé
   stream >> numLnk;
   lnk = new unsigned[4*numLnk];
   // ñîõðàíÿåì èíôîðìàöèþ î ñâÿçÿõ
   for(unsigned i=0; i<numLnk; i++){
      stream >> lnk[0+4*i];
      stream >> lnk[1+4*i];
      stream >> lnk[2+4*i];
      stream >> lnk[3+4*i];
   	}
   // ïåðåä ñîçäàíèåì ñåòè ïðèìåíèì ïàðàìåòðû
   for(unsigned i=0; i< numEl; i++ ) el[i]->accept();
   // ñîçäàåì ýòó ñåòü
   Link_Elements(numEl, el, numLnk, (unsigned (*)[2][2])lnk );
   // óñòàíàâëèâàåì ãðóïïû âûâîäîâ
   char outs[1024];
   stream >> outs;
   setOuts( outs );
}
//---------------------------------------------------------------------------
String PGrid::ClassName(){ return "PGrid";}
//---------------------------------------------------------------------------
String PGrid::getOuts(){
	String strOuts = "";
   for(int i=0, n=Out.Count(); i<n; i++){
   	strOuts +=  Out[i].Name; //Out[i][0].Obj()->Name + "." + Out[i].Name;
      if( (i+1)<n ) strOuts += ";";
      }
	return strOuts;
}
//---------------------------------------------------------------------------
// ñòîðîêó ñîäåðæàùóþ ãðóïïó âûâîäîâ ïðåîáðàçóåì â ãðóïïû âûâîäîâ
void PGrid::setOuts(String strOut){
   // î÷èùàåì
   Out.Clear();    // ñïèñîê ãðóïï âûâîäîâ
   // î÷èùàåì ãðóïïû âûâîäîâ
   //for(int i=0, n=X.size(); i<n; i++) delete X[i];
   //X.clear();
   // íàõîäèì ãðóïïû âûâîäîâ
	vector<String> Point;
	// âîçìîæíî áûëî áîëåå îäíîãî ïðîáåëà â íà÷àëå
   int numSpace, m;
   for(numSpace=1, m=strOut.Length(); numSpace<=m; numSpace++) if(strOut[numSpace]!=' ') break;
   strOut = strOut.SubString(numSpace, strOut.Length() - numSpace + 1);
   int pos = strOut.Pos(";");
   while( pos ){
   	Point.push_back( strOut.SubString(1,pos-1) );
      strOut = strOut.SubString(pos+1, strOut.Length()-pos);
      // âîçìîæíî áûëî áîëåå îäíîãî ïðîáåëà
      for(numSpace=1, m=strOut.Length(); numSpace<=m; numSpace++) if(strOut[numSpace]!=' ') break;
      strOut = strOut.SubString(numSpace, strOut.Length() - numSpace + 1);
      pos = strOut.Pos(";");
      }
   Point.push_back( strOut.SubString(1,strOut.Length()) );
   // ïåðåáèðàåì êàæäóþ ãðóïïó âûâîäîâ
   String obj, outName;   // îáúåêò è îáúåêò êîòîðûé â íåãî âõîäèò, íàïðèìåð ÎÝÑ.Ñåòü2.T2
   for(unsigned i=0, n=Point.size(); i<n; i++){
   	// çàçäåëÿåì èìÿ äî ïåðâîé òî÷êè
   	int point=Point[i].Pos(".");
   	if(point!=0){
      	obj =Point[i].SubString(1,point-1);
      	outName = Point[i].SubString(point+1, Point[i].Length()-point);
         PElement *Obj = obj_from_name(obj);
         if(Obj){
         	// äîáàâëÿåì ãðóïïó âûâîäîâ ýòîãî îáúåêòà
            for(unsigned j=0, m=Obj->Out.Count(); j<m; j++)
               if(Obj->Out[j].Name == outName){
                  set_pins( Obj, &Obj->Out[j] );
            		}
            }
			}
      }
}
//---------------------------------------------------------------------------
void PGrid::set_pins(PElement* Obj, Pins* pins){
   // ñîçäàäèì ãðóïïó âûâîäîâ
   Pins *x = new Pins( pins->Count );
   x->Name = Obj->Name + "." + pins->Name;
   // ñîçäàäèì âûâîäû óêàçûâàþùèå íà ñåòü
   for(int i=0, n=pins->Count; i<n; i++){
      PPin tmp_pin;
      unsigned node = Node_From_LocalNode( (*pins)[i].Obj(), (*pins)[i].Node() );
      // åñëè òàêîé óçåë íàéäåí
      if(node != -1)
         tmp_pin = set_pin( node );
      else{
         err(0, "PGrid: óçåë íå íàéäåí â ñåòè");
         tmp_pin = set_pin( Grounded_Node );
         }
      (*x)[i] = tmp_pin;
      }
   Out.add( x );
}
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------









//---------------------------------------------------------------------------
PSubGrid::PSubGrid(){
	Describe_Fields(); // îïèøåì ïîëÿ
   Name = "Ñåòü";
}
//---------------------------------------------------------------------------
void PSubGrid::Describe_Fields(){
   PFieldInfo fi;
   // ñîïðîòèâëåíèå âî âêëþ÷. ñîñòîÿíèè
   fi.Name = "Ãðóïïû âûâîäîâ";
   fi.Type = "Pins_List";
   fi.ptr = (void*)this;
   fi.Mode = ro;
   Fields.push_back(fi);
}
//---------------------------------------------------------------------------
PElement* __fastcall PSubGrid::Unit(int Index) { return Element.at(Index);};
//---------------------------------------------------------------------------
unsigned  __fastcall PSubGrid::num_Units(){ return Element.size(); } 
//---------------------------------------------------------------------------
void PSubGrid::Save(ostream &stream){
   // ñîõðàíÿåì äàííûå áàçîâîãî êëàññà
	sire::Save(stream);
}
//---------------------------------------------------------------------------
void PSubGrid::Read(istream &stream){
   // ÷èòàåì äàííûå áàçîâîãî êëàññà
	sire::Read(stream);
}
//---------------------------------------------------------------------------
String PSubGrid::ClassName(){ return "PSubGrid";}
//---------------------------------------------------------------------------
String PSubGrid::getOuts(){
	String strOuts = "";
   for(int i=0, n=Out.Count(); i<n; i++){
   	strOuts +=  Out[i][0].Obj()->Name + "." + Out[i].Name;
      if( (i+1)<n ) strOuts += ";";
      }
	return strOuts;
}
//---------------------------------------------------------------------------
// ñòîðîêó ñîäåðæàùóþ ãðóïïó âûâîäîâ ïðåîáðàçóåì â ãðóïïû âûâîäîâ
void PSubGrid::setOuts(String strOut){
   // î÷èùàåì
   Out.Clear();    // ñïèñîê ãðóïï âûâîäîâ
   // íàõîäèì ãðóïïû âûâîäîâ
	vector<String> Point;
	// âîçìîæíî áûëî áîëåå îäíîãî ïðîáåëà â íà÷àëå
   int numSpace, m;
   for(numSpace=1, m=strOut.Length(); numSpace<=m; numSpace++) if(strOut[numSpace]!=' ') break;
   strOut = strOut.SubString(numSpace, strOut.Length() - numSpace + 1);
   int pos = strOut.Pos(";");
   while( pos ){
   	Point.push_back( strOut.SubString(1,pos-1) );
      strOut = strOut.SubString(pos+1, strOut.Length()-pos);
      // âîçìîæíî áûëî áîëåå îäíîãî ïðîáåëà
      for(numSpace=1, m=strOut.Length(); numSpace<=m; numSpace++) if(strOut[numSpace]!=' ') break;
      strOut = strOut.SubString(numSpace, strOut.Length() - numSpace + 1);
      pos = strOut.Pos(";");
      }
   Point.push_back( strOut.SubString(1,strOut.Length()) );
   // ïåðåáèðàåì êàæäóþ ãðóïïó âûâîäîâ
   String obj, outName;   // îáúåêò è îáúåêò êîòîðûé â íåãî âõîäèò, íàïðèìåð ÎÝÑ.Ñåòü2.T2
   for(unsigned i=0, n=Point.size(); i<n; i++){
   	// çàçäåëÿåì èìÿ äî ïîñëåäíåé òî÷êè
      int point=Point[i].Pos(".");
      //for(int i=Point[i].Pos("."); i!=0; i=Point[i].Pos(".")) point = i;
   	if(point!=0){
      	obj =Point[i].SubString(1,point-1);
      	outName = Point[i].SubString(point+1, Point[i].Length()-point);
         PElement *Obj = obj_from_name(obj);
         if(Obj){
         	// äîáàâëÿåì ãðóïïó âûâîäîâ ýòîãî îáúåêòà
            for(unsigned j=0, m=Obj->Out.Count(); j<m; j++)
               if(Obj->Out[j].Name == outName)
                  Out.add( &Obj->Out[j] );
            }
			}
      }
}
//---------------------------------------------------------------------------
PElement* PSubGrid::obj_from_name(String Name){
   String obj, Child;   // îáúåêò è îáúåêò êîòîðûé â íåãî âõîäèò, íàïðèìåð ÎÝÑ.Ñåòü2.T2
   // çàçäåëÿåì èìÿ äî ïåðâîé òî÷êè
   int point=Name.Pos(".");
   if(point!=0){
      obj = Name.SubString(1,point-1);
      Child = Name.SubString(point+1, Name.Length()-point);
   }else{
      obj = Name;
      Child = "";
      }
   for(unsigned i=0, n=Element.size(); i<n; i++)
      if(Element[i]->Name == obj){   // íàøëè îáúåêò
         if(Child!="")  // èùåì îáúåêò êîòîðûé â íåãî âõîäèò
            return ((PSubGrid*)Element[i])->obj_from_name(Child);
         else
            return Element[i];
         }
   return NULL;   // íå íàøëè îáúåêò ñ ýòèì èìåíåì
}
//---------------------------------------------------------------------------
// óñòàíîâèòü îïèñàíèå ñåòè
bool PSubGrid::Change( Pins_Link &InLink, vector<PSubGrid*> SubGrids ){
   // ìû íå ÿâëÿåìñÿ ñåòüþ äëÿ ýëåìåíòîâ, êîòîðûå ìû "çàáûâàåì"
   for(unsigned i=0, n=Element.size(); i<n; i++)
   	if(Element[i]->Grid==this)
   		Element[i]->Grid = NULL;
   // "çàáóäåì" ïðåäøåñòâóþùèå ýëåìåíòû
   Element.clear();
   // çàïîìíèì ñâÿçè
   Internal_Links = InLink;
   // çàïîìíèì ïîäñåòè
   for(int i=0, n=SubGrids.size(); i<n; i++){
      PSubGrid *sg = SubGrids[i];
      // äîáàâèì, åñëè ýëåìåíò óæå íå äîáàâëåí
      int i;
      int n=Element.size();
      for(i=0; i<n; i++) if( Element[i]==sg ) break;
      if(i==n){
         if(sg->Grid == NULL )
         	sg->Grid = this;			// äîáàâëÿåìûé ýëåìåíò áóäåò îòíîñèòüñÿ ê ýòîé ñåòè
      	Element.push_back( sg );}
   	}
   // çàïîìíèì îáúåêòû ïîäñåòè
   for(int i=0, n=InLink.Number(); i<n; i++){
      PElement * A = InLink[i].First->Obj();
      PElement * B = InLink[i].Second->Obj();
      // çàïîìíèì ýëåìåíò À, åñëè îí íå ïîâòîðÿþùèéñÿ
      int i;
      int n=Element.size();
      for(i=0; i<n; i++) if( Element[i]==A ) break;
      if(i==n){
      	Element.push_back( A );
         // ñåòü âèäèò âñþ àïïàðàòóðó, âõîäÿùóþ âî âñå åãî ïîäñåòè
         // ïîýòîìó, åñëè êàêàÿ-òî ïîäñåòü ñêàçàëà, ÷òî ýòî îáîðóäîâàíèå åãî,
         // òî íå ïåðåíçíà÷àåì ïîäñåòü.
         if(A->Grid == NULL )
         	A->Grid = this;			// äîáàâëÿåìûé ýëåìåíò áóäåò îòíîñèòüñÿ ê ýòîé ñåòè
         }
      // çàïîìíèì ýëåìåíò B, åñëè îí íå ïîâòîðÿþùèéñÿ
      n=Element.size();
      for(i=0; i<n; i++) if( Element[i]==B ) break;
      if(i==n){
      	Element.push_back( B );
         // ñåòü âèäèò âñþ àïïàðàòóðó, âõîäÿùóþ âî âñå åãî ïîäñåòè
         // ïîýòîìó, åñëè êàêàÿ-òî ïîäñåòü ñêàçàëà, ÷òî ýòî îáîðóäîâàíèå åãî,
         // òî íå ïåðåíçíà÷àåì ïîäñåòü.
         if(B->Grid == NULL )
         	B->Grid = this;			// äîáàâëÿåìûé ýëåìåíò áóäåò îòíîñèòüñÿ ê ýòîé ñåòè
         }
      }
   // ïðîâåðèì óíèêàëüíû ëè èìåíà ýëåìåíòîâ
   for(unsigned i=0, n=Element.size(); i<n; i++){
      String name = Element[i]->Name;
      for(unsigned j=i+1; j<n; j++)
         if( name == Element[j]->Name ){
            err(0, "PSubGrid: âíóòðè ñåòè èìåíà âñåõ îáúåêòîâ äîëæíû áûòü óíèêàëüíû, ñåòü íå ñîáðàíà");
            return false;
         	}
      }
   // óäàëèì íåñóùåñòâóþùèå âûâîäû îò ñåòè
   for(unsigned i=0, n=Out.Count(); i<n; i++){
      PElement *Obj = Out[i][0].Obj();
      int j, m=Element.size();
      for(j=0; j<m; j++) if(Element[j] == Obj) break;
      if(j==m) // îáúåêò, íà êîòîðûé ññûëàþòñÿ âûâîäû íå íàéäåí
      	Out.Delete( &Out[i] );	// óäàëèì ãðóïïó âûâîäîâ	
   	}
   return true;
}
//---------------------------------------------------------------------------
// âîçâðàùàåò âñå ñâÿçè âíóòðè ñåáÿ. âêëþ÷àÿ ñâÿçè ïîäñåòåé
Pins_Link PSubGrid::Links(){
   Pins_Link   Link;
   LinksForSubGrid( this, Link );
   return Link;
}
//---------------------------------------------------------------------------
// ðåêóð÷èâíî îïðîñèì ïîäñåòè
void PSubGrid::LinksForSubGrid(PSubGrid *grid, Pins_Link &Link){
   // ñâÿçè îáúåêòîâ âíóòðè ýòîé ñåòè ïîëó÷èâ èõ ñâÿçè
   Link.add( grid->Internal_Links );
   // äîáàâèì òàêæå ñâÿçè îáúåêòîâ âíóòðè ïîäñåòåé, êîòîðûå ðàñïîëîæåíû âíóòðè ýòîé ñåòè
   for(int i=0, n=Element.size(); i<n; i++){
      PSubGrid *g = dynamic_cast<PSubGrid*>( Element[i] );
      if( g ) LinksForSubGrid( g , Link);
      }
}













tstA::tstA():PUnit(5, 4, 2),X(2){
	char _M[4][5] =   {{-1, 0,-1, 0, 0},
                      {+1,-1, 0, 0, 0},
                      { 0,+1,+1,-1,-1},
                      { 0, 0, 0, 1, 1},
                       };
   char _N[2][5] = {{ 1, 1,-1, 0, 0},
                    { 0, 0, 0,-1, 1}};
	M->operator =(&_M[0][0]);
   N->operator =(&_N[0][0]);
   /*/ äîëæíî áûòü çàäàíî èç âíå
   _U_L[0]=0;_U_L[1]=0; _U_L[2]=0;
   _U_C[0]=0;_U_C[1]=0; _U_C[2]=0;
   _R[0]=1; _R[1]=1; _R[2]=3;
   _L[0]=0.001; _L[1]=0.001; _L[2]=0;
   _C[0]=0; _C[1]=0; _C[2]=0;
   _E[0]=0; _E[1]=0; _E[2]=-10;
   _J[0]=0; _J[1]=0; _J[2]=0;*/

   // ðàñ÷åò ìàòðèöû Z
	for(unsigned i=0; i<v; i++)
   	if(*C[i])
      	*Z[i] = *R[i] + *L[i]/smp + smp/(*C[i]);
      else
      	*Z[i] = *R[i] + *L[i]/smp;

   // óñòàíîâêà âçàèìîèíäóêòèâíîñòåé
   mutual_inductance(0,1,-1*sqrt(_L[0]*_L[1]));
   // óñòàíîâêà âûâîäîâ
  Out.add(&X);  // óêàçàòåëè íà ãðóïïû ýëåìåíòîâ
   X[0] = set_pin(0);
   X[1] = set_pin(1);

   /*/ ìîäåëèðóåì ìàãíèòîïðîâîä
   _Magn = new MCircuit(2,2,1);
   char magn_M[2][2] ={{-1,-1},
                       { 1, 1}};
   char magn_N[1][2] = { 1,-1};
   *_Magn->M = (char*)magn_M;
   *_Magn->N = (char*)magn_N;
   *_Magn->R[0] = *_Magn->R[1] = 1e3/2;
   Magn = new PGrid(_Magn);
   Magn->Make_Equation();

   // ïðèâÿçûâàåì ìàãíèòîïðîâîä ê äðîññåëþ
   _Magn->add_D(this, 1, 0, 1000);*/

   magnetic_link(1,3,2);
   //*R[3] = 500; *R[4]=500;
   *L[4] = 2.257;
   *R[4] = 709;
}
//---------------------------------------------------------------------------
tstA::~tstA(){
}
//---------------------------------------------------------------------------
// îáíîâëÿåì èíôîðìàöèþ îá èñòî÷íèêà òîêà è ÇÄÑ â âåòâÿõ
bool tstA::update_sources(bool force_update){
   *E[2] = sin(100*M_PI*TIME);
	return true;
   }
bool tstB::update_sources(bool force_update){ return false;}
bool tstA::update_elements(bool force_update){
   // *C[1] = 6e-4 + 0.003*exp(-20*pow(fabs(*U_C[1]),4))
   //Magn->calc();
   return false;
}
bool tstB::update_elements(bool force_update){ return false;}

//---------------------------------------------------------------------------

tstB::tstB():PUnit(5, 4, 2),X(2){
	char _M[5][5] = {{-1, 0, 0,-1,-1},
                      {+1,-1, 0, 0, 0},
                      { 0,+1,-1, 0,+1},
                      { 0, 0,+1,+1, 0}};
   char _N[2][5] = {{+1,+1, 0, 0,-1},
                      { 0, 0,+1,-1,+1}};
	M->operator =(&_M[0][0]);
   N->operator =(&_N[0][0]);
   // äîëæíî áûòü çàäàíî èç âíå
   _U_L[0]=0;_U_L[1]=0; _U_L[2]=0; _U_L[3]=0; _U_L[4]=0;
   _U_C[0]=0;_U_C[1]=0; _U_C[2]=0; _U_C[4]=0; _U_C[5]=0;
   _R[0]=2; _R[1]=1; _R[2]=2; _R[3]=0; _R[4]=2;
   _L[0]=0; _L[1]=0; _L[2]=0.002; _L[3]=0; _L[4]=0;
   _C[0]=0; _C[1]=0; _C[2]=0; _C[3]=0.0001; _C[4]=0;
   _E[0]=0; _E[1]=1; _E[2]=0; _E[3]=1; _E[4]=0;
   _J[0]=0; _J[1]=0; _J[2]=0; _J[3]=0;

   // ðàñ÷åò ìàòðèöû Z
	for(unsigned i=0; i<v; i++)
   	if(*C[i])
      	*Z[i] = *R[i] + *L[i]/smp + smp/(*C[i]);
      else
      	*Z[i] = *R[i] + *L[i]/smp;
   // óñòàíîâêà âûâîäîâ
   Out.add(&X);  // óêàçàòåëè íà ãðóïïû ýëåìåíòîâ
   X[0] = set_pin(0);
   X[1] = set_pin(3);
}
//---------------------------------------------------------------------------
void __fastcall tstB::SetR(PType value){  // óñòàíîâêà àêòèâíûõ ñîïðîòèâëåíèé íà ôàçó
}
void __fastcall tstB::SetL(PType value){  // óñòàíîâêà èíäóêòèâíîñòè ôàçû
}
void __fastcall tstB::SetC(PType value){  // óñòàíîâêà óìêîñòè ôàçû
}
void __fastcall tstB::SetGz(PType value){ // óñòàíîâêà àêòèâíûõ ïðîâîäèìîñòåé íà çåìëþ
}
void __fastcall tstB::SetCz(PType value){ // óñòàíîâêà åìêîñòåé íà çåìëþ
}
void __fastcall tstB::SetGm(PType value){ // óñòàíîâêà àêòèâíûõ ìåæäóôàçíûõ ïðîâîäèìîñòåé
}
void __fastcall tstB::SetCm(PType value){ // óñòàíîâêà ìåæäóôàçíûõ åìêîñòåé
}
void __fastcall tstB::SetLm(PType value){ // óñòàíîâêà ìåæäóôàçíûõ âçàèìîèíäóêòèâíîñòåé
}
bool tstB::Mutual_Inductance(PType M_ab, PType M_bc, PType M_ca){// âçàèìíûå èíäóêòèâíîñòè ìåæäó îïðåäåëåííûìè ôàçàìè
   return true;
}
bool tstB::Mutual_Conductance(unsigned Phase1, unsigned Phase2, PType Gm, PType Cm){ // ïðîâîäèìîñòè ìåæäó îïðåäåëåííûìè ôàçàìè
   return true;
}
bool tstB::Phase_Params(Phase phase, PType __R, PType __L, PType __C, PType Gz, PType Cz){return true;};
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------











/*  Õðàíèò èíôîðìàöèþ äëÿ ðàññ÷åòà ÝÄÑ óêàçàííîé ôóíêöèåé */
//---------------------------------------------------------------------------
void Source_Params::Change(String  description){	// äîáàâèì çíà÷åíèå
   Field.clear();
	// ðàçäåëÿåì ñòðîêó ïî :
   PType t=0;
   String param = description;
   int pos = param.Pos(":");
   if(pos!=0){
      Type = param.SubString(1,pos-1);
      param = param.SubString(pos+1,param.Length()-pos+1);
      pos = param.Pos(":");
      while(pos!=0){
   	   t=0; TryStrToFloat(param.SubString(1,pos-1), t);
         Field.push_back(t);
         param = param.SubString(pos+1,param.Length()-pos+1);
         pos = param.Pos(":");
   	   }
      t=0;TryStrToFloat(param, t);
      Field.push_back(t);
      }
   else
      Type = param;
}
//---------------------------------------------------------------------------
String Source_Params::Get(){
      	String desc = Type;
      	for(int j=0, m=Field.size(); j<m;j++)
         	desc += ":" + FloatToStr(Field[j]);
         return desc;
}
//---------------------------------------------------------------------------
void Source_Params::Save(ostream &stream){			// ñîõðàíèòü  îáúåêò
   if(Type != ""){
      String param = Get();
	   stream << StringForSave( &param ) << " ";
      }
   else
      stream << "no" << " ";
}
//---------------------------------------------------------------------------
void Source_Params::Read(istream &stream){			// ïðî÷èòàòü  îáúåêò
   char tmp[2048];
   String param;
   stream >> tmp;							// çàãðóçèëè
   param = tmp;
   if( param!="no" ) Change(param);
}
//---------------------------------------------------------------------------
// ôóíêöèÿ ðàññ÷åòà ÝÄÑ ïî çàäàííûì ïàðàìåòðàì èç sourceParams
PType _Ea(PElement* obj, double &time){
	// íàéäåì ïàðàìåòðû ðàññ÷åòà ÝÄÑ
	Source_Params *sp = &((PSource*)obj)->sourceParams;
   if(sp->Type == "íåèçìåííî")
   	return sp->Field[0];
	else if(sp->Type == "sin"){
   	PType w = 2*M_PI*sp->Field[0];
      return sqrt(2)/sqrt(3)*sp->Field[1]*sin( w*time );
      }
   else if (sp->Type == "íåññèìåòðèÿ"){
      PType w = 2*M_PI*sp->Field[0];
      return sqrt(2)/sqrt(3)*( 	sp->Field[1]*sin( w*time ) +
      						         sp->Field[2]*sin( w*time ) +
                                 sp->Field[3]*sin( w*time ) );
      }
   else
   	return 0;
}
//---------------------------------------------------------------------------
PType _Eb(PElement* obj, double &time){
	// íàéäåì ïàðàìåòðû ðàññ÷åòà ÝÄÑ
	Source_Params *sp = &((PSource*)obj)->sourceParams;
   if(sp->Type == "íåèçìåííî")
   	return sp->Field[0];
	else if(sp->Type == "sin"){
   	PType w = 2*M_PI*sp->Field[0];
      return sqrt(2)/sqrt(3)*sp->Field[1]*sin( w*time - 2*M_PI/3);
      }
   else if (sp->Type == "íåññèìåòðèÿ"){
      PType w = 2*M_PI*sp->Field[0];
      return sqrt(2)/sqrt(3)*( 	sp->Field[1]*sin( w*time - 2*M_PI/3) +
      						         sp->Field[2]*sin( w*time + 2*M_PI/3) +
                                 sp->Field[3]*sin( w*time ) );
      }
   else
   	return 0;
}
//---------------------------------------------------------------------------
PType _Ec(PElement* obj, double &time){
	// íàéäåì ïàðàìåòðû ðàññ÷åòà ÝÄÑ
	Source_Params *sp = &((PSource*)obj)->sourceParams;
   if(sp->Type == "íåèçìåííî")
   	return sp->Field[0];
	else if(sp->Type == "sin"){
   	PType w = 2*M_PI*sp->Field[0];
      return sqrt(2)/sqrt(3)*sp->Field[1]*sin( w*time + 2*M_PI/3);
      }
   else if (sp->Type == "íåññèìåòðèÿ"){
      PType w = 2*M_PI*sp->Field[0];
      return sqrt(2)/sqrt(3)*( 	sp->Field[1]*sin( w*time + 2*M_PI/3) +
      						         sp->Field[2]*sin( w*time - 2*M_PI/3) +
                                 sp->Field[3]*sin( w*time ) );
      }
   else
   	return 0;
}








// èäåàëüíûé èñòî÷íèê áåñêîíå÷íîé ìîùíîñòè (ãëóõîçàçåìëåííûé)
PSource::PSource():
   PUnit(16,5,12),
   X(4){
   Ea=_Ea;  // ôóíêöèè ïî óìîë÷àíèþ äëÿ ðàññ÷åòà ÝÄÑ
   Eb=_Eb;
   Ec=_Ec;
   set_pins();          // îáîçíà÷åíèå âûâîäîâ îò èñòî÷íèêà
   Describe_Fields();   // îïèñûâàåì ñâîéñòâà êëàññà
	// çàïîëíÿåì ìàòðèöû
   char _M[5][16] =  {{ 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1},
   	                { 0, 1, 0, 0,-1, 0, 1,-1, 0, 1,-1, 0, 0,-1, 0, 0},
                      { 0, 0, 1, 0, 1,-1, 0, 1,-1, 0, 0,-1, 0, 0,-1, 0},
                      { 0, 0, 0, 1, 0, 1,-1, 0, 1,-1, 0, 0,-1, 0, 0,-1},
                      {-1,-1,-1,-1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}};
	*M = (char*)_M;
   char _N[12][16] = {{ 0, 0, 0, 0, 1, 0, 0, 0, 0, 0,-1, 1, 0, 0, 0, 0},
   						 { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0,-1, 1, 0, 0, 0},
                      { 0, 0, 0, 0, 0, 0, 1, 0, 0, 0,-1, 0, 1, 0, 0, 0},
                      { 0, 0, 0, 0, 1, 0, 0,-1, 0, 0, 0, 0, 0, 0, 0, 0},
                      { 0, 0, 0, 0, 0, 1, 0, 0,-1, 0, 0, 0, 0, 0, 0, 0},
                      { 0, 0, 0, 0, 0, 0, 1, 0, 0,-1, 0, 0, 0, 0, 0, 0},
                      { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0,-1, 0, 0},
                      { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0,-1, 0},
                      { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0,-1},
                      {-1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0},
                      {-1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0},
                      {-1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0}};
   *N = (char*)_N;
   Name = "G";  // èìÿ îáúåêòà
   Grounded_Node = 0;   // çàçåìëÿåìûé óçåë
   // èñõîäíûå  ïàðàìåòðû
   for(int i=_N_;i<=_C_;i++){
      R_[i] = MIN;
      L_[i] = 0 ;
      C_[i] = 0;
      Cz_[i] = 0 ;
      Gz_[i] = 1/MAX;
      }
   for(int i=_AB_;i<=_CA_;i++){
      Cm_[i] = 0;
      Gm_[i] = 1/MAX;
      M_ [i] = 0 ;
      }
   *R[0] = MIN;   // íåéòðàëü çàçåìëåíà
   /*/ áîëüøèå ìåæäóôàçíûå ñîïðîòèâëåíèÿ
   *R[4] = *R[5] = *R[6] = *R[7] = *R[8] = *R[9] = *R[10] = *R[11] = *R[12] = *R[13] = *R[14] = *R[15] = MAX;
   // ìèíèìàëüíûå ñîïðîòèâëåíèÿ G (íåîáõîäèìû äëÿ âîçìîæíîñòè çàïèñè 2 çàêîíà Êèðõãîôà)
   *R[0] = *R[1] = *R[2] = *R[3] = MIN;*/
}
//---------------------------------------------------------------------------
bool PSource::update_sources(bool force_update){
   if(Ea) *E[1] = (*Ea)(this, TIME);
   else *E[1]=0;
   if(Eb) *E[2] = (*Eb)(this, TIME);
   else *E[2]=0;
   if(Ec) *E[3] = (*Ec)(this, TIME);
   else *E[3]=0;
   return true;
}
//---------------------------------------------------------------------------
/* Óñòàíîâêà ÷åëîâåêî-ïîíÿòíûõ âûâîäîâ îò óñòðîéñòâà */
void PSource::set_pins(){
   Out.add(&X);  // óêàçàòåëè íà ãðóïïû ýëåìåíòîâ
   X.Name = "X";
   X[ _N_ ] = set_pin(0);
   X[ _A_ ] = set_pin(1);
   X[ _B_ ] = set_pin(2);
   X[ _C_ ] = set_pin(3);
}
//---------------------------------------------------------------------------
void PSource::Describe_Fields(){
   PFieldInfo fi;
   String name;
   // àêòèâíûå ñîïðîòèâëåíèÿ
   for(int i=_N_; i<=_C_; i++){
      if(i==_N_) name = "N";
      else       name = (String)((char)('A'+i-_A_));
      fi.Name = "R_[_" + name + "_]";
      fi.Type = "PType";
      fi.ptr = (void*) &R_[i];
      Fields.push_back(fi);
      }
   // èíäóêòèâíîñòè
   for(int i=_N_; i<=_C_; i++){
      if(i==_N_) name = "N";
      else       name = (String)((char)('A'+i-_A_));
      fi.Name = "L_[_" + name + "_]";
      fi.Type = "PType";
      fi.ptr = (void*) &L_[i];
      Fields.push_back(fi);
      }
   // åìêîñòè
   for(int i=_N_; i<=_C_; i++){
      if(i==_N_) name = "N";
      else       name = (String)((char)('A'+i-_A_));
      fi.Name = "C_[_" + name + "_]";
      fi.Type = "PType";
      fi.ptr = (void*) &C_[i];
      Fields.push_back(fi);
      }
   // âçàèìíàÿ èíäóêòèâíîñòü
   for(int i=0; i<3; i++){
      switch(i){
         case _AB_: name = "AB"; break;
         case _BC_: name = "ÂÑ"; break;
         case _CA_: name = "ÑÀ"; break;
         default:   name = "";
      }
      fi.Name = "M_[_" + name + "_]";
      fi.Type = "PType";
      fi.ptr = (void*) &M_[i];
      Fields.push_back(fi);
      }
   // àêòèâíàÿ ïðîâîäèìîñòü íà çåìëþ
   for(int i=_A_; i<=_C_; i++){
      fi.Name = "Gz_[_" + (String)((char)('A'+i-_A_)) + "_]";
      fi.Type = "PType";
      fi.ptr = (void*) &Gz_[i];
      Fields.push_back(fi);
      }
   // åìêîñòíàÿ ïðîâîäèìîñòü íà çåìëþ
   for(int i=_A_; i<=_C_; i++){
      fi.Name = "Cz_[_" + (String)((char)('A'+i-_A_)) + "_]";
      fi.Type = "PType";
      fi.ptr = (void*) &Cz_[i];
      Fields.push_back(fi);
      }
   // àêòèâíàÿ ìåæäóôàçíàÿ ïðîâîäèìîñòü
   for(int i=0; i<3; i++){
      switch(i){
         case _AB_: name = "AB"; break;
         case _BC_: name = "ÂÑ"; break;
         case _CA_: name = "ÑÀ"; break;
         default:   name = "";
      }
      fi.Name = "Gm_[_"+ name +"_]";
      fi.Type = "PType";
      fi.ptr = (void*) &Gm_[i];
      Fields.push_back(fi);
      }
   // åìêîñòíàÿ ìåæäóôàçíàÿ ïðîâîäèìîñòü
   for(int i=0; i<3; i++){
      switch(i){
         case _AB_: name = "AB"; break;
         case _BC_: name = "ÂÑ"; break;
         case _CA_: name = "ÑÀ"; break;
         default:   name = "";
      }
      fi.Name = "Cm_[_"+ name +"_]";
      fi.Type = "PType";
      fi.ptr = (void*) &Cm_[i];
      Fields.push_back(fi);
      }
}
/*/---------------------------------------------------------------------------
void PSource::R_(PType value){  // óñòàíîâêà àêòèâíûõ ñîïðîòèâëåíèé íà ôàçó
   *R[1] = value;
   *R[2] = value;
   *R[3] = value;
}
void PSource::L_(PType value){  // óñòàíîâêà èíäóêòèâíîñòè ôàçû
   *L[1] = value;
   *L[2] = value;
   *L[3] = value;
}
void PSource::C_(PType value){  // óñòàíîâêà óìêîñòè ôàçû
   *C[1] = value;
   *C[2] = value;
   *C[3] = value;
}
void PSource::Gz_(PType value){ // óñòàíîâêà àêòèâíûõ ïðîâîäèìîñòåé íà çåìëþ
   *R[10] = 1/value;
   *R[11] = 1/value;
   *R[12] = 1/value;
}
void PSource::Cz_(PType value){ // óñòàíîâêà åìêîñòåé íà çåìëþ
   *C[13] = value;
   *C[14] = value;
   *C[15] = value;
   // îáíóëÿåì àêòèâíîå ñîïðîòèâëåíèå â ýòèõ âåòâÿõ
   if(value!=0)
      *R[13] = *R[14] = *R[15] = 0;
   else
      *R[13] = *R[14] = *R[15] = MAX;
}
void PSource::Gm_(PType value){ // óñòàíîâêà àêòèâíûõ ìåæäóôàçíûõ ïðîâîäèìîñòåé
   *R[4] = 1/value;
   *R[5] = 1/value;
   *R[6] = 1/value;
}
void PSource::Cm_(PType value){ // óñòàíîâêà ìåæäóôàçíûõ åìêîñòåé
   *C[7] = value;
   *C[8] = value;
   *C[9] = value;
   // îáíóëÿåì àêòèâíîå ñîïðîòèâëåíèå â ýòèõ âåòâÿõ
   if(value!=0)
      *R[7] = *R[8] = *R[9] = 0;
   else
      *R[7] = *R[8] = *R[9] = MAX;
}
void PSource::Lm_(PType value){ // óñòàíîâêà ìåæäóôàçíûõ âçàèìîèíäóêòèâíîñòåé
   mutual_inductance(1, 2, value);
   mutual_inductance(1, 3, value);
   mutual_inductance(2, 3, value);
}*/
bool PSource::Mutual_Inductance(PType M_ab, PType M_bc, PType M_ca){// âçàèìíûå èíäóêòèâíîñòè ìåæäó îïðåäåëåííûìè ôàçàìè
   mutual_inductance(1, 2, M_ab);
   mutual_inductance(2, 3, M_bc);
   mutual_inductance(1, 3, M_ca);
   return true;
}
bool PSource::Mutual_Conductance(unsigned Phase1, unsigned Phase2, PType Gm, PType Cm){ // ïðîâîäèìîñòè ìåæäó îïðåäåëåííûìè ôàçàìè
   PType Rm;	// ìåæäóôàçíûå ñîïðîòèâëåíèÿ
   if(Gm) Rm = 1/Gm;
   else   Rm = MAX;
   // îïðåäåëÿåì ôàçó
   unsigned p;
   switch (Phase1 + Phase2){
   	case (_A_ + _B_): p=0; break;
      case (_B_ + _C_): p=1; break;
      case (_C_ + _A_): p=2; break;
      default:	 return false;
      }
   // óñòàíîâêà çíà÷åíèé
   *R[4+p] = Rm;  *L[4+p] = 0;   *C[4+p] = 0;
   if(Cm) {*C[7+p] = Cm; *R[7+p] = 0;  *L[7+p] = 0;}
   else   {*C[7+p] = Cm; *R[7+p] =MAX; *L[7+p] = 0;}
   return true;
}
bool PSource::Phase_Params(Phase phase, PType __R, PType __L, PType __C, PType Gz, PType Cz){ // ïàðàìåòðû íà 1 ôàçó
   // îïðåäåëÿåì ôàçó
   unsigned p;
   switch (phase){
   	case _A_: p=0; break;
      case _B_: p=1; break;
      case _C_: p=2; break;
      default:	 return false;
      }
   // óñòàíîâêà çíà÷åíèé
   *R[1+p] = __R;
   *L[1+p] = __L;
   *C[1+p] = __C;
   if(Gz) *R[10+p] = 1/Gz;
   else   *R[10+p] = MAX;
   if(Cz) {*C[13+p] = Cz;  *R[13+p] = 0;  *L[13+p] = 0;}
   else   {*C[13+p] = Cz;  *R[13+p] =MAX; *L[13+p] = 0;}
   return true;
}
//---------------------------------------------------------------------------
bool PSource::accept(){
   bool ret = true;
   // ôàçíûå ïàðàìåòðû
   for(int i=_A_; i<=_C_; i++)
      ret = ret & Phase_Params((Phase) i, R_[i], L_[i], C_[i], Gz_[i], Cz_[i]);
   // ïàðàìåòðû íåéòðàëè
   *R[0] = R_[_N_];
   *L[0] = L_[_N_];
   *C[0] = C_[_N_];
   // ìåæäóôàçíûå èíäóêòèâíîñòè
   ret = ret & Mutual_Inductance(M_[_AB_], M_[_BC_], M_[_CA_]);
   // ìåæäóôàçíûå ïðîâîäèìîñòè
   ret = ret & Mutual_Conductance(_A_, _B_, Gm_[_AB_], Cm_[_AB_]);
   ret = ret & Mutual_Conductance(_B_, _C_, Gm_[_BC_], Cm_[_BC_]);
   ret = ret & Mutual_Conductance(_C_, _A_, Gm_[_CA_], Cm_[_CA_]);
   update_differential_resistance();
   return ret;
}
//---------------------------------------------------------------------------
void PSource::Save(ostream &stream){		// ñîõðàíåíèå ïàðàìåòðîâ îáúåêòà â ïîòîê
   // ñíà÷àëà ñîõðàíèòñÿ áàçîâûé êëàññ
   sire::Save(stream);
   // òåïåðü ñîõðàíÿåì ýòîò êëàññ
   for(int i=0; i<4; i++){
      stream << R_[i] << " ";
      stream << L_[i] << " ";
      stream << C_[i] << " ";
      stream << Gz_[i] << " ";
      stream << Cz_[i] << " ";
   	}
   for(int i=0; i<3; i++){
      stream << M_[i] << " ";
      stream << Gm_[i] << " ";
      stream << Cm_[i] << " ";
   	}
   // ñîõðàíèì ïàðàìåòðû èñòî÷íèêîâ
   sourceParams.Save( stream );
}
//---------------------------------------------------------------------------
void PSource::Read(istream &stream){    // çàãðóçêà ïàðàìåòðîâ îáúåêòà èç ïîòîêà
   // ñíà÷àëà ÷èòàåò äàííûå áàçîâûé êëàññ
   sire::Read(stream);
   // òåïåðü ÷èòàåì ýòîò êëàññ
   for(int i=0; i<4; i++){
      stream >> R_[i];
      stream >> L_[i];
      stream >> C_[i];
      stream >> Gz_[i];
      stream >> Cz_[i];
   	}
   for(int i=0; i<3; i++){
      stream >> M_[i];
      stream >> Gm_[i];
      stream >> Cm_[i];
   	}
   // ÷èòàåì ïàðàìåòðû èñòî÷íèêîâ
   sourceParams.Read( stream );
}
//---------------------------------------------------------------------------
String PSource::ClassName(){return "PSource";};				// âîçâðàùàåò èìÿ êëàññà
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------













// Ïîòðåáèòåëü (ãëóõîçàçåìëåííûé ïî óìîë÷àíèþ)
PConsumer::PConsumer(){
   Name = "Íàãð";  // èìÿ îáúåêòà
   Grounded_Node = 0;   // çàçåìëÿåìûé óçåë
   // èñõîäíûå  ïàðàìåòðû
   for(int i=_N_;i<=_C_;i++){
      R_[i] = MAX;            // ïî óìîë÷àíèþ íàãðóçêà íå ïîòðåáëÿåò
      L_[i] = 0 ;
      C_[i] = 0 ;
      Cz_[i] = 0 ;
      Gz_[i] = 1/MAX;
      }
   for(int i=_AB_;i<=_CA_;i++){
      Cm_[i] = 0;
      Gm_[i] = 1/MAX;
      M_[i] = 0 ;
      }
   *R[0] = MIN;   // íåéòðàëü çàçåìëåíà
   /*/ áîëüøèå ìåæäóôàçíûå ñîïðîòèâëåíèÿ
   *R[4] = *R[5] = *R[6] = *R[7] = *R[8] = *R[9] = *R[10] = *R[11] = *R[12] = *R[13] = *R[14] = *R[15] = MAX;
   // íàãðóçêà çàçåìëåíà (!=0 äëÿ çàïèñè 2 çàêîíà Êèðõãîôà äëÿ äàííîé âåòâè)
   *R[0] = MIN;
   // ïî óìîë÷àíèþ íàãðóçêà íè÷åãî íå ïîòðåáëÿåò
   *R[1] = *R[2] = *R[3] = MAX;*/
   // ïðèíèìàåì õàðàêòåðèñòèêè
   accept();
}
/*/---------------------------------------------------------------------------
bool PConsumer::update_sources(bool force_update){
   if(Ea) *E[1] = (*Ea)(TIME);
   else *E[1]=0;
   if(Eb) *E[2] = (*Eb)(TIME);
   else *E[2]=0;
   if(Ec) *E[3] = (*Ec)(TIME);
   else *E[3]=0;
   return true;
}*/
//---------------------------------------------------------------------------
/* Óñòàíîâêà ÷åëîâåêî-ïîíÿòíûõ âûâîäîâ îò óñòðîéñòâà /
void PConsumer::set_pins(){
   Out.add(&X);  // óêàçàòåëè íà ãðóïïû ýëåìåíòîâ
   X.Name = "X";
   X[ _N_ ] = set_pin(0); //, 0);
   X[ _A_ ] = set_pin(1); //, 1);
   X[ _B_ ] = set_pin(2); //, 2);
   X[ _C_ ] = set_pin(3); //, 3);
}
//---------------------------------------------------------------------------
void __fastcall PConsumer::SetR(PType value){  // óñòàíîâêà àêòèâíûõ ñîïðîòèâëåíèé íà ôàçó
   *R[1] = value;
   *R[2] = value;
   *R[3] = value;
}
void __fastcall PConsumer::SetL(PType value){  // óñòàíîâêà èíäóêòèâíîñòè ôàçû
   *L[1] = value;
   *L[2] = value;
   *L[3] = value;
}
void __fastcall PConsumer::SetC(PType value){  // óñòàíîâêà óìêîñòè ôàçû
   *C[1] = value;
   *C[2] = value;
   *C[3] = value;
}
void __fastcall PConsumer::SetGz(PType value){ // óñòàíîâêà àêòèâíûõ ïðîâîäèìîñòåé íà çåìëþ
   *R[10] = 1/value;
   *R[11] = 1/value;
   *R[12] = 1/value;
}
void __fastcall PConsumer::SetCz(PType value){ // óñòàíîâêà åìêîñòåé íà çåìëþ
   *C[13] = value;
   *C[14] = value;
   *C[15] = value;
   // îáíóëÿåì àêòèâíîå ñîïðîòèâëåíèå â ýòèõ âåòâÿõ
   *R[13] = *R[14] = *R[15] = 0;
}
void __fastcall PConsumer::SetGm(PType value){ // óñòàíîâêà àêòèâíûõ ìåæäóôàçíûõ ïðîâîäèìîñòåé
   *R[4] = 1/value;
   *R[5] = 1/value;
   *R[6] = 1/value;
}
void __fastcall PConsumer::SetCm(PType value){ // óñòàíîâêà ìåæäóôàçíûõ åìêîñòåé
   *C[7] = value;
   *C[8] = value;
   *C[9] = value;
   // îáíóëÿåì àêòèâíîå ñîïðîòèâëåíèå â ýòèõ âåòâÿõ
   *R[7] = *R[8] = *R[9] = 0;
}
void __fastcall PConsumer::SetLm(PType value){ // óñòàíîâêà ìåæäóôàçíûõ âçàèìîèíäóêòèâíîñòåé
   mutual_inductance(1, 2, value);
   mutual_inductance(1, 3, value);
   mutual_inductance(2, 3, value);
}
bool PConsumer::Mutual_Inductance(PType M_ab, PType M_bc, PType M_ca){// âçàèìíûå èíäóêòèâíîñòè ìåæäó îïðåäåëåííûìè ôàçàìè
   mutual_inductance(1, 2, M_ab);
   mutual_inductance(2, 3, M_bc);
   mutual_inductance(3, 1, M_ca);
   return true;
}
bool PConsumer::Mutual_Conductance(unsigned Phase1, unsigned Phase2, PType Gm, PType Cm){ // ïðîâîäèìîñòè ìåæäó îïðåäåëåííûìè ôàçàìè
   PType Rm = 1/Gm;	// ìåæäóôàçíûå ñîïðîòèâëåíèÿ
   // îïðåäåëÿåì ôàçó
   unsigned p=0;
   switch (Phase1 + Phase2){
   	case (_A_ + _B_): p=0; break;
      case (_B_ + _C_): p=1; break;
      case (_C_ + _A_): p=2; break;
      default:	 return false;
      }
   // óñòàíîâêà çíà÷åíèé
   *R[4+p] = Rm;
   *C[7+p] = Cm;
   return true;
}
bool PConsumer::Phase_Params(Phase phase, PType __R, PType __L, PType __C, PType Gz, PType Cz){ // ïàðàìåòðû íà 1 ôàçó
   // îïðåäåëÿåì ôàçó
   unsigned p=0;
   switch (phase){
   	case _A_: p=0; break;
      case _B_: p=1; break;
      case _C_: p=2; break;
      default:	 return false;
      }
   // óñòàíîâêà çíà÷åíèé
   *R[1+p] = __R;
   *L[1+p] = __L;
   *C[1+p] = __C;
   *R[10+p] = 1/Gz;
   *C[13+p] = Cz;
   return true;
}*/
//---------------------------------------------------------------------------
/* îïðåäåëåíèå ïàðàìåòðîâ ñõåìû çàìåùåíèÿ ëèíèè ïî äàííûì íàãðóçêè */
bool PConsumer::Load(const PType P,const PType Q, const PType Unom, bool Grounding, const PType freq ){
   PType P_1 = P/3;
   PType r = Unom*Unom/P_1;
   PType Q_1 = Q/3;
   PType l=0, c=0;
   if(Q_1>0) l = Unom*Unom/(Q_1*2*M_PI*freq);
   else c = Q_1/(Unom*Unom*2*M_PI*freq);
   PType m=0;
   if(!Grounding) // ïîòðåáèòåëüëü ñ èçîëèðîâàííîé íåéòðàëüþ
      *R[0] = MAX;
   else
      *R[0] = MIN;
   // óñòàíîâêà çíà÷åíèé
   for(int i=_A_;i<=_C_;i++){
      R_[i] = r;            // ïî óìîë÷àíèþ íàãðóçêà íå ïîòðåáëÿåò
      L_[i] = l ;
      C_[i] = c ;
      M_[i] = m ;
      Cz_[i] = 0 ;
      Gz_[i] = 1/MAX;
      }
   for(int i=_AB_;i<=_CA_;i++){
      Cm_[i] = 0;
      Gm_[i] = 1/MAX;
      }
   /*
   R_( r );
   L_( l );
   C_( c );
   Lm_( m );
   Gm_( 1/MAX );
   Cm_( 0 );
   Gz_( 1/MAX );
   Cz_( 0 ); */
   return true;
}
//---------------------------------------------------------------------------
String PConsumer::ClassName(){return "PConsumer";};				// âîçâðàùàåò èìÿ êëàññà
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------















// òðàíñôîðìàòîð îäíîôàçíûå áåç ó÷åòà öåïè íàìàãíè÷èâàíèÿ
PSingleTransformer ::PSingleTransformer():
					PUnit(6, 6, 1),
               X1(2), X2(2){	// óêàçàíû 4, íî èñïîëüçóþòñÿ òîëüêî ñ èíäåêñàìè 1-3, Õ1[0] == X1[_N_] íå èñïîëüçóåòñÿ
   set_pins();
  	// çàïîëíÿåì ìàòðèöû
   char _M[6][6] =   {{-1, 0, 0,-1, 0, 0},
                      { 1, 0, 0, 0, 0, 0},
                      { 0,-1, 0, 0,-1, 0},
                      { 0, 1, 0, 0, 0, 0},
                      { 0, 0, 1, 1, 1, 1},
                      { 0, 0,-1, 0, 0,-1}};
	*M = (char*)_M;
   char _N[1][6] =    {{0, 0,-1, 0, 0, 1}};
   *N = (char*)_N;
   /* çàäàäèì òðàíñô ñ êîýô òðàíñôîðìàöèè 1 */
   _U1 = 1;
   _U2 = 1;
   _S  = 1;
   _dPk= 0;
   _Uk = 10.5;
   _dPx= 0;
   _Ix = 0.01;
   _freq = 50;
   // ñîïðîòâëåíèå óòå÷êè îáìîòîê
   *R[3] = *R[4] = MAX;
   Name = "ÎÒð";  // èìÿ îáúåêòà
   Grounded_Node = 4;   // çàçåìëÿåìûé óçåë
}
//---------------------------------------------------------------------------
void PSingleTransformer :: set_pins(){
   X1 [_N_] = set_pin(1);
   X1 [_A_] = set_pin(0);
   X2 [_N_] = set_pin(3);
   X2 [_A_] = set_pin(2);
   // èìåíà
   X1.Name  = "X1";
   X2.Name  = "X2";
	// äîáàâèì â ñïèñîê ãðóïï âûâîäîâ
	Out.add(&X1);
   Out.add(&X2);
}
//---------------------------------------------------------------------------
void PSingleTransformer :: Params(PType U1,  PType U2, PType S,  // óñòàíîâêà ïàðàìåòðîâ
      	                         PType dPk, PType Uk,
                                  PType dPx, PType Ix,
                                  PType freq){
   // Ïðèìåì
   PType Km = 1;				  // êîýôôèöèåíò ìàãíèòíîé ñâÿçè
   _Iu = 1e3;               // , À âûáèðàåì òîê â öåïè íàìàãíè÷èâàíèÿ (ìàãíèòîïðîâîäå)
                             // çàìåòèë: ÷åì áîëüøå Iu òåì ìåíüøå ïîãðåøíîñòü 2 çàê. Êèðõãîôà äëÿ öåïè íàìàãíè÷èâàíèÿ
   // çàïîìíèì
	_U1 = U1;
   _U2 = U2;
   _S  = S;
   _dPk= dPk;
   _Uk = Uk;
   _dPx= dPx;
   _Ix = Ix;
   _freq = freq;

   // êîçôôèöèåíòû
   PType k = U1/U2;        // êîýôôèöèåíò òðàíñôîðìàöèè
   PType w = 2*freq*M_PI;  // óãëîâàÿ ÷àñòîòà

   // ïîøëè ðàññ÷èòûâàòü
   // àêòèâíîå ñîïðîòèâëåíèå îáìîòîê
   PType R_sum = dPk * pow(U1,2) / pow(S,2);
   PType R1 = 0.5 * R_sum;
   PType R2 = R1 / pow(k,2);
   // âåëè÷èíà ìàãíèòíîé ñâÿçè (ïðè ó÷åòå ïðèáëèæåííîãî ðàâåíñòâà ÝÄÑxx = Uxx)
   PType Xm1 = U1 / _Iu ;
   PType Xm2 = U2 / _Iu ;
   // òîê õîëîñòîãî õîäà
   PType __Ix = Ix/100 * S/U1;   // â Àìïåðàõ
   //PType Ru = (dPx - R1 * pow(__Ix,2)) / pow(_Iu,2);
   // ðåàêòèâíûå ïîòåðè õîëîñòîãî õîäà
   PType dQ2 = pow(__Ix*U1,2) - pow(dPx,2);
   if(dQ2<0){
      err(0, "PSingleTransformer::Params(): ïàðàìåòðû òðàíñôîðìàòîðà çàäàíû íå âåðíî.Ñëèøêîì ìàëåíüêèé òîê õ.õ. äëÿ çàäàííûõ àêòèâí. ïîòåðü õ.õ. Óñòàíîâëåíî íîâîå çíà÷åíèå òîêà õ.õ.");
      __Ix = dPx/U1;
      _Ix = __Ix / (S/U1) * 100;
      //Ix = _Ix;
      dQ2 = 0;
      }
   PType dQx = sqrt( dQ2 );
   PType q_xx;	// óãîë ìåæäó òîêîì è íàïðÿæåíèåì  õîëîñòîãî õîäà
   if(dPx)
      q_xx = atan(dQx/dPx);
   else
      q_xx = M_PI/2;
   // àêòèâíîå ñîïðîòèâëåíèå öåïè íàìàãíè÷èâàíèÿ (ó÷åò ïîòåðü)
   PType Ru = __Ix * Xm1 * cos(q_xx)/_Iu;
   PType X_pot = __Ix * Xm1 * sin(q_xx)/_Iu;
   // ðåàêòèâíîå ñîïðîòèâëåíèå öåïè íàìàãíè÷èâàíèÿ (ó÷åò ïîòåðü)
   //PType X_pot  = (dQx - X1 * pow(__Ix,2) - 2*Xm1*__Ix*_Iu*sin(atan(dQx/dPx))) / pow(_Iu,2);	// îïðåäåëÿåò ðåàêòèâíûå ïîòåðè â ìàãíèòîïðîâîäå
   // ðåàêòèâíîå ñîïðîòèâëåíèå îáìîòîê
   PType Z_sum =  Uk/100 * pow(U1,2) / S;
   PType X_sum2 = pow(Z_sum,2) - pow(R_sum,2);
   if(X_sum2<0){
      err(0, "PSingleTransformer::Params(): ïàðàìåòðû òðàíñôîðìàòîðà çàäàíû íå âåðíî.Ñëèøêîì ìàëåíüêèé òîê Uk äëÿ çàäàííûõ àêòèâí. ïîòåðü ê.ç. Óñòàíîâëåíî íîâîå çíà÷åíèå Uk");
      _Uk = R_sum * S / pow(U1,2) * 100;
      //Uk = _Uk;
      //Z_sum =  _Uk/100 * pow(U1,2) / S;
      X_sum2 = 0;
      }
   PType X_sum =  sqrt( X_sum2 );
   PType X1 = 0.5*X_sum ;
   //PType X1 = 0.5 * X_sum + Xm1*(1+k)/2;  // õîðîø íà õîëîñòîé õîä
   PType X2 = X1 / pow(k,2);
   // èíäóêòèâíîñòü â öåïè íàìàãíè÷èâàíèÿ
   PType Xu1 = pow(Xm1/Km,2) / X1;    		// îíî ñêîìïåíñèðóåòñÿ åìêîñòüþ
   PType Xu2 = pow(Xm2/Km,2) / X2;
   PType Xu  = Xu1 + Xu2;
   PType X_Cu = Xu + X_pot;  // íåîáõîäèìàÿ åìêîñòü
   /*
   PType Z_sum =  Uk/100 * pow(U1,2) / S;
   PType X_sum2 = pow(Z_sum,2) - pow(R_sum,2);
   if(X_sum2<0){
      err(0, "PSingleTransformer::Params(): ïàðàìåòðû òðàíñôîðìàòîðà çàäàíû íå âåðíî.Ñëèøêîì ìàëåíüêèé òîê Uk äëÿ çàäàííûõ àêòèâí. ïîòåðü ê.ç. Óñòàíîâëåíî íîâîå çíà÷åíèå Uk");
      _Uk = R_sum * S / pow(U1,2) * 100;
      Uk = _Uk;
      Z_sum =  _Uk/100 * pow(U1,2) / S;
      X_sum2 = 0;
      }
   PType X_sum =  sqrt( X_sum2 );
   PType Zxx = U1 / __Ix;

   Km = sqrt (  (2*Zxx - X_sum)/(2*Zxx - 0.5*X_sum)  );

   PType X1 = Zxx / (1 - 0.5*pow(Km,2));
   Xm1 = (k+1)*(X1 - X_sum/2); // íà ñêîëüêî äîìíîæèì X1 âî ñòîëüêî ðàç òîê Iu áóäåò ìåíüøå

   PType Xu = 2 * pow(Xm1,2)/pow(Km,2)/X1 ;    // 2*X1

   PType X2 = X1 / pow(k,2);
   Xm2 = Xm1 / k;

   _Iu = U1 / Xm1;
   PType Ru = dPx / pow(_Iu,2);

   *R[0] = R1; *L[0] = X1/w;
   *R[1] = R2; *L[1] = X2/w;
	*R[2] = Ru/2; *L[2] = Xu/w/2;
   *R[5] = Ru/2; *L[5] = Xu/w/2;
   mutual_inductance(0, 2, Xm1/w);
   mutual_inductance(1, 5, Xm2/w);
   */
   // óñòàíàâëèâàåì ïàðàìåòðû
   *R[0] = R1; *L[0] = X1/w;
   *R[1] = R2; *L[1] = X2/w;
   *R[2] = Ru; *L[2] = Xu/w;  *C[2] = 1/(X_Cu*w);
   *R[5] = 0;  *L[5] = 0;
   //_Ru_nom = *C[2];  // çàïîìèíàåì íîìèíàëüíîå ñîïðîòèâëåíèå

   mutual_inductance(0, 2, Xm1/w);
   mutual_inductance(1, 2, Xm2/w);
   update_differential_resistance();
}
//---------------------------------------------------------------------------
String PSingleTransformer::ClassName(){return "PSingleTransformer";}				// âîçâðàùàåò èìÿ êëàññà








//---------------------------------------------------------------------------
PCurve :: PCurve(){
   Y_X = NULL;
   Symmetry = true;
   exist = false;
}
//---------------------------------------------------------------------------
void PCurve :: _set(PType X, PType Y){
   _X.push_back(X);
   _Y.push_back(Y);
   if(Y<0) Symmetry = false;
   if(size() > 0) exist = true; 
}
//---------------------------------------------------------------------------
void PCurve :: clear(){
   _X.clear();
   _Y.clear();
   if(Y_X == NULL) exist = false;  // àíàëèòè÷ êðèâàÿ íå çàäàíà, è ëîìàíàÿ óäàëåíà = Ãðàôèê Íå Çàäàí
}
//---------------------------------------------------------------------------
unsigned PCurve :: size(){
   int n = _X.size()-1;
   return (n==-1)? 0 : n;
}
//---------------------------------------------------------------------------
void PCurve :: Point(unsigned Index, PType &X, PType &Y){
   if( Index < _X.size() && Index < _Y.size() ){
      X = _X[Index];
      Y = _Y[Index];
      }
}
//---------------------------------------------------------------------------
void PCurve :: func( PType (*Func)(PType&) ){
   Y_X = Func;
   if(Y_X != NULL)
      exist = true;
   else if( size() < 1 ) // è ôóíêöèÿ îáíóëåíà è ëîìîíîé êðèâîé íåò
      exist = false;
}
//---------------------------------------------------------------------------
PType __fastcall PCurve :: X(PType _Y_){
 if (Y_X==NULL){  // åñëè íå çàäàíà êðèâàÿ
   int sgn = 1;
   if( Symmetry ){ // êðèâàÿ ñèììåòðè÷íà îòíîñèòåëüíî íà÷àëà êîîðäèíàò
      sgn = (_Y_>0)?1:-1;
      _Y_ = sgn*_Y_;
      }
   PType dY, dX;
   if(_Y.size() == 0) {
      err(0, "PCurve::X(): êðèâàÿ íå çàäàíà. âåðíóëè çíà÷åíèå -1.");
      return -1;}
   int n=_Y.size(); // ÷èñëî ó÷àñòêîâ
   int i;
   for(i=0;i<n;i++)
      if( _Y_ < _Y[i]) break;
   if (i==n || i==0){ // ìû ïîïàëè íà ïîñëåäíèé ó÷àñòîê
      err(0, "PCurve::X(): êðèâàÿ íå çàäàíà äëÿ èñêîìîãî Y="+ FloatToStr(_Y_)+". âåðíóëè çíà÷åíèå -1.");
      return -1;
      }
   else{
      i--;  // ó÷àñòîê êðèâîé íàìàãíè÷èâàíèÿ, íà êîòîðîé íàõîäèòñÿ ðàáî÷àÿ òî÷êà
      dY = _Y[i+1] - _Y[i]; // ïðèðàùåíèå íà ó÷àñòêå
      dX = _X[i+1] - _X[i]; // ïðèðàùåíèå íà ó÷àñòêå
      }
   // ñ÷èòàÿ êðèâóþ ñèììåòðè÷íîé îòíîñèòåëüíî íà÷àëà êîîðäèíàò
   return sgn*(_X[i] + dX/dY * (_Y_-_Y[i]));
 }
 else{
 	// ðàññ÷åò ïî àíàëèòè÷åñêîé êðèâîé
   // ïî óñëîâèÿ H(B) = 0
   PType _Ymin=0, _Ymax = 1e10;
   PType e=1e-3; 			// äîïóñòèìûå ïîãðåøíîñòè ðàññ÷åòà
   PType a = _Ymin, b = _Ymax, c = _Ymin/2 + _Ymax/2;
   PType Y_c;
   do{
   	Y_c = (*Y_X)(c);
   	if( (*Y_X)(a)<_Y_ &&  Y_c>_Y_){
         b = c;
         c = (a+b)/2;
      	}
      else if ( Y_c<_Y_ &&  (*Y_X)(b)>_Y_){
      	a = c;
         c = (a+b)/2;
      	}
      else{
         err(0,"PCurve :: X(): Íå íàéäåíî çíà÷åíèå X ïî Y="+FloatToStr(_Y_)+". Íå âåðíà àíàëèòè÷åñêàÿ ôóíêöèÿ.");
         return c;
      	}
   }while(fabs(a - b) > e || fabs(Y_c - _Y_) > e);
   return c;	// âîçâðàùàåì çíà÷åíèå èíäóêöèè
 }
}
//---------------------------------------------------------------------------
PType __fastcall PCurve :: Y(PType _X_){
 if(Y_X==NULL){    // åñëè íå çàäàíà êðèâàÿ
   int sgn = 1;
   if( Symmetry ){ // êðèâàÿ ñèììåòðè÷íà îòíîñèòåëüíî íà÷àëà êîîðäèíàò
      sgn = (_X_>0)?1:-1;
      _X_ = sgn*_X_;
      }
   PType dY, dX;
   if(_Y.size() == 0) {
      err(0, "PCurve::Y(): êðèâàÿ íå çàäàíà. âåðíóëè çíà÷åíèå -1.");
      return -1;}
   int n=_X.size(); // ÷èñëî ó÷àñòêîâ
   int i;
   for(i=0;i<n;i++)
      if( _X_ < _X[i]) break;
   if (i==n || i==0){ // ìû ïîïàëè íà ïîñëåäíèé ó÷àñòîê
      err(0, "PCurve::Y(): êðèâàÿ íå çàäàíà äëÿ èñêîìîãî X="+FloatToStr(_X_)+". âåðíóëè çíà÷åíèå -1.");
      return -1;
      }
   else{
      i--;  // ó÷àñòîê êðèâîé íàìàãíè÷èâàíèÿ, íà êîòîðîé íàõîäèòñÿ ðàáî÷àÿ òî÷êà
      dY = _Y[i+1] - _Y[i]; // ïðèðàùåíèå íà ó÷àñòêå
      dX = _X[i+1] - _X[i]; // ïðèðàùåíèå íà ó÷àñòêå
      }
   // ñ÷èòàÿ êðèâóþ ñèììåòðè÷íîé îòíîñèòåëüíî íà÷àëà êîîðäèíàò
   return sgn*(_Y[i] + dY/dX * (_X_-_X[i]));
 	}
 else{
 	// ðàññ÷åò ïî àíàëèòè÷åñêîé êðèâîé
   return (*Y_X)(_X_);
 }
}
//---------------------------------------------------------------------------
void PCurve::Save(ostream &stream){		// ñîõðàíåíèå ïàðàìåòðîâ îáúåêòà â ïîòîê
   /* êðèâóþ çàäàíóþ ôóíêöèåé ìîæíî ñîõðàíèòü êàê íàáîð òî÷åê
   è ïðè çàãðóçêå ïîëó÷èò ëîìàííóþ êðèâóþ, íî ýòîò ôóíêöèîíàë íå çàëîæåí */
   // ñîõðàíÿåì êðèâóþ íàìàãíè÷èâàíèÿ çàäàííóþ ëîìàííîé
   stream << _X.size() << " ";
   for(int i=0, n=_X.size(); i<n; i++){
      stream << _X[i] << " ";
      stream << _Y[i] << " ";
      }
}
//---------------------------------------------------------------------------
void PCurve::Read(istream &stream){    // çàãðóçêà ïàðàìåòðîâ îáúåêòà èç ïîòîêà
   // ÷èòàåì êðèâóþ íàìàãíè÷èâàíèÿ çàäàííóþ ëîìàííîé
   int n=0;
   stream >> n;
   PType X, Y;
   for(int i=0; i<n; i++){
      stream >> X;   _X.push_back(X);
      stream >> Y;   _Y.push_back(Y);
      }
   //  åñëè ëîìîíîé êðèâàÿ çàäàíà
   if( size() > 0 ) exist = true;
   //else             exist = false;  // íå ôàêò, ò.ê. ìîæåò áûòü çàäàíà àíàëèòè÷åñêàÿ ôóíêöèÿ - îñòàâëÿåì êàê åñòü 
}














//---------------------------------------------------------------------------
void MagnCurve :: set(PType F, PType I){
   _set(F,I);
}
PType __fastcall MagnCurve :: F(PType _I_){
   return X(_I_);
}
PType __fastcall MagnCurve :: I(PType _F_){
   return Y(_F_);
}
//---------------------------------------------------------------------------
void UICurve :: set(PType I, PType U){
   _set(I,U);
}
PType __fastcall UICurve :: I(PType _U_){
   return X(_U_);
}
PType __fastcall UICurve :: U(PType _I_){
   return Y(_I_);
}





//---------------------------------------------------------------------------
/* Áàçîâûé êëàññ äëÿ ñèëîâûõ òðàíñôîðìàòîðîâ */
PTransformer::PTransformer(unsigned NumBranches, unsigned NumNodes, unsigned NumCircuit) :
					PUnit(NumBranches, NumNodes, NumCircuit){
   Describe_Fields();   // îïèøåì ñâîéñòâà êëàññà
   /* çàäàäèì òðàíñô ñ êîýô òðàíñôîðìàöèè 1 */
   U1 = 1;
   U2 = 1;
   S  = 1;
   dPk= 0;
   Uk = 10.5;
   dPx= 0;
   Ix = MIN;
   freq = 50;
   F_nom = 0.01;
   Name = "Òð";  // èìÿ îáúåêòà
}
//---------------------------------------------------------------------------
void PTransformer::Describe_Fields(){
   PFieldInfo fi;
   // ìîùíîñòü
   fi.Name = "Ìîùíîñòü";
   fi.Type = "PType";
   fi.ptr = (void*) &S;
   Fields.push_back(fi);
   // ïåðâè÷íîå íàïðÿæåíèå
   fi.Name = "U1";
   fi.Type = "PType";
   fi.ptr = (void*) &U1;
   Fields.push_back(fi);
   // âòîðè÷íîå íàïðÿæåíèå
   fi.Name = "U2";
   fi.Type = "PType";
   fi.ptr = (void*) &U2;
   Fields.push_back(fi);
   // Íàïðÿæåíèå Êç
   fi.Name = "Íàïð. ê.ç.";
   fi.Type = "PType";
   fi.ptr = (void*) &Uk;
   Fields.push_back(fi);
   // Ïîòåðè Êç
   fi.Name = "Àêò.ïîòåðè ê.ç.";
   fi.Type = "PType";
   fi.ptr = (void*) &dPk;
   Fields.push_back(fi);
   // Òîê xx
   fi.Name = "Òîê x.x.";
   fi.Type = "PType";
   fi.ptr = (void*) &Ix;
   Fields.push_back(fi);
   // Ïîòåðè xx
   fi.Name = "Àêò.ïîòåðè x.x.";
   fi.Type = "PType";
   fi.ptr = (void*) &dPx;
   Fields.push_back(fi);
   // Íîìèíàëüíàÿ ÷àñòîòà
   fi.Name = "Íîì.÷àñòîòà";
   fi.Type = "PType";
   fi.ptr = (void*) &freq;
   Fields.push_back(fi);
   // Íîìèíàëüíûé ïîòîê
   fi.Name = "Íîì.ïîòîê";
   fi.Type = "PType";
   fi.ptr = (void*) &F_nom;
   Fields.push_back(fi);
}
/*/---------------------------------------------------------------------------
PType PTransformer :: U1()  {return _U1;}                // ÷òåíèå çíà÷åíèÿ íàïðÿæåíèÿ ïåðâè÷íéî îáìîòêè
PType PTransformer :: U2()  {return _U2;}
PType PTransformer :: S()   {return _S;}
PType PTransformer :: dPk() {return _dPk;}
PType PTransformer :: Uk()  {return _Uk;}
PType PTransformer :: dPx() {return _dPx;}
PType PTransformer :: Ix()  {return _Ix;}
PType PTransformer :: freq(){return _freq;}
PType PTransformer :: F_nom(){return _F_nom;}
//---------------------------------------------------------------------------
void PTransformer  :: U1(PType value)  {_U1   = value;}      // óñòàíîâêà íàïðÿæåíèÿ
void PTransformer  :: U2(PType value)  {_U2   = value;}
void PTransformer  :: S(PType value)   {_S    = value;}
void PTransformer  :: dPk(PType value) {_dPk  = value;}
void PTransformer  :: Uk(PType value)  {_Uk   = value;}
void PTransformer  :: dPx(PType value) {_dPx  = value;}
void PTransformer  :: Ix(PType value)  {_Ix   = value;}
void PTransformer  :: freq(PType value){_freq = value;}
void PTransformer  :: F_nom(PType value){_F_nom= value;}  */
//---------------------------------------------------------------------------
void PTransformer::Save(ostream &stream){		// ñîõðàíåíèå ïàðàìåòðîâ îáúåêòà â ïîòîê
   // ñíà÷àëà ñîõðàíèòñÿ áàçîâûé êëàññ
   sire::Save(stream);
   // òåïåðü ñîõðàíÿåì ýòîò êëàññ
   stream << n1 << " ";
   stream << n2 << " ";
   stream << U1 << " ";
   stream << U2 << " ";
   stream << S  << " ";
   stream << dPk<< " ";
   stream << Uk << " ";
   stream << dPx<< " ";
   stream << Ix << " ";
   stream <<freq<< " ";
   stream <<F_nom<< " ";
}
//---------------------------------------------------------------------------
void PTransformer::Read(istream &stream){    // çàãðóçêà ïàðàìåòðîâ îáúåêòà èç ïîòîêà
   // ñíà÷àëà ÷èòàåò äàííûå áàçîâûé êëàññ
   sire::Read(stream);
   // òåïåðü ÷èòàåì ýòîò êëàññ
   stream >> n1;
   stream >> n2 ;
   stream >> U1 ;
   stream >> U2 ;
   stream >> S  ;
   stream >> dPk;
   stream >> Uk ;
   stream >> dPx;
   stream >> Ix ;
   stream >>freq;
   stream >>F_nom;
}
//---------------------------------------------------------------------------
String PTransformer::ClassName(){return "PTransformer";};				// âîçâðàùàåò èìÿ êëàññà









PTransformer_1::PTransformer_1() :
					PTransformer(5, 5, 1),
               X1(2), X2(2){	// óêàçàíû 4, íî èñïîëüçóþòñÿ òîëüêî ñ èíäåêñàìè 1-3, Õ1[0] == X1[_N_] íå èñïîëüçóåòñÿ
   set_pins();          // óñòàíîâèì âûâîäû
   Describe_Fields();   // îïèøåì ïîëÿ
  	// çàïîëíÿåì ìàòðèöû
   char _M[5][5] =   {{-1, 0, 0,-1, 0},
                      { 1, 0, 0, 0, 0},
                      { 0,-1, 0, 0,-1},
                      { 0, 1, 0, 0, 0},
                      { 0, 0, 0, 1, 1}};
	*M = (char*)_M;
   char _N[1][5] =    {{0, 0, 1, 0, 0}};
   *N = (char*)_N;
   //mCurve.set(0,0);
   //mCurve.set(1e3,1e6);  // ëèíåéíàÿ êðèâàÿ íàìàãíè÷èâàíèÿ ñ íàñûùåíèåì ïðè ãðàìàíäîé èíäóêöèè
   //_Bnom = 1.2; 		// óñòàíîâêà ïàðàìåòðîâ òðàíñôîðìàòîðà äëÿ äàííîé íîìèíàëüíîé èíäóêöèè
   //Params(_U1,_U2,_S,_dPk,_Uk,_dPx,_Ix,_freq);
   // ñîïðîòâëåíèå óòå÷êè îáìîòîê
   *R[3] = *R[4] = MAX;
   // ðàññ÷èòàåì ïàðàìåòðû ñõåìû íà îñíîâå óñòàíîâëåííûõ äàííûõ
   Name = "ÎÒð";  // èìÿ îáúåêòà
   Grounded_Node = 4;   // çàçåìëÿåìûé óçåë
}
//---------------------------------------------------------------------------
void PTransformer_1 :: set_pins(){
   X1 [_N_] = set_pin(1);
   X1 [_A_] = set_pin(0);
   X2 [_N_] = set_pin(3);
   X2 [_A_] = set_pin(2);
   // èìåíà
   X1.Name  = "X1";
   X2.Name  = "X2";
	// äîáàâèì â ñïèñîê ãðóïï âûâîäîâ
	Out.add(&X1);
   Out.add(&X2);
}
//---------------------------------------------------------------------------
void PTransformer_1::Describe_Fields(){
   PFieldInfo fi;
   // Êðèâàÿ íàìàãíè÷èâàíèÿ
   fi.Name = "I(Ô)";
   fi.Type = "PCurve";
   fi.ptr = (void*) &mCurve;
   Fields.push_back(fi);
}
//---------------------------------------------------------------------------
bool PTransformer_1 :: accept(){
   if(Ix==0) {
   	err(0, "PTransformer_1: òîê õ.õ. íå ìîæåò áûòü ðàâíûì íóëþ");
      Ix=MIN;
      return false;
   	}
   // êîýôôèöèåíòû
   PType k = U1 / U2;        // äåéñòâèòåëüíûé êîýôôèöèåíò òðàíñôîðìàöèè
   PType w = 2*freq*M_PI;     // óãëîâàÿ ÷àñòîòà

   // àêòèâíîå ñîïðîòèâëåíèå îáìîòîê
   PType R_sum = dPk * pow(U1,2) / pow(S,2);
   PType R1 = 0.5 * R_sum;
   PType R2 = R1 / pow(k,2);
   // òîê õîëîñòîãî õîäà (â Àìïåðàõ)
   PType __Ix = Ix/100 * S/U1;   // â Àìïåðàõ
   // ðåàêòèâíûå ïîòåðè õîëîñòîãî õîäà
   PType dQ2 = pow(__Ix*U1,2) - pow(dPx,2);
   if(dQ2<0){
      err(0, "PTransformer_1::accept(): ïàðàìåòðû òðàíñôîðìàòîðà çàäàíû íå âåðíî.Ñëèøêîì ìàëåíüêèé òîê õ.õ. äëÿ çàäàííûõ àêòèâí. ïîòåðü õ.õ.");
      return false;
      }
   PType dQx = sqrt( dQ2 );
   PType q_xx;	// óãîë ìåæäó òîêîì è íàïðÿæåíèåì  õîëîñòîãî õîäà
   if(dPx) q_xx = atan(dQx/dPx);
   else    q_xx = M_PI/2;
   // ÷èñëî âèòêîâ îáìîòîê
   n1 = U1 / (w*F_nom);
   n2 = n1 / k;
   // ñîïðîòèâëåíèå öåïè íàìàãíè÷èâàíèÿ (ó÷åò ïîòåðü)
   PType Zu = __Ix * n1 / F_nom;
   PType Ru = Zu * sin(q_xx);
   PType Xu = Zu * cos(q_xx);
   // ðåàêòèâíîå ñîïðîòèâëåíèå îáìîòîê
   PType Z_sum =  Uk/100 * pow(U1,2) / S;
   PType X_sum2 = pow(Z_sum,2) - pow(R_sum,2);
   if(X_sum2<0){
      err(0, "PTransformer_1::accept(): ïàðàìåòðû òðàíñôîðìàòîðà çàäàíû íå âåðíî.Ñëèøêîì ìàëåíüêèé òîê Uk äëÿ çàäàííûõ àêòèâí. ïîòåðü ê.ç.");
      return false;
      }
   PType X_sum =  sqrt( X_sum2 );
   PType dX1 = X_sum / 2;   // ñîïðîòèâëåíèå ðàññåÿíèÿ ïåðâè÷íîé îáìîòêè
   PType dX2 = dX1 / pow(k,2);      // ñîïðîòèâëåíèå ðàññåÿíèÿ âòîðè÷íîé îáìîòêè */


   // óñòàíàâëèâàåì ïàðàìåòðû
   *R[0] = R1; *L[0] = dX1/w;
   *R[1] = R2; *L[1] = dX2/w;
   *R[2] = Ru; *L[2] = Xu/w;
   magnetic_link(0,2,n1);
   magnetic_link(1,2,n2);
   update_differential_resistance();   // ïåðåñ÷èòûâàåì äèôôåðåíöèàëüíûå ñîïðîòèâëåíèÿ
   return true;
}
//---------------------------------------------------------------------------
bool PTransformer_1 :: update_elements(bool force_update){
   // îáíîâëÿåì ïàðàìåòðû ñõåìû â ñîîòâåòñòâèè ñ êðèâîé íàìàãíè÷èâàíèÿ
   if( !mCurve.exist )  // çàäàíà ëè êðèâàÿ íàìàãíè÷èâàíèÿ
      return false;
   else{
   	PType Ru;
      PType _F = *I[2];          	// çíà÷åíèå ïîòîêà
      if(!_F) return false;
      PType _Ip = mCurve.I(_F);   	// êàêîé äîëæåíà áûòü ìãíîâ. ðåàêòèâíàÿ ñîñòàâëÿþùàÿ òîêà õîëîñòîãî õîäà
      PType _U = *f[0] - *f[1];		// íàïðÿæåíèå íà îáìîòêå
      PType dRxx = pow(U1,2)/dPx;	// êîýô. ïðîïîðöèîíàëüíîñòè ìåæäó íàïðÿæ íà îáìîòêå è àêò ñîñò òîêà õõ.
      PType _Ia = _U / dRxx;			// ìãíîâåííîå àêòèâíî ñîñòàâë òîêà õõ
      PType _I = _Ia + _Ip; 			// ìãíîâ. çíà÷åíèå òîêà õõ

      static PType _F_1 = 0;
      PType d_F = (_F - _F_1)/smp;
      Ru = (n1*_I - *L[2]*d_F)/_F; // óñòàíàâëèâàåì àêòèâíîå ñîïðîòèâëåíèå ìàãíèòîïðîâîäà, êîòîðîå âëèÿåò íà ïîòåðè
      if(Ru<0)	Ru=0;						// ñîïðîòèâë. íå ä.á. îòðèö. - ýòî ïîãðåøíîñòü ðàñ÷åòà
      _F_1 = _F;
      *R[2] = Ru;
      return true;
      }
}
//---------------------------------------------------------------------------
void PTransformer_1 :: R1(PType value){ *R[0] = value; }
void PTransformer_1 :: L1(PType value){ *L[0] = value; }
void PTransformer_1 :: R2(PType value){ *R[1] = value; }
void PTransformer_1 :: L2(PType value){ *L[1] = value; }
void PTransformer_1 :: Gz1(PType value){   *R[3] = 1/value; }
void PTransformer_1 :: Cz1(PType value){   *C[3] = value;   }
void PTransformer_1 :: Gz2(PType value){   *R[4] = 1/value; }
void PTransformer_1 :: Cz2(PType value){   *C[4] = value;   }
PType PTransformer_1 :: R1()   { return *R[0];      }
PType PTransformer_1 :: L1()   { return *L[0];      }
PType PTransformer_1 :: R2()   { return *R[1];      }
PType PTransformer_1 :: L2()   { return *L[1];      }
PType PTransformer_1 :: Gz1()  { return 1/(*R[3]);  }
PType PTransformer_1 :: Cz1()  { return *C[3];      }
PType PTransformer_1 :: Gz2()  { return 1/(*R[4]);  }
PType PTransformer_1 :: Cz2()  { return *C[4];      }
//---------------------------------------------------------------------------
void PTransformer_1::Save(ostream &stream){		// ñîõðàíåíèå ïàðàìåòðîâ îáúåêòà â ïîòîê
   // ñíà÷àëà ñîõðàíèòñÿ áàçîâûé êëàññ
   sire::Save(stream);
   // ñîõðàíÿåì êðèâóþ íàìàãíè÷èâàíèÿ
   mCurve.Save(stream);
}
//---------------------------------------------------------------------------
void PTransformer_1::Read(istream &stream){    // çàãðóçêà ïàðàìåòðîâ îáúåêòà èç ïîòîêà
   // ñíà÷àëà ÷èòàåò äàííûå áàçîâûé êëàññ
   sire::Read(stream);
   // òåïåðü ÷èòàåì ýòîò êëàññ
   // ÷èòàåì êðèâóþ íàìàãíè÷èâàíèÿ
   mCurve.Read(stream);
}
//---------------------------------------------------------------------------
String PTransformer_1::ClassName(){return "PTransformer_1";};				// âîçâðàùàåò èìÿ êëàññà
















// òðàíñôîðìàòîð (ïî óìîë÷àíèþ òðåõñòðåðæíåâîé)
PTransformer_3 ::PTransformer_3():
					PTransformer(23, 18, 6),
               X1(4), X2(4), X1n(4), X2n(4){	// óêàçàíû 4, íî èñïîëüçóþòñÿ òîëüêî ñ èíäåêñàìè 1-3, Õ1[0] == X1[_N_] íå èñïîëüçóåòñÿ
	set_pins();	         // óñòàíîâêà âûâîäîâ
   Describe_Fields();   // îïèñûâàåì ïîëÿ
   	// çàïîëíÿåì ìàòðèöû
   char _M[18][23] = {{-1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,-1, 0, 0, 0, 0, 0, 0, 0},
                      { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,-1, 0},
                      { 0,-1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,-1, 0, 0, 0, 0, 0, 0},
                      { 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,-1},
                      { 0, 0,-1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,-1, 0, 0, 0, 0, 0},
                      { 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
                      { 0, 0, 0,-1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,-1, 0, 0, 0, 0},
                      { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
                      { 0, 0, 0, 0,-1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,-1, 0, 0, 0},
                      { 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
                      { 0, 0, 0, 0, 0,-1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,-1, 0, 0},
                      { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
                      { 0, 0, 0, 0, 0, 0,-1, 0, 0,-1, 0,-1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
                      { 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0,-1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
                      { 0, 0, 0, 0, 0, 0, 0,-1, 0, 0, 0, 1, 0,-1, 0, 0, 0, 0, 0, 0, 0, 0, 0},
                      { 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0,-1, 0, 0, 0, 0, 0, 0, 0, 0},
                      { 0, 0, 0, 0, 0, 0, 0, 0,-1, 0,-1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0},
                      { 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1}};

	*M = (char*)_M;
   char _N[6][23] =  {{ 0, 0, 0, 0, 0, 0, 1, 0, 0,-1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
                      { 0, 0, 0, 0, 0, 0,-1, 1, 0, 0, 0, 1,-1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
                      { 0, 0, 0, 0, 0, 0, 0,-1, 1, 0, 0, 0, 0, 1,-1, 0, 0, 0, 0, 0, 0, 0, 0},
                      { 0, 0, 0, 0, 0, 0, 0, 0,-1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
                      { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,-1, 0, 0, 0, 0, 0, 1, 0},   // ñîïðîòèâëåíèå â íåéòðàëè ïåðâîé îáìîòêè
                      { 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,-1, 0, 0, 0, 0, 0, 1}};  // ñîïðîòèâëåíèå â íåéòðàëè âòîðîé îáìîòêè
   *N = (char*)_N;
   mType = Armored;           // òèï ìàãíèòîïðîâîäà - áðîíåâîé
   Winding_X1 = Winding_X2 = wStar;   // ñõåìà ñîåäèíåíèÿ îáìîòîê - çâåçäà
   // êðàéíèå ñòåðæíè îòñóòñòâóþò (èìåþò áîëüøîå ñîïðîòèâëåíèå)
   *R[9] = *R[10] = MAX;
	// ñòåðæíè ñ îáìîòêàìè è ÿðìà èìåþò ìèíèìàëüíîå ñîïðîòèâëåíèå
   *R[6] = *R[7] = *R[8] = *R[11] = *R[12] = *R[13] = *R[14] = MIN;
   // èíäóêòèâíîñòü ñòåðæíåé
   *L[6] = *L[7] = *L[8] = 0.63; // Ãåíðè
   // Èíäóêòèâíîñòü îáìîòîê âûâîäîâ Õ1
   *L[0] = *L[2] = *L[4] = 0.25;
   // èíäóêòèâíîñòü îáìîòîê âûâîäîâ Õ2 (êîýôôèöèåíò òðàíñôîðìàöèè îïðåäåëÿåòñÿ ñîîòíîøåíèåì èíäóêòèâíîñòåé)
   *L[1] = *L[3] = *L[5] = 0.25;
   // ñîïðîòâëåíèå óòå÷êè îáìîòîê
   *R[15] = *R[16] = *R[17] = *R[18] = *R[19] = *R[20] = MAX;
   // ñîïðîòèâëåíèå â íåòðàëÿõ (ðàççàçåìëåíû)
   *R[21] = *R[22] = MAX; // ýòî íåîáõîäèìî òàê êàê åùå íå èçâåñòíî ñâÿçàíû ëè âûâîäû ñî ñòîðîíû íåéòðàëè ó îáìîòîê
   // ñîåäèíÿåì îáìîòêè òðàíñôîðìàòîðà
   Link_Windings();
   Name = "Òð";  // èìÿ îáúåêòà
   Grounded_Node = 17;   // çàçåìëÿåìûé óçåë
}
//---------------------------------------------------------------------------
void PTransformer_3 :: set_pins(){
   X1 [_N_] = set_pin(17);
   X1 [_A_] = set_pin(0);
   X1 [_B_] = set_pin(4);
   X1 [_C_] = set_pin(8);
   X1n[_N_] = set_pin(1);// äà-äà ýòî íå îïå÷àòêà
   X1n[_A_] = set_pin(1);
   X1n[_B_] = set_pin(5);
   X1n[_C_] = set_pin(9);
   X2 [_N_] = set_pin(17);
   X2 [_A_] = set_pin(2);
   X2 [_B_] = set_pin(6);
   X2 [_C_] = set_pin(10);
   X2n[_N_] = set_pin(3); //äà-äà ýòî íå îïå÷àòêà
   X2n[_A_] = set_pin(3);
   X2n[_B_] = set_pin(7);
   X2n[_C_] = set_pin(11);
   // èìåíà
   X1.Name  = "X1";
   X2.Name  = "X2";
   X1n.Name = "X1n";
   X2n.Name = "X2n";
	// äîáàâèì â ñïèñîê ãðóïï âûâîäîâ
	Out.add(&X1);
   Out.add(&X2);
   Out.add(&X1n);
   Out.add(&X2n);
}
//---------------------------------------------------------------------------
void PTransformer_3::Describe_Fields(){
   PFieldInfo fi;
   // òèï ìàãíèòíîé ñèñòåìû
   fi.Name = "Ìàãí.ñèñò.";
   fi.Type = "MagnCircuit_Type";
   fi.ptr = (void*) &mType;
   Fields.push_back(fi);
   // Ñõåìà ñîåäèíåíèÿ ïåðâè÷íîé îáìîòêè
   fi.Name = "Ïåðâ.îáì.";
   fi.Type = "Winding_Connect";
   fi.ptr = (void*) &Winding_X1;
   Fields.push_back(fi);
   // Ñõåìà ñîåäèíåíèÿ âòîðè÷íîé îáìîòêè
   fi.Name = "Âòîð.îáì.";
   fi.Type = "Winding_Connect";
   fi.ptr = (void*) &Winding_X2;
   Fields.push_back(fi);
   // Êðèâàÿ íàìàãíè÷èâàíèÿ
   fi.Name = "I(Ô)";
   fi.Type = "PCurve";
   fi.ptr = (void*) &mCurve;
   Fields.push_back(fi);
}
//---------------------------------------------------------------------------
void __fastcall PTransformer_3 :: R1(PType value){  // óñòàíîâêà àêòèâíûõ ñîïðîòèâëåíèé íà ôàçó
   *R[0] = *R[2] = *R[4] = value;
}
void __fastcall PTransformer_3 :: L1(PType value){  // óñòàíîâêà èíäóêòèâíîñòè ôàçû
   *L[0] = *L[2] = *L[4] = value;
}
void __fastcall PTransformer_3 :: C1(PType value){  // óñòàíîâêà åìêîñòè ôàçû
   *C[0] = *C[2] = *C[4] = value;
}
void __fastcall PTransformer_3 :: Gz1(PType value){ // óñòàíîâêà àêòèâíûõ ïðîâîäèìîñòåé íà çåìëþ
   *R[15] = *R[17] = *R[19] = 1/value;
}
void __fastcall PTransformer_3 :: Cz1(PType value){ // óñòàíîâêà åìêîñòåé íà çåìëþ
   *C[15] = *C[17] = *C[19] = value;
}
PType PTransformer_3 :: R1(Phase ph){  // óñòàíîâêà àêòèâíûõ ñîïðîòèâëåíèé íà ôàçó
   switch(ph){
      case _A_: return *R[0];
      case _B_: return *R[2];
      case _C_: return *R[4];
      case _N_: return *R[21];
      default:  err(0,"PTransformer::R1(): íå âåðíî óêàçàíà ôàçà"); return null;
   }
}
PType PTransformer_3 :: L1(Phase ph){  // óñòàíîâêà èíäóêòèâíîñòè ôàçû
   switch(ph){
      case _A_: return *L[0];
      case _B_: return *L[2];
      case _C_: return *L[4];
      case _N_: return *L[21];
      default:  err(0,"PTransformer::R1(): íå âåðíî óêàçàíà ôàçà"); return null;
   }
}
PType PTransformer_3 :: C1(Phase ph){  // óñòàíîâêà åìêîñòè ôàçû
   switch(ph){
      case _A_: return *C[0];
      case _B_: return *C[2];
      case _C_: return *C[4];
      case _N_: return *C[21];
      default:  err(0,"PTransformer::R1(): íå âåðíî óêàçàíà ôàçà"); return null;
   }
}
PType PTransformer_3 :: Gz1(Phase ph){ // óñòàíîâêà àêòèâíûõ ïðîâîäèìîñòåé íà çåìëþ
   switch(ph){
      case _A_: return 1/(*R[15]);
      case _B_: return 1/(*R[17]);
      case _C_: return 1/(*R[19]);
      default:  err(0,"PTransformer::R1(): íå âåðíî óêàçàíà ôàçà"); return null;
   }
}
PType PTransformer_3 :: Cz1(Phase ph){ // óñòàíîâêà åìêîñòåé íà çåìëþ
   switch(ph){
      case _A_: return *C[15];
      case _B_: return *C[17];
      case _C_: return *C[19];
      default:  err(0,"PTransformer::R1(): íå âåðíî óêàçàíà ôàçà"); return null;
   }
}
//---------------------------------------------------------------------------
void __fastcall PTransformer_3 :: R2(PType value){  // óñòàíîâêà àêòèâíûõ ñîïðîòèâëåíèé íà ôàçó
   *R[1] = *R[3] = *R[5] = value;
}
void __fastcall PTransformer_3 :: L2(PType value){  // óñòàíîâêà èíäóêòèâíîñòè ôàçû
   *L[1] = *L[3] = *L[5] = value;
}
void __fastcall PTransformer_3 :: C2(PType value){  // óñòàíîâêà åìêîñòè ôàçû
   *C[1] = *C[3] = *C[5] = value;
}
void __fastcall PTransformer_3 :: Gz2(PType value){ // óñòàíîâêà àêòèâíûõ ïðîâîäèìîñòåé íà çåìëþ
   *R[16] = *R[18] = *R[20] = 1/value;
}
void __fastcall PTransformer_3 :: Cz2(PType value){ // óñòàíîâêà åìêîñòåé íà çåìëþ
   *C[16] = *C[18] = *C[20] = value;
}
PType PTransformer_3 :: R2(Phase ph){  // óñòàíîâêà àêòèâíûõ ñîïðîòèâëåíèé íà ôàçó
   switch(ph){
      case _A_: return *R[1];
      case _B_: return *R[3];
      case _C_: return *R[5];
      case _N_: return *R[22];
      default:  err(0,"PTransformer::R1(): íå âåðíî óêàçàíà ôàçà"); return null;
   }
}
PType PTransformer_3 :: L2(Phase ph){  // óñòàíîâêà èíäóêòèâíîñòè ôàçû
   switch(ph){
      case _A_: return *L[1];
      case _B_: return *L[3];
      case _C_: return *L[5];
      case _N_: return *L[22];
      default:  err(0,"PTransformer::R1(): íå âåðíî óêàçàíà ôàçà"); return null;
   }
}
PType PTransformer_3 :: C2(Phase ph){  // óñòàíîâêà åìêîñòè ôàçû
   switch(ph){
      case _A_: return *C[1];
      case _B_: return *C[3];
      case _C_: return *C[5];
      case _N_: return *C[22];
      default:  err(0,"PTransformer::R1(): íå âåðíî óêàçàíà ôàçà"); return null;
   }
}
PType PTransformer_3 :: Gz2(Phase ph){ // óñòàíîâêà àêòèâíûõ ïðîâîäèìîñòåé íà çåìëþ
   switch(ph){
      case _A_: return 1/(*R[16]);
      case _B_: return 1/(*R[18]);
      case _C_: return 1/(*R[20]);
      default:  err(0,"PTransformer::R1(): íå âåðíî óêàçàíà ôàçà"); return null;
   }
}
PType PTransformer_3 :: Cz2(Phase ph){ // óñòàíîâêà åìêîñòåé íà çåìëþ
   switch(ph){
      case _A_: return *C[16];
      case _B_: return *C[18];
      case _C_: return *C[20];
      default:  err(0,"PTransformer::R1(): íå âåðíî óêàçàíà ôàçà"); return null;
   }
}
//---------------------------------------------------------------------------
/* Ðàññ÷èòûâàåì ïàðàìåòðû ñõåìû çàìåùåíèÿ */
bool PTransformer_3 :: accept(){
   if(Ix==0) {
   	err(0, "PTransformer_1: òîê õ.õ. íå ìîæåò áûòü ðàâíûì íóëþ");
      Ix=MIN;
      return false;
   	}
   // ïàðàìåòðû ïðåñ÷èòàííûå íà ôàçó
   PType U1_f,  U2_f, S_f;    // íîìèíàëüíûå íàïðÿæåíèÿ è ìîùíîñòü òðàíñôîðìàòîðà
   PType dPk_f, Uk_f;  		   // äàííûå ÊÇ
   PType dPx_f, Ix_f;			   // äàííûå õîëîñòîãî õîäà
   // ñ÷èòàåì îáå îáìîòêè ñîåäèíåííûìè â çâåçäó
   // ïîòîì ïðîèçâåäåì ïðåîáðàçîâàíèå òðåóãîëüíèêà â çâåçäó (! íå çàáûòü ïåðåñ÷èòàòü ÷èñëî âèòêîâ)
   S_f = S/3;
   dPx_f = dPx/3;
   dPk_f = dPk/3;
   U1_f =  U1/sqrt(3);
   U2_f =  U2/sqrt(3);

   // êîýôôèöèåíòû
   PType k = U1_f / U2_f;        // äåéñòâèòåëüíûé êîýôôèöèåíò òðàíñôîðìàöèè
   PType w = 2*freq*M_PI;     // óãëîâàÿ ÷àñòîòà

   // 1. Ðàññ÷åò ïàðàìåòðîâ íà 1 ôàçó
   // àêòèâíîå ñîïðîòèâëåíèå îáìîòîê
   PType R_sum = dPk_f * pow(U1_f,2) / pow(S_f,2);
   PType R1 = 0.5 * R_sum;
   PType R2 = R1 / pow(k,2);
   // òîê õîëîñòîãî õîäà (â Àìïåðàõ)
   PType __Ix = Ix/100 * S_f/U1_f;   // â Àìïåðàõ
   // ðåàêòèâíûå ïîòåðè õîëîñòîãî õîäà
   PType dQ2_f = pow(__Ix*U1_f,2) - pow(dPx_f,2);
   if(dQ2_f<0){
      err(0, "PTransformer_3::accept(): ïàðàìåòðû òðàíñôîðìàòîðà çàäàíû íå âåðíî.Ñëèøêîì ìàëåíüêèé òîê õ.õ. äëÿ çàäàííûõ àêòèâí. ïîòåðü õ.õ.");
      return false;
      }
   PType dQx_f = sqrt( dQ2_f );
   PType q_xx;	// óãîë ìåæäó òîêîì è íàïðÿæåíèåì  õîëîñòîãî õîäà
   if(dPx) q_xx = atan(dQx_f/dPx_f);
   else    q_xx = M_PI/2;
   // ÷èñëî âèòêîâ îáìîòîê
   n1 = U1_f / (w*F_nom);
   n2 = n1 / k;
   // ñîïðîòèâëåíèå öåïè íàìàãíè÷èâàíèÿ (ó÷åò ïîòåðü)
   PType Zu = __Ix * n1 / F_nom;
   PType Ru = Zu * sin(q_xx);
   PType Xu = Zu * cos(q_xx);
   // ðåàêòèâíîå ñîïðîòèâëåíèå îáìîòîê
   PType Z_sum =  Uk/100 * pow(U1_f,2) / S_f;
   PType X_sum2 = pow(Z_sum,2) - pow(R_sum,2);
   if(X_sum2<0){
      err(0, "PTransformer_3::accept(): ïàðàìåòðû òðàíñôîðìàòîðà çàäàíû íå âåðíî.Ñëèøêîì ìàëåíüêèé òîê Uk äëÿ çàäàííûõ àêòèâí. ïîòåðü ê.ç.");
      return false;
      }
   PType X_sum =  sqrt( X_sum2 );
   PType dX1 = X_sum / 2;           // ñîïðîòèâëåíèå ðàññåÿíèÿ ïåðâè÷íîé îáìîòêè
   PType dX2 = dX1 / pow(k,2);      // ñîïðîòèâëåíèå ðàññåÿíèÿ âòîðè÷íîé îáìîòêè */
   // 2. ïåðåñ÷åò îáìîòîê
   if( Winding_X1 == wTriangle ){ // åñëè îáìîòêà áûëà ñîåäèíåíû â òðåóãîëüíèê, òî ïåðåñ÷èòûâàåì ïàðàìåòðû
      R1 = 3*R1;
      dX1 = 3*dX1;
      n1 = n1 * sqrt(3);
      }
   if( Winding_X2 == wTriangle ){ // åñëè îáìîòêà áûëà ñîåäèíåíû â òðåóãîëüíèê, òî ïåðåñ÷èòûâàåì ïàðàìåòðû
      R2 = 3*R2;
      dX2 = 3*dX2;
      n2 = n2 * sqrt(3);
      }
   // 3. ïåðåñ÷åò ñîïðîòèâëåíèé ìàãíèòíîé ñèñòåìû
   PType Ru_st, Ru_ya;                 // ìàãíèòíûå ñîïðîòèâëåíèÿ ñòåðæíÿ è ÿðìà
   PType Xu_st, Xu_ya;
   if( mType == Three_Rod ){           // åñëè òðåõñòåðæíåâîé
      Ru_st = 0.8 * Ru;
      Xu_st = 0.8 * Xu;
      Ru_ya = Ru_st / 8;
      Xu_ya = Xu_st / 8;
      *R[9] = *R[10] = MAX;            // ñîïðîòèâëåíèå êðàéíèõ ñòåðæíåé
      }
   else if( mType == Armored ){        // åñëè áðîíèðîâàííàÿ ìàãíèòíàÿ ñèñòåìà
      Ru_st = Ru / 1.223;
      Xu_st = Xu / 1.223;
      Ru_ya = Ru_st / 8;
      Xu_ya = Xu_st / 8;
      *R[9] = *R[10] = 8*Ru_st + Ru_ya;// ñîïðîòèâëåíèå êðàéíèõ ñòåðæíåé
      *L[9] = *L[10] = 8*Xu_st + Xu_ya;
      }
   else{
      err(0,"PTransformer_3::accept(): Òèï ìàãíèòíîé ñèñòåìû íå èçâåñòåí");
      return false;
      }
   // óñòàíàâëèâàåì ïàðàìåòðû
   // > ïåðâè÷íàÿ îáìîòêà
   *R[0] = *R[2] = *R[4] = R1;
   *L[0] = *L[2] = *L[4] = dX1/w;
   // > âòîðè÷íàÿ îáìîòêà
   *R[1] = *R[3] = *R[5] = R2;
   *L[1] = *L[3] = *L[5] = dX2/w;
   // > ñòåðæíè
   *R[6] = *R[7] = *R[8] = Ru_st;
   *L[6] = *L[7] = *L[8] = Xu_st/w;
   // > ÿðìà
   *R[11] = *R[12] = *R[13] = *R[14] = Ru_ya;
   *L[11] = *L[12] = *L[13] = *L[14] = Xu_ya/w;
   // > ìàãíèòíàÿ ñâÿçü ïåðâè÷íàÿ îáìîòêà
   magnetic_link(0,6,n1);
   magnetic_link(2,7,n1);
   magnetic_link(4,8,n1);
   // > ìàãíèòíàÿ ñâÿçü âòîðè÷íàÿ îáìîòêà
   magnetic_link(1,6,n2);
   magnetic_link(3,7,n2);
   magnetic_link(5,8,n2);
   // ñáîðêà îáìîòîê
   if(!Link_Windings()) return false;
   update_differential_resistance();   // ïåðåñ÷èòûâàåì äèôôåðåíöèàëüíûå ñîïðîòèâëåíèÿ
   return true;
}
//---------------------------------------------------------------------------
/* Ïåðåñ÷åò ñîïðîòèâëåíèÿ öåïè íàìàãíè÷èâàíèÿ */
bool PTransformer_3 :: update_elements(bool force_update){
   // îáíîâëÿåì ïàðàìåòðû ñõåìû â ñîîòâåòñòâèè ñ êðèâîé íàìàãíè÷èâàíèÿ
   if( !mCurve.exist )  // çàäàíà ëè êðèâàÿ íàìàãíè÷èâàíèÿ
      return false;
   else{
      #define PT3_FST_Ru     6      // ïåðâàÿ ïî íîìåðó ìàãíèòíàÿ âåòâü
      #define PT3_NUM_Ru     9      // ÷èñëî ìàãíèòíûõ âåòâåé
      PType _F,Ru;      	// çíà÷åíèå ïîòîêà è ñîîòâåòñòâóþùåãî åìó ñîïðîòèâëåíèÿ
      for(unsigned i= 0; i< PT3_NUM_Ru; i++ ){
         _F = *I[ i + PT3_FST_Ru ];
         if(_F!=0){
         	Ru  = n1*mCurve.I(_F)/_F; 		// ñîïðîòèâëåíèÿ âåòâåé ìàãíèòîïðîâîäîâ
         	if(Ru>=0) *R[ i + PT3_FST_Ru ] = Ru;   // óñòàíîâèì ñîïðîòèâëåíèå
         	}
         }
      return true;
      /*/PType _Ip[ PT3_NUM_Ru ];   	// êàêîé äîëæåíà áûòü ìãíîâ. ðåàêòèâíàÿ ñîñòàâëÿþùàÿ òîêà õîëîñòîãî õîäà
      PType _U[3];                  // íàïðÿæåíèå íà ïèòàþùèõ îáìîòêàõ
      _U[0] = *f[0] - *f[1];        // ôàçà À
      _U[1] = *f[4] - *f[5];        // ôàçà Â
      _U[2] = *f[8] - *f[9];        // ôàçà Ñ

      PType dRxx = pow(_U1,2)/_dPx;	// êîýô. ïðîïîðöèîíàëüíîñòè ìåæäó íàïðÿæ íà îáìîòêå è àêò ñîñò òîêà õõ.  = pow(_U1/sqrt(3),2) / (_dPx/3)
      //PType _Ia[3];			      // ìãíîâåííîå àêòèâíî ñîñòàâë òîêà õõ
      PType _I[PT3_NUM_Ru];	      // ìãíîâ. çíà÷åíèå òîêà íàìàãíè÷èâàíèÿ â äðîññåëÿõ, íàìîòàííûõ íà ìàãíèòíóþ âåòâü
      for(unsigned i=0; i<3; i++ )
         _I[i] = _U[i]/dRxx + mCurve.I(_F[i]);    // àêò. è ðåàêò ñîñòàâë ñåììèðóåì

      PType Ru[PT3_NUM_Ru];
      for(unsigned k=0;k< PT3_NUM_Ru;k++)
      	if(_F[k]!=0) Ru[k]  = _n1*mCurve.I(_F[k])/_F[k]; // ñîïðîòèâëåíèÿ âåòâåé ìàãíèòîïðîâîäîâ
      // óñòàíàâëèâàåì àêòèâíîå ñîïðîòèâëåíèå ìàãíèòîïðîâîäà, êîòîðîå âëèÿåò íà ïîòåðè
      //int k; // íîìåð îáðàáàòûâàåìîé âåòêè
      // ñòåðæíè
      //k=0; if(_F[k]!=0)   Ru[k]  = *R[k+PT3_FST_Ru]+(_n1*_I[k] - _n1*(*I[0]))/_F[k];  	// ôàçà A
      //k=0; if(_F[k]!=0)   Ru[k]  = (_n1*_I[k] - )/_F[k];
      //k=0; if(_F[k]!=0)   Ru[k]  = (_n1*_I[k] - *L[k+PT3_FST_Ru]*d_F[k])/_F[k];   // ôàçà A
      //k=1; if(_F[k]!=0)   Ru[k]  = (_n1*_I[k] - *L[k+PT3_FST_Ru]*d_F[k])/_F[k];   // ôàçà B
      //k=2; if(_F[k]!=0)   Ru[k]  = (_n1*_I[k] - *L[k+PT3_FST_Ru]*d_F[k])/_F[k];   // ôàçà B
      /*if(mType == Armored){   // åñëè áðîíåâîé ìàãíèòîïðîâîä
         k=3; if(_F[k]!=0)   Ru[k]  = (    0     - (*f[13]-*f[12]) - *L[k+PT3_FST_Ru]*d_F[k])/_F[k];   // äðîññåëÿ íåò
         k=4; if(_F[k]!=0)   Ru[k]  = (    0     - (*f[17]-*f[16]) - *L[k+PT3_FST_Ru]*d_F[k])/_F[k];
      } else
         Ru[3] = Ru[4] = 1e100;
      // ÿðìà
      k=5; if(_F[k]!=0)   Ru[k]  = (    0     - (*f[14]-*f[12]) - *L[k+PT3_FST_Ru]*d_F[k])/_F[k];
      k=6; if(_F[k]!=0)   Ru[k]  = (    0     - (*f[15]-*f[13]) - *L[k+PT3_FST_Ru]*d_F[k])/_F[k];
      k=7; if(_F[k]!=0)   Ru[k]  = (    0     - (*f[16]-*f[14]) - *L[k+PT3_FST_Ru]*d_F[k])/_F[k];
      k=8; if(_F[k]!=0)   Ru[k]  = (    0     - (*f[17]-*f[15]) - *L[k+PT3_FST_Ru]*d_F[k])/_F[k];
      */
      }
}
//---------------------------------------------------------------------------
bool PTransformer_3 :: Link_Windings(){
   // åñòü âåðîÿòíîñòü ñîáðàòü íåñêîëüêî ðàç
   Internal_Links.clear();
   // ñîåäèíÿåì ïåðâè÷íóþ îáìîòêó
   if( wStar == Winding_X1  ){             // â çâåçäó
      Internal_Links.add(X1n[_A_], X1n[_B_]);
      Internal_Links.add(X1n[_A_], X1n[_C_]);
   }else if( wTriangle == Winding_X1  ){   // â òðåóãîëüíèê
      Internal_Links.add(X1n[_A_], X1[_B_]);
      Internal_Links.add(X1n[_B_], X1[_C_]);
      Internal_Links.add(X1n[_C_], X1[_A_]);
   }else if( wGroundedStar == Winding_X1  ){// â çâåçäó c çàçåìëåííûì íóëåì
      Internal_Links.add(X1n[_A_], X1n[_B_]);
      Internal_Links.add(X1n[_A_], X1n[_C_]);
      *R[21] = *L[21] = *C[21] = 0;
   }else{
      err(0, "PTransformer_3::Winding_X2(): ñõåìà ñîåäèíåíèé íå èçâåñòíà");
      return false;
      }
   // ñîåäèíÿåì âòîðè÷íóþ îáìîòêó
   if( wStar == Winding_X2  ){             // â çâåçäó
      Internal_Links.add(X2n[_A_], X2n[_B_]);
      Internal_Links.add(X2n[_A_], X2n[_C_]);
   }else if( wTriangle == Winding_X2  ){   // â òðåóãîëüíèê
      Internal_Links.add(X2n[_A_], X2[_B_]);
      Internal_Links.add(X2n[_B_], X2[_C_]);
      Internal_Links.add(X2n[_C_], X2[_A_]);
   }else if( wGroundedStar == Winding_X2  ){// â çâåçäó c çàçåìëåííûì íóëåì
      Internal_Links.add(X2n[_A_], X2n[_B_]);
      Internal_Links.add(X2n[_A_], X2n[_C_]);
      *R[22] = *L[22] = *C[22] = 0;
   }else{
      err(0, "PTransformer_3::Winding_X2(): ñõåìà ñîåäèíåíèé íå èçâåñòíà");
      return false;
      }
   return true;
}
//---------------------------------------------------------------------------
void PTransformer_3::Save(ostream &stream){		// ñîõðàíåíèå ïàðàìåòðîâ îáúåêòà â ïîòîê
   // ñíà÷àëà ñîõðàíèòñÿ áàçîâûé êëàññ
   sire::Save(stream);
   // òåïåðü ñîõðàíÿåì ýòîò êëàññ
   stream << mType << " ";
   stream << Winding_X1 << " ";
   stream << Winding_X2 << " ";
   // ñîõðàíÿåì êðèâóþ íàìàãíè÷èâàíèÿ
   mCurve.Save(stream);
}
//---------------------------------------------------------------------------
void PTransformer_3::Read(istream &stream){    // çàãðóçêà ïàðàìåòðîâ îáúåêòà èç ïîòîêà
   // ñíà÷àëà ÷èòàåò äàííûå áàçîâûé êëàññ
   sire::Read(stream);
   // òåïåðü ÷èòàåì ýòîò êëàññ
   int tmp;
   stream >> tmp;          mType       = (MagnCircuit_Type)tmp ;
   stream >> tmp;          Winding_X1  = (Winding_Connect) tmp;
   stream >> tmp;          Winding_X2  = (Winding_Connect) tmp;
   // ÷èòàåì êðèâóþ íàìàãíè÷èâàíèÿ
   mCurve.Read(stream);
}
//---------------------------------------------------------------------------
String PTransformer_3::ClassName(){return "PTransformer_3";};				// âîçâðàùàåò èìÿ êëàññà
//---------------------------------------------------------------------------






/* Áàçîâûé êëàññ äëÿ òðàíñôîðìàòîðîâ òîêà */
PCurrent_Transformer::PCurrent_Transformer(unsigned NumBranches, unsigned NumNodes, unsigned NumCircuit) :
					PUnit(NumBranches, NumNodes, NumCircuit){
   Describe_Fields();   // îïèøåì ñâîéñòâà êëàññà
   S = 10;
   n1 = 0; n2 = 0;      // çíà÷åíèå âèòêîâ âû÷èñëèòñÿ â accept()
   I1= 100; I2= 5;
   K = 0.5; d = 1;
   freq = 50;
   Name = "TA";
}
//---------------------------------------------------------------------------
void PCurrent_Transformer::Describe_Fields(){
   PFieldInfo fi;
   // íîì. ìîùíîñòü
   fi.Name = "Ìîùíîñòü";
   fi.Type = "PType";
   fi.ptr = (void*) &S;
   Fields.push_back(fi);
   // ïåðâè÷íûé òîê
   fi.Name = "I1";
   fi.Type = "PType";
   fi.ptr = (void*) &I1;
   Fields.push_back(fi);
   // âòîðè÷íûé òîê
   fi.Name = "I2";
   fi.Type = "PType";
   fi.ptr = (void*) &I2;
   Fields.push_back(fi);
   // ÷èñëî âèòêîâ â ïåðâè÷íîé îáìîòêå
   fi.Name = "n1";
   fi.Type = "PType";
   fi.ptr = (void*) &n1;
   Fields.push_back(fi);
   // ÷èñëî âèòêîâ âî âòîðè÷íîé îáìîòêå
   fi.Name = "n2";
   fi.Type = "PType";
   fi.ptr = (void*) &n2;
   Fields.push_back(fi);
   // Êëàññ òî÷íîñòè
   fi.Name = "Êëàññ";
   fi.Type = "PType";
   fi.ptr = (void*) &K;
   Fields.push_back(fi);
   // Ïàñïîðòíàÿ óãëîâàÿ ïîãðåøíîñòü
   fi.Name = "Óãë.ïîãð";
   fi.Type = "PType";
   fi.ptr = (void*) &d;
   Fields.push_back(fi);
   // Íîìèíàëüíàÿ ÷àñòîòà
   fi.Name = "Íîì.÷àñòîòà";
   fi.Type = "PType";
   fi.ptr = (void*) &freq;
   Fields.push_back(fi);
   // Êðèâàÿ íàìàãíè÷èâàíèÿ
   fi.Name = "I(Ô)";
   fi.Type = "PCurve";
   fi.ptr = (void*) &mCurve;
   Fields.push_back(fi);
}
//---------------------------------------------------------------------------
void PCurrent_Transformer::Save(ostream &stream){		// ñîõðàíåíèå ïàðàìåòðîâ îáúåêòà â ïîòîê
   // ñíà÷àëà ñîõðàíèòñÿ áàçîâûé êëàññ
   sire::Save(stream);
   // òåïåðü ñîõðàíÿåì ýòîò êëàññ
   stream << n1 << " ";
   stream << n2 << " ";
   stream << I1 << " ";
   stream << I2 << " ";
   stream << S  << " ";
   stream << K  << " ";
   stream << d  << " ";
   stream <<freq<< " ";
   stream <<F_nom<< " ";
   // ñîõðàíÿåì êðèâóþ íàìàãíè÷èâàíèÿ
   mCurve.Save(stream);
}
//---------------------------------------------------------------------------
void PCurrent_Transformer::Read(istream &stream){    // çàãðóçêà ïàðàìåòðîâ îáúåêòà èç ïîòîêà
   // ñíà÷àëà ÷èòàåò äàííûå áàçîâûé êëàññ
   sire::Read(stream);
   // òåïåðü ÷èòàåì ýòîò êëàññ
   stream >> n1 ;
   stream >> n2 ;
   stream >> I1 ;
   stream >> I2 ;
   stream >> S  ;
   stream >> K  ;
   stream >> d  ;
   stream >>freq;
   stream >>F_nom;
   // ÷èòàåì êðèâóþ íàìàãíè÷èâàíèÿ
   mCurve.Read(stream);
}
//---------------------------------------------------------------------------
String PCurrent_Transformer::ClassName(){return "PCurrent_Transformer";};				// âîçâðàùàåò èìÿ êëàññà







//---------------------------------------------------------------------------
/* Ìîäåëü òðàíñôîðìàòîðà òîêà */
PCurrent_Transformer_1 :: PCurrent_Transformer_1() :
                           PCurrent_Transformer(5, 5, 1),
                           X1(2), X2(2){
   Describe_Fields(); // îïèøåì ïîëÿ òðàíñôîðìàòîðà òîêà
   set_pins();        // îïèøåì âûâîäû
  	// çàïîëíÿåì ìàòðèöû
   char _M[5][5] =   {{-1, 0, 0,-1, 0},
                      { 1, 0, 0, 0, 0},
                      { 0,-1, 0, 0,-1},
                      { 0, 1, 0, 0, 0},
                      { 0, 0, 0, 1, 1}};
	*M = (char*)_M;
   char _N[1][5] =    {{0, 0, 1, 0, 0}};
   *N = (char*)_N;
   //mCurve.set(0,0);
   //mCurve.set(1e3,1e6);  // ëèíåéíàÿ êðèâàÿ íàìàãíè÷èâàíèÿ ñ íàñûùåíèåì ïðè ãðàìàíäîé èíäóêöèè
   // ðàññ÷èòàåì ïàðàìåòðû ñõåìû íà îñíîâå óñòàíîâëåííûõ äàííûõ
   R1 = 1e-3;
   L1 = 0   ;
   R2 = 1e-1;
   L2 = 1e-6 ;
   *R[2] = MIN;         // ñîïðîòèâëåíèå öåïè íàìàãíè÷èâàíèÿ
   *R[3] = *R[4] = MAX; // ñîïðîòâëåíèå óòå÷êè îáìîòîê
   Grounded_Node = 4;   // çàçåìëÿåìûé óçåë
}
//---------------------------------------------------------------------------
void PCurrent_Transformer_1 :: set_pins(){
   X1 [_N_] = set_pin(1);
   X1 [_A_] = set_pin(0);
   X2 [_N_] = set_pin(3);
   X2 [_A_] = set_pin(2);
   // èìåíà
   X1.Name  = "X1";
   X2.Name  = "X2";
	// äîáàâèì â ñïèñîê ãðóïï âûâîäîâ
	Out.add(&X1);
   Out.add(&X2);
}
//---------------------------------------------------------------------------
void PCurrent_Transformer_1::Describe_Fields(){
   PFieldInfo fi;
   // àêò. ñîïðîòèâëåíèå ïåðâè÷íîé îáì
   fi.Name = "R1";
   fi.Type = "PType";
   fi.ptr = (void*) &R1;
   Fields.push_back(fi);
   // èíäóêòèâíîñòü ïåðâè÷íîé îáì
   fi.Name = "L1";
   fi.Type = "PType";
   fi.ptr = (void*) &L1;
   Fields.push_back(fi);
   // àêò. ñîïðîòèâëåíèå âòîðè÷íîé îáì
   fi.Name = "R2";
   fi.Type = "PType";
   fi.ptr = (void*) &R2;
   Fields.push_back(fi);
   // èíäóêòèâíîñòü âòîðè÷íîé îáì
   fi.Name = "L2";
   fi.Type = "PType";
   fi.ptr = (void*) &L2;
   Fields.push_back(fi);
}
//---------------------------------------------------------------------------
bool PCurrent_Transformer_1 :: accept(){
   // êîýôôèöèåíòû
   PType k = I1 / I2;        // äåéñòâèòåëüíûé êîýôôèöèåíò òðàíñôîðìàöèè
   PType w = 2*freq*M_PI;     // óãëîâàÿ ÷àñòîòà
   // åñëè íå çàäàíû ÷èñëî îáìîòîê
   if(n1==0) n1=1;
   if(n2==0)
      if(n1!=0) n2=k*n1;
      else {n1=1;n2=k*n1;}

   PType _d = d*M_PI/180;                // ïåðåâîäèì óãëîâóþ ïîãðåøíîñòü â ðàäèàíû
   PType a = acos(0.8);                   // ýòî êîñèíóñ ðàñ÷åòíîé íîìèíàëüíîé íàãðóçêè
   PType psi = atan(K/100/_d)-a;             // óãîë ìåæäó ïîòîêîì è òîêîì íàìàãíè÷èâàíèÿ
   PType _I2 = I1*n1/n2*( cos(_d)-K/100 ); // äåñòâèòåëüíûé òîê ñ ó÷åòîì ïîãðåøíîñòè ïðè íîìèíàëüíîé çàãðóçêå

   PType E2 = S / _I2;         // ÝÄÑ âî âòîðè÷íîì êîíòóðå ïðè íîìèíàëüíîé çàãðóçêå
   F_nom = E2 / (w*n2);        // ïîòîê, íåîáõîäèìûé äëÿ îáåñïå÷åíèÿ ýòîãî íàïðÿæåíèÿ
   // ÌÄÑ íàìàãíè÷èâàíèÿ
   PType F0 = K/100*(I1*n1)/sin(psi+a);
   // ñîïðîòèâëåíèå öåïè íàìàãíè÷èâàíèÿ (ó÷åò ïîòåðü)
   PType Zu = F0 / F_nom;
   PType Ru = Zu * sin(psi);
   PType Xu = Zu * cos(psi);

   // öåïü íàìàãíè÷èâàíèÿ
   *R[2] = Ru;  *L[2] = Xu/w;
   // îáìîòêè
   *R[0] = R1;  *L[0] = L1;
   *R[1] = R2;  *L[1] = L2;
   magnetic_link(0,2,n1);
   magnetic_link(1,2,n2);
   update_differential_resistance();   // ïåðåñ÷èòûâàåì äèôôåðåíöèàëüíûå ñîïðîòèâëåíèÿ
   return true;
}
//---------------------------------------------------------------------------
bool PCurrent_Transformer_1:: update_elements(bool force_update){
   // îáíîâëÿåì ïàðàìåòðû ñõåìû â ñîîòâåòñòâèè ñ êðèâîé íàìàãíè÷èâàíèÿ
   if( !mCurve.exist )           // çàäàíà ëè êðèâàÿ íàìàãíè÷èâàíèÿ
      return false;
   else{
      PType _F,Ru;      	      // çíà÷åíèå ïîòîêà è ñîîòâåòñòâóþùåãî åìó ñîïðîòèâëåíèÿ
      _F = *I[2];
      Ru  = n1*mCurve.I(_F)/_F; 	// ñîïðîòèâëåíèÿ âåòâåé ìàãíèòîïðîâîäîâ
      if(Ru>=0) *R[2] = Ru;      // óñòàíîâèì ñîïðîòèâëåíèå
      return true;
      }
}
//---------------------------------------------------------------------------
void PCurrent_Transformer_1::Save(ostream &stream){		// ñîõðàíåíèå ïàðàìåòðîâ îáúåêòà â ïîòîê
   // ñíà÷àëà ñîõðàíèòñÿ áàçîâûé êëàññ
   sire::Save(stream);
   // òåïåðü ñîõðàíÿåì ýòîò êëàññ
   stream << R1 << " ";
   stream << R2 << " ";
   stream << L1 << " ";
   stream << L2 << " ";
}
//---------------------------------------------------------------------------
void PCurrent_Transformer_1::Read(istream &stream){    // çàãðóçêà ïàðàìåòðîâ îáúåêòà èç ïîòîêà
   // ñíà÷àëà ÷èòàåò äàííûå áàçîâûé êëàññ
   sire::Read(stream);
   // òåïåðü ÷èòàåì ýòîò êëàññ
   stream >> R1 ;
   stream >> R2 ;
   stream >> L1 ;
   stream >> L2 ;
}
//---------------------------------------------------------------------------
String PCurrent_Transformer_1::ClassName(){return "PCurrent_Transformer_1";};				// âîçâðàùàåò èìÿ êëàññà







//---------------------------------------------------------------------------
/* Âûêëþ÷àòåëü òðåõôàçíûé */
PBreaker::PBreaker():
					      PUnit(9, 7, 3),
                     X1(4), X2(4){
   //óñòàíîâèì âûâîäû
   set_pins();
   // îïèøåì ñâîéñòâà êëàññà
   Describe_Fields();
  	// çàïîëíÿåì ìàòðèöû
   char _M[7][9] =   {{ 0, 0, 0, 1, 1, 1, 1, 1, 1},
                      {-1, 0, 0,-1, 0, 0, 0, 0, 0},
                      { 1, 0, 0, 0,-1, 0, 0, 0, 0},
                      { 0,-1, 0, 0, 0,-1, 0, 0, 0},
                      { 0, 1, 0, 0, 0, 0,-1, 0, 0},
                      { 0, 0,-1, 0, 0, 0, 0,-1, 0},
                      { 0, 0, 1, 0, 0, 0, 0, 0,-1}};
	*M = (char*)_M;
   char _N[3][9] =   {{ 1, 0, 0,-1, 1, 0, 0, 0, 0},
                      { 0, 1, 0, 0, 0,-1, 1, 0, 0},
                      { 0, 0, 1, 0, 0, 0, 0,-1, 1}};
   *N = (char*)_N;
   // ìàêñèìàëüíîå ñîïðîòèâëåíèå â âûêëþ÷åííîì ñîñòîÿíèè
   Rmax = MAX;
   // ñîïðîòèâëåíèå âî âêëþ÷åííîì ñîñòîÿíèè
   Rmin = MIN;
   // ïî óìîë÷àíèþ âûêëþ÷åí
   IsOn = true;
   *R[0] = *R[1] = *R[2] = Rmin;
   // ïðîâîäèìîñòè íà çåìëþ ìàêñèìàëüíû
   *R[3] = *R[4] = *R[5] = *R[6] = *R[7] = *R[8] = MAX;
   // ñîñòîÿíèèå îòêëþ÷åíèÿ (âêëþ÷åíèÿ)
   for(int i=0; i<4;i++){
      T_on[i]   = 0;   // ôàçà íå â ñîñòîÿíèè âêëþ÷åíèÿ
      T_off[i]  = 0;   // ôàçà íå â ñîñòîÿíèè âûêëþ÷åíèÿ
      }
   t_on  = 0.2;             // ñîáñòâåííîå âðåìÿ âêëþ÷åíèÿ
   t_off = 0.05;            // ñîáñòâåííîå âðåìÿ îòêëþ÷åíèÿ
   t_full_off = 0.08;       // ïîëíîå âðåìÿ îòêëþ÷åíèÿ
   Name = "Q";
}
//---------------------------------------------------------------------------
void PBreaker :: set_pins(){
   X1 [_N_] = set_pin(0);
   X1 [_A_] = set_pin(1);
   X1 [_B_] = set_pin(3);
   X1 [_C_] = set_pin(5);
   X2 [_N_] = set_pin(0);
   X2 [_A_] = set_pin(2);
   X2 [_B_] = set_pin(4);
   X2 [_C_] = set_pin(6);
   // èìåíà
   X1.Name  = "X1";
   X2.Name  = "X2";
	// äîáàâèì â ñïèñîê ãðóïï âûâîäîâ
	Out.add(&X1);
   Out.add(&X2);
}
//---------------------------------------------------------------------------
void PBreaker::Describe_Fields(){
   PFieldInfo fi;
   // ñîïðîòèâëåíèå âî âêëþ÷. ñîñòîÿíèè
   fi.Name = "Ñîïðîò. âêë";
   fi.Type = "PType";
   fi.ptr = (void*) &Rmin;
   Fields.push_back(fi);
   // ñîïðîòèâëåíèå â îòëþ÷. ñîñòîÿíèè
   fi.Name = "Ñîïðîò. îòêë";
   fi.Type = "PType";
   fi.ptr = (void*) &Rmax;
   Fields.push_back(fi);
   // ñîáñòâåííîå âðåìÿ âêëþ÷åíèÿ
   fi.Name = "Âðåìÿ âêë";
   fi.Type = "PType";
   fi.ptr = (void*) &t_on;
   Fields.push_back(fi);
   // ñîáñòâåííîå âðåìÿ îòêëþ÷åíèÿ
   fi.Name = "Ñîáñò.âð. îòêë";
   fi.Type = "PType";
   fi.ptr = (void*) &t_off;
   Fields.push_back(fi);
   // ïîëíîå âðåìÿ îòêëþ÷åíèÿ
   fi.Name = "Ïîëí.âð. îòêë";
   fi.Type = "PType";
   fi.ptr = (void*) &t_full_off;
   Fields.push_back(fi);
   // òåêóùåå ñîïðîòèâëåíèå âûêëþ÷àòåëÿ
   fi.Name = "Âêëþ÷åí";
   fi.Type = "bool";
   fi.ptr = (void*) &IsOn;
   Fields.push_back(fi);
}
//---------------------------------------------------------------------------
bool PBreaker::on(Phase phase){
   switch (phase){
   	case _A_: if(!T_off[_A_] && !T_on[_A_]) {T_on[_A_] = TIME; return true;}; break;  // åñëè  ôàçà íå â ñîñòîÿíèè âûêëþ÷åíèÿ, òî âêëþ÷àåì
      case _B_: if(!T_off[_B_] && !T_on[_B_]) {T_on[_B_] = TIME; return true;}; break;
      case _C_: if(!T_off[_C_] && !T_on[_C_]) {T_on[_C_] = TIME; return true;}; break;
      default:	 return false;
      }
   return false;
}
//---------------------------------------------------------------------------
bool PBreaker::off(Phase phase){
   switch (phase){
   	case _A_: if(!T_on[_A_] && !T_off[_A_]) {T_off[_A_] = TIME; return true;}; break;  // åñëè  ôàçà íå â ñîñòîÿíèè âêëþ÷åíèÿ, òî âûêëþ÷àåì
      case _B_: if(!T_on[_B_] && !T_off[_B_]) {T_off[_B_] = TIME; return true;}; break;
      case _C_: if(!T_on[_C_] && !T_off[_C_]) {T_off[_C_] = TIME; return true;}; break;
      default:	 return false;
      }
   return false;
}
//---------------------------------------------------------------------------
bool PBreaker::on(){
   bool a,b,c;
   a = on(_A_);
   b = on(_B_);
   c = on(_C_);
   return a && b && c;
}
//---------------------------------------------------------------------------
bool PBreaker::off(){
   bool a,b,c;
   a = off(_A_);
   b = off(_B_);
   c = off(_C_);
   return a && b && c;
}
//---------------------------------------------------------------------------
bool PBreaker::accept(){
	if(IsOn)
   	*R[0] = *R[1] = *R[2] = Rmin;
   else
      *R[0] = *R[1] = *R[2] = Rmax;
   update_differential_resistance();   // ïåðåñ÷èòûâàåì äèôôåðåíöèàëüíûå ñîïðîòèâëåíèÿ
   return true;
}
//---------------------------------------------------------------------------
bool PBreaker::update_elements(bool force_update){
   bool ret = false;
   static PType I1[4]={0,0,0,0};
   for(int i=_A_; i<=_C_; i++){
      // åñëè ôàçà â ïðîöåññå âêëþ÷åíèÿ
      if(T_on[i]){
         // ñ÷èòàåì, ÷òî âêëþ÷åíèå ïðîèñõîäèò áåç äóãè
         if( (TIME-T_on[i])>t_on) {
            *R[i-_A_]=Rmin;
            T_on[i] = 0;
            ret = true;
            }
         }
      // åñëè ôàçà â ïðîöåññå âûêëþ÷åíèÿ
      else if(T_off[i]){
         // ìîìåíò ïîëíîãî ãàøåíèÿ äóãè
         if( (TIME-T_off[i])>t_full_off && I1[i-_A_]*(*I[i-_A_])<0 ) {
            *R[i-_A_]=Rmax;
            T_off[i] = 0;
            ret = true;
            }
         // îïðåäåëÿåì ìîìåíò íà÷àëà ðàñõîæäåíèÿ êîíòàêòîâ
         else if( (TIME-T_off[i])>t_off) {
            /*/ ñ÷èòàåì, ÷òî ñîïðîòèâëåíèå èçìåíÿåòñÿ ïî ëèíåéíîìó çàêîíó
            PType dR = (Rmax-Rmin)/((t_full_off-t_off)/smp);
            *R[i-_A_] += dR;
            if(*R[i-_A_]>Rmax) *R[i-_A_]=Rmax; */
            // ó÷èòûâàåì ñîïðîòèâëåíèå äóãè
            *R[i-_A_] = fabs(11/(*I[i-_A_]));
            ret = true;
            }
         I1[i-_A_] = *I[i-_A_]; // ñîõðàíÿåì òåêóùåå çíà÷åíèå
         }
      }
   return ret;
}
//---------------------------------------------------------------------------
void PBreaker::Save(ostream &stream){		// ñîõðàíåíèå ïàðàìåòðîâ îáúåêòà â ïîòîê
   // ñíà÷àëà ñîõðàíèòñÿ áàçîâûé êëàññ
   sire::Save(stream);
   // òåïåðü ñîõðàíÿåì ýòîò êëàññ
   stream << Rmax << " ";
   stream << Rmin << " ";
   stream << t_on << " ";
   stream << t_off << " ";
   stream << t_full_off << " ";
   // ñîõðàíÿåì òåêóùèå ñîïðîòèâëåíèÿ â ôàçàõ - ãðÿçíûé õóê äëÿ èíòåðôåéñà
   stream << IsOn << " ";

}
//---------------------------------------------------------------------------
void PBreaker::Read(istream &stream){    // çàãðóçêà ïàðàìåòðîâ îáúåêòà èç ïîòîêà
   // ñíà÷àëà ÷èòàåò äàííûå áàçîâûé êëàññ
   sire::Read(stream);
   // òåïåðü ÷èòàåì ýòîò êëàññ
   stream >> Rmax ;
   stream >> Rmin ;
   stream >> t_on ;
   stream >> t_off ;
   stream >> t_full_off ;
   // ÷èòàåì ñîïðîòèâëåíèÿ â ôàçàõ - ãðÿçíûé õóê äëÿ èíòåðôåéñà
   stream >> IsOn;
}
//---------------------------------------------------------------------------
String PBreaker::ClassName(){return "PBreaker";};				// âîçâðàùàåò èìÿ êëàññà













/* Îïèñàòåëü ñâîéñòâ êëàññàîâ */
PFieldInfo::PFieldInfo(){
   ptr = NULL;
   Type = "PType";
   Mode = rw;     // ðåæèì ÷òåíèÿ çàïèñè
}
//---------------------------------------------------------------------------
String PFieldInfo::Value(){
   if(!ptr) return "";
   if     (Type == "String")
      return *(String*)ptr;
   else if(Type == "PType")
      return FloatToStr(*(PType*)ptr);
   else if(Type == "int")
      return IntToStr(*(int*)ptr);
   else if(Type == "MagnCircuit_Type"){
      	if		 (*(MagnCircuit_Type*)ptr == Three_Rod)		return "Three_Rod";
         else if(*(MagnCircuit_Type*)ptr == Armored)			return "Armored";
         else																return "Unknown";
   		}
   else if(Type == "Winding_Connect"){
      	if		 (*(Winding_Connect*)ptr == wStar)				return "wStar";
         else if(*(Winding_Connect*)ptr == wTriangle)			return "wTriangle";
         else if(*(Winding_Connect*)ptr == wGroundedStar)	return "wGroundedStar";
         else																return "Unknown";
   		}
   else if(Type == "bool"){
      switch(*(bool*)ptr){
         case true: 			return "true";
         default:				return "false";
      	}
   	}
   else if(Type == "PCurve"){
      String val = "";
      PCurve *obj = (PCurve*)ptr;
      unsigned lineNum = obj->size();
      if(   lineNum>0   ){
         // ñôîðìèðóåì ñòðîêó
         for(int i=0, n=lineNum+1; i<n; i++){
            PType X=0, Y=0;
            obj->Point(i, X, Y);
            val += "(" + FloatToStr(X) + ";" + FloatToStr(Y) + ")";
            if( (i+1)<n ) val += " ";
            }
         return val;
         }
      else    // ëîìàíàÿ íå çàäàíà
         return "";
      }
   else if(Type == "Pins_List"){
   	if(dynamic_cast<PGrid*>((PElement*)ptr))       			return ((PGrid*)ptr)->getOuts();
   	else if(dynamic_cast<PSubGrid*>((PElement*)ptr))  		return ((PSubGrid*)ptr)->getOuts();
      }
   return "";
}
//---------------------------------------------------------------------------
void PFieldInfo::Value(String newVal){
	if( Mode== ro) return;
   if(!ptr) return;
   if     (Type == "String")
      *(String*)ptr = newVal;
   else if(Type == "PType"){
      if(!TryStrToFloat(newVal, *(PType*)ptr))
         err(1, "PFieldInfo: Íåäîïóñòèìûé ñèìâîë ïðè ïðåîáðàçîâàíèè ñòðîêè â ÷èñëî");
      }
   else if(Type == "int"){
      if(!TryStrToInt(newVal, *(int*)ptr))
         err(1, "PFieldInfo: Íåäîïóñòèìûé ñèìâîë ïðè ïðåîáðàçîâàíèè ñòðîêè â ÷èñëî");
      }
   else if(Type == "MagnCircuit_Type"){
      if		 (  newVal == "Three_Rod")	*(MagnCircuit_Type*)ptr = Three_Rod;
      else if(  newVal == "Armored")	*(MagnCircuit_Type*)ptr = Armored;
      else                             *(MagnCircuit_Type*)ptr = Armored;
      }
   else if(Type == "Winding_Connect"){
   	if		 (  newVal == "wStar")		*(Winding_Connect*)ptr = wStar;
      else if(  newVal == "wTriangle")	*(Winding_Connect*)ptr = wTriangle;
      else if(  newVal == "wGroundedStar") *(Winding_Connect*)ptr = wGroundedStar;
      else                             *(Winding_Connect*)ptr = wStar;
   	}
   else if(Type == "bool"){
   	if		 (  newVal == "true")		*(bool*)ptr = true;
      else                             *(bool*)ptr = false;
   	}
   else if(Type == "PCurve"){
      PCurve *obj = (PCurve*)ptr;
      if(   newVal != ""   ){
         vector<String> Point;  // áóäåò ñîäåðæàòü ñòðîêè X;Y
         // íàéäåì âñå ïîäñòðîêè "X;Y", êîòîðûå ðàçäåëåíû ïðîáåëàìè
         unsigned pos;
         // âîçìîæíî áûëî áîëåå îäíîãî ïðîáåëà â íà÷àëå
         int numSpace, m;
         for(numSpace=1, m=newVal.Length(); numSpace<=m; numSpace++) if(newVal[numSpace]!=' ') break;
         newVal = newVal.SubString(numSpace, newVal.Length() - numSpace + 1);
         pos = newVal.Pos(" ");
         while( pos ){
            Point.push_back( newVal.SubString(2,pos-3) );
            newVal = newVal.SubString(pos+1, newVal.Length()-pos);
            // âîçìîæíî áûëî áîëåå îäíîãî ïðîáåëà
            for(numSpace=1, m=newVal.Length(); numSpace<=m; numSpace++) if(newVal[numSpace]!=' ') break;
            newVal = newVal.SubString(numSpace, newVal.Length() - numSpace + 1);
            pos = newVal.Pos(" ");
            }
         Point.push_back( newVal.SubString(2,newVal.Length()-2) );
         // âû÷èñëèì çíà÷åíèÿ X, Y è ñîõðàíèì â îáúåêòå òî÷êó
         obj->clear();
         PType X, Y;
         for(int i=0, n=Point.size(); i<n; i++){
            pos = Point[i].Pos(";");
            if( pos ){
               X=0; Y=0;
               TryStrToFloat( Point[i].SubString(1,     pos-1)                , X );
               TryStrToFloat( Point[i].SubString(pos+1, Point[i].Length()-pos), Y );
               //String f = Point[i].SubString(pos+1, Point[i].Length()-pos);
               obj->_set(X, Y);
               }
            }
         }
      else // ñòðîêà ïóñòàÿ
         obj->clear();  // óäàëÿåì ëîìàííóþ
      }
   else if(Type == "Pins_List"){
   	if(dynamic_cast<PGrid*>((PElement*)ptr))     		return ((PGrid*)ptr)->setOuts( newVal );
   	else if(dynamic_cast<PSubGrid*>((PElement*)ptr))  	return ((PSubGrid*)ptr)->setOuts( newVal );
   	}
}
//---------------------------------------------------------------------------
char *StringForSave(String *s){
   if(*s=="") *s = "_";
   for(int i=1,n=(*s).Length(); i<=n; i++ )
   	if((*s)[i]==' ')
      	(*s)[i]='_';
   return (*s).c_str();
}
//---------------------------------------------------------------------------
char *StringForSave(char *s){
   for(int i=0; s[i] && i<1024; i++ )
   	if(s[i]==' ')
      	s[i]='_';
   return s;
}
//---------------------------------------------------------------------------
void SaveObj(PElement *Obj, ostream &stream){
   String cname = Obj->ClassName();
   stream << StringForSave(&cname) << " ";	// èìÿ êëàññà
   if(Obj->ClassName() == "PLine") stream << ((PLine*)Obj)->Cells() << " ";
   // ñîõðàíÿåì äàííûå îáúåêòà
   Obj->Save( stream );
}
//---------------------------------------------------------------------------
PElement* CreateObj(istream &stream){
      PElement *Obj;
      char cname[1024];
   	stream >> cname;
      String ClassName = cname; // èìÿ êëàññà
      if(ClassName == "PLine"){
         unsigned cells;
      	stream >> cells;
      	if(cells<1) cells = 1;
      	Obj = new PLine(cells);
      	}
  		else if ( ClassName == "PSource" )               Obj = new PSource() ;
   	else if ( ClassName == "PConsumer" )             Obj = new PConsumer() ;
   	else if ( ClassName == "PTransformer_1" )        Obj = new PTransformer_1() ;
   	else if ( ClassName == "PTransformer_3" )        Obj = new PTransformer_3() ;
   	else if ( ClassName == "PCurrent_Transformer_1" )Obj = new PCurrent_Transformer_1() ;
   	else if ( ClassName == "PBreaker" )              Obj = new PBreaker() ;
      else if ( ClassName == "PGrid" )                 Obj = new PGrid() ;
      else if ( ClassName == "PSubGrid" )              Obj = new PSubGrid() ;
   	else if ( ClassName == "NULL" )	Obj = NULL;
   	else									   Obj = NULL;
      // ÷èòàåì äàííûå îáúåêòà
      if(Obj) Obj->Read(stream);
      return Obj;
}
//---------------------------------------------------------------------------
// Params - ïàðàìåòðû èñïîëüçóåìûå ïðè ñîçäàíèè îáúåêòà
PElement* CreateObj(String ClassName, vector<void*> Params){
      PElement *Obj;
      if(ClassName == "PLine" && Params.size()>0){
         int cells = *(unsigned*)Params[0];
         if( cells < 1 ) cells = 1;
         Obj = new PLine(cells) ;
      	}
  		else if ( ClassName == "PSource" )               Obj = new PSource() ;
   	else if ( ClassName == "PConsumer" )             Obj = new PConsumer() ;
   	else if ( ClassName == "PTransformer_1" )        Obj = new PTransformer_1() ;
   	else if ( ClassName == "PTransformer_3" )        Obj = new PTransformer_3() ;
   	else if ( ClassName == "PCurrent_Transformer_1" )Obj = new PCurrent_Transformer_1() ;
   	else if ( ClassName == "PBreaker" )              Obj = new PBreaker() ;
      else if ( ClassName == "PGrid" )                 Obj = new PGrid() ;
      else if ( ClassName == "PSubGrid" )              Obj = new PSubGrid() ;
   	else if ( ClassName == "NULL" )	Obj = NULL;
   	else									   Obj = NULL;
      return Obj;
}