_id stringlengths 2 7 | title stringlengths 1 88 | partition stringclasses 3
values | text stringlengths 31 13.1k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q262400 | RhoT.calculate | validation | def calculate(self, **state):
"""
Calculate the density at the specified temperature.
:param T: [K] temperature
:returns: [kg/m3] density
| python | {
"resource": ""
} |
q262401 | RhoTPx.calculate | validation | def calculate(self, **state):
"""
Calculate the density at the specified temperature, pressure, and
composition.
:param T: [K] temperature
:param P: [Pa] pressure
:param x: [mole fraction] dictionary of compounds and mole fractions
:returns: [kg/m3] density
The **state parameter contains the keyword argument(s) specified above\
that are used to describe the state of | python | {
"resource": ""
} |
q262402 | GeneralLedgerAccount.set_parent_path | validation | def set_parent_path(self, value):
"""
Set the parent path and the path from the new parent path.
:param value: The path to the object's parent
"""
| python | {
"resource": ""
} |
q262403 | GeneralLedgerAccount.create_account | validation | def create_account(self, name, number=None, description=None):
"""
Create a sub account in the account.
:param name: The account name.
:param description: The account description.
:param number: The account number.
:returns: The created account.
"""
new_account | python | {
"resource": ""
} |
q262404 | GeneralLedgerAccount.remove_account | validation | def remove_account(self, name):
"""
Remove an account from the account's sub accounts.
:param name: The name of the account to remove.
"""
acc_to_remove = None
for a in self.accounts:
| python | {
"resource": ""
} |
q262405 | GeneralLedgerAccount.get_child_account | validation | def get_child_account(self, account_name):
"""
Retrieves a child account.
This could be a descendant nested at any level.
:param account_name: The name of the account to retrieve.
:returns: The child account, if found, else None. | python | {
"resource": ""
} |
q262406 | GeneralLedgerStructure._create_account_ | validation | def _create_account_(self, name, number, account_type):
"""
Create an account in the general ledger structure.
:param name: The account name.
:param number: The account number.
:param account_type: The account type.
:returns: The created account.
| python | {
"resource": ""
} |
q262407 | GeneralLedgerStructure.get_account_descendants | validation | def get_account_descendants(self, account):
"""
Retrieves an account's descendants from the general ledger structure
given the account name.
:param account_name: The account name.
:returns: The decendants of the account.
"""
| python | {
"resource": ""
} |
q262408 | GeneralLedgerStructure._get_account_and_descendants_ | validation | def _get_account_and_descendants_(self, account, result):
"""
Returns the account and all of it's sub accounts.
:param account: The account.
:param result: The list to add all the accounts to.
"""
| python | {
"resource": ""
} |
q262409 | GeneralLedgerStructure.validate_account_names | validation | def validate_account_names(self, names):
"""
Validates whether the accounts in a list of account names exists.
:param names: The names of the accounts.
:returns: The descendants of the account.
"""
for name in names:
| python | {
"resource": ""
} |
q262410 | GeneralLedgerStructure.report | validation | def report(self, format=ReportFormat.printout, output_path=None):
"""
Returns a report of this class.
:param format: The format of the report.
:param output_path: The path to the file the report is written to.
If None, then the report is not written to a file.
| python | {
"resource": ""
} |
q262411 | GeneralLedger.create_transaction | validation | def create_transaction(self, name, description=None,
tx_date=datetime.min.date(),
dt_account=None, cr_account=None,
source=None, amount=0.00):
"""
Create a transaction in the general ledger.
:param name: The transaction's name.
:param description: The transaction's description.
| python | {
"resource": ""
} |
q262412 | get_path_relative_to_module | validation | def get_path_relative_to_module(module_file_path, relative_target_path):
"""
Calculate a path relative to the specified module file.
:param module_file_path: The file path to the module.
"""
module_path = | python | {
"resource": ""
} |
q262413 | get_date | validation | def get_date(date):
"""
Get the date from a value that could be a date object or a string.
:param date: The date object or string.
:returns: The date object.
""" | python | {
"resource": ""
} |
q262414 | IsothermalFlatSurface.Nu_x | validation | def Nu_x(self, L, theta, Ts, **statef):
"""
Calculate the local Nusselt number.
:param L: [m] characteristic length of the heat transfer surface
:param theta: [°] angle of the surface with the vertical
:param Ts: [K] heat transfer surface temperature
:param Tf: [K] bulk fluid temperature
:returns: float
"""
Tf = statef['T']
thetar = radians(theta)
if self._isgas:
self.Tr = Ts - 0.38 * (Ts - Tf)
beta = self._fluid.beta(T=Tf)
else: # for liquids
self.Tr = Ts - 0.5 * (Ts - Tf)
beta = self._fluid.beta(T=self.Tr)
if Ts > Tf: # hot surface
if 0.0 < theta < 45.0:
g = const.g*cos(thetar)
else:
g = const.g
else: | python | {
"resource": ""
} |
q262415 | IsothermalFlatSurface.Nu_L | validation | def Nu_L(self, L, theta, Ts, **statef):
"""
Calculate the average Nusselt number.
:param L: [m] characteristic length of the heat transfer surface
:param theta: [°] angle of the surface with the vertical
:param Ts: [K] heat transfer surface temperature
| python | {
"resource": ""
} |
q262416 | IsothermalFlatSurface.h_x | validation | def h_x(self, L, theta, Ts, **statef):
"""
Calculate the local heat transfer coefficient.
:param L: [m] characteristic length of the heat transfer surface
:param theta: [°] angle of the surface with the vertical
:param Ts: [K] heat transfer surface temperature
:param Tf: [K] bulk fluid temperature | python | {
"resource": ""
} |
q262417 | IsothermalFlatSurface.h_L | validation | def h_L(self, L, theta, Ts, **statef):
"""
Calculate the average heat transfer coefficient.
:param L: [m] characteristic length of the heat transfer surface
:param theta: [°] angle of the surface with the vertical
:param Ts: [K] heat transfer surface temperature
:param Tf: [K] bulk fluid temperature | python | {
"resource": ""
} |
q262418 | MaterialPackage.clear | validation | def clear(self):
"""
Set all the size class masses and H20_mass in the package to zero
and the | python | {
"resource": ""
} |
q262419 | DataSet.create_template | validation | def create_template(material, path, show=False):
"""
Create a template csv file for a data set.
:param material: the name of the material
:param path: the path of the directory where the file must be written
:param show: a boolean indicating whether the created file should be \
displayed after creation
"""
file_name = 'dataset-%s.csv' % material.lower()
file_path = os.path.join(path, file_name)
with open(file_path, 'w', newline='') as csvfile:
writer = csv.writer(csvfile, delimiter=',',
quotechar='"', quoting=csv.QUOTE_MINIMAL)
writer.writerow(['Name', material])
writer.writerow(['Description', '<Add a data set description '
'here.>'])
writer.writerow(['Reference', '<Add a reference to the source of '
'the data set here.>'])
writer.writerow(['Temperature', '<parameter 1 | python | {
"resource": ""
} |
q262420 | Api._url | validation | def _url(self, endpoint, url_data=None, parameters=None):
"""Generate URL on the modularized endpoints and url parameters"""
try:
url = '%s/%s' % (self.base_url, self.endpoints[endpoint])
except KeyError:
raise EndPointDoesNotExist(endpoint)
if url_data:
| python | {
"resource": ""
} |
q262421 | Api._httplib2_init | validation | def _httplib2_init(username, password):
"""Used to instantiate a regular HTTP request object"""
obj = httplib2.Http()
| python | {
"resource": ""
} |
q262422 | Material.alpha | validation | def alpha(self, **state):
"""
Calculate the alpha value given the material state.
| python | {
"resource": ""
} |
q262423 | DafHTy.calculate | validation | def calculate(self, **state):
"""
Calculate the enthalpy at the specified temperature and composition
using equation 9 in Merrick1983b.
:param T: [K] temperature
:param y_C: Carbon mass fraction
:param y_H: Hydrogen mass fraction
:param y_O: Oxygen mass fraction
:param y_N: Nitrogen mass fraction
:param y_S: Sulphur mass fraction
:returns: [J/kg] enthalpy
The **state parameter contains the keyword argument(s) specified above
that are used to describe the state of the material.
"""
| python | {
"resource": ""
} |
q262424 | TimeBasedModel.create_entity | validation | def create_entity(self, name, gl_structure, description=None):
"""
Create an entity and add it to the model.
:param name: The entity name.
:param gl_structure: The entity's general ledger structure.
:param description: The entity description.
:returns: The created entity.
| python | {
"resource": ""
} |
q262425 | TimeBasedModel.remove_entity | validation | def remove_entity(self, name):
"""
Remove an entity from the model.
:param name: The name of the entity to remove.
"""
entity_to_remove = None
for e in self.entities:
| python | {
"resource": ""
} |
q262426 | TimeBasedModel.prepare_to_run | validation | def prepare_to_run(self):
"""
Prepare the model for execution.
"""
self.clock.reset()
| python | {
"resource": ""
} |
q262427 | TimeBasedModel.run | validation | def run(self):
"""
Execute the model.
"""
self.prepare_to_run()
for i in range(0, self.period_count):
| python | {
"resource": ""
} |
q262428 | Material._create_element_list | validation | def _create_element_list(self):
"""
Extract an alphabetically sorted list of elements from the
material's compounds.
:returns: Alphabetically sorted list of elements.
| python | {
"resource": ""
} |
q262429 | Material.create_stream | validation | def create_stream(self, assay=None, mfr=0.0, P=1.0, T=25.0,
normalise=True):
"""
Create a MaterialStream based on the specified parameters.
:param assay: Name of the assay to be used to create the stream.
:param mfr: Stream mass flow rate. [kg/h]
:param P: Stream pressure. [atm]
:param T: Stream temperature. [°C]
:param normalise: Indicates whether the assay must be normalised
before creating the Stream.
:returns: MaterialStream object.
"""
if assay is None:
| python | {
"resource": ""
} |
q262430 | MaterialPackage._calculate_H | validation | def _calculate_H(self, T):
"""
Calculate the enthalpy of the package at the specified temperature.
:param T: Temperature. [°C]
:returns: Enthalpy. [kWh]
"""
if self.isCoal:
return self._calculate_Hfr_coal(T)
H = 0.0
| python | {
"resource": ""
} |
q262431 | MaterialPackage._calculate_H_coal | validation | def _calculate_H_coal(self, T):
"""
Calculate the enthalpy of the package at the specified temperature, in
case the material is coal.
:param T: [°C] temperature
:returns: [kWh] enthalpy
"""
m_C = 0 # kg
m_H = 0 # kg
m_O = 0 # kg
m_N = 0 # kg
m_S = 0 # kg
H = 0.0 # kWh/h
for compound in self.material.compounds:
index = self.material.get_compound_index(compound)
if stoich.element_mass_fraction(compound, 'C') == 1.0:
m_C += self._compound_masses[index]
elif stoich.element_mass_fraction(compound, 'H') == 1.0:
m_H += self._compound_masses[index]
elif stoich.element_mass_fraction(compound, 'O') == 1.0:
m_O += self._compound_masses[index]
elif stoich.element_mass_fraction(compound, 'N') == 1.0:
m_N += self._compound_masses[index]
elif stoich.element_mass_fraction(compound, 'S') == 1.0:
m_S += self._compound_masses[index]
else:
dH = thermo.H(compound, T, self._compound_masses[index])
| python | {
"resource": ""
} |
q262432 | MaterialPackage._calculate_T | validation | def _calculate_T(self, H):
"""
Calculate the temperature of the package given the specified
enthalpy using a secant algorithm.
:param H: Enthalpy. [kWh]
:returns: Temperature. [°C]
"""
# Create the initial guesses for temperature.
x = list()
x.append(self._T)
x.append(self._T + 10.0)
# Evaluate the enthalpy for the initial guesses.
y = list()
y.append(self._calculate_H(x[0]) - H)
y.append(self._calculate_H(x[1]) - H)
# Solve for | python | {
"resource": ""
} |
q262433 | MaterialPackage.H | validation | def H(self, H):
"""
Set the enthalpy of the package to the specified value, and
recalculate it's temperature.
:param H: The new | python | {
"resource": ""
} |
q262434 | MaterialPackage.T | validation | def T(self, T):
"""
Set the temperature of the package to the specified value, and
recalculate it's enthalpy.
| python | {
"resource": ""
} |
q262435 | MaterialPackage.clone | validation | def clone(self):
"""Create a complete copy of the package.
:returns: A new MaterialPackage object."""
result = copy.copy(self)
| python | {
"resource": ""
} |
q262436 | MaterialPackage.clear | validation | def clear(self):
"""
Set all the compound masses in the package to zero.
Set the pressure to 1, the temperature to 25 and the enthalpy to zero.
"""
| python | {
"resource": ""
} |
q262437 | MaterialPackage.get_compound_mass | validation | def get_compound_mass(self, compound):
"""
Determine the mass of the specified compound in the package.
:param compound: Formula and phase of a compound, e.g. "Fe2O3[S1]".
:returns: Mass. [kg]
"""
if compound in self.material.compounds: | python | {
"resource": ""
} |
q262438 | MaterialPackage.get_compound_amounts | validation | def get_compound_amounts(self):
"""
Determine the mole amounts of all the compounds.
:returns: List of amounts. [kmol]
"""
| python | {
"resource": ""
} |
q262439 | MaterialPackage.get_compound_amount | validation | def get_compound_amount(self, compound):
"""
Determine the mole amount of the specified compound.
:returns: Amount. [kmol]
| python | {
"resource": ""
} |
q262440 | MaterialPackage.amount | validation | def amount(self):
"""
Determine the sum of mole amounts of all the compounds.
:returns: Amount. [kmol]
| python | {
"resource": ""
} |
q262441 | MaterialPackage.get_element_mass_dictionary | validation | def get_element_mass_dictionary(self):
"""
Determine the masses of elements in the package and return as a
dictionary.
:returns: Dictionary of | python | {
"resource": ""
} |
q262442 | MaterialPackage.get_element_mass | validation | def get_element_mass(self, element):
"""
Determine the mass of the specified elements in the package.
:returns: Masses. [kg]
"""
result = numpy.zeros(1)
for compound in self.material.compounds:
result | python | {
"resource": ""
} |
q262443 | MaterialPackage.extract | validation | def extract(self, other):
"""
Extract 'other' from this package, modifying this package and
returning the extracted material as a new package.
:param other: Can be one of the following:
* float: A mass equal to other is extracted from self. Self is
reduced by other and the extracted package is returned as
a new package.
* tuple (compound, mass): The other tuple specifies the mass
of a compound to be extracted. It is extracted from self and
the extracted mass is returned as a new package.
* string: The 'other' string specifies the compound to be
extracted. All of the mass of that compound will be removed
from self and a new package created with it.
* Material: The 'other' material specifies the list of
compounds to extract.
:returns: New MaterialPackage object.
"""
# Extract the specified mass.
if type(other) is float or \
type(other) is numpy.float64 or \
type(other) is numpy.float32:
| python | {
"resource": ""
} |
q262444 | MaterialStream._calculate_Hfr | validation | def _calculate_Hfr(self, T):
"""
Calculate the enthalpy flow rate of the stream at the specified
temperature.
:param T: Temperature. [°C]
:returns: Enthalpy flow rate. [kWh/h]
| python | {
"resource": ""
} |
q262445 | MaterialStream._calculate_Hfr_coal | validation | def _calculate_Hfr_coal(self, T):
"""
Calculate the enthalpy flow rate of the stream at the specified
temperature, in the case of it being coal.
:param T: Temperature. [°C]
:returns: Enthalpy flow rate. [kWh/h]
"""
m_C = 0 # kg/h
m_H = 0 # kg/h
m_O = 0 # kg/h
m_N = 0 # kg/h
m_S = 0 # kg/h
Hfr = 0.0 # kWh/h
for compound in self.material.compounds:
index = self.material.get_compound_index(compound)
formula = compound.split('[')[0]
if stoich.element_mass_fraction(formula, 'C') == 1.0:
m_C += self._compound_mfrs[index]
elif stoich.element_mass_fraction(formula, 'H') == 1.0:
m_H += self._compound_mfrs[index]
elif stoich.element_mass_fraction(formula, 'O') == 1.0:
m_O += self._compound_mfrs[index]
elif stoich.element_mass_fraction(formula, 'N') == 1.0:
m_N += self._compound_mfrs[index]
elif stoich.element_mass_fraction(formula, 'S') == 1.0:
m_S += self._compound_mfrs[index]
else:
| python | {
"resource": ""
} |
q262446 | MaterialStream._calculate_T | validation | def _calculate_T(self, Hfr):
"""
Calculate the temperature of the stream given the specified
enthalpy flow rate using a secant algorithm.
:param H: Enthalpy flow rate. [kWh/h]
:returns: Temperature. [°C]
"""
# Create the initial guesses for temperature.
x = list()
x.append(self._T)
x.append(self._T + 10.0)
# Evaluate the enthalpy for the initial guesses.
y = list()
y.append(self._calculate_Hfr(x[0]) - Hfr)
y.append(self._calculate_Hfr(x[1]) - Hfr)
# Solve for | python | {
"resource": ""
} |
q262447 | MaterialStream.Hfr | validation | def Hfr(self, Hfr):
"""
Set the enthalpy flow rate of the stream to the specified value, and
recalculate it's temperature.
:param H: The new | python | {
"resource": ""
} |
q262448 | MaterialStream.T | validation | def T(self, T):
"""
Set the temperature of the stream to the specified value, and
recalculate it's enthalpy.
| python | {
"resource": ""
} |
q262449 | MaterialStream.HHV | validation | def HHV(self, HHV):
"""
Set the higher heating value of the stream to the specified value, and
recalculate the formation enthalpy of the daf coal.
:param HHV: MJ/kg coal, higher heating value
"""
| python | {
"resource": ""
} |
q262450 | MaterialStream.clone | validation | def clone(self):
"""Create a complete copy of the stream.
:returns: A new MaterialStream object."""
result = copy.copy(self)
| python | {
"resource": ""
} |
q262451 | MaterialStream.clear | validation | def clear(self):
"""
Set all the compound mass flow rates in the stream to zero.
Set the pressure to 1, the temperature to 25 and the enthalpy to zero.
| python | {
"resource": ""
} |
q262452 | MaterialStream.get_compound_mfr | validation | def get_compound_mfr(self, compound):
"""
Determine the mass flow rate of the specified compound in the stream.
:param compound: Formula and phase of a compound, e.g. "Fe2O3[S1]".
:returns: Mass flow rate. [kg/h]
"""
if compound | python | {
"resource": ""
} |
q262453 | MaterialStream.get_compound_afrs | validation | def get_compound_afrs(self):
"""
Determine the amount flow rates of all the compounds.
:returns: List of amount flow rates. [kmol/h]
"""
result = self._compound_mfrs * 1.0
for compound in self.material.compounds:
| python | {
"resource": ""
} |
q262454 | MaterialStream.get_compound_afr | validation | def get_compound_afr(self, compound):
"""
Determine the amount flow rate of the specified compound.
:returns: Amount flow rate. [kmol/h]
""" | python | {
"resource": ""
} |
q262455 | MaterialStream.afr | validation | def afr(self):
"""
Determine the sum of amount flow rates of all the compounds.
:returns: Amount flow rate. | python | {
"resource": ""
} |
q262456 | MaterialStream.get_element_mfrs | validation | def get_element_mfrs(self, elements=None):
"""
Determine the mass flow rates of elements in the stream.
:returns: Array of element mass flow rates. [kg/h]
"""
if elements is None:
elements = self.material.elements
result = numpy.zeros(len(elements))
| python | {
"resource": ""
} |
q262457 | MaterialStream.get_element_mfr_dictionary | validation | def get_element_mfr_dictionary(self):
"""
Determine the mass flow rates of elements in the stream and return as
a dictionary.
:returns: Dictionary of element symbols and mass flow rates. [kg/h]
"""
element_symbols = self.material.elements
element_mfrs | python | {
"resource": ""
} |
q262458 | MaterialStream.get_element_mfr | validation | def get_element_mfr(self, element):
"""
Determine the mass flow rate of the specified elements in the stream.
:returns: Mass flow rates. [kg/h]
"""
result = 0.0
for compound in self.material.compounds:
| python | {
"resource": ""
} |
q262459 | MaterialStream.extract | validation | def extract(self, other):
"""
Extract 'other' from this stream, modifying this stream and returning
the extracted material as a new stream.
:param other: Can be one of the following:
* float: A mass flow rate equal to other is extracted from self. Self
is reduced by other and the extracted stream is returned as
a new stream.
* tuple (compound, mass): The other tuple specifies the mass flow
rate of a compound to be extracted. It is extracted from self and
the extracted mass flow rate is returned as a new stream.
* string: The 'other' string specifies the compound to be
extracted. All of the mass flow rate of that compound will be
removed from self and a new stream created with it.
* Material: The 'other' material specifies the list of
compounds to extract.
:returns: New MaterialStream object.
"""
# Extract the specified mass flow rate.
if type(other) is float or \
type(other) is numpy.float64 or \
type(other) is numpy.float32:
| python | {
"resource": ""
} |
q262460 | Gr | validation | def Gr(L: float, Ts: float, Tf: float, beta: float, nu: float, g: float):
"""
Calculate the Grashof number.
:param L: [m] heat transfer surface characteristic length.
:param Ts: [K] heat transfer surface temperature.
:param Tf: [K] bulk fluid temperature.
:param beta: [1/K] fluid coefficient of thermal expansion.
:param nu: [m2/s] fluid kinematic viscosity.
:returns: float
.. math:: | python | {
"resource": ""
} |
q262461 | Re | validation | def Re(L: float, v: float, nu: float) -> float:
"""
Calculate the Reynolds number.
:param L: [m] surface characteristic length.
:param v: [m/s] fluid velocity relative to the object.
| python | {
"resource": ""
} |
q262462 | Ra | validation | def Ra(L: float, Ts: float, Tf: float, alpha: float, beta: float, nu: float
) -> float:
"""
Calculate the Ralleigh number.
:param L: [m] heat transfer surface characteristic length.
:param Ts: [K] heat transfer surface temperature.
:param Tf: [K] bulk fluid temperature.
:param alpha: [m2/s] fluid thermal diffusivity.
:param beta: [1/K] fluid coefficient of thermal expansion.
:param nu: [m2/s] fluid kinematic viscosity.
| python | {
"resource": ""
} |
q262463 | Nu | validation | def Nu(L: float, h: float, k: float) -> float:
"""
Calculate the Nusselt number.
:param L: [m] heat transfer surface characteristic | python | {
"resource": ""
} |
q262464 | Sh | validation | def Sh(L: float, h: float, D: float) -> float:
"""
Calculate the Sherwood number.
:param L: [m] mass transfer surface | python | {
"resource": ""
} |
q262465 | PolynomialModelT.create | validation | def create(dataset, symbol, degree):
"""
Create a model object from the data set for the property specified by
the supplied symbol, using the specified polynomial degree.
:param dataset: a DataSet object
:param symbol: the symbol of the property to be described, e.g. 'rho'
:param degree: the polynomial degree to use
:returns: a new PolynomialModelT object
"""
x_vals = dataset.data['T'].tolist()
y_vals = dataset.data[symbol].tolist()
coeffs = np.polyfit(x_vals, y_vals, degree)
result = PolynomialModelT(dataset.material,
| python | {
"resource": ""
} |
q262466 | PolynomialModelT.calculate | validation | def calculate(self, **state):
"""
Calculate the material physical property at the specified temperature
in the units specified by the object's 'property_units' property.
:param T: [K] temperature | python | {
"resource": ""
} |
q262467 | Component.create_component | validation | def create_component(self, name, description=None):
"""
Create a sub component in the business component.
:param name: The new component's name.
:param description: The new component's description.
:returns: The created component.
"""
new_comp | python | {
"resource": ""
} |
q262468 | Component.remove_component | validation | def remove_component(self, name):
"""
Remove a sub component from the component.
:param name: The name of the component to remove.
"""
component_to_remove = None
for c in self.components:
| python | {
"resource": ""
} |
q262469 | Component.get_component | validation | def get_component(self, name):
"""
Retrieve a child component given its name.
:param name: The name of the component.
:returns: | python | {
"resource": ""
} |
q262470 | Component.add_activity | validation | def add_activity(self, activity):
"""
Add an activity to the component.
:param activity: The activity.
"""
self.gl.structure.validate_account_names(
| python | {
"resource": ""
} |
q262471 | Component.get_activity | validation | def get_activity(self, name):
"""
Retrieve an activity given its name.
:param name: The name of the activity.
:returns: The activity. | python | {
"resource": ""
} |
q262472 | Component.prepare_to_run | validation | def prepare_to_run(self, clock, period_count):
"""
Prepare the component for execution.
:param clock: The clock containing the execution start time and
execution period information.
:param period_count: The total amount of periods this activity will be
requested to be run for.
| python | {
"resource": ""
} |
q262473 | Component.run | validation | def run(self, clock, generalLedger):
"""
Execute the component at the current clock cycle.
:param clock: The clock containing the current execution time and
period information.
:param generalLedger: The general ledger into which to create the
transactions.
| python | {
"resource": ""
} |
q262474 | Entity.prepare_to_run | validation | def prepare_to_run(self, clock, period_count):
"""
Prepare the entity for execution.
:param clock: The clock containing the execution start time and
execution period information.
:param period_count: The total amount of periods this activity will be
requested to be run for.
"""
self.period_count = period_count
self._exec_year_end_datetime = clock.get_datetime_at_period_ix(
| python | {
"resource": ""
} |
q262475 | Entity.run | validation | def run(self, clock):
"""
Execute the entity at the current clock cycle.
:param clock: The clock containing the current execution time and
period information.
"""
if clock.timestep_ix >= self.period_count:
| python | {
"resource": ""
} |
q262476 | count_with_multiplier | validation | def count_with_multiplier(groups, multiplier):
""" Update group counts with multiplier
This is for handling atom counts on groups like (OH)2
:param groups: iterable of Group/Element | python | {
"resource": ""
} |
q262477 | amounts | validation | def amounts(masses):
"""
Calculate the amounts from the specified compound masses.
:param masses: [kg] dictionary, e.g. {'SiO2': 3.0, 'FeO': 1.5}
:returns: [kmol] dictionary
""" | python | {
"resource": ""
} |
q262478 | amount_fractions | validation | def amount_fractions(masses):
"""
Calculate the mole fractions from the specified compound masses.
:param masses: [kg] dictionary, e.g. {'SiO2': 3.0, 'FeO': 1.5}
:returns: [mole fractions] dictionary
| python | {
"resource": ""
} |
q262479 | masses | validation | def masses(amounts):
"""
Calculate the masses from the specified compound amounts.
:param masses: [kmol] dictionary, e.g. {'SiO2': 3.0, 'FeO': 1.5}
:returns: [kg] dictionary
""" | python | {
"resource": ""
} |
q262480 | mass_fractions | validation | def mass_fractions(amounts):
"""
Calculate the mole fractions from the specified compound amounts.
:param amounts: [kmol] dictionary, e.g. {'SiO2': 3.0, 'FeO': 1.5}
:returns: [mass fractions] dictionary
| python | {
"resource": ""
} |
q262481 | convert_compound | validation | def convert_compound(mass, source, target, element):
"""
Convert the specified mass of the source compound to the target using
element as basis.
:param mass: Mass of from_compound. [kg]
:param source: Formula and phase of the original compound, e.g.
'Fe2O3[S1]'.
:param target: Formula and phase of the target compound, e.g. 'Fe[S1]'.
| python | {
"resource": ""
} |
q262482 | element_mass_fraction | validation | def element_mass_fraction(compound, element):
"""
Determine the mass fraction of an element in a chemical compound.
:param compound: Formula of the chemical compound, 'FeCr2O4'.
:param element: Element, | python | {
"resource": ""
} |
q262483 | elements | validation | def elements(compounds):
"""
Determine the set of elements present in a list of chemical compounds.
The list of elements is sorted alphabetically.
:param compounds: List of | python | {
"resource": ""
} |
q262484 | molar_mass | validation | def molar_mass(compound=''):
"""Determine the molar mass of a chemical compound.
The molar mass is usually the mass of one mole of the substance, but here
it is the mass of 1000 moles, since the mass unit used in auxi is kg.
:param compound: Formula of a chemical compound, e.g. 'Fe2O3'.
:returns: Molar mass. [kg/kmol]
"""
| python | {
"resource": ""
} |
q262485 | stoichiometry_coefficient | validation | def stoichiometry_coefficient(compound, element):
"""
Determine the stoichiometry coefficient of an element in a chemical
compound.
:param compound: Formula of a chemical compound, e.g. 'SiO2'.
:param element: Element, e.g. 'Si'.
| python | {
"resource": ""
} |
q262486 | stoichiometry_coefficients | validation | def stoichiometry_coefficients(compound, elements):
"""
Determine the stoichiometry coefficients of the specified elements in
the specified chemical compound.
:param compound: Formula of a chemical compound, e.g. 'SiO2'.
:param elements: List of elements, e.g. ['Si', | python | {
"resource": ""
} |
q262487 | MaterialPackage.add_to | validation | def add_to(self, other):
"""
Add another psd material package to this material package.
:param other: The other material package.
"""
# Add another package.
if type(other) is MaterialPackage:
# Packages of the same material.
if self.material == other.material:
self.size_class_masses = \
self.size_class_masses + other.size_class_masses
else: # Packages of different materials.
for size_class in other.material.size_classes:
if size_class not in self.material.size_classes:
raise Exception(
"Packages of '" + other.material.name +
"' cannot be added to packages of '" +
self.material.name +
"'. The size class '" + size_class +
| python | {
"resource": ""
} |
q262488 | Clock.get_datetime_at_period_ix | validation | def get_datetime_at_period_ix(self, ix):
"""
Get the datetime at a given period.
:param period: The index of the period.
:returns: The datetime.
"""
if self.timestep_period_duration == TimePeriod.millisecond:
return self.start_datetime + timedelta(milliseconds=ix)
elif self.timestep_period_duration == TimePeriod.second:
return self.start_datetime + timedelta(seconds=ix)
elif self.timestep_period_duration == TimePeriod.minute:
return self.start_datetime + timedelta(minutes=ix)
elif self.timestep_period_duration == TimePeriod.hour:
return self.start_datetime + timedelta(hours=ix)
elif self.timestep_period_duration == TimePeriod.day:
return self.start_datetime + | python | {
"resource": ""
} |
q262489 | _get_default_data_path_ | validation | def _get_default_data_path_():
"""
Calculate the default path in which thermochemical data is stored.
:returns: Default path.
"""
module_path = os.path.dirname(sys.modules[__name__].__file__)
| python | {
"resource": ""
} |
q262490 | _split_compound_string_ | validation | def _split_compound_string_(compound_string):
"""
Split a compound's combined formula and phase into separate strings for
the formula and phase.
:param compound_string: Formula and phase of a chemical compound, e.g.
'SiO2[S1]'.
:returns: Formula of chemical compound.
:returns: Phase of chemical compound.
| python | {
"resource": ""
} |
q262491 | _finalise_result_ | validation | def _finalise_result_(compound, value, mass):
"""
Convert the value to its final form by unit conversions and multiplying
by mass.
:param compound: Compound object.
:param value: [J/mol] Value to be finalised.
:param mass: [kg] Mass of compound.
:returns: [kWh] Finalised value.
"""
result | python | {
"resource": ""
} |
q262492 | write_compound_to_auxi_file | validation | def write_compound_to_auxi_file(directory, compound):
"""
Writes a compound to an auxi file at the specified directory.
:param dir: The directory.
:param compound: The compound.
"""
| python | {
"resource": ""
} |
q262493 | load_data_factsage | validation | def load_data_factsage(path=''):
"""
Load all the thermochemical data factsage files located at a path.
:param path: Path at which the data files are located.
"""
compounds.clear()
if path == '':
path = default_data_path
if not os.path.exists(path):
warnings.warn('The specified data file path does not exist. (%s)' % path)
| python | {
"resource": ""
} |
q262494 | load_data_auxi | validation | def load_data_auxi(path=''):
"""
Load all the thermochemical data auxi files located at a path.
:param path: Path at which the data files are located.
"""
compounds.clear()
if path == '':
path = default_data_path
if not os.path.exists(path):
warnings.warn('The specified data file path does not exist. (%s)' % path)
| python | {
"resource": ""
} |
q262495 | list_compounds | validation | def list_compounds():
"""
List all compounds that are currently loaded in the thermo module, and
their phases.
"""
print('Compounds currently loaded:')
for compound in sorted(compounds.keys()):
| python | {
"resource": ""
} |
q262496 | Cp | validation | def Cp(compound_string, T, mass=1.0):
"""
Calculate the heat capacity of the compound for the specified temperature
and mass.
:param compound_string: Formula and phase of chemical compound, e.g.
'Fe2O3[S1]'.
:param T: [°C] temperature
:param mass: [kg]
:returns: [kWh/K] Heat capacity.
"""
| python | {
"resource": ""
} |
q262497 | CpRecord.Cp | validation | def Cp(self, T):
"""
Calculate the heat capacity of the compound phase.
:param T: [K] temperature
:returns: [J/mol/K] Heat capacity.
"""
result = 0.0
| python | {
"resource": ""
} |
q262498 | CpRecord.H | validation | def H(self, T):
"""
Calculate the portion of enthalpy of the compound phase covered by this
Cp record.
:param T: [K] temperature
:returns: [J/mol] Enthalpy.
"""
result = 0.0
if T < self.Tmax:
lT = T
else:
lT = self.Tmax
Tref = self.Tmin
for c, e in zip(self._coefficients, self._exponents):
| python | {
"resource": ""
} |
q262499 | CpRecord.S | validation | def S(self, T):
"""
Calculate the portion of entropy of the compound phase covered by this
Cp record.
:param T: [K] temperature
:returns: Entropy. [J/mol/K]
"""
result = 0.0
if T < self.Tmax:
lT = T
else:
lT = self.Tmax
Tref = self.Tmin
for c, e in zip(self._coefficients, self._exponents):
# Create a modified exponent to analytically integrate Cp(T)/T
# instead of Cp(T).
| python | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.