|
| 1 | +--- |
| 2 | +title: "Running code from the Linux Command Line" |
| 3 | +teaching: 15 |
| 4 | +exercises: 10 |
| 5 | +alternate: true |
| 6 | +questions: |
| 7 | +- "How do I move my code from the interactive Jupyter notebook to run from the Linux command line?" |
| 8 | +- "How do I make simple Python scripts with user inputs using sys.argv?" |
| 9 | +objectives: |
| 10 | +- "Make code executable from the Linux command line." |
| 11 | +- "Use sys.argv() to accept user inputs." |
| 12 | +keypoints: |
| 13 | +- "You must `import sys` in your code to accept user arguments." |
| 14 | +- "The name of the script itself is always `sys.argv[0]` so the first user input is normally `sys.argv[1]`." |
| 15 | +--- |
| 16 | +## Creating and running a python input file |
| 17 | + |
| 18 | +We are now going to move our geometry analysis code out of the Jupyter notebook and into a format that can be run from the Linux command line. Open your favorite text editor and create a new file called "geom_analysis.py" (or choose another filename, just make sure the extension is .py). Paste in your geometry analysis code (the version with your functions) from your jupyter notebook and save your file. |
| 19 | + |
| 20 | +The best practice is to put all your functions at the top of the file, right after your import statements. Your file will look something like this. |
| 21 | +``` |
| 22 | +import numpy |
| 23 | +import os |
| 24 | +
|
| 25 | +def calculate_distance(atom1_coord, atom2_coord): |
| 26 | + x_distance = atom1_coord[0] - atom2_coord[0] |
| 27 | + y_distance = atom1_coord[1] - atom2_coord[1] |
| 28 | + z_distance = atom1_coord[2] - atom2_coord[2] |
| 29 | + bond_length_12 = numpy.sqrt(x_distance**2+y_distance**2+z_distance**2) |
| 30 | + return bond_length_12 |
| 31 | +
|
| 32 | +def bond_check(atom_distance, minimum_length=0, maximum_length=1.5): |
| 33 | + if atom_distance > minimum_length and atom_distance <= maximum_length: |
| 34 | + return True |
| 35 | + else: |
| 36 | + return False |
| 37 | +
|
| 38 | +def open_xyz(filename): |
| 39 | + xyz_file = numpy.genfromtxt(fname=filename, skip_header=2, dtype='unicode') |
| 40 | + symbols = xyz_file[:,0] |
| 41 | + coord = (xyz_file[:,1:]) |
| 42 | + coord = coord.astype(numpy.float) |
| 43 | + return symbols, coord |
| 44 | +
|
| 45 | +file_location = os.path.join('data', 'water.xyz') |
| 46 | +symbols, coord = open_xyz(file_location) |
| 47 | +num_atoms = len(symbols) |
| 48 | +for num1 in range(0,num_atoms): |
| 49 | + for num2 in range(0,num_atoms): |
| 50 | + if num1<num2: |
| 51 | + bond_length_12 = calculate_distance(coord[num1], coord[num2]) |
| 52 | + if bond_check(bond_length_12) is True: |
| 53 | + print(F'{symbols[num1]} to {symbols[num2]} : {bond_length_12:.3f}') |
| 54 | +``` |
| 55 | +{: .language-python} |
| 56 | + |
| 57 | +Exit your text editor and go back to the command line. Now all you have to do to run your code is type |
| 58 | + |
| 59 | +``` |
| 60 | +$ python geom_analysis.py |
| 61 | +``` |
| 62 | +{: .language-bash} |
| 63 | +in your Terminal window. Your code should either print the output to the screen or write it to a file, depending on what you have it set up to do. (The code example given prints to the screen.) |
| 64 | + |
| 65 | +## Changing your code to accept user inputs |
| 66 | +In your current code, the name of the xyzfile to analyze, "water.xyz", is hardcoded; in order to change it, you have to open your code and change the name of the file that is read in. If you were going to use this code to analyze geometries in your research, you would probably want to be able to specify the name of the input file when you run the code, so that you don't have to change it every single time. These types of user inputs are called *arguments* and to make our code accept arguments, we have to import a new python library in our code. |
| 67 | + |
| 68 | +Open your geometry analysis code in your text editor and add this line at the top. |
| 69 | + |
| 70 | +~~~ |
| 71 | +import sys |
| 72 | +~~~ |
| 73 | +{: .language-python} |
| 74 | + |
| 75 | +Now that you have imported the `sys` library, you can use its functions. The library has a function called `sys.argv()` which creates a list of all the arguments the user enters at the command line. Everything after *python* is an argument, so `sys.argv[0]` is always the name of your script. We would like our code to accept the name of the xyz file we want to analyze as an argument. Add this line to your code. |
| 76 | +``` |
| 77 | +xyzfilename = sys.argv[1] |
| 78 | +``` |
| 79 | +{: .language-python} |
| 80 | + |
| 81 | +Then you need to go the part of your code where you read in the data from the xyz file and change the name of the file to read to `xyzfilename`. |
| 82 | +``` |
| 83 | +symbols, coord = open_xyz(xyzfilename) |
| 84 | +``` |
| 85 | +{: .language python} |
| 86 | + |
| 87 | +Save your code and go back to the Terminal window. Make sure you are in the directory where your code is saved and type |
| 88 | +``` |
| 89 | +$ python geom_analysis.py data/water.xyz |
| 90 | +``` |
| 91 | +Check that the output of your code is what you expected. |
| 92 | + |
| 93 | + |
| 94 | +What would happen if the user forgot to specify the name of the xyz file? The way the code is written now, it would give an error message. |
| 95 | +``` |
| 96 | +Traceback (most recent call last): |
| 97 | + File "geom_analysis.py", line 22, in <module> |
| 98 | + xyzfilename = sys.argv[1] |
| 99 | +IndexError: list index out of range |
| 100 | +``` |
| 101 | +{: .error} |
| 102 | +The reason it says the list index is out of range is because `sys.argv[1]` does not exist. Since the user forgot to specify the name of the xyz file, the `sys.argv` list only has one element, `sys.argv[0]`. It would be better to print an error message and let the user know that they didn't enter the input correctly. Our code is expecting exactly two inputs: the script name and the xyz file name. The easiest way to add an error message is to check the length of the sys.argv list and print an error message and exit if it does not equal the expected length. |
| 103 | + |
| 104 | +While you have practiced coding, you have probably seen many error messages. We can actually raise errors in our code and write error messages to our users. |
| 105 | +``` |
| 106 | +if len(sys.argv) < 2: |
| 107 | + raise NameError("Incorrect input! Please specify a file to analyze.") |
| 108 | +``` |
| 109 | +{: .language-python} |
| 110 | + |
| 111 | +This will exit the code and print our error message if the user does not specify a filename. |
| 112 | + |
| 113 | +There are different types of errors you can raise. For example, you may want to raise a `TypeError` if you have data that is not the right type. If you want to learn more about raising errors, [see the official documenation from Python](https://docs.python.org/3/tutorial/errors.html) |
| 114 | + |
| 115 | +We need to add one more thing to our code. When you write a code that includes function definitions and a main script, you need to tell python which part is the main script. (This becomes very important later when we are talking about testing.) *After* your import statements and function definitions and *before* you check the length of the `sys.argv` list add this line to your code. |
| 116 | +``` |
| 117 | +if __name__ == "__main__": |
| 118 | +``` |
| 119 | +{: .language-python} |
| 120 | + |
| 121 | +Since this is an `if` statement, you now need to indent each line of your main script below this if statement. Be very careful with your indentation! Don't use a mixture of tabs and spaces! |
| 122 | + |
| 123 | +Save your code and run it again. It should work exactly as before. If you now get an error message, it is probably due to inconsistent indentation. |
| 124 | + |
| 125 | +``` |
| 126 | +import os |
| 127 | +import numpy |
| 128 | +import sys |
| 129 | +
|
| 130 | +def calculate_distance(atom1_coord, atom2_coord): |
| 131 | + x_distance = atom1_coord[0] - atom2_coord[0] |
| 132 | + y_distance = atom1_coord[1] - atom2_coord[1] |
| 133 | + z_distance = atom1_coord[2] - atom2_coord[2] |
| 134 | + bond_length_12 = numpy.sqrt(x_distance**2+y_distance**2+z_distance**2) |
| 135 | + return bond_length_12 |
| 136 | +
|
| 137 | +def bond_check(atom_distance, minimum_length=0, maximum_length=1.5): |
| 138 | + if atom_distance > minimum_length and atom_distance <= maximum_length: |
| 139 | + return True |
| 140 | + else: |
| 141 | + return False |
| 142 | +
|
| 143 | +def open_xyz(filename): |
| 144 | + xyz_file = numpy.genfromtxt(fname=filename, skip_header=2, dtype='unicode') |
| 145 | + symbols = xyz_file[:,0] |
| 146 | + coord = (xyz_file[:,1:]) |
| 147 | + coord = coord.astype(numpy.float) |
| 148 | + return symbols, coord |
| 149 | +
|
| 150 | +
|
| 151 | +if __name__ == "__main__": |
| 152 | +
|
| 153 | + if len(sys.argv) < 2: |
| 154 | + raise NameError("Incorrect input! Please specify a file to analyze.") |
| 155 | +
|
| 156 | +
|
| 157 | + xyz_file = sys.argv[1] |
| 158 | + symbols, coord = open_xyz(xyz_file) |
| 159 | + num_atoms = len(symbols) |
| 160 | +
|
| 161 | + for num1 in range(0,num_atoms): |
| 162 | + for num2 in range(0,num_atoms): |
| 163 | + if num1<num2: |
| 164 | + bond_length_12 = calculate_distance(coord[num1], coord[num2]) |
| 165 | + if bond_check(bond_length_12) is True: |
| 166 | + print(F'{symbols[num1]} to {symbols[num2]} : {bond_length_12:.3f}') |
| 167 | +
|
| 168 | +``` |
| 169 | +{: .language-python} |
| 170 | + |
| 171 | +{% include links.md %} |
0 commit comments