static inline void apply(nodes_container_type & additional_nodes,
Node & n,
Box & n_box,
parameters_type const& parameters,
Translator const& translator,
Allocators & allocators)
{
// TODO - consider creating nodes always with sufficient memory allocated
// create additional node, use auto ptr for automatic destruction on exception
node_auto_ptr second_node(rtree::create_node<Allocators, Node>::apply(allocators), allocators); // MAY THROW, STRONG (N: alloc)
// create reference to the newly created node
Node & n2 = rtree::get<Node>(*second_node);
// NOTE: thread-safety
// After throwing an exception by redistribute_elements the original node may be not changed or
// both nodes may be empty. In both cases the tree won't be valid r-tree.
// The alternative is to create 2 (or more) additional nodes here and store backup info
// in the original node, then, if exception was thrown, the node would always have more than max
// elements.
// The alternative is to use moving semantics in the implementations of redistribute_elements,
// it will be possible to throw from boost::move() in the case of e.g. static size nodes.
// redistribute elements
Box box2;
redistribute_elements<
Value,
Options,
Translator,
Box,
Allocators,
typename Options::redistribute_tag
>::apply(n, n2, n_box, box2, parameters, translator, allocators); // MAY THROW (V, E: alloc, copy, copy)
// check numbers of elements
BOOST_GEOMETRY_INDEX_ASSERT(parameters.get_min_elements() <= rtree::elements(n).size() &&
rtree::elements(n).size() <= parameters.get_max_elements(),
"unexpected number of elements");
BOOST_GEOMETRY_INDEX_ASSERT(parameters.get_min_elements() <= rtree::elements(n2).size() &&
rtree::elements(n2).size() <= parameters.get_max_elements(),
"unexpected number of elements");
// return the list of newly created nodes (this algorithm returns one)
additional_nodes.push_back(rtree::make_ptr_pair(box2, second_node.get())); // MAY THROW, STRONG (alloc, copy)
// release the ptr
second_node.release();
}
// Defines the parameters for the ising simulation
void ising_sim::define_parameters(parameters_type & parameters) {
// If the parameters are restored, they are already defined
if (parameters.is_restored()) {
return;
}
// Adds the parameters of the base class
alps::mcbase::define_parameters(parameters);
// Adds the convenience parameters (for save/load)
// followed by the ising specific parameters
alps::define_convenience_parameters(parameters)
.description("1D ising simulation")
.define<int>("length", 50, "lenth of the periodic ising chain")
.define<int>("sweeps", 1000, "maximum number of sweeps")
.define<int>("thermalization", "number of sweeps for thermalization")
.define<double>("temperature", "temperature of the system");
}
sge::sprite::state::object<
StateChoices
>::object(
render_device &_renderer,
parameters_type const &_parameters
)
:
renderer_(
_renderer
),
elements_(
sge::sprite::state::detail::make_objects<
StateChoices
>(
_renderer,
_parameters.elements()
)
)
{
}
void hybridization::define_parameters(parameters_type & parameters) {
// If the parameters are restored, they exist
if (parameters.is_restored()) {
return;
}
// Adds the parameters of the base class
alps::mcbase::define_parameters(parameters);
// Adds the convenience parameters (for save/load)
// alps::define_convenience_parameters(parameters);
// Define ct-hyb related parameters
parameters
.description("hybridization expansion simulation")
.define<bool>("cthyb.ACCURATE_COVARIANCE", false, "TODO: UNDERSTAND WHAT THIS DOES")
.define<std::string>("cthyb.BASEPATH","", "path in hdf5 file to which results are stored")
.define<double>("BETA", "inverse temperature")
.define<bool>("cthyb.COMPUTE_VERTEX", false, "whether to compute the vertex functions or not.")
.define<std::string>("cthyb.DELTA","path for hybridization function file")
.define<bool>("cthyb.DELTA_IN_HDF5",false,"true if hybridization function file is in hdf5 format")
.define<bool>("cthyb.DMFT_FRAMEWORK",false,"true if we need to tie into a dmft framework")
.define<bool>("cthyb.GLOBALFLIP", false, "TODO: UNDERSTAND WHAT THIS DOES.")
.define<double>("cthyb.J",0,"interaction value for density-density Hund's coupling term J.")
.define<bool>("cthyb.K_IN_HDF5",false,"set to true if retarded interaction K is stored in hdf5.")
.define<bool>("cthyb.MEASURE_freq",true, "measure in frequency domain")
.define<bool>("cthyb.MEASURE_g2w",false, "measure two-particle Green's function in frequency space")
.define<bool>("cthyb.MEASURE_h2w",false, "measure two-particle H Green's function in frequency space")
.define<bool>("cthyb.MEASURE_legendre",false, "measure legendre Green's function coefficients")
.define<bool>("cthyb.MEASURE_nn",false, "measure static density-density correlation functions")
.define<bool>("cthyb.MEASURE_nnt",false, "measure density-density correlation functions <n(0) n(t)>")
.define<bool>("cthyb.MEASURE_nnw",false, "measure density-density correlation functions in frequency domain")
.define<bool>("cthyb.MEASURE_sector_statistics",false, "measure sector statistics")
.define<bool>("cthyb.MEASURE_time",false, "measure in the time domain")
.define<double>("MU", "chemical potential / orbital energy values") //!TODO: document the shift by U/2
.define<std::string>("MU_VECTOR", "file name for file with chemical potential / orbital energy values")
.define<bool>("MU_IN_HDF5", false,"true if the file MU_VECTOR points to a hdf5 file")
.define<int >("cthyb.N_HISTOGRAM_ORDERS",200, "orders for the histograms of probability per order")
.define<int >("cthyb.N_LEGENDRE",0,"number of legendre coefficients")
.define<int >("NMATSUBARA",40,"number of matsubara coefficients")
.define<int >("cthyb.N_MEAS","number of updates per measurement")
.define<int >("FLAVORS","number of spin-orbitals (sometimes called flavors)")
.define<int >("N","number of imaginary time discretization points")
.define<int >("cthyb.N_W",0,"number of bosonic Matsubara frequencies for the two-particle measurement (0 ... N_W)")
.define<int >("cthyb.N_nn",0,"number of points for the measurement of the density density correlator")
.define<int >("cthyb.N_w2",0,"number of fermionic frequencies for the two-particle measurement (-N_w2 ... N_w2-1)")
.define<std::string>("cthyb.RET_INT_K","file with the retarted interaction information. See doc for format.")
.define<bool>("cthyb.SPINFLIP",false,"TODO: UNDERSTAND THIS PARAMETER")
.define<unsigned long>("cthyb.SWEEPS","total number of Monte Carlo sweeps to be done")
.define<bool>("cthyb.TEXT_OUTPUT","if this is enabled, we write text files in addition to hdf5 files")
.define<unsigned long>("cthyb.THERMALIZATION","thermalization steps")
.define<double>("U","interaction value. Only specify if you are not reading an U matrix")
.define<double>("Uprime",0,"interaction value Uprime. Only specify if you are not reading an U matrix")
.define<std::string>("U_MATRIX","file name for file that contains the interaction matrix")
.define<bool>("UMATRIX_IN_HDF5",false,"true if we store the U_matrix as /Umatrix in a hdf5 file")
.define<bool>("VERBOSE",false,"how verbose the code is. true = more output")
.define<std::size_t>("MAX_TIME", "maximum solver runtime")
.define<std::string>("solver.OUTFILE_H5GF", "alps_solver_in.h5gf", "H5GF Green's function input file containing G0(omega,k) at /G0 and G0(ij, tau) at /G0_tau_rs")
.define<std::string>("solver.INFILE_H5GF", "alps_solver_out.h5gf","H5GF Green's function output file containing G(omega,k) at /G_omega and G(ij, tau) at /G_tau")
.define<int >("L", 200, "Number of Brillouin Zone points")
.define<double>("t", 1.0, "Hopping element: nearest neighbor")
.define<double>("tprime", 0.0, "Hopping element: next-nearest neighbor")
;
}
unsigned int handle_nonopt(const parameters_type& params) {
inputfile = *(params.current());
return 1;
}
unsigned int handle_behind_parameters(const parameters_type& params) {
// only one input is allowed
throw avslint_error(BAD_ARGUMENT,
"Don't specify anything behind the nonopt parameter: "
+ *(params.current()) + "\n");
}
// implementations for virtual member functions of the super class
// util::getopt::getopt
unsigned int handle_unknown_opt(const parameters_type& params) {
// cash unknown options
unknown_opt.push_back(*(params.current()));
return 1;
}
static inline void apply(Node & n,
Node & second_node,
Box & box1,
Box & box2,
parameters_type const& parameters,
Translator const& translator,
Allocators & allocators)
{
typedef typename rtree::elements_type<Node>::type elements_type;
typedef typename elements_type::value_type element_type;
typedef typename rtree::element_indexable_type<element_type, Translator>::type indexable_type;
elements_type & elements1 = rtree::elements(n);
elements_type & elements2 = rtree::elements(second_node);
BOOST_GEOMETRY_INDEX_ASSERT(elements1.size() == parameters.get_max_elements() + 1, "unexpected elements number");
// copy original elements - use in-memory storage (std::allocator)
// TODO: move if noexcept
typedef typename rtree::container_from_elements_type<elements_type, element_type>::type
container_type;
container_type elements_copy(elements1.begin(), elements1.end()); // MAY THROW, STRONG (alloc, copy)
container_type elements_backup(elements1.begin(), elements1.end()); // MAY THROW, STRONG (alloc, copy)
// calculate initial seeds
size_t seed1 = 0;
size_t seed2 = 0;
quadratic::pick_seeds<Box>(elements_copy, parameters, translator, seed1, seed2);
// prepare nodes' elements containers
elements1.clear();
BOOST_GEOMETRY_INDEX_ASSERT(elements2.empty(), "second node's elements container should be empty");
BOOST_TRY
{
// add seeds
elements1.push_back(elements_copy[seed1]); // MAY THROW, STRONG (copy)
elements2.push_back(elements_copy[seed2]); // MAY THROW, STRONG (alloc, copy)
// calculate boxes
detail::bounds(rtree::element_indexable(elements_copy[seed1], translator), box1);
detail::bounds(rtree::element_indexable(elements_copy[seed2], translator), box2);
// remove seeds
if (seed1 < seed2)
{
rtree::move_from_back(elements_copy, elements_copy.begin() + seed2); // MAY THROW, STRONG (copy)
elements_copy.pop_back();
rtree::move_from_back(elements_copy, elements_copy.begin() + seed1); // MAY THROW, STRONG (copy)
elements_copy.pop_back();
}
else
{
rtree::move_from_back(elements_copy, elements_copy.begin() + seed1); // MAY THROW, STRONG (copy)
elements_copy.pop_back();
rtree::move_from_back(elements_copy, elements_copy.begin() + seed2); // MAY THROW, STRONG (copy)
elements_copy.pop_back();
}
// initialize areas
content_type content1 = index::detail::content(box1);
content_type content2 = index::detail::content(box2);
size_t remaining = elements_copy.size();
// redistribute the rest of the elements
while ( !elements_copy.empty() )
{
typename container_type::reverse_iterator el_it = elements_copy.rbegin();
bool insert_into_group1 = false;
size_t elements1_count = elements1.size();
size_t elements2_count = elements2.size();
// if there is small number of elements left and the number of elements in node is lesser than min_elems
// just insert them to this node
if ( elements1_count + remaining <= parameters.get_min_elements() )
{
insert_into_group1 = true;
}
else if ( elements2_count + remaining <= parameters.get_min_elements() )
{
insert_into_group1 = false;
}
// insert the best element
else
{
// find element with minimum groups areas increses differences
content_type content_increase1 = 0;
content_type content_increase2 = 0;
el_it = pick_next(elements_copy.rbegin(), elements_copy.rend(),
box1, box2, content1, content2, translator,
content_increase1, content_increase2);
if ( content_increase1 < content_increase2 ||
( content_increase1 == content_increase2 && ( content1 < content2 ||
( content1 == content2 && elements1_count <= elements2_count ) )
) )
{
insert_into_group1 = true;
}
else
{
insert_into_group1 = false;
}
}
// move element to the choosen group
element_type const& elem = *el_it;
indexable_type const& indexable = rtree::element_indexable(elem, translator);
if ( insert_into_group1 )
{
elements1.push_back(elem); // MAY THROW, STRONG (copy)
geometry::expand(box1, indexable);
content1 = index::detail::content(box1);
}
else
{
elements2.push_back(elem); // MAY THROW, STRONG (alloc, copy)
geometry::expand(box2, indexable);
content2 = index::detail::content(box2);
}
BOOST_GEOMETRY_INDEX_ASSERT(!elements_copy.empty(), "expected more elements");
typename container_type::iterator el_it_base = el_it.base();
rtree::move_from_back(elements_copy, --el_it_base); // MAY THROW, STRONG (copy)
elements_copy.pop_back();
BOOST_GEOMETRY_INDEX_ASSERT(0 < remaining, "expected more remaining elements");
--remaining;
}
}
BOOST_CATCH(...)
{
//elements_copy.clear();
elements1.clear();
elements2.clear();
rtree::destroy_elements<Value, Options, Translator, Box, Allocators>::apply(elements_backup, allocators);
//elements_backup.clear();
BOOST_RETHROW // RETHROW, BASIC
}
