ComputerAlgebra/Ccodeconversion.py at main · MarcusHatton/ComputerAlgebra · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Tue Jul 20 16:56:56 2021

@author: mjh1n20
"""

from sympy import *
import numpy as np

# Read in the algebra in sympy form from file
svs_str = [["" for i in range(4)] for j in range(5)]
fvs_str = [[["" for i in range(4)] for j in range(5)] for k in range(3)]
LO_str = ["" for i in range(13)]
infile = open('ISFullOutput.txt','r')

# Read first line which is text
print(infile.readline())
# Read in state vector components
for i in range(5):
    for j in range(4):
        svs_str[i][j] = str(infile.readline())

# Another line of flex before the flux vector
print(infile.readline())
# Read in flux vector components
for i in range(3):
    for j in range(5):
        for k in range(4):
            fvs_str[i][j][k] = str(infile.readline())

# Another line of text before LO CE Correction expressions
print(infile.readline())
for i in range(13):
    LO_str[i] = str(infile.readline())

infile.close()

# Use string replacement to get C++ style expressions for the state & flux vectors
func_of = '(t, x, y, z)'
components = ', i, j, k)]'
prim_vars = ['v1', 'v2', 'v3', 'p', 'n', 'rho']
diss_vars = ['q1', 'q2', 'q3', 'Pi', 'pi11', 'pi12', 'pi13', 'pi21', 'pi22', 'pi23', 'pi31', 'pi32', 'pi33']
diss1s = ['q1LO', 'q2LO', 'q3LO', 'PiLO', 'pi11LO', 'pi12LO', 'pi13LO', 'pi21LO', 'pi22LO', 'pi23LO', 'pi31LO', 'pi32LO', 'pi33LO']
aux_vars = ['T', 'W', 'qv', 'pi00', 'pi01', 'pi02', 'pi03']
dissNSs = ['q1NS', 'q2NS', 'q3NS', 'PiNS', 'pi11NS', 'pi12NS', 'pi13NS', 'pi21NS', 'pi22NS', 'pi23NS', 'pi31NS', 'pi32NS', 'pi33NS']
for i in range(5):
    for j in range(4):
        #print(svs_str[i][j])
        for prim_var in prim_vars:
            svs_str[i][j] = svs_str[i][j].replace(str(prim_var)+func_of,'prims[ID(Prims::'+str(prim_var)+components)
            for k in range(3):
                fvs_str[k][i][j] = fvs_str[k][i][j].replace(str(prim_var)+func_of,'prims[ID(Prims::'+str(prim_var)+components)


        for diss_var in diss_vars:
            svs_str[i][j] = svs_str[i][j].replace(str(diss_var)+func_of,'prims[ID(Prims::'+str(diss_var)+components)
            for k in range(3):
                fvs_str[k][i][j] = fvs_str[k][i][j].replace(str(diss_var)+func_of,'prims[ID(Prims::'+str(diss_var)+components)

        for aux_var in aux_vars:
            svs_str[i][j] = svs_str[i][j].replace(str(aux_var)+func_of,'aux[ID(Aux::'+str(aux_var)+components)
            for k in range(3):
                fvs_str[k][i][j] = fvs_str[k][i][j].replace(str(aux_var)+func_of,'aux[ID(Aux::'+str(aux_var)+components)

        for dissNS in dissNSs:
            svs_str[i][j] = svs_str[i][j].replace(str(dissNS)+func_of,'aux[ID(Aux::'+str(dissNS)+components)
            for k in range(3):
                fvs_str[k][i][j] = fvs_str[k][i][j].replace(str(dissNS)+func_of,'aux[ID(Aux::'+str(dissNS)+components)

        for diss1 in diss1s:
            svs_str[i][j] = svs_str[i][j].replace(str(diss1)+func_of,'aux[ID(Aux::'+str(diss1)+components)
            for k in range(3):
                fvs_str[k][i][j] = fvs_str[k][i][j].replace(str(diss1)+func_of,'aux[ID(Aux::'+str(diss1)+components)

for i in range(13):
    for prim_var in prim_vars:
        LO_str[i] = LO_str[i].replace(str(prim_var)+func_of,'prims[ID(Prims::'+str(prim_var)+components)
        LO_str[i] = LO_str[i].replace('Derivative(prims[ID(Prims::'+str(prim_var)+components+', x)', \
                                      '((prims[ID(Prims::'+str(prim_var)+', i+1, j, k)] - prims[ID(Prims::'+str(prim_var)+', i-1, j, k)])/(d->dx))')
        LO_str[i] = LO_str[i].replace('Derivative(prims[ID(Prims::'+str(prim_var)+components+', y)', \
                                      '((prims[ID(Prims::'+str(prim_var)+', i, j+1, k)] - prims[ID(Prims::'+str(prim_var)+', i, j-1, k)])/(d->dy))')
        LO_str[i] = LO_str[i].replace('Derivative(prims[ID(Prims::'+str(prim_var)+components+', z)', \
                                      '((prims[ID(Prims::'+str(prim_var)+', i, j, k+1)] - prims[ID(Prims::'+str(prim_var)+', i, j, k-1)])/(d->dz))')
        LO_str[i] = LO_str[i].replace('Derivative(prims[ID(Prims::'+str(prim_var)+components+', t)', \
                                      'tderivs[ID(TDerivs::dt'+str(prim_var)+', i, j, k)]')


    for diss_var in diss_vars:
        LO_str[i] = LO_str[i].replace(str(diss_var)+func_of,'prims[ID(Prims::'+str(diss_var)+components)
        LO_str[i] = LO_str[i].replace('Derivative(prims[ID(Prims::'+str(diss_var)+components+', x)', \
                                      '((prims[ID(Prims::'+str(diss_var)+', i+1, j, k)] - prims[ID(Prims::'+str(diss_var)+', i-1, j, k)])/(d->dx))')
        LO_str[i] = LO_str[i].replace('Derivative(prims[ID(Prims::'+str(diss_var)+components+', y)', \
                                      '((prims[ID(Prims::'+str(diss_var)+', i, j+1, k)] - prims[ID(Prims::'+str(diss_var)+', i, j-1, k)])/(d->dy))')
        LO_str[i] = LO_str[i].replace('Derivative(prims[ID(Prims::'+str(diss_var)+components+', z)', \
                                      '((prims[ID(Prims::'+str(diss_var)+', i, j, k+1)] - prims[ID(Prims::'+str(diss_var)+', i, j, k-1)])/(d->dz))')
        LO_str[i] = LO_str[i].replace('Derivative(prims[ID(Prims::'+str(diss_var)+components+', t)', \
                                      'tderivs[ID(TDerivs::dt'+str(diss_var)+', i, j, k)]')

    for aux_var in aux_vars:
        LO_str[i] = LO_str[i].replace(str(aux_var)+func_of,'aux[ID(Aux::'+str(aux_var)+components)
        LO_str[i] = LO_str[i].replace('Derivative(aux[ID(Aux::'+str(aux_var)+components+', x)', \
                                      '((aux[ID(Aux::'+str(aux_var)+', i+1, j, k)] - aux[ID(Aux::'+str(aux_var)+', i-1, j, k)])/(d->dx))')
        LO_str[i] = LO_str[i].replace('Derivative(aux[ID(Aux::'+str(aux_var)+components+', y)', \
                                      '((aux[ID(Aux::'+str(aux_var)+', i, j+1, k)] - aux[ID(Aux::'+str(aux_var)+', i, j-1, k)])/(d->dy))')
        LO_str[i] = LO_str[i].replace('Derivative(aux[ID(Aux::'+str(aux_var)+components+', z)', \
                                      '((aux[ID(Aux::'+str(aux_var)+', i, j, k+1)] - aux[ID(Aux::'+str(aux_var)+', i, j, k-1)])/(d->dz))')
        LO_str[i] = LO_str[i].replace('Derivative(aux[ID(Aux::'+str(aux_var)+components+', t)', \
                                      'tderivs[ID(TDerivs::dt'+str(aux_var)+', i, j, k)]')
    for dissNS in dissNSs:
        LO_str[i] = LO_str[i].replace(str(dissNS)+func_of,'aux[ID(Aux::'+str(dissNS)+components)
        LO_str[i] = LO_str[i].replace('Derivative(aux[ID(Aux::'+str(dissNS)+components+', x)', \
                                      '((aux[ID(Aux::'+str(dissNS)+', i+1, j, k)] - aux[ID(Aux::'+str(dissNS)+', i-1, j, k)])/(d->dx))')
        LO_str[i] = LO_str[i].replace('Derivative(aux[ID(Aux::'+str(dissNS)+components+', y)', \
                                      '((aux[ID(Aux::'+str(dissNS)+', i, j+1, k)] - aux[ID(Aux::'+str(dissNS)+', i, j-1, k)])/(d->dy))')
        LO_str[i] = LO_str[i].replace('Derivative(aux[ID(Aux::'+str(dissNS)+components+', z)', \
                                      '((aux[ID(Aux::'+str(dissNS)+', i, j, k+1)] - aux[ID(Aux::'+str(dissNS)+', i, j, k-1)])/(d->dz))')
        LO_str[i] = LO_str[i].replace('Derivative(aux[ID(Aux::'+str(dissNS)+components+', t)', \
                                      'tderivs[ID(TDerivs::dt'+str(dissNS)+', i, j, k)]')


state_vec = ['D', 'Sx', 'Sy', 'Sz', 'E']

outfile = open('CcodeOutput.txt','w')

outfile.write('STATE VECTOR STARTS\n')
for i in range(5):
    outfile.write('\n'+state_vec[i]+'\n')
    for j in range(4):
        outfile.write(svs_str[i][j].replace('aux[ID(Aux::W, i, j, k)]**2','sqr(aux[ID(Aux::W, i, j, k)])')\
                      .replace('prims[ID(Prims::vx, i, j, k)]**2','sqr(prims[ID(Prims::vx, i, j, k)])')\
                      .replace('prims[ID(Prims::vy, i, j, k)]**2','sqr(prims[ID(Prims::vy, i, j, k)])')\
                      .replace('prims[ID(Prims::vz, i, j, k)]**2','sqr(prims[ID(Prims::vz, i, j, k)])'))


dirs = ['x', 'y', 'z']
outfile.write('\nFLUX VECTOR STARTS \n')
for i in range(3):
    outfile.write(dirs[i]+'\n')
    for j in range(5):
        outfile.write(state_vec[j]+'\n')
        for k in range(4):
            outfile.write(fvs_str[i][j][k].replace('aux[ID(Aux::W, i, j, k)]**2','sqr(aux[ID(Aux::W, i, j, k)])')\
                      .replace('prims[ID(Prims::vx, i, j, k)]**2','sqr(prims[ID(Prims::vx, i, j, k)])')\
                      .replace('prims[ID(Prims::vy, i, j, k)]**2','sqr(prims[ID(Prims::vy, i, j, k)])')\
                      .replace('prims[ID(Prims::vz, i, j, k)]**2','sqr(prims[ID(Prims::vz, i, j, k)])'))
        outfile.write('\n')
    outfile.write('\n')

outfile.write('\nDiss LO Corrections START'+'\n')
for i in range(13):
    outfile.write('aux[ID(Aux::'+diss1s[i]+components+' = '+LO_str[i].replace('aux[ID(Aux::W, i, j, k)]**2','sqr(aux[ID(Aux::W, i, j, k)])')\
                      .replace('prims[ID(Prims::vx, i, j, k)]**2','sqr(prims[ID(Prims::vx, i, j, k)])')\
                      .replace('prims[ID(Prims::vy, i, j, k)]**2','sqr(prims[ID(Prims::vy, i, j, k)])')\
                      .replace('prims[ID(Prims::vz, i, j, k)]**2','sqr(prims[ID(Prims::vz, i, j, k)])'))
    outfile.write('\n')

outfile.close()