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
Loading
Loading
Loading
Loading
+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
+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:
+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()
+224 −176

File changed.

Preview size limit exceeded, changes collapsed.

+1599 −1541

File changed.

Preview size limit exceeded, changes collapsed.

Loading