BRIGITTE CAROLINA PARRAGA CEDEÑO

Taller #2

Ejercicio 1: Cálculo del rendimiento de una bomba de petróleo (1p)

#Crear una clase llamada BombaPetroleo que tenga dos atributos: caudal_litros y potencia_kw. Agregar un método calcular_rendimiento que
calcule el rendimiento de la bomba de petróleo, utilizando la fórmula:
rendimiento = (caudal_litros * 1000) / (potencia_kw * 3600)
class BombaPetroleo:
def __init__(self, caudal_litros, potencia_kw):
self.caudal_litros = caudal_litros
self.potencia_kw = potencia_kw

def calcular_rendimiento(self):
rendimiento = (self.caudal_litros * 1000) / (self.potencia_kw * 3600)
return rendimiento
# Crear un objeto de la clase BombaPetroleo
bomba1 = BombaPetroleo(200, 50)

# Calcular el rendimiento de la bomba1

rendimiento_bomba1 = bomba1.calcular_rendimiento()
print("Rendimiento de la bomba1:", rendimiento_bomba1)
BRIGITTE CAROLINA PARRAGA CEDEÑO
Taller #2
BRIGITTE CAROLINA PARRAGA CEDEÑO
Taller #2

Ejercicio 2: Cálculo del área de un reservorio de petróleo (1p)

área = 2 * pi * radio_metros * (radio_metros + altura_metros)

import math

class ReservorioPetroleo:
def __init__(self, radio_metros, altura_metros):
self.radio_metros = radio_metros
self.altura_metros = altura_metros

def calcular_area(self):
area = 2 * math.pi * self.radio_metros * (self.radio_metros + self.altura_metros)
return area
# Crear una instancia de ReservorioPetroleo
reservorio = ReservorioPetroleo(10, 5)

# Calcular el área del reservorio

area_reservorio = reservorio.calcular_area()

# Imprimir el resultado
print("El área del reservorio de petróleo es:", area_reservorio)
BRIGITTE CAROLINA PARRAGA CEDEÑO
Taller #2
BRIGITTE CAROLINA PARRAGA CEDEÑO
Taller #2

#Crear una clase llamada TuberiaPetroleo que tenga tres atributos: diametro_metros, longitud_metros y presion_bar.
# Agregar un método calcular_flujo_petroleo que calcule el flujo de petróleo en la tubería, utilizando la fórmula:
flujo = (math.pi * (diametro_metros**2) * math.sqrt(2 * presion_bar)) / (8.28 * longitud_metros)
Use import math al inicio del codigo

import math

class TuberiaPetroleo:
def __init__(self, diametro_metros, longitud_metros, presion_bar):
self.diametro_metros = diametro_metros
self.longitud_metros = longitud_metros
self.presion_bar = presion_bar

def calcular_flujo_petroleo(self):
flujo = (math.pi * (self.diametro_metros**2) * math.sqrt(2 * self.presion_bar)) / (8.28 * self.longitud_metros)
return flujo
# Crear una instancia de TuberiaPetroleo
tuberia = TuberiaPetroleo(0.5, 100, 10)

# Calcular el flujo de petróleo en la tubería

flujo_petroleo = tuberia.calcular_flujo_petroleo()

# Imprimir el resultado
print("El flujo de petróleo en la tubería es:", flujo_petroleo)
BRIGITTE CAROLINA PARRAGA CEDEÑO
Taller #2

Ejercicio 4: Cálculo de la presión en un yacimiento de petróleo (1p)

#Crear una clase llamada YacimientoPetroleo que tenga tres atributos: porosidad, permeabilidad y presion_inicial.
# Agregar un método calcular_presion que calcule la presión actual en el yacimiento de petróleo, utilizando la ecuación de difusividad del
gas:
presion = presion_inicial * math.exp((-porosidad * permeabilidad * tiempo) / volumen_yacimiento)
Use import math al inicio del código

import math

class YacimientoPetroleo:
def __init__(self, porosidad, permeabilidad, presion_inicial):
self.porosidad = porosidad
self.permeabilidad = permeabilidad
self.presion_inicial = presion_inicial

def calcular_presion(self, tiempo, volumen_yacimiento):

presion = self.presion_inicial * math.exp((-self.porosidad * self.permeabilidad * tiempo) / volumen_yacimiento)
return presion
# Crear una instancia de YacimientoPetroleo
yacimiento = YacimientoPetroleo(0.3, 100, 100)

# Calcular la presión actual en el yacimiento

tiempo = 10
volumen_yacimiento = 500
presion_actual = yacimiento.calcular_presion(tiempo, volumen_yacimiento)

# Imprimir el resultado
print("La presión actual en el yacimiento de petróleo es:", presion_actual)
BRIGITTE CAROLINA PARRAGA CEDEÑO
Taller #2
BRIGITTE CAROLINA PARRAGA CEDEÑO
Taller #2

Ejercicio 5: Simulación de una bomba de petróleo (2p)

#Crear una clase llamada BombaPetroleo que represente una bomba de extracción de petróleo. Esta clase debe tener atributos como potencia,
presion_salida, caudal. Además, agrega métodos para simular acciones como el encendido de la bomba, el cálculo del rendimiento
(caudal/potencia) y la regulación de la presión (cambiar de presión).
class BombaPetroleo:
def __init__(self, potencia, presion_salida, caudal):
self.potencia = potencia
self.presion_salida = presion_salida
self.caudal = caudal
self.encendida = False

def encender(self):
self.encendida = True
print("La bomba de extracción de petróleo ha sido encendida.")

def apagar(self):
self.encendida = False
print("La bomba de extracción de petróleo ha sido apagada.")

def calcular_rendimiento(self):
rendimiento = self.caudal / self.potencia
return rendimiento

def regular_presion(self, nueva_presion):

self.presion_salida = nueva_presion
print(f"La presión de salida de la bomba ha sido regulada a {nueva_presion}.")

# Ejemplo de uso de la clase BombaPetroleo

bomba = BombaPetroleo(500, 50, 1000)

bomba.encender()
rendimiento = bomba.calcular_rendimiento()
print("Rendimiento de la bomba:", rendimiento)
BRIGITTE CAROLINA PARRAGA CEDEÑO
Taller #2

bomba.regular_presion(60)

bomba.apagar()
BRIGITTE CAROLINA PARRAGA CEDEÑO
Taller #2

#Crear una clase llamada RefineriaPetroleo que represente una refinería de petróleo. Esta clase debe tener atributos como nombre,
# capacidad, tipo_procesamiento, etc. Además, agrega métodos para simular acciones como la recepción de crudo, el procesamiento del
petróleo,
# y la producción de productos refinados. "Gasolina", "Diesel", "Queroseno”
# (En el procesamiento nos dará de manera interna esos tres productos,
# y en la producción es cuando se harán visibles al usuario)

class RefineriaPetroleo:
def __init__(self, nombre, capacidad, tipo_procesamiento):
self.nombre = nombre
self.capacidad = capacidad
self.tipo_procesamiento = tipo_procesamiento
self.crudo_recibido = 0
self.gasolina_producida = 0
self.diesel_producido = 0
self.queroseno_producido = 0

def recibir_crudo(self, cantidad):

self.crudo_recibido += cantidad
print(f"La refinería {self.nombre} ha recibido {cantidad} barriles de crudo.")

def procesar_petroleo(self):
if self.crudo_recibido > 0:
print(f"Procesando {self.crudo_recibido} barriles de crudo...")
self.gasolina_producida = self.crudo_recibido * self.tipo_procesamiento["gasolina"]
self.diesel_producido = self.crudo_recibido * self.tipo_procesamiento["diesel"]
self.queroseno_producido = self.crudo_recibido * self.tipo_procesamiento["queroseno"]
print("Procesamiento completado.")
else:
print("No hay crudo para procesar.")

def producir_gasolina(self):
print(f"Produciendo gasolina: {self.gasolina_producida} barriles.")
BRIGITTE CAROLINA PARRAGA CEDEÑO
Taller #2

def producir_diesel(self):
print(f"Produciendo diesel: {self.diesel_producido} barriles.")

def producir_queroseno(self):
print(f"Produciendo queroseno: {self.queroseno_producido} barriles.")

# Ejemplo de uso de la clase RefineriaPetroleo

refineria = RefineriaPetroleo("Refineria1", 1000, {"gasolina": 0.3, "diesel": 0.5, "queroseno": 0.2})

refineria.recibir_crudo(500)
refineria.procesar_petroleo()

refineria.producir_gasolina()
refineria.producir_diesel()
refineria.producir_queroseno()
BRIGITTE CAROLINA PARRAGA CEDEÑO
Taller #2
BRIGITTE CAROLINA PARRAGA CEDEÑO
Taller #2

Ejercicio 7: Simulación de un yacimiento de petróleo con producción declinante (2p)

#Crear una clase llamada YacimientoPetroleo que simule la producción de un yacimiento de petróleo con producción declinante.
# Esta clase debe tener atributos como nombre, reservas_iniciales, presion_inicial, factor_declive, etc.
# Agrega métodos para simular la extracción de petróleo y el cálculo de la producción diaria considerando el declive del yacimiento.
class YacimientoPetroleo:
def __init__(self, nombre, reservas_iniciales, presion_inicial, factor_declive):
self.nombre = nombre
self.reservas_iniciales = reservas_iniciales
self.presion_inicial = presion_inicial
self.factor_declive = factor_declive
self.presion_actual = presion_inicial
self.reservas_actuales = reservas_iniciales

def extraer_petroleo(self, cantidad):

if self.reservas_actuales > 0:
cantidad_extraida = min(cantidad, self.reservas_actuales)
self.reservas_actuales -= cantidad_extraida
print(f"Se ha extraído {cantidad_extraida} barriles de petróleo del yacimiento {self.nombre}.")
else:
print(f"No quedan reservas de petróleo en el yacimiento {self.nombre}.")

def calcular_produccion_diaria(self):
produccion_diaria = self.presion_actual * self.reservas_actuales
self.presion_actual *= self.factor_declive
return produccion_diaria

# Ejemplo de uso de la clase YacimientoPetroleo

yacimiento = YacimientoPetroleo("Yacimiento1", 1000, 50, 0.9)

for i in range(5):
produccion = yacimiento.calcular_produccion_diaria()
BRIGITTE CAROLINA PARRAGA CEDEÑO
Taller #2
print(f"Producción diaria del día {i + 1}: {produccion} barriles.")

yacimiento.extraer_petroleo(300)

for i in range(5):
produccion = yacimiento.calcular_produccion_diaria()
print(f"Producción diaria del día {i + 6}: {produccion} barriles.")
BRIGITTE CAROLINA PARRAGA CEDEÑO
Taller #2

Ejercicio 8: Simulación de un tanque de almacenamiento de petróleo (2p)

#Crear una clase llamada TanqueAlmacenamiento que simule un tanque de almacenamiento de petróleo.
# Esta clase debe tener atributos como capacidad_maxima, cantidad_actual, temperatura, etc.
# Agrega métodos para simular acciones como el llenado del tanque, el vaciado del tanque y
# la verificación del nivel de almacenamiento (cantidad_actual / capacidad_maxima * 100).
class TanqueAlmacenamiento:
def __init__(self, capacidad_maxima, temperatura):
self.capacidad_maxima = capacidad_maxima
self.cantidad_actual = 0
self.temperatura = temperatura

def llenar_tanque(self, cantidad):

espacio_disponible = self.capacidad_maxima - self.cantidad_actual
cantidad_almacenada = min(cantidad, espacio_disponible)
self.cantidad_actual += cantidad_almacenada
print(f"Se han almacenado {cantidad_almacenada} barriles en el tanque.")

def vaciar_tanque(self, cantidad):

cantidad_extraida = min(cantidad, self.cantidad_actual)
self.cantidad_actual -= cantidad_extraida
print(f"Se han extraído {cantidad_extraida} barriles del tanque.")

def verificar_nivel_almacenamiento(self):
nivel_almacenamiento = (self.cantidad_actual / self.capacidad_maxima) * 100
return nivel_almacenamiento
BRIGITTE CAROLINA PARRAGA CEDEÑO
Taller #2

# Ejemplo de uso de la clase TanqueAlmacenamiento

tanque = TanqueAlmacenamiento(1000, 25)

tanque.llenar_tanque(500)
nivel_almacenamiento = tanque.verificar_nivel_almacenamiento()
print(f"Nivel de almacenamiento: {nivel_almacenamiento}%")

tanque.vaciar_tanque(200)
nivel_almacenamiento = tanque.verificar_nivel_almacenamiento()
print(f"Nivel de almacenamiento: {nivel_almacenamiento}%")
BRIGITTE CAROLINA PARRAGA CEDEÑO
Taller #2

Ejercicio 9: Simulación de una tubería de transporte de petróleo (2p)

#Crear una clase llamada TuberiaTransporte que simule una tubería de transporte de petróleo.
# Esta clase debe tener atributos como longitud, diametro, caudal, etc.
# Agrega métodos para simular acciones como el cálculo de la velocidad del flujo (v =Q/A*1000)
class TuberiaTransporte:
def __init__(self, longitud, diametro, caudal):
self.longitud = longitud
self.diametro = diametro
self.caudal = caudal

def calcular_velocidad_flujo(self):
area = (3.14159 * (self.diametro ** 2)) / 4
velocidad = (self.caudal / area) * 1000
return velocidad

def realizar_mantenimiento(self):
# Simulación del mantenimiento de la tubería
print("Realizando mantenimiento en la tubería de transporte...")

# Ejemplo de uso de la clase TuberiaTransporte

tuberia = TuberiaTransporte(1000, 0.5, 500)

velocidad_flujo = tuberia.calcular_velocidad_flujo()
print(f"Velocidad del flujo en la tubería: {velocidad_flujo} m/s")

tuberia.realizar_mantenimiento()
BRIGITTE CAROLINA PARRAGA CEDEÑO
Taller #2