main.cpp

用于潮流计算的程序请让我下载我需要的吧感谢了啊

                if (!PrintEvalue) fCustomPrint(stderr,"Minimum |e_value| -> %-10.6lg\n\n",EigenValue);
                PrintDirection('Y',x0,1.0);
         }
  } else if (flagPoC) {
         i=PoCPoint();
         if(i<0) {
                i= -i;
                fCustomPrint(stderr,"\n *** The DC equations have a square root of a negative number.\n");
                fCustomPrint(stderr,"     Try changing the DC controls.\n");
                fCustomPrint(stderr,"Loading factor -> %-10.6lg\n\n",lambda);
                WriteSolution(--i,TrueParamStr(2),"DC problems:");
                stopExecute(1);
         }
         fCustomPrint(stderr,"**** Point of Collapse Case Solved ****   ");
         fCustomPrint(stderr,"Loading factor -> %-10.6lg\n\n",lambda);
         WriteSolution(--i,TrueParamStr(2),"PoC Solution:");
  } else if (flagv) {
         i=1;
         V=BlPtr->V;
         if (flagD) {
                i=Pflow(i,FALSE,TRUE,TRUE);
                if(i<0) {
                  i= -i;
                  fCustomPrint(stderr,"\n *** The DC equations have a square root of a negative number.\n");
                  fCustomPrint(stderr,"     Try changing the DC controls.\n");
                  WriteSolution(--i,TrueParamStr(2),"DC problems:");
                  stopExecute(1);
                }
                fCustomPrint(stderr,"**** Base Case Solved (to calculate OH load parameters) ****\n\n");
         } else InitializeLoad();
         RealParameter('L',&lambda,-1e6,1e6);
         strcpy(BlPtr->Type,"BL");
         if(BlPtr->Area!=NULL && BlPtr->Area->Slack==BlPtr) strcat(BlPtr->Type,"A");
         Bl=BlPtr->N;
         BlPtr->V=V;
         BlPtr->Cont=NULL;
         i=Pflow(i,flagD,TRUE,FALSE);
         if(i<0) {
                i= -i;
                fCustomPrint(stderr,"\n *** The DC equations have a square root of a negative number.\n");
                fCustomPrint(stderr,"     Try changing the DC controls.\n");
                fCustomPrint(stderr,"Loading factor -> %-10.6lg\n\n",lambda);
                WriteSolution(--i,TrueParamStr(2),"DC problems:");
                stopExecute(1);
         }
         fCustomPrint(stderr,"**** Voltage/Lambda Case Solved ****    ");
         fCustomPrint(stderr,"Loading factor -> %-10.6lg\n\n",lambda);
         WriteSolution(--i,TrueParamStr(2),"Voltage/Lambda Solution:");
  } else if (ExistParameter('L') && (ExistParameter('K') || flagKdirection)) {
         i=1;
         if (ExistParameter('b') || flagD ) {
                i=Pflow(i,FALSE,TRUE,TRUE);
                if(i<0) {
                  i= -i;
                  fCustomPrint(stderr,"\n *** The DC equations have a square root of a negative number.\n");
                  fCustomPrint(stderr,"     Try changing the DC controls.\n");
                  WriteSolution(--i,TrueParamStr(2),"DC problems:");
                  stopExecute(1);
                }
                fCustomPrint(stderr,"**** Base Case Solved (to initialize power flow) ****\n\n");
         } else InitializeLoad();
         RealParameter('L',&lambda,-1e6,1e6);
         if (lambda==0 || (NullName(NameParameter('K')) && !flagKdirection)) {
                fCustomPrint(stderr,"***Warning: The program has detected the -L option but either lambda is zero\n");
                fCustomPrint(stderr,"            or there is no gen./load variations defined.\n");
                if (!ExistParameter('b') && !flagD  ) {
                  fCustomPrint(stderr,"            The program will just solve the base case.\n");
                  i=Pflow(i,FALSE,TRUE,TRUE);
                  if(i<0) {
                         i= -i;
                         fCustomPrint(stderr,"\n *** The DC equations have a square root of a negative number.\n");
                         fCustomPrint(stderr,"     Try changing the DC controls.\n");
                         WriteSolution(--i,TrueParamStr(2),"DC problems:");
                         stopExecute(1);
                  }
                  fCustomPrint(stderr,"**** Base Case Solved ****\n\n");
                }
         } else {
                i=Pflow(i,flagD,TRUE,FALSE);
                if(i<0) {
                  i= -i;
                  fCustomPrint(stderr,"\n *** The DC equations have a square root of a negative number.\n");
                  fCustomPrint(stderr,"     Try changing the DC controls.\n");
                  fCustomPrint(stderr,"Loading factor -> %-10.6lg\n\n",lambda);
                  WriteSolution(--i,TrueParamStr(2),"DC problems:");
                  stopExecute(1);
                }
                fCustomPrint(stderr,"**** Lambda Case Solved ****    ");
                fCustomPrint(stderr,"Loading factor -> %-10.6lg\n\n",lambda);
         }
         WriteSolution(--i,TrueParamStr(2),"Lambda Solution:");
         if (ExistParameter('y') && !NullName(NameParameter('y'))) {
                N1=NacVar+11*Ndc/2+1+3*Nsvc+NtcscVar+7*Nstatcom;   /* FACTS */
#ifdef WINDOWS
                x0= new VALUETYPE[N1];
#else
                x0=(VALUETYPE *) calloc(N1,sizeof(VALUETYPE));
                if (x0==NULL) {ErrorHalt("Insufficient memory to allocate approx. left e-vector."); stopExecute(ERROREXIT);}
#endif
                if(ExistParameter('d')) fCustomPrint(stderr,"Write left e-vector for base case (see file 'evect.dat').\n");
                Evector(40,0,0.00001,FALSE,&EigenValue);
                fCustomPrint(stderr,"Minimum |e_value| -> %-10.6lg\n\n",EigenValue);
                PrintEvalue=TRUE;
                Out=OpenOutput(NameParameter('y'));
                PrintLeftEvector(N1,Out);
         }
         if (ExistParameter('Y') && !NullName(NameParameter('Y'))){
                N1=NacVar+11*Ndc/2+1+3*Nsvc+NtcscVar+7*Nstatcom;   /* FACTS */
                if (x0 == NULL) {
#ifdef WINDOWS
                  x0= new VALUETYPE[N1];
#else
                  x0=(VALUETYPE *) calloc(N1,sizeof(VALUETYPE));
                  if (x0==NULL) {ErrorHalt("Insufficient memory to allocate approx. right e-vector."); stopExecute(ERROREXIT);}
#endif
                }
                if(ExistParameter('d')) fCustomPrint(stderr,"Write right e-vector for base case (see file 'evect.dat').\n");
                Evector(40,0,0.00001,TRUE,&EigenValue);
                if (!PrintEvalue) fCustomPrint(stderr,"Minimum |e_value| -> %-10.6lg\n\n",EigenValue);
                PrintDirection('Y',x0,1.0);
         }
  } else {
         i=Pflow(1,FALSE,TRUE,TRUE);
         if(i<0) {
                i= -i;
                fCustomPrint(stderr,"\n *** The DC equations have a square root of a negative number.\n");
                fCustomPrint(stderr,"     Try changing the DC controls.\n");
                WriteSolution(--i,TrueParamStr(2),"DC problems:");
                stopExecute(1);
         }
         fCustomPrint(stderr,"**** Base Case Solved ****\n\n");
         WriteSolution(--i,TrueParamStr(2),"Base Solution:");
         if (ExistParameter('y') && !NullName(NameParameter('y'))) {
                N1=NacVar+11*Ndc/2+1+3*Nsvc+NtcscVar+7*Nstatcom;   /* FACTS */
#ifdef WINDOWS
                x0= new VALUETYPE[N1];
#else
                x0=(VALUETYPE *) calloc(N1,sizeof(VALUETYPE));
                if (x0==NULL) {ErrorHalt("Insufficient memory to allocate approx. left e-vector."); stopExecute(ERROREXIT);}
#endif
                if(ExistParameter('d')) fCustomPrint(stderr,"Write left e-vector for base case (see file 'evect.dat').\n");
                Evector(40,0,0.00001,FALSE,&EigenValue);
        fCustomPrint(stderr,"Minimum |e_value| -> %-10.6lg\n\n",EigenValue);
        PrintEvalue=TRUE;
                Out=OpenOutput(NameParameter('y'));
                PrintLeftEvector(N1,Out);
         }
         if (ExistParameter('Y') && !NullName(NameParameter('Y'))){
                N1=NacVar+11*Ndc/2+1+3*Nsvc+NtcscVar+7*Nstatcom;   /* FACTS */
                if (x0 == NULL) {
#ifdef WINDOWS
                  x0= new VALUETYPE[N1];
#else
                  x0=(VALUETYPE *) calloc(N1,sizeof(VALUETYPE));
                  if (x0==NULL) {ErrorHalt("Insufficient memory to allocate approx. right e-vector."); stopExecute(ERROREXIT);}
#endif
                }
                if(ExistParameter('d')) fCustomPrint(stderr,"Write right e-vector for base case (see file 'evect.dat').\n");
                Evector(40,0,0.00001,TRUE,&EigenValue);
                if (!PrintEvalue) fCustomPrint(stderr,"Minimum |e_value| -> %-10.6lg\n\n",EigenValue);
                PrintDirection('Y',x0,1.0);
         }
  }
#ifdef WINDOWS

  CleanUp();
#endif
  return(0);
}


/* -------------------- Clean up all data structures ----------------------*/
#ifdef WINDOWS
void CleanUp()
/* Clean up all Pflow data structures */
{

  INDEX k;
  SparseMatrixElement *Jptr,*Jptrp;
  AreaData *Aptr,*Aptrp;
  AClist *LACptr,*LACptrp;
  DClist *LDCptr,*LDCptrp;
  ElementList *LEptr,*LEptrp;
  ACbusData *ACptr,*ACptrp;
  SVClist *LSVCptr,*LSVCptrp;                 /* FACTS */
  TCSClist *LTCSCptr,*LTCSCptrp;              /* FACTS */
  STATCOMlist *LSTATCOMptr,*LSTATCOMptrp;     /* FACTS */
  DCbusData *DCptr,*DCptrp;
  ElementData *Eptr,*Eptrp;
  SVCbusData *SVCptr,*SVCptrp;                /* FACTS */
  TCSCbusData *TCSCptr,*TCSCptrp;             /* FACTS */
  STATCOMbusData *STATCOMptr,*STATCOMptrp;    /* FACTS */

  if (Jac!=NULL) {
    for (k=1;k<=Jac->n1;k++) {
      Jptr=Jac->RowHead[k];
      while (Jptr!=NULL) {
        Jptrp=Jptr->RowNext;
        delete Jptr;
        Jptr=Jptrp;
      }
    }
    delete[] Jac->ColHead;
    delete[] Jac->RowHead;
    delete Jac;
    delete[] NewRow->p;
    delete NewRow;
    delete[] NewCol->p;
    delete NewCol;
    delete[] OldRow->p;
    delete OldRow;
    delete[] OldCol->p;
    delete OldCol;
    delete[] RowPartition->p;
    delete RowPartition;
    delete[] ColPartition->p;
    delete ColPartition;
    Jac=NULL;
  }
  if (ACvar!=NULL)  { delete[] ACvar;  ACvar=NULL; }
  if (Dx!=NULL) { delete[] Dx;  Dx=NULL; }
  if (x0!=NULL) { delete[] x0;  x0=NULL; }
  if (x0p!=NULL) { delete[] x0p;  x0p=NULL; }
  if (dx!=NULL) { delete[] dx;  dx=NULL; }
  if (dF!=NULL) {  delete[] dF;  dF=NULL; }
  if (DxZero!=NULL) {  delete[] DxZero;  DxZero=NULL; }
  if (Vlist!=NULL) {
    if (Vlist!=Vlistp) {
      for(LACptr=Vlist;LACptr!=NULL;LACptrp=LACptr->Next,delete LACptr,LACptr=LACptrp);
      for(LACptr=Vlistp;LACptr!=NULL;LACptrp=LACptr->Next,delete LACptr,LACptr=LACptrp);
    } else
      for(LACptr=Vlist;LACptr!=NULL;LACptrp=LACptr->Next,delete LACptr,LACptr=LACptrp);
    Vlist=Vlistp=NULL;
  }
  if (dataPtr!=NULL) {
    for (Aptr=dataPtr->Area;Aptr!=NULL;){
      Aptrp=Aptr->Next;
      for(LACptr=Aptr->AC;LACptr!=NULL;LACptrp=LACptr->Next,delete LACptr,LACptr=LACptrp);
      for(LDCptr=Aptr->DC;LDCptr!=NULL;LDCptrp=LDCptr->Next,delete LDCptr,LDCptr=LDCptrp);
      for(LEptr=Aptr->Elem;LEptr!=NULL;LEptrp=LEptr->Next,delete LEptr,LEptr=LEptrp);
      delete Aptr;
      Aptr=Aptrp;
    }
    for(ACptr=dataPtr->ACbus;ACptr!=NULL;) {
      ACptrp=ACptr->Next;
      for(LEptr=ACptr->Reg;LEptr!=NULL;LEptrp=LEptr->Next,delete LEptr,LEptr=LEptrp);
      for(LEptr=ACptr->Elem;LEptr!=NULL;LEptrp=LEptr->Next,delete LEptr,LEptr=LEptrp);
      for(LDCptr=ACptr->DC;LDCptr!=NULL;LDCptrp=LDCptr->Next,delete LDCptr,LDCptr=LDCptrp);
      for(LSVCptr=ACptr->SVC;LSVCptr!=NULL;LSVCptrp=LSVCptr->Next,delete LSVCptr,LSVCptr=LSVCptrp);                                  /* FACTS */
      for(LTCSCptr=ACptr->TCSC;LTCSCptr!=NULL;LTCSCptrp=LTCSCptr->Next,delete LTCSCptr,LTCSCptr=LTCSCptrp);                          /* FACTS */
      for(LSTATCOMptr=ACptr->STATCOM;LSTATCOMptr!=NULL;LSTATCOMptrp=LSTATCOMptr->Next,delete LSTATCOMptr,LSTATCOMptr=LSTATCOMptrp);  /* FACTS */
      for(LACptr=ACptr->ContBus;LACptr!=NULL;LACptrp=LACptr->Next,delete LACptr,LACptr=LACptrp);
      if (ACptr->Gen!=NULL) delete ACptr->Gen;
      delete ACptr;
      ACptr=ACptrp;
    }
    for(DCptr=dataPtr->DCbus;DCptr!=NULL;) {
      DCptrp=DCptr->Next;
      delete DCptr;
      DCptr=DCptrp;
    }
    for(Eptr=dataPtr->Element;Eptr!=NULL;) {
      Eptrp=Eptr->Next;
      delete Eptr;
      Eptr=Eptrp;
    }

                           /* FACTS */
    for(SVCptr=dataPtr->SVCbus;SVCptr!=NULL;) {
      SVCptrp=SVCptr->Next;
      delete SVCptr;
      SVCptr=SVCptrp;
    }
    for(TCSCptr=dataPtr->TCSCbus;TCSCptr!=NULL;) {
      TCSCptrp=TCSCptr->Next;
      delete TCSCptr;
      TCSCptr=TCSCptrp;
    }
    for(STATCOMptr=dataPtr->STATCOMbus;STATCOMptr!=NULL;) {
      STATCOMptrp=STATCOMptr->Next;
      delete STATCOMptr;
      STATCOMptr=STATCOMptrp;
    }
                        /* END FACTS */

    for(LACptr=dataPtr->KGbus;LACptr!=NULL;) {
      LACptrp=LACptr->Next;
      delete LACptr;
      LACptr=LACptrp;
    }
    delete dataPtr;
    dataPtr=NULL;

	
  }
  //close standard streams
  fclose(stdout);
  fclose(stderr);
  //fclose(stdin);

  
  //update graph
  //set range to around the max and min points on the graph
  GraphDlg->m_GraphCtrl.SetRange(GraphDlg->minX*0.9, GraphDlg->maxX*1.2, GraphDlg->minY*0.9, GraphDlg->maxY*1.1);
	  
  for (int i = 1; i<=GraphDlg->m_GraphCtrl.GetAnnoCount(); i++){
	//set the legend
	  GraphDlg->m_GraphCtrl.SetAnnotation(i-1);
	  GraphDlg->m_GraphCtrl.SetAnnoLabelX(GraphDlg->maxX*1.05);
	  GraphDlg->m_GraphCtrl.SetAnnoLabelY(GraphDlg->maxY * 1.1 *(1-i*0.1) + GraphDlg->minY* 0.9*0.1*i);
  }

  
  //set the x axis label
  GraphDlg->m_GraphCtrl.SetXLabel("L.F.");


}
#endif