Extracción líquido - líquido

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

Extracción en una etapa de equilibrio

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

function ELL1({L0, xA0, xB0, V0, yA0, yB0, FXAXB, FXAYA, FXAYB}={}) { const M = L0+V0; const CA0 = L0*xA0+V0*yA0; const CB0 = L0*xB0+V0*yB0; let xB1, yA1, yB1, L1, V1; const fXA1 = xA1 => { xB1 = FXAXB(xA1); yA1 = FXAYA(xA1); yB1 = FXAYB(xA1); L1 = (CA0*yB1-CB0*yA1)/(xA1*yB1-xB1*yA1); V1 = (CA0-L1*xA1)/yA1; return L1+V1-M; }; const xA1 = fXA1.newton({xi:CA0/M/2, err:9}); return {L1, xA1, xB1, V1, yA1, yB1}; }

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

Primero se guardan los datos conocidos y se construyen las funciones de interpolación requeridas:

L0=70; xA0=10/70; xB0=60/70; V0=30; yA0=0; yB0=0;
xA = [0.,.69,1.41,2.89,6.42,13.3,25.5,36.7,44.3,46.4].div(100); xB = [98.8,98.1,97.1,95.5,91.7,84.4,71.1,58.9,45.1,37.1].div(100); yA = [0.,.18,.37,.79,1.93,4.82,11.4,21.6,31.1,36.2].div(100); yB = [.6,.5,.7,.8,1.,1.9,3.9,6.9,10.8,15.1].div(100);
FXAXB = [xA,xB].inLin1; FXAYA = [xA,yA].inLin1; FXAYB = [xA,yB].inLin1;

Entonces, con los datos conocidos, se llama a la función ELL1, con lo que se obtienen 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 ácido acético extraído es:

V1*yA1/10*100

Para el inciso (b), simplemente cambia la masa de éter etílico (V0) de 30 a 100 kg. Entonces, simplemente modificando ese valor, se obtienen las nuevas masas y flujos de salida:

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

Siendo el nuevo porcentaje de ácido acético extraído:

(V1*yA1/10*100).round(2)

Extracción líquido - líquido en múltiples etapas de equilibrio

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

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

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

Primero se guardan los datos conocidos y se construyen las funciones de interpolación requeridas:

L0=200; xA0=0.3, xB0=0.7; xAN=0.04, V0=600; yA0=0; yB0=0;
xA = [0.,.69,1.41,2.89,6.42,13.3,25.5,36.7,44.3,46.4].div(100); xB = [98.8,98.1,97.1,95.5,91.7,84.4,71.1,58.9,45.1,37.1].div(100); yA = [0.,.18,.37,.79,1.93,4.82,11.4,21.6,31.1,36.2].div(100); yB = [.6,.5,.7,.8,1.,1.9,3.9,6.9,10.8,15.1].div(100); FXAXB = [xA,xB].inLin1; FYAYB = [yA,yB].inLin1;

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

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

Siendo el porcentaje de ácido acético extraído:

(V1*yA1/(L0*xA0)*100).round(2)

Cálculo del número de etapas teóricas

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

function ELLN({L0, xA0, xB0, xAN, V1, yA1, yB1, FYAYB, FYAXA, FYAXB}={}) { const DM = L0-V1; const DA = L0*xA0-V1*yA1; const DB = L0*xB0-V1*yB1; let yAI = yA1, xAI, xBI, N=0; var fYAJ = yAJ => { const yBJ = FYAYB(yAJ); const LI = (DA*yBJ-DB*yAJ)/(xAI*yBJ-xBI*yAJ); const VJ = (LI*xAI-DA)/yAJ; return LI-VJ-DM } for(;;) { xAI = FYAXA(yAI); xBI = FYAXB(yAI); if (xAI<=xAN) break; yAI = fYAJ.newton({xi:yAI*0.5}); xA0 = xAI; N++ } return N+(xAN-xA0)/(xAI-xA0); }

Así, el primero de los ejemplso de la sección 6.3.2.1 del texto (para los mismos datos del ejemplo 6.3.1.1) se resuelve de la siguiente forma:

De los resultados obtenidos al resolver el ejemplo 6.3.1.1 y con los datos de equilibrio, se tienen todos los datos necesarios para calcular el número de etapas.

[L0, xA0, xB0, xAN, V1, yA1, yB1]
FYAXA = [yA, xA].inLin1; FYAXB = [yA, xB].inLin1;
ELLN({L0, xA0, xB0, xAN, V1, yA1, yB1, FYAYB, FYAXA, FYAXB})

En el segundo ejemplo de la sección 6.3.2.1, cambian los flujos de éter isopropílico puro (V0), el de la solución (L0) y se fija la fracción molar final de ácido acético en 10% (xAN).

Actualizando estos datos y llamando primero a la función ELLN1 se obtienen los flujos y composiciones finales faltantes:

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

Entonces, con los valores calculados, se llama a ELLN para calcular el número de etapas necesarias:

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

Para el tercer ejemplo de la sección 6.3.2.1, los datos conocidos son:

L0=100; xA0=0.01; xB0=0.99; xAN=0.001; V0=200; yA0=0.0005; yB0=0;

Los datos de equilibrio disponibles corresponden únicamente a xA y yA (por lo que se tratan de líquidos completamente inmiscibles), los valores de xB son la diferencia entre 1 y los valores de xA (porque sólo existen los compuestos A y B en esa fase), mientras que los valores de yB son cero (porque en esa fase sólo existen los compuestos A y C).

xA = [0.00101,0.00246,0.00500,0.00746,0.00988,0.02020]; xB = [].const(6,1).sub(xA); print(xB); yA = [0.000806,0.001959,0.004540,0.006820,0.009040,0.018500]; yB = [].zeros(6); print(yB); FXAXB = [xA, xB].inLin1; FYAYB = [yA, yB].inLin1; FYAXA = [yA, xA].inLin1; FYAXB = [yA, xB].inLin1;

Primero se calculan los flujos y composiciones faltantes llamando a ELLN1

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

Entonces se calcula el número de etapas necesarias llamando a ELLN:

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

Flujo mínimo de la fase extracto

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

function ELMIN({L0, xA0, xB0, xAN, yA0, yB0, FXAXB, FXAYA, FXAYB}={}) { const xBN = FXAXB(xAN); const yA1 = FXAYA(xA0); const yB1 = FXAYB(xA0); const Vmin = ((yA1-xAN)*L0*(xB0-xBN)-(yB1-xBN)*L0*(xA0-xAN))/ ((yA1-xAN)*(xBN-yB0)-(yB1-xBN)*(xAN-yA0)); return {Vmin}; }

Así, para resolver el ejemplo de la sección 6.3.2.2 del texto, correspondiente a los datos del tercer ejemplo de la sección 6.3.2.1 (que al ser el último ejemplo ejecutado se encuentra en memoria), se construyen las funciones de equilibrio faltantes y llama a la función ELMIN, para calcular el flujo mínimo de extracto:

FXAYA = [xA, yA].inLin1; FXAYB = [xA, yB].inLin1;
ELMIN({L0, xA0, xB0, xAN, yA0, yB0, FXAXB, FXAYA, FXAYB})

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