void ifft3_allocate(sf_complex *inp /* [nk*n2*n3] */)
/*< allocate inverse transform >*/
{
#ifdef SF_HAS_FFTW
icfg = cmplx?
fftwf_plan_dft_3d(n3,n2,n1,
(fftwf_complex *) inp,
(fftwf_complex *) cc[0][0],
FFTW_BACKWARD, FFTW_MEASURE):
fftwf_plan_dft_c2r_3d(n3,n2,n1,
(fftwf_complex *) inp, ff[0][0],
FFTW_MEASURE);
if (NULL == icfg) sf_error("FFTW failure.");
#endif
}
int main(int argc, char **argv){
FILE *fid;
size_t elem;
long int i,j,p;
long int indi, indj;
double kk;
fftwf_complex *map_vel_c;
float *map;
fftwf_complex *map_in_c;
fftwf_plan pc2r;
fftwf_plan pr2c;
char fname[256];
DIR* dir;
if(argc != 2) {
printf("Usage: get_velocityfield work_dir\n");
printf("work_dir - directory containing simfast21.ini \n");
exit(1);
}
get_Simfast21_params(argv[1]);
#ifdef _OMPTHREAD_
omp_set_num_threads(global_nthreads);
fftwf_init_threads();
fftwf_plan_with_nthreads(global_nthreads);
printf("Using %d threads\n",global_nthreads);
#endif
if(!(map=(float *) fftwf_malloc(global_N_halo*global_N_halo*global_N_halo*sizeof(float)))) {
printf("Problem...\n");
exit(1);
}
if(!(map_in_c = (fftwf_complex*) fftwf_malloc(sizeof(fftwf_complex) * global_N_halo*global_N_halo*(global_N_halo/2+1)))) {
printf(" Out of memory...\n");
exit(1);
}
if(!(map_vel_c = (fftwf_complex*) fftwf_malloc(sizeof(fftwf_complex) * global_N_halo*global_N_halo*(global_N_halo/2+1)))) {
printf("Problem allocating memory for x velocity field in k-space...\n");
exit(1);
}
/* Tansformacoes de fourier para calcular as caixas vx(x) vx(y) e vx(z) */
if(!(pc2r=fftwf_plan_dft_c2r_3d(global_N_halo, global_N_halo, global_N_halo, map_vel_c, map, FFTW_ESTIMATE))) {
printf("Problem...\n");
exit(1);
}
/* FFT para map */
if(!(pr2c=fftwf_plan_dft_r2c_3d(global_N_halo, global_N_halo, global_N_halo, map , map_in_c, FFTW_ESTIMATE))) {
printf("Problem...\n");
exit(1);
}
sprintf(fname, "%s/delta/delta_z0_N%ld_L%d.dat", argv[1],global_N_halo,(int)(global_L));
/*Leitura do campo de densidades no espaco real*/
fid=fopen(fname,"rb"); /* second argument contains name of input file */
if (fid==NULL) {
printf("\n Density file path is not correct or the file does not exit...\n");
exit (1);
}
elem=fread(map,sizeof(float),global_N_halo*global_N_halo*global_N_halo,fid);
fclose(fid);
/***********************************************************************************/
// Conversao do mapa de densidades de real para complexo
fftwf_execute(pr2c);
/********************************************************************/
/********************************************************************/
/********************************************************************/
/* Computing velocity fields */
/* Create directory Velocity */
sprintf(fname,"%s/Velocity",argv[1]);
if((dir=opendir(fname))==NULL) {
printf("Creating Velocity directory\n");
if(mkdir(fname,(S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH))!=0) {
printf("Error creating directory!\n");
exit(1);
}
}
/********************************************************************/
printf("\nComputing v_x field...\n");fflush(0);
#ifdef _OMPTHREAD_
#pragma omp parallel for shared(global_N_halo,global_dk,map_vel_c,map_in_c,global_dx_halo) private(i,indi,j,indj,p,kk)
#endif
for(i=0;i<global_N_halo;i++) {
if(i>global_N_halo/2) { /* Large frequencies are equivalent to smaller negative ones */
indi=-(global_N_halo-i);
}else indi=i;
for(j=0;j<global_N_halo;j++) {
if(j>global_N_halo/2) {
indj=-(global_N_halo-j);
}else indj=j;
for(p=0;p<=global_N_halo/2;p++) {
kk=global_dk*sqrt(indi*indi+indj*indj+p*p);
if(kk>0){
//Normalizacao pois a biblioteca fftw3 não tem dx nem global_dk nos integrais
map_in_c[i*global_N_halo*(global_N_halo/2+1)+j*(global_N_halo/2+1)+p]=I*(global_dk)*(1/(kk*kk))*map_in_c[i*global_N_halo*(global_N_halo/2+1)+j*(global_N_halo/2+1)+p]*global_dx_halo*global_dx_halo*global_dx_halo/global_L3;
map_vel_c[i*global_N_halo*(global_N_halo/2+1)+j*(global_N_halo/2+1)+p]=indi*map_in_c[i*global_N_halo*(global_N_halo/2+1)+j*(global_N_halo/2+1)+p];
}else{
map_vel_c[i*global_N_halo*(global_N_halo/2+1)+j*(global_N_halo/2+1)+p]=0;
}
}
}
}
box_symmetriesf(map_vel_c,global_N_halo);
/* Executes FFT */
fftwf_execute(pc2r);
printf("\nWriting v_x field to file...\n");fflush(0);
sprintf(fname, "%s/Velocity/vel_x_z0_N%ld_L%d.dat", argv[1],global_N_halo,(int)(global_L));
if((fid=fopen(fname,"wb"))==NULL){
printf("\nThe file cannot be open\n");
return 0;
}
elem=fwrite(map,sizeof(float),global_N_halo*global_N_halo*global_N_halo,fid);
fclose(fid);
/********************************************************************/
printf("\nComputing v_y field...\n");fflush(0);
#ifdef _OMPTHREAD_
#pragma omp parallel for shared(global_N_halo,global_dk,map_vel_c,map_in_c,global_dx_halo) private(i,indi,j,indj,p,kk)
#endif
for(i=0;i<global_N_halo;i++) {
if(i>global_N_halo/2) { /* Large frequencies are equivalent to smaller negative ones */
indi=-(global_N_halo-i);
}else indi=i;
for(j=0;j<global_N_halo;j++) {
if(j>global_N_halo/2) {
indj=-(global_N_halo-j);
}else indj=j;
for(p=0;p<=global_N_halo/2;p++) {
kk=global_dk*sqrt(indi*indi+indj*indj+p*p);
if(kk>0){
//Normalizacao pois a biblioteca fftw3 não tem dx nem global_dk nos integrais
map_vel_c[i*global_N_halo*(global_N_halo/2+1)+j*(global_N_halo/2+1)+p]=indj*map_in_c[i*global_N_halo*(global_N_halo/2+1)+j*(global_N_halo/2+1)+p];
}else{
map_vel_c[i*global_N_halo*(global_N_halo/2+1)+j*(global_N_halo/2+1)+p]=0;
}
}
}
}
box_symmetriesf(map_vel_c,global_N_halo);
/* Executes FFT */
fftwf_execute(pc2r);
printf("\nWriting v_y field to file...\n");fflush(0);
sprintf(fname, "%s/Velocity/vel_y_z0_N%ld_L%d.dat", argv[1],global_N_halo,(int)(global_L));
if((fid=fopen(fname,"wb"))==NULL){
printf("\nThe file cannot be open\n");
return 0;
}
elem=fwrite(map,sizeof(float),global_N_halo*global_N_halo*global_N_halo,fid);
fclose(fid);
/********************************************************************/
printf("\nComputing v_z field...\n");fflush(0);
#ifdef _OMPTHREAD_
#pragma omp parallel for shared(global_N_halo,global_dk,map_vel_c,map_in_c,global_dx_halo) private(i,indi,j,indj,p,kk)
#endif
for(i=0;i<global_N_halo;i++) {
if(i>global_N_halo/2) { /* Large frequencies are equivalent to smaller negative ones */
indi=-(global_N_halo-i);
}else indi=i;
for(j=0;j<global_N_halo;j++) {
if(j>global_N_halo/2) {
indj=-(global_N_halo-j);
}else indj=j;
for(p=0;p<=global_N_halo/2;p++) {
kk=global_dk*sqrt(indi*indi+indj*indj+p*p);
if(kk>0){
//Normalizacao pois a biblioteca fftw3 não tem dx nem global_dk nos integrais
map_vel_c[i*global_N_halo*(global_N_halo/2+1)+j*(global_N_halo/2+1)+p]=p*map_in_c[i*global_N_halo*(global_N_halo/2+1)+j*(global_N_halo/2+1)+p];
}else{
map_vel_c[i*global_N_halo*(global_N_halo/2+1)+j*(global_N_halo/2+1)+p]=0;
}
}
}
}
box_symmetriesf(map_vel_c,global_N_halo);
/* Executes FFT */
fftwf_execute(pc2r);
printf("\nWriting v_z field to file...\n");fflush(0);
sprintf(fname, "%s/Velocity/vel_z_z0_N%ld_L%d.dat", argv[1],global_N_halo,(int)(global_L));
if((fid=fopen(fname,"wb"))==NULL){
printf("\nThe file cannot be open\n");
return 0;
}
elem=fwrite(map,sizeof(float),global_N_halo*global_N_halo*global_N_halo,fid);
fclose(fid);
fftwf_free(map);
fftwf_free(map_in_c);
fftwf_free(map_vel_c);
fftwf_destroy_plan(pc2r);
fftwf_destroy_plan(pr2c);
exit(0);
}
int main( int argc , char *argv[] ) {
/* index counters */
int i ;
/* Command line options */
char *output_file_name ;
char *static_file_name ;
char *mobile_file_name ;
int global_grid_size ;
int angle_step ;
float surface ;
float internal_value ;
int electrostatics ;
int keep_per_rotation ;
int kept_scores ;
int rescue ;
int calculate ;
float reverse_calculated_one_span ;
char *default_global_grid_size ;
char *default_angle_step ;
char *default_surface ;
char *default_internal_value ;
char *default_electrostatics ;
char *default_keep_per_rotation ;
/* File stuff */
FILE *ftdock_file ;
char line_buffer[100] ;
int id , id2 , SCscore ;
float RPscore ;
int x , y , z , z_twist , theta , phi ;
/* Angles stuff */
struct Angle Angles ;
int first_rotation , rotation ;
/* Structures */
struct Structure Static_Structure , Mobile_Structure ;
struct Structure Origin_Static_Structure , Origin_Mobile_Structure ;
struct Structure Rotated_at_Origin_Mobile_Structure ;
/* Co-ordinates */
int xyz , fx , fy , fz , fxyz ;
/* Grid stuff */
float grid_span , one_span ;
float *static_grid ;
float *mobile_grid ;
float *convoluted_grid ;
float *static_elec_grid = ( void * ) 0 ;
float *mobile_elec_grid = ( void * ) 0 ;
float *convoluted_elec_grid = ( void * ) 0 ;
/* FFTW stuff */
fftwf_plan ps, pse, pm, pme, pinvs, pinvse;
fftwf_complex *static_fsg ;
fftwf_complex *mobile_fsg ;
fftwf_complex *multiple_fsg ;
fftwf_complex *static_elec_fsg = ( void * ) 0 ;
fftwf_complex *mobile_elec_fsg = ( void * ) 0 ;
fftwf_complex *multiple_elec_fsg = ( void * ) 0 ;
/* Scores */
struct Score *Scores ;
float max_es_value ;
/* Timing */
unsigned long tb, ta;
struct rusage rb, ra;
struct timeval tvb, tva;
/************/
/* Its nice to tell people what going on straight away */
setvbuf( stdout , (char *)NULL , _IONBF , 0 ) ;
printf( "\n 3D-Dock Suite (March 2001)\n" ) ;
printf( " Copyright (C) 1997-2000 Gidon Moont\n" ) ;
printf( " This program comes with ABSOLUTELY NO WARRANTY\n" ) ;
printf( " for details see license. This program is free software,\n");
printf( " and you may redistribute it under certain conditions.\n\n");
printf( " Biomolecular Modelling Laboratory\n" ) ;
printf( " Imperial Cancer Research Fund\n" ) ;
printf( " 44 Lincoln's Inn Fields\n" ) ;
printf( " London WC2A 3PX\n" ) ;
printf( " +44 (0)20 7269 3348\n" ) ;
printf( " http://www.bmm.icnet.uk/\n\n" ) ;
printf( "Starting FTDock (v2.0) global search program\n" ) ;
/************/
/* Memory allocation */
if( ( ( output_file_name = ( char * ) malloc ( 500 * sizeof( char ) ) ) == NULL ) ||
( ( static_file_name = ( char * ) malloc ( 500 * sizeof( char ) ) ) == NULL ) ||
( ( mobile_file_name = ( char * ) malloc ( 500 * sizeof( char ) ) ) == NULL ) ) {
GENERAL_MEMORY_PROBLEM
}
/************/
/* Command Line defaults */
strcpy( output_file_name , "ftdock_global.dat" ) ;
strcpy( static_file_name , " --static file name was not provided--" ) ;
strcpy( mobile_file_name , " --mobile file name was not provided--" ) ;
global_grid_size = 128 ;
angle_step = 12 ;
surface = 1.3 ;
internal_value = -15 ;
electrostatics = 1 ;
keep_per_rotation = 3 ;
rescue = 0 ;
calculate = 1 ;
reverse_calculated_one_span = 0.7 ;
default_global_grid_size = "(default calculated)" ;
default_angle_step = "(default)" ;
default_surface = "(default)" ;
default_internal_value = "(default)" ;
default_electrostatics = "(default)" ;
default_keep_per_rotation = "(default)" ;
/* Command Line parse */
for( i = 1 ; i < argc ; i ++ ) {
if( strcmp( argv[i] , "-out" ) == 0 ) {
i ++ ;
if( ( i == argc ) || ( strncmp( argv[i] , "-" , 1 ) == 0 ) ) {
printf( "Bad command line\n" ) ;
exit( EXIT_FAILURE ) ;
}
strcpy( output_file_name , argv[i] ) ;
} else {
if( strcmp( argv[i] , "-static" ) == 0 ) {
i ++ ;
if( ( i == argc ) || ( strncmp( argv[i] , "-" , 1 ) == 0 ) ) {
printf( "Bad command line\n" ) ;
exit( EXIT_FAILURE ) ;
}
strcpy( static_file_name , argv[i] ) ;
} else {
if( strcmp( argv[i] , "-mobile" ) == 0 ) {
i ++ ;
if( ( i == argc ) || ( strncmp( argv[i] , "-" , 1 ) == 0 ) ) {
printf( "Bad command line\n" ) ;
exit( EXIT_FAILURE ) ;
}
strcpy( mobile_file_name , argv[i] ) ;
} else {
if( strcmp( argv[i] , "-grid" ) == 0 ) {
i ++ ;
if( ( i == argc ) || ( strncmp( argv[i] , "-" , 1 ) == 0 ) ) {
printf( "Bad command line\n" ) ;
exit( EXIT_FAILURE ) ;
}
sscanf( argv[i] , "%d" , &global_grid_size ) ;
if( ( global_grid_size % 2 ) != 0 ) {
printf( "Grid size must be even\n" ) ;
exit( EXIT_FAILURE ) ;
}
default_global_grid_size = "(user defined)" ;
calculate = 0 ;
} else {
if( strcmp( argv[i] , "-angle_step" ) == 0 ) {
i ++ ;
if( ( i == argc ) || ( strncmp( argv[i] , "-" , 1 ) == 0 ) ) {
printf( "Bad command line\n" ) ;
exit( EXIT_FAILURE ) ;
}
sscanf( argv[i] , "%d" , &angle_step ) ;
default_angle_step = "(user defined)" ;
} else {
if( strcmp( argv[i] , "-surface" ) == 0 ) {
i ++ ;
if( ( i == argc ) || ( strncmp( argv[i] , "-" , 1 ) == 0 ) ) {
printf( "Bad command line\n" ) ;
exit( EXIT_FAILURE ) ;
}
sscanf( argv[i] , "%f" , &surface ) ;
default_surface = "(user defined)" ;
} else {
if( strcmp( argv[i] , "-internal" ) == 0 ) {
i ++ ;
if( i == argc ) {
printf( "Bad command line\n" ) ;
exit( EXIT_FAILURE ) ;
}
sscanf( argv[i] , "%f" , &internal_value ) ;
default_internal_value = "(user defined)" ;
} else {
if( strcmp( argv[i] , "-noelec" ) == 0 ) {
electrostatics = 0 ;
default_electrostatics = "(user defined)" ;
} else {
if( strcmp( argv[i] , "-keep" ) == 0 ) {
i ++ ;
if( ( i == argc ) || ( strncmp( argv[i] , "-" , 1 ) == 0 ) ) {
printf( "Bad command line\n" ) ;
exit( EXIT_FAILURE ) ;
}
sscanf( argv[i] , "%d" , &keep_per_rotation ) ;
default_keep_per_rotation = "(user defined)" ;
} else {
if( strcmp( argv[i] , "-rescue" ) == 0 ) {
rescue = 1 ;
} else {
if( strcmp( argv[i] , "-calculate_grid" ) == 0 ) {
i ++ ;
if( ( i == argc ) || ( strncmp( argv[i] , "-" , 1 ) == 0 ) ) {
printf( "Bad command line\n" ) ;
exit( EXIT_FAILURE ) ;
}
calculate = 1 ;
default_global_grid_size = "(user defined calculated)" ;
sscanf( argv[i] , "%f" , &reverse_calculated_one_span ) ;
} else {
printf( "Bad command line\n" ) ;
exit( EXIT_FAILURE ) ;
}
}
}
}
}
}
}
}
}
}
}
}
/************/
/* Rescue option */
if( rescue == 1 ) {
printf( "RESCUE mode\n" ) ;
if( ( ftdock_file = fopen( "scratch_parameters.dat" , "r" ) ) == NULL ) {
printf( "Could not open scratch_parameters.dat for reading.\nDying\n\n" ) ;
exit( EXIT_FAILURE ) ;
}
calculate = 0 ;
default_global_grid_size = "(read from rescue file)" ;
default_angle_step = "(read from rescue file)" ;
default_surface = "(read from rescue file)" ;
default_internal_value = "(read from rescue file)" ;
default_electrostatics = "(read from rescue file)" ;
while( fgets( line_buffer , 99 , ftdock_file ) ) {
if( strncmp( line_buffer , "Static molecule" , 15 ) == 0 ) sscanf( line_buffer , "Static molecule :: %s" , static_file_name ) ;
if( strncmp( line_buffer , "Mobile molecule" , 15 ) == 0 ) sscanf( line_buffer , "Mobile molecule :: %s" , mobile_file_name ) ;
if( strncmp( line_buffer , "Output file name" , 16 ) == 0 ) sscanf( line_buffer , "Output file name :: %s" , output_file_name ) ;
if( strncmp( line_buffer , "Global grid size" , 16 ) == 0 ) sscanf( line_buffer , "Global grid size :: %d" , &global_grid_size ) ;
if( strncmp( line_buffer , "Global search angle step" , 24 ) == 0 ) sscanf( line_buffer , "Global search angle step :: %d" , &angle_step ) ;
if( strncmp( line_buffer , "Global surface thickness" , 24 ) == 0 ) sscanf( line_buffer , "Global surface thickness :: %f" , &surface ) ;
if( strncmp( line_buffer , "Global internal deterrent value" , 31 ) == 0 ) sscanf( line_buffer , "Global internal deterrent value :: %f" , &internal_value ) ;
if( strncmp( line_buffer , "Electrostatics :: on" , 44 ) == 0 ) electrostatics = 1 ;
if( strncmp( line_buffer , "Electrostatics :: off" , 44 ) == 0 ) electrostatics = 0 ;
if( strncmp( line_buffer , "Global keep per rotation" , 25 ) == 0 ) sscanf( line_buffer , "Global keep per rotation :: %d" , &keep_per_rotation ) ;
}
fclose( ftdock_file ) ;
if( ( ftdock_file = fopen( "scratch_scores.dat" , "r" ) ) == NULL ) {
printf( "Could not open scratch_scores.dat for reading.\nDying\n\n" ) ;
exit( EXIT_FAILURE ) ;
}
char* r = fgets( line_buffer , 99 , ftdock_file ) ;
while( fgets( line_buffer , 99 , ftdock_file ) ) {
sscanf( line_buffer , "G_DATA %d " , &first_rotation ) ;
}
fclose( ftdock_file ) ;
first_rotation ++ ;
printf( "Will be starting from rotation %d\n" , first_rotation ) ;
/************/
} else {
first_rotation = 1 ;
}
/************/
/* Do these things first so that bad inputs will be caught soonest */
/* Read in Structures from pdb files */
Static_Structure = read_pdb_to_structure( static_file_name ) ;
Mobile_Structure = read_pdb_to_structure( mobile_file_name ) ;
if( Mobile_Structure.length > Static_Structure.length ) {
printf( "WARNING\n" ) ;
printf( "The mobile molecule has more residues than the static\n" ) ;
printf( "Are you sure you have the correct molecules?\n" ) ;
printf( "Continuing anyway\n" ) ;
}
/************/
/* Get angles */
Angles = generate_global_angles( angle_step ) ;
printf( "Total number of rotations is %d\n" , Angles.n ) ;
/************/
/* Assign charges */
if( electrostatics == 1 ) {
printf( "Assigning charges\n" ) ;
assign_charges( Static_Structure ) ;
assign_charges( Mobile_Structure ) ;
}
/************/
/* Store new structures centered on Origin */
Origin_Static_Structure = translate_structure_onto_origin( Static_Structure ) ;
Origin_Mobile_Structure = translate_structure_onto_origin( Mobile_Structure ) ;
/* Free some memory */
for( i = 1 ; i <= Static_Structure.length ; i ++ ) {
free( Static_Structure.Residue[i].Atom ) ;
}
free( Static_Structure.Residue ) ;
for( i = 1 ; i <= Mobile_Structure.length ; i ++ ) {
free( Mobile_Structure.Residue[i].Atom ) ;
}
free( Mobile_Structure.Residue ) ;
/************/
/* Calculate Grid stuff */
grid_span = total_span_of_structures( Origin_Static_Structure , Origin_Mobile_Structure ) ;
if( calculate == 1 ) {
printf( "Using automatic calculation for grid size\n" ) ;
global_grid_size = (int)( grid_span / reverse_calculated_one_span ) ;
if( ( global_grid_size % 2 ) != 0 ) global_grid_size ++ ;
}
one_span = grid_span / (float)global_grid_size ;
printf( "Span = %.3f angstroms\n" , grid_span ) ;
printf( "Grid size = %d\n" , global_grid_size ) ;
printf( "Each Grid cube = %.5f angstroms\n" , one_span ) ;
/************/
/* Memory Allocation */
if( ( Scores = ( struct Score * ) malloc ( ( keep_per_rotation + 2 ) * sizeof( struct Score ) ) ) == NULL ) {
GENERAL_MEMORY_PROBLEM
}
if(
( ( static_grid = ( float * ) malloc
( global_grid_size * global_grid_size * ( 2 * ( global_grid_size / 2 + 1 ) ) * sizeof( float ) ) ) == NULL )
||
( ( mobile_grid = ( float * ) malloc
( global_grid_size * global_grid_size * ( 2 * ( global_grid_size / 2 + 1 ) ) * sizeof( float ) ) ) == NULL )
||
( ( convoluted_grid = ( float * ) malloc
( global_grid_size * global_grid_size * ( 2 * ( global_grid_size / 2 + 1 ) ) * sizeof( float ) ) ) == NULL )
) {
printf( "Not enough memory for surface grids\nUse (sensible) smaller grid size\nDying\n\n" ) ;
exit( EXIT_FAILURE ) ;
}
static_fsg = ( fftwf_complex * ) static_grid ;
mobile_fsg = ( fftwf_complex * ) mobile_grid ;
multiple_fsg = ( fftwf_complex * ) convoluted_grid ;
if( electrostatics == 1 ) {
if(
( ( static_elec_grid = ( float * ) malloc
( global_grid_size * global_grid_size * ( 2 * ( global_grid_size / 2 + 1 ) ) * sizeof( float ) ) ) == NULL )
||
( ( mobile_elec_grid = ( float * ) malloc
( global_grid_size * global_grid_size * ( 2 * ( global_grid_size / 2 + 1 ) ) * sizeof( float ) ) ) == NULL )
||
( ( convoluted_elec_grid = ( float * ) malloc
( global_grid_size * global_grid_size * ( 2 * ( global_grid_size / 2 + 1 ) ) * sizeof( float ) ) ) == NULL )
) {
printf( "Not enough memory for electrostatic grids\nSwitch off electrostatics or use (sensible) smaller grid size\nDying\n\n" ) ;
exit( EXIT_FAILURE ) ;
} else {
/* all ok */
printf( "Electrostatics are on\n" ) ;
}
static_elec_fsg = ( fftwf_complex * ) static_elec_grid ;
mobile_elec_fsg = ( fftwf_complex * ) mobile_elec_grid ;
multiple_elec_fsg = ( fftwf_complex * ) convoluted_elec_grid ;
}
/************/
/* Create FFTW plans */
printf( "Creating plans\n" ) ;
ps = fftwf_plan_dft_r2c_3d( global_grid_size , global_grid_size , global_grid_size , static_grid, (fftwf_complex*)static_grid,
FFTW_MEASURE) ;
if( electrostatics == 1 ) {
pse = fftwf_plan_dft_r2c_3d( global_grid_size , global_grid_size , global_grid_size , static_elec_grid, (fftwf_complex*)static_elec_grid,
FFTW_MEASURE ) ;
}
pm = fftwf_plan_dft_r2c_3d( global_grid_size , global_grid_size , global_grid_size , mobile_grid, (fftwf_complex*)mobile_grid,
FFTW_MEASURE ) ;
if (electrostatics == 1) {
pme = fftwf_plan_dft_r2c_3d( global_grid_size , global_grid_size , global_grid_size , mobile_elec_grid, (fftwf_complex*)mobile_elec_grid,
FFTW_MEASURE) ;
}
pinvs = fftwf_plan_dft_c2r_3d( global_grid_size , global_grid_size , global_grid_size , multiple_fsg, (float*)multiple_fsg,
FFTW_MEASURE ) ;
if (electrostatics == 1) {
pinvse = fftwf_plan_dft_c2r_3d( global_grid_size , global_grid_size , global_grid_size , multiple_elec_fsg, (float*)multiple_elec_fsg,
FFTW_MEASURE ) ;
}
/************/
getrusage(RUSAGE_SELF, &rb);
gettimeofday(&tvb, NULL);
printf( "Setting up Static Structure\n" ) ;
/* Discretise and surface the Static Structure (need do only once) */
discretise_structure( Origin_Static_Structure , grid_span , global_grid_size , static_grid ) ;
printf( " surfacing grid\n" ) ;
surface_grid( grid_span , global_grid_size , static_grid , surface , internal_value ) ;
/* Calculate electic field at all grid nodes (need do only once) */
if( electrostatics == 1 ) {
electric_field( Origin_Static_Structure , grid_span , global_grid_size , static_elec_grid ) ;
electric_field_zero_core( global_grid_size , static_elec_grid , static_grid , internal_value ) ;
}
/* Fourier Transform the static grids (need do only once) */
printf( " one time forward FFT calculations\n" ) ;
fftwf_execute(ps);
if( electrostatics == 1 ) {
fftwf_execute(pse);
}
printf( " done\n" ) ;
/************/
/* Store paramaters in case of rescue */
if( ( ftdock_file = fopen( "scratch_parameters.dat" , "w" ) ) == NULL ) {
printf( "Could not open scratch_parameters.dat for writing.\nDying\n\n" ) ;
exit( EXIT_FAILURE ) ;
}
fprintf( ftdock_file, "\nGlobal Scan\n" ) ;
fprintf( ftdock_file, "\nCommand line controllable values\n" ) ;
fprintf( ftdock_file, "Static molecule :: %s\n" , static_file_name ) ;
fprintf( ftdock_file, "Mobile molecule :: %s\n" , mobile_file_name ) ;
fprintf( ftdock_file, "Output file name :: %s\n" , output_file_name ) ;
fprintf( ftdock_file, "\n" ) ;
fprintf( ftdock_file, "Global grid size :: %6d %s\n" , global_grid_size , default_global_grid_size ) ;
fprintf( ftdock_file, "Global search angle step :: %6d %s\n" , angle_step , default_angle_step ) ;
fprintf( ftdock_file, "Global surface thickness :: %9.2f %s\n" , surface , default_surface ) ;
fprintf( ftdock_file, "Global internal deterrent value :: %9.2f %s\n" , internal_value , default_internal_value ) ;
if( electrostatics == 1 ) {
fprintf( ftdock_file, "Electrostatics :: on %s\n" , default_electrostatics ) ;
} else {
fprintf( ftdock_file, "Electrostatics :: off %s\n" , default_electrostatics ) ;
}
fprintf( ftdock_file, "Global keep per rotation :: %6d %s\n" , keep_per_rotation , default_keep_per_rotation ) ;
fprintf( ftdock_file, "\nCalculated values\n" ) ;
fprintf( ftdock_file, "Global rotations :: %6d\n" , Angles.n ) ;
fprintf( ftdock_file, "Global total span (angstroms) :: %10.3f\n" , grid_span ) ;
fprintf( ftdock_file, "Global grid cell span (angstroms) :: %10.3f\n" , one_span ) ;
fclose( ftdock_file ) ;
/************/
/* Main program loop */
max_es_value = 0 ;
printf( "Starting main loop through the rotations\n" ) ;
/* PCA: start comment
for( rotation = first_rotation ; rotation <= Angles.n ; rotation ++ ) {
* PCA: end comment
*/
for( rotation = first_rotation ; rotation <= 10/*Angles.n*/ ; rotation ++ ) {
printf( "." ) ;
if( ( rotation % 50 ) == 0 ) printf( "\nRotation number %5d\n" , rotation ) ;
/* Rotate Mobile Structure */
Rotated_at_Origin_Mobile_Structure =
rotate_structure( Origin_Mobile_Structure , (int)Angles.z_twist[rotation] , (int)Angles.theta[rotation] , (int)Angles.phi[rotation] ) ;
/* Discretise the rotated Mobile Structure */
discretise_structure( Rotated_at_Origin_Mobile_Structure , grid_span , global_grid_size , mobile_grid ) ;
/* Electic point charge approximation onto grid calculations ( quicker than filed calculations by a long way! ) */
if( electrostatics == 1 ) {
electric_point_charge( Rotated_at_Origin_Mobile_Structure , grid_span , global_grid_size , mobile_elec_grid ) ;
}
/* Forward Fourier Transforms */
fftwf_execute(pm);
if( electrostatics == 1 ) {
fftwf_execute(pme);
}
/************/
/* Do convolution of the two sets of grids
convolution is equivalent to multiplication of the complex conjugate of one
fourier grid with other (raw) one
hence the sign changes from a normal complex number multiplication
*/
for( fx = 0 ; fx < global_grid_size ; fx ++ ) {
for( fy = 0 ; fy < global_grid_size ; fy ++ ) {
for( fz = 0 ; fz < global_grid_size/2 + 1 ; fz ++ ) {
fxyz = fz + ( global_grid_size/2 + 1 ) * ( fy + global_grid_size * fx ) ;
multiple_fsg[fxyz][0] =
c_re(static_fsg[fxyz]) * c_re(mobile_fsg[fxyz]) + c_im(static_fsg[fxyz]) * c_im(mobile_fsg[fxyz]) ;
multiple_fsg[fxyz][1] =
c_im(static_fsg[fxyz]) * c_re(mobile_fsg[fxyz]) - c_re(static_fsg[fxyz]) * c_im(mobile_fsg[fxyz]) ;
if( electrostatics == 1 ) {
multiple_elec_fsg[fxyz][0] =
c_re(static_elec_fsg[fxyz]) * c_re(mobile_elec_fsg[fxyz]) + c_im(static_elec_fsg[fxyz]) * c_im(mobile_elec_fsg[fxyz]) ;
multiple_elec_fsg[fxyz][1] =
c_im(static_elec_fsg[fxyz]) * c_re(mobile_elec_fsg[fxyz]) - c_re(static_elec_fsg[fxyz]) * c_im(mobile_elec_fsg[fxyz]) ;
}
}
}
}
/* Reverse Fourier Transform */
fftwf_execute(pinvs);
if( electrostatics == 1 ) {
fftwf_execute(pinvse);
}
/************/
/* Get best scores */
for( i = 0 ; i < keep_per_rotation ; i ++ ) {
Scores[i].score = 0 ;
Scores[i].rpscore = 0.0 ;
Scores[i].coord[1] = 0 ;
Scores[i].coord[2] = 0 ;
Scores[i].coord[3] = 0 ;
}
for( x = 0 ; x < global_grid_size ; x ++ ) {
fx = x ;
if( fx > ( global_grid_size / 2 ) ) fx -= global_grid_size ;
for( y = 0 ; y < global_grid_size ; y ++ ) {
fy = y ;
if( fy > ( global_grid_size / 2 ) ) fy -= global_grid_size ;
for( z = 0 ; z < global_grid_size ; z ++ ) {
fz = z ;
if( fz > ( global_grid_size / 2 ) ) fz -= global_grid_size ;
xyz = z + ( 2 * ( global_grid_size / 2 + 1 ) ) * ( y + global_grid_size * x ) ;
if( ( electrostatics == 0 ) || ( convoluted_elec_grid[xyz] < 0 ) ) {
/* Scale factor from FFTs */
if( (int)convoluted_grid[xyz] != 0 ) {
convoluted_grid[xyz] /= ( global_grid_size * global_grid_size * global_grid_size ) ;
}
if( (int)convoluted_grid[xyz] > Scores[keep_per_rotation-1].score ) {
i = keep_per_rotation - 2 ;
while( ( (int)convoluted_grid[xyz] > Scores[i].score ) && ( i >= 0 ) ) {
Scores[i+1].score = Scores[i].score ;
Scores[i+1].rpscore = Scores[i].rpscore ;
Scores[i+1].coord[1] = Scores[i].coord[1] ;
Scores[i+1].coord[2] = Scores[i].coord[2] ;
Scores[i+1].coord[3] = Scores[i].coord[3] ;
i -- ;
}
Scores[i+1].score = (int)convoluted_grid[xyz] ;
if( ( electrostatics != 0 ) && ( convoluted_elec_grid[xyz] < 0.1 ) ) {
Scores[i+1].rpscore = (float)convoluted_elec_grid[xyz] ;
} else {
Scores[i+1].rpscore = (float)0 ;
}
Scores[i+1].coord[1] = fx ;
Scores[i+1].coord[2] = fy ;
Scores[i+1].coord[3] = fz ;
}
}
}
}
}
if( rotation == 1 ) {
if( ( ftdock_file = fopen( "scratch_scores.dat" , "w" ) ) == NULL ) {
printf( "Could not open scratch_scores.dat for writing.\nDying\n\n" ) ;
exit( EXIT_FAILURE ) ;
}
} else {
if( ( ftdock_file = fopen( "scratch_scores.dat" , "a" ) ) == NULL ) {
printf( "Could not open scratch_scores.dat for writing.\nDying\n\n" ) ;
exit( EXIT_FAILURE ) ;
}
}
for( i = 0 ; i < keep_per_rotation ; i ++ ) {
max_es_value = min( max_es_value , Scores[i].rpscore ) ;
/* PCA: start comment
fprintf( ftdock_file, "G_DATA %6d %6d %7d %.0f %4d %4d %4d %4d%4d%4d\n" ,
rotation , 0 , Scores[i].score , (float)Scores[i].rpscore , Scores[i].coord[1] , Scores[i].coord[2] , Scores[i].coord[3 ] ,
Angles.z_twist[rotation] , Angles.theta[rotation] , Angles.phi[rotation] ) ;
* PCA: Stop comment
*/
fprintf( stdout, "G_DATA %6d %6d %7d %4d %4d %4d %4d%4d%4d\n" ,
rotation , 0 , Scores[i].score , Scores[i].coord[1] , Scores[i].coord[2] , Scores[i].coord[3 ] ,
Angles.z_twist[rotation] , Angles.theta[rotation] , Angles.phi[rotation] ) ;
}
fclose( ftdock_file ) ;
/* Free some memory */
for( i = 1 ; i <= Rotated_at_Origin_Mobile_Structure.length ; i ++ ) {
free( Rotated_at_Origin_Mobile_Structure.Residue[i].Atom ) ;
}
free( Rotated_at_Origin_Mobile_Structure.Residue ) ;
}
/* Finished main loop */
/************/
/* Free the memory */
fftwf_destroy_plan( ps ) ;
fftwf_destroy_plan( pse ) ;
fftwf_destroy_plan( pm ) ;
fftwf_destroy_plan( pme ) ;
fftwf_destroy_plan( pinvs ) ;
fftwf_destroy_plan( pinvse ) ;
free( static_grid ) ;
free( mobile_grid ) ;
free( convoluted_grid ) ;
if( electrostatics == 1 ) {
free( static_elec_grid ) ;
free( mobile_elec_grid ) ;
free( convoluted_elec_grid ) ;
}
for( i = 1 ; i <= Origin_Static_Structure.length ; i ++ ) {
free( Origin_Static_Structure.Residue[i].Atom ) ;
}
free( Origin_Static_Structure.Residue ) ;
for( i = 1 ; i <= Origin_Mobile_Structure.length ; i ++ ) {
free( Origin_Mobile_Structure.Residue[i].Atom ) ;
}
free( Origin_Mobile_Structure.Residue ) ;
/* PCA: Finishing programm here*/
getrusage(RUSAGE_SELF, &ra);
gettimeofday(&tva, NULL);
struct timeval usertimea = ra.ru_utime;
struct timeval systimea = ra.ru_stime;
unsigned long long usera = usertimea.tv_sec*1e6 + usertimea.tv_usec;
unsigned long long sysa = systimea.tv_sec*1e6 + systimea.tv_usec;
struct timeval usertimeb = rb.ru_utime;
struct timeval systimeb = rb.ru_stime;
unsigned long long userb = usertimeb.tv_sec*1e6 + usertimeb.tv_usec;
unsigned long long sysb = systimeb.tv_sec*1e6 + systimeb.tv_usec;
unsigned long long user = usera - userb;
unsigned long long sys = sysa - sysb;
unsigned long long mem_max = ra.ru_maxrss;
unsigned long long elapsed = (tva.tv_sec - tvb.tv_sec)*1e6 + (tva.tv_usec - tvb.tv_usec);
fprintf(stderr, "{ \"elapsed\": %llu, \"user\": %llu, \"sys\": %llu, \"mem_max\": %llu }", elapsed, user, sys, mem_max);
return 0;
/* PCA: */
/************/
/* Read in all the scores */
printf( "\nReloading all the scores\n" ) ;
if( ( ftdock_file = fopen( "scratch_scores.dat" , "r" ) ) == NULL ) {
printf( "Could not open scratch_scores.dat for reading.\nDying\n\n" ) ;
exit( EXIT_FAILURE ) ;
}
if( ( Scores = ( struct Score * ) realloc ( Scores , ( 1 + keep_per_rotation ) * Angles.n * sizeof( struct Score ) ) ) == NULL ) {
printf( "Not enough memory left for storing scores\nProbably keeping too many per rotation\nDying\n\n" ) ;
exit( EXIT_FAILURE ) ;
}
kept_scores = 0 ;
while( fgets( line_buffer , 99 , ftdock_file ) ) {
sscanf( line_buffer , "G_DATA %d %d %d %f %d %d %d %d %d %d" , &id , &id2 , &SCscore , &RPscore ,
&x , &y , &z , &z_twist , &theta , &phi ) ;
Scores[kept_scores].score = SCscore ;
Scores[kept_scores].rpscore = RPscore ;
Scores[kept_scores].coord[1] = x ;
Scores[kept_scores].coord[2] = y ;
Scores[kept_scores].coord[3] = z ;
Scores[kept_scores].angle[1] = z_twist ;
Scores[kept_scores].angle[2] = theta ;
Scores[kept_scores].angle[3] = phi ;
kept_scores ++ ;
}
fclose( ftdock_file ) ;
kept_scores -- ;
qsort_scores( Scores , 0 , kept_scores ) ;
/************/
/* Writing data file */
if( ( ftdock_file = fopen( output_file_name , "w" ) ) == NULL ) {
printf( "Could not open %s for writing.\nDying\n\n" , output_file_name ) ;
exit( EXIT_FAILURE ) ;
}
fprintf( ftdock_file, "FTDOCK data file\n" ) ;
fprintf( ftdock_file, "\nGlobal Scan\n" ) ;
fprintf( ftdock_file, "\nCommand line controllable values\n" ) ;
fprintf( ftdock_file, "Static molecule :: %s\n" , static_file_name ) ;
fprintf( ftdock_file, "Mobile molecule :: %s\n" , mobile_file_name ) ;
fprintf( ftdock_file, "\n" ) ;
fprintf( ftdock_file, "Global grid size :: %6d %s\n" , global_grid_size , default_global_grid_size ) ;
fprintf( ftdock_file, "Global search angle step :: %6d %s\n" , angle_step , default_angle_step ) ;
fprintf( ftdock_file, "Global surface thickness :: %9.2f %s\n" , surface , default_surface ) ;
fprintf( ftdock_file, "Global internal deterrent value :: %9.2f %s\n" , internal_value , default_internal_value ) ;
if( electrostatics == 1 ) {
fprintf( ftdock_file, "Electrostatics :: on %s\n" , default_electrostatics ) ;
} else {
fprintf( ftdock_file, "Electrostatics :: off %s\n" , default_electrostatics ) ;
}
fprintf( ftdock_file, "Global keep per rotation :: %6d %s\n" , keep_per_rotation , default_keep_per_rotation ) ;
fprintf( ftdock_file, "\nCalculated values\n" ) ;
fprintf( ftdock_file, "Global rotations :: %6d\n" , Angles.n ) ;
fprintf( ftdock_file, "Global total span (angstroms) :: %10.3f\n" , grid_span ) ;
fprintf( ftdock_file, "Global grid cell span (angstroms) :: %10.3f\n" , one_span ) ;
fprintf( ftdock_file, "\nData\n" ) ;
fprintf( ftdock_file , "Type ID prvID SCscore ESratio Coordinates Angles\n\n" ) ;
if( electrostatics == 1 ) {
for( i = 0 ; i <= min( kept_scores , ( NUMBER_TO_KEEP - 1 ) ) ; i ++ ) {
fprintf( ftdock_file, "G_DATA %6d %6d %7d %8.3f %4d %4d %4d %4d%4d%4d\n" ,
i + 1 , 0 , Scores[i].score , 100 * ( Scores[i].rpscore / max_es_value ) ,
Scores[i].coord[1] , Scores[i].coord[2] , Scores[i].coord[3] ,
Scores[i].angle[1] , Scores[i].angle[2] , Scores[i].angle[3] ) ;
}
} else {
for( i = 0 ; i <= min( kept_scores , ( NUMBER_TO_KEEP - 1 ) ) ; i ++ ) {
fprintf( ftdock_file, "G_DATA %6d %6d %7d %8.3f %4d %4d %4d %4d%4d%4d\n" ,
i + 1 , 0 , Scores[i].score , 0.0 ,
Scores[i].coord[1] , Scores[i].coord[2] , Scores[i].coord[3] ,
Scores[i].angle[1] , Scores[i].angle[2] , Scores[i].angle[3] ) ;
}
}
fclose( ftdock_file ) ;
/************/
printf( "\n\nFinished\n\n" ) ;
return( 0 ) ;
} /* end main */
int main(int argc, char *argv[]) {
char fname[300];
FILE *fid;
DIR* dir;
size_t elem;
long int ii,ij,ik, ii_c, ij_c, ik_c, a, b, c;
long int ncells_1D;
long int i,j,p,indi,indj,ind;
int flag_bub,iz;
double redshift,tmp;
double kk;
double bfactor; /* value by which to divide bubble size R */
double neutral,*xHI;
float *halo_map, *top_hat_r, *density_map,*bubblef, *bubble;
fftwf_complex *halo_map_c, *top_hat_c, *collapsed_mass_c, *density_map_c, *total_mass_c, *bubble_c;
fftwf_plan pr2c1,pr2c2,pr2c3,pr2c4,pc2r1,pc2r2,pc2r3;
double zmin,zmax,dz;
double R;
if(argc != 2) {
printf("Generates boxes with ionization fraction for a range of redshifts\n");
printf("usage: get_HIIbubbles base_dir\n");
printf("base_dir contains simfast21.ini and directory structure\n");
exit(1);
}
get_Simfast21_params(argv[1]);
zmin=global_Zminsim;
zmax=global_Zmaxsim;
dz=global_Dzsim;
bfactor=pow(10.0,log10(global_bubble_Rmax/global_dx_smooth)/global_bubble_Nbins);
printf("Bubble radius ratio (bfactor): %f\n", bfactor); fflush(0);
#ifdef _OMPTHREAD_
omp_set_num_threads(global_nthreads);
fftwf_init_threads();
fftwf_plan_with_nthreads(global_nthreads);
printf("Using %d threads\n",global_nthreads);fflush(0);
#endif
/* Create directory Ionization */
sprintf(fname,"%s/Ionization",argv[1]);
if((dir=opendir(fname))==NULL) {
printf("Creating Ionization directory\n");
if(mkdir(fname,(S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH))!=0) {
printf("Error creating directory!\n");
exit(1);
}
}
sprintf(fname,"%s/Output_text_files",argv[1]);
if((dir=opendir(fname))==NULL) {
printf("Creating Output_text_files directory\n");
if(mkdir(fname,(S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH))!=0) {
printf("Error creating directory!\n");
exit(1);
}
}
/* Memory allocation - we could do some of the FFTs inline... */
/*************************************************************/
/* density_map mass */
if(!(density_map=(float *) fftwf_malloc(global_N3_smooth*sizeof(float)))) {
printf("Problem1...\n");
exit(1);
}
if(!(density_map_c=(fftwf_complex *) fftwf_malloc(global_N_smooth*global_N_smooth*(global_N_smooth/2+1)*sizeof(fftwf_complex)))) {
printf("Problem2...\n");
exit(1);
}
if(!(pr2c1=fftwf_plan_dft_r2c_3d(global_N_smooth, global_N_smooth, global_N_smooth, density_map, density_map_c, FFTWflag))) {
printf("Problem3...\n");
exit(1);
}
/* halo_map mass */
if(!(halo_map=(float *) fftwf_malloc(global_N3_smooth*sizeof(float)))) {
printf("Problem4...\n");
exit(1);
}
if(!(halo_map_c=(fftwf_complex *) fftwf_malloc(global_N_smooth*global_N_smooth*(global_N_smooth/2+1)*sizeof(fftwf_complex)))) {
printf("Problem5...\n");
exit(1);
}
if(!(pr2c2=fftwf_plan_dft_r2c_3d(global_N_smooth, global_N_smooth, global_N_smooth, halo_map, halo_map_c, FFTWflag))) {
printf("Problem6...\n");
exit(1);
}
/* total mass */
if(!(total_mass_c=(fftwf_complex *) fftwf_malloc(global_N_smooth*global_N_smooth*(global_N_smooth/2+1)*sizeof(fftwf_complex)))) {
printf("Problem7...\n");
exit(1);
}
if(!(pc2r1=fftwf_plan_dft_c2r_3d(global_N_smooth, global_N_smooth, global_N_smooth, total_mass_c, density_map, FFTWflag))) {
printf("Problem8...\n");
exit(1);
}
/* collapsed mass */
if(!(collapsed_mass_c=(fftwf_complex *) fftwf_malloc(global_N_smooth*global_N_smooth*(global_N_smooth/2+1)*sizeof(fftwf_complex)))) {
printf("Problem9...\n");
exit(1);
}
if(!(pc2r2=fftwf_plan_dft_c2r_3d(global_N_smooth, global_N_smooth, global_N_smooth, collapsed_mass_c, halo_map, FFTWflag))) {
printf("Problem10...\n");
exit(1);
}
/* top hat window */
if(!(top_hat_r=(float *) fftwf_malloc(global_N3_smooth*sizeof(float)))) {
printf("Problem11...\n");
exit(1);
}
if(!(top_hat_c=(fftwf_complex *) fftwf_malloc(global_N_smooth*global_N_smooth*(global_N_smooth/2+1)*sizeof(fftwf_complex)))) {
printf("Problem12...\n");
exit(1);
}
if(!(pr2c3=fftwf_plan_dft_r2c_3d(global_N_smooth, global_N_smooth, global_N_smooth, top_hat_r, top_hat_c, FFTWflag))) {
printf("Problem13...\n");
exit(1);
}
/* bubble boxes */
if(!(bubble=(float *) fftwf_malloc(global_N3_smooth*sizeof(float)))) {
printf("Problem14...\n");
exit(1);
}
if(!(bubble_c=(fftwf_complex *) fftwf_malloc(global_N_smooth*global_N_smooth*(global_N_smooth/2+1)*sizeof(fftwf_complex)))) {
printf("Problem15...\n");
exit(1);
}
if(!(bubblef=(float *) malloc(global_N3_smooth*sizeof(float)))) {
printf("Problem16...\n");
exit(1);
}
if(!(pr2c4=fftwf_plan_dft_r2c_3d(global_N_smooth, global_N_smooth, global_N_smooth, bubble, bubble_c, FFTWflag))) {
printf("Problem17...\n");
exit(1);
}
if(!(pc2r3=fftwf_plan_dft_c2r_3d(global_N_smooth, global_N_smooth, global_N_smooth, bubble_c, bubble, FFTWflag))) {
printf("Problem18...\n");
exit(1);
}
if(!(xHI=(double *) malloc((int)((zmax-zmin)/dz+2)*sizeof(double)))) {
printf("Problem19...\n");
exit(1);
}
/****************************************************/
/***************** Redshift cycle *******************/
printf("Number of bubble sizes: %d\n",(int)((log(global_bubble_Rmax)-log(2.*global_dx_smooth))/log(bfactor)));
printf("Redshift cycle...\n");fflush(0);
iz=0;
neutral=0.;
for(redshift=zmin;redshift<(zmax+dz/10) && (neutral < xHlim);redshift+=dz){
printf("z = %f\n",redshift);fflush(0);
sprintf(fname, "%s/delta/deltanl_z%.3f_N%ld_L%.1f.dat",argv[1],redshift,global_N_smooth,global_L/global_hubble);
fid=fopen(fname,"rb");
if (fid==NULL) {printf("\nError reading deltanl file... Check path or if the file exists..."); exit (1);}
elem=fread(density_map,sizeof(float),global_N3_smooth,fid);
fclose(fid);
#ifdef _OMPTHREAD_
#pragma omp parallel for shared(global_N3_smooth, density_map,global_rho_m, global_dx_smooth,bubblef) private(i)
#endif
for(i=0;i<(global_N3_smooth);i++){
density_map[i]=(1.0+density_map[i])*global_rho_m*global_dx_smooth*global_dx_smooth*global_dx_smooth; /* total mass in 1 cell */
bubblef[i]=0.0;
}
sprintf(fname, "%s/Halos/masscoll_z%.3f_N%ld_L%.1f.dat",argv[1],redshift,global_N_smooth,global_L/global_hubble);
fid=fopen(fname,"rb");
if (fid==NULL) {printf("\nError reading %s file... Check path or if the file exists...",fname); exit (1);}
elem=fread(halo_map,sizeof(float),global_N3_smooth,fid);
fclose(fid);
/* Quick fill of single cells before going to bubble cycle */
#ifdef _OMPTHREAD_
#pragma omp parallel for shared(global_N3_smooth,halo_map,density_map,global_eff,bubblef) private(i,tmp)
#endif
for(i=0;i<global_N3_smooth;i++) {
if(halo_map[i]>0.) {
if(density_map[i]>0.)
tmp=(double)halo_map[i]*global_eff/density_map[i];
else tmp=1.0;
}else tmp=0.;
if(tmp>=1.0) bubblef[i]=1.0; else bubblef[i]=tmp;
}
/* FFT density and halos */
fftwf_execute(pr2c1);
fftwf_execute(pr2c2);
/************** going over the bubble sizes ****************/
R=global_bubble_Rmax; /* Maximum bubble size...*/
while(R>=2*global_dx_smooth){
printf("bubble radius R= %lf\n", R);fflush(0);
// printf("Filtering halo and density boxes...\n");fflush(0);
#ifdef _OMPTHREAD_
#pragma omp parallel for shared(collapsed_mass_c,halo_map_c,total_mass_c,density_map_c,global_N_smooth,global_dk,R) private(i,j,p,indi,indj,kk)
#endif
for(i=0;i<global_N_smooth;i++) {
if(i>global_N_smooth/2) {
indi=-(global_N_smooth-i);
}else indi=i;
for(j=0;j<global_N_smooth;j++) {
if(j>global_N_smooth/2) {
indj=-(global_N_smooth-j);
}else indj=j;
for(p=0;p<=global_N_smooth/2;p++) {
kk=global_dk*sqrt(indi*indi+indj*indj+p*p);
total_mass_c[i*global_N_smooth*(global_N_smooth/2+1)+j*(global_N_smooth/2+1)+p]=density_map_c[i*global_N_smooth*(global_N_smooth/2+1)+j*(global_N_smooth/2+1)+p]*W_filter(kk*R);
collapsed_mass_c[i*global_N_smooth*(global_N_smooth/2+1)+j*(global_N_smooth/2+1)+p]=halo_map_c[i*global_N_smooth*(global_N_smooth/2+1)+j*(global_N_smooth/2+1)+p]*W_filter(kk*R);
}
}
}
fftwf_execute(pc2r1);
fftwf_execute(pc2r2);
flag_bub=0;
// printf("Starting to find and fill bubbles...\n");fflush(0);
/* signal center of bubbles */
#ifdef _OMPTHREAD_
#pragma omp parallel for shared(halo_map,density_map,bubble,global_N_smooth,global_eff,flag_bub) private(ii,ij,ik,ind)
#endif
for(ii=0;ii<global_N_smooth;ii++){
for(ij=0;ij<global_N_smooth;ij++){
for(ik=0;ik<global_N_smooth;ik++){
ind=ii*global_N_smooth*global_N_smooth+ij*global_N_smooth+ik;
if(halo_map[ind]>0.) {
if(density_map[ind]>0.) {
if((double)halo_map[ind]/density_map[ind]>=1.0/global_eff) {
flag_bub=1;
bubble[ind]=1.0;
}else bubble[ind]=0;
}else {
flag_bub=1;
bubble[ind]=1.0;
}
}else bubble[ind]=0;
}
}
}
/* generate spherical window in real space for a given R */
if(flag_bub>0){
printf("Found bubble...\n");fflush(0);
#ifdef _OMPTHREAD_
#pragma omp parallel for shared(top_hat_r,R,global_dx_smooth,global_N_smooth) private(i,j,p)
#endif
for(i=0;i<global_N_smooth;i++){
for(j=0;j<global_N_smooth;j++){
for(p=0;p<global_N_smooth;p++){
if(sqrt(i*i+j*j+p*p)*global_dx_smooth<=R || sqrt(i*i+(j-global_N_smooth)*(j-global_N_smooth)+p*p)*global_dx_smooth<=R || sqrt(i*i+(j-global_N_smooth)*(j-global_N_smooth)+(p-global_N_smooth)*(p-global_N_smooth))*global_dx_smooth <=R || sqrt(i*i+(p-global_N_smooth)*(p-global_N_smooth)+j*j)*global_dx_smooth<=R || sqrt((i-global_N_smooth)*(i-global_N_smooth)+j*j+p*p)*global_dx_smooth<=R || sqrt((i-global_N_smooth)*(i-global_N_smooth)+(j-global_N_smooth)*(j-global_N_smooth)+p*p)*global_dx_smooth<=R || sqrt((i-global_N_smooth)*(i-global_N_smooth)+(j-global_N_smooth)*(j-global_N_smooth)+(p-global_N_smooth)*(p-global_N_smooth))*global_dx_smooth<=R || sqrt((i-global_N_smooth)*(i-global_N_smooth)+j*j+(p-global_N_smooth)*(p-global_N_smooth))*global_dx_smooth<=R ) {
top_hat_r[i*global_N_smooth*global_N_smooth+j*global_N_smooth+p]=1.0;
}else top_hat_r[i*global_N_smooth*global_N_smooth+j*global_N_smooth+p]=0.0;
}
}
}
/* FFT bubble centers and window */
fftwf_execute(pr2c3);
fftwf_execute(pr2c4);
/* Make convolution */
#ifdef _OMPTHREAD_
#pragma omp parallel for shared(bubble_c,top_hat_c,global_N_smooth) private(i)
#endif
for(i=0;i<global_N_smooth*global_N_smooth*(global_N_smooth/2+1);i++) {
bubble_c[i]*=top_hat_c[i];
}
fftwf_execute(pc2r3);
/* after dividing by global_N3_smooth, values in bubble are between 0 (neutral)and global_N3_smooth */
#ifdef _OMPTHREAD_
#pragma omp parallel for shared(bubble,bubblef,global_N3_smooth) private(i)
#endif
for (i=0; i<global_N3_smooth; i++){
bubble[i]/=global_N3_smooth;
if (bubble[i]>0.2) bubblef[i]=1.0; /* neutral should be zero */
}
} /* ends filling out bubbles in box for R */
R/=bfactor;
} /* ends R cycle */
/* just to check smallest bubbles through older method */
printf("Going to smaller R cycle...\n"); fflush(0);
while(R>=global_dx_smooth){
printf("bubble radius R= %lf\n", R);fflush(0);
flag_bub=0;
#ifdef _OMPTHREAD_
#pragma omp parallel for shared(collapsed_mass_c,halo_map_c,total_mass_c,density_map_c,global_N_smooth,global_dx_smooth,global_dk,R) private(i,j,p,indi,indj,kk)
#endif
for(i=0;i<global_N_smooth;i++) {
if(i>global_N_smooth/2) {
indi=-(global_N_smooth-i);
}else indi=i;
for(j=0;j<global_N_smooth;j++) {
if(j>global_N_smooth/2) {
indj=-(global_N_smooth-j);
}else indj=j;
for(p=0;p<=global_N_smooth/2;p++) {
kk=global_dk*sqrt(indi*indi+indj*indj+p*p);
total_mass_c[i*global_N_smooth*(global_N_smooth/2+1)+j*(global_N_smooth/2+1)+p]=density_map_c[i*global_N_smooth*(global_N_smooth/2+1)+j*(global_N_smooth/2+1)+p]*W_filter(kk*R);
collapsed_mass_c[i*global_N_smooth*(global_N_smooth/2+1)+j*(global_N_smooth/2+1)+p]=halo_map_c[i*global_N_smooth*(global_N_smooth/2+1)+j*(global_N_smooth/2+1)+p]*W_filter(kk*R);
}
}
}
fftwf_execute(pc2r1);
fftwf_execute(pc2r2);
/* fill smaller bubbles in box */
ncells_1D=(long int)(R/global_dx_smooth);
// printf("Starting to find and fill bubbles...\n");fflush(0);
#ifdef _OMPTHREAD_
#pragma omp parallel for shared(halo_map,density_map,global_eff,global_N_smooth,global_dx_smooth,R,ncells_1D,bubblef,flag_bub) private(ii_c,ij_c,ik_c,ii,ij,ik,a,b,c,ind)
#endif
for(ii_c=0;ii_c<global_N_smooth;ii_c++){
for(ij_c=0;ij_c<global_N_smooth;ij_c++){
for(ik_c=0;ik_c<global_N_smooth;ik_c++){
ind=ii_c*global_N_smooth*global_N_smooth+ij_c*global_N_smooth+ik_c;
if(halo_map[ind]>0.) {
if(!(density_map[ind]>0.) || ((double)halo_map[ind]/density_map[ind]>=1.0/global_eff)) {
flag_bub=1;
for(ii=-(ncells_1D+1);ii<=ncells_1D+1;ii++){
a=check_borders(ii_c+ii,global_N_smooth);
for(ij=-(ncells_1D+1);ij<=ncells_1D+1;ij++){
if(sqrt(ii*ii+ij*ij)*global_dx_smooth <= R){
b=check_borders(ij_c+ij,global_N_smooth);
for(ik=-(ncells_1D+1);ik<=ncells_1D+1;ik++){
c=check_borders(ik_c+ik,global_N_smooth);
if(sqrt(ii*ii+ij*ij+ik*ik)*global_dx_smooth <= R){
bubblef[a*global_N_smooth*global_N_smooth+b*global_N_smooth+c]=1.0;
}
}
}
}
}
}
}
}
}
}
if(flag_bub>0){printf("Found bubble...\n");fflush(0);}
R/=bfactor;
} /* ends small bubbles R cycle */
neutral=0.;
for (i=0; i<global_N3_smooth; i++){
neutral+=1.0-bubblef[i];
}
neutral/=global_N3_smooth;
printf("neutral fraction=%lf\n",neutral);fflush(0);
xHI[iz]=neutral;
sprintf(fname, "%s/Ionization/xHII_z%.3f_eff%.2lf_N%ld_L%.1f.dat",argv[1],redshift,global_eff,global_N_smooth,global_L/global_hubble);
if((fid = fopen(fname,"wb"))==NULL) {
printf("Error opening file:%s\n",fname);
exit(1);
}
elem=fwrite(bubblef,sizeof(float),global_N3_smooth,fid);
fclose(fid);
iz++;
} /* ends redshift cycle */
/* z cycle for neutral>=xHlim */
while(redshift<(zmax+dz/10)) {
printf("z(>%f) = %f\n",xHlim,redshift);fflush(0);
xHI[iz]=1.0;
sprintf(fname, "%s/Ionization/xHII_z%.3f_eff%.2lf_N%ld_L%.1f.dat",argv[1],redshift,global_eff,global_N_smooth,global_L/global_hubble);
if((fid = fopen(fname,"wb"))==NULL) {
printf("Error opening file:%s\n",fname);
exit(1);
}
#ifdef _OMPTHREAD_
#pragma omp parallel for shared(bubblef,global_N3_smooth) private(i)
#endif
for(i=0;i<global_N3_smooth;i++) bubblef[i]=0.0;
elem=fwrite(bubblef,sizeof(float),global_N3_smooth,fid);
fclose(fid);
iz++;
redshift+=dz;
}
sprintf(fname, "%s/Output_text_files/zsim.txt",argv[1]);
if((fid = fopen(fname,"a"))==NULL) {
printf("Error opening file:%s\n",fname);
exit(1);
}
for(redshift=zmax;redshift>(zmin-dz/10);redshift-=dz) fprintf(fid,"%f\n",redshift); /* first line should be highest redshift */
fclose(fid);
sprintf(fname, "%s/Output_text_files/x_HI_eff%.2lf_N%ld_L%.1f.dat",argv[1],global_eff,global_N_smooth,global_L/global_hubble);
if((fid = fopen(fname,"a"))==NULL) {
printf("Error opening file:%s\n",fname);
exit(1);
}
for(i=iz-1;i>=0;i--) fprintf(fid,"%lf\n",xHI[i]); /* first line should be highest redshift */
fclose(fid);
free(xHI);
free(bubblef);
fftwf_free(top_hat_r);
fftwf_free(top_hat_c);
fftwf_free(collapsed_mass_c);
fftwf_free(density_map);
fftwf_free(density_map_c);
fftwf_free(halo_map);
fftwf_free(halo_map_c);
fftwf_free(total_mass_c);
fftwf_free(bubble);
fftwf_free(bubble_c);
exit(0);
}
void initTurbulence(ref_ptr<VectorGrid> grid, double Brms, double lMin,
double lMax, double alpha, int seed) {
size_t Nx = grid->getNx();
size_t Ny = grid->getNy();
size_t Nz = grid->getNz();
if ((Nx != Ny) or (Ny != Nz))
throw std::runtime_error("turbulentField: only cubic grid supported");
double spacing = grid->getSpacing();
if (lMin < 2 * spacing)
throw std::runtime_error("turbulentField: lMin < 2 * spacing");
if (lMin >= lMax)
throw std::runtime_error("turbulentField: lMin >= lMax");
if (lMax > Nx * spacing / 2)
throw std::runtime_error("turbulentField: lMax > size / 2");
size_t n = Nx; // size of array
size_t n2 = (size_t) floor(n / 2) + 1; // size array in z-direction in configuration space
// arrays to hold the complex vector components of the B(k)-field
fftwf_complex *Bkx, *Bky, *Bkz;
Bkx = (fftwf_complex*) fftwf_malloc(sizeof(fftwf_complex) * n * n * n2);
Bky = (fftwf_complex*) fftwf_malloc(sizeof(fftwf_complex) * n * n * n2);
Bkz = (fftwf_complex*) fftwf_malloc(sizeof(fftwf_complex) * n * n * n2);
Random random;
if (seed != 0)
random.seed(seed); // use given seed
// calculate the n possible discrete wave numbers
double K[n];
for (int i = 0; i < n; i++)
K[i] = (double) i / n - i / (n / 2);
// construct the field in configuration space
int i;
double k, theta, phase, cosPhase, sinPhase;
double kMin = spacing / lMax;
double kMax = spacing / lMin;
Vector3f b; // real b-field vector
Vector3f ek, e1, e2; // orthogonal base
Vector3f n0(1, 1, 1); // arbitrary vector to construct orthogonal base
for (size_t ix = 0; ix < n; ix++) {
for (size_t iy = 0; iy < n; iy++) {
for (size_t iz = 0; iz < n2; iz++) {
i = ix * n * n2 + iy * n2 + iz;
ek.setXYZ(K[ix], K[iy], K[iz]);
k = ek.getR();
// wave outside of turbulent range -> B(k) = 0
if ((k < kMin) || (k > kMax)) {
Bkx[i][0] = 0;
Bkx[i][1] = 0;
Bky[i][0] = 0;
Bky[i][1] = 0;
Bkz[i][0] = 0;
Bkz[i][1] = 0;
continue;
}
// construct an orthogonal base ek, e1, e2
if (ek.isParallelTo(n0, float(1e-3))) {
// ek parallel to (1,1,1)
e1.setXYZ(-1., 1., 0);
e2.setXYZ(1., 1., -2.);
} else {
// ek not parallel to (1,1,1)
e1 = n0.cross(ek);
e2 = ek.cross(e1);
}
e1 /= e1.getR();
e2 /= e2.getR();
// random orientation perpendicular to k
theta = 2 * M_PI * random.rand();
b = e1 * cos(theta) + e2 * sin(theta);
// normal distributed amplitude with mean = 0 and sigma = k^alpha/2
b *= random.randNorm() * pow(k, alpha / 2);
// uniform random phase
phase = 2 * M_PI * random.rand();
cosPhase = cos(phase); // real part
sinPhase = sin(phase); // imaginary part
Bkx[i][0] = b.x * cosPhase;
Bkx[i][1] = b.x * sinPhase;
Bky[i][0] = b.y * cosPhase;
Bky[i][1] = b.y * sinPhase;
Bkz[i][0] = b.z * cosPhase;
Bkz[i][1] = b.z * sinPhase;
}
}
}
// in-place, complex to real, inverse Fourier transformation on each component
// note that the last elements of B(x) are unused now
float *Bx = (float*) Bkx;
fftwf_plan plan_x = fftwf_plan_dft_c2r_3d(n, n, n, Bkx, Bx, FFTW_ESTIMATE);
fftwf_execute(plan_x);
fftwf_destroy_plan(plan_x);
float *By = (float*) Bky;
fftwf_plan plan_y = fftwf_plan_dft_c2r_3d(n, n, n, Bky, By, FFTW_ESTIMATE);
fftwf_execute(plan_y);
fftwf_destroy_plan(plan_y);
float *Bz = (float*) Bkz;
fftwf_plan plan_z = fftwf_plan_dft_c2r_3d(n, n, n, Bkz, Bz, FFTW_ESTIMATE);
fftwf_execute(plan_z);
fftwf_destroy_plan(plan_z);
// save to grid
for (size_t ix = 0; ix < n; ix++) {
for (size_t iy = 0; iy < n; iy++) {
for (size_t iz = 0; iz < n; iz++) {
i = ix * n * 2 * n2 + iy * 2 * n2 + iz;
Vector3f &b = grid->get(ix, iy, iz);
b.x = Bx[i];
b.y = By[i];
b.z = Bz[i];
}
}
}
fftwf_free(Bkx);
fftwf_free(Bky);
fftwf_free(Bkz);
scaleGrid(grid, Brms / rmsFieldStrength(grid)); // normalize to Brms
}
