void scene_free(scene_t *scene) {
int i;
glDisable(GL_LIGHT0);
glDisable(GL_LIGHT1);
glDisable(GL_LIGHT2);
glDisable(GL_LIGHT3);
glDisable(GL_LIGHT4);
glDisable(GL_LIGHT5);
glDisable(GL_LIGHT6);
glDisable(GL_LIGHT7);
if(scene->land) land_free(scene->land);
if(scene->camera) camera_free(scene->camera);
if(scene->pathpos) spline_free(scene->pathpos);
if(scene->pathdir) spline_free(scene->pathdir);
if(scene->sky) sky_free(scene->sky);
if(scene->sun) sky_sun_free(scene->sun);
if(scene->pathsun) spline_free(scene->pathsun);
for(i = 0; i < scene->num_mesh; i++) thing_mesh_free(scene->mesh[i]);
if(scene->mesh) free(scene->mesh);
for(i = 0; i < scene->num_thing; i++) thing_free(scene->thing[i]);
if(scene->thing) free(scene->thing);
for(i = 0; i < scene->num_animation; i++) {
thing_free(scene->animation[i]->thing);
if(scene->animation[i]->path) spline_free(scene->animation[i]->path);
free(scene->animation[i]);
}
if(scene->animation) free(scene->animation);
for(i = 0; i < scene->num_particle; i++) {
particle_free(scene->particle[i]->particle);
if(scene->particle[i]->path) spline_free(scene->particle[i]->path);
free(scene->particle[i]);
}
if(scene->particle) free(scene->particle);
for(i = 0; i < scene->num_dynamiclight; i++) {
dynamiclight_free(scene->dynamiclight[i]->light);
if(scene->dynamiclight[i]->path) spline_free(scene->dynamiclight[i]->path);
free(scene->dynamiclight[i]);
}
if(scene->dynamiclight) free(scene->dynamiclight);
free(scene);
}
void memclr( void )
{
char *me = "memclr";
char msg[256], **names = NULL;
int iblk,i,j,k,len2,num_tp_curs,icur, num_edits, num_tpc, num_tp;
TimePlotCurve_t *tpc_ptr = NULL;
TimePlot_t *tp_ptr = NULL;
RGST_AttributeElem_t *func;
if (domains != NULL) {
for ( iblk = 0 ; iblk < nblk ; iblk++ ) {
domain_free(&domains[iblk]);
}
}
spline_free();
decomp_free();
NodeList_free();
conditionals_free();
species_free();
TimeStepControl_free(NULL);
FunctionTimer_free(gv_hash_tbl);
FunctionTimer_ht_remove(gv_hash_tbl, "global");
FunctionTimer_ht_setup (gv_hash_tbl, "global");
UserList_free();
if (ifcom) freecom();
FREEMEM(lnbuf);
line = NULL;
GlobalArrays_free(NULL);
func = rgst_list_attr(A_OBJECT, "Function_Free");
while (func != NULL) {
Command_t *cp = (Command_t *) func->rgst_obj->obj;
(*(cp->proc))(NULL);
func = func->next;
}
if (rgst_check_for_obj("sourceData") == TRUE) {
rgst_del("sourceData");
for ( i = 0 ; i < nsrc ; i++ ) {
if (src[i].nzsrc > 0) { FREEMEM(src[i].ndxsrc) ; }
if (src[i].nidat1 > 0) { FREEMEM(src[i].idat1) ; }
if (src[i].nfdat1 > 0) { FREEMEM(src[i].fdat1) ; }
if (src[i].ndat2 > 0) { FREEMEM(src[i].dat2) ; }
}
FREEMEM(src) ;
}
nsrc = 0;
if (rgst_check_for_obj("freqMesgData") == TRUE) {
rgst_del("freqMesgData");
for ( i = 0 ; i < nfq ; i++ ) {
rgst_del (fq[i].name);
FREEMEM(fq[i].msg) ;
FREEMEM(fq[i].name) ;
}
FREEMEM(fq) ;
FREEMEM(fqtp) ;
}
nfq = 0;
if (rgst_check_for_obj("cycleMesgData") == TRUE) {
rgst_del("cycleMesgData");
for ( i = 0 ; i < ncyc ; i++ ) {
rgst_del (cyc[i].name);
FREEMEM(cyc[i].msg) ;
FREEMEM(cyc[i].name) ;
}
FREEMEM(cyc) ;
FREEMEM(cyctp) ;
}
ncyc = 0;
if (rgst_check_for_obj("gparmData") == TRUE) {
rgst_del("gparmData");
FREEMEM(gparm);
}
if (rgst_check_for_obj("timePlotData") == TRUE) {
rgst_del("timePlotData");
for (i=0 ; i<ntp ; i++) {
for (icur=0; icur<tpdata[i]->num_tp_curs; icur++) {
rgst_del(tpdata[i]->tp_curs[icur]->name);
TimePlotCurve_destruct(tpdata[i]->tp_curs[icur]);
}
rgst_del(tpdata[i]->name);
TimePlot_destruct(tpdata[i]);
}
FREEMEM(tpdata);
}
ntp = 0;
Region_free();
if (ptab != NULL) rgst_del("ptabData");
if (etab != NULL) rgst_del("etabData");
if (ktab != NULL) rgst_del("ktabData");
if (stab != NULL) rgst_del("stabData");
FREEMEM(ptab);
FREEMEM(etab);
FREEMEM(ktab);
FREEMEM(stab);
nbq = 0;
if (rgst_check_for_obj("domains") == TRUE) {
rgst_del("domains");
}
FREEMEM(domains);
names = rgst_list_objs_by_type( &num_tp, "TimePlot_t");
for (i = 0; i<num_tp; i++) {
ctlwarning(me,"shawn, why are there time plots left, they should have"
"been removed by now");
tp_ptr = rgst_get_t(names[i],"TimePlot_t");
if (tp_ptr == NULL) ctlerror(me,logic_err);
rgst_del(names[i]);
tp_ptr = TimePlot_destruct(tp_ptr);
FREEMEM(names[i]);
}
FREEMEM(names);
hash_del_objs_of_type(gv_hash_tbl,"double",NULL);
#ifdef DEBUG
hash_print_by_type(rgst_objs_hash_tbl);
hash_print_by_type(gv_hash_tbl);
#endif
}
RunParams *init_params(char *fname_ini)
{
FILE *fi;
int n,ii,stat,ibin;
double *x,*a,*y,dchi;
RunParams *par=param_new();
par->cpar=csm_params_new();
read_parameter_file(fname_ini,par);
csm_unset_gsl_eh();
if(par->has_bg) {
double hub;
csm_background_set(par->cpar,par->om,par->ol,par->ob,par->w0,par->wa,par->h0,D_TCMB);
par->chi_horizon=csm_radial_comoving_distance(par->cpar,0.);
par->chi_kappa=csm_radial_comoving_distance(par->cpar,1./(1+par->z_kappa));
par->chi_isw=csm_radial_comoving_distance(par->cpar,1./(1+par->z_isw));
hub=csm_hubble(par->cpar,1.);
par->prefac_lensing=1.5*hub*hub*par->om;
n=(int)(par->chi_horizon/par->dchi)+1;
dchi=par->chi_horizon/n;
par->dchi=dchi;
x=(double *)my_malloc(n*sizeof(double));
a=(double *)my_malloc(n*sizeof(double));
y=(double *)my_malloc(n*sizeof(double));
for(ii=0;ii<n;ii++)
x[ii]=dchi*ii;
printf("Setting up background splines\n");
//Set chi <-> a correspondence
const gsl_root_fdfsolver_type *T=gsl_root_fdfsolver_newton;
gsl_root_fdfsolver *s=gsl_root_fdfsolver_alloc(T);
double a_old=1.0;
for(ii=0;ii<n;ii++)
a[ii]=a_of_chi(x[ii],par->cpar,&a_old,s);
gsl_root_fdfsolver_free(s);
par->aofchi=spline_init(n,x,a,1.0,0.0);
//Compute redshift
for(ii=0;ii<n;ii++)
y[ii]=1./a[ii]-1;
par->zofchi=spline_init(n,x,y,y[0],y[n-1]);
//Compute hubble scale
for(ii=0;ii<n;ii++)
y[ii]=csm_hubble(par->cpar,a[ii]);
par->hofchi=spline_init(n,x,y,y[0],y[n-1]);
//Compute growth factor
double g0=csm_growth_factor(par->cpar,1.0);
for(ii=0;ii<n;ii++)
y[ii]=csm_growth_factor(par->cpar,a[ii])/g0;
par->gfofchi=spline_init(n,x,y,1.,0.);
//Compute growth rate
for(ii=0;ii<n;ii++)
y[ii]=csm_f_growth(par->cpar,a[ii]);
par->fgofchi=spline_init(n,x,y,y[0],1.);
free(x); free(a); free(y);
}
//Allocate power spectra
if(par->do_nc) {
par->cl_dd=(double *)my_malloc((par->lmax+1)*sizeof(double));
if(par->do_shear) {
par->cl_d1l2=(double *)my_malloc((par->lmax+1)*sizeof(double));
par->cl_d2l1=(double *)my_malloc((par->lmax+1)*sizeof(double));
}
if(par->do_cmblens)
par->cl_dc=(double *)my_malloc((par->lmax+1)*sizeof(double));
if(par->do_isw)
par->cl_di=(double *)my_malloc((par->lmax+1)*sizeof(double));
}
if(par->do_shear) {
par->cl_ll=(double *)my_malloc((par->lmax+1)*sizeof(double));
if(par->do_cmblens)
par->cl_lc=(double *)my_malloc((par->lmax+1)*sizeof(double));
if(par->do_isw)
par->cl_li=(double *)my_malloc((par->lmax+1)*sizeof(double));
}
if(par->do_cmblens) {
par->cl_cc=(double *)my_malloc((par->lmax+1)*sizeof(double));
if(par->do_isw)
par->cl_ci=(double *)my_malloc((par->lmax+1)*sizeof(double));
}
if(par->do_isw)
par->cl_ii=(double *)my_malloc((par->lmax+1)*sizeof(double));
if(par->do_w_theta) {
if(par->do_nc) {
par->wt_dd=(double *)my_malloc(par->n_th*sizeof(double));
if(par->do_shear) {
par->wt_d1l2=(double *)my_malloc(par->n_th*sizeof(double));
par->wt_d2l1=(double *)my_malloc(par->n_th*sizeof(double));
}
if(par->do_cmblens)
par->wt_dc=(double *)my_malloc(par->n_th*sizeof(double));
if(par->do_isw)
par->wt_di=(double *)my_malloc(par->n_th*sizeof(double));
}
if(par->do_shear) {
par->wt_ll_pp=(double *)my_malloc(par->n_th*sizeof(double));
par->wt_ll_mm=(double *)my_malloc(par->n_th*sizeof(double));
if(par->do_cmblens)
par->wt_lc=(double *)my_malloc(par->n_th*sizeof(double));
if(par->do_isw)
par->wt_li=(double *)my_malloc(par->n_th*sizeof(double));
}
if(par->do_cmblens) {
par->wt_cc=(double *)my_malloc(par->n_th*sizeof(double));
if(par->do_isw)
par->wt_ci=(double *)my_malloc(par->n_th*sizeof(double));
}
if(par->do_isw)
par->wt_ii=(double *)my_malloc(par->n_th*sizeof(double));
}
if(par->do_nc || par->do_shear || par->do_cmblens || par->do_isw)
csm_set_linear_pk(par->cpar,par->fname_pk,D_LKMIN,D_LKMAX,0.01,par->ns,par->s8);
if(par->do_nc || par->do_shear) {
par->wind_0=my_malloc(2*sizeof(SplPar *));
for(ibin=0;ibin<2;ibin++) {
printf("Reading window function %s\n",par->fname_window[ibin]);
fi=my_fopen(par->fname_window[ibin],"r");
n=my_linecount(fi); rewind(fi);
//Read unnormalized window
x=(double *)my_malloc(n*sizeof(double));
y=(double *)my_malloc(n*sizeof(double));
for(ii=0;ii<n;ii++) {
stat=fscanf(fi,"%lE %lE",&(x[ii]),&(y[ii]));
if(stat!=2)
report_error(1,"Error reading file, line %d\n",ii+1);
}
fclose(fi);
par->wind_0[ibin]=spline_init(n,x,y,0.,0.);
//Normalize window
double norm,enorm;
gsl_function F;
gsl_integration_workspace *w=gsl_integration_workspace_alloc(1000);
F.function=&speval_bis;
F.params=par->wind_0[ibin];
gsl_integration_qag(&F,x[0],x[n-1],0,1E-4,1000,GSL_INTEG_GAUSS41,w,&norm,&enorm);
gsl_integration_workspace_free(w);
for(ii=0;ii<n;ii++)
y[ii]/=norm;
spline_free(par->wind_0[ibin]);
par->wind_0[ibin]=spline_init(n,x,y,0.,0.);
double zmin,zmax;
double ymax=-1000;
for(ii=0;ii<n;ii++) {
if(y[ii]>ymax)
ymax=y[ii];
}
ii=0;
while(y[ii]<1E-3*ymax)
ii++;
zmin=x[ii];
ii=n-1;
while(y[ii]<1E-3*ymax)
ii--;
zmax=x[ii];
par->chimin_nc[ibin]=csm_radial_comoving_distance(par->cpar,1./(1+zmin));
par->chimax_nc[ibin]=csm_radial_comoving_distance(par->cpar,1./(1+zmax));
#ifdef _DEBUG
printf("%d %lE %lE %lE %lE\n",
ibin,zmin,zmax,par->chimin_nc[ibin],par->chimax_nc[ibin]);
#endif //_DEBUG
free(x); free(y);
}
}
if(par->do_nc) {
if(par->has_dens==1) {
printf("Reading bias function %s\n",par->fname_bias);
fi=my_fopen(par->fname_bias,"r");
n=my_linecount(fi); rewind(fi);
//Read bias
x=(double *)my_malloc(n*sizeof(double));
y=(double *)my_malloc(n*sizeof(double));
for(ii=0;ii<n;ii++) {
stat=fscanf(fi,"%lE %lE",&(x[ii]),&(y[ii]));
if(stat!=2)
report_error(1,"Error reading file, line %d\n",ii+1);
}
fclose(fi);
par->bias=spline_init(n,x,y,y[0],y[n-1]);
free(x); free(y);
}
if(par->has_lensing==1) {
printf("Reading s-bias function %s\n",par->fname_sbias);
fi=my_fopen(par->fname_sbias,"r");
n=my_linecount(fi); rewind(fi);
//Read s-bias
x=(double *)my_malloc(n*sizeof(double));
y=(double *)my_malloc(n*sizeof(double));
for(ii=0;ii<n;ii++) {
stat=fscanf(fi,"%lE %lE",&(x[ii]),&(y[ii]));
if(stat!=2)
report_error(1,"Error reading file, line %d\n",ii+1);
}
fclose(fi);
par->sbias=spline_init(n,x,y,y[0],y[n-1]);
free(x); free(y);
printf("Computing lensing magnification window function\n");
par->wind_M=my_malloc(2*sizeof(SplPar *));
for(ibin=0;ibin<2;ibin++) {
double dchi_here;
double zmax=par->wind_0[ibin]->xf;
double chimax=csm_radial_comoving_distance(par->cpar,1./(1+zmax));
n=(int)(chimax/par->dchi)+1;
dchi_here=chimax/n;
x=(double *)my_malloc(n*sizeof(double));
y=(double *)my_malloc(n*sizeof(double));
#ifdef _HAVE_OMP
#pragma omp parallel default(none) shared(n,x,y,par,dchi_here,ibin)
{
#endif //_HAVE_OMP
int j;
#ifdef _HAVE_OMP
#pragma omp for
#endif //_HAVE_OMP
for(j=0;j<n;j++) {
x[j]=dchi_here*j;
y[j]=window_magnification(x[j],par,ibin);
} //end omp for
#ifdef _HAVE_OMP
} //end omp parallel
#endif //_HAVE_OMP
par->wind_M[ibin]=spline_init(n,x,y,y[0],0);
free(x); free(y);
}
}
}
if(par->do_shear) {
if(par->has_intrinsic_alignment==1) {
printf("Reading IA bias function %s\n",par->fname_abias);
fi=my_fopen(par->fname_abias,"r");
n=my_linecount(fi); rewind(fi);
//Read bias
x=(double *)my_malloc(n*sizeof(double));
y=(double *)my_malloc(n*sizeof(double));
for(ii=0;ii<n;ii++) {
stat=fscanf(fi,"%lE %lE",&(x[ii]),&(y[ii]));
if(stat!=2)
report_error(1,"Error reading file, line %d\n",ii+1);
}
fclose(fi);
par->abias=spline_init(n,x,y,y[0],y[n-1]);
free(x); free(y);
}
printf("Computing lensing window function\n");
par->wind_L=my_malloc(2*sizeof(SplPar *));
for(ibin=0;ibin<2;ibin++) {
double dchi_here;
double zmax=par->wind_0[ibin]->xf;
double chimax=csm_radial_comoving_distance(par->cpar,1./(1+zmax));
n=(int)(chimax/par->dchi)+1;
dchi_here=chimax/n;
x=(double *)my_malloc(n*sizeof(double));
y=(double *)my_malloc(n*sizeof(double));
#ifdef _HAVE_OMP
#pragma omp parallel default(none) shared(n,x,y,par,dchi_here,ibin)
{
#endif //_HAVE_OMP
int j;
#ifdef _HAVE_OMP
#pragma omp for
#endif //_HAVE_OMP
for(j=0;j<n;j++) {
x[j]=dchi_here*j;
y[j]=window_lensing(x[j],par,ibin);
}
#ifdef _HAVE_OMP
} //end omp parallel
#endif //_HAVE_OMP
par->wind_L[ibin]=spline_init(n,x,y,y[0],0);
free(x); free(y);
}
}
#ifdef _DEBUG
print_bg(par);
#endif //_DEBUG
return par;
}
