geophires_x

class geophires_x.TDPReservoir.TDPReservoir(model: <module 'geophires_x.Model' from '/home/runner/work/GEOPHIRES-X/GEOPHIRES-X/src/geophires_x/Model.py'>)

This class models the Thermal Drawdown Percentage Reservoir.

Calculate(model: <module 'geophires_x.Model' from '/home/runner/work/GEOPHIRES-X/GEOPHIRES-X/src/geophires_x/Model.py'>)

The Calculate function calculates the values of all the parameters that are calculated by this object. :param model: The container class of the application, giving access to everything else, including the logger :type model: Model :return: None

read_parameters(model: <module 'geophires_x.Model' from '/home/runner/work/GEOPHIRES-X/GEOPHIRES-X/src/geophires_x/Model.py'>) → None

The read_parameters function reads in the parameters from a dictionary created by reading the user-provided file and updates the parameter values for this object. The function reads in all the parameters that relate to this object, including those that are inherited from other objects. It then updates any of these parameter values that have been changed by the user. It also handles any special cases. :param model: The container class of the application, giving access to everything else, including the logger :type model: Model :return: None

class geophires_x.LHSReservoir.LHSReservoir(model: <module 'geophires_x.Model' from '/home/runner/work/GEOPHIRES-X/GEOPHIRES-X/src/geophires_x/Model.py'>)

This class models the Linear Heat Sweep Reservoir. It is a subclass of the Reservoir class. It inherits all the methods and attributes of those classes, and can override them as necessary. It also has its own methods and attributes that are unique to this class.

Calculate(model: <module 'geophires_x.Model' from '/home/runner/work/GEOPHIRES-X/GEOPHIRES-X/src/geophires_x/Model.py'>)

The Calculate function calculates the values of all the parameters that are calculated by this object. It calls the Calculate function of the parent object to calculate the values of the parameters that are calculated by the parent object. It then calculates the values of the parameters that are calculated by this object. :param model: The container class of the application, giving access to everything else, including the logger :type model: Model :return: None

read_parameters(model: <module 'geophires_x.Model' from '/home/runner/work/GEOPHIRES-X/GEOPHIRES-X/src/geophires_x/Model.py'>) → None

The read_parameters function reads in the parameters from a dictionary created by reading the user-provided file

and updates the parameter values for this object.

The function reads in all the parameters that relate to this object, including those that are inherited from other objects. It then updates any of these parameter values that have been changed by the user.

It also handles any special cases.

Parameters:

model (Model) – The container class of the application, giving access to everything else, including the logger

Returns:

None

class geophires_x.MPFReservoir.MPFReservoir(model: <module 'geophires_x.Model' from '/home/runner/work/GEOPHIRES-X/GEOPHIRES-X/src/geophires_x/Model.py'>)

This class models the Multiple Parallel Fractures Reservoir. It is a subclass of the Reservoir class. It inherits all the methods and attributes of that class, and can override them as necessary. It also has its own methods and attributes that are unique to this class.

Calculate(model: <module 'geophires_x.Model' from '/home/runner/work/GEOPHIRES-X/GEOPHIRES-X/src/geophires_x/Model.py'>)

The Calculate function calculates the values of all the parameters that are calculated by this object. :param model: The container class of the application, giving access to everything else, including the logger :type model: Model :return: None

read_parameters(model: <module 'geophires_x.Model' from '/home/runner/work/GEOPHIRES-X/GEOPHIRES-X/src/geophires_x/Model.py'>) → None

The read_parameters function reads in the parameters from a dictionary created by reading the user-provided file and updates the parameter values for this object. The function reads in all parameters that relate to this object, including those that are inherited from other objects. It then updates any of these parameter values that have been changed by the user. It also handles any special cases. :param model: The container class of the application, giving access to everything else, including the logger :type model: Model :return: None

class geophires_x.SFReservoir.SFReservoir(model: <module 'geophires_x.Model' from '/home/runner/work/GEOPHIRES-X/GEOPHIRES-X/src/geophires_x/Model.py'>)

This class models the Single Fracture Reservoir.

Calculate(model: <module 'geophires_x.Model' from '/home/runner/work/GEOPHIRES-X/GEOPHIRES-X/src/geophires_x/Model.py'>)

The Calculate function calculates the values of all the parameters that are calculated by this object. It calls the Calculate function of the parent object to calculate the values of the parameters that are calculated by the parent object. It then calculates the values of the parameters that are calculated by this object. :param model: The container class of the application, giving access to everything else, including the logger :type model: Model :return: None

read_parameters(model: <module 'geophires_x.Model' from '/home/runner/work/GEOPHIRES-X/GEOPHIRES-X/src/geophires_x/Model.py'>) → None

The read_parameters function reads in the parameters from a dictionary created by reading the user-provided file

nd updates the parameter values for this object.

The function reads in all the parameters that relate to this object, including those that are inherited from other objects. It then updates any of these parameter values that have been changed by the user. It also handles any special cases. :param model: The container class of the application, giving access to everything else, including the logger :type model: Model :return: None

class geophires_x.CylindricalReservoir.CylindricalReservoir(model: <module 'geophires_x.Model' from '/home/runner/work/GEOPHIRES-X/GEOPHIRES-X/src/geophires_x/Model.py'>)

The CylindricalReservoir class is a subclass of the Reservoir class in a straightforward conduction-only model. It inherits from the primary Reservoir model but offers new parameters and calculations.

Calculate(model: <module 'geophires_x.Model' from '/home/runner/work/GEOPHIRES-X/GEOPHIRES-X/src/geophires_x/Model.py'>) → None

The Calculate function is where all the calculations are done. This function can be called multiple times, and will only recalculate what has changed each time it is called. This is where all the calculations are made using all the values that have been set. If you subclass this class, you can choose to run these calculations before (or after) your calculations, but that assumes you have set all the values that are required for these calculations If you choose to subclass this master class, you can also choose to override this method (or not), and if you do, do it before or after you call you own version of this method. If you do, you can also choose to call this method from you class, which can effectively run the calculations of the superclass, making all the values available to your methods. but you had better have set all the parameters! :param model: The container class of the application, giving access to everything else, including the logger :type model: Model :return: Nothing, but it does make calculations and set values in the model

lithostatic_pressure() → PlainQuantity

@override

read_parameters(model: <module 'geophires_x.Model' from '/home/runner/work/GEOPHIRES-X/GEOPHIRES-X/src/geophires_x/Model.py'>) → None

The read_parameters function reads in the parameters from a dictionary created by reading the user-provided

file and updates the parameter values for this object.

The function reads in all the parameters that relate to this object, including those that are inherited from other objects. It then updates any of these parameter values that have been changed by the user. It also handles any special cases. :param model: The container class of the application, giving access to everything else, including the logger :type model: Model :return: None

class geophires_x.SBTReservoir.SBTReservoir(model: <module 'geophires_x.Model' from '/home/runner/work/GEOPHIRES-X/GEOPHIRES-X/src/geophires_x/Model.py'>)

The following code calculates the temperature profile in a U-shaped geothermal well using the SBT algorithm.

Calculate(model)

The Calculate function is the main function that is called to run the calculations for this object. In this case, it just calls the appropriate function based on the configuration of the wellbores.

Calculate_Coaxial(model)

Calculate the coaxial version of the SBT model

Calculate_Uloop(model)

Calculate the U-loop version of the SBT model

read_parameters(model: <module 'geophires_x.Model' from '/home/runner/work/GEOPHIRES-X/GEOPHIRES-X/src/geophires_x/Model.py'>) → None

The read_parameters function reads in the parameters from a dictionary created by reading the user-provided file and updates the parameter values for this object. The function reads in all the parameters that relate to this object, including those that are inherited from other objects. It then updates any of these parameter values that have been changed by the user. It also handles any special cases. :param model: The container class of the application, giving access to everything else, including the logger :type model: Model :return: None

geophires_x.SBTReservoir.interpolator(time_value: float, times: ndarray, values: ndarray) → float

Interpolates values based on time :param time_value: Time value :type time_value: float :param values: Values :type values: float :return: Interpolated value :rtype: float

class geophires_x.SUTRAReservoir.SUTRAReservoir(model: <module 'geophires_x.Model' from '/home/runner/work/GEOPHIRES-X/GEOPHIRES-X/src/geophires_x/Model.py'>)

This class reads in the output of a simulation with SUTRA. It then uses the output to calculate the heat stored, heat supplied and efficiency for each year of the simulation. It also calculates the target heat and simulated heat for each SUTRA time step over the lifetime of the simulation. Finally, it calculates the well flow rate and temperature for each SUTRA time step over the lifetime of the simulation. It then stores all these values in the appropriate arrays in the reservoir class. It also creates plots of the SUTRA output data.

Calculate(model: <module 'geophires_x.Model' from '/home/runner/work/GEOPHIRES-X/GEOPHIRES-X/src/geophires_x/Model.py'>)

The Calculate function reads in the SUTRA output files and stores the data in the appropriate reservoir arrays. It also creates plots of the SUTRA output data. It then calls the Calculate function of the parent class. :param model: The container class of the application, giving access to everything else, including the logger :type model: Model :return: None

read_parameters(model: <module 'geophires_x.Model' from '/home/runner/work/GEOPHIRES-X/GEOPHIRES-X/src/geophires_x/Model.py'>) → None

The read_parameters function reads in the parameters from a dictionary created by reading the user-provided file and updates the parameter values for this object. The function reads in all the parameters that relate to this object, including those that are inherited from other objects. It then updates any of these parameter values that have been changed by the user. It also handles any special cases. :param model: The container class of the application, giving access to everything else, including the logger :type model: Model :return: None

geophires_x.WellBores.InjPressureDropAndPumpingPowerUsingIndexes(model: <module 'geophires_x.Model' from '/home/runner/work/GEOPHIRES-X/GEOPHIRES-X/src/geophires_x/Model.py'>, productionwellpumping: bool, usebuiltinppwellheadcorrelation: bool, usebuiltinoutletplantcorrelation: bool, Trock_degC: float, depth_m: float, ppwellhead: float, II: float, wellflowrate: float, f1: float, vinj: float, injwelldiam: float, nprod: int, ninj: int, waterloss: float, pumpeff: float, rhowaterinj: float, Pplantoutlet: float) → tuple

Calculate PressureDrops and Pumping Power needed for the injection well using indexes

param depth_m:

depth of the well [m]

type depth_m:

float

param wellflowrate:

flow rate of the fluid in the well [kg/s]

type wellflowrate:

float

param pumpeff:

pump efficiency [-]

type pumpeff:

float

param nprod:

number of production wells [-]

type nprod:

int

param ppwellhead:

production wellhead pressure [kPa]

type ppwellhead:

float

param Trock_degC:

rock temperature [C]

type Trock_degC:

float

param usebuiltinppwellheadcorrelation:

whether to use the built-in wellhead pressure correlation (True or False) [-]

type usebuiltinppwellheadcorrelation:

bool

param productionwellpumping:

whether the production well is pumping (True or False) [-]

type productionwellpumping:

bool

param model:

The container class of the application, giving access to everything else, including the logger

type model:

Model

param Pplantoutlet:

plant outlet pressure [kPa]

type Pplantoutlet:

float

param rhowaterinj:

density of the water in the injection well [kg/m3]

type rhowaterinj:

float

param waterloss:

water loss [-]

type waterloss:

float

param ninj:

number of injection wells [-]

type ninj:

int

param injwelldiam:

diameter of the well [m]

type injwelldiam:

float

param vinj:

velocity of the fluid in the injection well [m/s]

type vinj:

float

param f1:

friction factor [-]

type f1:

float

param usebuiltinoutletplantcorrelation:

whether or not to use the built-in outlet plant pressure correlation (True or False) [-]

type usebuiltinoutletplantcorrelation:

bool

param II:

injectivity index [kg/s/bar]

type II:

float

return:

tuple of PumpingPowerInj, DPInjWell, plant_outlet_pressure, Pprodwellhead [kPa]

rtype:

tuple

geophires_x.WellBores.InjPressureDropsAndPumpingPowerUsingImpedenceModel(f1: float, vinj: float, rhowaterinj: float, depth: float, wellflowrate: float, injwelldiam: float, ninj: int, waterloss: float, pumpeff: float, DPOverall) → tuple

Calculate Injection well Pressure Drops and Pumping Power needed for the injection well using the Impedance Model

param f1:

friction factor [-]

type f1:

float

param vinj:

velocity of the fluid in the injection well [m/s]

type vinj:

float

param rhowaterinj:

density of the water in the injection well [kg/m3]

type rhowaterinj:

float

param depth:

depth of the well [m]

type depth:

float

param wellflowrate:

flow rate of the fluid in the well [kg/s]

type wellflowrate:

float

param injwelldiam:

diameter of the well [m]

type injwelldiam:

float

param ninj:

number of injection wells [-]

type ninj:

int

param waterloss:

water loss [-]

type waterloss:

float

param pumpeff:

pump efficiency [-]

type pumpeff:

float

param DPOverall:

overall pressure drop [kPa]

type DPOverall:

float

return:

tuple of newDPOverall, PumpingPower, DPInjWell [kPa]

rtype:

tuple

geophires_x.WellBores.InjectionReservoirPressurePredictor(project_lifetime_yr: int, timesteps_per_year: int, initial_pressure_kPa: float, inflation_rate: float) → list

InjectionReservoirPressurePredictor builds the Injection Reservoir Pressure Array for the project lifetime

based on the initial (perhaps hydrostatic) pressure and the inflation rate. There is no limit to how high the

pressure can go.

Parameters:

• project_lifetime_yr (int) – The lifetime of the project in years

• timesteps_per_year (int) – The number of timesteps per year

• initial_pressure_kPa (float) – The initial pressure in kPa

• inflation_rate (float) – The inflation rate in %/yr

Returns:

pressure: The pressure array as a function of time.

Return type:

list

geophires_x.WellBores.InjectionWellPressureDrop(model: <module 'geophires_x.Model' from '/home/runner/work/GEOPHIRES-X/GEOPHIRES-X/src/geophires_x/Model.py'>, Taverage: float, wellflowrate: float, welldiam: float, impedancemodelused: bool, depth: float, nprod: int, ninj: int, waterloss: float) → tuple

calculate the injection well pressure drop over the length of the well due to friction or impedance

param model:

The container class of the application, giving access to everything else, including the logger

type model:

Model

param Taverage:

average temperature of the fluid in the well [C]

type Taverage:

float

param wellflowrate:

flow rate of the fluid in the well [kg/s]

type wellflowrate:

float

param welldiam:

diameter of the well [m]

type welldiam:

float

param impedancemodelused:

whether or not the impedance model is used (True or False) [-]

type impedancemodelused:

bool

param depth:

depth of the well [m]

type depth:

float

param nprod:

number of production wells [-]

type nprod:

int

param ninj:

number of injection wells [-]

type ninj:

int

param waterloss:

water loss [-]

type waterloss:

float

return:

tuple of DPWell, f1, v, rhowater

rtype:

tuple

geophires_x.WellBores.ProdPressureDropAndPumpingPowerUsingIndexes(model: <module 'geophires_x.Model' from '/home/runner/work/GEOPHIRES-X/GEOPHIRES-X/src/geophires_x/Model.py'>, productionwellpumping: bool, usebuiltinppwellheadcorrelation: bool, Trock_degC: float, depth_m: float, ppwellhead_kPa: float, PI_kg_per_sec_per_bar: float, wellflowrate_kg_per_sec: float, f3: float, vprod_m: float, prodwelldiam_m: float, nprod: int, pumpeff: float, rhowaterprod_kg_per_m3: float) → tuple

Calculate Pressure Drops and Pumping Power needed for the production well using indexes

param model:

The container class of the application, giving access to everything else, including the logger

type model:

Model

param productionwellpumping:

whether or not the production well is pumping (True or False) [-]

type productionwellpumping:

bool

param usebuiltinppwellheadcorrelation:

whether or not to use the built-in wellhead pressure correlation (True or False) [-]

type usebuiltinppwellheadcorrelation:

bool

param Trock_degC:

rock temperature [C]

type Trock_degC:

float

param depth_m:

depth of the well [m]

type depth_m:

float

param ppwellhead_kPa:

production wellhead pressure [kPa]

type ppwellhead_kPa:

float

param PI_kg_per_sec_per_bar:

productivity index [kg/s/bar]

type PI_kg_per_sec_per_bar:

float

param wellflowrate_kg_per_sec:

flow rate of the fluid in the well [kg/s]

type wellflowrate_kg_per_sec:

float

param f3:

friction factor [-]

type f3:

float

param vprod_m:

velocity of the fluid in the production well [m/s]

type vprod_m:

float

param prodwelldiam_m:

diameter of the well [m]

type prodwelldiam_m:

float

param nprod:

number of production wells [-]

type nprod:

int

param pumpeff:

pump efficiency [-]

type pumpeff:

float

param rhowaterprod_kg_per_m3:

density of the water in the production well [kg/m3]

type rhowaterprod_kg_per_m3:

float

return:

tuple of PumpingPower, PumpingPowerProd, DPProdWell, Pprodwellhead [kPa]

rtype:

tuple

geophires_x.WellBores.ProdPressureDropsAndPumpingPowerUsingImpedenceModel(f3: float, vprod: float, rhowaterinj: float, rhowaterprod: float, rhowaterreservoir: float, depth: float, wellflowrate: float, prodwelldiam: float, impedance: float, nprod: int, waterloss: float, pumpeff: float, tilt: float = 90.0, trim_neg_to_zero: bool = True) → tuple

Calculate Pressure Drops and Pumping Power needed for the production well using the Impedance Model

param f3:

friction factor [-]

type f3:

float

param vprod:

velocity of the fluid in the production well [m/s]

type vprod:

float

param rhowaterinj:

density of the water in the injection well [kg/m3]

type rhowaterinj:

float

param rhowaterreservoir:

density of the water in the reservoir [kg/m3]

type rhowaterreservoir:

float

param rhowaterprod:

density of the water in the production well [kg/m3]

type rhowaterprod:

float

param depth:

depth of the well [m]

type depth:

float

param wellflowrate:

flow rate of the fluid in the well [kg/s]

type wellflowrate:

float

param prodwelldiam:

diameter of the well [m]

type prodwelldiam:

float

param impedance:

impedance of the reservoir [kg/s/kPa]

type impedance:

float

param nprod:

number of production wells [-]

type nprod:

int

param waterloss:

water loss [-]

type waterloss:

float

param pumpeff:

pump efficiency [-]

type pumpeff:

float

param tilt:

tilt of the well from the junction box to the bottom of the laterals [degrees]

type tilt:

float

param trim_neg_to_zero:

whether to trim negative values of pumping power to zero

type trim_neg_to_zero:

bool

return:

tuple of DPOverall, PumpingPower, DPProdWell, DPReserv, DPBouyancy

rtype:

tuple

geophires_x.WellBores.RameyCalc(krock: float, rhorock: float, cprock: float, welldiam: float, tv, utilfactor: float, flowrate: float, cpwater: float, Trock: float, Tresoutput: float, averagegradient: float, depth: float) → float

Calculate the temperature drop along the length of a well this code is only valid so far for 1 gradient and deviation = 0 For multiple gradients, use Ramey’s model for every layer assume outside diameter of casing is 10% larger than inside diameter of production pipe (=prodwelldiam) assume borehole thermal resistance is negligible to rock thermal resistance

param depth:

depth of the well [m]

type:

float

param averagegradient:

average geothermal gradient [C/km]

type:

float

param Tresoutput:

reservoir output temperature [C]

type:

float

param Trock:

rock temperature [C]

type:

float

param flowrate:

flow rate [kg/s]

type:

float

param utilfactor:

utilization factor (fraction of time the well is producing) [-]

type:

float

param tv:

time vector [years]

type:

float

param welldiam:

well diameter [m]

type:

float

param cprock:

rock heat capacity [J/kg/C]

type:

float

param rhorock:

rock density [kg/m3]

type:

float

param krock:

rock thermal conductivity [W/m/C]

type:

float

param cpwater:

water heat capacity [J/kg/C]

type:

float

return:

temperature drop along the length of the well [C]

rtype:

float

geophires_x.WellBores.ReservoirPressurePredictor(project_lifetime_yr: int, timesteps_per_year: int, initial_pressure_kPa: float, overpressure_percentage: float, depletion_rate: float) → list

ReservoirPressurePredictor builds the Reservoir Pressure Array for the project lifetime based on the initial (likely hydrostatic) pressure. the overpressure percentage and the depletion rate. Don’t let the pressure drop below the initial pressure. :param project_lifetime_yr: The lifetime of the project in years :type project_lifetime_yr: int :param timesteps_per_year: The number of timesteps per year :type timesteps_per_year: int :param initial_pressure_kPa: The hydrostatic pressure in kPa :type initial_pressure_kPa: float :param overpressure_percentage: The overpressure percentage in % :type overpressure_percentage: float :param depletion_rate: The depletion rate in %/yr :type depletion_rate: float :return: hydrostatic_pressure: The hydrostatic pressure array as a function of time. :rtype: list

geophires_x.WellBores.WellPressureDrop(model: <module 'geophires_x.Model' from '/home/runner/work/GEOPHIRES-X/GEOPHIRES-X/src/geophires_x/Model.py'>, Taverage: float, wellflowrate: float, welldiam: float, impedancemodelused: bool, depth: float) → tuple

calculate the pressure drop over the length of the well due to friction or impedance for the production well and the injection well (if applicable) using the Impedance Model or the friction model (if applicable) and the well flow rate and diameter and the average temperature of the fluid in the well (which is the average of the reservoir temperature and the injection temperature) and the depth of the well and the impedance of the reservoir (if applicable) and the number of production wells and the number of injection wells and the water loss (if applicable)

param model:

The container class of the application, giving access to everything else, including the logger

type model:

Model

param Taverage:

average temperature of the fluid in the well [C]

type Taverage:

float

param wellflowrate:

flow rate of the fluid in the well [kg/s]

type wellflowrate:

float

param welldiam:

diameter of the well [m]

type welldiam:

float

param impedancemodelused:

whether or not the impedance model is used (True or False) [-]

type impedancemodelused:

bool

param depth:

depth of the well [m]

type depth:

float

return:

tuple of DPWell, f3, v, rhowater

rtype:

tuple

geophires_x.WellBores.calculate_total_drilling_lengths_m(Configuration, numnonverticalsections: int, nonvertical_length_km: float, InputDepth_km: float, OutputDepth_km: float, nprod: int, ninj: int, junction_depth_km: float = 0.0, angle_rad: float = 0.0) → tuple

returns the total length, vertical length, and non-vertical lengths, depending on the configuration :param Configuration: configuration of the well :type Configuration: :class:`~geophires :param numnonverticalsections: number of non-vertical sections :type numnonverticalsections: int :param nonvertical_length_km: length of non-vertical sections in km :type nonvertical_length_km: float :param InputDepth_km: depth of the well in km :type InputDepth_km: float :param OutputDepth_km: depth of the output end of the well in km, if U shaped, and not horizontal :type OutputDepth_km: float :param nprod: number of production wells :type nprod: int :param ninj: number of injection wells :param junction_depth_km: depth of the junction in km :type junction_depth_km: float :param angle_rad: angle of the well in radians, from horizontal :type angle_rad: float :return: total length, vertical length, lateral, and junction lengths in meters :rtype: tuple

geophires_x.WellBores.get_hydrostatic_pressure_kPa(Trock_degC: float, Tsurf_degC: float, depth_m: float, gradient_C_per_km: float, lithostatic_pressure: PlainQuantity) → float

Correlation cited as being from Xie, Bloomfield, and Shook in https://workingincaes.inl.gov/SiteAssets/CAES%20Files/FORGE/inl_ext-16-38751%20GETEM%20User%20Manual%20Final.pdf

contains code from Wanju Yuan based on: “Closed-Loop Geothermal Energy Recovery from Deep High Enthalpy Systems” ref: Yuan, Wanju, et al. “Closed-loop geothermal energy recovery from deep high enthalpy systems.” Renewable Energy 177 (2021): 976-991. and CLGScode from Koenraad ref Beckers, Koenraad, et al. Tabulated Database of Closed-Loop Geothermal Systems Performance for Cloud-Based Technical and Economic Modeling of Heat Production and Electricity Generation. No. NREL/CP-5700-84979. National Renewable Energy Lab.(NREL), Golden, CO (United States), 2023.

class geophires_x.AGSWellBores.AGSWellBores(model: <module 'geophires_x.Model' from '/home/runner/work/GEOPHIRES-X/GEOPHIRES-X/src/geophires_x/Model.py'>)

AGSWellBores Child class of WellBores; it is the same, but has advanced AGS closed-loop functionality

Calculate(model: <module 'geophires_x.Model' from '/home/runner/work/GEOPHIRES-X/GEOPHIRES-X/src/geophires_x/Model.py'>) → None

The calculate function verifies, initializes, and extracts the values from the AGS model :param model: The container class of the application, giving access to everything else, including the logger :type model: Model :return: None

CalculateNonverticalPressureDrop(model: <module 'geophires_x.Model' from '/home/runner/work/GEOPHIRES-X/GEOPHIRES-X/src/geophires_x/Model.py'>, time_operation: float, time_max: float, al: float)

Calculate nonvertical pressure drops - it will vary as the temperature varies :param model: The container class of the application, giving access to everything else, including the logger :type model: Model :param time_operation: time of operation in years (0.01) :type time_operation: float :param time_max: maximum time of operation in years (100) - this is the time of the last year of operation :type time_max: float :param al: time step in years (0.01) - this is the time step of the simulation (not the time step of the CLGS model) :type al: float :return: NonverticalPressureDrop, friction - pressure drop and friction factor for the nonvertical section of the wellbore :rtype: tuple

calculatedrillinglengths(model) → tuple

returns the total length, vertical length, and horizontal lengths, depending on the configuration :param model: The container class of the application, giving access to everything else, including the logger :type model: Model :return: total length, vertical length, and horizontal lengths :rtype: tuple

getTandP(model: <module 'geophires_x.Model' from '/home/runner/work/GEOPHIRES-X/GEOPHIRES-X/src/geophires_x/Model.py'>) → None

The getTandP function reads and prepares Temperature and Pressure values from the CLGS database :param model: The container class of the application, giving access to everything else, including the logger :type model: Model :return: None

initialize(model: <module 'geophires_x.Model' from '/home/runner/work/GEOPHIRES-X/GEOPHIRES-X/src/geophires_x/Model.py'>) → None

The initialize function reads values and arrays to be in the format that CLGS model systems expects :param model: The container class of the application, giving access to everything else, including the logger :type model: Model :return: None

read_parameters(model: <module 'geophires_x.Model' from '/home/runner/work/GEOPHIRES-X/GEOPHIRES-X/src/geophires_x/Model.py'>) → None

The read_parameters function reads in the parameters from a dictionary and stores them in the parameters. It also handles special cases that need to be handled after a value has been read in and checked. If you choose to subclass this master class, you can also choose to override this method (or not), and if you do :param model: The container class of the application, giving access to everything else, including the logger :type model: Model :return: None

verify(model: <module 'geophires_x.Model' from '/home/runner/work/GEOPHIRES-X/GEOPHIRES-X/src/geophires_x/Model.py'>) → int

The verify function checks that all values provided are within the range expected by CLGS modeling system.

These values in within a smaller range than the value ranges available to GEOPHIRES-X

Parameters:

model (Model) – The container class of the application, giving access to everything else, including the logger

Returns:

0 if all OK, 1 if error.

Return type:

int

geophires_x.AGSWellBores.Chebyshev(self, a, b, n, yy, zz, yt, zt, ye, ze, alpha, sp, func)

Chebyshev approximation for numerical Laplace transformation integration from 1e-8 to 1e30 :param a: a :type a: float :param b: b :type b: float :param n: n :type n: int :param yy: y coordinate of the point source/sink :type yy: float :param zz: z coordinate of the point source/sink :type zz: float :param yt: y coordinate of the point source/sink :type yt: float :param zt: z coordinate of the point source/sink :type zt: float :param ye: y coordinate of the point source/sink :type ye: float :param ze: z coordinate of the point source/sink :type ze: float :param alpha: thermal diffusivity (m2/s) :type alpha: float :param sp: Laplace variable (1/s) :type sp: float :param func: function to be integrated (pointsource) :type func: function :return: y * d - dd + 0.5 * cint[0] :rtype: float

geophires_x.AGSWellBores.chebeve_pointsource(self, yy, zz, yt, zt, ye, ze, alpha, sp) → float

Chebyshev approximation for numerical Laplace transformation integration from 1e-8 to 1e30 :param yy: y coordinate of the point source/sink (m) (yy = 0) for coaxial wellbore and (yy = 0.078) for U-loop wellbore (m) :type yy: float :param zz: z coordinate of the point source/sink (m) (zz = 0) for coaxial wellbore and (zz = 0.078) for U-loop wellbore (m) :type zz: float :param yt: y coordinate of the point source/sink (m) (yt = 0) for coaxial wellbore and (yt = 0.078) for U-loop wellbore (m) :type yt: float :param zt: z coordinate of the point source/sink (m) (zt = 0) for coaxial wellbore and (zt = 0.078) for U-loop wellbore (m) :type zt: float :param ye: y coordinate of the point source/sink (m) (ye = 0) for coaxial wellbore and (ye = 0.078) for U-loop wellbore (m) :type ye: float :param ze: z coordinate of the point source/sink (m) (ze = 0) for coaxial wellbore and (ze = 0.078) for U-loop wellbore (m) :type ze: float :param alpha: thermal diffusivity (m2/s) :type alpha: float :param sp: Laplace variable (1/s) :type sp: float :return: ???? (need to check) :rtype: float

geophires_x.AGSWellBores.inverselaplace(cls: WellBores, NL, MM, pressure: PlainQuantity)

Numerical Laplace transformation algorithm :param NL: NL :type NL: int :param MM: MM :type MM: int :return: Toutlet :rtype: float

geophires_x.AGSWellBores.laplace_solution(cls: WellBores, sp, pressure: PlainQuantity) → float

Duhamel convolution method for closed-loop system :param sp: Laplace variable (1/s) :type sp: float :return: Toutletl :rtype: float :param pressure: Lithostatic pressure, per https://github.com/NREL/GEOPHIRES-X/issues/113#issuecomment-1941951134

geophires_x.AGSWellBores.pointsource(self, yy, zz, yt, zt, ye, ze, alpha, sp, t)

point source/sink solution functions :param yy: y coordinate of the point source/sink (m) (yy = 0) for coaxial wellbore and (yy = 0.078) for U-loop wellbore (m) :type yy: float :param zz: z coordinate of the point source/sink (m) (zz = 0) for coaxial wellbore and (zz = 0.078) for U-loop wellbore (m) :type zz: float :param yt: y coordinate of the point source/sink (m) (yt = 0) for coaxial wellbore and (yt = 0.078) for U-loop wellbore (m) :type yt: float :param zt: z coordinate of the point source/sink (m) (zt = 0) for coaxial wellbore and (zt = 0.078) for U-loop wellbore (m) :type zt: float :param ye: y coordinate of the point source/sink (m) (ye = 0) for coaxial wellbore and (ye = 0.078) for U-loop wellbore (m) :type ye: float :param ze: z coordinate of the point source/sink (m) (ze = 0) for coaxial wellbore and (ze = 0.078) for U-loop wellbore (m) :type ze: float :param alpha: thermal diffusivity (m2/s) :type alpha: float :param sp: Laplace variable (1/s) :type sp: float :param t: time (s) :type t: float :return: z :rtype: float

class geophires_x.SurfacePlantAGS.SurfacePlantAGS(model: <module 'geophires_x.Model' from '/home/runner/work/GEOPHIRES-X/GEOPHIRES-X/src/geophires_x/Model.py'>)

SurfacePlantAGS Child class of SurfacePlant; it is the same, but has advanced AGS closed-loop functionality

Calculate(model: <module 'geophires_x.Model' from '/home/runner/work/GEOPHIRES-X/GEOPHIRES-X/src/geophires_x/Model.py'>) → None

The calculate function verifies, initializes, and extracts the values from the AGS model :param model: The container class of the application, giving access to everything else, including the logger :type model: Model :return: None

calculateelectricityproduction(model)

The calculateelectricityproduction function calculates instantaneous exergy production, exergy extraction, and electricity generation (MW) and annual electricity generation [kWh]the electricity production of the AGS system. :param model: The container class of the application, giving access to everything else, including the logger :type model: Model :return: None

calculateheatproduction(model)

The calculateheatproduction function calculates the heat production of the AGS system. :param model: The container class of the application, giving access to everything else, including the logger :type model: Model :return: None

calculatepumpingpower(model)

The calculatepumpingpower function calculates the pumping power needed to pump the fluid from the injection well to the production well. :param model: The container class of the application, giving access to everything else, including the logger :type model: Model :return: None

initialize(model: <module 'geophires_x.Model' from '/home/runner/work/GEOPHIRES-X/GEOPHIRES-X/src/geophires_x/Model.py'>) → None

The initialize function reads values and arrays to be in the format that AGS model systems expects :param model: The container class of the application, giving access to everything else, including the logger :type model: Model :return: None

read_parameters(model: <module 'geophires_x.Model' from '/home/runner/work/GEOPHIRES-X/GEOPHIRES-X/src/geophires_x/Model.py'>) → None

The read_parameters function reads in the parameters from a dictionary and stores them in the parameters. It also handles special cases that need to be handled after a value has been read in and checked. If you choose to subclass this master class, you can also choose to override this method (or not), and if you do :param model: The container class of the application, giving access to everything else, including the logger :type model: Model :return: None

verify(model: <module 'geophires_x.Model' from '/home/runner/work/GEOPHIRES-X/GEOPHIRES-X/src/geophires_x/Model.py'>) → int

The validate function checks that all values provided are within the range expected by AGS modeling system. These values in within a smaller range than the value ranges available to GEOPHIRES-X :param model: The container class of the application, giving access to everything else, including the logger :type model: Model :return: 0 if all OK, 1 if error. :rtype: int

geophires_x.Economics.BuildPTCModel(plantlifetime: int, duration: int, ptc_price: float, ptc_inflation_adjusted: bool, inflation_rate: float) → list

BuildPricingModel builds the price model array for the project lifetime. It is used to calculate the revenue stream for the project. :param plantlifetime: The lifetime of the project in years :type plantlifetime: int :param duration: The duration of the PTC in years :type duration: int :param ptc_price: The PTC in $/kWh :type ptc_price: float :param ptc_inflation_adjusted: Is the PTC is inflation? :type ptc_inflation_adjusted: bool :param inflation_rate: The inflation rate in % :type inflation_rate: float :return: Price: The price model array for the PTC in $/kWh :rtype: list

geophires_x.Economics.BuildPricingModel(plantlifetime: int, StartPrice: float, EndPrice: float, EscalationStartYear: int, EscalationRate: float, PTCAddition: list) → list

BuildPricingModel builds the price model array for the project lifetime. It is used to calculate the revenue stream for the project. :param plantlifetime: The lifetime of the project in years :type plantlifetime: int :param StartPrice: The price in the first year of the project in $/kWh :type StartPrice: float :param EndPrice: The price in the last year of the project in $/kWh :type EndPrice: float :param EscalationStartYear: The year the price escalation starts in years (not including construction years) in years :type EscalationStartYear: int :param EscalationRate: The rate of price escalation in $/kWh/year :type EscalationRate: float :param PTCAddition: The PTC addition array for the project in $/kWh :type PTCAddition: list :return: Price: The price model array for the project in $/kWh :rtype: list

geophires_x.Economics.CalculateFinancialPerformance(plantlifetime: int, FixedInternalRate: float, TotalRevenue: list, TotalCummRevenue: list, CAPEX: float, OPEX: float)

CalculateFinancialPerformance calculates the financial performance of the project. It is used to calculate the financial performance of the project. It is used to calculate the revenue stream for the project. :param plantlifetime: The lifetime of the project in years :type plantlifetime: int :param FixedInternalRate: The fixed internal rate of return for the project in % :type FixedInternalRate: float :param TotalRevenue: The total revenue stream for the project in MUSD :type TotalRevenue: list :param TotalCummRevenue: The total cumulative revenue stream for the project in MUSD :type TotalCummRevenue: list :param CAPEX: The total capital cost of the project in MUSD :type CAPEX: float :param OPEX: The total annual operating cost of the project in MUSD :type OPEX: float :return: NPV: The net present value of the project in MUSD :rtype: float :return: IRR: The internal rate of return of the project in % :rtype: float :return: VIR: The value to investment ratio of the project in % :rtype: float :return: MOIC: The money on investment capital of the project in % :rtype: float :rtype: tuple

geophires_x.Economics.CalculateLCOELCOHLCOC(self, model: <module 'geophires_x.Model' from '/home/runner/work/GEOPHIRES-X/GEOPHIRES-X/src/geophires_x/Model.py'>) → tuple

CalculateLCOELCOH calculates the levelized cost of electricity and heat for the project. :param model: The model object :type model: Model :return: LCOE: The levelized cost of electricity and LCOH: The levelized cost of heat and LCOC: The levelized cost of cooling :rtype: tuple

geophires_x.Economics.CalculateRevenue(plantlifetime: int, ConstructionYears: int, Energy, Price)

CalculateRevenue calculates the revenue stream for the project. It is used to calculate the revenue stream for the project. # note this doesn’t account for OPEX :param plantlifetime: The lifetime of the project in years in years (not including construction years) in years :type plantlifetime: int :param ConstructionYears: The number of years of construction for the project in years :type ConstructionYears: int :param Energy: The energy production array for the project in kWh :type Energy: list :param Price: The price model array for the project in $/kWh :type Price: list :return: CashFlow: The annual cash flow for the project in MUSD and CummCashFlow: The cumulative cash flow for the project in MUSD :rtype: list

geophires_x.Economics.CalculateTotalRevenue(plantlifetime: int, ConstructionYears: int, CAPEX: float, OPEX: float, AnnualRev)

CalculateRevenue calculates the revenue stream for the project. It is used to calculate the revenue stream for the project. :param plantlifetime: The lifetime of the project in years in years (not including construction years) in years :type plantlifetime: int :param ConstructionYears: The number of years of construction for the project in years :type ConstructionYears: int :param CAPEX: The total capital cost of the project in MUSD :type CAPEX: float :param OPEX: The total annual operating cost of the project in MUSD :type OPEX: float :param AnnualRev: The annual revenue array for the project in MUSD :type AnnualRev: list :return: CashFlow: The annual cash flow for the project in MUSD and CummCashFlow: The cumulative cash flow for the project in MUSD :rtype: list

class geophires_x.Economics.Economics(model: <module 'geophires_x.Model' from '/home/runner/work/GEOPHIRES-X/GEOPHIRES-X/src/geophires_x/Model.py'>)

Class to support the default economic calculations in GEOPHIRES

Calculate(model: <module 'geophires_x.Model' from '/home/runner/work/GEOPHIRES-X/GEOPHIRES-X/src/geophires_x/Model.py'>) → None

The Calculate function is where all the calculations are done. This function can be called multiple times, and will only recalculate what has changed each time it is called. This is where all the calculations are made using all the values that have been set. If you subclass this class, you can choose to run these calculations before (or after) your calculations, but that assumes you have set all the values that are required for these calculations If you choose to subclass this master class, you can also choose to override this method (or not), and if you do, do it before or after you call you own version of this method. If you do, you can also choose to call this method from you class, which can effectively run the calculations of the superclass, making all thr values available to your methods. but you had better have set all the parameters! :param model: The container class of the application, giving access to everything else, including the logger :type model: Model :return: Nothing, but it does make calculations and set values in the model

read_parameters(model: <module 'geophires_x.Model' from '/home/runner/work/GEOPHIRES-X/GEOPHIRES-X/src/geophires_x/Model.py'>) → None

read_parameters read and update the Economics parameters and handle the special cases Deal with all the parameter values that the user has provided. They should really only provide values that they want to change from the default values, but they can provide a value that is already set because it is a default value set in __init__. It will ignore those. This also deals with all the special cases that need to be taken care of after a value has been read in and checked. If you choose to subclass this master class, you can also choose to override this method (or not), and if you do, do it before or after you call you own version of this method. If you do, you can also choose to call this method from you class, which can effectively modify all these superclass parameters in your class. :param model: The container class of the application, giving access to everything else, including the logger :type model: Model :return: None

geophires_x.Economics.calculate_cost_of_non_vertical_section(model: <module 'geophires_x.Model' from '/home/runner/work/GEOPHIRES-X/GEOPHIRES-X/src/geophires_x/Model.py'>, length_m: float, well_correlation: int, nonvertical_drilling_cost_per_m: float, num_nonvertical_sections: int, fixed_well_cost_name: str, NonverticalsCased: bool, well_cost_adjustment_factor: float) → float

calculate_cost_of_non_vertical_section calculates the cost of the non vertical section of the well. Assume that the cost per meter for drilling of the non-vertical section is the same as the vertical section. :param model: The model object :type model: :class:`~geophires :param length_m: The depth of the well in meters :type length_m: float :param well_correlation: The well cost correlation :type well_correlation: int :param nonvertical_drilling_cost_per_m: The nonvertical drilling cost per meter in $/m :type nonvertical_drilling_cost_per_m: float :param num_nonvertical_sections: The number of non vertical sections :type num_nonvertical_sections: int :param fixed_well_cost_name: The fixed well cost name :type fixed_well_cost_name: str :param NonverticalsCased: Are the nonverticals cased? :type NonverticalsCased: bool :param well_cost_adjustment_factor: The well cost adjustment factor :type well_cost_adjustment_factor: float :return: cost_of_one_well: The cost of the nonvertical section in MUSD :rtype: float

geophires_x.Economics.calculate_cost_of_one_vertical_well(model: <module 'geophires_x.Model' from '/home/runner/work/GEOPHIRES-X/GEOPHIRES-X/src/geophires_x/Model.py'>, depth_m: float, well_correlation: int, vertical_drilling_cost_per_m: float, fixed_well_cost_name: str, well_cost_adjustment_factor: float) → float

CalculateCostOfOneWell calculates the cost of one vertical well based on the depth of the well and the cost correlation. :param model: The model object :type model: :class:`~geophires :param depth_m: The depth of the well in meters :type depth_m: float :param well_correlation: The well correlation :type well_correlation: int :param vertical_drilling_cost_per_m: The vertical drilling cost per meter in $/m :type vertical_drilling_cost_per_m: float :param fixed_well_cost_name: The fixed well cost name :type fixed_well_cost_name: str :param well_cost_adjustment_factor: The well cost adjustment factor :type well_cost_adjustment_factor: float :return: cost_of_one_well: The cost of one well in MUSD :rtype: float

class geophires_x.AGSEconomics.AGSEconomics(model: <module 'geophires_x.Model' from '/home/runner/work/GEOPHIRES-X/GEOPHIRES-X/src/geophires_x/Model.py'>)

AGSEconomics Child class of Economics; it is the same, but has advanced AGS closed-loop functionality

Calculate(model: <module 'geophires_x.Model' from '/home/runner/work/GEOPHIRES-X/GEOPHIRES-X/src/geophires_x/Model.py'>) → None

The calculate function verifies, initializes, and calculate the values for the AGS model :param model: The container class of the application, giving access to everything else, including the logger :type model: Model :return: None

read_parameters(model: <module 'geophires_x.Model' from '/home/runner/work/GEOPHIRES-X/GEOPHIRES-X/src/geophires_x/Model.py'>) → None

The read_parameters function reads in the parameters from a dictionary and stores them in the parameters. It also handles special cases that need to be handled after a value has been read in and checked. If you choose to subclass this master class, you can also choose to override this method (or not), and if you do :param model: The container class of the application, giving access to everything else, including the logger :type model: Model :return: None

verify(model: <module 'geophires_x.Model' from '/home/runner/work/GEOPHIRES-X/GEOPHIRES-X/src/geophires_x/Model.py'>) → int

The validate function checks that all values provided are within the range expected by AGS modeling system. These values in within a smaller range than the value ranges available to GEOPHIRES-X :param model: The container class of the application, giving access to everything else, including the logger :type model: Model :return: 0 if all OK, 1 if error.

class geophires_x.SBTEconomics.SBTEconomics(model: <module 'geophires_x.Model' from '/home/runner/work/GEOPHIRES-X/GEOPHIRES-X/src/geophires_x/Model.py'>)

SBTEconomics Child class of Economics; it is the same, but has advanced SBT closed-loop functionality

Calculate(model: <module 'geophires_x.Model' from '/home/runner/work/GEOPHIRES-X/GEOPHIRES-X/src/geophires_x/Model.py'>) → None

The Calculate function is where all the calculations are done. This function can be called multiple times, and will only recalculate what has changed each time it is called. This is where all the calculations are made using all the values that have been set. If you subclass this class, you can choose to run these calculations before (or after) your calculations, but that assumes you have set all the values that are required for these calculations If you choose to subclass this master class, you can also choose to override this method (or not), and if you do, do it before or after you call you own version of this method. If you do, you can also choose to call this method from you class, which can effectively run the calculations of the superclass, making all thr values available to your methods. but you had better have set all the parameters! :param model: The container class of the application, giving access to everything else, including the logger :type model: Model :return: Nothing, but it does make calculations and set values in the model

MyPath

self.O_and_M_cost_plant = self.ParameterDict[self.O_and_M_cost_plant.Name] = floatParameter(

“Operation & Maintenance Cost of Surface Plant”, DefaultValue=0.015, Min=0.0, Max=0.2, UnitType=Units.PERCENT, PreferredUnits=PercentUnit.TENTH, CurrentUnits=PercentUnit.TENTH, Required=True, ErrMessage=”assume default Operation & Maintenance cost of surface plant expressed as fraction of total surface plant capital cost (0.015)”

) self.Direct_use_heat_cost_per_kWth = self.ParameterDict[

self.Direct_use_heat_cost_per_kWth.Name] = floatParameter( “Capital Cost for Surface Plant for Direct-use System”, DefaultValue=100.0, Min=0.0, Max=10000.0, UnitType=Units.ENERGYCOST, PreferredUnits=EnergyCostUnit.DOLLARSPERKW, CurrentUnits=EnergyCostUnit.DOLLARSPERKW, Required=False, ErrMessage=”assume default Capital cost for surface plant for direct-use system (100 $/kWth)”

) self.Power_plant_cost_per_kWe = self.ParameterDict[self.Power_plant_cost_per_kWe.Name] = floatParameter(

“Capital Cost for Power Plant for Electricity Generation”, DefaultValue=3000.0, Min=0.0, Max=10000.0, UnitType=Units.ENERGYCOST, PreferredUnits=EnergyCostUnit.DOLLARSPERKW, CurrentUnits=EnergyCostUnit.DOLLARSPERKW, Required=True, ErrMessage=”assume default Power plant capital cost per kWe (3000 USD/kWe)”

)

# results are stored here and in the parent ProducedTemperature array

read_parameters(model: <module 'geophires_x.Model' from '/home/runner/work/GEOPHIRES-X/GEOPHIRES-X/src/geophires_x/Model.py'>) → None

The read_parameters function reads in the parameters from a dictionary and stores them in the parameters. It also handles special cases that need to be handled after a value has been read in and checked. If you choose to subclass this master class, you can also choose to override this method (or not), and if you do :param model: The container class of the application, giving access to everything else, including the logger :type model: Model :return: None

geophires_x.SBTEconomics.calculate_cost_of_lateral_section(model: <module 'geophires_x.Model' from '/home/runner/work/GEOPHIRES-X/GEOPHIRES-X/src/geophires_x/Model.py'>, length_m: float, well_correlation: int, lateral_drilling_cost_per_m: float, num_lateral_sections: int, fixed_well_cost_name: str, NonverticalsCased: bool, well_cost_adjustment_factor: float) → float

calculate_cost_of_lateral_section calculates the cost of the lateral section of the well. Assume that the cost per meter for drilling of the lateral section is the same as the vertical section, except the casing cost is half, if it is uncased. :param model: The model object :type model: :class:`~geophires :param length_m: The depth of the well in meters :type length_m: float :param well_correlation: The well cost correlation :type well_correlation: int :param lateral_drilling_cost_per_m: The lateral drilling cost per meter in $/m :type lateral_drilling_cost_per_m: float :param num_lateral_sections: The number of lateral sections :type num_lateral_sections: int :param fixed_well_cost_name: The fixed well cost name :type fixed_well_cost_name: str :param NonverticalsCased: Are the laterals cased? :type NonverticalsCased: bool :param well_cost_adjustment_factor: The well cost adjustment factor :type well_cost_adjustment_factor: float :return: cost_of_one_well: The cost of the lateral section in MUSD :rtype: float

class geophires_x.SUTRAEconomics.SUTRAEconomics(model: <module 'geophires_x.Model' from '/home/runner/work/GEOPHIRES-X/GEOPHIRES-X/src/geophires_x/Model.py'>)

Class to support the default economic calculations in GEOPHIRES

Calculate(model: <module 'geophires_x.Model' from '/home/runner/work/GEOPHIRES-X/GEOPHIRES-X/src/geophires_x/Model.py'>) → None

The Calculate function is where all the calculations are done. This function can be called multiple times, and will only recalculate what has changed each time it is called. :param model: The container class of the application, giving access to everything else, including the logger :type model: Model :return: Nothing, but it does make calculations and set values in the model

read_parameters(model: <module 'geophires_x.Model' from '/home/runner/work/GEOPHIRES-X/GEOPHIRES-X/src/geophires_x/Model.py'>) → None

read_parameters read and update the Economics parameters and handle the special cases that need to be taken care of after a value has been read in and checked. This is called from the main Model class. It is not called from the __init__ function because the user may not want to read in the parameters from the input file, but may want to set them in the user interface. :param model: The container class of the application, giving access to everything else, including the logger :type model: Model :return: Nothing, but it does make calculations and set values in the model

class geophires_x.EconomicsCCUS.EconomicsCCUS(model)

Calculate(model) → None

The Calculate function is where all the calculations are done. This function can be called multiple times, and will only recalculate what has changed each time it is called. This is where all the calculations are made using all the values that have been set. If you subclass this class, you can choose to run these calculations before (or after) your calculations, but that assumes you have set all the values that are required for these calculations If you choose to subclass this master class, you can also choose to override this method (or not), and if you do, do it before or after you call you own version of this method. If you do, you can also choose to call this method from you class, which can effectively run the calculations of the superclass, making all thr values available to your methods. but you had better have set all the parameters! :param model: The container class of the application, giving access to everything else, including the logger :type model: Model :return: Nothing, but it does make calculations and set values in the model

read_parameters(model) → None

The read_parameters function reads in the parameters from a dictionary and stores them in the parameters. It also handles special cases that need to be handled after a value has been read in and checked. If you choose to subclass this master class, you can also choose to override this method (or not), and if you do :param model: The container class of the application, giving access to everything else, including the logger :type model: Model :return: None

class geophires_x.EconomicsAddOns.EconomicsAddOns(model: <module 'geophires_x.Model' from '/home/runner/work/GEOPHIRES-X/GEOPHIRES-X/src/geophires_x/Model.py'>)

Calculate(model: <module 'geophires_x.Model' from '/home/runner/work/GEOPHIRES-X/GEOPHIRES-X/src/geophires_x/Model.py'>) → None

The Calculate function is where all the calculations are done. This function can be called multiple times, and will only recalculate what has changed each time it is called. This is where all the calculations are made using all the values that have been set. If you subclass this class, you can choose to run these calculations before (or after) your calculations, but that assumes you have set all the values that are required for these calculations If you choose to subclass this master class, you can also choose to override this method (or not), and if you do, do it before or after you call you own version of this method. If you do, you can also choose to call this method from you class, which can effectively run the calculations of the superclass, making all thr values available to your methods. but you had better have set all the parameters! :param model: The container class of the application, giving access to everything else, including the logger :type model: Model :return: Nothing, but it does make calculations and set values in the model

read_parameters(model: <module 'geophires_x.Model' from '/home/runner/work/GEOPHIRES-X/GEOPHIRES-X/src/geophires_x/Model.py'>) → None

The read_parameters function is called by the model to read in all the parameters that are used for this extension. The user can create as many or as few parameters as needed. Each parameter is created by a call to the InputParameter class, which is defined below, and then stored in a dictionary with a name assigned to :param model: The container class of the application, giving access to everything else, including the logger :type model: Model :return: None