readinit.c

电力系统分析计算 学习调试程序 UNIX / LINUX / CYGWIN 系统使用

                 */
                 if (IaMax<=0) {
                    fCustomPrint(stderr,"***Warning: The generator steady-state data for bus:%s\n",ACptr->Name);
                    fCustomPrint(stderr,"            has IaxMax<=0.  The program will force IaMax=9999999999.\n");
                    IaMax=9999999999.;
                 }
                 ACptr->Gen->IaMax=IaMax;
                 if (EqMax<=0) {
                    fCustomPrint(stderr,"***Warning: The generator steady-state data for bus:%s\n",ACptr->Name);
                    fCustomPrint(stderr,"            has EqMax<=0.  The program will force EqMax=9999999999.\n");
                    EqMax=9999999999.;
                 }
                 ACptr->Gen->EqMax=EqMax;
                 if (EqMin>EqMax || EqMin<0) {
                    fCustomPrint(stderr,"***Warning: The generator steady-state data for bus:%s\n",ACptr->Name);
                    fCustomPrint(stderr,"            has EqMin>EqMax or EqMin<0.  The program will force EqMin=0.\n");
                    EqMax=0.;
                 }
                 ACptr->Gen->EqMin=EqMin;
                 V=ACptr->V;
                 d=ACptr->Ang;
                 Pg=ACptr->Pg;
                 Qg=ACptr->Qg;
                 Vr=V*cos(d);
                 Vi=V*sin(d);
                 Ir=(Vr*Pg+Vi*Qg)/(V*V);
                 Ii=(Vi*Pg-Vr*Qg)/(V*V);
                 Ia=sqrt(Ir*Ir+Ii*Ii);
                 if (Ia>IaMax) Ia=IaMax;
                 else if (Ia==0) Ia=1.;
                 apr=Vr-Xq*Ii;
                 api=Vi+Xq*Ir;
                 dg=atan2(api,apr);
                 Vq=cos(dg)*Vr+sin(dg)*Vi;
                 Vd=-sin(dg)*Vr+cos(dg)*Vi;
                 Iq=cos(dg)*Ir+sin(dg)*Ii;
                 Id=-sin(dg)*Ir+cos(dg)*Ii;
                 Eq=Vq-Xd*Id;
                 if (Eq>EqMax) Eq=EqMax;
                 else if (Eq<EqMin) Eq=EqMin;
                 ACptr->Gen->Eq=Eq;
                 ACptr->Gen->dg=dg;
                 ACptr->Gen->Vr=Vr;
                 ACptr->Gen->Vi=Vi;
                 ACptr->Gen->Ir=Ir;
                 ACptr->Gen->Ii=Ii;
                 ACptr->Gen->Vd=Vd;
                 ACptr->Gen->Vq=Vq;
                 ACptr->Gen->Id=Id;
                 ACptr->Gen->Iq=Iq;
                 ACptr->Gen->Ia=Ia;
                 Ngen++;
              }
           }
        } else ACptr=NULL;
        if (ACptr==NULL) {
            fCustomPrint(stderr,"***Warning: Line-> %s",Line);
            fCustomPrint(stderr,"            will be ignored in file %s.\n",Name);
        }
      }
   }
   fclose(InputFile);
  }

 /* -------------------- Read OH Load Model --------------------- */
  if (!ReadOHload(NameParameter('D'))) {
    if (!NullName(NameParameter('D'))) {
      fCustomPrint(stderr,"Error in file %s.  The program will assume constant\n",NameParameter('D'));
      fCustomPrint(stderr,"P-Q load models.\n");
    }
    if (!flagVloads) for(ACptr=dataPtr->ACbus;ACptr!=NULL;ACptr=ACptr->Next) {
      ACptr->Pn=ACptr->Pl;
      ACptr->a=ACptr->Pz=0;
      ACptr->Qn=ACptr->Ql;
      ACptr->b=ACptr->Qz=0;
    }
  }


 /* -------------------- Voltage/Lambda Options -------------------- */
  Bl=0;
  if (ExistParameter('v')) {
    RealParameter('v',&V,0.0,10.0);
    if (V>0.001) {
      ACptr=NULL;
      N=IntegerParameter('B',0,0,9999);
      if (N) {
         for(ACptr=dataPtr->ACbus;ACptr!=NULL;ACptr=ACptr->Next)
         if((!strcmp(ACptr->Type,"B")||!strcmp(ACptr->Type,"BA")) && ACptr->Num==N) break;
         if (ACptr==NULL) {
            fCustomPrint(stderr,"***Warning: The program will ignore the number in -B option (not a PQ bus).\n");
         }
      }
      if (ACptr==NULL) {
         for(ACptr=dataPtr->ACbus;ACptr!=NULL;ACptr=ACptr->Next)
         if(!strcmp(ACptr->Type,"B")||!strcmp(ACptr->Type,"BA")) break;
      }
      if (ACptr!=NULL) {
         BlPtr=ACptr;
         BlPtr->V=V;
         return(TRUE);
      }
      else {
         fCustomPrint(stderr,"***Warning: The program will ignore the -v option (there is no PQ bus).\n");
      }
    } else {
      fCustomPrint(stderr,"***Warning: The program will ignore the -v option (mag=0).\n");
    }
  }
  return(FALSE);
}



/* --------------------- ReadOHload ---------------------------------- */
#ifdef ANSIPROTO
BOOLEAN ReadOHload(char *File)
#else
BOOLEAN ReadOHload(File)
char *File;
#endif
 /* Read Ontatio Hydro load model using SSSP (OH) format. */
{
  ACbusData *ACptr;
  FILE *Input;
  char Line[BUFLEN],Name[13];
  int LineNum=0;
  BOOLEAN flag=FALSE,flagp=FALSE;
  INDEX Num,NA,Nlow,Nhigh;
  VALUETYPE Pn,Pz,Qn,Qz,a,b,MinMW,MinMVAR;


  if (!NullName(File) && (Input=OpenInput(File))!=NULL) {
    for (ACptr=dataPtr->ACbus;ACptr!=NULL;ACptr=ACptr->Next) {
      ACptr->Pn=0;
      ACptr->Pz=1;
      ACptr->a=0;
      ACptr->Qn=0;
      ACptr->Qz=1;
      ACptr->b=0;
    }
    for(;;){ /* Reading Loop */
      if (fgets(Line,BUFLEN,Input)==NULL) {
         ErrorHalt("Missing NLBS, EDATA, or END cards on OH load data file.");
         fclose(Input);
         return(FALSE);
      }
      LineNum++;

      /* -------------- Comments ------------- */
      if (!strncmp(Line,"!",1) || !strncmp(Line,"C",1) ) continue;

      /* ------------ OH load Model ---------- */
      else if (!strncmp(Line," NLBS",5)) flag=TRUE;
      else if (flag && (!strncmp(Line,"EDATA",5) || !strncmp(Line,"  END",5))) break;
      else if (flag) {
         GetStr(Line,1,12,12,Name);
         Num=GetInt(Line,1,5);
         if (strncmp(Name,"50000",5) && strncmp(Name,"60000",5)) {

         /* -------------- Definition of each bus ------------- */
            for (ACptr=dataPtr->ACbus;ACptr!=NULL;ACptr=ACptr->Next) {
               if(!strncmp(ACptr->Name,Name,strlen(Name))){
                  flagp=TRUE;
                  ACptr->Pn=(VALUETYPE) GetInt(Line,13,5)/100.0;
                  ACptr->Pz=1-ACptr->Pn;
                  ACptr->a=GetValue(Line,23,10,5);
                  ACptr->Qn=(VALUETYPE) GetInt(Line,18,5)/100.0;
                  ACptr->Qz=1-ACptr->Qn;
                  ACptr->b=GetValue(Line,33,10,5);
                  break;
               } else if(Num==ACptr->Num) {
                  flagp=TRUE;
                  ACptr->Pn=(VALUETYPE) GetInt(Line,6,5)/100.0;
                  ACptr->Pz=1-ACptr->Pn;
                  ACptr->a=GetValue(Line,16,10,5);
                  ACptr->Qn=(VALUETYPE) GetInt(Line,11,5)/100.0;
                  ACptr->Qz=1-ACptr->Qn;
                  ACptr->b=GetValue(Line,26,10,5);
                  break;
               }
            }
            if (ACptr==NULL) {
               fCustomPrint(stderr,"***Warning: Line #%d-> %s",LineNum,Line);
               fCustomPrint(stderr,"            will be ignored in file %s.\n",File);
            }
         }

         /* -------------- Definition of buses by range ------------------- */
         else {
            Pn=(VALUETYPE) GetInt(Line,6,5)/100.0;
            Pz=1-Pn;
            a=GetValue(Line,16,10,5);
            Qn=(VALUETYPE) GetInt(Line,11,5)/100.0;
            Qz=1-Qn;
            b=GetValue(Line,26,10,5);
            LineNum++;
            if (fgets(Line,BUFLEN,Input)==NULL || !strncmp(Line,"EDATA",5) || !strncmp(Line,"  END",5)) {
               fCustomPrint(stderr,"Range card is missing in line #%d of file %s.\n",LineNum,File);
               fclose(Input);
               return(FALSE);
            }
            NA=GetInt(Line,1,5);
            if (!strncmp(Name,"50000",5) && Narea<=1 ) {
               fCustomPrint(stderr,"***Warning: Area %d doen't exist (line #%d of file %s).\n",NA,LineNum,File);
               fCustomPrint(stderr,"            The program will assume these data for all system loads.\n");
            }
            Nlow=GetInt(Line,6,5);
            if (Nlow<=0) Nlow=1;
            Nhigh=GetInt(Line,11,5);
            if (Nhigh<=0) Nhigh=INT_MAX;
            MinMW=GetValue(Line,16,10,5);
            MinMW=MinMW/Sn;
            MinMVAR=GetValue(Line,26,10,5);
            MinMVAR=MinMVAR/Sn;
            for (ACptr=dataPtr->ACbus;ACptr!=NULL;ACptr=ACptr->Next) {
               if (!strncmp(Name,"60000",5) || Narea<=1 || ACptr->Area->N==NA) {
                  flagp=TRUE;
                  if (ACptr->Num<=Nhigh && ACptr->Num>=Nlow) {
                     if (ACptr->Pl>MinMW) {
                        ACptr->Pn=Pn;
                        ACptr->Pz=Pz;
                        ACptr->a=a;
                     }
                     if (ACptr->Ql>MinMVAR) {
                        ACptr->Qn=Qn;
                        ACptr->Qz=Qz;
                        ACptr->b=b;
                     }
                  }
               }
            }
         }
      }
    }
    fclose(Input);
  }
  return(flagp);
}