OpenFPM_pdata  4.1.0
Project that contain the implementation of distributed structures
 
Loading...
Searching...
No Matches
Data Structures
Here are the data structures with brief descriptions:
[detail level 12345]
 ►Nboost
 ►NcubOptional outer namespace(s)
 ►NFD
 ►Ngpu
 ►NopenfpmConvert a type into constant type
 ►NSparseGridGpuKernels
 ►Nstd
 ►Ntsl
 C_add_
 C_max_
 CAdaptiveCylinderConeThis class represent an Adaptive cylinder cone
 Cadd_This structure define the operation add to use with copy general
 Cadd_atomic_This structure define the operation add to use with copy general
 Cadd_const_reference
 Cadd_const_reference< T, true >
 Cadd_prp_implStruct to merge two vectors
 Cadd_prp_impl< OBJECT_ADD, vect_dst >Struct to merge two vectors
 CAexampleExample structure
 Cagg_arrIt store the offsets of the interpolation points
 CaggregateAggregate of properties, from a list of object if create a struct that follow the OPENFPM native structure
 Caggregate_add
 Caggregate_add< aggregate< types ... > >
 Caggregate_bfvAn aggregate that accept a boost fusion vector as type
 Caggregate_convert
 Caggregate_convert< dim, blockEdgeSize, aggregate< types ... > >
 Caggregate_or_known_type
 Caggregate_or_known_type< layout_base, T, 2, args ... >
 Caggregate_or_known_type< layout_base, T, 4, args ... >
 Caggregate_transform_datablock_impl
 CAggregateAppend
 CAggregateAppend< BlockT, aggregate< list ... > >
 CAlgoimWrapper
 CAlgoimWrapper< wrapping_field, grid_type, wrapping_field_type[N1]>
 CAlgoimWrapper< wrapping_field, grid_type, wrapping_field_type[N1][N2]>
 CAlgoimWrapper< wrapping_field, grid_type, wrapping_field_type[N1][N2][N3]>
 CallocateThis class is a functor for "for_each" algorithm
 Calpa_base_structs
 CAMG_time_err_coarsIt contain information about the performance of the AMG
 Camr_launch_sparse
 Canyname_field[Constant fields struct definition]
 Canyname_field_with_posDefine a non-constant (in space) field
 Capply_kernel_is_number_or_expressionApply the kernel to particle differently that is a number or is an expression
 Capply_kernel_is_number_or_expression_genApply the kernel to particle differently that is a number or is an expression
 Capply_kernel_is_number_or_expression_simApply the kernel to particle differently that is a number or is an expression
 Capply_kernel_rtypeIt give the return type of the expression if applicable
 Capply_kernel_rtype< exp, false >It give the return type of the expression if applicable
 Capply_transform
 Capply_trasform_impl
 Capply_trasform_impl< layout_base, T, boost::fusion::vector< args... > >
 Carr_arr_ptr
 Carr_ptr
 Carray_asc
 Carray_asc< 2 >
 Carray_asc< 3 >
 Carray_asc< 4 >
 Carray_extentsStruct that give functionalities on array extensions
 Carray_extents< T[N1]>Struct that give functionalities on array extensions
 Carray_extents< T[N1][N2]>Struct that give functionalities on array extensions
 Carray_extents< T[N1][N2][N3]>Struct that give functionalities on array extensions
 Carray_ord
 Carray_ord< 2, size_type >
 Carray_ord< 3, size_type >
 Carray_ord< 4, size_type >
 Carray_to_vmplPartial specialization for scalar N=0
 Carray_to_vmpl< T[N1]>Partial specialization for N=1
 Carray_to_vmpl< T[N1][N2]>Partial specialization for N=2
 CArrayHolderArray itself
 CArrayHolder_constexprArray itself
 CArrayHolder_indexesArray itself
 CArrayWrapper
 CArrayWrapper< BaseType[N1]>
 CArrayWrapper< BaseType[N1][N2]>
 Cas_array_nncSet a dimension threshold
 Cat_impl
 Cat_impl< vector, p, true >
 CAvgAverage
 CAvg< d, arg, Sys_eqs, BACKWARD >First order BACKWARD derivative on direction i
 CAvg< d, arg, Sys_eqs, CENTRAL >Central average scheme on direction i
 CAvg< d, arg, Sys_eqs, FORWARD >FORWARD average on direction i
 Cb_cast_helper
 Cb_cast_helper< false >
 Cbase_copy
 Cbase_copy< true, base_obj, v_obj >
 Cbcast_inte_implThis class is a functor for "for_each" algorithm
 Cbest_conv
 Cbest_conv_impl
 Cbest_conv_impl< int, source2 >
 Cbest_conv_impl< long int, source2 >
 Cbest_conv_impl< source1, int >
 Cbest_conv_impl< source1, long int >
 Cbest_conv_impl< source1, unsigned int >
 Cbest_conv_impl< source1, unsigned long int >
 Cbest_conv_impl< unsigned int, source2 >
 Cbest_conv_impl< unsigned long int, source2 >
 Cbisect_unrollThis class is a functor for "for_each" algorithm
 Cblock_offset
 CBlockMapGpu
 CBlockMapGpu_ker
 CBMemoryIt override the behavior if size()
 CBoundaryStencilSetX
 CBoundaryStencilSetXRescaled
 CBoxThis class represent an N-dimensional box
 CBox_check
 CBox_domCase for external ghost box
 CBox_fixInternal ghost box sent to construct external ghost box into the other processors
 CBox_loc_subFor each sub-domain box sub contain the real the sub-domain id
 CBox_procCase for local external ghost box
 CBox_sub
 CBox_sub_kParticular case for local internal ghost boxes
 CBoxDistributionClass that distribute sub-sub-domains across processors using Metis Library
 Cbrt_test
 Cbump
 Ccalculate_aintCalculate aint
 Ccalculate_aint< 2, vector, np >Calculate aint 2D
 Ccalculate_aint< 3, vector, np >Calculate aint
 CCalcVelocity
 Ccall_aggregatePackCalls a packer in nested way
 Ccall_aggregatePackRequest
 Ccall_aggregatePackRequestChunking
 Ccall_aggregateUnpackCalls an unpacker in nested way
 Ccall_encapPack
 Ccall_encapPackChunking
 Ccall_encapPackRequest
 Ccall_encapUnpack
 Ccall_encapUnpackChunking
 Ccall_init_if_neededCall the init function if a type T has the function init
 Ccall_init_if_needed< T, false >Call the init function if a type T has the function init
 Ccall_pack_agg_functor
 Ccall_pack_enc_functor
 Ccall_pack_enc_functor_chunking
 Ccall_pack_enc_functor_chunking_impl_arr
 Ccall_pack_enc_functor_chunking_impl_arr< Timp[N1]>
 Ccall_packRequest_agg_functor
 Ccall_packRequest_agg_functor_cnk
 Ccall_packRequest_enc_functor
 Ccall_recursive_destructor_if_vector
 Ccall_recursive_destructor_if_vector< T, T_ker, type_prp, layout_base, 0 >
 Ccall_recursive_destructor_if_vector< T, T_ker, type_prp, layout_base, 3 >
 Ccall_recursive_destructor_if_vector< T, T_ker, type_prp, layout_base, 4 >
 Ccall_recursive_host_device_if_vector
 Ccall_recursive_host_device_if_vector< T, T_ker, type_prp, layout_base, 0 >
 Ccall_recursive_host_device_if_vector< T, T_ker, type_prp, layout_base, 3 >
 Ccall_recursive_host_device_if_vector< T, T_ker, type_prp, layout_base, 4 >
 Ccall_serialize_variadic
 Ccall_serialize_variadic< index_tuple< prp... > >
 Ccall_unpack_agg_functor
 Ccall_unpack_encap_functor
 Ccall_unpack_encap_functor_chunking
 Ccall_unpack_encap_functor_chunking_array_selector
 Ccall_unpack_encap_functor_chunking_array_selector< T[N1]>
 ►CCartDecompositionThis class decompose a space into sub-sub-domains and distribute them across processors
 CCartDecomposition_extThis class decompose a space into sub-sub-domains and distribute them across processors
 CCartDecomposition_gpu
 CCartesianGraphFactoryThis class construct a cartesian graph
 Ccell_gridFor each combination in the cell grid you can have different grids
 Ccell_list_selector
 Ccell_list_selector< vector, comp_host >
 CCellDecomposer_gpu_ker
 CCellIteratorIt iterate through the elements of a cell
 CCellIteratorMIt iterate through the elements of a cell
 CCellListClass for FAST cell list implementation
 CCellList_cpu_ker
 CCellList_gen
 CCellList_gpu_ker
 CCellList_gpu_ker< dim, T, cnt_type, ids_type, transform, true >
 CCellListMClass for Multi-Phase cell-list
 CCellNNIteratorIterator for the neighborhood of the cell structures
 CCellNNIterator< dim, Cell, RUNTIME, impl >Iterator for the neighborhood of the cell structures
 CCellNNIteratorMIterator for the neighborhood of the cell structures
 CCellNNIteratorM< dim, Cell, sh_byte, RUNTIME, impl >Iterator for the neighborhood of the cell structures
 CCellNNIteratorRadiusIterator for the neighborhood of the cell structures with free radius
 CCellNNIteratorSymSymmetric iterator for the neighborhood of the cell structures
 CCellNNIteratorSym< dim, Cell, vector_pos_type, RUNTIME, impl >Symmetric iterator for the neighborhood of the cell structures
 CCellNNIteratorSymMIterator for the neighborhood of the cell structures
 CCellNNIteratorSymM< dim, Cell, sh_byte, RUNTIME, impl >Symmetric iterator for the neighborhood of the cell structures
 CCellNNIteratorSymMPSymmetric iterator for the neighborhood of the cell structures
 CcheaderThis structure contain the information of a chunk
 Ccheck_all_apply_ker
 Ccheck_all_apply_ker< comp_dev >
 Ccheck_all_apply_ker_sort
 Ccheck_all_expressions
 Ccheck_all_expressions< comp_dev >
 Ccheck_device_ptrThis class is a functor for "for_each" algorithm
 Ccheck_nan
 Ccheck_nan< double >
 Ccheck_nan< float >
 Ccheck_no_pointersThis class check if the type T has pointers inside
 Ccheck_no_pointers_implCheck if the type T has pointers inside
 Ccheck_no_pointers_impl< T, false >Check if the type T has pointers inside
 Ccheck_type
 Ccheck_type< T, 1 >
 Ccheck_typesFunctor for for_each algorithm
 CCheckExistenceClass to check if the edge can be created or not
 Ccid_
 Ccid_< 1, cnt_type, ids_type, transform >
 Ccid_< 2, cnt_type, ids_type, transform >
 Ccid_< 3, cnt_type, ids_type, transform >
 Ccl_selector_impl
 Ccl_selector_impl< cl_type, 1 >
 Ccl_selector_impl< cl_type, 2 >
 CcombPosition of the element of dimension d in the hyper-cube of dimension dim
 Ccomb< 0 >
 Ccompare_aggregateStructure to compare aggregates
 Ccompare_cpu_encap_encapThis class is a functor for "for_each" algorithm
 Ccompare_fusion_vectorThis class is a functor for "for_each" algorithm
 Ccompare_generalStructure to copy aggregates
 Ccompare_general< T, 0 >
 Ccompare_general< T, 2 >
 Ccompare_host_device
 Ccompare_host_device< base_type[N1], prp >
 Ccompare_host_device< base_type[N1][N2], prp >
 Ccompare_host_device< Point< N1, base_type >, prp >
 CComposeArrayType
 CComposeArrayType< BaseType[N1]>
 CComposeArrayType< BaseType[N1][N2]>
 Cconditional_pushPush p_ele into v only of to_push is true
 Cconditional_push< v, p_ele, false >Push p_ele into v only of to_push is true
 Cconst_mul_functor_valueMultiplication expression
 CConstField
 Cconstruct_expression
 Cconstruct_expression< double >Construct a vector expression from a double
 Cconstruct_expression< float >Construct a vector expression from a float
 CConv3x3x3
 CConv3x3x3_noshared
 Cconv_coeff
 Cconv_impl
 Cconv_impl< 3 >
 CConv_tol_changeOptional convergence criterium checking the total change
 CConv_tol_residualOptional convergence criterium checking the residual
 CconvertSet a conversion map between A and B
 Cconvert< std::string >Partial specialization when A is a string
 Ccopy_accThis class is a functor for "for_each" algorithm
 Ccopy_aggregateStructure to copy aggregates
 Ccopy_aggregate_dualStructure to copy aggregates
 Ccopy_aggregate_opStructure to copy aggregates applying an operation
 Ccopy_all_prop_sparse
 Ccopy_bck
 Ccopy_corner_3Copy point in 3D
 Ccopy_corner_3< layout_type, prop, 1, chunking, is_cross >Copy point in 3D
 Ccopy_corner_3< layout_type, prop, stencil_size, chunking, true >Copy point in 3D
 Ccopy_cpu_encapThis class is a functor for "for_each" algorithm
 Ccopy_cpu_encap_encapThis class is a functor for "for_each" algorithm
 Ccopy_cpu_encap_encap_generalThis class is a functor for "for_each" algorithm
 Ccopy_cpu_encap_encap_op_prpIt copy two encap object
 Ccopy_cpu_encap_encap_prpThis class is a functor for "for_each" algorithm
 Ccopy_cpu_encap_singleThis class is a functor for "for_each" algorithm
 Ccopy_eleThis class is a functor for "for_each" algorithm
 Ccopy_ele_sca_arrayCopy scalar elements
 Ccopy_ele_sca_array< copy_type, T, Ev, Eqs_sys, 1 >Copy 1D array elements
 Ccopy_encap_vector_fusionThis class is a functor for "for_each" algorithm
 Ccopy_fast_1d_device_memoryThis class is a functor for "for_each" algorithm
 Ccopy_fast_1d_device_memory< true, data_type, S >This class is a functor for "for_each" algorithm
 Ccopy_fusion_vectorThis class is a functor for "for_each" algorithm
 Ccopy_fusion_vector_encapThis class is a functor for "for_each" algorithm
 Ccopy_generalStructure to copy aggregates
 Ccopy_general< T, 1 >Specialization for if dst type is copy assignable from src type
 Ccopy_general< T, 2 >Specialization for aggregate type object
 Ccopy_general< T, 3 >Specialization for aggregate type object that define an operator=
 Ccopy_general_opStructure to copy aggregates applying an operation
 Ccopy_general_op< op, T, 1 >Specialization for object that can be assigned with an operator copy
 Ccopy_general_op< op, T, 3 >Specialization for aggregate type objects
 Ccopy_grid_fastThis is a way to quickly copy a grid into another grid
 Ccopy_grid_fast< false, 2, grid, ginfo >This is a way to quickly copy a grid into another grid
 Ccopy_grid_fast< false, 3, grid, ginfo >This is a way to quickly copy a grid into another grid
 Ccopy_grid_fast< true, 1, grid, ginfo >This is a way to quickly copy a grid into another grid
 Ccopy_grid_fast< true, 2, grid, ginfo >This is a way to quickly copy a grid into another grid
 Ccopy_grid_fast< true, 3, grid, ginfo >This is a way to quickly copy a grid into another grid
 Ccopy_grid_fast_caller
 Ccopy_grid_fast_caller< index_tuple_sq< prp ... > >
 Ccopy_grid_fast_layout_switch
 Ccopy_grid_fast_layout_switch< true, dim, grid, ginfo >
 Ccopy_ndim_fast_selector
 Ccopy_ndim_fast_selector< 2 >
 Ccopy_ndim_fast_selector< 3 >
 Ccopy_packer_chunkIt copy one element of the chunk for each property
 Ccopy_packer_chunk_arr_impl
 Ccopy_packer_chunk_arr_impl< Timpl[N1]>
 Ccopy_prop_to_vector
 Ccopy_prop_to_vector_block
 Ccopy_prop_to_vector_block_impl
 Ccopy_prop_to_vector_block_impl< copy_type[N1]>
 Ccopy_sparse_to_sparse
 Ccopy_sparse_to_sparse_bb
 Ccopy_sparse_to_sparse_bb_impl
 Ccopy_sparse_to_sparse_bb_impl< T[N1]>
 Ccopy_sparse_to_sparse_bb_impl< T[N1][N2]>
 Ccopy_sparse_to_sparse_op
 Ccopy_switch_memory_c_no_cpyThis class is a functor for "for_each" algorithm
 Ccopy_szThis class is a functor for "for_each" algorithm
 Ccopy_unpacker_chunkIt copy one element of the chunk for each property
 Ccopy_x_3Copy x edge in 3D
 Ccopy_x_3< layout_type, prop, 1, chunking, is_cross >Copy x edge in 3D
 Ccopy_x_3< layout_type, prop, stencil_size, chunking, true >Copy x edge in 3D
 Ccopy_xy_3Copy XY surface in 3D
 Ccopy_xy_3< 1, prop, stencil_size, chunking, is_cross >Copy XY surface in 3D
 Ccopy_xyzCopy block in 3D
 Ccopy_xyz< 1, prop, stencil_size, chunking, is_cross >Copy block in 3D vectorized
 Ccopy_xz_3Copy XZ surface in 3D
 Ccopy_xz_3< layout_type, prop, 1, chunking, is_cross >Copy XZ surface in 3D
 Ccopy_y_3Copy y edge in 3D
 Ccopy_y_3< layout_type, prop, 1, chunking, is_cross >Copy y edge in 3D
 Ccopy_y_3< layout_type, prop, stencil_size, chunking, true >Copy y edge in 3D
 Ccopy_yz_3Copy YZ surface in 3D
 Ccopy_yz_3< layout_type, prop, 1, chunking, is_cross >Copy YZ surface in 3D
 Ccopy_z_3Copy z edge in 3D
 Ccopy_z_3< layout_type, prop, 1, chunking, is_cross >Copy z edge in 3D
 Ccopy_z_3< layout_type, prop, stencil_size, chunking, true >Copy z edge in 3D
 Ccp_block
 Ccp_block< T, stencil_size, vector_vmpl, 2 >
 Ccp_block< T, stencil_size, vector_vmpl, 3 >
 Ccp_block_base
 Ccross_stencil
 Ccross_stencil_v
 Ccsv_colThis class is a functor for "for_each" algorithm
 Ccsv_col< Tobj, false >This class is a functor for "for_each" algorithm
 Ccsv_col_strThis class is an helper to produce csv headers from multi-array
 Ccsv_col_str< T[N1]>Partial specialization for N=1 1D-Array
 Ccsv_col_str< T[N1][N2]>Partial specialization for N=2 2D-Array
 Ccsv_col_str< T[N1][N2][N3]>Partial specialization for N=3
 Ccsv_col_str< T[N1][N2][N3][N4]>Partial specialization for N=4
 Ccsv_prpThis class is a functor for "for_each" algorithm
 Ccsv_value_strThis class is an helper to produce csv data from multi-array
 Ccsv_value_str< T, false >Partial specialization for unknown property
 Ccsv_value_str< T[N1], is_writable >Partial specialization for N=1 1D-Array
 Ccsv_value_str< T[N1][N2], is_writable >Partial specialization for N=2 2D-Array
 Ccsv_value_str< T[N1][N2][N3], is_writable >Partial specialization for N=3
 Ccsv_value_str< T[N1][N2][N3][N4], is_writable >Partial specialization for N=4
 CCSVWriterCSV Writer
 Cct_par
 CCudaMemory
 CcvalIt store the non zero elements of the matrix
 CDDerivative second order on h (spacing)
 CD< d, arg, Sys_eqs, BACKWARD >First order BACKWARD derivative on direction i
 CD< d, arg, Sys_eqs, CENTRAL >Second order central Derivative scheme on direction i
 CD< d, arg, Sys_eqs, CENTRAL_B_ONE_SIDE >Second order one sided Derivative scheme on direction i
 CD< d, arg, Sys_eqs, FORWARD >First order FORWARD derivative on direction i
 Cdata_il
 Cdata_il< 1 >
 Cdata_il< 2 >
 Cdata_il< 4 >
 Cdata_il< 8 >
 Cdata_ptr_fill
 CDataBlock
 CdataDivClass that store Internal part external and border part of a dataset
 CDcpseDiagonalScalingMatrix
 CDcpseRhs
 CDEBUG
 CDebug
 CDEBUG< float & >
 Cdec_optimizerThis class take a graph representing the space decomposition and produce a simplified version
 CDecompositionThis class define the domain decomposition interface
 CDecomposition_encap
 Cdeconstruct_implThis class is a functor for "for_each" algorithm
 Cdecrement_memory
 Cdefault_chunking
 Cdefault_chunking< 1 >
 Cdefault_chunking< 2 >
 Cdefault_chunking< 3 >
 Cdefault_chunking< 4 >
 Cdefault_chunking< 5 >
 Cdefault_chunking< 6 >
 Cdefault_chunking< 7 >
 Cdefault_chunking< 8 >
 Cdefault_edge
 Cdefault_edge< 1 >
 Cdefault_edge< 2 >
 Cdefault_edge< 3 >
 Cdevice_grid
 Cdevice_grid_copy
 Cdevice_grid_copy< true >
 Cdevice_to_host_implThis class is a functor for "for_each" algorithm
 Cdevice_to_host_start_stop_implThis class is a functor for "for_each" algorithm
 Cdim3_
 Cdist_prop_out_edgeThis class is a functor for "for_each" algorithm
 Cdist_prop_out_vertexThis class is a functor for "for_each" algorithm
 Cdist_prop_outputThis class specialize functions in the case the type T has or not defined attributes
 Cdist_prop_output< false, Graph, i >This class specialize functions in the case the type T has not defined attributes
 Cdist_prop_output_array_scalar_selector_edgeProperty writer for scalar and vector
 Cdist_prop_output_array_scalar_selector_edge< true >Property writer for vector
 Cdist_prop_output_array_scalar_selector_edge_fill_vertexProperty writer for scalar and vector, it fill the vertex data (needed for edge representation in vtk)
 Cdist_prop_output_array_scalar_selector_edge_fill_vertex< true >Property writer for vector
 Cdist_prop_output_array_scalar_selector_vertexProperty writer for scalar and vector
 Cdist_prop_output_array_scalar_selector_vertex< true >Property writer for vector
 CDistFromSolBundles total residual and total change over all the grid points
 CDistGraph_constr_implGraph constructor function specialization
 CDistGraph_constr_impl< dim, Graph, NO_EDGE, T, dim_c, pos... >Graph constructor function specialization
 ►CDistGraph_CSRStructure that store a graph in CSR format or basically in compressed adjacency matrix format
 CDistGraph_CSR_sSimplified implementation of DistGraph_CSR
 CDistGraphFactoryThis class construct a cartesian graph
 CDistParmetisHelper class to define Metis graph
 CDistParMetisDistribution
 CDLB
 Cdo_not_print_warning_on_adjustment
 Cdo_when_dim_gr_iThis structure use SFINAE to avoid instantiation of invalid code
 Cdo_when_dim_gr_i< dim, i, ORB, typename boost::enable_if< boost::mpl::bool_<(i< dim)> >::type >
 Cdomain_icell_calculator
 Cdomain_nn_calculator_cartThis class calculate processor domains and neighborhood of each processor domain
 CDrawParticlesA class to draw/create particles based on simple shaped
 Ce_box_idIt store the information about the external ghost box
 Ce_box_multiFor each external ghost id, it contain a set of sub-domain at which this external box is linked
 Ce_info
 Ce_lbox_gridPer-processor external ghost box
 Ce_lbox_idIt store the information about the local external ghost box
 Ce_mapStructure used inside GraphCSR an edge
 CE_pEdge class that encapsulate an object T
 ►Ced
 Cedge_iteratorGraph edge iterator
 Cedge_key
 Cedge_nodeThis class is a functor for "for_each" algorithm
 Cedge_propThis class is a functor for "for_each" algorithm
 Cele
 Cele_gIt store one grid
 Cele_g_stConvert a staggered element into a string for vtk write
 Cele_vppStore a reference to the vector properties
 Cele_vpsStore a reference to the vector position
 CEllipseParameters
 Cenc_num
 Cencap_data_block
 Cencap_shmemMemcpy it split the copy across threads
 Cencapc
 Cencapc< dim, T, typename memory_traits_inte< T >::type >This structure encapsulate an object of the grid
 Cencapc< dim, T, typename memory_traits_lin< T >::type >This structure encapsulate an object of the grid
 Cencapc< dim, void, Mem >This structure specialize the class for a void object or null
 Cencapsulated_type
 Cep_box_gridPer-processor external ghost box
 CEqEquation
 Ceq_id
 Cequations2d1Specify the general characteristic of system to solve
 Cequations2d1_stagSpecify the general characteristic of system to solve
 Cequations2d1ESpecify the general characteristic of system to solve
 Cequations2d1p
 Cequations2d1pE
 Cequations2d2
 Cequations2d2E
 Cequations2d2p
 Cequations2d2pE
 Cequations2d3
 Cequations2d3E
 Cequations2d3p
 Cequations2d3pE
 Cequations2d4
 Cequations2d4E
 Cequations3d1
 Cequations3d1E
 Cequations3d1EPxy
 Cequations3d1Pxy
 Cequations3d1Pz
 Cequations3d3
 Cequations3d3E
 Cequations3d3EPxz
 Cequations3d3EPz
 Cequations3d3Pxz
 Cequations3d3Pyz
 Cequations3d3Pz
 CErrorOut-of-bound policy kill the program
 Ceta[Definition of the system]
 Cexecute_cl_test
 Cexecute_cl_test< 1 >
 Cexecute_cl_test< 2 >
 Cexist_sub_v_impl
 Cexist_sub_v_impl< 2 >
 Cexist_sub_v_impl< 4 >
 Cexist_sub_v_impl< 8 >
 Cexit_implExit condition
 Cexit_impl_sqExit condition
 Cexp_kernelExponential kernel
 CextendsClasses to get the number of components of the properties
 Cextends< T[N1]>Partial specialization for N=1 1D-Array
 Cextends< T[N1][N2]>Partial specialization for N=2 2D-Array
 Cextends< T[N1][N2][N3]>Partial specialization for N=3
 Cextends< T[N1][N2][N3][N4]>Partial specialization for N=4
 Cextends< T[N1][N2][N3][N4][N5]>Partial specialization for N=5
 Cextends< T[N1][N2][N3][N4][N5][N6]>Partial specialization for N=6
 Cextends< T[N1][N2][N3][N4][N5][N6][N7]>Partial specialization for N=7
 Cextends< T[N1][N2][N3][N4][N5][N6][N7][N8]>Partial specialization for N=8
 Cextends< T[N1][N2][N3][N4][N5][N6][N7][N8][N9]>Partial specialization for N=9
 Cextends< T[N1][N2][N3][N4][N5][N6][N7][N8][N9][N10]>Partial specialization for N=10
 CExtPreAlloc
 CF[v_transform metafunction]
 ►CFD_schemeFinite Differences
 ►CFDSchemeFinite Differences
 CField
 Cfill_idOperator to fill the property 'prp' with the linearization of indexes
 Cfill_id< dim, G_v, NO_VERTEX_ID >Operator to fill the property in case there are no properties
 CFill_one{1,1,1,1,....}
 Cfill_propThis class work as a functor
 Cfill_prop< dim, lin_id, dT, G_v, v, 0 >This class work as a functor
 Cfill_prop< dim, lin_id, dT, G_v, v, 2 >This class work as a functor
 Cfill_prop_by_typeOperator for vector and scalar property
 Cfill_prop_by_type< dim, 0, p, Graph, pos... >Operator for vector and scalar property in the case there are no properties
 Cfill_prop_vThis class work as a functor
 Cfill_prop_v< dim, dT, G_v, v, 0 >This class work as a functor
 Cfill_prop_v< dim, dT, G_v, v, 2 >This class work as a functor
 Cfill_prop_v_by_typeOperator for vector and scalar property
 Cfill_prop_v_by_type< 0, p, Graph, pos... >Operator for vector and scalar property in the case there are no properties
 CFill_threeCompile time array functor needed to generate array at compile-time of type
 CFill_two{2,2,2,2,....}
 CFill_zero{0,0,0,0,....}
 Cfirst_or_second
 Cfirst_or_second< true, exp1, exp2 >
 Cfirst_or_second_pt
 Cfirst_or_second_pt< true, exp1, exp2 >
 Cfirst_variadic
 CFitz
 CfrswapThis class is a functor for "for_each" algorithm
 Cfrswap_nomodeThis class is a functor for "for_each" algorithm
 CFt_chunkTransform T=aggregate<float,double,int> into aggregate<std::array<float,n_ele>,std::array<double,n_ele>,std::array<int,n_ele>>
 CFt_chunk< n_ele, const T(&)[N1]>Special case for vector
 CFtwo[v_transform metafunction]
 Cfunction
 CGaussianDLB
 CGBoxesThis structure store the Box that define the domain inside the Ghost + domain box
 CgclGeneral function t get a cell-list
 Cgcl< dim, St, CellL, Vector, GCL_HILBERT >General function t get a cell-list
 Cgcl< dim, St, CellL, Vector, GCL_SYMMETRIC >General function t get a cell-list
 Cgcl_AnGeneral function t get a cell-list
 Cgcl_standard_no_symmetric_impl
 Cgcl_standard_no_symmetric_impl< true, prp... >
 CGCoptionsGoogle chart options
 CgeneralDimensionFunctor
 CgeneralDimensionFunctor< T1[N1]>
 Cgenerate_arrayMain class to generate compile-time array
 Cgenerate_array_constexprMain class to generate constexpr compile-time array
 Cgenerate_array_constexpr_implRecursive meta-function to generate compile-time array
 Cgenerate_array_constexpr_impl< T, 0, orig_N, F, args... >Terminator of the variadic template
 Cgenerate_array_implGenerate the array specializing ArrayHolder
 Cgenerate_array_impl< T, 0, orig_N, F, args... >Terminator of the variadic template
 Cgenerate_array_vectorMain class to generate an array from a boost::mpl::vector of numbers
 Cgenerate_array_vector_implGenerate the array specializing ArrayHolder
 Cgenerate_array_vector_impl< T, 0, F, args... >Terminator of the variadic template
 Cgenerate_indexesMain class to generate indexes data structure
 Cgenerate_indexes_implGenerate compile time index array
 Cgenerate_indexes_impl< T, 0, orig_N, F, args... >Terminator of the variadic template
 Cgenerate_indexes_impl< T,-1, orig_N, F, args... >In case of an empty list
 Cger
 Cget_base_type_for_object_creator_chunking
 Cget_base_type_for_object_creator_chunking< std::array< T, N2 >[N1] >
 Cget_block_sizesThis class is a functor for "for_each" algorithm
 Cget_pointer
 Cget_pointer< 1, prp, grid_type >
 Cget_pointer< 2, prp, grid_type >
 Cget_pointer_unpack
 Cget_pointer_unpack< T, true >
 Cget_selector
 Cget_selector< T[N1]>
 Cget_striding
 Cget_vcl
 Cget_vcl< CudaMemory >
 Cget_vector_dist_expression_op
 Cget_vector_dist_expression_op< 1, false >
 Cget_vector_dist_expression_op< 1, true >
 Cget_vector_dist_expression_op< 2, true >
 CGetAddBlockTypeGet the type of the insertBlock
 CgetAttrNameReturn the Attributes name from the type
 CgetAttrName< ele_g, false >Return the Attributes name from the type
 CGetCpBlockTypeGet the type of the block
 CGetSetBlockTypeGet the type of the SetBlock
 CGGraphGoogle Graph
 CGhost
 Cghost_exchange_comm_implTemplate selector for asynchronous or not asynchronous
 Cghost_exchange_comm_impl< GHOST_ASYNC, layout_base, prp ... >
 Cgid
 ►CGoogleChartSmall class to produce graph with Google chart in HTML
 CGraph_constructor_implGraph constructor function specialization
 CGraph_constructor_impl< dim, lin_id, Graph, NO_EDGE, T, dim_c, pos... >Graph constructor function specialization
 CGraph_CSRStructure that store a graph in CSR format or basically in compressed adjacency matrix format
 CGraph_CSR_sSimplified implementation of Graph_CSR
 CGraphMLWriter
 Cgrid
 Cgrid_base
 Cgrid_base< dim, T, S, typename memory_traits_inte< T >::type, linearizer >This is an N-dimensional grid or an N-dimensional array with memory_traits_inte layout
 Cgrid_base< dim, T, S, typename memory_traits_lin< T >::type, linearizer >This is an N-dimensional grid or an N-dimensional array with memory_traits_lin layout
 Cgrid_base_implImplementation of a N-dimensional grid
 Cgrid_call_serialize_variadicUnpack selector
 Cgrid_call_serialize_variadic< device_grid, Memory, index_tuple< prp... > >Unpack selector
 Cgrid_dist_amr
 Cgrid_dist_amr< dim, St, T, AMR_IMPL_TRIVIAL, Decomposition, Memory, device_grid >AMR Adaptive Multi Resolution Grid
 Cgrid_dist_amr_keyAmr grid distributed key
 ►Cgrid_dist_amr_key_iterator
 Cgrid_dist_g_dxDistributed linearized key
 Cgrid_dist_idThis is a distributed grid
 ►Cgrid_dist_id_commThis class is an helper for the communication of grid_dist_id
 Cgrid_dist_id_iterator_decGiven the decomposition it create an iterator
 ►Cgrid_dist_id_iterator_dec_skinGiven the decomposition it create an iterator
 Cgrid_dist_id_iterator_gpuGiven the decomposition it create an iterator
 Cgrid_dist_iteratorDistributed grid iterator
 ►Cgrid_dist_iterator_subDistributed grid iterator
 Cgrid_dist_key_dxGrid key for a distributed grid
 Cgrid_dist_lin_dxDistributed linearized key
 Cgrid_dist_testing
 Cgrid_gpu_kerGrid interface available when on gpu
 Cgrid_gpu_ker_constructor_impl
 Cgrid_gpu_ker_constructor_impl< false, T >
 Cgrid_gpu_ker_ref
 Cgrid_key
 Cgrid_key_1
 Cgrid_key_2
 Cgrid_key_3
 Cgrid_key_4
 Cgrid_key_c3
 Cgrid_key_dGrid_key_d is the key to access any element in the grid
 Cgrid_key_dxGrid_key_dx is the key to access any element in the grid
 Cgrid_key_dx_expressionExpression template for grid_key_dx
 Cgrid_key_dx_iterator
 Cgrid_key_dx_iterator_hilbert
 Cgrid_key_dx_iterator_sp
 Cgrid_key_dx_iterator_subDeclaration grid_key_dx_iterator_sub
 Cgrid_key_dx_iterator_sub< 0, warn >
 Cgrid_key_dx_iterator_sub_bcThe same as grid_key_dx_iterator_sub_p but with periodic boundary
 Cgrid_key_dx_rEmulate grid_key_dx with runtime dimensionality
 Cgrid_key_dx_subMain class that encapsulate a sub expression
 Cgrid_key_dx_sumMain class that encapsulate a sum expression
 Cgrid_key_sparse_dx_iteratorGrid key sparse iterator
 Cgrid_key_sparse_dx_iterator_subGrid key sparse iterator on a sub-part of the domain
 Cgrid_key_sparse_lin_dxIt store the position in space of the sparse grid
 Cgrid_skin_iterator_bc
 Cgrid_smDeclaration grid_sm
 Cgrid_smb
 Cgrid_toKernelImpl
 Cgrid_toKernelImpl< true, base_grid, dim, T >
 Cgrid_unpack_selector_with_prpUnpack selector
 Cgrid_unpack_selector_with_prp< true, T, device_grid, Memory >Unpack selector
 Cgrid_unpack_with_prpUnpack selector
 Cgrid_zmClass that store the information of the grid like number of point on each direction and define the index linearization by stride
 Cgrid_zmb
 CGridRawReader
 CH5_prop_outThis class is a functor for "for_each" algorithm
 CH5_prop_out< ele_v, false >This class is a functor for "for_each" algorithm
 CH5_writeWrite an HDF5 dataset in case of scalars and vectors
 CH5_write< T[N1], pid, V >Partial specialization for N=1 1D-Array
 CH5_write< T[N1][N2], pid, V >Partial specialization for N=2 2D-Array
 CH5_write< T[N1][N2][N3], pid, V >Partial specialization for N=3
 CH5_write< T[N1][N2][N3][N4], pid, V >Partial specialization for N=4
 Chas_attributes
 Chas_attributes< T, typename Void< decltype(T::attributes::name[0])>::type >Has_attributes check if a type has defined an internal structure with attributes
 Chas_base_to_copy
 Chas_base_to_copy< T, typename Void< typename T::base_to_copy >::type >Has_data check if a type has defined a member data
 Chas_check_device_pointer
 Chas_check_device_pointer< T, typename Void_dev< typename T::yes_has_check_device_pointer >::type >Has_check_device_pointer check if a type has defined a member yes_has_check_device_pointer
 Chas_coordtype
 Chas_coordtype< T, typename Void< typename T::coord_type >::type >Has_data check if a type has defined a member data
 Chas_data
 Chas_data< T, typename Void< decltype(T::data)>::type >Has_data check if a type has defined a member data
 Chas_getGrid
 Chas_getGrid< T, typename Void< decltype(std::declval< T >().getGrid())>::type >
 Chas_grid_type
 Chas_grid_type< T, typename Void< decltype(T::grid_type)>::type >Has_grid_type check if T has defined the member grid_type
 Chas_initHas_init check if a type has defined a method called init
 Chas_init< ObjType, typename Void< typename ObjType::has_init >::type >
 Chas_max_prop
 Chas_max_prop< T, false >
 Chas_max_prop_nn
 Chas_max_prop_nn< T, typename Void< decltype(T::max_prop)>::type >Has_max_prop check if a type has defined a member max_prop
 Chas_noPointers
 Chas_noPointers< T, typename Void< decltype(T::noPointers())>::type >Has_noPointers check if a type has defined a method called noPointers
 Chas_packHas_Pack check if a type has defined a method called Pack
 Chas_pack< ObjType, typename Void< decltype(ObjType::pack())>::type >
 Chas_pack_aggReturn if true the aggregate type T has a property that has a complex packing(serialization) method
 Chas_pack_agg_implGenerate the array specializing ArrayHolder
 Chas_pack_agg_impl< T, 0, result_p, vprp >Terminator of the variadic template
 Chas_pack_encap
 Chas_pack_genIt return true if the object T require complex serialization
 Chas_pack_gen< T, false >It return true if the object T require complex serialization
 Chas_packMemHas_calculateMem check if a type has defined a method called calculateMem
 Chas_packMem< ObjType, typename Void< decltype(ObjType::packMem())>::type >Has_PackMem check if a type has packMem() member function
 Chas_packRequestHas_packRequest check if a type has defined a method called packRequest
 Chas_packRequest< ObjType, typename Void< decltype(ObjType::packRequest())>::type >
 Chas_posMask
 Chas_posMask< T, typename Void< decltype(T::stag_mask)>::type >Has_posMask check if a type has defined a member stag_mask
 Chas_set_d
 Chas_set_d< T, typename Void< decltype(std::declval< T >().set_d(0, 0))>::type >Has_move check if a type has defined a method function move
 Chas_state_vector
 Chas_state_vector< T, typename Void< typename T::is_state_vector >::type >
 Chas_toKernelHas_toKernel check if a type has defined a method called toKernel
 Chas_toKernel< ObjType, typename Void< decltype(std::declval< ObjType >().toKernel())>::type >
 Chas_typedef_type
 Chas_typedef_type< T, typename Void< typename T::type >::type >Has_typedef_type check if a typedef ... type inside the structure is defined
 Chas_valEvaluate the constant field function
 Chas_val< HAS_VAL, T >Evaluate the constant field function
 Chas_val_pos
 Chas_val_pos< T, typename Void< typename T::with_position >::type >Has_attributes check if a type has defined an internal structure with attributes
 Chas_value_type_ofp
 Chas_value_type_ofp< T, typename Void< typename T::value_type >::type >Has_value_type_ofp check if a type has defined a member value_type
 Chas_vector_kernel
 Chas_vector_kernel< T, typename Void< typename T::vector_kernel >::type >Has_vector_kernel check if a type has defined a member data
 Chas_vtype
 Chas_vtype< T, typename Void< typename T::vtype >::type >Has_data check if a type has defined a member data
 CHDF5_reader
 CHDF5_reader< GRID_DIST >
 CHDF5_reader< VECTOR_DIST >
 CHDF5_writer
 CHDF5_writer< GRID_DIST >
 CHDF5_writer< VECTOR_DIST >
 CHDF5_XdmfWriter
 CHDF5_XdmfWriter< H5_POINTSET >HDF5 writer for a point set
 CHeapMemoryThis class allocate, and destroy CPU memory
 CHeatStencil
 CHeatStencilGet
 Chost_to_dev_all_prpThis class is a functor for "for_each" algorithm
 Chost_to_device_implThis class is a functor for "for_each" algorithm
 CHyperCubeThis class calculate elements of the hyper-cube
 Ci_box_idIt store a box, its unique id and the sub-domain from where it come from
 Ci_lbox_gridLocal Internal ghost box
 Ci_lbox_idIt store an internal ghost box, the linked external ghost box and the sub-domain from where it come from as internal ghost box
 Cibox_sendSet of internal ghost box to send
 CID_operation
 Cids_crs
 Cids_pl
 Cie_ghostStructure that store and compute the internal and external local ghost box
 Cie_ghost_gpuStructure that store and compute the internal and external local ghost box. Version usable in kernel
 Cie_loc_ghostStructure that store and compute the internal and external local ghost box
 Cindex_tupleThese set of classes generate an array definition at compile-time
 Cindex_tuple_sq
 Cinit_propThis class is a functor for "for_each" algorithm
 Cinsert_kernel2D
 Cinsert_kernel3D
 CInsertBlockWrapper
 Cinte_calc_implCalculate the interpolation for one point
 Cinte_templateClass that select the operation to do differently if we are doing Mesh to particle (m2p) or particle to mesh (p2m)
 Cinte_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)
 Cinter_memcThis class convert a boost::mpl::fusion/vector to a boost::mpl::fusion/vector with memory_c interleaved
 Cinter_memc_redThis class convert a boost::mpl::fusion/vector to a boost::mpl::fusion/vector with memory_c<.....,MEMORY_C_REDUCED> interleaved
 Cinterp_eleThis class is a functor for "for_each" algorithm
 Cinterp_ele_sca_arrayAdd scalar elements
 Cinterp_ele_sca_array< copy_type, Tsrc, Tdst, Grid_src, Grid_dst, 1 >Add 1D array elements
 Cinterp_pointsThis class is a functor for "for_each" algorithm
 ►CinterpolateMain class for interpolation Particle to mest p2m and Mesh to particle m2p
 CIntPow
 CIntPow< base, 0 >
 Cip_box_gridPer-processor Internal ghost box
 Cis_aggregate
 Cis_aggregate< T, typename Void< typename T::yes_is_aggregate >::type >Check if a type T is an aggregate
 Cis_Box
 Cis_Box< T, typename Void< typename T::yes_is_box >::type >Check if a type T is an aggregate
 Cis_complex_aggReturn if true the aggregate type T has a property that has a complex packing(serialization) method
 Cis_complex_agg_implThese set of classes generate an array definition at compile-time
 Cis_complex_agg_impl< T, 0, result_p, vprp >Terminator of the variadic template
 Cis_const_field
 Cis_const_field< T, typename Void< typename T::const_field >::type >Is_constant check if a type define a constant field
 Cis_contiguos
 Cis_csv_writableIndicate if the property T is writable in CSV
 Cis_csv_writable< bool >Indicate if the property T is writable in CSV
 Cis_csv_writable< char >Indicate if the property T is writable in CSV
 Cis_csv_writable< double >Indicate if the property T is writable in CSV
 Cis_csv_writable< float >Indicate if the property T is writable in CSV
 Cis_csv_writable< int >Indicate if the property T is writable in CSV
 Cis_csv_writable< long int >Indicate if the property T is writable in CSV
 Cis_csv_writable< short >Indicate if the property T is writable in CSV
 Cis_csv_writable< T[N1]>Indicate if the property T is writable in CSV
 Cis_csv_writable< T[N1][N2]>Indicate if the property T is writable in CSV
 Cis_csv_writable< T[N1][N2][N3]>Indicate if the property T is writable in CSV
 Cis_csv_writable< unsigned char >Indicate if the property T is writable in CSV
 Cis_csv_writable< unsigned int >Indicate if the property T is writable in CSV
 Cis_csv_writable< unsigned long int >Indicate if the property T is writable in CSV
 Cis_csv_writable< unsigned short >Indicate if the property T is writable in CSV
 Cis_custom_vtk_writableIt check if the type is vtk writable
 Cis_custom_vtk_writable< ObjType, typename Void< typename ObjType::is_vtk_writable >::type >It check if the type is vtk writable
 Cis_encap
 Cis_encap< T, typename Void< typename T::yes_i_am_encap >::type >Is_encap check if the type is an encap type
 Cis_expressionIs_expression check if a type is simple a type or is just an encapsulation of an expression
 Cis_expression< ObjType, typename Void< typename ObjType::is_expression >::type >
 Cis_gpu_celllistCheck this is a gpu or cpu type cell-list
 Cis_gpu_celllist< T, typename Void< typename T::yes_is_gpu_celllist >::type >
 Cis_gpu_ker_celllistCheck this is a gpu or cpu type cell-list
 Cis_gpu_ker_celllist< T, typename Void< typename T::yes_is_gpu_ker_celllist >::type >
 Cis_grid
 Cis_grid< T, typename Void< typename T::yes_i_am_grid >::type >Is_grid check if the type is a grid
 Cis_grid_staggeredIs_grid_staggered analyse T if it has a property grid_type defined and indicate that the grid is staggered
 Cis_grid_staggered< T, false >Is_grid_staggered analyse T if it has a property that define the type of grid
 Cis_initializedInitialized
 Cis_initialized< openfpm::vector< T > >Initialized
 Cis_layout_inte
 Cis_layout_inte< T, typename Void< typename T::yes_is_inte >::type >Is_layout_inte
 Cis_layout_mlin
 Cis_layout_mlin< T, typename Void< typename T::yes_is_tlin >::type >Is_layout_mlin
 Cis_multiple_buffer_each_prpIs_multiple_buffer_each_prp
 Cis_multiple_buffer_each_prp< T, true >
 Cis_openfpm_nativeIs_openfpm_native check if a type is an openfpm native structure type
 Cis_openfpm_native< T, true >
 Cis_Point
 Cis_Point< T, typename Void< typename T::yes_is_point >::type >Check if a type T is an aggregate
 Cis_testing
 Cis_testing< T, typename Void< typename T::testing >::type >Is_testing check if a struct T has testing member defined
 Cis_typedef_and_data_sameCheck if T::type and T.data has the same type
 Cis_typedef_and_data_same< false, T >
 Cis_typedef_and_data_same< true, SpaceBox< dim, St > >
 Cis_typedef_and_data_same< true, wavefront< dim > >
 Cis_vector
 Cis_vector< T, typename Void< typename T::yes_i_am_vector >::type >Is_grid check if the type is a vector
 Cis_vector_dist
 Cis_vector_dist< T, typename Void< typename T::yes_i_am_vector_dist >::type >Is_grid check if the type is a vector
 Cis_vector_native
 Cis_vector_native< T, typename Void< typename std::remove_reference< T >::type::yes_i_am_vector_native >::type >Is_grid check if the type is a vector
 Cis_vtk_vector_dimsIt check if the type is vtk writable
 Cis_vtk_vector_dims< ObjType, typename Void< decltype(ObjType::dims) >::type >It check if the type is vtk writable
 Cis_vtk_writableCheck for T to be writable
 Cis_vtk_writable< bool >Check bool
 Cis_vtk_writable< char >Check char
 Cis_vtk_writable< double >Check double
 Cis_vtk_writable< float >Check float
 Cis_vtk_writable< int >Check int
 Cis_vtk_writable< long int >Check long int
 Cis_vtk_writable< short >Check short
 Cis_vtk_writable< unsigned char >Check unsigned char
 Cis_vtk_writable< unsigned int >Check unsigned int
 Cis_vtk_writable< unsigned long int >Check unsigned long int
 Cis_vtk_writable< unsigned short >Check unsigned short
 CisDynStruct
 CisDynStruct< ObjType, typename Void< decltype(ObjType::isCompressed())>::type >
 Cite_g
 Cite_gpu
 CIterator_g_const
 Ckey_equalStructure required for the Sph Harmonic amplitude dictionary arguments
 Ckey_hashStructure required for the Sph Harmonic amplitude dictionary arguments
 Ckey_int
 Ckey_shift
 Ckey_shift< 1, chunk >
 Ckey_shift< 2, chunk >
 Ckey_shift< 3, chunk >
 Ckey_shift< 4, chunk >
 Ckey_shift< 5, chunk >
 Ckey_shift< 6, chunk >
 Ckey_shift< 7, chunk >
 Ckey_shift< 8, chunk >
 CKillParticleOut of bound policy it detect out of bound particles and decide what to do
 CKillParticleWithWarningOut-of-bound policy kill the particle but print a warning
 Ckl_selector_impl
 Ckl_selector_impl< kl_type, cl_type, 1 >
 Ckl_selector_impl< kl_type, cl_type, 2 >
 CL_norms
 ClabelParticlesGhost_impl
 ClabelParticlesGhost_impl< dim, St, prop, Memory, layout_base, Decomposition, true >
 Clambda2_2kernel
 Clambda4_4kernel
 CLapLaplacian second order on h (spacing)
 CLap< arg, Sys_eqs, CENTRAL >Laplacian second order approximation CENTRAL Scheme
 CLap< arg, Sys_eqs, CENTRAL_SYM >Laplacian second order approximation CENTRAL Scheme (with central derivative in the single)
 CLap_PSEImplementation of the Laplacian kernels for PSE
 CLap_PSE< 1, T, 2, KER_GAUSSIAN >
 CLap_PSE< 1, T, 4, KER_GAUSSIAN >
 CLap_PSE< 1, T, 6, KER_GAUSSIAN >
 CLap_PSE< 1, T, 8, KER_GAUSSIAN >
 CLaplacianStencil
 Clast_variadic
 Clast_variadic< T1 >
 CLastPOf
 Claunch_call_impl
 Claunch_call_impl< 1 >
 Claunch_insert_sparse
 Claunch_insert_sparse_lambda_call
 Claunch_insert_sparse_lambda_call< 2 >
 Claunch_insert_sparse_lambda_call< 3 >
 Claunch_set_dense
 Claunch_set_dense< 2 >
 Claunch_set_dense< 3 >
 ClBox_domCase for local ghost box
 CleftOperand_t
 Clid
 Clid_nn[Definition of the system]
 Clid_nn_3d_eigenSpecify the general caratteristic of system to solve
 Clid_nn_3d_petsc
 Climit_max_t
 Cln_force
 Cln_potential
 CLNormsClass for computing the l2/l_infinity norm for distributed grids and vectors based on given errors
 Cload_mask_impl
 Cload_mask_impl< 1 >
 Cload_mask_impl< 16 >
 Cload_mask_impl< 2 >
 Cload_mask_impl< 4 >
 Cload_mask_impl< 8 >
 CloadGhostBlock_impl
 CloadGhostBlock_impl< 1, dim, AggregateBlockT, pMask, p, ct_params, blockEdgeSize >
 CloadGhostBlock_impl< 2, dim, AggregateBlockT, pMask, p, ct_params, blockEdgeSize >
 CloadGhostBlock_impl< 3, dim, AggregateBlockT, pMask, p, ct_params, blockEdgeSize >
 CloadGhostBlock_impl< 7, dim, AggregateBlockT, pMask, p, ct_params, blockEdgeSize >
 Clocal_ghost_from_dec_impl
 Clocal_ghost_from_dec_impl< dim, St, prop, Memory, layout_base, true >
 Clocal_ghost_from_opart_impl
 Clocal_ghost_from_opart_impl< with_pos, dim, St, prop, Memory, layout_base, true >
 CMatLabWriterThis class is able to save grid into tiff files
 CMatrixThis class implement an NxN (dense) matrix
 Cmax_This structure define the operation add to use with copy general
 Cmax_prop_nn
 Cmax_prop_nn< T, false >
 CMem_balClass for BALANCED cell list implementation
 CMem_fastIt is a class that work like a vector of vector
 CMem_fast_ker
 Cmem_getoCase memory_traits_lin
 Cmem_geto< dim, T, layout, data_type, g1_type, key_type, 1 >Case memory_traits_inte
 Cmem_getpointer
 Cmem_getpointer< data_type, layout, 1 >
 CMem_mwClass for MEMORY-WISE cell list implementation
 Cmem_referenceMetafunction take T and return a reference
 Cmem_setarrayThis class is a functor for "for_each" algorithm
 Cmem_setextCase memory_traits_lin
 Cmem_setext< grid_type, S, layout, data_type, 1 >Case memory_traits_inte
 Cmem_setext_prpThis class is a functor for "for_each" algorithm
 Cmem_setmCase memory_traits_lin
 Cmem_setm< S, layout, data_type, g1_type, 1 >Case memory_traits_inte
 Cmem_setmemory
 Cmem_setmemory< data_type, Mem_type, layout, 1 >
 Cmem_swapCase memory_traits_lin
 Cmem_swap< T, layout, data_type, grid_type, 1 >Case memory_traits_inte
 Cmemory
 Cmemory_arrayThis class give a representation to a chunk or memory
 Cmemory_c
 ►Cmemory_c< multi_array< T >, MEMORY_C_STANDARD, D >Specialization of memory_c for multi_array
 Cmemory_c< T, MEMORY_C_STANDARD, D >This class is a container for the memory interface like HeapMemory CudaMemory
 Cmemory_thrust_cThis class is a container for the memory interface
 Cmemory_traits_inteTransform the boost::fusion::vector into memory specification (memory_traits)
 Cmemory_traits_linTransform the boost::fusion::vector into memory specification (memory_traits)
 Cmemory_traits_lin_typeTransform the boost::fusion::vector into memory specification (memory_traits)
 Cmemory_traits_lin_type< T, false >Small meta-function to get the type of the memory
 Cmerge_This structure define the operation add to use with copy general
 Cmet_sub_wSub-domain list and weight
 Cmeta_compareThis class compare general objects
 Cmeta_compare< T[N1]>Partial specialization for N=1 1D-Array
 Cmeta_compare< T[N1][N2]>Partial specialization for N=2 2D-Array
 Cmeta_compare< T[N1][N2][N3]>Partial specialization for N=3
 Cmeta_copyThis class copy general objects
 Cmeta_copy< T[N1]>Partial specialization for N=1 1D-Array
 Cmeta_copy< T[N1][N2]>Partial specialization for N=2 2D-Array
 Cmeta_copy< T[N1][N2][N3]>Partial specialization for N=3
 Cmeta_copy< T[N1][N2][N3][N4]>Partial specialization for N=4
 Cmeta_copy< T[N1][N2][N3][N4][N5]>Partial specialization for N=5
 Cmeta_copy< T[N1][N2][N3][N4][N5][N6]>Partial specialization for N=6
 Cmeta_copy< T[N1][N2][N3][N4][N5][N6][N7]>Partial specialization for N=7
 Cmeta_copy< T[N1][N2][N3][N4][N5][N6][N7][N8]>Partial specialization for N=8
 Cmeta_copy< T[N1][N2][N3][N4][N5][N6][N7][N8][N9]>Partial specialization for N=9
 Cmeta_copy< T[N1][N2][N3][N4][N5][N6][N7][N8][N9][N10]>Partial specialization for N=10
 Cmeta_copy_block
 Cmeta_copy_block< copy_type[N1], nprp, prp_val, prp_id >
 Cmeta_copy_block< copy_type[N1][N2], nprp, prp_val, prp_id >
 Cmeta_copy_dCopy for a source object to a destination
 Cmeta_copy_d< Tsrc, Tdst[N1]>Partial specialization for N=1 1D-Array
 Cmeta_copy_d< Tsrc, Tdst[N1][N2]>Partial specialization for N=2 2D-Array
 Cmeta_copy_d< Tsrc[N1], Tdst >Partial specialization for N=1 1D-Array
 Cmeta_copy_d< Tsrc[N1], Tdst[N1]>Partial specialization for N=1 1D-Array
 Cmeta_copy_d< Tsrc[N1][N2], Tdst >Partial specialization for N=2 2D-Array
 Cmeta_copy_d< Tsrc[N1][N2], Tdst[N1][N2]>Partial specialization for N=1 1D-Array
 Cmeta_copy_opThis class copy general objects applying an operation
 Cmeta_copy_op< op, openfpm::detail::multi_array::sub_array_openfpm< T, 1, vmpl > >Partial specialization for N=1 1D-Array
 Cmeta_copy_op< op, openfpm::detail::multi_array::sub_array_openfpm< T, 2, vmpl > >Partial specialization for N=2 2D-Array
 Cmeta_copy_op< op, T[N1]>Partial specialization for N=1 1D-Array
 Cmeta_copy_op< op, T[N1][N2]>Partial specialization for N=2 2D-Array
 Cmeta_copy_op< op, T[N1][N2][N3]>Partial specialization for N=3
 Cmeta_copy_op_d
 Cmeta_copy_op_d< op, openfpm::detail::multi_array::sub_array_openfpm< Tsrc, 1, vmpl >, openfpm::detail::multi_array::sub_array_openfpm< Tdst, 1, vmpl > >Partial specialization for N=2 2D-Array
 Cmeta_copy_op_d< op, openfpm::detail::multi_array::sub_array_openfpm< Tsrc, 2, vmpl >, openfpm::detail::multi_array::sub_array_openfpm< Tdst, 2, vmpl > >Partial specialization for N=2 2D-Array
 Cmeta_copy_op_d< op, Tsrc, Tdst[N1]>Partial specialization for N=1 1D-Array
 Cmeta_copy_op_d< op, Tsrc[N1], Tdst >Partial specialization for N=1 1D-Array
 Cmeta_copy_op_d< op, Tsrc[N1], Tdst[N1]>Partial specialization for N=1 1D-Array
 Cmeta_copy_op_d< op, Tsrc[N1][N2], Tdst[N1][N2]>Partial specialization for N=2 2D-Array
 Cmeta_copy_set_bck
 Cmeta_copy_set_bck< T[N]>
 Cmeta_propThis class is an helper to create properties output from scalar and compile-time array elements
 Cmeta_prop< I, ele_g, St, T, false >Specialication when is not writable
 Cmeta_prop< I, ele_g, St, T[N1], is_writable >Partial specialization for N=1 1D-Array
 Cmeta_prop< I, ele_g, St, T[N1][N2], is_writable >Partial specialization for N=2 2D-Array
 Cmeta_prop< I, ele_g, St, T[N1][N2][N3], is_writable >Partial specialization for N=3 3D-Array
 Cmeta_prop_newThis class is an helper to create properties output from scalar and compile-time array elements
 Cmeta_prop_new< I, ele_g, St, T, false >Specialication when is not writable
 Cmeta_prop_new< I, ele_g, St, T[N1], is_writable >Partial specialization for N=1 1D-Array
 Cmeta_prop_new< I, ele_g, St, T[N1][N2], is_writable >Partial specialization for N=2 2D-Array
 Cmeta_prop_new< I, ele_g, St, T[N1][N2][N3], is_writable >Partial specialization for N=3 3D-Array
 Cmeta_raw_readThis is the scalar case
 Cmeta_raw_read< dim, Tg, Tr[nv], i >This is the vector case
 CMetaFunc[Metafunction definition]
 CMetaFuncOrd
 CMetaParser
 CMethodOfImagesClass for getting mirror particles to impose Neumann BCs
 CMetisHelper class to define Metis graph
 CMetis_graphMetis graph structure
 CMetisDistributionClass that distribute sub-sub-domains across processors using Metis Library
 CmheaderThis structure contain the information of a chunk
 Cmin_This structure define the operation add to use with copy general
 CminusIt ancapsulate the minus operation
 CModelCustomModel for Dynamic load balancing
 CModelCustom2Second model for dynamic load balancing
 CModelLinLinear model
 CModelSquareLinear model
 CMonomial
 CMonomial_gpu
 CMonomialBasis
 Cmove_impl
 Cmove_impl< false, grid_key_base, dim >
 Cmp4_kernel
 Cmp_funct
 Cmp_funct_impl
 Cmp_funct_impl< dim, T[N1]>
 Cmp_funct_impl< dim, T[N1][N2]>
 CMPI_IAllGatherWGeneral recv for vector of
 CMPI_IAllGatherW< char >Specialization for vector of char
 CMPI_IAllGatherW< double >Specialization for vector of double
 CMPI_IAllGatherW< float >Specialization for vector of float
 CMPI_IAllGatherW< int >Specialization for vector of integer
 CMPI_IAllGatherW< long int >Specialization for vector of long int
 CMPI_IAllGatherW< short >Specialization for vector of short
 CMPI_IAllGatherW< size_t >Specialization for vector of size_t
 CMPI_IAllGatherW< unsigned char >Specialization for vector of unsigned char
 CMPI_IAllGatherW< unsigned int >Specialization for vector of unsigned integer
 CMPI_IAllGatherW< unsigned short >Specialization for vector of short
 CMPI_IAllGatherWBSet of wrapping classing for MPI_Irecv
 CMPI_IallreduceWSet of wrapping classing for MPI_Iallreduce
 CMPI_IallreduceW< char >Specialization for char
 CMPI_IallreduceW< double >Specialization for double
 CMPI_IallreduceW< float >Specialization for float
 CMPI_IallreduceW< int >Specialization for integer
 CMPI_IallreduceW< long int >Specialization for size_t
 CMPI_IallreduceW< short >Specialization for short
 CMPI_IallreduceW< size_t >Specialization for size_t
 CMPI_IallreduceW< unsigned char >Specialization for char
 CMPI_IallreduceW< unsigned int >Specialization for unsigned integer
 CMPI_IallreduceW< unsigned short >Specialization for short
 CMPI_IBcastWGeneral recv for vector of
 CMPI_IBcastW< char >Specialization for char
 CMPI_IBcastW< double >Specialization for double
 CMPI_IBcastW< float >Specialization for float
 CMPI_IBcastW< int >Specialization for vector of integer
 CMPI_IBcastW< long int >Specialization for size_t
 CMPI_IBcastW< short >Specialization for short
 CMPI_IBcastW< size_t >Specialization for size_t
 CMPI_IBcastW< unsigned char >Specialization for char
 CMPI_IBcastW< unsigned int >Specialization for unsigned integer
 CMPI_IBcastW< unsigned short >Specialization for short
 CMPI_IBcastWBSet of wrapping classing for MPI_Irecv
 CMPI_IrecvWGeneral recv for vector of
 CMPI_IrecvW< char >Specialization for char
 CMPI_IrecvW< double >Specialization for double
 CMPI_IrecvW< float >Specialization for float
 CMPI_IrecvW< int >Specialization for vector of integer
 CMPI_IrecvW< long int >Specialization for size_t
 CMPI_IrecvW< short >Specialization for short
 CMPI_IrecvW< size_t >Specialization for size_t
 CMPI_IrecvW< unsigned char >Specialization for char
 CMPI_IrecvW< unsigned int >Specialization for unsigned integer
 CMPI_IrecvW< unsigned short >Specialization for short
 CMPI_IrecvWBSet of wrapping classing for MPI_Irecv
 CMPI_IsendWGeneral send for a vector of any type
 CMPI_IsendW< char, Mem, gr >Specialization for char
 CMPI_IsendW< double, Mem, gr >Specialization for double
 CMPI_IsendW< float, Mem, gr >Specialization for float
 CMPI_IsendW< int, Mem, gr >Specialization for vector of integer
 CMPI_IsendW< long int, Mem, gr >Specialization for size_t
 CMPI_IsendW< short, Mem, gr >Specialization for short
 CMPI_IsendW< size_t, Mem, gr >Specialization for size_t
 CMPI_IsendW< unsigned char, Mem, gr >Specialization for char
 CMPI_IsendW< unsigned int, Mem, gr >Specialization for unsigned integer
 CMPI_IsendW< unsigned short, Mem, gr >Specialization for short
 CMPI_IsendWBSet of wrapping classing for MPI_Isend
 CmulIt model an expression expr1 * expr2
 Cmul_inteMultiply the src by coeff for several types T
 Cmul_inte< T[N1]>Multiply the src by coeff for several types T
 Cmul_inte< T[N1][N2]>Multiply the src by coeff for several types T
 CmultThis class multiply all the elements in a boost::mpl::vector excluding the first element
 Cmult< T, 1 >
 Cmulti_arrayThis class is a trick to indicate the compiler a specific specialization pattern
 Cmulti_mask
 Cmulti_mask< 1 >
 Cmulti_mask< 16 >
 Cmulti_mask< 2 >
 Cmulti_mask< 4 >
 Cmulti_mask< 8 >
 CMultiArrayViewGpu
 CMultiArrayViewGpu< BaseT, Nup, 0 >
 Cmutable_or_not
 Cmutable_or_not< T, true >
 Cmy_particle
 Cmy_struct
 CN_box
 CN_operation
 CNarrowBandClass for getting the narrow band around the interface
 Cnative_encapsulated_type
 Cnb_f
 ►Cne_cp
 ►Cnm_eSub-domain edge graph node
 ►Cnm_part_eReduced edge graph node
 ►Cnm_part_vReduced sub-domain vertex graph node
 ►Cnm_v
 CNN_gpu_int_base
 CNN_gpu_int_base_hr_impl
 CNN_gpu_it
 CNN_gpu_it< dim, cnt_type, ids_type, r_int, true >
 CNN_gpu_it_radius
 CNN_gpu_selector
 CNN_gpu_selector< dim, cnt_type, ids_type, true >
 CNN_index
 CNN_index< NN_index_sort >
 Cnn_prcsThis class store the adjacent processors and the adjacent sub_domains
 Cnn_type_result
 Cnn_type_result< void, NN2_type >
 CNNc_array
 CNNc_array< dim, size, false >
 CNNFull
 CNNfull_is_padding_implCheck if is padding
 CNNfull_is_padding_impl< 2 >Check if is padding
 CNNfull_is_padding_impl< 3 >Check if is padding
 CNNStar
 CNNStar_c
 CNNTypeGet the neighborhood iterator based on type
 CNNType< dim, T, CellListImpl, PartIt, VL_CRS_SYMMETRIC, local_index >Get the neighborhood iterator based on type
 CNNType< dim, T, CellListImpl, PartIt, VL_SYMMETRIC, local_index >Get the neighborhood iterator based on type
 CNNType< dim, T, CellListImpl, PartIt, WITH_RADIUS, local_index >Get the neighborhood iterator based on type
 CNNTypeMGet the neighborhood iterator based on type
 CNNTypeM< dim, T, CellListImpl, PartIt, VL_CRS_SYMMETRIC >Get the neighborhood iterator based on type
 CNNTypeM< dim, T, CellListImpl, PartIt, VL_SYMMETRIC >Get the neighborhood iterator based on type
 CNo_check
 Cno_edgeClass with no edge
 Cno_equationSpecify the general characteristic of system to solve
 Cno_fieldStub field
 Cno_stencilNo stencil
 Cno_transformNo transformation
 Cno_transform_onlyNo transformation
 CNoCheckClass to check if the edge can be created or not
 ►Cnode_cp
 CnoPointers_sequenceIt return a boost::mpl::vector of integers where each integer identify one object without the method "noPointers"
 CnoPointers_sequence_implImplementation of noPointer_sequence_impl
 CnoPointers_sequence_impl< v, p1 >Implementation of noPointer_sequence_impl
 Cnot_on_testNot on testing mode
 CNothingOut-of-bound policy do nothing
 Cnumber_prop
 Cnumber_prop< T, 0 >Return the number of properties the type T has
 CobjectThis is a container to create a general object
 Cobject_creatorIt create a boost::fusion vector with the selected properties
 Cobject_creator< v >Specialization when no properties are passed
 Cobject_creator_chunking
 Cobject_creator_chunking< v >Specialization when no properties are passed
 Cobject_creator_chunking_encapsulator
 Cobject_creator_chunking_implImplementation of object creator
 Cobject_creator_chunking_impl< v, vc, p1, prp... >Implementation of object creator
 Cobject_creator_chunking_impl< v, vc, prp >Implementation of object creator
 Cobject_creator_implImplementation of object creator
 Cobject_creator_impl< v, vc, p1, prp... >Implementation of object creator
 Cobject_creator_impl< v, vc, prp >Implementation of object creator
 Cobject_s_diIt copy the properties from one object to another
 Cobject_s_di< v_src, v_dst, OBJ_ENCAP, prp... >It copy the properties from one object to another
 Cobject_s_di< v_src, v_dst, OBJ_ENCAP_CHUNKING, prp... >
 Cobject_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)
 Cobject_s_di_eThis class is a functor for "for_each" algorithm
 Cobject_s_di_e_cnkThis class is a functor for "for_each" algorithm
 Cobject_s_di_e_cnk_meta_copy_selector
 Cobject_s_di_e_cnk_meta_copy_selector< T[N1]>
 Cobject_s_di_e_opThis class is a functor for "for_each" algorithm
 Cobject_s_di_e_op_cnkThis class is a functor for "for_each" algorithm
 Cobject_s_di_fThis class is a functor for "for_each" algorithm
 Cobject_s_di_f_opThis class is a functor for "for_each" algorithm
 Cobject_s_di_opIt copy the properties from one object to another applying an operation
 Cobject_s_di_op< op, v_src, v_dst, OBJ_ENCAP, prp... >It copy the properties from one object to another applying an operation
 Cobject_s_di_op< op, v_src, v_dst, OBJ_ENCAP_CHUNKING, prp... >It copy the properties from one object to another applying an operation
 Cobject_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
 Cobject_si_dIt copy the properties from one object to another
 Cobject_si_d< v_src, v_dst, OBJ_ENCAP >
 Cobject_si_d< v_src, v_dst, OBJ_ENCAP, prp... >It copy the properties from one object to another
 Cobject_si_d< v_src, v_dst, OBJ_ENCAP_CHUNKING, prp... >It copy the properties from one object to another
 Cobject_si_d< v_src, v_dst, OBJ_NORMAL, prp... >It copy the properties from one object to another
 Cobject_si_d_eThis class is a functor for "for_each" algorithm
 Cobject_si_d_e_cnkThis class is a functor for "for_each" algorithm
 Cobject_si_d_e_cnk_meta_copy_selector
 Cobject_si_d_e_cnk_meta_copy_selector< T[N1]>
 Cobject_si_d_fThis class is a functor for "for_each" algorithm
 Cobject_si_diIt copy the properties from one object to another applying an operation
 Cobject_si_di< v_src, v_dst, OBJ_ENCAP, prp... >It copy the properties from one object to another applying an operation
 Cobject_si_di_e
 Cobject_si_di_e_opThis class is a functor for "for_each" algorithm
 Cobject_si_di_opIt copy the properties from one object to another applying an operation
 Cobject_si_di_op< op, v_src, v_dst, OBJ_ENCAP, prp... >It copy the properties from one object to another applying an operation
 CObserverFunctor
 Coffset_mvIt contain the offset necessary to move to coarser and finer level grids
 Con_test[Constant fields struct definition]
 Cop_ssend_gg_recv_mergeHelper class to merge data
 Cop_ssend_gg_recv_merge_implHelper class to merge data without serialization
 Cop_ssend_gg_recv_merge_impl< true >Helper class to merge data with serialization
 Cop_ssend_gg_recv_merge_impl_run_deviceHelper class to merge data without serialization, using host memory
 Cop_ssend_gg_recv_merge_impl_run_device_directHelper class to merge data without serialization direct transfer to CUDA buffer
 Cop_ssend_gg_recv_merge_run_deviceHelper class to merge data
 Cop_ssend_recv_addHelper class to add data
 Cop_ssend_recv_add_srHelper class to add data without serialization
 Cop_ssend_recv_add_sr< true >Helper class to add data with serialization
 Cop_ssend_recv_mergeHelper class to merge data
 Cop_ssend_recv_merge_gpuHelper class to merge data
 Cop_ssend_recv_merge_gpu_implHelper class to merge data without serialization
 Cop_ssend_recv_merge_gpu_impl< true, op, vector_type_opart, vector_type_prc_offset >Helper class to merge data with serialization
 Cop_ssend_recv_merge_implHelper class to merge data without serialization
 Cop_ssend_recv_merge_impl< true, op, vector_type_opart >Helper class to merge data with serialization
 CORBThis class implement orthogonal recursive bisection
 CORB_nodeORB node
 Cp_boxIt store all the boxes of the near processors in a linear array
 Cpack_pack_op
 Cpack_request_op
 Cpack_request_op< true, obj_type, Mem >
 CPack_selectorPack selector
 CPack_selector_array_prim
 CPack_selector_array_prim< T, true >
 CPack_selector_implIt is not a fundamental type
 CPack_selector_impl< T, true >Select the primitive packing
 CPack_selector_known_type_implPack selector for unknown type
 CPack_selector_known_type_impl< T, HAS_PACKER >
 CPack_selector_known_type_impl< T, IS_ENCAP >
 CPack_selector_known_type_impl< T, IS_GRID >
 CPack_selector_unknown_type_implPack selector for unknown type
 CPack_selector_unknown_type_impl< T, 0 >
 CPack_selector_unknown_type_impl< T, 2 >Pack selector for unknown type
 CPack_selector_unknown_type_impl< T, 3 >
 CPack_statPacking status object
 Cpack_unpack_cond_with_prpThere is max_prop inside
 Cpack_unpack_cond_with_prp_inte_lin
 Cpack_unpack_cond_with_prp_inte_lin< T, true >
 Cpack_with_iteratorPack an N-dimensional grid into a vector like structure B given an iterator of the grid
 Cpack_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
 Cpack_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
 Cpack_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
 Cpack_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
 Cpack_with_iterator_longx
 Cpack_with_iterator_longx< 2, obj_byte, git, grid >
 Cpack_with_iterator_longx< 3, obj_byte, git, grid >
 Cpack_with_iterator_shortx
 Cpack_with_iterator_shortx< 2, n_cpy, obj_byte, git, grid >
 Cpack_with_iterator_shortx< 3, n_cpy, obj_byte, git, grid >
 CPackerPacking class
 CPacker< T, Mem, PACKER_ARRAY_CP_PRIMITIVE >
 CPacker< T, Mem, PACKER_ARRAY_PRIMITIVE >Packer for primitives
 CPacker< T, Mem, PACKER_ENCAP_OBJECTS >
 CPacker< T, Mem, PACKER_ENCAP_OBJECTS_CHUNKING >
 CPacker< T, Mem, PACKER_GENERAL >Packer class for vectors
 CPacker< T, Mem, PACKER_GRID >Packer for grids and sub-grids
 CPacker< T, Mem, PACKER_OBJECTS_WITH_POINTER_CHECK >Packer class for objects
 CPacker< T, Mem, PACKER_OBJECTS_WITH_WARNING_POINTERS >Packer for objects, with impossibility to check for internal pointers
 CPacker< T, Mem, PACKER_PRIMITIVE >Packer for primitives
 CPaddingClass that contain Padding information on each direction positive and Negative direction
 Cpar_struct
 CParmetisHelper class to define Metis graph
 CParmetis_dist_graphMetis graph structure
 CParmetis_graphMetis graph structure
 CParMetisDistributionClass that distribute sub-sub-domains across processors using ParMetis Library
 CParticleIt_CellP
 CParticleIt_CellsThis iterator iterate across the particles of a Cell-list following the Cell structure
 CParticleItCRS_CellsThis iterator iterate across the particles of a Cell-list following the Cell structure
 CPartItNNIn general different NN scheme like full symmetric or CRS require different iterators over particles this class select the proper one
 CPartItNN< 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
 CperiodicityBoundary conditions
 Cperiodicity_intBoundary conditions
 Cpetsc_AMG_reportClass to test AMG solvers
 Cpetsc_solverIn case T does not match the PETSC precision compilation create a stub structure
 ►Cpetsc_solver< double >This class is able to do Matrix inversion in parallel with PETSC solvers
 CPointThis class implement the point shape in an N-dimensional space
 CPoint2D_testTest structure used for several test
 Cpoint_and_gid
 Cpoint_expressionMain class that encapsulate a constant number used in a point expression
 Cpoint_expression< const T[dim]>Specialization for a const array of dimension dim
 Cpoint_expression< openfpm::detail::multi_array::sub_array_openfpm< T, 1, vmpl > >Specialization for views
 Cpoint_expression< T[dim]>Specialization for an array of dimension dim as expression
 Cpoint_expression_opUnknown operation specialization
 Cpoint_expression_op< orig, exp1, exp2, POINT_DIV >Division operation
 Cpoint_expression_op< orig, exp1, exp2, POINT_MUL >Multiplication operation
 Cpoint_expression_op< orig, exp1, exp2, POINT_MUL_POINT >Multiplication operation
 Cpoint_expression_op< orig, exp1, exp2, POINT_NORM >Point norm operation
 Cpoint_expression_op< orig, exp1, exp2, POINT_NORM2 >Point square norm operation
 Cpoint_expression_op< orig, exp1, exp2, POINT_NORM_INF >Point norm Infinity operation
 Cpoint_expression_op< orig, exp1, exp2, POINT_SUB >Subtraction operation
 Cpoint_expression_op< orig, exp1, exp2, POINT_SUB_UNI >Expression that subtract two points
 Cpoint_expression_op< orig, exp1, exp2, POINT_SUM >Sum operation
 CPoint_origDefinition of a class Point in plain C++ and boost::vector for testing purpose
 Cpoint_scalar_process
 Cpoint_scalar_process< val_type, is_sort, true >
 CPoint_testTest structure used for several test
 ►CPoint_test_prpTest structure used for several test
 ►CPoint_test_scalPoint test with only scalar properties
 Cpointer_check
 CPointIteratorThis class draw particles on subset of grid-like position
 CPointIteratorSkinThis class draw particles on subset of grid-like position
 Cpoisson_nn_helm
 CPolarEv
 Cpopulate_cell_list_no_sym_impl
 Cpopulate_cell_list_no_sym_impl< true >
 Cpopulate_cell_list_sym_impl
 Cpopulate_cell_list_sym_impl< true >
 Cpos_or_propLSelector for position or properties left side expression
 Cpos_or_propL< vector, PROP_POS >Selector for position or properties left side
 Cpos_or_propL_kerSelector for position or properties left side expression
 Cpos_or_propL_ker< vector, PROP_POS >Selector for position or properties left side
 Cpos_or_propRSelector for position or properties right side position
 Cpos_or_propR< vector, PROP_POS >Selector for position or properties right side
 Cpos_pc
 Cpos_vStructure that contain a reference to a vector of particles
 Cpos_val
 Cpost_increment_sub_impl
 CPPInterpolationClass for Creating the DCPSE Operator For the function approximation objects and computes DCPSE Kernels
 Cprint_warning_on_adjustmentDeclaration print_warning_on_adjustment
 Cproc_box_idProcessor id and box id
 Cproc_without_prpProcess the particle without properties
 Cproc_without_prp_deviceProcess the particle without properties
 Cprocess_data_block
 Cprocess_data_block< T[N1], dim, blockEdgeSize >
 CProcess_keys_gridClass for an hilbert order processing of cell keys for CellList_gen implementation
 CProcess_keys_hilbClass for an hilbert order processing of cell keys for CellList_gen implementation
 CProcess_keys_lin
 Cprocess_receive_mem_traits_inteThis class is a functor for "for_each" algorithm
 Cprop_id
 Cprop_out_edgeThis class is a functor for "for_each" algorithm
 Cprop_out_gThis class is a functor for "for_each" algorithm
 Cprop_out_vThis class is a functor for "for_each" algorithm
 Cprop_out_v_pvtpThis class is a functor for "for_each" algorithm
 Cprop_out_vertexThis class is a functor for "for_each" algorithm
 Cprop_outputThis class specialize functions in the case the type T has or not defined attributes
 Cprop_output< false, Graph, i >This class specialize functions in the case the type T has not defined attributes
 Cprop_output_array_scalar_selector_edgeProperty writer for scalar and vector
 Cprop_output_array_scalar_selector_edge< true >Property writer for vector
 Cprop_output_array_scalar_selector_edge_fill_vertexProperty writer for scalar and vector, it fill the vertex data (needed for edge representation in vtk)
 Cprop_output_array_scalar_selector_edge_fill_vertex< true >Property writer for vector
 Cprop_output_array_scalar_selector_vertexProperty writer for scalar and vector
 Cprop_output_array_scalar_selector_vertex< true >Property writer for vector
 Cprop_write_outWrite the vectror property
 Cprop_write_out< 1, T >Write the scalar property
 Cprop_write_out_newWrite the vectror property
 Cprop_write_out_new< 1, T >Write the scalar property
 CpropCheckINFThis class is a functor for "for_each" algorithm
 CpropCheckNANThis class is a functor for "for_each" algorithm
 Cprp_all_zeroStructure to convert a variadic template into boost::mpl::vector
 Cprp_all_zero< T, true, prp ... >
 CPSEError
 Cptr_info
 CPtrMemoryThis class give memory from a preallocated memory, memory destruction is not performed
 Cpush_back_op
 Cpush_back_op< false, false, T, S >
 Cpush_back_op< false, true, T, S >
 Cpush_back_op< true, true, T, S >
 Cpush_back_op_nestePack/add function selector
 Cpush_back_op_neste< true, T, S >Pack/add function selector
 Cpush_back_std_op_nestePack/add function selector
 Cpush_back_std_op_neste< true, T, S >
 CPV_cl
 Cr_type_dimIt return the dimansionality of the operation given the dimensionality of the 2 operators
 Cr_type_dim< 1, 1, POINT_DIV >Scalar / scalar = scalar
 Cr_type_dim< 1, 1, POINT_MUL >Scalar * scalar = scalar
 Cr_type_dim< 1, 1, POINT_SUB >Scalar - scalar = scalar
 Cr_type_dim< 1, 1, POINT_SUM >Scalar + scalar = scalar
 Cr_type_dim< op1_dim, op2_dim, POINT_MUL_POINT >Point * Point = scalar
 Cr_type_pReturn type of the expression
 Cr_type_p< 1, orig >Return type of the expression
 Crank_genLike std::rank but it also work for openfpm structures like Point where it return 1
 Crank_gen< T, true >
 Craw_readThis class is a functor for "for_each" algorithm
 Crcv_rm
 CredTemporal buffer for reductions
 Cred_maxGet the reference of the selected element
 Cred_min
 Cred_sum
 CRedist_optionsStructure to bundle options for redistancing
 CRedistancingSussmanClass for reinitializing a level-set function into a signed distance function using Sussman redistancing
 Creduce_opThis class is a functor for "for_each" algorithm
 Creduce_op_finalThis class is a functor for "for_each" algorithm
 Creduce_typeIn general a reduction of a type T produce a type T
 Creduce_type< double[]>A reduction operation on an array of double is a double
 Creduce_type< float[]>A reduction operation on an array of float is a float
 Creduce_type< int[]>A reduction operation on an array of int is an int
 Cref_wrap
 Cremove_attributes_const_refT_to_memory_c is a metafunction that given T it convert it into
 Creplace_This structure define the operation add to use with copy general
 Creport_cell_list_func_tests
 Creport_cell_list_preord_tests
 Creport_grid_copy_func_tests
 Creport_grid_iterator_test
 Creport_sparse_grid_tests
 Creport_vector_func_tests
 Creport_vector_gg_map_tests
 Creport_verlet_tests
 Cresult_boxResult of the itersection of a box with an array of boxes
 CRGBRGB color struct
 CRhsBlockWrapper
 CRhsBlockWrapper< BlockT[N1][N2]>
 CRhsBlockWrapper< BlockT[N]>
 CRHSFunctor
 Crid
 CrightOperand_t
 CrvalIt store one row value of a vector
 Crval< T, EIGEN_RVAL >It store one row value of a vector
 Crval< T, PETSC_RVAL >It store one row value of a vector
 Csadd_
 Csadd_block_
 Cse_class3_vectorThis class check for inconsistency access
 Cselector_chunking_prp_has_zero_size
 Cselector_chunking_prp_has_zero_size< true, T, T_nc, prp... >
 Cselvg
 Cselvg< false >
 Cseq_traits_implImplementation of seq_traits
 Cset_buf_pointer_for_each_propThis class is a functor for "for_each" algorithm
 Cset_buf_size_for_each_propThis class is a functor for "for_each" algorithm
 Cset_compile_condition
 Cset_compile_condition< false >
 Cset_zeroMeta-function to return a compatible zero-element
 Cset_zero< Point< dim, T > >Create a point with all compunent set to zero
 CsetBackground_implThis class is a functor for "for_each" algorithm
 Csgrid_cpu
 Cshift
 Cshift_only
 Cshift_ph
 Cshift_vect_converterIn case of high dimensions shift vector converter
 CSimpleRNGSimpleRNG 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
 CSkeletonStencil
 Cskip_init
 Cskip_init< true, T >
 CsLeft_
 Csmax_
 Csmax_block_
 Csmin_
 Csmin_block_
 CsolErrorIt contain statistic of the error of the calculated solution
 Cspace_key_dxGrid_key_dx is the key to access any element in the grid
 CSpaceBoxThis class represent an N-dimensional box
 CSpaceDistributionClass that distribute sub-sub-domains across processors using an hilbert curve to divide the space
 Csparse_grid_bck_value
 Csparse_grid_bck_wrapper_impl
 Csparse_grid_bck_wrapper_impl< openfpm::detail::multi_array::sub_array_openfpm< T, 1, vmpl > >
 Csparse_grid_gpu_indexElement index contain a data chunk index and a point index
 Csparse_grid_section
 CSparseGridGpu
 CSparseGridGpu_iterator
 CSparseGridGpu_iterator_sub
 CSparseGridGpu_ker
 Csparsegridgpu_pack_implThis class is a functor for "for_each" algorithm
 Csparsegridgpu_pack_requestThis class is a functor for "for_each" algorithm
 Csparsegridgpu_unpack_implThis class is a functor for "for_each" algorithm
 CSparseMatrixSparse Matrix implementation
 CSparseMatrix< T, id_t, EIGEN_BASE >
 CSparseMatrix< T, id_t, PETSC_BASE >Sparse Matrix implementation, that map over Eigen
 CSphereThis class implement the Sphere concept in an N-dimensional space
 CsRight_
 Cstag_create_and_add_gridIt create separated grid for each properties to write them into a file
 Cstag_set_positionThis class is a functor for "for_each" algorithm
 Cstag_set_position< dim, v, false >This class is a functor for "for_each" algorithm
 Cstaggered_grid_distImplementation of the staggered grid
 Cstate_type_1d_ofpA 1d Odeint and Openfpm compatible structure
 Cstate_type_2d_ofpA 2d Odeint and Openfpm compatible structure
 Cstate_type_3d_ofpA 3d Odeint and Openfpm compatible structure
 Cstate_type_4d_ofpA 4d Odeint and Openfpm compatible structure
 Cstate_type_5d_ofpA 5d Odeint and Openfpm compatible structure
 Cstate_type_ofpm_add_elements
 Cstate_type_ofpm_add_elements< 0, state_type, list ... >
 Cstate_type_ofpm_impl
 Cstatic_array
 Cstd_array_copy_chunks
 Cstd_array_copy_chunks< prop, T[N1]>
 Cstd_array_vector_view
 Cstencil_offset_computeStructure for stencil iterator
 Cstore_reduce_op_finalThis class is a functor for "for_each" algorithm
 Cstriding
 Cstub_or_realIn case of testing return a stub grid
 Cstub_or_real< T, dims, stype, decomposition, false >Case when we are not on testing
 Csubar_dimReturn the dimension of the sub_array
 CSubHyperCubeThis represent a sub-hyper-cube of an hyper-cube like a face or an edge of a cube
 Csublin
 Csublin< 1, chunk >
 Csublin< 2, chunk >
 Csublin< 3, chunk >
 Csublin< 4, chunk >
 Csublin< 5, chunk >
 Csublin< 6, chunk >
 Csublin< 7, chunk >
 Csublin< 8, chunk >
 CsubsubSub-sub-domain
 Csubsub_linLinearized version of subsub
 CsumIt model an expression expr1 + ... exprn
 Csum_ele
 Csum_ele< boost::mpl::int_< op1 >, ele >
 Csum_ele< boost::mpl::na, ele >
 Csum_functor_valueSum functor value
 CSupport
 CSupportBuilder
 CSupportBuilderGPU
 Cswitch_copy_host_to_deviceThis class is a functor for "for_each" algorithm
 Cswitcher_get_v
 Cswitcher_get_v< vector, comp_dev >
 Csys_nn
 Csys_pp
 Csyss_nn
 Csyss_pp
 CSystemSystem of equations
 Ct_to_memory_cMeta-function t_to_memory_c
 Ct_to_memory_c_implPartial specialization for scalar N=0
 Ct_to_memory_c_impl< T[N1]>Partial specialization for N=1
 Ct_to_memory_c_impl< T[N1][N2]>Partial specialization for N=2
 Ct_to_memory_c_impl< T[N1][N2][N3]>Partial specialization for N=3
 Ct_to_memory_c_impl< T[N1][N2][N3][N4]>Partial specialization for N=4
 Ct_to_memory_c_impl< T[N1][N2][N3][N4][N5]>Partial specialization for N=5
 Ct_to_memory_c_impl< T[N1][N2][N3][N4][N5][N6]>Partial specialization for N=6
 Ct_to_memory_c_impl< T[N1][N2][N3][N4][N5][N6][N7]>Partial specialization for N=7
 Ct_to_memory_c_impl< T[N1][N2][N3][N4][N5][N6][N7][N8]>Partial specialization for N=8
 Ct_to_memory_c_impl< T[N1][N2][N3][N4][N5][N6][N7][N8][N9]>Partial specialization for N=9
 Ct_to_memory_c_impl< T[N1][N2][N3][N4][N5][N6][N7][N8][N9][N10]>Partial specialization for N=10
 Ct_to_memory_c_redMeta-function t_to_memory_c_red
 Ct_to_memory_c_red_implPartial specialization for scalar N=0
 Ct_to_memory_c_red_impl< T[N1]>Partial specialization for N=1
 Ct_to_memory_c_red_impl< T[N1][N2]>Partial specialization for N=2
 Ct_to_memory_c_red_impl< T[N1][N2][N3]>Partial specialization for N=3
 Ct_to_memory_c_red_impl< T[N1][N2][N3][N4]>Partial specialization for N=4
 Ct_to_memory_c_red_impl< T[N1][N2][N3][N4][N5]>Partial specialization for N=5
 Ctensor
 Ctensor< int, s1, s2, s3 >
 Ctest_box_vpack
 Ctest_chunking3
 Ctest_grid_type_no_def
 Ctest_grid_type_normal
 Ctest_grid_type_staggered[Define structures]
 ►Ctest_has_attributes[Check has_posMask struct definition]
 Ctest_has_max_propTest type for has_max_prop
 Ctest_has_no_max_propTest type for has_max_prop
 Ctest_has_posMask[Check has_posMask struct definition]
 Ctest_no_attributes
 Ctest_no_has_posMaskTest type for has_posMask
 CTiffWriterThis class is able to save grid into tiff files
 CtimerClass for cpu time benchmarking
 CTimesTime structure for statistical purposes
 Cto_boost_vmpl
 Cto_int_sequence
 Cto_memory_multi_array_ref_viewOpenFPM use memory_c<multi_array<T> ..... > to implement the structure of array layout
 Cto_variadic_const_implRecursive specialization of to_variadic
 Cto_variadic_const_impl< c, end, ele, true, vars ... >Terminator of to_variadic
 Cto_variadic_implRecursive specialization of to_variadic
 Cto_variadic_impl< c, end, true, vars ... >Terminator of to_variadic
 CtoKernel_transform
 CtoKernel_transform< layout_base, T, 0 >
 CtoKernel_transform< layout_base, T, 1 >
 CtoPoint
 Ctransform_if_temporal
 Ctransform_if_temporal< vector_dist_expression< 0, openfpm::vector_gpu< aggregate< T > > > >
 CtripletIt store the non zero elements of the matrix
 Ctriplet< T, EIGEN_TRIPLET >It store one non-zero element in the sparse matrix
 Ctriplet< T, PETSC_BASE >It store one non-zero element in the sparse matrix
 Ctype_identity
 Ctype_is_one
 CtypeCheckType check in case of unknown type
 CtypeCheck< tcheck, true >Type check in case of supported type
 CtypeCheck< tcheck[N1], foundamental >Type check in case of supported array type
 CtypeCheck< tcheck[N1][N2], foundamental >Type check in case of supported 2D array type
 CUIntDivCeil
 Cumfpack_solverStub when library compiled without eigen
 Cumfpack_solver< double >Stub when library compiled without eigen
 Cunpack_each_prop_buffer
 Cunpack_selector_with_prp
 Cunpack_selector_with_prp< true, T, S, layout_base, Memory >
 Cunpack_selector_with_prp_lin
 Cunpack_selector_with_prp_lin< true, T, S, layout_base, Memory >
 CUnpack_statUnpacking status object
 Cunpack_with_iteratorPack an N-dimensional grid into a vector like structure B given an iterator of the grid
 Cunpack_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
 CUnpackerUnpacker class
 CUnpacker< T, Mem, PACKER_ARRAY_CP_PRIMITIVE >
 CUnpacker< T, Mem, PACKER_ARRAY_PRIMITIVE >
 CUnpacker< T, Mem, PACKER_ENCAP_OBJECTS_CHUNKING >Unpacker for encapsulated objects
 CUnpacker< T, Mem, PACKER_GENERAL >Unpacker for vectors
 CUnpacker< T, Mem, PACKER_GRID >Unpacker for grids
 CUnpacker< T, Mem, PACKER_OBJECTS_WITH_POINTER_CHECK >Unpacker class for objects
 CUnpacker< T, Mem, PACKER_OBJECTS_WITH_WARNING_POINTERS >Unpacker for objects with no possibility to check for internal pointers
 CUnpacker< T, Mem, PACKER_PRIMITIVE >Unpacker for primitives
 Cunroll_with_to_kernel
 Cunroll_with_to_kernel< false, true, T >
 Cunroll_with_to_kernel< true, true, T >
 Cut_startBoost unit test fixation (start procedure to call before testing)
 Cv_box
 Cv_info
 Cv_mem_mutable
 CV_pVertex class that encapsulate an object T
 Cv_transform
 Cv_transform_implRecursive specialization of v_transform
 Cv_transform_impl< H, F, L, true, Args... >Terminator of to_variadic
 Cv_transform_two
 Cv_transform_two_implRecursive specialization of v_transform in case of metafunction with 2 argument
 Cv_transform_two_impl< H, arg0, F, L, true, Args... >Terminator of to_variadic
 Cv_transform_two_v2
 Cv_transform_two_v2_implRecursive specialization of v_transform in case of metafunction with 2 argument
 Cv_transform_two_v2_impl< H, arg0, F, L, true, Args... >Terminator of to_variadic
 Cvalue_function
 CVandermonde
 CVandermondeRowBuilder
 Cvariadic_caller
 Cvariadic_caller< index_tuple_sq< prp ... > >
 ►CVclusterImplementation of VCluster class
 CVcluster_baseThis class virtualize the cluster of PC as a set of processes that communicate
 CVcluster_logVcluster log
 Cvect_dist_key_dxGrid key for a distributed grid
 CVectorSparse Matrix implementation stub object when OpenFPM is compiled with no linear algebra support
 ►Cvector< T, CudaMemory, memory_traits_inte, grow_policy_double, STD_VECTOR >Implementation of 1-D std::vector like structure
 CVector< T, EIGEN_BASE >
 ►Cvector< T, HeapMemory, memory_traits_lin, grow_p, STD_VECTOR >Implementation of 1-D std::vector like structure
 CVector< T, PETSC_BASE >PETSC vector for linear algebra
 Cvector< T, PtrMemory, memory_traits_lin, gp, STD_VECTOR >
 Cvector_custd_kerGrid interface available when on gpu
 Cvector_distDistributed vector
 ►Cvector_dist_commThis class is an helper for the communication of vector_dist
 Cvector_dist_expressionMain class that encapsulate a vector properties operand to be used for expressions construction
 Cvector_dist_expression< 0, openfpm::vector< aggregate< T >, memory, layout_base > >Sub class that encapsulate a vector properties operand to be used for expressions construction Temporal Expressions
 Cvector_dist_expression< 0, openfpm::vector_gpu< aggregate< T > > >Sub class that encapsulate a GPU vector properties operand to be used for expressions construction Temporal Expressions
 Cvector_dist_expression< 16384, point >This class represent a constant parameter in a vector expression
 Cvector_dist_expression< prp, double >Main class that encapsulate a double constant
 Cvector_dist_expression< prp, float >Main class that encapsulate a float constant
 Cvector_dist_expression_comp_proxy_selExpression implementation computation selector
 Cvector_dist_expression_comp_proxy_sel< false >
 Cvector_dist_expression_comp_selExpression implementation computation selector
 Cvector_dist_expression_comp_sel< comp_dev, false >
 Cvector_dist_expression_comp_sel< comp_host, true >
 Cvector_dist_expression_implMain class that encapsulate a vector properties operand to be used for expressions construction Temporal Expressions
 Cvector_dist_expression_opUnknown operation specialization
 Cvector_dist_expression_op< exp1, boost::mpl::int_< n >, VECT_COMP >It take an expression and take the component
 Cvector_dist_expression_op< exp1, exp2, VECT_DIV >Division operation
 Cvector_dist_expression_op< exp1, exp2, VECT_MUL >Multiplication operation
 Cvector_dist_expression_op< exp1, exp2, VECT_SUB >Subtraction operation
 Cvector_dist_expression_op< exp1, exp2, VECT_SUM >Sum operation
 Cvector_dist_expression_op< exp1, vector_type, VECT_APPLYKER_IN >Apply kernel operation
 Cvector_dist_expression_op< exp1, vector_type, VECT_APPLYKER_IN_GEN >Apply kernel operation
 Cvector_dist_expression_op< exp1, vector_type, VECT_APPLYKER_IN_GEN_SORT >Apply kernel operation
 Cvector_dist_expression_op< exp1, vector_type, VECT_APPLYKER_IN_SIM >Apply kernel operation
 Cvector_dist_expression_op< exp1, vector_type, VECT_APPLYKER_IN_SIM_SORT >Apply kernel operation
 Cvector_dist_expression_op< exp1, vector_type, VECT_APPLYKER_IN_SORT >Apply kernel operation
 Cvector_dist_expression_op< exp1, void, VECT_NORM_INF >Expression that encapsulate a vector Norm INF expression
 Cvector_dist_expression_op< exp1, void, VECT_SUB_UNI >It take an expression and create the negatove of this expression
 Cvector_dist_expression_op< exp1, void, VECT_SUM_REDUCE >Expression that encapsulate a vector reduction expression
 Cvector_dist_iteratorIterator that Iterate across particle indexes
 Cvector_dist_iterator_subsetIterator that Iterate across particle indexes
 Cvector_dist_ker_listThis class contain a list of all tracked vector_dist_ker around
 Cvector_dist_op_compute_op
 Cvector_dist_op_compute_op< prp, false, comp_host >
 Cvector_dist_subset
 Cvector_dist_ws
 Cvector_expression_transform
 Cvector_expression_transform< vector, true >
 Cvector_frImplementation of 1-D std::vector like structure
 Cvector_is_sort_result
 Cvector_printerThis class is a functor for "for_each" algorithm
 Cvector_reduce_selector
 Cvector_reduce_selector< false >
 Cvector_result
 Cvector_result< void, v2_type >
 CVerletListClass for Verlet list implementation
 CVerletListMClass for Verlet list implementation with Multiphase
 CVerletNNIteratorIterator for the neighborhood of the cell structures
 CVerletNNIteratorMIterator for the neighborhood of the cell structures
 ►CvertexSub-domain vertex graph node
 ►Cvertex2
 ►Cvertex3
 Cvertex_nodeThis class is a functor for "for_each" algorithm
 Cvertex_propThis class is a functor for "for_each" algorithm
 Cvl_selector_impl
 Cvl_selector_impl< false, vl_type, cl_type, 2 >
 Cvl_selector_impl< is_sorted, vl_type, cl_type, 1 >
 Cvl_selector_impl< true, vl_type, cl_type, 2 >
 Cvmpl_create_constant
 Cvmpl_reduce_prod
 Cvmpl_reduce_prod_impl
 Cvmpl_reduce_prod_impl< c, accu, stop, vmpl, true >Terminator of to_variadic
 Cvmpl_reduce_prod_stop
 Cvmpl_reduce_prod_stop< vmpl,-1 >
 Cvmpl_sum_constant
 Cvmpl_sum_constant< ele, boost::mpl::vector< vars ... > >
 Cvmpl_sum_constant_impl
 CVoidVoid structure
 CVoid_devVoid structure
 Cvtk_dimsIf it has not dims property defined the object is considered scalar
 Cvtk_dims< ObjType, true >Return the dimansionality of the object
 Cvtk_dist_edge_nodeThis class is a functor for "for_each" algorithm
 Cvtk_dist_vertex_nodeThis class is a functor for "for_each" algorithm
 Cvtk_dist_vertex_node< G, false >This class is a functor for "for_each" algorithm
 Cvtk_dist_vertex_node_array_scalar_selector
 Cvtk_dist_vertex_node_array_scalar_selector< true >
 Cvtk_edge_nodeThis class is a functor for "for_each" algorithm
 Cvtk_typeVtk type
 Cvtk_type< T, false >Vtk type
 Cvtk_vertex_nodeThis class is a functor for "for_each" algorithm
 Cvtk_vertex_node< G, false >This class is a functor for "for_each" algorithm
 Cvtk_vertex_node_array_scalar_selector
 Cvtk_vertex_node_array_scalar_selector< true >
 Cvtk_writeWrite a property that has attributes
 Cvtk_write< ele, vtk, false >Add to the vtk writer the key
 CVTKWriter
 CVTKWriter< Graph, DIST_GRAPH >
 CVTKWriter< Graph, VTK_GRAPH >
 CVTKWriter< pair, VECTOR_GRIDS >
 ►CVTKWriter< pair, VECTOR_POINTS >
 CVTKWriter< pair, VECTOR_ST_GRIDS >
 CVTKWriter< vector, VECTOR_BOX >
 ►Cvx
 CwavefrontThis class represent a wavefront of dimension dim
 Cwrap_unordered_mapWrapper of the unordered map
 Cwrite_stagClasses to copy each component into a grid and add to the VTKWriter the grid
 Cwrite_stag< T[N1]>For each component add a grid fill it, and add to the VTK writer
 Cwrite_stag< T[N1][N2]>Partial specialization for N=2 2D-Array
 Cz_kernel
 Cz_kernel< st, 1 >
 Cz_kernel< st, 2 >
 Cz_kernel< st, 3 >
 Cz_kernel< st, 4 >
 Czero_t