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(); /***************************************************************************/ }