void ComboBox::MouseEventProc(MOUSE_EVENT_RECORD mer) {
if (displayList) {
if (checkPosition(mer) && mer.dwButtonState == FROM_LEFT_1ST_BUTTON_PRESSED) {
CloseList();
return;
}
string prevChose = optionsList->GetValue();
optionsList->MouseEventProc(mer);
string chose = optionsList->GetValue();
if (prevChose != chose) {
CloseList();
}
chosenText->CleanLabel();
if (chose != "no choose") {
chose[0] = '+';
chose[1] = ' ';
chose[2] = ' ';
}
else {
chose = "+ ";
}
chosenText->SwitchContent(chose);
}
else {
if (checkPosition(mer) && mer.dwButtonState == FROM_LEFT_1ST_BUTTON_PRESSED) {
OpenList();
}
}
}
void ComboBox::KeyEventProc(KEY_EVENT_RECORD ker) {
if (displayList) {
if (ker.wVirtualKeyCode == VK_ESCAPE) {
CloseList();
return;
}
string prevChose = optionsList->GetValue();
optionsList->KeyEventProc(ker);
string chose = optionsList->GetValue();
if (prevChose != chose) {
CloseList();
}
chosenText->CleanLabel();
if (chose != "no choose") {
chose[0] = '-';
chose[1] = ' ';
chose[2] = ' ';
}
else {
chose = "- ";
}
chosenText->SwitchContent(chose);
}
else {
if (ker.wVirtualKeyCode == VK_RETURN && displayList) {
OpenList();
}
}
}
void MakeRing(long ptr)
{
long first, last;
/* Check pointer */
CheckPointer(FUNCTION_NAME, "(ptr)", DATA_ARRAY, ptr);
/* Close list */
CloseList(ptr);
/* Get pointer to first and last */
first = FirstItem(ptr);
last = LastItem(ptr);
/* Combine pointers */
WDB[first + LIST_PTR_PREV] = (double)last;
WDB[last + LIST_PTR_NEXT] = (double)first;
}
long CreateUniverse(long loc0, char *name, long level)
{
long loc1, loc2, lst, ptr, uni, cell, nst, reg, lat, pbd, umsh, stl, n;
/* Check level count */
if (level > MAX_GEOMETRY_LEVELS)
Error(loc0, "Maximum number of geometry levels exceeded (infinite loop?)");
/* Compare level to maximum */
if (level + 1 > (long)RDB[DATA_GEOM_LEVELS])
WDB[DATA_GEOM_LEVELS] = (double)(level + 1.0);
/***************************************************************************/
/***** Check if universe exists ********************************************/
/* Loop over universes */
uni = RDB[DATA_PTR_U0];
while (uni > VALID_PTR)
{
/* Compare names */
if (!strcmp(GetText(uni + UNIVERSE_PTR_NAME), name))
return uni;
/* Next universe */
uni = NextItem(uni);
}
/* Create new universe */
uni = NewItem(DATA_PTR_U0, UNIVERSE_BLOCK_SIZE);
/* Put name */
WDB[uni + UNIVERSE_PTR_NAME] = (double)PutText(name);
/* Put level */
WDB[uni + UNIVERSE_LEVEL] = (double)level;
/* Reset pointers */
WDB[uni + UNIVERSE_PTR_CELL_LIST] = NULLPTR;
WDB[uni + UNIVERSE_PTR_NEST] = NULLPTR;
WDB[uni + UNIVERSE_PTR_LAT] = NULLPTR;
WDB[uni + UNIVERSE_PTR_PBED] = NULLPTR;
WDB[uni + UNIVERSE_PTR_UMSH] = NULLPTR;
WDB[uni + UNIVERSE_PTR_SYM] = NULLPTR;
/* Allocate memory for collision counter */
AllocValuePair(uni + UNIVERSE_COL_COUNT);
/* Allocate memory for coordinates */
ptr = AllocPrivateData(1, PRIVA_ARRAY);
WDB[uni + UNIVERSE_PTR_PRIVA_X] = (double)ptr;
ptr = AllocPrivateData(1, PRIVA_ARRAY);
WDB[uni + UNIVERSE_PTR_PRIVA_Y] = (double)ptr;
ptr = AllocPrivateData(1, PRIVA_ARRAY);
WDB[uni + UNIVERSE_PTR_PRIVA_Z] = (double)ptr;
/* Onko tän ajan pakko olla universe-rakenteessa? */
ptr = AllocPrivateData(1, PRIVA_ARRAY);
WDB[uni + UNIVERSE_PTR_PRIVA_T] = (double)ptr;
/* Allocate memory for previous region */
ptr = AllocPrivateData(1, PRIVA_ARRAY);
WDB[uni + UNIVERSE_PTR_PREV_REG] = (double)ptr;
/***************************************************************************/
/***** Cells ***************************************************************/
/* Loop over cells */
cell = RDB[DATA_PTR_C0];
while (cell > VALID_PTR)
{
/* Compare names and check used-flag */
if (!((long)RDB[cell + CELL_OPTIONS] & OPT_USED))
if (CompareStr(cell + CELL_PTR_UNI, uni + UNIVERSE_PTR_NAME))
{
/* Set used-flag */
SetOption(cell + CELL_OPTIONS, OPT_USED);
/* Put pointer */
WDB[cell + CELL_PTR_UNI] = (double)uni;
/* Create new item in universe cell list */
lst = NewItem(uni + UNIVERSE_PTR_CELL_LIST, CELL_LIST_BLOCK_SIZE);
/* Put pointer */
WDB[lst + CELL_LIST_PTR_CELL] = (double)cell;
/* Allocate memory from private array */
ptr = AllocPrivateData(1, PRIVA_ARRAY);
/* Put pointer */
WDB[lst + CELL_LIST_PTR_COUNT] = (double)ptr;
/* Check if fill pointer is set */
if (RDB[cell + CELL_PTR_FILL] > VALID_PTR)
{
/* Call recursively */
sprintf(name, "%s", GetText(cell + CELL_PTR_FILL));
loc1 = CreateUniverse(cell, name, level + 1);
/* Put pointer */
WDB[cell + CELL_PTR_FILL] = (double)loc1;
}
/* Put universe type */
WDB[uni + UNIVERSE_TYPE] = (double)UNIVERSE_TYPE_CELL;
}
/* Next cell */
cell = NextItem(cell);
}
/* Check if cells are defined */
if ((ptr = (long)RDB[uni + UNIVERSE_PTR_CELL_LIST]) > 0)
{
/* Close list (NOTE: Tää oli processinput.c:ssä 8.11.2010 asti) */
CloseList(ptr);
/* Return pointer to universe */
return uni;
}
/***************************************************************************/
/***** Nests ***************************************************************/
/* Loop over nests */
nst = RDB[DATA_PTR_NST0];
while (nst > VALID_PTR)
{
/* Compare names and check used-flag */
if ((CompareStr(nst + NEST_PTR_NAME, uni + UNIVERSE_PTR_NAME)) &
!((long)RDB[nst + NEST_OPTIONS] & OPT_USED))
{
/* Set used-flag */
SetOption(nst + NEST_OPTIONS, OPT_USED);
/* Put pointers */
WDB[nst + NEST_PTR_UNI] = (double)uni;
WDB[uni + UNIVERSE_PTR_NEST] = (double)nst;
/* Get pointer to regions */
reg = (long)RDB[nst + NEST_PTR_REGIONS];
CheckPointer(FUNCTION_NAME, "(reg)", DATA_ARRAY, reg);
/* Close list */
CloseList(reg);
/* Loop over regions */
while (reg > VALID_PTR)
{
/* Check if fill pointer is set */
if (RDB[reg + NEST_REG_PTR_FILL] > VALID_PTR)
{
/* Call recursively */
sprintf(name, "%s", GetText(reg + NEST_REG_PTR_FILL));
loc1 = CreateUniverse(nst, name, level + 1);
/* Put pointer */
WDB[reg + NEST_REG_PTR_FILL] = (double)loc1;
}
/* Next region */
reg = NextItem(reg);
}
/* Put universe type */
WDB[uni + UNIVERSE_TYPE] = (double)UNIVERSE_TYPE_NEST;
/* Return pointer to universe */
return uni;
}
/* Next nest */
nst = NextItem(nst);
}
/***************************************************************************/
/***** Lattices ************************************************************/
/* Loop over lattices */
lat = RDB[DATA_PTR_L0];
while (lat > VALID_PTR)
{
/* Compare names and check used-flag */
if ((CompareStr(lat + LAT_PTR_NAME, uni + UNIVERSE_PTR_NAME)) &
!((long)RDB[lat + LAT_OPTIONS] & OPT_USED))
{
/* Set used-flag */
SetOption(lat + LAT_OPTIONS, OPT_USED);
/* Put pointers */
WDB[lat + LAT_PTR_UNI] = (double)uni;
WDB[uni + UNIVERSE_PTR_LAT] = (double)lat;
/* Check type */
if ((long)RDB[lat + LAT_TYPE] == LAT_TYPE_CLU)
{
/***** Circular array ******************************************/
/* Get pointer to rings */
reg = (long)RDB[lat + LAT_PTR_FILL];
CheckPointer(FUNCTION_NAME, "(reg)", DATA_ARRAY, reg);
/* Loop over rings */
while (reg > VALID_PTR)
{
/* Loop over items */
ptr = (long)RDB[reg + RING_PTR_FILL];
while ((long)RDB[ptr] > VALID_PTR)
{
/* Call recursively */
sprintf(name, "%s", GetText(ptr));
loc1 = CreateUniverse(lat, name, level + 1);
/* Put pointer */
WDB[ptr++] = (double)loc1;
}
/* Next region */
reg = NextItem(reg);
}
/***************************************************************/
}
else
{
/***** Simple types ********************************************/
/* Loop over items */
ptr = (long)RDB[lat + LAT_PTR_FILL];
while ((long)RDB[ptr] > VALID_PTR)
{
/* Get universe name */
sprintf(name, "%s", GetText(ptr));
/* Check if intentionally undefined (dots) */
for (n = 0; n < strlen(name); n++)
if (name[n] != '.')
break;
/* Call recursively or put null pointer */
if (n < strlen(name))
loc1 = CreateUniverse(lat, name, level + 1);
else
loc1 = NULLPTR;
/* Put pointer */
WDB[ptr++] = (double)loc1;
}
/***************************************************************/
}
/* Put universe type */
WDB[uni + UNIVERSE_TYPE] = (double)UNIVERSE_TYPE_LATTICE;
/* Return pointer to universe */
return uni;
}
/* Next lattice */
lat = NextItem(lat);
}
/***************************************************************************/
/***** Pebble-bed geometries ***********************************************/
/* Loop over geometries */
pbd = RDB[DATA_PTR_PB0];
while (pbd > VALID_PTR)
{
/* Compare names and check used-flag */
if ((CompareStr(pbd + PBED_PTR_NAME, uni + UNIVERSE_PTR_NAME)) &
!((long)RDB[pbd + PBED_OPTIONS] & OPT_USED))
{
/* Set used-flag */
SetOption(pbd + PBED_OPTIONS, OPT_USED);
/* Put pointers */
WDB[pbd + PBED_PTR_UNI] = (double)uni;
WDB[uni + UNIVERSE_PTR_PBED] = (double)pbd;
/* Call recursively for background universe */
sprintf(name, "%s", GetText(pbd + PBED_PTR_BG_UNIV));
loc1 = CreateUniverse(pbd, name, level + 1);
/* Put pointer */
WDB[pbd + PBED_PTR_BG_UNIV] = (double)loc1;
/* Loop over pebbles */
loc1 = (long)RDB[pbd + PBED_PTR_PEBBLES];
while (loc1 > VALID_PTR)
{
/* Call recursively for pebble */
sprintf(name, "%s", GetText(loc1 + PEBBLE_PTR_UNIV));
ptr = CreateUniverse(pbd, name, level + 1);
/* Put pointer */
WDB[loc1 + PEBBLE_PTR_UNIV] = (double)ptr;
/* Loop over types */
loc2 = (long)RDB[pbd + PBED_PTR_PEBBLE_TYPES];
while(loc2 > VALID_PTR)
{
/* Compare universe pointer */
if ((long)RDB[loc2 + PEBTYPE_PTR_UNIV] == ptr)
{
/* Add counter */
WDB[loc2 + PEBTYPE_COUNT] =
RDB[loc2 + PEBTYPE_COUNT] + 1.0;
/* Break loop */
break;
}
/* Next type */
loc2 = NextItem(loc2);
}
/* Check pointer */
if (loc2 < VALID_PTR)
{
/* No previous definition */
loc2 = NewItem(pbd + PBED_PTR_PEBBLE_TYPES,
PEBTYPE_BLOCK_SIZE);
/* Put universe pointer */
WDB[loc2 + PEBTYPE_PTR_UNIV] = (double)ptr;
/* Init counter */
WDB[loc2 + PEBTYPE_COUNT] = 1.0;
}
/* Next pebble */
loc1 = NextItem(loc1);
}
/* Put universe type */
WDB[uni + UNIVERSE_TYPE] = (double)UNIVERSE_TYPE_PBED;
/* Return pointer to universe */
return uni;
}
/* Next geometry */
pbd = NextItem(pbd);
}
/***************************************************************************/
/***** Unstructured mesh based geometries **********************************/
/* Loop over geometries */
umsh = RDB[DATA_PTR_UMSH0];
while (umsh > VALID_PTR)
{
/* Compare names and check used-flag */
if ((CompareStr(umsh + UMSH_PTR_NAME, uni + UNIVERSE_PTR_NAME)) &
!((long)RDB[umsh + UMSH_OPTIONS] & OPT_USED))
{
/* Set used-flag */
SetOption(umsh + UMSH_OPTIONS, OPT_USED);
/* Put pointers */
WDB[umsh + UMSH_PTR_UNI] = (double)uni;
WDB[uni + UNIVERSE_PTR_UMSH] = (double)umsh;
/* Call recursively for background universe */
sprintf(name, "%s", GetText(umsh + UMSH_PTR_BG_UNIV));
loc1 = CreateUniverse(umsh, name, level + 1);
/* Put pointer */
WDB[umsh + UMSH_PTR_BG_UNIV] = (double)loc1;
/* Put universe type */
WDB[uni + UNIVERSE_TYPE] = (double)UNIVERSE_TYPE_UMSH;
/* Allocate memory for next cell */
AllocValuePair(uni + UNIVERSE_PTR_NEXT_CELL);
/* Return pointer to universe */
return uni;
}
/* Next geometry */
umsh = NextItem(umsh);
}
/***************************************************************************/
/***** STL geometries ******************************************************/
/* Loop over geometries */
stl = RDB[DATA_PTR_STL0];
while (stl > VALID_PTR)
{
/* Compare names and check used-flag */
if ((CompareStr(stl + STL_PTR_NAME, uni + UNIVERSE_PTR_NAME)) &
!((long)RDB[stl + STL_OPTIONS] & OPT_USED))
{
/* Set used-flag */
SetOption(stl + STL_OPTIONS, OPT_USED);
/* Put pointers */
WDB[stl + STL_PTR_UNI] = (double)uni;
WDB[uni + UNIVERSE_PTR_STL] = (double)stl;
/* Call recursively for background universe */
sprintf(name, "%s", GetText(stl + STL_PTR_BG_UNIV));
loc1 = CreateUniverse(stl, name, level + 1);
/* Put pointer */
WDB[stl + STL_PTR_BG_UNIV] = (double)loc1;
/* Put universe type */
WDB[uni + UNIVERSE_TYPE] = (double)UNIVERSE_TYPE_STL;
/* Return pointer to universe */
return uni;
}
/* Next geometry */
stl = NextItem(stl);
}
/***************************************************************************/
/* Universe is not defined */
if ((level == 0) && ((long)RDB[DATA_PTR_ROOT_UNIVERSE] < VALID_PTR))
Error(loc0, "Root universe %s is not defined", name);
else
Error(loc0, "Universe %s is not defined", name);
/* Avoid compiler warning */
return NULLPTR;
}
int mainprog(void)
{
int nfds = getdtablesize();
struct timeval timeout;
fd_set rfds;
struct sockaddr_in sonadr;
int fd;
CLIENT *client=NULL;
FD_ZERO(&fd_clients);
InitChListe(&PLCs);
InitChListe(&TAGs);
InitChListe(&CLIENTs);
InitChListe(&SESSIONs);
InitChListe(&CONNECTIONs);
if (GetPlc(&PLCs,Alias)<=0)
{
Log(LOG_CRIT,"Alias File is empty\n");
return(T_Error);
}
Server=OpenServerSock(SPort);
if (Server<0)
{
Log(LOG_CRIT,"Error creating Server socket : %s\n",strerror(errno));
return(T_Error);
}
SetCoe(Server);
FD_SET(Server,&fd_clients);
while ((!Terminated))
{
memcpy(&rfds, &fd_clients, sizeof(rfds));
timeout.tv_sec=ScanRate;
timeout.tv_usec=uScanRate;
switch (select(nfds, &rfds, 0, 0,&timeout))
{
case -1:if(errno == EINTR) continue;
else
{
Log(LOG_WARNING,"surveillance des descripteurs : %s\n",strerror(errno));
break;
}
case 0:
{ // timeout
//continue;
break;
}
default:
if(FD_ISSET(Server, &rfds))
{
int taille = sizeof (sonadr);
if((fd = accept(Server, (struct sockaddr *)&sonadr,(socklen_t *)&taille))==-1)
{
Log(LOG_WARNING, "accept: connexion impossible (%s)\n",strerror(errno));
} else
{
Log(LOG_INFO,"Connexion d'un client depuis %s (socket : %d)\n", inet_ntoa(sonadr.sin_addr),fd);
SetCoe(fd);
client=malloc(sizeof(CLIENT));
if (client!=NULL)
{
if (AddChListe(&CLIENTs,client)>0)
{ /* ajout du client dans les socket à surveiller */
memset(client,0,sizeof(CLIENT));
client->FD=fd;
FD_SET(fd, &fd_clients);
fcntl(fd, F_SETFL, O_NONBLOCK | fcntl(fd, F_GETFL, 0));
Log(LOG_INFO,"Client connecté depuis %s (socket : %d)\n", inet_ntoa(sonadr.sin_addr),fd);
} else
{
close(fd);
Log(LOG_CRIT, "Erreur à l'ajout du client (%s)\n",strerror(errno));
}
} else
{
close(fd);
Log(LOG_WARNING, "Erreur à la création du client (%s)\n",strerror(errno));
}
}
}
/* Tester si les sockets clientes ont bougées */
for(fd=0; fd<nfds; fd++ )
{
if((fd != Server) && FD_ISSET(fd, &rfds))
{
/* Recherche du client */
client=FindClient(fd,&CLIENTs);
if (client==NULL)
{
Log(LOG_WARNING, "Client inconnu !!! (socket : %d)--\n",fd);
close(fd);
FD_CLR(fd, &fd_clients);
Reply(fd,"Erreur interne (line : %d)\n",__LINE__);
continue;
}
switch (lire_client(client))
{
case 0:
RemoveChListe(&CLIENTs,client);
free(client);
close(fd);
FD_CLR(fd, &fd_clients);
Log(LOG_INFO, "-- perte d'un client ! (socket : %d)--\n",fd);
continue;
default:/* Traitement requete */
Log(LOG_DEBUG,"<-Client : %p (buffersize : %d)\n",client,client->InBuffer.size);
Traite(client);
continue;
}
}
}
break;
}
/* Checking Tag inactivity */
if (TAGs.Count>0)
{
time_t now=time(NULL);
ELEMENT *elt=GetFirst(&TAGs);
if (elt!=NULL) do
{
TAG *tag=elt->Data;
if ((now-tag->Time_Value)>INACTIVITY_TO)
{
ELEMENT *elt_old=elt;
Log(LOG_DEBUG,"\t-Deleting Tag %s on %s (%p / %p)\n",tag->TagName,tag->Plc->PlcName,tag,elt);
elt=GetNext(&TAGs,elt);
RemoveChListe_Ex(&TAGs,elt_old);
free(elt_old);
if (tag->Plc!=NULL)
{
tag->Plc->References--;
if (tag->Plc->References<=0)
{
Log(LOG_DEBUG,"No more Tag on plc : %s\n",tag->Plc->PlcName);
DisconnectPlc(tag->Plc);
}
}
free(tag);
continue;
}
} while ((elt=GetNext(&TAGs,elt))!=NULL);
}
}
close(Server);
Log(LOG_DEBUG,"Killing all connections\n");
KillConnections();
Log(LOG_DEBUG,"Closing list TAGs : %d counts\n",TAGs.Count);
CloseList(&TAGs);
Log(LOG_DEBUG,"Closing list PLCs : %d counts\n",PLCs.Count);
CloseList(&PLCs);
Log(LOG_DEBUG,"Closing list CLIENTs : %d counts\n",CLIENTs.Count);
CloseList(&CLIENTs);
return(0);
}
void ProcessFinix()
{
long msh0, i,j, fib, npins;
double val;
Rod *rod;
Boundary_conditions *bc;
Scenario *scenario;
Results *results;
Options *options;
char **err=NULL;
/* Check that some finix pins are defined */
if ((fib = (long)RDB[DATA_PTR_FIN0]) < VALID_PTR)
return;
/* Close list to allow omp-loops over it later */
CloseList(fib);
fprintf(out, "Processing Finix pins\n");
/* reset number of pins */
npins = 0;
/* Loop over FINIX definitions */
while (fib > VALID_PTR)
{
/* Link power binning here */
msh0 = (long)RDB[DATA_PTR_FINBIN0];
while (msh0 > VALID_PTR)
{
/* Compare name */
if (CompareStr(msh0 + MESH_PTR_NAME, fib + FINIX_PTR_POWMSH))
break;
/* Next possible binning mesh */
msh0 = NextItem(msh0);
}
/* Check that power binning was found */
if (msh0 < VALID_PTR)
Error(fib, "Power binning \"%s\" not defined", GetText(fib + FINIX_PTR_POWMSH));
/* Put direct pointer to mesh */
WDB[fib + FINIX_PTR_POWMSH] = (double)msh0;
/* Construct arrays */
rod = finix_rod_construct();
bc = finix_bc_construct();
scenario = finix_scenario_construct();
results = finix_results_construct();
options = finix_options_construct();
/* Store pointers */
WDB[fib + FINIX_PTR_ROD] = (double)((long)rod);
WDB[fib + FINIX_PTR_BC] = (double)((long)bc);
WDB[fib + FINIX_PTR_SCENARIO] = (double)((long)scenario);
WDB[fib + FINIX_PTR_RESULTS] = (double)((long)results);
WDB[fib + FINIX_PTR_OPTIONS] = (double)((long)options);
/* Create finix_rod.inp for this rod */
WriteFinixInputFile(fib, FILE_TYPE_ROD);
/* Create finix_options.inp for this rod */
WriteFinixInputFile(fib, FILE_TYPE_OPTIONS);
/* Create finix_scenario.inp for this rod */
WriteFinixInputFile(fib, FILE_TYPE_SCENARIO);
/* Initialize data structures */
err = finix_initialize_data_structures(rod, bc, scenario, results, options);
/* Handle errors */
if (err != NULL)
{
finix_printf_err(err);
Die(FUNCTION_NAME, "Error in initialization of FINIX data structures");
}
finix_free_err(&err);
/* Put zero linear power to all axial segments */
for (i = 0 ; i < options->axial_nodes ; i++)
bc->linear_power[i] = 0.0;
/* Set radial nodes to equal-distance, rather than equal area */
for (i = 0 ; i < options->axial_nodes ; i++)
{
/* Pellet */
for (j = 0; j < options->pellet_radial_nodes ; j++)
{
val = rod->pellet_inner_radius
+ (double)j/(double)(options->pellet_radial_nodes - 1)*
(rod->pellet_outer_radius - rod->pellet_inner_radius);
results->radial_node_position[i][j] = val;
results->radial_node_position_cold[i][j] = val;
}
/* Clad */
for (; j < options->pellet_radial_nodes
+ options->clad_radial_nodes ; j++)
{
val = rod->clad_inner_radius
+ (double)(j - options->pellet_radial_nodes)/
(double)(options->clad_radial_nodes - 1)*
(rod->clad_outer_radius - rod->clad_inner_radius);
results->radial_node_position[i][j] = val;
results->radial_node_position_cold[i][j] = val;
}
}
/* Solve initial steady state (HZP) */
err = finix_solve_initial_steady_state(rod, bc, results, options);
/* Handle errors */
if (err != NULL)
{
finix_printf_err(err);
Die(FUNCTION_NAME, "Error in initialization of FINIX data structures");
}
finix_free_err(&err);
npins++;
/* Process next pin */
fib = NextItem(fib);
}
/* Store total number of pins (needed for interface file) */
fib = RDB[DATA_PTR_FIN0];
while(fib > VALID_PTR)
{
WDB[fib + FINIX_N_PIN] = (double)npins;
fib = NextItem(fib);
}
/* Set Density Factor usage on */
WDB[DATA_USE_DENSITY_FACTOR] = (double)YES;
/* Read initial conditions */
ReadFinixIFC();
/* Write pins to an interface file */
WriteFinixIFC();
/* Create interface data structure */
CreateFinixIFC();
}
void ProcessDecaySrc()
{
long mat, iso, nuc, ptr, src;
double vol, adens, lambda, tot, prev, I;
fprintf(out, "Processing decay source...\n");
/* Check total source rate */
if (RDB[DATA_TOT_PHOTON_SRC_RATE] == 0.0)
Error(0, "Total photon source rate is zero in decay source mode");
/* Loop over materials */
mat = (long)RDB[DATA_PTR_M0];
while (mat > VALID_PTR)
{
/* Get volume */
vol = RDB[mat + MATERIAL_VOLUME];
/* Check total photon source rate */
if ((vol == 0.0) || ((RDB[mat + MATERIAL_PHOTON_SRC_RATE]/
RDB[DATA_TOT_PHOTON_SRC_RATE]) < 1E-19))
{
/* Next material */
mat = NextItem(mat);
/* Cycle loop */
continue;
}
/* Check that pointer is not defined (NOTE: Tää on lähinnä sitä */
/* varten että jos tätä rutiinia joskus kutsutaan silmukasta niin */
/* muistia ei varata turhaan. */
if ((long)RDB[mat + MATERIAL_PTR_DECAY_SRC] > VALID_PTR)
Die(FUNCTION_NAME, "Pointer to decay source already exists");
/* Avoid compiler warning */
src = -1;
/* Reset total */
tot = 0.0;
/* Loop over composition */
iso = (long)RDB[mat + MATERIAL_PTR_ORIG_NUC_COMP];
while (iso > VALID_PTR)
{
/* Get atomic density */
adens = RDB[iso + COMPOSITION_ADENS]*1E+24;
/* Get pointer to nuclide data */
nuc = (long)RDB[iso + COMPOSITION_PTR_NUCLIDE];
CheckPointer(FUNCTION_NAME, "(nuc)", DATA_ARRAY, nuc);
/* Get decay constant */
lambda = RDB[nuc + NUCLIDE_LAMBDA];
/* Get total intensity */
I = RDB[nuc + NUCLIDE_SPEC_PHOTON_I];
/* Check intensity */
if (I*lambda*adens*vol/RDB[mat + MATERIAL_PHOTON_SRC_RATE] < 1E-18)
{
/* Skip nuclide */
iso = NextItem(iso);
/* Cycle loop */
continue;
}
/* Create entry */
src = NewItem(mat + MATERIAL_PTR_DECAY_SRC, SRC_DECCAY_BLOCK_SIZE);
/* Put nuclide pointer */
WDB[src + SRC_DECCAY_PTR_NUCLIDE] = (double)nuc;
/* Put emission rate */
WDB[src + SRC_DECCAY_I] = I*lambda*adens*vol;
/* Reset weight */
WDB[src + SRC_DECCAY_WGT] = 1.0;
/* Add to total */
tot = tot + RDB[src + SRC_DECCAY_I];
/* Put pointer to line spectra */
ptr = (long)RDB[nuc + NUCLIDE_PTR_PHOTON_LINE_SPEC];
CheckPointer(FUNCTION_NAME, "(ptr)", DATA_ARRAY, ptr);
WDB[src + SRC_DECCAY_PTR_SPEC] = (double)ptr;
/* Next nuclide */
iso = NextItem(iso);
}
/* Check if source was created */
if (src > VALID_PTR)
{
/* Close list */
CloseList(src);
/* Sort */
SortList(src, SRC_DECCAY_I, SORT_MODE_DESCEND);
/* Check total */
if (tot == 0.0)
Die(FUNCTION_NAME, "WTF?");
/* Calculate cumulative probabilities */
prev = 0.0;
src = (long)RDB[mat + MATERIAL_PTR_DECAY_SRC];
while (src > VALID_PTR)
{
/* Calculate cumulative probability */
WDB[src + SRC_DECCAY_CUM_P] =
(prev + RDB[src + SRC_DECCAY_I])/tot;
/* Update previous */
prev = prev + RDB[src + SRC_DECCAY_I];
/* Next */
src = NextItem(src);
}
/* Allocate memory for sampled stats */
ptr = NewStat("SAMPLED_PHOTON_SRC", 1, 1);
WDB[mat + MATERIAL_SAMPLED_PHOTON_SRC] = (double)ptr;
}
/* Next material */
mat = NextItem(mat);
}
fprintf(out, "OK.\n\n");
}
void ProcessMaterials()
{
long mat, ptr, nmat, nbumat, i, TMS, iso, nuc;
double T;
/* Check burnup step */
if ((long)RDB[DATA_BURN_STEP] > 0)
Die(FUNCTION_NAME, "Should not be here");
/* Pointer to material list */
if ((mat = (long)RDB[DATA_PTR_M0]) < VALID_PTR)
Error(0, "No material definitions");
/***************************************************************************/
/***** Finalize material compositions **************************************/
fprintf(out, "Normalizing compositions and processing mixtures...\n");
/* Calculate fractions */
mat = (long)RDB[DATA_PTR_M0];
while (mat > VALID_PTR)
{
IsotopeFractions(mat);
mat = NextItem(mat);
}
/* Process mixtures */
mat = (long)RDB[DATA_PTR_M0];
while (mat > VALID_PTR)
{
ProcessMixture(mat, 0);
mat = NextItem(mat);
}
fprintf(out, "OK.\n\n");
/* Replace isotopic with atomic data in photon transport calculation */
/* (NOTE: tätä kutsutaan myöhemmin myös tuolla alempana). */
ReplacePhotonData();
/***************************************************************************/
/***** Sort composition for better memory management ***********************/
/* Check if macroscopic cross sections are pregenerated (if */
/* number of materials is large, the calculation hangs here) */
if ((long)RDB[DATA_OPTI_RECONSTRUCT_MACROXS] == YES)
{
/* Use MPI task numbers to remember initial order */
i = 0;
mat = (long)RDB[DATA_PTR_M0];
while (mat > VALID_PTR)
{
/* Check divided and burn flags */
if ((long)RDB[mat + MATERIAL_DIV_TYPE] == MAT_DIV_TYPE_PARENT)
WDB[mat + MATERIAL_MPI_ID] = 1E+12;
else if (!((long)RDB[mat + MATERIAL_OPTIONS] & OPT_BURN_MAT))
WDB[mat + MATERIAL_MPI_ID] = 1E+11;
else
WDB[mat + MATERIAL_MPI_ID] = (double)(i++);
/* Next material */
mat = NextItem(mat);
}
/* Use OpenMP thread number for sort */
i = 0;
mat = (long)RDB[DATA_PTR_M0];
while (mat > VALID_PTR)
{
/* Check divided and burn flags */
if ((long)RDB[mat + MATERIAL_DIV_TYPE] == MAT_DIV_TYPE_PARENT)
WDB[mat + MATERIAL_OMP_ID] = 1E+12;
else if (!((long)RDB[mat + MATERIAL_OPTIONS] & OPT_BURN_MAT))
WDB[mat + MATERIAL_OMP_ID] = 1E+11;
else
{
/* Set id */
WDB[mat + MATERIAL_OMP_ID] = (double)(i++);
/* Check id */
if (i == (long)RDB[DATA_OMP_MAX_THREADS])
i = 0;
}
/* Next material */
mat = NextItem(mat);
}
/* Sort */
mat = (long)RDB[DATA_PTR_M0];
SortList(mat, MATERIAL_OMP_ID, SORT_MODE_ASCEND);
}
/***************************************************************************/
/***** Allocate memory and process *****************************************/
/* Process compositions of burnable materials */
BurnMatCompositions();
/* Put composition to divided materials */
PutCompositions();
/* Override material compositions */
ReadMaterialComp();
/* Process burnable materials */
ProcessBurnMat();
/* Calculate masses (to get the value on output) */
CalculateMasses();
/* Close composition lists */
mat = (long)RDB[DATA_PTR_M0];
while (mat > VALID_PTR)
{
ptr = (long)RDB[mat + MATERIAL_PTR_COMP];
CloseList(ptr);
/* Tämä on lista alkuperäiseen nuklidikoostumukseen joka korvataan */
/* alkuainekohtaisella koostumuksella fotonitransportmoodissa jos */
/* inputti on annettu neutronidatana (JLe 3.6.2015 / 2.1.24). */
if ((ptr = (long)RDB[mat + MATERIAL_PTR_ORIG_NUC_COMP]) > VALID_PTR)
CloseList(ptr);
mat = NextItem(mat);
}
/* Check temperatures and TMS flags */
mat = (long)RDB[DATA_PTR_M0];
while (mat > VALID_PTR)
{
/* Get temperature */
T = RDB[mat + MATERIAL_DOPPLER_TEMP];
/* Get TMS flag */
if (RDB[mat + MATERIAL_TMS_MODE] != TMS_MODE_NONE)
TMS = NUCLIDE_FLAG_TMS;
else
TMS = 0;
/* 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);
/* Skip lost */
if (nuc == (long)RDB[DATA_PTR_NUCLIDE_LOST])
{
/* Next */
iso = NextItem(iso);
/* Cycle loop */
continue;
}
/* Compare temperature */
if ((T > 0) && (T != RDB[nuc + NUCLIDE_TEMP]))
Die(FUNCTION_NAME, "Error in temperature: %s %s %E %E",
GetText(mat + MATERIAL_PTR_NAME),
GetText(nuc + NUCLIDE_PTR_NAME), T, RDB[nuc + NUCLIDE_TEMP]);
/* Check TMS flag */
if (TMS != ((long)RDB[nuc + NUCLIDE_TYPE_FLAGS] & NUCLIDE_FLAG_TMS))
Die(FUNCTION_NAME, "Error in TMS flag %s %ld %ld",
GetText(nuc + NUCLIDE_PTR_NAME), TMS,
((long)RDB[nuc + NUCLIDE_TYPE_FLAGS] & NUCLIDE_FLAG_TMS));
/* Check TMS limits */
if (TMS != NO)
{
/* Check minimum */
if (RDB[nuc + NUCLIDE_TMS_MIN_TEMP] >
RDB[mat + MATERIAL_TMS_TMIN])
Die(FUNCTION_NAME, "Error in TMS Tmin: %s %s %E %E",
GetText(mat + MATERIAL_PTR_NAME),
GetText(nuc + NUCLIDE_PTR_NAME),
RDB[nuc + NUCLIDE_TMS_MIN_TEMP],
RDB[mat + MATERIAL_TMS_TMIN]);
/* Check maximum */
if (RDB[nuc + NUCLIDE_TMS_MAX_TEMP] <
RDB[mat + MATERIAL_TMS_TMAX])
Die(FUNCTION_NAME, "Error in TMS Tmax: %s %s %E %E",
GetText(mat + MATERIAL_PTR_NAME),
GetText(nuc + NUCLIDE_PTR_NAME),
RDB[nuc + NUCLIDE_TMS_MAX_TEMP],
RDB[mat + MATERIAL_TMS_TMAX]);
}
/* Next */
iso = NextItem(iso);
}
/* Next material */
mat = NextItem(mat);
}
/* Allocate memory for reaction lists and macroscopic cross sections */
AllocMacroXS();
/* Sort composition to get initial order */
if ((long)RDB[DATA_OPTI_RECONSTRUCT_MACROXS] == YES)
{
mat = (long)RDB[DATA_PTR_M0];
SortList(mat, MATERIAL_MPI_ID, SORT_MODE_ASCEND);
}
/* Re-read compositions from restart file (JLe: tämä pitää lukea uudestaan */
/* siitä syystä että alialuejako tehdään vasta PutCompositions():issa, jota */
/* kutsutaan tuolla ylempänä). */
ReadRestartFile(RESTART_OVERRIDE);
/* Replace isotopic with atomic data in photon transport calculation */
/* (JLe: Tätä joudutaan kutsumaan uudestaan että myös alialueiden */
/* koostumukset menee oikein). */
ReplacePhotonData();
/* Check if decay source is used */
if ((long)RDB[DATA_USE_DECAY_SRC] == YES)
{
/* Calculate activities (Aktiivisuudet lasketaan uudestaan */
/* transportcycle.c:n lopussa.) */
CalculateActivities();
/* Process decay source */
ProcessDecaySrc();
/* Print gamma source (spectra for testing) */
PrintGammaSpectra();
}
/* Process photon data if photon transport mode */
if ((long)RDB[DATA_PHOTON_TRANSPORT_MODE] == YES) {
/* Process photon attenuation data */
ProcessPhotonAtt();
/* Process TTB */
if ((long)RDB[DATA_PHOTON_USE_TTB] == YES)
ProcessTTB();
/* Process atomic relaxation */
ProcessRelaxation();
}
/***************************************************************************/
/***** Assign MPI numbers to materials *************************************/
/* NOTE: tää pitää miettiä uudestaan niin että toi järjestys menee */
/* jotenkin fiksusti */
/* Set MPI id's */
i = 0;
mat = (long)RDB[DATA_PTR_M0];
while (mat > VALID_PTR)
{
/* Check burn-flag */
if ((long)RDB[mat + MATERIAL_OPTIONS] & OPT_BURN_MAT)
{
/* Set id (MSR-palamarutiinit pitää suorittaa yhdellä */
/* MPI-taskilla) */
if ((long)RDB[mat + MATERIAL_FLOW_IDX] == 0)
WDB[mat + MATERIAL_MPI_ID] = (double)(i++);
else
WDB[mat + MATERIAL_MPI_ID] = 0.0;
/* Check id */
if (i == mpitasks)
i = 0;
}
else
WDB[mat + MATERIAL_MPI_ID] = -1.0;
/* Reset OpenMP thread number */
WDB[mat + MATERIAL_OMP_ID] = -1.0;
/* Next material */
mat = NextItem(mat);
}
/***************************************************************************/
/***** Count materials and set indexes for printout ************************/
/* Reset counters */
nmat = 0;
nbumat = 0;
/* Loop over materials */
mat = (long)RDB[DATA_PTR_M0];
while (mat > VALID_PTR)
{
/* Add total counter */
nmat++;
/* Put index */
WDB[mat + MATERIAL_PROC_IDX] = (double)nmat;
/* Check burn flag */
if (((long)RDB[mat + MATERIAL_OPTIONS] & OPT_BURN_MAT) &&
((long)RDB[mat + MATERIAL_DIV_TYPE] != MAT_DIV_TYPE_PARENT))
{
/* Add burn counter */
nbumat++;
/* Put index */
WDB[mat + MATERIAL_BURN_IDX] = (double)nmat;
}
/* Next material */
mat = NextItem(mat);
}
/* Put counters */
WDB[DATA_N_MATERIALS] = (double)nmat;
WDB[DATA_N_BURN_MATERIALS] = (double)nbumat;
/***************************************************************************/
/***** Calculate memory size and print summary *****************************/
/* Calculated divided material total memory */
mat = (long)RDB[DATA_PTR_M0];
while (mat > VALID_PTR)
{
/* Check pointer to parent */
if ((ptr = (long)RDB[mat + MATERIAL_DIV_PTR_PARENT]) > VALID_PTR)
WDB[ptr + MATERIAL_TOT_DIV_MEM_SIZE] =
RDB[ptr + MATERIAL_TOT_DIV_MEM_SIZE] + RDB[mat + MATERIAL_MEM_SIZE];
/* Next material */
mat = NextItem(mat);
}
/* Print material data */
PrintMaterialData();
/***************************************************************************/
}
