\section{/home/peifer/diffit/modules/parse.cc File Reference}
\label{parse_8cc}\index{/home/peifer/diffit/modules/parse.cc@{/home/peifer/diffit/modules/parse.cc}}
{\bf Module} for parsing command line arguments 

{\tt \#include $<$string.h$>$}\par
{\tt \#include $<$stdlib.h$>$}\par
{\tt \#include $<$stddef.h$>$}\par
{\tt \#include $<$iostream$>$}\par
{\tt \#include $<$fstream$>$}\par
{\tt \#include $<$getopt.h$>$}\par
{\tt \#include $<$string$>$}\par
{\tt \#include $<$math.h$>$}\par
{\tt \#include \char`\"{}../nr.h\char`\"{}}\par
{\tt \#include \char`\"{}../def.h\char`\"{}}\par
{\tt \#include \char`\"{}../model.h\char`\"{}}\par
\subsection*{Defines}
\begin{CompactItemize}
\item 
\#define {\bf MAXLENGTH}~1000
\begin{CompactList}\small\item\em maximal length of input line \item\end{CompactList}\end{CompactItemize}
\subsection*{Functions}
\begin{CompactItemize}
\item 
long {\bf get\_\-list} (long n, double $\ast$arg, char $\ast$string, char $\ast$desc)
\item 
{\bf Glob\-Exp} $\ast$ {\bf parseopts} (int argc, char $\ast$argv[$\,$], {\bf Glob} $\ast$globs, char $\ast$outstr)
\end{CompactItemize}
\subsection*{Variables}
\begin{CompactItemize}
\item 
char {\bf usage} [$\,$]
\begin{CompactList}\small\item\em description of command line arguments \item\end{CompactList}\end{CompactItemize}


\subsection{Detailed Description}
{\bf Module} for parsing command line arguments 

This module parses the command line arguments. It is based on the standard C routine getopt. The structure {\bf option} further below defines the command line arguments and if they require an argument or not. A documentation of this structure and further details of the getopt routine comes with documentation of the GNU compiler (e.g. use the linux/unix command:man getopt). 

Definition in file {\bf parse.cc}.

\subsection{Define Documentation}
\index{parse.cc@{parse.cc}!MAXLENGTH@{MAXLENGTH}}
\index{MAXLENGTH@{MAXLENGTH}!parse.cc@{parse.cc}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}\#define MAXLENGTH~1000}\label{parse_8cc_1dbd686f69551b83691025eaae058539}


maximal length of input line 



Definition at line 25 of file parse.cc.

Referenced by parseopts().

\subsection{Function Documentation}
\index{parse.cc@{parse.cc}!get_list@{get\_\-list}}
\index{get_list@{get\_\-list}!parse.cc@{parse.cc}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}long get\_\-list (long {\em n}, double $\ast$ {\em arg}, char $\ast$ {\em string}, char $\ast$ {\em desc})}\label{parse_8cc_3e400bee2443fb0a46657eb816659761}




Definition at line 78 of file parse.cc.

\footnotesize\begin{verbatim}79 {
80   long k=1,l=0,ind=0;
81   char sep=',';
82   char *dum=new char[strlen(string)+1];
83   while(string[ind]!='\0')
84     {
85       if(k>n)
86         {
87           cerr << "Too many arguments in" << desc << "list." << endl;
88           exit(1);
89         }
90       dum[l]=string[ind];
91       
92       if(dum[l]==sep)
93         {
94           dum[l]='\0';
95           arg[k]=atof(dum);
96           l=0;
97           k++;
98           ind++;
99         }
100       else
101         {
102           ind++;
103           l++;
104         }
105     }
106   dum[l]='\0';
107   arg[k]=atof(dum);
108 
109   delete dum;
110   return(k);
111 } 
\end{verbatim}\normalsize 


\index{parse.cc@{parse.cc}!parseopts@{parseopts}}
\index{parseopts@{parseopts}!parse.cc@{parse.cc}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf Glob\-Exp}$\ast$ parseopts (int {\em argc}, char $\ast$ {\em argv}[$\,$], {\bf Glob} $\ast$ {\em globs}, char $\ast$ {\em outstr})}\label{parse_8cc_f7cc992592a2b95c9c3dec59ccf66584}


Main module routine doing all the pasing. \begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em argc}]The number of command line arguments as passed by {\bf main}. \item[{\em $\ast$argv\mbox{[}$\,$\mbox{]}}]String of the arguments. \item[{\em $\ast$globs}]The structure {\bf Glob}{\rm (p.\,\pageref{structGlob})}. \item[{\em $\ast$outstr}]Depreciated, not used. \end{description}
\end{Desc}


Definition at line 120 of file parse.cc.

References Glob::do\-P, dvector(), Glob::elastic, Glob::eps, Glob::epsilon, Glob::faktor\-L, Glob::faktor\-Lexist, FALSE, Glob::gnu\-Fp, Glob::init\-Spline, Glob::integrator, ivector(), Glob::lambda, Glob::maxit, MAXLENGTH, Glob::maxstp, Glob::minimiser, Glob::minimp, Glob::nodamp, Glob::no\-Gnu, Glob::no\-Measurements, Glob::nowait, Glob::npar, Glob::pert, Glob::reg, Glob::silent, Glob::sim\-Init, Glob::stiff, Glob::strategy, TRUE, Glob::usesig, Glob::wait, Glob::wquer, and Glob::y0fix.

\footnotesize\begin{verbatim}121 {
122   int longindex,opt;
123   int parlistSpecified=FALSE;
124   long k,l,nExp,sp;
125   char name[MAXLENGTH],line[MAXLENGTH];
126 
127   // option definition
128   static struct option longopts[]={
129     {"help", 0, 0,  'h'},
130     {"help", 0, 0,  '?'},
131     {"x0"  , 1, 0,   1 },
132     {"x1"  , 1, 0,   2 },
133     {"nms"  ,1, 0,   3 },
134     {"f"    ,1, 0,   4 },
135     {"p"    ,1, 0,   5 },
136     {"y0"   ,1, 0,   6 },
137     {"nobs" ,1, 0,   7 },
138     {"eps"  ,1, 0,   8 },
139     {"nognu",0, 0,   9 },
140     {"nomeasure",0,0,10},
141     {"doP"  ,1, 0,   11},
142     {"maxit",1, 0,   12},
143     {"wait" ,0, 0,   13},
144     {"usesig",0,0,   14},
145     {"int"   ,1,0,   15},
146     {"maxstp",1,0,   17},
147     {"minimp",1,0,   18},
148     {"nowait",0,0,   19},
149     {"elastic" ,1,0, 21},
150     {"reg"     ,0,0, 22},
151     {"epsilon" ,1,0, 23},
152     {"lambda"  ,1,0, 24},
153     {"spline"  ,1,0, 25},
154     {"siminit" ,0,0, 26},
155     {"pert"    ,1,0, 27},
156     {"y0fix"   ,1,0, 28},
157     {"nodamp"  ,0,0, 29},
158     {"strat"   ,1,0, 30},
159     {"opt"     ,1,0, 31},
160     {"Lconst"  ,1,0, 32},
161     {0, 0, 0, 0}
162   };
163   //initialise some global parameters in globs
164   globs->noGnu=FALSE;
165   globs->eps=1e-6;
166   globs->npar=NPARAMS;
167   globs->noMeasurements=FALSE;
168   globs->doP=ivector(1,globs->npar);
169   for(k=1;k<=globs->npar;k++)
170     globs->doP[k]=TRUE;
171   globs->y0fix=ivector(1,NEQNS);
172   for(k=1;k<=NEQNS;k++)
173     globs->y0fix[k]=TRUE;
174   globs->maxit=1000;
175   globs->gnuFp=NULL;
176   globs->wait=FALSE;
177   globs->usesig=FALSE;
178   globs->integrator=1;
179   globs->stiff=TRUE;
180   globs->maxstp=5000;
181   globs->minimp=1e-4;
182   globs->nowait=FALSE;
183   globs->elastic=1.;
184   globs->reg=FALSE;
185   globs->epsilon=1e-10;
186   globs->lambda=1e6;
187   globs->simInit=FALSE;
188   globs->pert=0.;
189   globs->nodamp=FALSE;
190   globs->initSpline=TRUE;
191   globs->wquer=-1;
192   globs->silent=FALSE;
193   globs->strategy=1;
194   globs->minimiser=2;
195   globs->faktorL=dvector(1,NPARAMS);
196   globs->faktorLexist=FALSE;
197   for(k=1;k<=NPARAMS;k++)
198   {
199         globs->faktorL[k]=-1;
200   }     
201   while ((opt=getopt_long_only(argc,argv,"h?",longopts,&longindex)) != -1)
202     {
203       switch(opt)
204         {
205         case 4:
206           parlistSpecified=TRUE;
207           strncpy(name,optarg,MAXLENGTH);
208           break;
209         }
210     }
211   optind=0;
212   
213   GlobExp *ex;
214   if(parlistSpecified==FALSE)
215     {
216       globs->nrExp=1;
217       ex=new GlobExp[globs->nrExp+1];   
218       //initialise some global parameters
219       ex[1].fitstart=-1e99;
220       ex[1].fitend=1e99;
221       ex[1].nobs=NOBS;
222       ex[1].nvar=NEQNS;
223       ex[1].nPoints=2;
224       ex[1].splinesDefined=FALSE;
225       ex[1].y0=NULL;
226       // initialisation of the parameters
227       ex[1].par=dvector(1,NPARAMS);
228       for(k=1;k<=globs->npar;k++)
229         ex[1].par[k]=DefParameters[k-1];
230       
231       if(NSPLINES!=0)
232         {
233           ex[1].nNodes=lvector(1,NSPLINES);
234         }
235     }
236   else //if parlist specified
237     {
238       ifstream in;      ofstream out;
239       char str[MAXLENGTH];
240 
241       in.open(name);
242 
243       if(!in)
244         {
245           cerr << "parameter list " << name << "  not found\n";
246           exit(1);
247         }
248       
249       //preprocessing of data list
250       globs->nrExp=0;
251       sprintf(str,"%s.%d",name,globs->nrExp);
252       out.open(str);
253       while(!in.eof())
254         {
255           in.getline(str,MAXLENGTH,'\n');
256           if(str[0]=='@')
257             {
258               out.flush();
259               out.close();
260               globs->nrExp++;
261               sprintf(str,"%s.%d",name,globs->nrExp);
262               out.open(str);
263             }
264           else if(str[0]!='#')
265             {
266               out << str << endl;
267             }
268         }
269       out.flush();
270       out.close();
271       in.close();
272 
273       if(globs->nrExp==0)
274         {
275           cerr << "insuffient number of experiments, @ missing\n";
276           exit(1);
277         }
278       
279       long _argc;
280       char *_argv[MAXLENGTH];
281 
282       for(k=0;k<=MAXLENGTH;k++)
283         _argv[k]=(char *)malloc((size_t) (150*sizeof(char)));
284 
285       {
286         ifstream inp;
287         
288         _argc=0;
289         sprintf(str,"%s.0",name);
290         inp.open(str);
291         
292         
293         while(!inp.eof())
294           {
295             inp >> _argv[_argc+1];
296             _argc++;
297           }
298         inp.close();
299       }
300    
301       //PARSING LIST
302 
303       while((opt=getopt_long_only(_argc,_argv,"h?",longopts,&longindex)) != -1)
304         {
305           switch(opt) 
306             { 
307             case 'h':
308               cout << usage << endl;
309               exit(1);
310               break;
311             case '?':
312               cerr << usage << endl;
313               exit(1);  
314               break;
315             case 8:
316               globs->eps=fabs(atof(optarg));
317               break;
318             case 9:
319               globs->noGnu=TRUE;
320               break;
321             case 10:
322               globs->noMeasurements=TRUE;
323               break;
324             case 11:
325               if(strlen(optarg)!=globs->npar)
326                 {
327                   cerr << strlen(optarg) << " parameter(s) specified instead of " <<  globs->npar << ".\n";
328                   exit(1);
329                 }
330               for(k=0;k < globs->npar;k++)
331                 {
332                   if(optarg[k]=='0')
333                     globs->doP[k+1]=FALSE;
334                   else if (optarg[k]=='L')
335                     globs->doP[k+1]='L'; 
336                   else
337                     globs->doP[k+1]=TRUE;
338                 }
339               break;
340             case 12:
341               globs->maxit=abs(atol(optarg));
342               break;
343             case 13:
344               globs->wait=TRUE;
345               break;
346             case 14:
347               globs->usesig=TRUE;
348               break;
349             case 15:
350               globs->integrator=abs(atoi(optarg));
351               break;
352             case 17:
353               globs->maxstp=abs(atoi(optarg));
354               break;
355             case 18:
356               globs->minimp=fabs(atof(optarg));
357               break;
358             case 19:
359               globs->nowait=TRUE;
360               break;
361             case 21:
362               globs->elastic=fabs(atof(optarg));
363               if(globs->elastic > 1. || globs->elastic == 0.)
364                 {
365                   cerr << "Insufficient range of -elast <val> \n";
366                   exit(1);
367                 }
368               break;
369             case 22:
370               globs->reg=TRUE;
371               break;
372             case 23:
373               globs->epsilon=fabs(atof(optarg));
374               break;
375             case 24:
376               globs->lambda=fabs(atof(optarg));
377               break;
378             case 26:
379               globs->simInit=TRUE;
380               break;
381             case 27:
382               globs->pert=fabs(atof(optarg));
383               break;
384             case 28:
385               if(strlen(optarg)!=NEQNS)
386                 {
387                   cerr << strlen(optarg) << " variable(s) specified instead of " <<  NEQNS << ".\n";
388                   exit(1);
389                 }
390               for(k=0;k < NEQNS;k++)
391                 {
392                   if(optarg[k]=='0')
393                     globs->y0fix[k+1]=FALSE;
394                   else
395                     globs->y0fix[k+1]=TRUE;
396                 }
397               break;
398             case 29:
399               globs->nodamp=TRUE;
400               break; 
401             case 30:
402               globs->strategy=abs(atoi(optarg));
403               break;
404             case 31:
405               globs->minimiser=abs(atoi(optarg));
406               break;
407             case 32:
408               get_list(globs->npar,globs->faktorL,optarg," local paramter constraints ");
409               globs->faktorLexist=TRUE;
410               break;                  
411             default:
412               cerr << endl;
413               cerr << "Parsing parameter list produced errors.\n\n";
414               exit(1);
415             }
416         }
417 
418       optind=0;
419       ex=new GlobExp[globs->nrExp+1];   
420   
421       //PARSING experiment specific list
422       for(nExp=1;nExp<=globs->nrExp;nExp++)
423         {
424           //initialise some global parameters
425           ex[nExp].fitstart=-1e99;
426           ex[nExp].fitend=1e99;
427           ex[nExp].nobs=NOBS;
428           ex[nExp].nvar=NEQNS;
429           ex[nExp].nPoints=2;
430           ex[nExp].splinesDefined=FALSE;
431           ex[nExp].y0=NULL;
432           // initialisation of the parameters
433           ex[nExp].par=dvector(1,NPARAMS);
434           for(k=1;k<=globs->npar;k++)
435             ex[nExp].par[k]=DefParameters[k-1];
436           
437           if(NSPLINES!=0)
438             {
439               ex[nExp].nNodes=lvector(1,NSPLINES);
440             }
441 
442           _argc=0;
443 
444           ifstream inp;
445           sprintf(str,"%s.%d",name,nExp);
446           inp.open(str);
447 
448           while(!inp.eof())
449             {
450               inp >> _argv[_argc+1];
451               _argc++;
452             }
453 
454           inp.close();
455           while((opt=getopt_long_only(_argc,_argv,"h?",longopts,&longindex)) != -1)
456              {
457                switch(opt)
458                  {
459                  case 1:
460                    ex[nExp].fitstart=atof(optarg);
461                    break;
462                  case 2:
463                    ex[nExp].fitend=atof(optarg);
464                    break;
465                  case 3:
466                    ex[nExp].nPoints=abs(atol(optarg));
467                    ex[nExp].nPoints+=1;
468                    break;
469                  case 5:
470                    get_list(globs->npar,ex[nExp].par,optarg," parameter ");
471                    break;
472                  case 6:
473                    ex[nExp].y0=dvector(1,ex[nExp].nvar);
474                    for(k=1;k<=ex[nExp].nvar;k++)
475                      ex[nExp].y0[k]=0.;
476                    k=get_list(ex[nExp].nvar,ex[nExp].y0,optarg," initial values ");
477                    if(k!=ex[nExp].nvar)
478                      {
479                        cerr << ex[nExp].nvar << " initial values required.\n";
480                        exit(1);
481                      }
482                    break;
483                  case 7:
484                    ex[nExp].nobs=atol(optarg);
485                    break;
486                  case 25:
487                    k=0;
488                    l=1;
489                    ex[nExp].splinesDefined=TRUE;
490                    while(optarg[k]!='\0')
491                      {
492                        if(optarg[k]==',')
493                          l++;
494                        k++;
495                      }
496                    if(l!=NSPLINES)
497                      {
498                        cerr << "Incompatible number of splines.\n";
499                        exit(1);
500                      }
501                    ex[nExp].splineFile=new string[l+1];
502                    l=1;
503                    sp=0;
504                    k=0;
505                    while(optarg[k]!='\0')
506                      {
507                        if(optarg[k]==',')
508                          {
509                            line[sp]='\0';
510                            ex[nExp].splineFile[l]=(string)line;
511                            sp=0;
512                            l++;
513                          }
514                        else
515                          {
516                            line[sp]=optarg[k];
517                            sp++;
518                          }
519                        k++;
520                      }
521                    line[sp]='\0';
522                    ex[nExp].splineFile[l]=(string)line;
523                    break;
524                  default:
525                    cerr << endl;
526                    cerr << "Parsing parameter list produced errors.\n\n";
527                    exit(1);
528                  }
529              }
530 
531            //Parsing file name
532            if((_argc-optind)!=1)
533              {
534                cerr << "No/Too many datafile(s) specified for experiment " << nExp << " .  \n\n";
535                exit(1);
536              }
537            else
538              {
539                ex[nExp].fileName=new char[strlen(_argv[optind])+1];
540                strcpy(ex[nExp].fileName,_argv[optind]);
541              }
542            //checking if x0 < x1
543            if(ex[nExp].fitstart >= ex[nExp].fitend)
544              {
545                cerr << "x0 must be smaller than x1.\n";
546                exit(1);
547              }
548            optind=0;
549         }
550       
551      
552       //for(k=0;k<=MAXLENGTH;k++)
553       //free(_argv[k]);
554 
555       sprintf(str,"rm -f %s.*",name);
556       system(str);
557     }
558 
559   optind=0;
560   
561   while((opt=getopt_long_only(argc,argv,"h?",longopts,&longindex)) != -1)
562     {
563       switch(opt)
564         {
565         case 'h':
566           cout << usage << endl;
567           exit(1);
568           break;
569         case '?':
570           cerr << usage << endl;
571           exit(1);      
572           break;
573         case 1:
574           ex[1].fitstart=atof(optarg);
575           break;
576         case 2:
577           ex[1].fitend=atof(optarg);
578           break;
579         case 3:
580           ex[1].nPoints=abs(atol(optarg));
581           ex[1].nPoints+=1;
582           break;
583         case 4:
584           break;
585         case 5:
586           get_list(globs->npar,ex[1].par,optarg," parameter ");
587           break;
588         case 6:
589           ex[1].y0=dvector(1,ex[1].nvar);
590           for(k=1;k<=ex[1].nvar;k++)
591             ex[1].y0[k]=0.;
592           k=get_list(ex[1].nvar,ex[1].y0,optarg," initial values ");
593           if(k!=ex[1].nvar)
594             {
595               cerr << ex[1].nvar << " initial values required.\n";
596               exit(1);
597             }
598           break;
599         case 7:
600           ex[1].nobs=atol(optarg);
601           break;
602         case 8:
603           globs->eps=fabs(atof(optarg));
604           break;
605         case 9:
606           globs->noGnu=TRUE;
607           break;
608         case 10:
609           globs->noMeasurements=TRUE;
610           break;
611         case 11:
612           if(strlen(optarg)!=globs->npar)
613             {
614               cerr << strlen(optarg) << " parameter(s) specified instead of " <<  globs->npar << ".\n";
615               exit(1);
616             }
617           for(k=0;k < globs->npar;k++)
618             {
619               if(optarg[k]=='0')
620                 globs->doP[k+1]=FALSE;
621               else if (optarg[k]=='L')
622                 globs->doP[k+1]='L'; 
623               else
624                 globs->doP[k+1]=TRUE;
625             }
626           break;
627         case 12:
628           globs->maxit=abs(atol(optarg));
629           break;
630         case 13:
631           globs->wait=TRUE;
632           break;
633         case 14:
634           globs->usesig=TRUE;
635           break;
636         case 15:
637           globs->integrator=abs(atoi(optarg));
638           break;
639         case 17:
640           globs->maxstp=abs(atoi(optarg));
641           break;
642         case 18:
643           globs->minimp=fabs(atof(optarg));
644           break;
645         case 19:
646           globs->nowait=TRUE;
647           break;
648         case 21:
649           globs->elastic=fabs(atof(optarg));
650           if(globs->elastic > 1. || globs->elastic == 0.)
651             {
652               cerr << "Insufficient range of -elast <val> \n";
653               exit(1);
654             }
655           break;
656         case 22:
657           globs->reg=TRUE;
658           break;
659         case 23:
660           globs->epsilon=fabs(atof(optarg));
661           break;
662         case 24:
663           globs->lambda=fabs(atof(optarg));
664           break;
665         case 25:
666           k=0;
667           l=1;
668           ex[1].splinesDefined=TRUE;
669           while(optarg[k]!='\0')
670             {
671               if(optarg[k]==',')
672                 l++;
673               k++;
674             }
675           if(l!=NSPLINES)
676             {
677               cerr << "Incompatible number of splines.\n";
678               exit(1);
679             }
680           ex[1].splineFile=new string[l+1];
681           l=1;
682           sp=0;
683           k=0;
684           while(optarg[k]!='\0')
685             {
686               if(optarg[k]==',')
687                 {
688                   line[sp]='\0';
689                   ex[1].splineFile[l]=(string)line;
690                   sp=0;
691                   l++;
692                 }
693               else
694                 {
695                   line[sp]=optarg[k];
696                   sp++;
697                 }
698               k++;
699             }
700           line[sp]='\0';
701           ex[1].splineFile[l]=(string)line;
702           break;           
703         case 26:
704           globs->simInit=TRUE;
705           break;
706         case 27:
707           globs->pert=fabs(atof(optarg));
708           break;
709         case 28:
710           if(strlen(optarg)!=NEQNS)
711             {
712               cerr << strlen(optarg) << " variable(s) specified instead of " <<  NEQNS << ".\n";
713               exit(1);
714             }
715           for(k=0;k < NEQNS;k++)
716             {
717               if(optarg[k]=='0')
718                 globs->y0fix[k+1]=FALSE;
719               else
720                 globs->y0fix[k+1]=TRUE;
721             }
722           break;
723         case 29:
724           globs->nodamp=TRUE;
725           break;
726         case 30:
727           globs->strategy=abs(atoi(optarg));
728           break;
729         case 31:
730           globs->minimiser=abs(atoi(optarg));
731           break;
732         case 32:
733           get_list(globs->npar,globs->faktorL,optarg," local paramter constraints ");
734           globs->faktorLexist=TRUE;
735           break;
736         default:
737           cerr << endl;
738           cerr << "Parsing command line options produced errors \n\n";
739           exit(1);
740         }
741     }
742   //checking if x0 < x1
743   if(ex[1].fitstart >= ex[1].fitend)
744     {
745       cerr << "x0 must be smaller than x1.\n";
746       exit(1);
747     }
748   
749   //Parsing file name for a single experiment
750   if((argc-optind)!=1 && parlistSpecified==FALSE)
751     {
752       cerr << "No/Too many datafile(s) specified.  \n\n";
753       exit(1);
754     }
755   else if(parlistSpecified==FALSE)
756     {
757       ex[1].fileName=new char[strlen(argv[optind])+1];
758       strcpy(ex[1].fileName,argv[optind]);
759     }
760   
761   if(NSPLINES!=0)
762     {
763       for(k=1;k<=globs->nrExp;k++)
764         {
765           if(ex[k].splinesDefined==FALSE)
766             {
767               cerr << "Please specify spline data in experiment " << k << ".\n";
768               exit(1);
769             }
770         }
771     }
772   
773   return(ex);
774 }
\end{verbatim}\normalsize 




\subsection{Variable Documentation}
\index{parse.cc@{parse.cc}!usage@{usage}}
\index{usage@{usage}!parse.cc@{parse.cc}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}char {\bf usage}[$\,$]}\label{parse_8cc_c272052a23799ed4af95e9876ba00fac}


description of command line arguments 

can be displayed by using command line argument -h 

Definition at line 33 of file parse.cc.