 _children | Provides operator to find the child particles of a Vertex or Particle |
 _parents | Provides operator to find the parent particles of a Vertex or Particle |
 alias_constructor< Args > | |
 all_of | |
  is_copy_assignable< std::pair< T1, T2 > > | |
  is_copy_constructible< std::pair< T1, T2 > > | |
 always_construct_holder< T, Value > | |
 any_container< T > | |
 any_of | |
  class_< type_, options >::is_valid_class_option< T > | |
 argument_record | Internal data structure which holds metadata about a keyword argument |
 arithmetic | Annotation to mark enums as an arithmetic type |
 array_caster< ArrayType, Value, Resizable, Size > | |
 array_caster< std::array< Type, Size >, Type, false, Size > | |
  type_caster< std::array< Type, Size > > | |
 array_caster< std::valarray< Type >, Type, true > | |
  type_caster< std::valarray< Type > > | |
 array_info< std::array< T, N > > | |
  array_info< T[N]> | |
 array_info_scalar< T > | |
  array_info< T > | |
 array_info_scalar< char[N]> | |
  array_info< char[N]> | |
 array_info_scalar< std::array< char, N > > | |
  array_info< std::array< char, N > > | |
 arrow_proxy< T > | Quick proxy class needed to implement operator-> for iterators which can't return pointers |
 Attribute | Forward declaration of GenParticle |
  BoolAttribute | Attribute that holds an Booleger implemented as an int |
  CharAttribute | Attribute that holds an Chareger implemented as an int |
  DoubleAttribute | Attribute that holds a real number as a double |
  FloatAttribute | Attribute that holds a real number as a float |
  GenCrossSection | Stores additional information about cross-section |
  GenHeavyIon | Stores additional information about Heavy Ion generator |
  GenPdfInfo | Stores additional information about PDFs |
  HEPEUPAttribute | Class for storing data for LHEF run information |
  HEPRUPAttribute | Class for storing data for LHEF run information |
  IntAttribute | Attribute that holds an Integer implemented as an int |
   AssociatedParticle | Attribute class allowing eg. a GenParticle to refer to another GenParticle |
  LongAttribute | Attribute that holds an Integer implemented as an int |
  LongDoubleAttribute | Attribute that holds a real number as a double |
  LongLongAttribute | Attribute that holds an Integer implemented as an int |
  StringAttribute | Attribute that holds a string |
  UIntAttribute | Attribute that holds an unsigned int |
  ULongAttribute | Attribute that holds an unsigned long |
  ULongLongAttribute | Attribute that holds an unsigned long long |
  VectorCharAttribute | Attribute that holds a vector of charegers of type char |
  VectorDoubleAttribute | |
  VectorFloatAttribute | Attribute that holds a vector of floategers of type float |
  VectorIntAttribute | Attribute that holds a vector of integers of type int |
  VectorLongDoubleAttribute | Attribute that holds a vector of long doubleegers of type long double |
  VectorLongIntAttribute | |
  VectorLongLongAttribute | Attribute that holds a vector of long longegers of type long long |
  VectorStringAttribute | |
  VectorUIntAttribute | Attribute that holds a vector of unsigned integers of type unsigned int |
  VectorULongAttribute | Attribute that holds a vector of unsigned longegers of type unsigned long |
  VectorULongLongAttribute | Attribute that holds a vector of unsigned long longegers of type unsigned long long |
 AttributeFeature | AttributeFeature |
 base< T > | Annotation indicating that a class derives from another given type |
 bool_constant | |
  negation< T > | |
 bools<> | Compile-time all/any/none of that check the boolean value of all template types |
 object::borrowed_t | |
 buffer_info | Information record describing a Python buffer object |
 buffer_protocol | Annotation which enables the buffer protocol for a type |
 call_guard< Ts > | |
 call_guard< T > | |
 call_guard< T, Ts...> | |
 call_guard< Ts...> | |
 call_guard<> | |
 common_iterator | |
 compare_buffer_info< T, SFINAE > | |
 compare_buffer_info< T, detail::enable_if_t< detail::is_pod_struct< T >::value > > | |
 compare_buffer_info< T, detail::enable_if_t< std::is_integral< T >::value > > | |
 constructor< Args > | |
 container_traits< T > | |
 deferred_type< T, > | Defer the evaluation of type T until types Us are instantiated |
 descr< N, Ts > | |
 dict_readonly | Python's dictionary protocol permits this to be a forward iterator |
 doc | Annotation for documentation |
 duration_caster< type > | |
 duration_caster< std::chrono::duration< Rep, Period > > | |
  type_caster< std::chrono::duration< Rep, Period > > | |
 duration_caster< std::chrono::time_point< Clock, Duration > > | |
  type_caster< std::chrono::time_point< Clock, Duration > > | |
 dynamic_attr | Annotation which enables dynamic attributes, i.e. adds __dict__ to a class |
 eigen_extract_stride< Type > | |
 eigen_extract_stride< Eigen::Map< PlainObjectType, MapOptions, StrideType > > | |
 eigen_extract_stride< Eigen::Ref< PlainObjectType, Options, StrideType > > | |
 eigen_map_caster< MapType > | |
 eigen_map_caster< Eigen::Ref< PlainObjectType, 0, StrideType > > | |
  value >>< PlainObjectType, StrideType > | |
 eigen_map_caster< Type > | |
  type_caster< Type, enable_if_t< is_eigen_dense_map< Type >::value > > | |
 EigenConformable< EigenRowMajor > | |
 EigenProps< Type_ > | |
 embedded_module | Python 2.7/3.x compatible version of PyImport_AppendInittab and error checks |
 enable_shared_from_this | |
  GenParticle | Stores particle-related information |
  GenVertex | Stores vertex-related information |
 enum_base | |
 error_scope | RAII wrapper that temporarily clears any Python error state |
 exactly_one< Predicate, Default, Ts > | |
 exactly_one< P, Default > | |
 exception | STL class |
  runtime_error | STL class |
   builtin_exception | C++ bindings of builtin Python exceptions |
   error_already_set | |
 factory< CFunc, AFunc, typename, typename > | |
 factory< CFunc, AFunc, CReturn(CArgs...), AReturn(AArgs...)> | |
 factory< Func, void_type(*)(), Return(Args...)> | |
 false_type | |
  has_operator_delete< T, SFINAE > | |
  has_operator_delete_size< T, SFINAE > | |
  is_comparable< T, SFINAE > | |
  is_complex< T > | |
  is_input_iterator< T, typename > | Check if T looks like an input iterator |
  is_instantiation< Class, T > | |
  is_std_array< T > | |
  move_always< T, SFINAE > | |
  vector_has_data_and_format< Vector, typename > | |
 field_descriptor | |
 Filter | |
  ATTRIBUTE | Filter for the attributes |
 format_descriptor< T, SFINAE > | |
 format_descriptor< char[N]> | |
 format_descriptor< std::array< char, N > > | |
 format_descriptor< std::complex< T >, detail::enable_if_t< std::is_floating_point< T >::value > > | Glibc defines I as a macro which breaks things, e.g., boost template names |
 format_descriptor< T, detail::enable_if_t< detail::array_info< T >::is_array > > | |
 format_descriptor< T, detail::enable_if_t< detail::is_pod_struct< T >::value > > | |
 format_descriptor< T, detail::enable_if_t< std::is_arithmetic< T >::value > > | |
 format_descriptor< T, detail::enable_if_t< std::is_enum< T >::value > > | |
 FourVector | Generic 4-vector |
 function_record | Internal data structure which holds metadata about a bound function (signature, overloads, etc.) |
 generic_item | |
 generic_type | |
  class_< type_, options > | |
  class_< Type > | |
   enum_< Type > | Binds C++ enumerations and enumeration classes to Python |
 GenericFeature< Feature_type > | GenericFeature defines the Feature interface GenericFeature is not intended to be used directly. The derived Feature class and its specialisations should be used |
  Feature< Feature_type > | |
  Feature< Feature_type, Dummy > | Expose GenericFeature interface to derived Feature class |
  Feature< Feature_type, typename std::enable_if< std::is_floating_point< Feature_type >::value, void >::type > | Specialisation of Feature for floating point type |
  Feature< Feature_type, typename std::enable_if< std::is_integral< Feature_type >::value, void >::type > | Specialisation of Feature for integral types |
 GenEvent | Stores event-related information |
 GenEventData | Stores serializable event information |
 GenParticleData | Stores serializable particle information |
 GenParticlePtr_greater_order | Comparison of two particles |
 GenRunInfo | Stores run-related information |
 GenRunInfoData | Stores serializable run information |
 GenVertexData | Stores serializable vertex information |
 gil_scoped_acquire | |
 gil_scoped_release | |
 handle_type_name< T > | |
 handle_type_name< args > | |
 handle_type_name< array > | |
 handle_type_name< array_t< T, Flags > > | |
 handle_type_name< bytes > | |
 handle_type_name< int_ > | |
 handle_type_name< iterable > | |
 handle_type_name< iterator > | |
 handle_type_name< kwargs > | |
 handle_type_name< none > | |
 Recursive< T >::hasId | HasID |
  Recursive< T >::idInterface< ID_type > | IDinterface |
 HEPEvent | |
  HepMC3Event | HEPEvent Interface to HepMC classes |
 HEPEVT | Fortran common block HEPEVT |
 HEPEVT_Wrapper | An interface to HEPEVT common block |
 HEPParticle | |
  HepMC3Particle | HEPParticle interface to HepMC classes |
 holder_helper< T > | |
 index_sequence<> | Index sequences |
 instance | The 'instance' type which needs to be standard layout (need to be able to use 'offsetof') |
 int_to_str< Rem, Digits > | |
 int_to_str< 0, Digits...> | |
 internals | |
 intrinsic_type< T > | Helper template to strip away type modifiers |
 intrinsic_type< const T > | |
 intrinsic_type< const T[N]> | |
 intrinsic_type< T & > | |
 intrinsic_type< T && > | |
 intrinsic_type< T * > | |
 intrinsic_type< T[N]> | |
 is_base_of | |
  is_holder_type< base, holder > | |
 is_comparable< T, enable_if_t< container_traits< T >::is_pair > > | |
 is_comparable< T, enable_if_t< container_traits< T >::is_vector > > | |
 is_copy_assignable | |
  is_copy_assignable< T, SFINAE > | |
  is_copy_assignable< Container::value_type > | |
   is_copy_assignable< Container, enable_if_t< all_of< std::is_copy_assignable< Container >, std::is_same< typename Container::value_type &, typename Container::reference > >::value > > | |
 is_copy_constructible | |
  is_copy_constructible< T, SFINAE > | |
  is_copy_constructible< Container::value_type > | |
   is_copy_constructible< Container, enable_if_t< all_of< std::is_copy_constructible< Container >, std::is_same< typename Container::value_type &, typename Container::reference >, negation< std::is_same< Container, typename Container::value_type > > >::value > > | |
 is_final | Annotation for classes that cannot be subclassed |
 is_fmt_numeric< T, SFINAE > | |
 is_fmt_numeric< std::complex< T >, detail::enable_if_t< std::is_floating_point< T >::value > > | |
 is_fmt_numeric< T, enable_if_t< std::is_arithmetic< T >::value > > | |
 is_method | Annotation for methods |
 is_new_style_constructor | Tag for a new-style __init__ defined in detail/init.h |
 is_operator | Annotation for operators |
 is_template_base_of_impl< Base > | |
 IsGoodEvent | |
 IsGoodEventDIS | |
 values_and_holders::iterator | |
 iterator_state< Iterator, Sentinel, KeyIterator, Policy > | |
 keep_alive< Nurse, Patient > | Keep patient alive while nurse lives |
 list_caster< Type, Value > | |
 list_caster< std::deque< Type, Alloc >, Type > | |
  type_caster< std::deque< Type, Alloc > > | |
 list_caster< std::list< Type, Alloc >, Type > | |
  type_caster< std::list< Type, Alloc > > | |
 list_caster< std::vector< Type, Alloc >, Type > | |
  type_caster< std::vector< Type, Alloc > > | |
 list_item | |
 loader_life_support | |
 magic_t | Union to hold first 4 byts of file, i.e. magic bytes |
 make_index_sequence_impl< N, S > | |
 make_index_sequence_impl< 0, S...> | |
 map_caster< Type, Key, Value > | |
 map_caster< std::map< Key, Value, Compare, Alloc >, Key, Value > | |
  type_caster< std::map< Key, Value, Compare, Alloc > > | |
 map_caster< std::unordered_map< Key, Value, Hash, Equal, Alloc >, Key, Value > | |
  type_caster< std::unordered_map< Key, Value, Hash, Equal, Alloc > > | |
 metaclass | Annotation which requests that a special metaclass is created for a type |
 module_::module_def | |
 module_local | Annotation that marks a class as local to the module: |
 move_only_holder_caster< type, holder_type > | |
 move_only_holder_caster< type, std::unique_ptr< type, deleter > > | |
  type_caster< std::unique_ptr< type, deleter > > | |
 multi_array_iterator< N > | |
 multiple_inheritance | Annotation indicating that a class is involved in a multiple inheritance relationship |
 MyClass | Sample class for root I/O test |
 MyRunClass | Sample class for root I/O test |
 name | Annotation for function names |
 nodelete | Dummy destructor wrapper that can be used to expose classes with a private destructor |
 nonsimple_values_and_holders | |
 npy_api | |
 npy_format_descriptor< type, SFINAE > | |
 npy_format_descriptor< char[N]> | |
 npy_format_descriptor< std::array< char, N > > | |
 npy_format_descriptor< T, enable_if_t< array_info< T >::is_array > > | |
 npy_format_descriptor< T, enable_if_t< std::is_enum< T >::value > > | |
 npy_format_descriptor_name< T, typename > | |
 npy_format_descriptor_name< T > | |
  npy_format_descriptor< T, enable_if_t< satisfies_any_of< T, std::is_arithmetic, is_complex >::value > > | |
 npy_format_descriptor_name< T, enable_if_t< is_complex< T >::value > > | |
 npy_format_descriptor_name< T, enable_if_t< std::is_floating_point< T >::value > > | |
 npy_format_descriptor_name< T, enable_if_t< std::is_integral< T >::value > > | |
 numpy_internals | |
 numpy_type_info | |
 OAttr< T > | |
 obj_attr | |
 object_api | |
  handle | |
   args_proxy | |
   kwargs_proxy | |
   object | |
    bool_ | |
    buffer | |
     array | |
      array_t< T, ExtraFlags > | |
      array_t< Scalar, array::forcecast|((props::row_major?props::inner_stride:props::outer_stride)==1?array::c_style:(props::row_major?props::outer_stride:props::inner_stride)==1?array::f_style:0)> | |
    bytes | |
    capsule | |
    dict | |
     kwargs | |
    dtype | |
    ellipsis | |
    exception< type > | |
    float_ | |
    function | |
     cpp_function | Wraps an arbitrary C++ function/method/lambda function/.. into a callable Python object |
    generic_type | Generic support for creating new Python heap types |
    int_ | |
    iterable | |
    iterator | |
    list | |
    memoryview | |
    module_ | Wrapper for Python extension modules |
    none | |
    sequence | |
    set | |
    slice | |
    staticmethod | |
    str | |
    tuple | |
     args | |
    type | |
    weakref | |
 op_< id, ot, L, R > | Operator implementation generator |
 op_impl< op_id, op_type, B, L, R > | Base template of operator implementations |
 optional_caster< T > | |
 options | |
 OstreamRedirect | |
 overload_cast< Args > | |
 overload_cast_impl< Args > | |
 override_hash | |
 pack_element< N, T, Ts > | Return the Nth element from the parameter pack |
 pack_element< 0, T, Ts...> | |
 pair_GenVertexPtr_int_greater | Order vertices with equal paths |
 PhotosEvent | |
  PhotosHepMC3Event | |
 PhotosHepMC3Event | Interface to GenEvent objects |
 PhotosHepMC3Particle | Interface to GenParticle objects |
 PhotosParticle | |
  PhotosHepMC3Particle | |
 pickle_factory< Get, Set, typename, typename > | Implementation for py::pickle(GetState, SetState) |
 pickle_factory< Get, Set, RetState(Self), NewInstance(ArgState)> | |
 Policy | |
  generic_iterator< Policy > | STL iterator template used for tuple, list, sequence and dict |
 polymorphic_type_hook_base< itype, SFINAE > | |
 polymorphic_type_hook_base< itype > | |
  polymorphic_type_hook< itype, SFINAE > | |
 polymorphic_type_hook_base< itype, detail::enable_if_t< std::is_polymorphic< itype >::value > > | |
 prepend | Mark a function for addition at the beginning of the existing overload chain instead of the end |
 Print | Provides different printing formats |
 array_t< T, ExtraFlags >::private_ctor | |
 buffer_info::private_ctr_tag | |
 process_attribute< T, SFINAE > | |
 process_attribute_default< T > | |
 process_attribute_default< arg > | |
  process_attribute< arg > | Process a keyword argument attribute (without a default value) |
 process_attribute_default< arg_v > | |
  process_attribute< arg_v > | Process a keyword argument attribute (with a default value) |
 process_attribute_default< arithmetic > | |
  process_attribute< arithmetic > | Process an 'arithmetic' attribute for enums (does nothing here) |
 process_attribute_default< base< T > > | |
  process_attribute< base< T > > | Process a parent class attribute (deprecated, does not support multiple inheritance) |
 process_attribute_default< buffer_protocol > | |
  process_attribute< buffer_protocol > | |
 process_attribute_default< call_guard< Ts...> > | |
  process_attribute< call_guard< Ts...> > | |
 process_attribute_default< const char * > | |
  process_attribute< const char * > | Process an attribute specifying the function's docstring (provided as a C-style string) |
   process_attribute< char * > | |
 process_attribute_default< doc > | |
  process_attribute< doc > | Process an attribute specifying the function's docstring |
 process_attribute_default< dynamic_attr > | |
  process_attribute< dynamic_attr > | |
 process_attribute_default< handle > | |
  process_attribute< T, enable_if_t< is_pyobject< T >::value > > | Process a parent class attribute. Single inheritance only (class_ itself already guarantees that) |
 process_attribute_default< is_final > | |
  process_attribute< is_final > | |
 process_attribute_default< is_method > | |
  process_attribute< is_method > | Process an attribute which indicates that this function is a method |
 process_attribute_default< is_new_style_constructor > | |
  process_attribute< is_new_style_constructor > | |
 process_attribute_default< is_operator> | |
  process_attribute< is_operator> | Process an attribute which indicates that this function is an operator |
 process_attribute_default< keep_alive< Nurse, Patient > > | |
  process_attribute< keep_alive< Nurse, Patient > > | |
 process_attribute_default< kw_only > | |
  process_attribute< kw_only > | Process a keyword-only-arguments-follow pseudo argument |
 process_attribute_default< metaclass > | |
  process_attribute< metaclass > | |
 process_attribute_default< module_local > | |
  process_attribute< module_local > | |
 process_attribute_default< multiple_inheritance > | |
  process_attribute< multiple_inheritance > | Process a multiple inheritance attribute |
 process_attribute_default< name > | |
  process_attribute< name > | Process an attribute specifying the function's name |
 process_attribute_default< pos_only > | |
  process_attribute< pos_only > | Process a positional-only-argument maker |
 process_attribute_default< prepend > | |
  process_attribute< prepend > | Process a 'prepend' attribute, putting this at the beginning of the overload chain |
 process_attribute_default< return_value_policy > | |
  process_attribute< return_value_policy > | Process an attribute indicating the function's return value policy |
 process_attribute_default< scope > | |
  process_attribute< scope > | Process an attribute which indicates the parent scope of a method |
 process_attribute_default< sibling > | |
  process_attribute< sibling > | Process an attribute which indicates that this is an overloaded function associated with a given sibling |
 process_attributes< Args > | Recursively iterate over variadic template arguments |
 npy_api::PyArray_Dims | |
 PyArray_Proxy | |
 PyArrayDescr_Proxy | |
 pyobject_caster< type > | |
 pyobject_caster< array_t< T, ExtraFlags > > | |
 pyobject_caster< T > | |
  type_caster< T, enable_if_t< is_pyobject< T >::value > > | |
 pyobject_tag | Tag and check to identify a class which implements the Python object API |
  object_api< Derived > | |
  object_api< accessor< Policy > > | |
   accessor< Policy > | |
 Pythia8ToHepMC3 | |
 PyVoidScalarObject_Proxy | |
 Reader | |
 Reader | Base class for all I/O readers |
  ReaderAscii | GenEvent I/O parsing for structured text files |
  ReaderAsciiHepMC2 | Parser for HepMC2 I/O files |
  ReaderGZ | GenEvent I/O parsing for structured text files compressed with gzip |
  ReaderHEPEVT | GenEvent I/O parsing and serialization for HEPEVT files |
  ReaderLHEF | GenEvent I/O parsing and serialization for LHEF files |
  ReaderPlugin | GenEvent I/O parsing and serialization using external plugin |
  ReaderRoot | GenEvent I/O parsing and serialization for root files |
  ReaderRootTree | GenEvent I/O parsing and serialization for root files based on root TTree |
 Recursive< T > | Forward declare the recursion wrapper |
 Relatives | Define a common interface that all Relatives objects will satisfy Relatives provides an operator to get the relatives of a range of different GenObject types. The following are examples |
  RelativesInterface< T > | Forward declare the Relatives interface in which _parents and _children are wrapped |
 remove_class< T > | Strip the class from a method type |
 remove_class< R(C::*)(A...) const > | |
 remove_class< R(C::*)(A...)> | |
 same_size< T > | |
 scope | Annotation for parent scope |
 scoped_interpreter | |
 scoped_ostream_redirect | |
  scoped_estream_redirect | |
 select_indices_impl< ISeq, size_t, > | Make an index sequence of the indices of true arguments |
 select_indices_impl< conditional_t< B, index_sequence< IPrev..., I >, index_sequence< IPrev...> >, I+1, Bs...> | |
  select_indices_impl< index_sequence< IPrev...>, I, B, Bs...> | |
 Selector | Selector is an interface to "standard" Features that are valid for both integral and floating point comparisons |
  SelectorWrapper< T > | Forward declaration of SelectorWrapper |
  StandardSelector | StandardSelector |
  SelectorWrapper< double > | |
  SelectorWrapper< int > | |
 self_t | |
 sequence_fast_readonly | Lightweight iterator policy using just a simple pointer: see PySequence_Fast_ITEMS |
 sequence_item | |
 sequence_slow_readwrite | Full read and write access using the sequence protocol: see detail::sequence_accessor |
 set_caster< Type, Key > | |
 set_caster< std::set< Key, Compare, Alloc >, Key > | |
  type_caster< std::set< Key, Compare, Alloc > > | |
 set_caster< std::unordered_set< Key, Hash, Equal, Alloc >, Key > | |
  type_caster< std::unordered_set< Key, Hash, Equal, Alloc > > | |
 Setup | Configuration for HepMC |
 sibling | Annotation indicating that a function is an overload associated with a given "sibling" |
 simple_collector< policy > | |
 sort_by_id_asc | Comparison of two particle by id |
 options::state | |
 object::stolen_t | |
 str_attr | |
 streambuf | |
  pythonbuf | |
 string_caster< StringType, IsView > | |
 string_caster< std::basic_string< CharT, Traits, Allocator > > | |
  type_caster< std::basic_string< CharT, Traits, Allocator >, enable_if_t< is_std_char_type< CharT >::value > > | |
 strip_function_object< F > | |
 TagBase | |
  Clus | |
  Cut | |
  EventFile | |
  Generator | |
  HEPEUP | |
  HEPRUP | |
  MergeInfo | |
  PDFInfo | |
  ProcInfo | |
  Scale | |
  Scales | |
  Weight | |
  WeightGroup | |
  WeightInfo | |
  XSecInfo | |
 TauolaEvent | |
  TauolaHepMC3Event | |
 TauolaHepMC3Event | Interface to GenEvent objects |
 TauolaHepMC3Particle | Interface to GenParticle objects |
 TauolaParticle | |
  TauolaHepMC3Particle | |
 TGMainFrame | |
  HepMC3ViewerFrame | Definition of class HepMC3ViewerFrame used for simple GUI viewer |
 Timer | Used to benchmark MC generators |
 GenRunInfo::ToolInfo | Interrnal struct for keeping track of tools |
 true_type | |
  has_operator_delete< T, void_t< decltype(static_cast< void(*)(void *)>(T::operator delete))> > | |
  has_operator_delete_size< T, void_t< decltype(static_cast< void(*)(void *, size_t)>(T::operator delete))> > | |
  is_comparable< T, enable_if_t< container_traits< T >::is_element &&container_traits< T >::is_comparable > > | |
  is_complex< std::complex< T > > | |
  is_holder_type< base, std::unique_ptr< base, deleter > > | |
  is_input_iterator< T, void_t< decltype(*std::declval< T & >()), decltype(++std::declval< T & >())> > | |
  is_instantiation< Class, Class< Us...> > | |
  is_std_array< std::array< T, N > > | |
  vector_has_data_and_format< Vector, enable_if_t< std::is_same< decltype(format_descriptor< typename Vector::value_type >::format(), std::declval< Vector >().data()), typename Vector::value_type * >::value > > | |
 tuple_caster< Tuple, Ts > | |
 tuple_caster< std::pair, T1, T2 > | |
  type_caster< std::pair< T1, T2 > > | |
 tuple_caster< std::tuple, Ts...> | |
  type_caster< std::tuple< Ts...> > | |
 tuple_item | |
 call_guard< T, Ts...>::type | |
 type_caster< bool > | |
 type_caster< CharT, enable_if_t< is_std_char_type< CharT >::value > > | |
 type_caster< std::chrono::time_point< std::chrono::system_clock, Duration > > | |
 type_caster< std::complex< T > > | |
 type_caster< std::function< Return(Args...)> > | |
 type_caster< std::reference_wrapper< type > > | |
 type_caster< T, enable_if_t< std::is_arithmetic< T >::value &&!is_std_char_type< T >::value > > | |
 type_caster< Type, enable_if_t< is_eigen_dense_plain< Type >::value > > | |
 type_caster< Type, enable_if_t< is_eigen_other< Type >::value > > | |
 type_caster< Type, enable_if_t< is_eigen_sparse< Type >::value > > | |
 type_caster< unchecked_reference< T, Dim > > | |
  type_caster< unchecked_mutable_reference< T, Dim > > | |
 type_caster< value_and_holder > | |
 type_caster_generic | |
  type_caster_base< type > | Generic type caster for objects stored on the heap |
   copyable_holder_caster< type, holder_type > | Type caster for holder types like std::shared_ptr, etc |
   type_caster< type, SFINAE > | |
   type_caster< type > | |
  type_caster_base< StringType > | |
   type_caster< StringType > | |
  type_caster_base< T > | |
   copyable_holder_caster< T, std::shared_ptr< T > > | |
    type_caster< std::shared_ptr< T > > | Specialize for the common std::shared_ptr, so users don't need to |
 type_equal_to | |
 type_hash | |
 type_info | |
 type_list<> | Helper template which holds a list of types |
 type_record | Special data structure which (temporarily) holds metadata about a bound class |
 unchecked_reference< T, Dims > | |
  unchecked_mutable_reference< T, Dims > | |
 undefined_t | Type for an unused type slot |
 Units | Stores units-related enums and conversion functions |
 unpacking_collector< policy > | |
 ValidationControl | Runs multiple validation tools |
 ValidationTool | Virtual Interface to validation tools |
  McTesterValidationTool | Interface to MCTester |
  OutputValidationTool | Interface for validatio to Pythia |
  PhotosValidationTool | Interface for validatio to Photos |
  PythiaValidationTool | Interface for validatio to Pythia |
  SimpleEventTool | Simple validation |
  TauolaValidationTool | Interface for validatio to Tauola |
 value_and_holder | |
 values_and_holders | |
 variant_caster< Variant > | Generic variant caster |
 variant_caster< V< Ts...> > | |
 variant_caster_visitor | Visit a variant and cast any found type to Python |
 vector< T > | STL class |
  EventGroup | |
 vectorize_arg< T > | |
 vectorize_helper< Func, Return, Args > | |
 vectorize_returned_array< Func, Return, Args > | |
 vectorize_returned_array< Func, void, Args...> | |
 visit_helper< Variant > | |
 void_caster< T > | |
 void_caster< std::nullptr_t > | |
  type_caster< std::nullptr_t > | |
 void_caster< void_type > | |
  type_caster< void_type > | |
   type_caster< void > | |
 void_t_impl<> | |
 void_type | Helper type to replace 'void' in some expressions |
 Writer | Base class for all I/O writers |
  AnalysisExample | Example analysis. Produces a rapidity distribution of final state particles |
  WriterAscii | GenEvent I/O serialization for structured text files |
  WriterAsciiHepMC2 | GenEvent I/O serialization for structured text files |
  WriterDOT | GenEvent I/O output to dot files that should be processed by graphviz or other software |
  WriterHEPEVT | GenEvent I/O serialization for HEPEVT files |
   WriterHEPEVTZEUS | GenEvent I/O output to files readable by ZEUS software |
  WriterPlugin | GenEvent I/O parsing and serialization using external plugin |
  WriterRoot | GenEvent I/O serialization for root files |
  WriterRootTree | GenEvent I/O serialization for root files based on root TTree |
   WriterRootTreeOPAL | GenEvent I/O output to files similar to these produced by OPAL software |
 Writer | |
 XMLTag | |