inputoutput.doxy

 
bool  subdivide false @endcode
 
The results from the program are stored in a similar structure. At the end of a program, it is possible to write the input and output data into one file. The output file has the same syntax and structure as the input file and can therefore be used as an input file to reproduce the results at a later time.
See the <a href="#Results">results section</a> for an example.
 
@dontinclude inputoutput.py
@section commented Commented Program
 
First we have to import certain modules from the \c libconceptspy  package and other required python modules.
 
  @skip  from libconceptspy import concepts
  @until import argparse
 
All code in this example is in one large routine, the main program.
 
  @skip def main(args,argv):
  @until def main(args,argv):
 
Some default values for the parameters used. \c l and \c p are just two variables. If \c debug is set to true, more information is printed to screen.
 
  @skip l = 0
  @until debug = False
 
First, set up the input parameter class: some parameters are set up with a default value.
  
  @skip inp = concepts.InputParser(True)
  @until inputParameters.addString('parameterout',"inputoutput.out")
 
The variable outputParameter is for easier access to the output area. There, the results of the computations can be stored and eventually written to disk if necessary.
 
  @skip outputParameters = concepts.InOutParameters()
  @until outputParameters = concepts.InOutParameters()
 
Prepare an array for values computed later. This array is then added to \c table which is able to nicely format the content of the different arrays (e.g. for later processing with Gnuplot).
 
  @skip outputParameters.addArrayDouble("error")
  @until inputfile = ''
 
@subsection parsing Command Line Parsing
Here, we start with the command line parsing. 
  @code 
  parser = argparse.ArgumentParser()
  parser.add_argument('-l',help='LEVEL: level of refinement',required=False, type = int)
  parser.add_argument('-p',help='DEGREE: polynomial degree', required=False, type = int)
  parser.add_argument('-f',help='FILE: name of the input file',required=False, type = str)
  parser.add_argument('-d',action = "store_true",help='-d: print the matrices',required=False)
  args = parser.parse_args() 
  @endcode
 
Enter \c -h as command line argument for more information. The parameters are processed in the order they appear in the command line. When first specifying an input file with \c -f, the values in the file can be overridden with additional command line arguments after \c -f.
 
  @skip if (len(argv)>1):
  @until inputParameters.addBool('debug', True)
 
If there is an error reading the input file, then an exception error message is returned.
 
  @skip except RuntimeError:
  @until print("Input file not found.Cannot open input file.")
 
Print the parameters to show the user what is going on.
 
  @skip print('['+argv[0]+']')
  @until print('  input file = %s\n%s'%(inputfile,inputParameters))
 
Next, the parameters from the command line or the input file are stored in the respective variables. This is only used for abbrevation.
 
  @skip l = inputParameters.getInt('level')
  @until p = inputParameters.getInt('polynomial')
 
@subsection comp Computations
Here are some dummy computations to fill the output area with content.
 
  @skip outputParameters.addInt("nelm", 10)
  @until outputParameters.addArrayDouble("error",i,1.0/(1<<i))
 
@section output Output
Finally, the input and output data are written to disk with some more information about the user and the system in the header of the file.
 
  @skip print 'Writing gathered data to disk: ',inputParameters.getString("parameterout")
  @until ofile.close()
 
This prints the table and its content to the screen and also stores it with high precision in a file suitable for later processing with Gnuplot.
  
  @skip print(table)
  @until gnu_file.close()
 
@section Results
The output of the program called without parameters: @code
[inputoutput]
--
Parameters:
  input file =
string  author  "(empty)"
string  comment "(empty)"
string  parameterout    "inputoutput.out"
string  title   "(empty)"
int     level   0
int     polynomial      1
bool    debug   false
--
--
Writing gathered data to disk: inputoutput.out
ResultsTable(
error   error
0       1
1       0.5
2       0.25
3       0.125
4       0.0625
5       0.03125
6       0.015625
7       0.0078125
8       0.00390625
9       0.00195312
) @endcode
The program creates the following output files:
    - \c inputoutput.out: 
@code
/* program:     inputoutput
 * command:     inputoutput
 * input file:
 */
string  author  "(empty)"
string  comment "(empty)"
string  parameterout    "inputoutput.out"
string  title   "(empty)"
int     level   0
int     polynomial      1
bool    debug   false
end
// output starts here
int     nelm    10
array double error {
        0       1
        1       0.5
        2       0.25
        3       0.125
        4       0.0625
        5       0.03125
        6       0.015625
        7       0.0078125
        8       0.00390625
        9       0.00195312
} @endcode
    - \c inputoutput.gnuplot: 
@code
# error error
0       1q
1       0.5
2       0.25
3       0.125
4       0.0625
5       0.03125
6       0.015625
7       0.0078125
8       0.00390625
9       0.00195312 @endcode
 
Note the \c end keyword at the end of the input part and right before the output part. When reading in this file as input file, the parsing stops right there, ie. the previous output data is not read in.
 
    @section complete Complete Source Code
*/