void SPxSolver::qualSlackViolation(Real& maxviol, Real& sumviol) const
{
maxviol = 0.0;
sumviol = 0.0;
DVector solu( nCols() );
DVector slacks( nRows() );
getPrimal( solu );
getSlacks( slacks );
for( int row = 0; row < nRows(); ++row )
{
const SVector& rowvec = rowVector( row );
Real val = 0.0;
for( int col = 0; col < rowvec.size(); ++col )
val += rowvec.value( col ) * solu[rowvec.index( col )];
Real viol = spxAbs(val - slacks[row]);
if (viol > maxviol)
maxviol = viol;
sumviol += viol;
}
}
void SPxSolver::qualConstraintViolation(Real& maxviol, Real& sumviol) const
{
maxviol = 0.0;
sumviol = 0.0;
DVector solu( nCols() );
getPrimal( solu );
for( int row = 0; row < nRows(); ++row )
{
const SVector& rowvec = rowVector( row );
Real val = 0.0;
for( int col = 0; col < rowvec.size(); ++col )
val += rowvec.value( col ) * solu[rowvec.index( col )];
Real viol = 0.0;
assert(lhs( row ) <= rhs( row ));
if (val < lhs( row ))
viol = spxAbs(val - lhs( row ));
else
if (val > rhs( row ))
viol = spxAbs(val - rhs( row ));
if (viol > maxviol)
maxviol = viol;
sumviol += viol;
}
}
void SPxSolver::qualBoundViolation(
Real& maxviol, Real& sumviol) const
{
maxviol = 0.0;
sumviol = 0.0;
DVector solu( nCols() );
getPrimal( solu );
for( int col = 0; col < nCols(); ++col )
{
assert( lower( col ) <= upper( col ));
Real viol = 0.0;
if (solu[col] < lower( col ))
viol = spxAbs( solu[col] - lower( col ));
else
if (solu[col] > upper( col ))
viol = spxAbs( solu[col] - upper( col ));
if (viol > maxviol)
maxviol = viol;
sumviol += viol;
}
}
/*----------------------Inicio da funcao estado-------------------*/
void estado(double ce[],double cle[]){
double dx1[nbmax],dx2[nbmax],dpmax,dqmax,aux;
int k,ntot,lim,kp,kq,inic,i;
/*Cadeia de Zolenkopf com elementos nao-nulos das matrizes B' e B'' */
/*-----------Inicializando contadores e chaves----------*/
nitea = 0; // contador de iteracoes ativas
niter = 0; // contador de iteracoes reativas
kp = 1; // chaves
kq = 1;
lim = 60;
/*------------------- Inicio do processo iterativo-------------------- */
inic = 1;
while(niter <= lim && nitea <= lim && (kp!= 0 || kq != 0)){
if(inic == 1){
/*---------- CALCULO AS POTENCIAS ATIVAS----------- */
/*-------Calculo das injecoes de potencia nas barras:--- */
potencia();
inic = 0;
/*----- Calculo do MISMATCH ATIVO e do seu valor maximo:----*/
dpmax = 0.e0;
for(k=0; k<nb; k++){
dx1[k] = pes[k] - p[k];
if( itipo[k] != 2 ){ //se nao for barra slack
if (fabs(dx1[k]) > dpmax)//maior valor absoluto do vetor de mismatch ativo
dpmax = fabs(dx1[k]);
}
dx1[k] = dx1[k]/v[k];
}
/*--------Teste de convergencia (fase ATIVA):---------------*/
if( dpmax > 1.e+20 ){
exit(1);
}
else
if( dpmax <= tol )
kp = 0;
else{
/*---------------------------------------------------------------
Solucao do sistema linear P-TETA para MISMATCH ATIVO:
Chamada da rotina solu() - Solucao do Sist. Linear B'.dtet = dx1
----------------------------------------------------------------*/
solu(ce,dx1);
/*----------------------------------------
Atualiza o Vetor de Angulos Nodais TETA:
----------------------------------------*/
for( k=0; k<nb; k++){
tet[k] = tet[k] + dx1[k];
t[k] = tet[k];
}
/*------------------------------------------
Incrementa o Contador de Iteracoes Ativas
----------------------------------------- */
nitea++;
/*-------------Retorna a chave REATIVA ao valor inicial-----------*/
kq = 1;
} // fim do else
}
else // else de inic=1
if(kq == 1){
/*------------------------------------------------------
OBS: dx1[]-> Armazena os incrementos dos angulos nodais
dx2[]-> Armazena os incrementos das tensoes nodais
--------------------------------------------------------
--------------CALCULO DAS POTENCIAS REATIVAS------------
--------------------------------------------
Calculo das injecoes de potencia nas barras:
---------------------------------------------*/
potencia();
inic = 1;
/*---Calculo do MISMATCH REATIVO e do seu valor maximo:-----------*/
dqmax = 0.e0;
for( k=0; k<nb; k++){
dx2[k] = qes[k] - q[k];
if( itipo[k] <= 0 ){
if (fabs(dx2[k]) > dqmax)
dqmax = fabs(dx2[k]);
//maior valorabsoluto do vetor de mismatch reativo
dx2[k] = dx2[k]/v[k];
}
} // fim do for...
/*---------Teste de convergencia (fase REATIVA):----------*/
if( dqmax > 1.e+10 ){
// printf("\n DIVERGENCIA ...\n");
exit(1);
}
else{
if( dqmax <= tol )
kq = 0;
else{
/*----------Solucao do sistema linear Q-V para MISMATCH REATIVO:
----------------------------------------------------------------
Chamada da rotina solu() - Solucao do Sist. Linear B".dv = dx2
----------------------------------------------------------------*/
solu(cle,dx2);
/*-----------Atualiza o Vetor de Magnitudes Nodais V:-------------*/
for( k=0; k<nb; k++)
if( itipo[k] == 0 )
v[k] = v[k] + dx2[k];
/*----------Incrementa o Contador de Iteracoes Reativas ---------*/
kq = 1;
niter++;
/*----------Retorna a chave ATIVA ao valor inicial----------*/
kp = 1;
} // else ( dqmax<tol )
} // else ( dqmax> 1e10)
} // else ( se kq=1 )
} // while
if ((niter > lim) || (nitea >lim)){
/*------Fim do Processo Iterativo por Exceder o Limite Esp. de Iteracoes-------------*/
ntot = nitea + niter;
nconv = 1;
printf("\n O PROCESSO NAO CONVERGE COM %4d ITERACOES !!\n", ntot);
exit(1);
}
/*---------------- Fim do Processo Iterativo com Sucesso-------------*/
/*----------Armazena as injecoes/geracoes do ponto inicial--------------*/
for( k=0; k<nb; k++)
if( itipo[k] == 2 )
pg0[k]= p[k] + pca[k];
else
pg0[k]= pes[k] + pca[k];
return;
}
