void ariaDecryptBlock(AriaContext *context, const uint8_t *input, uint8_t *output)
{
uint32_t *dk;
uint32_t p[4];
uint32_t q[4];
//Copy the ciphertext to the buffer
memcpy(p, input, ARIA_BLOCK_SIZE);
//Point to the decryption round keys
dk = context->dk;
//Apply 11 rounds
OF(p, dk + 0);
EF(p, dk + 4);
OF(p, dk + 8);
EF(p, dk + 12);
OF(p, dk + 16);
EF(p, dk + 20);
OF(p, dk + 24);
EF(p, dk + 28);
OF(p, dk + 32);
EF(p, dk + 36);
OF(p, dk + 40);
//128-bit master keys require a total of 12 rounds
if(context->nr == 12)
{
XOR128(p, dk + 44);
SL2(q, p);
XOR128(q, dk + 48);
}
//192-bit master keys require a total of 14 rounds
else if(context->nr == 14)
{
EF(p, dk + 44);
OF(p, dk + 48);
XOR128(p, dk + 52);
SL2(q, p);
XOR128(q, dk + 56);
}
//256-bit master keys require a total of 16 rounds
else
{
EF(p, dk + 44);
OF(p, dk + 48);
EF(p, dk + 52);
OF(p, dk + 56);
XOR128(p, dk + 60);
SL2(q, p);
XOR128(q, dk + 64);
}
//The resulting value is the plaintext
memcpy(output, q, ARIA_BLOCK_SIZE);
}
static int
ematch(void *efh, void *fh)
{
FLOWDESC *x = F(fh);
EFLOWDESC *ex = EF(efh);
return (
N32(ex->src_ip) == N32(x->src_ip) &&
N32(ex->dst_ip) == N32(x->dst_ip) &&
N16(ex->src_port) == N16(x->src_port) &&
N16(ex->dst_port) == N16(x->dst_port) &&
ex->proto == x->proto &&
!(ex->full)
);
}
static int
ematch(void *self, void *efh, void *fh)
{
pkt_t* pkt;
int ret = 0;
FLOWDESC *x = F(fh);
EFLOWDESC *ex = EF(efh);
pkt = (pkt_t *)x->buf;
if (ex->full_flow == 0) { /* if its full, go to next export record */
ret = ((ex->dst_port == H16(TCP(dst_port))) &&
(ex->src_port == H16(TCP(src_port))) &&
(ex->src_ip == H32(IP(src_ip))) &&
(ex->dst_ip == H32(IP(dst_ip))));
}
return ret;
}
bits in same positions of instruction preceding current instruction in the
code (when assembling). */
#define EFN &l_none
#ifdef HAS_EXECUTION
#define EF(func) &(func)
#define EFI &l_invalid
#else /* HAS_EXECUTION */
#define EF(func) EFN
#define EFI EFN
#endif /* HAS_EXECUTION */
const struct or32_opcode or32_opcodes[] =
{
{ "l.j", "N", "00 0x0 NNNNN NNNNN NNNN NNNN NNNN NNNN", EF(l_j), OR32_IF_DELAY },
{ "l.jal", "N", "00 0x1 NNNNN NNNNN NNNN NNNN NNNN NNNN", EF(l_jal), OR32_IF_DELAY },
{ "l.bnf", "N", "00 0x3 NNNNN NNNNN NNNN NNNN NNNN NNNN", EF(l_bnf), OR32_IF_DELAY | OR32_R_FLAG},
{ "l.bf", "N", "00 0x4 NNNNN NNNNN NNNN NNNN NNNN NNNN", EF(l_bf), OR32_IF_DELAY | OR32_R_FLAG },
{ "l.nop", "K", "00 0x5 01--- ----- KKKK KKKK KKKK KKKK", EF(l_nop), 0 },
{ "l.movhi", "rD,K", "00 0x6 DDDDD ----0 KKKK KKKK KKKK KKKK", EF(l_movhi), 0 }, /*MM*/
{ "l.macrc", "rD", "00 0x6 DDDDD ----1 0000 0000 0000 0000", EF(l_macrc), 0 }, /*MM*/
{ "l.sys", "K", "00 0x8 00000 00000 KKKK KKKK KKKK KKKK", EF(l_sys), 0 },
{ "l.trap", "K", "00 0x8 01000 00000 KKKK KKKK KKKK KKKK", EF(l_trap), 0 }, /* CZ 21/06/01 */
{ "l.msync", "", "00 0x8 10000 00000 0000 0000 0000 0000", EFN, 0 },
{ "l.psync", "", "00 0x8 10100 00000 0000 0000 0000 0000", EFN, 0 },
{ "l.csync", "", "00 0x8 11000 00000 0000 0000 0000 0000", EFN, 0 },
{ "l.rfe", "", "00 0x9 ----- ----- ---- ---- ---- ----", EF(l_rfe), OR32_IF_DELAY },
{ "lv.all_eq.b","rD,rA,rB", "00 0xA DDDDD AAAAA BBBB B--- 0x1 0x0", EFI, 0 },
/* Subroutine */ int sptrfs_(integer *n, integer *nrhs, real *d, real *e,
real *df, real *ef, real *b, integer *ldb, real *x, integer *ldx,
real *ferr, real *berr, real *work, integer *info)
{
/* -- LAPACK routine (version 2.0) --
Univ. of Tennessee, Univ. of California Berkeley, NAG Ltd.,
Courant Institute, Argonne National Lab, and Rice University
September 30, 1994
Purpose
=======
SPTRFS improves the computed solution to a system of linear
equations when the coefficient matrix is symmetric positive definite
and tridiagonal, and provides error bounds and backward error
estimates for the solution.
Arguments
=========
N (input) INTEGER
The order of the matrix A. N >= 0.
NRHS (input) INTEGER
The number of right hand sides, i.e., the number of columns
of the matrix B. NRHS >= 0.
D (input) REAL array, dimension (N)
The n diagonal elements of the tridiagonal matrix A.
E (input) REAL array, dimension (N-1)
The (n-1) subdiagonal elements of the tridiagonal matrix A.
DF (input) REAL array, dimension (N)
The n diagonal elements of the diagonal matrix D from the
factorization computed by SPTTRF.
EF (input) REAL array, dimension (N-1)
The (n-1) subdiagonal elements of the unit bidiagonal factor
L from the factorization computed by SPTTRF.
B (input) REAL array, dimension (LDB,NRHS)
The right hand side matrix B.
LDB (input) INTEGER
The leading dimension of the array B. LDB >= max(1,N).
X (input/output) REAL array, dimension (LDX,NRHS)
On entry, the solution matrix X, as computed by SPTTRS.
On exit, the improved solution matrix X.
LDX (input) INTEGER
The leading dimension of the array X. LDX >= max(1,N).
FERR (output) REAL array, dimension (NRHS)
The forward error bound for each solution vector
X(j) (the j-th column of the solution matrix X).
If XTRUE is the true solution corresponding to X(j), FERR(j)
is an estimated upper bound for the magnitude of the largest
element in (X(j) - XTRUE) divided by the magnitude of the
largest element in X(j).
BERR (output) REAL array, dimension (NRHS)
The componentwise relative backward error of each solution
vector X(j) (i.e., the smallest relative change in
any element of A or B that makes X(j) an exact solution).
WORK (workspace) REAL array, dimension (2*N)
INFO (output) INTEGER
= 0: successful exit
< 0: if INFO = -i, the i-th argument had an illegal value
Internal Parameters
===================
ITMAX is the maximum number of steps of iterative refinement.
=====================================================================
Test the input parameters.
Parameter adjustments
Function Body */
/* Table of constant values */
static integer c__1 = 1;
static real c_b11 = 1.f;
/* System generated locals */
integer b_dim1, b_offset, x_dim1, x_offset, i__1, i__2;
real r__1, r__2, r__3;
/* Local variables */
static real safe1, safe2;
static integer i, j;
static real s;
static integer count;
extern /* Subroutine */ int saxpy_(integer *, real *, real *, integer *,
real *, integer *);
static real bi, cx, dx, ex;
static integer ix;
extern doublereal slamch_(char *);
static integer nz;
static real safmin;
extern /* Subroutine */ int xerbla_(char *, integer *);
extern integer isamax_(integer *, real *, integer *);
static real lstres;
extern /* Subroutine */ int spttrs_(integer *, integer *, real *, real *,
real *, integer *, integer *);
static real eps;
#define D(I) d[(I)-1]
#define E(I) e[(I)-1]
#define DF(I) df[(I)-1]
#define EF(I) ef[(I)-1]
#define FERR(I) ferr[(I)-1]
#define BERR(I) berr[(I)-1]
#define WORK(I) work[(I)-1]
#define B(I,J) b[(I)-1 + ((J)-1)* ( *ldb)]
#define X(I,J) x[(I)-1 + ((J)-1)* ( *ldx)]
*info = 0;
if (*n < 0) {
*info = -1;
} else if (*nrhs < 0) {
*info = -2;
} else if (*ldb < max(1,*n)) {
*info = -8;
} else if (*ldx < max(1,*n)) {
*info = -10;
}
if (*info != 0) {
i__1 = -(*info);
xerbla_("SPTRFS", &i__1);
return 0;
}
/* Quick return if possible */
if (*n == 0 || *nrhs == 0) {
i__1 = *nrhs;
for (j = 1; j <= *nrhs; ++j) {
FERR(j) = 0.f;
BERR(j) = 0.f;
/* L10: */
}
return 0;
}
/* NZ = maximum number of nonzero elements in each row of A, plus 1 */
nz = 4;
eps = slamch_("Epsilon");
safmin = slamch_("Safe minimum");
safe1 = nz * safmin;
safe2 = safe1 / eps;
/* Do for each right hand side */
i__1 = *nrhs;
for (j = 1; j <= *nrhs; ++j) {
count = 1;
lstres = 3.f;
L20:
/* Loop until stopping criterion is satisfied.
Compute residual R = B - A * X. Also compute
abs(A)*abs(x) + abs(b) for use in the backward error bound.
*/
if (*n == 1) {
bi = B(1,j);
dx = D(1) * X(1,j);
WORK(*n + 1) = bi - dx;
WORK(1) = dabs(bi) + dabs(dx);
} else {
bi = B(1,j);
dx = D(1) * X(1,j);
ex = E(1) * X(2,j);
WORK(*n + 1) = bi - dx - ex;
WORK(1) = dabs(bi) + dabs(dx) + dabs(ex);
i__2 = *n - 1;
for (i = 2; i <= *n-1; ++i) {
bi = B(i,j);
cx = E(i - 1) * X(i-1,j);
dx = D(i) * X(i,j);
ex = E(i) * X(i+1,j);
WORK(*n + i) = bi - cx - dx - ex;
WORK(i) = dabs(bi) + dabs(cx) + dabs(dx) + dabs(ex);
/* L30: */
}
bi = B(*n,j);
cx = E(*n - 1) * X(*n-1,j);
dx = D(*n) * X(*n,j);
WORK(*n + *n) = bi - cx - dx;
WORK(*n) = dabs(bi) + dabs(cx) + dabs(dx);
}
/* Compute componentwise relative backward error from formula
max(i) ( abs(R(i)) / ( abs(A)*abs(X) + abs(B) )(i) )
where abs(Z) is the componentwise absolute value of the matr
ix
or vector Z. If the i-th component of the denominator is le
ss
than SAFE2, then SAFE1 is added to the i-th components of th
e
numerator and denominator before dividing. */
s = 0.f;
i__2 = *n;
for (i = 1; i <= *n; ++i) {
if (WORK(i) > safe2) {
/* Computing MAX */
r__2 = s, r__3 = (r__1 = WORK(*n + i), dabs(r__1)) / WORK(i);
s = dmax(r__2,r__3);
} else {
/* Computing MAX */
r__2 = s, r__3 = ((r__1 = WORK(*n + i), dabs(r__1)) + safe1) /
(WORK(i) + safe1);
s = dmax(r__2,r__3);
}
/* L40: */
}
BERR(j) = s;
/* Test stopping criterion. Continue iterating if
1) The residual BERR(J) is larger than machine epsilon, a
nd
2) BERR(J) decreased by at least a factor of 2 during the
last iteration, and
3) At most ITMAX iterations tried. */
if (BERR(j) > eps && BERR(j) * 2.f <= lstres && count <= 5) {
/* Update solution and try again. */
spttrs_(n, &c__1, &DF(1), &EF(1), &WORK(*n + 1), n, info);
saxpy_(n, &c_b11, &WORK(*n + 1), &c__1, &X(1,j), &c__1)
;
lstres = BERR(j);
++count;
goto L20;
}
/* Bound error from formula
norm(X - XTRUE) / norm(X) .le. FERR =
norm( abs(inv(A))*
( abs(R) + NZ*EPS*( abs(A)*abs(X)+abs(B) ))) / norm(X)
where
norm(Z) is the magnitude of the largest component of Z
inv(A) is the inverse of A
abs(Z) is the componentwise absolute value of the matrix o
r
vector Z
NZ is the maximum number of nonzeros in any row of A, plus
1
EPS is machine epsilon
The i-th component of abs(R)+NZ*EPS*(abs(A)*abs(X)+abs(B))
is incremented by SAFE1 if the i-th component of
abs(A)*abs(X) + abs(B) is less than SAFE2. */
i__2 = *n;
for (i = 1; i <= *n; ++i) {
if (WORK(i) > safe2) {
WORK(i) = (r__1 = WORK(*n + i), dabs(r__1)) + nz * eps * WORK(
i);
} else {
WORK(i) = (r__1 = WORK(*n + i), dabs(r__1)) + nz * eps * WORK(
i) + safe1;
}
/* L50: */
}
ix = isamax_(n, &WORK(1), &c__1);
FERR(j) = WORK(ix);
/* Estimate the norm of inv(A).
Solve M(A) * x = e, where M(A) = (m(i,j)) is given by
m(i,j) = abs(A(i,j)), i = j,
m(i,j) = -abs(A(i,j)), i .ne. j,
and e = [ 1, 1, ..., 1 ]'. Note M(A) = M(L)*D*M(L)'.
Solve M(L) * x = e. */
WORK(1) = 1.f;
i__2 = *n;
for (i = 2; i <= *n; ++i) {
WORK(i) = WORK(i - 1) * (r__1 = EF(i - 1), dabs(r__1)) + 1.f;
/* L60: */
}
/* Solve D * M(L)' * x = b. */
WORK(*n) /= DF(*n);
for (i = *n - 1; i >= 1; --i) {
WORK(i) = WORK(i) / DF(i) + WORK(i + 1) * (r__1 = EF(i), dabs(
r__1));
/* L70: */
}
/* Compute norm(inv(A)) = max(x(i)), 1<=i<=n. */
ix = isamax_(n, &WORK(1), &c__1);
FERR(j) *= (r__1 = WORK(ix), dabs(r__1));
/* Normalize error. */
lstres = 0.f;
i__2 = *n;
for (i = 1; i <= *n; ++i) {
/* Computing MAX */
r__2 = lstres, r__3 = (r__1 = X(i,j), dabs(r__1));
lstres = dmax(r__2,r__3);
/* L80: */
}
if (lstres != 0.f) {
FERR(j) /= lstres;
}
/* L90: */
}
return 0;
/* End of SPTRFS */
} /* sptrfs_ */
error_t ariaInit(AriaContext *context, const uint8_t *key, size_t keyLength)
{
uint_t i;
uint32_t *ek;
uint32_t *dk;
const uint32_t *ck1;
const uint32_t *ck2;
const uint32_t *ck3;
uint32_t w[16];
//128-bit master key?
if(keyLength == 16)
{
//Select the relevant constants
ck1 = c + 0;
ck2 = c + 4;
ck3 = c + 8;
//The number of rounds depends on the size of the master key
context->nr = 12;
}
//192-bit master key?
else if(keyLength == 24)
{
//Select the relevant constants
ck1 = c + 4;
ck2 = c + 8;
ck3 = c + 0;
//The number of rounds depends on the size of the master key
context->nr = 14;
}
//256-bit master key?
else if(keyLength == 32)
{
//Select the relevant constants
ck1 = c + 8;
ck2 = c + 0;
ck3 = c + 4;
//The number of rounds depends on the size of the master key
context->nr = 16;
}
else
{
//Report an error
return ERROR_INVALID_KEY_LENGTH;
}
//Compute 128-bit values KL and KR
memset(w, 0, sizeof(w));
memcpy(w, key, keyLength);
//Save KR...
MOV128(w + 8, w + 4);
//Compute intermediate values W0, W1, W2, and W3
MOV128(w + 4, w + 0);
OF(w + 4, ck1);
XOR128(w + 4, w + 8);
MOV128(w + 8, w + 4);
EF(w + 8, ck2);
XOR128(w + 8, w + 0);
MOV128(w + 12, w + 8);
OF(w + 12, ck3);
XOR128(w + 12, w + 4);
//Convert from big-endian byte order to host byte order
for(i = 0; i < 16; i++)
w[i] = betoh32(w[i]);
//Point to the encryption round keys
ek = context->ek;
//Compute ek1, ..., ek17 as follow
ROL128(ek + 0, w + 4, 109);
XOR128(ek + 0, w + 0);
ROL128(ek + 4, w + 8, 109);
XOR128(ek + 4, w + 4);
ROL128(ek + 8, w + 12, 109);
XOR128(ek + 8, w + 8);
ROL128(ek + 12, w + 0, 109);
XOR128(ek + 12, w + 12);
ROL128(ek + 16, w + 4, 97);
XOR128(ek + 16, w + 0);
ROL128(ek + 20, w + 8, 97);
XOR128(ek + 20, w + 4);
ROL128(ek + 24, w + 12, 97);
XOR128(ek + 24, w + 8);
ROL128(ek + 28, w + 0, 97);
XOR128(ek + 28, w + 12);
ROL128(ek + 32, w + 4, 61);
XOR128(ek + 32, w + 0);
ROL128(ek + 36, w + 8, 61);
XOR128(ek + 36, w + 4);
ROL128(ek + 40, w + 12, 61);
XOR128(ek + 40, w + 8);
ROL128(ek + 44, w + 0, 61);
XOR128(ek + 44, w + 12);
ROL128(ek + 48, w + 4, 31);
XOR128(ek + 48, w + 0);
ROL128(ek + 52, w + 8, 31);
XOR128(ek + 52, w + 4);
ROL128(ek + 56, w + 12, 31);
XOR128(ek + 56, w + 8);
ROL128(ek + 60, w + 0, 31);
XOR128(ek + 60, w + 12);
ROL128(ek + 64, w + 4, 19);
XOR128(ek + 64, w + 0);
//Convert from host byte order to big-endian byte order
for(i = 0; i < 68; i++)
ek[i] = htobe32(ek[i]);
//Decryption round keys are derived from the encryption round keys
dk = context->dk;
//Compute dk1
MOV128(dk + 0, ek + context->nr * 4);
//Compute dk2, ..., dk(n)
for(i = 1; i < context->nr; i++)
A(dk + i * 4, ek + (context->nr - i) * 4);
//Compute dk(n + 1)
MOV128(dk + i * 4, ek + 0);
//No error to report
return NO_ERROR;
}
IGL_INLINE void igl::simplify_polyhedron(
const Eigen::MatrixXd & OV,
const Eigen::MatrixXi & OF,
Eigen::MatrixXd & V,
Eigen::MatrixXi & F,
Eigen::VectorXi & J)
{
// TODO: to generalize to open meshes, 0-cost should keep all incident
// boundary edges on their original lines. (for non-manifold meshes,
// igl::decimate needs to be generalized)
Eigen::MatrixXd N;
// Function for computing cost of collapsing edge (0 if at least one
// direction doesn't change pointset, inf otherwise) and placement (in lowest
// cost direction).
const auto & perfect= [&N](
const int e,
const Eigen::MatrixXd & V,
const Eigen::MatrixXi & F,
const Eigen::MatrixXi & E,
const Eigen::VectorXi & EMAP,
const Eigen::MatrixXi & EF,
const Eigen::MatrixXi & EI,
double & cost,
Eigen::RowVectorXd & p)
{
// Function for ocmputing cost (0 or inf) of collapsing edge by placing
// vertex at `positive` end of edge.
const auto & perfect_directed = [&N](
const int e,
const bool positive,
const Eigen::MatrixXd & V,
const Eigen::MatrixXi & F,
const Eigen::MatrixXi & E,
const Eigen::VectorXi & EMAP,
const Eigen::MatrixXi & EF,
const Eigen::MatrixXi & EI,
double & cost,
Eigen::RowVectorXd & p)
{
const auto vi = E(e,positive);
const auto vj = E(e,!positive);
p = V.row(vj);
std::vector<int> faces = igl::circulation(e,positive,F,E,EMAP,EF,EI);
cost = 0;
for(auto f : faces)
{
// Skip the faces being collapsed
if(f == EF(e,0) || f == EF(e,1))
{
continue;
}
const Eigen::RowVectorXd nbefore = N.row(f);
// Face with vi replaced with vj
const Eigen::RowVector3i fafter(
F(f,0) == vi ? vj : F(f,0),
F(f,1) == vi ? vj : F(f,1),
F(f,2) == vi ? vj : F(f,2));
Eigen::RowVectorXd nafter;
igl::per_face_normals(V,fafter,nafter);
const double epsilon = 1e-10;
// if normal changed then not feasible, break
if((nbefore-nafter).norm() > epsilon)
{
cost = std::numeric_limits<double>::infinity();
break;
}
}
};
p.resize(3);
double cost0, cost1;
Eigen::RowVectorXd p0, p1;
perfect_directed(e,false,V,F,E,EMAP,EF,EI,cost0,p0);
perfect_directed(e,true,V,F,E,EMAP,EF,EI,cost1,p1);
if(cost0 < cost1)
{
cost = cost0;
p = p0;
}else
{
cost = cost1;
p = p1;
}
};
igl::per_face_normals(OV,OF,N);
Eigen::VectorXi I;
igl::decimate(
OV,OF,
perfect,
igl::infinite_cost_stopping_condition(perfect),
V,F,J,I);
}
N32(ex->src_ip) == N32(x->src_ip) &&
N32(ex->dst_ip) == N32(x->dst_ip) &&
N16(ex->src_port) == N16(x->src_port) &&
N16(ex->dst_port) == N16(x->dst_port) &&
ex->proto == x->proto &&
!(ex->full)
);
}
static int
export(void *efh, void *fh, int isnew)
{
unsigned int i;
FLOWDESC *x = F(fh);
EFLOWDESC *ex = EF(efh);
if (isnew) {
ex->nts = 0;
ex->full = 0;
ex->proto = x->proto;
ex->src_ip = x->src_ip;
ex->dst_ip = x->dst_ip;
ex->src_port = x->src_port;
ex->dst_port = x->dst_port;
}
/* Add the timestamps to the array */
for (i = 0; i < x->nts; i++)
ex->ts[ex->nts + i] = x->ts[i];
void CoolingTower::EvalProducts(CNodeEvalIndex & NEI)
{
switch (SolveMethod())
{
case SM_Direct:
{
const int wi = H2OLiq();
const int si = H2OVap();
const int ioLiq = IOWithId_Self(ioid_Liq);
const int ioVap = IOWithId_Self(ioid_Vap);
const int ioLoss = IOWithId_Self(ioid_LiqLoss);
const int ioDrift = IOWithId_Self(ioid_DriftLoss);
SpConduit & Ql=*IOConduit(ioLiq);
SpConduit & Qv=*IOConduit(ioVap);
StkSpConduit QMix("Mix", chLINEID(), this);
iCycles = Max(2L, iCycles);
dLGRatio = Range(0.01, dLGRatio, 10.0);
ClrCI(3);
ClrCI(4);
ClrCI(5);
ClrCI(6);
dDuty = 0.0;
SigmaQInPMin(QMix(), som_ALL, Id_2_Mask(ioid_Feed));
Ql.QCopy(QMix());
Qv.QCopy(QMix());
const double QmWaterLiqIn = QMix().VMass[wi];
const double QmWaterVapIn = QMix().VMass[si];
const double QmVapIn = QMix().QMass(som_Gas);
dQmIn = QMix().QMass(som_ALL);
const flag HasFlw = (dQmIn>UsableMass);
dTempKFeed = QMix().Temp();
const double TotHfAtFeedT_Before = QMix().totHf(som_ALL, dTempKFeed, QMix().Press());
//RB.EvalProducts(QMix);
//EHX.EvalProducts(QMix);
//double POut = AtmosPress(); //force outlet to Atmos P
double POut = Std_P; //force outlet to Std_P
//double AvgCellAgeY=AvgCellAge/(365.25*24.0*60.0*60.0);
//double TimeSinceDescaleM=TimeSinceDescale/(365.25*24.0*60.0*60.0/12.0);
//double RqdLiqTemp = AirWetBulbT + Approach + AvgCellAgeY*1.1 + TimeSinceDescaleM/12.0*4.0;
double RqdLiqTemp = dAirWetBulbT + dApproachT;
double T1 = QMix().Temp();
double T2 = RqdLiqTemp;
dLossQm = 0.0;
bool ValidData;
switch (iMethod)
{
case CTM_Simple: ValidData = (RqdLiqTemp<T1); break;
case CTM_Merkel: ValidData = (iMerkelCalcType==MCT_TOut ? (dAirWetBulbT<T1) : (RqdLiqTemp<T1)); break;
}
if (!HasFlw)
ValidData = false;
double RqdLiqTempUsed;
if (ValidData)
{
m_VLE.SetHfInAtZero(QMix());
if (iMethod==CTM_Simple)
{
//const double h1 = QMix().totHf();
RqdLiqTempUsed = RqdLiqTemp;
EvapFnd EF(QMix(), RqdLiqTempUsed, POut, m_VLE);//QMix().Press());
EF.SetTarget(QMix().totHf());
if (Valid(dEvapFrac))
{
EF.SetEstimate(dEvapFrac, 1.0);
//dEvapFrac = dNAN;
}
flag Ok = false;
dMaxEvapFrac = Range(0.01, dMaxEvapFrac, 1.0);
int iRet=EF.Start(0.0, dMaxEvapFrac);
if (iRet==RF_EstimateOK) //estimate is good, solve not required
{
Ok = true;
}
else
{
if (iRet==RF_BadEstimate)
iRet = EF.Start(0.0, dMaxEvapFrac); // Restart
if (iRet==RF_OK)
if (EF.Solve_Brent()==RF_OK)
Ok = true;
}
dEvapFrac = EF.Result(); //use result regardless
if (!Ok)
{
SigmaQInPMin(QMix(), som_ALL, Id_2_Mask(ioid_Feed));
m_VLE.SetSatPVapFrac(QMix(), dEvapFrac, 0);
QMix().SetPress(POut);
RqdLiqTempUsed = QMix().Temp();
}
//const double h2 = QMix().totHf();
//dDuty = h1-h2; this gives 0 (as expected)
//dDuty is zero because there is no heattransfer with the air
}
else
{
dAirCp = Max(0.000001, dAirCp);
dAirWetBulbT = Range(MerkelTMn, dAirWetBulbT, MerkelTMx-10.0);
if (T1<MerkelTMn || T1>MerkelTMx)
{
SetCI(6, true);
T1 = Range(MerkelTMn, T1, MerkelTMx);
}
MerkelTempFnd Fnd(QMix(), *this, T1);
if (iMerkelCalcType==MCT_KaVL)
{
if (T2<MerkelTMn || T2>MerkelTMx)
{
SetCI(5, true);
T2 = Range(MerkelTMn, T2, MerkelTMx);
RqdLiqTemp = T2;
}
dKaVL = Fnd.Function(T2);
}
else
{
Fnd.SetTarget(dKaVL);
//Note that for high LG_Ratio (eg>1.0) then ApproachT is higher.
double Mn = dAirWetBulbT+(T1-dAirWetBulbT)*0.005;
const double Mx = dAirWetBulbT+(T1-dAirWetBulbT)*0.999;//T1-0.001;
if (Valid(RqdLiqTemp) && RqdLiqTemp>Mn && RqdLiqTemp<Mx)
{
Fnd.SetEstimate(RqdLiqTemp, 1.0);
//RqdLiqTemp = dNAN;
}
flag Ok = false;
int iRet=Fnd.Start(Mn, Mx);
if (iRet==RF_EstimateOK) //estimate is good, solve not required
{
Ok = true;
}
else
{
double KaVL_MnTest = Fnd.Function(Mn);
if (KaVL_MnTest<0.0)
{
//Crude fix to find min temp that doesn't cause KaV/L to be negative...
double fr = 0.01;
while (KaVL_MnTest<0.0 && fr<0.9)
{
Mn = dAirWetBulbT+(T1-dAirWetBulbT)*fr;
KaVL_MnTest = Fnd.Function(Mn);
fr += 0.01;
}
iRet = Fnd.Start(Mn, Mx); // Restart
}
if (iRet==RF_OK)
if (Fnd.Solve_Brent()==RF_OK)
Ok = true;
}
RqdLiqTemp = Fnd.Result(); //use result regardless
T2 = RqdLiqTemp;
if (!Ok)
{
const double KaVL_Calc = Fnd.Function(T2);
SetCI(3, fabs(KaVL_Calc-dKaVL)>1.0e-6);
}
dApproachT = RqdLiqTemp - dAirWetBulbT;
}
dEvapFactor = Min(dEvapFactor, 0.1); //prevent user from puting a silly large number for this
dEvapLossQm = dQmIn * dEvapFactor * (C2F(T1)-C2F(T2));//Evaporation Loss: WLe = Wc * EvapFactor * dT
dEvapLossQm = Min(dEvapLossQm, QmWaterLiqIn); //limit the amount that can be evaporated
RqdLiqTempUsed = RqdLiqTemp;
dEvapFrac = Min(dMaxEvapFrac, (dEvapLossQm+QmWaterVapIn)/GTZ(QmWaterLiqIn+QmWaterVapIn));
const double h1 = QMix().totHf();
m_VLE.SetSatPVapFrac(QMix(), dEvapFrac, 0);
QMix().SetPress(POut);
QMix().SetTemp(RqdLiqTempUsed);
const double h2 = QMix().totHf();
dDuty = h1-h2;
//dAirEnthOut = AirEnth(T2);
dAirEnthOut = Fnd.h2 / 0.430210432; //convert from Btu/lb to kJ/kg
dAirQmIn = dQmIn/dLGRatio;
dAirTRise = dDuty/GTZ(dAirQmIn)/dAirCp;
dAirTOut = dAirDryBulbT + dAirTRise;
dAirMixQm = dAirQmIn + dEvapLossQm;
const double EvapLossCp = Qv.msCp();
dAirMixCp = dAirQmIn/GTZ(dAirMixQm)*dAirCp + dEvapLossQm/GTZ(dAirMixQm)*EvapLossCp;
dAirMixT = dAirQmIn/GTZ(dAirMixQm)*dAirTOut + dEvapLossQm/GTZ(dAirMixQm)*T2;
}
double QmWaterVapOut = QMix().VMass[si];
dQmWaterEvap = Max(0.0, QmWaterVapOut - QmWaterVapIn);
if (iMethod==CTM_Simple)
dEvapLossQm=dQmWaterEvap;
switch (iLossMethod)
{
case WLM_None:
dDriftLossQm = 0.0;
dBlowdownLossQm = 0.0;
dLossQm = 0.0;
break;
case WLM_Frac:
dRqdDriftLossFrac = Range(0.0, dRqdDriftLossFrac, 1.0);
dRqdLossFrac = Range(0.0, dRqdLossFrac, 0.9);
dLossQm = dQmIn * dRqdLossFrac;
dDriftLossQm = dLossQm * dRqdDriftLossFrac;
dBlowdownLossQm = dLossQm - dDriftLossQm;
break;
case WLM_Qm:
dRqdDriftLossFrac = Range(0.0, dRqdDriftLossFrac, 1.0);
dLossQm = dRqdLossQm;
dDriftLossQm = dLossQm * dRqdDriftLossFrac;
dBlowdownLossQm = dLossQm - dDriftLossQm;
break;
case WLM_DriftBlowdown:
dDriftLossQm = dQmIn * dDriftLossFrac;//Drift Loss: WLd = % of water flow
dBlowdownLossQm = dEvapLossQm/(iCycles-1);//Blowdown Loss: WLb = WLe / (cycles - 1)
dLossQm = dDriftLossQm+dBlowdownLossQm;
break;
}
if (dLossQm>dQmIn-dEvapLossQm-QmVapIn)
{
SetCI(4, true);
dLossQm = dQmIn-dEvapLossQm-QmVapIn;
}
m_VLE.AddHfOutAtZero(QMix());
}
else
{
RqdLiqTempUsed = T1;
dEvapFrac = 0.0;
dLossQm = 0.0;
dDriftLossQm = 0.0;
dBlowdownLossQm = 0.0;
dEvapLossQm = 0.0;
dQmWaterEvap = 0.0;
//if (iMethod==CTM_Merkel)
{
dAirEnthOut = TotHfAtFeedT_Before / 0.430210432; //convert from Btu/lb to kJ/kg
dAirQmIn = 0.0;
dAirTRise = 0.0;
dAirTOut = dTempKFeed;
dAirMixQm = 0.0;
dAirMixCp = 0.0;
dAirMixT = dTempKFeed;
}
}
//QMix.ChangeModel(&SMSteamClass);
const double TotHfAtFeedT_After = QMix().totHf(som_ALL, dTempKFeed, QMix().Press());
Qv.QSetF(QMix(), som_Gas, 1.0);
Qv.SetPress(POut);
Qv.SetTemp(RqdLiqTempUsed);
const double Qsl = QMix().QMass(som_SL);
if (ioLoss<0)
{
if (ioDrift<0)
{
Ql.QSetF(QMix(), som_SL, 1.0);
Ql.SetPress(POut);
Ql.SetTemp(RqdLiqTempUsed);
}
else
{
SpConduit & Qdrift=*IOConduit(ioDrift);
const double f = dDriftLossQm/GTZ(Qsl);
Ql.QSetF(QMix(), som_SL, 1.0-f);
Ql.SetPress(POut);
Ql.SetTemp(RqdLiqTempUsed);
Qdrift.QCopy(QMix());
Qdrift.QSetF(QMix(), som_SL, f);
Qdrift.SetPress(POut);
Qdrift.SetTemp(RqdLiqTempUsed);
}
}
else
{
SpConduit & Qloss=*IOConduit(ioLoss);
const double f = dLossQm/GTZ(Qsl);
Ql.QSetF(QMix(), som_SL, 1.0-f);
Ql.SetPress(POut);
Ql.SetTemp(RqdLiqTempUsed);
if (ioDrift<0)
{
Qloss.QCopy(QMix());
Qloss.QSetF(QMix(), som_SL, f);
Qloss.SetPress(POut);
Qloss.SetTemp(RqdLiqTempUsed);
}
else
{
const double fd = dDriftLossQm/GTZ(Qsl);
const double fl = f - fd;
SpConduit & Qdrift=*IOConduit(ioDrift);
Qdrift.QCopy(QMix());
Qdrift.QSetF(QMix(), som_SL, fd);
Qdrift.SetPress(POut);
Qdrift.SetTemp(RqdLiqTempUsed);
Qloss.QCopy(QMix());
Qloss.QSetF(QMix(), som_SL, fl);
Qloss.SetPress(POut);
Qloss.SetTemp(RqdLiqTempUsed);
}
}
//results...
dTotalLossQm = dLossQm+dEvapLossQm;
dHeatFlow = TotHfAtFeedT_After - TotHfAtFeedT_Before; //what exactly is this???
dFinalP = Ql.Press();
dFinalT = Ql.Temp();
dTempDrop = T1 - dFinalT;
SetCI(1, HasFlw && RqdLiqTemp>T1);
SetCI(2, HasFlw && RqdLiqTempUsed>RqdLiqTemp);
break;
}
default:
MN_Surge::EvalProducts(NEI);
}
}
