Lixiviación

En este capítulo, al igual que el anterior, las funciones JavaScript, tienen los mismos nombres que las funciones HP equivalentes.

Lixiviación en una etapa de equilibrio

La función JavaScript equivalente a la función LIX1 de la calculadora HP, es:

function LIX1({Ny, yAA, Nx, xAA}={}) { const xB = Ny.map(n=>n/(1+n)); const xA = yAA.map((y,i)=>y/(1+Ny[i])); const yB = Nx.map(n=>n/(1+n)); const yA = xAA.map((x,i)=>x/(1+Nx[i])); return {xB, xA, yB, yA} }

Para resolver, con esta función, el ejemplo 7.2.1 del texto, se procede de la siguiente forma:

Primero se guardan los datos conocidos:

L0=100; xA0=0.2, xB0=0.8, V0=100; yA0=0; yB0=0; Ny = [1.5, 1.5]; yAA = [0.1, 0.9]; Nx = [0, 0]; xAA = [0.1, 0.9];

Primero se calculan las fracciones en peso estándar, en base a las fracciones en base a la solución sin sólido inerte, llamando a la función LIX1:

var {xB, xA, yB, yA} = LIX1({Ny, yAA, Nx, xAA});

Con las fracciones en peso estándar se construyen las funciones de equilibrio:

FXAXB = [xA, xB].inLin1; FXAYA = [xA, yA].inLin1; FXAYB = [xA, yB].inLin1;

Entonces se llama a la función ELL1, para calcular las masas y composiciones finales:

var {L1, xA1, xB1, V1, yA1, yB1} = ELL1({L0, xA0, xB0, V0, yA0, yB0, FXAXB, FXAYA, FXAYB}); [L1, xA1, xB1, V1, yA1, yB1]

En consecuencia, el porcentaje de aceite extraído es:

V1*yA1/(L0*xA0)*100

Lixiviación en múltiples etapas en contracorriente

La función JavaScript equivalente a la función ELLN2 de la calculadora HP, es:

function ELLN2({L0, xA0, xB0, LNxAN, V0, yA0, yB0, FXAXB, FYAYB}={}) { const M = L0+V0; const CA0 = L0*xA0+V0*yA0; const CB0 = L0*xB0+V0*yB0; let yB1, LN, V1, xAN, xBN; const fYA1 = yA1 => { yB1 = FYAYB(yA1); V1 = (CA0-LNxAN)/yA1; LN = M-V1; xAN = LNxAN/LN; xBN = FXAXB(xAN); return LN*xBN+V1*yB1-CB0; }; const yA1 = fYA1.newton({xi:CA0/M}); return {LN, xAN, xBN, V1, yA1, yB1}; }

Para resolver el ejemplo 7.3.1 con esta función, se procede de la siguiente forma:

Primero se guardan los datos conocidos:

L0=2850; xA0=800/L0; xB0=2000/L0; LNxAN=120; V0=1330; yA0=20/V0; yB0=0;
Ny = [2.00,1.98,1.94,1.89,1.82,1.75,1.68,1.61]; Nx = [].zeros(8); yAA = [0.0,0.1,0.2,0.3,0.4,0.5,0.6,0.7]; xAA = [0.0,0.1,0.2,0.3,0.4,0.5,0.6,0.7];

Con las fracciones en base a la solución sin sólido inerte, se calculan, empleando LIX1, las fracciones en peso estándar y con las mismas se construyen las funciones de equilibrio:

var {xB, xA, yB, yA} = LIX1({Ny, yAA, Nx, xAA});
FXAXB = [xA, xB].inLin1; FYAYB = [yA, yB].inLin1; FYAXA = [yA, xA].inLin1; FYAXB = [yA, xB].inLin1;

Entonces, se calculan los flujos y composiciones faltantes llamando a ELLN2:

var {LN, xAN, xBN, V1, yA1, yB1} = ELLN2({L0, xA0, xB0, LNxAN, V0, yA0, yB0, FXAXB, FYAYB}); [LN, xAN, xBN, V1, yA1, yB1]

Y con todos los flujos y composiciones conocidos, se calcula el número de etapas de equilibrio necesarias, llamando a ELLN:

ELLN({L0, xA0, xB0, xAN, V1, yA1, yB1, FYAYB, FYAXA, FYAXB})

Referencia de las funciones disponibles

La referencia detallada de las funciones presentadas en este y en los anteriores capítulos (incluido el código de los programas elaborados), está disponible en el siguiente enlace (donde se irán incorporando otras funciones a medida que se las presente y utilice):

Referencia funciones disponibles