inputoutput.py

Introduction

This tutorial and its program shows the usage of input and output files and command line parameters. With the use of input files its no longer necessary to recompile the whole program when you want to change a parameter and its no longer necessary to write a huge number of parameters on the command line.

With a carefully designed order of parsing the command line options and reading the input file, it is even possible that the parameters on the command line overwrite the parameters in the input file.

The input file has a C-like syntax. You can derive the structure from the following example:

string  title   "testing blending maps"
string  author    "Philipp Frauenfelder, 2001"
 
int level   1
int polynomial  15
 
// Viertelkreis
// string uex "(y*(1-x)*(x-y))"
// string fex "(-(-2+2*x-2*y+(-1+x)*(x-y)*y))"
 
// Dreieck (0,-1), (1,0), (0,1)
string  uex "(x*(1-x-y)*(x-1-y))"
string  fex "(-4 + 4*x + x*(1 - x - y)*(-1 + x - y))"
 
array string bcform {
  1 "(0)"
        2       "(1)"
}
 
// 0 means FREE, 1 means DIRICHLET, 2 means NEUMANN
array int bctype {
  1 1
        2       2
}
 
string  meshouteps  "blendmesh.eps"
string  meshoutdx "blendmesh.dx"
string  dataoutnumeric  "blendnumeric.data"
 
string  parameterout  "blendoutput2.concepts"
 
double  a   1.0 /* just a parameter */
bool  subdivide false 

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 results section for an example.

Commented Program

First we have to import certain modules from the libconceptspy package and other required python modules.

from libconceptspy import concepts
import sys 
import argparse

All code in this example is in one large routine, the main program.

def main(args,argv):

Some default values for the parameters used. l and p are just two variables. If debug is set to true, more information is printed to screen.

    l = 0
    p = 1
    debug = False

First, set up the input parameter class: some parameters are set up with a default value.

    inp = concepts.InputParser(True)
    inputParameters = concepts.InOutParameters()
    inputParameters = inp.inputParameters()
    inputParameters.addInt('level',l)
    inputParameters.addInt('polynomial',p)
    inputParameters.addBool('debug',debug)
    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.

    outputParameters = concepts.InOutParameters()

Prepare an array for values computed later. This array is then added to table which is able to nicely format the content of the different arrays (e.g. for later processing with Gnuplot).

    outputParameters.addArrayDouble("error")
    table = concepts.ResultsTable()
    table.addMap(concepts.ResultsTable.DOUBLE, "error", outputParameters)
 
    inputfile = ''

Command Line Parsing

Here, we start with the command line parsing.

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() 

Enter -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 -f, the values in the file can be overridden with additional command line arguments after -f.

    if (len(argv)>1):
      if args.l:
        inputParameters.addInt("level",args.l)
      if args.p:
        inputParameters.addInt("polynomial",args.p)
      if args.f:
        inputfile = args.f
        inp.parse(inputfile)
      if args.d:
        inputParameters.addBool('debug', True)

If there is an error reading the input file, then an exception error message is returned.

  except RuntimeError:
    print("Input file not found.Cannot open input file.")

Print the parameters to show the user what is going on.

    print('['+argv[0]+']')
    print('--')
    print('Parameters:')
    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.

    l = inputParameters.getInt('level')
    p = inputParameters.getInt('polynomial')

Computations

Here are some dummy computations to fill the output area with content.

    outputParameters.addInt("nelm", 10)
    for i in range(10):
      outputParameters.addArrayDouble("error",i,1.0/(1<<i))

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.

    print 'Writing gathered data to disk: ',inputParameters.getString("parameterout")
 
    filename = inputParameters.getString("parameterout")
    ofile = open(filename,'w')
    ofile.write("/* program:\t %s \n * command:\t " % (argv[0]))
    for i in range(0,len(argv)):
      ofile.write(argv[i]+ " ")
 
    ofile.write("\n * inputfile:\t %s \n" % (inputfile))
    ofile.write(" */ \n")
    ofile.write(str(inp))
    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.

    print(table)
    gnu_file = open("inputoutput.gnuplot",'w')
    gnu_file.write(str(table))
    gnu_file.close()

Results

The output of the program called without parameters:

[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
) 

The program creates the following output files:

• inputoutput.out:

  /* 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
  } 

• inputoutput.gnuplot:

  # 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 

Note the 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

from libconceptspy import concepts
import sys 
import argparse
 
def main(args,argv):
  try:
    l = 0
    p = 1
    debug = False
 
    
    inp = concepts.InputParser(True)
    inputParameters = concepts.InOutParameters()
    inputParameters = inp.inputParameters()
    inputParameters.addInt('level',l)
    inputParameters.addInt('polynomial',p)
    inputParameters.addBool('debug',debug)
    inputParameters.addString('parameterout',"inputoutput.out")
    
    outputParameters = concepts.InOutParameters()
    outputParameters = inp.outputParameters()
    outputParameters.addArrayDouble("error")
    table = concepts.ResultsTable()
    table.addMap(concepts.ResultsTable.DOUBLE, "error", outputParameters)
 
    inputfile = ''
    
    if (len(argv)>1):
      if args.l:
        inputParameters.addInt("level",args.l)
      if args.p:
        inputParameters.addInt("polynomial",args.p)
      if args.f:
        inputfile = args.f
        inp.parse(inputfile)
      if args.d:
        inputParameters.addBool('debug', True)
  except RuntimeError:
    print("Input file not found.Cannot open input file.")
  else:   
    
    print('['+argv[0]+']')
    print('--')
    print('Parameters:')
    print('  input file = %s\n%s'%(inputfile,inputParameters))
    print('--')
 
    l = inputParameters.getInt('level')
    p = inputParameters.getInt('polynomial')
 
    
    outputParameters.addInt("nelm", 10)
    for i in range(10):
      outputParameters.addArrayDouble("error",i,1.0/(1<<i))
 
 
    
    print('--')
    print 'Writing gathered data to disk: ',inputParameters.getString("parameterout")
 
    filename = inputParameters.getString("parameterout")
    ofile = open(filename,'w')
    ofile.write("/* program:\t %s \n * command:\t " % (argv[0]))
    for i in range(0,len(argv)):
      ofile.write(argv[i]+ " ")
 
    ofile.write("\n * inputfile:\t %s \n" % (inputfile))
    ofile.write(" */ \n")
    ofile.write(str(inp))
    ofile.close()
    print(table)
    gnu_file = open("inputoutput.gnuplot",'w')
    gnu_file.write(str(table))
    gnu_file.close()
 
if __name__ == "__main__":
  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()
  main(args,sys.argv)