Commit a0412b46 authored by Salko Jr, Robert's avatar Salko Jr, Robert
Browse files

Create autopep8 driver script and run autopep8 

Description:
This autoformats all files to pep8 standard and adds a convenience script
for running in the future.

CASL Ticket # - N/A
parent 673f06dc

SubKit/build/BoundaryCondition.py

+99 −95
Original line number Diff line number Diff line
@@ -7,6 +7,7 @@ class BoundaryCondition(object): 
    def __init__(me):

        pass





class MassEnthalpy(BoundaryCondition):

    """ Defines a mass flow rate/enthalpy BC.
@@ -29,6 +30,7 @@ class MassEnthalpy(BoundaryCondition): 
        me.mdotRamp = mdotRamp

        me.hRamp = hRamp





class MassTemperature(BoundaryCondition):

    """Defines a mass flow rate/temperature bc.
@@ -49,6 +51,7 @@ class MassTemperature(BoundaryCondition): 
        me.T = T

        me.mdotRamp = mdotRamp





class PressureEnthalpy(BoundaryCondition):

    """Defines a mass pressure/enthalpy boundary condition.
@@ -72,6 +75,7 @@ class PressureEnthalpy(BoundaryCondition): 
        me.pressureRamp = pressureRamp

        me.hRamp = hRamp





class PressureTemperature(BoundaryCondition):

    """Defines a mass pressure/temperature boundary condition.
@@ -91,6 +95,7 @@ class PressureTemperature(BoundaryCondition): 
        me.T = T

        me.pressureRamp = pressureRamp





class Mass(BoundaryCondition):

    """Defines a mass flow rate boundary condition.
@@ -107,4 +112,3 @@ class Mass(BoundaryCondition): 
        BoundaryCondition.__init__(me)

        me.mdot = mdot

        me.mdotRamp = mdotRamp

SubKit/build/CoreBuilder.py

+623 −601
Original line number Diff line number Diff line
@@ -13,7 +13,8 @@ import numpy as np 
import Model

import os

import sys

sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))

sys.path.insert(0, os.path.abspath(

    os.path.join(os.path.dirname(__file__), '..')))

import utils.utils as utils

import Solid

import Section
@@ -54,7 +55,8 @@ class Core(object): 
            for ls in row:

                obj = ls[1]

                if obj:

               coreRadius = max(coreRadius, utils.radialLocation(obj.x, obj.y))

                    coreRadius = max(

                        coreRadius, utils.radialLocation(obj.x, obj.y))



        return coreRadius
@@ -223,30 +225,33 @@ class MSRE(Core): 
            assert(len(rodDomains) == len(coreMap))

            assert(len(rodDomains[0]) == len(coreMap[0]))

            # Add a buffer layer around this map to be consistent with the buffer we'll put around the pin map

         _rodDomains = [[0 for x in range(len(rodDomains)+2)] for y in range(len(rodDomains)+2)]

            _rodDomains = [

                [0 for x in range(len(rodDomains) + 2)] for y in range(len(rodDomains) + 2)]

            for i, row in enumerate(rodDomains):

                for j, val in enumerate(row):

                    _rodDomains[i + 1][j + 1] = val

        else:

            # Model is not parallel, so just make all rods owned by domain 1

         _rodDomains = [[0 for x in range(len(coreMap)+2)] for y in range(len(coreMap)+2)]

            _rodDomains = [[0 for x in range(len(coreMap) + 2)]

                           for y in range(len(coreMap) + 2)]

            for i, row in enumerate(coreMap):

                for j, val in enumerate(row):

                    if val != 0:

                        _rodDomains[i + 1][j + 1] = 1





        thisMap = np.array(coreMap)

        me.grBlockWidth = grBlockWidth



        # Use an equivalent diameter to get the same cross sectional area of the graphite block

        area = grBlockWidth**2 - 2 * chArea

        rodDiameter = np.sqrt(4.0 * area / np.pi)

      me.model.addSolidType(solidTypeID=1, geoObj=Solid.SolidRod(d_outer=rodDiameter, material='graphite'))

        me.model.addSolidType(solidTypeID=1, geoObj=Solid.SolidRod(

            d_outer=rodDiameter, material='graphite'))



        # Add a buffer around the PinMap that is empty to make processing the map easier

        # Fill up the "array" with None

      me.pinMap = [ [[None, None] for x in range(thisMap.shape[0]+2)] for y in range(thisMap.shape[1]+2) ]

        me.pinMap = [[[None, None] for x in range(

            thisMap.shape[0] + 2)] for y in range(thisMap.shape[1] + 2)]



        # Set the cursor to the center of the north-west rod in the CoreMap

        # Origin is on the center of the graphite block
@@ -312,7 +317,6 @@ class MSRE(Core): 
                        rodsInDomain[owner].append(pinID)

                        rodOwners[pinID] = owner





            """

         viz = me.pinMap

         for x in viz:
@@ -355,12 +359,14 @@ class MSRE(Core): 
                            # Do not create a north channel for pins on the horizontal symmetry line

                            chi = chi + 1

                            ID = chi

                     me.model.addSolidOuterChan(me.pinMap[i][j][0], ID, 0.25)

                            me.model.addSolidOuterChan(

                                me.pinMap[i][j][0], ID, 0.25)

                            chx = me.pinMap[i][j][1].x

                            chy = me.pinMap[i][j][1].y + grBlockWidth / 2

                            chw = chLen

                            chh = chWidth / 2.0

                     me.sec.addChannel(ID, chArea/2, chPw/2, chx, chy, xsiz=chw, ysiz=chw)

                            me.sec.addChannel(

                                ID, chArea / 2, chPw / 2, chx, chy, xsiz=chw, ysiz=chw)

                            # Put in same domain as adjacent pin

                            chansInDomain[_rodDomains[i][j]].append(ID)

                            me.ch_xlist.append(chx)
@@ -377,12 +383,14 @@ class MSRE(Core): 
                            # Do not create a west channel for pins on the vertical symmetry line

                            chi = chi + 1

                            ID = chi

                     me.model.addSolidOuterChan(me.pinMap[i][j][0], ID, 0.25)

                            me.model.addSolidOuterChan(

                                me.pinMap[i][j][0], ID, 0.25)

                            chx = me.pinMap[i][j][1].x - grBlockWidth / 2

                            chy = me.pinMap[i][j][1].y

                            chw = chWidth / 2.0

                            chh = chLen

                     me.sec.addChannel(ID, chArea/2, chPw/2, chx, chy, xsiz=chw, ysiz=chh)

                            me.sec.addChannel(

                                ID, chArea / 2, chPw / 2, chx, chy, xsiz=chw, ysiz=chh)

                            # Put in same domain as adjacent pin

                            chansInDomain[_rodDomains[i][j]].append(ID)

                            me.ch_xlist.append(chx)
@@ -407,10 +415,12 @@ class MSRE(Core): 
                            chh = chLen

                        chi = chi + 1

                        ID = chi

                  me.model.addSolidOuterChan(me.pinMap[i][j][0], ID, 0.25)

                        me.model.addSolidOuterChan(

                            me.pinMap[i][j][0], ID, 0.25)

                        chx = me.pinMap[i][j][1].x + grBlockWidth / 2

                        chy = me.pinMap[i][j][1].y

                  me.sec.addChannel(ID, area, pw, chx, chy, xsiz=chw, ysiz=chh)

                        me.sec.addChannel(ID, area, pw, chx,

                                          chy, xsiz=chw, ysiz=chh)

                        # Put in same domain as adjacent pin

                        chansInDomain[_rodDomains[i][j]].append(ID)

                        me.ch_xlist.append(chx)
@@ -452,15 +462,18 @@ class MSRE(Core): 
                            chy = me.pinMap[i][j][1].y

                            chw = chWidth

                            chh = chLen

                     me.sec.addChannel(ID, area, pw, chx, chy, xsiz=chw, ysiz=chh)

                            me.sec.addChannel(

                                ID, area, pw, chx, chy, xsiz=chw, ysiz=chh)

                            # Put in same domain as adjacent pin

                            chansInDomain[_rodDomains[i][j]].append(ID)

                            me.ch_xlist.append(chx)

                            me.ch_ylist.append(chy)

                            me.ch_height.append(chh)

                            me.ch_width.append(chw)

                     me.model.addSolidOuterChan(me.pinMap[i][j][0], ID, percent)

                     me.model.addSolidOuterChan(me.pinMap[i][j+1][0], ID, 0.25)

                            me.model.addSolidOuterChan(

                                me.pinMap[i][j][0], ID, percent)

                            me.model.addSolidOuterChan(

                                me.pinMap[i][j + 1][0], ID, 0.25)

                            me.core_ch.append(ID)



                    # Add channels to the south
@@ -481,14 +494,16 @@ class MSRE(Core): 
                        ID = chi

                        chx = me.pinMap[i][j][1].x

                        chy = me.pinMap[i][j][1].y - grBlockWidth / 2

                  me.sec.addChannel(ID, area, pw, chx, chy, xsiz=chw, ysiz=chh)

                        me.sec.addChannel(ID, area, pw, chx,

                                          chy, xsiz=chw, ysiz=chh)

                        # Put in same domain as adjacent pin

                        chansInDomain[_rodDomains[i][j]].append(ID)

                        me.ch_xlist.append(chx)

                        me.ch_ylist.append(chy)

                        me.ch_height.append(chh)

                        me.ch_width.append(chw)

                  me.model.addSolidOuterChan(me.pinMap[i][j][0], ID, 0.25)

                        me.model.addSolidOuterChan(

                            me.pinMap[i][j][0], ID, 0.25)

                        me.core_ch.append(ID)

                    else:

                        # If there is a pin to the south, add a full channel unless we are on the vertical symmetry line
@@ -516,15 +531,18 @@ class MSRE(Core): 
                            ID = chi

                            chx = me.pinMap[i][j][1].x

                            chy = me.pinMap[i][j][1].y - grBlockWidth / 2.0

                     me.sec.addChannel(ID, area, pw, chx, chy, xsiz=chw, ysiz=chh)

                            me.sec.addChannel(

                                ID, area, pw, chx, chy, xsiz=chw, ysiz=chh)

                            # Put in same domain as adjacent pin

                            chansInDomain[_rodDomains[i][j]].append(ID)

                            me.ch_xlist.append(chx)

                            me.ch_ylist.append(chy)

                            me.ch_width.append(chw)

                            me.ch_height.append(chh)

                     me.model.addSolidOuterChan(me.pinMap[i][j][0], ID, percent)

                     me.model.addSolidOuterChan(me.pinMap[i+1][j][0], ID, 0.25)

                            me.model.addSolidOuterChan(

                                me.pinMap[i][j][0], ID, percent)

                            me.model.addSolidOuterChan(

                                me.pinMap[i + 1][j][0], ID, 0.25)

                            me.core_ch.append(ID)



        if rodDomains:
@@ -562,10 +580,12 @@ class MSRE(Core): 
        plt.title('Graphite block center locations')

        ax.set_xlabel('x [m]')

        ax.set_ylabel('y [m]')

      ax.plot(me.pin_xlist, me.pin_ylist, ls='', marker='.', color='b', label='pins')

        ax.plot(me.pin_xlist, me.pin_ylist, ls='',

                marker='.', color='b', label='pins')

        #ax.plot(ch_xlist, me.ch_ylist, ls='', marker='.', color='r', label='chans')

        for i, c in enumerate(ch_xlist):

         ax.add_patch(patches.Rectangle((me.ch_xlist[i]-me.ch_width[i]/2.0, me.ch_ylist[i]-me.ch_height[i]/2.0), me.ch_width[i], me.ch_height[i]))

            ax.add_patch(patches.Rectangle(

                (me.ch_xlist[i] - me.ch_width[i] / 2.0, me.ch_ylist[i] - me.ch_height[i] / 2.0), me.ch_width[i], me.ch_height[i]))

        ax.legend()

        plt.savefig(fname, dpi=150)

        plt.close(fig)
@@ -610,12 +630,14 @@ class MSRE(Core): 
            else:

                weights.append(0.25)

            if radialPower:

            radPowers.append(radialPower(utils.radialLocation(obj.x, obj.y)))

                radPowers.append(radialPower(

                    utils.radialLocation(obj.x, obj.y)))

            else:

                radPowers.append(1.0)



        # Normalize the radial powers

      radPowers = np.array(radPowers)/np.average(radPowers, weights=weights)

        radPowers = np.array(radPowers) / \

            np.average(radPowers, weights=weights)



        i = 0

        for row in me.pinMap:

SubKit/build/InpBuild.py

+90 −61
Original line number Diff line number Diff line 
#!/usr/bin/env python

import os

import sys

sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))

sys.path.insert(0, os.path.abspath(

    os.path.join(os.path.dirname(__file__), '..')))

import Model

import Section

import InpParse

import numpy as np

import argparse





class InpBuilder(object):

    def __init__(me, inpFileName):

        me.model = Model.Model()
@@ -35,7 +37,8 @@ class InpBuilder(object): 
            sec = Section.Section(dz=Dz)

            # Add Channels

            for chID in me.inp.getChannelIDs(secID):

                sec.addChannel(chID=chID, area=me.inp.getChannelArea(chID), pw=me.inp.getChannelPw(chID), x=me.inp.getChannelxLoc(chID), y=me.inp.getChannelyLoc(chID), xsiz=me.inp.getChannelxSize(chID), ysiz=me.inp.getChannelySize(chID))

                sec.addChannel(chID=chID, area=me.inp.getChannelArea(chID), pw=me.inp.getChannelPw(chID), x=me.inp.getChannelxLoc(

                    chID), y=me.inp.getChannelyLoc(chID), xsiz=me.inp.getChannelxSize(chID), ysiz=me.inp.getChannelySize(chID))

                # Gaps and connections have to be defined both in InpParse and InpBuilder

            me.model.addSection(secID=secID, section=sec)
@@ -48,45 +51,61 @@ class InpBuilder(object): 


        if massfluxinit:

            mdotinit = massfluxinit * me.inp.getInFlowArea()

        me.model.setInitialConditions(mdotInit=mdotinit, tempInit=temperatureinit, pressureInit=pressureinit)

        me.model.setInitialConditions(

            mdotInit=mdotinit, tempInit=temperatureinit, pressureInit=pressureinit)



        # Boundary Conditions

        for chID in me.inp.getChannelIDs():

            BCLevels = me.inp.getBCLevels(chID)

            for idx, bc in enumerate(me.inp.getBCs(chID)):

                me.model.addBoundaryCondition(bc=bc, chID=chID, lev=BCLevels[idx])

                me.model.addBoundaryCondition(

                    bc=bc, chID=chID, lev=BCLevels[idx])



        # Form Losses

        if me.inp.getNumFormLosses() > 0:

            for lossGroup in range(me.inp.getNumFormLosses()):

                me.model.addFormLosses(k=me.inp.getFormLossCoefficients(lossGroup),

                        levels=me.inp.getFormLossLevels(lossGroup),

                                       levels=me.inp.getFormLossLevels(

                                           lossGroup),

                                       channels=me.inp.getFormLossChannels(lossGroup))



        # Gaps

        if me.inp.getGapIDs():

            for gapID in me.inp.getGapIDs():

                me.model.setGap(ii=me.inp.getGapChannels(gapID)[0], jj=me.inp.getGapChannels(gapID)[1],width=me.inp.getGapWidth(gapID),length=me.inp.getGapLength(gapID))

                me.model.setGap(ii=me.inp.getGapChannels(gapID)[0], jj=me.inp.getGapChannels(

                    gapID)[1], width=me.inp.getGapWidth(gapID), length=me.inp.getGapLength(gapID))



        # Solution type

        if me.inp.IsSolutionTypeTransient():

            for trgroupID in me.inp.getTransientGroupIDs():

                me.model.addTransientGroup(tEnd=me.inp.getTransientTend(trgroupID),

                        editInterval=me.inp.getTransientEdits(trgroupID),

                        dtMin=me.inp.getTransientdtmin(trgroupID),

                                           editInterval=me.inp.getTransientEdits(

                                               trgroupID),

                                           dtMin=me.inp.getTransientdtmin(

                                               trgroupID),

                                           dtMax=me.inp.getTransientdtmax(trgroupID))

        else:

            me.model.setSteadyState(p_l2=me.inp.getSteadyStoppingCriteria()['p_l2_norm'],

                                    p_linf=me.inp.getSteadyStoppingCriteria()['p_linf_norm'],

                                    Tcool_l2=me.inp.getSteadyStoppingCriteria()['Tcool_l2_norm'],

                                    Tcool_linf=me.inp.getSteadyStoppingCriteria()['Tcool_linf_norm'],

                                    Tsolid_l2=me.inp.getSteadyStoppingCriteria()['Tsolid_l2_norm'],

                                    Tsolid_linf=me.inp.getSteadyStoppingCriteria()['Tsolid_linf_norm'],

                                    vl_l2=me.inp.getSteadyStoppingCriteria()['vl_l2_norm'],

                                    vl_linf=me.inp.getSteadyStoppingCriteria()['vl_linf_norm'],

                                    vv_l2=me.inp.getSteadyStoppingCriteria()['vv_l2_norm'],

                                    vv_linf=me.inp.getSteadyStoppingCriteria()['vv_linf_norm'],

                                    vd_l2=me.inp.getSteadyStoppingCriteria()['vd_l2_norm'],

                                    p_linf=me.inp.getSteadyStoppingCriteria()[

                'p_linf_norm'],

                Tcool_l2=me.inp.getSteadyStoppingCriteria()[

                'Tcool_l2_norm'],

                Tcool_linf=me.inp.getSteadyStoppingCriteria()[

                'Tcool_linf_norm'],

                Tsolid_l2=me.inp.getSteadyStoppingCriteria()[

                'Tsolid_l2_norm'],

                Tsolid_linf=me.inp.getSteadyStoppingCriteria()[

                'Tsolid_linf_norm'],

                vl_l2=me.inp.getSteadyStoppingCriteria()[

                'vl_l2_norm'],

                vl_linf=me.inp.getSteadyStoppingCriteria()[

                'vl_linf_norm'],

                vv_l2=me.inp.getSteadyStoppingCriteria()[

                'vv_l2_norm'],

                vv_linf=me.inp.getSteadyStoppingCriteria()[

                'vv_linf_norm'],

                vd_l2=me.inp.getSteadyStoppingCriteria()[

                'vd_l2_norm'],

                vd_linf=me.inp.getSteadyStoppingCriteria()['vd_linf_norm'])



        # Axial power tables
@@ -97,26 +116,32 @@ class InpBuilder(object): 
                if times:

                    for t in times:

                        power = me.inp.getAxialPowerFactors(axialPowerID, t)

                       me.model.addAxialPowerShape(axialPowerID, axial, power, time=t)

                        me.model.addAxialPowerShape(

                            axialPowerID, axial, power, time=t)

                else:

                    power = me.inp.getAxialPowerFactors(axialPowerID)

                    me.model.addAxialPowerShape(axialPowerID, axial, power)



        #Solids & Objects

        for typeID in me.inp.getSolidGeoms():

            me.model.addSolidType(solidTypeID=typeID, geoObj=me.inp.getSolidGeom(typeID))

            me.model.addSolidType(solidTypeID=typeID,

                                  geoObj=me.inp.getSolidGeom(typeID))



        for solidID in me.inp.getSolidIDs():

            me.model.addSolid(solidID=solidID, solidTypeID=me.inp.getSolidGeomID(solidID), solidObject=me.inp.getSolidObj(solidID))

            me.model.addSolid(solidID=solidID, solidTypeID=me.inp.getSolidGeomID(

                solidID), solidObject=me.inp.getSolidObj(solidID))

            percents = me.inp.getSolidPercents(solidID)

            chID = me.inp.getSolidChans(solidID)

            me.model.addSolidOuterChan(solidID=solidID, chID=chID, percent=percents)

            me.model.addSolidOuterChan(

                solidID=solidID, chID=chID, percent=percents)



        # Parallel models

        if me.inp.getParallelDomainIDs():

            for domainID in me.inp.getParallelDomainIDs():

                me.model.addRodsToDomain(domain=domainID, rods=me.inp.getParallelDomainSolids(domainID), owners=me.inp.getParallelDomainSolidOwners(domainID))

                me.model.addChannelsToDomain(domain=domainID, channels=me.inp.getParallelDomainChannels(domainID))

                me.model.addRodsToDomain(domain=domainID, rods=me.inp.getParallelDomainSolids(

                    domainID), owners=me.inp.getParallelDomainSolidOwners(domainID))

                me.model.addChannelsToDomain(

                    domain=domainID, channels=me.inp.getParallelDomainChannels(domainID))



        # VUQ input

        vuq_mult = me.inp.getVUQMultDict()
@@ -131,11 +156,15 @@ class InpBuilder(object): 
        me.model.setAveragePower(qprime=me.inp.getInitialQprime())

        me.model.generateModel(me.getOutputFilename())





def main():

   parser = argparse.ArgumentParser(description="Generates a CTF input deck from the simplified SubKit input file.")

   parser.add_argument("filename", type=str, help="The name of the SubKit input file.")

    parser = argparse.ArgumentParser(

        description="Generates a CTF input deck from the simplified SubKit input file.")

    parser.add_argument("filename", type=str,

                        help="The name of the SubKit input file.")

    args = parser.parse_args()

    model = InpBuilder(args.filename)





if __name__ == "__main__":

    main()

SubKit/build/InpParse.py

+224 −176

File changed.

Preview size limit exceeded, changes collapsed.

SubKit/build/Model.py

+1599 −1541

File changed.

Preview size limit exceeded, changes collapsed.