In looking to merge MARCS with DSEP, it is immediately clear that the two codes are incompatible when it comes to passing variables. MARCS is written with single precision declarations for real variables and DSEP is written with double precision declarations. Type conversions can be carried out in several different ways, but perhaps it is worth upgrading MARCS to double precision. However, while it is simple enough to redefine real declarations to real(dp), where dp is a double precision type declaration, there are many instances of hard coded single precision variables. That is, variables defined with X.XeYYY instead of X.XdYYY. Finding such declarations is non-trivial.
In [1]:
import fileinput as fi
An initial attempt to extract all instances of hard coded single precision real variables was done using grep and a regular expression,
grep -i "[0-9].e.[0-9]" *.f > marcs_single_precision.txt
where -i flags the result to be case insensitive. Let's read in the result.
In [2]:
single_precision_vars = [line.rstrip('\n') for line in fi.input('marcs_single_precision.txt')]
Take a quick look at the first few lines,
In [3]:
print single_precision_vars[:5]
Everything looks reasonble, but I know for a fact that scientific notation can also be declared in FORMAT statements. Therefore, it's necessary to remove these from the entry list.
In [4]:
single_precision_vars = [line for line in single_precision_vars if line.lower().find('format') == -1]
Make sure we haven't removed valid entries, as compared to the initial output.
In [5]:
print single_precision_vars[:5]
We can now organize the data by subroutine and output the lines on which a single precision real is expcted to occur. There will be false positives, but those can be checked by eye.
In [6]:
file_stream = open('single_precision_index.txt', 'w')
routine = ''
for line in single_precision_vars:
line = line.split(':')
if line[0] == routine:
file_stream.write('\t{:4s} :: {:50s}\n'.format(line[1].strip(), line[2].strip()))
else:
routine = line[0]
file_stream.write('\n\n{:s}\n\n'.format(line[0].rstrip('.f').upper()))
file_stream.write('\t{:4s} :: {:70s}\n'.format(line[1].strip(), line[2].strip()))
file_stream.close()
Markdown is also a helpful format.
In [7]:
file_stream = open('single_precision_index.md', 'w')
routine = ''
for line in single_precision_vars:
line = line.split(':')
if line[0] == routine:
file_stream.write('\t{:4s} :: {:50s}\n'.format(line[1].strip(), line[2].strip()))
else:
routine = line[0]
file_stream.write('\n\n# {:s}\n\n'.format(line[0].rstrip('.f').upper()))
file_stream.write('\t{:4s} :: {:70s}\n'.format(line[1].strip(), line[2].strip()))
file_stream.close()
Changing these can be done by a single person, but would perhaps benefit from multiple editors working on a subset of the declarations.
In [8]:
print "There are {:.0f} lines that need editing.".format(len(single_precision_vars))
Which means that, split among 3 people, it's approximately 96 lines of code per person. There are some routines that contain significantly more lines that require editing, as compared to others. We can create a histogram showing number of lines per subroutine.
In [9]:
N_lines = []
routine = ''
n = 0
for line in single_precision_vars:
line = line.split(':')
if line[0] == routine:
n += 1
else:
# output previous routine count
N_lines.append([routine, n])
n = 0
# start a new routine
routine = line[0]
n += 1
N_lines.pop(0)
Out[9]:
Now we should aim to sort and then distribute routines to be modified.
In [10]:
N_lines = sorted(N_lines, key = lambda routine: routine[1])
In [11]:
print N_lines
print "\n \t There are {:.0f} subroutines that need editing.".format(len(N_lines))
This is not too unreasonable for a single person, but additional checking for single precision declarations and functions would be beneficial. This requires that we also consider the total number of lines in each file that needs to be edited.
In [12]:
lines_in_routines = [line.split() for line in fi.input('marcs_routines_nlines.txt')]
In [13]:
lines_in_routines = [[x[1], int(x[0])] for x in lines_in_routines]
We now have a record for number of single precision statements to be changed and the number of lines in the entire routine.
In [14]:
total_lines = []
for routine in lines_in_routines:
n_edits = [x[1] for x in N_lines if x[0] == routine[0]]
if n_edits == []:
n_edits = 0
else:
n_edits = int(n_edits[0])
total_lines.append([routine[0], routine[1] + n_edits])
In [15]:
total_lines = sorted(total_lines, key = lambda routine: routine[1])
We've now combined the total number of lines in each file with the number of edits to fixed single precision constants that need to be made. Of course, there are instances where function calls need to be verified, but one expects this is somewhat proportional to the number of lines in the entire file.
In [16]:
print "\t There are {:.0f} subroutines that need checking.".format(len(total_lines))
If divided equally, that means each of 3 people will need to check 26 separate subroutines. However, these should we weighted so that each person searches roughly the same number of routines and the same number of lines.
In [18]:
person_1 = []
person_2 = []
person_3 = []
person_4 = []
for i, routine in enumerate(total_lines):
if i % 4 == 0:
person_1.append(routine)
elif i % 4 == 1:
person_2.append(routine)
elif i % 4 == 2:
person_3.append(routine)
elif i % 4 == 3:
person_4.append(routine)
else:
print "Whoops, misplaced", routine
Now, let's confirm that everything looks about equal.
In [19]:
print len(person_1), len(person_2), len(person_3), len(person_4)
and the number of lines of code
In [20]:
for person in [person_1, person_2, person_3, person_4]:
print sum([x[1] for x in person])
So that didn't work out quite as well as I had anticipated. Certainly person 2 will have considerably more work cut out for them, of order 1400 lines of code.
Looking at the routines in each set, it's possible to even up the 1st and 3rd sets in terms of lines of code by switching one entry with approx. 150 lines of code.
In [24]:
print person_1
print
print person_2
print
print person_3
print
print person_4
In [26]:
person_2.append(person_4.pop(-5))
Now, trying this again,
In [27]:
for person in [person_1, person_2, person_3, person_4]:
print sum([x[1] for x in person])
Much better!
From these lists, we can create simple markdown and text file to-do lists for each person.
In [33]:
for i, person in enumerate([person_1, person_2, person_3, person_4]):
text_stream = open('Person_{:02.0f}.txt'.format(i + 1), 'w')
mark_stream = open('Person_{:02.0f}.md'.format(i + 1), 'w')
for routine in person:
s = '{:20s} :: {:4.0f} lines \n'.format(routine[0], routine[1])
text_stream.write(s)
mark_stream.write('### ' + s)
text_stream.close()
mark_stream.close()
In [ ]: