int make_mi(mi_t* const m, const int n, const int k) {
if (n < k) return 0;
m->k = k;
m->n = n;
init_psi(m);
m->sxs = Calloc(n, coord_t);
m->xiis = Calloc(n, int);
m->sys = Calloc(n, coord_t);
m->yiis = Calloc(n, int);
return 1;
}
int imf_init_multi_power(IMF *imf,int n,double *m,double *alpha)
{
int i;
imf->n = n;
imf->k = 1;
imf->m_max_physical = IMF_MASSINF;
imf->m_cl = 0;
imf->m = (double *) malloc((imf->n+1) * sizeof(double));
imf->f = (double(**)(double,double *))
malloc((imf->n+1) * sizeof(double(*)(double,double *)));
imf->mf = (double(**)(double,double *))
malloc((imf->n+1) * sizeof(double(*)(double,double *)));
imf->F = (double(**)(double,double *))
malloc((imf->n+1) * sizeof(double(*)(double,double *)));
imf->mF = (double(**)(double,double *))
malloc((imf->n+1) * sizeof(double(*)(double,double *)));
imf->invF = (double(**)(double,double *))
malloc((imf->n+1) * sizeof(double(*)(double,double *)));
imf->a_f = (double **) malloc((imf->n+1) * sizeof(double*));
imf->a_mf = (double **) malloc((imf->n+1) * sizeof(double*));
imf->a_F = (double **) malloc((imf->n+1) * sizeof(double*));
imf->a_mF = (double **) malloc((imf->n+1) * sizeof(double*));
imf->a_invF = (double **) malloc((imf->n+1) * sizeof(double*));
imf->m[0] = m[0];
for(i=1;i<=imf->n;i++)
{
imf->f[i] = &imf_power;
imf->mf[i] = &imf_power;
imf->F[i] = &imf_prim_power;
imf->mF[i] = &imf_prim_power;
imf->invF[i] = &imf_inv_prim_power;
imf->a_f[i] = (double *) malloc(PARA_MAX * sizeof(double));
imf->a_mf[i] = (double *) malloc(PARA_MAX * sizeof(double));
imf->a_F[i] = (double *) malloc(PARA_MAX * sizeof(double));
imf->a_mF[i] = (double *) malloc(PARA_MAX * sizeof(double));
imf->a_invF[i] = (double *) malloc(PARA_MAX * sizeof(double));
imf->m[i] = m[i];
imf->a_f[i][0] = alpha[i-1];
imf->a_mf[i][0] = alpha[i-1]+1;
imf->a_F[i][0] = alpha[i-1];
imf->a_mF[i][0] = alpha[i-1]+1;
imf->a_invF[i][0] = alpha[i-1];
}
init_psi(imf);
return 0;
}
int imf_init_user(IMF *imf,char *imf_string_original){
int n,i;
double value;
double value2;
char *pos;
char *seg_pos;
char * imf_string;
char *parameter;
char *segment;
char *function;
segment = (char *) malloc((strlen(imf_string_original)+1)*sizeof(char));
parameter = (char *) malloc((strlen(imf_string_original)+1)*sizeof(char));
imf_string = (char *) malloc((strlen(imf_string_original)+1)*sizeof(char));
function = (char *) malloc((strlen(imf_string_original)+1)*sizeof(char));
strcpy(imf_string,imf_string_original);
n = 0;
pos = imf_string;
/** count bracketts **/
while((*pos) != 0){
if((*pos) == '(')
n++;
pos++;
}
imf->n = n;
imf->k = 1.;
imf->m_max_physical = IMF_MASSINF;
imf->m_cl = 0.;
imf->m = (double *) malloc((imf->n+1) * sizeof(double));
imf->f = (double(**)(double,double *))
malloc((imf->n+1) * sizeof(double(*)(double,double *)));
imf->a_f = (double **) malloc((imf->n+1) * sizeof(double*));
imf->mf = (double(**)(double,double *))
malloc((imf->n+1) * sizeof(double(*)(double,double *)));
imf->a_mf = (double **) malloc((imf->n+1) * sizeof(double*));
imf->F = (double(**)(double,double *))
malloc((imf->n+1) * sizeof(double(*)(double,double *)));
imf->a_F = (double **) malloc((imf->n+1) * sizeof(double*));
imf->mF = (double(**)(double,double *))
malloc((imf->n+1) * sizeof(double(*)(double,double *)));
imf->a_mF = (double **) malloc((imf->n+1) * sizeof(double*));
imf->invF = (double(**)(double,double *))
malloc((imf->n+1) * sizeof(double(*)(double,double *)));
imf->a_invF = (double **) malloc((imf->n+1) * sizeof(double*));
for(i=1;i<=imf->n;i++){
imf->a_f[i] = (double *) malloc(PARA_MAX * sizeof(double));
imf->a_mf[i] = (double *) malloc(PARA_MAX * sizeof(double));
imf->a_F[i] = (double *) malloc(PARA_MAX * sizeof(double));
imf->a_mF[i] = (double *) malloc(PARA_MAX * sizeof(double));
imf->a_invF[i] = (double *) malloc(PARA_MAX * sizeof(double));
}
pos = imf_string;
pos = string_parse(pos,parameter,"(");
imf->m[0] = assign_double(parameter);
for(i=1;i<=imf->n;i++){
pos = string_parse(pos,segment,")");
pos = string_parse(pos,parameter,"(");
imf->m[i] = assign_double(parameter);
seg_pos = segment;
seg_pos = string_parse(seg_pos,function,":");
if(strcmp(function,"pow") == 0){
seg_pos = string_parse(seg_pos,parameter,")");
value = assign_double(parameter);
imf->f[i] = &imf_power;
imf->a_f[i][0] = value;
imf->mf[i] = &imf_power;
imf->a_mf[i][0] = value+1.;
imf->F[i] = &imf_prim_power;
imf->a_F[i][0] = value;
imf->mF[i] = &imf_prim_power;
imf->a_mF[i][0] = value+1;
imf->invF[i] = &imf_inv_prim_power;
imf->a_invF[i][0] = value;
}
if(strcmp(function,"log-norm") == 0){
seg_pos = string_parse(seg_pos,parameter,":");
value = assign_double(parameter);
seg_pos = string_parse(seg_pos,parameter,")");
value2 = assign_double(parameter);
imf->f[i] = &imf_log_normal;
imf->a_f[i][0] = log10(value);
imf->a_f[i][1] = value2;
imf->mf[i] = &imf_mlog_normal;
imf->a_mf[i][0] = log10(value);
imf->a_mf[i][1] = value2;
imf->F[i] = &imf_prim_log_normal;
imf->a_F[i][0] = log10(value);
imf->a_F[i][1] = value2;
imf->mF[i] = &imf_prim_mlog_normal;
imf->a_mF[i][0] = log10(value);
imf->a_mF[i][1] = value2;
imf->invF[i] = &imf_inv_prim_log_normal;
imf->a_invF[i][0] = log10(value);
imf->a_invF[i][1] = value2;
}
}
init_psi(imf);
free(segment);
free(imf_string);
free(parameter);
free(function);
return 0;
}
int imf_init_chabrier_2003(IMF *imf){
int i;
imf->n = 2;
imf->k = 1.;
imf->m_max_physical = IMF_MASSINF;
imf->m_cl = 0.;
imf->m = (double *) malloc((imf->n+1) * sizeof(double));
imf->f = (double(**)(double,double *))
malloc((imf->n+1) * sizeof(double(*)(double,double *)));
imf->a_f = (double **) malloc((imf->n+1) * sizeof(double*));
imf->mf = (double(**)(double,double *))
malloc((imf->n+1) * sizeof(double(*)(double,double *)));
imf->a_mf = (double **) malloc((imf->n+1) * sizeof(double*));
imf->F = (double(**)(double,double *))
malloc((imf->n+1) * sizeof(double(*)(double,double *)));
imf->a_F = (double **) malloc((imf->n+1) * sizeof(double*));
imf->mF = (double(**)(double,double *))
malloc((imf->n+1) * sizeof(double(*)(double,double *)));
imf->a_mF = (double **) malloc((imf->n+1) * sizeof(double*));
imf->invF = (double(**)(double,double *))
malloc((imf->n+1) * sizeof(double(*)(double,double *)));
imf->a_invF = (double **) malloc((imf->n+1) * sizeof(double*));
for(i=1;i<=imf->n;i++){
imf->a_f[i] = (double *) malloc(PARA_MAX * sizeof(double));
imf->a_mf[i] = (double *) malloc(PARA_MAX * sizeof(double));
imf->a_F[i] = (double *) malloc(PARA_MAX * sizeof(double));
imf->a_mF[i] = (double *) malloc(PARA_MAX * sizeof(double));
imf->a_invF[i] = (double *) malloc(PARA_MAX * sizeof(double));
}
imf->m[0] = 0.01;
imf->m[1] = 1.0;
imf->m[2] = IMF_MASSINF;
imf->f[1] = &imf_log_normal;
imf->a_f[1][0] = log10(0.079);
imf->a_f[1][1] = 0.69;
imf->mf[1] = &imf_mlog_normal;
imf->a_mf[1][0] = log10(0.079);
imf->a_mf[1][1] = 0.69;
imf->F[1] = &imf_prim_log_normal;
imf->a_F[1][0] = log10(0.079);
imf->a_F[1][1] = 0.69;
imf->mF[1] = &imf_prim_mlog_normal;
imf->a_mF[1][0] = log10(0.079);
imf->a_mF[1][1] = 0.69;
imf->invF[1] = &imf_inv_prim_log_normal;
imf->a_invF[1][0] = log10(0.079);
imf->a_invF[1][1] = 0.69;
imf->f[2] = &imf_power;
imf->a_f[2][0] = -1.3-1.;
imf->mf[2] = &imf_power;
imf->a_mf[2][0] = imf->a_f[2][0]+1.;
imf->F[2] = &imf_prim_power;
imf->a_F[2][0] = imf->a_f[2][0];
imf->mF[2] = &imf_prim_power;
imf->a_mF[2][0] = imf->a_f[2][0]+1;
imf->invF[2] = &imf_inv_prim_power;
imf->a_invF[2][0] = imf->a_f[2][0];
init_psi(imf);
return 0;
}
/*------------------------------------------------------------------
Main driver for the simulator
------------------------------------------------------------------*/
int main( int argc, char **argv ){
double *hz, *hhxh; /* hamiltonian components */
double complex *psi; /* State vector */
params_t par;
uint64_t i, *largest, j, samples, maxIdx, ccount;
struct timeval tend, tbegin;
double delta;
double tempV, maxV;
//gettimeofday( &tbegin, NULL );
/* - - - - - - - - - - - Parse configuration file - - - - - - - - - - -*/
//if( argc < 3 ){
if( argc < 4 ){
fprintf( stderr, "Need a json configuration file or json string. Terminating...\n" );
return 1;
}
parse_file( argv[1][1], argv[2], &par );
samples = atoi( argv[3] );
par.dim = 1 << par.nQ;
hz = (double *)calloc( (par.dim),sizeof(double) );
hhxh = (double *)calloc( (par.dim),sizeof(double) );
psi = (double complex *)malloc( (par.dim)*sizeof(double complex) );
/* - - - - - - Compute the Hamiltonian for the simulation - - - - - - -*/
build_h( &par, hz, hhxh );
free( par.al ); free( par.be ); free( par.de );
ccount = 0UL;
for( i = 0; i < samples; ++i ){
/* - - - - - - Compute the state vector for the simulation - - - - - - */
init_psi( &par, psi );
/* - - - - - - - - - - - - Run the Simulation - - - - - - - - - - - - -*/
run_sim( &par, hz, hhxh, psi );
/* - - - - - - - - - - - - - Check results - - - - - - - - - - - - - - */
maxV = 0.0;
for( j = 0UL; j < par.dim; ++j ){
tempV = cabs( psi[j]*psi[j] );
if( tempV > maxV ){
maxV = tempV;
maxIdx = j;
}
}
ccount += ( maxIdx == par.res ) ? 1UL : 0UL;
}
printf( "%f\n", ccount/(double)samples );
/* - - - - - - - - - - - - - Check results - - - - - - - - - - - - - - */
/*
largest = (uint64_t *)calloc( par.L, sizeof(uint64_t) );
findLargest( par.dim, par.L, psi, largest );
for( i = par.L; i --> 0; ){ //remember that i is unsigned
//printf( "|psi[%d]| = %.8f\n",
printf( "%d %.8f\n",
largest[i],
cabs( psi[largest[i]]*psi[largest[i]] ) );
}
*/
//statm_t res;
//read_off_memory_status( &res );
/* - - - - - - - - - - - Clean up and output - - - - - - - - - - - - - */
//free( largest );
free( psi );
free( hz );
free( hhxh );
//gettimeofday( &tend, NULL );
//delta = ((tend.tv_sec - tbegin.tv_sec)*1000000u + tend.tv_usec - tbegin.tv_usec)/1.e6;
//printf( "Total time: %f s\n", delta );
//printf( "Memory used: %ld kB\n", res.resident );
return 0;
}
