\section{Stop\-Eval  Class Reference}
\label{class_StopEval}\index{StopEval@{Stop\-Eval}}
{\tt \#include $<$jd\_\-stop\_\-eval.h$>$}

Inheritance diagram for Stop\-Eval\begin{figure}[H]
\begin{center}
\leavevmode
\includegraphics[width=56pt]{class_StopEval_inherit_graph}
\end{center}
\end{figure}
Collaboration diagram for Stop\-Eval:\begin{figure}[H]
\begin{center}
\leavevmode
\includegraphics[width=419pt]{class_StopEval_coll_graph}
\end{center}
\end{figure}
\subsection*{Public Methods}
\begin{CompactItemize}
\item 
{\bf Stop\-Eval} (const Stop\-Eval \&ca)
\item 
{\bf Stop\-Eval} ({\bf Constraint\-Manager} \&{\bf CM})
\item 
{\bf $\sim$Stop\-Eval} ()
\item 
int {\bf run} ()
\item 
int {\bf check\_\-stress\_\-max\_\-tot} (double, double)
\item 
int {\bf check\_\-low\_\-error} (double, double)
\item 
void {\bf cycle\_\-header} (void)
\item 
void {\bf writebest} (void)
\end{CompactItemize}
\subsection*{Static Public Attributes}
\begin{CompactItemize}
\item 
bool {\bf Enable} = true
\item 
bool {\bf Solve\-Only} = false
\item 
bool {\bf Rtp} = false
\begin{CompactList}\small\item\em Real time plotting output -- single double outputs for plotting.\item\end{CompactList}\item 
bool {\bf Quiet} = false
\begin{CompactList}\small\item\em run-time ajdustable flag to stop default output.\item\end{CompactList}\item 
bool {\bf Verbose\-On} = false
\begin{CompactList}\small\item\em run-time ajdustable flag to provide verbose output.\item\end{CompactList}\end{CompactItemize}
\subsection*{Private Attributes}
\begin{CompactItemize}
\item 
{\bf Anim\-Frame}$\ast$ {\bf AF}
\item 
ofstream$\ast$ {\bf of}
\item 
{\bf j\-Vector}$\ast$ {\bf my\-Points}
\item 
double {\bf Low\-Err}
\item 
double {\bf Best\-Ave\-Err}
\item 
double {\bf Best\-Max\-Err}
\end{CompactItemize}
\subsection*{Static Private Attributes}
\begin{CompactItemize}
\item 
int {\bf Look\-Back} = 50
\begin{CompactList}\small\item\em number of calls to Stop\-Eval to remember.\item\end{CompactList}\item 
{\bf DLList}$<$double$>$ {\bf Total\-Stress\-List}
\item 
double {\bf Min\-Total\-Stress}
\item 
double {\bf Minof\-Max\-Stress}
\begin{CompactList}\small\item\em the overall min of the max on each list of stress calls on an iteration.\item\end{CompactList}\item 
double {\bf Minof\-Max\-Assoc\-Total}
\item 
double {\bf Min\-Look\-Back\-Stress}
\item 
double {\bf Max\-Look\-Back\-Stress}
\item 
double {\bf Mean\-Look\-Back\-Total\-Stress}
\item 
double {\bf Sum\-XX}
\begin{CompactList}\small\item\em Variables for linear regression these are maintained over the lookback calls to {\bf Stop\-Eval::run}() {\rm (p.\,\pageref{class_StopEval_a3})}.\item\end{CompactList}\item 
double {\bf Sum\-XY}
\item 
double {\bf Sum\-X}
\item 
double {\bf Sum\-Y}
\item 
double {\bf Sum\-YY}
\item 
double {\bf Variance}
\item 
int {\bf Num\-Calls} = 0
\item 
int {\bf Num\-Lpr\-Adj} = 0
\item 
int {\bf Num\-Lpr\-Lim} = 10
\item 
int {\bf Last\-Lpr\-Adj} = 0
\item 
int {\bf Best\-Iter} = 0
\item 
double {\bf Look\-Back\-Slope}
\item 
double {\bf Look\-Back\-D}
\end{CompactItemize}


\subsection{Detailed Description}
//////////////////////////////////////////////////////////

File: {\bf jd\_\-stop\_\-eval.h}

Created by: Jon Dugan

Evaluates the molecule state to determine iteration exit conditions.

////////////////////////////////////////////////////////// 



Definition at line 28 of file jd\_\-stop\_\-eval.h.

\subsection{Constructor \& Destructor Documentation}
\index{StopEval@{Stop\-Eval}!StopEval@{StopEval}}
\index{StopEval@{StopEval}!StopEval@{Stop\-Eval}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}Stop\-Eval::Stop\-Eval (const Stop\-Eval \& {\em se})}\label{class_StopEval_a0}




Definition at line 35 of file jd\_\-stop\_\-eval.C.\footnotesize\begin{verbatim}00036   : SatisfyMolecule(*(se.CM))
00037 {
00038   TotalStressList = se.TotalStressList;
00039   DIE(" Copy constructor for stop eval called ");
00040   
00041 \end{verbatim}\normalsize 
\index{StopEval@{Stop\-Eval}!StopEval@{StopEval}}
\index{StopEval@{StopEval}!StopEval@{Stop\-Eval}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}Stop\-Eval::Stop\-Eval ({\bf Constraint\-Manager} \& {\em cm\_\-in})}\label{class_StopEval_a1}




Definition at line 43 of file jd\_\-stop\_\-eval.C.\footnotesize\begin{verbatim}00044   : SatisfyMolecule(cm_in)
00045 {
00046 
00047   AF = new AnimFrame(cm_in);
00048   of = 0;
00049   myPoints = new jVector [CM->numAtoms()];
00050   LowErr = INF;
00051   BestAveErr= INF;
00052   BestMaxErr = INF;
00053 \end{verbatim}\normalsize 
\index{StopEval@{Stop\-Eval}!~StopEval@{$\sim$StopEval}}
\index{~StopEval@{$\sim$StopEval}!StopEval@{Stop\-Eval}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}Stop\-Eval::$\sim$Stop\-Eval ()}\label{class_StopEval_a2}




Definition at line 55 of file jd\_\-stop\_\-eval.C.\footnotesize\begin{verbatim}00056 { 
00057   delete AF; AF = 0;
00058   if (of) delete of; of = 0;
00059   delete [] myPoints;
00060 \end{verbatim}\normalsize 


\subsection{Member Function Documentation}
\index{StopEval@{Stop\-Eval}!check_low_error@{check\_\-low\_\-error}}
\index{check_low_error@{check\_\-low\_\-error}!StopEval@{Stop\-Eval}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int Stop\-Eval::check\_\-low\_\-error (double {\em max\_\-err}, double {\em ave\_\-err})}\label{class_StopEval_a5}




Definition at line 62 of file jd\_\-stop\_\-eval.C.

Referenced by Atom\-Buildup::run().\footnotesize\begin{verbatim}00062                                                             {
00063   double err = 0.1 * ave_err + max_err;
00064   if (err < LowErr) {
00065     LowErr = err;
00066     BestIter = NumCalls;
00067     for (int i= 0; i < CM->numAtoms(); i ++){
00068       myPoints[i] = CM->getMolecule().getPosition(i); // save best positions
00069     }
00070     BestAveErr = ave_err;
00071     BestMaxErr = max_err;
00072     return 1;
00073   }
00074 \end{verbatim}\normalsize 
\index{StopEval@{Stop\-Eval}!check_stress_max_tot@{check\_\-stress\_\-max\_\-tot}}
\index{check_stress_max_tot@{check\_\-stress\_\-max\_\-tot}!StopEval@{Stop\-Eval}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int Stop\-Eval::check\_\-stress\_\-max\_\-tot (double {\em max\_\-test}, double {\em total\_\-test})}\label{class_StopEval_a4}




Definition at line 77 of file jd\_\-stop\_\-eval.C.

Referenced by Atom\-Buildup::run().\footnotesize\begin{verbatim}00078 {  // if either passes, stop
00079   
00080   double max = -1*INF;
00081   double tot = 0;
00082   jVector currStressList = CM->getStressList();
00083 
00084   for (int i =0; i <  currStressList.Length(); i++){
00085     if (max < currStressList[i]) max = currStressList[i];
00086     tot += currStressList[i];
00087   }
00088 \end{verbatim}\normalsize 
\index{StopEval@{Stop\-Eval}!cycle_header@{cycle\_\-header}}
\index{cycle_header@{cycle\_\-header}!StopEval@{Stop\-Eval}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void Stop\-Eval::cycle\_\-header (void)}\label{class_StopEval_a6}




Definition at line 101 of file jd\_\-stop\_\-eval.C.\footnotesize\begin{verbatim}00101                              {
00102   cerr << "\nCycle   Avg Err    Max Err  Tot Err  %pert  Mean Total       Slope  Variance" 
00103        << LookBack << "\n"
00104        << "-----   -------    -------  -------   ----  ----------       -----  -----------      "
00105        << endl;
00106   
00107 \end{verbatim}\normalsize 
\index{StopEval@{Stop\-Eval}!run@{run}}
\index{run@{run}!StopEval@{Stop\-Eval}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int Stop\-Eval::run (void)\hspace{0.3cm}{\tt  [virtual]}}\label{class_StopEval_a3}


Execute this process. Returns the exit status of the process (0 is success, non-zero is error). 

Reimplemented from {\bf Process} {\rm (p.\,\pageref{class_Process_a1})}.

Definition at line 109 of file jd\_\-stop\_\-eval.C.\footnotesize\begin{verbatim}00109                   {
00110 #ifdef JOB_VERBOSE
00111   cerr << "DIDJOB:\tStopEval::run()" << endl;
00112 #endif
00113   /*
00114 
00115 // 
00116 //   // initialize max, mean and total stress
00117 //   double maxStress = 0;
00118 //   double totalStress = 0;
00119 //   jVector currStressList = CM->getStressList();
00120 // 
00121 //   for (int i =0; i <  currStressList.Length(); i++){
00122 //     if (maxStress < currStressList[i]) maxStress = currStressList[i];
00123 //     totalStress += currStressList[i];
00124 //   }
00125 //   double meanStress = totalStress / currStressList.Length();
00126 // 
00127 //   double PercentLP = gwNumerics::NumLP/(double)(gwNumerics::NumLP + gwNumerics::NumNotLP);
00128 //   //  cerr << endl <<", " << gwNumerics::get_NumLP() << ", " << gwNumerics::get_NumNotLP();
00129 //   gwNumerics::reset_LP_Count(); //reset
00130 //   
00131 //   NumCalls++;
00132 //   
00133 //   if (!Quiet) {
00134 //     if (NumCalls == 1){cycle_header();}
00135 //     // ref see
00136 //     // http://gcc.gnu.org/onlinedocs/iostream_3.html
00137 //     //
00138 //     cerr << endl ;
00139 //     cerr << setw(4) << setiosflags(ios::left) << resetiosflags(ios::showpoint)
00140 //       << NumCalls ;
00141 // 
00142 //     cerr << resetiosflags(ios::left) << setiosflags(ios::showpoint)
00143 //       << setw(11)  << setprecision(6)  
00144 //       << meanStress 
00145 // 
00146 //       << setw(11)  << setprecision(6)  
00147 //       << maxStress 
00148 // 
00149 //       << setw(9)  << setprecision(6)  
00150 //       << totalStress 
00151 // 
00152 //       << " " 
00153 //       << setw(6) << setprecision(2) << resetiosflags(ios::showpoint) 
00154 //       << 100*PercentLP  
00155 //       << setprecision(4);
00156 //   }
00157 // 
00158 //   if (Rtp) {
00159 //     cout << totalStress << " " << endl;
00160 //   }
00161 //   
00162 //   // disable other stuff
00163 //   //  return 0;
00164 // 
00165 // 
00166 //   if (!Enable) return 0; //keep running
00167 //   if (NumCalls < 5) return 0; //never quit before first 5 calls
00168 //   // FIX  magix number == 5, make a static, a default val above and add to interface
00169 //   
00170 // #ifdef JOB_VERBOSE2
00171 //   cerr << "Value: \tStopEval::run() Max. Stress Atom Value(EvalCall) = " \
00172 //        << maxStress << " ("<<NumCalls<<")"<< endl;
00173 //   cerr << "Value: \tStopEval::run() Total Stress Value = "<< totalStress << endl;
00174 // #endif
00175 // 
00176 //   if (MinTotalStress > totalStress) MinTotalStress = totalStress;  // maintain mins
00177 //   if (MinofMaxStress > maxStress) {
00178 //     MinofMaxStress = maxStress ;
00179 //     MinofMaxAssocTotal = totalStress;
00180 //     BestIter = NumCalls;
00181 //     for (int i= 0; i < CM->numAtoms(); i ++){
00182 //       myPoints[i] = CM->getMolecule().getPosition(i); // save best positions
00183 //     }
00184 //   }
00185 //   
00186 //   TotalStressList.AddToFront(totalStress);
00187 //   
00188 //   int listlength = TotalStressList.Number();    //Must check this, may not eval every cycle.
00189 // 
00190 //   if (listlength == LookBack) { //set up linear regression vars once
00191 // 
00192 //     double tempX, tempY;
00193 //     for (int i = 0; i < listlength; i++){
00194 //       tempY = TotalStressList.Get(i);
00195 //       tempX = (double) NumCalls - i;
00196 //       MeanLookBackTotalStress += tempY/LookBack;
00197 //       SumXX += tempX*tempX;
00198 //       SumXY += tempX*tempY;
00199 //       SumX  += tempX;
00200 //       SumY  += tempY;
00201 //       SumYY += tempY*tempY;
00202 // 
00203 //       if (MinLookBackStress > tempY) MinLookBackStress = tempY;    // set init min/max over list
00204 //       else if (MaxLookBackStress < tempY) MaxLookBackStress = tempY;
00205 //       
00206 //     } // done lookback times
00207 //     
00208 //     // now set init variance
00209 //     Variance = ((LookBack*SumYY)-(SumY*SumY))/(LookBack*(LookBack-1));
00210 //     
00211 //   } // done once to setup lookback vars
00212 //   
00213 //   if (listlength > LookBack) { //ie listlength == lookback+1
00214 //     // calcualte slope and mean over lookback length.  Currently I
00215 //     // will be simply adding data to the end and removing it from the
00216 //     // back to maintain the required data for the linear regression.
00217 //     double OldYVal = TotalStressList.RemoveFromBack();
00218 //     double OldX = (double) (NumCalls - LookBack);
00219 //     double OldSumYY = SumYY;
00220 //     double OldSumY = SumY;
00221 //     if (VerboseOn){
00222 //       cerr <<"StopEval:\t" ;
00223 //       cerr << "Num: " << NumCalls <<"  \t";
00224 //       cerr << "Added val: " << totalStress <<"  \t";
00225 //       cerr << "Removed val: " << OldYVal << endl;
00226 //     }
00227 //     
00228 //     // handle min/max over list
00229 //     if (MinLookBackStress > totalStress) MinLookBackStress = totalStress;
00230 //     else if (MaxLookBackStress < totalStress) MaxLookBackStress = totalStress;
00231 //     else {      
00232 //       if (MinLookBackStress == OldYVal) {    
00233 //      DLList<double>::ConstIterator it;
00234 //      for(it = TotalStressList.GetConstIterator(); it; ++it)
00235 //        if (MinLookBackStress > (*it)) MinLookBackStress = (*it);     
00236 //       }
00237 //       else if (MaxLookBackStress == OldYVal){
00238 //      DLList<double>::ConstIterator it;
00239 //      for(it = TotalStressList.GetConstIterator(); it; ++it)    
00240 //        if (MaxLookBackStress < (*it)) MaxLookBackStress = (*it);             
00241 //       }
00242 //     }
00243 // 
00244 //     
00245 //     MeanLookBackTotalStress = MeanLookBackTotalStress + ((totalStress-OldYVal)/LookBack);
00246 // 
00247 //     SumXX = SumXX + ((NumCalls)*(NumCalls) - OldX*OldX); // actually NumCalls-OldX=LookBack-1
00248 //     SumXY = SumXY + (NumCalls*totalStress - OldX*OldYVal);
00249 //     SumX  = SumX + (double) LookBack;  
00250 //     SumY  = SumY + (totalStress - OldYVal);
00251 //     SumYY  = SumYY + (totalStress*totalStress-OldYVal*OldYVal);
00252 //     
00253 //     LookBackD = LookBack*SumXX - SumX*SumX;
00254 //     LookBackSlope = (LookBack* SumXY-SumX*SumY)/LookBackD;
00255 // 
00256 //     Variance += (((LookBack*SumYY)-(SumY*SumY))-((LookBack*OldSumYY)-(OldSumY*OldSumY)))/(LookBack*(LookBack-1));
00257 //     //    cerr << NumCalls << " " << totalSat << " " << Variance << endl;  
00258 //     
00259 //     if (VerboseOn){
00260 //       cerr <<"StopEval:\t" ;
00261 //       cerr << "Call Number: " << NumCalls <<"\t";
00262 //       cerr << "OverallMin: " << MinTotalStress << "\t";
00263 //       cerr << "MaxAtomStress: " << maxStress << "\t";
00264 //       cerr << "Mean: " << MeanLookBackTotalStress << "\t";
00265 //       cerr << "Slope: " << LookBackSlope << "\t";
00266 //       cerr << "Variance: " << Variance << endl;
00267 //     }
00268 // 
00269 //     if (!Quiet){
00270 // 
00271 //       cerr << setw(11)  << setiosflags(ios::showpoint)    
00272 //         << MeanLookBackTotalStress
00273 // 
00274 //         << setw(11)  
00275 //         << LookBackSlope 
00276 // 
00277 //         << setw(10)  
00278 //         << Variance;
00279 // 
00280 //     } 
00281 // 
00282 //     // CASE FOR SOLVING CONSTRAINTS ON ALL ATOMS
00283 //     if (maxStress < 0.001 && Variance < 5)  {  //MAGIC NUMBERS!!
00284 //       cerr << "\nSTOP by case 1 (solved)";
00285 //       writebest();
00286 //       return 1; //stop now
00287 //     }
00288 // 
00289 //     if (SolveOnly) return 0; //keep running, don't check further
00290 // 
00291 // 
00292 //     //
00293 //     // Simulated anealing type stuff with lpertfactor going up and down.
00294 //     //    
00295 //     
00296 // //     if ((Variance < 5) && (LookBackSlope > -0.01) &&
00297 // //   (NumCalls - LastLprAdj > LookBack) && (maxStress > 0.1))
00298 // //                                                                                 
00299 // //       {
00300 // //   gwNumerics::Mul_LPertFacor(1.36);
00301 // //   
00302 // //   NumLprAdj++;
00303 // //   cerr << "\nLPR ADJUST ++  case 2a (stalled, no variance) cycle: " << NumCalls
00304 // //        << "# " << NumLprAdj << endl; 
00305 // //   
00306 // //   LastLprAdj = NumCalls;
00307 // // 
00308 // //   if (NumLprAdj == NumLprLim) {
00309 // //     cerr << "\nLPR RESET =0.5  case 2a (stalled, not improving) cycle: " << NumCalls
00310 // //          << "# " << NumLprAdj << endl; 
00311 // //     gwNumerics::Set_LPertFacor(1);
00312 // //     CM->RandomPerturb(20);
00313 // //     NumLprAdj = 0;
00314 // //   }
00315 // //   if (NumLprAdj > NumLprLim + 5) {
00316 // //     cerr << "\nSTOP ++  case 2a (stalled, no variance) cycle: " << NumCalls
00317 // //          << "# " << NumLprAdj << endl;  
00318 // //     writebest();
00319 // //     return 1; // STOP
00320 // //     
00321 // //       }
00322 // //       return 0;
00323 // //     }
00324 // 
00325 // 
00326 // //     if ((
00327 // //    (Variance > 5000) && (LookBackSlope > 8) &&
00328 // //    (NumCalls - LastLprAdj >  LookBack) && (PercentLP > .2)
00329 // //    ) || ( 
00330 // //          (NumCalls - BestIter > 3 * LookBack)
00331 // //          && (NumCalls - LastLprAdj >  LookBack )
00332 // //         )
00333 // //   ) {
00334 // //       gwNumerics::Mul_LPertFacor(.81);
00335 // //       NumLprAdj--;
00336 // // 
00337 // //       cerr << "\nLPR ADJUST --  case 2b (stalled, not improving) cycle: " << NumCalls
00338 // //      << "# " << NumLprAdj << endl; 
00339 // // 
00340 // //       LastLprAdj = NumCalls;
00341 // // 
00342 // //       if (NumLprAdj == (-1)*NumLprLim) {
00343 // //   cerr << "\nLPR RESET =3  case 2b (stalled, not improving) cycle: " << NumCalls
00344 // //        << "# " << NumLprAdj << endl; 
00345 // //   gwNumerics::Set_LPertFacor(3);
00346 // //   CM->RandomPerturb(20);
00347 // //   NumLprAdj = 0;
00348 // //       }
00349 // // 
00350 // //       if (NumLprAdj < (-1)*NumLprLim - 7) {
00351 // //   cerr << "\nSTOP --  case 2b (stalled, not improving) cycle: " << NumCalls
00352 // //        << "# " << NumLprAdj << endl; 
00353 // //   writebest();
00354 // //   return 1; // STOP
00355 // //       }
00356 // //       return 0;
00357 // //     }
00358 //     
00359 // 
00360 //     
00361 //     
00362 //     // getting worse
00363 //     if ((LookBackSlope > 100) && (NumCalls - LastLprAdj >  LookBack ) &&
00364 //      (MinTotalStress < MeanLookBackTotalStress/ 5) &&
00365 //      (NumLprAdj < 1)) {
00366 //       cerr << "\nSTOP by case 3 (getting worse) Slope = " << LookBackSlope << endl;
00367 //       writebest();
00368 //       return 1;
00369 //     }
00370 //     
00371 //     
00372 //   }
00373 \end{verbatim}\normalsize 
\index{StopEval@{Stop\-Eval}!writebest@{writebest}}
\index{writebest@{writebest}!StopEval@{Stop\-Eval}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void Stop\-Eval::writebest (void)}\label{class_StopEval_a7}




Definition at line 379 of file jd\_\-stop\_\-eval.C.

Referenced by Atom\-Buildup::run().\footnotesize\begin{verbatim}00379                              {
00380 
00381   int N = CM->numAtoms();
00382   
00383   DynString comment;
00384   DynString FN;
00385   comment = BaseFN +
00386     DynString(" ;Best Iteration ") + DynString(BestIter) +
00387     DynString(" ;Ave Err = ") + DynString (BestAveErr) + 
00388     DynString(" ;Max Err = ") + DynString (BestMaxErr);
00389   FN = BaseFN + DynString(".best.xmol"); 
00390 
00391   char * s = &(FN[0]);  // ACK  not good, but it doesn't leak. -jd
00392   ofstream os(s);
00393   
00394   os << N << "\n";
00395   os << comment << "\n";
00396   for(int i=0; i<N; ++i)
00397     os << CM->getAtom(i).Type() <<" "<< myPoints[i] << endl;
00398   
00399   
00400 \end{verbatim}\normalsize 


\subsection{Member Data Documentation}
\index{StopEval@{Stop\-Eval}!AF@{AF}}
\index{AF@{AF}!StopEval@{Stop\-Eval}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf Anim\-Frame} $\ast$ Stop\-Eval::AF\hspace{0.3cm}{\tt  [private]}}\label{class_StopEval_o0}




Definition at line 79 of file jd\_\-stop\_\-eval.h.\index{StopEval@{Stop\-Eval}!BestAveErr@{BestAveErr}}
\index{BestAveErr@{BestAveErr}!StopEval@{Stop\-Eval}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}double Stop\-Eval::Best\-Ave\-Err\hspace{0.3cm}{\tt  [private]}}\label{class_StopEval_o4}




Definition at line 139 of file jd\_\-stop\_\-eval.h.\index{StopEval@{Stop\-Eval}!BestIter@{BestIter}}
\index{BestIter@{BestIter}!StopEval@{Stop\-Eval}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int Stop\-Eval::Best\-Iter = 0\hspace{0.3cm}{\tt  [static, private]}}\label{class_StopEval_r18}




Definition at line 31 of file jd\_\-stop\_\-eval.C.\index{StopEval@{Stop\-Eval}!BestMaxErr@{BestMaxErr}}
\index{BestMaxErr@{BestMaxErr}!StopEval@{Stop\-Eval}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}double Stop\-Eval::Best\-Max\-Err\hspace{0.3cm}{\tt  [private]}}\label{class_StopEval_o5}




Definition at line 140 of file jd\_\-stop\_\-eval.h.\index{StopEval@{Stop\-Eval}!Enable@{Enable}}
\index{Enable@{Enable}!StopEval@{Stop\-Eval}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool Stop\-Eval::Enable = true\hspace{0.3cm}{\tt  [static]}}\label{class_StopEval_p0}




Definition at line 69 of file globals.C.\index{StopEval@{Stop\-Eval}!LastLprAdj@{LastLprAdj}}
\index{LastLprAdj@{LastLprAdj}!StopEval@{Stop\-Eval}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int Stop\-Eval::Last\-Lpr\-Adj = 0\hspace{0.3cm}{\tt  [static, private]}}\label{class_StopEval_r17}




Definition at line 30 of file jd\_\-stop\_\-eval.C.\index{StopEval@{Stop\-Eval}!LookBack@{LookBack}}
\index{LookBack@{LookBack}!StopEval@{Stop\-Eval}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int Stop\-Eval::Look\-Back = 50\hspace{0.3cm}{\tt  [static, private]}}\label{class_StopEval_r0}


number of calls to Stop\-Eval to remember.



Definition at line 68 of file globals.C.\index{StopEval@{Stop\-Eval}!LookBackD@{LookBackD}}
\index{LookBackD@{LookBackD}!StopEval@{Stop\-Eval}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}double Stop\-Eval::Look\-Back\-D\hspace{0.3cm}{\tt  [static, private]}}\label{class_StopEval_r20}




Definition at line 136 of file jd\_\-stop\_\-eval.h.\index{StopEval@{Stop\-Eval}!LookBackSlope@{LookBackSlope}}
\index{LookBackSlope@{LookBackSlope}!StopEval@{Stop\-Eval}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}double Stop\-Eval::Look\-Back\-Slope\hspace{0.3cm}{\tt  [static, private]}}\label{class_StopEval_r19}




Definition at line 135 of file jd\_\-stop\_\-eval.h.\index{StopEval@{Stop\-Eval}!LowErr@{LowErr}}
\index{LowErr@{LowErr}!StopEval@{Stop\-Eval}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}double Stop\-Eval::Low\-Err\hspace{0.3cm}{\tt  [private]}}\label{class_StopEval_o3}




Definition at line 138 of file jd\_\-stop\_\-eval.h.\index{StopEval@{Stop\-Eval}!MaxLookBackStress@{MaxLookBackStress}}
\index{MaxLookBackStress@{MaxLookBackStress}!StopEval@{Stop\-Eval}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}double Stop\-Eval::Max\-Look\-Back\-Stress\hspace{0.3cm}{\tt  [static, private]}}\label{class_StopEval_r6}




Definition at line 111 of file jd\_\-stop\_\-eval.h.\index{StopEval@{Stop\-Eval}!MeanLookBackTotalStress@{MeanLookBackTotalStress}}
\index{MeanLookBackTotalStress@{MeanLookBackTotalStress}!StopEval@{Stop\-Eval}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}double Stop\-Eval::Mean\-Look\-Back\-Total\-Stress\hspace{0.3cm}{\tt  [static, private]}}\label{class_StopEval_r7}


mean of the lookback list vals on total stress, incrementally updated after lookback number of calls to stopeval 

Definition at line 117 of file jd\_\-stop\_\-eval.h.\index{StopEval@{Stop\-Eval}!MinLookBackStress@{MinLookBackStress}}
\index{MinLookBackStress@{MinLookBackStress}!StopEval@{Stop\-Eval}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}double Stop\-Eval::Min\-Look\-Back\-Stress\hspace{0.3cm}{\tt  [static, private]}}\label{class_StopEval_r5}


The Minimum (max) total Stress value observed over lookback calls to stop\_\-eval. 

Definition at line 110 of file jd\_\-stop\_\-eval.h.\index{StopEval@{Stop\-Eval}!MinTotalStress@{MinTotalStress}}
\index{MinTotalStress@{MinTotalStress}!StopEval@{Stop\-Eval}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}double Stop\-Eval::Min\-Total\-Stress\hspace{0.3cm}{\tt  [static, private]}}\label{class_StopEval_r2}




Definition at line 93 of file jd\_\-stop\_\-eval.h.\index{StopEval@{Stop\-Eval}!MinofMaxAssocTotal@{MinofMaxAssocTotal}}
\index{MinofMaxAssocTotal@{MinofMaxAssocTotal}!StopEval@{Stop\-Eval}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}double Stop\-Eval::Minof\-Max\-Assoc\-Total\hspace{0.3cm}{\tt  [static, private]}}\label{class_StopEval_r4}


the asociated total stress on the saved "best" molecule defined by Minof\-Max\-Stress' 

Definition at line 104 of file jd\_\-stop\_\-eval.h.\index{StopEval@{Stop\-Eval}!MinofMaxStress@{MinofMaxStress}}
\index{MinofMaxStress@{MinofMaxStress}!StopEval@{Stop\-Eval}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}double Stop\-Eval::Minof\-Max\-Stress\hspace{0.3cm}{\tt  [static, private]}}\label{class_StopEval_r3}


the overall min of the max on each list of stress calls on an iteration.



Definition at line 98 of file jd\_\-stop\_\-eval.h.\index{StopEval@{Stop\-Eval}!NumCalls@{NumCalls}}
\index{NumCalls@{NumCalls}!StopEval@{Stop\-Eval}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int Stop\-Eval::Num\-Calls = 0\hspace{0.3cm}{\tt  [static, private]}}\label{class_StopEval_r14}




Definition at line 27 of file jd\_\-stop\_\-eval.C.\index{StopEval@{Stop\-Eval}!NumLprAdj@{NumLprAdj}}
\index{NumLprAdj@{NumLprAdj}!StopEval@{Stop\-Eval}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int Stop\-Eval::Num\-Lpr\-Adj = 0\hspace{0.3cm}{\tt  [static, private]}}\label{class_StopEval_r15}




Definition at line 28 of file jd\_\-stop\_\-eval.C.\index{StopEval@{Stop\-Eval}!NumLprLim@{NumLprLim}}
\index{NumLprLim@{NumLprLim}!StopEval@{Stop\-Eval}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int Stop\-Eval::Num\-Lpr\-Lim = 10\hspace{0.3cm}{\tt  [static, private]}}\label{class_StopEval_r16}




Definition at line 29 of file jd\_\-stop\_\-eval.C.\index{StopEval@{Stop\-Eval}!Quiet@{Quiet}}
\index{Quiet@{Quiet}!StopEval@{Stop\-Eval}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool Stop\-Eval::Quiet = false\hspace{0.3cm}{\tt  [static]}}\label{class_StopEval_p3}


run-time ajdustable flag to stop default output.



Definition at line 72 of file globals.C.\index{StopEval@{Stop\-Eval}!Rtp@{Rtp}}
\index{Rtp@{Rtp}!StopEval@{Stop\-Eval}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool Stop\-Eval::Rtp = false\hspace{0.3cm}{\tt  [static]}}\label{class_StopEval_p2}


Real time plotting output -- single double outputs for plotting.



Definition at line 73 of file globals.C.\index{StopEval@{Stop\-Eval}!SolveOnly@{SolveOnly}}
\index{SolveOnly@{SolveOnly}!StopEval@{Stop\-Eval}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool Stop\-Eval::Solve\-Only = false\hspace{0.3cm}{\tt  [static]}}\label{class_StopEval_p1}




Definition at line 70 of file globals.C.\index{StopEval@{Stop\-Eval}!SumX@{SumX}}
\index{SumX@{SumX}!StopEval@{Stop\-Eval}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}double Stop\-Eval::Sum\-X\hspace{0.3cm}{\tt  [static, private]}}\label{class_StopEval_r10}




Definition at line 123 of file jd\_\-stop\_\-eval.h.\index{StopEval@{Stop\-Eval}!SumXX@{SumXX}}
\index{SumXX@{SumXX}!StopEval@{Stop\-Eval}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}double Stop\-Eval::Sum\-XX\hspace{0.3cm}{\tt  [static, private]}}\label{class_StopEval_r8}


Variables for linear regression these are maintained over the lookback calls to {\bf Stop\-Eval::run}() {\rm (p.\,\pageref{class_StopEval_a3})}.



Definition at line 121 of file jd\_\-stop\_\-eval.h.\index{StopEval@{Stop\-Eval}!SumXY@{SumXY}}
\index{SumXY@{SumXY}!StopEval@{Stop\-Eval}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}double Stop\-Eval::Sum\-XY\hspace{0.3cm}{\tt  [static, private]}}\label{class_StopEval_r9}




Definition at line 122 of file jd\_\-stop\_\-eval.h.\index{StopEval@{Stop\-Eval}!SumY@{SumY}}
\index{SumY@{SumY}!StopEval@{Stop\-Eval}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}double Stop\-Eval::Sum\-Y\hspace{0.3cm}{\tt  [static, private]}}\label{class_StopEval_r11}




Definition at line 124 of file jd\_\-stop\_\-eval.h.\index{StopEval@{Stop\-Eval}!SumYY@{SumYY}}
\index{SumYY@{SumYY}!StopEval@{Stop\-Eval}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}double Stop\-Eval::Sum\-YY\hspace{0.3cm}{\tt  [static, private]}}\label{class_StopEval_r12}




Definition at line 125 of file jd\_\-stop\_\-eval.h.\index{StopEval@{Stop\-Eval}!TotalStressList@{TotalStressList}}
\index{TotalStressList@{TotalStressList}!StopEval@{Stop\-Eval}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf DLList}$<$ double $>$ Stop\-Eval::Total\-Stress\-List\hspace{0.3cm}{\tt  [static, private]}}\label{class_StopEval_r1}


list of total stress values kept over the last lookback number of calls to stop eval. Min, Mean and slope are used over this list. 

Definition at line 33 of file jd\_\-stop\_\-eval.C.\index{StopEval@{Stop\-Eval}!Variance@{Variance}}
\index{Variance@{Variance}!StopEval@{Stop\-Eval}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}double Stop\-Eval::Variance\hspace{0.3cm}{\tt  [static, private]}}\label{class_StopEval_r13}




Definition at line 126 of file jd\_\-stop\_\-eval.h.\index{StopEval@{Stop\-Eval}!VerboseOn@{VerboseOn}}
\index{VerboseOn@{VerboseOn}!StopEval@{Stop\-Eval}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool Stop\-Eval::Verbose\-On = false\hspace{0.3cm}{\tt  [static]}}\label{class_StopEval_p4}


run-time ajdustable flag to provide verbose output.



Definition at line 71 of file globals.C.\index{StopEval@{Stop\-Eval}!myPoints@{myPoints}}
\index{myPoints@{myPoints}!StopEval@{Stop\-Eval}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf j\-Vector} $\ast$ Stop\-Eval::my\-Points\hspace{0.3cm}{\tt  [private]}}\label{class_StopEval_o2}




Definition at line 81 of file jd\_\-stop\_\-eval.h.\index{StopEval@{Stop\-Eval}!of@{of}}
\index{of@{of}!StopEval@{Stop\-Eval}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}ofstream $\ast$ Stop\-Eval::of\hspace{0.3cm}{\tt  [private]}}\label{class_StopEval_o1}




Definition at line 80 of file jd\_\-stop\_\-eval.h.

The documentation for this class was generated from the following files:\begin{CompactItemize}
\item 
{\bf jd\_\-stop\_\-eval.h}\item 
{\bf globals.C}\item 
{\bf jd\_\-stop\_\-eval.C}\end{CompactItemize}
