commit dc5a09ff9dabbf4d5480d927e57bb07b326aa9d5 Author: dmy@lab Date: Sun Feb 1 16:58:04 2015 +0800 淇濆瓨 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 0000000..d893fcd Binary files /dev/null and b/libcoinhsl.lib differ diff --git a/opf.cpp b/opf.cpp new file mode 100644 index 0000000..5f4a478 --- /dev/null +++ b/opf.cpp @@ -0,0 +1,17655 @@ +//******中调无功优化版******2010.10 + +/* +* Copyright (c) 1997-2008, IPSO 广西大学最优化研究所 (ipso.gxu.edu.cn) +* All rights reserved. +* +* 文件名称： opf.cpp +* 功能：交直流OPF +* 说明：数学模型为《在线OPF计算软件设计方案》所设定 +* +* 当前版本：2.0（南瑞稳控所） +* 作者：李滨 阳育德 李佩杰 +* 完成日期： +* 修改：将线路支路无功功率约束改为变压器支路无功约束2011.1 +*/ + + +#include "stdio.h" +#include "math.h" +#include "malloc.h" + +//#include "windows.h" +//#include "windowsx.h" + +#include + +#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; +} + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +