From dc5a09ff9dabbf4d5480d927e57bb07b326aa9d5 Mon Sep 17 00:00:00 2001 From: "dmy@lab" Date: Sun, 1 Feb 2015 16:58:04 +0800 Subject: [PATCH] =?UTF-8?q?=E4=BF=9D=E5=AD=98?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .gitignore | 9 + HSLInterface.h | 75 + ldl.c | 507 ++ ldl.h | 134 + libcoinhsl.lib | Bin 0 -> 118352 bytes opf.cpp | 17655 +++++++++++++++++++++++++++++++++++++++++++++++ 6 files changed, 18380 insertions(+) create mode 100644 .gitignore create mode 100644 HSLInterface.h create mode 100644 ldl.c create mode 100644 ldl.h create mode 100644 libcoinhsl.lib create mode 100644 opf.cpp diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..e80d65d --- /dev/null +++ b/.gitignore @@ -0,0 +1,9 @@ +*.txt +*.exe +/Debug +/Release +*.dsp +*.dsw +*.ncb +*.opt +*.plg \ No newline at end of file diff --git a/HSLInterface.h b/HSLInterface.h new file mode 100644 index 0000000..72bdd84 --- /dev/null +++ b/HSLInterface.h @@ -0,0 +1,75 @@ +/* Copyright (C) 2008 GAMS Development and others + All Rights Reserved. + This code is published under the Common Public License. + + $Id: HSLLoader.c 341 2008-02-14 18:51:25Z stefan $ + + Author: Stefan Vigerske +*/ + + +#include +#include + + + +void ma57id_(double *cntl, int *icntl); + +void ma57ad_ ( + int *n, /* Order of matrix. */ + int *ne, /* Number of entries. */ + const int *irn, /* Matrix nonzero row structure */ + const int *jcn, /* Matrix nonzero column structure */ + int *lkeep, /* Workspace for the pivot order of lenght 3*n */ + int *keep, /* Workspace for the pivot order of lenght 3*n */ + /* Automatically iflag = 0; ikeep pivot order iflag = 1 */ + int *iwork, /* Integer work space. */ + int *icntl, /* Integer Control parameter of length 30*/ + int *info, /* Statistical Information; Integer array of length 20 */ + double *rinfo); /* Double Control parameter of length 5 */ + + void ma57bd_( + int *n, /* Order of matrix. */ + int *ne, /* Number of entries. */ + double *a, /* Numerical values. */ + double *fact, /* Entries of factors. */ + int *lfact, /* Length of array `fact'. */ + int *ifact, /* Indexing info for factors. */ + int *lifact, /* Length of array `ifact'. */ + int *lkeep, /* Length of array `keep'. */ + int *keep, /* Integer array. */ + int *iwork, /* Workspace of length `n'. */ + int *icntl, /* Integer Control parameter of length 20. */ + double *cntl, /* Double Control parameter of length 5. */ + int *info, /* Statistical Information; Integer array of length 40. */ + double *rinfo); /* Statistical Information; Real array of length 20. */ + +void ma57cd_( + int *job, /* Solution job. Solve for... */ + int *n, /* Order of matrix. */ + double *fact, /* Entries of factors. */ + int *lfact, /* Length of array `fact'. */ + int *ifact, /* Indexing info for factors. */ + int *lifact, /* Length of array `ifact'. */ + int *nrhs, /* Number of right hand sides. */ + double *rhs, /* Numerical Values. */ + int *lrhs, /* Leading dimensions of `rhs'. */ + double *work, /* Real workspace. */ + int *lwork, /* Length of `work', >= N*NRHS. */ + int *iwork, /* Integer array of length `n'. */ + int *icntl, /* Integer Control parameter array of length 20. */ + int *info); /* Statistical Information; Integer array of length 40. */ + +void ma57ed_ ( + int *n, + int *ic, /* 0: copy real array. >=1: copy integer array. */ + int *keep, + double *fact, + int *lfact, + double *newfac, + int *lnew, + int *ifact, + int *lifact, + int *newifc, + int *linew, + int *info); \ No newline at end of file diff --git a/ldl.c b/ldl.c new file mode 100644 index 0000000..a9b35c8 --- /dev/null +++ b/ldl.c @@ -0,0 +1,507 @@ +/* ========================================================================== */ +/* === ldl.c: sparse LDL' factorization and solve package =================== */ +/* ========================================================================== */ + +/* LDL: a simple set of routines for sparse LDL' factorization. These routines + * are not terrifically fast (they do not use dense matrix kernels), but the + * code is very short. The purpose is to illustrate the algorithms in a very + * concise manner, primarily for educational purposes. Although the code is + * very concise, this package is slightly faster than the built-in sparse + * Cholesky factorization in MATLAB 7.0 (chol), when using the same input + * permutation. + * + * The routines compute the LDL' factorization of a real sparse symmetric + * matrix A (or PAP' if a permutation P is supplied), and solve upper + * and lower triangular systems with the resulting L and D factors. If A is + * positive definite then the factorization will be accurate. A can be + * indefinite (with negative values on the diagonal D), but in this case no + * guarantee of accuracy is provided, since no numeric pivoting is performed. + * + * The n-by-n sparse matrix A is in compressed-column form. The nonzero values + * in column j are stored in Ax [Ap [j] ... Ap [j+1]-1], with corresponding row + * indices in Ai [Ap [j] ... Ap [j+1]-1]. Ap [0] = 0 is required, and thus + * nz = Ap [n] is the number of nonzeros in A. Ap is an int array of size n+1. + * The int array Ai and the double array Ax are of size nz. This data structure + * is identical to the one used by MATLAB, except for the following + * generalizations. The row indices in each column of A need not be in any + * particular order, although they must be in the range 0 to n-1. Duplicate + * entries can be present; any duplicates are summed. That is, if row index i + * appears twice in a column j, then the value of A (i,j) is the sum of the two + * entries. The data structure used here for the input matrix A is more + * flexible than MATLAB's, which requires sorted columns with no duplicate + * entries. + * + * Only the diagonal and upper triangular part of A (or PAP' if a permutation + * P is provided) is accessed. The lower triangular parts of the matrix A or + * PAP' can be present, but they are ignored. + * + * The optional input permutation is provided as an array P of length n. If + * P [k] = j, the row and column j of A is the kth row and column of PAP'. + * If P is present then the factorization is LDL' = PAP' or L*D*L' = A(P,P) in + * 0-based MATLAB notation. If P is not present (a null pointer) then no + * permutation is performed, and the factorization is LDL' = A. + * + * The lower triangular matrix L is stored in the same compressed-column + * form (an int Lp array of size n+1, an int Li array of size Lp [n], and a + * double array Lx of the same size as Li). It has a unit diagonal, which is + * not stored. The row indices in each column of L are always returned in + * ascending order, with no duplicate entries. This format is compatible with + * MATLAB, except that it would be more convenient for MATLAB to include the + * unit diagonal of L. Doing so here would add additional complexity to the + * code, and is thus omitted in the interest of keeping this code short and + * readable. + * + * The elimination tree is held in the Parent [0..n-1] array. It is normally + * not required by the user, but it is required by ldl_numeric. The diagonal + * matrix D is held as an array D [0..n-1] of size n. + * + * -------------------- + * C-callable routines: + * -------------------- + * + * ldl_symbolic: Given the pattern of A, computes the Lp and Parent arrays + * required by ldl_numeric. Takes time proportional to the number of + * nonzeros in L. Computes the inverse Pinv of P if P is provided. + * Also returns Lnz, the count of nonzeros in each column of L below + * the diagonal (this is not required by ldl_numeric). + * ldl_numeric: Given the pattern and numerical values of A, the Lp array, + * the Parent array, and P and Pinv if applicable, computes the + * pattern and numerical values of L and D. + * ldl_lsolve: Solves Lx=b for a dense vector b. + * ldl_dsolve: Solves Dx=b for a dense vector b. + * ldl_ltsolve: Solves L'x=b for a dense vector b. + * ldl_perm: Computes x=Pb for a dense vector b. + * ldl_permt: Computes x=P'b for a dense vector b. + * ldl_valid_perm: checks the validity of a permutation vector + * ldl_valid_matrix: checks the validity of the sparse matrix A + * + * ---------------------------- + * Limitations of this package: + * ---------------------------- + * + * In the interest of keeping this code simple and readable, ldl_symbolic and + * ldl_numeric assume their inputs are valid. You can check your own inputs + * prior to calling these routines with the ldl_valid_perm and ldl_valid_matrix + * routines. Except for the two ldl_valid_* routines, no routine checks to see + * if the array arguments are present (non-NULL). Like all C routines, no + * routine can determine if the arrays are long enough and don't overlap. + * + * The ldl_numeric does check the numerical factorization, however. It returns + * n if the factorization is successful. If D (k,k) is zero, then k is + * returned, and L is only partially computed. + * + * No pivoting to control fill-in is performed, which is often critical for + * obtaining good performance. I recommend that you compute the permutation P + * using AMD or SYMAMD (approximate minimum degree ordering routines), or an + * appropriate graph-partitioning based ordering. See the ldldemo.m routine for + * an example in MATLAB, and the ldlmain.c stand-alone C program for examples of + * how to find P. Routines for manipulating compressed-column matrices are + * available in UMFPACK. AMD, SYMAMD, UMFPACK, and this LDL package are all + * available at http://www.cise.ufl.edu/research/sparse. + * + * ------------------------- + * Possible simplifications: + * ------------------------- + * + * These routines could be made even simpler with a few additional assumptions. + * If no input permutation were performed, the caller would have to permute the + * matrix first, but the computation of Pinv, and the use of P and Pinv could be + * removed. If only the diagonal and upper triangular part of A or PAP' are + * present, then the tests in the "if (i < k)" statement in ldl_symbolic and + * "if (i <= k)" in ldl_numeric, are always true, and could be removed (i can + * equal k in ldl_symbolic, but then the body of the if statement would + * correctly do no work since Flag [k] == k). If we could assume that no + * duplicate entries are present, then the statement Y [i] += Ax [p] could be + * replaced with Y [i] = Ax [p] in ldl_numeric. + * + * -------------------------- + * Description of the method: + * -------------------------- + * + * LDL computes the symbolic factorization by finding the pattern of L one row + * at a time. It does this based on the following theory. Consider a sparse + * system Lx=b, where L, x, and b, are all sparse, and where L comes from a + * Cholesky (or LDL') factorization. The elimination tree (etree) of L is + * defined as follows. The parent of node j is the smallest k > j such that + * L (k,j) is nonzero. Node j has no parent if column j of L is completely zero + * below the diagonal (j is a root of the etree in this case). The nonzero + * pattern of x is the union of the paths from each node i to the root, for + * each nonzero b (i). To compute the numerical solution to Lx=b, we can + * traverse the columns of L corresponding to nonzero values of x. This + * traversal does not need to be done in the order 0 to n-1. It can be done in + * any "topological" order, such that x (i) is computed before x (j) if i is a + * descendant of j in the elimination tree. + * + * The row-form of the LDL' factorization is shown in the MATLAB function + * ldlrow.m in this LDL package. Note that row k of L is found via a sparse + * triangular solve of L (1:k-1, 1:k-1) \ A (1:k-1, k), to use 1-based MATLAB + * notation. Thus, we can start with the nonzero pattern of the kth column of + * A (above the diagonal), follow the paths up to the root of the etree of the + * (k-1)-by-(k-1) leading submatrix of L, and obtain the pattern of the kth row + * of L. Note that we only need the leading (k-1)-by-(k-1) submatrix of L to + * do this. The elimination tree can be constructed as we go. + * + * The symbolic factorization does the same thing, except that it discards the + * pattern of L as it is computed. It simply counts the number of nonzeros in + * each column of L and then constructs the Lp index array when it's done. The + * symbolic factorization does not need to do this in topological order. + * Compare ldl_symbolic with the first part of ldl_numeric, and note that the + * while (len > 0) loop is not present in ldl_symbolic. + * + * LDL Version 1.3, Copyright (c) 2006 by Timothy A Davis, + * University of Florida. All Rights Reserved. Developed while on sabbatical + * at Stanford University and Lawrence Berkeley National Laboratory. Refer to + * the README file for the License. Available at + * http://www.cise.ufl.edu/research/sparse. + */ + +#include "ldl.h" + +/* ========================================================================== */ +/* === ldl_symbolic ========================================================= */ +/* ========================================================================== */ + +/* The input to this routine is a sparse matrix A, stored in column form, and + * an optional permutation P. The output is the elimination tree + * and the number of nonzeros in each column of L. Parent [i] = k if k is the + * parent of i in the tree. The Parent array is required by ldl_numeric. + * Lnz [k] gives the number of nonzeros in the kth column of L, excluding the + * diagonal. + * + * One workspace vector (Flag) of size n is required. + * + * If P is NULL, then it is ignored. The factorization will be LDL' = A. + * Pinv is not computed. In this case, neither P nor Pinv are required by + * ldl_numeric. + * + * If P is not NULL, then it is assumed to be a valid permutation. If + * row and column j of A is the kth pivot, the P [k] = j. The factorization + * will be LDL' = PAP', or A (p,p) in MATLAB notation. The inverse permutation + * Pinv is computed, where Pinv [j] = k if P [k] = j. In this case, both P + * and Pinv are required as inputs to ldl_numeric. + * + * The floating-point operation count of the subsequent call to ldl_numeric + * is not returned, but could be computed after ldl_symbolic is done. It is + * the sum of (Lnz [k]) * (Lnz [k] + 2) for k = 0 to n-1. + */ + +void LDL_symbolic +( + LDL_int n, /* A and L are n-by-n, where n >= 0 */ + LDL_int Ap [ ], /* input of size n+1, not modified */ + LDL_int Ai [ ], /* input of size nz=Ap[n], not modified */ + LDL_int Lp [ ], /* output of size n+1, not defined on input */ + LDL_int Parent [ ], /* output of size n, not defined on input */ + LDL_int Lnz [ ], /* output of size n, not defined on input */ + LDL_int Flag [ ], /* workspace of size n, not defn. on input or output */ + LDL_int P [ ], /* optional input of size n */ + LDL_int Pinv [ ] /* optional output of size n (used if P is not NULL) */ +) +{ + LDL_int i, k, p, kk, p2 ; + if (P) + { + /* If P is present then compute Pinv, the inverse of P */ + for (k = 0 ; k < n ; k++) + { + Pinv [P [k]] = k ; + } + } + for (k = 0 ; k < n ; k++) + { + /* L(k,:) pattern: all nodes reachable in etree from nz in A(0:k-1,k) */ + Parent [k] = -1 ; /* parent of k is not yet known */ + Flag [k] = k ; /* mark node k as visited */ + Lnz [k] = 0 ; /* count of nonzeros in column k of L */ + kk = (P) ? (P [k]) : (k) ; /* kth original, or permuted, column */ + p2 = Ap [kk+1] ; + for (p = Ap [kk] ; p < p2 ; p++) + { + /* A (i,k) is nonzero (original or permuted A) */ + i = (Pinv) ? (Pinv [Ai [p]]) : (Ai [p]) ; + if (i < k) + { + /* follow path from i to root of etree, stop at flagged node */ + for ( ; Flag [i] != k ; i = Parent [i]) + { + /* find parent of i if not yet determined */ + if (Parent [i] == -1) Parent [i] = k ; + Lnz [i]++ ; /* L (k,i) is nonzero */ + Flag [i] = k ; /* mark i as visited */ + } + } + } + } + /* construct Lp index array from Lnz column counts */ + Lp [0] = 0 ; + for (k = 0 ; k < n ; k++) + { + Lp [k+1] = Lp [k] + Lnz [k] ; + } +} + + +/* ========================================================================== */ +/* === ldl_numeric ========================================================== */ +/* ========================================================================== */ + +/* Given a sparse matrix A (the arguments n, Ap, Ai, and Ax) and its symbolic + * analysis (Lp and Parent, and optionally P and Pinv), compute the numeric LDL' + * factorization of A or PAP'. The outputs of this routine are arguments Li, + * Lx, and D. It also requires three size-n workspaces (Y, Pattern, and Flag). + */ + +LDL_int LDL_numeric /* returns n if successful, k if D (k,k) is zero */ +( + LDL_int n, /* A and L are n-by-n, where n >= 0 */ + LDL_int Ap [ ], /* input of size n+1, not modified */ + LDL_int Ai [ ], /* input of size nz=Ap[n], not modified */ + double Ax [ ], /* input of size nz=Ap[n], not modified */ + LDL_int Lp [ ], /* input of size n+1, not modified */ + LDL_int Parent [ ], /* input of size n, not modified */ + LDL_int Lnz [ ], /* output of size n, not defn. on input */ + LDL_int Li [ ], /* output of size lnz=Lp[n], not defined on input */ + double Lx [ ], /* output of size lnz=Lp[n], not defined on input */ + double D [ ], /* output of size n, not defined on input */ + double Y [ ], /* workspace of size n, not defn. on input or output */ + LDL_int Pattern [ ],/* workspace of size n, not defn. on input or output */ + LDL_int Flag [ ], /* workspace of size n, not defn. on input or output */ + LDL_int P [ ], /* optional input of size n */ + LDL_int Pinv [ ] /* optional input of size n */ +) +{ + double yi, l_ki ; + LDL_int i, k, p, kk, p2, len, top ; + for (k = 0 ; k < n ; k++) + { + /* compute nonzero Pattern of kth row of L, in topological order */ + Y [k] = 0.0 ; /* Y(0:k) is now all zero */ + top = n ; /* stack for pattern is empty */ + Flag [k] = k ; /* mark node k as visited */ + Lnz [k] = 0 ; /* count of nonzeros in column k of L */ + kk = (P) ? (P [k]) : (k) ; /* kth original, or permuted, column */ + p2 = Ap [kk+1] ; + for (p = Ap [kk] ; p < p2 ; p++) + { + i = (Pinv) ? (Pinv [Ai [p]]) : (Ai [p]) ; /* get A(i,k) */ + if (i <= k) + { + Y [i] += Ax [p] ; /* scatter A(i,k) into Y (sum duplicates) */ + for (len = 0 ; Flag [i] != k ; i = Parent [i]) + { + Pattern [len++] = i ; /* L(k,i) is nonzero */ + Flag [i] = k ; /* mark i as visited */ + } + while (len > 0) Pattern [--top] = Pattern [--len] ; + } + } + /* compute numerical values kth row of L (a sparse triangular solve) */ + D [k] = Y [k] ; /* get D(k,k) and clear Y(k) */ + Y [k] = 0.0 ; + for ( ; top < n ; top++) + { + i = Pattern [top] ; /* Pattern [top:n-1] is pattern of L(:,k) */ + yi = Y [i] ; /* get and clear Y(i) */ + Y [i] = 0.0 ; + p2 = Lp [i] + Lnz [i] ; + for (p = Lp [i] ; p < p2 ; p++) + { + Y [Li [p]] -= Lx [p] * yi ; + } + l_ki = yi / D [i] ; /* the nonzero entry L(k,i) */ + D [k] -= l_ki * yi ; + Li [p] = k ; /* store L(k,i) in column form of L */ + Lx [p] = l_ki ; + Lnz [i]++ ; /* increment count of nonzeros in col i */ + } + if (D [k] == 0.0) return (k) ; /* failure, D(k,k) is zero */ + } + return (n) ; /* success, diagonal of D is all nonzero */ +} + + +/* ========================================================================== */ +/* === ldl_lsolve: solve Lx=b ============================================== */ +/* ========================================================================== */ + +void LDL_lsolve +( + LDL_int n, /* L is n-by-n, where n >= 0 */ + double X [ ], /* size n. right-hand-side on input, soln. on output */ + LDL_int Lp [ ], /* input of size n+1, not modified */ + LDL_int Li [ ], /* input of size lnz=Lp[n], not modified */ + double Lx [ ] /* input of size lnz=Lp[n], not modified */ +) +{ + LDL_int j, p, p2 ; + for (j = 0 ; j < n ; j++) + { + p2 = Lp [j+1] ; + for (p = Lp [j] ; p < p2 ; p++) + { + X [Li [p]] -= Lx [p] * X [j] ; + } + } +} + + +/* ========================================================================== */ +/* === ldl_dsolve: solve Dx=b ============================================== */ +/* ========================================================================== */ + +void LDL_dsolve +( + LDL_int n, /* D is n-by-n, where n >= 0 */ + double X [ ], /* size n. right-hand-side on input, soln. on output */ + double D [ ] /* input of size n, not modified */ +) +{ + LDL_int j ; + for (j = 0 ; j < n ; j++) + { + X [j] /= D [j] ; + } +} + + +/* ========================================================================== */ +/* === ldl_ltsolve: solve L'x=b ============================================ */ +/* ========================================================================== */ + +void LDL_ltsolve +( + LDL_int n, /* L is n-by-n, where n >= 0 */ + double X [ ], /* size n. right-hand-side on input, soln. on output */ + LDL_int Lp [ ], /* input of size n+1, not modified */ + LDL_int Li [ ], /* input of size lnz=Lp[n], not modified */ + double Lx [ ] /* input of size lnz=Lp[n], not modified */ +) +{ + int j, p, p2 ; + for (j = n-1 ; j >= 0 ; j--) + { + p2 = Lp [j+1] ; + for (p = Lp [j] ; p < p2 ; p++) + { + X [j] -= Lx [p] * X [Li [p]] ; + } + } +} + + +/* ========================================================================== */ +/* === ldl_perm: permute a vector, x=Pb ===================================== */ +/* ========================================================================== */ + +void LDL_perm +( + LDL_int n, /* size of X, B, and P */ + double X [ ], /* output of size n. */ + double B [ ], /* input of size n. */ + LDL_int P [ ] /* input permutation array of size n. */ +) +{ + LDL_int j ; + for (j = 0 ; j < n ; j++) + { + X [j] = B [P [j]] ; + } +} + + +/* ========================================================================== */ +/* === ldl_permt: permute a vector, x=P'b =================================== */ +/* ========================================================================== */ + +void LDL_permt +( + LDL_int n, /* size of X, B, and P */ + double X [ ], /* output of size n. */ + double B [ ], /* input of size n. */ + LDL_int P [ ] /* input permutation array of size n. */ +) +{ + LDL_int j ; + for (j = 0 ; j < n ; j++) + { + X [P [j]] = B [j] ; + } +} + + +/* ========================================================================== */ +/* === ldl_valid_perm: check if a permutation vector is valid =============== */ +/* ========================================================================== */ + +LDL_int LDL_valid_perm /* returns 1 if valid, 0 otherwise */ +( + LDL_int n, + LDL_int P [ ], /* input of size n, a permutation of 0:n-1 */ + LDL_int Flag [ ] /* workspace of size n */ +) +{ + LDL_int j, k ; + if (n < 0 || !Flag) + { + return (0) ; /* n must be >= 0, and Flag must be present */ + } + if (!P) + { + return (1) ; /* If NULL, P is assumed to be the identity perm. */ + } + for (j = 0 ; j < n ; j++) + { + Flag [j] = 0 ; /* clear the Flag array */ + } + for (k = 0 ; k < n ; k++) + { + j = P [k] ; + if (j < 0 || j >= n || Flag [j] != 0) + { + return (0) ; /* P is not valid */ + } + Flag [j] = 1 ; + } + return (1) ; /* P is valid */ +} + + +/* ========================================================================== */ +/* === ldl_valid_matrix: check if a sparse matrix is valid ================== */ +/* ========================================================================== */ + +/* This routine checks to see if a sparse matrix A is valid for input to + * ldl_symbolic and ldl_numeric. It returns 1 if the matrix is valid, 0 + * otherwise. A is in sparse column form. The numerical values in column j + * are stored in Ax [Ap [j] ... Ap [j+1]-1], with row indices in + * Ai [Ap [j] ... Ap [j+1]-1]. The Ax array is not checked. + */ + +LDL_int LDL_valid_matrix +( + LDL_int n, + LDL_int Ap [ ], + LDL_int Ai [ ] +) +{ + LDL_int j, p ; + if (n < 0 || !Ap || !Ai || Ap [0] != 0) + { + return (0) ; /* n must be >= 0, and Ap and Ai must be present */ + } + for (j = 0 ; j < n ; j++) + { + if (Ap [j] > Ap [j+1]) + { + return (0) ; /* Ap must be monotonically nondecreasing */ + } + } + for (p = 0 ; p < Ap [n] ; p++) + { + if (Ai [p] < 0 || Ai [p] >= n) + { + return (0) ; /* row indices must be in the range 0 to n-1 */ + } + } + return (1) ; /* matrix is valid */ +} diff --git a/ldl.h b/ldl.h new file mode 100644 index 0000000..36e30ad --- /dev/null +++ b/ldl.h @@ -0,0 +1,134 @@ +/* ========================================================================== */ +/* === ldl.h: include file for the LDL package ============================= */ +/* ========================================================================== */ + +/* LDL Copyright (c) Timothy A Davis, + * University of Florida. All Rights Reserved. See README for the License. + */ + +#ifdef __cplusplus +extern "C" { +#endif + +#include + +/* ========================================================================== */ +/* === UF_long ============================================================== */ +/* ========================================================================== */ + +#ifndef UF_long + +#ifdef _WIN64 + +#define UF_long __int64 +#define UF_long_max _I64_MAX +#define UF_long_id "%I64d" + +#else + +#define UF_long long +#define UF_long_max LONG_MAX +#define UF_long_id "%ld" + +#endif +#endif + +#ifdef __cplusplus +} +#endif + + +#ifdef LDL_LONG +#define LDL_int UF_long +#define LDL_ID UF_long_id + +#define LDL_symbolic ldl_l_symbolic +#define LDL_numeric ldl_l_numeric +#define LDL_lsolve ldl_l_lsolve +#define LDL_dsolve ldl_l_dsolve +#define LDL_ltsolve ldl_l_ltsolve +#define LDL_perm ldl_l_perm +#define LDL_permt ldl_l_permt +#define LDL_valid_perm ldl_l_valid_perm +#define LDL_valid_matrix ldl_l_valid_matrix + +#else +#define LDL_int int +#define LDL_ID "%d" + +#define LDL_symbolic ldl_symbolic +#define LDL_numeric ldl_numeric +#define LDL_lsolve ldl_lsolve +#define LDL_dsolve ldl_dsolve +#define LDL_ltsolve ldl_ltsolve +#define LDL_perm ldl_perm +#define LDL_permt ldl_permt +#define LDL_valid_perm ldl_valid_perm +#define LDL_valid_matrix ldl_valid_matrix + +#endif + +/* ========================================================================== */ +/* === int version ========================================================== */ +/* ========================================================================== */ + +void ldl_symbolic (int n, int Ap [ ], int Ai [ ], int Lp [ ], + int Parent [ ], int Lnz [ ], int Flag [ ], int P [ ], int Pinv [ ]) ; + +int ldl_numeric (int n, int Ap [ ], int Ai [ ], double Ax [ ], + int Lp [ ], int Parent [ ], int Lnz [ ], int Li [ ], double Lx [ ], + double D [ ], double Y [ ], int Pattern [ ], int Flag [ ], + int P [ ], int Pinv [ ]) ; + +void ldl_lsolve (int n, double X [ ], int Lp [ ], int Li [ ], + double Lx [ ]) ; + +void ldl_dsolve (int n, double X [ ], double D [ ]) ; + +void ldl_ltsolve (int n, double X [ ], int Lp [ ], int Li [ ], + double Lx [ ]) ; + +void ldl_perm (int n, double X [ ], double B [ ], int P [ ]) ; +void ldl_permt (int n, double X [ ], double B [ ], int P [ ]) ; + +int ldl_valid_perm (int n, int P [ ], int Flag [ ]) ; +int ldl_valid_matrix ( int n, int Ap [ ], int Ai [ ]) ; + +/* ========================================================================== */ +/* === long version ========================================================= */ +/* ========================================================================== */ + +void ldl_l_symbolic (UF_long n, UF_long Ap [ ], UF_long Ai [ ], UF_long Lp [ ], + UF_long Parent [ ], UF_long Lnz [ ], UF_long Flag [ ], UF_long P [ ], + UF_long Pinv [ ]) ; + +UF_long ldl_l_numeric (UF_long n, UF_long Ap [ ], UF_long Ai [ ], double Ax [ ], + UF_long Lp [ ], UF_long Parent [ ], UF_long Lnz [ ], UF_long Li [ ], + double Lx [ ], double D [ ], double Y [ ], UF_long Pattern [ ], + UF_long Flag [ ], UF_long P [ ], UF_long Pinv [ ]) ; + +void ldl_l_lsolve (UF_long n, double X [ ], UF_long Lp [ ], UF_long Li [ ], + double Lx [ ]) ; + +void ldl_l_dsolve (UF_long n, double X [ ], double D [ ]) ; + +void ldl_l_ltsolve (UF_long n, double X [ ], UF_long Lp [ ], UF_long Li [ ], + double Lx [ ]) ; + +void ldl_l_perm (UF_long n, double X [ ], double B [ ], UF_long P [ ]) ; +void ldl_l_permt (UF_long n, double X [ ], double B [ ], UF_long P [ ]) ; + +UF_long ldl_l_valid_perm (UF_long n, UF_long P [ ], UF_long Flag [ ]) ; +UF_long ldl_l_valid_matrix ( UF_long n, UF_long Ap [ ], UF_long Ai [ ]) ; + +/* ========================================================================== */ +/* === LDL version ========================================================== */ +/* ========================================================================== */ + +#define LDL_DATE "Nov 1, 2007" +#define LDL_VERSION_CODE(main,sub) ((main) * 1000 + (sub)) +#define LDL_MAIN_VERSION 2 +#define LDL_SUB_VERSION 0 +#define LDL_SUBSUB_VERSION 1 +#define LDL_VERSION LDL_VERSION_CODE(LDL_MAIN_VERSION,LDL_SUB_VERSION) + diff --git a/libcoinhsl.lib b/libcoinhsl.lib new file mode 100644 index 0000000000000000000000000000000000000000..d893fcd1a1eedcd37f841542ff8536ab657e3cbb GIT binary patch literal 118352 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 QU?D1SkO4&7VwY`t}s8&qOu3%Vn}L% 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 + +#define CRTDBG_MAP_ALLOC +#include +#include //平时可以用，编译DLL的时候要注释 +//#include "HSLInterface.h" + +//定义 节点导纳矩阵结构 +typedef struct opf_yij_struct +{ int irow; //行号 + int jcol; //列号 + double amp; //幅值 amplitude + double rad; //相角 angle 弧度radian + struct opf_yij_struct * next; +} opf_yij; + +//定义 雅可比矩阵、海森矩阵结构 +typedef struct opf_matrix_struct +{ int irow; //行号 + int jcol; //列号 + double z; //值，value + struct opf_matrix_struct * next; +} opf_matrix; + +//定义 不等式约束的结构，用于线路的P,Q,S,I,cos等，不用单列 pij +typedef struct opf_gij_struct +{ int i; //首节点 + int j; //末节点 + double gmin; //最小值 + double gmax; //最大值 + double g; //值，用于cos的值 + struct opf_gij_struct * next; +} opf_gij; + +//定义 有载调压变压器、可调电容（电抗）器，串联可调线路电抗器，可调移相器 的结构体，说明根据不同的需要取值 +typedef struct opf_kij_struct +{ int i; //首节点 + int j; //末节点 + double amp; //(变压器)支路导纳的幅值 amplitude + double rad; //(变压器)支路导纳的相角 angle + double up; //变比上限 + double down; //变比下限 + double k; //当前k值 + double k0; //new，第一次迭代值 + int t; //new 变压器档位，注意是原档位的抽头个数，不是倒数的，要注意还原成原来的再算哦//可投档位数 + double k1; //new，小值 + double k2; //new，大值 + double b; //当前B值(移相器) or t0(可调电容/电抗器原有调节量) new + double bup; //移相器B值上限 + double bdown; //移相器B值下限 + int flag; //计算标志，=0计算，=1不计算 + double w; //权重 new + double p; //首端有功功率 + double q; //首端无功功率 + struct opf_kij_struct * next; +} opf_kij; + +//定义 线路的参数 的结构体 lij，用于传递数据 +typedef struct opf_line_struct +{ int i; //首节点i + int j; //末节点j + double amp; //Yij，幅值 amplitude + double rad; //aij，相角 angle + double bb; //首节点i的bb(b/2) + double bbj; //末节点j的bb(b/2) + + double p; //线路有功功率 + double q; //线路无功功率 + double i2; //线路电流的平方 + double s2; //线路容量的平方 + + struct opf_line_struct * next; +} opf_line; + +//定义 变压器或移相器的结构体，用于传递数据的 +typedef struct opf_trans_struct +{ int i; //首节点 + int j; //尾节点 + double r; //变压器支路的电阻 + double x; //变压器支路的电抗 + double k; //变压器支路的变比 + double b; //移相器的相角，变压器是没有的 + struct opf_trans_struct *next; +} opf_trans; + +//定义 接地支路的结构体，用于传递数据的 +typedef struct opf_y0_struct +{ int i; //节点号 + double g; //电导 + double b; //电纳 + struct opf_y0_struct *next; +} opf_y0; + +//定义 功率负荷的结构体，用于传递数据的 +typedef struct opf_power_struct +{ int i; //节点号 + double pg; //有功出力 + double qg; //无功出力 + double pd; //有功负荷 + double qd; //无功负荷 + struct opf_power_struct *next; +} opf_power; + +//定义 功率负荷的结构体，用于传递数据的 +typedef struct opf_limit_p_struct +{ int i; + double pmin; //整体的最小出力 + double pmax; //整体的最大出力 + double fa01; //煤耗常数系数 + double fa11; //煤耗一次系数 + double fa21; //煤耗二次系数 + double fa31; //指数部分的系数 + double fa41; //指数部分的指数 + double pmin1; //第一段的最小出力 + double pmax1; //第一段的最大出力 + double fa02; //第二段 + double fa12; + double fa22; + double fa32; //指数部分的 + double fa42; + double pmin2; + double pmax2; + double fa03; //第三段 + double fa13; + double fa23; + double fa33; //指数部分的 + double fa43; + double pmin3; + double pmax3; + int k; //所在段 + int flag; //可控标志 + double w; //权重（新加）weight + double p0; //当前值 + struct opf_limit_p_struct *next; +} opf_limit_p; + +//定义 无功限制的结构体 +typedef struct opf_limit_q_struct +{ int i; + double qmin; //最小值 + double qmax; //最大值 + int flag; //可控标志对应电压 + double w; //权重（新加）weight + struct opf_limit_q_struct *next; +} opf_limit_q; + +//定义 电压限制的结构体 +typedef struct opf_limit_v_struct +{ int i; + double v0; //电压初值 + double vmin; //最小值 + double vmax; //最大值 + double w; //权重（新加）weight + struct opf_limit_v_struct *next; +} opf_limit_v; + +//定义 平衡点信息的结构体 +typedef struct opf_slack_struct +{ int i; //节点号 + double v; //电压值 + struct opf_slack_struct * next; +} opf_slack; + +//定义 负荷模型的结构体 +typedef struct opf_limit_vpdqd_struct +{ int i; + double min; //出力最小值 + double max; //出力最大值 + double a; //二次系数 + double b; //一次系数 + double c; //常数系数 + int flag; //可控标志 + double w; //权重（新加）weight + struct opf_limit_vpdqd_struct *next; +} opf_vpdqd; + +//定义 发电机功率园图模型的结构体 +typedef struct opf_limit_gpcd_struct +{ int i; + double sn; //发电机额定容量 + double rad; //发电机额定因数角 + double xd; //发电机额定电抗 + double qo; //无励磁运行时的无功功率 + int flag; //可控标志 + struct opf_limit_gpcd_struct *next; +} opf_gpcd; + +//定义 断面节点数据的结构体 +typedef struct opf_sij_struct +{ int num; //断面序号，要严格按照顺序排 + int i; //首节点号 + int j; //末节点号 + double w; //权重 + struct opf_sij_struct * next; +} opf_sij; + +//定义 直流节点数据的结构体 +typedef struct opf_dcbus_struct +{ int i; //节点号 + int iac; //对应的交流节点 + int flag; //整流或逆变器标记，整流器0，逆变器1 + int control_flag; //功率控制标志，当选为R时，采用整流侧定功率，定电压，定触发角控制，逆变侧定熄弧角控制。 + //当选为I时, 这时候变成逆变侧定功率，定熄弧角控制，整流侧采用定电压，定触发角控制。R=0，I=1。 + double vmax; //直流电压上限 + double vmin; //直流电压下限 + double imax; //直流电流上限 + double imin; //直流电流下限 + double amax; //直流功率因数上限 + double amin; //直流功率因数下限 + double pmax; //换流器功率上限 + double pmin; //换流器功率下限 + double kmax; //换流器变压器抽头上限 + double kmin; //换流器变压器抽头下限 + double bmax; //换流器触发角或熄弧角上限 + double bmin; //换流器触发角或熄弧角下限 + double r; //换流器换相电阻 + double kr; //换相重叠而引入的系数，取0.995 + struct opf_dcbus_struct * next; +} opf_dcbus; + +//定义 出错信息的结构体 +typedef struct opf_errorword +{ char str[200]; //200字节以内，英文 + struct opf_errorword * next; +}opf_error; + +//定义 调试信息的结构体 +typedef struct opf_debug_information +{ int i; //迭代次数 + int j; //迭代次数 + double x; //记录值 1 + double y; //记录值 2 + struct opf_debug_information * next; +} opf_debug; + +//定义 等变压器分接头的结构体 +typedef struct opf_equalitykij_struct +{ int ai; //受端节点号 + int aj; //受端节点号 + int fi; //供端节点号 + int fj; //供端节点号 + int i; //受端顺序号 + int j; //供端顺序号 + struct opf_equalitykij_struct * next; +} opf_equalitykij; + +//定义 系统信息结构体 +typedef struct opf_common_struct +{ + int n_sum; //系统节点数，单变量 mm(交流) + int n_dc; //直流系统节点数 + + int rpg; //可调有功出力节点个数， + int rqg; //可调无功出力节点个数， + int rpd; //可调有功负荷节点个数， + int rqd; //可调无功负荷节点个数， + + int rpge; //最小化潮流的有功偏差量控制 + int rqge; //最小化潮流的无功偏差量控制 + int mini_pf_flag; //最小化潮流控制标志,=1采用；=0不采用 + + double mini_pf_w; //最小化潮流控制权重 + + int rp; //可调有功出力+负荷节点个数+最小化潮流的有功偏差量 + int rq; //可调无功出力+负荷节点个数+最小化潮流的无功偏差量 + + int rv; //可调电压节点个数 + int rk; //可调变压器的个数 + int rkb; //可调移相器的个数 + int rt; //可调电容（电抗）器的个数 + int rx; //可调线路串联电抗的个数 + int rr; //rr=rp+rq+rv+rk+2*rkb+rt+rx+2rlcos+rvdcos+5*n_dc，变量数 + + int req; //req=2rlcos+rvdcos+3*n_dc+reqkij,除了功率方程以外的方程（等式约束） + + int rlpij; //支路有功容量限制 + int rlqij; //支路无功容量限制 + int rlsij; //支路容量限制（按平方计算） + int rliij; //支路电流限制（按平方计算） + int rlcos; //联络线功率因数限制（要转化成Pij Qij） + int rvpd; //有功负荷模型限制个数 + int rvqd; //无功负荷模型限制个数 + int rvdcos; //负荷模型功率因数限制个数 + int rgpcd; //发电机功率园图限制集合个数 + int rspij; //断面有功容量限制 + int rsqij; //断面无功容量限制 + int rrr; //rrr=rlpij+rlqij+rlsij+rliij+rvpd+rvqd+rgpcd+rspij+rsqij，表达式不等式约束 + + int reqkij; //等可调变压器集合 + + int obj_type; //目标函数的类型 + + int obj_type0; //目标函数的类型(原始的) + int obj_type_cflag; //是否采用目标函数控制方式，=0不用，=1用 + + int itera_max; //最大迭代次数(用户指定) + int itera_num; //迭代次数 + int itera_num_cic; //迭代次数 + + int slack_flag; //=1将平衡点电压不参加迭代，否则做为一般点参加迭代 + int overflow_flag; //溢出标志，=0，没有溢出，>0溢出；是在LDL分解的时候检测的 + int gap_flag; //后一次的gap大于前一次的gap，gapbz=gapbz+1 + + double fin_obj; //最终目标值finmbz + double ini_obj; //原始目标值ysmbz + double e; //要求的误差，用户要求 + + double steppfactor;//原始变量的步长因子，一般=0.9995 + double stepdfactor;//对偶变量的步长因子，一般=0.9995 + double centerparameter; //中心参数，一般=0.1 + double vmin; //整体电压最小值 + double vmax; //整体电压最大值 + int inizlwu; //互补间隙的选择方式，=0平启动，=1按对偶启动 + int bpacl; //是否用BPA的步长策略，=0不用，=1用 + int qv_slackflag; //是否对无功进行松驰，=0不用，=1用 + int v_slackflag; //是否对电压进行松驰，=0不用，=1用 + int ev_slackflag; //是否对等电压限制进行松驰，=0不用，=1用 + int lineq_slackflag; //是否对变压器支路限制进行松驰，=0不用，=1用 + int qnum_slackflag; //是否对无功源数量进行松驰，=0不用，=1用 + + int cc_flag; //互补约束的处理方式，=0连续化最优潮流，=1连续归整处理 + + double *varx; //原始变量 + double *vary; //对偶变量 + double *varl; //松弛变量 + double *varu; //松弛变量 + double *varw; //松弛变量 + double *varz; //松弛变量 + + double *v; //电压 + double *rad; //相角 + double *pg; //节点的有功出力 + double *qg; //节点的无功出力 + double *pd; //节点的有功负荷 + double *qd; //节点的有功负荷 + + double *pg_int; //归整后的节点有功出力 + + double qvmax; //无功松驰量 + double qvmin; //无功松驰量 + int qv_flag; //无功回复标志 + int v_flag; //电压回复标志 + int lineq_flag; //变压器支路回复标志 + + double *fa0; //数组 + double *fa1; //数组 + double *fa2; //煤耗系数fa0+fa1x+fa2x*x，数组 + double *fa3; //指数部分的系数 + double *fa4; //指数部分的指数 + + double ininetloss,endnetloss; //初始网损，结果网损 + + int * opt_list; //优化编号，数组 jdbh + +//网络参数 + opf_gij *head_lpij; //联络线有功功率限制 + opf_gij *head_lqij; //联络线无功功率限制 + opf_gij *head_lsij; //联络线容量限制（按平方计算） + opf_gij *head_liij; //联络线电流限制（按平方计算） + opf_gij *head_lcos; //联络线功率因数限制 + opf_gij *head_liij0; //联络线电流限制（按平方计算）,纯记录用的 + + opf_sij *head_sij; //断面线路节点 + opf_gij *head_spij; //断面有功功率限制 + opf_gij *head_sqij; //断面无功功率限制 + opf_sij *head_obsij; //目标函数断面线路节点 + + opf_kij *head_kij; //有载调压变压器 + opf_kij *head_kbij; //可调移相器 + opf_kij *head_ti; //可调电容器 + opf_kij *head_kx; //可调线路串联电抗 + opf_line *head_lij; //线路集合(交流) + opf_trans *head_trans; //变压器集合 headbyq + opf_trans *head_transb;//移相器集合 headbyq + opf_y0 *head_y0; //接地支路集合headjdzl + opf_power *head_power; //功率负荷集合 headglfh + opf_limit_p *head_pg; //有功限制集合 headygxz + opf_limit_p *head_pd; //有功负荷限制集合 + opf_limit_q *head_qg; //无功限制集合 headwgxz + opf_limit_q *head_qd; //无功负荷限制集合 + opf_limit_v *head_v; //电压限制集合headdyxz + opf_slack *head_slack; //平衡点集合headphd + + opf_vpdqd *head_vpd; //有功负荷模型（电压）限制集合 + opf_vpdqd *head_vqd; //无功负荷模型（电压）限制集合 + opf_gij *head_vdcos; //负荷模型功率因数限制 + + opf_gpcd *head_gpcd; //发电机功率园图限制集合 + + opf_line *head_dclij; //线路集合(直流) + opf_dcbus *head_dcbus; //直流节点信息集合 + + opf_equalitykij *head_eqkij; //等变压器集合 + + opf_error *head_error; //错误信息列表 + opf_debug *head_debuggap; //收敛消息 + opf_debug *head_debugpq; //最大不平衡量信息(功率方程) + opf_debug *head_debuglcos; //最大不平衡量信息(等式约束线路cos) + + +//节点导纳矩阵数据格式 + double *g; //节点导纳矩阵的对角元素的幅值，数组 + double *b; //节点导纳矩阵的对角元素的相角，数组 + opf_yij **a; //节点导纳矩阵非对角线元素，指针数组 + +//不等式约束格式 + int *gp; //可调有功节点排列，数组，按实际量开数组大小gp rpg+rpd,先排G再排D + int *gq; //可调无功节点排列，数组，按实际量开数组大小gq rqg+rqd,先排G再排D + int *gv; //可调电压节点排列，数组，按实际量开数组大小 + double *gmin; //不等式约束的下限 + double *gmax; //不等式约束的上限 + double *gvalue; //不等式约束的值 gzh + +//电压信息 + double *v0; //节点电压的初值 + double *wv; //节点电压的权重 + double *wpg; //有功出力的权重 + double *wqg; //无功出力的权重 + double *wpd; //有功负荷的权重 + double *wqd; //无功负荷的权重 + +} opf_common; + +//定义 修正矩阵格式的结构体 +typedef struct opf_correct_matrix_struct +{ double *d; //海森矩阵稀疏表的对角元素 + opf_matrix **jcb; //分别为雅可比矩阵稀疏表 + opf_matrix ** heisen; //分别为海森矩阵稀疏表 + opf_matrix **dg; //g的一阶导数稀疏表 +} opf_correct; + +//定义 解方程所用的数据格式的结构体 +typedef struct opf_decompose_struct //数组，按实际量开数组大小 +{ int *lj; + int *ljs; + int *li; + int *lis; + int *jtoi; + double *la; +} opf_decomp; + +typedef struct opf_senobjout_struct //目标函数的灵敏度输出结构体 +{ + int var_i; //变量的节点号 + int var_j; //变量的节点号 +// char VarBusName[50]; //我不用的，没法对应，后面你要走一遍，重新校核过 +// doulbe VarBaseVoltage; //我不用的，没法对应 + int vartype; //变量的类型，要统一协调 + double value; //值 + int iternum; //迭代的次数 + struct opf_senobjout_struct *next; +} opf_senobj; + +typedef struct opf_senequout_struct //等式约束的灵敏度输出结构体 +{ + int var_i; //变量的节点号 + int var_j; //变量的节点号 + + int equ_i; //等式约束的节点号 + int equ_j ; //等式约束的节点号 + +// char VarBusName1[50]; +// doulbe VarBaseVoltage1; +// char VarBusName2[50]; +// double VarBaseVoltage2; +// char Lid[2]; + + int vartype; //变量的类型，要统一协调 + int equtype; //等式约束的类型，要统一协调 + double value; + + int iternum; //迭代的次数 + struct opf_senequout_struct *next; +} opf_senequ; + +typedef struct opf_seninequout_struct //不等式约束的灵敏度输出结构体 +{ + int var_i; //变量的节点号 + int var_j; //变量的节点号 + int inequ_i; //不等式约束的节点号 + int inequ_j; //不等式约束的节点号 + +// char VarBusName1[50]; +// double VarBaseVoltage1; +// char VarBusName2[50]; +// double VarBaseVoltage2; +// char VarLid[2]; + + int vartype; //变量的类型，要统一协调 + int inequtype; //不等式约束的类型，要统一协调 + +// char InequBusName1[50]; +// double InequBaseVoltage1; +// char InequBusName2[50]; +// double InequBaseVoltage2; +// char InequLid2[2]; + double value; + + int iternum; //迭代的次数 + struct opf_seninequout_struct *next; +} opf_seninequ; + +typedef struct opf_sensitive_struct +{ int num; //初始值为0，灵敏度输出一次，最大只能为1 + opf_senobj *senobj; //目标函数灵敏度指针 + opf_senequ *senequ; //等式约束灵敏度指针 + opf_seninequ *seninequ; //不等式约束灵敏度指针 +} opf_sensitive; + + +//定义各结构体的长度 +#define leyij sizeof(opf_yij) //len +#define lematrix sizeof(opf_matrix) //lem +#define legij sizeof(opf_gij) //lepij +#define lekij sizeof(opf_kij) //lekij +#define leline sizeof(opf_line) //lelij +#define letrans sizeof(opf_trans) //lebyq +#define ley0 sizeof(opf_y0) //lejdzl +#define lepower sizeof(opf_power) //leglfh +#define lelimitp sizeof(opf_limit_p) //leygxz +#define lelimitq sizeof(opf_limit_q) //lewgxz +#define lelimitv sizeof(opf_limit_v) //ledyxz +#define leslack sizeof(opf_slack) //lephdimfor +#define levpdqd sizeof(opf_vpdqd) +#define legpcd sizeof(opf_gpcd) +#define lesij sizeof(opf_sij) +#define ledcbus sizeof(opf_dcbus) + +#define leerror sizeof(opf_error) +#define ledebug sizeof(opf_debug) + +#define lecommon sizeof(opf_common) +#define lecorrect sizeof(opf_correct) +#define ledecompose sizeof(opf_decomp) + +#define lesenobj sizeof(opf_senobj) +#define lesenequ sizeof(opf_senequ) +#define leseninequ sizeof(opf_seninequ) +#define lesensitive sizeof(opf_sensitive) + +#define leequalitykij sizeof(opf_equalitykij) + +#define null 0 +#define CPUTIME ((double) (clock ( )) / CLOCKS_PER_SEC*1000) + +/*****函数声明******/ +int InputData(char *,opf_common *); //从filename读数据 +int InitializeVarCommon(opf_common *); //计算应开数组的大小,初始化结构 +int Initialization(opf_common *); //形成节点导纳矩阵和其他相关元素 +void InitializeVarCorrect(opf_common *,opf_correct *);//开变量correct相应的内存空间 +int JudgeData(opf_common *); //对原始数据进行初步判断 + +void InitializeVarSensitive(opf_sensitive *);//开相应的内存空间 + +void Tinney_1(opf_common *); //节点优化编号Tinney_1 +void RevertList(opf_common *,opf_sensitive *); //节点优化编号Tinney_1的号码返回原来的值 + +opf_yij *insert1(opf_yij *,opf_yij *, int*); //节点导纳插入函数 +opf_matrix *insert2(opf_matrix *tp,opf_matrix *z,int *k); //矩阵插入函数 +int GiveValue(int **,int ,int ,int *); //动态扩大数组 + +void JcbMatrix(opf_common *,opf_correct *); //形成雅可比矩阵稀疏表（竖着排） +void HeisenMatrix(opf_common *,opf_correct *); //形成海森矩阵稀疏表（竖着排） +void DgMatrix(opf_common *,opf_correct *); //形成g的一阶偏导矩阵的固定部分和编号（竖着排） + +void SymbolDecompose(opf_decomp *,opf_correct *,int ); //符号分解 +void LDL(opf_common *,opf_decomp *,double *,double *); //LDL分解求修正方程 + +double ObjectiveValue(opf_common *); //计算目标值 + +int Iterative(opf_common *,opf_correct *,opf_decomp *); //迭代函数，=0收敛；=1不收敛但不发散；=2不收敛同时发散；=3收敛过程中出现问题 +int Iterative_cic(opf_common *,opf_correct *,opf_decomp *,int ); //连续化后进行归整，再进行第二次连续化迭代 + +void IterativeInivar(opf_common *,opf_correct *); //迭代过程中的变量初始化 +void JcbData(opf_common *,opf_correct *); //形成雅可比矩阵 +void DgData(opf_common *com,opf_correct *cor); //形成g的一阶偏导矩阵（可变部分） +void HeisenData(opf_common *com,opf_correct *cor,opf_decomp *dec); //形成海森矩阵 +void CalHImbalance(opf_common *,opf_correct *,double,double *); //计算海森部分的不平衡量,用derh返回 +void CalDpDq(opf_common *,opf_correct *,double *); //计算各节点功率不平衡量 + +void CorrectVarPD(opf_common *,opf_correct *r,double,double *); //修正原始对偶变量 +void CorrectYij(opf_common *); //修正节点导纳矩阵 + +opf_error * AddErrorWord(opf_error *,opf_error *); //添加error语句，headerror指明是哪个头指针 +void CheckLimit(opf_common *); //检测变量越限情况，|z|>1越下限；|w|>1越上限 + +void PrintResult(char *,opf_common *,int,int,int); //将结果打印到Text1上 +void PrintResultData(char *,opf_common *,int,int,int); //将结果打印到result.txt上 + +void DeleteVarCommon(opf_common *); //清common内存 +void DeleteVarCorrect(opf_common *,opf_correct *); //清correct内存 +void DeleteVarDecomp(opf_decomp *); //清decomp内存 +void DeleteVarsensitive(opf_sensitive *); //清sensitive内存 + +void Heisen_H2Y(opf_common *,opf_correct *,opf_decomp *); //形成修正方程的H2Y +void Heisen_F2(opf_common *,opf_correct *,opf_decomp *); //形成修正方程的-f2(部分) +void Heisen_G2(opf_common *,opf_correct *,opf_decomp *); //形成修正方程的G2(Z+W) +void Heisen_detG(opf_common *,opf_correct *,opf_decomp *); //形成修正方程的detG*(UW-ZL)*detG +void Heisen_J(opf_common *,opf_correct *,opf_decomp *); //形成修正方程的雅可比矩阵部分 + +void CalPgCoefficient(opf_common *,double ); //计算并确定发电费用曲线 +void CalResult(opf_common *,opf_correct *); //计算最后结果 + +void printTinney(opf_common *); + +void outputsensitive(opf_common *,opf_correct *,opf_sensitive *); //灵敏度输出 + +int CalGvalue(opf_common *,opf_correct *); //计算不等式约束的情况以及满足检测 +void CalTap(opf_common *); //修正变压器分接头 +double CalNetLoss(opf_common *); //计算网络损耗 +void CalIntPG(opf_common *); //机组出力归整 + +/******主函数******/ +/** +*作者：李滨 +*编写时间：2008－5 +*修改时间： +*功能：主函数入口 +*/ + +//20110506改了接口的电压和功率数据，加了结果输出 +int main() +{ + int i,t; + + int begintime,endtime,jstime; //开始时间、结束时间、计算时间 + int time1,time2,timejl[10]; + + opf_common *var_common; //系统变量 + opf_correct *var_correct; //修正变量 + opf_decomp *var_decomp; //解方程变量 + opf_sensitive *var_sensitive; //输出灵敏度变量 + + begintime = CPUTIME; + + var_common=(opf_common *)malloc(lecommon); //给固定变量开空间 + var_correct=(opf_correct *)malloc(lecorrect); + var_decomp=(opf_decomp *)malloc(ledecompose); + var_sensitive=(opf_sensitive *)malloc(lesensitive); + + var_common->itera_num=0; + var_common->itera_num_cic=0; + + var_common->ininetloss=0; + var_common->endnetloss=0; //初始网损，结果网损 + + var_common->qnum_slackflag=0; //是否对无功源数量进行松驰，=0不用，=1用(大系统用) + +// i=InputData("西北交直流正确编号2-1.txt",var_common); + + i=InputData("111.txt",var_common); + + var_common->mini_pf_flag=1; //最小化潮流控制标志,=1采用；=0不采用 + if((var_common->obj_type>0)&&(var_common->obj_type<=16)) + var_common->mini_pf_w=var_common->n_sum*10; //最小化潮流控制权重 + else + var_common->mini_pf_w=1; + + time2=CPUTIME; + timejl[0]=time2-begintime; + + i=InitializeVarCommon(var_common); //计算应开数组的大小,初始化结构 + Tinney_1(var_common); //节点优化编号Tinney_1 + + var_common->vmin=0.9; //整体电压最小值 + var_common->vmax=1.1; //整体电压最大值 + var_common->inizlwu=0; //互补间隙的选择方式，=0平启动，=1按对偶启动 + var_common->slack_flag=0; //平衡点,=1平衡点将不参加迭代，否则做为一般点参加迭代。 + + var_common->steppfactor=0.9995;//原始变量的步长因子，一般=0.9995 + var_common->stepdfactor=0.9995;//对偶变量的步长因子，一般=0.9995 + var_common->centerparameter=0.1; //中心参数，一般=0.1 + var_common->bpacl=0; //是否用BPA的步长策略，=0不用，=1用 + var_common->qv_slackflag=0; //是否对无功进行松驰，=0不用，=1用(大系统用) + var_common->v_slackflag=0; //是否对电压进行松驰，=0不用，=1用(大系统用) + var_common->ev_slackflag=0; //是否对等电压进行松驰，=0不用，=1用(大系统用) + var_common->lineq_slackflag=0; //是否对变压器支路限制进行松驰，=0不用，=1用(大系统用) + + var_common->cc_flag=0; //互补约束的处理方式，=0连续化最优潮流，=1连续归整处理 + + var_common->qvmax=10; //无功松驰量 + var_common->qvmin=10; //无功松驰量 + var_common->qv_flag=0; //无功回复标志 + var_common->v_flag=0; //电压回复标志 + var_common->lineq_flag=0; //电压回复标志 + + var_common->obj_type0=var_common->obj_type; //目标函数的类型(原始的) + var_common->obj_type_cflag=0; //是否采用目标函数控制方式，=0不用，=1用 + +/* + if(var_common->obj_type==0) + { var_common->cc_flag=0; //互补约束的处理方式，=0连续化最优潮流，=1连续归整处理 + var_common->qv_slackflag=1; //是否对无功进行松驰，=0不用，=1用(大系统用) + var_common->v_slackflag=0; //是否对电压进行松驰，=0不用，=1用(大系统用) + var_common->slack_flag=0; //平衡点,=1平衡点将不参加迭代，否则做为一般点参加迭代。 + var_common->ev_slackflag=1; //是否对等电压进行松驰，=0不用，=1用(大系统用) + + var_common->obj_type_cflag=1; //是否采用目标函数控制方式，=0不用，=1用 + }*/ + + + + if(var_common->obj_type==100) + { var_common->cc_flag=0; //互补约束的处理方式，=0连续化最优潮流，=1连续归整处理 + var_common->qv_slackflag=1; //是否对无功进行松驰，=0不用，=1用(大系统用) + var_common->v_slackflag=1; //是否对电压进行松驰，=0不用，=1用(大系统用) + var_common->slack_flag=0; //平衡点,=1平衡点将不参加迭代，否则做为一般点参加迭代。 + var_common->ev_slackflag=0; //是否对等电压进行松驰，=0不用，=1用(大系统用) + var_common->mini_pf_w=1; //最小化潮流控制权重 + } + +// printTinney(var_common); + + i=Initialization(var_common); //返回值=0，表示正常，=1有error，不计算 + + i=JudgeData(var_common); //对原始数据进行初步判断 + + if(i!=0) + { t=3; + PrintResult("Text1.txt",var_common,t,0,0); //将结果打印到Text1上 ,t是收敛情况 + DeleteVarCommon(var_common); //清common内存 + free(var_common); + return 3; + } + + InitializeVarCorrect(var_common,var_correct);//开相应的内存空间 + + InitializeVarSensitive(var_sensitive);//开相应的内存空间 + + var_common->ini_obj=ObjectiveValue(var_common); //计算原始目标值（只计交流部分） + var_common->ininetloss=CalNetLoss(var_common); //计算原始网损值 + + var_common->overflow_flag=0; //溢出标志，=0，没有溢出，>0溢出 + + time1=CPUTIME; + timejl[1]=time1-time2; + + + JcbMatrix(var_common,var_correct); //形成雅可比矩阵稀疏表（竖着排） + DgMatrix(var_common,var_correct); //形成g的一阶偏导矩阵的固定部分和编号（竖着排） + HeisenMatrix(var_common,var_correct); //形成海森矩阵稀疏表（竖着排） + + +/* FILE *fp1; + opf_matrix *p3; + fp1=fopen("Text3.txt","wb"); + for(i=1;i<=var_common->rr-var_common->rv+4*var_common->n_sum+var_common->rlcos;i++) + { p3=var_correct->heisen[i]; + while(p3!=null) + { fprintf(fp1," %d, %d, %f\n" ,p3->irow,p3->jcol,p3->z); + p3=p3->next; + } + } + fclose(fp1);*/ + + time2=CPUTIME; + timejl[2]=time2-time1; + + i=var_common->rr-var_common->rv+4*var_common->n_sum+var_common->req; + SymbolDecompose(var_decomp,var_correct,i); //符号分解 + + time1=CPUTIME; + timejl[3]=time1-time2; + +/* + FILE *fp1; + fp1=fopen("Text3.txt","wb"); + j=var_common->rr-var_common->rv+4*var_common->n_sum; + for(i=1;i<=var_decomp->lis[j+1];i++) + { fprintf(fp1," %d, %d, %d, %d, %f\n" ,i,var_decomp->li[i],var_decomp->lj[i],var_decomp->jtoi[i],var_decomp->la[i]); + } + fclose(fp1);*/ + +// x2= CPUTIME; +// jstime1[0]=x2-x1; + + +// gchtime=gchtime+1; //记录进行了1次迭代 + + t=Iterative(var_common,var_correct,var_decomp); //迭代函数，=0收敛；=1不收敛但不发散；=2不收敛同时发散；=3收敛过程中出现问题 + + time2=CPUTIME; + timejl[4]=time2-time1; + + var_common->fin_obj=ObjectiveValue(var_common); //最终原始目标值 + var_common->endnetloss=CalNetLoss(var_common); //计算最终网损值 + + CalIntPG(var_common); //机组出力归整 + +// outputsensitive(var_common,var_correct,var_sensitive); //灵敏度输出 + + RevertList(var_common,var_sensitive); //节点优化编号Tinney_1的号码返回原来的值 + +/* for(i=1;i<=sys_var->mm;i++) + { p[i]=0; + q[i]=0; + } + for(i=1;i<=sys_var->rp;i++) + p[inequation->gp[i]]=correct_var->varx[i]; + for(i=1;i<=sys_var->rq;i++) + q[inequation->gq[i]]=correct_var->varx[sys_var->rp+i];*/ + + + endtime = CPUTIME; + jstime=endtime-begintime; //计算时间 + + time1=CPUTIME; + timejl[5]=time1-time2; + +// CalResult(var_common,var_correct); //计算最后结果 + PrintResult("Text1.txt",var_common,t,jstime,1); //将结果打印到Text1上 ,t是收敛情况 + PrintResultData("Text4.txt",var_common,t,jstime,1); //将结果打印到result.txt上 + + timejl[6]=jstime; + + FILE *fp1; + fp1=fopen("Text3.txt","wb"); + for(i=0;i<=6;i++) + fprintf(fp1," %d\n" ,timejl[i]); + fclose(fp1); + + DeleteVarDecomp(var_decomp); //清decomp内存 + free(var_decomp); + + DeleteVarCorrect(var_common,var_correct); //清correct内存 + free(var_correct); + + DeleteVarsensitive(var_sensitive); //清sensitive内存 + free(var_sensitive); + + + DeleteVarCommon(var_common); //清common内存 + free(var_common); + + _CrtDumpMemoryLeaks(); //平时可以用，编译DLL的时候要注释 + + t=1; + + return t; + +} + +/******从Text文本中读数据******/ +int InputData(char *filename,opf_common * common) //从filename读数据 +{ + int i,j,m,k,n,t; + double r,x,bb,tmp,k0,ku,kd,b0,bu,bd,au,ad,r0,kr; + double fa01,fa11,fa21; + int i1,i2,i3,i4; + + opf_line *p1,*p2; + opf_trans *p3,*p4; + opf_kij *p5,*p6; + opf_y0 *p7,*p8; + opf_power *p9,*p10; + opf_limit_p *p11,*p12; + opf_limit_q *p13,*p14; + opf_limit_v *p15,*p16; + opf_gij *p17,*p18,*p30,*p31; + opf_slack *p20,*p21; + opf_vpdqd *p22,*p23; + opf_gpcd *p24,*p25; + opf_sij *p26,*p27; + opf_dcbus *p28,*p29; + + opf_equalitykij *p32,*p33; + + opf_error *p19; + + FILE *fp; + +//***先把变量中的头指针和部分变量清零 + common->head_lpij=null; + common->head_lqij=null; + common->head_lsij=null; + common->head_liij=null; + common->head_lcos=null; + + common->head_kij=null; + common->head_kbij=null; + common->head_ti=null; + common->head_kx=null; + common->head_lij=null; + common->head_trans=null; + common->head_transb=null; + common->head_y0=null; + common->head_power=null; + common->head_pg=null; + common->head_pd=null; + common->head_qg=null; + common->head_qd=null; + common->head_v=null; + common->head_slack=null; + + common->head_vpd=null; + common->head_vqd=null; + common->head_vdcos=null; + + common->head_gpcd=null; + + common->head_liij0=null; + + common->head_sij=null; + common->head_spij=null; + common->head_sqij=null; + common->head_obsij=null; + + common->head_dclij=null; //线路集合(直流) + common->head_dcbus=null; //直流节点信息集合 + + common->head_error=null; + common->head_debuggap=null; //收敛消息 + common->head_debugpq=null; //最大不平衡量信息(功率方程等式约束) + common->head_debuglcos=null; //最大不平衡量信息(线路功率因数方程等式约束) + common->head_eqkij=null; //等变压器集合 + + common->e=0; + common->itera_max=200; + + if((fp= fopen(filename, "rb"))==NULL) + { p19=(opf_error *)malloc(leerror); + sprintf(p19->str,"%s","error:sorry,this file can't be opened.Please examine it."); + p19->next=null; + common->head_error=AddErrorWord(p19,common->head_error); + return 0; + } + + fscanf(fp,"%d,%d,%lf,%lf,%d",&i,&n,&x,&bb,&k); //n表示支路数，x表示基准容量，不要 + common->n_sum=i; //节点总数,mm + common->e=bb; //收敛精度 + common->obj_type=k; //目标函数的类型mbhs + fscanf(fp,"%d",&m); + fscanf(fp,"%d",&m); + + common->head_slack=null; + k=1; + while(m!=0) + { fscanf(fp,",%d,%lf",&i,&x); //平衡节点部分 + p20=(opf_slack *)malloc(leslack); + p20->i=i; + p20->v=x; + p20->next=null; + if(k==1) + common->head_slack=p20; + else + p21->next=p20; + p21=p20; + k=k+1; + fscanf(fp,"%d",&m); + } + fscanf(fp,"%d",&m); + + k=1; + common->head_lij=null; + while(m!=0) //记录线路集合(原始的) + { + fscanf(fp,",%d,%d,%lf,%lf,%lf,%lf",&i,&j,&r,&x,&bb,&bu); //加个对地电容2008.10.15 +// fscanf(fp,",%d,%d,%lf,%lf,%lf,%lf",&i,&j,&r,&x,&bb); + p1=(opf_line *)malloc(leline); //线路部分 + p1->i=i; + p1->j=j; + p1->amp=r; //电阻 + p1->rad=x; //电抗 + p1->bb=bb; + p1->bbj=bu; //2008.10.20 +// p1->bbj=bb; + p1->next=null; + if(k==1) + common->head_lij=p1; + else + p2->next=p1; + p2=p1; + k=k+1; + fscanf(fp,"%d",&m); + } + fscanf(fp,"%d",&m); + + k=1; + t=1; + common->head_kij=null; + common->head_trans=null; + while(m!=0) //变压器集合 + { +// fscanf(fp,",%d,%d,%d,%lf,%lf,%lf,%lf,%lf",&n,&i,&j,&r,&x,&k0,&kd,&ku); + fscanf(fp,",%d,%d,%d,%lf,%lf,%lf,%lf,%lf,%d",&n,&i,&j,&r,&x,&k0,&kd,&ku,&i1); + p3=(opf_trans *)malloc(letrans); + p3->i=i; + p3->j=j; + p3->r=r; + p3->x=x; + p3->k=k0; + p3->next=null; + if(k==1) + common->head_trans=p3; + else + p4->next=p3; + p4=p3; + + if(n==1) //表示该变压器为可调变压器 + { p5=(opf_kij *)malloc(lekij); + p5->i=i; + p5->j=j; + p5->amp=r; //Yij' + p5->rad=x; + p5->k=k0; + p5->down=kd; + p5->up=ku; + p5->b=0; + p5->w=1; + p5->t=i1; //new +// p5->t=21; //new + p5->next=null; + if(t==1) + common->head_kij=p5; + else + p6->next=p5; + p6=p5; + t=t+1; + } + k=k+1; + fscanf(fp,"%d",&m); + } + fscanf(fp,"%d",&m); + + k=1; + t=1; + common->head_transb=null; + common->head_kbij=null; + while(m!=0) //移相器集合 + { fscanf(fp,",%d,%d,%d,%lf,%lf,%lf,%lf,%lf,%lf,%lf,%lf",&n,&i,&j,&r,&x,&k0,&kd,&ku,&b0,&bd,&bu); +// fscanf(fp,",%d,%d,%d,%lf,%lf,%lf,%lf,%lf,%lf,%lf,%lf",&n,&i,&j,&r,&x,&k0,&kd,&ku,&b0,&bd,&bu,&tmp); + p3=(opf_trans *)malloc(letrans); + p3->i=i; + p3->j=j; + p3->r=r; + p3->x=x; + p3->k=k0; + p3->b=b0; + p3->next=null; + if(k==1) + common->head_transb=p3; + else + p4->next=p3; + p4=p3; + + if(n==1) //表示该移相器为可调移相器 + { p5=(opf_kij *)malloc(lekij); + p5->i=i; + p5->j=j; + p5->amp=r; //Yij' + p5->rad=x; + p5->k=k0; + p5->down=kd; + p5->up=ku; + p5->b=b0; + p5->bdown=bd; + p5->bup=bu; + p5->w=1; + p5->t=21; //new 临时的p5->t=tmp; + p5->next=null; + if(t==1) + common->head_kbij=p5; + else + p6->next=p5; + p6=p5; + t=t+1; + } + k=k+1; + fscanf(fp,"%d",&m); + } + fscanf(fp,"%d",&m); + + + common->head_y0=null; //接地支路集合 + k=1; + while(m!=0) //接地支路部分 + { fscanf(fp,",%d,%lf,%lf",&i,&r,&x); + p7=(opf_y0 *)malloc(ley0); + p7->i=i; + p7->g=r; //电导 + p7->b=x; //电纳 + p7->next=null; + if(k==1) + common->head_y0=p7; + else + p8->next=p7; + p8=p7; + k=k+1; + fscanf(fp,"%d",&m); + } + fscanf(fp,"%d",&m); + + k=1; + common->head_ti=null; + while(m!=0) //可调电容器部分(要求该部分全是可调的) + { fscanf(fp,",%d,%d,%lf,%lf,%lf,%lf,%lf,%lf",&n,&i,&r,&x,&k0,&kd,&ku,&tmp); +// fscanf(fp,",%d,%d,%lf,%lf,%lf,%lf,%lf",&n,&i,&r,&x,&k0,&kd,&ku,&tmp); + fscanf(fp,"%d",&m); + if(n==1) //表示该电容器为可调电容器 + { p5=(opf_kij *)malloc(lekij); + p5->i=i; + p5->j=i; + p5->amp=r; //电阻 + p5->rad=x; + p5->k=k0; + p5->down=kd; + p5->up=ku; + p5->b=k0; //原有抽头 + p5->w=1; //权重 + p5->t=tmp; //new 临时的p5->t=21; + p5->next=null; + if(k==1) + common->head_ti=p5; + else + p6->next=p5; + p6=p5; + k=k+1; + } + } + fscanf(fp,"%d",&m); + + k=1; + common->head_kx=null; + while(m!=0) //可调线路电抗部分(要求该部分全是可调的,否则是不计的) + { fscanf(fp,",%d,%d,%d,%lf,%lf,%lf,%lf,%lf",&n,&i,&j,&r,&x,&k0,&kd,&ku); + fscanf(fp,"%d",&m); + if((n==1)&&(k0!=0)&&((r!=0)||(x!=0))) //表示可调线路电抗,并进行预处理 + { p5=(opf_kij *)malloc(lekij); + p5->i=i; + p5->j=j; + p5->amp=r; //电阻（当前调节量的） + p5->rad=x; //电抗（当前调节量的） + p5->k=k0; + p5->down=kd; + p5->up=ku; + p5->b=k0; //原有抽头 + p5->w=1; //权重 + p5->next=null; + if(k==1) + common->head_kx=p5; + else + p6->next=p5; + p6=p5; + k=k+1; + } + } + fscanf(fp,"%d",&m); + + + common->head_power=null; //功率负荷集合 + k=1; + while(m!=0) //功率负荷部分 + { + fscanf(fp,",%d,%d,%lf,%lf,%lf,%lf,%lf,%lf,%lf",&j,&i,&tmp,&r,&x,&bb,&k0,&kd,&ku);//kd节点电压幅值，ku节点电压相角 +// fscanf(fp,",%d,%d,%lf,%lf,%lf,%lf,%lf,%lf,%lf,%d",&j,&i,&tmp,&r,&x,&bb,&k0,&kd,&ku,&n);//kd节点电压幅值，ku节点电压相角 + p9=(opf_power *)malloc(lepower); + p9->i=i; + p9->pg=r; //有功发 + p9->qg=x; //无功发 + p9->pd=bb; //有功负 + p9->qd=k0; //无功负 + p9->next=null; + if(k==1) + common->head_power=p9; + else + p10->next=p9; + p10=p9; + k=k+1; + + fscanf(fp,"%d",&m); + } + + common->head_pg=null; //有功限制集合 + k=1; + fscanf(fp,"%d",&m); + while(m!=0) //有功功率和煤耗 + { +// fscanf(fp,",%d,%d,%lf,%lf,%lf,%lf,%lf,%lf,%lf,%lf,%lf,%lf,%lf,%lf,%lf,%lf,%lf,%lf,%lf,%lf,%lf,%lf,%lf,%lf,%lf",&n,&i,&r,&x,&fa01,&fa11,&fa21,&fa31,&fa41,&pmin1,&pmax1,&fa02,&fa12,&fa22,&fa32,&fa42,&pmin2,&pmax2,&fa03,&fa13,&fa23,&fa33,&fa43,&pmin3,&pmax3); + fscanf(fp,",%d,%d,%d,%lf,%lf,%lf,%lf,%lf,%lf",&n,&i,&j,&r,&x,&fa01,&fa11,&fa21,&tmp); + if(n==1) + { p11=(opf_limit_p *)malloc(lelimitp); + p11->i=i; + p11->pmin=r; +// p11->pmin=-100; + p11->pmax=x; + p11->fa01=fa01; + p11->fa11=fa11; + p11->fa21=fa21; + p11->fa31=0; + p11->fa41=0; + p11->p0=tmp; + +/* + p11->fa31=fa31; + p11->fa41=fa41; + p11->pmax1=pmax1; + p11->pmin1=pmin1; + p11->fa02=fa02; + p11->fa12=fa12; + p11->fa22=fa22; + p11->fa32=fa32; + p11->fa42=fa42; + p11->pmax2=pmax2; + p11->pmin2=pmin2; + p11->fa03=fa03; + p11->fa13=fa13; + p11->fa23=fa23; + p11->fa33=fa33; + p11->fa43=fa43; + p11->pmax3=pmax3; + p11->pmin3=pmin3;*/ + + p11->pmax1=x; + p11->pmin1=r; + p11->fa02=0; + p11->fa12=0; + p11->fa22=0; + p11->fa32=0; + p11->fa42=0; + p11->pmax2=0; + p11->pmin2=0; + p11->fa03=0; + p11->fa13=0; + p11->fa23=0; + p11->fa33=0; + p11->fa43=0; + p11->pmax3=0; + p11->pmin3=0; + + p11->flag=n; + p11->w=1; + p11->k=1; + p11->next=null; + if(k==1) + common->head_pg=p11; + else + p12->next=p11; + p12=p11; + k=k+1; + } + fscanf(fp,"%d",&m); + } + + common->head_pd=null; //有功负荷集合（线性） + k=1; + fscanf(fp,"%d",&m); + while(m!=0) //有功功率 + { fscanf(fp,",%d,%d,%lf,%lf",&n,&i,&r,&x); + if(n==1) + { p11=(opf_limit_p *)malloc(lelimitp); + p11->i=i; + p11->pmin=r; + p11->pmax=x; + p11->flag=n; + p11->w=1; + p11->next=null; + if(k==1) + common->head_pd=p11; + else + p12->next=p11; + p12=p11; + k=k+1; + } + fscanf(fp,"%d",&m); + } + + common->head_qg=null; //无功限制集合 + k=1; + fscanf(fp,"%d",&m); + while(m!=0) + { fscanf(fp,",%d,%d,%d,%lf,%lf,%lf",&n,&i,&j,&tmp,&r,&x); //tmp放的是电压定值 + if(n==1) + { p13=(opf_limit_q *)malloc(lelimitq); + p13->i=i; + p13->qmin=r; + p13->qmax=x; + p13->flag=n; + p13->w=1; + p13->next=null; + if(k==1) + common->head_qg=p13; + else + p14->next=p13; + p14=p13; + k=k+1; + } + fscanf(fp,"%d",&m); + } + + common->head_qd=null; //无功负荷集合（线性） + k=1; + fscanf(fp,"%d",&m); + while(m!=0) + { fscanf(fp,",%d,%d,%lf,%lf",&n,&i,&r,&x); + if(n==1) + { p13=(opf_limit_q *)malloc(lelimitq); + p13->i=i; + p13->qmin=r; + p13->qmax=x; + p13->flag=n; + p13->w=1; + p13->next=null; + if(k==1) + common->head_qd=p13; + else + p14->next=p13; + p14=p13; + k=k+1; + } + fscanf(fp,"%d",&m); + } + + common->head_v=null; //电压限制集合 + k=1; + fscanf(fp,"%d",&m); + while(m!=0) + { + fscanf(fp,",%d,%lf,%lf",&i,&r,&x); +// fscanf(fp,",%d,%lf,%lf,%lf",&i,&r,&x,&tmp); + p15=(opf_limit_v *)malloc(lelimitv); + p15->i=i; + p15->vmin=r; + p15->vmax=x; + p15->w=1; //电压的权重 + p15->v0=1; //电压的初值 + p15->next=null; + if(k==1) + common->head_v=p15; + else + p16->next=p15; + p16=p15; + k=k+1; + fscanf(fp,"%d",&m); + } + + k=1; //记录支路有功功率限制的个数 + common->head_lpij=null; + fscanf(fp,"%d",&m); + while(m!=0) + { fscanf(fp,",%d,%d,%d,%lf,%lf",&n,&i,&j,&r,&x); + if(n==1) + { p17=(opf_gij *)malloc(legij); + p17->i=i; + p17->j=j; + p17->gmin=r; +// p17->gmin=-x; + p17->gmax=x; + p17->g=0; //在程序里自己计算，不用在这里赋值 + p17->next=null; + if(k==1) + common->head_lpij=p17; + else + p18->next=p17; + p18=p17; + k=k+1; + } + fscanf(fp,"%d",&m); + } + + k=1; //记录支路无功功率限制的个数 + common->head_lqij=null; + fscanf(fp,"%d",&m); + while(m!=0) + { fscanf(fp,",%d,%d,%d,%lf,%lf",&n,&i,&j,&r,&x); + if(n==1) + { p17=(opf_gij *)malloc(legij); + p17->i=i; + p17->j=j; + p17->gmin=r; + p17->gmax=x; + p17->g=0; //在程序里自己计算，不用在这里赋值 + p17->next=null; + if(k==1) + common->head_lqij=p17; + else + p18->next=p17; + p18=p17; + k=k+1; + } + fscanf(fp,"%d",&m); + } + + k=1; //记录支路容量限制的个数 + common->head_lsij=null; + fscanf(fp,"%d",&m); + while(m!=0) + { fscanf(fp,",%d,%d,%d,%lf,%lf",&n,&i,&j,&r,&x); + if(n==1) + { p17=(opf_gij *)malloc(legij); + p17->i=i; + p17->j=j; + p17->gmin=r; + p17->gmax=x; + p17->g=0; //在程序里自己计算，不用在这里赋值 + p17->next=null; + if(k==1) + common->head_lsij=p17; + else + p18->next=p17; + p18=p17; + k=k+1; + } + fscanf(fp,"%d",&m); + } + + k=1; //记录支路电流限制的个数 + t=1; + common->head_liij=null; + common->head_liij0=null; + fscanf(fp,"%d",&m); + while(m!=0) + { fscanf(fp,",%d,%d,%d,%lf,%lf",&n,&i,&j,&r,&x); + if(n==1) + { p17=(opf_gij *)malloc(legij); + p17->i=i; + p17->j=j; + p17->gmin=r; + p17->gmax=x; + p17->g=0; //在程序里自己计算，不用在这里赋值 + p17->next=null; + if(k==1) + common->head_liij=p17; + else + p18->next=p17; + p18=p17; + k=k+1; + } + + p30=(opf_gij *)malloc(legij); + p30->i=i; + p30->j=j; + p30->gmin=r; + p30->gmax=x; + p30->g=0; //在程序里自己计算，不用在这里赋值 + p30->next=null; + if(t==1) + common->head_liij0=p30; + else + p31->next=p30; + p31=p30; + t=t+1; + + fscanf(fp,"%d",&m); + } + + k=1; //记录支路功率因数限制的个数 + common->head_lcos=null; + fscanf(fp,"%d",&m); + while(m!=0) + { fscanf(fp,",%d,%d,%d,%lf,%lf",&n,&i,&j,&r,&x); + if(n==1) + { p17=(opf_gij *)malloc(legij); + p17->i=i; + p17->j=j; + p17->gmin=r; + p17->gmax=x; + p17->g=0; //在程序里计算，在那里赋值 + p17->next=null; + if(k==1) + common->head_lcos=p17; + else + p18->next=p17; + p18=p17; + k=k+1; + } + fscanf(fp,"%d",&m); + } + + common->head_vpd=null; //有功负荷模型集合（电压型） + k=1; + fscanf(fp,"%d",&m); + while(m!=0) + { fscanf(fp,",%d,%d,%lf,%lf,%lf,%lf,%lf",&n,&i,&r,&x,&bb,&k0,&tmp); + if(n==1) + { p22=(opf_vpdqd *)malloc(levpdqd); + p22->i=i; + p22->min=r; + p22->max=x; + p22->a=tmp; + p22->b=k0; + p22->c=bb; + p22->flag=0; + p22->w=1; + p22->next=null; + if(k==1) + common->head_vpd=p22; + else + p23->next=p22; + p23=p22; + k=k+1; + } + fscanf(fp,"%d",&m); + } + + common->head_vqd=null; //无功负荷模型集合（电压型） + k=1; + fscanf(fp,"%d",&m); + while(m!=0) + { fscanf(fp,",%d,%d,%lf,%lf,%lf,%lf,%lf",&n,&i,&r,&x,&bb,&k0,&tmp); + if(n==1) + { p22=(opf_vpdqd *)malloc(levpdqd); + p22->i=i; + p22->min=r; + p22->max=x; + p22->a=tmp; + p22->b=k0; + p22->c=bb; + p22->flag=0; + p22->w=1; + p22->next=null; + if(k==1) + common->head_vqd=p22; + else + p23->next=p22; + p23=p22; + k=k+1; + } + fscanf(fp,"%d",&m); + } + + k=1; //记录负荷功率因数限制的个数 + common->head_vdcos=null; + fscanf(fp,"%d",&m); + while(m!=0) + { fscanf(fp,",%d,%d,%lf,%lf",&n,&j,&r,&x); + if(n==1) + { p17=(opf_gij *)malloc(legij); + p17->i=j; + p17->j=j; + p17->gmin=r; + p17->gmax=x; + p17->g=0; //在程序里计算，在那里赋值 + p17->next=null; + if(k==1) + common->head_vdcos=p17; + else + p18->next=p17; + p18=p17; + k=k+1; + } + fscanf(fp,"%d",&m); + } + + k=1; //断面线路节点 + common->head_sij=null; + fscanf(fp,"%d",&m); + while(m!=0) + { fscanf(fp,",%d,%d,%d,%d",&t,&n,&i,&j); + p26=(opf_sij *)malloc(lesij); + p26->num=t; + p26->i=i; + p26->j=j; + p26->w=0; + p26->next=null; + if(k==1) + common->head_sij=p26; + else + p27->next=p26; + p27=p26; + k=k+1; + fscanf(fp,"%d",&m); + } + + k=1; //目标函数断面线路节点 + common->head_obsij=null; + fscanf(fp,"%d",&m); + while(m!=0) + { fscanf(fp,",%d,%d,%d,%d",&t,&n,&i,&j); + p26=(opf_sij *)malloc(lesij); + p26->num=t; + p26->i=i; + p26->j=j; + p26->w=-1; //在接口的时候由用户输入 + p26->next=null; + if(k==1) + common->head_obsij=p26; + else + p27->next=p26; + p27=p26; + k=k+1; + fscanf(fp,"%d",&m); + } + + k=1; //断面有功功率限制 + common->head_spij=null; + fscanf(fp,"%d",&m); + while(m!=0) + { fscanf(fp,",%d,%d,%lf,%lf",&i,&n,&r,&x); + if(n==1) + { p17=(opf_gij *)malloc(legij); + p17->i=i; + p17->j=i; + p17->gmin=r; + p17->gmax=x; + p17->g=0; //在程序里自己计算，不用在这里赋值 + p17->next=null; + if(k==1) + common->head_spij=p17; + else + p18->next=p17; + p18=p17; + k=k+1; + } + fscanf(fp,"%d",&m); + } + + k=1; //断面无功功率限制 + common->head_sqij=null; + fscanf(fp,"%d",&m); + while(m!=0) + { fscanf(fp,",%d,%d,%lf,%lf",&i,&n,&r,&x); + if(n==1) + { p17=(opf_gij *)malloc(legij); + p17->i=i; + p17->j=i; + p17->gmin=r; + p17->gmax=x; + p17->g=0; //在程序里自己计算，不用在这里赋值 + p17->next=null; + if(k==1) + common->head_sqij=p17; + else + p18->next=p17; + p18=p17; + k=k+1; + } + fscanf(fp,"%d",&m); + } + + common->head_gpcd=null; //发电机功率圆图模型集合 + k=1; + fscanf(fp,"%d",&m); + while(m!=0) + { fscanf(fp,",%d,%d,%lf,%lf,%lf",&j,&i,&r,&x,&bb); + if(j==1) + { p25=(opf_gpcd *)malloc(legpcd); + p25->i=i; + p25->sn=r; + p25->rad=acos(x); + p25->xd=bb; + p25->flag=1; + p25->next=null; + if(k==1) + common->head_gpcd=p25; + else + p24->next=p25; + p24=p25; + k=k+1; + } + fscanf(fp,"%d",&m); + } + + k=1; + fscanf(fp,"%d",&m); + common->head_dclij=null; + while(m!=0) //记录直流线路集合 + { fscanf(fp,",%d,%d,%lf,%lf,%lf",&i,&j,&r); //直流线路部分 + p1=(opf_line *)malloc(leline); + p1->i=i; + p1->j=j; + p1->amp=1/r; //电阻 + p1->rad=0; + p1->bb=0; + p1->next=null; + if(k==1) + common->head_dclij=p1; + else + p2->next=p1; + p2=p1; + k=k+1; + fscanf(fp,"%d",&m); + } + fscanf(fp,"%d",&m); + + k=1; + fscanf(fp,"%d",&m); + common->head_dcbus=null; + while(m!=0) //记录直流节点集合 28,29 + { fscanf(fp,",%d,%d,%d,%d,%lf,%lf,%lf,%lf,%lf,%lf,%lf,%lf,%lf,%lf,%lf,%lf,%lf,%lf,%lf",&i,&j,&n,&t,&r,&x,&bb,&tmp,&k0,&b0,&ku,&kd,&bu,&bd,&au,&ad,&r0,&kr,&fa01); //直流线路部分 +// fscanf(fp,",%d,%d,%d,%d,%lf,%lf,%lf,%lf,%lf,%lf,%lf,%lf,%lf,%lf,%lf,%lf,%lf,%lf",&i,&j,&n,&t,&r,&x,&bb,&tmp,&k0,&b0,&ku,&kd,&bu,&bd,&au,&ad,&r0,&kr); + p28=(opf_dcbus *)malloc(ledcbus); + p28->i=i; + p28->iac=j; + p28->flag=n; //整流=0；逆变=1 + p28->control_flag=t; //新增变量，表示控制方式 R=0；I=1 + p28->vmax=r; + p28->vmin=x; + p28->imax=bb; + p28->imin=tmp; + p28->pmax=k0; + p28->pmin=b0; + p28->kmax=ku; + p28->kmin=kd; + p28->bmax=bu; + p28->bmin=bd; + p28->amax=au; + p28->amin=ad; + p28->r=r0; + p28->kr=kr; + p28->next=null; + if(k==1) + common->head_dcbus=p28; + else + p29->next=p28; + p29=p28; + k=k+1; + fscanf(fp,"%d",&m); + } + fscanf(fp,"%d",&m); + + k=1; + fscanf(fp,"%d",&m); + common->head_eqkij=null; + while(m!=0) //记录等变压器抽头集合 32,33 + { fscanf(fp,",%d,%d,%d,%d,%d",&n,&i1,&i2,&i3,&i4); //等变压器抽头集合 + if(n==1) + { p32=(opf_equalitykij *)malloc(leequalitykij); + p32->ai=i1; + p32->aj=i2; + p32->fi=i3; + p32->fj=i4; + p32->i=0; + p32->j=0; + p32->next=null; + if(k==1) + common->head_eqkij=p32; + else + p33->next=p32; + p33=p32; + k=k+1; + } + fscanf(fp,"%d",&m); + } + fscanf(fp,"%d",&m); + + fclose(fp); + + +/* + FILE *fp1; + fp1=fopen("Text2.txt","wb"); + for(i=1;i<=mm;i++) + fprintf(fp1," %d, %f, %f\n" ,i,g[i],b[i]); + fclose(fp1);*/ + return 1; + +} + +/******根据各链表里的数据计算应开数组的大小,初始化各结构体******/ +int InitializeVarCommon(opf_common *common) //计算应开数组的大小,初始化结构 +{ + int i,j; + + opf_kij *p11; + opf_limit_p *p7; + opf_limit_q *p8; + opf_gij *p10; + opf_vpdqd *p6; + opf_gpcd *p5; + opf_dcbus *p1; + opf_equalitykij *p2; + + common->rr=0; + common->rrr=0; + common->req=0; + + + j=1; + p7=common->head_pg; //统计可控有功出力约束的个数 + while(p7!=null) + { if(p7->flag==1) + j=j+1; + p7=p7->next; + } + common->rpg=j-1; + common->rr=common->rpg; + + if(common->mini_pf_flag==1) //采用最小化策略(有功) + common->rpge=common->n_sum; + else + common->rpge=0; + common->rr=common->rr+common->rpge; + + j=1; + p7=common->head_pd; //统计可控有功负荷的个数 + while(p7!=null) + { if(p7->flag==1) + j=j+1; + p7=p7->next; + } + common->rpd=j-1; + common->rr=common->rr+common->rpd; + + common->rp=common->rpg+common->rpd+common->rpge; //统计可控有功约束的个数 + + j=1; + p8=common->head_qg; //统计可控无功出力约束的个数 + while(p8!=null) + { if(p8->flag==1) + j=j+1; + p8=p8->next; + } + if(common->qnum_slackflag==1) + common->rqg=common->n_sum; + else + common->rqg=j-1; + common->rr=common->rr+common->rqg; + + if(common->mini_pf_flag==1) //采用最小化策略（无功） + common->rqge=common->n_sum; + else + common->rqge=0; + common->rr=common->rr+common->rqge; + + j=1; + p8=common->head_qd; //统计可控无功负荷约束的个数 + while(p8!=null) + { if(p8->flag==1) + j=j+1; + p8=p8->next; + } + common->rqd=j-1; + common->rr=common->rr+common->rqd; + + common->rq=common->rqg+common->rqd+common->rqge; //统计可控无功约束的个数 + + common->rk=1; + p11=common->head_kij; //统计可调变压器的个数(该链表里的可调变压器肯定都是可调的) + while(p11!=null) + { common->rk=common->rk+1; + p11=p11->next; + } + common->rk=common->rk-1; + common->rr=common->rr+common->rk; + + common->rkb=1; + p11=common->head_kbij; //统计移相器的个数(该链表里的移相器肯定都是可调的) + while(p11!=null) + { common->rkb=common->rkb+1; + p11=p11->next; + } + common->rkb=common->rkb-1; + common->rr=common->rr+2*common->rkb; + + common->rt=1; + p11=common->head_ti; //统计可调电容器的个数(该链表里的可调电容器肯定都是可调的) + while(p11!=null) + { common->rt=common->rt+1; + p11=p11->next; + } + common->rt=common->rt-1; + common->rr=common->rr+common->rt; + + common->rx=1; + p11=common->head_kx; //统计可调线路电抗的个数(该链表里的可调线路电抗肯定都是可调的) + while(p11!=null) + { common->rx=common->rx+1; + p11=p11->next; + } + common->rx=common->rx-1; + common->rr=common->rr+common->rx; + + common->rv=common->n_sum; //交流电压约束的个数 + common->rr=common->rr+common->rv; //记录不等约束的个数 + + common->rlpij=1; //统计支路有功功率限制的个数 + p10=common->head_lpij; + while(p10!=null) + { common->rlpij=common->rlpij+1; + p10=p10->next; + } + common->rlpij=common->rlpij-1; + + common->rlqij=1; //统计支路无功功率限制的个数 + p10=common->head_lqij; + while(p10!=null) + { common->rlqij=common->rlqij+1; + p10=p10->next; + } + common->rlqij=common->rlqij-1; + + common->rlsij=1; //统计支路容量限制的个数 + p10=common->head_lsij; + while(p10!=null) + { common->rlsij=common->rlsij+1; + p10=p10->next; + } + common->rlsij=common->rlsij-1; + + common->rliij=1; //统计支路电流限制的个数 + p10=common->head_liij; + while(p10!=null) + { common->rliij=common->rliij+1; + p10=p10->next; + } + common->rliij=common->rliij-1; + + common->rlcos=1; //统计支路功率因数限制的个数 + p10=common->head_lcos; + while(p10!=null) + { common->rlcos=common->rlcos+1; + p10=p10->next; + } + common->rlcos=common->rlcos-1; + common->rr=common->rr+2*common->rlcos;//Pij,Qij + common->req=common->req+2*common->rlcos;//Pij,Qij + + common->rvpd=1; //统计有功负荷模型的个数 + p6=common->head_vpd; + while(p6!=null) + { common->rvpd=common->rvpd+1; + p6=p6->next; + } + common->rvpd=common->rvpd-1; + + common->rvqd=1; //统计无功负荷模型的个数 + p6=common->head_vqd; + while(p6!=null) + { common->rvqd=common->rvqd+1; + p6=p6->next; + } + common->rvqd=common->rvqd-1; + + common->rvdcos=1; //统计负荷模型功率因数限制的个数 + p10=common->head_vdcos; + while(p10!=null) + { common->rvdcos=common->rvdcos+1; + p10=p10->next; + } + common->rvdcos=common->rvdcos-1; + common->rr=common->rr+common->rvdcos; + common->req=common->req+common->rvdcos; + + common->rspij=1; //统计断面有功功率限制的个数 + p10=common->head_spij; + while(p10!=null) + { common->rspij=common->rspij+1; + p10=p10->next; + } + common->rspij=common->rspij-1; + + common->rsqij=1; //统计断面无功功率限制的个数 + p10=common->head_sqij; + while(p10!=null) + { common->rsqij=common->rsqij+1; + p10=p10->next; + } + common->rsqij=common->rsqij-1; + + common->rgpcd=1; //统计发电机功率圆图限制的个数 + p5=common->head_gpcd; + while(p5!=null) + { common->rgpcd=common->rgpcd+1; + p5=p5->next; + } + common->rgpcd=common->rgpcd-1; + + common->n_dc=1; //统计直流节点的个数 + p1=common->head_dcbus; + while(p1!=null) + { common->n_dc=common->n_dc+1; + p1=p1->next; + } + common->n_dc=common->n_dc-1; + + common->reqkij=1; //统计等可调变压器分接头的个数 + p2=common->head_eqkij; + while(p2!=null) + { common->reqkij=common->reqkij+1; + p2=p2->next; + } + common->reqkij=common->reqkij-1; + +/******将直流数据加入统计量中******/ + common->rrr=common->rlpij+common->rlqij+common->rlsij+common->rliij+common->rvpd+common->rvqd + +common->rspij+common->rsqij+common->rgpcd; + + common->rr=common->rr+5*common->n_dc; + common->req=common->req+3*common->n_dc+common->reqkij; + common->rrr=common->rrr+common->n_dc; + + common->rrr=common->rrr+common->rlcos; //cosij + +//******开内存******var_common + i=common->rr-common->rv+2*common->n_sum; + common->varx=(double *)malloc((i+1)*sizeof(double)); + i=2*common->n_sum+common->req; + common->vary=(double *)malloc((i+1)*sizeof(double)); + i=common->rr+common->rrr; + common->varl=(double *)malloc((i+1)*sizeof(double)); + common->varu=(double *)malloc((i+1)*sizeof(double)); + common->varw=(double *)malloc((i+1)*sizeof(double)); + common->varz=(double *)malloc((i+1)*sizeof(double)); + + i=common->n_sum; + common->v=(double *)malloc((i+1)*sizeof(double)); + common->rad=(double *)malloc((i+1)*sizeof(double)); + common->pg=(double *)malloc((i+1)*sizeof(double)); + common->pd=(double *)malloc((i+1)*sizeof(double)); + common->qg=(double *)malloc((i+1)*sizeof(double)); + common->qd=(double *)malloc((i+1)*sizeof(double)); + + common->pg_int=(double *)malloc((i+1)*sizeof(double)); + + for(j=1;j<=i;j++) + { common->v[j]=1; + common->rad[j]=0; + } + + i=common->rpg; //煤耗参数 + common->fa0=(double *)malloc((i+1)*sizeof(double)); + common->fa1=(double *)malloc((i+1)*sizeof(double)); + common->fa2=(double *)malloc((i+1)*sizeof(double)); + common->fa3=(double *)malloc((i+1)*sizeof(double)); + common->fa4=(double *)malloc((i+1)*sizeof(double)); + + i=common->n_sum; //节点优化编号链表，只转换交流节点 + common->opt_list=(int *)malloc((i+1)*sizeof(int)); + + common->g=(double *)malloc((i+1)*sizeof(double)); + common->b=(double *)malloc((i+1)*sizeof(double)); + common->a=(opf_yij **)malloc((i+1)*sizeof(opf_yij *)); + + for(j=1;j<=i;j++) + common->a[j]=null; + + i=common->rp; //rp=rpg+rpd+rpge + common->gp=(int *)malloc((i+1)*sizeof(int)); //有功编号列表 + i=common->rq; //rq=rqg+rqd+rqge + common->gq=(int *)malloc((i+1)*sizeof(int)); //无功编号列表 + i=common->n_sum; + common->gv=(int *)malloc((i+1)*sizeof(int)); //电压编号列表 + i=common->rr+common->rrr; + common->gmax=(double *)malloc((i+1)*sizeof(double)); //不等式约束最大值数组 + common->gmin=(double *)malloc((i+1)*sizeof(double)); //不等式约束最小值数组 + common->gvalue=(double *)malloc((i+1)*sizeof(double)); //不等式约束值数组 + + i=common->n_sum; + common->v0=(double *)malloc((i+1)*sizeof(double)); //用户指定电压数组 + common->wv=(double *)malloc((i+1)*sizeof(double)); //电压权重数组 + + i=common->rpg; + common->wpg=(double *)malloc((i+1)*sizeof(double)); //有功出力权重数组 + i=common->rpd; + common->wpd=(double *)malloc((i+1)*sizeof(double)); //有功负荷权重数组 + i=common->rqg; + common->wqg=(double *)malloc((i+1)*sizeof(double)); //无功出力权重数组 + i=common->rqd; + common->wqd=(double *)malloc((i+1)*sizeof(double)); //无功负荷权重数组 + + return 1; +} + +/******节点优化编号Tinney_1******/ +void Tinney_1(opf_common *common) +{ + int i,j,m; + int kk; + + opf_yij *p1,*p2; + opf_line *p3; + opf_trans *p4; + opf_y0 *p5; + opf_power *p6; + opf_limit_p *p7; + opf_limit_q *p8; + opf_limit_v *p9; + opf_gij *p10; + opf_kij *p11; + opf_slack *p12; + opf_vpdqd *p13; + opf_gpcd *p14; + opf_sij *p15; + opf_dcbus *p16; + opf_equalitykij *p17; + + int *x1,*x2; //中间变量，要释放 + + + for(i=1;in_sum;i++) //节点导纳矩阵按行分组 + { p1=common->a[i]; + while(p1!=null) + { p1=common->a[i]->next; + free(common->a[i]); + common->a[i]=p1; + } + } + + p1=(opf_yij *)malloc(leyij); + p2=(opf_yij *)malloc(leyij); + p3=common->head_lij; //线路部分 + while(p3!=null) //形成节点导纳矩阵,可为双边的 + { p1->irow=p3->i; + p1->jcol=p3->j; + p1->amp=1; + common->a[p3->i]=insert1(common->a[p3->i],p1,&kk); + if(kk==0) + p1=(opf_yij *)malloc(leyij); + p2->irow=p3->j; + p2->jcol=p3->i; + p2->amp=1; + common->a[p3->j]=insert1(common->a[p3->j],p2,&kk); + if(kk==0) + p2=(opf_yij *)malloc(leyij); + p3=p3->next; + } + + p4=common->head_trans; + while(p4!=null) //变压器部分 + { p1->irow=p4->i; + p1->jcol=p4->j; + p1->amp=1; + common->a[p4->i]=insert1(common->a[p4->i],p1,&kk); + if(kk==0) + p1=(opf_yij *)malloc(leyij); + p2->irow=p4->j; + p2->jcol=p4->i; + p2->amp=1; + common->a[p4->j]=insert1(common->a[p4->j],p2,&kk); + if(kk==0) + p2=(opf_yij *)malloc(leyij); + p4=p4->next; + } + + p4=common->head_transb; + while(p4!=null) //移相器部分 + { p1->irow=p4->i; + p1->jcol=p4->j; + p1->amp=1; + common->a[p4->i]=insert1(common->a[p4->i],p1,&kk); + if(kk==0) + p1=(opf_yij *)malloc(leyij); + p2->irow=p4->j; + p2->jcol=p4->i; + p2->amp=1; + common->a[p4->j]=insert1(common->a[p4->j],p2,&kk); + if(kk==0) + p2=(opf_yij *)malloc(leyij); + p4=p4->next; + } + + free(p1); + free(p2); + + x1=(int *)malloc((common->n_sum+1)*sizeof(int)); + x2=(int *)malloc((common->n_sum+1)*sizeof(int)); + + for(i=1;i<=common->n_sum;i++) //统计各节点的出线度 + { p1=common->a[i]; + j=0; + while(p1!=null) + { j=j+1; + p1=p1->next; + } + x1[i]=j; //出线度 + x2[i]=i; //节点号 + } + + for(i=1;i<=common->n_sum;i++) + for(j=i+1;j<=common->n_sum;j++) + { if(x1[j]n_sum;i++) + common->opt_list[x2[i]]=i; //序号是原来的编号，值是后来的编号，将原来的编号按节点优化编号排列 + +//将原编号改成优化后的编号 + + p12=common->head_slack; + while(p12!=null) + { p12->i=common->opt_list[p12->i]; + p12=p12->next; + } + + p3=common->head_lij; //线路部分 + while(p3!=null) + { p3->i=common->opt_list[p3->i]; + p3->j=common->opt_list[p3->j]; + p3=p3->next; + } + + p4=common->head_trans; + while(p4!=null) //变压器部分 + { p4->i=common->opt_list[p4->i]; + p4->j=common->opt_list[p4->j]; + p4=p4->next; + } + + p4=common->head_transb; + while(p4!=null) //移相器部分 + { p4->i=common->opt_list[p4->i]; + p4->j=common->opt_list[p4->j]; + p4=p4->next; + } + + p5=common->head_y0; + while(p5!=null) //接地支路部分 + { p5->i=common->opt_list[p5->i]; + p5=p5->next; + } + + p11=common->head_ti; + while(p11!=null) //可调电容器部分(要求该部分全是可调的) + { p11->i=common->opt_list[p11->i]; + p11=p11->next; + } + + p11=common->head_kx; + while(p11!=null) //可调线路电抗部分(要求该部分全是可调的) + { p11->i=common->opt_list[p11->i]; + p11->j=common->opt_list[p11->j]; + p11=p11->next; + } + + p6=common->head_power; + while(p6!=null) //功率负荷部分 + { p6->i=common->opt_list[p6->i]; + p6=p6->next; + } + + p7=common->head_pg; + while(p7!=null) //有功功率和煤耗 + { p7->i=common->opt_list[p7->i]; + p7=p7->next; + } + + p7=common->head_pd; + while(p7!=null) //有功负荷 + { p7->i=common->opt_list[p7->i]; + p7=p7->next; + } + + p8=common->head_qg; + while(p8!=null) //无功约束数 + { p8->i=common->opt_list[p8->i]; + p8=p8->next; + } + + p8=common->head_qd; + while(p8!=null) //无功负荷 + { p8->i=common->opt_list[p8->i]; + p8=p8->next; + } + + p11=common->head_kij; //将可调变压器放到不等式约束中(并且肯定可调变压器都是有的) + while(p11!=null) + { p11->i=common->opt_list[p11->i]; + p11->j=common->opt_list[p11->j]; + p11=p11->next; + } + + p11=common->head_kbij; //将移相器放到不等式约束中 + while(p11!=null) + { p11->i=common->opt_list[p11->i]; + p11->j=common->opt_list[p11->j]; + p11=p11->next; + } + + p9=common->head_v; + while(p9!=null) //记录约束节点电压号 + { p9->i=common->opt_list[p9->i]; + p9=p9->next; + } + + p10=common->head_lcos; //记录线路功率因数限制的个数 + while(p10!=null) + { p10->i=common->opt_list[p10->i]; + p10->j=common->opt_list[p10->j]; + p10=p10->next; + } + + p10=common->head_vdcos; //记录负荷模型功率因数限制的个数 + while(p10!=null) + { p10->i=common->opt_list[p10->i]; + p10->j=common->opt_list[p10->j]; + p10=p10->next; + } + + p10=common->head_lpij; //记录线路有功功率限制的个数 + while(p10!=null) + { p10->i=common->opt_list[p10->i]; + p10->j=common->opt_list[p10->j]; + p10=p10->next; + } + + p10=common->head_lqij; //线路无功功率限制 + while(p10!=null) + { p10->i=common->opt_list[p10->i]; + p10->j=common->opt_list[p10->j]; + p10=p10->next; + } + + p10=common->head_lsij; //线路容量限制 + while(p10!=null) + { p10->i=common->opt_list[p10->i]; + p10->j=common->opt_list[p10->j]; + p10=p10->next; + } + + p10=common->head_liij; //线路电流限制 + while(p10!=null) + { p10->i=common->opt_list[p10->i]; + p10->j=common->opt_list[p10->j]; + p10=p10->next; + } + + p10=common->head_liij0; //线路电流限制 + while(p10!=null) + { p10->i=common->opt_list[p10->i]; + p10->j=common->opt_list[p10->j]; + p10=p10->next; + } + + p13=common->head_vpd; + while(p13!=null) //有功负荷模型 + { p13->i=common->opt_list[p13->i]; + p13=p13->next; + } + + p13=common->head_vqd; + while(p13!=null) //无功负荷模型 + { p13->i=common->opt_list[p13->i]; + p13=p13->next; + } + + p15=common->head_sij; //断面功率限制 + while(p15!=null) + { p15->i=common->opt_list[p15->i]; + p15->j=common->opt_list[p15->j]; + p15=p15->next; + } + + p15=common->head_obsij; //目标断面功率限制 + while(p15!=null) + { p15->i=common->opt_list[p15->i]; + p15->j=common->opt_list[p15->j]; + p15=p15->next; + } + + p14=common->head_gpcd; //发电机功率园图模型 + while(p14!=null) + { p14->i=common->opt_list[p14->i]; + p14=p14->next; + } + + p16=common->head_dcbus; //直流节点数据 + while(p16!=null) + { p16->iac=common->opt_list[p16->iac]; + p16=p16->next; + } + + p17=common->head_eqkij; //等可调变压器分接头 + while(p17!=null) + { p17->ai=common->opt_list[p17->ai]; + p17->aj=common->opt_list[p17->aj]; + p17->fi=common->opt_list[p17->fi]; + p17->fj=common->opt_list[p17->fj]; + p17=p17->next; + } + + for(i=1;i<=common->n_sum;i++) + x2[common->opt_list[i]]=i; + for(i=1;i<=common->n_sum;i++) + common->opt_list[i]=x2[i]; //序号是后来的编号，值是原来的编号，将节点编号后的值还原 + + + + free(x1); + free(x2); + return; + +} + +/*******节点导纳插入函数*******/ +opf_yij *insert1(opf_yij *tp,opf_yij *insert_p, int* k) //节点导纳插入函数 +{ + opf_yij *p0,*p111,*p112; + double r,r1,x,x1; + + *k=0; + p111=tp; + p0=insert_p; + if(p0==null) + return(tp); + if(tp==null) + { tp=p0; + p0->next=null; + return(tp); + } + if(p0->jcoljcol) + { tp=p0; + p0->next=p111; + return(tp); + } + while((p0->jcol>p111->jcol)&&(p111->next!=null)) + { p112=p111; + p111=p111->next; + } + + if(p0->jcol==p111->jcol) //两点间有多条线路或变压器 + { r=p111->amp*cos(p111->rad); + x=p111->amp*sin(p111->rad); + r1=p0->amp*cos(p0->rad); + x1=p0->amp*sin(p0->rad); + r=r+r1; + x=x+x1; + x1=sqrt(r*r+x*x); + p111->amp=x1; + p111->rad=atan2(x,r); + *k=1; + return(tp); + } + if((p111->next==null)&&(p0->jcol>p111->jcol)) + { p111->next=p0; + p0->next=null; + } + else + { p112->next=p0; + p0->next=p111; + } + return(tp); +} + +/******形成节点导纳矩阵和其他相关元素******/ +int Initialization(opf_common *common) +{ + int i,j,m,k; + double r,x,bb,bbj,gij,bij,tmp,k0,ku,kd,b0,bu,bd; + + opf_yij *p1,*p2; + opf_line *p3; + opf_trans *p4; + opf_y0 *p5; + opf_power *p6; + opf_limit_p *p7; + opf_limit_q *p8; + opf_limit_v *p9; + opf_gij *p10; + opf_kij *p11; + opf_vpdqd *p12; + opf_gpcd *p13; + opf_dcbus *p14; + opf_equalitykij *p15; + + int kk; + + for(m=1;m<=common->n_sum;m++) + { common->g[m]=0; + common->b[m]=0; + common->pg[m]=0; + common->qg[m]=0; + common->pd[m]=0; + common->qd[m]=0; + } + for(m=1;m<=common->n_sum;m++) //节点导纳矩阵按行分组 + { p1=common->a[m]; + while(p1!=null) + { p1=common->a[m]->next; + free(common->a[m]); + common->a[m]=p1; + } + } + + p1=(opf_yij *)malloc(leyij); + p2=(opf_yij *)malloc(leyij); + p3=common->head_lij; //线路部分 + while(p3!=null) //形成节点导纳矩阵,可为双边的,按行排 + { + r=p3->amp; + x=p3->rad; + bb=p3->bb; + bbj=p3->bbj; + i=p3->i; + j=p3->j; + gij=r/(r*r+x*x); + bij=-x/(r*r+x*x); + r=-gij; + x=-bij; + tmp=sqrt(r*r+x*x); + if(tmp!=0) + { p1->irow=i; + p1->jcol=j; + p1->amp=tmp; + p1->rad=atan2(x,r); + common->a[i]=insert1(common->a[i],p1,&kk); + if(kk==0) + p1=(opf_yij *)malloc(leyij); + p2->irow=j; + p2->jcol=i; + p2->amp=tmp; + p2->rad=atan2(x,r); + common->a[j]=insert1(common->a[j],p2,&kk); + if(kk==0) + p2=(opf_yij *)malloc(leyij); + } + p3->amp=tmp; + p3->rad=atan2(x,r); + p3->bb=bb; + p3->bbj=bbj; + + common->g[i]=common->g[i]+gij; + common->b[i]=common->b[i]+bij+bb; + common->g[j]=common->g[j]+gij; + common->b[j]=common->b[j]+bij+bbj; + p3=p3->next; + } + + k=1; + p4=common->head_trans; + while(p4!=null) //变压器部分 + { i=p4->i; + j=p4->j; + r=p4->r; + x=p4->x; + k0=p4->k; + gij=r/(r*r+x*x); + bij=-x/(r*r+x*x); + k0=1/k0; //在计变压器变比时用1/k0来做变量，既用倒数来做变量 + r=-gij*k0; + x=-bij*k0; + tmp=sqrt(r*r+x*x); + if(tmp!=0) + { p1->irow=i; + p1->jcol=j; + p1->amp=tmp; + p1->rad=atan2(x,r); + common->a[i]=insert1(common->a[i],p1,&kk); + if(kk==0) + p1=(opf_yij *)malloc(leyij); + p2->irow=j; + p2->jcol=i; + p2->amp=tmp; + p2->rad=atan2(x,r); + common->a[j]=insert1(common->a[j],p2,&kk); + if(kk==0) + p2=(opf_yij *)malloc(leyij); + } + common->g[i]=common->g[i]+gij*k0*k0; + common->b[i]=common->b[i]+bij*k0*k0; + common->g[j]=common->g[j]+gij; + common->b[j]=common->b[j]+bij; + p4=p4->next; + } + + k=1; + p4=common->head_transb; + while(p4!=null) //移相器部分 + { i=p4->i; + j=p4->j; + r=p4->r; + x=p4->x; + k0=p4->k; + b0=p4->b; + gij=r/(r*r+x*x); + bij=-x/(r*r+x*x); + k0=1/k0; //在计移相器变比时用1/k0来做变量，既用倒数来做变量 + b0=-b0; //在计移相器变比时用-b0来做变量，既用负数来做变量 + r=-gij*k0; + x=-bij*k0; + tmp=sqrt(r*r+x*x); + if(tmp!=0) + { p1->irow=i; //Yij + p1->jcol=j; + p1->amp=tmp; + p1->rad=atan2(x,r)-b0; + common->a[i]=insert1(common->a[i],p1,&kk); + if(kk==0) + p1=(opf_yij *)malloc(leyij); + p2->irow=j; //Yji + p2->jcol=i; + p2->amp=tmp; + p2->rad=atan2(x,r)+b0; + common->a[j]=insert1(common->a[j],p2,&kk); + if(kk==0) + p2=(opf_yij *)malloc(leyij); + } + common->g[i]=common->g[i]+gij*k0*k0; //Yii + common->b[i]=common->b[i]+bij*k0*k0; + common->g[j]=common->g[j]+gij; //Yjj + common->b[j]=common->b[j]+bij; + p4=p4->next; + } + + p5=common->head_y0; + while(p5!=null) //接地支路部分 + { i=p5->i; + r=p5->g; + x=p5->b; + common->g[i]=common->g[i]+r; + common->b[i]=common->b[i]+x; + p5=p5->next; + } + + p11=common->head_ti; + while(p11!=null) //可调电容器部分(要求该部分全是可调的) + { i=p11->i; + r=p11->amp; + x=p11->rad; + k0=p11->k; + common->g[i]=common->g[i]+k0*r; + common->b[i]=common->b[i]+k0*x; + p11->amp=sqrt(r*r+x*x); //Yij' + p11->rad=atan2(x,r); + p11=p11->next; + } + + p11=common->head_kx; + while(p11!=null) //可调线路电抗部分(要求该部分全是可调的),要注意转换成导纳型的 + { r=p11->amp; + x=p11->rad; + i=p11->i; + j=p11->j; + gij=r/(r*r+x*x); + bij=-x/(r*r+x*x); + r=-gij; + x=-bij; + tmp=sqrt(r*r+x*x); + if(tmp!=0) + { p1->irow=i; + p1->jcol=j; + p1->amp=tmp; + p1->rad=atan2(x,r); + common->a[i]=insert1(common->a[i],p1,&kk); + if(kk==0) + p1=(opf_yij *)malloc(leyij); + p2->irow=j; + p2->jcol=i; + p2->amp=tmp; + p2->rad=atan2(x,r); + common->a[j]=insert1(common->a[j],p2,&kk); + if(kk==0) + p2=(opf_yij *)malloc(leyij); + } + p11->k=1/p11->k; + p11->b=1/p11->k; //放的是原值 + p11->amp=tmp/p11->k; //化为单位导纳 幅值 + p11->rad=atan2(x,r); //相角 + r=p11->down; + x=p11->up; + + if(x==0) //下界 + p11->down=p11->k; + else + p11->down=1/x; + if(r==0) //上界 + p11->up=10000*p11->k; + else + p11->up=1/r; + + common->g[i]=common->g[i]+gij; + common->b[i]=common->b[i]+bij; + common->g[j]=common->g[j]+gij; + common->b[j]=common->b[j]+bij; + + p11=p11->next; + } + + free(p1); + free(p2); + + p6=common->head_power; + while(p6!=null) //功率负荷部分 + { i=p6->i; + r=p6->pg; + bb=p6->pd; + x=p6->qg; + k0=p6->qd; + common->pg[i]=r; + common->qg[i]=x; + common->pd[i]=bb; + common->qd[i]=k0; + p6=p6->next; + } + + j=1; + k=1; + p7=common->head_pg; + while(p7!=null) //有功功率和煤耗 + { i=p7->i; + if(p7->flag==1) + { common->gp[j]=i; //记录约束节点有功号 + common->wpg[j]=p7->w; //权重 + common->gmin[k]=p7->pmin; + common->gmax[k]=p7->pmax; + +/* + common->gmin[k]=0; + common->gmax[k]=1000;*/ + + +// common->varx[j]=(p7->pmin+p7->pmax)/2; //从中值启动 + common->varx[j]=p7->p0; //从给的潮流值启动 + r=common->varx[j]; //从中值启动 + common->fa0[k]=p7->fa01; + common->fa1[k]=p7->fa11; + common->fa2[k]=p7->fa21; + common->fa3[k]=p7->fa31; + common->fa4[k]=p7->fa41; + p7->k=1; + if((r>=p7->pmin2)&&(r<=p7->pmax2)) //第2段 + { common->fa0[k]=p7->fa02; + common->fa1[k]=p7->fa12; + common->fa2[k]=p7->fa22; + common->fa3[k]=p7->fa32; + common->fa4[k]=p7->fa42; + p7->k=2; + } + if((r>=p7->pmin3)&&(r<=p7->pmax3)) //第3段 + { common->fa0[k]=p7->fa03; + common->fa1[k]=p7->fa13; + common->fa2[k]=p7->fa23; + common->fa3[k]=p7->fa33; + common->fa4[k]=p7->fa43; + p7->k=3; + } + j=j+1; + k=k+1; + } + p7=p7->next; + } + + if(common->mini_pf_flag==1) //最小化潮流的有功偏差部分rpge + { for(i=1;i<=common->rpge;i++) + { common->gp[j]=i; + common->varx[j]=0; //从给的潮流值启动 + common->gmin[k]=-1; + common->gmax[k]=1; + j=j+1; + k=k+1; + } + } + + m=1; + p7=common->head_pd; + while(p7!=null) //有功负荷(紧接着刚才的有功出力，不用另外计数) + { i=p7->i; + if(p7->flag==1) + { common->gp[j]=i; //记录约束节点有功号，从rpg以后开始 + common->wpd[m]=p7->w; //权重 + common->gmin[k]=p7->pmin; + common->gmax[k]=p7->pmax; +// common->gmin[k]=-100; +// common->gmax[k]=100; +// common->varx[j]=(p7->pmin+p7->pmax)/2; //从中值启动 + common->varx[j]=common->pd[i]; //从给的潮流值启动(有功负荷) + j=j+1; + k=k+1; + m=m+1; + } + p7=p7->next; + } + + j=1; + if(common->qnum_slackflag!=1) + { p8=common->head_qg; + while(p8!=null) + { i=p8->i; + if(p8->flag==1) + { common->gq[j]=i; //记录约束节点无功号 + common->wqg[j]=p8->w; + common->gmin[k]=p8->qmin; + common->gmax[k]=p8->qmax; + +/* + common->gmin[k]=-1000; + common->gmax[k]=1000;*/ + +// common->varx[common->rp+j]=(p8->qmin+p8->qmax)/2; //从中值启动 + common->varx[common->rp+j]=common->qg[i]; //从给的潮流值启动 + j=j+1; + k=k+1; + } + p8=p8->next; + } + } + else + { for(i=1;i<=common->n_sum;i++) + { common->gq[j]=i; //记录约束节点无功号 + common->wqg[j]=1; + common->gmin[k]=common->qg[i]; + common->gmax[k]=common->qg[i]; + + common->varx[common->rp+j]=common->qg[i]; //从给的潮流值启动 + j=j+1; + k=k+1; + } + p8=common->head_qg; + while(p8!=null) + { i=p8->i; + if(p8->flag==1) + { common->wqg[i]=p8->w; + common->gmin[common->rp+i]=p8->qmin; + common->gmax[common->rp+i]=p8->qmax; + } + p8=p8->next; + } + } + + if(common->mini_pf_flag==1) //最小化潮流的无功偏差部分rqge + { for(i=1;i<=common->rqge;i++) + { common->gq[j]=i; + common->varx[common->rp+common->rqg+i]=0; //从给的潮流值启动 + common->gmin[k]=-1; + common->gmax[k]=1; + j=j+1; + k=k+1; + } + } + + + m=1; + p8=common->head_qd; + while(p8!=null) //无功负荷(紧接着刚才的无功出力，不用另外计数) + { i=p8->i; + if(p8->flag==1) + { common->gq[j]=i; //记录约束节点无功号 + common->wqd[m]=p8->w; //权重(重新编号) + common->gmin[k]=p8->qmin; + common->gmax[k]=p8->qmax; +// common->varx[rr+j]=(p8->qmin+p8->qmax)/2; //从中值启动 + common->varx[common->rp+j]=common->qd[i]; //从给的潮流值启动 + j=j+1; + k=k+1; + m=m+1; + } + p8=p8->next; + } + + j=1; + p11=common->head_kij; //将可调变压器放到不等式约束中(并且肯定可调变压器都是有的) + while(p11!=null) + { r=p11->amp; + x=p11->rad; + k0=1/p11->k; + ku=1/p11->down; + kd=1/p11->up; + gij=r/(r*r+x*x); + bij=-x/(r*r+x*x); + p11->amp=sqrt(gij*gij+bij*bij); //Yij' + p11->rad=atan2(-bij,-gij); + p11->k=k0; +// p11->k=(kd+ku)/2; + p11->down=kd; + p11->up=ku; + + common->gmin[k]=p11->down; + common->gmax[k]=p11->up; + common->varx[common->rp+common->rq+j]=p11->k; + k=k+1; + j=j+1; + p11=p11->next; + } + + j=1; + p11=common->head_kbij; //将移相器放到不等式约束中(并且肯定移相器都是有的) + while(p11!=null) + { r=p11->amp; + x=p11->rad; + k0=1/p11->k; + ku=1/p11->down; + kd=1/p11->up; + b0=-p11->b; + bu=-p11->bdown; + bd=-p11->bup; + gij=r/(r*r+x*x); + bij=-x/(r*r+x*x); + p11->amp=sqrt(gij*gij+bij*bij); //Yij' + p11->rad=atan2(-bij,-gij); //aij0 + p11->k=k0; +// p11->k=(kd+ku)/2; + p11->down=kd; + p11->up=ku; + if(bu>bd) + { p11->bup=bu; + p11->bdown=bd; + } + else + { p11->bup=bd; + p11->bdown=bu; + } + p11->b=b0; + + common->gmin[k]=p11->down; //注意变量排列是先排完k再排b + common->gmax[k]=p11->up; + common->varx[common->rp+common->rq+common->rk+j]=p11->k; + + common->gmin[k+common->rkb]=p11->bdown; + common->gmax[k+common->rkb]=p11->bup; + common->varx[common->rp+common->rq+common->rk+j+common->rkb]=p11->b; + k=k+1; + j=j+1; + + p11=p11->next; + } + k=k+common->rkb; + + j=1; + i=common->rp+common->rq+common->rk+2*common->rkb; + p11=common->head_ti; //将可调电容器放到不等式约束中 + while(p11!=null) + { common->gmin[k]=p11->down; + common->gmax[k]=p11->up; + common->varx[i+j]=p11->k; + k=k+1; + j=j+1; + p11=p11->next; + } + + j=1; + i=common->rp+common->rq+common->rk+2*common->rkb+common->rt; + p11=common->head_kx; //将可调线路电抗放到不等式约束中 + while(p11!=null) + { common->gmin[k]=p11->down; + common->gmax[k]=p11->up; + common->varx[i+j]=p11->k; + k=k+1; + j=j+1; + p11=p11->next; + } + + j=1; + i=common->rp+common->rq+common->rk+2*common->rkb+common->rt+common->rx; + p10=common->head_lcos; //将线路功率因数放到不等式约束中(转化成PijQij) + while(p10!=null) + { + common->gmin[k]=-100; //Pij + common->gmax[k]=100; +// common->varx[i+j]=(p10->gmin+p10->gmax)/2; //注意要在迭代初始更新 + common->varx[i+j]=0.5; + p10->g=common->varx[i+j]; + + common->gmin[k+common->rlcos]=-100; //Qij + common->gmax[k+common->rlcos]=100; +// common->varx[i+j+common->rlcos]=(p10->gmin+p10->gmax)/2; //注意要在迭代初始更新 + common->varx[i+j+common->rlcos]=0.5; + p10->g=common->varx[i+common->rlcos+j]; + k=k+1; + j=j+1; + + p10=p10->next; + } + k=k+common->rlcos; + + j=1; + i=common->rp+common->rq+common->rk+2*common->rkb+common->rt+common->rx+2*common->rlcos; + p10=common->head_vdcos; //将负荷模型功率因数放到不等式约束中 + while(p10!=null) + { common->gmin[k]=p10->gmin; + common->gmax[k]=p10->gmax; + common->varx[i+j]=(p10->gmin+p10->gmax)/2; //注意要在迭代初始更新 +// common->varx[i+j]=1; + p10->g=common->varx[i+j]; + k=k+1; + j=j+1; + p10=p10->next; + } + + j=1; + i=common->rp+common->rq+common->rk+2*common->rkb+common->rt+common->rx+2*common->rlcos+common->rvdcos; + p14=common->head_dcbus; //将直流数据放到不等式约束中，排列方式电压、电流、换流器变压器抽头、换流器触发角或熄弧角、功率因数角，并按大列排列 + while(p14!=null) + { + common->gmin[k]=p14->vmin; + common->gmax[k]=p14->vmax; + common->gmin[k+common->n_dc]=p14->imin; + common->gmax[k+common->n_dc]=p14->imax; + common->gmin[k+common->n_dc*2]=p14->kmin; + common->gmax[k+common->n_dc*2]=p14->kmax; + common->gmin[k+common->n_dc*3]=p14->bmin; + common->gmax[k+common->n_dc*3]=p14->bmax; + common->gmin[k+common->n_dc*4]=p14->amin; + common->gmax[k+common->n_dc*4]=p14->amax; + + common->varx[i+j]=(p14->vmin+p14->vmax)/2; //电压 + common->varx[i+j+common->n_dc]=(p14->imin+p14->imax)/2; //电流 + common->varx[i+j+common->n_dc*2]=(p14->kmin+p14->kmax)/2; //换流器变压器抽头 + common->varx[i+j+common->n_dc*3]=(p14->bmin+p14->bmax)/2; //换流器触发角或熄弧角 + common->varx[i+j+common->n_dc*4]=(p14->amin+p14->amax)/2; //功率因数角 + + k=k+1; + j=j+1; + p14=p14->next; + } + k=k+common->n_dc*4; + + +//电压限制都要有，要按顺序 + for(i=1;i<=common->n_sum;i++) + { common->varl[i]=common->vmin; //电压下限 + common->varu[i]=common->vmax; //电压上限 + common->v0[i]=1; //电压的初值 + common->wv[i]=1; //电压的权重 + } + p9=common->head_v; + while(p9!=null) + { i=p9->i; + common->varl[i]=p9->vmin; //电压下限 + common->varu[i]=p9->vmax; //电压上限 + common->v0[i]=p9->v0; //电压的初值 + common->wv[i]=p9->w; //电压的权重 + p9=p9->next; + } + for(i=1;i<=common->n_sum;i++) + { common->gv[i]=i; //记录约束节点电压号 + common->gmin[k]=common->varl[i]; + common->gmax[k]=common->varu[i]; + k=k+1; + } + + j=1; //记录线路有功功率限制的个数 + p10=common->head_lpij; + while(p10!=null) + { common->gmin[k]=p10->gmin; + common->gmax[k]=p10->gmax; + j=j+1; + k=k+1; + p10=p10->next; + } + + j=1; //记录线路无功功率限制的个数 + p10=common->head_lqij; + while(p10!=null) + { common->gmin[k]=p10->gmin; + common->gmax[k]=p10->gmax; + j=j+1; + k=k+1; + p10=p10->next; + } + + j=1; //线路容量限制 + p10=common->head_lsij; + while(p10!=null) + { + r=p10->gmin; + x=p10->gmax; + r=r*r; + x=x*x; + if(rgmin=r; + p10->gmax=x; + } + else + { p10->gmin=x; + p10->gmax=r; + } + common->gmin[k]=p10->gmin; + common->gmax[k]=p10->gmax; + j=j+1; + k=k+1; + p10=p10->next; + } + + j=1; //线路电流限制 + p10=common->head_liij; + while(p10!=null) + { + r=p10->gmin; + x=p10->gmax; + r=r*r; + x=x*x; + if(rgmin=r; + p10->gmax=x; + } + else + { p10->gmin=x; + p10->gmax=r; + } + common->gmin[k]=p10->gmin; + common->gmax[k]=p10->gmax; + j=j+1; + k=k+1; + p10=p10->next; + } + + j=1; //有功负荷模型 + p12=common->head_vpd; + while(p12!=null) + { common->gmin[k]=p12->min; + common->gmax[k]=p12->max; + j=j+1; + k=k+1; + p12=p12->next; + } + + j=1; //无功负荷模型 + p12=common->head_vqd; + while(p12!=null) + { common->gmin[k]=p12->min; + common->gmax[k]=p12->max; + j=j+1; + k=k+1; + p12=p12->next; + } + + j=1; //记录断面有功功率限制的个数 + p10=common->head_spij; + while(p10!=null) + { common->gmin[k]=p10->gmin; + common->gmax[k]=p10->gmax; + j=j+1; + k=k+1; + p10=p10->next; + } + + j=1; //记录断面无功功率限制的个数 + p10=common->head_sqij; + while(p10!=null) + { common->gmin[k]=p10->gmin; + common->gmax[k]=p10->gmax; + j=j+1; + k=k+1; + p10=p10->next; + } + + j=1; //发电机功率园图限制 + p13=common->head_gpcd; + while(p13!=null) + { if(p13->xd!=0) + p13->qo=-1/p13->xd; + else + p13->qo=0; + common->gmin[k]=0; + common->gmax[k]=pow(p13->sn*cos(p13->rad),2)+pow((p13->sn*sin(p13->rad)-p13->qo),2); + j=j+1; + k=k+1; + p13=p13->next; + } + + j=1; + p14=common->head_dcbus; //将功率直流数据放到不等式约束中 + while(p14!=null) + { + common->gmin[k]=p14->pmin; + common->gmax[k]=p14->pmax; + k=k+1; + j=j+1; + p14=p14->next; + } + + p10=common->head_lcos; //将线路功率因数放到不等式约束中(转化成PijQij的cos的平方) + while(p10!=null) + { r=p10->gmin*p10->gmin; + x=p10->gmax*p10->gmax; + + if(rgmin[k]=r; //cosij + common->gmax[k]=x; + } + else + { common->gmin[k]=x; //cosij + common->gmax[k]=r; + } + k=k+1; + + p10=p10->next; + } + + p15=common->head_eqkij; + while(p15!=null) + { m=0; + j=1; + p11=common->head_kij; + while((p11!=null)&&(m==0)) + { if((p11->i==p15->ai)&&(p11->j==p15->aj)) + p15->i=j; + if((p11->i==p15->fi)&&(p11->j==p15->fj)) + p15->j=j; + if((p15->i!=0)&&(p15->j!=0)) + m=1; + j=j+1; + p11=p11->next; + } + p15=p15->next; + } + + for(i=1;i<=common->n_sum;i++) //节点导纳矩阵对角线上的元素 + { r=sqrt(common->g[i]*common->g[i]+common->b[i]*common->b[i]); + common->b[i]=atan2(common->b[i],common->g[i]); + common->g[i]=r; + } + + p1=common->a[1]; + i=1; //将节点导纳矩阵联起来 + while(in_sum) + { j=0; + while(p1->next!=null) + { j=j+1; + p1=p1->next; + } + i=i+1; + if(common->a[i]!=null) //要不是空链表的才连在一起 + p1->next=common->a[i]; + } + +/* + FILE *fp1; + fp1=fopen("Text3.txt","wb"); + p1=common->a[1]; + while(p1!=null) + { fprintf(fp1," %d, %d, %f, %f\n" ,p1->irow,p1->jcol,p1->amp,p1->rad); + p1=p1->next; + } + for(i=1;i<=common->n_sum;i++) + fprintf(fp1," %d, %d, %f, %f\n" ,i,i,common->g[i],common->b[i]); + fclose(fp1);*/ + + return 0; + +} + +/******进行数据初步筛查*******/ +int JudgeData(opf_common *common) //对原始数据进行初步判断 + //如果通过测试，返回0，否则返回非零数j +{ int i,j,j1,j2,j3,j4,j5; + double r,x; + opf_error *p22; + + j1=0; //判断条件一：用于判断是否有孤点（完全） + for(i=1;i<=common->n_sum;i++) + { if(common->g[i]==0) //利用节点导纳矩阵的对角线元素进行判断 + j1=j1+1; + } + if(j1!=0) + { p22=(opf_error *)malloc(leerror); + sprintf(p22->str,"%s %d %s","error:sorry,don't compute because of",j1,"acnode in this system."); + p22->next=null; + common->head_error=AddErrorWord(p22,common->head_error); + } + + j5=0; //判断条件五：用于判断是否有孤点（带对地支路，但没有连接支路） + for(i=1;i<=common->n_sum;i++) + { if(common->a[i]==null) //利用节点导纳矩阵的非对角线元素进行判断，通常存在的情况是有对地支路 + j5=j5+1; + } + if(j5!=0) + { p22=(opf_error *)malloc(leerror); + sprintf(p22->str,"%s %d %s","error:sorry,don't compute because of",j5,"acnode in this system."); + p22->next=null; + common->head_error=AddErrorWord(p22,common->head_error); + } + + j2=0; + if(common->n_sum>=20000) //判断条件二：判断交流节点数是否过大（系统规模控制） + j2=j2+1; + if(j2!=0) + { p22=(opf_error *)malloc(leerror); + sprintf(p22->str,"%s","error:sorry,don't compute because of the node in this system."); + p22->next=null; + common->head_error=AddErrorWord(p22,common->head_error); + } + + r=0; //判断条件三：检测PGmax>PD + x=0; + j3=0; + for(i=1;i<=common->n_sum;i++) + r=r+common->pg[i]-common->pd[i]; //p[i]=PG-PD + for(i=1;i<=common->rpg;i++) + r=r+common->gmax[i]-common->pg[common->gp[i]]; + if(r<=0) //PGmax-PD<=0 + j3=j3+1; + if(j3!=0) + { p22=(opf_error *)malloc(leerror); + sprintf(p22->str,"%s","error:sorry,don't compute because of the generator capacity not enough."); + p22->next=null; + common->head_error=AddErrorWord(p22,common->head_error); + } + + j4=0; + if((common->rpg==0)||(common->rqg==0)) //判断条件四：至少要有一个可调的有功源和无功源 + j4=j4+1; + if(j4!=0) + { p22=(opf_error *)malloc(leerror); + sprintf(p22->str,"%s","error:sorry,don't compute because of no adjustable generator."); + p22->next=null; + common->head_error=AddErrorWord(p22,common->head_error); + } + + j=j1+j2+j3+j4+j5; + return j; + +} + +/******初始化矩阵结构体******/ +void InitializeVarCorrect(opf_common *common,opf_correct *correct)//开相应的内存空间 +{ + int i,j; + + i=common->rr-common->rv+2*common->n_sum; //变量 + correct->jcb=(opf_matrix **)malloc((i+1)*sizeof(opf_matrix *)); //等式约束雅克比矩阵 + for(j=1;j<=i;j++) + correct->jcb[j]=null; + i=common->rr+common->rrr; + correct->dg=(opf_matrix **)malloc((i+1)*sizeof(opf_matrix*)); //不等式约束雅克比矩阵 + for(j=1;j<=i;j++) + correct->dg[j]=null; + i=common->rr-common->rv+4*common->n_sum+common->req; + correct->heisen=(opf_matrix **)malloc((i+1)*sizeof(opf_matrix*));//修正方程 + correct->d=(double *)malloc((i+1)*sizeof(double)); //修正方程的对角线元素 + for(j=1;j<=i;j++) + { correct->heisen[j]=null; + correct->d[j]=0; + } + return; +} + +/******添加error语句******/ +opf_error * AddErrorWord(opf_error *tp,opf_error *headerror) //添加error语句，headerror指明是哪个头指针 +{ + opf_error *p1; + + + if(headerror==null) //判断是否是头指针 + headerror=tp; + else + { p1=headerror; + while(p1->next!=null) //添加到链表中 + p1=p1->next; + p1->next=tp; + } + return headerror; +} + +/******计算目标函数******/ +double ObjectiveValue(opf_common *common) //计算目标值 +{ + int i,j; + double x,r; + int *spg,*sqg; //临时变量 + + opf_yij *p1; + opf_line *p4; + opf_kij *p6; + opf_vpdqd *p2; + opf_sij *p8; + opf_gij *p3; + + spg=(int *)malloc((common->n_sum+1)*sizeof(int));//为了同一个节点有多台发电机的情况 + sqg=(int *)malloc((common->n_sum+1)*sizeof(int)); + + x=0; + if(common->mini_pf_flag==1) + { for(i=1;i<=common->rpge;i++) + x=x+common->mini_pf_w*(common->varx[i+common->rpg]*common->varx[i+common->rpg]); + for(i=1;i<=common->rqge;i++) + x=x+common->mini_pf_w*(common->varx[i+common->rp+common->rqg]*common->varx[i+common->rp+common->rqg]); + } + + switch(common->obj_type0) + { + case 1: //煤耗 + { for(i=1;i<=common->rpg;i++) //a0+a1PG+a2PG*PG+a3exp(a4PG) + x=x+common->fa0[i]+common->fa1[i]*common->varx[i]+common->fa2[i]*common->varx[i]*common->varx[i]+common->fa3[i]*exp(common->fa4[i]*common->varx[i]); + break; + } + case 2: //P之和 + { for(i=1;i<=common->rpg;i++) + x=x+common->varx[i]; + break; + } + case 3: //Q之和 + { for(i=common->rp+1;i<=common->rp+common->rqg;i++) + x=x+common->varx[i]; + break; + } + case 4: //支路有功损耗最小 + { r=0; + for(i=1;i<=common->n_sum;i++) + { p1=common->a[i]; + j=0; + if(p1!=null) + { while((p1->irow==i)&&(j==0)) + { r=r-(common->v[i]*common->v[i]+common->v[p1->jcol]*common->v[p1->jcol]-2*common->v[i]*common->v[p1->jcol]*cos(common->rad[p1->irow]-common->rad[p1->jcol]))*p1->amp*cos(p1->rad); + if(p1->next==null) + j=1; + else + p1=p1->next; + } + } + } + x=r/2; + break; + } + case 5: //支路无功损耗最小 + { r=0; + for(i=1;i<=common->n_sum;i++) + { p1=common->a[i]; + j=0; + if(p1!=null) + { while((p1->irow==i)&&(j==0)) + { r=r+(common->v[i]*common->v[i]+common->v[p1->jcol]*common->v[p1->jcol]-2*common->v[i]*common->v[p1->jcol]*cos(common->rad[p1->irow]-common->rad[p1->jcol]))*p1->amp*sin(p1->rad); + if(p1->next==null) + j=1; + else + p1=p1->next; + } + } + } + x=r/2; + break; + } + case 6: //线路有功损耗最小 + { p4=common->head_lij; + x=0; + while(p4!=null) + { x=x-(common->v[p4->i]*common->v[p4->i]+common->v[p4->j]*common->v[p4->j]-2*common->v[p4->i]*common->v[p4->j]*cos(common->rad[p4->i]-common->rad[p4->j]))*p4->amp*cos(p4->rad); + p4=p4->next; + } + break; + } + case 7: //线路无功损耗最小 + { p4=common->head_lij; + x=0; + while(p4!=null) + { x=x+(common->v[p4->i]*common->v[p4->i]+common->v[p4->j]*common->v[p4->j]-2*common->v[p4->i]*common->v[p4->j]*cos(common->rad[p4->i]-common->rad[p4->j]))*p4->amp*cos(p4->rad)-(common->v[p4->i]*common->v[p4->i]+common->v[p4->j]*common->v[p4->j])*p4->bb; + p4=p4->next; + } + break; + } + case 8: //电压偏差最小 + { x=0; + for(i=1;i<=common->n_sum;i++) + x=x+common->wv[i]*(common->v[i]-common->v0[i])*(common->v[i]-common->v0[i]); + break; + } + case 9: //有功网损PG-PD + { x=0; + for(i=1;i<=common->n_sum;i++) + { x=x+common->pg[i]-common->pd[i]; + spg[i]=0; //可变有功标志 + } + +/* + for(i=1;i<=common->rpg;i++) + x=x+common->varx[i]-common->pg[common->gp[i]];*/ + + for(i=1;i<=common->rpg;i++) + { x=x+common->varx[i]; + spg[common->gp[i]]=spg[common->gp[i]]+1; + } + for(i=1;i<=common->n_sum;i++) + if(spg[i]!=0) + x=x-common->pg[i]; + + + for(i=1;i<=common->rpd;i++) //负荷的线性模型 + x=x-common->varx[common->rpg+common->rpge+i]+common->pd[common->gp[common->rpg+common->rpge+i]]; + + p2=common->head_vpd; //有功负荷模型(与线性模型不一起出现) + while(p2!=null) + { r=p2->a*common->v[p2->i]*common->v[p2->i]+p2->b*common->v[p2->i]+p2->c; + x=x-r+common->pd[p2->i]; + p2=p2->next; + } + break; + } + case 10: //无功网损QG-QD + { x=0; + for(i=1;i<=common->n_sum;i++) + { x=x+common->qg[i]-common->qd[i]; + sqg[i]=0; //可变无功标志 + } + +/* + for(i=1;i<=common->rqg;i++) + x=x+common->varx[common->rp+i]-common->qg[common->gq[i]];*/ + + + for(i=1;i<=common->rqg;i++) + { x=x+common->varx[common->rp+i]; + sqg[common->gq[i]]=sqg[common->gq[i]]+1; + } + for(i=1;i<=common->n_sum;i++) + if(sqg[i]!=0) + x=x-common->qg[i]; + + + for(i=1;i<=common->rqd;i++) + x=x-common->varx[common->rp+common->rqg+common->rqge+i]+common->qd[common->gq[common->rqg+common->rqge+i]]; + + p2=common->head_vqd; //无功负荷模型(与线性模型不一起出现) + while(p2!=null) + { r=p2->a*common->v[p2->i]*common->v[p2->i]+p2->b*common->v[p2->i]+p2->c; + x=x-r+common->qd[p2->i]; + p2=p2->next; + } + break; + } + case 11: //电容/电抗调节最小 + { x=0; + p6=common->head_ti; + while(p6!=null) //w*(ti-ti0)*(ti-ti0) + { x=x+p6->w*(p6->k-p6->b)*(p6->k-p6->b); + p6=p6->next; + } + break; + } + case 12: //负荷功率调节最小 + { x=0; + for(i=1;i<=common->rpd;i++) //w*(PDi-PDi0)*(PDi-PDi0) + x=x+common->wpd[i]*(common->varx[common->rpg+common->rpge+i]-common->pd[common->gp[common->rpg+common->rpge+i]])*(common->varx[common->rpg+common->rpge+i]-common->pd[common->gp[common->rpg+common->rpge+i]]); + + p2=common->head_vpd; //有功负荷模型(与线性模型不一起出现) + while(p2!=null) + { r=p2->a*common->v[p2->i]*common->v[p2->i]+p2->b*common->v[p2->i]+p2->c; + x=x+p2->w*(r-common->pd[p2->i])*(r-common->pd[p2->i]); + p2=p2->next; + } + + break; + } + case 13: //断面功率最小 + { x=0; + p3=common->head_spij; //断面有功值 + while(p3!=null) + { p8=common->head_obsij; + while(p8!=null) + { if(p8->num==p3->i) + { +/* + p4=common->head_lij; + j=0; + while((p4!=null)&&(j==0)) + { if((p8->i==p4->i)&&(p8->j==p4->j)) + j=1; + else + p4=p4->next; + } + if(p4!=null) + x+=common->v[p4->i]*common->v[p4->i]*p4->amp*cos(p4->rad)-common->v[p4->i]*common->v[p4->j]*p4->amp*cos(common->rad[p4->i]-common->rad[p4->j]-p4->rad);*/ + + p1=common->a[p8->i]; //按列找 + j=0; + while((p1!=null)&&(j==0)) + { if((p8->i==p1->irow)&&(p8->j==p1->jcol)) + j=1; + else + p1=p1->next; + } + if(p1!=null) + x+=p8->w*(common->v[p1->irow]*common->v[p1->irow]*p1->amp*cos(p1->rad)-common->v[p1->irow]*common->v[p1->jcol]*p1->amp*cos(common->rad[p1->irow]-common->rad[p1->jcol]-p1->rad)); + } + p8=p8->next; + } + p3=p3->next; + } + break; + } + case 14: //机组无功备用最大 + { x=0; + for(i=1;i<=common->rqg;i++) //-w*(QGimax-QGi) + x=x-common->wqg[i]*(common->gmax[common->rp+i]-common->varx[common->rp+i]); + break; + } + case 15: //机组有功调节最小 + { x=0; + for(i=1;i<=common->rpg;i++) //w*(PGi-PGi0)*(PGi-PGi0) + x=x+common->wpg[i]*(common->varx[i]-common->pg[common->gp[i]])*(common->varx[i]-common->pg[common->gp[i]]); + break; + } + case 16: //机组无功调节最小 + { x=0; + for(i=1;i<=common->rqg;i++) //w*(QGi-QGi0)*(QGi-QGi0) + x=x+common->wqg[i]*(common->varx[common->rp+i]-common->qg[common->gq[i]])*(common->varx[common->rp+i]-common->qg[common->gq[i]]); + break; + } + default: //其他情况 + { +// x=0; + break; + } + } + free(spg); + free(sqg); + return x; +} + +double CalNetLoss(opf_common *common) //计算网络损耗 +{ + int i; + double x,r; + int *spg,*sqg; //临时变量 + + opf_vpdqd *p2; + + spg=(int *)malloc((common->n_sum+1)*sizeof(int));//为了同一个节点有多台发电机的情况 + sqg=(int *)malloc((common->n_sum+1)*sizeof(int)); + + + + x=0; //有功网损PG-PD + for(i=1;i<=common->n_sum;i++) + { x=x+common->pg[i]-common->pd[i]; + spg[i]=0; //可变有功标志 + } + + for(i=1;i<=common->rpg;i++) + { x=x+common->varx[i]; + spg[common->gp[i]]=spg[common->gp[i]]+1; + } + for(i=1;i<=common->n_sum;i++) + if(spg[i]!=0) + x=x-common->pg[i]; + + + for(i=1;i<=common->rpd;i++) //负荷的线性模型 + x=x-common->varx[common->rpg+common->rpge+i]+common->pd[common->gp[common->rpg+common->rpge+i]]; + p2=common->head_vpd; //有功负荷模型(与线性模型不一起出现) + while(p2!=null) + { r=p2->a*common->v[p2->i]*common->v[p2->i]+p2->b*common->v[p2->i]+p2->c; + x=x-r+common->pd[p2->i]; + p2=p2->next; + } + + free(spg); + free(sqg); + return x; +} + +void CalIntPG(opf_common *common) //机组出力归整 +{ + int i; + double sumpg,sumpg0; + double x,r; + + sumpg0=0; + for(i=1;i<=common->rpg;i++) + { sumpg0=sumpg0+common->varx[i]; + common->pg_int[i]=common->varx[i]; + } + for(i=1;i<=common->rpg;i++) + { if(((common->gmax[i]*100)>=10)&&((common->gmax[i]*100)<100)) //直接四舍五入到个位 + { common->pg_int[i]=(floor(common->pg_int[i]*100+0.5))/100; + if(common->pg_int[i]>common->gmax[i]) + common->pg_int[i]=common->gmax[i]; + } + if((common->gmax[i]*100)>=100) //直接四舍五入到十位 + { common->pg_int[i]=(floor((common->pg_int[i]/10)*100+0.5)*10)/100; + if(common->pg_int[i]>common->gmax[i]) + common->pg_int[i]=common->gmax[i]; + } + } + sumpg=0; + for(i=1;i<=common->rpg;i++) + sumpg=sumpg+common->pg_int[i]; + + return; +} + +/******形成雅可比矩阵稀疏表（竖着排）******/ +void JcbMatrix(opf_common *common,opf_correct *correct) +{ + int i,j,m,n,t; + + opf_yij *p1; + opf_matrix *p3,*p4,*p5; + opf_kij *p6; + opf_slack *p7; + opf_vpdqd *p2; + opf_gij *p8; + opf_line *p9; + opf_dcbus *p10,*p11; + opf_equalitykij *p12; + + int kk; + + for(i=1;i<=common->rr-common->rv+2*common->n_sum;i++) //释放空间 + { while(correct->jcb[i]!=null) + { p3=correct->jcb[i]->next; + free(correct->jcb[i]); + correct->jcb[i]=p3; + } + } + + m=common->rr-common->rv; + for(i=1;i<=common->rpg+common->rpge;i++) //有功出力部分 + { p3=(opf_matrix *)malloc(lematrix); + p3->irow=common->gp[i]*2-1; + p3->jcol=i; + p3->z=1; + p3->next=null; + correct->jcb[p3->jcol]=p3; + } + for(i=1;i<=common->rpd;i++) //有功负荷部分 + { p3=(opf_matrix *)malloc(lematrix); + p3->irow=common->gp[common->rpg+common->rpge+i]*2-1; + p3->jcol=i+common->rpg+common->rpge; + p3->z=-1; + p3->next=null; + correct->jcb[p3->jcol]=p3; + } + for(i=1;i<=common->rqg+common->rqge;i++) //无功出力部分 + { p3=(opf_matrix *)malloc(lematrix); + p3->irow=common->gq[i]*2; + p3->jcol=i+common->rp; + p3->z=1; + p3->next=null; + correct->jcb[p3->jcol]=p3; + } + for(i=1;i<=common->rqd;i++) //无功负荷部分 + { p3=(opf_matrix *)malloc(lematrix); + p3->irow=common->gq[common->rqg+common->rqge+i]*2; + p3->jcol=i+common->rp+common->rqg+common->rpge; + p3->z=-1; + p3->next=null; + correct->jcb[p3->jcol]=p3; + } + + n=common->rp+common->rq; + p6=common->head_kij; //可调变压器变比部分（只是定位置） + i=1; + while(p6!=null) + { p3=(opf_matrix *)malloc(lematrix); + p3->irow=p6->i*2-1; // aPi/akij + p3->jcol=n+i; + p3->z=1; + correct->jcb[p3->jcol]=insert2(correct->jcb[p3->jcol],p3,&kk); + if(kk==1) + free(p3); + + p3=(opf_matrix *)malloc(lematrix); + p3->irow=p6->j*2-1; // aPj/akij + p3->jcol=n+i; + p3->z=1; + correct->jcb[p3->jcol]=insert2(correct->jcb[p3->jcol],p3,&kk); + if(kk==1) + free(p3); + + p3=(opf_matrix *)malloc(lematrix); + p3->irow=p6->i*2; // aQi/akij + p3->jcol=n+i; + p3->z=1; + correct->jcb[p3->jcol]=insert2(correct->jcb[p3->jcol],p3,&kk); + if(kk==1) + free(p3); + + p3=(opf_matrix *)malloc(lematrix); + p3->irow=p6->j*2; // aQj/akij + p3->jcol=n+i; + p3->z=1; + correct->jcb[p3->jcol]=insert2(correct->jcb[p3->jcol],p3,&kk); + if(kk==1) + free(p3); + + i=i+1; + p6=p6->next; + } + + n=common->rp+common->rq+common->rk; + p6=common->head_kbij; //可调移相器器变比部分（只是定位置） + i=1; + while(p6!=null) + { p3=(opf_matrix *)malloc(lematrix); + p3->irow=p6->i*2-1; // aPi/akij + p3->jcol=n+i; + p3->z=1; + correct->jcb[p3->jcol]=insert2(correct->jcb[p3->jcol],p3,&kk); + if(kk==1) + free(p3); + + p3=(opf_matrix *)malloc(lematrix); + p3->irow=p6->j*2-1; // aPj/akij + p3->jcol=n+i; + p3->z=1; + correct->jcb[p3->jcol]=insert2(correct->jcb[p3->jcol],p3,&kk); + if(kk==1) + free(p3); + + p3=(opf_matrix *)malloc(lematrix); + p3->irow=p6->i*2; // aQi/akij + p3->jcol=n+i; + p3->z=1; + correct->jcb[p3->jcol]=insert2(correct->jcb[p3->jcol],p3,&kk); + if(kk==1) + free(p3); + + p3=(opf_matrix *)malloc(lematrix); + p3->irow=p6->j*2; // aQj/akij + p3->jcol=n+i; + p3->z=1; + correct->jcb[p3->jcol]=insert2(correct->jcb[p3->jcol],p3,&kk); + if(kk==1) + free(p3); + + p3=(opf_matrix *)malloc(lematrix); + p3->irow=p6->i*2-1; // aPi/abij + p3->jcol=n+i+common->rkb; + p3->z=1; + correct->jcb[p3->jcol]=insert2(correct->jcb[p3->jcol],p3,&kk); + if(kk==1) + free(p3); + + p3=(opf_matrix *)malloc(lematrix); + p3->irow=p6->j*2-1; // aPj/abij + p3->jcol=n+i+common->rkb; + p3->z=1; + correct->jcb[p3->jcol]=insert2(correct->jcb[p3->jcol],p3,&kk); + if(kk==1) + free(p3); + + p3=(opf_matrix *)malloc(lematrix); + p3->irow=p6->i*2; // aQi/abij + p3->jcol=n+i+common->rkb; + p3->z=1; + correct->jcb[p3->jcol]=insert2(correct->jcb[p3->jcol],p3,&kk); + if(kk==1) + free(p3); + + p3=(opf_matrix *)malloc(lematrix); + p3->irow=p6->j*2; // aQj/abij + p3->jcol=n+i+common->rkb; + p3->z=1; + correct->jcb[p3->jcol]=insert2(correct->jcb[p3->jcol],p3,&kk); + if(kk==1) + free(p3); + + i=i+1; + p6=p6->next; + } + + n=common->rp+common->rq+common->rk+2*common->rkb; + p6=common->head_ti; //可调电容器部分（只是定位置） + i=1; + while(p6!=null) + { p3=(opf_matrix *)malloc(lematrix); + p3->irow=p6->i*2-1; // aPi/ati + p3->jcol=n+i; + p3->z=1; + correct->jcb[p3->jcol]=insert2(correct->jcb[p3->jcol],p3,&kk); + if(kk==1) + free(p3); + + p3=(opf_matrix *)malloc(lematrix); + p3->irow=p6->i*2; // aQi/ati + p3->jcol=n+i; + p3->z=1; + correct->jcb[p3->jcol]=insert2(correct->jcb[p3->jcol],p3,&kk); + if(kk==1) + free(p3); + + i=i+1; + p6=p6->next; + } + + n=common->rp+common->rq+common->rk+2*common->rkb+common->rt; + p6=common->head_kx; //可调线路电抗部分（只是定位置） + i=1; + while(p6!=null) + { p3=(opf_matrix *)malloc(lematrix); + p3->irow=p6->i*2-1; // aPi/akxij + p3->jcol=n+i; + p3->z=1; + correct->jcb[p3->jcol]=insert2(correct->jcb[p3->jcol],p3,&kk); + if(kk==1) + free(p3); + + p3=(opf_matrix *)malloc(lematrix); + p3->irow=p6->j*2-1; // aPj/akxij + p3->jcol=n+i; + p3->z=1; + correct->jcb[p3->jcol]=insert2(correct->jcb[p3->jcol],p3,&kk); + if(kk==1) + free(p3); + + p3=(opf_matrix *)malloc(lematrix); + p3->irow=p6->i*2; // aQi/akxij + p3->jcol=n+i; + p3->z=1; + correct->jcb[p3->jcol]=insert2(correct->jcb[p3->jcol],p3,&kk); + if(kk==1) + free(p3); + + p3=(opf_matrix *)malloc(lematrix); + p3->irow=p6->j*2; // aQj/akxij + p3->jcol=n+i; + p3->z=1; + correct->jcb[p3->jcol]=insert2(correct->jcb[p3->jcol],p3,&kk); + if(kk==1) + free(p3); + + i=i+1; + p6=p6->next; + } + + for(i=1;i<=common->n_sum;i++) //（只是定位置）潮流功率方程 + { p1=common->a[i]; + j=0; + if(p1!=null) + { while((p1->irow==i)&&(j==0)) + { p3=(opf_matrix *)malloc(lematrix); //Hij,Nij + p4=(opf_matrix *)malloc(lematrix); + p3->irow=p1->irow*2-1; + p4->irow=p1->irow*2-1; + p3->jcol=m+p1->jcol*2-1; + p4->jcol=m+p1->jcol*2; + p3->z=1; + p4->z=1; + correct->jcb[p3->jcol]=insert2(correct->jcb[p3->jcol],p3,&kk); + correct->jcb[p4->jcol]=insert2(correct->jcb[p4->jcol],p4,&kk); + if(p1->next==null) + j=1; + else + p1=p1->next; + } + } + j=0; + p1=common->a[i]; + if(p1!=null) + { while((p1->irow==i)&&(j==0)) + { p3=(opf_matrix *)malloc(lematrix); //Jij,Lij + p4=(opf_matrix *)malloc(lematrix); + p3->irow=p4->irow=p1->irow*2; + p3->jcol=m+p1->jcol*2-1; + p4->jcol=m+p1->jcol*2; + p3->z=1; + p4->z=1; + correct->jcb[p3->jcol]=insert2(correct->jcb[p3->jcol],p3,&kk); + correct->jcb[p4->jcol]=insert2(correct->jcb[p4->jcol],p4,&kk); + if(p1->next==null) + j=1; + else + p1=p1->next; + } + } + p3=(opf_matrix *)malloc(lematrix); //Hii + p3->irow=2*i-1; + p3->jcol=m+2*i-1; + p3->z=1; + correct->jcb[p3->jcol]=insert2(correct->jcb[p3->jcol],p3,&kk); + p3=(opf_matrix *)malloc(lematrix); //Lii + p3->irow=2*i; + p3->jcol=m+2*i; + p3->z=1; + correct->jcb[p3->jcol]=insert2(correct->jcb[p3->jcol],p3,&kk); + p3=(opf_matrix *)malloc(lematrix); //Nii + p3->irow=2*i-1; + p3->jcol=m+2*i; + p3->z=1; + correct->jcb[p3->jcol]=insert2(correct->jcb[p3->jcol],p3,&kk); + p3=(opf_matrix *)malloc(lematrix); //Jii + p3->irow=2*i; + p3->jcol=m+2*i-1; + p3->z=1; + correct->jcb[p3->jcol]=insert2(correct->jcb[p3->jcol],p3,&kk); + } + + p2=common->head_vpd; //有功负荷模型的一阶偏导 (-PDi)潮流功率方程 + while(p2!=null) + { p3=(opf_matrix *)malloc(lematrix); + p3->irow=p2->i*2-1; // aPDi/aVi + p3->jcol=common->rr-common->rv+p2->i*2; + p3->z=1; + correct->jcb[p3->jcol]=insert2(correct->jcb[p3->jcol],p3,&kk); + if(kk==1) + free(p3); + p2=p2->next; + } + + p2=common->head_vqd; //无功负荷模型的一阶偏导 (-QDi)潮流功率方程 + while(p2!=null) + { p3=(opf_matrix *)malloc(lematrix); + p3->irow=p2->i*2; // aQDi/aVi + p3->jcol=common->rr-common->rv+p2->i*2; + p3->z=1; + correct->jcb[p3->jcol]=insert2(correct->jcb[p3->jcol],p3,&kk); + if(kk==1) + free(p3); + p2=p2->next; + } + + n=common->n_sum*2; + i=1; + p8=common->head_lcos; //联络线功率因数的一阶偏导，联络线功率因数的等式约束，转换成两个等式约束 + while(p8!=null) + { + p1=common->a[p8->i]; + j=0; + while((p1!=null)&&(j==0)) + { if((p1->irow==p8->i)&&(p1->jcol==p8->j)) + j=1; + else + p1=p1->next; + } + + if(p1!=null) + { p3=(opf_matrix *)malloc(lematrix); + p3->irow=n+i; // aPij/a&i + p3->jcol=common->rr-common->rv+p8->i*2-1; + p3->z=1; + correct->jcb[p3->jcol]=insert2(correct->jcb[p3->jcol],p3,&kk); + if(kk==1) + free(p3); + + p3=(opf_matrix *)malloc(lematrix); + p3->irow=n+i; // aPij/aVi + p3->jcol=common->rr-common->rv+p8->i*2; + p3->z=1; + correct->jcb[p3->jcol]=insert2(correct->jcb[p3->jcol],p3,&kk); + if(kk==1) + free(p3); + + p3=(opf_matrix *)malloc(lematrix); + p3->irow=n+i; // aPij/a&j + p3->jcol=common->rr-common->rv+p8->j*2-1; + p3->z=1; + correct->jcb[p3->jcol]=insert2(correct->jcb[p3->jcol],p3,&kk); + if(kk==1) + free(p3); + + p3=(opf_matrix *)malloc(lematrix); + p3->irow=n+i; // aPij/aVj + p3->jcol=common->rr-common->rv+p8->j*2; + p3->z=1; + correct->jcb[p3->jcol]=insert2(correct->jcb[p3->jcol],p3,&kk); + if(kk==1) + free(p3); + + p3=(opf_matrix *)malloc(lematrix); + p3->irow=n+i; // aPij/aPij + p3->jcol=common->rp+common->rq+common->rk+2*common->rkb+common->rt+common->rx+i; + p3->z=1; + correct->jcb[p3->jcol]=insert2(correct->jcb[p3->jcol],p3,&kk); + if(kk==1) + free(p3); + + p3=(opf_matrix *)malloc(lematrix); + p3->irow=n+i+common->rlcos; // aQij/a&i + p3->jcol=common->rr-common->rv+p8->i*2-1; + p3->z=1; + correct->jcb[p3->jcol]=insert2(correct->jcb[p3->jcol],p3,&kk); + if(kk==1) + free(p3); + + p3=(opf_matrix *)malloc(lematrix); + p3->irow=n+i+common->rlcos; // aQij/aVi + p3->jcol=common->rr-common->rv+p8->i*2; + p3->z=1; + correct->jcb[p3->jcol]=insert2(correct->jcb[p3->jcol],p3,&kk); + if(kk==1) + free(p3); + + p3=(opf_matrix *)malloc(lematrix); + p3->irow=n+i+common->rlcos; // aQij/a&j + p3->jcol=common->rr-common->rv+p8->j*2-1; + p3->z=1; + correct->jcb[p3->jcol]=insert2(correct->jcb[p3->jcol],p3,&kk); + if(kk==1) + free(p3); + + p3=(opf_matrix *)malloc(lematrix); + p3->irow=n+i+common->rlcos; // aQij/aVj + p3->jcol=common->rr-common->rv+p8->j*2; + p3->z=1; + correct->jcb[p3->jcol]=insert2(correct->jcb[p3->jcol],p3,&kk); + if(kk==1) + free(p3); + + p3=(opf_matrix *)malloc(lematrix); + p3->irow=n+i+common->rlcos; // aQij/aQij + p3->jcol=common->rp+common->rq+common->rk+2*common->rkb+common->rt+common->rx+i+common->rlcos; + p3->z=1; + correct->jcb[p3->jcol]=insert2(correct->jcb[p3->jcol],p3,&kk); + if(kk==1) + free(p3); + + } + + i=i+1; + p8=p8->next; + } + + n=common->n_sum*2+2*common->rlcos; + i=1; + p8=common->head_vdcos; //负荷模型功率因数的一阶偏导，负荷模型功率因数的等式约束 + while(p8!=null) + { p3=(opf_matrix *)malloc(lematrix); + p3->irow=n+i; // acosDi/aVi + p3->jcol=common->rr-common->rv+p8->i*2; + p3->z=1; + correct->jcb[p3->jcol]=insert2(correct->jcb[p3->jcol],p3,&kk); + if(kk==1) + free(p3); + + p3=(opf_matrix *)malloc(lematrix); + p3->irow=n+i; // acosDi/acosDi + p3->jcol=common->rp+common->rq+common->rk+2*common->rkb+common->rt+common->rx+2*common->rlcos+i; + p3->z=1; + correct->jcb[p3->jcol]=insert2(correct->jcb[p3->jcol],p3,&kk); + if(kk==1) + free(p3); + + i=i+1; + p8=p8->next; + } + + i=1; + n=common->n_sum*2+2*common->rlcos+common->rvdcos; + m=common->rp+common->rq+common->rk+2*common->rkb+common->rt+common->rx+2*common->rlcos+common->rvdcos; + p10=common->head_dcbus; //直流部分 + while(p10!=null) + { p3=(opf_matrix *)malloc(lematrix); //潮流方程P + p3->irow=2*p10->iac-1; //aP/aVd + p3->jcol=m+i; + p3->z=1; + correct->jcb[p3->jcol]=insert2(correct->jcb[p3->jcol],p3,&kk); + if(kk==1) + free(p3); + + p3=(opf_matrix *)malloc(lematrix); //潮流方程P + p3->irow=2*p10->iac-1; //aP/aId + p3->jcol=m+i+common->n_dc; + p3->z=1; + correct->jcb[p3->jcol]=insert2(correct->jcb[p3->jcol],p3,&kk); + if(kk==1) + free(p3); + + p3=(opf_matrix *)malloc(lematrix); //潮流方程Q + p3->irow=2*p10->iac; //aQ/aVd + p3->jcol=m+i; + p3->z=1; + correct->jcb[p3->jcol]=insert2(correct->jcb[p3->jcol],p3,&kk); + if(kk==1) + free(p3); + + p3=(opf_matrix *)malloc(lematrix); //潮流方程Q + p3->irow=2*p10->iac; //aQ/aId + p3->jcol=m+i+common->n_dc; + p3->z=1; + correct->jcb[p3->jcol]=insert2(correct->jcb[p3->jcol],p3,&kk); + if(kk==1) + free(p3); + + p3=(opf_matrix *)malloc(lematrix); //潮流方程Q + p3->irow=2*p10->iac; //aQ/afar + p3->jcol=m+i+4*common->n_dc; + p3->z=1; + correct->jcb[p3->jcol]=insert2(correct->jcb[p3->jcol],p3,&kk); + if(kk==1) + free(p3); + + p3=(opf_matrix *)malloc(lematrix); //直流方程d1 + p3->irow=n+i; // ad1/aVd + p3->jcol=m+i; + p3->z=1; + correct->jcb[p3->jcol]=insert2(correct->jcb[p3->jcol],p3,&kk); + if(kk==1) + free(p3); + + p3=(opf_matrix *)malloc(lematrix); //直流方程d1 + p3->irow=n+i; // ad1/akd + p3->jcol=m+i+2*common->n_dc; + p3->z=1; + correct->jcb[p3->jcol]=insert2(correct->jcb[p3->jcol],p3,&kk); + if(kk==1) + free(p3); + + p3=(opf_matrix *)malloc(lematrix); //直流方程d1 + p3->irow=n+i; // ad1/aV + p3->jcol=common->rr-common->rv+p10->iac*2; + p3->z=1; + correct->jcb[p3->jcol]=insert2(correct->jcb[p3->jcol],p3,&kk); + if(kk==1) + free(p3); + + p3=(opf_matrix *)malloc(lematrix); //直流方程d1 + p3->irow=n+i; // ad1/acos + p3->jcol=m+i+3*common->n_dc; + p3->z=1; + correct->jcb[p3->jcol]=insert2(correct->jcb[p3->jcol],p3,&kk); + if(kk==1) + free(p3); + + p3=(opf_matrix *)malloc(lematrix); //直流方程d1 + p3->irow=n+i; // ad1/aId + p3->jcol=m+i+common->n_dc; + p3->z=1; + correct->jcb[p3->jcol]=insert2(correct->jcb[p3->jcol],p3,&kk); + if(kk==1) + free(p3); + + p3=(opf_matrix *)malloc(lematrix); //直流方程d2 + p3->irow=n+i+common->n_dc; // ad2/aVd + p3->jcol=m+i; + p3->z=1; + correct->jcb[p3->jcol]=insert2(correct->jcb[p3->jcol],p3,&kk); + if(kk==1) + free(p3); + + p3=(opf_matrix *)malloc(lematrix); //直流方程d2 + p3->irow=n+i+common->n_dc; // ad2/akd + p3->jcol=m+i+2*common->n_dc; + p3->z=1; + correct->jcb[p3->jcol]=insert2(correct->jcb[p3->jcol],p3,&kk); + if(kk==1) + free(p3); + + p3=(opf_matrix *)malloc(lematrix); //直流方程d2 + p3->irow=n+i+common->n_dc; // ad2/aV + p3->jcol=common->rr-common->rv+p10->iac*2; + p3->z=1; + correct->jcb[p3->jcol]=insert2(correct->jcb[p3->jcol],p3,&kk); + if(kk==1) + free(p3); + + p3=(opf_matrix *)malloc(lematrix); //直流方程d2 + p3->irow=n+i+common->n_dc; // ad2/afar + p3->jcol=m+i+4*common->n_dc; + p3->z=1; + correct->jcb[p3->jcol]=insert2(correct->jcb[p3->jcol],p3,&kk); + if(kk==1) + free(p3); + + p3=(opf_matrix *)malloc(lematrix); //直流方程d3 + p3->irow=n+i+2*common->n_dc; // ad3/aId + p3->jcol=m+i+common->n_dc; + p3->z=1; + correct->jcb[p3->jcol]=insert2(correct->jcb[p3->jcol],p3,&kk); + if(kk==1) + free(p3); + + p9=common->head_dclij; + while(p9!=null) + { if((p9->i==p10->i)||(p9->j==p10->i)) + { if(p9->i==p10->i) + { p11=common->head_dcbus; + t=1; + j=0; + while((p11!=null)&&(j==0)) + { if(p11->i==p9->j) + j=1; + t=t+1; + p11=p11->next; + } + t=t-1; + } + else + { p11=common->head_dcbus; + t=1; + j=0; + while((p11!=null)&&(j==0)) + { if(p11->i==p9->i) + j=1; + t=t+1; + p11=p11->next; + } + t=t-1; + } + + p3=(opf_matrix *)malloc(lematrix); //直流方程d3 + p3->irow=n+i+2*common->n_dc; // ad3/aVdj + p3->jcol=m+t; + p3->z=1; + correct->jcb[p3->jcol]=insert2(correct->jcb[p3->jcol],p3,&kk); + if(kk==1) + free(p3); + + p3=(opf_matrix *)malloc(lematrix); //直流方程d3 + p3->irow=n+i+2*common->n_dc; // ad3/aVdi + p3->jcol=m+i; + p3->z=1; + correct->jcb[p3->jcol]=insert2(correct->jcb[p3->jcol],p3,&kk); + if(kk==1) + free(p3); + + } + p9=p9->next; + } + + i=i+1; + p10=p10->next; + } + + m=common->rp+common->rq; + n=common->n_sum*2+2*common->rlcos+common->rvdcos+3*common->n_dc; + i=1; + p12=common->head_eqkij; + while(p12!=null) + { p3=(opf_matrix *)malloc(lematrix); //等变比可调 k1-k2=0 + p3->irow=n+i; //等式 + p3->jcol=m+p12->i; //变量 + p3->z=1; + correct->jcb[p3->jcol]=insert2(correct->jcb[p3->jcol],p3,&kk); + if(kk==1) + free(p3); + + p3=(opf_matrix *)malloc(lematrix); //等变比可调 k1-k2=0 + p3->irow=n+i; //等式 + p3->jcol=m+p12->j; //变量 + p3->z=-1; + correct->jcb[p3->jcol]=insert2(correct->jcb[p3->jcol],p3,&kk); + if(kk==1) + free(p3); + + i=i+1; + p12=p12->next; + } + + m=common->rp+common->rq+common->rk+2*common->rkb+common->rt+common->rx+2*common->rlcos+common->rvdcos+5*common->n_dc; + p7=common->head_slack; + while(p7!=null) + { while(correct->jcb[m+2*p7->i-1]!=null) //处理平衡节点，相角不参加迭代 + { p5=correct->jcb[m+2*p7->i-1]->next; //释放指针 + free(correct->jcb[m+2*p7->i-1]); + correct->jcb[m+2*p7->i-1]=p5; + } + if(common->slack_flag==1) //=1将平衡点做为一般点参加迭代，否则不参加迭代 + { while(correct->jcb[m+2*p7->i]!=null) //处理平衡节点，幅值 + { p5=correct->jcb[m+2*p7->i]->next; + free(correct->jcb[m+2*p7->i]); + correct->jcb[m+2*p7->i]=p5; + } + } + p7=p7->next; + } + + +/* + FILE *fp1; + fp1=fopen("Text3.txt","wb"); + for(i=1;i<=common->rr-common->rv+2*common->n_sum;i++) + { p3=correct->jcb[i]; + while(p3!=null) + { fprintf(fp1," %d, %d, %f\n" ,p3->irow,p3->jcol,p3->z); + p3=p3->next; + } + } + fclose(fp1); +*/ + + return; +} + +/******矩阵插入函数******/ +opf_matrix *insert2(opf_matrix *tp,opf_matrix *z,int *k) +{ opf_matrix *p0,*p111,*p112; + + *k=0; + p111=tp; + p0=z; + if(p0==null) + return(tp); + if(tp==null) + { tp=p0; + p0->next=null; + return(tp); + } + if(p0->irowirow) + { tp=p0; + p0->next=p111; + return(tp); + } + + while((p0->irow>p111->irow)&&(p111->next!=null)) + { p112=p111; + p111=p111->next; + } + + + if(p0->irow==p111->irow) //相同的进行累加 + { + p111->z=p111->z+p0->z; + *k=1; + return(tp); + } + + if((p111->next==null)&&(p0->irow>p111->irow)) + { p111->next=p0; + p0->next=null; + } + else + { p112->next=p0; + p0->next=p111; + } + return(tp); +} + +/******形成海森矩阵稀疏表（竖着排）下三角******/ +void HeisenMatrix(opf_common *common,opf_correct *correct) +{ + int i,j,t,m,n,ii,tn,tm; + + opf_yij *p1; + opf_matrix *p3,*p2,*p4,*p5; + opf_kij *p6; + opf_slack *p7; + opf_gij *p8; + opf_dcbus *p10; + opf_equalitykij *p12; + + int kk; + int hnsum; + + + t=common->rr-common->rv; //求H的海森矩阵 + hnsum=common->rr-common->rv+4*common->n_sum+common->req; + + for(i=1;i<=hnsum;i++) + { while(correct->heisen[i]!=null) + { p3=correct->heisen[i]->next; + free(correct->heisen[i]); + correct->heisen[i]=p3; + } + } + + p2=(opf_matrix *)malloc(lematrix); //潮流方程等式约束 + for(i=1;i<=common->n_sum;i++) + { p1=common->a[i]; + j=0; + if(p1!=null) + { while((p1->irow==i)&&(j==0)) //只保存下三角 + { +// hasin[t+4*p1->jcol-3][t+4*p1->irow-3]+=1; + p2->irow=t+4*p1->jcol-3; + p2->jcol=t+4*p1->irow-3; + p2->z=1; + if(p2->irow>p2->jcol) + { correct->heisen[p2->jcol]=insert2(correct->heisen[p2->jcol],p2,&kk); + if(kk==0) + p2=(opf_matrix *)malloc(lematrix); + } + +// hasin[t+4*p1->irow-3][t+4*p1->jcol-3]+=1; + p2->irow=t+4*p1->irow-3; + p2->jcol=t+4*p1->jcol-3; + p2->z=1; + if(p2->irow>p2->jcol) + { correct->heisen[p2->jcol]=insert2(correct->heisen[p2->jcol],p2,&kk); + if(kk==0) + p2=(opf_matrix *)malloc(lematrix); + } + +// hasin[t+4*p1->jcol-3][t+4*p1->irow-2]+=1; + p2->irow=t+4*p1->jcol-3; + p2->jcol=t+4*p1->irow-2; + p2->z=1; + if(p2->irow>p2->jcol) + { correct->heisen[p2->jcol]=insert2(correct->heisen[p2->jcol],p2,&kk); + if(kk==0) + p2=(opf_matrix *)malloc(lematrix); + } + +// hasin[t+4*p1->irow-3][t+4*p1->jcol-2]+=1; + p2->irow=t+4*p1->irow-3; + p2->jcol=t+4*p1->jcol-2; + p2->z=1; + if(p2->irow>p2->jcol) + { correct->heisen[p2->jcol]=insert2(correct->heisen[p2->jcol],p2,&kk); + if(kk==0) + p2=(opf_matrix *)malloc(lematrix); + } + +// hasin[t+4*p1->jcol-2][t+4*p1->irow-3]+=1; + p2->irow=t+4*p1->jcol-2; + p2->jcol=t+4*p1->irow-3; + p2->z=1; + if(p2->irow>p2->jcol) + { correct->heisen[p2->jcol]=insert2(correct->heisen[p2->jcol],p2,&kk); + if(kk==0) + p2=(opf_matrix *)malloc(lematrix); + } + +// hasin[t+4*p1->jcol-2][t+4*p1->irow-2]+=1; + p2->irow=t+4*p1->jcol-2; + p2->jcol=t+4*p1->irow-2; + p2->z=1; + if(p2->irow>p2->jcol) + { correct->heisen[p2->jcol]=insert2(correct->heisen[p2->jcol],p2,&kk); + if(kk==0) + p2=(opf_matrix *)malloc(lematrix); + } + + +// hasin[t+4*p1->irow-2][t+4*p1->jcol-3]+=1; + p2->irow=t+4*p1->irow-2; + p2->jcol=t+4*p1->jcol-3; + p2->z=1; + if(p2->irow>p2->jcol) + { correct->heisen[p2->jcol]=insert2(correct->heisen[p2->jcol],p2,&kk); + if(kk==0) + p2=(opf_matrix *)malloc(lematrix); + } + +// hasin[t+4*p1->irow-2][t+4*p1->jcol-2]+=1; + p2->irow=t+4*p1->irow-2; + p2->jcol=t+4*p1->jcol-2; + p2->z=1; + if(p2->irow>p2->jcol) + { correct->heisen[p2->jcol]=insert2(correct->heisen[p2->jcol],p2,&kk); + if(kk==0) + p2=(opf_matrix *)malloc(lematrix); + } + +// hasin[t+4*p1->irow-3][t+4*p1->irow-3]+=1; + p2->irow=t+4*p1->irow-3; + p2->jcol=t+4*p1->irow-3; + p2->z=1; + if(p2->irow>p2->jcol) + { correct->heisen[p2->jcol]=insert2(correct->heisen[p2->jcol],p2,&kk); + if(kk==0) + p2=(opf_matrix *)malloc(lematrix); + } + +// hasin[t+4*p1->irow-3][t+4*p1->irow-2]+=1; + p2->irow=t+4*p1->irow-3; + p2->jcol=t+4*p1->irow-2; + p2->z=1; + if(p2->irow>p2->jcol) + { correct->heisen[p2->jcol]=insert2(correct->heisen[p2->jcol],p2,&kk); + if(kk==0) + p2=(opf_matrix *)malloc(lematrix); + } + +// hasin[t+4*p1->irow-2][t+4*p1->irow-3]+=1; + p2->irow=t+4*p1->irow-2; + p2->jcol=t+4*p1->irow-3; + p2->z=1; + if(p2->irow>p2->jcol) + { correct->heisen[p2->jcol]=insert2(correct->heisen[p2->jcol],p2,&kk); + if(kk==0) + p2=(opf_matrix *)malloc(lematrix); + } + +// hasin[t+4*p1->irow-2][t+4*p1->irow-2]+=1; + p2->irow=t+4*p1->irow-2; + p2->jcol=t+4*p1->irow-2; + p2->z=1; + if(p2->irow>p2->jcol) + { correct->heisen[p2->jcol]=insert2(correct->heisen[p2->jcol],p2,&kk); + if(kk==0) + p2=(opf_matrix *)malloc(lematrix); + } + + if(p1->next==null) + j=1; + else + p1=p1->next; + } + } + } + + n=common->rp+common->rq; + t=common->rr-common->rv; //海森矩阵（潮流方程） + p6=common->head_kij; //可调变压器变比部分（定位置，只要算k那一列就可以了，列的行号都比列号大，行的都在后面，可不记） + i=1; + while(p6!=null) + { + p2->irow=t+p6->i*4-3; // a2Pi/akija&i + p2->jcol=n+i; + p2->z=1; + correct->heisen[p2->jcol]=insert2(correct->heisen[p2->jcol],p2,&kk); + if(kk==0) + p2=(opf_matrix *)malloc(lematrix); + + p2->irow=t+p6->i*4-2; // a2Pi/akijaVi + p2->jcol=n+i; + p2->z=1; + correct->heisen[p2->jcol]=insert2(correct->heisen[p2->jcol],p2,&kk); + if(kk==0) + p2=(opf_matrix *)malloc(lematrix); + + p2->irow=t+p6->j*4-3; // a2Pi/akija&j + p2->jcol=n+i; + p2->z=1; + correct->heisen[p2->jcol]=insert2(correct->heisen[p2->jcol],p2,&kk); + if(kk==0) + p2=(opf_matrix *)malloc(lematrix); + + p2->irow=t+p6->j*4-2; // a2Pi/akijaVj + p2->jcol=n+i; + p2->z=1; + correct->heisen[p2->jcol]=insert2(correct->heisen[p2->jcol],p2,&kk); + if(kk==0) + p2=(opf_matrix *)malloc(lematrix); + +// a2Qi/akija&i,a2Qi/akijaVi,a2Qi/akija&j,a2Qi/akijaVj 在位置上与pi部分重叠，不用计了 +// a2Pj和a2Qj 在位置上与pi部分重叠，不用计了 + + i=i+1; + p6=p6->next; + } + + n=common->rp+common->rq+common->rk; + t=common->rr-common->rv; //海森矩阵（潮流方程） + p6=common->head_kbij; //可调移相器变比部分（定位置，只要算k和b那一列就可以了，列的行号都比列号大，行的都在后面，可不记） + i=1; + while(p6!=null) + { + p2->irow=t+p6->i*4-3; // a2Pi/akija&i + p2->jcol=n+i; + p2->z=1; + correct->heisen[p2->jcol]=insert2(correct->heisen[p2->jcol],p2,&kk); + if(kk==0) + p2=(opf_matrix *)malloc(lematrix); + + p2->irow=t+p6->i*4-2; // a2Pi/akijaVi + p2->jcol=n+i; + p2->z=1; + correct->heisen[p2->jcol]=insert2(correct->heisen[p2->jcol],p2,&kk); + if(kk==0) + p2=(opf_matrix *)malloc(lematrix); + + p2->irow=t+p6->j*4-3; // a2Pi/akija&j + p2->jcol=n+i; + p2->z=1; + correct->heisen[p2->jcol]=insert2(correct->heisen[p2->jcol],p2,&kk); + if(kk==0) + p2=(opf_matrix *)malloc(lematrix); + + p2->irow=t+p6->j*4-2; // a2Pi/akijaVj + p2->jcol=n+i; + p2->z=1; + correct->heisen[p2->jcol]=insert2(correct->heisen[p2->jcol],p2,&kk); + if(kk==0) + p2=(opf_matrix *)malloc(lematrix); + + p2->irow=n+common->rkb+i; // a2Pi/akijabij + p2->jcol=n+i; + p2->z=1; + correct->heisen[p2->jcol]=insert2(correct->heisen[p2->jcol],p2,&kk); + if(kk==0) + p2=(opf_matrix *)malloc(lematrix); + + + // a2Qi/akija&i,a2Qi/akijaVi,a2Qi/akija&j,a2Qi/akijaVj 在位置上与pi部分重叠，不用计了 + // a2Pj和a2Qj 在位置上与pi部分重叠，不用计了 + + p2->irow=t+p6->i*4-3; // a2Pi/abija&i + p2->jcol=n+common->rkb+i; + p2->z=1; + correct->heisen[p2->jcol]=insert2(correct->heisen[p2->jcol],p2,&kk); + if(kk==0) + p2=(opf_matrix *)malloc(lematrix); + + p2->irow=t+p6->i*4-2; // a2Pi/abijaVi + p2->jcol=n+common->rkb+i; + p2->z=1; + correct->heisen[p2->jcol]=insert2(correct->heisen[p2->jcol],p2,&kk); + if(kk==0) + p2=(opf_matrix *)malloc(lematrix); + + p2->irow=t+p6->j*4-3; // a2Pi/abija&j + p2->jcol=n+common->rkb+i; + p2->z=1; + correct->heisen[p2->jcol]=insert2(correct->heisen[p2->jcol],p2,&kk); + if(kk==0) + p2=(opf_matrix *)malloc(lematrix); + + p2->irow=t+p6->j*4-2; // a2Pi/abijaVj + p2->jcol=n+common->rkb+i; + p2->z=1; + correct->heisen[p2->jcol]=insert2(correct->heisen[p2->jcol],p2,&kk); + if(kk==0) + p2=(opf_matrix *)malloc(lematrix); + + p2->irow=n+i; // a2Pi/abijakij + p2->jcol=n+common->rkb+i; + p2->z=1; + correct->heisen[p2->jcol]=insert2(correct->heisen[p2->jcol],p2,&kk); + if(kk==0) + p2=(opf_matrix *)malloc(lematrix); + + + // a2Qi/abija&i,a2Qi/abijaVi,a2Qi/abija&j,a2Qi/abijaVj 在位置上与pi部分重叠，不用计了 + // a2Pj和a2Qj 在位置上与pi部分重叠，不用计了 + + i=i+1; + p6=p6->next; + } + + n=common->rp+common->rq+common->rk+2*common->rkb; + t=common->rr-common->rv; //海森阵（潮流方程） + p6=common->head_ti; //可调电容器部分（定位置，只要算t那一列就可以了，列的行号都比列号大，行的都在后面，可不记） + i=1; + while(p6!=null) + { + p2->irow=t+p6->i*4-2; // a2Pi/atiaVi + p2->jcol=n+i; + p2->z=1; + correct->heisen[p2->jcol]=insert2(correct->heisen[p2->jcol],p2,&kk); + if(kk==0) + p2=(opf_matrix *)malloc(lematrix); + + // a2Qi/atiaVi 在位置上与pi部分重叠，不用计了 + i=i+1; + p6=p6->next; + } + + n=common->rp+common->rq+common->rk+2*common->rkb+common->rt; + t=common->rr-common->rv; //海森矩阵（潮流方程） + p6=common->head_kx; //可调线路电抗部分（定位置，只要算k那一列就可以了，列的行号都比列号大，行的都在后面，可不记） + i=1; + while(p6!=null) + { + p2->irow=t+p6->i*4-3; // a2Pi/akxija&i + p2->jcol=n+i; + p2->z=1; + correct->heisen[p2->jcol]=insert2(correct->heisen[p2->jcol],p2,&kk); + if(kk==0) + p2=(opf_matrix *)malloc(lematrix); + + p2->irow=t+p6->i*4-2; // a2Pi/akxijaVi + p2->jcol=n+i; + p2->z=1; + correct->heisen[p2->jcol]=insert2(correct->heisen[p2->jcol],p2,&kk); + if(kk==0) + p2=(opf_matrix *)malloc(lematrix); + + p2->irow=t+p6->j*4-3; // a2Pi/akxija&j + p2->jcol=n+i; + p2->z=1; + correct->heisen[p2->jcol]=insert2(correct->heisen[p2->jcol],p2,&kk); + if(kk==0) + p2=(opf_matrix *)malloc(lematrix); + + p2->irow=t+p6->j*4-2; // a2Pi/akxijaVj + p2->jcol=n+i; + p2->z=1; + correct->heisen[p2->jcol]=insert2(correct->heisen[p2->jcol],p2,&kk); + if(kk==0) + p2=(opf_matrix *)malloc(lematrix); + + // a2Qi/akija&i,a2Qi/akijaVi,a2Qi/akija&j,a2Qi/akijaVj 在位置上与pi部分重叠，不用计了 + // a2Pj和a2Qj 在位置上与pi部分重叠，不用计了 + + i=i+1; + p6=p6->next; + } + + n=common->rp+common->rq+common->rk+2*common->rkb+common->rt+common->rx+2*common->rlcos+common->rvdcos; + t=common->rr-common->rv; //海森矩阵（潮流方程、直流方程） + p10=common->head_dcbus; //直流节点部分 + i=1; + while(p10!=null) + { + p2->irow=n+i+common->n_dc; // a2Pi/aIdaVd + p2->jcol=n+i; + p2->z=1; + correct->heisen[p2->jcol]=insert2(correct->heisen[p2->jcol],p2,&kk); + if(kk==0) + p2=(opf_matrix *)malloc(lematrix); + + p2->irow=n+i+4*common->n_dc; // a2Qi/afaraVd + p2->jcol=n+i; + p2->z=1; + correct->heisen[p2->jcol]=insert2(correct->heisen[p2->jcol],p2,&kk); + if(kk==0) + p2=(opf_matrix *)malloc(lematrix); + + p2->irow=n+i+4*common->n_dc; // a2Qi/afaraId + p2->jcol=n+i+common->n_dc; + p2->z=1; + correct->heisen[p2->jcol]=insert2(correct->heisen[p2->jcol],p2,&kk); + if(kk==0) + p2=(opf_matrix *)malloc(lematrix); + + p2->irow=n+i+4*common->n_dc; // a2Qi/afarafar + p2->jcol=n+i+4*common->n_dc; + p2->z=1; + correct->heisen[p2->jcol]=insert2(correct->heisen[p2->jcol],p2,&kk); + if(kk==0) + p2=(opf_matrix *)malloc(lematrix); + + p2->irow=t+p10->iac*4-2; // a2d1/aViak + p2->jcol=n+i+2*common->n_dc; + p2->z=1; + correct->heisen[p2->jcol]=insert2(correct->heisen[p2->jcol],p2,&kk); + if(kk==0) + p2=(opf_matrix *)malloc(lematrix); + + p2->irow=n+i+3*common->n_dc; // a2d1/acosak + p2->jcol=n+i+2*common->n_dc; + p2->z=1; + correct->heisen[p2->jcol]=insert2(correct->heisen[p2->jcol],p2,&kk); + if(kk==0) + p2=(opf_matrix *)malloc(lematrix); + + p2->irow=t+p10->iac*4-2; // a2d1/aViacos + p2->jcol=n+i+3*common->n_dc; + p2->z=1; + correct->heisen[p2->jcol]=insert2(correct->heisen[p2->jcol],p2,&kk); + if(kk==0) + p2=(opf_matrix *)malloc(lematrix); + + p2->irow=n+i+4*common->n_dc; // a2d2/afarak + p2->jcol=n+i+2*common->n_dc; + p2->z=1; + correct->heisen[p2->jcol]=insert2(correct->heisen[p2->jcol],p2,&kk); + if(kk==0) + p2=(opf_matrix *)malloc(lematrix); + + p2->irow=t+p10->iac*4-2; // a2d2/aViafar + p2->jcol=n+i+4*common->n_dc; + p2->z=1; + correct->heisen[p2->jcol]=insert2(correct->heisen[p2->jcol],p2,&kk); + if(kk==0) + p2=(opf_matrix *)malloc(lematrix); + + p2->irow=n+i+4*common->n_dc; // a2d2/afarafar + p2->jcol=n+i+4*common->n_dc; + p2->z=1; + correct->heisen[p2->jcol]=insert2(correct->heisen[p2->jcol],p2,&kk); + if(kk==0) + p2=(opf_matrix *)malloc(lematrix); + + // 其他在位置上与有重叠，不用计了，只存下三角,d3没有 + + i=i+1; + p10=p10->next; + } + + + n=common->rp+common->rq+common->rk+2*common->rkb+common->rt+common->rx; + t=common->rr-common->rv; //海森矩阵（线路功率因数方程） + p8=common->head_lcos; //转换成Pij Qij 可以预先不用定位置 + i=1; +/* + while(p8!=null) + { + i=i+1; + p8=p8->next; + }*/ + + + n=common->rp+common->rq+common->rk+2*common->rkb+common->rt+common->rx+2*common->rlcos; + t=common->rr-common->rv; //海森矩阵（负荷模型功率因数方程） + p8=common->head_vdcos; + i=1; + while(p8!=null) + { + p2->irow=t+p8->i*4-2; // a2cosDi/acosDi aVi + p2->jcol=n+i; + p2->z=1; + correct->heisen[p2->jcol]=insert2(correct->heisen[p2->jcol],p2,&kk); + if(kk==0) + p2=(opf_matrix *)malloc(lematrix); + + p2->irow=n+i; // a2cosDi/acosDi acosDi + p2->jcol=n+i; + p2->z=1; + correct->heisen[p2->jcol]=insert2(correct->heisen[p2->jcol],p2,&kk); + if(kk==0) + p2=(opf_matrix *)malloc(lematrix); + + //其他的和cos没有关系的，和已有的重复，不用列了 + + i=i+1; + p8=p8->next; + } + + m=common->rr-common->rv; //雅可比矩阵 + for(i=1;i<=common->rp+common->rq;i++) //有功和无功部分 + { p3=correct->jcb[i]; + while(p3!=null) + { j=p3->irow; + n=(j+1)/2; //行号 +// t=(int)fmod(j,2); + t=j%2; +// hasin[m+4*n-t][i]=p3->z; + p2->irow=m+4*n-t; + p2->jcol=i; + p2->z=1; + if(p2->irow>p2->jcol) + { correct->heisen[p2->jcol]=insert2(correct->heisen[p2->jcol],p2,&kk); + if(kk==0) + p2=(opf_matrix *)malloc(lematrix); + } + p3=p3->next; + } + } + + for(i=1;i<=common->rk+2*common->rkb+common->rt+common->rx;i++) //有载调压变压器、移相器、电容器部分(只记列),潮流方程部分 + { p3=correct->jcb[common->rp+common->rq+i]; + while(p3!=null) + { if(p3->irow<=2*common->n_sum) + { j=p3->irow; + n=(j+1)/2; //行号 + // t=(int)fmod(j,2); + t=j%2; + p2->irow=m+4*n-t; + p2->jcol=common->rp+common->rq+i; + p2->z=1; + if(p2->irow>p2->jcol) + { correct->heisen[p2->jcol]=insert2(correct->heisen[p2->jcol],p2,&kk); + if(kk==0) + p2=(opf_matrix *)malloc(lematrix); + } + } + p3=p3->next; + } + } + + ii=common->rp+common->rq+common->rk+2*common->rkb+common->rt+common->rx+2*common->rlcos+common->rvdcos; + for(i=1;i<=common->n_dc*5;i++) //直流节点变量(只记列) + { p3=correct->jcb[ii+i]; + while(p3!=null) + { if(p3->irow<=2*common->n_sum) //潮流方程部分 + { j=p3->irow; + n=(j+1)/2; //行号 +// t=(int)fmod(j,2); + t=j%2; + p2->irow=m+4*n-t; + p2->jcol=ii+i; + p2->z=1; + if(p2->irow>p2->jcol) + { correct->heisen[p2->jcol]=insert2(correct->heisen[p2->jcol],p2,&kk); + if(kk==0) + p2=(opf_matrix *)malloc(lematrix); + } + } + else //直流方程 + { p2->irow=p3->irow-2*common->n_sum+common->rr-common->rv+4*common->n_sum; + p2->jcol=ii+i; + p2->z=1; + if(p2->irow>p2->jcol) + { correct->heisen[p2->jcol]=insert2(correct->heisen[p2->jcol],p2,&kk); + if(kk==0) + p2=(opf_matrix *)malloc(lematrix); + } + } + p3=p3->next; + } + } + + for(i=1;i<=common->n_sum;i++) //交流的电压和相角变量，潮流方程（雅可比矩阵） + { p3=correct->jcb[2*i-1+m]; + while(p3!=null) + { if(p3->irow<=2*common->n_sum) + { j=p3->irow; + n=(j+1)/2; //行号 +// t=(int)fmod(j,2); + t=j%2; + if(n>=i) + { + p2->irow=m+4*n-t; + p2->jcol=m+4*i-3; + p2->z=1; + if(p2->irow>p2->jcol) + { correct->heisen[p2->jcol]=insert2(correct->heisen[p2->jcol],p2,&kk); + if(kk==0) + p2=(opf_matrix *)malloc(lematrix); + } + } + else + { + p2->irow=m+4*i-3; + p2->jcol=m+4*n-t; + p2->z=1; + if(p2->irow>p2->jcol) + { correct->heisen[p2->jcol]=insert2(correct->heisen[p2->jcol],p2,&kk); + if(kk==0) + p2=(opf_matrix *)malloc(lematrix); + } + } + } + p3=p3->next; + } + p3=correct->jcb[2*i+m]; + while(p3!=null) + { if(p3->irow<=2*common->n_sum) + { j=p3->irow; + n=(j+1)/2; //行号 +// t=(int)fmod(j,2); + t=j%2; + if(n>=i) + { + p2->irow=m+4*n-t; + p2->jcol=m+4*i-2; + p2->z=1; + if(p2->irow>p2->jcol) + { correct->heisen[p2->jcol]=insert2(correct->heisen[p2->jcol],p2,&kk); + if(kk==0) + p2=(opf_matrix *)malloc(lematrix); + } + } + else + { + p2->irow=m+4*i-2; + p2->jcol=m+4*n-t; + p2->z=1; + if(p2->irow>p2->jcol) + { correct->heisen[p2->jcol]=insert2(correct->heisen[p2->jcol],p2,&kk); + if(kk==0) + p2=(opf_matrix *)malloc(lematrix); + } + } + } + p3=p3->next; + } + } + + m=common->rr-common->rv; + i=1; + p8=common->head_lcos; //联络线功率因数的一阶偏导，等式约束（雅可比矩阵） + while(p8!=null) + { p2->irow=m+4*common->n_sum+i; + p2->jcol=m+p8->i*4-3;// aPij/a&i + p2->z=1; + correct->heisen[p2->jcol]=insert2(correct->heisen[p2->jcol],p2,&kk); + if(kk==0) + p2=(opf_matrix *)malloc(lematrix); + + p2->irow=m+4*common->n_sum+i; + p2->jcol=m+p8->i*4-2;// aPij/aVi + p2->z=1; + correct->heisen[p2->jcol]=insert2(correct->heisen[p2->jcol],p2,&kk); + if(kk==0) + p2=(opf_matrix *)malloc(lematrix); + + p2->irow=m+4*common->n_sum+i; + p2->jcol=m+p8->j*4-3;// aPij/a&j + p2->z=1; + correct->heisen[p2->jcol]=insert2(correct->heisen[p2->jcol],p2,&kk); + if(kk==0) + p2=(opf_matrix *)malloc(lematrix); + + p2->irow=m+4*common->n_sum+i; + p2->jcol=m+p8->j*4-2;// aPij/aVj + p2->z=1; + correct->heisen[p2->jcol]=insert2(correct->heisen[p2->jcol],p2,&kk); + if(kk==0) + p2=(opf_matrix *)malloc(lematrix); + + p2->irow=m+4*common->n_sum+i; + p2->jcol=common->rp+common->rq+common->rk+2*common->rkb+common->rt+common->rx+i; // aPij/aPij + p2->z=1; + correct->heisen[p2->jcol]=insert2(correct->heisen[p2->jcol],p2,&kk); + if(kk==0) + p2=(opf_matrix *)malloc(lematrix); + + p2->irow=m+4*common->n_sum+i+common->rlcos; + p2->jcol=m+p8->i*4-3;// aQij/a&i + p2->z=1; + correct->heisen[p2->jcol]=insert2(correct->heisen[p2->jcol],p2,&kk); + if(kk==0) + p2=(opf_matrix *)malloc(lematrix); + + p2->irow=m+4*common->n_sum+i+common->rlcos; + p2->jcol=m+p8->i*4-2;// aQij/aVi + p2->z=1; + correct->heisen[p2->jcol]=insert2(correct->heisen[p2->jcol],p2,&kk); + if(kk==0) + p2=(opf_matrix *)malloc(lematrix); + + p2->irow=m+4*common->n_sum+i+common->rlcos; + p2->jcol=m+p8->j*4-3;// aQij/a&j + p2->z=1; + correct->heisen[p2->jcol]=insert2(correct->heisen[p2->jcol],p2,&kk); + if(kk==0) + p2=(opf_matrix *)malloc(lematrix); + + p2->irow=m+4*common->n_sum+i+common->rlcos; + p2->jcol=m+p8->j*4-2;// aQij/aVj + p2->z=1; + correct->heisen[p2->jcol]=insert2(correct->heisen[p2->jcol],p2,&kk); + if(kk==0) + p2=(opf_matrix *)malloc(lematrix); + + p2->irow=m+4*common->n_sum+i+common->rlcos; + p2->jcol=common->rp+common->rq+common->rk+2*common->rkb+common->rt+common->rx+i+common->rlcos; // aQij/aQij + p2->z=1; + correct->heisen[p2->jcol]=insert2(correct->heisen[p2->jcol],p2,&kk); + if(kk==0) + p2=(opf_matrix *)malloc(lematrix); + + i=i+1; + p8=p8->next; + } + + m=common->rr-common->rv; + i=1; + p8=common->head_vdcos; //负荷模型功率因数的一阶偏导，等式约束（雅可比矩阵） + while(p8!=null) + { p2->irow=m+4*common->n_sum+2*common->rlcos+i; + p2->jcol=m+p8->i*4-2;// acosDi/aVi + p2->z=1; + correct->heisen[p2->jcol]=insert2(correct->heisen[p2->jcol],p2,&kk); + if(kk==0) + p2=(opf_matrix *)malloc(lematrix); + + p2->irow=m+4*common->n_sum+2*common->rlcos+i; + p2->jcol=common->rp+common->rq+common->rk+2*common->rkb+common->rt+common->rx+2*common->rlcos+i; // acosDi/acosDi + p2->z=1; + correct->heisen[p2->jcol]=insert2(correct->heisen[p2->jcol],p2,&kk); + if(kk==0) + p2=(opf_matrix *)malloc(lematrix); + + i=i+1; + p8=p8->next; + } + + i=1; //直流方程和相应的交流节点有关的部分 Vi + n=common->rr-common->rv+4*common->n_sum+2*common->rlcos+common->rvdcos; + m=common->rp+common->rq+common->rk+2*common->rkb+common->rt+common->rx+2*common->rlcos+common->rvdcos; + p10=common->head_dcbus; //直流部分 + while(p10!=null) + { + p2->irow=n+i; // ad1/aVi //直流方程d1 + p2->jcol=common->rr-common->rv+p10->iac*4-2; + p2->z=1; + correct->heisen[p2->jcol]=insert2(correct->heisen[p2->jcol],p2,&kk); + if(kk==0) + p2=(opf_matrix *)malloc(lematrix); + + p2->irow=n+i+common->n_dc; // ad2/aVi //直流方程d2 + p2->jcol=common->rr-common->rv+p10->iac*4-2; + p2->z=1; + correct->heisen[p2->jcol]=insert2(correct->heisen[p2->jcol],p2,&kk); + if(kk==0) + p2=(opf_matrix *)malloc(lematrix); + + i=i+1; + p10=p10->next; + } + + n=common->rr-common->rv+4*common->n_sum+2*common->rlcos+common->rvdcos+3*common->n_dc; + m=common->rp+common->rq; + i=1; + p12=common->head_eqkij; + while(p12!=null) + { p2->irow=n+i; + p2->jcol=m+p12->i; + p2->z=1; + correct->heisen[p2->jcol]=insert2(correct->heisen[p2->jcol],p2,&kk); + if(kk==0) + p2=(opf_matrix *)malloc(lematrix); + + p2->irow=n+i; + p2->jcol=m+p12->j; + p2->z=-1; + correct->heisen[p2->jcol]=insert2(correct->heisen[p2->jcol],p2,&kk); + if(kk==0) + p2=(opf_matrix *)malloc(lematrix); + + i=i+1; + p12=p12->next; + } + + t=common->rr-common->rv; + for(i=common->rr+1;i<=common->rr+common->rrr-common->rgpcd-common->n_dc-common->rlcos;i++) //计算derg乘derg的转置，多项式部分 + { p3=correct->dg[i]; + while(p3!=null) + { p4=correct->dg[i]; + while(p4!=null) + { + m=(p3->irow+1-(common->rr-common->rv))/2; + n=(p4->irow+1-(common->rr-common->rv))/2; +// tm=(int)fmod(p3->irow-(common->rr-common->rv),2); + tm=(p3->irow-(common->rr-common->rv))%2; +// tn=(int)fmod(p4->irow-(common->rr-common->rv),2); + tn=(p4->irow-(common->rr-common->rv))%2; + + p2->irow=t+4*m-2-tm; + p2->jcol=t+4*n-2-tn; + p2->z=1; + correct->heisen[p2->jcol]=insert2(correct->heisen[p2->jcol],p2,&kk); + if(kk==0) + p2=(opf_matrix *)malloc(lematrix); + + p4=p4->next; + } + p3=p3->next; + } + } + + for(i=common->rr+common->rrr-common->rgpcd-common->n_dc-common->rlcos+1;i<=common->rr+common->rrr;i++) //计算derg乘derg的转置,发电机模型部分、直流功率部分 + { p3=correct->dg[i]; + while(p3!=null) + { p4=correct->dg[i]; + while(p4!=null) + { + p2->irow=p3->irow; + p2->jcol=p4->irow; + p2->z=1; + correct->heisen[p2->jcol]=insert2(correct->heisen[p2->jcol],p2,&kk); + if(kk==0) + p2=(opf_matrix *)malloc(lematrix); + + p4=p4->next; + } + p3=p3->next; + } + } +// + + free(p2); + + +//**********只存下三角**************// + + t=common->rr-common->rv; + for(i=1;i<=hnsum;i++) //(p4->irow<=p4->jcol)只存下三角 + { p3=correct->heisen[i]; + p4=correct->heisen[i]; + p5=correct->heisen[i]; + j=0; + + while(p3!=null) + { p4=p3; + p3=p3->next; //(p4->irow<=p4->jcol)只存下三角 + if(p4->irow<=p4->jcol) + { if(j==0) //头指针 + { correct->heisen[i]=p3; + free(p4); + } + else + { p5->next=p3; + free(p4); + } + } + else + { j=1; //该节点已跳过，不是头指针了 + p5=p4; + } + } + } + +//**********处理平衡节点************// + + p7=common->head_slack; + t=common->rr-common->rv; + while(p7!=null) + { for(i=1;i<=hnsum;i++) //处理平衡节点的相角 + { if(i==t+4*p7->i-3) //h是按列排的，将整列删除 + { while(correct->heisen[i]!=null) + { p3=correct->heisen[i]->next; + free(correct->heisen[i]); + correct->heisen[i]=p3; + } + } + else //只是删除对应的那一行的元素 + { n=0; + p3=correct->heisen[i]; + p4=correct->heisen[i]; + p2=correct->heisen[i]; + while(p3!=null) + { p4=p3; + p3=p3->next; + if(p4->irow==t+4*p7->i-3) + { if(n==0) + { correct->heisen[i]=p3; + free(p4); + } + else + { p2->next=p3; + free(p4); + } + } + else + { n=1; + p2=p4; + } + } + } + } + p7=p7->next; + } + + if(common->slack_flag==1) + { p7=common->head_slack; + t=common->rr-common->rv; + while(p7!=null) + { for(i=1;i<=hnsum;i++) //处理平衡节点的幅值 + { if(i==t+4*p7->i-2) //h是按列排的，将整列删除 + { while(correct->heisen[i]!=null) + { p3=correct->heisen[i]->next; + free(correct->heisen[i]); + correct->heisen[i]=p3; + } + } + else //只是删除对应的那一行的元素 + { n=0; + p3=correct->heisen[i]; + p4=correct->heisen[i]; + p2=correct->heisen[i]; + while(p3!=null) + { p4=p3; + p3=p3->next; + if(p4->irow==t+4*p7->i-2) + { if(n==0) + { correct->heisen[i]=p3; + free(p4); + } + else + { p2->next=p3; + free(p4); + } + } + else + { n=1; + p2=p4; + } + } + } + } + p7=p7->next; + } + } + +/* + FILE *fp=fopen("Text3.txt","wb"); + j=0; + for(i=1;i<=hnsum;i++) + { p3=correct->heisen[i]; + while(p3!=null) + { fprintf(fp," %d, %d, %d, %f\n" ,j,p3->irow,p3->jcol,p3->z); + j=j+1; + p3=p3->next; + } + } + fclose(fp);*/ + + + return; + + +} + +/******形成g的一阶偏导矩阵的固定部分和编号（竖着排）******/ +void DgMatrix(opf_common *common,opf_correct *correct) +{ int i,j,t,m; + + opf_gij *p1,*p8; + opf_matrix *p3; + opf_vpdqd *p4; + opf_gpcd *p5; + opf_sij *p6; + opf_dcbus *p7; + + int kk; + + for(i=1;i<=common->rr+common->rrr;i++) + { while(correct->dg[i]!=null) + { p3=correct->dg[i]->next; + free(correct->dg[i]); + correct->dg[i]=p3; + } + } + + t=common->rp+common->rq+common->rk+2*common->rkb+common->rt+common->rx+2*common->rlcos+common->rvdcos+5*common->n_dc; + for(i=1;i<=t;i++) //有功无功、有载调压变压器、可调电容器、可调线路电抗、线路功率因数,负荷模型功率因数,直流数据 + { p3=(opf_matrix *)malloc(lematrix); + p3->irow=i; + p3->jcol=i; + p3->z=1; + correct->dg[i]=insert2(correct->dg[i],p3,&kk); + } + j=common->rr-common->rv; + for(i=1;i<=common->rv;i++) //计算g的一阶偏导的电压部分（竖着排） + { p3=(opf_matrix *)malloc(lematrix); + p3->irow=j+2*i; + p3->jcol=j+i; + p3->z=1; + correct->dg[j+i]=insert2(correct->dg[j+i],p3,&kk); + } + + p1=common->head_lpij; + i=1; + p3=(opf_matrix *)malloc(lematrix); + while(p1!=null) //计算g的一阶偏导的支路有功功率部分 + { t=p1->i; + m=p1->j; + + p3->irow=j+2*t-1; + p3->jcol=common->rr+i; + p3->z=0; + correct->dg[common->rr+i]=insert2(correct->dg[common->rr+i],p3,&kk); + if(kk==0) + p3=(opf_matrix *)malloc(lematrix); + + p3->irow=j+2*m-1; + p3->jcol=common->rr+i; + p3->z=0; + correct->dg[common->rr+i]=insert2(correct->dg[common->rr+i],p3,&kk); + if(kk==0) + p3=(opf_matrix *)malloc(lematrix); + + p3->irow=j+2*t; + p3->jcol=common->rr+i; + p3->z=0; + correct->dg[common->rr+i]=insert2(correct->dg[common->rr+i],p3,&kk); + if(kk==0) + p3=(opf_matrix *)malloc(lematrix); + + p3->irow=j+2*m; + p3->jcol=common->rr+i; + p3->z=0; + correct->dg[common->rr+i]=insert2(correct->dg[common->rr+i],p3,&kk); + if(kk==0) + p3=(opf_matrix *)malloc(lematrix); + i=i+1; + p1=p1->next; + } + + p1=common->head_lqij; + i=1; + while(p1!=null) //计算g的一阶偏导的支路无功功率部分 + { t=p1->i; + m=p1->j; + + p3->irow=j+2*t-1; + p3->jcol=common->rr+common->rlpij+i; + p3->z=0; + correct->dg[p3->jcol]=insert2(correct->dg[p3->jcol],p3,&kk); + if(kk==0) + p3=(opf_matrix *)malloc(lematrix); + + p3->irow=j+2*m-1; + p3->jcol=common->rr+common->rlpij+i; + p3->z=0; + correct->dg[p3->jcol]=insert2(correct->dg[p3->jcol],p3,&kk); + if(kk==0) + p3=(opf_matrix *)malloc(lematrix); + + p3->irow=j+2*t; + p3->jcol=common->rr+common->rlpij+i; + p3->z=0; + correct->dg[p3->jcol]=insert2(correct->dg[p3->jcol],p3,&kk); + if(kk==0) + p3=(opf_matrix *)malloc(lematrix); + + p3->irow=j+2*m; + p3->jcol=common->rr+common->rlpij+i; + p3->z=0; + correct->dg[p3->jcol]=insert2(correct->dg[p3->jcol],p3,&kk); + if(kk==0) + p3=(opf_matrix *)malloc(lematrix); + i=i+1; + p1=p1->next; + } + + p1=common->head_lsij; + i=1; + while(p1!=null) //计算g的一阶偏导的支路容量部分 + { t=p1->i; + m=p1->j; + + p3->irow=j+2*t-1; + p3->jcol=common->rr+common->rlpij+common->rlqij+i; + p3->z=0; + correct->dg[p3->jcol]=insert2(correct->dg[p3->jcol],p3,&kk); + if(kk==0) + p3=(opf_matrix *)malloc(lematrix); + + p3->irow=j+2*m-1; + p3->jcol=common->rr+common->rlpij+common->rlqij+i; + p3->z=0; + correct->dg[p3->jcol]=insert2(correct->dg[p3->jcol],p3,&kk); + if(kk==0) + p3=(opf_matrix *)malloc(lematrix); + + p3->irow=j+2*t; + p3->jcol=common->rr+common->rlpij+common->rlqij+i; + p3->z=0; + correct->dg[p3->jcol]=insert2(correct->dg[p3->jcol],p3,&kk); + if(kk==0) + p3=(opf_matrix *)malloc(lematrix); + + p3->irow=j+2*m; + p3->jcol=common->rr+common->rlpij+common->rlqij+i; + p3->z=0; + correct->dg[p3->jcol]=insert2(correct->dg[p3->jcol],p3,&kk); + if(kk==0) + p3=(opf_matrix *)malloc(lematrix); + i=i+1; + p1=p1->next; + } + + p1=common->head_liij; + i=1; + while(p1!=null) //计算g的一阶偏导的支路电流部分 + { t=p1->i; + m=p1->j; + + p3->irow=j+2*t-1; + p3->jcol=common->rr+common->rlpij+common->rlqij+common->rlsij+i; + p3->z=0; + correct->dg[p3->jcol]=insert2(correct->dg[p3->jcol],p3,&kk); + if(kk==0) + p3=(opf_matrix *)malloc(lematrix); + + p3->irow=j+2*m-1; + p3->jcol=common->rr+common->rlpij+common->rlqij+common->rlsij+i; + p3->z=0; + correct->dg[p3->jcol]=insert2(correct->dg[p3->jcol],p3,&kk); + if(kk==0) + p3=(opf_matrix *)malloc(lematrix); + + p3->irow=j+2*t; + p3->jcol=common->rr+common->rlpij+common->rlqij+common->rlsij+i; + p3->z=0; + correct->dg[p3->jcol]=insert2(correct->dg[p3->jcol],p3,&kk); + if(kk==0) + p3=(opf_matrix *)malloc(lematrix); + + p3->irow=j+2*m; + p3->jcol=common->rr+common->rlpij+common->rlqij+common->rlsij+i; + p3->z=0; + correct->dg[p3->jcol]=insert2(correct->dg[p3->jcol],p3,&kk); + if(kk==0) + p3=(opf_matrix *)malloc(lematrix); + i=i+1; + p1=p1->next; + } + + p4=common->head_vpd; + i=1; + while(p4!=null) //计算g的一阶偏导的有功负荷模型部分 + { t=p4->i; + + p3->irow=j+2*t; //电压部分 + p3->jcol=common->rr+common->rlpij+common->rlqij+common->rlsij+common->rliij+i; + p3->z=0; + correct->dg[p3->jcol]=insert2(correct->dg[p3->jcol],p3,&kk); + if(kk==0) + p3=(opf_matrix *)malloc(lematrix); + i=i+1; + p4=p4->next; + } + + p4=common->head_vqd; + i=1; + while(p4!=null) //计算g的一阶偏导的无功负荷模型部分 + { t=p4->i; + + p3->irow=j+2*t; //电压部分 + p3->jcol=common->rr+common->rlpij+common->rlqij+common->rlsij+common->rliij+common->rvpd+i; + p3->z=0; + correct->dg[p3->jcol]=insert2(correct->dg[p3->jcol],p3,&kk); + if(kk==0) + p3=(opf_matrix *)malloc(lematrix); + i=i+1; + p4=p4->next; + } + + p1=common->head_spij; //断面有功计算g的一阶偏导 + i=1; + while(p1!=null) + { p6=common->head_sij; + while(p6!=null) //找到匹配的支路有功功率部分 + { if(p6->num==p1->i) + { t=p6->i; + m=p6->j; + + p3->irow=j+2*t-1; + p3->jcol=common->rr+common->rlpij+common->rlqij+common->rlsij+common->rliij+common->rvpd+common->rvqd+i; + p3->z=0; + correct->dg[p3->jcol]=insert2(correct->dg[p3->jcol],p3,&kk); + if(kk==0) + p3=(opf_matrix *)malloc(lematrix); + + p3->irow=j+2*m-1; + p3->jcol=common->rr+common->rlpij+common->rlqij+common->rlsij+common->rliij+common->rvpd+common->rvqd+i; + p3->z=0; + correct->dg[p3->jcol]=insert2(correct->dg[p3->jcol],p3,&kk); + if(kk==0) + p3=(opf_matrix *)malloc(lematrix); + + p3->irow=j+2*t; + p3->jcol=common->rr+common->rlpij+common->rlqij+common->rlsij+common->rliij+common->rvpd+common->rvqd+i; + p3->z=0; + correct->dg[p3->jcol]=insert2(correct->dg[p3->jcol],p3,&kk); + if(kk==0) + p3=(opf_matrix *)malloc(lematrix); + + p3->irow=j+2*m; + p3->jcol=common->rr+common->rlpij+common->rlqij+common->rlsij+common->rliij+common->rvpd+common->rvqd+i; + p3->z=0; + correct->dg[p3->jcol]=insert2(correct->dg[p3->jcol],p3,&kk); + if(kk==0) + p3=(opf_matrix *)malloc(lematrix); + } + p6=p6->next; + } + i=i+1; + p1=p1->next; + } + + p1=common->head_sqij; //断面无功计算g的一阶偏导 + i=1; + while(p1!=null) + { p6=common->head_sij; + + while(p6!=null) //找到匹配的支路无功功率部分 + { if(p6->num==p1->i) + { t=p6->i; + m=p6->j; + + p3->irow=j+2*t-1; + p3->jcol=common->rr+common->rlpij+common->rlqij+common->rlsij+common->rliij + +common->rvpd+common->rvqd+common->rspij+i; + p3->z=0; + correct->dg[p3->jcol]=insert2(correct->dg[p3->jcol],p3,&kk); + if(kk==0) + p3=(opf_matrix *)malloc(lematrix); + + p3->irow=j+2*m-1; + p3->jcol=common->rr+common->rlpij+common->rlqij+common->rlsij+common->rliij + +common->rvpd+common->rvqd+common->rspij+i; + p3->z=0; + correct->dg[p3->jcol]=insert2(correct->dg[p3->jcol],p3,&kk); + if(kk==0) + p3=(opf_matrix *)malloc(lematrix); + + p3->irow=j+2*t; + p3->jcol=common->rr+common->rlpij+common->rlqij+common->rlsij+common->rliij + +common->rvpd+common->rvqd+common->rspij+i; + p3->z=0; + correct->dg[p3->jcol]=insert2(correct->dg[p3->jcol],p3,&kk); + if(kk==0) + p3=(opf_matrix *)malloc(lematrix); + + p3->irow=j+2*m; + p3->jcol=common->rr+common->rlpij+common->rlqij+common->rlsij+common->rliij + +common->rvpd+common->rvqd+common->rspij+i; + p3->z=0; + correct->dg[p3->jcol]=insert2(correct->dg[p3->jcol],p3,&kk); + if(kk==0) + p3=(opf_matrix *)malloc(lematrix); + } + p6=p6->next; + } + i=i+1; + p1=p1->next; + } + + p5=common->head_gpcd; + i=1; + while(p5!=null) //计算g的一阶偏导的发电机功率园图模型部分 + { t=0; + for(j=1;j<=common->rpg;j++) + { if(common->gp[j]==p5->i) + t=j; + } + if(t!=0) + { p3->irow=t; //有功部分 + p3->jcol=common->rr+common->rlpij+common->rlqij+common->rlsij+common->rliij + +common->rvpd+common->rvqd+common->rspij+common->rsqij+i; + p3->z=0; + correct->dg[p3->jcol]=insert2(correct->dg[p3->jcol],p3,&kk); + if(kk==0) + p3=(opf_matrix *)malloc(lematrix); + } + + t=0; + for(j=1;j<=common->rqg;j++) + { if(common->gq[j]==p5->i) + t=j; + } + if(t!=0) + { p3->irow=common->rp+t; //无功部分 + p3->jcol=common->rr+common->rlpij+common->rlqij+common->rlsij+common->rliij + +common->rvpd+common->rvqd+common->rspij+common->rsqij+i; + p3->z=0; + correct->dg[p3->jcol]=insert2(correct->dg[p3->jcol],p3,&kk); + if(kk==0) + p3=(opf_matrix *)malloc(lematrix); + } + i=i+1; + p5=p5->next; + } + + + p7=common->head_dcbus; + i=1; + t=common->rp+common->rq+common->rk+2*common->rkb+common->rt+common->rx+2*common->rlcos+common->rvdcos; + while(p7!=null) + { p3->irow=t+i+common->n_dc; //Pdi/Vdi + p3->jcol=common->rr+common->rlpij+common->rlqij+common->rlsij+common->rliij + +common->rvpd+common->rvqd+common->rspij+common->rsqij+common->rgpcd+i; + p3->z=0; + correct->dg[p3->jcol]=insert2(correct->dg[p3->jcol],p3,&kk); + if(kk==0) + p3=(opf_matrix *)malloc(lematrix); + + p3->irow=t+i; //Pdi/Idi + p3->jcol=common->rr+common->rlpij+common->rlqij+common->rlsij+common->rliij + +common->rvpd+common->rvqd+common->rspij+common->rsqij+common->rgpcd+i; + p3->z=0; + correct->dg[p3->jcol]=insert2(correct->dg[p3->jcol],p3,&kk); + if(kk==0) + p3=(opf_matrix *)malloc(lematrix); + + i=i+1; + p7=p7->next; + } + + + p8=common->head_lcos; //联络线功率因数的一阶偏导，联络线功率因数的等式约束，转换成PijQij表示的不等式约束 + m=common->rr+common->rlpij+common->rlqij+common->rlsij+common->rliij + +common->rvpd+common->rvqd+common->rspij+common->rsqij+common->rgpcd+common->n_dc; + t=common->rp+common->rq+common->rk+2*common->rkb+common->rt+common->rx; + i=1; + while(p8!=null) + { + p3->irow=t+i; //cosij/Pij + p3->jcol=m+i; + p3->z=0; + correct->dg[p3->jcol]=insert2(correct->dg[p3->jcol],p3,&kk); + if(kk==0) + p3=(opf_matrix *)malloc(lematrix); + + p3->irow=t+i+common->rlcos; //cosij/Qij + p3->jcol=m+i; + p3->z=0; + correct->dg[p3->jcol]=insert2(correct->dg[p3->jcol],p3,&kk); + if(kk==0) + p3=(opf_matrix *)malloc(lematrix); + + i=i+1; + p8=p8->next; + } + + + free(p3); +} + +/* + ******符号分解****** + * @param dim 方程维数 + */ +void SymbolDecompose(opf_decomp *decomp,opf_correct *correct,int dim) +{ + opf_matrix *p1; + int i,k,kk,g,gg; + + //dim是维数 dim=rr-rv+4*mm + + int *z,*ks,*jjs,*chazhi,*w;//中间变量 + int *li,*lj,*jj,*hh,*rr; + + int dimsum_li,dimsum_lj,dimsum_hh,dimsum_rr;//维数大小 + + int errbz; //错误标志 + + w=(int *)malloc((dim+2)*sizeof(int)); + z=(int *)malloc((dim+2)*sizeof(int)); + ks=(int *)malloc((dim+2)*sizeof(int)); + jjs=(int *)malloc((dim+2)*sizeof(int)); + chazhi=(int *)malloc((dim+2)*sizeof(int)); + + + decomp->lis=(int *)malloc((dim+2)*sizeof(int)); + decomp->ljs=(int *)malloc((dim+2)*sizeof(int)); + + k=1; //先计算jj数组要开多大 + for(i=1;i<=dim;i++) + { p1=correct->heisen[i]; + while(p1!=null) + { k=k+1; + p1=p1->next; + } + } + + jj=(int *)malloc((k+1)*sizeof(int)); //对于jj来说就足够了 + hh=(int *)malloc((k+1)*sizeof(int)); //先开这么大，然后再加 + rr=(int *)malloc((k+1)*sizeof(int)); + + li=(int *)malloc((k+1)*sizeof(int)); //先开这么大，然后再加 + lj=(int *)malloc((k+1)*sizeof(int)); + + for(i=1;i<=k;i++) + { jj[i]=0; + hh[i]=0; + rr[i]=0; + li[i]=0; + lj[i]=0; + } + + dimsum_li=k+1; + dimsum_lj=k+1; + dimsum_hh=k+1; + dimsum_rr=k+1; + + for(i=1;i<=dim+1;i++) + z[i]=0; + k=1; + + + for(i=1;i<=dim;i++) + { p1=correct->heisen[i]; + while(p1!=null) + { jj[k]=p1->irow; //记的是行号 + k=k+1; + z[p1->jcol]=z[p1->jcol]+1; + p1=p1->next; + } + } + + jjs[1]=1; + for(i=2;i<=dim+1;i++) + jjs[i]=jjs[i-1]+z[i-1]; + decomp->lis[1]=1; + decomp->lis[2]=1; + decomp->ljs[1]=1; + decomp->ljs[2]=jjs[2]; + kk=decomp->ljs[2]; + for(i=1;i<=dim;i++) + { w[i]=0; + z[i]=1; //可以少做一次 + chazhi[i]=0; + ks[i]=0; + } + for(i=1;i<=dim;i++) + lj[i]=jj[i]; + for(i=1;i<=jjs[2]-1;i++) + { hh[i]=1; + rr[i]=0; + chazhi[jj[i]]=i; + ks[jj[i]]=ks[jj[i]]+1; + } + + for(k=2;k<=dim;k++) + { + for(i=jjs[k];i<=jjs[k+1]-1;i++) + w[jj[i]]=w[jj[i]]+1; + i=chazhi[k]; + decomp->lis[k+1]=decomp->lis[k]+ks[k]; + for(g=decomp->lis[k+1]-1;g>=decomp->lis[k];g--) + { +// li[g]=hh[i]; + errbz=GiveValue(&li,g,hh[i],&dimsum_li); + i=rr[i]; + } + for(g=decomp->lis[k];g<=decomp->lis[k+1]-1;g++) + { gg=li[g]; + for(i=decomp->ljs[gg]+z[gg];i<=decomp->ljs[gg+1]-1;i++) + w[lj[i]]=w[lj[i]]+1; + z[gg]=z[gg]+1; + } + for(i=k+1;i<=dim;i++) + { + if(w[i]!=0) + { +// lj[kk]=i; + errbz=GiveValue(&lj,kk,i,&dimsum_lj); +// hh[kk]=k; + errbz=GiveValue(&hh,kk,k,&dimsum_hh); +// rr[kk]=chazhi[i]; + errbz=GiveValue(&rr,kk,chazhi[i],&dimsum_rr); + chazhi[i]=kk; + ks[i]=ks[i]+1; + kk=kk+1; + w[i]=0; + } + decomp->ljs[k+1]=kk; + } + + } + //kk是全部非零元哦 + + decomp->ljs[dim+1]=kk; + li[kk]=dim; + lj[kk]=dim; + + free(jj); + free(hh); + free(rr); + free(ks); + free(jjs); + free(chazhi); + free(w); + + + decomp->li=(int *)malloc((kk+1)*sizeof(int)); //给解方程所用的数组确定大小 + decomp->lj=(int *)malloc((kk+1)*sizeof(int)); + decomp->jtoi=(int *)malloc((kk+1)*sizeof(int)); + decomp->la=(double *)malloc((kk+1)*sizeof(double)); + + for(i=1;i<=kk;i++) + { decomp->li[i]=0; + decomp->lj[i]=0; + decomp->jtoi[i]=0; + decomp->la[i]=0; + } + + for(i=1;i<=kk;i++) + { decomp->li[i]=li[i]; + decomp->lj[i]=lj[i]; + } + + for(i=1;i<=dim;i++) + z[i]=0; + decomp->jtoi[1]=1; + for(k=1;k<=dim;k++) //给 jtoi 赋值 + { for(i=decomp->ljs[k];i<=decomp->ljs[k+1]-1;i++) + { g=decomp->lj[i]; + decomp->jtoi[decomp->lis[g]+z[g]]=i; + z[g]=z[g]+1; + } + } + + free(z); + free(li); + free(lj); + +} + +/******动态扩大数组*******/ +int GiveValue(int **array,int nowsize,int value,int *tosize) +{ + if((nowsize+1)>=*tosize)//将==改为>=，因为你不是按顺序访问！ + { + if(nowsize- (*tosize+1) >=1000) + *tosize+=nowsize- (*tosize)+100; + else + *tosize+=1000; + *array=(int *)realloc(*array,(*tosize)*sizeof(int)); + if((*array)==null) + // error("Could not expand the table"); + return 1; + } + (*array)[nowsize]=value; + return 0; +} + +/* + * 迭代函数 + * 返回值，=0收敛；=1不收敛但不发散；=2不收敛同时发散；=3收敛过程中出现问题 + */ +int Iterative(opf_common *common,opf_correct *correct,opf_decomp *decomp) +{ + int i,j,t; + double warp; //偏差 + double x; + int bjxx; + + opf_slack *p5; + opf_gij *p1; + opf_debug *p6,*p7; + + double gap,fact; + + double *derh; + + double *vmax0,*vmin0; + double *grlqijmax,*grlqijmin; + + int conv_flag; //收敛标志 + + j=common->rr-common->rv+4*common->n_sum+common->req; + derh=(double *)malloc((j+1)*sizeof(double)); + for(i=1;i<=j;i++) + derh[i]=0; + + vmax0=(double *)malloc((common->rv+1)*sizeof(double)); + vmin0=(double *)malloc((common->rv+1)*sizeof(double)); + + grlqijmax=(double *)malloc((common->rlqij+1)*sizeof(double)); + grlqijmin=(double *)malloc((common->rlqij+1)*sizeof(double)); + +// int begintime,endtime,jstime; + +// begintime = CPUTIME; + + IterativeInivar(common,correct); //迭代过程中的变量初始化 + + gap=0; + for(i=1;i<=common->rr+common->rrr;i++) + gap=gap+common->varl[i]*common->varz[i]-common->varu[i]*common->varw[i]; + common->itera_num=0; + + while(common->head_debuggap!=null) //收敛消息 + { p6=common->head_debuggap->next; + free(common->head_debuggap); + common->head_debuggap=p6; + } + + while(common->head_debugpq!=null) + { p6=common->head_debugpq->next; + free(common->head_debugpq); + common->head_debugpq=p6; + } + + while(common->head_debuglcos!=null) + { p6=common->head_debuglcos->next; + free(common->head_debuglcos); + common->head_debuglcos=p6; + } + + warp=gap; + common->gap_flag=0; //后一次的gap大于前一次的gap，gapbz=gapbz+1，后一次的gap大于前一次的gap + + bjxx=0; + + if(common->qv_slackflag==1) //对可调无功出力进行松驰 + { for(i=1;i<=common->rqg;i++) + { common->gmax[common->rp+i]=common->gmax[common->rp+i]+common->qvmax; + common->gmin[common->rp+i]=common->gmin[common->rp+i]-common->qvmin; + } + common->qv_flag=0; + } + + if(common->lineq_slackflag==1) //对变压器支路无功约束进行松驰 + { for(i=1;i<=common->rlqij;i++) + { grlqijmax[i]=common->gmax[common->rr+common->rlpij+i]; + grlqijmin[i]=common->gmin[common->rr+common->rlpij+i]; + if(common->gmax[common->rr+common->rlpij+i]>=0) + common->gmax[common->rr+common->rlpij+i]=common->gmax[common->rr+common->rlpij+i]*10; + else + common->gmax[common->rr+common->rlpij+i]=common->gmax[common->rr+common->rlpij+i]/10; + if(common->gmin[common->rr+common->rlpij+i]>=0) + common->gmin[common->rr+common->rlpij+i]=common->gmin[common->rr+common->rlpij+i]/10; + else + common->gmin[common->rr+common->rlpij+i]=common->gmin[common->rr+common->rlpij+i]*10; + } + common->lineq_flag=0; + } + + if(common->v_slackflag==1) //对所有的电压进行松驰 + { for(i=1;i<=common->rv;i++) + { vmax0[i]=common->gmax[common->rr-common->rv+i]; + vmin0[i]=common->gmin[common->rr-common->rv+i]; + common->gmax[common->rr-common->rv+i]=common->vmax; + common->gmin[common->rr-common->rv+i]=common->vmin; + } + common->v_flag=0; + } + else + { if(common->ev_slackflag==1) //对等电压限制进行松驰 + { for(i=1;i<=common->rv;i++) + { vmax0[i]=common->gmax[common->rr-common->rv+i]; + vmin0[i]=common->gmin[common->rr-common->rv+i]; + if(vmax0[i]==vmin0[i]) + { common->gmax[common->rr-common->rv+i]=common->vmax; + common->gmin[common->rr-common->rv+i]=common->vmin; + } + } + } + common->v_flag=0; + } + + if(common->obj_type_cflag==1) //是否采用目标函数控制方式，=0不用，=1用 + common->obj_type=0; + + if(warp>=common->e) + conv_flag=100; + else + conv_flag=1; + +// while ((common->itera_num<=common->itera_max)&&(warp>=common->e)) //warp可由gap和dpdq的最大值决定，也可以是gap，其实是等价的 + while ((common->itera_num<=common->itera_max)&&(conv_flag!=1)) + { + fact=common->centerparameter*gap/2/(common->rr+common->rrr); //干扰因子 + + JcbData(common,correct); //形成雅可比矩阵 + DgData(common,correct); //形成g的一阶偏导矩阵 + HeisenData(common,correct,decomp); //形成海森矩阵 + + CalHImbalance(common,correct,fact,derh); //计算海森部分的不平衡量,用derh返回 + + CalDpDq(common,correct,derh); //计算各节点功率不平衡量 + + + t=common->rr-common->rv; + p5=common->head_slack; + while(p5!=null) + { correct->d[t+4*p5->i-3]=1; //处理平衡节点，相角是不能放的，0要作为参考值 + derh[t+4*p5->i-3]=0; + if(common->slack_flag==1) //处理平衡节点 + { correct->d[t+4*p5->i-2]=1; //幅值 + derh[t+4*p5->i-2]=0; + } + p5=p5->next; + } + +/* + FILE *fp1; + fp1=fopen("Text3.txt","wb"); + t=common->rr-common->rv+4*common->n_sum+common->req; + + fprintf(fp1,"%s\n" ,"H"); + for(i=1;i<=t;i++) + { for(j=decomp->ljs[i];j<=decomp->ljs[i+1]-1;j++) + if(fabs(decomp->la[j])>0.000001) + fprintf(fp1," (%d,%d) %lf\n" ,decomp->lj[j],i,decomp->la[j]); + } + + fprintf(fp1,"%s\n" ,"d"); + j=common->rr-common->rv+4*common->n_sum+common->req; + for(i=1;i<=j;i++) + { if(fabs(correct->d[i])>=0.000001) + fprintf(fp1," (%d,%d) %lf\n" ,i,i,correct->d[i]); + } + + fprintf(fp1,"%s\n" ,"b"); + for(i=1;i<=j;i++) + if(fabs(derh[i])>=0.000001) + fprintf(fp1," (%d,1) %lf\n" ,i,derh[i]); + + fclose(fp1); +*/ + + common->overflow_flag=0; //溢出标志，=0，没有溢出，>0溢出 + +// x1= CPUTIME; + + LDL(common,decomp,correct->d,derh); //LDL分解求修正方程 + +/* + FILE *fp1; + fp1=fopen("Text3.txt","wb"); + j=common->rr-common->rv+4*common->n_sum+common->req; + for(i=1;i<=j;i++) + fprintf(fp1," (%d,1) %lf\n" ,i,derh[i]); + fclose(fp1);*/ + + + +// x2= CPUTIME; +// jstime1[common->itera_num+1]=x2-x1; + + if(common->overflow_flag==0) //如果溢出了就不要修正变量了 + { CorrectVarPD(common,correct,fact,derh); //修正原始对偶变量 + + j=common->rr-common->rv; //更新状态变量 + for(i=1;i<=common->n_sum;i++) + { common->rad[i]=common->varx[j+2*i-1]; + common->v[i]=common->varx[j+2*i]; + } + + i=1; //更新线路功率因数值 + t=common->rp+common->rq+common->rk+2*common->rkb+common->rt+common->rx; + p1=common->head_lcos; + while(p1!=null) + { if((common->varx[t+i]*common->varx[t+i]+common->varx[t+i+common->rlcos]*common->varx[t+i+common->rlcos])!=0) + p1->g=common->varx[t+i]*common->varx[t+i]/(common->varx[t+i]*common->varx[t+i]+common->varx[t+i+common->rlcos]*common->varx[t+i+common->rlcos]); + i=i+1; + p1=p1->next; + } + + i=1; //更新负荷功率功率因数值 + t=common->rp+common->rq+common->rk+2*common->rkb+common->rt+common->rx+2*common->rlcos; + p1=common->head_vdcos; + while(p1!=null) + { p1->g=common->varx[t+i]; + i=i+1; + p1=p1->next; + } + + CorrectYij(common); //修正节点导纳矩阵 + + x=ObjectiveValue(common); + } + + gap=0; + for(i=1;i<=common->rr+common->rrr;i++) + gap=gap+common->varl[i]*common->varz[i]-common->varu[i]*common->varw[i]; + + + if((gap<100)&&(common->qv_flag==0)&&(common->qv_slackflag==1)) //还原无功出力约束条件,只做一次 + { for(i=1;i<=common->rqg;i++) + { common->gmax[common->rp+i]=common->gmax[common->rp+i]-common->qvmax; + common->gmin[common->rp+i]=common->gmin[common->rp+i]+common->qvmin; + } + common->qv_flag=1; + } + + if((gap<10)&&(common->lineq_flag==0)&&(common->lineq_slackflag==1)) //还原变压器无功出力限制约束条件,只做一次 + { for(i=1;i<=common->rlqij;i++) + { common->gmax[common->rr+common->rlpij+i]=grlqijmax[i]; + common->gmin[common->rr+common->rlpij+i]=grlqijmin[i]; + } + common->lineq_flag=1; + } + + if((gap<(common->e*1000))&&(common->v_flag==0)&&((common->v_slackflag==1)||(common->ev_slackflag==1))) //还原电压约束条件,只做一次 + { for(i=1;i<=common->rv;i++) + { common->gmax[common->rr-common->rv+i]=vmax0[i]; + common->gmin[common->rr-common->rv+i]=vmin0[i]; + } + common->v_flag=1; + } + + + if((gap<(common->e*100))&&(common->obj_type_cflag==1)) //还原目标函数形式 + common->obj_type=common->obj_type0; + + common->itera_num=common->itera_num+1; + + p6=(opf_debug *)malloc(ledebug); //将gap和目标函数值保存在head_debuggap中 + p6->i=common->itera_num; //迭代次数 + p6->j=common->itera_num; + p6->x=gap; + p6->y=ObjectiveValue(common); //目标函数值 + p6->next=null; + if(common->head_debuggap==null) + common->head_debuggap=p6; + else + { p7=common->head_debuggap; + while(p7->next!=null) + p7=p7->next; + p7->next=p6; + } + + if(warpgap_flag=common->gap_flag+1; //后一次的gap大于前一次的gap，gapbz=gapbz+1 + if((common->gap_flag==2)&&(bjxx==0)) + { CheckLimit(common); //检测变量越限情况，|z|>1越下限；|w|>1越上限，相当在最低点附近采集越限问题的点 + bjxx=1; //只检测一次 + } + warp=gap; + if(common->overflow_flag>0) //if ycbz>0则认为该算例是发散的，停止跌代 + warp=0; + + if(common->obj_type==1) + CalPgCoefficient(common,warp); //计算并确定发电费用曲线 + + p6=common->head_debugpq; //warp可由gap和dpdq的最大值决定，对于大系统dpdq难以收敛到最小值 + x=0; + if(p6!=null) + { while(p6->next!=null) + p6=p6->next; + if(xx) + x=p6->x; + if(xy) + x=p6->y; + } + + t=CalGvalue(common,correct); //计算不等式约束的情况以及满足检测 + +// if((gap<=common->e)||((gap<0.001)&&(x<0.01))||((gap<0.01)&&(x<0.1))&&(t==0)) + if(gap<=common->e) + conv_flag=1; + + } + + +// endtime = CPUTIME; +// jstime=endtime-begintime; + + + t=4; + if(common->overflow_flag>0) //发散 + { + t=2; + } + if((gap<=common->e)||(conv_flag==1)) //收敛 + { + CalResult(common,correct); //计算结果 + t=0; + } + if(common->itera_num>=common->itera_max) //不收敛但不发散 + { + t=1; + } + + + if(((common->head_kij!=null)||(common->head_ti!=null))&&(t==0)) + { switch(common->cc_flag) + { case 0: + { + CalTap(common); //修正变压器分接头 + break; + } + case 1: //连续化归整处理 + { t=Iterative_cic(common,correct,decomp,t); //连续化后进行归整，再进行第二次连续化迭代 + break; + } + default: //其他情况 + break; + } + common->itera_num=common->itera_num+common->itera_num_cic; + } + + free(vmax0); + free(vmin0); + free(grlqijmax); + free(grlqijmin); + free(derh); + return t; + +} + +int Iterative_cic(opf_common *com,opf_correct *cor,opf_decomp *deco ,int tg) //连续化后进行归整，再进行第二次连续化迭代 +{ + + int i,j,t; + double warp; //偏差 + double x,r,y; + int bjxx; + + opf_kij *p1; + opf_yij *p2; + opf_slack *p5; + opf_debug *p6,*p7; + opf_equalitykij *p15; + + double gap,fact; + + double *vmax0,*vmin0; + double *derh; + + int conv_flag; //收敛标志 + + vmax0=(double *)malloc((com->rv+1)*sizeof(double)); + vmin0=(double *)malloc((com->rv+1)*sizeof(double)); + + j=com->rr-com->rv+4*com->n_sum+com->req; + derh=(double *)malloc((j+1)*sizeof(double)); + for(i=1;i<=j;i++) + derh[i]=0; + + com->gap_flag=0; //后一次的gap大于前一次的gap，gapbz=gapbz+1，后一次的gap大于前一次的gap + + bjxx=0; + + if((tg==0)&&((com->head_kij!=null)||(com->head_ti!=null))) //收敛成功，可以进行变压器抽头或电容器的连续化规整 + { + +/*原来希望可以从第一次迭代的结果启动，所有的状态变量和控制变量*/ + for(i=1;i<=com->rr+com->rrr;i++) + { com->varl[i]=1; + com->varu[i]=1; + com->varz[i]=1; + com->varw[i]=-1; + } + for(i=1;i<=2*com->n_sum+com->req;i++) + com->vary[i]=0.1; + +// IterativeInivar(com,cor); //迭代过程中的变量初始化 + + com->centerparameter=0.1; //中心参数 + gap=0; + for(i=1;i<=com->rr+com->rrr;i++) + gap=gap+com->varl[i]*com->varz[i]-com->varu[i]*com->varw[i]; + com->itera_num_cic=0; + + warp=gap; + com->gap_flag=0; //后一次的gap大于前一次的gap，gapbz=gapbz+1，后一次的gap大于前一次的gap + + bjxx=0; + +// **************** + p1=com->head_kij; //确定最靠近的档位 + i=1; + while(p1!=null) + { p1->k0=p1->k; + + if((p1->t-1)!=0) //每个档位的量(还原成原来的) + x=(1/p1->down-1/p1->up)/(p1->t-1); + else + x=1/p1->down-1/p1->up; + + r=1/p1->k-1/p1->up; + y=1/p1->up+floor(r/x)*x; //最小整数值，floor(r/x)最小的整数，原来的 + if(y<1/p1->up) + p1->k2=p1->down; + else + p1->k2=1/y; + y=1/p1->up+(floor(r/x)+1)*x; //最大整数值，floor(r/x)最小的整数，原来的 + if(y>1/p1->down) + p1->k1=p1->up; + else + p1->k1=1/y; + t=1; + if((p1->k-p1->k1)<(p1->k2-p1->k)) //按四舍五入确定分接头，变压器将取定值，不参与迭代 + { com->varx[com->rp+com->rq+i]=p1->k1; + p1->flag=1; + } + else + { com->varx[com->rp+com->rq+i]=p1->k2; + p1->flag=1; + } + + if(t==1) //按照变压器新值修改节点导纳矩阵 + { j=0; + p2=com->a[p1->i]; //是按照行排列的,Yij + if(p2!=null) + { while((p2->irow==p1->i)&&(j==0)) + { if(p2->jcol==p1->j) + { r=p2->amp*cos(p2->rad)+(com->varx[com->rp+com->rq+i]-p1->k)*p1->amp*cos(p1->rad); + x=p2->amp*sin(p2->rad)+(com->varx[com->rp+com->rq+i]-p1->k)*p1->amp*sin(p1->rad); + p2->amp=sqrt(r*r+x*x); + p2->rad=atan2(x,r); + j=1; + } + else + { if(p2->next==null) + j=1; + else + p2=p2->next; + } + } + } + j=0; + p2=com->a[p1->j]; //是按照行排列的,Yji + if(p2!=null) + { while((p2->irow==p1->j)&&(j==0)) + { if(p2->jcol==p1->i) + { r=p2->amp*cos(p2->rad)+(com->varx[com->rp+com->rq+i]-p1->k)*p1->amp*cos(p1->rad); + x=p2->amp*sin(p2->rad)+(com->varx[com->rp+com->rq+i]-p1->k)*p1->amp*sin(p1->rad); + p2->amp=sqrt(r*r+x*x); + p2->rad=atan2(x,r); + j=1; + } + else + { if(p2->next==null) + j=1; + else + p2=p2->next; + } + } + } + x=(com->varx[com->rp+com->rq+i]*com->varx[com->rp+com->rq+i]-p1->k*p1->k)*p1->amp; //Yii + r=com->g[p1->i]*cos(com->b[p1->i])-x*cos(p1->rad); + x=com->g[p1->i]*sin(com->b[p1->i])-x*sin(p1->rad); + com->g[p1->i]=sqrt(r*r+x*x); + com->b[p1->i]=atan2(x,r); + p1->k=com->varx[com->rp+com->rq+i]; + } + + if(p1->flag==1) + { com->gmax[com->rp+com->rq+i]=com->varx[com->rp+com->rq+i]; + com->gmin[com->rp+com->rq+i]=com->varx[com->rp+com->rq+i]; + } + + + i=i+1; + p1=p1->next; + } + + p1=com->head_ti; //确定最靠近的档位(可调电容器电抗器部分) + i=1; + while(p1!=null) + { p1->k0=p1->k; + + if((p1->t-1)!=0) //每个档位的量(还原成原来的) + x=(p1->up-p1->down)/(p1->t-1); + else + x=p1->up-p1->down; + + r=p1->k-p1->down; + y=p1->down+floor(r/x)*x; //最小整数值，floor(r/x)最小的整数，原来的 + if(ydown) + p1->k1=p1->down; + else + p1->k1=y; + y=p1->down+(floor(r/x)+1)*x; //最大整数值，floor(r/x)最小的整数，原来的 + if(y>p1->up) + p1->k2=p1->up; + else + p1->k2=y; + + t=1; + if((p1->k-p1->k1)<(p1->k2-p1->k)) //按四舍五入确定分接头，电容器将取定值，不参与迭代 + { com->varx[com->rp+com->rq+com->rk+2*com->rkb+i]=p1->k1; + p1->flag=1; + } + else + { com->varx[com->rp+com->rq+com->rk+2*com->rkb+i]=p1->k2; + p1->flag=1; + } + + if(t==1) //按照电容器新值修改节点导纳矩阵 + { j=com->rp+com->rq+com->rk+2*com->rkb; + + x=(com->varx[j+i]-p1->k)*p1->amp; //Yii + r=com->g[p1->i]*cos(com->b[p1->i])+x*cos(p1->rad); + x=com->g[p1->i]*sin(com->b[p1->i])+x*sin(p1->rad); + com->g[p1->i]=sqrt(r*r+x*x); + com->b[p1->i]=atan2(x,r); + + p1->k=com->varx[j+i]; //更新变比 + } + +/* + if(p1->flag==1) + { com->gmax[com->rp+com->rq+com->rk+2*com->rkb+i]=com->varx[com->rp+com->rq+com->rk+2*com->rkb+i]; + com->gmin[com->rp+com->rq+com->rk+2*com->rkb+i]=com->varx[com->rp+com->rq+com->rk+2*com->rkb+i]; + }*/ + + + i=i+1; + p1=p1->next; + } + + if(com->obj_type_cflag==1) //是否采用目标函数控制方式，=0不用，=1用 + com->obj_type=0; + + if(com->v_slackflag==1) //对电压进行松驰 + { for(i=1;i<=com->rv;i++) + { vmax0[i]=com->gmax[com->rr-com->rv+i]; + vmin0[i]=com->gmin[com->rr-com->rv+i]; + com->gmax[com->rr-com->rv+i]=com->vmax; + com->gmin[com->rr-com->rv+i]=com->vmin; + } + com->v_flag=0; + } + + if(com->qv_slackflag==0) + { com->qv_slackflag=1; + com->qvmax=0.5; + com->qvmin=0.5; + } + + if(com->obj_type==100) + com->qv_slackflag=1; + + if(com->qv_slackflag==1) //对可调无功出力进行松驰 + { for(i=1;i<=com->rqg;i++) + { com->gmax[com->rp+i]=com->gmax[com->rp+i]+com->qvmax; + com->gmin[com->rp+i]=com->gmin[com->rp+i]-com->qvmin; + } + com->qv_flag=0; + } + + if(warp>=com->e) + conv_flag=100; + else + conv_flag=1; + + +// while((com->itera_num_cic<=com->itera_max)&&(warp>=com->e))//warp可由gap和dpdq的最大值决定 + while ((com->itera_num_cic<=com->itera_max)&&(conv_flag!=1)) + { + fact=com->centerparameter*gap/2/(com->rr+com->rrr); //干扰因子 + + JcbData(com,cor); //形成雅可比矩阵 + DgData(com,cor); //形成g的一阶偏导矩阵 + HeisenData(com,cor,deco); //形成海森矩阵 + + CalHImbalance(com,cor,fact,derh); //计算海森部分的不平衡量,用derh返回 + + CalDpDq(com,cor,derh); //计算各节点功率不平衡量 + + + t=com->rr-com->rv; + p5=com->head_slack; + while(p5!=null) + { cor->d[t+4*p5->i-3]=1; //处理平衡节点，相角是不能放的，0要作为参考值 + derh[t+4*p5->i-3]=0; + if(com->slack_flag==1) //处理平衡节点 + { cor->d[t+4*p5->i-2]=1; //幅值 + derh[t+4*p5->i-2]=0; + } + p5=p5->next; + } + +//已经确定的可调变压器抽头，不进行计算了 + + if(com->reqkij==0) + { p1=com->head_kij; + i=1; + while(p1!=null) + { if(p1->flag==1) + { cor->d[com->rp+com->rq+i]=99999; + derh[com->rp+com->rq+i]=0; + for(j=deco->ljs[com->rp+com->rq+i];j<=deco->ljs[com->rp+com->rq+i+1]-1;j++) + deco->la[j]=0; + for(j=deco->lis[com->rp+com->rq+i];j<=deco->lis[com->rp+com->rq+i+1]-1;j++) + deco->la[j]=0; + } + i=i+1; + p1=p1->next; + } + } + +//已经确定的可调电容器抽头，不进行计算了 + + p1=com->head_ti; + i=1; + while(p1!=null) + { if(p1->flag==1) + { cor->d[com->rp+com->rq+com->rk+2*com->rkb+i]=1; + derh[com->rp+com->rq+com->rk+2*com->rkb+i]=0; + for(j=deco->ljs[com->rp+com->rq+com->rk+2*com->rkb+i];j<=deco->ljs[com->rp+com->rq+com->rk+2*com->rkb+i+1]-1;j++) + deco->la[j]=0; + for(j=deco->lis[com->rp+com->rq+com->rk+2*com->rkb+i];j<=deco->lis[com->rp+com->rq+com->rk+2*com->rkb+i+1]-1;j++) + deco->la[j]=0; + } + i=i+1; + p1=p1->next; + } + +/* + p15=com->head_eqkij; + i=1; + while(p15!=null) + { cor->d[com->rr-com->rv+4*com->n_sum+2*com->rlcos+com->rvdcos+3*com->n_dc+i]=0.000001; + derh[com->rr-com->rv+4*com->n_sum+2*com->rlcos+com->rvdcos+3*com->n_dc+i]=0; + for(j=deco->ljs[com->rr-com->rv+4*com->n_sum+2*com->rlcos+com->rvdcos+3*com->n_dc+i];j<=deco->ljs[com->rr-com->rv+4*com->n_sum+2*com->rlcos+com->rvdcos+3*com->n_dc+i+1]-1;j++) + deco->la[j]=0; + for(j=deco->lis[com->rr-com->rv+4*com->n_sum+2*com->rlcos+com->rvdcos+3*com->n_dc+i];j<=deco->lis[com->rr-com->rv+4*com->n_sum+2*com->rlcos+com->rvdcos+3*com->n_dc+i+1]-1;j++) + deco->la[j]=0; + i=i+1; + p15=p15->next; + }*/ + + + com->overflow_flag=0; //溢出标志，=0，没有溢出，>0溢出 + +// x1= CPUTIME; + +/* + FILE *fp1; + fp1=fopen("Text3.txt","wb"); + j=com->rr-com->rv+4*com->n_sum; + for(i=1;i<=j;i++) + if(fabs(derh[i])>=0.000001) + fprintf(fp1," (%d,1) %lf\n" ,i,derh[i]); + fclose(fp1);*/ + + + LDL(com,deco,cor->d,derh); //LDL分解求修正方程 + + // x2= CPUTIME; + // jstime1[com->itera_num+1]=x2-x1; + + if(com->overflow_flag==0) //如果溢出了就不要修正变量了 + { CorrectVarPD(com,cor,fact,derh); //修正原始对偶变量 + + j=com->rr-com->rv; //更新状态变量 + for(i=1;i<=com->n_sum;i++) + { com->rad[i]=com->varx[j+2*i-1]; + com->v[i]=com->varx[j+2*i]; + } + +// CorrectYij(com); //修正节点导纳矩阵 + + x=ObjectiveValue(com); + } + + gap=0; + for(i=1;i<=com->rr+com->rrr;i++) + gap=gap+com->varl[i]*com->varz[i]-com->varu[i]*com->varw[i]; + + com->itera_num_cic=com->itera_num_cic+1; + +/* + if((gap<0.001)&&(com->obj_type_cflag==1)) //还原目标函数形式 + com->obj_type=com->obj_type0;*/ + + if((gap<100)&&(com->qv_flag==0)&&(com->qv_slackflag==1)) //还原无功出力约束条件,只做一次 + { for(i=1;i<=com->rqg;i++) + { com->gmax[com->rp+i]=com->gmax[com->rp+i]-com->qvmax; + com->gmin[com->rp+i]=com->gmin[com->rp+i]+com->qvmin; + } + com->qv_flag=1; + } + + if((gap<0.001)&&(com->v_flag==0)&&(com->v_slackflag==1)) //还原电压约束条件,只做一次 + { for(i=1;i<=com->rv;i++) + { if((com->v[i]-vmax0[i]>0.01)||(vmin0[i]-com->v[i]>=0.01)) //控制电压，不让电压离得太远，控制一下精度就可以了 + { com->gmax[com->rr-com->rv+i]=vmax0[i]+0.01; + com->gmin[com->rr-com->rv+i]=vmin0[i]-0.01; + } + else + { com->gmax[com->rr-com->rv+i]=vmax0[i]; + com->gmin[com->rr-com->rv+i]=vmin0[i]; + } + } + com->v_flag=1; + } + + p6=(opf_debug *)malloc(ledebug); //将gap和目标函数值保存在head_debuggap中 + p6->i=com->itera_num_cic; //迭代次数 + p6->j=com->itera_num_cic; + p6->x=gap; +// p6->x=r; + p6->y=x; //目标函数值 + p6->next=null; + if(com->head_debuggap==null) + com->head_debuggap=p6; + else + { p7=com->head_debuggap; + while(p7->next!=null) + p7=p7->next; + p7->next=p6; + } + + if(warpgap_flag=com->gap_flag+1; //后一次的gap大于前一次的gap，gapbz=gapbz+1 + if((com->gap_flag==2)&&(bjxx==0)) + { CheckLimit(com); //检测变量越限情况，|z|>1越下限；|w|>1越上限，相当在最低点附近采集越限问题的点 + bjxx=1; //只检测一次 + } + warp=gap; + if(com->overflow_flag>0) //if ycbz>0则认为该算例是发散的，停止跌代 + warp=0; + + p6=com->head_debugpq; //warp可由gap和dpdq的最大值决定，对于大系统dpdq难以收敛到最小值 + x=0; + if(p6!=null) + { while(p6->next!=null) + p6=p6->next; + if(xx) + x=p6->x; + if(xy) + x=p6->y; + } + if((gap<=com->e)||((gap<0.001)&&(x<0.01))) + conv_flag=1; + } + } + + t=3; + if(com->overflow_flag>0) //发散 + { + t=2; + } + if((gap<=com->e)||(conv_flag==1)) //收敛 + { + CalResult(com,cor); //计算结果 + t=0; + } + if(com->itera_num_cic>=com->itera_max) //不收敛但不发散 + { + t=1; + } + + free(vmax0); + free(vmin0); + free(derh); + return t; +} + +void CalTap(opf_common *com) //修正变压器分接头 +{ + int i,j,t; + double x,r,y; + + opf_kij *p1; + opf_yij *p2; + + if(((com->head_kij!=null)||(com->head_ti!=null))) //收敛成功，可以进行变压器抽头或电容器的连续化规整 + { + +// **************** + p1=com->head_kij; //确定最靠近的档位 + i=1; + while(p1!=null) + { p1->k0=p1->k; + + if((p1->t-1)!=0) //每个档位的量(还原成原来的) + x=(1/p1->down-1/p1->up)/(p1->t-1); + else + x=1/p1->down-1/p1->up; + + r=1/p1->k-1/p1->up; + y=1/p1->up+floor(r/x)*x; //最小整数值，floor(r/x)最小的整数，原来的 + if(y<1/p1->up) + p1->k2=p1->down; + else + p1->k2=1/y; + y=1/p1->up+(floor(r/x)+1)*x; //最大整数值，floor(r/x)最小的整数，原来的 + if(y>1/p1->down) + p1->k1=p1->up; + else + p1->k1=1/y; + t=1; + if((p1->k-p1->k1)<(p1->k2-p1->k)) //按四舍五入确定分接头，变压器将取定值，不参与迭代 + { com->varx[com->rp+com->rq+i]=p1->k1; + p1->flag=1; + } + else + { com->varx[com->rp+com->rq+i]=p1->k2; + p1->flag=1; + } + + if(t==1) //按照变压器新值修改节点导纳矩阵 + { j=0; + p2=com->a[p1->i]; //是按照行排列的,Yij + if(p2!=null) + { while((p2->irow==p1->i)&&(j==0)) + { if(p2->jcol==p1->j) + { r=p2->amp*cos(p2->rad)+(com->varx[com->rp+com->rq+i]-p1->k)*p1->amp*cos(p1->rad); + x=p2->amp*sin(p2->rad)+(com->varx[com->rp+com->rq+i]-p1->k)*p1->amp*sin(p1->rad); + p2->amp=sqrt(r*r+x*x); + p2->rad=atan2(x,r); + j=1; + } + else + { if(p2->next==null) + j=1; + else + p2=p2->next; + } + } + } + j=0; + p2=com->a[p1->j]; //是按照行排列的,Yji + if(p2!=null) + { while((p2->irow==p1->j)&&(j==0)) + { if(p2->jcol==p1->i) + { r=p2->amp*cos(p2->rad)+(com->varx[com->rp+com->rq+i]-p1->k)*p1->amp*cos(p1->rad); + x=p2->amp*sin(p2->rad)+(com->varx[com->rp+com->rq+i]-p1->k)*p1->amp*sin(p1->rad); + p2->amp=sqrt(r*r+x*x); + p2->rad=atan2(x,r); + j=1; + } + else + { if(p2->next==null) + j=1; + else + p2=p2->next; + } + } + } + x=(com->varx[com->rp+com->rq+i]*com->varx[com->rp+com->rq+i]-p1->k*p1->k)*p1->amp; //Yii + r=com->g[p1->i]*cos(com->b[p1->i])-x*cos(p1->rad); + x=com->g[p1->i]*sin(com->b[p1->i])-x*sin(p1->rad); + com->g[p1->i]=sqrt(r*r+x*x); + com->b[p1->i]=atan2(x,r); + p1->k=com->varx[com->rp+com->rq+i]; + } + + if(p1->flag==1) + { com->gmax[com->rp+com->rq+i]=com->varx[com->rp+com->rq+i]; + com->gmin[com->rp+com->rq+i]=com->varx[com->rp+com->rq+i]; + } + + + i=i+1; + p1=p1->next; + } + + p1=com->head_ti; //确定最靠近的档位(可调电容器电抗器部分) + i=1; + while(p1!=null) + { p1->k0=p1->k; + + if((p1->t-1)!=0) //每个档位的量(还原成原来的) + x=(p1->up-p1->down)/(p1->t-1); + else + x=p1->up-p1->down; + + r=p1->k-p1->down; + y=p1->down+floor(r/x)*x; //最小整数值，floor(r/x)最小的整数，原来的 + if(ydown) + p1->k1=p1->down; + else + p1->k1=y; + y=p1->down+(floor(r/x)+1)*x; //最大整数值，floor(r/x)最小的整数，原来的 + if(y>p1->up) + p1->k2=p1->up; + else + p1->k2=y; + + t=1; + if((p1->k-p1->k1)<(p1->k2-p1->k)) //按四舍五入确定分接头，电容器将取定值，不参与迭代 + { com->varx[com->rp+com->rq+com->rk+2*com->rkb+i]=p1->k1; + p1->flag=1; + } + else + { com->varx[com->rp+com->rq+com->rk+2*com->rkb+i]=p1->k2; + p1->flag=1; + } + + if(t==1) //按照电容器新值修改节点导纳矩阵 + { j=com->rp+com->rq+com->rk+2*com->rkb; + + x=(com->varx[j+i]-p1->k)*p1->amp; //Yii + r=com->g[p1->i]*cos(com->b[p1->i])+x*cos(p1->rad); + x=com->g[p1->i]*sin(com->b[p1->i])+x*sin(p1->rad); + com->g[p1->i]=sqrt(r*r+x*x); + com->b[p1->i]=atan2(x,r); + + p1->k=com->varx[j+i]; //更新变比 + } + +/* + if(p1->flag==1) + { com->gmax[com->rp+com->rq+com->rk+2*com->rkb+i]=com->varx[com->rp+com->rq+com->rk+2*com->rkb+i]; + com->gmin[com->rp+com->rq+com->rk+2*com->rkb+i]=com->varx[com->rp+com->rq+com->rk+2*com->rkb+i]; + }*/ + + + i=i+1; + p1=p1->next; + } + + } + + return; +} + +/******迭代过程中的变量初始化******/ +void IterativeInivar(opf_common *com,opf_correct *cor ) +{ + int i,j; + opf_slack *p5; + + for(i=1;i<=com->n_sum;i++) + { com->rad[i]=0; + com->v[i]=1; + } + + p5=com->head_slack; + while(p5!=null) + { com->v[p5->i]=p5->v; + p5=p5->next; + } + + for(i=1;i<=2*com->n_sum+com->req;i++) + com->vary[i]=0.1; + + j=com->rr-com->rv; + for(i=1;i<=com->n_sum;i++) + { com->varx[j+i*2-1]=com->rad[i]; + com->varx[j+i*2]=com->v[i]; + } + + if(com->inizlwu==1) + { CalResult(com,cor); //计算g值 + for(i=1;i<=com->rr+com->rrr;i++) + { + if(com->gvalue[i]-com->gmin[i]!=0) + com->varl[i]=com->gvalue[i]-com->gmin[i]; + else + com->varl[i]=1; + if(com->gmax[i]-com->gvalue[i]!=0) + com->varu[i]=com->gmax[i]-com->gvalue[i]; + else + com->varu[i]=1; + // com->varl[i]=com->gvalue[i]-com->gmin[i]; + // com->varu[i]=com->gmax[i]-com->gvalue[i]; + + com->varz[i]=1; + com->varw[i]=-1; + } + } + else + { for(i=1;i<=com->rr+com->rrr;i++) + { com->varl[i]=1; + com->varu[i]=1; + com->varz[i]=1; + com->varw[i]=-1; + } + } + + return; +} + +/******形成雅可比矩阵******/ +void JcbData(opf_common *com,opf_correct *cor) +{ int i,j,t,n,k,m; + double x,r,x1; + double ap,bp,aq,bq; + + opf_yij *p1; + opf_matrix *p3; + opf_kij *p6; + opf_vpdqd *p2; + opf_gij *p8; + opf_line *p9; + opf_dcbus *p10,*p11; + opf_equalitykij *p12; + + int kk; + double *v,*rad; + + v=(double *)malloc((com->n_sum+1)*sizeof(double)); //减少打字，看上去简洁些 + rad=(double *)malloc((com->n_sum+1)*sizeof(double)); + for(i=1;i<=com->n_sum;i++) + { v[i]=com->v[i]; + rad[i]=com->rad[i]; + } + + t=com->rr-com->rv+2*com->n_sum; //清0,统一清0 + for(i=1;i<=t;i++) + { p3=cor->jcb[i]; + while(p3!=null) + { p3->z=0; + p3=p3->next; + } + } + + + p3=(opf_matrix *)malloc(lematrix); + m=com->rr-com->rv; + for(i=1;i<=com->rpg+com->rpge;i++) //有功出力部分 + { p3->irow=com->gp[i]*2-1; + p3->jcol=i; + p3->z=1; + cor->jcb[p3->jcol]=insert2(cor->jcb[p3->jcol],p3,&kk); + if(kk==0) + p3=(opf_matrix *)malloc(lematrix); + } + for(i=1;i<=com->rpd;i++) //有功负荷部分 + { p3->irow=com->gp[com->rpg+com->rpge+i]*2-1; + p3->jcol=i+com->rpg+com->rpge; + p3->z=-1; + cor->jcb[p3->jcol]=insert2(cor->jcb[p3->jcol],p3,&kk); + if(kk==0) + p3=(opf_matrix *)malloc(lematrix); + } + for(i=1;i<=com->rqg+com->rqge;i++) //无功出力部分 + { p3->irow=com->gq[i]*2; + p3->jcol=i+com->rp; + p3->z=1; + cor->jcb[p3->jcol]=insert2(cor->jcb[p3->jcol],p3,&kk); + if(kk==0) + p3=(opf_matrix *)malloc(lematrix); + } + for(i=1;i<=com->rqd;i++) //无功负荷部分 + { p3->irow=com->gq[com->rqg+com->rqge+i]*2; + p3->jcol=i+com->rp+com->rqg+com->rqge; + p3->z=-1; + cor->jcb[p3->jcol]=insert2(cor->jcb[p3->jcol],p3,&kk); + if(kk==0) + p3=(opf_matrix *)malloc(lematrix); + } + free(p3); + + + t=com->rr-com->rv; //潮流方程，交流变量 + for(i=1;i<=com->n_sum;i++) + { p3=cor->jcb[t+2*i-1]; + while(p3!=null) + { if(p3->irow<=2*com->n_sum) //这部分是H或J + { j=p3->irow; + n=(j+1)/2; //n对应的行号，i是列号 +// if(fmod(j,2)!=0) //表示H + if((j%2)!=0) + { if(n==i) //表示Hii + { p1=com->a[n]; + x=0; + k=0; + while((p1->irow==n)&&(k==0)) + { x=x+p1->amp*v[p1->jcol]*sin(rad[p1->irow]-rad[p1->jcol]-p1->rad); + if(p1->next==null) + k=1; + else + p1=p1->next; + } + x=x*v[n]; + p3->z=x; + } + else //表示Hij + { p1=com->a[n]; + while(p1->jcol!=i) + p1=p1->next; + p3->z=-v[p1->irow]*p1->amp*v[p1->jcol]*sin(rad[p1->irow]-rad[p1->jcol]-p1->rad); + } + } + else //表示J + { if(n==i) //表示Jii + { p1=com->a[n]; + x=0; + k=0; + while((p1->irow==n)&&(k==0)) + { x=x+p1->amp*v[p1->jcol]*cos(rad[p1->irow]-rad[p1->jcol]-p1->rad); + if(p1->next==null) + k=1; + else + p1=p1->next; + } + x=x*v[n]; + p3->z=-x; + } + else //表示Jij + { p1=com->a[n]; + while(p1->jcol!=i) + p1=p1->next; + p3->z=v[p1->irow]*p1->amp*v[p1->jcol]*cos(rad[p1->irow]-rad[p1->jcol]-p1->rad); + } + } + } + p3=p3->next; + } + p3=cor->jcb[t+2*i]; + while(p3!=null) + { if(p3->irow<=2*com->n_sum) //这部分是N或L + { j=p3->irow; + n=(j+1)/2; //n对应的行号，i是列号 +// if(fmod(j,2)!=0) //表示N + if((j%2)!=0) + { if(n==i) //表示Nii + { p1=com->a[n]; + x=0; + k=0; + while((p1->irow==n)&&(k==0)) + { x=x+p1->amp*v[p1->jcol]*cos(rad[p1->irow]-rad[p1->jcol]-p1->rad); + if(p1->next==null) + k=1; + else + p1=p1->next; + } + p3->z=-(x+2*v[n]*com->g[n]*cos(com->b[n])); + } + else //表示Nij + { p1=com->a[n]; + while(p1->jcol!=i) + p1=p1->next; + p3->z=-v[p1->irow]*p1->amp*cos(rad[p1->irow]-rad[p1->jcol]-p1->rad); + } + } + else //表示L + { if(n==i) //表示Lii + { p1=com->a[n]; + x=0; + k=0; + while((p1->irow==n)&&(k==0)) + { x=x+p1->amp*v[p1->jcol]*sin(rad[p1->irow]-rad[p1->jcol]-p1->rad); + if(p1->next==null) + k=1; + else + p1=p1->next; + } + p3->z=-(x-2*v[n]*com->g[n]*sin(com->b[n])); + } + else //表示Lij + { p1=com->a[n]; + while(p1->jcol!=i) + p1=p1->next; + p3->z=-v[p1->irow]*p1->amp*sin(rad[p1->irow]-rad[p1->jcol]-p1->rad); + } + } + } + p3=p3->next; + } + } + + n=com->rp+com->rq; //这是关于可调变压器、电容器、线路电抗部分部分，可能ij之间有两个变压器，所以不能用位置来判断，只能重新形成 +/* + for(i=n+1;i<=n+com->rk+2*com->rkb+com->rt+com->rx;i++) //先清0链表再形成 + { p3=cor->jcb[i]; + while(p3!=null) + { p3->z=0; + p3=p3->next; + } + } */ + + + p3=(opf_matrix *)malloc(lematrix); + n=com->rp+com->rq; + p6=com->head_kij; //可调变压器变比部分（确定数值） 功率方程 + i=1; + while(p6!=null) + { p3->irow=p6->i*2-1; // aPi/akij + p3->jcol=n+i; + p3->z=2*v[p6->i]*v[p6->i]*p6->k*p6->amp*cos(p6->rad)-v[p6->i]*p6->amp*v[p6->j]*cos(rad[p6->i]-rad[p6->j]-p6->rad); + cor->jcb[p3->jcol]=insert2(cor->jcb[p3->jcol],p3,&kk); + if(kk==0) + p3=(opf_matrix *)malloc(lematrix); + + p3->irow=p6->j*2-1; // aPj/akij + p3->jcol=n+i; + p3->z=-v[p6->j]*p6->amp*v[p6->i]*cos(rad[p6->j]-rad[p6->i]-p6->rad); + cor->jcb[p3->jcol]=insert2(cor->jcb[p3->jcol],p3,&kk); + if(kk==0) + p3=(opf_matrix *)malloc(lematrix); + + p3->irow=p6->i*2; // aQi/akij + p3->jcol=n+i; + p3->z=-2*v[p6->i]*v[p6->i]*p6->k*p6->amp*sin(p6->rad)-v[p6->i]*p6->amp*v[p6->j]*sin(rad[p6->i]-rad[p6->j]-p6->rad); + cor->jcb[p3->jcol]=insert2(cor->jcb[p3->jcol],p3,&kk); + if(kk==0) + p3=(opf_matrix *)malloc(lematrix); + + p3->irow=p6->j*2; // aQj/akij + p3->jcol=n+i; + p3->z=-v[p6->j]*p6->amp*v[p6->i]*sin(rad[p6->j]-rad[p6->i]-p6->rad); + cor->jcb[p3->jcol]=insert2(cor->jcb[p3->jcol],p3,&kk); + if(kk==0) + p3=(opf_matrix *)malloc(lematrix); + + i=i+1; + p6=p6->next; + } + + n=com->rp+com->rq+com->rk; + p6=com->head_kbij; //可调移相器变比部分（确定数值） 功率方程 + i=1; + while(p6!=null) + { //kij + p3->irow=p6->i*2-1; // aPi/akij + p3->jcol=n+i; + p3->z=2*v[p6->i]*v[p6->i]*p6->k*p6->amp*cos(p6->rad)-v[p6->i]*p6->amp*v[p6->j]*cos(rad[p6->i]-rad[p6->j]-p6->rad+p6->b); + cor->jcb[p3->jcol]=insert2(cor->jcb[p3->jcol],p3,&kk); + if(kk==0) + p3=(opf_matrix *)malloc(lematrix); + + p3->irow=p6->j*2-1; // aPj/akij + p3->jcol=n+i; + p3->z=-v[p6->j]*p6->amp*v[p6->i]*cos(rad[p6->j]-rad[p6->i]-p6->rad-p6->b); + cor->jcb[p3->jcol]=insert2(cor->jcb[p3->jcol],p3,&kk); + if(kk==0) + p3=(opf_matrix *)malloc(lematrix); + + p3->irow=p6->i*2; // aQi/akij + p3->jcol=n+i; + p3->z=-2*v[p6->i]*v[p6->i]*p6->k*p6->amp*sin(p6->rad)-v[p6->i]*p6->amp*v[p6->j]*sin(rad[p6->i]-rad[p6->j]-p6->rad+p6->b); + cor->jcb[p3->jcol]=insert2(cor->jcb[p3->jcol],p3,&kk); + if(kk==0) + p3=(opf_matrix *)malloc(lematrix); + + p3->irow=p6->j*2; // aQj/akij + p3->jcol=n+i; + p3->z=-v[p6->j]*p6->amp*v[p6->i]*sin(rad[p6->j]-rad[p6->i]-p6->rad-p6->b); + cor->jcb[p3->jcol]=insert2(cor->jcb[p3->jcol],p3,&kk); + if(kk==0) + p3=(opf_matrix *)malloc(lematrix); + +//bij + p3->irow=p6->i*2-1; // aPi/abij + p3->jcol=n+com->rkb+i; + p3->z=v[p6->i]*p6->k*p6->amp*v[p6->j]*sin(rad[p6->i]-rad[p6->j]-p6->rad+p6->b); + cor->jcb[p3->jcol]=insert2(cor->jcb[p3->jcol],p3,&kk); + if(kk==0) + p3=(opf_matrix *)malloc(lematrix); + + p3->irow=p6->j*2-1; // aPj/abij + p3->jcol=n+com->rkb+i; + p3->z=-v[p6->j]*p6->k*p6->amp*v[p6->i]*sin(rad[p6->j]-rad[p6->i]-p6->rad-p6->b); + cor->jcb[p3->jcol]=insert2(cor->jcb[p3->jcol],p3,&kk); + if(kk==0) + p3=(opf_matrix *)malloc(lematrix); + + p3->irow=p6->i*2; // aQi/abij + p3->jcol=n+com->rkb+i; + p3->z=-v[p6->i]*p6->k*p6->amp*v[p6->j]*cos(rad[p6->i]-rad[p6->j]-p6->rad+p6->b); + cor->jcb[p3->jcol]=insert2(cor->jcb[p3->jcol],p3,&kk); + if(kk==0) + p3=(opf_matrix *)malloc(lematrix); + + p3->irow=p6->j*2; // aQj/abij + p3->jcol=n+com->rkb+i; + p3->z=v[p6->j]*p6->k*p6->amp*v[p6->i]*cos(rad[p6->j]-rad[p6->i]-p6->rad-p6->b); + cor->jcb[p3->jcol]=insert2(cor->jcb[p3->jcol],p3,&kk); + if(kk==0) + p3=(opf_matrix *)malloc(lematrix); + + i=i+1; + p6=p6->next; + } + + + n=com->rp+com->rq+com->rk+2*com->rkb; + p6=com->head_ti; //可调电容器部分（确定数值） 功率方程 + i=1; + while(p6!=null) + { + p3->irow=p6->i*2-1; // aPi/ati + p3->jcol=n+i; + p3->z=-v[p6->i]*v[p6->i]*p6->amp*cos(p6->rad); + cor->jcb[p3->jcol]=insert2(cor->jcb[p3->jcol],p3,&kk); + if(kk==0) + p3=(opf_matrix *)malloc(lematrix); + + p3->irow=p6->i*2; // aQi/ati + p3->jcol=n+i; + p3->z=v[p6->i]*v[p6->i]*p6->amp*sin(p6->rad); + cor->jcb[p3->jcol]=insert2(cor->jcb[p3->jcol],p3,&kk); + if(kk==0) + p3=(opf_matrix *)malloc(lematrix); + + i=i+1; + p6=p6->next; + } + + n=com->rp+com->rq+com->rk+2*com->rkb+com->rt; + p6=com->head_kx; //可调线路电抗部分（确定数值） 功率方程 + i=1; + while(p6!=null) + { p3->irow=p6->i*2-1; // aPi/akxij + p3->jcol=n+i; + p3->z=v[p6->i]*v[p6->i]*p6->amp*cos(p6->rad)-v[p6->i]*p6->amp*v[p6->j]*cos(rad[p6->i]-rad[p6->j]-p6->rad); + cor->jcb[p3->jcol]=insert2(cor->jcb[p3->jcol],p3,&kk); + if(kk==0) + p3=(opf_matrix *)malloc(lematrix); + + p3->irow=p6->j*2-1; // aPj/akxij + p3->jcol=n+i; + p3->z=v[p6->j]*v[p6->j]*p6->amp*cos(p6->rad)-v[p6->j]*p6->amp*v[p6->i]*cos(rad[p6->j]-rad[p6->i]-p6->rad); + cor->jcb[p3->jcol]=insert2(cor->jcb[p3->jcol],p3,&kk); + if(kk==0) + p3=(opf_matrix *)malloc(lematrix); + + p3->irow=p6->i*2; // aQi/akxij + p3->jcol=n+i; + p3->z=-v[p6->i]*v[p6->i]*p6->amp*sin(p6->rad)-v[p6->i]*p6->amp*v[p6->j]*sin(rad[p6->i]-rad[p6->j]-p6->rad); + cor->jcb[p3->jcol]=insert2(cor->jcb[p3->jcol],p3,&kk); + if(kk==0) + p3=(opf_matrix *)malloc(lematrix); + + p3->irow=p6->j*2; // aQj/akxij + p3->jcol=n+i; + p3->z=-v[p6->j]*v[p6->j]*p6->amp*sin(p6->rad)-v[p6->j]*p6->amp*v[p6->i]*sin(rad[p6->j]-rad[p6->i]-p6->rad); + cor->jcb[p3->jcol]=insert2(cor->jcb[p3->jcol],p3,&kk); + if(kk==0) + p3=(opf_matrix *)malloc(lematrix); + + i=i+1; + p6=p6->next; + } + + p2=com->head_vpd; //有功负荷模型的一阶偏导 (-PDi) 功率方程 + while(p2!=null) + { p3->irow=p2->i*2-1; // aPDi/aVi + p3->jcol=com->rr-com->rv+p2->i*2; + p3->z=-2*p2->a*v[p2->i]-p2->b; + cor->jcb[p3->jcol]=insert2(cor->jcb[p3->jcol],p3,&kk); + if(kk==0) + p3=(opf_matrix *)malloc(lematrix); + p2=p2->next; + } + + p2=com->head_vqd; //无功负荷模型的一阶偏导 (-QDi) 功率方程 + while(p2!=null) + { + p3->irow=p2->i*2; // aQDi/aVi + p3->jcol=com->rr-com->rv+p2->i*2; + p3->z=-2*p2->a*v[p2->i]-p2->b; + cor->jcb[p3->jcol]=insert2(cor->jcb[p3->jcol],p3,&kk); + if(kk==0) + p3=(opf_matrix *)malloc(lematrix); + p2=p2->next; + } + free(p3); + + n=com->n_sum*2; + i=1; + p8=com->head_lcos; //联络线功率因数的一阶偏导，等式约束 + while(p8!=null) + { +/* + p9=com->head_lij; + j=0; + while((p9!=null)&&(j==0)) + { if((p9->i==p8->i)&&(p9->j==p8->j)) + j=1; + else + p9=p9->next; + }*/ + + + p1=com->a[p8->i]; + j=0; + while((p1!=null)&&(j==0)) + { if((p1->irow==p8->i)&&(p1->jcol==p8->j)) + j=1; + else + p1=p1->next; + } + + + if(p1!=null) + { + p3=(opf_matrix *)malloc(lematrix); + p3->irow=n+i; // aPij/a&i + p3->jcol=com->rr-com->rv+p8->i*2-1; + p3->z=v[p8->i]*v[p8->j]*p1->amp*sin(rad[p8->i]-rad[p8->j]-p1->rad); + x1=p3->z; + cor->jcb[p3->jcol]=insert2(cor->jcb[p3->jcol],p3,&kk); + if(kk==1) + free(p3); + + p3=(opf_matrix *)malloc(lematrix); + p3->irow=n+i; // aPij/a&j + p3->jcol=com->rr-com->rv+p8->j*2-1; + p3->z=-x1; + cor->jcb[p3->jcol]=insert2(cor->jcb[p3->jcol],p3,&kk); + if(kk==1) + free(p3); + + p3=(opf_matrix *)malloc(lematrix); + p3->irow=n+i; // aPij/aVi + p3->jcol=com->rr-com->rv+p8->i*2; + p3->z=2*v[p8->i]*p1->amp*cos(p1->rad)-v[p8->j]*p1->amp*cos(rad[p8->i]-rad[p8->j]-p1->rad); + cor->jcb[p3->jcol]=insert2(cor->jcb[p3->jcol],p3,&kk); + if(kk==1) + free(p3); + + p3=(opf_matrix *)malloc(lematrix); + p3->irow=n+i; // aPij/aVj + p3->jcol=com->rr-com->rv+p8->j*2; + p3->z=-v[p8->i]*p1->amp*cos(rad[p8->i]-rad[p8->j]-p1->rad); + cor->jcb[p3->jcol]=insert2(cor->jcb[p3->jcol],p3,&kk); + if(kk==1) + free(p3); + + p3=(opf_matrix *)malloc(lematrix); + p3->irow=n+i; // aPij/aPij + p3->jcol=com->rp+com->rq+com->rk+2*com->rkb+com->rt+com->rx+i; + p3->z=-1; + cor->jcb[p3->jcol]=insert2(cor->jcb[p3->jcol],p3,&kk); + if(kk==1) + free(p3); + + p3=(opf_matrix *)malloc(lematrix); + p3->irow=n+i+com->rlcos; // aQij/a&i + p3->jcol=com->rr-com->rv+p8->i*2-1; + p3->z=-v[p8->i]*v[p8->j]*p1->amp*cos(rad[p8->i]-rad[p8->j]-p1->rad); + x1=p3->z; + cor->jcb[p3->jcol]=insert2(cor->jcb[p3->jcol],p3,&kk); + if(kk==1) + free(p3); + + p3=(opf_matrix *)malloc(lematrix); + p3->irow=n+i+com->rlcos; // aQij/a&j + p3->jcol=com->rr-com->rv+p8->j*2-1; + p3->z=-x1; + cor->jcb[p3->jcol]=insert2(cor->jcb[p3->jcol],p3,&kk); + if(kk==1) + free(p3); + + p3=(opf_matrix *)malloc(lematrix); + p3->irow=n+i+com->rlcos; // aQij/aVi + p3->jcol=com->rr-com->rv+p8->i*2; + p3->z=-2*v[p8->i]*p1->amp*sin(p1->rad)-v[p8->j]*p1->amp*sin(rad[p8->i]-rad[p8->j]-p1->rad); + cor->jcb[p3->jcol]=insert2(cor->jcb[p3->jcol],p3,&kk); + if(kk==1) + free(p3); + + p3=(opf_matrix *)malloc(lematrix); + p3->irow=n+i+com->rlcos; // aQij/aVj + p3->jcol=com->rr-com->rv+p8->j*2; + p3->z=-v[p8->i]*p1->amp*sin(rad[p8->i]-rad[p8->j]-p1->rad); + cor->jcb[p3->jcol]=insert2(cor->jcb[p3->jcol],p3,&kk); + if(kk==1) + free(p3); + + p3=(opf_matrix *)malloc(lematrix); + p3->irow=n+i+com->rlcos; // aQij/aQij + p3->jcol=com->rp+com->rq+com->rk+2*com->rkb+com->rt+com->rx+i+com->rlcos; + p3->z=-1; + cor->jcb[p3->jcol]=insert2(cor->jcb[p3->jcol],p3,&kk); + if(kk==1) + free(p3); + } + + i=i+1; + p8=p8->next; + } + + n=com->n_sum*2+2*com->rlcos; + i=1; + p8=com->head_vdcos; //负荷模型功率因数的一阶偏导，等式约束 + while(p8!=null) + { x=0; + r=0; + ap=0; + bp=0; + aq=0; + bq=0; + + p2=com->head_vpd; + j=0; + while((p2!=null)&&(j==0)) + { if(p2->i==p8->i) + j=1; + else + p2=p2->next; + } + if(p2!=null) + { x=p2->a*pow(v[p8->i],2)+p2->b*v[p8->i]+p2->c; //PDi + ap=p2->a; + bp=p2->b; + } + + p2=com->head_vqd; + j=0; + while((p2!=null)&&(j==0)) + { if(p2->i==p8->i) + j=1; + else + p2=p2->next; + } + if(p2!=null) + { r=p2->a*pow(v[p8->i],2)+p2->b*v[p8->i]+p2->c; //QDi + aq=p2->a; + bq=p2->b; + } + + p3=(opf_matrix *)malloc(lematrix); + p3->irow=n+i; // acosDi/aVi + p3->jcol=com->rr-com->rv+p8->i*2; + p3->z=(2*x*(2*ap*v[p8->i]+bp)+2*r*(2*aq*v[p8->i]+bq))*pow(p8->g,2)-2*x*(2*ap*v[p8->i]+bp); + cor->jcb[p3->jcol]=insert2(cor->jcb[p3->jcol],p3,&kk); + if(kk==1) + free(p3); + + p3=(opf_matrix *)malloc(lematrix); + p3->irow=n+i; // acosDi/acosDi + p3->jcol=com->rp+com->rq+com->rk+2*com->rkb+com->rt+com->rx+2*com->rlcos+i; + p3->z=2*(x*x+r*r)*p8->g; + cor->jcb[p3->jcol]=insert2(cor->jcb[p3->jcol],p3,&kk); + if(kk==1) + free(p3); + + i=i+1; + p8=p8->next; + } + + i=1; + n=com->n_sum*2+2*com->rlcos+com->rvdcos; + m=com->rp+com->rq+com->rk+2*com->rkb+com->rt+com->rx+2*com->rlcos+com->rvdcos; + p10=com->head_dcbus; //直流部分 + while(p10!=null) + { p3=(opf_matrix *)malloc(lematrix); //潮流方程P + p3->irow=2*p10->iac-1; //aP/aVd + p3->jcol=m+i; + if(p10->flag==1) + p3->z=com->varx[m+i+com->n_dc]; //Id + else + p3->z=-com->varx[m+i+com->n_dc]; + cor->jcb[p3->jcol]=insert2(cor->jcb[p3->jcol],p3,&kk); + if(kk==1) + free(p3); + + p3=(opf_matrix *)malloc(lematrix); //潮流方程P + p3->irow=2*p10->iac-1; //aP/aId + p3->jcol=m+i+com->n_dc; + if(p10->flag==1) + p3->z=com->varx[m+i]; //Vd + else + p3->z=-com->varx[m+i]; + cor->jcb[p3->jcol]=insert2(cor->jcb[p3->jcol],p3,&kk); + if(kk==1) + free(p3); + + p3=(opf_matrix *)malloc(lematrix); //潮流方程Q + p3->irow=2*p10->iac; //aQ/aVd + p3->jcol=m+i; + if(p10->flag==1) //Id*tan(far) + p3->z=com->varx[m+i+com->n_dc]*tan(com->varx[m+i+4*com->n_dc]); + else + p3->z=-com->varx[m+i+com->n_dc]*tan(com->varx[m+i+4*com->n_dc]); + cor->jcb[p3->jcol]=insert2(cor->jcb[p3->jcol],p3,&kk); + if(kk==1) + free(p3); + + p3=(opf_matrix *)malloc(lematrix); //潮流方程Q + p3->irow=2*p10->iac; //aQ/aId + p3->jcol=m+i+com->n_dc; + if(p10->flag==1) //Vd*tan(far) + p3->z=com->varx[m+i]*tan(com->varx[m+i+4*com->n_dc]); + else + p3->z=-com->varx[m+i]*tan(com->varx[m+i+4*com->n_dc]); + cor->jcb[p3->jcol]=insert2(cor->jcb[p3->jcol],p3,&kk); + if(kk==1) + free(p3); + + p3=(opf_matrix *)malloc(lematrix); //潮流方程Q + p3->irow=2*p10->iac; //aQ/afar + p3->jcol=m+i+4*com->n_dc; + if(p10->flag==1) //Vd*Id/cos(far)cos(far) + p3->z=com->varx[m+i]*com->varx[m+i+com->n_dc]/pow(cos(com->varx[m+i+4*com->n_dc]),2); + else + p3->z=-com->varx[m+i]*com->varx[m+i+com->n_dc]/pow(cos(com->varx[m+i+4*com->n_dc]),2); + cor->jcb[p3->jcol]=insert2(cor->jcb[p3->jcol],p3,&kk); + if(kk==1) + free(p3); + + p3=(opf_matrix *)malloc(lematrix); //直流方程d1 + p3->irow=n+i; // ad1/aVd + p3->jcol=m+i; + p3->z=1; //=1 + cor->jcb[p3->jcol]=insert2(cor->jcb[p3->jcol],p3,&kk); + if(kk==1) + free(p3); + + p3=(opf_matrix *)malloc(lematrix); //直流方程d1 + p3->irow=n+i; // ad1/akd + p3->jcol=m+i+2*com->n_dc; + p3->z=-v[p10->iac]*com->varx[m+i+3*com->n_dc]; //-Vicos& + cor->jcb[p3->jcol]=insert2(cor->jcb[p3->jcol],p3,&kk); + if(kk==1) + free(p3); + + p3=(opf_matrix *)malloc(lematrix); //直流方程d1 + p3->irow=n+i; // ad1/aV + p3->jcol=com->rr-com->rv+p10->iac*2; + p3->z=-com->varx[m+i+2*com->n_dc]*com->varx[m+i+3*com->n_dc]; //-kdcos& + cor->jcb[p3->jcol]=insert2(cor->jcb[p3->jcol],p3,&kk); + if(kk==1) + free(p3); + + p3=(opf_matrix *)malloc(lematrix); //直流方程d1 + p3->irow=n+i; // ad1/acos + p3->jcol=m+i+3*com->n_dc; + p3->z=-com->varx[m+i+2*com->n_dc]*v[p10->iac]; //-kdVi + cor->jcb[p3->jcol]=insert2(cor->jcb[p3->jcol],p3,&kk); + if(kk==1) + free(p3); + + p3=(opf_matrix *)malloc(lematrix); //直流方程d1 + p3->irow=n+i; // ad1/aId + p3->jcol=m+i+com->n_dc; + p3->z=p10->r; //Xci + cor->jcb[p3->jcol]=insert2(cor->jcb[p3->jcol],p3,&kk); + if(kk==1) + free(p3); + + p3=(opf_matrix *)malloc(lematrix); //直流方程d2 + p3->irow=n+i+com->n_dc; // ad2/aVd + p3->jcol=m+i; + p3->z=1; //=1 + cor->jcb[p3->jcol]=insert2(cor->jcb[p3->jcol],p3,&kk); + if(kk==1) + free(p3); + + p3=(opf_matrix *)malloc(lematrix); //直流方程d2 + p3->irow=n+i+com->n_dc; // ad2/akd + p3->jcol=m+i+2*com->n_dc; + p3->z=-p10->kr*v[p10->iac]*cos(com->varx[m+i+4*com->n_dc]); //-krVicos(far) + cor->jcb[p3->jcol]=insert2(cor->jcb[p3->jcol],p3,&kk); + if(kk==1) + free(p3); + + p3=(opf_matrix *)malloc(lematrix); //直流方程d2 + p3->irow=n+i+com->n_dc; // ad2/aV + p3->jcol=com->rr-com->rv+p10->iac*2; + p3->z=-p10->kr*com->varx[m+i+2*com->n_dc]*cos(com->varx[m+i+4*com->n_dc]); //-krVicos(far) + cor->jcb[p3->jcol]=insert2(cor->jcb[p3->jcol],p3,&kk); + if(kk==1) + free(p3); + + p3=(opf_matrix *)malloc(lematrix); //直流方程d2 + p3->irow=n+i+com->n_dc; // ad2/afar + p3->jcol=m+i+4*com->n_dc; + p3->z=p10->kr*com->varx[m+i+2*com->n_dc]*v[p10->iac]*sin(com->varx[m+i+4*com->n_dc]); //krkdVisin(far) + cor->jcb[p3->jcol]=insert2(cor->jcb[p3->jcol],p3,&kk); + if(kk==1) + free(p3); + + p3=(opf_matrix *)malloc(lematrix); //直流方程d3 + p3->irow=n+i+2*com->n_dc; // ad3/aId + p3->jcol=m+i+com->n_dc; + if(p10->flag==0) + p3->z=1; //+-1 + else + p3->z=-1; + cor->jcb[p3->jcol]=insert2(cor->jcb[p3->jcol],p3,&kk); + if(kk==1) + free(p3); + + p9=com->head_dclij; + while(p9!=null) + { if((p9->i==p10->i)||(p9->j==p10->i)) + { if(p9->i==p10->i) + { p11=com->head_dcbus; + t=1; + j=0; + while((p11!=null)&&(j==0)) + { if(p11->i==p9->j) + j=1; + else + p11=p11->next; + t=t+1; + } + t=t-1; + } + else + { p11=com->head_dcbus; + t=1; + j=0; + while((p11!=null)&&(j==0)) + { if(p11->i==p9->i) + j=1; + else + p11=p11->next; + t=t+1; + } + t=t-1; + } + + p3=(opf_matrix *)malloc(lematrix); //直流方程d3 + p3->irow=n+i+2*com->n_dc; // ad3/aVdj + p3->jcol=m+t; + p3->z=p9->amp; //-gij + cor->jcb[p3->jcol]=insert2(cor->jcb[p3->jcol],p3,&kk); + if(kk==1) + free(p3); + + p3=(opf_matrix *)malloc(lematrix); //直流方程d3 + p3->irow=n+i+2*com->n_dc; // ad3/aVdi + p3->jcol=m+i; + p3->z=-p9->amp; //-gij + cor->jcb[p3->jcol]=insert2(cor->jcb[p3->jcol],p3,&kk); + if(kk==1) + free(p3); + + } + p9=p9->next; + } + + i=i+1; + p10=p10->next; + } + + m=com->rp+com->rq; + n=com->n_sum*2+2*com->rlcos+com->rvdcos+3*com->n_dc; + i=1; + p12=com->head_eqkij; + while(p12!=null) + { p3=(opf_matrix *)malloc(lematrix); //等变比可调 k1-k2=0 + p3->irow=n+i; //等式 + p3->jcol=m+p12->i; //变量 + p3->z=1; + cor->jcb[p3->jcol]=insert2(cor->jcb[p3->jcol],p3,&kk); + if(kk==1) + free(p3); + + p3=(opf_matrix *)malloc(lematrix); //等变比可调 k1-k2=0 + p3->irow=n+i; //等式 + p3->jcol=m+p12->j; //变量 + p3->z=-1; + cor->jcb[p3->jcol]=insert2(cor->jcb[p3->jcol],p3,&kk); + if(kk==1) + free(p3); + + i=i+1; + p12=p12->next; + } + +/* + FILE *fp1; + fp1=fopen("Text3.txt","wb"); + for(i=1;i<=com->rr-com->rv+2*com->n_sum;i++) + { p3=cor->jcb[i]; + while(p3!=null) + { fprintf(fp1," %d, %d, %f\n" ,p3->irow,p3->jcol,p3->z); + p3=p3->next; + } + } + fclose(fp1);*/ + + + + + free(v); + free(rad); + +} + +/******形成g的一阶偏导矩阵（可变部分）******/ +void DgData(opf_common *com,opf_correct *cor) +{ + int i,j,t,m,n,n1; + + opf_gij *p1; + opf_matrix *p3; + opf_vpdqd *p2; + opf_gpcd *p5; + opf_sij *p6; + opf_dcbus *p7; + opf_yij *p8; + opf_kij *p9; + + double *v,*rad; + double *chazhi; + double x,r,x1; + + j=com->rr-com->rv+2*com->n_sum+1; + chazhi=(double *)malloc(j*sizeof(double)); + v=(double *)malloc((com->n_sum+1)*sizeof(double)); //减少打字，看上去简洁些 + rad=(double *)malloc((com->n_sum+1)*sizeof(double)); + for(i=1;i<=com->n_sum;i++) + { v[i]=com->v[i]; + rad[i]=com->rad[i]; + } + + + i=1; + j=com->rr-com->rv; + p1=com->head_lpij; + while(p1!=null) //支路有功的部分 + { t=p1->i; + m=p1->j; + +// p4=com->head_lij; + p8=com->a[p1->i]; + n=0; + if(p8!=null) + { while((p8!=null)&&(n==0)) + { if((p8->irow==p1->i)&&(p8->jcol==p1->j)) + n=1; + else + p8=p8->next; + } + if(p8!=null) + { chazhi[j+2*t-1]=v[t]*v[m]*p8->amp*sin(rad[t]-rad[m]-p8->rad); //ai + chazhi[j+2*m-1]=-chazhi[j+2*t-1]; //aj + chazhi[j+2*t]=2*v[t]*p8->amp*cos(p8->rad)-v[m]*p8->amp*cos(rad[t]-rad[m]-p8->rad); //Vi + chazhi[j+2*m]=-v[t]*p8->amp*cos(rad[t]-rad[m]-p8->rad); //Vj + } + } + + p3=cor->dg[com->rr+i]; + while(p3!=null) + { p3->z=chazhi[p3->irow]; + p3=p3->next; + } + p1=p1->next; + i=i+1; + } + + i=1; + p1=com->head_lqij; + while(p1!=null) //支路无功的部分，（2011.1）修改成变压器支路无功约束 + { t=p1->i; + m=p1->j; + +// p4=com->head_lij; + p8=com->a[p1->i]; + n=0; + if(p8!=null) + { while((p8!=null)&&(n==0)) + { if((p8->irow==p1->i)&&(p8->jcol==p1->j)) + n=1; + else + p8=p8->next; + } + if(p8!=null) + { +/*支路无功的 + chazhi[j+2*t-1]=-v[t]*v[m]*p8->amp*cos(rad[t]-rad[m]-p8->rad); //ai + chazhi[j+2*m-1]=-chazhi[j+2*t-1]; //aj + chazhi[j+2*t]=-2*v[t]*p8->amp*sin(p8->rad)-v[m]*p8->amp*sin(rad[t]-rad[m]-p8->rad); //Vi + chazhi[j+2*m]=-v[t]*p8->amp*sin(rad[t]-rad[m]-p8->rad); //Vj*/ + + + n1=0; + p9=com->head_kij; + while((p9!=null)&&(n1==0)) + { if((p9->i==p1->i)&&(p9->j==p1->j)) + n1=1; + else + p9=p9->next; + } + + if(p9!=null) + { x=rad[t]-rad[m]-(p8->rad-3.1415926); //&ij=&i-&j-(aij-3.1415926) + chazhi[j+2*t-1]=-v[t]*v[m]*p8->amp*cos(x); //ai + chazhi[j+2*m-1]=-chazhi[j+2*t-1]; //aj + chazhi[j+2*t]=-2*p9->k*v[t]*p8->amp*sin(p8->rad-3.1415926)-v[m]*p8->amp*sin(x); //Vi + chazhi[j+2*m]=-v[t]*p8->amp*sin(rad[t]-rad[m]-p8->rad); //Vj + } + else + { chazhi[j+2*t-1]=0; //ai + chazhi[j+2*m-1]=0; //aj + chazhi[j+2*t]=0; //Vi + chazhi[j+2*m]=0; //Vj + } + } + } + + p3=cor->dg[com->rr+com->rlpij+i]; + while(p3!=null) + { p3->z=chazhi[p3->irow]; + p3=p3->next; + } + p1=p1->next; + i=i+1; + } + + i=1; + p1=com->head_lsij; + while(p1!=null) //支路容量的部分 + { t=p1->i; + m=p1->j; + +// p4=com->head_lij; + p8=com->a[p1->i]; + n=0; + if(p8!=null) + { while((p8!=null)&&(n==0)) + { if((p8->irow==p1->i)&&(p8->jcol==p1->j)) + n=1; + else + p8=p8->next; + } + if(p8!=null) + { chazhi[j+2*t-1]=2*pow(v[t],3)*pow(p8->amp,2)*v[m]*sin(rad[t]-rad[m]); //ai + chazhi[j+2*m-1]=-chazhi[j+2*t-1]; //aj + chazhi[j+2*t]=4*pow(v[t],3)*pow(p8->amp,2)+2*v[t]*pow(p8->amp,2)*pow(v[m],2)-6*pow(v[t],2)*pow(p8->amp,2)*v[m]*cos(rad[t]-rad[m]); //Vi + chazhi[j+2*m]=2*pow(v[t],2)*pow(p8->amp,2)*v[m]-2*pow(v[t],3)*pow(p8->amp,2)*cos(rad[t]-rad[m]); //Vj + } + } + + p3=cor->dg[com->rr+com->rlpij+com->rlqij+i]; + while(p3!=null) + { p3->z=chazhi[p3->irow]; + p3=p3->next; + } + p1=p1->next; + i=i+1; + } + + i=1; + p1=com->head_liij; + while(p1!=null) //支路电流的部分 + { t=p1->i; + m=p1->j; + +// p4=com->head_lij; + p8=com->a[p1->i]; + n=0; + if(p8!=null) + { while((p8!=null)&&(n==0)) + { if((p8->irow==p1->i)&&(p8->jcol==p1->j)) + n=1; + else + p8=p8->next; + } + if(p8!=null) + { chazhi[j+2*t-1]=2*v[t]*pow(p8->amp,2)*v[m]*sin(rad[t]-rad[m]); //ai + chazhi[j+2*m-1]=-chazhi[j+2*t-1]; //aj + chazhi[j+2*t]=2*v[t]*pow(p8->amp,2)-2*pow(p8->amp,2)*v[m]*cos(rad[t]-rad[m]); //Vi + chazhi[j+2*m]=2*pow(p8->amp,2)*v[m]-2*v[t]*pow(p8->amp,2)*cos(rad[t]-rad[m]); //Vj + } + } + + p3=cor->dg[com->rr+com->rlpij+com->rlqij+com->rlsij+i]; + while(p3!=null) + { p3->z=chazhi[p3->irow]; + p3=p3->next; + } + p1=p1->next; + i=i+1; + } + + i=1; + p2=com->head_vpd; + while(p2!=null) //有功负荷模型部分(PDi) + { t=p2->i; + chazhi[j+2*t]=2*p2->a*v[t]+p2->b; //PDi/Vi + + p3=cor->dg[com->rr+com->rlpij+com->rlqij+com->rlsij+com->rliij+i]; + while(p3!=null) + { p3->z=chazhi[p3->irow]; + p3=p3->next; + } + p2=p2->next; + i=i+1; + } + + i=1; + p2=com->head_vqd; + while(p2!=null) //无功负荷模型部分(QDi) + { t=p2->i; + chazhi[j+2*t]=2*p2->a*v[t]+p2->b; //QDi/Vi + + p3=cor->dg[com->rr+com->rlpij+com->rlqij+com->rlsij+com->rliij+com->rvpd+i]; + while(p3!=null) + { p3->z=chazhi[p3->irow]; + p3=p3->next; + } + p2=p2->next; + i=i+1; + } + + p1=com->head_spij; //断面有功计算g的一阶偏导 + i=1; + while(p1!=null) //断面有功的部分 + { n=com->rr-com->rv+2*com->n_sum; + for(t=1;t<=n;t++) + chazhi[t]=0; + p6=com->head_sij; + while(p6!=null) //找到匹配的支路有功功率部分 + { if(p6->num==p1->i) + { t=p6->i; + m=p6->j; + +// p4=com->head_lij; + p8=com->a[p6->i]; + n=0; + if(p8!=null) + { while((p8!=null)&&(n==0)) + { if((p8->irow==p6->i)&&(p8->jcol==p6->j)) + n=1; + else + p8=p8->next; + } + if(p8!=null) + { chazhi[j+2*t-1]+=v[t]*v[m]*p8->amp*sin(rad[t]-rad[m]-p8->rad); //ai + chazhi[j+2*m-1]+=-(v[t]*v[m]*p8->amp*sin(rad[t]-rad[m]-p8->rad)); //aj + chazhi[j+2*t]+=2*v[t]*p8->amp*cos(p8->rad)-v[m]*p8->amp*cos(rad[t]-rad[m]-p8->rad); //Vi + chazhi[j+2*m]+=-v[t]*p8->amp*cos(rad[t]-rad[m]-p8->rad); //Vj + } + } + } + p6=p6->next; + } + p3=cor->dg[com->rr+com->rlpij+com->rlqij+com->rlsij+com->rliij+com->rvpd+com->rvqd+i]; + while(p3!=null) + { p3->z=chazhi[p3->irow]; + p3=p3->next; + } + i=i+1; + p1=p1->next; + } + + p1=com->head_sqij; //断面无功计算g的一阶偏导 + i=1; + while(p1!=null) //断面无功的部分 + { n=com->rr-com->rv+2*com->n_sum; + for(t=1;t<=n;t++) + chazhi[t]=0; + p6=com->head_sij; + while(p6!=null) //找到匹配的支路无功功率部分 + { if(p6->num==p1->i) + { t=p6->i; + m=p6->j; + +// p4=com->head_lij; + p8=com->a[p6->i]; + n=0; + if(p8!=null) + { while((p8!=null)&&(n==0)) + { if((p8->irow==p6->i)&&(p8->jcol==p6->j)) + n=1; + else + p8=p8->next; + } + if(p8!=null) + { chazhi[j+2*t-1]+=-v[t]*v[m]*p8->amp*cos(rad[t]-rad[m]-p8->rad); //ai + chazhi[j+2*m-1]+=-(-v[t]*v[m]*p8->amp*cos(rad[t]-rad[m]-p8->rad)); //aj + chazhi[j+2*t]+=-2*v[t]*p8->amp*sin(p8->rad)-v[m]*p8->amp*sin(rad[t]-rad[m]-p8->rad); //Vi + chazhi[j+2*m]+=-v[t]*p8->amp*sin(rad[t]-rad[m]-p8->rad); //Vj + } + } + } + p6=p6->next; + } + p3=cor->dg[com->rr+com->rlpij+com->rlqij+com->rlsij+com->rliij+com->rvpd+com->rvqd+com->rspij+i]; + while(p3!=null) + { p3->z=chazhi[p3->irow]; + p3=p3->next; + } + i=i+1; + p1=p1->next; + } + + p5=com->head_gpcd; + i=1; + while(p5!=null) //计算g的一阶偏导的发电机功率园图模型部分 + { t=0; + for(j=1;j<=com->rpg;j++) + { if(com->gp[j]==p5->i) + t=j; + } + m=0; + for(j=1;j<=com->rqg;j++) + { if(com->gq[j]==p5->i) + m=j; + } + + if(t!=0) + { if(m!=0) + { if(com->varx[com->rp+m]>=0) + { chazhi[t]=2*com->varx[t]; + chazhi[com->rp+m]=2*(com->varx[com->rp+m]-p5->qo); + } + else + { chazhi[t]=1; + chazhi[com->rp+m]=tan(p5->rad); + } + } + else + { if(com->qg[p5->i]>=0) + { chazhi[t]=2*com->varx[t]; + chazhi[com->rp+m]=0; + } + } + } + else + { if(m!=0) + { if(com->varx[com->rp+m]>=0) + { chazhi[t]=0; + chazhi[com->rp+m]=2*(com->varx[com->rp+m]-p5->qo); + } + else + { chazhi[t]=0; + chazhi[com->rp+m]=tan(p5->rad); + } + } + else + { if(com->qg[p5->i]>=0) + { chazhi[t]=0; + chazhi[com->rp+m]=0; + } + } + } + p3=cor->dg[com->rr+com->rlpij+com->rlqij+com->rlsij+com->rliij+com->rvpd+com->rvqd+com->rspij+com->rsqij+i]; + while(p3!=null) + { p3->z=chazhi[p3->irow]; + p3=p3->next; + } + i=i+1; + p5=p5->next; + } + + p7=com->head_dcbus; + i=1; + t=com->rp+com->rq+com->rk+2*com->rkb+com->rt+com->rx+2*com->rlcos+com->rvdcos; + while(p7!=null) //直流功率 + { + chazhi[t+i]=com->varx[t+i+com->n_dc]; //Pdi/Vdi + chazhi[t+i+com->n_dc]=com->varx[t+i]; //Pdi/Idi + + p3=cor->dg[com->rr+com->rlpij+com->rlqij+com->rlsij+com->rliij+com->rvpd+com->rvqd+com->rspij+com->rsqij+com->rgpcd+i]; + while(p3!=null) + { p3->z=chazhi[p3->irow]; + p3=p3->next; + } + i=i+1; + p7=p7->next; + } + + p1=com->head_lcos; //联络线功率因数的一阶偏导，联络线功率因数的等式约束，转换成PijQij表示的不等式约束 + m=com->rr+com->rlpij+com->rlqij+com->rlsij+com->rliij+com->rvpd+com->rvqd+com->rspij+com->rsqij+com->rgpcd+com->n_dc; + j=com->rp+com->rq+com->rk+2*com->rkb+com->rt+com->rx; + i=1; + while(p1!=null) + { r=com->varx[j+i]; + x=com->varx[j+i+com->rlcos]; + x1=r*r+x*x; + + if(x1!=0) + { chazhi[j+i]=2*r*pow(x1,-1)-2*pow(r,3)*pow(x1,-2); //Pij + chazhi[j+i+com->rlcos]=-2*r*r*x*pow(x1,-2); //Qij + } + else + { chazhi[j+i]=0; //Pij + chazhi[j+i+com->rlcos]=0; //Qij + } + + p3=cor->dg[m+i]; + while(p3!=null) + { p3->z=chazhi[p3->irow]; + p3=p3->next; + } + p1=p1->next; + i=i+1; + } + + free(v); + free(rad); + free(chazhi); + +/* + FILE *fp1; + fp1=fopen("Text3.txt","wb"); + for(i=1;i<=com->rr+com->rrr;i++) + { p3=cor->dg[i]; + while(p3!=null) + { fprintf(fp1," %d, %d, %f\n" ,p3->irow,p3->jcol,p3->z); + p3=p3->next; + } + } + fclose(fp1);*/ + +} + +/******形成海森矩阵（下三角）******/ +void HeisenData(opf_common *com,opf_correct *cor,opf_decomp *dec) +{ + int i,j,t; + double x; + + opf_matrix *p3; + opf_kij *p6; + opf_vpdqd *p8; + + +// opf_matrix **h; + int mm,rr,rv,rlpij,rlqij,rlsij,rliij,rvpd,rvqd,rpg,rqg,rpd,rqd,rspij,rsqij,rgpcd,rk,rkb,rt,rx,rp,rq,rrr,rlcos,req,rvdcos,n_dc; + double *v,*rad; + double *chazhi; + + mm=com->n_sum; + rr=com->rr; + rv=com->rv; + rlpij=com->rlpij; + rlqij=com->rlqij; + rlsij=com->rlsij; + rliij=com->rliij; + rvpd=com->rvpd; + rvqd=com->rvqd; + rliij=com->rliij; + rpg=com->rpg; + rqg=com->rqg; + rpd=com->rpd; + rqd=com->rqd; + rspij=com->rspij; + rsqij=com->rsqij; + rgpcd=com->rgpcd; + rk=com->rk; + rkb=com->rkb; + rt=com->rt; + rx=com->rx; + rp=com->rp; + rq=com->rq; + rrr=com->rrr; + rlcos=com->rlcos; + req=com->req; + rvdcos=com->rvdcos; + n_dc=com->n_dc; + + j=rr-rv+4*mm+req; +/* + h=(opf_matrix **)malloc((j+1)*sizeof(opf_matrix *)); + for(i=1;i<=j;i++) + h[i]=null;*/ + + v=(double *)malloc((mm+1)*sizeof(double)); //减少打字，看上去简洁些 + rad=(double *)malloc((mm+1)*sizeof(double)); + chazhi=(double *)malloc((j+1)*sizeof(double)); + for(i=1;i<=com->n_sum;i++) + { v[i]=com->v[i]; + rad[i]=com->rad[i]; + } + + for(i=1;i<=rr-rv+4*mm+req;i++) + { p3=cor->heisen[i]; + while(p3!=null) + { p3->z=0; + p3=p3->next; + } + } + + Heisen_H2Y(com,cor,dec); //形成修正方程的H2Y + Heisen_F2(com,cor,dec); //形成修正方程的-F2 + Heisen_G2(com,cor,dec); //形成修正方程的G2(Z+W) + Heisen_detG(com,cor,dec); //形成修正方程的detG*(UW-ZL)*detG + Heisen_J(com,cor,dec); //形成修正方程的雅可比矩阵部分 + + for(i=1;i<=rr-rv+4*mm+req;i++) + { cor->d[i]=0; + chazhi[i]=0; + } + for(i=1;i<=rr-rv+4*mm+req;i++) + { p3=cor->heisen[i]; + while(p3!=null) + { chazhi[p3->irow]=p3->z; + p3=p3->next; + } + for(j=dec->ljs[i];j<=dec->ljs[i+1]-1;j++) + { + dec->la[j]=chazhi[dec->lj[j]]; + } + cor->d[i]=chazhi[i]; + p3=cor->heisen[i]; + while(p3!=null) + { chazhi[p3->irow]=0; + p3=p3->next; + } + } + + t=rr-rv; + if(com->mini_pf_flag==1) //最小化潮流部分 + { for(i=1;i<=com->rpge;i++) + cor->d[rpg+i]=cor->d[rpg+i]-2*com->mini_pf_w; + for(i=1;i<=com->rqge;i++) + cor->d[rp+rqg+i]=cor->d[rp+rqg+i]-2*com->mini_pf_w; + } + switch(com->obj_type) //f的二阶偏导(-det2f) 对角线部分 + { + case 1: //煤耗 + { for(i=1;i<=rpg;i++) + cor->d[i]=cor->d[i]-2*com->fa2[i]-com->fa3[i]*com->fa4[i]*com->fa4[i]*exp(com->fa4[i]*com->varx[i]); + break; + } + case 8: //电压越限最小 + { t=rr-rv; + for(i=1;i<=mm;i++) //求f的二阶偏导 + cor->d[t+4*i-2]=cor->d[t+4*i-2]-2*com->wv[i]; + break; + } + case 9: //有功负荷模型 + { p8=com->head_vpd; + while(p8!=null) //求f的二阶偏导，和电压有关 + { cor->d[t+4*p8->i-2]=cor->d[t+4*p8->i-2]+2*p8->a; + p8=p8->next; + } + break; + } + case 10: //无功负荷模型 + { p8=com->head_vqd; + while(p8!=null) //求f的二阶偏导，和电压有关 + { cor->d[t+4*p8->i-2]=cor->d[t+4*p8->i-2]+2*p8->a; + p8=p8->next; + } + break; + } + case 11: //电容/电抗调节最小 + { i=1; + p6=com->head_ti; + while(p6!=null) //-2w + { cor->d[rp+rq+rk+2*rkb+i]=cor->d[rp+rq+rk+2*rkb+i]-2*p6->w; + p6=p6->next; + i=i+1; + } + break; + } + case 12: //负荷功率调节最小 + { for(i=1;i<=rpd;i++) //-2wPD + cor->d[rpg+com->rpge+i]=cor->d[rpg+com->rpge+i]-2*com->wpd[i]; + p8=com->head_vpd; + while(p8!=null) //求f的二阶偏导，和电压有关 + { x=p8->a*v[p8->i]*v[p8->i]+p8->b*v[p8->i]+p8->c; + cor->d[t+4*p8->i-2]=cor->d[t+4*p8->i-2]-4*p8->a*p8->w*(x-com->pd[p8->i])+2*p8->w*pow((2*p8->a*v[p8->i]+p8->b),2); + p8=p8->next; + } + break; + } + case 15: //机组有功调节最小 + { for(i=1;i<=rpg;i++) //-2wPG + cor->d[i]=cor->d[i]-2*com->wpg[i]; + break; + } + case 16: //机组无功调节最小 + { for(i=1;i<=rqg;i++) //-2wQG + cor->d[rp+i]=cor->d[rp+i]-2*com->wqg[i]; + break; + } + default: + break; + } + +/* + if(com->itera_num<=1) //可能因为平启动而使整行整列为0 + for(i=1;i<=2*rlcos+rvdcos;i++) + cor->d[rr-rv+4*mm+i]+=100;*/ + + +// FILE *fp1; +// fp1=fopen("Text3.txt","wb"); + + + +/* for(i=1;i<=rr-rv+4*mm+req;i++) + { p3=cor->heisen[i]; + while(p3!=null) + { if(p3->irow>p3->jcol) + if(fabs(p3->z)>=0.000001) + fprintf(fp1," (%d,%d) %lf\n" ,p3->irow,p3->jcol,p3->z); + p3=p3->next; + } + } + + fprintf(fp1,"\n" ); + for(i=1;i<=rr-rv+4*mm+req;i++) + { if(fabs(cor->d[i])>=0.000001) + fprintf(fp1," (%d,%d) %lf\n" ,i,i,cor->d[i]); + }*/ + + + +/* + for(i=1;i<=rr-rv+4*mm+req;i++) + fprintf(fp1," %d, %d, %d\n" ,i,dec->lis[i],dec->ljs[i]); + fprintf(fp1,"\n" );*/ + +/* + for(i=1;i<=rr-rv+4*mm+req;i++) + { for(j=dec->ljs[i];j<=dec->ljs[i+1]-1;j++) + if(fabs(dec->la[j])>0.000001) + fprintf(fp1," (%d,%d) %lf\n" ,dec->lj[j],i,dec->la[j]); + } + + fprintf(fp1,"\n" ); + for(i=1;i<=rr-rv+4*mm+req;i++) + { if(fabs(cor->d[i])>=0.000001) + fprintf(fp1," (%d,%d) %lf\n" ,i,i,cor->d[i]); + }*/ + + + +/* + for(i=1;i<=rr-rv+4*mm+req;i++) + { for(j=dec->lis[i];j<=dec->lis[i+1]-1;j++) + fprintf(fp1," %d, %d\n" ,i,dec->li[j]); + }*/ + +// fclose(fp1); + + for(i=1;i<=rr-rv+4*mm+req;i++) + { p3=cor->heisen[i]; + while(p3!=null) + { p3->z=0;; + p3=p3->next; + } + } + + free(v); + free(rad); + free(chazhi); +// free(h); +} + +/*******形成修正方程的H2Y******/ +void Heisen_H2Y(opf_common *com,opf_correct *cor,opf_decomp *dec) +{ + int i,j,t,n,m; + double x,r; + double ap,bp,aq,bq; + + opf_yij *p1; + opf_gij *p2; + opf_matrix *p5; + opf_kij *p6; + opf_vpdqd *p8; + opf_dcbus *p12; + +// opf_matrix **h; + int mm,rr,rv,rlpij,rlqij,rlsij,rliij,rvpd,rvqd,rpg,rqg,rpd,rqd,rspij,rsqij,rgpcd,rk,rkb,rt,rx,rp,rq,rrr,rlcos,req,rvdcos,n_dc; + double *v,*rad; + int kk; + + mm=com->n_sum; + rr=com->rr; + rv=com->rv; + rlpij=com->rlpij; + rlqij=com->rlqij; + rlsij=com->rlsij; + rliij=com->rliij; + rvpd=com->rvpd; + rvqd=com->rvqd; + rliij=com->rliij; + rpg=com->rpg; + rqg=com->rqg; + rpd=com->rpd; + rqd=com->rqd; + rspij=com->rspij; + rsqij=com->rsqij; + rgpcd=com->rgpcd; + rk=com->rk; + rkb=com->rkb; + rt=com->rt; + rx=com->rx; + rp=com->rp; + rq=com->rq; + rrr=com->rrr; + rlcos=com->rlcos; + req=com->req; + rvdcos=com->rvdcos; + n_dc=com->n_dc; + + j=rr-rv+4*mm+req; +/* + h=(opf_matrix **)malloc((j+1)*sizeof(opf_matrix *)); + for(i=1;i<=j;i++) + h[i]=null;*/ + + v=(double *)malloc((mm+1)*sizeof(double)); //减少打字，看上去简洁些 + rad=(double *)malloc((mm+1)*sizeof(double)); + for(i=1;i<=com->n_sum;i++) + { v[i]=com->v[i]; + rad[i]=com->rad[i]; + } + + p5=(opf_matrix *)malloc(lematrix); //潮流方程等式约束的2阶海森阵（非对角线） + t=rr-rv; + p1=com->a[1]; + while(p1!=null) //i!=j + { +// hasin[t+4*p1->jcol-3][t+4*p1->jcol-3]+=com->vary[2*p1->irow-1]*v[p1->irow]*p1->amp*v[p1->jcol]*cos(rad[p1->irow]-rad[p1->jcol]-p1->rad)+com->vary[2*p1->irow]*v[p1->irow]*p1->amp*v[p1->jcol]*sin(rad[p1->irow]-rad[p1->jcol]-p1->rad); + p5->irow=t+4*p1->jcol-3; + p5->jcol=t+4*p1->jcol-3; + p5->z=com->vary[2*p1->irow-1]*v[p1->irow]*p1->amp*v[p1->jcol]*cos(rad[p1->irow]-rad[p1->jcol]-p1->rad)+com->vary[2*p1->irow]*v[p1->irow]*p1->amp*v[p1->jcol]*sin(rad[p1->irow]-rad[p1->jcol]-p1->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + +// hasin[t+4*p1->jcol-3][t+4*p1->irow-3]+=-com->vary[2*p1->irow-1]*v[p1->irow]*p1->amp*v[p1->jcol]*cos(rad[p1->irow]-rad[p1->jcol]-p1->rad)-com->vary[2*p1->irow]*v[p1->irow]*p1->amp*v[p1->jcol]*sin(rad[p1->irow]-rad[p1->jcol]-p1->rad); + p5->irow=t+4*p1->jcol-3; + p5->jcol=t+4*p1->irow-3; + p5->z=-com->vary[2*p1->irow-1]*v[p1->irow]*p1->amp*v[p1->jcol]*cos(rad[p1->irow]-rad[p1->jcol]-p1->rad)-com->vary[2*p1->irow]*v[p1->irow]*p1->amp*v[p1->jcol]*sin(rad[p1->irow]-rad[p1->jcol]-p1->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + +// hasin[t+4*p1->irow-3][t+4*p1->jcol-3]+=-com->vary[2*p1->irow-1]*v[p1->irow]*p1->amp*v[p1->jcol]*cos(rad[p1->irow]-rad[p1->jcol]-p1->rad)-com->vary[2*p1->irow]*v[p1->irow]*p1->amp*v[p1->jcol]*sin(rad[p1->irow]-rad[p1->jcol]-p1->rad); + p5->irow=t+4*p1->irow-3; + p5->jcol=t+4*p1->jcol-3; + p5->z=-com->vary[2*p1->irow-1]*v[p1->irow]*p1->amp*v[p1->jcol]*cos(rad[p1->irow]-rad[p1->jcol]-p1->rad)-com->vary[2*p1->irow]*v[p1->irow]*p1->amp*v[p1->jcol]*sin(rad[p1->irow]-rad[p1->jcol]-p1->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + +// hasin[t+4*p1->jcol-3][t+4*p1->jcol-2]+=-com->vary[2*p1->irow-1]*v[p1->irow]*p1->amp*sin(rad[p1->irow]-rad[p1->jcol]-p1->rad)+com->vary[2*p1->irow]*v[p1->irow]*p1->amp*cos(rad[p1->irow]-rad[p1->jcol]-p1->rad); + p5->irow=t+4*p1->jcol-3; + p5->jcol=t+4*p1->jcol-2; + p5->z=-com->vary[2*p1->irow-1]*v[p1->irow]*p1->amp*sin(rad[p1->irow]-rad[p1->jcol]-p1->rad)+com->vary[2*p1->irow]*v[p1->irow]*p1->amp*cos(rad[p1->irow]-rad[p1->jcol]-p1->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + +// hasin[t+4*p1->jcol-3][t+4*p1->irow-2]+=-com->vary[2*p1->irow-1]*p1->amp*v[p1->jcol]*sin(rad[p1->irow]-rad[p1->jcol]-p1->rad)+com->vary[2*p1->irow]*p1->amp*v[p1->jcol]*cos(rad[p1->irow]-rad[p1->jcol]-p1->rad); + p5->irow=t+4*p1->jcol-3; + p5->jcol=t+4*p1->irow-2; + p5->z=-com->vary[2*p1->irow-1]*p1->amp*v[p1->jcol]*sin(rad[p1->irow]-rad[p1->jcol]-p1->rad)+com->vary[2*p1->irow]*p1->amp*v[p1->jcol]*cos(rad[p1->irow]-rad[p1->jcol]-p1->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + +// hasin[t+4*p1->irow-3][t+4*p1->jcol-2]+=com->vary[2*p1->irow-1]*v[p1->irow]*p1->amp*sin(rad[p1->irow]-rad[p1->jcol]-p1->rad)-com->vary[2*p1->irow]*v[p1->irow]*p1->amp*cos(rad[p1->irow]-rad[p1->jcol]-p1->rad); + p5->irow=t+4*p1->irow-3; + p5->jcol=t+4*p1->jcol-2; + p5->z=com->vary[2*p1->irow-1]*v[p1->irow]*p1->amp*sin(rad[p1->irow]-rad[p1->jcol]-p1->rad)-com->vary[2*p1->irow]*v[p1->irow]*p1->amp*cos(rad[p1->irow]-rad[p1->jcol]-p1->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + +// hasin[t+4*p1->jcol-2][t+4*p1->jcol-3]+=-com->vary[2*p1->irow-1]*v[p1->irow]*p1->amp*sin(rad[p1->irow]-rad[p1->jcol]-p1->rad)+com->vary[2*p1->irow]*v[p1->irow]*p1->amp*cos(rad[p1->irow]-rad[p1->jcol]-p1->rad); + p5->irow=t+4*p1->jcol-2; + p5->jcol=t+4*p1->jcol-3; + p5->z=-com->vary[2*p1->irow-1]*v[p1->irow]*p1->amp*sin(rad[p1->irow]-rad[p1->jcol]-p1->rad)+com->vary[2*p1->irow]*v[p1->irow]*p1->amp*cos(rad[p1->irow]-rad[p1->jcol]-p1->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + +// hasin[t+4*p1->jcol-2][t+4*p1->irow-3]+=com->vary[2*p1->irow-1]*v[p1->irow]*p1->amp*sin(rad[p1->irow]-rad[p1->jcol]-p1->rad)-com->vary[2*p1->irow]*v[p1->irow]*p1->amp*cos(rad[p1->irow]-rad[p1->jcol]-p1->rad); + p5->irow=t+4*p1->jcol-2; + p5->jcol=t+4*p1->irow-3; + p5->z=com->vary[2*p1->irow-1]*v[p1->irow]*p1->amp*sin(rad[p1->irow]-rad[p1->jcol]-p1->rad)-com->vary[2*p1->irow]*v[p1->irow]*p1->amp*cos(rad[p1->irow]-rad[p1->jcol]-p1->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + +// hasin[t+4*p1->jcol-2][t+4*p1->irow-2]+=-com->vary[2*p1->irow-1]*p1->amp*cos(rad[p1->irow]-rad[p1->jcol]-p1->rad)-com->vary[2*p1->irow]*p1->amp*sin(rad[p1->irow]-rad[p1->jcol]-p1->rad); + p5->irow=t+4*p1->jcol-2; + p5->jcol=t+4*p1->irow-2; + p5->z=-com->vary[2*p1->irow-1]*p1->amp*cos(rad[p1->irow]-rad[p1->jcol]-p1->rad)-com->vary[2*p1->irow]*p1->amp*sin(rad[p1->irow]-rad[p1->jcol]-p1->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + +// hasin[t+4*p1->irow-2][t+4*p1->jcol-3]+=-com->vary[2*p1->irow-1]*p1->amp*v[p1->jcol]*sin(rad[p1->irow]-rad[p1->jcol]-p1->rad)+com->vary[2*p1->irow]*p1->amp*v[p1->jcol]*cos(rad[p1->irow]-rad[p1->jcol]-p1->rad); + p5->irow=t+4*p1->irow-2; + p5->jcol=t+4*p1->jcol-3; + p5->z=-com->vary[2*p1->irow-1]*p1->amp*v[p1->jcol]*sin(rad[p1->irow]-rad[p1->jcol]-p1->rad)+com->vary[2*p1->irow]*p1->amp*v[p1->jcol]*cos(rad[p1->irow]-rad[p1->jcol]-p1->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + +// hasin[t+4*p1->irow-2][t+4*p1->jcol-2]+=-com->vary[2*p1->irow-1]*p1->amp*cos(rad[p1->irow]-rad[p1->jcol]-p1->rad)-com->vary[2*p1->irow]*p1->amp*sin(rad[p1->irow]-rad[p1->jcol]-p1->rad); + p5->irow=t+4*p1->irow-2; + p5->jcol=t+4*p1->jcol-2; + p5->z=-com->vary[2*p1->irow-1]*p1->amp*cos(rad[p1->irow]-rad[p1->jcol]-p1->rad)-com->vary[2*p1->irow]*p1->amp*sin(rad[p1->irow]-rad[p1->jcol]-p1->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p1=p1->next; + } + + for(i=1;i<=mm;i++) //潮流方程等式约束的2阶海森阵（对角线） + { p1=com->a[i]; + r=0; + x=0; + j=0; + if(p1!=null) + { while((p1->irow==i)&&(j==0)) + { r=r+p1->amp*v[p1->jcol]*cos(rad[p1->irow]-rad[p1->jcol]-p1->rad); + x=x+p1->amp*v[p1->jcol]*sin(rad[p1->irow]-rad[p1->jcol]-p1->rad); + if(p1->next==null) + j=1; + else + p1=p1->next; + } + } +// hasin[t+4*i-3][t+4*i-3]+=com->vary[2*i-1]*v[i]*r+com->vary[2*i]*v[i]*x; + p5->irow=t+4*i-3; + p5->jcol=t+4*i-3; + p5->z=com->vary[2*i-1]*v[i]*r+com->vary[2*i]*v[i]*x; + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + +// hasin[t+4*i-3][t+4*i-2]+=com->vary[2*i-1]*x-com->vary[2*i]*r; + p5->irow=t+4*i-3; + p5->jcol=t+4*i-2; + p5->z=com->vary[2*i-1]*x-com->vary[2*i]*r; + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + +// hasin[t+4*i-2][t+4*i-3]+=com->vary[2*i-1]*x-com->vary[2*i]*r; + p5->irow=t+4*i-2; + p5->jcol=t+4*i-3; + p5->z=com->vary[2*i-1]*x-com->vary[2*i]*r; + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + +// hasin[t+4*i-2][t+4*i-2]+=-com->vary[2*i-1]*2*g[i]*cos(b[i])+com->vary[2*i]*2*g[i]*sin(b[i]); + p5->irow=t+4*i-2; + p5->jcol=t+4*i-2; + p5->z=-com->vary[2*i-1]*2*com->g[i]*cos(com->b[i])+com->vary[2*i]*2*com->g[i]*sin(com->b[i]); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + } + + i=1; + j=rr-rv; + n=rp+rq+rk+2*rkb+rt+rx; + p2=com->head_lcos; //线路功率因数方程等式约束的2阶海森阵（下三角） + while(p2!=null) + { +// p7=com->head_lij; + p1=com->a[p2->i]; + + t=0; + while((p1!=null)&&(t==0)) + { if((p1->irow==p2->i)&&(p1->jcol==p2->j)) + t=1; + else + p1=p1->next; + } + + t=p2->i; + m=p2->j; + + r=com->vary[2*mm+i]; //Pij + if(p1!=null) + { + p5->irow=j+4*t-3; //a&i + p5->jcol=j+4*t-3; //a&i + p5->z=r*v[t]*v[m]*p1->amp*cos(rad[t]-rad[m]-p1->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + // hasin[j+4*t-2][j+4*t-3]+=-r*v[m]*p1->amp*sin(rad[t]-rad[m]-p1->rad); + p5->irow=j+4*t-2; //aVi + p5->jcol=j+4*t-3; //a&i + p5->z=r*v[m]*p1->amp*sin(rad[t]-rad[m]-p1->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + // hasin[j+4*m-3][j+4*t-3]+=r*v[t]*v[m]*p1->amp*cos(rad[t]-rad[m]-p1->rad); + p5->irow=j+4*m-3; //a&j + p5->jcol=j+4*t-3; //a&i + p5->z=-r*v[t]*v[m]*p1->amp*cos(rad[t]-rad[m]-p1->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + // hasin[j+4*m-2][j+4*t-3]+=-r*v[t]*p1->amp*sin(rad[t]-rad[m]-p1->rad); + p5->irow=j+4*m-2; //aVj + p5->jcol=j+4*t-3; //a&i + p5->z=r*v[t]*p1->amp*sin(rad[t]-rad[m]-p1->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + // hasin[j+4*t-3][j+4*t-2]+=-r*v[m]*p1->amp*sin(rad[t]-rad[m]-p1->rad); + p5->irow=j+4*t-3; //a&i + p5->jcol=j+4*t-2; //aVi + p5->z=r*v[m]*p1->amp*sin(rad[t]-rad[m]-p1->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + // hasin[j+4*t-2][j+4*t-2]+=-r*2*p1->amp*sin(rad[t]-rad[m]-p1->rad); + p5->irow=j+4*t-2; //aVi + p5->jcol=j+4*t-2; //aVi + p5->z=r*2*p1->amp*cos(p1->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + // hasin[j+4*m-3][j+4*t-2]+=r*v[m]*p1->amp*sin(rad[t]-rad[m]-p1->rad); + p5->irow=j+4*m-3; //a&j + p5->jcol=j+4*t-2; //aVi + p5->z=-r*v[m]*p1->amp*sin(rad[t]-rad[m]-p1->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + // hasin[j+4*m-2][j+4*t-2]+=r*p1->amp*cos(rad[t]-rad[m]-p1->rad); + p5->irow=j+4*m-2; //aVj + p5->jcol=j+4*t-2; //aVi + p5->z=-r*p1->amp*cos(rad[t]-rad[m]-p1->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + // hasin[j+4*t-3][j+4*m-3]+=r*v[t]*v[m]*p1->amp*cos(rad[t]-rad[m]-p1->rad); + p5->irow=j+4*t-3; //a&i + p5->jcol=j+4*m-3; //a&j + p5->z=-r*v[t]*v[m]*p1->amp*cos(rad[t]-rad[m]-p1->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + // hasin[j+4*t-2][j+4*m-3]+=r*v[m]*p1->amp*sin(rad[t]-rad[m]-p1->rad); + p5->irow=j+4*t-2; //aVi + p5->jcol=j+4*m-3; //a&j + p5->z=-r*v[m]*p1->amp*sin(rad[t]-rad[m]-p1->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + // hasin[j+4*m-3][j+4*m-3]+=-r*v[t]*v[m]*p1->amp*cos(rad[t]-rad[m]-p1->rad); + p5->irow=j+4*m-3; //a&j + p5->jcol=j+4*m-3; //a&j + p5->z=r*v[t]*v[m]*p1->amp*cos(rad[t]-rad[m]-p1->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + // hasin[j+4*m-2][j+4*m-3]+=r*v[t]*p1->amp*sin(rad[t]-rad[m]-p1->rad); + p5->irow=j+4*m-2; //aVj + p5->jcol=j+4*m-3; //a&j + p5->z=-r*v[t]*p1->amp*sin(rad[t]-rad[m]-p1->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + // hasin[j+4*t-3][j+4*m-2]+=-r*v[t]*p1->amp*sin(rad[t]-rad[m]-p1->rad); + p5->irow=j+4*t-3; //a&i + p5->jcol=j+4*m-2; //aVj + p5->z=r*v[t]*p1->amp*sin(rad[t]-rad[m]-p1->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + // hasin[j+4*t-2][j+4*m-2]+=r*p1->amp*cos(rad[t]-rad[m]-p1->rad); + p5->irow=j+4*t-2; //aVi + p5->jcol=j+4*m-2; //aVj + p5->z=-r*p1->amp*cos(rad[t]-rad[m]-p1->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + // hasin[j+4*m-3][j+4*m-2]+=r*v[t]*p1->amp*sin(rad[t]-rad[m]-p1->rad); + p5->irow=j+4*m-3; //a&j + p5->jcol=j+4*m-2; //aVj + p5->z=-r*v[t]*p1->amp*sin(rad[t]-rad[m]-p1->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + } + + r=com->vary[2*mm+i+rlcos]; //Qij + if(p1!=null) + { + // hasin[j+4*t-3][j+4*t-3]+=-r*v[t]*v[m]*p1->amp*cos(rad[t]-rad[m]-p1->rad); + p5->irow=j+4*t-3; //aiai + p5->jcol=j+4*t-3; + p5->z=r*v[t]*v[m]*p1->amp*sin(rad[t]-rad[m]-p1->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + // hasin[j+4*t-2][j+4*t-3]+=-r*v[m]*p1->amp*sin(rad[t]-rad[m]-p1->rad); + p5->irow=j+4*t-2; //Viai + p5->jcol=j+4*t-3; + p5->z=-r*v[m]*p1->amp*cos(rad[t]-rad[m]-p1->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + // hasin[j+4*m-3][j+4*t-3]+=r*v[t]*v[m]*p1->amp*cos(rad[t]-rad[m]-p1->rad); + p5->irow=j+4*m-3; //ajai + p5->jcol=j+4*t-3; + p5->z=-r*v[t]*v[m]*p1->amp*sin(rad[t]-rad[m]-p1->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + // hasin[j+4*m-2][j+4*t-3]+=-r*v[t]*p1->amp*sin(rad[t]-rad[m]-p1->rad); + p5->irow=j+4*m-2; //Vjai + p5->jcol=j+4*t-3; + p5->z=-r*v[t]*p1->amp*cos(rad[t]-rad[m]-p1->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + // hasin[j+4*t-3][j+4*t-2]+=-r*v[m]*p1->amp*sin(rad[t]-rad[m]-p1->rad); + p5->irow=j+4*t-3; //aiVi + p5->jcol=j+4*t-2; + p5->z=-r*v[m]*p1->amp*cos(rad[t]-rad[m]-p1->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + // hasin[j+4*t-2][j+4*t-2]+=-r*2*p1->amp*sin(rad[t]-rad[m]-p1->rad); + p5->irow=j+4*t-2; //ViVi + p5->jcol=j+4*t-2; + p5->z=-r*2*p1->amp*sin(p1->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + // hasin[j+4*m-3][j+4*t-2]+=r*v[m]*p1->amp*sin(rad[t]-rad[m]-p1->rad); + p5->irow=j+4*m-3; //ajVi + p5->jcol=j+4*t-2; + p5->z=r*v[m]*p1->amp*cos(rad[t]-rad[m]-p1->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=j+4*m-2; //VjVi + p5->jcol=j+4*t-2; + p5->z=-r*p1->amp*sin(rad[t]-rad[m]-p1->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + // hasin[j+4*t-3][j+4*m-3]+=r*v[t]*v[m]*p1->amp*cos(rad[t]-rad[m]-p1->rad); + p5->irow=j+4*t-3; //aiaj + p5->jcol=j+4*m-3; + p5->z=-r*v[t]*v[m]*p1->amp*sin(rad[t]-rad[m]-p1->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + // hasin[j+4*t-2][j+4*m-3]+=r*v[m]*p1->amp*sin(rad[t]-rad[m]-p1->rad); + p5->irow=j+4*t-2; //Viaj + p5->jcol=j+4*m-3; + p5->z=r*v[m]*p1->amp*cos(rad[t]-rad[m]-p1->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + // hasin[j+4*m-3][j+4*m-3]+=-r*v[t]*v[m]*p1->amp*cos(rad[t]-rad[m]-p1->rad); + p5->irow=j+4*m-3; //ajaj + p5->jcol=j+4*m-3; + p5->z=r*v[t]*v[m]*p1->amp*sin(rad[t]-rad[m]-p1->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + // hasin[j+4*m-2][j+4*m-3]+=r*v[t]*p1->amp*sin(rad[t]-rad[m]-p1->rad); + p5->irow=j+4*m-2; //Vjaj + p5->jcol=j+4*m-3; + p5->z=r*v[t]*p1->amp*cos(rad[t]-rad[m]-p1->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + // hasin[j+4*t-3][j+4*m-2]+=-r*v[t]*p1->amp*sin(rad[t]-rad[m]-p1->rad); + p5->irow=j+4*t-3; //aiVj + p5->jcol=j+4*m-2; + p5->z=-r*v[t]*p1->amp*cos(rad[t]-rad[m]-p1->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + // hasin[j+4*t-2][j+4*m-2]+=r*p1->amp*cos(rad[t]-rad[m]-p1->rad); + p5->irow=j+4*t-2; //ViVj + p5->jcol=j+4*m-2; + p5->z=-r*p1->amp*sin(rad[t]-rad[m]-p1->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + // hasin[j+4*m-3][j+4*m-2]+=r*v[t]*p1->amp*sin(rad[t]-rad[m]-p1->rad); + p5->irow=j+4*m-3; //ajVj + p5->jcol=j+4*m-2; + p5->z=-r*v[t]*p1->amp*cos(rad[t]-rad[m]-p1->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + } + + i=i+1; + p2=p2->next; + } + + i=1; + t=rr-rv; + n=rp+rq+rk+2*rkb+rt+rx+2*rlcos; + p2=com->head_vdcos; //负荷模型功率因数方程等式约束的2阶海森阵（下三角） + while(p2!=null) + { x=0; + r=0; + ap=0; + bp=0; + aq=0; + bq=0; + + p8=com->head_vpd; + j=0; + while((p8!=null)&&(j==0)) + { if(p2->i==p8->i) + j=1; + else + p8=p8->next; + } + if(p8!=null) + { x=p8->a*pow(v[p2->i],2)+p8->b*v[p2->i]+p8->c; //PDi + ap=p8->a; + bp=p8->b; + } + + p8=com->head_vqd; + j=0; + while((p8!=null)&&(j==0)) + { if(p2->i==p8->i) + j=1; + else + p8=p8->next; + } + if(p8!=null) + { r=p8->a*pow(v[p2->i],2)+p8->b*v[p2->i]+p8->c; //QDi + aq=p8->a; + bq=p8->b; + } + + p5->irow=t+4*p2->i-2; //aVi + p5->jcol=t+4*p2->i-2; //aVi + p5->z=com->vary[2*mm+2*rlcos+i]*((2*pow(2*ap*v[p2->i]+bp,2)+4*ap*x+2*pow(2*aq*v[p2->i]+bq,2)+4*aq*r)*pow(p2->g,2)-(2*pow(2*ap*v[p2->i]+bp,2)+4*ap*x)); //aVi aVi (下三角) + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=t+4*p2->i-2; //aVi + p5->jcol=n+i; //acosDi + p5->z=com->vary[2*mm+2*rlcos+i]*4*(x*(2*ap*v[p2->i]+bp)+r*(2*aq*v[p2->i]+bq))*p2->g; //acosDi aVi(下三角) + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=n+i; //acosDi + p5->jcol=n+i; //acosDi + p5->z=com->vary[2*mm+2*rlcos+i]*2*(x*x+r*r); //acosDi acosDi(下三角) + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p2=p2->next; + i=i+1; + } + + n=rp+rq; + t=rr-rv; //海森矩阵（潮流方程） + p6=com->head_kij; //可调变压器变比部分（确定数值） + i=1; + while(p6!=null) + { + j=2*p6->i-1; + + p5->irow=n+i; // a2Pi/a2kij + p5->jcol=n+i; + p5->z=com->vary[j]*2*v[p6->i]*v[p6->i]*p6->amp*cos(p6->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=t+p6->i*4-3; // a2Pi/akija&i + p5->jcol=n+i; + p5->z=com->vary[j]*v[p6->i]*p6->amp*v[p6->j]*sin(rad[p6->i]-rad[p6->j]-p6->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=t+p6->i*4-2; // a2Pi/akijaVi + p5->jcol=n+i; + p5->z=com->vary[j]*(4*v[p6->i]*p6->k*p6->amp*cos(p6->rad)-p6->amp*v[p6->j]*cos(rad[p6->i]-rad[p6->j]-p6->rad)); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=t+p6->j*4-3; // a2Pi/akija&j + p5->jcol=n+i; + p5->z=-com->vary[j]*v[p6->i]*p6->amp*v[p6->j]*sin(rad[p6->i]-rad[p6->j]-p6->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=t+p6->j*4-2; // a2Pi/akijaVj + p5->jcol=n+i; + p5->z=-com->vary[j]*v[p6->i]*p6->amp*cos(rad[p6->i]-rad[p6->j]-p6->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + j=2*p6->i; + + p5->irow=n+i; // a2Qi/a2kij + p5->jcol=n+i; + p5->z=-com->vary[j]*2*v[p6->i]*v[p6->i]*p6->amp*sin(p6->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=t+p6->i*4-3; // a2Qi/akija&i + p5->jcol=n+i; + p5->z=-com->vary[j]*v[p6->i]*p6->amp*v[p6->j]*cos(rad[p6->i]-rad[p6->j]-p6->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=t+p6->i*4-2; // a2Qi/akijaVi + p5->jcol=n+i; + p5->z=com->vary[j]*(-4*v[p6->i]*p6->k*p6->amp*sin(p6->rad)-p6->amp*v[p6->j]*sin(rad[p6->i]-rad[p6->j]-p6->rad)); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=t+p6->j*4-3; // a2Qi/akija&j + p5->jcol=n+i; + p5->z=com->vary[j]*v[p6->i]*p6->amp*v[p6->j]*cos(rad[p6->i]-rad[p6->j]-p6->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=t+p6->j*4-2; // a2Qi/akijaVj + p5->jcol=n+i; + p5->z=-com->vary[j]*v[p6->i]*p6->amp*sin(rad[p6->i]-rad[p6->j]-p6->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + j=2*p6->j-1; + +// a2Pj/a2kij=0 + p5->irow=t+p6->i*4-3; // a2Pj/akija&i + p5->jcol=n+i; + p5->z=-com->vary[j]*v[p6->j]*p6->amp*v[p6->i]*sin(rad[p6->j]-rad[p6->i]-p6->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=t+p6->i*4-2; // a2Pj/akijaVi + p5->jcol=n+i; + p5->z=-com->vary[j]*v[p6->j]*p6->amp*cos(rad[p6->j]-rad[p6->i]-p6->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=t+p6->j*4-3; // a2Pj/akija&j + p5->jcol=n+i; + p5->z=com->vary[j]*v[p6->j]*p6->amp*v[p6->i]*sin(rad[p6->j]-rad[p6->i]-p6->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=t+p6->j*4-2; // a2Pj/akijaVj + p5->jcol=n+i; + p5->z=-com->vary[j]*p6->amp*v[p6->i]*cos(rad[p6->j]-rad[p6->i]-p6->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + j=2*p6->j; + +// a2Qj/a2kij=0 + + p5->irow=t+p6->i*4-3; // a2Qj/akija&i + p5->jcol=n+i; + p5->z=com->vary[j]*v[p6->j]*p6->amp*v[p6->i]*cos(rad[p6->j]-rad[p6->i]-p6->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=t+p6->i*4-2; // a2Qj/akijaVi + p5->jcol=n+i; + p5->z=-com->vary[j]*v[p6->j]*p6->amp*sin(rad[p6->j]-rad[p6->i]-p6->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=t+p6->j*4-3; // a2Qj/akija&j + p5->jcol=n+i; + p5->z=-com->vary[j]*v[p6->j]*p6->amp*v[p6->i]*cos(rad[p6->j]-rad[p6->i]-p6->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=t+p6->j*4-2; // a2Qj/akijaVj + p5->jcol=n+i; + p5->z=-com->vary[j]*p6->amp*v[p6->i]*sin(rad[p6->j]-rad[p6->i]-p6->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + i=i+1; + p6=p6->next; + } + + n=rp+rq+rk; + t=rr-rv; //海森矩阵（潮流方程） + p6=com->head_kbij; //可调移相器变比部分（确定数值） + i=1; + while(p6!=null) + { +//kij + j=2*p6->i-1; //Pi + + p5->irow=n+i; // a2Pi/a2kij + p5->jcol=n+i; + p5->z=com->vary[j]*2*v[p6->i]*v[p6->i]*p6->amp*cos(p6->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=t+p6->i*4-3; // a2Pi/akija&i + p5->jcol=n+i; + p5->z=com->vary[j]*v[p6->i]*p6->amp*v[p6->j]*sin(rad[p6->i]-rad[p6->j]-p6->rad+p6->b); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=t+p6->i*4-2; // a2Pi/akijaVi + p5->jcol=n+i; + p5->z=com->vary[j]*(4*v[p6->i]*p6->k*p6->amp*cos(p6->rad)-p6->amp*v[p6->j]*cos(rad[p6->i]-rad[p6->j]-p6->rad+p6->b)); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=t+p6->j*4-3; // a2Pi/akija&j + p5->jcol=n+i; + p5->z=-com->vary[j]*v[p6->i]*p6->amp*v[p6->j]*sin(rad[p6->i]-rad[p6->j]-p6->rad+p6->b); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=t+p6->j*4-2; // a2Pi/akijaVj + p5->jcol=n+i; + p5->z=-com->vary[j]*v[p6->i]*p6->amp*cos(rad[p6->i]-rad[p6->j]-p6->rad+p6->b); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=n+i+rkb; // a2Pi/akijabij (下三角) + p5->jcol=n+i; + p5->z=com->vary[j]*v[p6->i]*p6->amp*v[p6->j]*sin(rad[p6->i]-rad[p6->j]-p6->rad+p6->b); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + j=2*p6->i; //Qi + + p5->irow=n+i; // a2Qi/a2kij + p5->jcol=n+i; + p5->z=-com->vary[j]*2*v[p6->i]*v[p6->i]*p6->amp*sin(p6->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=t+p6->i*4-3; // a2Qi/akija&i + p5->jcol=n+i; + p5->z=-com->vary[j]*v[p6->i]*p6->amp*v[p6->j]*cos(rad[p6->i]-rad[p6->j]-p6->rad+p6->b); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=t+p6->i*4-2; // a2Qi/akijaVi + p5->jcol=n+i; + p5->z=com->vary[j]*(-4*v[p6->i]*p6->k*p6->amp*sin(p6->rad)-p6->amp*v[p6->j]*sin(rad[p6->i]-rad[p6->j]-p6->rad+p6->b)); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=t+p6->j*4-3; // a2Qi/akija&j + p5->jcol=n+i; + p5->z=com->vary[j]*v[p6->i]*p6->amp*v[p6->j]*cos(rad[p6->i]-rad[p6->j]-p6->rad+p6->b); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=t+p6->j*4-2; // a2Qi/akijaVj + p5->jcol=n+i; + p5->z=-com->vary[j]*v[p6->i]*p6->amp*sin(rad[p6->i]-rad[p6->j]-p6->rad+p6->b); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=n+i+rkb; // a2Qi/akijabij + p5->jcol=n+i; + p5->z=-com->vary[j]*v[p6->i]*p6->amp*v[p6->j]*cos(rad[p6->i]-rad[p6->j]-p6->rad+p6->b); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + j=2*p6->j-1; //Pj + +// a2Pj/a2kij=0 + p5->irow=t+p6->i*4-3; // a2Pj/akija&i + p5->jcol=n+i; + p5->z=-com->vary[j]*v[p6->j]*p6->amp*v[p6->i]*sin(rad[p6->j]-rad[p6->i]-p6->rad-p6->b); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=t+p6->i*4-2; // a2Pj/akijaVi + p5->jcol=n+i; + p5->z=-com->vary[j]*v[p6->j]*p6->amp*cos(rad[p6->j]-rad[p6->i]-p6->rad-p6->b); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=t+p6->j*4-3; // a2Pj/akija&j + p5->jcol=n+i; + p5->z=com->vary[j]*v[p6->j]*p6->amp*v[p6->i]*sin(rad[p6->j]-rad[p6->i]-p6->rad-p6->b); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=t+p6->j*4-2; // a2Pj/akijaVj + p5->jcol=n+i; + p5->z=-com->vary[j]*p6->amp*v[p6->i]*cos(rad[p6->j]-rad[p6->i]-p6->rad-p6->b); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=n+i+rkb; // a2Pj/akijabij + p5->jcol=n+i; + p5->z=-com->vary[j]*v[p6->j]*p6->amp*v[p6->i]*sin(rad[p6->j]-rad[p6->i]-p6->rad-p6->b); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + j=2*p6->j; //Qj + +// a2Qj/a2kij=0 + + p5->irow=t+p6->i*4-3; // a2Qj/akija&i + p5->jcol=n+i; + p5->z=com->vary[j]*v[p6->j]*p6->amp*v[p6->i]*cos(rad[p6->j]-rad[p6->i]-p6->rad-p6->b); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=t+p6->i*4-2; // a2Qj/akijaVi + p5->jcol=n+i; + p5->z=-com->vary[j]*v[p6->j]*p6->amp*sin(rad[p6->j]-rad[p6->i]-p6->rad-p6->b); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=t+p6->j*4-3; // a2Qj/akija&j + p5->jcol=n+i; + p5->z=-com->vary[j]*v[p6->j]*p6->amp*v[p6->i]*cos(rad[p6->j]-rad[p6->i]-p6->rad-p6->b); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=t+p6->j*4-2; // a2Qj/akijaVj + p5->jcol=n+i; + p5->z=-com->vary[j]*p6->amp*v[p6->i]*sin(rad[p6->j]-rad[p6->i]-p6->rad-p6->b); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=n+i+rkb; // a2Qj/akijabij + p5->jcol=n+i; + p5->z=com->vary[j]*v[p6->j]*p6->amp*v[p6->i]*cos(rad[p6->j]-rad[p6->i]-p6->rad-p6->b); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + +//bij + j=2*p6->i-1; //Pi + + p5->irow=n+i+rkb; // a2Pi/a2bij + p5->jcol=n+i+rkb; + p5->z=com->vary[j]*v[p6->i]*p6->k*p6->amp*v[p6->j]*cos(rad[p6->i]-rad[p6->j]-p6->rad+p6->b); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=t+p6->i*4-3; // a2Pi/abija&i + p5->jcol=n+i+rkb; + p5->z=com->vary[j]*v[p6->i]*p6->k*p6->amp*v[p6->j]*cos(rad[p6->i]-rad[p6->j]-p6->rad+p6->b); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=t+p6->i*4-2; // a2Pi/abijaVi + p5->jcol=n+i+rkb; + p5->z=com->vary[j]*p6->k*p6->amp*v[p6->j]*sin(rad[p6->i]-rad[p6->j]-p6->rad+p6->b); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=t+p6->j*4-3; // a2Pi/abija&j + p5->jcol=n+i+rkb; + p5->z=-com->vary[j]*v[p6->i]*p6->k*p6->amp*v[p6->j]*cos(rad[p6->i]-rad[p6->j]-p6->rad+p6->b); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=t+p6->j*4-2; // a2Pi/abijaVj + p5->jcol=n+i+rkb; + p5->z=com->vary[j]*p6->k*p6->amp*v[p6->i]*sin(rad[p6->i]-rad[p6->j]-p6->rad+p6->b); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + +// a2Pi/abijakij,只存下三角，前面已经做了 + + j=2*p6->i; //Qi + + p5->irow=n+i+rkb; // a2Qi/a2bij + p5->jcol=n+i+rkb; + p5->z=com->vary[j]*v[p6->i]*p6->k*p6->amp*v[p6->j]*sin(rad[p6->i]-rad[p6->j]-p6->rad+p6->b); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=t+p6->i*4-3; // a2Qi/abija&i + p5->jcol=n+i+rkb; + p5->z=com->vary[j]*v[p6->i]*p6->k*p6->amp*v[p6->j]*sin(rad[p6->i]-rad[p6->j]-p6->rad+p6->b); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=t+p6->i*4-2; // a2Qi/abijaVi + p5->jcol=n+i+rkb; + p5->z=-com->vary[j]*p6->k*p6->amp*v[p6->j]*cos(rad[p6->i]-rad[p6->j]-p6->rad+p6->b); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=t+p6->j*4-3; // a2Qi/abija&j + p5->jcol=n+i+rkb; + p5->z=-com->vary[j]*v[p6->i]*p6->k*p6->amp*v[p6->j]*sin(rad[p6->i]-rad[p6->j]-p6->rad+p6->b); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=t+p6->j*4-2; // a2Qi/abijaVj + p5->jcol=n+i+rkb; + p5->z=-com->vary[j]*p6->k*p6->amp*v[p6->i]*cos(rad[p6->i]-rad[p6->j]-p6->rad+p6->b); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + +// a2Qi/abijakij,只存下三角，前面已经做了 + + j=2*p6->j-1; //Pj + + p5->irow=n+i+rkb; // a2Pj/a2bij + p5->jcol=n+i+rkb; + p5->z=com->vary[j]*v[p6->i]*p6->k*p6->amp*v[p6->j]*cos(rad[p6->j]-rad[p6->i]-p6->rad-p6->b); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=t+p6->i*4-3; // a2Pj/abija&i + p5->jcol=n+i+rkb; + p5->z=com->vary[j]*v[p6->i]*p6->k*p6->amp*v[p6->j]*cos(rad[p6->j]-rad[p6->i]-p6->rad-p6->b); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=t+p6->i*4-2; // a2Pj/abijaVi + p5->jcol=n+i+rkb; + p5->z=-com->vary[j]*v[p6->j]*p6->k*p6->amp*sin(rad[p6->j]-rad[p6->i]-p6->rad-p6->b); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=t+p6->j*4-3; // a2Pj/abija&j + p5->jcol=n+i+rkb; + p5->z=-com->vary[j]*v[p6->i]*p6->k*p6->amp*v[p6->j]*cos(rad[p6->j]-rad[p6->i]-p6->rad-p6->b); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=t+p6->j*4-2; // a2Pj/abijaVj + p5->jcol=n+i+rkb; + p5->z=-com->vary[j]*p6->k*p6->amp*v[p6->i]*sin(rad[p6->j]-rad[p6->i]-p6->rad-p6->b); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + +// a2Pj/abijakij,只存下三角，前面已经做了 + + j=2*p6->j; //Qj + + p5->irow=n+i+rkb; // a2Qj/a2bij + p5->jcol=n+i+rkb; + p5->z=com->vary[j]*v[p6->j]*p6->k*p6->amp*v[p6->i]*sin(rad[p6->j]-rad[p6->i]-p6->rad-p6->b); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=t+p6->i*4-3; // a2Qj/abija&i + p5->jcol=n+i+rkb; + p5->z=com->vary[j]*v[p6->j]*p6->k*p6->amp*v[p6->i]*sin(rad[p6->j]-rad[p6->i]-p6->rad-p6->b); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=t+p6->i*4-2; // a2Qj/abijaVi + p5->jcol=n+i+rkb; + p5->z=com->vary[j]*v[p6->j]*p6->k*p6->amp*cos(rad[p6->j]-rad[p6->i]-p6->rad-p6->b); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=t+p6->j*4-3; // a2Qj/abija&j + p5->jcol=n+i+rkb; + p5->z=-com->vary[j]*v[p6->j]*p6->k*p6->amp*v[p6->i]*sin(rad[p6->j]-rad[p6->i]-p6->rad-p6->b); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=t+p6->j*4-2; // a2Qj/abijaVj + p5->jcol=n+i+rkb; + p5->z=com->vary[j]*v[p6->i]*p6->k*p6->amp*cos(rad[p6->j]-rad[p6->i]-p6->rad-p6->b); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + +// a2Qj/abijakij,只存下三角，前面已经做了 + + i=i+1; + p6=p6->next; + } + + n=rp+rq+rk+2*rkb; + t=rr-rv; //海森矩阵（潮流方程） + p6=com->head_ti; //可调电容器部分（定位置，只要算k那一列就可以了，列的行号都比列号大，行的都在后面，可不记） + i=1; + while(p6!=null) + { + j=2*p6->i-1; + + p5->irow=t+p6->i*4-2; // a2Pi/atiaVi + p5->jcol=n+i; + p5->z=com->vary[j]*(-2*v[p6->i]*p6->amp*cos(p6->rad)); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + j=2*p6->i; + + p5->irow=t+p6->i*4-2; // a2Qi/akijaVi + p5->jcol=n+i; + p5->z=com->vary[j]*(2*v[p6->i]*p6->amp*sin(p6->rad)); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + +// a2Qi/akijaVi 在位置上与pi部分重叠 + i=i+1; + p6=p6->next; + } + + n=rp+rq+rk+2*rkb+rt; + t=rr-rv; //海森矩阵（潮流方程） + p6=com->head_kx; //可调线路电抗部分（确定数值） + i=1; + while(p6!=null) + { + j=2*p6->i-1; + +/* + p5->irow=n+i; // a2Pi/a2kx + p5->jcol=n+i; + p5->z=0 + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix);*/ + + + p5->irow=t+p6->i*4-3; // a2Pi/akxa&i + p5->jcol=n+i; + p5->z=com->vary[j]*v[p6->i]*p6->amp*v[p6->j]*sin(rad[p6->i]-rad[p6->j]-p6->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=t+p6->i*4-2; // a2Pi/akxaVi + p5->jcol=n+i; + p5->z=com->vary[j]*(2*v[p6->i]*p6->amp*cos(p6->rad)-p6->amp*v[p6->j]*cos(rad[p6->i]-rad[p6->j]-p6->rad)); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=t+p6->j*4-3; // a2Pi/akxa&j + p5->jcol=n+i; + p5->z=-com->vary[j]*v[p6->i]*p6->amp*v[p6->j]*sin(rad[p6->i]-rad[p6->j]-p6->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=t+p6->j*4-2; // a2Pi/akxaVj + p5->jcol=n+i; + p5->z=-com->vary[j]*v[p6->i]*p6->amp*cos(rad[p6->i]-rad[p6->j]-p6->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + j=2*p6->i; + +/* + p5->irow=n+i; // a2Qi/a2kx + p5->jcol=n+i; + p5->z=0; + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix);*/ + + + p5->irow=t+p6->i*4-3; // a2Qi/akxa&i + p5->jcol=n+i; + p5->z=-com->vary[j]*v[p6->i]*p6->amp*v[p6->j]*cos(rad[p6->i]-rad[p6->j]-p6->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=t+p6->i*4-2; // a2Qi/akxaVi + p5->jcol=n+i; + p5->z=com->vary[j]*(-2*v[p6->i]*p6->amp*sin(p6->rad)-p6->amp*v[p6->j]*sin(rad[p6->i]-rad[p6->j]-p6->rad)); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=t+p6->j*4-3; // a2Qi/akxa&j + p5->jcol=n+i; + p5->z=com->vary[j]*v[p6->i]*p6->amp*v[p6->j]*cos(rad[p6->i]-rad[p6->j]-p6->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=t+p6->j*4-2; // a2Qi/akxaVj + p5->jcol=n+i; + p5->z=-com->vary[j]*v[p6->i]*p6->amp*sin(rad[p6->i]-rad[p6->j]-p6->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + j=2*p6->j-1; + +// a2Pj/a2kij=0 + p5->irow=t+p6->j*4-3; // a2Pj/akxa&j + p5->jcol=n+i; + p5->z=com->vary[j]*v[p6->j]*p6->amp*v[p6->i]*sin(rad[p6->j]-rad[p6->i]-p6->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=t+p6->j*4-2; // a2Pj/akxaVj + p5->jcol=n+i; + p5->z=com->vary[j]*(2*v[p6->j]*p6->amp*cos(p6->rad)-p6->amp*v[p6->i]*cos(rad[p6->j]-rad[p6->i]-p6->rad)); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=t+p6->i*4-3; // a2Pj/akxa&i + p5->jcol=n+i; + p5->z=-com->vary[j]*v[p6->j]*p6->amp*v[p6->i]*sin(rad[p6->j]-rad[p6->i]-p6->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=t+p6->i*4-2; // a2Pj/akxaVi + p5->jcol=n+i; + p5->z=-com->vary[j]*v[p6->j]*p6->amp*cos(rad[p6->j]-rad[p6->i]-p6->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + j=2*p6->j; + +// a2Qj/a2kij=0 + + p5->irow=t+p6->j*4-3; // a2Qj/akxa&j + p5->jcol=n+i; + p5->z=-com->vary[j]*v[p6->j]*p6->amp*v[p6->i]*cos(rad[p6->j]-rad[p6->i]-p6->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=t+p6->j*4-2; // a2Qj/akxaVj + p5->jcol=n+i; + p5->z=com->vary[j]*(-2*v[p6->j]*p6->amp*sin(p6->rad)-p6->amp*v[p6->i]*sin(rad[p6->j]-rad[p6->i]-p6->rad)); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=t+p6->i*4-3; // a2Qj/akxa&i + p5->jcol=n+i; + p5->z=com->vary[j]*v[p6->j]*p6->amp*v[p6->i]*cos(rad[p6->j]-rad[p6->i]-p6->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=t+p6->i*4-2; // a2Qj/akxaVi + p5->jcol=n+i; + p5->z=-com->vary[j]*v[p6->j]*p6->amp*sin(rad[p6->j]-rad[p6->i]-p6->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + i=i+1; + p6=p6->next; + } + + n=rp+rq+rk+2*rkb+rt+rx+2*rlcos+rvdcos; + t=rr-rv; //海森矩阵（潮流方程、直流方程）只存下三角 + p12=com->head_dcbus; //直流节点部分 + i=1; + j=2*mm+2*rlcos+rvdcos; + while(p12!=null) + { + p5->irow=n+i+n_dc; // a2Pi/aIdaVd + p5->jcol=n+i; + if(p12->flag==1) + p5->z=com->vary[p12->iac*2-1]; + else + p5->z=-com->vary[p12->iac*2-1]; + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=n+i+n_dc; // a2Qi/aIdaVd + p5->jcol=n+i; + if(p12->flag==1) + p5->z=com->vary[p12->iac*2]*tan(com->varx[n+i+4*n_dc]); + else + p5->z=-com->vary[p12->iac*2]*tan(com->varx[n+i+4*n_dc]); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=n+i+4*n_dc; // a2Qi/afaraVd + p5->jcol=n+i; + if(p12->flag==1) + p5->z=com->vary[p12->iac*2]*com->varx[n+i+n_dc]/pow(cos(com->varx[n+i+4*n_dc]),2); + else + p5->z=-com->vary[p12->iac*2]*com->varx[n+i+n_dc]/pow(cos(com->varx[n+i+4*n_dc]),2); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=n+i+4*n_dc; // a2Qi/afaraId + p5->jcol=n+i+n_dc; + if(p12->flag==1) + p5->z=com->vary[p12->iac*2]*com->varx[n+i]/pow(cos(com->varx[n+i+4*n_dc]),2); + else + p5->z=-com->vary[p12->iac*2]*com->varx[n+i]/pow(cos(com->varx[n+i+4*n_dc]),2); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=n+i+4*n_dc; // a2Qi/afarafar + p5->jcol=n+i+4*n_dc; + if(p12->flag==1) + p5->z=com->vary[p12->iac*2]*2*com->varx[n+i]*com->varx[n+i+n_dc]*sin(com->varx[n+i+4*n_dc])/pow(cos(com->varx[n+i+4*n_dc]),3); + else + p5->z=-com->vary[p12->iac*2]*2*com->varx[n+i]*com->varx[n+i+n_dc]*sin(com->varx[n+i+4*n_dc])/pow(cos(com->varx[n+i+4*n_dc]),3); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=t+p12->iac*4-2; // a2d1/aViak + p5->jcol=n+i+2*n_dc; + p5->z=-com->vary[j+i]*com->varx[n+i+3*n_dc]; + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=n+i+3*n_dc; // a2d1/acosak + p5->jcol=n+i+2*n_dc; + p5->z=-com->vary[j+i]*v[p12->iac]; + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=t+p12->iac*4-2; // a2d1/aViacos + p5->jcol=n+i+3*n_dc; + p5->z=-com->vary[j+i]*com->varx[n+i+2*n_dc]; + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=t+p12->iac*4-2; // a2d2/aViak + p5->jcol=n+i+2*n_dc; + p5->z=-com->vary[j+i+n_dc]*p12->kr*cos(com->varx[n+i+4*n_dc]); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=n+i+4*n_dc; // a2d2/afarak + p5->jcol=n+i+2*n_dc; + p5->z=com->vary[j+i+n_dc]*p12->kr*v[p12->iac]*sin(com->varx[n+i+4*n_dc]); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=t+p12->iac*4-2; // a2d2/aViafar + p5->jcol=n+i+4*n_dc; + p5->z=com->vary[j+i+n_dc]*p12->kr*com->varx[n+i+2*n_dc]*sin(com->varx[n+i+4*n_dc]); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=n+i+4*n_dc; // a2d2/afarafar + p5->jcol=n+i+4*n_dc; + p5->z=com->vary[j+i+n_dc]*p12->kr*com->varx[n+i+2*n_dc]*v[p12->iac]*cos(com->varx[n+i+4*n_dc]); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + i=i+1; + p12=p12->next; + } + + p8=com->head_vpd; //海森矩阵,有功负荷部分（等式约束里的） （潮流方程） + while(p8!=null) + { j=2*p8->i-1; + p5->irow=t+p8->i*4-2; + p5->jcol=t+p8->i*4-2; + p5->z=-com->vary[j]*2*p8->a; + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + p8=p8->next; + } + + p8=com->head_vqd; //海森矩阵,无功负荷部分（等式约束里的）（潮流方程） + while(p8!=null) + { j=2*p8->i; + p5->irow=t+p8->i*4-2; + p5->jcol=t+p8->i*4-2; + p5->z=-com->vary[j]*2*p8->a; + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + p8=p8->next; + } + + free(p5); + + free(v); + free(rad); + + return; +} + +/******形成修正方程的-f2(部分)******/ +void Heisen_F2(opf_common *com,opf_correct *cor,opf_decomp *dec) +{ int i,j,t,n,m; + double x,r,bb; + + opf_yij *p1; + opf_gij *p2; + opf_matrix *p5; + opf_line *p7; + opf_sij *p10; + +// opf_matrix **h; + int mm,rr,rv,rlpij,rlqij,rlsij,rliij,rvpd,rvqd,rpg,rqg,rpd,rqd,rspij,rsqij,rgpcd,rk,rkb,rt,rx,rp,rq,rrr,rlcos,req,rvdcos,n_dc; + double *v,*rad; + int kk; + + mm=com->n_sum; + rr=com->rr; + rv=com->rv; + rlpij=com->rlpij; + rlqij=com->rlqij; + rlsij=com->rlsij; + rliij=com->rliij; + rvpd=com->rvpd; + rvqd=com->rvqd; + rliij=com->rliij; + rpg=com->rpg; + rqg=com->rqg; + rpd=com->rpd; + rqd=com->rqd; + rspij=com->rspij; + rsqij=com->rsqij; + rgpcd=com->rgpcd; + rk=com->rk; + rkb=com->rkb; + rt=com->rt; + rx=com->rx; + rp=com->rp; + rq=com->rq; + rrr=com->rrr; + rlcos=com->rlcos; + req=com->req; + rvdcos=com->rvdcos; + n_dc=com->n_dc; + + j=rr-rv+4*mm+req; +/* + h=(opf_matrix **)malloc((j+1)*sizeof(opf_matrix *)); + for(i=1;i<=j;i++) + h[i]=null;*/ + + v=(double *)malloc((mm+1)*sizeof(double)); //减少打字，看上去简洁些 + rad=(double *)malloc((mm+1)*sizeof(double)); + for(i=1;i<=com->n_sum;i++) + { v[i]=com->v[i]; + rad[i]=com->rad[i]; + } + + t=rr-rv; + p5=(opf_matrix *)malloc(lematrix); + switch(com->obj_type) //f的二阶偏导(-) + { + case 4: //支路有功损耗最小 + { p1=com->a[1]; //先是不含和的部分 + while(p1!=null) + { + p5->irow=t+4*p1->irow-3; + p5->jcol=t+4*p1->jcol-3; + p5->z=-v[p1->irow]*v[p1->jcol]*cos(rad[p1->irow]-rad[p1->jcol])*p1->amp*cos(p1->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=t+4*p1->irow-3; + p5->jcol=t+4*p1->jcol-2; + p5->z=v[p1->irow]*sin(rad[p1->irow]-rad[p1->jcol])*p1->amp*cos(p1->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=t+4*p1->irow-2; + p5->jcol=t+4*p1->jcol-3; + p5->z=-v[p1->jcol]*sin(rad[p1->irow]-rad[p1->jcol])*p1->amp*cos(p1->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=t+4*p1->irow-2; + p5->jcol=t+4*p1->jcol-2; + p5->z=-cos(rad[p1->irow]-rad[p1->jcol])*p1->amp*cos(p1->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p1=p1->next; + } + + for(i=1;i<=mm;i++) + { + p1=com->a[i]; + r=0; + x=0; + bb=0; + j=0; + if(p1!=null) + { while((p1->irow==i)&&(j==0)) + { r=r+v[p1->jcol]*cos(rad[p1->irow]-rad[p1->jcol])*p1->amp*cos(p1->rad); + x=x+v[p1->jcol]*sin(rad[p1->irow]-rad[p1->jcol])*p1->amp*cos(p1->rad); + bb=bb+p1->amp*cos(p1->rad); + if(p1->next==null) + j=1; + else + p1=p1->next; + } + } + p5->irow=t+4*i-3; + p5->jcol=t+4*i-3; + p5->z=v[i]*r; + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=t+4*i-3; + p5->jcol=t+4*i-2; + p5->z=x; + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=t+4*i-2; + p5->jcol=t+4*i-3; + p5->z=x; + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=t+4*i-2; + p5->jcol=t+4*i-2; + p5->z=bb; + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + } + + break; + } + case 5: //支路无功损耗最小 + { p1=com->a[1]; //先是不含和的部分 + while(p1!=null) + { + p5->irow=t+4*p1->irow-3; + p5->jcol=t+4*p1->jcol-3; + p5->z=v[p1->irow]*v[p1->jcol]*cos(rad[p1->irow]-rad[p1->jcol])*p1->amp*sin(p1->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=t+4*p1->irow-3; + p5->jcol=t+4*p1->jcol-2; + p5->z=-v[p1->irow]*sin(rad[p1->irow]-rad[p1->jcol])*p1->amp*sin(p1->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=t+4*p1->irow-2; + p5->jcol=t+4*p1->jcol-3; + p5->z=v[p1->jcol]*sin(rad[p1->irow]-rad[p1->jcol])*p1->amp*sin(p1->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=t+4*p1->irow-2; + p5->jcol=t+4*p1->jcol-2; + p5->z=cos(rad[p1->irow]-rad[p1->jcol])*p1->amp*sin(p1->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p1=p1->next; + } + + for(i=1;i<=mm;i++) + { + p1=com->a[i]; + r=0; + x=0; + bb=0; + j=0; + if(p1!=null) + { while((p1->irow==i)&&(j==0)) + { r=r+v[p1->jcol]*cos(rad[p1->irow]-rad[p1->jcol])*p1->amp*sin(p1->rad); + x=x+v[p1->jcol]*sin(rad[p1->irow]-rad[p1->jcol])*p1->amp*sin(p1->rad); + bb=bb+p1->amp*sin(p1->rad); + if(p1->next==null) + j=1; + else + p1=p1->next; + } + } + p5->irow=t+4*i-3; + p5->jcol=t+4*i-3; + p5->z=-v[i]*r; + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=t+4*i-3; + p5->jcol=t+4*i-2; + p5->z=-x; + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=t+4*i-2; + p5->jcol=t+4*i-3; + p5->z=-x; + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=t+4*i-2; + p5->jcol=t+4*i-2; + p5->z=-bb; + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + } + + break; + } + + case 6: //线路有功损耗最小(注意是负的) + { p7=com->head_lij; + while(p7!=null) + { + p5->irow=t+4*p7->i-3; //角度i+角度 + p5->jcol=t+4*p7->i-3; + p5->z=2*v[p7->i]*v[p7->j]*cos(rad[p7->i]-rad[p7->j])*p7->amp*cos(p7->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=t+4*p7->i-3; + p5->jcol=t+4*p7->j-3; + p5->z=-2*v[p7->i]*v[p7->j]*cos(rad[p7->i]-rad[p7->j])*p7->amp*cos(p7->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=t+4*p7->j-3; //角度j+角度 + p5->jcol=t+4*p7->j-3; + p5->z=2*v[p7->j]*v[p7->i]*cos(rad[p7->j]-rad[p7->i])*p7->amp*cos(p7->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=t+4*p7->j-3; + p5->jcol=t+4*p7->i-3; + p5->z=-2*v[p7->i]*v[p7->j]*cos(rad[p7->i]-rad[p7->j])*p7->amp*cos(p7->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=t+4*p7->i-3; //角度i+电压 + p5->jcol=t+4*p7->i-2; + p5->z=2*v[p7->j]*sin(rad[p7->i]-rad[p7->j])*p7->amp*cos(p7->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=t+4*p7->i-3; + p5->jcol=t+4*p7->j-2; + p5->z=2*v[p7->i]*sin(rad[p7->i]-rad[p7->j])*p7->amp*cos(p7->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=t+4*p7->j-3; //角度j+电压 + p5->jcol=t+4*p7->j-2; + p5->z=2*v[p7->i]*sin(rad[p7->j]-rad[p7->i])*p7->amp*cos(p7->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=t+4*p7->j-3; + p5->jcol=t+4*p7->i-2; + p5->z=2*v[p7->j]*sin(rad[p7->j]-rad[p7->i])*p7->amp*cos(p7->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=t+4*p7->i-2; //电压i+角度 + p5->jcol=t+4*p7->i-3; + p5->z=2*v[p7->j]*sin(rad[p7->i]-rad[p7->j])*p7->amp*cos(p7->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=t+4*p7->i-2; + p5->jcol=t+4*p7->j-3; + p5->z=-2*v[p7->j]*sin(rad[p7->i]-rad[p7->j])*p7->amp*cos(p7->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=t+4*p7->j-2; //电压j+角度 + p5->jcol=t+4*p7->j-3; + p5->z=2*v[p7->i]*sin(rad[p7->j]-rad[p7->i])*p7->amp*cos(p7->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=t+4*p7->i-2; + p5->jcol=t+4*p7->j-3; + p5->z=-2*v[p7->i]*sin(rad[p7->j]-rad[p7->i])*p7->amp*cos(p7->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=t+4*p7->i-2; //电压i+电压 + p5->jcol=t+4*p7->i-2; + p5->z=2*p7->amp*cos(p7->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=t+4*p7->i-2; + p5->jcol=t+4*p7->j-2; + p5->z=-2*cos(rad[p7->i]-rad[p7->j])*p7->amp*cos(p7->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=t+4*p7->j-2; //电压j+电压 + p5->jcol=t+4*p7->j-2; + p5->z=2*p7->amp*cos(p7->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=t+4*p7->j-2; + p5->jcol=t+4*p7->i-2; + p5->z=-2*cos(rad[p7->j]-rad[p7->i])*p7->amp*cos(p7->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p7=p7->next; + } + break; + } + + case 7: //线路无功损耗最小 + { p7=com->head_lij; + while(p7!=null) + { + p5->irow=t+4*p7->i-3; //角度i+角度 + p5->jcol=t+4*p7->i-3; + p5->z=-2*v[p7->i]*v[p7->j]*cos(rad[p7->i]-rad[p7->j])*p7->amp*sin(p7->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=t+4*p7->i-3; + p5->jcol=t+4*p7->j-3; + p5->z=2*v[p7->i]*v[p7->j]*cos(rad[p7->i]-rad[p7->j])*p7->amp*sin(p7->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=t+4*p7->j-3; //角度j+角度 + p5->jcol=t+4*p7->j-3; + p5->z=-2*v[p7->i]*v[p7->j]*cos(rad[p7->i]-rad[p7->j])*p7->amp*sin(p7->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=t+4*p7->j-3; + p5->jcol=t+4*p7->i-3; + p5->z=2*v[p7->i]*v[p7->j]*cos(rad[p7->i]-rad[p7->j])*p7->amp*sin(p7->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=t+4*p7->i-3; //角度i+电压 + p5->jcol=t+4*p7->i-2; + p5->z=-2*v[p7->j]*sin(rad[p7->i]-rad[p7->j])*p7->amp*sin(p7->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=t+4*p7->i-3; + p5->jcol=t+4*p7->j-2; + p5->z=-2*v[p7->i]*sin(rad[p7->i]-rad[p7->j])*p7->amp*sin(p7->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=t+4*p7->j-3; //角度j+电压 + p5->jcol=t+4*p7->j-2; + p5->z=-2*v[p7->i]*sin(rad[p7->j]-rad[p7->i])*p7->amp*sin(p7->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=t+4*p7->j-3; + p5->jcol=t+4*p7->i-2; + p5->z=-2*v[p7->j]*sin(rad[p7->j]-rad[p7->i])*p7->amp*sin(p7->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=t+4*p7->i-2; //电压i+角度 + p5->jcol=t+4*p7->i-3; + p5->z=-2*v[p7->j]*sin(rad[p7->i]-rad[p7->j])*p7->amp*sin(p7->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=t+4*p7->i-2; + p5->jcol=t+4*p7->j-3; + p5->z=2*v[p7->j]*sin(rad[p7->i]-rad[p7->j])*p7->amp*sin(p7->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=t+4*p7->j-2; //电压j+角度 + p5->jcol=t+4*p7->j-3; + p5->z=-2*v[p7->i]*sin(rad[p7->j]-rad[p7->i])*p7->amp*sin(p7->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=t+4*p7->i-2; + p5->jcol=t+4*p7->j-3; + p5->z=2*v[p7->i]*sin(rad[p7->j]-rad[p7->i])*p7->amp*sin(p7->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=t+4*p7->i-2; //电压i+电压 + p5->jcol=t+4*p7->i-2; + p5->z=-2*p7->amp*sin(p7->rad)+2*p7->bb; + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=t+4*p7->i-2; + p5->jcol=t+4*p7->j-2; + p5->z=2*cos(rad[p7->i]-rad[p7->j])*p7->amp*sin(p7->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=t+4*p7->j-2; //电压j+电压 + p5->jcol=t+4*p7->j-2; + p5->z=-2*p7->amp*sin(p7->rad)+2*p7->bb; + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=t+4*p7->j-2; + p5->jcol=t+4*p7->i-2; + p5->z=2*cos(rad[p7->j]-rad[p7->i])*p7->amp*sin(p7->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p7=p7->next; + } + break; + } + case 13: + { p2=com->head_spij; + j=rr-rv; + while(p2!=null) //加入f的二阶偏导,目标断面有功功率限制部分 + { p10=com->head_obsij; + while(p10!=null) + { if(p10->num==p2->i) //判断断面是否相同 + { t=p10->i; + m=p10->j; + +// p7=com->head_lij; + p1=com->a[p10->i]; + n=0; + while((p1!=null)&&(n==0)) + { if((p10->i==p1->irow)&&(p10->j==p1->jcol)) + n=1; + else + p1=p1->next; + } + + if(p1!=null) + { + p5->irow=j+4*t-3; //aiai + p5->jcol=j+4*t-3; + p5->z=-p10->w*(v[t]*v[m]*p1->amp*sin(rad[t]-rad[m]-p1->rad)); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=j+4*t-2; //Viai + p5->jcol=j+4*t-3; + p5->z=-p10->w*(-v[m]*p1->amp*cos(rad[t]-rad[m]-p1->rad)); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=j+4*m-3; //ajai + p5->jcol=j+4*t-3; + p5->z=-p10->w*(-v[t]*v[m]*p1->amp*sin(rad[t]-rad[m]-p1->rad)); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=j+4*m-2; //Vjai + p5->jcol=j+4*t-3; + p5->z=-p10->w*(-v[t]*p1->amp*cos(rad[t]-rad[m]-p1->rad)); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=j+4*t-3; //aiVi + p5->jcol=j+4*t-2; + p5->z=-p10->w*(-v[m]*p1->amp*cos(rad[t]-rad[m]-p1->rad)); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=j+4*t-2; //ViVi + p5->jcol=j+4*t-2; + p5->z=-p10->w*(-2*p1->amp*sin(p1->rad)); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=j+4*m-3; //ajVi + p5->jcol=j+4*t-2; + p5->z=-p10->w*(v[m]*p1->amp*cos(rad[t]-rad[m]-p1->rad)); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=j+4*m-2; //VjVi + p5->jcol=j+4*t-2; + p5->z=-p10->w*(-p1->amp*sin(rad[t]-rad[m]-p1->rad)); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=j+4*t-3; //aiaj + p5->jcol=j+4*m-3; + p5->z=-p10->w*(-v[t]*v[m]*p1->amp*sin(rad[t]-rad[m]-p1->rad)); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=j+4*t-2; //Viaj + p5->jcol=j+4*m-3; + p5->z=-p10->w*(v[m]*p1->amp*cos(rad[t]-rad[m]-p1->rad)); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=j+4*m-3; //ajaj + p5->jcol=j+4*m-3; + p5->z=-p10->w*(v[t]*v[m]*p1->amp*sin(rad[t]-rad[m]-p1->rad)); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=j+4*m-2; //Vjaj + p5->jcol=j+4*m-3; + p5->z=-p10->w*(v[t]*p1->amp*cos(rad[t]-rad[m]-p1->rad)); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=j+4*t-3; //aiVj + p5->jcol=j+4*m-2; + p5->z=-p10->w*(-v[t]*p1->amp*cos(rad[t]-rad[m]-p1->rad)); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=j+4*t-2; //ViVj + p5->jcol=j+4*m-2; + p5->z=-p10->w*(-p1->amp*sin(rad[t]-rad[m]-p1->rad)); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=j+4*m-3; //ajVj + p5->jcol=j+4*m-2; + p5->z=-p10->w*(-v[t]*p1->amp*cos(rad[t]-rad[m]-p1->rad)); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + } + } + p10=p10->next; + } + p2=p2->next; + } + break; + } + + default: + break; + } + + free(p5); + free(v); + free(rad); + + return; + +} + +/******形成修正方程的G2(Z+W)******/ +void Heisen_G2(opf_common *com,opf_correct *cor,opf_decomp *dec) +{ int i,j,t,n,m,tn,tm,n1; + double r,x,x1,r1; + + opf_yij *p1; + opf_gij *p2; + opf_matrix *p5; + opf_vpdqd *p8; + opf_gpcd *p9; + opf_sij *p10; + opf_dcbus *p12; + opf_kij *p3; + +// opf_matrix **h; + int mm,rr,rv,rlpij,rlqij,rlsij,rliij,rvpd,rvqd,rpg,rqg,rpd,rqd,rspij,rsqij,rgpcd,rk,rkb,rt,rx,rp,rq,rrr,rlcos,req,rvdcos,n_dc; + double *v,*rad; + int kk; + + mm=com->n_sum; + rr=com->rr; + rv=com->rv; + rlpij=com->rlpij; + rlqij=com->rlqij; + rlsij=com->rlsij; + rliij=com->rliij; + rvpd=com->rvpd; + rvqd=com->rvqd; + rliij=com->rliij; + rpg=com->rpg; + rqg=com->rqg; + rpd=com->rpd; + rqd=com->rqd; + rspij=com->rspij; + rsqij=com->rsqij; + rgpcd=com->rgpcd; + rk=com->rk; + rkb=com->rkb; + rt=com->rt; + rx=com->rx; + rp=com->rp; + rq=com->rq; + rrr=com->rrr; + rlcos=com->rlcos; + req=com->req; + rvdcos=com->rvdcos; + n_dc=com->n_dc; + + j=rr-rv+4*mm+req; +/* + h=(opf_matrix **)malloc((j+1)*sizeof(opf_matrix *)); + for(i=1;i<=j;i++) + h[i]=null;*/ + + v=(double *)malloc((mm+1)*sizeof(double)); //减少打字，看上去简洁些 + rad=(double *)malloc((mm+1)*sizeof(double)); + for(i=1;i<=com->n_sum;i++) + { v[i]=com->v[i]; + rad[i]=com->rad[i]; + } + + p5=(opf_matrix *)malloc(lematrix); + + p2=com->head_lpij; + i=rr+1; + j=rr-rv; + while(p2!=null) //加入g的二阶偏导,支路有功功率限制部分 + { t=p2->i; + m=p2->j; + +// p7=com->head_lij; + p1=com->a[p2->i]; + n=0; + while((p1!=null)&&(n==0)) + { if((p2->i==p1->irow)&&(p2->j==p1->jcol)) + n=1; + else + p1=p1->next; + } + + r=com->varz[i]+com->varw[i]; + + if(p1!=null) + { + p5->irow=j+4*t-3; //a&i + p5->jcol=j+4*t-3; //a&i + p5->z=r*v[t]*v[m]*p1->amp*cos(rad[t]-rad[m]-p1->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + // hasin[j+4*t-2][j+4*t-3]+=-r*v[m]*p1->amp*sin(rad[t]-rad[m]-p1->rad); + p5->irow=j+4*t-2; //aVi + p5->jcol=j+4*t-3; //a&i + p5->z=r*v[m]*p1->amp*sin(rad[t]-rad[m]-p1->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + // hasin[j+4*m-3][j+4*t-3]+=r*v[t]*v[m]*p1->amp*cos(rad[t]-rad[m]-p1->rad); + p5->irow=j+4*m-3; //a&j + p5->jcol=j+4*t-3; //a&i + p5->z=-r*v[t]*v[m]*p1->amp*cos(rad[t]-rad[m]-p1->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + // hasin[j+4*m-2][j+4*t-3]+=-r*v[t]*p1->amp*sin(rad[t]-rad[m]-p1->rad); + p5->irow=j+4*m-2; //aVj + p5->jcol=j+4*t-3; //a&i + p5->z=r*v[t]*p1->amp*sin(rad[t]-rad[m]-p1->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + // hasin[j+4*t-3][j+4*t-2]+=-r*v[m]*p1->amp*sin(rad[t]-rad[m]-p1->rad); + p5->irow=j+4*t-3; //a&i + p5->jcol=j+4*t-2; //aVi + p5->z=r*v[m]*p1->amp*sin(rad[t]-rad[m]-p1->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + // hasin[j+4*t-2][j+4*t-2]+=-r*2*p1->amp*sin(rad[t]-rad[m]-p1->rad); + p5->irow=j+4*t-2; //aVi + p5->jcol=j+4*t-2; //aVi + p5->z=r*2*p1->amp*cos(p1->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + // hasin[j+4*m-3][j+4*t-2]+=r*v[m]*p1->amp*sin(rad[t]-rad[m]-p1->rad); + p5->irow=j+4*m-3; //a&j + p5->jcol=j+4*t-2; //aVi + p5->z=-r*v[m]*p1->amp*sin(rad[t]-rad[m]-p1->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + // hasin[j+4*m-2][j+4*t-2]+=r*p1->amp*cos(rad[t]-rad[m]-p1->rad); + p5->irow=j+4*m-2; //aVj + p5->jcol=j+4*t-2; //aVi + p5->z=-r*p1->amp*cos(rad[t]-rad[m]-p1->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + // hasin[j+4*t-3][j+4*m-3]+=r*v[t]*v[m]*p1->amp*cos(rad[t]-rad[m]-p1->rad); + p5->irow=j+4*t-3; //a&i + p5->jcol=j+4*m-3; //a&j + p5->z=-r*v[t]*v[m]*p1->amp*cos(rad[t]-rad[m]-p1->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + // hasin[j+4*t-2][j+4*m-3]+=r*v[m]*p1->amp*sin(rad[t]-rad[m]-p1->rad); + p5->irow=j+4*t-2; //aVi + p5->jcol=j+4*m-3; //a&j + p5->z=-r*v[m]*p1->amp*sin(rad[t]-rad[m]-p1->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + // hasin[j+4*m-3][j+4*m-3]+=-r*v[t]*v[m]*p1->amp*cos(rad[t]-rad[m]-p1->rad); + p5->irow=j+4*m-3; //a&j + p5->jcol=j+4*m-3; //a&j + p5->z=r*v[t]*v[m]*p1->amp*cos(rad[t]-rad[m]-p1->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + // hasin[j+4*m-2][j+4*m-3]+=r*v[t]*p1->amp*sin(rad[t]-rad[m]-p1->rad); + p5->irow=j+4*m-2; //aVj + p5->jcol=j+4*m-3; //a&j + p5->z=-r*v[t]*p1->amp*sin(rad[t]-rad[m]-p1->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + // hasin[j+4*t-3][j+4*m-2]+=-r*v[t]*p1->amp*sin(rad[t]-rad[m]-p1->rad); + p5->irow=j+4*t-3; //a&i + p5->jcol=j+4*m-2; //aVj + p5->z=r*v[t]*p1->amp*sin(rad[t]-rad[m]-p1->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + // hasin[j+4*t-2][j+4*m-2]+=r*p1->amp*cos(rad[t]-rad[m]-p1->rad); + p5->irow=j+4*t-2; //aVi + p5->jcol=j+4*m-2; //aVj + p5->z=-r*p1->amp*cos(rad[t]-rad[m]-p1->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + // hasin[j+4*m-3][j+4*m-2]+=r*v[t]*p1->amp*sin(rad[t]-rad[m]-p1->rad); + p5->irow=j+4*m-3; //a&j + p5->jcol=j+4*m-2; //aVj + p5->z=-r*v[t]*p1->amp*sin(rad[t]-rad[m]-p1->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + } + i=i+1; + p2=p2->next; + } + + p2=com->head_lqij; + i=rr+rlpij+1; + j=rr-rv; + while(p2!=null) //加入g的二阶偏导,支路无功功率限制部分 + { t=p2->i; + m=p2->j; + +// p7=com->head_lij; + p1=com->a[p2->i]; + n=0; + while((p1!=null)&&(n==0)) + { if((p2->i==p1->irow)&&(p2->j==p1->jcol)) + n=1; + else + p1=p1->next; + } + + r=com->varz[i]+com->varw[i]; + + if(p1!=null) + { + n1=0; + p3=com->head_kij; + while((p3!=null)&&(n1==0)) + { if((p3->i==p2->i)&&(p3->j==p2->j)) + n1=1; + else + p3=p3->next; + } + + if(p3!=null) + { + x=rad[t]-rad[m]-(p1->rad-3.1415926); + + p5->irow=j+4*t-3; //aiai + p5->jcol=j+4*t-3; + p5->z=r*v[t]*v[m]*p1->amp*sin(x); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=j+4*t-2; //Viai + p5->jcol=j+4*t-3; + p5->z=-r*v[m]*p1->amp*cos(x); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=j+4*m-3; //ajai + p5->jcol=j+4*t-3; + p5->z=-r*v[t]*v[m]*p1->amp*sin(x); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=j+4*m-2; //Vjai + p5->jcol=j+4*t-3; + p5->z=-r*v[t]*p1->amp*cos(x); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=j+4*t-3; //aiVi + p5->jcol=j+4*t-2; + p5->z=-r*v[m]*p1->amp*cos(x); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=j+4*t-2; //ViVi + p5->jcol=j+4*t-2; + p5->z=-r*2*p3->k*p1->amp*sin(p1->rad-3.1415926); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=j+4*m-3; //ajVi + p5->jcol=j+4*t-2; + p5->z=r*v[m]*p1->amp*cos(x); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=j+4*m-2; //VjVi + p5->jcol=j+4*t-2; + p5->z=-r*p1->amp*sin(x); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=j+4*t-3; //aiaj + p5->jcol=j+4*m-3; + p5->z=-r*v[t]*v[m]*p1->amp*sin(x); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=j+4*t-2; //Viaj + p5->jcol=j+4*m-3; + p5->z=r*v[m]*p1->amp*cos(x); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=j+4*m-3; //ajaj + p5->jcol=j+4*m-3; + p5->z=r*v[t]*v[m]*p1->amp*sin(x); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=j+4*m-2; //Vjaj + p5->jcol=j+4*m-3; + p5->z=r*v[t]*p1->amp*cos(x); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=j+4*t-3; //aiVj + p5->jcol=j+4*m-2; + p5->z=-r*v[t]*p1->amp*cos(x); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=j+4*t-2; //ViVj + p5->jcol=j+4*m-2; + p5->z=-r*p1->amp*sin(x); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=j+4*m-3; //ajVj + p5->jcol=j+4*m-2; + p5->z=-r*v[t]*p1->amp*cos(x); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + } + +/* + p5->irow=j+4*t-3; //aiai + p5->jcol=j+4*t-3; + p5->z=r*v[t]*v[m]*p1->amp*sin(rad[t]-rad[m]-p1->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=j+4*t-2; //Viai + p5->jcol=j+4*t-3; + p5->z=-r*v[m]*p1->amp*cos(rad[t]-rad[m]-p1->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=j+4*m-3; //ajai + p5->jcol=j+4*t-3; + p5->z=-r*v[t]*v[m]*p1->amp*sin(rad[t]-rad[m]-p1->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=j+4*m-2; //Vjai + p5->jcol=j+4*t-3; + p5->z=-r*v[t]*p1->amp*cos(rad[t]-rad[m]-p1->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=j+4*t-3; //aiVi + p5->jcol=j+4*t-2; + p5->z=-r*v[m]*p1->amp*cos(rad[t]-rad[m]-p1->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=j+4*t-2; //ViVi + p5->jcol=j+4*t-2; + p5->z=-r*2*p1->amp*sin(p1->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=j+4*m-3; //ajVi + p5->jcol=j+4*t-2; + p5->z=r*v[m]*p1->amp*cos(rad[t]-rad[m]-p1->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=j+4*m-2; //VjVi + p5->jcol=j+4*t-2; + p5->z=-r*p1->amp*sin(rad[t]-rad[m]-p1->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=j+4*t-3; //aiaj + p5->jcol=j+4*m-3; + p5->z=-r*v[t]*v[m]*p1->amp*sin(rad[t]-rad[m]-p1->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=j+4*t-2; //Viaj + p5->jcol=j+4*m-3; + p5->z=r*v[m]*p1->amp*cos(rad[t]-rad[m]-p1->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=j+4*m-3; //ajaj + p5->jcol=j+4*m-3; + p5->z=r*v[t]*v[m]*p1->amp*sin(rad[t]-rad[m]-p1->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=j+4*m-2; //Vjaj + p5->jcol=j+4*m-3; + p5->z=r*v[t]*p1->amp*cos(rad[t]-rad[m]-p1->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=j+4*t-3; //aiVj + p5->jcol=j+4*m-2; + p5->z=-r*v[t]*p1->amp*cos(rad[t]-rad[m]-p1->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=j+4*t-2; //ViVj + p5->jcol=j+4*m-2; + p5->z=-r*p1->amp*sin(rad[t]-rad[m]-p1->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=j+4*m-3; //ajVj + p5->jcol=j+4*m-2; + p5->z=-r*v[t]*p1->amp*cos(rad[t]-rad[m]-p1->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix);*/ + + } + i=i+1; + p2=p2->next; + } + + p2=com->head_lsij; + i=rr+rlpij+rlqij+1; + j=rr-rv; + while(p2!=null) //加入g的二阶偏导,支路容量限制部分 + { t=p2->i; + m=p2->j; + +// p7=com->head_lij; + p1=com->a[p2->i]; + n=0; + while((p1!=null)&&(n==0)) + { if((p2->i==p1->irow)&&(p2->j==p1->jcol)) + n=1; + else + p1=p1->next; + } + + r=com->varz[i]+com->varw[i]; + + if(p1!=null) + { + // hasin[j+4*t-3][j+4*t-3]+=-r*v[t]*v[m]*p1->amp*cos(rad[t]-rad[m]-p1->rad); + p5->irow=j+4*t-3; //aiai + p5->jcol=j+4*t-3; + p5->z=r*2*pow(v[t],3)*v[m]*pow(p1->amp,2)*cos(rad[t]-rad[m]); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + // hasin[j+4*t-2][j+4*t-3]+=-r*v[m]*p1->amp*sin(rad[t]-rad[m]-p1->rad); + p5->irow=j+4*t-2; //Viai + p5->jcol=j+4*t-3; + p5->z=r*6*pow(v[t],2)*v[m]*pow(p1->amp,2)*sin(rad[t]-rad[m]); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + // hasin[j+4*m-3][j+4*t-3]+=r*v[t]*v[m]*p1->amp*cos(rad[t]-rad[m]-p1->rad); + p5->irow=j+4*m-3; //ajai + p5->jcol=j+4*t-3; + p5->z=-r*2*pow(v[t],3)*v[m]*pow(p1->amp,2)*cos(rad[t]-rad[m]); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + // hasin[j+4*m-2][j+4*t-3]+=-r*v[t]*p1->amp*sin(rad[t]-rad[m]-p1->rad); + p5->irow=j+4*m-2; //Vjai + p5->jcol=j+4*t-3; + p5->z=r*2*pow(v[t],3)*pow(p1->amp,2)*sin(rad[t]-rad[m]); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + // hasin[j+4*t-3][j+4*t-2]+=-r*v[m]*p1->amp*sin(rad[t]-rad[m]-p1->rad); + p5->irow=j+4*t-3; //aiVi + p5->jcol=j+4*t-2; + p5->z=r*6*pow(v[t],2)*v[m]*pow(p1->amp,2)*sin(rad[t]-rad[m]); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + // hasin[j+4*t-2][j+4*t-2]+=-r*2*p1->amp*sin(rad[t]-rad[m]-p1->rad); + p5->irow=j+4*t-2; //ViVi + p5->jcol=j+4*t-2; + p5->z=r*(12*pow(v[t],2)*pow(p1->amp,2)+2*pow(v[m],2)*pow(p1->amp,2)-12*v[t]*pow(p1->amp,2)*v[m]*cos(rad[t]-rad[m])); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + // hasin[j+4*m-3][j+4*t-2]+=r*v[m]*p1->amp*sin(rad[t]-rad[m]-p1->rad); + p5->irow=j+4*m-3; //ajVi + p5->jcol=j+4*t-2; + p5->z=-r*6*pow(v[t],2)*v[m]*pow(p1->amp,2)*sin(rad[t]-rad[m]); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + // hasin[j+4*m-2][j+4*t-2]+=r*p1->amp*cos(rad[t]-rad[m]-p1->rad); + p5->irow=j+4*m-2; //VjVi + p5->jcol=j+4*t-2; + p5->z=r*(4*v[t]*pow(p1->amp,2)*v[m]-6*pow(v[t],2)*pow(p1->amp,2)*cos(rad[t]-rad[m])); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + // hasin[j+4*t-3][j+4*m-3]+=r*v[t]*v[m]*p1->amp*cos(rad[t]-rad[m]-p1->rad); + p5->irow=j+4*t-3; //aiaj + p5->jcol=j+4*m-3; + p5->z=-r*2*pow(v[t],3)*v[m]*pow(p1->amp,2)*cos(rad[t]-rad[m]); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + // hasin[j+4*t-2][j+4*m-3]+=r*v[m]*p1->amp*sin(rad[t]-rad[m]-p1->rad); + p5->irow=j+4*t-2; //Viaj + p5->jcol=j+4*m-3; + p5->z=-r*6*pow(v[t],2)*v[m]*pow(p1->amp,2)*sin(rad[t]-rad[m]); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + // hasin[j+4*m-3][j+4*m-3]+=-r*v[t]*v[m]*p1->amp*cos(rad[t]-rad[m]-p1->rad); + p5->irow=j+4*m-3; //ajaj + p5->jcol=j+4*m-3; + p5->z=r*2*pow(v[t],3)*v[m]*pow(p1->amp,2)*cos(rad[t]-rad[m]); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + // hasin[j+4*m-2][j+4*m-3]+=r*v[t]*p1->amp*sin(rad[t]-rad[m]-p1->rad); + p5->irow=j+4*m-2; //Vjaj + p5->jcol=j+4*m-3; + p5->z=-r*2*pow(v[t],3)*pow(p1->amp,2)*sin(rad[t]-rad[m]); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + // hasin[j+4*t-3][j+4*m-2]+=-r*v[t]*p1->amp*sin(rad[t]-rad[m]-p1->rad); + p5->irow=j+4*t-3; //aiVj + p5->jcol=j+4*m-2; + p5->z=r*2*pow(v[t],3)*pow(p1->amp,2)*sin(rad[t]-rad[m]); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + // hasin[j+4*t-2][j+4*m-2]+=r*p1->amp*cos(rad[t]-rad[m]-p1->rad); + p5->irow=j+4*t-2; //ViVj + p5->jcol=j+4*m-2; + p5->z=r*(4*v[t]*pow(p1->amp,2)*v[m]-6*pow(v[t],2)*pow(p1->amp,2)*cos(rad[t]-rad[m])); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + // hasin[j+4*m-3][j+4*m-2]+=r*v[t]*p1->amp*sin(rad[t]-rad[m]-p1->rad); + p5->irow=j+4*m-3; //ajVj + p5->jcol=j+4*m-2; + p5->z=-r*2*pow(v[t],3)*pow(p1->amp,2)*sin(rad[t]-rad[m]); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=j+4*m-2; //VjVj + p5->jcol=j+4*m-2; + p5->z=r*2*pow(v[t],2)*pow(p1->amp,2); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + } + i=i+1; + p2=p2->next; + } + + p2=com->head_liij; + i=rr+rlpij+rlqij+rlsij+1; + j=rr-rv; + while(p2!=null) //加入g的二阶偏导,支路电流限制部分 + { t=p2->i; + m=p2->j; + +// p7=com->head_lij; + p1=com->a[p2->i]; + n=0; + while((p1!=null)&&(n==0)) + { if((p2->i==p1->irow)&&(p2->j==p1->jcol)) + n=1; + else + p1=p1->next; + } + + r=com->varz[i]+com->varw[i]; + + if(p1!=null) + { + // hasin[j+4*t-3][j+4*t-3]+=-r*v[t]*v[m]*p1->amp*cos(rad[t]-rad[m]-p1->rad); + p5->irow=j+4*t-3; //aiai + p5->jcol=j+4*t-3; + p5->z=r*2*v[t]*pow(p1->amp,2)*v[m]*cos(rad[t]-rad[m]); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + // hasin[j+4*t-2][j+4*t-3]+=-r*v[m]*p1->amp*sin(rad[t]-rad[m]-p1->rad); + p5->irow=j+4*t-2; //Viai + p5->jcol=j+4*t-3; + p5->z=r*2*pow(p1->amp,2)*v[m]*sin(rad[t]-rad[m]); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + // hasin[j+4*m-3][j+4*t-3]+=r*v[t]*v[m]*p1->amp*cos(rad[t]-rad[m]-p1->rad); + p5->irow=j+4*m-3; //ajai + p5->jcol=j+4*t-3; + p5->z=-r*2*v[t]*pow(p1->amp,2)*v[m]*cos(rad[t]-rad[m]); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + // hasin[j+4*m-2][j+4*t-3]+=-r*v[t]*p1->amp*sin(rad[t]-rad[m]-p1->rad); + p5->irow=j+4*m-2; //Vjai + p5->jcol=j+4*t-3; + p5->z=r*2*v[t]*pow(p1->amp,2)*sin(rad[t]-rad[m]); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + // hasin[j+4*t-3][j+4*t-2]+=-r*v[m]*p1->amp*sin(rad[t]-rad[m]-p1->rad); + p5->irow=j+4*t-3; //aiVi + p5->jcol=j+4*t-2; + p5->z=r*2*pow(p1->amp,2)*v[m]*sin(rad[t]-rad[m]); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + // hasin[j+4*t-2][j+4*t-2]+=-r*2*p1->amp*sin(rad[t]-rad[m]-p1->rad); + p5->irow=j+4*t-2; //ViVi + p5->jcol=j+4*t-2; + p5->z=r*2*pow(p1->amp,2); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + // hasin[j+4*m-3][j+4*t-2]+=r*v[m]*p1->amp*sin(rad[t]-rad[m]-p1->rad); + p5->irow=j+4*m-3; //ajVi + p5->jcol=j+4*t-2; + p5->z=-r*2*pow(p1->amp,2)*v[m]*sin(rad[t]-rad[m]); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + // hasin[j+4*m-2][j+4*t-2]+=r*p1->amp*cos(rad[t]-rad[m]-p1->rad); + p5->irow=j+4*m-2; //VjVi + p5->jcol=j+4*t-2; + p5->z=-r*2*pow(p1->amp,2)*cos(rad[t]-rad[m]); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + // hasin[j+4*t-3][j+4*m-3]+=r*v[t]*v[m]*p1->amp*cos(rad[t]-rad[m]-p1->rad); + p5->irow=j+4*t-3; //aiaj + p5->jcol=j+4*m-3; + p5->z=-r*2*v[t]*pow(p1->amp,2)*v[m]*cos(rad[t]-rad[m]); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + // hasin[j+4*t-2][j+4*m-3]+=r*v[m]*p1->amp*sin(rad[t]-rad[m]-p1->rad); + p5->irow=j+4*t-2; //Viaj + p5->jcol=j+4*m-3; + p5->z=-r*2*pow(p1->amp,2)*v[m]*sin(rad[t]-rad[m]); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + // hasin[j+4*m-3][j+4*m-3]+=-r*v[t]*v[m]*p1->amp*cos(rad[t]-rad[m]-p1->rad); + p5->irow=j+4*m-3; //ajaj + p5->jcol=j+4*m-3; + p5->z=r*2*v[t]*pow(p1->amp,2)*v[m]*cos(rad[t]-rad[m]); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + // hasin[j+4*m-2][j+4*m-3]+=r*v[t]*p1->amp*sin(rad[t]-rad[m]-p1->rad); + p5->irow=j+4*m-2; //Vjaj + p5->jcol=j+4*m-3; + p5->z=-r*2*v[t]*pow(p1->amp,2)*sin(rad[t]-rad[m]); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + // hasin[j+4*t-3][j+4*m-2]+=-r*v[t]*p1->amp*sin(rad[t]-rad[m]-p1->rad); + p5->irow=j+4*t-3; //aiVj + p5->jcol=j+4*m-2; + p5->z=r*2*v[t]*pow(p1->amp,2)*sin(rad[t]-rad[m]); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + // hasin[j+4*t-2][j+4*m-2]+=r*p1->amp*cos(rad[t]-rad[m]-p1->rad); + p5->irow=j+4*t-2; //ViVj + p5->jcol=j+4*m-2; + p5->z=-r*2*pow(p1->amp,2)*cos(rad[t]-rad[m]); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + // hasin[j+4*m-3][j+4*m-2]+=r*v[t]*p1->amp*sin(rad[t]-rad[m]-p1->rad); + p5->irow=j+4*m-3; //ajVj + p5->jcol=j+4*m-2; + p5->z=-r*2*v[t]*pow(p1->amp,2)*sin(rad[t]-rad[m]); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=j+4*m-2; //VjVj + p5->jcol=j+4*m-2; + p5->z=r*2*pow(p1->amp,2); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + } + i=i+1; + p2=p2->next; + } + + p8=com->head_vpd; + i=rr+rlpij+rlqij+rlsij+rliij+1; + j=rr-rv; + while(p8!=null) //加入g的二阶偏导,负荷模型功率限制部分 + { t=p8->i; + r=com->varz[i]+com->varw[i]; + + p5->irow=j+p8->i*4-2; + p5->jcol=j+p8->i*4-2; + p5->z=r*2*p8->a; + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + i=i+1; + p8=p8->next; + } + + p8=com->head_vqd; + i=rr+rlpij+rlqij+rlsij+rliij+rvpd+1; + j=rr-rv; + while(p8!=null) //加入g的二阶偏导,负荷模型功率限制部分 + { t=p8->i; + r=com->varz[i]+com->varw[i]; + + p5->irow=j+p8->i*4-2; + p5->jcol=j+p8->i*4-2; + p5->z=r*2*p8->a; + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + i=i+1; + p8=p8->next; + } + + + p2=com->head_spij; + i=rr+rlpij+rlqij+rlsij+rliij+rvpd+rvqd+1; + j=rr-rv; + while(p2!=null) //加入g的二阶偏导,断面有功功率限制部分 + { p10=com->head_sij; + while(p10!=null) + { if(p10->num==p2->i) //判断断面是否相同 + { t=p10->i; + m=p10->j; + +// p7=com->head_lij; + p1=com->a[p2->i]; + n=0; + while((p1!=null)&&(n==0)) + { if((p10->i==p1->irow)&&(p10->j==p1->jcol)) + n=1; + else + p1=p1->next; + } + + r=com->varz[i]+com->varw[i]; + + if(p1!=null) + { + p5->irow=j+4*t-3; + p5->jcol=j+4*t-3; + p5->z=r*v[t]*v[m]*p1->amp*cos(rad[t]-rad[m]-p1->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + // hasin[j+4*t-2][j+4*t-3]+=-r*v[m]*p1->amp*sin(rad[t]-rad[m]-p1->rad); + p5->irow=j+4*t-2; + p5->jcol=j+4*t-3; + p5->z=r*v[m]*p1->amp*sin(rad[t]-rad[m]-p1->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + // hasin[j+4*m-3][j+4*t-3]+=r*v[t]*v[m]*p1->amp*cos(rad[t]-rad[m]-p1->rad); + p5->irow=j+4*m-3; + p5->jcol=j+4*t-3; + p5->z=-r*v[t]*v[m]*p1->amp*cos(rad[t]-rad[m]-p1->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + // hasin[j+4*m-2][j+4*t-3]+=-r*v[t]*p1->amp*sin(rad[t]-rad[m]-p1->rad); + p5->irow=j+4*m-2; + p5->jcol=j+4*t-3; + p5->z=r*v[t]*p1->amp*sin(rad[t]-rad[m]-p1->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + // hasin[j+4*t-3][j+4*t-2]+=-r*v[m]*p1->amp*sin(rad[t]-rad[m]-p1->rad); + p5->irow=j+4*t-3; + p5->jcol=j+4*t-2; + p5->z=r*v[m]*p1->amp*sin(rad[t]-rad[m]-p1->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + // hasin[j+4*t-2][j+4*t-2]+=-r*2*p1->amp*sin(rad[t]-rad[m]-p1->rad); + p5->irow=j+4*t-2; + p5->jcol=j+4*t-2; + p5->z=r*2*p1->amp*cos(p1->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + // hasin[j+4*m-3][j+4*t-2]+=r*v[m]*p1->amp*sin(rad[t]-rad[m]-p1->rad); + p5->irow=j+4*m-3; + p5->jcol=j+4*t-2; + p5->z=-r*v[m]*p1->amp*sin(rad[t]-rad[m]-p1->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + // hasin[j+4*m-2][j+4*t-2]+=r*p1->amp*cos(rad[t]-rad[m]-p1->rad); + p5->irow=j+4*m-2; + p5->jcol=j+4*t-2; + p5->z=-r*p1->amp*cos(rad[t]-rad[m]-p1->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + // hasin[j+4*t-3][j+4*m-3]+=r*v[t]*v[m]*p1->amp*cos(rad[t]-rad[m]-p1->rad); + p5->irow=j+4*t-3; + p5->jcol=j+4*m-3; + p5->z=-r*v[t]*v[m]*p1->amp*cos(rad[t]-rad[m]-p1->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + // hasin[j+4*t-2][j+4*m-3]+=r*v[m]*p1->amp*sin(rad[t]-rad[m]-p1->rad); + p5->irow=j+4*t-2; + p5->jcol=j+4*m-3; + p5->z=-r*v[m]*p1->amp*sin(rad[t]-rad[m]-p1->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + // hasin[j+4*m-3][j+4*m-3]+=-r*v[t]*v[m]*p1->amp*cos(rad[t]-rad[m]-p1->rad); + p5->irow=j+4*m-3; + p5->jcol=j+4*m-3; + p5->z=r*v[t]*v[m]*p1->amp*cos(rad[t]-rad[m]-p1->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + // hasin[j+4*m-2][j+4*m-3]+=r*v[t]*p1->amp*sin(rad[t]-rad[m]-p1->rad); + p5->irow=j+4*m-2; + p5->jcol=j+4*m-3; + p5->z=-r*v[t]*p1->amp*sin(rad[t]-rad[m]-p1->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + // hasin[j+4*t-3][j+4*m-2]+=-r*v[t]*p1->amp*sin(rad[t]-rad[m]-p1->rad); + p5->irow=j+4*t-3; + p5->jcol=j+4*m-2; + p5->z=r*v[t]*p1->amp*sin(rad[t]-rad[m]-p1->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + // hasin[j+4*t-2][j+4*m-2]+=r*p1->amp*cos(rad[t]-rad[m]-p1->rad); + p5->irow=j+4*t-2; + p5->jcol=j+4*m-2; + p5->z=-r*p1->amp*cos(rad[t]-rad[m]-p1->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + // hasin[j+4*m-3][j+4*m-2]+=r*v[t]*p1->amp*sin(rad[t]-rad[m]-p1->rad); + p5->irow=j+4*m-3; + p5->jcol=j+4*m-2; + p5->z=-r*v[t]*p1->amp*sin(rad[t]-rad[m]-p1->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + } + } + p10=p10->next; + } + i=i+1; + p2=p2->next; + } + + p2=com->head_sqij; + i=rr+rlpij+rlqij+rlsij+rliij+rvpd+rvqd+rspij+1; + j=rr-rv; + while(p2!=null) //加入g的二阶偏导,断面无功功率限制部分 + { p10=com->head_sij; + while(p10!=null) + { if(p10->num==p2->i) //判断断面是否相同 + { t=p10->i; + m=p10->j; + +// p7=com->head_lij; + p1=com->a[p2->i]; + n=0; + while((p1!=null)&&(n==0)) + { if((p10->i==p1->irow)&&(p10->j==p1->jcol)) + n=1; + else + p1=p1->next; + } + + r=com->varz[i]+com->varw[i]; + + if(p1!=null) + { + // hasin[j+4*t-3][j+4*t-3]+=-r*v[t]*v[m]*p1->amp*cos(rad[t]-rad[m]-p1->rad); + p5->irow=j+4*t-3; //aiai + p5->jcol=j+4*t-3; + p5->z=r*v[t]*v[m]*p1->amp*sin(rad[t]-rad[m]-p1->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + // hasin[j+4*t-2][j+4*t-3]+=-r*v[m]*p1->amp*sin(rad[t]-rad[m]-p1->rad); + p5->irow=j+4*t-2; //Viai + p5->jcol=j+4*t-3; + p5->z=-r*v[m]*p1->amp*cos(rad[t]-rad[m]-p1->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + // hasin[j+4*m-3][j+4*t-3]+=r*v[t]*v[m]*p1->amp*cos(rad[t]-rad[m]-p1->rad); + p5->irow=j+4*m-3; //ajai + p5->jcol=j+4*t-3; + p5->z=-r*v[t]*v[m]*p1->amp*sin(rad[t]-rad[m]-p1->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + // hasin[j+4*m-2][j+4*t-3]+=-r*v[t]*p1->amp*sin(rad[t]-rad[m]-p1->rad); + p5->irow=j+4*m-2; //Vjai + p5->jcol=j+4*t-3; + p5->z=-r*v[t]*p1->amp*cos(rad[t]-rad[m]-p1->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + // hasin[j+4*t-3][j+4*t-2]+=-r*v[m]*p1->amp*sin(rad[t]-rad[m]-p1->rad); + p5->irow=j+4*t-3; //aiVi + p5->jcol=j+4*t-2; + p5->z=-r*v[m]*p1->amp*cos(rad[t]-rad[m]-p1->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + // hasin[j+4*t-2][j+4*t-2]+=-r*2*p1->amp*sin(rad[t]-rad[m]-p1->rad); + p5->irow=j+4*t-2; //ViVi + p5->jcol=j+4*t-2; + p5->z=-r*2*p1->amp*sin(p1->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + // hasin[j+4*m-3][j+4*t-2]+=r*v[m]*p1->amp*sin(rad[t]-rad[m]-p1->rad); + p5->irow=j+4*m-3; //ajVi + p5->jcol=j+4*t-2; + p5->z=r*v[m]*p1->amp*cos(rad[t]-rad[m]-p1->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + // hasin[j+4*m-2][j+4*t-2]+=r*p1->amp*cos(rad[t]-rad[m]-p1->rad); + p5->irow=j+4*m-2; //VjVi + p5->jcol=j+4*t-2; + p5->z=-r*p1->amp*sin(rad[t]-rad[m]-p1->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + // hasin[j+4*t-3][j+4*m-3]+=r*v[t]*v[m]*p1->amp*cos(rad[t]-rad[m]-p1->rad); + p5->irow=j+4*t-3; //aiaj + p5->jcol=j+4*m-3; + p5->z=-r*v[t]*v[m]*p1->amp*sin(rad[t]-rad[m]-p1->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + // hasin[j+4*t-2][j+4*m-3]+=r*v[m]*p1->amp*sin(rad[t]-rad[m]-p1->rad); + p5->irow=j+4*t-2; //Viaj + p5->jcol=j+4*m-3; + p5->z=r*v[m]*p1->amp*cos(rad[t]-rad[m]-p1->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + // hasin[j+4*m-3][j+4*m-3]+=-r*v[t]*v[m]*p1->amp*cos(rad[t]-rad[m]-p1->rad); + p5->irow=j+4*m-3; //ajaj + p5->jcol=j+4*m-3; + p5->z=r*v[t]*v[m]*p1->amp*sin(rad[t]-rad[m]-p1->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + // hasin[j+4*m-2][j+4*m-3]+=r*v[t]*p1->amp*sin(rad[t]-rad[m]-p1->rad); + p5->irow=j+4*m-2; //Vjaj + p5->jcol=j+4*m-3; + p5->z=r*v[t]*p1->amp*cos(rad[t]-rad[m]-p1->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + // hasin[j+4*t-3][j+4*m-2]+=-r*v[t]*p1->amp*sin(rad[t]-rad[m]-p1->rad); + p5->irow=j+4*t-3; //aiVj + p5->jcol=j+4*m-2; + p5->z=-r*v[t]*p1->amp*cos(rad[t]-rad[m]-p1->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + // hasin[j+4*t-2][j+4*m-2]+=r*p1->amp*cos(rad[t]-rad[m]-p1->rad); + p5->irow=j+4*t-2; //ViVj + p5->jcol=j+4*m-2; + p5->z=-r*p1->amp*sin(rad[t]-rad[m]-p1->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + // hasin[j+4*m-3][j+4*m-2]+=r*v[t]*p1->amp*sin(rad[t]-rad[m]-p1->rad); + p5->irow=j+4*m-3; //ajVj + p5->jcol=j+4*m-2; + p5->z=-r*v[t]*p1->amp*cos(rad[t]-rad[m]-p1->rad); + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + } + } + p10=p10->next; + } + i=i+1; + p2=p2->next; + } + + p9=com->head_gpcd; + i=rr+rlpij+rlqij+rlsij+rliij+rvpd+rvqd+rspij+rsqij+1; + j=rr-rv; + while(p9!=null) //加入g的二阶偏导,发电机功率园图限制部分 + { r=com->varz[i]+com->varw[i]; + + tn=0; //有功部分 + for(t=1;t<=com->rpg;t++) + { if(com->gp[t]==p9->i) + tn=t; + } + tm=0; //无功部分 + for(t=1;t<=com->rqg;t++) + { if(com->gq[t]==p9->i) + tm=t; + } + + if(tn!=0) //有有功部分 + { if(tm!=0) //有无功部分 + { if(com->varx[com->rp+tm]>=0) + { p5->irow=tn; + p5->jcol=tn; + p5->z=r*2; + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=com->rp+tm; + p5->jcol=com->rp+tm; + p5->z=r*2; + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + } + } + else //无功部分为常数 + { if(com->qd[p9->i]>=0) + { p5->irow=tn; + p5->jcol=tn; + p5->z=r*2; + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + } + } + } + else //有功部分为常数 + { if(tm!=0) //有无功部分 + { if(com->varx[com->rp+tm]>=0) + { p5->irow=com->rp+tm; + p5->jcol=com->rp+tm; + p5->z=r*2; + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + } + } + } + + i=i+1; + p9=p9->next; + } + + p12=com->head_dcbus; + i=rr+rlpij+rlqij+rlsij+rliij+rvpd+rvqd+rspij+rsqij+rgpcd+1; + t=rp+rq+rk+rkb*2+rt+rx+2*rlcos+rvdcos; + j=1; + while(p12!=null) //加入g的二阶偏导,直流功率限制 + { r=com->varz[i]+com->varw[i]; //Pdi/IdiVdi + p5->irow=t+j+n_dc; + p5->jcol=t+j; + p5->z=r; + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + i=i+1; + j=j+1; + p12=p12->next; + } + + p2=com->head_lcos; + i=rr+rlpij+rlqij+rlsij+rliij+rvpd+rvqd+rspij+rsqij+rgpcd+n_dc+1; + t=rp+rq+rk+rkb*2+rt+rx; + j=1; + while(p2!=null) + { r=com->varz[i]+com->varw[i]; + + r1=com->varx[t+j]; + x1=com->varx[t+j+com->rlcos]; + x=r1*r1+x1*x1; + + p5->irow=t+j; //Pij + p5->jcol=t+j; //Pij + if(x!=0) + p5->z=r*(2*pow(x,-1)-10*r1*r1*pow(x,-2)+8*pow(r1,4)*pow(x,-3)); + else + p5->z=0; + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=t+j; //Pij + p5->jcol=t+j+com->rlcos; //Qij + if(x!=0) + p5->z=r*(-4*r1*x1*pow(x,-2)+8*pow(r1,3)*x1*pow(x,-3)); + else + p5->z=0; + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=t+j+com->rlcos; //Qij + p5->jcol=t+j; //Pij + if(x!=0) + p5->z=r*(-4*r1*x1*pow(x,-2)+8*pow(r1,3)*x1*pow(x,-3)); + else + p5->z=0; + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=t+j+com->rlcos; //Qij + p5->jcol=t+j+com->rlcos; //Qij + if(x!=0) + p5->z=r*(-2*r1*r1*pow(x,-2)+8*r1*r1*x1*x1*pow(x,-3)); + else + p5->z=0; + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + i=i+1; + j=j+1; + p2=p2->next; + + } + + free(p5); + free(v); + free(rad); + + return; +} + +/******形成修正方程的detG*(UW-ZL)*detG******/ +void Heisen_detG(opf_common *com,opf_correct *cor,opf_decomp *dec) +{ int i,j,t,n,m,tn,tm; + double r; + + opf_matrix *p3,*p4,*p5; + +// opf_matrix **h; + int mm,rr,rv,rlpij,rlqij,rlsij,rliij,rvpd,rvqd,rpg,rqg,rpd,rqd,rspij,rsqij,rgpcd,rk,rkb,rt,rx,rp,rq,rrr,rlcos,req,rvdcos,n_dc; + double *v,*rad; + int kk; + + mm=com->n_sum; + rr=com->rr; + rv=com->rv; + rlpij=com->rlpij; + rlqij=com->rlqij; + rlsij=com->rlsij; + rliij=com->rliij; + rvpd=com->rvpd; + rvqd=com->rvqd; + rliij=com->rliij; + rpg=com->rpg; + rqg=com->rqg; + rpd=com->rpd; + rqd=com->rqd; + rspij=com->rspij; + rsqij=com->rsqij; + rgpcd=com->rgpcd; + rk=com->rk; + rkb=com->rkb; + rt=com->rt; + rx=com->rx; + rp=com->rp; + rq=com->rq; + rrr=com->rrr; + rlcos=com->rlcos; + req=com->req; + rvdcos=com->rvdcos; + n_dc=com->n_dc; + + j=rr-rv+4*mm+req; +/* + h=(opf_matrix **)malloc((j+1)*sizeof(opf_matrix *)); + for(i=1;i<=j;i++) + h[i]=null;*/ + + v=(double *)malloc((mm+1)*sizeof(double)); //减少打字，看上去简洁些 + rad=(double *)malloc((mm+1)*sizeof(double)); + for(i=1;i<=com->n_sum;i++) + { v[i]=com->v[i]; + rad[i]=com->rad[i]; + } + + p5=(opf_matrix *)malloc(lematrix); + + //计算derg乘derg的转置 + t=rr-rv; //计算derg乘derg的转置功率部分、有载调压变压器、可调移相器、可调电容器、可调线路电抗 线路功率因数限制 负荷模型功率因数限制、直流部分 + for(i=1;i<=t;i++) + { r=com->varw[i]/com->varu[i]-com->varz[i]/com->varl[i]; +// hasin[i][i]+=r; + p5->irow=i; + p5->jcol=i; + p5->z=r; + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + } + + + t=rr-rv; //计算derg乘derg的转置,电压部分 + for(i=1;i<=rv;i++) + { r=com->varw[i+t]/com->varu[i+t]-com->varz[i+t]/com->varl[i+t]; +// hasin[t+4*i-2][t+4*i-2]+=r; + p5->irow=t+4*i-2; + p5->jcol=t+4*i-2; + p5->z=r; + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + } + + + for(i=rr+1;i<=rr+rrr-rgpcd-n_dc-rlcos;i++) //计算derg乘derg的转置，多项式部分 + { r=com->varw[i]/com->varu[i]-com->varz[i]/com->varl[i]; + p3=cor->dg[i]; + while(p3!=null) + { p4=cor->dg[i]; + while(p4!=null) + { + m=(p3->irow+1-(rr-rv))/2; + n=(p4->irow+1-(rr-rv))/2; +// tm=(int)fmod(p3->irow-(rr-rv),2); + tm=(p3->irow-(rr-rv))%2; +// tn=(int)fmod(p4->irow-(rr-rv),2); + tn=(p4->irow-(rr-rv))%2; + + p5->irow=t+4*m-2-tm; + p5->jcol=t+4*n-2-tn; + p5->z=r*p3->z*p4->z; + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p4=p4->next; + } + p3=p3->next; + } + } + + for(i=rr+rrr-rgpcd-n_dc-rlcos+1;i<=rr+rrr;i++) //计算derg乘derg的转置,发电机模型部分、直流功率部分 + { r=com->varw[i]/com->varu[i]-com->varz[i]/com->varl[i]; + p3=cor->dg[i]; + while(p3!=null) + { p4=cor->dg[i]; + while(p4!=null) + { + p5->irow=p3->irow; + p5->jcol=p4->irow; + p5->z=r*p3->z*p4->z; + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p4=p4->next; + } + p3=p3->next; + } + } + + free(p5); + free(v); + free(rad); + + return; +} + +/******形成修正方程的雅可比矩阵部分******/ +void Heisen_J(opf_common *com,opf_correct *cor,opf_decomp *dec) +{ int i,j,t,n,m,tm; + + opf_matrix *p3,*p5; + opf_equalitykij *p12; + +// opf_matrix **h; + int mm,rr,rv,rlpij,rlqij,rlsij,rliij,rvpd,rvqd,rpg,rqg,rpd,rqd,rspij,rsqij,rgpcd,rk,rkb,rt,rx,rp,rq,rrr,rlcos,req,rvdcos,n_dc; + double *v,*rad; + int kk; + + mm=com->n_sum; + rr=com->rr; + rv=com->rv; + rlpij=com->rlpij; + rlqij=com->rlqij; + rlsij=com->rlsij; + rliij=com->rliij; + rvpd=com->rvpd; + rvqd=com->rvqd; + rliij=com->rliij; + rpg=com->rpg; + rqg=com->rqg; + rpd=com->rpd; + rqd=com->rqd; + rspij=com->rspij; + rsqij=com->rsqij; + rgpcd=com->rgpcd; + rk=com->rk; + rkb=com->rkb; + rt=com->rt; + rx=com->rx; + rp=com->rp; + rq=com->rq; + rrr=com->rrr; + rlcos=com->rlcos; + req=com->req; + rvdcos=com->rvdcos; + n_dc=com->n_dc; + + j=rr-rv+4*mm+req; +/* + h=(opf_matrix **)malloc((j+1)*sizeof(opf_matrix *)); + for(i=1;i<=j;i++) + h[i]=null;*/ + + v=(double *)malloc((mm+1)*sizeof(double)); //减少打字，看上去简洁些 + rad=(double *)malloc((mm+1)*sizeof(double)); + for(i=1;i<=com->n_sum;i++) + { v[i]=com->v[i]; + rad[i]=com->rad[i]; + } + + p5=(opf_matrix *)malloc(lematrix); + + m=rr-rv; //雅可比矩阵 JT和J + for(i=1;i<=rp+rq;i++) //只和功率方程有关 + { p3=cor->jcb[i]; + while(p3!=null) + { j=p3->irow; + n=(j+1)/2; //行号 +// t=(int)fmod(j,2); + t=j%2; + p5->irow=m+4*n-t; + p5->jcol=i; + p5->z=p3->z; + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p3=p3->next; + } + } + + for(i=1;i<=rk+2*rkb+rt+rx;i++) //有载调压变压器、电容器部分(只记列)、可调线路电抗 + { p3=cor->jcb[rp+rq+i]; //只和功率方程有关 + while(p3!=null) + { if(p3->irow<=2*mm) + { j=p3->irow; + n=(j+1)/2; //行号 + // t=(int)fmod(j,2); + t=j%2; + p5->irow=m+4*n-t; + p5->jcol=rp+rq+i; + p5->z=p3->z; + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + } + p3=p3->next; + } + } + + t=rp+rq+rk+2*rkb+rt+rx; + for(i=1;i<=2*rlcos+rvdcos;i++) //功率因数变量 + { p3=cor->jcb[t+i]; //只和功率因数有关 + while(p3!=null) + { p5->irow=m+4*mm+i; //和Y有关 + p5->jcol=t+i; + p5->z=p3->z; + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + p3=p3->next; + } + } + + tm=rp+rq+rk+2*rkb+rt+rx+2*rlcos+rvdcos; + for(i=1;i<=n_dc*5;i++) //直流节点变量(只记列) + { p3=cor->jcb[tm+i]; + while(p3!=null) + { if(p3->irow<=2*mm) //潮流方程部分 + { j=p3->irow; + n=(j+1)/2; //行号 +// t=(int)fmod(j,2); + t=j%2; + p5->irow=m+4*n-t; + p5->jcol=tm+i; + p5->z=p3->z; + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + } + else //直流方程 + { p5->irow=p3->irow-2*mm+rr-rv+4*mm; + p5->jcol=tm+i; + p5->z=p3->z; + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + } + p3=p3->next; + } + } + + n=rr-rv+4*mm+2*rlcos+rvdcos+3*n_dc; //等变压器分接头集合 + m=rp+rq; + i=1; + p12=com->head_eqkij; + while(p12!=null) + { p5->irow=n+i; + p5->jcol=m+p12->i; + p5->z=1; + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=n+i; + p5->jcol=m+p12->j; + p5->z=-1; + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + i=i+1; + p12=p12->next; + } + + m=rr-rv; //雅可比矩阵 JT和J + for(i=1;i<=mm;i++) + { p3=cor->jcb[2*i-1+m]; //角度部分 + while(p3!=null) + { if(p3->irow<=2*mm) //潮流方程 + { j=p3->irow; + n=(j+1)/2; //行号 +// t=(int)fmod(j,2); + t=j%2; + if(n>=i) + { + // hasin[m+4*n-t][m+4*i-3]=p3->z; + p5->irow=m+4*n-t; + p5->jcol=m+4*i-3; + p5->z=p3->z; + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + } + else + { + // hasin[m+4*i-3][m+4*n-t]=p3->z; + p5->irow=m+4*i-3; + p5->jcol=m+4*n-t; + p5->z=p3->z; + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + } + } + else //功率因数方程、直流方程 + { p5->irow=p3->irow-2*mm+m+4*mm; + p5->jcol=m+4*i-3; + p5->z=p3->z; + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=m+4*i-3; + p5->jcol=p3->irow-2*mm+m+4*mm; + p5->z=p3->z; + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + } + p3=p3->next; + } + p3=cor->jcb[2*i+m]; //电压部分 + while(p3!=null) + { if(p3->irow<=2*mm) //潮流方程 + { j=p3->irow; + n=(j+1)/2; //行号 +// t=(int)fmod(j,2); + t=j%2; + if(n>=i) + { + // hasin[m+4*n-t][m+4*i-2]=p3->z; + p5->irow=m+4*n-t; + p5->jcol=m+4*i-2; + p5->z=p3->z; + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + } + else + { + // hasin[m+4*i-2][m+4*n-t]=p3->z; + p5->irow=m+4*i-2; + p5->jcol=m+4*n-t; + p5->z=p3->z; + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + } + } + else //功率因数方程、直流方程 + { p5->irow=p3->irow-2*mm+m+4*mm; + p5->jcol=m+4*i-2; + p5->z=p3->z; + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + + p5->irow=m+4*i-2; + p5->jcol=p3->irow-2*mm+m+4*mm; + p5->z=p3->z; + cor->heisen[p5->jcol]=insert2(cor->heisen[p5->jcol],p5,&kk); + if(kk==0) + p5=(opf_matrix *)malloc(lematrix); + } + p3=p3->next; + } + } + free(p5); + free(v); + free(rad); + + return; +} + +/* + *计算海森部分的不平衡量 + * @param 用derh返回 + */ +void CalHImbalance(opf_common *com,opf_correct *cor,double fact1,double * derh1) +{ + int i,j,t,tm,tn,m,n; + double r,x; + + opf_yij *p1; + opf_gij *p2; + opf_matrix *p3; + opf_line *p4; + opf_kij *p6; + opf_vpdqd *p5; + opf_gpcd *p7; + opf_sij *p8; + opf_dcbus *p9; + + int mm,rr,rv,rlpij,rlqij,rlsij,rliij,rvpd,rvqd,rspij,rsqij,rpg,rqg,rpd,rqd,rk,rkb,rt,rx,rp,rq,rrr,rlcos,rvdcos,req,n_dc,rgpcd; + double *v,*rad; + double *derf; + + mm=com->n_sum; + rr=com->rr; + rv=com->rv; + rlpij=com->rlpij; + rlqij=com->rlqij; + rlsij=com->rlsij; + rliij=com->rliij; + rvpd=com->rvpd; + rvqd=com->rvqd; + rspij=com->rspij; + rsqij=com->rsqij; + rpg=com->rpg; + rqg=com->rqg; + rpd=com->rpd; + rqd=com->rqd; + rk=com->rk; + rkb=com->rkb; + rt=com->rt; + rx=com->rx; + rp=com->rp; + rq=com->rq; + rrr=com->rrr; + rlcos=com->rlcos; + req=com->req; + n_dc=com->n_dc; + rgpcd=com->rgpcd; + rvdcos=com->rvdcos; + + v=(double *)malloc((mm+1)*sizeof(double)); //减少打字，看上去简洁些 + rad=(double *)malloc((mm+1)*sizeof(double)); + for(i=1;i<=mm;i++) + { v[i]=com->v[i]; + rad[i]=com->rad[i]; + } + derf=(double *)malloc((rr-rv+2*mm+1)*sizeof(double)); + for(i=1;i<=rr-rv+2*mm;i++) + derf[i]=0; + + for(i=1;i<=rr-rv;i++) //计算的g值 + com->gvalue[i]=com->varx[i]; + for(i=1;i<=rv;i++) + com->gvalue[i+rr-rv]=v[com->gv[i]]; + + i=1; + p2=com->head_lpij; //支路有功g值 + while(p2!=null) + { +// p4=com->head_lij; + p1=com->a[p2->i]; + j=0; + while((p1!=null)&&(j==0)) + { if((p2->i==p1->irow)&&(p2->j==p1->jcol)) + j=1; + else + p1=p1->next; + } + if(p1!=null) + com->gvalue[rr+i]=v[p2->i]*v[p2->i]*p1->amp*cos(p1->rad)-v[p2->i]*v[p2->j]*p1->amp*cos(com->rad[p2->i]-com->rad[p2->j]-p1->rad); + p2=p2->next; + i=i+1; + } + + i=1; + p2=com->head_lqij; //支路无功g值 + while(p2!=null) + { +// p4=com->head_lij; + p1=com->a[p2->i]; + j=0; + while((p1!=null)&&(j==0)) + { if((p2->i==p1->irow)&&(p2->j==p1->jcol)) + j=1; + else + p1=p1->next; + } + if(p1!=null) + { +// com->gvalue[rr+rlpij+i]=-v[p2->i]*v[p2->i]*p1->amp*sin(p1->rad)-v[p2->i]*v[p2->j]*p1->amp*sin(com->rad[p2->i]-com->rad[p2->j]-p1->rad); + n=0; + p6=com->head_kij; + while((p6!=null)&&(n==0)) + { if((p6->i==p2->i)&&(p6->j==p2->j)) + n=1; + else + p6=p6->next; + } + if(p6!=null) + com->gvalue[rr+rlpij+i]=-v[p2->i]*v[p2->i]*p6->k*p1->amp*sin(p1->rad-3.1415926)-v[p2->i]*v[p2->j]*p1->amp*sin(com->rad[p2->i]-com->rad[p2->j]-(p1->rad-3.1415926)); + else + com->gvalue[rr+rlpij+i]=0; + } + p2=p2->next; + i=i+1; + } + + i=1; + p2=com->head_lsij; //支路容量g值 + while(p2!=null) + { +// p4=com->head_lij; + p1=com->a[p2->i]; + j=0; + while((p1!=null)&&(j==0)) + { if((p2->i==p1->irow)&&(p2->j==p1->jcol)) + j=1; + else + p1=p1->next; + } + if(p1!=null) + com->gvalue[rr+rlpij+rlqij+i]=pow(v[p2->i],4)*pow(p1->amp,2)+pow(v[p2->i],2)*pow(p1->amp,2)*pow(v[p2->j],2)-2*pow(v[p2->i],3)*pow(p1->amp,2)*v[p2->j]*cos(com->rad[p2->i]-com->rad[p2->j]); + p2=p2->next; + i=i+1; + } + + i=1; + p2=com->head_liij; //支路电流g值 + while(p2!=null) + { +// p4=com->head_lij; + p1=com->a[p2->i]; + j=0; + while((p1!=null)&&(j==0)) + { if((p2->i==p1->irow)&&(p2->j==p1->jcol)) + j=1; + else + p1=p1->next; + } + if(p1!=null) + com->gvalue[rr+rlpij+rlqij+rlsij+i]=pow(v[p2->i],2)*pow(p1->amp,2)+pow(v[p2->j],2)*pow(p1->amp,2)-2*v[p2->i]*pow(p1->amp,2)*v[p2->j]*cos(com->rad[p2->i]-com->rad[p2->j]); + p2=p2->next; + i=i+1; + } + + i=1; + j=rr+rlpij+rlqij+rlsij+rliij; + p5=com->head_vpd; //有功负荷模型g值 + while(p5!=null) + { com->gvalue[j+i]=p5->a*pow(v[p5->i],2)+p5->b*v[p5->i]+p5->c; + p5=p5->next; + i=i+1; + } + + i=1; + j=rr+rlpij+rlqij+rlsij+rliij+rvpd; + p5=com->head_vqd; //无功负荷模型g值 + while(p5!=null) + { com->gvalue[j+i]=p5->a*pow(v[p5->i],2)+p5->b*v[p5->i]+p5->c; + p5=p5->next; + i=i+1; + } + + i=rr+rlpij+rlqij+rlsij+rliij+rvpd+rvqd+1; + for(j=0;j<=rspij-1;j++) + com->gvalue[i+j]=0; + p2=com->head_spij; //断面有功g值 + while(p2!=null) + { p8=com->head_sij; + while(p8!=null) + { if(p8->num==p2->i) + { +// p4=com->head_lij; + p1=com->a[p8->i]; + j=0; + while((p1!=null)&&(j==0)) + { if((p8->i==p1->irow)&&(p8->j==p1->jcol)) + j=1; + else + p1=p1->next; + } + if(p1!=null) + com->gvalue[i]+=v[p8->i]*v[p8->i]*p1->amp*cos(p1->rad)-v[p8->i]*v[p8->j]*p1->amp*cos(com->rad[p8->i]-com->rad[p8->j]-p1->rad); + } + p8=p8->next; + } + p2=p2->next; + i=i+1; + } + + i=rr+rlpij+rlqij+rlsij+rliij+rvpd+rvqd+rspij+1; + for(j=0;j<=rsqij-1;j++) + com->gvalue[i+j]=0; + p2=com->head_sqij; //断面无功g值 + while(p2!=null) + { p8=com->head_sij; + while(p8!=null) + { if(p8->num==p2->i) + { +// p4=com->head_lij; + p1=com->a[p8->i]; + j=0; + while((p1!=null)&&(j==0)) + { if((p8->i==p1->irow)&&(p8->j==p1->jcol)) + j=1; + else + p1=p1->next; + } + if(p1!=null) + com->gvalue[i]+=-v[p8->i]*v[p8->i]*p1->amp*sin(p1->rad)-v[p8->i]*v[p8->j]*p1->amp*sin(com->rad[p8->i]-com->rad[p8->j]-p1->rad); + } + p8=p8->next; + } + p2=p2->next; + i=i+1; + } + + i=1; + p7=com->head_gpcd; //发电机功率圆图g值 + j=rr+rlpij+rlqij+rlsij+rliij+rvpd+rvqd+rspij+rsqij; + while(p7!=null) + { + r=0; + x=0; + + tn=0; //有功部分 + for(t=1;t<=com->rpg;t++) + { if(com->gp[t]==p7->i) + tn=t; + } + tm=0; //无功部分 + for(t=1;t<=com->rqg;t++) + { if(com->gq[t]==p7->i) + tm=t; + } + if(tn!=0) + r=com->varx[tn]; + else + r=com->pg[p7->i]; + if(tm!=0) + x=com->varx[com->rp+tm]; + else + x=com->qg[p7->i]; + + if(x>=0) //值随时修改变化 + { com->gvalue[j+i]=r*r+(x-p7->qo)*(x-p7->qo); + com->gmax[j+i]=pow(p7->sn*cos(p7->rad),2)+pow((p7->sn*sin(p7->rad)-p7->qo),2); + } + else + { com->gvalue[j+i]=r+tan(p7->rad)*x; + com->gmax[j+i]=p7->sn*cos(p7->rad); + } + + p7=p7->next; + i=i+1; + } + + i=1; + p9=com->head_dcbus; //直流功率g值 + j=rr+rlpij+rlqij+rlsij+rliij+rvpd+rvqd+rspij+rsqij+rgpcd; + t=rp+rq+rk+2*rkb+rt+rx+2*rlcos+rvdcos; + while(p9!=null) + { com->gvalue[j+i]=com->varx[t+i]*com->varx[t+i+n_dc]; + p9=p9->next; + i=i+1; + } + + i=1; + p2=com->head_lcos; //功率因数 + j=rr+rlpij+rlqij+rlsij+rliij+rvpd+rvqd+rspij+rsqij+rgpcd+n_dc; + t=rp+rq+rk+2*rkb+rt+rx; + while(p2!=null) + { r=com->varx[t+i]; + x=com->varx[t+i+rlcos]; + if((r*r+x*x)!=0) + com->gvalue[j+i]=(r*r)/(r*r+x*x); + else + com->gvalue[j+i]=1; + p2=p2->next; + i=i+1; + } + + for(i=1;i<=rr-rv+2*mm;i++) //求误差1(关于f的一阶偏导) + derf[i]=0; + switch(com->obj_type) + { case 1: //煤耗 + { for(i=1;i<=rpg;i++) //求误差1 + derf[i]=com->fa1[i]+2*com->fa2[i]*com->varx[i]+com->fa3[i]*com->fa4[i]*exp(com->fa4[i]*com->varx[i]); + break; + } + case 2: //有功出力最小 + { for(i=1;i<=rpg;i++) + derf[i]=1; + break; + } + case 3: //无功出力最小 + { for(i=rp+1;i<=rp+rqg;i++) + derf[i]=1; + break; + } + case 4: //支路有功损耗最小 + { t=rr-rv; + for(i=1;i<=mm;i++) //求f的一阶偏导 + { r=0; + x=0; + j=0; + p1=com->a[i]; + while((p1->irow==i)&&(j==0)) + { if(p1->irow!=p1->jcol) + { r=r+v[p1->jcol]*sin(com->rad[i]-com->rad[p1->jcol])*p1->amp*cos(p1->rad); + x=x+(v[i]-v[p1->jcol]*cos(com->rad[i]-com->rad[p1->jcol]))*p1->amp*cos(p1->rad); + } + if(p1->next==null) + j=1; + else + p1=p1->next; + } + derf[t+2*i-1]=-v[i]*r; + derf[t+2*i]=-x; + } + break; + } + case 5: //支路无功损耗最小 + { t=rr-rv; + for(i=1;i<=mm;i++) //求f的一阶偏导 + { r=0; + x=0; + j=0; + p1=com->a[i]; + while((p1->irow==i)&&(j==0)) + { if(p1->irow!=p1->jcol) + { r=r+v[i]*v[p1->jcol]*sin(com->rad[i]-com->rad[p1->jcol])*p1->amp*sin(p1->rad); + x=x+(v[i]-v[p1->jcol]*cos(com->rad[i]-com->rad[p1->jcol]))*p1->amp*sin(p1->rad); + } + if(p1->next==null) + j=1; + else + p1=p1->next; + } + derf[t+2*i-1]=r; + derf[t+2*i]=x; + } + break; + } + case 6: //线路有功损耗最小 + { t=rr-rv; + p4=com->head_lij; + while(p4!=null) //求f的一阶偏导 + { r=-2*v[p4->i]*v[p4->j]*sin(com->rad[p4->i]-com->rad[p4->j])*p4->amp*cos(p4->rad); + x=-2*(v[p4->i]-v[p4->j]*cos(com->rad[p4->i]-com->rad[p4->j]))*p4->amp*cos(p4->rad); + derf[t+2*p4->i-1]+=r; + derf[t+2*p4->i]+=x; + + r=-2*v[p4->j]*v[p4->i]*sin(com->rad[p4->j]-com->rad[p4->i])*p4->amp*cos(p4->rad); + x=-2*(v[p4->j]-v[p4->i]*cos(com->rad[p4->j]-com->rad[p4->i]))*p4->amp*cos(p4->rad); + derf[t+2*p4->j-1]+=r; + derf[t+2*p4->j]+=x; + p4=p4->next; + } + break; + } + case 7: //线路无功损耗最小 + { t=rr-rv; + p4=com->head_lij; + while(p4!=null) //求f的一阶偏导 + { r=2*v[p4->i]*v[p4->j]*sin(com->rad[p4->i]-com->rad[p4->j])*p4->amp*sin(p4->rad); + x=2*(v[p4->i]-v[p4->j]*cos(com->rad[p4->i]-com->rad[p4->j]))*p4->amp*sin(p4->rad)-2*v[p4->i]*p4->bb; + derf[t+2*p4->i-1]+=r; + derf[t+2*p4->i]+=x; + r=2*v[p4->j]*v[p4->i]*sin(com->rad[p4->j]-com->rad[p4->i])*p4->amp*sin(p4->rad); + x=2*(v[p4->j]-v[p4->i]*cos(com->rad[p4->j]-com->rad[p4->i]))*p4->amp*sin(p4->rad)-2*v[p4->j]*p4->bb; + derf[t+2*p4->j-1]+=r; + derf[t+2*p4->j]+=x; + p4=p4->next; + } + break; + } + case 8: //电压越限最小 + { t=rr-rv; + for(i=1;i<=mm;i++) //求f的一阶偏导 + derf[t+2*i]+=2*com->wv[i]*(v[i]-com->v0[i]); + break; + } + case 9: //有功网损 + { for(i=1;i<=rpg;i++) + derf[i]=1; + for(i=rpg+com->rpge+1;i<=rp;i++) //rpd + derf[i]=-1; + p5=com->head_vpd; + t=rr-rv; + while(p5!=null) + { derf[t+2*p5->i]+=-2*p5->a*v[p5->i]-p5->b; + p5=p5->next; + } + break; + } + case 10: //无功网损 + { for(i=rp+1;i<=rp+rqg;i++) + derf[i]=1; + for(i=rp+rqg+com->rqge+1;i<=rp+rq;i++) + derf[i]=-1; + p5=com->head_vqd; + t=rr-rv; + while(p5!=null) + { derf[t+2*p5->i]+=-2*p5->a*v[p5->i]-p5->b; + p5=p5->next; + } + break; + } + case 11: //电容/电抗调节最小 + { i=1; + p6=com->head_ti; + while(p6!=null) //2w(ti-ti0) + { derf[rp+rq+rk+2*rkb+i]=derf[rp+rq+rk+2*rkb+i]+2*p6->w*(p6->k-p6->b); + p6=p6->next; + i=i+1; + } + break; + } + case 12: //负荷功率调节最小 + { for(i=1;i<=rpd;i++) //2w(PDi-PDi0) + derf[rpg+com->rpge+i]=derf[rpg+com->rpge+i]+2*com->wpd[i]*(com->varx[rpg+com->rpge+i]-com->pd[com->gp[rpg+com->rpge+i]]); + p5=com->head_vpd; + t=rr-rv; + while(p5!=null) + { r=p5->a*v[p5->i]*v[p5->i]+p5->b*v[p5->i]+p5->c; + derf[t+2*p5->i]+=2*p5->w*(r-com->pd[p5->i])*(2*p5->a*v[p5->i]+p5->b); + p5=p5->next; + } + break; + } + case 13: + { + p2=com->head_spij; //断面有功计算f的一阶偏导 + j=com->rr-com->rv; + while(p2!=null) //断面有功的部分 + { p8=com->head_obsij; + while(p8!=null) //找到匹配的支路有功功率部分 + { if(p8->num==p2->i) + { t=p8->i; + m=p8->j; +// p4=com->head_lij; + p1=com->a[p8->i]; + n=0; + if(p1!=null) + { while((p1!=null)&&(n==0)) + { if((p1->irow==p8->i)&&(p1->jcol==p8->j)) + n=1; + else + p1=p1->next; + } + if(p1!=null) + { derf[j+2*t-1]+=p8->w*v[t]*v[m]*p1->amp*sin(rad[t]-rad[m]-p1->rad); //ai + derf[j+2*m-1]+=-p8->w*(v[t]*v[m]*p1->amp*sin(rad[t]-rad[m]-p1->rad)); //aj + derf[j+2*t]+=p8->w*(2*v[t]*p1->amp*cos(p1->rad)-v[m]*p1->amp*cos(rad[t]-rad[m]-p1->rad)); //Vi + derf[j+2*m]+=-p8->w*v[t]*p1->amp*cos(rad[t]-rad[m]-p1->rad); //Vj + } + } + } + p8=p8->next; + } + p2=p2->next; + } + break; + } + case 14: //机组无功备用最大 + { x=0; + for(i=1;i<=rqg;i++) //-2w + derf[rp+i]=derf[rp+i]-2*com->wqg[i]; + break; + } + case 15: //机组有功调节最小 + { for(i=1;i<=rpg;i++) //2w(PGi-PGi0) + derf[i]=derf[i]+2*com->wpg[i]*(com->varx[i]-com->pg[com->gp[i]]); + break; + } + case 16: //机组无功调节最小 + { for(i=1;i<=rqg;i++) //2w(QGi-QGi0) + derf[rp+i]=derf[rp+i]+2*com->wqg[i]*(com->varx[rp+i]-com->qg[com->gq[i]]); + break; + } + default: + break; + } + + if(com->mini_pf_flag==1) //最小化潮流部分 + { for(i=1;i<=com->rpge;i++) + derf[rpg+i]=derf[rpg+i]+2*com->varx[rpg+i]*com->mini_pf_w; + for(i=1;i<=com->rqge;i++) + derf[rp+rqg+i]=derf[rp+rqg+i]+2*com->varx[rp+rqg+i]*com->mini_pf_w; + } + + for(i=1;i<=rr-rv+2*mm;i++) + { p3=cor->jcb[i]; + r=0; + while(p3!=null) + { r=r+p3->z*com->vary[p3->irow]; + p3=p3->next; + } + derf[i]=derf[i]-r; + } + + for(i=1;i<=rr+rrr;i++) + derh1[i]=fact1*(1/com->varu[i]-1/com->varl[i])-com->varz[i]-com->varw[i]; + for(i=1;i<=rr+rrr;i++) + derh1[i]=derh1[i]-com->varw[i]*(com->gvalue[i]-com->gmax[i])/com->varu[i]+com->varz[i]*(com->gvalue[i]-com->gmin[i])/com->varl[i]; + +// tm=0; + for(i=1;i<=rr+rrr;i++) + { p3=cor->dg[i]; + while(p3!=null) + { +// if(p3->irow==598) +// tm=tm+1; + + derf[p3->irow]=derf[p3->irow]+p3->z*derh1[p3->jcol]; + p3=p3->next; + } + } + + for(i=1;i<=rr-rv;i++) + derh1[i]=derf[i]; + t=rr-rv; + for(i=1;i<=mm;i++) + { derh1[t+4*i-3]=derf[t+2*i-1]; + derh1[t+4*i-2]=derf[t+2*i]; + } + + free(v); + free(rad); + free(derf); +} + +int CalGvalue(opf_common *com,opf_correct *cor) //计算不等式约束的情况以及满足检测 +{ + int i,j,t,tm,tn,n; + double r,x; + int pch; + + opf_yij *p1; + opf_gij *p2; + opf_matrix *p3; + opf_line *p4; + opf_kij *p6; + opf_vpdqd *p5; + opf_gpcd *p7; + opf_sij *p8; + opf_dcbus *p9; + + int mm,rr,rv,rlpij,rlqij,rlsij,rliij,rvpd,rvqd,rspij,rsqij,rpg,rqg,rpd,rqd,rk,rkb,rt,rx,rp,rq,rrr,rlcos,rvdcos,req,n_dc,rgpcd; + double *v,*rad; + + mm=com->n_sum; + rr=com->rr; + rv=com->rv; + rlpij=com->rlpij; + rlqij=com->rlqij; + rlsij=com->rlsij; + rliij=com->rliij; + rvpd=com->rvpd; + rvqd=com->rvqd; + rspij=com->rspij; + rsqij=com->rsqij; + rpg=com->rpg; + rqg=com->rqg; + rpd=com->rpd; + rqd=com->rqd; + rk=com->rk; + rkb=com->rkb; + rt=com->rt; + rx=com->rx; + rp=com->rp; + rq=com->rq; + rrr=com->rrr; + rlcos=com->rlcos; + req=com->req; + n_dc=com->n_dc; + rgpcd=com->rgpcd; + rvdcos=com->rvdcos; + + v=(double *)malloc((mm+1)*sizeof(double)); //减少打字，看上去简洁些 + rad=(double *)malloc((mm+1)*sizeof(double)); + for(i=1;i<=mm;i++) + { v[i]=com->v[i]; + rad[i]=com->rad[i]; + } + + for(i=1;i<=rr-rv;i++) //计算的g值 + com->gvalue[i]=com->varx[i]; + for(i=1;i<=rv;i++) + com->gvalue[i+rr-rv]=v[com->gv[i]]; + + i=1; + p2=com->head_lpij; //支路有功g值 + while(p2!=null) + { +// p4=com->head_lij; + p1=com->a[p2->i]; + j=0; + while((p1!=null)&&(j==0)) + { if((p2->i==p1->irow)&&(p2->j==p1->jcol)) + j=1; + else + p1=p1->next; + } + if(p1!=null) + com->gvalue[rr+i]=v[p2->i]*v[p2->i]*p1->amp*cos(p1->rad)-v[p2->i]*v[p2->j]*p1->amp*cos(com->rad[p2->i]-com->rad[p2->j]-p1->rad); + p2=p2->next; + i=i+1; + } + + i=1; + p2=com->head_lqij; //支路无功g值 + while(p2!=null) + { +// p4=com->head_lij; + p1=com->a[p2->i]; + j=0; + while((p1!=null)&&(j==0)) + { if((p2->i==p1->irow)&&(p2->j==p1->jcol)) + j=1; + else + p1=p1->next; + } + if(p1!=null) + { +// com->gvalue[rr+rlpij+i]=-v[p2->i]*v[p2->i]*p1->amp*sin(p1->rad)-v[p2->i]*v[p2->j]*p1->amp*sin(com->rad[p2->i]-com->rad[p2->j]-p1->rad); + n=0; + p6=com->head_kij; + while((p6!=null)&&(n==0)) + { if((p6->i==p2->i)&&(p6->j==p2->j)) + n=1; + else + p6=p6->next; + } + if(p6!=null) + com->gvalue[rr+rlpij+i]=-v[p2->i]*v[p2->i]*p6->k*p1->amp*sin(p1->rad-3.1415926)-v[p2->i]*v[p2->j]*p1->amp*sin(com->rad[p2->i]-com->rad[p2->j]-(p1->rad-3.1415926)); + else + com->gvalue[rr+rlpij+i]=0; + } + p2=p2->next; + i=i+1; + } + + i=1; + p2=com->head_lsij; //支路容量g值 + while(p2!=null) + { +// p4=com->head_lij; + p1=com->a[p2->i]; + j=0; + while((p1!=null)&&(j==0)) + { if((p2->i==p1->irow)&&(p2->j==p1->jcol)) + j=1; + else + p1=p1->next; + } + if(p1!=null) + com->gvalue[rr+rlpij+rlqij+i]=pow(v[p2->i],4)*pow(p1->amp,2)+pow(v[p2->i],2)*pow(p1->amp,2)*pow(v[p2->j],2)-2*pow(v[p2->i],3)*pow(p1->amp,2)*v[p2->j]*cos(com->rad[p2->i]-com->rad[p2->j]); + p2=p2->next; + i=i+1; + } + + i=1; + p2=com->head_liij; //支路电流g值 + while(p2!=null) + { +// p4=com->head_lij; + p1=com->a[p2->i]; + j=0; + while((p1!=null)&&(j==0)) + { if((p2->i==p1->irow)&&(p2->j==p1->jcol)) + j=1; + else + p1=p1->next; + } + if(p1!=null) + com->gvalue[rr+rlpij+rlqij+rlsij+i]=pow(v[p2->i],2)*pow(p1->amp,2)+pow(v[p2->j],2)*pow(p1->amp,2)-2*v[p2->i]*pow(p1->amp,2)*v[p2->j]*cos(com->rad[p2->i]-com->rad[p2->j]); + p2=p2->next; + i=i+1; + } + + i=1; + j=rr+rlpij+rlqij+rlsij+rliij; + p5=com->head_vpd; //有功负荷模型g值 + while(p5!=null) + { com->gvalue[j+i]=p5->a*pow(v[p5->i],2)+p5->b*v[p5->i]+p5->c; + p5=p5->next; + i=i+1; + } + + i=1; + j=rr+rlpij+rlqij+rlsij+rliij+rvpd; + p5=com->head_vqd; //无功负荷模型g值 + while(p5!=null) + { com->gvalue[j+i]=p5->a*pow(v[p5->i],2)+p5->b*v[p5->i]+p5->c; + p5=p5->next; + i=i+1; + } + + i=rr+rlpij+rlqij+rlsij+rliij+rvpd+rvqd+1; + for(j=0;j<=rspij-1;j++) + com->gvalue[i+j]=0; + p2=com->head_spij; //断面有功g值 + while(p2!=null) + { p8=com->head_sij; + while(p8!=null) + { if(p8->num==p2->i) + { +// p4=com->head_lij; + p1=com->a[p8->i]; + j=0; + while((p1!=null)&&(j==0)) + { if((p8->i==p1->irow)&&(p8->j==p1->jcol)) + j=1; + else + p1=p1->next; + } + if(p1!=null) + com->gvalue[i]+=v[p8->i]*v[p8->i]*p1->amp*cos(p1->rad)-v[p8->i]*v[p8->j]*p1->amp*cos(com->rad[p8->i]-com->rad[p8->j]-p1->rad); + } + p8=p8->next; + } + p2=p2->next; + i=i+1; + } + + i=rr+rlpij+rlqij+rlsij+rliij+rvpd+rvqd+rspij+1; + for(j=0;j<=rsqij-1;j++) + com->gvalue[i+j]=0; + p2=com->head_sqij; //断面无功g值 + while(p2!=null) + { p8=com->head_sij; + while(p8!=null) + { if(p8->num==p2->i) + { +// p4=com->head_lij; + p1=com->a[p8->i]; + j=0; + while((p1!=null)&&(j==0)) + { if((p8->i==p1->irow)&&(p8->j==p1->jcol)) + j=1; + else + p1=p1->next; + } + if(p1!=null) + com->gvalue[i]+=-v[p8->i]*v[p8->i]*p1->amp*sin(p1->rad)-v[p8->i]*v[p8->j]*p1->amp*sin(com->rad[p8->i]-com->rad[p8->j]-p1->rad); + } + p8=p8->next; + } + p2=p2->next; + i=i+1; + } + + i=1; + p7=com->head_gpcd; //发电机功率圆图g值 + j=rr+rlpij+rlqij+rlsij+rliij+rvpd+rvqd+rspij+rsqij; + while(p7!=null) + { + r=0; + x=0; + + tn=0; //有功部分 + for(t=1;t<=com->rpg;t++) + { if(com->gp[t]==p7->i) + tn=t; + } + tm=0; //无功部分 + for(t=1;t<=com->rqg;t++) + { if(com->gq[t]==p7->i) + tm=t; + } + if(tn!=0) + r=com->varx[tn]; + else + r=com->pg[p7->i]; + if(tm!=0) + x=com->varx[com->rp+tm]; + else + x=com->qg[p7->i]; + + if(x>=0) //值随时修改变化 + { com->gvalue[j+i]=r*r+(x-p7->qo)*(x-p7->qo); + com->gmax[j+i]=pow(p7->sn*cos(p7->rad),2)+pow((p7->sn*sin(p7->rad)-p7->qo),2); + } + else + { com->gvalue[j+i]=r+tan(p7->rad)*x; + com->gmax[j+i]=p7->sn*cos(p7->rad); + } + + p7=p7->next; + i=i+1; + } + + i=1; + p9=com->head_dcbus; //直流功率g值 + j=rr+rlpij+rlqij+rlsij+rliij+rvpd+rvqd+rspij+rsqij+rgpcd; + t=rp+rq+rk+2*rkb+rt+rx+2*rlcos+rvdcos; + while(p9!=null) + { com->gvalue[j+i]=com->varx[t+i]*com->varx[t+i+n_dc]; + p9=p9->next; + i=i+1; + } + + i=1; + p2=com->head_lcos; //功率因数 + j=rr+rlpij+rlqij+rlsij+rliij+rvpd+rvqd+rspij+rsqij+rgpcd+n_dc; + t=rp+rq+rk+2*rkb+rt+rx; + while(p2!=null) + { r=com->varx[t+i]; + x=com->varx[t+i+rlcos]; + if((r*r+x*x)!=0) + com->gvalue[j+i]=(r*r)/(r*r+x*x); + else + com->gvalue[j+i]=1; + p2=p2->next; + i=i+1; + } + + pch=0; + for(i=1;i<=rr+rrr;i++) + { if((com->gvalue[i]>com->gmax[i])||(com->gvalue[i]gmin[i])) + pch=pch+1; + } + + free(v); + free(rad); + return pch; + +} + +/******计算等式约束的不平衡量******/ +void CalDpDq(opf_common *com,opf_correct *cor,double * derh1) +{ + int i,t,j,n,m; + double r,x; + + + opf_yij *p1; + opf_debug *p2,*p3; + opf_vpdqd *p5; + opf_gij *p4; + opf_line *p6; + opf_dcbus *p7,*p8; + opf_equalitykij *p12; + + double *pp,*qq,*spg,*sqg; //临时变量 + double *v,*rad; + + pp=(double *)malloc((com->n_sum+1)*sizeof(double)); + qq=(double *)malloc((com->n_sum+1)*sizeof(double)); + spg=(double *)malloc((com->n_sum+1)*sizeof(double));//为了同一个节点有多台发电机的情况 + sqg=(double *)malloc((com->n_sum+1)*sizeof(double)); + + v=(double *)malloc((com->n_sum+1)*sizeof(double)); //减少打字，看上去简洁些 + rad=(double *)malloc((com->n_sum+1)*sizeof(double)); + for(i=1;i<=com->n_sum;i++) + { v[i]=com->v[i]; + rad[i]=com->rad[i]; + } + +/******交流节点的潮流方程的不平衡量******/ + for(i=1;i<=com->n_sum;i++) + { pp[i]=0; + qq[i]=0; + spg[i]=com->pg[i]; + sqg[i]=com->qg[i]; + } + + for(i=1;i<=com->rpg;i++) //给是变量的地方清0 + spg[com->gp[i]]=0; + for(i=1;i<=com->rqg;i++) + sqg[com->gq[i]]=0; + + for(i=1;i<=com->rpg;i++) //给是变量的地方赋值 + spg[com->gp[i]]+=com->varx[i]; + for(i=1;i<=com->rqg;i++) + sqg[com->gq[i]]+=com->varx[com->rp+i]; + + p1=com->a[1]; + while(p1!=null) + { pp[p1->irow]=pp[p1->irow]+p1->amp*v[p1->jcol]*cos(rad[p1->irow]-rad[p1->jcol]-p1->rad); + qq[p1->irow]+=p1->amp*v[p1->jcol]*sin(rad[p1->irow]-rad[p1->jcol]-p1->rad); + p1=p1->next; + } + for(i=1;i<=com->n_sum;i++) + { + pp[i]=(pp[i]+v[i]*com->g[i]*cos(com->b[i]))*v[i]; + qq[i]=(qq[i]+v[i]*com->g[i]*sin(-com->b[i]))*v[i]; + pp[i]=spg[i]-com->pd[i]-pp[i]; + qq[i]=sqg[i]-com->qd[i]-qq[i]; + } + + if(com->mini_pf_flag==1) + { for(i=1;i<=com->rpge;i++) + pp[i]=pp[i]+com->varx[com->rpg+i]; + for(i=1;i<=com->rqge;i++) + qq[i]=qq[i]+com->varx[com->rp+com->rqg+i]; + + } + + for(i=com->rpg+com->rpge+1;i<=com->rp;i++) //rpd + pp[com->gp[i]]=com->pd[com->gp[i]]-com->varx[i]+pp[com->gp[i]]; + + for(i=com->rqg+com->rqge+1;i<=com->rq;i++) //rqd + qq[com->gq[i]]=com->qd[com->gq[i]]-com->varx[com->rp+i]+qq[com->gq[i]]; + + p5=com->head_vpd; + while(p5!=null) + { r=p5->a*v[p5->i]*v[p5->i]+p5->b*v[p5->i]+p5->c; + pp[p5->i]=com->pd[p5->i]-r+pp[p5->i]; + p5=p5->next; + } + + p5=com->head_vqd; + while(p5!=null) + { r=p5->a*v[p5->i]*v[p5->i]+p5->b*v[p5->i]+p5->c; + qq[p5->i]=com->qd[p5->i]-r+qq[p5->i]; + p5=p5->next; + } + + t=com->rr-com->rv; + for(i=1;i<=com->n_sum;i++) + { derh1[t+i*4-1]=-pp[i]; + derh1[t+i*4]=-qq[i]; + } + +/******关于线路功率因数的等式约束的不平衡量*******/ + t=com->rr-com->rv; + i=1; + p4=com->head_lcos; //线路功率因数 + while(p4!=null) + { +// p6=com->head_lij; + p1=com->a[p4->i]; + j=0; + while((p1!=null)&&(j==0)) + { if((p1->irow==p4->i)&&(p1->jcol==p4->j)) + j=1; + else + p1=p1->next; + } + if(p1!=null) + { r=com->varx[com->rp+com->rq+com->rk+2*com->rkb+com->rt+com->rx+i]; //Pij + x=v[p4->i]*v[p4->i]*p1->amp*cos(p1->rad)-v[p4->i]*v[p4->j]*p1->amp*cos(com->rad[p4->i]-com->rad[p4->j]-p1->rad)-r; + derh1[t+4*com->n_sum+i]=-x; + + r=com->varx[com->rp+com->rq+com->rk+2*com->rkb+com->rt+com->rx+i+com->rlcos]; //Qij + x=-v[p4->i]*v[p4->i]*p1->amp*sin(p1->rad)-v[p4->i]*v[p4->j]*p1->amp*sin(com->rad[p4->i]-com->rad[p4->j]-p1->rad)-r; + derh1[t+4*com->n_sum+i+com->rlcos]=-x; + } + i=i+1; + p4=p4->next; + } + +/******关于负荷功率因数的等式约束的不平衡量*******/ + t=com->rr-com->rv; + i=1; + p4=com->head_vdcos; //负荷功率因数 + while(p4!=null) + { x=0; + r=0; + + p5=com->head_vpd; + j=0; + while((p5!=null)&&(j==0)) + { if(p4->i==p5->i) + j=1; + else + p5=p5->next; + } + if(p5!=null) + x=p5->a*pow(v[p4->i],2)+p5->b*v[p4->i]+p5->c; //PDi + else + x=com->pd[p4->i];//为常数 + + p5=com->head_vqd; + j=0; + while((p5!=null)&&(j==0)) + { if(p4->i==p5->i) + j=1; + else + p5=p5->next; + } + if(p5!=null) + r=p5->a*pow(v[p4->i],2)+p5->b*v[p4->i]+p5->c; //QDi + else + r=com->qd[p4->i];//为常数 + + derh1[t+4*com->n_sum+2*com->rlcos+i]=-((x*x+r*r)*p4->g*p4->g-x*x); + + i=i+1; + p4=p4->next; + } + +/******关于直流节点等式约束的不平衡量*******/ + m=com->rr-com->rv; + n=com->rp+com->rq+com->rk+2*com->rkb+com->rt+com->rx+2*com->rlcos+com->rvdcos; + i=1; + p7=com->head_dcbus; + while(p7!=null) + { if(p7->flag==1) + { derh1[m+p7->iac*4-1]+=-com->varx[n+i]*com->varx[n+i+com->n_dc]; //Pi + pp[p7->iac]+=com->varx[n+i]*com->varx[n+i+com->n_dc]; + derh1[m+p7->iac*4]+=-com->varx[n+i]*com->varx[n+i+com->n_dc]*tan(com->varx[n+i+4*com->n_dc]); //Qi + qq[p7->iac]+=com->varx[n+i]*com->varx[n+i+com->n_dc]*tan(com->varx[n+i+4*com->n_dc]); + } + else + { derh1[m+p7->iac*4-1]+=com->varx[n+i]*com->varx[n+i+com->n_dc]; //Pi + pp[p7->iac]+=-com->varx[n+i]*com->varx[n+i+com->n_dc]; + derh1[m+p7->iac*4]+=com->varx[n+i]*com->varx[n+i+com->n_dc]*tan(com->varx[n+i+4*com->n_dc]); //Qi + qq[p7->iac]+=-com->varx[n+i]*com->varx[n+i+com->n_dc]*tan(com->varx[n+i+4*com->n_dc]); + } + derh1[m+4*com->n_sum+2*com->rlcos+com->rvdcos+i]=-(com->varx[n+i]-com->varx[n+i+2*com->n_dc]*v[p7->iac]*com->varx[n+i+3*com->n_dc]+p7->r*com->varx[n+i+com->n_dc]); //d1 + derh1[m+4*com->n_sum+2*com->rlcos+com->rvdcos+i+com->n_dc]=-(com->varx[n+i]-p7->kr*com->varx[n+i+2*com->n_dc]*v[p7->iac]*cos(com->varx[n+i+4*com->n_dc])); //d2 + + p6=com->head_dclij; + x=0; + while(p6!=null) + { if((p6->i==p7->i)||(p6->j==p7->i)) + { if(p6->i==p7->i) + { p8=com->head_dcbus; + t=1; + j=0; + while((p8!=null)&&(j==0)) + { if(p8->i==p6->j) + j=1; + t=t+1; + p8=p8->next; + } + t=t-1; + } + else + { p8=com->head_dcbus; + t=1; + j=0; + while((p8!=null)&&(j==0)) + { if(p8->i==p6->i) + j=1; + t=t+1; + p8=p8->next; + } + t=t-1; + } + x=x+p6->amp*com->varx[n+i]-p6->amp*com->varx[n+t]; + } + p6=p6->next; + } + if(p7->flag==0) //d3 + derh1[m+4*com->n_sum+2*com->rlcos+com->rvdcos+i+2*com->n_dc]=-(com->varx[n+p7->i+com->n_dc]-x); + else + derh1[m+4*com->n_sum+2*com->rlcos+com->rvdcos+i+2*com->n_dc]=-(-com->varx[n+p7->i+com->n_dc]-x); + + i=i+1; + p7=p7->next; + } + + m=com->rr-com->rv; + n=com->rp+com->rq; + i=1; + p12=com->head_eqkij; + while(p12!=null) + { derh1[m+4*com->n_sum+2*com->rlcos+com->rvdcos+3*com->n_dc+i]=-(com->varx[n+p12->i]-com->varx[n+p12->j]); + i=i+1; + p12=p12->next; + } + + p2=(opf_debug *)malloc(ledebug); //选择交流节点最大的dp,dq的绝对值（潮流方程） + p2->next=null; + p2->i=1; + p2->j=1; + p2->x=fabs(pp[1]); + p2->y=fabs(qq[1]); + for(i=2;i<=com->n_sum;i++) + { if(p2->xx=fabs(pp[i]); + p2->i=i; + } + if(p2->yy=fabs(qq[i]); + p2->j=i; + } + } + + if(com->head_debugpq==null) //将最大的dp,dq的绝对值保存在debuginfo_pq中 + com->head_debugpq=p2; + else + { p3=com->head_debugpq; + while(p3->next!=null) + p3=p3->next; + p3->next=p2; + } + + t=com->rr-com->rv+4*com->n_sum; + if(com->req!=0) + { p2=(opf_debug *)malloc(ledebug); //选择最大的其他等式约束的绝对值（功率因数方程、直流节点） + p2->next=null; + p2->i=1; + p2->j=1; + p2->x=0; + p2->y=0; + i=1; + for(i=1;i<=com->req;i++) + { if(p2->xx=fabs(derh1[t+i]); + p2->i=i; + p2->j=i; + } + } + if(com->head_debuglcos==null) //将最大的偏差的绝对值保存在head_debuglcos中 + com->head_debuglcos=p2; + else + { p3=com->head_debuglcos; + while(p3->next!=null) + p3=p3->next; + p3->next=p2; + } + } + + free(v); + free(rad); + free(pp); + free(qq); + free(spg); + free(sqg); + +/* + FILE *fp1; + fp1=fopen("Text2.txt","wb"); + for(i=1;i<=mm;i++) + fprintf(fp1," %d, %f, %f\n" ,i,-dp[i],-dq[i]); + fclose(fp1); +*/ + +} + +/******LDL分解求修正方程******/ +void LDL(opf_common *com,opf_decomp *dec,double *d,double *derh1) //LDL分解求修正方程 +{ int i,j,t,hh,n; + double r,x; + + int *z; + double *yl; + + int dim; + +// d[22]=0.00001; +// d[23]=0.00001; +// d[24]=0.00001; + + dim=com->rr-com->rv+4*com->n_sum+com->req; + + z=(int *)malloc((dim+1)*sizeof(int)); + yl=(double *)malloc((dim+1)*sizeof(double)); + for(i=1;i<=dim;i++) + { z[i]=0; + yl[i]=0; + } + + for(j=1;j<=dim;j++) + { for(i=dec->ljs[j];i<=dec->ljs[j+1]-1;i++) + { t=dec->lj[i]; + yl[t]=dec->la[i]; + } + for(i=dec->lis[j];i<=dec->lis[j+1]-1;i++) + { t=dec->li[i]; + r=dec->la[dec->jtoi[i]]; + x=d[t]*r; + d[j]=d[j]-r*x; + for(hh=dec->ljs[t]+z[t];hh<=dec->ljs[t+1]-1;hh++) + { n=dec->lj[hh]; + // yu[n]=yu[n]-ua[hh]*r; + yl[n]=yl[n]-dec->la[hh]*x; + } + z[t]=z[t]+1; + } + for(i=dec->ljs[j];i<=dec->ljs[j+1]-1;i++) + { hh=dec->lj[i]; + if(d[j]==0) + { com->overflow_flag=com->overflow_flag+1; + free(z); + free(yl); + return; + } + dec->la[i]=yl[hh]/d[j]; + yl[hh]=0; + } + } + + + for(i=1;i<=dim;i++) + { r=0; + for(j=dec->lis[i];j<=dec->lis[i+1]-1;j++) + { t=dec->li[j]; + r=r+dec->la[dec->jtoi[j]]*derh1[t]; + } + derh1[i]=derh1[i]-r; + } + for(i=dim;i>=1;i--) + { + if(d[i]==0) + { com->overflow_flag=com->overflow_flag+1; + free(z); + free(yl); + return; + } + derh1[i]=derh1[i]/d[i]; + r=0; + for(j=dec->ljs[i];j<=dec->ljs[i+1]-1;j++) + { t=dec->lj[j]; + r=r+dec->la[j]*derh1[t]; + } + derh1[i]=derh1[i]-r; + } + free(z); + free(yl); + +/* + fprintf(fp1,"2\n" ); + for(i=1;i<=dim;i++) + fprintf(fp1," (%d,%d) %lf\n" ,i,i,d[i]); + fclose(fp1); + + i=1;*/ + + return; +} + +/******修正原始对偶变量******/ +void CorrectVarPD(opf_common *com,opf_correct *cor,double fact1,double *derh1) //修正原始对偶变量 +{ + int i,m; + double r,x; + double stepp,stepd;//步长 + + double *derl,*deru,*derw,*derz,*dery;//修正量 + double *derx;//修正量 + + double *derv,*derrad; + double stepbpa_v,stepbpa_rad; //按照BPA的策略修正步长 + + int mm,rr,rv,rlpij,rlqij,rlsij,rliij,rrr,rlcos,req; + + opf_matrix *p3; + + mm=com->n_sum; + rr=com->rr; + rv=com->rv; + rlpij=com->rlpij; + rlqij=com->rlqij; + rlsij=com->rlsij; + rliij=com->rliij; + rrr=com->rrr; + rlcos=com->rlcos; + req=com->req; + +/******开相应临时数组******/ + i=rr-rv+2*mm; + derx=(double *)malloc((i+1)*sizeof(double)); + i=2*mm+req; + dery=(double *)malloc((i+1)*sizeof(double)); + i=rr+rrr; + derl=(double *)malloc((i+1)*sizeof(double)); + deru=(double *)malloc((i+1)*sizeof(double)); + derw=(double *)malloc((i+1)*sizeof(double)); + derz=(double *)malloc((i+1)*sizeof(double)); + + derv=(double *)malloc((mm+1)*sizeof(double)); //减少打字，看上去简洁些 + derrad=(double *)malloc((mm+1)*sizeof(double)); + + for(i=1;i<=rr-rv;i++) + derx[i]=derh1[i]; + m=rr-rv; + for(i=1;i<=mm;i++) + { derx[m+2*i-1]=derh1[m+4*i-3]; + derx[m+2*i]=derh1[m+4*i-2]; + dery[2*i-1]=derh1[m+4*i-1]; + dery[2*i]=derh1[m+4*i]; + } + for(i=1;i<=req;i++) + dery[2*mm+i]=derh1[m+4*mm+i]; + + if((com->bpacl==1)&&(com->itera_num>=0)) //选择BPA的步长修正策略 + { m=rr-rv; //更新状态变量 + for(i=1;i<=mm;i++) + { derrad[i]=derx[m+2*i-1]; + derv[i]=derx[m+2*i]; + } + + r=fabs(derrad[1]); //BPA策略 + x=fabs(derv[1]); + for(i=2;i<=mm;i++) + { if(r1) + r=1*1.001/r; + if(x>0.15) + x=0.15*1.001/x; + + stepbpa_rad=r; + stepbpa_v=x; + } + +/* + FILE *fp1; + int j; + fp1=fopen("Text3.txt","wb"); + j=com->rr-com->rv+2*com->n_sum; + for(i=1;i<=j;i++) + fprintf(fp1," %d, %lf\n" ,i,derx[i]); + fclose(fp1);*/ + + + for(i=1;i<=rr+rrr;i++) //dg*derx + { p3=cor->dg[i]; + r=0; + while(p3!=null) + { r=r+p3->z*derx[p3->irow]; + p3=p3->next; + } + derh1[i]=r; + } + + for(i=1;i<=rr+rrr;i++) + { derl[i]=derh1[i]+com->gvalue[i]-com->gmin[i]-com->varl[i]; //derl[i] + deru[i]=-derh1[i]-com->gvalue[i]+com->gmax[i]-com->varu[i]; //deru[i] + derw[i]=(com->varw[i]*derh1[i]+com->varw[i]*com->gvalue[i]-com->varw[i]*com->gmax[i]-fact1)/com->varu[i]; //derw[i] + derz[i]=-(com->varz[i]*derh1[i]+com->varz[i]*com->gvalue[i]-com->varz[i]*com->gmin[i]-fact1)/com->varl[i]; //derz[i] + } + + stepp=1; + stepd=1; + for(i=1;i<=rr+rrr;i++) + { if(derl[i]<0) //derl + { r=-com->varl[i]/derl[i]; + if(rvaru[i]/deru[i]; + if(xvarz[i]/derz[i]; + if(r0) //derw + { x=-com->varw[i]/derw[i]; + if(xsteppfactor; + stepd=stepd*com->stepdfactor; + + if((com->bpacl==1)&&(com->itera_num>=0)) //选择BPA的步长修正策略 + { stepbpa_rad=stepbpa_rad*com->steppfactor; + stepbpa_v=stepbpa_v*com->steppfactor; + + if(stepbpa_rad>stepp) + stepbpa_rad=stepp; + if(stepbpa_v>stepp) + stepbpa_v=stepp; + + } + else + { stepbpa_rad=stepp; + stepbpa_v=stepp; + } + + for(i=1;i<=rr-rv;i++) + com->varx[i]=com->varx[i]+stepp*derx[i]; //varx + m=rr-rv; + for(i=1;i<=mm;i++) + { com->varx[m+2*i-1]=com->varx[m+2*i-1]+stepbpa_rad*derx[m+2*i-1]; //varx + com->varx[m+2*i]=com->varx[m+2*i]+stepbpa_v*derx[m+2*i]; + } + + for(i=1;i<=2*mm+req;i++) + com->vary[i]=com->vary[i]+stepd*dery[i]; //vary + + for(i=1;i<=rr+rrr;i++) + { com->varl[i]=com->varl[i]+stepp*derl[i]; //varl + com->varu[i]=com->varu[i]+stepp*deru[i]; //varu + com->varz[i]=com->varz[i]+stepd*derz[i]; //varz + com->varw[i]=com->varw[i]+stepd*derw[i]; //varw + } + +/* + FILE *fp1; + fp1=fopen("Text3.txt","wb"); +// fprintf(fp1," %s, %s, %s, %s, %s\n" ,"i","z","l","w","u"); + fprintf(fp1," %s, %s\n" ,"i","l"); + for(i=1;i<=rr+rlpij;i++) + fprintf(fp1," %lf\n" ,com->varl[i]); + fprintf(fp1,"\n"); + fprintf(fp1," %s, %s\n" ,"i","u"); + for(i=1;i<=rr+rlpij;i++) + fprintf(fp1," %lf\n" ,com->varu[i]); + fprintf(fp1,"\n"); + fprintf(fp1," %s, %s\n" ,"i","z"); + for(i=1;i<=rr+rlpij;i++) + fprintf(fp1," %lf\n" ,com->varz[i]); + fprintf(fp1,"\n"); + fprintf(fp1," %s, %s\n" ,"i","w"); + for(i=1;i<=rr+rlpij;i++) + fprintf(fp1," %lf\n" ,com->varw[i]); + fprintf(fp1,"\n"); + + +/ * + fprintf(fp1," %s, %s\n" ,"i","x"); + for(i=1;i<=rr-rv+2*mm;i++) + fprintf(fp1," %d, %lf\n" ,i,derx[i]); + fprintf(fp1,"\n"); + fprintf(fp1," %s, %s\n" ,"i","y"); + for(i=1;i<=2*mm+req;i++) + fprintf(fp1," %d, %lf\n" ,i,dery[i]);* / + + + fclose(fp1);*/ + + free(derx); + free(dery); + free(derl); + free(deru); + free(derz); + free(derw); + + free(derv); + free(derrad); + + return; +} + +/******修正节点导纳矩阵，主要修正由于可调变压器、可调移相器、可调电容器、可调线路电抗的变比变化对节点导纳矩阵产生的变化******/ +void CorrectYij(opf_common *com) //修正节点导纳矩阵 +{ int i,j,t; + double r,x; + + opf_yij *p1; + opf_kij *p6; + + p6=com->head_kij; //可调变压器修正节点导纳矩阵 + i=1; + t=com->rp+com->rq; + while(p6!=null) + { j=0; + p1=com->a[p6->i]; //是按照行排列的,Yij + if(p1!=null) + { while((p1->irow==p6->i)&&(j==0)) + { if(p1->jcol==p6->j) + { r=p1->amp*cos(p1->rad)+(com->varx[t+i]-p6->k)*p6->amp*cos(p6->rad); + x=p1->amp*sin(p1->rad)+(com->varx[t+i]-p6->k)*p6->amp*sin(p6->rad); + p1->amp=sqrt(r*r+x*x); + p1->rad=atan2(x,r); + j=1; + } + else + { if(p1->next==null) + j=1; + else + p1=p1->next; + } + } + } + j=0; + p1=com->a[p6->j]; //是按照行排列的,Yji + if(p1!=null) + { while((p1->irow==p6->j)&&(j==0)) + { if(p1->jcol==p6->i) + { r=p1->amp*cos(p1->rad)+(com->varx[t+i]-p6->k)*p6->amp*cos(p6->rad); + x=p1->amp*sin(p1->rad)+(com->varx[t+i]-p6->k)*p6->amp*sin(p6->rad); + p1->amp=sqrt(r*r+x*x); + p1->rad=atan2(x,r); + j=1; + } + else + { if(p1->next==null) + j=1; + else + p1=p1->next; + } + } + } + + x=(com->varx[t+i]*com->varx[t+i]-p6->k*p6->k)*p6->amp; //Yii + r=com->g[p6->i]*cos(com->b[p6->i])-x*cos(p6->rad); + x=com->g[p6->i]*sin(com->b[p6->i])-x*sin(p6->rad); + com->g[p6->i]=sqrt(r*r+x*x); + com->b[p6->i]=atan2(x,r); + + p6->k=com->varx[t+i]; //更新变比 + + i=i+1; + p6=p6->next; + } + + p6=com->head_kbij; //可调移相器修正节点导纳矩阵 + i=1; + t=com->rp+com->rq+com->rk; + while(p6!=null) + { j=0; + p1=com->a[p6->i]; //是按照行排列的,Yij + if(p1!=null) + { while((p1->irow==p6->i)&&(j==0)) + { if(p1->jcol==p6->j) + { r=p1->amp*cos(p1->rad)-p6->k*p6->amp*cos(p6->rad-p6->b)+com->varx[t+i]*p6->amp*cos(p6->rad-com->varx[t+i+com->rkb]); + x=p1->amp*sin(p1->rad)-p6->k*p6->amp*sin(p6->rad-p6->b)+com->varx[t+i]*p6->amp*sin(p6->rad-com->varx[t+i+com->rkb]); + p1->amp=sqrt(r*r+x*x); + p1->rad=atan2(x,r); + j=1; + } + else + { if(p1->next==null) + j=1; + else + p1=p1->next; + } + } + } + j=0; + p1=com->a[p6->j]; //是按照行排列的,Yji + if(p1!=null) + { while((p1->irow==p6->j)&&(j==0)) + { if(p1->jcol==p6->i) + { r=p1->amp*cos(p1->rad)-p6->k*p6->amp*cos(p6->rad+p6->b)+com->varx[t+i]*p6->amp*cos(p6->rad+com->varx[t+i+com->rkb]); + x=p1->amp*sin(p1->rad)-p6->k*p6->amp*sin(p6->rad+p6->b)+com->varx[t+i]*p6->amp*sin(p6->rad+com->varx[t+i+com->rkb]); + p1->amp=sqrt(r*r+x*x); + p1->rad=atan2(x,r); + j=1; + } + else + { if(p1->next==null) + j=1; + else + p1=p1->next; + } + } + } + + x=(com->varx[t+i]*com->varx[t+i]-p6->k*p6->k)*p6->amp; //Yii + r=com->g[p6->i]*cos(com->b[p6->i])-x*cos(p6->rad); + x=com->g[p6->i]*sin(com->b[p6->i])-x*sin(p6->rad); + com->g[p6->i]=sqrt(r*r+x*x); + com->b[p6->i]=atan2(x,r); + + p6->k=com->varx[t+i]; //更新变比 + p6->b=com->varx[t+i+com->rkb];//更新相角 + + i=i+1; + p6=p6->next; + } + + p6=com->head_ti; //可调电容器修正节点导纳矩阵 + i=1; + t=com->rp+com->rq+com->rk+2*com->rkb; + while(p6!=null) + { j=0; + + x=(com->varx[t+i]-p6->k)*p6->amp; //Yii + r=com->g[p6->i]*cos(com->b[p6->i])+x*cos(p6->rad); + x=com->g[p6->i]*sin(com->b[p6->i])+x*sin(p6->rad); + com->g[p6->i]=sqrt(r*r+x*x); + com->b[p6->i]=atan2(x,r); + + p6->k=com->varx[t+i]; //更新变比 + + i=i+1; + p6=p6->next; + } + + p6=com->head_kx; //可调线路电抗修正节点导纳矩阵 + i=1; + t=com->rp+com->rq+com->rk+2*com->rkb+com->rt; + while(p6!=null) + { j=0; + p1=com->a[p6->i]; //是按照行排列的,Yij + if(p1!=null) + { while((p1->irow==p6->i)&&(j==0)) + { if(p1->jcol==p6->j) + { r=p1->amp*cos(p1->rad)+(com->varx[t+i]-p6->k)*p6->amp*cos(p6->rad); + x=p1->amp*sin(p1->rad)+(com->varx[t+i]-p6->k)*p6->amp*sin(p6->rad); + p1->amp=sqrt(r*r+x*x); + p1->rad=atan2(x,r); + j=1; + } + else + { if(p1->next==null) + j=1; + else + p1=p1->next; + } + } + } + j=0; + p1=com->a[p6->j]; //是按照行排列的,Yji + if(p1!=null) + { while((p1->irow==p6->j)&&(j==0)) + { if(p1->jcol==p6->i) + { r=p1->amp*cos(p1->rad)+(com->varx[t+i]-p6->k)*p6->amp*cos(p6->rad); + x=p1->amp*sin(p1->rad)+(com->varx[t+i]-p6->k)*p6->amp*sin(p6->rad); + p1->amp=sqrt(r*r+x*x); + p1->rad=atan2(x,r); + j=1; + } + else + { if(p1->next==null) + j=1; + else + p1=p1->next; + } + } + } + + r=com->g[p6->i]*cos(com->b[p6->i])-(com->varx[t+i]-p6->k)*p6->amp*cos(p6->rad);//Yii + x=com->g[p6->i]*sin(com->b[p6->i])-(com->varx[t+i]-p6->k)*p6->amp*sin(p6->rad); + com->g[p6->i]=sqrt(r*r+x*x); + com->b[p6->i]=atan2(x,r); + + r=com->g[p6->j]*cos(com->b[p6->j])-(com->varx[t+i]-p6->k)*p6->amp*cos(p6->rad);//Yjj + x=com->g[p6->j]*sin(com->b[p6->j])-(com->varx[t+i]-p6->k)*p6->amp*sin(p6->rad); + com->g[p6->j]=sqrt(r*r+x*x); + com->b[p6->j]=atan2(x,r); + + p6->k=com->varx[t+i]; //更新变比 + + i=i+1; + p6=p6->next; + } + +/* + FILE *fp1; + fp1=fopen("Text3.txt","wb"); + p1=com->a[1]; + while(p1!=null) + { fprintf(fp1," (%d,%d) %f\n" ,p1->jcol,p1->irow,p1->amp); + p1=p1->next; + } + + p1=com->a[1]; + while(p1!=null) + { fprintf(fp1," (%d,%d) %f\n" ,p1->jcol,p1->irow,p1->rad); + p1=p1->next; + } + fclose(fp1);*/ + + return; +} + +/******计算并确定发电费用曲线(分段型)******/ +void CalPgCoefficient(opf_common * com,double w) //计算并确定发电费用曲线 +{ opf_limit_p *p2; + int i,j; + double x; + + p2=com->head_pg; + i=1; + while(p2!=null) + { j=0; //确定当前所在的段，用j来表示 + x=com->varx[i]; + if((x>=p2->pmin1)&&(x<=p2->pmax1)) + j=1; + if((x>p2->pmax1)&&(xpmin2)) + { if((x-p2->pmax1)<(p2->pmin2-x)) + j=1; + else + j=2; + } + if((x>=p2->pmin2)&&(x<=p2->pmax2)) + j=2; + + if((x>p2->pmax2)&&(xpmin3)) + { if((x-p2->pmax2)<(p2->pmin3-x)) + j=2; + else + j=3; + } + if((x>=p2->pmin3)&&(x<=p2->pmax3)) + j=3; + if(j!=p2->k) + { switch(j) + { case 1: + { com->fa0[i]=p2->fa01; + com->fa1[i]=p2->fa11; + com->fa2[i]=p2->fa21; + com->fa3[i]=p2->fa31; + com->fa4[i]=p2->fa41; + p2->k=1; + break; + } + case 2: + { com->fa0[i]=p2->fa02; + com->fa1[i]=p2->fa12; + com->fa2[i]=p2->fa22; + com->fa3[i]=p2->fa32; + com->fa4[i]=p2->fa42; + p2->k=2; + break; + } + case 3: + { com->fa0[i]=p2->fa03; + com->fa1[i]=p2->fa13; + com->fa2[i]=p2->fa23; + com->fa3[i]=p2->fa33; + com->fa4[i]=p2->fa43; + p2->k=3; + break; + } + default: + break; + } + } + + i=i+1; + p2=p2->next; + } + + if((w<=0.001)&&(w<=com->e*100)) //根据收敛的情况修改不等式约束边界 + { i=1; + p2=com->head_pg; + while(p2!=null) + { switch(p2->k) + { case 1: + { com->gmin[i]=p2->pmin1; + com->gmax[i]=p2->pmax1; + break; + } + case 2: + { com->gmin[i]=p2->pmin2; + com->gmax[i]=p2->pmax2; + break; + } + case 3: + { com->gmin[i]=p2->pmin3; + com->gmax[i]=p2->pmax3; + break; + } + default: + break; + } + + p2=p2->next; + i=i+1; + } + } +} + +/******检测变量越限情况******/ +void CheckLimit(opf_common *com) //检测变量越限情况，|z|>1越下限；|w|>1越上限 +{ + int i,j,k,t; + + opf_gij *p2; + opf_vpdqd *p5; + opf_gpcd *p7; + opf_dcbus *p9; + + opf_error *p10; + + int mm,rr,rv,rlpij,rlqij,rlsij,rliij,rvpd,rvqd,rspij,rsqij,rpg,rqg,rpd,rqd,rk,rkb,rt,rx,rp,rq,rrr,rlcos,rvdcos,req,n_dc,rgpcd; + + mm=com->n_sum; + rr=com->rr; + rv=com->rv; + rlpij=com->rlpij; + rlqij=com->rlqij; + rlsij=com->rlsij; + rliij=com->rliij; + rvpd=com->rvpd; + rvqd=com->rvqd; + rspij=com->rspij; + rsqij=com->rsqij; + rpg=com->rpg; + rqg=com->rqg; + rpd=com->rpd; + rqd=com->rqd; + rk=com->rk; + rkb=com->rkb; + rt=com->rt; + rx=com->rx; + rp=com->rp; + rq=com->rq; + rrr=com->rrr; + rlcos=com->rlcos; + req=com->req; + n_dc=com->n_dc; + rgpcd=com->rgpcd; + rvdcos=com->rvdcos; + + for(i=1;i<=rpg;i++) //检查发电机有功出力是否越限 + { if(fabs(com->varz[i])>2) //下限检查 + { j=com->opt_list[com->gp[i]]; + p10=(opf_error *)malloc(leerror); + sprintf(p10->str,"warning:The active power of No.%d generator is beyond the lower limit or on the lower limit",j);//第%d节点发电机有功越下限或在下限。 + p10->next=null; + com->head_error=AddErrorWord(p10,com->head_error); + } + if(fabs(com->varw[i])>2) //上限检查 + { j=com->opt_list[com->gp[i]]; + p10=(opf_error *)malloc(leerror); + sprintf(p10->str,"warning:The active power of No.%d generator is beyond the upper limit or on the upper limit",j);//第%d节点发电机有功上限或在上限。 + p10->next=null; + com->head_error=AddErrorWord(p10,com->head_error); + } + } + + k=rpg; + for(i=1;i<=rpd;i++) //检查负荷有功是否越限 + { if(fabs(com->varz[i+k])>2) + { j=com->opt_list[com->gp[i+k]]; + p10=(opf_error *)malloc(leerror); + sprintf(p10->str,"warning:The active power of No.%d load is beyond the lower limit or on the lower limit",j);//第%d节点负荷有功越下限或在下限 + p10->next=null; + com->head_error=AddErrorWord(p10,com->head_error); + } + if(fabs(com->varw[i+k])>2) //上限检查 + { j=com->opt_list[com->gp[i+k]]; + p10=(opf_error *)malloc(leerror); + sprintf(p10->str,"warning:The active power of No.%d load is beyond the upper limit or on the upper limit",j);//第%d节点负荷有功上限或在上限。 + p10->next=null; + com->head_error=AddErrorWord(p10,com->head_error); + } + } + + k=rp; + for(i=1;i<=rqg;i++) //检查发电机无功是否越限 + { if(fabs(com->varz[i+k])>2) + { j=com->opt_list[com->gq[i]]; + p10=(opf_error *)malloc(leerror); + sprintf(p10->str,"warning:The reactive power of No.%d generator is beyond the lower limit or on the lower limit",j);//第%d节点发电机无功越下限或在下限 + p10->next=null; + com->head_error=AddErrorWord(p10,com->head_error); + } + if(fabs(com->varw[i+k])>2) //上限检查 + { j=com->opt_list[com->gq[i]]; + p10=(opf_error *)malloc(leerror); + sprintf(p10->str,"warning:The reactive power of No.%d generator is beyond the upper limit or on the upper limit",j);//第%d节点发电机无功上限或在上限。 + p10->next=null; + com->head_error=AddErrorWord(p10,com->head_error); + } + } + + k=rp+rqg; + for(i=1;i<=rqd;i++) //检查负荷无功是否越限 + { if(fabs(com->varz[i+k])>2) + { j=com->opt_list[com->gq[i+rqg]]; + p10=(opf_error *)malloc(leerror); + sprintf(p10->str,"warning:The reactive power of No.%d load is beyond the lower limit or on the lower limit",j);//第%d节点发电机无功越下限或在下限 + p10->next=null; + com->head_error=AddErrorWord(p10,com->head_error); + } + if(fabs(com->varw[i+k])>2) //上限检查 + { j=com->opt_list[com->gq[i+rqg]]; + p10=(opf_error *)malloc(leerror); + sprintf(p10->str,"warning:The reactive power of No.%d load is beyond the upper limit or on the upper limit",j);//第%d节点发电机无功上限或在上限。 + p10->next=null; + com->head_error=AddErrorWord(p10,com->head_error); + } + } + + k=rp+rq+rk+2*rkb+rt+rx+2*rlcos+rvdcos; + for(i=1;i<=n_dc;i++) //检查直流节点电压是否越限 + { if(fabs(com->varz[i+k])>2) + { j=i; + p10=(opf_error *)malloc(leerror); + sprintf(p10->str,"warning:The voltage on No.%d DC node is beyond the lower limit or on the lower limit",j);//第%d节点直流电压越下限或在下限 + p10->next=null; + com->head_error=AddErrorWord(p10,com->head_error); + } + if(fabs(com->varw[i+k])>2) //上限检查 + { j=i; + p10=(opf_error *)malloc(leerror); + sprintf(p10->str,"warning:The voltage on No.%d DC node is beyond the upper limit or on the upper limit",j);//第%d节点直流电压上限或在上限。 + p10->next=null; + com->head_error=AddErrorWord(p10,com->head_error); + } + } + + k=rp+rq+rk+2*rkb+rt+rx+2*rlcos+rvdcos+n_dc; + for(i=1;i<=n_dc;i++) //检查直流节点电流是否越限 + { if(fabs(com->varz[i+k])>2) + { j=i; + p10=(opf_error *)malloc(leerror); + sprintf(p10->str,"warning:The current on No.%d DC node is beyond the lower limit or on the lower limit",j);//第%d节点直流电流越下限或在下限 + p10->next=null; + com->head_error=AddErrorWord(p10,com->head_error); + } + if(fabs(com->varw[i+k])>2) //上限检查 + { j=i; + p10=(opf_error *)malloc(leerror); + sprintf(p10->str,"warning:The current on No.%d DC node is beyond the upper limit or on the upper limit",j);//第%d节点直流电流上限或在上限。 + p10->next=null; + com->head_error=AddErrorWord(p10,com->head_error); + } + } + + k=rr-rv; + for(i=1;i<=mm;i++) //检查交流节点电压是否越限 + { if(fabs(com->varz[i+k])>2) + { j=com->opt_list[i]; + p10=(opf_error *)malloc(leerror); + sprintf(p10->str,"warning:The voltage on No.%d AC node is beyond the lower limit or on the lower limit",j);//第%d节点交流节点电压越下限或在下限 + p10->next=null; + com->head_error=AddErrorWord(p10,com->head_error); + } + if(fabs(com->varw[i+k])>2) //上限检查 + { j=i; + p10=(opf_error *)malloc(leerror); + sprintf(p10->str,"warning:The voltage on No.%d AC node is beyond the upper limit or on the upper limit",j);//第%d节点交流节点电压上限或在上限。 + p10->next=null; + com->head_error=AddErrorWord(p10,com->head_error); + } + } + + k=rr; + i=1; + p2=com->head_lpij; //检查联络线有功功率是否越限 + while(p2!=null) + { if(fabs(com->varz[i+k])>2) + { j=com->opt_list[p2->i]; + t=com->opt_list[p2->j]; + p10=(opf_error *)malloc(leerror); + sprintf(p10->str,"warning:The active power of the branche between No.%d node and No.%d node is beyond the lower limit or on the lower limit",j,t);//第jt节点联络线有功功率越下限或在下限 + p10->next=null; + com->head_error=AddErrorWord(p10,com->head_error); + } + if(fabs(com->varw[i+k])>2) //上限检查 + { j=com->opt_list[p2->i]; + t=com->opt_list[p2->j]; + p10=(opf_error *)malloc(leerror); + sprintf(p10->str,"warning:The active power of the branche between No.%d node and No.%d node is beyond the upper limit or on the upper limit",j,t);//第jt节点联络线有功功率上限或在上限。 + p10->next=null; + com->head_error=AddErrorWord(p10,com->head_error); + } + i=1+1; + p2=p2->next; + } + + k=rr+rlpij; + i=1; + p2=com->head_lqij; //检查联络线无功功率是否越限 + while(p2!=null) + { if(fabs(com->varz[i+k])>2) + { j=com->opt_list[p2->i]; + t=com->opt_list[p2->j]; + p10=(opf_error *)malloc(leerror); + sprintf(p10->str,"warning:The reactive power of the branche between No.%d node and No.%d node is beyond the lower limit or on the lower limit",j,t);//第jt节点联络线无功功率越下限或在下限 + p10->next=null; + com->head_error=AddErrorWord(p10,com->head_error); + } + if(fabs(com->varw[i+k])>2) //上限检查 + { j=com->opt_list[p2->i]; + t=com->opt_list[p2->j]; + p10=(opf_error *)malloc(leerror); + sprintf(p10->str,"warning:The reactive power of the branche between No.%d node and No.%d node is beyond the upper limit or on the upper limit",j,t);//第jt节点联络线无功功率上限或在上限。 + p10->next=null; + com->head_error=AddErrorWord(p10,com->head_error); + } + i=1+1; + p2=p2->next; + } + + k=rr+rlpij+rlqij; + i=1; + p2=com->head_lsij; //检查联络线容量是否越限 + while(p2!=null) + { if(fabs(com->varz[i+k])>2) + { j=com->opt_list[p2->i]; + t=com->opt_list[p2->j]; + p10=(opf_error *)malloc(leerror); + sprintf(p10->str,"warning:The capacity of the branche between No.%d node and No.%d node is beyond the lower limit or on the lower limit",j,t);//第jt节点联络线容量越下限或在下限 + p10->next=null; + com->head_error=AddErrorWord(p10,com->head_error); + } + if(fabs(com->varw[i+k])>2) //上限检查 + { j=com->opt_list[p2->i]; + t=com->opt_list[p2->j]; + p10=(opf_error *)malloc(leerror); + sprintf(p10->str,"warning:The capacity of the branche between No.%d node and No.%d node is beyond the upper limit or on the upper limit",j,t);//第jt节点联络线容量上限或在上限。 + p10->next=null; + com->head_error=AddErrorWord(p10,com->head_error); + } + i=1+1; + p2=p2->next; + } + + k=rr+rlpij+rlqij+rlsij; + i=1; + p2=com->head_liij; //检查联络线电流是否越限 + while(p2!=null) + { if(fabs(com->varz[i+k])>2) + { j=com->opt_list[p2->i]; + t=com->opt_list[p2->j]; + p10=(opf_error *)malloc(leerror); + sprintf(p10->str,"warning:The current of the branche between No.%d node and No.%d node is beyond the lower limit or on the lower limit",j,t);//第jt节点电流越下限或在下限 + p10->next=null; + com->head_error=AddErrorWord(p10,com->head_error); + } + if(fabs(com->varw[i+k])>2) //上限检查 + { j=com->opt_list[p2->i]; + t=com->opt_list[p2->j]; + p10=(opf_error *)malloc(leerror); + sprintf(p10->str,"warning:The current of the branche between No.%d node and No.%d node is beyond the upper limit or on the upper limit",j,t);//第jt节点电流上限或在上限。 + p10->next=null; + com->head_error=AddErrorWord(p10,com->head_error); + } + i=1+1; + p2=p2->next; + } + + k=rr+rlpij+rlqij+rlsij+rliij; + i=1; + p5=com->head_vpd; //检查有功负荷模型是否越限 + while(p5!=null) + { if(fabs(com->varz[i+k])>2) + { j=com->opt_list[p5->i]; + p10=(opf_error *)malloc(leerror); + sprintf(p10->str,"warning:The active power of the load related to the voltage on No.%d node is beyond the lower limit or on the lower limit",j);//第j节点有功负荷模型越下限或在下限 + p10->next=null; + com->head_error=AddErrorWord(p10,com->head_error); + } + if(fabs(com->varw[i+k])>2) //上限检查 + { j=com->opt_list[p5->i]; + p10=(opf_error *)malloc(leerror); + sprintf(p10->str,"warning:The active power of the load related to the voltage on No.%d node is beyond the upper limit or on the upper limit",j);//第j节点有功负荷模型上限或在上限。 + p10->next=null; + com->head_error=AddErrorWord(p10,com->head_error); + } + i=1+1; + p5=p5->next; + } + + k=rr+rlpij+rlqij+rlsij+rliij+rvpd; + i=1; + p5=com->head_vqd; //检查无功负荷模型是否越限 + while(p5!=null) + { if(fabs(com->varz[i+k])>2) + { j=com->opt_list[p5->i]; + p10=(opf_error *)malloc(leerror); + sprintf(p10->str,"warning:The reactive power of the load related to the voltage on No.%d node is beyond the lower limit or on the lower limit",j);//第j节点无功负荷模型越下限或在下限 + p10->next=null; + com->head_error=AddErrorWord(p10,com->head_error); + } + if(fabs(com->varw[i+k])>2) //上限检查 + { j=com->opt_list[p5->i]; + p10=(opf_error *)malloc(leerror); + sprintf(p10->str,"warning:The reactive power of the load related to the voltage on No.%d node is beyond the upper limit or on the upper limit",j);//第j节点无功负荷模型上限或在上限。 + p10->next=null; + com->head_error=AddErrorWord(p10,com->head_error); + } + i=1+1; + p5=p5->next; + } + + k=rr+rlpij+rlqij+rlsij+rliij+rvpd+rvqd; + for(i=1;i<=rspij;i++) + { if(fabs(com->varz[i+k])>2) + { j=i; + p10=(opf_error *)malloc(leerror); + sprintf(p10->str,"warning:The active power of the No.%d power_side is beyond the lower limit or on the lower limit",j);//第j个功率断面越下限或在下限 + p10->next=null; + com->head_error=AddErrorWord(p10,com->head_error); + } + if(fabs(com->varw[i+k])>2) //上限检查 + { j=i; + p10=(opf_error *)malloc(leerror); + sprintf(p10->str,"warning:The active power of the No.%d power_side is beyond the upper limit or on the upper limit",j);//第j个功率断面上限或在上限。 + p10->next=null; + com->head_error=AddErrorWord(p10,com->head_error); + } + } + + k=rr+rlpij+rlqij+rlsij+rliij+rvpd+rvqd+rspij; + for(i=1;i<=rsqij;i++) + { if(fabs(com->varz[i+k])>2) + { j=i; + p10=(opf_error *)malloc(leerror); + sprintf(p10->str,"warning:The reactive power of the No.%d power_side is beyond the lower limit or on the lower limit",j);//第j个功率断面越下限或在下限 + p10->next=null; + com->head_error=AddErrorWord(p10,com->head_error); + } + if(fabs(com->varw[i+k])>2) //上限检查 + { j=i; + p10=(opf_error *)malloc(leerror); + sprintf(p10->str,"warning:The reactive power of the No.%d power_side is beyond the upper limit or on the upper limit",j);//第j个功率断面上限或在上限。 + p10->next=null; + com->head_error=AddErrorWord(p10,com->head_error); + } + } + + k=rr+rlpij+rlqij+rlsij+rliij+rvpd+rvqd+rspij+rsqij; + i=1; + p7=com->head_gpcd; //发电机功率园图 + while(p7!=null) + { if(fabs(com->varz[i+k])>2) + { j=com->opt_list[p7->i]; + p10=(opf_error *)malloc(leerror); + sprintf(p10->str,"warning:The capacity of the No.%d power_side is beyond the lower limit or on the lower limit",j);//第j节点的发电机功率原图越下限或在下限 + p10->next=null; + com->head_error=AddErrorWord(p10,com->head_error); + } + if(fabs(com->varw[i+k])>2) //上限检查 + { j=com->opt_list[p7->i]; + p10=(opf_error *)malloc(leerror); + sprintf(p10->str,"warning:he capacity of the No.%d power_side is beyond the upper limit or on the upper limit",j);//第j节点发电机功率原图上限或在上限。 + p10->next=null; + com->head_error=AddErrorWord(p10,com->head_error); + } + p7=p7->next; + i=i+1; + } + + k=rr+rlpij+rlqij+rlsij+rliij+rvpd+rvqd+rspij+rsqij+rgpcd; + p9=com->head_dcbus; //直流功率 + i=1; + while(p9!=null) + { if(fabs(com->varz[i+k])>2) + { j=p9->i; + p10=(opf_error *)malloc(leerror); + sprintf(p10->str,"warning:The DC power of the No.%d is beyond the lower limit or on the lower limit",j);//第j节点的直流功率越下限或在下限 + p10->next=null; + com->head_error=AddErrorWord(p10,com->head_error); + } + if(fabs(com->varw[i+k])>2) //上限检查 + { j=p9->i; + p10=(opf_error *)malloc(leerror); + sprintf(p10->str,"warning:The DC power of the No.%d is beyond the upper limit or on the upper limit",j);//第j节点直流功率越上限或在上限。 + p10->next=null; + com->head_error=AddErrorWord(p10,com->head_error); + } + p9=p9->next; + i=i+1; + } + + return; +} + +/*节点优化编号Tinney_1的号码返回原来的值*/ +void RevertList(opf_common *common,opf_sensitive *sensitive) +{ + int i,j; + + opf_kij *p11; + opf_slack *p12; + opf_limit_v *p9; + opf_gij *p10; + opf_line *p3; + opf_debug *p2; + opf_vpdqd *p4; + opf_gpcd *p5; + opf_sij *p6; + opf_dcbus *p8; + + opf_senobj *p13; + opf_senequ *p14; + opf_seninequ *p15; + + double *tmpx; + + i=common->n_sum; + tmpx=(double *)malloc((i+1)*sizeof(double)); + + + p12=common->head_slack; + while(p12!=null) + { p12->i=common->opt_list[p12->i]; + p12=p12->next; + } + + p3=common->head_lij; //线路部分 + while(p3!=null) + { p3->i=common->opt_list[p3->i]; + p3->j=common->opt_list[p3->j]; + p3=p3->next; + } + + for(i=1;i<=common->rp;i++) + common->gp[i]=common->opt_list[common->gp[i]]; + for(i=1;i<=common->rq;i++) + common->gq[i]=common->opt_list[common->gq[i]]; + + for(i=1;i<=common->n_sum;i++) + tmpx[i]=common->pg[i]; + for(i=1;i<=common->n_sum;i++) + common->pg[common->opt_list[i]]=tmpx[i]; + + for(i=1;i<=common->n_sum;i++) + tmpx[i]=common->pd[i]; + for(i=1;i<=common->n_sum;i++) + common->pd[common->opt_list[i]]=tmpx[i]; + + for(i=1;i<=common->n_sum;i++) + tmpx[i]=common->qg[i]; + for(i=1;i<=common->n_sum;i++) + common->qg[common->opt_list[i]]=tmpx[i]; + + for(i=1;i<=common->n_sum;i++) + tmpx[i]=common->qd[i]; + for(i=1;i<=common->n_sum;i++) + common->qd[common->opt_list[i]]=tmpx[i]; + + p11=common->head_kij; //可调变压器 + while(p11!=null) + { p11->i=common->opt_list[p11->i]; + p11->j=common->opt_list[p11->j]; + p11=p11->next; + } + p11=common->head_kbij; //可调移相器 + while(p11!=null) + { p11->i=common->opt_list[p11->i]; + p11->j=common->opt_list[p11->j]; + p11=p11->next; + } + p11=common->head_ti; //可调电容器 + while(p11!=null) + { p11->i=common->opt_list[p11->i]; + p11->j=common->opt_list[p11->j]; + p11=p11->next; + } + + p11=common->head_kx; //可调线路电抗 + while(p11!=null) + { p11->i=common->opt_list[p11->i]; + p11->j=common->opt_list[p11->j]; + p11=p11->next; + } + + p9=common->head_v; + while(p9!=null) //记录约束节点电压号 + { p9->i=common->opt_list[p9->i]; + p9=p9->next; + } + + p10=common->head_lcos; //记录线路功率因数限制的个数 + while(p10!=null) + { p10->i=common->opt_list[p10->i]; + p10->j=common->opt_list[p10->j]; + p10=p10->next; + } + + p10=common->head_vdcos; //记录负荷模型功率因数限制的个数 + while(p10!=null) + { p10->i=common->opt_list[p10->i]; + p10->j=common->opt_list[p10->j]; + p10=p10->next; + } + + p10=common->head_lpij; //记录线路功率有功限制的个数 + while(p10!=null) + { p10->i=common->opt_list[p10->i]; + p10->j=common->opt_list[p10->j]; + p10=p10->next; + } + + p10=common->head_lqij; //记录线路功率无功限制的个数 + while(p10!=null) + { p10->i=common->opt_list[p10->i]; + p10->j=common->opt_list[p10->j]; + p10=p10->next; + } + + p10=common->head_lsij; //记录线路容量限制的个数 + while(p10!=null) + { p10->i=common->opt_list[p10->i]; + p10->j=common->opt_list[p10->j]; + p10=p10->next; + } + + p10=common->head_liij; //记录线路电流限制的个数 + while(p10!=null) + { p10->i=common->opt_list[p10->i]; + p10->j=common->opt_list[p10->j]; + p10=p10->next; + } + + p10=common->head_liij0; //记录原线路电流限制的个数 + while(p10!=null) + { p10->i=common->opt_list[p10->i]; + p10->j=common->opt_list[p10->j]; + p10=p10->next; + } + + p4=common->head_vpd; //有功负荷模型 + while(p4!=null) + { p4->i=common->opt_list[p4->i]; + p4=p4->next; + } + + p4=common->head_vqd; //无功负荷模型 + while(p4!=null) + { p4->i=common->opt_list[p4->i]; + p4=p4->next; + } + + p6=common->head_sij; //断面功率集合 + while(p6!=null) + { p6->i=common->opt_list[p6->i]; + p6->j=common->opt_list[p6->j]; + p6=p6->next; + } + + p6=common->head_obsij; //目标断面功率集合 + while(p6!=null) + { p6->i=common->opt_list[p6->i]; + p6->j=common->opt_list[p6->j]; + p6=p6->next; + } + + p5=common->head_gpcd; //发电机功率园图 + while(p5!=null) + { p5->i=common->opt_list[p5->i]; + p5=p5->next; + } + + p8=common->head_dcbus; // 直流数据 + while(p8!=null) + { p8->iac=common->opt_list[p8->iac]; + p8=p8->next; + } + + j=common->rr-common->rv; + for(i=1;i<=common->n_sum;i++) + { common->rad[common->opt_list[i]]=common->varx[j+2*i-1]; + common->v[common->opt_list[i]]=common->varx[j+2*i]; + } + for(i=1;i<=common->n_sum;i++) + { common->varx[j+2*i-1]=common->rad[i]; + common->varx[j+2*i]=common->v[i]; + } + + p2=common->head_debugpq; + while(p2!=null) + { p2->i=common->opt_list[p2->i]; + p2->j=common->opt_list[p2->j]; + p2=p2->next; + } + + p13=sensitive->senobj; + while(p13!=null) + { p13->var_i=common->opt_list[p13->var_i]; + p13->var_j=common->opt_list[p13->var_j]; + p13=p13->next; + } + + p14=sensitive->senequ; + while(p14!=null) + { p14->var_i=common->opt_list[p14->var_i]; + p14->var_j=common->opt_list[p14->var_j]; + p14->equ_i=common->opt_list[p14->equ_i]; + p14->equ_j=common->opt_list[p14->equ_j]; + p14=p14->next; + } + + p15=sensitive->seninequ; + while(p15!=null) + { p15->var_i=common->opt_list[p15->var_i]; + p15->var_j=common->opt_list[p15->var_j]; + p15->inequ_i=common->opt_list[p15->inequ_i]; + p15->inequ_j=common->opt_list[p15->inequ_j]; + p15=p15->next; + } + + j=common->rr-common->rv; + for(i=1;i<=common->n_sum;i++) + tmpx[i]=common->gmin[j+i]; + for(i=1;i<=common->n_sum;i++) + common->gmin[j+common->opt_list[i]]=tmpx[i]; + for(i=1;i<=common->n_sum;i++) + tmpx[i]=common->gmax[j+i]; + for(i=1;i<=common->n_sum;i++) + common->gmax[j+common->opt_list[i]]=tmpx[i]; + +/*是算个数的不是节点号的 + p2=common->head_debuglcos; + while(p2!=null) + { p2->i=common->opt_list[p2->i]; + p2->j=common->opt_list[p2->j]; + p2=p2->next; + }*/ + + + free(tmpx); + return; +} + +/*将结果打印到Text1上*/ +void PrintResult(char *filename,opf_common *common,int kk,int iterativetime,int flag) +{ + FILE *fp; + char *str,*str1; + + opf_error *p3; + opf_gij *p2; + opf_debug *p5; + opf_kij *p6; + opf_vpdqd *p7; + opf_dcbus *p8; + opf_gpcd *p9; + opf_limit_v *p15; + +// struct outlimit *p10; + int i,j,t; + double r,x; + + switch(common->obj_type0) + { case 1: //煤耗 + { str="Floss"; + break; + } + case 2: //有功出力最小 + { str="P"; + break; + } + case 3: //无功出力最小 + { str="Q"; + break; + } + case 4: //支路有功损耗最小 + { str="Ploss"; + break; + } + case 5: //支路无功损耗最小 + { str="Qloss"; + break; + } + case 6: //线路有功损耗最小 + { str="Plossxl"; + break; + } + case 7: //线路无功损耗最小 + { str="Qlossxl"; + break; + } + case 8: //电压越限最小 + { str="V"; + break; + } + case 9: //有功网损 + { str="PG-PD"; + break; + } + case 10: //无功网损 + { str="QG-QD"; + break; + } + case 11: //电容/电抗调节最小 + { str="t"; + break; + } + case 12: //负荷功率调节最小 + { str="w(PDi-PDi0)(PDi-PDi0)"; + break; + } + case 13: //断面有功功率调节最小 + { str="SPij"; + break; + } + case 14: //机组无功备用最大 + { str="-w(QGimax-QGi)"; + break; + } + case 15: //机组有功调节最小 + { str="w(PGi-PGi0)(PGi-PGi0)"; + break; + } + case 16: //机组无功调节最小 + { str="w(QGi-QGi0)(QGi-QGi0)"; + break; + } + default: + { str="error"; + break; + } + } + + switch(kk) + { case 0: //收敛 + { str1="收敛"; + break; + } + case 1: //不收敛不发散 + { str1="不收敛不发散"; + break; + } + case 2: //不收敛，发散 + { str1="不收敛，发散"; + break; + } + default: + { str1="error"; + break; + } + } + + fp=fopen(filename,"wb"); + fprintf(fp,"%s%d%s%s\n" ,"计算",common->n_sum,"系统 ",str); + fprintf(fp,"\n"); + fprintf(fp,"%s%s %s%d\n" ,"收敛情况：",str1,"迭代次数：",common->itera_num); + fprintf(fp,"\n"); + + if(flag==0) + { fclose(fp); + return; + } + + fprintf(fp,"%s%f\n" ,"原始目标值：",common->ini_obj); + fprintf(fp,"\n"); + fprintf(fp,"%s%f\n" ,"最终目标值：",common->fin_obj); + fprintf(fp,"\n"); + fprintf(fp,"%s %s %s\n" ,"迭代次数","gap",str); + p5=common->head_debuggap; + while(p5!=null) + { fprintf(fp," %d, %f, %f\n" ,p5->i,p5->x,p5->y); + p5=p5->next; + } + fprintf(fp,"\n"); + + fprintf(fp,"%s %s %s %s %s\n" ,"迭代次数","有功节点","maxdp","无功节点","maxdq"); + p5=common->head_debugpq; + i=1; + while(p5!=null) + { fprintf(fp," %d, %d, %f, %d, %f\n" ,i,p5->i,p5->x,p5->j,p5->y); + i=i+1; + p5=p5->next; + } + + fprintf(fp,"%s %s %s\n" ,"迭代次数","节点i","maxHeq"); + p5=common->head_debuglcos; + i=1; + while(p5!=null) + { fprintf(fp," %d, %d, %f\n" ,i,p5->i,p5->x); + i=i+1; + p5=p5->next; + } + + fprintf(fp,"\n"); + fprintf(fp," %s, %s\n" ,"节点号","发电机有功出力"); + for(i=1;i<=common->rpg;i++) + fprintf(fp," %d, %d, %f, %f\n" ,i,common->gp[i],common->varx[i],common->pg_int[i]); + fprintf(fp,"\n"); + fprintf(fp," %s, %s\n" ,"节点号","节点有功出力"); + for(i=1;i<=common->rpge;i++) //序号，节点号，节点有功偏差 + fprintf(fp," %d, %d, %f\n" ,i,common->gp[i+common->rpg],common->varx[i+common->rpg]); + fprintf(fp,"\n"); //分隔符0 + fprintf(fp," %s, %s\n" ,"节点号","发电机有功负荷"); + for(i=1;i<=common->rpd;i++) + fprintf(fp," %d, %d, %f\n" ,i,common->gp[common->rpg+i],common->varx[common->rpg+i]); + fprintf(fp,"\n"); + fprintf(fp," %s, %s\n" ,"节点号","发电机无功出力"); + for(i=1;i<=common->rqg;i++) + fprintf(fp," %d, %d, %f, %f, %f, %f\n" ,i,common->gq[i],common->varx[i+common->rp],common->v[common->gq[i]],common->gmin[common->rp+i],common->gmax[common->rp+i]); + fprintf(fp,"\n"); + fprintf(fp," %s, %s\n" ,"节点号","节点无功出力"); + for(i=1;i<=common->rqge;i++) //序号，节点号，节点无功偏差 + fprintf(fp," %d, %d, %f\n" ,i,common->gq[i+common->rqg],common->varx[i+common->rp+common->rqg]); + fprintf(fp,"\n"); //分隔符0 + fprintf(fp," %s, %s\n" ,"节点号","发电机无功负荷"); + for(i=1;i<=common->rqd;i++) + fprintf(fp," %d, %d, %f\n" ,i,common->gq[common->rqg+i],common->varx[i+common->rp+common->rqg]); + fprintf(fp,"\n"); + fprintf(fp," %s\n" ,"节点状态变量数据"); + fprintf(fp," %s, %s, %s\n" ,"节点号","电压","相角"); + for(i=1;i<=common->n_sum;i++) + fprintf(fp," %d, %f, %f, %f, %f\n" ,i,common->v[i],common->rad[i],common->gmin[common->rr-common->rv+i],common->gmax[common->rr-common->rv+i]); + fprintf(fp,"\n"); + + fprintf(fp," %s, %s\n" ,"节点号","电压"); + i=1; + p15=common->head_v; + while(p15!=null) + { fprintf(fp," %d, %f, %f, %f\n" ,p15->i,common->v[p15->i],p15->vmin,p15->vmax); + p15=p15->next; + i=i+1; + } + fprintf(fp,"\n"); + + i=1; + fprintf(fp," %s\n" ,"可调变压器数据"); + fprintf(fp," %s, %s, %s\n" ,"首节点号","尾节点号","k"); + j=common->rp+common->rq; + p6=common->head_kij; + while(p6!=null) + { fprintf(fp," %d, %d, %d, %f\n" ,i,p6->i,p6->j,1/common->varx[j+i]); + i=i+1; + p6=p6->next; + } + fprintf(fp,"\n"); + i=1; + fprintf(fp," %s\n" ,"可调移相器数据"); + fprintf(fp," %s, %s, %s, %s\n" ,"首节点号","尾节点号","k","b"); + j=common->rp+common->rq+common->rk; + p6=common->head_kbij; + while(p6!=null) + { fprintf(fp," %d, %d, %d, %f, %f\n" ,i,p6->i,p6->j,1/common->varx[j+i],-common->varx[j+i+common->rkb]); + i=i+1; + p6=p6->next; + } + fprintf(fp,"\n"); + i=1; + fprintf(fp," %s\n" ,"可调电容or电抗器数据"); + fprintf(fp," %s, %s\n" ,"节点号","t"); + j=common->rp+common->rq+common->rk+2*common->rkb; + p6=common->head_ti; + while(p6!=null) + { fprintf(fp," %d, %d, %f\n" ,i,p6->i,common->varx[j+i]); + i=i+1; + p6=p6->next; + } + fprintf(fp,"\n"); + + i=1; + fprintf(fp," %s\n" ,"可调线路电抗数据"); + fprintf(fp," %s, %s, %s, %s\n" ,"节点号","kx","r","x"); + p6=common->head_kx; + while(p6!=null) + { r=1/(p6->k*p6->amp)*cos(-p6->rad); + x=1/(p6->k*p6->amp)*sin(-p6->rad); + fprintf(fp," %d, %d, %d, %f, %f, %f, %f, %f\n" ,i,p6->i,p6->j,1/p6->k,-r,-x,p6->p,p6->q); + i=i+1; + p6=p6->next; + } + fprintf(fp,"\n"); + + i=1; + fprintf(fp," %s\n" ,"线路功率因数数据"); + fprintf(fp," %s, %s\n" ,"节点号","lcos"); + j=common->rp+common->rq+common->rk+2*common->rkb+common->rt+common->rx; + p2=common->head_lcos; + while(p2!=null) + { fprintf(fp," %d, %d, %f\n" ,p2->i,p2->j,p2->g); + i=i+1; + p2=p2->next; + } + fprintf(fp,"\n"); + + i=1; + fprintf(fp," %s\n" ,"负荷模型功率因数数据"); + fprintf(fp," %s, %s\n" ,"节点号","vdcos"); + j=common->rp+common->rq+common->rk+2*common->rkb+common->rt+common->rx+2*common->rlcos; + p2=common->head_vdcos; + while(p2!=null) + { fprintf(fp," %d, %d, %f\n" ,p2->i,p2->j,p2->g); + i=i+1; + p2=p2->next; + } + fprintf(fp,"\n"); + + i=1; + fprintf(fp," %s\n" ,"线路有功功率数据"); + fprintf(fp," %s, %s, %s, %s, %s\n" ,"首节点号","尾节点号","pij","pijmin","pijmax"); + p2=common->head_lpij; //支路有功 + while(p2!=null) + { j=common->rr+i; + fprintf(fp," %d, %d, %d, %f, %f, %f\n" ,i,p2->i,p2->j,common->gvalue[j],common->gmin[j],common->gmax[j]); + p2=p2->next; + i=i+1; + } + fprintf(fp,"\n"); + + i=1; + fprintf(fp," %s\n" ,"线路无功功率数据"); + fprintf(fp," %s, %s, %s, %s, %s\n" ,"首节点号","尾节点号","qij","qijmin","qijmax"); + p2=common->head_lqij; //支路无功 + while(p2!=null) + { + j=common->rr+common->rlpij+i; + fprintf(fp," %d, %d, %d, %f, %f, %f\n" ,i,p2->i,p2->j,common->gvalue[j],common->gmin[j],common->gmax[j]); + p2=p2->next; + i=i+1; + } + fprintf(fp,"\n"); + + i=1; + fprintf(fp," %s\n" ,"线路视在功率数据"); + fprintf(fp," %s, %s, %s, %s, %s\n" ,"首节点号","尾节点号","sij","sijmin","sijmax"); + p2=common->head_lsij; //支路容量 + while(p2!=null) + { j=common->rr+common->rlpij+common->rlqij+i; + fprintf(fp," %d, %d, %d, %f, %f, %f\n" ,i,p2->i,p2->j,common->gvalue[j],common->gmin[j],common->gmax[j]); + p2=p2->next; + i=i+1; + } + + i=1; + fprintf(fp," %s\n" ,"线路电流限制数据"); + fprintf(fp," %s, %s, %s, %s, %s\n" ,"首节点号","尾节点号","iij","iijmin","iijmax"); + p2=common->head_liij; //支路电流 + while(p2!=null) + { j=common->rr+common->rlpij+common->rlqij+common->rlsij+i; + fprintf(fp," %d, %d, %d, %f, %f, %f\n" ,i,p2->i,p2->j,common->gvalue[j],common->gmin[j],common->gmax[j]); + p2=p2->next; + i=i+1; + } + + i=1; //监控线路电流数据 + fprintf(fp," %s\n" ,"线路电流数据"); + p2=common->head_liij0; //支路电流 + while(p2!=null) + { r=sqrt(p2->g); + fprintf(fp," %d, %d, %d, %f, %f, %f, %f\n" ,i,p2->i,p2->j,r,p2->gmin,p2->gmax,p2->gmax-r); + p2=p2->next; + i=i+1; + } + fprintf(fp,"%d\n",0); //分隔符0 + + i=1; + fprintf(fp," %s\n" ,"负荷模型数据"); + fprintf(fp," %s, %s, %s\n" ,"首节点号","vPD","Ui"); + p7=common->head_vpd; //有功负荷模型 + while(p7!=null) + { x=p7->a*pow(common->v[p7->i],2)+p7->b*common->v[p7->i]+p7->c; + fprintf(fp," %d, %d, %f, %f\n" ,i,p7->i,x,common->v[p7->i]); + p7=p7->next; + i=i+1; + } + + i=1; + fprintf(fp," %s, %s, %s\n" ,"首节点号","vQD","Ui"); + p7=common->head_vqd; //无功负荷模型 + while(p7!=null) + { x=p7->a*pow(common->v[p7->i],2)+p7->b*common->v[p7->i]+p7->c; + fprintf(fp," %d, %d, %f, %f\n" ,i,p7->i,x,common->v[p7->i]); + p7=p7->next; + i=i+1; + } + + i=1; //断面有功 + fprintf(fp," %s, %s, %s\n" ,"序号","断面号","&Pij"); + p2=common->head_spij; + while(p2!=null) + { j=common->rr+common->rlpij+common->rlqij+common->rlsij+common->rliij+common->rvpd+common->rvqd+i; + fprintf(fp," %d, %d, %f, %f, %f\n" ,i,p2->i,common->gvalue[j],common->gmin[j],common->gmax[j]); + p2=p2->next; + i=i+1; + } + + i=1; //断面无功 + fprintf(fp," %s, %s, %s\n" ,"序号","断面号","&Qij"); + p2=common->head_sqij; + while(p2!=null) + { j=common->rr+common->rlpij+common->rlqij+common->rlsij+common->rliij+common->rvpd+common->rvqd+common->rspij+i; + fprintf(fp," %d, %d, %f, %f, %f\n" ,i,p2->i,common->gvalue[j],common->gmin[j],common->gmax[j]); + p2=p2->next; + i=i+1; + } + + i=1; //发电机功率图 + fprintf(fp," %s, %s, %s\n" ,"序号","节点号","Gi"); + p9=common->head_gpcd; + while(p2!=null) + { j=common->rr+common->rlpij+common->rlqij+common->rlsij+common->rliij+common->rvpd+common->rvqd+common->rspij+common->rsqij+i; + fprintf(fp," %d, %d, %f, %f, %f\n" ,i,p9->i,common->gvalue[j],common->gmin[j],common->gmax[j]); + p2=p2->next; + i=i+1; + } + + i=1; + t=common->rp+common->rq+common->rk+2*common->rkb+common->rt+common->rx+2*common->rlcos+common->rvdcos; + fprintf(fp," %s\n" ,"直流数据"); + fprintf(fp," %s, %s, %s, %s, %s, %s, %s\n" ,"序号","节点号","Vdi","Idi","kdi","cosdi","fardi"); + p8=common->head_dcbus; + while(p8!=null) + { fprintf(fp," %d, %d, %f, %f, %f, %f, %f\n" ,i,p8->i,common->varx[t+i],common->varx[t+i+common->n_dc],common->varx[t+i+2*common->n_dc],common->varx[t+i+3*common->n_dc],common->varx[t+i+4*common->n_dc]); + p8=p8->next; + i=i+1; + } + + i=1; + fprintf(fp," %s\n" ,"直流数据"); //将功率直流数据 + fprintf(fp," %s, %s, %s,\n" ,"序号","节点号","Pi"); + p8=common->head_dcbus; + while(p8!=null) + { j=common->rr+common->rlpij+common->rlqij+common->rlsij+common->rliij+common->rvpd+common->rvqd+common->rspij+common->rsqij+common->rgpcd+i; + fprintf(fp," %d, %d, %f, %f, %f\n" ,i,p8->i,common->gvalue[j],common->gmin[j],common->gmax[j]); + p8=p8->next; + i=i+1; + } + + +/* + i=1; + p10=outlimit_v; + fprintf(fp," %s, %s, %s, %s, %s\n" ,"序号","节点号","type","limitesetting","currentvalue"); + while(p10!=null) + { fprintf(fp," %d, %d, %d, %f, %f\n" ,i,p10->i,p10->type,p10->limitesetting,p10->currentvalue); + i=i+1; + p10=p10->next; + } + fprintf(fp,"\n");*/ + + +/* + i=1; + p10=outlimit_branch; + fprintf(fp," %s, %s, %s, %s %s, %s\n" ,"序号","首节点号","尾节点号","type","limitesetting","currentvalue"); + while(p10!=null) + { fprintf(fp," %d, %d, %d, %d, %f, %f\n" ,i,p10->i,p10->j,p10->type,p10->limitesetting,p10->currentvalue); + i=i+1; + p10=p10->next; + } + fprintf(fp,"\n");*/ + + + + i=1; + p3=common->head_error; + fprintf(fp," %s, %s\n" ,"序号","error"); + while(p3!=null) + { fprintf(fp," %d, %s\n" ,i,p3->str); + i=i+1; + p3=p3->next; + } + fprintf(fp,"\n"); + + +/* + fprintf(fp," %s, %s\n" ,"迭代次数","每次迭代时间"); + for(i=1;i<=3;i++) + fprintf(fp," %d, %d\n" ,i,iterative_time[i]); + + fprintf(fp,"\n");*/ + + + for(i=1;i<=common->rpg;i++) //发电机有功出力 + common->pg[common->gp[i]]=common->varx[i]; + for(i=1;i<=common->rpd;i++)//发电机有功负荷 + common->pd[common->gp[common->rpg+common->rpge+i]]=common->varx[common->rpg+common->rpge+i]; + for(i=1;i<=common->rqg;i++)//发电机无功出力 + common->qg[common->gq[i]]=common->varx[i+common->rp]; + for(i=1;i<=common->rqd;i++)//发电机无功负荷 + common->qd[common->gq[common->rqg+common->rqge+i]]=common->varx[i+common->rp+common->rqge+common->rqg]; + + + fprintf(fp," %s, %d\n" ,"总时间",iterativetime); + + fclose(fp); + return; +} + +/*将结果打印到result.txt上*/ +void PrintResultData(char *filename,opf_common *common,int kk,int iterativetime,int flag) +{ + FILE *fp; + + opf_gij *p2; + opf_kij *p6; + opf_vpdqd *p7; + opf_dcbus *p8; + + int i,j,t; + double r,x; + + fp=fopen(filename,"wb"); + fprintf(fp,"%d\n",kk); //收敛情况,0收敛，1不收敛不发散，2不收敛，发散 + fprintf(fp,"%d\n",0); //分隔符0 + + fprintf(fp,"%d,%d,%d,%f,%f,%f\n",common->n_sum,common->obj_type0,common->itera_num,common->fin_obj,common->ininetloss,common->endnetloss);//节点数，目标函数模型，迭代次数，目标函数值，最初网损值，最终网损值 + fprintf(fp,"%d\n" ,0); //分隔符0 + + for(i=1;i<=common->rpg;i++) + fprintf(fp,"%d,%d,%f\n" ,i,common->gp[i],common->pg_int[i]); //序号，节点号，发电机有功出力 + fprintf(fp,"%d\n",0); //分隔符0 + + for(i=1;i<=common->rpd;i++) + fprintf(fp,"%d,%d,%f\n",i,common->gp[common->rpg+common->rpge+i],common->varx[common->rpg+common->rpge+i]); //序号，节点号，有功负荷（线性） + fprintf(fp,"%d\n",0); //分隔符0 + + i=1; + p7=common->head_vpd; //有功负荷模型 + while(p7!=null) + { x=p7->a*pow(common->v[p7->i],2)+p7->b*common->v[p7->i]+p7->c; + fprintf(fp,"%d,%d,%f,%f\n" ,i,p7->i,x,common->v[p7->i]); //序号，节点号，有功负荷（负荷模型），节点电压 + p7=p7->next; + i=i+1; + } + fprintf(fp,"%d\n",0); //分隔符0 + + for(i=1;i<=common->rqg;i++) //序号，节点号，发电机无功出力 + fprintf(fp,"%d,%d,%f,%f\n" ,i,common->gq[i],common->varx[i+common->rp],common->v[common->gq[i]]); + fprintf(fp,"%d\n",0); //分隔符0 + + for(i=1;i<=common->rqd;i++) //序号，节点号，无功负荷（线性） + fprintf(fp,"%d,%d,%f\n" ,i,common->gq[common->rqg+common->rqge+i],common->varx[i+common->rp+common->rqg+common->rqge]); + fprintf(fp,"%d\n",0); //分隔符0 + + i=1; + p7=common->head_vqd; //无功负荷模型 + while(p7!=null) + { x=p7->a*pow(common->v[p7->i],2)+p7->b*common->v[p7->i]+p7->c; + fprintf(fp,"%d,%d,%f,%f\n" ,i,p7->i,x,common->v[p7->i]); //序号，节点号，无功负荷（负荷模型），节点电压 + p7=p7->next; + i=i+1; + } + fprintf(fp,"%d\n",0); //分隔符0 + + for(i=1;i<=common->n_sum;i++) + fprintf(fp,"%d,%d,%f,%f\n" ,i,i,common->v[i],common->rad[i]); //序号，节点号，电压幅值，相角 + fprintf(fp,"%d\n",0); //分隔符0 + + i=1; + j=common->rp+common->rq; + p6=common->head_kij; + while(p6!=null) + { fprintf(fp,"%d,%d,%d,%f\n" ,i,p6->i,p6->j,1/common->varx[j+i]); //序号，首节点，末节点，可调变压器变比 + i=i+1; + p6=p6->next; + } + fprintf(fp,"%d\n",0); //分隔符0 + + i=1; + j=common->rp+common->rq+common->rk; + p6=common->head_kbij; + while(p6!=null) + { fprintf(fp,"%d,%d,%d,%f,%f\n" ,i,p6->i,p6->j,1/common->varx[j+i],-common->varx[j+i+common->rkb]); //序号，首节点，末节点，可调移相器变比，可调移相器相角 + i=i+1; + p6=p6->next; + } + fprintf(fp,"%d\n",0); //分隔符0 + + i=1; + j=common->rp+common->rq+common->rk+2*common->rkb; + p6=common->head_ti; + while(p6!=null) + { fprintf(fp,"%d,%d,%f\n" ,i,p6->i,common->varx[j+i]); //序号，节点号，可调电抗器电容器变比 + i=i+1; + p6=p6->next; + } + fprintf(fp,"%d\n",0); //分隔符0 + + i=1; + p6=common->head_kx; + while(p6!=null) + { r=1/(p6->k*p6->amp)*cos(-p6->rad); + x=1/(p6->k*p6->amp)*sin(-p6->rad); + fprintf(fp,"%d,%d,%d,%f,%f,%f\n" ,i,p6->i,p6->j,1/p6->k,-r,-x); //序号，首节点，末节点，可调线路串联电抗器变比 + i=i+1; + p6=p6->next; + } + fprintf(fp,"%d\n",0); //分隔符0 + + i=1; + t=common->rp+common->rq+common->rk+2*common->rkb+common->rt+common->rx+2*common->rlcos+common->rvdcos; + p8=common->head_dcbus; + while(p8!=null) + { fprintf(fp,"%d,%d,%f,%f,%f,%f,%f\n" ,i,p8->i,common->varx[t+i],common->varx[t+i+common->n_dc],common->varx[t+i+2*common->n_dc],common->varx[t+i+3*common->n_dc],common->varx[t+i+4*common->n_dc]); + p8=p8->next; + i=i+1; + } + fprintf(fp,"%d\n",0); //分隔符0 + + i=1; //监控线路电流数据 +// fprintf(fp," %s, %s, %s, %s, %s\n" ,"首节点号","尾节点号","iij0-2","iijmin","iijmax"); + p2=common->head_liij0; //支路电流 + while(p2!=null) + { fprintf(fp,"%d,%d,%d,%f,%f,%f\n" ,i,p2->i,p2->j,sqrt(p2->g),p2->gmin,p2->gmax); + p2=p2->next; + i=i+1; + } + + i=1; //监控线路电流数据 + j=1; + p2=common->head_liij; //支路电流 + while(p2!=null) + { r=sqrt(p2->g); + if((rgmin)||(r>p2->gmax)) + { fprintf(fp,"%d,%d,%d,%f,%f,%f\n" ,j,p2->i,p2->j,r,p2->gmin,p2->gmax); + j=j+1; + } + p2=p2->next; + i=i+1; + } + fprintf(fp,"%d\n",0); //分隔符0 + + i=1; //断面有功 + t=1; //监控断面有功数据 + p2=common->head_spij; + while(p2!=null) + { if((common->gvalue[j]gmin[j])||(common->gvalue[j]>common->gmax[j])) + { j=common->rr+common->rlpij+common->rlqij+common->rlsij+common->rliij+common->rvpd+common->rvqd+i; + fprintf(fp,"%d,%d,%f,%f,%f\n" ,t,p2->i,common->gvalue[j],common->gmin[j],common->gmax[j]); + t=t+1; + } + p2=p2->next; + i=i+1; + } + fprintf(fp,"%d\n",0); //分隔符0 + + fclose(fp); + return; +} + +/*清common内存*/ +void DeleteVarCommon(opf_common *common) +{ + int i; + opf_yij *p1; + opf_gij *p2; + opf_debug *p3; + opf_line *p4; + opf_error *p5; + opf_kij *p6; + + opf_trans *p7; + opf_y0 *p8; + opf_power *p9; + opf_limit_p *p10; + opf_limit_q *p11; + opf_limit_v *p12; + opf_slack *p13; + opf_vpdqd *p14; + opf_gpcd *p15; + opf_sij *p16; + opf_dcbus *p17; + opf_equalitykij *p18; + +// struct outlimit *p10; + + int mm,rr,rv,rlpij,rlqij,rpg,rqg,rk,rt; + + mm=common->n_sum; + rr=common->rr; + rv=common->rv; + rlpij=common->rlpij; + rlqij=common->rlqij; + rpg=common->rpg; + rqg=common->rqg; + rk=common->rk; + rt=common->rt; + + while(common->head_lpij!=null) + { p2=common->head_lpij->next; + free(common->head_lpij); + common->head_lpij=p2; + } + + while(common->head_lqij!=null) + { p2=common->head_lqij->next; + free(common->head_lqij); + common->head_lqij=p2; + } + + while(common->head_lsij!=null) + { p2=common->head_lsij->next; + free(common->head_lsij); + common->head_lsij=p2; + } + + while(common->head_liij!=null) + { p2=common->head_liij->next; + free(common->head_liij); + common->head_liij=p2; + } + + while(common->head_liij0!=null) + { p2=common->head_liij0->next; + free(common->head_liij0); + common->head_liij0=p2; + } + + while(common->head_lcos!=null) + { p2=common->head_lcos->next; + free(common->head_lcos); + common->head_lcos=p2; + } + + while(common->head_vdcos!=null) + { p2=common->head_vdcos->next; + free(common->head_vdcos); + common->head_vdcos=p2; + } + + while(common->head_spij!=null) + { p2=common->head_spij->next; + free(common->head_spij); + common->head_spij=p2; + } + + while(common->head_sqij!=null) + { p2=common->head_sqij->next; + free(common->head_sqij); + common->head_sqij=p2; + } + + while(common->head_sij!=null) + { p16=common->head_sij->next; + free(common->head_sij); + common->head_sij=p16; + } + + while(common->head_obsij!=null) + { p16=common->head_obsij->next; + free(common->head_obsij); + common->head_obsij=p16; + } + + while(common->head_vpd!=null) + { p14=common->head_vpd->next; + free(common->head_vpd); + common->head_vpd=p14; + } + + while(common->head_vqd!=null) + { p14=common->head_vqd->next; + free(common->head_vqd); + common->head_vqd=p14; + } + + while(common->head_gpcd!=null) + { p15=common->head_gpcd->next; + free(common->head_gpcd); + common->head_gpcd=p15; + } + + while(common->head_kij!=null) + { p6=common->head_kij->next; + free(common->head_kij); + common->head_kij=p6; + } + while(common->head_kbij!=null) + { p6=common->head_kbij->next; + free(common->head_kbij); + common->head_kbij=p6; + } + while(common->head_ti!=null) + { p6=common->head_ti->next; + free(common->head_ti); + common->head_ti=p6; + } + while(common->head_kx!=null) + { p6=common->head_kx->next; + free(common->head_kx); + common->head_kx=p6; + } + while(common->head_lij!=null) + { p4=common->head_lij->next; + free(common->head_lij); + common->head_lij=p4; + } + + while(common->head_trans!=null) + { p7=common->head_trans->next; + free(common->head_trans); + common->head_trans=p7; + } + while(common->head_transb!=null) + { p7=common->head_transb->next; + free(common->head_transb); + common->head_transb=p7; + } + while(common->head_y0!=null) + { p8=common->head_y0->next; + free(common->head_y0); + common->head_y0=p8; + } + while(common->head_power!=null) + { p9=common->head_power->next; + free(common->head_power); + common->head_power=p9; + } + while(common->head_pg!=null) + { p10=common->head_pg->next; + free(common->head_pg); + common->head_pg=p10; + } + while(common->head_pd!=null) + { p10=common->head_pd->next; + free(common->head_pd); + common->head_pd=p10; + } + while(common->head_qg!=null) + { p11=common->head_qg->next; + free(common->head_qg); + common->head_qg=p11; + } + while(common->head_qd!=null) + { p11=common->head_qd->next; + free(common->head_qd); + common->head_qd=p11; + } + while(common->head_v!=null) + { p12=common->head_v->next; + free(common->head_v); + common->head_v=p12; + } + while(common->head_slack!=null) + { p13=common->head_slack->next; + free(common->head_slack); + common->head_slack=p13; + } + + while(common->head_dcbus!=null) + { p17=common->head_dcbus->next; + free(common->head_dcbus); + common->head_dcbus=p17; + } + while(common->head_dclij!=null) + { p4=common->head_dclij->next; + free(common->head_dclij); + common->head_dclij=p4; + + } + + while(common->head_debuggap!=null) + { p3=common->head_debuggap->next; + free(common->head_debuggap); + common->head_debuggap=p3; + } + while(common->head_debugpq!=null) + { p3=common->head_debugpq->next; + free(common->head_debugpq); + common->head_debugpq=p3; + } + while(common->head_debuglcos!=null) + { p3=common->head_debuglcos->next; + free(common->head_debuglcos); + common->head_debuglcos=p3; + } + + while(common->head_error!=null) + { p5=common->head_error->next; + free(common->head_error); + common->head_error=p5; + } + + while(common->head_eqkij!=null) + { p18=common->head_eqkij->next; + free(common->head_eqkij); + common->head_eqkij=p18; + } + + free(common->head_lpij); //联络线功率有功限制 + free(common->head_lqij); //联络线功率无功限制 + free(common->head_lsij); //联络线容量限制 + free(common->head_liij); //联络线电流限制 + free(common->head_liij0); + free(common->head_lcos); //联络线功率因数限制 + free(common->head_spij); //断面有功限制 + free(common->head_sqij); //断面无功限制 + free(common->head_sij); + free(common->head_obsij); + free(common->head_vpd); //有功负荷模型限制 + free(common->head_vqd); //无功负荷模型限制 + free(common->head_lcos); //负荷模型功率因数限制 + free(common->head_gpcd); //发电机功率圆图限制 + free(common->head_kij); //有载调压变压器 + free(common->head_kbij); //可调移相器 + free(common->head_ti); //可调电容器 + free(common->head_kx); //可调线路电抗 + free(common->head_lij); //线路集合 + free(common->head_trans); //变压器集合 free(common->headbyq + free(common->head_transb); //移相器集合 free(common->headbyq + free(common->head_y0); //接地支路集合free(common->headjdzl + free(common->head_power); //功率负荷集合 free(common->headglfh + free(common->head_pg); //有功限制集合 free(common->headygxz + free(common->head_qg); //无功限制集合 free(common->headwgxz + free(common->head_v); //电压限制集合free(common->headdyxz + free(common->head_slack); //平衡点集合free(common->headphd + free(common->head_eqkij); + +/* + free(common->head_dcbus); + free(common->head_dclij);*/ + + + free(common->head_error); //错误信息列表 + free(common->head_debuggap); //收敛消息 + free(common->head_debugpq); //最大不平衡量信息 + free(common->head_debuglcos); //最大不平衡量信息 + + + free(common->g); + free(common->b); + + while(common->a[1]!=null) + { p1=common->a[1]->next; + free(common->a[1]); + common->a[1]=p1; + } + + for(i=2;i<=mm;i++) + common->a[i]=null; + + free(common->a); + + free(common->gp); + free(common->gq); + free(common->gv); + free(common->gmin); + free(common->gmax); + free(common->gvalue); + + free(common->varx); + free(common->vary); + free(common->varl); + free(common->varu); + free(common->varw); + free(common->varz); + + free(common->v); + free(common->rad); + free(common->pg); + free(common->qg); + free(common->pd); + free(common->qd); + + free(common->fa0); + free(common->fa1); + free(common->fa2); + free(common->fa3); + free(common->fa4); + + free(common->opt_list); + + free(common->v0); + free(common->wv); + + free(common->wpg); + free(common->wpd); + free(common->wqg); + free(common->wqd); + + +/* + p10=outlimit_v; //节点电压越限 + while(p10!=null) + { p10=outlimit_v->next; + free(outlimit_v); + outlimit_v=p10; + } + + p10=outlimit_branch; //线路功率越限 + while(p10!=null) + { p10=outlimit_branch->next; + free(outlimit_branch); + outlimit_branch=p10; + }*/ + + return; +} + +/*清correct内存*/ +void DeleteVarCorrect(opf_common *common,opf_correct *correct) +{ + int i; + int cmm, hmm,dmm; + opf_matrix *p3; + + cmm=common->rr-common->rv+2*common->n_sum; + hmm=common->rr-common->rv+4*common->n_sum+common->req; + dmm=common->rr+common->rrr; + + for(i=1;i<=cmm;i++) //释放空间 + { while(correct->jcb[i]!=null) + { p3=correct->jcb[i]->next; + free(correct->jcb[i]); + correct->jcb[i]=p3; + } + } + for(i=1;i<=hmm;i++) + { while(correct->heisen[i]!=null) + { p3=correct->heisen[i]->next; + free(correct->heisen[i]); + correct->heisen[i]=p3; + } + } + for(i=1;i<=dmm;i++) + { while(correct->dg[i]!=null) + { p3=correct->dg[i]->next; + free(correct->dg[i]); + correct->dg[i]=p3; + } + } + + free(correct->jcb); + free(correct->heisen); + free(correct->dg); + + free(correct->d); + + return; +} + +/*清decomp内存*/ +void DeleteVarDecomp(opf_decomp *decomp) +{ + free(decomp->jtoi); + free(decomp->la); + free(decomp->li); + free(decomp->lis); + free(decomp->lj); + free(decomp->ljs); + return; +} + +/*计算最后结果*/ +void CalResult(opf_common *com,opf_correct *cor) +{ + int i,j,t,tm,tn,n; + double r,x; + + opf_yij *p1; + opf_gij *p2; + opf_line *p3; + opf_kij *p6; + opf_vpdqd *p5; + opf_gpcd *p7; + opf_sij *p8; + opf_dcbus *p9; + + int mm,rr,rv,rlpij,rlqij,rlsij,rliij,rvpd,rvqd,rspij,rsqij,rpg,rqg,rpd,rqd,rk,rkb,rt,rx,rp,rq,rrr,rlcos,rvdcos,req,n_dc,rgpcd; + double *v,*rad; + + mm=com->n_sum; + rr=com->rr; + rv=com->rv; + rlpij=com->rlpij; + rlqij=com->rlqij; + rlsij=com->rlsij; + rliij=com->rliij; + rvpd=com->rvpd; + rvqd=com->rvqd; + rspij=com->rspij; + rsqij=com->rsqij; + rpg=com->rpg; + rqg=com->rqg; + rpd=com->rpd; + rqd=com->rqd; + rk=com->rk; + rkb=com->rkb; + rt=com->rt; + rx=com->rx; + rp=com->rp; + rq=com->rq; + rrr=com->rrr; + rlcos=com->rlcos; + req=com->req; + n_dc=com->n_dc; + rgpcd=com->rgpcd; + rvdcos=com->rvdcos; + + v=(double *)malloc((mm+1)*sizeof(double)); //减少打字，看上去简洁些 + rad=(double *)malloc((mm+1)*sizeof(double)); + for(i=1;i<=mm;i++) + { v[i]=com->v[i]; + rad[i]=com->rad[i]; + } + + for(i=1;i<=rr-rv;i++) //计算的g值 + com->gvalue[i]=com->varx[i]; + for(i=1;i<=rv;i++) + com->gvalue[i+rr-rv]=v[com->gv[i]]; + + i=1; + p2=com->head_lpij; //支路有功g值 + while(p2!=null) + { +// p4=com->head_lij; + p1=com->a[p2->i]; + j=0; + while((p1!=null)&&(j==0)) + { if((p2->i==p1->irow)&&(p2->j==p1->jcol)) + j=1; + else + p1=p1->next; + } + if(p1!=null) + com->gvalue[rr+i]=v[p2->i]*v[p2->i]*p1->amp*cos(p1->rad)-v[p2->i]*v[p2->j]*p1->amp*cos(com->rad[p2->i]-com->rad[p2->j]-p1->rad); + p2=p2->next; + i=i+1; + } + + i=1; + p2=com->head_lqij; //支路无功g值 + while(p2!=null) + { +// p4=com->head_lij; + p1=com->a[p2->i]; + j=0; + while((p1!=null)&&(j==0)) + { if((p2->i==p1->irow)&&(p2->j==p1->jcol)) + j=1; + else + p1=p1->next; + } + if(p1!=null) + { +// com->gvalue[rr+rlpij+i]=-v[p2->i]*v[p2->i]*p1->amp*sin(p1->rad)-v[p2->i]*v[p2->j]*p1->amp*sin(com->rad[p2->i]-com->rad[p2->j]-p1->rad); + n=0; + p6=com->head_kij; + while((p6!=null)&&(n==0)) + { if((p6->i==p2->i)&&(p6->j==p2->j)) + n=1; + else + p6=p6->next; + } + if(p6!=null) + com->gvalue[rr+rlpij+i]=-v[p2->i]*v[p2->i]*p6->k*p1->amp*sin(p1->rad-3.1415926)-v[p2->i]*v[p2->j]*p1->amp*sin(com->rad[p2->i]-com->rad[p2->j]-(p1->rad-3.1415926)); + else + com->gvalue[rr+rlpij+i]=0; + } + p2=p2->next; + i=i+1; + } + + i=1; + p2=com->head_lsij; //支路容量g值 + while(p2!=null) + { +// p4=com->head_lij; + p1=com->a[p2->i]; + j=0; + while((p1!=null)&&(j==0)) + { if((p2->i==p1->irow)&&(p2->j==p1->jcol)) + j=1; + else + p1=p1->next; + } + if(p1!=null) + com->gvalue[rr+rlpij+rlqij+i]=pow(v[p2->i],4)*pow(p1->amp,2)+pow(v[p2->i],2)*pow(p1->amp,2)*pow(v[p2->j],2)-2*pow(v[p2->i],3)*pow(p1->amp,2)*v[p2->j]*cos(com->rad[p2->i]-com->rad[p2->j]); + p2=p2->next; + i=i+1; + } + + i=1; + p2=com->head_liij; //支路电流g值 + while(p2!=null) + { +// p4=com->head_lij; + p1=com->a[p2->i]; + j=0; + while((p1!=null)&&(j==0)) + { if((p2->i==p1->irow)&&(p2->j==p1->jcol)) + j=1; + else + p1=p1->next; + } + if(p1!=null) + com->gvalue[rr+rlpij+rlqij+rlsij+i]=pow(v[p2->i],2)*pow(p1->amp,2)+pow(v[p2->j],2)*pow(p1->amp,2)-2*v[p2->i]*pow(p1->amp,2)*v[p2->j]*cos(com->rad[p2->i]-com->rad[p2->j]); + p2=p2->next; + i=i+1; + } + + i=1; + j=rr+rlpij+rlqij+rlsij+rliij; + p5=com->head_vpd; //有功负荷模型g值 + while(p5!=null) + { com->gvalue[j+i]=p5->a*pow(v[p5->i],2)+p5->b*v[p5->i]+p5->c; + p5=p5->next; + i=i+1; + } + + i=1; + j=rr+rlpij+rlqij+rlsij+rliij+rvpd; + p5=com->head_vqd; //无功负荷模型g值 + while(p5!=null) + { com->gvalue[j+i]=p5->a*pow(v[p5->i],2)+p5->b*v[p5->i]+p5->c; + p5=p5->next; + i=i+1; + } + + i=rr+rlpij+rlqij+rlsij+rliij+rvpd+rvqd+1; + for(j=0;j<=rspij-1;j++) + com->gvalue[i+j]=0; + p2=com->head_spij; //断面有功g值 + while(p2!=null) + { p8=com->head_sij; + while(p8!=null) + { if(p8->num==p2->i) + { +// p4=com->head_lij; + p1=com->a[p8->i]; + j=0; + while((p1!=null)&&(j==0)) + { if((p8->i==p1->irow)&&(p8->j==p1->jcol)) + j=1; + else + p1=p1->next; + } + if(p1!=null) + com->gvalue[i]+=v[p8->i]*v[p8->i]*p1->amp*cos(p1->rad)-v[p8->i]*v[p8->j]*p1->amp*cos(com->rad[p8->i]-com->rad[p8->j]-p1->rad); + } + p8=p8->next; + } + p2=p2->next; + i=i+1; + } + + i=rr+rlpij+rlqij+rlsij+rliij+rvpd+rvqd+rspij+1; + for(j=0;j<=rsqij-1;j++) + com->gvalue[i+j]=0; + p2=com->head_sqij; //断面无功g值 + while(p2!=null) + { p8=com->head_sij; + while(p8!=null) + { if(p8->num==p2->i) + { +// p4=com->head_lij; + p1=com->a[p8->i]; + j=0; + while((p1!=null)&&(j==0)) + { if((p8->i==p1->irow)&&(p8->j==p1->jcol)) + j=1; + else + p1=p1->next; + } + if(p1!=null) + com->gvalue[i]+=-v[p8->i]*v[p8->i]*p1->amp*sin(p1->rad)-v[p8->i]*v[p8->j]*p1->amp*sin(com->rad[p8->i]-com->rad[p8->j]-p1->rad); + } + p8=p8->next; + } + p2=p2->next; + i=i+1; + } + + i=1; + p7=com->head_gpcd; //发电机功率圆图g值 + j=rr+rlpij+rlqij+rlsij+rliij+rvpd+rvqd+rspij+rsqij; + while(p7!=null) + { + r=0; + x=0; + + tn=0; //有功部分 + for(t=1;t<=com->rpg;t++) + { if(com->gp[t]==p7->i) + tn=t; + } + tm=0; //无功部分 + for(t=1;t<=com->rqg;t++) + { if(com->gq[t]==p7->i) + tm=t; + } + if(tn!=0) + r=com->varx[tn]; + else + r=com->pg[p7->i]; + if(tm!=0) + x=com->varx[com->rp+tm]; + else + x=com->qg[p7->i]; + + if(x>=0) //值随时修改变化 + { com->gvalue[j+i]=r*r+(x-p7->qo)*(x-p7->qo); + com->gmax[j+i]=pow(p7->sn*cos(p7->rad),2)+pow((p7->sn*sin(p7->rad)-p7->qo),2); + } + else + { com->gvalue[j+i]=r+tan(p7->rad)*x; + com->gmax[j+i]=p7->sn*cos(p7->rad); + } + + p7=p7->next; + i=i+1; + } + + i=1; + p9=com->head_dcbus; //直流功率g值 + j=rr+rlpij+rlqij+rlsij+rliij+rvpd+rvqd+rspij+rsqij+rgpcd; + t=rp+rq+rk+2*rkb+rt+rx+2*rlcos+rvdcos; + while(p9!=null) + { com->gvalue[j+i]=com->varx[t+i]*com->varx[t+i+n_dc]; + p9=p9->next; + i=i+1; + } + + i=1; + p2=com->head_lcos; //功率因数 + j=rr+rlpij+rlqij+rlsij+rliij+rvpd+rvqd+rspij+rsqij+rgpcd+n_dc; + t=rp+rq+rk+2*rkb+rt+rx; + while(p2!=null) + { r=com->varx[t+i]; + x=com->varx[t+i+rlcos]; + if((r*r+x*x)!=0) + com->gvalue[j+i]=(r*r)/(r*r+x*x); + else + com->gvalue[j+i]=1; + p2=p2->next; + i=i+1; + } + + p6=com->head_kij; //计算可调变压器的首端功率 + while(p6!=null) + { p6->p=v[p6->i]*v[p6->i]*p6->k*p6->amp*cos(p6->rad)-v[p6->i]*v[p6->j]*p6->k*p6->amp*cos(rad[p6->i]-rad[p6->j]-p6->rad); + p6->q=-v[p6->i]*v[p6->i]*p6->k*p6->amp*sin(p6->rad)-v[p6->i]*v[p6->j]*p6->amp*sin(rad[p6->i]-rad[p6->j]-p6->rad); + p6=p6->next; + } + + p6=com->head_kbij; //计算可调移相器的首端功率 + while(p6!=null) + { p6->p=v[p6->i]*v[p6->i]*p6->k*p6->amp*cos(p6->rad-p6->b)-v[p6->i]*v[p6->j]*p6->k*p6->amp*cos(rad[p6->i]-rad[p6->j]-p6->rad+p6->b); + p6->q=-v[p6->i]*v[p6->i]*p6->k*p6->amp*sin(p6->rad-p6->b)-v[p6->i]*v[p6->j]*p6->amp*sin(rad[p6->i]-rad[p6->j]-p6->rad+p6->b); + p6=p6->next; + } + + p6=com->head_kx; //计算可调线路电抗器的首端功率 + while(p6!=null) + { p6->p=v[p6->i]*v[p6->i]*p6->k*p6->amp*cos(p6->rad)-v[p6->i]*v[p6->j]*p6->k*p6->amp*cos(rad[p6->i]-rad[p6->j]-p6->rad); + p6->q=-v[p6->i]*v[p6->i]*p6->k*p6->amp*sin(p6->rad)-v[p6->i]*v[p6->j]*p6->k*p6->amp*sin(rad[p6->i]-rad[p6->j]-p6->rad); + p6=p6->next; + } + + p3=com->head_lij; //线路的功率、电流、容量 + while(p3!=null) + { p3->p=v[p3->i]*v[p3->i]*p3->amp*cos(p3->rad)-v[p3->i]*v[p3->j]*p3->amp*cos(rad[p3->i]-rad[p3->j]-p3->rad); + p3->q=-v[p3->i]*v[p3->i]*p3->amp*sin(p3->rad)-v[p3->i]*v[p3->j]*p3->amp*sin(rad[p3->i]-rad[p3->j]-p3->rad); + p3->s2=pow(v[p3->i],4)*pow(p3->amp,2)+pow(v[p3->i],2)*pow(p3->amp,2)*pow(v[p3->j],2)-2*pow(v[p3->i],3)*pow(p3->amp,2)*v[p3->j]*cos(rad[p3->i]-rad[p3->j]); + p3->i2=pow(v[p3->i],2)*pow(p3->amp,2)+pow(v[p3->j],2)*pow(p3->amp,2)-2*v[p3->i]*pow(p3->amp,2)*v[p3->j]*cos(rad[p3->i]-rad[p3->j]); + p3=p3->next; + } + + i=1; + p2=com->head_liij0; //支路电流g值 + while(p2!=null) + { + p1=com->a[p2->i]; + j=0; + while((p1!=null)&&(j==0)) + { if((p2->i==p1->irow)&&(p2->j==p1->jcol)) + j=1; + else + p1=p1->next; + } + if(p1!=null) + p2->g=pow(v[p2->i],2)*pow(p1->amp,2)+pow(v[p2->j],2)*pow(p1->amp,2)-2*v[p2->i]*pow(p1->amp,2)*v[p2->j]*cos(rad[p2->i]-rad[p2->j]); + p2=p2->next; + i=i+1; + } + + free(v); + free(rad); + +} + +void printTinney(opf_common *com) +{ + int i; + +/* + FILE *fp1; + fp1=fopen("Text3.txt","wb");*/ + + + +/* + p3=com->head_lij; //线路部分 + while(p3!=null) + { p3->i=com->opt_list[p3->i]; + p3->j=com->opt_list[p3->j]; + p3=p3->next; + } + + p4=com->head_trans; //变压器部分 + while(p4!=null) + { p4->i=com->opt_list[p4->i]; + p4->j=com->opt_list[p4->j]; + p4=p4->next; + }*/ + + + i=1; +/* + p3=com->head_lij; + while(p3!=null) + { fprintf(fp1,"%d,%d,%d,%f,%f,%f\n",i,p3->i,p3->j,p3->amp,p3->rad); + i=i+1; + p3=p3->next; + } + + i=1; + p4=com->head_trans; + while(p4!=null) + { fprintf(fp1,"%d,%d,%d,%d,%f,%f,%f,%f,%f\n",i,0,p4->i,p4->j,p4->r,p4->x,p4->k,0.9,1.1); + i=i+1; + p4=p4->next; + } + + fclose(fp1);*/ + +} + +void outputsensitive(opf_common *com,opf_correct *cor,opf_sensitive *sensi) //灵敏度输出 +{ + int i,j,t,tm,tn,m,n; + double r,x; + + opf_yij *p1; + opf_gij *p2; + opf_matrix *p3; + opf_line *p4; + opf_kij *p6; + opf_vpdqd *p5; + opf_sij *p8; + opf_dcbus *p9; + + opf_senobj *p10,*p11; + opf_senequ *p12,*p13; + opf_seninequ *p14,*p15; + + int mm,rr,rv,rlpij,rlqij,rlsij,rliij,rvpd,rvqd,rspij,rsqij,rpg,rqg,rpd,rqd,rk,rkb,rt,rx,rp,rq,rrr,rlcos,rvdcos,req,n_dc,rgpcd; + double *v,*rad; + double *derf; + + if(sensi->num>0) + return; + else + sensi->num=1; + + mm=com->n_sum; + rr=com->rr; + rv=com->rv; + rlpij=com->rlpij; + rlqij=com->rlqij; + rlsij=com->rlsij; + rliij=com->rliij; + rvpd=com->rvpd; + rvqd=com->rvqd; + rspij=com->rspij; + rsqij=com->rsqij; + rpg=com->rpg; + rqg=com->rqg; + rpd=com->rpd; + rqd=com->rqd; + rk=com->rk; + rkb=com->rkb; + rt=com->rt; + rx=com->rx; + rp=com->rp; + rq=com->rq; + rrr=com->rrr; + rlcos=com->rlcos; + req=com->req; + n_dc=com->n_dc; + rgpcd=com->rgpcd; + rvdcos=com->rvdcos; + + v=(double *)malloc((mm+1)*sizeof(double)); //减少打字，看上去简洁些 + rad=(double *)malloc((mm+1)*sizeof(double)); + for(i=1;i<=mm;i++) + { v[i]=com->v[i]; + rad[i]=com->rad[i]; + } + + derf=(double *)malloc((rr-rv+2*mm+1)*sizeof(double)); + for(i=1;i<=rr-rv+2*mm;i++) + derf[i]=0; + + while(sensi->senobj!=null) //清空前面的，只做一次灵敏度 + { p10=sensi->senobj->next; + free(sensi->senobj); + sensi->senobj=p10; + } + + while(sensi->senequ!=null) //清空前面的，只做一次灵敏度 + { p12=sensi->senequ->next; + free(sensi->senequ); + sensi->senequ=p12; + } + + while(sensi->seninequ!=null) //清空前面的，只做一次灵敏度 + { p14=sensi->seninequ->next; + free(sensi->seninequ); + sensi->seninequ=p14; + } + +//目标函数灵敏度 + p11=sensi->senobj; + switch(com->obj_type) //关于f的一阶偏导，即目标函数的灵敏度 + { case 1: //煤耗 + { for(i=1;i<=rpg;i++) + { p10=(opf_senobj *)malloc(lesenobj); + p10->var_i=com->gp[i]; + p10->var_j=com->gp[i]; + p10->iternum=com->itera_num; + p10->vartype=1; + p10->value=com->fa1[i]+2*com->fa2[i]*com->varx[i]+com->fa3[i]*com->fa4[i]*exp(com->fa4[i]*com->varx[i]); + p10->next=null; + if(p11!=null) + { p11->next=p10; + p11=p10; + } + else + { p11=p10; + sensi->senobj=p11; + } + } + break; + } + case 2: //有功出力最小 + { for(i=1;i<=rpg;i++) + { p10=(opf_senobj *)malloc(lesenobj); + p10->var_i=com->gp[i]; + p10->var_j=com->gp[i]; + p10->iternum=com->itera_num; + p10->vartype=1; + p10->value=1; + p10->next=null; + if(p11!=null) + { p11->next=p10; + p11=p10; + } + else + { p11=p10; + sensi->senobj=p11; + } + } + break; + } + case 3: //无功出力最小 + { for(i=1;i<=rqg;i++) + { p10=(opf_senobj *)malloc(lesenobj); + p10->var_i=com->gq[i]; + p10->var_j=com->gq[i]; + p10->iternum=com->itera_num; + p10->vartype=3; + p10->value=1; + p10->next=null; + if(p11!=null) + { p11->next=p10; + p11=p10; + } + else + { p11=p10; + sensi->senobj=p11; + } + } + break; + } + case 4: //支路有功损耗最小 + { t=rr-rv; + for(i=1;i<=mm;i++) //求f的一阶偏导 + { r=0; + x=0; + j=0; + p1=com->a[i]; + while((p1->irow==i)&&(j==0)) + { if(p1->irow!=p1->jcol) + { r=r+v[p1->jcol]*sin(com->rad[i]-com->rad[p1->jcol])*p1->amp*cos(p1->rad); + x=x+(v[i]-v[p1->jcol]*cos(com->rad[i]-com->rad[p1->jcol]))*p1->amp*cos(p1->rad); + } + if(p1->next==null) + j=1; + else + p1=p1->next; + } + p10=(opf_senobj *)malloc(lesenobj); + p10->var_i=i; + p10->var_j=i; + p10->iternum=com->itera_num; + p10->vartype=14; + p10->value=-v[i]*r; + p10->next=null; + if(p11!=null) + { p11->next=p10; + p11=p10; + } + else + { p11=p10; + sensi->senobj=p11; + } + + p10=(opf_senobj *)malloc(lesenobj); + p10->var_i=i; + p10->var_j=i; + p10->iternum=com->itera_num; + p10->vartype=15; + p10->value=-x; + p10->next=null; + if(p11!=null) + { p11->next=p10; + p11=p10; + } + else + { p11=p10; + sensi->senobj=p11; + } + } + break; + } + case 5: //支路无功损耗最小 + { t=rr-rv; + for(i=1;i<=mm;i++) //求f的一阶偏导 + { r=0; + x=0; + j=0; + p1=com->a[i]; + while((p1->irow==i)&&(j==0)) + { if(p1->irow!=p1->jcol) + { r=r+v[i]*v[p1->jcol]*sin(com->rad[i]-com->rad[p1->jcol])*p1->amp*sin(p1->rad); + x=x+(v[i]-v[p1->jcol]*cos(com->rad[i]-com->rad[p1->jcol]))*p1->amp*sin(p1->rad); + } + if(p1->next==null) + j=1; + else + p1=p1->next; + } + p10=(opf_senobj *)malloc(lesenobj); + p10->var_i=i; + p10->var_j=i; + p10->iternum=com->itera_num; + p10->vartype=14; + p10->value=r; + p10->next=null; + if(p11!=null) + { p11->next=p10; + p11=p10; + } + else + { p11=p10; + sensi->senobj=p11; + } + + p10=(opf_senobj *)malloc(lesenobj); + p10->var_i=i; + p10->var_j=i; + p10->iternum=com->itera_num; + p10->vartype=15; + p10->value=x; + p10->next=null; + if(p11!=null) + { p11->next=p10; + p11=p10; + } + else + { p11=p10; + sensi->senobj=p11; + } + } + break; + } + case 6: //线路有功损耗最小 + { t=rr-rv; + p4=com->head_lij; + while(p4!=null) //求f的一阶偏导 + { r=-2*v[p4->i]*v[p4->j]*sin(com->rad[p4->i]-com->rad[p4->j])*p4->amp*cos(p4->rad); + x=-2*(v[p4->i]-v[p4->j]*cos(com->rad[p4->i]-com->rad[p4->j]))*p4->amp*cos(p4->rad); + derf[t+2*p4->i-1]+=r; + derf[t+2*p4->i]+=x; + + r=-2*v[p4->j]*v[p4->i]*sin(com->rad[p4->j]-com->rad[p4->i])*p4->amp*cos(p4->rad); + x=-2*(v[p4->j]-v[p4->i]*cos(com->rad[p4->j]-com->rad[p4->i]))*p4->amp*cos(p4->rad); + derf[t+2*p4->j-1]+=r; + derf[t+2*p4->j]+=x; + p4=p4->next; + } + for(i=1;i<=mm;i++) + { p10=(opf_senobj *)malloc(lesenobj); + p10->var_i=i; + p10->var_j=i; + p10->iternum=com->itera_num; + p10->vartype=14; + p10->value=derf[t+2*i-1]; + p10->next=null; + if(p11!=null) + { p11->next=p10; + p11=p10; + } + else + { p11=p10; + sensi->senobj=p11; + } + + p10=(opf_senobj *)malloc(lesenobj); + p10->var_i=i; + p10->var_j=i; + p10->iternum=com->itera_num; + p10->vartype=15; + p10->value=derf[t+2*i];; + p10->next=null; + if(p11!=null) + { p11->next=p10; + p11=p10; + } + else + { p11=p10; + sensi->senobj=p11; + } + } + break; + } + case 7: //线路无功损耗最小 + { t=rr-rv; + p4=com->head_lij; + while(p4!=null) //求f的一阶偏导 + { r=2*v[p4->i]*v[p4->j]*sin(com->rad[p4->i]-com->rad[p4->j])*p4->amp*sin(p4->rad); + x=2*(v[p4->i]-v[p4->j]*cos(com->rad[p4->i]-com->rad[p4->j]))*p4->amp*sin(p4->rad)-2*v[p4->i]*p4->bb; + derf[t+2*p4->i-1]+=r; + derf[t+2*p4->i]+=x; + r=2*v[p4->j]*v[p4->i]*sin(com->rad[p4->j]-com->rad[p4->i])*p4->amp*sin(p4->rad); + x=2*(v[p4->j]-v[p4->i]*cos(com->rad[p4->j]-com->rad[p4->i]))*p4->amp*sin(p4->rad)-2*v[p4->j]*p4->bb; + derf[t+2*p4->j-1]+=r; + derf[t+2*p4->j]+=x; + p4=p4->next; + } + for(i=1;i<=mm;i++) + { p10=(opf_senobj *)malloc(lesenobj); + p10->var_i=i; + p10->var_j=i; + p10->iternum=com->itera_num; + p10->vartype=14; + p10->value=derf[t+2*i-1]; + p10->next=null; + if(p11!=null) + { p11->next=p10; + p11=p10; + } + else + { p11=p10; + sensi->senobj=p11; + } + + p10=(opf_senobj *)malloc(lesenobj); + p10->var_i=i; + p10->var_j=i; + p10->iternum=com->itera_num; + p10->vartype=15; + p10->value=derf[t+2*i];; + p10->next=null; + if(p11!=null) + { p11->next=p10; + p11=p10; + } + else + { p11=p10; + sensi->senobj=p11; + } + } + break; + } + case 8: //电压越限最小 + { t=rr-rv; + for(i=1;i<=mm;i++) //求f的一阶偏导 + { p10=(opf_senobj *)malloc(lesenobj); + p10->var_i=i; + p10->var_j=i; + p10->iternum=com->itera_num; + p10->vartype=15; + p10->value=2*com->wv[i]*(v[i]-com->v0[i]); + p10->next=null; + if(p11!=null) + { p11->next=p10; + p11=p10; + } + else + { p11=p10; + sensi->senobj=p11; + } + } + break; + } + case 9: //有功网损 + { for(i=1;i<=rpg;i++) + { p10=(opf_senobj *)malloc(lesenobj); + p10->var_i=com->gp[i]; + p10->var_j=com->gp[i]; + p10->iternum=com->itera_num; + p10->vartype=1; + p10->value=1; + p10->next=null; + if(p11!=null) + { p11->next=p10; + p11=p10; + } + else + { p11=p10; + sensi->senobj=p11; + } + } + for(i=rpg+com->rpge+1;i<=rp;i++) //rpd + { p10=(opf_senobj *)malloc(lesenobj); + p10->var_i=com->gp[i]; + p10->var_j=com->gp[i]; + p10->iternum=com->itera_num; + p10->vartype=2; + p10->value=-1; + p10->next=null; + if(p11!=null) + { p11->next=p10; + p11=p10; + } + else + { p11=p10; + sensi->senobj=p11; + } + } + p5=com->head_vpd; + t=rr-rv; + while(p5!=null) + { derf[t+2*p5->i]+=2*p5->a*v[p5->i]+p5->b; + p5=p5->next; + } + for(i=1;i<=mm;i++) //求f的一阶偏导 + { p10=(opf_senobj *)malloc(lesenobj); + p10->var_i=i; + p10->var_j=i; + p10->iternum=com->itera_num; + p10->vartype=15; + p10->value=derf[t+2*i]; + p10->next=null; + if(p11!=null) + { p11->next=p10; + p11=p10; + } + else + { p11=p10; + sensi->senobj=p11; + } + } + break; + } + case 10: //无功网损 + { for(i=1;i<=rqg;i++) + { p10=(opf_senobj *)malloc(lesenobj); + p10->var_i=com->gq[i]; + p10->var_j=com->gq[i]; + p10->iternum=com->itera_num; + p10->vartype=3; + p10->value=1; + p10->next=null; + if(p11!=null) + { p11->next=p10; + p11=p10; + } + else + { p11=p10; + sensi->senobj=p11; + } + } + for(i=rqg+com->rqge+1;i<=rq;i++) + { p10=(opf_senobj *)malloc(lesenobj); + p10->var_i=com->gq[i]; + p10->var_j=com->gq[i]; + p10->iternum=com->itera_num; + p10->vartype=4; + p10->value=-1; + p10->next=null; + if(p11!=null) + { p11->next=p10; + p11=p10; + } + else + { p11=p10; + sensi->senobj=p11; + } + } + p5=com->head_vqd; + t=rr-rv; + while(p5!=null) + { derf[t+2*p5->i]+=2*p5->a*v[p5->i]+p5->b; + p5=p5->next; + } + for(i=1;i<=mm;i++) //求f的一阶偏导 + { p10=(opf_senobj *)malloc(lesenobj); + p10->var_i=i; + p10->var_j=i; + p10->iternum=com->itera_num; + p10->vartype=15; + p10->value=derf[t+2*i]; + p10->next=null; + if(p11!=null) + { p11->next=p10; + p11=p10; + } + else + { p11=p10; + sensi->senobj=p11; + } + } + break; + } + case 11: //电容/电抗调节最小 + { i=1; + p6=com->head_ti; + while(p6!=null) //2w(ti-ti0) + { p10=(opf_senobj *)malloc(lesenobj); + p10->var_i=p6->i; + p10->var_j=p6->i; + p10->iternum=com->itera_num; + p10->vartype=7; + p10->value=2*p6->w*(p6->k-p6->b); + p10->next=null; + if(p11!=null) + { p11->next=p10; + p11=p10; + } + else + { p11=p10; + sensi->senobj=p11; + } + p6=p6->next; + i=i+1; + } + break; + } + case 12: //负荷功率调节最小 + { for(i=1;i<=rpd;i++) //2w(PDi-PDi0) + { p10=(opf_senobj *)malloc(lesenobj); + p10->var_i=com->gp[i+rpg+com->rpge]; + p10->var_j=com->gp[i+rpg+com->rpge]; + p10->iternum=com->itera_num; + p10->vartype=2; + p10->value=2*com->wpd[i]*(com->varx[rpg+com->rpge+i]-com->pd[com->gp[rpg+com->rpge+i]]); + p10->next=null; + if(p11!=null) + { p11->next=p10; + p11=p10; + } + else + { p11=p10; + sensi->senobj=p11; + } + } + p5=com->head_vpd; + t=rr-rv; + while(p5!=null) + { r=p5->a*v[p5->i]*v[p5->i]+p5->b*v[p5->i]+p5->c; + derf[t+2*p5->i]+=2*p5->w*(r-com->pd[p5->i])*(2*p5->a*v[p5->i]+p5->b); + p5=p5->next; + } + for(i=1;i<=mm;i++) //求f的一阶偏导 + { p10=(opf_senobj *)malloc(lesenobj); + p10->var_i=i; + p10->var_j=i; + p10->iternum=com->itera_num; + p10->vartype=15; + p10->value=derf[t+2*i]; + p10->next=null; + if(p11!=null) + { p11->next=p10; + p11=p10; + } + else + { p11=p10; + sensi->senobj=p11; + } + } + break; + } + case 13: + { + p2=com->head_spij; //断面有功计算f的一阶偏导 + j=com->rr-com->rv; + while(p2!=null) //断面有功的部分 + { p8=com->head_obsij; + while(p8!=null) //找到匹配的支路有功功率部分 + { if(p8->num==p2->i) + { t=p8->i; + m=p8->j; +// p4=com->head_lij; + p1=com->a[p8->i]; + n=0; + if(p1!=null) + { while((p1!=null)&&(n==0)) + { if((p1->irow==p8->i)&&(p1->jcol==p8->j)) + n=1; + else + p1=p1->next; + } + if(p1!=null) + { derf[j+2*t-1]+=p8->w*v[t]*v[m]*p1->amp*sin(rad[t]-rad[m]-p1->rad); //ai + derf[j+2*m-1]+=-p8->w*(v[t]*v[m]*p1->amp*sin(rad[t]-rad[m]-p1->rad)); //aj + derf[j+2*t]+=p8->w*(2*v[t]*p1->amp*cos(p1->rad)-v[m]*p1->amp*cos(rad[t]-rad[m]-p1->rad)); //Vi + derf[j+2*m]+=-p8->w*v[t]*p1->amp*cos(rad[t]-rad[m]-p1->rad); //Vj + } + } + } + p8=p8->next; + } + p2=p2->next; + } + for(i=1;i<=mm;i++) + { p10=(opf_senobj *)malloc(lesenobj); + p10->var_i=i; + p10->var_j=i; + p10->iternum=com->itera_num; + p10->vartype=14; + p10->value=derf[j+2*i-1]; + p10->next=null; + if(p11!=null) + { p11->next=p10; + p11=p10; + } + else + { p11=p10; + sensi->senobj=p11; + } + + p10=(opf_senobj *)malloc(lesenobj); + p10->var_i=i; + p10->var_j=i; + p10->iternum=com->itera_num; + p10->vartype=15; + p10->value=derf[j+2*i]; + p10->next=null; + if(p11!=null) + { p11->next=p10; + p11=p10; + } + else + { p11=p10; + sensi->senobj=p11; + } + } + break; + } + case 14: //机组无功备用最大 + { x=0; + for(i=1;i<=rqg;i++) //-2w + { p10=(opf_senobj *)malloc(lesenobj); + p10->var_i=com->gq[i]; + p10->var_j=com->gq[i]; + p10->iternum=com->itera_num; + p10->vartype=3; + p10->value=-2*com->wqg[i]; + p10->next=null; + if(p11!=null) + { p11->next=p10; + p11=p10; + } + else + { p11=p10; + sensi->senobj=p11; + } + } + break; + } + case 15: //机组有功调节最小 + { for(i=1;i<=rpg;i++) //2w(PGi-PGi0) + { p10=(opf_senobj *)malloc(lesenobj); + p10->var_i=com->gp[i]; + p10->var_j=com->gp[i]; + p10->iternum=com->itera_num; + p10->vartype=1; + p10->value=2*com->wpg[i]*(com->varx[i]-com->pg[com->gp[i]]); + p10->next=null; + if(p11!=null) + p11->next=p10; + else + { p11=p10; + sensi->senobj=p11; + } + } + break; + } + case 16: //机组无功调节最小 + { for(i=1;i<=rqg;i++) //2w(QGi-QGi0) + { p10=(opf_senobj *)malloc(lesenobj); + p10->var_i=com->gq[i]; + p10->var_j=com->gq[i]; + p10->iternum=com->itera_num; + p10->vartype=3; + p10->value=2*com->wqg[i]*(com->varx[rp+i]-com->qg[com->gq[i]]); + p10->next=null; + if(p11!=null) + { p11->next=p10; + p11=p10; + } + else + { p11=p10; + sensi->senobj=p11; + } + } + break; + } + default: + break; + } + +//等式约束灵敏度部分 + p13=sensi->senequ; + for(i=1;i<=com->rpg;i++) //有功出力部分(等式约束灵敏度) + { p3=cor->jcb[i]; + while(p3!=null) + { p12=(opf_senequ *)malloc(lesenequ); + p12->var_i=com->gp[p3->jcol]; + p12->var_j=com->gp[p3->jcol]; + p12->vartype=1; + p12->equ_i=com->gp[p3->jcol]; + p12->equ_j=com->gp[p3->jcol]; + p12->equtype=1; + p12->iternum=com->itera_num; + p12->value=p3->z; + p12->next=null; + if(p13!=null) + { p13->next=p12; + p13=p12; + } + else + { p13=p12; + sensi->senequ=p13; + } + p3=p3->next; + } + } + for(i=1;i<=com->rpd;i++) //有功负荷部分(等式约束灵敏度) + { p3=cor->jcb[i+com->rpg+com->rpge]; + while(p3!=null) + { p12=(opf_senequ *)malloc(lesenequ); + p12->var_i=com->gp[p3->jcol]; + p12->var_j=com->gp[p3->jcol]; + p12->vartype=2; + p12->equ_i=com->gp[p3->jcol]; + p12->equ_j=com->gp[p3->jcol]; + p12->equtype=1; + p12->iternum=com->itera_num; + p12->value=p3->z; + p12->next=null; + if(p13!=null) + { p13->next=p12; + p13=p12; + } + else + { p13=p12; + sensi->senequ=p13; + } + p3=p3->next; + } + } + for(i=1;i<=com->rqg;i++) //无功出力部分(等式约束灵敏度) + { p3=cor->jcb[i+com->rp]; + while(p3!=null) + { p12=(opf_senequ *)malloc(lesenequ); + p12->var_i=com->gq[i]; + p12->var_j=com->gq[i]; + p12->vartype=3; + p12->equ_i=com->gq[i]; + p12->equ_j=com->gq[i]; + p12->equtype=2; + p12->iternum=com->itera_num; + p12->value=p3->z; + p12->next=null; + if(p13!=null) + { p13->next=p12; + p13=p12; + } + else + { p13=p12; + sensi->senequ=p13; + } + p3=p3->next; + } + } + for(i=1;i<=com->rqd;i++) //无功负荷部分(等式约束灵敏度) + { p3=cor->jcb[i+com->rp+com->rqg+com->rqge]; + while(p3!=null) + { p12=(opf_senequ *)malloc(lesenequ); + p12->var_i=com->gq[i+com->rqg+com->rqge]; + p12->var_j=com->gq[i+com->rqg+com->rqge]; + p12->vartype=4; + p12->equ_i=com->gq[i+com->rqg+com->rqge]; + p12->equ_j=com->gq[i+com->rqg+com->rqge]; + p12->equtype=2; + p12->iternum=com->itera_num; + p12->value=p3->z; + p12->next=null; + if(p13!=null) + { p13->next=p12; + p13=p12; + } + else + { p13=p12; + sensi->senequ=p13; + } + p3=p3->next; + } + } + n=com->rp+com->rq; + p6=com->head_kij; //可调变压器变比部分(等式约束灵敏度) + i=1; + while(p6!=null) + { p3=cor->jcb[i+n]; + while(p3!=null) + { p12=(opf_senequ *)malloc(lesenequ); + p12->var_i=p6->i; + p12->var_j=p6->j; + p12->vartype=5; + t=(p3->irow+1)/2; + p12->equ_i=t; + p12->equ_j=t; +// m=(int)fmod(p3->irow,2); + m=p3->irow%2; + if(m==1) + p12->equtype=1; + else + p12->equtype=2; + p12->iternum=com->itera_num; + p12->value=p3->z; + p12->next=null; + if(p13!=null) + { p13->next=p12; + p13=p12; + } + else + { p13=p12; + sensi->senequ=p13; + } + p3=p3->next; + } + i=i+1; + p6=p6->next; + } + n=com->rp+com->rq+com->rk; + p6=com->head_kbij; //可调移相器变比部分(等式约束灵敏度) + i=1; + while(p6!=null) + { p3=cor->jcb[i+n]; //幅值 + while(p3!=null) + { p12=(opf_senequ *)malloc(lesenequ); + p12->var_i=p6->i; + p12->var_j=p6->j; + p12->vartype=6; + t=(p3->irow+1)/2; + p12->equ_i=t; + p12->equ_j=t; +// m=(int)fmod(p3->irow,2); + m=p3->irow%2; + if(m==1) + p12->equtype=1; + else + p12->equtype=2; + p12->iternum=com->itera_num; + p12->value=p3->z; + p12->next=null; + if(p13!=null) + { p13->next=p12; + p13=p12; + } + else + { p13=p12; + sensi->senequ=p13; + } + p3=p3->next; + } + p3=cor->jcb[i+n+com->rkb]; //角度 + while(p3!=null) + { p12=(opf_senequ *)malloc(lesenequ); + p12->var_i=p6->i; + p12->var_j=p6->j; + p12->vartype=66; + t=(p3->irow+1)/2; + p12->equ_i=t; + p12->equ_j=t; +// m=(int)fmod(p3->irow,2); + m=p3->irow%2; + if(m==1) + p12->equtype=1; + else + p12->equtype=2; + p12->iternum=com->itera_num; + p12->value=p3->z; + p12->next=null; + if(p13!=null) + { p13->next=p12; + p13=p12; + } + else + { p13=p12; + sensi->senequ=p13; + } + p3=p3->next; + } + i=i+1; + p6=p6->next; + } + n=com->rp+com->rq+com->rk+2*com->rkb; + p6=com->head_ti; //可调电容器部分(等式约束灵敏度) + i=1; + while(p6!=null) + { p3=cor->jcb[i+n]; + while(p3!=null) + { p12=(opf_senequ *)malloc(lesenequ); + p12->var_i=p6->i; + p12->var_j=p6->i; + p12->vartype=7; + t=(p3->irow+1)/2; + p12->equ_i=t; + p12->equ_j=t; +// m=(int)fmod(p3->irow,2); + m=p3->irow%2; + if(m==1) + p12->equtype=1; + else + p12->equtype=2; + p12->iternum=com->itera_num; + p12->value=p3->z; + p12->next=null; + if(p13!=null) + { p13->next=p12; + p13=p12; + } + else + { p13=p12; + sensi->senequ=p13; + } + p3=p3->next; + } + i=i+1; + p6=p6->next; + } + n=com->rp+com->rq+com->rk+2*com->rkb+com->rt; + p6=com->head_kx; //可调线路电抗部分(等式约束灵敏度) + i=1; + while(p6!=null) + { p3=cor->jcb[i+n]; + while(p3!=null) + { p12=(opf_senequ *)malloc(lesenequ); + p12->var_i=p6->i; + p12->var_j=p6->j; + p12->vartype=8; + t=(p3->irow+1)/2; + p12->equ_i=t; + p12->equ_j=t; +// m=(int)fmod(p3->irow,2); + m=p3->irow%2; + if(m==1) + p12->equtype=1; + else + p12->equtype=2; + p12->iternum=com->itera_num; + p12->value=p3->z; + p12->next=null; + if(p13!=null) + { p13->next=p12; + p13=p12; + } + else + { p13=p12; + sensi->senequ=p13; + } + p3=p3->next; + } + i=i+1; + p6=p6->next; + } + i=1; + n=com->n_sum*2+2*com->rlcos+com->rvdcos; + m=com->rp+com->rq+com->rk+2*com->rkb+com->rt+com->rx+2*com->rlcos+com->rvdcos; + p9=com->head_dcbus; //直流部分(等式约束灵敏度) + while(p9!=null) + { p3=cor->jcb[i+m]; + while(p3!=null) + { p12=(opf_senequ *)malloc(lesenequ); + p12->var_i=p9->i; + p12->var_j=p9->i; + tm=p3->jcol-m; + if(tm<=com->n_dc) + p12->vartype=9; + if((tm>com->n_dc)&&(tm<=2*com->n_dc)) + p12->vartype=10; + if((tm>2*com->n_dc)&&(tm<=3*com->n_dc)) + p12->vartype=11; + if((tm>3*com->n_dc)&&(tm<=4*com->n_dc)) + p12->vartype=12; + if(tm>4*com->n_dc) + p12->vartype=13; + t=(p3->irow+1)/2; + if(t==p9->iac) //节点功率方程 + { p12->equ_i=t; + p12->equ_j=t; +// tm=(int)fmod(p3->irow,2); + tm=p3->irow%2; + if(m==1) + p12->equtype=1; + else + p12->equtype=2; + } + else + { p12->equ_i=p9->i; + p12->equ_j=p9->i; + tm=p3->irow-n; + if(tm<=com->n_dc) + p12->equtype=3; + if((tm>com->n_dc)&&(tm<=2*com->n_dc)) + p12->equtype=4; + if((tm>2*com->n_dc)&&(tm<=3*com->n_dc)) + p12->equtype=5; + } + p12->iternum=com->itera_num; + p12->value=p3->z; + p12->next=null; + if(p13!=null) + { p13->next=p12; + p13=p12; + } + else + { p13=p12; + sensi->senequ=p13; + } + p3=p3->next; + } + i=i+1; + p9=p9->next; + } + t=com->rr-com->rv; //潮流方程，交流变量(等式约束灵敏度) + for(i=1;i<=com->n_sum;i++) + { p3=cor->jcb[t+2*i-1]; + while(p3!=null) + { p12=(opf_senequ *)malloc(lesenequ); + p12->var_i=i; + p12->var_j=i; + p12->vartype=14; + tm=(p3->irow+1)/2; + p12->equ_i=tm; + p12->equ_j=tm; +// m=(int)fmod(p3->irow,2); + m=p3->irow%2; + if(m==1) + p12->equtype=1; + else + p12->equtype=2; + + p12->iternum=com->itera_num; + p12->value=p3->z; + p12->next=null; + if(p13!=null) + { p13->next=p12; + p13=p12; + } + else + { p13=p12; + sensi->senequ=p13; + } + p3=p3->next; + } + p3=cor->jcb[t+2*i]; + while(p3!=null) + { p12=(opf_senequ *)malloc(lesenequ); + p12->var_i=i; + p12->var_j=i; + p12->vartype=15; + tm=(p3->irow+1)/2; + p12->equ_i=tm; + p12->equ_j=tm; +// m=(int)fmod(p3->irow,2); + m=p3->irow%2; + if(m==1) + p12->equtype=1; + else + p12->equtype=2; + + p12->iternum=com->itera_num; + p12->value=p3->z; + p12->next=null; + if(p13!=null) + { p13->next=p12; + p13=p12; + } + else + { p13=p12; + sensi->senequ=p13; + } + p3=p3->next; + } + } + +//不等式约束灵敏度 + tn=rr-rv; + p15=sensi->seninequ; + for(i=1;i<=com->rpg;i++) //有功出力(不等式约束灵敏度) + { p3=cor->dg[i]; + while(p3!=null) + { p14=(opf_seninequ *)malloc(leseninequ); + p14->var_i=com->gp[i]; + p14->var_j=com->gp[i]; + p14->vartype=1; + p14->inequ_i=com->gp[i]; + p14->inequ_j=com->gp[i]; + p14->inequtype=1; + p14->iternum=com->itera_num; + p14->value=p3->z; + p14->next=null; + if(p15!=null) + { p15->next=p14; + p15=p14; + } + else + { p15=p14; + sensi->seninequ=p15; + } + p3=p3->next; + } + } + for(i=1;i<=com->rpd;i++) //有功负荷 (不等式约束灵敏度) + { p3=cor->dg[i+rpg+com->rpge]; + while(p3!=null) + { p14=(opf_seninequ *)malloc(leseninequ); + p14->var_i=com->gp[i+rpg+com->rpge]; + p14->var_j=com->gp[i+rpg+com->rpge]; + p14->vartype=2; + p14->inequ_i=com->gp[i+rpg+com->rpge]; + p14->inequ_j=com->gp[i+rpg+com->rpge]; + p14->inequtype=2; + p14->iternum=com->itera_num; + p14->value=p3->z; + p14->next=null; + if(p15!=null) + { p15->next=p14; + p15=p14; + } + else + { p15=p14; + sensi->seninequ=p15; + } + p3=p3->next; + } + } + for(i=1;i<=com->rqg;i++) //无功出力 (不等式约束灵敏度) + { p3=cor->dg[i+rp]; + while(p3!=null) + { p14=(opf_seninequ *)malloc(leseninequ); + p14->var_i=com->gq[i]; + p14->var_j=com->gq[i]; + p14->vartype=3; + p14->inequ_i=com->gq[i]; + p14->inequ_j=com->gq[i]; + p14->inequtype=3; + p14->iternum=com->itera_num; + p14->value=p3->z; + p14->next=null; + if(p15!=null) + { p15->next=p14; + p15=p14; + } + else + { p15=p14; + sensi->seninequ=p15; + } + p3=p3->next; + } + } + for(i=1;i<=com->rqd;i++) //无功负荷 (不等式约束灵敏度) + { p3=cor->dg[i+rp+rqg+com->rqge]; + while(p3!=null) + { p14=(opf_seninequ *)malloc(leseninequ); + p14->var_i=com->gq[i+rqg+com->rqge]; + p14->var_j=com->gq[i+rqg+com->rqge]; + p14->vartype=4; + p14->inequ_i=com->gq[i+rqg+com->rqge]; + p14->inequ_j=com->gq[i+rqg+com->rqge]; + p14->inequtype=4; + p14->iternum=com->itera_num; + p14->value=p3->z; + p14->next=null; + if(p15!=null) + { p15->next=p14; + p15=p14; + } + else + { p15=p14; + sensi->seninequ=p15; + } + p3=p3->next; + } + } + p6=com->head_kij; //可调变压器变比部分(不等式约束灵敏度) + i=1; + while(p6!=null) + { p14=(opf_seninequ *)malloc(leseninequ); + p14->var_i=p6->i; + p14->var_j=p6->j; + p14->vartype=5; + p14->inequ_i=p6->i; + p14->inequ_j=p6->j; + p14->inequtype=5; + p14->iternum=com->itera_num; + p14->value=1; + p14->next=null; + if(p15!=null) + { p15->next=p14; + p15=p14; + } + else + { p15=p14; + sensi->seninequ=p15; + } + p6=p6->next; + } + + p6=com->head_kbij; //可调移相器变比部分(等式约束灵敏度) + while(p6!=null) + { p14=(opf_seninequ *)malloc(leseninequ);//幅值 + p14->var_i=p6->i; + p14->var_j=p6->j; + p14->vartype=6; + p14->inequ_i=p6->i; + p14->inequ_j=p6->j; + p14->inequtype=6; + p14->iternum=com->itera_num; + p14->value=1; + p14->next=null; + if(p15!=null) + { p15->next=p14; + p15=p14; + } + else + { p15=p14; + sensi->seninequ=p15; + } + p14=(opf_seninequ *)malloc(leseninequ);//角度 + p14->var_i=p6->i; + p14->var_j=p6->j; + p14->vartype=66; + p14->inequ_i=p6->i; + p14->inequ_j=p6->j; + p14->inequtype=7; + p14->iternum=com->itera_num; + p14->value=1; + p14->next=null; + if(p15!=null) + { p15->next=p14; + p15=p14; + } + else + { p15=p14; + sensi->seninequ=p15; + } + p6=p6->next; + } + p6=com->head_ti; //可调电容器部分(不等式约束灵敏度) + while(p6!=null) + { p14=(opf_seninequ *)malloc(leseninequ); + p14->var_i=p6->i; + p14->var_j=p6->j; + p14->vartype=7; + p14->inequ_i=p6->i; + p14->inequ_j=p6->j; + p14->inequtype=8; + p14->iternum=com->itera_num; + p14->value=1; + p14->next=null; + if(p15!=null) + { p15->next=p14; + p15=p14; + } + else + { p15=p14; + sensi->seninequ=p15; + } + p6=p6->next; + } + p6=com->head_kx; //可调线路电抗部分(不等式约束灵敏度) + while(p6!=null) + { p14=(opf_seninequ *)malloc(leseninequ); + p14->var_i=p6->i; + p14->var_j=p6->j; + p14->vartype=8; + p14->inequ_i=p6->i; + p14->inequ_j=p6->j; + p14->inequtype=9; + p14->iternum=com->itera_num; + p14->value=1; + p14->next=null; + if(p15!=null) + { p15->next=p14; + p15=p14; + } + else + { p15=p14; + sensi->seninequ=p15; + } + p6=p6->next; + } + p9=com->head_dcbus; //直流部分(不等式约束灵敏度) + while(p9!=null) + { p14=(opf_seninequ *)malloc(leseninequ); + p14->var_i=p9->i; + p14->var_j=p9->i; + p14->vartype=9; + p14->inequ_i=p9->i; + p14->inequ_j=p9->i; + p14->inequtype=10; + p14->iternum=com->itera_num; + p14->value=1; + p14->next=null; + if(p15!=null) + { p15->next=p14; + p15=p14; + } + else + { p15=p14; + sensi->seninequ=p15; + } + + p14=(opf_seninequ *)malloc(leseninequ); + p14->var_i=p9->i; + p14->var_j=p9->i; + p14->vartype=10; + p14->inequ_i=p9->i; + p14->inequ_j=p9->i; + p14->inequtype=11; + p14->iternum=com->itera_num; + p14->value=1; + p14->next=null; + if(p15!=null) + { p15->next=p14; + p15=p14; + } + else + { p15=p14; + sensi->seninequ=p15; + } + + p14=(opf_seninequ *)malloc(leseninequ); + p14->var_i=p9->i; + p14->var_j=p9->i; + p14->vartype=11; + p14->inequ_i=p9->i; + p14->inequ_j=p9->i; + p14->inequtype=12; + p14->iternum=com->itera_num; + p14->value=1; + p14->next=null; + if(p15!=null) + { p15->next=p14; + p15=p14; + } + else + { p15=p14; + sensi->seninequ=p15; + } + + p14=(opf_seninequ *)malloc(leseninequ); + p14->var_i=p9->i; + p14->var_j=p9->i; + p14->vartype=12; + p14->inequ_i=p9->i; + p14->inequ_j=p9->i; + p14->inequtype=13; + p14->iternum=com->itera_num; + p14->value=1; + p14->next=null; + if(p15!=null) + { p15->next=p14; + p15=p14; + } + else + { p15=p14; + sensi->seninequ=p15; + } + + p14=(opf_seninequ *)malloc(leseninequ); + p14->var_i=p9->i; + p14->var_j=p9->i; + p14->vartype=13; + p14->inequ_i=p9->i; + p14->inequ_j=p9->i; + p14->inequtype=14; + p14->iternum=com->itera_num; + p14->value=1; + p14->next=null; + if(p15!=null) + { p15->next=p14; + p15=p14; + } + else + { p15=p14; + sensi->seninequ=p15; + } + p9=p9->next; + } + for(i=1;i<=com->rv;i++) + { p14=(opf_seninequ *)malloc(leseninequ); + p14->var_i=i; + p14->var_j=i; + p14->vartype=15; + p14->inequ_i=i; + p14->inequ_j=i; + p14->inequtype=15; + p14->iternum=com->itera_num; + p14->value=1; + p14->next=null; + if(p15!=null) + { p15->next=p14; + p15=p14; + } + else + { p15=p14; + sensi->seninequ=p15; + } + } + + p2=com->head_lpij; + i=1; + while(p2!=null) + { p3=cor->dg[com->rr+i]; + while(p3!=null) + { p14=(opf_seninequ *)malloc(leseninequ); + tm=(p3->irow+1-tn)/2; + p14->var_i=tm; + p14->var_j=tm; +// m=(int)fmod((p3->irow-tn),2); + m=(p3->irow-tn)%2; + if(m==1) + p14->vartype=14; + else + p14->vartype=15; + p14->inequ_i=p2->i; + p14->inequ_j=p2->j; + p14->inequtype=16; + p14->iternum=com->itera_num; + p14->value=p3->z; + p14->next=null; + if(p15!=null) + { p15->next=p14; + p15=p14; + } + else + { p15=p14; + sensi->seninequ=p15; + } + p3=p3->next; + } + p2=p2->next; + i=i+1; + } + + p2=com->head_lqij; + i=1; + while(p2!=null) + { p3=cor->dg[com->rr+rlpij+i]; + while(p3!=null) + { p14=(opf_seninequ *)malloc(leseninequ); + tm=(p3->irow+1-tn)/2; + p14->var_i=tm; + p14->var_j=tm; +// m=(int)fmod((p3->irow-tn),2); + m=(p3->irow-tn)%2; + if(m==1) + p14->vartype=14; + else + p14->vartype=15; + p14->inequ_i=p2->i; + p14->inequ_j=p2->j; + p14->inequtype=17; + p14->iternum=com->itera_num; + p14->value=p3->z; + p14->next=null; + if(p15!=null) + { p15->next=p14; + p15=p14; + } + else + { p15=p14; + sensi->seninequ=p15; + } + p3=p3->next; + } + p2=p2->next; + i=i+1; + } + + p2=com->head_lsij; + i=1; + while(p2!=null) + { p3=cor->dg[com->rr+rlpij+rlqij+i]; + while(p3!=null) + { p14=(opf_seninequ *)malloc(leseninequ); + tm=(p3->irow+1-tn)/2; + p14->var_i=tm; + p14->var_j=tm; +// m=(int)fmod((p3->irow-tn),2); + m=(p3->irow-tn)%2; + if(m==1) + p14->vartype=14; + else + p14->vartype=15; + p14->inequ_i=p2->i; + p14->inequ_j=p2->j; + p14->inequtype=18; + p14->iternum=com->itera_num; + p14->value=p3->z; + p14->next=null; + if(p15!=null) + { p15->next=p14; + p15=p14; + } + else + { p15=p14; + sensi->seninequ=p15; + } + p3=p3->next; + } + p2=p2->next; + i=i+1; + } + + p2=com->head_liij; + i=1; + while(p2!=null) + { p3=cor->dg[com->rr+rlpij+rlqij+rlsij+i]; + while(p3!=null) + { p14=(opf_seninequ *)malloc(leseninequ); + tm=(p3->irow+1-tn)/2; + p14->var_i=tm; + p14->var_j=tm; +// m=(int)fmod((p3->irow-tn),2); + m=(p3->irow-tn)%2; + if(m==1) + p14->vartype=14; + else + p14->vartype=15; + p14->inequ_i=p2->i; + p14->inequ_j=p2->j; + p14->inequtype=19; + p14->iternum=com->itera_num; + p14->value=p3->z; + p14->next=null; + if(p15!=null) + { p15->next=p14; + p15=p14; + } + else + { p15=p14; + sensi->seninequ=p15; + } + p3=p3->next; + } + p2=p2->next; + i=i+1; + } + + p5=com->head_vpd; //有功负荷模型部分 + i=1; + while(p5!=null) + { p3=cor->dg[com->rr+rlpij+rlqij+rlsij+rliij+i]; + while(p3!=null) + { p14=(opf_seninequ *)malloc(leseninequ); + tm=(p3->irow+1-tn)/2; + p14->var_i=tm; + p14->var_j=tm; + p14->vartype=15; + p14->inequ_i=p5->i; + p14->inequ_j=p5->i; + p14->inequtype=20; + p14->iternum=com->itera_num; + p14->value=p3->z; + p14->next=null; + if(p15!=null) + { p15->next=p14; + p15=p14; + } + else + { p15=p14; + sensi->seninequ=p15; + } + p3=p3->next; + } + p5=p5->next; + i=i+1; + } + p5=com->head_vqd; //无功负荷模型部分 + i=1; + while(p5!=null) + { p3=cor->dg[com->rr+rlpij+rlqij+rlsij+rliij+rvpd+i]; + while(p3!=null) + { p14=(opf_seninequ *)malloc(leseninequ); + tm=(p3->irow+1-tn)/2; + p14->var_i=tm; + p14->var_j=tm; + p14->vartype=15; + p14->inequ_i=p5->i; + p14->inequ_j=p5->i; + p14->inequtype=21; + p14->iternum=com->itera_num; + p14->value=p3->z; + p14->next=null; + if(p15!=null) + { p15->next=p14; + p15=p14; + } + else + { p15=p14; + sensi->seninequ=p15; + } + p3=p3->next; + } + p5=p5->next; + i=i+1; + } + + i=1; + p2=com->head_spij; + while(p2!=null) + { p3=cor->dg[com->rr+rlpij+rlqij+rlsij+rliij+rvpd+rvqd+i]; + while(p3!=null) + { p14=(opf_seninequ *)malloc(leseninequ); + tm=(p3->irow+1-tn)/2; + p14->var_i=tm; + p14->var_j=tm; +// m=(int)fmod((p3->irow-tn),2); + m=(p3->irow-tn)%2; + if(m==1) + p14->vartype=14; + else + p14->vartype=15; + p14->inequ_i=0; + p14->inequ_j=0; + p14->inequtype=22; + p14->iternum=com->itera_num; + p14->value=p3->z; + p14->next=null; + if(p15!=null) + { p15->next=p14; + p15=p14; + } + else + { p15=p14; + sensi->seninequ=p15; + } + p3=p3->next; + } + p2=p2->next; + i=i+1; + } + + i=1; + p2=com->head_sqij; + while(p2!=null) + { p3=cor->dg[com->rr+rlpij+rlqij+rlsij+rliij+rvpd+rvqd+rspij+i]; + while(p3!=null) + { p14=(opf_seninequ *)malloc(leseninequ); + tm=(p3->irow+1-tn)/2; + p14->var_i=tm; + p14->var_j=tm; +// m=(int)fmod((p3->irow-tn),2); + m=(p3->irow-tn)%2; + if(m==1) + p14->vartype=14; + else + p14->vartype=15; + p14->inequ_i=0; + p14->inequ_j=0; + p14->inequtype=23; + p14->iternum=com->itera_num; + p14->value=p3->z; + p14->next=null; + if(p15!=null) + { p15->next=p14; + p15=p14; + } + else + { p15=p14; + sensi->seninequ=p15; + } + p3=p3->next; + } + p2=p2->next; + i=i+1; + } + + for(i=1;i<=rgpcd;i++) //功率园图 + { p3=cor->dg[com->rr+rlpij+rlqij+rlsij+rliij+rvpd+rvqd+rspij+rsqij+i]; + while(p3!=null) + { p14=(opf_seninequ *)malloc(leseninequ); + if(p3->irow<=com->rp) + { p14->var_i=com->gp[p3->irow]; + p14->var_j=com->gp[p3->irow]; +// tn=p3->irow; + p14->vartype=1; + p14->inequ_i=com->gp[p3->irow]; + p14->inequ_j=com->gp[p3->irow]; + } + else + { p14->var_i=com->gq[p3->irow-com->rp]; + p14->var_j=com->gq[p3->irow-com->rp]; +// tn=p3->irow-com->rp; + p14->vartype=3; + p14->inequ_i=com->gq[p3->irow-com->rp]; + p14->inequ_j=com->gq[p3->irow-com->rp]; + } +// p14->inequ_i=tn; +// p14->inequ_j=tn; + + p14->inequtype=24; + p14->iternum=com->itera_num; + p14->value=p3->z; + p14->next=null; + if(p15!=null) + { p15->next=p14; + p15=p14; + } + else + { p15=p14; + sensi->seninequ=p15; + } + p3=p3->next; + } + } + + t=com->rp+com->rq+com->rk+2*com->rkb+com->rt+com->rx+2*com->rlcos+com->rvdcos; + p9=com->head_dcbus; + i=1; + while(p9!=null) //直流线路功率 + { p3=cor->dg[com->rr+rlpij+rlqij+rlsij+rliij+rvpd+rvqd+rspij+rsqij+rgpcd+i]; + while(p3!=null) + { p14=(opf_seninequ *)malloc(leseninequ); + p14->var_i=p9->i; + p14->var_j=p9->i; + if((p3->irow-t)<=com->n_dc) + p14->vartype=9; + else + p14->vartype=10; + p14->inequ_i=p9->i; + p14->inequ_j=p9->i; + p14->inequtype=25; + p14->iternum=com->itera_num; + p14->value=p3->z; + p14->next=null; + if(p15!=null) + { p15->next=p14; + p15=p14; + } + else + { p15=p14; + sensi->seninequ=p15; + } + p3=p3->next; + } + p9=p9->next; + } + + free(v); + free(rad); + free(derf); +} + +void DeleteVarsensitive(opf_sensitive *sensitive) //清sensitive内存 +{ + opf_senobj *p1; + opf_senequ *p2; + opf_seninequ *p3; + + while(sensitive->senobj!=null) + { p1=sensitive->senobj->next; + free(sensitive->senobj); + sensitive->senobj=p1; + } + + while(sensitive->senequ!=null) + { p2=sensitive->senequ->next; + free(sensitive->senequ); + sensitive->senequ=p2; + } + + while(sensitive->seninequ!=null) + { p3=sensitive->seninequ->next; + free(sensitive->seninequ); + sensitive->seninequ=p3; + } + + + free(sensitive->senobj); + free(sensitive->senequ); + free(sensitive->seninequ); + + return; +} + +void InitializeVarSensitive(opf_sensitive *sensitive)//开相应的内存空间 +{ + sensitive->senobj=null; + sensitive->senequ=null; + sensitive->seninequ=null; + sensitive->num=0; + return; +} + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +