double inter_paraboloide(t_cam *eye, t_obj *o)
{
double a;
double b;
double c;
double delta;
double tan_square;
double k;
t_vector p;
tan_square = pow(tan(o->size), 2.0);
a = pow(eye->v.x, 2.0)
+ pow(eye->v.y, 2.0);
b = 2 * (eye->pos.x * eye->v.x
+ eye->pos.y * eye->v.y)
- tan_square * eye->v.z;
c = pow(eye->pos.x, 2.0)
+ pow(eye->pos.y, 2.0)
- tan_square * eye->pos.z;
delta = pow(b, 2.0) - (4.0 * a * c);
k = solve_eq(a, b, delta);
p = eq_parametric(eye->pos, eye->v, k);
if (double_are_same(check_limit(p, o), -1.0))
return (-1.0);
return (k);
}
void log_flush_remote(struct log_context *logctx)
{
char *msg = 0;
// check to see if we have a rate limit catchup to send
if (logctx->remote_limited && check_limit(logctx->remote_ratelimit, 0)) {
msg = malloc(MAX_PACKET_SIZE + 1);
bzero(msg, MAX_PACKET_SIZE + 1);
switch (logctx->remote_format) {
case TYPE_TEXT:
snprintf(msg, MAX_PACKET_SIZE,
"Tripwire has dropped %d events due to ratelimiting\n",
logctx->remote_limited);
break;
case TYPE_CEF:
snprintf(msg, MAX_PACKET_SIZE,
"CEF:0|||||Tripwire Rate Limiting Activated.||msg=Tripware has dropped %d events due to ratelimiting",
logctx->remote_limited);
break;
}
switch (logctx->remote_type) {
case TRANS_UDP:
log_msg_udp(logctx, msg);
break;
case TRANS_TCP:
log_msg_tcp(logctx, msg);
break;
}
free(msg);
logctx->remote_limited = 0;
}
}
static
rc_t KTocEntryInflateNodeSoftLink (KToc * toc, const KTocEntryInflateCommon * common,
const void ** ptr, uint64_t offset, const void * limit, bool rev)
{
rc_t rc;
uint16_t llen;
char * link;
rc = read_u16 (ptr, limit, rev, &llen);
if (rc)
return rc;
if (check_limit (*ptr, limit, llen))
return RC (rcFS, rcTocEntry, rcParsing, rcBuffer, rcTooShort);;
link = malloc (llen + 1);
if (link == NULL)
return RC (rcFS, rcTocEntry, rcParsing, rcMemory, rcExhausted);
memmove (link, *ptr, llen);
link[llen] = '\0';
rc = KTocCreateSoftLink (toc,
common->mtime,
common->access,
(KCreateMode)(kcmInit|kcmParents),
link,
common->name);
free (link);
return rc;
}
// Peform the AST passes on the given AST up to the speficied last pass
static bool ast_passes(ast_t** astp, pass_opt_t* options, pass_id last)
{
assert(astp != NULL);
bool r;
if(!visit_pass(astp, options, last, &r, PASS_SUGAR, pass_sugar, NULL))
return r;
if(options->check_tree)
check_tree(*astp, options->check.errors);
if(!visit_pass(astp, options, last, &r, PASS_SCOPE, pass_scope, NULL))
return r;
if(!visit_pass(astp, options, last, &r, PASS_IMPORT, pass_import, NULL))
return r;
if(!visit_pass(astp, options, last, &r, PASS_NAME_RESOLUTION, NULL,
pass_names))
return r;
if(!visit_pass(astp, options, last, &r, PASS_FLATTEN, NULL, pass_flatten))
return r;
if(!visit_pass(astp, options, last, &r, PASS_TRAITS, pass_traits, NULL))
return r;
if(!check_limit(astp, options, PASS_DOCS, last))
return true;
if(options->docs && ast_id(*astp) == TK_PROGRAM)
generate_docs(*astp, options);
if(!visit_pass(astp, options, last, &r, PASS_EXPR, pass_pre_expr, pass_expr))
return r;
if(!check_limit(astp, options, PASS_FINALISER, last))
return true;
if(!pass_finalisers(*astp, options))
return false;
if(options->check_tree)
check_tree(*astp, options->check.errors);
return true;
}
static void
check_limits(const char *line, struct pattern_rule *rule, regmatch_t *parens, time_t tstamp)
{
char **entry;
for (entry = rule->limits; *entry != NULL; entry++) {
check_limit(*entry, line, rule, parens, tstamp);
}
}
void
Main_GUI::set_defaults()
{
min_box->setValue(hinting_range_min);
max_box->setValue(hinting_range_max);
fallback_box->setCurrentIndex(latin_fallback);
limit_box->setValue(hinting_limit ? hinting_limit : hinting_range_max);
// handle command line option `--hinting-limit=0'
if (!hinting_limit)
{
hinting_limit = max_box->value();
no_limit_box->setChecked(true);
}
increase_box->setValue(increase_x_height ? increase_x_height
: TA_INCREASE_X_HEIGHT);
// handle command line option `--increase-x-height=0'
if (!increase_x_height)
{
increase_x_height = TA_INCREASE_X_HEIGHT;
no_increase_box->setChecked(true);
}
snapping_line->setText(x_height_snapping_exceptions_string);
if (windows_compatibility)
wincomp_box->setChecked(true);
if (pre_hinting)
pre_box->setChecked(true);
if (hint_with_components)
hint_box->setChecked(true);
if (symbol)
symbol_box->setChecked(true);
if (!no_info)
info_box->setChecked(true);
if (gray_strong_stem_width)
gray_box->setChecked(true);
if (gdi_cleartype_strong_stem_width)
gdi_box->setChecked(true);
if (dw_cleartype_strong_stem_width)
dw_box->setChecked(true);
run_button->setEnabled(false);
check_min();
check_max();
check_limit();
check_no_limit();
check_no_increase();
check_number_set();
}
double calc_k_sphere(t_vect *o, t_vect *u, t_obj *obj)
{
t_vect tmp;
double x1;
double x2;
tmp.x = (u->x * u->x + u->y * u->y + u->z * u->z);
tmp.y = 2 * (o->x * u->x + o->y * u->y + o->z * u->z);
tmp.z = (o->x * o->x + o->y * o->y + o->z * o->z - obj->param * obj->param);
if (res_eq_sc(&tmp, &x1, &x2))
{
if ((x1 * norme(u)) > PAS && x1 < x2 && check_limit(o, u, x1, obj))
return (x1);
else if ((x2 * norme(u)) > PAS && check_limit(o, u, x2, obj))
return (x2);
else
return (-1);
}
else
return (-1);
}
/*
* mr_admin - ADMIN command handler
* parv[0] = sender prefix
* parv[1] = servername
*/
static int
mr_admin(struct Client *client_p, struct Client *source_p, int parc, const char *parv[])
{
static time_t last_used = 0L;
static int count;
if (!check_limit(source_p, &last_used, &count, "ADMIN"))
return 0;
do_admin(source_p);
return 0;
}
static
rc_t read_u8 (const void ** _ptr, const void * limit, uint8_t * pout)
{
const uint8_t * ptr;
if (check_limit (*_ptr, limit, sizeof (uint8_t)))
return RC (rcFS, rcTocEntry, rcParsing, rcBuffer, rcTooShort);
ptr = *_ptr;
*pout = *ptr++;
*_ptr = ptr;
return 0;
}
/**
* Read an argument converted in string, either in hex or decimal.
* Report an error if it wasn't declared correctly.
*
* min: minimum value of decimal number
* max: maximum value of decimal number
* hex: can it be a hex value?
* return: value in decimal
*/
lld read_constant(char* buffer, int line, lld min, lld max,
bool hex, regex_t* decimal_regex, regex_t* hex_regex) {
lld tmp_lld;
if (match(decimal_regex, buffer)) {
// save value
tmp_lld = atol(buffer);
/* Since its a decimal value, make sure
* it has a proper size */
check_limit(min, max, tmp_lld, line);
} else if (match(hex_regex, buffer)) {
// save value as decimal
sscanf(buffer, "%llx", &tmp_lld);
} else {
// none of them, report an error!
report_error(strcat(buffer, " is not a valid argument!"), line, 1);
}
return tmp_lld;
}
double inter_cone(t_obj *obj, t_calc *calc)
{
t_coord abc;
double delta;
t_coord tmp_view;
t_coord tmp_eye;
double res;
init_view(&tmp_eye, &tmp_view, obj, calc);
abc.x = (SQ(VIEW_X) + SQ(VIEW_Y) -
((SQ(VIEW_Z)) / SQ(tan(RAD(ANGLE)))));
abc.y = ((EYE_X * 2 * VIEW_X) + (EYE_Y * 2 * VIEW_Y) -
((EYE_Z * 2 * VIEW_Z) / SQ(tan(RAD(ANGLE)))));
abc.z = (SQ(EYE_X) + SQ(EYE_Y) -
(SQ(EYE_Z) / SQ(tan(RAD(ANGLE)))));
delta = SQ(abc.y) - (4 * abc.x * abc.z);
res = calc_delta(&abc, delta);
if (res != -1.0 && (obj->typdef.size_x != -1 || obj->typdef.size_y != -1))
res = check_limit(obj, res, &tmp_eye, &tmp_view);
return (res);
}
/*
** m_info
** parv[0] = sender prefix
** parv[1] = servername
*/
static int
m_info(struct Client *client_p, struct Client *source_p, int parc, const char *parv[])
{
static time_t last_used = 0L;
static int count;
if (!check_limit(source_p, &last_used, &count, "INFO")) {
sendto_one_numeric(source_p, RPL_ENDOFINFO, form_str(RPL_ENDOFINFO));
return 0;
}
if(hunt_server(client_p, source_p, ":%s INFO :%s", 1, parc, parv) != HUNTED_ISME)
return 0;
info_spy(source_p);
SetCork(source_p);
send_info_text(source_p);
send_birthdate_online_time(source_p);
ClearCork(source_p);
sendto_one_numeric(source_p, RPL_ENDOFINFO, form_str(RPL_ENDOFINFO));
return 0;
}
// Perform an ast_visit pass, after checking the pass limits.
// Returns true to continue, false to stop processing and return the value in
// out_r.
static bool visit_pass(ast_t** astp, pass_opt_t* options, pass_id last_pass,
bool* out_r, pass_id pass, ast_visit_t pre_fn, ast_visit_t post_fn)
{
assert(out_r != NULL);
if(!check_limit(astp, options, pass, last_pass))
{
*out_r = true;
return false;
}
//fprintf(stderr, "Pass %s (last %s) on %s\n", pass_name(pass),
// pass_name(last_pass), ast_get_print(*astp));
if(ast_visit(astp, pre_fn, post_fn, options, pass) != AST_OK)
{
*out_r = false;
return false;
}
return true;
}
void log_event_remote(struct log_context *logctx, struct sockaddr_in *remote,
struct sockaddr_in *local)
{
char *msg = 0;
// check for rate limiting
if (logctx->remote_ratelimit
&& !check_limit(logctx->remote_ratelimit, 1)) {
logctx->remote_limited++;
} else {
// flush logs and catch up alerts
log_flush(logctx);
// send alert
switch (logctx->remote_format) {
case TYPE_TEXT:
text_format(&msg, remote, local, logctx);
break;
case TYPE_CEF:
cef_format(&msg, remote, local, logctx);
break;
}
// send alert to remote location
switch (logctx->remote_type) {
case TRANS_UDP:
log_msg_udp(logctx, msg);
break;
case TRANS_TCP:
log_msg_tcp(logctx, msg);
break;
}
// free the message allocated by *_format()
free(msg);
}
}
int do_icache_dump(cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
{
int cache_status = icache_status();
if (cache_status)
icache_disable();
uint32_t cmd_base, tag, cache_upper, cache_lower;
size_t way, way_start = 0, way_end = 3;
size_t sbnk, sbnk_start = 0, sbnk_end = 3;
size_t set, set_start = 0, set_end = 31;
size_t dw;
if (argc > 1) {
way_start = way_end = simple_strtoul(argv[1], NULL, 10);
if (argc > 2) {
sbnk_start = sbnk_end = simple_strtoul(argv[2], NULL, 10);
if (argc > 3)
set_start = set_end = simple_strtoul(argv[3], NULL, 10);
}
}
if (check_limit("way", 0, 3, way_start, way_end) || \
check_limit("subbank", 0, 3, sbnk_start, sbnk_end) || \
check_limit("set", 0, 31, set_start, set_end))
return 1;
puts("Way:Subbank:Set: [valid-tag lower upper] {invalid-tag lower upper}...\n");
for (way = way_start; way <= way_end; ++way) {
for (sbnk = sbnk_start; sbnk <= sbnk_end; ++sbnk) {
for (set = set_start; set <= set_end; ++set) {
printf("%zu:%zu:%2zu: ", way, sbnk, set);
for (dw = 0; dw < 4; ++dw) {
if (ctrlc())
return 1;
cmd_base = \
(way << 26) | \
(sbnk << 16) | \
(set << 5) | \
(dw << 3);
/* first read the tag */
bfin_write_ITEST_COMMAND(cmd_base | 0x0);
SSYNC();
tag = bfin_read_ITEST_DATA0();
printf("%c%08x ", (tag & 0x1 ? ' ' : '{'), tag);
/* grab the data at this loc */
bfin_write_ITEST_COMMAND(cmd_base | 0x4);
SSYNC();
cache_lower = bfin_read_ITEST_DATA0();
cache_upper = bfin_read_ITEST_DATA1();
printf("%08x %08x%c ", cache_lower, cache_upper, (tag & 0x1 ? ' ' : '}'));
}
puts("\n");
}
}
}
if (cache_status)
icache_enable();
return 0;
}
//place_halos():
//
//Takes a list of halo masses (Nhalos, HaloMass), a list of particles (NTotPart,PartX,PartY,PartZ), some simulation parameters (L, mp), and user-defined parameters (Nlin,rho_ref,alpha,Malpha,Nalpha,seed)
//and returns a list of halo positions and radii (HaloX,HaloY,HaloZ,HaloR)
int place_halos(long Nend, float *HaloMass, long Nlin, long NTotPart, float *PartX, float *PartY, float *PartZ, float *PartVX, float *PartVY, float *PartVZ,float L, float rho_ref, long seed, float mp, double *alpha, int *Nhalosbin,long Nalpha,float *HaloX, float *HaloY, float *HaloZ, float *HaloVX, float *HaloVY, float *HaloVZ,float *HaloR,long **ListOfPart, long *NPartPerCell){
fprintf(stderr,"\tThis is place_halos.c v11\n");
//Initiallising -------------------------------------------------
long i,j,k,lin_ijk,check, Nmin;
long *count,trials;
long ihalo, ipart,Halos_done;
double invL = 1./L;
float Mcell,Mhalo;
float R;
time_t t0;
int i_alpha;
long icell;
double mpart;
double exponent;
double TotProb;
double *MassLeft;
double *CumulativeProb;
long **ListOfHalos, *NHalosPerCell;
long Nstart=0,Nhalos;
#ifdef VERB
time_t t1,t2,t3,t4,t5,tI,tII;
float diff;
#endif
NCells = Nlin;
Lbox = L;
t0=time(NULL);
NTotCells = NCells*NCells*NCells;
MassLeft = malloc(NTotCells*sizeof(double));
fprintf(stderr,"N[0]=%ld, N[1]=%ld, N[2]=%ld, \n",NPartPerCell[0],NPartPerCell[1],NPartPerCell[2]);
//Allocate memory for the arrays
//NPartPerCell = (long *) calloc(NTotCells,sizeof(long));
/* if( NPartPerCell == NULL) {
fprintf(stderr,"\tplace_halos(): could not allocate %ld array for NPartPerCell[]\nABORTING",NTotCells);
exit(-1);
}*/
NHalosPerCell = (long *) calloc(NTotCells,sizeof(long));
if(NHalosPerCell == NULL) {
fprintf(stderr,"\tplace_halos(): could not allocate %ld array for NHalosPerCell[]\nABORTING",NTotCells);
exit(-1);
}
count = (long *) calloc(NTotCells,sizeof(long));
if(count == NULL) {
fprintf(stderr,"\tplace_halos(): could not allocate %ld array for NTotCells[]\nABORTING",NTotCells);
exit(-1);
}
CumulativeProb = (double *) calloc(NTotCells, sizeof(double));
if(CumulativeProb == NULL) {
fprintf(stderr,"\tplace_halos(): could not allocate %ld array for CumulativeProb[]\nABORTING",NTotCells);
exit(-1);
}
fprintf(stderr,"\tUsing OMP with %d threads\n",omp_get_max_threads());
#ifdef MASS_OF_PARTS
Nexcluded = (long *) calloc(NTotCells,sizeof(long));
if(Nexcluded == NULL) {
fprintf(stderr,"\tplace_halos(): could not allocate %ld array for Nexcluded[]\nABORTING",NTotCells);
exit(-1);
}
excluded = (int *) calloc(NTotPart, sizeof(long));
if(excluded == NULL) {
fprintf(stderr,"\tplace_halos(): could not allocate %ld array for excluded[]\nABORTING",NTotPart);
exit(-1);
}
#endif
//Initiallise random numbers
#ifdef VERB
fprintf(stderr,"\tinput seed: %ld. time0: %ld.",seed,t0);
#endif
if (seed>=0){
srand(seed);
#ifdef VERB
fprintf(stderr,"Used: %ld \n",seed);
#endif
}
else {
srand(t0);
fprintf(stderr,"Seed Used: %ld \n",t0);
}
mpart = (double) mp;
//Nmin = (long)ceil(HaloMass[Nhalos-1]/mpart);
Nmin = (long)ceil(HaloMass[Nend-1]*0.8/mpart);
lcell = (float) L/NCells;
#ifdef VERB
fprintf(stderr,"\n\tParticles and Halos placed in %ld^3 cells\n",NCells);
fprintf(stderr,"\tBOX = %f lcell =%f rho_ref = %e invL %f\n",L,L/NCells,rho_ref,invL);
fprintf(stderr,"\tNhalostart = %ld,Nhalosend = %ld, NPart = %ld\n",Nstart, Nend, NTotPart);
#endif
#ifdef DEBUG
fprintf(stderr,"\n\tRAND_MAX=%d\n",RAND_MAX);
fprintf(stderr,"\tX[0] = %f Y[0] = %f Z[0] = %f\n",PartX[0],PartY[0],PartZ[0]);
fprintf(stderr,"\tX[1] = %f Y[1] = %f Z[1] = %f\n",PartX[1],PartY[1],PartZ[1]);
fprintf(stderr,"\tM[0] = %e \n",HaloMass[0]);
fprintf(stderr,"\tM[1] = %e \n",HaloMass[1]);
fprintf(stderr,"\tM[%ld] = %e \n",Nend-1,HaloMass[Nend-1]);
fprintf(stderr,"\n\tMinimmum mass= %e. Minimum part per halo = %ld. mpart %e\n",HaloMass[Nend-1],Nmin,mpart);
#endif
if (L/NCells<R_from_mass(HaloMass[0],rho_ref)){
fprintf(stderr,"WARNING!!!: cell size is smaller than the radius of the biggest halo. Please, change the number of cells\n");
//exit(0);
}
#ifdef VERB
t1=time(NULL);
diff = difftime(t1,t0);
fprintf(stderr,"\ttime of initialisation %f\n",diff);
#endif
// ------------------------------------------------- Initiallised
#ifdef VERB
fprintf(stderr,"\tAssigning particles to grid ...\n");
#endif
#ifdef VERB
fprintf(stderr,"\t... particles counted ...\n");
t2=time(NULL);
diff = difftime(t2,t1);
fprintf(stderr,"\ttime counting %f\n",diff);
#endif
//Alloc Enough Memory
//ListOfPart = (long **) calloc(NCells*NCells*NCells,sizeof(long *));
ListOfHalos = (long **) calloc(NCells*NCells*NCells,sizeof(long *));
for (i=0;i<NCells;i++){
for (j=0;j<NCells;j++){
for (k=0;k<NCells;k++){
lin_ijk = k+j*NCells+i*NCells*NCells;
//ListOfPart[lin_ijk] = (long *) calloc(NPartPerCell[lin_ijk],sizeof(long));
Nhalos = (long) (NPartPerCell[lin_ijk]/Nmin);
ListOfHalos[lin_ijk] = (long *) calloc(Nhalos,sizeof(long));
if (Nstart==0)
MassLeft[lin_ijk] = (double) NPartPerCell[lin_ijk]*mpart;
#ifdef ULTRADEBUG
if (lin_ijk<10 || lin_ijk > (NCells*NCells*NCells) - 10){
fprintf(stderr,"\tAllocated %ld (longs) in ListOfPart(%ld=[%ld,%ld,%ld])\n",NPartPerCell[lin_ijk],lin_ijk,i,j,k);
fprintf(stderr,"\tAllocated %ld (longs) in ListOfHalos(%ld=[%ld,%ld,%ld])\n",Nhalos,lin_ijk,i,j,k);
}
#endif
}
}
}
#ifdef VERB
fprintf(stderr,"\t... memory allocated ...\n");
t3=time(NULL);
diff = difftime(t3,t2);
fprintf(stderr,"\ttime allocating %f\n",diff);
#endif
for (ihalo=0;ihalo<Nstart;ihalo++){
i = (long) (invL * HaloX[ihalo]*NCells);
j = (long) (invL * HaloY[ihalo]*NCells);
k = (long) (invL * HaloZ[ihalo]*NCells);
i=check_limit(i,NCells);
j=check_limit(j,NCells);
k=check_limit(k,NCells);
lin_ijk = k+j*NCells+i*NCells*NCells;
ListOfHalos[lin_ijk][NHalosPerCell[lin_ijk]] = ihalo;
NHalosPerCell[lin_ijk]++;
}
#ifdef DEBUG
fprintf(stderr,"\tMass_cell[0]=%e",MassLeft[0]);
fprintf(stderr,"\t Mass Function\n");
for (ihalo=0;ihalo<15;ihalo++){
fprintf(stderr,"\thalo %ld: ",ihalo);
fprintf(stderr,"M=%e\n",HaloMass[ihalo]);
}
#endif
#ifdef VERB
fprintf(stderr,"\t ...done\n\n");
t4=time(NULL);
diff = difftime(t4,t3);
fprintf(stderr,"\ttime of the actual assignment %f\n",diff);
fprintf(stderr,"\tComputing probabilities...\n");
#endif
//----------------------------------- Particles and haloes assigned to grid
//Actually placing the haloes-----------------------------------
Halos_done =0;
for(i_alpha=0;i_alpha<Nalpha;i_alpha++){
exponent = alpha[i_alpha];
tI=time(NULL);
TotProb=ComputeCumulative(exponent, mpart, MassLeft, CumulativeProb);
tII=time(NULL);
diff = difftime(tII,tI);
fprintf(stderr,"\t\t alpha[%d]=%f. time computing prob: %f\n",i_alpha,exponent,diff);
Nstart = Halos_done;
Nend = Halos_done + Nhalosbin[i_alpha];
fprintf(stderr,"\tNstart=%ld, Nend=%ld\n",Nstart,Nend);
#ifndef NO_HALOS_PARALLEL
#pragma omp parallel for private(Mhalo,ihalo,Mcell,R,i,j,k,lin_ijk,check,trials,ipart,icell) shared(rho_ref,HaloMass,NCells,TotProb,Nend,Nstart,stderr,ListOfHalos,ListOfPart,NHalosPerCell,NPartPerCell,MassLeft,PartX,PartY,PartZ,PartVX,PartVY,PartVZ,HaloX,HaloY,HaloZ,HaloVX,HaloVY,HaloVZ,HaloR,CumulativeProb,stdout) default(none)
#endif
for (ihalo=Nstart;ihalo<Nend;ihalo++){
#ifdef DEBUG
fprintf(stderr,"\n\t- Halo %ld \n",ihalo);
#endif
#ifdef VERB
if ((ihalo%1000000)==0)
fprintf(stderr,"\t%ld million haloes done\n",(ihalo/1000000));
#endif
Mhalo= HaloMass[ihalo];
do {
//First, choose a cell
trials=0;
#ifndef RANKED
do{
lin_ijk = select_cell(TotProb, CumulativeProb);
if (trials == MAXTRIALS){
fprintf(stderr,"WARNING: MAXTRIALS=%d reached and selected a complete cell\n",MAXTRIALS);
break;
}
trials++;
} while (MassLeft[lin_ijk]==0.);
k=lin_ijk%(NCells);
j=((lin_ijk-k)/NCells)%NCells;
i=(lin_ijk-k-j*NCells)/(NCells*NCells);
#else
lin_ijk=select_heaviest_cell(&i,&j,&k);
#endif
trials=0;
//Second, choose a particle in that cell
do {
ipart = select_part(lin_ijk,ListOfPart, NPartPerCell);
HaloX[ihalo] = PartX[ipart];
HaloY[ihalo] = PartY[ipart];
HaloZ[ihalo] = PartZ[ipart];
HaloVX[ihalo] = PartVX[ipart];
HaloVY[ihalo] = PartVY[ipart];
HaloVZ[ihalo] = PartVZ[ipart];
R=R_from_mass(HaloMass[ihalo],rho_ref);
HaloR[ihalo]= R;
#ifdef NO_EXCLUSION
check = 0;
#else
//Third, check that is not overlapping a previous halo
//check = check_HaloR_in_mesh(ihalo,HaloX,HaloY,HaloZ,HaloR,i,j,k,ListOfHalos,NHalosPerCell);
fprintf(stderr,"Shouldnt be here!\n");
#endif
if (check==1){
#ifdef DEBUG
fprintf(stderr,"Refused part : %ld\n",ipart);
#endif
trials++;
}
if (trials == MAXTRIALS){
//in order to avoid infinite loop, we will exit this loop, after MAXTRIALS trials
//#ifdef VERB
fprintf(stderr,"MAXTRIALS=%d reached, removing cell [%ld,%ld,%ld]\n",MAXTRIALS,i,j,k);
//#endif
MassLeft[lin_ijk]=0.;
//TotProb=ComputeCumulative(exponent, mpart, MassLeft, CumulativeProb);
break;
}
} while (check==1);//If the particle was excluded, try another one in the same cell
} while(check==1); //if reached MAXTRIALS, select another cell
//Particle chosen!
//mass in cell before assignment
Mcell=MassLeft[lin_ijk];
#ifndef MASS_OF_PARTS
if (Mcell>HaloMass[ihalo])
MassLeft[lin_ijk] -= Mhalo;
else
MassLeft[lin_ijk] = 0.;
#else
exclude(ipart,R,PartX,PartY,PartZ,i,j,k);
#endif
#ifndef NO_MASS_CONSERVATION
double ProbDiff = pow(MassLeft[lin_ijk]/mpart,exponent)-pow(Mcell/mpart,exponent);
#ifdef DEBUG
fprintf(stderr,"\n \tassigned to cell %ld=[%ld,%ld,%ld]\n\t Before: Mcell=%e, CProbCell=%e, TotProb=%e. ",lin_ijk,i,j,k,Mcell,CumulativeProb[lin_ijk],TotProb);
#endif
#ifndef MASS_OF_PARTS
//Substract the Probability difference from the array (only affected those cells after the selected one)
#pragma omp parallel for private(icell) shared(CumulativeProb,ProbDiff,NTotCells,lin_ijk) default(none)
for(icell=lin_ijk;icell<NTotCells;icell++){
CumulativeProb[icell]+=ProbDiff;
}
TotProb=CumulativeProb[NCells*NCells*NCells-1];
#endif
#endif
#ifdef DEBUG
fprintf(stderr," After: Mcell=%e, CProbCell=%e, TotProb=%e. ProbDiff=, Mhalo=%e. CProb[last]=%e\n",MassLeft[lin_ijk],CumulativeProb[lin_ijk],TotProb,Mhalo,CumulativeProb[NCells*NCells*NCells-1]);
fprintf(stderr,"\thalo %ld assigned to particle %ld at [%f,%f,%f]. R= %f, M= %e\n",ihalo,ipart,HaloX[ihalo],HaloY[ihalo],HaloZ[ihalo],R,Mhalo);
#endif
ListOfHalos[lin_ijk][NHalosPerCell[lin_ijk]]=ihalo;
NHalosPerCell[lin_ijk]++;
}//for(ihalo=Halos_done + Nalpha)
Halos_done += Nhalosbin[i_alpha];
}
//----------------------------------- Haloes Placed
#ifdef VERB
t5=time(NULL);
diff = difftime(t5,t4);
fprintf(stderr,"\ttime placing %f\n",diff);
diff = difftime(t5,t0);
fprintf(stderr,"\ttotal time in place_halos.c %f\n",diff);
fprintf(stderr,"\n\tPlacement done!!!\n");
#endif
free(NHalosPerCell);
free(count);
free(CumulativeProb);
free(MassLeft);
/* for (i=0;i<NCells;i++){
for (j=0;j<NCells;j++){
for (k=0;k<NCells;k++){
lin_ijk = k+j*NCells+i*NCells*NCells;
free(ListOfHalos[lin_ijk]);
}
}
}
*/
free(ListOfHalos);
#ifdef MASS_OF_PARTS
free(excluded); free(Nexcluded);
#endif
fprintf(stderr," e ");
return 0;
}
int place_halos(long NHalosTot, float *HaloMass, long Nlin, long NTotPart, float *PartX, float *PartY, float *PartZ, float L, float rho_ref, long seed, float mp, double *alpha, double *Malpha,long Nalpha,float *HaloX, float *HaloY, float *HaloZ, float *HaloR){
fprintf(stderr,"\tThis is place_halos.c v9.2\n");
//Initiallising -------------------------------------------------
long i,j,k,lin_ijk,check, icell, Nmin;
long *count,trials;
long ihalo,ilong, ipart, Nhalos,i_alpha;
double invL = 1./L, ProbDiff;
float Mcell,Mhalo,Mchange,exp;
float R;
time_t t0;
#ifdef VERB
time_t t1,t2,t3,t4,t5;
float diff;
#endif
NCells = Nlin;
Lbox = L;
t0=time(NULL);
NTotCells = NCells*NCells*NCells;
//Allocate memory for the arrays
NPartPerCell = (long *) calloc(NCells*NCells*NCells,sizeof(long));
NHalosPerCell = (long *) calloc(NCells*NCells*NCells,sizeof(long));
MassLeft = (double *) calloc(NCells*NCells*NCells,sizeof(double));
count = (long *) calloc(NCells*NCells*NCells,sizeof(long));
CumulativeProb = (double *) calloc(NTotCells, sizeof(double));
if(CumulativeProb == NULL) {
fprintf(stderr,"\tplace_halos(): could not allocate %ld array for CumulativeProb[]\nABORTING",NTotCells);
exit(-1);
}
fprintf(stderr,"\tUsing OMP with %d threads\n",omp_get_max_threads());
//Initiallise random numbers
#ifdef VERB
fprintf(stderr,"\tinput seed: %ld. time0: %ld. Used: ",seed,t0);
#endif
if (seed>=0){
srand(seed);
#ifdef VERB
fprintf(stderr,"%ld \n",seed);
#endif
}
else {
srand(t0);
#ifdef VERB
fprintf(stderr,"%ld \n",t0);
#endif
}
mpart = (double) mp;
Nmin = (long)ceil(HaloMass[NHalosTot-1]/mpart);
#ifdef VERB
fprintf(stderr,"\n\tParticles and Halos placed in %ld^3 cells\n",NCells);
fprintf(stderr,"\tBOX = %f lcell =%f rho_ref = %e invL %f\n",L,L/NCells,rho_ref,invL);
fprintf(stderr,"\tNhalos = %ld NPart = %ld\n",NHalosTot, NTotPart);
#endif
#ifdef DEBUG
fprintf(stderr,"\n\tRAND_MAX=%d\n",RAND_MAX);
fprintf(stderr,"\tX[0] = %f Y[0] = %f Z[0] = %f\n",PartX[0],PartY[0],PartZ[0]);
fprintf(stderr,"\tX[1] = %f Y[1] = %f Z[1] = %f\n",PartX[1],PartY[1],PartZ[1]);
fprintf(stderr,"\tM[0] = %e \n",HaloMass[0]);
fprintf(stderr,"\tM[1] = %e \n",HaloMass[1]);
fprintf(stderr,"\tM[%ld] = %e \n",NHalosTot-1,HaloMass[NHalosTot-1]);
fprintf(stderr,"\n\tMinimmum mass= %e. Minimum part per halo = %ld. mpart %e\n",HaloMass[NHalosTot-1],Nmin,mpart);
#endif
#ifdef VERB
t1=time(NULL);
diff = difftime(t1,t0);
fprintf(stderr,"\ttime of initialisation %f\n",diff);
#endif
// ------------------------------------------------- Initiallised
#ifdef VERB
fprintf(stderr,"\tAssigning particles to grid ...\n");
#endif
//Assign particles to grid ------------------------------------
//count particles per cell
for (ilong=0;ilong<NTotPart;ilong++) {
i = (long) (invL * PartX[ilong]*NCells);
j = (long) (invL * PartY[ilong]*NCells);
k = (long) (invL * PartZ[ilong]*NCells);
if (i<0 || i>=NCells || j<0 || j>=NCells || k<0 || k>=NCells){
fprintf(stderr,"\tWARNING: Particle %ld at [%f,%f,%f] seems to be out of the right box interval [0.,%f)",ilong,PartX[ilong],PartY[ilong],PartZ[ilong],L);
i=check_limit(i,NCells);
j=check_limit(j,NCells);
k=check_limit(k,NCells);
fprintf(stderr,", placed at cell [%ld,%ld,%ld]\n",i,j,k);
}
lin_ijk = k+j*NCells+i*NCells*NCells;
NPartPerCell[lin_ijk]++;
#ifdef DEBUG
if(ilong<10 || ilong > NTotPart -10 || ilong==243666)
fprintf(stderr,"\tipart=%ld cell: %ld=[%ld,%ld,%ld] Parts in cell=%ld, Pos= [%f,%f,%f]\n",ilong,lin_ijk,i,j,k,NPartPerCell[lin_ijk],PartX[ilong],PartY[ilong],PartZ[ilong]);
#endif
}
#ifdef VERB
fprintf(stderr,"\t... particles counted ...\n");
t2=time(NULL);
diff = difftime(t2,t1);
fprintf(stderr,"\ttime counting %f\n",diff);
#endif
//Alloc Enough Memory
ListOfPart = (long **) calloc(NCells*NCells*NCells,sizeof(long *));
ListOfHalos = (long **) calloc(NCells*NCells*NCells,sizeof(long *));
for (i=0;i<NCells;i++){
for (j=0;j<NCells;j++){
for (k=0;k<NCells;k++){
lin_ijk = k+j*NCells+i*NCells*NCells;
ListOfPart[lin_ijk] = (long *) calloc(NPartPerCell[lin_ijk],sizeof(long));
Nhalos = (long) (NPartPerCell[lin_ijk]/Nmin);
ListOfHalos[lin_ijk] = (long *) calloc(Nhalos,sizeof(long));
MassLeft[lin_ijk] = (double) NPartPerCell[lin_ijk]*mpart;
#ifdef ULTRADEBUG
if (lin_ijk<10 || lin_ijk > (NCells*NCells*NCells) - 10){
fprintf(stderr,"\tAllocated %ld (longs) in ListOfPart(%ld=[%ld,%ld,%ld])\n",NPartPerCell[lin_ijk],lin_ijk,i,j,k);
fprintf(stderr,"\tAllocated %ld (longs) in ListOfHalos(%ld=[%ld,%ld,%ld])\n",Nhalos,lin_ijk,i,j,k);
}
#endif
}
}
}
#ifdef VERB
fprintf(stderr,"\t... memory allocated ...\n");
t3=time(NULL);
diff = difftime(t3,t2);
fprintf(stderr,"\ttime allocating %f\n",diff);
#endif
for (ilong=0;ilong<NTotPart;ilong++) {
i = (long) (invL * PartX[ilong]*NCells);
j = (long) (invL * PartY[ilong]*NCells);
k = (long) (invL * PartZ[ilong]*NCells);
i=check_limit(i,NCells);
j=check_limit(j,NCells);
k=check_limit(k,NCells);
lin_ijk = k+j*NCells+i*NCells*NCells;
ListOfPart[lin_ijk][count[lin_ijk]] = ilong;
count[lin_ijk]++;
}
#ifdef DEBUG
fprintf(stderr,"\tMass_cell[0]=%e",MassLeft[0]);
#endif
Mhalo = HaloMass[0];
i_alpha = 0;
while(Mhalo<Malpha[i_alpha]) {
i_alpha++;
if (i_alpha==Nalpha){
fprintf(stderr,"\tERROR: No alpha low enough found\n");
exit(0);
}
}
Mchange = Malpha[i_alpha];
exp = alpha[i_alpha];
ComputeCumulative(exp);
#ifdef VERB
fprintf(stderr,"\tNumber of alphas: %ld\n",Nalpha);
fprintf(stderr,"\tUsing alpha_%ld=%f for M>%e\n",i_alpha,exp,Mchange);
#endif
//----------------------------------- Particles assigned to grid
#ifdef VERB
fprintf(stderr,"\t ...done\n\n");
t4=time(NULL);
diff = difftime(t4,t3);
fprintf(stderr,"\ttime of the actual assignment %f\n",diff);
#endif
#ifdef DEBUG
fprintf(stderr,"\t Mass Function\n");
for (ihalo=0;ihalo<15;ihalo++){
fprintf(stderr,"\thalo %ld: ",ihalo);
fprintf(stderr,"M=%e\n",HaloMass[ihalo]);
}
#endif
#ifdef VERB
fprintf(stderr,"\n\tPlacing Halos...\n\n");
#endif
for (ihalo=0;ihalo<NHalosTot;ihalo++){
#ifdef DEBUG
fprintf(stderr,"\n\t- Halo %ld ",ihalo);
#endif
do {
#ifndef RANKED
lin_ijk = select_cell();
k=lin_ijk%(NCells);
j=((lin_ijk-k)/NCells)%NCells;
i=(lin_ijk-k-j*NCells)/(NCells*NCells);
#else
lin_ijk=select_heaviest_cell(&i,&j,&k);
#endif
trials=0;
do {
ipart = select_part(lin_ijk);
HaloX[ihalo] = PartX[ipart];
HaloY[ihalo] = PartY[ipart];
HaloZ[ihalo] = PartZ[ipart];
R=R_from_mass(HaloMass[ihalo],rho_ref);
HaloR[ihalo]= R;
#ifdef NO_EXCLUSION
check = 1;
#else
check = check_HaloR_in_mesh(ihalo,HaloX,HaloY,HaloZ,HaloR,i,j,k);
#endif
if (check==0){
#ifdef DEBUG
fprintf(stderr,"Refused part : %ld\n",ipart);
#endif
trials++;
}
if (trials == MAXTRIALS){
#ifdef DEBUG
fprintf(stderr,"MAXTRIALS=%d reached, selecting another cell\n",MAXTRIALS);
#endif
break;
}
} while (check==0);//PART excluded
} while(check==0); //if reached MAXTRIALS, select another cell
Mcell=MassLeft[lin_ijk];
Mhalo= HaloMass[ihalo];
while (Mhalo < Mchange){
i_alpha++;
Mchange = Malpha[i_alpha];
exp = alpha[i_alpha];
ComputeCumulative(exp);
#ifdef VERB
fprintf(stderr,"\n\tUsing alpha_%ld=%f for M>%e\n",i_alpha,exp,Mchange);
#endif
}
#ifndef NO_MASS_CONSERVATION
if (Mcell>HaloMass[ihalo])
MassLeft[lin_ijk] -= Mhalo;
else
MassLeft[lin_ijk] = 0.;
#endif
ProbDiff = pow(MassLeft[lin_ijk]/mpart,exp)-pow(Mcell/mpart,exp);
#ifdef DEBUG
fprintf(stderr,"\n \tassigned to cell %ld=[%ld,%ld,%ld]\n\t Before: Mcell=%e, TotProb=%e. ",lin_ijk,i,j,k,Mcell,TotProb);
#endif
#pragma omp parallel for private(icell) shared(CumulativeProb,ProbDiff,NTotCells,lin_ijk) default(none)
for(icell=lin_ijk;icell<NTotCells;icell++){
CumulativeProb[icell]+=ProbDiff;
}
TotProb+=ProbDiff;
#ifdef DEBUG
fprintf(stderr," After: Mcell=%e, TotProb=%e. ProbDiff=%e, Mhalo=%e\n",MassLeft[lin_ijk],TotProb,ProbDiff,Mhalo);
#endif
#ifdef DEBUG
fprintf(stderr,"\thalo %ld assigned to particle %ld at [%f,%f,%f]. R= %f, M= %e\n",ihalo,ipart,HaloX[ihalo],HaloY[ihalo],HaloZ[ihalo],R,Mhalo);
#endif
ListOfHalos[lin_ijk][NHalosPerCell[lin_ijk]]=ihalo;
NHalosPerCell[lin_ijk]++;
}
#ifdef VERB
t5=time(NULL);
diff = difftime(t5,t4);
fprintf(stderr,"\ttime placing %f\n",diff);
diff = difftime(t5,t0);
fprintf(stderr,"\ttotal time in .c %f\n",diff);
fprintf(stderr,"\n\tPlacement done!!!\n");
#endif
free(count); free(NPartPerCell); free(ListOfPart);
free(CumulativeProb);
return 0;
}
bool DeckBuilder::OnEvent(const irr::SEvent& event) {
if(mainGame->dField.OnCommonEvent(event))
return false;
switch(event.EventType) {
case irr::EET_GUI_EVENT: {
s32 id = event.GUIEvent.Caller->getID();
if(mainGame->wCategories->isVisible() && id != BUTTON_CATEGORY_OK)
break;
if(mainGame->wQuery->isVisible() && id != BUTTON_YES && id != BUTTON_NO)
break;
if(mainGame->wLinkMarks->isVisible() && id != BUTTON_MARKERS_OK)
break;
switch(event.GUIEvent.EventType) {
case irr::gui::EGET_BUTTON_CLICKED: {
switch(id) {
case BUTTON_CLEAR_DECK: {
deckManager.current_deck.main.clear();
deckManager.current_deck.extra.clear();
deckManager.current_deck.side.clear();
break;
}
case BUTTON_SORT_DECK: {
std::sort(deckManager.current_deck.main.begin(), deckManager.current_deck.main.end(), ClientCard::deck_sort_lv);
std::sort(deckManager.current_deck.extra.begin(), deckManager.current_deck.extra.end(), ClientCard::deck_sort_lv);
std::sort(deckManager.current_deck.side.begin(), deckManager.current_deck.side.end(), ClientCard::deck_sort_lv);
break;
}
case BUTTON_SHUFFLE_DECK: {
std::random_shuffle(deckManager.current_deck.main.begin(), deckManager.current_deck.main.end());
break;
}
case BUTTON_SAVE_DECK: {
int sel = mainGame->cbDBDecks->getSelected();
if(sel >= 0 && deckManager.SaveDeck(deckManager.current_deck, mainGame->cbDBDecks->getItem(sel))) {
mainGame->stACMessage->setText(dataManager.GetSysString(1335));
mainGame->PopupElement(mainGame->wACMessage, 20);
}
break;
}
case BUTTON_SAVE_DECK_AS: {
const wchar_t* dname = mainGame->ebDeckname->getText();
if(*dname == 0)
break;
int sel = -1;
for(size_t i = 0; i < mainGame->cbDBDecks->getItemCount(); ++i) {
if(!wcscmp(dname, mainGame->cbDBDecks->getItem(i))) {
sel = i;
break;
}
}
if(sel >= 0)
mainGame->cbDBDecks->setSelected(sel);
else {
mainGame->cbDBDecks->addItem(dname);
mainGame->cbDBDecks->setSelected(mainGame->cbDBDecks->getItemCount() - 1);
}
if(deckManager.SaveDeck(deckManager.current_deck, dname)) {
mainGame->stACMessage->setText(dataManager.GetSysString(1335));
mainGame->PopupElement(mainGame->wACMessage, 20);
}
break;
}
case BUTTON_DELETE_DECK: {
int sel = mainGame->cbDBDecks->getSelected();
if(sel == -1)
break;
mainGame->gMutex.Lock();
wchar_t textBuffer[256];
myswprintf(textBuffer, L"%ls\n%ls", mainGame->cbDBDecks->getItem(sel), dataManager.GetSysString(1337));
mainGame->SetStaticText(mainGame->stQMessage, 310, mainGame->textFont, (wchar_t*)textBuffer);
mainGame->PopupElement(mainGame->wQuery);
mainGame->gMutex.Unlock();
prev_operation = id;
break;
}
case BUTTON_LEAVE_GAME: {
Terminate();
break;
}
case BUTTON_EFFECT_FILTER: {
mainGame->PopupElement(mainGame->wCategories);
break;
}
case BUTTON_START_FILTER: {
StartFilter();
break;
}
case BUTTON_CLEAR_FILTER: {
ClearSearch();
break;
}
case BUTTON_CATEGORY_OK: {
filter_effect = 0;
long long filter = 0x1;
for(int i = 0; i < 32; ++i, filter <<= 1)
if(mainGame->chkCategory[i]->isChecked())
filter_effect |= filter;
mainGame->HideElement(mainGame->wCategories);
break;
}
case BUTTON_SIDE_OK: {
if(deckManager.current_deck.main.size() != deckManager.pre_deck.main.size() || deckManager.current_deck.extra.size() != deckManager.pre_deck.extra.size()
|| deckManager.current_deck.side.size() != deckManager.pre_deck.side.size()) {
mainGame->env->addMessageBox(L"", dataManager.GetSysString(1410));
break;
}
mainGame->imgCard->setImage(imageManager.tCover[0]);
mainGame->stName->setText(L"");
mainGame->stInfo->setText(L"");
mainGame->stDataInfo->setText(L"");
mainGame->stSetName->setText(L"");
mainGame->stText->setText(L"");
mainGame->showingcard = 0;
mainGame->scrCardText->setVisible(false);
char deckbuf[1024];
char* pdeck = deckbuf;
BufferIO::WriteInt32(pdeck, deckManager.current_deck.main.size() + deckManager.current_deck.extra.size());
BufferIO::WriteInt32(pdeck, deckManager.current_deck.side.size());
for(size_t i = 0; i < deckManager.current_deck.main.size(); ++i)
BufferIO::WriteInt32(pdeck, deckManager.current_deck.main[i]->first);
for(size_t i = 0; i < deckManager.current_deck.extra.size(); ++i)
BufferIO::WriteInt32(pdeck, deckManager.current_deck.extra[i]->first);
for(size_t i = 0; i < deckManager.current_deck.side.size(); ++i)
BufferIO::WriteInt32(pdeck, deckManager.current_deck.side[i]->first);
DuelClient::SendBufferToServer(CTOS_UPDATE_DECK, deckbuf, pdeck - deckbuf);
break;
}
case BUTTON_SIDE_RELOAD: {
deckManager.current_deck = deckManager.pre_deck;
break;
}
case BUTTON_MSG_OK: {
mainGame->HideElement(mainGame->wMessage);
mainGame->actionSignal.Set();
break;
}
case BUTTON_YES: {
mainGame->HideElement(mainGame->wQuery);
if(!mainGame->is_building || mainGame->is_siding)
break;
if(prev_operation == BUTTON_DELETE_DECK) {
int sel = mainGame->cbDBDecks->getSelected();
if(deckManager.DeleteDeck(deckManager.current_deck, mainGame->cbDBDecks->getItem(sel))) {
mainGame->cbDBDecks->removeItem(sel);
int count = mainGame->cbDBDecks->getItemCount();
if(sel >= count)
sel = count - 1;
mainGame->cbDBDecks->setSelected(sel);
if(sel != -1)
deckManager.LoadDeck(mainGame->cbDBDecks->getItem(sel));
mainGame->stACMessage->setText(dataManager.GetSysString(1338));
mainGame->PopupElement(mainGame->wACMessage, 20);
prev_deck = sel;
}
} else if(prev_operation == BUTTON_LEAVE_GAME) {
Terminate();
} else if(prev_operation == COMBOBOX_DBDECKS) {
int sel = mainGame->cbDBDecks->getSelected();
deckManager.LoadDeck(mainGame->cbDBDecks->getItem(sel));
prev_deck = sel;
}
prev_operation = 0;
break;
}
case BUTTON_NO: {
mainGame->HideElement(mainGame->wQuery);
if (prev_operation == COMBOBOX_DBDECKS) {
mainGame->cbDBDecks->setSelected(prev_deck);
}
prev_operation = 0;
break;
}
case BUTTON_MARKS_FILTER: {
mainGame->PopupElement(mainGame->wLinkMarks);
break;
}
case BUTTON_MARKERS_OK: {
filter_marks = 0;
if (mainGame->btnMark[0]->isPressed())
filter_marks |= 0100;
if (mainGame->btnMark[1]->isPressed())
filter_marks |= 0200;
if (mainGame->btnMark[2]->isPressed())
filter_marks |= 0400;
if (mainGame->btnMark[3]->isPressed())
filter_marks |= 0010;
if (mainGame->btnMark[4]->isPressed())
filter_marks |= 0040;
if (mainGame->btnMark[5]->isPressed())
filter_marks |= 0001;
if (mainGame->btnMark[6]->isPressed())
filter_marks |= 0002;
if (mainGame->btnMark[7]->isPressed())
filter_marks |= 0004;
mainGame->HideElement(mainGame->wLinkMarks);
StartFilter();
break;
}
}
break;
}
case irr::gui::EGET_EDITBOX_ENTER: {
switch(id) {
case EDITBOX_KEYWORD: {
StartFilter();
break;
}
}
break;
}
case irr::gui::EGET_EDITBOX_CHANGED: {
switch (id) {
case EDITBOX_KEYWORD: {
stringw filter = mainGame->ebCardName->getText();
if (filter.size() > 2) {
StartFilter();
}
break;
}
case EDITBOX_DECK_NAME: {
mainGame->ValidateName(mainGame->ebDeckname);
break;
}
}
break;
}
case irr::gui::EGET_COMBO_BOX_CHANGED: {
switch(id) {
case COMBOBOX_DBLFLIST: {
filterList = deckManager._lfList[mainGame->cbDBLFList->getSelected()].content;
break;
}
case COMBOBOX_DBDECKS: {
int sel = mainGame->cbDBDecks->getSelected();
if(sel >= 0)
deckManager.LoadDeck(mainGame->cbDBDecks->getItem(sel));
prev_deck = sel;
break;
}
case COMBOBOX_MAINTYPE: {
mainGame->cbCardType2->setSelected(0);
mainGame->cbAttribute->setSelected(0);
mainGame->cbRace->setSelected(0);
mainGame->ebAttack->setText(L"");
mainGame->ebDefense->setText(L"");
mainGame->ebStar->setText(L"");
mainGame->ebScale->setText(L"");
switch(mainGame->cbCardType->getSelected()) {
case 0: {
mainGame->cbCardType2->setEnabled(false);
mainGame->cbCardType2->setSelected(0);
mainGame->cbRace->setEnabled(false);
mainGame->cbAttribute->setEnabled(false);
mainGame->ebAttack->setEnabled(false);
mainGame->ebDefense->setEnabled(false);
mainGame->ebStar->setEnabled(false);
mainGame->ebScale->setEnabled(false);
break;
}
case 1: {
wchar_t normaltuner[32];
wchar_t normalpen[32];
wchar_t syntuner[32];
mainGame->cbCardType2->setEnabled(true);
mainGame->cbRace->setEnabled(true);
mainGame->cbAttribute->setEnabled(true);
mainGame->ebAttack->setEnabled(true);
mainGame->ebDefense->setEnabled(true);
mainGame->ebStar->setEnabled(true);
mainGame->ebScale->setEnabled(true);
mainGame->cbCardType2->clear();
mainGame->cbCardType2->addItem(dataManager.GetSysString(1080), 0);
mainGame->cbCardType2->addItem(dataManager.GetSysString(1054), TYPE_MONSTER + TYPE_NORMAL);
mainGame->cbCardType2->addItem(dataManager.GetSysString(1055), TYPE_MONSTER + TYPE_EFFECT);
mainGame->cbCardType2->addItem(dataManager.GetSysString(1056), TYPE_MONSTER + TYPE_FUSION);
mainGame->cbCardType2->addItem(dataManager.GetSysString(1057), TYPE_MONSTER + TYPE_RITUAL);
mainGame->cbCardType2->addItem(dataManager.GetSysString(1063), TYPE_MONSTER + TYPE_SYNCHRO);
mainGame->cbCardType2->addItem(dataManager.GetSysString(1073), TYPE_MONSTER + TYPE_XYZ);
mainGame->cbCardType2->addItem(dataManager.GetSysString(1074), TYPE_MONSTER + TYPE_PENDULUM);
mainGame->cbCardType2->addItem(dataManager.GetSysString(1076), TYPE_MONSTER + TYPE_LINK);
mainGame->cbCardType2->addItem(dataManager.GetSysString(1075), TYPE_MONSTER + TYPE_SPSUMMON);
myswprintf(normaltuner, L"%ls|%ls", dataManager.GetSysString(1054), dataManager.GetSysString(1062));
mainGame->cbCardType2->addItem(normaltuner, TYPE_MONSTER + TYPE_NORMAL + TYPE_TUNER);
myswprintf(normalpen, L"%ls|%ls", dataManager.GetSysString(1054), dataManager.GetSysString(1074));
mainGame->cbCardType2->addItem(normalpen, TYPE_MONSTER + TYPE_NORMAL + TYPE_PENDULUM);
myswprintf(syntuner, L"%ls|%ls", dataManager.GetSysString(1063), dataManager.GetSysString(1062));
mainGame->cbCardType2->addItem(syntuner, TYPE_MONSTER + TYPE_SYNCHRO + TYPE_TUNER);
mainGame->cbCardType2->addItem(dataManager.GetSysString(1062), TYPE_MONSTER + TYPE_TUNER);
mainGame->cbCardType2->addItem(dataManager.GetSysString(1061), TYPE_MONSTER + TYPE_DUAL);
mainGame->cbCardType2->addItem(dataManager.GetSysString(1060), TYPE_MONSTER + TYPE_UNION);
mainGame->cbCardType2->addItem(dataManager.GetSysString(1059), TYPE_MONSTER + TYPE_SPIRIT);
mainGame->cbCardType2->addItem(dataManager.GetSysString(1071), TYPE_MONSTER + TYPE_FLIP);
mainGame->cbCardType2->addItem(dataManager.GetSysString(1072), TYPE_MONSTER + TYPE_TOON);
break;
}
case 2: {
mainGame->cbCardType2->setEnabled(true);
mainGame->cbRace->setEnabled(false);
mainGame->cbAttribute->setEnabled(false);
mainGame->ebAttack->setEnabled(false);
mainGame->ebDefense->setEnabled(false);
mainGame->ebStar->setEnabled(false);
mainGame->ebScale->setEnabled(false);
mainGame->cbCardType2->clear();
mainGame->cbCardType2->addItem(dataManager.GetSysString(1080), 0);
mainGame->cbCardType2->addItem(dataManager.GetSysString(1054), TYPE_SPELL);
mainGame->cbCardType2->addItem(dataManager.GetSysString(1066), TYPE_SPELL + TYPE_QUICKPLAY);
mainGame->cbCardType2->addItem(dataManager.GetSysString(1067), TYPE_SPELL + TYPE_CONTINUOUS);
mainGame->cbCardType2->addItem(dataManager.GetSysString(1057), TYPE_SPELL + TYPE_RITUAL);
mainGame->cbCardType2->addItem(dataManager.GetSysString(1068), TYPE_SPELL + TYPE_EQUIP);
mainGame->cbCardType2->addItem(dataManager.GetSysString(1069), TYPE_SPELL + TYPE_FIELD);
break;
}
case 3: {
mainGame->cbCardType2->setEnabled(true);
mainGame->cbRace->setEnabled(false);
mainGame->cbAttribute->setEnabled(false);
mainGame->ebAttack->setEnabled(false);
mainGame->ebDefense->setEnabled(false);
mainGame->ebStar->setEnabled(false);
mainGame->ebScale->setEnabled(false);
mainGame->cbCardType2->clear();
mainGame->cbCardType2->addItem(dataManager.GetSysString(1080), 0);
mainGame->cbCardType2->addItem(dataManager.GetSysString(1054), TYPE_TRAP);
mainGame->cbCardType2->addItem(dataManager.GetSysString(1067), TYPE_TRAP + TYPE_CONTINUOUS);
mainGame->cbCardType2->addItem(dataManager.GetSysString(1070), TYPE_TRAP + TYPE_COUNTER);
break;
}
}
StartFilter();
break;
}
case COMBOBOX_SECONDTYPE:
case COMBOBOX_OTHER_FILT: {
if (id==COMBOBOX_SECONDTYPE && mainGame->cbCardType->getSelected() == 1) {
if (mainGame->cbCardType2->getSelected() == 8) {
mainGame->ebDefense->setEnabled(false);
mainGame->ebDefense->setText(L"");
} else {
mainGame->ebDefense->setEnabled(true);
}
}
StartFilter();
break;
}
case COMBOBOX_SORTTYPE: {
SortList();
mainGame->env->setFocus(0);
break;
}
}
break;
}
case irr::gui::EGET_CHECKBOX_CHANGED: {
switch (id) {
case CHECKBOX_SHOW_ANIME: {
int prevLimit = mainGame->cbLimit->getSelected();
mainGame->cbLimit->clear();
mainGame->cbLimit->addItem(dataManager.GetSysString(1310));
mainGame->cbLimit->addItem(dataManager.GetSysString(1316));
mainGame->cbLimit->addItem(dataManager.GetSysString(1317));
mainGame->cbLimit->addItem(dataManager.GetSysString(1318));
mainGame->cbLimit->addItem(dataManager.GetSysString(1240));
mainGame->cbLimit->addItem(dataManager.GetSysString(1241));
mainGame->cbLimit->addItem(dataManager.GetSysString(1242));
if(mainGame->chkAnime->isChecked()) {
mainGame->cbLimit->addItem(dataManager.GetSysString(1243));
mainGame->cbLimit->addItem(L"Illegal");
mainGame->cbLimit->addItem(L"VG");
mainGame->cbLimit->addItem(L"Custom");
}
if (prevLimit < 8)
mainGame->cbLimit->setSelected(prevLimit);
StartFilter();
break;
}
}
break;
}
default: break;
}
break;
}
case irr::EET_MOUSE_INPUT_EVENT: {
switch(event.MouseInput.Event) {
case irr::EMIE_LMOUSE_PRESSED_DOWN: {
irr::gui::IGUIElement* root = mainGame->env->getRootGUIElement();
if(root->getElementFromPoint(mouse_pos) != root)
break;
if(mainGame->wCategories->isVisible() || mainGame->wQuery->isVisible())
break;
if(hovered_pos == 0 || hovered_seq == -1)
break;
click_pos = hovered_pos;
dragx = event.MouseInput.X;
dragy = event.MouseInput.Y;
draging_pointer = dataManager.GetCodePointer(hovered_code);
if(draging_pointer == dataManager._datas.end())
break;
if(hovered_pos == 4) {
if(!check_limit(draging_pointer))
break;
}
is_draging = true;
if(hovered_pos == 1)
pop_main(hovered_seq);
else if(hovered_pos == 2)
pop_extra(hovered_seq);
else if(hovered_pos == 3)
pop_side(hovered_seq);
mouse_pos.set(event.MouseInput.X, event.MouseInput.Y);
GetHoveredCard();
break;
}
case irr::EMIE_LMOUSE_LEFT_UP: {
if(!is_draging)
break;
bool pushed = false;
if(hovered_pos == 1)
pushed = push_main(draging_pointer, hovered_seq);
else if(hovered_pos == 2)
pushed = push_extra(draging_pointer, hovered_seq + is_lastcard);
else if(hovered_pos == 3)
pushed = push_side(draging_pointer, hovered_seq + is_lastcard);
else if(hovered_pos == 4 && !mainGame->is_siding)
pushed = true;
if(!pushed) {
if(click_pos == 1)
push_main(draging_pointer);
else if(click_pos == 2)
push_extra(draging_pointer);
else if(click_pos == 3)
push_side(draging_pointer);
}
is_draging = false;
break;
}
case irr::EMIE_RMOUSE_LEFT_UP: {
if(mainGame->is_siding) {
if(is_draging)
break;
if(hovered_pos == 0 || hovered_seq == -1)
break;
auto pointer = dataManager.GetCodePointer(hovered_code);
if(pointer == dataManager._datas.end())
break;
if(hovered_pos == 1) {
if(push_side(pointer))
pop_main(hovered_seq);
} else if(hovered_pos == 2) {
if(push_side(pointer))
pop_extra(hovered_seq);
} else {
if(push_extra(pointer) || push_main(pointer))
pop_side(hovered_seq);
}
break;
}
if(mainGame->wCategories->isVisible() || mainGame->wQuery->isVisible())
break;
if(!is_draging) {
if(hovered_pos == 0 || hovered_seq == -1)
break;
if(hovered_pos == 1) {
pop_main(hovered_seq);
} else if(hovered_pos == 2) {
pop_extra(hovered_seq);
} else if(hovered_pos == 3) {
pop_side(hovered_seq);
} else {
auto pointer = dataManager.GetCodePointer(hovered_code);
if(pointer == dataManager._datas.end())
break;
if(event.MouseInput.Shift)
push_side(pointer);
else {
if (!check_limit(pointer))
break;
if (!push_extra(pointer) && !push_main(pointer))
push_side(pointer);
}
}
} else {
if(click_pos == 1) {
push_side(draging_pointer);
} else if(click_pos == 2) {
push_side(draging_pointer);
} else if(click_pos == 3) {
if(!push_extra(draging_pointer))
push_main(draging_pointer);
} else {
push_side(draging_pointer);
}
is_draging = false;
}
break;
}
case irr::EMIE_MMOUSE_LEFT_UP: {
if (mainGame->is_siding)
break;
if (mainGame->wCategories->isVisible() || mainGame->wQuery->isVisible())
break;
if (hovered_pos == 0 || hovered_seq == -1)
break;
if (is_draging)
break;
auto pointer = dataManager.GetCodePointer(hovered_code);
if(!check_limit(pointer))
break;
if (hovered_pos == 1) {
if(!push_main(pointer))
push_side(pointer);
} else if (hovered_pos == 2) {
if(!push_extra(pointer))
push_side(pointer);
} else if (hovered_pos == 3) {
if(!push_side(pointer) && !push_extra(pointer))
push_main(pointer);
} else {
if(!push_extra(pointer) && !push_main(pointer))
push_side(pointer);
}
break;
}
case irr::EMIE_MOUSE_MOVED: {
mouse_pos.set(event.MouseInput.X, event.MouseInput.Y);
GetHoveredCard();
break;
}
case irr::EMIE_MOUSE_WHEEL: {
if(!mainGame->scrFilter->isVisible())
break;
if(!mainGame->Resize(805, 160, 1020, 630).isPointInside(mouse_pos))
break;
if(event.MouseInput.Wheel < 0) {
if(mainGame->scrFilter->getPos() < mainGame->scrFilter->getMax())
mainGame->scrFilter->setPos(mainGame->scrFilter->getPos() + 1);
} else {
if(mainGame->scrFilter->getPos() > 0)
mainGame->scrFilter->setPos(mainGame->scrFilter->getPos() - 1);
}
GetHoveredCard();
break;
}
default: break;
}
break;
}
default: break;
}
return false;
}
int place_halos(long NHalosTot, double *HaloMass, long Nlin, long NTotPart, float *PartX, float *PartY, float *PartZ, float L, float mp, float rho_ref, long seed, double *alpha, double *Malpha,long Nalpha,float *HaloX, float *HaloY, float *HaloZ){
fprintf(stderr,"Hi! This is place_halos.c v9.2\n");
fprintf(stdout,"Hi! This is place_halos.c v9.2\n");
//Initiallising -------------------------------------------------
long i,j,k,lin_ijk,check, icell, Nmin;
long *count,trials;
long ihalo,ilong, ipart, Nhalos,i_alpha;
double invL = 1./L,diff,ProbDiff,Mcell,Mhalo,Mchange,exp;
float R;
double Mmin;
time_t t0,t1,t2,t3,t4,t5;
NCells = Nlin;
lcell=L/NCells;
Lbox = L;
t0=time(NULL);
NTotCells = NCells*NCells*NCells;
//temp
float *HaloR;
//Allocate memory for the arrays
excluded = (long *) calloc(NTotPart, sizeof(long));
NPartPerCell = (long *) calloc(NCells*NCells*NCells,sizeof(long));
NHalosPerCell = (long *) calloc(NCells*NCells*NCells,sizeof(long));
MassLeft = (double *) calloc(NCells*NCells*NCells,sizeof(double));
count = (long *) calloc(NCells*NCells*NCells,sizeof(long));
Nexcluded = (long *) calloc(NTotCells,sizeof(long));
HaloR = (float *) calloc(NHalosTot,sizeof(float));
CumulativeProb = (double *) calloc(NTotCells, sizeof(double));
if(CumulativeProb == NULL) {
fprintf(stderr,"place_halos(): could not allocate %ld array for CumulativeProb[]\nABORTING",NTotCells);
exit(-1);
}
fprintf(stderr,"Using OMP with %d threads\n",omp_get_max_threads());
//Initiallise random numbers
if (seed>=0)
srand(seed);
else
srand(t0);
fprintf(stderr,"input seed: %ld. time0: %ld\n",seed,t0);
mpart = (double) mp;
#ifdef _VERB
fprintf(stderr,"#def _VERB\n");
#endif
#ifdef _DEBUG
fprintf(stderr,"#def _DEBUG \n");
#endif
#ifdef _ULTRADEBUG
fprintf(stderr,"#def _ULTRADEBUG \n");
#endif
#ifdef _PERIODIC
fprintf(stderr,"#def _PERIODIC\n");
#endif
#ifdef _ONLYBIG
fprintf(stderr,"#def _ONLYBIG\n");
#endif
Mmin = HaloMass[NHalosTot-1];
Nmin = (long)ceil(HaloMass[NHalosTot-1]/mp);
#ifdef _VERB
fprintf(stderr,"\nMassFunction computed globally with hmf. Particles and Halos placed in %ld^3 cells\n",NCells);
fprintf(stderr,"Exclusion done only with haloes.\n");
fprintf(stderr,"BOX = %f lcell =%f rho_ref = %e invL %f\n",L,lcell,rho_ref,invL);
fprintf(stderr,"Nhalos = %ld NPart = %ld\n",NHalosTot, NTotPart);
fprintf(stderr,"\nRAND_MAX=%d\n",RAND_MAX);
fprintf(stderr,"X[0] = %f Y[0] = %f Z[0] = %f\n",PartX[0],PartY[0],PartZ[0]);
fprintf(stderr,"X[1] = %f Y[1] = %f Z[1] = %f\n",PartX[1],PartY[1],PartZ[1]);
fprintf(stderr,"M[0] = %e \n",HaloMass[0]);
fprintf(stderr,"M[1] = %e \n",HaloMass[1]);
fprintf(stderr,"\nExclusion done only with haloes. Minimmum mass= %e. Minimum part per halo = %ld. Effective mp (not the real one) %e\n",HaloMass[NHalosTot-1],Nmin,mp);
#endif
t1=time(NULL);
diff = difftime(t1,t0);
fprintf(stderr,"time of initialisation %f\n",diff);
// ------------------------------------------------- Initiallised
#ifdef _VERB
fprintf(stderr,"Assigning particles to grid ...\n");
#endif
//Assign particles to grid ------------------------------------
//count particles per cell
for (ilong=0;ilong<NTotPart;ilong++) {
i = (long) (invL * PartX[ilong]*NCells);
j = (long) (invL * PartY[ilong]*NCells);
k = (long) (invL * PartZ[ilong]*NCells);
if (i<0 || i>=NCells || j<0 || j>=NCells || k<0 || k>=NCells){
fprintf(stderr,"WARNING: Particle %ld at [%f,%f,%f] seems to be out of the right box interval [0.,%f)",ilong,PartX[ilong],PartY[ilong],PartZ[ilong],L);
i=check_limit(i,NCells);
j=check_limit(j,NCells);
k=check_limit(k,NCells);
fprintf(stderr,", placed at cell [%ld,%ld,%ld]\n",i,j,k);
}
lin_ijk = k+j*NCells+i*NCells*NCells;
NPartPerCell[lin_ijk]++;
#ifdef _DEBUG
if(ilong<10 || ilong > NTotPart -10 || ilong==243666)
fprintf(stderr,"ipart=%ld cell: %ld=[%ld,%ld,%ld] Parts in cell=%ld, Pos= [%f,%f,%f]\n",ilong,lin_ijk,i,j,k,NPartPerCell[lin_ijk],PartX[ilong],PartY[ilong],PartZ[ilong]);
#endif
}
#ifdef _DEBUG
fprintf(stderr,"... particles counted ...\n");
t2=time(NULL);
diff = difftime(t2,t1);
fprintf(stderr,"time counting %f\n",diff);
#endif
//Alloc Enough Memory
ListOfPart = (long **) calloc(NCells*NCells*NCells,sizeof(long *));
ListOfHalos = (long **) calloc(NCells*NCells*NCells,sizeof(long *));
for (i=0;i<NCells;i++){
for (j=0;j<NCells;j++){
for (k=0;k<NCells;k++){
lin_ijk = k+j*NCells+i*NCells*NCells;
ListOfPart[lin_ijk] = (long *) calloc(NPartPerCell[lin_ijk],sizeof(long));
Nhalos = (long) (NPartPerCell[lin_ijk]/Nmin);
ListOfHalos[lin_ijk] = (long *) calloc(Nhalos,sizeof(long));
MassLeft[lin_ijk] = (double) NPartPerCell[lin_ijk]*mpart;
#ifdef _ULTRADEBUG
if (lin_ijk<10 || lin_ijk > (NCells*NCells*NCells) - 10){
fprintf(stderr,"Allocated %ld (longs) in ListOfPart(%ld=[%ld,%ld,%ld])\n",NPartPerCell[lin_ijk],lin_ijk,i,j,k);
fprintf(stderr,"Allocated %ld (longs) in ListOfHalos(%ld=[%ld,%ld,%ld])\n",Nhalos,lin_ijk,i,j,k);
}
#endif
}
}
}
#ifdef _DEBUG
fprintf(stderr,"... memory allocated ...\n");
t3=time(NULL);
diff = difftime(t3,t2);
fprintf(stderr,"time allocating %f\n",diff);
#endif
for (ilong=0;ilong<NTotPart;ilong++) {
i = (long) (invL * PartX[ilong]*NCells);
j = (long) (invL * PartY[ilong]*NCells);
k = (long) (invL * PartZ[ilong]*NCells);
i=check_limit(i,NCells);
j=check_limit(j,NCells);
k=check_limit(k,NCells);
lin_ijk = k+j*NCells+i*NCells*NCells;
ListOfPart[lin_ijk][count[lin_ijk]] = ilong;
count[lin_ijk]++;
}
fprintf(stderr,"Mass_cell[0]=%e",MassLeft[0]);
fprintf(stderr," TotProb=%e\n",TotProb);
Mhalo = HaloMass[0];
i_alpha = 0;
while(Mhalo<Malpha[i_alpha]) {
i_alpha++;
if (i_alpha==Nalpha){
fprintf(stderr,"ERROR: No alpha low enough found\n");
exit(0);
}
}
Mchange = Malpha[i_alpha];
exp = alpha[i_alpha];
ComputeCumulative(exp);
//----------------------------------- Particles assigned to grid
#ifdef _VERB
fprintf(stderr," ...done\n\n");
t4=time(NULL);
diff = difftime(t4,t3);
fprintf(stderr,"time of the actual assignment %f\n",diff);
#endif
#ifdef _DEBUG
fprintf(stderr," Mass Function\n");
for (ihalo=0;ihalo<15;ihalo++){
fprintf(stderr,"halo %ld: ",ihalo);
fprintf(stderr,"M=%e\n",HaloMass[ihalo]);
}
#endif
#ifdef _VERB
fprintf(stderr,"\nPlacing Halos...\n\n");
#endif
for (ihalo=0;ihalo<NHalosTot;ihalo++){
#ifdef _DEBUG
fprintf(stderr,"\n- Halo %ld ",ihalo);
#endif
lin_ijk = select_cell();
if(lin_ijk<0) {
fprintf(stderr,"Maximum Mass cell was %e\n",MassLeft[select_heaviest_cell(&i,&j,&k,MassLeft,NCells,HaloMass[ihalo])]);
break;
}
k=lin_ijk%(NCells);
j=((lin_ijk-k)/NCells)%NCells;
i=(lin_ijk-k-j*NCells)/(NCells*NCells);
Mcell=MassLeft[lin_ijk];
Mhalo= HaloMass[ihalo];
while (Mhalo < Mchange){
i_alpha++;
Mchange = Malpha[i_alpha];
exp = alpha[i_alpha];
ComputeCumulative(exp);
}
if (Mcell>HaloMass[ihalo])
MassLeft[lin_ijk] -= Mhalo;
else
MassLeft[lin_ijk] = 0.;
ProbDiff = pow(MassLeft[lin_ijk]/mpart,exp)-pow(Mcell/mpart,exp);
#ifdef _DEBUG
fprintf(stderr,"\n assigned to cell %ld=[%ld,%ld,%ld]\n Before: Mcell=%e, TotProb=%e. ",lin_ijk,i,j,k,Mcell,TotProb);
#endif
#pragma omp parallel for private(icell) shared(CumulativeProb,ProbDiff,NTotCells,lin_ijk) default(none)
for(icell=lin_ijk;icell<NTotCells;icell++){
CumulativeProb[icell]+=ProbDiff;
}
TotProb+=ProbDiff;
#ifdef _DEBUG
fprintf(stderr," After: Mcell=%e, TotProb=%e. ProbDiff=%e, Mhalo=%e\n",MassLeft[lin_ijk],TotProb,ProbDiff,Mhalo);
#endif
trials=0;
do {
ipart = select_part(lin_ijk);
HaloX[ihalo] = PartX[ipart];
HaloY[ihalo] = PartY[ipart];
HaloZ[ihalo] = PartZ[ipart];
R=R_from_mass(HaloMass[ihalo],rho_ref);
HaloR[ihalo]=R;
check = check_HaloR_in_mesh(ihalo,HaloX,HaloY,HaloZ,HaloR,i,j,k);
if (check==0){
#ifdef _DEBUG
fprintf(stderr,"Refused part : %ld\n",ipart);
#endif
trials++;
}
if (trials ==20)
exit(-1);
} while (check==0);
#ifdef _DEBUG
fprintf(stderr,"halo %ld assigned to particle %ld at [%f,%f,%f]. R= %f, M= %e\n",ihalo,ipart,HaloX[ihalo],HaloY[ihalo],HaloZ[ihalo],R,Mhalo);
#endif
ListOfHalos[lin_ijk][NHalosPerCell[lin_ijk]]=ihalo;
NHalosPerCell[lin_ijk]++;
}
#ifdef _VERB
t5=time(NULL);
diff = difftime(t5,t4);
fprintf(stderr,"time placing %f\n",diff);
diff = difftime(t5,t0);
fprintf(stderr,"total time in .c %f\n",diff);
fprintf(stderr,"\nEverything done!!!\n");
#endif
free(count); free(NPartPerCell); free(ListOfPart); free(excluded);
free(CumulativeProb);
return 0;
}
static
rc_t KTocEntryInflateNodeCommon (const void ** ptr,
const void * limit,
KTocEntryInflateCommon * common,
const char * path,
bool rev)
{
rc_t rc;
uint16_t plen;
uint16_t nlen;
rc = read_u16 (ptr, limit, rev, &nlen);
if (rc)
return rc;
if (check_limit (*ptr, limit, nlen))
return RC (rcFS, rcTocEntry, rcParsing, rcBuffer, rcTooShort);;
plen = (uint16_t)strlen (path);
if (plen == 0)
{
common->name = malloc (nlen+1);
if (common->name == NULL)
{
return RC (rcFS, rcTocEntry, rcInflating, rcMemory, rcExhausted);
}
memmove (common->name, *ptr, nlen);
common->name[nlen] = '\0';
}
else
{
common->name = malloc (plen + 1 + nlen+1);
if (common->name == NULL)
{
return RC (rcFS, rcTocEntry, rcInflating, rcMemory, rcExhausted);
}
memmove (common->name, path, plen);
common->name[plen] = '/';
memmove (common->name+plen+1, *ptr, nlen);
common->name[plen + nlen + 1] = '\0';
}
*ptr = ((uint8_t*)*ptr) + nlen;
rc = read_i64 (ptr, limit, rev, &common->mtime);
if (rc == 0)
{
rc =read_u32 (ptr, limit, rev, &common->access);
if (rc == 0)
{
uint8_t type;
rc = read_u8 (ptr, limit, &type);
if (rc == 0)
{
common->type = type;
return 0;
}
}
}
free (common->name);
common->name = NULL;
common->mtime = 0;
common->access = 0;
common->type = ktocentrytype_unknown;
return rc;
}
//place_halos():
//
//Takes a list of halo masses (Nhalos, HaloMass), a list of particles (NTotPart,PartX,PartY,PartZ), some simulation parameters (L, mp), and user-defined parameters (Nlin,rho_ref,alpha,Malpha,Nalpha,seed)
//and returns a list of halo positions and radii (HaloX,HaloY,HaloZ,HaloR)
int place_halos(long Nend, float *HaloMass, long Nlin, long NTotPart, float *PartX, float *PartY, float *PartZ, float *PartVX, float *PartVY, float *PartVZ,float L, float rho_ref, long seed, float mp, double *alpha, double *Malpha,long Nalpha,float *HaloX, float *HaloY, float *HaloZ, float *HaloVX, float *HaloVY, float *HaloVZ,float *HaloR,long **ListOfPart, long *NPartPerCell){
fprintf(stderr,"\tThis is place_halos.c v11\n");
//Initiallising -------------------------------------------------
long i,j,k,lin_ijk, Nmin;
long *count,trials;
long ihalo,ilong, ipart,i_alpha;
double invL = 1./L;
float Mcell,Mhalo,Mchange;
float R;
time_t t0;
int check;
double mpart;
double exponent;
double TotProb;
double *MassLeft;
double *CumulativeProb;
long **ListOfHalos, *NHalosPerCell;
long Nstart=0,Nhalos;
#ifdef VERB
time_t t1,t2,t3,t4,t4_5,t5;
float diff;
#endif
NCells = Nlin;
Lbox = L;
t0=time(NULL);
NTotCells = NCells*NCells*NCells;
MassLeft = malloc(NTotCells*sizeof(double));
//Allocate memory for the arrays
//NPartPerCell = (long *) calloc(NTotCells,sizeof(long));
/* if( NPartPerCell == NULL) {
fprintf(stderr,"\tplace_halos(): could not allocate %ld array for NPartPerCell[]\nABORTING",NTotCells);
exit(-1);
}*/
NHalosPerCell = (long *) calloc(NTotCells,sizeof(long));
if(NHalosPerCell == NULL) {
fprintf(stderr,"\tplace_halos(): could not allocate %ld array for NHalosPerCell[]\nABORTING",NTotCells);
exit(-1);
}
count = (long *) calloc(NTotCells,sizeof(long));
if(count == NULL) {
fprintf(stderr,"\tplace_halos(): could not allocate %ld array for NTotCells[]\nABORTING",NTotCells);
exit(-1);
}
CumulativeProb = (double *) calloc(NTotCells, sizeof(double));
if(CumulativeProb == NULL) {
fprintf(stderr,"\tplace_halos(): could not allocate %ld array for CumulativeProb[]\nABORTING",NTotCells);
exit(-1);
}
fprintf(stderr,"\tUsing OMP with %d threads\n",omp_get_max_threads());
#ifdef MASS_OF_PARTS
Nexcluded = (long *) calloc(NTotCells,sizeof(long));
if(Nexcluded == NULL) {
fprintf(stderr,"\tplace_halos(): could not allocate %ld array for Nexcluded[]\nABORTING",NTotCells);
exit(-1);
}
excluded = (int *) calloc(NTotPart, sizeof(long));
if(excluded == NULL) {
fprintf(stderr,"\tplace_halos(): could not allocate %ld array for excluded[]\nABORTING",NTotPart);
exit(-1);
}
#endif
//Initiallise random numbers
#ifdef VERB
fprintf(stderr,"\tinput seed: %ld. time0: %ld.",seed,t0);
#endif
if (seed>=0){
srand(seed);
#ifdef VERB
fprintf(stderr,"Used: %ld \n",seed);
#endif
}
else {
srand(t0);
fprintf(stderr,"Seed Used: %ld \n",t0);
}
mpart = (double) mp;
//Nmin = (long)ceil(HaloMass[Nhalos-1]/mpart);
Nmin = (long)ceil(HaloMass[Nend-1]*0.8/mpart);
lcell = (float) L/NCells;
#ifdef VERB
fprintf(stderr,"\n\tParticles and Halos placed in %ld^3 cells\n",NCells);
fprintf(stderr,"\tBOX = %f lcell =%f rho_ref = %e invL %f\n",L,L/NCells,rho_ref,invL);
fprintf(stderr,"\tNhalostart = %ld,Nhalosend = %ld, NPart = %ld\n",Nstart, Nend, NTotPart);
#endif
#ifdef DEBUG
fprintf(stderr,"\n\tRAND_MAX=%d\n",RAND_MAX);
fprintf(stderr,"\tX[0] = %f Y[0] = %f Z[0] = %f\n",PartX[0],PartY[0],PartZ[0]);
fprintf(stderr,"\tX[1] = %f Y[1] = %f Z[1] = %f\n",PartX[1],PartY[1],PartZ[1]);
fprintf(stderr,"\tM[0] = %e \n",HaloMass[0]);
fprintf(stderr,"\tM[1] = %e \n",HaloMass[1]);
fprintf(stderr,"\tM[%ld] = %e \n",Nend-1,HaloMass[Nend-1]);
fprintf(stderr,"\n\tMinimmum mass= %e. Minimum part per halo = %ld. mpart %e\n",HaloMass[Nend-1],Nmin,mpart);
#endif
if (L/NCells<R_from_mass(HaloMass[0],rho_ref)){
fprintf(stderr,"ERROR: cell size is smaller than the radius of the biggest halo. Please, change the number of cells\n");
exit(0);
}
#ifdef VERB
t1=time(NULL);
diff = difftime(t1,t0);
fprintf(stderr,"\ttime of initialisation %f\n",diff);
#endif
// ------------------------------------------------- Initiallised
#ifdef VERB
fprintf(stderr,"\tAssigning particles to grid ...\n");
#endif
//Assign particles to grid ------------------------------------
//count particles per cell
/*for (ilong=0;ilong<NTotPart;ilong++) {
if (PartX[ilong]==Lbox)
PartX[ilong]=0.;
if (PartY[ilong]==Lbox)
PartY[ilong]=0.;
if (PartZ[ilong]==Lbox)
PartZ[ilong]=0.;
i = (long) (invL * PartX[ilong]*NCells);
j = (long) (invL * PartY[ilong]*NCells);
k = (long) (invL * PartZ[ilong]*NCells);
if (i<0 || i>=NCells || j<0 || j>=NCells || k<0 || k>=NCells){
fprintf(stderr,"\tERROR: Particle %ld at [%f,%f,%f] seems to be out of the right box interval [0.,%f)",ilong,PartX[ilong],PartY[ilong],PartZ[ilong],L);
}
lin_ijk = k+j*NCells+i*NCells*NCells;
// NPartPerCell[lin_ijk]++;
#ifdef DEBUG
if(ilong<10 || ilong > NTotPart -10 || ilong==243666)
fprintf(stderr,"\tipart=%ld cell: %ld=[%ld,%ld,%ld] Parts in cell=%ld, Pos= [%f,%f,%f]\n",ilong,lin_ijk,i,j,k,NPartPerCell[lin_ijk],PartX[ilong],PartY[ilong],PartZ[ilong]);
#endif
}*/
#ifdef VERB
fprintf(stderr,"\t... particles counted ...\n");
t2=time(NULL);
diff = difftime(t2,t1);
fprintf(stderr,"\ttime counting %f\n",diff);
#endif
//Alloc Enough Memory
//ListOfPart = (long **) calloc(NCells*NCells*NCells,sizeof(long *));
ListOfHalos = (long **) calloc(NCells*NCells*NCells,sizeof(long *));
for (i=0;i<NCells;i++){
for (j=0;j<NCells;j++){
for (k=0;k<NCells;k++){
lin_ijk = k+j*NCells+i*NCells*NCells;
//ListOfPart[lin_ijk] = (long *) calloc(NPartPerCell[lin_ijk],sizeof(long));
Nhalos = (long) (NPartPerCell[lin_ijk]/Nmin);
ListOfHalos[lin_ijk] = (long *) calloc(Nhalos,sizeof(long));
if (Nstart==0)
MassLeft[lin_ijk] = (double) NPartPerCell[lin_ijk]*mpart;
#ifdef ULTRADEBUG
if (lin_ijk<10 || lin_ijk > (NCells*NCells*NCells) - 10){
fprintf(stderr,"\tAllocated %ld (longs) in ListOfPart(%ld=[%ld,%ld,%ld])\n",NPartPerCell[lin_ijk],lin_ijk,i,j,k);
fprintf(stderr,"\tAllocated %ld (longs) in ListOfHalos(%ld=[%ld,%ld,%ld])\n",Nhalos,lin_ijk,i,j,k);
}
#endif
}
}
}
#ifdef VERB
fprintf(stderr,"\t... memory allocated ...\n");
t3=time(NULL);
diff = difftime(t3,t2);
fprintf(stderr,"\ttime allocating %f\n",diff);
#endif
/*
#pragma omp parallel for private(ilong,i,k,j,lin_ijk) shared(NTotPart,invL,NCells,ListOfPart,count,PartZ,PartX,PartY,L,stderr) default(none)
for (ilong=0;ilong<NTotPart;ilong++) {
i = (long) (invL * PartX[ilong]*NCells);
j = (long) (invL * PartY[ilong]*NCells);
k = (long) (invL * PartZ[ilong]*NCells);
if (i<0 || i>=NCells || j<0 || j>=NCells || k<0 || k>=NCells){
fprintf(stderr,"\tERROR: Particle %ld at [%f,%f,%f] seems to be out of the right box interval [0.,%f)",ilong,PartX[ilong],PartY[ilong],PartZ[ilong],L);
}
lin_ijk = k+j*NCells+i*NCells*NCells;
ListOfPart[lin_ijk][count[lin_ijk]] = ilong;
count[lin_ijk]++;
}
#ifdef VERB
fprintf(stderr,"\t...particles assigned, now haloes...\n");
#endif */
for (ihalo=0;ihalo<Nstart;ihalo++){
i = (long) (invL * HaloX[ihalo]*NCells);
j = (long) (invL * HaloY[ihalo]*NCells);
k = (long) (invL * HaloZ[ihalo]*NCells);
i=check_limit(i,NCells);
j=check_limit(j,NCells);
k=check_limit(k,NCells);
lin_ijk = k+j*NCells+i*NCells*NCells;
ListOfHalos[lin_ijk][NHalosPerCell[lin_ijk]] = ihalo;
NHalosPerCell[lin_ijk]++;
}
#ifdef DEBUG
fprintf(stderr,"\tMass_cell[0]=%e",MassLeft[0]);
fprintf(stderr,"\t Mass Function\n");
for (ihalo=0;ihalo<15;ihalo++){
fprintf(stderr,"\thalo %ld: ",ihalo);
fprintf(stderr,"M=%e\n",HaloMass[ihalo]);
}
#endif
#ifdef VERB
fprintf(stderr,"\t ...done\n\n");
t4=time(NULL);
diff = difftime(t4,t3);
fprintf(stderr,"\ttime of the actual assignment %f\n",diff);
fprintf(stderr,"\tComputing probabilities...\n");
#endif
//----------------------------------- Particles and haloes assigned to grid
//Computing Cumulative Probability -----------------------------
//find the right alpha
Mhalo = HaloMass[Nstart];
i_alpha = 0;
while(Mhalo<Malpha[i_alpha]) {
i_alpha++;
if (i_alpha==Nalpha){
fprintf(stderr,"\tERROR: No M_alpha low enough found\n");
fprintf(stderr,"\tERROR: N_alpha = %ld, Mh=%e, Ma= %e\n",Nalpha,Mhalo,Malpha[i_alpha-1]);
exit(0);
}
}
Mchange = Malpha[i_alpha];
exponent = alpha[i_alpha];
//compute the probability
TotProb = ComputeCumulative(exponent, mpart, MassLeft, CumulativeProb);
#ifdef VERB
fprintf(stderr,"\tNumber of alphas: %ld\n",Nalpha);
fprintf(stderr,"\tUsing alpha_%ld=%f for M>%e\n",i_alpha,exponent,Mchange);
t4_5=time(NULL);
diff = difftime(t4_5,t4);
fprintf(stderr,"\tprobabilty computed in %f secods\n",diff);
#endif
// ----------------------------------------- Computed Probability
//Actually placing the haloes-----------------------------------
#ifdef VERB
fprintf(stderr,"\n\tPlacing Halos...\n\n");
#endif
//Place one by one all the haloes (assumed to be ordered from the most massive to the least massive)
for (ihalo=Nstart;ihalo<Nend;ihalo++){
#ifdef DEBUG
fprintf(stderr,"\n\t- Halo %ld ",ihalo);
#endif
#ifdef VERB
if ((ihalo%1000000)==0)
fprintf(stderr,"\t%ld million haloes done\n",(ihalo/1000000));
#endif
//Check whether or not, a change of alpha is needed for this halo mass
Mhalo= HaloMass[ihalo];
// if (ihalo<=-1)
// fprintf(stderr,"\tMhalo=%e\n",Mhalo);
while (Mhalo < Mchange){//if so search the right alpha, and recompute probabilities
i_alpha++;
if (i_alpha==Nalpha){
fprintf(stderr,"\tERROR: No M_alpha low enough found\n");
exit(0);
}
Mchange = Malpha[i_alpha];
exponent = alpha[i_alpha];
TotProb=ComputeCumulative(exponent, mpart, MassLeft, CumulativeProb);
#ifdef VERB
fprintf(stderr,"\n\tUsing alpha_%ld=%f for M>%e\n",i_alpha,exponent,Mchange);
#endif
}
// if (ihalo<=-1)
// fprintf(stderr,"\talpha=%f\n",exponent);
do {
//First, choose a cell
#ifndef RANKED
lin_ijk = select_cell(TotProb, CumulativeProb);
// if (ihalo<=-1)
// fprintf(stderr,"\tlin_ijk=%ld ",lin_ijk);
k=lin_ijk%(NCells);
j=((lin_ijk-k)/NCells)%NCells;
i=(lin_ijk-k-j*NCells)/(NCells*NCells);
if (ihalo<=-1)
fprintf(stderr," = [%ld,%ld,%ld]\n",i,j,k);
#else
lin_ijk=select_heaviest_cell(&i,&j,&k);
#endif
trials=0;
//Second, choose a particle in that cell
do {
ipart = select_part(lin_ijk,ListOfPart, NPartPerCell);
// if (ihalo<=-1)
// fprintf(stderr,"\tipart=%ld\n",ipart);
HaloX[ihalo] = PartX[ipart];
HaloY[ihalo] = PartY[ipart];
HaloZ[ihalo] = PartZ[ipart];
HaloVX[ihalo] = PartVX[ipart];
HaloVY[ihalo] = PartVY[ipart];
HaloVZ[ihalo] = PartVZ[ipart];
R=R_from_mass(HaloMass[ihalo],rho_ref);
HaloR[ihalo]= R;
// if (ihalo<=-1)
// fprintf(stderr,"\thalo: [[%f,%f,%f],[%f,%f,%f],%f]\n",HaloX[ihalo],HaloY[ihalo],HaloZ[ihalo],HaloVX[ihalo],HaloVY[ihalo],HaloVZ[ihalo],HaloR[ihalo]);
#ifdef NO_EXCLUSION
check = 0;
#else
//Third, check that is not overlapping a previous halo
check = check_HaloR_in_mesh(ihalo,HaloX,HaloY,HaloZ,HaloR,i,j,k,ListOfHalos,NHalosPerCell);
#endif
// if (ihalo<=-1)
// fprintf(stderr,"\tCHECK=%d\n",check);
if (check==1){
#ifdef DEBUG
fprintf(stderr,"Refused part : %ld\n",ipart);
#endif
trials++;
}
if (trials == MAXTRIALS){
//in order to avoid infinite loop, we will exit this loop, after MAXTRIALS trials
#ifdef VERB
fprintf(stderr,"MAXTRIALS=%d reached, removing cell [%ld,%ld,%ld]\n",MAXTRIALS,i,j,k);
#endif
MassLeft[lin_ijk]=0.;
TotProb=ComputeCumulative(exponent, mpart, MassLeft, CumulativeProb);
break;
}
} while (check==1);//If the particle was excluded, try another one in the same cell
} while(check==1); //if reached MAXTRIALS, select another cell
//Particle chosen!
//mass in cell before assignment
Mcell=MassLeft[lin_ijk];
// if (ihalo<=-1)
// fprintf(stderr,"\tMbefore=%e\n",Mcell);
#ifndef MASS_OF_PARTS
if (Mcell>HaloMass[ihalo])
MassLeft[lin_ijk] -= Mhalo;
else
MassLeft[lin_ijk] = 0.;
#else
exclude(ipart,R,PartX,PartY,PartZ,i,j,k);
#endif
//// if (ihalo<=-1)
// fprintf(stderr,"\tMafter=%e\n",MassLeft[lin_ijk]);
#ifndef NO_MASS_CONSERVATION
if (ihalo<=-1)
fprintf(stderr,"\tOld version!\n");
double ProbDiff = pow(MassLeft[lin_ijk]/mpart,exponent)-pow(Mcell/mpart,exponent);
#ifdef DEBUG
fprintf(stderr,"\n \tassigned to cell %ld=[%ld,%ld,%ld]\n\t Before: Mcell=%e, CProbCell=%e, TotProb=%e. ",lin_ijk,i,j,k,Mcell,CumulativeProb[lin_ijk],TotProb);
#endif
#ifndef MASS_OF_PARTS
long icell;
//Substract the Probability difference from the array (only affected those cells after the selected one)
#pragma omp parallel for private(icell) shared(CumulativeProb,robDiff,NTotCells,lin_ijk) default(none)
for(icell=lin_ijk;icell<NTotCells;icell++){
CumulativeProb[icell]+=ProbDiff;
}
//TotProb+=ProbDiff;
TotProb=CumulativeProb[NCells*NCells*NCells-1];
#endif
#endif
#ifdef DEBUG
fprintf(stderr," After: Mcell=%e, CProbCell=%e, TotProb=%e. , Mhalo=%e. CProb[last]=%e\n",MassLeft[lin_ijk],CumulativeProb[lin_ijk],TotProb,Mhalo,CumulativeProb[NTotCells-1]);
#endif
#ifdef DEBUG
fprintf(stderr,"\thalo %ld assigned to particle %ld at [%f,%f,%f]. R= %f, M= %e\n",ihalo,ipart,HaloX[ihalo],HaloY[ihalo],HaloZ[ihalo],R,Mhalo);
#endif
// if (ihalo<=-1)
// fprintf(stderr,"\tplace ihalo=%ld",ihalo);
ListOfHalos[lin_ijk][NHalosPerCell[lin_ijk]]=ihalo;
// if (ihalo<=-1)
// fprintf(stderr,"\t check: %ld\n",ListOfHalos[lin_ijk][NHalosPerCell[lin_ijk]]);
NHalosPerCell[lin_ijk]++;
// if (ihalo<=-1)
// fprintf(stderr,"\t Nhalospercell[%ld]= %ld\n",lin_ijk,NHalosPerCell[lin_ijk]);
}//for(ihalo=Nstart:Nend)
//----------------------------------- Haloes Placed
#ifdef VERB
t5=time(NULL);
diff = difftime(t5,t4_5);
fprintf(stderr,"\ttime placing %f\n",diff);
diff = difftime(t5,t0);
fprintf(stderr,"\ttotal time in place_halos.c %f\n",diff);
fprintf(stderr,"\n\tPlacement done!!!\n");
#endif
free(NHalosPerCell);
free(count);
//free(NPartPerCell);
free(CumulativeProb);
free(MassLeft);
for (i=0;i<NCells;i++){
for (j=0;j<NCells;j++){
for (k=0;k<NCells;k++){
lin_ijk = k+j*NCells+i*NCells*NCells;
//free(ListOfPart[lin_ijk]);
//free(ListOfHalos[lin_ijk]);
}
}
}
//free(ListOfPart);
free(ListOfHalos);
#ifdef MASS_OF_PARTS
free(excluded); free(Nexcluded);
#endif
fprintf(stderr," e ");
return 0;
}
