Пример #1
0
int lua_random_Float32(lua_State *L) {
	RandomLib::Random *s = Glue<RandomLib::Random>::checkto(L, 1);
	lua::push<double>(L, s->Fixed());
	return 1;
}
void WangLandau_Algorithm_bean_2D(float** ptrMatrix, float* Matrix, std::vector<double>& Histogram, std::vector<double>& Histogram2, std::vector<double>& DOS, Lattice lattice, Bean bean, RandomLib::Random& r, double* ptrf, double const InitialDOS, double const end_f, double const average_frac, double const J, double const h, int const mcycle)
{
  int k, p, z, g, average;
  double H_tot_trial, H_in, H_fin, gE1, gE2;

  int M = lattice.get_M();
  int N = lattice.get_N();
  double H_tot = ising_total_hamiltonian_2D(ptrMatrix,lattice,J,h);
   
  initialiseHistogram_bean(Histogram, DOS);
  initialiseHistogram_bean(Histogram2, DOS);
  
  /*
    std::cout<<"DEBUG3: DOS size: "<<DOS.size()<< std::endl;
    std::cout<<"DEBUG3: Histogram size: "<<Histogram.size()<< std::endl;
  */
  
  while(*ptrf >= end_f)
    {
      bool LOOP = true; 
              
      //std::cout<<"DEBUG Outer while loop"<<std::endl;
       
      while(LOOP == true)
	{
	  //std::cout<<"DEBUG inner while loop"<<std::endl;
	     
	  for(z = 0; z < mcycle; z++)
	    {
	      //the inner loop is necessary for the preconditioning
	      
	      //select random node on the lattice Matrix
	      Matrix_samplepoint_2D(lattice, r, &k, &p);
	      
	      H_in = ising_nodal_hamiltonian_2D(ptrMatrix, p, lattice, J, h);
	      
	      //flip spin
	      Matrix[k] = - Matrix[k];
	      
	      H_fin = ising_nodal_hamiltonian_2D(ptrMatrix, p, lattice, J, h);
	      
	      H_tot_trial = H_tot - H_in + H_fin;
	      gE1 = get_DOS_bean(DOS, bean, H_tot);
	      gE2 = get_DOS_bean(DOS, bean, H_tot_trial);
	      
	      if(gE2 <= gE1)
		{
		  H_tot = H_tot_trial;
		  update_DOS_bean(DOS, Histogram, Histogram2, bean, ptrf, H_tot, InitialDOS);
		  update_EnergyHistogram_bean(Histogram, bean, H_tot);
		}
	      else if (r.Fixed() <= exp( gE1 - gE2 ) ) 
		{
		  H_tot = H_tot_trial;
		  update_DOS_bean(DOS, Histogram, Histogram2, bean, ptrf, H_tot, InitialDOS);
		  update_EnergyHistogram_bean(Histogram, bean, H_tot);
		}
	      else
		{
		  Matrix[k] = - Matrix[k];
		  update_DOS_bean(DOS, Histogram, Histogram2, bean, ptrf, H_tot, InitialDOS);
		  update_EnergyHistogram_bean(Histogram, bean, H_tot);
		}
	    }
	    
	  average = average_EnergyHistogram_bean(Histogram, DOS, InitialDOS, end_f);
	     
	  LOOP = termination_EnergyHistogram_bean(Histogram, DOS, InitialDOS, average, average_frac, end_f);
	}
       
      initialiseHistogram_bean(Histogram, DOS);
      evolve_update_function_sqrt(ptrf);
    }
}
Пример #3
0
void sar(char *argv[], unsigned int seed)
{
    RandomLib::Random rng;
    rng.Reseed();

    // List of variables for run conditions:
    const int num_species = 50;
    const int num_patches = 300;
    const int num_step = 5000;
    const int search_radius = 5;

    // Species characteristics:
    const double d = 0.5; // Species mean dispersal distance (shapes dispersal kernel): 1/d
    const double m = 0.1; // Disturbance probability (disturbance kills individual)
    const double niche_min = 0.1; // Competitive strength of empty cells
    const double emi_from_out = 0.001; // Seed bank

    array2Ddouble E;
    array2Dint occupied;
    array2Dint disturbance_counter;

    SetArraySize2d(E, num_patches, num_patches);
    SetArraySize2d(occupied, num_patches, num_patches);
    SetArraySize2d(disturbance_counter, num_patches, num_patches);

    // List of global species characteristic parameters (read in from file or defined in main function):
    double *h = new double[num_species];
    double *u = new double[num_species];
    double *c = new double[num_species];
    double *sigma = new double[num_species];

    // read in species characteristics from file
    char buffer[100];
    sprintf(buffer, "%s_st.txt", argv[1]);
    std::ifstream input_traits(buffer);
    for (int i = 0; i < num_species; ++i)
    {
        input_traits >> sigma[i]; // Niche width
        input_traits >> h[i]; // Performance at niche optimum (height, y at maximum)
        input_traits >> c[i]; // Seed production
        input_traits >> u[i]; // Resource at niche optimum (location, x at maximum)
    }
    input_traits.close();
  
    sprintf(buffer, "%s_species.txt", argv[1]);
    std::ifstream input_species(buffer);
    {
        int i = 0, j = 0;
        while (!input_species.eof())
        {
            input_species >> i;
            input_species >> j;
            input_species >> E[i][j];
            input_species >> occupied[i][j];
            input_species >> disturbance_counter[i][j];
        }
    }
    input_species.close();

    for (int block = 0; block < 1; ++block)
    {
        sprintf(buffer, "%s_dest%d.txt", argv[1], block);
        std::ifstream input_dest(buffer);
		
        for (int i = 0; i < num_patches; ++i)
        {
            for (int j = 0; j < num_patches; ++j)
            {
                disturbance_counter[i][j] = 0;
				//                occupied[i][j] = 0;
            }
        }
		
		// Removed the input_dest as a matrix and replaced by a list (see next loop).
		
		//		for (int i = 0; i < num_patches; ++i)
		//        {
		//            for (int j = 0; j < num_patches; ++j)
		//            {
		//                input_dest >> E[i][j];
		//            }
		//        }
		
		// The input file is now x,y,E with 90000 lines
		
		{										
			int i = 0, j = 0;			
			while (!input_dest.eof())
			{
				input_dest >> i;
				input_dest >> j;
				input_dest >> E[i][j];
			}
		}										
		
        input_dest.close();
		
		//        for (int x = 0; x < num_patches; x++)
		//        {
		//            for (int y = 0; y < num_patches; y++)
		//            {
		//                const int s = (int)(rng.Fixed() * num_species); // Select a species at random
		//                occupied[x][y] = NICHE_F(h[s], u[s], E[x][y], sigma[s]) < niche_min ? EMPTY : s;
		//            }
		//       }
        double all_possible_seeds = 0;

        for (int dx = -search_radius; dx <= search_radius; dx++)
        {
            for (int dy = -search_radius; dy <= search_radius; dy++)
            {
                if ((dx != 0) || (dy != 0))
                {
                    all_possible_seeds += exp(-d * sqrt(dx * dx + dy * dy));
                }
            }
        }
        all_possible_seeds += emi_from_out * num_species;

        for (int t = 0; t < num_step; ++t)
        {
            for (int cell = 0; cell < num_patches * num_patches; cell++)
            {
                const int x = (int)(rng.Fixed() * num_patches);
                const int y = (int)(rng.Fixed() * num_patches);

                if(rng.Fixed() < m)
                {
                    occupied[x][y] = EMPTY;
                    ++disturbance_counter[x][y]; // BR
                }

                double Niche_res = niche_min;
                if (occupied[x][y] != EMPTY)
                {
                    int i = occupied[x][y];
                    Niche_res = NICHE_F(h[i], u[i], E[x][y], sigma[i]);
                }

                std::vector<double> Seed(num_species, 0.0);

                const int dx_min = (x - search_radius < 0) ? -x : -search_radius; 
                const int dx_max = (x + search_radius >= num_patches) ? num_patches - 1 - x : search_radius;
                const int dy_min = (y - search_radius < 0) ? -y : -search_radius;
                const int dy_max = (y + search_radius >= num_patches) ? num_patches - 1 - y : search_radius; 

                assert(x + dx_min >= 0 && x + dx_max < num_patches);
                assert(y + dy_min >= 0 && y + dy_max < num_patches);

                for (int dx = dx_min; dx <= dx_max; ++dx)
                {
                    for (int dy = dy_min; dy <= dy_max; ++dy)
                    {
                        if (((dx != 0) || (dy != 0)) && (occupied[x + dx][y + dy] != EMPTY))
                        {
                            int i = occupied[x + dx][y + dy];
                            if (NICHE_F(h[i], u[i], E[x][y], sigma[i]) > Niche_res)
                            {
                                Seed[i] += c[i] * (exp(-d * sqrt(dx * dx + dy * dy)));
                            }
                        }
                    }
                }
                double all_seeds = 0.0;
                for (int i = 0; i < num_species; ++i)
                {
                    if (NICHE_F(h[i], u[i], E[x][y], sigma[i]) > Niche_res)
                    {
                        Seed[i] += emi_from_out;
                    }
                    all_seeds += Seed[i];
                }

                bool total_colon = false;
                if (all_seeds / all_possible_seeds > rng.Fixed())
                {
                    total_colon = true;
                }

                std::vector<double> Prob_recruit(num_species, 0.0);
                if (total_colon == true)
                {
                    //Prob_recruit[0] = Colon[0]/double(total_colon);
                    Prob_recruit[0] = Seed[0] / all_seeds;
                    for (int i = 1; i < num_species; ++i)
                    {
                        Prob_recruit[i] = Seed[i] / all_seeds + Prob_recruit[i-1];
                    }

                    occupied[x][y] = EMPTY;

                    double randnumb = rng.Fixed();
                    for (int i = 0; i < num_species; i++)
                    {
                        if (randnumb < Prob_recruit[i])
                        {
                            assert(NICHE_F(h[i], u[i], E[x][y], sigma[i]) > niche_min);
                            occupied[x][y] = i;
                            break;
                        }
                    }
                }
            } // ends loop over cells
        } // ends loop t

        sprintf(buffer, "%s_out200_%d.txt", argv[1], block);
        std::ofstream out(buffer);
        for (int x = 0; x < num_patches; ++x)
        {
            for (int y = 0; y < num_patches; ++y)
            {
                out << x << " " << y << " " << E[x][y] << " " << occupied[x][y] << " " << disturbance_counter[x][y] << "\n";
            }
        }
        out.close();
    }
}