void Algorithm1::toBank(int* buf, int num, DataUnitPlusTime* pack,
int first_count) {
memcpy(pack->sampl, buf, num * sizeof(int));
pack->mode = Mad::ALGORITHM1;
pack->amountCount = num;
pack->numFirstCount += first_count / 4;
ptrans(pack,
sizeof(DataUnitPlusTime) + num * sizeof(int) - sizeof(pack->sampl));
}
void Algorithm1::follow_algorithm(void) {
double num_aver = 0; //среднее наблюдаемое количество пакетов в очереди за время измерения
unsigned num_max = 0; //максимальное наблюдаемое количество пакетов в очереди за время измерения
unsigned num = 0;
unsigned int count = 0; //количество учтённых данных на данном промежутке измерения
unsigned int sum = 0;
int t;
time_t tStamp = time(NULL) + PERIOD;
std::string str = "Создан поток сопровождения для алгоритма 1 для МАД "
+ std::to_string(bufStat__.id_MAD) + " pid = " + std::to_string(getpid());
to_journal(str);
for (;;) {
if (!isRunFollowThread__)
break;
mut__.lock();
num = fifo__.size();
mut__.unlock();
sum += num;
num_aver = sum / ++count;
if (num > num_max)
num_max = num;
usleep(TICK);
if ((t = time(NULL)) >= tStamp) {
//передача данных на БЦ
bufStat__.average = static_cast<int>(num_aver);
bufStat__.maximum = num_max;
bufStat__.time = t;
ptrans(&bufStat__, sizeof(StatAlg));
//обнуление счётчиков
count = sum = num_max = 0;
tStamp = t + PERIOD;
}
}
str = "Уничтожен поток сопровождения для алгоритма 1 для МАД "
+ std::to_string(bufStat__.id_MAD);
to_journal(str);
return;
}
void principal_comp(int n, atom_id index[], t_atom atom[], rvec x[],
matrix trans, rvec d)
{
int i, j, ai, m, nrot;
real mm, rx, ry, rz;
double **inten, dd[NDIM], tvec[NDIM], **ev;
#ifdef DEBUG
real e[NDIM];
#endif
real temp;
snew(inten, NDIM);
snew(ev, NDIM);
for (i = 0; (i < NDIM); i++)
{
snew(inten[i], NDIM);
snew(ev[i], NDIM);
dd[i] = 0.0;
#ifdef DEBUG
e[i] = 0.0;
#endif
}
for (i = 0; (i < NDIM); i++)
{
for (m = 0; (m < NDIM); m++)
{
inten[i][m] = 0;
}
}
for (i = 0; (i < n); i++)
{
ai = index[i];
mm = atom[ai].m;
rx = x[ai][XX];
ry = x[ai][YY];
rz = x[ai][ZZ];
inten[0][0] += mm*(sqr(ry)+sqr(rz));
inten[1][1] += mm*(sqr(rx)+sqr(rz));
inten[2][2] += mm*(sqr(rx)+sqr(ry));
inten[1][0] -= mm*(ry*rx);
inten[2][0] -= mm*(rx*rz);
inten[2][1] -= mm*(rz*ry);
}
inten[0][1] = inten[1][0];
inten[0][2] = inten[2][0];
inten[1][2] = inten[2][1];
#ifdef DEBUG
ptrans("initial", inten, dd, e);
#endif
for (i = 0; (i < DIM); i++)
{
for (m = 0; (m < DIM); m++)
{
trans[i][m] = inten[i][m];
}
}
/* Call numerical recipe routines */
jacobi(inten, 3, dd, ev, &nrot);
#ifdef DEBUG
ptrans("jacobi", ev, dd, e);
#endif
/* Sort eigenvalues in ascending order */
#define SWAPPER(i) \
if (fabs(dd[i+1]) < fabs(dd[i])) { \
temp = dd[i]; \
for (j = 0; (j < NDIM); j++) { tvec[j] = ev[j][i]; } \
dd[i] = dd[i+1]; \
for (j = 0; (j < NDIM); j++) { ev[j][i] = ev[j][i+1]; } \
dd[i+1] = temp; \
for (j = 0; (j < NDIM); j++) { ev[j][i+1] = tvec[j]; } \
}
SWAPPER(0)
SWAPPER(1)
SWAPPER(0)
#ifdef DEBUG
ptrans("swap", ev, dd, e);
t_trans(trans, dd, ev);
#endif
for (i = 0; (i < DIM); i++)
{
d[i] = dd[i];
for (m = 0; (m < DIM); m++)
{
trans[i][m] = ev[m][i];
}
}
for (i = 0; (i < NDIM); i++)
{
sfree(inten[i]);
sfree(ev[i]);
}
sfree(inten);
sfree(ev);
}
Eigen::Vector2d mesh_core::PlaneProjection::project(const Eigen::Vector3d& p) const
{
Eigen::Vector3d ptrans(p - origin_);
return Eigen::Vector2d(ptrans.dot(x_axis_), ptrans.dot(y_axis_));
}
cholmod_dense *CHOLMOD(solve)
(
/* ---- input ---- */
int sys, /* system to solve */
cholmod_factor *L, /* factorization to use */
cholmod_dense *B, /* right-hand-side */
/* --------------- */
cholmod_common *Common
)
{
cholmod_dense *Y = NULL, *X = NULL ;
Int *Perm ;
Int n, nrhs, ncols, ctype, xtype, k1, nr, ok ;
/* ---------------------------------------------------------------------- */
/* check inputs */
/* ---------------------------------------------------------------------- */
RETURN_IF_NULL_COMMON (NULL) ;
RETURN_IF_NULL (L, NULL) ;
RETURN_IF_NULL (B, NULL) ;
RETURN_IF_XTYPE_INVALID (L, CHOLMOD_REAL, CHOLMOD_ZOMPLEX, NULL) ;
RETURN_IF_XTYPE_INVALID (B, CHOLMOD_REAL, CHOLMOD_ZOMPLEX, NULL) ;
if (sys < CHOLMOD_A || sys > CHOLMOD_Pt)
{
ERROR (CHOLMOD_INVALID, "invalid system") ;
return (NULL) ;
}
if (B->d < L->n || B->nrow != L->n)
{
ERROR (CHOLMOD_INVALID, "dimensions of L and B do not match") ;
return (NULL) ;
}
DEBUG (CHOLMOD(dump_factor) (L, "L", Common)) ;
DEBUG (CHOLMOD(dump_dense) (B, "B", Common)) ;
Common->status = CHOLMOD_OK ;
/* ---------------------------------------------------------------------- */
/* get inputs */
/* ---------------------------------------------------------------------- */
if ((sys == CHOLMOD_P || sys == CHOLMOD_Pt || sys == CHOLMOD_A)
&& L->ordering != CHOLMOD_NATURAL)
{
Perm = L->Perm ;
}
else
{
/* do not use L->Perm; use the identity permutation instead */
Perm = NULL ;
}
nrhs = B->ncol ;
n = L->n ;
/* ---------------------------------------------------------------------- */
/* allocate the result X */
/* ---------------------------------------------------------------------- */
ctype = (Common->prefer_zomplex) ? CHOLMOD_ZOMPLEX : CHOLMOD_COMPLEX ;
if (sys == CHOLMOD_P || sys == CHOLMOD_Pt)
{
/* x=Pb and x=P'b return X real if B is real; X is the preferred
* complex/zcomplex type if B is complex or zomplex */
xtype = (B->xtype == CHOLMOD_REAL) ? CHOLMOD_REAL : ctype ;
}
else if (L->xtype == CHOLMOD_REAL && B->xtype == CHOLMOD_REAL)
{
/* X is real if both L and B are real */
xtype = CHOLMOD_REAL ;
}
else
{
/* X is complex, use the preferred complex/zomplex type */
xtype = ctype ;
}
X = CHOLMOD(allocate_dense) (n, nrhs, n, xtype, Common) ;
if (Common->status < CHOLMOD_OK)
{
return (NULL) ;
}
/* ---------------------------------------------------------------------- */
/* solve using L, D, L', P, or some combination */
/* ---------------------------------------------------------------------- */
if (sys == CHOLMOD_P)
{
/* ------------------------------------------------------------------ */
/* x = P*b */
/* ------------------------------------------------------------------ */
perm (B, Perm, 0, nrhs, X) ;
}
else if (sys == CHOLMOD_Pt)
{
/* ------------------------------------------------------------------ */
/* x = P'*b */
/* ------------------------------------------------------------------ */
iperm (B, Perm, 0, nrhs, X) ;
}
else if (L->is_super)
{
/* ------------------------------------------------------------------ */
/* solve using a supernodal LL' factorization */
/* ------------------------------------------------------------------ */
#ifndef NSUPERNODAL
/* allocate workspace */
cholmod_dense *E ;
Int dual ;
dual = (L->xtype == CHOLMOD_REAL && B->xtype != CHOLMOD_REAL) ? 2 : 1 ;
Y = CHOLMOD(allocate_dense) (n, dual*nrhs, n, L->xtype, Common) ;
E = CHOLMOD(allocate_dense) (dual*nrhs, L->maxesize, dual*nrhs,
L->xtype, Common) ;
if (Common->status < CHOLMOD_OK)
{
/* out of memory */
CHOLMOD(free_dense) (&X, Common) ;
CHOLMOD(free_dense) (&Y, Common) ;
CHOLMOD(free_dense) (&E, Common) ;
return (NULL) ;
}
perm (B, Perm, 0, nrhs, Y) ; /* Y = P*B */
if (sys == CHOLMOD_A || sys == CHOLMOD_LDLt)
{
ok = CHOLMOD(super_lsolve) (L, Y, E, Common) ; /* Y = L\Y */
ok = ok && CHOLMOD(super_ltsolve) (L, Y, E, Common) ; /* Y = L'\Y*/
}
else if (sys == CHOLMOD_L || sys == CHOLMOD_LD)
{
ok = CHOLMOD(super_lsolve) (L, Y, E, Common) ; /* Y = L\Y */
}
else if (sys == CHOLMOD_Lt || sys == CHOLMOD_DLt)
{
ok = CHOLMOD(super_ltsolve) (L, Y, E, Common) ; /* Y = L'\Y */
}
CHOLMOD(free_dense) (&E, Common) ;
iperm (Y, Perm, 0, nrhs, X) ; /* X = P'*Y */
if (CHECK_BLAS_INT && !ok)
{
/* integer overflow in the BLAS */
CHOLMOD(free_dense) (&X, Common) ;
}
#else
/* CHOLMOD Supernodal module not installed */
ERROR (CHOLMOD_NOT_INSTALLED,"Supernodal module not installed") ;
#endif
}
else
{
/* ------------------------------------------------------------------ */
/* solve using a simplicial LL' or LDL' factorization */
/* ------------------------------------------------------------------ */
if (L->xtype == CHOLMOD_REAL)
{
/* L is real, B is real/complex/zomplex, Y is real */
if (B->xtype == CHOLMOD_REAL)
{
/* solve with up to 4 columns of B at a time */
ncols = 4 ;
nr = MAX (4, nrhs) ;
Y = CHOLMOD(allocate_dense) (nr, n, nr, CHOLMOD_REAL, Common) ;
}
else
{
/* solve with one column of B (real/imag), at a time */
ncols = 1 ;
Y = CHOLMOD(allocate_dense) (2, n, 2, CHOLMOD_REAL, Common) ;
}
}
else
{
/* L is complex or zomplex, B is real/complex/zomplex, Y has the
* same complexity as L. Solve with one column of B at a time. */
ncols = 1 ;
Y = CHOLMOD(allocate_dense) (1, n, 1, L->xtype, Common) ;
}
if (Common->status < CHOLMOD_OK)
{
/* out of memory */
CHOLMOD(free_dense) (&X, Common) ;
CHOLMOD(free_dense) (&Y, Common) ;
return (NULL) ;
}
for (k1 = 0 ; k1 < nrhs ; k1 += ncols)
{
/* -------------------------------------------------------------- */
/* Y = B (P, k1:k1+ncols-1)' = (P * B (:,...))' */
/* -------------------------------------------------------------- */
ptrans (B, Perm, k1, ncols, Y) ;
/* -------------------------------------------------------------- */
/* solve Y = (L' \ (L \ Y'))', or other system, with template */
/* -------------------------------------------------------------- */
switch (L->xtype)
{
case CHOLMOD_REAL:
r_simplicial_solver (sys, L, Y) ;
break ;
case CHOLMOD_COMPLEX:
c_simplicial_solver (sys, L, Y) ;
break ;
case CHOLMOD_ZOMPLEX:
z_simplicial_solver (sys, L, Y) ;
break ;
}
/* -------------------------------------------------------------- */
/* X (P, k1:k2+ncols-1) = Y' */
/* -------------------------------------------------------------- */
iptrans (Y, Perm, k1, ncols, X) ;
}
}
CHOLMOD(free_dense) (&Y, Common) ;
DEBUG (CHOLMOD(dump_dense) (X, "X result", Common)) ;
return (X) ;
}
