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

Change how h5py is accessed to improve performance

parent 56debc89

SubKit/process/Hdf5Tools.py

+25 −25
Original line number Diff line number Diff line
@@ -13,6 +13,7 @@ class Hdf5Interface(object): 


    """

    def __init__(me, fname):

        me.time = eTime()

        me.fname = fname

        me.h5 = h5py.File(fname, 'r')

        assert('CORE' in me.h5)
@@ -408,8 +409,7 @@ class Hdf5Interface(object): 


        """

        res = []

        sections = me.h5['/CORE/chan_sections'][()]

        for i, sec in enumerate(sections):

        for i, sec in enumerate(me.chanSections):

            if section==sec:

                res.append(i+1)

        return res
@@ -440,8 +440,8 @@ class Hdf5Interface(object): 


        """

        chID = list(np.array(chans)-1)

        data = me.h5['/STATE_{:04d}/{:s}'.format(state, dataset)][()]

        area = me.h5["/CORE/chan_area"][()][chID]

        data = me.h5['/STATE_{:04d}/{:s}'.format(state, dataset)][:, :]

        area = me.h5["/CORE/chan_area"][chID][:]

        return np.average(data[level, chID], weights=area)



    def getAvePressure(me, section=1, level=None, state=1):
@@ -467,7 +467,7 @@ class Hdf5Interface(object): 
    def _sumChanDataset(me, dataset, state, chans, level):

        """ Gets the sum of the dataset for passed state, chans, and level"""

        chID = np.array(chans)-1

        data = me.h5['STATE_{:04d}/{:s}'.format(state, dataset)][()]

        data = me.h5['STATE_{:04d}/{:s}'.format(state, dataset)][:, :]

        return np.sum(data[level, chID])



    def getAveMassFlux(me, section=1, level=None, state=1):
@@ -524,10 +524,10 @@ class Hdf5Interface(object): 
        me._chanIndexValid(chan)

        numLevel = me.getChanDatasetNumLev(chan, dataset)

        if level is None:

            return me.h5['/STATE_{:04d}/{:s}'.format(state, dataset)][list(range(numLevel)), chan-1][()]

            return me.h5['/STATE_{:04d}/{:s}'.format(state, dataset)][list(range(numLevel)), chan-1][:]

        else:

            me._chLevelValid(dataset, state, chan, level)

            return me.h5['/STATE_{:04d}/{:s}'.format(state, dataset)][()][level, chan-1]

            return me.h5['/STATE_{:04d}/{:s}'.format(state, dataset)][level, chan-1][()]



    def getPinAxialDataset(me, dataset, state, pin):

        """ Retrieve pin dataset from the h5 file
@@ -545,7 +545,7 @@ class Hdf5Interface(object): 
        me._datasetValid(dataset)

        me._pinIndexValid(pin)

        levels = list(range(me.pinNumAxial[pin-1]))

        return me.h5['/STATE_{:04d}/{:s}'.format(state, dataset)][levels, pin-1][()]

        return me.h5['/STATE_{:04d}/{:s}'.format(state, dataset)][levels, pin-1][:]



    def getPinSurfaceDataset(me, dataset, state, pin):

        """ Returns the surface dataset for passed state/pin
@@ -563,7 +563,7 @@ class Hdf5Interface(object): 
        me._pinIndexValid(pin)

        n = me.pinNumAxial[pin-1]

        s = me.getPinNumSector(pin)

        return me.h5['/STATE_{:04d}/{:s}'.format(state, dataset)][0:n, 0:s, pin-1][()]

        return me.h5['/STATE_{:04d}/{:s}'.format(state, dataset)][0:n, 0:s, pin-1][:, :]



    def getPinSurfaceTemp(me, state, pin):

        """ Returns a 2D array containing the solid surface temperature distribution
@@ -596,7 +596,7 @@ class Hdf5Interface(object): 
       me._pinIndexValid(pin)

       if me._pinHasCouplingData(pin):

           me._datasetValid(dataset)

           azimuthal_nodes = me.h5['/CORE/mesh/PIN_{:05d}/reconstruction/azimuthal_nodes'.format(pin)][()]

           azimuthal_nodes = me.h5['/CORE/mesh/PIN_{:05d}/reconstruction/azimuthal_nodes'.format(pin)][:]

           # Assume the azimuthal mesh is uniform

           daz = azimuthal_nodes[1]-azimuthal_nodes[0]

           bounds = [azimuthal_nodes[0]-daz/2]
@@ -620,7 +620,7 @@ class Hdf5Interface(object): 
           me._datasetValid(dataset)

           # Assume that each CTF level will be subdivided equally

           # Use the reconstruction axial mesh to figure out how many times they are divided

           axial_nodes = me.h5['/CORE/mesh/PIN_{:05d}/reconstruction/axial_nodes'.format(pin)][()]

           axial_nodes = me.h5['/CORE/mesh/PIN_{:05d}/reconstruction/axial_nodes'.format(pin)][:]

           base_dz = me.pinAxialHeights[0:me.pinNumAxial[pin-1], pin-1]

           assert(len(axial_nodes)%len(base_dz)==0)

           numDiv = len(axial_nodes)/len(base_dz)
@@ -654,9 +654,9 @@ class Hdf5Interface(object): 
        me._pinIndexValid(pin)

        if me._pinHasCouplingData(pin):

           me._datasetValid(dataset)

           axial_nodes = me.h5['/CORE/mesh/PIN_{:05d}/reconstruction/axial_nodes'.format(pin)][()]

           azimuthal_nodes = me.h5['/CORE/mesh/PIN_{:05d}/reconstruction/azimuthal_nodes'.format(pin)][()]

           return (axial_nodes, azimuthal_nodes, me.h5['/STATE_{:04d}/{:s}'.format(state, dataset)][0:len(axial_nodes), 0:len(azimuthal_nodes), pin-1][()])

           axial_nodes = me.h5['/CORE/mesh/PIN_{:05d}/reconstruction/axial_nodes'.format(pin)][:]

           azimuthal_nodes = me.h5['/CORE/mesh/PIN_{:05d}/reconstruction/azimuthal_nodes'.format(pin)][:]

           return (axial_nodes, azimuthal_nodes, me.h5['/STATE_{:04d}/{:s}'.format(state, dataset)][0:len(axial_nodes), 0:len(azimuthal_nodes), pin-1][:, :])

        else:

           return (None, None, None)
@@ -680,10 +680,10 @@ class Hdf5Interface(object): 
            me._chLevelValid('chan_pressure', state, chans[0], level)

            _level = level

        chID = np.array(chans)-1

        T     = me.h5['/STATE_{:04d}/chan_temp'.format(state)][()]

        mdotl = me.h5['/STATE_{:04d}/chan_mdot_liq'.format(state)][()]

        mdotv = me.h5['/STATE_{:04d}/chan_mdot_vap'.format(state)][()]

        mdote = me.h5['/STATE_{:04d}/chan_mdot_drp'.format(state)][()]

        T     = me.h5['/STATE_{:04d}/chan_temp'.format(state)][:, :]

        mdotl = me.h5['/STATE_{:04d}/chan_mdot_liq'.format(state)][:, :]

        mdotv = me.h5['/STATE_{:04d}/chan_mdot_vap'.format(state)][:, :]

        mdote = me.h5['/STATE_{:04d}/chan_mdot_drp'.format(state)][:, :]

        mdotTot = mdotl[_level, chID]+mdotv[_level, chID]+mdote[_level, chID]

        #mdotTot = me.h5['/STATE_{:04d}/chan_mdot_liq'.format(state)][_level, chID]+\

        #        me.h5['/STATE_{:04d}/chan_mdot_vap'.format(state)][_level, chID]+\
@@ -868,7 +868,7 @@ class Hdf5Interface(object): 


        # Get level slice, takes azimuthal/radial

        tempLevel = me.h5['STATE_{:04d}/pin_temp'.format(state)][0:me.getPinNumSector(pin),

                level, 0:me.getPinNumRadial(pin), pin-1][()]

                level, 0:me.getPinNumRadial(pin), pin-1][:, :]

        # Calculate azimuthal fraction weighted average

        Tave = np.zeros(me.getPinNumRadial(pin))

        thetas = me.getPinThetas(pin, level)
@@ -1136,7 +1136,7 @@ class Hdf5Interface(object): 
        if pin is not None: _pin = pin

        if sector is not None: _sector = sector



        data = me.h5['STATE_{:04d}/pin_temp'.format(_state)][()][_sector, 0:me.getPinNumLev(_pin), me.getPinNumRadial(_pin)-1, _pin-1]

        data = me.h5['STATE_{:04d}/pin_temp'.format(_state)][_sector, 0:me.getPinNumLev(_pin), me.getPinNumRadial(_pin)-1, _pin-1][:]

        axial = me.pinAxialNodes[0:me.pinNumAxial[_pin-1], _pin-1]



        return list(axial), list(data)
@@ -1286,9 +1286,9 @@ class Hdf5Interface(object): 


        for st in searchStates:

            if level is None:

                ma = np.ma.array(me.h5['STATE_{:04d}/{:s}'.format(st, dataset)][()][:, searchChans], mask=mask[:, searchChans])

                ma = np.ma.array(me.h5['STATE_{:04d}/{:s}'.format(st, dataset)][:, searchChans], mask=mask[:, searchChans][()])

            else:

                ma = np.ma.array(me.h5['STATE_{:04d}/{:s}'.format(st, dataset)][()][level, searchChans], mask=mask[level, searchChans])

                ma = np.ma.array(me.h5['STATE_{:04d}/{:s}'.format(st, dataset)][level, searchChans], mask=mask[level, searchChans][()])

            maxval = ma.max()

            if maxVal is None or maxval>maxVal:

               maxVal = maxval
@@ -1372,7 +1372,7 @@ class Hdf5Interface(object): 
        mdotVap = me.getChanDataset('chan_mdot_vap', state, chan)

        axial, mdotDrp = me.getChanMeshAndData('chan_mdot_drp', state, chan)

        mdotTot = np.array(mdotLiq)+np.array(mdotVap)+np.array(mdotDrp)

        return axial, list(mdotTot/me.h5['CORE/chan_area'][()][chan-1])

        return axial, list(mdotTot/me.h5['CORE/chan_area'][chan-1][()])



    def getPinAxialTimeData(me, dataset, pin, level):

        """ Returns time series data for single location in pin axial data
@@ -1398,7 +1398,7 @@ class Hdf5Interface(object): 
                times.append(me.h5['STATE_{:04d}/time'.format(state)][()])

            else:

                times.append(state)

            data.append(me.h5['STATE_{:04d}/{:s}'.format(state, dataset)][()][level, pin-1])

            data.append(me.h5['STATE_{:04d}/{:s}'.format(state, dataset)][level, pin-1][()])

        return times, data



    def getPinInternalTimeData(me, pin, theta, radial, level):
@@ -1429,5 +1429,5 @@ class Hdf5Interface(object): 
                times.append(me.h5['STATE_{:04d}/time'.format(state)][()])

            else:

                times.append(state)

            temps.append(me.h5['STATE_{:04d}/pin_temp'.format(state)][()][theta, level, radial, pin-1])

            temps.append(me.h5['STATE_{:04d}/pin_temp'.format(state)][theta, level, radial, pin-1][()])

        return times, temps

SubKit/process/SummaryTools.py

+1 −0
Original line number Diff line number Diff line
@@ -163,6 +163,7 @@ class SummaryTools(object): 
            times, Tpellet = me.h5.getPinInternalTimeData(pin, _sector, -3, _level)

        times, Tcent = me.h5.getPinAxialTimeData('pin_axial_centerline_temp', pin, _level)

        for i, t in enumerate(times):

            print me.time.elapsed(), "Processing state {:d}".format(i+1)

            _Tclado = Tclado[i]

            if Tcladi is None:

                _Tcladi = 0.0