AdaptiveCylinderCone< dim, T > | This class represent an Adaptive cylinder cone |
add_< Tdst, Tsrc > | This structure define the operation add to use with copy general |
openfpm::add_prp_impl< objv, vect_dst > | Struct to merge two vectors |
add_prp_impl< objv, vect_dst > | Struct to merge two vectors |
openfpm::add_prp_impl< OBJECT_ADD, vect_dst > | Struct to merge two vectors |
add_prp_impl< OBJECT_ADD, vect_dst > | Struct to merge two vectors |
Aexample | Example structure |
agg_arr< n_ele > | It store the offsets of the interpolation points |
aggregate< list > | Aggregate of properties, from a list of object if create a struct that follow the OPENFPM native structure |
allocate< S > | This class is a functor for "for_each" algorithm |
AMG_time_err_coars | It contain information about the performance of the AMG |
anyname_field | [Constant fields struct definition] |
anyname_field_with_pos | Define a non-constant (in space) field |
apply_kernel_is_number_or_expression< T, vector, exp, NN_type, Kernel, rtype, is_exp > | Apply the kernel to particle differently that is a number or is an expression |
apply_kernel_is_number_or_expression_gen< T, vector, exp, NN_type, Kernel, rtype, is_exp > | Apply the kernel to particle differently that is a number or is an expression |
apply_kernel_is_number_or_expression_sim< vector, exp, NN_type, Kernel, rtype > | Apply the kernel to particle differently that is a number or is an expression |
apply_kernel_rtype< exp, is_exp > | It give the return type of the expression if applicable |
apply_kernel_rtype< exp, false > | It give the return type of the expression if applicable |
array_extents< T > | Struct that give functionalities on array extensions |
array_extents< T[N1]> | Struct that give functionalities on array extensions |
array_extents< T[N1][N2]> | Struct that give functionalities on array extensions |
array_extents< T[N1][N2][N3]> | Struct that give functionalities on array extensions |
ArrayHolder< T, args > | Array itself |
ArrayHolder_constexpr< T, args > | Array itself |
ArrayHolder_indexes< T, args > | Array itself |
as_array_nnc< dim > | Set a dimension threshold |
memory_c< multi_array< T >, D >::ascending< index, N > | In combination with generate_array is used to produce array at compile-time |
nm_part_v::attributes | Attributes name |
vertex::attributes | Attributes name |
vertex2::attributes | Attributes name |
vertex3::attributes | Attributes name |
nm_e::attributes | Attributes name |
nm_part_e::attributes | Attributes name |
node_cp::attributes | Attributes name |
test_has_attributes::attributes | Define attribute names |
nm_v::attributes | Attributes name |
vx::attributes | Attributes name |
Point_test_scal< T >::attributes | Attributes name |
Point_test_prp< T >::attributes | Attributes name |
ne_cp::attributes | Define attributes names |
ed::attributes | Attributes name |
Avg< d, Field, Sys_eqs, impl > | Average |
Avg< d, arg, Sys_eqs, BACKWARD > | First order BACKWARD derivative on direction i |
Avg< d, arg, Sys_eqs, CENTRAL > | Central average scheme on direction i |
Avg< d, arg, Sys_eqs, FORWARD > | FORWARD average on direction i |
base_copy< has_base, base_obj, v_obj > | |
base_copy< true, base_obj, v_obj > | |
Vcluster::base_info | Base info |
bisect_unroll< dim, ORB > | This class is a functor for "for_each" algorithm |
Box< dim, T > | This class represent an N-dimensional box |
Ghost< dim, T > | |
SpaceBox< dim, T > | This class represent an N-dimensional box |
Box< 3, float > | |
Box< dim, dT > | |
Box< dim, long int > | |
Ghost< dim, long int > | |
Padding< dim > | Class that contain Padding information on each direction positive and Negative direction |
Padding< Sys_eqs::dims > | |
Box< dim, size_t > | |
SpaceBox< dim, size_t > | |
wavefront< dim > | This class represent a wavefront of dimension dim |
Box< dim, St > | |
Ghost< dim, St > | |
Box< dim, typename last::stype > | |
Ghost< dim, typename last::stype > | |
Box< dim, typename Sys_eqs::stype > | |
Ghost< dim, typename Sys_eqs::stype > | |
Box< Grid::dims, size_t > | |
Box< N, size_t > | |
Box< vector::dims, size_t > | |
Box< vector::dims, typename vector::stype > | |
Box_dom< dim, T > | Case for external ghost box |
Box_fix< dim > | Internal ghost box sent to construct external ghost box into the other processors |
CartDecomposition< dim, T, Memory, Distribution >::box_id | Class to select the returned id by ghost_processorID |
Box_loc_sub< dim, T > | For each sub-domain box sub contain the real the sub-domain id |
Box_proc< dim, T > | Case for local external ghost box |
Box_sub< dim, T > | |
Box_sub_k< dim, T > | Particular case for local internal ghost boxes |
interpolate< vector, grid, kernel >::Box_vol | |
brt_test | |
calculate_aint< dims, vector, np > | Calculate aint |
calculate_aint< 2, vector, np > | Calculate aint 2D |
calculate_aint< 3, vector, np > | Calculate aint |
call_aggregatePack< obj_type, Mem, prp > | Calls a packer in nested way |
call_aggregatePackRequest< obj_type, Mem, prp > | |
call_aggregateUnpack< obj_type, Mem, prp > | Calls an unpacker in nested way |
call_encapPack< encap, Mem, prp > | |
call_encapPackRequest< encap, Mem, prp > | |
call_encapUnpack< encap, Mem, prp > | |
call_init_if_needed< T, has_init > | Call the init function if a type T has the function init |
call_init_if_needed< T, false > | Call the init function if a type T has the function init |
call_pack_agg_functor< obj_type, Mem > | |
call_pack_enc_functor< encap, Mem > | |
call_packRequest_agg_functor< obj_type, Mem > | |
call_packRequest_enc_functor< encap, Mem > | |
call_serialize_variadic< T > | |
call_serialize_variadic< index_tuple< prp...> > | |
call_unpack_agg_functor< obj_type, Mem > | |
call_unpack_encap_functor< encap, Mem, prp > | |
CartesianGraphFactory< dim, Graph > | This class construct a cartesian graph |
cell_grid< Grid > | For each combination in the cell grid you can have different grids |
CellBase | |
CellListM< dim, T, sh_byte, CellBase > | Class for Multi-Phase cell-list |
CellDecomposer_sm | |
CellList< dim, T, Mem_type, transform, base > | Class for FAST cell list implementation |
CellList_gen< dim, T, Prock, Mem_type, transform, base > | |
CellList< dim, T, Mem_fast<>, shift< dim, T > > | |
CellList< vector::dims, typename vector::stype, Mem_fast<>, shift< vector::dims, typename vector::stype > > | |
CellIterator< Cell > | It iterate through the elements of a cell |
CellIteratorM< Cell, sh_byte > | It iterate through the elements of a cell |
CellNNIterator< dim, Cell, NNc_size, impl > | Iterator for the neighborhood of the cell structures |
CellNNIteratorM< dim, Cell, sh_byte, NNc_size, impl > | Iterator for the neighborhood of the cell structures |
CellNNIteratorSym< dim, Cell, NNc_size, impl > | Symmetric iterator for the neighborhood of the cell structures |
CellNNIteratorSymM< dim, Cell, sh_byte, NNc_size, impl > | Iterator for the neighborhood of the cell structures |
CellNNIteratorSymMP< dim, Cell, NNc_size, impl > | Symmetric iterator for the neighborhood of the cell structures |
CellNNIterator< dim, Cell, RUNTIME, impl > | Iterator for the neighborhood of the cell structures |
CellNNIteratorM< dim, Cell, sh_byte, RUNTIME, impl > | Iterator for the neighborhood of the cell structures |
CellNNIteratorSym< dim, Cell, RUNTIME, impl > | Symmetric iterator for the neighborhood of the cell structures |
CellNNIteratorSymM< dim, Cell, sh_byte, RUNTIME, impl > | Symmetric iterator for the neighborhood of the cell structures |
CellNNIteratorRadius< dim, Cell, impl > | Iterator for the neighborhood of the cell structures with free radius |
check_no_pointers< T > | This class check if the type T has pointers inside |
check_no_pointers_impl< T, has_pointer > | Check if the type T has pointers inside |
check_no_pointers_impl< T, false > | Check if the type T has pointers inside |
check_types< v > | Functor for for_each algorithm |
CheckExistence | Class to check if the edge can be created or not |
comb< dim > | Position of the element of dimension d in the hyper-cube of dimension dim |
comb< 0 > | |
comb< Grid::dims > | |
comb< Sys_eqs::dims > | |
compare_aggregate< S > | Structure to copy aggregates applying an operation limited to some properties |
compare_cpu_encap_encap< e_src, e_dst > | This class is a functor for "for_each" algorithm |
compare_fusion_vector< bfv > | This class is a functor for "for_each" algorithm |
compare_general< T, agg > | Structure to copy aggregates |
compare_general< T, 0 > | |
compare_general< T, 2 > | |
conditional_push< v, p_ele, to_push > | Push p_ele into v only of to_push is true |
conditional_push< v, p_ele, false > | Push p_ele into v only of to_push is true |
const_mul_functor_value< v_expr > | Multiplication expression |
FDScheme< Sys_eqs >::constant_b | Encapsulation of the b term as constant |
ConstField | |
construct_expression< T > | |
construct_expression< double > | Construct a vector expression from a double |
construct_expression< float > | Construct a vector expression from a float |
convert< A > | Set a conversion map between A and B |
convert< std::string > | Partial specialization when A is a string |
copy_acc< S > | This class is a functor for "for_each" algorithm |
copy_aggregate< S > | Structure to copy aggregates |
copy_aggregate_op< op, S > | Structure to copy aggregates applying an operation |
copy_cpu_encap< dim, S, Memory > | This class is a functor for "for_each" algorithm |
copy_cpu_encap_encap< e_src, e_dst > | This class is a functor for "for_each" algorithm |
copy_cpu_encap_encap_op_prp< op, e_src, e_dst, prp > | It copy two encap object |
copy_ele< Eqs_sys, S, Ev > | This class is a functor for "for_each" algorithm |
copy_ele_sca_array< copy_type, T, Ev, Eqs_sys, sa > | Copy scalar elements |
copy_ele_sca_array< copy_type, T, Ev, Eqs_sys, 1 > | Copy 1D array elements |
copy_fusion_vector< bfv > | This class is a functor for "for_each" algorithm |
copy_fusion_vector_encap< bfv, enc > | This class is a functor for "for_each" algorithm |
copy_general< T, agg > | Structure to copy aggregates |
copy_general< T, 1 > | Specialization for if dst type is copy assignable from src type |
copy_general< T, 2 > | Specialization for aggregate type object |
copy_general< T, 3 > | Specialization for aggregate type object that define an operator= |
copy_general_op< op, T, agg > | Structure to copy aggregates applying an operation |
copy_general_op< op, T, 1 > | Specialization for object that can be assigned with an operator copy |
copy_general_op< op, T, 2 > | Specialization for aggregate type objects |
copy_general_op< op, T, 3 > | Specialization for aggregate type object that define an operator= |
copy_grid_fast< is_complex, N, grid, ginfo > | This is a way to quickly copy a grid into another grid |
copy_grid_fast< false, 2, grid, ginfo > | This is a way to quickly copy a grid into another grid |
copy_grid_fast< false, 3, grid, ginfo > | This is a way to quickly copy a grid into another grid |
copy_grid_fast< true, 1, grid, ginfo > | This is a way to quickly copy a grid into another grid |
copy_grid_fast< true, 2, grid, ginfo > | This is a way to quickly copy a grid into another grid |
copy_grid_fast< true, 3, grid, ginfo > | This is a way to quickly copy a grid into another grid |
csv_col< Tobj, attr > | This class is a functor for "for_each" algorithm |
csv_col< Tobj, false > | This class is a functor for "for_each" algorithm |
csv_col_str< T > | This class is an helper to produce csv headers from multi-array |
csv_col_str< T[N1]> | Partial specialization for N=1 1D-Array |
csv_col_str< T[N1][N2]> | Partial specialization for N=2 2D-Array |
csv_col_str< T[N1][N2][N3]> | Partial specialization for N=3 |
csv_col_str< T[N1][N2][N3][N4]> | Partial specialization for N=4 |
csv_prp< Tobj > | This class is a functor for "for_each" algorithm |
csv_value_str< T, is_writable > | This class is an helper to produce csv data from multi-array |
csv_value_str< T, false > | Partial specialization for unknown property |
csv_value_str< T[N1], is_writable > | Partial specialization for N=1 1D-Array |
csv_value_str< T[N1][N2], is_writable > | Partial specialization for N=2 2D-Array |
csv_value_str< T[N1][N2][N3], is_writable > | Partial specialization for N=3 |
csv_value_str< T[N1][N2][N3][N4], is_writable > | Partial specialization for N=4 |
CSVWriter< v_pos, v_prp, impl > | CSV Writer |
cval< T > | It store the non zero elements of the matrix |
D< d, Field, Sys_eqs, impl > | Derivative second order on h (spacing) |
D< d, arg, Sys_eqs, BACKWARD > | First order BACKWARD derivative on direction i |
D< d, arg, Sys_eqs, CENTRAL > | Second order central Derivative scheme on direction i |
D< d, arg, Sys_eqs, CENTRAL_B_ONE_SIDE > | Second order one sided Derivative scheme on direction i |
D< d, arg, Sys_eqs, FORWARD > | First order FORWARD derivative on direction i |
dataDiv< T > | Class that store Internal part external and border part of a dataset |
Debug< typename > | |
openfpm::Debug< typename > | |
dec_optimizer< dim, Graph > | This class take a graph representing the space decomposition and produce a simplified version |
Decomposition< T, S > | This class define the domain decomposition interface |
dist_prop_out_edge< Graph > | This class is a functor for "for_each" algorithm |
dist_prop_out_vertex< Graph > | This class is a functor for "for_each" algorithm |
dist_prop_output< has_attributes, Graph, i > | This class specialize functions in the case the type T has or not defined attributes |
dist_prop_output< false, Graph, i > | This class specialize functions in the case the type T has not defined attributes |
dist_prop_output_array_scalar_selector_edge< is_array > | Property writer for scalar and vector |
dist_prop_output_array_scalar_selector_edge< true > | Property writer for vector |
dist_prop_output_array_scalar_selector_edge_fill_vertex< is_array > | Property writer for scalar and vector, it fill the vertex data (needed for edge representation in vtk) |
dist_prop_output_array_scalar_selector_edge_fill_vertex< true > | Property writer for vector |
dist_prop_output_array_scalar_selector_vertex< is_array > | Property writer for scalar and vector |
dist_prop_output_array_scalar_selector_vertex< true > | Property writer for vector |
DistGraph_constr_impl< dim, Graph, se, T, dim_c, pos > | Graph constructor function specialization |
DistGraph_constr_impl< dim, Graph, NO_EDGE, T, dim_c, pos...> | Graph constructor function specialization |
DistGraph_CSR< V, E, Memory, layout_v, layout_e, layout_v_base, layout_e_base, grow_p > | Structure that store a graph in CSR format or basically in compressed adjacency matrix format |
DistGraph_CSR< nm_v, nm_e > | |
DistGraph_CSR< V, E > | |
DistGraph_CSR_s< V, E > | Simplified implementation of DistGraph_CSR |
DistGraphFactory< dim, Graph > | This class construct a cartesian graph |
DistParmetis< Graph > | Helper class to define Metis graph |
DistParmetis< DistGraph_CSR< nm_v, nm_e > > | |
DistParMetisDistribution< dim, T > | |
DLB | |
do_not_print_warning_on_adjustment< dim > | |
do_when_dim_gr_i< dim, i, ORB, Enable > | This structure use SFINAE to avoid instantiation of invalid code |
domain_nn_calculator_cart< dim > | This class calculate processor domains and neighborhood of each processor domain |
CartDecomposition< dim, T, Memory, Distribution > | This class decompose a space into sub-sub-domains and distribute them across processors |
CartDecomposition_ext< dim, T, Memory, Distribution > | This class decompose a space into sub-sub-domains and distribute them across processors |
DrawParticles | A class to draw/create particles based on simple shaped |
e_box_id< dim > | It store the information about the external ghost box |
e_info | |
e_lbox_grid< dim > | Per-processor external ghost box |
e_lbox_id< dim > | It store the information about the local external ghost box |
e_map | Structure used inside GraphCSR an edge |
E_p< T > | Edge class that encapsulate an object T |
ed | |
edge_iterator< Graph > | Graph edge iterator |
edge_key | |
edge_node< G > | This class is a functor for "for_each" algorithm |
edge_prop< G > | This class is a functor for "for_each" algorithm |
DistGraph_CSR< V, E, Memory, layout_v, layout_e, layout_v_base, layout_e_base, grow_p >::EdgeReq | Structure to store a add request of an edge |
ele_g< Grid, St > | It store one grid |
ele_g_st< Grid, St > | Convert a staggered element into a string for vtk write |
ele_vpp< Vpp > | Store a reference to the vector properties |
ele_vps< Vps > | Store a reference to the vector position |
encapc< dim, T, layout > | |
encapc< 1, obj_type, Memory > | |
encapc< dim, T, typename memory_traits_inte< T >::type > | This structure encapsulate an object of the grid |
encapc< dim, T, typename memory_traits_lin< T >::type > | This structure encapsulate an object of the grid |
encapc< dim, void, Mem > | This structure specialize the class for a void object or null |
ep_box_grid< dim > | Per-processor external ghost box |
Eq< expr1, expr2, Sys_eqs > | Equation |
equal_to | |
exit_impl< c, end > | Exit condition |
exit_impl< c, end > | Exit condition |
Error | Out-of-bound policy kill the program |
eta | [Definition of the system] |
exp_kernel | Exponential kernel |
extends< T > | Classes to get the number of components of the properties |
extends< T[N1]> | Partial specialization for N=1 1D-Array |
extends< T[N1][N2]> | Partial specialization for N=2 2D-Array |
extends< T[N1][N2][N3]> | Partial specialization for N=3 |
extends< T[N1][N2][N3][N4]> | Partial specialization for N=4 |
extends< T[N1][N2][N3][N4][N5]> | Partial specialization for N=5 |
extends< T[N1][N2][N3][N4][N5][N6]> | Partial specialization for N=6 |
extends< T[N1][N2][N3][N4][N5][N6][N7]> | Partial specialization for N=7 |
extends< T[N1][N2][N3][N4][N5][N6][N7][N8]> | Partial specialization for N=8 |
extends< T[N1][N2][N3][N4][N5][N6][N7][N8][N9]> | Partial specialization for N=9 |
extends< T[N1][N2][N3][N4][N5][N6][N7][N8][N9][N10]> | Partial specialization for N=10 |
F< T > | [v_transform metafunction] |
false_type | |
has_attributes< T, Sfinae > | |
has_base_to_copy< T, Sfinae > | |
has_data< T, Sfinae > | |
has_grid_type< T, Sfinae > | |
has_init< ObjType, Sfinae > | Has_init check if a type has defined a method called init |
has_max_prop_nn< T, Sfinae > | |
has_noPointers< T, Sfinae > | |
has_pack< ObjType, Sfinae > | Has_Pack check if a type has defined a method called Pack |
has_packMem< ObjType, Sfinae > | Has_calculateMem check if a type has defined a method called calculateMem |
has_packRequest< ObjType, Sfinae > | Has_packRequest check if a type has defined a method called packRequest |
has_posMask< T, Sfinae > | |
has_typedef_type< T, Sfinae > | |
has_val_pos< T, Sfinae > | |
has_value_type< T, Sfinae > | |
is_const_field< T, Sfinae > | |
is_custom_vtk_writable< ObjType, Sfinae > | It check if the type is vtk writable |
is_encap< T, Sfinae > | |
is_expression< ObjType, Sfinae > | Is_expression check if a type is simple a type or is just an encapsulation of an expression |
is_grid< T, Sfinae > | |
is_layout_inte< T, Sfinae > | |
is_layout_mlin< T, Sfinae > | |
is_openfpm_native< T, bool > | Is_openfpm_native check if a type is an openfpm native structure type |
is_testing< T, Sfinae > | |
is_vector< T, Sfinae > | |
is_vtk_vector_dims< ObjType, Sfinae > | It check if the type is vtk writable |
FDScheme< Sys_eqs > | Finite Differences |
Field< f, Sys_eqs > | |
fill_id< dim, G_v, prp > | Operator to fill the property 'prp' with the linearization of indexes |
fill_id< dim, G_v, NO_VERTEX_ID > | Operator to fill the property in case there are no properties |
Fill_one< index, N > | {1,1,1,1,....} |
fill_prop< dim, lin_id, dT, G_v, v, impl > | This class work as a functor |
fill_prop< dim, lin_id, dT, G_v, v, 0 > | This class work as a functor |
fill_prop< dim, lin_id, dT, G_v, v, 2 > | This class work as a functor |
fill_prop_by_type< i, p, Graph, pos > | Operator for vector and scalar property |
fill_prop_by_type< 0, p, Graph, pos...> | Operator for vector and scalar property in the case there are no properties |
fill_prop_v< dim, dT, G_v, v, impl > | This class work as a functor |
fill_prop_v< dim, dT, G_v, v, 0 > | This class work as a functor |
fill_prop_v< dim, dT, G_v, v, 2 > | This class work as a functor |
fill_prop_v_by_type< i, p, Graph, pos > | Operator for vector and scalar property |
fill_prop_v_by_type< 0, p, Graph, pos...> | Operator for vector and scalar property in the case there are no properties |
Fill_three< index, N > | Compile time array functor needed to generate array at compile-time of type |
Fill_two< index, N > | {2,2,2,2,....} |
Fill_zero< index, N > | {0,0,0,0,....} |
first_variadic< T1, T > | |
boost::mpl::aux::for_each_ref_impl< done > | |
boost::mpl::aux::for_each_ref_impl< false > | |
frswap< s_m > | This class is a functor for "for_each" algorithm |
Ftwo< arg0, T > | [v_transform metafunction] |
fun_index | |
GBoxes< dim > | This structure store the Box that define the domain inside the Ghost + domain box |
gcl< dim, St, CellL, Vector, impl > | General function t get a cell-list |
gcl< dim, St, CellL, Vector, GCL_HILBERT > | General function t get a cell-list |
gcl< dim, St, CellL, Vector, GCL_SYMMETRIC > | General function t get a cell-list |
gcl_An< dim, St, CellL, Vector, impl > | General function t get a cell-list |
GCoptions | Google chart options |
generate_array< T, N, F > | Main class to generate compile-time array |
generate_array_constexpr< T, N, F > | Main class to generate constexpr compile-time array |
generate_array_constexpr_impl< T, N, orig_N, F, args > | Recursive meta-function to generate compile-time array |
generate_array_constexpr_impl< T, 0, orig_N, F, args...> | Terminator of the variadic template |
generate_array_impl< T, N, orig_N, F, args > | Generate the array specializing ArrayHolder |
generate_array_impl< T, 0, orig_N, F, args...> | Terminator of the variadic template |
generate_array_vector< T, F > | Main class to generate an array from a boost::mpl::vector of numbers |
generate_array_vector_impl< T, N, F, args > | Generate the array specializing ArrayHolder |
generate_array_vector_impl< T, 1, F, args...> | Terminator of the variadic template |
generate_indexes< T, N, F > | Main class to generate indexes data structure |
generate_indexes_impl< T, N, orig_N, F, args > | Generate compile time index array |
generate_indexes_impl< T, 0, orig_N, F, args...> | Terminator of the variadic template |
generate_indexes_impl< T,-1, orig_N, F, args...> | In case of an empty list |
getAttrName< ele_g, has_attributes > | Return the Attributes name from the type |
getAttrName< ele_g, false > | Return the Attributes name from the type |
GGraph | Google Graph |
gid | |
DistGraph_CSR< V, E, Memory, layout_v, layout_e, layout_v_base, layout_e_base, grow_p >::GlobalVInfo | Structure needed to get vertex position by global id |
GoogleChart | Small class to produce graph with Google chart in HTML |
grid_dist_id_iterator_dec_skin< Decomposition >::gp_sub | Internal struct |
Graph_constructor_impl< dim, lin_id, Graph, se, T, dim_c, pos > | Graph constructor function specialization |
Graph_constructor_impl< dim, lin_id, Graph, NO_EDGE, T, dim_c, pos...> | Graph constructor function specialization |
Graph_CSR< V, E, Memory, layout_v, layout_e, layout_v_base, layout_e_base, grow_p > | Structure that store a graph in CSR format or basically in compressed adjacency matrix format |
Graph_CSR< nm_v, nm_e > | |
Graph_CSR< V, E > | |
Graph_CSR_s< V, E > | Simplified implementation of Graph_CSR |
GraphMLWriter< Graph > | |
grid< T > | |
FDScheme< Sys_eqs >::grid_b< grid, prp > | Encapsulation of the b term as grid |
grid_base_impl< dim, T, S, layout_, layout_base > | Implementation of a N-dimensional grid |
grid_base_impl< dim, T, S, memory_traits_inte< T >::type, memory_traits_inte > | |
grid_cpu< dim, T, S, typename memory_traits_inte< T >::type > | This is an N-dimensional grid or an N-dimensional array with memory_traits_inte layout |
grid_base_impl< dim, T, S, memory_traits_lin< T >::type, memory_traits_lin > | |
grid_cpu< dim, T, S, typename memory_traits_lin< T >::type > | This is an N-dimensional grid or an N-dimensional array with memory_traits_lin layout |
grid_call_serialize_variadic< device_grid, Memory, T > | Unpack selector |
grid_call_serialize_variadic< device_grid, Memory, index_tuple< prp...> > | Unpack selector |
grid_cpu< dim, T, S, layout > | |
grid_cpu< 1, T, Memory, typename layout_base< T >::type > | |
grid_cpu< dim, aggregate< size_t > > | |
grid_cpu< dim, Tg > | |
grid_dist_g_dx< device_grid > | Distributed linearized key |
grid_dist_id_comm< dim, St, T, Decomposition, Memory, device_grid > | This class is an helper for the communication of grid_dist_id |
grid_dist_id< dim, St, T, Decomposition, Memory, device_grid > | This is a distributed grid |
staggered_grid_dist< dim, St, T, Decomposition, Memory, device_grid > | Implementation of the staggered grid |
grid_dist_id_comm< dim, typename last::stype, aggregate< size_t >, typename last::b_grid::decomposition::extended_type, HeapMemory, grid_cpu< dim, aggregate< size_t > > > | |
grid_dist_id< last::dims, typename last::stype, aggregate< size_t >, typename last::b_grid::decomposition::extended_type > | |
grid_dist_id_comm< dim, typename Sys_eqs::stype, aggregate< size_t >, typename Sys_eqs::b_grid::decomposition::extended_type, HeapMemory, grid_cpu< dim, aggregate< size_t > > > | |
grid_dist_id< Sys_eqs::dims, typename Sys_eqs::stype, aggregate< size_t >, typename Sys_eqs::b_grid::decomposition::extended_type > | |
grid_dist_id_iterator_dec< Decomposition > | Given the decomposition it create an iterator |
PointIterator< dim, T, Decomposition > | This class draw particles on subset of grid-like position |
grid_dist_iterator< dim, device_grid, impl, stencil > | Distributed grid iterator |
grid_dist_iterator< dim, device_grid, FIXED, stencil > | Distributed grid iterator |
grid_dist_iterator< dim, device_grid, FREE, stencil > | Distributed grid iterator |
grid_dist_iterator_sub< dim, device_grid > | Distributed grid iterator |
grid_dist_key_dx< dim > | Grid key for a distributed grid |
grid_dist_key_dx< Eqs_sys::dims > | |
grid_dist_key_dx< Grid_dst::dims > | |
grid_dist_key_dx< last::dims > | |
grid_dist_lin_dx | Distributed linearized key |
grid_dist_testing< dim > | |
grid_key< p > | |
grid_key_1< p > | |
grid_key_2< p > | |
grid_key_3< p > | |
grid_key_4< p > | |
grid_key_c3< p > | |
grid_key_d< dim, p > | Grid_key_d is the key to access any element in the grid |
grid_key_dx< dim > | Grid_key_dx is the key to access any element in the grid |
grid_key_dx< Decomposition::dims > | |
grid_key_dx< Sys_eqs::dims > | |
grid_key_dx_expression< dim, exp > | Expression template for grid_key_dx |
grid_key_dx_expression< dim, grid_key_dx_sub< dim, exp1, exp2 > > | |
grid_key_dx_sub< dim, exp1, exp2 > | Main class that encapsulate a sub expression |
grid_key_dx_expression< dim, grid_key_dx_sum< dim, exp1, exp2 > > | |
grid_key_dx_sum< dim, exp1, exp2 > | Main class that encapsulate a sum expression |
grid_key_dx_iterator< dim, stencil > | |
grid_key_dx_iterator_sub< dim, stencil, warn > | Declaration grid_key_dx_iterator_sub |
grid_key_dx_iterator_sub_bc< dim, stencil, warn > | The same as grid_key_dx_iterator_sub_p but with periodic boundary |
grid_key_dx_iterator_sub< dim, stencil > | |
grid_key_dx_iterator< dim > | |
grid_key_dx_iterator_sp< dim > | |
grid_key_dx_iterator< dim, no_stencil > | |
grid_key_dx_iterator_sub< Decomposition::dims > | |
grid_key_dx_iterator_sub< dim > | |
grid_key_dx_iterator_sub< dim, no_stencil, print_warning_on_adjustment< dim > > | |
grid_key_dx_iterator_sub_bc< dim > | |
grid_key_dx_iterator_hilbert< dim > | |
grid_key_dx_iterator_sub< 0, warn > | |
grid_key_dx_r | Emulate grid_key_dx with runtime dimensionality |
grid_skin_iterator_bc< dim > | |
grid_skin_iterator_bc< Decomposition::dims > | |
grid_dist_id_iterator_dec_skin< Decomposition > | Given the decomposition it create an iterator |
PointIteratorSkin< dim, T, Decomposition > | This class draw particles on subset of grid-like position |
grid_sm< N, T > | Declaration grid_sm |
grid_sm< dim, aggregate< size_t > > | |
grid_sm< dim, T > | |
grid_sm< dim, void > | |
grid_sm< last::dims, void > | |
grid_sm< Sys_eqs::dims, void > | |
grid_unpack_selector_with_prp< result, T, device_grid, Memory > | Unpack selector |
grid_unpack_selector_with_prp< true, T, device_grid, Memory > | Unpack selector |
grid_unpack_with_prp< op, T, device_grid, Memory > | Unpack selector |
GridRawReader< dim, T, idx_type > | |
openfpm::grow_policy_double | Grow policy define how the vector should grow every time we exceed the size |
openfpm::grow_policy_identity | Grow policy define how the vector should grow every time we exceed the size |
openfpm::grow_policy_page | Grow policy define how the vector should grow every time we exceed the size |
H5_prop_out< ele_v, has_name > | This class is a functor for "for_each" algorithm |
H5_prop_out< ele_v, false > | This class is a functor for "for_each" algorithm |
H5_write< T, pid, V > | Write an HDF5 dataset in case of scalars and vectors |
H5_write< T[N1], pid, V > | Partial specialization for N=1 1D-Array |
H5_write< T[N1][N2], pid, V > | Partial specialization for N=2 2D-Array |
H5_write< T[N1][N2][N3], pid, V > | Partial specialization for N=3 |
H5_write< T[N1][N2][N3][N4], pid, V > | Partial specialization for N=4 |
has_max_prop< T, hvt > | |
has_max_prop< T, false > | |
has_pack_agg< T, prp > | Return if true the aggregate type T has a property that has a complex packing(serialization) method |
has_pack_agg_impl< T, N, result_p, vprp > | These set of classes generate an array definition at compile-time |
has_pack_agg_impl< T, 0, result_p, vprp > | Terminator of the variadic template |
has_pack_encap< T, prp > | |
has_pack_gen< T, sel > | It return true if the object T require complex serialization |
has_pack_gen< T, false > | It return true if the object T require complex serialization |
has_val< int, T > | Evaluate the constant field function |
has_val< HAS_VAL, T > | Evaluate the constant field function |
std::hash< gid > | |
std::hash< lid > | |
std::hash< rid > | |
HDF5_reader< type > | |
HDF5_reader< GRID_DIST > | |
HDF5_reader< VECTOR_DIST > | |
HDF5_writer< type > | |
HDF5_writer< GRID_DIST > | |
HDF5_writer< VECTOR_DIST > | |
HDF5_XdmfWriter< imp > | |
HDF5_XdmfWriter< H5_POINTSET > | HDF5 writer for a point set |
HyperCube< dim > | This class calculate elements of the hyper-cube |
HyperCube< subdim > | |
SubHyperCube< dim, subdim > | This represent a sub-hyper-cube of an hyper-cube like a face or an edge of a cube |
i_box_id< dim > | It store a box, its unique id and the sub-domain from where it come from |
i_lbox_grid< dim > | Local Internal ghost box |
i_lbox_id< dim > | It store an internal ghost box, the linked external ghost box and the sub-domain from where it come from as internal ghost box |
ie_ghost< dim, T > | Structure that store and compute the internal and external local ghost box |
CartDecomposition< dim, T, Memory, Distribution > | This class decompose a space into sub-sub-domains and distribute them across processors |
ie_loc_ghost< dim, T > | Structure that store and compute the internal and external local ghost box |
CartDecomposition< dim, T, Memory, Distribution > | This class decompose a space into sub-sub-domains and distribute them across processors |
Vcluster::index_gen< T > | |
Vcluster::index_gen< index_tuple< prp...> > | Process the receive buffer using the specified properties (meta-function) |
index_tuple<> | These set of classes generate an array definition at compile-time |
init_prop< Np, vector > | This class is a functor for "for_each" algorithm |
inte_calc_impl< vector, kernel > | Calculate the interpolation for one point |
inte_template< np, prp_g, prp_v, m2p_or_p2m > | Class that select the operation to do differently if we are doing Mesh to particle (m2p) or particle to mesh (p2m) |
inte_template< np, prp_g, prp_v, inte_m2p > | Class that select the operation to do differently if we are doing Mesh to particle (m2p) or particle to mesh (p2m) |
inter_memc< Seq > | This class convert a boost::mpl::fusion/vector to a boost::mpl::fusion/vector with memory_c interleaved |
interp_ele< Tdst, Grid_dst, Grid_src, nst_pos > | This class is a functor for "for_each" algorithm |
interp_ele_sca_array< copy_type, Tsrc, Tdst, Grid_src, Grid_dst, sa > | Add scalar elements |
interp_ele_sca_array< copy_type, Tsrc, Tdst, Grid_src, Grid_dst, 1 > | Add 1D array elements |
interp_points< dim, v_prp_id, v_prp_type > | This class is a functor for "for_each" algorithm |
interpolate< vector, grid, kernel > | Main class for interpolation Particle to mest p2m and Mesh to particle m2p |
ip_box_grid< dim > | Per-processor Internal ghost box |
is_contiguos< prp > | |
is_csv_writable< T > | Indicate if the property T is writable in CSV |
is_csv_writable< bool > | Indicate if the property T is writable in CSV |
is_csv_writable< char > | Indicate if the property T is writable in CSV |
is_csv_writable< double > | Indicate if the property T is writable in CSV |
is_csv_writable< float > | Indicate if the property T is writable in CSV |
is_csv_writable< int > | Indicate if the property T is writable in CSV |
is_csv_writable< long int > | Indicate if the property T is writable in CSV |
is_csv_writable< short > | Indicate if the property T is writable in CSV |
is_csv_writable< unsigned char > | Indicate if the property T is writable in CSV |
is_csv_writable< unsigned int > | Indicate if the property T is writable in CSV |
is_csv_writable< unsigned long int > | Indicate if the property T is writable in CSV |
is_csv_writable< unsigned short > | Indicate if the property T is writable in CSV |
is_grid_staggered< T, has_gt > | Is_grid_staggered analyse T if it has a property grid_type defined and indicate that the grid is staggered |
is_grid_staggered< T, false > | Is_grid_staggered analyse T if it has a property that define the type of grid |
is_initialized< T > | Initialized |
is_initialized< openfpm::vector< T > > | Initialized |
is_typedef_and_data_same< cond, T > | Check if T::type and T.data has the same type |
is_typedef_and_data_same< false, T > | |
is_vtk_writable< T > | Check for T to be writable |
is_vtk_writable< bool > | Check bool |
is_vtk_writable< char > | Check char |
is_vtk_writable< double > | Check double |
is_vtk_writable< float > | Check float |
is_vtk_writable< int > | Check int |
is_vtk_writable< long int > | Check long int |
is_vtk_writable< short > | Check short |
is_vtk_writable< unsigned char > | Check unsigned char |
is_vtk_writable< unsigned int > | Check unsigned int |
is_vtk_writable< unsigned long int > | Check unsigned long int |
is_vtk_writable< unsigned short > | Check unsigned short |
Iterator_g_const | |
petsc_solver< double >::itError | Contain the infinity norm of the residual at each iteration |
key< T > | This class is a trick to indicate the compiler a specific specialization pattern |
FDScheme< Sys_eqs >::key_and_eq | Equation id + space position |
KillParticle | Out of bound policy it detect out of bound particles and decide what to do |
KillParticleWithWarning | Out-of-bound policy kill the particle but print a warning |
Lap< arg, Sys_eqs, impl > | Laplacian second order on h (spacing) |
Lap< arg, Sys_eqs, CENTRAL > | Laplacian second order approximation CENTRAL Scheme |
Lap< arg, Sys_eqs, CENTRAL_SYM > | Laplacian second order approximation CENTRAL Scheme (with central derivative in the single) |
Lap_PSE< dim, T, ord, impl > | Implementation of the Laplacian kernels for PSE |
Lap_PSE< 1, T, 2, KER_GAUSSIAN > | |
Lap_PSE< 1, T, 4, KER_GAUSSIAN > | |
Lap_PSE< 1, T, 6, KER_GAUSSIAN > | |
Lap_PSE< 1, T, 8, KER_GAUSSIAN > | |
last_variadic< T1, T > | |
last_variadic< T1 > | |
lBox_dom< dim, T > | Case for local ghost box |
CartDecomposition< dim, T, Memory, Distribution >::lc_processor_id | Class to select the returned id by ghost_processorID |
lid | |
lid_nn | [Definition of the system] |
lid_nn_3d_eigen | Specify the general caratteristic of system to solve |
lid_nn_3d_petsc | |
ln_force | |
ln_potential | |
MatLabWriter< dim, T > | This class is able to save grid into tiff files |
Matrix< dim, T > | This class implement an NxN (dense) matrix |
max_prop_nn< T, has_max_prop > | |
max_prop_nn< T, false > | |
Mem_bal< local_index > | Class for BALANCED cell list implementation |
Mem_fast< local_index > | It is a class that work like a vector of vector |
Mem_fast<> | |
CellList< dim, T, Mem_fast<>, shift< dim, T > > | |
CellList< vector::dims, typename vector::stype, Mem_fast<>, shift< vector::dims, typename vector::stype > > | |
mem_get< p, layout, data_type, g1_type, key_type, sel > | Case memory_traits_lin |
mem_get< p, layout, data_type, g1_type, key_type, 1 > | Case memory_traits_inte |
mem_geto< dim, T, layout, data_type, g1_type, key_type, sel > | Case memory_traits_lin |
mem_geto< dim, T, layout, data_type, g1_type, key_type, 1 > | Case memory_traits_inte |
Mem_mw< local_index > | Class for MEMORY-WISE cell list implementation |
mem_reference< T > | Metafunction take T and return a reference |
mem_setext< grid_type, S, layout, data_type, sel > | Case memory_traits_lin |
mem_setext< grid_type, S, layout, data_type, 1 > | Case memory_traits_inte |
mem_setm< S, layout, data_type, g1_type, sel > | Case memory_traits_lin |
mem_setm< S, layout, data_type, g1_type, 1 > | Case memory_traits_inte |
mem_swap< T, layout, data_type, grid_type, sel > | Case memory_traits_lin |
mem_swap< T, layout, data_type, grid_type, 1 > | Case memory_traits_inte |
Mem_type | |
CellList< dim, T, Mem_type, transform, base > | Class for FAST cell list implementation |
VerletList< dim, T, Mem_type, transform, CellListImpl > | Class for Verlet list implementation |
memory | |
ExtPreAlloc< Mem > | |
HeapMemory | This class allocate, and destroy CPU memory |
BHeapMemory | It is like HeapMemory but buffered |
PtrMemory | This class give memory from a preallocated memory, memory destruction is not performed |
memory_array< T > | This class give a representation to a chunk or memory |
memory_c< T, D > | This class is a container for the memory interface like HeapMemory CudaMemory |
memory_c< multi_array< T >, D > | Specialization of memory_c for multi_array |
memory_thrust_c< T > | This class is a container for the memory interface |
memory_traits_inte< T > | Transform the boost::fusion::vector into memory specification (memory_traits) |
memory_traits_lin< T > | Transform the boost::fusion::vector into memory specification (memory_traits) |
memory_traits_lin_type< T, is_agg > | Small meta-function to get the type of the memory |
memory_traits_lin_type< T, false > | Small meta-function to get the type of the memory |
merge_< Tdst, Tsrc > | This structure define the operation add to use with copy general |
MetisDistribution< dim, T >::met_sub_w | Sub-domain list and weight |
meta_compare< T > | This class compare general objects |
meta_compare< T[N1]> | Partial specialization for N=1 1D-Array |
meta_compare< T[N1][N2]> | Partial specialization for N=2 2D-Array |
meta_compare< T[N1][N2][N3]> | Partial specialization for N=3 |
meta_copy< T > | This class copy general objects |
meta_copy< T[N1]> | Partial specialization for N=1 1D-Array |
meta_copy< T[N1][N2]> | Partial specialization for N=2 2D-Array |
meta_copy< T[N1][N2][N3]> | Partial specialization for N=3 |
meta_copy< T[N1][N2][N3][N4]> | Partial specialization for N=4 |
meta_copy< T[N1][N2][N3][N4][N5]> | Partial specialization for N=5 |
meta_copy< T[N1][N2][N3][N4][N5][N6]> | Partial specialization for N=6 |
meta_copy< T[N1][N2][N3][N4][N5][N6][N7]> | Partial specialization for N=7 |
meta_copy< T[N1][N2][N3][N4][N5][N6][N7][N8]> | Partial specialization for N=8 |
meta_copy< T[N1][N2][N3][N4][N5][N6][N7][N8][N9]> | Partial specialization for N=9 |
meta_copy< T[N1][N2][N3][N4][N5][N6][N7][N8][N9][N10]> | Partial specialization for N=10 |
meta_copy_d< Tsrc, Tdst > | Copy for a source object to a destination |
meta_copy_d< Tsrc, Tdst[N1]> | Partial specialization for N=1 1D-Array |
meta_copy_d< Tsrc, Tdst[N1][N2]> | Partial specialization for N=2 2D-Array |
meta_copy_d< Tsrc[N1], Tdst > | Partial specialization for N=1 1D-Array |
meta_copy_d< Tsrc[N1], Tdst[N1]> | Partial specialization for N=1 1D-Array |
meta_copy_d< Tsrc[N1][N2], Tdst > | Partial specialization for N=2 2D-Array |
meta_copy_d< Tsrc[N1][N2], Tdst[N1][N2]> | Partial specialization for N=1 1D-Array |
meta_copy_op< op, T > | This class copy general objects applying an operation |
meta_copy_op< op, T[N1]> | Partial specialization for N=1 1D-Array |
meta_copy_op< op, T[N1][N2]> | Partial specialization for N=2 2D-Array |
meta_copy_op< op, T[N1][N2][N3]> | Partial specialization for N=3 |
meta_copy_op_d< op, Tsrc, Tdst > | |
meta_copy_op_d< op, Tsrc, Tdst[N1]> | Partial specialization for N=1 1D-Array |
meta_copy_op_d< op, Tsrc[N1], Tdst > | Partial specialization for N=1 1D-Array |
meta_copy_op_d< op, Tsrc[N1], Tdst[N1]> | Partial specialization for N=1 1D-Array |
meta_prop< I, ele_g, St, T, is_writable > | This class is an helper to create properties output from scalar and compile-time array elements |
meta_prop< I, ele_g, St, T, false > | Specialication when is not writable |
meta_prop< I, ele_g, St, T[N1], is_writable > | Partial specialization for N=1 1D-Array |
meta_prop< I, ele_g, St, T[N1][N2], is_writable > | Partial specialization for N=2 2D-Array |
meta_raw_read< dim, Tg, Tr, i > | This is the scalar case |
meta_raw_read< dim, Tg, Tr[nv], i > | This is the vector case |
MetaFunc< index, N > | [Metafunction definition] |
MetaFuncOrd< index, N > | |
Vcluster::MetaFuncOrd< index, N > | Metafunction |
Metis< Graph > | Helper class to define Metis graph |
Metis< Graph_CSR< nm_v, nm_e > > | |
Metis_graph | Metis graph structure |
MetisDistribution< dim, T > | Class that distribute sub-sub-domains across processors using Metis Library |
minus< arg, Sys_eqs > | It ancapsulate the minus operation |
ModelCustom | Model for Dynamic load balancing |
ModelCustom2 | Second model for dynamic load balancing |
ModelLin | Linear model |
ModelSquare | Linear model |
mp4_kernel< st > | |
z_kernel< st, 2 > | |
MPI_IAllGatherW< T > | General recv for vector of |
MPI_IAllGatherW< char > | Specialization for vector of char |
MPI_IAllGatherW< double > | Specialization for vector of double |
MPI_IAllGatherW< float > | Specialization for vector of float |
MPI_IAllGatherW< int > | Specialization for vector of integer |
MPI_IAllGatherW< long int > | Specialization for vector of long int |
MPI_IAllGatherW< short > | Specialization for vector of short |
MPI_IAllGatherW< size_t > | Specialization for vector of size_t |
MPI_IAllGatherW< unsigned char > | Specialization for vector of unsigned char |
MPI_IAllGatherW< unsigned int > | Specialization for vector of unsigned integer |
MPI_IAllGatherW< unsigned short > | Specialization for vector of short |
MPI_IAllGatherWB | Set of wrapping classing for MPI_Irecv |
MPI_IallreduceW< T > | Set of wrapping classing for MPI_Iallreduce |
MPI_IallreduceW< char > | Specialization for char |
MPI_IallreduceW< double > | Specialization for double |
MPI_IallreduceW< float > | Specialization for float |
MPI_IallreduceW< int > | Specialization for integer |
MPI_IallreduceW< long int > | Specialization for size_t |
MPI_IallreduceW< short > | Specialization for short |
MPI_IallreduceW< size_t > | Specialization for size_t |
MPI_IallreduceW< unsigned char > | Specialization for char |
MPI_IallreduceW< unsigned int > | Specialization for unsigned integer |
MPI_IallreduceW< unsigned short > | Specialization for short |
MPI_IBcastW< T > | General recv for vector of |
MPI_IBcastW< char > | Specialization for char |
MPI_IBcastW< double > | Specialization for double |
MPI_IBcastW< float > | Specialization for float |
MPI_IBcastW< int > | Specialization for vector of integer |
MPI_IBcastW< long int > | Specialization for size_t |
MPI_IBcastW< short > | Specialization for short |
MPI_IBcastW< size_t > | Specialization for size_t |
MPI_IBcastW< unsigned char > | Specialization for char |
MPI_IBcastW< unsigned int > | Specialization for unsigned integer |
MPI_IBcastW< unsigned short > | Specialization for short |
MPI_IBcastWB | Set of wrapping classing for MPI_Irecv |
MPI_IrecvW< T > | General recv for vector of |
MPI_IrecvW< char > | Specialization for char |
MPI_IrecvW< double > | Specialization for double |
MPI_IrecvW< float > | Specialization for float |
MPI_IrecvW< int > | Specialization for vector of integer |
MPI_IrecvW< long int > | Specialization for size_t |
MPI_IrecvW< short > | Specialization for short |
MPI_IrecvW< size_t > | Specialization for size_t |
MPI_IrecvW< unsigned char > | Specialization for char |
MPI_IrecvW< unsigned int > | Specialization for unsigned integer |
MPI_IrecvW< unsigned short > | Specialization for short |
MPI_IrecvWB | Set of wrapping classing for MPI_Irecv |
MPI_IsendW< T, Mem, gr > | General send for a vector of any type |
MPI_IsendW< char, Mem, gr > | Specialization for char |
MPI_IsendW< double, Mem, gr > | Specialization for double |
MPI_IsendW< float, Mem, gr > | Specialization for float |
MPI_IsendW< int, Mem, gr > | Specialization for vector of integer |
MPI_IsendW< long int, Mem, gr > | Specialization for size_t |
MPI_IsendW< short, Mem, gr > | Specialization for short |
MPI_IsendW< size_t, Mem, gr > | Specialization for size_t |
MPI_IsendW< unsigned char, Mem, gr > | Specialization for char |
MPI_IsendW< unsigned int, Mem, gr > | Specialization for unsigned integer |
MPI_IsendW< unsigned short, Mem, gr > | Specialization for short |
MPI_IsendWB | Set of wrapping classing for MPI_Isend |
mul< expr > | It model an expression expr1 * expr2 |
mul_inte< T > | Multiply the src by coeff for several types T |
mul_inte< T[N1]> | Multiply the src by coeff for several types T |
mul_inte< T[N1][N2]> | Multiply the src by coeff for several types T |
mult< T, N > | This class multiply all the elements in a boost::mpl::vector excluding the first element |
mult< T, 1 > | |
multi_array< T > | This class is a trick to indicate the compiler a specific specialization pattern |
my_struct | |
N_box< dim, T > | |
ne_cp | |
nm_e | Sub-domain edge graph node |
nm_part_e | Reduced edge graph node |
nm_part_v | Reduced sub-domain vertex graph node |
nm_v | |
nn_prcs< dim, T > | This class store the adjacent processors and the adjacent sub_domains |
CartDecomposition< dim, T, Memory, Distribution > | This class decompose a space into sub-sub-domains and distribute them across processors |
NNc_array< dim, size, thr > | |
NNc_array< dim, NNc_size > | |
NNc_array< dim, openfpm::math::pow(3, dim)/2+1 > | |
NNc_array< dim, size, false > | |
NNc_array< dim,(unsigned int) openfpm::math::pow(3, dim)/2+1 > | |
NNc_array< dim,(unsigned int) openfpm::math::pow(3, dim)> | |
NNType< dim, T, CellListImpl, PartIt, type, local_index > | Get the neighborhood iterator based on type |
NNType< dim, T, CellListImpl, PartIt, VL_CRS_SYMMETRIC, local_index > | Get the neighborhood iterator based on type |
NNType< dim, T, CellListImpl, PartIt, VL_SYMMETRIC, local_index > | Get the neighborhood iterator based on type |
NNType< dim, T, CellListImpl, PartIt, WITH_RADIUS, local_index > | Get the neighborhood iterator based on type |
NNTypeM< dim, T, CellListImpl, PartIt, type > | Get the neighborhood iterator based on type |
NNTypeM< dim, T, CellListImpl, PartIt, VL_CRS_SYMMETRIC > | Get the neighborhood iterator based on type |
NNTypeM< dim, T, CellListImpl, PartIt, VL_SYMMETRIC > | Get the neighborhood iterator based on type |
no_edge | Class with no edge |
no_field | Stub field |
no_stencil | No stencil |
no_transform< dim, T > | No transformation |
NoCheck | Class to check if the edge can be created or not |
node_cp | |
noPointers_sequence< v, prp > | It return a boost::mpl::vector of integers where each integer identify one object without the method "noPointers" |
noPointers_sequence_impl< v, p1, prp > | Implementation of noPointer_sequence_impl |
noPointers_sequence_impl< v, p1 > | Implementation of noPointer_sequence_impl |
not_on_test | Not on testing mode |
Nothing | Out-of-bound policy do nothing |
number_prop< T, np > | |
number_prop< T, 0 > | Return the number of properties the type T has |
object< v > | This is a container to create a general object |
object_creator< v, prp > | It create a boost::fusion vector with the selected properties |
object_creator< v > | Specialization when no properties are passed |
object_creator_impl< v, vc, prp > | Implementation of object creator |
object_creator_impl< v, vc, p1, prp...> | Implementation of object creator |
object_creator_impl< v, vc, prp > | Implementation of object creator |
object_s_di< v_src, v_dst, type_copy, prp > | It copy the properties from one object to another |
object_s_di< v_src, v_dst, OBJ_ENCAP, prp...> | It copy the properties from one object to another |
object_s_di< v_src, v_dst, OBJ_NORMAL, prp...> | Given a set of properties for the destination (0,1,3,5) it copy the source properties (0,1,2,3) |
object_s_di_e< v_src, v_dst, prp > | This class is a functor for "for_each" algorithm |
object_s_di_e_op< op, v_src, v_dst, prp > | This class is a functor for "for_each" algorithm |
object_s_di_f< v_src, v_dst, prp > | This class is a functor for "for_each" algorithm |
object_s_di_f_op< op, v_src, v_dst, prp > | This class is a functor for "for_each" algorithm |
object_s_di_op< op, v_src, v_dst, type_copy, prp > | It copy the properties from one object to another applying an operation |
object_s_di_op< op, v_src, v_dst, OBJ_ENCAP, prp...> | It copy the properties from one object to another applying an operation |
object_s_di_op< op, v_src, v_dst, OBJ_NORMAL, prp...> | Given a set of properties for the destination (0,1,3,5) it copy the source properties (0,1,2,3) applying an operation |
object_si_d< v_src, v_dst, type_copy, prp > | It copy the properties from one object to another |
object_si_d< v_src, v_dst, OBJ_ENCAP > | |
object_si_d< v_src, v_dst, OBJ_ENCAP, prp...> | It copy the properties from one object to another |
object_si_d< v_src, v_dst, OBJ_NORMAL, prp...> | It copy the properties from one object to another |
object_si_d_e< v_src, v_dst, prp > | This class is a functor for "for_each" algorithm |
object_si_d_f< v_src, v_dst, prp > | This class is a functor for "for_each" algorithm |
on_test | [Constant fields struct definition] |
op_ssend_gg_recv_merge | Helper class to merge data |
op_ssend_gg_recv_merge_impl< sr > | Helper class to merge data without serialization |
op_ssend_gg_recv_merge_impl< true > | Helper class to merge data with serialization |
op_ssend_recv_add< op > | Helper class to add data |
op_ssend_recv_add_sr< sr > | Helper class to add data without serialization |
op_ssend_recv_add_sr< true > | Helper class to add data with serialization |
op_ssend_recv_merge< op > | Helper class to merge data |
op_ssend_recv_merge_impl< sr, op > | Helper class to merge data without serialization |
op_ssend_recv_merge_impl< true, op > | Helper class to merge data with serialization |
memory_c< multi_array< T >, D >::ordering< index, N > | In combination with generate_array is used to produce array at compile-time |
p_box< dim, T > | It store all the boxes of the near processors in a linear array |
openfpm::vector< T, HeapMemory, typename memory_traits_lin< T >::type, memory_traits_lin, grow_policy_double, STD_VECTOR >::pack_cond< cond, T1, Memory1, prp > | Structures that do a nested packing, depending on the existence of 'pack' function inside of the object |
openfpm::vector< T, Memory, layout, layout_base, grow_p, OPENFPM_NATIVE >::pack_cond< cond, T1, Memory1, prp > | Structures that do a nested packing, depending on the existence of 'pack()' function inside the object |
vector< T, HeapMemory, typename memory_traits_lin< T >::type, memory_traits_lin, grow_policy_double, STD_VECTOR >::pack_cond< cond, T1, Memory1, prp > | Structures that do a nested packing, depending on the existence of 'pack' function inside of the object |
openfpm::vector< T, HeapMemory, typename memory_traits_lin< T >::type, memory_traits_lin, grow_policy_double, STD_VECTOR >::pack_cond< true, T1, Memory1, prp...> | Structures that do a nested packing, depending on the existence of 'pack' function inside of the object |
openfpm::vector< T, Memory, layout, layout_base, grow_p, OPENFPM_NATIVE >::pack_cond< true, T1, Memory1, prp...> | Structures that do a nested packing, depending on the existence of 'pack()' function inside the object |
vector< T, HeapMemory, typename memory_traits_lin< T >::type, memory_traits_lin, grow_policy_double, STD_VECTOR >::pack_cond< true, T1, Memory1, prp...> | Structures that do a nested packing, depending on the existence of 'pack' function inside of the object |
Pack_selector< T > | Pack selector |
Pack_selector_impl< T, is_foundamental > | It is not a fundamental type |
Pack_selector_impl< T, true > | Select the primitive packing |
Pack_selector_known_type_impl< T, known_type > | Pack selector for unknown type |
Pack_selector_known_type_impl< T, HAS_PACKER > | |
Pack_selector_known_type_impl< T, IS_ENCAP > | |
Pack_selector_known_type_impl< T, IS_GRID > | |
Pack_selector_unknown_type_impl< T, has_noPointers > | Pack selector for unknown type |
Pack_selector_unknown_type_impl< T, false > | |
openfpm::vector< T, Memory, layout, layout_base, grow_p, OPENFPM_NATIVE >::pack_simple_cond< sel, prp > | These structures serialize a simple (no "pack()" inside) object |
grid_base_impl< dim, T, S, layout_, layout_base >::pack_simple_cond< sel, prp > | |
openfpm::vector< T, Memory, layout, layout_base, grow_p, OPENFPM_NATIVE >::pack_simple_cond< true, prp...> | These structures serialize a simple (no "pack()" inside) object |
grid_base_impl< dim, T, S, layout_, layout_base >::pack_simple_cond< true, prp...> | |
Pack_stat | Packing status object |
pack_unpack_cond_with_prp< cond, op, T, S, layout_base, prp > | There is max_prop inside |
pack_with_iterator< is_complex, dim, grid, encap_src, encap_dst, boost_vct, it, dtype, prp > | Pack an N-dimensional grid into a vector like structure B given an iterator of the grid |
pack_with_iterator< false, dim, grid, encap_src, encap_dst, boost_vct, it, dtype, prp...> | Pack an N-dimensional grid into a vector like structure B given an iterator of the grid |
pack_with_iterator< true, 1, grid, encap_src, encap_dst, boost_vct, it, dtype, prp...> | Pack an N-dimensional grid into a vector like structure B given an iterator of the grid |
pack_with_iterator< true, 2, grid, encap_src, encap_dst, boost_vct, it, dtype, prp...> | Pack an N-dimensional grid into a vector like structure B given an iterator of the grid |
pack_with_iterator< true, 3, grid, encap_src, encap_dst, boost_vct, it, dtype, prp...> | Pack an N-dimensional grid into a vector like structure B given an iterator of the grid |
pack_with_iterator_longx< dim, obj_byte, git, grid > | |
pack_with_iterator_longx< 2, obj_byte, git, grid > | |
pack_with_iterator_longx< 3, obj_byte, git, grid > | |
pack_with_iterator_shortx< dim, n_cpy, obj_byte, git, grid > | |
pack_with_iterator_shortx< 2, n_cpy, obj_byte, git, grid > | |
pack_with_iterator_shortx< 3, n_cpy, obj_byte, git, grid > | |
Packer< T, Mem, pack_type > | Packing class |
Packer< T, Mem, PACKER_ARRAY_PRIMITIVE > | Packer for primitives |
Packer< T, Mem, PACKER_ENCAP_OBJECTS > | |
Packer< T, Mem, PACKER_GENERAL > | Packer class for vectors |
Packer< T, Mem, PACKER_GRID > | Packer for grids and sub-grids |
Packer< T, Mem, PACKER_OBJECTS_WITH_POINTER_CHECK > | Packer class for objects |
Packer< T, Mem, PACKER_OBJECTS_WITH_WARNING_POINTERS > | Packer for objects, with impossibility to check for internal pointers |
Packer< T, Mem, PACKER_PRIMITIVE > | Packer for primitives |
openfpm::vector< T, HeapMemory, typename memory_traits_lin< T >::type, memory_traits_lin, grow_policy_double, STD_VECTOR >::packMem_cond< cond, T1, prp > | Structures that calculate memory for an object, depending on the existence of 'packMem' function inside the object |
openfpm::vector< T, Memory, layout, layout_base, grow_p, OPENFPM_NATIVE >::packMem_cond< cond, T1 > | Structures that calculate how many bytes are required to serialize an object |
vector< T, HeapMemory, typename memory_traits_lin< T >::type, memory_traits_lin, grow_policy_double, STD_VECTOR >::packMem_cond< cond, T1, prp > | Structures that calculate memory for an object, depending on the existence of 'packMem' function inside the object |
openfpm::vector< T, Memory, layout, layout_base, grow_p, OPENFPM_NATIVE >::packMem_cond< true, T1 > | Structures that calculate memory for an object, depending on the existence of 'packMem()' |
openfpm::vector< T, HeapMemory, typename memory_traits_lin< T >::type, memory_traits_lin, grow_policy_double, STD_VECTOR >::packMem_cond< true, T1, prp...> | Structures that calculate memory for an object, depending on the existence of 'packMem' function inside the object |
vector< T, HeapMemory, typename memory_traits_lin< T >::type, memory_traits_lin, grow_policy_double, STD_VECTOR >::packMem_cond< true, T1, prp...> | Structures that calculate memory for an object, depending on the existence of 'packMem' function inside the object |
openfpm::vector< T, HeapMemory, typename memory_traits_lin< T >::type, memory_traits_lin, grow_policy_double, STD_VECTOR >::packRequest_cond< cond, T1, prp > | Structures that do a pack request, depending on the existence of 'packRequest' function inside of the object |
vector< T, HeapMemory, typename memory_traits_lin< T >::type, memory_traits_lin, grow_policy_double, STD_VECTOR >::packRequest_cond< cond, T1, prp > | Structures that do a pack request, depending on the existence of 'packRequest' function inside of the object |
vector< T, HeapMemory, typename memory_traits_lin< T >::type, memory_traits_lin, grow_policy_double, STD_VECTOR >::packRequest_cond< true, T1, prp...> | Structures that do a pack request, depending on the existence of 'packRequest' function inside of the object |
openfpm::vector< T, HeapMemory, typename memory_traits_lin< T >::type, memory_traits_lin, grow_policy_double, STD_VECTOR >::packRequest_cond< true, T1, prp...> | Structures that do a pack request, depending on the existence of 'packRequest' function inside of the object |
Parmetis< Graph > | Helper class to define Metis graph |
Parmetis< Graph_CSR< nm_v, nm_e > > | |
Parmetis_dist_graph | Metis graph structure |
Parmetis_graph | Metis graph structure |
ParMetisDistribution< dim, T > | Class that distribute sub-sub-domains across processors using ParMetis Library |
ParticleIt_CellP< T > | |
ParticleIt_Cells< dim, CellListType > | This iterator iterate across the particles of a Cell-list following the Cell structure |
ParticleItCRS_Cells< dim, CellListType > | This iterator iterate across the particles of a Cell-list following the Cell structure |
PartItNN< type, dim, vector, CellList > | In general different NN scheme like full symmetric or CRS require different iterators over particles this class select the proper one |
PartItNN< VL_CRS_SYMMETRIC, dim, vector, CellList > | In general different NN scheme like full symmetric or CRS require different iterators over particles this class select the proper one |
periodicity< dim > | |
petsc_AMG_report | Class to test AMG solvers |
petsc_solver< T > | In case T does not match the PETSC precision compilation create a stub structure |
petsc_solver< double > | This class is able to do Matrix inversion in parallel with PETSC solvers |
Point< dim, T > | This class implement the point shape in an N-dimensional space |
Point2D_test< T > | Test structure used for several test |
Point< dim, long int > | |
Point< Grid::dims, St > | |
point_expression< T > | Main class that encapsulate a constant number used in a point expression |
point_expression< const T[dim]> | Specialization for a const array of dimension dim |
point_expression< T[dim]> | Specialization for an array of dimension dim as expression |
point_expression_op< orig, exp1, exp2, op > | Unknown operation specialization |
point_expression_op< orig, exp1, exp2, POINT_DIV > | Division operation |
point_expression_op< orig, exp1, exp2, POINT_MUL > | Multiplication operation |
point_expression_op< orig, exp1, exp2, POINT_MUL_POINT > | Multiplication operation |
point_expression_op< orig, exp1, exp2, POINT_NORM > | Point norm operation |
point_expression_op< orig, exp1, exp2, POINT_NORM2 > | Point square norm operation |
point_expression_op< orig, exp1, exp2, POINT_SUB > | Subtraction operation |
point_expression_op< orig, exp1, exp2, POINT_SUB_UNI > | Expression that subtract two points |
point_expression_op< orig, exp1, exp2, POINT_SUM > | Sum operation |
Point_orig< T > | Definition of a class Point in plain C++ and boost::vector for testing purpose |
Point_test< T > | Test structure used for several test |
Point_test_prp< T > | Test structure used for several test |
Point_test_scal< T > | Point test with only scalar properties |
poisson_nn_helm | |
pos_or_propL< vector, prp > | Selector for position or properties left side expression |
pos_or_propL< vector, PROP_POS > | Selector for position or properties left side |
pos_or_propR< vector, prp > | Selector for position or properties right side position |
pos_or_propR< vector, PROP_POS > | Selector for position or properties right side |
pos_v< dim, T > | Structure that contain a reference to a vector of particles |
pos_val< dim, T > | |
post_increment_sub_impl< dim, stl_type > | |
print_warning_on_adjustment< dim > | Declaration print_warning_on_adjustment |
vector_dist_comm< dim, St, prop, layout, layout_base, Decomposition, Memory >::proc_with_prp< prp_object, prp > | Process the particle with properties |
vector_dist_comm< dim, St, prop, layout, layout_base, Decomposition, Memory >::proc_without_prp | Process the particle without properties |
Process_keys_grid< dim, CellList > | Class for an hilbert order processing of cell keys for CellList_gen implementation |
Process_keys_hilb< dim, CellList > | Class for an hilbert order processing of cell keys for CellList_gen implementation |
Process_keys_lin< dim, CellList > | |
CartDecomposition< dim, T, Memory, Distribution >::processor_id | Class to select the returned id by ghost_processorID |
prop_out_edge< Graph > | This class is a functor for "for_each" algorithm |
prop_out_g< ele_g, St > | This class is a functor for "for_each" algorithm |
prop_out_v< ele_v, St > | This class is a functor for "for_each" algorithm |
prop_out_vertex< Graph > | This class is a functor for "for_each" algorithm |
prop_output< has_attributes, Graph, i > | This class specialize functions in the case the type T has or not defined attributes |
prop_output< false, Graph, i > | This class specialize functions in the case the type T has not defined attributes |
prop_output_array_scalar_selector_edge< is_array > | Property writer for scalar and vector |
prop_output_array_scalar_selector_edge< true > | Property writer for vector |
prop_output_array_scalar_selector_edge_fill_vertex< is_array > | Property writer for scalar and vector, it fill the vertex data (needed for edge representation in vtk) |
prop_output_array_scalar_selector_edge_fill_vertex< true > | Property writer for vector |
prop_output_array_scalar_selector_vertex< is_array > | Property writer for scalar and vector |
prop_output_array_scalar_selector_vertex< true > | Property writer for vector |
prop_write_out< dim, T > | Write the vectror property |
prop_write_out< 1, T > | Write the scalar property |
propCheckINF< vector > | This class is a functor for "for_each" algorithm |
propCheckNAN< vector > | This class is a functor for "for_each" algorithm |
prp_all_zero< T, is_zero, prp > | Structure to convert a variadic template into boost::mpl::vector |
prp_all_zero< T, true, prp... > | |
PSEError | |
ptr_info | |
push_back_op< is_t, is_s, T, S > | |
push_back_op< false, false, T, S > | |
push_back_op< false, true, T, S > | |
push_back_op< true, true, T, S > | |
push_back_op_neste< bool, T, S > | Pack/add function selector |
push_back_op_neste< true, T, S > | Pack/add function selector |
push_back_std_op_neste< bool, T, S > | Pack/add function selector |
push_back_std_op_neste< true, T, S > | |
PV_cl | |
r_type_dim< op1_dim, op2_dim, op > | It return the dimansionality of the operation given the dimensionality of the 2 operators |
r_type_dim< 1, 1, POINT_DIV > | Scalar / scalar = scalar |
r_type_dim< 1, 1, POINT_MUL > | Scalar * scalar = scalar |
r_type_dim< 1, 1, POINT_SUB > | Scalar - scalar = scalar |
r_type_dim< 1, 1, POINT_SUM > | Scalar + scalar = scalar |
r_type_dim< op1_dim, op2_dim, POINT_MUL_POINT > | Point * Point = scalar |
r_type_p< r, orig > | Return type of the expression |
r_type_p< 1, orig > | Return type of the expression |
raw_read< dim, Tg > | This class is a functor for "for_each" algorithm |
red | Temporal buffer for reductions |
reduce_type< T > | In general a reduction of a type T produce a type T |
reduce_type< double[]> | A reduction operation on an array of double is a double |
reduce_type< float[]> | A reduction operation on an array of float is a float |
reduce_type< int[]> | A reduction operation on an array of int is an int |
remove_attributes_const_ref< T > | T_to_memory_c is a metafunction that given T it convert it into |
replace_< Tdst, Tsrc > | This structure define the operation add to use with copy general |
RGB | RGB color struct |
rid | |
rval< T, impl > | It store one row value of a vector |
rval< T, EIGEN_RVAL > | It store one row value of a vector |
rval< T, PETSC_RVAL > | It store one row value of a vector |
se_class3_vector< Np, dim, T, Decomposition, vector > | This class check for inconsistency access |
DistGraph_CSR< V, E, Memory, layout_v, layout_e, layout_v_base, layout_e_base, grow_p >::SendGraphPack | Struct containing the (sub)graph to send |
seq_traits_impl< Seq > | Implementation of seq_traits |
set_zero< rtype > | Meta-function to return a compatible zero-element |
set_zero< Point< dim, T > > | Create a point with all compunent set to zero |
shift< dim, T > | |
CartDecomposition< dim, T, Memory, Distribution >::shift_id | Class to select the returned id by ghost_processorID |
shift_vect_converter< dim, T > | In case of high dimensions shift vector converter |
SimpleRNG | SimpleRNG is a simple random number generator based on George Marsaglia's MWC (multiply with carry) generator. Although it is very simple, it passes Marsaglia's DIEHARD series of random number generator tests |
solError | It contain statistic of the error of the calculated solution |
petsc_solver< double >::solv_bench_info | It contain the benchmark information for each solver |
space_key_dx< dim, T > | Grid_key_dx is the key to access any element in the grid |
SpaceDistribution< dim, T > | Class that distribute sub-sub-domains across processors using an hilbert curve to divide the space |
SparseMatrix< T, id_t, DEFAULT_MATRIX > | Sparse Matrix implementation |
SparseMatrix< T, id_t, EIGEN_BASE > | |
SparseMatrix< T, id_t, PETSC_BASE > | Sparse Matrix implementation, that map over Eigen |
Sphere< dim, T > | This class implement the Sphere concept in an N-dimensional space |
stag_create_and_add_grid< dim, st_grid, St > | It create separated grid for each properties to write them into a file |
stag_set_position< dim, v, has_pM > | This class is a functor for "for_each" algorithm |
stag_set_position< dim, v, false > | This class is a functor for "for_each" algorithm |
stencil_offset_compute< dim, Np > | Structure for stencil iterator |
stub_or_real< T, dims, stype, decomposition, stub > | In case of testing return a stub grid |
stub_or_real< last, last::dims, typename last::stype, typename last::b_grid::decomposition::extended_type > | |
stub_or_real< T, dims, stype, decomposition, false > | Case when we are not on testing |
grid_dist_iterator_sub< dim, device_grid >::sub_set | |
subsub< dim > | Sub-sub-domain |
subsub_lin< dim > | Linearized version of subsub |
sum< expr > | It model an expression expr1 + ... exprn |
sum_functor_value< v_expr > | Sum functor value |
sys_nn | |
sys_pp | |
syss_nn | |
syss_pp | |
System< dim, nvf, ncf, eqs > | System of equations |
t_to_memory_c< T > | Meta-function t_to_memory_c |
t_to_memory_c_impl< T > | Partial specialization for scalar N=0 |
t_to_memory_c_impl< T[N1]> | Partial specialization for N=1 |
t_to_memory_c_impl< T[N1][N2]> | Partial specialization for N=2 |
t_to_memory_c_impl< T[N1][N2][N3]> | Partial specialization for N=3 |
t_to_memory_c_impl< T[N1][N2][N3][N4]> | Partial specialization for N=4 |
t_to_memory_c_impl< T[N1][N2][N3][N4][N5]> | Partial specialization for N=5 |
t_to_memory_c_impl< T[N1][N2][N3][N4][N5][N6]> | Partial specialization for N=6 |
t_to_memory_c_impl< T[N1][N2][N3][N4][N5][N6][N7]> | Partial specialization for N=7 |
t_to_memory_c_impl< T[N1][N2][N3][N4][N5][N6][N7][N8]> | Partial specialization for N=8 |
t_to_memory_c_impl< T[N1][N2][N3][N4][N5][N6][N7][N8][N9]> | Partial specialization for N=9 |
t_to_memory_c_impl< T[N1][N2][N3][N4][N5][N6][N7][N8][N9][N10]> | Partial specialization for N=10 |
tensor< T, s1, s2, s3 > | |
tensor< int, s1, s2, s3 > | |
test_box_vpack | |
test_grid_type_no_def | |
test_grid_type_normal | |
test_grid_type_staggered | [Define structures] |
test_has_attributes | [Check has_posMask struct definition] |
test_has_max_prop | Test type for has_max_prop |
test_has_no_max_prop | Test type for has_max_prop |
test_has_posMask | [Check has_posMask struct definition] |
test_no_attributes | |
test_no_has_posMask | Test type for has_posMask |
TiffWriter< dim, T > | This class is able to save grid into tiff files |
timer | Class for cpu time benchmarking |
Times | Time structure for statistical purposes |
to_boost_vmpl< id > | |
to_boost_vmpl<> | Terminator for to_boost_mpl with last parameter |
to_boost_vmpl_impl< a, id > | Implementation of to_boost_vmpl |
to_boost_vmpl_impl< a > | Terminator for to_boost_mpl with last parameter |
to_int_sequence< N, M > | |
to_variadic_impl< H, c, end, exit > | Recursive specialization of to_variadic |
to_variadic_impl< H, F, L, true > | Terminator of to_variadic |
toPoint< dim, St > | |
triplet< T, impl > | It store the non zero elements of the matrix |
triplet< T, EIGEN_TRIPLET > | It store one non-zero element in the sparse matrix |
triplet< T, PETSC_BASE > | It store one non-zero element in the sparse matrix |
true_type | |
has_attributes< T, typename Void< decltype(T::attributes::name[0])>::type > | Has_attributes check if a type has defined an internal structure with attributes |
has_base_to_copy< T, typename Void< typename T::base_to_copy >::type > | Has_data check if a type has defined a member data |
has_data< T, typename Void< decltype(T::data)>::type > | Has_data check if a type has defined a member data |
has_grid_type< T, typename Void< decltype(T::grid_type)>::type > | Has_grid_type check if T has defined the member grid_type |
has_init< ObjType, typename Void< typename ObjType::has_init >::type > | |
has_max_prop_nn< T, typename Void< decltype(T::max_prop)>::type > | Has_max_prop check if a type has defined a member max_prop |
has_noPointers< T, typename Void< decltype(T::noPointers())>::type > | Has_noPointers check if a type has defined a method called noPointers |
has_pack< ObjType, typename Void< decltype(ObjType::pack())>::type > | |
has_packMem< ObjType, typename Void< decltype(ObjType::packMem())>::type > | Has_PackMem check if a type has packMem() member function |
has_packRequest< ObjType, typename Void< decltype(ObjType::packRequest())>::type > | |
has_posMask< T, typename Void< decltype(T::stag_mask)>::type > | Has_data check if a type has defined a member data |
has_typedef_type< T, typename Void< typename T::type >::type > | Has_typedef_type check if a typedef ... type inside the structure is defined |
has_val_pos< T, typename Void< typename T::with_position >::type > | Has_attributes check if a type has defined an internal structure with attributes |
has_value_type< T, typename Void< typename T::value_type >::type > | Has_value_type check if a type has defined a member value_type |
is_const_field< T, typename Void< typename T::const_field >::type > | Is_constant check if a type define a constant field |
is_custom_vtk_writable< ObjType, typename Void< typename ObjType::is_vtk_writable >::type > | It check if the type is vtk writable |
is_encap< T, typename Void< typename T::yes_i_am_encap >::type > | Is_encap check if the type is an encap type |
is_expression< ObjType, typename Void< typename ObjType::is_expression >::type > | |
is_grid< T, typename Void< typename T::yes_i_am_grid >::type > | Is_grid check if the type is a grid |
is_layout_inte< T, typename Void< typename T::yes_is_inte >::type > | Is_layout_inte |
is_layout_mlin< T, typename Void< typename T::yes_is_tlin >::type > | Is_layout_mlin |
is_openfpm_native< T, true > | |
is_testing< T, typename Void< typename T::testing >::type > | Is_testing check if a struct T has testing member defined |
is_vector< T, typename Void< typename T::yes_i_am_vector >::type > | Is_grid check if the type is a vector |
is_vtk_vector_dims< ObjType, typename Void< decltype(ObjType::dims) >::type > | It check if the type is vtk writable |
type_gpu_prop< p, Mem > | This class is an helper to get the return type of get for each property |
typeCheck< tcheck, foundamental > | Type check in case of unknown type |
typeCheck< tcheck, true > | Type check in case of supported type |
typeCheck< tcheck[N1], foundamental > | Type check in case of supported array type |
typeCheck< tcheck[N1][N2], foundamental > | Type check in case of supported 2D array type |
umfpack_solver< T > | Stub when library compiled without eigen |
umfpack_solver< double > | Stub when library compiled without eigen |
unordered_map | |
wrap_unordered_map< key, val > | Wrapper of the unordered map |
wrap_unordered_map< T, openfpm::vector< long int > > | |
wrap_unordered_map< typename vector::stype, openfpm::vector< long int > > | |
vector< T, HeapMemory, typename memory_traits_lin< T >::type, memory_traits_lin, grow_policy_double, STD_VECTOR >::unpack_cond< cond, T1, Memory1, prp > | Structures that do a nested unpacking, depending on the existence of 'pack' function inside the object |
openfpm::vector< T, HeapMemory, typename memory_traits_lin< T >::type, memory_traits_lin, grow_policy_double, STD_VECTOR >::unpack_cond< cond, T1, Memory1, prp > | Structures that do a nested unpacking, depending on the existence of 'pack' function inside the object |
openfpm::vector< T, HeapMemory, typename memory_traits_lin< T >::type, memory_traits_lin, grow_policy_double, STD_VECTOR >::unpack_cond< true, T1, Memory1, prp...> | Structures that do a nested unpacking, depending on the existence of 'pack' function inside the object |
vector< T, HeapMemory, typename memory_traits_lin< T >::type, memory_traits_lin, grow_policy_double, STD_VECTOR >::unpack_cond< true, T1, Memory1, prp...> | Structures that do a nested unpacking, depending on the existence of 'pack' function inside the object |
unpack_selector_with_prp< result, T, S > | |
unpack_selector_with_prp< true, T, S > | |
openfpm::vector< T, Memory, layout, layout_base, grow_p, OPENFPM_NATIVE >::unpack_simple_cond< sel, prp > | These structures do an de-serialize a simple object (no pack() inside) |
grid_base_impl< dim, T, S, layout_, layout_base >::unpack_simple_cond< sel, prp > | |
grid_base_impl< dim, T, S, layout_, layout_base >::unpack_simple_cond< true, prp...> | |
openfpm::vector< T, Memory, layout, layout_base, grow_p, OPENFPM_NATIVE >::unpack_simple_cond< true, prp...> | |
Unpack_stat | Unpacking status object |
unpack_with_iterator< dim, grid, encap_src, encap_dst, boost_vct, it, stype, prp > | Pack an N-dimensional grid into a vector like structure B given an iterator of the grid |
unpack_with_iterator< 3, grid, encap_src, encap_dst, boost_vct, it, stype, prp...> | Pack an N-dimensional grid into a vector like structure B given an iterator of the grid |
Unpacker< T, Mem, pack_type > | Unpacker class |
Unpacker< T, Mem, PACKER_ARRAY_PRIMITIVE > | |
Unpacker< T, Mem, PACKER_ENCAP_OBJECTS > | Unpacker for encapsulated objects |
Unpacker< T, Mem, PACKER_GENERAL > | Unpacker for vectors |
Unpacker< T, Mem, PACKER_GRID > | Unpacker for grids |
Unpacker< T, Mem, PACKER_OBJECTS_WITH_POINTER_CHECK > | Unpacker class for objects |
Unpacker< T, Mem, PACKER_OBJECTS_WITH_WARNING_POINTERS > | Unpacker for objects with no possibility to check for internal pointers |
Unpacker< T, Mem, PACKER_PRIMITIVE > | Unpacker for primitives |
ut_start | Boost unit test fixation (start procedure to call before testing) |
v_box< vector > | |
v_info | |
V_p< T > | Vertex class that encapsulate an object T |
v_transform< H, L > | |
v_transform_impl< H, F, L, exit, Args > | Recursive specialization of v_transform |
v_transform_impl< H, F, L, true, Args...> | Terminator of to_variadic |
v_transform_two< H, arg0, L > | |
v_transform_two_impl< H, arg0, F, L, exit, Args > | Recursive specialization of v_transform in case of metafunction with 2 argument |
v_transform_two_impl< H, arg0, F, L, true, Args...> | Terminator of to_variadic |
Vcluster_base | This class virtualize the cluster of PC as a set of processes that communicate |
Vcluster | Implementation of VCluster class |
Vcluster_log | Vcluster log |
vect_dist_key_dx | Grid key for a distributed grid |
openfpm::vect_isel< T > | It analyze the type given and it select correctly the implementation for vector |
Vector< T, DEFAULT_VECTOR > | Sparse Matrix implementation stub object when OpenFPM is compiled with no linear algebra support |
openfpm::vector< T, Memory, layout, layout_base, grow_p, impl > | Implementation of 1-D std::vector like structure |
openfpm::vector< agg_arr< openfpm::math::pow(kernel::np, vector::dims)> > | |
openfpm::vector< aggregate< size_t, size_t > > | |
openfpm::vector< aggregate< size_t, size_t, size_t > > | |
openfpm::vector< AMG_time_err_coars > | |
openfpm::vector< BHeapMemory > | |
openfpm::vector< Box< dim, T > > | |
openfpm::vector< Box_dom< dim, T > > | |
openfpm::vector< Box_loc_sub< dim, T > > | |
openfpm::vector< Box_sub< dim, T > > | |
openfpm::vector< Box_sub_k< dim, T > > | |
openfpm::vector< cell_grid< Grid > > | |
std::vector< comb< 0 > > | Stub vector specialization |
openfpm::vector< comb< dim > > | |
openfpm::vector< const Grid * > | |
openfpm::vector< device_grid > | |
openfpm::vector< DistGraph_CSR::EdgeReq > | |
openfpm::vector< DistGraph_CSR::SendGraphPack > | |
openfpm::vector< E > | |
openfpm::vector< E, Memory, layout_e, layout_e_base, grow_p, openfpm::vect_isel< E >::value > | |
openfpm::vector< e_box_id< dim > > | |
openfpm::vector< e_info > | |
openfpm::vector< e_info, Memory, typename layout_e_base< e_info >::type, layout_e_base, grow_p, openfpm::vect_isel< e_info >::value > | |
openfpm::vector< e_lbox_grid< dim > > | |
openfpm::vector< e_lbox_id< dim > > | |
openfpm::vector< e_map, Memory, typename layout_e_base< e_map >::type, layout_e_base, grow_p, openfpm::vect_isel< e_map >::value > | |
openfpm::vector< e_map, Memory, typename memory_traits_lin< e_map >::type, layout_e_base, grow_p, openfpm::vect_isel< e_map >::value > | |
openfpm::vector< ele_g > | |
openfpm::vector< ele_g< typename pair::first, typename pair::second > > | |
openfpm::vector< ele_g_st< typename pair::first, typename pair::second > > | |
openfpm::vector< ele_v > | |
openfpm::vector< ele_vpp< typename pair::second > > | |
openfpm::vector< ele_vps< typename pair::first > > | |
openfpm::vector< ep_box_grid< dim > > | |
openfpm::vector< GBoxes< Decomposition::dims > > | |
openfpm::vector< GBoxes< device_grid::dims > > | |
openfpm::vector< GBoxes< grid_cpu< dim, aggregate< size_t > >::dims > > | |
openfpm::vector< GGraph > | |
openfpm::vector< grid_cpu< dim, aggregate< size_t > > > | |
openfpm::vector< grid_dist_id_iterator_dec_skin::gp_sub > | |
openfpm::vector< grid_key_dx< dim > > | |
openfpm::vector< HeapMemory > | |
openfpm::vector< i_box_id< dim > > | |
openfpm::vector< i_lbox_grid< dim > > | |
openfpm::vector< i_lbox_id< dim > > | |
openfpm::vector< idx_t > | |
openfpm::vector< int > | |
openfpm::vector< ip_box_grid< dim > > | |
openfpm::vector< itError > | |
openfpm::vector< lBox_dom< dim, T > > | |
openfpm::vector< lid > | |
openfpm::vector< local_index > | |
openfpm::vector< long > | |
openfpm::vector< long int > | |
openfpm::vector< MetisDistribution::met_sub_w > | |
openfpm::vector< MPI_Request > | |
openfpm::vector< MPI_Status > | |
openfpm::vector< nm_e, Memory, layout_e, layout_e_base, grow_p, openfpm::vect_isel< nm_e >::value > | |
openfpm::vector< nm_v, Memory, layout_v, layout_v_base, grow_p, openfpm::vect_isel< nm_v >::value > | |
openfpm::vector< openfpm::vector< ::SpaceBox< dim, T > > > | |
openfpm::vector< openfpm::vector< aggregate< device_grid, SpaceBox< dim, long int > > > > | |
openfpm::vector< openfpm::vector< aggregate< grid_cpu< dim, aggregate< size_t > >, SpaceBox< dim, long int > > > > | |
openfpm::vector< openfpm::vector< aggregate< size_t, size_t > > > | |
openfpm::vector< openfpm::vector< Box_proc< dim, T > > > | |
openfpm::vector< openfpm::vector< gid > > | |
openfpm::vector< openfpm::vector< idx_t > > | |
openfpm::vector< openfpm::vector< long unsigned int > > | |
openfpm::vector< openfpm::vector< size_t > > | |
openfpm::vector< openfpm::vector< SpaceBox< dim, T > > > | |
openfpm::vector< openfpm::vector_std< Box< dim, St > > > | |
openfpm::vector< p_box< dim, T > > | |
openfpm::vector< PetscInt > | |
openfpm::vector< PetscScalar > | |
openfpm::vector< Point< dim, St >, Memory > | |
openfpm::vector< Point< dim, T > > | |
openfpm::vector< Point< dim, typename Cell::stype > > | |
openfpm::vector< pos_v< dim, typename Cell::stype > > | |
openfpm::vector< prop, Memory, layout, layout_base > | |
openfpm::vector< rid > | |
openfpm::vector< rval< PetscScalar, PETSC_RVAL >, HeapMemory, typename memory_traits_inte< rval< PetscScalar, PETSC_RVAL > >::type, memory_traits_inte > | |
openfpm::vector< rval< T, EIGEN_RVAL > > | |
openfpm::vector< size_t > | |
openfpm::vector< size_t, Memory, typename layout_v_base< size_t >::type, layout_v_base, grow_p, openfpm::vect_isel< size_t >::value > | |
openfpm::vector< solv_bench_info > | |
openfpm::vector< SpaceBox< dim, T > > | |
openfpm::vector< std::pair< size_t, size_t > > | |
openfpm::vector< std::string > | |
openfpm::vector< std::unordered_map< size_t, size_t > > | |
openfpm::vector< subsub< dim > > | |
openfpm::vector< subsub_lin< dim > > | |
Vector< T, EIGEN_BASE > | |
vector< T, HeapMemory, typename memory_traits_lin< T >::type, memory_traits_lin, grow_policy_double, STD_VECTOR > | Implementation of 1-D std::vector like structure |
openfpm::vector< T, HeapMemory, typename memory_traits_lin< T >::type, memory_traits_lin, grow_policy_double, STD_VECTOR > | Implementation of 1-D std::vector like structure |
openfpm::vector< T, Memory, layout, layout_base, grow_p, OPENFPM_NATIVE > | Implementation of 1-D std::vector like structure |
Vector< T, PETSC_BASE > | PETSC vector for linear algebra |
vector< T, PtrMemory, typename memory_traits_lin< T >::type, memory_traits_lin, gp, STD_VECTOR > | |
openfpm::vector< T, PtrMemory, typename memory_traits_lin< T >::type, memory_traits_lin, gp, STD_VECTOR > | |
openfpm::vector< triplet > | |
openfpm::vector< triplet< T, PETSC_BASE > > | |
openfpm::vector< typename Mem_type::loc_index > | |
openfpm::vector< V > | |
openfpm::vector< V, Memory, layout_v, layout_v_base, grow_p, openfpm::vect_isel< V >::value > | |
openfpm::vector< v_box< vector > > | |
openfpm::vector< v_info > | |
openfpm::vector< v_info, Memory, typename memory_traits_lin< v_info >::type, memory_traits_lin, grow_p, openfpm::vect_isel< v_info >::value > | |
openfpm::vector< vector< local_index > > | |
openfpm::vector< void * > | |
openfpm::vector<::Box< dim, T > > | |
openfpm::vector<::SpaceBox< dim, size_t > > | |
vector_dist_comm< dim, St, prop, layout, layout_base, Decomposition, Memory > | This class is an helper for the communication of vector_dist |
vector_dist< dim, St, prop, layout, layout_base, Decomposition, Memory > | Distributed vector |
vector_dist_expression< prp, vector > | Main class that encapsulate a vector properties operand to be used for expressions construction |
vector_dist_expression< 16384, point > | This class represent a constant parameter in a vector expression |
vector_dist_expression< prp, double > | Main class that encapsulate a double constant |
vector_dist_expression< prp, float > | Main class that encapsulate a float constant |
vector_dist_expression_op< exp1, exp2, op > | Unknown operation specialization |
vector_dist_expression_op< exp1, exp2, VECT_DIV > | Division operation |
vector_dist_expression_op< exp1, exp2, VECT_MUL > | Multiplication operation |
vector_dist_expression_op< exp1, exp2, VECT_SUB > | Subtraction operation |
vector_dist_expression_op< exp1, exp2, VECT_SUM > | Sum operation |
vector_dist_expression_op< exp1, vector_type, VECT_APPLYKER_IN > | Apply kernel operation |
vector_dist_expression_op< exp1, vector_type, VECT_APPLYKER_IN_GEN > | Apply kernel operation |
vector_dist_expression_op< exp1, vector_type, VECT_APPLYKER_IN_SIM > | Apply kernel operation |
vector_dist_expression_op< exp1, vector_type, VECT_SUM_REDUCE > | Expression that encapsulate a vector reduction expression |
vector_dist_expression_op< exp1, void, VECT_SUB_UNI > | It take an expression and create the negatove of this expression |
vector_dist_iterator | Iterator that Iterate across particle indexes |
openfpm::vector_key_iterator | Vector iterator |
openfpm::vector_key_iterator_seq< lid > | Vector iterator |
VerletBase | |
VerletListM< dim, T, sh_byte, CellListImpl, transform, VerletBase > | Class for Verlet list implementation with Multiphase |
VerletNNIterator< dim, Ver > | Iterator for the neighborhood of the cell structures |
VerletNNIteratorM< dim, Ver, sh_byte > | Iterator for the neighborhood of the cell structures |
vertex | Sub-domain vertex graph node |
vertex2 | |
vertex3 | |
vertex_node< G > | This class is a functor for "for_each" algorithm |
vertex_prop< G > | This class is a functor for "for_each" algorithm |
Void< typename > | Void structure |
vtk_dims< ObjType, has_dims > | If it has not dims property defined the object is considered scalar |
vtk_dims< ObjType, true > | Return the dimansionality of the object |
vtk_dist_edge_node< G > | This class is a functor for "for_each" algorithm |
vtk_dist_vertex_node< G, attr > | This class is a functor for "for_each" algorithm |
vtk_dist_vertex_node< G, false > | This class is a functor for "for_each" algorithm |
vtk_dist_vertex_node_array_scalar_selector< is_array > | |
vtk_dist_vertex_node_array_scalar_selector< true > | |
vtk_edge_node< G > | This class is a functor for "for_each" algorithm |
vtk_type< T, is_w > | Vtk type |
vtk_type< T, false > | Vtk type |
vtk_vertex_node< G, attr > | This class is a functor for "for_each" algorithm |
vtk_vertex_node< G, false > | This class is a functor for "for_each" algorithm |
vtk_vertex_node_array_scalar_selector< is_array > | |
vtk_vertex_node_array_scalar_selector< true > | |
vtk_write< ele, vtk, has_attributes > | Write a property that has attributes |
vtk_write< ele, vtk, false > | Add to the vtk writer the key |
VTKWriter< Object, imp > | |
VTKWriter< Graph, DIST_GRAPH > | |
VTKWriter< Graph, VTK_GRAPH > | |
VTKWriter< pair, VECTOR_GRIDS > | |
VTKWriter< pair, VECTOR_POINTS > | |
VTKWriter< pair, VECTOR_ST_GRIDS > | |
VTKWriter< vector, VECTOR_BOX > | |
vx | |
write_stag< T > | Classes to copy each component into a grid and add to the VTKWriter the grid |
write_stag< T[N1]> | For each component add a grid fill it, and add to the VTK writer |
write_stag< T[N1][N2]> | Partial specialization for N=2 2D-Array |
z_kernel< st, ord > | |
z_kernel< st, 1 > | |
z_kernel< st, 3 > | |
z_kernel< st, 4 > | |