How to split data block in Fortran?

Question

I need to count number of lines in each block and count number of blocks in order to read it properly afterwards. Can anybody suggest a sample piece of code in Fortran?

My input file goes like this:

# Section 1 at 50%    (Name of the block and its number and value)

1 2 3                 (Three numbers in line with random number of lines)

...

1 2 3

# Section 2 at 100% (And then again Name of the block)

1 2 3... 

and so on.

The code goes below. It works fine with 1 set of data, but when it meets " # " again it just stops providing data only about one section. Can not jump to another section:

  integer IS, NOSEC, count

    double precision SPAN

    character(LEN=100):: NAME, NAME2, AT

    real whatever

 101   read (10,*,iostat=ios) NAME, NAME2, IS, AT, SPAN

       if (ios/=0) go to 200

       write(6,*) IS, SPAN

       count = 0

  102         read(10,*,iostat=ios) whatever

       if (ios/=0) go to 101

       count = count + 1

       write(6,*) whatever

       go to 102

200      write(6,*) 'Section span =', SPAN

So the first loop (101) suppose to read parameters of the Block and second (102) counts the number of lines in block with 'ncount' as the only parameter which is needed. However, when after 102 it suppose to jump back to 101 to start a new block, it just goes to 200 instead (printing results of the operation), which means it couldn't read the data about second block.

Answer 1

Let's say your file contains two valid types of lines:

• Block headers which begin with '#, and
• Data lines which begin with a digit 0 through 9

Let's add further conditions:

• Leading whitespace is ignored,
• Lines which don't match the first two patterns are considered comments and are ignored
• Comment lines do not terminate a block; blocks are only terminated when a new block is found or the end of the file is reached,
• Data lines must follow a block header (the first non-comment line in a file must be a block header),
• Blocks may be empty, and
• Files may contain no blocks

You want to know the number of blocks and how many data lines are in each block but you don't know how many blocks there might be. A simple dynamic data structure will help with record-keeping. The number of blocks may be counted with just an integer, but a singly-linked list with nodes containing a block ID, a data line count, and a pointer to the next node will gracefully handle an arbitrarily large blob of data. Create a head node with ID = 0, a data line count of 0, and the pointer nullify()'d.

The Fortran Wiki has a pile of references on singly-linked lists: http://fortranwiki.org/fortran/show/Linked+list

Since the parsing is simple (e.g. no backtracking), you can process each line as it is read. Iterate over the lines in the file, use adjustl() to dispose of leading whitespace, then check the first two characters: if they are '#, increment your block counter by one and add a new node to the list and set its ID to the value of the block counter (1), and process the next line.

Aside: I have a simple character function called munch() which is just trim(adjustl()). Great for stripping whitespace off both ends of a string. It doesn't quite act like Perl's chop() or chomp() and Fortran's trim() is more of an rtrim() so munch() was the next best name.

If the line doesn't match a block header, check if the first character is a digit; index('0123456789', line(1:1)) is greater than zero if the the first character of line is a digit, otherwise it returns 0. Increment the data line count in the head node of the linked list and go on to process the next line.

Note that if the block count is zero, this is an error condition; write out a friendly "Data line seen before block header" error message with the last line read and (ideally) the line number in the file. It takes a little more effort but it's worth it from the user's standpoint, especially if you're the main user.

Otherwise if the line isn't a block header or a data line, process the next line.

Eventually you'll hit the end of the file and you'll be left with the block counter and a linked list that has at least one node. Depending on how you want to use this data later, you can dynamically allocate an array of integers the length of the block counter, then transfer the data line count from the linked list to the array. Then you can deallocate the linked list and get direct access to the data line count for any block because the block index matches the array index.

I use a similar technique for reading arbitrarily long lists of data. The singly-linked list is extremely simple to code and it avoids the irritation of having to reallocate and expand a dynamic array. But once the amount of data is known, I carve out a dynamic array the exact size I need and copy the data from the linked list so I can have fast access to the data instead of needing to walk the list all the time.

Since Fortran doesn't have a standard library worth mentioning, I also use a variant of this technique with an insertion sort to simultaneously read and sort data.

So sorry, no code but enough to get you started. Defining your file format is key; once you do that, the parser almost writes itself. It also makes you think about exceptional conditions: data before block header, how you want to treat whitespace and unrecognized input, etc. Having this clearly written down is incredibly helpful if you're planning on sharing data; the Fortran world is littered with poorly-documented custom data file formats. Please don't add to the wreckage...

Finally, if you're really ambitious/insane, you could write this as a recursive routine and make your functional programming friends' heads explode. :)