static int IDAfnorm(IDAMem IDA_mem, realtype *fnorm)
{
int retval;
/* Get residual vector F, return if failed, and save F in savres. */
retval = res(t0, ynew, ypnew, delnew, user_data);
nre++;
if(retval < 0) return(IDA_RES_FAIL);
if(retval > 0) return(IC_FAIL_RECOV);
N_VScale(ONE, delnew, savres);
/* Call the linear solve function to get J-inverse F; return if failed. */
retval = lsolve(IDA_mem, delnew, ewt, ynew, ypnew, savres);
if(retval < 0) return(IDA_LSOLVE_FAIL);
if(retval > 0) return(IC_FAIL_RECOV);
/* Compute the WRMS-norm; rescale if index = 0. */
*fnorm = IDAWrmsNorm(IDA_mem, delnew, ewt, FALSE);
if(sysindex == 0) (*fnorm) *= tscale*SUNRabs(cj);
return(IDA_SUCCESS);
}
static int IDAfnorm(IDAMem IDA_mem, realtype *fnorm)
{
int retval, is;
/* Get residual vector F, return if failed, and save F in savres. */
retval = res(t0, ynew, ypnew, delnew, user_data);
nre++;
if(retval < 0) return(IDA_RES_FAIL);
if(retval > 0) return(IC_FAIL_RECOV);
N_VScale(ONE, delnew, savres);
/* Call the linear solve function to get J-inverse F; return if failed. */
retval = lsolve(IDA_mem, delnew, ewt, ynew, ypnew, savres);
if(retval < 0) return(IDA_LSOLVE_FAIL);
if(retval > 0) return(IC_FAIL_RECOV);
/* Compute the WRMS-norm. */
*fnorm = IDAWrmsNorm(IDA_mem, delnew, ewt, FALSE);
/* Are we computing SENSITIVITIES with the IDA_SIMULTANEOUS approach? */
if(sensi && (ism==IDA_SIMULTANEOUS)) {
/* Evaluate the residual for sensitivities. */
retval = resS(Ns, t0,
ynew, ypnew, savres,
yyS0new, ypS0new, delnewS,
user_dataS, tmpS1, tmpS2, tmpS3);
nrSe++;
if(retval < 0) return(IDA_RES_FAIL);
if(retval > 0) return(IC_FAIL_RECOV);
/* Save delnewS in savresS. */
for(is=0; is<Ns; is++)
N_VScale(ONE, delnewS[is], savresS[is]);
/* Call the linear solve function to get J-inverse deltaS. */
for(is=0; is<Ns; is++) {
retval = lsolve(IDA_mem, delnewS[is], ewtS[is], ynew, ypnew, savres);
if(retval < 0) return(IDA_LSOLVE_FAIL);
if(retval > 0) return(IC_FAIL_RECOV);
}
/* Include sensitivities in norm. */
*fnorm = IDASensWrmsNormUpdate(IDA_mem, *fnorm, delnewS, ewtS, FALSE);
}
/* Rescale norm if index = 0. */
if(sysindex == 0) (*fnorm) *= tscale*SUNRabs(cj);
return(IDA_SUCCESS);
}
static int IDANewtonIC(IDAMem IDA_mem)
{
int retval, mnewt;
realtype delnorm, fnorm, fnorm0, oldfnrm, rate;
/* Set pointer for vector delnew */
IDA_mem->ida_delnew = IDA_mem->ida_phi[2];
/* Call the linear solve function to get the Newton step, delta. */
retval = IDA_mem->ida_lsolve(IDA_mem, IDA_mem->ida_delta,
IDA_mem->ida_ewt, IDA_mem->ida_yy0,
IDA_mem->ida_yp0, IDA_mem->ida_savres);
if(retval < 0) return(IDA_LSOLVE_FAIL);
if(retval > 0) return(IC_FAIL_RECOV);
/* Compute the norm of the step; return now if this is small. */
fnorm = IDAWrmsNorm(IDA_mem, IDA_mem->ida_delta, IDA_mem->ida_ewt, SUNFALSE);
if(IDA_mem->ida_sysindex == 0)
fnorm *= IDA_mem->ida_tscale * SUNRabs(IDA_mem->ida_cj);
if(fnorm <= IDA_mem->ida_epsNewt)
return(IDA_SUCCESS);
fnorm0 = fnorm;
/* Initialize rate to avoid compiler warning message */
rate = ZERO;
/* Newton iteration loop */
for(mnewt = 0; mnewt < IDA_mem->ida_maxnit; mnewt++) {
IDA_mem->ida_nni++;
delnorm = fnorm;
oldfnrm = fnorm;
/* Call the Linesearch function and return if it failed. */
retval = IDALineSrch(IDA_mem, &delnorm, &fnorm);
if(retval != IDA_SUCCESS) return(retval);
/* Set the observed convergence rate and test for convergence. */
rate = fnorm/oldfnrm;
if(fnorm <= IDA_mem->ida_epsNewt) return(IDA_SUCCESS);
/* If not converged, copy new step vector, and loop. */
N_VScale(ONE, IDA_mem->ida_delnew, IDA_mem->ida_delta);
} /* End of Newton iteration loop */
/* Return either IC_SLOW_CONVRG or recoverable fail flag. */
if(rate <= ICRATEMAX || fnorm < PT1*fnorm0) return(IC_SLOW_CONVRG);
return(IC_CONV_FAIL);
}
int IDACalcIC(void *ida_mem, int icopt, realtype tout1)
{
int ewtsetOK;
int ier, nwt, nh, mxnh, icret, retval=0;
realtype tdist, troundoff, minid, hic, ypnorm;
IDAMem IDA_mem;
/* Check if IDA memory exists */
if(ida_mem == NULL) {
IDAProcessError(NULL, IDA_MEM_NULL, "IDA", "IDACalcIC", MSG_NO_MEM);
return(IDA_MEM_NULL);
}
IDA_mem = (IDAMem) ida_mem;
/* Check if problem was malloc'ed */
if(IDA_mem->ida_MallocDone == FALSE) {
IDAProcessError(IDA_mem, IDA_NO_MALLOC, "IDA", "IDACalcIC", MSG_NO_MALLOC);
return(IDA_NO_MALLOC);
}
/* Check inputs to IDA for correctness and consistency */
ier = IDAInitialSetup(IDA_mem);
if(ier != IDA_SUCCESS) return(IDA_ILL_INPUT);
IDA_mem->ida_SetupDone = TRUE;
/* Check legality of input arguments, and set IDA memory copies. */
if(icopt != IDA_YA_YDP_INIT && icopt != IDA_Y_INIT) {
IDAProcessError(IDA_mem, IDA_ILL_INPUT, "IDA", "IDACalcIC", MSG_IC_BAD_ICOPT);
return(IDA_ILL_INPUT);
}
IDA_mem->ida_icopt = icopt;
if(icopt == IDA_YA_YDP_INIT && (id == NULL)) {
IDAProcessError(IDA_mem, IDA_ILL_INPUT, "IDA", "IDACalcIC", MSG_IC_MISSING_ID);
return(IDA_ILL_INPUT);
}
tdist = SUNRabs(tout1 - tn);
troundoff = TWO*uround*(SUNRabs(tn) + SUNRabs(tout1));
if(tdist < troundoff) {
IDAProcessError(IDA_mem, IDA_ILL_INPUT, "IDA", "IDACalcIC", MSG_IC_TOO_CLOSE);
return(IDA_ILL_INPUT);
}
/* Allocate space and initialize temporary vectors */
yy0 = N_VClone(ee);
yp0 = N_VClone(ee);
t0 = tn;
N_VScale(ONE, phi[0], yy0);
N_VScale(ONE, phi[1], yp0);
/* For use in the IDA_YA_YP_INIT case, set sysindex and tscale. */
IDA_mem->ida_sysindex = 1;
IDA_mem->ida_tscale = tdist;
if(icopt == IDA_YA_YDP_INIT) {
minid = N_VMin(id);
if(minid < ZERO) {
IDAProcessError(IDA_mem, IDA_ILL_INPUT, "IDA", "IDACalcIC", MSG_IC_BAD_ID);
return(IDA_ILL_INPUT);
}
if(minid > HALF) IDA_mem->ida_sysindex = 0;
}
/* Set the test constant in the Newton convergence test */
IDA_mem->ida_epsNewt = epiccon;
/* Initializations:
cjratio = 1 (for use in direct linear solvers);
set nbacktr = 0; */
cjratio = ONE;
nbacktr = 0;
/* Set hic, hh, cj, and mxnh. */
hic = PT001*tdist;
ypnorm = IDAWrmsNorm(IDA_mem, yp0, ewt, suppressalg);
if(ypnorm > HALF/hic) hic = HALF/ypnorm;
if(tout1 < tn) hic = -hic;
hh = hic;
if(icopt == IDA_YA_YDP_INIT) {
cj = ONE/hic;
mxnh = maxnh;
}
else {
cj = ZERO;
mxnh = 1;
}
/* Loop over nwt = number of evaluations of ewt vector. */
for(nwt = 1; nwt <= 2; nwt++) {
/* Loop over nh = number of h values. */
for(nh = 1; nh <= mxnh; nh++) {
/* Call the IC nonlinear solver function. */
retval = IDAnlsIC(IDA_mem);
/* Cut h and loop on recoverable IDA_YA_YDP_INIT failure; else break. */
if(retval == IDA_SUCCESS) break;
ncfn++;
if(retval < 0) break;
if(nh == mxnh) break;
/* If looping to try again, reset yy0 and yp0 if not converging. */
if(retval != IC_SLOW_CONVRG) {
N_VScale(ONE, phi[0], yy0);
N_VScale(ONE, phi[1], yp0);
}
hic *= PT1;
cj = ONE/hic;
hh = hic;
} /* End of nh loop */
/* Break on failure; else reset ewt, save yy0, yp0 in phi, and loop. */
if(retval != IDA_SUCCESS) break;
ewtsetOK = efun(yy0, ewt, edata);
if(ewtsetOK != 0) {
retval = IDA_BAD_EWT;
break;
}
N_VScale(ONE, yy0, phi[0]);
N_VScale(ONE, yp0, phi[1]);
} /* End of nwt loop */
/* Free temporary space */
N_VDestroy(yy0);
N_VDestroy(yp0);
/* Load the optional outputs. */
if(icopt == IDA_YA_YDP_INIT) hused = hic;
/* On any failure, print message and return proper flag. */
if(retval != IDA_SUCCESS) {
icret = IDAICFailFlag(IDA_mem, retval);
return(icret);
}
/* Otherwise return success flag. */
return(IDA_SUCCESS);
}
static int IDANewtonIC(IDAMem IDA_mem)
{
int retval, mnewt;
realtype delnorm, fnorm, fnorm0, oldfnrm, rate;
//---OPENCOR--- BEGIN
unsigned char *uc;
//---OPENCOR--- END
/* Set pointer for vector delnew */
delnew = phi[2];
/* Call the linear solve function to get the Newton step, delta. */
retval = lsolve(IDA_mem, delta, ewt, yy0, yp0, savres);
if(retval < 0) return(IDA_LSOLVE_FAIL);
if(retval > 0) return(IC_FAIL_RECOV);
/* Compute the norm of the step; return now if this is small. */
fnorm = IDAWrmsNorm(IDA_mem, delta, ewt, FALSE);
if(sysindex == 0) fnorm *= tscale*ABS(cj);
if(fnorm <= epsNewt) return(IDA_SUCCESS);
//---OPENCOR--- BEGIN
// Note #1: when trying to retrieve consistent initial conditions, the user may
// have provided some (very) bad initial conditions, in which case
// fnorm won't have a finite value. This means that we won't be able to
// retrieve consistent initial conditions. So, IDA really ought to
// check that fnorm has a finite value and, if not, then return with
// some error code...
// Note #2: the code to test whether a value is finite comes from Qt. It's just
// that using it directly would require a C++ compiler while we would
// rather stick to a C compiler whenever possible since this will avoid
// potential warnings because of differences between C and C++...
uc = (unsigned char *) &fnorm;
#if Q_BYTE_ORDER == Q_BIG_ENDIAN
if (((uc[0] & 0x7F) == 0x7F) && ((uc[1] & 0xF0) == 0xF0))
return IC_CONV_FAIL;
#else
if (((uc[7] & 0x7F) == 0x7F) && ((uc[6] & 0xF0) == 0xF0))
return IC_CONV_FAIL;
#endif
//---OPENCOR--- END
fnorm0 = fnorm;
/* Initialize rate to avoid compiler warning message */
rate = ZERO;
/* Newton iteration loop */
for(mnewt = 0; mnewt < maxnit; mnewt++) {
nni++;
delnorm = fnorm;
oldfnrm = fnorm;
/* Call the Linesearch function and return if it failed. */
retval = IDALineSrch(IDA_mem, &delnorm, &fnorm);
if(retval != IDA_SUCCESS) return(retval);
/* Set the observed convergence rate and test for convergence. */
rate = fnorm/oldfnrm;
if(fnorm <= epsNewt) return(IDA_SUCCESS);
/* If not converged, copy new step vector, and loop. */
N_VScale(ONE, delnew, delta);
} /* End of Newton iteration loop */
/* Return either IC_SLOW_CONVRG or recoverable fail flag. */
if(rate <= ICRATEMAX || fnorm < PT1*fnorm0) return(IC_SLOW_CONVRG);
return(IC_CONV_FAIL);
}
static int IDANewtonIC(IDAMem IDA_mem)
{
int retval, mnewt, is;
realtype delnorm, fnorm, fnorm0, oldfnrm, rate;
booleantype sensi_sim;
/* Are we computing sensitivities with the IDA_SIMULTANEOUS approach? */
sensi_sim = (sensi && (ism==IDA_SIMULTANEOUS));
/* Set pointer for vector delnew */
delnew = phi[2];
/* Call the linear solve function to get the Newton step, delta. */
retval = lsolve(IDA_mem, delta, ewt, yy0, yp0, savres);
if(retval < 0) return(IDA_LSOLVE_FAIL);
if(retval > 0) return(IC_FAIL_RECOV);
/* Compute the norm of the step. */
fnorm = IDAWrmsNorm(IDA_mem, delta, ewt, FALSE);
/* Call the lsolve function to get correction vectors deltaS. */
if (sensi_sim) {
for(is=0;is<Ns;is++) {
retval = lsolve(IDA_mem, deltaS[is], ewtS[is], yy0, yp0, savres);
if(retval < 0) return(IDA_LSOLVE_FAIL);
if(retval > 0) return(IC_FAIL_RECOV);
}
/* Update the norm of delta. */
fnorm = IDASensWrmsNormUpdate(IDA_mem, fnorm, deltaS, ewtS, FALSE);
}
/* Test for convergence. Return now if the norm is small. */
if(sysindex == 0) fnorm *= tscale*SUNRabs(cj);
if(fnorm <= epsNewt) return(IDA_SUCCESS);
fnorm0 = fnorm;
/* Initialize rate to avoid compiler warning message */
rate = ZERO;
/* Newton iteration loop */
for(mnewt = 0; mnewt < maxnit; mnewt++) {
nni++;
delnorm = fnorm;
oldfnrm = fnorm;
/* Call the Linesearch function and return if it failed. */
retval = IDALineSrch(IDA_mem, &delnorm, &fnorm);
if(retval != IDA_SUCCESS) return(retval);
/* Set the observed convergence rate and test for convergence. */
rate = fnorm/oldfnrm;
if(fnorm <= epsNewt) return(IDA_SUCCESS);
/* If not converged, copy new step vector, and loop. */
N_VScale(ONE, delnew, delta);
if(sensi_sim) {
/* Update the iteration's step for sensitivities. */
for(is=0; is<Ns; is++)
N_VScale(ONE, delnewS[is], deltaS[is]);
}
} /* End of Newton iteration loop */
/* Return either IC_SLOW_CONVRG or recoverable fail flag. */
if(rate <= ICRATEMAX || fnorm < PT1*fnorm0) return(IC_SLOW_CONVRG);
return(IC_CONV_FAIL);
}
int IDACalcIC(void *ida_mem, int icopt, realtype tout1)
{
int ewtsetOK;
int ier, nwt, nh, mxnh, icret, retval=0;
int is;
realtype tdist, troundoff, minid, hic, ypnorm;
IDAMem IDA_mem;
booleantype sensi_stg, sensi_sim;
/* Check if IDA memory exists */
if(ida_mem == NULL) {
IDAProcessError(NULL, IDA_MEM_NULL, "IDAS", "IDACalcIC", MSG_NO_MEM);
return(IDA_MEM_NULL);
}
IDA_mem = (IDAMem) ida_mem;
/* Check if problem was malloc'ed */
if(IDA_mem->ida_MallocDone == FALSE) {
IDAProcessError(IDA_mem, IDA_NO_MALLOC, "IDAS", "IDACalcIC", MSG_NO_MALLOC);
return(IDA_NO_MALLOC);
}
/* Check inputs to IDA for correctness and consistency */
ier = IDAInitialSetup(IDA_mem);
if(ier != IDA_SUCCESS) return(IDA_ILL_INPUT);
IDA_mem->ida_SetupDone = TRUE;
/* Check legality of input arguments, and set IDA memory copies. */
if(icopt != IDA_YA_YDP_INIT && icopt != IDA_Y_INIT) {
IDAProcessError(IDA_mem, IDA_ILL_INPUT, "IDAS", "IDACalcIC", MSG_IC_BAD_ICOPT);
return(IDA_ILL_INPUT);
}
IDA_mem->ida_icopt = icopt;
if(icopt == IDA_YA_YDP_INIT && (id == NULL)) {
IDAProcessError(IDA_mem, IDA_ILL_INPUT, "IDAS", "IDACalcIC", MSG_IC_MISSING_ID);
return(IDA_ILL_INPUT);
}
tdist = SUNRabs(tout1 - tn);
troundoff = TWO*uround*(SUNRabs(tn) + SUNRabs(tout1));
if(tdist < troundoff) {
IDAProcessError(IDA_mem, IDA_ILL_INPUT, "IDAS", "IDACalcIC", MSG_IC_TOO_CLOSE);
return(IDA_ILL_INPUT);
}
/* Are we computing sensitivities? */
sensi_stg = (sensi && (ism==IDA_STAGGERED));
sensi_sim = (sensi && (ism==IDA_SIMULTANEOUS));
/* Allocate space and initialize temporary vectors */
yy0 = N_VClone(ee);
yp0 = N_VClone(ee);
t0 = tn;
N_VScale(ONE, phi[0], yy0);
N_VScale(ONE, phi[1], yp0);
if (sensi) {
/* Allocate temporary space required for sensitivity IC: yyS0 and ypS0. */
yyS0 = N_VCloneVectorArray(Ns, ee);
ypS0 = N_VCloneVectorArray(Ns, ee);
/* Initialize sensitivity vector. */
for (is=0; is<Ns; is++) {
N_VScale(ONE, phiS[0][is], yyS0[is]);
N_VScale(ONE, phiS[1][is], ypS0[is]);
}
/* Initialize work space vectors needed for sensitivities. */
savresS = phiS[2];
delnewS = phiS[3];
yyS0new = phiS[4];
ypS0new = eeS;
}
/* For use in the IDA_YA_YP_INIT case, set sysindex and tscale. */
IDA_mem->ida_sysindex = 1;
IDA_mem->ida_tscale = tdist;
if(icopt == IDA_YA_YDP_INIT) {
minid = N_VMin(id);
if(minid < ZERO) {
IDAProcessError(IDA_mem, IDA_ILL_INPUT, "IDAS", "IDACalcIC", MSG_IC_BAD_ID);
return(IDA_ILL_INPUT);
}
if(minid > HALF) IDA_mem->ida_sysindex = 0;
}
/* Set the test constant in the Newton convergence test */
IDA_mem->ida_epsNewt = epiccon;
/* Initializations:
cjratio = 1 (for use in direct linear solvers);
set nbacktr = 0; */
cjratio = ONE;
nbacktr = 0;
/* Set hic, hh, cj, and mxnh. */
hic = PT001*tdist;
ypnorm = IDAWrmsNorm(IDA_mem, yp0, ewt, suppressalg);
if (sensi_sim)
ypnorm = IDASensWrmsNormUpdate(IDA_mem, ypnorm, ypS0, ewtS, FALSE);
if(ypnorm > HALF/hic) hic = HALF/ypnorm;
if(tout1 < tn) hic = -hic;
hh = hic;
if(icopt == IDA_YA_YDP_INIT) {
cj = ONE/hic;
mxnh = maxnh;
}
else {
cj = ZERO;
mxnh = 1;
}
/* Loop over nwt = number of evaluations of ewt vector. */
for(nwt = 1; nwt <= 2; nwt++) {
/* Loop over nh = number of h values. */
for(nh = 1; nh <= mxnh; nh++) {
/* Call the IC nonlinear solver function. */
retval = IDANlsIC(IDA_mem);
/* Cut h and loop on recoverable IDA_YA_YDP_INIT failure; else break. */
if(retval == IDA_SUCCESS) break;
ncfn++;
if(retval < 0) break;
if(nh == mxnh) break;
/* If looping to try again, reset yy0 and yp0 if not converging. */
if(retval != IC_SLOW_CONVRG) {
N_VScale(ONE, phi[0], yy0);
N_VScale(ONE, phi[1], yp0);
if (sensi_sim) {
/* Reset yyS0 and ypS0. */
/* Copy phiS[0] and phiS[1] into yyS0 and ypS0. */
for (is=0; is<Ns; is++) {
N_VScale(ONE, phiS[0][is], yyS0[is]);
N_VScale(ONE, phiS[1][is], ypS0[is]);
}
}
}
hic *= PT1;
cj = ONE/hic;
hh = hic;
} /* End of nh loop */
/* Break on failure */
if(retval != IDA_SUCCESS) break;
/* Reset ewt, save yy0, yp0 in phi, and loop. */
ewtsetOK = efun(yy0, ewt, edata);
if(ewtsetOK != 0) {
retval = IDA_BAD_EWT;
break;
}
N_VScale(ONE, yy0, phi[0]);
N_VScale(ONE, yp0, phi[1]);
if (sensi_sim) {
/* Reevaluate ewtS. */
ewtsetOK = IDASensEwtSet(IDA_mem, yyS0, ewtS);
if(ewtsetOK != 0) {
retval = IDA_BAD_EWT;
break;
}
/* Save yyS0 and ypS0. */
for (is=0; is<Ns; is++) {
N_VScale(ONE, yyS0[is], phiS[0][is]);
N_VScale(ONE, ypS0[is], phiS[1][is]);
}
}
} /* End of nwt loop */
/* Load the optional outputs. */
if(icopt == IDA_YA_YDP_INIT) hused = hic;
/* On any failure, free memory, print error message and return */
if(retval != IDA_SUCCESS) {
N_VDestroy(yy0);
N_VDestroy(yp0);
if(sensi) {
N_VDestroyVectorArray(yyS0, Ns);
N_VDestroyVectorArray(ypS0, Ns);
}
icret = IDAICFailFlag(IDA_mem, retval);
return(icret);
}
/* Unless using the STAGGERED approach for sensitivities, return now */
if (!sensi_stg) {
N_VDestroy(yy0);
N_VDestroy(yp0);
if(sensi) {
N_VDestroyVectorArray(yyS0, Ns);
N_VDestroyVectorArray(ypS0, Ns);
}
return(IDA_SUCCESS);
}
/* Find consistent I.C. for sensitivities using a staggered approach */
/* Evaluate res at converged y, needed for future evaluations of sens. RHS
If res() fails recoverably, treat it as a convergence failure and
attempt the step again */
retval = res(t0, yy0, yp0, delta, user_data);
nre++;
if(retval < 0)
/* res function failed unrecoverably. */
return(IDA_RES_FAIL);
if(retval > 0)
/* res function failed recoverably but no recovery possible. */
return(IDA_FIRST_RES_FAIL);
/* Loop over nwt = number of evaluations of ewt vector. */
for(nwt = 1; nwt <= 2; nwt++) {
/* Loop over nh = number of h values. */
for(nh = 1; nh <= mxnh; nh++) {
retval = IDASensNlsIC(IDA_mem);
if(retval == IDA_SUCCESS) break;
/* Increment the number of the sensitivity related corrector convergence failures. */
ncfnS++;
if(retval < 0) break;
if(nh == mxnh) break;
/* If looping to try again, reset yyS0 and ypS0 if not converging. */
if(retval != IC_SLOW_CONVRG) {
for (is=0; is<Ns; is++) {
N_VScale(ONE, phiS[0][is], yyS0[is]);
N_VScale(ONE, phiS[1][is], ypS0[is]);
}
}
hic *= PT1;
cj = ONE/hic;
hh = hic;
} /* End of nh loop */
/* Break on failure */
if(retval != IDA_SUCCESS) break;
/* Since it was successful, reevaluate ewtS with the new values of yyS0, save
yyS0 and ypS0 in phiS[0] and phiS[1] and loop one more time to check and
maybe correct the new sensitivities IC with respect to the new weights. */
/* Reevaluate ewtS. */
ewtsetOK = IDASensEwtSet(IDA_mem, yyS0, ewtS);
if(ewtsetOK != 0) {
retval = IDA_BAD_EWT;
break;
}
/* Save yyS0 and ypS0. */
for (is=0; is<Ns; is++) {
N_VScale(ONE, yyS0[is], phiS[0][is]);
N_VScale(ONE, ypS0[is], phiS[1][is]);
}
} /* End of nwt loop */
/* Load the optional outputs. */
if(icopt == IDA_YA_YDP_INIT) hused = hic;
/* Free temporary space */
N_VDestroy(yy0);
N_VDestroy(yp0);
/* Here sensi is TRUE, so deallocate sensitivity temporary vectors. */
N_VDestroyVectorArray(yyS0, Ns);
N_VDestroyVectorArray(ypS0, Ns);
/* On any failure, print message and return proper flag. */
if(retval != IDA_SUCCESS) {
icret = IDAICFailFlag(IDA_mem, retval);
return(icret);
}
/* Otherwise return success flag. */
return(IDA_SUCCESS);
}
