particles.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "AMUSE tutorial on particle sets\n",
    "====================\n",
    "\n",
    "\n",
    "AMUSE particle sets are a handy tool for storing data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Load in the amuse units module\n",
    "from amuse.units import units\n",
    "from amuse.lab import Particles"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sun= Particle(5327607734827039294, set=<140344016938512>\n",
      "    , mass=1.0 MSun\n",
      "    , vx=0.0 kms\n",
      "    , vy=0.0 kms\n",
      "    , vz=0.0 kms\n",
      "    , x=0.0 au\n",
      "    , y=0.0 au\n",
      "    , z=0.0 au)\n"
     ]
    }
   ],
   "source": [
    "# Declare a single particle\n",
    "sun_and_earth = Particles(2)\n",
    "sun = sun_and_earth[0]\n",
    "sun.mass = 1 | units.MSun\n",
    "sun.position = (0,0,0) | units.au\n",
    "sun.velocity = (0,0,0) | units.kms\n",
    "print(\"Sun=\", sun)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Earth= Particle(11549171301815924007, set=<140344016938512>\n",
      "    , mass=3.00273515275e-06 MSun\n",
      "    , vx=0.0 kms\n",
      "    , vy=29.7885123292 kms\n",
      "    , vz=0.0 kms\n",
      "    , x=1.0 au\n",
      "    , y=0.0 au\n",
      "    , z=0.0 au)\n"
     ]
    }
   ],
   "source": [
    "# Now declare the Earth\n",
    "from amuse.units.constants import G\n",
    "earth = sun_and_earth[1]\n",
    "earth.mass = 1 | units.MEarth\n",
    "earth.position = (1, 0, 0) | units.au\n",
    "def relative_orbital_velocity(mass, distance):\n",
    "    return (G*mass/distance).sqrt()\n",
    "vorb = relative_orbital_velocity(sun_and_earth.mass.sum(), \n",
    "                                earth.position.sum())\n",
    "earth.velocity = (0, 1, 0) * vorb\n",
    "print(\"Earth=\", earth)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                 key         mass           vx           vy           vz            x            y            z\n",
      "                   -         MSun          kms          kms          kms           au           au           au\n",
      "====================  ===========  ===========  ===========  ===========  ===========  ===========  ===========\n",
      " 5327607734827039294    1.000e+00    0.000e+00   -8.945e-05    0.000e+00   -3.003e-06    0.000e+00    0.000e+00\n",
      "11549171301815924007    3.003e-06    0.000e+00    2.979e+01    0.000e+00    1.000e+00    0.000e+00    0.000e+00\n",
      "====================  ===========  ===========  ===========  ===========  ===========  ===========  ===========\n"
     ]
    }
   ],
   "source": [
    "sun_and_earth.move_to_center()\n",
    "print(sun_and_earth)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, let's give the particles a specific name (or other attribute)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "setattr(sun_and_earth, \"name\", \"\")\n",
    "sun_and_earth.name = [\"sun\", \"earth\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "How we have declared the particles and moved them to the center of mass. We can also search for a specific particle. For example, the one with the \"sun\" in the attribute \"name\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sun= Particle(5327607734827039294, set=<140344016938512>\n",
      "    , mass=1.0 MSun\n",
      "    , name=sun\n",
      "    , vx=0.0 kms\n",
      "    , vy=-8.9446744534e-05 kms\n",
      "    , vz=0.0 kms\n",
      "    , x=-3.00272613635e-06 au\n",
      "    , y=0.0 au\n",
      "    , z=0.0 au)\n"
     ]
    }
   ],
   "source": [
    "earth = sun_and_earth[sun_and_earth.name==\"earth\"]\n",
    "print(\"Sun=\", sun)"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "We can add a moon in orbit around the earth"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "moon=                  key         mass         name           vx           vy           vz            x            y            z\n",
      "                   -           kg         none  44597309335878.1 * m * s**-1  44597309335878.1 * m * s**-1  44597309335878.1 * m * s**-1           km           km           km\n",
      "====================  ===========  ===========  ===========  ===========  ===========  ===========  ===========  ===========\n",
      " 5429030374334993932    7.348e+22         moon    0.000e+00    2.297e-11    0.000e+00    3.844e+05    0.000e+00    0.000e+00\n",
      "====================  ===========  ===========  ===========  ===========  ===========  ===========  ===========  ===========\n"
     ]
    }
   ],
   "source": [
    "moon = Particles(1)\n",
    "moon.name = \"moon\"\n",
    "moon.mass = 7.34767309e+22 | units.kg\n",
    "moon.position = (384400, 0, 0) | units.km\n",
    "vorb = relative_orbital_velocity(earth.mass + moon.mass, \n",
    "                                 moon.position.sum())\n",
    "moon.velocity = (0, 1, 0) * vorb\n",
    "print(\"moon=\", moon)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The moon, however, is not somewhere inside the Sun with zero velocity which is not good. We will have to replace the moon to make it orbit around the Earth. We do that by simply adding the positions and velocity of Earth to the moon's."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "moon.position += earth.position\n",
    "moon.velocity += earth.velocity"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And we can add the moon to the Sun and Earth system"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<amuse.datamodel.particles.Particle at 0x7fa46347c640>"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sun_and_earth.add_particle(moon)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note the use of the singular here, because we only add a single particle to the particle set sun_and_earth.\n",
    "It is probably better to rename the sun_and_earth now."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "solarsystem = sun_and_earth"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is important now to recenter the entire system, because by adding the moon we shifted the center of mass."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Solar system:                  key         mass         name           vx           vy           vz            x            y            z\n",
      "                   -         MSun         none          kms          kms          kms           au           au           au\n",
      "====================  ===========  ===========  ===========  ===========  ===========  ===========  ===========  ===========\n",
      " 5327607734827039294    1.000e+00          sun    0.000e+00   -9.059e-05    0.000e+00   -3.040e-06    0.000e+00    0.000e+00\n",
      "11549171301815924007    3.003e-06        earth    0.000e+00    2.979e+01    0.000e+00    1.000e+00    0.000e+00    0.000e+00\n",
      " 5429030374334993932    3.694e-08         moon    0.000e+00    3.081e+01    0.000e+00    1.003e+00    0.000e+00    0.000e+00\n",
      "====================  ===========  ===========  ===========  ===========  ===========  ===========  ===========  ===========\n"
     ]
    }
   ],
   "source": [
    "solarsystem.move_to_center()\n",
    "print(\"Solar system:\", solarsystem)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can now manipulate the planetary system, or query it.\n",
    "for example by querying the masses."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "mass= [333029.704297, 1.0, 0.0123031263019] MEarth\n"
     ]
    }
   ],
   "source": [
    "print(\"mass=\", solarsystem.mass.in_(units.MEarth))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This gives us a list of the masses of all objects, in units the the earth's mass. In fact, each of the particle's attributes is a simple numpy array: it can be assigned and manipulated as such.\n",
    "\n",
    "Another way to ecquire the same information could be done as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "mass= [  3.33029704e+05   1.00000000e+00   1.23031263e-02]\n"
     ]
    }
   ],
   "source": [
    "print(\"mass=\", solarsystem.mass/solarsystem[1].mass)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In some (hopefully rare) cases you may want to use the particle set or its attributes as simple numpy arrays, without the units.\n",
    "This is easily achieved by stripping the unit from the array. This can be realied by explicitely querying the selected parameter with that specific unit."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ -1.47371911e-11,   0.00000000e+00,   0.00000000e+00],\n",
       "       [  4.84812207e-06,   0.00000000e+00,   0.00000000e+00],\n",
       "       [  4.86057963e-06,   0.00000000e+00,   0.00000000e+00]])"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "solarsystem.position.value_in(units.parsec)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "which, in this case, gives you a 2-dimensional *numpy.array* of the positions of star, planet and moon in units of a parsec."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, you may want to query the particle set solarsystem.\n",
    "for example by asking what are all its attributes.\n",
    "this can be done as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['GLOBAL_DERIVED_ATTRIBUTES',\n",
       " 'LagrangianRadii',\n",
       " 'Qparameter',\n",
       " '__add__',\n",
       " '__array__',\n",
       " '__array_interface__',\n",
       " '__array_struct__',\n",
       " '__class__',\n",
       " '__contains__',\n",
       " '__delattr__',\n",
       " '__dict__',\n",
       " '__dir__',\n",
       " '__doc__',\n",
       " '__eq__',\n",
       " '__format__',\n",
       " '__ge__',\n",
       " '__getattr__',\n",
       " '__getattribute__',\n",
       " '__getitem__',\n",
       " '__gt__',\n",
       " '__hash__',\n",
       " '__init__',\n",
       " '__init_subclass__',\n",
       " '__iter__',\n",
       " '__le__',\n",
       " '__len__',\n",
       " '__lt__',\n",
       " '__module__',\n",
       " '__ne__',\n",
       " '__new__',\n",
       " '__or__',\n",
       " '__reduce__',\n",
       " '__reduce_ex__',\n",
       " '__repr__',\n",
       " '__setattr__',\n",
       " '__sizeof__',\n",
       " '__str__',\n",
       " '__sub__',\n",
       " '__subclasshook__',\n",
       " '__weakref__',\n",
       " '_add_indices_in_attribute_storage',\n",
       " '_as_masked_subset_in',\n",
       " '_attributes_for_dir',\n",
       " '_convert_from_entities_or_quantities',\n",
       " '_convert_to_entities_or_quantities',\n",
       " '_convert_to_entities_or_quantities_async',\n",
       " '_convert_to_entity_or_quantity',\n",
       " '_factory_for_new_collection',\n",
       " '_get_derived_attribute_value',\n",
       " '_get_particle',\n",
       " '_get_particle_unsave',\n",
       " '_get_value_of_attribute',\n",
       " '_get_values_for_entity',\n",
       " '_get_version',\n",
       " '_is_superset',\n",
       " '_masked_subset',\n",
       " '_original_set',\n",
       " '_remove_indices_in_attribute_storage',\n",
       " '_set_value_of_attribute',\n",
       " '_set_values_for_entity',\n",
       " '_subset',\n",
       " '_values_of_particle',\n",
       " 'acceleration',\n",
       " 'add_attribute_domain',\n",
       " 'add_caching_function_attribute',\n",
       " 'add_calculated_attribute',\n",
       " 'add_function_attribute',\n",
       " 'add_global_caching_function_attribute',\n",
       " 'add_global_calculated_attribute',\n",
       " 'add_global_function_attribute',\n",
       " 'add_global_vector_attribute',\n",
       " 'add_particle',\n",
       " 'add_particle_function_attribute',\n",
       " 'add_particles',\n",
       " 'add_particles_to_store',\n",
       " 'add_spin',\n",
       " 'add_vector_attribute',\n",
       " 'all_attributes',\n",
       " 'angular_momentum',\n",
       " 'are_all_keys_in_set',\n",
       " 'as_binary_tree',\n",
       " 'as_set',\n",
       " 'attribute_for_set',\n",
       " 'binaries',\n",
       " 'bound_subset',\n",
       " 'box_counting_dimension',\n",
       " 'caching_function_for_set',\n",
       " 'can_extend_attributes',\n",
       " 'center_of_mass',\n",
       " 'center_of_mass_velocity',\n",
       " 'check_attribute',\n",
       " 'cluster_core',\n",
       " 'collection_attributes',\n",
       " 'compressed',\n",
       " 'connected_components',\n",
       " 'copy',\n",
       " 'copy_to_memory',\n",
       " 'copy_to_new_particles',\n",
       " 'copy_values_of_all_attributes_to',\n",
       " 'copy_values_of_attribute_to',\n",
       " 'copy_values_of_attributes_to',\n",
       " 'correlation_dimension',\n",
       " 'densitycentre_coreradius_coredens',\n",
       " 'difference',\n",
       " 'distances_squared',\n",
       " 'divide_attributes',\n",
       " 'dynamical_timescale',\n",
       " 'empty_copy',\n",
       " 'empty_particles_set_string',\n",
       " 'ensure_presence_of',\n",
       " 'find_closest_particle_to',\n",
       " 'function_for_set',\n",
       " 'get_all_indices_in_store',\n",
       " 'get_all_keys_in_store',\n",
       " 'get_all_particles_at',\n",
       " 'get_all_values_of_attribute_in_store',\n",
       " 'get_all_values_of_attribute_in_store_async',\n",
       " 'get_attribute_names_defined_in_store',\n",
       " 'get_binaries',\n",
       " 'get_containing_set',\n",
       " 'get_indices_of_keys',\n",
       " 'get_intersecting_subset_in',\n",
       " 'get_settable_attribute_names_defined_in_store',\n",
       " 'get_state_at_timestamp',\n",
       " 'get_timeline_of_attribute',\n",
       " 'get_timeline_of_attribute_as_vector',\n",
       " 'get_timeline_of_attributes',\n",
       " 'get_timestamp',\n",
       " 'get_valid_particles_mask',\n",
       " 'get_value_in_store',\n",
       " 'get_values_in_store',\n",
       " 'get_values_in_store_async',\n",
       " 'has_duplicates',\n",
       " 'has_key_in_store',\n",
       " 'history',\n",
       " 'is_empty',\n",
       " 'is_quantity',\n",
       " 'iter_history',\n",
       " 'key',\n",
       " 'kinetic_energy',\n",
       " 'mass',\n",
       " 'mass_segregation_Gini_coefficient',\n",
       " 'mass_segregation_from_nearest_neighbour',\n",
       " 'mass_segregation_ratio',\n",
       " 'minimum_spanning_tree_length',\n",
       " 'moment_of_inertia',\n",
       " 'move_to_center',\n",
       " 'name',\n",
       " 'natal_kick_velocity',\n",
       " 'nearest_neighbour',\n",
       " 'new_binary_tree_wrapper',\n",
       " 'new_channel_to',\n",
       " 'new_particle',\n",
       " 'new_particle_from_cluster_core',\n",
       " 'new_working_copy',\n",
       " 'oblateness',\n",
       " 'position',\n",
       " 'potential',\n",
       " 'potential_energy',\n",
       " 'potential_energy_in_field',\n",
       " 'previous_state',\n",
       " 'random_sample',\n",
       " 'remove_attribute_from_store',\n",
       " 'remove_particle',\n",
       " 'remove_particles',\n",
       " 'remove_particles_from_store',\n",
       " 'reversed',\n",
       " 'rotate',\n",
       " 'savepoint',\n",
       " 'scale_to_standard',\n",
       " 'select',\n",
       " 'select_array',\n",
       " 'set_values_in_store',\n",
       " 'set_values_in_store_async',\n",
       " 'sorted_by_attribute',\n",
       " 'sorted_by_attributes',\n",
       " 'specific_kinetic_energy',\n",
       " 'stored_attributes',\n",
       " 'synchronize_to',\n",
       " 'thermal_energy',\n",
       " 'to_string',\n",
       " 'total_angular_momentum',\n",
       " 'total_mass',\n",
       " 'total_momentum',\n",
       " 'total_radius',\n",
       " 'velocity',\n",
       " 'virial_radius',\n",
       " 'vx',\n",
       " 'vy',\n",
       " 'vz',\n",
       " 'x',\n",
       " 'y',\n",
       " 'z']"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dir(solarsystem)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Or get some general help on the underlying particle class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on Particles in module amuse.datamodel.particles object:\n",
      "\n",
      "class Particles(AbstractParticleSet)\n",
      " |  Particles(size=0, storage=None, keys=None, keys_generator=None, particles=None, is_working_copy=True, **attributes)\n",
      " |  \n",
      " |  A set of particles. Attributes and values are stored in\n",
      " |  a private storage model. This storage model can store\n",
      " |  the values in the python memory space, in the memory space\n",
      " |  of the code or in a HDF5 file. By default the storage\n",
      " |  model is in memory.\n",
      " |  \n",
      " |  Method resolution order:\n",
      " |      Particles\n",
      " |      AbstractParticleSet\n",
      " |      amuse.datamodel.base.AbstractSet\n",
      " |      builtins.object\n",
      " |  \n",
      " |  Methods defined here:\n",
      " |  \n",
      " |  __getitem__(self, index)\n",
      " |  \n",
      " |  __init__(self, size=0, storage=None, keys=None, keys_generator=None, particles=None, is_working_copy=True, **attributes)\n",
      " |      Initialize self.  See help(type(self)) for accurate signature.\n",
      " |  \n",
      " |  __iter__(self)\n",
      " |  \n",
      " |  add_particles_to_store(self, keys, attributes=[], values=[])\n",
      " |  \n",
      " |  can_extend_attributes(self)\n",
      " |  \n",
      " |  get_all_indices_in_store(self)\n",
      " |  \n",
      " |  get_all_keys_in_store(self)\n",
      " |  \n",
      " |  get_attribute_names_defined_in_store(self)\n",
      " |  \n",
      " |  get_indices_of_keys(self, keys)\n",
      " |  \n",
      " |  get_settable_attribute_names_defined_in_store(self)\n",
      " |  \n",
      " |  get_state_at_timestamp(self, timestamp)\n",
      " |  \n",
      " |  get_timeline_of_attribute(self, particle_key, attribute)\n",
      " |  \n",
      " |  get_timeline_of_attribute_as_vector(self, particle_key, attribute)\n",
      " |  \n",
      " |  get_timeline_of_attributes(self, particle_key, attributes)\n",
      " |  \n",
      " |  get_timestamp(self)\n",
      " |  \n",
      " |  get_value_in_store(self, index, attribute)\n",
      " |  \n",
      " |  get_values_in_store(self, indices, attributes)\n",
      " |  \n",
      " |  get_values_in_store_async(self, indices, attributes)\n",
      " |  \n",
      " |  has_key_in_store(self, key)\n",
      " |  \n",
      " |  iter_history(self)\n",
      " |  \n",
      " |  new_particle(self, key=None, **keyword_arguments)\n",
      " |  \n",
      " |  new_working_copy(self)\n",
      " |  \n",
      " |  previous_state(self)\n",
      " |  \n",
      " |  remove_attribute_from_store(self, name)\n",
      " |  \n",
      " |  remove_particles_from_store(self, indices)\n",
      " |  \n",
      " |  savepoint(self, timestamp=None, format='memory', **attributes)\n",
      " |  \n",
      " |  set_values_in_store(self, indices, attributes, values)\n",
      " |  \n",
      " |  set_values_in_store_async(self, indices, attributes, values)\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Static methods defined here:\n",
      " |  \n",
      " |  is_quantity()\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data descriptors defined here:\n",
      " |  \n",
      " |  history\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from AbstractParticleSet:\n",
      " |  \n",
      " |  __add__(self, particles)\n",
      " |      Returns a particle subset, composed of the given\n",
      " |      particle(s) and this particle set. Attribute values are\n",
      " |      not stored by the subset. The subset provides a view\n",
      " |      on two or more sets of particles.\n",
      " |      \n",
      " |      :parameter particles: (set of) particle(s) to be added to self.\n",
      " |      \n",
      " |      >>> particles = Particles(4)\n",
      " |      >>> particles1 = particles[:2]\n",
      " |      >>> particles1.x = [1.0, 2.0] | units.m\n",
      " |      >>> particles2 = particles[2:]\n",
      " |      >>> particles2.x = [3.0, 4.0] | units.m\n",
      " |      >>> new_set = particles1 + particles2\n",
      " |      >>> new_set  # doctest:+ELLIPSIS\n",
      " |      <amuse.datamodel.particles.ParticlesSubset object at 0x...>\n",
      " |      >>> print len(new_set)\n",
      " |      4\n",
      " |      >>> print new_set.x\n",
      " |      [1.0, 2.0, 3.0, 4.0] m\n",
      " |  \n",
      " |  __contains__(self, particle)\n",
      " |      Check if a particle is part of a set\n",
      " |      \n",
      " |      >>> particles = Particles(3)\n",
      " |      >>> particles.mass = [10.0, 20.0, 30.0] | units.kg\n",
      " |      >>> p1 = particles[1]\n",
      " |      >>> print p1 in particles\n",
      " |      True\n",
      " |      >>> p4 = Particle()\n",
      " |      >>> print p4 in particles\n",
      " |      False\n",
      " |  \n",
      " |  __delattr__(self, name)\n",
      " |      Implement delattr(self, name).\n",
      " |  \n",
      " |  __dir__(self)\n",
      " |      Utility function for introspection of paricle objects\n",
      " |      \n",
      " |      >>> particles = Particles(3)\n",
      " |      >>> particles.mass = [10.0, 20.0, 30.0] | units.kg\n",
      " |      >>> particles.x = [1.0, 2.0, 3.0] | units.m\n",
      " |      >>> print 'mass' in dir(particles)\n",
      " |      True\n",
      " |      >>> print 'x' in dir(particles)\n",
      " |      True\n",
      " |  \n",
      " |  __or__(self, particles)\n",
      " |      Returns a particle superset, composed of the given\n",
      " |      particle(s) and this particle set.\n",
      " |      \n",
      " |      :parameter particles: (set of) particle(s) to be added to self.\n",
      " |      \n",
      " |      >>> particles1 = Particles(2)\n",
      " |      >>> particles1.x = [1.0, 2.0] | units.m\n",
      " |      >>> particles2 = Particles(2)\n",
      " |      >>> particles2.x = [3.0, 4.0] | units.m\n",
      " |      >>> new_set = particles1 | particles2\n",
      " |      >>> new_set  # doctest:+ELLIPSIS\n",
      " |      <amuse.datamodel.particles.ParticlesSuperset object at 0x...>\n",
      " |      >>> print len(new_set)\n",
      " |      4\n",
      " |      >>> print new_set.x\n",
      " |      [1.0, 2.0, 3.0, 4.0] m\n",
      " |  \n",
      " |  __setattr__(self, name_of_the_attribute, value)\n",
      " |      Implement setattr(self, name, value).\n",
      " |  \n",
      " |  __str__(self)\n",
      " |      Display string of a particle set.\n",
      " |      \n",
      " |      >>> p0 = Particle(10)\n",
      " |      >>> p1 = Particle(11)\n",
      " |      >>> particles = Particles()\n",
      " |      >>> particles.add_particle(p0) # doctest:+ELLIPSIS\n",
      " |      <amuse.datamodel.particles.Particle object at ...>\n",
      " |      >>> particles.add_particle(p1) # doctest:+ELLIPSIS\n",
      " |      <amuse.datamodel.particles.Particle object at ...>\n",
      " |      >>> particles.x = [4.0 , 3.0] | units.m\n",
      " |      >>> particles.y = [5.0 , 2.0] | units.km\n",
      " |      >>> print particles\n",
      " |                       key            x            y\n",
      " |                         -            m           km\n",
      " |      ====================  ===========  ===========\n",
      " |                        10    4.000e+00    5.000e+00\n",
      " |                        11    3.000e+00    2.000e+00\n",
      " |      ====================  ===========  ===========\n",
      " |  \n",
      " |  __sub__(self, particles)\n",
      " |      Returns a subset of the set without the given particle(s)\n",
      " |      Attribute values are not stored by the subset. The subset\n",
      " |      provides a view on two or more sets of particles.\n",
      " |      \n",
      " |      :parameter particles: (set of) particle(s) to be subtracted from self.\n",
      " |      \n",
      " |      >>> particles = Particles(4)\n",
      " |      >>> particles.x = [1.0, 2.0, 3.0, 4.0] | units.m\n",
      " |      >>> junk = particles[2:]\n",
      " |      >>> new_set = particles - junk\n",
      " |      >>> new_set  # doctest:+ELLIPSIS\n",
      " |      <amuse.datamodel.particles.ParticlesSubset object at 0x...>\n",
      " |      >>> print len(new_set)\n",
      " |      2\n",
      " |      >>> print new_set.x\n",
      " |      [1.0, 2.0] m\n",
      " |      >>> print particles.x\n",
      " |      [1.0, 2.0, 3.0, 4.0] m\n",
      " |  \n",
      " |  add_attribute_domain(self, namespace)\n",
      " |  \n",
      " |  add_particle(self, particle)\n",
      " |      Add one particle to the set.\n",
      " |      \n",
      " |      :parameter particle: particle to add\n",
      " |      \n",
      " |      >>> particles = Particles()\n",
      " |      >>> print len(particles)\n",
      " |      0\n",
      " |      >>> particle = Particle()\n",
      " |      >>> particle.x = 1.0 | units.m\n",
      " |      >>> particles.add_particle(particle)  # doctest:+ELLIPSIS\n",
      " |      <amuse.datamodel.particles.Particle object at ...>\n",
      " |      >>> print len(particles)\n",
      " |      1\n",
      " |      >>> print particles.x\n",
      " |      [1.0] m\n",
      " |  \n",
      " |  add_particles(self, particles)\n",
      " |      Adds particles from the supplied set to this set. Attributes\n",
      " |      and values are copied over.\n",
      " |      \n",
      " |      .. note::\n",
      " |          For performance reasons the particles\n",
      " |          are not checked for duplicates. When the same particle\n",
      " |          is part of both sets errors may occur.\n",
      " |      \n",
      " |      :parameter particles: set of particles to copy values from\n",
      " |      \n",
      " |      >>> particles1 = Particles(2)\n",
      " |      >>> particles1.x = [1.0, 2.0] | units.m\n",
      " |      >>> particles2 = Particles(2)\n",
      " |      >>> particles2.x = [3.0, 4.0] | units.m\n",
      " |      >>> particles1.add_particles(particles2)  # doctest:+ELLIPSIS\n",
      " |      <amuse.datamodel.particles.ParticlesSubset object at 0x...>\n",
      " |      >>> print len(particles1)\n",
      " |      4\n",
      " |      >>> print particles1.x\n",
      " |      [1.0, 2.0, 3.0, 4.0] m\n",
      " |  \n",
      " |  all_attributes(self)\n",
      " |  \n",
      " |  as_binary_tree(self, name_of_first_child='child1', name_of_second_child='child2')\n",
      " |  \n",
      " |  as_set(self)\n",
      " |      Returns a subset view on this set. The subset\n",
      " |      will contain all particles of this set.\n",
      " |      \n",
      " |      >>> particles = Particles(3)\n",
      " |      >>> particles.x = [1.0, 2.0, 3.0] | units.m\n",
      " |      >>> subset = particles.as_set()\n",
      " |      >>> print subset.x\n",
      " |      [1.0, 2.0, 3.0] m\n",
      " |      >>> print particles.x\n",
      " |      [1.0, 2.0, 3.0] m\n",
      " |  \n",
      " |  compressed(self)\n",
      " |  \n",
      " |  copy(self, memento=None, keep_structure=False, filter_attributes=<function AbstractParticleSet.<lambda> at 0x7f4a942f17a0>)\n",
      " |      Creates a new in particle set and copies all attributes and \n",
      " |      values into this set. \n",
      " |      \n",
      " |      The history of the set is not copied over.\n",
      " |      \n",
      " |      \n",
      " |      Keyword arguments:\n",
      " |      memento -- internal, a dictionary to keep track of already copied sets in \n",
      " |                 case of links between particles (default: None, will be created)\n",
      " |      keep_structure -- internal, if True, in case of a sub or super set make a copy of\n",
      " |                 the original set and return a new subset (default: False)\n",
      " |  \n",
      " |  copy_to_new_particles(self, keys=None, keys_generator=None, memento=None, keep_structure=False, filter_attributes=<function AbstractParticleSet.<lambda> at 0x7f4a942f18c0>)\n",
      " |  \n",
      " |  copy_values_of_attribute_to(self, attribute_name, particles)\n",
      " |      Copy values of one attribute from this set to the\n",
      " |      other set. Will only copy values for the particles\n",
      " |      in both sets. See also :meth:`synchronize_to`.\n",
      " |      \n",
      " |      If you need to do this a lot, setup a dedicated\n",
      " |      channel.\n",
      " |      \n",
      " |      >>> particles1 = Particles(2)\n",
      " |      >>> particles1.x = [1.0, 2.0] | units.m\n",
      " |      >>> particles2 = particles1.copy()\n",
      " |      >>> print particles2.x\n",
      " |      [1.0, 2.0] m\n",
      " |      >>> p3 = particles1.add_particle(Particle())\n",
      " |      >>> particles1.x = [3.0, 4.0, 5.0] | units.m\n",
      " |      >>> particles1.copy_values_of_attribute_to(\"x\", particles2)\n",
      " |      >>> print particles2.x\n",
      " |      [3.0, 4.0] m\n",
      " |  \n",
      " |  copy_values_of_attributes_to(self, attribute_names, particles)\n",
      " |  \n",
      " |  difference(self, other)\n",
      " |      Returns a new subset containing the difference between\n",
      " |      this set and the provided set.\n",
      " |      \n",
      " |      >>> particles = Particles(3)\n",
      " |      >>> particles.mass = [10.0, 20.0, 30.0] | units.kg\n",
      " |      >>> particles.x = [1.0, 2.0, 3.0] | units.m\n",
      " |      >>> subset = particles.select(lambda x : x > 15.0 | units.kg, [\"mass\"])\n",
      " |      >>> less_than_15kg = particles.difference(subset)\n",
      " |      >>> len(subset)\n",
      " |      2\n",
      " |      >>> len(less_than_15kg)\n",
      " |      1\n",
      " |  \n",
      " |  divide_attributes(self, attributes=(), n=3)\n",
      " |  \n",
      " |  empty_copy(self)\n",
      " |      Creates a new in memory set and copies the particles to it.\n",
      " |      The attributes and values are not copied.The history\n",
      " |      of the set is not copied over.\n",
      " |      \n",
      " |      >>> from amuse.datamodel import Particles\n",
      " |      >>> from amuse.units import units\n",
      " |      >>> original = Particles(2)\n",
      " |      >>> original.mass = 0 | units.m\n",
      " |      >>> print hasattr(original, \"mass\")\n",
      " |      True\n",
      " |      >>> print len(original)\n",
      " |      2\n",
      " |      >>> copy = original.empty_copy()\n",
      " |      >>> print hasattr(copy, \"mass\")\n",
      " |      False\n",
      " |      >>> print len(copy)\n",
      " |      2\n",
      " |  \n",
      " |  empty_particles_set_string(self, attributes=())\n",
      " |  \n",
      " |  ensure_presence_of(self, x)\n",
      " |      Add one particle to the set, but only if not already in set.\n",
      " |      \n",
      " |      :parameter particle: particle to add\n",
      " |      \n",
      " |      >>> particles = Particles()\n",
      " |      >>> print len(particles)\n",
      " |      0\n",
      " |      >>> particle = Particle()\n",
      " |      >>> p1=particles.ensure_presence_of(particle)  # doctest:+ELLIPSIS\n",
      " |      >>> print len(particles)\n",
      " |      1\n",
      " |      >>> p2=particles.ensure_presence_of(particle)  # doctest:+ELLIPSIS\n",
      " |      >>> print len(particles)\n",
      " |      1\n",
      " |      >>> p1==p2\n",
      " |      True\n",
      " |      >>> particle2 = Particle()\n",
      " |      >>> set=particle.as_set()\n",
      " |      >>> p3=set.add_particle(particle2)\n",
      " |      >>> set2=particles.ensure_presence_of(set)\n",
      " |      >>> len(particles)\n",
      " |      2\n",
      " |      >>> len(set2)\n",
      " |      2\n",
      " |  \n",
      " |  get_all_particles_at(self, *indices)\n",
      " |  \n",
      " |  get_all_values_of_attribute_in_store(self, attribute)\n",
      " |  \n",
      " |  get_containing_set(self)\n",
      " |  \n",
      " |  get_intersecting_subset_in(self, other)\n",
      " |  \n",
      " |  get_valid_particles_mask(self)\n",
      " |  \n",
      " |  has_duplicates(self)\n",
      " |      Returns True when a set contains a particle with the\n",
      " |      same key more than once. Particles with the same\n",
      " |      key are interpreted as the same particles.\n",
      " |      \n",
      " |      >>> particles = Particles()\n",
      " |      >>> p1 = particles.add_particle(Particle(1))\n",
      " |      >>> p2 = particles.add_particle(Particle(2))\n",
      " |      >>> particles.has_duplicates()\n",
      " |      False\n",
      " |      >>> p3 = particles.add_particle(Particle(1))\n",
      " |      >>> particles.has_duplicates()\n",
      " |      True\n",
      " |      >>> p3 == p1\n",
      " |      True\n",
      " |  \n",
      " |  is_empty(self)\n",
      " |  \n",
      " |  new_binary_tree_wrapper(self, name_of_first_child='child1', name_of_second_child='child2')\n",
      " |  \n",
      " |  new_channel_to(self, other, attributes=None, target_names=None)\n",
      " |  \n",
      " |  random_sample(self, number_of_particles)\n",
      " |  \n",
      " |  remove_particle(self, particle)\n",
      " |      Removes a particle from this set.\n",
      " |      \n",
      " |      Result is undefined if particle is not part of the set\n",
      " |      \n",
      " |      :parameter particle: particle to remove from this set\n",
      " |      \n",
      " |      >>> particles1 = Particles(2)\n",
      " |      >>> particles1.x = [1.0, 2.0] | units.m\n",
      " |      >>> particles1.remove_particle(particles1[0])\n",
      " |      >>> print len(particles1)\n",
      " |      1\n",
      " |      >>> print particles1.x\n",
      " |      [2.0] m\n",
      " |  \n",
      " |  remove_particles(self, particles)\n",
      " |      Removes particles from the supplied set from this set.\n",
      " |      \n",
      " |      :parameter particles: set of particles to remove from this set\n",
      " |      \n",
      " |      >>> particles1 = Particles(2)\n",
      " |      >>> particles1.x = [1.0, 2.0] | units.m\n",
      " |      >>> particles2 = Particles()\n",
      " |      >>> particles2.add_particle(particles1[0]) # doctest:+ELLIPSIS\n",
      " |      <amuse.datamodel.particles.Particle object at ...>\n",
      " |      >>> particles1.remove_particles(particles2)\n",
      " |      >>> print len(particles1)\n",
      " |      1\n",
      " |      >>> print particles1.x\n",
      " |      [2.0] m\n",
      " |  \n",
      " |  reversed(self)\n",
      " |      Returns a subset with the same particles, but with reversed\n",
      " |      sequenctial order (the first particle will become last)\n",
      " |      \n",
      " |      >>> particles = Particles(3)\n",
      " |      >>> particles.radius = [1.0, 2.0, 3.0] | units.m\n",
      " |      >>> r = particles.reversed()\n",
      " |      >>> print r.radius\n",
      " |      [3.0, 2.0, 1.0] m\n",
      " |  \n",
      " |  select(self, selection_function, attributes)\n",
      " |      Returns a subset view on this set. The subset\n",
      " |      will contain all particles for which the selection\n",
      " |      function returned True. The selection function\n",
      " |      is called with scalar quantities defined by\n",
      " |      the attributes parameter\n",
      " |      \n",
      " |      >>> particles = Particles(3)\n",
      " |      >>> particles.mass = [10.0, 20.0, 30.0] | units.kg\n",
      " |      >>> particles.x = [1.0, 2.0, 3.0] | units.m\n",
      " |      >>> subset = particles.select(lambda x : x > 15.0 | units.kg, [\"mass\"])\n",
      " |      >>> print subset.mass\n",
      " |      [20.0, 30.0] kg\n",
      " |      >>> print subset.x\n",
      " |      [2.0, 3.0] m\n",
      " |  \n",
      " |  select_array(self, selection_function, attributes=())\n",
      " |      Returns a subset view on this set. The subset\n",
      " |      will contain all particles for which the selection\n",
      " |      function returned True. The selection function\n",
      " |      is called with a vector quantities containing all\n",
      " |      the values for the attributes parameter.\n",
      " |      \n",
      " |      This function can be faster than the select function\n",
      " |      as it works on entire arrays. The selection_function\n",
      " |      is called once.\n",
      " |      \n",
      " |      >>> particles = Particles(3)\n",
      " |      >>> particles.mass = [10.0, 20.0, 30.0] | units.kg\n",
      " |      >>> particles.x = [1.0, 2.0, 3.0] | units.m\n",
      " |      >>> subset = particles.select_array(lambda x : x > 15.0 | units.kg, [\"mass\"])\n",
      " |      >>> print subset.mass\n",
      " |      [20.0, 30.0] kg\n",
      " |      >>> print subset.x\n",
      " |      [2.0, 3.0] m\n",
      " |      \n",
      " |      \n",
      " |      >>> particles = Particles(1000)\n",
      " |      >>> particles.x = units.m.new_quantity(numpy.arange(1,1001))\n",
      " |      >>> subset = particles.select_array(lambda x : x > (500 | units.m), (\"x\",) )\n",
      " |      >>> print len(subset)\n",
      " |      500\n",
      " |  \n",
      " |  sorted_by_attribute(self, attribute, kind='mergesort')\n",
      " |      Returns a subset with the same particles, but sorted\n",
      " |      using the given attribute name\n",
      " |      \n",
      " |      :argument: kind, the sort method for supported kinds see\n",
      " |          the numpy.sort documentation\n",
      " |      \n",
      " |      \n",
      " |      >>> particles = Particles(3)\n",
      " |      >>> particles.mass = [2.0, 3.0, 1.0] | units.kg\n",
      " |      >>> particles.radius = [1.0, 2.0, 3.0] | units.m\n",
      " |      >>> sorted = particles.sorted_by_attribute('mass')\n",
      " |      >>> print sorted.mass\n",
      " |      [1.0, 2.0, 3.0] kg\n",
      " |      >>> print sorted.radius\n",
      " |      [3.0, 1.0, 2.0] m\n",
      " |  \n",
      " |  sorted_by_attributes(self, *attributes)\n",
      " |      Returns a subset with the same particles, but sorted\n",
      " |      using the given attribute names. The last attribute name\n",
      " |      in the call is used for the primary sort order, the\n",
      " |      second-to-last attribute name for the secondary sort order,\n",
      " |      and so on. See also numpy.lexsort\n",
      " |      \n",
      " |      \n",
      " |      >>> particles = Particles(4)\n",
      " |      >>> particles.mass = [2.0, 3.0, 1.0, 4.0] | units.kg\n",
      " |      >>> particles.radius = [3.0, 2.0, 1.0, 2.0] | units.m\n",
      " |      >>> sorted = particles.sorted_by_attributes('mass', 'radius')\n",
      " |      >>> print sorted.radius\n",
      " |      [1.0, 2.0, 2.0, 3.0] m\n",
      " |      >>> print sorted.mass\n",
      " |      [1.0, 3.0, 4.0, 2.0] kg\n",
      " |  \n",
      " |  synchronize_to(self, other_particles)\n",
      " |      Synchronize the particles of this set\n",
      " |      with the contents of the provided set.\n",
      " |      \n",
      " |      After this call the `other_particles` set will have\n",
      " |      the same particles as this set.\n",
      " |      \n",
      " |      This call will check if particles have been removed or\n",
      " |      added it will not copy values of existing particles\n",
      " |      over.\n",
      " |      \n",
      " |      :parameter other_particles: particle set wich has to be updated\n",
      " |      \n",
      " |      >>> particles = Particles(2)\n",
      " |      >>> particles.x = [1.0, 2.0] | units.m\n",
      " |      >>> copy = particles.copy()\n",
      " |      >>> new_particle = Particle()\n",
      " |      >>> new_particle.x = 3.0 | units.m\n",
      " |      >>> particles.add_particle(new_particle)# doctest:+ELLIPSIS\n",
      " |      <amuse.datamodel.particles.Particle object at ...>\n",
      " |      >>> print particles.x\n",
      " |      [1.0, 2.0, 3.0] m\n",
      " |      >>> print copy.x\n",
      " |      [1.0, 2.0] m\n",
      " |      >>> particles.synchronize_to(copy)\n",
      " |      >>> print copy.x\n",
      " |      [1.0, 2.0, 3.0] m\n",
      " |  \n",
      " |  to_string(self, attributes_to_show=None, split_at=20)\n",
      " |      Display string of a particle set.\n",
      " |      \n",
      " |      >>> p0 = Particle(10)\n",
      " |      >>> p1 = Particle(11)\n",
      " |      >>> particles = Particles()\n",
      " |      >>> particles.add_particle(p0) # doctest:+ELLIPSIS\n",
      " |      <amuse.datamodel.particles.Particle object at ...>\n",
      " |      >>> particles.add_particle(p1) # doctest:+ELLIPSIS\n",
      " |      <amuse.datamodel.particles.Particle object at ...>\n",
      " |      >>> particles.x = [4.0 , 3.0] | units.m\n",
      " |      >>> particles.y = [5.0 , 2.0] | units.km\n",
      " |      >>> print particles.to_string()\n",
      " |                       key            x            y\n",
      " |                         -            m           km\n",
      " |      ====================  ===========  ===========\n",
      " |                        10    4.000e+00    5.000e+00\n",
      " |                        11    3.000e+00    2.000e+00\n",
      " |      ====================  ===========  ===========\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data and other attributes inherited from AbstractParticleSet:\n",
      " |  \n",
      " |  GLOBAL_DERIVED_ATTRIBUTES = {'LagrangianRadii': <amuse.datamodel.base....\n",
      " |  \n",
      " |  __array_interface__ = {'shape': (), 'typestr': '|O4'}\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from amuse.datamodel.base.AbstractSet:\n",
      " |  \n",
      " |  __array__\n",
      " |  \n",
      " |  __array_struct__\n",
      " |  \n",
      " |  __getattr__(self, name_of_the_attribute)\n",
      " |  \n",
      " |  __len__(self)\n",
      " |  \n",
      " |  add_caching_function_attribute(self, name_of_the_attribute, function, function_for_particle=None)\n",
      " |      Define a function attribute, adding a function to the particles, the function will\n",
      " |      be evaluated once for the set, after that the function will return the same results.\n",
      " |      The function must not take any arguments and the caching only works for the whole set (not on single\n",
      " |      particles) \n",
      " |      \n",
      " |      :argument name_of_the_attribute: Name to reference the vector attribute by. \n",
      " |      :argument function: A function, first argument will be the particles.\n",
      " |      \n",
      " |      >>> from amuse.datamodel import Particles\n",
      " |      >>> particles = Particles(2)\n",
      " |      >>> particles.x = [1.0, 2.0] | units.m\n",
      " |      >>> def sumx(p):\n",
      " |      ...   return p.x.sum()\n",
      " |      ...\n",
      " |      >>> particles.add_caching_function_attribute(\"sum_of_x\", sumx)\n",
      " |      >>> particles.sum_of_x()\n",
      " |      quantity<3.0 m>\n",
      " |      \n",
      " |      >>> particles.x = [3.0, 4.0] | units.m\n",
      " |      >>> particles.sum_of_x()\n",
      " |      quantity<3.0 m>\n",
      " |  \n",
      " |  add_calculated_attribute(self, name_of_the_attribute, function, attributes_names=None)\n",
      " |      Define a read-only calculated attribute, values for the attribute are\n",
      " |      calculated using the given function. The functions argument \n",
      " |      names are interperted as attribute names. For example, if\n",
      " |      the given function is::\n",
      " |      \n",
      " |          def norm(x, y):\n",
      " |              return (x*x + y*y).sqrt()\n",
      " |              \n",
      " |      The attributes \"x\" and \"y\" will be retrieved from the particles\n",
      " |      and send to the \"norm\" function.\n",
      " |      \n",
      " |      The calculated values are not stored on the particles. Values\n",
      " |      are recalculated every time this attribute is accessed.\n",
      " |      \n",
      " |      :argument name_of_the_attribute: Name to reference the attribute by. \n",
      " |      :argument function: Function to call, when attribute is accessed\n",
      " |        \n",
      " |      \n",
      " |      >>> from amuse.datamodel import Particles\n",
      " |      >>> particles = Particles(2)\n",
      " |      >>> particles.x = [1.0 , 2.0] | units.m \n",
      " |      >>> particles.y = [3.0 , 4.0] | units.m\n",
      " |      >>> particles.add_calculated_attribute(\"xy\", lambda x, y : x * y)\n",
      " |      >>> print particles.xy\n",
      " |      [3.0, 8.0] m**2\n",
      " |      >>> particles[0].x = 4.0 | units.m\n",
      " |      >>> print particles.xy\n",
      " |      [12.0, 8.0] m**2\n",
      " |      >>> print particles[1].xy\n",
      " |      8.0 m**2\n",
      " |  \n",
      " |  add_function_attribute(self, name_of_the_attribute, function, function_for_particle=None)\n",
      " |      Define a function attribute, adding a function to the particles\n",
      " |      \n",
      " |      :argument name_of_the_attribute: Name to reference the vector attribute by. \n",
      " |      :argument function: A function, first argument will be the particles.\n",
      " |      \n",
      " |      >>> from amuse.datamodel import Particles\n",
      " |      >>> particles = Particles(2)\n",
      " |      >>> particles.x = [1.0 , 2.0] | units.m\n",
      " |      >>> def sumx(p):\n",
      " |      ...   return p.x.sum()\n",
      " |      ...\n",
      " |      >>> particles.add_function_attribute(\"sum_of_x\", sumx)\n",
      " |      >>> particles.sum_of_x()\n",
      " |      quantity<3.0 m>\n",
      " |  \n",
      " |  add_particle_function_attribute(self, name_of_the_attribute, function)\n",
      " |      Define a function working on one particle\n",
      " |      \n",
      " |      :argument name_of_the_attribute: Name to reference the attribute by. \n",
      " |      :argument function: A function, first argument will be the particle.\n",
      " |      \n",
      " |      >>> from amuse.datamodel import Particles\n",
      " |      >>> def xsquared(set, p):\n",
      " |      ...   return p.x * p.x\n",
      " |      ...\n",
      " |      >>> particles = Particles(2)\n",
      " |      >>> particles.add_particle_function_attribute(\"xsquared\", xsquared)\n",
      " |      >>> particles.x = [4.0 , 2.0] | units.m\n",
      " |      >>> particles[0].xsquared()\n",
      " |      quantity<16.0 m**2>\n",
      " |  \n",
      " |  add_vector_attribute(self, name_of_the_attribute, name_of_the_components)\n",
      " |  \n",
      " |  are_all_keys_in_set(self, keys)\n",
      " |  \n",
      " |  check_attribute(self, value)\n",
      " |  \n",
      " |  copy_to_memory(self)\n",
      " |  \n",
      " |  copy_values_of_all_attributes_to(self, particles)\n",
      " |  \n",
      " |  get_all_values_of_attribute_in_store_async(self, attribute)\n",
      " |  \n",
      " |  stored_attributes(self)\n",
      " |      Returns a list of the names of the attributes defined on\n",
      " |      the objects in this set (or grid).\n",
      " |      \n",
      " |      This list will not contain the set specific methods, or derived\n",
      " |      attributes (such as function attributes or vector attributes)\n",
      " |      for a list with all these attributes please use ``dir``.\n",
      " |      \n",
      " |      >>> from amuse.datamodel import Particles\n",
      " |      >>> particles = Particles(3)\n",
      " |      >>> particles.mass = [10.0, 20.0, 30.0] | units.kg\n",
      " |      >>> particles.x = [1.0, 2.0, 3.0] | units.m\n",
      " |      >>> print particles.stored_attributes()\n",
      " |      ['key', 'mass', 'x']\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Class methods inherited from amuse.datamodel.base.AbstractSet:\n",
      " |  \n",
      " |  add_global_caching_function_attribute(name_of_the_attribute, function, function_for_particle=None) from builtins.type\n",
      " |      Define a function attribute, adding a function to the particles\n",
      " |      \n",
      " |      :argument name_of_the_attribute: Name to reference the attribute by. \n",
      " |      :argument function: A function, first argument will be the particles.\n",
      " |      \n",
      " |      >>> from amuse.datamodel import Particles\n",
      " |      >>> def sumx(p):\n",
      " |      ...   return p.x.sum()\n",
      " |      ...\n",
      " |      >>> Particles.add_global_caching_function_attribute(\"sum_of_x\", sumx)\n",
      " |      >>> particles = Particles(2)\n",
      " |      >>> particles.x = [4.0 , 2.0] | units.m\n",
      " |      >>> particles.sum_of_x()\n",
      " |      quantity<6.0 m>\n",
      " |      >>> particles.x = [5.0 , 6.0] | units.m\n",
      " |      >>> particles.sum_of_x()\n",
      " |      quantity<6.0 m>\n",
      " |      >>> del Particles.GLOBAL_DERIVED_ATTRIBUTES['sum_of_x']\n",
      " |  \n",
      " |  add_global_calculated_attribute(name_of_the_attribute, function, attributes_names=None) from builtins.type\n",
      " |      Define a *global* vector attribute, coupling two or more scalar attributes into\n",
      " |      one vector attribute. The vector will be defined for all particle sets\n",
      " |      created after calling this function.\n",
      " |      \n",
      " |      :argument name_of_the_attribute: Name to reference the vector attribute by. \n",
      " |      :argument function: Name of the function to call. \n",
      " |      :argument attributes_names: List of strings, each string a name of a scalar attribute, if None uses argument names.\n",
      " |      \n",
      " |      \n",
      " |      >>> from amuse.datamodel import Particles\n",
      " |      >>> Particles.add_global_calculated_attribute(\"xy\", lambda x, y : x * y)\n",
      " |      >>> particles = Particles(2)\n",
      " |      >>> particles.x = [1.0 , 2.0] | units.m \n",
      " |      >>> particles.y = [3.0 , 4.0] | units.m\n",
      " |      >>> print particles.xy\n",
      " |      [3.0, 8.0] m**2\n",
      " |      >>> del Particles.GLOBAL_DERIVED_ATTRIBUTES['xy']\n",
      " |  \n",
      " |  add_global_function_attribute(name_of_the_attribute, function, function_for_particle=None) from builtins.type\n",
      " |      Define a function attribute, adding a function to the particles\n",
      " |      \n",
      " |      :argument name_of_the_attribute: Name to reference the attribute by. \n",
      " |      :argument function: A function, first argument will be the particles.\n",
      " |      \n",
      " |      >>> from amuse.datamodel import Particles\n",
      " |      >>> def sumx(p):\n",
      " |      ...   return p.x.sum()\n",
      " |      ...\n",
      " |      >>> Particles.add_global_function_attribute(\"sum_of_x\", sumx)\n",
      " |      >>> particles = Particles(2)\n",
      " |      >>> particles.x = [4.0 , 2.0] | units.m\n",
      " |      >>> particles.sum_of_x()\n",
      " |      quantity<6.0 m>\n",
      " |      >>> del Particles.GLOBAL_DERIVED_ATTRIBUTES['sum_of_x']\n",
      " |  \n",
      " |  add_global_vector_attribute(name_of_the_attribute, name_of_the_components) from builtins.type\n",
      " |      Define a *global* vector attribute, coupling two or more scalar attributes into\n",
      " |      one vector attribute. The vector will be defined for all particle sets\n",
      " |      created after calling this function.\n",
      " |      \n",
      " |      :argument name_of_the_attribute: Name to reference the vector attribute by. \n",
      " |      :argument name_of_the_components: List of strings, each string a name of a scalar attribute.\n",
      " |      \n",
      " |      >>> from amuse.datamodel import Particles\n",
      " |      >>> particles = Particles(2)\n",
      " |      >>> Particles.add_global_vector_attribute('vel', ['vx','vy'])\n",
      " |      >>> particles.vx = [1.0 , 2.0] | units.m / units.s\n",
      " |      >>> particles.vy = [3.0 , 4.0] | units.m / units.s\n",
      " |      >>> particles.vel\n",
      " |      quantity<[[1.0, 3.0], [2.0, 4.0]] m / s>\n",
      " |  \n",
      " |  attribute_for_set(function) from builtins.type\n",
      " |  \n",
      " |  caching_function_for_set(function) from builtins.type\n",
      " |  \n",
      " |  function_for_set(function) from builtins.type\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data descriptors inherited from amuse.datamodel.base.AbstractSet:\n",
      " |  \n",
      " |  __dict__\n",
      " |      dictionary for instance variables (if defined)\n",
      " |  \n",
      " |  __weakref__\n",
      " |      list of weak references to the object (if defined)\n",
      " |  \n",
      " |  collection_attributes\n",
      " |  \n",
      " |  key\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(solarsystem)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### You have performed some rudimentary operations on a particle set.\n",
    "It is now time to experiment a little for yourself.\n",
    "\n",
    "\n",
    "Assignments and questions:\n",
    "---------------\n",
    "\n",
    "### Assignment 1:\n",
    "Add the planet Jupiter (see [Wikipedia](https://en.wikipedia.org/wiki/Jupiter)) to your small planetary system.\n",
    "\n",
    "### Assignment 2:\n",
    "Your planetary system is notoriously planar, and initialy the earth and moon are positioned along the Cartesian x-axis with the velocity vector in the Cartesian y-direction. \n",
    "\n",
    "Make the Sun-Earth-Moon system more realistic by introducing a small inclination to the Earth's and Moon's orbits and by giving them a random mean anomaly.\n",
    "\n",
    "The [Orbital element module](https://github.com/amusecode/amuse/blob/main/src/amuse/ext/orbital_elements.py) of AMUSE could come in handy. \n",
    "\n",
    "### Assignment 3:\n",
    "Calculate the total  gravitational binding energy of solarsystem.\n",
    "\n",
    "Now displace the entire particle set by 100 parsec and give it a linear velocity of 100km/s in the z-direction.\n",
    "Then calculate the binding energy of the system again.\n",
    "\n",
    "Did the binding energy of the Solar system change by this translation?\n",
    "\n",
    "### Question 1:\n",
    "Particle sets have the attribute *get_binaries()*.\n",
    "If you use this function to check the binaries in your system you will find that (without Jupiter) you have 3 binaries. Explain why the Sun is in a binary with the Moon. You may want to take a look at the [source code](https://github.com/amusecode/amuse/blob/main/src/amuse/datamodel/particle_attributes.py).\n",
    "\n",
    "### Assignment 4:\n",
    "Generate another particle set with a 2 solar-mass star and two planets of 10 and 100 Earth masses in cirular orbits at 0.1 and 0.6 au. Place this second planetary system at apocenter around your Solar system (true anomaly of 180 degrees) at a semimajor axis of 60 au with an eccentricity of 0.6.\n",
    "Then move the entire system to the center of mass.\n",
    "\n",
    "### Question 2:\n",
    "Which of the orbits of the binary star with planets from *Assignment 4* has the highest binding energy?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}