Beispiel #1
0
int main(int argc, char **argv)
{
		double T=0;;
		double mag=0.0;
		int N;
		int i;
		Ising **S;
		double tot_Erg=0;
		double capacity=0.0;
		double kai=0.0; 

		init_rnd(gus());

		N=atoi(argv[1]);
		S=(Ising **)malloc(sizeof(Ising *) * N);
		for(i=0; i<N; i++)
				S[i]=(Ising *)malloc(sizeof(Ising) * N);

		initialize(N, S);

		for(T=3.01; T>=0.01; T-=0.01)
		{
				mag=0.0;
				tot_Erg=0.0;
				kai=0.0;
				capacity=0.0;

				for(i=0; i<200000; i++)
						mcstep(N, T, S);

				for(i=0; i<200000; i++)
				{
						mcstep(N, T, S);
						mag+=magnetization(N, S);
						tot_Erg+=energy(N, S);
						kai+=pow(magnetization(N, S), 2);
						capacity+=pow(energy(N,S), 2);
				}
				mag=mag/200000;
				tot_Erg=tot_Erg/200000;
				kai=kai/200000;
				capacity=capacity/200000;

				kai=(kai-mag*mag)/T;
				capacity=(capacity - tot_Erg*tot_Erg)/(T*T);

				kai=kai*N*N;
				capacity=capacity*N*N;

				printf("%lf\t%lf\t%lf\t%lf\t%lf\n", T, mag, tot_Erg, kai, capacity);
		}

		free(S);

		return 0;

}
Beispiel #2
0
/********************************************************************************
 * clusterupdatebatch: Runs clusterupdate multiple times and gets physics as well
 * as error estimates.
 *******************************************************************************/
int
clusterupdatebatch(lattice_site * lattice, settings conf, double beta, datapoint * data )
{
  int i,j;
  double * e_block, * m_block, * e_block_avg, * m_block_avg, \
         * e_block_error, * m_block_error, * c_block , * chi_block;
  gsl_vector * mag_vector;

  e_block       = (double *) malloc(conf.block_size*sizeof(double));
  m_block       = (double *) malloc(conf.block_size*sizeof(double));
  e_block_avg   = (double *) malloc(conf.blocks*sizeof(double));
  m_block_avg   = (double *) malloc(conf.blocks*sizeof(double));
  c_block       = (double *) malloc(conf.blocks*sizeof(double));
  chi_block     = (double *) malloc(conf.blocks*sizeof(double));
  e_block_error = (double *) malloc(conf.blocks*sizeof(double));
  m_block_error = (double *) malloc(conf.blocks*sizeof(double));

  mag_vector = gsl_vector_alloc(conf.spindims);

  //Settle first
  for(i = 0 ; i < conf.max_settle ; i++)
  {
   clusterupdate(lattice,conf,beta);
  }

  //Get averages and stdev for messurements
  for(i = 0 ; i < conf.blocks ; i++)
  {
    for(j = 0 ; j < conf.block_size ; j++)
    {
      clusterupdate(lattice,conf,beta);
      e_block[j] = total_energy(lattice,conf);
      m_block[j] = magnetization(lattice,conf,mag_vector);
    }
    e_block_avg[i]   = gsl_stats_mean(e_block,1,conf.block_size);
    e_block_error[i] = gsl_stats_sd(e_block,1,conf.block_size);
    m_block_avg[i]   = gsl_stats_mean(m_block,1,conf.block_size);
    m_block_error[i] = gsl_stats_sd(m_block,1,conf.block_size);
    c_block[i]       = gsl_pow_2(beta)*gsl_pow_2(e_block_error[i]);
    chi_block[i]     = beta*gsl_pow_2(m_block_error[i]);
  }
  (*data).beta      = beta;
  (*data).erg       = gsl_stats_mean(e_block_avg,1,conf.blocks);
  (*data).erg_error = gsl_stats_sd(e_block_avg,1,conf.blocks);
  (*data).mag       = gsl_stats_mean(m_block_avg,1,conf.blocks);
  (*data).mag_error = gsl_stats_sd(m_block_avg,1,conf.blocks);
  (*data).c         = gsl_stats_mean(c_block,1,conf.blocks);
  (*data).c_error   = gsl_stats_sd(c_block,1,conf.blocks);
  (*data).chi       = gsl_stats_mean(chi_block,1,conf.blocks);
  (*data).chi_error = gsl_stats_sd(chi_block,1,conf.blocks);

  free(e_block);
  free(m_block);
  free(e_block_avg);
  free(m_block_avg);
  free(e_block_error);
  free(m_block_error);
  gsl_vector_free(mag_vector);
  return(0);
}
Beispiel #3
0
 THREADABLE_FUNCTION_END
 
 //compute the magnetization
 void magnetization(complex *magn,complex *magn_proj_x,quad_su3 **conf,int quantization,quad_u1 **u1b,quark_content_t *quark,double residue)
 {
   //allocate source and generate it
   color *rnd[2]={nissa_malloc("rnd_EVN",loc_volh+bord_volh,color),nissa_malloc("rnd_ODD",loc_volh+bord_volh,color)};
   generate_fully_undiluted_eo_source(rnd,RND_GAUSS,-1);
   
   //call inner function
   magnetization(magn,magn_proj_x,conf,quantization,u1b,quark,residue,rnd);
   
   for(int par=0;par<2;par++) nissa_free(rnd[par]);
 }
Beispiel #4
0
  //measure magnetization
  void measure_magnetization(quad_su3 **conf,theory_pars_t &theory_pars,magnetization_meas_pars_t &meas_pars,int iconf,int conf_created)
  {
    FILE *file=open_file(meas_pars.path,conf_created?"w":"a");
    FILE *file_proj=open_file(meas_pars.path+"%s_proj_x",conf_created?"w":"a");
    
    int ncopies=meas_pars.ncopies;
    for(int icopy=0;icopy<ncopies;icopy++)
      {
        master_fprintf(file,"%d",iconf);
        
        //measure magnetization for each quark
        for(int iflav=0;iflav<theory_pars.nflavs();iflav++)
          {
	    if(theory_pars.quarks[iflav].discretiz!=ferm_discretiz::ROOT_STAG) crash("not defined for non-staggered quarks");
	    
            complex magn={0,0};
            complex magn_proj_x[glb_size[1]]; //this makes pair and pact with "1" and "2" upstairs
            for(int i=0;i<glb_size[1];i++) magn_proj_x[i][RE]=magn_proj_x[i][IM]=0;
            
            //loop over hits
            int nhits=meas_pars.nhits;
            for(int hit=0;hit<nhits;hit++)
              {
                verbosity_lv2_master_printf("Evaluating magnetization for flavor %d/%d, ncopies %d/%d nhits %d/%d\n",
                                            iflav+1,theory_pars.nflavs(),icopy+1,ncopies,hit+1,nhits);
            
                //compute and summ
                complex temp,temp_magn_proj_x[glb_size[1]];
                magnetization(&temp,temp_magn_proj_x,conf,theory_pars.em_field_pars.flag,theory_pars.backfield[iflav],&theory_pars.quarks[iflav],meas_pars.residue); //flag holds quantization
                
                //normalize
                complex_summ_the_prod_double(magn,temp,1.0/nhits);
                for(int x=0;x<glb_size[1];x++) complex_summ_the_prod_double(magn_proj_x[x],temp_magn_proj_x[x],1.0/nhits);
              }
            
            //output
            master_fprintf(file,"\t%+016.16lg \t%+016.16lg",magn[RE],magn[IM]);
            for(int x=0;x<glb_size[1];x++)
              master_fprintf(file_proj,"%d\t%d\t%d\t%d\t%+016.16lg \t%+016.16lg\n",iconf,icopy,iflav,x,magn_proj_x[x][RE],magn_proj_x[x][IM]);
          }
        
        master_fprintf(file,"\n");
      }
    
    close_file(file);
    close_file(file_proj);
  }
Beispiel #5
0
 THREADABLE_FUNCTION_END
 
 //compute the magnetization
 THREADABLE_FUNCTION_8ARG(magnetization, complex*,magn, complex*,magn_proj_x, quad_su3**,conf, int,quantization, quad_u1**,u1b, quark_content_t*,quark, double,residue, color**,rnd)
 {
   GET_THREAD_ID();
   
   //fixed to Z magnetization
   int mu=1,nu=2;
   
   //allocate source and propagator
   color *chi[2]={nissa_malloc("chi_EVN",loc_volh+bord_volh,color),nissa_malloc("chi_ODD",loc_volh+bord_volh,color)};
   
   //we need to store phases
   coords *arg=nissa_malloc("arg",loc_vol+bord_vol,coords);
   NISSA_PARALLEL_LOOP(ivol,0,loc_vol+bord_vol)
     get_args_of_quantization[quantization](arg[ivol],ivol,mu,nu);
   
   //array to store magnetization on single site (actually storing backward contrib at displaced site)
   complex *point_magn=nissa_malloc("app",loc_vol,complex);
   
   //we add backfield externally because we need them for derivative
   add_backfield_to_conf(conf,u1b);
   
   //invert
   inv_stD_cg(chi,conf,quark->mass,1000000,residue,rnd);
   
   //compute mag
   magnetization(magn,magn_proj_x,conf,quark,rnd,chi,point_magn,arg,mu,nu);
   
   //remove backfield
   rem_backfield_from_conf(conf,u1b);
   
   //free
   for(int par=0;par<2;par++) nissa_free(chi[par]);
   nissa_free(point_magn);
   nissa_free(arg);
 }
double magnetization(int L, std::vector<std::pair<int, int> >& lattice, int power, const std::vector<double>& v) {
  return magnetization(L, lattice, power, &v[0]);
}
Beispiel #7
0
int main()
{
    clock_t begin,end;
	double time_spent;
	begin = clock();

    int latsizes[7] =  {5,64,16,32,64,128,512}; //try these different lattice sizes
    /*
    * ntrials : Number of monte carlo steps to run. Each monte carlo step is an attempt to flip N spins. 
    *           So for a 4x4 lattice 1 monte carlo step is an attempt to flip 16 times.
    * N       : Lattice size
    * temp    : Array of temperatures to try.
    * meanE   : Array containing mean energy for each temperature.
    * meanE2  : Array contaiing square of mean energies. Useful to calculate the variance as meanE2 - (meanE)^2
    * meanMag : Array for mean magnetization
    * meanMag2: Array for square mean magnetization. Again used for variance calculation
    * cv      : Specific heat at a temperature
    * chi     : Magnetic susceptibility at a temperature
    * */
    int const ntrials = 1e4;         
    int N = 0;
    double temp[500] = {0};
    double meanE[500] = {0};
    double meanE2[500] = {0};
    double meanMag[500] = {0};
    double meanMag2[500] = {0};
    double cv[500] = {0};
    double chi[500]={0};
    int skip = ntrials*0.2;
    double E = 0;
    
    //loop counters
    int i,t,ss;

    //declaring spin array once
    int *spins = NULL;
    int **Nbr = NULL;

    //int spins[19600] = {0};
    //int Nbr[19600][4] = {0};
    int row = 0;
    int rowMin = 0;
    int col = 0;
    int l = 0;
    double toss=0;
    double tempMag = 0;
    double beta;
    FILE* stat_file;
    //char fn_stat[200] = "/home/a/ahamed/scratch/\0";
    
    //monte carlo variables
    int k,field_k,delE,j;
    double probRatio;
    
    spins = (int *) malloc(sizeof(int)*262144);
    Nbr = (int **)malloc(sizeof(int *)*262144);
    Nbr[0] = (int *)malloc(sizeof(int)*262144*4);
    for(int i=1;i<262144;i++)
        Nbr[i] = Nbr[i-1]+4;

    //for (i=0;i<500;i++)
    //    temp[i] = 0.01*(500 - i + 1);
    
    for(int cnt=0;cnt<1;cnt++)
    {
        N = latsizes[cnt];
        srand(time(NULL));
        //int* spins = (int *)malloc(N*N * sizeof(int));
         
        /*
         * This following loop sets of the initial lattice. Initial configuration is completely random
         */
        for(i=0;i<N*N;i++)
        {
            /*toss = RAND(0.0,1.0);
            if(toss > 0.5)
                spins[i] = -1;
            else
                spins[i] = 1;*/
            spins[i] = (toss<0.5) - (toss>=0.5);
        }

        /*
         * The neighbour table. Calculate the neighbours and store them in a lookup table so that in every loop a function call is saved
         */
        //int (*Nbr)[4] = (int(*)[4])malloc((sizeof *Nbr)*N*N);
        
        for (i = 0; i < N*N; i++)
        {
            row = i / N;
            rowMin = row*N;
            col = i - rowMin;
            l=(i - col)/N;

            Nbr[i][0] = ((i+1) + N)%N + rowMin;
            Nbr[i][1] = (((l+1) + N)%N)*N + col;
            Nbr[i][2] = ((i-1) + N)%N + rowMin;
            Nbr[i][3] = (((l-1) + N)%N)*N + col;
        }

        /*
         * E is the current energy of the lattice. Calculate the energy of the initial random configuration
         */
        E = 0;
        for(i=0;i<N*N;i++)
            E = E - spins[i]*spins[Nbr[i][0]] - spins[i]*spins[Nbr[i][1]];
       
       /*
        * ntrials : Number of monte carlo steps to run. Each monte carlo step is an attempt to flip N spins. 
        *           So for a 4x4 lattice 1 monte carlo step is an attempt to flip 16 times.
        * temp    : Array of temperatures to try.
        * meanE   : Array containing mean energy for each temperature.
        * meanE2  : Array contaiing square of mean energies. Useful to calculate the variance as meanE2 - (meanE)^2
        * meanMag : Array for mean magnetization
        * meanMag2: Array for square mean magnetization. Again used for variance calculation
        * cv      : Specific heat at a temperature
        * chi     : Magnetic susceptibility at a temperature
        * */

        //for (i=0;i<500;i++)
        //    temp[i] = 0.01*(i + 1);
        //double tempMag = magnetization(spins,N);

        //FILE* file, stat_file;
        //char nlat[100];
        //sprintf(nlat, "%d", N);
        //char* end = "spins.txt\0";
        //char fn[200] = "/home/a/ahamed/work/\\";
        //strcat(fn, strcat(nlat,end));
        //file=fopen(fn, "w");
        
        //char* endst = "stat.csv\0";
        //char fn_st[200] = "/home/a/ahamed/work/\\";
        //strcat(fn_st, strcat(nlat,endst));
        //stat_file=fopen(fn_st, "w");

        //FILE* file;
        //FILE* stat_file;
        //char fn_spins[200] = "/home/a/ahamed/scratch/\0";
        //file_name(N,"spins.txt\0",fn_spins);

        char fn_stat[200] = "/home/a/ahamed/scratch/\0";
        //fn_stat = "/home/a/ahamed/scratch/\0";
        file_name(N,"stat.csv\0",fn_stat);
        //file = fopen(fn_spins, "w");
        stat_file = fopen(fn_stat,"w");
       
        for(t=0; t< 500; t++)
        {
            //double beta = 1/temp[t];  //beta is inverse temperature in boltzmann distrubution
            beta = 1/( 0.01*(500 - i + 1));
            for(i=1;i<ntrials;i++) //run ntrials MC steps
            {
                //int k,field_k,delE;
                //double probRatio, toss;
                //Monte Carlo Loop
                //One Monte Carlo step is attempt to flip (N*N) spins
                for(ss=0; ss<N*N;ss++)
                {
                    k = floor(RAND(1,N*N)); //get a random site on lattice
                    field_k = spins[Nbr[k][0]] + spins[Nbr[k][1]] +spins[Nbr[k][2]] + spins[Nbr[k][3]]; // Calculate the neighbouring field on it
                    delE = 2*field_k*spins[k];  //calculate the change in energy if the spin was to be flipped
                    probRatio = exp(-1*beta*delE); //calculate the boltzmann prob of the state corresponding to the energy
                    toss = RAND(0,1); //toss a coin, generate a random number between 0 and 1
                    if(toss < probRatio)  // if less than probratio accept, i.e. accept the next state with a probability with probratio
                    {
                        spins[k] = -1*spins[k]; //flip the spin
                        E = E + delE; //calculate the change in energy
                    }
                }
                if(i>=skip)  //skip is how many MC steps to let the system equilibriate. collect stats every markov step or every 10
                {
                    tempMag = magnetization(spins, N);
                    meanE[t] = (meanE[t] + E);
                    meanMag[t] = (meanMag[t]) + tempMag;
                    meanE2[t] = (meanE2[t]) + E*E;
                    meanMag2[t] = (meanMag2[t]) + tempMag*tempMag;
                }
            }
            j= (ntrials - skip);
            meanE[t] = meanE[t]/j;
            meanMag[t] = meanMag[t]/j;
            meanE2[t] = meanE2[t]/j;
            meanMag2[t] = meanMag2[t]/j;
            cv[t] = (beta*beta*(meanE2[t] - meanE[t]*meanE[t]))/(N*N);
            chi[t] = (beta*(meanMag2[t] - meanMag[t]*meanMag[t]))/(N*N);
            fprintf(stat_file, "%f\t%f\t%f\t%f\n", meanMag[t], meanE[t], chi[t], cv[t]);
            //for (int i=0;i<N*N;i++)
            //    fprintf(file, "%d\t", spins[i]);
            //fprintf(file,"\n");
        }
        //fclose(file);
        fclose(stat_file);
        free(spins);
    }
    end = clock();
	time_spent = (double)(end - begin) / CLOCKS_PER_SEC;
	printf("Time spent in execution %f\n",time_spent);
    return time_spent;
}
Beispiel #8
0
int
main (int argc, char * argv[])
{
  int i,j;
  int size = argc - 2;
  int *data  = (int *)  malloc(sizeof(int)*size);
  int sidelength, spacedims, spindims;
  int * loc;
  int num;
  gsl_rng * rng;
  const gsl_rng_type * RngType;
  gsl_rng_env_setup();
  RngType = gsl_rng_default;
  rng = gsl_rng_alloc (RngType);
  gsl_vector ** lattice;
  gsl_vector * magnet;
  double mag,energy;

  /* Read in data */
  if(size != 0)
  {
    for (i = 0 ; i< size ; i++)
    {
      data[i] = atoi(argv[i+2]);
    }
  }
  switch(atoi(argv[1]))
  {
    case 0: /* Magnetization */
      /**********************************************
       * Outputs magnetization of a uniform lattice *
       **********************************************/
      sidelength = data[0];
      spacedims  = data[1];
      spindims   = data[2];
      magnet = gsl_vector_alloc(spindims);
      lattice = allocate_lattice(sidelength,spacedims,spindims);
      set_homogenious_spins(lattice,sidelength,spacedims,spindims);
      mag = magnetization(lattice,sidelength,spacedims,spindims,magnet);
      free_lattice(lattice,sidelength,spacedims);
      printf("%2.1f\n",mag);
      break;
    case 1: /* Local Energy */
      /**********************************************
       * Outputs energy of a uniform lattice point *
       **********************************************/
      sidelength = data[0];
      spacedims  = data[1];
      spindims   = data[2];
      loc        = (int *) malloc(sizeof(int)*spacedims);
      for(i = 0 ; i < spacedims ; i++)
        loc[i] = data[i+3];
      lattice = allocate_lattice(sidelength,spacedims,spindims);
      set_homogenious_spins(lattice,sidelength,spacedims,spindims);
      energy = 0;
      energy = local_energy(lattice, sidelength, spacedims, spindims, loc);
      free_lattice(lattice,sidelength,spacedims);
      printf("%1.3e\n",energy);
      break;
    case 2: /* Total Energy */
      /********************************************
       * Outputs energy of a checkerboard lattice *
       ********************************************/
      sidelength = data[0];
      spacedims  = data[1];
      spindims   = data[2];
      lattice = allocate_lattice(sidelength,spacedims,spindims);
      set_checkerboard_spins(lattice,sidelength,spacedims,spindims);
      energy = total_energy(lattice, sidelength, spacedims, spindims );
      printf("%1.3e\n",energy);
      break;
    default:
      printf("No arguments!\n");
      exit(EXIT_FAILURE);
  }

}