예제 #1
0
    def test_getMRforER(self):
        """ test call to getMRforER( ERphi=None, ERr=None) """
        C = CEA_Obj(oxName="LOX", fuelName="MMH", fac_CR=None)
        mr = C.getMRforER(ERphi=1.0, ERr=None)
        self.assertAlmostEqual(mr, 1.7363572550114232, places=3)

        mr = C.getMRforER(ERphi=None, ERr=1.0)
        self.assertAlmostEqual(mr, 1.7363572550114232, places=3)

        del C
예제 #2
0
class CEA_Obj(object):
    """
    RocketCEA wraps the NASA FORTRAN CEA code to calculate Isp, cstar, and Tcomb
    
    This object wraps the English unit version of CEA_Obj to enable desired user units.    
    """
    def __init__(self,
                 propName='',
                 oxName='',
                 fuelName='',
                 useFastLookup=0,
                 makeOutput=0,
                 isp_units='sec',
                 cstar_units='ft/sec',
                 pressure_units='psia',
                 temperature_units='degR',
                 sonic_velocity_units='ft/sec',
                 enthalpy_units='BTU/lbm',
                 density_units='lbm/cuft',
                 specific_heat_units='BTU/lbm degR',
                 viscosity_units='millipoise',
                 thermal_cond_units='mcal/cm-K-s',
                 fac_CR=None,
                 make_debug_prints=False):
        """::
        
        #: RocketCEA wraps the NASA FORTRAN CEA code to calculate Isp, cstar, and Tcomb
        #: This object wraps the English unit version of CEA_Obj to enable desired user units.
        #: Same as CEA_Obj with standard units except, input and output units can be specified.
        #:  parameter             default             options
        #: isp_units            = 'sec',         # N-s/kg, m/s, km/s
        #: cstar_units          = 'ft/sec',      # m/s
        #: pressure_units       = 'psia',        # MPa, KPa, Pa, Bar, Atm, Torr
        #: temperature_units    = 'degR',        # K, C, F
        #: sonic_velocity_units = 'ft/sec',      # m/s
        #: enthalpy_units       = 'BTU/lbm',     # J/g, kJ/kg, J/kg, kcal/kg, cal/g
        #: density_units        = 'lbm/cuft',    # g/cc, sg, kg/m^3
        #: specific_heat_units  = 'BTU/lbm degR' # kJ/kg-K, cal/g-C, J/kg-K (# note: cal/g K == BTU/lbm degR)
        #: viscosity_units      = 'millipoise'   # lbf-sec/sqin, lbf-sec/sqft, lbm/ft-sec, poise, centipoise
        #: thermal_cond_units   = 'mcal/cm-K-s'  # millical/cm-degK-sec, BTU/hr-ft-degF, BTU/s-in-degF, cal/s-cm-degC, W/cm-degC
        #: fac_CR, Contraction Ratio of finite area combustor (None=infinite)
        #: if make_debug_prints is True, print debugging info to terminal.
        """

        self.isp_units = isp_units
        self.cstar_units = cstar_units
        self.pressure_units = pressure_units
        self.temperature_units = temperature_units
        self.sonic_velocity_units = sonic_velocity_units
        self.enthalpy_units = enthalpy_units
        self.density_units = density_units
        self.specific_heat_units = specific_heat_units
        self.viscosity_units = viscosity_units
        self.thermal_cond_units = thermal_cond_units
        self.fac_CR = fac_CR

        # Units objects for input/output (e.g. Pc and Pamb)
        self.Pc_U = get_units_obj('psia', pressure_units)

        # units of output quantities
        self.isp_U = get_units_obj('sec', isp_units)
        self.cstar_U = get_units_obj('ft/sec', cstar_units)
        self.temperature_U = get_units_obj('degR', temperature_units)
        self.sonic_velocity_U = get_units_obj('ft/sec', sonic_velocity_units)
        self.enthalpy_U = get_units_obj('BTU/lbm', enthalpy_units)
        self.density_U = get_units_obj('lbm/cuft', density_units)
        self.specific_heat_U = get_units_obj('BTU/lbm degR',
                                             specific_heat_units)
        self.viscosity_U = get_units_obj('millipoise', viscosity_units)
        self.thermal_cond_U = get_units_obj('mcal/cm-K-s', thermal_cond_units)

        self.cea_obj = CEA_Obj_default(propName=propName,
                                       oxName=oxName,
                                       fuelName=fuelName,
                                       useFastLookup=useFastLookup,
                                       makeOutput=makeOutput,
                                       fac_CR=fac_CR,
                                       make_debug_prints=make_debug_prints)
        self.desc = self.cea_obj.desc

    def get_IvacCstrTc(self, Pc=100.0, MR=1.0, eps=40.0):

        Pc = self.Pc_U.uval_to_dval(Pc)  # convert user units to psia
        IspVac, Cstar, Tcomb = self.cea_obj.get_IvacCstrTc(Pc=Pc,
                                                           MR=MR,
                                                           eps=eps)

        IspVac = self.isp_U.dval_to_uval(IspVac)
        Cstar = self.cstar_U.dval_to_uval(Cstar)
        Tcomb = self.temperature_U.dval_to_uval(Tcomb)

        return IspVac, Cstar, Tcomb

    def getFrozen_IvacCstrTc(self,
                             Pc=100.0,
                             MR=1.0,
                             eps=40.0,
                             frozenAtThroat=0):

        Pc = self.Pc_U.uval_to_dval(Pc)  # convert user units to psia
        IspFrozen, Cstar, Tcomb = self.cea_obj.getFrozen_IvacCstrTc(
            Pc=Pc, MR=MR, eps=eps, frozenAtThroat=frozenAtThroat)
        IspFrozen = self.isp_U.dval_to_uval(IspFrozen)
        Cstar = self.cstar_U.dval_to_uval(Cstar)
        Tcomb = self.temperature_U.dval_to_uval(Tcomb)

        return IspFrozen, Cstar, Tcomb

    def get_IvacCstrTc_exitMwGam(self, Pc=100.0, MR=1.0, eps=40.0):

        Pc = self.Pc_U.uval_to_dval(Pc)  # convert user units to psia
        IspVac, Cstar, Tcomb, mw, gam = self.cea_obj.get_IvacCstrTc_exitMwGam(
            Pc=Pc, MR=MR, eps=eps)

        IspVac = self.isp_U.dval_to_uval(IspVac)
        Cstar = self.cstar_U.dval_to_uval(Cstar)
        Tcomb = self.temperature_U.dval_to_uval(Tcomb)

        return IspVac, Cstar, Tcomb, mw, gam

    def get_IvacCstrTc_ChmMwGam(self, Pc=100.0, MR=1.0, eps=40.0):

        Pc = self.Pc_U.uval_to_dval(Pc)  # convert user units to psia
        IspVac, Cstar, Tcomb, mw, gam = self.cea_obj.get_IvacCstrTc_ChmMwGam(
            Pc=Pc, MR=MR, eps=eps)

        IspVac = self.isp_U.dval_to_uval(IspVac)
        Cstar = self.cstar_U.dval_to_uval(Cstar)
        Tcomb = self.temperature_U.dval_to_uval(Tcomb)

        return IspVac, Cstar, Tcomb, mw, gam

    def get_IvacCstrTc_ThtMwGam(self, Pc=100.0, MR=1.0, eps=40.0):

        Pc = self.Pc_U.uval_to_dval(Pc)  # convert user units to psia
        IspVac, Cstar, Tcomb, mw, gam = self.cea_obj.get_IvacCstrTc_ThtMwGam(
            Pc=Pc, MR=MR, eps=eps)

        IspVac = self.isp_U.dval_to_uval(IspVac)
        Cstar = self.cstar_U.dval_to_uval(Cstar)
        Tcomb = self.temperature_U.dval_to_uval(Tcomb)

        return IspVac, Cstar, Tcomb, mw, gam

    def __call__(self, Pc=100.0, MR=1.0, eps=40.0):
        return self.get_Isp(Pc=Pc, MR=MR, eps=eps)

    def get_Isp(self, Pc=100.0, MR=1.0, eps=40.0):

        Pc = self.Pc_U.uval_to_dval(Pc)  # convert user units to psia
        IspVac = self.cea_obj.get_Isp(Pc=Pc, MR=MR, eps=eps)
        IspVac = self.isp_U.dval_to_uval(IspVac)

        return IspVac

    def get_Cstar(self, Pc=100.0, MR=1.0):

        Pc = self.Pc_U.uval_to_dval(Pc)  # convert user units to psia
        Cstar = self.cea_obj.get_Cstar(Pc=Pc, MR=MR)
        Cstar = self.cstar_U.dval_to_uval(Cstar)
        return Cstar

    def get_Tcomb(self, Pc=100.0, MR=1.0):

        Pc = self.Pc_U.uval_to_dval(Pc)  # convert user units to psia
        Tcomb = self.cea_obj.get_Tcomb(Pc=Pc, MR=MR)
        Tcomb = self.temperature_U.dval_to_uval(Tcomb)
        return Tcomb

    def get_PcOvPe(self, Pc=100.0, MR=1.0, eps=40.0):
        Pc = self.Pc_U.uval_to_dval(Pc)  # convert user units to psia
        return self.cea_obj.get_PcOvPe(Pc=Pc, MR=MR, eps=eps)

    def get_eps_at_PcOvPe(self, Pc=100.0, MR=1.0, PcOvPe=1000.0):
        Pc = self.Pc_U.uval_to_dval(Pc)  # convert user units to psia
        return self.cea_obj.get_eps_at_PcOvPe(Pc=Pc, MR=MR, PcOvPe=PcOvPe)

    def get_Throat_PcOvPe(self, Pc=100.0, MR=1.0):
        Pc = self.Pc_U.uval_to_dval(Pc)  # convert user units to psia
        return self.cea_obj.get_Throat_PcOvPe(Pc=Pc, MR=MR)

    def get_MachNumber(self, Pc=100.0, MR=1.0, eps=40.0):
        Pc = self.Pc_U.uval_to_dval(Pc)  # convert user units to psia
        return self.cea_obj.get_MachNumber(Pc=Pc, MR=MR, eps=eps)

    def get_Temperatures(self,
                         Pc=100.0,
                         MR=1.0,
                         eps=40.0,
                         frozen=0,
                         frozenAtThroat=0):
        Pc = self.Pc_U.uval_to_dval(Pc)  # convert user units to psia
        tempList = self.cea_obj.get_Temperatures(Pc=Pc,
                                                 MR=MR,
                                                 eps=eps,
                                                 frozen=frozen,
                                                 frozenAtThroat=frozenAtThroat)

        for i, T in enumerate(tempList):
            tempList[i] = self.temperature_U.dval_to_uval(T)
        return tempList  # Tc, Tthroat, Texit

    def get_SonicVelocities(self, Pc=100.0, MR=1.0, eps=40.0):
        Pc = self.Pc_U.uval_to_dval(Pc)  # convert user units to psia
        sonicList = self.cea_obj.get_SonicVelocities(Pc=Pc, MR=MR, eps=eps)

        for i, S in enumerate(sonicList):
            sonicList[i] = self.sonic_velocity_U.dval_to_uval(S)
        return sonicList  # Chamber, Throat, Exit

    def get_Chamber_SonicVel(self, Pc=100.0, MR=1.0, eps=40.0):
        Pc = self.Pc_U.uval_to_dval(Pc)  # convert user units to psia
        sonicVel = self.cea_obj.get_Chamber_SonicVel(Pc=Pc, MR=MR, eps=eps)

        sonicVel = self.sonic_velocity_U.dval_to_uval(sonicVel)
        return sonicVel

    def get_Enthalpies(self, Pc=100.0, MR=1.0, eps=40.0):
        Pc = self.Pc_U.uval_to_dval(Pc)  # convert user units to psia

        hList = self.cea_obj.get_Enthalpies(Pc=Pc, MR=MR, eps=eps)
        for i, H in enumerate(hList):
            hList[i] = self.enthalpy_U.dval_to_uval(H)

        return hList

    def get_SpeciesMassFractions(self,
                                 Pc=100.0,
                                 MR=1.0,
                                 eps=40.0,
                                 frozen=0,
                                 frozenAtThroat=0,
                                 min_fraction=0.000005):
        Pc = self.Pc_U.uval_to_dval(Pc)  # convert user units to psia

        molWtD, massFracD = self.cea_obj.get_SpeciesMassFractions(
            Pc=Pc,
            MR=MR,
            eps=eps,
            frozenAtThroat=frozenAtThroat,
            min_fraction=min_fraction)
        return molWtD, massFracD

    def get_SpeciesMoleFractions(self,
                                 Pc=100.0,
                                 MR=1.0,
                                 eps=40.0,
                                 frozen=0,
                                 frozenAtThroat=0,
                                 min_fraction=0.000005):
        Pc = self.Pc_U.uval_to_dval(Pc)  # convert user units to psia

        molWtD, moleFracD = self.cea_obj.get_SpeciesMoleFractions(
            Pc=Pc,
            MR=MR,
            eps=eps,
            frozenAtThroat=frozenAtThroat,
            min_fraction=min_fraction)
        return molWtD, moleFracD

    def get_Chamber_H(self, Pc=100.0, MR=1.0, eps=40.0):

        Pc = self.Pc_U.uval_to_dval(Pc)  # convert user units to psia
        H = self.cea_obj.get_Chamber_H(Pc=Pc, MR=MR, eps=eps)
        return self.enthalpy_U.dval_to_uval(H)

    def get_Densities(self, Pc=100.0, MR=1.0, eps=40.0):

        Pc = self.Pc_U.uval_to_dval(Pc)  # convert user units to psia
        dList = self.cea_obj.get_Densities(Pc=Pc, MR=MR, eps=eps)

        for i, d in enumerate(dList):
            dList[i] = self.density_U.dval_to_uval(d)

        return dList

    def get_Chamber_Density(self, Pc=100.0, MR=1.0, eps=40.0):

        Pc = self.Pc_U.uval_to_dval(Pc)  # convert user units to psia
        H = self.cea_obj.get_Chamber_Density(Pc=Pc, MR=MR, eps=eps)
        return self.density_U.dval_to_uval(H)

    def get_HeatCapacities(self, Pc=100.0, MR=1.0, eps=40.0, frozen=0):

        Pc = self.Pc_U.uval_to_dval(Pc)  # convert user units to psia
        cpList = self.cea_obj.get_HeatCapacities(Pc=Pc,
                                                 MR=MR,
                                                 eps=eps,
                                                 frozen=frozen)

        for i, cp in enumerate(cpList):
            cpList[i] = self.specific_heat_U.dval_to_uval(cp)

        return cpList

    def get_Chamber_Cp(self, Pc=100.0, MR=1.0, eps=40.0):

        Pc = self.Pc_U.uval_to_dval(Pc)  # convert user units to psia
        Cp = self.cea_obj.get_Chamber_Cp(Pc=Pc, MR=MR, eps=eps)
        return self.specific_heat_U.dval_to_uval(Cp)

    def get_Throat_Isp(self, Pc=100.0, MR=1.0):

        Pc = self.Pc_U.uval_to_dval(Pc)  # convert user units to psia
        Isp = self.cea_obj.get_Throat_Isp(Pc=Pc, MR=MR)
        Isp = self.isp_U.dval_to_uval(Isp)

        return Isp

    def get_Chamber_MolWt_gamma(self, Pc=100.0, MR=1.0, eps=40.0):

        Pc = self.Pc_U.uval_to_dval(Pc)  # convert user units to psia
        return self.cea_obj.get_Chamber_MolWt_gamma(Pc=Pc, MR=MR, eps=eps)

    def get_Throat_MolWt_gamma(self, Pc=100.0, MR=1.0, eps=40.0):

        Pc = self.Pc_U.uval_to_dval(Pc)  # convert user units to psia
        return self.cea_obj.get_Throat_MolWt_gamma(Pc=Pc, MR=MR, eps=eps)

    def get_exit_MolWt_gamma(self, Pc=100.0, MR=1.0, eps=40.0):

        Pc = self.Pc_U.uval_to_dval(Pc)  # convert user units to psia
        return self.cea_obj.get_exit_MolWt_gamma(Pc=Pc, MR=MR, eps=eps)

    def get_eqratio(self, Pc=100.0, MR=1.0, eps=40.0):

        Pc = self.Pc_U.uval_to_dval(Pc)  # convert user units to psia
        return self.cea_obj.get_eqratio(Pc=Pc, MR=MR, eps=eps)

    def getMRforER(self, ERphi=None, ERr=None):
        return self.cea_obj.getMRforER(ERphi=ERphi, ERr=ERr)

    def get_description(self):
        return self.cea_obj.get_description()

    def estimate_Ambient_Isp(self,
                             Pc=100.0,
                             MR=1.0,
                             eps=40.0,
                             Pamb=14.7,
                             frozen=0,
                             frozenAtThroat=0):

        Pc = self.Pc_U.uval_to_dval(Pc)  # convert user units to psia
        Pamb = self.Pc_U.uval_to_dval(Pamb)  # convert user units to psia
        IspAmb, mode = self.cea_obj.estimate_Ambient_Isp(
            Pc=Pc,
            MR=MR,
            eps=eps,
            Pamb=Pamb,
            frozen=frozen,
            frozenAtThroat=frozenAtThroat)

        IspAmb = self.isp_U.dval_to_uval(IspAmb)

        return IspAmb, mode

    def get_PambCf(self, Pamb=14.7, Pc=100.0, MR=1.0, eps=40.0):
        Pc = self.Pc_U.uval_to_dval(Pc)  # convert user units to psia
        Pamb = self.Pc_U.uval_to_dval(Pamb)  # convert user units to psia

        CFcea, CF, mode = self.cea_obj.get_PambCf(Pamb=Pamb,
                                                  Pc=Pc,
                                                  MR=MR,
                                                  eps=eps)

        return CFcea, CF, mode

    def getFrozen_PambCf(self,
                         Pamb=0.0,
                         Pc=100.0,
                         MR=1.0,
                         eps=40.0,
                         frozenAtThroat=0):
        Pc = self.Pc_U.uval_to_dval(Pc)  # convert user units to psia
        Pamb = self.Pc_U.uval_to_dval(Pamb)  # convert user units to psia

        CFcea, CFfrozen, mode = self.cea_obj.getFrozen_PambCf(
            Pamb=Pamb, Pc=Pc, MR=MR, eps=eps, frozenAtThroat=frozenAtThroat)

        return CFcea, CFfrozen, mode

    def get_Chamber_Transport(self, Pc=100.0, MR=1.0, eps=40.0, frozen=0):

        Pc = self.Pc_U.uval_to_dval(Pc)  # convert user units to psia
        Cp, visc, cond, Prandtl = self.cea_obj.get_Chamber_Transport(
            Pc=Pc, MR=MR, eps=eps, frozen=frozen)

        #Cp = Cp * 8314.51 / 4184.0  # convert into BTU/lbm degR
        Cp = self.specific_heat_U.dval_to_uval(Cp)
        visc = self.viscosity_U.dval_to_uval(visc)
        cond = self.thermal_cond_U.dval_to_uval(cond)

        return Cp, visc, cond, Prandtl

    def get_Throat_Transport(self, Pc=100.0, MR=1.0, eps=40.0, frozen=0):

        Pc = self.Pc_U.uval_to_dval(Pc)  # convert user units to psia
        Cp, visc, cond, Prandtl = self.cea_obj.get_Throat_Transport(
            Pc=Pc, MR=MR, eps=eps, frozen=frozen)

        #Cp = Cp * 8314.51 / 4184.0  # convert into BTU/lbm degR
        Cp = self.specific_heat_U.dval_to_uval(Cp)
        visc = self.viscosity_U.dval_to_uval(visc)
        cond = self.thermal_cond_U.dval_to_uval(cond)

        return Cp, visc, cond, Prandtl

    def get_Exit_Transport(self, Pc=100.0, MR=1.0, eps=40.0, frozen=0):

        Pc = self.Pc_U.uval_to_dval(Pc)  # convert user units to psia
        Cp, visc, cond, Prandtl = self.cea_obj.get_Exit_Transport(
            Pc=Pc, MR=MR, eps=eps, frozen=frozen)

        Cp = Cp * 8314.51 / 4184.0  # convert into BTU/lbm degR
        Cp = self.specific_heat_U.dval_to_uval(Cp)
        visc = self.viscosity_U.dval_to_uval(visc)
        cond = self.thermal_cond_U.dval_to_uval(cond)

        return Cp, visc, cond, Prandtl
예제 #3
0
class MR_Temperature_Limits(object):
    def __init__(self,
                 oxName='N2O4',
                 fuelName='MMH',
                 oxPcentL=None,
                 fuelPcentL=None,
                 TC_LIMIT=1000.0,
                 PcNominal=1000.0,
                 epsNominal=10.0,
                 MR_MIN=0.0,
                 MR_MAX=1000.0):  # degR, psia
        """
        For the nominal Pc and Area Ratio,
        Find minimum and maximum mixture ratio where Tcombusion >= 1000 degR
        """

        self.oxName = oxName
        self.oxPcentL = oxPcentL
        self.fuelName = fuelName
        self.fuelPcentL = fuelPcentL

        self.cea_fuelName = get_propellant_name(Name=fuelName,
                                                PcentL=fuelPcentL)
        self.cea_oxName = get_propellant_name(Name=oxName, PcentL=oxPcentL)
        self.TC_LIMIT = TC_LIMIT
        self.PcNominal = PcNominal
        self.epsNominal = epsNominal
        self.MR_MIN = MR_MIN
        self.MR_MAX = MR_MAX

        self.ispODEObj = CEA_Obj(fuelName=self.cea_fuelName,
                                 oxName=self.cea_oxName,
                                 useFastLookup=0,
                                 fac_CR=None)

        self.Stoich_MR = self.ispODEObj.getMRforER(ERphi=1.0)
        #print( 'Stoich MR =',self.Stoich_MR,'for %s/%s'%(self.cea_oxName, self.cea_fuelName) )

        self.find_min_mr()
        self.find_max_mr()

    def find_min_mr(self):
        '''Find min mr where CEA Isp is Non-Zero AND Tc >= TC_LIMIT'''

        isp = self.ispODEObj.get_Isp(Pc=self.PcNominal,
                                     MR=0.0,
                                     eps=self.epsNominal)
        if isp > 0.0:
            self.min_MR = 0.0
            isp, cstr, self.Tc_at_min_MR = self.ispODEObj.get_IvacCstrTc(
                Pc=self.PcNominal, MR=self.min_MR, eps=self.epsNominal)
            if isp > 0.1 and self.Tc_at_min_MR > self.TC_LIMIT:
                return

        mr_top = self.Stoich_MR
        mr_bot = 0.0
        for i in range(40):
            mr = (mr_top + mr_bot) / 2.0

            isp, cstr, tc = self.ispODEObj.get_IvacCstrTc(Pc=self.PcNominal,
                                                          MR=mr,
                                                          eps=self.epsNominal)
            if isp > 0.0 and tc > self.TC_LIMIT:
                mr_top = mr
            else:
                mr_bot = mr

        #print( 'Calculated Min MR = %g'%mr_top, '  Isp at Min MR =',self.ispODEObj.get_Isp( Pc=self.PcNominal, MR=mr_top, eps=eps) )
        self.min_MR = mr_top
        isp, cstr, self.Tc_at_min_MR = self.ispODEObj.get_IvacCstrTc(
            Pc=self.PcNominal, MR=mr_top, eps=self.epsNominal)

    def find_max_mr(self):
        '''Find max mr where CEA Isp is Non-Zero AND Tc >= TC_LIMIT'''
        isp = self.ispODEObj.get_Isp(Pc=self.PcNominal,
                                     MR=self.MR_MAX,
                                     eps=self.epsNominal)
        if isp > 0.0:
            self.max_MR = self.MR_MAX
            isp, cstr, self.Tc_at_max_MR = self.ispODEObj.get_IvacCstrTc(
                Pc=self.PcNominal, MR=self.max_MR, eps=self.epsNominal)
            if isp > 0.0 and self.Tc_at_max_MR > self.TC_LIMIT:
                return

        mr_top = self.MR_MAX
        mr_bot = self.Stoich_MR
        for i in range(40):
            mr = (mr_top + mr_bot) / 2.0

            isp, cstr, tc = self.ispODEObj.get_IvacCstrTc(Pc=self.PcNominal,
                                                          MR=mr,
                                                          eps=self.epsNominal)

            if isp > 0.0 and tc > self.TC_LIMIT:
                mr_bot = mr
            else:
                mr_top = mr

        #print( 'Calculated Max MR = %g'%mr_bot, '  Isp at Max MR =',self.ispODEObj.get_Isp( Pc=self.PcNominal, MR=mr_bot, eps=eps))
        self.max_MR = mr_bot
        isp, cstr, self.Tc_at_max_MR = self.ispODEObj.get_IvacCstrTc(
            Pc=self.PcNominal, MR=mr_bot, eps=self.epsNominal)

    def __str__(self):

        return '''<%s/%s, Stoich_MR=%g, Min MR=%g, Max MR=%g, Tc Left=%g R, Tc Right=%g R>'''%\
            (self.cea_oxName, self.cea_fuelName, self.Stoich_MR, self.min_MR, self.max_MR, self.Tc_at_min_MR, self.Tc_at_max_MR)