/*@
TSAdaptGetClip - Gets the admissible decrease/increase factor in step size
Not Collective
Input Arguments:
. adapt - adaptive controller context
Ouput Arguments:
+ low - optional, admissible decrease factor
- high - optional, admissible increase factor
Level: intermediate
.seealso: TSAdaptChoose(), TSAdaptSetClip()
@*/
PetscErrorCode TSAdaptGetClip(TSAdapt adapt,PetscReal *low,PetscReal *high)
{
PetscFunctionBegin;
PetscValidHeaderSpecific(adapt,TSADAPT_CLASSID,1);
if (low) PetscValidRealPointer(low,2);
if (high) PetscValidRealPointer(high,3);
if (low) *low = adapt->clip[0];
if (high) *high = adapt->clip[1];
PetscFunctionReturn(0);
}
/*@
TSAdaptGetSafety - Get safety factors
Not Collective
Input Arguments:
. adapt - adaptive controller context
Ouput Arguments:
. safety - safety factor relative to target error/stability goal
+ reject_safety - extra safety factor to apply if the last step was rejected
Level: intermediate
.seealso: TSAdapt, TSAdaptSetSafety(), TSAdaptChoose()
@*/
PetscErrorCode TSAdaptGetSafety(TSAdapt adapt,PetscReal *safety,PetscReal *reject_safety)
{
PetscFunctionBegin;
PetscValidHeaderSpecific(adapt,TSADAPT_CLASSID,1);
if (safety) PetscValidRealPointer(safety,2);
if (reject_safety) PetscValidRealPointer(reject_safety,3);
if (safety) *safety = adapt->safety;
if (reject_safety) *reject_safety = adapt->reject_safety;
PetscFunctionReturn(0);
}
/*@
TSAdaptGetStepLimits - Get the minimum and maximum step sizes to be considered by the controller
Not Collective
Input Arguments:
. adapt - time step adaptivity context, usually gotten with TSGetAdapt()
Output Arguments:
+ hmin - minimum time step
- hmax - maximum time step
Level: intermediate
.seealso: TSAdapt, TSAdaptSetStepLimits(), TSAdaptChoose()
@*/
PetscErrorCode TSAdaptGetStepLimits(TSAdapt adapt,PetscReal *hmin,PetscReal *hmax)
{
PetscFunctionBegin;
PetscValidHeaderSpecific(adapt,TSADAPT_CLASSID,1);
if (hmin) PetscValidRealPointer(hmin,2);
if (hmax) PetscValidRealPointer(hmax,3);
if (hmin) *hmin = adapt->dt_min;
if (hmax) *hmax = adapt->dt_max;
PetscFunctionReturn(0);
}
/*@
TSAlpha2GetParams - gets the algorithmic parameters for TSALPHA2
Not Collective
Input Parameter:
. ts - timestepping context
Output Parameters:
+ \alpha_m - algorithmic parameter
. \alpha_f - algorithmic parameter
. \gamma - algorithmic parameter
- \beta - algorithmic parameter
Note:
Use of this function is normally only required to hack TSALPHA2 to
use a modified integration scheme. Users should call
TSAlpha2SetRadius() to set the high-frequency damping (i.e. spectral
radius of the method) in order so select optimal values for these
parameters.
Level: advanced
.seealso: TSAlpha2SetRadius(), TSAlpha2SetParams()
@*/
PetscErrorCode TSAlpha2GetParams(TS ts,PetscReal *alpha_m,PetscReal *alpha_f,PetscReal *gamma,PetscReal *beta)
{
PetscErrorCode ierr;
PetscFunctionBegin;
PetscValidHeaderSpecific(ts,TS_CLASSID,1);
if (alpha_m) PetscValidRealPointer(alpha_m,2);
if (alpha_f) PetscValidRealPointer(alpha_f,3);
if (gamma) PetscValidRealPointer(gamma,4);
if (beta) PetscValidRealPointer(beta,5);
ierr = PetscUseMethod(ts,"TSAlpha2GetParams_C",(TS,PetscReal*,PetscReal*,PetscReal*,PetscReal*),(ts,alpha_m,alpha_f,gamma,beta));CHKERRQ(ierr);
PetscFunctionReturn(0);
}
/*@
PetscDrawGetViewPort - Gets the portion of the window (page) to which draw
routines will write.
Collective on PetscDraw
Input Parameter:
. draw - the drawing context
Output Parameter:
. xl,yl,xr,yr - upper right and lower left corners of subwindow
These numbers must always be between 0.0 and 1.0.
Lower left corner is (0,0).
Level: advanced
Concepts: drawing^in subset of window
Concepts: graphics^in subset of window
@*/
PetscErrorCode PetscDrawGetViewPort(PetscDraw draw,PetscReal *xl,PetscReal *yl,PetscReal *xr,PetscReal *yr)
{
PetscFunctionBegin;
PetscValidHeaderSpecific(draw,PETSC_DRAW_CLASSID,1);
PetscValidRealPointer(xl,2);
PetscValidRealPointer(yl,3);
PetscValidRealPointer(xr,4);
PetscValidRealPointer(yr,5);
*xl = draw->port_xl;
*yl = draw->port_yl;
*xr = draw->port_xr;
*yr = draw->port_yr;
PetscFunctionReturn(0);
}
/*@
PetscDTReconstructPoly - create matrix representing polynomial reconstruction using cell intervals and evaluation at target intervals
Not Collective
Input Arguments:
+ degree - degree of reconstruction polynomial
. nsource - number of source intervals
. sourcex - sorted coordinates of source cell boundaries (length nsource+1)
. ntarget - number of target intervals
- targetx - sorted coordinates of target cell boundaries (length ntarget+1)
Output Arguments:
. R - reconstruction matrix, utarget = sum_s R[t*nsource+s] * usource[s]
Level: advanced
.seealso: PetscDTLegendreEval()
@*/
PetscErrorCode PetscDTReconstructPoly(PetscInt degree,PetscInt nsource,const PetscReal *sourcex,PetscInt ntarget,const PetscReal *targetx,PetscReal *R)
{
PetscErrorCode ierr;
PetscInt i,j,k,*bdegrees,worksize;
PetscReal xmin,xmax,center,hscale,*sourcey,*targety,*Bsource,*Bsinv,*Btarget;
PetscScalar *tau,*work;
PetscFunctionBegin;
PetscValidRealPointer(sourcex,3);
PetscValidRealPointer(targetx,5);
PetscValidRealPointer(R,6);
if (degree >= nsource) SETERRQ2(PETSC_COMM_SELF,PETSC_ERR_ARG_INCOMP,"Reconstruction degree %D must be less than number of source intervals %D",degree,nsource);
#if defined(PETSC_USE_DEBUG)
for (i=0; i<nsource; i++) {
if (sourcex[i] >= sourcex[i+1]) SETERRQ3(PETSC_COMM_SELF,PETSC_ERR_ARG_CORRUPT,"Source interval %D has negative orientation (%G,%G)",i,sourcex[i],sourcex[i+1]);
}
for (i=0; i<ntarget; i++) {
if (targetx[i] >= targetx[i+1]) SETERRQ3(PETSC_COMM_SELF,PETSC_ERR_ARG_CORRUPT,"Target interval %D has negative orientation (%G,%G)",i,targetx[i],targetx[i+1]);
}
#endif
xmin = PetscMin(sourcex[0],targetx[0]);
xmax = PetscMax(sourcex[nsource],targetx[ntarget]);
center = (xmin + xmax)/2;
hscale = (xmax - xmin)/2;
worksize = nsource;
ierr = PetscMalloc4(degree+1,PetscInt,&bdegrees,nsource+1,PetscReal,&sourcey,nsource*(degree+1),PetscReal,&Bsource,worksize,PetscScalar,&work);CHKERRQ(ierr);
ierr = PetscMalloc4(nsource,PetscScalar,&tau,nsource*(degree+1),PetscReal,&Bsinv,ntarget+1,PetscReal,&targety,ntarget*(degree+1),PetscReal,&Btarget);CHKERRQ(ierr);
for (i=0; i<=nsource; i++) sourcey[i] = (sourcex[i]-center)/hscale;
for (i=0; i<=degree; i++) bdegrees[i] = i+1;
ierr = PetscDTLegendreIntegrate(nsource,sourcey,degree+1,bdegrees,PETSC_TRUE,Bsource);CHKERRQ(ierr);
ierr = PetscDTPseudoInverseQR(nsource,nsource,degree+1,Bsource,Bsinv,tau,nsource,work);CHKERRQ(ierr);
for (i=0; i<=ntarget; i++) targety[i] = (targetx[i]-center)/hscale;
ierr = PetscDTLegendreIntegrate(ntarget,targety,degree+1,bdegrees,PETSC_FALSE,Btarget);CHKERRQ(ierr);
for (i=0; i<ntarget; i++) {
PetscReal rowsum = 0;
for (j=0; j<nsource; j++) {
PetscReal sum = 0;
for (k=0; k<degree+1; k++) {
sum += Btarget[i*(degree+1)+k] * Bsinv[k*nsource+j];
}
R[i*nsource+j] = sum;
rowsum += sum;
}
for (j=0; j<nsource; j++) R[i*nsource+j] /= rowsum; /* normalize each row */
}
ierr = PetscFree4(bdegrees,sourcey,Bsource,work);CHKERRQ(ierr);
ierr = PetscFree4(tau,Bsinv,targety,Btarget);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
/*@
TSAdaptGetMaxIgnore - Get error estimation threshold. Solution components below this threshold value will not be considered when computing error norms for time step adaptivity (in absolute value).
Not Collective
Input Arguments:
. adapt - adaptive controller context
Ouput Arguments:
. max_ignore - threshold for solution components that are ignored during error estimation
Level: intermediate
.seealso: TSAdapt, TSAdaptSetMaxIgnore(), TSAdaptChoose()
@*/
PetscErrorCode TSAdaptGetMaxIgnore(TSAdapt adapt,PetscReal *max_ignore)
{
PetscFunctionBegin;
PetscValidHeaderSpecific(adapt,TSADAPT_CLASSID,1);
PetscValidRealPointer(max_ignore,2);
*max_ignore = adapt->ignore_max;
PetscFunctionReturn(0);
}
/*@
KSPGetResidualNorm - Gets the last (approximate preconditioned)
residual norm that has been computed.
Not Collective
Input Parameters:
. ksp - the iterative context
Output Parameters:
. rnorm - residual norm
Level: intermediate
.keywords: KSP, get, residual norm
.seealso: KSPBuildResidual()
@*/
PetscErrorCode KSPGetResidualNorm(KSP ksp,PetscReal *rnorm)
{
PetscFunctionBegin;
PetscValidHeaderSpecific(ksp,KSP_CLASSID,1);
PetscValidRealPointer(rnorm,2);
*rnorm = ksp->rnorm;
PetscFunctionReturn(0);
}
/*@
TSAdaptBasicGetClip - Gets the admissible decrease/increase factor in step size
Collective on TSAdapt
Input Arguments:
. adapt - adaptive controller context
Ouput Arguments:
+ low - optional, admissible decrease factor
- high - optional, admissible increase factor
Level: intermediate
.seealso: TSAdaptChoose()
@*/
PetscErrorCode TSAdaptBasicGetClip(TSAdapt adapt,PetscReal *low,PetscReal *high)
{
TSAdapt_Basic *basic = (TSAdapt_Basic*)adapt->data;
PetscBool isbasic;
PetscErrorCode ierr;
PetscFunctionBegin;
PetscValidHeaderSpecific(adapt,TSADAPT_CLASSID,1);
if (low) PetscValidRealPointer(low,2);
if (high) PetscValidRealPointer(high,3);
ierr = PetscObjectTypeCompare((PetscObject)adapt,TSADAPTBASIC,&isbasic);CHKERRQ(ierr);
if (isbasic) {
if (low) *low = basic->clip[0];
if (high) *high = basic->clip[1];
} else {
if (low) *low = 0;
if (high) *high = PETSC_MAX_REAL;
}
PetscFunctionReturn(0);
}
/*@
TSSetEventTolerances - Set tolerances for event zero crossings when using event handler
Logically Collective
Input Arguments:
+ ts - time integration context
. tol - scalar tolerance, PETSC_DECIDE to leave current value
- vtol - array of tolerances or NULL, used in preference to tol if present
Options Database Keys:
. -ts_event_tol <tol> tolerance for event zero crossing
Notes:
Must call TSSetEventHandler() before setting the tolerances.
The size of vtol is equal to the number of events.
Level: beginner
.seealso: TS, TSEvent, TSSetEventHandler()
@*/
PetscErrorCode TSSetEventTolerances(TS ts,PetscReal tol,PetscReal vtol[])
{
TSEvent event;
PetscInt i;
PetscFunctionBegin;
PetscValidHeaderSpecific(ts,TS_CLASSID,1);
if (vtol) PetscValidRealPointer(vtol,3);
if (!ts->event) SETERRQ(PetscObjectComm((PetscObject)ts),PETSC_ERR_USER,"Must set the events first by calling TSSetEventHandler()");
event = ts->event;
if (vtol) {
for (i=0; i < event->nevents; i++) event->vtol[i] = vtol[i];
} else {
if (tol != PETSC_DECIDE || tol != PETSC_DEFAULT) {
for (i=0; i < event->nevents; i++) event->vtol[i] = tol;
}
}
PetscFunctionReturn(0);
}
PetscErrorCode TaoLineSearchApply(TaoLineSearch ls, Vec x, PetscReal *f, Vec g, Vec s, PetscReal *steplength, TaoLineSearchConvergedReason *reason)
{
PetscErrorCode ierr;
PetscInt low1,low2,low3,high1,high2,high3;
PetscFunctionBegin;
*reason = TAOLINESEARCH_CONTINUE_ITERATING;
PetscValidHeaderSpecific(ls,TAOLINESEARCH_CLASSID,1);
PetscValidHeaderSpecific(x,VEC_CLASSID,2);
PetscValidRealPointer(f,3);
PetscValidHeaderSpecific(g,VEC_CLASSID,4);
PetscValidHeaderSpecific(s,VEC_CLASSID,5);
PetscValidPointer(reason,7);
PetscCheckSameComm(ls,1,x,2);
PetscCheckSameTypeAndComm(x,2,g,4);
PetscCheckSameTypeAndComm(x,2,s,5);
ierr = VecGetOwnershipRange(x, &low1, &high1);CHKERRQ(ierr);
ierr = VecGetOwnershipRange(g, &low2, &high2);CHKERRQ(ierr);
ierr = VecGetOwnershipRange(s, &low3, &high3);CHKERRQ(ierr);
if ( low1!= low2 || low1!= low3 || high1!= high2 || high1!= high3) SETERRQ(PETSC_COMM_SELF,1,"InCompatible vector local lengths");
ierr = PetscObjectReference((PetscObject)s);CHKERRQ(ierr);
ierr = VecDestroy(&ls->stepdirection);CHKERRQ(ierr);
ls->stepdirection = s;
ierr = TaoLineSearchSetUp(ls);CHKERRQ(ierr);
if (!ls->ops->apply) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_ARG_WRONGSTATE,"Line Search Object does not have 'apply' routine");
ls->nfeval=0;
ls->ngeval=0;
ls->nfgeval=0;
/* Check parameter values */
if (ls->ftol < 0.0) {
ierr = PetscInfo1(ls,"Bad Line Search Parameter: ftol (%g) < 0\n",(double)ls->ftol);CHKERRQ(ierr);
*reason=TAOLINESEARCH_FAILED_BADPARAMETER;
}
if (ls->rtol < 0.0) {
ierr = PetscInfo1(ls,"Bad Line Search Parameter: rtol (%g) < 0\n",(double)ls->rtol);CHKERRQ(ierr);
*reason=TAOLINESEARCH_FAILED_BADPARAMETER;
}
if (ls->gtol < 0.0) {
ierr = PetscInfo1(ls,"Bad Line Search Parameter: gtol (%g) < 0\n",(double)ls->gtol);CHKERRQ(ierr);
*reason=TAOLINESEARCH_FAILED_BADPARAMETER;
}
if (ls->stepmin < 0.0) {
ierr = PetscInfo1(ls,"Bad Line Search Parameter: stepmin (%g) < 0\n",(double)ls->stepmin);CHKERRQ(ierr);
*reason=TAOLINESEARCH_FAILED_BADPARAMETER;
}
if (ls->stepmax < ls->stepmin) {
ierr = PetscInfo2(ls,"Bad Line Search Parameter: stepmin (%g) > stepmax (%g)\n",(double)ls->stepmin,(double)ls->stepmax);CHKERRQ(ierr);
*reason=TAOLINESEARCH_FAILED_BADPARAMETER;
}
if (ls->max_funcs < 0) {
ierr = PetscInfo1(ls,"Bad Line Search Parameter: max_funcs (%D) < 0\n",ls->max_funcs);CHKERRQ(ierr);
*reason=TAOLINESEARCH_FAILED_BADPARAMETER;
}
if (PetscIsInfOrNanReal(*f)) {
ierr = PetscInfo1(ls,"Initial Line Search Function Value is Inf or Nan (%g)\n",(double)*f);CHKERRQ(ierr);
*reason=TAOLINESEARCH_FAILED_INFORNAN;
}
ierr = PetscObjectReference((PetscObject)x);CHKERRQ(ierr);
ierr = VecDestroy(&ls->start_x);CHKERRQ(ierr);
ls->start_x = x;
ierr = PetscLogEventBegin(TaoLineSearch_ApplyEvent,ls,0,0,0);CHKERRQ(ierr);
ierr = (*ls->ops->apply)(ls,x,f,g,s);CHKERRQ(ierr);
ierr = PetscLogEventEnd(TaoLineSearch_ApplyEvent, ls, 0,0,0);CHKERRQ(ierr);
*reason=ls->reason;
ls->new_f = *f;
if (steplength) {
*steplength=ls->step;
}
ierr = TaoLineSearchViewFromOptions(ls,NULL,"-tao_ls_view");CHKERRQ(ierr);
PetscFunctionReturn(0);
}
