|
OpenFPM_pdata
1.1.0
Project that contain the implementation of distributed structures
|
|
|
OpenFPM_pdata
1.1.0
Project that contain the implementation of distributed structures
|
|
  boost | |
| openfpm | Convert a type into constant type |
| 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 |
| as_array_nnc | Set a dimension threshold |
| 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 |
| CellNNIteratorSymMP | 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= |
| copy_grid_fast | 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 | 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 |
| Debug | |
| 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,....} |
| first_variadic | |
| frswap | This class is a functor for "for_each" algorithm |
| Ftwo | [v_transform metafunction] |
| fun_index | |
| 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, 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 | 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_g_dx | Distributed linearized key |
| 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_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_contiguos | |
| 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 | Initialized |
| is_initialized< openfpm::vector< T > > | Initialized |
| 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 > | |
| last_variadic | |
| last_variadic< T1 > | |
| 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, 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 | 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 | |
| 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 | 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 |
| NNc_array | |
| NNc_array< dim, size, false > | |
| 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 |
| pack_with_iterator | 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 | |
| pack_with_iterator_longx< 2, obj_byte, git, grid > | |
| pack_with_iterator_longx< 3, obj_byte, git, grid > | |
| pack_with_iterator_shortx | |
| pack_with_iterator_shortx< 2, n_cpy, obj_byte, git, grid > | |
| pack_with_iterator_shortx< 3, n_cpy, obj_byte, git, grid > | |
| 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 | |
| post_increment_sub_impl | |
| print_warning_on_adjustment | Declaration print_warning_on_adjustment |
| Process_keys_grid | Class for an hilbert order processing of cell keys for CellList_gen implementation |
| 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 |
| 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 | |
| shift_vect_converter | 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 |
| 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 | 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 | 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 |
| unpack_with_iterator | 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 | 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 | 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 > |
1.8.6 
