void drawCRSpline(IplImage* img,CvPoint* p,int num,int thickness=1)
{
for (float t=0;t<1;t=t+.001)
{
double x=0;
double y=0;
for (int i=0;i<num;i++)
{
x+=Lagrangian(num,i,t)*p[i].x;
y+=Lagrangian(num,i,t)*p[i].y;
}
cvCircle(img, cvPoint(x,y), thickness, cvScalar(0,0,0), 1);
}
}
void NonlinearPDEConstrainedObj::initEquations(
const Array<Expr>& stateVars,
const Array<Expr>& adjointVars,
const Array<Array<Expr> >& fixedVarsInStateEqns,
const Array<Array<Expr> >& fixedVarsInStateEqnsVals,
const Array<Array<Expr> >& fixedVarsInAdjointEqns,
const Array<Array<Expr> >& fixedVarsInAdjointEqnsVals
)
{
Tabs tab(0);
PLAYA_MSG2(verb(), tab << "setting up nonlinear equations");
for (int i=0; i<stateVars.size(); i++)
{
Tabs tab1;
PLAYA_MSG3(verb(), tab1 << "setting up state equation #" << i);
Expr fixedVars = new ListExpr(fixedVarsInStateEqns[i]);
Expr fixedVarVals = new ListExpr(fixedVarsInStateEqnsVals[i]);
PLAYA_MSG3(verb(), tab1 << "Fixed vars are: " << fixedVars);
NonlinearProblem stateProb
= Lagrangian().nonlinearVariationalProb(adjointVars[i],
adjointVarVals(i),
stateVars[i], stateVarVals(i),
fixedVars, fixedVarVals);
stateProbs_.append(stateProb);
}
for (int i=0; i<adjointVars.size(); i++)
{
Tabs tab1;
PLAYA_MSG3(verb(), tab1 << "setting up adjoint equation #" << i);
Expr fixedVars = new ListExpr(fixedVarsInAdjointEqns[i]);
Expr fixedVarVals = new ListExpr(fixedVarsInAdjointEqnsVals[i]);
PLAYA_MSG3(verb(), tab1 << "Fixed vars are: " << fixedVars);
LinearProblem adjointProb
= Lagrangian().linearVariationalProb(stateVars[i], stateVarVals(i),
adjointVars[i],
fixedVars, fixedVarVals);
adjointProbs_.append(adjointProb);
}
PLAYA_MSG2(verb(), tab << "done setting up nonlinear equations");
}
int main(int argc, char** argv)
{
try
{
Sundance::init(&argc, &argv);
int np = MPIComm::world().getNProc();
int nx = 48;
int ny = 48;
int npx = -1;
int npy = -1;
PartitionedRectangleMesher::balanceXY(np, &npx, &npy);
TEUCHOS_TEST_FOR_EXCEPT(npx < 1);
TEUCHOS_TEST_FOR_EXCEPT(npy < 1);
TEUCHOS_TEST_FOR_EXCEPT(npx * npy != np);
MeshType meshType = new BasicSimplicialMeshType();
MeshSource mesher = new PartitionedRectangleMesher(0.0, 1.0, nx, npx,
0.0, 1.0, ny, npy, meshType);
Mesh mesh = mesher.getMesh();
CellFilter interior = new MaximalCellFilter();
CellFilter bdry = new BoundaryCellFilter();
/* Create a vector space factory, used to
* specify the low-level linear algebra representation */
VectorType<double> vecType = new EpetraVectorType();
/* create a discrete space on the mesh */
DiscreteSpace discreteSpace(mesh, new Lagrange(1), vecType);
/* initialize the design, state, and multiplier vectors */
Expr alpha0 = new DiscreteFunction(discreteSpace, 1.0, "alpha0");
Expr u0 = new DiscreteFunction(discreteSpace, 1.0, "u0");
Expr lambda0 = new DiscreteFunction(discreteSpace, 1.0, "lambda0");
/* create symbolic objects for test and unknown functions */
Expr u = new UnknownFunction(new Lagrange(1), "u");
Expr lambda = new UnknownFunction(new Lagrange(1), "lambda");
Expr alpha = new UnknownFunction(new Lagrange(1), "alpha");
/* create symbolic differential operators */
Expr dx = new Derivative(0);
Expr dy = new Derivative(1);
Expr grad = List(dx, dy);
/* create symbolic coordinate functions */
Expr x = new CoordExpr(0);
Expr y = new CoordExpr(1);
/* create target function */
const double pi = 4.0*atan(1.0);
Expr uStar = sin(pi*x)*sin(pi*y);
/* create quadrature rules of different orders */
QuadratureFamily q1 = new GaussianQuadrature(1);
QuadratureFamily q2 = new GaussianQuadrature(2);
QuadratureFamily q4 = new GaussianQuadrature(4);
/* Regularization weight */
double R = 0.001;
double U0 = 1.0/(1.0 + 4.0*pow(pi,4.0)*R);
double A0 = -2.0*pi*pi*U0;
/* Form objective function */
Expr reg = Integral(interior, 0.5 * R * alpha*alpha, q2);
Expr fit = Integral(interior, 0.5 * pow(u-uStar, 2.0), q4);
Expr constraintEqn = Integral(interior,
(grad*lambda)*(grad*u) + lambda*alpha, q2);
Expr L = reg + fit + constraintEqn;
Expr constraintBC = EssentialBC(bdry, lambda*u, q2);
Functional Lagrangian(mesh, L, constraintBC, vecType);
LinearSolver<double> solver
= LinearSolverBuilder::createSolver("amesos.xml");
RCP<ObjectiveBase> obj = rcp(new LinearPDEConstrainedObj(
Lagrangian, u, u0, lambda, lambda0, alpha, alpha0,
solver));
Vector<double> xInit = obj->getInit();
bool doFDCheck = false;
if (doFDCheck)
{
Out::root() << "Doing FD check of gradient..." << endl;
bool fdOK = obj->fdCheck(xInit, 1.0e-6, 2);
if (fdOK)
{
Out::root() << "FD check OK" << endl;
}
else
{
Out::root() << "FD check FAILED" << endl;
}
}
RCP<UnconstrainedOptimizerBase> opt
= OptBuilder::createOptimizer("basicLMBFGS.xml");
opt->setVerb(2);
OptState state = opt->run(obj, xInit);
bool ok = true;
if (state.status() != Opt_Converged)
{
Out::root()<< "optimization failed: " << state.status() << endl;
TEUCHOS_TEST_FOR_EXCEPT(state.status() != Opt_Converged);
}
Out::root() << "opt converged: " << state.iter() << " iterations"
<< endl;
Out::root() << "exact solution: U0=" << U0 << " A0=" << A0 << endl;
FieldWriter w = new VTKWriter("PoissonSourceInversion");
w.addMesh(mesh);
w.addField("u", new ExprFieldWrapper(u0));
w.addField("alpha", new ExprFieldWrapper(alpha0));
w.addField("lambda", new ExprFieldWrapper(lambda0));
w.write();
double uErr = L2Norm(mesh, interior, u0-U0*uStar, q4);
double aErr = L2Norm(mesh, interior, alpha0-A0*uStar, q4);
Out::root() << "error in u = " << uErr << endl;
Out::root() << "error in alpha = " << aErr << endl;
double tol = 0.01;
Sundance::passFailTest(uErr + aErr, tol);
}
catch(std::exception& e)
{
cerr << "main() caught exception: " << e.what() << endl;
}
Sundance::finalize();
return Sundance::testStatus();
}
int main(int argc, char** argv)
{
try
{
Sundance::init(&argc, &argv);
int np = MPIComm::world().getNProc();
int nx = 64;
const double pi = 4.0*atan(1.0);
MeshType meshType = new BasicSimplicialMeshType();
MeshSource mesher = new PartitionedLineMesher(0.0, pi, nx, meshType);
Mesh mesh = mesher.getMesh();
CellFilter interior = new MaximalCellFilter();
CellFilter bdry = new BoundaryCellFilter();
/* Create a vector space factory, used to
* specify the low-level linear algebra representation */
VectorType<double> vecType = new EpetraVectorType();
/* create symbolic coordinate functions */
Expr x = new CoordExpr(0);
/* create target function */
double R = 0.01;
Expr sx = sin(x);
Expr cx = cos(x);
Expr ssx = sin(sx);
Expr sx2 = sx*sx;
Expr cx2 = cx*cx;
Expr f = sx2 - sx - ssx;
Expr uStar = 2.0*R*(sx2-cx2) + R*sx2*ssx + sx;
/* Form exact solution */
Expr uEx = sx;
Expr lambdaEx = R*sx2;
Expr alphaEx = -lambdaEx/R;
/* create a discrete space on the mesh */
BasisFamily bas = new Lagrange(1);
DiscreteSpace discreteSpace(mesh, bas, vecType);
/* initialize the design, state, and multiplier vectors to constants */
Expr alpha0 = new DiscreteFunction(discreteSpace, 0.25, "alpha0");
Expr u0 = new DiscreteFunction(discreteSpace, 0.5, "u0");
Expr lambda0 = new DiscreteFunction(discreteSpace, 0.25, "lambda0");
/* create symbolic objects for test and unknown functions */
Expr u = new UnknownFunction(bas, "u");
Expr lambda = new UnknownFunction(bas, "lambda");
Expr alpha = new UnknownFunction(bas, "alpha");
/* create symbolic differential operators */
Expr dx = new Derivative(0);
Expr grad = dx;
/* create quadrature rules of different orders */
QuadratureFamily q1 = new GaussianQuadrature(1);
QuadratureFamily q2 = new GaussianQuadrature(2);
QuadratureFamily q4 = new GaussianQuadrature(4);
/* Form objective function */
Expr reg = Integral(interior, 0.5 * R * alpha*alpha, q2);
Expr fit = Integral(interior, 0.5 * pow(u-uStar, 2.0), q4);
Expr constraintEqn = Integral(interior,
(grad*lambda)*(grad*u) + lambda*(alpha + sin(u) + f), q4);
Expr L = reg + fit + constraintEqn;
Expr constraintBC = EssentialBC(bdry, lambda*u, q2);
Functional Lagrangian(mesh, L, constraintBC, vecType);
LinearSolver<double> adjSolver
= LinearSolverBuilder::createSolver("amesos.xml");
ParameterXMLFileReader reader("nox-amesos.xml");
ParameterList noxParams = reader.getParameters();
NOXSolver nonlinSolver(noxParams);
RCP<PDEConstrainedObjBase> obj = rcp(new NonlinearPDEConstrainedObj(
Lagrangian, u, u0, lambda, lambda0, alpha, alpha0,
nonlinSolver, adjSolver));
Vector<double> xInit = obj->getInit();
bool doFDCheck = true;
if (doFDCheck)
{
Out::root() << "Doing FD check of gradient..." << endl;
bool fdOK = obj->fdCheck(xInit, 1.0e-6, 0);
if (fdOK)
{
Out::root() << "FD check OK" << endl;
}
else
{
Out::root() << "FD check FAILED" << endl;
TEUCHOS_TEST_FOR_EXCEPT(!fdOK);
}
}
RCP<UnconstrainedOptimizerBase> opt
= OptBuilder::createOptimizer("basicLMBFGS.xml");
opt->setVerb(3);
OptState state = opt->run(obj, xInit);
if (state.status() != Opt_Converged)
{
Out::root()<< "optimization failed: " << state.status() << endl;
TEUCHOS_TEST_FOR_EXCEPT(state.status() != Opt_Converged);
}
else
{
Out::root() << "opt converged: " << state.iter() << " iterations"
<< endl;
}
FieldWriter w = new MatlabWriter("NonlinControl1D");
w.addMesh(mesh);
w.addField("u", new ExprFieldWrapper(u0));
w.addField("alpha", new ExprFieldWrapper(alpha0));
w.addField("lambda", new ExprFieldWrapper(lambda0));
w.write();
double uErr = L2Norm(mesh, interior, u0-uEx, q4);
double lamErr = L2Norm(mesh, interior, lambda0-lambdaEx, q4);
double aErr = L2Norm(mesh, interior, alpha0-alphaEx, q4);
Out::root() << "error in u = " << uErr << endl;
Out::root() << "error in lambda = " << lamErr << endl;
Out::root() << "error in alpha = " << aErr << endl;
double tol = 0.05;
Sundance::passFailTest(uErr + lamErr + aErr, tol);
}
catch(exception& e)
{
cerr << "main() caught exception: " << e.what() << endl;
}
Sundance::finalize();
return Sundance::testStatus();
}
void LinearPDEConstrainedObj
::solveStateAndAdjoint(const Vector<double>& x) const
{
Tabs tab(0);
PLAYA_MSG2(verb(), tab << "solving state and adjoint");
PLAYA_MSG3(verb(), tab << "|x|=" << x.norm2());
PLAYA_MSG5(verb(), tab << "x=" << endl << tab << x.norm2());
Tabs tab1;
setDiscreteFunctionVector(designVarVal(), x);
PLAYA_MSG3(verb(), tab1 << "solving state eqns");
/* solve the state equations in order */
for (int i=0; i<stateProbs_.size(); i++)
{
SolverState<double> status
= stateProbs_[i].solve(solvers_[i], stateVarVals(i));
/* if the solve failed, write out the design var and known state
* variables */
if (status.finalState() != SolveConverged)
{
FieldWriter w = new VTKWriter("badSolve");
w.addMesh(Lagrangian().mesh());
w.addField("designVar", new ExprFieldWrapper(designVarVal()));
for (int j=0; j<i; j++)
{
Expr tmp = stateVarVals(j).flatten();
for (int k=0; k<tmp.size(); k++)
{
w.addField("stateVar-"+Teuchos::toString(j)+"-"+Teuchos::toString(k),
new ExprFieldWrapper(tmp[k]));
}
}
w.write();
}
TEUCHOS_TEST_FOR_EXCEPTION(status.finalState() != SolveConverged,
std::runtime_error,
"state equation " << i
<< " could not be solved: status="
<< status.stateDescription());
}
PLAYA_MSG3(verb(), tab1 << "done solving state eqns");
/* do postprocessing */
statePostprocCallback();
PLAYA_MSG3(verb(), tab1 << "solving adjoint eqns");
/* solve the adjoint equations in reverse order */
for (int i=adjointProbs_.size()-1; i>=0; i--)
{
SolverState<double> status
= adjointProbs_[i].solve(solvers_[i], adjointVarVals(i));
/* if the solve failed, write out the design var and known state
* and adjoint variables */
if (status.finalState() != SolveConverged)
{
FieldWriter w = new VTKWriter("badSolve");
w.addMesh(Lagrangian().mesh());
w.addField("designVar", new ExprFieldWrapper(designVarVal()));
for (int j=0; j<stateProbs_.size(); j++)
{
Expr tmp = stateVarVals(j).flatten();
for (int k=0; k<tmp.size(); k++)
{
w.addField("stateVar-"+Teuchos::toString(j)+"-"+Teuchos::toString(k),
new ExprFieldWrapper(tmp[k]));
}
}
for (int j=adjointProbs_.size()-1; j>i; j--)
{
Expr tmp = adjointVarVals(j).flatten();
for (int k=0; k<tmp.size(); k++)
{
w.addField("adjointVar-"+Teuchos::toString(j)+"-"+Teuchos::toString(k),
new ExprFieldWrapper(tmp[k]));
}
}
w.write();
}
TEUCHOS_TEST_FOR_EXCEPTION(status.finalState() != SolveConverged,
std::runtime_error,
"adjoint equation " << i
<< " could not be solved: status="
<< status.stateDescription());
}
PLAYA_MSG3(verb(), tab1 << "done solving adjoint eqns");
PLAYA_MSG2(verb(), tab1 << "done solving state and adjoint eqns");
}