int main(void){
//cli(); /* Ensure usb interrupts enabled by bootloader alter disconnect of usb */
wdt_enable(WDTO_1S);
SCH_Init();
ADM_Init();
UIB_Init();
UIF_Init();
LED_Init();
CRD_Init();
UCP_Init();
OSCCAL_Init();
/* USB Init */
usbInit();
usbDeviceDisconnect(); /* enforce re-enumeration, do this while interrupts are disabled! */
_delay_ms(500);
usbDeviceConnect();
sei();
/* 1 - Keyboard report id
2 - HID feature report id
reportBuffer is only used to send keyboard data so, initialize to 1
*/
reportBuffer.reportid = 1;
for(;; ) { /* main event loop */
wdt_reset();
usbPoll();
ADM_Task();
SCH_Task();
if(usbInterruptIsReady()) {
UCP_WriteTask();
LED_Task();
printUpdate();
usbSetInterrupt((void*)&reportBuffer, sizeof(reportBuffer));
}
}
}
NOX::StatusTest::StatusType NOX::Solver::LineSearchBased::step()
{
prePostOperator.runPreIterate(*this);
// On the first step, do some initializations
if (nIter == 0) {
// Compute F of initital guess
NOX::Abstract::Group::ReturnType rtype = solnPtr->computeF();
if (rtype != NOX::Abstract::Group::Ok) {
utilsPtr->out() << "NOX::Solver::LineSearchBased::init - "
<< "Unable to compute F" << std::endl;
throw "NOX Error";
}
// Test the initial guess
status = testPtr->checkStatus(*this, checkType);
if ((status == NOX::StatusTest::Converged) &&
(utilsPtr->isPrintType(NOX::Utils::Warning))) {
utilsPtr->out() << "Warning: NOX::Solver::LineSearchBased::init() - "
<< "The solution passed into the solver (either "
<< "through constructor or reset method) "
<< "is already converged! The solver wil not "
<< "attempt to solve this system since status is "
<< "flagged as converged." << std::endl;
}
printUpdate();
}
// First check status
if (status != NOX::StatusTest::Unconverged) {
prePostOperator.runPostIterate(*this);
printUpdate();
return status;
}
// Copy pointers into temporary references
NOX::Abstract::Group& soln = *solnPtr;
NOX::StatusTest::Generic& test = *testPtr;
// Compute the direction for the update vector at the current solution.
bool ok;
ok = directionPtr->compute(*dirPtr, soln, *this);
if (!ok)
{
utilsPtr->out() << "NOX::Solver::LineSearchBased::iterate - unable to calculate direction" << std::endl;
status = NOX::StatusTest::Failed;
prePostOperator.runPostIterate(*this);
printUpdate();
return status;
}
// Update iteration count.
nIter ++;
// Copy current soln to the old soln.
*oldSolnPtr = *solnPtr;
// Do line search and compute new soln.
ok = lineSearchPtr->compute(soln, stepSize, *dirPtr, *this);
if (!ok)
{
if (stepSize == 0.0)
{
utilsPtr->out() << "NOX::Solver::LineSearchBased::iterate - line search failed" << std::endl;
status = NOX::StatusTest::Failed;
prePostOperator.runPostIterate(*this);
printUpdate();
return status;
}
else if (utilsPtr->isPrintType(NOX::Utils::Warning))
utilsPtr->out() << "NOX::Solver::LineSearchBased::iterate - using recovery step for line search" << std::endl;
}
// Compute F for new current solution.
NOX::Abstract::Group::ReturnType rtype = soln.computeF();
if (rtype != NOX::Abstract::Group::Ok)
{
utilsPtr->out() << "NOX::Solver::LineSearchBased::iterate - unable to compute F" << std::endl;
status = NOX::StatusTest::Failed;
prePostOperator.runPostIterate(*this);
printUpdate();
return status;
}
// Evaluate the current status.
status = test.checkStatus(*this, checkType);
prePostOperator.runPostIterate(*this);
printUpdate();
return status;
}
NOX::StatusTest::StatusType NOX::Solver::PseudoTransient::step()
{
prePostOperator.runPreIterate(*this);
// On the first step, do some initializations
if (nIter == 0) {
// Compute F of initital guess
NOX::Abstract::Group::ReturnType rtype = solnPtr->computeF();
if (rtype != NOX::Abstract::Group::Ok) {
utilsPtr->out() << "NOX::Solver::PseudoTransient::init - "
<< "Unable to compute F" << endl;
throw "NOX Error";
}
// Test the initial guess
status = testPtr->checkStatus(*this, checkType);
if ((status == NOX::StatusTest::Converged) &&
(utilsPtr->isPrintType(NOX::Utils::Warning))) {
utilsPtr->out() << "Warning: NOX::Solver::PseudoTransient::init() - "
<< "The solution passed into the solver (either "
<< "through constructor or reset method) "
<< "is already converged! The solver wil not "
<< "attempt to solve this system since status is "
<< "flagged as converged." << endl;
}
printUpdate();
}
// First check status
if (status != NOX::StatusTest::Unconverged) {
prePostOperator.runPostIterate(*this);
printUpdate();
return status;
}
// Copy pointers into temporary references
NOX::Abstract::Group& soln = *solnPtr;
NOX::StatusTest::Generic& test = *testPtr;
// Pseudo-transient: change the Jacobian evaluation to evaluate a transient version
{
deltaOld = delta;
// Update step size
if (nIter == 0)
delta = deltaInit;
else
delta = deltaOld * oldSolnPtr->getNormF() / solnPtr->getNormF();
inv_delta = 1.0 / delta;
if (delta > deltaMax)
inv_delta = 0.0;
if (delta < deltaMin) {
delta = deltaMin;
inv_delta = 1.0 / delta;
}
time += delta;
Teuchos::RCP<const ::Thyra::VectorBase<double> > x =
thyraSolnGroup->get_current_x();
Teuchos::RCP<const ::Thyra::VectorBase<double> > x_old =
thyraOldSolnGroup->get_current_x();
// Compute x_dot using backward Euler
if (is_null(x_dot))
x_dot = ::Thyra::createMember(x->space());
if (nIter == 0)
::Thyra::put_scalar(0.0,x_dot.ptr());
else {
::Thyra::V_StVpStV(x_dot.ptr(),inv_delta,*x,-inv_delta,*x_old);
}
::Thyra::ModelEvaluatorBase::InArgs<double>& inArgs = thyraSolnGroup->getNonconstInArgs();
inArgs.set_x_dot(x_dot);
inArgs.set_alpha(inv_delta);
inArgs.set_beta(1.0);
inArgs.set_t(time);
}
// Compute the direction for the update vector at the current solution.
// F is already computed so the only thing to compute is J using our augmented inargs
bool ok = true;
ok = directionPtr->compute(*dirPtr, soln, *this);
if (!ok)
{
utilsPtr->out() << "NOX::Solver::PseudoTransient::iterate - unable to calculate direction" << endl;
status = NOX::StatusTest::Failed;
prePostOperator.runPostIterate(*this);
printUpdate();
return status;
}
// reset the inargs to the correct value for steady state residual evaluations
{
::Thyra::ModelEvaluatorBase::InArgs<double>& inArgs = thyraSolnGroup->getNonconstInArgs();
inArgs.set_x_dot(Teuchos::null);
inArgs.set_alpha(0.0);
inArgs.set_beta(1.0);
inArgs.set_t(0.0);
}
// Update iteration count.
nIter ++;
// Copy current soln to the old soln.
*oldSolnPtr = *solnPtr;
// Do line search and compute new soln.
ok = lineSearchPtr->compute(soln, stepSize, *dirPtr, *this);
if (!ok)
{
if (stepSize == 0.0)
{
utilsPtr->out() << "NOX::Solver::PseudoTransient::iterate - line search failed" << endl;
status = NOX::StatusTest::Failed;
prePostOperator.runPostIterate(*this);
printUpdate();
return status;
}
else if (utilsPtr->isPrintType(NOX::Utils::Warning))
utilsPtr->out() << "NOX::Solver::PseudoTransient::iterate - using recovery step for line search" << endl;
}
// Compute F for new current solution.
NOX::Abstract::Group::ReturnType rtype = soln.computeF();
if (rtype != NOX::Abstract::Group::Ok)
{
utilsPtr->out() << "NOX::Solver::PseudoTransient::iterate - unable to compute F" << endl;
status = NOX::StatusTest::Failed;
prePostOperator.runPostIterate(*this);
printUpdate();
return status;
}
// Evaluate the current status.
status = test.checkStatus(*this, checkType);
prePostOperator.runPostIterate(*this);
printUpdate();
return status;
}
NOX::StatusTest::StatusType NOX::Solver::AndersonAcceleration::step()
{
prePostOperator.runPreIterate(*this);
Teuchos::ParameterList lsParams = paramsPtr->sublist("Direction").sublist("Newton").sublist("Linear Solver");
// On the first step, do some initializations
if (nIter == 0) {
// Compute F of initital guess
NOX::Abstract::Group::ReturnType rtype = solnPtr->computeF();
if (rtype != NOX::Abstract::Group::Ok) {
utilsPtr->out() << "NOX::Solver::AndersonAcceleration::init - "
<< "Unable to compute F" << std::endl;
throw "NOX Error";
}
// Test the initial guess
status = testPtr->checkStatus(*this, checkType);
if ((status == NOX::StatusTest::Converged) &&
(utilsPtr->isPrintType(NOX::Utils::Warning))) {
utilsPtr->out() << "Warning: NOX::Solver::AndersonAcceleration::init() - "
<< "The solution passed into the solver (either "
<< "through constructor or reset method) "
<< "is already converged! The solver wil not "
<< "attempt to solve this system since status is "
<< "flagged as converged." << std::endl;
}
printUpdate();
// First check status
if (status != NOX::StatusTest::Unconverged) {
prePostOperator.runPostIterate(*this);
printUpdate();
return status;
}
// Apply preconditioner if enabled
if (precond) {
if (recomputeJacobian)
solnPtr->computeJacobian();
solnPtr->applyRightPreconditioning(false, lsParams, solnPtr->getF(), *oldPrecF);
}
else
*oldPrecF = solnPtr->getF();
// Copy initial guess to old soln
*oldSolnPtr = *solnPtr;
// Compute step then first iterate with a line search.
workVec->update(mixParam,*oldPrecF);
bool ok = lineSearchPtr->compute(*solnPtr, stepSize, *workVec, *this);
if (!ok)
{
if (stepSize == 0.0)
{
utilsPtr->out() << "NOX::Solver::AndersonAcceleratino::iterate - line search failed" << std::endl;
status = NOX::StatusTest::Failed;
prePostOperator.runPostIterate(*this);
printUpdate();
return status;
}
else if (utilsPtr->isPrintType(NOX::Utils::Warning))
utilsPtr->out() << "NOX::Solver::AndersonAcceleration::iterate - using recovery step for line search" << std::endl;
}
// Compute F for the first iterate in case it isn't in the line search
rtype = solnPtr->computeF();
if (rtype != NOX::Abstract::Group::Ok)
{
utilsPtr->out() << "NOX::Solver::AndersonAcceleration::iterate - unable to compute F" << std::endl;
status = NOX::StatusTest::Failed;
prePostOperator.runPostIterate(*this);
printUpdate();
return status;
}
// Evaluate the current status.
status = testPtr->checkStatus(*this, checkType);
//Update iteration count
nIter++;
prePostOperator.runPostIterate(*this);
printUpdate();
return status;
}
// First check status
if (status != NOX::StatusTest::Unconverged) {
prePostOperator.runPostIterate(*this);
printUpdate();
return status;
}
// Apply preconditioner if enabled
if (precond) {
if (recomputeJacobian)
solnPtr->computeJacobian();
solnPtr->applyRightPreconditioning(false, lsParams, solnPtr->getF(), *precF);
}
else
*precF = solnPtr->getF();
// Manage the matrices of past iterates and QR factors
if (storeParam > 0) {
if (nIter == accelerationStartIteration) {
// Initialize
nStore = 0;
rMat.shape(0,0);
oldPrecF->update(1.0, *precF, -1.0);
qrAdd(*oldPrecF);
xMat[0]->update(1.0, solnPtr->getX(), -1.0, oldSolnPtr->getX(), 0.0);
}
else if (nIter > accelerationStartIteration) {
if (nStore == storeParam) {
Teuchos::RCP<NOX::Abstract::Vector> tempPtr = xMat[0];
for (int ii = 0; ii<nStore-1; ii++)
xMat[ii] = xMat[ii+1];
xMat[nStore-1] = tempPtr;
qrDelete();
}
oldPrecF->update(1.0, *precF, -1.0);
qrAdd(*oldPrecF);
xMat[nStore-1]->update(1.0, solnPtr->getX(), -1.0, oldSolnPtr->getX(), 0.0);
}
}
// Reorthogonalize
if ( (nStore > 1) && (orthoFrequency > 0) )
if (nIter % orthoFrequency == 0)
reorthogonalize();
// Copy current soln to the old soln.
*oldSolnPtr = *solnPtr;
*oldPrecF = *precF;
// Adjust for condition number
if (nStore > 0) {
Teuchos::LAPACK<int,double> lapack;
char normType = '1';
double invCondNum = 0.0;
int info = 0;
if ( WORK.size() < static_cast<std::size_t>(4*nStore) )
WORK.resize(4*nStore);
if (IWORK.size() < static_cast<std::size_t>(nStore))
IWORK.resize(nStore);
lapack.GECON(normType,nStore,rMat.values(),nStore,rMat.normOne(),&invCondNum,&WORK[0],&IWORK[0],&info);
if (utilsPtr->isPrintType(Utils::Details))
utilsPtr->out() << " R condition number estimate ("<< nStore << ") = " << 1.0/invCondNum << std::endl;
if (adjustForConditionNumber) {
while ( (1.0/invCondNum > dropTolerance) && (nStore > 1) ) {
Teuchos::RCP<NOX::Abstract::Vector> tempPtr = xMat[0];
for (int ii = 0; ii<nStore-1; ii++)
xMat[ii] = xMat[ii+1];
xMat[nStore-1] = tempPtr;
qrDelete();
lapack.GECON(normType,nStore,rMat.values(),nStore,rMat.normOne(),&invCondNum,&WORK[0],&IWORK[0],&info);
if (utilsPtr->isPrintType(Utils::Details))
utilsPtr->out() << " Adjusted R condition number estimate ("<< nStore << ") = " << 1.0/invCondNum << std::endl;
}
}
}
// Solve the least-squares problem.
Teuchos::SerialDenseMatrix<int,double> gamma(nStore,1), RHS(nStore,1), Rgamma(nStore,1);
for (int ii = 0; ii<nStore; ii++)
RHS(ii,0) = precF->innerProduct( *(qMat[ii]) );
//Back-solve for gamma
for (int ii = nStore-1; ii>=0; ii--) {
gamma(ii,0) = RHS(ii,0);
for (int jj = ii+1; jj<nStore; jj++) {
gamma(ii,0) -= rMat(ii,jj)*gamma(jj,0);
}
gamma(ii,0) /= rMat(ii,ii);
}
if (nStore > 0)
Rgamma.multiply(Teuchos::NO_TRANS,Teuchos::NO_TRANS,mixParam,rMat,gamma,0.0);
// Compute the step and new solution using the line search.
workVec->update(mixParam,*precF);
for (int ii=0; ii<nStore; ii++)
workVec->update(-gamma(ii,0), *(xMat[ii]), -Rgamma(ii,0),*(qMat[ii]),1.0);
bool ok = lineSearchPtr->compute(*solnPtr, stepSize, *workVec, *this);
if (!ok)
{
if (stepSize == 0.0)
{
utilsPtr->out() << "NOX::Solver::AndersonAcceleratino::iterate - line search failed" << std::endl;
status = NOX::StatusTest::Failed;
prePostOperator.runPostIterate(*this);
printUpdate();
return status;
}
else if (utilsPtr->isPrintType(NOX::Utils::Warning))
utilsPtr->out() << "NOX::Solver::AndersonAcceleration::iterate - using recovery step for line search" << std::endl;
}
// Compute F for new current solution in case the line search didn't .
NOX::Abstract::Group::ReturnType rtype = solnPtr->computeF();
if (rtype != NOX::Abstract::Group::Ok)
{
utilsPtr->out() << "NOX::Solver::AndersonAcceleration::iterate - unable to compute F" << std::endl;
status = NOX::StatusTest::Failed;
prePostOperator.runPostIterate(*this);
printUpdate();
return status;
}
// Update iteration count
nIter++;
// Evaluate the current status.
status = testPtr->checkStatus(*this, checkType);
prePostOperator.runPostIterate(*this);
printUpdate();
return status;
}
