PetscErrorCode computeMaxEigVal(Mat A, PetscInt its, PetscScalar *eig)
{
PetscErrorCode ierr;
PetscRandom rctx; /* random number generator context */
Vec x0, x, x_1, tmp;
PetscScalar lambda_its, lambda_its_1;
PetscInt i;
PetscFunctionBeginUser;
ierr = PetscRandomCreate(PETSC_COMM_WORLD,&rctx);CHKERRQ(ierr);
ierr = PetscRandomSetFromOptions(rctx);CHKERRQ(ierr);
ierr = MatGetVecs(A, &x_1, &x);CHKERRQ(ierr);
ierr = VecSetRandom(x, rctx);CHKERRQ(ierr);
ierr = VecDuplicate(x, &x0);CHKERRQ(ierr);
ierr = VecCopy(x, x0);CHKERRQ(ierr);
ierr = MatMult(A, x, x_1);CHKERRQ(ierr);
for (i=0; i<its; i++) {
tmp = x; x = x_1; x_1 = tmp;
ierr = MatMult(A, x, x_1);CHKERRQ(ierr);
}
ierr = VecDot(x0, x, &lambda_its);CHKERRQ(ierr);
ierr = VecDot(x0, x_1, &lambda_its_1);CHKERRQ(ierr);
*eig = lambda_its_1/lambda_its;
ierr = VecDestroy(&x0);CHKERRQ(ierr);
ierr = VecDestroy(&x);CHKERRQ(ierr);
ierr = VecDestroy(&x_1);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
//求点到直线的垂足，返回点到垂足的距离。输入直线的两端点，当前点，输出垂足点，返回点到垂足的距离.Tested.
float FootPoint(const float* Posi1, const float* Posi2, const float* PosiCur, float* fp)
{
float SE[3];
float SC[3];
float CE[3];
int i;
VecSub(Posi2,Posi1,SE);
VecSub(PosiCur,Posi1,SC);
VecSub(Posi2,PosiCur,CE);
if(VecDot(SE,SC) < 0)
for(i=0; i<3; i++)
fp[i] = Posi1[i];
else if(VecDot(SE,CE) < 0)
for(i=0; i<3; i++)
fp[i] = Posi2[i];
else
{
fp[1] = ( (SE[0]*SE[0]/SE[1]+SE[2]*SE[2]/SE[1])*Posi1[1] - SE[0]*(Posi1[0]-PosiCur[0]) + SE[1]*PosiCur[1] - SE[2]*(Posi1[2]-PosiCur[2]) ) / ( SE[0]*SE[0]/SE[1]+SE[1]+SE[2]*SE[2]/SE[1] );
fp[0] = SE[0]/SE[1]*(fp[1]-Posi1[1]) + Posi1[0];
fp[2] = SE[2]/SE[1]*(fp[1]-Posi1[1]) + Posi1[2];
}
return sqrt((fp[0]-PosiCur[0])*(fp[0]-PosiCur[0]) + (fp[1]-PosiCur[1])*(fp[1]-PosiCur[1]) + (fp[2]-PosiCur[2])*(fp[2]-PosiCur[2]));
}
EXTERN_C_END
#undef __FUNCT__
#define __FUNCT__ "SNESNCGComputeYtJtF_Private"
/*
Assuming F = SNESComputeFunction(X) compute Y^tJ^tF using a simple secant approximation of the jacobian.
*/
PetscErrorCode SNESNCGComputeYtJtF_Private(SNES snes, Vec X, Vec F, Vec Y, Vec W, Vec G, PetscScalar * ytJtf)
{
PetscErrorCode ierr;
PetscScalar ftf, ftg, fty, h;
PetscFunctionBegin;
ierr = VecDot(F, F, &ftf);
CHKERRQ(ierr);
ierr = VecDot(F, Y, &fty);
CHKERRQ(ierr);
h = 1e-5*fty / fty;
ierr = VecCopy(X, W);
CHKERRQ(ierr);
ierr = VecAXPY(W, -h, Y);
CHKERRQ(ierr); /* this is arbitrary */
ierr = SNESComputeFunction(snes, W, G);
CHKERRQ(ierr);
ierr = VecDot(G, F, &ftg);
CHKERRQ(ierr);
*ytJtf = (ftg - ftf) / h;
PetscFunctionReturn(0);
}
PetscErrorCode BSSCR_PCScGtKGUseStandardScaling( PC pc )
{
PC_SC_GtKG ctx = (PC_SC_GtKG)pc->data;
Mat K,G,D,C;
Vec rG;
PetscScalar rg2, rg, ra;
PetscInt N;
Vec rA, rC;
Vec L1,L2, R1,R2;
BSSCR_BSSCR_pc_error_ScGtKG( pc, __func__ );
L1 = ctx->X1;
L2 = ctx->X2;
R1 = ctx->Y1;
R2 = ctx->Y2;
rA = L1;
rC = L2;
K = ctx->F;
G = ctx->Bt;
D = ctx->B;
C = ctx->C;
VecDuplicate( rA, &rG );
/* Get magnitude of K */
MatGetRowMax( K, rA, PETSC_NULL );
VecSqrt( rA );
VecReciprocal( rA );
VecDot( rA,rA, &ra );
VecGetSize( rA, &N );
ra = PetscSqrtScalar( ra/N );
/* Get magnitude of G */
MatGetRowMax( G, rG, PETSC_NULL );
VecDot( rG, rG, &rg2 );
VecGetSize( rG, &N );
rg = PetscSqrtScalar(rg2/N);
// printf("rg = %f \n", rg );
VecSet( rC, 1.0/(rg*ra) );
Stg_VecDestroy(&rG );
VecCopy( L1, R1 );
VecCopy( L2, R2 );
PetscFunctionReturn(0);
}
static PetscErrorCode TaoSolve_SSILS(Tao tao)
{
TAO_SSLS *ssls = (TAO_SSLS *)tao->data;
PetscReal psi, ndpsi, normd, innerd, t=0;
PetscReal delta, rho;
PetscInt iter=0,kspits;
TaoConvergedReason reason;
TaoLineSearchConvergedReason ls_reason;
PetscErrorCode ierr;
PetscFunctionBegin;
/* Assume that Setup has been called!
Set the structure for the Jacobian and create a linear solver. */
delta = ssls->delta;
rho = ssls->rho;
ierr = TaoComputeVariableBounds(tao);CHKERRQ(ierr);
ierr = VecMedian(tao->XL,tao->solution,tao->XU,tao->solution);CHKERRQ(ierr);
ierr = TaoLineSearchSetObjectiveAndGradientRoutine(tao->linesearch,Tao_SSLS_FunctionGradient,tao);CHKERRQ(ierr);
ierr = TaoLineSearchSetObjectiveRoutine(tao->linesearch,Tao_SSLS_Function,tao);CHKERRQ(ierr);
/* Calculate the function value and fischer function value at the
current iterate */
ierr = TaoLineSearchComputeObjectiveAndGradient(tao->linesearch,tao->solution,&psi,ssls->dpsi);CHKERRQ(ierr);
ierr = VecNorm(ssls->dpsi,NORM_2,&ndpsi);CHKERRQ(ierr);
while (1) {
ierr=PetscInfo3(tao, "iter: %D, merit: %g, ndpsi: %g\n",iter, (double)ssls->merit, (double)ndpsi);CHKERRQ(ierr);
/* Check the termination criteria */
ierr = TaoMonitor(tao,iter++,ssls->merit,ndpsi,0.0,t,&reason);CHKERRQ(ierr);
if (reason!=TAO_CONTINUE_ITERATING) break;
/* Calculate direction. (Really negative of newton direction. Therefore,
rest of the code uses -d.) */
ierr = KSPSetOperators(tao->ksp,tao->jacobian,tao->jacobian_pre);CHKERRQ(ierr);
ierr = KSPSolve(tao->ksp,ssls->ff,tao->stepdirection);CHKERRQ(ierr);
ierr = KSPGetIterationNumber(tao->ksp,&kspits);CHKERRQ(ierr);
tao->ksp_its+=kspits;
ierr = VecNorm(tao->stepdirection,NORM_2,&normd);CHKERRQ(ierr);
ierr = VecDot(tao->stepdirection,ssls->dpsi,&innerd);CHKERRQ(ierr);
/* Make sure that we have a descent direction */
if (innerd <= delta*pow(normd, rho)) {
ierr = PetscInfo(tao, "newton direction not descent\n");CHKERRQ(ierr);
ierr = VecCopy(ssls->dpsi,tao->stepdirection);CHKERRQ(ierr);
ierr = VecDot(tao->stepdirection,ssls->dpsi,&innerd);CHKERRQ(ierr);
}
ierr = VecScale(tao->stepdirection, -1.0);CHKERRQ(ierr);
innerd = -innerd;
ierr = TaoLineSearchSetInitialStepLength(tao->linesearch,1.0);
ierr = TaoLineSearchApply(tao->linesearch,tao->solution,&psi,ssls->dpsi,tao->stepdirection,&t,&ls_reason);CHKERRQ(ierr);
ierr = VecNorm(ssls->dpsi,NORM_2,&ndpsi);CHKERRQ(ierr);
}
PetscFunctionReturn(0);
}
//---------------------------------------------------------------------------
//fresnel equation
// ni = ior outside
// nt = ior inside
// cos(Oi) VecDot(-ray.dir, nhit)
// cos(Ot) VecDot(refr.dir, -nhit)
// r_ = E0r / E0i = [ni * cos(Oi) - nt * cos(Ot)] / [ni * cos(Oi) + nt * cos(Ot)]
// t_ = E0t / E0i = 2ni * cos(Oi) / [ni * cos(Oi) + nt * cos(Ot)]
//---------------------------------------------------------------------------
void fresnelEquation(Flt ni, Flt nt, Ray *ray, Vec refr, Vec nhit, Flt *r, Flt *t) {
Vec v;
VecCopyNeg(ray->d, v);
Flt cosOi = VecDot(v, nhit);
VecCopyNeg(nhit, v);
Flt cosOt = VecDot(refr, v);
Flt E0r = ni * cosOi - nt * cosOt;
Flt E0i = ni * cosOi + nt * cosOt;
*r = E0r / E0i;
Flt E0t = 2.0*ni * cosOi;
*t = E0t / E0i;
}
static PetscErrorCode IPMComputeKKT(Tao tao)
{
TAO_IPM *ipmP = (TAO_IPM *)tao->data;
PetscScalar norm;
PetscErrorCode ierr;
PetscFunctionBegin;
ierr = VecCopy(tao->gradient,ipmP->rd);CHKERRQ(ierr);
if (ipmP->me > 0) {
/* rd = gradient + Ae'*lamdae */
ierr = MatMultTranspose(tao->jacobian_equality,ipmP->lamdae,ipmP->work);CHKERRQ(ierr);
ierr = VecAXPY(ipmP->rd, 1.0, ipmP->work);CHKERRQ(ierr);
/* rpe = ce(x) */
ierr = VecCopy(tao->constraints_equality,ipmP->rpe);CHKERRQ(ierr);
}
if (ipmP->nb > 0) {
/* rd = rd - Ai'*lamdai */
ierr = MatMultTranspose(ipmP->Ai,ipmP->lamdai,ipmP->work);CHKERRQ(ierr);
ierr = VecAXPY(ipmP->rd, -1.0, ipmP->work);CHKERRQ(ierr);
/* rpi = cin - s */
ierr = VecCopy(ipmP->ci,ipmP->rpi);CHKERRQ(ierr);
ierr = VecAXPY(ipmP->rpi, -1.0, ipmP->s);CHKERRQ(ierr);
/* com = s .* lami */
ierr = VecPointwiseMult(ipmP->complementarity, ipmP->s,ipmP->lamdai);CHKERRQ(ierr);
}
/* phi = ||rd; rpe; rpi; com|| */
ierr = VecDot(ipmP->rd,ipmP->rd,&norm);CHKERRQ(ierr);
ipmP->phi = norm;
if (ipmP->me > 0 ) {
ierr = VecDot(ipmP->rpe,ipmP->rpe,&norm);CHKERRQ(ierr);
ipmP->phi += norm;
}
if (ipmP->nb > 0) {
ierr = VecDot(ipmP->rpi,ipmP->rpi,&norm);CHKERRQ(ierr);
ipmP->phi += norm;
ierr = VecDot(ipmP->complementarity,ipmP->complementarity,&norm);CHKERRQ(ierr);
ipmP->phi += norm;
/* mu = s'*lami/nb */
ierr = VecDot(ipmP->s,ipmP->lamdai,&ipmP->mu);CHKERRQ(ierr);
ipmP->mu /= ipmP->nb;
} else {
ipmP->mu = 1.0;
}
ipmP->phi = PetscSqrtScalar(ipmP->phi);
PetscFunctionReturn(0);
}
PetscErrorCode FormFunctionGradient(Tao tao, Vec x, PetscReal *f, Vec g, void *ctx)
{
AppCtx *user = (AppCtx*)ctx;
PetscScalar xtHx;
PetscErrorCode ierr;
PetscFunctionBegin;
ierr = MatMult(user->H,x,g);CHKERRQ(ierr);
ierr = VecDot(x,g,&xtHx);CHKERRQ(ierr);
ierr = VecDot(x,user->d,f);CHKERRQ(ierr);
*f += 0.5*xtHx;
ierr = VecAXPY(g,1.0,user->d);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
PetscErrorCode SNESLineSearchApply_NCGLinear(SNESLineSearch linesearch)
{
PetscScalar alpha, ptAp;
Vec X, Y, F, W;
SNES snes;
PetscErrorCode ierr;
PetscReal *fnorm, *xnorm, *ynorm;
MatStructure flg = DIFFERENT_NONZERO_PATTERN;
PetscFunctionBegin;
ierr = SNESLineSearchGetSNES(linesearch, &snes);
CHKERRQ(ierr);
X = linesearch->vec_sol;
W = linesearch->vec_sol_new;
F = linesearch->vec_func;
Y = linesearch->vec_update;
fnorm = &linesearch->fnorm;
xnorm = &linesearch->xnorm;
ynorm = &linesearch->ynorm;
/*
The exact step size for unpreconditioned linear CG is just:
alpha = (r, r) / (p, Ap) = (f, f) / (y, Jy)
*/
ierr = SNESComputeJacobian(snes, X, &snes->jacobian, &snes->jacobian_pre, &flg);
CHKERRQ(ierr);
ierr = VecDot(F, F, &alpha);
CHKERRQ(ierr);
ierr = MatMult(snes->jacobian, Y, W);
CHKERRQ(ierr);
ierr = VecDot(Y, W, &ptAp);
CHKERRQ(ierr);
alpha = alpha / ptAp;
ierr = PetscPrintf(((PetscObject)snes)->comm, "alpha: %G\n", PetscRealPart(alpha));
CHKERRQ(ierr);
ierr = VecAXPY(X, alpha, Y);
CHKERRQ(ierr);
ierr = SNESComputeFunction(snes, X, F);
CHKERRQ(ierr);
ierr = VecNorm(F, NORM_2, fnorm);
CHKERRQ(ierr);
ierr = VecNorm(X, NORM_2, xnorm);
CHKERRQ(ierr);
ierr = VecNorm(Y, NORM_2, ynorm);
CHKERRQ(ierr);
PetscFunctionReturn(0);
}
static PetscErrorCode GPCGObjectiveAndGradient(TaoLineSearch ls, Vec X, PetscReal *f, Vec G, void*tptr)
{
Tao tao = (Tao)tptr;
TAO_GPCG *gpcg = (TAO_GPCG*)tao->data;
PetscErrorCode ierr;
PetscReal f1,f2;
PetscFunctionBegin;
ierr = MatMult(tao->hessian,X,G);CHKERRQ(ierr);
ierr = VecDot(G,X,&f1);CHKERRQ(ierr);
ierr = VecDot(gpcg->B,X,&f2);CHKERRQ(ierr);
ierr = VecAXPY(G,1.0,gpcg->B);CHKERRQ(ierr);
*f=f1/2.0 + f2 + gpcg->c;
PetscFunctionReturn(0);
}
void ConvectionDiffusionFE<TDomain>::
add_rhs_elem(LocalVector& d, GridObject* elem, const MathVector<dim> vCornerCoords[])
{
// request geometry
const TFEGeom& geo = GeomProvider<TFEGeom>::get(m_lfeID, m_quadOrder);
// skip if no source present
if(!m_imSource.data_given() && !m_imVectorSource.data_given()) return;
// loop integration points
for(size_t ip = 0; ip < geo.num_ip(); ++ip)
{
// loop test spaces
// only do this if (volume) source is given
if(m_imSource.data_given()) {
for(size_t i = 0; i < geo.num_sh(); ++i)
{
// add contribution to local defect
d(_C_, i) += m_imSource[ip] * geo.shape(ip, i) * geo.weight(ip);
}
}
// only do this if vector source is given
if(m_imVectorSource.data_given()) {
for(size_t i = 0; i < geo.num_sh(); ++i)
{
// add contribution to local defect
d(_C_, i) += geo.weight(ip) * VecDot(m_imVectorSource[ip], geo.global_grad(ip, i));
}
}
}
}
/*
Checks rhs of Lp systems is in the null space of Lp, i.e. {rhs} \centerdot {null_space} = 0
Since Lp should contain the null space {1}, we just check the \sum_i rhs_i = 0
*/
PetscErrorCode BSSCRBSSCR_Lp_monitor_check_rhs_consistency( KSP ksp, Vec rhs, PetscInt index )
{
PetscScalar dot;
#if 0
Vec one;
VecDuplicate( rhs, &one );
VecSet( one, 1.0 );
VecDot( rhs, one, &dot );
if( PetscAbsReal(dot) > 1.0e-8 ) {
PetscPrintf(ksp->comm," ($D) Lp z = r: ******* WARNING ******* RHS is not consistent. {b}.{1} = %5.5e \n", index, dot );
}
Stg_VecDestroy(&one );
PetscFunctionReturn(0);
#endif
#if 0
VecSum( rhs, &dot );
if( PetscAbsReal(dot) > 1.0e-8 ) {
PetscPrintf(((PetscObject)ksp)->comm," (%D) Lp z = r: ******* WARNING ******* RHS is not consistent. {b}.{1} = %5.5e \n",
index, dot );
BSSCR_VecRemoveConstNullspace( rhs, PETSC_NULL );
}
#endif
PetscFunctionReturn(0);
}
/*
BVOrthogonalizeMGS1 - Compute one step of Modified Gram-Schmidt
*/
static PetscErrorCode BVOrthogonalizeMGS1(BV bv,PetscInt k,Vec v,PetscBool *which,PetscScalar *H)
{
PetscErrorCode ierr;
PetscInt i;
PetscScalar dot;
Vec vi,z;
PetscFunctionBegin;
z = v;
for (i=-bv->nc;i<k;i++) {
if (which && i>=0 && !which[i]) continue;
ierr = BVGetColumn(bv,i,&vi);CHKERRQ(ierr);
/* h_i = ( v, v_i ) */
if (bv->matrix) {
ierr = BV_IPMatMult(bv,v);CHKERRQ(ierr);
z = bv->Bx;
}
ierr = VecDot(z,vi,&dot);CHKERRQ(ierr);
/* v <- v - h_i v_i */
if (bv->indef) dot /= bv->omega[bv->nc+i];
ierr = VecAXPY(v,-dot,vi);CHKERRQ(ierr);
if (bv->indef) dot *= bv->omega[bv->nc+i];
if (H) H[bv->nc+i] += dot;
ierr = BVRestoreColumn(bv,i,&vi);CHKERRQ(ierr);
}
PetscFunctionReturn(0);
}
PetscErrorCode test_vec_ops( void )
{
Vec X, a,b;
Vec c,d,e,f;
PetscScalar val;
PetscErrorCode ierr;
PetscFunctionBegin;
PetscPrintf( PETSC_COMM_WORLD, "\n\n============== %s ==============\n",PETSC_FUNCTION_NAME);
ierr = VecCreate( PETSC_COMM_WORLD, &X );CHKERRQ(ierr);
ierr = VecSetSizes( X, 2, 2 );CHKERRQ(ierr);
ierr = VecSetType( X, VECNEST );CHKERRQ(ierr);
ierr = VecCreate( PETSC_COMM_WORLD, &a );CHKERRQ(ierr);
ierr = VecSetSizes( a, 2, 2 );CHKERRQ(ierr);
ierr = VecSetType( a, VECNEST );CHKERRQ(ierr);
ierr = VecCreate( PETSC_COMM_WORLD, &b );CHKERRQ(ierr);
ierr = VecSetSizes( b, 2, 2 );CHKERRQ(ierr);
ierr = VecSetType( b, VECNEST );CHKERRQ(ierr);
/* assemble X */
ierr = VecNestSetSubVec( X, 0, a );CHKERRQ(ierr);
ierr = VecNestSetSubVec( X, 1, b );CHKERRQ(ierr);
ierr = VecAssemblyBegin(X);CHKERRQ(ierr);
ierr = VecAssemblyEnd(X);CHKERRQ(ierr);
ierr = VecCreate( PETSC_COMM_WORLD, &c );CHKERRQ(ierr);
ierr = VecSetSizes( c, 3, 3 );CHKERRQ(ierr);
ierr = VecSetType( c, VECSEQ );CHKERRQ(ierr);
ierr = VecDuplicate( c, &d );CHKERRQ(ierr);
ierr = VecDuplicate( c, &e );CHKERRQ(ierr);
ierr = VecDuplicate( c, &f );CHKERRQ(ierr);
ierr = VecSet( c, 1.0 );CHKERRQ(ierr);
ierr = VecSet( d, 2.0 );CHKERRQ(ierr);
ierr = VecSet( e, 3.0 );CHKERRQ(ierr);
ierr = VecSet( f, 4.0 );CHKERRQ(ierr);
/* assemble a */
ierr = VecNestSetSubVec( a, 0, c );CHKERRQ(ierr);
ierr = VecNestSetSubVec( a, 1, d );CHKERRQ(ierr);
ierr = VecAssemblyBegin(a);CHKERRQ(ierr);
ierr = VecAssemblyEnd(a);CHKERRQ(ierr);
/* assemble b */
ierr = VecNestSetSubVec( b, 0, e );CHKERRQ(ierr);
ierr = VecNestSetSubVec( b, 1, f );CHKERRQ(ierr);
ierr = VecAssemblyBegin(b);CHKERRQ(ierr);
ierr = VecAssemblyEnd(b);CHKERRQ(ierr);
//PetscPrintf( PETSC_COMM_WORLD, "X \n");
//VecView( X, PETSC_VIEWER_STDOUT_WORLD );
ierr = VecDot( X,X, &val );CHKERRQ(ierr);
PetscPrintf( PETSC_COMM_WORLD, "X.X = %f \n", val );
PetscFunctionReturn(0);
}
static PetscErrorCode SNESNEWTONLSCheckLocalMin_Private(SNES snes,Mat A,Vec F,PetscReal fnorm,PetscBool *ismin)
{
PetscReal a1;
PetscErrorCode ierr;
PetscBool hastranspose;
Vec W;
PetscFunctionBegin;
*ismin = PETSC_FALSE;
ierr = MatHasOperation(A,MATOP_MULT_TRANSPOSE,&hastranspose);CHKERRQ(ierr);
ierr = VecDuplicate(F,&W);CHKERRQ(ierr);
if (hastranspose) {
/* Compute || J^T F|| */
ierr = MatMultTranspose(A,F,W);CHKERRQ(ierr);
ierr = VecNorm(W,NORM_2,&a1);CHKERRQ(ierr);
ierr = PetscInfo1(snes,"|| J^T F|| %14.12e near zero implies found a local minimum\n",(double)(a1/fnorm));CHKERRQ(ierr);
if (a1/fnorm < 1.e-4) *ismin = PETSC_TRUE;
} else {
Vec work;
PetscScalar result;
PetscReal wnorm;
ierr = VecSetRandom(W,NULL);CHKERRQ(ierr);
ierr = VecNorm(W,NORM_2,&wnorm);CHKERRQ(ierr);
ierr = VecDuplicate(W,&work);CHKERRQ(ierr);
ierr = MatMult(A,W,work);CHKERRQ(ierr);
ierr = VecDot(F,work,&result);CHKERRQ(ierr);
ierr = VecDestroy(&work);CHKERRQ(ierr);
a1 = PetscAbsScalar(result)/(fnorm*wnorm);
ierr = PetscInfo1(snes,"(F^T J random)/(|| F ||*||random|| %14.12e near zero implies found a local minimum\n",(double)a1);CHKERRQ(ierr);
if (a1 < 1.e-4) *ismin = PETSC_TRUE;
}
ierr = VecDestroy(&W);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
static PetscErrorCode bfgs_apply(PC pc, Vec xin, Vec xout)
{
TaoLMVMMat *M ;
TaoVecPetsc Xin(xin);
TaoVecPetsc Xout(xout);
TaoTruth info2;
int info;
PetscFunctionBegin;
PetscTruth VerbosePrint = PETSC_FALSE;
PetscOptionsGetTruth(PETSC_NULL,"-verboseapp",&VerbosePrint,PETSC_NULL);
info = PCShellGetContext(pc,(void**)&M); CHKERRQ(info);
PetscScalar solnNorm,solnDot;
info = VecNorm(xin,NORM_2,&solnNorm); CHKERRQ(info)
info=PetscPrintf(PETSC_COMM_WORLD,"bfgs_apply: ||Xin||_2 = %22.15e\n",solnNorm);
if(VerbosePrint) VecView(xin,0);
info = M->Solve(&Xin, &Xout, &info2); CHKERRQ(info);
info = VecNorm(xout,NORM_2,&solnNorm); CHKERRQ(info)
info = VecDot(xin,xout,&solnDot); CHKERRQ(info)
info=PetscPrintf(PETSC_COMM_WORLD,"bfgs_apply: ||Xout||_2 = %22.15e, Xin^T Xout= %22.15e\n",solnNorm,solnDot);
if(VerbosePrint) VecView(xout,0);
PetscFunctionReturn(0);
}
static PetscErrorCode VecNorm_Nest(Vec xin,NormType type,PetscReal *z)
{
Vec_Nest *bx = (Vec_Nest*)xin->data;
PetscInt i,nr;
PetscReal z_i;
PetscReal _z;
PetscErrorCode ierr;
PetscFunctionBegin;
nr = bx->nb;
_z = 0.0;
if (type == NORM_2) {
PetscScalar dot;
ierr = VecDot(xin,xin,&dot);CHKERRQ(ierr);
_z = PetscAbsScalar(PetscSqrtScalar(dot));
} else if (type == NORM_1) {
for (i=0; i<nr; i++) {
ierr = VecNorm(bx->v[i],type,&z_i);CHKERRQ(ierr);
_z = _z + z_i;
}
} else if (type == NORM_INFINITY) {
for (i=0; i<nr; i++) {
ierr = VecNorm(bx->v[i],type,&z_i);CHKERRQ(ierr);
if (z_i > _z) _z = z_i;
}
}
*z = _z;
PetscFunctionReturn(0);
}
/*
Assuming F = SNESComputeFunction(X) compute Y^tJ^tF using a simple secant approximation of the jacobian.
*/
PetscErrorCode SNESNCGComputeYtJtF_Private(SNES snes, Vec X, Vec F, Vec Y, Vec W, Vec G, PetscScalar * ytJtf)
{
PetscErrorCode ierr;
PetscScalar ftf, ftg, fty, h;
PetscFunctionBegin;
ierr = VecDot(F, F, &ftf);CHKERRQ(ierr);
ierr = VecDot(F, Y, &fty);CHKERRQ(ierr);
h = 1e-5*fty / fty;
ierr = VecCopy(X, W);CHKERRQ(ierr);
ierr = VecAXPY(W, -h, Y);CHKERRQ(ierr); /* this is arbitrary */
ierr = SNESComputeFunction(snes, W, G);CHKERRQ(ierr);
ierr = VecDot(G, F, &ftg);CHKERRQ(ierr);
*ytJtf = (ftg - ftf) / h;
PetscFunctionReturn(0);
}
void ConvectionDiffusionFE<TDomain>::
add_def_A_elem(LocalVector& d, const LocalVector& u, GridObject* elem, const MathVector<dim> vCornerCoords[])
{
// request geometry
const TFEGeom& geo = GeomProvider<TFEGeom>::get(m_lfeID, m_quadOrder);
number integrand, shape_u;
MathMatrix<dim,dim> D;
MathVector<dim> v, Dgrad_u, grad_u;
// loop integration points
for(size_t ip = 0; ip < geo.num_ip(); ++ip)
{
// get current u and grad_u
VecSet(grad_u, 0.0);
shape_u = 0.0;
for(size_t j = 0; j < geo.num_sh(); ++j)
{
VecScaleAppend(grad_u, u(_C_,j), geo.global_grad(ip, j));
shape_u += u(_C_,j) * geo.shape(ip, j);
}
// Diffusion
if(m_imDiffusion.data_given())
MatVecMult(Dgrad_u, m_imDiffusion[ip], grad_u);
else
VecSet(Dgrad_u, 0.0);
// Convection
if(m_imVelocity.data_given())
VecScaleAppend(Dgrad_u, -1*shape_u, m_imVelocity[ip]);
// Convection
if(m_imFlux.data_given())
VecScaleAppend(Dgrad_u, 1.0, m_imFlux[ip]);
// loop test spaces
for(size_t i = 0; i < geo.num_sh(); ++i)
{
// compute integrand
integrand = VecDot(Dgrad_u, geo.global_grad(ip, i));
// add Reaction Rate
if(m_imReactionRate.data_given())
integrand += m_imReactionRate[ip] * shape_u * geo.shape(ip, i);
// add Reaction
if(m_imReaction.data_given())
integrand += m_imReaction[ip] * geo.shape(ip, i);
// multiply by integration weight
integrand *= geo.weight(ip);
// add to local defect
d(_C_, i) += integrand;
}
}
}
int main(int argc, char **argv)
{
PetscErrorCode ierr;
Vec *V,t;
PetscInt i,j,reps,n=15,k=6;
PetscRandom rctx;
PetscScalar *val_dot,*val_mdot,*tval_dot,*tval_mdot;
ierr = PetscInitialize(&argc,&argv,(char*)0,help);if (ierr) return ierr;
ierr = PetscOptionsGetInt(NULL,NULL,"-n",&n,NULL);CHKERRQ(ierr);
ierr = PetscOptionsGetInt(NULL,NULL,"-k",&k,NULL);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD,"Test with %D random vectors of length %D",k,n);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD,"\n",k,n);CHKERRQ(ierr);
ierr = PetscRandomCreate(PETSC_COMM_WORLD,&rctx);CHKERRQ(ierr);
ierr = PetscRandomSetFromOptions(rctx);CHKERRQ(ierr);
ierr = VecCreate(PETSC_COMM_WORLD,&t);CHKERRQ(ierr);
ierr = VecSetSizes(t,n,PETSC_DECIDE);CHKERRQ(ierr);
ierr = VecSetFromOptions(t);CHKERRQ(ierr);
ierr = VecDuplicateVecs(t,k,&V);CHKERRQ(ierr);
ierr = VecSetRandom(t,rctx);CHKERRQ(ierr);
ierr = PetscMalloc1(k,&val_dot);CHKERRQ(ierr);
ierr = PetscMalloc1(k,&val_mdot);CHKERRQ(ierr);
ierr = PetscMalloc1(k,&tval_dot);CHKERRQ(ierr);
ierr = PetscMalloc1(k,&tval_mdot);CHKERRQ(ierr);
for (i=0; i<k; i++) { ierr = VecSetRandom(V[i],rctx);CHKERRQ(ierr); }
for (reps=0; reps<20; reps++) {
for (i=1; i<k; i++) {
ierr = VecMDot(t,i,V,val_mdot);CHKERRQ(ierr);
ierr = VecMTDot(t,i,V,tval_mdot);CHKERRQ(ierr);
for (j=0;j<i;j++) {
ierr = VecDot(t,V[j],&val_dot[j]);CHKERRQ(ierr);
ierr = VecTDot(t,V[j],&tval_dot[j]);CHKERRQ(ierr);
}
/* Check result */
for (j=0;j<i;j++) {
if (PetscAbsScalar(val_mdot[j] - val_dot[j])/PetscAbsScalar(val_dot[j]) > 1e-5) {
ierr = PetscPrintf(PETSC_COMM_WORLD, "[TEST FAILED] i=%D, j=%D, val_mdot[j]=%g, val_dot[j]=%g\n",i,j,(double)PetscAbsScalar(val_mdot[j]), (double)PetscAbsScalar(val_dot[j]));CHKERRQ(ierr);
break;
}
if (PetscAbsScalar(tval_mdot[j] - tval_dot[j])/PetscAbsScalar(tval_dot[j]) > 1e-5) {
ierr = PetscPrintf(PETSC_COMM_WORLD, "[TEST FAILED] i=%D, j=%D, tval_mdot[j]=%g, tval_dot[j]=%g\n",i,j,(double)PetscAbsScalar(tval_mdot[j]), (double)PetscAbsScalar(tval_dot[j]));CHKERRQ(ierr);
break;
}
}
}
}
ierr = PetscPrintf(PETSC_COMM_WORLD,"Test completed successfully!\n",k,n);CHKERRQ(ierr);
ierr = PetscFree(val_dot);CHKERRQ(ierr);
ierr = PetscFree(val_mdot);CHKERRQ(ierr);
ierr = PetscFree(tval_dot);CHKERRQ(ierr);
ierr = PetscFree(tval_mdot);CHKERRQ(ierr);
ierr = VecDestroyVecs(k,&V);CHKERRQ(ierr);
ierr = VecDestroy(&t);CHKERRQ(ierr);
ierr = PetscRandomDestroy(&rctx);CHKERRQ(ierr);
ierr = PetscFinalize();
return ierr;
}
static PetscErrorCode GPCGGradProjections(Tao tao)
{
PetscErrorCode ierr;
TAO_GPCG *gpcg = (TAO_GPCG *)tao->data;
PetscInt i;
PetscReal actred=-1.0,actred_max=0.0, gAg,gtg=gpcg->gnorm,alpha;
PetscReal f_new,gdx,stepsize;
Vec DX=tao->stepdirection,XL=tao->XL,XU=tao->XU,Work=gpcg->Work;
Vec X=tao->solution,G=tao->gradient;
TaoLineSearchConvergedReason lsflag=TAOLINESEARCH_CONTINUE_ITERATING;
/*
The free, active, and binding variables should be already identified
*/
PetscFunctionBegin;
for (i=0;i<gpcg->maxgpits;i++){
if ( -actred <= (gpcg->pg_ftol)*actred_max) break;
ierr = VecBoundGradientProjection(G,X,XL,XU,DX);CHKERRQ(ierr);
ierr = VecScale(DX,-1.0);CHKERRQ(ierr);
ierr = VecDot(DX,G,&gdx);CHKERRQ(ierr);
ierr = MatMult(tao->hessian,DX,Work);CHKERRQ(ierr);
ierr = VecDot(DX,Work,&gAg);CHKERRQ(ierr);
gpcg->gp_iterates++;
gpcg->total_gp_its++;
gtg=-gdx;
alpha = PetscAbsReal(gtg/gAg);
ierr = TaoLineSearchSetInitialStepLength(tao->linesearch,alpha);CHKERRQ(ierr);
f_new=gpcg->f;
ierr = TaoLineSearchApply(tao->linesearch,X,&f_new,G,DX,&stepsize,&lsflag);CHKERRQ(ierr);
/* Update the iterate */
actred = f_new - gpcg->f;
actred_max = PetscMax(actred_max,-(f_new - gpcg->f));
gpcg->f = f_new;
ierr = ISDestroy(&gpcg->Free_Local);CHKERRQ(ierr);
ierr = VecWhichBetween(XL,X,XU,&gpcg->Free_Local);CHKERRQ(ierr);
}
gpcg->gnorm=gtg;
PetscFunctionReturn(0);
} /* End gradient projections */
realtype N_VDotProd_Petsc(N_Vector x, N_Vector y)
{
Vec *xv = NV_PVEC_PTC(x);
Vec *yv = NV_PVEC_PTC(y);
PetscScalar dotprod;
VecDot(*xv, *yv, &dotprod);
return dotprod;
}
int vf_sphere_inside(const view_params *vp, const vec3 center, real radius)
{
vec3 c_eye;
/* transform center to eye space */
VecSub(c_eye, center, vp->eye);
/* check if it's inside near and far z planes */
real d = VecDot(vp->gaze, c_eye);
if (d+radius < vp->znear || d-radius > vp->zfar) return 0;
/* now if it's outside with respect to any of top, bottom, left or right
* view planes, it's outside the vf, otherwise it's inside */
if (VecDot(c_eye, vp->nr) > radius) return 0;
if (VecDot(c_eye, vp->nl) > radius) return 0;
if (VecDot(c_eye, vp->nt) > radius) return 0;
if (VecDot(c_eye, vp->nb) > radius) return 0;
return 1;
}
D3DMATRIX* MatrixLookAtLH(
D3DMATRIX *pOut,
const D3DVECTOR *pEye,
const D3DVECTOR *pAt,
const D3DVECTOR *pUp
)
{
D3DVECTOR vecX, vecY, vecZ;
// Compute direction of gaze. (+Z)
VecSubtract(&vecZ, pAt, pEye);
VecNormalize(&vecZ, &vecZ);
// Compute orthogonal axes from cross product of gaze and pUp vector.
VecCross(&vecX, pUp, &vecZ);
VecNormalize(&vecX, &vecX);
VecCross(&vecY, &vecZ, &vecX);
// Set rotation and translate by pEye
pOut->_11 = vecX.x;
pOut->_21 = vecX.y;
pOut->_31 = vecX.z;
pOut->_41 = -VecDot(&vecX, pEye);
pOut->_12 = vecY.x;
pOut->_22 = vecY.y;
pOut->_32 = vecY.z;
pOut->_42 = -VecDot(&vecY, pEye);
pOut->_13 = vecZ.x;
pOut->_23 = vecZ.y;
pOut->_33 = vecZ.z;
pOut->_43 = -VecDot(&vecZ, pEye);
pOut->_14 = 0.0f;
pOut->_24 = 0.0f;
pOut->_34 = 0.0f;
pOut->_44 = 1.0f;
return pOut;
}
INT SphPeIntersect(RAY *pr, ELEMENT *pe, IRECORD *hit)
{
INT nhits; /* Number of hits. */
REAL b, disc, t1, t2, vsq; /* Formula variables. */
SPHERE *ps; /* Ptr to sphere data. */
POINT V; /* C - P */
IRECORD *sphhit;
ps = (SPHERE *)(pe->data);
sphhit = hit;
VecSub(V, ps->center, pr->P); /* Ray from origin to center.*/
vsq = VecDot(V, V); /* Length sq of V. */
b = VecDot(V, pr->D); /* Perpendicular scale of V. */
if (vsq > ps->rad2 && b < RAYEPS) /* Behind ray origin. */
return (0);
disc = b*b - vsq + ps->rad2; /* Discriminate. */
if (disc < 0.0) /* Misses ray. */
return (0);
disc = sqrt(disc); /* Find intersection param. */
t2 = b + disc;
t1 = b - disc;
if (t2 <= RAYEPS) /* Behind ray origin. */
return (0);
nhits = 0;
if (t1 > RAYEPS) /* Entering sphere. */
{
IsectAdd(sphhit, t1, pe);
sphhit++;
nhits++;
}
IsectAdd(sphhit, t2, pe); /* Exiting sphere */
nhits++;
return (nhits);
}
int vf_point_inside(const view_params *vp, const vec3 v)
{
vec3 v_eye;
/* transform vertex to eye space */
VecSub(v_eye, v, vp->eye);
/* check if it's inside near and far z planes */
real d = VecDot(vp->gaze, v_eye);
if (d < vp->znear || d > vp->zfar)
return 0;
/* now if it's outside with respect to any of top, bottom, left or right
* view planes, it's outside the vf, otherwise it's inside */
if (VecDot(v_eye, vp->nr) > 0) return 0;
if (VecDot(v_eye, vp->nl) > 0) return 0;
if (VecDot(v_eye, vp->nt) > 0) return 0;
if (VecDot(v_eye, vp->nb) > 0) return 0;
return 1;
}
static PetscErrorCode pounders_fg(Tao subtao, Vec x, PetscReal *f, Vec g, void *ctx)
{
TAO_POUNDERS *mfqP = (TAO_POUNDERS*)ctx;
PetscReal d1,d2;
PetscErrorCode ierr;
PetscFunctionBegin;
/* g = A*x (add b later)*/
ierr = MatMult(mfqP->Hs,x,g);CHKERRQ(ierr);
/* f = 1/2 * x'*(Ax) + b'*x */
ierr = VecDot(x,g,&d1);CHKERRQ(ierr);
ierr = VecDot(mfqP->b,x,&d2);CHKERRQ(ierr);
*f = 0.5 *d1 + d2;
/* now g = g + b */
ierr = VecAXPY(g, 1.0, mfqP->b);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
static PetscErrorCode VecMDot_Nest(Vec x,PetscInt nv,const Vec y[],PetscScalar *val)
{
PetscInt j;
PetscErrorCode ierr;
PetscFunctionBegin;
for (j=0; j<nv; j++) {
ierr = VecDot(x,y[j],&val[j]);CHKERRQ(ierr);
}
PetscFunctionReturn(0);
}
PetscErrorCode SolveInit(FEMInf fem, int L, PetscScalar *e0, Vec *x) {
PetscErrorCode ierr;
Mat H, S;
ierr = CalcMat(fem, L, &H, &S); CHKERRQ(ierr);
EPS eps;
ierr = PrintTimeStamp(fem->comm, "EPS", NULL); CHKERRQ(ierr);
ierr = EPSCreate(fem->comm, &eps); CHKERRQ(ierr);
ierr = EPSSetTarget(eps, -0.6); CHKERRQ(ierr);
ierr = EPSSetWhichEigenpairs(eps, EPS_TARGET_MAGNITUDE); CHKERRQ(ierr);
ierr = EPSSetOperators(eps, H, S); CHKERRQ(ierr);
if(S == NULL) {
ierr = EPSSetProblemType(eps, EPS_NHEP); CHKERRQ(ierr);
} else {
ierr = EPSSetProblemType(eps, EPS_GNHEP); CHKERRQ(ierr);
}
Vec x0[1]; MatCreateVecs(H, &x0[0], NULL);
int num; FEMInfGetSize(fem, &num);
for(int i = 0; i < num; i++) {
VecSetValue(x0[0], i, 0.5, INSERT_VALUES);
}
VecAssemblyBegin(x0[0]); VecAssemblyEnd(x0[0]);
EPSSetInitialSpace(eps, 1, x0);
ierr = EPSSetFromOptions(eps); CHKERRQ(ierr);
ierr = EPSSolve(eps); CHKERRQ(ierr);
PetscInt nconv;
EPSGetConverged(eps, &nconv);
if(nconv == 0)
SETERRQ(fem->comm, 1, "Failed to digonalize in init state\n");
Vec x_ans;
MatCreateVecs(H, &x_ans, NULL);
EPSGetEigenpair(eps, 0, e0, NULL, x_ans, NULL);
EPSDestroy(&eps);
PetscScalar v[1]; PetscInt idx[1] = {1};
VecGetValues(x_ans, 1, idx, v);
PetscScalar scale_factor = v[0] / cabs(v[0]);
VecScale( x_ans, 1.0/scale_factor);
PetscScalar norm0;
Vec Sx; MatCreateVecs(S, &Sx, NULL);
MatMult(S, x_ans, Sx); VecDot(x_ans, Sx, &norm0);
VecScale(x_ans, 1.0/sqrt(norm0));
*x = x_ans;
return 0;
}
double PetscVector::dotProductWith( OoqpVector& v )
{
int ierr;
double dot;
PetscVector & w = dynamic_cast<PetscVector &>(v);
ierr = VecDot( pv, w.pv, &dot);
assert( ierr == 0);
return dot;
}
