void write_tasks(transport::repository<>& repo, transport::dquad_mpi<>* model)
{
const double Mp = 1.0;
const double Mphi = 9E-5 * Mp;
const double Mchi = 1E-5 * Mp;
transport::parameters<> params(Mp, {Mphi, Mchi}, model);
const double phi_init = 10.0 * Mp;
const double chi_init = 12.9 * Mp;
const double N_init = 0.0;
const double N_pre = 12.0;
const double N_end = 60.0;
transport::initial_conditions<> ics("dquad", params, {phi_init, chi_init}, N_init, N_pre);
transport::basic_range<> ts(N_init, N_end, 300, transport::spacing::linear);
const double kt_lo = std::exp(3.0);
const double kt_hi = std::exp(8.0);
transport::basic_range<> ks(kt_lo, kt_hi, 50, transport::spacing::log_bottom);
transport::twopf_task<> tk2("dquad.twopf", ics, ts, ks);
tk2.set_adaptive_ics_efolds(5.0);
tk2.set_description("Compute time history of the 2-point function from k ~ e^3 to k ~ e^9");
transport::threepf_cubic_task<> tk3("dquad.threepf", ics, ts, ks);
tk3.set_adaptive_ics_efolds(5.0);
tk3.set_description("Compute time history of the 3-point function on a cubic lattice from k ~ e^3 to k ~ e^9");
repo.commit(tk2);
repo.commit(tk3);
}
void write_tasks(transport::repository<>& repo, transport::step_mpi<>* model)
{
const double M_P = 1.0;
const double m = 1E-5 * M_P;
const double c = 0.0018;
const double d = 0.022 * M_P;
const double phi0 = 14.84 * M_P;
const double phi_init = 16.5 * M_P;
const double N_init = 0.0;
const double N_pre = 6.0;
const double N_max = 50.1;
transport::parameters<> params(M_P, { m, c, d, phi0 }, model);
transport::initial_conditions<> ics("step", params, { phi_init }, N_init, N_pre);
transport::basic_range<> times(N_init, N_max, 100, transport::spacing::linear);
transport::basic_range<> ks(exp(7.0), exp(11.5), 1000, transport::spacing::log_bottom);
transport::basic_range<> alphas(0.0, 0.0, 0, transport::spacing::linear);
transport::basic_range<> betas(1.0/3.0, 1.0/3.0, 0, transport::spacing::linear);
// construct a threepf task
transport::threepf_alphabeta_task<> tk3("step.threepf", ics, times, ks, alphas, betas);
tk3.set_collect_initial_conditions(true).set_adaptive_ics_efolds(5.0);
transport::zeta_threepf_task<> ztk3("step.threepf-zeta", tk3);
repo.commit(ztk3);
}
void write_tasks(transport::repository<>& repo, transport::new_axion_mpi<>* model)
{
const double M_Planck = 1.0;
const double g = 1e-10;
const double f = M_Planck;
const double Lambda = std::pow(g, 1.0/4.0) * std::pow(25.0/(2*M_PI), 1.0/2.0) * M_Planck;
const double phi_init = 23.5 * M_Planck;
const double chi_init = f/2.0 - 0.001*M_Planck;
const double N_init = 0.0;
const double N_pre = 10.0;
const double N_max = 68.0;
transport::parameters<> params(M_Planck, { g, Lambda, f, M_PI }, model);
transport::initial_conditions<> ics("axion_cfs", params, { phi_init, chi_init }, N_init, N_pre);
transport::basic_range<> times(N_init, N_max, 500, transport::spacing::linear);
transport::basic_range<> ks(exp(5.0), exp(5.0), 0, transport::spacing::linear);
transport::basic_range<> alphas(0.0, 0.0, 0, transport::spacing::linear);
transport::basic_range<> beta_equi(1.0/3.0, 1.0/3.0, 0, transport::spacing::linear);
transport::basic_range<> beta_sq(0.95, 0.95, 0, transport::spacing::linear);
// construct a threepf task for the equilateral mode
transport::threepf_alphabeta_task<> tk3_equi("axion_cfs.equi.threepf", ics, times, ks, alphas, beta_equi);
tk3_equi.set_adaptive_ics_efolds(4.0);
tk3_equi.set_collect_initial_conditions(true);
transport::zeta_threepf_task<> ztk3_equi("axion_cfs.equi.threepf-zeta", tk3_equi);
ztk3_equi.set_paired(true);
// construct a threepf task for the squeezed mode
transport::threepf_alphabeta_task<> tk3_sq("axion_cfs.sq.threepf", ics, times, ks, alphas, beta_sq);
tk3_sq.set_adaptive_ics_efolds(4.0);
tk3_sq.set_collect_initial_conditions(true);
transport::zeta_threepf_task<> ztk3_sq("axion_cfs.sq.threepf-zeta", tk3_sq);
ztk3_sq.set_paired(true);
repo.commit(ztk3_equi);
repo.commit(ztk3_sq);
}
void CTest::TestEmptyInputData(CCompressStream::EMethod method)
{
const size_t kLen = 1024;
char src_buf[kLen];
char dst_buf[kLen];
char cmp_buf[kLen];
size_t n;
const size_t count = ArraySize(s_EmptyInputDataTests);
for (size_t i = 0; i < count; ++i)
{
SEmptyInputDataTest test = s_EmptyInputDataTests[i];
if (test.method != method) {
continue;
}
_TRACE("Test # " << i+1);
CNcbiIstrstream is_str("");
unique_ptr<CCompression> compression;
unique_ptr<CCompressionStreamProcessor> stream_compressor;
unique_ptr<CCompressionStreamProcessor> stream_decompressor;
if (method == CCompressStream::eBZip2) {
compression.reset(new CBZip2Compression());
compression->SetFlags(test.flags);
stream_compressor.reset(new CBZip2StreamCompressor(test.flags));
stream_decompressor.reset(new CBZip2StreamDecompressor(test.flags));
} else
#if defined(HAVE_LIBLZO)
if (method == CCompressStream::eLZO) {
compression.reset(new CLZOCompression());
compression->SetFlags(test.flags);
stream_compressor.reset(new CLZOStreamCompressor(test.flags));
stream_decompressor.reset(new CLZOStreamDecompressor(test.flags));
} else
#endif
if (method == CCompressStream::eZip) {
compression.reset(new CZipCompression());
compression->SetFlags(test.flags);
stream_compressor.reset(new CZipStreamCompressor(test.flags));
stream_decompressor.reset(new CZipStreamDecompressor(test.flags));
} else
{
_TROUBLE;
}
// ---- Run tests ----
// Buffer compression/decompression test
{{
bool res = compression->CompressBuffer(src_buf, 0, dst_buf, kLen, &n);
assert(res == test.result);
assert(n == test.buffer_output_size);
res = compression->DecompressBuffer(dst_buf, n, cmp_buf, kLen, &n);
assert(res == test.result);
assert(n == 0);
}}
// Input stream tests
{{
CCompressionIStream ics(is_str, stream_compressor.get());
assert(ics.good());
ics.read(dst_buf, kLen);
assert(ics.eof());
n = (size_t)ics.gcount();
assert(n == test.stream_output_size);
assert(ics.GetProcessedSize() == 0);
assert(ics.GetOutputSize() == n);
CCompressionIStream ids(is_str, stream_decompressor.get());
assert(ids.good());
ids.read(dst_buf, kLen);
assert(ids.eof());
n = (size_t)ids.gcount();
assert(n == 0);
assert(ids.GetProcessedSize() == 0);
assert(ids.GetOutputSize() == n);
}}
// Output stream tests
{{
{{
CNcbiOstrstream os_str;
CCompressionOStream ocs(os_str, stream_compressor.get());
assert(ocs.good());
ocs.Finalize();
assert(ocs.good());
n = (size_t)GetOssSize(os_str);
assert(n == test.stream_output_size);
assert(ocs.GetProcessedSize() == 0);
assert(ocs.GetOutputSize() == n);
}}
{{
CNcbiOstrstream os_str;
CCompressionOStream ods(os_str, stream_decompressor.get());
assert(ods.good());
ods.Finalize();
assert(test.result ? ods.good() : !ods.good());
n = (size_t)GetOssSize(os_str);
assert(n == 0);
assert(ods.GetProcessedSize() == 0);
assert(ods.GetOutputSize() == n);
}}
}}
// Output stream tests -- with flush()
{{
{{
CNcbiOstrstream os_str;
CCompressionOStream ocs(os_str, stream_compressor.get());
assert(ocs.good());
ocs.flush();
assert(ocs.good());
ocs.Finalize();
assert(ocs.good());
n = (size_t)GetOssSize(os_str);
assert(n == test.stream_output_size);
assert(ocs.GetProcessedSize() == 0);
assert(ocs.GetOutputSize() == n);
}}
{{
CNcbiOstrstream os_str;
CCompressionOStream ods(os_str, stream_decompressor.get());
assert(ods.good());
ods.flush();
assert(ods.good());
ods.Finalize();
assert(test.result ? ods.good() : !ods.good());
n = (size_t)GetOssSize(os_str);
assert(n == 0);
assert(ods.GetProcessedSize() == 0);
assert(ods.GetOutputSize() == n);
}}
}}
}
}
