int DEC_FIXP_LDPC_BIN::Activate(DECODING *ptDec)
{
int ErrorFlag = IN_ERROR;
// ---------------------------------------
// Get the module configuration parameters
// ---------------------------------------
GetParam(ptDec);
// --------------------
// Allocation of memory
// --------------------
if ( Mem() == IN_ERROR ) goto end;
// ----------------------
// Initialization actions
// ----------------------
if ( Init() == IN_ERROR ) goto end;
// --------------------
// sucessful activation
// --------------------
ErrorFlag = NO_ERROR;
end:
return ErrorFlag;
}
void TWebNetClt::OnNetMem(const PNetObj& NetObj){
TNetMem& NetMem=*(TNetMem*)NetObj();
const TMem& Mem=NetMem.GetMem();
IAssert("Screwed NetMem"&&!memchr(Mem(),0,Mem.Len()));
PSIn MemIn=TMemIn::New(Mem);
PHttpResp HttpResp=THttpResp::New(MemIn);
OnHttpResp(HttpResp);
}
t_stat WritePB(t_addr a, uint32 val)
{
uint8* mem;
t_stat rc = Mem(a&addrmask,&mem);
switch (rc) {
default:
return rc;
case SCPE_OK:
*mem = val & BMASK;
/*fallthru*/
case SIM_NOMEM:
return SCPE_OK;
}
}
/* memory access routines
* The Motorola CPU is big endian, whereas others like the i386 is
* little endian. The memory uses the natural order of the emulating CPU.
*
* addressing uses all bits but LSB to access the memory cell
*
* Memorybits 15 14 13 12 11 10 09 08 07 06 05 04 03 02 01 00
* ------68K Byte0-(MSB)-- ---68K Byte1-----------
* ------68K Byte2-------- ---68K Byte3-(LSB)-----
*/
t_stat ReadPB(t_addr a, uint32* val)
{
uint8* mem;
t_stat rc = Mem(a & addrmask,&mem);
switch (rc) {
default:
return rc;
case SIM_NOMEM:
*val = 0xff;
return SCPE_OK;
case SCPE_OK:
*val = *mem & BMASK;
return SCPE_OK;
}
}
t_stat WritePW(t_addr a, uint32 val)
{
uint8* mem;
t_stat rc = Mem((a+1)&addrmask,&mem);
switch (rc) {
default:
return rc;
case SCPE_OK:
/* 68000/08/10 do not like unaligned access */
if (cputype < 3 && (a & 1)) return STOP_ERRADR;
*(mem-1) = (val >> 8) & BMASK;
*mem = val & BMASK;
/*fallthru*/
case SIM_NOMEM:
return SCPE_OK;
}
}
t_stat ReadPW(t_addr a, uint32* val)
{
uint8* mem;
uint32 dat1,dat2;
t_stat rc = Mem((a+1)&addrmask,&mem);
switch (rc) {
default:
return rc;
case SIM_NOMEM:
*val = 0xffff;
return SCPE_OK;
case SCPE_OK:
/* 68000/08/10 do not like unaligned access */
if (cputype < 3 && (a & 1)) return STOP_ERRADR;
dat1 = (*(mem-1) & BMASK) << 8;
dat2 = *mem & BMASK;
*val = (dat1 | dat2) & WMASK;
return SCPE_OK;
}
}
///////////////////////////////////////////////////////////////////////////////////////////////////
//应用程序向设备写数据时的操作
NTSTATUS KadyUsbTestDevice::Write(KIrp I)
{
NTSTATUS status = STATUS_INSUFFICIENT_RESOURCES;
//声明变量，存放实际发送的字节数
ULONG dwBytesSent = 0;
//URB
PURB pUrb = NULL;
//获取应用程序内存对象
KMemory Mem(I.Mdl());
//检查缓冲区长度
ULONG dwTotalSize = I.WriteSize(CURRENT); //应用程序要写的数据长度
ULONG dwMaxSize = EndPoint2Out.MaximumTransferSize(); //端点允许传输的最大数据长度
if ( dwTotalSize > dwMaxSize )
{
//如果超过允许的最大数据长度，则传输最大允许数据长度个字节数
ASSERT(dwMaxSize);
dwTotalSize = dwMaxSize;
}
if(UsbdPipeTypeBulk == EndPoint2Out.Type())
{
pUrb = EndPoint2Out.BuildBulkTransfer(
Mem, //数据缓冲区
dwTotalSize, //需要传输的字节数
FALSE, //写数据
NULL //下一个URB(无)
);
}
else if(UsbdPipeTypeInterrupt == EndPoint2Out.Type())
{
//创建URB
pUrb = EndPoint2Out.BuildInterruptTransfer(
Mem, //数据缓冲区
dwTotalSize, //需要传输的字节数
TRUE, //允许实际传输的字节数小于需要传输的字节数
NULL, //下一个URB(无)
NULL, //当前URB(无，创建新的)
FALSE //写数据
);
}
//判断URB创建是否成功
if (pUrb != NULL)
{
//提交URB
status = EndPoint2Out.SubmitUrb(pUrb, NULL, NULL,1000);
//获取实际写入的字节数
if ( NT_SUCCESS(status) )
{
dwBytesSent = pUrb->UrbBulkOrInterruptTransfer.TransferBufferLength;
}
delete pUrb;
}
//向应用程序返回实际写入的字节数
I.Information() = dwBytesSent;
//完成IRP
return I.PnpComplete(this, status, IO_NO_INCREMENT);
}
void ReadMaterialComp()
{
char *input, fname[MAX_STR], word[MAX_STR], pname[MAX_STR], **params;
long loc0, loc1, mat, mat0, iso, iso0, nuc, i0, i, np, j, n, line, r, g, b;
double val, sum;
FILE *fp;
/* Get pointer to file list */
if ((loc0 = (long)RDB[DATA_PTR_COMP_FILE]) < VALID_PTR)
return;
fprintf(out, "Overriding initial material compositions...\n");
/* Reset previous pointer */
mat0 = -1;
/* Reset counters for line number calculation */
WDB[DATA_LINE_NUM_N0] = 0.0;
WDB[DATA_LINE_NUM_NL0] = 1.0;
/* Loop over list */
while (RDB[loc0] > VALID_PTR)
{
/* Get file name */
sprintf(fname, "%s", GetText(loc0));
/* Check that file exists */
if ((fp = fopen(fname, "r")) != NULL)
fclose(fp);
else
{
/* File not found */
Error(0, "Material composition file \"%s\" does not exist", fname);
}
/* Read input file */
input = ReadTextFile(fname);
/* Avoid compiler warning */
params = NULL;
/* Loop over file */
i0 = 0;
while ((i = NextWord(&input[i0], word)) > 0)
{
/* update pointer */
i0 = i0 + i;
/* Get line number for error messages */
line = GetLineNumber(input, i0);
/* Look for material definition */
if (!strcasecmp(word, "mat"))
{
/* Copy parameter name */
strcpy (pname, word);
/* Read parameters */
params = GetParams(word, input, &np, &i0, 4, 4*MAX_ISOTOPES + 8,
fname);
/* Read data */
j = 0;
/* Find material (try starting from previous) */
mat = mat0;
while (mat > VALID_PTR)
{
/* Compare */
if (!strcmp(params[j], GetText(mat + MATERIAL_PTR_NAME)))
break;
/* Next */
mat = NextItem(mat);
}
/* Find material (start from beginning) */
if (mat < VALID_PTR)
{
mat = (long)RDB[DATA_PTR_M0];
while (mat > VALID_PTR)
{
/* Compare */
if (!strcmp(params[j], GetText(mat + MATERIAL_PTR_NAME)))
break;
/* Next */
mat = NextItem(mat);
}
}
/* Check */
if (mat < VALID_PTR)
Error(-1, pname, fname, line, "Material %s is not defined",
params[j]);
else
j++;
/* Remember previous */
mat0 = NextItem(mat);
/* Material density */
if (!strcmp(params[j], "sum"))
{
/* Set value to -inf to calculate sum from composition */
WDB[mat + MATERIAL_ADENS] = -INFTY;
j++;
}
else
{
/* Read value */
WDB[mat + MATERIAL_ADENS] =
TestParam(pname, fname, line, params[j++], PTYPE_REAL,
-1000.0, 1000.0);
}
/* Reset sum */
sum = 0.0;
/* Reset previous pointer */
iso0 = -1;
/* Loop over parameters */
while (j < np)
{
/* Check parameter */
if (!strcmp(params[j], "tmp"))
{
/***** Temperature for Doppler-breadening **************/
j++;
/* Get temperature */
WDB[mat + MATERIAL_DOPPLER_TEMP] =
TestParam(pname, fname, line, params[j++],
PTYPE_REAL, 0.0, 100000.0);
/* Set option */
WDB[DATA_USE_DOPPLER_PREPROCESSOR] = (double)YES;
/*******************************************************/
}
if (!strcmp(params[j], "tms") || !strcmp(params[j], "ettm"))
{
/***** Temperature for TMS *****************************/
j++;
/* Get temperature */
WDB[mat + MATERIAL_TMS_TMIN] =
TestParam(pname, fname, line, params[j++],
PTYPE_REAL, 0.0, 100000.0);
/* Copy to maximum */
WDB[mat + MATERIAL_TMS_TMAX] =
RDB[mat + MATERIAL_TMS_TMIN];
/* Set mode */
WDB[DATA_TMS_MODE] = (double)TMS_MODE_CE;
WDB[mat + MATERIAL_TMS_MODE] = (double)YES;
/*******************************************************/
}
else if (!strcmp(params[j], "rgb"))
{
/***** Material colour *********************************/
j++;
/* Get r, b and g */
r = TestParam(pname, fname, line, params[j++],
PTYPE_INT, 0, 255);
g = TestParam(pname, fname, line, params[j++],
PTYPE_INT, 0, 255);
b = TestParam(pname, fname, line, params[j++],
PTYPE_INT, 0, 255);
/* Set color */
WDB[mat + MATERIAL_RGB] = b + 1000.0*g + 1000000.0*r;
/*******************************************************/
}
else if (!strcmp(params[j], "vol"))
{
/***** Material volume *********************************/
j++;
/* Get volume */
WDB[mat + MATERIAL_VOLUME_GIVEN] =
TestParam(pname, fname, line, params[j++], PTYPE_REAL,
0.0, INFTY);
/*******************************************************/
}
else if (!strcmp(params[j], "fix"))
{
/***** Default library ID and temperature***************/
j++;
/* Get default ID and temperature */
WDB[mat + MATERIAL_DEFAULT_PTR_LIB_ID] =
PutText(params[j++]);
WDB[mat + MATERIAL_DEFAULT_TMP] =
TestParam(pname, fname, line, params[j++], PTYPE_REAL,
0.0, INFTY);
/*******************************************************/
}
else if (!strcmp(params[j], "mass"))
{
/***** Material mass ***********************************/
j++;
/* Get mass */
WDB[mat + MATERIAL_MASS_GIVEN] =
TestParam(pname, fname, line, params[j++], PTYPE_REAL,
0.0, INFTY);
/*******************************************************/
}
else if (!strcmp(params[j], "burn"))
{
/***** Burnable material *******************************/
j++;
/* Set burn flag */
SetOption(mat + MATERIAL_OPTIONS, OPT_BURN_MAT);
/* Set burn sort flag and materials flag */
WDB[mat + MATERIAL_BURN_SORT_FLAG] = 1.0;
WDB[DATA_BURN_MATERIALS_FLAG] = (double)YES;
/* Get number of rings */
WDB[mat + MATERIAL_BURN_RINGS] =
(double)TestParam(pname, fname, line, params[j++],
PTYPE_INT, 0, 10000000);
/*******************************************************/
}
else if (!strcmp(params[j], "moder"))
{
/***** Thermal scattering data *************************/
j++;
/* Check number of parameters */
if (j > np - 3)
Error(mat, "Invalid number of parameters");
/* Create new item (use the same structure as with */
/* the therm card) */
WDB[mat + MATERIAL_PTR_SAB] = NULLPTR;
loc1 = NewItem(mat + MATERIAL_PTR_SAB,
THERM_BLOCK_SIZE);
/* Read name */
WDB[loc1 + THERM_PTR_ALIAS] =
(double)PutText(params[j++]);
/* Read ZA */
WDB[loc1 + THERM_ZA] =
(double)TestParam(pname, fname, line, params[j++],
PTYPE_INT, 1001, 120000);
/*******************************************************/
}
else if (!strcmp(params[j], "tft"))
{
/***** Minimum and maximum temperatures for TMS ********/
j++;
/* Get minimum temperature */
WDB[mat + MATERIAL_TMS_TMIN] =
TestParam(pname, fname, line, params[j++],
PTYPE_REAL, 0.0, 100000.0);
/* Get maximum temperature */
WDB[mat + MATERIAL_TMS_TMAX] =
TestParam(pname, fname, line, params[j++],
PTYPE_REAL, RDB[mat + MATERIAL_TMS_TMIN],
100000.0);
/* Set mode */
WDB[DATA_TMS_MODE] = (double)TMS_MODE_CE;
WDB[mat + MATERIAL_TMS_MODE] = (double)YES;
/*******************************************************/
}
else
{
/***** Composition *************************************/
/* Find nuclide in composition (start from previous) */
iso = iso0;
while (iso > VALID_PTR)
{
/* Pointer to nuclide data */
nuc = (long)RDB[iso + COMPOSITION_PTR_NUCLIDE];
CheckPointer(FUNCTION_NAME, "(nuc)", DATA_ARRAY,nuc);
/* Compare */
if (!strcmp(GetText(nuc + NUCLIDE_PTR_NAME),
params[j]))
break;
/* Next */
iso = NextItem(iso);
}
/* Find nuclide in composition (start from beginning) */
if (iso < VALID_PTR)
{
iso = (long)RDB[mat + MATERIAL_PTR_COMP];
while (iso > VALID_PTR)
{
/* Pointer to nuclide data */
nuc = (long)RDB[iso + COMPOSITION_PTR_NUCLIDE];
CheckPointer(FUNCTION_NAME, "(nuc)",
DATA_ARRAY,nuc);
/* Compare */
if (!strcmp(GetText(nuc + NUCLIDE_PTR_NAME),
params[j]))
break;
/* Next */
iso = NextItem(iso);
}
}
/* Check pointer */
if (iso < VALID_PTR)
Error(-1, pname, fname, line,
"Material %s has no nuclide %s in composition",
GetText(mat + MATERIAL_PTR_NAME), params[j]);
else
j++;
/* Remember pointer */
iso0 = iso;
/* Read fraction */
val = TestParam(pname, fname, line, params[j++],
PTYPE_REAL, -100.0, 1E+25);
/* Put value */
WDB[iso + COMPOSITION_ADENS] = val;
/* Add to sum */
sum = sum + val;
/*******************************************************/
}
}
/* Set density if sum */
if (RDB[mat + MATERIAL_ADENS] == -INFTY)
WDB[mat + MATERIAL_ADENS] = sum;
/* Calculate normalized fractions */
IsotopeFractions(mat);
}
/* Free parameter list */
if (np > 0)
for (n = 0; n < np + 1; n++)
Mem(MEM_FREE, params[n]);
}
/* Free memory */
Mem(MEM_FREE, input);
/* Next file */
loc0++;
}
/* This must be called to get the divided compositions into material */
/* structures */
SumDivCompositions();
fprintf(out, "OK.\n\n");
}
void schurFactorization(long n, complex **A, complex **T, complex **U)
{
/* Schur factorization: A = U*T*U', T = upper triangular, U = unitary */
long i,j,iter,maxIter;
double tol, diff1,diff2;
complex T11, T12, T21, T22;
complex sigma1, sigma2, sigma;
complex z, z1, z2;
complex **P, **Q, **R;
/* Allocate auxiliary matrices */
P = (complex **)Mem(MEM_ALLOC,n, sizeof(complex *));
Q = (complex **)Mem(MEM_ALLOC,n, sizeof(complex *));
R = (complex **)Mem(MEM_ALLOC,n, sizeof(complex *));
for (i=0; i<n; i++){
P[i] = (complex *)Mem(MEM_ALLOC,n, sizeof(complex));
Q[i] = (complex *)Mem(MEM_ALLOC,n, sizeof(complex));
R[i] = (complex *)Mem(MEM_ALLOC,n, sizeof(complex));
}
/* ------------------------------------------------------------*/
/* Parameters for iteration */
maxIter = 500;
tol = 1E-30;
/* ------------------------------------------------------------*/
/* Init U = eye(n) (identity matrix) */
for (i=0; i<n; i++){
U[i][i].re = 1.0;
U[i][i].im = 0.0;
}
/* ------------------------------------------------------------*/
/* Reduce A to Hessenberg form */
hessFactorization(n,A,P,T);
/* ------------------------------------------------------------*/
/* Compute Schur factorization of Hessenberg matrix T */
for (j=n-1; j>0; j--){ /* Main loop */
for (iter=0; iter<maxIter; iter++){ /* Iteration loop */
sigma.re = T[j][j].re;
sigma.im = T[j][j].im;
/* -- Use Wilkinson shift -- */
/* submatrix considered in the shift */
T11 = T[j-1][j-1];
T12 = T[j-1][j];
T21 = T[j][j-1];
T22 = T[j][j];
/* Compute eigenvalues of submatrix */
z.re = 0.0;
z.im = 0.0;
z2.re = 0.0;
z2.im = 0.0;
/* z = T11*T11 + T22*T22 - 2*T11*T22 + 4*T12*T21 */
z1 = c_mul(T11,T11);
z = c_add(z ,z1);
z2 = c_add(z2,z1);
z1 = c_mul(T22,T22);
z = c_add(z ,z1);
z2 = c_add(z2,z1);
z1 = c_mul(T11,T22);
z1.re = -2.0 * z1.re;
z1.im = -2.0 * z1.im;
z = c_add(z,z1);
z1 = c_mul(T12,T21);
z1.re = 4.0 * z1.re;
z1.im = 4.0 * z1.im;
z = c_add(z,z1);
/* Square root*/
z = c_sqrt(z);
/* Eigenvalues */
sigma1 = c_add(z2,z);
sigma2 = c_sub(z2,z);
/* printf("sigma1 = %e %e\n", sigma1.re, sigma1.im); */
/* printf("sigma2 = %e %e\n", sigma2.re, sigma2.im); */
/* Select eigenvalue for shift*/
diff1 = c_norm( c_sub(T[j][j], sigma1) );
diff2 = c_norm( c_sub(T[j][j], sigma2) );
if (diff1 < diff2){
sigma.re = sigma1.re;
sigma.im = sigma1.im;
}else{
sigma.re = sigma2.re;
sigma.im = sigma2.im;
}
/* --- QR step with Wilkinson shift --- */
/* Shift: T(1:j,1:j) = T(1:j,1:j) - sigma * eye(j) */
for (i=0; i<j+1; i++){
CheckValue(FUNCTION_NAME, "T[i][i].re","", T[i][i].re, -INFTY, INFTY);
CheckValue(FUNCTION_NAME, "T[i][i].im","", T[i][i].im, -INFTY, INFTY);
T[i][i].re = T[i][i].re - sigma.re;
T[i][i].im = T[i][i].im - sigma.im;
}
/* Compute QR factorization of shifted Hessenberg matrix */
for (i=0; i<n; i++){
memset(Q[i], 0, n*sizeof(complex));
memset(R[i], 0, n*sizeof(complex));
}
QRfactorization(n,T,Q,R);
/* T = T_new = R * Q */
for (i=0; i<n; i++){
memset(T[i], 0, n*sizeof(complex));
}
matProduct(n, n, n, R, Q, T);
/* T(1:j,1:j) = T(1:j,1:j) + sigma * eye(j) */
for (i=0; i<j+1; i++){
T[i][i].re = T[i][i].re + sigma.re;
T[i][i].im = T[i][i].im + sigma.im;
}
/* R = U_new = U * Q */
for (i=0; i<n; i++){
memset(R[i], 0, n*sizeof(complex));
}
matProduct(n,n,n,U,Q,R);
/* U = R */
for (i=0; i<n; i++){
memcpy(U[i],R[i], n*sizeof(complex));
}
/* Check convergence */
if (c_norm( T[j][j-1] ) <= tol * (c_norm(T[j-1][j-1]) + c_norm(T[j][j]))){
T[j][j-1].re = 0.0;
T[j][j-1].im = 0.0;
break;
}
} /* end of iter loop */
} /* end of main loop */
/* -------------------------------------------------------------*/
/* U = P*U */
for (i=0; i<n; i++){
memset(U[i], 0, n*sizeof(complex));
}
matProduct(n,n,n,P,R,U);
/* -------------------------------------------------------------*/
/* Free auxiliary variables */
for (i=0; i<n; i++){
Mem(MEM_FREE,P[i]);
Mem(MEM_FREE,Q[i]);
Mem(MEM_FREE,R[i]);
}
Mem(MEM_FREE,P);
Mem(MEM_FREE,Q);
Mem(MEM_FREE,R);
/* Return */
return;
}
void ProcessPhotonAtt()
{
long mat, iso, nuc, Z, ne, n, N, i0, i, ptr;
double Ei[100], fi[100], *E, *f, mdens, mfrac, val;
/* Avoid compiler warning (photon_attenuation.h sisältää dataa jota */
/* käytetään useammassa aliohjelmassa) */
n = idx1[0][0];
val = dat1[0][0];
/* Adjust coincident points */
ne = (long)idx0[91][0] + (long)idx0[91][1];
for (n = 1; n < ne; n++)
if (dat0[n][1] == dat0[n - 1][1])
dat0[n][1] = dat0[n][1] + 1E-11;
fprintf(out, "Processing reponse functions for photon dose rates...\n");
/* Loop over materials */
mat = (long)RDB[DATA_PTR_M0];
while (mat > VALID_PTR)
{
/***********************************************************************/
/***** Unionize energy grid ********************************************/
/* Reset pointer */
E = NULL;
N = 0;
/* Get mass density */
if ((mdens = RDB[mat + MATERIAL_MDENS]) == 0.0)
{
/* Skip zero-density material */
mat = NextItem(mat);
/* Cycle loop */
continue;
}
/* Loop over composition */
iso = (long)RDB[mat + MATERIAL_PTR_COMP];
while (iso > VALID_PTR)
{
/* Pointer to nuclide */
nuc = (long)RDB[iso + COMPOSITION_PTR_NUCLIDE];
CheckPointer(FUNCTION_NAME, "(nuc)", DATA_ARRAY, nuc);
/* Get Z */
Z = (long)RDB[nuc + NUCLIDE_Z];
/* Data only goes up to 92 */
if (Z > 92)
{
/* Skip */
iso = NextItem(iso);
/* Cycle loop */
continue;
}
/* Get index to data array and number of points */
i0 = (long)idx0[Z - 1][0];
ne = (long)idx0[Z - 1][1];
/* Check first and last energy point */
if (dat0[i0][1] != 1E-3)
Die(FUNCTION_NAME, "Mismatch in first energy point");
else if (dat0[i0 + ne - 1][1] != 20.0)
Die(FUNCTION_NAME, "Mismatch in last energy point");
/* Read data */
for (n = 0; n < ne; n++)
{
/* Check Z and read value */
if (dat0[i0 + n][0] != Z)
Die(FUNCTION_NAME, "Mismatch in Z");
else
Ei[n] = dat0[i0 + n][1];
}
/* Add points to main array */
E = AddPts(E, &N, Ei, ne);
/* Next */
iso = NextItem(iso);
}
/* Check order */
for (n = 1; n < N; n++)
if (E[n] <= E[n - 1])
Die(FUNCTION_NAME, "Error in order");
/***********************************************************************/
/***** Reconstruct data ************************************************/
/* Put number of points */
WDB[mat + MATERIAL_PHOTON_ATT_NE] = (double)N;
/* Put energy array in material structure */
ptr = ReallocMem(DATA_ARRAY, N);
WDB[mat + MATERIAL_PTR_PHOTON_ATT_E] = (double)ptr;
for (n = 0; n < N; n++)
WDB[ptr++] = E[n];
/* Allocate memory for data array */
ptr = ReallocMem(DATA_ARRAY, N);
WDB[mat + MATERIAL_PTR_PHOTON_ATT_F] = (double)ptr;
f = &WDB[ptr];
/* Reset vector (just to be safe) */
memset(f, 0.0, N*sizeof(double));
/* Loop over composition */
iso = (long)RDB[mat + MATERIAL_PTR_COMP];
while (iso > VALID_PTR)
{
/* Pointer to nuclide */
nuc = (long)RDB[iso + COMPOSITION_PTR_NUCLIDE];
CheckPointer(FUNCTION_NAME, "(nuc)", DATA_ARRAY, nuc);
/* Calculate mass fraction */
mfrac = RDB[nuc + NUCLIDE_AW]*RDB[iso + COMPOSITION_ADENS]/
mdens/N_AVOGADRO;
/* Get Z */
Z = (long)RDB[nuc + NUCLIDE_Z];
/* Data only goes up to 92 */
if (Z > 92)
{
/* Skip */
iso = NextItem(iso);
/* Cycle loop */
continue;
}
/* Get index to data array and number of points */
i0 = (long)idx0[Z - 1][0];
ne = (long)idx0[Z - 1][1];
/* Read data */
for (n = 0; n < ne; n++)
{
Ei[n] = dat0[i0 + n][1];
fi[n] = dat0[i0 + n][3];
}
/* Loop over unionized grid */
for (n = 0; n < N - 1; n++)
{
/* Find index */
if ((i = SearchArray(Ei, E[n], ne)) < 0)
Die(FUNCTION_NAME, "Point not in grid: %ld %E", n, E[n]);
/* Interpolate */
val = ENDFInterp(5, E[n], Ei[i], Ei[i + 1], fi[i], fi[i + 1]);
/* Add to data */
f[n] = f[n] + val*mfrac;
}
/* Add last point */
f[N - 1] = f[N -1] + fi[ne - 1]*mfrac;
/* Next */
iso = NextItem(iso);
}
/***********************************************************************/
/* Free memory */
if (E != NULL)
Mem(MEM_FREE, E);
/* Next material */
mat = NextItem(mat);
}
/* Exit OK */
fprintf(out, "OK.\n\n");
}
double *GetImportantPts(long ace, long *NXS, long *JXS, long *ni)
{
long NES, n0, i, itot, ptr, xss, n, nr, mt, ne, loc0, loc1, add;
double *tmp, *Ei;
/* Get maximum number of energy points */
NES = NXS[2];
/* Allocate memory for data */
tmp = (double *)Mem(MEM_ALLOC, NES, sizeof(double));
/* Reset values */
for (n = 0; n < NES; n++)
tmp[n] = 0.0;
/* Reset total number of important points */
itot = 0;
/* Pointer to XSS array */
xss = (long)ACE[ace + ACE_PTR_XSS];
/* Loop over reaction channels */
for (nr = -1; nr < NXS[3]; nr++)
{
/* Reset pointers to energy array and xs data */
loc0 = -1;
loc1 = -1;
/* Reset indexes */
n0 = -1;
ne = -1;
if (nr == -1)
{
/* Elastic scattering. Set mt */
mt = 2;
/* Set number of energy points */
ne = NES;
/* Set index to first point */
n0 = 0;
/* Pointer to energy array */
loc0 = xss + JXS[0] - 1;
/* Get pointer to xs data */
loc1 = xss + JXS[0] - 1 + 3*NES;
}
else
{
/* Other reactions, get mt */
ptr = xss + JXS[2] - 1 + nr;
mt = (long)ACE[ptr];
/* Check mt and specials flag (tää on vähän tarpeeton) */
if (((mt > 15) && (mt < 100)) || ((mt > 101) && (mt < 200)) ||
((long)RDB[DATA_OPTI_INCLUDE_SPECIALS] == YES))
{
/* Get pointer to SIG-block (Table F-10, page F-17) */
ptr = xss + JXS[5] - 1 + nr;
ptr = xss + (long)ACE[ptr] + JXS[6] - 1;
/* Get number of energy points */
ne = (long)ACE[ptr];
/* Get index to first point */
n0 = NXS[2] - (long)ACE[ptr];
/* Pointer to energy array */
loc0 = xss + JXS[0] - 1 + n0;
/* Get pointer to xs data */
loc1 = ptr + 1;
}
}
/* Find important points */
if (loc0 > 0)
{
/* Check indexes */
CheckValue(FUNCTION_NAME, "n0", "", n0, 0, NES);
CheckValue(FUNCTION_NAME, "ne", "", n0, 0, NES);
CheckValue(FUNCTION_NAME, "n0 + ne", "", n0 + ne, 0, NES);
/* Reset number of important points */
i = 0;
/* Loop over grid */
for (n = 0; n < ne; n++)
{
/* Reset add flag */
add = NO;
/* First two points */
if (n < 2)
add = YES;
/* Last two points */
else if (n > ne - 3)
add = YES;
/* Local minimum */
else if ((ACE[loc1 + n] < ACE[loc1 + n - 1]) &&
(ACE[loc1 + n] < ACE[loc1 + n + 1]))
add = YES;
/* Local maximum */
else if ((ACE[loc1 + n] > ACE[loc1 + n - 1]) &&
(ACE[loc1 + n] > ACE[loc1 + n + 1]))
add = YES;
/* Check add-flag */
if (add == YES)
{
/* Add new or compare to existing value */
if (tmp[n0 + n] == 0.0)
{
tmp[n0 + n] = ACE[loc0 + n];
itot++;
}
else if (tmp[n0 + n] != ACE[loc0 + n])
{
fprintf(err, "%s Mismatch in energy data.\n",
FUNCTION_NAME);
exit(-1);
}
i++;
}
}
}
}
/* Allocate memory for final important data */
Ei = (double *)Mem(MEM_ALLOC, itot, sizeof(double));
/* Clean data (remove zeros) */
i = 0;
for (n = 0; n < NES; n++)
if (tmp[n] > 0.0)
Ei[i++] = tmp[n];
/* Check pointer */
if (i != itot)
{
fprintf(err, "%s i != itot.\n", FUNCTION_NAME);
exit(-1);
}
/* Free temporary array */
if (tmp != NULL)
Mem(MEM_FREE, tmp);
/* Set array size */
*ni = itot;
/* Return pointer */
return Ei;
}
struct ccsMatrix *SymbolicLU(struct ccsMatrix *cmat){
/* Palauttaa ccs-matriisin A, joka sisältää myös Gaussissa tulevan fill-inin (E u F) */
long k,l,i,j,ind,n, m, nnz, rs, len, nnzi; /* len = listan pituus, nnzi = nollasta eroavien lkm rivillä i*/
long *col, *row, *list, *colA, *rowA, *fill, count;
complex *val, *valA;
struct ccsMatrix *A;
/* Aseta muuttujat matriisien kenttiin */
n = cmat->n;
m = cmat->m;
if (n != m)
Die(FUNCTION_NAME, "burnup matrix not square");
nnz = cmat->nnz;
/* Varaa tila uusille suureille */
/* pidä listaa vierekkäisistä solmuista */
list = (long *)Mem(MEM_ALLOC, n, sizeof(long));
/* pidä kirjaa jokaisen sarakkeen nz:oista */
fill = (long *)Mem(MEM_ALLOC, n, sizeof(long));
/* Varaa tilaa joka riviltä (sarakkeesta) fill-iniä varten */
rs = 0.1*n;
/* rs = 1.0; */
nnz = nnz + rs*n; /* rs uutta paikkaa joka rivillä */
A = ccsMatrixNew(n,n,nnz);
if (A == NULL)
Die(FUNCTION_NAME, "Failed to allocate space");
row = cmat->rowind;
col = cmat->colptr;
val = cmat->values;
rowA = A->rowind; /* fill-in tähän matriisiin */
colA = A->colptr;
valA = A->values;
/* Init. */
for (i=0 ; i < n; i++){
CheckValue(FUNCTION_NAME, "i", "", i, 0, cmat->n - 1);
CheckValue(FUNCTION_NAME, "i", "", i, 0, A->n);
nnzi = col[i+1]-col[i]; /* nz tässä sarakkeessa */
colA[i] = col[i] + i*rs; /* aseta sarakepointterit oikein */
/* JLE (1.6.2011): mitä jos nnzi == 0? */
/* (Huomaa, että 1. kierroksella i = 0, eli i*rs = 0... ) */
/* copy: memcpy(dest, src, size) */
memcpy(valA + colA[i], val + col[i], nnzi * sizeof(complex));
memcpy(rowA + colA[i], row + col[i], nnzi * sizeof(long));
memset(valA + colA[i] + nnzi, 0, rs * sizeof(complex));
memset(rowA + colA[i] + nnzi, -1, rs * sizeof(long));
}
colA[n] = nnz; /* aseta vielä viimeisen sarakkeen pointteri */
/*------------------------------------------------------------------*/
/* symbolinen hajotelma */
/*------------------------------------------------------------------*/
/* Algoritmi perustuu seuraavaan lemmaan:
kaari (i,j) kuuluu täytetyn matriisin (A u F) graafiin jos
solmusta i on polku solmuun j s.e. kaikki välissä olevan solmut
ovat pienempiä kuin min(i,j).
Kaikki kaaret (*,j) lasketaan etsimällä ne solmut, joista polku solmuun j s.e.
edellinen ehto toteutuu */
for (i = 1 ; i < n ; i++) { /* aloita toisesta sarakkeesta */
len = -1; /* tyhjä joukko */
CheckValue(FUNCTION_NAME, "i", "", i, 0, cmat->n - 1);
nnzi = col[i+1]-col[i]; /* alkuperäinen nollasta eroavien lkm tässä sarakkeessa */
for (j=col[i] ; j < col[i+1] ; j++){ /* käy läpi nollasta eroavat sarakkeessa i */
/* 2015/03/30: muutettu A->nnz -1 => A->nnz eli sallii nyt nollasarakkeet matriisin oikeassa reunassa (MPu)*/
CheckValue(FUNCTION_NAME, "j", "", j, 0, cmat->nnz);
k = row[j]; /* a_ki ~= 0 eli k -> i */
CheckValue(FUNCTION_NAME, "k", "", k, 0, cmat->n - 1);
fill[k] = 1; /* otetaan tieto talteen */
if (k < i){ /* Nyt siis k -> i s.e. k < i */
len = len + 1;
CheckValue(FUNCTION_NAME, "len", "", len, 0, cmat->n - 1);
/* lisää k listalle */
list[len] = k;
}
}
/*----------------------------------------------------------------*/
/* Se on tää luuppi johon jumittaa (JLe) */
count = 0;
while (len >= 0){ /* Etsitään löytyykö m s.e. m ->... ->k -> i ja k < min(m,i) */
CheckValue(FUNCTION_NAME, "len", "", len, 0, cmat->n - 1);
k = list[len]; /* poista edellinen solmu listalta*/
len = len - 1;
/* Testataan ikuinen luuppi (JLe) */
if (count++ > 100000000)
Die(FUNCTION_NAME, "Infinite loop?");
CheckValue(FUNCTION_NAME, "k", "", k, 0, A->n - 1);
/* Käy läpi listaa vastaavat sarakkeet eli etsi m -> k */
for (l = colA[k]; l < colA[k+1] ; l++) {
m = rowA[l]; /* a_mk ~= 0 */
if (m < 0){
break;
}
if (m > k){
/* Nyt siis m -> k -> i s.e. k < min(m,i) eli (m,i) lisätään täytettyyn matriisin */
CheckValue(FUNCTION_NAME, "m", "", m, 0, cmat->n - 1);
if (fill[m] == 0){ /* Ei ollut siellä valmiiksi */
/* lisää kaari (m,i) A:han */
CheckValue(FUNCTION_NAME, "i", "", i, 0, A->n - 1);
ind = colA[i] + nnzi;
if (ind >= colA[i+1]){ /* varaa lisää tilaa */
/* Tässä nyt uusi funktio */
ccsMatrixColSpace(A,i,rs);
colA = A->colptr;
rowA = A->rowind;
valA = A->values;
nnz = A->nnz;
}
/*2015/03/30: Tähän muutettu A->nnz-1 => A->nnz (MPu)*/
CheckValue(FUNCTION_NAME, "ind", "", ind, 0, A->nnz);
rowA[ind] = m; /* Nyt matriisissa */
nnzi = nnzi + 1;
CheckValue(FUNCTION_NAME, "m", "", m, 0, cmat->n - 1);
fill[m] = 1;
/* Seuraava if-osio oli aikaisemmin tämän if-osion ulkopuolella vaikka pitäisi olla sisällä!
=> selitys päättymättömään luuppiin...? */
if (m < i){ /* HUOM! edelleen m > k */
/* Nyt siis m -> k -> i s.e. m & k < i */
/* => lisätään m listalle, koska voi löytyä j -> m -> k -> i */
len = len + 1;
CheckValue(FUNCTION_NAME, "len", "", len, 0, cmat->n - 1);
list[len] = m;
}
}
}
CheckValue(FUNCTION_NAME, "k", "", k, 0, A->n - 1);
}
}
/*-----------------------------------------------------------------*/
CheckValue(FUNCTION_NAME, "i", "", i, 0, A->n - 1);
for (l = colA[i] ; l < colA[i] + nnzi ; l++) { /* nollaa fill seuraava kierrosta varten */
CheckValue(FUNCTION_NAME, "l", "", l, 0, A->nnz - 1);
k = rowA[l];
CheckValue(FUNCTION_NAME, "k", "", k, 0, cmat->n - 1);
fill[k] = 0;
CheckValue(FUNCTION_NAME, "i", "", i, 0, A->n - 1);
}
} /* i silmukka loppuu tähän */
/*-------------------------------------------------------------------------*/
ccsMatrixIsort(A); /* lisäyssorttaus */
Mem(MEM_FREE, list);
Mem(MEM_FREE, fill);
return A;
}
Mem MemMgrItf :: make_mem_ref ( Refcount * obj, MemoryItf * itf, caps_t caps )
{
// TBD - can set max capabilities here
return Mem ( obj, itf, caps );
}
void LUdecomposition(long n, complex **A, complex *b, complex *x)
{
long i,j,k,*p;
complex akk, bk, z, sum;
complex *Ak;
/* Allocate auxiliary variables */
p = (long *)Mem(MEM_ALLOC, n, sizeof(long));
/* Gaussian elimination with partial pivoting */
for (k=0; k<n-1; k++){ /* columns of A */
/* --- Pivoting --- */
akk.re = 0.0;
akk.im = 0.0;
j = k;
for (i=k; i<n; i++){
if ( c_norm(A[i][k]) > c_norm(akk)){
akk = A[i][k];
CheckValue(FUNCTION_NAME, "A[i][k].re","", A[i][k].re, -INFTY, INFTY);
CheckValue(FUNCTION_NAME, "A[i][k].im","", A[i][k].im, -INFTY, INFTY);
j = i;
}
}
if (j != k){ /* swap rows j and k*/
Ak = A[k];
A[k] = A[j]; /* swap pointers*/
A[j] = Ak;
bk = b[k];
b[k] = b[j];
b[j] = bk;
}
p[k] = j; /* Keep list of permutations */
/* Sanity check */
if (akk.re != A[k][k].re && akk.im != A[k][k].im){
Die(FUNCTION_NAME, "Something went wrong with pivoting?");
return;
}
if (akk.re == 0.0 && akk.im == 0.0){
Die(FUNCTION_NAME, "Matrix singular?");
return;
}
/* Store L part */
for (i=k+1;i<n; i++){
A[i][k] = c_div(A[i][k],A[k][k]);
CheckValue(FUNCTION_NAME, "A[i][k].re","", A[i][k].re, -INFTY, INFTY);
CheckValue(FUNCTION_NAME, "A[i][k].im","", A[i][k].im, -INFTY, INFTY);
}
/* Update */
for (i=k+1; i<n; i++){
/* update b */
z = c_mul(A[i][k], b[k]);
b[i] = c_sub(b[i], z);
CheckValue(FUNCTION_NAME, "b[i].re","", b[i].re, -INFTY, INFTY);
CheckValue(FUNCTION_NAME, "b[i].im","", b[i].im, -INFTY, INFTY);
for (j=k+1; j<n; j++){
/* Update U part of A */
z = c_mul( A[i][k], A[k][j]);
A[i][j] = c_sub(A[i][j],z);
CheckValue(FUNCTION_NAME, "A[i][j].re","", A[i][j].re, -INFTY, INFTY);
CheckValue(FUNCTION_NAME, "A[i][j].im","", A[i][j].im, -INFTY, INFTY);
}
}
}
/* Solve x */
x[n-1] = c_div(b[n-1],A[n-1][n-1]);
for (i=n-2; i>=0; i--){
sum.re = 0.0;
sum.im = 0.0;
for (j=i+1; j<n; j++){
z = c_mul(A[i][j], x[j]);
sum = c_add(sum, z);
}
z = c_sub(b[i], sum);
x[i] = c_div(z, A[i][i]);
}
Mem(MEM_FREE, p);
/* Return */
return;
}
void ApplyGCSymmetries(long gcu)
{
long ng, adf, ptr, surf, type, ns, nc, nmax, n, m, i, sym, mode;
double *f, *f0, val, max;
/* Check pointer to group constant universe */
CheckPointer(FUNCTION_NAME, "(gcu)", DATA_ARRAY, gcu);
/***************************************************************************/
/***** Fluxes and currents in ADF's ****************************************/
/* Reset maximum difference */
max = 0.0;
/* Get pointer to ADF structure and symmetry */
if ((adf = (long)RDB[gcu + GCU_PTR_ADF]) > VALID_PTR)
if ((sym = (long)RDB[adf + ADF_SYM]) > 0)
{
/* Get pointer to outer boundary surface */
surf = (long)RDB[adf + ADF_PTR_SURF];
CheckPointer(FUNCTION_NAME, "(surf)", DATA_ARRAY, surf);
/* Get surface type */
type = (long)RDB[surf + SURFACE_TYPE];
/* Get number of surfaces and corners */
ns = (long)RDB[adf + ADF_NSURF];
CheckValue(FUNCTION_NAME, "ns", "", ns, 1, 6);
nc = (long)RDB[adf + ADF_NCORN];
CheckValue(FUNCTION_NAME, "nc", "", nc, 0, 6);
/* Get number of energy groups */
ng = (long)RDB[DATA_ERG_FG_NG];
CheckValue(FUNCTION_NAME, "ng", "", ng, 1, 100000);
/* Allocate memory for temporary arrays */
if (ns > nc)
{
f0 = (double *)Mem(MEM_ALLOC, ns, sizeof(double));
f = (double *)Mem(MEM_ALLOC, ns, sizeof(double));
}
else
{
f0 = (double *)Mem(MEM_ALLOC, nc, sizeof(double));
f = (double *)Mem(MEM_ALLOC, nc, sizeof(double));
}
/* Loop over parameters */
for (i = 0; i < 11; i++)
{
/* Avoid compiler warning */
ptr = -1;
nmax = 0;
mode = 0;
/* Get pointer and set number of values */
if (i == 0)
{
ptr = RDB[gcu + GCU_RES_FG_DF_HET_SURF_FLUX];
nmax = ns;
mode = 1;
}
else if (i == 1)
{
ptr = RDB[gcu + GCU_RES_FG_DF_HET_CORN_FLUX];
nmax = nc;
mode = 2;
}
else if (i == 2)
{
ptr = RDB[gcu + GCU_RES_FG_DF_SURF_IN_CURR];
nmax = ns;
mode = 1;
}
else if (i == 3)
{
ptr = RDB[gcu + GCU_RES_FG_DF_SURF_OUT_CURR];
nmax = ns;
mode = 1;
}
else if (i == 4)
{
ptr = RDB[gcu + GCU_RES_FG_DF_SURF_NET_CURR];
nmax = ns;
mode = 1;
}
else if (i == 5)
{
ptr = RDB[gcu + GCU_RES_FG_DF_MID_IN_CURR];
nmax = ns;
mode = 1;
}
else if (i == 6)
{
ptr = RDB[gcu + GCU_RES_FG_DF_MID_OUT_CURR];
nmax = ns;
mode = 1;
}
else if (i == 7)
{
ptr = RDB[gcu + GCU_RES_FG_DF_MID_NET_CURR];
nmax = ns;
mode = 1;
}
else if (i == 8)
{
ptr = RDB[gcu + GCU_RES_FG_DF_CORN_IN_CURR];
nmax = nc;
mode = 2;
}
else if (i == 9)
{
ptr = RDB[gcu + GCU_RES_FG_DF_CORN_OUT_CURR];
nmax = nc;
mode = 2;
}
else if (i == 10)
{
ptr = RDB[gcu + GCU_RES_FG_DF_CORN_NET_CURR];
nmax = nc;
mode = 2;
}
else
Die(FUNCTION_NAME, "Overflow");
/* Check pointer */
if (ptr < VALID_PTR)
continue;
/* Loop over energy groups */
for (n = 0; n < ng; n++)
{
/* Read data */
for (m = 0; m < nmax; m++)
f0[m] = BufVal(ptr, m, n);
/* Check geometry type */
switch (type)
{
case SURF_SQC:
case SURF_RECT:
{
/* Infinite square prism (2D case) */
if (sym == 1)
{
/* Full symmetry */
if (type == SURF_SQC)
{
/* Average over all values if sqc */
val = (f0[0] + f0[1] + f0[2] + f0[3])/4.0;
f[0] = val - f0[0];
f[1] = val - f0[1];
f[2] = val - f0[2];
f[3] = val - f0[3];
}
else
{
/* Average over NS and EW and all corners */
/* if rect */
if (mode == 1)
{
val = (f0[S] + f0[N])/2.0;
f[S] = val - f0[S];
f[N] = val - f0[N];
val = (f0[W] + f0[E])/2.0;
f[W] = val - f0[W];
f[E] = val - f0[E];
}
else
{
val = (f0[0] + f0[1] + f0[2] + f0[3])/4.0;
f[0] = val - f0[0];
f[1] = val - f0[1];
f[2] = val - f0[2];
f[3] = val - f0[3];
}
}
}
else if (sym == 2)
{
/* S1 / NS symmetry */
if (mode == 1)
{
val = (f0[S] + f0[N])/2.0;
f[W] = 0.0;
f[S] = val - f0[S];
f[E] = 0.0;
f[N] = val - f0[N];
}
else
{
val = (f0[NW] + f0[SW])/2.0;
f[NW] = val - f0[NW];
f[SW] = val - f0[SW];
val = (f0[NE] + f0[SE])/2.0;
f[NE] = val - f0[NE];
f[SE] = val - f0[SE];
}
}
else if (sym == 3)
{
/* C1 / SENW symmetry */
if (mode == 1)
{
val = (f0[W] + f0[S])/2.0;
f[W] = val - f0[W];
f[S] = val - f0[S];
val = (f0[E] + f0[N])/2.0;
f[E] = val - f0[E];
f[N] = val - f0[N];
}
else
{
val = (f0[SE] + f0[NW])/2.0;
f[SW] = 0.0;
f[SE] = val - f0[SE];
f[NW] = val - f0[NW];
f[NE] = 0.0;
}
}
else if (sym == 4)
{
/* S2 / EW symmetry */
if (mode == 1)
{
val = (f0[W] + f0[E])/2.0;
f[W] = val - f0[W];
f[S] = 0.0;
f[E] = val - f0[E];
f[N] = 0.0;
}
else
{
val = (f0[SW] + f0[SE])/2.0;
f[SW] = val - f0[SW];
f[SE] = val - f0[SE];
val = (f0[NW] + f0[NE])/2.0;
f[NW] = val - f0[NW];
f[NE] = val - f0[NE];
}
}
else if (sym == 5)
{
/* C2 / SWNE symmetry */
if (mode == 1)
{
val = (f0[W] + f0[N])/2.0;
f[W] = val - f0[W];
f[N] = val - f0[N];
val = (f0[E] + f0[S])/2.0;
f[E] = val - f0[E];
f[S] = val - f0[S];
}
else
{
val = (f0[SW] + f0[NE])/2.0;
f[SW] = val - f0[SW];
f[SE] = 0.0;
f[NW] = 0.0;
f[NE] = val - f0[NE];
}
}
else if (sym != 0)
Die(FUNCTION_NAME, "Invalid symmetry");
/* Break case */
break;
}
case SURF_HEXYC:
case SURF_HEXXC:
{
/* Infinite hexagonal prism (2D case) */
if (sym == 1)
{
/* Full symmetry */
val = (f0[0] + f0[1] + f0[2] +
f0[3] + f0[4] + f0[5])/6.0;
f[0] = val - f0[0];
f[1] = val - f0[1];
f[2] = val - f0[2];
f[3] = val - f0[3];
f[4] = val - f0[4];
f[5] = val - f0[5];
}
else if (sym == 2)
{
/* S1-symmetry */
if (mode == 1)
{
f[0] = 0.0;
f[3] = 0.0;
val = (f0[1] + f0[5])/2.0;
f[1] = val - f0[1];
f[5] = val - f0[5];
val = (f0[2] + f0[4])/2.0;
f[2] = val - f0[2];
f[4] = val - f0[4];
}
else
{
val = (f0[0] + f0[5])/2.0;
f[0] = val - f0[0];
f[5] = val - f0[5];
val = (f0[1] + f0[4])/2.0;
f[1] = val - f0[1];
f[4] = val - f0[4];
val = (f0[2] + f0[3])/2.0;
f[2] = val - f0[2];
f[3] = val - f0[3];
}
}
else if (sym == 3)
{
/* C1-symmetry */
if (mode == 1)
{
val = (f0[0] + f0[1])/2.0;
f[0] = val - f0[0];
f[1] = val - f0[1];
val = (f0[2] + f0[5])/2.0;
f[2] = val - f0[2];
f[5] = val - f0[5];
val = (f0[3] + f0[4])/2.0;
f[3] = val - f0[3];
f[4] = val - f0[4];
}
else
{
f[0] = 0.0;
f[3] = 0.0;
val = (f0[1] + f0[5])/2.0;
f[1] = val - f0[1];
f[5] = val - f0[5];
val = (f0[2] + f0[4])/2.0;
f[2] = val - f0[2];
f[4] = val - f0[4];
}
}
else if (sym == 4)
{
/* S2-symmetry */
if (mode == 1)
{
f[1] = 0.0;
f[4] = 0.0;
val = (f0[0] + f0[2])/2.0;
f[0] = val - f0[0];
f[2] = val - f0[2];
val = (f0[3] + f0[5])/2.0;
f[3] = val - f0[3];
f[5] = val - f0[5];
}
else
{
val = (f0[0] + f0[1])/2.0;
f[0] = val - f0[0];
f[1] = val - f0[1];
val = (f0[2] + f0[5])/2.0;
f[2] = val - f0[2];
f[5] = val - f0[5];
val = (f0[3] + f0[4])/2.0;
f[3] = val - f0[3];
f[4] = val - f0[4];
}
}
else if (sym == 5)
{
/* C2-symmetry */
if (mode == 1)
{
val = (f0[0] + f0[3])/2.0;
f[0] = val - f0[0];
f[3] = val - f0[3];
val = (f0[1] + f0[2])/2.0;
f[1] = val - f0[1];
f[2] = val - f0[2];
val = (f0[4] + f0[5])/2.0;
f[4] = val - f0[4];
f[5] = val - f0[5];
}
else
{
f[1] = 0.0;
f[4] = 0.0;
val = (f0[0] + f0[2])/2.0;
f[0] = val - f0[0];
f[2] = val - f0[2];
val = (f0[3] + f0[5])/2.0;
f[3] = val - f0[3];
f[5] = val - f0[5];
}
}
else if (sym == 6)
{
/* S3-symmetry */
if (mode == 1)
{
f[2] = 0.0;
f[5] = 0.0;
val = (f0[1] + f0[3])/2.0;
f[1] = val - f0[1];
f[3] = val - f0[3];
val = (f0[0] + f0[4])/2.0;
f[0] = val - f0[0];
f[4] = val - f0[4];
}
else
{
val = (f0[0] + f0[3])/2.0;
f[0] = val - f0[0];
f[3] = val - f0[3];
val = (f0[1] + f0[2])/2.0;
f[1] = val - f0[1];
f[2] = val - f0[2];
val = (f0[4] + f0[5])/2.0;
f[4] = val - f0[4];
f[5] = val - f0[5];
}
}
else if (sym == 7)
{
/* C3-symmetry */
if (mode == 1)
{
val = (f0[0] + f0[5])/2.0;
f[0] = val - f0[0];
f[5] = val - f0[5];
val = (f0[1] + f0[4])/2.0;
f[1] = val - f0[1];
f[4] = val - f0[4];
val = (f0[2] + f0[3])/2.0;
f[2] = val - f0[2];
f[3] = val - f0[3];
}
else
{
f[2] = 0.0;
f[5] = 0.0;
val = (f0[1] + f0[3])/2.0;
f[1] = val - f0[1];
f[3] = val - f0[3];
val = (f0[0] + f0[4])/2.0;
f[0] = val - f0[0];
f[4] = val - f0[4];
}
}
else if (sym != 0)
Die(FUNCTION_NAME, "Invalid symmetry");
/* Break case */
break;
}
}
/* Mark scoring buffer unreduced */
WDB[DATA_BUF_REDUCED] = (double)NO;
/* Get maximum difference for error checking */
/* (surface flux and currents) */
if ((i == 0) || (i == 2) || (i == 3))
for (m = 0; m < nmax; m++)
if (fabs(f[m]/f0[m]) > max)
max = fabs(f[m]/f0[m]);
/* Put data */
for (m = 0; m < nmax; m++)
AddBuf(f[m], 1.0, ptr, 0, -1, m, n);
/* Reduce buffer */
ReduceBuffer();
}
}
/* Free temporary arrays */
Mem(MEM_FREE, f0);
Mem(MEM_FREE, f);
}
/* Print warning if statistics is good enough */
if ((long)(RDB[DATA_MICRO_CALC_BATCH_SIZE]*RDB[DATA_CYCLE_BATCH_SIZE]) >
1000*20)
if (max > 0.1)
Note(0, "ADF symmetry option may be wrong");
/***************************************************************************/
}
/*
* Read the message from the rtdServer and call a virtual method to
* display the image and evaluate the tcl event scripts.
*/
int RtdCamera::fileEvent()
{
Mem mem;
rtdIMAGE_INFO info;
int stat;
memset(&info, '\0', sizeof(rtdIMAGE_INFO));
info.semId = info.shmNum = -1;
stat = rtdRecvImageInfo(eventHndl_, &info, verbose_, buffer_);
semId_ = info.semId;
shmNum_ = info.shmNum;
if (stat != RTD_OK || checkType(info.dataType) != RTD_OK ||
info.xPixels <=0 || info.yPixels <= 0) {
checkStat();
return TCL_ERROR;
}
if ( ! attached()) {
semDecr();
return TCL_OK;
}
/*
* class Mem takes care of possible reusing previous shared memory areas
* and cleanup. Choose the constructor depending on whether the
* semaphore fields of the image info have been set.
*/
int bytes = info.xPixels * info.yPixels * (abs(info.dataType) / 8);
if (semId_ > 0)
mem = Mem(bytes, info.shmId, 0, verbose_, shmNum_, semId_);
else
mem = Mem(bytes, info.shmId, 0, verbose_);
if (mem.status() != 0) {
checkStat();
return TCL_ERROR;
}
dbl_->log("image event: Id=%d, x=%d, y=%d, width=%d, height=%d, "
"shmId=%d shmNum=%d semId=%d\n",
info.frameId, info.frameX, info.frameY, info.xPixels, info.yPixels,
info.shmId, shmNum_, semId_);
/*
* before displaying the image delete the file handler. This blocks
* new image events which must not be handled between camera pre/post commands.
*/
fileHandler(0);
// call the virtual method in a derived class to display the image
int disperr = display(info, mem);
// re-install the file handler
fileHandler(1);
// finally decrement the semaphore
semDecr();
return disperr;
}
void Rendezvous(long *nsrc0, double *wgt0)
{
#ifdef OLD_HIST
#ifdef MPI
long n, ntot, *ntsk, *buf, ptr, i, i0, sz1, sz2, nhist, pth, id;
double totwgt, *src1, *src2;
/* Check mode */
if ((long)RDB[DATA_OPTI_MPI_REPRODUCIBILITY] == NO)
return;
Die(FUNCTION_NAME, "Tää ei toimi uuden historiarakenteen kanssa");
/* Check number of mpi tasks */
if (mpitasks == 1)
return;
/* Start timers */
StartTimer(TIMER_MPI_OVERHEAD);
StartTimer(TIMER_MPI_OVERHEAD_TOTAL);
/* Allocate memory for task-wise sizes */
ntsk = (long *)Mem(MEM_ALLOC, mpitasks, sizeof(long));
buf = (long *)Mem(MEM_ALLOC, mpitasks, sizeof(long));
/* Put task-wise value */
buf[mpiid] = *nsrc0;
/* Reduce data */
MPI_Barrier(MPI_COMM_WORLD);
if (MPI_Reduce(buf, ntsk, mpitasks, MPI_LONG, MPI_SUM, 0, MPI_COMM_WORLD)
!= MPI_SUCCESS)
Die(FUNCTION_NAME, "MPI Error");
/* Broadcast data */
MPI_Barrier(MPI_COMM_WORLD);
if (MPI_Bcast(ntsk, mpitasks, MPI_LONG, 0, MPI_COMM_WORLD) != MPI_SUCCESS)
Die(FUNCTION_NAME, "MPI Error");
/* Calculate total size */
ntot = 0;
for (n = 0; n < mpitasks; n++)
ntot = ntot + ntsk[n];
/* Free buffer */
Mem(MEM_FREE, buf);
/* Get size of particle and history data blocks */
sz1 = PARTICLE_BLOCK_SIZE - LIST_DATA_SIZE;
sz2 = HIST_BLOCK_SIZE - LIST_DATA_SIZE;
/* Get size of history array */
if ((nhist = (long)RDB[DATA_HIST_LIST_SIZE]) < 0)
nhist = 0;
/* Allocate memory for histories */
src1 = Mem(MEM_ALLOC, (sz1 + nhist*sz2)*ntot, sizeof(double));
/* Calculate starting point */
i0 = 0;
for (i = 0; i < mpiid; i++)
i0 = i0 + ntsk[i]*(sz1 + nhist*sz2);
/* Reset OpenMP id */
id = 0;
/* Loop over distribution and read data into block */
while (1 != 2)
{
/* Pointer to source distribution */
ptr = (long)RDB[DATA_PART_PTR_SOURCE];
CheckPointer(FUNCTION_NAME, "(ptr)", DATA_ARRAY, ptr);
/* Pointer to first after dummy */
if ((ptr = NextItem(ptr)) < VALID_PTR)
break;
/* Remove particle from source */
RemoveItem(ptr);
/* Copy particle data */
memcpy(&src1[i0], &RDB[ptr + LIST_DATA_SIZE], sz1*sizeof(double));
/* Update pointer */
i0 = i0 + sz1;
/* Pointer to history data */
pth = (long)RDB[ptr + PARTICLE_PTR_HIST];
/* Loop over histories */
for (i = 0; i < nhist; i++)
{
/* Check pointer */
CheckPointer(FUNCTION_NAME, "(pth1)", DATA_ARRAY, pth);
/* Copy history data */
memcpy(&src1[i0], &RDB[pth + LIST_DATA_SIZE], sz2*sizeof(double));
/* Update pointer */
i0 = i0 + sz2;
/* Next */
pth = NextItem(pth);
}
/* Put particle in stack */
ToStack(ptr, id++);
/* Check OpenMP id */
if (id > (long)RDB[DATA_OMP_MAX_THREADS] - 1)
id = 0;
}
/* Allocate memory for temporary data */
if (mpiid == 0)
src2 = Mem(MEM_ALLOC, (sz1 + nhist*sz2)*ntot, sizeof(double));
else
src2 = NULL;
/* Reduce data */
MPI_Barrier(MPI_COMM_WORLD);
MPITransfer(src1, src2, (sz1 + nhist*sz2)*ntot, 0, MPI_METH_RED);
/* Move data back to original */
if (mpiid == 0)
memcpy(src1, src2, (sz1 + nhist*sz2)*ntot*sizeof(double));
/* Free temporary array */
if (mpiid == 0)
Mem(MEM_FREE, src2);
/* Broadcast data */
MPI_Barrier(MPI_COMM_WORLD);
MPITransfer(src1, NULL, (sz1 + nhist*sz2)*ntot, 0, MPI_METH_BC);
/* Reset pointer and OpenMP id */
i0 = 0;
id = 0;
/* Read data back to source */
for (n = 0; n < ntot; n++)
{
/* Get new particle from stack */
ptr = FromStack(PARTICLE_TYPE_NEUTRON, id++);
/* Check OpenMP id */
if (id > (long)RDB[DATA_OMP_MAX_THREADS] - 1)
id = 0;
/* Get pointer to history data (done here to avoid overwrite) */
pth = (long)RDB[ptr + PARTICLE_PTR_HIST];
/* Copy particle data */
memcpy(&WDB[ptr + LIST_DATA_SIZE], &src1[i0], sz1*sizeof(double));
/* Put pointer to history data */
WDB[ptr + PARTICLE_PTR_HIST] = (double)pth;
/* Update pointer */
i0 = i0 + sz1;
/* Loop over histories */
for (i = 0; i < nhist; i++)
{
/* Check pointer */
CheckPointer(FUNCTION_NAME, "(pth2)", DATA_ARRAY, pth);
/* Copy history data */
memcpy(&WDB[pth + LIST_DATA_SIZE], &src1[i0], sz2*sizeof(double));
/* Update pointer */
i0 = i0 + sz2;
/* Next */
pth = NextItem(pth);
}
/* Put particle back to source */
AddItem(DATA_PART_PTR_SOURCE, ptr);
}
/* Free memory */
Mem(MEM_FREE, src1);
Mem(MEM_FREE, ntsk);
/* Calculate number of particles and total weight */
totwgt = 0.0;
n = 0;
/* Pointer to first after dummy */
ptr = (long)RDB[DATA_PART_PTR_SOURCE];
CheckPointer(FUNCTION_NAME, "(ptr)", DATA_ARRAY, ptr);
ptr = NextItem(ptr);
/* Loop over remaining */
while (ptr > VALID_PTR)
{
/* Add to counter and weight */
n++;
totwgt = totwgt + RDB[ptr + PARTICLE_WGT];
/* Next */
ptr = NextItem(ptr);
}
/* Check */
if (n != ntot)
Die(FUNCTION_NAME, "Error in count");
/* Put values */
*nsrc0 = ntot;
*wgt0 = totwgt;
MPI_Barrier(MPI_COMM_WORLD);
/* Stop timers */
StopTimer(TIMER_MPI_OVERHEAD);
StopTimer(TIMER_MPI_OVERHEAD_TOTAL);
#endif
#endif
}
void QRfactorization(long n, complex **A, complex **Q, complex **R)
{
/* QR factorization based on Householder transformations */
long i,j,k,m;
double nrm;
complex z,z1,z2;
complex *vj;
/* Init. Q = eye(n) (identity matrix) */
for (i=0; i<n; i++){
Q[i][i].re = 1.0;
Q[i][i].im = 0.0;
}
/* Init. R = A */
for(j=0; j<n; j++){
for (i=0; i<n; i++){
R[i][j].re = A[i][j].re;
R[i][j].im = A[i][j].im;
CheckValue(FUNCTION_NAME, "A[i][j].re","", A[i][j].re, -INFTY, INFTY);
CheckValue(FUNCTION_NAME, "A[i][j].im","", A[i][j].im, -INFTY, INFTY);
}
}
/* Allocate auxiliary variables*/
vj = (complex *)Mem(MEM_ALLOC, n, sizeof(complex));
/* printf("begin calc, n = %d\n", n); */
/* ------------------------------------------------------------*/
for (j=0; j<n; j++){ /* Main loop */
/* R(j:end, j) */
for (i=j; i<n; i++){
vj[i-j].re = R[i][j].re;
vj[i-j].im = R[i][j].im;
}
nrm = vectorNorm(n-j, vj);
/* v(1) = v(1) + sign(R(j,j)) * norm(v) */
vj[0].re = vj[0].re + R[j][j].re / c_norm(R[j][j]) * nrm;
vj[0].im = vj[0].im + R[j][j].im / c_norm(R[j][j]) * nrm;
/* Update norm */
nrm = vectorNorm(n-j, vj);
/* v = v./norm(v) */
for (i=0; i<n-j; i++){
vj[i].re = vj[i].re / nrm;
vj[i].im = vj[i].im / nrm;
}
/* Update */
/* R(j:end, :) = R(j:end,:) - 2 * vj * vj' * R(j:end,:), : */
/* Q(:,j:end) = Q(:,j:end) - 2 * Q(:,j:end) * vj * vj^T */
for (k=0; k<n; k++){
/* (v * v' * A)_ik = v_i SUM_m Conj(v_m) A_mk */
z.re = 0.0;
z.im = 0.0;
for (m=j; m<n; m++){
z1 = c_con(vj[m-j]);
z1 = c_mul(z1, R[m][k]);
z = c_add(z,z1);
}
for (i=j; i<n; i++){
z2 = c_mul(vj[i-j],z);
/* Update R(i,k) */
R[i][k].re = R[i][k].re - 2.0 * z2.re;
R[i][k].im = R[i][k].im - 2.0 * z2.im;
CheckValue(FUNCTION_NAME, "R[i][k].re","", R[i][k].re, -INFTY, INFTY);
CheckValue(FUNCTION_NAME, "R[i][k].im","", R[i][k].im, -INFTY, INFTY);
}
/* (A * v * v^')_ki = v_i * SUM_m Conj(v_m) A_km */
z.re = 0.0;
z.im = 0.0;
for (m=j; m<n; m++){
z1 = vj[m-j];
z1 = c_mul(z1, Q[k][m]);
z = c_add(z,z1);
}
for (i=j; i<n; i++){
z1 = c_con(vj[i-j]);
z2 = c_mul(z1,z);
/* Update Q(k,i)*/
Q[k][i].re = Q[k][i].re - 2.0 * z2.re;
Q[k][i].im = Q[k][i].im - 2.0 * z2.im;
CheckValue(FUNCTION_NAME, "Q[k][i].re","", Q[k][i].re, -INFTY, INFTY);
CheckValue(FUNCTION_NAME, "Q[k][i].im","", Q[k][i].im, -INFTY, INFTY);
}
}
} /* End of main loop (j) */
/* -------------------------------------------------------------*/
/* Free auxiliary variables */
Mem(MEM_FREE, vj);
return;
}
void XSPlotter()
{
double Emin, Emax, *E;
long nuc, mat, rea, ne, n, i, ptr, rea1, ncol;
char tmpstr[MAX_STR];
FILE *fp;
unsigned long seed;
/* Check if plot is defined */
if ((long)RDB[DATA_XSPLOT_NE] < 1)
return;
/* Check mpi task */
if (mpiid > 0)
return;
/* Init random number sequence */
seed = ReInitRNG(0);
SEED[0] = seed;
/* Set filename */
sprintf(tmpstr, "%s_xs%ld.m", GetText(DATA_PTR_INPUT_FNAME),
(long)RDB[DATA_BURN_STEP]);
fprintf(out, "Creating XS plot file \"%s\"...\n", tmpstr);
/* Open file for writing */
if ((fp = fopen(tmpstr, "w")) == NULL)
Die(FUNCTION_NAME, "Unable to open file for writing");
/* Remember collision count */
ptr = (long)RDB[DATA_PTR_COLLISION_COUNT];
ncol = GetPrivateData(ptr, 0);
/***************************************************************************/
/***** Generate energy grid ************************************************/
/* Boundaries and grid size */
if (RDB[DATA_XSPLOT_EMIN] > 0.0)
Emin = RDB[DATA_XSPLOT_EMIN];
else
Emin = RDB[DATA_NEUTRON_EMIN];
if (RDB[DATA_XSPLOT_EMAX] > 0.0)
Emax = RDB[DATA_XSPLOT_EMAX];
else
Emax = RDB[DATA_NEUTRON_EMAX];
ne = (long)RDB[DATA_XSPLOT_NE];
/* Generate array */
E = MakeArray(Emin, Emax, ne, 2);
/* Print array */
fprintf(fp, "E = [\n");
for (n = 0; n < ne; n++)
fprintf(fp, "%1.5E\n", E[n]);
fprintf(fp, "];\n\n");
/***************************************************************************/
/***** Print microscopic cross sections ************************************/
/* Loop over nuclides */
nuc = (long)RDB[DATA_PTR_NUC0];
while(nuc > VALID_PTR)
{
/* Check type */
if ((long)RDB[nuc + NUCLIDE_TYPE] == NUCLIDE_TYPE_DOSIMETRY)
{
/* Set name */
sprintf(tmpstr, "i%s", GetText(nuc + NUCLIDE_PTR_NAME));
if ((long)RDB[nuc + NUCLIDE_TYPE] != NUCLIDE_TYPE_DECAY)
tmpstr[strlen(tmpstr) - 4] = '_';
/* Print reaction mt's */
fprintf(fp, "%s_mt = [\n", tmpstr);
/* Loop over reactions */
rea = (long)RDB[nuc + NUCLIDE_PTR_REA];
while (rea > VALID_PTR)
{
/* Print mt */
fprintf(fp, "%4ld %% %s\n", (long)RDB[rea + REACTION_MT],
ReactionMT((long)RDB[rea + REACTION_MT]));
/* Next */
rea = NextItem(rea);
}
fprintf(fp, "];\n\n");
/* Print cross sections */
fprintf(fp, "%s_xs = [\n", tmpstr);
for (n = 0; n < ne; n++)
{
/* Loop over reactions */
rea = (long)RDB[nuc + NUCLIDE_PTR_REA];
while (rea > VALID_PTR)
{
/* Get cross section */
if ((long)RDB[nuc + NUCLIDE_TYPE] == NUCLIDE_TYPE_PHOTON)
fprintf(fp, "%1.5E ", PhotonMicroXS(rea, E[n], 0));
else
fprintf(fp, "%1.5E ", MicroXS(rea, E[n], 0));
/* 0K data */
if ((rea1 = (long)RDB[rea + REACTION_PTR_0K_DATA])
> VALID_PTR)
fprintf(fp, "%1.5E ", MicroXS(rea1, E[n], 0));
/* Majorant */
if ((rea1 = (long)RDB[rea + REACTION_PTR_TMP_MAJORANT])
> VALID_PTR)
fprintf(fp, "%1.5E ", MicroXS(rea1, E[n], 0));
/* Next reaction */
rea = NextItem(rea);
}
fprintf(fp, "\n");
}
fprintf(fp, "];\n\n");
}
else if (((long)RDB[nuc + NUCLIDE_TYPE] != NUCLIDE_TYPE_DECAY) ||
((long)RDB[nuc + NUCLIDE_TYPE_FLAGS] &
NUCLIDE_FLAG_TRANSMU_DATA))
{
/* Set name */
sprintf(tmpstr, "i%s", GetText(nuc + NUCLIDE_PTR_NAME));
if ((long)RDB[nuc + NUCLIDE_TYPE] != NUCLIDE_TYPE_DECAY)
tmpstr[strlen(tmpstr) - 4] = '_';
/* Print reaction mt's */
fprintf(fp, "%s_mt = [\n", tmpstr);
if ((long)RDB[nuc + NUCLIDE_TYPE] == NUCLIDE_TYPE_PHOTON)
fprintf(fp, "%4ld %% Total\n", (long)501);
else
{
fprintf(fp, "%4ld %% Total\n", (long)1);
if ((long)RDB[nuc + NUCLIDE_PTR_SUM_ABSXS] > VALID_PTR)
fprintf(fp, "%4ld %% Sum of absorption\n", (long)101);
}
if ((long)RDB[nuc + NUCLIDE_PTR_HEATPRODXS] > VALID_PTR)
fprintf(fp, "%4ld %% Heat production\n", (long)301);
if ((long)RDB[nuc + NUCLIDE_PTR_PHOTPRODXS] > VALID_PTR)
fprintf(fp, "%4ld %% Photon production\n", (long)202);
/* Pointer total xs */
rea = (long)RDB[nuc + NUCLIDE_PTR_TOTXS];
CheckPointer(FUNCTION_NAME, "(rea)", DATA_ARRAY, rea);
if ((long)RDB[rea + REACTION_PTR_0K_DATA] > VALID_PTR)
fprintf(fp, "%4ld %% %s (0K)\n",
(long)RDB[rea + REACTION_MT],
ReactionMT((long)RDB[rea + REACTION_MT]));
if ((long)RDB[rea + REACTION_PTR_TMP_MAJORANT] > VALID_PTR)
fprintf(fp, "%4ld %% %s (temperature Majorant)\n",
(long)RDB[rea + REACTION_MT],
ReactionMT((long)RDB[rea + REACTION_MT]));
/* Pointer to partial list */
ptr = (long)RDB[rea + REACTION_PTR_PARTIAL_LIST];
CheckPointer(FUNCTION_NAME, "(ptr)", DATA_ARRAY, ptr);
/* Loop over partials */
i = 0;
while ((rea = ListPtr(ptr, i++)) > VALID_PTR)
{
/* Pointer to reaction data */
rea = (long)RDB[rea + RLS_DATA_PTR_REA];
CheckPointer(FUNCTION_NAME, "(rea)", DATA_ARRAY, rea);
/* Print mt */
fprintf(fp, "%4ld %% %s\n", (long)RDB[rea + REACTION_MT],
ReactionMT((long)RDB[rea + REACTION_MT]));
if ((long)RDB[rea + REACTION_PTR_0K_DATA] > VALID_PTR)
fprintf(fp, "%4ld %% %s (0K)\n",
(long)RDB[rea + REACTION_MT],
ReactionMT((long)RDB[rea + REACTION_MT]));
if ((long)RDB[rea + REACTION_PTR_TMP_MAJORANT] > VALID_PTR)
fprintf(fp, "%4ld %% %s (temperature Majorant)\n",
(long)RDB[rea + REACTION_MT],
ReactionMT((long)RDB[rea + REACTION_MT]));
}
fprintf(fp, "];\n\n");
/* Print cross sections */
fprintf(fp, "%s_xs = [\n", tmpstr);
for (n = 0; n < ne; n++)
{
/* Pointer to total xs */
rea = (long)RDB[nuc + NUCLIDE_PTR_TOTXS];
CheckPointer(FUNCTION_NAME, "(rea)", DATA_ARRAY, rea);
/* Get cross section */
if ((long)RDB[nuc + NUCLIDE_TYPE] == NUCLIDE_TYPE_PHOTON)
fprintf(fp, "%1.5E ", PhotonMicroXS(rea, E[n], 0));
else
fprintf(fp, "%1.5E ", MicroXS(rea, E[n], 0));
/* Pointer to total absorption xs */
if ((rea1 = (long)RDB[nuc + NUCLIDE_PTR_SUM_ABSXS]) > VALID_PTR)
fprintf(fp, "%1.5E ", MicroXS(rea1, E[n], 0));
/* Heat production */
if ((long)RDB[nuc + NUCLIDE_TYPE] == NUCLIDE_TYPE_PHOTON)
{
ptr = (long)RDB[nuc + NUCLIDE_PTR_PHOTON_HEATPRODXS];
fprintf(fp, "%1.5E ", PhotonMicroXS(ptr, E[n], 0));
}
else if ((ptr = (long)RDB[nuc + NUCLIDE_PTR_HEATPRODXS]) >
VALID_PTR)
fprintf(fp, "%1.5E ", MicroXS(ptr, E[n], 0));
/* Photon production */
if ((long)RDB[nuc + NUCLIDE_TYPE] == NUCLIDE_TYPE_TRANSPORT)
if ((ptr = (long)RDB[nuc + NUCLIDE_PTR_PHOTPRODXS]) > VALID_PTR)
fprintf(fp, "%1.5E ", MicroXS(ptr, E[n], 0));
/* 0K data */
if ((rea1 = (long)RDB[rea + REACTION_PTR_0K_DATA])
> VALID_PTR)
fprintf(fp, "%1.5E ", MicroXS(rea1, E[n], 0));
/* Majorant */
if ((rea1 = (long)RDB[rea + REACTION_PTR_TMP_MAJORANT])
> VALID_PTR)
fprintf(fp, "%1.5E ", MicroXS(rea1, E[n], 0));
/* Pointer to partial list */
ptr = (long)RDB[rea + REACTION_PTR_PARTIAL_LIST];
CheckPointer(FUNCTION_NAME, "(ptr)", DATA_ARRAY, ptr);
/* Loop over partials */
i = 0;
while ((rea = ListPtr(ptr, i++)) > VALID_PTR)
{
/* Pointer to reaction data */
rea = (long)RDB[rea + RLS_DATA_PTR_REA];
CheckPointer(FUNCTION_NAME, "(rea)", DATA_ARRAY, rea);
/* Get cross section */
if ((long)RDB[nuc + NUCLIDE_TYPE] == NUCLIDE_TYPE_PHOTON)
fprintf(fp, "%1.5E ", PhotonMicroXS(rea, E[n], 0));
else
fprintf(fp, "%1.5E ", MicroXS(rea, E[n], 0));
/* 0K data */
if ((rea1 = (long)RDB[rea + REACTION_PTR_0K_DATA])
> VALID_PTR)
fprintf(fp, "%1.5E ", MicroXS(rea1, E[n], 0));
/* Majorant */
if ((rea1 = (long)RDB[rea + REACTION_PTR_TMP_MAJORANT])
> VALID_PTR)
fprintf(fp, "%1.5E ", MicroXS(rea1, E[n], 0));
}
fprintf(fp, "\n");
}
fprintf(fp, "];\n\n");
/* Print multi-group cross sections */
if ((long)RDB[DATA_OPTI_MG_MODE] == YES)
{
fprintf(fp, "%s_mg_xs = [\n", tmpstr);
for (n = 0; n < ne; n++)
{
/* Pointer total xs */
rea = (long)RDB[nuc + NUCLIDE_PTR_TOTXS];
CheckPointer(FUNCTION_NAME, "(rea)", DATA_ARRAY, rea);
/* Get cross section */
fprintf(fp, "%1.5E ", MGXS(rea, E[n], -1, 0));
fprintf(fp, "\n");
}
fprintf(fp, "];\n\n");
}
}
/* Next nuclide */
nuc = NextItem(nuc);
}
/***************************************************************************/
/***** Print photon yields *************************************************/
if ((long)RDB[DATA_PHOTON_PRODUCTION] == YES)
{
/* Loop over nuclides */
nuc = (long)RDB[DATA_PTR_NUC0];
while(nuc > VALID_PTR)
{
/* Check if reactions exist */
if ((long)RDB[nuc + NUCLIDE_PTR_PHOTON_PROD] < VALID_PTR)
{
/* Next nuclide */
nuc = NextItem(nuc);
/* Cycle loop */
continue;
}
/* Print mt's */
sprintf(tmpstr, "i%s", GetText(nuc + NUCLIDE_PTR_NAME));
tmpstr[strlen(tmpstr) - 4] = '_';
fprintf(fp, "%s_pprod_mt = [\n", tmpstr);
/* Loop over reactions */
ptr = (long)RDB[nuc + NUCLIDE_PTR_PHOTON_PROD];
while (ptr > VALID_PTR)
{
fprintf(fp, "%ld\n", (long)RDB[ptr + PHOTON_PROD_MT]);
ptr = NextItem(ptr);
}
fprintf(fp, "];\n\n");
/* Print cross sections */
sprintf(tmpstr, "i%s", GetText(nuc + NUCLIDE_PTR_NAME));
tmpstr[strlen(tmpstr) - 4] = '_';
fprintf(fp, "%s_pprod_xs = [\n", tmpstr);
for (n = 0; n < ne; n++)
{
/* Loop over reactions */
ptr = (long)RDB[nuc + NUCLIDE_PTR_PHOTON_PROD];
while (ptr > VALID_PTR)
{
rea1 = (long)RDB[ptr + PHOTON_PROD_PTR_PRODXS];
CheckPointer(FUNCTION_NAME, "(rea1)", DATA_ARRAY, rea1);
fprintf(fp, "%1.5E ", MicroXS(rea1, E[n], 0));
ptr = NextItem(ptr);
}
fprintf(fp, "\n");
}
fprintf(fp, "];\n\n");
/* Next */
nuc = NextItem(nuc);
}
}
/***************************************************************************/
/***** Print photon line spectra *******************************************/
/* Loop over nuclides */
nuc = (long)RDB[DATA_PTR_NUC0];
while(nuc > VALID_PTR)
{
/* Check if line spectra exists */
if ((ptr = (long)RDB[nuc + NUCLIDE_PTR_PHOTON_LINE_SPEC]) > VALID_PTR)
{
/* Set name */
sprintf(tmpstr, "i%s", GetText(nuc + NUCLIDE_PTR_NAME));
if ((long)RDB[nuc + NUCLIDE_TYPE] != NUCLIDE_TYPE_DECAY)
tmpstr[strlen(tmpstr) - 4] = '_';
/* Print spectra */
fprintf(fp, "%s_pspec = [\n", tmpstr);
while (ptr > VALID_PTR)
{
fprintf(fp, "%1.5E %1.5E\n", RDB[ptr + PHOTON_LINE_SPEC_E],
RDB[ptr + PHOTON_LINE_SPEC_RI]);
/* Next line */
ptr = NextItem(ptr);
}
fprintf(fp, "];\n\n");
}
/* Next nuclide */
nuc = NextItem(nuc);
}
/***************************************************************************/
/***** Print nubar data ****************************************************/
/* Loop over nuclides */
nuc = (long)RDB[DATA_PTR_NUC0];
while(nuc > VALID_PTR)
{
/* Pointer to fission channel */
if ((rea = (long)RDB[nuc + NUCLIDE_PTR_FISSXS]) > VALID_PTR)
{
/* Set name */
sprintf(tmpstr, "i%s", GetText(nuc + NUCLIDE_PTR_NAME));
if ((long)RDB[nuc + NUCLIDE_TYPE] != NUCLIDE_TYPE_DECAY)
tmpstr[strlen(tmpstr) - 4] = '_';
/* Print nubars */
fprintf(fp, "%s_nu = [\n", tmpstr);
for (n = 0; n < ne; n++)
{
/* Prompt nubar data */
if ((ptr = (long)RDB[rea + REACTION_PTR_TNUBAR])> VALID_PTR)
fprintf(fp, "%1.5f ", Nubar(ptr, E[n], 0));
/* Delayed nubar data */
if ((ptr = (long)RDB[rea + REACTION_PTR_DNUBAR])> VALID_PTR)
fprintf(fp, "%1.5f ", Nubar(ptr, E[n], 0));
fprintf(fp, "\n");
}
fprintf(fp, "];\n\n");
}
/* Next nuclide */
nuc = NextItem(nuc);
}
/***************************************************************************/
/***** Print energy-dependent isomeric branching ratios ********************/
/* Tää tehtiinkin eri tavalla */
#ifdef mmmmmmmmmmmmmmmmmmmmmm
/* Loop over nuclides */
nuc = (long)RDB[DATA_PTR_NUC0];
while (nuc > VALID_PTR)
{
/* Check pointer to branching data */
if ((long)RDB[nuc + NUCLIDE_BRA_TYPE] != BRA_TYPE_ENE)
{
/* Next nuclide */
nuc = NextItem(nuc);
/* Cycle loop */
continue;
}
/* Set name */
sprintf(tmpstr, "i%s", GetText(nuc + NUCLIDE_PTR_NAME));
tmpstr[strlen(tmpstr) - 4] = '_';
/* Print data */
fprintf(fp, "%s_bra = [\n", tmpstr);
for (n = 0; n < ne; n++)
{
/* Loop over reactions */
rea = (long)RDB[nuc + NUCLIDE_PTR_REA];
while (rea > VALID_PTR)
{
/* Check pointer to branching data */
if ((long)RDB[rea + REACTION_RFS] > 0)
fprintf(fp, "%1.5E ", MicroXS(rea, E[n], 0));
/* Next reaction */
rea = NextItem(rea);
}
fprintf(fp, "\n");
}
fprintf(fp, "];\n\n");
/* Next nuclide */
nuc = NextItem(nuc);
}
#endif
/***************************************************************************/
/***** Print macroscopic cross sections ************************************/
/* Loop over materials */
mat = (long)RDB[DATA_PTR_M0];
while(mat > VALID_PTR)
{
/* Set name */
sprintf(tmpstr, "m%s", GetText(mat + MATERIAL_PTR_NAME));
/* Print reaction mt's */
fprintf(fp, "%s_mt = [\n", tmpstr);
if ((rea = (long)RDB[mat + MATERIAL_PTR_TOTXS]) > VALID_PTR)
fprintf(fp, "%4ld\n", (long)RDB[rea + REACTION_MT]);
if ((rea = (long)RDB[mat + MATERIAL_PTR_ELAXS]) > VALID_PTR)
fprintf(fp, "%4ld\n", (long)RDB[rea + REACTION_MT]);
if ((rea = (long)RDB[mat + MATERIAL_PTR_ABSXS]) > VALID_PTR)
fprintf(fp, "%4ld\n", (long)RDB[rea + REACTION_MT]);
if ((rea = (long)RDB[mat + MATERIAL_PTR_FISSXS]) > VALID_PTR)
fprintf(fp, "%4ld\n", (long)RDB[rea + REACTION_MT]);
if ((rea = (long)RDB[mat + MATERIAL_PTR_HEATTXS]) > VALID_PTR)
fprintf(fp, "%4ld\n", (long)RDB[rea + REACTION_MT]);
if ((rea = (long)RDB[mat + MATERIAL_PTR_PHOTPXS]) > VALID_PTR)
fprintf(fp, "%4ld\n", (long)RDB[rea + REACTION_MT]);
if ((rea = (long)RDB[mat + MATERIAL_PTR_NSF]) > VALID_PTR)
fprintf(fp, "%4ld\n", (long)RDB[rea + REACTION_MT]);
if ((rea = (long)RDB[mat + MATERIAL_PTR_INLPXS]) > VALID_PTR)
fprintf(fp, "%4ld\n", (long)RDB[rea + REACTION_MT]);
if ((rea = (long)RDB[mat + MATERIAL_PTR_TOTPHOTXS]) > VALID_PTR)
fprintf(fp, "%4ld\n", (long)RDB[rea + REACTION_MT]);
if ((rea = (long)RDB[mat + MATERIAL_PTR_HEATPHOTXS]) > VALID_PTR)
fprintf(fp, "%4ld\n", (long)RDB[rea + REACTION_MT]);
if ((rea = (long)RDB[mat + MATERIAL_PTR_TMP_MAJORANTXS]) > VALID_PTR)
fprintf(fp, "%4ld\n", (long)RDB[rea + REACTION_MT]);
fprintf(fp, "];\n\n");
/* Print cross sections */
fprintf(fp, "%s_xs = [\n", tmpstr);
for (n = 0; n < ne; n++)
{
/* Add to counter */
ptr = (long)RDB[DATA_PTR_COLLISION_COUNT];
AddPrivateData(ptr, 1.0, 0);
if ((rea = (long)RDB[mat + MATERIAL_PTR_TOTXS]) > VALID_PTR)
fprintf(fp, "%1.5E ", MacroXS(rea, E[n],0));
if ((rea = (long)RDB[mat + MATERIAL_PTR_ELAXS]) > VALID_PTR)
fprintf(fp, "%1.5E ", MacroXS(rea, E[n],0));
if ((rea = (long)RDB[mat + MATERIAL_PTR_ABSXS]) > VALID_PTR)
fprintf(fp, "%1.5E ", MacroXS(rea, E[n],0));
if ((rea = (long)RDB[mat + MATERIAL_PTR_FISSXS]) > VALID_PTR)
fprintf(fp, "%1.5E ", MacroXS(rea, E[n],0));
if ((rea = (long)RDB[mat + MATERIAL_PTR_HEATTXS]) > VALID_PTR)
fprintf(fp, "%1.5E ", MacroXS(rea, E[n],0));
if ((rea = (long)RDB[mat + MATERIAL_PTR_PHOTPXS]) > VALID_PTR)
fprintf(fp, "%1.5E ", MacroXS(rea, E[n],0));
if ((rea = (long)RDB[mat + MATERIAL_PTR_NSF]) > VALID_PTR)
fprintf(fp, "%1.5E ", MacroXS(rea, E[n],0));
if ((rea = (long)RDB[mat + MATERIAL_PTR_INLPXS]) > VALID_PTR)
fprintf(fp, "%1.5E ", MacroXS(rea, E[n],0));
if ((rea = (long)RDB[mat + MATERIAL_PTR_TOTPHOTXS]) > VALID_PTR)
fprintf(fp, "%1.5E ", PhotonMacroXS(rea, E[n], 0));
if ((rea = (long)RDB[mat + MATERIAL_PTR_HEATPHOTXS]) > VALID_PTR)
fprintf(fp, "%1.5E ", PhotonMacroXS(rea, E[n], 0));
if ((rea = (long)RDB[mat + MATERIAL_PTR_TMP_MAJORANTXS]) > VALID_PTR)
fprintf(fp, "%1.5E ", MacroXS(rea, E[n],0));
fprintf(fp, "\n");
}
fprintf(fp, "];\n\n");
/* Next material */
mat = NextItem(mat);
}
/***************************************************************************/
/***** Print multi-group macroscopic xs ************************************/
/* Check mode */
if ((long)RDB[DATA_OPTI_MG_MODE] == YES)
{
/* Loop over materials */
mat = (long)RDB[DATA_PTR_M0];
while(mat > VALID_PTR)
{
/* Set name */
sprintf(tmpstr, "m%s", GetText(mat + MATERIAL_PTR_NAME));
/* Print cross sections */
fprintf(fp, "%s_mg_xs = [\n", tmpstr);
for (n = 0; n < ne; n++)
{
if ((rea = (long)RDB[mat + MATERIAL_PTR_TOTXS]) > VALID_PTR)
{
if ((ptr = (long)RDB[rea + REACTION_PTR_MGXS]) > VALID_PTR)
fprintf(fp, "%1.5E ", MGXS(rea, E[n], -1, 0));
}
if ((rea = (long)RDB[mat + MATERIAL_PTR_ELAXS]) > VALID_PTR)
{
if ((ptr = (long)RDB[rea + REACTION_PTR_MGXS]) > VALID_PTR)
fprintf(fp, "%1.5E ", MGXS(rea, E[n], -1, 0));
}
if ((rea = (long)RDB[mat + MATERIAL_PTR_ABSXS]) > VALID_PTR)
{
if ((ptr = (long)RDB[rea + REACTION_PTR_MGXS]) > VALID_PTR)
fprintf(fp, "%1.5E ", MGXS(rea, E[n], -1, 0));
}
if ((rea = (long)RDB[mat + MATERIAL_PTR_FISSXS]) > VALID_PTR)
{
if ((ptr = (long)RDB[rea + REACTION_PTR_MGXS]) > VALID_PTR)
fprintf(fp, "%1.5E ", MGXS(rea, E[n], -1, 0));
}
if ((rea = (long)RDB[mat + MATERIAL_PTR_INLPXS]) > VALID_PTR)
{
if ((ptr = (long)RDB[rea + REACTION_PTR_MGXS]) > VALID_PTR)
fprintf(fp, "%1.5E ", MGXS(rea, E[n], -1, 0));
}
fprintf(fp, "\n");
}
fprintf(fp, "];\n\n");
/* Next material */
mat = NextItem(mat);
}
}
/***************************************************************************/
/***** Print majorant ******************************************************/
/* TODO: muuta tohon ne simulation moodit instead */
if ((rea = (long)RDB[DATA_PTR_MAJORANT]) > VALID_PTR)
{
fprintf(fp, "majorant_xs = [\n");
for (n = 0; n < ne; n++)
fprintf(fp, "%1.5E\n", DTMajorant(PARTICLE_TYPE_NEUTRON, E[n],0));
fprintf(fp, "];\n\n");
}
if ((rea = (long)RDB[DATA_PTR_PHOTON_MAJORANT]) > VALID_PTR)
{
fprintf(fp, "photon_majorant_xs = [\n");
for (n = 0; n < ne; n++)
fprintf(fp, "%1.5E\n", DTMajorant(PARTICLE_TYPE_GAMMA, E[n],0));
fprintf(fp, "];\n\n");
}
/***************************************************************************/
/* Free memory */
Mem(MEM_FREE, E);
/* Close file */
fclose(fp);
/* Restore collision count */
ptr = (long)RDB[DATA_PTR_COLLISION_COUNT];
PutPrivateData(ptr, ncol, 0);
/* Exit */
fprintf(out, "OK.\n\n");
}
void CalculateEntropies()
{
long nx, ny, nz, part, i, j, k, idx, ptr;
double xmin, xmax, ymin, ymax, zmin, zmax, x, y, z, wgt, totw, totp;
double *spt, *swg, entrp, entrw, sump, sumw;
/* Check if entropies are calculated */
if ((long)RDB[DATA_OPTI_ENTROPY_CALC] == NO)
return;
/* Get mesh size */
nx = (long)RDB[DATA_ENTROPY_NX];
ny = (long)RDB[DATA_ENTROPY_NY];
nz = (long)RDB[DATA_ENTROPY_NZ];
/* Check values */
CheckValue(FUNCTION_NAME, "nx", "", nx, 1, 500);
CheckValue(FUNCTION_NAME, "ny", "", ny, 1, 500);
CheckValue(FUNCTION_NAME, "nz", "", nz, 1, 500);
/* Get boundaries */
xmin = RDB[DATA_ENTROPY_XMIN];
xmax = RDB[DATA_ENTROPY_XMAX];
ymin = RDB[DATA_ENTROPY_YMIN];
ymax = RDB[DATA_ENTROPY_YMAX];
zmin = RDB[DATA_ENTROPY_ZMIN];
zmax = RDB[DATA_ENTROPY_ZMAX];
/* Check values */
CheckValue(FUNCTION_NAME, "xmin", "", xmin, -INFTY, INFTY);
CheckValue(FUNCTION_NAME, "xmax", "", xmax, -INFTY, INFTY);
CheckValue(FUNCTION_NAME, "ymin", "", ymin, -INFTY, INFTY);
CheckValue(FUNCTION_NAME, "ymax", "", ymax, -INFTY, INFTY);
CheckValue(FUNCTION_NAME, "zmin", "", zmin, -INFTY, INFTY);
CheckValue(FUNCTION_NAME, "zmax", "", zmax, -INFTY, INFTY);
/* Check order */
if (xmin > xmax)
Die(FUNCTION_NAME, "Error in boundaries");
if (ymin > ymax)
Die(FUNCTION_NAME, "Error in boundaries");
if (zmin > zmax)
Die(FUNCTION_NAME, "Error in boundaries");
/* Allocate memory for temporary arrays */
spt = (double *)Mem(MEM_ALLOC, nx*ny*nz, sizeof(double));
swg = (double *)Mem(MEM_ALLOC, nx*ny*nz, sizeof(double));
/* Reset data */
memset(spt, 0.0, nx*ny*nz*sizeof(double));
memset(swg, 0.0, nx*ny*nz*sizeof(double));
/* Reset totals */
totw = 0.0;
totp = 0.0;
/* Pointer to first item after dummy */
part = (long)RDB[DATA_PART_PTR_SOURCE];
part = NextItem(part);
/* Loop over source and collect points */
while(part > VALID_PTR)
{
/* Get coordinates and weight */
x = RDB[part + PARTICLE_X];
y = RDB[part + PARTICLE_Y];
z = RDB[part + PARTICLE_Z];
wgt = RDB[part + PARTICLE_WGT];
/* Get local normalised co-ordinates */
if (xmin != xmax)
x = (x - xmin)/(xmax - xmin);
else
x = 0.0;
if (ymin != ymax)
y = (y - ymin)/(ymax - ymin);
else
y = 0.0;
if (zmin != zmax)
z = (z - zmin)/(zmax - zmin);
else
z = 0.0;
/* Check */
if ((x >= 0.0) && (x < 1.0) && (y >= 0.0) && (y < 1.0) &&
(z >= 0.0) && (z < 1.0))
{
/* Calculate indexes */
i = (long)(x*nx);
j = (long)(y*ny);
k = (long)(z*nz);
/* Calculate index */
idx = i + nx*j + nx*ny*k;
/* Add points and weight */
spt[idx] = spt[idx] + 1.0;
swg[idx] = swg[idx] + wgt;
/* Add to totals */
totp = totp + 1.0;
totw = totw + wgt;
}
/* Next particle */
part = NextItem(part);
}
/* X-component of entropy */
entrp = 0.0;
entrw = 0.0;
for (i = 0; i < nx; i++)
{
/* Sum over values */
sump = 0.0;
sumw = 0.0;
for (j = 0; j < ny; j++)
for (k = 0; k < nz; k++)
{
/* Calculate index */
idx = i + nx*j + nx*ny*k;
/* Add to sums */
sump = sump + spt[idx]/totp;
sumw = sumw + swg[idx]/totw;
}
/* Add to entropies */
if ((sump > 0.0) && (sump < 1.0))
entrp = entrp - sump*log2(sump);
if ((sumw > 0.0) && (sumw < 1.0))
entrw = entrw - sumw*log2(sumw);
}
/* Divide by uniform source entropy */
if (nx > 1)
{
entrp = entrp/log2(nx);
entrw = entrw/log2(nx);
}
/* Add to statistics */
ptr = (long)RDB[DATA_ENTROPY_PTR_SPT_STAT];
AddStat(entrp, ptr, 1);
ptr = (long)RDB[DATA_ENTROPY_PTR_SWG_STAT];
AddStat(entrw, ptr, 1);
/* Y-component of entropy */
entrp = 0.0;
entrw = 0.0;
for (j = 0; j < ny; j++)
{
/* Sum over values */
sump = 0.0;
sumw = 0.0;
for (i = 0; i < nx; i++)
for (k = 0; k < nz; k++)
{
/* Calculate index */
idx = i + nx*j + nx*ny*k;
/* Add to sums */
sump = sump + spt[idx]/totp;
sumw = sumw + swg[idx]/totw;
}
/* Add to entropies */
if ((sump > 0.0) && (sump < 1.0))
entrp = entrp - sump*log2(sump);
if ((sumw > 0.0) && (sumw < 1.0))
entrw = entrw - sumw*log2(sumw);
}
/* Divide by uniform source entropy */
if (ny > 1)
{
entrp = entrp/log2(ny);
entrw = entrw/log2(ny);
}
/* Add to statistics */
ptr = (long)RDB[DATA_ENTROPY_PTR_SPT_STAT];
AddStat(entrp, ptr, 2);
ptr = (long)RDB[DATA_ENTROPY_PTR_SWG_STAT];
AddStat(entrw, ptr, 2);
/* Z-component of entropy */
entrp = 0.0;
entrw = 0.0;
for (k = 0; k < nz; k++)
{
/* Sum over values */
sump = 0.0;
sumw = 0.0;
for (i = 0; i < nx; i++)
for (j = 0; j < ny; j++)
{
/* Calculate index */
idx = i + nx*j + nx*ny*k;
/* Add to sums */
sump = sump + spt[idx]/totp;
sumw = sumw + swg[idx]/totw;
}
/* Add to entropies */
if ((sump > 0.0) && (sump < 1.0))
entrp = entrp - sump*log2(sump);
if ((sumw > 0.0) && (sumw < 1.0))
entrw = entrw - sumw*log2(sumw);
}
/* Divide by uniform source entropy */
if (nz > 1)
{
entrp = entrp/log2(nz);
entrw = entrw/log2(nz);
}
/* Add to statistics */
ptr = (long)RDB[DATA_ENTROPY_PTR_SPT_STAT];
AddStat(entrp, ptr, 3);
ptr = (long)RDB[DATA_ENTROPY_PTR_SWG_STAT];
AddStat(entrw, ptr, 3);
/* Total entropy */
entrp = 0.0;
entrw = 0.0;
/* Loop over values */
for (i = 0; i < nx; i++)
for (j = 0; j < ny; j++)
for (k = 0; k < nz; k++)
{
/* Calculate index */
idx = i + nx*j + nx*ny*k;
/* Get value */
sump = spt[idx]/totp;
sumw = swg[idx]/totw;
/* Add to entropies */
if ((sump > 0.0) && (sump < 1.0))
entrp = entrp - sump*log2(sump);
if ((sumw > 0.0) && (sumw < 1.0))
entrw = entrw - sumw*log2(sumw);
}
/* Divide by uniform source entropy */
if (nx*ny*nz > 1)
{
entrp = entrp/log2(nx*ny*nz);
entrw = entrw/log2(nx*ny*nz);
}
/* Add to statistics */
ptr = (long)RDB[DATA_ENTROPY_PTR_SPT_STAT];
AddStat(entrp, ptr, 0);
ptr = (long)RDB[DATA_ENTROPY_PTR_SWG_STAT];
AddStat(entrw, ptr, 0);
/* Free temporary arrays */
Mem(MEM_FREE, spt);
Mem(MEM_FREE, swg);
}
/*!
\todo better zero copy handling
*/
filepos_t KaxInternalBlock::ReadData(IOCallback & input, ScopeMode ReadFully)
{
filepos_t Result;
FirstFrameLocation = input.getFilePointer(); // will be updated accordingly below
SetValueIsSet(false);
try {
if (ReadFully == SCOPE_ALL_DATA) {
Result = EbmlBinary::ReadData(input, ReadFully);
if (Result != GetSize())
throw SafeReadIOCallback::EndOfStreamX(GetSize() - Result);
binary *BufferStart = EbmlBinary::GetBuffer();
SafeReadIOCallback Mem(*this);
uint8 BlockHeadSize = 4;
// update internal values
TrackNumber = Mem.GetUInt8();
if ((TrackNumber & 0x80) == 0) {
// there is extra data
if ((TrackNumber & 0x40) == 0) {
// We don't support track numbers that large !
throw SafeReadIOCallback::EndOfStreamX(0);
}
TrackNumber = (TrackNumber & 0x3F) << 8;
TrackNumber += Mem.GetUInt8();
BlockHeadSize++;
} else {
TrackNumber &= 0x7F;
}
LocalTimecode = int16(Mem.GetUInt16BE());
bLocalTimecodeUsed = true;
uint8 Flags = Mem.GetUInt8();
if (EbmlId(*this) == EBML_ID(KaxSimpleBlock)) {
bIsKeyframe = (Flags & 0x80) != 0;
bIsDiscardable = (Flags & 0x01) != 0;
}
mInvisible = (Flags & 0x08) >> 3;
mLacing = LacingType((Flags & 0x06) >> 1);
// put all Frames in the list
if (mLacing == LACING_NONE) {
FirstFrameLocation += Mem.GetPosition();
DataBuffer * soloFrame = new DataBuffer(BufferStart + Mem.GetPosition(), GetSize() - BlockHeadSize);
myBuffers.push_back(soloFrame);
SizeList.resize(1);
SizeList[0] = GetSize() - BlockHeadSize;
} else {
// read the number of frames in the lace
uint32 LastBufferSize = GetSize() - BlockHeadSize - 1; // 1 for number of frame
uint8 FrameNum = Mem.GetUInt8(); // number of frames in the lace - 1
// read the list of frame sizes
uint8 Index;
int32 FrameSize;
uint32 SizeRead;
uint64 SizeUnknown;
SizeList.resize(FrameNum + 1);
switch (mLacing) {
case LACING_XIPH:
for (Index=0; Index<FrameNum; Index++) {
// get the size of the frame
FrameSize = 0;
uint8 Value;
do {
Value = Mem.GetUInt8();
FrameSize += Value;
LastBufferSize--;
} while (Value == 0xFF);
SizeList[Index] = FrameSize;
LastBufferSize -= FrameSize;
}
SizeList[Index] = LastBufferSize;
break;
case LACING_EBML:
SizeRead = LastBufferSize;
FrameSize = ReadCodedSizeValue(BufferStart + Mem.GetPosition(), SizeRead, SizeUnknown);
SizeList[0] = FrameSize;
Mem.Skip(SizeRead);
LastBufferSize -= FrameSize + SizeRead;
for (Index=1; Index<FrameNum; Index++) {
// get the size of the frame
SizeRead = LastBufferSize;
FrameSize += ReadCodedSizeSignedValue(BufferStart + Mem.GetPosition(), SizeRead, SizeUnknown);
SizeList[Index] = FrameSize;
Mem.Skip(SizeRead);
LastBufferSize -= FrameSize + SizeRead;
}
if (Index <= FrameNum) // Safety check if FrameNum == 0
SizeList[Index] = LastBufferSize;
break;
case LACING_FIXED:
for (Index=0; Index<=FrameNum; Index++) {
// get the size of the frame
SizeList[Index] = LastBufferSize / (FrameNum + 1);
}
break;
default: // other lacing not supported
assert(0);
}
FirstFrameLocation += Mem.GetPosition();
for (Index=0; Index<=FrameNum; Index++) {
DataBuffer * lacedFrame = new DataBuffer(BufferStart + Mem.GetPosition(), SizeList[Index]);
myBuffers.push_back(lacedFrame);
Mem.Skip(SizeList[Index]);
}
}
binary *BufferEnd = BufferStart + GetSize();
size_t NumFrames = myBuffers.size();
// Sanity checks for frame pointers and boundaries.
for (size_t Index = 0; Index < NumFrames; ++Index) {
binary *FrameStart = myBuffers[Index]->Buffer();
binary *FrameEnd = FrameStart + myBuffers[Index]->Size();
binary *ExpectedEnd = (Index + 1) < NumFrames ? myBuffers[Index + 1]->Buffer() : BufferEnd;
if ((FrameStart < BufferStart) || (FrameEnd > BufferEnd) || (FrameEnd != ExpectedEnd))
throw SafeReadIOCallback::EndOfStreamX(0);
}
SetValueIsSet();
} else if (ReadFully == SCOPE_PARTIAL_DATA) {
binary _TempHead[5];
Result = input.read(_TempHead, 5);
if (Result != 5)
throw SafeReadIOCallback::EndOfStreamX(0);
binary *cursor = _TempHead;
binary *_tmpBuf;
uint8 BlockHeadSize = 4;
// update internal values
TrackNumber = *cursor++;
if ((TrackNumber & 0x80) == 0) {
// there is extra data
if ((TrackNumber & 0x40) == 0) {
// We don't support track numbers that large !
return Result;
}
TrackNumber = (TrackNumber & 0x3F) << 8;
TrackNumber += *cursor++;
BlockHeadSize++;
} else {
TrackNumber &= 0x7F;
}
big_int16 b16;
b16.Eval(cursor);
LocalTimecode = int16(b16);
bLocalTimecodeUsed = true;
cursor += 2;
if (EbmlId(*this) == EBML_ID(KaxSimpleBlock)) {
bIsKeyframe = (*cursor & 0x80) != 0;
bIsDiscardable = (*cursor & 0x01) != 0;
}
mInvisible = (*cursor & 0x08) >> 3;
mLacing = LacingType((*cursor++ & 0x06) >> 1);
if (cursor == &_TempHead[4]) {
_TempHead[0] = _TempHead[4];
} else {
Result += input.read(_TempHead, 1);
}
FirstFrameLocation += cursor - _TempHead;
// put all Frames in the list
if (mLacing != LACING_NONE) {
// read the number of frames in the lace
uint32 LastBufferSize = GetSize() - BlockHeadSize - 1; // 1 for number of frame
uint8 FrameNum = _TempHead[0]; // number of frames in the lace - 1
// read the list of frame sizes
uint8 Index;
int32 FrameSize;
uint32 SizeRead;
uint64 SizeUnknown;
SizeList.resize(FrameNum + 1);
switch (mLacing) {
case LACING_XIPH:
for (Index=0; Index<FrameNum; Index++) {
// get the size of the frame
FrameSize = 0;
do {
Result += input.read(_TempHead, 1);
FrameSize += uint8(_TempHead[0]);
LastBufferSize--;
FirstFrameLocation++;
} while (_TempHead[0] == 0xFF);
FirstFrameLocation++;
SizeList[Index] = FrameSize;
LastBufferSize -= FrameSize;
}
SizeList[Index] = LastBufferSize;
break;
case LACING_EBML:
SizeRead = LastBufferSize;
cursor = _tmpBuf = new binary[FrameNum*4]; /// \warning assume the mean size will be coded in less than 4 bytes
Result += input.read(cursor, FrameNum*4);
FrameSize = ReadCodedSizeValue(cursor, SizeRead, SizeUnknown);
SizeList[0] = FrameSize;
cursor += SizeRead;
LastBufferSize -= FrameSize + SizeRead;
for (Index=1; Index<FrameNum; Index++) {
// get the size of the frame
SizeRead = LastBufferSize;
FrameSize += ReadCodedSizeSignedValue(cursor, SizeRead, SizeUnknown);
SizeList[Index] = FrameSize;
cursor += SizeRead;
LastBufferSize -= FrameSize + SizeRead;
}
FirstFrameLocation += cursor - _tmpBuf;
SizeList[Index] = LastBufferSize;
delete [] _tmpBuf;
break;
case LACING_FIXED:
for (Index=0; Index<=FrameNum; Index++) {
// get the size of the frame
SizeList[Index] = LastBufferSize / (FrameNum + 1);
}
break;
default: // other lacing not supported
assert(0);
}
} else {
SizeList.resize(1);
SizeList[0] = GetSize() - BlockHeadSize;
}
SetValueIsSet(false);
Result = GetSize();
} else {
///////////////////////////////////////////////////////////////////////////////////////////////////
//应用程序读设备数据时(应用程序调用ReadFile函数)，系统会调用此函数
NTSTATUS KadyUsbTestDevice::Read(KIrp I)
{
NTSTATUS status = STATUS_INSUFFICIENT_RESOURCES;
//声明变量，接收实际读取的字节数
ULONG dwBytesRead = 0;
//URB
PURB pUrb = NULL;
//获取应用程序内存对象
KMemory Mem(I.Mdl());
//检查缓冲区长度
ULONG dwTotalSize = I.ReadSize(CURRENT); //应用程序要读取的字节数
ULONG dwMaxSize = EndPoint1In.MaximumTransferSize(); //端点能传输的最大字节数
if ( dwTotalSize > dwMaxSize )
{
//如果要读取的字节数超过端点的最大长度，则设置为最大长度
ASSERT(dwMaxSize);
dwTotalSize = dwMaxSize;
}
if(UsbdPipeTypeBulk == EndPoint2Out.Type())
{
pUrb = EndPoint1In.BuildBulkTransfer(
Mem, //数据缓冲区
dwTotalSize, //要读取的字节数
TRUE, //输入
NULL //下一个URB(无)
);
}
else if(UsbdPipeTypeInterrupt == EndPoint2Out.Type())
{
pUrb = EndPoint1In.BuildInterruptTransfer(
Mem, //数据缓冲区
dwTotalSize, //要读取的字节数
TRUE, //允许接收的字节数小于需求字节数
NULL, //下一个URB(无)
NULL, //当前USB(无，则创建新的)
TRUE //读数据
);
}
//判断创建URB是否成功
if ( pUrb != NULL)
{
//设置为直接读取方式，允许接收字节数小于要求的字节数
pUrb->UrbBulkOrInterruptTransfer.TransferFlags =
(USBD_TRANSFER_DIRECTION_IN | USBD_SHORT_TRANSFER_OK);
//提交URB
status = EndPoint1In.SubmitUrb(pUrb, NULL, NULL,1000);
//获取实际读取的字节数
if ( NT_SUCCESS(status) )
{
dwBytesRead = pUrb->UrbBulkOrInterruptTransfer.TransferBufferLength;
}
delete pUrb;
}
//向应用程序返回实际读取的字节数
I.Information() = dwBytesRead;
//结束IRP操作
return I.PnpComplete(this, status, IO_NO_INCREMENT);
}
