File Handling in Fortran

File handling is a fundamental part of programming that allows a program to read from and write to files. Fortran, being a powerful scientific and engineering programming language, provides robust support for file operations. These operations include opening files, reading data, writing data, and closing files. Proper file handling ensures data persistence, reusability, and efficient program workflows.

1. Introduction to File Handling

In programming, a file is a container that stores data permanently on a storage device. Unlike variables stored in memory, file contents remain available even after a program terminates. File handling involves performing operations such as creating, reading, updating, and deleting files.

Fortran provides a simple and structured way to handle files using the open, read, write, and close statements. Files can be either text files, containing readable characters, or binary files, containing raw data.

---

2. Opening Files

Before a file can be read from or written to, it must be opened using the open statement. The syntax is:

open(unit=unit_number, file='filename', status='status_option', action='action_option', iostat=iostat_variable)

Explanation of Parameters:

• unit: An integer that represents a file unit number. Fortran uses this number to refer to the file.
• file: The name of the file you want to open.
• status: Defines the file’s existence condition. Options include:
  • 'old' – file must already exist.
  • 'new' – file must not exist; a new file will be created.
  • 'replace' – replaces the file if it exists.
  • 'unknown' – file may or may not exist.
• action: Specifies allowed operations: 'read', 'write', or 'readwrite'.
• iostat: Optional variable to detect errors when opening the file.

Example:

integer :: unit, ios
unit = 10
open(unit=unit, file='data.txt', status='unknown', action='write', iostat=ios)
if (ios /= 0) then
print *, "Error opening file"
end if

This code opens a file data.txt for writing and handles any error during the opening process.

---

3. Writing to Files

After opening a file for writing, data can be written using the write statement. The basic syntax is:

write(unit, format) variable_list

• unit is the file unit number used in the open statement.
• format specifies the output format; * can be used for default formatting.
• variable_list is the data to be written.

Example:

integer :: unit
unit = 10
open(unit=unit, file='data.txt', status='unknown')
write(unit,*) "Hello File!"
write(unit,*) 42, 3.14159
close(unit)

Explanation:

• The file data.txt is opened for writing.
• A string "Hello File!" is written, followed by an integer and a real number.
• The file is then closed.

Writing to files is essential for saving program outputs, logging events, or storing intermediate calculations for later use.

---

4. Reading from Files

To read data from a file, the file must first be opened with the read permission. The read statement is used to fetch data from a file.

Syntax:

read(unit, format) variable_list

Example:

integer :: unit, num
open(unit=10, file='data.txt', status='old', action='read')
read(10,*) num
print *, "Read number from file:", num
close(10)

Explanation:

• The file data.txt is opened for reading.
• The first value in the file is read into the variable num.
• The value is printed to the screen.

Reading from files allows programs to process external data, making them dynamic and adaptable.

---

5. Using Loops to Read Multiple Lines

Often, files contain multiple lines of data. A loop can be used to read each line sequentially.

Example:

integer :: unit, num, ios
open(unit=10, file='numbers.txt', status='old', action='read', iostat=ios)
if (ios /= 0) then
print *, "Error opening file"
end if

do
read(10,*,iostat=ios) num
if (ios /= 0) exit
print *, num
end do

close(10)

Explanation:

• The loop continues reading integers from the file until the end of file is reached (iostat becomes non-zero).
• Each integer is printed to the screen.

This approach is commonly used for reading datasets, logs, or simulation results from files.

---

6. Closing Files

Closing a file is a crucial step to ensure that all data is properly written and resources are freed. The close statement is used for this purpose.

Syntax:

close(unit)

Example:

integer :: unit
unit = 10
open(unit=unit, file='data.txt', status='unknown')
write(unit,*) "Hello File!"
close(unit)

Explanation:

• The close statement ensures the file is saved correctly and can be accessed by other programs.
• Neglecting to close files may result in data loss or file corruption.

---

7. File Status and Error Handling

Fortran provides mechanisms to check file status and handle errors effectively.

• iostat: Captures the status of file operations. Non-zero value indicates an error.
• existence check: Using status='old' or 'new' ensures the program behaves correctly based on the file’s presence.

Example:

integer :: unit, ios
unit = 10
open(unit=unit, file='data.txt', status='old', action='read', iostat=ios)
if (ios /= 0) then
print *, "File does not exist"
else
print *, "File opened successfully"
end if
close(unit)

Error handling is critical for robust programs that interact with external files, especially when user input or external datasets are involved.

---

8. Appending Data to Files

Instead of overwriting, you may want to add new data to an existing file. This is achieved using position='append'.

Example:

integer :: unit
unit = 10
open(unit=unit, file='data.txt', status='old', position='append')
write(unit,*) "Adding another line"
close(unit)

Explanation:

• The position='append' option ensures that new data is added at the end of the file rather than replacing existing content.

---

9. File Formats

Fortran supports multiple ways to format file data:

1. Unformatted Files (Binary)
   • Stored as raw binary data.
   • Efficient for large datasets.
   • Example: integer :: unit, num unit = 10 open(unit=unit, file='binary.dat', form='unformatted', status='unknown') num = 12345 write(unit) num close(unit)
2. Formatted Files (Text)
   • Human-readable text format.
   • Can use * for default formatting or specify formats.
   • Example: integer :: unit, num unit = 10 open(unit=unit, file='text.txt', status='unknown') num = 123 write(unit, '(I5)') num close(unit)

Choosing the appropriate format depends on whether readability or performance is prioritized.

---

10. Reading and Writing Arrays

Fortran allows reading and writing arrays directly, which is useful for scientific calculations and data analysis.

Example:

integer :: unit, i
integer, dimension(5) :: arr = (/1,2,3,4,5/)
unit = 10
open(unit=unit, file='array.txt', status='unknown')
write(unit,*) arr
close(unit)

open(unit=unit, file='array.txt', status='old')
read(unit,*) arr
close(unit)

do i=1,5
print *, arr(i)
end do

Explanation:

• The array arr is written to array.txt.
• The array is then read back and printed.

Array operations with files are crucial for handling large datasets efficiently.

---

11. Real-World Applications

1. Logging Program Execution: Storing logs for debugging or auditing.
2. Data Analysis: Reading datasets from files and performing computations.
3. Simulation Outputs: Storing results from simulations for later visualization.
4. Configuration Files: Reading input parameters from files to customize program behavior.

Example of reading multiple parameters:

integer :: a, b
open(unit=10, file='config.txt', status='old')
read(10,*) a, b
print *, "Parameter A:", a
print *, "Parameter B:", b
close(10)

---

12. Best Practices in File Handling

1. Always close files after operations to prevent corruption.
2. Use iostat to detect errors while opening, reading, or writing files.
3. Use formatted files for readability and unformatted for performance.
4. Avoid hardcoding filenames; use variables for flexibility.
5. For large files, consider reading/writing in chunks rather than loading the entire file into memory.