Vp->reinit(*Vx);
Vv->reinit(*Vx);
*Vrbar = *Vr;
- return control().check(step, res);
+ return this->control().check(step, res);
}
else
res = r.l2_norm();
- state = control().check(step, res);
+ state = this->control().check(step, res);
print_vectors(step, *Vx, r, y);
}
while (state == SolverControl::iterate);
const PRECONDITIONER& precondition)
{
deallog.push("Bicgstab");
- Vr = memory.alloc(); Vr->reinit(x);
- Vrbar = memory.alloc(); Vrbar->reinit(x);
- Vp = memory.alloc();
- Vy = memory.alloc(); Vy->reinit(x);
- Vz = memory.alloc(); Vz->reinit(x);
- Vs = memory.alloc(); Vs->reinit(x);
- Vt = memory.alloc(); Vt->reinit(x);
- Vv = memory.alloc();
+ Vr = this->memory.alloc(); Vr->reinit(x);
+ Vrbar = this->memory.alloc(); Vrbar->reinit(x);
+ Vp = this->memory.alloc();
+ Vy = this->memory.alloc(); Vy->reinit(x);
+ Vz = this->memory.alloc(); Vz->reinit(x);
+ Vs = this->memory.alloc(); Vs->reinit(x);
+ Vt = this->memory.alloc(); Vt->reinit(x);
+ Vv = this->memory.alloc();
Vx = &x;
Vb = &b;
}
while (state);
- memory.free(Vr);
- memory.free(Vrbar);
- memory.free(Vp);
- memory.free(Vy);
- memory.free(Vz);
- memory.free(Vs);
- memory.free(Vt);
- memory.free(Vv);
+ this->memory.free(Vr);
+ this->memory.free(Vrbar);
+ this->memory.free(Vp);
+ this->memory.free(Vy);
+ this->memory.free(Vz);
+ this->memory.free(Vs);
+ this->memory.free(Vt);
+ this->memory.free(Vv);
deallog.pop();
// in case of failure: throw
// exception
if (control().last_check() != SolverControl::success)
- throw SolverControl::NoConvergence (control().last_step(),
- control().last_value());
+ throw SolverControl::NoConvergence (this->control().last_step(),
+ this->control().last_value());
// otherwise exit as normal
}
SolverControl::State conv=SolverControl::iterate;
// Memory allocation
- Vr = memory.alloc(); VECTOR& r = *Vr; r.reinit(x);
- Vd = memory.alloc(); VECTOR& d = *Vd; d.reinit(x);
+ Vr = this->memory.alloc(); VECTOR& r = *Vr; r.reinit(x);
+ Vd = this->memory.alloc(); VECTOR& d = *Vd; d.reinit(x);
deallog.push("Richardson");
if (!additional_data.use_preconditioned_residual)
{
res = r.l2_norm();
- conv = control().check (iter, criterion());
+ conv = this->control().check (iter, criterion());
if (conv != SolverControl::iterate)
break;
}
if (additional_data.use_preconditioned_residual)
{
res = d.l2_norm();
- conv = control().check (iter, criterion());
+ conv = this->control().check (iter, criterion());
if (conv != SolverControl::iterate)
break;
}
}
// Deallocate Memory
- memory.free(Vr);
- memory.free(Vd);
+ this->memory.free(Vr);
+ this->memory.free(Vd);
deallog.pop();
// in case of failure: throw
// exception
- if (control().last_check() != SolverControl::success)
- throw SolverControl::NoConvergence (control().last_step(),
- control().last_value());
+ if (this->control().last_check() != SolverControl::success)
+ throw SolverControl::NoConvergence (this->control().last_step(),
+ this->control().last_value());
// otherwise exit as normal
}
SolverControl::State conv=SolverControl::iterate;
// Memory allocation
- Vr = memory.alloc(); VECTOR& r = *Vr; r.reinit(x);
- Vd = memory.alloc(); VECTOR& d = *Vd; d.reinit(x);
+ Vr = this->memory.alloc(); VECTOR& r = *Vr; r.reinit(x);
+ Vd =this-> memory.alloc(); VECTOR& d = *Vd; d.reinit(x);
deallog.push("RichardsonT");
r.sadd(-1.,1.,b);
res=r.l2_norm();
- conv = control().check (iter, criterion());
+ conv = this->control().check (iter, criterion());
if (conv != SolverControl::iterate)
break;
deallog.pop();
// in case of failure: throw
// exception
- if (control().last_check() != SolverControl::success)
- throw SolverControl::NoConvergence (control().last_step(),
- control().last_value());
+ if (this->control().last_check() != SolverControl::success)
+ throw SolverControl::NoConvergence (this->control().last_step(),
+ this->control().last_value());
// otherwise exit as normal
}