Data Structures

Here are the data structures with brief descriptions:

[detail level 1234]

boost | |

openfpm | |

std | |

AdaptiveCylinderCone | This class represent an Adaptive cylinder cone |

add_ | This structure define the operation add to use with copy general |

add_prp_impl | Struct to merge two vectors |

add_prp_impl< OBJECT_ADD, vect_dst > | Struct to merge two vectors |

Aexample | Example structure |

agg_arr | It store the offsets of the interpolation points |

aggregate | Aggregate of properties, from a list of object if create a struct that follow the OPENFPM native structure |

allocate | 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 | Apply the kernel to particle differently that is a number or is an expression |

apply_kernel_is_number_or_expression_gen | Apply the kernel to particle differently that is a number or is an expression |

apply_kernel_is_number_or_expression_sim | Apply the kernel to particle differently that is a number or is an expression |

apply_kernel_rtype | 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 | 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 | Array itself |

ArrayHolder_constexpr | Array itself |

ArrayHolder_indexes | Array itself |

Avg | 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 | |

base_copy< true, base_obj, v_obj > | |

BHeapMemory | It is like HeapMemory but buffered |

bisect_unroll | This class is a functor for "for_each" algorithm |

Box | This class represent an N-dimensional box |

Box_dom | Case for external ghost box |

Box_fix | Internal ghost box sent to construct external ghost box into the other processors |

Box_loc_sub | For each sub-domain box sub contain the real the sub-domain id |

Box_proc | Case for local external ghost box |

Box_sub | |

Box_sub_k | Particular case for local internal ghost boxes |

brt_test | |

calculate_aint | Calculate aint |

calculate_aint< 2, vector, np > | Calculate aint 2D |

calculate_aint< 3, vector, np > | Calculate aint |

call_aggregatePack | Calls a packer in nested way |

call_aggregatePackRequest | |

call_aggregateUnpack | Calls an unpacker in nested way |

call_encapPack | |

call_encapPackRequest | |

call_encapUnpack | |

call_init_if_needed | 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 | |

call_pack_enc_functor | |

call_packRequest_agg_functor | |

call_packRequest_enc_functor | |

call_serialize_variadic | |

call_serialize_variadic< index_tuple< prp...> > | |

call_unpack_agg_functor | |

call_unpack_encap_functor | |

CartDecomposition | This class decompose a space into sub-sub-domains and distribute them across processors |

CartDecomposition_ext | This class decompose a space into sub-sub-domains and distribute them across processors |

CartesianGraphFactory | This class construct a cartesian graph |

cell_grid | For each combination in the cell grid you can have different grids |

CellIterator | It iterate through the elements of a cell |

CellIteratorM | It iterate through the elements of a cell |

CellList | Class for FAST cell list implementation |

CellList_gen | |

CellListM | Class for Multi-Phase cell-list |

CellNNIterator | Iterator for the neighborhood of the cell structures |

CellNNIterator< dim, Cell, RUNTIME, impl > | Iterator for the neighborhood of the cell structures |

CellNNIteratorM | Iterator for the neighborhood of the cell structures |

CellNNIteratorM< dim, Cell, sh_byte, RUNTIME, impl > | Iterator for the neighborhood of the cell structures |

CellNNIteratorRadius | Iterator for the neighborhood of the cell structures with free radius |

CellNNIteratorSym | Symmetric iterator for the neighborhood of the cell structures |

CellNNIteratorSym< dim, Cell, RUNTIME, impl > | Symmetric iterator for the neighborhood of the cell structures |

CellNNIteratorSymM | Iterator for the neighborhood of the cell structures |

CellNNIteratorSymM< dim, Cell, sh_byte, RUNTIME, impl > | Symmetric iterator for the neighborhood of the cell structures |

check_no_pointers | This class check if the type T has pointers inside |

check_no_pointers_impl | Check if the type T has pointers inside |

check_no_pointers_impl< T, false > | Check if the type T has pointers inside |

check_types | Functor for for_each algorithm |

CheckExistence | Class to check if the edge can be created or not |

comb | Position of the element of dimension d in the hyper-cube of dimension dim |

comb< 0 > | |

compare_aggregate | Structure to copy aggregates applying an operation limited to some properties |

compare_cpu_encap_encap | This class is a functor for "for_each" algorithm |

compare_fusion_vector | This class is a functor for "for_each" algorithm |

compare_general | Structure to copy aggregates |

compare_general< T, 0 > | |

compare_general< T, 2 > | |

conditional_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 | Multiplication expression |

ConstField | |

construct_expression | |

construct_expression< double > | Construct a vector expression from a double |

construct_expression< float > | Construct a vector expression from a float |

convert | Set a conversion map between A and B |

convert< std::string > | Partial specialization when A is a string |

copy_acc | This class is a functor for "for_each" algorithm |

copy_aggregate | Structure to copy aggregates |

copy_aggregate_op | Structure to copy aggregates applying an operation |

copy_cpu_encap | This class is a functor for "for_each" algorithm |

copy_cpu_encap_encap | This class is a functor for "for_each" algorithm |

copy_cpu_encap_encap_op_prp | It copy two encap object |

copy_ele | This class is a functor for "for_each" algorithm |

copy_ele_sca_array | Copy scalar elements |

copy_ele_sca_array< copy_type, T, Ev, Eqs_sys, 1 > | Copy 1D array elements |

copy_fusion_vector | This class is a functor for "for_each" algorithm |

copy_fusion_vector_encap | This class is a functor for "for_each" algorithm |

copy_general | 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 | 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= |

csv_col | 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 | 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 | This class is a functor for "for_each" algorithm |

csv_value_str | 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 | CSV Writer |

cval | It store the non zero elements of the matrix |

D | 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 | Class that store Internal part external and border part of a dataset |

dec_optimizer | This class take a graph representing the space decomposition and produce a simplified version |

Decomposition | This class define the domain decomposition interface |

dist_prop_out_edge | This class is a functor for "for_each" algorithm |

dist_prop_out_vertex | This class is a functor for "for_each" algorithm |

dist_prop_output | 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 | 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 | 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 | Property writer for scalar and vector |

dist_prop_output_array_scalar_selector_vertex< true > | Property writer for vector |

DistGraph_constr_impl | Graph constructor function specialization |

DistGraph_constr_impl< dim, Graph, NO_EDGE, T, dim_c, pos...> | Graph constructor function specialization |

DistGraph_CSR | Structure that store a graph in CSR format or basically in compressed adjacency matrix format |

DistGraph_CSR_s | Simplified implementation of DistGraph_CSR |

DistGraphFactory | This class construct a cartesian graph |

DistParmetis | Helper class to define Metis graph |

DistParMetisDistribution | |

DLB | |

do_not_print_warning_on_adjustment | |

do_when_dim_gr_i | This structure use SFINAE to avoid instantiation of invalid code |

domain_nn_calculator_cart | This class calculate processor domains and neighborhood of each processor domain |

DrawParticles | A class to draw/create particles based on simple shaped |

e_box_id | It store the information about the external ghost box |

e_info | |

e_lbox_grid | Per-processor external ghost box |

e_lbox_id | It store the information about the local external ghost box |

e_map | Structure used inside GraphCSR an edge |

E_p | Edge class that encapsulate an object T |

ed | |

edge_iterator | Graph edge iterator |

edge_key | |

edge_node | This class is a functor for "for_each" algorithm |

edge_prop | This class is a functor for "for_each" algorithm |

ele_g | It store one grid |

ele_g_st | Convert a staggered element into a string for vtk write |

ele_vpp | Store a reference to the vector properties |

ele_vps | Store a reference to the vector position |

encapc | |

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 | Per-processor external ghost box |

Eq | Equation |

Error | Out-of-bound policy kill the program |

eta | [Definition of the system] |

exit_impl | Exit condition |

exp_kernel | Exponential kernel |

extends | 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 |

ExtPreAlloc | |

F | [v_transform metafunction] |

FDScheme | Finite Differences |

Field | |

fill_id | 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 | {1,1,1,1,....} |

fill_prop | 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 | 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 | 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 | 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 | Compile time array functor needed to generate array at compile-time of type |

Fill_two | {2,2,2,2,....} |

Fill_zero | {0,0,0,0,....} |

frswap | This class is a functor for "for_each" algorithm |

Ftwo | [v_transform metafunction] |

GBoxes | This structure store the Box that define the domain inside the Ghost + domain box |

gcl | General function t get a cell-list |

gcl< dim, St, CellList_gen< dim, St, Process_keys_hilb, Mem_type, shift< dim, St > >, Vector > | General function t get a cell-list |

GCoptions | Google chart options |

generate_array | Main class to generate compile-time array |

generate_array_constexpr | Main class to generate constexpr compile-time array |

generate_array_constexpr_impl | 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 | Generate the array specializing ArrayHolder |

generate_array_impl< T, 0, orig_N, F, args...> | Terminator of the variadic template |

generate_array_vector | Main class to generate an array from a boost::mpl::vector of numbers |

generate_array_vector_impl | Generate the array specializing ArrayHolder |

generate_array_vector_impl< T, 1, F, args...> | Terminator of the variadic template |

generate_indexes | Main class to generate indexes data structure |

generate_indexes_impl | 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 | Return the Attributes name from the type |

getAttrName< ele_g, false > | Return the Attributes name from the type |

GGraph | Google Graph |

Ghost | |

gid | |

GoogleChart | Small class to produce graph with Google chart in HTML |

Graph_constructor_impl | Graph constructor function specialization |

Graph_constructor_impl< dim, lin_id, Graph, NO_EDGE, T, dim_c, pos...> | Graph constructor function specialization |

Graph_CSR | Structure that store a graph in CSR format or basically in compressed adjacency matrix format |

Graph_CSR_s | Simplified implementation of Graph_CSR |

GraphMLWriter | |

grid | |

grid_base_impl | Implementation of a N-dimensional grid |

grid_call_serialize_variadic | Unpack selector |

grid_call_serialize_variadic< device_grid, Memory, index_tuple< prp...> > | Unpack selector |

grid_cpu | |

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_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_dist_id | This is a distributed grid |

grid_dist_id_comm | This class is an helper for the communication of grid_dist_id |

grid_dist_id_iterator_dec | Given the decomposition it create an iterator |

grid_dist_id_iterator_dec_skin | Given the decomposition it create an iterator |

grid_dist_iterator | 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 | Distributed grid iterator |

grid_dist_key_dx | Grid key for a distributed grid |

grid_dist_lin_dx | Distributed linearized key |

grid_dist_testing | |

grid_key | |

grid_key_1 | |

grid_key_2 | |

grid_key_3 | |

grid_key_4 | |

grid_key_c3 | |

grid_key_d | Grid_key_d is the key to access any element in the grid |

grid_key_dx | Grid_key_dx is the key to access any element in the grid |

grid_key_dx_expression | Expression template for grid_key_dx |

grid_key_dx_iterator | |

grid_key_dx_iterator_hilbert | |

grid_key_dx_iterator_sp | |

grid_key_dx_iterator_stencil | |

grid_key_dx_iterator_sub | Declaration grid_key_dx_iterator_sub |

grid_key_dx_iterator_sub< 0, warn > | |

grid_key_dx_iterator_sub_bc | The same as grid_key_dx_iterator_sub_p but with periodic boundary |

grid_key_dx_r | Emulate grid_key_dx with runtime dimensionality |

grid_key_dx_sub | Main class that encapsulate a sub expression |

grid_key_dx_sum | Main class that encapsulate a sum expression |

grid_skin_iterator_bc | |

grid_sm | Declaration grid_sm |

grid_unpack_selector_with_prp | Unpack selector |

grid_unpack_selector_with_prp< true, T, device_grid, Memory > | Unpack selector |

grid_unpack_with_prp | Unpack selector |

GridRawReader | |

H5_prop_out | 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 | 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_attributes | |

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 | |

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 | |

has_data< T, typename Void< decltype(T::data)>::type > | Has_data check if a type has defined a member data |

has_grid_type | |

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 | Has_init check if a type has defined a method called init |

has_init< ObjType, typename Void< typename ObjType::has_init >::type > | |

has_max_prop | |

has_max_prop< T, false > | |

has_max_prop_nn | |

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 | |

has_noPointers< T, typename Void< decltype(T::noPointers())>::type > | Has_noPointers check if a type has defined a method called noPointers |

has_pack | Has_Pack check if a type has defined a method called Pack |

has_pack< ObjType, typename Void< decltype(ObjType::pack())>::type > | |

has_pack_agg | Return if true the aggregate type T has a property that has a complex packing(serialization) method |

has_pack_agg_impl | 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 | |

has_pack_gen | 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_packMem | Has_calculateMem check if a type has defined a method called calculateMem |

has_packMem< ObjType, typename Void< decltype(ObjType::packMem())>::type > | Has_PackMem check if a type has packMem() member function |

has_packRequest | Has_packRequest check if a type has defined a method called packRequest |

has_packRequest< ObjType, typename Void< decltype(ObjType::packRequest())>::type > | |

has_posMask | |

has_posMask< T, typename Void< decltype(T::stag_mask)>::type > | Has_data check if a type has defined a member data |

has_typedef_type | |

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 | Evaluate the constant field function |

has_val< HAS_VAL, T > | Evaluate the constant field function |

has_val_pos | |

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 | |

has_value_type< T, typename Void< typename T::value_type >::type > | Has_value_type check if a type has defined a member value_type |

HDF5_reader | |

HDF5_reader< GRID_DIST > | |

HDF5_reader< VECTOR_DIST > | |

HDF5_writer | |

HDF5_writer< GRID_DIST > | |

HDF5_writer< VECTOR_DIST > | |

HDF5_XdmfWriter | |

HDF5_XdmfWriter< H5_POINTSET > | HDF5 writer for a point set |

HeapMemory | This class allocate, and destroy CPU memory |

HyperCube | This class calculate elements of the hyper-cube |

i_box_id | It store a box, its unique id and the sub-domain from where it come from |

i_lbox_grid | Local Internal ghost box |

i_lbox_id | 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 | Structure that store and compute the internal and external local ghost box |

ie_loc_ghost | Structure that store and compute the internal and external local ghost box |

index_tuple | These set of classes generate an array definition at compile-time |

init_prop | This class is a functor for "for_each" algorithm |

inte_calc_impl | Calculate the interpolation for one point |

inte_template | 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 | This class convert a boost::mpl::fusion/vector to a boost::mpl::fusion/vector with memory_c interleaved |

interp_ele | This class is a functor for "for_each" algorithm |

interp_ele_sca_array | Add scalar elements |

interp_ele_sca_array< copy_type, Tsrc, Tdst, Grid_src, Grid_dst, 1 > | Add 1D array elements |

interp_points | This class is a functor for "for_each" algorithm |

interpolate | Main class for interpolation Particle to mest p2m and Mesh to particle m2p |

ip_box_grid | Per-processor Internal ghost box |

is_const_field | |

is_const_field< T, typename Void< typename T::const_field >::type > | Is_constant check if a type define a constant field |

is_csv_writable | 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_custom_vtk_writable | It check if the type is vtk writable |

is_custom_vtk_writable< ObjType, typename Void< typename ObjType::is_vtk_writable >::type > | It check if the type is vtk writable |

is_encap | |

is_encap< T, typename Void< typename T::yes_i_am_encap >::type > | Is_encap check if the type is an encap type |

is_expression | Is_expression check if a type is simple a type or is just an encapsulation of an expression |

is_expression< ObjType, typename Void< typename ObjType::is_expression >::type > | |

is_grid | |

is_grid< T, typename Void< typename T::yes_i_am_grid >::type > | Is_grid check if the type is a grid |

is_grid_staggered | 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 | |

is_initialized< openfpm::vector< T > > | |

is_layout_inte | |

is_layout_inte< T, typename Void< typename T::yes_is_inte >::type > | Is_layout_inte |

is_layout_mlin | |

is_layout_mlin< T, typename Void< typename T::yes_is_tlin >::type > | Is_layout_mlin |

is_openfpm_native | Is_openfpm_native check if a type is an openfpm native structure type |

is_openfpm_native< T, true > | |

is_testing | |

is_testing< T, typename Void< typename T::testing >::type > | Is_testing check if a struct T has testing member defined |

is_typedef_and_data_same | Check if T::type and T.data has the same type |

is_typedef_and_data_same< false, T > | |

is_vector | |

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 | It check if the type is vtk writable |

is_vtk_vector_dims< ObjType, typename Void< decltype(ObjType::dims) >::type > | It check if the type is vtk writable |

is_vtk_writable | 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 | |

key | This class is a trick to indicate the compiler a specific specialization pattern |

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 | 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 | 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 > | |

lBox_dom | Case for local ghost box |

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 | This class is able to save grid into tiff files |

Matrix | This class implement an NxN (dense) matrix |

max_prop_nn | |

max_prop_nn< T, false > | |

Mem_bal | Class for BALANCED cell list implementation |

Mem_fast | It is a class that work like a vector of vector |

mem_get | Case memory_traits_lin |

mem_get< p, layout, data_type, g1_type, key_type, 1 > | Case memory_traits_inte |

mem_geto | Case memory_traits_lin |

mem_geto< dim, T, layout, data_type, g1_type, key_type, 1 > | Case memory_traits_inte |

Mem_mw | Class for MEMORY-WISE cell list implementation |

mem_reference | Metafunction take T and return a reference |

mem_setext | Case memory_traits_lin |

mem_setext< grid_type, S, layout, data_type, 1 > | Case memory_traits_inte |

mem_setm | Case memory_traits_lin |

mem_setm< S, layout, data_type, g1_type, 1 > | Case memory_traits_inte |

mem_swap | Case memory_traits_lin |

mem_swap< T, layout, data_type, grid_type, 1 > | Case memory_traits_inte |

memory | |

memory_array | This class give a representation to a chunk or memory |

memory_c | 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 | This class is a container for the memory interface |

memory_traits_inte | Transform the boost::fusion::vector into memory specification (memory_traits) |

memory_traits_lin | Transform the boost::fusion::vector into memory specification (memory_traits) |

memory_traits_lin_type | 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_ | This structure define the operation add to use with copy general |

meta_compare | 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 | 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 | Copy for a source object to a destination |

meta_copy_d< Tsrc[N1], Tdst > | Partial specialization for N=1 1D-Array |

meta_copy_d< Tsrc[N1][N2], Tdst > | Partial specialization for N=2 2D-Array |

meta_copy_op | 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_prop | 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 | This is the scalar case |

meta_raw_read< dim, Tg, Tr[nv], i > | This is the vector case |

MetaFunc | [Metafunction definition] |

MetaFuncOrd | |

Metis | Helper class to define Metis graph |

Metis_graph | Metis graph structure |

MetisDistribution | Class that distribute sub-sub-domains across processors using Metis Library |

minus | 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 | |

MPI_IAllGatherW | 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 | 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 | 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 | 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 | 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 | It model an expression expr1 * expr2 |

mul_inte | 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 | This class multiply all the elements in a boost::mpl::vector excluding the first element |

mult< T, 1 > | |

multi_array | This class is a trick to indicate the compiler a specific specialization pattern |

my_struct | |

N_box | |

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 | This class store the adjacent processors and the adjacent sub_domains |

NNType | 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 | 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 | No transformation |

NoCheck | Class to check if the edge can be created or not |

node_cp | |

noPointers_sequence | It return a boost::mpl::vector of integers where each integer identify one object without the method "noPointers" |

noPointers_sequence_impl | 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 | |

number_prop< T, 0 > | Return the number of properties the type T has |

object | This is a container to create a general object |

object_creator | It create a boost::fusion vector with the selected properties |

object_creator< v > | Specialization when no properties are passed |

object_creator_impl | 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 | 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 | This class is a functor for "for_each" algorithm |

object_s_di_e_op | This class is a functor for "for_each" algorithm |

object_s_di_f | This class is a functor for "for_each" algorithm |

object_s_di_f_op | This class is a functor for "for_each" algorithm |

object_s_di_op | 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 | 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 | This class is a functor for "for_each" algorithm |

object_si_d_f | 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 | 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 | Helper class to add data |

op_ssend_recv_add_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 | Helper class to merge data |

op_ssend_recv_merge_impl | Helper class to merge data without serialization |

op_ssend_recv_merge_impl< true, op > | Helper class to merge data with serialization |

p_box | It store all the boxes of the near processors in a linear array |

Pack_selector | Pack selector |

Pack_selector_impl | It is not a fundamental type |

Pack_selector_impl< T, true > | Select the primitive packing |

Pack_selector_known_type_impl | 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 | Pack selector for unknown type |

Pack_selector_unknown_type_impl< T, false > | |

Pack_stat | Packing status object |

pack_unpack_cond_with_prp | There is max_prop inside |

Packer | 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 |

Padding | Class that contain Padding information on each direction positive and Negative direction |

Parmetis | Helper class to define Metis graph |

Parmetis_dist_graph | Metis graph structure |

Parmetis_graph | Metis graph structure |

ParMetisDistribution | Class that distribute sub-sub-domains across processors using ParMetis Library |

ParticleIt_CellP | |

ParticleIt_Cells | This iterator iterate across the particles of a Cell-list following the Cell structure |

ParticleItCRS_Cells | This iterator iterate across the particles of a Cell-list following the Cell structure |

PartItNN | 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 | |

petsc_AMG_report | Class to test AMG solvers |

petsc_solver | 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 | This class implement the point shape in an N-dimensional space |

Point2D_test | Test structure used for several test |

point_expression | 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 | 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 | Definition of a class Point in plain C++ and boost::vector for testing purpose |

Point_test | Test structure used for several test |

Point_test_prp | Test structure used for several test |

Point_test_scal | Point test with only scalar properties |

PointIterator | This class draw particles on subset of grid-like position |

PointIteratorSkin | This class draw particles on subset of grid-like position |

poisson_nn_helm | |

pos_or_propL | Selector for position or properties left side expression |

pos_or_propL< vector, PROP_POS > | Selector for position or properties left side |

pos_or_propR | Selector for position or properties right side position |

pos_or_propR< vector, PROP_POS > | Selector for position or properties right side |

pos_v | Structure that contain a reference to a vector of particles |

pos_val | |

print_warning_on_adjustment | Declaration print_warning_on_adjustment |

Process_keys_hilb | Class for an hilbert order processing of cell keys for CellList_gen implementation |

Process_keys_lin | |

prop_out_edge | This class is a functor for "for_each" algorithm |

prop_out_g | This class is a functor for "for_each" algorithm |

prop_out_v | This class is a functor for "for_each" algorithm |

prop_out_vertex | This class is a functor for "for_each" algorithm |

prop_output | 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 | 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 | 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 | Property writer for scalar and vector |

prop_output_array_scalar_selector_vertex< true > | Property writer for vector |

prop_write_out | Write the vectror property |

prop_write_out< 1, T > | Write the scalar property |

propCheckINF | This class is a functor for "for_each" algorithm |

propCheckNAN | This class is a functor for "for_each" algorithm |

prp_all_zero | Structure to convert a variadic template into boost::mpl::vector |

prp_all_zero< T, true, prp... > | |

PSEError | |

ptr_info | |

PtrMemory | This class give memory from a preallocated memory, memory destruction is not performed |

push_back_op | |

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 | Pack/add function selector |

push_back_op_neste< true, T, S > | Pack/add function selector |

push_back_std_op_neste | Pack/add function selector |

push_back_std_op_neste< true, T, S > | |

PV_cl | |

r_type_dim | 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 | Return type of the expression |

r_type_p< 1, orig > | Return type of the expression |

raw_read | This class is a functor for "for_each" algorithm |

red | Temporal buffer for reductions |

reduce_type | 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_to_memory_c is a metafunction that given T it convert it into |

replace_ | This structure define the operation add to use with copy general |

RGB | RGB color struct |

rid | |

rval | 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 |

scalar | It define a scalar value compatible with grid_cpu , grid_gpu, vector, graph .. |

se_class3_vector | This class check for inconsistency access |

seq_traits_impl | Implementation of seq_traits |

set_zero | Meta-function to return a compatible zero-element |

set_zero< Point< dim, T > > | Create a point with all compunent set to zero |

shift | |

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 |

space_key_dx | Grid_key_dx is the key to access any element in the grid |

SpaceBox | This class represent an N-dimensional box |

SpaceDistribution | Class that distribute sub-sub-domains across processors using an hilbert curve to divide the space |

SparseMatrix | Sparse Matrix implementation |

SparseMatrix< T, id_t, EIGEN_BASE > | |

SparseMatrix< T, id_t, PETSC_BASE > | Sparse Matrix implementation, that map over Eigen |

Sphere | This class implement the Sphere concept in an N-dimensional space |

stag_create_and_add_grid | It create separated grid for each properties to write them into a file |

stag_set_position | This class is a functor for "for_each" algorithm |

stag_set_position< dim, v, false > | This class is a functor for "for_each" algorithm |

staggered_grid_dist | Implementation of the staggered grid |

stencil_offset_compute | Structure for stencil iterator |

stub_or_real | In case of testing return a stub grid |

stub_or_real< T, dims, stype, decomposition, false > | Case when we are not on testing |

SubHyperCube | This represent a sub-hyper-cube of an hyper-cube like a face or an edge of a cube |

subsub | Sub-sub-domain |

subsub_lin | Linearized version of subsub |

sum | It model an expression expr1 + ... exprn |

sum_functor_value | Sum functor value |

sys_nn | |

sys_pp | |

syss_nn | |

syss_pp | |

System | System of equations |

t_to_memory_c | Meta-function t_to_memory_c |

t_to_memory_c_impl | 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 | |

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 | 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 | |

to_boost_vmpl<> | Terminator for to_boost_mpl with last parameter |

to_boost_vmpl_impl | Implementation of to_boost_vmpl |

to_boost_vmpl_impl< a > | Terminator for to_boost_mpl with last parameter |

to_int_sequence | |

to_variadic_impl | Recursive specialization of to_variadic |

to_variadic_impl< H, F, L, true > | Terminator of to_variadic |

toPoint | |

triplet | 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 |

type_gpu_prop | This class is an helper to get the return type of get for each property |

typeCheck | |

typeCheck< tcheck, true > | |

typeCheck< tcheck[N1], foundamental > | |

typeCheck< tcheck[N1][N2], foundamental > | |

umfpack_solver | Stub when library compiled without eigen |

umfpack_solver< double > | Stub when library compiled without eigen |

unpack_selector_with_prp | |

unpack_selector_with_prp< true, T, S > | |

Unpack_stat | Unpacking status object |

Unpacker | 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 | |

v_info | |

V_p | Vertex class that encapsulate an object T |

v_transform | |

v_transform_impl | Recursive specialization of v_transform |

v_transform_impl< H, F, L, true, Args...> | Terminator of to_variadic |

v_transform_two | |

v_transform_two_impl | 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 | Implementation of VCluster class |

Vcluster_base | This class virtualize the cluster of PC as a set of processes that communicate |

Vcluster_log | Vcluster log |

vect_dist_key_dx | Grid key for a distributed grid |

Vector | Sparse Matrix implementation stub object when OpenFPM is compiled with no linear algebra support |

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 |

Vector< T, PETSC_BASE > | PETSC vector for linear algebra |

vector< T, PtrMemory, typename memory_traits_lin< T >::type, memory_traits_lin, gp, STD_VECTOR > | |

vector_dist | Distributed vector |

vector_dist_comm | This class is an helper for the communication of vector_dist |

vector_dist_expression | 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 | 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 |

VerletList | Cell list structure |

VerletList< dim, T, FAST, transform, local_index, CellListImpl > | Class for Verlet list implementation |

VerletListM | Class for Verlet list implementation with Multiphase |

VerletNNIterator | Iterator for the neighborhood of the cell structures |

VerletNNIteratorM | Iterator for the neighborhood of the cell structures |

vertex | Sub-domain vertex graph node |

vertex2 | |

vertex3 | |

vertex_node | This class is a functor for "for_each" algorithm |

vertex_prop | This class is a functor for "for_each" algorithm |

Void | Void structure |

vtk_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 | This class is a functor for "for_each" algorithm |

vtk_dist_vertex_node | 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 | |

vtk_dist_vertex_node_array_scalar_selector< true > | |

vtk_edge_node | This class is a functor for "for_each" algorithm |

vtk_type | Vtk type |

vtk_type< T, false > | Vtk type |

vtk_vertex_node | 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 | |

vtk_vertex_node_array_scalar_selector< true > | |

vtk_write | Write a property that has attributes |

vtk_write< ele, vtk, false > | Add to the vtk writer the key |

VTKWriter | |

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 | |

wavefront | This class represent a wavefront of dimension dim |

wrap_unordered_map | Wrapper of the unordered map |

write_stag | 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 | |

z_kernel< st, 1 > | |

z_kernel< st, 2 > | |

z_kernel< st, 3 > | |

z_kernel< st, 4 > |