readital.cpp

用于电力系统潮流计算 c++程序

/* Read AC data in ITALIAN format  */

#include "readdata.h"

BOOLEAN ReadADDfile();
#ifdef ANSIPROTO
ACbusData *ACbusInList2(INDEX BusN,char *BusCode,INDEX N1,INDEX N2,BOOLEAN flagAddBus);
ElementData *ElemInList2(ACbusData *From,ACbusData *To,INDEX N,char *Type,char *Ckt,BOOLEAN flagAddElement);
VALUETYPE GetVelevels(char *BusName);
ElementList *TakeElemFromList(ElementList *ELptr,ElementData *Eptr);
#else
ACbusData *ACbusInList2();
ElementData *ElemInList2();
VALUETYPE GetVelevels();
ElementList *TakeElemFromList();
#endif


/* ------- Global Variables ------ */
extern FILE *InputDataFile;


/* --------------- ACbusInList2  ------------------- */
#ifdef ANSIPROTO
ACbusData *ACbusInList2(INDEX BusN,char *BusCode,INDEX N1,INDEX N2,BOOLEAN flagAddBus)
#else
ACbusData *ACbusInList2(BusN,BusCode,N1,N2,flagAddBus)
char *BusCode;
INDEX BusN,N1,N2;
BOOLEAN flagAddBus;
#endif
{
  ACbusData *ptr,*ptrp,*ptrn;
  INDEX i;

  if((N1==0||N2==0) && flagAddBus) {
    if(N1==0) ptrn=NULL;
    else ptrn=dataPtr->ACbus;
#ifdef WINDOWS
    dataPtr->ACbus= new ACbusData;
#else
    dataPtr->ACbus=(ACbusData *) malloc(sizeof(ACbusData));
    if (dataPtr->ACbus==NULL) {
      fclose(InputDataFile);
      ErrorHalt("Insufficient memory to allocate AC bus data.");
      exit(ERROREXIT);
    }
#endif
    ptr=dataPtr->ACbus;
    if(ptrn!=NULL) ptrn->Prev=ptr;
    ptrp=NULL;
  }
  else {
    ptr=dataPtr->ACbus;
    while (ptr!=NULL){
      if(BusN==ptr->Num||(BusN==0 && !strncmp(ptr->Name,BusCode,strlen(BusCode)))) return(ptr);
      ptrp=ptr;
      ptr=ptr->Next;
    }
    if (!flagAddBus) return(ptr);
#ifdef WINDOWS
    ptr= new ACbusData;
#else
    ptr=(ACbusData *) malloc(sizeof(ACbusData));
    if (ptr==NULL) {
      fclose(InputDataFile);
      ErrorHalt("Insufficient memory to allocate AC bus data.");
      exit(ERROREXIT);
    }
#endif
    ptrp->Next=ptr;
    ptrn=NULL;
  }
  ptr->Num=0;
  strcpy(ptr->Name,BusCode);
  ptr->N=0;
  ptr->KV=0;
  strcpy(ptr->Type,"B");
  strcpy(ptr->Zone,"");
  strcpy(ptr->Owner,"");
  strcpy(ptr->cont,"");
  ptr->Area=NULL;
  ptr->Ncont=0;
  ptr->Reg=NULL;
  ptr->Elem=NULL;
  ptr->Gen=NULL;
  ptr->V=0;
  ptr->VCont=0;
  ptr->Ang=1000.;
  ptr->Pg=0;
  ptr->Qg=0;
  ptr->Pl=0;
  ptr->Ql=0;
  ptr->G=0;
  ptr->B=0;
  ptr->Bz=0;
  ptr->step=0;
  ptr->steps=0;
  for(i=0;i<=72;ptr->Bx[i]=0,i++);
  ptr->PgMax=0;
  ptr->Smax=0;
  ptr->flagPgMax=0;
  ptr->DPg=0;
  ptr->Kg=0;
  ptr->Pz=0;
  ptr->Qz=0;
  ptr->Pn=0;
  ptr->Qn=0;
  ptr->Pzl=0;
  ptr->Qzl=0;
  ptr->Pnl=0;
  ptr->Qnl=0;
  ptr->a=0;
  ptr->b=0;
  ptr->Qmax=0;
  ptr->Qmin=0;
  ptr->Max=0;
  ptr->Min=0;
  ptr->Vmax=0;
  ptr->Vmin=0;
  ptr->Vlmax=0;
  ptr->Vlmin=0;
  ptr->CheckVlimits=TRUE;
  ptr->Qr=0;
  ptr->Kbg=0;
  ptr->Kbg1=0;
  ptr->Kbg2=0;
  ptr->val=0;
  ptr->valp=0;
  ptr->vals=0;
  ptr->valt=0;
  ptr->DC=NULL;
  ptr->SVC=NULL;      /* FACTS */
  ptr->TCSC=NULL;     /* FACTS */
  ptr->STATCOM=NULL;  /* FACTS */
  ptr->Cont=NULL;
  ptr->ContBus=NULL;
  ptr->Next=ptrn;
  ptr->Prev=ptrp;
  return(ptr);
}


/* --------------- ElemInList2  ------------------- */
#ifdef ANSIPROTO
ElementData *ElemInList2(ACbusData *From,ACbusData *To,INDEX N,char *Type,char *Ckt,BOOLEAN flagAddElement)
#else
ElementData *ElemInList2(From,To,N,Type,Ckt,flagAddElement)
ACbusData *From,*To;
INDEX N;
char *Type,*Ckt;
BOOLEAN flagAddElement;
#endif
{
  ElementData *ptr,*ptrp;
  ElementList *ELptr;

  if(N==0) {
#ifdef WINDOWS
    dataPtr->Element= new ElementData;
#else
    dataPtr->Element=(ElementData *) malloc(sizeof(ElementData));
    if (dataPtr->Element==NULL){
      fclose(InputDataFile);
      ErrorHalt("Insufficient memory to allocate AC element data.");
      exit(ERROREXIT);
    }
#endif
    ptr=dataPtr->Element;
  }
  else {
    for(ELptr=From->Elem;ELptr!=NULL;ELptr=ELptr->Next){
      ptr=ELptr->Eptr;
      if(((ptr->From==From && ptr->To==To) || (ptr->From==To && ptr->To==From))
         && strpbrk(ptr->Type,Type) && !strcmp(ptr->Ckt,Ckt) )  {
         if (flagAddElement) return(NULL);
         else                return(ptr);
      }
    }
    if (!flagAddElement) return(NULL);
#ifdef WINDOWS
    ptr= new ElementData;
#else
    ptr=(ElementData *) malloc(sizeof(ElementData));
    if (ptr==NULL) {
      fclose(InputDataFile);
      ErrorHalt("Insufficient memory to allocate AC element data.");
      exit(ERROREXIT);
    }
#endif
  }
  ptrp=dataPtr->Element;
  if (ptrp!=ptr) {
    ptrp->Prev=ptr;
    ptr->Next=ptrp;
    dataPtr->Element=ptr;
  } else ptr->Next=NULL;
  ptr->Prev=NULL;
  ptr->From=From;
  ptr->To=To;
  From->Elem=(ElementList *) AddElemToList(From->Elem,ptr);
  To->Elem=(ElementList *) AddElemToList(To->Elem,ptr);
  strcpy(ptr->Ckt,Ckt);
  strcpy(ptr->Type,Type);
  strcpy(ptr->Zone,"");
  strcpy(ptr->Owner,"");
  ptr->Area=NULL;
  ptr->Meter=NULL;
  ptr->Sec=0;
  ptr->G=0;
  ptr->B=0;
  ptr->G1=0;
  ptr->B1=0;
  ptr->G2=0;
  ptr->B2=0;
  ptr->Tap=1;
  ptr->Taps=1;
  ptr->Ang=0;
  ptr->Cont=NULL;
  ptr->Ncont=0;
  ptr->Cvar=0;
  strcpy(ptr->Ctype,"");
  ptr->Tmin=0;
  ptr->Tmax=0;
  ptr->Min=0;
  ptr->Max=0;
  ptr->Imax=0;
  ptr->CheckIlimits=TRUE;
  return(ptr);
}


/* ---------------- ReadITALY ----------------------------- */
void ReadITALY()
/* Read Bus and Element data in WSCC format. */
{
  ACbusData *ACptr,*ACptrp,*ACptrs,*ACptrEstimate;
  ElementData *Eptr;
  AreaData *Aptr;
  char Line[BUFLEN],Code[6],Ckt[2],Type[2],Zone[3];
  VALUETYPE KV,KVp,KVs,R,X,G,B,B1,B2,Zb,Tap,Ang,Taps,Tmax,Tmin;
  VALUETYPE Vlevels[10],Vmax[10],Vmin[10],Vlmax,Vlmin;
  INDEX N,KVl;
  int i,j;
  BOOLEAN EstimatePl=FALSE,EstimateQl=FALSE;


  for(i=0;i<=2;strcpy(dataPtr->Title[i],"\n"),i++);
  for(i=0;i<10;Vlevels[i]=Vmax[i]=Vmin[i]=0,i++);
  Sn=100.0;
  RealParameter('$',&Sn,1.0,100000000.0);
  ACptr=NULL;
  i=0;
  for(;;){ /* Reading Loop */
    Line[79]=' ';
    if (fgets(Line,BUFLEN,InputDataFile)==NULL){
      ErrorHalt("Missing F card.");
      break;
    }
    LineNum++;

  /* --------------- Title and Comments ----------------------------- */
    if (Line[79]=='C' || Line[79]=='*') {
      if(i==0) {strcpy(dataPtr->Title[i],Line); i++;}
      else continue;
    }

  /* --------------- Voltage Levels and Limits --------------------- */
    else if (Line[79]=='Z' && !strncmp(Line,"VNOM",4)) {
      for (j=0;j<=9;j++) Vlevels[j+1]=GetValue(Line,7+j*5,5,0);
    }
    else if (Line[79]=='Z' && !strncmp(Line,"VMIN",4)) {
      for (j=0;j<=9;j++) Vmin[j+1]=GetValue(Line,7+j*5,5,0);
    }
    else if (Line[79]=='Z' && !strncmp(Line,"VMAX",4)) {
      for (j=0;j<=9;j++) Vmax[j+1]=GetValue(Line,7+j*5,5,0);
    }

  /* --------------- AC bus data -------------------------------- */

    /* Load */
    else if (Line[79]=='N') {
      N=GetInt(Line,1,3);
      GetStr(Line,4,1,1,Zone);
      KVl=GetInt(Line,5,1);
      sprintf(Code,"%3d%1s%1d",N,Zone,KVl);
      ACptr=ACbusInList2(0,Code,Nac,1,TRUE);
      if (ACptr->V>0) {
        fprintf(stderr,"Input Line-> %d\n%s",LineNum,Line);
        ErrorHalt("The AC bus was previously defined (check N cards).");
      }
      if (ACptr->N==0) {
        Nac++;
        ACptr->Num=ACptr->N=Nac;
        KV=Vlevels[KVl];
        sprintf(ACptr->Name,"%5s %6.0lf",Code,KV);
        Vlmax=Vmax[KVl];
        Vlmin=Vmin[KVl];
        if (KV==0){
          fprintf(stderr,"Input Line-> %d\n%s",LineNum,Line);
          ErrorHalt("Base voltage is zero.");
          KV=1;
        }
        else if (Vlmax>Vlmin && Vlmax>=KV && Vlmin<=KV) {
          ACptr->Vlmax=Vlmax/KV;
          ACptr->Vlmin=Vlmin/KV;
        }
        ACptr->KV=KV;
      } else KV=ACptr->KV;
      strcpy(ACptr->Zone,Zone);
      strcpy(ACptr->Owner,Zone);
      ACptr->V=GetValue(Line,47,5,0)/KV;
      if (ACptr->V<=0) ACptr->V=1;
      ACptr->VCont=ACptr->V;
      if (Line[20]=='T') {
        EstimatePl=TRUE;
        ACptrEstimate=ACptr;
        fprintf(stderr,"***Warning: The P load at bus %d %s will be estimated from the\n",ACptr->N,ACptr->Name);
        fprintf(stderr,"            oncoming element data for this bus.\n");
      }
      else {
        EstimatePl=FALSE;
        ACptr->Pl=GetValue(Line,14,6,0)/Sn;

      }
      if (Line[42]=='T') {
        EstimateQl=TRUE;
        ACptrEstimate=ACptr;
        fprintf(stderr,"***Warning: The Q load at bus %d %s will be estimated from the\n",ACptr->N,ACptr->Name);
        fprintf(stderr,"            oncoming element data for this bus.\n");
      }
      else {
        EstimateQl=FALSE;
        ACptr->Ql=GetValue(Line,36,6,0)/Sn;
      }
      ACptr->Vmax=GetValue(Line,57,3,0)/KV;
      if (ACptr->Vmax<=0) ACptr->Vmax=10.;
      ACptr->Vmin=GetValue(Line,53,3,0)/KV;
      if (ACptr->Vmin<=0) ACptr->Vmin=0.001;
      if (ACptr->Vmax<=ACptr->Vmin) {
        fprintf(stderr,"Input Line-> %d\n%s",LineNum,Line);
        ErrorHalt("AC bus V limits are wrong: Vmin >= Vmax.");
      }
      if (Line[22]=='T') {
        Nslack++;
        strcpy(ACptr->Type,"BS");
        strcpy(ACptr->cont,"V");
        AngSlack=0;
      }
      else if (Line[44]=='T' && strcmp(ACptr->Type,"BQ")){
        Nvolt++;
        strcpy(ACptr->Type,"BQ");
        strcpy(ACptr->cont,"V");
      }
      else {
        ACptr->Cont=ACptr;
      }
    }

    /* Generator */
    else if (Line[79]=='I' || Line[79]=='E') {
      N=GetInt(Line,1,3);
      GetStr(Line,4,1,1,Zone);
      KVl=GetInt(Line,5,1);
      sprintf(Code,"%3d%1s%1d",N,Zone,KVl);
      ACptr=ACbusInList2(0,Code,Nac,1,TRUE);