# -*- coding: utf-8 -*-
# This file is part of pyChemEngg python package.
# PyChemEngg: A python-based framework to promote problem solving and critical
# thinking in chemical engineering.
# Copyright (c) 2021 Harvinder Singh Gill<EMAIL_ADDRESS># Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
# The above copyright notice and this permission notice shall be included in all
# copies or substantial portions of the Software.
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
"""
Module for transient/unsteady state heat transfer.
"""
import numpy as np
from scipy.optimize import brentq
from scipy.optimize import fsolve
from scipy.special import j0
from scipy.special import j1
from scipy.special import erfc
__all__ = ["LumpedSystem", "NonLumpedSlab", "NonLumpedCylinder",
"NonLumpedSphere", "SemiInfinite"]
sin=np.sin
cos=np.cos
[docs]class LumpedSystem():
r""" Model for lumped system analysis.
Parameters
----------
surfacearea : `int or float`
Surface area of solid object.
volume : `int or float`
Volume of solid object.
density : `int or float`
Density of solid object.
specificheat : `int or float`
Specific heat of solid object.
thermalconductivity : `int or float`
Thermal conductivity of solid object.
heattransfercoefficient : `int or float`
Heat transfer coefficient between solid object and surrounding.
T_infinity : `int or float`
Temperature of surroundings.
T_initial : `int or float`
Temperature of solid object at time = 0.
Attributes
----------
See "Parameters". All parameters are attributes. Additional attributes are listed below.
mass : `int or float`
Mass of solid object computed as (volume * density) of solid object.
characteristiclength : `int or float`
Characteristic length of object computed as (volume/surface area) of object.
Examples
--------
First import the module **transient**
Units used in this example: SI system
However, any consistent units can be used
>>> from pychemengg.heattransfer import transient
>>> plate = transient.LumpedSystem(thermalconductivity=180, density=2800, specificheat=880, T_initial=700, T_infinity=15, heattransfercoefficient=53, surfacearea=2*1, volume=1*2e-2)
# This will create an instance of 'LumpedSystem' with a name 'plate'
"""
[docs] def __init__(self, surfacearea=None,
volume=None,
density=None,
specificheat=None,
thermalconductivity=None,
heattransfercoefficient=None,
T_infinity=None,
T_initial=None):
# assign
self.surfacearea = surfacearea
self.volume = volume
self.density=density
self.specificheat=specificheat
self.thermalconductivity = thermalconductivity
self.heattransfercoefficient=heattransfercoefficient
self.T_infinity=T_infinity
self.T_initial=T_initial
# calculate
self.mass = self.volume * self.density
self.characteristiclength = self.volume/self.surfacearea
[docs] def calc_Bi(self):
r"""Computes Biot number.
Parameters
----------
None_required : `None`
Attributes that are already defined are used in calculation.
Returns
-------
Bi : `int or float`
Biot number
Notes
-----
Biot number is calculated using the following formula.
.. math::
Bi = \frac {h L_{c}} {k}
*where:*
*h = heat transfer coefficient*
*k = thermal conductivity of solid object*
:math:`L_c` *= characteristic length of solid object*
*Bi = Biot number*
Examples
--------
First import the module **transient**
Units used in this example: SI system
However, any consistent units can be used
>>> from pychemengg.heattransfer import transient
>>> plate = transient.LumpedSystem(thermalconductivity=180, density=2800, specificheat=880, T_initial=700, T_infinity=15, heattransfercoefficient=53, surfacearea=2*1, volume=1*2e-2)
# This will create an instance of 'LumpedSystem' with a name 'plate'
# Next call calc_Bi
>>> plate.calc_Bi()
0.0029444444444444444
References
----------
[1] Y. A. Cengel and A. J. Ghajar, "Heat And Mass Transfer
Fundamentals and Applications", 6th Edition. New York, McGraw Hill
Education, 2020.
"""
self.Bi = (self.heattransfercoefficient
* self.characteristiclength
/ self.thermalconductivity)
return self.Bi
[docs] def calc_temperature_of_solid_at_time_t(self, time=None):
r"""Temperature of solid object at a given time = t.
Parameters
----------
time : `int or float`
Time instant from begining of process, at which temperature
of solid object is to be found.
Returns
-------
temperature : `int or float`
Temperature of solid object at time = t
Notes
-----
Temperature of solid object at time = t is calculated using the following formula:
.. math::
T(t) = T_{infinity} + (T_{initial} - T_{infinity}) e^{-bt}
*where:*
:math:`T_{infinity}` *= temperature of surrounding fluid*
:math:`T_{initial}` *= intitial temperature of solid object*
:math:`b = \frac{hA_s}{\rho V C_p}`
*t = time at which temperature is to be computed*
where:
*h = heat transfer coefficient*
:math:`A_s` *= surface area of solid object*
:math:`\rho` *= density of solid object*
*V = volume of solid object*
:math:`C_p` *= specific heat of solid object*
Examples
--------
First import the module **transient**
Units used in this example: SI system
However, any consistent units can be used
>>> from pychemengg.heattransfer import transient
>>> plate = transient.LumpedSystem(thermalconductivity=180, density=2800, specificheat=880, T_initial=700, T_infinity=15, heattransfercoefficient=53, surfacearea=2*1, volume=1*2e-2)
# This will create an instance of 'LumpedSystem' with a name 'plate'
# Let temperature at time = 60 s after start of the process be needed.
# Next call the following
>>> plate.calc_temperature_of_solid_at_time_t(time=60s)
617.0619799301729
References
----------
[1] Y. A. Cengel and A. J. Ghajar, "Heat And Mass Transfer
Fundamentals and Applications", 6th Edition. New York, McGraw Hill
Education, 2020.
"""
b = ((self.heattransfercoefficient * self.surfacearea)
/ (self.density*self.volume*self.specificheat)) # unit of b is 1/time
solidtemp_at_time_t = (self.T_infinity
+ (self.T_initial-self.T_infinity)*np.exp(-b*time+0j))
return solidtemp_at_time_t.real
[docs] def calc_heatrateof_conv_at_time_t(self, time=None):
r"""Heat rate of convection between object and surroundings at a given time = t.
Parameters
----------
time : `int or float`
Time instant from begining of process, at which heat rate is to be found.
Returns
-------
heat rate of convection : `int or float; Positive: Heat is gained by object, Negative: Heat is lost by object`
Heat rate of convection between solid object and surroundings at time = t.
Notes
-----
Heat rate is calculated using the following formula:
.. math::
q_{t} = h A_s (T_{infinity} - T_{t})
*where:*
*t = time at which temperature is to be computed*
*h = heat transfer coefficient*
:math:`T_{infinity}` *= temperature of surrounding fluid*
:math:`T_{t}` *= temperature of solid object at time = t*
:math:`A_s` *= surface area of solid object*
:math:`q_{t}` *= heat rate at time = t*
Examples
--------
First import the module **transient**
Units used in this example: SI system
However, any consistent units can be used
>>> from pychemengg.heattransfer import transient
>>> plate = transient.LumpedSystem(thermalconductivity=180, density=2800, specificheat=880, T_initial=700, T_infinity=15, heattransfercoefficient=53, surfacearea=2*1, volume=1*2e-2)
# This will create an instance of 'LumpedSystem' with a name 'plate'
# Let temperature at time = 60 s after start of the process be needed.
# Next call the following
>>> plate.calc_heatrateof_conv_at_time_t(time=60)
-63818.56987259833
# negative value indicates heat is being lost by the solid object
References
----------
[1] Y. A. Cengel and A. J. Ghajar, "Heat And Mass Transfer
Fundamentals and Applications", 6th Edition. New York, McGraw Hill
Education, 2020.
"""
q_rate = (self.heattransfercoefficient * self.surfacearea
*(self.calc_temperature_of_solid_at_time_t(time=time) - self.T_infinity))
return q_rate
[docs] def calc_totalheat_transferred_during_interval_t(self, time=None):
r"""Heat transferred between solid object and surroundings during
time interval = 0 to t.
Parameters
----------
time : `int or float`
Time-limit after start of process for which
heat transferred is to be computed.
Returns
-------
total heat transferred : `int or float; Positive: Heat is gained by object, Negative: Heat is lost by object`
Total heat transferred between object and
surroundings during interval 0 to t
Notes
-----
Total heat transferred in interval 0 to t is calculated using the
following formula:
.. math::
q_{0 \to t} = m C_p (T_{t} - T_{inintial})
*where:*
*t = time marking the interval [0, t] for which heat
transferred is to be computed*
*m = mass of object*
:math:`C_{p}` *= specific heat of object*
:math:`T_{t}` *= temperature of object at time = t*
:math:`T_{initial}` *= temperature of object at time = 0*
:math:`q_{0 \to t}` *= heat transferred in interval [0, t]*
Examples
--------
First import the module **transient**
Units used in this example: SI system
However, any consistent units can be used
>>> from pychemengg.heattransfer import transient
>>> plate = transient.LumpedSystem(thermalconductivity=180, density=2800, specificheat=880, T_initial=700, T_infinity=15, heattransfercoefficient=53, surfacearea=2*1, volume=1*2e-2)
# This will create an instance of 'LumpedSystem' with a name 'plate'
# Let heat transferred in time = 60 s after start of the process be needed.
# Next call the following
>>> plate.calc_totalheat_transferred_during_interval_t(time=60)
-4087185.6290410785
# negative value indicates heat is being lost by the solid object
References
----------
[1] Y. A. Cengel and A. J. Ghajar, "Heat And Mass Transfer
Fundamentals and Applications", 6th Edition. New York, McGraw Hill
Education, 2020.
"""
qtotal = (self.mass * self.specificheat
* (self.calc_temperature_of_solid_at_time_t(time=time) - self.T_initial))
return qtotal
[docs] def calc_maxheattransferpossible(self):
r"""Maximum possible heat transfer between solid object and surroundings.
Parameters
----------
None_required : `None`
This class takes no parameters for instance creation.
Returns
-------
maximum heat transfer possible: `int or float; Positive: Heat is gained by object, Negative: Heat is lost by object`
Maximum heat transfer posssible between object and
surroundings
Notes
-----
Maximum heat transfer possible between solid object and surroundings
is calculated using the following formula. This is based on the assumption
that final object temperature will eventually reach surrounding temperature
of :math:`T_{infinity}`
.. math::
q_{max} = m C_p (T_{infinity} - T_{initial})
*where:*
*m = mass of solid object*
:math:`C_{p}` *= specific heat of solid object*
:math:`T_{infinity}` *= temperature of surrounding, which the solid object will eventually attain*
:math:`T_{initial}` *= temperature of solid object at time = initial*
:math:`q_{max}` *= max heat transfer possible*
Examples
--------
First import the module **transient**
Units used in this example: SI system
However, any consistent units can be used
>>> from pychemengg.heattransfer import transient
>>> plate = transient.LumpedSystem(thermalconductivity=180, density=2800, specificheat=880, T_initial=700, T_infinity=15, heattransfercoefficient=53, surfacearea=2*1, volume=1*2e-2)
# This will create an instance of 'LumpedSystem' with a name 'plate'
# Next call the following
>>> plate.calc_maxheattransferpossible()
-33756800.0
# negative value indicates heat is being lost by the solid object
References
----------
[1] Y. A. Cengel and A. J. Ghajar, "Heat And Mass Transfer
Fundamentals and Applications", 6th Edition. New York, McGraw Hill
Education, 2020.
"""
qtotal_max = self.mass * self.specificheat * (self.T_infinity - self.T_initial)
return qtotal_max
[docs]class NonLumpedSlab():
r""" Model for nonlumped analysis of rectangular solid object.
Parameters
----------
thickness : `int or float`
Thickness of solid object
surfacearea : `int or float`
Surface area of solid object.
volume : `int or float`
Volume of solid object.
density : `int or float`
Density of solid object.
specificheat : `int or float`
Specific heat of solid object.
thermalconductivity : `int or float`
Thermal conductivity of solid object.
thermaldiffusivity : `int or float`
Thermal diffusivity of solid object.
heattransfercoefficient : `int or float`
Heat transfer coefficient between solid object and surrounding.
T_infinity : `int or float`
Temperature of surroundings.
T_initial : `int or float`
Temperature of solid object at time = 0.
Attributes
----------
See "Parameters". All parameters are attributes. Additional attributes are listed below.
mass : `int or float`
Mass of solid object computed as (volume * density) of solid object.
Examples
--------
First import the module **transient**
Units used in this example: SI system
However, any consistent units can be used
>>> from pychemengg.heattransfer import transient
>>> plate = transient.NonLumpedSlab(thickness=4e-2, surfacearea=1, volume=1*4e-2, density=8530, specificheat=380, thermalconductivity=110, thermaldiffusivity=None, heattransfercoefficient=120, T_infinity=500, T_initial=20)
# This will create an instance of 'NonLumpedSlab' with a name 'plate'
"""
[docs] def __init__(self, thickness=None,
surfacearea=None,
volume=None,
density=None,
specificheat=None,
thermalconductivity=None,
thermaldiffusivity=None,
heattransfercoefficient=None,
T_infinity=None,
T_initial=None):
# assign
self.thickness = thickness
self.surfacearea=surfacearea
self.volume=volume
self.density=density
self.specificheat=specificheat
self.thermalconductivity = thermalconductivity
self.heattransfercoefficient=heattransfercoefficient
self.T_infinity=T_infinity
self.T_initial=T_initial
# calculate mass
if self.density is not None:
self.mass = self.volume * self.density
# calculate thermal diffusivity
if (self.density is not None) and (self.specificheat is not None):
self.thermaldiffusivity = self.thermalconductivity/self.density/self.specificheat
else:
if thermaldiffusivity is not None:
self.thermaldiffusivity = thermaldiffusivity
[docs] def calc_Bi(self):
r"""Computes Biot number.
Parameters
----------
None_required : `None`
Attributes that are already defined are used in calculation.
Returns
-------
Bi : `int or float`
Biot number
Notes
-----
Biot number is calculated using the following formula.
.. math::
Bi = \frac {h L_{c}} {k}
*where:*
*h = heat transfer coefficient*
*k = thermal conductivity of solid object*
:math:`L_c` *= characteristic length of solid object = thickness/2*
*Bi = Biot number*
Examples
--------
First import the module **transient**
Units used in this example: SI system
However, any consistent units can be used
>>> from pychemengg.heattransfer import transient
>>> plate = transient.NonLumpedSlab(thickness=4e-2, surfacearea=1, volume=1*4e-2, density=8530, specificheat=380, thermalconductivity=110, thermaldiffusivity=None, heattransfercoefficient=120, T_infinity=500, T_initial=20)
# This will create an instance of 'NonLumpedSlab' with a name 'plate'
# Next call calc_Bi
>>> plate.calc_Bi()
0.021818181818181816
References
----------
[1] Y. A. Cengel and A. J. Ghajar, "Heat And Mass Transfer
Fundamentals and Applications", 6th Edition. New York, McGraw Hill
Education, 2020.
"""
self.Bi = (self.heattransfercoefficient
* self.thickness/2
/ self.thermalconductivity)
return self.Bi
[docs] def calc_Fo(self, time=None):
r"""Computes Fourier number.
Parameters
----------
time : `int or float`
Time at which temperature or heat transfer is to be evaluated.
Returns
-------
Fo : `int or float`
Fourier number
Notes
-----
Fourier number is calculated using the following formula.
.. math::
Fo = \frac {\alpha t} {L_c^2}
*where:*
:math:`\alpha` *= thermal diffusivity*
*t = time at which temperature or heat transfer is to be evaluated*
:math:`L_c` *= characteristic length = (slab thickness)/2*
*Fo = Fourier number*
Examples
--------
First import the module **transient**
Units used in this example: SI system
However, any consistent units can be used
>>> from pychemengg.heattransfer import transient
>>> plate = transient.NonLumpedSlab(thickness=4e-2, surfacearea=1, volume=1*4e-2, density=8530, specificheat=380, thermalconductivity=110, thermaldiffusivity=None, heattransfercoefficient=120, T_infinity=500, T_initial=20)
# This will create an instance of 'NonLumpedSlab' with a name 'plate'
# Next call calc_Fo assuming temperature is required at 7 min
>>> plate.calc_Fo(time=7*60)
35.63275128031097
References
----------
[1] Y. A. Cengel and A. J. Ghajar, "Heat And Mass Transfer
Fundamentals and Applications", 6th Edition. New York, McGraw Hill
Education, 2020.
"""
self.Fo = self.thermaldiffusivity*time/(self.thickness/2)**2
return self.Fo
[docs] def calc_eigenvalues(self, numberof_eigenvalues_desired=10):
r"""Computes eigen values of characteristic equation for Slab geometry.
Parameters
----------
numberof_eigenvalues_desired : `int or float` (default = 10)
Number of eigen values desired for the characteristic equation.
Returns
-------
eigenvalues : `np.array of int or float`
Eigen values
Notes
-----
Eigen values are calculated as roots of the following equation.
.. math::
x_n tan(x_n) - Bi = 0 , n = 1 \hspace{2pt} to \hspace{2pt} \infty
*where:*
:math:`x_n` *= nth eigen value*
*Bi = Biot number*
Examples
--------
First import the module **transient**
Units used in this example: SI system
However, any consistent units can be used
>>> from pychemengg.heattransfer import transient
>>> plate = transient.NonLumpedSlab(thickness=4e-2, surfacearea=1, volume=1*4e-2, density=8530, specificheat=380, thermalconductivity=110, thermaldiffusivity=None, heattransfercoefficient=120, T_infinity=500, T_initial=20)
# This will create an instance of 'NonLumpedSlab' with a name 'plate'
# Next call calc_Bi
>>> plate.calc_Bi()
0.021818181818181816
# Let first 5 eigen values be required
>>> plate.calc_eigenvalues(numberof_eigenvalues_desired=5)
array([ 0.14717481, 3.1485222 , 6.28665585, 9.42709237, 12.56810661])
References
----------
[1] Y. A. Cengel and A. J. Ghajar, "Heat And Mass Transfer
Fundamentals and Applications", 6th Edition. New York, McGraw Hill
Education, 2020.
"""
slab_eigenfunction = lambda x, Bi: x*np.tan(x)-Bi
slab_eigenvalues = _get_eigenvalues(slab_eigenfunction, Bi=self.Bi,
numberof_eigenvalues_desired=numberof_eigenvalues_desired)
self.eigenvalues = np.array(slab_eigenvalues)
return self.eigenvalues
[docs] def calc_temperature_of_solid_at_time_t(self, time=None, xposition_tofindtemp=None):
r"""Calculates temperature of solid object at a given time = t and position = x.
Parameters
----------
time : `int or float`
Time instant from begining of process, at which temperature
of solid object is to be found.
xposition_tofindtemp : `int or float`
Distance measured from center of rectangular object where temperature is to be found.
Returns
-------
temperature : `int or float`
Temperature of solid object at time = t and position = x.
Notes
-----
Temperature of solid object at time = t and position = x is calculated using the following formula:
.. math::
T(t) = T_{infinity} + (T_{initial} - T_{infinity}) \displaystyle\sum_{n=1}^\infty \cfrac{4sin(\lambda_n)}{2 \lambda_n + sin(2 \lambda_n)} e^{- \lambda_n^2 \tau} cos(\lambda_n x/L)
*where:*
:math:`T_{infinity}` *= temperature of surrounding fluid*
:math:`T_{initial}` *= intitial temperature of solid object*
:math:`\lambda_n` *= nth eigen value of* :math:`x_n tan(x_n) - Bi = 0` *, n = 1* :math:`\hspace{2pt} to \hspace{2pt} \infty`
:math:`\tau` *= Fourier number*
*x = distance from center of solid slab where temperature is required (x = 0 for center of slab)*
*L = thickness/2*
Examples
--------
First import the module **transient**
Units used in this example: SI system
However, any consistent units can be used
>>> from pychemengg.heattransfer import transient
>>> plate = transient.NonLumpedSlab(thickness=4e-2, surfacearea=1, volume=1*4e-2, density=8530, specificheat=380, thermalconductivity=110, thermaldiffusivity=None, heattransfercoefficient=120, T_infinity=500, T_initial=20)
# This will create an instance of 'NonLumpedSlab' with a name 'plate'
# Let temperature at time = 7 min after start of the process be required.
# Next call the following
>>> plate.calc_Bi()
0.021818181818181816
>>> plate.calc_Fo(time=7*60)
35.63275128031097
plate.calc_eigenvalues()
array([ 0.14717481, 3.1485222 , 6.28665585, 9.42709237, 12.56810661,
15.70935213, 18.85071334, 21.99214066, 25.13360932, 28.27510552])
>>> plate.calc_temperature_of_solid_at_time_t(time=7*60, xposition_tofindtemp=plate.thickness/2)
279.76430920417204
References
----------
[1] Y. A. Cengel and A. J. Ghajar, "Heat And Mass Transfer
Fundamentals and Applications", 6th Edition. New York, McGraw Hill
Education, 2020.
"""
term1 = 4*np.sin(self.eigenvalues)
term2 = 2*self.eigenvalues + np.sin(2*self.eigenvalues)
term3 = np.exp(-np.power(self.eigenvalues,2) * self.Fo)
term4 = np.cos(self.eigenvalues*xposition_tofindtemp/(self.thickness/2))
theta = np.sum(term1/term2*term3*term4)
self.solidtemp_at_time_t = (self.T_infinity
+ (self.T_initial-self.T_infinity)*theta)
return self.solidtemp_at_time_t
[docs] def calc_heatrateof_conv_at_time_t(self, time=None):
r"""Heat rate of convection between object and surroundings at a given time = t.
Parameters
----------
time : `int or float`
Time instant from begining of process, at which heat rate is to be found.
Returns
-------
heat rate of convection : `int or float ; Positive: Heat is gained by object, Negative: Heat is lost by object`
Heat rate of convection between solid object and surroundings at time = t.
Notes
-----
Heat rate of convection is calculated using the following formula:
.. math::
q_{t} = h A_s (T_{infinity} - T_{t})
*where:*
*t = time at which temperature is to be computed*
*h = heat transfer coefficient*
:math:`T_{infinity}` *= temperature of surrounding fluid*
:math:`T_{t}` *= temperature of surface of solid object at time = t*
:math:`A_s` *= surface area of solid object*
:math:`q_{t}` *= heat rate of convection at time = t*
Examples
--------
First import the module **transient**
Units used in this example: SI system
However, any consistent units can be used
>>> from pychemengg.heattransfer import transient
>>> plate = transient.NonLumpedSlab(thickness=4e-2, surfacearea=1, volume=1*4e-2, density=8530, specificheat=380, thermalconductivity=110, thermaldiffusivity=None, heattransfercoefficient=120, T_infinity=500, T_initial=20)
# This will create an instance of 'NonLumpedSlab' with a name 'plate'
# Let temperature at time = 7 min after start of the process be required.
# Next call the following
>>> plate.calc_Bi()
0.021818181818181816
>>> plate.calc_Fo(time=7*60)
35.63275128031097
plate.calc_eigenvalues()
array([ 0.14717481, 3.1485222 , 6.28665585, 9.42709237, 12.56810661,
15.70935213, 18.85071334, 21.99214066, 25.13360932, 28.27510552])
>>> plate.calc_temperature_of_solid_at_time_t(time=7*60, xposition_tofindtemp=plate.thickness/2)
279.76430920417204
# Next call the following
>>> plate.calc_heatrateof_conv_at_time_t(time=7*60)
26428.282895499357
# Positive sign indicates gain of heat by the solid object
References
----------
[1] Y. A. Cengel and A. J. Ghajar, "Heat And Mass Transfer
Fundamentals and Applications", 6th Edition. New York, McGraw Hill
Education, 2020.
"""
qrate = (self.heattransfercoefficient * self.surfacearea
*(self.T_infinity - self.calc_temperature_of_solid_at_time_t(time=None, xposition_tofindtemp=self.thickness/2)))
# For convection, surface temperature is required, therefore let
# xposition_tofindtemp = surface position = thickness/2 because origin is in middle
return qrate
[docs] def calc_totalheat_transferred_during_interval_t(self):
r"""Heat transferred between solid object and surroundings during
time interval = 0 to t.
Parameters
----------
None_required : `None`
Attributes that are already defined or calculated are used in calculation.
Returns
-------
total heat transferred : `int or float; Positive: Heat is gained by object, Negative: Heat is lost by object`
Total heat transferred between object and surroundings during interval 0 to t
Notes
-----
Total heat transferred in interval 0 to t is calculated using the
following formula:
.. math::
q_{0 \to t} = q_{max} \left( 1 - \displaystyle\sum_{n=1}^\infty \cfrac{4sin( \lambda_n)}{2 \lambda_n + sin(2 \lambda_n)} \frac{sin( \lambda_n)}{\lambda_n} e^{- \lambda_n^2 \tau} \right)
*where:*
:math:`\lambda_n` *= nth eigen value of* :math:`x_n tan(x_n) - Bi = 0` *, n = 1* :math:`\hspace{2pt} to \hspace{2pt} \infty`
:math:`\tau` *= Fourier number*
:math:`q_{max}` *= maximum heat transfer possible between object and surroundings*
See Also
----------
pychemengg.heattransfer.transient.NonLumpedSlab.calc_maxheattransferpossible
Examples
--------
First import the module **transient**
Units used in this example: SI system
However, any consistent units can be used
>>> from pychemengg.heattransfer import transient
>>> plate = transient.NonLumpedSlab(thickness=4e-2, surfacearea=1, volume=1*4e-2, density=8530, specificheat=380, thermalconductivity=110, thermaldiffusivity=None, heattransfercoefficient=120, T_infinity=500, T_initial=20)
# This will create an instance of 'NonLumpedSlab' with a name 'plate'
# Let temperature at time = 7 min after start of the process be required.
# Next call the following
>>> plate.calc_Bi()
0.021818181818181816
>>> plate.calc_Fo(time=7*60)
35.63275128031097
plate.calc_eigenvalues()
array([ 0.14717481, 3.1485222 , 6.28665585, 9.42709237, 12.56810661,
15.70935213, 18.85071334, 21.99214066, 25.13360932, 28.27510552])
>>> plate.calc_totalheat_transferred_during_interval_t()
33472028.92491645
# Positive value means heat is gained by the object.
References
----------
[1] Y. A. Cengel and A. J. Ghajar, "Heat And Mass Transfer
Fundamentals and Applications", 6th Edition. New York, McGraw Hill
Education, 2020.
"""
term1 = 4*np.sin(self.eigenvalues)
term2 = 2*self.eigenvalues + np.sin(2*self.eigenvalues)
term3 = np.exp(-np.power(self.eigenvalues,2) * self.Fo)
term4 = np.sin(self.eigenvalues)/self.eigenvalues
normalized_heatamount = 1 - np.sum(term1/term2*term3*term4)
heattransferred = self.calc_maxheattransferpossible() * normalized_heatamount
return heattransferred
[docs] def calc_maxheattransferpossible(self):
r"""Maximum possible heat transfer between solid object and surroundings.
Parameters
----------
None_required : `None`
Attributes that are already defined are used in calculation.
Returns
-------
maximum heat transfer possible: `int or float; Positive: Heat is gained by object, Negative: Heat is lost by object`
Maximum heat transfer posssible between object and surroundings.
Notes
-----
Maximum heat transfer possible between solid object and surroundings
is calculated using the following formula. This is based on the assumption
that final object temperature will eventually reach surrounding temperature
of :math:`T_{infinity}`
.. math::
q_{max} = m C_p (T_{infinity} - T_{initial})
*where:*
*m = mass of solid object*
:math:`C_{p}` *= specific heat of solid object*
:math:`T_{infinity}` *= temperature of surrounding, which the solid object will eventually attain*
:math:`T_{initial}` *= temperature of solid object at time = initial*
:math:`q_{max}` *= max heat transfer possible*
Examples
--------
First import the module **transient**
Units used in this example: SI system
However, any consistent units can be used
>>> from pychemengg.heattransfer import transient
>>> plate = transient.NonLumpedSlab(thickness=4e-2, surfacearea=1, volume=1*4e-2, density=8530, specificheat=380, thermalconductivity=110, thermaldiffusivity=None, heattransfercoefficient=120, T_infinity=500, T_initial=20)
# This will create an instance of 'NonLumpedSlab' with a name 'plate'
>>> plate.calc_maxheattransferpossible()
62234880.0
# negative value indicates heat is being lost by the solid object
References
----------
[1] Y. A. Cengel and A. J. Ghajar, "Heat And Mass Transfer
Fundamentals and Applications", 6th Edition. New York, McGraw Hill
Education, 2020.
"""
qtotal_max = self.mass * self.specificheat * (self.T_infinity - self.T_initial)
return qtotal_max
[docs]class NonLumpedCylinder():
r""" Model for nonlumped analysis of cylindrical solid object.
Parameters
----------
radius : `int or float`
Radius of solid object.
surfacearea : `int or float`
Surface area of solid object.
volume : `int or float`
Volume of solid object.
density : `int or float`
Density of solid object.
specificheat : `int or float`
Specific heat of solid object.
thermalconductivity : `int or float`
Thermal conductivity of solid object.
thermaldiffusivity : `int or float`
Thermal diffusivity of solid object.
heattransfercoefficient : `int or float`
Heat transfer coefficient between solid object and surrounding.
T_infinity : `int or float`
Temperature of surroundings.
T_initial : `int or float`
Temperature of solid object at time = 0.
Attributes
----------
See "Parameters". All parameters are attributes. Additional attributes are listed below.
mass : `int or float`
Mass of solid object computed as (volume * density) of solid object.
Examples
--------
First import the module **transient**
Units used in this example: SI system
However, any consistent units can be used
>>> from pychemengg.heattransfer import transient
>>> cylinder=transient.NonLumpedCylinder(radius=10e-2, surfacearea=1, T_initial=600, volume=np.pi*10e-2**2*1, T_infinity=200, density=7900, thermaldiffusivity=None, specificheat=477, heattransfercoefficient=80, thermalconductivity=14.9)
# This will create an instance of 'NonLumpedCylinder' with a name 'cylinder'
"""
[docs] def __init__(self, radius=None,
surfacearea=None,
volume=None,
density=None,
specificheat=None,
thermalconductivity=None,
thermaldiffusivity=None,
heattransfercoefficient=None,
T_infinity=None,
T_initial=None):
# assign
self.radius = radius
self.surfacearea=surfacearea
self.volume=volume
self.density=density
self.specificheat=specificheat
self.thermalconductivity = thermalconductivity
self.heattransfercoefficient=heattransfercoefficient
self.T_infinity=T_infinity
self.T_initial=T_initial
# calculate mass
if self.density is not None:
self.mass = self.volume * self.density
# calculate thermal diffusivity
if (self.density is not None) and (self.specificheat is not None):
self.thermaldiffusivity = self.thermalconductivity/self.density/self.specificheat
else:
if thermaldiffusivity is not None:
self.thermaldiffusivity = thermaldiffusivity
[docs] def calc_Bi(self):
r"""Computes Biot number.
Parameters
----------
None_required : `None`
Attributes that are already defined are used in calculation.
Returns
-------
Bi : `int or float`
Biot number
Notes
-----
Biot number is calculated using the following formula.
.. math::
Bi = \frac {h L_{c}} {k}
*where:*
*h = heat transfer coefficient*
*k = thermal conductivity of solid object*
:math:`L_c` *= characteristic length of solid object = radius*
*Bi = Biot number*
Examples
--------
First import the module **transient**
Units used in this example: SI system
However, any consistent units can be used
>>> from pychemengg.heattransfer import transient
>>> cylinder=transient.NonLumpedCylinder(radius=10e-2, surfacearea=1, T_initial=600, volume=np.pi*10e-2**2*1, T_infinity=200, density=7900, thermaldiffusivity=None, specificheat=477, heattransfercoefficient=80, thermalconductivity=14.9)
# This will create an instance of 'NonLumpedSlab' with a name 'plate'
# Next call calc_Bi
>>> cylinder.calc_Bi()
0.5369127516778524
References
----------
[1] Y. A. Cengel and A. J. Ghajar, "Heat And Mass Transfer
Fundamentals and Applications", 6th Edition. New York, McGraw Hill
Education, 2020.
"""
self.Bi = (self.heattransfercoefficient
* self.radius
/ self.thermalconductivity)
return self.Bi
[docs] def calc_Fo(self, time=None):
r"""Computes Fourier number.
Parameters
----------
time : `int or float`
Time at which temperature or heat transfer is to be evaluated.
Returns
-------
Fo : `int or float`
Fourier number
Notes
-----
Fourier number is calculated using the following formula.
.. math::
Fo = \frac {\alpha t} {L_c^2}
*where:*
:math:`\alpha` *= thermal diffusivity*
*t = time at which temperature or heat transfer is to be evaluated*
:math:`L_c` *= characteristic length = radius*
*Fo = Fourier number*
Examples
--------
First import the module **transient**
Units used in this example: SI system
However, any consistent units can be used
>>> from pychemengg.heattransfer import transient
>>> cylinder=transient.NonLumpedCylinder(radius=10e-2, surfacearea=1, T_initial=600, volume=np.pi*10e-2**2*1, T_infinity=200, density=7900, thermaldiffusivity=None, specificheat=477, heattransfercoefficient=80, thermalconductivity=14.9)
# This will create an instance of 'NonLumpedSlab' with a name 'plate'
# Next call calc_Fo assuming temperature is required at 7 min
>>> cylinder.calc_Fo(time=7*60)
0.16606958044741657
References
----------
[1] Y. A. Cengel and A. J. Ghajar, "Heat And Mass Transfer
Fundamentals and Applications", 6th Edition. New York, McGraw Hill
Education, 2020.
"""
self.Fo = self.thermaldiffusivity * time / (self.radius)**2
return self.Fo
[docs] def calc_eigenvalues(self, numberof_eigenvalues_desired=10):
r"""Computes eigen values of characteristic equation for Cylindrical geometry.
Parameters
----------
numberof_eigenvalues_desired : `int or float` (default = 10)
Number of eigen values desired for the characteristic equation.
Returns
-------
eigenvalues : `np.array of int or float`
Eigen values
Notes
-----
Eigen values are calculated as roots of the following equation.
.. math::
\lambda_n \frac{J_1(\lambda_n)}{J_0(\lambda_n)} - Bi = 0 , n = 1 \hspace{2pt} to \hspace{2pt} \infty
*where:*
:math:`J_0` *= Bessel function of first kind of order 0*
:math:`J_1` *= Bessel function of first kind of order 1*
:math:`\lambda_n` *= nth eigen value*
*Bi = Biot number*
Examples
--------
First import the module **transient**
Units used in this example: SI system
However, any consistent units can be used
>>> from pychemengg.heattransfer import transient
>>> cylinder=transient.NonLumpedCylinder(radius=10e-2, surfacearea=1, T_initial=600, volume=np.pi*10e-2**2*1, T_infinity=200, density=7900, thermaldiffusivity=None, specificheat=477, heattransfercoefficient=80, thermalconductivity=14.9)
# This will create an instance of 'NonLumpedSlab' with a name 'plate'
# Next call calc_Bi
>>> cylinder.calc_Bi()
0.5369127516778524
# Let first 5 eigen values be required
>>> cylinder.calc_eigenvalues(numberof_eigenvalues_desired=5)
array([ 0.97061535, 3.96852663, 7.0915602 , 10.22605944, 13.36390715])
References
----------
[1] Y. A. Cengel and A. J. Ghajar, "Heat And Mass Transfer
Fundamentals and Applications", 6th Edition. New York, McGraw Hill
Education, 2020.
"""
cylinder_eigenfunction = lambda x, Bi: x*j1(x)/j0(x)-Bi
cylinder_eigenvalues = _get_eigenvalues(cylinder_eigenfunction, Bi=self.Bi,
numberof_eigenvalues_desired=numberof_eigenvalues_desired)
self.eigenvalues = np.array(cylinder_eigenvalues)
return self.eigenvalues
[docs] def calc_temperature_of_solid_at_time_t(self, rposition_tofindtemp=None):
r"""Calculates temperature of solid object at a given time = t and radius = r.
Parameters
----------
time : `int or float`
Time instant from begining of process, at which temperature
of solid object is to be found.
rposition_tofindtemp : `int or float`
Radius from center of cylindrical object where temperature is to be found.
Returns
-------
temperature : `int or float`
Temperature of solid object at time = t and radius = r.
Notes
-----
Temperature of solid object at time = t and radius = r is calculated using the following formula:
.. math::
T(t) = T_{infinity} + (T_{initial} - T_{infinity}) \displaystyle\sum_{n=1}^\infty \cfrac{2}{\lambda_n} \left( \frac{J_1(\lambda_n)}{J_0^2(\lambda_n) + J_1^2(\lambda_n)} \right) e^{- \lambda_n^2 \tau} J_0(\lambda_n r/r_{outside})
*where:*
:math:`T_{infinity}` *= temperature of surrounding fluid*
:math:`T_{initial}` *= intitial temperature of solid object*
:math:`J_0` *= Bessel function of first kind of order 0*
:math:`J_1` *= Bessel function of first kind of order 1*
:math:`\lambda_n` = :math:`n^{th}` eigen value of :math:`x_n tan(x_n) - Bi = 0` , n = 1 to :math:`\infty`
*Bi = Biot number*
:math:`\tau` *= Fourier number*
*r = radius from center of solid cylinder where temperature is required (r = 0 for center of cylinder)*
:math:`r_{outside}` *= outer radius of the cylinder*
Examples
--------
First import the module **transient**
Units used in this example: SI system
However, any consistent units can be used
>>> from pychemengg.heattransfer import transient
>>> cylinder=transient.NonLumpedCylinder(radius=10e-2, surfacearea=1, T_initial=600, volume=np.pi*10e-2**2*1, T_infinity=200, density=7900, thermaldiffusivity=None, specificheat=477, heattransfercoefficient=80, thermalconductivity=14.9)
# This will create an instance of 'NonLumpedSlab' with a name 'plate'
# Next call calc_Bi
>>> cylinder.calc_Bi()
0.5369127516778524
# Next call calc_Fo assuming temperature is required at 7 min
>>> cylinder.calc_Fo(time=7*60)
0.16606958044741657
# Let default (=10) eigen values be required
>>> cylinder.calc_eigenvalues()
array([ 0.97061535, 3.96852663, 7.0915602 , 10.22605944, 13.36390715,
16.50318456, 19.64320399, 22.78365791, 25.92438812, 29.06530494])
>>> cylinder.calc_temperature_of_solid_at_time_t(rposition_tofindtemp=0)
578.8399893522001
"""
term1 = 2/self.eigenvalues*j1(self.eigenvalues)
term2 = np.power(j0(self.eigenvalues),2) + np.power(j1(self.eigenvalues),2)
term3 = np.exp(-np.power(self.eigenvalues,2) * self.Fo)
term4 = j0(self.eigenvalues*rposition_tofindtemp/self.radius)
theta = np.sum(term1/term2*term3*term4)
solidtemp_at_time_t = (self.T_infinity
+ (self.T_initial-self.T_infinity)*theta)
self.solidtemp_at_time_t = solidtemp_at_time_t
return solidtemp_at_time_t
[docs] def calc_totalheat_transferred_during_interval_t(self):
r"""Heat transferred between solid object and surroundings during
time interval = 0 to t.
Parameters
----------
None_required : `None`
Attributes that are already defined or calculated are used in calculation.
Returns
-------
total heat transferred : `int or float; Positive: Heat is gained by object, Negative: Heat is lost by object`
Total heat transferred between object and
surroundings during interval 0 to t
Notes
-----
Total heat transferred in interval 0 to t is calculated using the
following formula:
.. math::
q_{0 \to t} = q_{max} \left( 1-2\displaystyle\sum_{n=1}^\infty \cfrac{2}{\lambda_n} \left( \frac{J_1(\lambda_n)}{J_0^2(\lambda_n) + J_1^2(\lambda_n)} \right) e^{- \lambda_n^2 \tau} \frac{J_1(\lambda_n) }{\lambda_n} \right)
*where:*
:math:`J_0` *= Bessel function of first kind of order 0*
:math:`J_1` *= Bessel function of first kind of order 1*
:math:`\lambda_n` = :math:`n^{th}` eigen value of :math:`x_n tan(x_n) - Bi = 0` , n = 1 to :math:`\infty`
*Bi = Biot number*
:math:`\tau` *= Fourier number*
:math:`q_{max}` = *maximum possible heat transfer between solid and surrounding*
:math:`q_{0 \to t}` *= heat transferred in time interval [0, t]*
See Also
----------
pychemengg.heattransfer.transient.NonLumpedCylinder.calc_maxheattransferpossible
Examples
--------
First import the module **transient**
Units used in this example: SI system
However, any consistent units can be used
>>> from pychemengg.heattransfer import transient
>>> cylinder=transient.NonLumpedCylinder(radius=10e-2, surfacearea=1, T_initial=600, volume=np.pi*10e-2**2*1, T_infinity=200, density=7900, thermaldiffusivity=None, specificheat=477, heattransfercoefficient=80, thermalconductivity=14.9)
# This will create an instance of 'NonLumpedSlab' with a name 'plate'
# Next call calc_Bi
>>> cylinder.calc_Bi()
0.5369127516778524
# Next call calc_Fo assuming temperature is required at 7 min
>>> cylinder.calc_Fo(time=7*60)
0.16606958044741657
# Let default (=10) eigen values be required
>>> cylinder.calc_eigenvalues()
array([ 0.97061535, 3.96852663, 7.0915602 , 10.22605944, 13.36390715,
16.50318456, 19.64320399, 22.78365791, 25.92438812, 29.06530494])
>>> cylinder.calc_totalheat_transferred_during_interval_t()
-7052779.476897862
References
----------
[1] Y. A. Cengel and A. J. Ghajar, "Heat And Mass Transfer
Fundamentals and Applications", 6th Edition. New York, McGraw Hill
Education, 2020.
"""
term1 = 2/self.eigenvalues*j1(self.eigenvalues)
term2 = np.power(j0(self.eigenvalues),2) + np.power(j1(self.eigenvalues),2)
term3 = np.exp(-np.power(self.eigenvalues,2) * self.Fo)
term4 = 2*j1(self.eigenvalues)/self.eigenvalues
normalized_heatamount = 1 - np.sum(term1/term2*term3*term4)
heattransferred = self.calc_maxheattransferpossible() * normalized_heatamount
return heattransferred
[docs] def calc_heatrateof_conv_at_time_t(self):
r"""Heat rate of convection between object and surroundings at a given time = t.
Parameters
----------
None_required : `None`
Attributes that are already defined are used in calculation.
Returns
-------
heat rate of convection : `int or float ; Positive: Heat is gained by object, Negative: Heat is lost by object`
Heat rate of convection between solid object and surroundings at time = t.
Notes
-----
Heat rate of convection is calculated using the following formula:
.. math::
q_{t} = h A_s (T_{infinity} - T_{t})
*where:*
*t = time at which temperature is to be computed*
*h = heat transfer coefficient*
:math:`T_{infinity}` *= temperature of surrounding fluid*
:math:`T_{t}` *= temperature of surface of solid object at time = t*
:math:`A_s` *= surface area of solid object*
:math:`q_{t}` *= heat rate of convection at time = t*
Examples
--------
First import the module **transient**
Units used in this example: SI system
However, any consistent units can be used
>>> from pychemengg.heattransfer import transient
>>> cylinder=transient.NonLumpedCylinder(radius=10e-2, surfacearea=1, T_initial=600, volume=np.pi*10e-2**2*1, T_infinity=200, density=7900, thermaldiffusivity=None, specificheat=477, heattransfercoefficient=80, thermalconductivity=14.9)
# This will create an instance of 'NonLumpedCylinder' with a name 'cylinder'
# Next call calc_Bi
>>> cylinder.calc_Bi()
0.5369127516778524
# Next call calc_Fo assuming temperature is required at 7 min
>>> cylinder.calc_Fo(time=7*60)
0.16606958044741657
# Let default (=10) eigen values be required
>>> cylinder.calc_eigenvalues()
array([ 0.97061535, 3.96852663, 7.0915602 , 10.22605944, 13.36390715,
16.50318456, 19.64320399, 22.78365791, 25.92438812, 29.06530494])
>>> calc_heatrateof_conv_at_time_t()
-24040.54791137568
References
----------
[1] Y. A. Cengel and A. J. Ghajar, "Heat And Mass Transfer
Fundamentals and Applications", 6th Edition. New York, McGraw Hill
Education, 2020.
"""
qrate = (self.heattransfercoefficient * self.surfacearea
*(self.T_infinity - self.calc_temperature_of_solid_at_time_t(rposition_tofindtemp=self.radius)))
# For convection, surface temperature is required, thereforeput
# rposition_tofindtemp = surface position = self.radius, because origin is in middle
return qrate
[docs] def calc_maxheattransferpossible(self):
r"""Maximum possible heat transfer between solid object and surroundings.
Parameters
----------
None_required : `None`
Attributes that are already defined are used in calculation.
Returns
-------
maximum heat transfer possible: `int or float; Positive: Heat is gained by object, Negative: Heat is lost by object`
Maximum heat transfer posssible between object and surroundings.
Notes
-----
Maximum heat transfer possible between solid object and surroundings
is calculated using the following formula. This is based on the assumption
that final object temperature will eventually reach surrounding temperature
of :math:`T_{infinity}`
.. math::
q_{max} = m C_p (T_{infinity} - T_{initial})
*where:*
*m = mass of solid object*
:math:`C_{p}` *= specific heat of solid object*
:math:`T_{infinity}` *= temperature of surrounding, which the solid object will eventually attain*
:math:`T_{initial}` *= temperature of solid object at time = initial*
:math:`q_{max}` *= max heat transfer possible*
Examples
--------
>>> from pychemengg.heattransfer import transient
>>> cylinder=transient.NonLumpedCylinder(radius=10e-2, surfacearea=1, T_initial=600, volume=np.pi*10e-2**2*1, T_infinity=200, density=7900, thermaldiffusivity=None, specificheat=477, heattransfercoefficient=80, thermalconductivity=14.9)
>>> cylinder.calc_maxheattransferpossible()
-47353854.386089675
# negative value indicates heat is being lost by the solid object
References
----------
[1] Y. A. Cengel and A. J. Ghajar, "Heat And Mass Transfer
Fundamentals and Applications", 6th Edition. New York, McGraw Hill
Education, 2020.
"""
qtotal_max = self.mass * self.specificheat * (self.T_infinity - self.T_initial)
return qtotal_max
[docs]class NonLumpedSphere():
r""" Model for nonlumped analysis of spherical solid object.
Parameters
----------
radius : `int or float`
Radius of solid object.
surfacearea : `int or float`
Surface area of solid object.
volume : `int or float`
Volume of solid object.
density : `int or float`
Density of solid object.
specificheat : `int or float`
Specific heat of solid object.
thermalconductivity : `int or float`
Thermal conductivity of solid object.
thermaldiffusivity : `int or float`
Thermal diffusivity of solid object.
heattransfercoefficient : `int or float`
Heat transfer coefficient between solid object and surrounding.
T_infinity : `int or float`
Temperature of surroundings.
T_initial : `int or float`
Temperature of solid object at time = 0.
Attributes
----------
See "Parameters". All parameters are attributes. Additional attributes are listed below.
mass : `int or float`
Mass of solid object computed as (volume * density) of solid object.
Examples
--------
First import the module **transient**
Units used in this example: SI system
However, any consistent units can be used
>>> from pychemengg.heattransfer import transient
>>> potato=transient.NonLumpedSphere(radius=.0275, surfacearea=4*np.pi*.0275**2, volume=4/3*np.pi*0.0275**3, density=1100, specificheat=3900, thermaldiffusivity=0.14e-6, T_initial=8, T_infinity=97, thermalconductivity=0.6, heattransfercoefficient=1400)
# This will create an instance of 'NonLumpedCylinder' with a name 'cylinder'
"""
[docs] def __init__(self, radius=None,
surfacearea=None,
volume=None,
density=None,
specificheat=None,
thermalconductivity=None,
thermaldiffusivity=None,
heattransfercoefficient=None,
T_infinity=None,
T_initial=None):
# assign
self.radius = radius
self.surfacearea=surfacearea
self.volume=volume
self.density=density
self.specificheat=specificheat
self.thermalconductivity = thermalconductivity
self.heattransfercoefficient=heattransfercoefficient
self.T_infinity=T_infinity
self.T_initial=T_initial
# calculate
if self.density is not None:
self.mass = self.volume * self.density
if (self.density is not None) and (self.specificheat is not None):
self.thermaldiffusivity = self.thermalconductivity/self.density/self.specificheat
else:
if thermaldiffusivity is not None:
self.thermaldiffusivity = thermaldiffusivity
[docs] def calc_Bi(self):
r"""Computes Biot number.
Parameters
----------
None_required : `None`
Attributes that are already defined are used in calculation.
Returns
-------
Bi : `int or float`
Biot number
Notes
-----
Biot number is calculated using the following formula.
.. math::
Bi = \frac {h L_{c}} {k}
*where:*
*h = heat transfer coefficient*
*k = thermal conductivity of solid object*
:math:`L_c` *= characteristic length of solid object = radius*
*Bi = Biot number*
Examples
--------
First import the module **transient**
Units used in this example: SI system
However, any consistent units can be used
>>> from pychemengg.heattransfer import transient
>>> potato=transient.NonLumpedSphere(radius=.0275, surfacearea=4*np.pi*.0275**2, volume=4/3*np.pi*0.0275**3, density=1100, specificheat=3900, thermaldiffusivity=0.14e-6, T_initial=8, T_infinity=97, thermalconductivity=0.6, heattransfercoefficient=1400)
# This will create an instance of 'NonLumpedSphere' with a name 'potato'
# Next call calc_Bi
>>> potato.calc_Bi()
64.16666666666667
References
----------
[1] Y. A. Cengel and A. J. Ghajar, "Heat And Mass Transfer
Fundamentals and Applications", 6th Edition. New York, McGraw Hill
Education, 2020.
"""
self.Bi = (self.heattransfercoefficient * self.radius / self.thermalconductivity)
return self.Bi
[docs] def calc_Fo(self, time=None):
r"""Computes Fourier number.
Parameters
----------
time : `int or float`
Time at which temperature or heat transfer is to be evaluated.
Returns
-------
Fo : `int or float`
Fourier number
Notes
-----
Fourier number is calculated using the following formula.
.. math::
Fo = \frac {\alpha t} {L_c^2}
*where:*
:math:`\alpha` *= thermal diffusivity*
*t = time at which temperature or heat transfer is to be evaluated*
:math:`L_c` *= characteristic length = radius*
*Fo = Fourier number*
Examples
--------
First import the module **transient**
Units used in this example: SI system
However, any consistent units can be used
>>> from pychemengg.heattransfer import transient
>>> potato=transient.NonLumpedSphere(radius=.0275, surfacearea=4*np.pi*.0275**2, volume=4/3*np.pi*0.0275**3, density=1100, specificheat=3900, thermaldiffusivity=0.14e-6, T_initial=8, T_infinity=97, thermalconductivity=0.6, heattransfercoefficient=1400)
# This will create an instance of 'NonLumpedSphere' with a name 'potato'
# Next call calc_Fo for time = 7 min
>>> potato.calc_Fo(7*60)
0.07767439172397851
References
----------
[1] Y. A. Cengel and A. J. Ghajar, "Heat And Mass Transfer
Fundamentals and Applications", 6th Edition. New York, McGraw Hill
Education, 2020.
"""
self.Fo = self.thermaldiffusivity * time / (self.radius)**2
return self.Fo
[docs] def calc_eigenvalues(self, numberof_eigenvalues_desired=10):
r"""Computes eigen values of characteristic equation for spherical geometry.
Parameters
----------
numberof_eigenvalues_desired : `int or float` (default = 10)
Number of eigen values desired for the characteristic equation.
Returns
-------
eigenvalues : `np.array of int or float`
Eigen values
Notes
-----
Eigen values are calculated as roots of the following equation.
.. math::
1 - \lambda_n cot(\lambda_n) - Bi = 0 , n = 1 \hspace{2pt} to \hspace{2pt} \infty
*where:*
:math:`\lambda_n` *= nth eigen value*
*Bi = Biot number*
Examples
--------
First import the module **transient**
Units used in this example: SI system
However, any consistent units can be used
>>> from pychemengg.heattransfer import transient
>>> potato=transient.NonLumpedSphere(radius=.0275, surfacearea=4*np.pi*.0275**2, volume=4/3*np.pi*0.0275**3, density=1100, specificheat=3900, thermaldiffusivity=0.14e-6, T_initial=8, T_infinity=97, thermalconductivity=0.6, heattransfercoefficient=1400)
# This will create an instance of 'NonLumpedSphere' with a name 'potato'
# Next call calc_Bi
>>> potato.calc_Bi()
64.16666666666667
# Let first 5 eigen values be required
>>> potato.calc_eigenvalues(numberof_eigenvalues_desired=5)
array([ 3.09267122, 6.1855719 , 9.27892517, 12.37294192, 15.46781574])
References
----------
[1] Y. A. Cengel and A. J. Ghajar, "Heat And Mass Transfer
Fundamentals and Applications", 6th Edition. New York, McGraw Hill
Education, 2020.
"""
sphere_eigenfunction = lambda x,Bi: 1-x/np.tan(x)-Bi
sphere_eigenvalues = _get_eigenvalues(sphere_eigenfunction, Bi=self.Bi,
numberof_eigenvalues_desired=numberof_eigenvalues_desired)
self.eigenvalues = np.array(sphere_eigenvalues)
return self.eigenvalues
[docs] def calc_temperature_of_solid_at_time_t(self, rposition_tofindtemp=None):
r"""Calculates temperature of solid object at a given time = t and radius = r.
Parameters
----------
time : `int or float`
Time instant from begining of process, at which temperature
of solid object is to be found.
rposition_tofindtemp : `int or float`
Radius from center of spherical object where temperature is to be found.
Returns
-------
temperature : `int or float`
Temperature of solid object at time = t and radius = r.
Notes
-----
Temperature of solid object at time = t and radius = r is calculated using the following formula:
.. math::
T(t) = T_{infinity} + (T_{initial} - T_{infinity}) \displaystyle\sum_{n=1}^\infty \cfrac{4(sin\lambda_n - \lambda_ncos\lambda_n)}{2 \lambda_n - sin(2 \lambda_n)} e^{- \lambda_n^2 \tau} \frac{sin(\lambda_n r/r_{outside})} {\lambda_n r/r_{outside}}
*where:*
:math:`T_{infinity}` *= temperature of surrounding fluid*
:math:`T_{initial}` *= intitial temperature of solid object*
:math:`\lambda_n` = :math:`n^{th}` eigen value of :math:`1 - \lambda_n cot(\lambda_n) - Bi = 0` , n = 1 to :math:`\infty`
*Bi = Biot number*
:math:`\tau` *= Fourier number*
*r = radius from center of solid sphere where temperature is required (r = 0 for center of sphere)*
:math:`r_{outside}` *= outer radius of the sphere*
Examples
--------
First import the module **transient**
Units used in this example: SI system
However, any consistent units can be used
>>> from pychemengg.heattransfer import transient
>>> potato=transient.NonLumpedSphere(radius=.0275, surfacearea=4*np.pi*.0275**2, volume=4/3*np.pi*0.0275**3, density=1100, specificheat=3900, thermaldiffusivity=0.14e-6, T_initial=8, T_infinity=97, thermalconductivity=0.6, heattransfercoefficient=1400)
# This will create an instance of 'NonLumpedSphere' with a name 'potato'
# Next call calc_Bi
>>> potato.calc_Bi()
64.16666666666667
>>> potato.calc_Fo(7*60)
0.07767439172397851
# Let first 5 eigen values be required
>>> potato.calc_eigenvalues(numberof_eigenvalues_desired=5)
array([ 3.09267122, 6.1855719 , 9.27892517, 12.37294192, 15.46781574])
>>> potato.calc_temperature_of_solid_at_time_t(rposition_tofindtemp=0)
21.274035537652196
"""
term1 = 4*(np.sin(self.eigenvalues)-self.eigenvalues*np.cos(self.eigenvalues))
term2 = 2*self.eigenvalues - np.sin(2*self.eigenvalues)
term3 = np.exp(-np.power(self.eigenvalues,2) * self.Fo)
if rposition_tofindtemp == 0:
term4 = 1
else:
term4 = (np.sin(self.eigenvalues*rposition_tofindtemp/self.radius)
/(self.eigenvalues*rposition_tofindtemp/self.radius))
theta = np.sum(term1/term2*term3*term4)
solidtemp_at_time_t = (self.T_infinity
+ (self.T_initial-self.T_infinity)*theta)
self.solidtemp_at_time_t = solidtemp_at_time_t
return solidtemp_at_time_t
[docs] def calc_totalheat_transferred_during_interval_t(self):
r"""Heat transferred between solid object and surroundings during
time interval = 0 to t.
Parameters
----------
None_required : `None`
Attributes that are already defined or calculated are used in calculation.
Returns
-------
total heat transferred : `int or float; Positive: Heat is gained by object, Negative: Heat is lost by object`
Total heat transferred between object andsurroundings during interval 0 to t
Notes
-----
Total heat transferred in interval 0 to t is calculated using the
following formula:
.. math::
q_{0 \to t} = q_{max} \left( 1-3 \displaystyle\sum_{n=1}^\infty \cfrac{4(sin\lambda_n - \lambda_ncos\lambda_n)}{2 \lambda_n - sin(2 \lambda_n)} e^{- \lambda_n^2 \tau} \frac{sin\lambda_n - \lambda_n cos\lambda_n}{\lambda_n^3} \right)
*where:*
:math:`\lambda_n` = :math:`n^{th}` eigen value of :math:`x_n tan(x_n) - Bi = 0` , n = 1 to :math:`\infty`
*Bi = Biot number*
:math:`\tau` *= Fourier number*
:math:`q_{max}` = *maximum possible heat transfer between solid and surrounding*
:math:`q_{0 \to t}` *= heat transferred in time interval [0, t]*
See Also
----------
pychemengg.heattransfer.transient.NonLumpedSphere.calc_maxheattransferpossible
Examples
--------
First import the module **transient**
Units used in this example: SI system
However, any consistent units can be used
>>> from pychemengg.heattransfer import transient
>>> potato=transient.NonLumpedSphere(radius=.0275, surfacearea=4*np.pi*.0275**2, volume=4/3*np.pi*0.0275**3, density=1100, specificheat=3900, thermaldiffusivity=0.14e-6, T_initial=8, T_infinity=97, thermalconductivity=0.6, heattransfercoefficient=1400)
# This will create an instance of 'NonLumpedSphere' with a name 'potato'
# Next call calc_Bi
>>> potato.calc_Bi()
64.16666666666667
>>> potato.calc_Fo(7*60)
0.07767439172397851
# Let first 5 eigen values be required
>>> potato.calc_eigenvalues(numberof_eigenvalues_desired=5)
array([ 3.09267122, 6.1855719 , 9.27892517, 12.37294192, 15.46781574])
>>> potato.calc_totalheat_transferred_during_interval_t()
22929.965184224005
References
----------
[1] Y. A. Cengel and A. J. Ghajar, "Heat And Mass Transfer
Fundamentals and Applications", 6th Edition. New York, McGraw Hill
Education, 2020.
"""
term1 = 4*(np.sin(self.eigenvalues)-self.eigenvalues*np.cos(self.eigenvalues))
term2 = 2*self.eigenvalues - np.sin(2*self.eigenvalues)
term3 = np.exp(-np.power(self.eigenvalues,2) * self.Fo)
term4 = 3*((np.sin(self.eigenvalues)-self.eigenvalues*np.cos(self.eigenvalues))
/ np.power(self.eigenvalues,3))
normalized_heatamount = 1 - np.sum(term1/term2*term3*term4)
print("normalized heat =", normalized_heatamount)
heattransferred = self.calc_maxheattransferpossible() * normalized_heatamount
return heattransferred
[docs] def calc_heatrateof_conv_at_time_t(self):
r"""Heat rate of convection between object and surroundings at a given time = t.
Parameters
----------
None_required : `None`
Attributes that are already defined are used in calculation.
Returns
-------
heat rate of convection : `int or float ; Positive: Heat is gained by object, Negative: Heat is lost by object`
Heat rate of convection between solid object and surroundings at time = t.
Notes
-----
Heat rate of convection is calculated using the following formula:
.. math::
q_{t} = h A_s (T_{infinity} - T_{t})
*where:*
*t = time at which temperature is to be computed*
*h = heat transfer coefficient*
:math:`T_{infinity}` *= temperature of surrounding fluid*
:math:`T_{t}` *= temperature of surface of solid object at time = t*
:math:`A_s` *= surface area of solid object*
:math:`q_{t}` *= heat rate of convection at time = t*
Examples
--------
First import the module **transient**
Units used in this example: SI system
However, any consistent units can be used
>>> from pychemengg.heattransfer import transient
>>> potato=transient.NonLumpedSphere(radius=.0275, surfacearea=4*np.pi*.0275**2, volume=4/3*np.pi*0.0275**3, density=1100, specificheat=3900, thermaldiffusivity=0.14e-6, T_initial=8, T_infinity=97, thermalconductivity=0.6, heattransfercoefficient=1400)
# This will create an instance of 'NonLumpedSphere' with a name 'potato'
# Next call calc_Bi
>>> potato.calc_Bi()
64.16666666666667
# Consider temperature needs to be found at 7 min
>>> potato.calc_Fo(7*60)
0.07767439172397851
# Let first 5 eigen values be required
>>> potato.calc_eigenvalues(numberof_eigenvalues_desired=5)
array([ 3.09267122, 6.1855719 , 9.27892517, 12.37294192, 15.46781574])
>>> potato.calc_heatrateof_conv_at_time_t()
19.741373294927822
References
----------
[1] Y. A. Cengel and A. J. Ghajar, "Heat And Mass Transfer
Fundamentals and Applications", 6th Edition. New York, McGraw Hill
Education, 2020.
"""
qrate = (self.heattransfercoefficient * self.surfacearea
*(self.T_infinity - self.calc_temperature_of_solid_at_time_t(rposition_tofindtemp=self.radius)))
# For convection, surface temperature is required, thereforeput
# rposition_tofindtemp = surface position = self.radius, because origin is in middle
return qrate
[docs] def calc_maxheattransferpossible(self):
r"""Maximum possible heat transfer between solid object and surroundings.
Parameters
----------
None_required : `None`
Attributes that are already defined are used in calculation.
Returns
-------
maximum heat transfer possible: `int or float; Positive: Heat is gained by object, Negative: Heat is lost by object`
Maximum heat transfer posssible between object and surroundings.
Notes
-----
Maximum heat transfer possible between solid object and surroundings
is calculated using the following formula. This is based on the assumption
that final object temperature will eventually reach surrounding temperature
of :math:`T_{infinity}`
.. math::
q_{max} = m C_p (T_{infinity} - T_{initial})
*where:*
*m = mass of solid object*
:math:`C_{p}` *= specific heat of solid object*
:math:`T_{infinity}` *= temperature of surrounding, which the solid object will eventually attain*
:math:`T_{initial}` *= temperature of solid object at time = initial*
:math:`q_{max}` *= max heat transfer possible*
Examples
--------
>>> from pychemengg.heattransfer import transient
>>> potato=transient.NonLumpedSphere(radius=.0275, surfacearea=4*np.pi*.0275**2, volume=4/3*np.pi*0.0275**3, density=1100, specificheat=3900, thermaldiffusivity=0.14e-6, T_initial=8, T_infinity=97, thermalconductivity=0.6, heattransfercoefficient=1400)
# This will create an instance of 'NonLumpedSphere' with a name 'potato'
>>> potato.calc_maxheattransferpossible()
33260.89947104865
# positive value indicates heat is being gained by the solid object
References
----------
[1] Y. A. Cengel and A. J. Ghajar, "Heat And Mass Transfer
Fundamentals and Applications", 6th Edition. New York, McGraw Hill
Education, 2020.
"""
qtotal_max = self.mass * self.specificheat * (self.T_infinity - self.T_initial)
return qtotal_max
def _get_eigenvalues(func, Bi=None, numberof_eigenvalues_desired=None):
sol = []
increment_leftrange = 1e-5
incrementvalue = 0.1
left=0.0 + increment_leftrange
right=left
for root_count in range(numberof_eigenvalues_desired):
roots_found = False
while roots_found == False:
try:
a = brentq(func, left, right, Bi)
if abs(func(a, Bi)) <= 1e-7:
sol.append(a)
roots_found = True
else:
left=right
right=left
except Exception as e:
if str(e) == "f(a) and f(b) must have different signs":
right = right + incrementvalue
left = right
right = left
return sol
[docs]class SemiInfinite():
r""" Model to analyze transient heat flow in semi-infinite objects.
Parameters
----------
boundarycondition : `str`
String defining the boundary condition applied to surface of semi-infinite object.
It can take any of the four following values:
"surfacetemperature_specified"
"heatflux_specified"
"surfaceconvection_specified"
"energypulse_specified"
xposition_tofindtemp : `int or float`
Location inside the semi infinite object where temperature is to be found.
Surface of the semi infinite object is considered to be the origin (x=0)
time : `int or float`
Time at which temperature in the semi infinite solid is to be found.
density : `int or float`
Density of solid object.
specificheat : `int or float`
Specific heat of solid object.
thermalconductivity : `int or float`
Thermal conductivity of solid object.
thermaldiffusivity : `int or float`
Thermal diffusivity of solid object.
constantsurfacetemperature : `int or float`
New temperature of surface at which it is held contant (following a step change from T_initial)
heattransfercoefficient : `int or float`
Heat transfer coefficient between solid object and surrounding.
heatflux : `int of float`
Heat flux applied on surface of solid object.
energypulse : `int or float`
Energy pulse applied to surface of solid object.
T_infinity : `int or float`
Temperature of surroundings.
T_initial : `int or float`
Temperature of solid object at time = 0.
Attributes
----------
See "Parameters". All parameters are attributes. Additional attributes are listed below.
Examples
--------
First import the module **transient**
Units used in this example: SI system
However, any consistent units can be used
>>> from pychemengg.heattransfer import transient
>>> wood = transient.SemiInfinite(boundarycondition="heatflux_specified", time = 20*60, T_initial=20, heatflux=1250, thermalconductivity=0.159, thermaldiffusivity=1.75e-7, xposition_tofindtemp=0)
# This will create an instance of 'Semi Infinite object' with a name 'wood'
"""
[docs] def __init__(self, boundarycondition=None,
xposition_tofindtemp=None,
time=None,
density=None,
specificheat=None,
thermalconductivity=None,
thermaldiffusivity=None,
constantsurfacetemperature=None,
heattransfercoefficient=None,
heatflux=None,
energypulse=None,
T_infinity=None,
T_initial=None):
self.boundarycondition = boundarycondition
self.xposition_tofindtemp = xposition_tofindtemp
self.time = time
self.specificheat=specificheat
self.density=density
self.thermalconductivity = thermalconductivity
self.constantsurfacetemperature = constantsurfacetemperature
self.heattransfercoefficient = heattransfercoefficient
self.heatflux = heatflux
self.energypulse = energypulse
self.T_infinity = T_infinity
self.T_initial = T_initial
# calculate
if (self.density is not None) and (self.specificheat is not None):
self.thermaldiffusivity = self.thermalconductivity/self.density/self.specificheat
else:
if thermaldiffusivity is not None:
self.thermaldiffusivity = thermaldiffusivity
[docs] def calc_temperature(self):
r"""Calculate temperature of Semi Infinite object at time = t and position = x.
Parameters
----------
None_required : `None`
Attributes that are already defined are used in calculation.
Returns
-------
temperature : `int or float`
Temperature of object at given location and time.
Notes
-----
Temperature of the sold semi infinite object at given location and time
is computed based on the 'boundary condition'.
1. Boundary condition: Surface temperature is specified as :math:`T_s` = constant
.. math::
\frac{T(x,t) - T_i}{T_s - T_i} = erfc \left( \frac{x}{2\sqrt{\alpha t}} \right)
2. Boundary condition: Surface heat flux is specified as :math:`q_s` = constant
.. math::
T(x,t) - T_i = \frac{q_s}{k} \left( \sqrt{\frac{4 \alpha t}{\pi}} exp\left(-\frac {x^2}{4 \alpha t}\right) -x erfc\left( \frac{x}{2\sqrt{\alpha t}} \right) \right)
3. Boundary condition: Convection on surface, :math:`q_s(t) = h[T_{\infty} - T(0,t)]`
.. math::
\frac{T(x,t) - T_i}{T_s - T_i} = erfc \left( \frac{x}{2\sqrt{\alpha t}} \right) - exp \left( \frac{hx}{k} + \frac{h^2 \alpha t}{k^2}\right) erfc\left( \frac{x}{2\sqrt{\alpha t}} + \frac{h \sqrt{\alpha t}}{k}\right)
4. Boundary condition: Surface is exposed to energy pulse, :math:`e_s` = constant
.. math::
T(x,t) - T_i = \frac{e_s}{k \sqrt{ \frac{\pi t}{\alpha} }} exp \left( -\frac {x^2}{4 \alpha t} \right)
*where:*
*t = time at which temperature or flux is to be computed*
*x = location from surface of the semi infinite object where temperature is to be computed*
*k = thermal conductivity of solid*
*h = heat transfer coefficient between solid and fluid*
:math:`\alpha` *= thermal diffusivity of solid object*
:math:`T(x,t)` *= temperature of solid object at losition 'x' and time 't'*
:math:`T_{s}` *= new surface temperature of solid object*
:math:`T_{i}` *= temperature of solid object at time = 0*
:math:`q_s` *= constant heat flux applied to solid surface*
:math:`e_s` *= constant energy pulse applied to soild surface*
:math:`T_{\infty}` = temperature of fluid in contact with solid
Examples
--------
>>> from pychemengg.heattransfer import transient
>>> wood = transient.SemiInfinite(boundarycondition="heatflux_specified", time = 20*60, T_initial=20, heatflux=1250, thermalconductivity=0.159, thermaldiffusivity=1.75e-7, xposition_tofindtemp=0)
# This will create an instance of 'Semi Infinite object' with a name 'wood'
>>> wood.calc_temperature()
148.5516322557588
References
----------
[1] Y. A. Cengel and A. J. Ghajar, "Heat And Mass Transfer
Fundamentals and Applications", 6th Edition. New York, McGraw Hill
Education, 2020.
"""
if self.boundarycondition == "surfacetemperature_specified":
theta = erfc(self.xposition_tofindtemp/2/np.power(self.thermaldiffusivity*self.time, 0.5))
temp_at_given_x_and_time = self.T_initial + theta * (self.constantsurfacetemperature-self.T_initial)
if self.boundarycondition == "heatflux_specified":
term1 = np.power(4*self.thermaldiffusivity*self.time/np.pi,0.5)
term2 = np.exp(-np.power(self.xposition_tofindtemp,2)/4/self.thermaldiffusivity/self.time)
term3 = self.xposition_tofindtemp*erfc(self.xposition_tofindtemp/2/np.power(self.thermaldiffusivity*self.time,0.5))
temp_at_given_x_and_time = self.T_initial + self.heatflux/self.thermalconductivity*(term1*term2-term3)
if self.boundarycondition == "surfaceconvection_specified":
term0 = self.xposition_tofindtemp/2/np.power(self.thermaldiffusivity*self.time, 0.5)
term1 = erfc(term0)
term2 = self.heattransfercoefficient*self.xposition_tofindtemp/self.thermalconductivity
term3 = np.power(self.heattransfercoefficient, 2)*self.thermaldiffusivity*self.time/np.power(self.thermalconductivity,2)
term4 = self.heattransfercoefficient*np.power(self.thermaldiffusivity*self.time, 0.5)/self.thermalconductivity
theta = term1 - np.exp(term2+term3)*erfc(term0+term4)
temp_at_given_x_and_time = self.T_initial + theta * (self.T_infinity-self.T_initial)
if self.boundarycondition == "energypulse_specified":
term1 = self.energypulse/self.thermalconductivity
term2 = np.power(np.pi*self.time/self.thermaldiffusivity, 0.5)
term3 = np.exp(- np.power(self.xposition_tofindtemp,2)/4/self.thermaldiffusivity/self.time)
temp_at_given_x_and_time = self.T_initial + term1/term2*term3
self.temp_at_given_x_and_time = temp_at_given_x_and_time
return self.temp_at_given_x_and_time
[docs] def calc_heatflux_forconstantsurfacetemperature(self):
r"""Calculate heat flux at time = t for boundary condition = "surfacetemperature_specified".
Parameters
----------
None_required : `None`
Attributes that are already defined are used in calculation.
Returns
-------
heat flux : `int or float; Positive: Heat is gained by object, Negative: Heat is lost by object`
Heat flux at a given instance of time 't'.
Notes
-----
Heat flux of the sold semi infinite object at given time 't'
is computed using the following formula:
1. Boundary condition: Surface temperature is specified as :math:`T_s` = constant
q_s(t) = \frac{k(T_s - T_i)}{\sqrt{\pi \alpha t}}
*where:*
*t = time at which temperature or flux is to be computed*
:math:`\alpha` *= thermal diffusivity of solid object*
:math:`T_{s}` *= new surface temperature of solid object*
:math:`T_{i}` *= temperature of solid object at time = 0*
:math:`q_s(t)` *= heat flux at any time 't'*
Examples
--------
>>> from pychemengg.heattransfer import transient
>>> pipe = transient.SemiInfinite(boundarycondition="surfacetemperature_specified", constantsurfacetemperature=-10, T_initial=15, thermalconductivity=0.4, thermaldiffusivity=0.15e-6, time = 90*24*3600)
# This will create an instance of 'Semi Infinite object' with a name 'pipe'
>>> pipe.calc_heatflux_forconstantsurfacetemperature ()
pipe.calc_heatflux_forconstantsurfacetemperature ()
-5.223977625442188
# negative value indicates heat is being lost by the solid object
References
----------
[1] Y. A. Cengel and A. J. Ghajar, "Heat And Mass Transfer
Fundamentals and Applications", 6th Edition. New York, McGraw Hill
Education, 2020.
"""
if self.boundarycondition == "surfacetemperature_specified":
term1 = np.power(np.pi*self.thermaldiffusivity*self.time, 0.5)
heatflux = self.thermalconductivity * (self.constantsurfacetemperature - self.T_initial)/term1
return heatflux


How much of Financial Stuff do you know?
Beginner
Intermediate
Expert
Advanced
Great! How much do you wanna learn?
5 mins/day
10 mins/day
15 mins/day
20 mins/day
Good job! Now get a daily reminder to meet your goal!
Maybe, now we can test your proficiency?
Start with the basics
CPF
Jump ahead
Financial Planning
s
Back
Next


--- layout: post title: Comments on Tumblr. date: '2008-08-02T19:30:00+02:00' tags: - comments - tumblr tumblr_url: http://blog.alezzandro.com/post/44469526/comments-on-tumblr ---
Comments on Tumblr.??
What?

I don’t want to know if you like the header, if you like the style, I like it, this is the only important matter.
This is why I chose Tumblr instead of many blogger’s sites.
Here I can post everything is coming on my brain, comments aren’t accepted here!
gbye :-)


{{Refimprove|date=October 2012}} {{Infobox prepared food | name = Tlacoyo | image = | caption = Tlacoyo with green and chile pasilla sauce | alternate_name = | country = | region = | creator = | course = | type = Pancake | served = | main_ingredient = Masa | variations = | calories = | other = }}
Tlacoyo {{IPA-es|t͡ɬaˈkoʝo|}} is an oval-shaped fried or toasted cake made of masa. Somewhat torpedo-shaped, they are fatter than fresh corn tortillas and stuffed with cooked and ground beans, cheese, fava beans, chicharron or other ingredients. Tlacoyos can be served as an accompaniment to soups and stews or as appetizers for celebrations. Most traditional tlacoyos do not have lard or salt in the masa, and if not eaten soon after they are cooked, they become very tough and dry, even if reheated. On Mexican markets, vendors keep their tlacoyos warm by putting them in a covered basket, in order to keep them moist for a longer time. This dish is similar to the Salvadoran pupusa.
The name tlacoyo is a variation of the Nahuatl word tlahtlaōyoh {{IPA-nah|t͡ɬɑʔt͡ɬɑˈoːjoʔ|}}),<ref name="dic">Nahuatl Dictionary. (1997). Wired Humanities Project. University of Oregon. Retrieved August 29, 2012, from link</ref> a name given to an antojito typical of central Mexico.
The tlacoyo is a completely different traditional Mexican dish which must not be confused with a sope or a huarache, but according to modern recipes,<ref name="HayTlacoyos">"Hay Tlacoyos: Tradicional Recipes from Mexico City" (2012). link</ref> in some regions has started to be used in a similar way, as a base for the same ingredients used for sopes.
Since it is similar in shape to a huarache (but smaller), and is made of the same corn as the sope and is even thicker (so it has more resistance to humid foods), Mexican street vendors, especially in Mexico City, sometimes sell it adding toppings on it, as an alternative to the sopes and huaraches. However, note the traditional tlacoyo is supposed to be consumed without any toppings on it, but fresh salsa. In this form they are mostly found on the streets. {{Citation needed|date=April 2010}}
Tlacoyos come in three different colors, but no artificial colors are added to its preparation. The color comes from the cornmeal used to prepare the masa which the tlacoyo is made with. The most common is blue, made with blue corn kernels.{{Citation needed|date=April 2010}}
<gallery class="center" caption="Tlacoyo" widths="175px" heights="175px" > File:Tlacoyo.jpg|blue corn meal tlacoyo File:Tlacoyera.jpg|Lady preparing tlacoyos over the sidewalk in Colonia Condesa in Mexico City, it can be seen how the tlacoyo is cooked over a comal which is over an anafre, a kind of coal stove used in Mexican households without any heating energy </gallery>
{{reflist}}
{{Mexican cuisine}} {{Pancakes}}


What happens after I order?
After you place your order we get to work! Based on the questions you answered in the quiz,
we’ll craft your plan to your exact personal nutrition requirements. All plans are double
verified - by the person making it and a supervisor - so you can be certain the plan you get is
the best.
When do I get my plan?
Our every plan is personalized and our nutritionists work hard to make them for you to like.
Usually it takes up to 2 hours for your plan to be delivered into your email.


class Vertex
extends Object
| Modifier and Type | Field and Description |
|---|---|
ArrayList<Vertex> |
children
Any child vertices.
|
float |
heading
The direction of our parent vertex from this vertex.
|
int |
index
An integer which is unique to this vertex.
|
float |
magnitude
The distance from this vertex to our parent vertex.
|
Vertex |
parent
Our parent vertex.
|
static float |
pointSize
How big the points you drag around with your mouse to manipulate the StickPuppet are (sometimes called lugs, handles or pivots).
|
| Constructor and Description |
|---|
Vertex(int _index) |
| Modifier and Type | Method and Description |
|---|---|
void |
addChild(Vertex child)
Adds a child vertex to this vertex
|
void |
draw(PVector pvParent)
Draw a line to our parent vertex, then recursively call our children so that all lines between vertices are drawn.
|
void |
drawPoints(PVector pvParent)
Draw a point at our present location (to show we can be dragged around with the mouse to manipulate the StickPuppet).
|
PVector |
getChildVector(int desiredIndex,
PVector pvParent)
Called to determine a particular vertex's x-y location.
|
PVector |
getVector(PVector pvParent)
Calculate's the position of this vertex from the position of its parent vertex.
|
int |
hitTest(PVector pvParent)
Called to determine which vertex, if any, the mouse is currently over.
|
void |
mouseDragged(int currentDrag,
PVector pvParent)
If this vertex is being dragged by the mouse then rotate appropriately in order to follow the mouse,
otherwise call our children recursively in case one of them is being dragged.
|
void |
rotate(float angle)
Rotate this vertex around its parent.
|
void |
tween(float value,
float start,
float stop,
Vertex parentA,
Vertex parentB)
Calculate the direction of our parent vertex as somewhere in between the directions of the two given vertices.
|
int index
StickPuppet.vertices
Vertex parent
ArrayList<Vertex> children
float magnitude
float heading
static final float pointSize
Vertex(int _index)
_index
- The unique index of the vertex we are creating.public void addChild(Vertex child)
child
- The child vertex we are addingpublic PVector getVector(PVector pvParent)
pvParent
- PVector representing the position of our parentpublic void draw(PVector pvParent)
pvParent
- PVector representing the position of our parentpublic void drawPoints(PVector pvParent)
pvParent
- PVector representing the position of our parentpublic void rotate(float angle)
angle
- The amount to rotate bypublic void tween(float value, float start, float stop, Vertex parentA, Vertex parentB)
value
- The incoming value to be convertedstart
- The lower bound of the value's current rangestop
- The upper bound of the value's current rangeparentA
- The desired vertex's lower boundparentB
- The desired vertex's upper boundpublic int hitTest(PVector pvParent)
pvParent
- The position of our parent vertexpublic void mouseDragged(int currentDrag, PVector pvParent)
currentDrag
- The index of the vertex which is currently being draggedpvParent
- The position of our parent vertexpublic PVector getChildVector(int desiredIndex, PVector pvParent)
desiredIndex
- The index of the vertex who's location we wish to determinepvParent
- The position of our parent vertex


Department of Computer Science and Engineering at HKBK College of Engineering is organizing the Third State Level CSI Technical Symposium OVERLOAD++ on 5th April 2015.
This is a launch platform for students to showcase and test their creativity, programming, knowledge and communication skills. The parallel programming contest is the highlight of this event. It tests the students in their proficiency to parallelize a given sequential code in C using OpenMP / CUDA for execution on the given HPC architecture.


Home
Staff
Owners
Managers
Admins
Moderators
Helpers
Builders
Trainees
Gamemodes
Survival
Creative
Events
Other Information
Pedestria
Discord Server
Server History
Pedestriapedia - The Official Wiki for PedestriaMC
Plugins (Survival)
AntiDonkeyDupe
ArmorEquipEvent
BanFromClaim
BetterSleeping3
BlockNotifier
BlockParticles
BottledExp
ChatItemDisplay
ChatReaction
ChestShop
Citizens
CoreProtect
CraftingStore
CrazyAuctions
DiscordSRV
EpicRename
Essentials
EssentialsChat
EssentialsSpawn
EZColors
FogusCore
FriendsRELOADED
GoldenCrates
GriefProtection
GSit
HandyOrbs
HolographicDisplays
ImageOnMap
KickFromClaim
KometTools
LagAssist
Lobby
LuckPerms
mcMMO
MCSF
MineResetLite
MiningUtils
Modules
MultiWorld
NoCheatPlus
OldCombatMechanics
Oof
PhantomAntiDupe
PlaceholderAPI
Plan
PlayerParticles
PlugMan
ProtocolLib
ProtocolSupport
Quests
QuickBoard
RealisticTreeStay
SellWands
ShopGUIPlus
ShopGUIPlus-SellGUI
ShopGUIPlusSilkSpawnersBridge
SilkSpawners
SimpleAutoBrodcast
StaffList
SuperbVote
SuperVanish
TAB
Taxes
TradeSystem
Vault
VeinMiner
Votifier
Wild
WildStacker
WorldBorder
WorldEdit
WorldGuard
XrayNotifier*


Hello Everyone !!
Thanks for continuing with this post.
In this post, I want to show you that how easy it is to use an existing Machine Learning model and using it using TensorFlow.js to make predictions on images in the browser. So, let's get started.
First, let me begin by showing you a simple demo of what we'll be building in this tutorial. Below, you can see some images. If you click on any image, you see that some text appears below that tells that what the machine learning model thinks is in the image i.e. predicted labels and their probabilities. Go ahead and try it out.
Predicted Labels and their Probabilities appears here.
So, what's going on here. I am making use of TensorFlow.js to load a MobileNet model and providing the selected images as input to the model to get some predictions from the model. What's different in this approach as compared to others is that all the prediction using the model is taking place in your browser.
Yes, you heard that right !! It's hapenning right here on your browser, be it the phone or a laptop. No server required. Don't believe me yet ? Go ahead and open your browser's console and click on any image. Believe me now ?
As you open the console and click on an image above, you should see some output like in the image below. This is the output that I get when I select the Panda image:
Let's see how this all is done in code. The first step is to load TensorFlow.js library and the MobileNet model. We can doo this in two ways: load the library hosted using a CDN or load the library locally using a tfjs.json and model.json files. In this tutorial we'll be using the CND. Let's see this in code.
Next, we define a function to get the ID of the image that the user selects. For this, we provide all images with a unique ID. Then to get this ID on selecting an image and process it, we add a OnClick event to each image that calls a function in JavaScript.
The OnClick event calls the imageSelected(image_id) function in JavaScript and passes in the selected image's ID as an argument. The JavaScript function for doing this looks like follows:
Now that we know that which image was selected, we can use this information to get the image from the source for processing like resizing the image to 224x224 for input to MobileNet model as follows:
Since, we have done all the pre-processing required, we are now ready to make predictions on the selected image. For doing this, we just load our MobileNet model using CDN or you can save and load the model locally as a model.json file and call the model.classify(image) function. The model.classify(image) function returns two things, the className i.e. the class labels for the image and probability i.e. the probability the model thinks this image belongs to that class. This can be done in the code as follows:
So, in this tutorial, we saw that how to use TensorFlow.js for performing image classification in the browser using a machine learning model. You can follow almost similar steps to use a custom machine learning model and run in the browser.

Predicted Labels and their Probabilities appears here.
Now that we know how to use pre-trained model to make prediction on images in the browser, now it's time to see how we can use the same model to make predictions on live video using our webcam in the browser.
Great work on completing this tutorial. Next, we'll see how to use a pre-trained model using TensorFlow.js in the browser and make predictions on live stream video. Image Classification on Live Video using TensorFlow.js
For more projects and code, follow me on Github
Please feel free to leave any comments, suggestions, corrections if any, below.
comments powered by Disqus


"(5++ stars) This was my first time getting my eyebrows threaded and it was quick and easy. I'm more than happy with how my eyebrows turned out. She made sure that the stubborn hairs were out and taken care of and I felt very comfortable. I would definitely recommend this place to everyone and her prices are a plus."
"She is amazing at what she does! I waited months to get my eyebrows done just cause I wanted to get it done with her. No one has been able to do my eyebrows like the way she does. I finally got the shape I wanted. She can fix any type of eyebrows and you will be completely satisfied! She works with what you want and what will look good on you. I can't stop looking at my eyebrows, I always get it done with her because she is the best at what she does. She is extremely friendly and makes one feel very comfortable. I highly recommend getting your eyebrows done by her."
"sam was the first to thread my eyebrows. shes so confident and enthusiastic about what she does. she really is a perfectionist like me and my eyebrows never looked better. she takes such pride and care to get evey last stray hair and give you the perfect shape for your face. shes also a real sweetheart and makes you feel very welcome and comfortable."


events_mutation_response
response of any mutation on the table "events"
Fields
affected_rows (
Int!
)
number of rows affected by the mutation
returning (
[events!]!
)
data from the rows affected by the mutation


Classes
\
| Name | Description | |
|---|---|---|
| DoctrineAdapter | A simple wrapper for using the Doctrine Database Abstraction Layer with Phinx. | EMPTY |
\Doctrine\DBAL\Types
| Name | Description | |
|---|---|---|
| EncryptedStringType | Same as a string, but with encryption. | EMPTY |
| ProtectedString | No description available | EMPTY |
\Moose\Context
| Name | Description | |
|---|---|---|
| AnnotationEntityManagerFactory | Description of EntityManagerFactory | EMPTY |
| Context | No description available | EMPTY |
| DefaultPlatesEngineFactory | Description of DefaultPlatesEngineFactory | EMPTY |
| MooseConfig | Models the configuration required by this web application and takes care of serializing and deserializing it. | EMPTY |
| MooseEnvironment | Description of MooseEnvironment | EMPTY |
| NetteMailerFactory | Description of EntityManagerFactory | EMPTY |
| PortalSessionHandler | Instance of a session for the current user. Mostly immutable. | EMPTY |
\Moose\Controller
| Name | Description | |
|---|---|---|
| AbstractController | Description of AbstractController | EMPTY |
| AbstractForumController | Some convenience methods for creating threads and posts etc. | EMPTY |
| BaseController | Description of BaseController | EMPTY |
| BoardController | Shows a list of forums for the current user. | EMPTY |
| ContactController | Performs registration for a normal user account. | EMPTY |
| DashboardController | Dashboard, the main page. | EMPTY |
| ExamController | Shows all or some exams for the current user. | EMPTY |
| ForumController | For displaying a list of threads for a forum. | EMPTY |
| LegaleseController | Stuff. | EMPTY |
| LoginController | Performs registration for a normal user account. | EMPTY |
| LogoutController | Performs registration for a normal user account. | EMPTY |
| PermissionsException | PermissionsException is thrown when a request is made without by a user without proper authorization. | EMPTY |
| PwRecoveryController | Performs registration for a normal user account. | EMPTY |
| PwResetController | Performs registration for a normal user account. | EMPTY |
| RegisterController | Performs registration for a normal user account. | EMPTY |
| ScheduleController | Performs registration for a normal user account. | EMPTY |
| SetupAdminController | No description available | EMPTY |
| SetupController | No description available | EMPTY |
| SetupImportController | No description available | EMPTY |
| SiteSettingsController | No description available | EMPTY |
| ThreadController | Shows a list of posts for a given thread. | EMPTY |
| UserProfileController | No description available | EMPTY |
| UserlistController | Shows a list of users viewable by the current user. | EMPTY |
\Moose\Dao
| Name | Description | |
|---|---|---|
| AbstractDao | Bridge between the database and entities. | EMPTY |
| CourseDao | Methods for interacting with Course objects and the database. | EMPTY |
| DiningHallDao | Methods for interacting with dining hall objects and the database. | EMPTY |
| DiningHallMealDao | Methods for interacting with dining hall meal objects and the database. | EMPTY |
| DocumentDao | Methods for interacting with Post objects and the database. | EMPTY |
| ExamDao | Methods for interacting with Post objects and the database. | EMPTY |
| ExpireTokenDao | Methods for interacting with Post objects and the database. | EMPTY |
| FieldOfStudyDao | Methods for interacting with Post objects and the database. | EMPTY |
| ForumDao | Methods for interacting with user objects and the database. | EMPTY |
| GenericDao | Generic methods for interacting with the database. Do not use and find... functions, they will throw. | EMPTY |
| LessonDao | Methods for interacting with Lesson objects and the database. | EMPTY |
| MailDao | Methods for interacting with user objects and the database. | EMPTY |
| PostDao | Methods for interacting with Post objects and the database. | EMPTY |
| ScheduledEventDao | Methods for interacting with scheduled event objects and the database. | EMPTY |
| TagDao | Methods for interacting with Post objects and the database. | EMPTY |
| ThreadDao | Methods for interacting with Thread objects and the database. | EMPTY |
| TutorialGroupDao | Methods for interacting with TutorialGroup objects and the database. | EMPTY |
| UniversityDao | Methods for interacting with Post objects and the database. | EMPTY |
| UserDao | Methods for interacting with User objects and the database. | EMPTY |
\Moose\Entity
| Name | Description | |
|---|---|---|
| AbstractEntity | Base entity with an id. | EMPTY |
| Course | Description of Module | EMPTY |
| DiningHall | No description available | EMPTY |
| DiningHallMeal | No description available | EMPTY |
| Document | A document that might have been uploaded, generated automatically etc. | EMPTY |
| DocumentData | A document that might have been uploaded, generated automatically etc. | EMPTY |
| Exam | A course a student may visit. | EMPTY |
| ExpireToken | A token with a random UUID, a creatiion date and a lifetime. It cannot be used anymore once it becomes invalid. | EMPTY |
| FieldOfStudy | Description of Subject | EMPTY |
| Forum | Description of Forum | EMPTY |
| Lesson | A course a student may visit. | EMPTY |
| Entity for EMails they are sent to Users | EMPTY | |
| Post | Entity for post on the message board. | EMPTY |
| ScheduledEvent | No description available | EMPTY |
| Tag | A tag. Each entity may be tagged with several tags. | EMPTY |
| Thread | Description of Thread | EMPTY |
| TutorialGroup | A tutorial group (Seminargruppe) to which student belong to. | EMPTY |
| University | A university (BA - Berufsakademie) at which student may be enrolled. | EMPTY |
| User | Entity for users that may register and use the system. | EMPTY |
\Moose\Extension\CampusDual
| Name | Description | |
|---|---|---|
| CampusDualException | No description available | EMPTY |
| CampusDualHelper | Static methods for the campus dual login, such as sending the requests. | EMPTY |
| CampusDualLoader | For querying data from CapusDual. | EMPTY |
| CampusDualSession | Contains all data of a campus dual session, such as session cookies. | EMPTY |
\Moose\Extension\DiningHall
| Name | Description | |
|---|---|---|
| DiningHallException | General exception thrown when a dining hall loader fails. | EMPTY |
| DiningHallMealImpl | Description of DiningHallMeal | EMPTY |
| GeoLocation | No description available | EMPTY |
| MensaJohannstadtLoader | Description of MensaJohanstadtLoader | EMPTY |
| MensaJohannstadtMeal | Description of MensaJohannstadtMeal | EMPTY |
\Moose\Migration
| Name | Description | |
|---|---|---|
| ToVersion2 | No description available | EMPTY |
\Moose\PlatesExtension
| Name | Description | |
|---|---|---|
| PlatesMooseExtension | Common functions for our templates. | EMPTY |
\Moose\Seed
| Name | Description | |
|---|---|---|
| CourseSeed | No description available | EMPTY |
| DiningHallMealSeed | No description available | EMPTY |
| DormantSeed | Description of AbstractClass | EMPTY |
| FieldOfStudySeed | No description available | EMPTY |
| PostSeed | No description available | EMPTY |
| ScheduledEventSeed | No description available | EMPTY |
| SchemaSeed | No description available | EMPTY |
| ThreadSeed | No description available | EMPTY |
| TutorialGroupSeed | No description available | EMPTY |
| UniversitySeed | No description available | EMPTY |
| UserSeed | <pre> DormantSeed::grow([ 'User' => [ 'RandomUsers' => [20, 'myPassword'] ] ]); </pre> <pre> DormantSeed::grow([ 'Admin', 'RandomUsers' ]); </pre> | EMPTY |
\Moose\Servlet
| Name | Description | |
|---|---|---|
| AbstractEntityServlet | Description of AbstractEntityServlet | EMPTY |
| AbstractRestServlet | A REST-like servlet with additional methods and a dedicated ServletResponse object. | EMPTY |
| CheckStudentIdExistsServlet | No description available | EMPTY |
| CheckStudentIdServlet | No description available | EMPTY |
| DocumentServlet | //TODO What to do when we cannot get a MIME type? Description of UpdatePost | EMPTY |
| PostServlet | TODO: Accept JSON data instead of POST data. | EMPTY |
| SeedServlet | Servlet for automated testing. Runs the seeds passed to this servlet. | EMPTY |
| ThreadServlet | For manipulating (forum) threads. | EMPTY |
| UserServlet | For manipulating (forum) threads. | EMPTY |
\Moose\Tasks
| Name | Description | |
|---|---|---|
| AbstractDbEvent | Updates all meals from the configured dining halls. | EMPTY |
| CampusDualEvent | Updates all meals from the configured dining halls. | EMPTY |
| DiningHallLoadEvent | Updates all meals from the configured dining halls. | EMPTY |
| ExpireTokenPurgeEvent | Updates all meals from the configured dining halls. | EMPTY |
| MailSendEvent | Sends mail that are not sent yet. The parameters is the maximum number of mails to send each time. | EMPTY |
| PhpEventRunner | No description available | EMPTY |
\Moose\Test\Unit
| Name | Description | |
|---|---|---|
| AbstractContextTest | No description available | EMPTY |
| AbstractDbTest | No description available | EMPTY |
| CampusDualTest | Description of CampusDualTest | EMPTY |
| ForumTest | Description of ForumTest | EMPTY |
| ThreadTest | Description of ForumTest | EMPTY |
| UserTest | No description available | EMPTY |
\Moose\Util
| Name | Description | |
|---|---|---|
| CollectionUtil | Utility functions for working with collections. | EMPTY |
| DebugUtil | Description of DebugUtil | EMPTY |
| EncryptionUtil | Utility functions for working with encryptions. Mainly encapsulates existing PHP functions and libraries. | EMPTY |
| MailUtil | Utility functions for working with mails. | EMPTY |
| MathUtil | No description available | EMPTY |
| PlaceholderTranslator | Pretty much the same as \Gettext\Translator, but there are additional methods accepting an optional second argument of type array with a list of variables to be replaced in the returned string. For example, when the translation contains an entry | EMPTY |
| RandomUtil | No description available | EMPTY |
| ReflectionCache | Description of ReflectionFieldList | EMPTY |
| UiUtil | No description available | EMPTY |
\Moose\ViewModel
| Name | Description | |
|---|---|---|
| AbstractDashboardPanel | Base class for all dashboard panels with common functionality. | EMPTY |
| AbstractSection | No description available | EMPTY |
| BaseButton | A button, used for dialog etc. | EMPTY |
| ButtonFactory | A button for editing an HTML element with a markdown editor. | EMPTY |
| ButtonMarkdownEdit | A button for editing an HTML element with a markdown editor. | EMPTY |
| DashboardPanelDiningHallMenu | Description of DashboardPanelDiningHallMenu | EMPTY |
| DashboardPanelProxy | A simple proxy panel that simply renders the given template with the given data. | EMPTY |
| DataTable | Description of DataTable | EMPTY |
| DataTableColumn | No description available | EMPTY |
| Message | A message, to be used in displaying messages with bootstrap. | EMPTY |
| MessageRegistry | <p> A list of predefined messages. When a controller redirects to another page, it cannot add any error or success messages. To avoid this issue, the controller may add an URL parameter with a list of messages to be displayed. | EMPTY |
| Paginable | No description available | EMPTY |
| SectionBasic | A basic section with a fixed name retrieved from an I18N string and requiring no additional URL parameters etc. | EMPTY |
| SectionForum | No description available | EMPTY |
| SectionThread | No description available | EMPTY |
\Moose\Web
| Name | Description | |
|---|---|---|
| HttpRequest | No description available | EMPTY |
| HttpResponse | A response object that is rendered once a controller finishes processing. | EMPTY |
| RequestException | Thrown when a controller or servlet encounters a unrecoverable situation. | EMPTY |
| RequestWithPaginableData | No description available | EMPTY |
| RestRequest | Description of RestRequest | EMPTY |
| RestResponse | No description available | EMPTY |
\Symfony\Component\Validator\Constraints
| Name | Description | |
|---|---|---|
| Json | No description available | EMPTY |
| JsonValidator | No description available | EMPTY |
| LengthEncrypted | No description available | EMPTY |
| LengthEncryptedValidator | No description available | EMPTY |