| swarm::gpu::bppt::AdaptiveTimeStep | Data structure for adaptive time step |
| gpulog::internal::alignment< T > | Type alignment querying |
| gpulog::internal::alignment< body_set< N > > | Body_set_cls is a proxy for an array of bodies, so make sure it reports the same alignment as body[N], as well as sizeof() return alignment of body[N] |
| gpulog::internal::alignment< float2 > | Alignment overrides to make the host packing compatible with device packing See table B-1 in CUDA 2.2 Programming Guide for reference |
| gpulog::internal::arginfo | Arginfo (mainly used for debugging) |
| gpulog::internal::argio< T > | I/o support: scalar PODs |
| gpulog::internal::argio< array< T > > | I/o support: unbound array (array<>) specialization |
| gpulog::internal::argio< body_set< N > > | Template partial specialization of argio class from gpulog for body_set |
| gpulog::internal::argio< T * > | Force a compiler error if the user attempts to serialize a pointer |
| gpulog::internal::argio< T[N]> | Presized array read/write specialization |
| gpulog::internal::array< T > | Unbound array alloc request class |
| peyton::io::basic_bstream< _CharT, _Traits > | Input/output stream |
| peyton::io::basic_ibstream< _CharT, _Traits > | Input stream |
| peyton::io::basic_obstream< _CharT, _Traits > | Output stream |
| swarm::basic_plugin< T > | Template class for easy plugin development |
| swarm::basic_plugin_initializer< T > | Template class for easy plugin development and management |
| swarm::log::bdb_writer | Writer plugin to output the log into a Berkeley-DB database |
| swarm::log::binary_writer | A writer plugin that writes to binary files |
| swarm::snapshot::body | Data structure used in binary files. parameters for each body. nbod instances of this struct follows after each sys data structure |
| swarm::EnsembleBase< _CHUNK_SIZE, _NUM_BODY_ATTRIBUTES, _NUM_SYS_ATTRIBUTES >::Body | Concrete structure of Body This class is specifically designed to be used with CoalescedStruct array |
| swarm::log::body_set< N > | Body_set class: hold a set of indices to bodies in a given system in a given ensemble |
| choose< T, N, MAXN, B, P > | Template object function to choose the appropriate instantiation of a function at compile time |
| swarm::CoalescedMemberArray< _value_type, _N, _CHUNK_SIZE > | To use as an array for members of Body and Sys |
| swarm::CoalescedStructArray< Item, _Scalar, _CHUNK_SIZE > | Array of structures with coalecsed access |
| swarm::monitors::combine< log_t, Monitor1, Monitor2 > | Template to allow developer to join two monitors Signal is true if either monitor returns true |
| swarm::monitors::combine_monitors_params< Param1, Param2 > | Define parameters for combining monitors |
| swarm::compile_time_params_t< i > | This is a wrapper for a compile time integere value. Because CUDA chokes when encountered with integer template values |
| swarm::config | Basic dictionary like data structure to hold configuration |
| cudaException | Unrecoverable CUDA error, thrown by cudaErrCheck macro |
| peyton::io::binary::datatype_info | Type information structure for manifest |
| DefaultAllocator< T > | Default allocator that uses C++ new/delete This class uses standard C++ routines for allocation and memory manipulation: new[], delete[] and std::copy |
| peyton::util::demangling_error | Defines run time error handling |
| gpulog::internal::dev_internals | Device internals encapsulation for log_base<> template |
| DeviceAllocator< T > | CUDA device memory allocator that uses cudaMalloc,cudaMemcpy,cudaFree It creates a pointer that is allocated on the device. The pointer cannot be used by the caller and should only be passed to a CUDA kernel. The copy uses cudaMemcpy to transfer data between 2 device arrays |
| swarm::DoubleCoalescedStruct< W > | CoalescedStruct for double data type |
| swarm::EnsembleAlloc< W, _Allocator > | Allocator based version of ensemble containing memory management routines It takes an allocator as a parameter and uses the allocator for allocate, deallocate and copying the ensemble |
| swarm::EnsembleBase< _CHUNK_SIZE, _NUM_BODY_ATTRIBUTES, _NUM_SYS_ATTRIBUTES > | Ensemble data structure containing nbody systems |
| swarm::gpu::bppt::EulerPropagator< T, Gravitation > | GPU implementation of euler propagator It is of no practical use |
| swarm::gpu::bppt::EulerPropagatorParams | Paramaters for EulerPropagator |
| swarm::log::event_record< NumData > | Define event_record class |
| swarm::log::event_record< 0 > | Specialized version for NumData=0 to allow for no double data (is this needed?) |
| swarm::log::event_record<-1 > | Specialized version for NumData=-1 to allow for variable length |
| f2dstruct< T > | Printf API |
| swarm::gpu::bppt::FixedTimeStep | Data structure for fixed time step |
| swarm::gpu::bppt::generic< Propagator, Monitor, Gravitation > | Generic integrator for rapid creation of new integrators |
| swarm::gpu::bppt::GravitationAcc< T > | Templatized Class to calculate acceleration and jerk in parallel |
| swarm::gpu::bppt::GravitationAcc_GR< T > | Templatized Class to calculate acceleration and jerk in parallel |
| swarm::gpu::bppt::GravitationAccJerk< T > | Templatized Class working as a function object to calculate acceleration and jerk in parallel |
| swarm::gpu::bppt::GravitationAccJerkScalars< W > | Unit type of the acceleration and jerk pairs shared array |
| swarm::gpu::bppt::GravitationAccScalars< W > | Unit type of the acceleration pairs shared array |
| swarm::gpu::bppt::GravitationLargeN< T > | Gravitation calculation class for large number of bodies in a system |
| swarm::gpu::bppt::GravitationMediumN< T > | Gravitation calculation for a number of bodies between 10-20 *EXPERIMENTAL*: This class is not thoroughly tested |
| swarm::snapshot::header | Data structure used in binary files. This is meant to be found at offset 0 of the file |
| gpulog::internal::header | Log record header |
| swarm::gpu::bppt::hermite< Monitor, Gravitation > | GPU implementation of PEC2 Hermite integrator |
| swarm::gpu::bppt::hermite_adap< Monitor, Gravitation > | GPU implementation of PEC2 Hermite integrator w/ adaptive time step |
| swarm::cpu::hermite_cpu< Monitor > | CPU implementation of PEC2 Hermite integrator |
| swarm::gpu::bppt::HermitePropagator< T, Gravitation > | GPU implementation of hermite propagator It is of no practical use since hermite integrator implements the same functionaliy faster |
| swarm::gpu::bppt::HermitePropagatorParams | Paramaters for HermitePropagator |
| swarm::log::host_array_writer | A writer plugin that keeps the data in the memory |
| gpulog::internal::host_internals | Host internals encapsulation for log_base<> template |
| gpulog::internal::host_log | Host specialization, with memory management |
| HostAllocator< T > | CUDA host memory allocator uses cudaMallocHost,cudaMemcpy,cudaFreeHost Host memory allocator is similar to malloc. The pointers point to memory that can be used by C++. However, CUDA documentation claims that copying to device memory from a CUDA allocated host array is faster than memory allocated using malloc |
| swarm::query::idx_t | Sort the raw outputs |
| gpulog::internal::ilogstream | Stream of logrecords |
| swarm::query::index_creator< Cmp > | Define class for creating index |
| swarm::query::swarmdb::index_entry | Structure for index entry |
| swarm::gpu::bppt::integrator | Common functionality and skeleton for body-pair-per-thread integrators Common tasks include:
- Setting up the CUDA grid and block values
|
| swarm::integrator | Interface class for all integrators |
| swarm::gpu::integrator | Interface class for all GPU based integrators |
| swarm::integrator_plugin_initializer< T > | Template to add a new integrator to swarm |
| boost::is_pod< ::std::pair< First, Second > > | Marks a std::pair of PODs as a POD |
| swarm::key_not_found | Raised when a key not found in the configuration |
| swarm::launch_template_choose< N > | Structure crafted to be used with choose template |
| gpulog::internal::log_base< A > | Log template with the write() implementations |
| swarm::monitors::log_time_interval< log_t > | Monitor that logs the entire state of systems at periodic intervals of approximately "log_interval" Systems may be integrated for more than log interval before another log entry is written |
| swarm::monitors::log_time_interval_params | Parameters for log_time_interval monitor log_on_interval (bool): log_interval (real): time between sucessive logging |
| swarm::monitors::log_transit< log_t > | Monitor that logs (the estimated transit time, the estimated minimum impact parameter in units of stellar radii, and the estimated velocity projected onto the planet of the sky in units of stellar radii per time) at times near a transit *EXPERIMENTAL*: This class is not thoroughly tested |
| swarm::monitors::log_transit_params | Parameters for log_transit monitor log_transit_tol (real): desired precision of transit times (zero makes inactive) |
| gpulog::internal::logrecord | Log unserialization - reads elements from a log record |
| swarm::log::manager | Manage CPU/GPU logs and writing them to appropriate output |
| MappedHostAllocator< T > | CUDA host memory allocator similar to HostAllocator using device mapped memory A Mapped memory is accessible on host and device. However, the pointers are different and this complicated everything. According to CUDA manual, version 4.0 of CUDA SDK uses unified pointers so there in to need to map the pointer. In that case, The pointer obtained using this allocator can be passed to a kernel |
| peyton::system::MemoryMap | Class for memory mapping |
| peyton::system::MemoryMapError | Define run time error with memory mapping |
| peyton::system::MemoryMapVector< T > | Class for memory map array |
| swarm::gpu::bppt::MidpointPropagator< T, Gravitation > | GPU implementation of modified midpoint method propagator |
| swarm::gpu::bppt::MidpointPropagatorParams | Paramaters for MidpointPropagator |
| mmapped_file_with_header< Header > | Define class memory map with header |
| swarm::monitors::monitor_template< log_t > | Empty monitor to use as a template |
| swarm::monitors::monitor_template_params | Structure for monitor_template_params |
| swarm::cpu::mvs_cpu< Monitor > | CPU implementation of mixed variables symplectic propagator: template<class Monitor> *EXPERIMENTAL*: This class is not thoroughly tested |
| swarm::gpu::bppt::MVSPropagator< T, Gravitation > | GPU implementation of mixed variables symplectic propagator |
| swarm::gpu::bppt::MVSPropagatorParams | Paramaters for MvsPropagator |
| swarm::log::null_writer | A writer plugin to use when the log output is not needed |
| parameter_range | Data structure hold the values for a range of parameters |
| swarm::monitors::stop_on_ejection_or_close_encounter_or_crossing_orbit< L >::params | Defines parameter structure |
| swarm::monitors::stop_on_ejection_or_close_encounter< L >::params | Define the structure params |
| gpulog::internal::pktsize< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 > | Struct template to compile-time compute (properly aligned) offsets and sizes of passed types |
| swarm::plugin | Abstract interface class for all plugins |
| swarm::plugin_initializer< T > | Template class to add your plugin to the list of plugins |
| swarm::plugin_not_found | Thrown when a nonexisting plugin is requested |
| swarm::query::range< T > | Structure defines data range |
| swarm::EnsembleBase< _CHUNK_SIZE, _NUM_BODY_ATTRIBUTES, _NUM_SYS_ATTRIBUTES >::range_t | A simple data structure to calculate statistical measures on a range of values |
| swarm::snapshot::readfileexception | Raised when an error encountered reading a text or binary file. Used in load and load_text |
| swarm::query::swarmdb::result | Defines query result structure |
| swarm::gpu::bppt::rkck< AdaptationStyle, Monitor, Gravitation > | Runge Kutta Cash Karp integrator Fixed/Adaptive |
| swarm::runtime_error | Unrecoverable error exception |
| swarm::query::swarmdb::snapshots | Defines snapshots structure |
| swarm::monitors::stop_on_all_but_two_at_large_distance< log_t > | Simple monitor that signals and logs when no more than two bodies are within a distance "rmax" of origin or another body |
| swarm::monitors::stop_on_all_but_two_at_large_distance_params | Parameters for stop_on_all_but_two_at_large_distance monitor deactivate_on_close_encounter (bool): log_on_close_encounter (bool): verbose_on_close_encounter (bool): rmax (real): minimum distance between bodies to be considered isolated |
| swarm::monitors::stop_on_any_large_distance< log_t > | Simple monitor that logs when any one body is separated from *EXPERIMENTAL*: This class is not thoroughly tested |
| swarm::monitors::stop_on_any_large_distance_params | Parameters for stop_on_any_large_distance monitor deactivate_on_close_encounter (bool): log_on_close_encounter (bool): verbose_on_close_encounter (bool): rmax (real): minimum distance between bodies to trigger |
| swarm::monitors::stop_on_close_encounter< log_t > | Simple monitor to detect close encounters |
| swarm::monitors::stop_on_close_encounter_param | Parameters for stop_on_close_encounter monitor deactivate_on_close_encounter (bool): log_on_close_encounter (bool): verbose_on_close_encounter (bool): close_approach (real): maximum distance in Hill radii to trigger action |
| swarm::monitors::stop_on_collision< log_t > | Simple monitor to detect physical collisions |
| swarm::monitors::stop_on_collision_param | Parameters for stop_on_collision monitor deactivate_on_collision (bool): log_on_collision (bool): verbose_on_collision (bool): collision_distance_to_origin (real): default distance or collision if individual radii not avaliable |
| swarm::monitors::stop_on_crossing_orbit< log_t > | Stopping monitor to detect crossing orbits for planets *EXPERIMENTAL*: This class is not thoroughly tested |
| swarm::monitors::stop_on_crossing_orbit_params | Parameters for stop_on_crossing_orbit monitor deactivate_on_crossing (bool): log_on_crossing (bool): verbose_on_crossing (bool): |
| swarm::monitors::stop_on_ejection< log_t > | Simple monitor that signals and logs when any body (other than body 0) meets all of the following criteria: 1 |
| swarm::monitors::stop_on_ejection_or_close_encounter< L > | Combination of stop_on_ejcetion and stop_on_close_encounter *EXPERIMENTAL*: This class is not thoroughly tested |
| swarm::monitors::stop_on_ejection_or_close_encounter_or_crossing_orbit< L > | Combination of stop_on_ejcetion, stop_on_close_encounter and stop_on_crossing_orbit |
| swarm::monitors::stop_on_ejection_params | Parameters for stop_on_ejection monitor deactivate_on_ejection (bool): log_on_ejection (bool): verbose_on_ejection (bool): rmax (real): minimum distance to check for ejections |
| stopwatch | Class for benchmarking cpu & gpu performance. Based on NVIDIA's LinuxStopWatch class |
| swarm::query::swarmdb | Defines swarmdb class |
| swarm::snapshot::sys | Data structure used in binary files. parameters for a system. This comes right after the header and is followed by nbod number of body structs |
| swarm::EnsembleBase< _CHUNK_SIZE, _NUM_BODY_ATTRIBUTES, _NUM_SYS_ATTRIBUTES >::Sys | Structure for quantities stored per system |
| swarm::query::sysinfo | Define structure sysinfo |
| swarm::EnsembleBase< _CHUNK_SIZE, _NUM_BODY_ATTRIBUTES, _NUM_SYS_ATTRIBUTES >::SystemRef | Reference to a system within an ensemble |
| swarm::EnsembleBase< _CHUNK_SIZE, _NUM_BODY_ATTRIBUTES, _NUM_SYS_ATTRIBUTES >::SystemRefConst | Constant encapsulation of SystemRef If the ens is constant use: SystemRefConst s = ens[i]; |
| swarm::gpu::bppt::hermite_adap< Monitor, Gravitation >::SystemSharedData< T > | Date structure for system shared data |
| gpulog::internal::ttrait< T > | Type traits, scalar type |
| gpulog::internal::ttrait< array< T > > | Type traits, array type |
| gpulog::internal::ttrait< body_set< N > > | Return traits of body[N] |
| gpulog::internal::ttrait< T * > | Type traits, pointer type |
| gpulog::internal::ttrait< T[N]> | Type traits, array type |
| gpulog::internal::ttrait< Tunspec > | Type traits, type unspecified |
| gpulog::internal::Tunspec | "unspecified datatype" marker for pktsize structure |
| TutorialIntegrator< Monitor, Gravitation > | The integrator does not have to be a template, but defining it as |
| TutorialPropagator< T, Gravitation > | Class TutorialPropagator |
| TutorialPropagatorParams | Data structure for TutorialPropagator |
| Unroller< Begin, End, Step > | Template helper for unrolling of loops This template helper is used for unrolling loops This and the template specialization below provide a pattern matching recursive function that is evaluated at compile time and generates code for unrolling a function |
| swarm::gpu::bppt::VerletPropagator< T, Gravitation > | GPU implementation of Verlet propagator |
| swarm::gpu::bppt::VerletPropagatorParams | Paramaters for VerletPropagator |
| swarm::snapshot::writefileexception | Raised when an error encountered writing to a text or binary file. Used in save and save_text |
| swarm::log::writer | Abstract output writer interface |
| swarm::writer_plugin_initializer< T > | Template to add a new writer plugin to swarm |
