\section{/home/peifer/diffit/modules/call\_\-odessa.cc File Reference}
\label{call__odessa_8cc}\index{/home/peifer/diffit/modules/call_odessa.cc@{/home/peifer/diffit/modules/call\_\-odessa.cc}}
{\tt \#include $<$math.h$>$}\par
{\tt \#include $<$fstream$>$}\par
{\tt \#include $<$iomanip$>$}\par
{\tt \#include $<$iostream$>$}\par
{\tt \#include $<$stdio.h$>$}\par
{\tt \#include $<$stdlib.h$>$}\par
{\tt \#include $<$string.h$>$}\par
{\tt \#include \char`\"{}../def.h\char`\"{}}\par
{\tt \#include \char`\"{}../model.h\char`\"{}}\par
{\tt \#include \char`\"{}../nr.h\char`\"{}}\par
\subsection*{Functions}
\begin{CompactItemize}
\item 
void {\bf \_\-dcopy} (double $\ast$dest, double $\ast$src, long n)
\item 
void {\bf \_\-dfill0} (double $\ast$x, long n)
\item 
void {\bf \_\-init\-Yt} (double $\ast$Yt, double $\ast$state)
\item 
int {\bf odessa\_\-} (int NEQ[$\,$], double Y[$\,$], double PAR[$\,$], double $\ast$T, double $\ast$TOUT, int $\ast$ITOL, double $\ast$RTOL, double $\ast$ATOL, int $\ast$ITASK, int $\ast$ISTATE, int IOPT[$\,$], double RWORK[$\,$], int $\ast$LRW, int IWORK[$\,$], int $\ast$LIW, int $\ast$MF)
\item 
void {\bf dop\_\-komponente\_\-} (int NEQ[$\,$], int \&J\_\-OPT, int \&J\_\-GES)
\item 
void {\bf call\_\-odessa} ({\bf Glob} $\ast$globs, {\bf Glob\-Exp} $\ast$ex, int N, int M\_\-PAR\_\-GES, char $\ast$do\-P, int D\_\-FLAG, int MAX\_\-NR\_\-STEP, int STIFF, int inhomogen, int nmesh, double $\ast$tmesh, double t0, double t1, double $\ast$zustand, double $\ast$$\ast$y, double $\ast$$\ast$$\ast$dmds, double $\ast$$\ast$$\ast$dmdp, double $\ast$$\ast$dyds, double $\ast$$\ast$dydp, double $\ast$parameter, double rtol, double atol, double min\_\-stepsize, double max\_\-stepsize, double initial\_\-stepsize)
\item 
void {\bf ode\_\-} (int \&n, int \&m, double \&x, double $\ast$y, double $\ast$dydx, double $\ast$p)
\item 
void {\bf jac\_\-} (int $\ast$NEQ, double \&t, double $\ast$y, int \&n, double $\ast$p, int \&M, double $\ast$pd)
\item 
void {\bf od\_\-ode\_\-} (int $\ast$NEQ, double \&t, double $\ast$y, int \&N, double $\ast$p, int \&M, double $\ast$dfdp, int \&j)
\item 
void {\bf ad\_\-ode\_\-} (int \&, int \&, int \&, double \&, double $\ast$, double $\ast$, double $\ast$, int \&, double $\ast$, double $\ast$, int \&)
\end{CompactItemize}


\subsection{Function Documentation}
\index{call_odessa.cc@{call\_\-odessa.cc}!_dcopy@{\_\-dcopy}}
\index{_dcopy@{\_\-dcopy}!call_odessa.cc@{call\_\-odessa.cc}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void \_\-dcopy (double $\ast$ {\em dest}, double $\ast$ {\em src}, long {\em n})\hspace{0.3cm}{\tt  [inline]}}\label{call__odessa_8cc_4bd76d53925e08a9beeed4802a2dbc53}




Definition at line 32 of file call\_\-odessa.cc.

Referenced by \_\-init\-Yt().

\footnotesize\begin{verbatim}33 {
34   memcpy (dest + 1, src + 1, n * sizeof (double));
35 }
\end{verbatim}\normalsize 


\index{call_odessa.cc@{call\_\-odessa.cc}!_dfill0@{\_\-dfill0}}
\index{_dfill0@{\_\-dfill0}!call_odessa.cc@{call\_\-odessa.cc}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void \_\-dfill0 (double $\ast$ {\em x}, long {\em n})\hspace{0.3cm}{\tt  [inline]}}\label{call__odessa_8cc_900f1efba7d57ecea1d930bdcdd0b2ea}




Definition at line 37 of file call\_\-odessa.cc.

Referenced by \_\-init\-Yt().

\footnotesize\begin{verbatim}38 {
39   memset (x + 1, 0, n * sizeof (double));
40 }
\end{verbatim}\normalsize 


\index{call_odessa.cc@{call\_\-odessa.cc}!_initYt@{\_\-initYt}}
\index{_initYt@{\_\-initYt}!call_odessa.cc@{call\_\-odessa.cc}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void \_\-init\-Yt (double $\ast$ {\em Yt}, double $\ast$ {\em state})}\label{call__odessa_8cc_a0488a375ef50508e2eef8e6c980f096}




Definition at line 42 of file call\_\-odessa.cc.

References \_\-dcopy(), and \_\-dfill0().

\footnotesize\begin{verbatim}43 {
44   // initialise Y
45   if (state)
46     _dcopy (Yt, state, NEQNS);    // original state vector
47   _dfill0 (Yt + NEQNS, (NPARAMS + NEQNS) * NEQNS);    // 0 in middle and rear part
48   for (long i = 1; i <= NEQNS; i++)       // identity matrix in rear part dy/dy0
49     Yt[(NPARAMS + i) * NEQNS + i] = 1;
50 }                       
\end{verbatim}\normalsize 


\index{call_odessa.cc@{call\_\-odessa.cc}!ad_ode_@{ad\_\-ode\_\-}}
\index{ad_ode_@{ad\_\-ode\_\-}!call_odessa.cc@{call\_\-odessa.cc}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void ad\_\-ode\_\- (int \&, int \&, int \&, double \&, double $\ast$, double $\ast$, double $\ast$, int \&, double $\ast$, double $\ast$, int \&)}\label{call__odessa_8cc_73472d673d9b8a792362dd5f9c0ebcf1}




Definition at line 530 of file call\_\-odessa.cc.

\footnotesize\begin{verbatim}532 {
533   cerr << "unexpected call to AD_ODE" <<endl;
534 }
\end{verbatim}\normalsize 


\index{call_odessa.cc@{call\_\-odessa.cc}!call_odessa@{call\_\-odessa}}
\index{call_odessa@{call\_\-odessa}!call_odessa.cc@{call\_\-odessa.cc}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void call\_\-odessa ({\bf Glob} $\ast$ {\em globs}, {\bf Glob\-Exp} $\ast$ {\em ex}, int {\em N}, int {\em M\_\-PAR\_\-GES}, char $\ast$ {\em do\-P}, int {\em D\_\-FLAG}, int {\em MAX\_\-NR\_\-STEP}, int {\em STIFF}, int {\em inhomogen}, int {\em nmesh}, double $\ast$ {\em tmesh}, double {\em t0}, double {\em t1}, double $\ast$ {\em zustand}, double $\ast$$\ast$ {\em y}, double $\ast$$\ast$$\ast$ {\em dmds}, double $\ast$$\ast$$\ast$ {\em dmdp}, double $\ast$$\ast$ {\em dyds}, double $\ast$$\ast$ {\em dydp}, double $\ast$ {\em parameter}, double {\em rtol}, double {\em atol}, double {\em min\_\-stepsize}, double {\em max\_\-stepsize}, double {\em initial\_\-stepsize})}\label{call__odessa_8cc_77d593ebea400902d8585a26dff9e89e}




Definition at line 69 of file call\_\-odessa.cc.

References dmatrix(), dvector(), ivector(), Glob::npar, Glob\-Exp::nvar, and TRUE.

Referenced by tabulate\-Values().

\footnotesize\begin{verbatim}75 {
76 
77 /* from DOKUMENTATION/call_odessa.doc
78 obsolet: N      nVar=anzahl der gleichungen
79 obsolet: M_PAR_GES, nPExp=gesamt_anzahl der parameter
80 char *doP       [1..nPExp] parameter fixen ("0") oder optimieren (sonst)
81 hieraus berechnet:
82     M_PAR_SENS  anzahl zu variierender parameter
83     M_GES =     nVar+M_PAR_SENS; anzahl fit-variablen
84 int D_FLAG      verwende OD_ODE (1) oder AD_ODE (0)
85 int MAX_NR_STEP maximale anzahl der integrationsschritte
86 int STIFF       steifes / nicht-steifes problem (1 / 0)
87 int inhomogen   liegt Inhomogenitätsmatrix vor (1)? bestimme die ableitungen
88                 ansonsten über finite differenzen (0)
89 int nmesh       anzahl der punkte, auf denen der zustand berechnet werden soll
90 double *tmesh           zeitpunkte, an denen der zustand berechnet werden soll
91 obsolet: sens_mesh;     Sensitivitäten werden entweder gar nicht berechnet
92                         (dmds==NULL) oder am Endpunkt UND an den Datenpunkten
93                         (dmds,dmdp,dyds,dydp!=NULL)
94 double t0               Startpunkt, kann < tmesh[1] sein
95 double t1               Endpunkt, kann > tmesh[nmesh] sein
96 double **y              [k=1..nmesh][1..nVar] output: y(tmesh[k])
97 double *zustand         [1..nVar] input: y(t0), output: y(t1)
98 wie in tabVal:
99 double ***dmds          [k=1..nmesh][i=1..nVar][j=1..nVar] dy[i]/dy0[j](jacobi)
100 double ***dmdp          [k=1..nmesh][i=1..nVar][j=1..nPExp] (hiess sensitiv)
101                         output: Sensitivitäten dy[i]/dp[j] bei t=tmesh[k]
102 double **dyds           [i=1..nVar][j=1..nVar]         dy[i]/dy0[j] bei t=t1
103 double **dydp           [i=1..nVar][j=1..nPExp] dy[i]/dp[j]  bei t=t1
104 double *parameter       [1..nPExp] parameter-vektor
105 double rtol             error test passes if yerr<rtol*|y|+atol
106 double atol
107 double min_stepsize     minimale schrittweite
108 double max_stepsize     maximale schrittweite
109 double initial_stepsize
110  */
111 
112   /*==================*/
113   /* lokale variablen */
114   /*==================*/
115 
116   int i = 0, j = 0, k = 0, M_GES, M_PAR_SENS = 0;
117   long nPExp=globs->npar;
118   long nVar=ex->nvar;
119   double * gy=dvector(1,NOBS);
120   int generic=TRUE;
121   
122   /*===============================*/
123   /* berechne M_GES und M_PAR_SENS */
124   /*===============================*/
125 
126   for (i = 1; i <= nPExp; i++)
127     if (doP[i] != '0')
128       M_PAR_SENS++;
129   M_GES = nVar + M_PAR_SENS;
130 
131   /*=======================*/
132   /* stelle NEQ() zusammen */
133   /*=======================*/
134 
135   int IPAR_offset = 10;
136   // wenn diese größe verändert wird, muß berechne_doP_komponente.f
137   // ebenfalls angepaßt werden !!
138 
139   int *NEQ;
140   NEQ = ivector (1, IPAR_offset + nPExp);
141 
142   // stecke den gesamten doP-vektor (in int umgewandelt) in NEQ,
143   // sodass dies global zugänglich ist!
144   for (i = 1; i <= nPExp; i++)
145     NEQ[IPAR_offset + i] = (doP[i] != '0' ? 1 : 0);
146 
147   // alle NEQ-einträge die startwerte betreffend werden
148   // in berechne_komponente auf null gesetzt, sodass keine
149   // inhomogenitäten für diese "Parameter" berechnet werden
150 
151   NEQ[1] = nVar;
152   NEQ[2] = M_GES;               // = nVar + M_PAR_SENS
153   NEQ[3] = M_PAR_SENS;          // Anzahl Fitparameter, <=nPExp
154   NEQ[4] = D_FLAG;
155   NEQ[5] = nPExp;
156 
157   /*===================*/
158   /* stelle Y zusammen */
159   /*===================*/
160 
161   double **Yt = dmatrix (0, M_GES, 1, nVar);
162   //Y = dvector(1,nVar + nVar*M_GES);
163   for (i = 1; i <= nVar; i++)
164     Yt[0][i] = zustand[i];
165 
166   for (j = 1; j <= M_PAR_SENS + nVar; j++)
167     {
168 
169       // initialisiere: Sij = 0 für dy/dp
170 
171       if (j <= M_PAR_SENS)
172         for (i = 1; i <= nVar; i++)
173           Yt[j][i] = 0.0;
174 
175       // initialisiere: Sii = 1 für dyi/dyi°
176 
177       else
178         for (i = 1; i <= nVar; i++)
179           if ((j - M_PAR_SENS) == i)
180             Yt[j][i] = 1.0;
181           else
182             Yt[j][i] = 0.0;
183     }                           //nächster zustand i, der abgeleitet werden soll
184   //Yt[2][2]=0;//!!
185 
186   /*=====================*/
187   /* stelle PAR zusammen */
188   /*=====================*/
189 
190   double *PARAMETER;
191   PARAMETER = dvector (1, nPExp + nVar * nVar);
192   //(1,nPExp) wird von ODESSA erwartet, der rest ist zur vereinfachung
193 
194   //übergebe an PARAMETER alle Parameter!
195   int zaehler = 1;
196   for (i = 1; i <= nPExp; i++)
197     PARAMETER[i] = parameter[i];
198 
199   /*=================================*/
200   /* stelle fehlerparameter zusammen */
201   /*=================================*/
202 
203   int SqualCheck=FALSE;
204   int ITOL = SqualCheck ? 1 : 4;        // erlaubt: 1 or 4
205   int nTOL = (ITOL == 4) ? nVar * (M_GES + 1) : 1;
206 
207   double *RTOL = dvector (1, nTOL);
208   double *ATOL = dvector (1, nTOL);
209   if (ITOL == 4)
210     {
211       for (i = 1; i <= nVar; i++)
212         {
213           RTOL[i] = rtol;       // 1..nVar: rtol
214           ATOL[i] = atol;
215         }
216       for (; i <= nTOL; i++)
217         {
218           RTOL[i] = rtol * 1e8; // nVar+1..: fast ignoriert
219           ATOL[i] = atol * 1e8;
220         }
221     }
222   else
223     {
224       RTOL[1] = rtol;           // alle: rtol
225       ATOL[1] = atol;
226     }
227 
228   /*===================================*/
229   /* stelle kontrollparameter zusammen */
230   /*===================================*/
231 
232   int ITASK = 1;                //siehe ODESSA-beschreibung -> normale integration von T bis TOUT
233   // variable der status-abfrage
234   int ISTATE = 1;               //-> erster aufruf von ODESSA!
235 
236   int *IOPT;
237   IOPT = ivector (1, 3);
238   IOPT[1] = 1;                  //zusätzliche angaben über RWORK-feld
239   IOPT[2] = 1;                  //sensitivitäten werden berechnet !
240   IOPT[3] = inhomogen;          //verwende inhomogenitäten, sonst finite differenzen
241 
242   int MITER = 1;                // -> volle Jacobi-Matrix vorhanden
243   int METH;                     // normaler / steifer Integrator
244   int MAXORD;                   // maximale ordnung der verwendeten approximationen
245 
246   if (STIFF == 0)
247     {
248       METH = 1;
249       MAXORD = 12;
250     }
251   else
252     {
253       METH = 2;
254       MAXORD = 5;
255     }
256   int MF = 10 * METH + MITER;
257   //cout<<"mf = "<<MF<<LF;
258 
259   /*=================================*/
260   /* stelle arbeitsspeicher zusammen */
261   /*=================================*/
262 
263   int LRW;
264   int LIW;
265 
266   if (IOPT[1] == 0)
267     {                           //ohne sensitivitäten
268       LRW = 20 + nVar * (MAXORD + 1) + 3 * nVar + nVar * nVar + 2 + 1;
269       LIW = 20 + nVar;
270     }
271   if (IOPT[1] == 1)
272     {                           //mit sensitivitäten
273       LRW = 20 + nVar * (M_GES + 1) * (MAXORD + 1) + 2 * nVar * (M_GES + 1) +
274         nVar * nVar + 2 + nVar + 1;
275       LIW = 21 + nVar + M_GES;
276     }
277 
278   double *RWORK;
279   RWORK = dvector (1, LRW);
280 
281   int *IWORK;
282   IWORK = ivector (1, LIW);
283 
284   /*==================================*/
285   /* stelle optionalen input zusammen */
286   /*==================================*/
287 
288   // odeint detects stepsize underflow independently of hmin
289   // odessa relies on min_stepsize being large enough to avoid prevent it
290   if (t0 + min_stepsize == t0)
291     {
292       cerr<< t0 << "\t" << min_stepsize << endl;
293       throw 1;
294     }
295   if (t1 + min_stepsize == t0)
296     {
297       cerr<< t0 << "\t" << min_stepsize << endl;
298       throw 1;
299     }
300 
301   RWORK[5] = initial_stepsize;
302   RWORK[6] = max_stepsize;
303   RWORK[7] = min_stepsize;
304 
305   IWORK[5] = MAXORD;
306   IWORK[6] = MAX_NR_STEP;
307   IWORK[7] = 3;                 // not more than 3 warnings of type T=T+H
308 
309   /*==================================*/
310   /* bestimme T und TOUT mittels tmesh */
311   /*==================================*/
312 
313 
314   double T = t0;
315   double TOUT;                  //wird mittels gitter vorgegeben
316 
317 
318   if (dmds)
319     {                           // Sensitivitäten speichern
320       double **dgdy = NULL, **dgdp = NULL;
321       dgdy = dmatrix (1, NOBS, 1, nVar);
322       dgdp = dmatrix (1, NOBS, 1, nPExp);
323       _dfill0 (dgdy[1], NOBS * nVar);
324       _dfill0 (dgdp[1], NOBS * nPExp);
325 
326 
327       for (k = 1; k <= nmesh + 1; k++)
328         {
329           if (k > nmesh)
330             TOUT = t1;          // Endpunkt
331           else
332             TOUT = tmesh[k];    // Datenpunkt
333 
334           /*=================*/
335           /* rufe ODESSA auf */
336           /*=================*/
337 
338           odessa_ (&NEQ[1],
339                    &Yt[0][1],
340                    &PARAMETER[1],
341                    &T, &TOUT, &ITOL, &RTOL[1], &ATOL[1],
342                    &ITASK, &ISTATE, &IOPT[1], &RWORK[1], &LRW, &IWORK[1],
343                    &LIW, &MF);
344 
345           if (ISTATE < 0)
346             break;              // skip remaining k
347 
348           // Zustand speichern
349           int jlong;            // 1..nPExp
350           if (k > nmesh)
351             {                   // Endpunkt
352               _dcopy (zustand, Yt[0], nVar);
353 
354               for (j = 1; j <= M_PAR_SENS; j++)
355                 {
356                   dop_komponente_ (&NEQ[1], j, jlong);
357 
358                   //übernehme die ableitung nach den parametern
359                   for (i = 1; i <= nVar; i++)
360                     dydp[i][jlong] = Yt[j][i];
361                   // jlong and j were exchanged until 3/02
362                 }
363 
364               for (j = 1; j <= nVar; j++)
365                 //übernehme die ableitung nach den startwerten
366                 for (i = 1; i <= nVar; i++)
367                   {
368                     dyds[i][j] = Yt[M_PAR_SENS + j][i];
369                   }
370             }
371           else
372             {                   // k<=nmesh: Datenpunkt
373               _dcopy (y[k], Yt[0], nVar);
374 
375               // write sensitivities to dm/dp and dm/ds
376               // support for extra observables as in odeExpment::tabVal
377               //if (nVarObs > nVar)
378               //  observation (globs,ex,TOUT, y[k], globs->par, dgdy, dgdp);
379               generic=observation(globs,ex,TOUT, y[k],gy, ex->par, dgdy, dgdp);
380               for(i=1;i<=NOBS;i++)
381                 y[k][i]=gy[i];
382               
383               for (i = 1; i <= NOBS; i++)
384                 {
385                   int ivar = i;
386                   for (j = 1; j <= M_PAR_SENS; j++)
387                     {
388                       dop_komponente_ (&NEQ[1], j, jlong);
389                       double &dest = dmdp[k][i][jlong];
390                       if (!generic)
391                         {
392                           dest = dgdp[i][j];
393                           for (long l = 1; l <= nVar; l++)
394                             dest += dgdy[i][l] * Yt[j][l];
395                         }
396                       else
397                         dest = Yt[j][i];
398                     }           // for j
399                   for (j = 1; j <= nVar; j++)
400                     {
401                       double &dest = dmds[k][i][j];
402                       if (!generic)
403                         {
404                           dest = 0;
405                           for (long l = 1; l <= nVar; l++)
406                             dest +=  dgdy[ivar][l] * Yt[M_PAR_SENS + j][l];
407                         }
408                       else
409                         dest = Yt[M_PAR_SENS + j][ivar];
410                     }           // for j
411                 }               // for i
412             }                   // if k>nmesh else
413 
414           T = TOUT;             // für nächstes k
415         }                       //nächster zeitpunkt k
416       //BEGIN eingefuegt von Felix
417       if (dgdy)
418         free_dmatrix (dgdy, 1, NOBS, 1, nVar);
419       if (dgdp)
420         free_dmatrix (dgdp, 1, NOBS, 1, nPExp);
421       //END
422     }
423   else
424     {                           // !dmds
425 
426       for (k = 1; k <= nmesh + 1; k++)
427         {
428           if (k > nmesh)
429             TOUT = t1;          // Endpunkt
430           else
431             TOUT = tmesh[k];    // Datenpunkt
432 
433           odessa_ (&NEQ[1],
434                    &Yt[0][1],
435                    &PARAMETER[1],
436                    &T, &TOUT, &ITOL, &RTOL[1], &ATOL[1],
437                    &ITASK, &ISTATE, &IOPT[1], &RWORK[1], &LRW, &IWORK[1],
438                    &LIW, &MF);
439 
440           if (ISTATE < 0)
441             break;              // skip remaining k
442 
443           // Zustand speichern
444           if (k > nmesh)        // Endpunkt
445             _dcopy (zustand, Yt[0], nVar);
446           else
447             {                   // k<=nmesh: Datenpunkt
448               _dcopy (y[k], Yt[0], nVar);
449               
450               // compute extra observables
451               generic=observation (globs,ex,TOUT, y[k],gy,ex->par, NULL, NULL);
452               for(i=1;i<=NOBS;i++)
453                 y[k][i]=gy[i];
454             }
455           T = TOUT;             // für nächstes k
456         }                       //nächster zeitpunkt k
457 
458     }                           // if dmds else
459 
460 
462 
463   // dvector
464 
465   free_dmatrix (Yt, 0, M_GES, 1, nVar);
466   free_dvector (PARAMETER, 1, nPExp + nVar * nVar);
467 
468   free_dvector (RTOL, 1, nTOL);
469   free_dvector (ATOL, 1, nTOL);
470   free_dvector (RWORK, 1, LRW);
471   free_dvector (gy,1,NOBS);
472 
473   // ivector
474 
475   free_ivector (NEQ, 1, IPAR_offset + nPExp);
476   free_ivector (IWORK, 1, LIW);
477   free_ivector (IOPT, 1, 3);
478 
479   /*===================================================*/
480   /* abfang eventueller fehler / auswertung von ISTATE */
481   /*===================================================*/
482 
483   char *odessaErrStr[6] = {
484     "excess work done on this call (perhaps wrong MF)",
485     "excess accuracy requested (tolerances too small)",
486     "illegal input detected (see printed message)",
487     "repeated error test failures (check all inputs)",
488     "repeated convergence failures\n"
489       "(perhaps bad jacobian supplied or wrong choice of MF or tolerances)",
490     "error weight became zero during problem\n"
491       "(solution component I,J vanished, and ATOL or ATOL(I,J) = 0.0)"
492   };
493 
494   if (ISTATE < 0)
495     {
496       cerr << odessaErrStr[-ISTATE - 1] <<endl;
497       throw 1;
498     }
499 }                              // odeExpment::call_odessa
\end{verbatim}\normalsize 


\index{call_odessa.cc@{call\_\-odessa.cc}!dop_komponente_@{dop\_\-komponente\_\-}}
\index{dop_komponente_@{dop\_\-komponente\_\-}!call_odessa.cc@{call\_\-odessa.cc}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void dop\_\-komponente\_\- (int {\em NEQ}[$\,$], int \& {\em J\_\-OPT}, int \& {\em J\_\-GES})}\label{call__odessa_8cc_20c02fc28d7425d4ad8e7d63855fec06}


\index{call_odessa.cc@{call\_\-odessa.cc}!jac_@{jac\_\-}}
\index{jac_@{jac\_\-}!call_odessa.cc@{call\_\-odessa.cc}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void jac\_\- (int $\ast$ {\em NEQ}, double \& {\em t}, double $\ast$ {\em y}, int \& {\em n}, double $\ast$ {\em p}, int \& {\em M}, double $\ast$ {\em pd})}\label{call__odessa_8cc_9b3a720f825d7b5c632992095bed06a3}




Definition at line 513 of file call\_\-odessa.cc.

\footnotesize\begin{verbatim}514 {
515   double **dfdy = new double *[NEQNS] - 1;
516   for (int i = 1; i <= NEQNS; i++)
517     dfdy[i] = pd - 1 + (i - 1) * NEQNS;
518   jacobi (t, y - 1, dfdy, p - 1);
519   delete[]++ dfdy;
520 }
\end{verbatim}\normalsize 


\index{call_odessa.cc@{call\_\-odessa.cc}!od_ode_@{od\_\-ode\_\-}}
\index{od_ode_@{od\_\-ode\_\-}!call_odessa.cc@{call\_\-odessa.cc}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void od\_\-ode\_\- (int $\ast$ {\em NEQ}, double \& {\em t}, double $\ast$ {\em y}, int \& {\em N}, double $\ast$ {\em p}, int \& {\em M}, double $\ast$ {\em dfdp}, int \& {\em j})}\label{call__odessa_8cc_a2387a8bb8030d5a034dbd29d4a7c739}




Definition at line 522 of file call\_\-odessa.cc.

\footnotesize\begin{verbatim}524 {
525   if (!j)
526     return;
527   inhomo1 (t, y - 1, dfdp - 1, p - 1, j);
528 }                               // od_ode_
\end{verbatim}\normalsize 


\index{call_odessa.cc@{call\_\-odessa.cc}!ode_@{ode\_\-}}
\index{ode_@{ode\_\-}!call_odessa.cc@{call\_\-odessa.cc}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void ode\_\- (int \& {\em n}, int \& {\em m}, double \& {\em x}, double $\ast$ {\em y}, double $\ast$ {\em dydx}, double $\ast$ {\em p})}\label{call__odessa_8cc_5cf070a66ead81817c12b2a0308462a9}




Definition at line 508 of file call\_\-odessa.cc.

\footnotesize\begin{verbatim}509 {
510   ode (x, y - 1, dydx - 1, p - 1);
511 }                               // ode_
\end{verbatim}\normalsize 


\index{call_odessa.cc@{call\_\-odessa.cc}!odessa_@{odessa\_\-}}
\index{odessa_@{odessa\_\-}!call_odessa.cc@{call\_\-odessa.cc}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int odessa\_\- (int {\em NEQ}[$\,$], double {\em Y}[$\,$], double {\em PAR}[$\,$], double $\ast$ {\em T}, double $\ast$ {\em TOUT}, int $\ast$ {\em ITOL}, double $\ast$ {\em RTOL}, double $\ast$ {\em ATOL}, int $\ast$ {\em ITASK}, int $\ast$ {\em ISTATE}, int {\em IOPT}[$\,$], double {\em RWORK}[$\,$], int $\ast$ {\em LRW}, int {\em IWORK}[$\,$], int $\ast$ {\em LIW}, int $\ast$ {\em MF})}\label{call__odessa_8cc_b4fe95e752b1952cfdeb6927b86b7062}


