ConfigurationFile.h

Go to the documentation of this file.

// Copyright (c) 2005-2014 Code Synthesis Tools CC
//
// This program was generated by CodeSynthesis XSD, an XML Schema to
// C++ data binding compiler.
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License version 2 as
// published by the Free Software Foundation.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
//
// In addition, as a special exception, Code Synthesis Tools CC gives
// permission to link this program with the Xerces-C++ library (or with
// modified versions of Xerces-C++ that use the same license as Xerces-C++),
// and distribute linked combinations including the two. You must obey
// the GNU General Public License version 2 in all respects for all of
// the code used other than Xerces-C++. If you modify this copy of the
// program, you may extend this exception to your version of the program,
// but you are not obligated to do so. If you do not wish to do so, delete
// this exception statement from your version.
//
// Furthermore, Code Synthesis Tools CC makes a special exception for
// the Free/Libre and Open Source Software (FLOSS) which is described
// in the accompanying FLOSSE file.
//
 
#ifndef CONFIGURATION_FILE_H
#define CONFIGURATION_FILE_H
 
#ifndef XSD_CXX11
#define XSD_CXX11
#endif
 
#ifndef XSD_USE_CHAR
#define XSD_USE_CHAR
#endif
 
#ifndef XSD_CXX_TREE_USE_CHAR
#define XSD_CXX_TREE_USE_CHAR
#endif
 
// Begin prologue.
//
//
// End prologue.
 
#include <xsd/cxx/config.hxx>
 
#if (XSD_INT_VERSION != 4000000L)
#error XSD runtime version mismatch
#endif
 
#include <xsd/cxx/pre.hxx>
 
#include <xsd/cxx/xml/char-utf8.hxx>
 
#include <xsd/cxx/tree/exceptions.hxx>
#include <xsd/cxx/tree/elements.hxx>
#include <xsd/cxx/tree/types.hxx>
 
#include <xsd/cxx/xml/error-handler.hxx>
 
#include <xsd/cxx/xml/dom/auto-ptr.hxx>
 
#include <xsd/cxx/tree/parsing.hxx>
#include <xsd/cxx/tree/parsing/byte.hxx>
#include <xsd/cxx/tree/parsing/unsigned-byte.hxx>
#include <xsd/cxx/tree/parsing/short.hxx>
#include <xsd/cxx/tree/parsing/unsigned-short.hxx>
#include <xsd/cxx/tree/parsing/int.hxx>
#include <xsd/cxx/tree/parsing/unsigned-int.hxx>
#include <xsd/cxx/tree/parsing/long.hxx>
#include <xsd/cxx/tree/parsing/unsigned-long.hxx>
#include <xsd/cxx/tree/parsing/boolean.hxx>
#include <xsd/cxx/tree/parsing/float.hxx>
#include <xsd/cxx/tree/parsing/double.hxx>
#include <xsd/cxx/tree/parsing/decimal.hxx>
 
#include <xsd/cxx/xml/dom/serialization-header.hxx>
#include <xsd/cxx/tree/serialization.hxx>
#include <xsd/cxx/tree/serialization/byte.hxx>
#include <xsd/cxx/tree/serialization/unsigned-byte.hxx>
#include <xsd/cxx/tree/serialization/short.hxx>
#include <xsd/cxx/tree/serialization/unsigned-short.hxx>
#include <xsd/cxx/tree/serialization/int.hxx>
#include <xsd/cxx/tree/serialization/unsigned-int.hxx>
#include <xsd/cxx/tree/serialization/long.hxx>
#include <xsd/cxx/tree/serialization/unsigned-long.hxx>
#include <xsd/cxx/tree/serialization/boolean.hxx>
#include <xsd/cxx/tree/serialization/float.hxx>
#include <xsd/cxx/tree/serialization/double.hxx>
#include <xsd/cxx/tree/serialization/decimal.hxx>
 
namespace xml_schema
{
  // anyType and anySimpleType.
  //
 
  typedef ::xsd::cxx::tree::type type;
 
  typedef ::xsd::cxx::tree::simple_type< char, type > simple_type;
 
  typedef ::xsd::cxx::tree::type container;
 
 
  // 8-bit
  //
 
  typedef signed char byte;
 
  typedef unsigned char unsigned_byte;
 
 
  // 16-bit
  //
 
  typedef short short_;
 
  typedef unsigned short unsigned_short;
 
 
  // 32-bit
  //
 
  typedef int int_;
 
  typedef unsigned int unsigned_int;
 
 
  // 64-bit
  //
 
  typedef long long long_;
 
  typedef unsigned long long unsigned_long;
 
 
  // Supposed to be arbitrary-length integral types.
  //
 
  typedef long long integer;
 
  typedef long long non_positive_integer;
 
  typedef unsigned long long non_negative_integer;
 
  typedef unsigned long long positive_integer;
 
  typedef long long negative_integer;
 
 
  // Boolean.
  //
 
  typedef bool boolean;
 
 
  // Floating-point types.
  //
 
  typedef float float_;
 
  typedef double double_;
 
  typedef double decimal;
 
 
  // String types.
  //
 
  typedef ::xsd::cxx::tree::string< char, simple_type > string;
 
  typedef ::xsd::cxx::tree::normalized_string< char, string > normalized_string;
 
  typedef ::xsd::cxx::tree::token< char, normalized_string > token;
 
  typedef ::xsd::cxx::tree::name< char, token > name;
 
  typedef ::xsd::cxx::tree::nmtoken< char, token > nmtoken;
 
  typedef ::xsd::cxx::tree::nmtokens< char, simple_type, nmtoken > nmtokens;
 
  typedef ::xsd::cxx::tree::ncname< char, name > ncname;
 
  typedef ::xsd::cxx::tree::language< char, token > language;
 
 
  // ID/IDREF.
  //
 
  typedef ::xsd::cxx::tree::id< char, ncname > id;
 
  typedef ::xsd::cxx::tree::idref< char, ncname, type > idref;
 
  typedef ::xsd::cxx::tree::idrefs< char, simple_type, idref > idrefs;
 
 
  // URI.
  //
 
  typedef ::xsd::cxx::tree::uri< char, simple_type > uri;
 
 
  // Qualified name.
  //
 
  typedef ::xsd::cxx::tree::qname< char, simple_type, uri, ncname > qname;
 
 
  // Binary.
  //
 
  typedef ::xsd::cxx::tree::buffer< char > buffer;
 
  typedef ::xsd::cxx::tree::base64_binary< char, simple_type > base64_binary;
 
  typedef ::xsd::cxx::tree::hex_binary< char, simple_type > hex_binary;
 
 
  // Date/time.
  //
 
  typedef ::xsd::cxx::tree::time_zone time_zone;
 
  typedef ::xsd::cxx::tree::date< char, simple_type > date;
 
  typedef ::xsd::cxx::tree::date_time< char, simple_type > date_time;
 
  typedef ::xsd::cxx::tree::duration< char, simple_type > duration;
 
  typedef ::xsd::cxx::tree::gday< char, simple_type > gday;
 
  typedef ::xsd::cxx::tree::gmonth< char, simple_type > gmonth;
 
  typedef ::xsd::cxx::tree::gmonth_day< char, simple_type > gmonth_day;
 
  typedef ::xsd::cxx::tree::gyear< char, simple_type > gyear;
 
  typedef ::xsd::cxx::tree::gyear_month< char, simple_type > gyear_month;
 
  typedef ::xsd::cxx::tree::time< char, simple_type > time;
 
 
  // Entity.
  //
 
  typedef ::xsd::cxx::tree::entity< char, ncname > entity;
 
  typedef ::xsd::cxx::tree::entities< char, simple_type, entity > entities;
 
 
 
  typedef ::xsd::cxx::tree::content_order content_order;
  // Namespace information and list stream. Used in
  // serialization functions.
  //
  typedef ::xsd::cxx::xml::dom::namespace_info< char > namespace_info;
 
  typedef ::xsd::cxx::xml::dom::namespace_infomap< char > namespace_infomap;
 
  typedef ::xsd::cxx::tree::list_stream< char > list_stream;
 
  typedef ::xsd::cxx::tree::as_double< double_ > as_double;
 
  typedef ::xsd::cxx::tree::as_decimal< decimal > as_decimal;
 
  typedef ::xsd::cxx::tree::facet facet;
 
  // Flags and properties.
  //
 
  typedef ::xsd::cxx::tree::flags flags;
 
  typedef ::xsd::cxx::tree::properties< char > properties;
 
  // Parsing/serialization diagnostics.
  //
 
  typedef ::xsd::cxx::tree::severity severity;
 
  typedef ::xsd::cxx::tree::error< char > error;
 
  typedef ::xsd::cxx::tree::diagnostics< char > diagnostics;
 
  // Exceptions.
  //
 
  typedef ::xsd::cxx::tree::exception< char > exception;
 
  typedef ::xsd::cxx::tree::bounds< char > bounds;
 
  typedef ::xsd::cxx::tree::duplicate_id< char > duplicate_id;
 
  typedef ::xsd::cxx::tree::parsing< char > parsing;
 
  typedef ::xsd::cxx::tree::expected_element< char > expected_element;
 
  typedef ::xsd::cxx::tree::unexpected_element< char > unexpected_element;
 
  typedef ::xsd::cxx::tree::expected_attribute< char > expected_attribute;
 
  typedef ::xsd::cxx::tree::unexpected_enumerator< char > unexpected_enumerator;
 
  typedef ::xsd::cxx::tree::expected_text_content< char > expected_text_content;
 
  typedef ::xsd::cxx::tree::no_prefix_mapping< char > no_prefix_mapping;
 
  typedef ::xsd::cxx::tree::serialization< char > serialization;
 
  typedef ::xsd::cxx::xml::error_handler< char > error_handler;
 
  namespace dom
  {
    using ::xsd::cxx::xml::dom::unique_ptr;
 
#ifndef XSD_CXX_TREE_TREE_NODE_KEY__XML_SCHEMA
#define XSD_CXX_TREE_TREE_NODE_KEY__XML_SCHEMA
    const XMLCh* const tree_node_key = ::xsd::cxx::tree::user_data_keys::node;
#endif
  }
}
 
// Forward declarations.
//
class Molecules;
class OutputFileName;
class OutputFrequency;
class ParallelizationStrategy;
class ThermostatConfig;
class GravityConfig;
class model;
class SingleParticles;
class Cuboids;
class Discs;
class Spheres;
class Membrane;
class Type;
class InitialTemperature;
class TargetTemperature;
class MaximumTemperatureChange;
class ApplyAfterHowManySteps;
class Dimension;
class Name;
class t_end;
class delta_t;
class force;
class DomainSize;
class rCutOff;
class BoundaryCondition;
class Size;
class SingleParticle;
class Cuboid;
class Disc;
class Sphere;
class PullingActiveUntil;
class PullingForce;
class Velocity;
class Position;
class N1;
class N2;
class Mass;
class InterParticleDistance;
class Sigma;
class Epsilon;
class First;
class Second;
class Third;
class boundaries;
class N11;
class N21;
class N3;
class Distance;
class Brownian;
class DimensionBrownian;
class Center;
class Front;
class Back;
class Left;
class Right;
class Top;
class Bottom;
 
#include <memory>    // ::std::unique_ptr
#include <limits>    // std::numeric_limits
#include <algorithm> // std::binary_search
#include <utility>   // std::move
 
#include <xsd/cxx/xml/char-utf8.hxx>
 
#include <xsd/cxx/tree/exceptions.hxx>
#include <xsd/cxx/tree/elements.hxx>
#include <xsd/cxx/tree/containers.hxx>
#include <xsd/cxx/tree/list.hxx>
 
#include <xsd/cxx/xml/dom/parsing-header.hxx>
 
class Molecules: public ::xml_schema::type
{
  public:
 
  typedef ::OutputFileName OutputFileName_type;
 
  typedef ::xsd::cxx::tree::traits< OutputFileName_type, char > OutputFileName_traits;
 
  const OutputFileName_type&
  OutputFileName () const;
 
  OutputFileName_type&
  OutputFileName ();
 
  void
  OutputFileName (const OutputFileName_type& x);
 
  void
  OutputFileName (::std::unique_ptr< OutputFileName_type > p);
 
 
 
  typedef ::OutputFrequency OutputFrequency_type;
 
  typedef ::xsd::cxx::tree::traits< OutputFrequency_type, char > OutputFrequency_traits;
 
  const OutputFrequency_type&
  OutputFrequency () const;
 
  OutputFrequency_type&
  OutputFrequency ();
 
  void
  OutputFrequency (const OutputFrequency_type& x);
 
  void
  OutputFrequency (::std::unique_ptr< OutputFrequency_type > p);
 
 
 
  typedef ::ParallelizationStrategy ParallelizationStrategy_type;
 
  typedef ::xsd::cxx::tree::optional< ParallelizationStrategy_type > ParallelizationStrategy_optional;
 
  typedef ::xsd::cxx::tree::traits< ParallelizationStrategy_type, char > ParallelizationStrategy_traits;
 
  const ParallelizationStrategy_optional&
  ParallelizationStrategy () const;
 
  ParallelizationStrategy_optional&
  ParallelizationStrategy ();
 
  void
  ParallelizationStrategy (const ParallelizationStrategy_type& x);
 
  void
  ParallelizationStrategy (const ParallelizationStrategy_optional& x);
 
  void
  ParallelizationStrategy (::std::unique_ptr< ParallelizationStrategy_type > p);
 
 
 
  typedef ::ThermostatConfig ThermostatConfig_type;
 
  typedef ::xsd::cxx::tree::optional< ThermostatConfig_type > ThermostatConfig_optional;
 
  typedef ::xsd::cxx::tree::traits< ThermostatConfig_type, char > ThermostatConfig_traits;
 
  const ThermostatConfig_optional&
  ThermostatConfig () const;
 
  ThermostatConfig_optional&
  ThermostatConfig ();
 
  void
  ThermostatConfig (const ThermostatConfig_type& x);
 
  void
  ThermostatConfig (const ThermostatConfig_optional& x);
 
  void
  ThermostatConfig (::std::unique_ptr< ThermostatConfig_type > p);
 
 
 
  typedef ::GravityConfig GravityConfig_type;
 
  typedef ::xsd::cxx::tree::optional< GravityConfig_type > GravityConfig_optional;
 
  typedef ::xsd::cxx::tree::traits< GravityConfig_type, char > GravityConfig_traits;
 
  const GravityConfig_optional&
  GravityConfig () const;
 
  GravityConfig_optional&
  GravityConfig ();
 
  void
  GravityConfig (const GravityConfig_type& x);
 
  void
  GravityConfig (const GravityConfig_optional& x);
 
  void
  GravityConfig (::std::unique_ptr< GravityConfig_type > p);
 
 
 
  typedef ::model model_type;
 
  typedef ::xsd::cxx::tree::traits< model_type, char > model_traits;
 
  const model_type&
  model () const;
 
  model_type&
  model ();
 
  void
  model (const model_type& x);
 
  void
  model (::std::unique_ptr< model_type > p);
 
 
 
  typedef ::SingleParticles SingleParticles_type;
 
  typedef ::xsd::cxx::tree::optional< SingleParticles_type > SingleParticles_optional;
 
  typedef ::xsd::cxx::tree::traits< SingleParticles_type, char > SingleParticles_traits;
 
  const SingleParticles_optional&
  SingleParticles () const;
 
  SingleParticles_optional&
  SingleParticles ();
 
  void
  SingleParticles (const SingleParticles_type& x);
 
  void
  SingleParticles (const SingleParticles_optional& x);
 
  void
  SingleParticles (::std::unique_ptr< SingleParticles_type > p);
 
 
 
  typedef ::Cuboids Cuboids_type;
 
  typedef ::xsd::cxx::tree::optional< Cuboids_type > Cuboids_optional;
 
  typedef ::xsd::cxx::tree::traits< Cuboids_type, char > Cuboids_traits;
 
  const Cuboids_optional&
  Cuboids () const;
 
  Cuboids_optional&
  Cuboids ();
 
  void
  Cuboids (const Cuboids_type& x);
 
  void
  Cuboids (const Cuboids_optional& x);
 
  void
  Cuboids (::std::unique_ptr< Cuboids_type > p);
 
 
 
  typedef ::Discs Discs_type;
 
  typedef ::xsd::cxx::tree::optional< Discs_type > Discs_optional;
 
  typedef ::xsd::cxx::tree::traits< Discs_type, char > Discs_traits;
 
  const Discs_optional&
  Discs () const;
 
  Discs_optional&
  Discs ();
 
  void
  Discs (const Discs_type& x);
 
  void
  Discs (const Discs_optional& x);
 
  void
  Discs (::std::unique_ptr< Discs_type > p);
 
 
 
  typedef ::Spheres Spheres_type;
 
  typedef ::xsd::cxx::tree::optional< Spheres_type > Spheres_optional;
 
  typedef ::xsd::cxx::tree::traits< Spheres_type, char > Spheres_traits;
 
  const Spheres_optional&
  Spheres () const;
 
  Spheres_optional&
  Spheres ();
 
  void
  Spheres (const Spheres_type& x);
 
  void
  Spheres (const Spheres_optional& x);
 
  void
  Spheres (::std::unique_ptr< Spheres_type > p);
 
 
 
  typedef ::Membrane Membrane_type;
 
  typedef ::xsd::cxx::tree::optional< Membrane_type > Membrane_optional;
 
  typedef ::xsd::cxx::tree::traits< Membrane_type, char > Membrane_traits;
 
  const Membrane_optional&
  Membrane () const;
 
  Membrane_optional&
  Membrane ();
 
  void
  Membrane (const Membrane_type& x);
 
  void
  Membrane (const Membrane_optional& x);
 
  void
  Membrane (::std::unique_ptr< Membrane_type > p);
 
 
 
  Molecules (const OutputFileName_type&,
             const OutputFrequency_type&,
             const model_type&);
 
  Molecules (const OutputFileName_type&,
             const OutputFrequency_type&,
             ::std::unique_ptr< model_type >);
 
  Molecules (const ::xercesc::DOMElement& e,
             ::xml_schema::flags f = 0,
             ::xml_schema::container* c = 0);
 
  Molecules (const Molecules& x,
             ::xml_schema::flags f = 0,
             ::xml_schema::container* c = 0);
 
  virtual Molecules*
  _clone (::xml_schema::flags f = 0,
          ::xml_schema::container* c = 0) const;
 
  Molecules&
  operator= (const Molecules& x);
 
 
  virtual 
  ~Molecules ();
 
  // Implementation.
  //
 
  //@cond
 
  protected:
  void
  parse (::xsd::cxx::xml::dom::parser< char >&,
         ::xml_schema::flags);
 
  protected:
  ::xsd::cxx::tree::one< OutputFileName_type > OutputFileName_;
  ::xsd::cxx::tree::one< OutputFrequency_type > OutputFrequency_;
  ParallelizationStrategy_optional ParallelizationStrategy_;
  ThermostatConfig_optional ThermostatConfig_;
  GravityConfig_optional GravityConfig_;
  ::xsd::cxx::tree::one< model_type > model_;
  SingleParticles_optional SingleParticles_;
  Cuboids_optional Cuboids_;
  Discs_optional Discs_;
  Spheres_optional Spheres_;
  Membrane_optional Membrane_;
 
  //@endcond
};
 
class OutputFileName: public ::xml_schema::string
{
  public:
 
  OutputFileName ();
 
  OutputFileName (const char*);
 
  OutputFileName (const ::std::string&);
 
  OutputFileName (const ::xml_schema::string&);
 
  OutputFileName (const ::xercesc::DOMElement& e,
                  ::xml_schema::flags f = 0,
                  ::xml_schema::container* c = 0);
 
  OutputFileName (const ::xercesc::DOMAttr& a,
                  ::xml_schema::flags f = 0,
                  ::xml_schema::container* c = 0);
 
  OutputFileName (const ::std::string& s,
                  const ::xercesc::DOMElement* e,
                  ::xml_schema::flags f = 0,
                  ::xml_schema::container* c = 0);
 
  OutputFileName (const OutputFileName& x,
                  ::xml_schema::flags f = 0,
                  ::xml_schema::container* c = 0);
 
  virtual OutputFileName*
  _clone (::xml_schema::flags f = 0,
          ::xml_schema::container* c = 0) const;
 
 
  virtual 
  ~OutputFileName ();
};
 
class OutputFrequency: public ::xsd::cxx::tree::fundamental_base< ::xml_schema::integer, char, ::xml_schema::simple_type >
{
  public:
 
  OutputFrequency (const ::xml_schema::integer&);
 
  OutputFrequency (const ::xercesc::DOMElement& e,
                   ::xml_schema::flags f = 0,
                   ::xml_schema::container* c = 0);
 
  OutputFrequency (const ::xercesc::DOMAttr& a,
                   ::xml_schema::flags f = 0,
                   ::xml_schema::container* c = 0);
 
  OutputFrequency (const ::std::string& s,
                   const ::xercesc::DOMElement* e,
                   ::xml_schema::flags f = 0,
                   ::xml_schema::container* c = 0);
 
  OutputFrequency (const OutputFrequency& x,
                   ::xml_schema::flags f = 0,
                   ::xml_schema::container* c = 0);
 
  virtual OutputFrequency*
  _clone (::xml_schema::flags f = 0,
          ::xml_schema::container* c = 0) const;
 
 
  virtual 
  ~OutputFrequency ();
};
 
class ParallelizationStrategy: public ::xml_schema::string
{
  public:
 
  enum value
  {
    Linear,
    Skipping,
    Reduction
  };
 
  ParallelizationStrategy (value v);
 
  ParallelizationStrategy (const char* v);
 
  ParallelizationStrategy (const ::std::string& v);
 
  ParallelizationStrategy (const ::xml_schema::string& v);
 
  ParallelizationStrategy (const ::xercesc::DOMElement& e,
                           ::xml_schema::flags f = 0,
                           ::xml_schema::container* c = 0);
 
  ParallelizationStrategy (const ::xercesc::DOMAttr& a,
                           ::xml_schema::flags f = 0,
                           ::xml_schema::container* c = 0);
 
  ParallelizationStrategy (const ::std::string& s,
                           const ::xercesc::DOMElement* e,
                           ::xml_schema::flags f = 0,
                           ::xml_schema::container* c = 0);
 
  ParallelizationStrategy (const ParallelizationStrategy& x,
                           ::xml_schema::flags f = 0,
                           ::xml_schema::container* c = 0);
 
  virtual ParallelizationStrategy*
  _clone (::xml_schema::flags f = 0,
          ::xml_schema::container* c = 0) const;
 
  ParallelizationStrategy&
  operator= (value v);
 
  virtual
  operator value () const
  {
    return _xsd_ParallelizationStrategy_convert ();
  }
 
  //@cond
 
  protected:
  value
  _xsd_ParallelizationStrategy_convert () const;
 
  public:
  static const char* const _xsd_ParallelizationStrategy_literals_[3];
  static const value _xsd_ParallelizationStrategy_indexes_[3];
 
  //@endcond
};
 
class ThermostatConfig: public ::xml_schema::type
{
  public:
 
  typedef ::Type Type_type;
 
  typedef ::xsd::cxx::tree::traits< Type_type, char > Type_traits;
 
  const Type_type&
  Type () const;
 
  Type_type&
  Type ();
 
  void
  Type (const Type_type& x);
 
  void
  Type (::std::unique_ptr< Type_type > p);
 
 
 
  typedef ::InitialTemperature InitialTemperature_type;
 
  typedef ::xsd::cxx::tree::traits< InitialTemperature_type, char > InitialTemperature_traits;
 
  const InitialTemperature_type&
  InitialTemperature () const;
 
  InitialTemperature_type&
  InitialTemperature ();
 
  void
  InitialTemperature (const InitialTemperature_type& x);
 
  void
  InitialTemperature (::std::unique_ptr< InitialTemperature_type > p);
 
 
 
  typedef ::TargetTemperature TargetTemperature_type;
 
  typedef ::xsd::cxx::tree::traits< TargetTemperature_type, char > TargetTemperature_traits;
 
  const TargetTemperature_type&
  TargetTemperature () const;
 
  TargetTemperature_type&
  TargetTemperature ();
 
  void
  TargetTemperature (const TargetTemperature_type& x);
 
  void
  TargetTemperature (::std::unique_ptr< TargetTemperature_type > p);
 
 
 
  typedef ::xml_schema::boolean InitialBrownian_type;
 
  typedef ::xsd::cxx::tree::traits< InitialBrownian_type, char > InitialBrownian_traits;
 
  const InitialBrownian_type&
  InitialBrownian () const;
 
  InitialBrownian_type&
  InitialBrownian ();
 
  void
  InitialBrownian (const InitialBrownian_type& x);
 
 
 
  typedef ::xml_schema::boolean ScalingGradually_type;
 
  typedef ::xsd::cxx::tree::traits< ScalingGradually_type, char > ScalingGradually_traits;
 
  const ScalingGradually_type&
  ScalingGradually () const;
 
  ScalingGradually_type&
  ScalingGradually ();
 
  void
  ScalingGradually (const ScalingGradually_type& x);
 
 
 
  typedef ::MaximumTemperatureChange MaximumTemperatureChange_type;
 
  typedef ::xsd::cxx::tree::optional< MaximumTemperatureChange_type > MaximumTemperatureChange_optional;
 
  typedef ::xsd::cxx::tree::traits< MaximumTemperatureChange_type, char > MaximumTemperatureChange_traits;
 
  const MaximumTemperatureChange_optional&
  MaximumTemperatureChange () const;
 
  MaximumTemperatureChange_optional&
  MaximumTemperatureChange ();
 
  void
  MaximumTemperatureChange (const MaximumTemperatureChange_type& x);
 
  void
  MaximumTemperatureChange (const MaximumTemperatureChange_optional& x);
 
  void
  MaximumTemperatureChange (::std::unique_ptr< MaximumTemperatureChange_type > p);
 
 
 
  typedef ::ApplyAfterHowManySteps ApplyAfterHowManySteps_type;
 
  typedef ::xsd::cxx::tree::traits< ApplyAfterHowManySteps_type, char > ApplyAfterHowManySteps_traits;
 
  const ApplyAfterHowManySteps_type&
  ApplyAfterHowManySteps () const;
 
  ApplyAfterHowManySteps_type&
  ApplyAfterHowManySteps ();
 
  void
  ApplyAfterHowManySteps (const ApplyAfterHowManySteps_type& x);
 
  void
  ApplyAfterHowManySteps (::std::unique_ptr< ApplyAfterHowManySteps_type > p);
 
 
 
  typedef ::Dimension Dimension_type;
 
  typedef ::xsd::cxx::tree::traits< Dimension_type, char > Dimension_traits;
 
  const Dimension_type&
  Dimension () const;
 
  Dimension_type&
  Dimension ();
 
  void
  Dimension (const Dimension_type& x);
 
  void
  Dimension (::std::unique_ptr< Dimension_type > p);
 
 
 
  ThermostatConfig (const Type_type&,
                    const InitialTemperature_type&,
                    const TargetTemperature_type&,
                    const InitialBrownian_type&,
                    const ScalingGradually_type&,
                    const ApplyAfterHowManySteps_type&,
                    const Dimension_type&);
 
  ThermostatConfig (const ::xercesc::DOMElement& e,
                    ::xml_schema::flags f = 0,
                    ::xml_schema::container* c = 0);
 
  ThermostatConfig (const ThermostatConfig& x,
                    ::xml_schema::flags f = 0,
                    ::xml_schema::container* c = 0);
 
  virtual ThermostatConfig*
  _clone (::xml_schema::flags f = 0,
          ::xml_schema::container* c = 0) const;
 
  ThermostatConfig&
  operator= (const ThermostatConfig& x);
 
 
  virtual 
  ~ThermostatConfig ();
 
  // Implementation.
  //
 
  //@cond
 
  protected:
  void
  parse (::xsd::cxx::xml::dom::parser< char >&,
         ::xml_schema::flags);
 
  protected:
  ::xsd::cxx::tree::one< Type_type > Type_;
  ::xsd::cxx::tree::one< InitialTemperature_type > InitialTemperature_;
  ::xsd::cxx::tree::one< TargetTemperature_type > TargetTemperature_;
  ::xsd::cxx::tree::one< InitialBrownian_type > InitialBrownian_;
  ::xsd::cxx::tree::one< ScalingGradually_type > ScalingGradually_;
  MaximumTemperatureChange_optional MaximumTemperatureChange_;
  ::xsd::cxx::tree::one< ApplyAfterHowManySteps_type > ApplyAfterHowManySteps_;
  ::xsd::cxx::tree::one< Dimension_type > Dimension_;
 
  //@endcond
};
 
class GravityConfig: public ::xml_schema::type
{
  public:
 
  typedef ::xml_schema::decimal X_type;
 
  typedef ::xsd::cxx::tree::traits< X_type, char, ::xsd::cxx::tree::schema_type::decimal > X_traits;
 
  const X_type&
  X () const;
 
  X_type&
  X ();
 
  void
  X (const X_type& x);
 
 
 
  typedef ::xml_schema::decimal Y_type;
 
  typedef ::xsd::cxx::tree::traits< Y_type, char, ::xsd::cxx::tree::schema_type::decimal > Y_traits;
 
  const Y_type&
  Y () const;
 
  Y_type&
  Y ();
 
  void
  Y (const Y_type& x);
 
 
 
  typedef ::xml_schema::decimal Z_type;
 
  typedef ::xsd::cxx::tree::traits< Z_type, char, ::xsd::cxx::tree::schema_type::decimal > Z_traits;
 
  const Z_type&
  Z () const;
 
  Z_type&
  Z ();
 
  void
  Z (const Z_type& x);
 
 
 
  GravityConfig (const X_type&,
                 const Y_type&,
                 const Z_type&);
 
  GravityConfig (const ::xercesc::DOMElement& e,
                 ::xml_schema::flags f = 0,
                 ::xml_schema::container* c = 0);
 
  GravityConfig (const GravityConfig& x,
                 ::xml_schema::flags f = 0,
                 ::xml_schema::container* c = 0);
 
  virtual GravityConfig*
  _clone (::xml_schema::flags f = 0,
          ::xml_schema::container* c = 0) const;
 
  GravityConfig&
  operator= (const GravityConfig& x);
 
 
  virtual 
  ~GravityConfig ();
 
  // Implementation.
  //
 
  //@cond
 
  protected:
  void
  parse (::xsd::cxx::xml::dom::parser< char >&,
         ::xml_schema::flags);
 
  protected:
  ::xsd::cxx::tree::one< X_type > X_;
  ::xsd::cxx::tree::one< Y_type > Y_;
  ::xsd::cxx::tree::one< Z_type > Z_;
 
  //@endcond
};
 
class model: public ::xml_schema::type
{
  public:
 
  typedef ::Name Name_type;
 
  typedef ::xsd::cxx::tree::traits< Name_type, char > Name_traits;
 
  const Name_type&
  Name () const;
 
  Name_type&
  Name ();
 
  void
  Name (const Name_type& x);
 
  void
  Name (::std::unique_ptr< Name_type > p);
 
 
 
  typedef ::t_end t_end_type;
 
  typedef ::xsd::cxx::tree::traits< t_end_type, char > t_end_traits;
 
  const t_end_type&
  t_end () const;
 
  t_end_type&
  t_end ();
 
  void
  t_end (const t_end_type& x);
 
  void
  t_end (::std::unique_ptr< t_end_type > p);
 
 
 
  typedef ::delta_t delta_t_type;
 
  typedef ::xsd::cxx::tree::traits< delta_t_type, char > delta_t_traits;
 
  const delta_t_type&
  delta_t () const;
 
  delta_t_type&
  delta_t ();
 
  void
  delta_t (const delta_t_type& x);
 
  void
  delta_t (::std::unique_ptr< delta_t_type > p);
 
 
 
  typedef ::force force_type;
 
  typedef ::xsd::cxx::tree::traits< force_type, char > force_traits;
 
  const force_type&
  force () const;
 
  force_type&
  force ();
 
  void
  force (const force_type& x);
 
  void
  force (::std::unique_ptr< force_type > p);
 
 
 
  typedef ::DomainSize DomainSize_type;
 
  typedef ::xsd::cxx::tree::optional< DomainSize_type > DomainSize_optional;
 
  typedef ::xsd::cxx::tree::traits< DomainSize_type, char > DomainSize_traits;
 
  const DomainSize_optional&
  DomainSize () const;
 
  DomainSize_optional&
  DomainSize ();
 
  void
  DomainSize (const DomainSize_type& x);
 
  void
  DomainSize (const DomainSize_optional& x);
 
  void
  DomainSize (::std::unique_ptr< DomainSize_type > p);
 
 
 
  typedef ::rCutOff rCutOff_type;
 
  typedef ::xsd::cxx::tree::optional< rCutOff_type > rCutOff_optional;
 
  typedef ::xsd::cxx::tree::traits< rCutOff_type, char > rCutOff_traits;
 
  const rCutOff_optional&
  rCutOff () const;
 
  rCutOff_optional&
  rCutOff ();
 
  void
  rCutOff (const rCutOff_type& x);
 
  void
  rCutOff (const rCutOff_optional& x);
 
  void
  rCutOff (::std::unique_ptr< rCutOff_type > p);
 
 
 
  typedef ::BoundaryCondition BoundaryCondition_type;
 
  typedef ::xsd::cxx::tree::optional< BoundaryCondition_type > BoundaryCondition_optional;
 
  typedef ::xsd::cxx::tree::traits< BoundaryCondition_type, char > BoundaryCondition_traits;
 
  const BoundaryCondition_optional&
  BoundaryCondition () const;
 
  BoundaryCondition_optional&
  BoundaryCondition ();
 
  void
  BoundaryCondition (const BoundaryCondition_type& x);
 
  void
  BoundaryCondition (const BoundaryCondition_optional& x);
 
  void
  BoundaryCondition (::std::unique_ptr< BoundaryCondition_type > p);
 
 
 
  model (const Name_type&,
         const t_end_type&,
         const delta_t_type&,
         const force_type&);
 
  model (const ::xercesc::DOMElement& e,
         ::xml_schema::flags f = 0,
         ::xml_schema::container* c = 0);
 
  model (const model& x,
         ::xml_schema::flags f = 0,
         ::xml_schema::container* c = 0);
 
  virtual model*
  _clone (::xml_schema::flags f = 0,
          ::xml_schema::container* c = 0) const;
 
  model&
  operator= (const model& x);
 
 
  virtual 
  ~model ();
 
  // Implementation.
  //
 
  //@cond
 
  protected:
  void
  parse (::xsd::cxx::xml::dom::parser< char >&,
         ::xml_schema::flags);
 
  protected:
  ::xsd::cxx::tree::one< Name_type > Name_;
  ::xsd::cxx::tree::one< t_end_type > t_end_;
  ::xsd::cxx::tree::one< delta_t_type > delta_t_;
  ::xsd::cxx::tree::one< force_type > force_;
  DomainSize_optional DomainSize_;
  rCutOff_optional rCutOff_;
  BoundaryCondition_optional BoundaryCondition_;
 
  //@endcond
};
 
class SingleParticles: public ::xml_schema::type
{
  public:
 
  typedef ::Size Size_type;
 
  typedef ::xsd::cxx::tree::traits< Size_type, char > Size_traits;
 
  const Size_type&
  Size () const;
 
  Size_type&
  Size ();
 
  void
  Size (const Size_type& x);
 
  void
  Size (::std::unique_ptr< Size_type > p);
 
 
 
  typedef ::SingleParticle SingleParticle_type;
 
  typedef ::xsd::cxx::tree::sequence< SingleParticle_type > SingleParticle_sequence;
 
  typedef SingleParticle_sequence::iterator SingleParticle_iterator;
 
  typedef SingleParticle_sequence::const_iterator SingleParticle_const_iterator;
 
  typedef ::xsd::cxx::tree::traits< SingleParticle_type, char > SingleParticle_traits;
 
  const SingleParticle_sequence&
  SingleParticle () const;
 
  SingleParticle_sequence&
  SingleParticle ();
 
  void
  SingleParticle (const SingleParticle_sequence& s);
 
 
 
  SingleParticles (const Size_type&);
 
  SingleParticles (const ::xercesc::DOMElement& e,
                   ::xml_schema::flags f = 0,
                   ::xml_schema::container* c = 0);
 
  SingleParticles (const SingleParticles& x,
                   ::xml_schema::flags f = 0,
                   ::xml_schema::container* c = 0);
 
  virtual SingleParticles*
  _clone (::xml_schema::flags f = 0,
          ::xml_schema::container* c = 0) const;
 
  SingleParticles&
  operator= (const SingleParticles& x);
 
 
  virtual 
  ~SingleParticles ();
 
  // Implementation.
  //
 
  //@cond
 
  protected:
  void
  parse (::xsd::cxx::xml::dom::parser< char >&,
         ::xml_schema::flags);
 
  protected:
  ::xsd::cxx::tree::one< Size_type > Size_;
  SingleParticle_sequence SingleParticle_;
 
  //@endcond
};
 
class Cuboids: public ::xml_schema::type
{
  public:
 
  typedef ::Size Size_type;
 
  typedef ::xsd::cxx::tree::traits< Size_type, char > Size_traits;
 
  const Size_type&
  Size () const;
 
  Size_type&
  Size ();
 
  void
  Size (const Size_type& x);
 
  void
  Size (::std::unique_ptr< Size_type > p);
 
 
 
  typedef ::Cuboid Cuboid_type;
 
  typedef ::xsd::cxx::tree::sequence< Cuboid_type > Cuboid_sequence;
 
  typedef Cuboid_sequence::iterator Cuboid_iterator;
 
  typedef Cuboid_sequence::const_iterator Cuboid_const_iterator;
 
  typedef ::xsd::cxx::tree::traits< Cuboid_type, char > Cuboid_traits;
 
  const Cuboid_sequence&
  Cuboid () const;
 
  Cuboid_sequence&
  Cuboid ();
 
  void
  Cuboid (const Cuboid_sequence& s);
 
 
 
  Cuboids (const Size_type&);
 
  Cuboids (const ::xercesc::DOMElement& e,
           ::xml_schema::flags f = 0,
           ::xml_schema::container* c = 0);
 
  Cuboids (const Cuboids& x,
           ::xml_schema::flags f = 0,
           ::xml_schema::container* c = 0);
 
  virtual Cuboids*
  _clone (::xml_schema::flags f = 0,
          ::xml_schema::container* c = 0) const;
 
  Cuboids&
  operator= (const Cuboids& x);
 
 
  virtual 
  ~Cuboids ();
 
  // Implementation.
  //
 
  //@cond
 
  protected:
  void
  parse (::xsd::cxx::xml::dom::parser< char >&,
         ::xml_schema::flags);
 
  protected:
  ::xsd::cxx::tree::one< Size_type > Size_;
  Cuboid_sequence Cuboid_;
 
  //@endcond
};
 
class Discs: public ::xml_schema::type
{
  public:
 
  typedef ::Size Size_type;
 
  typedef ::xsd::cxx::tree::traits< Size_type, char > Size_traits;
 
  const Size_type&
  Size () const;
 
  Size_type&
  Size ();
 
  void
  Size (const Size_type& x);
 
  void
  Size (::std::unique_ptr< Size_type > p);
 
 
 
  typedef ::Disc Disc_type;
 
  typedef ::xsd::cxx::tree::sequence< Disc_type > Disc_sequence;
 
  typedef Disc_sequence::iterator Disc_iterator;
 
  typedef Disc_sequence::const_iterator Disc_const_iterator;
 
  typedef ::xsd::cxx::tree::traits< Disc_type, char > Disc_traits;
 
  const Disc_sequence&
  Disc () const;
 
  Disc_sequence&
  Disc ();
 
  void
  Disc (const Disc_sequence& s);
 
 
 
  Discs (const Size_type&);
 
  Discs (const ::xercesc::DOMElement& e,
         ::xml_schema::flags f = 0,
         ::xml_schema::container* c = 0);
 
  Discs (const Discs& x,
         ::xml_schema::flags f = 0,
         ::xml_schema::container* c = 0);
 
  virtual Discs*
  _clone (::xml_schema::flags f = 0,
          ::xml_schema::container* c = 0) const;
 
  Discs&
  operator= (const Discs& x);
 
 
  virtual 
  ~Discs ();
 
  // Implementation.
  //
 
  //@cond
 
  protected:
  void
  parse (::xsd::cxx::xml::dom::parser< char >&,
         ::xml_schema::flags);
 
  protected:
  ::xsd::cxx::tree::one< Size_type > Size_;
  Disc_sequence Disc_;
 
  //@endcond
};
 
class Spheres: public ::xml_schema::type
{
  public:
 
  typedef ::Size Size_type;
 
  typedef ::xsd::cxx::tree::traits< Size_type, char > Size_traits;
 
  const Size_type&
  Size () const;
 
  Size_type&
  Size ();
 
  void
  Size (const Size_type& x);
 
  void
  Size (::std::unique_ptr< Size_type > p);
 
 
 
  typedef ::Sphere Sphere_type;
 
  typedef ::xsd::cxx::tree::sequence< Sphere_type > Sphere_sequence;
 
  typedef Sphere_sequence::iterator Sphere_iterator;
 
  typedef Sphere_sequence::const_iterator Sphere_const_iterator;
 
  typedef ::xsd::cxx::tree::traits< Sphere_type, char > Sphere_traits;
 
  const Sphere_sequence&
  Sphere () const;
 
  Sphere_sequence&
  Sphere ();
 
  void
  Sphere (const Sphere_sequence& s);
 
 
 
  Spheres (const Size_type&);
 
  Spheres (const ::xercesc::DOMElement& e,
           ::xml_schema::flags f = 0,
           ::xml_schema::container* c = 0);
 
  Spheres (const Spheres& x,
           ::xml_schema::flags f = 0,
           ::xml_schema::container* c = 0);
 
  virtual Spheres*
  _clone (::xml_schema::flags f = 0,
          ::xml_schema::container* c = 0) const;
 
  Spheres&
  operator= (const Spheres& x);
 
 
  virtual 
  ~Spheres ();
 
  // Implementation.
  //
 
  //@cond
 
  protected:
  void
  parse (::xsd::cxx::xml::dom::parser< char >&,
         ::xml_schema::flags);
 
  protected:
  ::xsd::cxx::tree::one< Size_type > Size_;
  Sphere_sequence Sphere_;
 
  //@endcond
};
 
class Membrane: public ::xml_schema::type
{
  public:
 
  typedef ::xml_schema::boolean Pull_type;
 
  typedef ::xsd::cxx::tree::traits< Pull_type, char > Pull_traits;
 
  const Pull_type&
  Pull () const;
 
  Pull_type&
  Pull ();
 
  void
  Pull (const Pull_type& x);
 
 
 
  typedef ::PullingActiveUntil PullingActiveUntil_type;
 
  typedef ::xsd::cxx::tree::optional< PullingActiveUntil_type > PullingActiveUntil_optional;
 
  typedef ::xsd::cxx::tree::traits< PullingActiveUntil_type, char > PullingActiveUntil_traits;
 
  const PullingActiveUntil_optional&
  PullingActiveUntil () const;
 
  PullingActiveUntil_optional&
  PullingActiveUntil ();
 
  void
  PullingActiveUntil (const PullingActiveUntil_type& x);
 
  void
  PullingActiveUntil (const PullingActiveUntil_optional& x);
 
  void
  PullingActiveUntil (::std::unique_ptr< PullingActiveUntil_type > p);
 
 
 
  typedef ::PullingForce PullingForce_type;
 
  typedef ::xsd::cxx::tree::optional< PullingForce_type > PullingForce_optional;
 
  typedef ::xsd::cxx::tree::traits< PullingForce_type, char > PullingForce_traits;
 
  const PullingForce_optional&
  PullingForce () const;
 
  PullingForce_optional&
  PullingForce ();
 
  void
  PullingForce (const PullingForce_type& x);
 
  void
  PullingForce (const PullingForce_optional& x);
 
  void
  PullingForce (::std::unique_ptr< PullingForce_type > p);
 
 
 
  typedef ::xml_schema::decimal r0_type;
 
  typedef ::xsd::cxx::tree::traits< r0_type, char, ::xsd::cxx::tree::schema_type::decimal > r0_traits;
 
  const r0_type&
  r0 () const;
 
  r0_type&
  r0 ();
 
  void
  r0 (const r0_type& x);
 
 
 
  typedef ::xml_schema::decimal k_type;
 
  typedef ::xsd::cxx::tree::traits< k_type, char, ::xsd::cxx::tree::schema_type::decimal > k_traits;
 
  const k_type&
  k () const;
 
  k_type&
  k ();
 
  void
  k (const k_type& x);
 
 
 
  typedef ::Velocity Velocity_type;
 
  typedef ::xsd::cxx::tree::traits< Velocity_type, char > Velocity_traits;
 
  const Velocity_type&
  Velocity () const;
 
  Velocity_type&
  Velocity ();
 
  void
  Velocity (const Velocity_type& x);
 
  void
  Velocity (::std::unique_ptr< Velocity_type > p);
 
 
 
  typedef ::Position Position_type;
 
  typedef ::xsd::cxx::tree::traits< Position_type, char > Position_traits;
 
  const Position_type&
  Position () const;
 
  Position_type&
  Position ();
 
  void
  Position (const Position_type& x);
 
  void
  Position (::std::unique_ptr< Position_type > p);
 
 
 
  typedef ::N1 N1_type;
 
  typedef ::xsd::cxx::tree::traits< N1_type, char > N1_traits;
 
  const N1_type&
  N1 () const;
 
  N1_type&
  N1 ();
 
  void
  N1 (const N1_type& x);
 
  void
  N1 (::std::unique_ptr< N1_type > p);
 
 
 
  typedef ::N2 N2_type;
 
  typedef ::xsd::cxx::tree::traits< N2_type, char > N2_traits;
 
  const N2_type&
  N2 () const;
 
  N2_type&
  N2 ();
 
  void
  N2 (const N2_type& x);
 
  void
  N2 (::std::unique_ptr< N2_type > p);
 
 
 
  typedef ::Mass Mass_type;
 
  typedef ::xsd::cxx::tree::traits< Mass_type, char > Mass_traits;
 
  const Mass_type&
  Mass () const;
 
  Mass_type&
  Mass ();
 
  void
  Mass (const Mass_type& x);
 
  void
  Mass (::std::unique_ptr< Mass_type > p);
 
 
 
  typedef ::InterParticleDistance InterParticleDistance_type;
 
  typedef ::xsd::cxx::tree::traits< InterParticleDistance_type, char > InterParticleDistance_traits;
 
  const InterParticleDistance_type&
  InterParticleDistance () const;
 
  InterParticleDistance_type&
  InterParticleDistance ();
 
  void
  InterParticleDistance (const InterParticleDistance_type& x);
 
  void
  InterParticleDistance (::std::unique_ptr< InterParticleDistance_type > p);
 
 
 
  typedef ::Sigma Sigma_type;
 
  typedef ::xsd::cxx::tree::traits< Sigma_type, char > Sigma_traits;
 
  const Sigma_type&
  Sigma () const;
 
  Sigma_type&
  Sigma ();
 
  void
  Sigma (const Sigma_type& x);
 
  void
  Sigma (::std::unique_ptr< Sigma_type > p);
 
 
 
  typedef ::Epsilon Epsilon_type;
 
  typedef ::xsd::cxx::tree::traits< Epsilon_type, char > Epsilon_traits;
 
  const Epsilon_type&
  Epsilon () const;
 
  Epsilon_type&
  Epsilon ();
 
  void
  Epsilon (const Epsilon_type& x);
 
  void
  Epsilon (::std::unique_ptr< Epsilon_type > p);
 
 
 
  Membrane (const Pull_type&,
            const r0_type&,
            const k_type&,
            const Velocity_type&,
            const Position_type&,
            const N1_type&,
            const N2_type&,
            const Mass_type&,
            const InterParticleDistance_type&,
            const Sigma_type&,
            const Epsilon_type&);
 
  Membrane (const Pull_type&,
            const r0_type&,
            const k_type&,
            ::std::unique_ptr< Velocity_type >,
            ::std::unique_ptr< Position_type >,
            const N1_type&,
            const N2_type&,
            const Mass_type&,
            const InterParticleDistance_type&,
            const Sigma_type&,
            const Epsilon_type&);
 
  Membrane (const ::xercesc::DOMElement& e,
            ::xml_schema::flags f = 0,
            ::xml_schema::container* c = 0);
 
  Membrane (const Membrane& x,
            ::xml_schema::flags f = 0,
            ::xml_schema::container* c = 0);
 
  virtual Membrane*
  _clone (::xml_schema::flags f = 0,
          ::xml_schema::container* c = 0) const;
 
  Membrane&
  operator= (const Membrane& x);
 
 
  virtual 
  ~Membrane ();
 
  // Implementation.
  //
 
  //@cond
 
  protected:
  void
  parse (::xsd::cxx::xml::dom::parser< char >&,
         ::xml_schema::flags);
 
  protected:
  ::xsd::cxx::tree::one< Pull_type > Pull_;
  PullingActiveUntil_optional PullingActiveUntil_;
  PullingForce_optional PullingForce_;
  ::xsd::cxx::tree::one< r0_type > r0_;
  ::xsd::cxx::tree::one< k_type > k_;
  ::xsd::cxx::tree::one< Velocity_type > Velocity_;
  ::xsd::cxx::tree::one< Position_type > Position_;
  ::xsd::cxx::tree::one< N1_type > N1_;
  ::xsd::cxx::tree::one< N2_type > N2_;
  ::xsd::cxx::tree::one< Mass_type > Mass_;
  ::xsd::cxx::tree::one< InterParticleDistance_type > InterParticleDistance_;
  ::xsd::cxx::tree::one< Sigma_type > Sigma_;
  ::xsd::cxx::tree::one< Epsilon_type > Epsilon_;
 
  //@endcond
};
 
class Type: public ::xml_schema::string
{
  public:
 
  enum value
  {
    Default,
    Flow
  };
 
  Type (value v);
 
  Type (const char* v);
 
  Type (const ::std::string& v);
 
  Type (const ::xml_schema::string& v);
 
  Type (const ::xercesc::DOMElement& e,
        ::xml_schema::flags f = 0,
        ::xml_schema::container* c = 0);
 
  Type (const ::xercesc::DOMAttr& a,
        ::xml_schema::flags f = 0,
        ::xml_schema::container* c = 0);
 
  Type (const ::std::string& s,
        const ::xercesc::DOMElement* e,
        ::xml_schema::flags f = 0,
        ::xml_schema::container* c = 0);
 
  Type (const Type& x,
        ::xml_schema::flags f = 0,
        ::xml_schema::container* c = 0);
 
  virtual Type*
  _clone (::xml_schema::flags f = 0,
          ::xml_schema::container* c = 0) const;
 
  Type&
  operator= (value v);
 
  virtual
  operator value () const
  {
    return _xsd_Type_convert ();
  }
 
  //@cond
 
  protected:
  value
  _xsd_Type_convert () const;
 
  public:
  static const char* const _xsd_Type_literals_[2];
  static const value _xsd_Type_indexes_[2];
 
  //@endcond
};
 
class InitialTemperature: public ::xsd::cxx::tree::fundamental_base< ::xml_schema::double_, char, ::xml_schema::simple_type, ::xsd::cxx::tree::schema_type::double_ >
{
  public:
 
  InitialTemperature (const ::xml_schema::double_&);
 
  InitialTemperature (const ::xercesc::DOMElement& e,
                      ::xml_schema::flags f = 0,
                      ::xml_schema::container* c = 0);
 
  InitialTemperature (const ::xercesc::DOMAttr& a,
                      ::xml_schema::flags f = 0,
                      ::xml_schema::container* c = 0);
 
  InitialTemperature (const ::std::string& s,
                      const ::xercesc::DOMElement* e,
                      ::xml_schema::flags f = 0,
                      ::xml_schema::container* c = 0);
 
  InitialTemperature (const InitialTemperature& x,
                      ::xml_schema::flags f = 0,
                      ::xml_schema::container* c = 0);
 
  virtual InitialTemperature*
  _clone (::xml_schema::flags f = 0,
          ::xml_schema::container* c = 0) const;
 
 
  virtual 
  ~InitialTemperature ();
};
 
class TargetTemperature: public ::xsd::cxx::tree::fundamental_base< ::xml_schema::double_, char, ::xml_schema::simple_type, ::xsd::cxx::tree::schema_type::double_ >
{
  public:
 
  TargetTemperature (const ::xml_schema::double_&);
 
  TargetTemperature (const ::xercesc::DOMElement& e,
                     ::xml_schema::flags f = 0,
                     ::xml_schema::container* c = 0);
 
  TargetTemperature (const ::xercesc::DOMAttr& a,
                     ::xml_schema::flags f = 0,
                     ::xml_schema::container* c = 0);
 
  TargetTemperature (const ::std::string& s,
                     const ::xercesc::DOMElement* e,
                     ::xml_schema::flags f = 0,
                     ::xml_schema::container* c = 0);
 
  TargetTemperature (const TargetTemperature& x,
                     ::xml_schema::flags f = 0,
                     ::xml_schema::container* c = 0);
 
  virtual TargetTemperature*
  _clone (::xml_schema::flags f = 0,
          ::xml_schema::container* c = 0) const;
 
 
  virtual 
  ~TargetTemperature ();
};
 
class MaximumTemperatureChange: public ::xsd::cxx::tree::fundamental_base< ::xml_schema::double_, char, ::xml_schema::simple_type, ::xsd::cxx::tree::schema_type::double_ >
{
  public:
 
  MaximumTemperatureChange (const ::xml_schema::double_&);
 
  MaximumTemperatureChange (const ::xercesc::DOMElement& e,
                            ::xml_schema::flags f = 0,
                            ::xml_schema::container* c = 0);
 
  MaximumTemperatureChange (const ::xercesc::DOMAttr& a,
                            ::xml_schema::flags f = 0,
                            ::xml_schema::container* c = 0);
 
  MaximumTemperatureChange (const ::std::string& s,
                            const ::xercesc::DOMElement* e,
                            ::xml_schema::flags f = 0,
                            ::xml_schema::container* c = 0);
 
  MaximumTemperatureChange (const MaximumTemperatureChange& x,
                            ::xml_schema::flags f = 0,
                            ::xml_schema::container* c = 0);
 
  virtual MaximumTemperatureChange*
  _clone (::xml_schema::flags f = 0,
          ::xml_schema::container* c = 0) const;
 
 
  virtual 
  ~MaximumTemperatureChange ();
};
 
class ApplyAfterHowManySteps: public ::xsd::cxx::tree::fundamental_base< ::xml_schema::integer, char, ::xml_schema::simple_type >
{
  public:
 
  ApplyAfterHowManySteps (const ::xml_schema::integer&);
 
  ApplyAfterHowManySteps (const ::xercesc::DOMElement& e,
                          ::xml_schema::flags f = 0,
                          ::xml_schema::container* c = 0);
 
  ApplyAfterHowManySteps (const ::xercesc::DOMAttr& a,
                          ::xml_schema::flags f = 0,
                          ::xml_schema::container* c = 0);
 
  ApplyAfterHowManySteps (const ::std::string& s,
                          const ::xercesc::DOMElement* e,
                          ::xml_schema::flags f = 0,
                          ::xml_schema::container* c = 0);
 
  ApplyAfterHowManySteps (const ApplyAfterHowManySteps& x,
                          ::xml_schema::flags f = 0,
                          ::xml_schema::container* c = 0);
 
  virtual ApplyAfterHowManySteps*
  _clone (::xml_schema::flags f = 0,
          ::xml_schema::container* c = 0) const;
 
 
  virtual 
  ~ApplyAfterHowManySteps ();
};
 
class Dimension: public ::xsd::cxx::tree::fundamental_base< ::xml_schema::integer, char, ::xml_schema::simple_type >
{
  public:
 
  Dimension (const ::xml_schema::integer&);
 
  Dimension (const ::xercesc::DOMElement& e,
             ::xml_schema::flags f = 0,
             ::xml_schema::container* c = 0);
 
  Dimension (const ::xercesc::DOMAttr& a,
             ::xml_schema::flags f = 0,
             ::xml_schema::container* c = 0);
 
  Dimension (const ::std::string& s,
             const ::xercesc::DOMElement* e,
             ::xml_schema::flags f = 0,
             ::xml_schema::container* c = 0);
 
  Dimension (const Dimension& x,
             ::xml_schema::flags f = 0,
             ::xml_schema::container* c = 0);
 
  virtual Dimension*
  _clone (::xml_schema::flags f = 0,
          ::xml_schema::container* c = 0) const;
 
 
  virtual 
  ~Dimension ();
};
 
class Name: public ::xml_schema::string
{
  public:
 
  enum value
  {
    DirectSum,
    LinkedCells
  };
 
  Name (value v);
 
  Name (const char* v);
 
  Name (const ::std::string& v);
 
  Name (const ::xml_schema::string& v);
 
  Name (const ::xercesc::DOMElement& e,
        ::xml_schema::flags f = 0,
        ::xml_schema::container* c = 0);
 
  Name (const ::xercesc::DOMAttr& a,
        ::xml_schema::flags f = 0,
        ::xml_schema::container* c = 0);
 
  Name (const ::std::string& s,
        const ::xercesc::DOMElement* e,
        ::xml_schema::flags f = 0,
        ::xml_schema::container* c = 0);
 
  Name (const Name& x,
        ::xml_schema::flags f = 0,
        ::xml_schema::container* c = 0);
 
  virtual Name*
  _clone (::xml_schema::flags f = 0,
          ::xml_schema::container* c = 0) const;
 
  Name&
  operator= (value v);
 
  virtual
  operator value () const
  {
    return _xsd_Name_convert ();
  }
 
  //@cond
 
  protected:
  value
  _xsd_Name_convert () const;
 
  public:
  static const char* const _xsd_Name_literals_[2];
  static const value _xsd_Name_indexes_[2];
 
  //@endcond
};
 
class t_end: public ::xsd::cxx::tree::fundamental_base< ::xml_schema::double_, char, ::xml_schema::simple_type, ::xsd::cxx::tree::schema_type::double_ >
{
  public:
 
  t_end (const ::xml_schema::double_&);
 
  t_end (const ::xercesc::DOMElement& e,
         ::xml_schema::flags f = 0,
         ::xml_schema::container* c = 0);
 
  t_end (const ::xercesc::DOMAttr& a,
         ::xml_schema::flags f = 0,
         ::xml_schema::container* c = 0);
 
  t_end (const ::std::string& s,
         const ::xercesc::DOMElement* e,
         ::xml_schema::flags f = 0,
         ::xml_schema::container* c = 0);
 
  t_end (const t_end& x,
         ::xml_schema::flags f = 0,
         ::xml_schema::container* c = 0);
 
  virtual t_end*
  _clone (::xml_schema::flags f = 0,
          ::xml_schema::container* c = 0) const;
 
 
  virtual 
  ~t_end ();
};
 
class delta_t: public ::xsd::cxx::tree::fundamental_base< ::xml_schema::double_, char, ::xml_schema::simple_type, ::xsd::cxx::tree::schema_type::double_ >
{
  public:
 
  delta_t (const ::xml_schema::double_&);
 
  delta_t (const ::xercesc::DOMElement& e,
           ::xml_schema::flags f = 0,
           ::xml_schema::container* c = 0);
 
  delta_t (const ::xercesc::DOMAttr& a,
           ::xml_schema::flags f = 0,
           ::xml_schema::container* c = 0);
 
  delta_t (const ::std::string& s,
           const ::xercesc::DOMElement* e,
           ::xml_schema::flags f = 0,
           ::xml_schema::container* c = 0);
 
  delta_t (const delta_t& x,
           ::xml_schema::flags f = 0,
           ::xml_schema::container* c = 0);
 
  virtual delta_t*
  _clone (::xml_schema::flags f = 0,
          ::xml_schema::container* c = 0) const;
 
 
  virtual 
  ~delta_t ();
};
 
class force: public ::xml_schema::string
{
  public:
 
  enum value
  {
    Gravity,
    LennardJonesForce
  };
 
  force (value v);
 
  force (const char* v);
 
  force (const ::std::string& v);
 
  force (const ::xml_schema::string& v);
 
  force (const ::xercesc::DOMElement& e,
         ::xml_schema::flags f = 0,
         ::xml_schema::container* c = 0);
 
  force (const ::xercesc::DOMAttr& a,
         ::xml_schema::flags f = 0,
         ::xml_schema::container* c = 0);
 
  force (const ::std::string& s,
         const ::xercesc::DOMElement* e,
         ::xml_schema::flags f = 0,
         ::xml_schema::container* c = 0);
 
  force (const force& x,
         ::xml_schema::flags f = 0,
         ::xml_schema::container* c = 0);
 
  virtual force*
  _clone (::xml_schema::flags f = 0,
          ::xml_schema::container* c = 0) const;
 
  force&
  operator= (value v);
 
  virtual
  operator value () const
  {
    return _xsd_force_convert ();
  }
 
  //@cond
 
  protected:
  value
  _xsd_force_convert () const;
 
  public:
  static const char* const _xsd_force_literals_[2];
  static const value _xsd_force_indexes_[2];
 
  //@endcond
};
 
class DomainSize: public ::xml_schema::type
{
  public:
 
  typedef ::First First_type;
 
  typedef ::xsd::cxx::tree::traits< First_type, char > First_traits;
 
  const First_type&
  First () const;
 
  First_type&
  First ();
 
  void
  First (const First_type& x);
 
  void
  First (::std::unique_ptr< First_type > p);
 
 
 
  typedef ::Second Second_type;
 
  typedef ::xsd::cxx::tree::traits< Second_type, char > Second_traits;
 
  const Second_type&
  Second () const;
 
  Second_type&
  Second ();
 
  void
  Second (const Second_type& x);
 
  void
  Second (::std::unique_ptr< Second_type > p);
 
 
 
  typedef ::Third Third_type;
 
  typedef ::xsd::cxx::tree::traits< Third_type, char > Third_traits;
 
  const Third_type&
  Third () const;
 
  Third_type&
  Third ();
 
  void
  Third (const Third_type& x);
 
  void
  Third (::std::unique_ptr< Third_type > p);
 
 
 
  DomainSize (const First_type&,
              const Second_type&,
              const Third_type&);
 
  DomainSize (const ::xercesc::DOMElement& e,
              ::xml_schema::flags f = 0,
              ::xml_schema::container* c = 0);
 
  DomainSize (const DomainSize& x,
              ::xml_schema::flags f = 0,
              ::xml_schema::container* c = 0);
 
  virtual DomainSize*
  _clone (::xml_schema::flags f = 0,
          ::xml_schema::container* c = 0) const;
 
  DomainSize&
  operator= (const DomainSize& x);
 
 
  virtual 
  ~DomainSize ();
 
  // Implementation.
  //
 
  //@cond
 
  protected:
  void
  parse (::xsd::cxx::xml::dom::parser< char >&,
         ::xml_schema::flags);
 
  protected:
  ::xsd::cxx::tree::one< First_type > First_;
  ::xsd::cxx::tree::one< Second_type > Second_;
  ::xsd::cxx::tree::one< Third_type > Third_;
 
  //@endcond
};
 
class rCutOff: public ::xsd::cxx::tree::fundamental_base< ::xml_schema::double_, char, ::xml_schema::simple_type, ::xsd::cxx::tree::schema_type::double_ >
{
  public:
 
  rCutOff (const ::xml_schema::double_&);
 
  rCutOff (const ::xercesc::DOMElement& e,
           ::xml_schema::flags f = 0,
           ::xml_schema::container* c = 0);
 
  rCutOff (const ::xercesc::DOMAttr& a,
           ::xml_schema::flags f = 0,
           ::xml_schema::container* c = 0);
 
  rCutOff (const ::std::string& s,
           const ::xercesc::DOMElement* e,
           ::xml_schema::flags f = 0,
           ::xml_schema::container* c = 0);
 
  rCutOff (const rCutOff& x,
           ::xml_schema::flags f = 0,
           ::xml_schema::container* c = 0);
 
  virtual rCutOff*
  _clone (::xml_schema::flags f = 0,
          ::xml_schema::container* c = 0) const;
 
 
  virtual 
  ~rCutOff ();
};
 
class BoundaryCondition: public ::xml_schema::type
{
  public:
 
  typedef ::boundaries boundaries_type;
 
  typedef ::xsd::cxx::tree::traits< boundaries_type, char > boundaries_traits;
 
  const boundaries_type&
  boundaries () const;
 
  boundaries_type&
  boundaries ();
 
  void
  boundaries (const boundaries_type& x);
 
  void
  boundaries (::std::unique_ptr< boundaries_type > p);
 
 
 
  BoundaryCondition (const boundaries_type&);
 
  BoundaryCondition (::std::unique_ptr< boundaries_type >);
 
  BoundaryCondition (const ::xercesc::DOMElement& e,
                     ::xml_schema::flags f = 0,
                     ::xml_schema::container* c = 0);
 
  BoundaryCondition (const BoundaryCondition& x,
                     ::xml_schema::flags f = 0,
                     ::xml_schema::container* c = 0);
 
  virtual BoundaryCondition*
  _clone (::xml_schema::flags f = 0,
          ::xml_schema::container* c = 0) const;
 
  BoundaryCondition&
  operator= (const BoundaryCondition& x);
 
 
  virtual 
  ~BoundaryCondition ();
 
  // Implementation.
  //
 
  //@cond
 
  protected:
  void
  parse (::xsd::cxx::xml::dom::parser< char >&,
         ::xml_schema::flags);
 
  protected:
  ::xsd::cxx::tree::one< boundaries_type > boundaries_;
 
  //@endcond
};
 
class Size: public ::xsd::cxx::tree::fundamental_base< ::xml_schema::integer, char, ::xml_schema::simple_type >
{
  public:
 
  Size (const ::xml_schema::integer&);
 
  Size (const ::xercesc::DOMElement& e,
        ::xml_schema::flags f = 0,
        ::xml_schema::container* c = 0);
 
  Size (const ::xercesc::DOMAttr& a,
        ::xml_schema::flags f = 0,
        ::xml_schema::container* c = 0);
 
  Size (const ::std::string& s,
        const ::xercesc::DOMElement* e,
        ::xml_schema::flags f = 0,
        ::xml_schema::container* c = 0);
 
  Size (const Size& x,
        ::xml_schema::flags f = 0,
        ::xml_schema::container* c = 0);
 
  virtual Size*
  _clone (::xml_schema::flags f = 0,
          ::xml_schema::container* c = 0) const;
 
 
  virtual 
  ~Size ();
};
 
class SingleParticle: public ::xml_schema::type
{
  public:
 
  typedef ::Position Position_type;
 
  typedef ::xsd::cxx::tree::traits< Position_type, char > Position_traits;
 
  const Position_type&
  Position () const;
 
  Position_type&
  Position ();
 
  void
  Position (const Position_type& x);
 
  void
  Position (::std::unique_ptr< Position_type > p);
 
 
 
  typedef ::Velocity Velocity_type;
 
  typedef ::xsd::cxx::tree::traits< Velocity_type, char > Velocity_traits;
 
  const Velocity_type&
  Velocity () const;
 
  Velocity_type&
  Velocity ();
 
  void
  Velocity (const Velocity_type& x);
 
  void
  Velocity (::std::unique_ptr< Velocity_type > p);
 
 
 
  typedef ::Mass Mass_type;
 
  typedef ::xsd::cxx::tree::traits< Mass_type, char > Mass_traits;
 
  const Mass_type&
  Mass () const;
 
  Mass_type&
  Mass ();
 
  void
  Mass (const Mass_type& x);
 
  void
  Mass (::std::unique_ptr< Mass_type > p);
 
 
 
  typedef ::Sigma Sigma_type;
 
  typedef ::xsd::cxx::tree::optional< Sigma_type > Sigma_optional;
 
  typedef ::xsd::cxx::tree::traits< Sigma_type, char > Sigma_traits;
 
  const Sigma_optional&
  Sigma () const;
 
  Sigma_optional&
  Sigma ();
 
  void
  Sigma (const Sigma_type& x);
 
  void
  Sigma (const Sigma_optional& x);
 
  void
  Sigma (::std::unique_ptr< Sigma_type > p);
 
 
 
  typedef ::Epsilon Epsilon_type;
 
  typedef ::xsd::cxx::tree::optional< Epsilon_type > Epsilon_optional;
 
  typedef ::xsd::cxx::tree::traits< Epsilon_type, char > Epsilon_traits;
 
  const Epsilon_optional&
  Epsilon () const;
 
  Epsilon_optional&
  Epsilon ();
 
  void
  Epsilon (const Epsilon_type& x);
 
  void
  Epsilon (const Epsilon_optional& x);
 
  void
  Epsilon (::std::unique_ptr< Epsilon_type > p);
 
 
 
  SingleParticle (const Position_type&,
                  const Velocity_type&,
                  const Mass_type&);
 
  SingleParticle (::std::unique_ptr< Position_type >,
                  ::std::unique_ptr< Velocity_type >,
                  const Mass_type&);
 
  SingleParticle (const ::xercesc::DOMElement& e,
                  ::xml_schema::flags f = 0,
                  ::xml_schema::container* c = 0);
 
  SingleParticle (const SingleParticle& x,
                  ::xml_schema::flags f = 0,
                  ::xml_schema::container* c = 0);
 
  virtual SingleParticle*
  _clone (::xml_schema::flags f = 0,
          ::xml_schema::container* c = 0) const;
 
  SingleParticle&
  operator= (const SingleParticle& x);
 
 
  virtual 
  ~SingleParticle ();
 
  // Implementation.
  //
 
  //@cond
 
  protected:
  void
  parse (::xsd::cxx::xml::dom::parser< char >&,
         ::xml_schema::flags);
 
  protected:
  ::xsd::cxx::tree::one< Position_type > Position_;
  ::xsd::cxx::tree::one< Velocity_type > Velocity_;
  ::xsd::cxx::tree::one< Mass_type > Mass_;
  Sigma_optional Sigma_;
  Epsilon_optional Epsilon_;
 
  //@endcond
};
 
class Cuboid: public ::xml_schema::type
{
  public:
 
  typedef ::Position Position_type;
 
  typedef ::xsd::cxx::tree::traits< Position_type, char > Position_traits;
 
  const Position_type&
  Position () const;
 
  Position_type&
  Position ();
 
  void
  Position (const Position_type& x);
 
  void
  Position (::std::unique_ptr< Position_type > p);
 
 
 
  typedef ::Velocity Velocity_type;
 
  typedef ::xsd::cxx::tree::traits< Velocity_type, char > Velocity_traits;
 
  const Velocity_type&
  Velocity () const;
 
  Velocity_type&
  Velocity ();
 
  void
  Velocity (const Velocity_type& x);
 
  void
  Velocity (::std::unique_ptr< Velocity_type > p);
 
 
 
  typedef ::N11 N1_type;
 
  typedef ::xsd::cxx::tree::traits< N1_type, char > N1_traits;
 
  const N1_type&
  N1 () const;
 
  N1_type&
  N1 ();
 
  void
  N1 (const N1_type& x);
 
  void
  N1 (::std::unique_ptr< N1_type > p);
 
 
 
  typedef ::N21 N2_type;
 
  typedef ::xsd::cxx::tree::traits< N2_type, char > N2_traits;
 
  const N2_type&
  N2 () const;
 
  N2_type&
  N2 ();
 
  void
  N2 (const N2_type& x);
 
  void
  N2 (::std::unique_ptr< N2_type > p);
 
 
 
  typedef ::N3 N3_type;
 
  typedef ::xsd::cxx::tree::traits< N3_type, char > N3_traits;
 
  const N3_type&
  N3 () const;
 
  N3_type&
  N3 ();
 
  void
  N3 (const N3_type& x);
 
  void
  N3 (::std::unique_ptr< N3_type > p);
 
 
 
  typedef ::Distance Distance_type;
 
  typedef ::xsd::cxx::tree::traits< Distance_type, char > Distance_traits;
 
  const Distance_type&
  Distance () const;
 
  Distance_type&
  Distance ();
 
  void
  Distance (const Distance_type& x);
 
  void
  Distance (::std::unique_ptr< Distance_type > p);
 
 
 
  typedef ::Mass Mass_type;
 
  typedef ::xsd::cxx::tree::traits< Mass_type, char > Mass_traits;
 
  const Mass_type&
  Mass () const;
 
  Mass_type&
  Mass ();
 
  void
  Mass (const Mass_type& x);
 
  void
  Mass (::std::unique_ptr< Mass_type > p);
 
 
 
  typedef ::Brownian Brownian_type;
 
  typedef ::xsd::cxx::tree::traits< Brownian_type, char > Brownian_traits;
 
  const Brownian_type&
  Brownian () const;
 
  Brownian_type&
  Brownian ();
 
  void
  Brownian (const Brownian_type& x);
 
  void
  Brownian (::std::unique_ptr< Brownian_type > p);
 
 
 
  typedef ::DimensionBrownian DimensionBrownian_type;
 
  typedef ::xsd::cxx::tree::traits< DimensionBrownian_type, char > DimensionBrownian_traits;
 
  const DimensionBrownian_type&
  DimensionBrownian () const;
 
  DimensionBrownian_type&
  DimensionBrownian ();
 
  void
  DimensionBrownian (const DimensionBrownian_type& x);
 
  void
  DimensionBrownian (::std::unique_ptr< DimensionBrownian_type > p);
 
 
 
  typedef ::Sigma Sigma_type;
 
  typedef ::xsd::cxx::tree::optional< Sigma_type > Sigma_optional;
 
  typedef ::xsd::cxx::tree::traits< Sigma_type, char > Sigma_traits;
 
  const Sigma_optional&
  Sigma () const;
 
  Sigma_optional&
  Sigma ();
 
  void
  Sigma (const Sigma_type& x);
 
  void
  Sigma (const Sigma_optional& x);
 
  void
  Sigma (::std::unique_ptr< Sigma_type > p);
 
 
 
  typedef ::Epsilon Epsilon_type;
 
  typedef ::xsd::cxx::tree::optional< Epsilon_type > Epsilon_optional;
 
  typedef ::xsd::cxx::tree::traits< Epsilon_type, char > Epsilon_traits;
 
  const Epsilon_optional&
  Epsilon () const;
 
  Epsilon_optional&
  Epsilon ();
 
  void
  Epsilon (const Epsilon_type& x);
 
  void
  Epsilon (const Epsilon_optional& x);
 
  void
  Epsilon (::std::unique_ptr< Epsilon_type > p);
 
 
 
  typedef ::xml_schema::boolean Fixed_type;
 
  typedef ::xsd::cxx::tree::optional< Fixed_type > Fixed_optional;
 
  typedef ::xsd::cxx::tree::traits< Fixed_type, char > Fixed_traits;
 
  const Fixed_optional&
  Fixed () const;
 
  Fixed_optional&
  Fixed ();
 
  void
  Fixed (const Fixed_type& x);
 
  void
  Fixed (const Fixed_optional& x);
 
 
 
  Cuboid (const Position_type&,
          const Velocity_type&,
          const N1_type&,
          const N2_type&,
          const N3_type&,
          const Distance_type&,
          const Mass_type&,
          const Brownian_type&,
          const DimensionBrownian_type&);
 
  Cuboid (::std::unique_ptr< Position_type >,
          ::std::unique_ptr< Velocity_type >,
          const N1_type&,
          const N2_type&,
          const N3_type&,
          const Distance_type&,
          const Mass_type&,
          const Brownian_type&,
          const DimensionBrownian_type&);
 
  Cuboid (const ::xercesc::DOMElement& e,
          ::xml_schema::flags f = 0,
          ::xml_schema::container* c = 0);
 
  Cuboid (const Cuboid& x,
          ::xml_schema::flags f = 0,
          ::xml_schema::container* c = 0);
 
  virtual Cuboid*
  _clone (::xml_schema::flags f = 0,
          ::xml_schema::container* c = 0) const;
 
  Cuboid&
  operator= (const Cuboid& x);
 
 
  virtual 
  ~Cuboid ();
 
  // Implementation.
  //
 
  //@cond
 
  protected:
  void
  parse (::xsd::cxx::xml::dom::parser< char >&,
         ::xml_schema::flags);
 
  protected:
  ::xsd::cxx::tree::one< Position_type > Position_;
  ::xsd::cxx::tree::one< Velocity_type > Velocity_;
  ::xsd::cxx::tree::one< N1_type > N1_;
  ::xsd::cxx::tree::one< N2_type > N2_;
  ::xsd::cxx::tree::one< N3_type > N3_;
  ::xsd::cxx::tree::one< Distance_type > Distance_;
  ::xsd::cxx::tree::one< Mass_type > Mass_;
  ::xsd::cxx::tree::one< Brownian_type > Brownian_;
  ::xsd::cxx::tree::one< DimensionBrownian_type > DimensionBrownian_;
  Sigma_optional Sigma_;
  Epsilon_optional Epsilon_;
  Fixed_optional Fixed_;
 
  //@endcond
};
 
class Disc: public ::xml_schema::type
{
  public:
 
  typedef ::Center Center_type;
 
  typedef ::xsd::cxx::tree::traits< Center_type, char > Center_traits;
 
  const Center_type&
  Center () const;
 
  Center_type&
  Center ();
 
  void
  Center (const Center_type& x);
 
  void
  Center (::std::unique_ptr< Center_type > p);
 
 
 
  typedef ::Mass Mass_type;
 
  typedef ::xsd::cxx::tree::traits< Mass_type, char > Mass_traits;
 
  const Mass_type&
  Mass () const;
 
  Mass_type&
  Mass ();
 
  void
  Mass (const Mass_type& x);
 
  void
  Mass (::std::unique_ptr< Mass_type > p);
 
 
 
  typedef ::InterParticleDistance InterParticleDistance_type;
 
  typedef ::xsd::cxx::tree::traits< InterParticleDistance_type, char > InterParticleDistance_traits;
 
  const InterParticleDistance_type&
  InterParticleDistance () const;
 
  InterParticleDistance_type&
  InterParticleDistance ();
 
  void
  InterParticleDistance (const InterParticleDistance_type& x);
 
  void
  InterParticleDistance (::std::unique_ptr< InterParticleDistance_type > p);
 
 
 
  typedef ::Velocity Velocity_type;
 
  typedef ::xsd::cxx::tree::traits< Velocity_type, char > Velocity_traits;
 
  const Velocity_type&
  Velocity () const;
 
  Velocity_type&
  Velocity ();
 
  void
  Velocity (const Velocity_type& x);
 
  void
  Velocity (::std::unique_ptr< Velocity_type > p);
 
 
 
  typedef ::xml_schema::decimal Radius_type;
 
  typedef ::xsd::cxx::tree::traits< Radius_type, char, ::xsd::cxx::tree::schema_type::decimal > Radius_traits;
 
  const Radius_type&
  Radius () const;
 
  Radius_type&
  Radius ();
 
  void
  Radius (const Radius_type& x);
 
 
 
  typedef ::xml_schema::decimal Brownian_type;
 
  typedef ::xsd::cxx::tree::traits< Brownian_type, char, ::xsd::cxx::tree::schema_type::decimal > Brownian_traits;
 
  const Brownian_type&
  Brownian () const;
 
  Brownian_type&
  Brownian ();
 
  void
  Brownian (const Brownian_type& x);
 
 
 
  typedef ::xml_schema::unsigned_byte DimensionBrownian_type;
 
  typedef ::xsd::cxx::tree::traits< DimensionBrownian_type, char > DimensionBrownian_traits;
 
  const DimensionBrownian_type&
  DimensionBrownian () const;
 
  DimensionBrownian_type&
  DimensionBrownian ();
 
  void
  DimensionBrownian (const DimensionBrownian_type& x);
 
 
 
  typedef ::Sigma Sigma_type;
 
  typedef ::xsd::cxx::tree::optional< Sigma_type > Sigma_optional;
 
  typedef ::xsd::cxx::tree::traits< Sigma_type, char > Sigma_traits;
 
  const Sigma_optional&
  Sigma () const;
 
  Sigma_optional&
  Sigma ();
 
  void
  Sigma (const Sigma_type& x);
 
  void
  Sigma (const Sigma_optional& x);
 
  void
  Sigma (::std::unique_ptr< Sigma_type > p);
 
 
 
  typedef ::Epsilon Epsilon_type;
 
  typedef ::xsd::cxx::tree::optional< Epsilon_type > Epsilon_optional;
 
  typedef ::xsd::cxx::tree::traits< Epsilon_type, char > Epsilon_traits;
 
  const Epsilon_optional&
  Epsilon () const;
 
  Epsilon_optional&
  Epsilon ();
 
  void
  Epsilon (const Epsilon_type& x);
 
  void
  Epsilon (const Epsilon_optional& x);
 
  void
  Epsilon (::std::unique_ptr< Epsilon_type > p);
 
 
 
  typedef ::xml_schema::boolean Fixed_type;
 
  typedef ::xsd::cxx::tree::optional< Fixed_type > Fixed_optional;
 
  typedef ::xsd::cxx::tree::traits< Fixed_type, char > Fixed_traits;
 
  const Fixed_optional&
  Fixed () const;
 
  Fixed_optional&
  Fixed ();
 
  void
  Fixed (const Fixed_type& x);
 
  void
  Fixed (const Fixed_optional& x);
 
 
 
  Disc (const Center_type&,
        const Mass_type&,
        const InterParticleDistance_type&,
        const Velocity_type&,
        const Radius_type&,
        const Brownian_type&,
        const DimensionBrownian_type&);
 
  Disc (::std::unique_ptr< Center_type >,
        const Mass_type&,
        const InterParticleDistance_type&,
        ::std::unique_ptr< Velocity_type >,
        const Radius_type&,
        const Brownian_type&,
        const DimensionBrownian_type&);
 
  Disc (const ::xercesc::DOMElement& e,
        ::xml_schema::flags f = 0,
        ::xml_schema::container* c = 0);
 
  Disc (const Disc& x,
        ::xml_schema::flags f = 0,
        ::xml_schema::container* c = 0);
 
  virtual Disc*
  _clone (::xml_schema::flags f = 0,
          ::xml_schema::container* c = 0) const;
 
  Disc&
  operator= (const Disc& x);
 
 
  virtual 
  ~Disc ();
 
  // Implementation.
  //
 
  //@cond
 
  protected:
  void
  parse (::xsd::cxx::xml::dom::parser< char >&,
         ::xml_schema::flags);
 
  protected:
  ::xsd::cxx::tree::one< Center_type > Center_;
  ::xsd::cxx::tree::one< Mass_type > Mass_;
  ::xsd::cxx::tree::one< InterParticleDistance_type > InterParticleDistance_;
  ::xsd::cxx::tree::one< Velocity_type > Velocity_;
  ::xsd::cxx::tree::one< Radius_type > Radius_;
  ::xsd::cxx::tree::one< Brownian_type > Brownian_;
  ::xsd::cxx::tree::one< DimensionBrownian_type > DimensionBrownian_;
  Sigma_optional Sigma_;
  Epsilon_optional Epsilon_;
  Fixed_optional Fixed_;
 
  //@endcond
};
 
class Sphere: public ::xml_schema::type
{
  public:
 
  typedef ::Center Center_type;
 
  typedef ::xsd::cxx::tree::traits< Center_type, char > Center_traits;
 
  const Center_type&
  Center () const;
 
  Center_type&
  Center ();
 
  void
  Center (const Center_type& x);
 
  void
  Center (::std::unique_ptr< Center_type > p);
 
 
 
  typedef ::Mass Mass_type;
 
  typedef ::xsd::cxx::tree::traits< Mass_type, char > Mass_traits;
 
  const Mass_type&
  Mass () const;
 
  Mass_type&
  Mass ();
 
  void
  Mass (const Mass_type& x);
 
  void
  Mass (::std::unique_ptr< Mass_type > p);
 
 
 
  typedef ::InterParticleDistance InterParticleDistance_type;
 
  typedef ::xsd::cxx::tree::traits< InterParticleDistance_type, char > InterParticleDistance_traits;
 
  const InterParticleDistance_type&
  InterParticleDistance () const;
 
  InterParticleDistance_type&
  InterParticleDistance ();
 
  void
  InterParticleDistance (const InterParticleDistance_type& x);
 
  void
  InterParticleDistance (::std::unique_ptr< InterParticleDistance_type > p);
 
 
 
  typedef ::Velocity Velocity_type;
 
  typedef ::xsd::cxx::tree::traits< Velocity_type, char > Velocity_traits;
 
  const Velocity_type&
  Velocity () const;
 
  Velocity_type&
  Velocity ();
 
  void
  Velocity (const Velocity_type& x);
 
  void
  Velocity (::std::unique_ptr< Velocity_type > p);
 
 
 
  typedef ::xml_schema::decimal Radius_type;
 
  typedef ::xsd::cxx::tree::traits< Radius_type, char, ::xsd::cxx::tree::schema_type::decimal > Radius_traits;
 
  const Radius_type&
  Radius () const;
 
  Radius_type&
  Radius ();
 
  void
  Radius (const Radius_type& x);
 
 
 
  typedef ::xml_schema::decimal Brownian_type;
 
  typedef ::xsd::cxx::tree::traits< Brownian_type, char, ::xsd::cxx::tree::schema_type::decimal > Brownian_traits;
 
  const Brownian_type&
  Brownian () const;
 
  Brownian_type&
  Brownian ();
 
  void
  Brownian (const Brownian_type& x);
 
 
 
  typedef ::xml_schema::unsigned_byte DimensionBrownian_type;
 
  typedef ::xsd::cxx::tree::traits< DimensionBrownian_type, char > DimensionBrownian_traits;
 
  const DimensionBrownian_type&
  DimensionBrownian () const;
 
  DimensionBrownian_type&
  DimensionBrownian ();
 
  void
  DimensionBrownian (const DimensionBrownian_type& x);
 
 
 
  typedef ::Sigma Sigma_type;
 
  typedef ::xsd::cxx::tree::optional< Sigma_type > Sigma_optional;
 
  typedef ::xsd::cxx::tree::traits< Sigma_type, char > Sigma_traits;
 
  const Sigma_optional&
  Sigma () const;
 
  Sigma_optional&
  Sigma ();
 
  void
  Sigma (const Sigma_type& x);
 
  void
  Sigma (const Sigma_optional& x);
 
  void
  Sigma (::std::unique_ptr< Sigma_type > p);
 
 
 
  typedef ::Epsilon Epsilon_type;
 
  typedef ::xsd::cxx::tree::optional< Epsilon_type > Epsilon_optional;
 
  typedef ::xsd::cxx::tree::traits< Epsilon_type, char > Epsilon_traits;
 
  const Epsilon_optional&
  Epsilon () const;
 
  Epsilon_optional&
  Epsilon ();
 
  void
  Epsilon (const Epsilon_type& x);
 
  void
  Epsilon (const Epsilon_optional& x);
 
  void
  Epsilon (::std::unique_ptr< Epsilon_type > p);
 
 
 
  typedef ::xml_schema::boolean Fixed_type;
 
  typedef ::xsd::cxx::tree::optional< Fixed_type > Fixed_optional;
 
  typedef ::xsd::cxx::tree::traits< Fixed_type, char > Fixed_traits;
 
  const Fixed_optional&
  Fixed () const;
 
  Fixed_optional&
  Fixed ();
 
  void
  Fixed (const Fixed_type& x);
 
  void
  Fixed (const Fixed_optional& x);
 
 
 
  Sphere (const Center_type&,
          const Mass_type&,
          const InterParticleDistance_type&,
          const Velocity_type&,
          const Radius_type&,
          const Brownian_type&,
          const DimensionBrownian_type&);
 
  Sphere (::std::unique_ptr< Center_type >,
          const Mass_type&,
          const InterParticleDistance_type&,
          ::std::unique_ptr< Velocity_type >,
          const Radius_type&,
          const Brownian_type&,
          const DimensionBrownian_type&);
 
  Sphere (const ::xercesc::DOMElement& e,
          ::xml_schema::flags f = 0,
          ::xml_schema::container* c = 0);
 
  Sphere (const Sphere& x,
          ::xml_schema::flags f = 0,
          ::xml_schema::container* c = 0);
 
  virtual Sphere*
  _clone (::xml_schema::flags f = 0,
          ::xml_schema::container* c = 0) const;
 
  Sphere&
  operator= (const Sphere& x);
 
 
  virtual 
  ~Sphere ();
 
  // Implementation.
  //
 
  //@cond
 
  protected:
  void
  parse (::xsd::cxx::xml::dom::parser< char >&,
         ::xml_schema::flags);
 
  protected:
  ::xsd::cxx::tree::one< Center_type > Center_;
  ::xsd::cxx::tree::one< Mass_type > Mass_;
  ::xsd::cxx::tree::one< InterParticleDistance_type > InterParticleDistance_;
  ::xsd::cxx::tree::one< Velocity_type > Velocity_;
  ::xsd::cxx::tree::one< Radius_type > Radius_;
  ::xsd::cxx::tree::one< Brownian_type > Brownian_;
  ::xsd::cxx::tree::one< DimensionBrownian_type > DimensionBrownian_;
  Sigma_optional Sigma_;
  Epsilon_optional Epsilon_;
  Fixed_optional Fixed_;
 
  //@endcond
};
 
class PullingActiveUntil: public ::xsd::cxx::tree::fundamental_base< ::xml_schema::int_, char, ::xml_schema::simple_type >
{
  public:
 
  PullingActiveUntil (const ::xml_schema::int_&);
 
  PullingActiveUntil (const ::xercesc::DOMElement& e,
                      ::xml_schema::flags f = 0,
                      ::xml_schema::container* c = 0);
 
  PullingActiveUntil (const ::xercesc::DOMAttr& a,
                      ::xml_schema::flags f = 0,
                      ::xml_schema::container* c = 0);
 
  PullingActiveUntil (const ::std::string& s,
                      const ::xercesc::DOMElement* e,
                      ::xml_schema::flags f = 0,
                      ::xml_schema::container* c = 0);
 
  PullingActiveUntil (const PullingActiveUntil& x,
                      ::xml_schema::flags f = 0,
                      ::xml_schema::container* c = 0);
 
  virtual PullingActiveUntil*
  _clone (::xml_schema::flags f = 0,
          ::xml_schema::container* c = 0) const;
 
 
  virtual 
  ~PullingActiveUntil ();
};
 
class PullingForce: public ::xml_schema::type
{
  public:
 
  typedef ::xml_schema::decimal X_type;
 
  typedef ::xsd::cxx::tree::traits< X_type, char, ::xsd::cxx::tree::schema_type::decimal > X_traits;
 
  const X_type&
  X () const;
 
  X_type&
  X ();
 
  void
  X (const X_type& x);
 
 
 
  typedef ::xml_schema::decimal Y_type;
 
  typedef ::xsd::cxx::tree::traits< Y_type, char, ::xsd::cxx::tree::schema_type::decimal > Y_traits;
 
  const Y_type&
  Y () const;
 
  Y_type&
  Y ();
 
  void
  Y (const Y_type& x);
 
 
 
  typedef ::xml_schema::decimal Z_type;
 
  typedef ::xsd::cxx::tree::traits< Z_type, char, ::xsd::cxx::tree::schema_type::decimal > Z_traits;
 
  const Z_type&
  Z () const;
 
  Z_type&
  Z ();
 
  void
  Z (const Z_type& x);
 
 
 
  PullingForce (const X_type&,
                const Y_type&,
                const Z_type&);
 
  PullingForce (const ::xercesc::DOMElement& e,
                ::xml_schema::flags f = 0,
                ::xml_schema::container* c = 0);
 
  PullingForce (const PullingForce& x,
                ::xml_schema::flags f = 0,
                ::xml_schema::container* c = 0);
 
  virtual PullingForce*
  _clone (::xml_schema::flags f = 0,
          ::xml_schema::container* c = 0) const;
 
  PullingForce&
  operator= (const PullingForce& x);
 
 
  virtual 
  ~PullingForce ();
 
  // Implementation.
  //
 
  //@cond
 
  protected:
  void
  parse (::xsd::cxx::xml::dom::parser< char >&,
         ::xml_schema::flags);
 
  protected:
  ::xsd::cxx::tree::one< X_type > X_;
  ::xsd::cxx::tree::one< Y_type > Y_;
  ::xsd::cxx::tree::one< Z_type > Z_;
 
  //@endcond
};
 
class Velocity: public ::xml_schema::type
{
  public:
 
  typedef ::xml_schema::decimal X_type;
 
  typedef ::xsd::cxx::tree::traits< X_type, char, ::xsd::cxx::tree::schema_type::decimal > X_traits;
 
  const X_type&
  X () const;
 
  X_type&
  X ();
 
  void
  X (const X_type& x);
 
 
 
  typedef ::xml_schema::decimal Y_type;
 
  typedef ::xsd::cxx::tree::traits< Y_type, char, ::xsd::cxx::tree::schema_type::decimal > Y_traits;
 
  const Y_type&
  Y () const;
 
  Y_type&
  Y ();
 
  void
  Y (const Y_type& x);
 
 
 
  typedef ::xml_schema::decimal Z_type;
 
  typedef ::xsd::cxx::tree::traits< Z_type, char, ::xsd::cxx::tree::schema_type::decimal > Z_traits;
 
  const Z_type&
  Z () const;
 
  Z_type&
  Z ();
 
  void
  Z (const Z_type& x);
 
 
 
  Velocity (const X_type&,
            const Y_type&,
            const Z_type&);
 
  Velocity (const ::xercesc::DOMElement& e,
            ::xml_schema::flags f = 0,
            ::xml_schema::container* c = 0);
 
  Velocity (const Velocity& x,
            ::xml_schema::flags f = 0,
            ::xml_schema::container* c = 0);
 
  virtual Velocity*
  _clone (::xml_schema::flags f = 0,
          ::xml_schema::container* c = 0) const;
 
  Velocity&
  operator= (const Velocity& x);
 
 
  virtual 
  ~Velocity ();
 
  // Implementation.
  //
 
  //@cond
 
  protected:
  void
  parse (::xsd::cxx::xml::dom::parser< char >&,
         ::xml_schema::flags);
 
  protected:
  ::xsd::cxx::tree::one< X_type > X_;
  ::xsd::cxx::tree::one< Y_type > Y_;
  ::xsd::cxx::tree::one< Z_type > Z_;
 
  //@endcond
};
 
class Position: public ::xml_schema::type
{
  public:
 
  typedef ::xml_schema::decimal X_type;
 
  typedef ::xsd::cxx::tree::traits< X_type, char, ::xsd::cxx::tree::schema_type::decimal > X_traits;
 
  const X_type&
  X () const;
 
  X_type&
  X ();
 
  void
  X (const X_type& x);
 
 
 
  typedef ::xml_schema::decimal Y_type;
 
  typedef ::xsd::cxx::tree::traits< Y_type, char, ::xsd::cxx::tree::schema_type::decimal > Y_traits;
 
  const Y_type&
  Y () const;
 
  Y_type&
  Y ();
 
  void
  Y (const Y_type& x);
 
 
 
  typedef ::xml_schema::decimal Z_type;
 
  typedef ::xsd::cxx::tree::traits< Z_type, char, ::xsd::cxx::tree::schema_type::decimal > Z_traits;
 
  const Z_type&
  Z () const;
 
  Z_type&
  Z ();
 
  void
  Z (const Z_type& x);
 
 
 
  Position (const X_type&,
            const Y_type&,
            const Z_type&);
 
  Position (const ::xercesc::DOMElement& e,
            ::xml_schema::flags f = 0,
            ::xml_schema::container* c = 0);
 
  Position (const Position& x,
            ::xml_schema::flags f = 0,
            ::xml_schema::container* c = 0);
 
  virtual Position*
  _clone (::xml_schema::flags f = 0,
          ::xml_schema::container* c = 0) const;
 
  Position&
  operator= (const Position& x);
 
 
  virtual 
  ~Position ();
 
  // Implementation.
  //
 
  //@cond
 
  protected:
  void
  parse (::xsd::cxx::xml::dom::parser< char >&,
         ::xml_schema::flags);
 
  protected:
  ::xsd::cxx::tree::one< X_type > X_;
  ::xsd::cxx::tree::one< Y_type > Y_;
  ::xsd::cxx::tree::one< Z_type > Z_;
 
  //@endcond
};
 
class N1: public ::xsd::cxx::tree::fundamental_base< ::xml_schema::unsigned_int, char, ::xml_schema::simple_type >
{
  public:
 
  N1 (const ::xml_schema::unsigned_int&);
 
  N1 (const ::xercesc::DOMElement& e,
      ::xml_schema::flags f = 0,
      ::xml_schema::container* c = 0);
 
  N1 (const ::xercesc::DOMAttr& a,
      ::xml_schema::flags f = 0,
      ::xml_schema::container* c = 0);
 
  N1 (const ::std::string& s,
      const ::xercesc::DOMElement* e,
      ::xml_schema::flags f = 0,
      ::xml_schema::container* c = 0);
 
  N1 (const N1& x,
      ::xml_schema::flags f = 0,
      ::xml_schema::container* c = 0);
 
  virtual N1*
  _clone (::xml_schema::flags f = 0,
          ::xml_schema::container* c = 0) const;
 
 
  virtual 
  ~N1 ();
};
 
class N2: public ::xsd::cxx::tree::fundamental_base< ::xml_schema::unsigned_int, char, ::xml_schema::simple_type >
{
  public:
 
  N2 (const ::xml_schema::unsigned_int&);
 
  N2 (const ::xercesc::DOMElement& e,
      ::xml_schema::flags f = 0,
      ::xml_schema::container* c = 0);
 
  N2 (const ::xercesc::DOMAttr& a,
      ::xml_schema::flags f = 0,
      ::xml_schema::container* c = 0);
 
  N2 (const ::std::string& s,
      const ::xercesc::DOMElement* e,
      ::xml_schema::flags f = 0,
      ::xml_schema::container* c = 0);
 
  N2 (const N2& x,
      ::xml_schema::flags f = 0,
      ::xml_schema::container* c = 0);
 
  virtual N2*
  _clone (::xml_schema::flags f = 0,
          ::xml_schema::container* c = 0) const;
 
 
  virtual 
  ~N2 ();
};
 
class Mass: public ::xsd::cxx::tree::fundamental_base< ::xml_schema::double_, char, ::xml_schema::simple_type, ::xsd::cxx::tree::schema_type::double_ >
{
  public:
 
  Mass (const ::xml_schema::double_&);
 
  Mass (const ::xercesc::DOMElement& e,
        ::xml_schema::flags f = 0,
        ::xml_schema::container* c = 0);
 
  Mass (const ::xercesc::DOMAttr& a,
        ::xml_schema::flags f = 0,
        ::xml_schema::container* c = 0);
 
  Mass (const ::std::string& s,
        const ::xercesc::DOMElement* e,
        ::xml_schema::flags f = 0,
        ::xml_schema::container* c = 0);
 
  Mass (const Mass& x,
        ::xml_schema::flags f = 0,
        ::xml_schema::container* c = 0);
 
  virtual Mass*
  _clone (::xml_schema::flags f = 0,
          ::xml_schema::container* c = 0) const;
 
 
  virtual 
  ~Mass ();
};
 
class InterParticleDistance: public ::xsd::cxx::tree::fundamental_base< ::xml_schema::double_, char, ::xml_schema::simple_type, ::xsd::cxx::tree::schema_type::double_ >
{
  public:
 
  InterParticleDistance (const ::xml_schema::double_&);
 
  InterParticleDistance (const ::xercesc::DOMElement& e,
                         ::xml_schema::flags f = 0,
                         ::xml_schema::container* c = 0);
 
  InterParticleDistance (const ::xercesc::DOMAttr& a,
                         ::xml_schema::flags f = 0,
                         ::xml_schema::container* c = 0);
 
  InterParticleDistance (const ::std::string& s,
                         const ::xercesc::DOMElement* e,
                         ::xml_schema::flags f = 0,
                         ::xml_schema::container* c = 0);
 
  InterParticleDistance (const InterParticleDistance& x,
                         ::xml_schema::flags f = 0,
                         ::xml_schema::container* c = 0);
 
  virtual InterParticleDistance*
  _clone (::xml_schema::flags f = 0,
          ::xml_schema::container* c = 0) const;
 
 
  virtual 
  ~InterParticleDistance ();
};
 
class Sigma: public ::xsd::cxx::tree::fundamental_base< ::xml_schema::double_, char, ::xml_schema::simple_type, ::xsd::cxx::tree::schema_type::double_ >
{
  public:
 
  Sigma (const ::xml_schema::double_&);
 
  Sigma (const ::xercesc::DOMElement& e,
         ::xml_schema::flags f = 0,
         ::xml_schema::container* c = 0);
 
  Sigma (const ::xercesc::DOMAttr& a,
         ::xml_schema::flags f = 0,
         ::xml_schema::container* c = 0);
 
  Sigma (const ::std::string& s,
         const ::xercesc::DOMElement* e,
         ::xml_schema::flags f = 0,
         ::xml_schema::container* c = 0);
 
  Sigma (const Sigma& x,
         ::xml_schema::flags f = 0,
         ::xml_schema::container* c = 0);
 
  virtual Sigma*
  _clone (::xml_schema::flags f = 0,
          ::xml_schema::container* c = 0) const;
 
 
  virtual 
  ~Sigma ();
};
 
class Epsilon: public ::xsd::cxx::tree::fundamental_base< ::xml_schema::double_, char, ::xml_schema::simple_type, ::xsd::cxx::tree::schema_type::double_ >
{
  public:
 
  Epsilon (const ::xml_schema::double_&);
 
  Epsilon (const ::xercesc::DOMElement& e,
           ::xml_schema::flags f = 0,
           ::xml_schema::container* c = 0);
 
  Epsilon (const ::xercesc::DOMAttr& a,
           ::xml_schema::flags f = 0,
           ::xml_schema::container* c = 0);
 
  Epsilon (const ::std::string& s,
           const ::xercesc::DOMElement* e,
           ::xml_schema::flags f = 0,
           ::xml_schema::container* c = 0);
 
  Epsilon (const Epsilon& x,
           ::xml_schema::flags f = 0,
           ::xml_schema::container* c = 0);
 
  virtual Epsilon*
  _clone (::xml_schema::flags f = 0,
          ::xml_schema::container* c = 0) const;
 
 
  virtual 
  ~Epsilon ();
};
 
class First: public ::xsd::cxx::tree::fundamental_base< ::xml_schema::double_, char, ::xml_schema::simple_type, ::xsd::cxx::tree::schema_type::double_ >
{
  public:
 
  First (const ::xml_schema::double_&);
 
  First (const ::xercesc::DOMElement& e,
         ::xml_schema::flags f = 0,
         ::xml_schema::container* c = 0);
 
  First (const ::xercesc::DOMAttr& a,
         ::xml_schema::flags f = 0,
         ::xml_schema::container* c = 0);
 
  First (const ::std::string& s,
         const ::xercesc::DOMElement* e,
         ::xml_schema::flags f = 0,
         ::xml_schema::container* c = 0);
 
  First (const First& x,
         ::xml_schema::flags f = 0,
         ::xml_schema::container* c = 0);
 
  virtual First*
  _clone (::xml_schema::flags f = 0,
          ::xml_schema::container* c = 0) const;
 
 
  virtual 
  ~First ();
};
 
class Second: public ::xsd::cxx::tree::fundamental_base< ::xml_schema::double_, char, ::xml_schema::simple_type, ::xsd::cxx::tree::schema_type::double_ >
{
  public:
 
  Second (const ::xml_schema::double_&);
 
  Second (const ::xercesc::DOMElement& e,
          ::xml_schema::flags f = 0,
          ::xml_schema::container* c = 0);
 
  Second (const ::xercesc::DOMAttr& a,
          ::xml_schema::flags f = 0,
          ::xml_schema::container* c = 0);
 
  Second (const ::std::string& s,
          const ::xercesc::DOMElement* e,
          ::xml_schema::flags f = 0,
          ::xml_schema::container* c = 0);
 
  Second (const Second& x,
          ::xml_schema::flags f = 0,
          ::xml_schema::container* c = 0);
 
  virtual Second*
  _clone (::xml_schema::flags f = 0,
          ::xml_schema::container* c = 0) const;
 
 
  virtual 
  ~Second ();
};
 
class Third: public ::xsd::cxx::tree::fundamental_base< ::xml_schema::double_, char, ::xml_schema::simple_type, ::xsd::cxx::tree::schema_type::double_ >
{
  public:
 
  Third (const ::xml_schema::double_&);
 
  Third (const ::xercesc::DOMElement& e,
         ::xml_schema::flags f = 0,
         ::xml_schema::container* c = 0);
 
  Third (const ::xercesc::DOMAttr& a,
         ::xml_schema::flags f = 0,
         ::xml_schema::container* c = 0);
 
  Third (const ::std::string& s,
         const ::xercesc::DOMElement* e,
         ::xml_schema::flags f = 0,
         ::xml_schema::container* c = 0);
 
  Third (const Third& x,
         ::xml_schema::flags f = 0,
         ::xml_schema::container* c = 0);
 
  virtual Third*
  _clone (::xml_schema::flags f = 0,
          ::xml_schema::container* c = 0) const;
 
 
  virtual 
  ~Third ();
};
 
class boundaries: public ::xml_schema::type
{
  public:
 
  typedef ::Front Front_type;
 
  typedef ::xsd::cxx::tree::traits< Front_type, char > Front_traits;
 
  const Front_type&
  Front () const;
 
  Front_type&
  Front ();
 
  void
  Front (const Front_type& x);
 
  void
  Front (::std::unique_ptr< Front_type > p);
 
 
 
  typedef ::Back Back_type;
 
  typedef ::xsd::cxx::tree::traits< Back_type, char > Back_traits;
 
  const Back_type&
  Back () const;
 
  Back_type&
  Back ();
 
  void
  Back (const Back_type& x);
 
  void
  Back (::std::unique_ptr< Back_type > p);
 
 
 
  typedef ::Left Left_type;
 
  typedef ::xsd::cxx::tree::traits< Left_type, char > Left_traits;
 
  const Left_type&
  Left () const;
 
  Left_type&
  Left ();
 
  void
  Left (const Left_type& x);
 
  void
  Left (::std::unique_ptr< Left_type > p);
 
 
 
  typedef ::Right Right_type;
 
  typedef ::xsd::cxx::tree::traits< Right_type, char > Right_traits;
 
  const Right_type&
  Right () const;
 
  Right_type&
  Right ();
 
  void
  Right (const Right_type& x);
 
  void
  Right (::std::unique_ptr< Right_type > p);
 
 
 
  typedef ::Top Top_type;
 
  typedef ::xsd::cxx::tree::traits< Top_type, char > Top_traits;
 
  const Top_type&
  Top () const;
 
  Top_type&
  Top ();
 
  void
  Top (const Top_type& x);
 
  void
  Top (::std::unique_ptr< Top_type > p);
 
 
 
  typedef ::Bottom Bottom_type;
 
  typedef ::xsd::cxx::tree::traits< Bottom_type, char > Bottom_traits;
 
  const Bottom_type&
  Bottom () const;
 
  Bottom_type&
  Bottom ();
 
  void
  Bottom (const Bottom_type& x);
 
  void
  Bottom (::std::unique_ptr< Bottom_type > p);
 
 
 
  boundaries (const Front_type&,
              const Back_type&,
              const Left_type&,
              const Right_type&,
              const Top_type&,
              const Bottom_type&);
 
  boundaries (const ::xercesc::DOMElement& e,
              ::xml_schema::flags f = 0,
              ::xml_schema::container* c = 0);
 
  boundaries (const boundaries& x,
              ::xml_schema::flags f = 0,
              ::xml_schema::container* c = 0);
 
  virtual boundaries*
  _clone (::xml_schema::flags f = 0,
          ::xml_schema::container* c = 0) const;
 
  boundaries&
  operator= (const boundaries& x);
 
 
  virtual 
  ~boundaries ();
 
  // Implementation.
  //
 
  //@cond
 
  protected:
  void
  parse (::xsd::cxx::xml::dom::parser< char >&,
         ::xml_schema::flags);
 
  protected:
  ::xsd::cxx::tree::one< Front_type > Front_;
  ::xsd::cxx::tree::one< Back_type > Back_;
  ::xsd::cxx::tree::one< Left_type > Left_;
  ::xsd::cxx::tree::one< Right_type > Right_;
  ::xsd::cxx::tree::one< Top_type > Top_;
  ::xsd::cxx::tree::one< Bottom_type > Bottom_;
 
  //@endcond
};
 
class N11: public ::xsd::cxx::tree::fundamental_base< ::xml_schema::integer, char, ::xml_schema::simple_type >
{
  public:
 
  N11 (const ::xml_schema::integer&);
 
  N11 (const ::xercesc::DOMElement& e,
       ::xml_schema::flags f = 0,
       ::xml_schema::container* c = 0);
 
  N11 (const ::xercesc::DOMAttr& a,
       ::xml_schema::flags f = 0,
       ::xml_schema::container* c = 0);
 
  N11 (const ::std::string& s,
       const ::xercesc::DOMElement* e,
       ::xml_schema::flags f = 0,
       ::xml_schema::container* c = 0);
 
  N11 (const N11& x,
       ::xml_schema::flags f = 0,
       ::xml_schema::container* c = 0);
 
  virtual N11*
  _clone (::xml_schema::flags f = 0,
          ::xml_schema::container* c = 0) const;
 
 
  virtual 
  ~N11 ();
};
 
class N21: public ::xsd::cxx::tree::fundamental_base< ::xml_schema::integer, char, ::xml_schema::simple_type >
{
  public:
 
  N21 (const ::xml_schema::integer&);
 
  N21 (const ::xercesc::DOMElement& e,
       ::xml_schema::flags f = 0,
       ::xml_schema::container* c = 0);
 
  N21 (const ::xercesc::DOMAttr& a,
       ::xml_schema::flags f = 0,
       ::xml_schema::container* c = 0);
 
  N21 (const ::std::string& s,
       const ::xercesc::DOMElement* e,
       ::xml_schema::flags f = 0,
       ::xml_schema::container* c = 0);
 
  N21 (const N21& x,
       ::xml_schema::flags f = 0,
       ::xml_schema::container* c = 0);
 
  virtual N21*
  _clone (::xml_schema::flags f = 0,
          ::xml_schema::container* c = 0) const;
 
 
  virtual 
  ~N21 ();
};
 
class N3: public ::xsd::cxx::tree::fundamental_base< ::xml_schema::integer, char, ::xml_schema::simple_type >
{
  public:
 
  N3 (const ::xml_schema::integer&);
 
  N3 (const ::xercesc::DOMElement& e,
      ::xml_schema::flags f = 0,
      ::xml_schema::container* c = 0);
 
  N3 (const ::xercesc::DOMAttr& a,
      ::xml_schema::flags f = 0,
      ::xml_schema::container* c = 0);
 
  N3 (const ::std::string& s,
      const ::xercesc::DOMElement* e,
      ::xml_schema::flags f = 0,
      ::xml_schema::container* c = 0);
 
  N3 (const N3& x,
      ::xml_schema::flags f = 0,
      ::xml_schema::container* c = 0);
 
  virtual N3*
  _clone (::xml_schema::flags f = 0,
          ::xml_schema::container* c = 0) const;
 
 
  virtual 
  ~N3 ();
};
 
class Distance: public ::xsd::cxx::tree::fundamental_base< ::xml_schema::double_, char, ::xml_schema::simple_type, ::xsd::cxx::tree::schema_type::double_ >
{
  public:
 
  Distance (const ::xml_schema::double_&);
 
  Distance (const ::xercesc::DOMElement& e,
            ::xml_schema::flags f = 0,
            ::xml_schema::container* c = 0);
 
  Distance (const ::xercesc::DOMAttr& a,
            ::xml_schema::flags f = 0,
            ::xml_schema::container* c = 0);
 
  Distance (const ::std::string& s,
            const ::xercesc::DOMElement* e,
            ::xml_schema::flags f = 0,
            ::xml_schema::container* c = 0);
 
  Distance (const Distance& x,
            ::xml_schema::flags f = 0,
            ::xml_schema::container* c = 0);
 
  virtual Distance*
  _clone (::xml_schema::flags f = 0,
          ::xml_schema::container* c = 0) const;
 
 
  virtual 
  ~Distance ();
};
 
class Brownian: public ::xsd::cxx::tree::fundamental_base< ::xml_schema::double_, char, ::xml_schema::simple_type, ::xsd::cxx::tree::schema_type::double_ >
{
  public:
 
  Brownian (const ::xml_schema::double_&);
 
  Brownian (const ::xercesc::DOMElement& e,
            ::xml_schema::flags f = 0,
            ::xml_schema::container* c = 0);
 
  Brownian (const ::xercesc::DOMAttr& a,
            ::xml_schema::flags f = 0,
            ::xml_schema::container* c = 0);
 
  Brownian (const ::std::string& s,
            const ::xercesc::DOMElement* e,
            ::xml_schema::flags f = 0,
            ::xml_schema::container* c = 0);
 
  Brownian (const Brownian& x,
            ::xml_schema::flags f = 0,
            ::xml_schema::container* c = 0);
 
  virtual Brownian*
  _clone (::xml_schema::flags f = 0,
          ::xml_schema::container* c = 0) const;
 
 
  virtual 
  ~Brownian ();
};
 
class DimensionBrownian: public ::xsd::cxx::tree::fundamental_base< ::xml_schema::integer, char, ::xml_schema::simple_type >
{
  public:
 
  DimensionBrownian (const ::xml_schema::integer&);
 
  DimensionBrownian (const ::xercesc::DOMElement& e,
                     ::xml_schema::flags f = 0,
                     ::xml_schema::container* c = 0);
 
  DimensionBrownian (const ::xercesc::DOMAttr& a,
                     ::xml_schema::flags f = 0,
                     ::xml_schema::container* c = 0);
 
  DimensionBrownian (const ::std::string& s,
                     const ::xercesc::DOMElement* e,
                     ::xml_schema::flags f = 0,
                     ::xml_schema::container* c = 0);
 
  DimensionBrownian (const DimensionBrownian& x,
                     ::xml_schema::flags f = 0,
                     ::xml_schema::container* c = 0);
 
  virtual DimensionBrownian*
  _clone (::xml_schema::flags f = 0,
          ::xml_schema::container* c = 0) const;
 
 
  virtual 
  ~DimensionBrownian ();
};
 
class Center: public ::xml_schema::type
{
  public:
 
  typedef ::xml_schema::decimal X_type;
 
  typedef ::xsd::cxx::tree::traits< X_type, char, ::xsd::cxx::tree::schema_type::decimal > X_traits;
 
  const X_type&
  X () const;
 
  X_type&
  X ();
 
  void
  X (const X_type& x);
 
 
 
  typedef ::xml_schema::decimal Y_type;
 
  typedef ::xsd::cxx::tree::traits< Y_type, char, ::xsd::cxx::tree::schema_type::decimal > Y_traits;
 
  const Y_type&
  Y () const;
 
  Y_type&
  Y ();
 
  void
  Y (const Y_type& x);
 
 
 
  typedef ::xml_schema::decimal Z_type;
 
  typedef ::xsd::cxx::tree::traits< Z_type, char, ::xsd::cxx::tree::schema_type::decimal > Z_traits;
 
  const Z_type&
  Z () const;
 
  Z_type&
  Z ();
 
  void
  Z (const Z_type& x);
 
 
 
  Center (const X_type&,
          const Y_type&,
          const Z_type&);
 
  Center (const ::xercesc::DOMElement& e,
          ::xml_schema::flags f = 0,
          ::xml_schema::container* c = 0);
 
  Center (const Center& x,
          ::xml_schema::flags f = 0,
          ::xml_schema::container* c = 0);
 
  virtual Center*
  _clone (::xml_schema::flags f = 0,
          ::xml_schema::container* c = 0) const;
 
  Center&
  operator= (const Center& x);
 
 
  virtual 
  ~Center ();
 
  // Implementation.
  //
 
  //@cond
 
  protected:
  void
  parse (::xsd::cxx::xml::dom::parser< char >&,
         ::xml_schema::flags);
 
  protected:
  ::xsd::cxx::tree::one< X_type > X_;
  ::xsd::cxx::tree::one< Y_type > Y_;
  ::xsd::cxx::tree::one< Z_type > Z_;
 
  //@endcond
};
 
class Front: public ::xml_schema::string
{
  public:
 
  enum value
  {
    Reflective,
    Outflow,
    Periodic
  };
 
  Front (value v);
 
  Front (const char* v);
 
  Front (const ::std::string& v);
 
  Front (const ::xml_schema::string& v);
 
  Front (const ::xercesc::DOMElement& e,
         ::xml_schema::flags f = 0,
         ::xml_schema::container* c = 0);
 
  Front (const ::xercesc::DOMAttr& a,
         ::xml_schema::flags f = 0,
         ::xml_schema::container* c = 0);
 
  Front (const ::std::string& s,
         const ::xercesc::DOMElement* e,
         ::xml_schema::flags f = 0,
         ::xml_schema::container* c = 0);
 
  Front (const Front& x,
         ::xml_schema::flags f = 0,
         ::xml_schema::container* c = 0);
 
  virtual Front*
  _clone (::xml_schema::flags f = 0,
          ::xml_schema::container* c = 0) const;
 
  Front&
  operator= (value v);
 
  virtual
  operator value () const
  {
    return _xsd_Front_convert ();
  }
 
  //@cond
 
  protected:
  value
  _xsd_Front_convert () const;
 
  public:
  static const char* const _xsd_Front_literals_[3];
  static const value _xsd_Front_indexes_[3];
 
  //@endcond
};
 
class Back: public ::xml_schema::string
{
  public:
 
  enum value
  {
    Reflective,
    Outflow,
    Periodic
  };
 
  Back (value v);
 
  Back (const char* v);
 
  Back (const ::std::string& v);
 
  Back (const ::xml_schema::string& v);
 
  Back (const ::xercesc::DOMElement& e,
        ::xml_schema::flags f = 0,
        ::xml_schema::container* c = 0);
 
  Back (const ::xercesc::DOMAttr& a,
        ::xml_schema::flags f = 0,
        ::xml_schema::container* c = 0);
 
  Back (const ::std::string& s,
        const ::xercesc::DOMElement* e,
        ::xml_schema::flags f = 0,
        ::xml_schema::container* c = 0);
 
  Back (const Back& x,
        ::xml_schema::flags f = 0,
        ::xml_schema::container* c = 0);
 
  virtual Back*
  _clone (::xml_schema::flags f = 0,
          ::xml_schema::container* c = 0) const;
 
  Back&
  operator= (value v);
 
  virtual
  operator value () const
  {
    return _xsd_Back_convert ();
  }
 
  //@cond
 
  protected:
  value
  _xsd_Back_convert () const;
 
  public:
  static const char* const _xsd_Back_literals_[3];
  static const value _xsd_Back_indexes_[3];
 
  //@endcond
};
 
class Left: public ::xml_schema::string
{
  public:
 
  enum value
  {
    Reflective,
    Outflow,
    Periodic
  };
 
  Left (value v);
 
  Left (const char* v);
 
  Left (const ::std::string& v);
 
  Left (const ::xml_schema::string& v);
 
  Left (const ::xercesc::DOMElement& e,
        ::xml_schema::flags f = 0,
        ::xml_schema::container* c = 0);
 
  Left (const ::xercesc::DOMAttr& a,
        ::xml_schema::flags f = 0,
        ::xml_schema::container* c = 0);
 
  Left (const ::std::string& s,
        const ::xercesc::DOMElement* e,
        ::xml_schema::flags f = 0,
        ::xml_schema::container* c = 0);
 
  Left (const Left& x,
        ::xml_schema::flags f = 0,
        ::xml_schema::container* c = 0);
 
  virtual Left*
  _clone (::xml_schema::flags f = 0,
          ::xml_schema::container* c = 0) const;
 
  Left&
  operator= (value v);
 
  virtual
  operator value () const
  {
    return _xsd_Left_convert ();
  }
 
  //@cond
 
  protected:
  value
  _xsd_Left_convert () const;
 
  public:
  static const char* const _xsd_Left_literals_[3];
  static const value _xsd_Left_indexes_[3];
 
  //@endcond
};
 
class Right: public ::xml_schema::string
{
  public:
 
  enum value
  {
    Reflective,
    Outflow,
    Periodic
  };
 
  Right (value v);
 
  Right (const char* v);
 
  Right (const ::std::string& v);
 
  Right (const ::xml_schema::string& v);
 
  Right (const ::xercesc::DOMElement& e,
         ::xml_schema::flags f = 0,
         ::xml_schema::container* c = 0);
 
  Right (const ::xercesc::DOMAttr& a,
         ::xml_schema::flags f = 0,
         ::xml_schema::container* c = 0);
 
  Right (const ::std::string& s,
         const ::xercesc::DOMElement* e,
         ::xml_schema::flags f = 0,
         ::xml_schema::container* c = 0);
 
  Right (const Right& x,
         ::xml_schema::flags f = 0,
         ::xml_schema::container* c = 0);
 
  virtual Right*
  _clone (::xml_schema::flags f = 0,
          ::xml_schema::container* c = 0) const;
 
  Right&
  operator= (value v);
 
  virtual
  operator value () const
  {
    return _xsd_Right_convert ();
  }
 
  //@cond
 
  protected:
  value
  _xsd_Right_convert () const;
 
  public:
  static const char* const _xsd_Right_literals_[3];
  static const value _xsd_Right_indexes_[3];
 
  //@endcond
};
 
class Top: public ::xml_schema::string
{
  public:
 
  enum value
  {
    Reflective,
    Outflow,
    Periodic
  };
 
  Top (value v);
 
  Top (const char* v);
 
  Top (const ::std::string& v);
 
  Top (const ::xml_schema::string& v);
 
  Top (const ::xercesc::DOMElement& e,
       ::xml_schema::flags f = 0,
       ::xml_schema::container* c = 0);
 
  Top (const ::xercesc::DOMAttr& a,
       ::xml_schema::flags f = 0,
       ::xml_schema::container* c = 0);
 
  Top (const ::std::string& s,
       const ::xercesc::DOMElement* e,
       ::xml_schema::flags f = 0,
       ::xml_schema::container* c = 0);
 
  Top (const Top& x,
       ::xml_schema::flags f = 0,
       ::xml_schema::container* c = 0);
 
  virtual Top*
  _clone (::xml_schema::flags f = 0,
          ::xml_schema::container* c = 0) const;
 
  Top&
  operator= (value v);
 
  virtual
  operator value () const
  {
    return _xsd_Top_convert ();
  }
 
  //@cond
 
  protected:
  value
  _xsd_Top_convert () const;
 
  public:
  static const char* const _xsd_Top_literals_[3];
  static const value _xsd_Top_indexes_[3];
 
  //@endcond
};
 
class Bottom: public ::xml_schema::string
{
  public:
 
  enum value
  {
    Reflective,
    Outflow,
    Periodic
  };
 
  Bottom (value v);
 
  Bottom (const char* v);
 
  Bottom (const ::std::string& v);
 
  Bottom (const ::xml_schema::string& v);
 
  Bottom (const ::xercesc::DOMElement& e,
          ::xml_schema::flags f = 0,
          ::xml_schema::container* c = 0);
 
  Bottom (const ::xercesc::DOMAttr& a,
          ::xml_schema::flags f = 0,
          ::xml_schema::container* c = 0);
 
  Bottom (const ::std::string& s,
          const ::xercesc::DOMElement* e,
          ::xml_schema::flags f = 0,
          ::xml_schema::container* c = 0);
 
  Bottom (const Bottom& x,
          ::xml_schema::flags f = 0,
          ::xml_schema::container* c = 0);
 
  virtual Bottom*
  _clone (::xml_schema::flags f = 0,
          ::xml_schema::container* c = 0) const;
 
  Bottom&
  operator= (value v);
 
  virtual
  operator value () const
  {
    return _xsd_Bottom_convert ();
  }
 
  //@cond
 
  protected:
  value
  _xsd_Bottom_convert () const;
 
  public:
  static const char* const _xsd_Bottom_literals_[3];
  static const value _xsd_Bottom_indexes_[3];
 
  //@endcond
};
 
#include <iosfwd>
 
#include <xercesc/sax/InputSource.hpp>
#include <xercesc/dom/DOMDocument.hpp>
#include <xercesc/dom/DOMErrorHandler.hpp>
 
 
::std::unique_ptr< ::Molecules >
Molecules_ (const ::std::string& uri,
            ::xml_schema::flags f = 0,
            const ::xml_schema::properties& p = ::xml_schema::properties ());
 
::std::unique_ptr< ::Molecules >
Molecules_ (const ::std::string& uri,
            ::xml_schema::error_handler& eh,
            ::xml_schema::flags f = 0,
            const ::xml_schema::properties& p = ::xml_schema::properties ());
 
::std::unique_ptr< ::Molecules >
Molecules_ (const ::std::string& uri,
            ::xercesc::DOMErrorHandler& eh,
            ::xml_schema::flags f = 0,
            const ::xml_schema::properties& p = ::xml_schema::properties ());
 
::std::unique_ptr< ::Molecules >
Molecules_ (::std::istream& is,
            ::xml_schema::flags f = 0,
            const ::xml_schema::properties& p = ::xml_schema::properties ());
 
::std::unique_ptr< ::Molecules >
Molecules_ (::std::istream& is,
            ::xml_schema::error_handler& eh,
            ::xml_schema::flags f = 0,
            const ::xml_schema::properties& p = ::xml_schema::properties ());
 
::std::unique_ptr< ::Molecules >
Molecules_ (::std::istream& is,
            ::xercesc::DOMErrorHandler& eh,
            ::xml_schema::flags f = 0,
            const ::xml_schema::properties& p = ::xml_schema::properties ());
 
::std::unique_ptr< ::Molecules >
Molecules_ (::std::istream& is,
            const ::std::string& id,
            ::xml_schema::flags f = 0,
            const ::xml_schema::properties& p = ::xml_schema::properties ());
 
::std::unique_ptr< ::Molecules >
Molecules_ (::std::istream& is,
            const ::std::string& id,
            ::xml_schema::error_handler& eh,
            ::xml_schema::flags f = 0,
            const ::xml_schema::properties& p = ::xml_schema::properties ());
 
::std::unique_ptr< ::Molecules >
Molecules_ (::std::istream& is,
            const ::std::string& id,
            ::xercesc::DOMErrorHandler& eh,
            ::xml_schema::flags f = 0,
            const ::xml_schema::properties& p = ::xml_schema::properties ());
 
::std::unique_ptr< ::Molecules >
Molecules_ (::xercesc::InputSource& is,
            ::xml_schema::flags f = 0,
            const ::xml_schema::properties& p = ::xml_schema::properties ());
 
::std::unique_ptr< ::Molecules >
Molecules_ (::xercesc::InputSource& is,
            ::xml_schema::error_handler& eh,
            ::xml_schema::flags f = 0,
            const ::xml_schema::properties& p = ::xml_schema::properties ());
 
::std::unique_ptr< ::Molecules >
Molecules_ (::xercesc::InputSource& is,
            ::xercesc::DOMErrorHandler& eh,
            ::xml_schema::flags f = 0,
            const ::xml_schema::properties& p = ::xml_schema::properties ());
 
::std::unique_ptr< ::Molecules >
Molecules_ (const ::xercesc::DOMDocument& d,
            ::xml_schema::flags f = 0,
            const ::xml_schema::properties& p = ::xml_schema::properties ());
 
::std::unique_ptr< ::Molecules >
Molecules_ (::xml_schema::dom::unique_ptr< ::xercesc::DOMDocument > d,
            ::xml_schema::flags f = 0,
            const ::xml_schema::properties& p = ::xml_schema::properties ());
 
 
#include <iosfwd>
 
#include <xercesc/dom/DOMDocument.hpp>
#include <xercesc/dom/DOMErrorHandler.hpp>
#include <xercesc/framework/XMLFormatter.hpp>
 
#include <xsd/cxx/xml/dom/auto-ptr.hxx>
 
 
void
Molecules_ (::std::ostream& os,
            const ::Molecules& x, 
            const ::xml_schema::namespace_infomap& m = ::xml_schema::namespace_infomap (),
            const ::std::string& e = "UTF-8",
            ::xml_schema::flags f = 0);
 
void
Molecules_ (::std::ostream& os,
            const ::Molecules& x, 
            ::xml_schema::error_handler& eh,
            const ::xml_schema::namespace_infomap& m = ::xml_schema::namespace_infomap (),
            const ::std::string& e = "UTF-8",
            ::xml_schema::flags f = 0);
 
void
Molecules_ (::std::ostream& os,
            const ::Molecules& x, 
            ::xercesc::DOMErrorHandler& eh,
            const ::xml_schema::namespace_infomap& m = ::xml_schema::namespace_infomap (),
            const ::std::string& e = "UTF-8",
            ::xml_schema::flags f = 0);
 
void
Molecules_ (::xercesc::XMLFormatTarget& ft,
            const ::Molecules& x, 
            const ::xml_schema::namespace_infomap& m = ::xml_schema::namespace_infomap (),
            const ::std::string& e = "UTF-8",
            ::xml_schema::flags f = 0);
 
void
Molecules_ (::xercesc::XMLFormatTarget& ft,
            const ::Molecules& x, 
            ::xml_schema::error_handler& eh,
            const ::xml_schema::namespace_infomap& m = ::xml_schema::namespace_infomap (),
            const ::std::string& e = "UTF-8",
            ::xml_schema::flags f = 0);
 
void
Molecules_ (::xercesc::XMLFormatTarget& ft,
            const ::Molecules& x, 
            ::xercesc::DOMErrorHandler& eh,
            const ::xml_schema::namespace_infomap& m = ::xml_schema::namespace_infomap (),
            const ::std::string& e = "UTF-8",
            ::xml_schema::flags f = 0);
 
void
Molecules_ (::xercesc::DOMDocument& d,
            const ::Molecules& x,
            ::xml_schema::flags f = 0);
 
::xml_schema::dom::unique_ptr< ::xercesc::DOMDocument >
Molecules_ (const ::Molecules& x, 
            const ::xml_schema::namespace_infomap& m = ::xml_schema::namespace_infomap (),
            ::xml_schema::flags f = 0);
 
 
void
operator<< (::xercesc::DOMElement&, const Molecules&);
 
void
operator<< (::xercesc::DOMElement&, const OutputFileName&);
 
void
operator<< (::xercesc::DOMAttr&, const OutputFileName&);
 
void
operator<< (::xml_schema::list_stream&,
            const OutputFileName&);
 
void
operator<< (::xercesc::DOMElement&, const OutputFrequency&);
 
void
operator<< (::xercesc::DOMAttr&, const OutputFrequency&);
 
void
operator<< (::xml_schema::list_stream&,
            const OutputFrequency&);
 
void
operator<< (::xercesc::DOMElement&, const ParallelizationStrategy&);
 
void
operator<< (::xercesc::DOMAttr&, const ParallelizationStrategy&);
 
void
operator<< (::xml_schema::list_stream&,
            const ParallelizationStrategy&);
 
void
operator<< (::xercesc::DOMElement&, const ThermostatConfig&);
 
void
operator<< (::xercesc::DOMElement&, const GravityConfig&);
 
void
operator<< (::xercesc::DOMElement&, const model&);
 
void
operator<< (::xercesc::DOMElement&, const SingleParticles&);
 
void
operator<< (::xercesc::DOMElement&, const Cuboids&);
 
void
operator<< (::xercesc::DOMElement&, const Discs&);
 
void
operator<< (::xercesc::DOMElement&, const Spheres&);
 
void
operator<< (::xercesc::DOMElement&, const Membrane&);
 
void
operator<< (::xercesc::DOMElement&, const Type&);
 
void
operator<< (::xercesc::DOMAttr&, const Type&);
 
void
operator<< (::xml_schema::list_stream&,
            const Type&);
 
void
operator<< (::xercesc::DOMElement&, const InitialTemperature&);
 
void
operator<< (::xercesc::DOMAttr&, const InitialTemperature&);
 
void
operator<< (::xml_schema::list_stream&,
            const InitialTemperature&);
 
void
operator<< (::xercesc::DOMElement&, const TargetTemperature&);
 
void
operator<< (::xercesc::DOMAttr&, const TargetTemperature&);
 
void
operator<< (::xml_schema::list_stream&,
            const TargetTemperature&);
 
void
operator<< (::xercesc::DOMElement&, const MaximumTemperatureChange&);
 
void
operator<< (::xercesc::DOMAttr&, const MaximumTemperatureChange&);
 
void
operator<< (::xml_schema::list_stream&,
            const MaximumTemperatureChange&);
 
void
operator<< (::xercesc::DOMElement&, const ApplyAfterHowManySteps&);
 
void
operator<< (::xercesc::DOMAttr&, const ApplyAfterHowManySteps&);
 
void
operator<< (::xml_schema::list_stream&,
            const ApplyAfterHowManySteps&);
 
void
operator<< (::xercesc::DOMElement&, const Dimension&);
 
void
operator<< (::xercesc::DOMAttr&, const Dimension&);
 
void
operator<< (::xml_schema::list_stream&,
            const Dimension&);
 
void
operator<< (::xercesc::DOMElement&, const Name&);
 
void
operator<< (::xercesc::DOMAttr&, const Name&);
 
void
operator<< (::xml_schema::list_stream&,
            const Name&);
 
void
operator<< (::xercesc::DOMElement&, const t_end&);
 
void
operator<< (::xercesc::DOMAttr&, const t_end&);
 
void
operator<< (::xml_schema::list_stream&,
            const t_end&);
 
void
operator<< (::xercesc::DOMElement&, const delta_t&);
 
void
operator<< (::xercesc::DOMAttr&, const delta_t&);
 
void
operator<< (::xml_schema::list_stream&,
            const delta_t&);
 
void
operator<< (::xercesc::DOMElement&, const force&);
 
void
operator<< (::xercesc::DOMAttr&, const force&);
 
void
operator<< (::xml_schema::list_stream&,
            const force&);
 
void
operator<< (::xercesc::DOMElement&, const DomainSize&);
 
void
operator<< (::xercesc::DOMElement&, const rCutOff&);
 
void
operator<< (::xercesc::DOMAttr&, const rCutOff&);
 
void
operator<< (::xml_schema::list_stream&,
            const rCutOff&);
 
void
operator<< (::xercesc::DOMElement&, const BoundaryCondition&);
 
void
operator<< (::xercesc::DOMElement&, const Size&);
 
void
operator<< (::xercesc::DOMAttr&, const Size&);
 
void
operator<< (::xml_schema::list_stream&,
            const Size&);
 
void
operator<< (::xercesc::DOMElement&, const SingleParticle&);
 
void
operator<< (::xercesc::DOMElement&, const Cuboid&);
 
void
operator<< (::xercesc::DOMElement&, const Disc&);
 
void
operator<< (::xercesc::DOMElement&, const Sphere&);
 
void
operator<< (::xercesc::DOMElement&, const PullingActiveUntil&);
 
void
operator<< (::xercesc::DOMAttr&, const PullingActiveUntil&);
 
void
operator<< (::xml_schema::list_stream&,
            const PullingActiveUntil&);
 
void
operator<< (::xercesc::DOMElement&, const PullingForce&);
 
void
operator<< (::xercesc::DOMElement&, const Velocity&);
 
void
operator<< (::xercesc::DOMElement&, const Position&);
 
void
operator<< (::xercesc::DOMElement&, const N1&);
 
void
operator<< (::xercesc::DOMAttr&, const N1&);
 
void
operator<< (::xml_schema::list_stream&,
            const N1&);
 
void
operator<< (::xercesc::DOMElement&, const N2&);
 
void
operator<< (::xercesc::DOMAttr&, const N2&);
 
void
operator<< (::xml_schema::list_stream&,
            const N2&);
 
void
operator<< (::xercesc::DOMElement&, const Mass&);
 
void
operator<< (::xercesc::DOMAttr&, const Mass&);
 
void
operator<< (::xml_schema::list_stream&,
            const Mass&);
 
void
operator<< (::xercesc::DOMElement&, const InterParticleDistance&);
 
void
operator<< (::xercesc::DOMAttr&, const InterParticleDistance&);
 
void
operator<< (::xml_schema::list_stream&,
            const InterParticleDistance&);
 
void
operator<< (::xercesc::DOMElement&, const Sigma&);
 
void
operator<< (::xercesc::DOMAttr&, const Sigma&);
 
void
operator<< (::xml_schema::list_stream&,
            const Sigma&);
 
void
operator<< (::xercesc::DOMElement&, const Epsilon&);
 
void
operator<< (::xercesc::DOMAttr&, const Epsilon&);
 
void
operator<< (::xml_schema::list_stream&,
            const Epsilon&);
 
void
operator<< (::xercesc::DOMElement&, const First&);
 
void
operator<< (::xercesc::DOMAttr&, const First&);
 
void
operator<< (::xml_schema::list_stream&,
            const First&);
 
void
operator<< (::xercesc::DOMElement&, const Second&);
 
void
operator<< (::xercesc::DOMAttr&, const Second&);
 
void
operator<< (::xml_schema::list_stream&,
            const Second&);
 
void
operator<< (::xercesc::DOMElement&, const Third&);
 
void
operator<< (::xercesc::DOMAttr&, const Third&);
 
void
operator<< (::xml_schema::list_stream&,
            const Third&);
 
void
operator<< (::xercesc::DOMElement&, const boundaries&);
 
void
operator<< (::xercesc::DOMElement&, const N11&);
 
void
operator<< (::xercesc::DOMAttr&, const N11&);
 
void
operator<< (::xml_schema::list_stream&,
            const N11&);
 
void
operator<< (::xercesc::DOMElement&, const N21&);
 
void
operator<< (::xercesc::DOMAttr&, const N21&);
 
void
operator<< (::xml_schema::list_stream&,
            const N21&);
 
void
operator<< (::xercesc::DOMElement&, const N3&);
 
void
operator<< (::xercesc::DOMAttr&, const N3&);
 
void
operator<< (::xml_schema::list_stream&,
            const N3&);
 
void
operator<< (::xercesc::DOMElement&, const Distance&);
 
void
operator<< (::xercesc::DOMAttr&, const Distance&);
 
void
operator<< (::xml_schema::list_stream&,
            const Distance&);
 
void
operator<< (::xercesc::DOMElement&, const Brownian&);
 
void
operator<< (::xercesc::DOMAttr&, const Brownian&);
 
void
operator<< (::xml_schema::list_stream&,
            const Brownian&);
 
void
operator<< (::xercesc::DOMElement&, const DimensionBrownian&);
 
void
operator<< (::xercesc::DOMAttr&, const DimensionBrownian&);
 
void
operator<< (::xml_schema::list_stream&,
            const DimensionBrownian&);
 
void
operator<< (::xercesc::DOMElement&, const Center&);
 
void
operator<< (::xercesc::DOMElement&, const Front&);
 
void
operator<< (::xercesc::DOMAttr&, const Front&);
 
void
operator<< (::xml_schema::list_stream&,
            const Front&);
 
void
operator<< (::xercesc::DOMElement&, const Back&);
 
void
operator<< (::xercesc::DOMAttr&, const Back&);
 
void
operator<< (::xml_schema::list_stream&,
            const Back&);
 
void
operator<< (::xercesc::DOMElement&, const Left&);
 
void
operator<< (::xercesc::DOMAttr&, const Left&);
 
void
operator<< (::xml_schema::list_stream&,
            const Left&);
 
void
operator<< (::xercesc::DOMElement&, const Right&);
 
void
operator<< (::xercesc::DOMAttr&, const Right&);
 
void
operator<< (::xml_schema::list_stream&,
            const Right&);
 
void
operator<< (::xercesc::DOMElement&, const Top&);
 
void
operator<< (::xercesc::DOMAttr&, const Top&);
 
void
operator<< (::xml_schema::list_stream&,
            const Top&);
 
void
operator<< (::xercesc::DOMElement&, const Bottom&);
 
void
operator<< (::xercesc::DOMAttr&, const Bottom&);
 
void
operator<< (::xml_schema::list_stream&,
            const Bottom&);
 
#include <xsd/cxx/post.hxx>
 
// Begin epilogue.
//
//
// End epilogue.
 
#endif // CONFIGURATION_FILE_H