Collaboration diagram for App_Var_Chi::ChiImpl:

Public Member Functions
	ChiImpl (const Sim_Param &sim)

void	solve (double a, const std::vector< Particle_v< double >> &particles, const Sim_Param &sim, const FFTW_PLAN_TYPE &p_F, const FFTW_PLAN_TYPE &p_B)

void	gen_pow_spec_binned (const Sim_Param &sim, Data_Vec< double, 2 > &pwr_spec_binned, const FFTW_PLAN_TYPE &p_F)

void	get_chi_force (const FFTW_PLAN_TYPE &p_F, const FFTW_PLAN_TYPE &p_B)

void	kick_step_w_chi (const Cosmo_Param &cosmo, const double a, const double da, std::vector< Particle_v< double >> &particles, const std::vector< Mesh > &force_field)

void	kick_step_w_chi_no_momentum (const Cosmo_Param &cosmo, const double a, const double da, std::vector< Particle_v< double >> &particles, const std::vector< Mesh > &vel_field)

Public Attributes
ChiSolver< CHI_PREC_t >	sol

MultiGrid< 3, CHI_PREC_t >	drho

std::vector< Mesh >	chi_force

uint64_t	memory_alloc

Private Member Functions
void	solve_multigrid ()

void	solve_finest ()

Private Attributes
const size_t	N_level_orig

const double	x_0

Detailed Description

Definition at line 683 of file chameleon.cpp.

Constructor & Destructor Documentation

App_Var_Chi::ChiImpl::ChiImpl ( const Sim_Param & sim )

inline

Definition at line 687 of file chameleon.cpp.

References Sim_Param::box_opt, anonymous_namespace{chameleon.cpp}::CONVERGENCE_BI_DCHI, anonymous_namespace{chameleon.cpp}::CONVERGENCE_BI_L, anonymous_namespace{chameleon.cpp}::CONVERGENCE_BI_STEPS_INIT, and Box_Opt::mesh_num.

                                  :
         sol(sim.box_opt.mesh_num, sim, false), drho(sim.box_opt.mesh_num), N_level_orig(sol.get_Nlevel()), x_0(sim.x_0())
     {
         // EFFICIENTLY ALLOCATE VECTOR OF MESHES
         chi_force.reserve(3);
         for(size_t i = 0; i < 3; i++){
             chi_force.emplace_back(sim.box_opt.mesh_num);
         }
 
         // ALLOCATED MEMORY
         memory_alloc  = sizeof(FTYPE_t)*chi_force[0].length*chi_force.size();
         memory_alloc += sizeof(CHI_PREC_t)*8*(sol.get_Ntot()-1)/7 // MultiGrid<3, CHI_PREC_t>
                                           *3; // _f, _res, _source
         memory_alloc += sizeof(CHI_PREC_t)*8*(sol.get_Ntot()-1)/7;// MultiGrid<3, CHI_PREC_t> drho
 
         // SET CHI SOLVER
         sol.add_external_grid(&drho);
         sol.set_bisection_convergence(CONVERGENCE_BI_STEPS_INIT, CONVERGENCE_BI_DCHI, CONVERGENCE_BI_L);
     }

Member Function Documentation

void App_Var_Chi::ChiImpl::gen_pow_spec_binned	(	const Sim_Param &	sim,
		Data_Vec< double, 2 > &	pwr_spec_binned,
		const FFTW_PLAN_TYPE &	p_F
	)

inline

Definition at line 747 of file chameleon.cpp.

References fftw_execute_dft_r2c(), gen_pow_spec_binned(), pwr_spec_k_init(), and anonymous_namespace{chameleon.cpp}::transform_MultiGridSolver_to_Mesh().

     {
         transform_MultiGridSolver_to_Mesh(chi_force[0], sol); // - get solution
         fftw_execute_dft_r2c(p_F, chi_force[0]); // - get chi(k)
         pwr_spec_k_init(chi_force[0], chi_force[0]); // - get chi(k)^2, NO w_k correction
         ::gen_pow_spec_binned(sim, chi_force[0], pwr_spec_binned); // - get average Pk
     }

void App_Var_Chi::ChiImpl::get_chi_force	(	const FFTW_PLAN_TYPE &	p_F,
		const FFTW_PLAN_TYPE &	p_B
	)

inline

Definition at line 755 of file chameleon.cpp.

References fftw_execute_dft_c2r_triple(), fftw_execute_dft_r2c(), gen_displ_k_cic(), and anonymous_namespace{chameleon.cpp}::transform_MultiGridSolver_to_Mesh().

     {
         transform_MultiGridSolver_to_Mesh(chi_force[0], sol); // - get solution
         fftw_execute_dft_r2c(p_F, chi_force[0]); // - get chi(k)
         gen_displ_k_cic(chi_force, chi_force[0]); // - get -k*chi(k)
         fftw_execute_dft_c2r_triple(p_B, chi_force);// - get chi force
     }

void App_Var_Chi::ChiImpl::kick_step_w_chi	(	const Cosmo_Param &	cosmo,
		const double	a,
		const double	da,
		std::vector< Particle_v< double >> &	particles,
		const std::vector< Mesh > &	force_field
	)

inline

-3/2a represents usual EOM, the rest are LCDM corrections
chameleon force factor + units

Definition at line 763 of file chameleon.cpp.

References assign_from(), growth_allz::growth_factor, Cosmo_Param::Omega_L(), Cosmo_Param::Omega_m, pow(), and pow2().

     {
         const size_t Np = particles.size();
         Vec_3D<FTYPE_t> force;
         const FTYPE_t D = growth_factor(a, cosmo);
         const FTYPE_t OL = cosmo.Omega_L()*pow(a,3);
         const FTYPE_t Om = cosmo.Omega_m;
         const FTYPE_t OLa = OL/(Om+OL);
 
         const FTYPE_t f1 = 3/(2*a)*(1 + OLa);
         const FTYPE_t f2 = 3/(2*a)*(1 - OLa)*D/a;
         const FTYPE_t f3 = a/D*sol.chi_force_units(a)/pow2(x_0);      
         
         #pragma omp parallel for private(force)
         for (size_t i = 0; i < Np; i++)
         {
             force.fill(0.);
             assign_from(force_field, particles[i].position, force);
             assign_from(chi_force, particles[i].position, force, f3);
             force = force*f2 - particles[i].velocity*f1;        
             particles[i].velocity += force*da;
         }
     }

void App_Var_Chi::ChiImpl::kick_step_w_chi_no_momentum	(	const Cosmo_Param &	cosmo,
		const double	a,
		const double	da,
		std::vector< Particle_v< double >> &	particles,
		const std::vector< Mesh > &	vel_field
	)

inline

chameleon force factor + units

Definition at line 789 of file chameleon.cpp.

References assign_from(), growth_change(), growth_allz::growth_factor, and pow2().

     {
         const size_t Np = particles.size();
         Vec_3D<FTYPE_t> vel;
         const FTYPE_t D = growth_factor(a, cosmo);
         const FTYPE_t dDda = growth_change(a, cosmo); // dD / da
 
         const FTYPE_t f3 = a/D*sol.chi_force_units(a)/pow2(x_0);      
         
         #pragma omp parallel for private(vel)
         for (size_t i = 0; i < Np; i++)
         {
             vel.fill(0.);
             assign_from(vel_field, particles[i].position, vel);
             assign_from(chi_force, particles[i].position, vel, f3);
             particles[i].velocity = vel*dDda;
         }
     }

void App_Var_Chi::ChiImpl::solve	(	double	a,
		const std::vector< Particle_v< double >> &	particles,
		const Sim_Param &	sim,
		const FFTW_PLAN_TYPE &	p_F,
		const FFTW_PLAN_TYPE &	p_B
	)

inline

set prefactor
set convergence – compensate for units in which we compute laplace operator
save (over)density from particles

linear guess and solver

set guess from linear theory
set guess from linear theory and correct unphysical values
get multigrid_solver runnig

< solve using multigrid teqniques

< solve only on the finest mesh using NGS sweeps

Definition at line 714 of file chameleon.cpp.

References Sim_Param::chi_opt, Sim_Param::cosmo, get_rho_from_par(), Chi_Opt::linear, and anonymous_namespace{chameleon.cpp}::transform_Mesh_to_MultiGrid().

     {
         sol.set_time(a, sim.cosmo);
 
         sol.set_def_convergence();
 
         BOOST_LOG_TRIVIAL(debug) << "Storing density distribution...";
         get_rho_from_par(particles, chi_force[0], sim);
         transform_Mesh_to_MultiGrid(chi_force[0], drho);
 
         BOOST_LOG_TRIVIAL(debug) << "Setting linear guess for chameleon field...";
         if (sim.chi_opt.linear)
         {
             sol.set_linear_sol_at_level(chi_force[0], p_F, p_B, 0);
         }
         else
         {
             sol.set_linear(chi_force[0], p_F, p_B);
             sol.set_screened();
 
             BOOST_LOG_TRIVIAL(debug) << "Solving equations of motion for chameleon field...";
             solve_multigrid(); 
             solve_finest(); 
         }
     }

void App_Var_Chi::ChiImpl::solve_finest ( )

inlineprivate

< fine, coarse

Definition at line 820 of file chameleon.cpp.

     {
         sol.set_ngs_sweeps(5, 0); 
         sol.set_Nlevel(1);
         sol.set_maxsteps(30);
         ES status = sol.solve();
         sol.set_Nlevel(N_level_orig);
     }

void App_Var_Chi::ChiImpl::solve_multigrid ( )

inlineprivate

< fine, coarse

Definition at line 813 of file chameleon.cpp.

     {
         sol.set_ngs_sweeps(3, 6); 
         sol.set_maxsteps(30);
         ES status = sol.solve();
     }

Member Data Documentation

std::vector<Mesh> App_Var_Chi::ChiImpl::chi_force

Definition at line 710 of file chameleon.cpp.

MultiGrid<3, CHI_PREC_t> App_Var_Chi::ChiImpl::drho

Definition at line 709 of file chameleon.cpp.

uint64_t App_Var_Chi::ChiImpl::memory_alloc

Definition at line 711 of file chameleon.cpp.

const size_t App_Var_Chi::ChiImpl::N_level_orig

private

Definition at line 810 of file chameleon.cpp.

ChiSolver<CHI_PREC_t> App_Var_Chi::ChiImpl::sol

Definition at line 708 of file chameleon.cpp.

const double App_Var_Chi::ChiImpl::x_0

private

Definition at line 811 of file chameleon.cpp.

The documentation for this class was generated from the following file:

src/ApproximationsSchemes/chameleon.cpp

Public Member Functions

Public Attributes

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation