\section{/home/peifer/diffit/glob\-Opt.cc File Reference}
\label{globOpt_8cc}\index{/home/peifer/diffit/globOpt.cc@{/home/peifer/diffit/globOpt.cc}}
{\tt \#include $<$iostream$>$}\par
{\tt \#include $<$fstream$>$}\par
{\tt \#include $<$stdlib.h$>$}\par
{\tt \#include $<$stdio.h$>$}\par
{\tt \#include \char`\"{}lib\-SRES/sharefunc.h\char`\"{}}\par
{\tt \#include \char`\"{}lib\-SRES/ESSRSort.h\char`\"{}}\par
{\tt \#include \char`\"{}lib\-SRES/ESES.h\char`\"{}}\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 int\-ODE} ({\bf Glob\-Exp} $\ast$ex, {\bf Glob} $\ast$globs, int do\-Derivs, int do\-Plot, long exp\-Nr)
\item 
double {\bf compute\-Right} ({\bf Glob} $\ast$globs, {\bf Glob\-Exp} $\ast$ex)
\item 
void {\bf solv\-Lin} ({\bf Glob} $\ast$globs, {\bf Glob\-Exp} $\ast$ex, int compute\-Covar)
\item 
double {\bf damp\-It} ({\bf Glob} $\ast$globs, {\bf Glob\-Exp} $\ast$ex, double $\ast$$\ast$P0, double $\ast$$\ast$$\ast$S0, double $\ast$$\ast$d\-P, double $\ast$$\ast$$\ast$d\-S, double $\ast$u\-S)
\item 
void {\bf fitness} (double $\ast$x, double $\ast$f, double $\ast$g)
\item 
void {\bf glob\-Opt} ({\bf Glob\-Exp} ex[$\,$], {\bf Glob} $\ast$globs)
\end{CompactItemize}
\subsection*{Variables}
\begin{CompactItemize}
\item 
{\bf Glob} $\ast$ {\bf globs\-Ptr}
\item 
{\bf Glob\-Exp} $\ast$ {\bf ex\-Ptr}
\end{CompactItemize}


\subsection{Function Documentation}
\index{globOpt.cc@{glob\-Opt.cc}!computeRight@{computeRight}}
\index{computeRight@{computeRight}!globOpt.cc@{glob\-Opt.cc}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}double compute\-Right ({\bf Glob} $\ast$ {\em globs}, {\bf Glob\-Exp} $\ast$ {\em ex})}\label{globOpt_8cc_6d52e05b0106034e961975936240e279}




Definition at line 39 of file compute\-Right.cc.

\footnotesize\begin{verbatim}40 {
41     long i,j,k;
42 
43     // calculate discrepancies, residues and constraints
44     long nPoints=ex->nPoints, nvar=ex->nvar;
45     long nMeasure=ex->nMeasure, nobs=ex->nobs;
46     long nP=globs->npar;
47 
48     // no continuity constraints for first and last mesh point
49     for (j=1;j<=nvar;++j) {
50         ex->h[1][j]=0;
51         ex->h[nPoints][j]=0;
52     }
53     for (i=2;i<nPoints;++i)
54       {
55         for (j=1;j<=nvar;++j)
56           ex->h[i][j]=ex->yComp[i][j]-ex->yTry[i][j];
57       }
58     for (i=1;i<=nMeasure;++i)
59       {
60         for (j=1;j<=nobs;++j)
61           ex->residues[i][j]=ex->yPred[i][j]-ex->yMeasure[i][j];
62       }
63 
64     //extra equality and inequality constraints
65     R2(globs,ex, TRUE);
66     R3(globs,ex ,TRUE);
67 
68 #ifdef PRINTDERIVS
69     for (i=1; i<=nPoints; ++i) {
70         *dbg << "dyds[" << i << "] = (";
71         for (j=1; j<=nvar; ++j) {
72             for (k=1; k<=nvar; ++k)
73                 *dbg << " " << ex->dyds[i][j][k];
74             *dbg << ", ";
75         }
76         *dbg << ")\ndydp[" << i << "] = (";
77         for (j=1; j<=nvar; ++j) {
78             for (k=1; k<=nP; ++k)
79                 *dbg << " " << ex->dydp[i][j][k];
80             *dbg << ", ";
81         }
82         *dbg << ")\n";
83     }
84     for (i=1; i<=nMeasure; ++i) {
85         *dbg << "dmds[" << i << "] = (";
86         for (j=1; j<=nobs; ++j) {
87             for (k=1; k<=nvar; ++k)
88                 *dbg << " " << ex->dmds[i][j][k];
89             *dbg << ", ";
90         }
91         *dbg << ")\ndmdp[" << i << "] = (";
92         for (j=1; j<=nobs; ++j) {
93             for (k=1; k<=nP; ++k)
94                 *dbg << " " << ex->dmdp[i][j][k];
95             *dbg << ", ";
96         }
97         *dbg << ")\n";
98     }
99     for (i=1; i<=ex->me; ++i) {
100         *dbg << "dR2ds[" << i << "] = (";
101         for (j=1; j<=nPoints; ++j) {
102             for (k=1; k<=nvar; ++k)
103                 *dbg << " " << ex->dR2ds[i][j][k];
104             *dbg << ", ";
105         }
106         *dbg << ")\n";
107         *dbg << "dR2dp[" << i << "] = (";
108         for (j=1; j<=nP; ++j)
109             *dbg << " " << ex->dR2dp[i][j];
110         *dbg << ")\n";
111     }
112     for (i=1; i<=ex->mg; ++i) {
113         *dbg << "dR3ds[" << i << "] = (";
114         for (j=1; j<=nPoints; ++j) {
115             for (k=1; k<=nvar; ++k)
116                 *dbg << " " << ex->dR3ds[i][j][k];
117             *dbg << ", ";
118         }
119         *dbg << ")\n";
120         *dbg << "dR3dp[" << i << "] = (";
121         for (j=1; j<=nP; ++j)
122             *dbg << " " << ex->dR3dp[i][j];
123         *dbg << ")\n";
124     }
125     dbg->flush();
126 #endif
127 
128     return(objectiveF(globs,ex));
129 }
\end{verbatim}\normalsize 


\index{globOpt.cc@{glob\-Opt.cc}!dampIt@{dampIt}}
\index{dampIt@{dampIt}!globOpt.cc@{glob\-Opt.cc}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}double damp\-It ({\bf Glob} $\ast$ {\em globs}, {\bf Glob\-Exp} $\ast$ {\em ex}, double $\ast$$\ast$ {\em P0}, double $\ast$$\ast$$\ast$ {\em S0}, double $\ast$$\ast$ {\em d\-P}, double $\ast$$\ast$$\ast$ {\em d\-S}, double $\ast$ {\em u\-S})}\label{globOpt_8cc_fd845b25760e3f82f6f527956fab80e8}




Definition at line 155 of file damp\-It.cc.

References Glob::chisq, FALSE, Norm(), Glob::silent, sub\-It(), TRUE, and Glob::wquer.

\footnotesize\begin{verbatim}157 {
158   int etaOk=FALSE,i=1;
159   double tau=0.95;
160   double t;
161   double tau_min=0.1;
162   double eta0=1.;
163   double eta2=1.8; //should be parsed
164 
165   double normdx=Norm(globs,ex,dS,dP,*uS);
166   // damping algorithm
167 
168   if(globs->wquer<0)
169     {
170       globs->wquer=1.*eta0/normdx;
171     }
172   
173   else
174     t=eta0/(globs->wquer*normdx);
175   
176   if (t > tau) 
177     {
178       t=1;
179     }
180   else if(t <= tau_min)
181     {
182       t=tau_min;
183     }
184  
185   globs->wquer=subIt(globs, ex, t,normdx,P0, S0, dP, dS,*uS);
186   if(globs->silent!=TRUE)
187     {
188       cout << "Start damping:\n";
189       cout << "#" << i << " (Predicted)  t = " << t << "\t";
190       cout << "chisq=" << globs->chisq;
191       cout << endl;
192     }
193 
194   etaOk=((globs->wquer*t*normdx)<eta2);
195   i++;
196 
197   while (!etaOk) 
198     {
199       t=eta0/(normdx*globs->wquer);
200         
201       if (t > tau) 
202         {
203           t=1;
204           etaOk=TRUE;
205           continue;
206         }
207       else if(t < tau_min)
208         {
209               t=tau_min;
210               etaOk=TRUE;
211               if(globs->silent!=TRUE)
212                 {
213                   cout << "#" << i <<  " (Corrected)  t = " << t << "\t";
214                   cout << "\nMinimal damping factor tau_min= " << tau_min << " reached.\n";
215                 }
216               continue;
217         }
218       globs->wquer=subIt(globs, ex, t, normdx,P0, S0, dP, dS,*uS);
219       if(globs->silent!=TRUE)
220         {
221           cout << "#" << i <<  " (Corrected)  t = " << t << "\t";
222           cout << "chisq=" << globs->chisq;
223           cout << endl;
224         }
225       etaOk=((globs->wquer*t*normdx)<eta2);
226       i++;
227       if(i>=10)
228         {
229           cerr << "Too many corrections.\n";
230           throw 1;
231         }
232     }
233   return(t);
234 }
\end{verbatim}\normalsize 


\index{globOpt.cc@{glob\-Opt.cc}!fitness@{fitness}}
\index{fitness@{fitness}!globOpt.cc@{glob\-Opt.cc}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void fitness (double $\ast$ {\em x}, double $\ast$ {\em f}, double $\ast$ {\em g})}\label{globOpt_8cc_167dde5f43560ad7da08adabfeb4b514}




Definition at line 35 of file glob\-Opt.cc.

References ex\-Ptr, globs\-Ptr, Glob::nr\-Exp, TRUE, Glob::y0fix, and Glob\-Exp::y\-Try.

\footnotesize\begin{verbatim}36 {
37   long nExp,j;
38   long pos=0;
39   double sum=0;
40   
41   for (nExp=1;nExp<=globsPtr->nrExp;++nExp)
42     {
43       for(j=1;j<=NEQNS;j++)
44         {
45           if(globsPtr->y0fix[j]==TRUE)
46             {
47               exPtr[nExp].yTry[1][j]=x[pos];
48               pos++;
49             }
50         } 
51       for(j=1;j<=globsPtr->npar;j++)
52         {
53           if(globsPtr->doP[j]=='L')
54             {
55               exPtr[nExp].par[j]=x[pos];
56               pos++;
57             }
58         } 
59     }
60   for(j=1;j<=globsPtr->npar;j++)
61     {
62       if(globsPtr->doP[j]==TRUE)
63         {
64           for (nExp=1;nExp<=globsPtr->nrExp;++nExp)
65             exPtr[nExp].par[j]=x[pos];
66           pos++;
67         }
68     } 
69   
70   
71   for (nExp=1;nExp<=globsPtr->nrExp;++nExp)
72         {
73           try
74             {
75               intODE(&exPtr[nExp],globsPtr,FALSE,FALSE,nExp);
76               // set up internal data (residues, etc.)
77               sum+=computeRight(globsPtr,&exPtr[nExp]);
78             }
79           catch(int i)
80             {
81               sum+=1e10;
82             }
83         }
84   globsPtr->chisq=sum;
85   (*f)=sum;
86 }
\end{verbatim}\normalsize 


\index{globOpt.cc@{glob\-Opt.cc}!globOpt@{globOpt}}
\index{globOpt@{globOpt}!globOpt.cc@{glob\-Opt.cc}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void glob\-Opt ({\bf Glob\-Exp} {\em ex}[$\,$], {\bf Glob} $\ast$ {\em globs})}\label{globOpt_8cc_d83d1b2a175d158bafd1cb79d3aeb172}




Definition at line 89 of file glob\-Opt.cc.

References ex\-Ptr, globs\-Ptr, lvector(), Glob::n\-Iter, Glob\-Exp::n\-Points, and Glob::nr\-Exp.

\footnotesize\begin{verbatim}90 {
91   globsPtr=globs;
92   exPtr=ex;
93 
94 
95   globsPtr->nIter=0;
96   long i,j;
97   //variables for libSRES
98   ESParameter *param;
99   ESPopulation *population;
100   ESStatistics *stats;
101   ESfcnTrsfm *trsfm;
102   unsigned int seed;
103   int es;
104   int dim=0;
105   double *ub, *lb;
106   int miu, lambda, gen;
107   double gamma, alpha, varphi;
108   int retry;
109   double pf; 
110 
111   //keeping old values
112   long unsigned *nms=lvector(1,globsPtr->nrExp);
113   for(i=1;i<=globsPtr->nrExp;i++)
114     {
115       nms[i]=exPtr[i].nPoints;
116       exPtr[i].nPoints=2;
117     }
118 
119   seed = shareDefSeed;
120   gamma = esDefGamma;
121   alpha = esDefAlpha;
122   varphi = esDefVarphi;
123   retry = esDefRetry;
124   pf = essrDefPf;
125   es = esDefESSlash;
126   miu = 30;
127   lambda = 200;
128   gen = 1750;
129   trsfm = NULL;
130 
131   //determine # of decision variables
132   for(i=1;i<=globsPtr->nrExp;i++)
133     {
134       for(j=1;j<=NEQNS;j++)
135         {
136           if(globsPtr->y0fix[j]==TRUE)
137             dim++;
138         }
139       for(j=1;j<=globsPtr->npar;j++)
140         {
141           if(globsPtr->doP[j]=='L')
142             dim++;
143         }
144     }      
145   for(j=1;j<=globsPtr->npar;j++)
146     {
147       if(globsPtr->doP[j]==TRUE)
148         dim++;
149     }
150 
151 
152   //bounds ...for test only
153 
154   lb=dvector(0,dim);
155   ub=dvector(0,dim);
156 
157   for(i=0;i<dim;i++)
158     {
159       lb[i]=0;
160       ub[i]=2;
161     }
162 
163   ESInitial(seed, &param, trsfm, fitness, es,0, dim, ub, lb, \
164             miu, lambda, gen, gamma, alpha, varphi,  \
165             retry, &population, &stats);
166   
167   for(int i=1;i<=globsPtr->maxit;i++)
168     { 
169       globsPtr->nIter++;
170       ESStep(population, param, stats, pf);
171       if(stats->curgen >= param->gen)
172         break;
173     }
174   
175   //copying old stuff back
176   for(i=1;i<=globsPtr->nrExp;i++)
177     {
178       exPtr[i].nPoints=nms[i];
179     }
180 
181   cout << endl;
182 
183   free_dvector(lb,0,dim);
184   free_dvector(ub,0,dim);
185   free_lvector(nms,1,globsPtr->nrExp);
186 }
\end{verbatim}\normalsize 


\index{globOpt.cc@{glob\-Opt.cc}!intODE@{intODE}}
\index{intODE@{intODE}!globOpt.cc@{glob\-Opt.cc}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void int\-ODE ({\bf Glob\-Exp} $\ast$ {\em ex}, {\bf Glob} $\ast$ {\em globs}, int {\em do\-Derivs}, int {\em do\-Plot}, long {\em exp\-Nr})}\label{globOpt_8cc_f476965d47230b44b3b9d785a278fd27}




Definition at line 313 of file int\-ODE.cc.

\footnotesize\begin{verbatim}314 {
315   long i,j,k,ksav,l,m,n,nok,nbad;
316   long nobs=ex->nobs;
317   long nPoints=ex->nPoints, nvar=ex->nvar, nMeasure=ex->nMeasure;
318   double *mesh=ex->mesh, *xMeasure=ex->xMeasure;
319   long tableLen=maxTableLen(mesh, nPoints, xMeasure, nMeasure)+1; 
320   double temp, h,ymin,ymax;
321   
322   // allocate memory
323   double *ys=dvector(1,nvar);
324   double *xTab=dvector(1,tableLen);
325   double **yTab=dmatrix(1,tableLen,1,nvar);
326   double ***dTabds, ***dTabdp;
327   char name[50];
328   ofstream gnuout;
329   ofstream outout;
330 
331 
332   //gnuout.open("gnuout.dat");
333   
334   // compute derivatives?
335   // if not, don't write to graphics either
336   // (no genuine integration, but only estimation of omega)
337   if (doDerivs) 
338     {
339       dTabds=d3tensor(1,tableLen,1,nvar,1,nvar);
340       dTabdp=d3tensor(1,tableLen,1,nvar,1,globs->npar);
341     } 
342   else 
343     {
344       dTabds=NULL; 
345       dTabdp=NULL;
346     }
347   
348 
349   // first mesh point
350   if (doDerivs) {
351     for (i=1; i<=nvar; ++i) 
352       {
353         for (j=1; j<=nvar; ++j)
354           { 
355             ex->dyds[1][i][j] = (i==j) ? 1 : 0;
356             ex->dmds[1][i][j] = (i==j) ? 1 : 0;
357           }
358         for (j=1; j<=globs->npar; ++j)  
359           {
360             ex->dydp[1][i][j] = 0;
361             ex->dmdp[1][i][j] = 0;
362           }
363       }
364   }
365   for (j=1; j<=nvar; ++j) 
366     ex->yComp[1][j]=ex->yTry[1][j];
367 
368 
369   if (doDerivs && mesh[1]==xMeasure[1]) 
370     {
371       observation(globs,ex,mesh[1],ex->yTry[1],ex->yPred[1],ex->par,ex->dmds[1],ex->dmdp[1]);
372     }
373   
374   // integrate
375   k=1;
376   ksav=1;
377   if (mesh[1]==xMeasure[1]) 
378     {
379       k=2; 
380       ksav=2;
381     }
382   for (i=1; i< nPoints; ++i) 
383     {   // given starting values
384       for (j=1; j<=nvar; ++j) 
385         ys[j]=ex->yTry[i][j];  
386       if (xMeasure[k]<mesh[i]) 
387         {
388           cerr << "fatal: intODE: xMeasure table corrupted (mesh: "
389                << mesh[i] << ", xMeasure: " << xMeasure[k] << ")\n";
390           throw 1;
391         }
392       // build table of measuring points
393       n=1;
394       while (k <= nMeasure && xMeasure[k]<=mesh[i+1]) 
395         xTab[n++]=xMeasure[k++];
396       xTab[n]=mesh[i+1];
397 #ifdef PRINTMESH
398       *dbg << "Mesh point " << mesh[i] << ": xTab = (";
399       for (j=1; j<=n; ++j) 
400         *dbg << '\t' << xTab[j];
401       *dbg << ")\n";
402       dbg->flush();
403 #endif      
404       //integration 
405       tabulateValues(globs,ex,mesh[i],mesh[i+1],xTab,n,ys,yTab, dTabds, dTabdp,ex->dyds[i+1],ex->dydp[i+1]);
406 
407 #ifdef PRINTINTEGRATE
408       *dbg << "Integration returned\t  (";
409       for (j=1; j<=n; ++j) 
410         {
411           for (l=1; l<=nvar; ++l) 
412             *dbg << " " << yTab[j][l];
413           *dbg << ",";
414         }
415       *dbg << ")\n";
416       dbg->flush();
417 #endif      
418       for (j=1; j<=ex->nvar; ++j)
419         ex->yComp[i+1][j]=ys[j];   // store value at next mesh point
420 
421       for (j=ksav; j<k; ++j)          // store value at measuring points
422         {
423           for (l=1; l<=ex->nobs; ++l) 
424             {
425               ex->yPred[j][l]=yTab[j-ksav+1][l];
426               if (doDerivs) 
427                 {
428                   for (m=1; m<=ex->nvar; ++m)
429                     ex->dmds[j][l][m]=dTabds[j-ksav+1][l][m];
430                   for (m=1; m<=globs->npar; ++m)
431                     ex->dmdp[j][l][m]=dTabdp[j-ksav+1][l][m];
432                 }
433             }
434         }
435       ksav=k;
436     }
437 
438       //GnuPlotting
439   long mind=2;
440   if(doDerivs && (globs->noGnu==FALSE) && doPlot==TRUE)
441     { 
442       for(l=1;l<=ex->nobs;l++)
443         {
444           if(globs->gnuindex <= globs->ngnu)
445             {
446               mind=2;
447               ofstream gnuout;
448               gnuout.open("gnuout.dat");
449               ymax=ex->yPred[1][l];
450               ymin=ex->yPred[1][l];           
451               for(j=1;j<=ex->nMeasure;j++)
452                 {
453                   gnuout << ex->xMeasure[j] << "\t" << ex->yPred[j][l] << "\t" << ex->yMeasure[j][l] << endl;
454                   if(mesh[mind] <= ex->xMeasure[j])
455                     {
456                       observation (globs,ex,mesh[mind],ex->yComp[mind],ys,ex->par,NULL,NULL);
457                       gnuout << mesh[mind] << "\t" << ys[l] << endl << endl;
458                       observation (globs,ex,mesh[mind],ex->yTry[mind],ys,ex->par,NULL,NULL);
459                       gnuout << mesh[mind] << "\t" << ys[l] << endl;
460                       mind++;
461                     }
462                   //determine y-range
463                   if(ymax <= ex->yPred[j][l])
464                     ymax=ex->yPred[j][l];
465                   if(ymin >= ex->yPred[j][l])
466                     ymin=ex->yPred[j][l];
467                   if(ymax <= ex->yMeasure[j][l])
468                     ymax=ex->yMeasure[j][l];
469                   if(ymin >= ex->yMeasure[j][l])
470                     ymin=ex->yMeasure[j][l];
471                 }
472               gnuout.flush();
473               gnuout.close();
474               
475               fprintf(globs->gnuFp[globs->gnuindex],"reset\n");
476               fprintf(globs->gnuFp[globs->gnuindex],"set yrange[%f:%f]\n",ymin-0.01*ymin,ymax+0.01*ymax);
477               fprintf(globs->gnuFp[globs->gnuindex],"set xrange[%f:%f]\n",ex->xMeasure[1],ex->xMeasure[ex->nMeasure]);        
478               fflush(globs->gnuFp[globs->gnuindex]);
479               fprintf(globs->gnuFp[globs->gnuindex],"plot \"gnuout.dat\" title \"\"w l 3,\"gnuout.dat\" u 1:3 title \"\" 1 \n");
480               fflush(globs->gnuFp[globs->gnuindex]);
481               //DELAY
482               for(long dd=1;dd<=1000000;dd++)
483                1+1;
484             }
485           sprintf(name,"Gnuout_Exp%d_Obs%d.dat",expNr,l);
486           outout.open(name);
487           
488           globs->gnuindex++;
489           mind=2;
490           for(j=1;j<=ex->nMeasure;j++)
491             {
492               
493               outout << ex->xMeasure[j] << "\t" << ex->yPred[j][l] << "\t" << ex->yMeasure[j][l] << endl;
494               if(mesh[mind] <= ex->xMeasure[j])
495                 {
496                   observation (globs,ex,mesh[mind],ex->yComp[mind],ys,ex->par,NULL,NULL);
497                   outout << mesh[mind] << "\t" << ys[l] << endl << endl;
498                   observation (globs,ex,mesh[mind],ex->yTry[mind],ys,ex->par,NULL,NULL);
499                   outout << mesh[mind] << "\t" << ys[l] << endl;
500                   mind++;
501                 }
502             }
503           outout.flush();
504           outout.close();
505           for(long dd=1;dd<=1000000;dd++)
506             1+1; 
507         }
508     }
509   
510   if (doDerivs) {
511     free_d3tensor(dTabdp,1,tableLen,1,nvar,1,globs->npar);
512     free_d3tensor(dTabds,1,tableLen,1,nvar,1,nvar);
513   }
514   free_dmatrix(yTab,1,tableLen,1,nvar);
515   free_dvector(xTab,1,tableLen);
516   free_dvector(ys,1,nvar);
517 }
\end{verbatim}\normalsize 


\index{globOpt.cc@{glob\-Opt.cc}!solvLin@{solvLin}}
\index{solvLin@{solvLin}!globOpt.cc@{glob\-Opt.cc}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void solv\-Lin ({\bf Glob} $\ast$ {\em globs}, {\bf Glob\-Exp} $\ast$ {\em ex}, int {\em compute\-Covar})}\label{globOpt_8cc_ff7b6c2bcde7c9861871a4f9df066a07}




Definition at line 313 of file solv\-Lin.cc.

\footnotesize\begin{verbatim}314 {
315   
316   long i,j,k,l,xind=0,yind=0,nL;
317   long nvarFit=0;  // # der zu fittenden Anfangswerte
318   long nLpara=0;   // # lokale Parameter
319   long nparL=0;    // nLpara*nrExp
320   long npar=globs->npar;
321   long nvar=ex[1].nvar;
322   long nrExp=globs->nrExp;
323   long nparG=0;
324   long fitDim=0;
325   long aDim=0,eDim=0,gDim=0;
326 
327   //big system (condensed)
328   double **Ma,*Ra;
329   double **Me,*Re;
330   double **Mg,*Rg;
331 
332   //solution
333   double *dX;
334   //condense experiments
335   condense(globs,ex);
336 
337   //determine dimension of big system
338   for(i=1;i<=nvar;i++)
339     {
340       if(globs->y0fix[i]!=FALSE)
341         nvarFit++;
342     }
343   nvarFit*=nrExp;
344   for(i=1;i<=npar;i++)
345     {
346       if(globs->doP[i]=='L')
347         nparL++;
348       else if(globs->doP[i]!=FALSE)
349         nparG++;
350     }
351   nLpara=nparL;
352   nparL*=nrExp;
353   fitDim=nvarFit+nparL+nparG;
354   for(i=1;i<=nrExp;i++)
355     {
356       aDim+=ex[i].nMeasure*ex[i].nobs;
357       eDim+=ex[i].me;
358       gDim+=ex[i].mg;
359     }
360   if(fitDim==0)
361     {
362       cerr << "Nothing to fit.\n";
363       throw 1;
364     }
365 #ifdef PRINTDIMENSION
366   //print dimension of bigsys;
367   *dbg << "Dimension of Big-System\n";
368   *dbg << "-----------------------\n";
369   *dbg << "Least-squares:\n";
370   *dbg << "#Rows : " << aDim  << "  #Columns : " << fitDim << endl;
371   *dbg << "Equality constraints:\n";
372   *dbg << "#Rows : " << eDim  << "  #Columns : " << fitDim << endl;  
373   *dbg << "Inequality constraints:\n";
374   *dbg << "#Rows : " << gDim  << "  #Columns : " << fitDim;  
375   *dbg << "\n\n";
376   dbg->flush();
377 #endif
378 
379 
380   long aDimold=aDim;
381   long eDimold=eDim;
382   long fitDimold=fitDim;
383 
384   // Beginn Local_Parameter_Constraints
385   if(globs->faktorLexist)
386   {
387         // Erweiterung der Dimensionen um nLpara*nExp
388         aDim=aDim+nparL;
389         eDim=eDim+nparL;
390         fitDim=fitDim+nparL;
391   }
392   // Ende Local_Parameter_Constraints
393   
394   //allocate memory
395   Ma=dmatrix(0,aDim,1,fitDim);
396   Me=dmatrix(0,eDim,1,fitDim);
397   Mg=dmatrix(0,gDim,1,fitDim);
398   Ra=dvector(0,aDim);
399   Re=dvector(0,eDim);
400   Rg=dvector(0,gDim);
401 
402   //initialise 
403   for(i=1;i<=aDim;i++)
404     {
405       Ra[i]=0.;
406       for(j=1;j<=fitDim;j++)
407         Ma[i][j]=0.;
408     }
409    for(i=1;i<=eDim;i++)
410     {
411       Re[i]=0.;
412       for(j=1;j<=fitDim;j++)
413         Me[i][j]=0.;
414     } 
415    for(i=1;i<=gDim;i++)
416      {
417       Rg[i]=0.;
418       for(j=1;j<=fitDim;j++)
419         Mg[i][j]=0.;
420     } 
421 
422   //least-squares
423   for(i=1;i<=nrExp;i++)
424     {
425       for(k=1;k<=ex[i].nMeasure*ex[i].nobs;k++)    
426         Ra[yind+k]=-ex[i].ua[k];
427       //initial values
428       for(j=1;j<=nvar;j++)
429         {
430           if(globs->y0fix[j]!=FALSE)
431             {
432               xind++;
433               for(k=1;k<=ex[i].nMeasure*ex[i].nobs;k++)    
434                 Ma[yind+k][xind]=ex[i].Ea[k][j];
435             }
436           
437         }
438       //parameters
439       nL=0;
440       for(j=1;j<=npar;j++)
441         {
442           if(globs->doP[j]=='L')
443             {
444               xind++;
445               for(k=1;k<=ex[i].nMeasure*ex[i].nobs;k++)
446                 Ma[yind+k][xind]=ex[i].Pa[k][j];
447             }
448           else if(globs->doP[j]!=FALSE)
449             {
450               nL++;
451               for(k=1;k<=ex[i].nMeasure*ex[i].nobs;k++)
452                 Ma[yind+k][nvarFit+nparL+nL]=ex[i].Pa[k][j];
453             }
454         }
455       yind=yind+(ex[i].nMeasure*ex[i].nobs);
456     }//end loop over experiments
457   //-------------> end lest squares
458   
459   //equality constraints
460   yind=0;
461   xind=0;
462   for(i=1;i<=nrExp;i++)
463     {
464       for(k=1;k<=ex[i].me;k++)    
465         Re[yind+k]=-ex[i].ue[k];
466       //initial values
467       for(j=1;j<=nvar;j++)
468         {
469           if(globs->y0fix[j]!=FALSE)
470             {
471               xind++;
472               for(k=1;k<=ex[i].me;k++)    
473                 Me[yind+k][xind]=ex[i].Ee[k][xind];
474             }
475         }
476       //parameters
477       nL=0;
478       for(j=1;j<=npar;j++)
479         {
480           if(globs->doP[j]=='L')
481             {
482               xind++;
483               for(k=1;k<=ex[i].me;k++)
484                 Me[yind+k][xind]=ex[i].Pe[k][j];
485             }
486           else if(globs->doP[j]!=FALSE)
487             {
488               nL++;
489               for(k=1;k<=ex[i].me;k++)
490                 Me[yind+k][nvarFit+nparL+nL]=ex[i].Pe[k][j];
491             }
492         }
493       yind+=ex[i].me;
494     }//end loop over experiments
495   //-------------> end equality  constraints
496 
497   //inequality constraints
498   yind=0;
499   xind=0;
500   for(i=1;i<=nrExp;i++)
501     {
502       for(k=1;k<=ex[i].mg;k++)    
503         Rg[yind+k]=-ex[i].ug[k];
504       //initial values
505       for(j=1;j<=nvar;j++)
506         {
507           if(globs->y0fix[j]!=FALSE)
508             {
509               xind++;
510               for(k=1;k<=ex[i].mg;k++)  
511                 Mg[yind+k][xind]=ex[i].Eg[k][xind];
512             }
513         }
514       //parameters
515       nL=0;
516       for(j=1;j<=npar;j++)
517         {
518           if(globs->doP[j]=='L')
519             {
520               xind++;
521               for(k=1;k<=ex[i].mg;k++)
522                 Mg[yind+k][xind]=ex[i].Pg[k][j];
523             }
524           else if(globs->doP[j]!=FALSE)
525             {
526               nL++;
527               for(k=1;k<=ex[i].mg;k++)
528                 Mg[yind+k][nvarFit+nparL+nL]=ex[i].Pg[k][j];
529             }
530         }
531       yind+=ex[i].mg;
532     }//end loop over experiments
533   //-------------> end equality  constraints
534   
535   //Big System Ready to Solve
536   //-------------------------
537   //
538   //  Ma*dX  ~  Ra
539   //  Me*dX  =  Re
540   //  Mg*dX >=  Rg
541   //
542   //-------------------------
543   
544   //****************************************************************************
545   // Beginn Local_Parameter_Constraints
546   // Erweiterung der Systems auf Local_Parameter_Constraints:
547   //
548   // pLmean und pLsig bestimmen
549   if(globs->faktorLexist)
550   {
551         double *pLmean, *pLsig;
552         int index;
553         int index_local_parameter;
554         pLmean=dvector(1,nLpara);
555         pLsig=dvector(1,nLpara);
556   
557 //      for(i=1;i<=nLpara;i++)
558 //      {
559 //         cerr<<"i="<< i<<" faktorL[i]="<<globs->faktorL[i]<<endl;
560 //         if(globs->faktorL[i]<0)
561 //         {
562 //            //i;
563 //            break;
564 //         }
565 //      }
566 //      cerr<<"i="<< i<<" faktorL[i]="<<globs->faktorL[i]<<endl;
567 //      if(i<=nLpara)
568 //      {
569 //         cerr<<"number of local parameter constraints too small"<<endl;
570 //         throw(1);
571 //      }
572         for(i=1;i<=nLpara;i++)
573         {
574                 pLmean[i]=0;
575                 index=0;
576                 index_local_parameter=0;
577                 while(index_local_parameter!=i)
578                 {
579                         index++;
580 //                      cerr<<"doP[index]="<<globs->doP[index]<<" index="<<index<<" i="<<i<<endl;
581                         if(globs->doP[index]=='L')
582                         {
583                                 index_local_parameter++;
584 //                              cerr<<"index="<<index<<" i="<<i<<endl;
585                         }
586                         
587                 }               
588                 for(j=1;j<=nrExp;j++)
589                 {
590                         pLmean[i]=pLmean[i]+ex[j].par[index]; 
591 //                      cerr<<"ex[j].par[index]="<<ex[j].par[index]<<endl;
592                 }
593                 pLmean[i]=pLmean[i]/double(nrExp);
594           //    cerr<<"pLmean["<<i<<"]="<<pLmean[i]<<" globs->faktorL["<<i<<"]"<<globs->faktorL[i]<<endl;
595         }
596         // Berechnung pLsig
597         for(i=1;i<=nLpara;i++)
598         {
599                 pLsig[i]=(globs->faktorL[i]*pLmean[i]-pLmean[i])/(1+globs->faktorL[i]);
600                 if(pLsig[i]<0)
601                 {
602                 cerr<<"ERROR - Negative varianz bei den Lokalen Parameter Constraints..."<<endl;
603                 }
604         }       
605         // Ra,Re
606         k=1;
607         for(i=1;i<=nrExp;i++)
608         {
609                 for(j=1;j<=nLpara;j++)
610                 {       
611                         index=0;
612                         index_local_parameter=0;
613                         while(index_local_parameter!=j)
614                         {
615                                 index++;
616                                 if(globs->doP[index]=='L')
617                                 {
618                                         index_local_parameter++;
619                                 }
620                         
621                         }  
622                         Ra[aDimold+k]=(ex[i].par[index]-pLmean[j])/pLsig[j];
623                         Re[eDimold+k]=0;
624                         double pLsig_real=0;
625                         for(int z=1;z<=nrExp;z++)
626                         {
627                                 pLsig_real=pLsig_real+(ex[z].par[index]-pLmean[j])*(ex[z].par[index]-pLmean[j]);
628                         }
629                         pLsig_real=sqrt(pLsig_real/nrExp);
630                         //*dbg<<"ex["<<i<<"].par["<<index<<"]="<<ex[i].par[index]<<" pLmean["<<j<<"]="<<pLmean[j]<<" pLsig["<<j<<"]="<<pLsig[j]<<" pLsig_real="<<pLsig_real<<endl;
631                         // Ma
632                         for(int l=1;l<=nrExp;l++)
633                         {
634                                 Ma[aDimold+(i-1)*nLpara+j][fitDimold+(l-1)*nLpara+j]=1/(pLsig[j]*nrExp);
635                                 if(i == l)
636                                 {
637                                         Ma[aDimold+(i-1)*nLpara+j][fitDimold+(l-1)*nLpara+j]=Ma[aDimold+(i-1)*nLpara+j][fitDimold+(l-1)*nLpara+j]-1/pLsig[j];
638                                 }
639                         }
640                         k++;
641                 }
642         }
643         // Me
644         for(i=eDimold+1;i<=eDim;i++)
645         {
646                 for(j=nvarFit+1;j<=fitDim;j++)   
647                 {
648                         if(j==fitDimold+i)
649                         {
650                                 Me[i][j]=Me[i][j]+1;
651                         }
652                         if(j==nvarFit+i)
653                         {
654                                 Me[i][j]=Me[i][j]-1;
655                         }
656                 }
657         }
658   }
659   // Ende Local_Parameter_Constraints
660   //****************************************************************************
661   
662   //regularising
663   if(globs->reg==TRUE)
664     {
665       double *diag,**V,**MMa;
666       double cond,maxx;
667       double reg=0.;
668 
669       V=dmatrix(1,fitDim,1,fitDim);
670       MMa=dmatrix(1,aDim,1,fitDim);
671       diag=dvector(1,fitDim);
672 
673        for(i=1;i<=aDim;i++)
674         {
675           for(j=1;j<=fitDim;j++)
676             {
677               MMa[i][j]=Ma[i][j];
678             }     
679         }
680       
681       //SVD
682       svdcmp(MMa,aDim,fitDim,diag,V);
683       
684       //determine condition number
685       *dbg << "\ncondition number : ";
686       maxx=diag[1];
687       cond=diag[1];
688       for(i=1;i<=fitDim;i++)
689         {
690           if(diag[i]>maxx)
691             maxx=diag[i];
692           if(diag[i]<cond)
693             cond=diag[i];
694         }
695 
696       //Is the matrix approximately singular?
697       for(i=1;i<=fitDim;i++)
698         {
699           if(fabs(diag[i]/maxx)<=globs->epsilon)
700             {
701               diag[i]=0.;
702               reg=globs->lambda*maxx;
703             }
704         }
705       
706       cond*=1./maxx;
707       *dbg << cond << endl;
708       globs->cond=cond;
709       
710       //writing regularised system back
711       for(i=1;i<=aDim;i++)
712         {
713           for(j=1;j<=fitDim;j++)
714             {
715               Ma[i][j]=0.;
716               for(k=1;k<=fitDim;k++)
717                 {
718                   Ma[i][j]+=MMa[i][k]*diag[k]*V[j][k];
719                 }
720               if(i <=fitDim)
721                 {
722                   if(diag[i]==0.)
723                     Ma[i][j]+=reg*V[j][i];
724                 }
725             }
726         }
727       if(reg!=0.)
728         {
729           *dbg << "regularisation active, linear dependency of parameters:\n";
730           for(i=1;i<=fitDim;i++)
731               {
732                 if(diag[i]==0.)
733                   *dbg << "line " << i << ": ";
734                 for(j=1;j<=fitDim;j++)
735                   {
736                     if(diag[i]==0.)
737                       *dbg << V[j][i] << " ";
738                   }
739                 if(diag[i]==0.)
740                   *dbg << endl;
741               }
742         }
743 
744       free_dmatrix(MMa,1,aDim,1,fitDim);
745       free_dmatrix(V,1,fitDim,1,fitDim);
746       free_dvector(diag,1,fitDim);
747     }//end if(globs->reg==TRUE)
748 
749 #ifdef PRINTBIGSYS
750   *dbg << "\nLeast-squares :\n";
751    for(i=1;i<=aDim;i++)
752     {
753       for(j=1;j<=fitDim;j++)
754         {
755           *dbg << Ma[i][j] << " ";
756         }
757       *dbg << "| " << Ra[i] << endl;
758     }  
759    *dbg << "\nEquality constraints :\n";
760    for(i=1;i<=eDim;i++)
761     {
762       for(j=1;j<=fitDim;j++)
763         {
764           *dbg << Me[i][j] << " ";
765         }
766       *dbg << "| " << Re[i] << endl;
767     }
768    *dbg << "\nInquality constraints :\n";
769    for(i=1;i<=gDim;i++)
770     {
771       for(j=1;j<=fitDim;j++)
772         {
773           *dbg << Mg[i][j] << " ";
774         }
775       *dbg << "| " << Rg[i] << endl;
776     }
777    dbg->flush();
778   #endif
779   //allocate solution vector
780   dX=(double*)malloc((fitDim+10)*sizeof(double));
781   //allocate covariance matrix
782   globs->fitdim=fitDim;
783   if(globs->covar==NULL)
784     globs->covar=dmatrix(1,fitDim,1,fitDim);
785 
786   if(globs->minimiser==1)
787     {
788       // ###############
789       // #     LSEI    #
790       // ###############
791       
792       //allocation/initialisation for LSEI
793       double *w;
794       double *ws;
795       double *prgopt;
796       double rnorme,rnorml;
797       long mdw=aDim+eDim+gDim;
798       long mode;
799       long ipstor=mdw+npar+2*fitDim+2;
800       long wsstor=3*(mdw+npar)+(mdw+npar+2)*(fitDim+8)+fitDim+npar;
801       long *ip;
802       
803       w=(double*)malloc(((fitDim+1)*mdw)*sizeof(double));
804       ws=(double*)malloc((wsstor+1)*sizeof(double));
805       ip=(long*)malloc((ipstor+10)*sizeof(long));
806       prgopt=(double*)malloc(30*sizeof(double));
807       
808       xind=0;
809       yind=0;
810       
811       for(i=1;i<=fitDim;i++)
812         {
813           for(j=1;j<=eDim;j++)
814             {
815               w[xind*mdw+yind]=Me[j][i];
816               yind++;
817             }
818           for(j=1;j<=aDim;j++)
819             {
820               w[xind*mdw+yind]=Ma[j][i];
821               yind++;
822             }
823           for(j=1;j<=gDim;j++)
824             {
825               w[xind*mdw+yind]=Mg[j][i];
826               yind++;
827             } 
828           yind=0;
829           xind++;
830         }
831  
832       for(j=1;j<=eDim;j++)
833         {
834           w[(fitDim)*mdw+yind]=Re[j];
835           yind++;
836         }
837       for(j=1;j<=aDim;j++)
838         {
839           w[(fitDim)*mdw+yind]=Ra[j];
840           yind++;
841         }
842       for(j=1;j<=gDim;j++)
843         {
844           w[(fitDim)*mdw+yind]=Rg[j];
845           yind++;
846         }
847       
848       ip[0]=wsstor;
849       ip[1]=ipstor;
850       
851       if(computeCovar==TRUE)
852         {
853           prgopt[0]=4.0; 
854           prgopt[1]=1.0; 
855           prgopt[2]=1.0;
856           prgopt[3]=7.0;
857           prgopt[4]=10.0;
858           prgopt[5]=1.0;
859         }
860       else
861         {
862           prgopt[0]=4.0; 
863           prgopt[1]=0.0; 
864           prgopt[2]=1.0;
865           prgopt[3]=7.0;
866           prgopt[4]=10.0;
867           prgopt[5]=0.0;
868         }
869       prgopt[6]=1.0;
870       
871       //call LSEI
872       lsei_(w,mdw,eDim,aDim,gDim,fitDim,prgopt,dX,&rnorme,&rnorml,&mode,ws,ip);
873       
874       if(mode>=4)
875         {
876           cerr << "Minimisation (LSEI) failed.\n";
877           throw 1;
878         }
879       
880       if(computeCovar==TRUE)
881         {
882           for (i=1; i<=fitDim; ++i)
883             {
884               for (j=1;j<=fitDim;++j)
885                 globs->covar[i][j] = w[(j-1)*mdw+i-1];
886             } 
887         }
888       
889       free(w);
890       free(ws);
891       free(ip);
892       free(prgopt);
893       
894       // #######  END OF LSEI ######
895     }
896   else if(globs->minimiser==2)
897     {
898       //to solve ----->
899       //-------------------------
900       //
901       //  Ma*dX  ~  Ra
902       //  Me*dX  =  Re
903       //  Mg*dX >=  Rg
904       //
905       //-------------------------
906 
907 
908       //initialisation of  E04NCF
909       long NCLIN=eDim+gDim;
910       double *C=(double*)malloc(((eDim+gDim+1)*fitDim)*sizeof(double));
911       double *BL=(double*)malloc((fitDim+eDim+gDim+1)*sizeof(double));
912       double *BU=(double*)malloc((fitDim+eDim+gDim+1)*sizeof(double));
913       double *CVEC=(double*)malloc((fitDim+1)*sizeof(double));
914       long *ISTATE=(long*)malloc((fitDim+eDim+gDim+1)*sizeof(long));
915       long *KX=(long*)malloc((fitDim+1)*sizeof(long));
916       double *X=(double*)malloc((1+fitDim)*sizeof(double));
917       double *A=(double*)malloc((1+fitDim*aDim)*sizeof(double));
918       double *B=(double*)malloc((1+aDim)*sizeof(double));
919       long ITER;
920       double OBJ;
921       double *CLAMDA=(double*)malloc((1+fitDim+eDim+gDim)*sizeof(double));
922       long *IWORK=(long*)malloc((1+fitDim)*sizeof(long));
923       long LWORK=2*fitDim*fitDim+9*fitDim+6*(eDim+gDim);
924       double *WORK=(double*)malloc((1+LWORK)*sizeof(double));
925       long IFAIL=-1;
926       double **CTMP=dmatrix(1,1+eDim+gDim,1,1+fitDim);
927 
928       //right-hand side
929       for(i=1;i<=aDim;i++)
930         B[i-1]=Ra[i];
931       
932       //bounds
933       for(i=1;i<=fitDim;i++)
934         {
935           BL[i-1]=-1e25;
936           BU[i-1]=1e25;
937           X[i-1]=0.;  //initialisation of X
938         }
939       for(i=fitDim+1;i<=fitDim+eDim;i++)
940         {
941           BL[i-1]=Re[i-fitDim];
942           BU[i-1]=Re[i-fitDim];
943         }
944       for(i=fitDim+eDim+1;i<=fitDim+eDim+gDim;i++)
945         {
946           BL[i-1]=Rg[i-fitDim-eDim];
947           BU[i-1]=1e25;
948         }
949       
950       for(i=1;i<=fitDim;i++)
951         {
952           for(j=1;j<=eDim+gDim;j++)
953             {
954               if(j<=eDim)
955                 CTMP[j][i]=Me[j][i];
956               else
957                 CTMP[j][i]=Mg[j-eDim][i];
958             }
959         }
960       
961       for(i=1;i<=fitDim+eDim+gDim;i++)
962       {
963         ISTATE[i]=0;
964       }
965       
966       cmat2fvec(Ma,aDim,fitDim,A);
967       cmat2fvec(CTMP,eDim+gDim,fitDim,C);
968       
969       setopte04ncf_();
970       e04ncf_(aDim,fitDim,NCLIN,NCLIN,aDim,C,BL,BU,CVEC,ISTATE,
971               KX,X,A,B,ITER,OBJ,CLAMDA,IWORK,fitDim,WORK,LWORK,IFAIL);
972       for(i=0;i< fitDim;i++)
973       {
974         dX[i]=X[i];
975       }
976       
977       //free memory
978       free(C);
979       free(BL);
980       free(BU);
981       free(CVEC);
982       free(ISTATE);
983       free(KX);
984       free(X);
985       free(A);
986       free(B);
987       free(CLAMDA);
988       free(IWORK);
989       free(WORK);
990       free_dmatrix(CTMP,1,eDim+gDim,1,fitDim);
991     }
992 
993   //decondense experiments
994   decondense(globs,ex,dX);
995 
996 #ifdef PRINTSTEP
997   for(i=1;i<=nrExp;i++)
998     {
999       *dbg << "\nExperiment #" << i << ":\n\n";
1000       for(k=1;k<=ex[i].nPoints-1;k++)
1001         {
1002           *dbg << "dS(msP=" << k << ") = ";
1003           for(j=1;j<=nvar;j++)
1004             *dbg << ex[i].dS[k][j] << " ";
1005           *dbg << endl;
1006         }
1007       *dbg << "dP = ";
1008       for(j=1;j<=npar;j++)
1009         *dbg << ex[i].dP[j] << " ";
1010     }
1011   *dbg << endl;
1012   dbg->flush();
1013 #endif
1014   
1015 
1016   //free memory
1017   free_dmatrix(Ma,0,aDim,1,fitDim);
1018   free_dmatrix(Me,0,eDim,1,fitDim);
1019   free_dmatrix(Mg,0,gDim,1,fitDim);
1020   free_dvector(Ra,0,aDim);
1021   free_dvector(Re,0,eDim);
1022   free_dvector(Rg,0,gDim);
1023 
1024   dX[0];
1025   free(dX);
1026 }
\end{verbatim}\normalsize 




\subsection{Variable Documentation}
\index{globOpt.cc@{glob\-Opt.cc}!exPtr@{exPtr}}
\index{exPtr@{exPtr}!globOpt.cc@{glob\-Opt.cc}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf Glob\-Exp}$\ast$ {\bf ex\-Ptr}}\label{globOpt_8cc_b2fc1ecb87c326a22347d9c2daaaa809}




Definition at line 30 of file glob\-Opt.cc.

Referenced by fitness(), and glob\-Opt().\index{globOpt.cc@{glob\-Opt.cc}!globsPtr@{globsPtr}}
\index{globsPtr@{globsPtr}!globOpt.cc@{glob\-Opt.cc}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf Glob}$\ast$ {\bf globs\-Ptr}}\label{globOpt_8cc_6fcdd60b6e9608cc71e75fc85d1ce6df}




Definition at line 29 of file glob\-Opt.cc.

Referenced by fitness(), and glob\-Opt().